Debian Codegraph @

media_driver/agnostic/common/codec/hal/codechal_hw.cpp

raw
1 /*
2 * Copyright (c) 2011-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 codechal_hw.cpp
24 //! \brief This modules implements HW interface layer to be used on all platforms on all operating systems/DDIs, across CODECHAL components.
25 //!
26 #include "codechal_hw.h"
27 #include "codechal_setting.h"
28 #include "mos_os_cp_interface_specific.h"
29
30 CodechalHwInterface::CodechalHwInterface(
31 PMOS_INTERFACE osInterface,
32 CODECHAL_FUNCTION codecFunction,
33 MhwInterfaces *mhwInterfaces,
34 bool disableScalability)
35 {
36 CODECHAL_HW_FUNCTION_ENTER;
37
38 // Basic intialization
39 m_osInterface = osInterface;
40
41 MOS_ZeroMemory(&m_platform, sizeof(PLATFORM));
42 m_osInterface->pfnGetPlatform(m_osInterface, &m_platform);
43
44 m_skuTable = m_osInterface->pfnGetSkuTable(m_osInterface);
45 m_waTable = m_osInterface->pfnGetWaTable(m_osInterface);
46
47 CODECHAL_HW_ASSERT(m_skuTable);
48 CODECHAL_HW_ASSERT(m_waTable);
49
50 // Init sub-interfaces
51 m_cpInterface = mhwInterfaces->m_cpInterface;
52 m_mfxInterface = mhwInterfaces->m_mfxInterface;
53 m_hcpInterface = mhwInterfaces->m_hcpInterface;
54 m_hucInterface = mhwInterfaces->m_hucInterface;
55 m_vdencInterface = mhwInterfaces->m_vdencInterface;
56 m_veboxInterface = mhwInterfaces->m_veboxInterface;
57 m_sfcInterface = mhwInterfaces->m_sfcInterface;
58 m_miInterface = mhwInterfaces->m_miInterface;
59 m_renderInterface = mhwInterfaces->m_renderInterface;
60 // Prevent double free
61 mhwInterfaces->m_cpInterface = nullptr;
62 mhwInterfaces->m_mfxInterface = nullptr;
63 mhwInterfaces->m_hcpInterface = nullptr;
64 mhwInterfaces->m_hucInterface = nullptr;
65 mhwInterfaces->m_vdencInterface = nullptr;
66 mhwInterfaces->m_veboxInterface = nullptr;
67 mhwInterfaces->m_sfcInterface = nullptr;
68 mhwInterfaces->m_miInterface = nullptr;
69 mhwInterfaces->m_renderInterface = nullptr;
70
71 m_stateHeapSettings = MHW_STATE_HEAP_SETTINGS();
72 m_disableScalability = disableScalability;
73
74 MOS_ZeroMemory(&m_hucDmemDummy, sizeof(m_hucDmemDummy));
75 MOS_ZeroMemory(&m_dummyStreamIn, sizeof(m_dummyStreamIn));
76 MOS_ZeroMemory(&m_dummyStreamOut, sizeof(m_dummyStreamOut));
77 MOS_ZeroMemory(&m_conditionalBbEndDummy, sizeof(m_conditionalBbEndDummy));
78
79 InitMemoryObjectCacheSettings();
80 }
81
82 CodechalHwInterface *CodechalHwInterface::Create(
83 PMOS_INTERFACE osInterface,
84 CODECHAL_FUNCTION codecFunction,
85 MhwInterfaces *mhwInterfaces,
86 bool disableScalability)
87 {
88 return MOS_New(CodechalHwInterface,
89 osInterface, codecFunction, mhwInterfaces, disableScalability);
90 }
91
92 MOS_STATUS CodechalHwInterface::SetCacheabilitySettings(
93 MHW_MEMORY_OBJECT_CONTROL_PARAMS cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_END_CODEC])
94 {
95 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
96
97 CODECHAL_HW_FUNCTION_ENTER;
98
99 if (m_mfxInterface)
100 {
101 CODECHAL_HW_CHK_STATUS_RETURN(m_mfxInterface->SetCacheabilitySettings(cacheabilitySettings));
102 }
103 if (m_hcpInterface)
104 {
105 CODECHAL_HW_CHK_STATUS_RETURN(m_hcpInterface->SetCacheabilitySettings(cacheabilitySettings));
106 }
107 if (m_vdencInterface)
108 {
109 CODECHAL_HW_CHK_STATUS_RETURN(m_vdencInterface->SetCacheabilitySettings(cacheabilitySettings));
110 }
111 if (m_hucInterface)
112 {
113 CODECHAL_HW_CHK_STATUS_RETURN(m_hucInterface->SetCacheabilitySettings(cacheabilitySettings));
114 }
115 return eStatus;
116 }
117
118 MOS_STATUS CodechalHwInterface::SetRowstoreCachingOffsets(
119 PMHW_VDBOX_ROWSTORE_PARAMS rowstoreParams)
120 {
121 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
122
123 CODECHAL_HW_FUNCTION_ENTER;
124
125 if (m_vdencInterface)
126 {
127 CODECHAL_HW_CHK_STATUS_RETURN(m_vdencInterface->GetRowstoreCachingAddrs(rowstoreParams));
128 }
129 if (m_mfxInterface)
130 {
131 CODECHAL_HW_CHK_STATUS_RETURN(m_mfxInterface->GetRowstoreCachingAddrs(rowstoreParams));
132 }
133 if (m_hcpInterface)
134 {
135 CODECHAL_HW_CHK_STATUS_RETURN(m_hcpInterface->GetRowstoreCachingAddrs(rowstoreParams));
136 }
137
138 return eStatus;
139 }
140
141 MOS_STATUS CodechalHwInterface::InitCacheabilityControlSettings(
142 CODECHAL_FUNCTION codecFunction)
143 {
144 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
145
146 CODECHAL_HW_FUNCTION_ENTER;
147
148 CODECHAL_HW_CHK_STATUS_RETURN(InitMemoryObjectCacheSettings());
149 CODECHAL_HW_CHK_STATUS_RETURN(InitL3CacheSettings());
150
151 return eStatus;
152 }
153
154 MOS_STATUS CodechalHwInterface::InitMemoryObjectCacheSettings()
155 {
156 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
157
158 CODECHAL_HW_FUNCTION_ENTER;
159
160 CODECHAL_HW_CHK_NULL_RETURN(m_osInterface);
161
162 for (uint32_t i = MOS_CODEC_RESOURCE_USAGE_BEGIN_CODEC + 1; i < MOS_CODEC_RESOURCE_USAGE_END_CODEC; i++)
163 {
164 CODECHAL_HW_CHK_STATUS_RETURN(CachePolicyGetMemoryObject(
165 (MOS_HW_RESOURCE_DEF)i));
166 }
167
168 SetCacheabilitySettings(m_cacheabilitySettings);
169
170 return eStatus;
171 }
172
173 MOS_STATUS CodechalHwInterface::InitL3CacheSettings()
174 {
175 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
176
177 CODECHAL_HW_FUNCTION_ENTER;
178
179 CODECHAL_HW_CHK_NULL_RETURN(m_osInterface);
180
181 // This code needs to be removed
182 PMHW_MEMORY_OBJECT_CONTROL_PARAMS cacheabilitySettings = &m_cacheabilitySettings[0];
183 bool l3CachingEnabled = !m_osInterface->bSimIsActive;
184
185 if (m_checkTargetCache)
186 {
187 l3CachingEnabled =
188 ((cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_SURFACE_CURR_ENCODE].Gen8.TargetCache == 0x3) ||
189 (cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_SURFACE_REF_ENCODE].Gen8.TargetCache == 0x3) ||
190 (cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_SURFACE_MV_DATA_ENCODE].Gen8.TargetCache == 0x3) ||
191 (cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_SURFACE_HME_DOWNSAMPLED_ENCODE].Gen8.TargetCache == 0x3));
192 }
193
194 if (m_checkBankCount)
195 {
196 CODECHAL_HW_CHK_NULL_RETURN(m_osInterface);
197 auto gtSysInfo = m_osInterface->pfnGetGtSystemInfo(m_osInterface);
198 CODECHAL_HW_CHK_NULL_RETURN(gtSysInfo);
199
200 l3CachingEnabled = (gtSysInfo->L3BankCount != 0 || gtSysInfo->L3CacheSizeInKb != 0);
201 }
202
203 if (l3CachingEnabled)
204 {
205 if (m_renderInterface)
206 {
207 // Get default L3 cache settings
208 CODECHAL_HW_CHK_STATUS_RETURN(m_renderInterface->EnableL3Caching(nullptr));
209
210 #if (_DEBUG || _RELEASE_INTERNAL)
211 // Override default L3 cache settings
212 auto l3CacheConfig =
213 m_renderInterface->GetL3CacheConfig();
214 MHW_RENDER_ENGINE_L3_CACHE_SETTINGS l3Overrides;
215 CODECHAL_HW_CHK_STATUS_RETURN(InitL3ControlUserFeatureSettings(
216 l3CacheConfig,
217 &l3Overrides));
218 CODECHAL_HW_CHK_STATUS_RETURN(m_renderInterface->EnableL3Caching(
219 &l3Overrides));
220 #endif // (_DEBUG || _RELEASE_INTERNAL)
221 }
222 }
223
224 return MOS_STATUS_SUCCESS;
225 }
226
227 MOS_STATUS CodechalHwInterface::CachePolicyGetMemoryObject(
228 MOS_HW_RESOURCE_DEF mosUsage)
229 {
230 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
231
232 m_cacheabilitySettings[mosUsage].Value =
233 (m_osInterface->pfnCachePolicyGetMemoryObject(
234 mosUsage,
235 m_osInterface->pfnGetGmmClientContext(m_osInterface))).DwordValue;
236
237 m_cacheabilitySettings[mosUsage].Value = ComposeSurfaceCacheabilityControl(
238 mosUsage,
239 codechalUncacheableWa);
240
241 return eStatus;
242 }
243
244 MOS_STATUS CodechalHwInterface::GetMfxStateCommandsDataSize(
245 uint32_t mode,
246 uint32_t *commandsSize,
247 uint32_t *patchListSize,
248 bool shortFormat)
249 {
250 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
251
252 CODECHAL_HW_FUNCTION_ENTER;
253
254 uint32_t cpCmdsize = 0;
255 uint32_t cpPatchListSize = 0;
256
257 if (m_mfxInterface)
258 {
259 CODECHAL_HW_CHK_STATUS_RETURN(m_mfxInterface->GetMfxStateCommandsDataSize(
260 mode, (uint32_t*)commandsSize, (uint32_t*)patchListSize, shortFormat ? true : false));
261
262 m_cpInterface->GetCpStateLevelCmdSize(cpCmdsize, cpPatchListSize);
263 }
264 *commandsSize += (uint32_t)cpCmdsize;
265 *patchListSize += (uint32_t)cpPatchListSize;
266
267 return eStatus;
268 }
269
270 MOS_STATUS CodechalHwInterface::GetMfxPrimitiveCommandsDataSize(
271 uint32_t mode,
272 uint32_t *commandsSize,
273 uint32_t *patchListSize,
274 bool modeSpecific)
275 {
276 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
277
278 CODECHAL_HW_FUNCTION_ENTER;
279
280 uint32_t cpCmdsize = 0;
281 uint32_t cpPatchListSize = 0;
282
283 if (m_mfxInterface)
284 {
285 CODECHAL_HW_CHK_STATUS_RETURN(m_mfxInterface->GetMfxPrimitiveCommandsDataSize(
286 mode, (uint32_t*)commandsSize, (uint32_t*)patchListSize, modeSpecific ? true : false));
287
288 m_cpInterface->GetCpSliceLevelCmdSize(cpCmdsize, cpPatchListSize);
289 }
290
291 *commandsSize += (uint32_t)cpCmdsize;
292 *patchListSize += (uint32_t)cpPatchListSize;
293
294 return eStatus;
295 }
296
297 MOS_STATUS CodechalHwInterface::GetHxxStateCommandSize(
298 uint32_t mode,
299 uint32_t *commandsSize,
300 uint32_t *patchListSize,
301 PMHW_VDBOX_STATE_CMDSIZE_PARAMS params)
302 {
303 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
304
305 CODECHAL_HW_FUNCTION_ENTER;
306
307 uint32_t standard = CodecHal_GetStandardFromMode(mode);
308
309 uint32_t hcpCommandsSize = 0;
310 uint32_t hcpPatchListSize = 0;
311 uint32_t cpCmdsize = 0;
312 uint32_t cpPatchListSize = 0;
313
314 if (m_hcpInterface && (standard == CODECHAL_HEVC || standard == CODECHAL_VP9))
315 {
316 CODECHAL_HW_CHK_STATUS_RETURN(m_hcpInterface->GetHcpStateCommandSize(
317 mode, (uint32_t*)&hcpCommandsSize, (uint32_t*)&hcpPatchListSize, params));
318
319 m_cpInterface->GetCpStateLevelCmdSize(cpCmdsize, cpPatchListSize);
320 }
321
322 uint32_t hucCommandsSize = 0;
323 uint32_t hucPatchListSize = 0;
324
325 if (m_hucInterface && (standard == CODECHAL_HEVC || standard == CODECHAL_CENC || standard == CODECHAL_VP9 || standard == CODECHAL_AVC))
326 {
327 CODECHAL_HW_CHK_STATUS_RETURN(m_hucInterface->GetHucStateCommandSize(
328 mode, (uint32_t*)&hucCommandsSize, (uint32_t*)&hucPatchListSize, params));
329 }
330
331 *commandsSize = hcpCommandsSize + hucCommandsSize + (uint32_t)cpCmdsize;
332 *patchListSize = hcpPatchListSize + hucPatchListSize + (uint32_t)cpPatchListSize;
333
334 return eStatus;
335 }
336
337 MOS_STATUS CodechalHwInterface::GetHxxPrimitiveCommandSize(
338 uint32_t mode,
339 uint32_t *commandsSize,
340 uint32_t *patchListSize,
341 bool modeSpecific)
342 {
343 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
344
345 CODECHAL_HW_FUNCTION_ENTER;
346
347 uint32_t standard = CodecHal_GetStandardFromMode(mode);
348
349 uint32_t hcpCommandsSize = 0;
350 uint32_t hcpPatchListSize = 0;
351 uint32_t cpCmdsize = 0;
352 uint32_t cpPatchListSize = 0;
353
354 if (m_hcpInterface && (standard == CODECHAL_HEVC || standard == CODECHAL_VP9))
355 {
356 CODECHAL_HW_CHK_STATUS_RETURN(m_hcpInterface->GetHcpPrimitiveCommandSize(
357 mode, (uint32_t*)&hcpCommandsSize, (uint32_t*)&hcpPatchListSize, modeSpecific ? true : false));
358
359 m_cpInterface->GetCpSliceLevelCmdSize(cpCmdsize, cpPatchListSize);
360 }
361
362 uint32_t hucCommandsSize = 0;
363 uint32_t hucPatchListSize = 0;
364
365 if (m_hucInterface && (standard == CODECHAL_HEVC || standard == CODECHAL_CENC || standard == CODECHAL_VP9))
366 {
367 CODECHAL_HW_CHK_STATUS_RETURN(m_hucInterface->GetHucPrimitiveCommandSize(
368 mode, (uint32_t*)&hucCommandsSize, (uint32_t*)&hucPatchListSize));
369 }
370
371 *commandsSize = hcpCommandsSize + hucCommandsSize + (uint32_t)cpCmdsize;
372 *patchListSize = hcpPatchListSize + hucPatchListSize + (uint32_t)cpPatchListSize;
373
374 return eStatus;
375 }
376
377 MOS_STATUS CodechalHwInterface::GetHcpStateCommandSize(
378 uint32_t mode,
379 uint32_t * commandsSize,
380 uint32_t * patchListSize,
381 PMHW_VDBOX_STATE_CMDSIZE_PARAMS params)
382 {
383 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
384
385 CODECHAL_HW_FUNCTION_ENTER;
386
387 uint32_t standard = CodecHal_GetStandardFromMode(mode);
388
389 uint32_t hcpCommandsSize = 0;
390 uint32_t hcpPatchListSize = 0;
391 uint32_t cpCmdsize = 0;
392 uint32_t cpPatchListSize = 0;
393
394 if (m_hcpInterface && (standard == CODECHAL_HEVC || standard == CODECHAL_VP9))
395 {
396 CODECHAL_HW_CHK_STATUS_RETURN(m_hcpInterface->GetHcpStateCommandSize(
397 mode, &hcpCommandsSize, &hcpPatchListSize, params));
398
399 m_cpInterface->GetCpStateLevelCmdSize(cpCmdsize, cpPatchListSize);
400 }
401
402 *commandsSize = hcpCommandsSize + cpCmdsize;
403 *patchListSize = hcpPatchListSize + cpPatchListSize;
404
405 return eStatus;
406 }
407
408 MOS_STATUS CodechalHwInterface::GetHcpPrimitiveCommandSize(
409 uint32_t mode,
410 uint32_t *commandsSize,
411 uint32_t *patchListSize,
412 bool modeSpecific)
413 {
414 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
415
416 CODECHAL_HW_FUNCTION_ENTER;
417
418 uint32_t standard = CodecHal_GetStandardFromMode(mode);
419
420 uint32_t hcpCommandsSize = 0;
421 uint32_t hcpPatchListSize = 0;
422 uint32_t cpCmdsize = 0;
423 uint32_t cpPatchListSize = 0;
424
425 if (m_hcpInterface && (standard == CODECHAL_HEVC || standard == CODECHAL_VP9))
426 {
427 CODECHAL_HW_CHK_STATUS_RETURN(m_hcpInterface->GetHcpPrimitiveCommandSize(
428 mode, &hcpCommandsSize, &hcpPatchListSize, modeSpecific ? true : false));
429
430 m_cpInterface->GetCpSliceLevelCmdSize(cpCmdsize, cpPatchListSize);
431 }
432
433 *commandsSize = hcpCommandsSize + cpCmdsize;
434 *patchListSize = hcpPatchListSize + cpPatchListSize;
435
436 return eStatus;
437 }
438
439 MOS_STATUS CodechalHwInterface::GetHucStateCommandSize(
440 uint32_t mode,
441 uint32_t * commandsSize,
442 uint32_t * patchListSize,
443 PMHW_VDBOX_STATE_CMDSIZE_PARAMS params)
444 {
445 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
446
447 CODECHAL_HW_FUNCTION_ENTER;
448
449 uint32_t standard = CodecHal_GetStandardFromMode(mode);
450 uint32_t hucCommandsSize = 0;
451 uint32_t hucPatchListSize = 0;
452 uint32_t cpCmdsize = 0;
453 uint32_t cpPatchListSize = 0;
454
455 if (m_hucInterface && (standard == CODECHAL_HEVC || standard == CODECHAL_CENC || standard == CODECHAL_VP9
456 || standard == CODECHAL_AVC || standard == CODECHAL_MPEG2 || standard == CODECHAL_VC1 || standard == CODECHAL_JPEG))
457 {
458 CODECHAL_HW_CHK_STATUS_RETURN(m_hucInterface->GetHucStateCommandSize(
459 mode, &hucCommandsSize, &hucPatchListSize, params));
460
461 m_cpInterface->GetCpStateLevelCmdSize(cpCmdsize, cpPatchListSize);
462 }
463
464 *commandsSize = hucCommandsSize + cpCmdsize;
465 *patchListSize = hucPatchListSize + cpPatchListSize;
466
467 return eStatus;
468 }
469
470 MOS_STATUS CodechalHwInterface::GetHucPrimitiveCommandSize(
471 uint32_t mode,
472 uint32_t *commandsSize,
473 uint32_t *patchListSize)
474 {
475 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
476
477 CODECHAL_HW_FUNCTION_ENTER;
478
479 uint32_t standard = CodecHal_GetStandardFromMode(mode);
480 uint32_t hucCommandsSize = 0;
481 uint32_t hucPatchListSize = 0;
482 uint32_t cpCmdsize = 0;
483 uint32_t cpPatchListSize = 0;
484
485 if (m_hucInterface && (standard == CODECHAL_HEVC || standard == CODECHAL_CENC || standard == CODECHAL_VP9))
486 {
487 CODECHAL_HW_CHK_STATUS_RETURN(m_hucInterface->GetHucPrimitiveCommandSize(
488 mode, &hucCommandsSize, &hucPatchListSize));
489 m_cpInterface->GetCpSliceLevelCmdSize(cpCmdsize, cpPatchListSize);
490 }
491
492 *commandsSize = hucCommandsSize + cpCmdsize;
493 *patchListSize = hucPatchListSize + cpPatchListSize;
494
495 return eStatus;
496 }
497
498 MOS_STATUS CodechalHwInterface::GetVdencStateCommandsDataSize(
499 uint32_t mode,
500 uint32_t *commandsSize,
501 uint32_t *patchListSize)
502 {
503 CODECHAL_HW_FUNCTION_ENTER;
504
505 MHW_MI_CHK_NULL(m_miInterface);
506 MHW_MI_CHK_NULL(m_hcpInterface);
507 MHW_MI_CHK_NULL(m_vdencInterface);
508
509 uint32_t commands = 0;
510 uint32_t patchList = 0;
511
512 uint32_t standard = CodecHal_GetStandardFromMode(mode);
513
514 MHW_MI_CHK_STATUS(m_vdencInterface->GetVdencStateCommandsDataSize(
515 mode,
516 0,
517 &commands,
518 &patchList));
519
520 commands += m_sizeOfCmdMediaReset;
521
522 if (standard == CODECHAL_AVC)
523 {
524 commands += m_miInterface->GetMiFlushDwCmdSize();
525 commands += m_miInterface->GetMiBatchBufferStartCmdSize();
526 commands += m_sizeOfCmdBatchBufferEnd;
527 }
528 else if (standard == CODECHAL_HEVC)
529 {
530 commands += m_miInterface->GetMiFlushDwCmdSize();
531 commands += m_miInterface->GetMiBatchBufferStartCmdSize();
532 commands += m_hcpInterface->GetHcpHevcVp9RdoqStateCommandSize();
533 commands += m_sizeOfCmdBatchBufferEnd;
534 }
535 else if (standard == CODECHAL_VP9)
536 {
537 commands += m_miInterface->GetMiFlushDwCmdSize();
538 commands += m_miInterface->GetMiBatchBufferStartCmdSize();
539 }
540 else if (standard == CODECHAL_AV1)
541 {
542 commands += m_miInterface->GetMiFlushDwCmdSize();
543 commands += m_miInterface->GetMiBatchBufferStartCmdSize();
544 commands += m_sizeOfCmdBatchBufferEnd;
545 }
546 else
547 {
548 MHW_ASSERTMESSAGE("Unsupported encode mode.");
549 return MOS_STATUS_UNKNOWN;
550 }
551
552 *commandsSize = commands;
553 *patchListSize = patchList;
554
555 return MOS_STATUS_SUCCESS;
556 }
557
558 MOS_STATUS CodechalHwInterface::GetVdencPrimitiveCommandsDataSize(
559 uint32_t mode,
560 uint32_t *commandsSize,
561 uint32_t *patchListSize)
562 {
563 CODECHAL_HW_FUNCTION_ENTER;
564
565 MHW_MI_CHK_NULL(m_miInterface);
566 MHW_MI_CHK_NULL(m_hcpInterface);
567 MHW_MI_CHK_NULL(m_vdencInterface);
568
569 uint32_t commands = 0;
570 uint32_t patchList = 0;
571
572 MHW_MI_CHK_STATUS(m_vdencInterface->GetVdencPrimitiveCommandsDataSize(
573 mode,
574 &commands,
575 &patchList));
576
577 *commandsSize = commands;
578 *patchListSize = patchList;
579
580 return MOS_STATUS_SUCCESS;
581 }
582
583 MOS_STATUS CodechalHwInterface::GetVdencPictureSecondLevelCommandsSize(
584 uint32_t mode,
585 uint32_t *commandsSize)
586 {
587 CODECHAL_HW_FUNCTION_ENTER;
588
589 uint32_t commands = 0;
590
591 MHW_MI_CHK_NULL(m_hcpInterface);
592 MHW_MI_CHK_NULL(m_vdencInterface);
593
594 uint32_t standard = CodecHal_GetStandardFromMode(mode);
595
596 if (standard == CODECHAL_VP9)
597 {
598 commands += m_hcpInterface->GetHcpVp9PicStateCommandSize();
599 commands += m_hcpInterface->GetHcpVp9SegmentStateCommandSize() * 8;
600 commands += 128;
601 commands += 220;
602 commands += m_sizeOfCmdBatchBufferEnd;
603 }
604 else
605 {
606 MHW_ASSERTMESSAGE("Unsupported encode mode.");
607 return MOS_STATUS_UNKNOWN;
608 }
609
610 *commandsSize = commands;
611
612 return MOS_STATUS_SUCCESS;
613 }
614
615 MOS_STATUS CodechalHwInterface::GetStreamoutCommandSize(
616 uint32_t *commandsSize,
617 uint32_t *patchListSize)
618 {
619 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
620
621 CODECHAL_HW_FUNCTION_ENTER;
622
623 MHW_VDBOX_STATE_CMDSIZE_PARAMS stateCmdSizeParams;
624
625 stateCmdSizeParams.bShortFormat = false;
626 stateCmdSizeParams.bHucDummyStream = MEDIA_IS_WA(m_waTable, WaHucStreamoutEnable);
627 CODECHAL_HW_CHK_STATUS_RETURN(GetHxxStateCommandSize(
628 CODECHAL_DECODE_MODE_CENC, // For cenc phase
629 commandsSize,
630 patchListSize,
631 &stateCmdSizeParams));
632
633 return eStatus;
634 }
635
636 MOS_STATUS CodechalHwInterface::Initialize(
637 CodechalSetting *settings)
638 {
639 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
640 MediaUserSettingSharedPtr userSettingPtr = nullptr;
641 uint32_t value = 0;
642
643 CODECHAL_HW_FUNCTION_ENTER;
644
645 if (UsesRenderEngine(settings->codecFunction, settings->standard) ||
646 CodecHalIsEnableFieldScaling(settings->codecFunction, settings->standard, settings->downsamplingHinted))
647 {
648 CODECHAL_HW_CHK_NULL_RETURN(m_renderInterface);
649
650 m_stateHeapSettings.m_ishBehavior = HeapManager::Behavior::clientControlled;
651 m_stateHeapSettings.m_dshBehavior = HeapManager::Behavior::destructiveExtend;
652 // As a performance optimization keep the DSH locked always,
653 // the ISH is only accessed at device creation and thus does not need to be locked
654 m_stateHeapSettings.m_keepDshLocked = true;
655 m_stateHeapSettings.dwDshIncrement = 2 * MOS_PAGE_SIZE;
656
657 if (m_stateHeapSettings.dwIshSize > 0 &&
658 m_stateHeapSettings.dwDshSize > 0 &&
659 m_stateHeapSettings.dwNumSyncTags > 0)
660 {
661 CODECHAL_HW_CHK_STATUS_RETURN(m_renderInterface->AllocateHeaps(
662 m_stateHeapSettings));
663 }
664 }
665
666 #if (_DEBUG || _RELEASE_INTERNAL)
667 userSettingPtr = m_osInterface->pfnGetUserSettingInstance(m_osInterface);
668 ReadUserSettingForDebug(
669 userSettingPtr,
670 value,
671 __MEDIA_USER_FEATURE_VALUE_SSEU_SETTING_OVERRIDE,
672 MediaUserSetting::Group::Device);
673
674 if (value != 0xDEADC0DE)
675 {
676 m_numRequestedEuSlicesOverride = value & 0xFF; // Bits 0-7
677 m_numRequestedSubSlicesOverride = (value >> 8) & 0xFF; // Bits 8-15
678 m_numRequestedEusOverride = (value >> 16) & 0xFFFF; // Bits 16-31
679 m_numRequestedOverride = true;
680 }
681 #endif
682
683 m_enableCodecMmc = !MEDIA_IS_WA(GetWaTable(), WaDisableCodecMmc);
684
685 return eStatus;
686 }
687
688 uint32_t CodechalHwInterface::GetMediaObjectBufferSize(
689 uint32_t numMbs,
690 uint32_t inlineDataSize)
691 {
692 uint32_t maxSize = 0;
693
694 maxSize +=
695 (m_sizeOfCmdMediaObject + inlineDataSize) * numMbs +
696 m_sizeOfCmdMediaStateFlush +
697 m_sizeOfCmdBatchBufferEnd +
698 128; // extra padding needed for scaling
699
700 return maxSize;
701 }
702
703 MOS_STATUS CodechalHwInterface::AddVdencBrcImgBuffer(
704 PMOS_RESOURCE vdencBrcImgBuffer,
705 PMHW_VDBOX_AVC_IMG_PARAMS params)
706 {
707 CODECHAL_HW_FUNCTION_ENTER;
708
709 MHW_MI_CHK_NULL(m_osInterface);
710 MHW_MI_CHK_NULL(m_mfxInterface);
711 MHW_MI_CHK_NULL(m_vdencInterface);
712
713 uint8_t *data = nullptr;
714 MOS_LOCK_PARAMS lockFlags;
715
716 uint32_t mfxAvcImgStateSize = m_mfxInterface->GetAvcImgStateSize();
717 uint32_t vdencAvcCostStateSize = m_vdencInterface->GetVdencAvcCostStateSize();
718 uint32_t vdencCmd3Size = m_vdencInterface->GetVdencCmd3Size();
719 uint32_t vdencAvcImgStateSize = m_vdencInterface->GetVdencAvcImgStateSize();
720
721 MOS_ZeroMemory(&lockFlags, sizeof(MOS_LOCK_PARAMS));
722 lockFlags.WriteOnly = 1;
723
724 data = (uint8_t*)m_osInterface->pfnLockResource(m_osInterface, vdencBrcImgBuffer, &lockFlags);
725 MHW_MI_CHK_NULL(data);
726
727 MOS_COMMAND_BUFFER constructedCmdBuf;
728
729 MOS_ZeroMemory(&constructedCmdBuf, sizeof(MOS_COMMAND_BUFFER));
730 constructedCmdBuf.pCmdBase = (uint32_t *)data;
731 constructedCmdBuf.iRemaining = mfxAvcImgStateSize + vdencAvcCostStateSize + vdencCmd3Size + vdencAvcImgStateSize;
732
733 // Set MFX_IMAGE_STATE command
734 constructedCmdBuf.pCmdPtr = (uint32_t *)data;
735 constructedCmdBuf.iOffset = 0;
736 MHW_MI_CHK_STATUS(m_mfxInterface->AddMfxAvcImgCmd(&constructedCmdBuf, nullptr, params));
737
738 // Set VDENC_COST_STATE command
739 constructedCmdBuf.pCmdPtr = (uint32_t *)(data + mfxAvcImgStateSize);
740 constructedCmdBuf.iOffset = mfxAvcImgStateSize;
741 MHW_MI_CHK_STATUS(m_vdencInterface->AddVdencAvcCostStateCmd(&constructedCmdBuf, nullptr, params));
742
743 // Set VDENC_CMD3 command
744 constructedCmdBuf.pCmdPtr = (uint32_t *)(data + mfxAvcImgStateSize + vdencAvcCostStateSize);
745 constructedCmdBuf.iOffset = mfxAvcImgStateSize + vdencAvcCostStateSize;
746 MHW_MI_CHK_STATUS(m_vdencInterface->AddVdencCmd3Cmd(&constructedCmdBuf, nullptr, params));
747
748 // Set VDENC_IMAGE_STATE command
749 constructedCmdBuf.pCmdPtr = (uint32_t *)(data + mfxAvcImgStateSize + vdencAvcCostStateSize + vdencCmd3Size);
750 constructedCmdBuf.iOffset = mfxAvcImgStateSize + vdencAvcCostStateSize + vdencCmd3Size;
751 MHW_MI_CHK_STATUS(m_vdencInterface->AddVdencImgStateCmd(&constructedCmdBuf, nullptr, params));
752
753 // Add batch buffer end insertion flag
754 m_miInterface->AddBatchBufferEndInsertionFlag(constructedCmdBuf);
755
756 if (data)
757 {
758 m_osInterface->pfnUnlockResource(
759 m_osInterface,
760 vdencBrcImgBuffer);
761 }
762
763 return MOS_STATUS_SUCCESS;
764 }
765
766 MOS_STATUS CodechalHwInterface::AddVdencSfdImgBuffer(
767 PMOS_RESOURCE vdencSfdImgBuffer,
768 PMHW_VDBOX_AVC_IMG_PARAMS params)
769 {
770 CODECHAL_HW_FUNCTION_ENTER;
771
772 MHW_MI_CHK_NULL(m_osInterface);
773 MHW_MI_CHK_NULL(m_vdencInterface);
774
775 uint8_t *data = nullptr;
776 MOS_LOCK_PARAMS lockFlags;
777
778 uint32_t vdencAvcImgStateSize = m_vdencInterface->GetVdencAvcImgStateSize();
779
780 MOS_ZeroMemory(&lockFlags, sizeof(MOS_LOCK_PARAMS));
781 lockFlags.WriteOnly = 1;
782
783 data = (uint8_t*)m_osInterface->pfnLockResource(m_osInterface, vdencSfdImgBuffer, &lockFlags);
784 MHW_MI_CHK_NULL(data);
785
786 MOS_COMMAND_BUFFER constructedCmdBuf;
787
788 MOS_ZeroMemory(&constructedCmdBuf, sizeof(MOS_COMMAND_BUFFER));
789 constructedCmdBuf.pCmdBase = (uint32_t *)data;
790 constructedCmdBuf.pCmdPtr = (uint32_t *)data;
791 constructedCmdBuf.iOffset = 0;
792 constructedCmdBuf.iRemaining = vdencAvcImgStateSize + m_sizeOfCmdBatchBufferEnd;
793
794 MHW_MI_CHK_STATUS(m_vdencInterface->AddVdencImgStateCmd(&constructedCmdBuf, nullptr, params));
795
796 // Add batch buffer end insertion flag
797 constructedCmdBuf.pCmdPtr = (uint32_t *)(data + vdencAvcImgStateSize);
798 constructedCmdBuf.iOffset = vdencAvcImgStateSize;
799 constructedCmdBuf.iRemaining = m_sizeOfCmdBatchBufferEnd;
800 m_miInterface->AddBatchBufferEndInsertionFlag(constructedCmdBuf);
801
802 if (data)
803 {
804 m_osInterface->pfnUnlockResource(
805 m_osInterface,
806 vdencSfdImgBuffer);
807 }
808
809 return MOS_STATUS_SUCCESS;
810 }
811
812 uint32_t CodechalHwInterface::GetKernelLoadCommandSize(
813 uint32_t maxNumSurfaces)
814 {
815 CODECHAL_HW_FUNCTION_ENTER;
816
817 MOS_UNUSED(maxNumSurfaces);
818
819 return m_maxKernelLoadCmdSize;
820 }
821
822 MOS_STATUS CodechalHwInterface::ResizeCommandBufferAndPatchList(
823 uint32_t requestedCommandBufferSize,
824 uint32_t requestedPatchListSize)
825 {
826 CODECHAL_HW_FUNCTION_ENTER;
827
828 if (m_osInterface->bUsesCmdBufHeaderInResize)
829 {
830 return ResizeCommandBufferAndPatchListCmd(requestedCommandBufferSize, requestedPatchListSize);
831 }
832 else
833 {
834 return ResizeCommandBufferAndPatchListOs(requestedCommandBufferSize, requestedPatchListSize);
835 }
836 }
837
838 MOS_STATUS CodechalHwInterface::ResizeCommandBufferAndPatchListCmd(
839 uint32_t requestedCommandBufferSize,
840 uint32_t requestedPatchListSize)
841 {
842 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
843
844 CODECHAL_HW_FUNCTION_ENTER;
845
846 CODECHAL_HW_CHK_NULL_RETURN(m_miInterface);
847
848 MOS_COMMAND_BUFFER cmdBuffer;
849
850 CODECHAL_HW_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));
851 CODECHAL_HW_CHK_STATUS_RETURN(m_miInterface->AddMiNoop(&cmdBuffer, nullptr));
852 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
853 CODECHAL_HW_CHK_STATUS_RETURN(m_osInterface->pfnResizeCommandBufferAndPatchList(m_osInterface, requestedCommandBufferSize, requestedPatchListSize, 0));
854
855 return eStatus;
856 }
857
858 MOS_STATUS CodechalHwInterface::ResizeCommandBufferAndPatchListOs(
859 uint32_t requestedCommandBufferSize,
860 uint32_t requestedPatchListSize)
861 {
862 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
863
864 CODECHAL_HW_CHK_STATUS_RETURN(m_osInterface->pfnResizeCommandBufferAndPatchList(m_osInterface, requestedCommandBufferSize, requestedPatchListSize, 0));
865
866 return eStatus;
867 }
868
869 MOS_STATUS CodechalHwInterface::WriteSyncTagToResource(
870 PMOS_COMMAND_BUFFER cmdBuffer,
871 PMOS_SYNC_PARAMS syncParams)
872 {
873 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
874
875 CODECHAL_HW_FUNCTION_ENTER;
876
877 CODECHAL_HW_CHK_NULL_RETURN(m_miInterface);
878 MOS_UNUSED(syncParams);
879
880 MHW_MI_STORE_DATA_PARAMS params;
881 PMOS_RESOURCE globalGpuContextSyncTagBuffer = nullptr;
882 uint32_t offset = 0;
883 uint32_t value = 0;
884
885 CODECHAL_HW_CHK_STATUS_RETURN(m_osInterface->pfnGetGpuStatusBufferResource(
886 m_osInterface,
887 globalGpuContextSyncTagBuffer));
888 CODECHAL_HW_CHK_NULL_RETURN(globalGpuContextSyncTagBuffer);
889
890 offset = m_osInterface->pfnGetGpuStatusTagOffset(m_osInterface, m_osInterface->CurrentGpuContextOrdinal);
891 value = m_osInterface->pfnGetGpuStatusTag(m_osInterface, m_osInterface->CurrentGpuContextOrdinal);
892
893 params.pOsResource = globalGpuContextSyncTagBuffer;
894 params.dwResourceOffset = offset;
895 params.dwValue = value;
896
897 CODECHAL_HW_CHK_STATUS_RETURN(m_miInterface->AddMiStoreDataImmCmd(cmdBuffer, &params));
898
899 // Increment GPU Context Tag for next use
900 m_osInterface->pfnIncrementGpuStatusTag(m_osInterface, m_osInterface->CurrentGpuContextOrdinal);
901
902 return eStatus;
903 }
904
905 uint32_t CodechalHwInterface::ComposeSurfaceCacheabilityControl(
906 uint32_t cacheabiltySettingIdx,
907 uint32_t cacheabilityTypeRequested)
908 {
909 CODECHAL_HW_FUNCTION_ENTER;
910
911 MHW_MEMORY_OBJECT_CONTROL_PARAMS cacheSetting = m_cacheabilitySettings[cacheabiltySettingIdx];
912
913 if (m_noSeparateL3LlcCacheabilitySettings)
914 {
915 if (cacheabilityTypeRequested == codechalUncacheableWa)
916 {
917 if (cacheSetting.Gen8.TargetCache == CODECHAL_MO_TARGET_CACHE_ELLC)
918 {
919 //Check if the SKU doesn't have EDRAM
920 if (!MEDIA_IS_SKU(m_skuTable, FtrEDram))
921 {
922 // No eDRAM, set the caching to uncache
923 cacheSetting.Gen8.CacheControl = 1;
924 }
925 }
926 }
927 // No separate LLC and L3 cacheability settings in the memory control object, so just return the value
928 return (uint32_t)cacheSetting.Value;
929 }
930
931 return (uint32_t)m_cacheabilitySettings[cacheabiltySettingIdx].Value;
932 }
933
934 MOS_STATUS CodechalHwInterface::AddHucDummyStreamOut(
935 PMOS_COMMAND_BUFFER cmdBuffer)
936 {
937 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
938
939 if (!MEDIA_IS_WA(m_waTable, WaHucStreamoutEnable))
940 {
941 return eStatus;
942 }
943
944 CODECHAL_HW_FUNCTION_ENTER;
945
946 CODECHAL_HW_CHK_NULL_RETURN(cmdBuffer);
947 CODECHAL_HW_CHK_NULL_RETURN(m_miInterface);
948
949 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
950 MHW_VDBOX_PIPE_MODE_SELECT_PARAMS pipeModeSelectParams;
951 MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS indObjParams;
952 MHW_VDBOX_HUC_STREAM_OBJ_PARAMS streamObjParams;
953
954 if (Mos_ResourceIsNull(&m_dummyStreamOut))
955 {
956 MOS_LOCK_PARAMS lockFlags;
957 uint8_t* data;
958 MOS_ALLOC_GFXRES_PARAMS allocParamsForBufferLinear;
959
960 MOS_ZeroMemory(&allocParamsForBufferLinear, sizeof(MOS_ALLOC_GFXRES_PARAMS));
961 allocParamsForBufferLinear.Type = MOS_GFXRES_BUFFER;
962 allocParamsForBufferLinear.TileType = MOS_TILE_LINEAR;
963 allocParamsForBufferLinear.Format = Format_Buffer;
964
965 m_dmemBufSize = MHW_CACHELINE_SIZE;
966
967 allocParamsForBufferLinear.dwBytes = m_dmemBufSize;
968 allocParamsForBufferLinear.pBufName = "HucDmemBufferDummy";
969 CODECHAL_HW_CHK_STATUS_RETURN((MOS_STATUS)m_osInterface->pfnAllocateResource(
970 m_osInterface,
971 &allocParamsForBufferLinear,
972 &m_hucDmemDummy));
973 // set lock flag to WRITE_ONLY
974 MOS_ZeroMemory(&lockFlags, sizeof(MOS_LOCK_PARAMS));
975 lockFlags.WriteOnly = 1;
976 data =
977 (uint8_t*)m_osInterface->pfnLockResource(m_osInterface, &m_hucDmemDummy, &lockFlags);
978 CODECHAL_HW_CHK_NULL_RETURN(data);
979 MOS_ZeroMemory(data, m_dmemBufSize);
980 *data = 8;
981 m_osInterface->pfnUnlockResource(m_osInterface, &m_hucDmemDummy);
982
983 allocParamsForBufferLinear.dwBytes = CODECHAL_CACHELINE_SIZE;
984
985 allocParamsForBufferLinear.pBufName = "HucDummyStreamInBuffer";
986 CODECHAL_HW_CHK_STATUS_RETURN(m_osInterface->pfnAllocateResource(
987 m_osInterface,
988 &allocParamsForBufferLinear,
989 &m_dummyStreamIn));
990 allocParamsForBufferLinear.pBufName = "HucDummyStreamOutBuffer";
991 CODECHAL_HW_CHK_STATUS_RETURN(m_osInterface->pfnAllocateResource(
992 m_osInterface,
993 &allocParamsForBufferLinear,
994 &m_dummyStreamOut));
995 }
996
997 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
998 CODECHAL_HW_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(cmdBuffer, &flushDwParams));
999
1000 // pipe mode select
1001 pipeModeSelectParams.dwMediaSoftResetCounterValue = 2400;
1002
1003 // pass bit-stream buffer by Ind Obj Addr command. Set size to 1 for dummy stream
1004 MOS_ZeroMemory(&indObjParams, sizeof(indObjParams));
1005 indObjParams.presDataBuffer = &m_dummyStreamIn;
1006 indObjParams.dwDataSize = 1;
1007 indObjParams.presStreamOutObjectBuffer = &m_dummyStreamOut;
1008 indObjParams.dwStreamOutObjectSize = 1;
1009
1010 // set stream object with stream out enabled
1011 MOS_ZeroMemory(&streamObjParams, sizeof(streamObjParams));
1012 streamObjParams.dwIndStreamInLength = 1;
1013 streamObjParams.dwIndStreamInStartAddrOffset = 0;
1014 streamObjParams.bHucProcessing = true;
1015 streamObjParams.dwIndStreamOutStartAddrOffset = 0;
1016 streamObjParams.bStreamOutEnable = 1;
1017
1018 CODECHAL_HW_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(cmdBuffer, &flushDwParams));
1019
1020 MHW_VDBOX_HUC_IMEM_STATE_PARAMS imemParams;
1021 MHW_VDBOX_HUC_DMEM_STATE_PARAMS dmemParams;
1022 MHW_VDBOX_HUC_VIRTUAL_ADDR_PARAMS virtualAddrParams;
1023
1024 MOS_ZeroMemory(&imemParams, sizeof(imemParams));
1025 imemParams.dwKernelDescriptor = VDBOX_HUC_VDENC_BRC_INIT_KERNEL_DESCRIPTOR;
1026
1027 // set HuC DMEM param
1028 MOS_ZeroMemory(&dmemParams, sizeof(dmemParams));
1029 dmemParams.presHucDataSource = &m_hucDmemDummy;
1030 dmemParams.dwDataLength = m_dmemBufSize;
1031 dmemParams.dwDmemOffset = HUC_DMEM_OFFSET_RTOS_GEMS;
1032
1033 MOS_ZeroMemory(&virtualAddrParams, sizeof(virtualAddrParams));
1034 virtualAddrParams.regionParams[0].presRegion = &m_dummyStreamOut;
1035
1036 streamObjParams.bHucProcessing = true;
1037 streamObjParams.bStreamInEnable = 1;
1038
1039 CODECHAL_HW_CHK_STATUS_RETURN(m_hucInterface->AddHucImemStateCmd(cmdBuffer, &imemParams));
1040 CODECHAL_HW_CHK_STATUS_RETURN(m_hucInterface->AddHucPipeModeSelectCmd(cmdBuffer, &pipeModeSelectParams));
1041 CODECHAL_HW_CHK_STATUS_RETURN(m_hucInterface->AddHucDmemStateCmd(cmdBuffer, &dmemParams));
1042 CODECHAL_HW_CHK_STATUS_RETURN(m_hucInterface->AddHucVirtualAddrStateCmd(cmdBuffer, &virtualAddrParams));
1043 CODECHAL_HW_CHK_STATUS_RETURN(m_hucInterface->AddHucIndObjBaseAddrStateCmd(cmdBuffer, &indObjParams));
1044 CODECHAL_HW_CHK_STATUS_RETURN(m_hucInterface->AddHucStreamObjectCmd(cmdBuffer, &streamObjParams));
1045 CODECHAL_HW_CHK_STATUS_RETURN(m_hucInterface->AddHucStartCmd(cmdBuffer, true));
1046
1047 CODECHAL_HW_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(cmdBuffer, &flushDwParams));
1048
1049 return eStatus;
1050
1051 }
1052
1053 MOS_STATUS CodechalHwInterface::PerformHucStreamOut(
1054 CodechalHucStreamoutParams *hucStreamOutParams,
1055 PMOS_COMMAND_BUFFER cmdBuffer)
1056 {
1057 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1058
1059 CODECHAL_HW_FUNCTION_ENTER;
1060 CODECHAL_HW_CHK_NULL_RETURN(cmdBuffer);
1061
1062 if (MEDIA_IS_SKU(m_skuTable, FtrEnableMediaKernels) && MEDIA_IS_WA(m_waTable, WaHucStreamoutEnable))
1063 {
1064 CODECHAL_HW_CHK_STATUS_RETURN(AddHucDummyStreamOut(cmdBuffer));
1065 }
1066
1067 // pipe mode select
1068 MHW_VDBOX_PIPE_MODE_SELECT_PARAMS pipeModeSelectParams;
1069 pipeModeSelectParams.Mode = hucStreamOutParams->mode;
1070 pipeModeSelectParams.dwMediaSoftResetCounterValue = 2400;
1071 pipeModeSelectParams.bStreamObjectUsed = true;
1072 pipeModeSelectParams.bStreamOutEnabled = true;
1073 if (hucStreamOutParams->segmentInfo == nullptr && m_osInterface->osCpInterface->IsCpEnabled())
1074 {
1075 // Disable protection control setting in huc drm
1076 pipeModeSelectParams.disableProtectionSetting = true;
1077 }
1078
1079 // Enlarge the stream in/out data size to avoid upper bound hit assert in HuC
1080 hucStreamOutParams->dataSize += hucStreamOutParams->inputRelativeOffset;
1081 hucStreamOutParams->streamOutObjectSize += hucStreamOutParams->outputRelativeOffset;
1082
1083 // pass bit-stream buffer by Ind Obj Addr command
1084 MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS indObjParams;
1085 MOS_ZeroMemory(&indObjParams, sizeof(indObjParams));
1086 indObjParams.presDataBuffer = hucStreamOutParams->dataBuffer;
1087 indObjParams.dwDataSize = MOS_ALIGN_CEIL(hucStreamOutParams->dataSize, MHW_PAGE_SIZE);
1088 indObjParams.dwDataOffset = hucStreamOutParams->dataOffset;
1089 indObjParams.presStreamOutObjectBuffer = hucStreamOutParams->streamOutObjectBuffer;
1090 indObjParams.dwStreamOutObjectSize = MOS_ALIGN_CEIL(hucStreamOutParams->streamOutObjectSize, MHW_PAGE_SIZE);
1091 indObjParams.dwStreamOutObjectOffset = hucStreamOutParams->streamOutObjectOffset;
1092
1093 // set stream object with stream out enabled
1094 MHW_VDBOX_HUC_STREAM_OBJ_PARAMS streamObjParams;
1095 MOS_ZeroMemory(&streamObjParams, sizeof(streamObjParams));
1096 streamObjParams.dwIndStreamInLength = hucStreamOutParams->indStreamInLength;
1097 streamObjParams.dwIndStreamInStartAddrOffset = hucStreamOutParams->inputRelativeOffset;
1098 streamObjParams.dwIndStreamOutStartAddrOffset = hucStreamOutParams->outputRelativeOffset;
1099 streamObjParams.bHucProcessing = true;
1100 streamObjParams.bStreamInEnable = true;
1101 streamObjParams.bStreamOutEnable = true;
1102
1103 CODECHAL_HW_CHK_STATUS_RETURN(m_hucInterface->AddHucPipeModeSelectCmd(cmdBuffer, &pipeModeSelectParams));
1104 CODECHAL_HW_CHK_STATUS_RETURN(m_hucInterface->AddHucIndObjBaseAddrStateCmd(cmdBuffer, &indObjParams));
1105 CODECHAL_HW_CHK_STATUS_RETURN(m_hucInterface->AddHucStreamObjectCmd(cmdBuffer, &streamObjParams));
1106
1107 // This flag is always false if huc fw is not loaded.
1108 if (MEDIA_IS_SKU(m_skuTable, FtrEnableMediaKernels) &&
1109 MEDIA_IS_WA(m_waTable, WaHucStreamoutOnlyDisable))
1110 {
1111 CODECHAL_HW_CHK_STATUS_RETURN(AddHucDummyStreamOut(cmdBuffer));
1112 }
1113
1114 return eStatus;
1115 }
1116
1117 MOS_STATUS CodechalHwInterface::UpdateSSEuForCmdBuffer(
1118 PMOS_COMMAND_BUFFER cmdBuffer,
1119 bool singleTaskPhaseSupported,
1120 bool lastTaskInPhase)
1121 {
1122 CODECHAL_HW_FUNCTION_ENTER;
1123
1124 CODECHAL_HW_CHK_NULL_RETURN(cmdBuffer);
1125
1126 if (singleTaskPhaseSupported && lastTaskInPhase)
1127 {
1128 PMOS_COMMAND_BUFFER_ATTRIBUTES attributes = &cmdBuffer->Attributes; // Base of the command buffer is where the command buffer header would be
1129
1130 // Update the SSEU realted values in the comand buffer header header with the final values in the HwInterface structure
1131 attributes->dwNumRequestedEUSlices = m_numRequestedEuSlices;
1132 attributes->dwNumRequestedSubSlices = m_numRequestedSubSlices;
1133 attributes->dwNumRequestedEUs = m_numRequestedEus;
1134 CODECHAL_HW_VERBOSEMESSAGE("CB Attributes Updated: S/SS/EU: %d/%d/%d.", m_numRequestedEuSlices, m_numRequestedSubSlices, m_numRequestedEus);
1135 }
1136
1137 // Clear the SSEU setting in HwInterface always for non-singletaskphase mode and after updating command buffer header for singletaskphase mode
1138 if ((!singleTaskPhaseSupported) || (singleTaskPhaseSupported && lastTaskInPhase))
1139 {
1140 m_numRequestedSubSlices = 0;
1141 m_numRequestedEus = 0;
1142 }
1143
1144 return MOS_STATUS_SUCCESS;
1145 }
1146
1147 MOS_STATUS CodechalHwInterface::GetDefaultSSEuSetting(
1148 CODECHAL_MEDIA_STATE_TYPE mediaStateType,
1149 bool setRequestedSlices,
1150 bool setRequestedSubSlices,
1151 bool setRequestedEus)
1152 {
1153 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1154
1155 CODECHAL_HW_FUNCTION_ENTER;
1156
1157 MOS_UNUSED(setRequestedSlices);
1158
1159 if (m_ssEuTable == nullptr) // SSEUTable may be nullptr if not initialized(for newer platforms) or not supported(on HSW). Its not an error, just return success.
1160 {
1161 return eStatus;
1162 }
1163
1164 if (mediaStateType >= m_numMediaStates)
1165 {
1166 return MOS_STATUS_INVALID_PARAMETER;
1167 }
1168
1169 #if (_DEBUG || _RELEASE_INTERNAL)
1170 if (m_numRequestedOverride)
1171 {
1172 m_numRequestedEuSlices = m_numRequestedEuSlicesOverride;
1173 m_numRequestedSubSlices = m_numRequestedSubSlicesOverride;
1174 m_numRequestedEus = m_numRequestedEusOverride;
1175 return eStatus;
1176 }
1177 #endif
1178
1179 CODECHAL_SSEU_SETTING const *ssEutable = m_ssEuTable + mediaStateType;
1180
1181 if (m_numRequestedEuSlices != CODECHAL_SLICE_SHUTDOWN_DEFAULT) // Num Slices will be set based on table only if it is not set to default (HALO)
1182 {
1183 if (m_numRequestedEuSlices < ssEutable->ui8NumSlices)
1184 {
1185 m_numRequestedEuSlices = ssEutable->ui8NumSlices;
1186 }
1187 }
1188 if (!setRequestedSubSlices) // If num Sub-Slices is already programmed, then don't change it
1189 {
1190 if (m_numRequestedSubSlices < ssEutable->ui8NumSubSlices)
1191 {
1192 m_numRequestedSubSlices = ssEutable->ui8NumSubSlices;
1193 }
1194 }
1195 if (!setRequestedEus) // If num EUs is already programmed, then don't change it
1196 {
1197 if (m_numRequestedEus < ssEutable->ui8NumEUs)
1198 {
1199 m_numRequestedEus = ssEutable->ui8NumEUs;
1200 }
1201 }
1202
1203 return eStatus;
1204 }
1205
1206 MOS_STATUS CodechalHwInterface::CopyDataSourceWithDrv(
1207 CodechalDataCopyParams *dataCopyParams)
1208 {
1209 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1210
1211 CODECHAL_HW_FUNCTION_ENTER;
1212 CODECHAL_HW_CHK_NULL_RETURN(dataCopyParams);
1213 CODECHAL_HW_CHK_NULL_RETURN(dataCopyParams->srcResource);
1214 CODECHAL_HW_CHK_NULL_RETURN(dataCopyParams->dstResource)
1215
1216 uint8_t* src = nullptr;
1217 uint8_t* dst = nullptr;
1218 MOS_LOCK_PARAMS lockFlags;
1219
1220 // initiate lock flags
1221 MOS_ZeroMemory(&lockFlags, sizeof(MOS_LOCK_PARAMS));
1222 lockFlags.ReadOnly = 1;
1223
1224 src = (uint8_t*)m_osInterface->pfnLockResource(m_osInterface, dataCopyParams->srcResource, &lockFlags);
1225 if (nullptr != src)
1226 {
1227 src += dataCopyParams->srcOffset;
1228
1229 MOS_ZeroMemory(&lockFlags, sizeof(MOS_LOCK_PARAMS));
1230 lockFlags.WriteOnly = 1;
1231
1232 dst = (uint8_t*)m_osInterface->pfnLockResource(m_osInterface, dataCopyParams->dstResource, &lockFlags);
1233 if (nullptr != dst)
1234 {
1235 dst += dataCopyParams->dstOffset;
1236 eStatus = MOS_SecureMemcpy(dst, dataCopyParams->dstSize, src, dataCopyParams->srcSize);
1237 if (eStatus != MOS_STATUS_SUCCESS)
1238 {
1239 CODECHAL_HW_ASSERTMESSAGE("Failed to copy memory.");
1240 return eStatus;
1241 }
1242
1243 m_osInterface->pfnUnlockResource(m_osInterface, dataCopyParams->dstResource);
1244 }
1245
1246 m_osInterface->pfnUnlockResource(m_osInterface, dataCopyParams->srcResource);
1247 }
1248
1249 return eStatus;
1250 }
1251
1252 #if (_DEBUG || _RELEASE_INTERNAL)
1253 MOS_STATUS CodechalHwInterface::InitL3ControlUserFeatureSettings(
1254 MHW_RENDER_ENGINE_L3_CACHE_CONFIG *l3CacheConfig,
1255 MHW_RENDER_ENGINE_L3_CACHE_SETTINGS *l3Overrides)
1256 {
1257 CODECHAL_HW_FUNCTION_ENTER;
1258
1259 CODECHAL_HW_CHK_NULL_RETURN(l3CacheConfig);
1260 CODECHAL_HW_CHK_NULL_RETURN(l3Overrides);
1261
1262 MOS_USER_FEATURE_VALUE_DATA userFeatureData;
1263 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
1264 userFeatureData.u32Data = l3CacheConfig->dwL3CacheCntlReg_Setting;
1265 userFeatureData.i32DataFlag = MOS_USER_FEATURE_VALUE_DATA_FLAG_CUSTOM_DEFAULT_VALUE_TYPE;
1266 MOS_UserFeature_ReadValue_ID(
1267 nullptr,
1268 __MEDIA_USER_FEATURE_VALUE_ENCODE_L3_CACHE_CNTLREG_OVERRIDE_ID,
1269 &userFeatureData,
1270 m_osInterface->pOsContext);
1271 l3Overrides->dwCntlReg = (uint32_t)userFeatureData.i32Data;
1272
1273 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
1274 userFeatureData.u32Data = l3CacheConfig->dwL3CacheCntlReg2_Setting;
1275 userFeatureData.i32DataFlag = MOS_USER_FEATURE_VALUE_DATA_FLAG_CUSTOM_DEFAULT_VALUE_TYPE;
1276 MOS_UserFeature_ReadValue_ID(
1277 nullptr,
1278 __MEDIA_USER_FEATURE_VALUE_ENCODE_L3_CACHE_CNTLREG2_OVERRIDE_ID,
1279 &userFeatureData,
1280 m_osInterface->pOsContext);
1281 l3Overrides->dwCntlReg2 = (uint32_t)userFeatureData.i32Data;
1282
1283 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
1284 userFeatureData.u32Data = l3CacheConfig->dwL3CacheCntlReg3_Setting;
1285 userFeatureData.i32DataFlag = MOS_USER_FEATURE_VALUE_DATA_FLAG_CUSTOM_DEFAULT_VALUE_TYPE;
1286 MOS_UserFeature_ReadValue_ID(
1287 nullptr,
1288 __MEDIA_USER_FEATURE_VALUE_ENCODE_L3_CACHE_CNTLREG3_OVERRIDE_ID,
1289 &userFeatureData,
1290 m_osInterface->pOsContext);
1291 l3Overrides->dwCntlReg3 = (uint32_t)userFeatureData.i32Data;
1292
1293 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
1294 userFeatureData.u32Data = l3CacheConfig->dwL3CacheSqcReg1_Setting;
1295 userFeatureData.i32DataFlag = MOS_USER_FEATURE_VALUE_DATA_FLAG_CUSTOM_DEFAULT_VALUE_TYPE;
1296 MOS_UserFeature_ReadValue_ID(
1297 nullptr,
1298 __MEDIA_USER_FEATURE_VALUE_ENCODE_L3_CACHE_SQCREG1_OVERRIDE_ID,
1299 &userFeatureData,
1300 m_osInterface->pOsContext);
1301 l3Overrides->dwSqcReg1 = (uint32_t)userFeatureData.i32Data;
1302
1303 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
1304 userFeatureData.u32Data = l3CacheConfig->dwL3CacheSqcReg4_Setting;
1305 userFeatureData.i32DataFlag = MOS_USER_FEATURE_VALUE_DATA_FLAG_CUSTOM_DEFAULT_VALUE_TYPE;
1306 MOS_UserFeature_ReadValue_ID(
1307 nullptr,
1308 __MEDIA_USER_FEATURE_VALUE_ENCODE_L3_CACHE_SQCREG4_OVERRIDE_ID,
1309 &userFeatureData,
1310 m_osInterface->pOsContext);
1311 l3Overrides->dwSqcReg4 = (uint32_t)userFeatureData.i32Data;
1312
1313 if (l3CacheConfig->bL3LRA1Reset)
1314 {
1315 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
1316 userFeatureData.u32Data = l3CacheConfig->dwL3LRA1Reg_Setting;
1317 userFeatureData.i32DataFlag = MOS_USER_FEATURE_VALUE_DATA_FLAG_CUSTOM_DEFAULT_VALUE_TYPE;
1318 MOS_UserFeature_ReadValue_ID(
1319 nullptr,
1320 __MEDIA_USER_FEATURE_VALUE_ENCODE_L3_LRA_1_REG1_OVERRIDE_ID,
1321 &userFeatureData,
1322 m_osInterface->pOsContext);
1323 l3Overrides->dwLra1Reg = (uint32_t)userFeatureData.i32Data;
1324 }
1325
1326 return MOS_STATUS_SUCCESS;
1327 }
1328 #endif // _DEBUG || _RELEASE_INTERNAL
1329
1330 MOS_STATUS CodechalHwInterface::SendHwSemaphoreWaitCmd(
1331 PMOS_RESOURCE semaMem,
1332 uint32_t semaData,
1333 MHW_COMMON_MI_SEMAPHORE_COMPARE_OPERATION opCode,
1334 PMOS_COMMAND_BUFFER cmdBuffer,
1335 uint32_t semaMemOffset)
1336 {
1337 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1338
1339 CODECHAL_HW_FUNCTION_ENTER;
1340
1341 MHW_MI_SEMAPHORE_WAIT_PARAMS miSemaphoreWaitParams;
1342 MOS_ZeroMemory((&miSemaphoreWaitParams), sizeof(miSemaphoreWaitParams));
1343 miSemaphoreWaitParams.presSemaphoreMem = semaMem;
1344 miSemaphoreWaitParams.bPollingWaitMode = true;
1345 miSemaphoreWaitParams.dwSemaphoreData = semaData;
1346 miSemaphoreWaitParams.CompareOperation = opCode;
1347 miSemaphoreWaitParams.dwResourceOffset = semaMemOffset;
1348 eStatus = m_miInterface->AddMiSemaphoreWaitCmd(cmdBuffer, &miSemaphoreWaitParams);
1349
1350 return eStatus;
1351 }
1352
1353 MOS_STATUS CodechalHwInterface::SendMiAtomicDwordCmd(
1354 PMOS_RESOURCE resource,
1355 uint32_t immData,
1356 MHW_COMMON_MI_ATOMIC_OPCODE opCode,
1357 PMOS_COMMAND_BUFFER cmdBuffer)
1358 {
1359 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1360
1361 CODECHAL_HW_FUNCTION_ENTER;
1362
1363 CODECHAL_HW_CHK_NULL_RETURN(m_miInterface);
1364
1365 MHW_MI_ATOMIC_PARAMS atomicParams;
1366 MOS_ZeroMemory((&atomicParams), sizeof(atomicParams));
1367 atomicParams.pOsResource = resource;
1368 atomicParams.dwDataSize = sizeof(uint32_t);
1369 atomicParams.Operation = opCode;
1370 atomicParams.bInlineData = true;
1371 atomicParams.dwOperand1Data[0] = immData;
1372 eStatus = m_miInterface->AddMiAtomicCmd(cmdBuffer, &atomicParams);
1373
1374 return eStatus;
1375 }
1376
1377 MOS_STATUS CodechalHwInterface::SendCondBbEndCmd(
1378 PMOS_RESOURCE resource,
1379 uint32_t offset,
1380 uint32_t compData,
1381 bool disableCompMask,
1382 PMOS_COMMAND_BUFFER cmdBuffer)
1383 {
1384 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1385
1386 CODECHAL_HW_FUNCTION_ENTER;
1387
1388 if (!Mos_ResourceIsNull(&m_conditionalBbEndDummy))
1389 {
1390 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
1391 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
1392 flushDwParams.postSyncOperation = 1;
1393 flushDwParams.pOsResource = &m_conditionalBbEndDummy;
1394 flushDwParams.dwDataDW1 = 0;
1395 CODECHAL_HW_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(cmdBuffer, &flushDwParams));
1396 }
1397
1398 MHW_MI_CONDITIONAL_BATCH_BUFFER_END_PARAMS conditionalBatchBufferEndParams;
1399 MOS_ZeroMemory(&conditionalBatchBufferEndParams, sizeof(conditionalBatchBufferEndParams));
1400 conditionalBatchBufferEndParams.presSemaphoreBuffer = resource;
1401 conditionalBatchBufferEndParams.dwOffset = offset;
1402 conditionalBatchBufferEndParams.dwValue = compData;
1403 conditionalBatchBufferEndParams.bDisableCompareMask = disableCompMask;
1404 eStatus = m_miInterface->AddMiConditionalBatchBufferEndCmd(cmdBuffer, &conditionalBatchBufferEndParams);
1405
1406 return eStatus;
1407 }
1408
1409 MOS_STATUS CodechalHwInterface::MhwInitISH(
1410 PMHW_STATE_HEAP_INTERFACE stateHeapInterface,
1411 PMHW_KERNEL_STATE kernelState)
1412 {
1413 CODECHAL_HW_FUNCTION_ENTER;
1414
1415 CODECHAL_HW_CHK_NULL_RETURN(stateHeapInterface);
1416 CODECHAL_HW_CHK_NULL_RETURN(kernelState);
1417
1418 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1419 CODECHAL_HW_CHK_STATUS_RETURN(stateHeapInterface->pfnAssignSpaceInStateHeap(
1420 stateHeapInterface,
1421 MHW_ISH_TYPE,
1422 kernelState,
1423 kernelState->KernelParams.iSize,
1424 true,
1425 false));
1426
1427 CODECHAL_HW_CHK_STATUS_RETURN(kernelState->m_ishRegion.AddData(
1428 kernelState->KernelParams.pBinary,
1429 0,
1430 kernelState->KernelParams.iSize));
1431
1432 return MOS_STATUS_SUCCESS;
1433 }
1434
1435 MOS_STATUS CodechalHwInterface::AssignDshAndSshSpace(
1436 PMHW_STATE_HEAP_INTERFACE stateHeapInterface,
1437 PMHW_KERNEL_STATE kernelState,
1438 bool noDshSpaceRequested,
1439 uint32_t forcedDshSize,
1440 bool noSshSpaceRequested,
1441 uint32_t currCmdBufId)
1442 {
1443 CODECHAL_HW_FUNCTION_ENTER;
1444
1445 CODECHAL_HW_CHK_NULL_RETURN(stateHeapInterface);
1446 CODECHAL_HW_CHK_NULL_RETURN(kernelState);
1447
1448 kernelState->m_currTrackerId = currCmdBufId;
1449
1450 if (!noDshSpaceRequested)
1451 {
1452 uint32_t dshSize = 0;
1453 if (forcedDshSize != 0)
1454 {
1455 dshSize = forcedDshSize;
1456 }
1457 else
1458 {
1459 dshSize = stateHeapInterface->pStateHeapInterface->GetSizeofCmdInterfaceDescriptorData()+
1460 MOS_ALIGN_CEIL(kernelState->KernelParams.iCurbeLength,
1461 stateHeapInterface->pStateHeapInterface->GetCurbeAlignment());
1462 }
1463
1464 CODECHAL_HW_CHK_STATUS_RETURN(stateHeapInterface->pfnAssignSpaceInStateHeap(
1465 stateHeapInterface,
1466 MHW_DSH_TYPE,
1467 kernelState,
1468 dshSize,
1469 false,
1470 true));
1471 }
1472
1473 if (!noSshSpaceRequested)
1474 {
1475 CODECHAL_HW_CHK_STATUS_RETURN(stateHeapInterface->pfnAssignSpaceInStateHeap(
1476 stateHeapInterface,
1477 MHW_SSH_TYPE,
1478 kernelState,
1479 kernelState->dwSshSize,
1480 false,
1481 false));
1482 }
1483
1484 return MOS_STATUS_SUCCESS;
1485 }
1486
1487 MmioRegistersMfx * CodechalHwInterface::SelectVdboxAndGetMmioRegister(
1488 MHW_VDBOX_NODE_IND index,
1489 PMOS_COMMAND_BUFFER pCmdBuffer)
1490 {
1491 if (m_getVdboxNodeByUMD)
1492 {
1493 pCmdBuffer->iVdboxNodeIndex = m_osInterface->pfnGetVdboxNodeId(m_osInterface, pCmdBuffer);
1494 switch (pCmdBuffer->iVdboxNodeIndex)
1495 {
1496 case MOS_VDBOX_NODE_1:
1497 index = MHW_VDBOX_NODE_1;
1498 break;
1499 case MOS_VDBOX_NODE_2:
1500 index = MHW_VDBOX_NODE_2;
1501 break;
1502 case MOS_VDBOX_NODE_INVALID:
1503 // That's a legal case meaning that we were not assigned with per-bb index because
1504 // balancing algorithm can't work (forcedly diabled or miss kernel support).
1505 // If that's the case we just proceed with the further static context assignment.
1506 break;
1507 default:
1508 // That's the case when MHW and MOS enumerations mismatch. We again proceed with the
1509 // best effort (static context assignment, but provide debug note).
1510 MHW_ASSERTMESSAGE("MOS and MHW VDBOX enumerations mismatch! Adjust HW description!");
1511 break;
1512 }
1513 }
1514
1515 return m_mfxInterface->GetMmioRegisters(index);
1516 }
1517
1518 MOS_STATUS CodechalHwInterface::SendMiStoreDataImm(
1519 PMOS_RESOURCE resource,
1520 uint32_t immData,
1521 PMOS_COMMAND_BUFFER cmdBuffer)
1522 {
1523 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1524
1525 CODECHAL_HW_FUNCTION_ENTER;
1526
1527 CODECHAL_HW_CHK_NULL_RETURN(resource);
1528 CODECHAL_HW_CHK_NULL_RETURN(cmdBuffer);
1529
1530 MHW_MI_STORE_DATA_PARAMS storeDataParams;
1531 MOS_ZeroMemory(&storeDataParams, sizeof(storeDataParams));
1532 storeDataParams.pOsResource = resource;
1533 storeDataParams.dwResourceOffset = 0;
1534 storeDataParams.dwValue = immData;
1535
1536 CODECHAL_HW_CHK_STATUS_RETURN(m_miInterface->AddMiStoreDataImmCmd(
1537 cmdBuffer,
1538 &storeDataParams));
1539
1540 return eStatus;
1541 }
1542
1543 MOS_STATUS CodechalHwInterface::ReadMfcStatus(
1544 MHW_VDBOX_NODE_IND vdboxIndex,
1545 const EncodeStatusReadParams &params,
1546 PMOS_COMMAND_BUFFER cmdBuffer)
1547 {
1548 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1549
1550 CODECHAL_HW_FUNCTION_ENTER;
1551
1552 CODECHAL_HW_CHK_NULL_RETURN(cmdBuffer);
1553
1554 CODECHAL_HW_CHK_COND_RETURN((vdboxIndex > GetMaxVdboxIndex()),"ERROR - vdbox index exceed the maximum");
1555 MmioRegistersMfx* mmioRegisters = SelectVdboxAndGetMmioRegister(vdboxIndex, cmdBuffer);
1556
1557 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
1558 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
1559 CODECHAL_HW_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(cmdBuffer, &flushDwParams));
1560
1561 MHW_MI_STORE_REGISTER_MEM_PARAMS miStoreRegMemParams;
1562 MOS_ZeroMemory(&miStoreRegMemParams, sizeof(miStoreRegMemParams));
1563
1564 miStoreRegMemParams.presStoreBuffer = params.resBitstreamByteCountPerFrame;
1565 miStoreRegMemParams.dwOffset = params.bitstreamByteCountPerFrameOffset;
1566 miStoreRegMemParams.dwRegister = mmioRegisters->mfcBitstreamBytecountFrameRegOffset;
1567 CODECHAL_HW_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &miStoreRegMemParams));
1568
1569 miStoreRegMemParams.presStoreBuffer = params.resBitstreamSyntaxElementOnlyBitCount;
1570 miStoreRegMemParams.dwOffset = params.bitstreamSyntaxElementOnlyBitCountOffset;
1571 miStoreRegMemParams.dwRegister = mmioRegisters->mfcBitstreamSeBitcountFrameRegOffset;
1572 CODECHAL_HW_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &miStoreRegMemParams));
1573
1574 miStoreRegMemParams.presStoreBuffer = params.resQpStatusCount;
1575 miStoreRegMemParams.dwOffset = params.qpStatusCountOffset;
1576 miStoreRegMemParams.dwRegister = mmioRegisters->mfcQPStatusCountOffset;
1577 CODECHAL_HW_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &miStoreRegMemParams));
1578
1579 if (mmioRegisters->mfcAvcNumSlicesRegOffset > 0)
1580 {
1581 //read MFC_AVC_NUM_SLICES register to status report
1582 miStoreRegMemParams.presStoreBuffer = params.resNumSlices;
1583 miStoreRegMemParams.dwOffset = params.numSlicesOffset;
1584 miStoreRegMemParams.dwRegister = mmioRegisters->mfcAvcNumSlicesRegOffset;
1585 CODECHAL_HW_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &miStoreRegMemParams));
1586 }
1587
1588 if (params.vdencBrcEnabled)
1589 {
1590 // Store PAK FrameSize MMIO to DMEM for HuC next BRC pass of current frame and first pass of next frame.
1591 for (int i = 0; i < 2; i++)
1592 {
1593 if (params.resVdencBrcUpdateDmemBufferPtr[i])
1594 {
1595 miStoreRegMemParams.presStoreBuffer = params.resVdencBrcUpdateDmemBufferPtr[i];
1596 miStoreRegMemParams.dwOffset = 5 * sizeof(uint32_t);
1597 miStoreRegMemParams.dwRegister = mmioRegisters->mfcBitstreamBytecountFrameRegOffset;
1598 CODECHAL_HW_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &miStoreRegMemParams));
1599
1600 if (params.vdencBrcNumOfSliceOffset)
1601 {
1602 miStoreRegMemParams.presStoreBuffer = params.resVdencBrcUpdateDmemBufferPtr[i];
1603 miStoreRegMemParams.dwOffset = params.vdencBrcNumOfSliceOffset;
1604 miStoreRegMemParams.dwRegister = mmioRegisters->mfcAvcNumSlicesRegOffset;
1605 CODECHAL_HW_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &miStoreRegMemParams));
1606 }
1607 }
1608 }
1609 }
1610
1611 CODECHAL_HW_CHK_STATUS_RETURN(ReadImageStatus(vdboxIndex, params, cmdBuffer));
1612
1613 return eStatus;
1614 }
1615
1616 MOS_STATUS CodechalHwInterface::ReadImageStatus(
1617 MHW_VDBOX_NODE_IND vdboxIndex,
1618 const EncodeStatusReadParams &params,
1619 PMOS_COMMAND_BUFFER cmdBuffer)
1620 {
1621 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1622
1623 CODECHAL_HW_FUNCTION_ENTER;
1624
1625 CODECHAL_HW_CHK_NULL_RETURN(cmdBuffer);
1626
1627 CODECHAL_HW_CHK_COND_RETURN((vdboxIndex > GetMaxVdboxIndex()),"ERROR - vdbox index exceed the maximum");
1628 MmioRegistersMfx* mmioRegisters = SelectVdboxAndGetMmioRegister(vdboxIndex, cmdBuffer);
1629
1630 MOS_RESOURCE *osResource;
1631 uint32_t offset;
1632
1633 MHW_MI_STORE_REGISTER_MEM_PARAMS miStoreRegMemParams;
1634 MOS_ZeroMemory(&miStoreRegMemParams, sizeof(miStoreRegMemParams));
1635
1636 miStoreRegMemParams.presStoreBuffer = params.resImageStatusMask;
1637 miStoreRegMemParams.dwOffset = params.imageStatusMaskOffset;
1638 miStoreRegMemParams.dwRegister = mmioRegisters->mfcImageStatusMaskRegOffset;
1639 CODECHAL_HW_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &miStoreRegMemParams));
1640
1641 miStoreRegMemParams.presStoreBuffer = params.resImageStatusCtrl;
1642 miStoreRegMemParams.dwOffset = params.imageStatusCtrlOffset;
1643 miStoreRegMemParams.dwRegister = mmioRegisters->mfcImageStatusCtrlRegOffset;
1644 CODECHAL_HW_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &miStoreRegMemParams));
1645
1646 // VDEnc dynamic slice overflow semaphore, DW0 is SW programmed mask(MFX_IMAGE_MASK does not support), DW1 is MFX_IMAGE_STATUS_CONTROL
1647 if (params.vdencBrcEnabled)
1648 {
1649 MHW_VDBOX_PIPE_MODE_SELECT_PARAMS pipeModeSelectParams;
1650
1651 // Added for VDEnc slice overflow bit in MFC_IMAGE_STATUS_CONTROL
1652 // The bit is connected on the non-AVC encoder side of MMIO register.
1653 // Need a dummy MFX_PIPE_MODE_SELECT to decoder and read this register.
1654 if (params.waReadVDEncOverflowStatus)
1655 {
1656 MOS_ZeroMemory(&pipeModeSelectParams, sizeof(pipeModeSelectParams));
1657 pipeModeSelectParams.Mode = CODECHAL_DECODE_MODE_AVCVLD;
1658 m_mfxInterface->SetDecodeInUse(true);
1659 CODECHAL_HW_CHK_STATUS_RETURN(m_mfxInterface->AddMfxPipeModeSelectCmd(cmdBuffer, &pipeModeSelectParams));
1660 }
1661
1662 // Store MFC_IMAGE_STATUS_CONTROL MMIO to DMEM for HuC next BRC pass of current frame and first pass of next frame.
1663 for (int i = 0; i < 2; i++)
1664 {
1665 if (params.resVdencBrcUpdateDmemBufferPtr[i])
1666 {
1667 miStoreRegMemParams.presStoreBuffer = params.resVdencBrcUpdateDmemBufferPtr[i];
1668 miStoreRegMemParams.dwOffset = 7 * sizeof(uint32_t); // offset of SliceSizeViolation in HUC_BRC_UPDATE_DMEM
1669 miStoreRegMemParams.dwRegister = mmioRegisters->mfcImageStatusCtrlRegOffset;
1670 CODECHAL_HW_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &miStoreRegMemParams));
1671 }
1672 }
1673
1674 // Restore MFX_PIPE_MODE_SELECT to encode mode
1675 if (params.waReadVDEncOverflowStatus)
1676 {
1677 MOS_ZeroMemory(&pipeModeSelectParams, sizeof(pipeModeSelectParams));
1678 pipeModeSelectParams.Mode = params.mode;
1679 pipeModeSelectParams.bVdencEnabled = true;
1680 m_mfxInterface->SetDecodeInUse(false);
1681 CODECHAL_HW_CHK_STATUS_RETURN(m_mfxInterface->AddMfxPipeModeSelectCmd(cmdBuffer, &pipeModeSelectParams));
1682 }
1683 }
1684
1685 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
1686 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
1687 CODECHAL_HW_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(cmdBuffer, &flushDwParams));
1688
1689 return eStatus;
1690 }
1691
1692 MOS_STATUS CodechalHwInterface::ReadBrcPakStatistics(
1693 MHW_VDBOX_NODE_IND vdboxIndex,
1694 const BrcPakStatsReadParams &params,
1695 PMOS_COMMAND_BUFFER cmdBuffer)
1696 {
1697 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1698
1699 CODECHAL_HW_FUNCTION_ENTER;
1700
1701 CODECHAL_HW_CHK_NULL_RETURN(cmdBuffer);
1702 CODECHAL_HW_CHK_NULL_RETURN(params.presBrcPakStatisticBuffer);
1703
1704 CODECHAL_HW_CHK_COND_RETURN((vdboxIndex > GetMaxVdboxIndex()),"ERROR - vdbox index exceed the maximum");
1705 MmioRegistersMfx* mmioRegisters = SelectVdboxAndGetMmioRegister(vdboxIndex, cmdBuffer);
1706
1707 MHW_MI_STORE_REGISTER_MEM_PARAMS miStoreRegMemParams;
1708 MOS_ZeroMemory(&miStoreRegMemParams, sizeof(miStoreRegMemParams));
1709
1710 miStoreRegMemParams.presStoreBuffer = params.presBrcPakStatisticBuffer;
1711 miStoreRegMemParams.dwOffset = 0;
1712 miStoreRegMemParams.dwRegister = mmioRegisters->mfcBitstreamBytecountFrameRegOffset;
1713 CODECHAL_HW_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &miStoreRegMemParams));
1714
1715 miStoreRegMemParams.presStoreBuffer = params.presBrcPakStatisticBuffer;
1716 miStoreRegMemParams.dwOffset = sizeof(uint32_t);
1717 miStoreRegMemParams.dwRegister = mmioRegisters->mfcBitstreamBytecountSliceRegOffset;
1718 CODECHAL_HW_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &miStoreRegMemParams));
1719
1720 MHW_MI_STORE_DATA_PARAMS storeDataParams;
1721 storeDataParams.pOsResource = params.presBrcPakStatisticBuffer;
1722 storeDataParams.dwResourceOffset = sizeof(uint32_t) * 2;
1723 storeDataParams.dwValue = params.ucPass + 1;
1724 CODECHAL_HW_CHK_STATUS_RETURN(m_miInterface->AddMiStoreDataImmCmd(cmdBuffer, &storeDataParams));
1725
1726 storeDataParams.pOsResource = params.presStatusBuffer;
1727 storeDataParams.dwResourceOffset = params.dwStatusBufNumPassesOffset;
1728 storeDataParams.dwValue = params.ucPass + 1;
1729 CODECHAL_HW_CHK_STATUS_RETURN(m_miInterface->AddMiStoreDataImmCmd(cmdBuffer, &storeDataParams));
1730
1731 miStoreRegMemParams.presStoreBuffer = params.presBrcPakStatisticBuffer;
1732 miStoreRegMemParams.dwOffset = sizeof(uint32_t) * (4 + params.ucPass);
1733 miStoreRegMemParams.dwRegister = mmioRegisters->mfcImageStatusCtrlRegOffset;
1734 CODECHAL_HW_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &miStoreRegMemParams));
1735
1736 return eStatus;
1737 }
1738
1739 MOS_STATUS CodechalHwInterface::ReadHcpStatus(
1740 MHW_VDBOX_NODE_IND vdboxIndex,
1741 const EncodeStatusReadParams &params,
1742 PMOS_COMMAND_BUFFER cmdBuffer)
1743 {
1744 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1745
1746 CODECHAL_HW_FUNCTION_ENTER;
1747
1748 CODECHAL_HW_CHK_NULL_RETURN(cmdBuffer);
1749
1750 CODECHAL_HW_CHK_COND_RETURN((vdboxIndex > GetMaxVdboxIndex()), "ERROR - vdbox index exceed the maximum");
1751
1752 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
1753 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
1754 CODECHAL_HW_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(cmdBuffer, &flushDwParams));
1755
1756 auto mmioRegisters = m_hcpInterface->GetMmioRegisters(vdboxIndex);
1757
1758 MHW_MI_STORE_REGISTER_MEM_PARAMS miStoreRegMemParams;
1759 MOS_ZeroMemory(&miStoreRegMemParams, sizeof(miStoreRegMemParams));
1760 miStoreRegMemParams.presStoreBuffer = params.resBitstreamByteCountPerFrame;
1761 miStoreRegMemParams.dwOffset = params.bitstreamByteCountPerFrameOffset;
1762 miStoreRegMemParams.dwRegister = mmioRegisters->hcpEncBitstreamBytecountFrameRegOffset;
1763 CODECHAL_HW_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &miStoreRegMemParams));
1764
1765 MOS_ZeroMemory(&miStoreRegMemParams, sizeof(miStoreRegMemParams));
1766 miStoreRegMemParams.presStoreBuffer = params.resBitstreamSyntaxElementOnlyBitCount;
1767 miStoreRegMemParams.dwOffset = params.bitstreamSyntaxElementOnlyBitCountOffset;
1768 miStoreRegMemParams.dwRegister = mmioRegisters->hcpEncBitstreamSeBitcountFrameRegOffset;
1769 CODECHAL_HW_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &miStoreRegMemParams));
1770
1771 MOS_ZeroMemory(&miStoreRegMemParams, sizeof(miStoreRegMemParams));
1772 miStoreRegMemParams.presStoreBuffer = params.resQpStatusCount;
1773 miStoreRegMemParams.dwOffset = params.qpStatusCountOffset;
1774 miStoreRegMemParams.dwRegister = mmioRegisters->hcpEncQpStatusCountRegOffset;
1775 CODECHAL_HW_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &miStoreRegMemParams));
1776
1777 return eStatus;
1778 }
1779
1780 MOS_STATUS CodechalHwInterface::ReadImageStatusForHcp(
1781 MHW_VDBOX_NODE_IND vdboxIndex,
1782 const EncodeStatusReadParams &params,
1783 PMOS_COMMAND_BUFFER cmdBuffer)
1784 {
1785 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1786
1787 CODECHAL_HW_FUNCTION_ENTER;
1788
1789 CODECHAL_HW_CHK_NULL_RETURN(cmdBuffer);
1790
1791 CODECHAL_HW_CHK_COND_RETURN((vdboxIndex > GetMaxVdboxIndex()),"ERROR - vdbox index exceed the maximum");
1792
1793 auto mmioRegisters = m_hcpInterface->GetMmioRegisters(vdboxIndex);
1794
1795 MHW_MI_STORE_REGISTER_MEM_PARAMS miStoreRegMemParams;
1796 MOS_ZeroMemory(&miStoreRegMemParams, sizeof(miStoreRegMemParams));
1797 miStoreRegMemParams.presStoreBuffer = params.resImageStatusMask;
1798 miStoreRegMemParams.dwOffset = params.imageStatusMaskOffset;
1799 miStoreRegMemParams.dwRegister = mmioRegisters->hcpEncImageStatusMaskRegOffset;
1800 CODECHAL_HW_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &miStoreRegMemParams));
1801
1802 MOS_ZeroMemory(&miStoreRegMemParams, sizeof(miStoreRegMemParams));
1803 miStoreRegMemParams.presStoreBuffer = params.resImageStatusCtrl;
1804 miStoreRegMemParams.dwOffset = params.imageStatusCtrlOffset;
1805 miStoreRegMemParams.dwRegister = mmioRegisters->hcpEncImageStatusCtrlRegOffset;
1806 CODECHAL_HW_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &miStoreRegMemParams));
1807
1808 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
1809 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
1810 CODECHAL_HW_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(cmdBuffer, &flushDwParams));
1811
1812 return eStatus;
1813 }
1814
1815 MOS_STATUS CodechalHwInterface::ReadBrcPakStatisticsForHcp(
1816 MHW_VDBOX_NODE_IND vdboxIndex,
1817 const BrcPakStatsReadParams &params,
1818 PMOS_COMMAND_BUFFER cmdBuffer)
1819 {
1820 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1821
1822 CODECHAL_HW_FUNCTION_ENTER;
1823
1824 CODECHAL_HW_CHK_NULL_RETURN(cmdBuffer);
1825 CODECHAL_HW_CHK_NULL_RETURN(params.presBrcPakStatisticBuffer);
1826
1827 CODECHAL_HW_CHK_COND_RETURN((vdboxIndex > GetMaxVdboxIndex()),"ERROR - vdbox index exceed the maximum");
1828
1829 auto mmioRegisters = m_hcpInterface->GetMmioRegisters(vdboxIndex);
1830
1831 MHW_MI_STORE_REGISTER_MEM_PARAMS miStoreRegMemParams;
1832 MOS_ZeroMemory(&miStoreRegMemParams, sizeof(miStoreRegMemParams));
1833 miStoreRegMemParams.presStoreBuffer = params.presBrcPakStatisticBuffer;
1834 miStoreRegMemParams.dwOffset = params.bitstreamBytecountFrameOffset;
1835 miStoreRegMemParams.dwRegister = mmioRegisters->hcpEncBitstreamBytecountFrameRegOffset;
1836 CODECHAL_HW_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &miStoreRegMemParams));
1837
1838 MOS_ZeroMemory(&miStoreRegMemParams, sizeof(miStoreRegMemParams));
1839 miStoreRegMemParams.presStoreBuffer = params.presBrcPakStatisticBuffer;
1840 miStoreRegMemParams.dwOffset = params.bitstreamBytecountFrameNoHeaderOffset;
1841 miStoreRegMemParams.dwRegister = mmioRegisters->hcpEncBitstreamBytecountFrameNoHeaderRegOffset;
1842 CODECHAL_HW_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &miStoreRegMemParams));
1843
1844 MOS_ZeroMemory(&miStoreRegMemParams, sizeof(miStoreRegMemParams));
1845 miStoreRegMemParams.presStoreBuffer = params.presBrcPakStatisticBuffer;
1846 miStoreRegMemParams.dwOffset = params.imageStatusCtrlOffset;
1847 miStoreRegMemParams.dwRegister = mmioRegisters->hcpEncImageStatusCtrlRegOffset;
1848 CODECHAL_HW_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &miStoreRegMemParams));
1849
1850 MHW_MI_STORE_DATA_PARAMS storeDataParams;
1851 storeDataParams.pOsResource = params.presStatusBuffer;
1852 storeDataParams.dwResourceOffset = params.dwStatusBufNumPassesOffset;
1853 storeDataParams.dwValue = params.ucPass;
1854 CODECHAL_HW_CHK_STATUS_RETURN(m_miInterface->AddMiStoreDataImmCmd(cmdBuffer, &storeDataParams));
1855
1856 return eStatus;
1857 }
1858
1859 MOS_STATUS CodechalHwInterface::SetStatusTagByPipeCtrl(
1860 PMOS_RESOURCE osResource,
1861 uint32_t offset,
1862 uint32_t tag,
1863 bool needFlushCache,
1864 PMOS_COMMAND_BUFFER cmdBuffer)
1865 {
1866 MOS_STATUS result = MOS_STATUS_SUCCESS;
1867
1868 MHW_PIPE_CONTROL_PARAMS pipeControlParams;
1869 MOS_ZeroMemory(&pipeControlParams, sizeof(pipeControlParams));
1870
1871 if (!needFlushCache)
1872 {
1873 pipeControlParams.presDest = osResource;
1874 pipeControlParams.dwPostSyncOp = MHW_FLUSH_WRITE_IMMEDIATE_DATA;
1875 pipeControlParams.dwResourceOffset = offset;
1876 pipeControlParams.dwDataDW1 = tag;
1877 result = m_miInterface->AddPipeControl(
1878 cmdBuffer,
1879 nullptr,
1880 &pipeControlParams);
1881
1882 return result;
1883 }
1884
1885 pipeControlParams.dwFlushMode = MHW_FLUSH_WRITE_CACHE;
1886 pipeControlParams.bGenericMediaStateClear = true;
1887 CODECHAL_HW_CHK_STATUS_RETURN(m_miInterface->AddPipeControl(cmdBuffer, nullptr, &pipeControlParams));
1888
1889 if (MEDIA_IS_WA(m_waTable, WaSendDummyVFEafterPipelineSelect))
1890 {
1891 MHW_VFE_PARAMS vfeStateParams;
1892
1893 MOS_ZeroMemory(&vfeStateParams, sizeof(vfeStateParams));
1894 vfeStateParams.dwNumberofURBEntries = 1;
1895 CODECHAL_HW_CHK_STATUS_RETURN(m_renderInterface->AddMediaVfeCmd(cmdBuffer, &vfeStateParams));
1896 }
1897
1898 MHW_MI_STORE_DATA_PARAMS storeDataParams;
1899 MOS_ZeroMemory(&storeDataParams, sizeof(MHW_MI_STORE_DATA_PARAMS));
1900 storeDataParams.pOsResource = osResource;
1901 storeDataParams.dwResourceOffset = offset;
1902 storeDataParams.dwValue = tag;
1903 result = m_miInterface->AddMiStoreDataImmCmd(
1904 cmdBuffer,
1905 &storeDataParams);
1906
1907 return result;
1908 }
1909
1910 MOS_STATUS CodechalHwInterface::SetStatusTagByMiCommand(
1911 PMOS_RESOURCE osResource,
1912 uint32_t offset,
1913 uint32_t tag,
1914 PMOS_COMMAND_BUFFER cmdBuffer)
1915 {
1916 MOS_STATUS result = MOS_STATUS_SUCCESS;
1917
1918 MHW_MI_STORE_DATA_PARAMS storeDataParams;
1919 MOS_ZeroMemory(&storeDataParams, sizeof(MHW_MI_STORE_DATA_PARAMS));
1920 storeDataParams.pOsResource = osResource;
1921 storeDataParams.dwResourceOffset = offset;
1922 storeDataParams.dwValue = tag;
1923
1924 result = m_miInterface->AddMiStoreDataImmCmd(
1925 cmdBuffer,
1926 &storeDataParams);
1927
1928 return result;
1929 }
1930
1931 bool CodechalHwInterface::UsesRenderEngine(CODECHAL_FUNCTION codecFunction, uint32_t standard)
1932 {
1933 if(codecFunction == CODECHAL_FUNCTION_ENC ||
1934 (codecFunction == CODECHAL_FUNCTION_ENC_PAK) ||
1935 codecFunction == CODECHAL_FUNCTION_HYBRIDPAK ||
1936 ((codecFunction == CODECHAL_FUNCTION_DECODE) && (standard == CODECHAL_VC1)) ||
1937 codecFunction == CODECHAL_FUNCTION_ENC_VDENC_PAK ||
1938 codecFunction == CODECHAL_FUNCTION_FEI_PRE_ENC ||
1939 codecFunction == CODECHAL_FUNCTION_FEI_ENC ||
1940 codecFunction == CODECHAL_FUNCTION_FEI_ENC_PAK)
1941 {
1942 return true;
1943 }
1944
1945 return false;
1946 }
1947
1948 MOS_STATUS CodechalHwInterface::GetFilmGrainKernelInfo(
1949 uint8_t*& kernelBase,
1950 uint32_t& kernelSize)
1951 {
1952 kernelBase = nullptr;
1953 kernelSize = 0;
1954
1955 return MOS_STATUS_SUCCESS;
1956 }