| 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 |
//! |
| 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 |
//! |
| 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 |
//! |
| 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 |
//! |
| 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 |
//! |
| 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 |
//! |
| 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 |
//! |
| 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 |
//! |
| 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 |
//! |
| 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 |
//! |
| 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 |
//! |
| 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 |
//! |
| 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 |
| 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 |
|