1 /*
2 * Copyright (c) 2017-2020, 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_g11.cpp
24 //! \brief implementation of Gen11 hardware functions
25 //! \details Render functions
26 //!
27
28 #include "renderhal_legacy.h"
29 #include "renderhal_g11.h"
30
31 //!
32 //! \brief GSH settings for G11
33 //!
34 extern const RENDERHAL_STATE_HEAP_SETTINGS g_cRenderHal_State_Heap_Settings_g11 =
35 {
36 // Global GSH Allocation parameters
37 RENDERHAL_SYNC_SIZE, //!< iSyncSize
38
39 // Media State Allocation parameters
40 RENDERHAL_MEDIA_STATES, //!< iMediaStateHeaps - Set by Initialize
41 RENDERHAL_MEDIA_IDS, //!< iMediaIDs
42 RENDERHAL_CURBE_SIZE, //!< iCurbeSize
43 RENDERHAL_SAMPLERS, //!< iSamplers
44 RENDERHAL_SAMPLERS_AVS_G11, //!< iSamplersAVS
45 RENDERHAL_SAMPLERS_VA, //!< iSamplersVA
46 RENDERHAL_KERNEL_COUNT, //!< iKernelCount
47 RENDERHAL_KERNEL_HEAP, //!< iKernelHeapSize
48 RENDERHAL_KERNEL_BLOCK_SIZE, //!< iKernelBlockSize
49
50 // Media VFE/ID configuration, limits
51 0, //!< iPerThreadScratchSize
52 RENDERHAL_MAX_SIP_SIZE, //!< iSipSize
53
54 // Surface State Heap Settings
55 RENDERHAL_SSH_INSTANCES, //!< iSurfaceStateHeaps
56 RENDERHAL_SSH_BINDING_TABLES, //!< iBindingTables
57 RENDERHAL_SSH_SURFACE_STATES, //!< iSurfaceStates
58 RENDERHAL_SSH_SURFACES_PER_BT, //!< iSurfacesPerBT
59 RENDERHAL_SSH_BINDING_TABLE_ALIGN //!< iBTAlignment
60 };
61
62
63 const uint32_t g_cLookup_RotationMode_g11[8] =
64 {
65 ROTATION_IDENTITY, // 0 - MHW_ROTATION_IDENTITY
66 ROTATION_90, // 1 - MHW_ROTATION_90
67 ROTATION_180, // 2 - MHW_ROTATION_180
68 ROTATION_270, // 3 - MHW_ROTATION_270
69 ROTATION_IDENTITY, // 4 - MHW_MIRROR_HORIZONTAL
70 ROTATION_180, // 5 - MHW_MIRROR_VERTICAL
71 ROTATION_270, // 6 - MHW_ROTATE_90_MIRROR_VERTICAL
72 ROTATION_90 // 7 - MHW_ROTATE_90_MIRROR_HORIZONTAL
73 };
74
75 #define RENDERHAL_NS_PER_TICK_RENDER_G11 (83.333) // Assume it same as SKL, 83.333 nano seconds per tick in render engine
76
77 //!
78 //! DSH State Heap settings for G11
79 //!
80 const RENDERHAL_DYN_HEAP_SETTINGS g_cRenderHal_DSH_Settings_g11 =
81 {
82 0x0080000, // dwDshInitialSize = 512MB
83 0x0080000, // dwDshSizeIncrement = 512kB
84 0x8000000, // dwDshMaximumSize = 128MB (all heaps)
85 0x0100000, // dwIshInitialSize = 1M
86 0x0040000, // dwIshSizeIncrement = 256kB
87 0x0400000, // dwIshMaximumSize = 4MB
88 16, // iMinMediaStates
89 256, // iMaxMediaStates
90 16, // iMinKernels
91 2048 // iMaxKernels
92 };
93
94 //!
95 //! \brief Setup Surface State
96 //! \details Setup Surface State for Gen11
97 //! \param PRENDERHAL_INTERFACE pRenderHal
98 //! [in] Pointer to Hardware Interface Structure
99 //! \param PRENDERHAL_SURFACE pRenderHalSurface
100 //! [in] Pointer to Render Hal Surface
101 //! \param PRENDERHAL_SURFACE_STATE_PARAMS pParams
102 //! [in] Pointer to Surface State Params
103 //! \param int32_t *piNumEntries
104 //! [out] Pointer to Number of Surface State Entries (Num Planes)
105 //! \param PRENDERHAL_SURFACE_STATE_ENTRY * ppSurfaceEntries
106 //! [out] Array of Surface State Entries
107 //! \param PRENDERHAL_OFFSET_OVERRIDE pOffsetOverride
108 //! [in] Ignored (not used in Gen11)
109 //! \return MOS_STATUS
110 //!
SetupSurfaceState(PRENDERHAL_INTERFACE pRenderHal,PRENDERHAL_SURFACE pRenderHalSurface,PRENDERHAL_SURFACE_STATE_PARAMS pParams,int32_t * piNumEntries,PRENDERHAL_SURFACE_STATE_ENTRY * ppSurfaceEntries,PRENDERHAL_OFFSET_OVERRIDE pOffsetOverride)111 MOS_STATUS XRenderHal_Interface_g11::SetupSurfaceState (
112 PRENDERHAL_INTERFACE pRenderHal,
113 PRENDERHAL_SURFACE pRenderHalSurface,
114 PRENDERHAL_SURFACE_STATE_PARAMS pParams,
115 int32_t *piNumEntries,
116 PRENDERHAL_SURFACE_STATE_ENTRY *ppSurfaceEntries,
117 PRENDERHAL_OFFSET_OVERRIDE pOffsetOverride)
118 {
119 PRENDERHAL_SURFACE_STATE_ENTRY pSurfaceEntry;
120 PMOS_PLANE_OFFSET pPlaneOffset;
121 MHW_SURFACE_STATE_PARAMS SurfStateParams;
122 PMOS_SURFACE pSurface;
123 int32_t i;
124 uint32_t dwPixelsPerSampleUV;
125 uint32_t dwSurfaceSize;
126 MOS_STATUS eStatus = MOS_STATUS_UNKNOWN;
127
128 //-----------------------------------------
129 MHW_RENDERHAL_UNUSED(pOffsetOverride);
130 MHW_RENDERHAL_CHK_NULL(pRenderHal);
131 MHW_RENDERHAL_CHK_NULL(pRenderHalSurface);
132 MHW_RENDERHAL_CHK_NULL(pParams);
133 MHW_RENDERHAL_CHK_NULL(ppSurfaceEntries);
134 MHW_RENDERHAL_CHK_NULL(pRenderHal->pStateHeap);
135 MHW_RENDERHAL_CHK_NULL(pRenderHal->pHwSizes);
136 MHW_RENDERHAL_CHK_NULL(pRenderHal->pMhwStateHeap);
137 MHW_RENDERHAL_ASSERT(pRenderHalSurface->Rotation >= MHW_ROTATION_IDENTITY &&
138 pRenderHalSurface->Rotation <= MHW_ROTATE_90_MIRROR_HORIZONTAL);
139 //-----------------------------------------
140
141 dwSurfaceSize = pRenderHal->pHwSizes->dwSizeSurfaceState;
142
143 MOS_ZeroMemory(&SurfStateParams, sizeof(SurfStateParams));
144
145 // Get the Surface State Entries
146 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pfnGetSurfaceStateEntries(
147 pRenderHal,
148 pRenderHalSurface,
149 pParams,
150 piNumEntries,
151 ppSurfaceEntries));
152
153 for (i = 0; i < *piNumEntries; i++)
154 {
155 // Pointer to surface state entry for current plane
156 pSurfaceEntry = ppSurfaceEntries[i];
157
158 pSurface = pSurfaceEntry->pSurface;
159
160 // Set the Surface State Offset from base of SSH
161 pSurfaceEntry->dwSurfStateOffset = pRenderHal->pStateHeap->iSurfaceStateOffset + // Offset to Base Of Current Surface State Area
162 pSurfaceEntry->iSurfStateID * dwSurfaceSize; // Offset to Surface State within the area
163
164 // Obtain the Pointer to the Surface state from SSH Buffer
165 SurfStateParams.pSurfaceState = pSurfaceEntry->pSurfaceState;
166 SurfStateParams.bUseAdvState = pSurfaceEntry->bAVS;
167 SurfStateParams.dwWidth = pSurfaceEntry->dwWidth;
168 SurfStateParams.dwHeight = pSurfaceEntry->dwHeight;
169 SurfStateParams.dwFormat = pSurfaceEntry->dwFormat;
170 SurfStateParams.dwPitch = pSurfaceEntry->dwPitch;
171 SurfStateParams.dwQPitch = pSurfaceEntry->dwQPitch;
172 SurfStateParams.bTiledSurface = pSurfaceEntry->bTiledSurface;
173 SurfStateParams.bTileWalk = pSurfaceEntry->bTileWalk;
174 SurfStateParams.dwCacheabilityControl = pRenderHal->pfnGetSurfaceMemoryObjectControl(pRenderHal, pParams);
175 SurfStateParams.bCompressionEnabled = pSurface->bIsCompressed;
176 SurfStateParams.bCompressionMode = (pSurface->CompressionMode == MOS_MMC_VERTICAL) ? 1 : 0;
177 SurfStateParams.RotationMode = g_cLookup_RotationMode_g11[pRenderHalSurface->Rotation];
178
179 if (pSurfaceEntry->bAVS)
180 {
181 SurfStateParams.bHalfPitchChroma = pSurfaceEntry->bHalfPitchChroma;
182 SurfStateParams.bInterleaveChroma = pSurfaceEntry->bInterleaveChroma;
183 SurfStateParams.UVPixelOffsetUDirection = pSurfaceEntry->DirectionU;
184 SurfStateParams.UVPixelOffsetVDirection = pSurfaceEntry->DirectionV;
185
186 // On SNB+, when VDI Walker is enabled, Input surface width should be 16 pixel aligned
187 if (pParams->bWidth16Align)
188 {
189 SurfStateParams.dwWidth = MOS_ALIGN_CEIL(pSurfaceEntry->dwWidth, 16);
190 }
191
192 if (pSurfaceEntry->YUVPlane == MHW_U_PLANE) // AVS U plane
193 {
194 // Lockoffset is the offset from base address of Y plane to the origin of U/V plane.
195 // So, We can get XOffsetforU by Lockoffset % pSurface->dwPitch, and get YOffsetForU by Lockoffset / pSurface->dwPitch
196 SurfStateParams.dwXOffsetForU = (uint32_t)pSurface->UPlaneOffset.iLockSurfaceOffset % pSurface->dwPitch;
197 SurfStateParams.dwYOffsetForU = (uint32_t)pSurface->UPlaneOffset.iLockSurfaceOffset / pSurface->dwPitch;
198 SurfStateParams.dwXOffsetForV = 0;
199 SurfStateParams.dwYOffsetForV = 0;
200 SurfStateParams.iXOffset = pSurface->UPlaneOffset.iXOffset;
201 SurfStateParams.iYOffset = pSurface->UPlaneOffset.iYOffset;
202 }
203 else if (pSurfaceEntry->YUVPlane == MHW_V_PLANE) // AVS V plane
204 {
205 SurfStateParams.dwXOffsetForU = 0;
206 SurfStateParams.dwYOffsetForU = 0;
207 SurfStateParams.dwXOffsetForV = (uint32_t)pSurface->VPlaneOffset.iLockSurfaceOffset % pSurface->dwPitch;
208 SurfStateParams.dwYOffsetForV = (uint32_t)pSurface->VPlaneOffset.iLockSurfaceOffset / pSurface->dwPitch;
209 SurfStateParams.iXOffset = pSurface->VPlaneOffset.iXOffset;
210 SurfStateParams.iYOffset = pSurface->VPlaneOffset.iYOffset;
211 }
212 else // AVS/DNDI Y plane
213 {
214 SurfStateParams.dwXOffsetForU = pSurfaceEntry->wUXOffset;
215 SurfStateParams.dwYOffsetForU = pSurfaceEntry->wUYOffset;
216 SurfStateParams.dwXOffsetForV = pSurfaceEntry->wVXOffset;
217 SurfStateParams.dwYOffsetForV = pSurfaceEntry->wVYOffset;
218 SurfStateParams.iXOffset = 0;
219 SurfStateParams.iYOffset = pSurface->YPlaneOffset.iYOffset;
220 }
221 if (pRenderHalSurface->bInterlacedScaling)
222 {
223 SurfStateParams.bVerticalLineStrideOffset = pSurfaceEntry->bVertStrideOffs;
224 SurfStateParams.bVerticalLineStride = pSurfaceEntry->bVertStride;
225 }
226 }
227 else // 2D/3D Surface (non-AVS)
228 {
229 SurfStateParams.SurfaceType3D = (pSurface->dwDepth > 1) ?
230 GFX3DSTATE_SURFACETYPE_3D :
231 GFX3DSTATE_SURFACETYPE_2D;
232 SurfStateParams.dwDepth = MOS_MAX(1, pSurface->dwDepth);
233 SurfStateParams.bVerticalLineStrideOffset = pSurfaceEntry->bVertStrideOffs;
234 SurfStateParams.bVerticalLineStride = pSurfaceEntry->bVertStride;
235 SurfStateParams.bHalfPitchChroma = pSurfaceEntry->bHalfPitchChroma;
236
237 // Setup surface g9 surface state
238 if (pSurfaceEntry->YUVPlane == MHW_U_PLANE ||
239 pSurfaceEntry->YUVPlane == MHW_V_PLANE)
240 {
241 pPlaneOffset = (pSurfaceEntry->YUVPlane == MHW_U_PLANE) ?
242 &pSurface->UPlaneOffset : &pSurface->VPlaneOffset;
243
244 // Get Pixels Per Sample if we use dataport read
245 if(pParams->bWidthInDword_UV)
246 {
247 RenderHal_GetPixelsPerSample(pSurface->Format, &dwPixelsPerSampleUV);
248 }
249 else
250 {
251 // If the kernel uses sampler - do not change width (it affects coordinates)
252 dwPixelsPerSampleUV = 1;
253 }
254
255 if(dwPixelsPerSampleUV == 1)
256 {
257 SurfStateParams.iXOffset = pPlaneOffset->iXOffset;
258 }
259 else
260 {
261 SurfStateParams.iXOffset = pPlaneOffset->iXOffset/sizeof(uint32_t);
262 }
263
264 SurfStateParams.iYOffset = pPlaneOffset->iYOffset;
265 }
266 else // Y plane
267 {
268 pPlaneOffset = &pSurface->YPlaneOffset;
269
270 SurfStateParams.iXOffset = pPlaneOffset->iXOffset/sizeof(uint32_t);
271 SurfStateParams.iYOffset = pPlaneOffset->iYOffset;
272
273 if((pSurfaceEntry->YUVPlane == MHW_Y_PLANE) &&
274 (pSurfaceEntry->dwFormat == MHW_GFX3DSTATE_SURFACEFORMAT_PLANAR_420_8))
275 {
276 if (pSurface->Format == Format_YV12)
277 {
278 SurfStateParams.bSeperateUVPlane = true;
279 SurfStateParams.dwXOffsetForU = 0;
280 SurfStateParams.dwYOffsetForU = pSurface->dwHeight * 2 + pSurface->dwHeight / 2;
281 SurfStateParams.dwXOffsetForV = 0;
282 SurfStateParams.dwYOffsetForV = pSurface->dwHeight * 2;
283 }
284 else
285 {
286 SurfStateParams.bSeperateUVPlane = false;
287 SurfStateParams.dwXOffsetForU = 0;
288 SurfStateParams.dwYOffsetForU = (uint32_t)((pSurface->UPlaneOffset.iSurfaceOffset - pSurface->YPlaneOffset.iSurfaceOffset) / pSurface->dwPitch) + pSurface->UPlaneOffset.iYOffset;
289 SurfStateParams.dwXOffsetForV = 0;
290 SurfStateParams.dwYOffsetForV = 0;
291 }
292 }
293
294 if((pSurfaceEntry->YUVPlane == MHW_Y_PLANE) &&
295 (pSurfaceEntry->dwFormat == MHW_GFX3DSTATE_SURFACEFORMAT_PLANAR_420_16))
296 {
297 SurfStateParams.bSeperateUVPlane = false;
298 SurfStateParams.dwXOffsetForU = 0;
299 SurfStateParams.dwYOffsetForU = (uint32_t)((pSurface->UPlaneOffset.iSurfaceOffset - pSurface->YPlaneOffset.iSurfaceOffset) / pSurface->dwPitch) + pSurface->UPlaneOffset.iYOffset;
300 SurfStateParams.dwXOffsetForV = 0;
301 SurfStateParams.dwYOffsetForV = 0;
302 }
303 }
304 }
305
306 // Call MHW to setup the Surface State Heap entry
307 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwStateHeap->SetSurfaceStateEntry(&SurfStateParams));
308
309 // Setup OS specific states
310 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pfnSetupSurfaceStatesOs(pRenderHal, pParams, pSurfaceEntry));
311 }
312
313 eStatus = MOS_STATUS_SUCCESS;
314
315 finish:
316 return eStatus;
317 }
318
319 //!
320 //! \brief Encode SLM Size for Interface Descriptor
321 //! \details Setup SLM size
322 //! \param uint32_t SLMSize
323 //! [in] SLM size in 1K
324 //! \return encoded output
325 //!
EncodeSLMSize(uint32_t SLMSize)326 uint32_t XRenderHal_Interface_g11::EncodeSLMSize(uint32_t SLMSize)
327 {
328 uint32_t EncodedValue;
329 if (SLMSize <= 2)
330 {
331 EncodedValue = SLMSize;
332 }
333 else
334 {
335 EncodedValue = 0;
336 do
337 {
338 SLMSize >>= 1;
339 EncodedValue++;
340 } while (SLMSize);
341 }
342 return EncodedValue;
343 }
344
345 //!
346 //! \brief Convert To Nano Seconds
347 //! \details Convert to Nano Seconds
348 //! \param PRENDERHAL_INTERFACE pRenderHal
349 //! [in] Pointer to Hardware Interface Structure
350 //! \param uint64_t iTicks
351 //! [in] Ticks
352 //! \param uint64_t *piNs
353 //! [in] Nano Seconds
354 //! \return void
355 //!
ConvertToNanoSeconds(PRENDERHAL_INTERFACE pRenderHal,uint64_t iTicks,uint64_t * piNs)356 void XRenderHal_Interface_g11::ConvertToNanoSeconds(
357 PRENDERHAL_INTERFACE pRenderHal,
358 uint64_t iTicks,
359 uint64_t *piNs)
360 {
361 //-----------------------------
362 MHW_RENDERHAL_UNUSED(pRenderHal);
363 MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pRenderHal);
364 MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(piNs);
365 //-----------------------------
366 *piNs = (uint64_t)(iTicks * RENDERHAL_NS_PER_TICK_RENDER_G11);
367 }
368
369 //!
370 //! \brief Setup Chroma direction for Gen11
371 //! \details Setup Chroma direction
372 //! \param PRENDERHAL_INTERFACE pRenderHal
373 //! [in] Pointer to HW Interface
374 //! \param PRENDERHAL_SURFACE pSurface
375 //! [in] Pointer to surface
376 //! \return uint8_t
377 //!
SetChromaDirection(PRENDERHAL_INTERFACE pRenderHal,PRENDERHAL_SURFACE pRenderHalSurface)378 uint8_t XRenderHal_Interface_g11::SetChromaDirection(
379 PRENDERHAL_INTERFACE pRenderHal,
380 PRENDERHAL_SURFACE pRenderHalSurface)
381 {
382 uint8_t Direction;
383 MHW_RENDERHAL_UNUSED(pRenderHal);
384
385 MHW_RENDERHAL_ASSERT(pRenderHal);
386 MHW_RENDERHAL_ASSERT(pRenderHalSurface);
387
388 Direction = 0;
389
390 if (pRenderHalSurface->ChromaSiting & MHW_CHROMA_SITING_HORZ_CENTER)
391 {
392 Direction = CHROMA_SITING_UDIRECTION_CENTER;
393 }
394 else
395 {
396 Direction = CHROMA_SITING_UDIRECTION_LEFT;
397 }
398
399 // Combined U/V direction together in one uint8_t, 1 bit for U direction, 3 bits for V direction.
400 Direction = Direction << 3;
401
402 if (pRenderHalSurface->pDeinterlaceParams || pRenderHalSurface->bQueryVariance)
403 {
404 if ((pRenderHalSurface->SampleType == RENDERHAL_SAMPLE_INTERLEAVED_EVEN_FIRST_BOTTOM_FIELD) ||
405 (pRenderHalSurface->SampleType == RENDERHAL_SAMPLE_INTERLEAVED_ODD_FIRST_BOTTOM_FIELD))
406 {
407 if (pRenderHalSurface->ChromaSiting & MHW_CHROMA_SITING_VERT_TOP)
408 {
409 Direction |= CHROMA_SITING_VDIRECTION_1_2;
410 }
411 else if (pRenderHalSurface->ChromaSiting & MHW_CHROMA_SITING_VERT_BOTTOM)
412 {
413 Direction |= CHROMA_SITING_VDIRECTION_1;
414 }
415 else
416 {
417 Direction |= CHROMA_SITING_VDIRECTION_3_4;
418 }
419 }
420 else if ((pRenderHalSurface->SampleType == RENDERHAL_SAMPLE_INTERLEAVED_EVEN_FIRST_TOP_FIELD) ||
421 (pRenderHalSurface->SampleType == RENDERHAL_SAMPLE_INTERLEAVED_ODD_FIRST_TOP_FIELD))
422 {
423 if (pRenderHalSurface->ChromaSiting & MHW_CHROMA_SITING_VERT_TOP)
424 {
425 Direction |= CHROMA_SITING_VDIRECTION_0;
426 }
427 else if (pRenderHalSurface->ChromaSiting & MHW_CHROMA_SITING_VERT_BOTTOM)
428 {
429 Direction |= CHROMA_SITING_VDIRECTION_1_2;
430 }
431 else
432 {
433 Direction |= CHROMA_SITING_VDIRECTION_1_4;
434 }
435 }
436 }
437 else
438 {
439 if (pRenderHalSurface->ChromaSiting & MHW_CHROMA_SITING_VERT_TOP)
440 {
441 Direction |= CHROMA_SITING_VDIRECTION_0;
442 }
443 else if (pRenderHalSurface->ChromaSiting & MHW_CHROMA_SITING_VERT_BOTTOM)
444 {
445 Direction |= CHROMA_SITING_VDIRECTION_1;
446 }
447 else
448 {
449 Direction |= CHROMA_SITING_VDIRECTION_1_2;
450 }
451 }
452
453 return Direction;
454 }
455
456 //!
457 //! \brief Initialize the State Heap Settings per platform
458 //! \param PRENDERHAL_STATE_HEAP_SETTINGS pSettings
459 //! [out] Pointer to PRENDERHAL_STATE_HEAP_SETTINGSStructure
460 //! \return void
461 //!
InitStateHeapSettings(PRENDERHAL_INTERFACE pRenderHal)462 void XRenderHal_Interface_g11::InitStateHeapSettings(
463 PRENDERHAL_INTERFACE pRenderHal)
464 {
465 MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pRenderHal);
466 // Set State Heap settings for g11
467 pRenderHal->StateHeapSettings = g_cRenderHal_State_Heap_Settings_g11;
468 }
469
470 //!
471 //! \brief Initialize the default surface type and advanced surface type per platform
472 //! \param PRENDERHAL_INTERFACE pRenderHal
473 //! [out] Pointer to PRENDERHAL_INTERFACE
474 //! \return void
475 //!
InitSurfaceTypes(PRENDERHAL_INTERFACE pRenderHal)476 void XRenderHal_Interface_g11::InitSurfaceTypes(
477 PRENDERHAL_INTERFACE pRenderHal)
478 {
479 MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pRenderHal);
480 // Set default / advanced surface types
481 pRenderHal->SurfaceTypeDefault = RENDERHAL_SURFACE_TYPE_G10;
482 pRenderHal->SurfaceTypeAdvanced = RENDERHAL_SURFACE_TYPE_ADV_G10;
483 }
484
485 //!
486 //! \brief Enables L3 cacheing flag and sets related registers/values
487 //! \param PRENDERHAL_INTERFACE pRenderHal
488 //! [in] Pointer to Hardware Interface
489 //! \param pCacheSettings
490 //! [in] L3 Cache Configurations
491 //! \return MOS_STATUS
492 //! MOS_STATUS_SUCCESS if success, else fail reason
493 //!
EnableL3Caching(PRENDERHAL_INTERFACE pRenderHal,PRENDERHAL_L3_CACHE_SETTINGS pCacheSettings)494 MOS_STATUS XRenderHal_Interface_g11::EnableL3Caching(
495 PRENDERHAL_INTERFACE pRenderHal,
496 PRENDERHAL_L3_CACHE_SETTINGS pCacheSettings)
497 {
498 MOS_STATUS eStatus;
499 MHW_RENDER_ENGINE_L3_CACHE_SETTINGS_G11 mHwL3CacheConfig = {};
500 PMHW_RENDER_ENGINE_L3_CACHE_SETTINGS pCacheConfig;
501 MhwRenderInterface *pMhwRender;
502 PRENDERHAL_INTERFACE_LEGACY pRenderHalLegacy = (PRENDERHAL_INTERFACE_LEGACY)pRenderHal;
503
504 MHW_RENDERHAL_CHK_NULL(pRenderHalLegacy);
505 pMhwRender = pRenderHalLegacy->pMhwRenderInterface;
506 MHW_RENDERHAL_CHK_NULL(pMhwRender);
507
508 if (nullptr == pCacheSettings)
509 {
510 MHW_RENDERHAL_CHK_STATUS(pMhwRender->EnableL3Caching(nullptr));
511 goto finish;
512 }
513
514 // customize the cache config for renderhal and let mhw_render overwrite it
515 pCacheConfig = &mHwL3CacheConfig;
516
517 pCacheConfig->dwCntlReg = RENDERHAL_L3_CACHE_CONFIG_CNTLREG_VALUE_G11_RENDERHAL;
518
519 // Override L3 cache configuration
520 if (pCacheSettings->bOverride)
521 {
522 if (pCacheSettings->bCntlRegOverride)
523 {
524 pCacheConfig->dwCntlReg = pCacheSettings->dwCntlReg;
525 }
526 }
527 MHW_RENDERHAL_CHK_STATUS(pMhwRender->EnableL3Caching(pCacheConfig));
528
529 finish:
530 return eStatus;
531 }
532
533 //!
534 //! \brief Get offset and/or pointer to sampler state
535 //! \details Get offset and/or pointer to sampler state in General State Heap
536 //! \param PRENDERHAL_INTERFACE pRenderHal
537 //! [in] Pointer to RenderHal Interface
538 //! \param int32_t iMediaID
539 //! [in] Media ID associated with sampler
540 //! \param int32_t iSamplerID
541 //! [in] Sampler ID
542 //! \param uint32_t *pdwSamplerOffset
543 //! [out] optional; offset of sampler state from GSH base
544 //! \param void **ppSampler
545 //! [out] optional; pointer to sampler state in GSH
546 //! \return MOS_STATUS
547 //!
GetSamplerOffsetAndPtr_DSH(PRENDERHAL_INTERFACE pRenderHal,int32_t iMediaID,int32_t iSamplerID,PMHW_SAMPLER_STATE_PARAM pSamplerParams,uint32_t * pdwSamplerOffset,void ** ppSampler)548 MOS_STATUS XRenderHal_Interface_g11::GetSamplerOffsetAndPtr_DSH(
549 PRENDERHAL_INTERFACE pRenderHal,
550 int32_t iMediaID,
551 int32_t iSamplerID,
552 PMHW_SAMPLER_STATE_PARAM pSamplerParams,
553 uint32_t *pdwSamplerOffset,
554 void **ppSampler)
555 {
556 PRENDERHAL_STATE_HEAP pStateHeap;
557 PRENDERHAL_DYNAMIC_STATE pDynamicState;
558 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
559 uint32_t dwSamplerIndirect;
560 uint32_t dwOffset;
561 MHW_SAMPLER_TYPE SamplerType;
562
563 MHW_RENDERHAL_CHK_NULL(pRenderHal);
564 MHW_RENDERHAL_CHK_NULL(pRenderHal->pStateHeap);
565 MHW_RENDERHAL_CHK_NULL(pRenderHal->pStateHeap->pCurMediaState);
566 MHW_RENDERHAL_CHK_NULL(pRenderHal->pHwSizes);
567
568 pStateHeap = pRenderHal->pStateHeap;
569 pDynamicState = ((PRENDERHAL_MEDIA_STATE_LEGACY)pStateHeap->pCurMediaState)->pDynamicState;
570
571 MHW_RENDERHAL_CHK_NULL(pDynamicState);
572
573 MHW_RENDERHAL_ASSERT(iMediaID < pDynamicState->MediaID.iCount);
574
575 dwOffset = iMediaID * pDynamicState->dwSizeSamplers; // Go to Media ID sampler offset
576
577 SamplerType = (pSamplerParams) ? pSamplerParams->SamplerType : MHW_SAMPLER_TYPE_3D;
578
579 switch (SamplerType)
580 {
581 case MHW_SAMPLER_TYPE_AVS:
582 MHW_RENDERHAL_ASSERT(iSamplerID < pDynamicState->SamplerAVS.iCount);
583 dwOffset += pDynamicState->SamplerAVS.dwOffset + // Go to AVS sampler area
584 iSamplerID * MHW_SAMPLER_STATE_AVS_INC_G11; // 16: size of one element, 128 elements for SKL
585 break;
586
587 case MHW_SAMPLER_TYPE_CONV:
588 MHW_RENDERHAL_ASSERT(iSamplerID < pDynamicState->SamplerConv.iCount);
589 dwOffset = pDynamicState->SamplerConv.dwOffset; // Goto Conv sampler base
590 if ( pSamplerParams->Convolve.ui8ConvolveType == 0 && pSamplerParams->Convolve.skl_mode )
591 { // 2D convolve
592 dwOffset += iSamplerID * MHW_SAMPLER_STATE_CONV_INC_G11; // 16: size of one element, 128 elements for SKL
593 }
594 else if ( pSamplerParams->Convolve.ui8ConvolveType == 1 )
595 { // 1D convolve
596 dwOffset += iSamplerID * MHW_SAMPLER_STATE_CONV_1D_INC; // 16: size of one element, 8 elements for SKL
597 }
598 else
599 { // 1P convolve (same as gen8) and 2D convolve BDW mode
600 dwOffset += iSamplerID * MHW_SAMPLER_STATE_CONV_INC_LEGACY; // 16: size of one element, 32: 32 entry
601 }
602 break;
603
604 case MHW_SAMPLER_TYPE_MISC:
605 MHW_RENDERHAL_ASSERT(iSamplerID < pDynamicState->SamplerMisc.iCount);
606 dwOffset += pDynamicState->Sampler3D.dwOffset + // Goto sampler base
607 iSamplerID * MHW_SAMPLER_STATE_VA_INC; // 16: size of one element, 2: 2 entries
608 break;
609
610 case MHW_SAMPLER_TYPE_3D:
611 case MHW_SAMPLER_TYPE_VME:
612 default:
613 MHW_RENDERHAL_ASSERT(iSamplerID < pDynamicState->Sampler3D.iCount);
614 dwSamplerIndirect = dwOffset;
615 dwOffset += pDynamicState->Sampler3D.dwOffset + // Go 3D Sampler base
616 iSamplerID * pRenderHal->pHwSizes->dwSizeSamplerState; // Goto to "samplerID" sampler state
617
618 if (pSamplerParams)
619 {
620 dwSamplerIndirect += pDynamicState->SamplerInd.dwOffset + // offset to indirect sampler area
621 iSamplerID * pRenderHal->pHwSizes->dwSizeSamplerIndirectState; // Goto to "samplerID" indirect state
622 pSamplerParams->Unorm.IndirectStateOffset = dwSamplerIndirect;
623 }
624
625 break;
626 }
627
628 if (pdwSamplerOffset)
629 {
630 *pdwSamplerOffset = dwOffset;
631 }
632
633 finish:
634 return eStatus;
635 }
636
637 //!
638 //! \brief Initialize the DSH Settings
639 //! \details Initialize the structure DynamicHeapSettings in pRenderHal
640 //! \param PRENDERHAL_INTERFACE pRenderHal
641 //! [in] Pointer to HW interface
642 //! \return void
643 //!
InitDynamicHeapSettings(PRENDERHAL_INTERFACE pRenderHal)644 void XRenderHal_Interface_g11::InitDynamicHeapSettings(
645 PRENDERHAL_INTERFACE pRenderHal)
646 {
647 PRENDERHAL_INTERFACE_LEGACY pRenderHalLegacy = static_cast<PRENDERHAL_INTERFACE_LEGACY>(pRenderHal);
648 MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pRenderHalLegacy);
649 // Additional Dynamic State Heap settings for g11
650 pRenderHalLegacy->DynamicHeapSettings = g_cRenderHal_DSH_Settings_g11;
651 }
652
653 //!
654 //! \brief Set Power Option Status
655 //! \param [in] pRenderHal
656 //! Pointer to Hardware Interface
657 //! \param [in/out] pCmdBuffer
658 //! Pointer to Command Buffer
659 //! \return MOS_STATUS
660 //! MOS_STATUS_SUCCESS if success, else fail reason
661 //!
SetPowerOptionStatus(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer)662 MOS_STATUS XRenderHal_Interface_g11::SetPowerOptionStatus(
663 PRENDERHAL_INTERFACE pRenderHal,
664 PMOS_COMMAND_BUFFER pCmdBuffer)
665 {
666 // deprecated after enabled per-context SSEU.
667 return MOS_STATUS_SUCCESS;
668 }
669
670 //!
671 //! \brief Set L3 cache override config parameters
672 //! \param [in] pRenderHal
673 //! Pointer to RenderHal Interface Structure
674 //! \param [in,out] pCacheSettings
675 //! Pointer to pCacheSettings
676 //! \param [in] bEnableSLM
677 //! Flag to enable SLM
678 //! \return MOS_STATUS
679 //! MOS_STATUS_SUCCESS if success. Error code otherwise
680 //!
SetCacheOverrideParams(PRENDERHAL_INTERFACE pRenderHal,PRENDERHAL_L3_CACHE_SETTINGS pCacheSettings,bool bEnableSLM)681 MOS_STATUS XRenderHal_Interface_g11::SetCacheOverrideParams(
682 PRENDERHAL_INTERFACE pRenderHal,
683 PRENDERHAL_L3_CACHE_SETTINGS pCacheSettings,
684 bool bEnableSLM)
685 {
686 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
687
688 MHW_RENDERHAL_CHK_NULL(pCacheSettings);
689
690 pCacheSettings->dwCntlReg = RENDERHAL_L3_CACHE_CONFIG_CNTLREG_VALUE_G11_RENDERHAL;
691 pCacheSettings->bCntlRegOverride = true;
692
693 finish:
694 return eStatus;
695 }
696
697 //!
698 //! \brief Check if Override is needed or not
699 //! \param [in] pRenderHal
700 //! Pointer to Hardware Interface
701 //! \param [in,out] pCmdBuffer
702 //! Pointer to Command Buffer
703 //! \param [in] pGenericPrologParam
704 //! Pointer to MHW generic prolog parameters
705 //! \return MOS_STATUS
706 //! MOS_STATUS_SUCCESS if success, else fail reason
707 //!
IsOvrdNeeded(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer,PRENDERHAL_GENERIC_PROLOG_PARAMS pGenericPrologParams)708 MOS_STATUS XRenderHal_Interface_g11::IsOvrdNeeded(
709 PRENDERHAL_INTERFACE pRenderHal,
710 PMOS_COMMAND_BUFFER pCmdBuffer,
711 PRENDERHAL_GENERIC_PROLOG_PARAMS pGenericPrologParams)
712 {
713 PMOS_INTERFACE pOsInterface;
714 MOS_STATUS eStatus;
715 PMOS_CMD_BUF_ATTRI_VE pAttriVe;
716 PRENDERHAL_GENERIC_PROLOG_PARAMS_G11 pGenericPrologParamsG11;
717
718 MHW_RENDERHAL_CHK_NULL(pRenderHal);
719 MHW_RENDERHAL_CHK_NULL(pCmdBuffer);
720 MHW_RENDERHAL_CHK_NULL(pRenderHal->pOsInterface);
721
722 eStatus = MOS_STATUS_SUCCESS;
723 pOsInterface = pRenderHal->pOsInterface;
724 pAttriVe = (PMOS_CMD_BUF_ATTRI_VE)(pCmdBuffer->Attributes.pAttriVe);
725 pGenericPrologParamsG11 = dynamic_cast<PRENDERHAL_GENERIC_PROLOG_PARAMS_G11>(pGenericPrologParams);
726
727 if (pAttriVe)
728 {
729 if (pGenericPrologParamsG11)
730 {
731 // Split Frame
732 if (pGenericPrologParamsG11->VEngineHintParams.BatchBufferCount == 2 && pOsInterface->VEEnable)
733 {
734 pAttriVe->bUseVirtualEngineHint = true;
735 pAttriVe->VEngineHintParams = pGenericPrologParamsG11->VEngineHintParams;
736 }
737 }
738
739 #if (_DEBUG || _RELEASE_INTERNAL)
740 if (pOsInterface->bEnableDbgOvrdInVE)
741 {
742 if (pOsInterface->bVeboxScalabilityMode)
743 {
744 pAttriVe->VEngineHintParams.DebugOverride = true;
745 pAttriVe->VEngineHintParams.BatchBufferCount = 2;
746 pAttriVe->VEngineHintParams.EngineInstance[0] = 0;
747 pAttriVe->VEngineHintParams.EngineInstance[1] = 1;
748 }
749 else if (pOsInterface->eForceVebox)
750 {
751 pAttriVe->VEngineHintParams.DebugOverride = true;
752 pAttriVe->VEngineHintParams.BatchBufferCount = 1;
753 pAttriVe->VEngineHintParams.EngineInstance[0] = pOsInterface->eForceVebox - 1;
754 }
755 }
756 #endif
757 }
758
759 finish:
760 return eStatus;
761 };
762
763 //! \brief Get the size of Render Surface State Command
764 //! \return size_t
765 //! the size of render surface state command
GetSurfaceStateCmdSize()766 size_t XRenderHal_Interface_g11::GetSurfaceStateCmdSize()
767 {
768 return MOS_ALIGN_CEIL( MOS_MAX(mhw_state_heap_g11_X::RENDER_SURFACE_STATE_CMD::byteSize,
769 mhw_state_heap_g11_X::MEDIA_SURFACE_STATE_CMD::byteSize), MHW_SURFACE_STATE_ALIGN);
770 }
771
772