Debian Codegraph @

media_softlet/agnostic/common/hw/mhw_render_impl.h

raw
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:
50 MOS_STATUS EnableL3Caching(MHW_RENDER_ENGINE_L3_CACHE_SETTINGS *cacheSettings) override
51 {
52 return MOS_STATUS_SUCCESS;
53 }
54
55 MOS_STATUS SetL3Cache(PMOS_COMMAND_BUFFER cmdBuffer, std::shared_ptr<mhw::mi::Itf> miItf) override
56 {
57 return MOS_STATUS_SUCCESS;
58 }
59
60 MOS_STATUS InitMmioRegisters() override
61 {
62 return MOS_STATUS_SUCCESS;
63 }
64
65 PMHW_MI_MMIOREGISTERS GetMmioRegisters() override
66 {
67 return &m_mmioRegisters;
68 }
69
70 MHW_RENDER_ENGINE_L3_CACHE_CONFIG* GetL3CacheConfig() override
71 {
72 return &m_l3CacheConfig;
73 }
74
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
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
122 ~Impl()
123 {
124 MHW_FUNCTION_ENTER;
125
126 if (m_stateHeapInterface)
127 {
128 m_stateHeapInterface->pfnDestroy(m_stateHeapInterface);
129 }
130 }
131
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 //!
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
175 PMHW_STATE_HEAP_INTERFACE GetStateHeapInterface() override
176 {
177 MHW_FUNCTION_ENTER;
178
179 return m_stateHeapInterface;
180 }
181
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
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
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
297 bool IsPreemptionEnabled() override
298 {
299 return m_preemptionEnabled;
300 }
301
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
310 MHW_RENDER_ENGINE_CAPS* GetHwCaps() override
311 {
312 return &m_hwCaps;
313 }
314
315 _MHW_SETCMD_OVERRIDE_DECL(PIPELINE_SELECT)
316 {
317 _MHW_SETCMD_CALLBASE(PIPELINE_SELECT);
318 return MOS_STATUS_SUCCESS;
319 }
320
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
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
530 _MHW_SETCMD_OVERRIDE_DECL(PALETTE_ENTRY)
531 {
532 _MHW_SETCMD_CALLBASE(PALETTE_ENTRY);
533
534 return MOS_STATUS_SUCCESS;
535 }
536
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
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
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
606 _MHW_SETCMD_OVERRIDE_DECL(CFE_STATE)
607 {
608 _MHW_SETCMD_CALLBASE(CFE_STATE);
609
610 return MOS_STATUS_SUCCESS;
611 }
612
613 _MHW_SETCMD_OVERRIDE_DECL(COMPUTE_WALKER)
614 {
615 _MHW_SETCMD_CALLBASE(COMPUTE_WALKER);
616
617 return MOS_STATUS_SUCCESS;
618 }
619
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__