1 /*
2 * Copyright (c) 2021-2023, 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_next.cpp
24 //! \brief abstract the platfrom specific APIs into one class
25 //!
26 //! \file renderhal.h
27 //! \brief Render Engine Interfaces shared across platforms
28 //! \details Platform Independent Hardware Interfaces
29 //!
30
31 #include <stdint.h>
32 #include "renderhal_platform_interface_next.h"
33 #include "media_packet.h"
34 #include "mhw_utilities_next.h"
35 #include "hal_oca_interface_next.h"
36 #include "media_feature.h"
37 #include "media_interfaces_mhw_next.h"
38 #include "media_skuwa_specific.h"
39 #include "mhw_itf.h"
40 #include "mhw_mi_cmdpar.h"
41 #include "mhw_mi_itf.h"
42 #include "mhw_render_cmdpar.h"
43 #include "mos_os.h"
44 #include "mos_utilities.h"
45 #include "renderhal.h"
46 #include "vp_utils.h"
47 #include "media_perf_profiler.h"
48
XRenderHal_Platform_Interface_Next()49 XRenderHal_Platform_Interface_Next::XRenderHal_Platform_Interface_Next()
50 {
51 MOS_ZeroMemory(&m_scratchSpaceResource, sizeof(m_scratchSpaceResource));
52 }
53
AddPipelineSelectCmd(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer,bool gpGpuPipe)54 MOS_STATUS XRenderHal_Platform_Interface_Next::AddPipelineSelectCmd(
55 PRENDERHAL_INTERFACE pRenderHal,
56 PMOS_COMMAND_BUFFER pCmdBuffer,
57 bool gpGpuPipe)
58 {
59 VP_FUNC_CALL();
60
61 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
62
63 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
64 MHW_RENDERHAL_CHK_NULL_RETURN(pCmdBuffer);
65 m_renderHal = pRenderHal;
66
67 MHW_RENDERHAL_CHK_NULL_RETURN(m_renderItf);
68
69 auto& par = m_renderItf->MHW_GETPAR_F(PIPELINE_SELECT)();
70 par = {};
71 par.gpGpuPipe = gpGpuPipe;
72 MHW_CHK_STATUS_RETURN(m_renderItf->MHW_ADDCMD_F(PIPELINE_SELECT)(pCmdBuffer));
73
74 return eStatus;
75 }
76
SendStateBaseAddress(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer)77 MOS_STATUS XRenderHal_Platform_Interface_Next::SendStateBaseAddress(
78 PRENDERHAL_INTERFACE pRenderHal,
79 PMOS_COMMAND_BUFFER pCmdBuffer)
80 {
81 VP_FUNC_CALL();
82 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
83
84 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
85 MHW_RENDERHAL_CHK_NULL_RETURN(pCmdBuffer);
86 m_renderHal = pRenderHal;
87
88 MHW_RENDERHAL_CHK_NULL_RETURN(m_renderItf);
89 SETPAR_AND_ADDCMD(STATE_BASE_ADDRESS, m_renderItf, pCmdBuffer);
90
91 return eStatus;
92 }
93
AddSipStateCmd(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer)94 MOS_STATUS XRenderHal_Platform_Interface_Next::AddSipStateCmd(
95 PRENDERHAL_INTERFACE pRenderHal,
96 PMOS_COMMAND_BUFFER pCmdBuffer)
97 {
98 VP_FUNC_CALL();
99 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
100
101 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
102 MHW_RENDERHAL_CHK_NULL_RETURN(pCmdBuffer);
103 m_renderHal = pRenderHal;
104
105 MHW_RENDERHAL_CHK_NULL_RETURN(m_renderItf);
106 SETPAR_AND_ADDCMD(STATE_SIP, m_renderItf, pCmdBuffer);
107
108 return eStatus;
109 }
110
AddCfeStateCmd(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer,PMHW_VFE_PARAMS params)111 MOS_STATUS XRenderHal_Platform_Interface_Next::AddCfeStateCmd(
112 PRENDERHAL_INTERFACE pRenderHal,
113 PMOS_COMMAND_BUFFER pCmdBuffer,
114 PMHW_VFE_PARAMS params)
115 {
116 VP_FUNC_CALL();
117
118 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
119
120 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
121 MHW_RENDERHAL_CHK_NULL_RETURN(pCmdBuffer);
122 m_renderHal = pRenderHal;
123
124 MHW_RENDERHAL_CHK_NULL_RETURN(m_renderItf);
125 SETPAR_AND_ADDCMD(CFE_STATE, m_renderItf, pCmdBuffer);
126
127 return eStatus;
128 }
129
SendChromaKey(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer,PMHW_CHROMAKEY_PARAMS pChromaKeyParams)130 MOS_STATUS XRenderHal_Platform_Interface_Next::SendChromaKey(
131 PRENDERHAL_INTERFACE pRenderHal,
132 PMOS_COMMAND_BUFFER pCmdBuffer,
133 PMHW_CHROMAKEY_PARAMS pChromaKeyParams)
134 {
135 VP_FUNC_CALL();
136 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
137 MEDIA_WA_TABLE *pWaTable = nullptr;
138 MOS_GPU_CONTEXT renderGpuContext = {};
139
140 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
141 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface);
142 MHW_RENDERHAL_CHK_NULL_RETURN(pCmdBuffer);
143 m_renderHal = pRenderHal;
144
145 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface);
146 pWaTable = pRenderHal->pOsInterface->pfnGetWaTable(pRenderHal->pOsInterface);
147 MHW_RENDERHAL_CHK_NULL_RETURN(pWaTable);
148 renderGpuContext = pRenderHal->pOsInterface->pfnGetGpuContext(pRenderHal->pOsInterface);
149
150 // Program stalling pipecontrol with HDC pipeline flush enabled before programming 3DSTATE_CHROMA_KEY for CCS W/L.
151 if ((renderGpuContext == MOS_GPU_CONTEXT_COMPUTE) ||
152 (renderGpuContext == MOS_GPU_CONTEXT_CM_COMPUTE) ||
153 (renderGpuContext == MOS_GPU_CONTEXT_COMPUTE_RA))
154 {
155 if (MEDIA_IS_WA(pWaTable, Wa_16011481064))
156 {
157 MHW_RENDERHAL_CHK_NULL_RETURN(m_miItf);
158 auto &par = m_miItf->MHW_GETPAR_F(PIPE_CONTROL)();
159 par = {};
160 par.dwFlushMode = MHW_FLUSH_WRITE_CACHE;
161 par.bDisableCSStall = false;
162 par.bGenericMediaStateClear = true;
163 par.bIndirectStatePointersDisable = true;
164 par.bHdcPipelineFlush = true;
165 MHW_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(PIPE_CONTROL)(pCmdBuffer));
166 }
167 }
168
169 MHW_RENDERHAL_CHK_NULL_RETURN(m_renderItf);
170 SETPAR_AND_ADDCMD(_3DSTATE_CHROMA_KEY, m_renderItf, pCmdBuffer);
171
172 return eStatus;
173 }
174
SendPalette(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer,PMHW_PALETTE_PARAMS pPaletteLoadParams)175 MOS_STATUS XRenderHal_Platform_Interface_Next::SendPalette(
176 PRENDERHAL_INTERFACE pRenderHal,
177 PMOS_COMMAND_BUFFER pCmdBuffer,
178 PMHW_PALETTE_PARAMS pPaletteLoadParams)
179 {
180 VP_FUNC_CALL();
181
182 return MOS_STATUS_SUCCESS;
183 }
184
SetL3Cache(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer)185 MOS_STATUS XRenderHal_Platform_Interface_Next::SetL3Cache(
186 PRENDERHAL_INTERFACE pRenderHal,
187 PMOS_COMMAND_BUFFER pCmdBuffer)
188 {
189 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
190 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
191 MHW_RENDERHAL_CHK_NULL_RETURN(m_renderItf);
192
193 m_renderHal = pRenderHal;
194 MHW_RENDERHAL_CHK_STATUS_RETURN(m_renderItf->SetL3Cache(pCmdBuffer, m_miItf));
195
196 return eStatus;
197 }
198
199 //!
200 //! \brief Get the size of render hal media state
201 //! \return size_t
202 //! The size of render hal media state
203 //!
GetRenderHalMediaStateSize()204 size_t XRenderHal_Platform_Interface_Next::GetRenderHalMediaStateSize()
205 {
206 return sizeof(RENDERHAL_MEDIA_STATE);
207 }
208
209 //!
210 //! \brief Get the size of render hal state heap
211 //! \return size_t
212 //! The size of render hal state heap
213 //!
GetRenderHalStateHeapSize()214 size_t XRenderHal_Platform_Interface_Next::GetRenderHalStateHeapSize()
215 {
216 return sizeof(RENDERHAL_STATE_HEAP);
217 }
218
GetMmioRegisters(PRENDERHAL_INTERFACE pRenderHal)219 PMHW_MI_MMIOREGISTERS XRenderHal_Platform_Interface_Next::GetMmioRegisters(
220 PRENDERHAL_INTERFACE pRenderHal)
221 {
222 PMHW_MI_MMIOREGISTERS pMmioRegisters = nullptr;
223
224 if (m_renderItf)
225 {
226 pMmioRegisters = m_renderItf->GetMmioRegisters();
227 }
228
229 return pMmioRegisters;
230 }
231
EnablePreemption(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer)232 MOS_STATUS XRenderHal_Platform_Interface_Next::EnablePreemption(
233 PRENDERHAL_INTERFACE pRenderHal,
234 PMOS_COMMAND_BUFFER pCmdBuffer)
235 {
236 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
237 MEDIA_FEATURE_TABLE* m_skuTable = nullptr;
238 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
239 MHW_RENDERHAL_CHK_NULL_RETURN(m_miItf);
240 MHW_RENDERHAL_CHK_NULL_RETURN(m_renderItf);
241
242 MHW_RENDERHAL_CHK_STATUS_RETURN(m_renderItf->EnablePreemption(pCmdBuffer, m_miItf));
243
244 return eStatus;
245 }
246
SendPredicationCommand(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer)247 MOS_STATUS XRenderHal_Platform_Interface_Next::SendPredicationCommand(
248 PRENDERHAL_INTERFACE pRenderHal,
249 PMOS_COMMAND_BUFFER pCmdBuffer)
250 {
251 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
252
253 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
254 MHW_RENDERHAL_CHK_NULL_RETURN(m_miItf);
255 MHW_RENDERHAL_CHK_NULL_RETURN(m_miItf->GetMmioRegisters());
256
257 MOS_SYNC_PARAMS syncParams;
258 MOS_ZeroMemory(&syncParams, sizeof(syncParams));
259 syncParams.uiSemaphoreCount = 1;
260 // Currently only sync between VEBOX and 3D, also need to consider sync between Render Engine and 3D
261 // low priority since current VP Predication test case does not cover this scenario.
262 syncParams.GpuContext = MOS_GPU_CONTEXT_VEBOX;
263 syncParams.presSyncResource = pRenderHal->PredicationParams.pPredicationResource;
264 syncParams.bReadOnly = true;
265 syncParams.bDisableDecodeSyncLock = false;
266 syncParams.bDisableLockForTranscode = false;
267
268 MHW_CHK_STATUS_RETURN(pRenderHal->pOsInterface->pfnPerformOverlaySync(pRenderHal->pOsInterface, &syncParams));
269 MHW_CHK_STATUS_RETURN(pRenderHal->pOsInterface->pfnResourceWait(pRenderHal->pOsInterface, &syncParams));
270
271 if (pRenderHal->PredicationParams.predicationNotEqualZero)
272 {
273 auto mmioRegistersRender = m_miItf->GetMmioRegisters();
274
275 auto& parFlush = m_miItf->MHW_GETPAR_F(MI_FLUSH_DW)();
276 parFlush = {};
277 MHW_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_FLUSH_DW)(pCmdBuffer));
278
279 // load presPredication to general purpose register0
280 auto& parRegM = m_miItf->MHW_GETPAR_F(MI_LOAD_REGISTER_MEM)();
281 parRegM = {};
282 parRegM.presStoreBuffer = pRenderHal->PredicationParams.pPredicationResource;
283 parRegM.dwOffset = (uint32_t)pRenderHal->PredicationParams.predicationResOffset;
284 parRegM.dwRegister = mmioRegistersRender->generalPurposeRegister0LoOffset;
285 MHW_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_LOAD_REGISTER_MEM)(pCmdBuffer));
286
287 auto& parImm = m_miItf->MHW_GETPAR_F(MI_LOAD_REGISTER_IMM)();
288 parImm = {};
289 parImm.dwData = 0;
290 parImm.dwRegister = mmioRegistersRender->generalPurposeRegister0HiOffset;
291 MHW_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_LOAD_REGISTER_IMM)(pCmdBuffer));
292
293 parImm = {};
294 parImm.dwData = 0;
295 parImm.dwRegister = mmioRegistersRender->generalPurposeRegister4LoOffset;
296 MHW_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_LOAD_REGISTER_IMM)(pCmdBuffer));
297
298 parImm = {};
299 parImm.dwData = 0;
300 parImm.dwRegister = mmioRegistersRender->generalPurposeRegister4HiOffset;
301 MHW_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_LOAD_REGISTER_IMM)(pCmdBuffer));
302
303 //perform the add operation
304 mhw::mi::MHW_MI_ALU_PARAMS miAluParams[4] = {};
305
306 // load srcA, reg0
307 miAluParams[0].AluOpcode = MHW_MI_ALU_LOAD;
308 miAluParams[0].Operand1 = MHW_MI_ALU_SRCA;
309 miAluParams[0].Operand2 = MHW_MI_ALU_GPREG0;
310 // load srcB, reg4
311 miAluParams[1].AluOpcode = MHW_MI_ALU_LOAD;
312 miAluParams[1].Operand1 = MHW_MI_ALU_SRCB;
313 miAluParams[1].Operand2 = MHW_MI_ALU_GPREG4;
314 // add srcA, srcB
315 miAluParams[2].AluOpcode = MHW_MI_ALU_ADD;
316 miAluParams[2].Operand1 = MHW_MI_ALU_SRCB;
317 miAluParams[2].Operand2 = MHW_MI_ALU_GPREG4;
318 // store reg0, ZF
319 miAluParams[3].AluOpcode = MHW_MI_ALU_STORE;
320 miAluParams[3].Operand1 = MHW_MI_ALU_GPREG0;
321 miAluParams[3].Operand2 = MHW_MI_ALU_ZF;
322
323 auto& par = m_miItf->MHW_GETPAR_F(MI_MATH)();
324 par = {};
325 par.pAluPayload = miAluParams;
326 par.dwNumAluParams = 4; // four ALU commands needed for this substract opertaion. see following ALU commands.
327 MHW_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_MATH)(pCmdBuffer));
328
329 // if zero, the zero flag will be 0xFFFFFFFF, else zero flag will be 0x0.
330 parRegM = {};
331 parRegM.presStoreBuffer = &pRenderHal->PredicationBuffer;
332 parRegM.dwOffset = 0x10;
333 parRegM.dwRegister = mmioRegistersRender->generalPurposeRegister0LoOffset;
334 MHW_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_STORE_REGISTER_MEM)(pCmdBuffer));
335
336 // Programming of 4 dummy MI_STORE_DATA_IMM commands prior to programming of MiConditionalBatchBufferEnd
337 auto& parData = m_miItf->MHW_GETPAR_F(MI_STORE_DATA_IMM)();
338 parData = {};
339 parData.pOsResource = &pRenderHal->PredicationBuffer;
340 parData.dwValue = 1;
341 MHW_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_STORE_DATA_IMM)(pCmdBuffer));
342
343 parData.dwValue = 2;
344 MHW_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_STORE_DATA_IMM)(pCmdBuffer));
345
346 parData.dwValue = 3;
347 MHW_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_STORE_DATA_IMM)(pCmdBuffer));
348
349 parData.dwValue = 4;
350 MHW_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_STORE_DATA_IMM)(pCmdBuffer));
351
352 parFlush = {};
353 parFlush.postSyncOperation = 1;
354 parFlush.pOsResource = &pRenderHal->PredicationBuffer;
355 MHW_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_FLUSH_DW)(pCmdBuffer));
356
357 auto& parBatch = m_miItf->MHW_GETPAR_F(MI_CONDITIONAL_BATCH_BUFFER_END)();
358 parBatch = {};
359 parBatch.presSemaphoreBuffer = &pRenderHal->PredicationBuffer;
360 parBatch.dwOffset = 0x10;
361 parBatch.dwValue = 0;
362 parBatch.bDisableCompareMask = true;
363 MHW_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_CONDITIONAL_BATCH_BUFFER_END)(pCmdBuffer));
364
365 pRenderHal->PredicationParams.ptempPredicationBuffer = &pRenderHal->PredicationBuffer;
366 }
367 else
368 {
369 auto mmioRegistersRender = m_miItf->GetMmioRegisters();
370
371 auto& parFlush = m_miItf->MHW_GETPAR_F(MI_FLUSH_DW)();
372 parFlush = {};
373 MHW_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_FLUSH_DW)(pCmdBuffer));
374
375 // load presPredication to general purpose register0
376 auto& parRegM = m_miItf->MHW_GETPAR_F(MI_LOAD_REGISTER_MEM)();
377 parRegM = {};
378 parRegM.presStoreBuffer = pRenderHal->PredicationParams.pPredicationResource;
379 parRegM.dwOffset = (uint32_t)pRenderHal->PredicationParams.predicationResOffset;
380 parRegM.dwRegister = mmioRegistersRender->generalPurposeRegister0LoOffset;
381 MHW_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_LOAD_REGISTER_MEM)(pCmdBuffer));
382
383 // if zero, the zero flag will be 0xFFFFFFFF, else zero flag will be 0x0.
384 auto& parStore = m_miItf->MHW_GETPAR_F(MI_STORE_REGISTER_MEM)();
385 parStore.presStoreBuffer = &pRenderHal->PredicationBuffer;
386 parStore.dwOffset = 0x10;
387 parStore.dwRegister = mmioRegistersRender->generalPurposeRegister0LoOffset;
388 MHW_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_STORE_REGISTER_MEM)(pCmdBuffer));
389
390 // Programming of 4 dummy MI_STORE_DATA_IMM commands prior to programming of MiConditionalBatchBufferEnd
391 auto& parData = m_miItf->MHW_GETPAR_F(MI_STORE_DATA_IMM)();
392 parData.pOsResource = &pRenderHal->PredicationBuffer;
393 parData.dwValue = 1;
394 MHW_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_STORE_DATA_IMM)(pCmdBuffer));
395
396 parData.dwValue = 2;
397 MHW_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_STORE_DATA_IMM)(pCmdBuffer));
398
399 parData.dwValue = 3;
400 MHW_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_STORE_DATA_IMM)(pCmdBuffer));
401
402 parData.dwValue = 4;
403 MHW_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_STORE_DATA_IMM)(pCmdBuffer));
404
405 parFlush = {};
406 parFlush.postSyncOperation = 1;
407 parFlush.pOsResource = &pRenderHal->PredicationBuffer;
408 MHW_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_FLUSH_DW)(pCmdBuffer));
409
410 // Skip current frame if presPredication is equal to zero
411 auto& parBatch = m_miItf->MHW_GETPAR_F(MI_CONDITIONAL_BATCH_BUFFER_END)();
412 parBatch = {};
413 parBatch.presSemaphoreBuffer = &pRenderHal->PredicationBuffer;
414 parBatch.dwOffset = 0x10;
415 parBatch.dwValue = 0;
416 parBatch.bDisableCompareMask = true;
417 MHW_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_CONDITIONAL_BATCH_BUFFER_END)(pCmdBuffer));
418 }
419
420 return eStatus;
421 }
422
423 //!
424 //! \brief Adds marker attributes in command buffer
425 //! \param PRENDERHAL_INTERFACE pRenderHal
426 //! [in] Pointer to RenderHal Interface Structure
427 //! \param PMOS_COMMAND_BUFFER pcmdBuffer
428 //! [in] Pointer to Command Buffer
429 //! \param bool isRender
430 //! [in] Flag of Render Engine
431 //! \return MOS_STATUS
432 //!
SendMarkerCommand(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER cmdBuffer,bool isRender)433 MOS_STATUS XRenderHal_Platform_Interface_Next::SendMarkerCommand(
434 PRENDERHAL_INTERFACE pRenderHal,
435 PMOS_COMMAND_BUFFER cmdBuffer,
436 bool isRender)
437 {
438 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
439
440 //-----------------------------------------
441 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
442 MHW_RENDERHAL_CHK_NULL_RETURN(m_miItf);
443 //-----------------------------------------
444
445 if (isRender)
446 {
447 // Send pipe_control to get the timestamp
448 auto& params = m_miItf->MHW_GETPAR_F(PIPE_CONTROL)();
449 params = {};
450 params.presDest = pRenderHal->SetMarkerParams.pSetMarkerResource;
451 params.dwResourceOffset = 0;
452 params.dwPostSyncOp = MHW_FLUSH_WRITE_TIMESTAMP_REG;
453 params.dwFlushMode = MHW_FLUSH_WRITE_CACHE;
454 MHW_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(PIPE_CONTROL)(cmdBuffer));
455 }
456 else
457 {
458 // Send flush_dw to get the timestamp
459 auto& parFlush = m_miItf->MHW_GETPAR_F(MI_FLUSH_DW)();
460 parFlush = {};
461 parFlush.pOsResource = pRenderHal->SetMarkerParams.pSetMarkerResource;
462 parFlush.dwResourceOffset = 0;
463 parFlush.postSyncOperation = MHW_FLUSH_WRITE_TIMESTAMP_REG;
464 parFlush.bQWordEnable = 1;
465 MHW_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_FLUSH_DW)(cmdBuffer));
466 }
467
468 return eStatus;
469 }
470
AddMiPipeControl(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer,MHW_PIPE_CONTROL_PARAMS * params)471 MOS_STATUS XRenderHal_Platform_Interface_Next::AddMiPipeControl(
472 PRENDERHAL_INTERFACE pRenderHal,
473 PMOS_COMMAND_BUFFER pCmdBuffer,
474 MHW_PIPE_CONTROL_PARAMS* params)
475 {
476 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
477
478 //------------------------------------
479 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
480 MHW_RENDERHAL_CHK_NULL_RETURN(pCmdBuffer);
481 MHW_RENDERHAL_CHK_NULL_RETURN(params);
482 MHW_RENDERHAL_CHK_NULL_RETURN(m_miItf);
483 //------------------------------------
484
485 auto& par = m_miItf->MHW_GETPAR_F(PIPE_CONTROL)();
486 par = {};
487 par.presDest = params->presDest;
488 par.dwResourceOffset = params->dwResourceOffset;
489 par.dwDataDW1 = params->dwDataDW1;
490 par.dwDataDW2 = params->dwDataDW2;
491 par.dwFlushMode = params->dwFlushMode;
492 par.dwPostSyncOp = params->dwPostSyncOp;
493 par.bDisableCSStall = params->bDisableCSStall;
494 par.bInvalidateStateCache = params->bInvalidateStateCache;
495 par.bInvalidateConstantCache = params->bInvalidateConstantCache;
496 par.bInvalidateVFECache = params->bInvalidateVFECache;
497 par.bInvalidateInstructionCache = params->bInvalidateInstructionCache;
498 par.bFlushRenderTargetCache = params->bFlushRenderTargetCache;
499 par.bTlbInvalidate = params->bTlbInvalidate;
500 par.bInvalidateTextureCache = params->bInvalidateTextureCache;
501 par.bGenericMediaStateClear = params->bGenericMediaStateClear;
502 par.bIndirectStatePointersDisable = params->bIndirectStatePointersDisable;
503 par.bUnTypedDataPortCacheFlush = params->bUnTypedDataPortCacheFlush;
504 par.bHdcPipelineFlush = params->bHdcPipelineFlush;
505 par.bKernelFenceEnabled = params->bKernelFenceEnabled;
506 MHW_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(PIPE_CONTROL)(pCmdBuffer));
507
508 return eStatus;
509 }
510
511 //!
512 //! \brief Adds MI_LOAD_REGISTER_IMM to the command buffer
513 //! \param PRENDERHAL_INTERFACE pRenderHal
514 //! [in] Pointer to RenderHal Interface Structure
515 //! \param [in] pCmdBuffer
516 //! Command buffer to which requested command is added
517 //! \param [in] params
518 //! Parameters used to populate the requested command
519 //! \return MOS_STATUS
520 //! MOS_STATUS_SUCCESS if success, else fail reason
521 //!
AddMiLoadRegisterImmCmd(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer,PMHW_MI_LOAD_REGISTER_IMM_PARAMS params)522 MOS_STATUS XRenderHal_Platform_Interface_Next::AddMiLoadRegisterImmCmd(
523 PRENDERHAL_INTERFACE pRenderHal,
524 PMOS_COMMAND_BUFFER pCmdBuffer,
525 PMHW_MI_LOAD_REGISTER_IMM_PARAMS params)
526 {
527 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
528
529 //-----------------------------------------
530 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
531 MHW_RENDERHAL_CHK_NULL_RETURN(m_miItf);
532 MHW_RENDERHAL_CHK_NULL_RETURN(pCmdBuffer);
533 MHW_RENDERHAL_CHK_NULL_RETURN(params);
534 //-----------------------------------------
535
536 auto& par = m_miItf->MHW_GETPAR_F(MI_LOAD_REGISTER_IMM)();
537 par = {};
538 par.dwData = params->dwData;
539 par.dwRegister = params->dwRegister;
540 MHW_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_LOAD_REGISTER_IMM)(pCmdBuffer));
541
542 // TD_CTL, force thread breakpoint enable
543 // Also enable external halt/exceptions, because the source-level debugger
544 // needs to be able to interrupt running EU threads.
545 params->dwRegister = TD_CTL;
546 params->dwData = TD_CTL_FORCE_THREAD_BKPT_ENABLE |
547 TD_CTL_FORCE_EXT_EXCEPTION_ENABLE;
548
549 par = {};
550 par.dwData = params->dwData;
551 par.dwRegister = params->dwRegister;
552 MHW_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_LOAD_REGISTER_IMM)(pCmdBuffer));
553
554 return eStatus;
555 }
556
SendGenericPrologCmd(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer,PMHW_GENERIC_PROLOG_PARAMS pParams,MHW_MI_MMIOREGISTERS * pMmioReg)557 MOS_STATUS XRenderHal_Platform_Interface_Next::SendGenericPrologCmd(
558 PRENDERHAL_INTERFACE pRenderHal,
559 PMOS_COMMAND_BUFFER pCmdBuffer,
560 PMHW_GENERIC_PROLOG_PARAMS pParams,
561 MHW_MI_MMIOREGISTERS* pMmioReg)
562 {
563 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
564
565 //-----------------------------------------
566 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
567 MHW_RENDERHAL_CHK_NULL_RETURN(m_miItf);
568 MHW_RENDERHAL_CHK_NULL_RETURN(pCmdBuffer);
569 MHW_RENDERHAL_CHK_NULL_RETURN(pParams);
570 //-----------------------------------------
571
572 MHW_CHK_STATUS_RETURN(Mhw_SendGenericPrologCmdNext(pCmdBuffer, pParams, m_miItf, pMmioReg));
573
574 return eStatus;
575 }
576
CreateMhwInterfaces(PRENDERHAL_INTERFACE pRenderHal,PMOS_INTERFACE pOsInterface)577 MOS_STATUS XRenderHal_Platform_Interface_Next::CreateMhwInterfaces(
578 PRENDERHAL_INTERFACE pRenderHal,
579 PMOS_INTERFACE pOsInterface)
580 {
581 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
582
583 //-----------------------------------------
584 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
585 MHW_RENDERHAL_CHK_NULL_RETURN(pOsInterface);
586 //-----------------------------------------
587
588 MhwInterfacesNext::CreateParams params;
589 MOS_ZeroMemory(¶ms, sizeof(params));
590 params.Flags.m_render = true;
591 params.m_heapMode = pRenderHal->bDynamicStateHeap;
592 MhwInterfacesNext *mhwInterfaces = MhwInterfacesNext::CreateFactory(params, pOsInterface);
593 MHW_RENDERHAL_CHK_NULL_RETURN(mhwInterfaces);
594 MHW_RENDERHAL_CHK_NULL_RETURN(mhwInterfaces->m_cpInterface);
595
596 pRenderHal->pCpInterface = mhwInterfaces->m_cpInterface;
597 m_renderItf = mhwInterfaces->m_renderItf;
598 m_miItf = mhwInterfaces->m_miItf;
599 MOS_Delete(mhwInterfaces);
600
601 return eStatus;
602 }
603
On1stLevelBBStart(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer,PMOS_CONTEXT pOsContext,uint32_t gpuContextHandle,MHW_MI_MMIOREGISTERS * pMmioReg)604 MOS_STATUS XRenderHal_Platform_Interface_Next::On1stLevelBBStart(
605 PRENDERHAL_INTERFACE pRenderHal,
606 PMOS_COMMAND_BUFFER pCmdBuffer,
607 PMOS_CONTEXT pOsContext,
608 uint32_t gpuContextHandle,
609 MHW_MI_MMIOREGISTERS *pMmioReg)
610 {
611 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
612 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
613 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface);
614 MHW_RENDERHAL_CHK_NULL_RETURN(m_miItf);
615 MHW_RENDERHAL_CHK_NULL_RETURN(pCmdBuffer);
616
617 HalOcaInterfaceNext::On1stLevelBBStart(*pCmdBuffer, (MOS_CONTEXT_HANDLE)pOsContext, pRenderHal->pOsInterface->CurrentGpuContextHandle,
618 m_miItf, *pMmioReg);
619
620 return eStatus;
621 }
622
OnDispatch(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer,PMOS_INTERFACE pOsInterface,MHW_MI_MMIOREGISTERS * pMmioReg)623 MOS_STATUS XRenderHal_Platform_Interface_Next::OnDispatch(
624 PRENDERHAL_INTERFACE pRenderHal,
625 PMOS_COMMAND_BUFFER pCmdBuffer,
626 PMOS_INTERFACE pOsInterface,
627 MHW_MI_MMIOREGISTERS *pMmioReg)
628 {
629 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
630 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
631 MHW_RENDERHAL_CHK_NULL_RETURN(m_miItf);
632 MHW_RENDERHAL_CHK_NULL_RETURN(pCmdBuffer);
633 MHW_RENDERHAL_CHK_NULL_RETURN(pOsInterface);
634 MHW_RENDERHAL_CHK_NULL_RETURN(pMmioReg);
635
636 HalOcaInterfaceNext::OnDispatch(*pCmdBuffer, *pOsInterface, m_miItf, *pMmioReg);
637
638 return eStatus;
639 }
640
CreatePerfProfiler(PRENDERHAL_INTERFACE pRenderHal)641 MOS_STATUS XRenderHal_Platform_Interface_Next::CreatePerfProfiler(
642 PRENDERHAL_INTERFACE pRenderHal)
643 {
644 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
645 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface);
646
647 if (!pRenderHal->pPerfProfiler)
648 {
649 pRenderHal->pPerfProfiler = MediaPerfProfiler::Instance();
650 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pPerfProfiler);
651
652 MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pPerfProfiler->Initialize((void*)pRenderHal, pRenderHal->pOsInterface));
653 }
654
655 return MOS_STATUS_SUCCESS;
656 }
657
DestroyPerfProfiler(PRENDERHAL_INTERFACE pRenderHal)658 MOS_STATUS XRenderHal_Platform_Interface_Next::DestroyPerfProfiler(
659 PRENDERHAL_INTERFACE pRenderHal)
660 {
661 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
662 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface);
663
664 if (pRenderHal->pPerfProfiler)
665 {
666 MediaPerfProfiler::Destroy(pRenderHal->pPerfProfiler, (void*)pRenderHal, pRenderHal->pOsInterface);
667 pRenderHal->pPerfProfiler = nullptr;
668 }
669
670 return MOS_STATUS_SUCCESS;
671 }
672
AddPerfCollectStartCmd(PRENDERHAL_INTERFACE pRenderHal,MOS_INTERFACE * osInterface,MOS_COMMAND_BUFFER * cmdBuffer)673 MOS_STATUS XRenderHal_Platform_Interface_Next::AddPerfCollectStartCmd(
674 PRENDERHAL_INTERFACE pRenderHal,
675 MOS_INTERFACE *osInterface,
676 MOS_COMMAND_BUFFER *cmdBuffer)
677 {
678 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
679 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
680 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pPerfProfiler);
681 MHW_RENDERHAL_CHK_NULL_RETURN(osInterface);
682 MHW_RENDERHAL_CHK_NULL_RETURN(m_miItf);
683 MHW_RENDERHAL_CHK_NULL_RETURN(cmdBuffer);
684
685 MHW_CHK_STATUS_RETURN(pRenderHal->pPerfProfiler->AddPerfCollectStartCmd((void *)pRenderHal, osInterface, m_miItf, cmdBuffer));
686
687 return eStatus;
688 }
689
StartPredicate(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER cmdBuffer)690 MOS_STATUS XRenderHal_Platform_Interface_Next::StartPredicate(
691 PRENDERHAL_INTERFACE pRenderHal,
692 PMOS_COMMAND_BUFFER cmdBuffer)
693 {
694 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
695 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
696 MHW_RENDERHAL_CHK_NULL_RETURN(m_miItf);
697 MHW_RENDERHAL_CHK_NULL_RETURN(cmdBuffer);
698
699 MHW_CHK_STATUS_RETURN(NullHW::StartPredicateNext(pRenderHal->pOsInterface, m_miItf, cmdBuffer));
700
701 return eStatus;
702 }
703
StopPredicate(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER cmdBuffer)704 MOS_STATUS XRenderHal_Platform_Interface_Next::StopPredicate(
705 PRENDERHAL_INTERFACE pRenderHal,
706 PMOS_COMMAND_BUFFER cmdBuffer)
707 {
708 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
709 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
710 MHW_RENDERHAL_CHK_NULL_RETURN(m_miItf);
711 MHW_RENDERHAL_CHK_NULL_RETURN(cmdBuffer);
712
713 MHW_CHK_STATUS_RETURN(NullHW::StopPredicateNext(pRenderHal->pOsInterface, m_miItf, cmdBuffer));
714
715 return eStatus;
716 }
717
AddPerfCollectEndCmd(PRENDERHAL_INTERFACE pRenderHal,PMOS_INTERFACE pOsInterface,MOS_COMMAND_BUFFER * cmdBuffer)718 MOS_STATUS XRenderHal_Platform_Interface_Next::AddPerfCollectEndCmd(
719 PRENDERHAL_INTERFACE pRenderHal,
720 PMOS_INTERFACE pOsInterface,
721 MOS_COMMAND_BUFFER *cmdBuffer)
722 {
723 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
724 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
725 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pPerfProfiler);
726 MHW_RENDERHAL_CHK_NULL_RETURN(pOsInterface);
727 MHW_RENDERHAL_CHK_NULL_RETURN(m_miItf);
728 MHW_RENDERHAL_CHK_NULL_RETURN(cmdBuffer);
729
730 MHW_CHK_STATUS_RETURN(pRenderHal->pPerfProfiler->AddPerfCollectEndCmd((void *)pRenderHal, pOsInterface, m_miItf, cmdBuffer));
731
732 return eStatus;
733 }
734
AddMediaVfeCmd(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer,MHW_VFE_PARAMS * params)735 MOS_STATUS XRenderHal_Platform_Interface_Next::AddMediaVfeCmd(
736 PRENDERHAL_INTERFACE pRenderHal,
737 PMOS_COMMAND_BUFFER pCmdBuffer,
738 MHW_VFE_PARAMS *params)
739 {
740 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
741 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
742 MHW_RENDERHAL_CHK_NULL_RETURN(params);
743 MHW_RENDERHAL_CHK_NULL_RETURN(m_renderItf);
744 MHW_RENDERHAL_CHK_NULL_RETURN(pCmdBuffer);
745
746 return eStatus;
747 }
748
AddMediaStateFlush(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer,MHW_MEDIA_STATE_FLUSH_PARAM * flushParam)749 MOS_STATUS XRenderHal_Platform_Interface_Next::AddMediaStateFlush(
750 PRENDERHAL_INTERFACE pRenderHal,
751 PMOS_COMMAND_BUFFER pCmdBuffer,
752 MHW_MEDIA_STATE_FLUSH_PARAM *flushParam)
753 {
754 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
755 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
756 MHW_RENDERHAL_CHK_NULL_RETURN(flushParam);
757 MHW_RENDERHAL_CHK_NULL_RETURN(m_miItf);
758 MHW_RENDERHAL_CHK_NULL_RETURN(pCmdBuffer);
759
760 auto& params = m_miItf->MHW_GETPAR_F(MEDIA_STATE_FLUSH)();
761 params = {};
762 params.ui8InterfaceDescriptorOffset = flushParam->ui8InterfaceDescriptorOffset;
763 params.bFlushToGo = flushParam->bFlushToGo;
764 MHW_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MEDIA_STATE_FLUSH)(pCmdBuffer));
765
766 return eStatus;
767 }
768
AddMiBatchBufferEnd(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer,PMHW_BATCH_BUFFER batchBuffer)769 MOS_STATUS XRenderHal_Platform_Interface_Next::AddMiBatchBufferEnd(
770 PRENDERHAL_INTERFACE pRenderHal,
771 PMOS_COMMAND_BUFFER pCmdBuffer,
772 PMHW_BATCH_BUFFER batchBuffer)
773 {
774 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
775 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
776 MHW_RENDERHAL_CHK_NULL_RETURN(m_miItf);
777 MHW_RENDERHAL_CHK_NULL_RETURN(pCmdBuffer);
778
779 MHW_CHK_STATUS_RETURN(m_miItf->AddMiBatchBufferEnd(pCmdBuffer, nullptr));
780
781 return eStatus;
782 }
783
AddMediaObjectWalkerCmd(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer,PMHW_WALKER_PARAMS params)784 MOS_STATUS XRenderHal_Platform_Interface_Next::AddMediaObjectWalkerCmd(
785 PRENDERHAL_INTERFACE pRenderHal,
786 PMOS_COMMAND_BUFFER pCmdBuffer,
787 PMHW_WALKER_PARAMS params)
788 {
789 return MOS_STATUS_SUCCESS;
790 }
791
AddGpGpuWalkerStateCmd(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer,PMHW_GPGPU_WALKER_PARAMS params)792 MOS_STATUS XRenderHal_Platform_Interface_Next::AddGpGpuWalkerStateCmd(
793 PRENDERHAL_INTERFACE pRenderHal,
794 PMOS_COMMAND_BUFFER pCmdBuffer,
795 PMHW_GPGPU_WALKER_PARAMS params)
796 {
797 return MOS_STATUS_SUCCESS;
798 }
799
AllocateHeaps(PRENDERHAL_INTERFACE pRenderHal,MHW_STATE_HEAP_SETTINGS MhwStateHeapSettings)800 MOS_STATUS XRenderHal_Platform_Interface_Next::AllocateHeaps(
801 PRENDERHAL_INTERFACE pRenderHal,
802 MHW_STATE_HEAP_SETTINGS MhwStateHeapSettings)
803 {
804 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
805 MHW_RENDERHAL_CHK_NULL_RETURN(m_renderItf);
806
807 MHW_CHK_STATUS_RETURN(m_renderItf->AllocateHeaps(MhwStateHeapSettings));
808
809 return MOS_STATUS_SUCCESS;
810 }
811
GetStateHeapInterface(PRENDERHAL_INTERFACE pRenderHal)812 PMHW_STATE_HEAP_INTERFACE XRenderHal_Platform_Interface_Next::GetStateHeapInterface(
813 PRENDERHAL_INTERFACE pRenderHal)
814 {
815 if (m_renderItf)
816 {
817 return m_renderItf->GetStateHeapInterface();
818 }
819 else
820 {
821 return nullptr;
822 }
823 }
824
DestoryMhwInterface(PRENDERHAL_INTERFACE pRenderHal)825 MOS_STATUS XRenderHal_Platform_Interface_Next::DestoryMhwInterface(
826 PRENDERHAL_INTERFACE pRenderHal)
827 {
828 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
829 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
830
831 return MOS_STATUS_SUCCESS;
832 }
833
AddMediaCurbeLoadCmd(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer,PMHW_CURBE_LOAD_PARAMS params)834 MOS_STATUS XRenderHal_Platform_Interface_Next::AddMediaCurbeLoadCmd(
835 PRENDERHAL_INTERFACE pRenderHal,
836 PMOS_COMMAND_BUFFER pCmdBuffer,
837 PMHW_CURBE_LOAD_PARAMS params)
838 {
839 return MOS_STATUS_SUCCESS;
840 }
841
AddMediaIDLoadCmd(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer,PMHW_ID_LOAD_PARAMS params)842 MOS_STATUS XRenderHal_Platform_Interface_Next::AddMediaIDLoadCmd(
843 PRENDERHAL_INTERFACE pRenderHal,
844 PMOS_COMMAND_BUFFER pCmdBuffer,
845 PMHW_ID_LOAD_PARAMS params)
846 {
847 return MOS_STATUS_SUCCESS;
848 }
849
IsPreemptionEnabled(PRENDERHAL_INTERFACE pRenderHal)850 bool XRenderHal_Platform_Interface_Next::IsPreemptionEnabled(
851 PRENDERHAL_INTERFACE pRenderHal)
852 {
853 if (m_renderItf)
854 {
855 return m_renderItf->IsPreemptionEnabled();
856 }
857 else
858 {
859 return false;
860 }
861 }
862
GetSamplerResolutionAlignUnit(PRENDERHAL_INTERFACE pRenderHal,bool isAVSSampler,uint32_t & widthAlignUnit,uint32_t & heightAlignUnit)863 void XRenderHal_Platform_Interface_Next::GetSamplerResolutionAlignUnit(
864 PRENDERHAL_INTERFACE pRenderHal,
865 bool isAVSSampler,
866 uint32_t &widthAlignUnit,
867 uint32_t &heightAlignUnit)
868 {
869 uint32_t wAlignUnit = 0;
870 uint32_t hAlignUnit = 0;
871
872 if (m_renderItf)
873 {
874 m_renderItf->GetSamplerResolutionAlignUnit(
875 isAVSSampler,
876 wAlignUnit,
877 hAlignUnit);
878 }
879
880 widthAlignUnit = wAlignUnit;
881 heightAlignUnit = hAlignUnit;
882
883 }
884
GetHwCaps(PRENDERHAL_INTERFACE pRenderHal)885 MHW_RENDER_ENGINE_CAPS* XRenderHal_Platform_Interface_Next::GetHwCaps(
886 PRENDERHAL_INTERFACE pRenderHal)
887 {
888 if (m_renderItf)
889 {
890 return (MHW_RENDER_ENGINE_CAPS * )m_renderItf->GetHwCaps();
891 }
892 else
893 {
894 return nullptr;
895 }
896 }
897
IsComputeContextInUse(PRENDERHAL_INTERFACE pRenderHal)898 bool XRenderHal_Platform_Interface_Next::IsComputeContextInUse(PRENDERHAL_INTERFACE pRenderHal)
899 {
900 return true;
901 }
902
IsSampler128ElementsSupported()903 bool XRenderHal_Platform_Interface_Next::IsSampler128ElementsSupported()
904 {
905 return true;
906 }
907
PerThreadScratchSpaceStart2K(PRENDERHAL_INTERFACE pRenderHal)908 bool XRenderHal_Platform_Interface_Next::PerThreadScratchSpaceStart2K(PRENDERHAL_INTERFACE pRenderHal)
909 {
910 MHW_RENDERHAL_UNUSED(pRenderHal);
911 return false;
912 }
913
PerThreadScratchSpaceStart64Byte(RENDERHAL_INTERFACE * renderHal)914 bool XRenderHal_Platform_Interface_Next::PerThreadScratchSpaceStart64Byte(RENDERHAL_INTERFACE *renderHal)
915 {
916 MHW_RENDERHAL_UNUSED(renderHal);
917 return true;
918 }
919
CalculatePreferredSlmAllocationSizeFromSlmSize(RENDERHAL_INTERFACE * renderHal,uint32_t slmSize,uint32_t numberOfThreadsPerThreadGroup)920 uint32_t XRenderHal_Platform_Interface_Next::CalculatePreferredSlmAllocationSizeFromSlmSize(
921 RENDERHAL_INTERFACE *renderHal,
922 uint32_t slmSize,
923 uint32_t numberOfThreadsPerThreadGroup)
924 {
925 if (!renderHal || !renderHal->pOsInterface || !renderHal->pOsInterface->pfnGetGtSystemInfo)
926 {
927 MHW_RENDERHAL_ASSERTMESSAGE("renderhal or osInterface or pfnGetGtSystemInfo is nullptr");
928 return 0;
929 }
930 if (numberOfThreadsPerThreadGroup == 0)
931 {
932 MHW_RENDERHAL_ASSERTMESSAGE("numberOfThreadsPerThreadGroup is 0");
933 return 0;
934 }
935
936 MEDIA_SYSTEM_INFO *gtInfo = renderHal->pOsInterface->pfnGetGtSystemInfo(renderHal->pOsInterface);
937 if (!gtInfo)
938 {
939 MHW_RENDERHAL_ASSERTMESSAGE("GtSystemInfo is nullptr");
940 return 0;
941 }
942 if (gtInfo->SubSliceCount == 0)
943 {
944 MHW_RENDERHAL_ASSERTMESSAGE("SubSliceCount is 0");
945 return 0;
946 }
947 uint32_t preferredSlmAllicationSize = 0;
948 slmSize = slmSize / 1024 + (slmSize % 1024 != 0);
949 uint32_t threadsPerDssCount = gtInfo->ThreadCount / gtInfo->SubSliceCount;
950 uint32_t workGroupCountPerDss = (threadsPerDssCount + numberOfThreadsPerThreadGroup - 1) / numberOfThreadsPerThreadGroup;
951 uint32_t slmSizePerSubSlice = slmSize * workGroupCountPerDss;
952 if (slmSize == 0)
953 {
954 preferredSlmAllicationSize = 0;
955 }
956 else if (slmSizePerSubSlice <= 16)
957 {
958 preferredSlmAllicationSize = 1;
959 }
960 else if (slmSizePerSubSlice <= 32)
961 {
962 preferredSlmAllicationSize = 2;
963 }
964 else if (slmSizePerSubSlice > 256)
965 {
966 if (slmSizePerSubSlice > 384)
967 {
968 MHW_RENDERHAL_ASSERTMESSAGE("slmSizePerSubSlice %d is bigger than max size", slmSizePerSubSlice);
969 }
970 else
971 {
972 preferredSlmAllicationSize = 10;
973 }
974 }
975 else
976 {
977 preferredSlmAllicationSize = slmSizePerSubSlice / 32 + (slmSizePerSubSlice % 32 != 0) + 1;
978 }
979
980 return preferredSlmAllicationSize;
981 }
982
EncodeSLMSize(uint32_t SLMSize)983 uint32_t XRenderHal_Platform_Interface_Next::EncodeSLMSize(uint32_t SLMSize)
984 {
985 uint32_t EncodedValue;
986 SLMSize = SLMSize / 1024 + (SLMSize % 1024 != 0);
987
988 if (SLMSize <= 2)
989 {
990 EncodedValue = SLMSize;
991 }
992 else
993 {
994 EncodedValue = 0;
995 do
996 {
997 if (SLMSize != 1 && (SLMSize & 0x1) != 0)
998 {
999 ++SLMSize;
1000 }
1001 SLMSize >>= 1;
1002 EncodedValue++;
1003 } while (SLMSize);
1004 }
1005 return EncodedValue;
1006 }
1007
SetChromaDirection(PRENDERHAL_INTERFACE pRenderHal,PRENDERHAL_SURFACE pRenderHalSurface)1008 uint8_t XRenderHal_Platform_Interface_Next::SetChromaDirection(
1009 PRENDERHAL_INTERFACE pRenderHal,
1010 PRENDERHAL_SURFACE pRenderHalSurface)
1011 {
1012 uint8_t Direction;
1013 MHW_RENDERHAL_UNUSED(pRenderHal);
1014
1015 MHW_RENDERHAL_ASSERT(pRenderHalSurface);
1016
1017 Direction = 0;
1018
1019 if (pRenderHalSurface->ChromaSiting & MHW_CHROMA_SITING_HORZ_CENTER)
1020 {
1021 Direction = CHROMA_SITING_UDIRECTION_CENTER;
1022 }
1023 else
1024 {
1025 Direction = CHROMA_SITING_UDIRECTION_LEFT;
1026 }
1027
1028 // Combined U/V direction together in one uint8_t, 1 bit for U direction, 3 bits for V direction.
1029 Direction = Direction << 3;
1030
1031 if (pRenderHalSurface->pDeinterlaceParams || pRenderHalSurface->bQueryVariance)
1032 {
1033 if ((pRenderHalSurface->SampleType == RENDERHAL_SAMPLE_INTERLEAVED_EVEN_FIRST_BOTTOM_FIELD) ||
1034 (pRenderHalSurface->SampleType == RENDERHAL_SAMPLE_INTERLEAVED_ODD_FIRST_BOTTOM_FIELD))
1035 {
1036 if (pRenderHalSurface->ChromaSiting & MHW_CHROMA_SITING_VERT_TOP)
1037 {
1038 Direction |= CHROMA_SITING_VDIRECTION_1_2;
1039 }
1040 else if (pRenderHalSurface->ChromaSiting & MHW_CHROMA_SITING_VERT_BOTTOM)
1041 {
1042 Direction |= CHROMA_SITING_VDIRECTION_1;
1043 }
1044 else
1045 {
1046 Direction |= CHROMA_SITING_VDIRECTION_3_4;
1047 }
1048 }
1049 else if ((pRenderHalSurface->SampleType == RENDERHAL_SAMPLE_INTERLEAVED_EVEN_FIRST_TOP_FIELD) ||
1050 (pRenderHalSurface->SampleType == RENDERHAL_SAMPLE_INTERLEAVED_ODD_FIRST_TOP_FIELD))
1051 {
1052 if (pRenderHalSurface->ChromaSiting & MHW_CHROMA_SITING_VERT_TOP)
1053 {
1054 Direction |= CHROMA_SITING_VDIRECTION_0;
1055 }
1056 else if (pRenderHalSurface->ChromaSiting & MHW_CHROMA_SITING_VERT_BOTTOM)
1057 {
1058 Direction |= CHROMA_SITING_VDIRECTION_1_2;
1059 }
1060 else
1061 {
1062 Direction |= CHROMA_SITING_VDIRECTION_1_4;
1063 }
1064 }
1065 }
1066 else
1067 {
1068 if (pRenderHalSurface->ChromaSiting & MHW_CHROMA_SITING_VERT_TOP)
1069 {
1070 Direction |= CHROMA_SITING_VDIRECTION_0;
1071 }
1072 else if (pRenderHalSurface->ChromaSiting & MHW_CHROMA_SITING_VERT_BOTTOM)
1073 {
1074 Direction |= CHROMA_SITING_VDIRECTION_1;
1075 }
1076 else
1077 {
1078 Direction |= CHROMA_SITING_VDIRECTION_1_2;
1079 }
1080 }
1081
1082 return Direction;
1083 }
1084
InitSurfaceTypes(PRENDERHAL_INTERFACE pRenderHal)1085 void XRenderHal_Platform_Interface_Next::InitSurfaceTypes(PRENDERHAL_INTERFACE pRenderHal)
1086 {
1087 MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pRenderHal);
1088 // Set default / advanced surface types
1089 pRenderHal->SurfaceTypeDefault = RENDERHAL_SURFACE_TYPE_G10;
1090 pRenderHal->SurfaceTypeAdvanced = RENDERHAL_SURFACE_TYPE_ADV_G10;
1091 }
1092
IsEnableYV12SinglePass(PRENDERHAL_INTERFACE pRenderHal)1093 bool XRenderHal_Platform_Interface_Next::IsEnableYV12SinglePass(PRENDERHAL_INTERFACE pRenderHal)
1094 {
1095 MHW_RENDERHAL_UNUSED(pRenderHal);
1096 return true;
1097 }
1098
GetSizeSamplerStateAvs(PRENDERHAL_INTERFACE pRenderHal)1099 uint32_t XRenderHal_Platform_Interface_Next::GetSizeSamplerStateAvs(PRENDERHAL_INTERFACE pRenderHal)
1100 {
1101 if (pRenderHal && pRenderHal->pHwSizes)
1102 {
1103 return 2 * pRenderHal->pHwSizes->dwSizeSamplerStateAvs; // Kernel using 1,3,5 sampler index for AVS sampler state.
1104 }
1105 else
1106 {
1107 MHW_RENDERHAL_ASSERTMESSAGE("Failed to get SizeSamplerStateAvs");
1108 return 0;
1109 }
1110 }
1111
SetPowerOptionStatus(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer)1112 MOS_STATUS XRenderHal_Platform_Interface_Next::SetPowerOptionStatus(
1113 PRENDERHAL_INTERFACE pRenderHal,
1114 PMOS_COMMAND_BUFFER pCmdBuffer)
1115 {
1116 PMOS_INTERFACE pOsInterface;
1117 MOS_STATUS eStatus;
1118 MEDIA_SYSTEM_INFO *pGtSystemInfo;
1119
1120 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
1121 MHW_RENDERHAL_CHK_NULL_RETURN(pCmdBuffer);
1122 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface);
1123
1124 eStatus = MOS_STATUS_SUCCESS;
1125 pOsInterface = pRenderHal->pOsInterface;
1126 pGtSystemInfo = pOsInterface->pfnGetGtSystemInfo(pOsInterface);
1127 MHW_RENDERHAL_CHK_NULL_RETURN(pGtSystemInfo);
1128
1129 // Check if Slice Shutdown can be enabled
1130 if (pRenderHal->bRequestSingleSlice)
1131 {
1132 pCmdBuffer->Attributes.dwNumRequestedEUSlices = 1;
1133 }
1134 else if (pRenderHal->bEUSaturationNoSSD)
1135 {
1136 pCmdBuffer->Attributes.dwNumRequestedEUSlices = 2;
1137 }
1138
1139 if ((pRenderHal->pSkuTable) && (MEDIA_IS_SKU(pRenderHal->pSkuTable, FtrSSEUPowerGating) || MEDIA_IS_SKU(pRenderHal->pSkuTable, FtrSSEUPowerGatingControlByUMD)))
1140 {
1141 // VP does not request subslice shutdown according to the array VpHalDefaultSSEUTableGxx
1142 if (((pRenderHal->PowerOption.nSlice != 0) || (pRenderHal->PowerOption.nSubSlice != 0) || (pRenderHal->PowerOption.nEU != 0)) &&
1143 ((pGtSystemInfo->SliceCount != 0) && (pGtSystemInfo->SubSliceCount != 0)))
1144 {
1145 pCmdBuffer->Attributes.dwNumRequestedEUSlices = MOS_MIN(pRenderHal->PowerOption.nSlice, pGtSystemInfo->SliceCount);
1146 pCmdBuffer->Attributes.dwNumRequestedSubSlices = MOS_MIN(pRenderHal->PowerOption.nSubSlice, (pGtSystemInfo->SubSliceCount / pGtSystemInfo->SliceCount));
1147 pCmdBuffer->Attributes.dwNumRequestedEUs = MOS_MIN(pRenderHal->PowerOption.nEU, (pGtSystemInfo->EUCount / pGtSystemInfo->SubSliceCount));
1148 pCmdBuffer->Attributes.bValidPowerGatingRequest = true;
1149 pCmdBuffer->Attributes.bUmdSSEUEnable = true;
1150 }
1151 }
1152
1153 return eStatus;
1154 }
1155
SetCompositePrologCmd(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer)1156 MOS_STATUS XRenderHal_Platform_Interface_Next::SetCompositePrologCmd(
1157 PRENDERHAL_INTERFACE pRenderHal,
1158 PMOS_COMMAND_BUFFER pCmdBuffer)
1159 {
1160 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1161 uint64_t auxTableBaseAddr = 0;
1162
1163 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
1164 MHW_RENDERHAL_CHK_NULL_RETURN(pCmdBuffer);
1165 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface);
1166 MHW_RENDERHAL_CHK_NULL_RETURN(m_miItf);
1167
1168 auxTableBaseAddr = pRenderHal->pOsInterface->pfnGetAuxTableBaseAddr(pRenderHal->pOsInterface);
1169
1170 if (auxTableBaseAddr)
1171 {
1172 auto& parImm = m_miItf->MHW_GETPAR_F(MI_LOAD_REGISTER_IMM)();
1173 parImm = {};
1174 parImm.dwRegister = m_miItf->GetMmioInterfaces(mhw::mi::MHW_MMIO_RCS_AUX_TABLE_BASE_LOW);
1175 parImm.dwData = (auxTableBaseAddr & 0xffffffff);
1176 MHW_MI_CHK_STATUS(m_miItf->MHW_ADDCMD_F(MI_LOAD_REGISTER_IMM)(pCmdBuffer));
1177
1178 parImm.dwRegister = m_miItf->GetMmioInterfaces(mhw::mi::MHW_MMIO_RCS_AUX_TABLE_BASE_HIGH);
1179 parImm.dwData = ((auxTableBaseAddr >> 32) & 0xffffffff);
1180 MHW_MI_CHK_STATUS(m_miItf->MHW_ADDCMD_F(MI_LOAD_REGISTER_IMM)(pCmdBuffer));
1181
1182 parImm.dwRegister = m_miItf->GetMmioInterfaces(mhw::mi::MHW_MMIO_CCS0_AUX_TABLE_BASE_LOW);
1183 parImm.dwData = (auxTableBaseAddr & 0xffffffff);
1184 MHW_MI_CHK_STATUS(m_miItf->MHW_ADDCMD_F(MI_LOAD_REGISTER_IMM)(pCmdBuffer));
1185
1186 parImm.dwRegister = m_miItf->GetMmioInterfaces(mhw::mi::MHW_MMIO_CCS0_AUX_TABLE_BASE_HIGH);
1187 parImm.dwData = ((auxTableBaseAddr >> 32) & 0xffffffff);
1188 MHW_MI_CHK_STATUS(m_miItf->MHW_ADDCMD_F(MI_LOAD_REGISTER_IMM)(pCmdBuffer));
1189 }
1190
1191 return eStatus;
1192 }
1193
SendComputeWalker(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer,PMHW_GPGPU_WALKER_PARAMS pGpGpuWalkerParams)1194 MOS_STATUS XRenderHal_Platform_Interface_Next::SendComputeWalker(
1195 PRENDERHAL_INTERFACE pRenderHal,
1196 PMOS_COMMAND_BUFFER pCmdBuffer,
1197 PMHW_GPGPU_WALKER_PARAMS pGpGpuWalkerParams)
1198 {
1199 VP_FUNC_CALL();
1200
1201 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1202 MHW_ID_ENTRY_PARAMS mhwIdEntryParams;
1203 PRENDERHAL_KRN_ALLOCATION pKernelEntry;
1204 PRENDERHAL_MEDIA_STATE pCurMediaState;
1205
1206 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
1207 MHW_RENDERHAL_CHK_NULL_RETURN(pCmdBuffer);
1208 MHW_RENDERHAL_CHK_NULL_RETURN(pGpGpuWalkerParams);
1209 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap);
1210 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap->pKernelAllocation);
1211
1212 MOS_ZeroMemory(&mhwIdEntryParams, sizeof(mhwIdEntryParams));
1213
1214 pKernelEntry = &pRenderHal->pStateHeap->pKernelAllocation[pRenderHal->iKernelAllocationID];
1215 pCurMediaState = pRenderHal->pStateHeap->pCurMediaState;
1216
1217 MHW_RENDERHAL_CHK_NULL_RETURN(pKernelEntry);
1218 MHW_RENDERHAL_CHK_NULL_RETURN(pCurMediaState);
1219
1220 mhwIdEntryParams.dwKernelOffset = pKernelEntry->dwOffset;
1221 mhwIdEntryParams.dwSamplerCount = pKernelEntry->Params.Sampler_Count;
1222 mhwIdEntryParams.dwSamplerOffset = pCurMediaState->dwOffset +
1223 pRenderHal->pStateHeap->dwOffsetSampler +
1224 pGpGpuWalkerParams->InterfaceDescriptorOffset * pRenderHal->pStateHeap->dwSizeSamplers;
1225 mhwIdEntryParams.dwBindingTableOffset = pGpGpuWalkerParams->BindingTableID * pRenderHal->pStateHeap->iBindingTableSize;
1226 mhwIdEntryParams.dwSharedLocalMemorySize = m_renderHal->pfnEncodeSLMSize(m_renderHal, pGpGpuWalkerParams->SLMSize);
1227 if (pGpGpuWalkerParams->isGenerateLocalID && pGpGpuWalkerParams->emitLocal != MHW_EMIT_LOCAL_NONE)
1228 {
1229 //When COMPUTE_WALKER Emit Local ID is enabled, thread group number need to divide MHW_RENDER_ENGINE_NUMBER_OF_THREAD_UNIT
1230 mhwIdEntryParams.dwNumberofThreadsInGPGPUGroup = pGpGpuWalkerParams->ThreadWidth * pGpGpuWalkerParams->ThreadHeight / MHW_RENDER_ENGINE_NUMBER_OF_THREAD_UNIT;
1231 if (mhwIdEntryParams.dwNumberofThreadsInGPGPUGroup > MHW_RENDER_ENGINE_MAX_NUMBER_OF_THREAD)
1232 {
1233 MHW_RENDERHAL_ASSERTMESSAGE("Number of Threads In GpGpuGroup %d Exceeds the Max Number %d", mhwIdEntryParams.dwNumberofThreadsInGPGPUGroup, MHW_RENDER_ENGINE_MAX_NUMBER_OF_THREAD);
1234 MHW_RENDERHAL_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
1235 }
1236 }
1237 else
1238 {
1239 mhwIdEntryParams.dwNumberofThreadsInGPGPUGroup = pGpGpuWalkerParams->ThreadWidth * pGpGpuWalkerParams->ThreadHeight;
1240 }
1241 mhwIdEntryParams.preferredSlmAllocationSize = CalculatePreferredSlmAllocationSizeFromSlmSize(m_renderHal, pGpGpuWalkerParams->SLMSize, mhwIdEntryParams.dwNumberofThreadsInGPGPUGroup);
1242 //This only a WA to disable EU fusion for multi-layer blending cases or single layer do colorfill and rotation together.
1243 //Need remove it after kernel or compiler fix it.
1244 mhwIdEntryParams.bBarrierEnable = pRenderHal->eufusionBypass ? 1 : 0;
1245 mhwIdEntryParams.bBarrierEnable |= pGpGpuWalkerParams->hasBarrier;
1246 pGpGpuWalkerParams->IndirectDataStartAddress = pGpGpuWalkerParams->IndirectDataStartAddress + pRenderHal->pStateHeap->pCurMediaState->dwOffset;
1247
1248 MHW_RENDERHAL_CHK_NULL_RETURN(m_renderItf);
1249 m_gpgpuWalkerParams = pGpGpuWalkerParams;
1250 m_interfaceDescriptorParams = &mhwIdEntryParams;
1251 SETPAR_AND_ADDCMD(COMPUTE_WALKER, m_renderItf, pCmdBuffer);
1252
1253 return eStatus;
1254 }
1255
SendTo3DStateBindingTablePoolAlloc(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer)1256 MOS_STATUS XRenderHal_Platform_Interface_Next::SendTo3DStateBindingTablePoolAlloc(
1257 PRENDERHAL_INTERFACE pRenderHal,
1258 PMOS_COMMAND_BUFFER pCmdBuffer)
1259 {
1260 VP_FUNC_CALL();
1261
1262 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1263 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
1264 MHW_RENDERHAL_CHK_NULL_RETURN(pCmdBuffer);
1265 MHW_RENDERHAL_CHK_NULL_RETURN(m_renderItf);
1266 SETPAR_AND_ADDCMD(_3DSTATE_BINDING_TABLE_POOL_ALLOC, m_renderItf, pCmdBuffer);
1267
1268 return eStatus;
1269 }
1270
IsRenderHalMMCEnabled(PRENDERHAL_INTERFACE pRenderHal)1271 MOS_STATUS XRenderHal_Platform_Interface_Next::IsRenderHalMMCEnabled(
1272 PRENDERHAL_INTERFACE pRenderHal)
1273 {
1274 VP_FUNC_CALL();
1275
1276 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1277 bool isMMCEnabled = false;
1278
1279 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
1280
1281
1282 #if defined(LINUX) && (!defined(WDDM_LINUX))
1283 isMMCEnabled = !MEDIA_IS_WA(pRenderHal->pWaTable, WaDisableVPMmc) || !MEDIA_IS_WA(pRenderHal->pWaTable, WaDisableCodecMmc);
1284 #else
1285 isMMCEnabled = true; // turn on MMC
1286 #endif
1287
1288 #if (_DEBUG || _RELEASE_INTERNAL)
1289 // Read reg key to set MMC for Fast Composition surfaces
1290 if (pRenderHal->userSettingPtr != nullptr)
1291 {
1292 ReadUserSettingForDebug(
1293 pRenderHal->userSettingPtr,
1294 isMMCEnabled,
1295 __MEDIA_USER_FEATURE_ENABLE_RENDER_ENGINE_MMC,
1296 MediaUserSetting::Group::Device,
1297 isMMCEnabled,
1298 true);
1299 }
1300 #endif
1301 m_renderHalMMCEnabled = isMMCEnabled && MEDIA_IS_SKU(pRenderHal->pSkuTable, FtrE2ECompression);
1302 pRenderHal->isMMCEnabled = m_renderHalMMCEnabled;
1303
1304 return eStatus;
1305 }
1306
IsOvrdNeeded(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer,PRENDERHAL_GENERIC_PROLOG_PARAMS pGenericPrologParams)1307 MOS_STATUS XRenderHal_Platform_Interface_Next::IsOvrdNeeded(
1308 PRENDERHAL_INTERFACE pRenderHal,
1309 PMOS_COMMAND_BUFFER pCmdBuffer,
1310 PRENDERHAL_GENERIC_PROLOG_PARAMS pGenericPrologParams)
1311 {
1312 PMOS_INTERFACE pOsInterface;
1313 MOS_STATUS eStatus;
1314 PMOS_CMD_BUF_ATTRI_VE pAttriVe;
1315 PRENDERHAL_GENERIC_PROLOG_PARAMS_NEXT pGenericPrologParamsNext;
1316 uint8_t i;
1317
1318 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
1319 MHW_RENDERHAL_CHK_NULL_RETURN(pCmdBuffer);
1320 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface);
1321 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pRenderHalPltInterface);
1322
1323 eStatus = MOS_STATUS_SUCCESS;
1324 pOsInterface = pRenderHal->pOsInterface;
1325 pAttriVe = (PMOS_CMD_BUF_ATTRI_VE)(pCmdBuffer->Attributes.pAttriVe);
1326 pGenericPrologParamsNext = dynamic_cast<PRENDERHAL_GENERIC_PROLOG_PARAMS_NEXT>(pGenericPrologParams);
1327
1328 // Split Frame
1329 if (pOsInterface->VEEnable)
1330 {
1331 #if !EMUL
1332 if (pGenericPrologParamsNext)
1333 #else
1334 if (pGenericPrologParamsNext && pAttriVe != nullptr)
1335 #endif
1336 {
1337 // Split Frame
1338 if (pGenericPrologParamsNext->VEngineHintParams.BatchBufferCount > 1)
1339 {
1340 pAttriVe->bUseVirtualEngineHint = true;
1341 pAttriVe->VEngineHintParams = pGenericPrologParamsNext->VEngineHintParams;
1342 }
1343 }
1344
1345 #if (_DEBUG || _RELEASE_INTERNAL)
1346 #if !EMUL
1347 if (pOsInterface->bEnableDbgOvrdInVE)
1348 #else
1349 if (pOsInterface->bEnableDbgOvrdInVE && pAttriVe != nullptr)
1350 #endif
1351 {
1352 if (pOsInterface->bVeboxScalabilityMode)
1353 {
1354 pAttriVe->VEngineHintParams.DebugOverride = true;
1355 #if !EMUL
1356 if (pGenericPrologParamsNext)
1357 #else
1358 if (pGenericPrologParamsNext && pAttriVe != nullptr)
1359 #endif
1360 {
1361 pAttriVe->VEngineHintParams.BatchBufferCount = pGenericPrologParamsNext->VEngineHintParams.BatchBufferCount;
1362 for (i = 0; i < pGenericPrologParamsNext->VEngineHintParams.BatchBufferCount; i++)
1363 {
1364 pAttriVe->VEngineHintParams.EngineInstance[i] = i;
1365 }
1366 }
1367 }
1368 else if (pOsInterface->eForceVebox)
1369 {
1370 pAttriVe->VEngineHintParams.DebugOverride = true;
1371 pAttriVe->VEngineHintParams.BatchBufferCount = 1;
1372 pAttriVe->VEngineHintParams.EngineInstance[0] = pOsInterface->eForceVebox - 1;
1373 }
1374 }
1375 #endif
1376 }
1377
1378 return eStatus;
1379 }
1380
AllocateScratchSpaceBuffer(uint32_t perThreadScratchSpace,RENDERHAL_INTERFACE * renderHal)1381 MOS_STATUS XRenderHal_Platform_Interface_Next::AllocateScratchSpaceBuffer(
1382 uint32_t perThreadScratchSpace,
1383 RENDERHAL_INTERFACE *renderHal)
1384 {
1385 VP_FUNC_CALL();
1386
1387 if (m_scratchSpaceResource.iSize > 0)
1388 { // Already allocated.
1389 return MOS_STATUS_SUCCESS;
1390 }
1391
1392 const MEDIA_SYSTEM_INFO *gt_sys_info = renderHal->pOsInterface
1393 ->pfnGetGtSystemInfo(renderHal->pOsInterface);
1394 uint32_t hw_threads_per_eu = gt_sys_info->ThreadCount / gt_sys_info->EUCount;
1395 uint32_t scratch_space_entries = gt_sys_info->MaxEuPerSubSlice * hw_threads_per_eu * gt_sys_info->MaxSubSlicesSupported;
1396 uint32_t scratch_space_size = scratch_space_entries * perThreadScratchSpace;
1397
1398 MOS_ALLOC_GFXRES_PARAMS alloc_param;
1399 MOS_ZeroMemory(&alloc_param, sizeof(alloc_param));
1400 alloc_param.Type = MOS_GFXRES_SCRATCH;
1401 alloc_param.Format = Format_Buffer;
1402 alloc_param.dwBytes = scratch_space_size;
1403 alloc_param.pSystemMemory = nullptr;
1404 alloc_param.TileType = MOS_TILE_LINEAR;
1405 alloc_param.pBufName = "ScratchSpaceBuffer";
1406
1407 return renderHal->pOsInterface->pfnAllocateResource(
1408 renderHal->pOsInterface, &alloc_param, &m_scratchSpaceResource);
1409 }
1410
FreeScratchSpaceBuffer(RENDERHAL_INTERFACE * renderHal)1411 MOS_STATUS XRenderHal_Platform_Interface_Next::FreeScratchSpaceBuffer(
1412 RENDERHAL_INTERFACE *renderHal)
1413 {
1414 MOS_GFXRES_FREE_FLAGS resFreeFlags = {0};
1415
1416 resFreeFlags.AssumeNotInUse = 1;
1417
1418 if (m_scratchSpaceResource.iSize <= 0)
1419 {
1420 return MOS_STATUS_SUCCESS; // Scratch space is not allocated. No need to free resources.
1421 }
1422
1423 renderHal->pOsInterface
1424 ->pfnFreeResourceWithFlag(renderHal->pOsInterface,
1425 &m_scratchSpaceResource,
1426 resFreeFlags.Value);
1427 renderHal->pOsInterface
1428 ->pfnResetResourceAllocationIndex(renderHal->pOsInterface,
1429 &m_scratchSpaceResource);
1430 return MOS_STATUS_SUCCESS;
1431 }
1432
IsFormatMMCSupported(MOS_FORMAT format)1433 bool XRenderHal_Platform_Interface_Next::IsFormatMMCSupported(MOS_FORMAT format)
1434 {
1435 // Check if Sample Format is supported
1436 if ((format != Format_YUY2) &&
1437 (format != Format_Y410) &&
1438 (format != Format_Y216) &&
1439 (format != Format_Y210) &&
1440 (format != Format_Y416) &&
1441 (format != Format_P010) &&
1442 (format != Format_P016) &&
1443 (format != Format_AYUV) &&
1444 (format != Format_NV21) &&
1445 (format != Format_NV12) &&
1446 (format != Format_UYVY) &&
1447 (format != Format_YUYV) &&
1448 (format != Format_A8B8G8R8) &&
1449 (format != Format_X8B8G8R8) &&
1450 (format != Format_A8R8G8B8) &&
1451 (format != Format_X8R8G8B8) &&
1452 (format != Format_B10G10R10A2) &&
1453 (format != Format_R10G10B10A2) &&
1454 (format != Format_A16R16G16B16F) &&
1455 (format != Format_A16B16G16R16F) &&
1456 (format != Format_IMC3) &&
1457 (format != Format_444P) &&
1458 (format != Format_422H) &&
1459 (format != Format_422V) &&
1460 (format != Format_411P) &&
1461 (format != Format_411R) &&
1462 (format != Format_444P) &&
1463 (format != Format_RGBP) &&
1464 (format != Format_BGRP) &&
1465 (format != Format_400P) &&
1466 (format != Format_420O) &&
1467 (format != Format_R8UN) &&
1468 (format != Format_A8) &&
1469 (format != Format_R8G8UN))
1470 {
1471 MHW_RENDERHAL_NORMALMESSAGE("Unsupported Format '0x%08x' for Render MMC.", format);
1472 return false;
1473 }
1474
1475 return true;
1476 }
1477
IsL8FormatSupported()1478 bool XRenderHal_Platform_Interface_Next::IsL8FormatSupported()
1479 {
1480 return true;
1481 }
1482
GetMhwMiItf()1483 std::shared_ptr<mhw::mi::Itf> XRenderHal_Platform_Interface_Next::GetMhwMiItf()
1484 {
1485 return m_miItf;
1486 }
1487
MHW_SETPAR_DECL_SRC(STATE_BASE_ADDRESS,XRenderHal_Platform_Interface_Next)1488 MHW_SETPAR_DECL_SRC(STATE_BASE_ADDRESS, XRenderHal_Platform_Interface_Next)
1489 {
1490 MHW_STATE_BASE_ADDR_PARAMS* pStateBaseParams = nullptr;
1491 MHW_RENDERHAL_CHK_NULL_RETURN(m_renderHal);
1492 pStateBaseParams = &m_renderHal->StateBaseAddressParams;
1493 MHW_RENDERHAL_CHK_NULL_RETURN(pStateBaseParams);
1494
1495 params.presGeneralState = pStateBaseParams->presGeneralState;
1496 params.dwGeneralStateSize = pStateBaseParams->dwGeneralStateSize;
1497 params.presDynamicState = pStateBaseParams->presDynamicState;
1498 params.dwDynamicStateSize = pStateBaseParams->dwDynamicStateSize;
1499 params.bDynamicStateRenderTarget = pStateBaseParams->bDynamicStateRenderTarget;
1500 params.presIndirectObjectBuffer = pStateBaseParams->presIndirectObjectBuffer;
1501 params.dwIndirectObjectBufferSize = pStateBaseParams->dwIndirectObjectBufferSize;
1502 params.presInstructionBuffer = pStateBaseParams->presInstructionBuffer;
1503 params.dwInstructionBufferSize = pStateBaseParams->dwInstructionBufferSize;
1504 params.mocs4InstructionCache = pStateBaseParams->mocs4InstructionCache;
1505 params.mocs4GeneralState = pStateBaseParams->mocs4GeneralState;
1506 params.mocs4DynamicState = pStateBaseParams->mocs4DynamicState;
1507 params.mocs4SurfaceState = pStateBaseParams->mocs4SurfaceState;
1508 params.mocs4IndirectObjectBuffer = pStateBaseParams->mocs4IndirectObjectBuffer;
1509 params.mocs4StatelessDataport = pStateBaseParams->mocs4StatelessDataport;
1510 params.addressDis = m_renderHal->isBindlessHeapInUse;
1511
1512 return MOS_STATUS_SUCCESS;
1513 }
1514
MHW_SETPAR_DECL_SRC(_3DSTATE_CHROMA_KEY,XRenderHal_Platform_Interface_Next)1515 MHW_SETPAR_DECL_SRC(_3DSTATE_CHROMA_KEY, XRenderHal_Platform_Interface_Next)
1516 {
1517 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1518 PMHW_CHROMAKEY_PARAMS pChromaKeyParams = nullptr;
1519 MHW_RENDERHAL_CHK_NULL_RETURN(m_renderHal);
1520 pChromaKeyParams = m_renderHal->ChromaKey;
1521 MHW_RENDERHAL_CHK_NULL_RETURN(pChromaKeyParams);
1522
1523 params.dwIndex = pChromaKeyParams->dwIndex;
1524 params.dwLow = pChromaKeyParams->dwLow;
1525 params.dwHigh = pChromaKeyParams->dwHigh;
1526
1527 return MOS_STATUS_SUCCESS;
1528 }
1529
MHW_SETPAR_DECL_SRC(STATE_SIP,XRenderHal_Platform_Interface_Next)1530 MHW_SETPAR_DECL_SRC(STATE_SIP, XRenderHal_Platform_Interface_Next)
1531 {
1532 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1533 MHW_SIP_STATE_PARAMS SipStateParams = {};
1534 MHW_RENDERHAL_CHK_NULL_RETURN(m_renderHal);
1535 SipStateParams = m_renderHal->SipStateParams;
1536
1537 params.dwSipBase = SipStateParams.dwSipBase;
1538
1539 return MOS_STATUS_SUCCESS;
1540 }
1541
MHW_SETPAR_DECL_SRC(COMPUTE_WALKER,XRenderHal_Platform_Interface_Next)1542 MHW_SETPAR_DECL_SRC(COMPUTE_WALKER, XRenderHal_Platform_Interface_Next)
1543 {
1544 MHW_RENDERHAL_CHK_NULL_RETURN(m_gpgpuWalkerParams);
1545 MHW_RENDERHAL_CHK_NULL_RETURN(m_interfaceDescriptorParams);
1546
1547 params.IndirectDataLength = m_gpgpuWalkerParams->IndirectDataLength;
1548 params.IndirectDataStartAddress = m_gpgpuWalkerParams->IndirectDataStartAddress;
1549 params.ThreadWidth = m_gpgpuWalkerParams->ThreadWidth;
1550 params.ThreadHeight = m_gpgpuWalkerParams->ThreadHeight;
1551 params.ThreadDepth = m_gpgpuWalkerParams->ThreadDepth;
1552
1553 params.GroupWidth = m_gpgpuWalkerParams->GroupWidth;
1554 params.GroupHeight = m_gpgpuWalkerParams->GroupHeight;
1555 params.GroupDepth = m_gpgpuWalkerParams->GroupDepth;
1556 params.GroupStartingX = m_gpgpuWalkerParams->GroupStartingX;
1557 params.GroupStartingY = m_gpgpuWalkerParams->GroupStartingY;
1558 params.GroupStartingZ = m_gpgpuWalkerParams->GroupStartingZ;
1559
1560 params.dwKernelOffset = m_interfaceDescriptorParams->dwKernelOffset;
1561 params.dwSamplerCount = m_interfaceDescriptorParams->dwSamplerCount;
1562 params.dwSamplerOffset = m_interfaceDescriptorParams->dwSamplerOffset;
1563 params.dwBindingTableOffset = m_interfaceDescriptorParams->dwBindingTableOffset;
1564 params.bBarrierEnable = m_interfaceDescriptorParams->bBarrierEnable;
1565 params.dwNumberofThreadsInGPGPUGroup = m_interfaceDescriptorParams->dwNumberofThreadsInGPGPUGroup;
1566 params.dwSharedLocalMemorySize = m_interfaceDescriptorParams->dwSharedLocalMemorySize;
1567 params.preferredSlmAllocationSize = m_interfaceDescriptorParams->preferredSlmAllocationSize;
1568 params.IndirectDataStartAddress = m_gpgpuWalkerParams->IndirectDataStartAddress;
1569 params.forcePreferredSLMZero = m_gpgpuWalkerParams->ForcePreferredSLMZero;
1570
1571 if (m_gpgpuWalkerParams->ThreadDepth == 0)
1572 {
1573 params.ThreadDepth = 1;
1574 }
1575 if (m_gpgpuWalkerParams->GroupDepth == 0)
1576 {
1577 params.GroupDepth = 1;
1578 }
1579
1580 params.isEmitInlineParameter = m_gpgpuWalkerParams->isEmitInlineParameter;
1581 if (m_gpgpuWalkerParams->inlineDataLength > 0 && m_gpgpuWalkerParams->inlineData)
1582 {
1583 params.inlineDataLength = m_gpgpuWalkerParams->inlineDataLength;
1584 params.inlineData = m_gpgpuWalkerParams->inlineData;
1585 }
1586
1587 params.isGenerateLocalId = m_gpgpuWalkerParams->isGenerateLocalID;
1588 params.emitLocal = mhw::render::MHW_EMIT_LOCAL_MODE(m_gpgpuWalkerParams->emitLocal);
1589
1590 return MOS_STATUS_SUCCESS;
1591 }
1592
MHW_SETPAR_DECL_SRC(_3DSTATE_BINDING_TABLE_POOL_ALLOC,XRenderHal_Platform_Interface_Next)1593 MHW_SETPAR_DECL_SRC(_3DSTATE_BINDING_TABLE_POOL_ALLOC, XRenderHal_Platform_Interface_Next)
1594 {
1595 MHW_STATE_BASE_ADDR_PARAMS *pStateBaseParams = nullptr;
1596 MHW_RENDERHAL_CHK_NULL_RETURN(m_renderHal);
1597 pStateBaseParams = &m_renderHal->StateBaseAddressParams;
1598 MHW_RENDERHAL_CHK_NULL_RETURN(pStateBaseParams);
1599 params.mocs4SurfaceState = pStateBaseParams->mocs4SurfaceState;
1600
1601 return MOS_STATUS_SUCCESS;
1602 }