/**************************************************************************/ /*!
|
@File
|
@Title Common MMU Management
|
@Copyright Copyright (c) Imagination Technologies Ltd. All Rights Reserved
|
@Description Implements basic low level control of MMU.
|
@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 MMU_COMMON_H
|
#define MMU_COMMON_H
|
|
/*
|
The Memory Management Unit (MMU) performs device virtual to physical translation.
|
|
Terminology:
|
- page catalogue, PC (optional, 3 tier MMU)
|
- page directory, PD
|
- page table, PT (can be variable sized)
|
- data page, DP (can be variable sized)
|
Note: PD and PC are fixed size and can't be larger than
|
the native physical (CPU) page size
|
Shifts and AlignShift variables:
|
- 'xxxShift' represent the number of bits a bitfield is shifted left from bit0
|
- 'xxxAlignShift' is used to convert a bitfield (based at bit0) into byte units
|
by applying a bit shift left by 'xxxAlignShift' bits
|
*/
|
|
/*
|
Device Virtual Address Config:
|
|
Incoming Device Virtual Address is deconstructed into up to 4
|
fields, where the virtual address is up to 64bits:
|
MSB-----------------------------------------------LSB
|
| PC Index: | PD Index: | PT Index: | DP offset: |
|
| d bits | c bits | b-v bits | a+v bits |
|
-----------------------------------------------------
|
where v is the variable page table modifier, e.g.
|
v == 0 -> 4KB DP
|
v == 2 -> 16KB DP
|
v == 4 -> 64KB DP
|
v == 6 -> 256KB DP
|
v == 8 -> 1MB DP
|
v == 10 -> 4MB DP
|
*/
|
|
/* services/server/include/ */
|
// #include "pmr.h"
|
#include "pdump.h"
|
#include "pmr_impl.h"
|
#include "pvrsrv_memallocflags.h"
|
#include "powervr/mem_types.h"
|
#include "pdumpdefs.h"
|
|
|
/* include/ */
|
#include "img_types.h"
|
#include "pvr_notifier.h"
|
#include "pvrsrv_error.h"
|
#include "servicesext.h"
|
|
|
/*!
|
The level of the MMU
|
*/
|
typedef enum
|
{
|
MMU_LEVEL_0 = 0, /* Level 0 = Page */
|
|
MMU_LEVEL_1,
|
MMU_LEVEL_2,
|
MMU_LEVEL_3,
|
MMU_LEVEL_LAST
|
} MMU_LEVEL;
|
|
/* moved after declaration of MMU_LEVEL, as pdump_mmu.h references it */
|
#include "pdump_mmu.h"
|
|
#define MMU_MAX_LEVEL 3
|
|
struct _MMU_DEVVADDR_CONFIG_;
|
|
/*!
|
MMU device attributes. This structure is the interface between the generic
|
MMU code and the device specific MMU code.
|
*/
|
typedef struct _MMU_DEVICEATTRIBS_
|
{
|
PDUMP_MMU_TYPE eMMUType;
|
|
IMG_CHAR *pszMMUPxPDumpMemSpaceName;
|
|
/*! The type of the top level object */
|
MMU_LEVEL eTopLevel;
|
|
/*! Alignment requirement of the base object */
|
IMG_UINT32 ui32BaseAlign;
|
|
/*! HW config of the base object */
|
struct _MMU_PxE_CONFIG_ *psBaseConfig;
|
|
/*! Address split for the base object */
|
const struct _MMU_DEVVADDR_CONFIG_ *psTopLevelDevVAddrConfig;
|
|
/*! Callback for creating protection bits for the page catalogue entry with 8 byte entry */
|
IMG_UINT64 (*pfnDerivePCEProt8)(IMG_UINT32, IMG_UINT32);
|
/*! Callback for creating protection bits for the page catalogue entry with 4 byte entry */
|
IMG_UINT32 (*pfnDerivePCEProt4)(IMG_UINT32);
|
/*! Callback for creating protection bits for the page directory entry with 8 byte entry */
|
IMG_UINT64 (*pfnDerivePDEProt8)(IMG_UINT32, IMG_UINT32);
|
/*! Callback for creating protection bits for the page directory entry with 4 byte entry */
|
IMG_UINT32 (*pfnDerivePDEProt4)(IMG_UINT32);
|
/*! Callback for creating protection bits for the page table entry with 8 byte entry */
|
IMG_UINT64 (*pfnDerivePTEProt8)(IMG_UINT32, IMG_UINT32);
|
/*! Callback for creating protection bits for the page table entry with 4 byte entry */
|
IMG_UINT32 (*pfnDerivePTEProt4)(IMG_UINT32);
|
|
/*! Callback for getting the MMU configuration based on the specified page size */
|
PVRSRV_ERROR (*pfnGetPageSizeConfiguration)(IMG_UINT32 ui32DataPageSize,
|
const struct _MMU_PxE_CONFIG_ **ppsMMUPDEConfig,
|
const struct _MMU_PxE_CONFIG_ **ppsMMUPTEConfig,
|
const struct _MMU_DEVVADDR_CONFIG_ **ppsMMUDevVAddrConfig,
|
IMG_HANDLE *phPriv2);
|
/*! Callback for putting the MMU configuration obtained from pfnGetPageSizeConfiguration */
|
PVRSRV_ERROR (*pfnPutPageSizeConfiguration)(IMG_HANDLE hPriv);
|
|
/*! Callback for getting the page size from the PDE for the page table entry with 4 byte entry */
|
PVRSRV_ERROR (*pfnGetPageSizeFromPDE4)(IMG_UINT32, IMG_UINT32 *);
|
/*! Callback for getting the page size from the PDE for the page table entry with 8 byte entry */
|
PVRSRV_ERROR (*pfnGetPageSizeFromPDE8)(IMG_UINT64, IMG_UINT32 *);
|
|
/*! Private data handle */
|
IMG_HANDLE hGetPageSizeFnPriv;
|
} MMU_DEVICEATTRIBS;
|
|
/*!
|
MMU virtual address split
|
*/
|
typedef struct _MMU_DEVVADDR_CONFIG_
|
{
|
/*! Page catalogue index mask */
|
IMG_UINT64 uiPCIndexMask;
|
/*! Page catalogue index shift */
|
IMG_UINT8 uiPCIndexShift;
|
/*! Total number of PC entries */
|
IMG_UINT32 uiNumEntriesPC;
|
/*! Page directory mask */
|
IMG_UINT64 uiPDIndexMask;
|
/*! Page directory shift */
|
IMG_UINT8 uiPDIndexShift;
|
/*! Total number of PD entries */
|
IMG_UINT32 uiNumEntriesPD;
|
/*! Page table mask */
|
IMG_UINT64 uiPTIndexMask;
|
/*! Page index shift */
|
IMG_UINT8 uiPTIndexShift;
|
/*! Total number of PT entries */
|
IMG_UINT32 uiNumEntriesPT;
|
/*! Page offset mask */
|
IMG_UINT64 uiPageOffsetMask;
|
/*! Page offset shift */
|
IMG_UINT8 uiPageOffsetShift;
|
/*! First virtual address mappable for this config */
|
IMG_UINT64 uiOffsetInBytes;
|
|
} MMU_DEVVADDR_CONFIG;
|
|
/*
|
P(C/D/T) Entry Config:
|
|
MSB-----------------------------------------------LSB
|
| PT Addr: | variable PT ctrl | protection flags: |
|
| bits c+v | b bits | a bits |
|
-----------------------------------------------------
|
where v is the variable page table modifier and is optional
|
*/
|
/*!
|
Generic MMU entry description. This is used to describe PC, PD and PT entries.
|
*/
|
typedef struct _MMU_PxE_CONFIG_
|
{
|
IMG_UINT8 uiBytesPerEntry; /*! Size of an entry in bytes */
|
|
IMG_UINT64 uiAddrMask; /*! Physical address mask */
|
IMG_UINT8 uiAddrShift; /*! Physical address shift */
|
IMG_UINT8 uiAddrLog2Align; /*! Physical address Log 2 alignment */
|
|
IMG_UINT64 uiVarCtrlMask; /*! Variable control mask */
|
IMG_UINT8 uiVarCtrlShift; /*! Variable control shift */
|
|
IMG_UINT64 uiProtMask; /*! Protection flags mask */
|
IMG_UINT8 uiProtShift; /*! Protection flags shift */
|
|
IMG_UINT64 uiValidEnMask; /*! Entry valid bit mask */
|
IMG_UINT8 uiValidEnShift; /*! Entry valid bit shift */
|
} MMU_PxE_CONFIG;
|
|
/* MMU Protection flags */
|
|
|
/* These are specified generically and in a h/w independent way, and
|
are interpreted at each level (PC/PD/PT) separately. */
|
|
/* The following flags are for internal use only, and should not
|
traverse the API */
|
#define MMU_PROTFLAGS_INVALID 0x80000000U
|
|
typedef IMG_UINT32 MMU_PROTFLAGS_T;
|
|
/* The following flags should be supplied by the caller: */
|
#define MMU_PROTFLAGS_READABLE (1U<<0)
|
#define MMU_PROTFLAGS_WRITEABLE (1U<<1)
|
#define MMU_PROTFLAGS_CACHE_COHERENT (1U<<2)
|
#define MMU_PROTFLAGS_CACHED (1U<<3)
|
|
/* Device specific flags*/
|
#define MMU_PROTFLAGS_DEVICE_OFFSET 16
|
#define MMU_PROTFLAGS_DEVICE_MASK 0x000f0000UL
|
#define MMU_PROTFLAGS_DEVICE(n) \
|
(((n) << MMU_PROTFLAGS_DEVICE_OFFSET) & \
|
MMU_PROTFLAGS_DEVICE_MASK)
|
|
|
typedef struct _MMU_CONTEXT_ MMU_CONTEXT;
|
|
struct _PVRSRV_DEVICE_NODE_;
|
|
typedef struct _MMU_PAGESIZECONFIG_
|
{
|
const MMU_PxE_CONFIG *psPDEConfig;
|
const MMU_PxE_CONFIG *psPTEConfig;
|
const MMU_DEVVADDR_CONFIG *psDevVAddrConfig;
|
IMG_UINT32 uiRefCount;
|
IMG_UINT32 uiMaxRefCount;
|
} MMU_PAGESIZECONFIG;
|
|
/*************************************************************************/ /*!
|
@Function MMU_ContextCreate
|
|
@Description Create a new MMU context
|
|
@Input psDevNode Device node of the device to create the
|
MMU context for
|
|
@Output ppsMMUContext The created MMU context
|
|
@Return PVRSRV_OK if the MMU context was successfully created
|
*/
|
/*****************************************************************************/
|
extern PVRSRV_ERROR
|
MMU_ContextCreate (struct _PVRSRV_DEVICE_NODE_ *psDevNode,
|
MMU_CONTEXT **ppsMMUContext,
|
MMU_DEVICEATTRIBS *psDevAttrs);
|
|
|
/*************************************************************************/ /*!
|
@Function MMU_ContextDestroy
|
|
@Description Destroy a MMU context
|
|
@Input ppsMMUContext MMU context to destroy
|
|
@Return None
|
*/
|
/*****************************************************************************/
|
extern void
|
MMU_ContextDestroy (MMU_CONTEXT *psMMUContext);
|
|
/*************************************************************************/ /*!
|
@Function MMU_Alloc
|
|
@Description Allocate the page tables required for the specified virtual range
|
|
@Input psMMUContext MMU context to operate on
|
|
@Input uSize The size of the allocation
|
|
@Output puActualSize Actual size of allocation
|
|
@Input uiProtFlags Generic MMU protection flags
|
|
@Input uDevVAddrAlignment Alignment requirement of the virtual
|
allocation
|
|
@Input psDevVAddr Virtual address to start the allocation
|
from
|
|
@Return PVRSRV_OK if the allocation of the page tables was successful
|
*/
|
/*****************************************************************************/
|
extern PVRSRV_ERROR
|
MMU_Alloc (MMU_CONTEXT *psMMUContext,
|
IMG_DEVMEM_SIZE_T uSize,
|
IMG_DEVMEM_SIZE_T *puActualSize,
|
IMG_UINT32 uiProtFlags,
|
IMG_DEVMEM_SIZE_T uDevVAddrAlignment,
|
IMG_DEV_VIRTADDR *psDevVAddr,
|
IMG_UINT32 uiLog2PageSize);
|
|
|
/*************************************************************************/ /*!
|
@Function MMU_Free
|
|
@Description Free the page tables of the specified virtual range
|
|
@Input psMMUContext MMU context to operate on
|
|
@Input psDevVAddr Virtual address to start the free
|
from
|
|
@Input uSize The size of the allocation
|
|
@Return None
|
*/
|
/*****************************************************************************/
|
extern void
|
MMU_Free (MMU_CONTEXT *psMMUContext,
|
IMG_DEV_VIRTADDR sDevVAddr,
|
IMG_DEVMEM_SIZE_T uiSize,
|
IMG_UINT32 uiLog2DataPageSize);
|
|
|
/*************************************************************************/ /*!
|
@Function MMU_MapPages
|
|
@Description Map pages to the MMU.
|
Two modes of operation: One requires a list of physical page
|
indices that are going to be mapped, the other just takes
|
the PMR and a possible offset to map parts of it.
|
|
@Input psMMUContext MMU context to operate on
|
|
@Input uiMappingFlags Memalloc flags for the mapping
|
|
@Input sDevVAddrBase Device virtual address of the 1st page
|
|
@Input psPMR PMR to map
|
|
@Input ui32PhysPgOffset Physical offset into the PMR
|
|
@Input ui32MapPageCount Number of pages to map
|
|
@Input paui32MapIndices List of page indices to map,
|
can be NULL
|
|
@Input uiLog2PageSize Log2 page size of the pages to map
|
|
@Return PVRSRV_OK if the mapping was successful
|
*/
|
/*****************************************************************************/
|
extern PVRSRV_ERROR
|
MMU_MapPages(MMU_CONTEXT *psMMUContext,
|
PVRSRV_MEMALLOCFLAGS_T uiMappingFlags,
|
IMG_DEV_VIRTADDR sDevVAddrBase,
|
PMR *psPMR,
|
IMG_UINT32 ui32PhysPgOffset,
|
IMG_UINT32 ui32MapPageCount,
|
IMG_UINT32 *paui32MapIndices,
|
IMG_UINT32 uiLog2PageSize);
|
|
/*************************************************************************/ /*!
|
@Function MMU_UnmapPages
|
|
@Description Unmap pages from the MMU.
|
|
@Input psMMUContext MMU context to operate on
|
|
@Input uiMappingFlags Memalloc flags for the mapping
|
|
@Input psDevVAddr Device virtual address of the 1st page
|
|
@Input ui32PageCount Number of pages to unmap
|
|
@Input pai32UnmapIndicies Array of page indices to be unmapped
|
|
@Input uiLog2PageSize log2 size of the page
|
|
|
@Input bDummyBacking Bool that indicates if the unmapped
|
regions need to be backed by dummy
|
page
|
|
@Return None
|
*/
|
/*****************************************************************************/
|
extern void
|
MMU_UnmapPages (MMU_CONTEXT *psMMUContext,
|
PVRSRV_MEMALLOCFLAGS_T uiMappingFlags,
|
IMG_DEV_VIRTADDR sDevVAddr,
|
IMG_UINT32 ui32PageCount,
|
IMG_UINT32 *pai32UnmapIndicies,
|
IMG_UINT32 uiLog2PageSize,
|
IMG_BOOL bDummyBacking);
|
|
/*************************************************************************/ /*!
|
@Function MMU_MapPMRFast
|
|
@Description Map a PMR into the MMU. Must be not sparse.
|
This is supposed to cover most mappings and, as the name suggests,
|
should be as fast as possible.
|
|
@Input psMMUContext MMU context to operate on
|
|
@Input sDevVAddr Device virtual address to map the PMR
|
into
|
|
@Input psPMR PMR to map
|
|
@Input uiSizeBytes Size in bytes to map
|
|
@Input uiMappingFlags Memalloc flags for the mapping
|
|
@Return PVRSRV_OK if the PMR was successfully mapped
|
*/
|
/*****************************************************************************/
|
extern PVRSRV_ERROR
|
MMU_MapPMRFast (MMU_CONTEXT *psMMUContext,
|
IMG_DEV_VIRTADDR sDevVAddr,
|
const PMR *psPMR,
|
IMG_DEVMEM_SIZE_T uiSizeBytes,
|
PVRSRV_MEMALLOCFLAGS_T uiMappingFlags,
|
IMG_UINT32 uiLog2PageSize);
|
|
/*************************************************************************/ /*!
|
@Function MMU_UnmapPMRFast
|
|
@Description Unmap pages from the MMU as fast as possible.
|
PMR must be non sparse!
|
|
@Input psMMUContext MMU context to operate on
|
|
@Input sDevVAddrBase Device virtual address of the 1st page
|
|
@Input ui32PageCount Number of pages to unmap
|
|
@Input uiLog2PageSize log2 size of the page
|
|
@Return None
|
*/
|
/*****************************************************************************/
|
extern void
|
MMU_UnmapPMRFast(MMU_CONTEXT *psMMUContext,
|
IMG_DEV_VIRTADDR sDevVAddrBase,
|
IMG_UINT32 ui32PageCount,
|
IMG_UINT32 uiLog2PageSize);
|
|
/*************************************************************************/ /*!
|
@Function MMU_ChangeValidity
|
|
@Description Sets or unsets the valid bit of page table entries for a given
|
address range.
|
|
@Input psMMUContext MMU context to operate on
|
|
@Input sDevVAddr The device virtual base address of
|
the range we want to modify
|
|
@Input uiSizeBytes The size of the range in bytes
|
|
@Input uiLog2PageSize Log2 of the used page size
|
|
@Input bMakeValid Choose to set or unset the valid bit.
|
(bMakeValid == IMG_TRUE ) -> SET
|
(bMakeValid == IMG_FALSE) -> UNSET
|
|
@Input psPMR The PMR backing the allocation.
|
Needed in case we have sparse memory
|
where we have to check whether a physical
|
address actually backs the virtual.
|
|
@Return PVRSRV_OK if successful
|
*/
|
/*****************************************************************************/
|
PVRSRV_ERROR
|
MMU_ChangeValidity(MMU_CONTEXT *psMMUContext,
|
IMG_DEV_VIRTADDR sDevVAddr,
|
IMG_DEVMEM_SIZE_T uiSizeBytes,
|
IMG_UINT32 uiLog2PageSize,
|
IMG_BOOL bMakeValid,
|
PMR *psPMR);
|
|
/*************************************************************************/ /*!
|
@Function MMU_AcquireBaseAddr
|
|
@Description Acquire the device physical address of the base level MMU object
|
|
@Input psMMUContext MMU context to operate on
|
|
@Output psPhysAddr Device physical address of the base level
|
MMU object
|
|
@Return PVRSRV_OK if successful
|
*/
|
/*****************************************************************************/
|
PVRSRV_ERROR
|
MMU_AcquireBaseAddr(MMU_CONTEXT *psMMUContext, IMG_DEV_PHYADDR *psPhysAddr);
|
|
/*************************************************************************/ /*!
|
@Function MMU_ReleaseBaseAddr
|
|
@Description Release the device physical address of the base level MMU object
|
|
@Input psMMUContext MMU context to operate on
|
|
@Return PVRSRV_OK if successful
|
*/
|
/*****************************************************************************/
|
void
|
MMU_ReleaseBaseAddr(MMU_CONTEXT *psMMUContext);
|
|
#if defined(SUPPORT_GPUVIRT_VALIDATION)
|
/***********************************************************************************/ /*!
|
@Function MMU_SetOSid
|
|
@Description Set the OSid associated with the application (and the MMU Context)
|
|
@Input psMMUContext MMU context to store the OSid on
|
|
@Input ui32OSid the OSid in question
|
|
@Input ui32OSidReg The value that the firmware will assign to the
|
registers.
|
|
@Input bOSidAxiProt Toggles whether the AXI prot bit will be set or
|
not.
|
@Return None
|
*/
|
/***********************************************************************************/
|
|
void MMU_SetOSids(MMU_CONTEXT *psMMUContext, IMG_UINT32 ui32OSid, IMG_UINT32 ui32OSidReg, IMG_BOOL bOSidAxiProt);
|
|
/***********************************************************************************/ /*!
|
@Function MMU_GetOSid
|
|
@Description Retrieve the OSid associated with the MMU context.
|
|
@Input psMMUContext MMU context in which the OSid is stored
|
|
@Output pui32OSid The OSid in question
|
|
@Output pui32OSidReg The OSid that the firmware will assign to the
|
registers.
|
|
@Output pbOSidAxiProt Toggles whether the AXI prot bit will be set or
|
not.
|
@Return None
|
*/
|
/***********************************************************************************/
|
|
void MMU_GetOSids(MMU_CONTEXT *psMMUContext, IMG_UINT32 * pui32OSid, IMG_UINT32 * pui32OSidReg, IMG_BOOL *pbOSidAxiProt);
|
#endif
|
|
/*************************************************************************/ /*!
|
@Function MMU_SetDeviceData
|
|
@Description Set the device specific callback data
|
|
@Input psMMUContext MMU context to store the data on
|
|
@Input hDevData Device data
|
|
@Return None
|
*/
|
/*****************************************************************************/
|
void MMU_SetDeviceData(MMU_CONTEXT *psMMUContext, IMG_HANDLE hDevData);
|
|
/*************************************************************************/ /*!
|
@Function MMU_CheckFaultAddress
|
|
@Description Check the specified MMU context to see if the provided address
|
should be valid
|
|
@Input psMMUContext MMU context to store the data on
|
|
@Input psDevVAddr Address to check
|
|
@Input pfnDumpDebugPrintf Debug print function
|
|
@Input pvDumpDebugFile Optional file identifier to be passed
|
to the debug print function if required
|
|
@Return None
|
*/
|
/*****************************************************************************/
|
void MMU_CheckFaultAddress(MMU_CONTEXT *psMMUContext,
|
IMG_DEV_VIRTADDR *psDevVAddr,
|
DUMPDEBUG_PRINTF_FUNC *pfnDumpDebugPrintf,
|
void *pvDumpDebugFile);
|
|
/*************************************************************************/ /*!
|
@Function MMUI_IsVDevAddrValid
|
@Description Checks if given address is valid.
|
@Input psMMUContext MMU context to store the data on
|
@Input uiLog2PageSize page size
|
@Input psDevVAddr Address to check
|
@Return IMG_TRUE of address is valid
|
*/ /**************************************************************************/
|
IMG_BOOL MMU_IsVDevAddrValid(MMU_CONTEXT *psMMUContext,
|
IMG_UINT32 uiLog2PageSize,
|
IMG_DEV_VIRTADDR sDevVAddr);
|
|
|
#if defined(PDUMP)
|
/*************************************************************************/ /*!
|
@Function MMU_ContextDerivePCPDumpSymAddr
|
|
@Description Derives a PDump Symbolic address for the top level MMU object
|
|
@Input psMMUContext MMU context to operate on
|
|
@Input pszPDumpSymbolicNameBuffer Buffer to write the PDump symbolic
|
address to
|
|
@Input uiPDumpSymbolicNameBufferSize Size of the buffer
|
|
@Return PVRSRV_OK if successful
|
*/
|
/*****************************************************************************/
|
extern PVRSRV_ERROR MMU_ContextDerivePCPDumpSymAddr(MMU_CONTEXT *psMMUContext,
|
IMG_CHAR *pszPDumpSymbolicNameBuffer,
|
size_t uiPDumpSymbolicNameBufferSize);
|
|
/*************************************************************************/ /*!
|
@Function MMU_PDumpWritePageCatBase
|
|
@Description PDump write of the top level MMU object to a device register
|
|
@Input psMMUContext MMU context to operate on
|
|
@Input pszSpaceName PDump name of the mem/reg space
|
|
@Input uiOffset Offset to write the address to
|
|
@Return PVRSRV_OK if successful
|
*/
|
/*****************************************************************************/
|
PVRSRV_ERROR MMU_PDumpWritePageCatBase(MMU_CONTEXT *psMMUContext,
|
const IMG_CHAR *pszSpaceName,
|
IMG_DEVMEM_OFFSET_T uiOffset,
|
IMG_UINT32 ui32WordSize,
|
IMG_UINT32 ui32AlignShift,
|
IMG_UINT32 ui32Shift,
|
PDUMP_FLAGS_T uiPdumpFlags);
|
|
/*************************************************************************/ /*!
|
@Function MMU_AcquirePDumpMMUContext
|
|
@Description Acquire a reference to the PDump MMU context for this MMU
|
context
|
|
@Input psMMUContext MMU context to operate on
|
|
@Input pszRegSpaceName PDump name of the register space
|
|
@Output pui32PDumpMMUContextID PDump MMU context ID
|
|
@Return PVRSRV_OK if successful
|
*/
|
/*****************************************************************************/
|
PVRSRV_ERROR MMU_AcquirePDumpMMUContext(MMU_CONTEXT *psMMUContext, IMG_UINT32 *pui32PDumpMMUContextID);
|
|
/*************************************************************************/ /*!
|
@Function MMU_ReleasePDumpMMUContext
|
|
@Description Release a reference to the PDump MMU context for this MMU context
|
|
@Input psMMUContext MMU context to operate on
|
|
@Input pszRegSpaceName PDump name of the register space
|
|
@Output pui32PDumpMMUContextID PDump MMU context ID
|
|
@Return PVRSRV_OK if successful
|
*/
|
/*****************************************************************************/
|
PVRSRV_ERROR MMU_ReleasePDumpMMUContext(MMU_CONTEXT *psMMUContext);
|
#else /* PDUMP */
|
|
#ifdef INLINE_IS_PRAGMA
|
#pragma inline(MMU_PDumpWritePageCatBase)
|
#endif
|
static INLINE void
|
MMU_PDumpWritePageCatBase(MMU_CONTEXT *psMMUContext,
|
const IMG_CHAR *pszSpaceName,
|
IMG_DEVMEM_OFFSET_T uiOffset,
|
IMG_UINT32 ui32WordSize,
|
IMG_UINT32 ui32AlignShift,
|
IMG_UINT32 ui32Shift,
|
PDUMP_FLAGS_T uiPdumpFlags)
|
{
|
PVR_UNREFERENCED_PARAMETER(psMMUContext);
|
PVR_UNREFERENCED_PARAMETER(pszSpaceName);
|
PVR_UNREFERENCED_PARAMETER(uiOffset);
|
PVR_UNREFERENCED_PARAMETER(ui32WordSize);
|
PVR_UNREFERENCED_PARAMETER(ui32AlignShift);
|
PVR_UNREFERENCED_PARAMETER(ui32Shift);
|
PVR_UNREFERENCED_PARAMETER(uiPdumpFlags);
|
}
|
#endif /* PDUMP */
|
|
|
#endif /* #ifdef MMU_COMMON_H */
|
