/*************************************************************************/ /*!
|
@File
|
@Title Device Memory Management core internal
|
@Copyright Copyright (c) Imagination Technologies Ltd. All Rights Reserved
|
@Description Services internal interface to core device memory management
|
functions that are shared between client and server code.
|
@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 SRVCLIENT_DEVICEMEM_H
|
#define SRVCLIENT_DEVICEMEM_H
|
|
/********************************************************************************
|
* *
|
* +------------+ +------------+ +--------------+ +--------------+ *
|
* | a sub- | | a sub- | | an | | allocation | *
|
* | allocation | | allocation | | allocation | | also mapped | *
|
* | | | | | in proc 1 | | into proc 2 | *
|
* +------------+ +------------+ +--------------+ +--------------+ *
|
* | | | | *
|
* +--------------+ +--------------+ +--------------+ *
|
* | page gran- | | page gran- | | page gran- | *
|
* | ular mapping | | ular mapping | | ular mapping | *
|
* +--------------+ +--------------+ +--------------+ *
|
* | | | *
|
* | | | *
|
* | | | *
|
* +--------------+ +--------------+ *
|
* | | | | *
|
* | A "P.M.R." | | A "P.M.R." | *
|
* | | | | *
|
* +--------------+ +--------------+ *
|
* *
|
********************************************************************************/
|
|
/*
|
All device memory allocations are ultimately a view upon (not
|
necessarily the whole of) a "PMR".
|
|
A PMR is a "Physical Memory Resource", which may be a
|
"pre-faulted" lump of physical memory, or it may be a
|
representation of some physical memory that will be instantiated
|
at some future time.
|
|
PMRs always represent multiple of some power-of-2 "contiguity"
|
promised by the PMR, which will allow them to be mapped in whole
|
pages into the device MMU. As memory allocations may be smaller
|
than a page, these mappings may be suballocated and thus shared
|
between multiple allocations in one process. A PMR may also be
|
mapped simultaneously into multiple device memory contexts
|
(cross-process scenario), however, for security reasons, it is not
|
legal to share a PMR "both ways" at once, that is, mapped into
|
multiple processes and divided up amongst several suballocations.
|
|
This PMR terminology is introduced here for background
|
information, but is generally of little concern to the caller of
|
this API. This API handles suballocations and mappings, and the
|
caller thus deals primarily with MEMORY DESCRIPTORS representing
|
an allocation or suballocation, HEAPS representing ranges of
|
virtual addresses in a CONTEXT.
|
*/
|
|
/*
|
|<---------------------------context------------------------------>|
|
|<-------heap------->| |<-------heap------->|<-------heap------->|
|
|<-alloc->| | |<-alloc->|<-alloc->|| |<-alloc->| |
|
*/
|
|
#include "img_types.h"
|
#include "devicemem_typedefs.h"
|
#include "pdumpdefs.h"
|
#include "pvrsrv_error.h"
|
#include "pvrsrv_memallocflags.h"
|
|
#include "pdump.h"
|
|
#include "device_connection.h"
|
|
|
typedef IMG_UINT32 DEVMEM_HEAPCFGID;
|
#define DEVMEM_HEAPCFG_FORCLIENTS 0
|
#define DEVMEM_HEAPCFG_META 1
|
|
|
|
|
|
/*
|
In order to call the server side functions, we need a bridge handle.
|
We abstract that here, as we may wish to change its form.
|
*/
|
|
typedef IMG_HANDLE DEVMEM_BRIDGE_HANDLE;
|
|
/**************************************************************************/ /*!
|
@Function DevmemUnpin
|
@Description This is the counterpart to DevmemPin(). It is meant to be
|
called before repinning an allocation.
|
|
For a detailed description see client API documentation.
|
|
@Input phMemDesc The MemDesc that is going to be unpinned.
|
|
@Return PVRSRV_ERROR: PVRSRV_OK on success and the memory is
|
registered to be reclaimed. Error otherwise.
|
*/ /***************************************************************************/
|
IMG_INTERNAL PVRSRV_ERROR
|
DevmemUnpin(DEVMEM_MEMDESC *psMemDesc);
|
|
/**************************************************************************/ /*!
|
@Function DevmemPin
|
@Description This is the counterpart to DevmemUnpin(). It is meant to be
|
called after unpinning an allocation.
|
|
For a detailed description see client API documentation.
|
|
@Input phMemDesc The MemDesc that is going to be pinned.
|
|
@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.
|
*/ /***************************************************************************/
|
IMG_INTERNAL PVRSRV_ERROR
|
DevmemPin(DEVMEM_MEMDESC *psMemDesc);
|
|
IMG_INTERNAL PVRSRV_ERROR
|
DevmemGetHeapInt(DEVMEM_HEAP *psHeap,
|
IMG_HANDLE *phDevmemHeap);
|
|
IMG_INTERNAL PVRSRV_ERROR
|
DevmemGetSize(DEVMEM_MEMDESC *psMemDesc,
|
IMG_DEVMEM_SIZE_T* puiSize);
|
|
/*
|
* DevmemCreateContext()
|
*
|
* Create a device memory context
|
*
|
* This must be called before any heap is created in this context
|
*
|
* Caller to provide bridge handle which will be squirreled away
|
* internally and used for all future operations on items from this
|
* memory context. Caller also to provide devicenode handle, as this
|
* is used for MMU configuration and also to determine the heap
|
* configuration for the auto-instantiated heaps.
|
*
|
* Note that when compiled in services/server, the hBridge is not used
|
* and is thrown away by the "fake" direct bridge. (This may change.
|
* It is recommended that NULL be passed for the handle for now)
|
*
|
* hDeviceNode and uiHeapBlueprintID shall together dictate which
|
* heap-config to use.
|
*
|
* This will cause the server side counterpart to be created also.
|
*
|
* If you call DevmemCreateContext() (and the call succeeds) you
|
* are promising that you will later call Devmem_ContextDestroy(),
|
* except for abnormal process termination in which case it is
|
* expected it will be destroyed as part of handle clean up.
|
*
|
* Caller to provide storage for the pointer to the NEWDEVMEM_CONTEXT
|
* object thusly created.
|
*/
|
extern PVRSRV_ERROR
|
DevmemCreateContext(SHARED_DEV_CONNECTION hDevConnection,
|
DEVMEM_HEAPCFGID uiHeapBlueprintID,
|
DEVMEM_CONTEXT **ppsCtxPtr);
|
|
/*
|
* DevmemAcquireDevPrivData()
|
*
|
* Acquire the device private data for this memory context
|
*/
|
PVRSRV_ERROR
|
DevmemAcquireDevPrivData(DEVMEM_CONTEXT *psCtx,
|
IMG_HANDLE *hPrivData);
|
|
/*
|
* DevmemReleaseDevPrivData()
|
*
|
* Release the device private data for this memory context
|
*/
|
PVRSRV_ERROR
|
DevmemReleaseDevPrivData(DEVMEM_CONTEXT *psCtx);
|
|
/*
|
* DevmemDestroyContext()
|
*
|
* Undoes that done by DevmemCreateContext()
|
*/
|
extern PVRSRV_ERROR
|
DevmemDestroyContext(DEVMEM_CONTEXT *psCtx);
|
|
/*
|
* DevmemCreateHeap()
|
*
|
* Create a heap in the given context.
|
*
|
* N.B. Not intended to be called directly, though it can be.
|
* Normally, heaps are instantiated at context creation time according
|
* to the specified blueprint. See DevmemCreateContext() for details.
|
*
|
* This will cause MMU code to set up data structures for the heap,
|
* but may not cause page tables to be modified until allocations are
|
* made from the heap.
|
*
|
* The "Quantum" is both the device MMU page size to be configured for
|
* this heap, and the unit multiples of which "quantized" allocations
|
* are made (allocations smaller than this, known as "suballocations"
|
* will be made from a "sub alloc RA" and will "import" chunks
|
* according to this quantum)
|
*
|
* Where imported PMRs (or, for example, PMRs created by device class
|
* buffers) are mapped into this heap, it is important that the
|
* physical contiguity guarantee offered by the PMR is greater than or
|
* equal to the quantum size specified here, otherwise the attempt to
|
* map it will fail. "Normal" allocations via Devmem_Allocate
|
* shall automatically meet this requirement, as each "import" will
|
* trigger the creation of a PMR with the desired contiguity. The
|
* supported quantum sizes in that case shall be dictated by the OS
|
* specific implementation of PhysmemNewOSRamBackedPMR() (see)
|
*/
|
extern PVRSRV_ERROR
|
DevmemCreateHeap(DEVMEM_CONTEXT *psCtxPtr,
|
/* base and length of heap */
|
IMG_DEV_VIRTADDR sBaseAddress,
|
IMG_DEVMEM_SIZE_T uiLength,
|
/* log2 of allocation quantum, i.e. "page" size.
|
All allocations (that go to server side) are
|
multiples of this. We use a client-side RA to
|
make sub-allocations from this */
|
IMG_UINT32 ui32Log2Quantum,
|
/* The minimum import alignment for this heap */
|
IMG_UINT32 ui32Log2ImportAlignment,
|
/* (For tiling heaps) the factor to use to convert
|
alignment to optimum buffer stride */
|
IMG_UINT32 ui32Log2TilingStrideFactor,
|
/* Name of heap for debug */
|
/* N.B. Okay to exist on caller's stack - this
|
func takes a copy if it needs it. */
|
const IMG_CHAR *pszName,
|
DEVMEM_HEAPCFGID uiHeapBlueprintID,
|
DEVMEM_HEAP **ppsHeapPtr);
|
/*
|
* DevmemDestroyHeap()
|
*
|
* Reverses DevmemCreateHeap()
|
*
|
* N.B. All allocations must have been freed and all mappings must
|
* have been unmapped before invoking this call
|
*/
|
extern PVRSRV_ERROR
|
DevmemDestroyHeap(DEVMEM_HEAP *psHeap);
|
|
/*
|
* DevmemExportalignAdjustSizeAndAlign()
|
* Compute the Size and Align passed to avoid suballocations (used when allocation with PVRSRV_MEMALLOCFLAG_EXPORTALIGN)
|
*/
|
IMG_INTERNAL void
|
DevmemExportalignAdjustSizeAndAlign(IMG_UINT32 uiLog2Quantum,
|
IMG_DEVMEM_SIZE_T *puiSize,
|
IMG_DEVMEM_ALIGN_T *puiAlign);
|
|
/*
|
* DevmemSubAllocate()
|
*
|
* Makes an allocation (possibly a "suballocation", as described
|
* below) of device virtual memory from this heap.
|
*
|
* The size and alignment of the allocation will be honoured by the RA
|
* that allocates the "suballocation". The resulting allocation will
|
* be mapped into GPU virtual memory and the physical memory to back
|
* it will exist, by the time this call successfully completes.
|
*
|
* The size must be a positive integer multiple of the alignment.
|
* (i.e. the aligment specifies the alignment of both the start and
|
* the end of the resulting allocation.)
|
*
|
* Allocations made via this API are routed though a "suballocation
|
* RA" which is responsible for ensuring that small allocations can be
|
* made without wasting physical memory in the server. Furthermore,
|
* such suballocations can be made entirely client side without
|
* needing to go to the server unless the allocation spills into a new
|
* page.
|
*
|
* Such suballocations cause many allocations to share the same "PMR".
|
* This happens only when the flags match exactly.
|
*
|
*/
|
|
PVRSRV_ERROR
|
DevmemSubAllocate(IMG_UINT8 uiPreAllocMultiplier,
|
DEVMEM_HEAP *psHeap,
|
IMG_DEVMEM_SIZE_T uiSize,
|
IMG_DEVMEM_ALIGN_T uiAlign,
|
DEVMEM_FLAGS_T uiFlags,
|
const IMG_CHAR *pszText,
|
DEVMEM_MEMDESC **ppsMemDescPtr);
|
|
#define DevmemAllocate(...) \
|
DevmemSubAllocate(DEVMEM_NO_PRE_ALLOCATE_MULTIPLIER, __VA_ARGS__)
|
|
PVRSRV_ERROR
|
DevmemAllocateExportable(SHARED_DEV_CONNECTION hDevConnection,
|
IMG_DEVMEM_SIZE_T uiSize,
|
IMG_DEVMEM_ALIGN_T uiAlign,
|
IMG_UINT32 uiLog2HeapPageSize,
|
DEVMEM_FLAGS_T uiFlags,
|
const IMG_CHAR *pszText,
|
DEVMEM_MEMDESC **ppsMemDescPtr);
|
|
PVRSRV_ERROR
|
DeviceMemChangeSparse(DEVMEM_MEMDESC *psMemDesc,
|
IMG_UINT32 ui32AllocPageCount,
|
IMG_UINT32 *paui32AllocPageIndices,
|
IMG_UINT32 ui32FreePageCount,
|
IMG_UINT32 *pauiFreePageIndices,
|
SPARSE_MEM_RESIZE_FLAGS uiFlags);
|
|
PVRSRV_ERROR
|
DevmemAllocateSparse(SHARED_DEV_CONNECTION hDevConnection,
|
IMG_DEVMEM_SIZE_T uiSize,
|
IMG_DEVMEM_SIZE_T uiChunkSize,
|
IMG_UINT32 ui32NumPhysChunks,
|
IMG_UINT32 ui32NumVirtChunks,
|
IMG_UINT32 *pui32MappingTable,
|
IMG_DEVMEM_ALIGN_T uiAlign,
|
IMG_UINT32 uiLog2HeapPageSize,
|
DEVMEM_FLAGS_T uiFlags,
|
const IMG_CHAR *pszText,
|
DEVMEM_MEMDESC **ppsMemDescPtr);
|
|
/*
|
* DevmemFree()
|
*
|
* Reverses that done by DevmemSubAllocate() N.B. The underlying
|
* mapping and server side allocation _may_ not be torn down, for
|
* example, if the allocation has been exported, or if multiple
|
* allocations were suballocated from the same mapping, but this is
|
* properly refcounted, so the caller does not have to care.
|
*/
|
|
extern void
|
DevmemFree(DEVMEM_MEMDESC *psMemDesc);
|
|
/*
|
DevmemMapToDevice:
|
|
Map an allocation to the device it was allocated from.
|
This function _must_ be called before any call to
|
DevmemAcquireDevVirtAddr is made as it binds the allocation
|
to the heap.
|
DevmemReleaseDevVirtAddr is used to release the reference
|
to the device mapping this function created, but it doesn't
|
mean that the memory will actually be unmapped from the
|
device as other references to the mapping obtained via
|
DevmemAcquireDevVirtAddr could still be active.
|
*/
|
PVRSRV_ERROR DevmemMapToDevice(DEVMEM_MEMDESC *psMemDesc,
|
DEVMEM_HEAP *psHeap,
|
IMG_DEV_VIRTADDR *psDevVirtAddr);
|
|
/*
|
DevmemMapToDeviceAddress:
|
|
Same as DevmemMapToDevice but the caller chooses the address
|
to map to.
|
*/
|
IMG_INTERNAL PVRSRV_ERROR
|
DevmemMapToDeviceAddress(DEVMEM_MEMDESC *psMemDesc,
|
DEVMEM_HEAP *psHeap,
|
IMG_DEV_VIRTADDR sDevVirtAddr);
|
|
/*
|
DevmemAcquireDevVirtAddr
|
|
Acquire the MemDesc's device virtual address.
|
This function _must_ be called after DevmemMapToDevice
|
and is expected to be used be functions which didn't allocate
|
the MemDesc but need to know it's address
|
*/
|
PVRSRV_ERROR DevmemAcquireDevVirtAddr(DEVMEM_MEMDESC *psMemDesc,
|
IMG_DEV_VIRTADDR *psDevVirtAddrRet);
|
/*
|
* DevmemReleaseDevVirtAddr()
|
*
|
* give up the licence to use the device virtual address that was
|
* acquired by "Acquire" or "MapToDevice"
|
*/
|
extern void
|
DevmemReleaseDevVirtAddr(DEVMEM_MEMDESC *psMemDesc);
|
|
/*
|
* DevmemAcquireCpuVirtAddr()
|
*
|
* Acquires a license to use the cpu virtual address of this mapping.
|
* Note that the memory may not have been mapped into cpu virtual
|
* memory prior to this call. On first "acquire" the memory will be
|
* mapped in (if it wasn't statically mapped in) and on last put it
|
* _may_ become unmapped. Later calling "Acquire" again, _may_ cause
|
* the memory to be mapped at a different address.
|
*/
|
PVRSRV_ERROR DevmemAcquireCpuVirtAddr(DEVMEM_MEMDESC *psMemDesc,
|
void **ppvCpuVirtAddr);
|
/*
|
* DevmemReleaseDevVirtAddr()
|
*
|
* give up the licence to use the cpu virtual address that was granted
|
* with the "Get" call.
|
*/
|
extern void
|
DevmemReleaseCpuVirtAddr(DEVMEM_MEMDESC *psMemDesc);
|
|
#if defined(SUPPORT_INSECURE_EXPORT)
|
/*
|
* DevmemExport()
|
*
|
* Given a memory allocation allocated with DevmemAllocateExportable()
|
* create a "cookie" that can be passed intact by the caller's own choice
|
* of secure IPC to another process and used as the argument to "map"
|
* to map this memory into a heap in the target processes. N.B. This can
|
* also be used to map into multiple heaps in one process, though that's not
|
* the intention.
|
*
|
* Note, the caller must later call Unexport before freeing the
|
* memory.
|
*/
|
PVRSRV_ERROR DevmemExport(DEVMEM_MEMDESC *psMemDesc,
|
DEVMEM_EXPORTCOOKIE *psExportCookie);
|
|
|
void DevmemUnexport(DEVMEM_MEMDESC *psMemDesc,
|
DEVMEM_EXPORTCOOKIE *psExportCookie);
|
|
PVRSRV_ERROR
|
DevmemImport(SHARED_DEV_CONNECTION hDevConnection,
|
DEVMEM_EXPORTCOOKIE *psCookie,
|
DEVMEM_FLAGS_T uiFlags,
|
DEVMEM_MEMDESC **ppsMemDescPtr);
|
#endif /* SUPPORT_INSECURE_EXPORT */
|
|
/*
|
* DevmemMakeLocalImportHandle()
|
*
|
* This is a "special case" function for making a server export cookie
|
* which went through the direct bridge into an export cookie that can
|
* be passed through the client bridge.
|
*/
|
PVRSRV_ERROR
|
DevmemMakeLocalImportHandle(SHARED_DEV_CONNECTION hDevConnection,
|
IMG_HANDLE hServerExport,
|
IMG_HANDLE *hClientExport);
|
|
/*
|
* DevmemUnmakeLocalImportHandle()
|
*
|
* Free any resource associated with the Make operation
|
*/
|
PVRSRV_ERROR
|
DevmemUnmakeLocalImportHandle(SHARED_DEV_CONNECTION hDevConnection,
|
IMG_HANDLE hClientExport);
|
|
/*
|
*
|
* The following set of functions is specific to the heap "blueprint"
|
* stuff, for automatic creation of heaps when a context is created
|
*
|
*/
|
|
|
/* Devmem_HeapConfigCount: returns the number of heap configs that
|
this device has. Note that there is no acquire/release semantics
|
required, as this data is guaranteed to be constant for the
|
lifetime of the device node */
|
extern PVRSRV_ERROR
|
DevmemHeapConfigCount(SHARED_DEV_CONNECTION hDevConnection,
|
IMG_UINT32 *puiNumHeapConfigsOut);
|
|
/* Devmem_HeapCount: returns the number of heaps that a given heap
|
config on this device has. Note that there is no acquire/release
|
semantics required, as this data is guaranteed to be constant for
|
the lifetime of the device node */
|
extern PVRSRV_ERROR
|
DevmemHeapCount(SHARED_DEV_CONNECTION hDevConnection,
|
IMG_UINT32 uiHeapConfigIndex,
|
IMG_UINT32 *puiNumHeapsOut);
|
/* Devmem_HeapConfigName: return the name of the given heap config.
|
The caller is to provide the storage for the returned string and
|
indicate the number of bytes (including null terminator) for such
|
string in the BufSz arg. Note that there is no acquire/release
|
semantics required, as this data is guaranteed to be constant for
|
the lifetime of the device node.
|
*/
|
extern PVRSRV_ERROR
|
DevmemHeapConfigName(SHARED_DEV_CONNECTION hsDevConnection,
|
IMG_UINT32 uiHeapConfigIndex,
|
IMG_CHAR *pszConfigNameOut,
|
IMG_UINT32 uiConfigNameBufSz);
|
|
/* Devmem_HeapDetails: fetches all the metadata that is recorded in
|
this heap "blueprint". Namely: heap name (caller to provide
|
storage, and indicate buffer size (including null terminator) in
|
BufSz arg), device virtual address and length, log2 of data page
|
size (will be one of 12, 14, 16, 18, 20, 21, at time of writing).
|
Note that there is no acquire/release semantics required, as this
|
data is guaranteed to be constant for the lifetime of the device
|
node. */
|
extern PVRSRV_ERROR
|
DevmemHeapDetails(SHARED_DEV_CONNECTION hDevConnection,
|
IMG_UINT32 uiHeapConfigIndex,
|
IMG_UINT32 uiHeapIndex,
|
IMG_CHAR *pszHeapNameOut,
|
IMG_UINT32 uiHeapNameBufSz,
|
IMG_DEV_VIRTADDR *psDevVAddrBaseOut,
|
IMG_DEVMEM_SIZE_T *puiHeapLengthOut,
|
IMG_UINT32 *puiLog2DataPageSize,
|
IMG_UINT32 *puiLog2ImportAlignmentOut,
|
IMG_UINT32 *puiLog2TilingStrideFactor);
|
|
/*
|
* Devmem_FindHeapByName()
|
*
|
* returns the heap handle for the named _automagic_ heap in this
|
* context. "automagic" heaps are those that are born with the
|
* context from a blueprint
|
*/
|
extern PVRSRV_ERROR
|
DevmemFindHeapByName(const DEVMEM_CONTEXT *psCtx,
|
const IMG_CHAR *pszHeapName,
|
DEVMEM_HEAP **ppsHeapRet);
|
|
/*
|
* DevmemGetHeapBaseDevVAddr()
|
*
|
* returns the device virtual address of the base of the heap.
|
*/
|
|
PVRSRV_ERROR
|
DevmemGetHeapBaseDevVAddr(DEVMEM_HEAP *psHeap,
|
IMG_DEV_VIRTADDR *pDevVAddr);
|
|
extern PVRSRV_ERROR
|
DevmemLocalGetImportHandle(DEVMEM_MEMDESC *psMemDesc,
|
IMG_HANDLE *phImport);
|
|
extern PVRSRV_ERROR
|
DevmemGetImportUID(DEVMEM_MEMDESC *psMemDesc,
|
IMG_UINT64 *pui64UID);
|
|
PVRSRV_ERROR
|
DevmemGetReservation(DEVMEM_MEMDESC *psMemDesc,
|
IMG_HANDLE *hReservation);
|
|
IMG_INTERNAL PVRSRV_ERROR
|
DevmemGetPMRData(DEVMEM_MEMDESC *psMemDesc,
|
IMG_HANDLE *hPMR,
|
IMG_DEVMEM_OFFSET_T *puiPMROffset);
|
|
IMG_INTERNAL PVRSRV_ERROR
|
DevmemGetFlags(DEVMEM_MEMDESC *psMemDesc,
|
DEVMEM_FLAGS_T *puiFlags);
|
|
IMG_INTERNAL IMG_HANDLE
|
DevmemGetConnection(DEVMEM_MEMDESC *psMemDesc);
|
|
PVRSRV_ERROR
|
DevmemLocalImport(IMG_HANDLE hBridge,
|
IMG_HANDLE hExtHandle,
|
DEVMEM_FLAGS_T uiFlags,
|
DEVMEM_MEMDESC **ppsMemDescPtr,
|
IMG_DEVMEM_SIZE_T *puiSizePtr,
|
const IMG_CHAR *pszAnnotation);
|
|
IMG_INTERNAL PVRSRV_ERROR
|
DevmemIsDevVirtAddrValid(DEVMEM_CONTEXT *psContext,
|
IMG_DEV_VIRTADDR sDevVAddr);
|
|
/* DevmemGetHeapLog2PageSize()
|
*
|
* Get the page size used for a certain heap.
|
*/
|
IMG_UINT32
|
DevmemGetHeapLog2PageSize(DEVMEM_HEAP *psHeap);
|
|
/* DevmemGetHeapTilingProperties()
|
*
|
* Get the import alignment and tiling stride factor used for a certain heap.
|
*/
|
IMG_UINT32
|
DevmemGetHeapTilingProperties(DEVMEM_HEAP *psHeap,
|
IMG_UINT32 *puiLog2ImportAlignment,
|
IMG_UINT32 *puiLog2TilingStrideFactor);
|
|
/**************************************************************************/ /*!
|
@Function RegisterDevMemPFNotify
|
@Description Registers that the application wants to be signaled when a page
|
fault occurs.
|
|
@Input psContext Memory context the process that would like to
|
be notified about.
|
@Input ui32PID The PID of the calling process.
|
@Input bRegister If true, register. If false, de-register.
|
@Return PVRSRV_ERROR: PVRSRV_OK on success. Otherwise, a PVRSRV_
|
error code
|
*/ /***************************************************************************/
|
IMG_INTERNAL PVRSRV_ERROR
|
RegisterDevmemPFNotify(DEVMEM_CONTEXT *psContext,
|
IMG_UINT32 ui32PID,
|
IMG_BOOL bRegister);
|
|
#endif /* #ifndef SRVCLIENT_DEVICEMEM_CLIENT_H */
|
