1 /* 2 * Copyright (c) 2021-2024, Intel Corporation 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice shall be included 12 * in all copies or substantial portions of the Software. 13 * 14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 20 * OTHER DEALINGS IN THE SOFTWARE. 21 */ 22 //! 23 //! \file mhw_render_impl.h 24 //! \brief MHW RENDER interface common base 25 //! \details 26 //! 27 28 #ifndef __MHW_RENDER_IMPL_H__ 29 #define __MHW_RENDER_IMPL_H__ 30 31 #include "mhw_render_itf.h" 32 #include "mhw_impl.h" 33 #include "mhw_mmio.h" 34 35 #ifdef IGFX_RENDER_INTERFACE_EXT_SUPPORT 36 #include "mhw_render_impl_ext.h" 37 #endif 38 39 namespace mhw 40 { 41 namespace render 42 { 43 44 template <typename cmd_t> 45 class Impl : public Itf, public mhw::Impl 46 { 47 _RENDER_CMD_DEF(_MHW_CMD_ALL_DEF_FOR_IMPL); 48 49 public: EnableL3Caching(MHW_RENDER_ENGINE_L3_CACHE_SETTINGS * cacheSettings)50 MOS_STATUS EnableL3Caching(MHW_RENDER_ENGINE_L3_CACHE_SETTINGS *cacheSettings) override 51 { 52 return MOS_STATUS_SUCCESS; 53 } 54 SetL3Cache(PMOS_COMMAND_BUFFER cmdBuffer,std::shared_ptr<mhw::mi::Itf> miItf)55 MOS_STATUS SetL3Cache(PMOS_COMMAND_BUFFER cmdBuffer, std::shared_ptr<mhw::mi::Itf> miItf) override 56 { 57 return MOS_STATUS_SUCCESS; 58 } 59 InitMmioRegisters()60 MOS_STATUS InitMmioRegisters() override 61 { 62 return MOS_STATUS_SUCCESS; 63 } 64 GetMmioRegisters()65 PMHW_MI_MMIOREGISTERS GetMmioRegisters() override 66 { 67 return &m_mmioRegisters; 68 } 69 GetL3CacheConfig()70 MHW_RENDER_ENGINE_L3_CACHE_CONFIG* GetL3CacheConfig() override 71 { 72 return &m_l3CacheConfig; 73 } 74 SetupInlineData()75 MOS_STATUS SetupInlineData() override 76 { 77 return MOS_STATUS_SUCCESS; 78 } 79 80 protected: 81 using base_t = Itf; 82 83 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_cacheabilitySettings[MOS_HW_RESOURCE_DEF_MAX] = {}; 84 MHW_MI_MMIOREGISTERS m_mmioRegisters = {}; 85 MHW_RENDER_ENGINE_L3_CACHE_CONFIG m_l3CacheConfig = {}; 86 87 bool m_preemptionEnabled = false; 88 uint32_t m_preemptionCntlRegisterOffset = 0; 89 uint32_t m_preemptionCntlRegisterValue = 0; 90 MHW_STATE_HEAP_INTERFACE *m_stateHeapInterface = nullptr; 91 MHW_RENDER_ENGINE_CAPS m_hwCaps = {}; 92 uint8_t m_heapMode = MHW_RENDER_HAL_MODE; 93 Impl(PMOS_INTERFACE osItf)94 Impl(PMOS_INTERFACE osItf) : mhw::Impl(osItf) 95 { 96 MHW_FUNCTION_ENTER; 97 98 if (!osItf->bUsesGfxAddress && !osItf->bUsesPatchList) 99 { 100 MHW_ASSERTMESSAGE("No valid addressing mode indicated"); 101 return; 102 } 103 104 m_stateHeapInterface = nullptr; 105 106 MEDIA_SYSTEM_INFO *gtSystemInfo = osItf->pfnGetGtSystemInfo(osItf); 107 108 InitPlatformCaps(gtSystemInfo); 109 110 InitPreemption(); 111 112 if (Mhw_StateHeapInterface_InitInterface( 113 &m_stateHeapInterface, 114 osItf, 115 m_heapMode) != MOS_STATUS_SUCCESS) 116 { 117 MHW_ASSERTMESSAGE("State heap initialization failed!"); 118 return; 119 } 120 } 121 ~Impl()122 ~Impl() 123 { 124 MHW_FUNCTION_ENTER; 125 126 if (m_stateHeapInterface) 127 { 128 m_stateHeapInterface->pfnDestroy(m_stateHeapInterface); 129 } 130 } 131 InitMocsParams(MHW_RESOURCE_PARAMS & hwResourceParam,uint32_t * addr,uint8_t bitFieldLow,uint8_t bitFieldHigh)132 void inline InitMocsParams( 133 MHW_RESOURCE_PARAMS& hwResourceParam, 134 uint32_t* addr, 135 uint8_t bitFieldLow, 136 uint8_t bitFieldHigh) 137 { 138 hwResourceParam.mocsParams.mocsTableIndex = addr; 139 hwResourceParam.mocsParams.bitFieldLow = bitFieldLow; 140 hwResourceParam.mocsParams.bitFieldHigh = bitFieldHigh; 141 return; 142 } 143 144 public: 145 146 //! 147 //! \brief Allocates the MHW render interface internal parameters 148 //! \details Internal MHW function to allocate all parameters needed for the 149 //! render interface including the state heap interface 150 //! \param MHW_STATE_HEAP_SETTINGS stateHeapSettings 151 //! [in] Setting used to initialize the state heap interface 152 //! \return MOS_STATUS 153 //! MOS_STATUS_SUCCESS if success, else fail reason 154 //! AllocateHeaps(MHW_STATE_HEAP_SETTINGS stateHeapSettings)155 MOS_STATUS AllocateHeaps( 156 MHW_STATE_HEAP_SETTINGS stateHeapSettings) override 157 { 158 MOS_STATUS eStatus = MOS_STATUS_SUCCESS; 159 MHW_STATE_HEAP_INTERFACE *stateHeapInterface = nullptr; 160 161 MHW_FUNCTION_ENTER; 162 163 if ((stateHeapSettings.dwIshSize > 0 || 164 stateHeapSettings.dwDshSize > 0 ) && 165 stateHeapSettings.dwNumSyncTags > 0) 166 { 167 MHW_MI_CHK_STATUS(m_stateHeapInterface->pfnCreate( 168 &m_stateHeapInterface, 169 stateHeapSettings)); 170 } 171 172 return eStatus; 173 } 174 GetStateHeapInterface()175 PMHW_STATE_HEAP_INTERFACE GetStateHeapInterface() override 176 { 177 MHW_FUNCTION_ENTER; 178 179 return m_stateHeapInterface; 180 } 181 InitPlatformCaps(MEDIA_SYSTEM_INFO * gtSystemInfo)182 void InitPlatformCaps( 183 MEDIA_SYSTEM_INFO *gtSystemInfo) 184 { 185 if (gtSystemInfo == nullptr) 186 { 187 MHW_ASSERTMESSAGE("Invalid input pointer provided"); 188 return; 189 } 190 191 MOS_ZeroMemory(&m_hwCaps, sizeof(MHW_RENDER_ENGINE_CAPS)); 192 193 m_hwCaps.dwMaxUnormSamplers = MHW_RENDER_ENGINE_SAMPLERS_MAX; 194 m_hwCaps.dwMaxAVSSamplers = MHW_RENDER_ENGINE_SAMPLERS_AVS_MAX; 195 m_hwCaps.dwMaxBTIndex = MHW_RENDER_ENGINE_SSH_SURFACES_PER_BT_MAX - 1; 196 m_hwCaps.dwMaxThreads = gtSystemInfo->ThreadCount; 197 m_hwCaps.dwMaxMediaPayloadSize = MHW_RENDER_ENGINE_MEDIA_PALOAD_SIZE_MAX; 198 m_hwCaps.dwMaxURBSize = MHW_RENDER_ENGINE_URB_SIZE_MAX; 199 m_hwCaps.dwMaxURBEntries = MHW_RENDER_ENGINE_URB_ENTRIES_MAX; 200 m_hwCaps.dwMaxSubslice = gtSystemInfo->MaxSubSlicesSupported; 201 m_hwCaps.dwMaxEUIndex = MHW_RENDER_ENGINE_EU_INDEX_MAX; 202 m_hwCaps.dwNumThreadsPerEU = (gtSystemInfo->EUCount > 0) ? 203 gtSystemInfo->ThreadCount / gtSystemInfo->EUCount : 0; 204 m_hwCaps.dwSizeRegistersPerThread = MHW_RENDER_ENGINE_SIZE_REGISTERS_PER_THREAD; 205 206 m_hwCaps.dwMaxInterfaceDescriptorEntries = MHW_RENDER_ENGINE_INTERFACE_DESCRIPTOR_ENTRIES_MAX; 207 m_hwCaps.dwMaxURBEntryAllocationSize = 208 m_hwCaps.dwMaxCURBEAllocationSize = 209 m_hwCaps.dwMaxURBSize - m_hwCaps.dwMaxInterfaceDescriptorEntries; 210 } 211 InitPreemption()212 void InitPreemption() 213 { 214 MHW_FUNCTION_ENTER; 215 MHW_CHK_NULL_NO_STATUS_RETURN(this->m_osItf); 216 217 auto skuTable = this->m_osItf->pfnGetSkuTable(this->m_osItf); 218 auto waTable = this->m_osItf->pfnGetWaTable(this->m_osItf); 219 220 if (skuTable == nullptr || waTable == nullptr) 221 { 222 MHW_ASSERTMESSAGE("Invalid SKU or WA table acquired"); 223 return; 224 } 225 226 if (MEDIA_IS_SKU(skuTable, FtrMediaThreadGroupLevelPreempt) || 227 MEDIA_IS_SKU(skuTable, FtrMediaMidBatchPreempt)) 228 { 229 m_preemptionEnabled = true; 230 231 #if (_DEBUG || _RELEASE_INTERNAL) 232 if (this->m_userSettingPtr != nullptr) 233 { 234 ReadUserSettingForDebug( 235 this->m_userSettingPtr, 236 m_preemptionEnabled, 237 __MEDIA_USER_FEATURE_VALUE_MEDIA_PREEMPTION_ENABLE, 238 MediaUserSetting::Group::Device); 239 } 240 #endif 241 } 242 243 if (MEDIA_IS_SKU(skuTable, FtrPerCtxtPreemptionGranularityControl)) 244 { 245 m_preemptionCntlRegisterOffset = MHW_RENDER_ENGINE_PREEMPTION_CONTROL_OFFSET; 246 247 if (MEDIA_IS_SKU(skuTable, FtrMediaMidThreadLevelPreempt)) 248 { 249 m_preemptionCntlRegisterValue = MHW_RENDER_ENGINE_MID_THREAD_PREEMPT_VALUE; 250 } 251 else if (MEDIA_IS_SKU(skuTable, FtrMediaThreadGroupLevelPreempt)) 252 { 253 m_preemptionCntlRegisterValue = MHW_RENDER_ENGINE_THREAD_GROUP_PREEMPT_VALUE; 254 } 255 else if (MEDIA_IS_SKU(skuTable, FtrMediaMidBatchPreempt)) 256 { 257 m_preemptionCntlRegisterValue = MHW_RENDER_ENGINE_MID_BATCH_PREEMPT_VALUE; 258 } 259 260 // Set it to Mid Batch Pre-emption level (command level) to avoid render engine hang after preemption is turned on in ring buffer 261 if (MEDIA_IS_WA(waTable, WaMidBatchPreemption)) 262 { 263 m_preemptionCntlRegisterValue = MHW_RENDER_ENGINE_MID_BATCH_PREEMPT_VALUE; 264 } 265 266 MHW_NORMALMESSAGE("InitPreemption m_preemptionCntlRegisterValue = %x", m_preemptionCntlRegisterValue); 267 } 268 } 269 EnablePreemption(PMOS_COMMAND_BUFFER cmdBuffer,std::shared_ptr<mhw::mi::Itf> miItf)270 MOS_STATUS EnablePreemption(PMOS_COMMAND_BUFFER cmdBuffer, std::shared_ptr<mhw::mi::Itf> miItf) override 271 { 272 MHW_FUNCTION_ENTER; 273 MOS_STATUS eStatus = MOS_STATUS_SUCCESS; 274 MEDIA_FEATURE_TABLE* skuTable = nullptr; 275 MHW_MI_LOAD_REGISTER_IMM_PARAMS loadRegisterParams = {}; 276 277 MHW_MI_CHK_NULL(cmdBuffer); 278 MHW_MI_CHK_NULL(miItf); 279 MHW_MI_CHK_NULL(this->m_osItf); 280 281 skuTable = this->m_osItf->pfnGetSkuTable(this->m_osItf); 282 MHW_MI_CHK_NULL(skuTable); 283 if (MEDIA_IS_SKU(skuTable, FtrPerCtxtPreemptionGranularityControl)) 284 { 285 auto& par = miItf->MHW_GETPAR_F(MI_LOAD_REGISTER_IMM)(); 286 par = {}; 287 par.dwRegister = m_preemptionCntlRegisterOffset; 288 par.dwData = m_preemptionCntlRegisterValue; 289 MHW_MI_CHK_STATUS(miItf->MHW_ADDCMD_F(MI_LOAD_REGISTER_IMM)(cmdBuffer)); 290 291 MHW_NORMALMESSAGE("EnablePreemption Set %x to reg %x", m_preemptionCntlRegisterValue, m_preemptionCntlRegisterOffset); 292 } 293 294 return eStatus; 295 } 296 IsPreemptionEnabled()297 bool IsPreemptionEnabled() override 298 { 299 return m_preemptionEnabled; 300 } 301 GetSamplerResolutionAlignUnit(bool isAVSSampler,uint32_t & widthAlignUnit,uint32_t & heightAlignUnit)302 void GetSamplerResolutionAlignUnit(bool isAVSSampler, uint32_t &widthAlignUnit, uint32_t &heightAlignUnit) override 303 { 304 // enable 2 plane NV12 when width is not multiple of 2 or height is 305 // not multiple of 4. For AVS sampler, no limitation for 4 alignment. 306 widthAlignUnit = isAVSSampler ? MHW_AVS_SAMPLER_WIDTH_ALIGN_UNIT : MHW_SAMPLER_WIDTH_ALIGN_UNIT; 307 heightAlignUnit = isAVSSampler ? MHW_AVS_SAMPLER_HEIGHT_ALIGN_UNIT : MHW_SAMPLER_HEIGHT_ALIGN_UNIT; 308 } 309 GetHwCaps()310 MHW_RENDER_ENGINE_CAPS* GetHwCaps() override 311 { 312 return &m_hwCaps; 313 } 314 _MHW_SETCMD_OVERRIDE_DECL(PIPELINE_SELECT)315 _MHW_SETCMD_OVERRIDE_DECL(PIPELINE_SELECT) 316 { 317 _MHW_SETCMD_CALLBASE(PIPELINE_SELECT); 318 return MOS_STATUS_SUCCESS; 319 } 320 _MHW_SETCMD_OVERRIDE_DECL(STATE_BASE_ADDRESS)321 _MHW_SETCMD_OVERRIDE_DECL(STATE_BASE_ADDRESS) 322 { 323 _MHW_SETCMD_CALLBASE(STATE_BASE_ADDRESS); 324 325 if (params.addressDis == false) 326 { 327 MHW_RESOURCE_PARAMS resourceParams = {}; 328 329 resourceParams.dwLsbNum = MHW_RENDER_ENGINE_STATE_BASE_ADDRESS_SHIFT; 330 resourceParams.HwCommandType = MOS_STATE_BASE_ADDR; 331 332 if (!Mos_ResourceIsNull(params.presGeneralState)) 333 { 334 cmd.DW1_2.GeneralStateBaseAddressModifyEnable = true; 335 cmd.DW12.GeneralStateBufferSizeModifyEnable = true; 336 resourceParams.presResource = params.presGeneralState; 337 resourceParams.dwOffset = 0; 338 resourceParams.pdwCmd = cmd.DW1_2.Value; 339 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DW1_2.Value); 340 341 // upper bound of the allocated resource will not be set 342 resourceParams.dwUpperBoundLocationOffsetFromCmd = 0; 343 344 InitMocsParams(resourceParams, &cmd.DW1_2.Value[0], 5, 10); 345 MHW_MI_CHK_STATUS(AddResourceToCmd( 346 this->m_osItf, 347 this->m_currentCmdBuf, 348 &resourceParams)); 349 350 if (params.mocs4GeneralState != 0) 351 { 352 cmd.DW1_2.GeneralStateMemoryObjectControlState = params.mocs4GeneralState; 353 } 354 MT_LOG2(MT_VP_MHW_CACHE_MOCS_TABLE, MT_NORMAL, MT_VP_MHW_CACHE_MEMORY_OBJECT_NAME, *((int64_t *)"STATE_BASE_ADDRESS"), MT_VP_MHW_CACHE_MEMORY_OBJECT_CONTROL_STATE, (int64_t)cmd.DW1_2.GeneralStateMemoryObjectControlState); 355 MHW_NORMALMESSAGE( 356 "Feature Graph: Cache settings of DW1_2 GeneralState in STATE_BASE_ADDRESS: SurfaceMemoryObjectControlState %u, Index to Mocs table %u", 357 cmd.DW1_2.GeneralStateMemoryObjectControlState, 358 (cmd.DW1_2.GeneralStateMemoryObjectControlState >> 1) & 0x0000003f); 359 cmd.DW12.GeneralStateBufferSize = (params.dwGeneralStateSize + MHW_PAGE_SIZE - 1) / MHW_PAGE_SIZE; 360 } 361 362 if (this->m_osItf->bNoParsingAssistanceInKmd && !Mos_ResourceIsNull(&(this->m_currentCmdBuf->OsResource))) 363 { 364 uint32_t indirectStateOffset, indirectStateSize; 365 MHW_MI_CHK_STATUS(this->m_osItf->pfnGetIndirectState(this->m_osItf, &indirectStateOffset, &indirectStateSize)); 366 367 // When KMD parsing assistance is not used, 368 // UMD is required to set up the SSH 369 // in the STATE_BASE_ADDRESS command. 370 // All addresses used in the STATE_BASE_ADDRESS 371 // command need to have the modify 372 // bit associated with it set to 1. 373 cmd.DW4_5.SurfaceStateBaseAddressModifyEnable = true; 374 resourceParams.presResource = &(this->m_currentCmdBuf->OsResource); 375 resourceParams.dwOffset = indirectStateOffset; 376 resourceParams.pdwCmd = cmd.DW4_5.Value; 377 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DW4_5.Value); 378 379 // upper bound of the allocated resource will not be set 380 resourceParams.dwUpperBoundLocationOffsetFromCmd = 0; 381 382 InitMocsParams(resourceParams, &cmd.DW4_5.Value[0], 5, 10); 383 MHW_MI_CHK_STATUS(AddResourceToCmd( 384 this->m_osItf, 385 this->m_currentCmdBuf, 386 &resourceParams)); 387 388 if (params.mocs4SurfaceState != 0) 389 { 390 cmd.DW4_5.SurfaceStateMemoryObjectControlState = params.mocs4SurfaceState; 391 } 392 MT_LOG2(MT_VP_MHW_CACHE_MOCS_TABLE, MT_NORMAL, MT_VP_MHW_CACHE_MEMORY_OBJECT_NAME, *((int64_t *)"STATE_BASE_ADDRESS"), MT_VP_MHW_CACHE_MEMORY_OBJECT_CONTROL_STATE, (int64_t)cmd.DW4_5.SurfaceStateMemoryObjectControlState); 393 MHW_NORMALMESSAGE( 394 "Feature Graph: Cache settings of DW4_5 SurfaceState in STATE_BASE_ADDRESS: SurfaceMemoryObjectControlState %u, Index to Mocs table %u", 395 cmd.DW4_5.SurfaceStateMemoryObjectControlState, 396 (cmd.DW4_5.SurfaceStateMemoryObjectControlState >> 1) & 0x0000003f); 397 } 398 399 if (!Mos_ResourceIsNull(params.presDynamicState)) 400 { 401 cmd.DW6_7.DynamicStateBaseAddressModifyEnable = true; 402 cmd.DW13.DynamicStateBufferSizeModifyEnable = true; 403 resourceParams.presResource = params.presDynamicState; 404 resourceParams.dwOffset = 0; 405 resourceParams.pdwCmd = cmd.DW6_7.Value; 406 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DW6_7.Value); 407 resourceParams.bIsWritable = params.bDynamicStateRenderTarget; 408 409 // upper bound of the allocated resource will not be set 410 resourceParams.dwUpperBoundLocationOffsetFromCmd = 0; 411 412 InitMocsParams(resourceParams, &cmd.DW6_7.Value[0], 5, 10); 413 MHW_MI_CHK_STATUS(AddResourceToCmd( 414 this->m_osItf, 415 this->m_currentCmdBuf, 416 &resourceParams)); 417 418 if (params.mocs4DynamicState != 0) 419 { 420 cmd.DW6_7.DynamicStateMemoryObjectControlState = params.mocs4DynamicState; 421 } 422 423 MT_LOG2(MT_VP_MHW_CACHE_MOCS_TABLE, MT_NORMAL, MT_VP_MHW_CACHE_MEMORY_OBJECT_NAME, *((int64_t *)"STATE_BASE_ADDRESS"), MT_VP_MHW_CACHE_MEMORY_OBJECT_CONTROL_STATE, (int64_t)cmd.DW6_7.DynamicStateMemoryObjectControlState); 424 MHW_NORMALMESSAGE( 425 "Feature Graph: Cache settings of DW6_7 DynamicState in STATE_BASE_ADDRESS: SurfaceMemoryObjectControlState %u, Index to Mocs table %u", 426 cmd.DW6_7.DynamicStateMemoryObjectControlState, 427 (cmd.DW6_7.DynamicStateMemoryObjectControlState >> 1) & 0x0000003f); 428 cmd.DW13.DynamicStateBufferSize = (params.dwDynamicStateSize + MHW_PAGE_SIZE - 1) / MHW_PAGE_SIZE; 429 430 //Reset isOutput as it should be enabled only for Dynamic State 431 resourceParams.bIsWritable = false; 432 } 433 434 if (!Mos_ResourceIsNull(params.presIndirectObjectBuffer)) 435 { 436 cmd.DW8_9.IndirectObjectBaseAddressModifyEnable = true; 437 cmd.DW14.IndirectObjectBufferSizeModifyEnable = true; 438 resourceParams.presResource = params.presIndirectObjectBuffer; 439 resourceParams.dwOffset = 0; 440 resourceParams.pdwCmd = cmd.DW8_9.Value; 441 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DW8_9.Value); 442 443 // upper bound of the allocated resource will not be set 444 resourceParams.dwUpperBoundLocationOffsetFromCmd = 0; 445 446 InitMocsParams(resourceParams, &cmd.DW8_9.Value[0], 5, 10); 447 MHW_MI_CHK_STATUS(AddResourceToCmd( 448 this->m_osItf, 449 this->m_currentCmdBuf, 450 &resourceParams)); 451 452 if (params.mocs4IndirectObjectBuffer != 0) 453 { 454 cmd.DW8_9.IndirectObjectMemoryObjectControlState = params.mocs4IndirectObjectBuffer; 455 } 456 MT_LOG2(MT_VP_MHW_CACHE_MOCS_TABLE, MT_NORMAL, MT_VP_MHW_CACHE_MEMORY_OBJECT_NAME, *((int64_t *)"STATE_BASE_ADDRESS"), MT_VP_MHW_CACHE_MEMORY_OBJECT_CONTROL_STATE, (int64_t)cmd.DW8_9.IndirectObjectMemoryObjectControlState); 457 MHW_NORMALMESSAGE( 458 "Feature Graph: Cache settings of DW8_9 IndirectObject in STATE_BASE_ADDRESS: SurfaceMemoryObjectControlState %u, Index to Mocs table %u", 459 cmd.DW8_9.IndirectObjectMemoryObjectControlState, 460 (cmd.DW8_9.IndirectObjectMemoryObjectControlState >> 1) & 0x0000003f); 461 cmd.DW14.IndirectObjectBufferSize = (params.dwIndirectObjectBufferSize + MHW_PAGE_SIZE - 1) / MHW_PAGE_SIZE; 462 } 463 464 if (!Mos_ResourceIsNull(params.presInstructionBuffer)) 465 { 466 cmd.DW10_11.InstructionBaseAddressModifyEnable = true; 467 cmd.DW15.InstructionBufferSizeModifyEnable = true; 468 resourceParams.presResource = params.presInstructionBuffer; 469 resourceParams.dwOffset = 0; 470 resourceParams.pdwCmd = cmd.DW10_11.Value; 471 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DW10_11.Value); 472 473 // upper bound of the allocated resource will not be set 474 resourceParams.dwUpperBoundLocationOffsetFromCmd = 0; 475 476 InitMocsParams(resourceParams, &cmd.DW10_11.Value[0], 5, 10); 477 478 MHW_MI_CHK_STATUS(AddResourceToCmd( 479 this->m_osItf, 480 this->m_currentCmdBuf, 481 &resourceParams)); 482 483 if (params.mocs4InstructionCache != 0) 484 { 485 cmd.DW10_11.InstructionMemoryObjectControlState = params.mocs4InstructionCache; 486 } 487 MT_LOG2(MT_VP_MHW_CACHE_MOCS_TABLE, MT_NORMAL, MT_VP_MHW_CACHE_MEMORY_OBJECT_NAME, *((int64_t *)"STATE_BASE_ADDRESS"), MT_VP_MHW_CACHE_MEMORY_OBJECT_CONTROL_STATE, (int64_t)cmd.DW10_11.InstructionMemoryObjectControlState); 488 MHW_NORMALMESSAGE( 489 "Feature Graph: Cache settings of DW10_11 Instruction in STATE_BASE_ADDRESS: SurfaceMemoryObjectControlState %u, Index to Mocs table %u", 490 cmd.DW10_11.InstructionMemoryObjectControlState, 491 (cmd.DW10_11.InstructionMemoryObjectControlState >> 1) & 0x0000003f); 492 cmd.DW15.InstructionBufferSize = (params.dwInstructionBufferSize + MHW_PAGE_SIZE - 1) / MHW_PAGE_SIZE; 493 } 494 495 // stateless dataport access 496 cmd.DW3.StatelessDataPortAccessMemoryObjectControlState = params.mocs4StatelessDataport; 497 MT_LOG2(MT_VP_MHW_CACHE_MOCS_TABLE, MT_NORMAL, MT_VP_MHW_CACHE_MEMORY_OBJECT_NAME, *((int64_t *)"STATE_BASE_ADDRESS"), MT_VP_MHW_CACHE_MEMORY_OBJECT_CONTROL_STATE, (int64_t)cmd.DW3.StatelessDataPortAccessMemoryObjectControlState); 498 MHW_NORMALMESSAGE( 499 "Feature Graph: Cache settings of DW3 StatelessDataPortAccess in STATE_BASE_ADDRESS: SurfaceMemoryObjectControlState %u, Index to Mocs table %u", 500 cmd.DW3.StatelessDataPortAccessMemoryObjectControlState, 501 (cmd.DW3.StatelessDataPortAccessMemoryObjectControlState >> 1) & 0x0000003f); 502 503 MT_LOG2(MT_VP_MHW_CACHE_MOCS_TABLE, MT_NORMAL, MT_VP_MHW_CACHE_MEMORY_OBJECT_NAME, *((int64_t *)"STATE_BASE_ADDRESS"), MT_VP_MHW_CACHE_MEMORY_OBJECT_CONTROL_STATE, (int64_t)cmd.DW16_17.BindlessSurfaceStateMemoryObjectControlState); 504 MHW_NORMALMESSAGE( 505 "Feature Graph: Cache settings of DW16_17 BindlessSurfaceState in STATE_BASE_ADDRESS: SurfaceMemoryObjectControlState %u, Index to Mocs table %u", 506 cmd.DW16_17.BindlessSurfaceStateMemoryObjectControlState, 507 (cmd.DW16_17.BindlessSurfaceStateMemoryObjectControlState >> 1) & 0x0000003f); 508 509 MT_LOG2(MT_VP_MHW_CACHE_MOCS_TABLE, MT_NORMAL, MT_VP_MHW_CACHE_MEMORY_OBJECT_NAME, *((int64_t *)"STATE_BASE_ADDRESS"), MT_VP_MHW_CACHE_MEMORY_OBJECT_CONTROL_STATE, (int64_t)cmd.DW19_20.BindlessSamplerStateMemoryObjectControlState); 510 MHW_NORMALMESSAGE( 511 "Feature Graph: Cache settings of DW19_20 BindlessSamplerState in STATE_BASE_ADDRESS: SurfaceMemoryObjectControlState %u, Index to Mocs table %u", 512 cmd.DW19_20.BindlessSamplerStateMemoryObjectControlState, 513 (cmd.DW19_20.BindlessSamplerStateMemoryObjectControlState >> 1) & 0x0000003f); 514 } 515 516 return MOS_STATUS_SUCCESS; 517 } 518 _MHW_SETCMD_OVERRIDE_DECL(_3DSTATE_CHROMA_KEY)519 _MHW_SETCMD_OVERRIDE_DECL(_3DSTATE_CHROMA_KEY) 520 { 521 _MHW_SETCMD_CALLBASE(_3DSTATE_CHROMA_KEY); 522 523 cmd.DW1.ChromakeyTableIndex = params.dwIndex; 524 cmd.DW2.ChromakeyLowValue = params.dwLow; 525 cmd.DW3.ChromakeyHighValue = params.dwHigh; 526 527 return MOS_STATUS_SUCCESS; 528 } 529 _MHW_SETCMD_OVERRIDE_DECL(PALETTE_ENTRY)530 _MHW_SETCMD_OVERRIDE_DECL(PALETTE_ENTRY) 531 { 532 _MHW_SETCMD_CALLBASE(PALETTE_ENTRY); 533 534 return MOS_STATUS_SUCCESS; 535 } 536 _MHW_SETCMD_OVERRIDE_DECL(STATE_SIP)537 _MHW_SETCMD_OVERRIDE_DECL(STATE_SIP) 538 { 539 _MHW_SETCMD_CALLBASE(STATE_SIP); 540 cmd.DW1_2.SystemInstructionPointer = (uint64_t)(params.dwSipBase >> 4); 541 542 return MOS_STATUS_SUCCESS; 543 } 544 _MHW_SETCMD_OVERRIDE_DECL(GPGPU_CSR_BASE_ADDRESS)545 _MHW_SETCMD_OVERRIDE_DECL(GPGPU_CSR_BASE_ADDRESS) 546 { 547 _MHW_SETCMD_CALLBASE(GPGPU_CSR_BASE_ADDRESS); 548 MHW_RESOURCE_PARAMS resourceParams = {}; 549 550 if (!Mos_ResourceIsNull(&(this->m_currentCmdBuf->OsResource))) 551 { 552 resourceParams.presResource = &(this->m_currentCmdBuf->OsResource); 553 resourceParams.pdwCmd = cmd.DW1_2.Value; 554 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DW1_2.Value); 555 556 MHW_MI_CHK_STATUS(AddResourceToCmd( 557 this->m_osItf, 558 this->m_currentCmdBuf, 559 &resourceParams)); 560 } 561 562 return MOS_STATUS_SUCCESS; 563 } 564 _MHW_SETCMD_OVERRIDE_DECL(_3DSTATE_BINDING_TABLE_POOL_ALLOC)565 _MHW_SETCMD_OVERRIDE_DECL(_3DSTATE_BINDING_TABLE_POOL_ALLOC) 566 { 567 _MHW_SETCMD_CALLBASE(_3DSTATE_BINDING_TABLE_POOL_ALLOC); 568 569 uint32_t indirect_state_offset = 0, indirect_state_size = 0; 570 MHW_MI_CHK_STATUS(this->m_osItf->pfnGetIndirectState(this->m_osItf, 571 &indirect_state_offset, 572 &indirect_state_size)); 573 574 MHW_RESOURCE_PARAMS resource_params = {}; 575 if (!Mos_ResourceIsNull(&(this->m_currentCmdBuf->OsResource))) 576 { 577 InitMocsParams(resource_params, &cmd.DW1_2.Value[0], 1, 6); 578 resource_params.dwLsbNum = MHW_RENDER_ENGINE_STATE_BASE_ADDRESS_SHIFT; 579 resource_params.HwCommandType = MOS_STATE_BASE_ADDR; 580 resource_params.presResource = &this->m_currentCmdBuf->OsResource; 581 resource_params.dwOffset = indirect_state_offset; 582 resource_params.pdwCmd = cmd.DW1_2.Value; 583 resource_params.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DW1_2.Value); 584 585 MHW_MI_CHK_STATUS(AddResourceToCmd( 586 this->m_osItf, 587 this->m_currentCmdBuf, 588 &resource_params)); 589 if (params.mocs4SurfaceState != 0) 590 { 591 cmd.DW1_2.SurfaceObjectControlState = params.mocs4SurfaceState; 592 } 593 594 MT_LOG2(MT_VP_MHW_CACHE_MOCS_TABLE, MT_NORMAL, MT_VP_MHW_CACHE_MEMORY_OBJECT_NAME, *((int64_t *)"3DSTATE_BINDING_TABLE_POOL_ALLOC"), MT_VP_MHW_CACHE_MEMORY_OBJECT_CONTROL_STATE, (int64_t)cmd.DW1_2.SurfaceObjectControlState); 595 MHW_NORMALMESSAGE( 596 "Feature Graph: Cache settings of StatelessDataPortAccess in STATE_BASE_ADDRESS: SurfaceMemoryObjectControlState %u, Index to Mocs table %u", 597 cmd.DW1_2.SurfaceObjectControlState, 598 (cmd.DW1_2.SurfaceObjectControlState >> 1) & 0x0000003f); 599 } 600 601 cmd.DW3.BindingTablePoolBufferSize = indirect_state_size; 602 603 return MOS_STATUS_SUCCESS; 604 } 605 _MHW_SETCMD_OVERRIDE_DECL(CFE_STATE)606 _MHW_SETCMD_OVERRIDE_DECL(CFE_STATE) 607 { 608 _MHW_SETCMD_CALLBASE(CFE_STATE); 609 610 return MOS_STATUS_SUCCESS; 611 } 612 _MHW_SETCMD_OVERRIDE_DECL(COMPUTE_WALKER)613 _MHW_SETCMD_OVERRIDE_DECL(COMPUTE_WALKER) 614 { 615 _MHW_SETCMD_CALLBASE(COMPUTE_WALKER); 616 617 return MOS_STATUS_SUCCESS; 618 } 619 _MHW_SETCMD_OVERRIDE_DECL(STATE_COMPUTE_MODE)620 _MHW_SETCMD_OVERRIDE_DECL(STATE_COMPUTE_MODE) 621 { 622 _MHW_SETCMD_CALLBASE(STATE_COMPUTE_MODE); 623 624 return MOS_STATUS_SUCCESS; 625 } 626 MEDIA_CLASS_DEFINE_END(mhw__render__Impl) 627 }; 628 } // namespace render 629 } // namespace mhw 630 631 #endif // __MHW_RENDER_IMPL_H__ 632