1 /*
2 * Copyright (c) 2011-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_g8.cpp
24 //! \brief implementation of Gen8 hardware functions
25 //! \details render functions
26 //!
27 #include "mos_os.h"
28 #include "renderhal_legacy.h"
29 #include "renderhal_g8.h"
30
31 //!
32 //! \brief State Heap Settings for G8
33 //!
34 const RENDERHAL_STATE_HEAP_SETTINGS g_cRenderHal_State_Heap_Settings_g8 =
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_G8, //!< 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 #define RENDERHAL_NS_PER_TICK_RENDER_G8 80 // Prior to Skylake, 80 nano seconds per tick in render engine
63
64 //!
65 //! DSH State Heap settings for G8
66 //!
67 const RENDERHAL_DYN_HEAP_SETTINGS g_cRenderHal_DSH_Settings_g8 =
68 {
69 0x0080000, // dwDshInitialSize = 512MB
70 0x0080000, // dwDshSizeIncrement = 512kB
71 0x8000000, // dwDshMaximumSize = 128MB (all heaps)
72 0x0100000, // dwIshInitialSize = 1M
73 0x0040000, // dwIshSizeIncrement = 256kB
74 0x0400000, // dwIshMaximumSize = 4MB
75 16, // iMinMediaStates
76 256, // iMaxMediaStates
77 16, // iMinKernels
78 2048 // iMaxKernels
79 };
80
81 //!
82 //! \brief Setup Surface State
83 //! \details Setup Surface States for Gen75/Gen8
84 //! \param PRENDERHAL_INTERFACE pRenderHal
85 //! [in] Pointer to Hardware Interface Structure
86 //! \param PRENDERHAL_SURFACE pRenderHalSurface
87 //! [in] Pointer to Render Hal Surface
88 //! \param PRENDERHAL_SURFACE_STATE_PARAMS pParams
89 //! [in] Pointer to Surface State Params
90 //! \param int32_t *piNumEntries
91 //! [out] Pointer to Number of Surface State Entries (Num Planes)
92 //! \param PRENDERHAL_SURFACE_STATE_ENTRY * ppSurfaceEntries
93 //! [out] Array of Surface State Entries
94 //! \param PRENDERHAL_OFFSET_OVERRIDE pOffsetOverride
95 //! [in] If not nullptr, provides adjustments to Y, UV plane offsets,
96 //! used for kernel WA in a few cases. nullptr is the most common usage.
97 //! \return MOS_STATUS
98 //!
SetupSurfaceState(PRENDERHAL_INTERFACE pRenderHal,PRENDERHAL_SURFACE pRenderHalSurface,PRENDERHAL_SURFACE_STATE_PARAMS pParams,int32_t * piNumEntries,PRENDERHAL_SURFACE_STATE_ENTRY * ppSurfaceEntries,PRENDERHAL_OFFSET_OVERRIDE pOffsetOverride)99 MOS_STATUS XRenderHal_Interface_g8::SetupSurfaceState(
100 PRENDERHAL_INTERFACE pRenderHal,
101 PRENDERHAL_SURFACE pRenderHalSurface,
102 PRENDERHAL_SURFACE_STATE_PARAMS pParams,
103 int32_t *piNumEntries,
104 PRENDERHAL_SURFACE_STATE_ENTRY *ppSurfaceEntries,
105 PRENDERHAL_OFFSET_OVERRIDE pOffsetOverride)
106 {
107 PRENDERHAL_SURFACE_STATE_ENTRY pSurfaceEntry;
108 PMOS_PLANE_OFFSET pPlaneOffset;
109 MHW_SURFACE_STATE_PARAMS SurfStateParams;
110 PMOS_SURFACE pSurface;
111 int32_t i;
112 uint32_t dwPixelsPerSampleUV;
113 uint32_t dwSurfaceSize;
114 MOS_STATUS eStatus = MOS_STATUS_UNKNOWN;
115
116 //-----------------------------------------
117 MHW_RENDERHAL_CHK_NULL(pRenderHal);
118 MHW_RENDERHAL_CHK_NULL(pRenderHalSurface);
119 MHW_RENDERHAL_CHK_NULL(pParams);
120 MHW_RENDERHAL_CHK_NULL(ppSurfaceEntries);
121 MHW_RENDERHAL_CHK_NULL(pRenderHal->pStateHeap);
122 MHW_RENDERHAL_CHK_NULL(pRenderHal->pHwSizes);
123 MHW_RENDERHAL_CHK_NULL(pRenderHal->pMhwStateHeap);
124 //-----------------------------------------
125
126 dwSurfaceSize = pRenderHal->pHwSizes->dwSizeSurfaceState;
127
128 MOS_ZeroMemory(&SurfStateParams, sizeof(SurfStateParams));
129
130 // Get the Surface State Entries
131 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pfnGetSurfaceStateEntries(
132 pRenderHal,
133 pRenderHalSurface,
134 pParams,
135 piNumEntries,
136 ppSurfaceEntries));
137
138 for (i = 0; i < *piNumEntries; i++)
139 {
140 // Pointer to surface state entry for current plane
141 pSurfaceEntry = ppSurfaceEntries[i];
142
143 pSurface = pSurfaceEntry->pSurface;
144
145 // Set the Surface State Offset from base of SSH
146 pSurfaceEntry->dwSurfStateOffset = pRenderHal->pStateHeap->iSurfaceStateOffset + // Offset to Base Of Current Surface State Area
147 pSurfaceEntry->iSurfStateID * dwSurfaceSize; // Offset to Surface State within the area
148
149 // Obtain the Pointer to the Surface state from SSH Buffer
150 SurfStateParams.pSurfaceState = pSurfaceEntry->pSurfaceState;
151 SurfStateParams.bUseAdvState = pSurfaceEntry->bAVS;
152 SurfStateParams.dwWidth = (pParams->bWAUseSrcWidth) ? pRenderHalSurface->rcSrc.right : pSurfaceEntry->dwWidth;
153 SurfStateParams.dwHeight = (pParams->bWAUseSrcHeight) ? pRenderHalSurface->rcSrc.bottom : pSurfaceEntry->dwHeight;
154 SurfStateParams.dwFormat = pSurfaceEntry->dwFormat;
155 SurfStateParams.dwPitch = pSurfaceEntry->dwPitch;
156 SurfStateParams.dwQPitch = pSurfaceEntry->dwQPitch;
157 SurfStateParams.bTiledSurface = pSurfaceEntry->bTiledSurface;
158 SurfStateParams.bTileWalk = pSurfaceEntry->bTileWalk;
159 SurfStateParams.dwCacheabilityControl = pRenderHal->pfnGetSurfaceMemoryObjectControl(pRenderHal, pParams);
160
161 if (pSurfaceEntry->bAVS)
162 {
163 SurfStateParams.bHalfPitchChroma = pSurfaceEntry->bHalfPitchChroma;
164 SurfStateParams.bInterleaveChroma = pSurfaceEntry->bInterleaveChroma;
165 SurfStateParams.UVPixelOffsetVDirection = pSurfaceEntry->DirectionV;
166 SurfStateParams.AddressControl = pSurfaceEntry->AddressControl;
167
168 // On SNB+, when VDI Walker is enabled, Input surface width should be 16 pixel aligned
169 if (pParams->bWidth16Align)
170 {
171 SurfStateParams.dwWidth = MOS_ALIGN_CEIL(pSurfaceEntry->dwWidth, 16);
172 }
173
174 if (pSurfaceEntry->YUVPlane == MHW_U_PLANE) // AVS U plane
175 {
176 SurfStateParams.dwXOffsetForU = (uint32_t)pSurface->UPlaneOffset.iXOffset;
177 SurfStateParams.dwYOffsetForU = (uint32_t)pSurface->UPlaneOffset.iYOffset;
178 SurfStateParams.dwXOffsetForV = 0;
179 SurfStateParams.dwYOffsetForV = 0;
180 }
181 else if (pSurfaceEntry->YUVPlane == MHW_V_PLANE) // AVS V plane
182 {
183 SurfStateParams.dwXOffsetForU = (uint32_t)pSurface->VPlaneOffset.iXOffset;
184 SurfStateParams.dwYOffsetForU = (uint32_t)pSurface->VPlaneOffset.iYOffset;
185 SurfStateParams.dwXOffsetForV = 0;
186 SurfStateParams.dwYOffsetForV = 0;
187 }
188 else // AVS/DNDI Y plane
189 {
190 SurfStateParams.dwXOffsetForU = pSurfaceEntry->wUXOffset;
191 SurfStateParams.dwYOffsetForU = pSurfaceEntry->wUYOffset;
192 SurfStateParams.dwXOffsetForV = pSurfaceEntry->wVXOffset;
193 SurfStateParams.dwYOffsetForV = pSurfaceEntry->wVYOffset;
194 }
195 if (pRenderHalSurface->bInterlacedScaling)
196 {
197 SurfStateParams.bVerticalLineStrideOffset = pSurfaceEntry->bVertStrideOffs;
198 SurfStateParams.bVerticalLineStride = pSurfaceEntry->bVertStride;
199 }
200 }
201 else // 2D/3D Surface (non-AVS)
202 {
203 SurfStateParams.SurfaceType3D =
204 (pSurface->dwDepth > 1) ? GFX3DSTATE_SURFACETYPE_3D :
205 GFX3DSTATE_SURFACETYPE_2D;
206 SurfStateParams.dwDepth = MOS_MAX(1, pSurface->dwDepth);
207 SurfStateParams.bVerticalLineStrideOffset = pSurfaceEntry->bVertStrideOffs;
208 SurfStateParams.bVerticalLineStride = pSurfaceEntry->bVertStride;
209 SurfStateParams.bSurfaceArraySpacing = true;
210
211 // Setup surface g7 surface state
212 if (pSurfaceEntry->YUVPlane == MHW_U_PLANE ||
213 pSurfaceEntry->YUVPlane == MHW_V_PLANE)
214 {
215 pPlaneOffset = (pSurfaceEntry->YUVPlane == MHW_U_PLANE) ?
216 &pSurface->UPlaneOffset : &pSurface->VPlaneOffset;
217
218 // Get Pixels Per Sample if we use dataport read
219 if (pParams->bWidthInDword_UV)
220 {
221 RenderHal_GetPixelsPerSample(pSurface->Format, &dwPixelsPerSampleUV);
222 }
223 else
224 {
225 // If the kernel uses sampler - do not change width (it affects coordinates)
226 dwPixelsPerSampleUV = 1;
227 }
228
229 if (pOffsetOverride)
230 {
231 pPlaneOffset->iSurfaceOffset += pOffsetOverride->iUVOffsetAdjust;
232 SurfStateParams.iXOffset = (dwPixelsPerSampleUV == 1) ?
233 pPlaneOffset->iXOffset : // is it correct? No override if PixelsPerSamplerUV == 1??
234 pOffsetOverride->iUVOffsetX;
235 SurfStateParams.iYOffset = pOffsetOverride->iUVOffsetY;
236 }
237 else
238 {
239 if (dwPixelsPerSampleUV == 1)
240 {
241 SurfStateParams.iXOffset = pPlaneOffset->iXOffset;
242 }
243 else
244 {
245 SurfStateParams.iXOffset = pPlaneOffset->iXOffset/sizeof(uint32_t);
246 }
247
248 SurfStateParams.iYOffset = pPlaneOffset->iYOffset;
249 }
250 }
251 else // Y plane
252 {
253 pPlaneOffset = &pSurface->YPlaneOffset;
254
255 if (pOffsetOverride)
256 {
257 pSurface->dwOffset += pOffsetOverride->iYOffsetAdjust;
258 SurfStateParams.iXOffset = pOffsetOverride->iYOffsetX;
259 SurfStateParams.iYOffset = pOffsetOverride->iYOffsetY;
260 }
261 else
262 {
263 SurfStateParams.iXOffset = pPlaneOffset->iXOffset/sizeof(uint32_t);
264 SurfStateParams.iYOffset = pPlaneOffset->iYOffset;
265 }
266
267 if (pSurfaceEntry->YUVPlane == MHW_Y_PLANE &&
268 pSurfaceEntry->dwFormat == MHW_GFX3DSTATE_SURFACEFORMAT_PLANAR_420_8)
269 {
270 SurfStateParams.dwXOffsetForU = 0;
271 SurfStateParams.dwYOffsetForU = pSurface->dwHeight;
272 }
273 }
274 }
275
276 // Call MHW to setup the Surface State Heap entry
277 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwStateHeap->SetSurfaceStateEntry(&SurfStateParams));
278
279 // Setup OS specific states
280 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pfnSetupSurfaceStatesOs(pRenderHal, pParams, pSurfaceEntry));
281 }
282
283 eStatus = MOS_STATUS_SUCCESS;
284
285 finish:
286 return eStatus;
287 }
288
289 //!
290 //! \brief Checks how per thread scratch space size bits in VFE state are interpreted by HW
291 //! \details For BDW GT1/2/3 A0 steppings, per thread scratch space size in VFE state
292 //! is 11 bits indicating [2k bytes, 2 Mbytes]: 0=2k, 1=4k, 2=8k ... 10=2M
293 //! BDW+ excluding A0 step is 12 bits indicating [1k bytes, 2 Mbytes]: 0=1k, 1=2k, 2=4k, 3=8k ... 11=2M
294 //! \param PRENDERHAL_INTERFACE pRenderHal
295 //! [in] Pointer to RenderHal interface
296 //! \return true if BDW A0 stepping, false otherwise
297 //!
PerThreadScratchSpaceStart2K(PRENDERHAL_INTERFACE pRenderHal)298 bool XRenderHal_Interface_g8::PerThreadScratchSpaceStart2K(
299 PRENDERHAL_INTERFACE pRenderHal)
300 {
301 if (pRenderHal == nullptr)
302 {
303 MHW_RENDERHAL_ASSERTMESSAGE("Null pointer detected.");
304 return false;
305 }
306
307 // true for BDW GT1/2/3 A0 stepping
308 if (pRenderHal->Platform.usRevId == 0)
309 return true;
310 else
311 return false;
312 }
313
314 //!
315 //! \brief Encode SLM Size for Interface Descriptor
316 //! \details Setup SLM size
317 //! \param uint32_t SLMSize
318 //! [in] SLM size in 1K
319 //! \return encoded output
320 //!
EncodeSLMSize(uint32_t SLMSize)321 uint32_t XRenderHal_Interface_g8::EncodeSLMSize(uint32_t SLMSize)
322 {
323 return (MOS_ALIGN_CEIL(SLMSize, 4) >> MHW_SLM_SHIFT);
324 }
325
326 //!
327 //! \brief Set Chroma Direction
328 //! \details Setup Chroma Direction for G8
329 //! \param PRENDERHAL_INTERFACE pRenderHal
330 //! [in] Pointer to Hardware Interface
331 //! \param PRENDERHAL_SURFACE pRenderHalSurface
332 //! [in] Pointer to Render Hal Surface
333 //! \return uint8_t
334 //!
SetChromaDirection(PRENDERHAL_INTERFACE pRenderHal,PRENDERHAL_SURFACE pRenderHalSurface)335 uint8_t XRenderHal_Interface_g8::SetChromaDirection(
336 PRENDERHAL_INTERFACE pRenderHal,
337 PRENDERHAL_SURFACE pRenderHalSurface)
338 {
339 uint8_t Direction;
340 MHW_RENDERHAL_UNUSED(pRenderHal);
341 MHW_RENDERHAL_ASSERT(pRenderHal);
342 MHW_RENDERHAL_ASSERT(pRenderHalSurface);
343
344 Direction = MEDIASTATE_VDIRECTION_FULL_FRAME;
345 if (pRenderHalSurface->pDeinterlaceParams || pRenderHalSurface->bQueryVariance)
346 {
347 if ((pRenderHalSurface->SampleType == RENDERHAL_SAMPLE_INTERLEAVED_EVEN_FIRST_BOTTOM_FIELD) ||
348 (pRenderHalSurface->SampleType == RENDERHAL_SAMPLE_INTERLEAVED_ODD_FIRST_BOTTOM_FIELD))
349 {
350 Direction = MEDIASTATE_VDIRECTION_BOTTOM_FIELD;
351 }
352 else if ((pRenderHalSurface->SampleType == RENDERHAL_SAMPLE_INTERLEAVED_EVEN_FIRST_TOP_FIELD) ||
353 (pRenderHalSurface->SampleType == RENDERHAL_SAMPLE_INTERLEAVED_ODD_FIRST_TOP_FIELD))
354 {
355 Direction = MEDIASTATE_VDIRECTION_TOP_FIELD;
356 }
357 }
358
359 return Direction;
360 }
361
362 //!
363 //! \brief Convert To Nano Seconds
364 //! \details Convert to Nano Seconds
365 //! \param PRENDERHAL_INTERFACE pRenderHal
366 //! [in] Pointer to Hardware Interface Structure
367 //! \param uint64_t iTicks
368 //! [in] Ticks
369 //! \param uint64_t *piNs
370 //! [in] Nano Seconds
371 //! \return void
372 //!
ConvertToNanoSeconds(PRENDERHAL_INTERFACE pRenderHal,uint64_t iTicks,uint64_t * piNs)373 void XRenderHal_Interface_g8::ConvertToNanoSeconds(
374 PRENDERHAL_INTERFACE pRenderHal,
375 uint64_t iTicks,
376 uint64_t *piNs)
377 {
378 //-----------------------------
379 MHW_RENDERHAL_UNUSED(pRenderHal);
380 MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pRenderHal);
381 MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(piNs);
382 //-----------------------------
383
384 *piNs = iTicks * RENDERHAL_NS_PER_TICK_RENDER_G8;
385 }
386
387 //!
388 //! \brief Initialize the State Heap Settings per platform
389 //! \param PRENDERHAL_STATE_HEAP_SETTINGS pSettings
390 //! [out] Pointer to PRENDERHAL_STATE_HEAP_SETTINGSStructure
391 //! \return void
392 //!
InitStateHeapSettings(PRENDERHAL_INTERFACE pRenderHal)393 void XRenderHal_Interface_g8::InitStateHeapSettings(
394 PRENDERHAL_INTERFACE pRenderHal)
395 {
396 MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pRenderHal);
397 // Set State Heap settings for g8
398 pRenderHal->StateHeapSettings = g_cRenderHal_State_Heap_Settings_g8;
399 }
400
401 //!
402 //! \brief Initialize the default surface type and advanced surface type per platform
403 //! \param PRENDERHAL_INTERFACE pRenderHal
404 //! [out] Pointer to PRENDERHAL_INTERFACE
405 //! \return void
406 //!
InitSurfaceTypes(PRENDERHAL_INTERFACE pRenderHal)407 void XRenderHal_Interface_g8::InitSurfaceTypes(
408 PRENDERHAL_INTERFACE pRenderHal)
409 {
410 MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pRenderHal);
411 // Set default / advanced surface types
412 pRenderHal->SurfaceTypeDefault = RENDERHAL_SURFACE_TYPE_G8;
413 pRenderHal->SurfaceTypeAdvanced = RENDERHAL_SURFACE_TYPE_ADV_G8;
414 }
415
416 //!
417 //! \brief Enables L3 cacheing flag and sets related registers/values
418 //! \param PRENDERHAL_INTERFACE pRenderHal
419 //! [in] Pointer to Hardware Interface
420 //! \param pCacheSettings
421 //! [in] L3 Cache Configurations
422 //! \return MOS_STATUS
423 //! MOS_STATUS_SUCCESS if success, else fail reason
424 //!
EnableL3Caching(PRENDERHAL_INTERFACE pRenderHal,PRENDERHAL_L3_CACHE_SETTINGS pCacheSettings)425 MOS_STATUS XRenderHal_Interface_g8::EnableL3Caching(
426 PRENDERHAL_INTERFACE pRenderHal,
427 PRENDERHAL_L3_CACHE_SETTINGS pCacheSettings)
428 {
429 MOS_STATUS eStatus;
430 PLATFORM Platform;
431 MHW_RENDER_ENGINE_L3_CACHE_SETTINGS mHwL3CacheConfig = {};
432 PMHW_RENDER_ENGINE_L3_CACHE_SETTINGS pCacheConfig;
433 MhwRenderInterface *pMhwRender;
434 PRENDERHAL_INTERFACE_LEGACY pRenderHalLegacy = (PRENDERHAL_INTERFACE_LEGACY)pRenderHal;
435
436 MHW_RENDERHAL_CHK_NULL(pRenderHalLegacy);
437 pMhwRender = pRenderHalLegacy->pMhwRenderInterface;
438 MHW_RENDERHAL_CHK_NULL(pMhwRender);
439
440 if (nullptr == pCacheSettings)
441 {
442 MHW_RENDERHAL_CHK_STATUS(pMhwRender->EnableL3Caching(nullptr));
443 goto finish;
444 }
445
446 // customize the cache config for renderhal and let mhw_render overwrite it
447 pCacheConfig = &mHwL3CacheConfig;
448
449 pRenderHalLegacy->pOsInterface->pfnGetPlatform(pRenderHalLegacy->pOsInterface, &Platform);
450
451 pCacheConfig->dwSqcReg1 = L3_CACHE_SQC1_REG_VALUE_G8;
452
453 pCacheConfig->dwCntlReg = GetL3CacheCntlRegWithSLM();
454
455 // Override L3 cache configuration
456 if (pCacheSettings->bOverride)
457 {
458 if (pCacheSettings->bSqcReg1Override)
459 {
460 pCacheConfig->dwSqcReg1 = pCacheSettings->dwSqcReg1;
461 }
462
463 if (pCacheSettings->bCntlRegOverride)
464 {
465 pCacheConfig->dwCntlReg = pCacheSettings->dwCntlReg;
466 }
467 }
468
469 MHW_RENDERHAL_CHK_STATUS(pMhwRender->EnableL3Caching(pCacheConfig));
470
471 finish:
472 return eStatus;
473 }
474
475 //!
476 //! \brief Get offset and/or pointer to sampler state
477 //! \details Get offset and/or pointer to sampler state in General State Heap
478 //! \param PRENDERHAL_INTERFACE pRenderHal
479 //! [in] Pointer to RenderHal Interface
480 //! \param int32_t iMediaID
481 //! [in] Media ID associated with sampler
482 //! \param int32_t iSamplerID
483 //! [in] Sampler ID
484 //! \param uint32_t *pdwSamplerOffset
485 //! [out] optional; offset of sampler state from GSH base
486 //! \param void **ppSampler
487 //! [out] optional; pointer to sampler state in GSH
488 //! \return MOS_STATUS
489 //!
GetSamplerOffsetAndPtr_DSH(PRENDERHAL_INTERFACE pRenderHal,int32_t iMediaID,int32_t iSamplerID,PMHW_SAMPLER_STATE_PARAM pSamplerParams,uint32_t * pdwSamplerOffset,void ** ppSampler)490 MOS_STATUS XRenderHal_Interface_g8::GetSamplerOffsetAndPtr_DSH(
491 PRENDERHAL_INTERFACE pRenderHal,
492 int32_t iMediaID,
493 int32_t iSamplerID,
494 PMHW_SAMPLER_STATE_PARAM pSamplerParams,
495 uint32_t *pdwSamplerOffset,
496 void **ppSampler)
497 {
498 PRENDERHAL_STATE_HEAP pStateHeap;
499 PRENDERHAL_DYNAMIC_STATE pDynamicState;
500 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
501 uint32_t dwSamplerIndirect;
502 uint32_t dwOffset;
503 MHW_SAMPLER_TYPE SamplerType;
504
505 MHW_RENDERHAL_CHK_NULL(pRenderHal);
506 MHW_RENDERHAL_CHK_NULL(pRenderHal->pStateHeap);
507 MHW_RENDERHAL_CHK_NULL(pRenderHal->pStateHeap->pCurMediaState);
508 MHW_RENDERHAL_CHK_NULL(pRenderHal->pHwSizes);
509
510 pStateHeap = pRenderHal->pStateHeap;
511 pDynamicState = ((PRENDERHAL_MEDIA_STATE_LEGACY)pStateHeap->pCurMediaState)->pDynamicState;
512
513 MHW_RENDERHAL_CHK_NULL(pDynamicState);
514
515 MHW_RENDERHAL_ASSERT(iMediaID < pDynamicState->MediaID.iCount);
516
517 dwOffset = iMediaID * pDynamicState->dwSizeSamplers; // Go to Media ID sampler offset
518
519 SamplerType = (pSamplerParams) ? pSamplerParams->SamplerType : MHW_SAMPLER_TYPE_3D;
520
521 switch (SamplerType)
522 {
523 case MHW_SAMPLER_TYPE_AVS:
524 MHW_RENDERHAL_ASSERT(iSamplerID < pDynamicState->SamplerAVS.iCount);
525 dwOffset += pDynamicState->SamplerAVS.dwOffset + // Go to AVS sampler area
526 iSamplerID * MHW_SAMPLER_STATE_AVS_INC_LEGACY; // 16: size of one element, 32: 32 entries
527 break;
528
529 case MHW_SAMPLER_TYPE_CONV:
530 MHW_RENDERHAL_ASSERT(iSamplerID < pDynamicState->SamplerConv.iCount);
531 dwOffset += pDynamicState->SamplerConv.dwOffset + // Goto Conv sampler base
532 iSamplerID * MHW_SAMPLER_STATE_CONV_INC_LEGACY; // 16: size of one element, 32: 32 entries
533 break;
534
535 case MHW_SAMPLER_TYPE_MISC:
536 MHW_RENDERHAL_ASSERT(iSamplerID < pDynamicState->SamplerMisc.iCount);
537 dwOffset += pDynamicState->SamplerMisc.dwOffset + // Goto sampler base
538 iSamplerID * MHW_SAMPLER_STATE_VA_INC; // 16: size of one element, 2: 2 entries
539 break;
540
541 case MHW_SAMPLER_TYPE_3D:
542 default:
543 MHW_RENDERHAL_ASSERT(iSamplerID < pDynamicState->Sampler3D.iCount);
544 dwSamplerIndirect = dwOffset;
545 dwOffset += pDynamicState->Sampler3D.dwOffset + // Go 3D Sampler base
546 iSamplerID * pRenderHal->pHwSizes->dwSizeSamplerState; // Go to "samplerID" sampler state
547
548 if (pSamplerParams)
549 {
550 dwSamplerIndirect += pDynamicState->SamplerInd.dwOffset + // offset to indirect sampler area
551 iSamplerID * pRenderHal->pHwSizes->dwSizeSamplerIndirectState; // Goto to "samplerID" indirect state
552 pSamplerParams->Unorm.IndirectStateOffset = dwSamplerIndirect;
553 }
554
555 break;
556 }
557
558 if (pdwSamplerOffset)
559 {
560 *pdwSamplerOffset = dwOffset;
561 }
562
563 finish:
564 return eStatus;
565 }
566
567 //!
568 //! \brief Initialize the DSH Settings
569 //! \details Initialize the structure DynamicHeapSettings in pRenderHal
570 //! \param PRENDERHAL_INTERFACE pRenderHal
571 //! [in] Pointer to HW interface
572 //! \return void
573 //!
InitDynamicHeapSettings(PRENDERHAL_INTERFACE pRenderHal)574 void XRenderHal_Interface_g8::InitDynamicHeapSettings(
575 PRENDERHAL_INTERFACE pRenderHal)
576 {
577 PRENDERHAL_INTERFACE_LEGACY pRenderHalLegacy = static_cast<PRENDERHAL_INTERFACE_LEGACY>(pRenderHal);
578 MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pRenderHalLegacy);
579 // Additional Dynamic State Heap settings for g8
580 pRenderHalLegacy->DynamicHeapSettings = g_cRenderHal_DSH_Settings_g8;
581 }
582
583 //!
584 //! \brief Set Power Option Status
585 //! \param [in] pRenderHal
586 //! Pointer to Hardware Interface
587 //! \param [in,out] pCmdBuffer
588 //! Pointer to Command Buffer
589 //! \return MOS_STATUS
590 //! MOS_STATUS_SUCCESS if success, else fail reason
591 //!
SetPowerOptionStatus(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer)592 MOS_STATUS XRenderHal_Interface_g8::SetPowerOptionStatus(
593 PRENDERHAL_INTERFACE pRenderHal,
594 PMOS_COMMAND_BUFFER pCmdBuffer)
595 {
596 PMOS_INTERFACE pOsInterface;
597 MOS_STATUS eStatus;
598 MEDIA_SYSTEM_INFO *pGtSystemInfo;
599
600 MHW_RENDERHAL_CHK_NULL(pRenderHal);
601 MHW_RENDERHAL_CHK_NULL(pCmdBuffer);
602 MHW_RENDERHAL_CHK_NULL(pRenderHal->pOsInterface);
603
604 eStatus = MOS_STATUS_SUCCESS;
605 pOsInterface = pRenderHal->pOsInterface;
606 pGtSystemInfo = pOsInterface->pfnGetGtSystemInfo(pOsInterface);
607 MHW_RENDERHAL_CHK_NULL(pGtSystemInfo);
608
609 // Check if Slice Shutdown can be enabled
610 if (pRenderHal->bRequestSingleSlice)
611 {
612 pCmdBuffer->Attributes.dwNumRequestedEUSlices = 1;
613 }
614 else if (pRenderHal->bEUSaturationNoSSD)
615 {
616 pCmdBuffer->Attributes.dwNumRequestedEUSlices = 2;
617 }
618
619 if ((pRenderHal->pSkuTable) && MEDIA_IS_SKU(pRenderHal->pSkuTable, FtrSSEUPowerGating))
620 {
621 // VP does not request subslice shutdown according to the array VpHalDefaultSSEUTableGxx
622 if (((pRenderHal->PowerOption.nSlice != 0) || (pRenderHal->PowerOption.nSubSlice != 0) || (pRenderHal->PowerOption.nEU != 0)) &&
623 ((pGtSystemInfo->SliceCount != 0) && (pGtSystemInfo->SubSliceCount != 0)))
624 {
625 pCmdBuffer->Attributes.dwNumRequestedEUSlices = MOS_MIN(pRenderHal->PowerOption.nSlice, pGtSystemInfo->SliceCount);
626 pCmdBuffer->Attributes.dwNumRequestedSubSlices = MOS_MIN(pRenderHal->PowerOption.nSubSlice, (pGtSystemInfo->SubSliceCount / pGtSystemInfo->SliceCount));
627 pCmdBuffer->Attributes.dwNumRequestedEUs = MOS_MIN(pRenderHal->PowerOption.nEU, (pGtSystemInfo->EUCount / pGtSystemInfo->SubSliceCount));
628 pCmdBuffer->Attributes.bValidPowerGatingRequest = true;
629
630 if (pOsInterface->pfnSetSliceCount)
631 {
632 uint32_t sliceCount = pCmdBuffer->Attributes.dwNumRequestedEUSlices;
633 pOsInterface->pfnSetSliceCount(pOsInterface, &sliceCount);
634 }
635 }
636 }
637
638 finish:
639 return eStatus;
640 }
641
642 //!
643 //! \brief Set L3 cache override config parameters
644 //! \param [in] pRenderHal
645 //! Pointer to RenderHal Interface Structure
646 //! \param [in,out] pCacheSettings
647 //! Pointer to pCacheSettings
648 //! \param [in] bEnableSLM
649 //! Flag to enable SLM
650 //! \return MOS_STATUS
651 //! MOS_STATUS_SUCCESS if success. Error code otherwise
652 //!
SetCacheOverrideParams(PRENDERHAL_INTERFACE pRenderHal,PRENDERHAL_L3_CACHE_SETTINGS pCacheSettings,bool bEnableSLM)653 MOS_STATUS XRenderHal_Interface_g8::SetCacheOverrideParams(
654 PRENDERHAL_INTERFACE pRenderHal,
655 PRENDERHAL_L3_CACHE_SETTINGS pCacheSettings,
656 bool bEnableSLM)
657 {
658 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
659
660 MHW_RENDERHAL_CHK_NULL(pRenderHal);
661 MHW_RENDERHAL_CHK_NULL(pCacheSettings);
662
663 if (bEnableSLM)
664 {
665 pCacheSettings->dwCntlReg = RENDERHAL_L3_CACHE_CNTL_REG_SLM_ENABLE_G8;
666 }
667 else
668 {
669 pCacheSettings->dwCntlReg = RENDERHAL_L3_CACHE_CNTL_REG_SLM_DISABLE_ALL_L3_512K_G8;
670 }
671 pCacheSettings->bCntlRegOverride = true;
672
673 finish:
674 return eStatus;
675 }
676
677 //! \brief Get the size of Render Surface State Command
678 //! \return size_t
679 //! the size of render surface state command
GetSurfaceStateCmdSize()680 size_t XRenderHal_Interface_g8::GetSurfaceStateCmdSize()
681 {
682 return MOS_ALIGN_CEIL( MOS_MAX(mhw_state_heap_g8_X::RENDER_SURFACE_STATE_CMD::byteSize,
683 mhw_state_heap_g8_X::MEDIA_SURFACE_STATE_CMD::byteSize), MHW_SURFACE_STATE_ALIGN);
684 }
685
686