Debian Codegraph @

media_softlet/agnostic/common/hw/mhw_mi_impl.h

raw
1 /*
2 * Copyright (c) 2020-2021, 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_mi_impl.h
24 //! \brief MHW MI interface common base
25 //! \details
26 //!
27
28 #ifndef __MHW_MI_IMPL_H__
29 #define __MHW_MI_IMPL_H__
30
31 #include "mhw_mi_itf.h"
32 #include "mhw_impl.h"
33 #include "mos_os_cp_interface_specific.h"
34
35 #ifdef IGFX_MI_INTERFACE_EXT_SUPPORT
36 #include "mhw_mi_impl_ext.h"
37 #endif
38
39 // Common MMIO register defines used by base Impl<cmd_t> methods.
40 // Platform-specific headers (mhw_mmio_xe*_lpm*.h) define these same values;
41 // the #ifndef guards allow the platform definition to take precedence when
42 // the platform header is included first.
43 #ifndef M_MMIO_MAX_RELATIVE_OFFSET
44 #define M_MMIO_MAX_RELATIVE_OFFSET 0x3FFF
45 #define M_MMIO_MEDIA_LOW_OFFSET 0x1C0000
46 #define M_MMIO_MEDIA_HIGH_OFFSET 0x200000
47 #endif
48
49 #ifndef M_MMIO_RCS_HW_FE_REMAP_RANGE_BEGIN
50 #define M_MMIO_RCS_HW_FE_REMAP_RANGE_BEGIN 0x2000
51 #define M_MMIO_RCS_HW_FE_REMAP_RANGE_END 0x27FF
52 #define M_MMIO_RCS_AUX_TBL_REMAP_RANGE_BEGIN 0x4200
53 #define M_MMIO_RCS_AUX_TBL_REMAP_RANGE_END 0x420F
54 #define M_MMIO_RCS_TRTT_REMAP_RANGE_BEGIN 0x4400
55 #define M_MMIO_RCS_TRTT_REMAP_RANGE_END 0x441F
56 #endif
57
58 #ifndef M_MMIO_CCS0_HW_FRONT_END_BASE_BEGIN
59 #define M_MMIO_CCS0_HW_FRONT_END_BASE_BEGIN 0x1A000
60 #define M_MMIO_CCS0_HW_FRONT_END_BASE_END 0x1A7FF
61 #define M_MMIO_CCS1_HW_FRONT_END_BASE_BEGIN 0x1C000
62 #define M_MMIO_CCS1_HW_FRONT_END_BASE_END 0x1C7FF
63 #define M_MMIO_CCS2_HW_FRONT_END_BASE_BEGIN 0x1E000
64 #define M_MMIO_CCS2_HW_FRONT_END_BASE_END 0x1E7FF
65 #define M_MMIO_CCS3_HW_FRONT_END_BASE_BEGIN 0x26000
66 #define M_MMIO_CCS3_HW_FRONT_END_BASE_END 0x267FF
67 #endif
68
69 #ifndef M_MMIO_RCS_AUX_TABLE_BASE_LOW
70 #define M_MMIO_RCS_AUX_TABLE_BASE_LOW 0x4200
71 #define M_MMIO_RCS_AUX_TABLE_BASE_HIGH 0x4204
72 #define M_MMIO_RCS_AUX_TABLE_INVALIDATE 0x4208
73 #endif
74
75 #ifndef M_MMIO_VD0_AUX_TABLE_BASE_LOW
76 #define M_MMIO_VD0_AUX_TABLE_BASE_LOW 0x4210
77 #define M_MMIO_VD0_AUX_TABLE_BASE_HIGH 0x4214
78 #define M_MMIO_VD0_AUX_TABLE_INVALIDATE 0x4218
79 #define M_MMIO_VD1_AUX_TABLE_BASE_LOW 0x4220
80 #define M_MMIO_VD1_AUX_TABLE_BASE_HIGH 0x4224
81 #define M_MMIO_VD1_AUX_TABLE_INVALIDATE 0x4228
82 #define M_MMIO_VD2_AUX_TABLE_BASE_LOW 0x4290
83 #define M_MMIO_VD2_AUX_TABLE_BASE_HIGH 0x4294
84 #define M_MMIO_VD2_AUX_TABLE_INVALIDATE 0x4298
85 #define M_MMIO_VD3_AUX_TABLE_BASE_LOW 0x42A0
86 #define M_MMIO_VD3_AUX_TABLE_BASE_HIGH 0x42A4
87 #define M_MMIO_VD3_AUX_TABLE_INVALIDATE 0x42A8
88 #endif
89
90 #ifndef M_MMIO_VE0_AUX_TABLE_BASE_LOW
91 #define M_MMIO_VE0_AUX_TABLE_BASE_LOW 0x4230
92 #define M_MMIO_VE0_AUX_TABLE_BASE_HIGH 0x4234
93 #define M_MMIO_VE0_AUX_TABLE_INVALIDATE 0x4238
94 #define M_MMIO_VE1_AUX_TABLE_BASE_LOW 0x42B0
95 #define M_MMIO_VE1_AUX_TABLE_BASE_HIGH 0x42B4
96 #define M_MMIO_VE1_AUX_TABLE_INVALIDATE 0x42B8
97 #endif
98
99 #ifndef M_MMIO_CCS0_AUX_TABLE_BASE_LOW
100 #define M_MMIO_CCS0_AUX_TABLE_BASE_LOW 0x42C0
101 #define M_MMIO_CCS0_AUX_TABLE_BASE_HIGH 0x42C4
102 #define M_MMIO_CCS0_AUX_TABLE_INVALIDATE 0x42C8
103 #endif
104
105 namespace mhw
106 {
107 namespace mi
108 {
109 static constexpr uint32_t GENERAL_PURPOSE_REGISTER0_LO_OFFSET_NODE_1_INIT = 0x1C0600;
110 static constexpr uint32_t GENERAL_PURPOSE_REGISTER0_HI_OFFSET_NODE_1_INIT = 0x1C0604;
111 static constexpr uint32_t GENERAL_PURPOSE_REGISTER4_LO_OFFSET_NODE_1_INIT = 0x1C0620;
112 static constexpr uint32_t GENERAL_PURPOSE_REGISTER4_HI_OFFSET_NODE_1_INIT = 0x1C0624;
113 static constexpr uint32_t GENERAL_PURPOSE_REGISTER11_LO_OFFSET_NODE_1_INIT = 0x1C0658;
114 static constexpr uint32_t GENERAL_PURPOSE_REGISTER11_HI_OFFSET_NODE_1_INIT = 0x1C065C;
115 static constexpr uint32_t GENERAL_PURPOSE_REGISTER12_LO_OFFSET_NODE_1_INIT = 0x1C0660;
116 static constexpr uint32_t GENERAL_PURPOSE_REGISTER12_HI_OFFSET_NODE_1_INIT = 0x1C0664;
117
118 template <typename cmd_t>
119 class Impl : public Itf, public mhw::Impl
120 {
121 _MI_CMD_DEF(_MHW_CMD_ALL_DEF_FOR_IMPL);
122 public:
123
124 //! \brief Indicates the global GTT setting on each engine.
125 struct
126 {
127 bool m_cs = false; //!< GGTT in use for the render engine.
128 bool m_vcs = false; //!< GGTT in use for VDBOX.
129 bool m_vecs = false; //!< GGTT in use for VEBOX.
130 } UseGlobalGtt;
131
132 bool IsGlobalGttInUse()
133 {
134 MOS_GPU_CONTEXT gpuContext = this->m_osItf->pfnGetGpuContext(this->m_osItf);
135 bool vcsEngineUsed = MOS_VCS_ENGINE_USED(gpuContext);
136 bool renderEngineUsed = MOS_RCS_ENGINE_USED(gpuContext);
137
138 bool globalGttInUse = renderEngineUsed ? UseGlobalGtt.m_cs :
139 (vcsEngineUsed ? UseGlobalGtt.m_vcs : UseGlobalGtt.m_vecs);
140
141 return globalGttInUse;
142 }
143
144 //!
145 //! \brief Helper function to compose opcode for MI_ATOMIC
146 //! \return uint32_t
147 //! Composed opcode for MI_ATOMIC or 0
148 //!
149 uint32_t CreateMiAtomicOpcode(
150 uint32_t dataSize,
151 MHW_COMMON_MI_ATOMIC_OPCODE opCode)
152 {
153 uint32_t formattedOpCode = dataSize;
154
155 switch (opCode) {
156 case MHW_MI_ATOMIC_AND:
157 formattedOpCode += MHW_MI_ATOMIC_AND;
158 break;
159 case MHW_MI_ATOMIC_OR:
160 formattedOpCode += MHW_MI_ATOMIC_OR;
161 break;
162 case MHW_MI_ATOMIC_XOR:
163 formattedOpCode += MHW_MI_ATOMIC_XOR;
164 break;
165 case MHW_MI_ATOMIC_MOVE:
166 formattedOpCode += MHW_MI_ATOMIC_MOVE;
167 break;
168 case MHW_MI_ATOMIC_INC:
169 formattedOpCode += MHW_MI_ATOMIC_INC;
170 break;
171 case MHW_MI_ATOMIC_DEC:
172 formattedOpCode += MHW_MI_ATOMIC_DEC;
173 break;
174 case MHW_MI_ATOMIC_ADD:
175 formattedOpCode += MHW_MI_ATOMIC_ADD;
176 break;
177 case MHW_MI_ATOMIC_SUB:
178 formattedOpCode += MHW_MI_ATOMIC_SUB;
179 break;
180 case MHW_MI_ATOMIC_RSUB:
181 formattedOpCode += MHW_MI_ATOMIC_RSUB;
182 break;
183 case MHW_MI_ATOMIC_IMAX:
184 formattedOpCode += MHW_MI_ATOMIC_IMAX;
185 break;
186 case MHW_MI_ATOMIC_IMIN:
187 formattedOpCode += MHW_MI_ATOMIC_IMIN;
188 break;
189 case MHW_MI_ATOMIC_UMAX:
190 formattedOpCode += MHW_MI_ATOMIC_UMAX;
191 break;
192 case MHW_MI_ATOMIC_UMIN:
193 formattedOpCode += MHW_MI_ATOMIC_UMIN;
194 break;
195 case MHW_MI_ATOMIC_CMP:
196 formattedOpCode += MHW_MI_ATOMIC_CMP;
197 break;
198 default:
199 formattedOpCode = MHW_MI_ATOMIC_NONE;
200 break;
201 }
202
203 return formattedOpCode;
204 }
205
206 MOS_STATUS SetWatchdogTimerThreshold(uint32_t frameWidth, uint32_t frameHeight, bool isEncoder, uint32_t codecMode, bool isTee) override
207 {
208 MHW_FUNCTION_ENTER;
209 MHW_MI_CHK_NULL(this->m_osItf);
210 if (this->m_osItf->bMediaReset == false ||
211 this->m_osItf->umdMediaResetEnable == false)
212 {
213 return MOS_STATUS_SUCCESS;
214 }
215
216 if (isTee)
217 {
218 MHW_MI_CHK_STATUS(SetTeeWatchdogThreshold());
219 }
220 else if (isEncoder)
221 {
222 if ((frameWidth * frameHeight) >= (7680 * 4320))
223 {
224 MediaResetParam.watchdogCountThreshold = MHW_MI_ENCODER_16K_WATCHDOG_THRESHOLD_IN_MS;
225 }
226 else if ((frameWidth * frameHeight) >= (3840 * 2160))
227 {
228 MediaResetParam.watchdogCountThreshold = MHW_MI_ENCODER_8K_WATCHDOG_THRESHOLD_IN_MS;
229 }
230 else if ((frameWidth * frameHeight) >= (1920 * 1080))
231 {
232 MediaResetParam.watchdogCountThreshold = MHW_MI_ENCODER_4K_WATCHDOG_THRESHOLD_IN_MS;
233 }
234 else
235 {
236 MediaResetParam.watchdogCountThreshold = MHW_MI_ENCODER_FHD_WATCHDOG_THRESHOLD_IN_MS;
237 }
238 }
239 else
240 {
241 SetDecoderWatchdogThreshold(frameWidth, frameHeight, codecMode);
242 }
243
244 GetWatchdogThreshold(this->m_osItf);
245
246 return MOS_STATUS_SUCCESS;
247 }
248
249 MOS_STATUS SetWatchdogTimerRegisterOffset(MOS_GPU_CONTEXT gpuContext) override
250 {
251 MHW_FUNCTION_ENTER;
252
253 switch (gpuContext)
254 {
255 // RCS
256 case MOS_GPU_CONTEXT_RENDER:
257 case MOS_GPU_CONTEXT_RENDER2:
258 case MOS_GPU_CONTEXT_RENDER3:
259 case MOS_GPU_CONTEXT_RENDER4:
260 case MOS_GPU_CONTEXT_COMPUTE:
261 case MOS_GPU_CONTEXT_CM_COMPUTE:
262 case MOS_GPU_CONTEXT_RENDER_RA:
263 case MOS_GPU_CONTEXT_COMPUTE_RA:
264 MediaResetParam.watchdogCountCtrlOffset = m_watchdogOffsets.ctrlRcs;
265 MediaResetParam.watchdogCountThresholdOffset = m_watchdogOffsets.thresholdRcs;
266 break;
267 // VCS0
268 case MOS_GPU_CONTEXT_VIDEO:
269 case MOS_GPU_CONTEXT_VIDEO2:
270 case MOS_GPU_CONTEXT_VIDEO3:
271 case MOS_GPU_CONTEXT_VIDEO4:
272 case MOS_GPU_CONTEXT_VIDEO5:
273 case MOS_GPU_CONTEXT_VIDEO6:
274 case MOS_GPU_CONTEXT_VIDEO7:
275 MediaResetParam.watchdogCountCtrlOffset = m_watchdogOffsets.ctrlVcs0;
276 MediaResetParam.watchdogCountThresholdOffset = m_watchdogOffsets.thresholdVcs0;
277 break;
278 // VCS1
279 case MOS_GPU_CONTEXT_VDBOX2_VIDEO:
280 case MOS_GPU_CONTEXT_VDBOX2_VIDEO2:
281 case MOS_GPU_CONTEXT_VDBOX2_VIDEO3:
282 MediaResetParam.watchdogCountCtrlOffset = m_watchdogOffsets.ctrlVcs1;
283 MediaResetParam.watchdogCountThresholdOffset = m_watchdogOffsets.thresholdVcs1;
284 break;
285 // VECS
286 case MOS_GPU_CONTEXT_VEBOX:
287 MediaResetParam.watchdogCountCtrlOffset = m_watchdogOffsets.ctrlVecs;
288 MediaResetParam.watchdogCountThresholdOffset = m_watchdogOffsets.thresholdVecs;
289 break;
290 // TEE
291 case MOS_GPU_CONTEXT_TEE:
292 MediaResetParam.watchdogCountCtrlOffset = m_watchdogOffsets.teecsCtrl;
293 MediaResetParam.watchdogCountThresholdOffset = m_watchdogOffsets.thresholdTeecs;
294 break;
295 // Default
296 default:
297 break;
298 }
299
300 return MOS_STATUS_SUCCESS;
301 }
302
303 MOS_STATUS AddWatchdogTimerStartCmd(PMOS_COMMAND_BUFFER cmdBuffer) override
304 {
305 MOS_GPU_CONTEXT gpuContext;
306
307 MHW_FUNCTION_ENTER;
308 MHW_MI_CHK_NULL(this->m_osItf);
309 if (this->m_osItf->bMediaReset == false ||
310 this->m_osItf->umdMediaResetEnable == false)
311 {
312 return MOS_STATUS_SUCCESS;
313 }
314
315 MHW_MI_CHK_NULL(cmdBuffer);
316
317 // Set Watchdog Timer Register Offset
318 gpuContext = this->m_osItf->pfnGetGpuContext(this->m_osItf);
319 MHW_MI_CHK_STATUS(SetWatchdogTimerRegisterOffset(gpuContext));
320
321 // Send Stop before Start is to help recover from incorrect wdt state if previous submission
322 // cause hang and not have a chance to execute the stop cmd in the end of batch buffer.
323 MHW_MI_CHK_STATUS(AddWatchdogTimerStopCmd(cmdBuffer));
324
325 //Configure Watchdog timer Threshold
326 auto& par = MHW_GETPAR_F(MI_LOAD_REGISTER_IMM)();
327 par = {};
328 par.dwData = MHW_MI_WATCHDOG_COUNTS_PER_MILLISECOND * MediaResetParam.watchdogCountThreshold *
329 (this->m_osItf->bSimIsActive ? 2 : 1);
330 par.dwRegister = MediaResetParam.watchdogCountThresholdOffset;
331 MHW_ADDCMD_F(MI_LOAD_REGISTER_IMM)(cmdBuffer);
332
333 MHW_VERBOSEMESSAGE("MediaReset Threshold is %d for register 0x%x", MediaResetParam.watchdogCountThreshold * (this->m_osItf->bSimIsActive ? 2 : 1), par.dwRegister);
334
335 //Start Watchdog Timer
336 auto& par1 = MHW_GETPAR_F(MI_LOAD_REGISTER_IMM)();
337 par1 = {};
338 par1.dwData = MHW_MI_WATCHDOG_ENABLE_COUNTER;
339 par1.dwRegister = MediaResetParam.watchdogCountCtrlOffset;
340 MHW_ADDCMD_F(MI_LOAD_REGISTER_IMM)(cmdBuffer);
341
342 return MOS_STATUS_SUCCESS;
343 }
344
345 MOS_STATUS AddWatchdogTimerStopCmd(PMOS_COMMAND_BUFFER cmdBuffer) override
346 {
347 MOS_GPU_CONTEXT gpuContext;
348
349 MHW_FUNCTION_ENTER;
350 MHW_MI_CHK_NULL(this->m_osItf);
351 if (this->m_osItf->bMediaReset == false ||
352 this->m_osItf->umdMediaResetEnable == false)
353 {
354 return MOS_STATUS_SUCCESS;
355 }
356
357 MHW_MI_CHK_NULL(cmdBuffer);
358
359 // Set Watchdog Timer Register Offset
360 gpuContext = this->m_osItf->pfnGetGpuContext(this->m_osItf);
361 MHW_MI_CHK_STATUS(SetWatchdogTimerRegisterOffset(gpuContext));
362
363 //Stop Watchdog Timer
364 auto& par = MHW_GETPAR_F(MI_LOAD_REGISTER_IMM)();
365 par = {};
366 par.dwData = MHW_MI_WATCHDOG_DISABLE_COUNTER;
367 par.dwRegister = MediaResetParam.watchdogCountCtrlOffset;
368 MHW_ADDCMD_F(MI_LOAD_REGISTER_IMM)(cmdBuffer);
369
370 return MOS_STATUS_SUCCESS;
371 }
372
373 MOS_STATUS AddMiBatchBufferEnd(
374 PMOS_COMMAND_BUFFER cmdBuffer,
375 PMHW_BATCH_BUFFER batchBuffer) override
376 {
377 MHW_FUNCTION_ENTER;
378
379 if (cmdBuffer == nullptr && batchBuffer == nullptr)
380 {
381 MHW_ASSERTMESSAGE("There was no valid buffer to add the HW command to.");
382 return MOS_STATUS_NULL_POINTER;
383 }
384
385 auto waTable = this->m_osItf->pfnGetWaTable(this->m_osItf);
386 MHW_MI_CHK_NULL(waTable);
387
388 // This WA does not apply for video or other engines, render requirement only
389 bool isRender =
390 MOS_RCS_ENGINE_USED(this->m_osItf->pfnGetGpuContext(this->m_osItf));
391
392 if (isRender &&
393 (MEDIA_IS_WA(waTable, WaMSFWithNoWatermarkTSGHang) ||
394 MEDIA_IS_WA(waTable, WaAddMediaStateFlushCmd)))
395 {
396 auto& params = MHW_GETPAR_F(MEDIA_STATE_FLUSH)();
397 params = {};
398 MHW_ADDCMD_F(MEDIA_STATE_FLUSH)(cmdBuffer, batchBuffer);
399 }
400
401 // Mhw_CommonMi_AddMiBatchBufferEnd() is designed to handle both 1st level
402 // and 2nd level BB. It inserts MI_BATCH_BUFFER_END in both cases.
403 // However, since the 2nd level BB always returens to the 1st level BB and
404 // no chained BB scenario in Media, Epilog is only needed in the 1st level BB.
405 // Therefre, here only the 1st level BB case needs an Epilog inserted.
406 if (cmdBuffer && cmdBuffer->is1stLvlBB)
407 {
408 MHW_MI_CHK_STATUS(m_cpInterface->AddEpilog(this->m_osItf, cmdBuffer));
409 }
410
411 auto& params = MHW_GETPAR_F(MI_BATCH_BUFFER_END)();
412 params = {};
413 MHW_ADDCMD_F(MI_BATCH_BUFFER_END)(cmdBuffer, batchBuffer);
414
415 if (!cmdBuffer) // Don't need BB not nullptr chk b/c if both are nullptr it won't get this far
416 {
417 #if (_DEBUG || _RELEASE_INTERNAL)
418 batchBuffer->iLastCurrent = batchBuffer->iCurrent;
419 #endif
420 }
421
422 // Send End Marker command
423 if (this->m_osItf->pfnIsSetMarkerEnabled(this->m_osItf) && cmdBuffer && cmdBuffer->is1stLvlBB)
424 {
425 PMOS_RESOURCE resMarker = nullptr;
426 resMarker = this->m_osItf->pfnGetMarkerResource(this->m_osItf);
427 MHW_MI_CHK_NULL(resMarker);
428
429 if (isRender)
430 {
431 // Send pipe_control to get the timestamp
432 auto& params = MHW_GETPAR_F(PIPE_CONTROL)();
433 params = {};
434 params.presDest = resMarker;
435 params.dwResourceOffset = sizeof(uint64_t);
436 params.dwPostSyncOp = MHW_FLUSH_WRITE_TIMESTAMP_REG;
437 params.dwFlushMode = MHW_FLUSH_WRITE_CACHE;
438 MHW_ADDCMD_F(PIPE_CONTROL)(cmdBuffer, batchBuffer);
439 }
440 else
441 {
442 // Send flush_dw to get the timestamp
443 auto& params = MHW_GETPAR_F(MI_FLUSH_DW)();
444 params = {};
445 params.pOsResource = resMarker;
446 params.dwResourceOffset = sizeof(uint64_t);
447 params.postSyncOperation = MHW_FLUSH_WRITE_TIMESTAMP_REG;
448 params.bQWordEnable = 1;
449 MHW_ADDCMD_F(MI_FLUSH_DW)(cmdBuffer, batchBuffer);
450 }
451
452 if (!this->m_osItf->apoMosEnabled)
453 {
454 MOS_SafeFreeMemory(resMarker);
455 }
456 }
457 MHW_MI_CHK_STATUS(this->m_osItf->osCpInterface->PermeateBBPatchForHM());
458
459 return MOS_STATUS_SUCCESS;
460 }
461
462 MOS_STATUS AddMiBatchBufferEndOnly(
463 PMOS_COMMAND_BUFFER cmdBuffer,
464 PMHW_BATCH_BUFFER batchBuffer) override
465 {
466 MHW_FUNCTION_ENTER;
467
468 if (cmdBuffer == nullptr && batchBuffer == nullptr)
469 {
470 MHW_ASSERTMESSAGE("There was no valid buffer to add the HW command to.");
471 return MOS_STATUS_NULL_POINTER;
472 }
473
474 // This WA does not apply for video or other engines, render requirement only
475 bool isRender =
476 MOS_RCS_ENGINE_USED(this->m_osItf->pfnGetGpuContext(this->m_osItf));
477
478 // Mhw_CommonMi_AddMiBatchBufferEnd() is designed to handle both 1st level
479 // and 2nd level BB. It inserts MI_BATCH_BUFFER_END in both cases.
480 // However, since the 2nd level BB always returens to the 1st level BB and
481 // no chained BB scenario in Media, Epilog is only needed in the 1st level BB.
482 // Therefre, here only the 1st level BB case needs an Epilog inserted.
483 if (cmdBuffer && cmdBuffer->is1stLvlBB)
484 {
485 MHW_MI_CHK_STATUS(m_cpInterface->AddEpilog(this->m_osItf, cmdBuffer));
486 }
487
488 auto &params = MHW_GETPAR_F(MI_BATCH_BUFFER_END)();
489 params = {};
490 MHW_ADDCMD_F(MI_BATCH_BUFFER_END)
491 (cmdBuffer, batchBuffer);
492
493 if (!cmdBuffer) // Don't need BB not nullptr chk b/c if both are nullptr it won't get this far
494 {
495 #if (_DEBUG || _RELEASE_INTERNAL)
496 batchBuffer->iLastCurrent = batchBuffer->iCurrent;
497 #endif
498 }
499
500 // Send End Marker command
501 if (this->m_osItf->pfnIsSetMarkerEnabled(this->m_osItf) && cmdBuffer && cmdBuffer->is1stLvlBB)
502 {
503 PMOS_RESOURCE resMarker = nullptr;
504 resMarker = this->m_osItf->pfnGetMarkerResource(this->m_osItf);
505 MHW_MI_CHK_NULL(resMarker);
506
507 if (isRender)
508 {
509 // Send pipe_control to get the timestamp
510 auto &params = MHW_GETPAR_F(PIPE_CONTROL)();
511 params = {};
512 params.presDest = resMarker;
513 params.dwResourceOffset = sizeof(uint64_t);
514 params.dwPostSyncOp = MHW_FLUSH_WRITE_TIMESTAMP_REG;
515 params.dwFlushMode = MHW_FLUSH_WRITE_CACHE;
516 MHW_ADDCMD_F(PIPE_CONTROL)
517 (cmdBuffer, batchBuffer);
518 }
519 else
520 {
521 // Send flush_dw to get the timestamp
522 auto &params = MHW_GETPAR_F(MI_FLUSH_DW)();
523 params = {};
524 params.pOsResource = resMarker;
525 params.dwResourceOffset = sizeof(uint64_t);
526 params.postSyncOperation = MHW_FLUSH_WRITE_TIMESTAMP_REG;
527 params.bQWordEnable = 1;
528 MHW_ADDCMD_F(MI_FLUSH_DW)
529 (cmdBuffer, batchBuffer);
530 }
531
532 if (!this->m_osItf->apoMosEnabled)
533 {
534 MOS_SafeFreeMemory(resMarker);
535 }
536 }
537
538 return MOS_STATUS_SUCCESS;
539 }
540
541 MOS_STATUS AddBatchBufferEndInsertionFlag(MOS_COMMAND_BUFFER &constructedCmdBuf) override
542 {
543 MHW_FUNCTION_ENTER;
544
545 typename cmd_t::MI_BATCH_BUFFER_END_CMD cmd;
546
547 MHW_CHK_NULL_RETURN(constructedCmdBuf.pCmdPtr);
548 *((typename cmd_t::MI_BATCH_BUFFER_END_CMD *)(constructedCmdBuf.pCmdPtr)) = cmd;
549
550 return MOS_STATUS_SUCCESS;
551 }
552
553 MHW_MI_MMIOREGISTERS* GetMmioRegisters() override
554 {
555 return &m_mmioRegisters;
556 }
557
558 virtual MOS_STATUS SetCpInterface(MhwCpInterface *cpInterface, std::shared_ptr<mhw::mi::Itf> m_miItf) override
559 {
560 m_cpInterface = cpInterface;
561 MHW_CHK_NULL_RETURN(m_cpInterface);
562 MHW_MI_CHK_STATUS(m_cpInterface->RegisterMiInterfaceNext(m_miItf));
563 return MOS_STATUS_SUCCESS;
564 }
565
566 virtual uint32_t GetMmioInterfaces(MHW_MMIO_REGISTER_OPCODE opCode) override
567 {
568 uint32_t mmioRegisters = MHW_MMIO_RCS_AUX_TABLE_NONE;
569
570 switch (opCode)
571 {
572 case MHW_MMIO_RCS_AUX_TABLE_BASE_LOW:
573 mmioRegisters = M_MMIO_RCS_AUX_TABLE_BASE_LOW;
574 break;
575 case MHW_MMIO_RCS_AUX_TABLE_BASE_HIGH:
576 mmioRegisters = M_MMIO_RCS_AUX_TABLE_BASE_HIGH;
577 break;
578 case MHW_MMIO_RCS_AUX_TABLE_INVALIDATE:
579 mmioRegisters = M_MMIO_RCS_AUX_TABLE_INVALIDATE;
580 break;
581 case MHW_MMIO_VD0_AUX_TABLE_BASE_LOW:
582 mmioRegisters = M_MMIO_VD0_AUX_TABLE_BASE_LOW;
583 break;
584 case MHW_MMIO_VD0_AUX_TABLE_BASE_HIGH:
585 mmioRegisters = M_MMIO_VD0_AUX_TABLE_BASE_HIGH;
586 break;
587 case MHW_MMIO_VD0_AUX_TABLE_INVALIDATE:
588 mmioRegisters = M_MMIO_VD0_AUX_TABLE_INVALIDATE;
589 break;
590 case MHW_MMIO_VD1_AUX_TABLE_BASE_LOW:
591 mmioRegisters = M_MMIO_VD1_AUX_TABLE_BASE_LOW;
592 break;
593 case MHW_MMIO_VD1_AUX_TABLE_BASE_HIGH:
594 mmioRegisters = M_MMIO_VD1_AUX_TABLE_BASE_HIGH;
595 break;
596 case MHW_MMIO_VD1_AUX_TABLE_INVALIDATE:
597 mmioRegisters = M_MMIO_VD1_AUX_TABLE_INVALIDATE;
598 break;
599 case MHW_MMIO_VD2_AUX_TABLE_BASE_LOW:
600 mmioRegisters = M_MMIO_VD2_AUX_TABLE_BASE_LOW;
601 break;
602 case MHW_MMIO_VD2_AUX_TABLE_BASE_HIGH:
603 mmioRegisters = M_MMIO_VD2_AUX_TABLE_BASE_HIGH;
604 break;
605 case MHW_MMIO_VD2_AUX_TABLE_INVALIDATE:
606 mmioRegisters = M_MMIO_VD2_AUX_TABLE_INVALIDATE;
607 break;
608 case MHW_MMIO_VD3_AUX_TABLE_BASE_LOW:
609 mmioRegisters = M_MMIO_VD3_AUX_TABLE_BASE_LOW;
610 break;
611 case MHW_MMIO_VD3_AUX_TABLE_BASE_HIGH:
612 mmioRegisters = M_MMIO_VD3_AUX_TABLE_BASE_HIGH;
613 break;
614 case MHW_MMIO_VD3_AUX_TABLE_INVALIDATE:
615 mmioRegisters = M_MMIO_VD3_AUX_TABLE_INVALIDATE;
616 break;
617 case MHW_MMIO_VE0_AUX_TABLE_BASE_LOW:
618 mmioRegisters = M_MMIO_VE0_AUX_TABLE_BASE_LOW;
619 break;
620 case MHW_MMIO_VE0_AUX_TABLE_BASE_HIGH:
621 mmioRegisters = M_MMIO_VE0_AUX_TABLE_BASE_HIGH;
622 break;
623 case MHW_MMIO_VE0_AUX_TABLE_INVALIDATE:
624 mmioRegisters = M_MMIO_VE0_AUX_TABLE_INVALIDATE;
625 break;
626 case MHW_MMIO_VE1_AUX_TABLE_BASE_LOW:
627 mmioRegisters = M_MMIO_VE1_AUX_TABLE_BASE_LOW;
628 break;
629 case MHW_MMIO_VE1_AUX_TABLE_BASE_HIGH:
630 mmioRegisters = M_MMIO_VE1_AUX_TABLE_BASE_HIGH;
631 break;
632 case MHW_MMIO_VE1_AUX_TABLE_INVALIDATE:
633 mmioRegisters = M_MMIO_VE1_AUX_TABLE_INVALIDATE;
634 break;
635 case MHW_MMIO_CCS0_AUX_TABLE_BASE_LOW:
636 mmioRegisters = M_MMIO_CCS0_AUX_TABLE_BASE_LOW;
637 break;
638 case MHW_MMIO_CCS0_AUX_TABLE_BASE_HIGH:
639 mmioRegisters = M_MMIO_CCS0_AUX_TABLE_BASE_HIGH;
640 break;
641 case MHW_MMIO_CCS0_AUX_TABLE_INVALIDATE:
642 mmioRegisters = M_MMIO_CCS0_AUX_TABLE_INVALIDATE;
643 break;
644 default:
645 MHW_ASSERTMESSAGE("Invalid mmio data provided");
646 break;
647 }
648
649 return mmioRegisters;
650 }
651
652 MOS_STATUS AddProtectedProlog(MOS_COMMAND_BUFFER *cmdBuffer) override
653 {
654 MHW_MI_CHK_NULL(cmdBuffer);
655
656 MHW_MI_CHK_STATUS(m_cpInterface->AddProlog(this->m_osItf, cmdBuffer));
657 MHW_MI_CHK_STATUS(m_cpInterface->AddCheckForEarlyExit(this->m_osItf, cmdBuffer));
658
659 return MOS_STATUS_SUCCESS;
660 }
661
662 MOS_STATUS AddVeboxMMIOPrologCmd(
663 PMOS_COMMAND_BUFFER cmdBuffer) override
664 {
665 return MOS_STATUS_SUCCESS;
666 }
667
668 virtual MOS_STATUS AddBLTMMIOPrologCmd(
669 PMOS_COMMAND_BUFFER cmdBuffer) override
670 {
671 return MOS_STATUS_SUCCESS;
672 }
673
674 virtual MOS_STATUS AddWaitInSyncBatchBuffer(
675 uint64_t fenceTokenValue,
676 uint64_t gpuVirtualAddress,
677 uint64_t waitValue,
678 MHW_BATCH_BUFFER *batchBuffer,
679 MHW_SEMAPHORE_WATI_REGISTERS &tokenRegister,
680 PMOS_COMMAND_BUFFER cmdbuffer) override
681 {
682 return MOS_STATUS_SUCCESS;
683 }
684
685 virtual MOS_STATUS AddSignalInSyncBatchBuffer(
686 uint64_t fenceTokenValue,
687 uint64_t currentValueGpuVA,
688 uint64_t monitoredValueGpuVA,
689 uint64_t signalValue,
690 MHW_SEMAPHORE_WATI_REGISTERS &tokenRegister,
691 PMOS_COMMAND_BUFFER cmdbuffer) override
692 {
693 return MOS_STATUS_SUCCESS;
694 }
695 protected:
696 using base_t = Itf;
697
698 MHW_MI_MMIOREGISTERS m_mmioRegisters = {};
699 MhwCpInterface *m_cpInterface = nullptr;
700
701 //! \brief Indicates the MediaReset Parameter.
702 struct
703 {
704 uint32_t watchdogCountThreshold = 0;
705 uint32_t watchdogCountCtrlOffset = 0;
706 uint32_t watchdogCountThresholdOffset = 0;
707 } MediaResetParam;
708
709 //! \brief Watchdog timer register offsets per engine, initialized by platform.
710 struct
711 {
712 uint32_t ctrlRcs = 0;
713 uint32_t thresholdRcs = 0;
714 uint32_t ctrlVcs0 = 0;
715 uint32_t thresholdVcs0 = 0;
716 uint32_t ctrlVcs1 = 0;
717 uint32_t thresholdVcs1 = 0;
718 uint32_t ctrlVecs = 0;
719 uint32_t thresholdVecs = 0;
720 uint32_t teecsCtrl = 0;
721 uint32_t thresholdTeecs = 0;
722 } m_watchdogOffsets;
723
724 //!
725 //! \brief Check RCS and CCS remap offset
726 //! \details Check if a RCS register offset is set and remap it to RCS/CCS register offset if so.
727 //! \param [in] reg
728 //! Register to be checked and converted
729 //! \return bool
730 //! Return true if it is RCS register
731 //!
732 bool IsRemappingMMIO(uint32_t &reg)
733 {
734 if (nullptr == this->m_osItf)
735 {
736 MHW_ASSERTMESSAGE("invalid m_osInterface for RemappingMMIO");
737 return false;
738 }
739 MOS_GPU_CONTEXT gpuContext = this->m_osItf->pfnGetGpuContext(this->m_osItf);
740
741 if (MOS_RCS_ENGINE_USED(gpuContext) &&
742 ((M_MMIO_RCS_HW_FE_REMAP_RANGE_BEGIN <= reg && reg <= M_MMIO_RCS_HW_FE_REMAP_RANGE_END)
743 ||(M_MMIO_RCS_AUX_TBL_REMAP_RANGE_BEGIN <= reg && reg <= M_MMIO_RCS_AUX_TBL_REMAP_RANGE_END)
744 ||(M_MMIO_RCS_TRTT_REMAP_RANGE_BEGIN <= reg && reg <= M_MMIO_RCS_TRTT_REMAP_RANGE_END)
745 ||(M_MMIO_CCS0_HW_FRONT_END_BASE_BEGIN <= reg && reg <= M_MMIO_CCS0_HW_FRONT_END_BASE_END)
746 ||(M_MMIO_CCS1_HW_FRONT_END_BASE_BEGIN <= reg && reg <= M_MMIO_CCS1_HW_FRONT_END_BASE_END)
747 ||(M_MMIO_CCS2_HW_FRONT_END_BASE_BEGIN <= reg && reg <= M_MMIO_CCS2_HW_FRONT_END_BASE_END)
748 ||(M_MMIO_CCS3_HW_FRONT_END_BASE_BEGIN <= reg && reg <= M_MMIO_CCS3_HW_FRONT_END_BASE_END)))
749 {
750 return true;
751 }
752 else
753 {
754 return false;
755 }
756 }
757
758 bool IsRelativeMMIO(uint32_t &reg)
759 {
760 if (nullptr == this->m_osItf)
761 {
762 MHW_ASSERTMESSAGE("invalid m_osInterface for RelativeMMIO");
763 return false;
764 }
765 MOS_GPU_CONTEXT gpuContext = this->m_osItf->pfnGetGpuContext(this->m_osItf);
766
767 if ((MOS_VCS_ENGINE_USED(gpuContext) ||
768 MOS_VECS_ENGINE_USED(gpuContext) ||
769 MOS_TEECS_ENGINE_USED(gpuContext)) &&
770 (reg >= M_MMIO_MEDIA_LOW_OFFSET && reg < M_MMIO_MEDIA_HIGH_OFFSET))
771 {
772 reg &= M_MMIO_MAX_RELATIVE_OFFSET;
773 return true;
774 }
775 return false;
776 }
777
778 //! \brief Set TEE watchdog threshold for the trusted execution engine.
779 //! Called only when isTee is true in SetWatchdogTimerThreshold.
780 //! The default implementation applies to all platforms that use
781 //! the trusted execution engine for protected content.
782 //! Platforms that do not exercise the isTee path are unaffected
783 //! since this function is never called for them.
784 //! Do NOT override this to return an error -- doing so will cause
785 //! SetWatchdogTimerThreshold to fail via MHW_MI_CHK_STATUS and
786 //! break TEE initialization on platforms that need it.
787 virtual MOS_STATUS SetTeeWatchdogThreshold()
788 {
789 MediaResetParam.watchdogCountThreshold = WATCHDOG_TEE_DEFAULT_WATCHDOG_THRESHOLD_IN_MS;
790 return MOS_STATUS_SUCCESS;
791 }
792
793 virtual void GetWatchdogThreshold(PMOS_INTERFACE osInterface)
794 {
795 uint32_t countThreshold = 0;
796 #if (_DEBUG || _RELEASE_INTERNAL)
797 // User feature config of watchdog timer threshold
798 ReadUserSettingForDebug(
799 m_userSettingPtr,
800 countThreshold,
801 __MEDIA_USER_FEATURE_VALUE_MEDIA_RESET_TH,
802 MediaUserSetting::Group::Device);
803 if (countThreshold != 0)
804 {
805 MediaResetParam.watchdogCountThreshold = countThreshold;
806 }
807 #endif
808 }
809
810 //! \brief Set decoder-specific watchdog threshold based on resolution.
811 //! Override in platform implementations for different threshold tiers.
812 virtual void SetDecoderWatchdogThreshold(uint32_t frameWidth, uint32_t frameHeight, uint32_t codecMode)
813 {
814 // Default: Group A behavior
815 if ((frameWidth * frameHeight) >= (7680 * 4320))
816 {
817 MediaResetParam.watchdogCountThreshold = MHW_MI_DECODER_8K_WATCHDOG_THRESHOLD_IN_MS;
818 }
819 else if ((frameWidth * frameHeight) >= (3840 * 2160))
820 {
821 MediaResetParam.watchdogCountThreshold = MHW_MI_DECODER_4K_WATCHDOG_THRESHOLD_IN_MS;
822 }
823 else
824 {
825 MediaResetParam.watchdogCountThreshold = MHW_MI_DECODER_720P_WATCHDOG_THRESHOLD_IN_MS;
826 }
827
828 if ((CODECHAL_STANDARD)codecMode == CODECHAL_AV1)
829 {
830 // This is temporary solution to address the inappropriate threshold setting for high bit-rate AV1 decode.
831 // The final solution will incorporate bitstream size, increasing the setting when the bit-rate is high.
832 MediaResetParam.watchdogCountThreshold = MHW_MI_DECODER_AV1_WATCHDOG_THRESHOLD_IN_MS;
833 }
834 }
835
836 void InitMhwMiInterface()
837 {
838 MHW_FUNCTION_ENTER;
839
840 UseGlobalGtt = {};
841 MediaResetParam = {};
842
843 if (this->m_osItf == nullptr)
844 {
845 MHW_ASSERTMESSAGE("Invalid input pointers provided");
846 return;
847 }
848
849 if (!this->m_osItf->bUsesGfxAddress && !this->m_osItf->bUsesPatchList)
850 {
851 MHW_ASSERTMESSAGE("No valid addressing mode indicated");
852 return;
853 }
854
855 UseGlobalGtt.m_cs =
856 UseGlobalGtt.m_vcs =
857 UseGlobalGtt.m_vecs = MEDIA_IS_WA(this->m_osItf->pfnGetWaTable(this->m_osItf), WaForceGlobalGTT) ||
858 !MEDIA_IS_SKU(this->m_osItf->pfnGetSkuTable(this->m_osItf), FtrPPGTT);
859
860 MediaResetParam.watchdogCountThreshold = MHW_MI_DEFAULT_WATCHDOG_THRESHOLD_IN_MS;
861
862 GetWatchdogThreshold(this->m_osItf);
863
864 if (this->m_osItf->bUsesGfxAddress)
865 {
866 AddResourceToCmd = Mhw_AddResourceToCmd_GfxAddress;
867 }
868 else // if (pOsInterface->bUsesPatchList)
869 {
870 AddResourceToCmd = Mhw_AddResourceToCmd_PatchList;
871 }
872 }
873
874 void InitMmioRegisters()
875 {
876 MHW_FUNCTION_ENTER;
877 MHW_MI_MMIOREGISTERS* mmioRegisters = &m_mmioRegisters;
878
879 mmioRegisters->generalPurposeRegister0LoOffset = GP_REGISTER0_LO_OFFSET;
880 mmioRegisters->generalPurposeRegister0HiOffset = GP_REGISTER0_HI_OFFSET;
881 mmioRegisters->generalPurposeRegister4LoOffset = GP_REGISTER4_LO_OFFSET;
882 mmioRegisters->generalPurposeRegister4HiOffset = GP_REGISTER4_HI_OFFSET;
883 mmioRegisters->generalPurposeRegister11LoOffset = GP_REGISTER11_LO_OFFSET;
884 mmioRegisters->generalPurposeRegister11HiOffset = GP_REGISTER11_HI_OFFSET;
885 mmioRegisters->generalPurposeRegister12LoOffset = GP_REGISTER12_LO_OFFSET;
886 mmioRegisters->generalPurposeRegister12HiOffset = GP_REGISTER12_HI_OFFSET;
887 }
888
889 public:
890 Impl(PMOS_INTERFACE osItf) : mhw::Impl(osItf)
891 {
892 MHW_FUNCTION_ENTER;
893 }
894 _MHW_SETCMD_OVERRIDE_DECL(MI_SEMAPHORE_SIGNAL)
895 {
896 _MHW_SETCMD_CALLBASE(MI_SEMAPHORE_SIGNAL);
897
898 return MOS_STATUS_SUCCESS;
899 }
900
901 _MHW_SETCMD_OVERRIDE_DECL(MI_SEMAPHORE_WAIT)
902 {
903 _MHW_SETCMD_CALLBASE(MI_SEMAPHORE_WAIT);
904
905 if (params.presSemaphoreMem)
906 {
907 MHW_MI_CHK_NULL(this->m_currentCmdBuf);
908 MHW_RESOURCE_PARAMS resourceParams ={};
909 resourceParams.presResource = params.presSemaphoreMem;
910 resourceParams.dwOffset = params.dwResourceOffset;
911 resourceParams.pdwCmd = cmd.DW2_3.Value;
912 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DW2_3.Value);;
913 resourceParams.dwLsbNum = MHW_COMMON_MI_GENERAL_SHIFT;
914 resourceParams.HwCommandType = MOS_MI_SEMAPHORE_WAIT;
915
916 MHW_MI_CHK_STATUS(AddResourceToCmd(
917 this->m_osItf,
918 this->m_currentCmdBuf,
919 &resourceParams));
920 }
921 else if (params.gpuVirtualAddress != 0)
922 {
923 cmd.DW2_3.SemaphoreAddress = (params.gpuVirtualAddress) >> MHW_COMMON_MI_GENERAL_SHIFT;
924 }
925 else
926 {
927 MHW_ASSERTMESSAGE("Invalid parameter, both resource and gpuva zero.");
928 return MOS_STATUS_INVALID_PARAMETER;
929 }
930
931 cmd.DW0.MemoryType = IsGlobalGttInUse();
932 cmd.DW0.WaitMode = params.bPollingWaitMode;
933 cmd.DW0.CompareOperation = params.CompareOperation;
934 cmd.DW1.SemaphoreDataDword = params.dwSemaphoreData;
935 cmd.DW4.WaitTokenNumber = params.waitTokenNumber;
936
937 return MOS_STATUS_SUCCESS;
938 }
939
940 #ifdef _MEDIA_RESERVED
941 _MHW_SETCMD_OVERRIDE_DECL(MI_SEMAPHORE_WAIT_64)
942 {
943 return MOS_STATUS_SUCCESS;
944 }
945 #endif
946
947 _MHW_SETCMD_OVERRIDE_DECL(PIPE_CONTROL)
948 {
949 _MHW_SETCMD_CALLBASE(PIPE_CONTROL);
950
951 return MOS_STATUS_SUCCESS;
952 }
953
954 _MHW_SETCMD_OVERRIDE_DECL(MI_BATCH_BUFFER_START)
955 {
956 _MHW_SETCMD_CALLBASE(MI_BATCH_BUFFER_START);
957
958 return MOS_STATUS_SUCCESS;
959 }
960
961
962 _MHW_SETCMD_OVERRIDE_DECL(MI_CONDITIONAL_BATCH_BUFFER_END)
963 {
964 _MHW_SETCMD_CALLBASE(MI_CONDITIONAL_BATCH_BUFFER_END);
965
966 return MOS_STATUS_SUCCESS;
967 }
968
969 _MHW_SETCMD_OVERRIDE_DECL(MI_SET_PREDICATE)
970 {
971 _MHW_SETCMD_CALLBASE(MI_SET_PREDICATE);
972
973 return MOS_STATUS_SUCCESS;
974 }
975
976 _MHW_SETCMD_OVERRIDE_DECL(MI_STORE_REGISTER_MEM)
977 {
978 _MHW_SETCMD_CALLBASE(MI_STORE_REGISTER_MEM);
979
980 MHW_MI_CHK_NULL(this->m_currentCmdBuf);
981 MHW_MI_CHK_NULL(params.presStoreBuffer);
982
983 MHW_RESOURCE_PARAMS resourceParams = {};
984 resourceParams.presResource = params.presStoreBuffer;
985 resourceParams.dwOffset = params.dwOffset;
986 resourceParams.pdwCmd = cmd.DW2_3.Value;
987 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DW2_3.Value);;
988 resourceParams.dwLsbNum = MHW_COMMON_MI_GENERAL_SHIFT;
989 resourceParams.HwCommandType = MOS_MI_STORE_REGISTER_MEM;
990 resourceParams.bIsWritable = true;
991
992 MHW_MI_CHK_STATUS(AddResourceToCmd(
993 this->m_osItf,
994 this->m_currentCmdBuf,
995 &resourceParams));
996
997 cmd.DW0.UseGlobalGtt = IsGlobalGttInUse();
998 cmd.DW1.RegisterAddress = params.dwRegister >> 2;
999
1000 return MOS_STATUS_SUCCESS;
1001 }
1002
1003 _MHW_SETCMD_OVERRIDE_DECL(MI_LOAD_REGISTER_MEM)
1004 {
1005 _MHW_SETCMD_CALLBASE(MI_LOAD_REGISTER_MEM);
1006
1007 if (params.presStoreBuffer)
1008 {
1009 MHW_MI_CHK_NULL(this->m_currentCmdBuf);
1010 MHW_MI_CHK_NULL(params.presStoreBuffer);
1011
1012 MHW_RESOURCE_PARAMS resourceParams = {};
1013 resourceParams.presResource = params.presStoreBuffer;
1014 resourceParams.dwOffset = params.dwOffset;
1015 resourceParams.pdwCmd = cmd.DW2_3.Value;
1016 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DW2_3.Value);;
1017 resourceParams.dwLsbNum = MHW_COMMON_MI_GENERAL_SHIFT;
1018 resourceParams.HwCommandType = MOS_MI_LOAD_REGISTER_MEM;
1019 resourceParams.bIsWritable = true;
1020
1021 MHW_MI_CHK_STATUS(AddResourceToCmd(
1022 this->m_osItf,
1023 this->m_currentCmdBuf,
1024 &resourceParams));
1025 }
1026 else if (params.gpuVirtualAddress)
1027 {
1028 cmd.DW2_3.MemoryAddress = (params.gpuVirtualAddress) >> MHW_COMMON_MI_GENERAL_SHIFT;
1029 }
1030 else
1031 {
1032 MHW_ASSERTMESSAGE("Invalid parameter, both resource and gpuva zero.");
1033 return MOS_STATUS_INVALID_PARAMETER;
1034 }
1035
1036 cmd.DW0.UseGlobalGtt = IsGlobalGttInUse();
1037 cmd.DW1.RegisterAddress = params.dwRegister >> 2;
1038
1039 return MOS_STATUS_SUCCESS;
1040 }
1041
1042 _MHW_SETCMD_OVERRIDE_DECL(MI_LOAD_REGISTER_IMM)
1043 {
1044 _MHW_SETCMD_CALLBASE(MI_LOAD_REGISTER_IMM);
1045
1046 cmd.DW1.RegisterOffset = params.dwRegister >> 2;
1047 cmd.DW2.DataDword = params.dwData;
1048
1049 return MOS_STATUS_SUCCESS;
1050 }
1051
1052 _MHW_SETCMD_OVERRIDE_DECL(MI_LOAD_REGISTER_REG)
1053 {
1054 _MHW_SETCMD_CALLBASE(MI_LOAD_REGISTER_REG);
1055
1056 cmd.DW1.SourceRegisterAddress = params.dwSrcRegister >> 2;
1057 cmd.DW2.DestinationRegisterAddress = params.dwDstRegister >> 2;
1058
1059 return MOS_STATUS_SUCCESS;
1060 }
1061
1062 _MHW_SETCMD_OVERRIDE_DECL(MI_FORCE_WAKEUP)
1063 {
1064 _MHW_SETCMD_CALLBASE(MI_FORCE_WAKEUP);
1065
1066 return MOS_STATUS_SUCCESS;
1067 }
1068
1069 _MHW_SETCMD_OVERRIDE_DECL(VD_CONTROL_STATE)
1070 {
1071 _MHW_SETCMD_CALLBASE(VD_CONTROL_STATE);
1072
1073 return MOS_STATUS_SUCCESS;
1074 }
1075
1076 _MHW_SETCMD_OVERRIDE_DECL(MEDIA_STATE_FLUSH)
1077 {
1078 _MHW_SETCMD_CALLBASE(MEDIA_STATE_FLUSH);
1079
1080 return MOS_STATUS_SUCCESS;
1081 }
1082
1083 _MHW_SETCMD_OVERRIDE_DECL(MI_BATCH_BUFFER_END)
1084 {
1085 _MHW_SETCMD_CALLBASE(MI_BATCH_BUFFER_END);
1086
1087 return MOS_STATUS_SUCCESS;
1088 }
1089
1090 _MHW_SETCMD_OVERRIDE_DECL(MI_FLUSH_DW)
1091 {
1092 _MHW_SETCMD_CALLBASE(MI_FLUSH_DW);
1093
1094 return MOS_STATUS_SUCCESS;
1095 }
1096
1097 _MHW_SETCMD_OVERRIDE_DECL(MI_NOOP)
1098 {
1099 _MHW_SETCMD_CALLBASE(MI_NOOP);
1100
1101 return MOS_STATUS_SUCCESS;
1102 }
1103
1104 _MHW_SETCMD_OVERRIDE_DECL(MI_ATOMIC)
1105 {
1106 _MHW_SETCMD_CALLBASE(MI_ATOMIC);
1107 if (params.pOsResource)
1108 {
1109 MHW_RESOURCE_PARAMS resourceParams = {};
1110 resourceParams.presResource = params.pOsResource;
1111 resourceParams.dwOffset = params.dwResourceOffset;
1112 resourceParams.pdwCmd = &(cmd.DW1.Value);
1113 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DW1.Value);;
1114 resourceParams.dwLsbNum = MHW_COMMON_MI_GENERAL_SHIFT;
1115 resourceParams.HwCommandType = MOS_MI_ATOMIC;
1116 resourceParams.bIsWritable = true;
1117
1118 MHW_MI_CHK_STATUS(AddResourceToCmd(
1119 this->m_osItf,
1120 this->m_currentCmdBuf,
1121 &resourceParams));
1122 }
1123 else if (params.gpuVirtualAddress != 0)
1124 {
1125 cmd.DW1.MemoryAddress = (params.gpuVirtualAddress) >> MHW_COMMON_MI_GENERAL_SHIFT;
1126 cmd.DW2.MemoryAddressHigh = ((params.gpuVirtualAddress & 0xFFFFFFFF00000000) >> 32);
1127 }
1128
1129 cmd.DW0.DwordLength = params.bInlineData ? 1 : 9;
1130 cmd.DW0.MemoryType = IsGlobalGttInUse();
1131 cmd.DW0.ReturnDataControl = params.bReturnData;
1132 if (params.dwDataSize == sizeof(uint32_t))
1133 {
1134 cmd.DW0.DataSize = cmd.DATA_SIZE_DWORD;
1135 }
1136 else if (params.dwDataSize == sizeof(uint64_t))
1137 {
1138 cmd.DW0.DataSize = cmd.DATA_SIZE_QWORD;
1139 }
1140 else if (params.dwDataSize == sizeof(uint64_t) * 2)
1141 {
1142 cmd.DW0.DataSize = cmd.DATA_SIZE_OCTWORD;
1143 }
1144 else
1145 {
1146 MHW_ASSERTMESSAGE("Invalid data size provided");
1147 return MOS_STATUS_INVALID_PARAMETER;
1148 }
1149
1150 if (cmd.DW0.DataSize == cmd.DATA_SIZE_QWORD)
1151 {
1152 cmd.DW0.AtomicOpcode = MHW_MI_ATOMIC_QWORD;
1153 }
1154 else if (cmd.DW0.DataSize == cmd.DATA_SIZE_OCTWORD)
1155 {
1156 if (params.Operation != MHW_MI_ATOMIC_CMP)
1157 {
1158 MHW_ASSERTMESSAGE("An OCTWORD may only be used in the case of a compare operation!");
1159 return MOS_STATUS_INVALID_PARAMETER;
1160 }
1161 cmd.DW0.AtomicOpcode = MHW_MI_ATOMIC_OCTWORD;
1162 }
1163 cmd.DW0.AtomicOpcode = CreateMiAtomicOpcode(
1164 cmd.DW0.AtomicOpcode,
1165 params.Operation);
1166 if (cmd.DW0.AtomicOpcode == MHW_MI_ATOMIC_NONE)
1167 {
1168 MHW_ASSERTMESSAGE("No MI_ATOMIC opcode could be generated");
1169 return MOS_STATUS_INVALID_PARAMETER;
1170 }
1171
1172 cmd.DW0.InlineData = params.bInlineData;
1173 cmd.DW0.DwordLength = params.bInlineData ? 9 : 1;
1174
1175 if (params.bInlineData)
1176 {
1177 cmd.DW3.Operand1DataDword0 = params.dwOperand1Data[0];
1178 cmd.DW4.Operand2DataDword0 = params.dwOperand2Data[0];
1179 cmd.DW5.Operand1DataDword1 = params.dwOperand1Data[1];
1180 cmd.DW6.Operand2DataDword1 = params.dwOperand2Data[1];
1181 cmd.DW7.Operand1DataDword2 = params.dwOperand1Data[2];
1182 cmd.DW8.Operand2DataDword2 = params.dwOperand2Data[3];
1183 cmd.DW9.Operand1DataDword3 = params.dwOperand1Data[3];
1184 cmd.DW10.Operand2DataDword3 = params.dwOperand2Data[3];
1185 }
1186
1187 return MOS_STATUS_SUCCESS;
1188 }
1189
1190 _MHW_SETCMD_OVERRIDE_DECL(MI_STORE_DATA_IMM)
1191 {
1192 _MHW_SETCMD_CALLBASE(MI_STORE_DATA_IMM);
1193 MHW_MI_CHK_NULL(this->m_currentCmdBuf);
1194 MHW_MI_CHK_NULL(params.pOsResource);
1195
1196 MHW_RESOURCE_PARAMS resourceParams = {};
1197 resourceParams.presResource = params.pOsResource;
1198 resourceParams.dwOffset = params.dwResourceOffset;
1199 resourceParams.pdwCmd = cmd.DW1_2.Value;
1200 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DW1_2.Value);
1201 resourceParams.dwLsbNum = MHW_COMMON_MI_STORE_DATA_DW_SHIFT;
1202 resourceParams.HwCommandType = MOS_MI_STORE_DATA_IMM;
1203 resourceParams.bIsWritable = true;
1204
1205 MHW_MI_CHK_STATUS(AddResourceToCmd(
1206 this->m_osItf,
1207 this->m_currentCmdBuf,
1208 &resourceParams));
1209
1210 cmd.DW0.UseGlobalGtt = IsGlobalGttInUse();
1211 // Force single DW write, driver never writes a QW
1212 cmd.DW0.StoreQword = 0;
1213 cmd.DW0.DwordLength--;
1214
1215 cmd.DW3.DataDword0 = params.dwValue;
1216
1217 return MOS_STATUS_SUCCESS;
1218 }
1219
1220 _MHW_SETCMD_OVERRIDE_DECL(MI_MATH)
1221 {
1222 _MHW_SETCMD_CALLBASE(MI_MATH);
1223 MHW_MI_CHK_NULL(this->m_currentCmdBuf);
1224
1225 if (params.dwNumAluParams == 0 || params.pAluPayload == nullptr)
1226 {
1227 MHW_ASSERTMESSAGE("MI_MATH requires a valid payload");
1228 return MOS_STATUS_INVALID_PARAMETER;
1229 }
1230
1231 cmd.DW0.DwordLength = params.dwNumAluParams - 1;
1232
1233 return MOS_STATUS_SUCCESS;
1234 }
1235
1236 _MHW_SETCMD_OVERRIDE_DECL(MI_COPY_MEM_MEM)
1237 {
1238 _MHW_SETCMD_CALLBASE(MI_COPY_MEM_MEM);
1239
1240 MHW_MI_CHK_NULL(this->m_currentCmdBuf);
1241 MHW_MI_CHK_NULL(params.presSrc);
1242 MHW_MI_CHK_NULL(params.presDst);
1243
1244 cmd.DW0.UseGlobalGttDestination = IsGlobalGttInUse();
1245 cmd.DW0.UseGlobalGttSource = IsGlobalGttInUse();
1246
1247 MHW_RESOURCE_PARAMS resourceParams = {};
1248 resourceParams.presResource = params.presDst;
1249 resourceParams.dwOffset = params.dwDstOffset;
1250 resourceParams.pdwCmd = cmd.DW1_2.Value;
1251 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DW1_2.Value);
1252 resourceParams.dwLsbNum = MHW_COMMON_MI_GENERAL_SHIFT;
1253 resourceParams.HwCommandType = MOS_MI_COPY_MEM_MEM;
1254 resourceParams.bIsWritable = true;
1255
1256 MHW_MI_CHK_STATUS(AddResourceToCmd(
1257 this->m_osItf,
1258 this->m_currentCmdBuf,
1259 &resourceParams));
1260
1261 resourceParams = {};
1262 resourceParams.presResource = params.presSrc;
1263 resourceParams.dwOffset = params.dwSrcOffset;
1264 resourceParams.pdwCmd = cmd.DW3_4.Value;
1265 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DW3_4.Value);
1266 resourceParams.dwLsbNum = MHW_COMMON_MI_GENERAL_SHIFT;
1267 resourceParams.HwCommandType = MOS_MI_COPY_MEM_MEM;
1268 resourceParams.bIsWritable = false;
1269
1270 MHW_MI_CHK_STATUS(AddResourceToCmd(
1271 this->m_osItf,
1272 this->m_currentCmdBuf,
1273 &resourceParams));
1274
1275 return MOS_STATUS_SUCCESS;
1276 }
1277
1278 _MHW_SETCMD_OVERRIDE_DECL(MFX_WAIT)
1279 {
1280 _MHW_SETCMD_CALLBASE(MFX_WAIT);
1281
1282 cmd.DW0.MfxSyncControlFlag = params.iStallVdboxPipeline;
1283
1284 // set the protection bit based on CP status
1285 MHW_MI_CHK_STATUS(m_cpInterface->SetProtectionSettingsForMfxWait(this->m_osItf, &cmd));
1286
1287 return MOS_STATUS_SUCCESS;
1288 }
1289 MEDIA_CLASS_DEFINE_END(mhw__mi__Impl)
1290 };
1291 } // namespace render
1292 } // namespace mhw
1293
1294 #endif // __MHW_RENDER_IMPL_H__