Debian Codegraph @

media_softlet/agnostic/common/hw/mhw_utilities_next.cpp

raw
1 /*
2 * Copyright (c) 2014-2022, Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included
12 * in all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 */
22 //!
23 //! \file mhw_utilities.c
24 //! \brief This modules implements utilities which are shared by both the HW interface and the state heap interface.
25 //!
26
27 #include <math.h>
28 #include <set>
29 #include "mhw_utilities_next.h"
30 #include "mhw_state_heap.h"
31 #include "mos_interface.h"
32 #include "hal_oca_interface_next.h"
33 #include "media_skuwa_specific.h"
34 #include "mhw_itf.h"
35 #include "mhw_mi.h"
36 #include "mhw_mi_cmdpar.h"
37 #include "mhw_mi_itf.h"
38
39 #define MHW_NS_PER_TICK_RENDER_ENGINE 80 // 80 nano seconds per tick in render engine
40
41 static const std::set<MOS_HW_COMMAND> s_OCAResourceInfoType = {
42 MOS_MI_BATCH_BUFFER_START,
43 MOS_VEBOX_STATE,
44 MOS_VEBOX_DI_IECP,
45 MOS_VEBOX_TILING_CONVERT,
46 MOS_SFC_STATE,
47 MOS_STATE_BASE_ADDR,
48 MOS_SURFACE_STATE,
49 MOS_SURFACE_STATE_ADV,
50 MOS_MFX_PIPE_BUF_ADDR,
51 MOS_MFX_INDIRECT_OBJ_BASE_ADDR,
52 MOS_MFX_BSP_BUF_BASE_ADDR,
53 MOS_MFX_AVC_DIRECT_MODE,
54 MOS_MFX_VP8_PIC,
55 MOS_HUC_IND_OBJ_BASE_ADDR,
56 MOS_HUC_DMEM,
57 MOS_HUC_VIRTUAL_ADDR,
58 MOS_VDENC_PIPE_BUF_ADDR,
59 MOS_BINDLESS_STATELESS_SURFACE,
60 };
61
62 //!
63 //! \brief Set mocs index
64 //! \details Set mocs index
65 //! command buffer or indirect state
66 //! \param PMOS_INTERFACE osInterface
67 //! [in] OS interface
68 //! \param PMOS_RESOURCE resource
69 //! [in] resource
70 //! \param MHW_MOCS_PARAMS &mocsParams
71 //! [in] mocsParams
72 //! \return MOS_STATUS
73 //! MOS_STATUS_SUCCESS if success, else fail reason
74 //!
75 MOS_STATUS Mhw_SetMocsTableIndex(
76 PMOS_INTERFACE osInterface,
77 PMOS_RESOURCE resource,
78 MHW_MOCS_PARAMS &mocsParams)
79 {
80 MHW_CHK_NULL_RETURN(resource);
81 MHW_CHK_NULL_RETURN(osInterface);
82
83 // Index is defined in bit 1:6
84 const uint8_t indexBitFieldLow = 1;
85 const uint8_t indexMask = 0x3F;
86 uint32_t memObjCtrlStateValue = 0;
87
88 uint32_t *data = mocsParams.mocsTableIndex;
89 uint32_t value = 0;
90 uint32_t mask = 0;
91 uint8_t bitFieldLow = mocsParams.bitFieldLow;
92 uint8_t bitFieldHigh = mocsParams.bitFieldHigh;
93
94 if (data == nullptr)
95 {
96 MHW_NORMALMESSAGE("skip to set the mocs");
97 return MOS_STATUS_SUCCESS;
98 }
99
100 if (bitFieldLow > bitFieldHigh || bitFieldHigh > 31)
101 {
102 MOS_OS_ASSERTMESSAGE("invalid bit field");
103 return MOS_STATUS_INVALID_PARAMETER;
104 }
105
106 value = *data;
107
108 auto memObjCtrlState = osInterface->pfnGetResourceCachePolicyMemoryObject(osInterface, resource);
109 memObjCtrlStateValue = (memObjCtrlState.DwordValue >> indexBitFieldLow) & indexMask;
110
111 if (bitFieldHigh == 31)
112 {
113 mask = (1 << bitFieldLow) - 1;
114 }
115 else
116 {
117 mask = (~((1 << (bitFieldHigh + 1)) - 1)) | ((1 << bitFieldLow) - 1);
118 }
119 value = value & mask;
120 *data = value | (memObjCtrlStateValue << bitFieldLow);
121
122 return MOS_STATUS_SUCCESS;
123 }
124
125 //!
126 //! \brief Adds graphics address of a resource to the command buffer or indirect state
127 //! \details Internal MHW function to add the graphics address of resources to the
128 //! command buffer or indirect state
129 //! \param PMOS_INTERFACE pOsInterface
130 //! [in] OS interface
131 //! \param PMOS_COMMAND_BUFFER pCmdBuffer
132 //! [in] Command buffer
133 //! \param PMHW_RESOURCE_PARAMS pParams
134 //! [in] Parameters necessary to insert the graphics address
135 //! \return MOS_STATUS
136 //! MOS_STATUS_SUCCESS if success, else fail reason
137 //!
138 MOS_STATUS Mhw_AddResourceToCmd_GfxAddress(
139 PMOS_INTERFACE pOsInterface,
140 PMOS_COMMAND_BUFFER pCmdBuffer,
141 PMHW_RESOURCE_PARAMS pParams)
142 {
143 uint32_t dwAlign, dwMask;
144 uint32_t dwGfxAddrBottom, dwGfxAddrTop = 0;
145 uint64_t ui64GfxAddress, ui64GfxAddressUpperBound;
146 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
147 int32_t iAllocationIndex = 0;
148 uint32_t uiPatchOffset = 0;
149 uint8_t *pbCmdBufBase = nullptr;
150
151 MHW_CHK_NULL_RETURN(pOsInterface);
152 MHW_CHK_NULL_RETURN(pParams);
153 MHW_CHK_NULL_RETURN(pParams->presResource);
154 MHW_CHK_NULL_RETURN(pCmdBuffer);
155 MHW_CHK_NULL_RETURN(pCmdBuffer->pCmdBase);
156
157 pbCmdBufBase = (uint8_t*)pCmdBuffer->pCmdBase;
158
159 MHW_CHK_STATUS_RETURN(pOsInterface->pfnRegisterResource(
160 pOsInterface,
161 pParams->presResource,
162 pParams->bIsWritable ? true : false,
163 pParams->bIsWritable ? true : false));
164
165 dwAlign = ( 1 << pParams->dwLsbNum);
166 dwMask = (-1 << pParams->dwLsbNum);
167
168 pParams->dwOffset = MOS_ALIGN_CEIL(pParams->dwOffset, dwAlign);
169 ui64GfxAddress =
170 pOsInterface->pfnGetResourceGfxAddress(pOsInterface, pParams->presResource) + pParams->dwOffset;
171 MHW_CHK_COND(ui64GfxAddress == 0, "Driver can't add resource with ui64GfxAddress == 0. DW location in cmd == %d.", pParams->dwLocationInCmd);
172
173 dwGfxAddrBottom = (uint32_t)(ui64GfxAddress & 0x00000000FFFFFFFF);
174 dwGfxAddrTop = (uint32_t)((ui64GfxAddress & 0xFFFFFFFF00000000) >> 32);
175
176 *pParams->pdwCmd = (*pParams->pdwCmd & ~dwMask) | (dwGfxAddrBottom & dwMask);
177 // this is next DW for top part of the address
178 *(pParams->pdwCmd + 1) = dwGfxAddrTop;
179
180 Mhw_SetMocsTableIndex(pOsInterface, pParams->presResource, pParams->mocsParams);
181
182 #if (_DEBUG || _RELEASE_INTERNAL)
183 {
184 uint32_t evtData[4] ={(uint32_t)pParams->HwCommandType, pParams->dwLocationInCmd, pParams->dwOffset, pParams->dwSize};
185 MOS_TraceEventExt(EVENT_RESOURCE_REGISTER, EVENT_TYPE_INFO2, evtData, sizeof(evtData), &ui64GfxAddress, sizeof(ui64GfxAddress));
186 }
187 #endif
188
189 if (pParams->dwOffsetInSSH > 0)
190 {
191 // Calculate the patch offset to command buffer
192 uiPatchOffset = pParams->dwOffsetInSSH + (pParams->dwLocationInCmd * sizeof(uint32_t));
193 }
194 else
195 {
196 // Calculate the patch offset to command buffer
197 uiPatchOffset = pCmdBuffer->iOffset + (pParams->dwLocationInCmd * sizeof(uint32_t));
198 }
199
200 MOS_PATCH_ENTRY_PARAMS PatchEntryParams;
201
202 iAllocationIndex = pOsInterface->pfnGetResourceAllocationIndex(pOsInterface, pParams->presResource);
203 MOS_ZeroMemory(&PatchEntryParams, sizeof(PatchEntryParams));
204 PatchEntryParams.uiAllocationIndex = iAllocationIndex;
205 PatchEntryParams.uiResourceOffset = pParams->dwOffset;
206 PatchEntryParams.uiPatchOffset = uiPatchOffset;
207 PatchEntryParams.bWrite = pParams->bIsWritable;
208 PatchEntryParams.HwCommandType = pParams->HwCommandType;
209 PatchEntryParams.forceDwordOffset = pParams->dwSharedMocsOffset;
210 PatchEntryParams.cmdBufBase = pbCmdBufBase;
211 PatchEntryParams.presResource = pParams->presResource;
212 PatchEntryParams.cmdBuffer = pCmdBuffer;
213
214 // Add patch entry
215 MHW_CHK_STATUS_RETURN(pOsInterface->pfnSetPatchEntry(
216 pOsInterface,
217 &PatchEntryParams));
218
219 if (pParams->dwUpperBoundLocationOffsetFromCmd > 0)
220 {
221 pParams->dwSize = MOS_ALIGN_CEIL(pParams->dwSize, dwAlign);
222
223 ui64GfxAddressUpperBound = ui64GfxAddress + pParams->dwSize;
224 dwGfxAddrBottom = (uint32_t)(ui64GfxAddressUpperBound & 0x00000000FFFFFFFF);
225 dwGfxAddrTop = (uint32_t)((ui64GfxAddressUpperBound & 0xFFFFFFFF00000000) >> 32);
226
227 pParams->pdwCmd += pParams->dwUpperBoundLocationOffsetFromCmd;
228 *pParams->pdwCmd = (*pParams->pdwCmd & ~dwMask) | (dwGfxAddrBottom & dwMask);
229 // this is next DW for top part of the address
230 *(pParams->pdwCmd + 1) = dwGfxAddrTop;
231
232 MOS_PATCH_ENTRY_PARAMS PatchEntryParams;
233
234 // Calculate the patch offset to command buffer
235 uiPatchOffset += pParams->dwUpperBoundLocationOffsetFromCmd * sizeof(uint32_t);
236
237 MOS_ZeroMemory(&PatchEntryParams, sizeof(PatchEntryParams));
238 PatchEntryParams.uiAllocationIndex = iAllocationIndex;
239 PatchEntryParams.uiResourceOffset = pParams->dwOffset + pParams->dwSize;
240 PatchEntryParams.uiPatchOffset = uiPatchOffset;
241 PatchEntryParams.bUpperBoundPatch = true;
242 PatchEntryParams.presResource = pParams->presResource;
243
244 // Add patch entry (CP won't register this patch point since bUpperBoundPatch = true)
245 MHW_CHK_STATUS_RETURN(pOsInterface->pfnSetPatchEntry(
246 pOsInterface,
247 &PatchEntryParams));
248 }
249
250 if (s_OCAResourceInfoType.count(pParams->HwCommandType))
251 {
252 HalOcaInterfaceNext::DumpResourceInfo(*pCmdBuffer, *pOsInterface, *pParams->presResource, pParams->HwCommandType,
253 pParams->dwLocationInCmd, pParams->dwOffset);
254 }
255
256 return eStatus;
257 }
258
259 //!
260 //! \brief Adds resources to a patch list
261 //! \details Internal MHW function to put resources to be added to the command
262 //! buffer or indirect state into a patch list for patch later
263 //! \param PMOS_INTERFACE pOsInterface
264 //! [in] OS interface
265 //! \param PMOS_COMMAND_BUFFER pCmdBuffer
266 //! [in] Command buffer
267 //! \param PMHW_RESOURCE_PARAMS pParams
268 //! [in] Parameters necessary to add the resource to the patch list
269 //! \return MOS_STATUS
270 //! MOS_STATUS_SUCCESS if success, else fail reason
271 //!
272 MOS_STATUS Mhw_AddResourceToCmd_PatchList(
273 PMOS_INTERFACE pOsInterface,
274 PMOS_COMMAND_BUFFER pCmdBuffer,
275 PMHW_RESOURCE_PARAMS pParams)
276 {
277 MOS_GPU_CONTEXT GpuContext;
278 int32_t iAllocationIndex;
279 uint32_t dwLsbNum, dwUpperBoundOffset;
280 uint32_t dwOffset;
281 uint32_t uiPatchOffset;
282 MOS_PATCH_ENTRY_PARAMS PatchEntryParams;
283 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
284
285 MHW_CHK_NULL_RETURN(pOsInterface);
286 MHW_CHK_NULL_RETURN(pParams);
287 MHW_CHK_NULL_RETURN(pParams->presResource);
288 MHW_CHK_NULL_RETURN(pCmdBuffer);
289
290 MOS_TraceEventExt(EVENT_RESOURCE_REGISTER, EVENT_TYPE_INFO2, &pParams->HwCommandType, sizeof(uint32_t), &pParams->dwLocationInCmd, sizeof(uint32_t));
291
292 MHW_CHK_STATUS_RETURN(pOsInterface->pfnRegisterResource(
293 pOsInterface,
294 pParams->presResource,
295 pParams->bIsWritable ? true : false,
296 pParams->bIsWritable ? true : false));
297
298 GpuContext = pOsInterface->pfnGetGpuContext(pOsInterface);
299 iAllocationIndex = pOsInterface->pfnGetResourceAllocationIndex(pOsInterface, pParams->presResource);
300 dwLsbNum = pParams->dwLsbNum;
301
302 // Offset and command LSB parameters
303 dwOffset = pParams->dwOffset | ((*pParams->pdwCmd) & ((1 << dwLsbNum) - 1));
304
305 Mhw_SetMocsTableIndex(pOsInterface, pParams->presResource, pParams->mocsParams);
306
307 if (pParams->dwOffsetInSSH > 0)
308 {
309 // Calculate the patch offset to command buffer
310 uiPatchOffset = pParams->dwOffsetInSSH + (pParams->dwLocationInCmd * sizeof(uint32_t));
311 }
312 else
313 {
314 // Calculate the patch offset to command buffer
315 uiPatchOffset = pCmdBuffer->iOffset + (pParams->dwLocationInCmd * sizeof(uint32_t));
316 }
317
318 MOS_ZeroMemory(&PatchEntryParams, sizeof(PatchEntryParams));
319 PatchEntryParams.uiAllocationIndex = iAllocationIndex;
320 if(pParams->patchType == MOS_PATCH_TYPE_UV_Y_OFFSET ||
321 pParams->patchType == MOS_PATCH_TYPE_PITCH ||
322 pParams->patchType == MOS_PATCH_TYPE_V_Y_OFFSET)
323 {
324 PatchEntryParams.uiResourceOffset = *pParams->pdwCmd;
325 }
326 else
327 {
328 PatchEntryParams.uiResourceOffset = dwOffset;
329 }
330 PatchEntryParams.uiPatchOffset = uiPatchOffset;
331 PatchEntryParams.bWrite = pParams->bIsWritable;
332 PatchEntryParams.HwCommandType = pParams->HwCommandType;
333 PatchEntryParams.forceDwordOffset = pParams->dwSharedMocsOffset;
334 PatchEntryParams.cmdBufBase = (uint8_t*)pCmdBuffer->pCmdBase;
335 PatchEntryParams.presResource = pParams->presResource;
336 PatchEntryParams.patchType = pParams->patchType;
337 PatchEntryParams.shiftAmount = pParams->shiftAmount;
338 PatchEntryParams.shiftDirection = pParams->shiftDirection;
339 PatchEntryParams.offsetInSSH = pParams->dwOffsetInSSH;
340 PatchEntryParams.cmdBuffer = pCmdBuffer;
341
342 // Add patch entry to patch the address field for this command
343 MHW_CHK_STATUS_RETURN(pOsInterface->pfnSetPatchEntry(
344 pOsInterface,
345 &PatchEntryParams));
346
347 if (pParams->dwUpperBoundLocationOffsetFromCmd > 0)
348 {
349 pParams->pdwCmd += pParams->dwUpperBoundLocationOffsetFromCmd;
350 dwUpperBoundOffset = pParams->dwUpperBoundLocationOffsetFromCmd;
351
352 // Offset and command LSB parameters
353 dwOffset = MOS_ALIGN_CEIL((pParams->dwOffset + pParams->dwSize), (1 << dwLsbNum));
354 dwOffset = dwOffset | ((*pParams->pdwCmd) & ((1 << dwLsbNum) - 1));
355
356 // Calculate the patch offset to command buffer
357 uiPatchOffset += dwUpperBoundOffset * sizeof(uint32_t);
358
359 MOS_ZeroMemory(&PatchEntryParams, sizeof(PatchEntryParams));
360 PatchEntryParams.uiAllocationIndex = iAllocationIndex;
361 PatchEntryParams.uiResourceOffset = dwOffset;
362 PatchEntryParams.uiPatchOffset = uiPatchOffset;
363 PatchEntryParams.bUpperBoundPatch = true;
364 PatchEntryParams.presResource = pParams->presResource;
365 PatchEntryParams.patchType = pParams->patchType;
366 PatchEntryParams.shiftAmount = pParams->shiftAmount;
367 PatchEntryParams.shiftDirection = pParams->shiftDirection;
368 PatchEntryParams.offsetInSSH = pParams->dwOffsetInSSH;
369 PatchEntryParams.cmdBuffer = pCmdBuffer;
370
371 if(dwLsbNum)
372 {
373 PatchEntryParams.shiftAmount = dwLsbNum;
374 PatchEntryParams.shiftDirection = 0;
375 }
376
377 // Add patch entry to patch the address field for this command
378 MHW_CHK_STATUS_RETURN(pOsInterface->pfnSetPatchEntry(
379 pOsInterface,
380 &PatchEntryParams));
381 }
382
383 if (s_OCAResourceInfoType.count(pParams->HwCommandType))
384 {
385 HalOcaInterfaceNext::DumpResourceInfo(*pCmdBuffer, *pOsInterface, *pParams->presResource, pParams->HwCommandType,
386 pParams->dwLocationInCmd, pParams->dwOffset);
387 }
388
389 return eStatus;
390 }
391
392 //!
393 //! \brief Derive Surface Type from Surface Format
394 //! \details Internal MHW function to dervie surface type from surface format
395 //! \param uint32_t dwForceSurfaceFormat
396 //! [in] surface format information
397 //! \param PMOS_SURFACE psSurface
398 //! [in] surface which have depth information
399 //! \param uint32_t* pdwSurfaceType
400 //! [out] Surface type
401 //! \return MOS_STATUS
402 //! MOS_STATUS_SUCCESS if success, else fail reason
403 //!
404 MOS_STATUS Mhw_SurfaceFormatToType(
405 uint32_t dwForceSurfaceFormat,
406 PMOS_SURFACE psSurface,
407 uint32_t *pdwSurfaceType)
408 {
409 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
410
411 MHW_FUNCTION_ENTER;
412
413 MHW_CHK_NULL_RETURN(psSurface);
414 MHW_CHK_NULL_RETURN(pdwSurfaceType);
415
416 switch ( dwForceSurfaceFormat )
417 {
418 // 1D Surface
419 case MHW_GFX3DSTATE_SURFACEFORMAT_RAW:
420 case MHW_GFX3DSTATE_SURFACEFORMAT_R32_UINT:
421 case MHW_GFX3DSTATE_SURFACEFORMAT_L8_UNORM:
422 *pdwSurfaceType = GFX3DSTATE_SURFACETYPE_BUFFER;
423 break;
424
425 // 2D Surface for Codec: GFX3DSTATE_SURFACEFORMAT_YCRCB_NORMAL, GFX3DSTATE_SURFACEFORMAT_YCRCB_SWAPY
426 // GFX3DSTATE_SURFACEFORMAT_R32_UNORM, GFX3DSTATE_SURFACEFORMAT_R16_UNORM, GFX3DSTATE_SURFACEFORMAT_R8_UNORM
427
428 // 2D & 3D Surface
429 default:
430 (psSurface->dwDepth > 1) ?
431 *pdwSurfaceType = GFX3DSTATE_SURFACETYPE_3D:
432 *pdwSurfaceType = GFX3DSTATE_SURFACETYPE_2D;
433 }
434
435 return eStatus;
436 }
437
438 //!
439 //! \brief Send native fence sync batch buffer start command
440 //! \details Emits MI_BATCH_BUFFER_START for the native fence sync batch buffer
441 //! if the GPU context supports sync-by-command. After emitting the
442 //! command, sets bNativeFenceSyncBBAdded flag on the command buffer
443 //! to prevent double emission in subsequent prolog functions.
444 //! This function MUST be called before any other commands
445 //! (MI_FORCE_WAKEUP, watchdog, cache flush) in the command buffer.
446 //! \param PMOS_COMMAND_BUFFER pCmdBuffer
447 //! [in] Command buffer
448 //! \param PMOS_INTERFACE pOsInterface
449 //! [in] OS interface
450 //! \param std::shared_ptr<void> pMiItf
451 //! [in] MI interface
452 //! \return MOS_STATUS
453 //! MOS_STATUS_SUCCESS if success, else fail reason
454 //!
455 MOS_STATUS Mhw_SendNativeFenceSyncBBStartCmd(
456 PMOS_COMMAND_BUFFER pCmdBuffer,
457 PMOS_INTERFACE pOsInterface,
458 std::shared_ptr<void> pMiItf)
459 {
460 MHW_FUNCTION_ENTER;
461
462 // Skip if not fully initialized
463 if (pCmdBuffer == nullptr || pOsInterface == nullptr)
464 {
465 return MOS_STATUS_SUCCESS;
466 }
467
468 // Early out if native fence sync is not applicable
469 if (pOsInterface->pfnIsGpuSyncByCmd == nullptr ||
470 !pOsInterface->pfnIsGpuSyncByCmd(pOsInterface, pOsInterface->CurrentGpuContextHandle) ||
471 pCmdBuffer->syncMhwBatchBuffer == nullptr ||
472 pCmdBuffer->bNativeFenceSyncBBAdded)
473 {
474 return MOS_STATUS_SUCCESS;
475 }
476
477 // Native fence sync is needed - validate MI interface
478 std::shared_ptr<mhw::mi::Itf> miItf = std::static_pointer_cast<mhw::mi::Itf>(pMiItf);
479 MHW_CHK_NULL_RETURN(miItf);
480
481 auto &miBatchBufferStartParams = miItf->MHW_GETPAR_F(MI_BATCH_BUFFER_START)();
482 uint64_t gfxAddr = pOsInterface->pfnGetResourceGfxAddress(pOsInterface, &pCmdBuffer->OsResource);
483 pOsInterface->pfnOnNativeFenceSyncBBAdded(pCmdBuffer, gfxAddr);
484 miBatchBufferStartParams = {};
485 MHW_CHK_STATUS_RETURN(miItf->MHW_ADDCMD_F(MI_BATCH_BUFFER_START)(pCmdBuffer, pCmdBuffer->syncMhwBatchBuffer));
486
487 pCmdBuffer->bNativeFenceSyncBBAdded = true;
488
489 return MOS_STATUS_SUCCESS;
490 }
491
492 //!
493 //! \brief Inserts the generic prologue command for a command buffer
494 //! \details Client facing function to add the generic prologue commands:
495 //! - the command buffer header (if necessary)
496 //! - flushes for the read/write caches (MI_FLUSH_DW or PIPE_CONTROL)
497 //! - CP prologue if necessary
498 //! \param PMOS_COMMAND_BUFFER pCmdBuffer
499 //! [in] Command buffer
500 //! \param PMHW_GENERIC_PROLOG_PARAMS pParams
501 //! [in] Parameters necessary to add the generic prologue commands
502 //! \return MOS_STATUS
503 //! MOS_STATUS_SUCCESS if success, else fail reason
504 //!
505 MOS_STATUS Mhw_SendGenericPrologCmdNext(
506 PMOS_COMMAND_BUFFER pCmdBuffer,
507 PMHW_GENERIC_PROLOG_PARAMS pParams,
508 std::shared_ptr<void> pMiItf,
509 MHW_MI_MMIOREGISTERS *pMmioReg)
510 {
511 PMOS_INTERFACE pOsInterface;
512 MEDIA_FEATURE_TABLE *pSkuTable;
513 MEDIA_WA_TABLE *pWaTable;
514 MOS_GPU_CONTEXT GpuContext;
515 MHW_PIPE_CONTROL_PARAMS PipeControlParams;
516 MHW_MI_FLUSH_DW_PARAMS FlushDwParams;
517 bool bRcsEngineUsed = false;
518 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
519 std::shared_ptr<mhw::mi::Itf> miItf = std::static_pointer_cast<mhw::mi::Itf>(pMiItf);
520 MHW_FUNCTION_ENTER;
521
522 MHW_CHK_NULL_RETURN(pCmdBuffer);
523 MHW_CHK_NULL_RETURN(pParams);
524 MHW_CHK_NULL_RETURN(pParams->pOsInterface);
525 MHW_CHK_NULL_RETURN(miItf);
526
527 pOsInterface = pParams->pOsInterface;
528
529 pSkuTable = pOsInterface->pfnGetSkuTable(pOsInterface);
530 MHW_CHK_NULL_RETURN(pSkuTable);
531 pWaTable = pOsInterface->pfnGetWaTable(pOsInterface);
532 MHW_CHK_NULL_RETURN(pWaTable);
533 GpuContext = pOsInterface->pfnGetGpuContext(pOsInterface);
534 MHW_CHK_STATUS_RETURN(Mhw_SendNativeFenceSyncBBStartCmd(pCmdBuffer, pOsInterface, pMiItf));
535
536 if ( pOsInterface->Component != COMPONENT_CM )
537 {
538 if ( GpuContext == MOS_GPU_CONTEXT_RENDER ||
539 GpuContext == MOS_GPU_CONTEXT_RENDER2 ||
540 GpuContext == MOS_GPU_CONTEXT_RENDER3 ||
541 GpuContext == MOS_GPU_CONTEXT_RENDER4 ||
542 GpuContext == MOS_GPU_CONTEXT_VIDEO ||
543 GpuContext == MOS_GPU_CONTEXT_VIDEO2 ||
544 GpuContext == MOS_GPU_CONTEXT_VIDEO3 ||
545 GpuContext == MOS_GPU_CONTEXT_VIDEO4 ||
546 GpuContext == MOS_GPU_CONTEXT_VDBOX2_VIDEO ||
547 GpuContext == MOS_GPU_CONTEXT_VDBOX2_VIDEO2 ||
548 GpuContext == MOS_GPU_CONTEXT_VDBOX2_VIDEO3 ||
549 GpuContext == MOS_GPU_CONTEXT_VEBOX ||
550 GpuContext == MOS_GPU_CONTEXT_VIDEO5 ||
551 GpuContext == MOS_GPU_CONTEXT_VIDEO6 ||
552 GpuContext == MOS_GPU_CONTEXT_VIDEO7 )
553 {
554 MHW_CHK_STATUS_RETURN(miItf->AddWatchdogTimerStartCmd(pCmdBuffer));
555 }
556 }
557
558 bRcsEngineUsed = MOS_RCS_ENGINE_USED(GpuContext);
559
560 if (bRcsEngineUsed)
561 {
562 auto& par = miItf->MHW_GETPAR_F(PIPE_CONTROL)();
563 par = {};
564 par.dwFlushMode = MHW_FLUSH_WRITE_CACHE;
565 MHW_CHK_STATUS_RETURN(miItf->MHW_ADDCMD_F(PIPE_CONTROL)(pCmdBuffer));
566
567 auto& par1 = miItf->MHW_GETPAR_F(PIPE_CONTROL)();
568 par1 = {};
569 par1.dwFlushMode = MHW_FLUSH_READ_CACHE;
570 par1.presDest = pParams->presStoreData;
571 par1.dwResourceOffset = pParams->dwStoreDataOffset;
572 par1.dwPostSyncOp = MHW_FLUSH_WRITE_IMMEDIATE_DATA;
573 MHW_CHK_STATUS_RETURN(miItf->MHW_ADDCMD_F(PIPE_CONTROL)(pCmdBuffer));
574
575 if(pCmdBuffer->Attributes.bUmdSSEUEnable)
576 {
577 MHW_MI_LOAD_REGISTER_IMM_PARAMS MiLoadRegImmParams;
578 MHW_RENDER_PWR_CLK_STATE_PARAMS params;
579
580 MOS_ZeroMemory(&params, sizeof(params));
581 params.PowerClkStateEn = true;
582 params.SCountEn = true;
583 params.SSCountEn = true;
584 params.SliceCount = pCmdBuffer->Attributes.dwNumRequestedEUSlices;
585 params.SubSliceCount = pCmdBuffer->Attributes.dwNumRequestedSubSlices;
586 params.EUmax = pCmdBuffer->Attributes.dwNumRequestedEUs;
587 params.EUmin = pCmdBuffer->Attributes.dwNumRequestedEUs;
588
589 auto& par = miItf->MHW_GETPAR_F(MI_LOAD_REGISTER_IMM)();
590 par = {};
591 par.dwRegister = MHW__PWR_CLK_STATE_REG;
592 par.dwData = params.Data;
593 MHW_CHK_STATUS_RETURN(miItf->MHW_ADDCMD_F(MI_LOAD_REGISTER_IMM)(pCmdBuffer));
594 }
595 }
596 else
597 {
598 // Send MI_FLUSH with protection bit off, which will FORCE exit protected mode for MFX
599 auto& params = miItf->MHW_GETPAR_F(MI_FLUSH_DW)();
600 params = {};
601 params.bVideoPipelineCacheInvalidate = true;
602 params.pOsResource = pParams->presStoreData;
603 params.dwResourceOffset = pParams->dwStoreDataOffset;
604 params.dwDataDW1 = pParams->dwStoreDataValue;
605 MHW_CHK_STATUS_RETURN(miItf->MHW_ADDCMD_F(MI_FLUSH_DW)(pCmdBuffer));
606 }
607
608 MHW_CHK_STATUS_RETURN(miItf->AddProtectedProlog(pCmdBuffer));
609
610 if (pMmioReg)
611 {
612 HalOcaInterfaceNext::On1stLevelBBStart(
613 *pCmdBuffer,
614 (MOS_CONTEXT_HANDLE)pOsInterface->pOsContext,
615 pOsInterface->CurrentGpuContextHandle,
616 miItf,
617 *pMmioReg);
618 }
619
620 return eStatus;
621 }
622
623 //!
624 //! \brief Sets Nearest Mode Table for Gen75/9, across SFC and Render engine to set the sampler states
625 //! \details This function sets Coefficients for Nearest Mode
626 //! \param int32_t* iCoefs
627 //! [out] Polyphase Table to fill
628 //! \param uint32_t dwPlane
629 //! [in] Number of Polyphase tables
630 //! \param bool bBalancedFilter
631 //! [in] If Filter is balanced, set true
632 //! \return MOS_STATUS
633 //! MOS_STATUS_SUCCESS if success, else fail reason
634 //!
635 MOS_STATUS Mhw_SetNearestModeTable(
636 int32_t *iCoefs,
637 uint32_t dwPlane,
638 bool bBalancedFilter)
639 {
640 uint32_t dwNumEntries;
641 uint32_t dwOffset;
642 uint32_t i;
643 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
644
645 MHW_FUNCTION_ENTER;
646
647 MHW_CHK_NULL_RETURN(iCoefs);
648
649 if (dwPlane == MHW_GENERIC_PLANE || dwPlane == MHW_Y_PLANE)
650 {
651 dwNumEntries = NUM_POLYPHASE_Y_ENTRIES;
652 dwOffset = 3;
653 }
654 else // if (dwPlane == MHW_U_PLANE || dwPlane == MHW_V_PLANE)
655 {
656 dwNumEntries = NUM_POLYPHASE_UV_ENTRIES;
657 dwOffset = 1;
658 }
659
660 for (i = 0; i <= NUM_HW_POLYPHASE_TABLES / 2; i++)
661 {
662 iCoefs[i * dwNumEntries + dwOffset] = 0x40;
663 }
664
665 if (bBalancedFilter)
666 {
667 // Fix offset so that filter is balanced
668 for (i = (NUM_HW_POLYPHASE_TABLES / 2 + 1); i < NUM_HW_POLYPHASE_TABLES; i++)
669 {
670 iCoefs[i * dwNumEntries + dwOffset + 1] = 0x40;
671 }
672 }
673
674 return eStatus;
675 }
676
677 //!
678 //! \brief Calculate Polyphase tables for Y , across SFC and Render engine to set the sampler states
679 //! \details Calculate Polyphase tables for Y
680 //! This function uses 17 phases.
681 //! MHW_NUM_HW_POLYPHASE_TABLES reflects the phases to program coefficients in HW, and
682 //! NUM_POLYPHASE_TABLES reflects the number of phases used for internal calculations.
683 //! \param int32_t* iCoefs
684 //! [out] Polyphase Table to fill
685 //! \param float fScaleFactor
686 //! [in] Scaling factor
687 //! \param uint32_t dwPlane
688 //! [in] Plane Info
689 //! \param MOS_FORMAT srcFmt
690 //! [in] Source Format
691 //! \param float fHPStrength
692 //! [in] High Pass Strength
693 //! \param bool bUse8x8Filter
694 //! [in] is 8x8 Filter used
695 //! \param uint32_t dwHwPhase
696 //! [in] Number of phases in HW
697 //! \param float fLanczosT
698 //! [in] Lanczos factor
699 //! \return MOS_STATUS
700 //! MOS_STATUS_SUCCESS if success, else fail reason
701 //!
702 MOS_STATUS Mhw_CalcPolyphaseTablesY(
703 int32_t *iCoefs,
704 float fScaleFactor,
705 uint32_t dwPlane,
706 MOS_FORMAT srcFmt,
707 float fHPStrength,
708 bool bUse8x8Filter,
709 uint32_t dwHwPhase,
710 float fLanczosT)
711 {
712 uint32_t dwNumEntries;
713 uint32_t dwTableCoefUnit;
714 uint32_t i, j;
715 int32_t k;
716 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
717 float fPhaseCoefs[NUM_POLYPHASE_Y_ENTRIES];
718 float fPhaseCoefsCopy[NUM_POLYPHASE_Y_ENTRIES];
719 float fStartOffset;
720 float fHPFilter[3], fHPSum, fHPHalfPhase; // Only used for Y_PLANE
721 float fBase, fPos, fSumCoefs;
722 int32_t iCenterPixel;
723 int32_t iSumQuantCoefs;
724
725 MHW_FUNCTION_ENTER;
726
727 MHW_CHK_NULL_RETURN(iCoefs);
728 MHW_ASSERT((dwHwPhase == MHW_NUM_HW_POLYPHASE_TABLES) || (dwHwPhase == NUM_HW_POLYPHASE_TABLES));
729
730 if (dwPlane == MHW_GENERIC_PLANE || dwPlane == MHW_Y_PLANE)
731 {
732 dwNumEntries = NUM_POLYPHASE_Y_ENTRIES;
733 }
734 else // if (dwPlane == MHW_U_PLANE || dwPlane == MHW_V_PLANE)
735 {
736 dwNumEntries = NUM_POLYPHASE_UV_ENTRIES;
737 }
738
739 MOS_ZeroMemory(fPhaseCoefs , sizeof(fPhaseCoefs));
740 MOS_ZeroMemory(fPhaseCoefsCopy, sizeof(fPhaseCoefsCopy));
741
742 dwTableCoefUnit = 1 << MHW_AVS_TBL_COEF_PREC;
743 iCenterPixel = dwNumEntries / 2 - 1;
744 fStartOffset = (float)(-iCenterPixel);
745
746 if ((IS_YUV_FORMAT(srcFmt) &&
747 dwPlane != MHW_U_PLANE &&
748 dwPlane != MHW_V_PLANE) ||
749 ((IS_RGB32_FORMAT(srcFmt) ||
750 srcFmt == Format_Y410 ||
751 srcFmt == Format_AYUV) &&
752 dwPlane == MHW_Y_PLANE))
753 {
754 if (fScaleFactor < 1.0F)
755 {
756 fLanczosT = 4.0F;
757 }
758 else
759 {
760 fLanczosT = 8.0F;
761 }
762 }
763 else // if (dwPlane == MHW_U_PLANE || dwPlane == MHW_V_PLANE || (IS_RGB_FORMAT(srcFmt) && dwPlane != MHW_V_PLANE))
764 {
765 fLanczosT = 2.0F;
766 }
767
768 for (i = 0; i < dwHwPhase; i++)
769 {
770 fBase = fStartOffset - (float)i / (float)NUM_POLYPHASE_TABLES;
771 fSumCoefs = 0.0F;
772
773 for (j = 0; j < dwNumEntries; j++)
774 {
775 fPos = fBase + (float)j;
776
777 if (bUse8x8Filter)
778 {
779 fPhaseCoefs[j] = fPhaseCoefsCopy[j] = MosUtilities::MosLanczos(fPos * fScaleFactor, dwNumEntries, fLanczosT);
780 }
781 else
782 {
783 fPhaseCoefs[j] = fPhaseCoefsCopy[j] = MosUtilities::MosLanczosG(fPos * fScaleFactor, NUM_POLYPHASE_5x5_Y_ENTRIES, fLanczosT);
784 }
785
786 fSumCoefs += fPhaseCoefs[j];
787 }
788
789 // Convolve with HP
790 if (dwPlane == MHW_GENERIC_PLANE || dwPlane == MHW_Y_PLANE)
791 {
792 if (i <= NUM_POLYPHASE_TABLES / 2)
793 {
794 fHPHalfPhase = (float)i / (float)NUM_POLYPHASE_TABLES;
795 }
796 else
797 {
798 fHPHalfPhase = (float)(NUM_POLYPHASE_TABLES - i) / (float)NUM_POLYPHASE_TABLES;
799 }
800 fHPFilter[0] = fHPFilter[2] = -fHPStrength * MosUtilities::MosSinc(fHPHalfPhase * MOS_PI);
801 fHPFilter[1] = 1.0F + 2.0F * fHPStrength;
802
803 for (j = 0; j < dwNumEntries; j++)
804 {
805 fHPSum = 0.0F;
806 for (k = -1; k <= 1; k++)
807 {
808 if ((((long)j + k) >= 0) && (j + k < dwNumEntries))
809 {
810 fHPSum += fPhaseCoefsCopy[(int32_t)j+k] * fHPFilter[k+1];
811 }
812 fPhaseCoefs[j] = fHPSum;
813 }
814 }
815 }
816
817 // Normalize coefs and save
818 iSumQuantCoefs = 0;
819 for (j = 0; j < dwNumEntries; j++)
820 {
821 iCoefs[i * dwNumEntries + j] = (int32_t)floor(0.5F + (float)dwTableCoefUnit * fPhaseCoefs[j] / fSumCoefs);
822 iSumQuantCoefs += iCoefs[i * dwNumEntries + j];
823 }
824
825 // Fix center coef so that filter is balanced
826 if (i <= NUM_POLYPHASE_TABLES / 2)
827 {
828 iCoefs[i * dwNumEntries + iCenterPixel] -= iSumQuantCoefs - dwTableCoefUnit;
829 }
830 else
831 {
832 iCoefs[i * dwNumEntries + iCenterPixel + 1] -= iSumQuantCoefs - dwTableCoefUnit;
833 }
834 }
835
836 return eStatus;
837 }
838
839 //!
840 //! \brief Calculate Polyphase tables for UV for Gen9, across SFC and Render engine to set the sampler states
841 //! \details Calculate Polyphase tables for UV
842 //! \param int32_t* piCoefs
843 //! [out] Polyphase Table to fill
844 //! \param float fLanczosT
845 //! [in] Lanczos modifying factor
846 //! \param float fInverseScaleFactor
847 //! [in] Inverse scaling factor
848 //! \return MOS_STATUS
849 //! MOS_STATUS_SUCCESS if success, else fail reason
850 //!
851 MOS_STATUS Mhw_CalcPolyphaseTablesUV(
852 int32_t *piCoefs,
853 float fLanczosT,
854 float fInverseScaleFactor)
855 {
856 int32_t phaseCount, tableCoefUnit, centerPixel, sumQuantCoefs;
857 double phaseCoefs[MHW_SCALER_UV_WIN_SIZE];
858 double startOffset, sf, base, sumCoefs, pos;
859 int32_t minCoef[MHW_SCALER_UV_WIN_SIZE];
860 int32_t maxCoef[MHW_SCALER_UV_WIN_SIZE];
861 int32_t i, j;
862 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
863
864 MHW_FUNCTION_ENTER;
865
866 MHW_CHK_NULL_RETURN(piCoefs);
867
868 phaseCount = MHW_TABLE_PHASE_COUNT;
869 centerPixel = (MHW_SCALER_UV_WIN_SIZE / 2) - 1;
870 startOffset = (double)(-centerPixel);
871 tableCoefUnit = 1 << MHW_TBL_COEF_PREC;
872 sf = MOS_MIN(1.0, fInverseScaleFactor); // Sf isn't used for upscaling
873
874 MOS_ZeroMemory(piCoefs, sizeof(int32_t) * MHW_SCALER_UV_WIN_SIZE * phaseCount);
875 MOS_ZeroMemory(minCoef, sizeof(minCoef));
876 MOS_ZeroMemory(maxCoef, sizeof(maxCoef));
877
878 if (sf < 1.0F)
879 {
880 fLanczosT = 2.0F;
881 }
882
883 for(i = 0; i < phaseCount; ++i, piCoefs += MHW_SCALER_UV_WIN_SIZE)
884 {
885 // Write all
886 // Note - to shift by a half you need to a half to each phase.
887 base = startOffset - (double)(i) / (double)(phaseCount);
888 sumCoefs = 0.0;
889
890 for(j = 0; j < MHW_SCALER_UV_WIN_SIZE; ++j)
891 {
892 pos = base + (double) j;
893 phaseCoefs[j] = MosUtilities::MosLanczos((float)(pos * sf), MHW_SCALER_UV_WIN_SIZE, fLanczosT);
894 sumCoefs += phaseCoefs[j];
895 }
896 // Normalize coefs and save
897 for(j = 0; j < MHW_SCALER_UV_WIN_SIZE; ++j)
898 {
899 piCoefs[j] = (int32_t) floor((0.5 + (double)(tableCoefUnit) * (phaseCoefs[j] / sumCoefs)));
900
901 //For debug purposes:
902 minCoef[j] = MOS_MIN(minCoef[j], piCoefs[j]);
903 maxCoef[j] = MOS_MAX(maxCoef[j], piCoefs[j]);
904 }
905
906 // Recalc center coef
907 sumQuantCoefs = 0;
908 for(j = 0; j < MHW_SCALER_UV_WIN_SIZE; ++j)
909 {
910 sumQuantCoefs += piCoefs[j];
911 }
912
913 // Fix center coef so that filter is balanced
914 if (i <= phaseCount/2)
915 {
916 piCoefs[centerPixel] -= sumQuantCoefs - tableCoefUnit;
917 }
918 else
919 {
920 piCoefs[centerPixel + 1] -= sumQuantCoefs - tableCoefUnit;
921 }
922 }
923
924 return eStatus;
925 }
926
927 //!
928 //! \brief Calculate polyphase tables UV offset for Gen9, across SFC and Render engine to set the sampler states
929 //! \details Calculate Polyphase tables for UV with chroma siting for
930 //! 420 to 444 conversion
931 //! \param int32_t* piCoefs
932 //! [out] Polyphase Table to fill
933 //! \param float fLanczosT
934 //! [in] Lanczos modifying factor
935 //! \param float fInverseScaleFactor
936 //! [in] Inverse scaling factor
937 //! \param int32_t iUvPhaseOffset
938 //! [in] UV Phase Offset
939 //! \return MOS_STATUS
940 //! MOS_STATUS_SUCCESS if success, else fail reason
941 //!
942 MOS_STATUS Mhw_CalcPolyphaseTablesUVOffset(
943 int32_t *piCoefs,
944 float fLanczosT,
945 float fInverseScaleFactor,
946 int32_t iUvPhaseOffset)
947 {
948 int32_t phaseCount, tableCoefUnit, centerPixel, sumQuantCoefs;
949 double phaseCoefs[MHW_SCALER_UV_WIN_SIZE];
950 double startOffset, sf, pos, sumCoefs, base;
951 int32_t minCoef[MHW_SCALER_UV_WIN_SIZE];
952 int32_t maxCoef[MHW_SCALER_UV_WIN_SIZE];
953 int32_t i, j;
954 int32_t adjusted_phase;
955 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
956
957 MHW_FUNCTION_ENTER;
958
959 MHW_CHK_NULL_RETURN(piCoefs);
960
961 phaseCount = MHW_TABLE_PHASE_COUNT;
962 centerPixel = (MHW_SCALER_UV_WIN_SIZE / 2) - 1;
963 startOffset = (double)(-centerPixel +
964 (double)iUvPhaseOffset / (double)(phaseCount));
965 tableCoefUnit = 1 << MHW_TBL_COEF_PREC;
966
967 MOS_ZeroMemory(minCoef, sizeof(minCoef));
968 MOS_ZeroMemory(maxCoef, sizeof(maxCoef));
969 MOS_ZeroMemory(piCoefs, sizeof(int32_t)* MHW_SCALER_UV_WIN_SIZE * phaseCount);
970
971 sf = MOS_MIN(1.0, fInverseScaleFactor); // Sf isn't used for upscaling
972 if (sf < 1.0)
973 {
974 fLanczosT = 3.0;
975 }
976
977 for (i = 0; i < phaseCount; ++i, piCoefs += MHW_SCALER_UV_WIN_SIZE)
978 {
979 // Write all
980 // Note - to shift by a half you need to a half to each phase.
981 base = startOffset - (double)(i) / (double)(phaseCount);
982 sumCoefs = 0.0;
983
984 for (j = 0; j < MHW_SCALER_UV_WIN_SIZE; ++j)
985 {
986 pos = base + (double)j;
987 phaseCoefs[j] = MosUtilities::MosLanczos((float)(pos * sf), 6/*MHW_SCALER_UV_WIN_SIZE*/, fLanczosT);
988 sumCoefs += phaseCoefs[j];
989 }
990 // Normalize coefs and save
991 for (j = 0; j < MHW_SCALER_UV_WIN_SIZE; ++j)
992 {
993 piCoefs[j] = (int32_t)floor((0.5 + (double)(tableCoefUnit)* (phaseCoefs[j] / sumCoefs)));
994
995 // For debug purposes:
996 minCoef[j] = MOS_MIN(minCoef[j], piCoefs[j]);
997 maxCoef[j] = MOS_MAX(maxCoef[j], piCoefs[j]);
998 }
999
1000 // Recalc center coef
1001 sumQuantCoefs = 0;
1002 for (j = 0; j < MHW_SCALER_UV_WIN_SIZE; ++j)
1003 {
1004 sumQuantCoefs += piCoefs[j];
1005 }
1006
1007 // Fix center coef so that filter is balanced
1008 adjusted_phase = i - iUvPhaseOffset;
1009 if (adjusted_phase <= phaseCount / 2)
1010 {
1011 piCoefs[centerPixel] -= sumQuantCoefs - tableCoefUnit;
1012 }
1013 else // if(adjusted_phase < phaseCount)
1014 {
1015 piCoefs[centerPixel + 1] -= sumQuantCoefs - tableCoefUnit;
1016 }
1017 }
1018
1019 return eStatus;
1020 }
1021
1022 //!
1023 //! \brief Allocate BB
1024 //! \details Allocated Batch Buffer
1025 //! \param PMOS_INTERFACE pOsInterface
1026 //! [in] Pointer to OS Interface
1027 //! \param PMHW_BATCH_BUFFER pBatchBuffer
1028 //! [in/out] Pointer to Batch Buffer
1029 //! \param PMHW_BATCH_BUFFER pBatchBufferList
1030 //! [in/out] If valid, represents the batch buffer list maintained by the client
1031 //! \param uint32_t dwSize
1032 //! [in] Sixe of the batch vuffer to be allocated
1033 //! \param bool notLockable
1034 //! [in] Indicate if the batch buffer not lockable, by default is false
1035 //! \param bool inSystemMem
1036 //! [in] Indicate if the batch buffer in system memory, by default is false
1037 //! \return MOS_STATUS
1038 //! true if the Batch Buffer was successfully allocated
1039 //! false if failed
1040 //!
1041 MOS_STATUS Mhw_AllocateBb(
1042 PMOS_INTERFACE pOsInterface,
1043 PMHW_BATCH_BUFFER pBatchBuffer,
1044 PMHW_BATCH_BUFFER pBatchBufferList,
1045 uint32_t dwSize,
1046 uint32_t batchCount,
1047 bool notLockable,
1048 bool inSystemMem)
1049 {
1050 MHW_FUNCTION_ENTER;
1051
1052 MOS_RESOURCE OsResource;
1053 MOS_ALLOC_GFXRES_PARAMS AllocParams;
1054 uint32_t allocSize;
1055 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1056
1057 MHW_CHK_NULL_RETURN(pOsInterface);
1058 MHW_CHK_NULL_RETURN(pBatchBuffer);
1059 MHW_ASSERT(!(notLockable && inSystemMem)); // Notlockable system memory doesn't make sense
1060
1061 dwSize += 8 * MHW_CACHELINE_SIZE;
1062 dwSize = MOS_ALIGN_CEIL(dwSize, MOS_PAGE_SIZE);
1063 allocSize = dwSize * batchCount;
1064
1065 MOS_ZeroMemory(&OsResource, sizeof(OsResource));
1066 MOS_ZeroMemory(&AllocParams, sizeof(AllocParams));
1067 AllocParams.Type = MOS_GFXRES_BUFFER;
1068 AllocParams.TileType = MOS_TILE_LINEAR;
1069 AllocParams.Format = Format_Buffer;
1070 AllocParams.dwBytes = allocSize;
1071 AllocParams.pBufName = "BatchBuffer";
1072 AllocParams.ResUsageType = MOS_HW_RESOURCE_USAGE_MEDIA_BATCH_BUFFERS;
1073 AllocParams.Flags.bNotLockable = notLockable ? 1 : 0;
1074 if (notLockable)
1075 {
1076 AllocParams.dwMemType = MOS_MEMPOOL_DEVICEMEMORY;
1077 }
1078 else if (inSystemMem)
1079 {
1080 AllocParams.dwMemType = MOS_MEMPOOL_SYSTEMMEMORY;
1081 }
1082 else
1083 {
1084 AllocParams.dwMemType = MOS_MEMPOOL_VIDEOMEMORY;
1085 }
1086
1087 MHW_CHK_STATUS_RETURN(pOsInterface->pfnAllocateResource(
1088 pOsInterface,
1089 &AllocParams,
1090 &OsResource));
1091
1092 // Reset Allocation
1093 pOsInterface->pfnResetResourceAllocationIndex(pOsInterface, &OsResource);
1094
1095 pBatchBuffer->OsResource = OsResource;
1096 pBatchBuffer->iSize = (int32_t)dwSize;
1097 pBatchBuffer->count = batchCount;
1098 pBatchBuffer->iRemaining = pBatchBuffer->iSize;
1099 pBatchBuffer->iCurrent = 0;
1100 pBatchBuffer->bLocked = false;
1101 #if (_DEBUG || _RELEASE_INTERNAL)
1102 pBatchBuffer->iLastCurrent = 0;
1103 #endif
1104
1105 // Link BB for synchronization
1106 pBatchBuffer->bBusy = false;
1107 pBatchBuffer->dwCmdBufId = 0;
1108
1109 if (pBatchBufferList)
1110 {
1111 pBatchBuffer->pNext = pBatchBufferList;
1112 pBatchBufferList = pBatchBuffer;
1113 if (pBatchBuffer->pNext)
1114 {
1115 pBatchBuffer->pNext->pPrev = pBatchBuffer;
1116 }
1117 }
1118
1119 return eStatus;
1120 }
1121
1122 //!
1123 //! \brief Free BB
1124 //! \details Frees Batch Buffer
1125 //! \param PMOS_INTERFACE pOsInterface
1126 //! [in] Pointer to OS Interface
1127 //! \param PMHW_BATCH_BUFFER pBatchBuffer
1128 //! [in] Pointer to Batch Buffer
1129 //! \param PMHW_BATCH_BUFFER pBatchBufferList
1130 //! [in/out] If valid, represents the batch buffer list maintained by the client
1131 //! \return MOS_STATUS
1132 //!
1133 MOS_STATUS Mhw_FreeBb(
1134 PMOS_INTERFACE pOsInterface,
1135 PMHW_BATCH_BUFFER pBatchBuffer,
1136 PMHW_BATCH_BUFFER pBatchBufferList)
1137 {
1138 MHW_FUNCTION_ENTER;
1139
1140 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1141
1142 MHW_CHK_NULL_RETURN(pOsInterface);
1143 MHW_CHK_NULL_RETURN(pBatchBuffer);
1144
1145 if (pBatchBuffer->bLocked)
1146 {
1147 MHW_CHK_STATUS_RETURN(Mhw_UnlockBb(pOsInterface, pBatchBuffer, true));
1148 }
1149
1150 pOsInterface->pfnFreeResource(pOsInterface, &pBatchBuffer->OsResource);
1151
1152 pBatchBuffer->dwCmdBufId = 0;
1153 pBatchBuffer->iSize = 0;
1154 pBatchBuffer->count = 0;
1155 pBatchBuffer->iCurrent = 0;
1156 #if (_DEBUG || _RELEASE_INTERNAL)
1157 pBatchBuffer->iLastCurrent = 0;
1158 #endif
1159
1160 if (pBatchBufferList)
1161 {
1162 // Unlink BB from synchronization list
1163 if (pBatchBuffer->pNext)
1164 {
1165 pBatchBuffer->pNext->pPrev = pBatchBuffer->pPrev;
1166 }
1167
1168 if (pBatchBuffer->pPrev)
1169 {
1170 pBatchBuffer->pPrev->pNext = pBatchBuffer->pNext;
1171 }
1172 else
1173 {
1174 pBatchBufferList = pBatchBuffer->pNext;
1175 }
1176
1177 pBatchBuffer->pPrev = pBatchBuffer->pNext = nullptr;
1178 }
1179
1180 return eStatus;
1181 }
1182
1183 //!
1184 //! \brief Lock BB
1185 //! \details Locks Batch Buffer
1186 //! \param PMOS_INTERFACE pOsInterface
1187 //! [in] Pointer to OS Interface
1188 //! \param PMHW_BATCH_BUFFER pBatchBuffer
1189 //! [in] Pointer to Batch Buffer
1190 //! \return MOS_STATUS
1191 //!
1192 MOS_STATUS Mhw_LockBb(
1193 PMOS_INTERFACE pOsInterface,
1194 PMHW_BATCH_BUFFER pBatchBuffer)
1195 {
1196 MHW_FUNCTION_ENTER;
1197
1198 MOS_LOCK_PARAMS LockFlags;
1199 MOS_STATUS eStatus;
1200
1201 MHW_CHK_NULL_RETURN(pOsInterface);
1202 MHW_CHK_NULL_RETURN(pBatchBuffer);
1203
1204 eStatus = MOS_STATUS_UNKNOWN;
1205
1206 if (pBatchBuffer->bLocked)
1207 {
1208 MHW_ASSERTMESSAGE("Batch Buffer is already locked.");
1209 return eStatus;
1210 }
1211
1212 MOS_ZeroMemory(&LockFlags, sizeof(MOS_LOCK_PARAMS));
1213 LockFlags.WriteOnly = 1;
1214 pBatchBuffer->pData = (uint8_t*)pOsInterface->pfnLockResource(
1215 pOsInterface,
1216 &pBatchBuffer->OsResource,
1217 &LockFlags);
1218
1219 MHW_CHK_NULL_RETURN(pBatchBuffer->pData);
1220
1221 pBatchBuffer->bLocked = true;
1222 eStatus = MOS_STATUS_SUCCESS;
1223
1224 return eStatus;
1225 }
1226
1227 //!
1228 //! \brief Unlock BB
1229 //! \details Unlocks Batch Buffer
1230 //! \param PMOS_INTERFACE pOsInterface
1231 //! [in] Pointer to OS Interface
1232 //! \param PMHW_BATCH_BUFFER pBatchBuffer
1233 //! [in] Pointer to Batch Buffer
1234 //! \param bool bResetBuffer
1235 //! [in] Reset BB information concerning current offset and size
1236 //! \return MOS_STATUS
1237 //!
1238 MOS_STATUS Mhw_UnlockBb(
1239 PMOS_INTERFACE pOsInterface,
1240 PMHW_BATCH_BUFFER pBatchBuffer,
1241 bool bResetBuffer)
1242 {
1243 MHW_FUNCTION_ENTER;
1244
1245 MOS_STATUS eStatus;
1246
1247 MHW_CHK_NULL_RETURN(pOsInterface);
1248 MHW_CHK_NULL_RETURN(pBatchBuffer);
1249
1250 eStatus = MOS_STATUS_UNKNOWN;
1251
1252 if (!pBatchBuffer->bLocked)
1253 {
1254 MHW_ASSERTMESSAGE("Batch buffer is locked.");
1255 return eStatus;
1256 }
1257
1258 if (bResetBuffer)
1259 {
1260 pBatchBuffer->iRemaining = pBatchBuffer->iSize;
1261 pBatchBuffer->iCurrent = 0;
1262 }
1263
1264 MHW_CHK_STATUS_RETURN(pOsInterface->pfnUnlockResource(
1265 pOsInterface,
1266 &pBatchBuffer->OsResource));
1267
1268 pBatchBuffer->bLocked = false;
1269 pBatchBuffer->pData = nullptr;
1270
1271 eStatus = MOS_STATUS_SUCCESS;
1272
1273 return eStatus;
1274 }
1275
1276 //!
1277 //! \brief Convert To Nano Seconds
1278 //! \details Convert to Nano Seconds
1279 //! \param PVPHAL_HW_int32_tERFACE pHwInterface
1280 //! [in] Pointer to Hardware Interface Structure
1281 //! \param uint64_t iTicks
1282 //! [in] Ticks
1283 //! \param uint64_t* piNs
1284 //! [in] Nano Seconds
1285 //! \return MOS_STATUS
1286 //!
1287 MOS_STATUS Mhw_ConvertToNanoSeconds(
1288 uint64_t iTicks,
1289 uint64_t *piNs)
1290 {
1291 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1292
1293 MHW_CHK_NULL_RETURN(piNs);
1294
1295 *piNs = iTicks * MHW_NS_PER_TICK_RENDER_ENGINE;
1296
1297 return eStatus;
1298 }
1299
1300 //!
1301 //! \brief Convert Mos Tile Type to TR Mode
1302 //! \details Convert Mos Tile Type to TR Mode
1303 //! \param MOS_TILE_TYPE Type
1304 //! [in] MOS tile type
1305 //! \return uint32_t
1306 //! Tile Resouece Mode
1307 //!
1308 uint32_t Mhw_ConvertToTRMode(MOS_TILE_TYPE Type)
1309 {
1310 switch (Type)
1311 {
1312 case MOS_TILE_YS:
1313 return TRMODE_TILEYS;
1314 case MOS_TILE_YF:
1315 return TRMODE_TILEYF;
1316 default:
1317 return TRMODE_NONE;
1318 }
1319 }