| /*************************************************************************/ /*! |
| @File |
| @Title RGX firmware utility routines |
| @Copyright Copyright (c) Imagination Technologies Ltd. All Rights Reserved |
| @Description RGX firmware utility routines |
| @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(__RGXFWUTILS_H__) |
| #define __RGXFWUTILS_H__ |
| |
| #include "rgxdevice.h" |
| #include "rgxccb.h" |
| #include "devicemem.h" |
| #include "device.h" |
| #include "pvr_notifier.h" |
| #include "pvrsrv.h" |
| #include "connection_server.h" |
| #include "rgxta3d.h" |
| #include "devicemem_utils.h" |
| |
| #if defined(SUPPORT_TRUSTED_DEVICE) |
| #include "physmem_tdfwcode.h" |
| #include "physmem_tdsecbuf.h" |
| #endif |
| |
| |
| /* |
| * Firmware-only allocation (which are initialised by the host) must be aligned to the SLC cache line size. |
| * This is because firmware-only allocations are GPU_CACHE_INCOHERENT and this causes problems |
| * if two allocations share the same cache line; e.g. the initialisation of the second allocation won't |
| * make it into the SLC cache because it has been already loaded when accessing the content of the first allocation. |
| */ |
| static INLINE PVRSRV_ERROR DevmemFwAllocate(PVRSRV_RGXDEV_INFO *psDevInfo, |
| IMG_DEVMEM_SIZE_T uiSize, |
| DEVMEM_FLAGS_T uiFlags, |
| IMG_PCHAR pszText, |
| DEVMEM_MEMDESC **ppsMemDescPtr) |
| { |
| IMG_DEV_VIRTADDR sTmpDevVAddr; |
| PVRSRV_ERROR eError; |
| |
| PVR_DPF_ENTERED; |
| |
| #if defined(PVRSRV_GPUVIRT_GUESTDRV) |
| uiFlags |= PVRSRV_MEMALLOCFLAG_UNCACHED; |
| uiFlags &= ~PVRSRV_MEMALLOCFLAG_DEVICE_FLAG(FIRMWARE_CACHED); |
| #endif |
| |
| /* Ensure all RI labels begin 'Fw' for the FW heap. */ |
| PVR_ASSERT((pszText != NULL) && (pszText[0] == 'F') && (pszText[1] == 'w')); |
| |
| eError = DevmemAllocate(psDevInfo->psFirmwareHeap, |
| uiSize, |
| GET_ROGUE_CACHE_LINE_SIZE(psDevInfo->sDevFeatureCfg.ui32CacheLineSize), |
| uiFlags | PVRSRV_MEMALLOCFLAG_FW_LOCAL, |
| pszText, |
| ppsMemDescPtr); |
| if (eError != PVRSRV_OK) |
| { |
| PVR_DPF_RETURN_RC(eError); |
| } |
| |
| /* |
| We need to map it so the heap for this allocation |
| is set |
| */ |
| eError = DevmemMapToDevice(*ppsMemDescPtr, |
| psDevInfo->psFirmwareHeap, |
| &sTmpDevVAddr); |
| if (eError != PVRSRV_OK) |
| { |
| PVR_DPF_RETURN_RC(eError); |
| } |
| |
| |
| PVR_DPF_RETURN_RC(eError); |
| } |
| |
| static INLINE PVRSRV_ERROR DevmemFwAllocateExportable(PVRSRV_DEVICE_NODE *psDeviceNode, |
| IMG_DEVMEM_SIZE_T uiSize, |
| IMG_DEVMEM_ALIGN_T uiAlign, |
| DEVMEM_FLAGS_T uiFlags, |
| IMG_PCHAR pszText, |
| DEVMEM_MEMDESC **ppsMemDescPtr) |
| { |
| PVRSRV_RGXDEV_INFO *psDevInfo = (PVRSRV_RGXDEV_INFO *) psDeviceNode->pvDevice; |
| IMG_DEV_VIRTADDR sTmpDevVAddr; |
| PVRSRV_ERROR eError; |
| |
| #if defined(PVRSRV_GPUVIRT_GUESTDRV) |
| uiFlags |= PVRSRV_MEMALLOCFLAG_UNCACHED; |
| uiFlags &= ~PVRSRV_MEMALLOCFLAG_DEVICE_FLAG(FIRMWARE_CACHED); |
| #endif |
| |
| PVR_DPF_ENTERED; |
| |
| PVR_ASSERT((pszText != NULL) && |
| (pszText[0] == 'F') && (pszText[1] == 'w') && |
| (pszText[2] == 'E') && (pszText[3] == 'x')); |
| |
| eError = DevmemAllocateExportable(psDeviceNode, |
| uiSize, |
| uiAlign, |
| DevmemGetHeapLog2PageSize(psDevInfo->psFirmwareHeap), |
| uiFlags | PVRSRV_MEMALLOCFLAG_FW_LOCAL, |
| pszText, |
| ppsMemDescPtr); |
| if (eError != PVRSRV_OK) |
| { |
| PVR_DPF((PVR_DBG_ERROR,"FW DevmemAllocateExportable failed (%u)", eError)); |
| PVR_DPF_RETURN_RC(eError); |
| } |
| |
| /* |
| We need to map it so the heap for this allocation |
| is set |
| */ |
| eError = DevmemMapToDevice(*ppsMemDescPtr, |
| psDevInfo->psFirmwareHeap, |
| &sTmpDevVAddr); |
| if (eError != PVRSRV_OK) |
| { |
| PVR_DPF((PVR_DBG_ERROR,"FW DevmemMapToDevice failed (%u)", eError)); |
| } |
| |
| PVR_DPF_RETURN_RC1(eError, *ppsMemDescPtr); |
| } |
| |
| static void DevmemFWPoison(DEVMEM_MEMDESC *psMemDesc, IMG_BYTE ubPoisonValue) |
| { |
| void *pvLinAddr; |
| PVRSRV_ERROR eError; |
| |
| eError = DevmemAcquireCpuVirtAddr(psMemDesc, &pvLinAddr); |
| |
| if(eError != PVRSRV_OK) |
| { |
| PVR_DPF((PVR_DBG_ERROR, "%s: Failed to acquire FW allocation mapping " |
| "to poison: %s", |
| __func__, |
| PVRSRVGETERRORSTRING(eError))); |
| return; |
| } |
| |
| OSDeviceMemSet(pvLinAddr, ubPoisonValue, psMemDesc->uiAllocSize); |
| |
| DevmemReleaseCpuVirtAddr(psMemDesc); |
| } |
| |
| static INLINE void DevmemFwFree(PVRSRV_RGXDEV_INFO *psDevInfo, |
| DEVMEM_MEMDESC *psMemDesc) |
| { |
| PVR_DPF_ENTERED1(psMemDesc); |
| |
| if(psDevInfo->bEnableFWPoisonOnFree) |
| { |
| DevmemFWPoison(psMemDesc, psDevInfo->ubFWPoisonOnFreeValue); |
| } |
| |
| DevmemReleaseDevVirtAddr(psMemDesc); |
| DevmemFree(psMemDesc); |
| |
| PVR_DPF_RETURN; |
| } |
| |
| #if defined(SUPPORT_TRUSTED_DEVICE) |
| static INLINE |
| PVRSRV_ERROR DevmemImportTDFWCode(PVRSRV_DEVICE_NODE *psDeviceNode, |
| IMG_DEVMEM_SIZE_T uiSize, |
| PMR_LOG2ALIGN_T uiLog2Align, |
| IMG_UINT32 uiMemAllocFlags, |
| IMG_BOOL bFWCorememCode, |
| DEVMEM_MEMDESC **ppsMemDescPtr) |
| { |
| PVRSRV_RGXDEV_INFO *psDevInfo = (PVRSRV_RGXDEV_INFO *) psDeviceNode->pvDevice; |
| PMR *psTDFWCodePMR; |
| IMG_DEV_VIRTADDR sTmpDevVAddr; |
| IMG_DEVMEM_SIZE_T uiMemDescSize; |
| IMG_DEVMEM_ALIGN_T uiAlign = 1 << uiLog2Align; |
| PVRSRV_ERROR eError; |
| |
| PVR_ASSERT(ppsMemDescPtr); |
| |
| DevmemExportalignAdjustSizeAndAlign(DevmemGetHeapLog2PageSize(psDevInfo->psFirmwareHeap), |
| &uiSize, |
| &uiAlign); |
| |
| eError = PhysmemNewTDFWCodePMR(psDeviceNode, |
| uiSize, |
| uiLog2Align, |
| uiMemAllocFlags, |
| bFWCorememCode, |
| &psTDFWCodePMR); |
| if (eError != PVRSRV_OK) |
| { |
| PVR_DPF((PVR_DBG_ERROR, "PhysmemNewTDFWCodePMR failed (%u)", eError)); |
| goto PMRCreateError; |
| } |
| |
| /* NB: TDFWCodePMR refcount: 1 -> 2 */ |
| eError = DevmemLocalImport(psDeviceNode, |
| psTDFWCodePMR, |
| uiMemAllocFlags, |
| ppsMemDescPtr, |
| &uiMemDescSize, |
| "TDFWCode"); |
| if(eError != PVRSRV_OK) |
| { |
| goto ImportError; |
| } |
| |
| eError = DevmemMapToDevice(*ppsMemDescPtr, |
| psDevInfo->psFirmwareHeap, |
| &sTmpDevVAddr); |
| if(eError != PVRSRV_OK) |
| { |
| PVR_DPF((PVR_DBG_ERROR,"Failed to map TD META code PMR (%u)", eError)); |
| goto MapError; |
| } |
| |
| /* NB: TDFWCodePMR refcount: 2 -> 1 |
| * The PMR will be unreferenced again (and destroyed) when |
| * the memdesc tracking it is cleaned up |
| */ |
| PMRUnrefPMR(psTDFWCodePMR); |
| |
| return PVRSRV_OK; |
| |
| MapError: |
| DevmemFree(*ppsMemDescPtr); |
| *ppsMemDescPtr = NULL; |
| ImportError: |
| /* Unref and destroy the PMR */ |
| PMRUnrefPMR(psTDFWCodePMR); |
| PMRCreateError: |
| |
| return eError; |
| } |
| |
| static INLINE |
| PVRSRV_ERROR DevmemImportTDSecureBuf(PVRSRV_DEVICE_NODE *psDeviceNode, |
| IMG_DEVMEM_SIZE_T uiSize, |
| PMR_LOG2ALIGN_T uiLog2Align, |
| IMG_UINT32 uiMemAllocFlags, |
| DEVMEM_MEMDESC **ppsMemDescPtr, |
| IMG_UINT64 *pui64SecBufHandle) |
| { |
| PVRSRV_RGXDEV_INFO *psDevInfo = (PVRSRV_RGXDEV_INFO *) psDeviceNode->pvDevice; |
| PMR *psTDSecureBufPMR; |
| IMG_DEV_VIRTADDR sTmpDevVAddr; |
| IMG_DEVMEM_SIZE_T uiMemDescSize; |
| IMG_DEVMEM_ALIGN_T uiAlign = 1 << uiLog2Align; |
| PVRSRV_ERROR eError; |
| |
| PVR_ASSERT(ppsMemDescPtr); |
| |
| DevmemExportalignAdjustSizeAndAlign(DevmemGetHeapLog2PageSize(psDevInfo->psFirmwareHeap), |
| &uiSize, |
| &uiAlign); |
| |
| eError = PhysmemNewTDSecureBufPMR(NULL, |
| psDeviceNode, |
| uiSize, |
| uiLog2Align, |
| uiMemAllocFlags, |
| &psTDSecureBufPMR, |
| pui64SecBufHandle); |
| if (eError != PVRSRV_OK) |
| { |
| PVR_DPF((PVR_DBG_ERROR, "PhysmemNewTDSecureBufPMR failed (%u)", eError)); |
| goto PMRCreateError; |
| } |
| |
| /* NB: psTDSecureBufPMR refcount: 1 -> 2 */ |
| eError = DevmemLocalImport(psDeviceNode, |
| psTDSecureBufPMR, |
| uiMemAllocFlags, |
| ppsMemDescPtr, |
| &uiMemDescSize, |
| "TDSecureBuffer"); |
| if(eError != PVRSRV_OK) |
| { |
| goto ImportError; |
| } |
| |
| eError = DevmemMapToDevice(*ppsMemDescPtr, |
| psDevInfo->psFirmwareHeap, |
| &sTmpDevVAddr); |
| if(eError != PVRSRV_OK) |
| { |
| PVR_DPF((PVR_DBG_ERROR,"Failed to map TD secure buffer PMR (%u)", eError)); |
| goto MapError; |
| } |
| |
| /* NB: psTDSecureBufPMR refcount: 2 -> 1 |
| * The PMR will be unreferenced again (and destroyed) when |
| * the memdesc tracking it is cleaned up |
| */ |
| PMRUnrefPMR(psTDSecureBufPMR); |
| |
| return PVRSRV_OK; |
| |
| MapError: |
| DevmemFree(*ppsMemDescPtr); |
| *ppsMemDescPtr = NULL; |
| ImportError: |
| /* Unref and destroy the PMR */ |
| PMRUnrefPMR(psTDSecureBufPMR); |
| PMRCreateError: |
| |
| return eError; |
| } |
| #endif |
| |
| |
| /* |
| * This function returns the value of the hardware register RGX_CR_TIMER |
| * which is a timer counting in ticks. |
| */ |
| |
| static INLINE IMG_UINT64 RGXReadHWTimerReg(PVRSRV_RGXDEV_INFO *psDevInfo) |
| { |
| IMG_UINT64 ui64Time = OSReadHWReg64(psDevInfo->pvRegsBaseKM, RGX_CR_TIMER); |
| |
| /* |
| * In order to avoid having to issue three 32-bit reads to detect the |
| * lower 32-bits wrapping, the MSB of the low 32-bit word is duplicated |
| * in the MSB of the high 32-bit word. If the wrap happens, we just read |
| * the register again (it will not wrap again so soon). |
| */ |
| if ((ui64Time ^ (ui64Time << 32)) & ~RGX_CR_TIMER_BIT31_CLRMSK) |
| { |
| ui64Time = OSReadHWReg64(psDevInfo->pvRegsBaseKM, RGX_CR_TIMER); |
| } |
| |
| return ((ui64Time & ~RGX_CR_TIMER_VALUE_CLRMSK) >> RGX_CR_TIMER_VALUE_SHIFT); |
| } |
| |
| /* |
| * This FW Common Context is only mapped into kernel for initialisation and cleanup purposes. |
| * Otherwise this allocation is only used by the FW. |
| * Therefore the GPU cache doesn't need coherency, |
| * and write-combine is suffice on the CPU side (WC buffer will be flushed at the first kick) |
| */ |
| #define RGX_FWCOMCTX_ALLOCFLAGS (PVRSRV_MEMALLOCFLAG_DEVICE_FLAG(PMMETA_PROTECT) | \ |
| PVRSRV_MEMALLOCFLAG_DEVICE_FLAG(FIRMWARE_CACHED)| \ |
| PVRSRV_MEMALLOCFLAG_GPU_READABLE | \ |
| PVRSRV_MEMALLOCFLAG_GPU_WRITEABLE | \ |
| PVRSRV_MEMALLOCFLAG_GPU_CACHE_INCOHERENT | \ |
| PVRSRV_MEMALLOCFLAG_CPU_READABLE | \ |
| PVRSRV_MEMALLOCFLAG_CPU_WRITEABLE | \ |
| PVRSRV_MEMALLOCFLAG_CPU_WRITE_COMBINE | \ |
| PVRSRV_MEMALLOCFLAG_KERNEL_CPU_MAPPABLE | \ |
| PVRSRV_MEMALLOCFLAG_ZERO_ON_ALLOC) |
| |
| /****************************************************************************** |
| * RGXSetFirmwareAddress Flags |
| *****************************************************************************/ |
| #define RFW_FWADDR_FLAG_NONE (0) /*!< Void flag */ |
| #define RFW_FWADDR_NOREF_FLAG (1U << 0) /*!< It is safe to immediately release the reference to the pointer, |
| otherwise RGXUnsetFirmwareAddress() must be call when finished. */ |
| |
| IMG_BOOL RGXTraceBufferIsInitRequired(PVRSRV_RGXDEV_INFO *psDevInfo); |
| PVRSRV_ERROR RGXTraceBufferInitOnDemandResources(PVRSRV_RGXDEV_INFO *psDevInfo); |
| |
| PVRSRV_ERROR RGXSetupFirmware(PVRSRV_DEVICE_NODE *psDeviceNode, |
| IMG_BOOL bEnableSignatureChecks, |
| IMG_UINT32 ui32SignatureChecksBufSize, |
| IMG_UINT32 ui32HWPerfFWBufSizeKB, |
| IMG_UINT64 ui64HWPerfFilter, |
| IMG_UINT32 ui32RGXFWAlignChecksArrLength, |
| IMG_UINT32 *pui32RGXFWAlignChecks, |
| IMG_UINT32 ui32ConfigFlags, |
| IMG_UINT32 ui32LogType, |
| RGXFWIF_BIFTILINGMODE eBifTilingMode, |
| IMG_UINT32 ui32NumTilingCfgs, |
| IMG_UINT32 *pui32BIFTilingXStrides, |
| IMG_UINT32 ui32FilterFlags, |
| IMG_UINT32 ui32JonesDisableMask, |
| IMG_UINT32 ui32HWRDebugDumpLimit, |
| IMG_UINT32 ui32HWPerfCountersDataSize, |
| PMR **ppsHWPerfPMR, |
| RGXFWIF_DEV_VIRTADDR *psRGXFWInitFWAddr, |
| RGX_RD_POWER_ISLAND_CONF eRGXRDPowerIslandConf, |
| FW_PERF_CONF eFirmwarePerf); |
| |
| |
| |
| void RGXFreeFirmware(PVRSRV_RGXDEV_INFO *psDevInfo); |
| |
| /*************************************************************************/ /*! |
| @Function RGXSetFirmwareAddress |
| |
| @Description Sets a pointer in a firmware data structure. |
| |
| @Input ppDest Address of the pointer to set |
| @Input psSrc MemDesc describing the pointer |
| @Input ui32Flags Any combination of RFW_FWADDR_*_FLAG |
| |
| @Return void |
| */ /**************************************************************************/ |
| void RGXSetFirmwareAddress(RGXFWIF_DEV_VIRTADDR *ppDest, |
| DEVMEM_MEMDESC *psSrc, |
| IMG_UINT32 uiOffset, |
| IMG_UINT32 ui32Flags); |
| |
| |
| /*************************************************************************/ /*! |
| @Function RGXSetMetaDMAAddress |
| |
| @Description Fills a Firmware structure used to setup the Meta DMA with two |
| pointers to the same data, one on 40 bit and one on 32 bit |
| (pointer in the FW memory space). |
| |
| @Input ppDest Address of the structure to set |
| @Input psSrcMemDesc MemDesc describing the pointer |
| @Input psSrcFWDevVAddr Firmware memory space pointer |
| |
| @Return void |
| */ /**************************************************************************/ |
| void RGXSetMetaDMAAddress(RGXFWIF_DMA_ADDR *psDest, |
| DEVMEM_MEMDESC *psSrcMemDesc, |
| RGXFWIF_DEV_VIRTADDR *psSrcFWDevVAddr, |
| IMG_UINT32 uiOffset); |
| |
| |
| /*************************************************************************/ /*! |
| @Function RGXUnsetFirmwareAddress |
| |
| @Description Unsets a pointer in a firmware data structure |
| |
| @Input psSrc MemDesc describing the pointer |
| |
| @Return void |
| */ /**************************************************************************/ |
| void RGXUnsetFirmwareAddress(DEVMEM_MEMDESC *psSrc); |
| |
| /*************************************************************************/ /*! |
| @Function FWCommonContextAllocate |
| |
| @Description Allocate a FW common context. This allocates the HW memory |
| for the context, the CCB and wires it all together. |
| |
| @Input psConnection Connection this context is being created on |
| @Input psDeviceNode Device node to create the FW context on |
| (must be RGX device node) |
| @Input eRGXCCBRequestor RGX_CCB_REQUESTOR_TYPE enum constant which |
| which represents the requestor of this FWCC |
| @Input eDM Data Master type |
| @Input psAllocatedMemDesc Pointer to pre-allocated MemDesc to use |
| as the FW context or NULL if this function |
| should allocate it |
| @Input ui32AllocatedOffset Offset into pre-allocate MemDesc to use |
| as the FW context. If psAllocatedMemDesc |
| is NULL then this parameter is ignored |
| @Input psFWMemContextMemDesc MemDesc of the FW memory context this |
| common context resides on |
| @Input psContextStateMemDesc FW context state (context switch) MemDesc |
| @Input ui32CCBAllocSize Size of the CCB for this context |
| @Input ui32Priority Priority of the context |
| @Input psInfo Structure that contains extra info |
| required for the creation of the context |
| (elements might change from core to core) |
| @Return PVRSRV_OK if the context was successfully created |
| */ /**************************************************************************/ |
| PVRSRV_ERROR FWCommonContextAllocate(CONNECTION_DATA *psConnection, |
| PVRSRV_DEVICE_NODE *psDeviceNode, |
| RGX_CCB_REQUESTOR_TYPE eRGXCCBRequestor, |
| RGXFWIF_DM eDM, |
| DEVMEM_MEMDESC *psAllocatedMemDesc, |
| IMG_UINT32 ui32AllocatedOffset, |
| DEVMEM_MEMDESC *psFWMemContextMemDesc, |
| DEVMEM_MEMDESC *psContextStateMemDesc, |
| IMG_UINT32 ui32CCBAllocSize, |
| IMG_UINT32 ui32Priority, |
| RGX_COMMON_CONTEXT_INFO *psInfo, |
| RGX_SERVER_COMMON_CONTEXT **ppsServerCommonContext); |
| |
| |
| |
| void FWCommonContextFree(RGX_SERVER_COMMON_CONTEXT *psServerCommonContext); |
| |
| PRGXFWIF_FWCOMMONCONTEXT FWCommonContextGetFWAddress(RGX_SERVER_COMMON_CONTEXT *psServerCommonContext); |
| |
| RGX_CLIENT_CCB *FWCommonContextGetClientCCB(RGX_SERVER_COMMON_CONTEXT *psServerCommonContext); |
| |
| RGXFWIF_CONTEXT_RESET_REASON FWCommonContextGetLastResetReason(RGX_SERVER_COMMON_CONTEXT *psServerCommonContext, |
| IMG_UINT32 *pui32LastResetJobRef); |
| |
| /*! |
| ****************************************************************************** |
| |
| @Function RGXScheduleProcessQueuesKM |
| |
| @Description - Software command complete handler |
| (sends uncounted kicks for all the DMs through the MISR) |
| |
| @Input hCmdCompHandle - RGX device node |
| |
| ******************************************************************************/ |
| IMG_IMPORT |
| void RGXScheduleProcessQueuesKM(PVRSRV_CMDCOMP_HANDLE hCmdCompHandle); |
| |
| /*! |
| ****************************************************************************** |
| |
| @Function RGXInstallProcessQueuesMISR |
| |
| @Description - Installs the MISR to handle Process Queues operations |
| |
| @Input phMISR - Pointer to the MISR handler |
| |
| @Input psDeviceNode - RGX Device node |
| |
| ******************************************************************************/ |
| IMG_IMPORT |
| PVRSRV_ERROR RGXInstallProcessQueuesMISR(IMG_HANDLE *phMISR, PVRSRV_DEVICE_NODE *psDeviceNode); |
| |
| /*************************************************************************/ /*! |
| @Function RGXSendCommandWithPowLock |
| |
| @Description Sends a command to a particular DM without honouring |
| pending cache operations but taking the power lock. |
| |
| @Input psDevInfo Device Info |
| @Input eDM To which DM the cmd is sent. |
| @Input psKCCBCmd The cmd to send. |
| @Input ui32CmdSize The cmd size. |
| @Input ui32PDumpFlags Pdump flags |
| |
| @Return PVRSRV_ERROR |
| */ /**************************************************************************/ |
| PVRSRV_ERROR RGXSendCommandWithPowLock(PVRSRV_RGXDEV_INFO *psDevInfo, |
| RGXFWIF_DM eKCCBType, |
| RGXFWIF_KCCB_CMD *psKCCBCmd, |
| IMG_UINT32 ui32CmdSize, |
| IMG_UINT32 ui32PDumpFlags); |
| |
| /*************************************************************************/ /*! |
| @Function RGXSendCommand |
| |
| @Description Sends a command to a particular DM without honouring |
| pending cache operations or the power lock. |
| The function flushes any deferred KCCB commands first. |
| |
| @Input psDevInfo Device Info |
| @Input eDM To which DM the cmd is sent. |
| @Input psKCCBCmd The cmd to send. |
| @Input ui32CmdSize The cmd size. |
| @Input uiPdumpFlags PDump flags. |
| |
| @Return PVRSRV_ERROR |
| */ /**************************************************************************/ |
| PVRSRV_ERROR RGXSendCommand(PVRSRV_RGXDEV_INFO *psDevInfo, |
| RGXFWIF_DM eKCCBType, |
| RGXFWIF_KCCB_CMD *psKCCBCmd, |
| IMG_UINT32 ui32CmdSize, |
| PDUMP_FLAGS_T uiPdumpFlags); |
| |
| |
| /*************************************************************************/ /*! |
| @Function RGXScheduleCommand |
| |
| @Description Sends a command to a particular DM |
| |
| @Input psDevInfo Device Info |
| @Input eDM To which DM the cmd is sent. |
| @Input psKCCBCmd The cmd to send. |
| @Input ui32CmdSize The cmd size. |
| @Input ui32CacheOpFence Pending cache op. fence value. |
| @Input ui32PDumpFlags PDump flags |
| |
| @Return PVRSRV_ERROR |
| */ /**************************************************************************/ |
| PVRSRV_ERROR RGXScheduleCommand(PVRSRV_RGXDEV_INFO *psDevInfo, |
| RGXFWIF_DM eKCCBType, |
| RGXFWIF_KCCB_CMD *psKCCBCmd, |
| IMG_UINT32 ui32CmdSize, |
| IMG_UINT32 ui32CacheOpFence, |
| IMG_UINT32 ui32PDumpFlags); |
| |
| /*************************************************************************/ /*! |
| @Function RGXScheduleCommandAndWait |
| |
| @Description Schedules the command with RGXScheduleCommand and then waits |
| for the FW to update a sync. The sync must be piggy backed on |
| the cmd, either by passing a sync cmd or a cmd that contains the |
| sync which the FW will eventually update. The sync is created in |
| the function, therefore the function provides a FWAddr and |
| UpdateValue for that cmd. |
| |
| @Input psDevInfo Device Info |
| @Input eDM To which DM the cmd is sent. |
| @Input psKCCBCmd The cmd to send. |
| @Input ui32CmdSize The cmd size. |
| @Input puiSyncObjFWAddr Pointer to the location with the FWAddr of |
| the sync. |
| @Input puiUpdateValue Pointer to the location with the update |
| value of the sync. |
| @Input ui32PDumpFlags PDump flags |
| |
| @Return PVRSRV_ERROR |
| */ /**************************************************************************/ |
| PVRSRV_ERROR RGXScheduleCommandAndWait(PVRSRV_RGXDEV_INFO *psDevInfo, |
| RGXFWIF_DM eDM, |
| RGXFWIF_KCCB_CMD *psKCCBCmd, |
| IMG_UINT32 ui32CmdSize, |
| IMG_UINT32 *puiSyncObjDevVAddr, |
| IMG_UINT32 *puiUpdateValue, |
| PVRSRV_CLIENT_SYNC_PRIM *psSyncPrim, |
| IMG_UINT32 ui32PDumpFlags); |
| |
| PVRSRV_ERROR RGXFirmwareUnittests(PVRSRV_RGXDEV_INFO *psDevInfo); |
| |
| |
| /*! ***********************************************************************//** |
| @brief Copy framework command into FW addressable buffer |
| |
| @param psFWFrameworkMemDesc |
| @param pbyGPUFRegisterList |
| @param ui32FrameworkRegisterSize |
| |
| @returns PVRSRV_ERROR |
| */ /**************************************************************************/ |
| PVRSRV_ERROR PVRSRVRGXFrameworkCopyCommand(DEVMEM_MEMDESC *psFWFrameworkMemDesc, |
| IMG_PBYTE pbyGPUFRegisterList, |
| IMG_UINT32 ui32FrameworkRegisterSize); |
| |
| |
| /*! ***********************************************************************//** |
| @brief Create FW addressable buffer for framework |
| |
| @param psDeviceNode |
| @param ppsFWFrameworkMemDesc |
| @param ui32FrameworkRegisterSize |
| |
| @returns PVRSRV_ERROR |
| */ /**************************************************************************/ |
| PVRSRV_ERROR PVRSRVRGXFrameworkCreateKM(PVRSRV_DEVICE_NODE * psDeviceNode, |
| DEVMEM_MEMDESC ** ppsFWFrameworkMemDesc, |
| IMG_UINT32 ui32FrameworkRegisterSize); |
| |
| /*************************************************************************/ /*! |
| @Function RGXWaitForFWOp |
| |
| @Description Send a sync command and wait to be signalled. |
| |
| @Input psDevInfo Device Info |
| @Input eDM To which DM the cmd is sent. |
| @Input ui32PDumpFlags PDump flags |
| |
| @Return void |
| */ /**************************************************************************/ |
| PVRSRV_ERROR RGXWaitForFWOp(PVRSRV_RGXDEV_INFO *psDevInfo, |
| RGXFWIF_DM eDM, |
| PVRSRV_CLIENT_SYNC_PRIM *psSyncPrim, |
| IMG_UINT32 ui32PDumpFlags); |
| |
| /*************************************************************************/ /*! |
| @Function RGXStateFlagCtrl |
| |
| @Description Set and return FW internal state flags. |
| |
| @Input psDevInfo Device Info |
| @Input ui32Config AppHint config flags |
| @Output pui32State Current AppHint state flag configuration |
| @Input bSetNotClear Set or clear the provided config flags |
| |
| @Return PVRSRV_ERROR |
| */ /**************************************************************************/ |
| PVRSRV_ERROR RGXStateFlagCtrl(PVRSRV_RGXDEV_INFO *psDevInfo, |
| IMG_UINT32 ui32Config, |
| IMG_UINT32 *pui32State, |
| IMG_BOOL bSetNotClear); |
| |
| /*! |
| ****************************************************************************** |
| |
| @Function RGXFWRequestCommonContextCleanUp |
| |
| @Description Schedules a FW common context cleanup. The firmware will doesn't |
| block waiting for the resource to become idle but rather notifies |
| the host that the resources is busy. |
| |
| @Input psDeviceNode - pointer to device node |
| |
| @Input psFWContext - firmware address of the context to be cleaned up |
| |
| @Input eDM - Data master, to which the cleanup command should be send |
| |
| @Input ui32PDumpFlags - PDump continuous flag |
| |
| ******************************************************************************/ |
| PVRSRV_ERROR RGXFWRequestCommonContextCleanUp(PVRSRV_DEVICE_NODE *psDeviceNode, |
| RGX_SERVER_COMMON_CONTEXT *psServerCommonContext, |
| PVRSRV_CLIENT_SYNC_PRIM *psSyncPrim, |
| RGXFWIF_DM eDM, |
| IMG_UINT32 ui32PDumpFlags); |
| |
| /*! |
| ****************************************************************************** |
| |
| @Function RGXFWRequestHWRTDataCleanUp |
| |
| @Description Schedules a FW HWRTData memory cleanup. The firmware will doesn't |
| block waiting for the resource to become idle but rather notifies |
| the host that the resources is busy. |
| |
| @Input psDeviceNode - pointer to device node |
| |
| @Input psHWRTData - firmware address of the HWRTData to be cleaned up |
| |
| @Input eDM - Data master, to which the cleanup command should be send |
| |
| ******************************************************************************/ |
| PVRSRV_ERROR RGXFWRequestHWRTDataCleanUp(PVRSRV_DEVICE_NODE *psDeviceNode, |
| PRGXFWIF_HWRTDATA psHWRTData, |
| PVRSRV_CLIENT_SYNC_PRIM *psSync, |
| RGXFWIF_DM eDM); |
| |
| PVRSRV_ERROR RGXFWRequestRayFrameDataCleanUp(PVRSRV_DEVICE_NODE *psDeviceNode, |
| PRGXFWIF_RAY_FRAME_DATA psHWFrameData, |
| PVRSRV_CLIENT_SYNC_PRIM *psSync, |
| RGXFWIF_DM eDM); |
| |
| /*! |
| ****************************************************************************** |
| |
| @Function RGXFWRequestRPMFreeListCleanUp |
| |
| @Description Schedules a FW RPM FreeList cleanup. The firmware will doesn't block |
| waiting for the resource to become idle but rather notifies the |
| host that the resources is busy. |
| |
| @Input psDeviceNode - pointer to device node |
| |
| @Input psFWRPMFreeList - firmware address of the RPM freelist to be cleaned up |
| |
| @Input psSync - Sync object associated with cleanup |
| |
| ******************************************************************************/ |
| PVRSRV_ERROR RGXFWRequestRPMFreeListCleanUp(PVRSRV_RGXDEV_INFO *psDevInfo, |
| PRGXFWIF_RPM_FREELIST psFWRPMFreeList, |
| PVRSRV_CLIENT_SYNC_PRIM *psSync); |
| |
| |
| /*! |
| ****************************************************************************** |
| |
| @Function RGXFWRequestFreeListCleanUp |
| |
| @Description Schedules a FW FreeList cleanup. The firmware will doesn't block |
| waiting for the resource to become idle but rather notifies the |
| host that the resources is busy. |
| |
| @Input psDeviceNode - pointer to device node |
| |
| @Input psHWRTData - firmware address of the HWRTData to be cleaned up |
| |
| @Input eDM - Data master, to which the cleanup command should be send |
| |
| ******************************************************************************/ |
| PVRSRV_ERROR RGXFWRequestFreeListCleanUp(PVRSRV_RGXDEV_INFO *psDeviceNode, |
| PRGXFWIF_FREELIST psFWFreeList, |
| PVRSRV_CLIENT_SYNC_PRIM *psSync); |
| |
| /*! |
| ****************************************************************************** |
| |
| @Function RGXFWRequestZSBufferCleanUp |
| |
| @Description Schedules a FW ZS Buffer cleanup. The firmware will doesn't block |
| waiting for the resource to become idle but rather notifies the |
| host that the resources is busy. |
| |
| @Input psDeviceNode - pointer to device node |
| |
| @Input psFWZSBuffer - firmware address of the ZS Buffer to be cleaned up |
| |
| @Input eDM - Data master, to which the cleanup command should be send |
| |
| ******************************************************************************/ |
| |
| PVRSRV_ERROR RGXFWRequestZSBufferCleanUp(PVRSRV_RGXDEV_INFO *psDevInfo, |
| PRGXFWIF_ZSBUFFER psFWZSBuffer, |
| PVRSRV_CLIENT_SYNC_PRIM *psSync); |
| |
| PVRSRV_ERROR ContextSetPriority(RGX_SERVER_COMMON_CONTEXT *psContext, |
| CONNECTION_DATA *psConnection, |
| PVRSRV_RGXDEV_INFO *psDevInfo, |
| IMG_UINT32 ui32Priority, |
| RGXFWIF_DM eDM); |
| |
| /*! |
| ****************************************************************************** |
| |
| @Function RGXFWSetHCSDeadline |
| |
| @Description Requests the Firmware to set a new Hard Context |
| Switch timeout deadline. Context switches that |
| surpass that deadline cause the system to kill |
| the currently running workloads. |
| |
| @Input psDeviceNode pointer to device node |
| |
| @Input ui32HCSDeadlineMs The deadline in milliseconds. |
| ******************************************************************************/ |
| PVRSRV_ERROR RGXFWSetHCSDeadline(PVRSRV_RGXDEV_INFO *psDevInfo, |
| IMG_UINT32 ui32HCSDeadlineMs); |
| |
| /*! |
| ****************************************************************************** |
| |
| @Function RGXFWChangeOSidPriority |
| |
| @Description Requests the Firmware to change the priority of an |
| operating system. Higher priority number equals |
| higher priority on the scheduling system. |
| |
| @Input psDeviceNode pointer to device node |
| |
| @Input ui32OSid The OSid whose priority is to be altered |
| |
| @Input ui32Priority The new priority number for the specified OSid |
| ******************************************************************************/ |
| PVRSRV_ERROR RGXFWChangeOSidPriority(PVRSRV_RGXDEV_INFO *psDevInfo, |
| IMG_UINT32 ui32OSid, |
| IMG_UINT32 ui32Priority); |
| |
| /*! |
| **************************************************************************** |
| |
| @Function RGXFWSetOSIsolationThreshold |
| |
| @Description Requests the Firmware to change the priority |
| threshold of the OS Isolation group. Any OS with a |
| priority higher or equal than the threshold is |
| considered to be belonging to the isolation group. |
| |
| @Input psDeviceNode pointer to device node |
| |
| @Input ui32IsolationPriorityThreshold The new priority threshold |
| ***************************************************************************/ |
| PVRSRV_ERROR RGXFWSetOSIsolationThreshold(PVRSRV_RGXDEV_INFO *psDevInfo, |
| IMG_UINT32 ui32IsolationPriorityThreshold); |
| |
| /*! |
| **************************************************************************** |
| |
| @Function RGXFWOSConfig |
| |
| @Description Sends the OS Init structure to the FW to complete |
| the initialization process. The FW will then set all |
| the OS specific parameters for that DDK |
| |
| @Input psDeviceNode pointer to device node |
| ***************************************************************************/ |
| PVRSRV_ERROR RGXFWOSConfig(PVRSRV_RGXDEV_INFO *psDevInfo); |
| |
| /*! |
| **************************************************************************** |
| |
| @Function RGXFWSetVMOnlineState |
| |
| @Description Requests the Firmware to change the guest OS Online |
| states. This should be initiated by the VMM when a |
| guest VM comes online or goes offline. If offline, |
| the FW offloads any current resource from that OSID. |
| The request is repeated until the FW has had time to |
| free all the resources or has waited for workloads |
| to finish. |
| |
| @Input psDeviceNode pointer to device node |
| |
| @Input ui32OSid The Guest OSid whose state is being altered |
| |
| @Input eOSOnlineState The new state (Online or Offline) |
| ***************************************************************************/ |
| PVRSRV_ERROR RGXFWSetVMOnlineState(PVRSRV_RGXDEV_INFO *psDevInfo, |
| IMG_UINT32 ui32OSid, |
| RGXFWIF_OS_STATE_CHANGE eOSOnlineState); |
| /*! |
| ****************************************************************************** |
| |
| @Function RGXReadMETAAddr |
| |
| @Description Reads a value at given address in META memory space |
| (it can be either a memory location or a META register) |
| |
| @Input psDevInfo - pointer to device info |
| |
| @Input ui32METAAddr - address in META memory space |
| |
| @Output pui32Value - value |
| |
| ******************************************************************************/ |
| |
| PVRSRV_ERROR RGXReadMETAAddr(PVRSRV_RGXDEV_INFO *psDevInfo, |
| IMG_UINT32 ui32METAAddr, |
| IMG_UINT32 *pui32Value); |
| |
| /*! |
| ****************************************************************************** |
| |
| @Function RGXCheckFirmwareCCB |
| |
| @Description Processes all commands that are found in the Firmware CCB. |
| |
| @Input psDevInfo - pointer to device |
| |
| ******************************************************************************/ |
| void RGXCheckFirmwareCCB(PVRSRV_RGXDEV_INFO *psDevInfo); |
| |
| /*! |
| ****************************************************************************** |
| |
| @Function RGXUpdateHealthStatus |
| |
| @Description Tests a number of conditions which might indicate a fatal error has |
| occurred in the firmware. The result is stored in the device node |
| eheathStatus. |
| |
| @Input psDevNode Pointer to device node structure. |
| @Input bCheckAfterTimePassed When TRUE, the function will also test for |
| firmware queues and polls not changing |
| since the previous test. |
| |
| Note: if not enough time has passed since |
| the last call, false positives may occur. |
| |
| @returns PVRSRV_ERROR |
| ******************************************************************************/ |
| PVRSRV_ERROR RGXUpdateHealthStatus(PVRSRV_DEVICE_NODE* psDevNode, |
| IMG_BOOL bCheckAfterTimePassed); |
| |
| |
| PVRSRV_ERROR CheckStalledClientCommonContext(RGX_SERVER_COMMON_CONTEXT *psCurrentServerCommonContext, RGX_KICK_TYPE_DM eKickTypeDM); |
| |
| void DumpStalledFWCommonContext(RGX_SERVER_COMMON_CONTEXT *psCurrentServerCommonContext, |
| DUMPDEBUG_PRINTF_FUNC *pfnDumpDebugPrintf, |
| void *pvDumpDebugFile); |
| |
| /*! |
| ****************************************************************************** |
| |
| @Function AttachKickResourcesCleanupCtls |
| |
| @Description Attaches the cleanup structures to a kick command so that |
| submission reference counting can be performed when the |
| firmware processes the command |
| |
| @Output apsCleanupCtl Array of CleanupCtl structure pointers to populate. |
| @Output pui32NumCleanupCtl Number of CleanupCtl structure pointers written out. |
| @Input eDM Which data master is the subject of the command. |
| @Input bKick TRUE if the client originally wanted to kick this DM. |
| @Input psRTDataCleanup Optional RTData cleanup associated with the command. |
| @Input psZBuffer Optional ZBuffer associated with the command. |
| @Input psSBuffer Optional SBuffer associated with the command. |
| ******************************************************************************/ |
| void AttachKickResourcesCleanupCtls(PRGXFWIF_CLEANUP_CTL *apsCleanupCtl, |
| IMG_UINT32 *pui32NumCleanupCtl, |
| RGXFWIF_DM eDM, |
| IMG_BOOL bKick, |
| RGX_RTDATA_CLEANUP_DATA *psRTDataCleanup, |
| RGX_ZSBUFFER_DATA *psZBuffer, |
| RGX_ZSBUFFER_DATA *psSBuffer); |
| |
| /*! |
| ****************************************************************************** |
| |
| @Function RGXResetHWRLogs |
| |
| @Description Resets the HWR Logs buffer (the hardware recovery count is not reset) |
| |
| @Input psDevInfo Pointer to the device |
| |
| @Return PVRSRV_ERROR PVRSRV_OK on success. Otherwise, a PVRSRV_ |
| error code |
| ******************************************************************************/ |
| PVRSRV_ERROR RGXResetHWRLogs(PVRSRV_DEVICE_NODE *psDevNode); |
| |
| |
| /*! |
| ****************************************************************************** |
| |
| @Function RGXGetPhyAddr |
| |
| @Description Get the physical address of a certain PMR at a certain offset within it |
| |
| @Input psPMR PMR of the allocation |
| |
| @Input ui32LogicalOffset Logical offset |
| |
| @Output psPhyAddr Physical address of the allocation |
| |
| @Return PVRSRV_ERROR PVRSRV_OK on success. Otherwise, a PVRSRV_ |
| error code |
| ******************************************************************************/ |
| PVRSRV_ERROR RGXGetPhyAddr(PMR *psPMR, |
| IMG_DEV_PHYADDR *psPhyAddr, |
| IMG_UINT32 ui32LogicalOffset, |
| IMG_UINT32 ui32Log2PageSize, |
| IMG_UINT32 ui32NumOfPages, |
| IMG_BOOL *bValid); |
| |
| #if defined(PDUMP) |
| /*! |
| ****************************************************************************** |
| |
| @Function RGXPdumpDrainKCCB |
| |
| @Description Wait for the firmware to execute all the commands in the kCCB |
| |
| @Input psDevInfo Pointer to the device |
| |
| @Input ui32WriteOffset Woff we have to POL for the Roff to be equal to |
| |
| @Return PVRSRV_ERROR PVRSRV_OK on success. Otherwise, a PVRSRV_ |
| error code |
| ******************************************************************************/ |
| PVRSRV_ERROR RGXPdumpDrainKCCB(PVRSRV_RGXDEV_INFO *psDevInfo, IMG_UINT32 ui32WriteOffset); |
| #endif /* PDUMP */ |
| |
| |
| #endif /* __RGXFWUTILS_H__ */ |
| /****************************************************************************** |
| End of file (rgxfwutils.h) |
| ******************************************************************************/ |
