1 /*
2 * Copyright (c) 2012-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_g9.cpp
24 //! \brief implementation of Gen9 hardware functions
25 //! \details Render functions
26 //!
27
28 #include "mos_os.h"
29 #include "renderhal_legacy.h"
30 #include "renderhal_g9.h"
31 #include "mhw_state_heap_g9.h"
32
33 #define RENDERHAL_NS_PER_TICK_RENDER_G9 (83.333) // For SKL, 83.333 nano seconds per tick in render engine
34 #define RENDERHAL_NS_PER_TICK_RENDER_G9LP (52.083) //For BXT, 52.083 nano seconds per tick in render engine
35
36 //!
37 //! \brief GSH settings for G9
38 //!
39 const RENDERHAL_STATE_HEAP_SETTINGS g_cRenderHal_State_Heap_Settings_g9 =
40 {
41 // Global GSH Allocation parameters
42 RENDERHAL_SYNC_SIZE, //!< iSyncSize
43
44 // Media State Allocation parameters
45 RENDERHAL_MEDIA_STATES, //!< iMediaStateHeaps - Set by Initialize
46 RENDERHAL_MEDIA_IDS, //!< iMediaIDs
47 RENDERHAL_CURBE_SIZE, //!< iCurbeSize
48 RENDERHAL_SAMPLERS, //!< iSamplers
49 RENDERHAL_SAMPLERS_AVS_G9, //!< iSamplersAVS
50 RENDERHAL_SAMPLERS_VA, //!< iSamplersVA
51 RENDERHAL_KERNEL_COUNT, //!< iKernelCount
52 RENDERHAL_KERNEL_HEAP, //!< iKernelHeapSize
53 RENDERHAL_KERNEL_BLOCK_SIZE, //!< iKernelBlockSize
54
55 // Media VFE/ID configuration, limits
56 0, //!< iPerThreadScratchSize
57 RENDERHAL_MAX_SIP_SIZE, //!< iSipSize
58
59 // Surface State Heap Settings
60 RENDERHAL_SSH_INSTANCES, //!< iSurfaceStateHeaps
61 RENDERHAL_SSH_BINDING_TABLES, //!< iBindingTables
62 RENDERHAL_SSH_SURFACE_STATES, //!< iSurfaceStates
63 RENDERHAL_SSH_SURFACES_PER_BT, //!< iSurfacesPerBT
64 RENDERHAL_SSH_BINDING_TABLE_ALIGN //!< iBTAlignment
65 };
66
67 const uint32_t g_cLookup_RotationMode_g9[8] =
68 {
69 ROTATION_IDENTITY, // 0 - MHW_ROTATION_IDENTITY
70 ROTATION_90, // 1 - MHW_ROTATION_90
71 ROTATION_180, // 2 - MHW_ROTATION_180
72 ROTATION_270, // 3 - MHW_ROTATION_270
73 ROTATION_IDENTITY, // 4 - MHW_MIRROR_HORIZONTAL
74 ROTATION_180, // 5 - MHW_MIRROR_VERTICAL
75 ROTATION_270, // 6 - MHW_ROTATE_90_MIRROR_VERTICAL
76 ROTATION_90 // 7 - MHW_ROTATE_90_MIRROR_HORIZONTAL
77 };
78
79 //!
80 //! DSH State Heap settings for G9
81 //!
82 const RENDERHAL_DYN_HEAP_SETTINGS g_cRenderHal_DSH_Settings_g9 =
83 {
84 0x0080000, // dwDshInitialSize = 512kB
85 0x0080000, // dwDshSizeIncrement = 512kB
86 0x8000000, // dwDshMaximumSize = 128MB
87 0x0040000, // dwIshInitialSize = 256kB
88 0x0040000, // dwIshSizeIncrement = 256kB
89 0x0400000, // dwIshMaximumSize = 4MB
90 16, // iMinMediaStates
91 1024, // iMaxMediaStates
92 16, // iMinKernels
93 1024 // iMaxKernels
94 };
95
96 //!
97 //! \brief Setup Surface State
98 //! \details Setup Surface State for Gen9
99 //! \param PRENDERHAL_INTERFACE pRenderHal
100 //! [in] Pointer to Hardware Interface Structure
101 //! \param PRENDERHAL_SURFACE pRenderHalSurface
102 //! [in] Pointer to Render Hal Surface
103 //! \param PRENDERHAL_SURFACE_STATE_PARAMS pParams
104 //! [in] Pointer to Surface State Params
105 //! \param int32_t *piNumEntries
106 //! [out] Pointer to Number of Surface State Entries (Num Planes)
107 //! \param PRENDERHAL_SURFACE_STATE_ENTRY * ppSurfaceEntries
108 //! [out] Array of Surface State Entries
109 //! \param PRENDERHAL_OFFSET_OVERRIDE pOffsetOverride
110 //! [in] Ignored (not used in Gen9)
111 //! \return MOS_STATUS
112 //!
SetupSurfaceState(PRENDERHAL_INTERFACE pRenderHal,PRENDERHAL_SURFACE pRenderHalSurface,PRENDERHAL_SURFACE_STATE_PARAMS pParams,int32_t * piNumEntries,PRENDERHAL_SURFACE_STATE_ENTRY * ppSurfaceEntries,PRENDERHAL_OFFSET_OVERRIDE pOffsetOverride)113 MOS_STATUS XRenderHal_Interface_g9::SetupSurfaceState (
114 PRENDERHAL_INTERFACE pRenderHal,
115 PRENDERHAL_SURFACE pRenderHalSurface,
116 PRENDERHAL_SURFACE_STATE_PARAMS pParams,
117 int32_t *piNumEntries,
118 PRENDERHAL_SURFACE_STATE_ENTRY *ppSurfaceEntries,
119 PRENDERHAL_OFFSET_OVERRIDE pOffsetOverride)
120 {
121 PRENDERHAL_SURFACE_STATE_ENTRY pSurfaceEntry;
122 PMOS_PLANE_OFFSET pPlaneOffset;
123 MHW_SURFACE_STATE_PARAMS SurfStateParams;
124 PMOS_SURFACE pSurface;
125 int32_t i;
126 uint32_t dwPixelsPerSampleUV;
127 uint32_t dwSurfaceSize;
128 MOS_STATUS eStatus = MOS_STATUS_UNKNOWN;
129
130 //-----------------------------------------
131 MHW_RENDERHAL_UNUSED(pOffsetOverride);
132 MHW_RENDERHAL_CHK_NULL(pRenderHal);
133 MHW_RENDERHAL_CHK_NULL(pRenderHalSurface);
134 MHW_RENDERHAL_CHK_NULL(pParams);
135 MHW_RENDERHAL_CHK_NULL(ppSurfaceEntries);
136 MHW_RENDERHAL_CHK_NULL(pRenderHal->pStateHeap);
137 MHW_RENDERHAL_CHK_NULL(pRenderHal->pHwSizes);
138 MHW_RENDERHAL_CHK_NULL(pRenderHal->pMhwStateHeap);
139 MHW_RENDERHAL_ASSERT(pRenderHalSurface->Rotation >= MHW_ROTATION_IDENTITY &&
140 pRenderHalSurface->Rotation <= MHW_ROTATE_90_MIRROR_HORIZONTAL);
141 //-----------------------------------------
142
143 dwSurfaceSize = pRenderHal->pHwSizes->dwSizeSurfaceState;
144
145 MOS_ZeroMemory(&SurfStateParams, sizeof(SurfStateParams));
146
147 // Get the Surface State Entries
148 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pfnGetSurfaceStateEntries(
149 pRenderHal,
150 pRenderHalSurface,
151 pParams,
152 piNumEntries,
153 ppSurfaceEntries));
154
155 for (i = 0; i < *piNumEntries; i++)
156 {
157 // Pointer to surface state entry for current plane
158 pSurfaceEntry = ppSurfaceEntries[i];
159
160 pSurface = pSurfaceEntry->pSurface;
161
162 // Set the Surface State Offset from base of SSH
163 pSurfaceEntry->dwSurfStateOffset = pRenderHal->pStateHeap->iSurfaceStateOffset + // Offset to Base Of Current Surface State Area
164 pSurfaceEntry->iSurfStateID * dwSurfaceSize; // Offset to Surface State within the area
165
166 // Obtain the Pointer to the Surface state from SSH Buffer
167 SurfStateParams.pSurfaceState = pSurfaceEntry->pSurfaceState;
168 SurfStateParams.bUseAdvState = pSurfaceEntry->bAVS;
169 SurfStateParams.dwWidth = pSurfaceEntry->dwWidth;
170 SurfStateParams.dwHeight = pSurfaceEntry->dwHeight;
171 SurfStateParams.dwFormat = pSurfaceEntry->dwFormat;
172 SurfStateParams.dwPitch = pSurfaceEntry->dwPitch;
173 SurfStateParams.dwQPitch = pSurfaceEntry->dwQPitch;
174 SurfStateParams.bTiledSurface = pSurfaceEntry->bTiledSurface;
175 SurfStateParams.bTileWalk = pSurfaceEntry->bTileWalk;
176 SurfStateParams.dwCacheabilityControl = pRenderHal->pfnGetSurfaceMemoryObjectControl(pRenderHal, pParams);
177 SurfStateParams.bCompressionEnabled = pSurface->bIsCompressed;
178 SurfStateParams.bCompressionMode = (pSurface->CompressionMode == MOS_MMC_VERTICAL) ? 1 : 0;
179 SurfStateParams.RotationMode = g_cLookup_RotationMode_g9[pRenderHalSurface->Rotation];
180
181 if (pSurfaceEntry->bAVS)
182 {
183 SurfStateParams.bHalfPitchChroma = pSurfaceEntry->bHalfPitchChroma;
184 SurfStateParams.bInterleaveChroma = pSurfaceEntry->bInterleaveChroma;
185 SurfStateParams.UVPixelOffsetUDirection = pSurfaceEntry->DirectionU;
186 SurfStateParams.UVPixelOffsetVDirection = pSurfaceEntry->DirectionV;
187
188 // On SNB+, when VDI Walker is enabled, Input surface width should be 16 pixel aligned
189 if (pParams->bWidth16Align)
190 {
191 SurfStateParams.dwWidth = MOS_ALIGN_CEIL(pSurfaceEntry->dwWidth, 16);
192 }
193
194 if (pSurfaceEntry->YUVPlane == MHW_U_PLANE) // AVS U plane
195 {
196 // Lockoffset is the offset from base address of Y plane to the origin of U/V plane.
197 // So, We can get XOffsetforU by Lockoffset % pSurface->dwPitch, and get YOffsetForU by Lockoffset / pSurface->dwPitch
198 SurfStateParams.dwXOffsetForU = (uint32_t)pSurface->UPlaneOffset.iLockSurfaceOffset % pSurface->dwPitch;
199 SurfStateParams.dwYOffsetForU = (uint32_t)pSurface->UPlaneOffset.iLockSurfaceOffset / pSurface->dwPitch;
200 SurfStateParams.dwXOffsetForV = 0;
201 SurfStateParams.dwYOffsetForV = 0;
202 SurfStateParams.iXOffset = pSurface->UPlaneOffset.iXOffset;
203 SurfStateParams.iYOffset = pSurface->UPlaneOffset.iYOffset;
204 }
205 else if (pSurfaceEntry->YUVPlane == MHW_V_PLANE) // AVS V plane
206 {
207 SurfStateParams.dwXOffsetForU = 0;
208 SurfStateParams.dwYOffsetForU = 0;
209 SurfStateParams.dwXOffsetForV = (uint32_t)pSurface->VPlaneOffset.iLockSurfaceOffset % pSurface->dwPitch;
210 SurfStateParams.dwYOffsetForV = (uint32_t)pSurface->VPlaneOffset.iLockSurfaceOffset / pSurface->dwPitch;
211 SurfStateParams.iXOffset = pSurface->VPlaneOffset.iXOffset;
212 SurfStateParams.iYOffset = pSurface->VPlaneOffset.iYOffset;
213 }
214 else // AVS/DNDI Y plane
215 {
216 SurfStateParams.dwXOffsetForU = pSurfaceEntry->wUXOffset;
217 SurfStateParams.dwYOffsetForU = pSurfaceEntry->wUYOffset;
218 SurfStateParams.dwXOffsetForV = pSurfaceEntry->wVXOffset;
219 SurfStateParams.dwYOffsetForV = pSurfaceEntry->wVYOffset;
220 SurfStateParams.iXOffset = 0;
221 SurfStateParams.iYOffset = pSurface->YPlaneOffset.iYOffset;
222 }
223 if (pRenderHalSurface->bInterlacedScaling)
224 {
225 SurfStateParams.bVerticalLineStrideOffset = pSurfaceEntry->bVertStrideOffs;
226 SurfStateParams.bVerticalLineStride = pSurfaceEntry->bVertStride;
227 }
228 }
229 else // 2D/3D Surface (non-AVS)
230 {
231 SurfStateParams.SurfaceType3D = (pSurface->dwDepth > 1) ?
232 GFX3DSTATE_SURFACETYPE_3D :
233 GFX3DSTATE_SURFACETYPE_2D;
234 SurfStateParams.dwDepth = MOS_MAX(1, pSurface->dwDepth);
235 SurfStateParams.bVerticalLineStrideOffset = pSurfaceEntry->bVertStrideOffs;
236 SurfStateParams.bVerticalLineStride = pSurfaceEntry->bVertStride;
237 SurfStateParams.bHalfPitchChroma = pSurfaceEntry->bHalfPitchChroma;
238
239 // Setup surface g9 surface state
240 if (pSurfaceEntry->YUVPlane == MHW_U_PLANE ||
241 pSurfaceEntry->YUVPlane == MHW_V_PLANE)
242 {
243 pPlaneOffset = (pSurfaceEntry->YUVPlane == MHW_U_PLANE) ?
244 &pSurface->UPlaneOffset : &pSurface->VPlaneOffset;
245
246 // Get Pixels Per Sample if we use dataport read
247 if(pParams->bWidthInDword_UV)
248 {
249 RenderHal_GetPixelsPerSample(pSurface->Format, &dwPixelsPerSampleUV);
250 }
251 else
252 {
253 // If the kernel uses sampler - do not change width (it affects coordinates)
254 dwPixelsPerSampleUV = 1;
255 }
256
257 if(dwPixelsPerSampleUV == 1)
258 {
259 SurfStateParams.iXOffset = pPlaneOffset->iXOffset;
260 }
261 else
262 {
263 SurfStateParams.iXOffset = pPlaneOffset->iXOffset/sizeof(uint32_t);
264 }
265
266 SurfStateParams.iYOffset = pPlaneOffset->iYOffset;
267 }
268 else // Y plane
269 {
270 pPlaneOffset = &pSurface->YPlaneOffset;
271
272 SurfStateParams.iXOffset = pPlaneOffset->iXOffset/sizeof(uint32_t);
273 SurfStateParams.iYOffset = pPlaneOffset->iYOffset;
274
275 if((pSurfaceEntry->YUVPlane == MHW_Y_PLANE) &&
276 (pSurfaceEntry->dwFormat == MHW_GFX3DSTATE_SURFACEFORMAT_PLANAR_420_8))
277 {
278 if (pSurface->Format == Format_YV12)
279 {
280 SurfStateParams.bSeperateUVPlane = true;
281 SurfStateParams.dwXOffsetForU = 0;
282 SurfStateParams.dwYOffsetForU = pSurface->dwHeight * 2 + pSurface->dwHeight / 2;
283 SurfStateParams.dwXOffsetForV = 0;
284 SurfStateParams.dwYOffsetForV = pSurface->dwHeight * 2;
285 }
286 else
287 {
288 SurfStateParams.bSeperateUVPlane = false;
289 SurfStateParams.dwXOffsetForU = 0;
290 SurfStateParams.dwYOffsetForU = (uint32_t)((pSurface->UPlaneOffset.iSurfaceOffset - pSurface->YPlaneOffset.iSurfaceOffset) / pSurface->dwPitch) + pSurface->UPlaneOffset.iYOffset;
291 SurfStateParams.dwXOffsetForV = 0;
292 SurfStateParams.dwYOffsetForV = 0;
293 }
294 }
295 }
296 }
297
298 // Call MHW to setup the Surface State Heap entry
299 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwStateHeap->SetSurfaceStateEntry(&SurfStateParams));
300
301 // Setup OS specific states
302 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pfnSetupSurfaceStatesOs(pRenderHal, pParams, pSurfaceEntry));
303 }
304
305 eStatus = MOS_STATUS_SUCCESS;
306
307 finish:
308 return eStatus;
309 }
310
311 //!
312 //! \brief Encode SLM Size for Interface Descriptor
313 //! \details Setup SLM size
314 //! \param uint32_t SLMSize
315 //! [in] SLM size in 1K
316 //! \return encoded output
317 //!
EncodeSLMSize(uint32_t SLMSize)318 uint32_t XRenderHal_Interface_g9::EncodeSLMSize(uint32_t SLMSize)
319 {
320 uint32_t EncodedValue;
321 if (SLMSize <= 2)
322 EncodedValue = SLMSize;
323 else
324 {
325 EncodedValue = 0;
326 do
327 {
328 SLMSize >>= 1;
329 EncodedValue++;
330 } while (SLMSize);
331 }
332 return EncodedValue;
333 }
334
335 //!
336 //! \brief Setup Chroma direction for Gen9
337 //! \details Setup Chroma direction
338 //! \param PRENDERHAL_INTERFACE pRenderHal
339 //! [in] Pointer to RenderHal Interface
340 //! \param PRENDERHAL_SURFACE pRenderHalSurface
341 //! [in] Pointer to RenderHal Surface
342 //! \return uint8_t
343 //!
SetChromaDirection(PRENDERHAL_INTERFACE pRenderHal,PRENDERHAL_SURFACE pRenderHalSurface)344 uint8_t XRenderHal_Interface_g9::SetChromaDirection(
345 PRENDERHAL_INTERFACE pRenderHal,
346 PRENDERHAL_SURFACE pRenderHalSurface)
347 {
348 MHW_RENDERHAL_UNUSED(pRenderHal);
349 uint8_t Direction;
350
351 MHW_RENDERHAL_ASSERT(pRenderHal);
352 MHW_RENDERHAL_ASSERT(pRenderHalSurface);
353
354 Direction = 0;
355
356 if (pRenderHalSurface->ChromaSiting & MHW_CHROMA_SITING_HORZ_CENTER)
357 {
358 Direction = CHROMA_SITING_UDIRECTION_CENTER;
359 }
360 else
361 {
362 Direction = CHROMA_SITING_UDIRECTION_LEFT;
363 }
364
365 // Combined U/V direction together in one uint8_t, 1 bit for U direction, 3 bits for V direction.
366 Direction = Direction << 3;
367
368 if (pRenderHalSurface->pDeinterlaceParams || pRenderHalSurface->bQueryVariance)
369 {
370 if ((pRenderHalSurface->SampleType == RENDERHAL_SAMPLE_INTERLEAVED_EVEN_FIRST_BOTTOM_FIELD) ||
371 (pRenderHalSurface->SampleType == RENDERHAL_SAMPLE_INTERLEAVED_ODD_FIRST_BOTTOM_FIELD))
372 {
373 if (pRenderHalSurface->ChromaSiting & MHW_CHROMA_SITING_VERT_TOP)
374 {
375 Direction |= CHROMA_SITING_VDIRECTION_1_2;
376 }
377 else if (pRenderHalSurface->ChromaSiting & MHW_CHROMA_SITING_VERT_BOTTOM)
378 {
379 Direction |= CHROMA_SITING_VDIRECTION_1;
380 }
381 else
382 {
383 Direction |= CHROMA_SITING_VDIRECTION_3_4;
384 }
385 }
386 else if ((pRenderHalSurface->SampleType == RENDERHAL_SAMPLE_INTERLEAVED_EVEN_FIRST_TOP_FIELD) ||
387 (pRenderHalSurface->SampleType == RENDERHAL_SAMPLE_INTERLEAVED_ODD_FIRST_TOP_FIELD))
388 {
389 if (pRenderHalSurface->ChromaSiting & MHW_CHROMA_SITING_VERT_TOP)
390 {
391 Direction |= CHROMA_SITING_VDIRECTION_0;
392 }
393 else if (pRenderHalSurface->ChromaSiting & MHW_CHROMA_SITING_VERT_BOTTOM)
394 {
395 Direction |= CHROMA_SITING_VDIRECTION_1_2;
396 }
397 else
398 {
399 Direction |= CHROMA_SITING_VDIRECTION_1_4;
400 }
401 }
402 }
403 else
404 {
405 if (pRenderHalSurface->ChromaSiting & MHW_CHROMA_SITING_VERT_TOP)
406 {
407 Direction |= CHROMA_SITING_VDIRECTION_0;
408 }
409 else if (pRenderHalSurface->ChromaSiting & MHW_CHROMA_SITING_VERT_BOTTOM)
410 {
411 Direction |= CHROMA_SITING_VDIRECTION_1;
412 }
413 else
414 {
415 Direction |= CHROMA_SITING_VDIRECTION_1_2;
416 }
417 }
418
419 return Direction;
420 }
421
422 //!
423 //! \brief Convert To Nano Seconds
424 //! \details Convert to Nano Seconds
425 //! \param PRENDERHAL_INTERFACE pRenderHal
426 //! [in] Pointer to Hardware Interface Structure
427 //! \param uint64_t iTicks
428 //! [in] Ticks
429 //! \param uint64_t *piNs
430 //! [in] Nano Seconds
431 //! \return void
432 //!
ConvertToNanoSeconds(PRENDERHAL_INTERFACE pRenderHal,uint64_t iTicks,uint64_t * piNs)433 void XRenderHal_Interface_g9::ConvertToNanoSeconds(
434 PRENDERHAL_INTERFACE pRenderHal,
435 uint64_t iTicks,
436 uint64_t *piNs)
437 {
438 //-----------------------------
439 MHW_RENDERHAL_UNUSED(pRenderHal);
440 MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pRenderHal);
441 MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(piNs);
442 //-----------------------------
443 if (GFX_IS_PRODUCT(pRenderHal->Platform, IGFX_BROXTON))
444 {
445 *piNs = (uint64_t)(iTicks * RENDERHAL_NS_PER_TICK_RENDER_G9LP);
446 }
447 else
448 {
449 *piNs = (uint64_t)(iTicks * RENDERHAL_NS_PER_TICK_RENDER_G9);
450 }
451 }
452
453 //!
454 //! \brief Initialize the State Heap Settings per platform
455 //! \param PRENDERHAL_STATE_HEAP_SETTINGS pSettings
456 //! [out] Pointer to PRENDERHAL_STATE_HEAP_SETTINGSStructure
457 //! \return void
458 //!
InitStateHeapSettings(PRENDERHAL_INTERFACE pRenderHal)459 void XRenderHal_Interface_g9::InitStateHeapSettings(
460 PRENDERHAL_INTERFACE pRenderHal)
461 {
462 MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pRenderHal);
463 // Set State Heap settings for g9
464 pRenderHal->StateHeapSettings = g_cRenderHal_State_Heap_Settings_g9;
465 }
466
467 //!
468 //! \brief Initialize the default surface type and advanced surface type per platform
469 //! \param PRENDERHAL_INTERFACE pRenderHal
470 //! [out] Pointer to PRENDERHAL_INTERFACE
471 //! \return void
472 //!
InitSurfaceTypes(PRENDERHAL_INTERFACE pRenderHal)473 void XRenderHal_Interface_g9::InitSurfaceTypes(
474 PRENDERHAL_INTERFACE pRenderHal)
475 {
476 MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pRenderHal);
477 // Set default / advanced surface types
478 pRenderHal->SurfaceTypeDefault = RENDERHAL_SURFACE_TYPE_G9;
479 pRenderHal->SurfaceTypeAdvanced = RENDERHAL_SURFACE_TYPE_ADV_G9;
480 }
481
482 //!
483 //! \brief Enables L3 cacheing flag and sets related registers/values
484 //! \param PRENDERHAL_INTERFACE pRenderHal
485 //! [in] Pointer to Hardware Interface
486 //! \param pCacheSettings
487 //! [in] L3 Cache Configurations
488 //! \return MOS_STATUS
489 //! MOS_STATUS_SUCCESS if success, else fail reason
490 //!
EnableL3Caching(PRENDERHAL_INTERFACE pRenderHal,PRENDERHAL_L3_CACHE_SETTINGS pCacheSettings)491 MOS_STATUS XRenderHal_Interface_g9::EnableL3Caching(
492 PRENDERHAL_INTERFACE pRenderHal,
493 PRENDERHAL_L3_CACHE_SETTINGS pCacheSettings)
494 {
495 MOS_STATUS eStatus;
496 MHW_RENDER_ENGINE_L3_CACHE_SETTINGS mHwL3CacheConfig = {};
497 PMHW_RENDER_ENGINE_L3_CACHE_SETTINGS pCacheConfig;
498 MhwRenderInterface *pMhwRender;
499 PRENDERHAL_INTERFACE_LEGACY pRenderHalLegacy = (PRENDERHAL_INTERFACE_LEGACY)pRenderHal;
500
501 MHW_RENDERHAL_CHK_NULL(pRenderHalLegacy);
502 pMhwRender = pRenderHalLegacy->pMhwRenderInterface;
503 MHW_RENDERHAL_CHK_NULL(pMhwRender);
504
505 if (nullptr == pCacheSettings)
506 {
507 MHW_RENDERHAL_CHK_STATUS(pMhwRender->EnableL3Caching(nullptr));
508 goto finish;
509 }
510
511 // customize the cache config for renderhal and let mhw_render overwrite it
512 pCacheConfig = &mHwL3CacheConfig;
513
514 if (pCacheSettings->bEnableSLM)
515 pCacheConfig->dwCntlReg = RENDERHAL_L3_CACHE_SLM_CONFIG_CNTLREG_VALUE_G9_RENDERHAL;
516 else
517 pCacheConfig->dwCntlReg = RENDERHAL_L3_CACHE_CONFIG_CNTLREG_VALUE_G9_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_g9::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_G9; // 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_G9; // 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_g9::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 g9
650 pRenderHalLegacy->DynamicHeapSettings = g_cRenderHal_DSH_Settings_g9;
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_g9::SetPowerOptionStatus(
663 PRENDERHAL_INTERFACE pRenderHal,
664 PMOS_COMMAND_BUFFER pCmdBuffer)
665 {
666 PMOS_INTERFACE pOsInterface;
667 MOS_STATUS eStatus;
668 MEDIA_SYSTEM_INFO *pGtSystemInfo;
669
670 MHW_RENDERHAL_CHK_NULL(pRenderHal);
671 MHW_RENDERHAL_CHK_NULL(pCmdBuffer);
672 MHW_RENDERHAL_CHK_NULL(pRenderHal->pOsInterface);
673
674 eStatus = MOS_STATUS_SUCCESS;
675 pOsInterface = pRenderHal->pOsInterface;
676 pGtSystemInfo = pOsInterface->pfnGetGtSystemInfo(pOsInterface);
677 MHW_RENDERHAL_CHK_NULL(pGtSystemInfo);
678
679 // Check if Slice Shutdown can be enabled
680 if (pRenderHal->bRequestSingleSlice)
681 {
682 pCmdBuffer->Attributes.dwNumRequestedEUSlices = 1;
683 }
684 else if (pRenderHal->bEUSaturationNoSSD)
685 {
686 pCmdBuffer->Attributes.dwNumRequestedEUSlices = 2;
687 }
688
689 if ((pRenderHal->pSkuTable) && MEDIA_IS_SKU(pRenderHal->pSkuTable, FtrSSEUPowerGating))
690 {
691 // VP does not request subslice shutdown according to the array VpHalDefaultSSEUTableGxx
692 if (((pRenderHal->PowerOption.nSlice != 0) || (pRenderHal->PowerOption.nSubSlice != 0) || (pRenderHal->PowerOption.nEU != 0)) &&
693 ((pGtSystemInfo->SliceCount != 0) && (pGtSystemInfo->SubSliceCount != 0)))
694 {
695 pCmdBuffer->Attributes.dwNumRequestedEUSlices = MOS_MIN(pRenderHal->PowerOption.nSlice, pGtSystemInfo->SliceCount);
696 pCmdBuffer->Attributes.dwNumRequestedSubSlices = MOS_MIN(pRenderHal->PowerOption.nSubSlice, (pGtSystemInfo->SubSliceCount / pGtSystemInfo->SliceCount));
697 pCmdBuffer->Attributes.dwNumRequestedEUs = MOS_MIN(pRenderHal->PowerOption.nEU, (pGtSystemInfo->EUCount / pGtSystemInfo->SubSliceCount));
698 pCmdBuffer->Attributes.bValidPowerGatingRequest = true;
699
700 if (GFX_IS_PRODUCT(pRenderHal->Platform, IGFX_SKYLAKE) && pOsInterface->pfnSetSliceCount)
701 {
702 uint32_t sliceCount = pCmdBuffer->Attributes.dwNumRequestedEUSlices;
703 pOsInterface->pfnSetSliceCount(pOsInterface, &sliceCount);
704 }
705 }
706 }
707
708 finish:
709 return eStatus;
710 }
711
712 //!
713 //! \brief Set L3 cache override config parameters
714 //! \param [in] pRenderHal
715 //! Pointer to RenderHal Interface Structure
716 //! \param [in,out] pCacheSettings
717 //! Pointer to pCacheSettings
718 //! \param [in] bEnableSLM
719 //! Flag to enable SLM
720 //! \return MOS_STATUS
721 //! MOS_STATUS_SUCCESS if success. Error code otherwise
722 //!
SetCacheOverrideParams(PRENDERHAL_INTERFACE pRenderHal,PRENDERHAL_L3_CACHE_SETTINGS pCacheSettings,bool bEnableSLM)723 MOS_STATUS XRenderHal_Interface_g9::SetCacheOverrideParams(
724 PRENDERHAL_INTERFACE pRenderHal,
725 PRENDERHAL_L3_CACHE_SETTINGS pCacheSettings,
726 bool bEnableSLM)
727 {
728 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
729
730 MHW_RENDERHAL_CHK_NULL(pRenderHal);
731 MHW_RENDERHAL_CHK_NULL(pCacheSettings);
732
733 if (bEnableSLM)
734 {
735 pCacheSettings->dwCntlReg = RENDERHAL_L3_CACHE_CNTL_REG_SLM_ENABLE_G9;
736 }
737 else
738 {
739 pCacheSettings->dwCntlReg = RENDERHAL_L3_CACHE_CNTL_REG_SLM_DISABLE_ALL_L3_512K_G9;
740 }
741 pCacheSettings->bCntlRegOverride = true;
742
743 finish:
744 return eStatus;
745 }
746
747 //! \brief Get the size of Render Surface State Command
748 //! \return size_t
749 //! the size of render surface state command
GetSurfaceStateCmdSize()750 size_t XRenderHal_Interface_g9::GetSurfaceStateCmdSize()
751 {
752 return MOS_ALIGN_CEIL( MOS_MAX(mhw_state_heap_g9_X::RENDER_SURFACE_STATE_CMD::byteSize,
753 mhw_state_heap_g9_X::MEDIA_SURFACE_STATE_CMD::byteSize), MHW_SURFACE_STATE_ALIGN);
754 }
755
756