/*************************************************************************/ /*! @File @Title Header for Services abstraction layer @Copyright Copyright (c) Imagination Technologies Ltd. All Rights Reserved @Description Declaration of an interface layer used to abstract code that can be compiled outside of the DDK, potentially in a completely different OS. All the headers included by this file must also be copied to the alternative source tree. All the functions declared here must have a DDK implementation inside the DDK source tree (e.g. rgxlayer_km_impl.h/.c) and another different implementation in case they are used outside of the DDK. All of the functions accept as a first parameter a "const void *hPrivate" argument. It should be used to pass around any implementation specific data required. @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. */ /**************************************************************************/ #if !defined (__RGXLAYER_KM_H__) #define __RGXLAYER_KM_H__ #if defined (__cplusplus) extern "C" { #endif #include "img_types.h" #include "img_defs.h" #include "pvrsrv_error.h" /* includes pvrsrv_errors.h */ #include "rgx_bvnc_defs_km.h" #include "rgx_firmware_processor.h" /* includes: * rgx_meta.h and rgx_mips.h, * rgxdefs_km.h, * rgx_cr_defs_km.h, * RGX_BVNC_CORE_KM_HEADER (rgxcore_km_B.V.N.C.h), * RGX_BNC_CONFIG_KM_HEADER (rgxconfig_km_B.V.N.C.h) */ /*! ******************************************************************************* @Function RGXWriteReg32/64 @Description Write a value to a 32/64 bit RGX register @Input hPrivate : Implementation specific data @Input ui32RegAddr : Register offset inside the register bank @Input ui32/64RegValue : New register value @Return void ******************************************************************************/ void RGXWriteReg32(const void *hPrivate, IMG_UINT32 ui32RegAddr, IMG_UINT32 ui32RegValue); void RGXWriteReg64(const void *hPrivate, IMG_UINT32 ui32RegAddr, IMG_UINT64 ui64RegValue); /*! ******************************************************************************* @Function RGXReadReg32/64 @Description Read a 32/64 bit RGX register @Input hPrivate : Implementation specific data @Input ui32RegAddr : Register offset inside the register bank @Return Register value ******************************************************************************/ IMG_UINT32 RGXReadReg32(const void *hPrivate, IMG_UINT32 ui32RegAddr); IMG_UINT64 RGXReadReg64(const void *hPrivate, IMG_UINT32 ui32RegAddr); /*! ******************************************************************************* @Function RGXPollReg32/64 @Description Poll on a 32/64 bit RGX register until some bits are set/unset @Input hPrivate : Implementation specific data @Input ui32RegAddr : Register offset inside the register bank @Input ui32/64RegValue : Value expected from the register @Input ui32/64RegMask : Only the bits set in this mask will be checked against uiRegValue @Return PVRSRV_OK if the poll succeeds, PVRSRV_ERROR_TIMEOUT if the poll takes too long ******************************************************************************/ PVRSRV_ERROR RGXPollReg32(const void *hPrivate, IMG_UINT32 ui32RegAddr, IMG_UINT32 ui32RegValue, IMG_UINT32 ui32RegMask); PVRSRV_ERROR RGXPollReg64(const void *hPrivate, IMG_UINT32 ui32RegAddr, IMG_UINT64 ui64RegValue, IMG_UINT64 ui64RegMask); /*! ******************************************************************************* @Function RGXWaitCycles @Description Wait for a number of GPU cycles and/or microseconds @Input hPrivate : Implementation specific data @Input ui32Cycles : Number of GPU cycles to wait for in pdumps, it can also be used when running driver-live if desired (ignoring the next parameter) @Input ui32WaitUs : Number of microseconds to wait for when running driver-live @Return void ******************************************************************************/ void RGXWaitCycles(const void *hPrivate, IMG_UINT32 ui32Cycles, IMG_UINT32 ui32WaitUs); /*! ******************************************************************************* @Function RGXCommentLogPower @Description This function is called with debug messages during the RGX start/stop process @Input hPrivate : Implementation specific data @Input pszString : Message to be printed @Input ... : Variadic arguments @Return void ******************************************************************************/ void RGXCommentLogPower(const void *hPrivate, const IMG_CHAR *pszString, ...) __printf(2, 3); /*! ******************************************************************************* @Function RGXAcquireKernelMMUPC @Description Acquire the Kernel MMU Page Catalogue device physical address @Input hPrivate : Implementation specific data @Input psPCAddr : Returned page catalog address @Return void ******************************************************************************/ void RGXAcquireKernelMMUPC(const void *hPrivate, IMG_DEV_PHYADDR *psPCAddr); /*! ******************************************************************************* @Function RGXWriteKernelMMUPC32/64 @Description Write the Kernel MMU Page Catalogue to the 32/64 bit RGX register passed as argument. In a driver-live scenario without PDump these functions are the same as RGXWriteReg32/64 and they don't need to be reimplemented. @Input hPrivate : Implementation specific data @Input ui32PCReg : Register offset inside the register bank @Input ui32AlignShift : PC register alignshift @Input ui32Shift : PC register shift @Input ui32/64PCVal : Page catalog value (aligned and shifted) @Return void ******************************************************************************/ #if defined(PDUMP) void RGXWriteKernelMMUPC64(const void *hPrivate, IMG_UINT32 ui32PCReg, IMG_UINT32 ui32PCRegAlignShift, IMG_UINT32 ui32PCRegShift, IMG_UINT64 ui64PCVal); void RGXWriteKernelMMUPC32(const void *hPrivate, IMG_UINT32 ui32PCReg, IMG_UINT32 ui32PCRegAlignShift, IMG_UINT32 ui32PCRegShift, IMG_UINT32 ui32PCVal); #else /* defined(PDUMP) */ #define RGXWriteKernelMMUPC64(priv, pcreg, alignshift, shift, pcval) \ RGXWriteReg64(priv, pcreg, pcval) #define RGXWriteKernelMMUPC32(priv, pcreg, alignshift, shift, pcval) \ RGXWriteReg32(priv, pcreg, pcval) #endif /* defined(PDUMP) */ /*! ******************************************************************************* @Function RGXAcquireGPURegsAddr @Description Acquire the GPU registers base device physical address @Input hPrivate : Implementation specific data @Input psGPURegsAddr : Returned GPU registers base address @Return void ******************************************************************************/ void RGXAcquireGPURegsAddr(const void *hPrivate, IMG_DEV_PHYADDR *psGPURegsAddr); /*! ******************************************************************************* @Function RGXMIPSWrapperConfig @Description Write GPU register bank transaction ID and MIPS boot mode to the MIPS wrapper config register (passed as argument). In a driver-live scenario without PDump this is the same as RGXWriteReg64 and it doesn't need to be reimplemented. @Input hPrivate : Implementation specific data @Input ui32RegAddr : Register offset inside the register bank @Input ui64GPURegsAddr : GPU registers base address @Input ui32GPURegsAlign : Register bank transactions alignment @Input ui32BootMode : Mips BOOT ISA mode @Return void ******************************************************************************/ #if defined(PDUMP) void RGXMIPSWrapperConfig(const void *hPrivate, IMG_UINT32 ui32RegAddr, IMG_UINT64 ui64GPURegsAddr, IMG_UINT32 ui32GPURegsAlign, IMG_UINT32 ui32BootMode); #else #define RGXMIPSWrapperConfig(priv, regaddr, gpuregsaddr, gpuregsalign, bootmode) \ RGXWriteReg64(priv, regaddr, ((gpuregsaddr) >> (gpuregsalign)) | (bootmode)) #endif /*! ******************************************************************************* @Function RGXAcquireBootRemapAddr @Description Acquire the device physical address of the MIPS bootloader accessed through remap region @Input hPrivate : Implementation specific data @Output psBootRemapAddr : Base address of the remapped bootloader @Return void ******************************************************************************/ void RGXAcquireBootRemapAddr(const void *hPrivate, IMG_DEV_PHYADDR *psBootRemapAddr); /*! ******************************************************************************* @Function RGXBootRemapConfig @Description Configure the bootloader remap registers passed as arguments. In a driver-live scenario without PDump this is the same as two RGXWriteReg64 and it doesn't need to be reimplemented. @Input hPrivate : Implementation specific data @Input ui32Config1RegAddr : Remap config1 register offset @Input ui64Config1RegValue : Remap config1 register value @Input ui32Config2RegAddr : Remap config2 register offset @Input ui64Config2PhyAddr : Output remapped aligned physical address @Input ui64Config2PhyMask : Mask for the output physical address @Input ui64Config2Settings : Extra settings for this remap region @Return void ******************************************************************************/ #if defined(PDUMP) void RGXBootRemapConfig(const void *hPrivate, IMG_UINT32 ui32Config1RegAddr, IMG_UINT64 ui64Config1RegValue, IMG_UINT32 ui32Config2RegAddr, IMG_UINT64 ui64Config2PhyAddr, IMG_UINT64 ui64Config2PhyMask, IMG_UINT64 ui64Config2Settings); #else #define RGXBootRemapConfig(priv, c1reg, c1val, c2reg, c2phyaddr, c2phymask, c2settings) do { \ RGXWriteReg64(priv, c1reg, (c1val)); \ RGXWriteReg64(priv, c2reg, ((c2phyaddr) & (c2phymask)) | (c2settings)); \ } while (0) #endif /*! ******************************************************************************* @Function RGXAcquireCodeRemapAddr @Description Acquire the device physical address of the MIPS code accessed through remap region @Input hPrivate : Implementation specific data @Output psCodeRemapAddr : Base address of the remapped code @Return void ******************************************************************************/ void RGXAcquireCodeRemapAddr(const void *hPrivate, IMG_DEV_PHYADDR *psCodeRemapAddr); /*! ******************************************************************************* @Function RGXCodeRemapConfig @Description Configure the code remap registers passed as arguments. In a driver-live scenario without PDump this is the same as two RGXWriteReg64 and it doesn't need to be reimplemented. @Input hPrivate : Implementation specific data @Input ui32Config1RegAddr : Remap config1 register offset @Input ui64Config1RegValue : Remap config1 register value @Input ui32Config2RegAddr : Remap config2 register offset @Input ui64Config2PhyAddr : Output remapped aligned physical address @Input ui64Config2PhyMask : Mask for the output physical address @Input ui64Config2Settings : Extra settings for this remap region @Return void ******************************************************************************/ #if defined(PDUMP) void RGXCodeRemapConfig(const void *hPrivate, IMG_UINT32 ui32Config1RegAddr, IMG_UINT64 ui64Config1RegValue, IMG_UINT32 ui32Config2RegAddr, IMG_UINT64 ui64Config2PhyAddr, IMG_UINT64 ui64Config2PhyMask, IMG_UINT64 ui64Config2Settings); #else #define RGXCodeRemapConfig(priv, c1reg, c1val, c2reg, c2phyaddr, c2phymask, c2settings) do { \ RGXWriteReg64(priv, c1reg, (c1val)); \ RGXWriteReg64(priv, c2reg, ((c2phyaddr) & (c2phymask)) | (c2settings)); \ } while (0) #endif /*! ******************************************************************************* @Function RGXAcquireDataRemapAddr @Description Acquire the device physical address of the MIPS data accessed through remap region @Input hPrivate : Implementation specific data @Output psDataRemapAddr : Base address of the remapped data @Return void ******************************************************************************/ void RGXAcquireDataRemapAddr(const void *hPrivate, IMG_DEV_PHYADDR *psDataRemapAddr); /*! ******************************************************************************* @Function RGXDataRemapConfig @Description Configure the data remap registers passed as arguments. In a driver-live scenario without PDump this is the same as two RGXWriteReg64 and it doesn't need to be reimplemented. @Input hPrivate : Implementation specific data @Input ui32Config1RegAddr : Remap config1 register offset @Input ui64Config1RegValue : Remap config1 register value @Input ui32Config2RegAddr : Remap config2 register offset @Input ui64Config2PhyAddr : Output remapped aligned physical address @Input ui64Config2PhyMask : Mask for the output physical address @Input ui64Config2Settings : Extra settings for this remap region @Return void ******************************************************************************/ #if defined(PDUMP) void RGXDataRemapConfig(const void *hPrivate, IMG_UINT32 ui32Config1RegAddr, IMG_UINT64 ui64Config1RegValue, IMG_UINT32 ui32Config2RegAddr, IMG_UINT64 ui64Config2PhyAddr, IMG_UINT64 ui64Config2PhyMask, IMG_UINT64 ui64Config2Settings); #else #define RGXDataRemapConfig(priv, c1reg, c1val, c2reg, c2phyaddr, c2phymask, c2settings) do { \ RGXWriteReg64(priv, c1reg, (c1val)); \ RGXWriteReg64(priv, c2reg, ((c2phyaddr) & (c2phymask)) | (c2settings)); \ } while (0) #endif /*! ******************************************************************************* @Function RGXAcquireTrampolineRemapAddr @Description Acquire the device physical address of the MIPS data accessed through remap region @Input hPrivate : Implementation specific data @Output psTrampolineRemapAddr: Base address of the remapped data @Return void ******************************************************************************/ void RGXAcquireTrampolineRemapAddr(const void *hPrivate, IMG_DEV_PHYADDR *psTrampolineRemapAddr); /*! ******************************************************************************* @Function RGXTrampolineRemapConfig @Description Configure the trampoline remap registers passed as arguments. In a driver-live scenario without PDump this is the same as two RGXWriteReg64 and it doesn't need to be reimplemented. @Input hPrivate : Implementation specific data @Input ui32Config1RegAddr : Remap config1 register offset @Input ui64Config1RegValue : Remap config1 register value @Input ui32Config2RegAddr : Remap config2 register offset @Input ui64Config2PhyAddr : Output remapped aligned physical address @Input ui64Config2PhyMask : Mask for the output physical address @Input ui64Config2Settings : Extra settings for this remap region @Return void ******************************************************************************/ #define RGXTrampolineRemapConfig(priv, c1reg, c1val, c2reg, c2phyaddr, c2phymask, c2settings) do { \ RGXWriteReg64(priv, c1reg, (c1val)); \ RGXWriteReg64(priv, c2reg, ((c2phyaddr) & (c2phymask)) | (c2settings)); \ } while (0) /*! ******************************************************************************* @Function RGXDoFWSlaveBoot @Description Returns whether or not a FW Slave Boot is required while powering on @Input hPrivate : Implementation specific data @Return IMG_BOOL ******************************************************************************/ IMG_BOOL RGXDoFWSlaveBoot(const void *hPrivate); /*! ******************************************************************************* @Function RGXIOCoherencyTest @Description Performs a coherency test @Input hPrivate : Implementation specific data @Return PVRSRV_OK if the test succeeds, PVRSRV_ERROR_INIT_FAILURE if the test fails at some point ******************************************************************************/ PVRSRV_ERROR RGXIOCoherencyTest(const void *hPrivate); /*! ******************************************************************************* @Function RGXDeviceHasFeaturePower @Description Checks if a device has a particular feature @Input hPrivate : Implementation specific data @Input ui64Feature : Feature to check @Return IMG_TRUE if the given feature is available, IMG_FALSE otherwise ******************************************************************************/ IMG_BOOL RGXDeviceHasFeaturePower(const void *hPrivate, IMG_UINT64 ui64Feature); /*! ******************************************************************************* @Function RGXDeviceHasErnBrnPower @Description Checks if a device has a particular errata @Input hPrivate : Implementation specific data @Input ui64ErnsBrns : Flags to check @Return IMG_TRUE if the given errata is available, IMG_FALSE otherwise ******************************************************************************/ IMG_BOOL RGXDeviceHasErnBrnPower(const void *hPrivate, IMG_UINT64 ui64ErnsBrns); /*! ******************************************************************************* @Function RGXGetDeviceSLCBanks @Description Returns the number of SLC banks used by the device @Input hPrivate : Implementation specific data @Return Number of SLC banks ******************************************************************************/ IMG_UINT32 RGXGetDeviceSLCBanks(const void *hPrivate); /*! ******************************************************************************* @Function RGXGetDeviceSLCSize @Description Returns the device SLC size @Input hPrivate : Implementation specific data @Return SLC size ******************************************************************************/ IMG_UINT32 RGXGetDeviceSLCSize(const void *hPrivate); /*! ******************************************************************************* @Function RGXGetDeviceCacheLineSize @Description Returns the device cache line size @Input hPrivate : Implementation specific data @Return Cache line size ******************************************************************************/ IMG_UINT32 RGXGetDeviceCacheLineSize(const void *hPrivate); #if defined (__cplusplus) } #endif #endif /* !defined (__RGXLAYER_KM_H__) */