1 /*
2 * Copyright (c) 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 renderhal_platform_interface_legacy.cpp
24 //! \brief abstract the platfrom specific APIs into one class
25 //!
26 //!
27 //! \file renderhal_platform_interface_legacy.cpp
28 //! \brief Render Engine Interfaces shared across platforms
29 //! \details Platform Independent Hardware Interfaces
30 //!
31
32 #include "renderhal_platform_interface_legacy.h"
33 #include "hal_oca_interface.h"
34
35 //! \brief Add Pipeline SelectCmd
36 //! \details Add Pipeline SelectCmd
37 //! \param PRENDERHAL_INTERFACE pRenderHal
38 //! [in] Pointer to RenderHal Interface Structure
39 //! \param PMOS_COMMAND_BUFFER pCmdBuffer
40 //! [in] Pointer to Command Buffer
41 //! \return MOS_STATUS
AddPipelineSelectCmd(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer,bool gpGpuPipe)42 MOS_STATUS XRenderHal_Platform_Interface_Legacy::AddPipelineSelectCmd(
43 PRENDERHAL_INTERFACE pRenderHal,
44 PMOS_COMMAND_BUFFER pCmdBuffer,
45 bool gpGpuPipe)
46 {
47 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
48 PRENDERHAL_INTERFACE_LEGACY pRenderHalLegacy = (PRENDERHAL_INTERFACE_LEGACY)pRenderHal;
49
50 MHW_RENDERHAL_CHK_NULL(pRenderHalLegacy);
51 MHW_RENDERHAL_CHK_NULL(pRenderHalLegacy->pMhwRenderInterface);
52
53 MHW_RENDERHAL_CHK_STATUS(pRenderHalLegacy->pMhwRenderInterface->AddPipelineSelectCmd(pCmdBuffer, gpGpuPipe));
54
55 finish:
56 return eStatus;
57 }
58
59 //! \brief Send StateBase Address
60 //! \details Send StateBase Address
61 //! \param PRENDERHAL_INTERFACE pRenderHal
62 //! [in] Pointer to RenderHal Interface Structure
63 //! \param PMOS_COMMAND_BUFFER pCmdBuffer
64 //! [in] Pointer to Command Buffer
65 //! \return MOS_STATUS
SendStateBaseAddress(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer)66 MOS_STATUS XRenderHal_Platform_Interface_Legacy::SendStateBaseAddress(
67 PRENDERHAL_INTERFACE pRenderHal,
68 PMOS_COMMAND_BUFFER pCmdBuffer)
69 {
70 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
71 PRENDERHAL_INTERFACE_LEGACY pRenderHalLegacy = (PRENDERHAL_INTERFACE_LEGACY)pRenderHal;
72
73 MHW_RENDERHAL_CHK_NULL(pRenderHalLegacy);
74
75 eStatus = pRenderHalLegacy->pMhwRenderInterface->AddStateBaseAddrCmd(pCmdBuffer,
76 &pRenderHalLegacy->StateBaseAddressParams);
77
78 finish:
79 return eStatus;
80 }
81
82 //! \brief Add Sip State Cmd
83 //! \details Add Sip State Cmd
84 //! \param PRENDERHAL_INTERFACE pRenderHal
85 //! [in] Pointer to RenderHal Interface Structure
86 //! \param PMOS_COMMAND_BUFFER pCmdBuffer
87 //! [in] Pointer to Command Buffer
88 //! \return MOS_STATUS
AddSipStateCmd(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer)89 MOS_STATUS XRenderHal_Platform_Interface_Legacy::AddSipStateCmd(
90 PRENDERHAL_INTERFACE pRenderHal,
91 PMOS_COMMAND_BUFFER pCmdBuffer)
92 {
93 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
94 PRENDERHAL_INTERFACE_LEGACY pRenderHalLegacy = (PRENDERHAL_INTERFACE_LEGACY)pRenderHal;
95
96 MHW_RENDERHAL_CHK_NULL(pRenderHalLegacy);
97 MHW_RENDERHAL_CHK_NULL(pRenderHalLegacy->pMhwRenderInterface);
98
99 MHW_RENDERHAL_CHK_STATUS(pRenderHalLegacy->pMhwRenderInterface->AddSipStateCmd(pCmdBuffer, &pRenderHalLegacy->SipStateParams));
100
101 finish:
102 return eStatus;
103 }
104
105 //! \brief Add Cfe State Cmd
106 //! \details Add Cfe State Cmd
107 //! \param PRENDERHAL_INTERFACE pRenderHal
108 //! [in] Pointer to RenderHal Interface Structure
109 //! \param PMOS_COMMAND_BUFFER pCmdBuffer
110 //! [in] Pointer to Command Buffer
111 //! \return MOS_STATUS
AddCfeStateCmd(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer,PMHW_VFE_PARAMS params)112 MOS_STATUS XRenderHal_Platform_Interface_Legacy::AddCfeStateCmd(
113 PRENDERHAL_INTERFACE pRenderHal,
114 PMOS_COMMAND_BUFFER pCmdBuffer,
115 PMHW_VFE_PARAMS params)
116 {
117 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
118 PRENDERHAL_INTERFACE_LEGACY pRenderHalLegacy = (PRENDERHAL_INTERFACE_LEGACY)pRenderHal;
119 MHW_RENDERHAL_CHK_NULL(pRenderHalLegacy);
120 MHW_RENDERHAL_CHK_NULL(pRenderHalLegacy->pMhwRenderInterface);
121
122 MHW_RENDERHAL_CHK_STATUS(pRenderHalLegacy->pMhwRenderInterface->AddCfeStateCmd(pCmdBuffer, params));
123
124 finish:
125 return eStatus;
126 };
127
128 //! \brief Send ChromaKey
129 //! \details Send ChromaKey
130 //! \param PRENDERHAL_INTERFACE pRenderHal
131 //! [in] Pointer to RenderHal Interface Structure
132 //! \param PMOS_COMMAND_BUFFER pCmdBuffer
133 //! [in] Pointer to Command Buffer
134 //! \return MOS_STATUS
SendChromaKey(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer,PMHW_CHROMAKEY_PARAMS pChromaKeyParams)135 MOS_STATUS XRenderHal_Platform_Interface_Legacy::SendChromaKey(
136 PRENDERHAL_INTERFACE pRenderHal,
137 PMOS_COMMAND_BUFFER pCmdBuffer,
138 PMHW_CHROMAKEY_PARAMS pChromaKeyParams)
139 {
140 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
141 PRENDERHAL_INTERFACE_LEGACY pRenderHalLegacy = (PRENDERHAL_INTERFACE_LEGACY)pRenderHal;
142 MHW_RENDERHAL_CHK_NULL(pRenderHalLegacy);
143
144 MHW_RENDERHAL_CHK_STATUS(pRenderHalLegacy->pMhwRenderInterface->AddChromaKeyCmd(pCmdBuffer, pChromaKeyParams));
145 finish:
146 return eStatus;
147 }
148
149 //! \brief Send Palette
150 //! \details Send Palette
151 //! \param PRENDERHAL_INTERFACE pRenderHal
152 //! [in] Pointer to RenderHal Interface Structure
153 //! \param PMOS_COMMAND_BUFFER pCmdBuffer
154 //! [in] Pointer to Command Buffer
155 //! \return MOS_STATUS
SendPalette(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer,PMHW_PALETTE_PARAMS pPaletteLoadParams)156 MOS_STATUS XRenderHal_Platform_Interface_Legacy::SendPalette(
157 PRENDERHAL_INTERFACE pRenderHal,
158 PMOS_COMMAND_BUFFER pCmdBuffer,
159 PMHW_PALETTE_PARAMS pPaletteLoadParams)
160 {
161 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
162 PRENDERHAL_INTERFACE_LEGACY pRenderHalLegacy = (PRENDERHAL_INTERFACE_LEGACY)pRenderHal;
163 MHW_RENDERHAL_CHK_NULL(pRenderHalLegacy);
164 MHW_RENDERHAL_CHK_NULL(pRenderHalLegacy->pMhwRenderInterface);
165
166 MHW_RENDERHAL_CHK_STATUS(pRenderHalLegacy->pMhwRenderInterface->AddPaletteLoadCmd(pCmdBuffer, pPaletteLoadParams));
167
168 finish:
169 return eStatus;
170 };
171
172 //! \brief Set L3Cache
173 //! \details Set L3Cache
174 //! \param PRENDERHAL_INTERFACE pRenderHal
175 //! [in] Pointer to RenderHal Interface Structure
176 //! \param PMOS_COMMAND_BUFFER pCmdBuffer
177 //! [in] Pointer to Command Buffer
178 //! \return MOS_STATUS
SetL3Cache(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer)179 MOS_STATUS XRenderHal_Platform_Interface_Legacy::SetL3Cache(
180 PRENDERHAL_INTERFACE pRenderHal,
181 PMOS_COMMAND_BUFFER pCmdBuffer)
182 {
183 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
184 PRENDERHAL_INTERFACE_LEGACY pRenderHalLegacy = (PRENDERHAL_INTERFACE_LEGACY)pRenderHal;
185 MHW_RENDERHAL_CHK_NULL(pRenderHalLegacy);
186 MHW_RENDERHAL_CHK_NULL(pRenderHalLegacy->pMhwRenderInterface);
187
188 MHW_RENDERHAL_CHK_STATUS(pRenderHalLegacy->pMhwRenderInterface->SetL3Cache(pCmdBuffer));
189
190 finish:
191 return eStatus;
192 }
193
194 //!
195 //! \brief Get the size of render hal media state
196 //! \return size_t
197 //! The size of render hal media state
198 //!
GetRenderHalMediaStateSize()199 size_t XRenderHal_Platform_Interface_Legacy::GetRenderHalMediaStateSize()
200 {
201 return sizeof(RENDERHAL_MEDIA_STATE_LEGACY);
202 }
203
204 //!
205 //! \brief Get the size of render hal state heap
206 //! \return size_t
207 //! The size of render hal state heap
208 //!
GetRenderHalStateHeapSize()209 size_t XRenderHal_Platform_Interface_Legacy::GetRenderHalStateHeapSize()
210 {
211 return sizeof(RENDERHAL_STATE_HEAP_LEGACY);
212 }
213
GetMmioRegisters(PRENDERHAL_INTERFACE pRenderHal)214 PMHW_MI_MMIOREGISTERS XRenderHal_Platform_Interface_Legacy::GetMmioRegisters(
215 PRENDERHAL_INTERFACE pRenderHal)
216 {
217 PMHW_MI_MMIOREGISTERS pMmioRegisters = nullptr;
218 PRENDERHAL_INTERFACE_LEGACY pRenderHalLegacy = (PRENDERHAL_INTERFACE_LEGACY)pRenderHal;
219 if (pRenderHalLegacy && pRenderHalLegacy->pMhwRenderInterface)
220 {
221 pMmioRegisters = pRenderHalLegacy->pMhwRenderInterface->GetMmioRegisters();
222 }
223
224 return pMmioRegisters;
225 };
226
EnablePreemption(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer)227 MOS_STATUS XRenderHal_Platform_Interface_Legacy::EnablePreemption(
228 PRENDERHAL_INTERFACE pRenderHal,
229 PMOS_COMMAND_BUFFER pCmdBuffer)
230 {
231 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
232 PRENDERHAL_INTERFACE_LEGACY pRenderHalLegacy = (PRENDERHAL_INTERFACE_LEGACY)pRenderHal;
233 MHW_RENDERHAL_CHK_NULL(pRenderHalLegacy);
234 MHW_RENDERHAL_CHK_NULL(pRenderHalLegacy->pMhwRenderInterface);
235
236 MHW_RENDERHAL_CHK_STATUS(pRenderHalLegacy->pMhwRenderInterface->EnablePreemption(pCmdBuffer));
237
238 finish:
239 return eStatus;
240 }
241
SendPredicationCommand(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer)242 MOS_STATUS XRenderHal_Platform_Interface_Legacy::SendPredicationCommand(
243 PRENDERHAL_INTERFACE pRenderHal,
244 PMOS_COMMAND_BUFFER pCmdBuffer)
245 {
246 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
247
248 //-----------------------------------------
249 MHW_RENDERHAL_CHK_NULL(pRenderHal);
250 MHW_RENDERHAL_CHK_NULL(pRenderHal->pOsInterface);
251 MHW_RENDERHAL_CHK_NULL(pRenderHal->pMhwMiInterface);
252 MHW_RENDERHAL_CHK_NULL(pRenderHal->pMhwMiInterface->GetMmioRegisters());
253 //-----------------------------------------
254
255 MHW_MI_CONDITIONAL_BATCH_BUFFER_END_PARAMS condBBEndParams;
256 MOS_ZeroMemory(&condBBEndParams, sizeof(condBBEndParams));
257
258 MOS_SYNC_PARAMS syncParams;
259 MOS_ZeroMemory(&syncParams, sizeof(syncParams));
260 syncParams.uiSemaphoreCount = 1;
261 // Currently only sync between VEBOX and 3D, also need to consider sync between Render Engine and 3D
262 // low priority since current VP Predication test case does not cover this scenario.
263 syncParams.GpuContext = MOS_GPU_CONTEXT_VEBOX;
264 syncParams.presSyncResource = pRenderHal->PredicationParams.pPredicationResource;
265 syncParams.bReadOnly = true;
266 syncParams.bDisableDecodeSyncLock = false;
267 syncParams.bDisableLockForTranscode = false;
268
269 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pOsInterface->pfnPerformOverlaySync(pRenderHal->pOsInterface, &syncParams));
270 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pOsInterface->pfnResourceWait(pRenderHal->pOsInterface, &syncParams));
271
272 // This function is only support VEBox right now, since register returned by pMhwMiInterface->GetMmioRegisters() is for VEBox.
273 // Keep implementation same between Render and VEBox engines - for Render it is highly inefficient
274 // Skip current frame if presPredication is not equal to zero
275 if (pRenderHal->PredicationParams.predicationNotEqualZero)
276 {
277 auto mmioRegistersRender = pRenderHal->pMhwMiInterface->GetMmioRegisters();
278 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
279 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
280 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiFlushDwCmd(pCmdBuffer, &flushDwParams));
281
282 // load presPredication to general purpose register0
283 MHW_MI_STORE_REGISTER_MEM_PARAMS loadRegisterMemParams;
284 MOS_ZeroMemory(&loadRegisterMemParams, sizeof(loadRegisterMemParams));
285 loadRegisterMemParams.presStoreBuffer = pRenderHal->PredicationParams.pPredicationResource;
286 loadRegisterMemParams.dwOffset = (uint32_t)pRenderHal->PredicationParams.predicationResOffset;
287 loadRegisterMemParams.dwRegister = mmioRegistersRender->generalPurposeRegister0LoOffset;
288 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiLoadRegisterMemCmd(
289 pCmdBuffer,
290 &loadRegisterMemParams));
291
292 MHW_MI_LOAD_REGISTER_IMM_PARAMS loadRegisterImmParams;
293 MOS_ZeroMemory(&loadRegisterImmParams, sizeof(loadRegisterImmParams));
294 loadRegisterImmParams.dwData = 0;
295 loadRegisterImmParams.dwRegister = mmioRegistersRender->generalPurposeRegister0HiOffset;
296 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiLoadRegisterImmCmd(
297 pCmdBuffer,
298 &loadRegisterImmParams));
299
300 // load 0 to general purpose register4
301 MOS_ZeroMemory(&loadRegisterImmParams, sizeof(loadRegisterImmParams));
302 loadRegisterImmParams.dwData = 0;
303 loadRegisterImmParams.dwRegister = mmioRegistersRender->generalPurposeRegister4LoOffset;
304 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiLoadRegisterImmCmd(
305 pCmdBuffer,
306 &loadRegisterImmParams));
307
308 MOS_ZeroMemory(&loadRegisterImmParams, sizeof(loadRegisterImmParams));
309 loadRegisterImmParams.dwData = 0;
310 loadRegisterImmParams.dwRegister = mmioRegistersRender->generalPurposeRegister4HiOffset;
311 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiLoadRegisterImmCmd(
312 pCmdBuffer,
313 &loadRegisterImmParams));
314
315 //perform the add operation
316 MHW_MI_MATH_PARAMS miMathParams;
317 MHW_MI_ALU_PARAMS miAluParams[4];
318 MOS_ZeroMemory(&miMathParams, sizeof(miMathParams));
319 MOS_ZeroMemory(&miAluParams, sizeof(miAluParams));
320 // load srcA, reg0
321 miAluParams[0].AluOpcode = MHW_MI_ALU_LOAD;
322 miAluParams[0].Operand1 = MHW_MI_ALU_SRCA;
323 miAluParams[0].Operand2 = MHW_MI_ALU_GPREG0;
324 // load srcB, reg4
325 miAluParams[1].AluOpcode = MHW_MI_ALU_LOAD;
326 miAluParams[1].Operand1 = MHW_MI_ALU_SRCB;
327 miAluParams[1].Operand2 = MHW_MI_ALU_GPREG4;
328 // add srcA, srcB
329 miAluParams[2].AluOpcode = MHW_MI_ALU_ADD;
330 miAluParams[2].Operand1 = MHW_MI_ALU_SRCB;
331 miAluParams[2].Operand2 = MHW_MI_ALU_GPREG4;
332 // store reg0, ZF
333 miAluParams[3].AluOpcode = MHW_MI_ALU_STORE;
334 miAluParams[3].Operand1 = MHW_MI_ALU_GPREG0;
335 miAluParams[3].Operand2 = MHW_MI_ALU_ZF;
336 miMathParams.pAluPayload = miAluParams;
337 miMathParams.dwNumAluParams = 4; // four ALU commands needed for this substract opertaion. see following ALU commands.
338 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiMathCmd(
339 pCmdBuffer,
340 &miMathParams));
341
342 // if zero, the zero flag will be 0xFFFFFFFF, else zero flag will be 0x0.
343 MHW_MI_STORE_REGISTER_MEM_PARAMS storeRegParams;
344 MOS_ZeroMemory(&storeRegParams, sizeof(storeRegParams));
345 storeRegParams.presStoreBuffer = &pRenderHal->PredicationBuffer;
346 storeRegParams.dwOffset = 0x10;
347 storeRegParams.dwRegister = mmioRegistersRender->generalPurposeRegister0LoOffset;
348 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiStoreRegisterMemCmd(
349 pCmdBuffer,
350 &storeRegParams));
351
352 // Programming of 4 dummy MI_STORE_DATA_IMM commands prior to programming of MiConditionalBatchBufferEnd
353 MHW_MI_STORE_DATA_PARAMS dataParams;
354 MOS_ZeroMemory(&dataParams, sizeof(dataParams));
355 dataParams.pOsResource = &pRenderHal->PredicationBuffer;
356 dataParams.dwValue = 1;
357 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiStoreDataImmCmd(
358 pCmdBuffer,
359 &dataParams));
360
361 dataParams.dwValue = 2;
362 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiStoreDataImmCmd(
363 pCmdBuffer,
364 &dataParams));
365
366 dataParams.dwValue = 3;
367 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiStoreDataImmCmd(
368 pCmdBuffer,
369 &dataParams));
370
371 dataParams.dwValue = 4;
372 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiStoreDataImmCmd(
373 pCmdBuffer,
374 &dataParams));
375
376 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
377 flushDwParams.postSyncOperation = 1;
378 flushDwParams.pOsResource = &pRenderHal->PredicationBuffer;
379 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiFlushDwCmd(pCmdBuffer, &flushDwParams));
380
381 condBBEndParams.presSemaphoreBuffer = &pRenderHal->PredicationBuffer;
382 condBBEndParams.dwOffset = 0x10;
383 condBBEndParams.dwValue = 0;
384 condBBEndParams.bDisableCompareMask = true;
385 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiConditionalBatchBufferEndCmd(
386 pCmdBuffer,
387 &condBBEndParams));
388
389 pRenderHal->PredicationParams.ptempPredicationBuffer = &pRenderHal->PredicationBuffer;
390 }
391 else
392 {
393 auto mmioRegistersRender = pRenderHal->pMhwMiInterface->GetMmioRegisters();
394
395 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
396 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
397 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiFlushDwCmd(pCmdBuffer, &flushDwParams));
398
399 // load presPredication to general purpose register0
400 MHW_MI_STORE_REGISTER_MEM_PARAMS loadRegisterMemParams;
401 MOS_ZeroMemory(&loadRegisterMemParams, sizeof(loadRegisterMemParams));
402 loadRegisterMemParams.presStoreBuffer = pRenderHal->PredicationParams.pPredicationResource;
403 loadRegisterMemParams.dwOffset = (uint32_t)pRenderHal->PredicationParams.predicationResOffset;
404 loadRegisterMemParams.dwRegister = mmioRegistersRender->generalPurposeRegister0LoOffset;
405 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiLoadRegisterMemCmd(
406 pCmdBuffer,
407 &loadRegisterMemParams));
408
409 // if zero, the zero flag will be 0xFFFFFFFF, else zero flag will be 0x0.
410 MHW_MI_STORE_REGISTER_MEM_PARAMS storeRegParams;
411 MOS_ZeroMemory(&storeRegParams, sizeof(storeRegParams));
412 storeRegParams.presStoreBuffer = &pRenderHal->PredicationBuffer;
413 storeRegParams.dwOffset = 0x10;
414 storeRegParams.dwRegister = mmioRegistersRender->generalPurposeRegister0LoOffset;
415 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiStoreRegisterMemCmd(
416 pCmdBuffer,
417 &storeRegParams));
418
419 // Programming of 4 dummy MI_STORE_DATA_IMM commands prior to programming of MiConditionalBatchBufferEnd
420 MHW_MI_STORE_DATA_PARAMS dataParams;
421 MOS_ZeroMemory(&dataParams, sizeof(dataParams));
422 dataParams.pOsResource = &pRenderHal->PredicationBuffer;
423 dataParams.dwValue = 1;
424 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiStoreDataImmCmd(
425 pCmdBuffer,
426 &dataParams));
427
428 dataParams.dwValue = 2;
429 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiStoreDataImmCmd(
430 pCmdBuffer,
431 &dataParams));
432
433 dataParams.dwValue = 3;
434 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiStoreDataImmCmd(
435 pCmdBuffer,
436 &dataParams));
437
438 dataParams.dwValue = 4;
439 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiStoreDataImmCmd(
440 pCmdBuffer,
441 &dataParams));
442
443 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
444 flushDwParams.postSyncOperation = 1;
445 flushDwParams.pOsResource = &pRenderHal->PredicationBuffer;
446 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiFlushDwCmd(pCmdBuffer, &flushDwParams));
447
448 // Skip current frame if presPredication is equal to zero
449 condBBEndParams.presSemaphoreBuffer = &pRenderHal->PredicationBuffer;
450 condBBEndParams.dwOffset = 0x10;
451 condBBEndParams.bDisableCompareMask = true;
452 condBBEndParams.dwValue = 0;
453 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiConditionalBatchBufferEndCmd(
454 pCmdBuffer,
455 &condBBEndParams));
456 }
457
458 finish:
459 return eStatus;
460 }
461
462 //!
463 //! \brief Adds marker attributes in command buffer
464 //! \param PRENDERHAL_INTERFACE pRenderHal
465 //! [in] Pointer to RenderHal Interface Structure
466 //! \param PMOS_COMMAND_BUFFER pcmdBuffer
467 //! [in] Pointer to Command Buffer
468 //! \param bool isRender
469 //! [in] Flag of Render Engine
470 //! \return MOS_STATUS
471 //!
SendMarkerCommand(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER cmdBuffer,bool isRender)472 MOS_STATUS XRenderHal_Platform_Interface_Legacy::SendMarkerCommand(
473 PRENDERHAL_INTERFACE pRenderHal,
474 PMOS_COMMAND_BUFFER cmdBuffer,
475 bool isRender)
476 {
477 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
478
479 //-----------------------------------------
480 MHW_RENDERHAL_CHK_NULL(pRenderHal);
481 MHW_RENDERHAL_CHK_NULL(pRenderHal->pMhwMiInterface);
482 //-----------------------------------------
483
484 if (isRender)
485 {
486 // Send pipe_control to get the timestamp
487 MHW_PIPE_CONTROL_PARAMS pipeControlParams;
488 MOS_ZeroMemory(&pipeControlParams, sizeof(pipeControlParams));
489 pipeControlParams.presDest = pRenderHal->SetMarkerParams.pSetMarkerResource;
490 pipeControlParams.dwResourceOffset = 0;
491 pipeControlParams.dwPostSyncOp = MHW_FLUSH_WRITE_TIMESTAMP_REG;
492 pipeControlParams.dwFlushMode = MHW_FLUSH_WRITE_CACHE;
493 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddPipeControl(cmdBuffer, nullptr, &pipeControlParams));
494 }
495 else
496 {
497 // Send flush_dw to get the timestamp
498 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
499 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
500 flushDwParams.pOsResource = pRenderHal->SetMarkerParams.pSetMarkerResource;
501 flushDwParams.dwResourceOffset = 0;
502 flushDwParams.postSyncOperation = MHW_FLUSH_WRITE_TIMESTAMP_REG;
503 flushDwParams.bQWordEnable = 1;
504 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiFlushDwCmd(cmdBuffer, &flushDwParams));
505 }
506
507 finish:
508 return eStatus;
509 }
510
AddMiPipeControl(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer,MHW_PIPE_CONTROL_PARAMS * params)511 MOS_STATUS XRenderHal_Platform_Interface_Legacy::AddMiPipeControl(
512 PRENDERHAL_INTERFACE pRenderHal,
513 PMOS_COMMAND_BUFFER pCmdBuffer,
514 MHW_PIPE_CONTROL_PARAMS* params)
515 {
516 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
517
518 //------------------------------------
519 MHW_RENDERHAL_CHK_NULL(pRenderHal);
520 MHW_RENDERHAL_CHK_NULL(pRenderHal->pMhwMiInterface);
521 MHW_RENDERHAL_CHK_NULL(pCmdBuffer);
522 MHW_RENDERHAL_CHK_NULL(params);
523 //------------------------------------
524
525 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddPipeControl(pCmdBuffer, nullptr, params));
526
527 finish:
528 return eStatus;
529 }
530
531 //!
532 //! \brief Adds MI_LOAD_REGISTER_IMM to the command buffer
533 //! \param PRENDERHAL_INTERFACE pRenderHal
534 //! [in] Pointer to RenderHal Interface Structure
535 //! \param [in] pCmdBuffer
536 //! Command buffer to which requested command is added
537 //! \param [in] params
538 //! Parameters used to populate the requested command
539 //! \return MOS_STATUS
540 //! MOS_STATUS_SUCCESS if success, else fail reason
541 //!
AddMiLoadRegisterImmCmd(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer,PMHW_MI_LOAD_REGISTER_IMM_PARAMS params)542 MOS_STATUS XRenderHal_Platform_Interface_Legacy::AddMiLoadRegisterImmCmd(
543 PRENDERHAL_INTERFACE pRenderHal,
544 PMOS_COMMAND_BUFFER pCmdBuffer,
545 PMHW_MI_LOAD_REGISTER_IMM_PARAMS params)
546 {
547 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
548
549 //-----------------------------------------
550 MHW_RENDERHAL_CHK_NULL(pRenderHal);
551 MHW_RENDERHAL_CHK_NULL(pRenderHal->pMhwMiInterface);
552 MHW_RENDERHAL_CHK_NULL(pCmdBuffer);
553 MHW_RENDERHAL_CHK_NULL(params);
554 //-----------------------------------------
555
556 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiLoadRegisterImmCmd(pCmdBuffer, params));
557
558 finish:
559 return eStatus;
560 }
561
SendGenericPrologCmd(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer,PMHW_GENERIC_PROLOG_PARAMS pParams,MHW_MI_MMIOREGISTERS * pMmioReg)562 MOS_STATUS XRenderHal_Platform_Interface_Legacy::SendGenericPrologCmd(
563 PRENDERHAL_INTERFACE pRenderHal,
564 PMOS_COMMAND_BUFFER pCmdBuffer,
565 PMHW_GENERIC_PROLOG_PARAMS pParams,
566 MHW_MI_MMIOREGISTERS* pMmioReg)
567 {
568 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
569
570 //-----------------------------------------
571 MHW_RENDERHAL_CHK_NULL(pRenderHal);
572 MHW_RENDERHAL_CHK_NULL(pRenderHal->pMhwMiInterface);
573 MHW_RENDERHAL_CHK_NULL(pCmdBuffer);
574 MHW_RENDERHAL_CHK_NULL(pParams);
575 //-----------------------------------------
576
577 MHW_RENDERHAL_CHK_STATUS(Mhw_SendGenericPrologCmd(pCmdBuffer, pParams, pMmioReg));
578
579 finish:
580 return eStatus;
581 }
582
CreateMhwInterfaces(PRENDERHAL_INTERFACE pRenderHal,PMOS_INTERFACE pOsInterface)583 MOS_STATUS XRenderHal_Platform_Interface_Legacy::CreateMhwInterfaces(
584 PRENDERHAL_INTERFACE pRenderHal,
585 PMOS_INTERFACE pOsInterface)
586 {
587 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
588 PRENDERHAL_INTERFACE_LEGACY pRenderHalLegacy = (PRENDERHAL_INTERFACE_LEGACY)pRenderHal;
589 //-----------------------------------------
590 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHalLegacy);
591 MHW_RENDERHAL_CHK_NULL_RETURN(pOsInterface);
592 //-----------------------------------------
593
594 MhwInterfaces::CreateParams params;
595 MOS_ZeroMemory(¶ms, sizeof(params));
596 params.Flags.m_render = true;
597 params.m_heapMode = pRenderHalLegacy->bDynamicStateHeap;
598 MhwInterfaces *mhwInterfaces = MhwInterfaces::CreateFactory(params, pOsInterface);
599 MHW_RENDERHAL_CHK_NULL_RETURN(mhwInterfaces);
600 MHW_RENDERHAL_CHK_NULL_RETURN(mhwInterfaces->m_cpInterface);
601 MHW_RENDERHAL_CHK_NULL_RETURN(mhwInterfaces->m_miInterface);
602 MHW_RENDERHAL_CHK_NULL_RETURN(mhwInterfaces->m_renderInterface);
603 pRenderHalLegacy->pCpInterface = mhwInterfaces->m_cpInterface;
604 pRenderHalLegacy->pMhwMiInterface = mhwInterfaces->m_miInterface;
605 pRenderHalLegacy->pMhwRenderInterface = mhwInterfaces->m_renderInterface;
606
607 MOS_Delete(mhwInterfaces);
608
609 return eStatus;
610 }
611
On1stLevelBBStart(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer,PMOS_CONTEXT pOsContext,uint32_t gpuContextHandle,MHW_MI_MMIOREGISTERS * pMmioReg)612 MOS_STATUS XRenderHal_Platform_Interface_Legacy::On1stLevelBBStart(
613 PRENDERHAL_INTERFACE pRenderHal,
614 PMOS_COMMAND_BUFFER pCmdBuffer,
615 PMOS_CONTEXT pOsContext,
616 uint32_t gpuContextHandle,
617 MHW_MI_MMIOREGISTERS *pMmioReg)
618 {
619 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
620 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
621 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface);
622 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pMhwMiInterface);
623 MHW_RENDERHAL_CHK_NULL_RETURN(pCmdBuffer);
624 MHW_RENDERHAL_CHK_NULL_RETURN(pOsContext);
625 MHW_RENDERHAL_CHK_NULL_RETURN(pMmioReg);
626
627 HalOcaInterface::On1stLevelBBStart(*pCmdBuffer, *pOsContext, pRenderHal->pOsInterface->CurrentGpuContextHandle,
628 *(pRenderHal->pMhwMiInterface), *pMmioReg);
629
630 return eStatus;
631 }
632
OnDispatch(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer,PMOS_INTERFACE pOsInterface,MHW_MI_MMIOREGISTERS * pMmioReg)633 MOS_STATUS XRenderHal_Platform_Interface_Legacy::OnDispatch(
634 PRENDERHAL_INTERFACE pRenderHal,
635 PMOS_COMMAND_BUFFER pCmdBuffer,
636 PMOS_INTERFACE pOsInterface,
637 MHW_MI_MMIOREGISTERS *pMmioReg)
638 {
639 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
640 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
641 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pMhwMiInterface);
642 MHW_RENDERHAL_CHK_NULL_RETURN(pCmdBuffer);
643 MHW_RENDERHAL_CHK_NULL_RETURN(pOsInterface);
644 MHW_RENDERHAL_CHK_NULL_RETURN(pMmioReg);
645
646 HalOcaInterface::OnDispatch(*pCmdBuffer, *pOsInterface, *pRenderHal->pMhwMiInterface, *pMmioReg);
647
648 return eStatus;
649 }
650
CreatePerfProfiler(PRENDERHAL_INTERFACE pRenderHal)651 MOS_STATUS XRenderHal_Platform_Interface_Legacy::CreatePerfProfiler(
652 PRENDERHAL_INTERFACE pRenderHal)
653 {
654 PRENDERHAL_INTERFACE_LEGACY pRenderHalLegacy = static_cast<PRENDERHAL_INTERFACE_LEGACY>(pRenderHal);
655
656 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHalLegacy);
657 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHalLegacy->pOsInterface);
658
659 if (!pRenderHalLegacy->pPerfProfiler)
660 {
661 pRenderHalLegacy->pPerfProfiler = MediaPerfProfiler::Instance();
662 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHalLegacy->pPerfProfiler);
663
664 MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHalLegacy->pPerfProfiler->Initialize((void*)pRenderHalLegacy, pRenderHalLegacy->pOsInterface));
665 }
666
667 return MOS_STATUS_SUCCESS;
668 }
669
DestroyPerfProfiler(PRENDERHAL_INTERFACE pRenderHal)670 MOS_STATUS XRenderHal_Platform_Interface_Legacy::DestroyPerfProfiler(
671 PRENDERHAL_INTERFACE pRenderHal)
672 {
673 PRENDERHAL_INTERFACE_LEGACY pRenderHalLegacy = static_cast<PRENDERHAL_INTERFACE_LEGACY>(pRenderHal);
674
675 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHalLegacy);
676 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHalLegacy->pOsInterface);
677
678 if (pRenderHalLegacy->pPerfProfiler)
679 {
680 MediaPerfProfiler::Destroy(pRenderHalLegacy->pPerfProfiler, (void*)pRenderHalLegacy, pRenderHalLegacy->pOsInterface);
681 pRenderHalLegacy->pPerfProfiler = nullptr;
682 }
683
684 return MOS_STATUS_SUCCESS;
685 }
686
AddPerfCollectStartCmd(PRENDERHAL_INTERFACE pRenderHal,MOS_INTERFACE * osInterface,MOS_COMMAND_BUFFER * cmdBuffer)687 MOS_STATUS XRenderHal_Platform_Interface_Legacy::AddPerfCollectStartCmd(
688 PRENDERHAL_INTERFACE pRenderHal,
689 MOS_INTERFACE *osInterface,
690 MOS_COMMAND_BUFFER *cmdBuffer)
691 {
692 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
693 PRENDERHAL_INTERFACE_LEGACY pRenderHalLegacy = static_cast<PRENDERHAL_INTERFACE_LEGACY>(pRenderHal);
694
695 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHalLegacy);
696 MHW_RENDERHAL_CHK_NULL_RETURN(osInterface);
697 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHalLegacy->pPerfProfiler);
698 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHalLegacy->pMhwMiInterface);
699 MHW_RENDERHAL_CHK_NULL_RETURN(cmdBuffer);
700
701 MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHalLegacy->pPerfProfiler->AddPerfCollectStartCmd((void*)pRenderHalLegacy, osInterface, pRenderHalLegacy->pMhwMiInterface, cmdBuffer));
702
703 return eStatus;
704 }
705
StartPredicate(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER cmdBuffer)706 MOS_STATUS XRenderHal_Platform_Interface_Legacy::StartPredicate(
707 PRENDERHAL_INTERFACE pRenderHal,
708 PMOS_COMMAND_BUFFER cmdBuffer)
709 {
710 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
711 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
712 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pMhwMiInterface);
713 MHW_RENDERHAL_CHK_NULL_RETURN(cmdBuffer);
714
715 MHW_RENDERHAL_CHK_STATUS_RETURN(NullHW::StartPredicate(pRenderHal->pOsInterface, pRenderHal->pMhwMiInterface, cmdBuffer));
716
717 return eStatus;
718 }
719
StopPredicate(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER cmdBuffer)720 MOS_STATUS XRenderHal_Platform_Interface_Legacy::StopPredicate(
721 PRENDERHAL_INTERFACE pRenderHal,
722 PMOS_COMMAND_BUFFER cmdBuffer)
723 {
724 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
725 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
726 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pMhwMiInterface);
727 MHW_RENDERHAL_CHK_NULL_RETURN(cmdBuffer);
728
729 MHW_RENDERHAL_CHK_STATUS_RETURN(NullHW::StopPredicate(pRenderHal->pOsInterface, pRenderHal->pMhwMiInterface, cmdBuffer));
730
731 return eStatus;
732 }
733
AddPerfCollectEndCmd(PRENDERHAL_INTERFACE pRenderHal,PMOS_INTERFACE pOsInterface,MOS_COMMAND_BUFFER * cmdBuffer)734 MOS_STATUS XRenderHal_Platform_Interface_Legacy::AddPerfCollectEndCmd(
735 PRENDERHAL_INTERFACE pRenderHal,
736 PMOS_INTERFACE pOsInterface,
737 MOS_COMMAND_BUFFER *cmdBuffer)
738 {
739 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
740 PRENDERHAL_INTERFACE_LEGACY pRenderHalLegacy = static_cast<PRENDERHAL_INTERFACE_LEGACY>(pRenderHal);
741
742 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHalLegacy);
743 MHW_RENDERHAL_CHK_NULL_RETURN(pOsInterface);
744 MHW_RENDERHAL_CHK_NULL_RETURN(cmdBuffer);
745 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHalLegacy->pPerfProfiler);
746
747 MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHalLegacy->pPerfProfiler->AddPerfCollectEndCmd((void*)pRenderHalLegacy, pOsInterface, pRenderHalLegacy->pMhwMiInterface, cmdBuffer));
748
749 return eStatus;
750 }
751
AddMediaVfeCmd(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer,MHW_VFE_PARAMS * params)752 MOS_STATUS XRenderHal_Platform_Interface_Legacy::AddMediaVfeCmd(
753 PRENDERHAL_INTERFACE pRenderHal,
754 PMOS_COMMAND_BUFFER pCmdBuffer,
755 MHW_VFE_PARAMS *params)
756 {
757 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
758 PRENDERHAL_INTERFACE_LEGACY pRenderHalLegacy = (PRENDERHAL_INTERFACE_LEGACY)pRenderHal;
759 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHalLegacy);
760 MHW_RENDERHAL_CHK_NULL_RETURN(params);
761 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHalLegacy->pMhwRenderInterface);
762 MHW_RENDERHAL_CHK_NULL_RETURN(pCmdBuffer);
763
764 MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHalLegacy->pMhwRenderInterface->AddMediaVfeCmd(pCmdBuffer, params));
765
766 return eStatus;
767 }
768
AddMediaStateFlush(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer,MHW_MEDIA_STATE_FLUSH_PARAM * params)769 MOS_STATUS XRenderHal_Platform_Interface_Legacy::AddMediaStateFlush(
770 PRENDERHAL_INTERFACE pRenderHal,
771 PMOS_COMMAND_BUFFER pCmdBuffer,
772 MHW_MEDIA_STATE_FLUSH_PARAM *params)
773 {
774 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
775 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
776 MHW_RENDERHAL_CHK_NULL_RETURN(params);
777 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pMhwMiInterface);
778 MHW_RENDERHAL_CHK_NULL_RETURN(pCmdBuffer);
779
780 MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pMhwMiInterface->AddMediaStateFlush(pCmdBuffer, nullptr, params));
781
782 return eStatus;
783 }
784
AddMiBatchBufferEnd(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer,PMHW_BATCH_BUFFER batchBuffer)785 MOS_STATUS XRenderHal_Platform_Interface_Legacy::AddMiBatchBufferEnd(
786 PRENDERHAL_INTERFACE pRenderHal,
787 PMOS_COMMAND_BUFFER pCmdBuffer,
788 PMHW_BATCH_BUFFER batchBuffer)
789 {
790 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
791 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
792 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pMhwMiInterface);
793 MHW_RENDERHAL_CHK_NULL_RETURN(pCmdBuffer);
794
795 MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pMhwMiInterface->AddMiBatchBufferEnd(pCmdBuffer, batchBuffer));
796
797 return eStatus;
798 }
799
AddMediaObjectWalkerCmd(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer,PMHW_WALKER_PARAMS params)800 MOS_STATUS XRenderHal_Platform_Interface_Legacy::AddMediaObjectWalkerCmd(
801 PRENDERHAL_INTERFACE pRenderHal,
802 PMOS_COMMAND_BUFFER pCmdBuffer,
803 PMHW_WALKER_PARAMS params)
804 {
805 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
806 PRENDERHAL_INTERFACE_LEGACY pRenderHalLegacy = (PRENDERHAL_INTERFACE_LEGACY)pRenderHal;
807 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHalLegacy);
808 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHalLegacy->pMhwRenderInterface);
809 MHW_RENDERHAL_CHK_NULL_RETURN(pCmdBuffer);
810
811 MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHalLegacy->pMhwRenderInterface->AddMediaObjectWalkerCmd(
812 pCmdBuffer,
813 params));
814
815 return MOS_STATUS_SUCCESS;
816 }
817
AddGpGpuWalkerStateCmd(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer,PMHW_GPGPU_WALKER_PARAMS params)818 MOS_STATUS XRenderHal_Platform_Interface_Legacy::AddGpGpuWalkerStateCmd(
819 PRENDERHAL_INTERFACE pRenderHal,
820 PMOS_COMMAND_BUFFER pCmdBuffer,
821 PMHW_GPGPU_WALKER_PARAMS params)
822 {
823 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
824 PRENDERHAL_INTERFACE_LEGACY pRenderHalLegacy = (PRENDERHAL_INTERFACE_LEGACY)pRenderHal;
825 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHalLegacy);
826 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHalLegacy->pMhwRenderInterface);
827 MHW_RENDERHAL_CHK_NULL_RETURN(pCmdBuffer);
828
829 MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHalLegacy->pMhwRenderInterface->AddGpGpuWalkerStateCmd(
830 pCmdBuffer,
831 params));
832
833 return MOS_STATUS_SUCCESS;
834 }
835
AllocateHeaps(PRENDERHAL_INTERFACE pRenderHal,MHW_STATE_HEAP_SETTINGS MhwStateHeapSettings)836 MOS_STATUS XRenderHal_Platform_Interface_Legacy::AllocateHeaps(
837 PRENDERHAL_INTERFACE pRenderHal,
838 MHW_STATE_HEAP_SETTINGS MhwStateHeapSettings)
839 {
840 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
841 PRENDERHAL_INTERFACE_LEGACY pRenderHalLegacy = (PRENDERHAL_INTERFACE_LEGACY)pRenderHal;
842 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHalLegacy);
843 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHalLegacy->pMhwRenderInterface);
844
845 MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHalLegacy->pMhwRenderInterface->AllocateHeaps(MhwStateHeapSettings));
846
847 return MOS_STATUS_SUCCESS;
848 }
849
GetStateHeapInterface(PRENDERHAL_INTERFACE pRenderHal)850 PMHW_STATE_HEAP_INTERFACE XRenderHal_Platform_Interface_Legacy::GetStateHeapInterface(
851 PRENDERHAL_INTERFACE pRenderHal)
852 {
853 PRENDERHAL_INTERFACE_LEGACY pRenderHalLegacy = (PRENDERHAL_INTERFACE_LEGACY)pRenderHal;
854 if (pRenderHalLegacy && pRenderHalLegacy->pMhwRenderInterface)
855 {
856 return pRenderHalLegacy->pMhwRenderInterface->m_stateHeapInterface;
857 }
858 else
859 {
860 return nullptr;
861 }
862 }
863
DestoryMhwInterface(PRENDERHAL_INTERFACE pRenderHal)864 MOS_STATUS XRenderHal_Platform_Interface_Legacy::DestoryMhwInterface(
865 PRENDERHAL_INTERFACE pRenderHal)
866 {
867 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
868 PRENDERHAL_INTERFACE_LEGACY pRenderHalLegacy = (PRENDERHAL_INTERFACE_LEGACY)pRenderHal;
869 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHalLegacy);
870 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHalLegacy->pMhwRenderInterface);
871
872 if (pRenderHalLegacy->pMhwRenderInterface)
873 {
874 MOS_Delete(pRenderHalLegacy->pMhwRenderInterface);
875 pRenderHalLegacy->pMhwRenderInterface = nullptr;
876 }
877
878 // Destroy MHW MI Interface
879 if (pRenderHalLegacy->pMhwMiInterface)
880 {
881 MOS_Delete(pRenderHalLegacy->pMhwMiInterface);
882 pRenderHalLegacy->pMhwMiInterface = nullptr;
883 }
884
885 return MOS_STATUS_SUCCESS;
886 }
887
AddMediaCurbeLoadCmd(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer,PMHW_CURBE_LOAD_PARAMS params)888 MOS_STATUS XRenderHal_Platform_Interface_Legacy::AddMediaCurbeLoadCmd(
889 PRENDERHAL_INTERFACE pRenderHal,
890 PMOS_COMMAND_BUFFER pCmdBuffer,
891 PMHW_CURBE_LOAD_PARAMS params)
892 {
893 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
894 PRENDERHAL_INTERFACE_LEGACY pRenderHalLegacy = (PRENDERHAL_INTERFACE_LEGACY)pRenderHal;
895 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHalLegacy);
896 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHalLegacy->pMhwRenderInterface);
897
898 MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHalLegacy->pMhwRenderInterface->AddMediaCurbeLoadCmd(pCmdBuffer, params));
899 return MOS_STATUS_SUCCESS;
900 }
901
AddMediaIDLoadCmd(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer,PMHW_ID_LOAD_PARAMS params)902 MOS_STATUS XRenderHal_Platform_Interface_Legacy::AddMediaIDLoadCmd(
903 PRENDERHAL_INTERFACE pRenderHal,
904 PMOS_COMMAND_BUFFER pCmdBuffer,
905 PMHW_ID_LOAD_PARAMS params)
906 {
907 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
908 PRENDERHAL_INTERFACE_LEGACY pRenderHalLegacy = (PRENDERHAL_INTERFACE_LEGACY)pRenderHal;
909 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHalLegacy);
910 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHalLegacy->pMhwRenderInterface);
911
912 MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHalLegacy->pMhwRenderInterface->AddMediaIDLoadCmd(pCmdBuffer, params));
913 return MOS_STATUS_SUCCESS;
914 }
915
IsPreemptionEnabled(PRENDERHAL_INTERFACE pRenderHal)916 bool XRenderHal_Platform_Interface_Legacy::IsPreemptionEnabled(
917 PRENDERHAL_INTERFACE pRenderHal)
918 {
919 PRENDERHAL_INTERFACE_LEGACY pRenderHalLegacy = (PRENDERHAL_INTERFACE_LEGACY)pRenderHal;
920 if (pRenderHalLegacy && pRenderHalLegacy->pMhwRenderInterface)
921 {
922 return pRenderHalLegacy->pMhwRenderInterface->IsPreemptionEnabled();
923 }
924 else
925 {
926 return false;
927 }
928 }
929
GetSamplerResolutionAlignUnit(PRENDERHAL_INTERFACE pRenderHal,bool isAVSSampler,uint32_t & widthAlignUnit,uint32_t & heightAlignUnit)930 void XRenderHal_Platform_Interface_Legacy::GetSamplerResolutionAlignUnit(
931 PRENDERHAL_INTERFACE pRenderHal,
932 bool isAVSSampler,
933 uint32_t &widthAlignUnit,
934 uint32_t &heightAlignUnit)
935 {
936 uint32_t wAlignUnit = 0;
937 uint32_t hAlignUnit = 0;
938 PRENDERHAL_INTERFACE_LEGACY pRenderHalLegacy = (PRENDERHAL_INTERFACE_LEGACY)pRenderHal;
939 if (pRenderHalLegacy && pRenderHalLegacy->pMhwRenderInterface)
940 {
941 pRenderHalLegacy->pMhwRenderInterface->GetSamplerResolutionAlignUnit(
942 isAVSSampler,
943 wAlignUnit,
944 hAlignUnit);
945 }
946
947 widthAlignUnit = wAlignUnit;
948 heightAlignUnit = hAlignUnit;
949 }
950
GetHwCaps(PRENDERHAL_INTERFACE pRenderHal)951 PMHW_RENDER_ENGINE_CAPS XRenderHal_Platform_Interface_Legacy::GetHwCaps(
952 PRENDERHAL_INTERFACE pRenderHal)
953 {
954 PRENDERHAL_INTERFACE_LEGACY pRenderHalLegacy = (PRENDERHAL_INTERFACE_LEGACY)pRenderHal;
955 if (pRenderHalLegacy && pRenderHalLegacy->pMhwRenderInterface)
956 {
957 return pRenderHalLegacy->pMhwRenderInterface->GetHwCaps();
958 }
959 else
960 {
961 return nullptr;
962 }
963 }
964
GetMhwMiItf()965 std::shared_ptr<mhw::mi::Itf> XRenderHal_Platform_Interface_Legacy::GetMhwMiItf()
966 {
967 return nullptr;
968 }
969