Debian Codegraph @

media_softlet/agnostic/common/codec/hal/enc/shared/packet/encode_huc.cpp

raw
1 /*
2 * Copyright (c) 2018-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 //!
24 //! \file encode_huc.cpp
25 //! \brief Defines the common interface for encode huc implementation
26 //! \details The encode huc interface is further sub-divided by different huc usage,
27 //! this file is for the base interface which is shared by all.
28 //!
29
30 #include "encode_huc.h"
31 #include "codechal_debug.h"
32 #include <algorithm>
33
34 namespace encode
35 {
36 MOS_STATUS EncodeHucPkt::Init()
37 {
38 HUC_CHK_STATUS_RETURN(CmdPacket::Init());
39 m_allocator = m_pipeline->GetEncodeAllocator();
40 HUC_CHK_STATUS_RETURN(AllocateResources());
41
42 ENCODE_CHK_NULL_RETURN(m_pipeline);
43 m_statusReport = m_pipeline->GetStatusReportInstance();
44 ENCODE_CHK_NULL_RETURN(m_statusReport);
45 ENCODE_CHK_STATUS_RETURN(m_statusReport->RegistObserver(this));
46
47 HUC_CHK_NULL_RETURN(m_hwInterface);
48 m_skuFtrEnableMediaKernels = MEDIA_IS_SKU(m_hwInterface->GetSkuTable(), FtrEnableMediaKernels);
49 m_hucItf = m_hwInterface->GetHucInterfaceNext();
50 HUC_CHK_NULL_RETURN(m_hucItf);
51 m_hucStatus2ImemLoadedMask = m_hucItf->GetHucStatus2ImemLoadedMask();
52
53 return MOS_STATUS_SUCCESS;
54 }
55
56 bool EncodeHucPkt::IsHuCStsUpdNeeded()
57 {
58 bool enabled = false;
59 #if _SW_BRC
60 enabled = m_swBrc && m_swBrc->SwBrcEnabled();
61 #endif // !_SW_BRC
62 return enabled;
63 }
64
65 MOS_STATUS EncodeHucPkt::AllocateResources()
66 {
67 MOS_ALLOC_GFXRES_PARAMS allocParamsForBufferLinear;
68 MOS_ZeroMemory(&allocParamsForBufferLinear, sizeof(MOS_ALLOC_GFXRES_PARAMS));
69 allocParamsForBufferLinear.Type = MOS_GFXRES_BUFFER;
70 allocParamsForBufferLinear.TileType = MOS_TILE_LINEAR;
71 allocParamsForBufferLinear.Format = Format_Buffer;
72
73 // HUC STATUS 2 Buffer for HuC status check in COND_BB_END
74 allocParamsForBufferLinear.dwBytes = sizeof(uint64_t);
75 allocParamsForBufferLinear.pBufName = "HUC STATUS 2 Buffer";
76 allocParamsForBufferLinear.ResUsageType = MOS_HW_RESOURCE_USAGE_ENCODE_INTERNAL_READ_WRITE_NOCACHE;
77 PMOS_RESOURCE allocatedbuffer = m_allocator->AllocateResource(allocParamsForBufferLinear, true);
78 ENCODE_CHK_NULL_RETURN(allocatedbuffer);
79 m_resHucStatus2Buffer = allocatedbuffer;
80
81 return MOS_STATUS_SUCCESS;
82 }
83
84 MOS_STATUS EncodeHucPkt::StoreHuCStatus2Register(PMOS_COMMAND_BUFFER cmdBuffer, bool storeHucStatus2Needed)
85 {
86 HUC_CHK_NULL_RETURN(cmdBuffer);
87 HUC_CHK_NULL_RETURN(m_statusReport);
88
89 auto mmioRegisters = m_hucItf->GetMmioRegisters(m_vdboxIndex);
90 HUC_CHK_NULL_RETURN(mmioRegisters);
91
92 PMOS_RESOURCE osResource = nullptr;
93 uint32_t offset = 0;
94
95 ENCODE_CHK_STATUS_RETURN(m_statusReport->GetAddress(statusReportHucStatus2Reg, osResource, offset));
96
97 auto &storeRegParams = m_miItf->MHW_GETPAR_F(MI_STORE_REGISTER_MEM)();
98 storeRegParams = {};
99 storeRegParams.presStoreBuffer = osResource;
100 storeRegParams.dwOffset = offset;
101 storeRegParams.dwRegister = mmioRegisters->hucStatus2RegOffset;
102 HUC_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_STORE_REGISTER_MEM)(cmdBuffer));
103
104 if (storeHucStatus2Needed)
105 {
106 // Write HUC_STATUS2 mask - bit 6 - valid IMEM loaded
107 auto &storeDataParams = m_miItf->MHW_GETPAR_F(MI_STORE_DATA_IMM)();
108 storeDataParams = {};
109 storeDataParams.pOsResource = m_resHucStatus2Buffer;
110 storeDataParams.dwResourceOffset = 0;
111 storeDataParams.dwValue = m_hucItf->GetHucStatus2ImemLoadedMask();
112 HUC_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_STORE_DATA_IMM)(cmdBuffer));
113
114 // Store HUC_STATUS2 register
115 auto &storeRegParams = m_miItf->MHW_GETPAR_F(MI_STORE_REGISTER_MEM)();
116 storeRegParams = {};
117 storeRegParams.presStoreBuffer = m_resHucStatus2Buffer;
118 storeRegParams.dwOffset = sizeof(uint32_t);
119 storeRegParams.dwRegister = mmioRegisters->hucStatus2RegOffset;
120 HUC_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_STORE_REGISTER_MEM)(cmdBuffer));
121 }
122
123 return MOS_STATUS_SUCCESS;
124 }
125
126 MOS_STATUS EncodeHucPkt::SendPrologCmds(
127 MOS_COMMAND_BUFFER &cmdBuffer)
128 {
129 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
130
131 ENCODE_FUNC_CALL();
132 bool mmcEnabled = false;
133
134 EncodeMemComp *mmcState = m_pipeline->GetMmcState();
135 ENCODE_CHK_NULL_RETURN(mmcState);
136 mmcEnabled = mmcState->IsMmcEnabled();
137 ENCODE_CHK_STATUS_RETURN(mmcState->SendPrologCmd(&cmdBuffer, false));
138
139 MHW_GENERIC_PROLOG_PARAMS genericPrologParams;
140 MOS_ZeroMemory(&genericPrologParams, sizeof(genericPrologParams));
141 ENCODE_CHK_NULL_RETURN(m_hwInterface);
142 genericPrologParams.pOsInterface = m_hwInterface->GetOsInterface();
143 std::shared_ptr<void> m_miItf = m_hwInterface->GetMiInterfaceNext();
144 genericPrologParams.pvMiInterface = nullptr;
145 genericPrologParams.bMmcEnabled = mmcEnabled;
146 ENCODE_CHK_STATUS_RETURN(Mhw_SendGenericPrologCmdNext(&cmdBuffer, &genericPrologParams, m_miItf));
147
148 return eStatus;
149 }
150
151 MOS_STATUS EncodeHucPkt::AddForceWakeup(MOS_COMMAND_BUFFER &cmdBuffer)
152 {
153 ENCODE_FUNC_CALL();
154 // NativeFence sync BB may cause preemption and ring idle, so force wakeup after it
155 ENCODE_CHK_STATUS_RETURN(AddNativeFenceSyncBBStartCmd(cmdBuffer));
156
157 auto &forceWakeupParams = m_miItf->MHW_GETPAR_F(MI_FORCE_WAKEUP)();
158 forceWakeupParams = {};
159 forceWakeupParams.bMFXPowerWellControl = true;
160 forceWakeupParams.bMFXPowerWellControlMask = true;
161 forceWakeupParams.bHEVCPowerWellControl = true;
162 forceWakeupParams.bHEVCPowerWellControlMask = true;
163
164 ENCODE_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_FORCE_WAKEUP)(&cmdBuffer));
165
166 return MOS_STATUS_SUCCESS;
167 }
168
169 void EncodeHucPkt::SetPerfTag(uint16_t type, uint16_t mode, uint16_t picCodingType)
170 {
171 ENCODE_FUNC_CALL();
172
173 PerfTagSetting perfTag;
174 perfTag.Value = 0;
175 perfTag.Mode = mode & CODECHAL_ENCODE_MODE_BIT_MASK;
176 perfTag.CallType = type;
177 perfTag.PictureCodingType = picCodingType > 3 ? 0 : picCodingType;
178 m_osInterface->pfnSetPerfTag(m_osInterface, perfTag.Value);
179 m_osInterface->pfnIncPerfBufferID(m_osInterface);
180 }
181
182 MOS_STATUS EncodeHucPkt::StartPerfCollect(MOS_COMMAND_BUFFER& cmdBuffer)
183 {
184 MediaPerfProfiler *perfProfiler = MediaPerfProfiler::Instance();
185 ENCODE_CHK_NULL_RETURN(perfProfiler);
186 ENCODE_CHK_STATUS_RETURN(perfProfiler->AddPerfCollectStartCmd(
187 (void *)m_pipeline, m_osInterface, m_miItf, &cmdBuffer));
188
189 return MOS_STATUS_SUCCESS;
190 }
191
192 MOS_STATUS EncodeHucPkt::EndPerfCollect(MOS_COMMAND_BUFFER& cmdBuffer)
193 {
194 MediaPerfProfiler *perfProfiler = MediaPerfProfiler::Instance();
195 ENCODE_CHK_NULL_RETURN(perfProfiler);
196 ENCODE_CHK_STATUS_RETURN(perfProfiler->AddPerfCollectEndCmd(
197 (void *)m_pipeline, m_osInterface, m_miItf, &cmdBuffer));
198
199 return MOS_STATUS_SUCCESS;
200 }
201
202 MOS_STATUS EncodeHucPkt::AddAllCmds_HUC_PIPE_MODE_SELECT(PMOS_COMMAND_BUFFER cmdBuffer) const
203 {
204 MHW_MI_CHK_NULL(cmdBuffer);
205
206 //for gen 11, we need to add MFX wait for both KIN and VRT before and after HUC Pipemode select...
207 auto &mfxWaitParams = m_miItf->MHW_GETPAR_F(MFX_WAIT)();
208 mfxWaitParams = {};
209 mfxWaitParams.iStallVdboxPipeline = true;
210 MHW_MI_CHK_STATUS(m_miItf->MHW_ADDCMD_F(MFX_WAIT)(cmdBuffer));
211
212 SETPAR_AND_ADDCMD(HUC_PIPE_MODE_SELECT, m_hucItf, cmdBuffer);
213
214 //for gen 11, we need to add MFX wait for both KIN and VRT before and after HUC Pipemode select...
215 mfxWaitParams = {};
216 mfxWaitParams.iStallVdboxPipeline = true;
217 MHW_MI_CHK_STATUS(m_miItf->MHW_ADDCMD_F(MFX_WAIT)(cmdBuffer));
218
219 return MOS_STATUS_SUCCESS;
220 }
221
222 MOS_STATUS EncodeHucPkt::AddAllCmds_HUC_IMEM_STATE(PMOS_COMMAND_BUFFER cmdBuffer) const
223 {
224 MHW_MI_CHK_NULL(cmdBuffer);
225
226 SETPAR_AND_ADDCMD(HUC_IMEM_STATE, m_hucItf, cmdBuffer);
227
228 auto &mfxWaitParams = m_miItf->MHW_GETPAR_F(MFX_WAIT)();
229 mfxWaitParams = {};
230 mfxWaitParams.iStallVdboxPipeline = true;
231 MHW_MI_CHK_STATUS(m_miItf->MHW_ADDCMD_F(MFX_WAIT)(cmdBuffer));
232
233 return MOS_STATUS_SUCCESS;
234 }
235
236 MOS_STATUS EncodeHucPkt::Execute(PMOS_COMMAND_BUFFER cmdBuffer, bool storeHucStatus2Needed, bool prologNeeded, HuCFunction function)
237 {
238 HUC_CHK_NULL_RETURN(cmdBuffer);
239
240 #if _SW_BRC
241 HUC_CHK_STATUS_RETURN(InitSwBrc(function));
242 if (function != NONE_BRC && m_swBrc && m_swBrc->SwBrcEnabled())
243 {
244 SETPAR(HUC_DMEM_STATE, m_hucItf);
245 SETPAR(HUC_VIRTUAL_ADDR_STATE, m_hucItf);
246
247 auto &virtualAddrParams = m_hucItf->MHW_GETPAR_F(HUC_VIRTUAL_ADDR_STATE)();
248 auto &dmemParams = m_hucItf->MHW_GETPAR_F(HUC_DMEM_STATE)();
249
250 CODECHAL_DEBUG_TOOL(
251 ENCODE_CHK_STATUS_RETURN(DumpInput());)
252
253 EncodeBasicFeature *basicFeature = dynamic_cast<EncodeBasicFeature *>(m_featureManager->GetFeature(FeatureIDs::basicFeature));
254 HUC_CHK_NULL_RETURN(basicFeature);
255 return m_swBrc->SwBrcImpl(
256 function,
257 virtualAddrParams,
258 dmemParams,
259 basicFeature->m_recycleBuf->GetBuffer(VdencBrcPakMmioBuffer, 0));
260 }
261 #endif // !_SW_BRC
262
263 if (prologNeeded)
264 {
265 ENCODE_CHK_STATUS_RETURN(AddForceWakeup(*cmdBuffer));
266 ENCODE_CHK_STATUS_RETURN(SendPrologCmds(*cmdBuffer));
267 }
268
269 ENCODE_CHK_STATUS_RETURN(StartPerfCollect(*cmdBuffer));
270
271 ENCODE_CHK_STATUS_RETURN(AddAllCmds_HUC_IMEM_STATE(cmdBuffer));
272 ENCODE_CHK_STATUS_RETURN(AddAllCmds_HUC_PIPE_MODE_SELECT(cmdBuffer));
273
274 SETPAR_AND_ADDCMD(HUC_DMEM_STATE, m_hucItf, cmdBuffer);
275 SETPAR_AND_ADDCMD(HUC_VIRTUAL_ADDR_STATE, m_hucItf, cmdBuffer);
276
277 m_enableHucStatusReport = true;
278 HUC_CHK_STATUS_RETURN(StoreHuCStatus2Register(cmdBuffer, storeHucStatus2Needed));
279
280 SETPAR_AND_ADDCMD(HUC_START, m_hucItf, cmdBuffer);
281
282 CODECHAL_DEBUG_TOOL(
283 ENCODE_CHK_STATUS_RETURN(DumpInput());)
284
285 SETPAR_AND_ADDCMD(VD_PIPELINE_FLUSH, m_vdencItf, cmdBuffer);
286
287 // Flush the engine to ensure memory written out
288 auto &flushDwParams = m_miItf->MHW_GETPAR_F(MI_FLUSH_DW)();
289 flushDwParams = {};
290 flushDwParams.bVideoPipelineCacheInvalidate = true;
291 HUC_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_FLUSH_DW)(cmdBuffer));
292
293 ENCODE_CHK_STATUS_RETURN(EndPerfCollect(*cmdBuffer));
294 HUC_CHK_STATUS_RETURN(StoreHuCStatusRegister(cmdBuffer));
295
296 return MOS_STATUS_SUCCESS;
297 }
298
299 MHW_SETPAR_DECL_SRC(VD_PIPELINE_FLUSH, EncodeHucPkt)
300 {
301 params.waitDoneHEVC = true;
302 params.flushHEVC = true;
303 return MOS_STATUS_SUCCESS;
304 }
305
306 MOS_STATUS EncodeHucPkt::Completed(void *mfxStatus, void *rcsStatus, void *statusReport)
307 {
308 ENCODE_FUNC_CALL();
309
310 if (!m_enableHucStatusReport)
311 {
312 return MOS_STATUS_SUCCESS;
313 }
314
315 ENCODE_CHK_NULL_RETURN(mfxStatus);
316 ENCODE_CHK_NULL_RETURN(statusReport);
317
318 EncodeStatusMfx *encodeStatusMfx = (EncodeStatusMfx *)mfxStatus;
319
320 MOS_USER_FEATURE_VALUE_WRITE_DATA userFeatureWriteData;
321 MOS_ZeroMemory(&userFeatureWriteData, sizeof(MOS_USER_FEATURE_VALUE_WRITE_DATA));
322
323 if (!m_skuFtrEnableMediaKernels)
324 {
325 ENCODE_ASSERTMESSAGE("Failed to load HuC firmware!");
326
327 // Reporting
328 ReportUserSetting(
329 m_userSettingPtr,
330 "HuC Firmware Load Failed",
331 1,
332 MediaUserSetting::Group::Sequence);
333
334 return MOS_STATUS_HUC_KERNEL_FAILED;
335 }
336 else if (!(encodeStatusMfx->hucStatus2Reg & m_hucStatus2ImemLoadedMask))
337 {
338 ENCODE_ASSERTMESSAGE("HuC status2 indicates Valid Imem Load failed!");
339
340 // Reporting
341 ReportUserSetting(
342 m_userSettingPtr,
343 "HuC Valid Imem Load Failed",
344 1,
345 MediaUserSetting::Group::Sequence);
346
347 #if (_DEBUG || _RELEASE_INTERNAL)
348 ReportUserSettingForDebug(
349 m_userSettingPtr,
350 "Huc Status2 Value",
351 encodeStatusMfx->hucStatus2Reg,
352 MediaUserSetting::Group::Sequence);
353 #endif
354
355 return MOS_STATUS_HUC_KERNEL_FAILED;
356 }
357 #if (_DEBUG || _RELEASE_INTERNAL)
358 else
359 {
360 EncodeStatusReportData* encodeStatusReport = (EncodeStatusReportData *)statusReport;
361 std::string hucStatusReport = "HuC Status Value is " + std::to_string(encodeStatusMfx->hucStatusReg) +
362 " for Frame number #" + std::to_string(encodeStatusReport->statusReportNumber) + ".";
363 ENCODE_NORMALMESSAGE(hucStatusReport.c_str());
364 }
365 #endif
366
367 return MOS_STATUS_SUCCESS;
368 }
369
370 MOS_STATUS EncodeHucPkt::StoreHuCStatusRegister(PMOS_COMMAND_BUFFER cmdBuffer)
371 {
372 HUC_CHK_NULL_RETURN(cmdBuffer);
373 HUC_CHK_NULL_RETURN(m_statusReport);
374
375 auto mmioRegisters = m_hucItf->GetMmioRegisters(m_vdboxIndex);
376 HUC_CHK_NULL_RETURN(mmioRegisters);
377
378 PMOS_RESOURCE osResource = nullptr;
379 uint32_t offset = 0;
380
381 ENCODE_CHK_STATUS_RETURN(m_statusReport->GetAddress(statusReportHucStatusReg, osResource, offset));
382
383 // Store HUC_STATUS register
384 auto &storeRegParams = m_miItf->MHW_GETPAR_F(MI_STORE_REGISTER_MEM)();
385 storeRegParams = {};
386 storeRegParams.presStoreBuffer = osResource;
387 storeRegParams.dwOffset = offset;
388 storeRegParams.dwRegister = mmioRegisters->hucStatusRegOffset;
389 HUC_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_STORE_REGISTER_MEM)(cmdBuffer));
390
391 return MOS_STATUS_SUCCESS;
392 }
393
394 #if _SW_BRC
395 MOS_STATUS EncodeHucPkt::InitSwBrc(HuCFunction function)
396 {
397 if (m_swBrc == nullptr)
398 {
399 EncodeBasicFeature* basicFeature = dynamic_cast<EncodeBasicFeature*>(m_featureManager->GetFeature(FeatureIDs::basicFeature));
400 HUC_CHK_NULL_RETURN(basicFeature);
401 m_swBrc = EncodeSwBrc::CreateFactory(basicFeature->m_mode, m_allocator, m_hwInterface->GetOsInterface(), function);
402 }
403 return MOS_STATUS_SUCCESS;
404 }
405 #endif // !_SW_BRC
406
407 #if USE_CODECHAL_DEBUG_TOOL
408 MOS_STATUS EncodeHucPkt::DumpRegion(
409 uint32_t regionNum,
410 const char *regionName,
411 bool inputBuffer,
412 CodechalHucRegionDumpType dumpType,
413 uint32_t size)
414 {
415 auto virtualAddrParams = m_hucItf->MHW_GETPAR_F(HUC_VIRTUAL_ADDR_STATE)();
416 auto bufferToDump = virtualAddrParams.regionParams[regionNum].presRegion;
417 auto offset = virtualAddrParams.regionParams[regionNum].dwOffset;
418
419 CodechalDebugInterface *debugInterface = m_pipeline->GetDebugInterface();
420 ENCODE_CHK_NULL_RETURN(debugInterface);
421
422 if (bufferToDump)
423 {
424 // Dump the full region when size = 0 or exceed the region size, else dump the size indicated
425 GMM_SIZE_PARAM GmmSizeParam = GMM_MAIN_SURF;
426 uint32_t bufferSize = (uint32_t)bufferToDump->pGmmResInfo->GetSize(GmmSizeParam);
427 ENCODE_CHK_STATUS_RETURN(debugInterface->DumpHucRegion(
428 bufferToDump,
429 offset,
430 size ? size : bufferSize,
431 regionNum,
432 regionName,
433 inputBuffer,
434 m_pipeline->GetCurrentPass(),
435 dumpType));
436 }
437
438 return MOS_STATUS_SUCCESS;
439 }
440 #endif
441 }