/* * Copyright (c) 2017, Intel Corporation * * 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. * * 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. 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. */ //! //! \file cm_hal_generic.h //! \brief Main Entry point for CM HAL Generic component //! #ifndef MEDIADRIVER_AGNOSTIC_COMMON_CM_CMHALGENERIC_H_ #define MEDIADRIVER_AGNOSTIC_COMMON_CM_CMHALGENERIC_H_ #include "cm_def.h" typedef struct CM_HAL_GENERIC * PCM_HAL_GENERIC; typedef struct _CM_HAL_SAMPLER_8X8_PARAM *PCM_HAL_SAMPLER_8X8_PARAM; typedef struct CmHalL3Settings * PCmHalL3Settings; //------------------------------- //| CM HW platform info //------------------------------- struct CM_PLATFORM_INFO { uint32_t numSlices; uint32_t numSubSlices; uint32_t numEUsPerSubSlice; uint32_t numHWThreadsPerEU; uint32_t numMaxEUsPerPool; }; typedef CM_PLATFORM_INFO *PCM_PLATFORM_INFO; struct CM_HAL_WALKER_XY { union { struct { uint32_t x : 16; uint32_t y : 16; }; uint32_t value; }; }; typedef CM_HAL_WALKER_XY *PCM_HAL_WALKER_XY; // The following enum type must match // MHW_WALKER_MODE defined in mhw_render.h enum CM_HAL_WALKER_MODE { CM_HAL_WALKER_MODE_NOT_SET = -1, CM_HAL_WALKER_MODE_DISABLED = 0, CM_HAL_WALKER_MODE_SINGLE = 1, // dual = 0, repel = 1 CM_HAL_WALKER_MODE_DUAL = 2, // dual = 1, repel = 0) CM_HAL_WALKER_MODE_TRI = 3, // applies in BDW GT2 which has 1 slice and 3 sampler/VME per slice CM_HAL_WALKER_MODE_QUAD = 4, // applies in HSW GT3 which has 2 slices and 2 sampler/VME per slice CM_HAL_WALKER_MODE_HEX = 6, // applies in BDW GT2 which has 2 slices and 3 sampler/VME per slice CM_HAL_WALKER_MODE_OCT = 8 // may apply in future Gen media architectures }; // The following structure must match the structure // MHW_WALKER_PARAMS defined in mhw_render.h struct CM_HAL_WALKER_PARAMS { uint32_t interfaceDescriptorOffset : 5; uint32_t cmWalkerEnable : 1; uint32_t colorCountMinusOne : 8; uint32_t useScoreboard : 1; uint32_t scoreboardMask : 8; uint32_t midLoopUnitX : 2; uint32_t midLoopUnitY : 2; uint32_t middleLoopExtraSteps : 5; uint32_t groupIdLoopSelect : 24; uint32_t : 8; uint32_t inlineDataLength; uint8_t *inlineData; uint32_t localLoopExecCount; uint32_t globalLoopExecCount; CM_HAL_WALKER_MODE walkerMode; CM_HAL_WALKER_XY blockResolution; CM_HAL_WALKER_XY localStart; CM_HAL_WALKER_XY localEnd; CM_HAL_WALKER_XY localOutLoopStride; CM_HAL_WALKER_XY localInnerLoopUnit; CM_HAL_WALKER_XY globalResolution; CM_HAL_WALKER_XY globalStart; CM_HAL_WALKER_XY globalOutlerLoopStride; CM_HAL_WALKER_XY globalInnerLoopUnit; bool addMediaFlush; bool requestSingleSlice; }; typedef CM_HAL_WALKER_PARAMS *PCM_HAL_WALKER_PARAMS; struct SamplerParam { unsigned int samplerTableIndex; unsigned int heapOffset; unsigned int bti; unsigned int btiStepping; unsigned int btiMultiplier; bool userDefinedBti; bool regularBti; unsigned int elementType; unsigned int size; }; struct CM_SURFACE_BTI_INFO { uint32_t normalSurfaceStart; // start index of normal surface uint32_t normalSurfaceEnd; // end index of normal surface uint32_t reservedSurfaceStart; // start index of reserved surface uint32_t reservedSurfaceEnd; // end index of reserved surface }; typedef CM_SURFACE_BTI_INFO *PCM_SURFACE_BTI_INFO; //------------------------------------------------------------------------------ //| CM HW Expected GT system info //------------------------------------------------------------------------------ struct CM_EXPECTED_GT_SYSTEM_INFO { uint32_t numSlices; uint32_t numSubSlices; }; typedef CM_EXPECTED_GT_SYSTEM_INFO *PCM_EXPECTED_GT_SYSTEM_INFO; struct CM_HAL_GENERIC { #define ASSIGN_IF_VALID(ptr, value) \ if (ptr) \ { \ *ptr = value; \ } public: PCM_HAL_STATE m_cmState; const L3ConfigRegisterValues *m_l3Plane = nullptr; size_t m_l3ConfigCount = 0; CM_HAL_GENERIC(PCM_HAL_STATE cmState) : m_cmState(cmState), m_platformID(PLATFORM_INTEL_UNKNOWN), m_genGT(PLATFORM_INTEL_GT_UNKNOWN), m_platformStr(nullptr), m_requestShutdownSubslicesForVmeUsage(false), m_overridePowerOptionPerGpuContext(false), m_redirectRcsToCcs(false), m_decompress(false), m_fastpathDefault(false), m_defaultMocs(MOS_CM_RESOURCE_USAGE_SurfaceState){}; virtual ~CM_HAL_GENERIC(){}; //! //! \brief Get GPUCopy Kernel's ISA and Size //! \details Get GPUCopy Kernel's ISA and Size //! \param [out] isa //! pointer to memory of gpucopy isa //! \param [out] isaSize //! size of gpucopy isa //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success, else fail reason //! virtual MOS_STATUS GetCopyKernelIsa(void *&isa, uint32_t &isaSize) = 0; //! //! \brief Get GPU Surface Initialization Kernel's ISA and Size //! \details Get GPU Surface Initialization Kernel's ISA and Size //! \param [out] isa //! pointer to memory of gpu initialization isa //! \param [out] isaSize //! size of gpu initialization isa //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success, else fail reason //! virtual MOS_STATUS GetInitKernelIsa(void *&isa, uint32_t &isaSize) = 0; //! //! \brief Set media walker parameters //! \details Set media walker parameters //! \param [in] engineeringParams //! engineering params passed by caller //! \param [in] walkerParams //! pointer to walker paramaeters to set //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success, else fail reason //! virtual MOS_STATUS SetMediaWalkerParams( CM_WALKING_PARAMETERS engineeringParams, PCM_HAL_WALKER_PARAMS walkerParams) = 0; //! //! \brief Set Surface Memory Object Control //! \details Convert Memory Object Control bits to RenderHal Surface State //! \param [in] memObjCtl //! memObjCtl passed by caller //! \param [in] surfStateParams //! pointer to surface state param //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success, else fail reason //! virtual MOS_STATUS HwSetSurfaceMemoryObjectControl( uint16_t memObjCtl, PRENDERHAL_SURFACE_STATE_PARAMS surfStateParams) = 0; //! //! \brief Register Sampler8x8 //! \details Register Sampler8x8 //! \param [in] param //! pointer to cmhal sampler8x8 param //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success, else fail reason //! virtual MOS_STATUS RegisterSampler8x8( PCM_HAL_SAMPLER_8X8_PARAM param) = 0; //! //! \brief Submit commmand to kernel mode driver //! \details Submit commmand to kernel mode driver //! \param [in] batchBuffer //! pointer to mhw batch buffer to submit //! \param [in] taskId //! id of task //! \param [in] kernelParam //! pointer to array of kernel param //! \param [out] cmdBuffer //! pointer cmd buffer returned to cm event //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success, else fail reason //! virtual MOS_STATUS SubmitCommands( PMHW_BATCH_BUFFER batchBuffer, int32_t taskId, PCM_HAL_KERNEL_PARAM *kernelParam, void ** cmdBuffer) = 0; #if (_RELEASE_INTERNAL || _DEBUG) #if defined(CM_DIRECT_GUC_SUPPORT) //! //! \brief Submit dummy commmand to kernel mode driver to set up page table for Direct submission //! \details Submit commmand to kernel mode driver //! \param [in] pBatchBuffer //! pointer to mhw batch buffer to submit //! \param [in] iTaskId //! id of task //! \param [out] ppCmdBuffer //! pointer cmd buffer returned to cm event //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success, else fail reason //! virtual MOS_STATUS SubmitDummyCommands( PMHW_BATCH_BUFFER batchBuffer, int32_t taskId, PCM_HAL_KERNEL_PARAM *kernelParam, void ** cmdBuffer) = 0; #endif #endif //! //! \brief Submit a commmand to get the time stamp base //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success, else fail reason //! virtual MOS_STATUS SubmitTimeStampBaseCommands() { return MOS_STATUS_SUCCESS; } //! //! \brief Update platform information from power option //! \details Power option can be used to do slice shutdown. This function is //! to adjust platform info (EU numbers/Slice number) accordingly. //! \param [in] platformInfo //! pointer to platform info //! \param [in] euSaturated //! if EU Saturation required. //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success, else fail reason //! virtual MOS_STATUS UpdatePlatformInfoFromPower( PCM_PLATFORM_INFO platformInfo, bool euSaturated) = 0; //! //! \brief Get media walker's max width //! \details Get media walker's max width //! \return media walker's max width //! virtual uint32_t GetMediaWalkerMaxThreadWidth() = 0; //! //! \brief Get media walker's max height //! \details Get media walker's max height //! \return media walker's max height //! virtual uint32_t GetMediaWalkerMaxThreadHeight() = 0; //! //! \brief Get Surface binding table index info //! \details Get Surface binding table index info, including the start/end index of //! reserved surfaces and normal surfaces //! \param [in] btiInfo //! pointer to binding table information //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success, else fail reason virtual MOS_STATUS GetHwSurfaceBTIInfo( PCM_SURFACE_BTI_INFO btiInfo) = 0; //! //! \brief Set Suggested L3 Configuration to RenderHal //! \details Set Suggested L3 Configuration to RenderHal //! \param [in] l3Config //! index of selected configuration //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success, else fail reason virtual MOS_STATUS SetSuggestedL3Conf( L3_SUGGEST_CONFIG l3Config) = 0; //! //! \brief Allocate SIP/CSR Resource for Preemption and Debug //! \details Allocate SIP/CSR Resource for Preemption and Debug //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success, else fail reason virtual MOS_STATUS AllocateSIPCSRResource() = 0; //! //! \brief Get the stepping string of Gen platform //! \details Get the stepping string of Gen platform //! \param [in,out] stepInfoStr //! reference to stepping information string //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success, else fail reason virtual MOS_STATUS GetGenStepInfo(char *&stepInfoStr) = 0; //! //! \brief Get the platform code and GT type of Gen platform //! \param [out] platformID //! pointer to the platform code defined in GPU_PLATFORM //! \param [out] gengt //! pointer to the GT type defined in GPU_GT_PLATFORM //! \param [out] platformStr //! pointer to platform string //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success, else fail reason virtual MOS_STATUS GetGenPlatformInfo(uint32_t *platformID, uint32_t * genGT, const char ** platformStr) { ASSIGN_IF_VALID(platformID, m_platformID); ASSIGN_IF_VALID(genGT, m_genGT); ASSIGN_IF_VALID(platformStr, m_platformStr); return MOS_STATUS_SUCCESS; } //! //! \brief set the platform code and GT type of Gen platform //! \param [in] platformID //! the platform code defined in GPU_PLATFORM //! \param [in] gengt //! the GT type defined in GPU_GT_PLATFORM //! \param [in] platformStr //! platform string //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success, else fail reason virtual MOS_STATUS SetGenPlatformInfo(uint32_t platformID, uint32_t genGT, const char * platformStr) { m_platformID = platformID; m_genGT = genGT; m_platformStr = platformStr; return MOS_STATUS_SUCCESS; } //! //! \brief enable or disable the slice downdown feature //! \param [in] enabled //! true: enable slice shutdown; false: disable slice shutdown virtual void SetRequestShutdownSubslicesForVmeUsage(bool enabled) { m_requestShutdownSubslicesForVmeUsage = enabled; } //! //! \brief return whether the slice downdown feature is enabled //! \return bool //! true: slice shutdown enabled; false: slice shutdown disabled virtual bool IsRequestShutdownSubslicesForVmeUsage() { return m_requestShutdownSubslicesForVmeUsage; } //! //! \brief check if the CISA Gen ID is supported on the platform //! \param [in] cisaGenID //! the CISA ID that will be checked //! \return bool //! true if it is supported; false if not virtual bool IsCisaIDSupported(uint32_t cisaGenID) { for (uint32_t id : m_cisaGenIDs) { if (id == cisaGenID) { return true; } } return false; } //! //! \brief add the supported CISA Gen IDs of this product //! \param [in] cisaGenIDs //! pointer to the vector of supported cisaGenIDs //! \param [in] len //! length of the vector of supported cisaGenIDs //! \return MOS_STATUS //! always return MOS_STATUS_SUCCESS virtual MOS_STATUS AddSupportedCisaIDs(uint32_t *cisaGenIDs, int len = 1) { for (int i = 0; i < len; i++) { m_cisaGenIDs.push_back(cisaGenIDs[i]); } return MOS_STATUS_SUCCESS; } //! //! \brief Check if Qpitch is supported by hw in surface 3d lock //! \details Check if Qpitch is supported by hw in surface 3d lock //! Qpitch is supported from SKL //! \return True for SKL+ virtual bool IsSurf3DQpitchSupportedbyHw() { return true; }; //! //! \brief Check if compare mask supported by hw in conditional buffer //! \details Check if compare mask supported by hw in conditional buffer //! compare mask is supported from SKL //! \return True for SKL+ virtual bool IsCompareMaskSupportedbyHw() { return true; }; //! //! \brief Check if two adjacent sampler index requried by hardware //! \details Check if two adjacent sampler index requried by hardware //! compare mask is supported from SKL //! \return True for BDW, and False for SKL+ virtual bool IsAdjacentSamplerIndexRequiredbyHw() { return false; }; //! //! \brief Check if the WA to disable surface compression required //! \details Check if the WA to disable surface compression required //! \return False for BDW, and True for SKL+ virtual bool IsSurfaceCompressionWARequired() { return true; }; //! //! \brief Check if scoreboading parameters are supported. //! \details Check if scoreboading parameters are supported. //! \return False for Not needed, and True for Needed virtual bool IsScoreboardParamNeeded() { return true; }; //! //! \brief Check if surface color format is supported by VME //! \return true if format is supported by VME surface virtual bool IsSupportedVMESurfaceFormat(MOS_FORMAT format) { if (format != Format_NV12) return false; else return true; } //! //! \brief Sanity check for ColorCount. //! \details Sanity check for ColorCount. //! ColorCountMinusOne varies from 4 bit to 8 bit on different platforms //! \return Result of the operation. virtual int32_t ColorCountSanityCheck(uint32_t colorCount) = 0; //! //! \brief Sanity check for memory object control policy. //! \details Sanity check for memory object control policy. //! Each platform supports different control policy. //! \param [in] memCtrl //! input of memory object control to check //! \return Result of the operation. virtual bool MemoryObjectCtrlPolicyCheck(uint32_t memCtrl) = 0; //! //! \brief Check if the WA to use No cache setting for GPUCopy surface required //! \details Check if the WA to use No cache setting for GPUCopy surface required //! Configure memory object control for the two BufferUP to solve the same //! cache-line coherency issue. //! \return False for BDW, and True for SKL+ virtual bool IsGPUCopySurfaceNoCacheWARequired() { return true; }; //! //! \brief Check if one plane P010 surface is supported. //! \details Check if one plane P010 surface is supported. //! one plane P010 surface is supported since CNL. //! \return False for pre-CNL, and True for CNL+ virtual bool IsP010SinglePassSupported() { return true; }; //! //! \brief Get Convolution Sampler Index. //! \details Get Convolution Sampler Index. //! \param [in] samplerParam //! pointer to sampler param //! \param [in] samplerIndexTable //! pointer to sampler index table //! \param [in] nSamp8X8Num //! number of sampler8x8 //! \param [in] nSampConvNum //! number of conv sampler //! \return Sampler index. virtual int32_t GetConvSamplerIndex( PMHW_SAMPLER_STATE_PARAM samplerParam, char * samplerIndexTable, int32_t nSamp8X8Num, int32_t nSampConvNum) = 0; //! //! \brief Set L3 values in CM hal layer. //! \details Use the L3 struct to set L3 to different platforms. //! \param [in] values //! pointer to input L3 config values //! \param [in] cmHalL3Setting //! pointer to hal layer L3 config values //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success, else fail reason virtual MOS_STATUS SetL3CacheConfig( const L3ConfigRegisterValues *values, PCmHalL3Settings cmHalL3Setting) = 0; //! //! \brief Get sampler element count for a given sampler type. //! \details Convert the sampler type to how many element for this sampler //! type for current platform. //! \param [in] mhwSamplerParam //! pointer to the sampler param defined by MHW //! \param [in,out] samplerParam //! Will get sampler size, sampler element type, sampler bti //! stepping and sampler multiplier for this type of sampler //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success, else fail reason virtual MOS_STATUS GetSamplerParamInfoForSamplerType( PMHW_SAMPLER_STATE_PARAM mhwSamplerParam, SamplerParam & samplerParam) = 0; //! //! \brief Get the expected configuration for specific GT //! \details Get the expected configuration for specific GT //! \param [in] expectedConfig //! pointer to expected config //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success, else fail reason //! virtual MOS_STATUS GetExpectedGtSystemConfig( PCM_EXPECTED_GT_SYSTEM_INFO expectedConfig) = 0; //! //! \brief Get the size of the timestamp resource for each task //! \details Get the size of the timestamp resource for each task //! \return int32_t //! Size of the timestamp resource for each task //! virtual int32_t GetTimeStampResourceSize() { // Default: 2 QWORDs for each kernel in the task + 1 QWORD for frame tracking return (sizeof(uint64_t) * CM_SYNC_QWORD_PER_TASK) + (sizeof(uint64_t) * CM_TRACKER_ID_QWORD_PER_TASK); } //! //! \brief Covnert the ticks to nano seconds with default config if KMD querying failed //! \param [in] ticks //! input ticks //! \return uint64_t //! Nano seconds converted from the input ticks //! virtual uint64_t ConverTicksToNanoSecondsDefault(uint64_t ticks) = 0; //! //! \brief Check if the platform has media mode or not //! \details Check if the platform has media mode or not //! \return bool //! true: the platform has media mode; false the platform //! does not have media mode. //! virtual bool CheckMediaModeAvailability() { return true; } //! //! \brief enable or disable the power option per GPU context //! \param [in] enabled //! true: enable per GPU context; false: disable per Batch command virtual void SetOverridePowerOptionPerGpuContext(bool enabled) { m_overridePowerOptionPerGpuContext = enabled; } //! //! \brief return whether the power option per GPU context is enabled //! \return bool //! true: enable per GPU context; false: disable per Batch command virtual bool IsOverridePowerOptionPerGpuContext() { return m_overridePowerOptionPerGpuContext; } //! //! \brief enable or disable redirect of RCS to CCS //! \param [in] enabled //! true: enable redirect of RCS to CCS; false: disable redirect of RCS to CCS virtual void SetRedirectRcsToCcs(bool enabled) { m_redirectRcsToCcs = enabled; } //! //! \brief return whether need redirect RCS to CCS //! \return bool //! true: redirect is need; false: don't need redirect virtual bool IsRedirectRcsToCcs() { return m_redirectRcsToCcs; } //! //! \brief enable or disable decompression flag //! \param [in] enabled //! true: enable decompression for surface; //! false: disable decompression virtual void SetDecompressFlag(bool enabled) { m_decompress = enabled; } //! //! \brief return whether the decompreesion option //! \return bool //! true: need to decompress a compressed surface; //! false: no need to decompress the compressed surface virtual bool GetDecompressFlag() { return m_decompress; } virtual MOS_STATUS RegisterResourceBeforeLock(PMOS_INTERFACE pOsInterface, PMOS_RESOURCE pResource) { return MOS_STATUS_SUCCESS; } //! //! \brief Init the default value of task related property //! \param [in,out] taskConfig //! Task related property //! \return MOS_STATUS_SUCCESS //! virtual MOS_STATUS InitTaskProperty(CM_TASK_CONFIG &taskConfig) { return MOS_STATUS_SUCCESS; } //! //! \brief Whether switch to fast path by default //! \return true or false //! virtual void SetFastPathByDefault(bool flag) { m_fastpathDefault = flag; } //! //! \brief Whether switch to fast path by default //! \return true or false //! virtual bool IsFastPathByDefault() { return m_fastpathDefault; } //! \brief Get the smallest max thread number that can be set in VFE //! \return the smallest max thread number //! virtual uint32_t GetSmallestMaxThreadNum() { return 1; } //! //! \brief Set the default MOCS for this platform //! \return void //! inline void SetDefaultMOCS(MOS_HW_RESOURCE_DEF mocs) { m_defaultMocs = mocs; } //! //! \brief Get the default MOCS for this platform //! \return the default MOCS //! inline MOS_HW_RESOURCE_DEF GetDefaultMOCS() { return m_defaultMocs; } //! \brief Check whether compressed output is needed //! \return true if compression format is needed //! virtual bool SupportCompressedOutput() { return false; } //! \brief Check whether separate scratch space is needed //! \return true if separate scratch is needed //! virtual bool IsSeparateScratch() { return false; } protected: uint32_t m_platformID; uint32_t m_genGT; const char * m_platformStr; std::vector m_cisaGenIDs; bool m_requestShutdownSubslicesForVmeUsage; bool m_overridePowerOptionPerGpuContext; bool m_redirectRcsToCcs; bool m_decompress; bool m_fastpathDefault; MOS_HW_RESOURCE_DEF m_defaultMocs; }; #endif // #ifndef MEDIADRIVER_AGNOSTIC_COMMON_CM_CMHALGENERIC_H_