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