| /*************************************************************************/ /*! |
| @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__) */ |
| |
