/* * Copyright (c) 2009-2022, Intel Corporation * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ //! //! \file renderhal.cpp //! \brief Render Engine state heap manager for VP and CM //! \details Platform/OS Independent Render Engine state heap management interfaces //! #include "renderhal.h" #include "hal_kerneldll_next.h" #include "renderhal_platform_interface.h" #include "media_interfaces_renderhal.h" #include "media_interfaces_mhw_next.h" #include "hal_oca_interface_next.h" #define OutputSurfaceWidthRatio 1 extern const SURFACE_STATE_TOKEN_COMMON g_cInit_SURFACE_STATE_TOKEN_COMMON = { // DWORD 0 { OP_LENGTH(SIZE32(SURFACE_STATE_TOKEN_COMMON)), // Length GFXSUBOP_SURFACE_STATE_TOKEN, // InstructionSubOpcode GFXOP_PIPELINED, // InstructionOpcode PIPE_3D, // InstructionPipeline INSTRUCTION_GFX, // InstructionType 1 // Token }, // DWORD 1 { 0, // SurfaceStateHeapOffset 0 // SurfaceAllocationIndex }, // DWORD 2 { 0 // SurfaceOffset }, // DWORD 3 { 0, // RenderTargetEnable 0, // YUVPlane 0 // SurfaceStateType }, // DWORD 4 { 0 // SurfaceBaseAddress }, // DWORD 5 { 0 // SurfaceBaseAddress64 }, }; const MHW_PIPE_CONTROL_PARAMS g_cRenderHal_InitPipeControlParams = { nullptr, // presDest 0, // dwResourceOffset 0, // dwDataDW1 0, // dwDataDW2 MHW_FLUSH_NONE, // dwFlushMode MHW_FLUSH_NOWRITE, // dwPostSyncOp false, // bDisableCSStall false, // bInvalidateStateCache false, // bInvalidateConstantCache false, // bInvalidateVFECache false, // bInvalidateInstructionCache true, // bFlushRenderTargetCache false, // bTlbInvalidate false, // bInvalidateTextureCache false, // bGenericMediaStateClear false, // bIndirectStatePointersDisable false, // bHdcPipelineFlush false, // bKernelFenceEnabled }; extern const RENDERHAL_SURFACE_STATE_ENTRY g_cInitSurfaceStateEntry = { RENDERHAL_SURFACE_TYPE_INVALID, // Type nullptr, // pSurface nullptr, // pSurfaceState { // SurfaceS Token {}, //DW0 {}, //DW1 {}, //DW2 {}, //DW3 {}, //DW4 {}, //DW5 nullptr, // pResourceInfo }, -1, // iSurfStateID 0, // dwSurfStateOffset 0, // dwFormat 0, // dwWidth 0, // dwHeight 0, // dwPitch 0, // dwQPitch 0, // YUVPlane false, // bAVS false, // bRenderTarget false, // bVertStride false, // bVertStrideOffs false, // bWidthInDword false, // bTiledSurface false, // bTileWalk false, // bHalfPitchChroma false, // bInterleaveChroma 0, // DirectionV 0, // DirectionU 0, // AddressControl 0, // wUXOffset 0, // wUYOffset 0, // wVXOffset 0 // wVYOffset }; const MHW_MEDIA_STATE_FLUSH_PARAM g_cRenderHal_InitMediaStateFlushParams = { false, // bFlushToGo 0 // ui8InterfaceDescriptorOffset }; const RENDERHAL_KERNEL_PARAM g_cRenderHal_InitKernelParams = { 0, // GRF_Count; 0, // BT_Count; 0, // Sampler_Count 0, // Thread_Count 0, // GRF_Start_Register 0, // CURBE_Length 0, // block_width 0, // block_height 0, // blocks_x 0 // blocks_y }; //! //! \brief Table only used on HSW (look @ renderhal.c for HSW- table) //! Constants used for setting up surface states ui8PlaneID, //! ui8ScaleWidth, ui8ScaleHeight, ui8AlignWidth, ui8AlignHeight, //! ui8PixelsPerDword, bAdvanced, dwFormat //! extern const MHW_SURFACE_PLANES g_cRenderHal_SurfacePlanes[RENDERHAL_PLANES_DEFINITION_COUNT] = { // RENDERHAL_PLANES_PL3 { 3, { { MHW_Y_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM }, { MHW_U_PLANE , 2, 2, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM }, { MHW_V_PLANE , 2, 2, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM } } }, // RENDERHAL_PLANES_NV12 { 1, { { MHW_Y_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_PLANAR_420_8 } } }, // RENDERHAL_PLANES_YUY2 { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_YCRCB_NORMAL } } }, // RENDERHAL_PLANES_UYVY { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_YCRCB_SWAPY } } }, // RENDERHAL_PLANES_YVYU { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_YCRCB_SWAPUV } } }, // RENDERHAL_PLANES_VYUY { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_YCRCB_SWAPUVY } } }, // RENDERHAL_PLANES_ARGB { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_B8G8R8A8_UNORM } } }, // RENDERHAL_PLANES_XRGB { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_B8G8R8X8_UNORM } } }, // RENDERHAL_PLANES_ABGR { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_UNORM } } }, // RENDERHAL_PLANES_XBGR { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8G8B8X8_UNORM } } }, // RENDERHAL_PLANES_RGB16 { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_B5G6R5_UNORM } } }, // RENDERHAL_PLANES_RGB24 { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8G8B8_UNORM } } }, // RENDERHAL_PLANES_R16U { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16_UINT } } }, // RENDERHAL_PLANES_R16S { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16_SINT } } }, // RENDERHAL_PLANES_R32U { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R32_UINT } } }, // RENDERHAL_PLANES_R32S { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R32_SINT } } }, // RENDERHAL_PLANES_R32F { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R32_FLOAT } } }, // RENDERHAL_PLANES_V8U8 { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8G8_SNORM } } }, // RENDERHAL_PLANES_R8G8_UNORM { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8G8_UNORM } } }, // RENDERHAL_PLANES_411P { 3, { { MHW_Y_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM }, { MHW_U_PLANE , 4, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM }, { MHW_V_PLANE , 4, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM } } }, // RENDERHAL_PLANES_411R { 3, { { MHW_Y_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM }, { MHW_U_PLANE , 1, 4, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM }, { MHW_V_PLANE , 1, 4, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM } } }, // RENDERHAL_PLANES_422H { 3, { { MHW_Y_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM }, { MHW_U_PLANE , 2, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM }, { MHW_V_PLANE , 2, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM } } }, // RENDERHAL_PLANES_422V { 3, { { MHW_Y_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM }, { MHW_U_PLANE , 1, 2, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM }, { MHW_V_PLANE , 1, 2, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM } } }, // RENDERHAL_PLANES_444P { 3, { { MHW_Y_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM }, { MHW_U_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM }, { MHW_V_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM } } }, // RENDERHAL_PLANES_RGBP { 3, { { MHW_U_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM }, { MHW_V_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM }, { MHW_Y_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM } } }, // RENDERHAL_PLANES_BGRP { 3, { { MHW_U_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM }, { MHW_Y_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM }, { MHW_V_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM } } }, // RENDERHAL_PLANES_AI44_PALLETE_0 { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_P4A4_UNORM_PALETTE_0 } } }, // RENDERHAL_PLANES_IA44_PALLETE_0 { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_A4P4_UNORM_PALETTE_0 } } }, // RENDERHAL_PLANES_P8_PALLETE_0 { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_P8_UNORM_PALETTE_0 } } }, // RENDERHAL_PLANES_A8P8_PALLETE_0 { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_P8A8_UNORM_PALETTE_0 } } }, // RENDERHAL_PLANES_AI44_PALLETE_1 { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_P4A4_UNORM_PALETTE_1 } } }, // RENDERHAL_PLANES_IA44_PALLETE_1 { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_A4P4_UNORM_PALETTE_1 } } }, // RENDERHAL_PLANES_P8_PALLETE_1 { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_P8_UNORM_PALETTE_1 } } }, // RENDERHAL_PLANES_A8P8_PALLETE_1 { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_P8A8_UNORM_PALETTE_1 } } }, // RENDERHAL_PLANES_AYUV { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8B8G8A8_UNORM } } }, // RENDERHAL_PLANES_STMM { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_L8_UNORM } } }, // RENDERHAL_PLANES_L8 { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_L8_UNORM } } }, // RENDERHAL_PLANES_PL3_ADV { 3, { { MHW_Y_PLANE , 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_Y8_UNORM }, { MHW_U_PLANE , 2, 2, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM }, { MHW_V_PLANE , 2, 2, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM } } }, // RENDERHAL_PLANES_NV12_ADV { 1, { { MHW_Y_PLANE , 1, 1, 2, 2, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_PLANAR_420_8 } } }, // RENDERHAL_PLANES_YUY2_ADV { 1, { { MHW_GENERIC_PLANE, 1, 1, 2, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_YCRCB_NORMAL } } }, // RENDERHAL_PLANES_UYVY_ADV { 1, { { MHW_GENERIC_PLANE, 1, 1, 2, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_YCRCB_SWAPY } } }, // RENDERHAL_PLANES_YVYU_ADV { 1, { { MHW_GENERIC_PLANE, 1, 1, 2, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_YCRCB_SWAPUV } } }, // RENDERHAL_PLANES_VYUY_ADV { 1, { { MHW_GENERIC_PLANE, 1, 1, 2, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_YCRCB_SWAPUVY } } }, // RENDERHAL_PLANES_ARGB_ADV { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_B8G8R8A8_UNORM } } }, // RENDERHAL_PLANES_ABGR_ADV { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8G8B8A8_UNORM } } }, // RENDERHAL_PLANES_AYUV_ADV { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 1, MHW_MEDIASTATE_SURFACEFORMAT_A8Y8U8V8_UNORM } } }, // RENDERHAL_PLANES_STMM_ADV { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_STMM_DN_STATISTICS } } }, // RENDERHAL_PLANES_L8_ADV { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM } } }, // RENDERHAL_PLANES_A8_ADV { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_PLANAR_411_8 } } }, // RENDERHAL_PLANES_A8 { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_A8_UNORM } } }, // RENDERHAL_PLANES_R8 { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM } } }, // RENDERHAL_PLANES_NV12_2PLANES { 2, { { MHW_Y_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM }, { MHW_U_PLANE , 2, 2, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8G8_UNORM } } }, // RENDERHAL_PLANES_NV12_2PLANES_ADV { 2, { { MHW_Y_PLANE , 1, 1, 2, 2, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_Y8_UNORM }, { MHW_U_PLANE , 2, 2, 1, 1, 2, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8B8_UNORM } } }, // RENDERHAL_PLANES_411P_ADV { 3, { { MHW_Y_PLANE , 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_Y8_UNORM }, { MHW_U_PLANE , 4, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM }, { MHW_V_PLANE , 4, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM } } }, // RENDERHAL_PLANES_411R_ADV { 3, { { MHW_Y_PLANE , 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_Y8_UNORM }, { MHW_U_PLANE , 1, 4, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM }, { MHW_V_PLANE , 1, 4, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM } } }, // RENDERHAL_PLANES_422H_ADV { 3, { { MHW_Y_PLANE , 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_Y8_UNORM }, { MHW_U_PLANE , 2, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM }, { MHW_V_PLANE , 2, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM } } }, // RENDERHAL_PLANES_422V_ADV { 3, { { MHW_Y_PLANE , 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_Y8_UNORM }, { MHW_U_PLANE , 1, 2, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM }, { MHW_V_PLANE , 1, 2, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM } } }, // RENDERHAL_PLANES_444P_ADV { 3, { { MHW_Y_PLANE , 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_Y8_UNORM }, { MHW_U_PLANE , 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM }, { MHW_V_PLANE , 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM } } }, // RENDERHAL_PLANES_RGBP_ADV { 3, { { MHW_U_PLANE , 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_Y8_UNORM }, { MHW_V_PLANE , 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM }, { MHW_Y_PLANE , 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM } } }, // RENDERHAL_PLANES_BGRP_ADV { 3, { { MHW_U_PLANE , 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_Y8_UNORM }, { MHW_Y_PLANE , 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM }, { MHW_V_PLANE , 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM } } }, // RENDERHAL_PLANES_R16_UNORM { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16_UNORM } } }, // RENDERHAL_PLANES_Y8 { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_PLANAR_411_8 } } }, // RENDERHAL_PLANES_Y1 { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 1, 16 } } }, // RENDERHAL_PLANES_Y16U { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 1, MHW_MEDIASTATE_SURFACEFORMAT_STMM_DN_STATISTICS } } }, // RENDERHAL_PLANES_Y16S { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 1, MHW_MEDIASTATE_SURFACEFORMAT_PLANAR_422_8 } } }, // RENDERHAL_PLANES_A16B16G16R16 { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 0, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_UNORM } //setting "PixelsPerDword = 0" for sampler_8x8 use } }, // RENDERHAL_PLANES_A16B16G16R16_ADV { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 0, 1, MHW_MEDIASTATE_SURFACEFORMAT_R16G16B16A16 } //setting "PixelsPerDword = 0" for sampler_8x8 use } }, // RENDERHAL_PLANES_R10G10B10A2 { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R10G10B10A2_UNORM } } }, // RENDERHAL_PLANES_R10G10B10A2_ADV { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 0, 1, MHW_MEDIASTATE_SURFACEFORMAT_R10G10B10A2_UNORM } } }, // RENDERHAL_PLANES_B10G10R10A2 { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_B10G10R10A2_UNORM } } }, // RENDERHAL_PLANES_L16 { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_L16_UNORM } } }, // RENDERHAL_PLANES_NV21 { 2, { { MHW_Y_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM }, { MHW_U_PLANE , 2, 2, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8G8_UNORM } } }, // RENDERHAL_PLANES_YV12 { 1, { { MHW_Y_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_PLANAR_420_8 } } }, // RENDERHAL_PLANES_P016 { 2, { { MHW_Y_PLANE , 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16_UNORM }, { MHW_U_PLANE , 2, 2, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16G16_UNORM } } }, // RENDERHAL_PLANES_P016_2PLANES_ADV { 2, { { MHW_Y_PLANE , 1, 1, 2, 2, 2, 1, MHW_MEDIASTATE_SURFACEFORMAT_Y16_UNORM }, { MHW_U_PLANE , 2, 2, 2, 2, 1, 1, MHW_MEDIASTATE_SURFACEFORMAT_R16B16_UNORM } } }, // RENDERHAL_PLANES_P010 { 2, { { MHW_Y_PLANE , 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16_UNORM }, { MHW_U_PLANE , 2, 2, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16G16_UNORM } } }, // RENDERHAL_PLANES_P010_1PLANE { 1, { { MHW_Y_PLANE , 1, 1, 2, 2, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_PLANAR_420_16 } } }, // RENDERHAL_PLANES_P010_1PLANE_ADV { 1, { { MHW_Y_PLANE , 1, 1, 2, 2, 2, 1, MHW_MEDIASTATE_SURFACEFORMAT_PLANAR_420_16 } } }, // RENDERHAL_PLANES_IRW0 { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16_UNORM } } }, // RENDERHAL_PLANES_IRW1 { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16_UNORM } } }, // RENDERHAL_PLANES_IRW2 { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16_UNORM } } }, // RENDERHAL_PLANES_IRW3 { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16_UNORM } } }, // RENDERHAL_PLANES_A16B16G16R16F {1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 0, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_FLOAT } //setting "PixelsPerDword = 0" in DP R/W usage, "0" means no need to adjust dwSurfaceWidth. already DWord aligned. } }, // RENDERHAL_PLANES_R16G16_UNORM {1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16G16_UNORM } } }, // RENDERHAL_PLANES_R16F { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16_FLOAT } } }, // RENDERHAL_PLANES_A16R16G16B16F {1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 0, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_FLOAT } //setting "PixelsPerDword = 0" in DP R/W usage, "0" means no need to adjust dwSurfaceWidth. already DWord aligned. } }, // RENDERHAL_PLANES_YUY2_2PLANES { 2, { { MHW_Y_PLANE, 1, 1, 2, 2, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8G8_UNORM }, { MHW_U_PLANE, 2, 1, 2, 2, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_UNORM } } }, // RENDERHAL_PLANES_Y210_ADV { 2, { { MHW_Y_PLANE, 1, 1, 1, 1, 1, 1, MHW_MEDIASTATE_SURFACEFORMAT_R16B16_UNORM }, { MHW_U_PLANE, 2, 1, 1, 1, 0, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_UNORM } } }, // RENDERHAL_PLANES_Y210_RT { 1, { { MHW_GENERIC_PLANE, 2, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_UNORM } } }, // RENDERHAL_PLANES_Y210 { 2, { { MHW_Y_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16G16_UNORM }, { MHW_U_PLANE, 2, 1, 1, 1, 0, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_UNORM } } }, // RENDERHAL_PLANES_Y210_1PLANE_ADV { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 1, MHW_MEDIASTATE_SURFACEFORMAT_R16B16_UNORM } } }, // RENDERHAL_PLANES_R16G16_SINT { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16G16_SINT } } }, // RENDERHAL_PLANES_R24_UNORM_X8_TYPELESS { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R24_UNORM_X8_TYPELESS } } }, // RENDERHAL_PLANES_R32_FLOAT_X8X24_TYPELESS { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 0, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R32_FLOAT_X8X24_TYPELESS } } }, // RENDERHAL_PLANES_P208 { 2, { { MHW_Y_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM }, { MHW_U_PLANE , 2, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8G8_UNORM } } }, // RENDERHAL_PLANES_P208_1PLANE_ADV { 1, { { MHW_GENERIC_PLANE, 1, 1, 2, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_YCRCB_NORMAL } } }, // RENDERHAL_PLANES_Y416_RT { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_UNORM } } }, // RENDERHAL_PLANES_R32G32B32A32 { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 0, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R32G32B32A32_FLOAT } } }, //RENDERHAL_PLANES_Y8_ADV { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_Y8_UNORM } } }, //RENDERHAL_PLANES_G32R32F { 1, { { MHW_GENERIC_PLANE, 1, 1, 1, 1, 0, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_UNORM } } }, //RENDERHAL_PLANES_NV12_2PLANES_COMBINED Combine 2 Luma Channel pixels into 1 pixel, so that kernel can reduce write times { 2, { {MHW_Y_PLANE, 2, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8G8_UNORM}, {MHW_U_PLANE, 2, 2, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8G8_UNORM} } }, //RENDERHAL_PLANES_P016_2PLANES_COMBINED Combine 2 Luma Channel pixels into 1 pixel, so that kernel can reduce write times { 2, { {MHW_Y_PLANE, 2, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16G16_UNORM}, {MHW_U_PLANE, 2, 2, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16G16_UNORM} } }, // RENDERHAL_PLANES_YUY2_2PLANES_WIDTH_UNALIGNED { 2, { { MHW_Y_PLANE, 1, 1, 2, 2, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8G8_UNORM }, { MHW_U_PLANE, 2, 1, 1, 2, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_UNORM } } }, }; //! //! \brief Get Align Unit //! \details Set HW alignment Unit //! \param uint16_t *pwWidthAlignUnit //! [out] Width Align Unit //! \param uint16_t *pwHeightAlignUnit //! [out] Height Align Unit //! \param PRENDERHAL_SURFACE pRenderHalSurface //! [in] Pointer to Surface //! \return void //! void RenderHal_GetAlignUnit( uint16_t *pwWidthAlignUnit, uint16_t *pwHeightAlignUnit, PRENDERHAL_SURFACE pRenderHalSurface) { MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pRenderHalSurface); switch (pRenderHalSurface->OsSurface.Format) { case Format_YUY2: case Format_UYVY: case Format_YVYU: case Format_VYUY: case Format_P208: *pwWidthAlignUnit = 1; // Height alignment should be 1 but is currently set to 2 because // of an issue in AVS scaling. *pwHeightAlignUnit = 2; break; default: *pwWidthAlignUnit = 1; *pwHeightAlignUnit = 1; break; } // For deinterlace messages, the width must be a multiple of 8. if (pRenderHalSurface->bDeinterlaceEnable) { *pwWidthAlignUnit = 8; } } //! //! \brief Adjust Boundary //! \details Adjust the height and width of the surface based on Boundary //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to Hardware Interface //! \param PRENDERHAL_SURFACE pRenderHalSurface //! [in] Pointer to Input Surface //! \param RENDERHAL_SS_BOUNDARY Boundary //! [in] How the adjustment needs to be done //! \param uint32_t *pdwSurfaceWidth //! [out] Adjusted surface width //! \param uint32_t *pdwSurfaceHeight //! [out] Adjusted surface height //! \return void //! void RenderHal_AdjustBoundary( PRENDERHAL_INTERFACE pRenderHal, PRENDERHAL_SURFACE pRenderHalSurface, RENDERHAL_SS_BOUNDARY Boundary, uint32_t *pdwSurfaceWidth, uint32_t *pdwSurfaceHeight) { uint16_t wWidthAlignUnit; uint16_t wHeightAlignUnit; MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pRenderHalSurface); MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pdwSurfaceWidth); MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pdwSurfaceHeight); PMOS_SURFACE pSurface = &(pRenderHalSurface->OsSurface); pRenderHal->pfnGetAlignUnit(&wWidthAlignUnit, &wHeightAlignUnit, pRenderHalSurface); switch (Boundary) { case RENDERHAL_SS_BOUNDARY_SRCRECT: *pdwSurfaceHeight = MOS_ALIGN_CEIL(MOS_MIN(pSurface->dwHeight, (uint32_t)pRenderHalSurface->rcSrc.bottom), wHeightAlignUnit); *pdwSurfaceWidth = MOS_ALIGN_CEIL(MOS_MIN(pSurface->dwWidth, (uint32_t)pRenderHalSurface->rcSrc.right), wWidthAlignUnit); break; case RENDERHAL_SS_BOUNDARY_DSTRECT: *pdwSurfaceHeight = MOS_ALIGN_CEIL(MOS_MIN(pSurface->dwHeight, (uint32_t)pRenderHalSurface->rcDst.bottom), wHeightAlignUnit); *pdwSurfaceWidth = MOS_ALIGN_CEIL(MOS_MIN(pSurface->dwWidth, (uint32_t)pRenderHalSurface->rcDst.right), wWidthAlignUnit); break; // align with max src rect case RENDERHAL_SS_BOUNDARY_MAXSRCRECT: *pdwSurfaceHeight = MOS_ALIGN_CEIL(MOS_MIN(pSurface->dwHeight, (uint32_t)pRenderHalSurface->rcMaxSrc.bottom), wHeightAlignUnit); *pdwSurfaceWidth = MOS_ALIGN_CEIL(MOS_MIN(pSurface->dwWidth, (uint32_t)pRenderHalSurface->rcMaxSrc.right), wWidthAlignUnit); break; case RENDERHAL_SS_BOUNDARY_ORIGINAL: default: *pdwSurfaceHeight = (pRenderHalSurface->dwHeightInUse == 0) ? MOS_ALIGN_CEIL(pSurface->dwHeight, wHeightAlignUnit) : pRenderHalSurface->dwHeightInUse; *pdwSurfaceWidth = (pRenderHalSurface->dwWidthInUse == 0) ? MOS_ALIGN_CEIL(pSurface->dwWidth, wWidthAlignUnit) : pRenderHalSurface->dwWidthInUse; break; } } //! //! \brief Get Pixels Per Sample //! \details Get Number of Pixels per Dataport Sample //! \param MOS_FORMAT format //! [in] Surface Format //! \param uint32_t *pdwPixelsPerSampleUV //! [in] Pointer to dwPixelsPerSampleUV //! \return void //! void RenderHal_GetPixelsPerSample( MOS_FORMAT format, uint32_t *pdwPixelsPerSampleUV) { MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pdwPixelsPerSampleUV); *pdwPixelsPerSampleUV = 0; switch (format) { CASE_PL3_FORMAT: CASE_PL3_RGB_FORMAT: *pdwPixelsPerSampleUV = 4; // 4 U/V pixels per dataport sample (uint32_t) break; // Y and UV surfaces have different formats CASE_PL2_FORMAT: case Format_400P: *pdwPixelsPerSampleUV = 2; // 2 UV pixels per dataport sample (uint32_t) break; default: *pdwPixelsPerSampleUV = 1; MHW_RENDERHAL_ASSERTMESSAGE("Incorrect Filter Format."); break; } } //! //! \brief Allocate GSH, SSH, ISH control structures and heaps //! \details Allocates State Heap control structure (system memory) //! and associated State Buffer in gfx/sys memory (GSH,ISH,SSH) //! initializes the State Heap control structure and state buffers /*----------------------------------------------------------------------------- | | GSH ORGANIZATION (GSH block in GFX memory) | | |===========================================| | | SYNC/PERF TAGS (SY) | | |-------------------------------------------| | | | | | MEDIA STATE [0] (MS) | | | | | |-------------------------------------------| | | | | | ... | | | | | |-------------------------------------------| | | | | | MEDIA STATE [Q-1] | | | | | |-------------------------------------------| | | | | | KERNEL SPILL AREA | | | | | |===========================================| | where SY = (sSettings.iSyncSize) bytes | MS = Media state heap entry shown below. | Q = (sSettings.iMediaStateHeaps) Media States | | ISH ORGANIZATION (ISH block in GFX memory) | ~~~~~~~~~~~~~~~~~~~~~~~~ | | |===========================================| | | | | | | | | | | | | | | |---+---+---+---+---+---+---+---+---+---+---| | | | | | | | | | | | | | | |---+---+-- --+---+---| | | KERNEL HEAP (KH) | | |---+---+-- --+---+---| | | | | | | | | | | | | | | |---+---+---+---+---+---+---+---+---+---+---| | | | | | | | | | | | | | | |-------------------------------------------| | | | | | SYSTEM ROUTINE (SIP Kernel) | | | | | |===========================================| | where KH = (sSettings.iKernelHeapSize) bytes in allocation | blocks of (sSettings.iKernelBlockSize) bytes | | MEDIA STATE ORGANIZATION (Media States in GFX memory) | ~~~~~~~~~~~~~~~~~~~~~~~~ | (Gen6, Gen7, Gen75 Layout) | |================================================| | | | | | CURBE DATA (C) | | | | | |------------------------------------------------| | | SAMPLER STATES [0] to [S-1] - for ID[0] | | | . | | | . | | | SAMPLER STATES [0] to [S-1] - for ID[M-1] | | |------------------------------------------------| | | SAMPLER 8x8 TABLE [0] | | | . | | | SAMPLER 8x8 TABLE [AS-1] | | |------------------------------------------------| | | MEDIA INTERFACE DESCRIPTOR [0] | | | . | | | . | | | MEDIA INTERFACE DESCRIPTOR [M-1] | | |------------------------------------------------| | | Kernel Execution start time (8 Bytes) | | |------------------------------------------------| | | Kernel Execution end time (8 Bytes) | | |------------------------------------------------| | | Component ID (4 Bytes) | | |------------------------------------------------| | | Reserved (44 Bytes) | | |================================================| | | (Gen8+ Layout) | |================================================| | | | | | CURBE DATA (C) | | | | | |------------------------------------------------| | | SAMPLER STATES [0] to [S-1] | | | VA SAMPLER 8x8 STATE [0] to [VA-1] | ID[0] | | AVS SAMPLER 8x8 STATE [0] to [AS-1] | | |------------------------------------------------| | | . | | | . | | | . | | |------------------------------------------------| | | SAMPLER STATES [0] to [S-1] | ID[M-1] | | VA SAMPLER 8x8 STATE [0] to [VA-1] | | | AVS SAMPLER 8x8 STATE [0] to [AS-1] | | |------------------------------------------------| | | MEDIA INTERFACE DESCRIPTOR [0] | | | . | | | . | | | MEDIA INTERFACE DESCRIPTOR [M-1] | | |------------------------------------------------| | | Kernel Execution start time (8 Bytes) | | |------------------------------------------------| | | Kernel Execution end time (8 Bytes) | | |------------------------------------------------| | | Component ID (4 Bytes) | | |------------------------------------------------| | | Reserved (44 Bytes) | | |================================================| | | where C = (sSettings.iCurbeSize) bytes for static parameters | S = (sSettings.iSamplers) samplers per Media ID | AS = (sSettings.iSamplersAVS) advanced sampler 8x8 tables (preGen8) | AS = (sSettings.iSamplersAVS) advanced sampler 8x8 states (Gen8+) | VA = (sSettings.iSamplersVA) video analytics sampler | M = (sSettings.iMediaIDs) Media Interface Descriptors (ID) | | | STATE HEAP CONTROL STRUCTURE ORGANIZATION (in system memory) | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |===========================================| | | RENDERHAL_STATE_HEAP STRUCTURE | | | | | +---------| pSshBuffer | | | |-------------------------------------------| | | | Kernel Allocation [0] | | | | . | | | | . | | | | Kernel Allocation [K-1] | | | |-------------------------------------------| | | | Media State Control Structure [0] |--+ | | | Media State Control Structure [1] |--|--+ | | | . | | | | | | . | | | | | | Media State Control Structure [Q-1] |--|--|--+ | | |-------------------------------------------| | | | | | | KAID[0] to KAID[M-1] for Media State[0] |<-+ | | | | | KAID[0] to KAID[M-1] for Media State[1] |<----+ | | | | . | | | | | . | | | | | KAID[0] to KAID[M-1] for Media State[Q-1] |<-------+ | | |-------------------------------------------| | | +------| SurfStateEntry[0] | | | | | . | | | | | . | | | | +---| SurfStateEntry[P-1] | | | | | |===========================================| | | | | | | | | SSH BUFFER for HW (or SW) - or IndirectBuffer | +--|--|-->|==============================| <-- iBindingTableOffset = 0 | | | | BI[0] ...... BI[T-1] | <- BT[0] (iBindingTableSize) | | | | BI[0] ...... BI[T-1] | <- BT[1] | | | | . | | | | | BI[0] ...... BI[T-1] | <- BT[N-1] | | | |------------------------------| <-- iSurfaceStateOffset | +--|-->| SurfState[0] | | | | . | | | | . | | +-->| SurfState[P-1] | | |==============================| | | where K = (sSettings.iKernelCount) Kernel Allocation Entries | Q = (sSettings.iMediaStateHeaps) Media States | M = (sSettings.iMediaIDs) Media Interface Descriptors (ID) | P = (sSettings.iSurfaceStates) Surface States | T = (sSettings.iSurfacesPerBT) Binding Index entries per Binding Table | N = (sSettings.iBindingTables) Binding Tables | | BT = Binding Table (Each Binding Table contains M Binding Indices) | BI = Binding Index | | KAID => Kernel Allocation ID - each value determines the kernel | allocation entry in StateHeap (0 to sSettings.iKernelCount - 1) | |-----------------------------------------------------------------------------*/ //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to Rendering Interface Structure //! \param PRENDERHAL_STATE_HEAP_SETTINGS pSettings //! [in] Pointer to state heap settings (GSH/SSH/ISH) //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if state heaps were successfully allocated and initialized //! others if bad parameters or allocation failed //! MOS_STATUS RenderHal_AllocateStateHeaps( PRENDERHAL_INTERFACE pRenderHal, PRENDERHAL_STATE_HEAP_SETTINGS pSettings) { MHW_STATE_HEAP_SETTINGS MhwStateHeapSettings; PMHW_RENDER_STATE_SIZES pHwSizes; PRENDERHAL_STATE_HEAP pStateHeap; int32_t *pAllocations; uint32_t dwSizeAlloc; uint32_t dwSizeGSH; uint32_t dwSizeSSH; uint32_t dwSizeISH; uint32_t dwSizeMediaState; PMHW_STATE_HEAP pDshHeap; PMHW_STATE_HEAP pIshHeap; int32_t i; uint8_t *ptr; uint8_t *ptrMediaState = nullptr; MOS_STATUS eStatus; size_t mediaStateSize = 0; size_t stateHeapSize = 0; // Initialize locals eStatus = MOS_STATUS_UNKNOWN; pStateHeap = nullptr; //--------------------------------------- MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pRenderHalPltInterface); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pHwSizes); MHW_RENDERHAL_CHK_NULL_RETURN(pSettings); // verify GSH parameters and alignments MHW_RENDERHAL_ASSERT((pSettings->iSyncSize % RENDERHAL_SYNC_BLOCK_ALIGN) == 0); MHW_RENDERHAL_ASSERT((pSettings->iCurbeSize % RENDERHAL_URB_BLOCK_ALIGN) == 0); MHW_RENDERHAL_ASSERT((pSettings->iKernelHeapSize % RENDERHAL_KERNEL_BLOCK_ALIGN) == 0); MHW_RENDERHAL_ASSERT((pSettings->iKernelBlockSize % RENDERHAL_KERNEL_BLOCK_ALIGN) == 0); // verify SSH parameters MHW_RENDERHAL_ASSERT(pSettings->iBindingTables >= RENDERHAL_SSH_BINDING_TABLES_MIN); MHW_RENDERHAL_ASSERT(pSettings->iBindingTables <= RENDERHAL_SSH_BINDING_TABLES_MAX); MHW_RENDERHAL_ASSERT(pSettings->iSurfaceStates >= RENDERHAL_SSH_SURFACE_STATES_MIN); MHW_RENDERHAL_ASSERT(pSettings->iSurfaceStates <= RENDERHAL_SSH_SURFACE_STATES_MAX); MHW_RENDERHAL_ASSERT(pSettings->iSurfacesPerBT >= RENDERHAL_SSH_SURFACES_PER_BT_MIN); MHW_RENDERHAL_ASSERT(pSettings->iSurfacesPerBT <= RENDERHAL_SSH_SURFACES_PER_BT_MAX); //--------------------------------------- pHwSizes = pRenderHal->pHwSizes; mediaStateSize = pRenderHal->pRenderHalPltInterface->GetRenderHalMediaStateSize(); stateHeapSize = pRenderHal->pRenderHalPltInterface->GetRenderHalStateHeapSize(); //--------------------------------------- // Setup General State Heap //--------------------------------------- // Calculate size of State Heap control structure dwSizeAlloc = MOS_ALIGN_CEIL(stateHeapSize, 16); dwSizeAlloc += MOS_ALIGN_CEIL(pSettings->iKernelCount * sizeof(RENDERHAL_KRN_ALLOCATION) , 16); dwSizeAlloc += MOS_ALIGN_CEIL(pSettings->iMediaStateHeaps * mediaStateSize, 16); dwSizeAlloc += MOS_ALIGN_CEIL(pSettings->iMediaStateHeaps * pSettings->iMediaIDs * sizeof(int32_t) , 16); dwSizeAlloc += MOS_ALIGN_CEIL(pSettings->iSurfaceStates * sizeof(RENDERHAL_SURFACE_STATE_ENTRY), 16); // Allocate State Heap control structure (aligned) pRenderHal->pStateHeap = pStateHeap = (PRENDERHAL_STATE_HEAP)MOS_AlignedAllocMemory(dwSizeAlloc, 16); pRenderHal->dwStateHeapSize = dwSizeAlloc; MHW_RENDERHAL_CHK_NULL_RETURN(pStateHeap); MOS_ZeroMemory(pStateHeap, dwSizeAlloc); //------------------------------------------------------------------------- // Reset resource allocations //------------------------------------------------------------------------- pRenderHal->pOsInterface->pfnResetResource(&pStateHeap->GshOsResource); pStateHeap->bGshLocked = false; pStateHeap->pGshBuffer = nullptr; pRenderHal->pOsInterface->pfnResetResource(&pStateHeap->SshOsResource); pStateHeap->pSshBuffer = nullptr; pStateHeap->bSshLocked = false; pRenderHal->pOsInterface->pfnResetResource(&pStateHeap->IshOsResource); pStateHeap->bIshLocked = false; pStateHeap->pIshBuffer = nullptr; //------------------------------------------------------------------------- // Setup State Heap control structures //------------------------------------------------------------------------- // Skip RENDERHAL_STATE_HEAP structure ptr = (uint8_t*)pStateHeap; ptr += MOS_ALIGN_CEIL(stateHeapSize, 16); // Pointer to Kernel allocations pStateHeap->pKernelAllocation = (PRENDERHAL_KRN_ALLOCATION) ptr; ptr += MOS_ALIGN_CEIL(pSettings->iKernelCount * sizeof(RENDERHAL_KRN_ALLOCATION), 16); // Pointer to Media State allocations pStateHeap->pMediaStates = (PRENDERHAL_MEDIA_STATE) ptr; ptr += MOS_ALIGN_CEIL(pSettings->iMediaStateHeaps * mediaStateSize, 16); // Pointer to Media ID allocations pAllocations = (int32_t*) ptr; ptr += MOS_ALIGN_CEIL(pSettings->iMediaStateHeaps * pSettings->iMediaIDs * sizeof(int32_t), 16); // Pointer to Surface State allocations pStateHeap->pSurfaceEntry = (PRENDERHAL_SURFACE_STATE_ENTRY) ptr; //------------------------------------------------------------------------- // Calculate offsets/sizes in GSH //------------------------------------------------------------------------- // Synchronization, debugging data pStateHeap->dwOffsetSync = 0; pStateHeap->dwSizeSync = pSettings->iSyncSize; pStateHeap->dwNextTag = 0; pStateHeap->dwSyncTag = 0; dwSizeGSH = pStateHeap->dwSizeSync; // Align Media State base dwSizeGSH = MOS_ALIGN_CEIL(dwSizeGSH, MHW_MEDIA_STATE_ALIGN); dwSizeMediaState = 0; // Reset current media state pStateHeap->iCurMediaState = 0; pStateHeap->iNextMediaState = 0; // Constant URBs pStateHeap->dwOffsetCurbe = dwSizeMediaState; pStateHeap->dwSizeCurbe = pSettings->iCurbeSize; dwSizeMediaState += pStateHeap->dwSizeCurbe; // Allocate Samplers if (pRenderHal->bHasCombinedAVSSamplerState == false) { // Sampler states pStateHeap->dwOffsetSampler = dwSizeMediaState; pStateHeap->dwSizeSampler = MOS_ALIGN_CEIL(pSettings->iSamplers * pHwSizes->dwSizeSamplerState, MHW_SAMPLER_STATE_ALIGN); pStateHeap->dwSizeSamplers = pStateHeap->dwSizeSampler; dwSizeMediaState += pSettings->iMediaIDs * pStateHeap->dwSizeSamplers; // Sampler 8x8 State table is allocated in this area pStateHeap->dwOffsetSampler8x8Table = dwSizeMediaState; pStateHeap->dwSizeSampler8x8Table = MOS_ALIGN_CEIL(pHwSizes->dwSizeSamplerStateTable8x8, MHW_SAMPLER_STATE_ALIGN); dwSizeMediaState += pSettings->iSamplersAVS * pHwSizes->dwSizeSampler8x8Table; } else { // Sampler states - Start of this area to be aligned on MHW_SAMPLER_STATE_ALIGN byte boundary uint32_t dwOffsetSamplers = dwSizeMediaState; pStateHeap->dwOffsetSampler = dwSizeMediaState; pStateHeap->dwSizeSampler = MOS_ALIGN_CEIL(pSettings->iSamplers * pHwSizes->dwSizeSamplerState, MHW_SAMPLER_STATE_ALIGN); dwSizeMediaState += pStateHeap->dwSizeSampler; // Sampler for MinMax, Erode and Dilate - Start of this area to be aligned on MHW_SAMPLER_STATE_VA_ALIGN byte boundary pStateHeap->dwOffsetSamplerVA = dwSizeMediaState; pStateHeap->dwSizeSamplerVA = MOS_ALIGN_CEIL(pSettings->iSamplersVA * pHwSizes->dwSizeSamplerStateVA, MHW_SAMPLER_STATE_VA_ALIGN); dwSizeMediaState += pStateHeap->dwSizeSamplerVA; // Sampler for AVS - Start of this area to be aligned on 64 byte boundary if(GFX_IS_GEN_9_OR_LATER(pRenderHal->Platform)) { // AVS state should begin on MHW_SAMPLER_STATE_AVS_ALIGN_G9 byte boundary in g9+ dwSizeMediaState = MOS_ALIGN_CEIL((dwSizeMediaState - pStateHeap->dwSizeCurbe), MHW_SAMPLER_STATE_AVS_ALIGN_G9) + pStateHeap->dwSizeCurbe; } pStateHeap->dwOffsetSamplerAVS = dwSizeMediaState; pStateHeap->dwSizeSamplerAVS = MOS_ALIGN_CEIL(pSettings->iSamplersAVS * pHwSizes->dwSizeSamplerStateAvs, MHW_SAMPLER_STATE_AVS_ALIGN); dwSizeMediaState += pStateHeap->dwSizeSamplerAVS; // Sampler Indirect State pStateHeap->dwOffsetSamplerIndirect = dwSizeMediaState; pStateHeap->dwSizeSamplerIndirect = MOS_ALIGN_CEIL(pSettings->iSamplers * pHwSizes->dwSizeSamplerIndirectState, MHW_SAMPLER_STATE_ALIGN); dwSizeMediaState += pStateHeap->dwSizeSamplerIndirect; // Get the total size of all the samplers pStateHeap->dwSizeSamplers = MOS_ALIGN_CEIL((dwSizeMediaState - dwOffsetSamplers), MHW_SAMPLER_STATE_ALIGN); dwSizeMediaState += pSettings->iMediaIDs * pStateHeap->dwSizeSamplers; // Sampler 8x8 State table is part of Sampler8x8 state pStateHeap->dwOffsetSampler8x8Table = 0; pStateHeap->dwSizeSampler8x8Table = pHwSizes->dwSizeSamplerStateTable8x8; } // Interface Descriptors pStateHeap->dwOffsetMediaID = dwSizeMediaState; pStateHeap->dwSizeMediaID = pHwSizes->dwSizeInterfaceDescriptor; dwSizeMediaState += pSettings->iMediaIDs * pStateHeap->dwSizeMediaID; // 3P Budget pStateHeap->dwOffsetStartTime = dwSizeMediaState; pStateHeap->dwStartTimeSize = sizeof(uint64_t); dwSizeMediaState += pStateHeap->dwStartTimeSize; pStateHeap->dwOffsetEndTime = dwSizeMediaState; pStateHeap->dwEndTimeSize = sizeof(uint64_t); dwSizeMediaState += pStateHeap->dwEndTimeSize; pStateHeap->dwOffsetComponentID = dwSizeMediaState; pStateHeap->dwComponentIDSize = sizeof(uint32_t); dwSizeMediaState += pStateHeap->dwComponentIDSize; pStateHeap->dwOffsetReserved = dwSizeMediaState; pStateHeap->dwReservedSize = 44; // 64 - 2 * sizeof(uint64_t) - sizeof(uint32_t); dwSizeMediaState += pStateHeap->dwReservedSize; // Ensure correct alignment of consecutive Media States if(GFX_IS_GEN_9_OR_LATER(pRenderHal->Platform)) { dwSizeMediaState = MOS_ALIGN_CEIL(dwSizeMediaState, MHW_SAMPLER_STATE_AVS_ALIGN_G9); } else { dwSizeMediaState = MOS_ALIGN_CEIL(dwSizeMediaState, MHW_SAMPLER_STATE_AVS_ALIGN); } // Create multiple instances of Media state heaps for Dynamic GSH ptrMediaState = (uint8_t*)pStateHeap->pMediaStates; for (i = 0; i < pSettings->iMediaStateHeaps; i++) { PRENDERHAL_MEDIA_STATE pStat = (PRENDERHAL_MEDIA_STATE)ptrMediaState; pStat->dwOffset = dwSizeGSH; pStat->piAllocation = pAllocations; dwSizeGSH += dwSizeMediaState; pAllocations += pSettings->iMediaIDs; // Pointer moves to next MEDIA STATE position ptrMediaState += mediaStateSize; } // Kernel Spill Area if (pSettings->iPerThreadScratchSize > 0) { // Scratch Space Base Pointer. Specifies the MHW_SCRATCH_SPACE_ALIGN // aligned address offset to scratch space for use by the kernel. // This pointer is relative to the General State Base Address. dwSizeGSH = MOS_ALIGN_CEIL(dwSizeGSH, MHW_SCRATCH_SPACE_ALIGN); MHW_RENDERHAL_ASSERT(pSettings->iPerThreadScratchSize == MOS_ALIGN_CEIL(pSettings->iPerThreadScratchSize, MHW_SCRATCH_SPACE_ALIGN)); pStateHeap->dwScratchSpaceSize = pRenderHal->pfnGetScratchSpaceSize(pRenderHal, pSettings->iPerThreadScratchSize); pStateHeap->dwScratchSpaceBase = dwSizeGSH; dwSizeGSH += pStateHeap->dwScratchSpaceSize; } pStateHeap->dwSizeGSH = dwSizeGSH; pStateHeap->dwSizeMediaState = dwSizeMediaState; //---------------------------------- // Instruction State Heap (Kernel Heap) //---------------------------------- pStateHeap->dwKernelBase = 0; dwSizeISH = MOS_ALIGN_CEIL(pSettings->iKernelHeapSize, RENDERHAL_KERNEL_BLOCK_ALIGN); // System Routine Area, always loaded for Cm // Don't put the allocation under bIsaAsmDebugEnable pStateHeap->dwSipBase = dwSizeISH; pRenderHal->SipStateParams.bSipKernel = false; pRenderHal->SipStateParams.dwSipBase = dwSizeISH; dwSizeISH += MOS_ALIGN_CEIL(pSettings->iSipSize, RENDERHAL_KERNEL_BLOCK_ALIGN); pStateHeap->dwSizeISH = dwSizeISH; //---------------------------------- // Surface State Heap //---------------------------------- // Reset initial SSH allocations pStateHeap->iCurSshBufferIndex = 0; pStateHeap->iCurrentBindingTable = 0; pStateHeap->iCurrentSurfaceState = 0; if (pRenderHal->isBindlessHeapInUse == false) { // Set BT sizes pStateHeap->iBindingTableSize = MOS_ALIGN_CEIL(pSettings->iSurfacesPerBT * pHwSizes->dwSizeBindingTableState, pSettings->iBTAlignment); // Set offsets to BT and SS entries pStateHeap->iBindingTableOffset = 0; pStateHeap->iSurfaceStateOffset = pSettings->iBindingTables * pStateHeap->iBindingTableSize; // Calculate size of a single SSH instance and total SSH buffer size dwSizeSSH = pStateHeap->iSurfaceStateOffset + pSettings->iSurfaceStates * pRenderHal->pRenderHalPltInterface->GetSurfaceStateCmdSize(); pStateHeap->dwSshIntanceSize = dwSizeSSH; pRenderHal->dwIndirectHeapSize = MOS_ALIGN_CEIL(dwSizeSSH, MHW_PAGE_SIZE); // Allocate SSH buffer in system memory, not Gfx pStateHeap->dwSizeSSH = dwSizeSSH; // Single SSH instance pStateHeap->pSshBuffer = (uint8_t *)MOS_AllocAndZeroMemory(dwSizeSSH); } else { if (!pStateHeap->surfaceStateMgr) { pStateHeap->surfaceStateMgr = MOS_New(SurfaceStateHeapManager, pRenderHal->pOsInterface); if (pStateHeap->surfaceStateMgr == nullptr) { MHW_RENDERHAL_ASSERTMESSAGE("Fail to Allocate SSH manager."); // Free State Heap control structure MOS_AlignedFreeMemory(pStateHeap); pRenderHal->pStateHeap = nullptr; return MOS_STATUS_NULL_POINTER; } eStatus = pStateHeap->surfaceStateMgr->CreateHeap(pRenderHal->pRenderHalPltInterface->GetSurfaceStateCmdSize()); if (eStatus != MOS_STATUS_SUCCESS) { MHW_RENDERHAL_ASSERTMESSAGE("Fail to Allocate SSH manager."); MHW_RENDERHAL_CHK_STATUS_RETURN(pStateHeap->surfaceStateMgr->DestroyHeap()); // Free State Heap control structure MOS_AlignedFreeMemory(pStateHeap); pRenderHal->pStateHeap = nullptr; return eStatus; } pStateHeap->iCurrentSurfaceState = pStateHeap->surfaceStateMgr->m_surfStateHeap->uiCurState; } } do { if (pStateHeap->dwSizeSSH > 0 && !pStateHeap->pSshBuffer) { MHW_RENDERHAL_ASSERTMESSAGE("Fail to Allocate SSH buffer."); eStatus = MOS_STATUS_NO_SPACE; break; } pStateHeap->bSshLocked = true; //---------------------------------- // Allocate State Heap in MHW //---------------------------------- MOS_ZeroMemory(&MhwStateHeapSettings, sizeof(MhwStateHeapSettings)); MhwStateHeapSettings.dwDshSize = pStateHeap->dwSizeGSH; MhwStateHeapSettings.dwIshSize = pStateHeap->dwSizeISH; MhwStateHeapSettings.dwNumSyncTags = pStateHeap->dwSizeSync; MhwStateHeapSettings.m_heapUsageType = pSettings->heapUsageType; if (pRenderHal->pRenderHalPltInterface->AllocateHeaps(pRenderHal, MhwStateHeapSettings) != MOS_STATUS_SUCCESS) { break; } if (pRenderHal->pRenderHalPltInterface->GetStateHeapInterface(pRenderHal)==nullptr) { break; } pDshHeap = pRenderHal->pMhwStateHeap->GetDSHPointer(); if (pRenderHal->pMhwStateHeap->GetDynamicMode() == MHW_RENDER_HAL_MODE) { while (pDshHeap->pNext != nullptr) { pDshHeap = pDshHeap->pNext; } } if (pRenderHal->pMhwStateHeap->LockStateHeap(pDshHeap) != MOS_STATUS_SUCCESS) { break; } pStateHeap->GshOsResource = pDshHeap->resHeap; pStateHeap->pGshBuffer = (uint8_t *)pDshHeap->pvLockedHeap; pStateHeap->bGshLocked = true; pIshHeap = pRenderHal->pMhwStateHeap->GetISHPointer(); if (pRenderHal->pMhwStateHeap->GetDynamicMode() == MHW_RENDER_HAL_MODE) { while (pIshHeap->pNext != nullptr) { pIshHeap = pIshHeap->pNext; } } if (pRenderHal->pMhwStateHeap->LockStateHeap(pIshHeap) != MOS_STATUS_SUCCESS) { break; } pStateHeap->IshOsResource = pIshHeap->resHeap; pStateHeap->pIshBuffer = (uint8_t *)pIshHeap->pvLockedHeap; pStateHeap->bIshLocked = true; //----------------------------- // Heap initialization //----------------------------- // Reset GSH contents until scratch space (excluding) MOS_ZeroMemory(pStateHeap->pGshBuffer, pStateHeap->dwScratchSpaceBase); // Setup pointer to sync tags pStateHeap->pSync = (uint32_t *)(pStateHeap->pGshBuffer + pStateHeap->dwOffsetSync); // Reset kernel allocations pRenderHal->pfnResetKernels(pRenderHal); eStatus = MOS_STATUS_SUCCESS; } while (false); if (eStatus != MOS_STATUS_SUCCESS) { if (pStateHeap) { // Free SSH buffer if (pStateHeap->pSshBuffer) { MOS_FreeMemory(pStateHeap->pSshBuffer); } // Free State Heap control structure MOS_AlignedFreeMemory(pStateHeap); pRenderHal->pStateHeap = nullptr; } } return eStatus; } MOS_STATUS RenderHal_ReAllocateStateHeapsforAdvFeatureWithSshEnlarged( PRENDERHAL_INTERFACE pRenderHal, bool &bAllocated) { PMOS_INTERFACE pOsInterface = nullptr; PRENDERHAL_STATE_HEAP pStateHeap = nullptr; PRENDERHAL_STATE_HEAP pOldStateHeap = nullptr; uint8_t *ptr = nullptr; int32_t *pAllocations = nullptr; PRENDERHAL_STATE_HEAP_SETTINGS pSettings = nullptr; uint8_t *ptrMediaState = nullptr; MOS_STATUS eStatus = MOS_STATUS_SUCCESS; PMHW_RENDER_STATE_SIZES pHwSizes = {}; uint32_t dwSizeAlloc = 0; uint32_t dwSizeSSH = 0; int32_t i = 0; uint32_t dwSizeGSH = 0; uint32_t dwSizeMediaState = 0; size_t mediaStateSize = 0; size_t stateHeapSize = 0; //------------------------------------------------ MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pHwSizes); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pRenderHalPltInterface); pSettings = &pRenderHal->StateHeapSettings; bAllocated = false; //------------------------------------------------ if (pRenderHal->pStateHeap == nullptr) { return MOS_STATUS_SUCCESS; } if ((pSettings->iBindingTables == pRenderHal->enlargeStateHeapSettingsForAdv.iBindingTables) && (pSettings->iSurfaceStates == pRenderHal->enlargeStateHeapSettingsForAdv.iSurfaceStates) && (pSettings->iSurfacesPerBT == pRenderHal->enlargeStateHeapSettingsForAdv.iSurfacesPerBT)) { return MOS_STATUS_SUCCESS; } pOsInterface = pRenderHal->pOsInterface; pOldStateHeap = pRenderHal->pStateHeap; pHwSizes = pRenderHal->pHwSizes; // Free SSH Resource if (pOldStateHeap->pSshBuffer) { MOS_FreeMemory(pOldStateHeap->pSshBuffer); pOldStateHeap->pSshBuffer = nullptr; } // Free MOS surface in surface state entry for (int32_t index = 0; index < pSettings->iSurfaceStates; ++index) { PRENDERHAL_SURFACE_STATE_ENTRY entry = pOldStateHeap->pSurfaceEntry + index; MOS_SafeFreeMemory(entry->pSurface); entry->pSurface = nullptr; } // Enlarge the binding table size and surface state size pSettings->iBindingTables = pRenderHal->enlargeStateHeapSettingsForAdv.iBindingTables; pSettings->iSurfaceStates = pRenderHal->enlargeStateHeapSettingsForAdv.iSurfaceStates; pSettings->iSurfacesPerBT = pRenderHal->enlargeStateHeapSettingsForAdv.iSurfacesPerBT; mediaStateSize = pRenderHal->pRenderHalPltInterface->GetRenderHalMediaStateSize(); stateHeapSize = pRenderHal->pRenderHalPltInterface->GetRenderHalStateHeapSize(); //--------------------------------------- // Setup General State Heap //--------------------------------------- // Calculate size of State Heap control structure dwSizeAlloc = MOS_ALIGN_CEIL(stateHeapSize , 16); dwSizeAlloc += MOS_ALIGN_CEIL(pSettings->iKernelCount * sizeof(RENDERHAL_KRN_ALLOCATION) , 16); dwSizeAlloc += MOS_ALIGN_CEIL(pSettings->iMediaStateHeaps * mediaStateSize , 16); dwSizeAlloc += MOS_ALIGN_CEIL(pSettings->iMediaStateHeaps * pSettings->iMediaIDs * sizeof(int32_t) , 16); dwSizeAlloc += MOS_ALIGN_CEIL(pSettings->iSurfaceStates * sizeof(RENDERHAL_SURFACE_STATE_ENTRY), 16); // Allocate State Heap control structure (aligned) pStateHeap = (PRENDERHAL_STATE_HEAP)MOS_AlignedAllocMemory(dwSizeAlloc, 16); pRenderHal->dwStateHeapSize = dwSizeAlloc; MHW_RENDERHAL_CHK_NULL_RETURN(pStateHeap); MOS_ZeroMemory(pStateHeap, dwSizeAlloc); MOS_SecureMemcpy(pStateHeap, dwSizeAlloc, pOldStateHeap, dwSizeAlloc - MOS_ALIGN_CEIL(pSettings->iSurfaceStates * sizeof(RENDERHAL_SURFACE_STATE_ENTRY), 16)); // Update the State Heap pRenderHal->pStateHeap = pStateHeap; //------------------------------------------------------------------------- // Setup State Heap control structures //------------------------------------------------------------------------- // Skip RENDERHAL_STATE_HEAP structure ptr = (uint8_t *)pStateHeap; ptr += MOS_ALIGN_CEIL(stateHeapSize, 16); // Pointer to Kernel allocations pStateHeap->pKernelAllocation = (PRENDERHAL_KRN_ALLOCATION)ptr; ptr += MOS_ALIGN_CEIL(pSettings->iKernelCount * sizeof(RENDERHAL_KRN_ALLOCATION), 16); // Pointer to Media State allocations pStateHeap->pMediaStates = (PRENDERHAL_MEDIA_STATE)ptr; ptr += MOS_ALIGN_CEIL(pSettings->iMediaStateHeaps * mediaStateSize, 16); // Pointer to Media ID allocations pAllocations = (int32_t *)ptr; ptr += MOS_ALIGN_CEIL(pSettings->iMediaStateHeaps * pSettings->iMediaIDs * sizeof(int32_t), 16); // Pointer to Surface State allocations pStateHeap->pSurfaceEntry = (PRENDERHAL_SURFACE_STATE_ENTRY)ptr; dwSizeMediaState = pStateHeap->dwSizeMediaState; // Reset current media state pStateHeap->iCurMediaState = 0; pStateHeap->iNextMediaState = 0; dwSizeGSH = pStateHeap->dwSizeSync; // Align Media State base dwSizeGSH = MOS_ALIGN_CEIL(dwSizeGSH, MHW_MEDIA_STATE_ALIGN); // Create multiple instances of Media state heaps for Dynamic GSH ptrMediaState = (uint8_t *)pStateHeap->pMediaStates; for (i = 0; i < pSettings->iMediaStateHeaps; i++) { PRENDERHAL_MEDIA_STATE pStat = (PRENDERHAL_MEDIA_STATE)ptrMediaState; pStat->dwOffset = dwSizeGSH; pStat->piAllocation = pAllocations; dwSizeGSH += dwSizeMediaState; pAllocations += pSettings->iMediaIDs; // Pointer moves to next MEDIA STATE position ptrMediaState += mediaStateSize; } //---------------------------------- // Surface State Heap //---------------------------------- // Reset initial SSH allocations pStateHeap->iCurSshBufferIndex = 0; pStateHeap->iCurrentBindingTable = 0; pStateHeap->iCurrentSurfaceState = 0; // Set BT sizes pStateHeap->iBindingTableSize = MOS_ALIGN_CEIL(pSettings->iSurfacesPerBT * pHwSizes->dwSizeBindingTableState, pSettings->iBTAlignment); // Set offsets to BT and SS entries pStateHeap->iBindingTableOffset = 0; pStateHeap->iSurfaceStateOffset = pSettings->iBindingTables * pStateHeap->iBindingTableSize; // Calculate size of a single SSH instance and total SSH buffer size dwSizeSSH = pStateHeap->iSurfaceStateOffset + pSettings->iSurfaceStates * pRenderHal->pRenderHalPltInterface->GetSurfaceStateCmdSize(); pStateHeap->dwSshIntanceSize = dwSizeSSH; pRenderHal->dwIndirectHeapSize = MOS_ALIGN_CEIL(dwSizeSSH, MHW_PAGE_SIZE); // Allocate SSH buffer in system memory, not Gfx pStateHeap->dwSizeSSH = dwSizeSSH; // Single SSH instance pStateHeap->pSshBuffer = (uint8_t*)MOS_AllocAndZeroMemory(dwSizeSSH); if (!pStateHeap->pSshBuffer) { MHW_RENDERHAL_ASSERTMESSAGE("Fail to Allocate SSH buffer."); eStatus = MOS_STATUS_NO_SPACE; return eStatus; } pStateHeap->bSshLocked = true; // Free State Heap Control structure MOS_AlignedFreeMemory(pOldStateHeap); pOldStateHeap = nullptr; eStatus = MOS_STATUS_SUCCESS; bAllocated = true; return eStatus; } MOS_STATUS RenderHal_ReAllocateStateHeapsforAdvFeatureWithAllHeapsEnlarged( PRENDERHAL_INTERFACE pRenderHal, bool &bAllocated) { PRENDERHAL_STATE_HEAP_SETTINGS pRenderhalSettings = nullptr; PRENDERHAL_ENLARGE_PARAMS pParams = nullptr; MOS_STATUS eStatus = MOS_STATUS_SUCCESS; //------------------------------------------------ MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pHwSizes); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pRenderHalPltInterface); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap); pParams = &pRenderHal->enlargeStateHeapSettingsForAdv; pRenderhalSettings = &pRenderHal->StateHeapSettings; bAllocated = false; //------------------------------------------------ // Enlarge the binding table size and surface state size if ((pRenderhalSettings->iBindingTables == pParams->iBindingTables) && (pRenderhalSettings->iSurfaceStates == pParams->iSurfaceStates) && (pRenderhalSettings->iKernelCount == pParams->iKernelCount) && (pRenderhalSettings->iCurbeSize == pParams->iCurbeSize) && (pRenderhalSettings->iKernelHeapSize == pParams->iKernelHeapSize) && (pRenderhalSettings->iSurfacesPerBT == pParams->iSurfacesPerBT)) { return MOS_STATUS_SUCCESS; } // Free State Heaps(RenderHal_FreeStateHeaps): // Free state heap here will only destroy software allocations. // Will not destroy resources used by hw. MHW_RENDERHAL_CHK_STATUS_RETURN((MOS_STATUS)(pRenderHal->pfnFreeStateHeaps(pRenderHal))); pRenderhalSettings->iBindingTables = pParams->iBindingTables; pRenderhalSettings->iSurfaceStates = pParams->iSurfaceStates; pRenderhalSettings->iKernelCount = pParams->iKernelCount; pRenderhalSettings->iCurbeSize = pParams->iCurbeSize; pRenderhalSettings->iKernelHeapSize = pParams->iKernelHeapSize; pRenderhalSettings->iSurfacesPerBT = pParams->iSurfacesPerBT; eStatus = pRenderHal->pfnAllocateStateHeaps(pRenderHal, pRenderhalSettings); bAllocated = true; return eStatus; } //! //! \brief Free State Heaps (including MHW interfaces) //! \details Free State Heap resources allocated by RenderHal //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to Render Hal Interface //! \return MOS_STATUS //! MOS_STATUS RenderHal_FreeStateHeaps(PRENDERHAL_INTERFACE pRenderHal) { PMOS_INTERFACE pOsInterface; PRENDERHAL_STATE_HEAP pStateHeap; MOS_STATUS eStatus; //------------------------------------------------ MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface); //------------------------------------------------ if (pRenderHal->pStateHeap == nullptr) { return MOS_STATUS_SUCCESS; } eStatus = MOS_STATUS_UNKNOWN; pOsInterface = pRenderHal->pOsInterface; pStateHeap = pRenderHal->pStateHeap; // Free SSH Resource if (pStateHeap->pSshBuffer) { MOS_FreeMemory(pStateHeap->pSshBuffer); pStateHeap->pSshBuffer = nullptr; } if (pStateHeap->surfaceStateMgr) { MOS_Delete(pStateHeap->surfaceStateMgr); pStateHeap->surfaceStateMgr = nullptr; } // Free MOS surface in surface state entry for (int32_t index = 0; index < pRenderHal->StateHeapSettings.iSurfaceStates; ++index) { PRENDERHAL_SURFACE_STATE_ENTRY entry = pStateHeap->pSurfaceEntry + index; MOS_SafeFreeMemory(entry->pSurface); entry->pSurface = nullptr; } // Free State Heap Control structure MOS_AlignedFreeMemory(pStateHeap); pRenderHal->pStateHeap = nullptr; eStatus = MOS_STATUS_SUCCESS; return eStatus; } //! //! \brief Allocate BB //! \details Allocate Batch Buffer resource (not BB structure), //! attaching it to head of linked list in RenderHal. //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to Hardwaew interface structure //! \param PMHW_BATCH_BUFFER pBatchBuffer //! [out] Pointer to batch buffer structure to be initialized //! \param int32_t iSize //! [in] Size of the batch buffer to be allocated //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if the Batch Buffer was successfully allocated //! others if failed //! MOS_STATUS RenderHal_AllocateBB( PRENDERHAL_INTERFACE pRenderHal, PMHW_BATCH_BUFFER pBatchBuffer, int32_t iSize) { PMOS_INTERFACE pOsInterface; MOS_RESOURCE OsResource; MOS_ALLOC_GFXRES_PARAMS AllocParams; MOS_STATUS eStatus; //--------------------------------------------- MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface); MHW_RENDERHAL_CHK_NULL_RETURN(pBatchBuffer); //--------------------------------------------- eStatus = MOS_STATUS_UNKNOWN; pOsInterface = pRenderHal->pOsInterface; MOS_ZeroMemory(&OsResource, sizeof(OsResource)); MOS_ZeroMemory(&AllocParams, sizeof(MOS_ALLOC_GFXRES_PARAMS)); AllocParams.Type = MOS_GFXRES_BUFFER; AllocParams.TileType = MOS_TILE_LINEAR; AllocParams.Format = Format_Buffer; AllocParams.dwBytes = iSize; AllocParams.pBufName = "RenderHalBB"; AllocParams.ResUsageType = MOS_HW_RESOURCE_USAGE_MEDIA_BATCH_BUFFERS; MHW_RENDERHAL_CHK_STATUS_RETURN(pOsInterface->pfnAllocateResource( pOsInterface, &AllocParams, &OsResource)); // Reset Allocation pOsInterface->pfnResetResourceAllocationIndex( pOsInterface, &OsResource); pBatchBuffer->OsResource = OsResource; pBatchBuffer->iRemaining = iSize; pBatchBuffer->iSize = iSize; pBatchBuffer->iCurrent = 0; pBatchBuffer->bLocked = false; pBatchBuffer->pData = nullptr; pBatchBuffer->dwOffset = 0; pBatchBuffer->bBusy = false; pBatchBuffer->dwCmdBufId = 0; // Link BB to beginning of linked list pBatchBuffer->pPrev = nullptr; pBatchBuffer->pNext = pRenderHal->pBatchBufferList; pRenderHal->pBatchBufferList = pBatchBuffer; if (pBatchBuffer->pNext) { pBatchBuffer->pNext->pPrev = pBatchBuffer; } // Reset Sync/BB Reuse data pBatchBuffer->dwSyncTag = 0; pBatchBuffer->bMatch = false; eStatus = MOS_STATUS_SUCCESS; return eStatus; } //! //! \brief Free BB //! \details Frees Batch Buffer Resource (not structure), //! detaching it from linked list in RenderHal. //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to Hardware Interface Structure //! \param PMHW_BATCH_BUFFER pBatchBuffer //! [in] Pointer to Batch Buffer //! \return MOS_STATUS //! MOS_STATUS RenderHal_FreeBB( PRENDERHAL_INTERFACE pRenderHal, PMHW_BATCH_BUFFER pBatchBuffer) { PMOS_INTERFACE pOsInterface; MOS_STATUS eStatus; //---------------------------------------------- MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface); MHW_RENDERHAL_CHK_NULL_RETURN(pBatchBuffer); //---------------------------------------------- eStatus = MOS_STATUS_UNKNOWN; pOsInterface = pRenderHal->pOsInterface; if (pBatchBuffer->bLocked) { MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pfnUnlockBB(pRenderHal, pBatchBuffer)); } pOsInterface->pfnFreeResource(pOsInterface, &pBatchBuffer->OsResource); pBatchBuffer->dwSyncTag = 0; pBatchBuffer->iSize = 0; pBatchBuffer->iCurrent = 0; pBatchBuffer->bMatch = 0; // Unlink BB from synchronization list if (pBatchBuffer->pNext) { pBatchBuffer->pNext->pPrev = pBatchBuffer->pPrev; } if (pBatchBuffer->pPrev) { pBatchBuffer->pPrev->pNext = pBatchBuffer->pNext; } else { pRenderHal->pBatchBufferList = pBatchBuffer->pNext; } pBatchBuffer->pPrev = pBatchBuffer->pNext = nullptr; eStatus = MOS_STATUS_SUCCESS; return eStatus; } //! //! \brief Lock BB //! \details Locks Batch Buffer //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to Hardware Interface Structure //! \param PMHW_BATCH_BUFFER pBatchBuffer //! [in] Pointer to Batch Buffer //! \return MOS_STATUS //! MOS_STATUS RenderHal_LockBB( PRENDERHAL_INTERFACE pRenderHal, PMHW_BATCH_BUFFER pBatchBuffer) { PMOS_INTERFACE pOsInterface; MOS_LOCK_PARAMS LockFlags; MOS_STATUS eStatus; //----------------------------------- MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(pBatchBuffer); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface); //----------------------------------- eStatus = MOS_STATUS_UNKNOWN; pOsInterface = pRenderHal->pOsInterface; if (pBatchBuffer->bLocked) { MHW_RENDERHAL_ASSERTMESSAGE("Batch Buffer is already locked."); return eStatus; } MOS_ZeroMemory(&LockFlags, sizeof(MOS_LOCK_PARAMS)); LockFlags.WriteOnly = 1; pBatchBuffer->pData = (uint8_t*)pOsInterface->pfnLockResource( pOsInterface, &pBatchBuffer->OsResource, &LockFlags); MHW_RENDERHAL_CHK_NULL_RETURN(pBatchBuffer->pData); pBatchBuffer->bLocked = true; eStatus = MOS_STATUS_SUCCESS; return eStatus; } //! //! \brief Unlock BB //! \details Unlocks Batch Buffer //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to Hardware Interface Structure //! \param PMHW_BATCH_BUFFER pBatchBuffer //! [in] Pointer to Batch Buffer //! \return MOS_STATUS //! MOS_STATUS RenderHal_UnlockBB( PRENDERHAL_INTERFACE pRenderHal, PMHW_BATCH_BUFFER pBatchBuffer) { PMOS_INTERFACE pOsInterface; MOS_STATUS eStatus; //--------------------------------- MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(pBatchBuffer); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface); //--------------------------------- eStatus = MOS_STATUS_UNKNOWN; pOsInterface = pRenderHal->pOsInterface; if (!pBatchBuffer->bLocked) { MHW_RENDERHAL_ASSERTMESSAGE("Batch buffer is locked."); return eStatus; } MHW_RENDERHAL_CHK_STATUS_RETURN(pOsInterface->pfnUnlockResource( pOsInterface, &pBatchBuffer->OsResource)); pBatchBuffer->bLocked = false; eStatus = MOS_STATUS_SUCCESS; return eStatus; } //! //! \brief Refresh Sync //! \details Update Sync tags //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to Hardware Interface Structure //! \return MOS_STATUS //! MOS_STATUS RenderHal_RefreshSync(PRENDERHAL_INTERFACE pRenderHal) { PRENDERHAL_STATE_HEAP pStateHeap; PRENDERHAL_MEDIA_STATE pCurMediaState; PMHW_BATCH_BUFFER pBatchBuffer; uint32_t dwCurrentTag; int32_t i; int32_t iStatesInUse; int32_t iBuffersInUse; MOS_STATUS eStatus; MOS_NULL_RENDERING_FLAGS NullRenderingFlags; uint8_t *pCurrentPtr; uint64_t uiStartTime; uint64_t uiEndTime; uint64_t uiDiff; uint64_t uiNS; double TimeMS; uint32_t uiComponent; size_t mediaStateSize = 0; uint8_t *ptrMediaState = nullptr; //---------------------------------- MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pRenderHalPltInterface); //---------------------------------- eStatus = MOS_STATUS_UNKNOWN; pCurrentPtr = nullptr; uiNS = 0; mediaStateSize = pRenderHal->pRenderHalPltInterface->GetRenderHalMediaStateSize(); // GSH must be locked pStateHeap = pRenderHal->pStateHeap; if (!pStateHeap->bGshLocked) { return eStatus; } // Most recent tag dwCurrentTag = pStateHeap->pSync[0]; pStateHeap->dwSyncTag = dwCurrentTag - 1; // Refresh batch buffers iBuffersInUse = 0; pBatchBuffer = pRenderHal->pBatchBufferList; NullRenderingFlags = pRenderHal->pOsInterface->pfnGetNullHWRenderFlags( pRenderHal->pOsInterface); for (; pBatchBuffer != nullptr; pBatchBuffer = pBatchBuffer->pNext) { if (!pBatchBuffer->bBusy) continue; // Clear BB busy flag when Sync Tag is reached if ((int32_t)(dwCurrentTag - pBatchBuffer->dwSyncTag) > 0 || NullRenderingFlags.VPGobal) { pBatchBuffer->bBusy = false; } else { iBuffersInUse++; } } // Refresh media states if(pRenderHal->StateHeapSettings.iMediaStateHeaps > 0) { MHW_RENDERHAL_CHK_NULL_RETURN(pStateHeap->pMediaStates); } ptrMediaState = (uint8_t*)pStateHeap->pMediaStates; pCurMediaState = pStateHeap->pMediaStates; iStatesInUse = 0; for (i = pRenderHal->StateHeapSettings.iMediaStateHeaps; i > 0; i--, pCurMediaState = (PRENDERHAL_MEDIA_STATE)ptrMediaState) { ptrMediaState += mediaStateSize; if (!pCurMediaState->bBusy) continue; // The condition below is valid when sync tag wraps from 2^32-1 to 0 if ((int32_t)(dwCurrentTag - pCurMediaState->dwSyncTag) > 0) { pCurMediaState->bBusy = false; if (pRenderHal->bKerneltimeDump) { // Dump Kernel execution time when media state is being freed pCurrentPtr = pStateHeap->pGshBuffer + pCurMediaState->dwOffset + pStateHeap->dwOffsetStartTime; if (pCurrentPtr) { uiStartTime = *((uint64_t *) pCurrentPtr); pCurrentPtr += pStateHeap->dwStartTimeSize; uiEndTime = *((uint64_t *) pCurrentPtr); pCurrentPtr += pStateHeap->dwEndTimeSize; uiComponent = *((RENDERHAL_COMPONENT *) pCurrentPtr); if (uiComponent < (uint32_t)RENDERHAL_COMPONENT_COUNT) { // Convert ticks to ns uiDiff = uiEndTime - uiStartTime; uiNS = 0; pRenderHal->pfnConvertToNanoSeconds(pRenderHal, uiDiff, &uiNS); TimeMS = ((double)uiNS) / (1000 * 1000); // Convert to ms (double) pRenderHal->kernelTime[uiComponent] += TimeMS; } } } } else { iStatesInUse++; } } // Save number of states/buffers in use pRenderHal->iBuffersInUse = iBuffersInUse; pRenderHal->iMediaStatesInUse = iStatesInUse; eStatus = MOS_STATUS_SUCCESS; return eStatus; } //! //! \brief Load Kernel //! \details Load a kernel from cache into GSH; searches for unused space in //! the kernel heap; deallocates kernels identified as no longer in use. //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to Hardware Interface Structure //! \param PCRENDERHAL_KERNEL_PARAM pParameters //! [in] Pointer to Kernel Parameters //! \param PMHW_KERNEL_PARAMS pKernel //! [in] Pointer to Kernel entry //! \param Kdll_CacheEntry pKernelEntry //! [in] The cache entry pointer maintaining the load status. //! For cache entries from local variable, //! set it to nullptr to avoid memory corruption //! \return int32_t //! Index to a kernel allocation index //! -1 if invalid parameters, no available space and no //! deallocation possible //! int32_t RenderHal_LoadKernel( PRENDERHAL_INTERFACE pRenderHal, PCRENDERHAL_KERNEL_PARAM pParameters, PMHW_KERNEL_PARAM pKernel, Kdll_CacheEntry *pKernelEntry) { PRENDERHAL_STATE_HEAP pStateHeap; PRENDERHAL_KRN_ALLOCATION pKernelAllocation; int32_t iKernelAllocationID; // Kernel allocation ID in GSH int32_t iKernelCacheID; // Kernel cache ID int32_t iKernelUniqueID; // Kernel unique ID void *pKernelPtr; int32_t iKernelSize; int32_t iSearchIndex; int32_t iMaxKernels; // Max number of kernels allowed in GSH uint32_t dwOffset; int32_t iSize; MOS_STATUS eStatus; iKernelAllocationID = RENDERHAL_KERNEL_LOAD_FAIL; eStatus = MOS_STATUS_SUCCESS; do { if (pRenderHal==nullptr) { break; } if (pRenderHal->pStateHeap == nullptr) { break; } if (pRenderHal->pStateHeap->pKernelAllocation == nullptr) { break; } if (pParameters == nullptr) { break; } if (pKernel == nullptr) { break; } pStateHeap = pRenderHal->pStateHeap; // Validate parameters if (pStateHeap->bGshLocked == false || pKernel->iSize == 0) { eStatus = MOS_STATUS_INVALID_PARAMETER; MHW_RENDERHAL_NORMALMESSAGE("Failed to load kernel - invalid parameters."); break; } // Kernel parameters pKernelPtr = pKernel->pBinary; iKernelSize = pKernel->iSize; iKernelUniqueID = pKernel->iKUID; iKernelCacheID = pKernel->iKCID; // Check if kernel is already loaded; Search free allocation index iSearchIndex = -1; iMaxKernels = pRenderHal->StateHeapSettings.iKernelCount; pKernelAllocation = pStateHeap->pKernelAllocation; for (iKernelAllocationID = 0; iKernelAllocationID < iMaxKernels; iKernelAllocationID++, pKernelAllocation++) { if (pKernelAllocation->iKUID == iKernelUniqueID && pKernelAllocation->iKCID == iKernelCacheID) { if (iKernelAllocationID != RENDERHAL_KERNEL_LOAD_FAIL) { // Update kernel usage pRenderHal->pfnTouchKernel(pRenderHal, iKernelAllocationID); // Increment reference counter if (pKernelEntry) { pKernelEntry->dwLoaded = 1; } pRenderHal->iKernelAllocationID = iKernelAllocationID; } // Return kernel allocation index return iKernelAllocationID; } if (iSearchIndex < 0 && pKernelAllocation->dwFlags == RENDERHAL_KERNEL_ALLOCATION_FREE) { iSearchIndex = iKernelAllocationID; } } // The kernel size to be dumped in oca buffer. pStateHeap->iKernelUsedForDump = iKernelSize; // Kernel already loaded: refresh timer; return allocation index if (iKernelAllocationID < iMaxKernels) { // To reload the kernel forcibly if needed if (pKernel->bForceReload) { dwOffset = pKernelAllocation->dwOffset; MOS_SecureMemcpy(pStateHeap->pIshBuffer + dwOffset, iKernelSize, pKernelPtr, iKernelSize); pKernel->bForceReload = false; } break; } // Kernel parameters pKernelPtr = pKernel->pBinary; iKernelSize = pKernel->iSize; iKernelUniqueID = pKernel->iKUID; iKernelCacheID = pKernel->iKCID; // Check if kernel is already loaded; Search free allocation index iSearchIndex = -1; iMaxKernels = pRenderHal->StateHeapSettings.iKernelCount; pKernelAllocation = pStateHeap->pKernelAllocation; for (iKernelAllocationID = 0; iKernelAllocationID < iMaxKernels; iKernelAllocationID++, pKernelAllocation++) { if (pKernelAllocation->iKUID == iKernelUniqueID && pKernelAllocation->iKCID == iKernelCacheID) { break; } if (iSearchIndex < 0 && pKernelAllocation->dwFlags == RENDERHAL_KERNEL_ALLOCATION_FREE) { iSearchIndex = iKernelAllocationID; } } // The kernel size to be dumped in oca buffer. pStateHeap->iKernelUsedForDump = iKernelSize; // Kernel already loaded: refresh timer; return allocation index if (iKernelAllocationID < iMaxKernels) { // To reload the kernel forcibly if needed if (pKernel->bForceReload) { dwOffset = pKernelAllocation->dwOffset; MOS_SecureMemcpy(pStateHeap->pIshBuffer + dwOffset, iKernelSize, pKernelPtr, iKernelSize); pKernel->bForceReload = false; } break; } // Simple allocation: allocation index available, space available if ((iSearchIndex >= 0) && (pStateHeap->iKernelUsed + iKernelSize <= pStateHeap->iKernelSize)) { // Allocate kernel at the end of the heap iKernelAllocationID = iSearchIndex; pKernelAllocation = &(pStateHeap->pKernelAllocation[iSearchIndex]); // Allocate block from the end of the heap dwOffset = pStateHeap->dwKernelBase + pStateHeap->iKernelUsed; iSize = MOS_ALIGN_CEIL(iKernelSize, pRenderHal->StateHeapSettings.iKernelBlockSize); // Update heap pStateHeap->iKernelUsed += iSize; // Load kernel goto loadkernel; } // Search block from deallocated entry if (iSearchIndex >= 0) { int32_t iMinSize = 0; iSearchIndex = -1; pKernelAllocation = pStateHeap->pKernelAllocation; for (iKernelAllocationID = 0; iKernelAllocationID < iMaxKernels; iKernelAllocationID++, pKernelAllocation++) { // Skip allocated/empty entries if (pKernelAllocation->dwFlags != RENDERHAL_KERNEL_ALLOCATION_FREE || pKernelAllocation->iSize == 0) { continue; } // Allocate minimum available block if (pKernelAllocation->iSize >= iKernelSize) { if (iSearchIndex < 0 || pKernelAllocation->iSize < iMinSize) { iSearchIndex = iKernelAllocationID; iMinSize = pKernelAllocation->iSize; } } } } // Did not find block, try to deallocate a kernel not recently used if (iSearchIndex < 0) { uint32_t dwOldest = 0; uint32_t dwLastUsed; // Search and deallocate least used kernel pKernelAllocation = pStateHeap->pKernelAllocation; for (iKernelAllocationID = 0; iKernelAllocationID < iMaxKernels; iKernelAllocationID++, pKernelAllocation++) { // Skip unused entries and entries that would not fit // Skip kernels flagged as locked (cannot be automatically deallocated) if (pKernelAllocation->dwFlags == RENDERHAL_KERNEL_ALLOCATION_FREE || pKernelAllocation->dwFlags == RENDERHAL_KERNEL_ALLOCATION_LOCKED || pKernelAllocation->iSize < iKernelSize) { continue; } // Check if kernel may be replaced (not in use by GPU) if ((int32_t)(pStateHeap->dwSyncTag - pKernelAllocation->dwSync) < 0) { continue; } // Find kernel not used for the greater amount of time (measured in number of operations) // Must not unload recently allocated kernels dwLastUsed = (uint32_t)(pStateHeap->dwAccessCounter - pKernelAllocation->dwCount); if (dwLastUsed > dwOldest) { iSearchIndex = iKernelAllocationID; dwOldest = dwLastUsed; } } // Did not found any entry for deallocation if (iSearchIndex < 0) { MHW_RENDERHAL_NORMALMESSAGE("Failed to load kernel - no space available in GSH."); iKernelAllocationID = RENDERHAL_KERNEL_LOAD_FAIL; break; } // Free kernel entry and states associated with the kernel (if any) if (pRenderHal->pfnUnloadKernel(pRenderHal, iSearchIndex) != MOS_STATUS_SUCCESS) { MHW_RENDERHAL_NORMALMESSAGE("Failed to load kernel - no space available in GSH."); iKernelAllocationID = RENDERHAL_KERNEL_LOAD_FAIL; break; } } // Allocate the entry iKernelAllocationID = iSearchIndex; pKernelAllocation = &(pStateHeap->pKernelAllocation[iSearchIndex]); dwOffset = pKernelAllocation->dwOffset; iSize = pKernelAllocation->iSize; loadkernel: // Allocate kernel pKernelAllocation->iKID = -1; pKernelAllocation->iKUID = iKernelUniqueID; pKernelAllocation->iKCID = iKernelCacheID; pKernelAllocation->dwSync = 0; FrameTrackerTokenFlat_Clear(&pKernelAllocation->trackerToken); pKernelAllocation->dwOffset = dwOffset; pKernelAllocation->iSize = iSize; pKernelAllocation->dwFlags = RENDERHAL_KERNEL_ALLOCATION_USED; pKernelAllocation->dwCount = 0; // will be updated by "TouchKernel" pKernelAllocation->Params = *pParameters; pKernelAllocation->pKernelEntry = pKernelEntry; pKernelAllocation->iAllocIndex = iKernelAllocationID; // Copy kernel data MOS_SecureMemcpy(pStateHeap->pIshBuffer + dwOffset, iKernelSize, pKernelPtr, iKernelSize); if (iKernelSize < iSize) { MOS_ZeroMemory(pStateHeap->pIshBuffer + dwOffset + iKernelSize, iSize - iKernelSize); } } while (false); if (iKernelAllocationID != RENDERHAL_KERNEL_LOAD_FAIL) { // Update kernel usage pRenderHal->pfnTouchKernel(pRenderHal, iKernelAllocationID); // Increment reference counter if (pKernelEntry) { pKernelEntry->dwLoaded = 1; } pRenderHal->iKernelAllocationID = iKernelAllocationID; } // Return kernel allocation index return iKernelAllocationID; } //! //! \brief Unload Kernel //! \details Unload a kernel from GSH, free kernel heap space //! Notify that the kernel has been unloaded (for tracking) //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to Hardware Interface Structure //! \param int32_t iKernelAllocationID //! [in] Kernel allocation index in GSH //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success //! others if invalid parameters or if kernel cannot be unloaded //! MOS_STATUS RenderHal_UnloadKernel( PRENDERHAL_INTERFACE pRenderHal, int32_t iKernelAllocationID) { PRENDERHAL_STATE_HEAP pStateHeap; PRENDERHAL_KRN_ALLOCATION pKernelAllocation; MOS_STATUS eStatus; //--------------------------------------- MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap); MHW_RENDERHAL_CHK_NULL_RETURN((void *)(iKernelAllocationID >= 0)); //--------------------------------------- eStatus = MOS_STATUS_UNKNOWN; pStateHeap = pRenderHal->pStateHeap; //--------------------------------------- MHW_RENDERHAL_CHK_NULL_RETURN(pStateHeap->pKernelAllocation); MHW_RENDERHAL_ASSERT(iKernelAllocationID < pRenderHal->StateHeapSettings.iKernelCount); //--------------------------------------- pKernelAllocation = &(pStateHeap->pKernelAllocation[iKernelAllocationID]); if (pKernelAllocation->dwFlags == RENDERHAL_KERNEL_ALLOCATION_FREE) { return eStatus; } // Update Sync tags MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pfnRefreshSync(pRenderHal)); // Check if kernel may be unloaded if ((int32_t)(pStateHeap->dwSyncTag - pKernelAllocation->dwSync) < 0) { return eStatus; } // Unload kernel if (pKernelAllocation->pKernelEntry) { pKernelAllocation->pKernelEntry->dwLoaded = 0; } // Release kernel entry (Offset/size may be used for reallocation) pKernelAllocation->iKID = -1; pKernelAllocation->iKUID = -1; pKernelAllocation->iKCID = -1; pKernelAllocation->dwSync = 0; FrameTrackerTokenFlat_Clear(&pKernelAllocation->trackerToken); pKernelAllocation->dwFlags = RENDERHAL_KERNEL_ALLOCATION_FREE; pKernelAllocation->dwCount = 0; pKernelAllocation->pKernelEntry = nullptr; eStatus = MOS_STATUS_SUCCESS; return eStatus; } //! //! \brief Touch Kernel //! \details Touch Kernel //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to Hardware Interface Structure //! \param int32_t iKernelAllocationID //! [in] Kernel Allocation ID //! \return void //! void RenderHal_TouchKernel( PRENDERHAL_INTERFACE pRenderHal, int32_t iKernelAllocationID) { PRENDERHAL_STATE_HEAP pStateHeap; PRENDERHAL_KRN_ALLOCATION pKernelAllocation; pStateHeap = (pRenderHal) ? pRenderHal->pStateHeap : nullptr; if (pStateHeap == nullptr || pStateHeap->pKernelAllocation == nullptr || iKernelAllocationID < 0 || iKernelAllocationID >= pRenderHal->StateHeapSettings.iKernelCount) { return; } // Update usage pKernelAllocation = &(pStateHeap->pKernelAllocation[iKernelAllocationID]); if (pKernelAllocation->dwFlags != RENDERHAL_KERNEL_ALLOCATION_FREE && pKernelAllocation->dwFlags != RENDERHAL_KERNEL_ALLOCATION_LOCKED) { pKernelAllocation->dwCount = pStateHeap->dwAccessCounter++; } // Set sync tag, for deallocation control pKernelAllocation->dwSync = pStateHeap->dwNextTag; } //! //! \brief Reset Kernels //! \details Reset Kernels //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to Hardware Interface Structure //! \return void //! void RenderHal_ResetKernels( PRENDERHAL_INTERFACE pRenderHal) { PRENDERHAL_STATE_HEAP pStateHeap; PRENDERHAL_KRN_ALLOCATION pKernelAllocation; int32_t i; MOS_STATUS eStatus = MOS_STATUS_UNKNOWN; //--------------------------------------- MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pRenderHal->pStateHeap); MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pRenderHal->pStateHeap->pKernelAllocation); //--------------------------------------- pStateHeap = pRenderHal->pStateHeap; // Unload kernels and notify HAL layer pKernelAllocation = pStateHeap->pKernelAllocation; for (i = 0; i< pRenderHal->StateHeapSettings.iKernelCount; i++, pKernelAllocation++) { // Unload kernel if (pKernelAllocation->pKernelEntry) { pKernelAllocation->pKernelEntry->dwLoaded = 0; } pKernelAllocation->iKID = -1; pKernelAllocation->iKUID = -1; pKernelAllocation->iKCID = -1; pKernelAllocation->dwSync = 0; FrameTrackerTokenFlat_Clear(&pKernelAllocation->trackerToken); pKernelAllocation->dwOffset = 0; pKernelAllocation->iSize = 0; pKernelAllocation->dwFlags = RENDERHAL_KERNEL_ALLOCATION_FREE; pKernelAllocation->dwCount = 0; pKernelAllocation->pKernelEntry = nullptr; pKernelAllocation->iAllocIndex = i; pKernelAllocation->Params = g_cRenderHal_InitKernelParams; } // Free Kernel Heap pStateHeap->dwAccessCounter = 0; pStateHeap->iKernelSize = pRenderHal->StateHeapSettings.iKernelHeapSize; pStateHeap->iKernelUsed = 0; pStateHeap->iKernelUsedForDump = 0; return; } //! //! \brief Get Kernel Offset //! \details Get Kernel Offset //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to Hardware Interface Structure //! \param int32_t iKernelAllocationIndex //! [in] Kernel Allocation Index //! \return int32_t //! int32_t RenderHal_GetKernelOffset( PRENDERHAL_INTERFACE pRenderHal, int32_t iKernelAllocationIndex) { PRENDERHAL_STATE_HEAP pStateHeap; int32_t iResult; pStateHeap = (pRenderHal) ? pRenderHal->pStateHeap : nullptr; if (pStateHeap && pStateHeap->pKernelAllocation && iKernelAllocationIndex >= 0 && iKernelAllocationIndex < pRenderHal->StateHeapSettings.iKernelCount) { iResult = pStateHeap->pKernelAllocation[iKernelAllocationIndex].dwOffset; } else { iResult = -1; } return iResult; } //! //! \brief Allocate Media ID //! \details Allocates an setup Interface Descriptor for Media Pipeline //! Kernel must be preloaded using pfnLoadKernel //! Curbe must be allocated using pfnAllocateCurbe //! Binding Table must be allocated using pfnAllocateBindingTable //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to Hardware Interface Structure //! \param int32_t iKernelAllocationID //! [in] Kernel Allocation ID //! \param int32_t iBindingTableID //! [in] Binding Table ID //! \param int32_t iCurbeOffset //! [in] Curbe Offset (from Curbe base) //! \param int32_t iCurbeLength //! [in] Curbe Length //! \param int32_t iCrsThrdConstDataLn //! [in] Cross Thread constant data length //! \param PMHW_GPGPU_WALKER_PARAMS pGpGpuWalkerParams //! [in] Pointer to GpGpu Walker Params //! \return int32_t //! Media Interface descriptor ID //! -1 if invalid parameters, no ID entry available in GSH //! int32_t RenderHal_AllocateMediaID( PRENDERHAL_INTERFACE pRenderHal, int32_t iKernelAllocationID, int32_t iBindingTableID, int32_t iCurbeOffset, int32_t iCurbeLength, int32_t iCrsThrdConstDataLn, PMHW_GPGPU_WALKER_PARAMS pGpGpuWalkerParams) { PRENDERHAL_STATE_HEAP pStateHeap; PRENDERHAL_KRN_ALLOCATION pKernelAllocation; PRENDERHAL_MEDIA_STATE pCurMediaState; int32_t iCurbeSize; int32_t iInterfaceDescriptor; RENDERHAL_INTERFACE_DESCRIPTOR_PARAMS InterfaceDescriptorParams; iInterfaceDescriptor = -1; // Validate GSH pStateHeap = (pRenderHal) ? pRenderHal->pStateHeap : nullptr; if (pStateHeap == nullptr || pStateHeap->pKernelAllocation == nullptr || pStateHeap->bGshLocked == false) { MHW_RENDERHAL_ASSERTMESSAGE("Invalid GSH State."); return iInterfaceDescriptor; } // Obtain pointer to current media state pCurMediaState = pStateHeap->pCurMediaState; if (pCurMediaState == nullptr || pCurMediaState->piAllocation == nullptr) { MHW_RENDERHAL_ASSERTMESSAGE("Invalid Media State."); return iInterfaceDescriptor; } // Validate kernel allocation ID (kernel must be pre-loaded into GSH) if (iKernelAllocationID < 0 || iKernelAllocationID >= pRenderHal->StateHeapSettings.iKernelCount) { MHW_RENDERHAL_ASSERTMESSAGE("Invalid Kernel Allocation ID."); return iInterfaceDescriptor; } // Obtain pointer to kernel allocation control and kernel parameters pKernelAllocation = &(pStateHeap->pKernelAllocation[iKernelAllocationID]); if (pKernelAllocation->dwFlags == RENDERHAL_KERNEL_ALLOCATION_FREE || pKernelAllocation->iSize == 0) { MHW_RENDERHAL_ASSERTMESSAGE("Invalid Kernel Allocation."); return iInterfaceDescriptor; } // Check Curbe allocation (CURBE_Lenght is in 256-bit count -> convert to bytes) iCurbeSize = iCurbeLength; if (iCurbeSize <= 0) { // Curbe is not used by the kernel iCurbeSize = iCurbeOffset = 0; } // Validate Curbe Offset (curbe must be pre-allocated) else if ( iCurbeOffset < 0 || // Not allocated (iCurbeOffset & 0x1F) != 0 || // Invalid alignment (iCurbeOffset + iCurbeSize) > pCurMediaState->iCurbeOffset) // Invalid size { MHW_RENDERHAL_ASSERTMESSAGE("Invalid Curbe Allocation."); return iInterfaceDescriptor; } // Search available ID in current media state heap, try to reuse index (2nd level BB reuse) iInterfaceDescriptor = pRenderHal->pfnGetMediaID(pRenderHal, pCurMediaState, pKernelAllocation); if (iInterfaceDescriptor < 0) { MHW_RENDERHAL_ASSERTMESSAGE("No Interface Descriptor available."); return iInterfaceDescriptor; } MOS_ZeroMemory((void *)&InterfaceDescriptorParams, sizeof(InterfaceDescriptorParams)); InterfaceDescriptorParams.iMediaID = iInterfaceDescriptor; InterfaceDescriptorParams.iBindingTableID = iBindingTableID; InterfaceDescriptorParams.iCurbeOffset = iCurbeOffset; InterfaceDescriptorParams.iCurbeLength = iCurbeLength; InterfaceDescriptorParams.iCrsThrdConstDataLn = iCrsThrdConstDataLn; // barrier and slm if (pGpGpuWalkerParams && pGpGpuWalkerParams->GpGpuEnable) { InterfaceDescriptorParams.blBarrierEnable = true; InterfaceDescriptorParams.iNumberThreadsInGroup = pGpGpuWalkerParams->ThreadWidth * pGpGpuWalkerParams->ThreadHeight; InterfaceDescriptorParams.iSLMSize = pGpGpuWalkerParams->SLMSize; // The shift will be handled by pfnEncodeSLMSize() InterfaceDescriptorParams.blGlobalBarrierEnable = false; } else //Reset barrier and slm setting since they may be set before { InterfaceDescriptorParams.blBarrierEnable = false; InterfaceDescriptorParams.iNumberThreadsInGroup = pRenderHal->dwMinNumberThreadsInGroup; InterfaceDescriptorParams.iSLMSize = 0; InterfaceDescriptorParams.iCrsThrdConstDataLn &= pRenderHal->dwMaskCrsThdConDataRdLn; InterfaceDescriptorParams.blGlobalBarrierEnable = false; } // Setup Media ID entry - this call could be HW dependent if (MOS_STATUS_SUCCESS != pRenderHal->pfnSetupInterfaceDescriptor( pRenderHal, pCurMediaState, pKernelAllocation, &InterfaceDescriptorParams)) { MHW_RENDERHAL_ASSERTMESSAGE("Failed to setup interface descriptor."); return iInterfaceDescriptor; } // Update kernel usage pRenderHal->pfnTouchKernel(pRenderHal, iInterfaceDescriptor); return iInterfaceDescriptor; } int32_t RenderHal_GetMediaID( PRENDERHAL_INTERFACE pRenderHal, PRENDERHAL_MEDIA_STATE pMediaState, PRENDERHAL_KRN_ALLOCATION pKernelAllocation) { int32_t iInterfaceDescriptor = -1; int32_t *Allocation; MOS_STATUS eStatus = MOS_STATUS_UNKNOWN; MHW_RENDERHAL_CHK_NULL_RETURN(pMediaState); MHW_RENDERHAL_CHK_NULL_RETURN(pMediaState->piAllocation); MHW_RENDERHAL_CHK_NULL_RETURN(pKernelAllocation); iInterfaceDescriptor = pKernelAllocation->iKID; Allocation = pMediaState->piAllocation; // Try to reuse interface descriptor (for 2nd level buffer optimizations) // Check if ID already in use by another kernel - must use a different ID if (iInterfaceDescriptor >= 0 && Allocation[iInterfaceDescriptor] >= 0 && Allocation[iInterfaceDescriptor] != pKernelAllocation->iAllocIndex) { iInterfaceDescriptor = -1; } // Search available ID in current media state heap if (iInterfaceDescriptor < 0) { int32_t iMax = pRenderHal->StateHeapSettings.iMediaIDs; for (iInterfaceDescriptor = 0; iInterfaceDescriptor < iMax; iInterfaceDescriptor++) { if (Allocation[iInterfaceDescriptor] < 0) { break; } } // All IDs are in use - fail if (iInterfaceDescriptor >= iMax) { MHW_RENDERHAL_ASSERT("No Interface Descriptor available."); iInterfaceDescriptor = -1; return iInterfaceDescriptor; } } // Set kernel allocation for the current Media ID Allocation[iInterfaceDescriptor] = pKernelAllocation->iAllocIndex; // Set preferred Media ID for the current kernel // This is necessary for 2nd level BB optimization. if (pKernelAllocation->iKID < 0) { pKernelAllocation->iKID = iInterfaceDescriptor; } return iInterfaceDescriptor; } uint32_t RenderHal_SetSurfacesPerBT(PRENDERHAL_INTERFACE pRenderHal, uint32_t dwSurfacesPerBT) { if (pRenderHal == nullptr) { MHW_RENDERHAL_ASSERT("Invalid renderhal interface."); return dwSurfacesPerBT; } // Set number of surfaces per Binding Table uint32_t dwSizeBT = (uint32_t)pRenderHal->StateHeapSettings.iBTAlignment/pRenderHal->pRenderHalPltInterface->GetBTStateCmdSize(); while (dwSizeBT < dwSurfacesPerBT) dwSizeBT <<= 1; dwSurfacesPerBT = dwSizeBT; // Reconfigure the binding table size pRenderHal->pStateHeap->iBindingTableSize = MOS_ALIGN_CEIL(dwSizeBT * pRenderHal->pRenderHalPltInterface->GetBTStateCmdSize(), pRenderHal->StateHeapSettings.iBTAlignment); // Reconfigure the binding table number, surface per BT pRenderHal->StateHeapSettings.iBindingTables = pRenderHal->StateHeapSettings.iBindingTables * pRenderHal->StateHeapSettings.iSurfacesPerBT / dwSurfacesPerBT; pRenderHal->StateHeapSettings.iSurfacesPerBT = (int32_t) dwSurfacesPerBT; return dwSurfacesPerBT; } //! //! \brief Assign Surface State //! \details Assign a new surface state from already allocated surfState pool //! Setup the surface state to default //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to Hardware Interface Structure //! \param RENDERHAL_SURFACE_STATE_TYPE Type //! [in] Surface State Type //! \param PRENDERHAL_SURFACE_STATE_ENTRY * ppSurfaceEntry //! [in] Pointer to Surface State Entry //! \return MOS_STATUS //! MOS_STATUS RenderHal_AssignSurfaceState( PRENDERHAL_INTERFACE pRenderHal, RENDERHAL_SURFACE_STATE_TYPE Type, PRENDERHAL_SURFACE_STATE_ENTRY *ppSurfaceEntry) { PRENDERHAL_STATE_HEAP pStateHeap; int32_t iSurfaceEntry; PRENDERHAL_SURFACE_STATE_ENTRY pSurfaceEntry; uint32_t dwOffset; MOS_STATUS eStatus; //---------------------------------------------- MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(ppSurfaceEntry); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap); //---------------------------------------------- eStatus = MOS_STATUS_UNKNOWN; pStateHeap = pRenderHal->pStateHeap; uint8_t *pCurSurfaceState; // Calculate the Offset to the Surface State MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pRenderHalPltInterface); if (pRenderHal->isBindlessHeapInUse == false) { if (pStateHeap->iCurrentSurfaceState >= pRenderHal->StateHeapSettings.iSurfaceStates) { MHW_RENDERHAL_ASSERTMESSAGE("Unable to allocate Surface State. Exceeds Maximum."); return eStatus; } dwOffset = pStateHeap->iSurfaceStateOffset + (pStateHeap->iCurrentSurfaceState * pRenderHal->pRenderHalPltInterface->GetSurfaceStateCmdSize()); // Moves the pointer to a Currently assigned Surface State // Increment the Current Surface State Entry // Obtain new surface entry and initialize iSurfaceEntry = pStateHeap->iCurrentSurfaceState; pCurSurfaceState = pStateHeap->pSshBuffer + dwOffset; ++pStateHeap->iCurrentSurfaceState; } else { MHW_RENDERHAL_CHK_NULL_RETURN(pStateHeap->surfaceStateMgr); MHW_RENDERHAL_CHK_STATUS_RETURN(pStateHeap->surfaceStateMgr->AssignSurfaceState()); SURFACE_STATES_HEAP_OBJ *sufStateHeap = pStateHeap->surfaceStateMgr->m_surfStateHeap; MHW_RENDERHAL_CHK_NULL_RETURN(sufStateHeap); MHW_RENDERHAL_CHK_NULL_RETURN(sufStateHeap->pLockedOsResourceMem); dwOffset = sufStateHeap->uiCurState * sufStateHeap->uiInstanceSize; pCurSurfaceState =sufStateHeap->pLockedOsResourceMem + dwOffset; pStateHeap->iCurrentSurfaceState = sufStateHeap->uiCurState; MHW_RENDERHAL_CHK_STATUS_RETURN(pStateHeap->surfaceStateMgr->AssignUsedSurfaceState(pStateHeap->iCurrentSurfaceState)); // Obtain new surface entry and initialize iSurfaceEntry = pStateHeap->iCurrentSurfaceState; } pSurfaceEntry = &pStateHeap->pSurfaceEntry[iSurfaceEntry]; if (pSurfaceEntry->pSurface) { MOS_SafeFreeMemory(pSurfaceEntry->pSurface); pSurfaceEntry->pSurface = nullptr; } *pSurfaceEntry = g_cInitSurfaceStateEntry; // Setup Surface Entry parameters pSurfaceEntry->iSurfStateID = iSurfaceEntry; pSurfaceEntry->Type = Type; pSurfaceEntry->dwSurfStateOffset = (uint32_t)-1; // Each platform to setup pSurfaceEntry->pSurfaceState = pCurSurfaceState; pSurfaceEntry->pSurface = (PMOS_SURFACE)MOS_AllocAndZeroMemory(sizeof(MOS_SURFACE)); if (pSurfaceEntry->pSurface == nullptr) { MHW_RENDERHAL_ASSERTMESSAGE("Allocating Surface failed!"); eStatus = MOS_STATUS_NO_SPACE; return eStatus; } *ppSurfaceEntry = pSurfaceEntry; eStatus = MOS_STATUS_SUCCESS; return eStatus; } //! //! \brief Get DI UV Offset //! \details Get DI UV Offset //! \param PRENDERHAL_SURFACE pRenderHalSurface //! [in] Pointer to Surface //! \param uint16_t *pUXOffset //! [out] X Offset for U Plane //! \param uint16_t *pUYOffset //! [out] Y Offset for U Plane //! \param uint16_t *pVXOffset //! [out] X Offset for V Plane //! \param uint16_t *pVYOffset //! [out] Y Offset for V Plane //! \return void //! void RenderHal_Get_DI_UVOffSet( PRENDERHAL_SURFACE pRenderHalSurface, uint16_t *pUXOffset, uint16_t *pUYOffset, uint16_t *pVXOffset, uint16_t *pVYOffset) { MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pRenderHalSurface); MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pUXOffset); MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pUYOffset); MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pVXOffset); MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pVXOffset); PMOS_SURFACE pSurface = &pRenderHalSurface->OsSurface; MOS_FORMAT fmt = pSurface->Format; uint32_t dwNumRowsFromTopV = 0; uint32_t dwNumRowsFromTopU = 0; uint32_t dwNumColsFromLeftV = 0; uint32_t dwNumColsFromLeftU = 0; uint32_t dwHeight = pSurface->dwHeight; uint32_t dwPitch = pSurface->dwPitch; switch (fmt) { // YY // YY // V- // U- case Format_IMC1: dwNumRowsFromTopV = dwHeight; dwNumRowsFromTopU = dwHeight + (dwHeight >> 1); break; // YY // YY // VU case Format_IMC2: dwNumRowsFromTopV = dwNumRowsFromTopU = dwHeight; dwNumColsFromLeftU = dwPitch >> 1; break; // YY // YY // U- // V- case Format_IMC3: dwNumRowsFromTopU = dwHeight; dwNumRowsFromTopV = dwHeight + (dwHeight >> 1); break; // YY // YY // UV case Format_IMC4: dwNumRowsFromTopU = dwNumRowsFromTopV = dwHeight; dwNumColsFromLeftV = dwPitch >> 1; break; // YY // YY // U // V case Format_I420: case Format_IYUV: dwNumRowsFromTopU = dwHeight; dwNumRowsFromTopV = dwHeight + (dwHeight >> 1); break; // YY // YY // V // U case Format_YV12: dwNumRowsFromTopU = dwHeight + (dwHeight >> 1); dwNumRowsFromTopV = dwHeight; break; // YYYY // YYYY // YYYY // YYYY // V // U case Format_YVU9: dwNumRowsFromTopU = dwHeight; dwNumRowsFromTopV = dwHeight + (dwHeight >> 2); break; // NV12 P208 // ---- ---- // YY YY // YY UV (interleaved) // UV (interleaved) case Format_NV12: case Format_P208: case Format_P016: case Format_P010: dwNumRowsFromTopU = dwNumRowsFromTopV = dwHeight; break; // NV11 // ---- // YYYY // UV (interleaved) case Format_NV11: dwNumRowsFromTopU = dwNumRowsFromTopV = dwHeight; break; default: MHW_RENDERHAL_ASSERTMESSAGE("called with Packed or Unknown format."); break; } // the Offsets must be even numbers so we round down dwNumRowsFromTopU = MOS_ALIGN_FLOOR(dwNumRowsFromTopU, 2); dwNumColsFromLeftU = MOS_ALIGN_FLOOR(dwNumColsFromLeftU, 2); dwNumRowsFromTopV = MOS_ALIGN_FLOOR(dwNumRowsFromTopV, 2); dwNumColsFromLeftV = MOS_ALIGN_FLOOR(dwNumColsFromLeftV, 2); *pVYOffset = (uint16_t)dwNumRowsFromTopV; *pUYOffset = (uint16_t)dwNumRowsFromTopU; *pVXOffset = (uint16_t)dwNumColsFromLeftV; *pUXOffset = (uint16_t)dwNumColsFromLeftU; } //! //! \brief Set Slice Shutdown Mode //! \details Sets Slice Shutdown Mode //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to RenderHal Interface Structure //! \param bool bMode //! [in] Slice Shutdown Mode //! \return void //! void RenderHal_SetSliceShutdownMode( PRENDERHAL_INTERFACE pRenderHal, bool bMode) { MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pRenderHal); pRenderHal->bRequestSingleSlice = bMode; } //! //! \brief Set General Slice Shutdown Mode //! \details Sets General Slice Shutdown Mode //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to RenderHal Interface Structure //! \param PRENDERHAL_POWEROPTION pMode //! [in] Slice Shutdown Mode //! \return void //! void RenderHal_SetPowerOptionMode( PRENDERHAL_INTERFACE pRenderHal, PRENDERHAL_POWEROPTION pMode ) { MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pMode); pRenderHal->PowerOption = *pMode; } //! //! \brief Enable Middle Batch Buffer Preemption //! \details Enable Middle Batch Buffer Preemption //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to Hardware Interface Structurev //! \return void //! void RenderHal_EnableGpgpuMiddleBatchBufferPreemption( PRENDERHAL_INTERFACE pRenderHal) { MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pRenderHal); pRenderHal->bEnableGpgpuMidBatchPreEmption = MEDIA_IS_SKU(pRenderHal->pSkuTable, FtrGpGpuMidBatchPreempt) ? true : false; } //! //! \brief Enable Middle Thread Preemption //! \details Enable Middle Thread Preemption //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to Hardware Interface Structurev //! \return void //! void RenderHal_EnableGpgpuMiddleThreadPreemption( PRENDERHAL_INTERFACE pRenderHal) { MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pRenderHal); pRenderHal->bEnableGpgpuMidThreadPreEmption = MEDIA_IS_SKU(pRenderHal->pSkuTable, FtrGpGpuMidThreadLevelPreempt) ? true : false; } //! //! \brief Get Surface State Entries //! \details Gets the Surface State Entries //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to Hardware Interface structure //! \param PRENDERHAL_SURFACE pRenderHalSurface //! [in] Pointer to Render Hal Surface //! \param PRENDERHAL_SURFACE_STATE_PARAMS pParams //! [in] Pointer to Surface State Params //! \param int32_t *piNumEntries //! [out] Number of Surface Entries (one entry per surface plane) //! \param PRENDERHAL_SURFACE_STATE_ENTRY * ppSurfaceEntries //! [out] Array of Surface State Entries //! \return MOS_STATUS //! MOS_STATUS RenderHal_GetSurfaceStateEntries( PRENDERHAL_INTERFACE pRenderHal, PRENDERHAL_SURFACE pRenderHalSurface, PRENDERHAL_SURFACE_STATE_PARAMS pParams, int32_t *piNumEntries, PRENDERHAL_SURFACE_STATE_ENTRY *ppSurfaceEntries) { MOS_STATUS eStatus; PCMHW_PLANE_SETTING pPlane; PMOS_SURFACE pSurface; RENDERHAL_PLANE_DEFINITION PlaneDefinition; PRENDERHAL_SURFACE_STATE_ENTRY pSurfaceEntry; uint32_t dwSurfaceWidth; uint32_t dwSurfaceHeight; uint32_t dwUVPitch; int32_t i; bool bHalfPitchForChroma; bool bInterleaveChroma; bool bWidthInDword; uint8_t Direction; uint16_t wUXOffset; uint16_t wUYOffset; uint16_t wVXOffset; uint16_t wVYOffset; bool bIsChromaSitEnabled; bool bIsTri9YV12; //------------------------------------------------ MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHalSurface); MHW_RENDERHAL_CHK_NULL_RETURN(pParams); MHW_RENDERHAL_CHK_NULL_RETURN(piNumEntries); MHW_RENDERHAL_CHK_NULL_RETURN(ppSurfaceEntries); //------------------------------------------------ eStatus = MOS_STATUS_UNKNOWN; pSurface = &pRenderHalSurface->OsSurface; dwUVPitch = pSurface->dwPitch; bHalfPitchForChroma = false; bInterleaveChroma = false; Direction = MEDIASTATE_VDIRECTION_FULL_FRAME; wUXOffset = 0; wUYOffset = 0; wVXOffset = 0; wVYOffset = 0; *piNumEntries = -1; PlaneDefinition = RENDERHAL_PLANES_DEFINITION_COUNT; bIsChromaSitEnabled = 0; // In trinity9, YV12 format will use 3 Planes bIsTri9YV12 = pSurface->Format == Format_YV12 && pRenderHal->pOsInterface != nullptr && pRenderHal->pOsInterface->trinityPath == TRINITY9_ENABLED; pRenderHal->bIsAVS = pParams->bAVS; // Check palette allocations if (IS_PAL_FORMAT(pSurface->Format)) { if (pRenderHalSurface->iPaletteID < 0 || pRenderHalSurface->iPaletteID >= pRenderHal->iMaxPalettes) { MHW_RENDERHAL_ASSERTMESSAGE("Invalid palette."); return eStatus; } } // adjust the U/V-Pitch for formats that have U/V-Pitch smaller than Y-Pitch if (pSurface->Format == Format_I420 || pSurface->Format == Format_IYUV || pSurface->Format == Format_YV12 || pSurface->Format == Format_NV11) { dwUVPitch >>= 1; } else if (pSurface->Format == Format_YVU9) { dwUVPitch >>= 2; } if (pParams->Type == RENDERHAL_SURFACE_TYPE_ADV_G8 || pParams->Type == RENDERHAL_SURFACE_TYPE_ADV_G9 || pParams->Type == RENDERHAL_SURFACE_TYPE_ADV_G10) { // Select the surface/plane description switch (pSurface->Format) { case Format_NV12: // On G8, NV12 format needs the width and Height to be a multiple // of 4 for both 3D sampler and 8x8 sampler; G75 needs the width // of NV12 input surface to be a multiple of 4 for 3D sampler; // G9+ does not has such restriction; to simplify the implementation, // we enable 2 plane NV12 for all of the platform when the width // or Height is not a multiple of 4 if (pRenderHal->pfnIs2PlaneNV12Needed(pRenderHal, pRenderHalSurface, pParams->Boundary)) { PlaneDefinition = RENDERHAL_PLANES_NV12_2PLANES_ADV; } else { PlaneDefinition = RENDERHAL_PLANES_NV12_ADV; wUYOffset = RenderHal_CalculateYOffset(pRenderHal->pOsInterface, &pSurface->OsResource); } bHalfPitchForChroma = false; bInterleaveChroma = true; // Set up chroma direction Direction = pRenderHal->pfnSetChromaDirection(pRenderHal, pRenderHalSurface); break; case Format_P208: PlaneDefinition = RENDERHAL_PLANES_P208_1PLANE_ADV; break; case Format_IMC1: case Format_IMC2: case Format_IMC3: case Format_IMC4: case Format_I420: case Format_IYUV: case Format_YV12: case Format_YVU9: PlaneDefinition = RENDERHAL_PLANES_PL3_ADV; bHalfPitchForChroma = false; if (pSurface->Format == Format_I420 || pSurface->Format == Format_IYUV || pSurface->Format == Format_YV12 || pSurface->Format == Format_NV11) { bHalfPitchForChroma = true; } // Set up chroma direction Direction = pRenderHal->pfnSetChromaDirection(pRenderHal, pRenderHalSurface); if (!pParams->bAVS) { // Get U/V offset for PL3 DNDI RenderHal_Get_DI_UVOffSet(pRenderHalSurface, &wUXOffset, &wUYOffset, &wVXOffset, &wVYOffset); PlaneDefinition = RENDERHAL_PLANES_NV12_ADV; } break; case Format_400P: // Single Y plane here is treated like a NV12 surface. // U and V offsets fall inside this Y plane. Eventhough false UV pixels are // picked by the kernel, CSC coeffecients are such that the effect of these // are nullified. PlaneDefinition = RENDERHAL_PLANES_NV12_ADV; break; case Format_411P: PlaneDefinition = RENDERHAL_PLANES_411P_ADV; break; case Format_411R: PlaneDefinition = RENDERHAL_PLANES_411R_ADV; break; case Format_422H: PlaneDefinition = RENDERHAL_PLANES_422H_ADV; break; case Format_422V: PlaneDefinition = RENDERHAL_PLANES_422V_ADV; break; case Format_444P: PlaneDefinition = RENDERHAL_PLANES_444P_ADV; break; case Format_RGBP: PlaneDefinition = RENDERHAL_PLANES_RGBP_ADV; break; case Format_BGRP: PlaneDefinition = RENDERHAL_PLANES_BGRP_ADV; break; case Format_AYUV: PlaneDefinition = RENDERHAL_PLANES_AYUV_ADV; break; case Format_YUYV: case Format_YUY2: if (pParams->bVmeUse) { //Since 422 planar is not supported on application side. //App is using 422 packed as WA with w=w/2 and h=h*2 pSurface->dwWidth = pSurface->dwWidth * 2; pSurface->dwHeight = pSurface->dwHeight / 2; pRenderHalSurface->rcSrc.right = pSurface->dwWidth; pRenderHalSurface->rcSrc.bottom = pSurface->dwHeight; pRenderHalSurface->rcDst = pRenderHalSurface->rcSrc; PlaneDefinition = RENDERHAL_PLANES_YUY2_ADV; // Set up chroma direction Direction = pRenderHal->pfnSetChromaDirection(pRenderHal, pRenderHalSurface); } else { PlaneDefinition = RENDERHAL_PLANES_YUY2_ADV; // Set up chroma direction Direction = pRenderHal->pfnSetChromaDirection(pRenderHal, pRenderHalSurface); } break; case Format_UYVY: PlaneDefinition = RENDERHAL_PLANES_UYVY_ADV; // Set up chroma direction Direction = pRenderHal->pfnSetChromaDirection(pRenderHal, pRenderHalSurface); break; case Format_YVYU: PlaneDefinition = RENDERHAL_PLANES_YVYU_ADV; // Set up chroma direction Direction = pRenderHal->pfnSetChromaDirection(pRenderHal, pRenderHalSurface); break; case Format_VYUY: PlaneDefinition = RENDERHAL_PLANES_VYUY_ADV; // Set up chroma direction Direction = pRenderHal->pfnSetChromaDirection(pRenderHal, pRenderHalSurface); break; case Format_A8R8G8B8: case Format_X8R8G8B8: if (pParams->bVASurface) { pSurface->dwWidth *= 32; PlaneDefinition = RENDERHAL_PLANES_Y1; } else { PlaneDefinition = RENDERHAL_PLANES_ARGB_ADV; } break; case Format_R8G8SN: if ( pParams->bVASurface ) { PlaneDefinition = RENDERHAL_PLANES_Y16S; } break; case Format_V8U8: if ( pParams->bVASurface ) { PlaneDefinition = RENDERHAL_PLANES_Y16U; } break; case Format_A8B8G8R8: case Format_X8B8G8R8: PlaneDefinition = RENDERHAL_PLANES_ABGR_ADV; break; case Format_STMM: PlaneDefinition = RENDERHAL_PLANES_STMM_ADV; break; case Format_A8: case Format_Buffer_2D: if (pParams->bVASurface) { PlaneDefinition = RENDERHAL_PLANES_Y8; } break; case Format_Y8: PlaneDefinition = RENDERHAL_PLANES_Y8_ADV; break; case Format_L8: case Format_R8UN: if (pParams->bForceNV12) { PlaneDefinition = RENDERHAL_PLANES_NV12_ADV; bHalfPitchForChroma = false; bInterleaveChroma = true; wUYOffset = (uint16_t) pSurface->dwHeight; } else { PlaneDefinition = RENDERHAL_PLANES_L8_ADV; } break; case Format_A16B16G16R16: case Format_Y416: PlaneDefinition = RENDERHAL_PLANES_A16B16G16R16_ADV; break; case Format_R10G10B10A2: case Format_Y410: PlaneDefinition = RENDERHAL_PLANES_R10G10B10A2_ADV; break; case Format_L16: case Format_R16S: if (pParams->bVASurface) { PlaneDefinition = RENDERHAL_PLANES_Y16S; } break; case Format_D16: case Format_R16U: if (pParams->bVASurface) { PlaneDefinition = RENDERHAL_PLANES_Y16U; } break; case Format_P010: case Format_P016: if (pParams->bVmeUse) { PlaneDefinition = RENDERHAL_PLANES_P010_1PLANE_ADV; } else if (pRenderHal->bEnableP010SinglePass && (pRenderHalSurface->SurfType != RENDERHAL_SURF_OUT_RENDERTARGET)) { PlaneDefinition = RENDERHAL_PLANES_P010_1PLANE_ADV; bHalfPitchForChroma = false; bInterleaveChroma = true; wUYOffset = RenderHal_CalculateYOffset(pRenderHal->pOsInterface, &pSurface->OsResource); // Set up chroma direction Direction = pRenderHal->pfnSetChromaDirection(pRenderHal, pRenderHalSurface); } else { // Format not supported with AVS - use regular format MHW_RENDERHAL_NORMALMESSAGE("Format not supported with AVS."); pParams->bAVS = false; // Since the format is not supported with AVS, set the scaling mode as bilinear. pRenderHalSurface->ScalingMode = RENDERHAL_SCALING_BILINEAR; if (pParams->Type == RENDERHAL_SURFACE_TYPE_ADV_G8) { pParams->Type = RENDERHAL_SURFACE_TYPE_G8; } else if (pParams->Type == RENDERHAL_SURFACE_TYPE_ADV_G9) { pParams->Type = RENDERHAL_SURFACE_TYPE_G9; } else if (pParams->Type == RENDERHAL_SURFACE_TYPE_ADV_G10) { pParams->Type = RENDERHAL_SURFACE_TYPE_G10; } else { MHW_RENDERHAL_ASSERTMESSAGE("Unsupported surface type"); } } break; case Format_Y210: case Format_Y216: if (pParams->bVmeUse) { //Since 422 planar is not supported on application side. //App is using 422 packed as WA with w=w/2 and h=h*2 pSurface->dwWidth = pSurface->dwWidth * 2; pSurface->dwHeight = pSurface->dwHeight / 2; pRenderHalSurface->rcSrc.right = pSurface->dwWidth; pRenderHalSurface->rcSrc.bottom = pSurface->dwHeight; pRenderHalSurface->rcDst = pRenderHalSurface->rcSrc; PlaneDefinition = RENDERHAL_PLANES_Y210_1PLANE_ADV; } else { PlaneDefinition = RENDERHAL_PLANES_Y210_ADV; } break; default: // Format not supported with AVS - use regular format MHW_RENDERHAL_NORMALMESSAGE("Format not supported with AVS."); pParams->bAVS = false; // Since the format is not supported with AVS, set the scaling mode as bilinear. pRenderHalSurface->ScalingMode = RENDERHAL_SCALING_BILINEAR; if (pParams->Type == RENDERHAL_SURFACE_TYPE_ADV_G8) { pParams->Type = RENDERHAL_SURFACE_TYPE_G8; } else if (pParams->Type == RENDERHAL_SURFACE_TYPE_ADV_G9) { pParams->Type = RENDERHAL_SURFACE_TYPE_G9; } else if (pParams->Type == RENDERHAL_SURFACE_TYPE_ADV_G10) { pParams->Type = RENDERHAL_SURFACE_TYPE_G10; } else { MHW_RENDERHAL_ASSERTMESSAGE("Unsupported surface type"); } break; } } // Select the surface/plane description if (pParams->Type == RENDERHAL_SURFACE_TYPE_G8 || pParams->Type == RENDERHAL_SURFACE_TYPE_G9 || pParams->Type == RENDERHAL_SURFACE_TYPE_G10) { bIsChromaSitEnabled = pRenderHal->pRenderHalPltInterface->IsChromasitingEnabled(pRenderHal, pParams); switch (pSurface->Format) { case Format_IMC1: case Format_IMC2: case Format_IMC3: case Format_IMC4: case Format_I420: case Format_IYUV: case Format_YVU9: PlaneDefinition = RENDERHAL_PLANES_PL3; break; case Format_YV12: bHalfPitchForChroma = true; // Y_Uoffset(Height*2 + Height/2) of RENDERHAL_PLANES_YV12 define Bitfield_Range(0, 13) on gen9+. // The max value is 16383. So use PL3 kernel to avoid out of range when Y_Uoffset is larger than 16383. // Use PL3 plane to avoid YV12 blending issue with DI enabled and U channel shift issue with not 4-aligned height PlaneDefinition = (pRenderHal->bEnableYV12SinglePass && !pRenderHalSurface->pDeinterlaceParams && !pRenderHalSurface->bInterlacedScaling && !bIsTri9YV12 && MOS_IS_ALIGNED(pSurface->dwHeight, 4) && pRenderHalSurface->SurfType != RENDERHAL_SURF_OUT_RENDERTARGET && (pSurface->dwHeight * 2 + pSurface->dwHeight / 2) < RENDERHAL_MAX_YV12_PLANE_Y_U_OFFSET_G9)? RENDERHAL_PLANES_YV12 : RENDERHAL_PLANES_PL3; break; case Format_400P: // Single Y plane here is treated like a NV12 surface. // U and V offsets fall inside this Y plane. Eventhough false UV pixels are // picked by the kernel, CSC coeffecients are such that the effect of these // are nullified. PlaneDefinition = RENDERHAL_PLANES_NV12; break; case Format_P208: PlaneDefinition = RENDERHAL_PLANES_P208; break; case Format_P010: case Format_P016: if (pParams->bUseSinglePlane == true) { PlaneDefinition = RENDERHAL_PLANES_R16_UNORM; } else if (pRenderHal->bEnableP010SinglePass && (pRenderHalSurface->SurfType != RENDERHAL_SURF_OUT_RENDERTARGET)) { PlaneDefinition = RENDERHAL_PLANES_P010_1PLANE; } else { PlaneDefinition = RENDERHAL_PLANES_P010; } break; case Format_411P: PlaneDefinition = RENDERHAL_PLANES_411P; break; case Format_411R: PlaneDefinition = RENDERHAL_PLANES_411R; break; case Format_422H: PlaneDefinition = RENDERHAL_PLANES_422H; break; case Format_422V: PlaneDefinition = RENDERHAL_PLANES_422V; break; case Format_444P: PlaneDefinition = RENDERHAL_PLANES_444P; break; case Format_RGBP: PlaneDefinition = RENDERHAL_PLANES_RGBP; break; case Format_BGRP: PlaneDefinition = RENDERHAL_PLANES_BGRP; break; case Format_NV12: // On Gen7.5 (Haswell) NV12 format needs a single plane instead // of two (listed in renderhal_g75.c for RENDERHAL_PLANES_NV12), and // is also expected by the Sampler or Media Kernels. Yet, the // Data Port works with two planes instead. Besides, the Sampler // uses it for input only (as there is no output) while the Data // Port uses it for input as well as output or both for the same // surface. Hence the check added for bWidthInDword_Y && // bWidthInDword_UV, which are set in vphal_render_3P.c for the // above reason. Two plane NV12 can also be explicitly spcified. // On G8, NV12 format needs the width and Height to be a multiple // of 4 for both 3D sampler and 8x8 sampler; G75 needs the width // of NV12 input surface to be a multiple of 4 for 3D sampler; // On G9+, width need to be a multiple of 2, while height still need // be a multiple of 4; since G9 already post PV, just keep the old logic // to enable 2 plane NV12 when the width or Height is not a multiple of 4. // For G10+, enable 2 plane NV12 when width is not multiple of 2 or height // is not multiple of 4. if (pParams->bUseSinglePlane == true) { PlaneDefinition = RENDERHAL_PLANES_R8; } else if (pRenderHalSurface->SurfType == RENDERHAL_SURF_OUT_RENDERTARGET || (pParams->bWidthInDword_Y && pParams->bWidthInDword_UV) || pParams->b2PlaneNV12NeededByKernel || bIsChromaSitEnabled || pRenderHal->pfnIs2PlaneNV12Needed(pRenderHal, pRenderHalSurface, pParams->Boundary)) { PlaneDefinition = RENDERHAL_PLANES_NV12_2PLANES; } else { PlaneDefinition = RENDERHAL_PLANES_NV12; MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pRenderHalPltInterface); pRenderHal->pRenderHalPltInterface->GetPlaneDefForFormatNV12( PlaneDefinition); } break; case Format_YUYV : case Format_YUY2 : if (bIsChromaSitEnabled) { PlaneDefinition = RENDERHAL_PLANES_YUY2_2PLANES; } else { PlaneDefinition = RENDERHAL_PLANES_YUY2; } break; case Format_G8R8_G8B8: case Format_UYVY : PlaneDefinition = RENDERHAL_PLANES_UYVY; break; case Format_YVYU: PlaneDefinition = RENDERHAL_PLANES_YVYU; break; case Format_VYUY: PlaneDefinition = RENDERHAL_PLANES_VYUY; break; case Format_A8R8G8B8: PlaneDefinition = RENDERHAL_PLANES_ARGB; break; case Format_R32U: PlaneDefinition = RENDERHAL_PLANES_R32U; break; case Format_R32S: PlaneDefinition = RENDERHAL_PLANES_R32S; break; case Format_R32F: case Format_D32F: case Format_R32: PlaneDefinition = RENDERHAL_PLANES_R32F; break; case Format_G32R32F: PlaneDefinition = RENDERHAL_PLANES_G32R32F; break; case Format_Y8: PlaneDefinition = RENDERHAL_PLANES_R8; break; case Format_Y1: PlaneDefinition = RENDERHAL_PLANES_Y1; break; case Format_Y16U: PlaneDefinition = RENDERHAL_PLANES_Y16U; break; case Format_Y16S: PlaneDefinition = RENDERHAL_PLANES_Y16S; break; case Format_R8G8SN: case Format_V8U8: PlaneDefinition = RENDERHAL_PLANES_V8U8; break; case Format_R16U: PlaneDefinition = RENDERHAL_PLANES_R16U; break; case Format_R16S: PlaneDefinition = RENDERHAL_PLANES_R16S; break; case Format_R8G8UN: PlaneDefinition = RENDERHAL_PLANES_R8G8_UNORM; break; case Format_X8R8G8B8: // h/w doesn't support XRGB render target PlaneDefinition = (pParams->isOutput) ? RENDERHAL_PLANES_ARGB : RENDERHAL_PLANES_XRGB; break; case Format_A8B8G8R8: PlaneDefinition = RENDERHAL_PLANES_ABGR; break; case Format_X8B8G8R8: // h/w doesn't support XBGR render target PlaneDefinition = (pParams->isOutput) ? RENDERHAL_PLANES_ABGR : RENDERHAL_PLANES_XBGR; break; case Format_R5G6B5: PlaneDefinition = RENDERHAL_PLANES_RGB16; break; case Format_R8G8B8: PlaneDefinition = RENDERHAL_PLANES_RGB24; break; case Format_AYUV : PlaneDefinition = RENDERHAL_PLANES_AYUV; break; case Format_AI44 : PlaneDefinition = (pRenderHalSurface->iPaletteID == 0) ? RENDERHAL_PLANES_AI44_PALLETE_0 : RENDERHAL_PLANES_AI44_PALLETE_1; break; case Format_IA44: PlaneDefinition = (pRenderHalSurface->iPaletteID == 0) ? RENDERHAL_PLANES_IA44_PALLETE_0 : RENDERHAL_PLANES_IA44_PALLETE_1; break; case Format_P8: PlaneDefinition = (pRenderHalSurface->iPaletteID == 0) ? RENDERHAL_PLANES_P8_PALLETE_0 : RENDERHAL_PLANES_P8_PALLETE_1; break; case Format_A8P8: PlaneDefinition = (pRenderHalSurface->iPaletteID == 0) ? RENDERHAL_PLANES_A8P8_PALLETE_0 : RENDERHAL_PLANES_A8P8_PALLETE_1; break; case Format_STMM: PlaneDefinition = RENDERHAL_PLANES_STMM; break; case Format_L8: PlaneDefinition = RENDERHAL_PLANES_L8; break; case Format_A8: case Format_Buffer_2D: PlaneDefinition = RENDERHAL_PLANES_A8; break; case Format_R8U: case Format_R8UN: PlaneDefinition = RENDERHAL_PLANES_R8; break; case Format_R16UN: case Format_D16: case Format_R16: PlaneDefinition = RENDERHAL_PLANES_R16_UNORM; break; case Format_A16B16G16R16: PlaneDefinition = RENDERHAL_PLANES_A16B16G16R16; break; case Format_Y416: if (pRenderHalSurface->SurfType == RENDERHAL_SURF_OUT_RENDERTARGET) { PlaneDefinition = RENDERHAL_PLANES_Y416_RT; } else { PlaneDefinition = RENDERHAL_PLANES_A16B16G16R16; } break; case Format_A16B16G16R16F: PlaneDefinition = RENDERHAL_PLANES_A16B16G16R16F; break; case Format_A16R16G16B16F: PlaneDefinition = RENDERHAL_PLANES_A16R16G16B16F; break; case Format_R32G32B32A32F: PlaneDefinition = RENDERHAL_PLANES_R32G32B32A32F; break; case Format_NV21: PlaneDefinition = RENDERHAL_PLANES_NV21; break; case Format_L16: PlaneDefinition = RENDERHAL_PLANES_L16; break; case Format_R10G10B10A2: case Format_Y410: PlaneDefinition = RENDERHAL_PLANES_R10G10B10A2; break; case Format_Y210: case Format_Y216: MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->GetPlaneDefForFormatY216( (pRenderHalSurface->SurfType == RENDERHAL_SURF_OUT_RENDERTARGET), pRenderHal, PlaneDefinition)); break; case Format_B10G10R10A2: PlaneDefinition = RENDERHAL_PLANES_B10G10R10A2; break; case Format_IRW0: PlaneDefinition = RENDERHAL_PLANES_IRW0; break; case Format_IRW1: PlaneDefinition = RENDERHAL_PLANES_IRW1; break; case Format_IRW2: PlaneDefinition = RENDERHAL_PLANES_IRW2; break; case Format_IRW3: PlaneDefinition = RENDERHAL_PLANES_IRW3; break; case Format_R16G16UN: PlaneDefinition = RENDERHAL_PLANES_R16G16_UNORM; break; case Format_R16G16S: PlaneDefinition = RENDERHAL_PLANES_R16G16_SINT; break; case Format_R16F: PlaneDefinition = RENDERHAL_PLANES_R16_FLOAT; break; case Format_R24G8: case Format_D24S8UN: PlaneDefinition = RENDERHAL_PLANES_R24_UNORM_X8_TYPELESS; break; case Format_R32G8X24: case Format_D32S8X24_FLOAT: PlaneDefinition = RENDERHAL_PLANES_R32_FLOAT_X8X24_TYPELESS; break; default: return eStatus; } } if (pParams->forceCommonSurfaceMessage) { MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pfnGetPlaneDefinitionForCommonMessage); MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pfnGetPlaneDefinitionForCommonMessage(pRenderHal, pSurface->Format, pParams, pRenderHalSurface->SurfType == RENDERHAL_SURF_OUT_RENDERTARGET, PlaneDefinition)); } // Get plane definitions MHW_RENDERHAL_ASSERT(PlaneDefinition < RENDERHAL_PLANES_DEFINITION_COUNT); *piNumEntries = pRenderHal->pPlaneDefinitions[PlaneDefinition].dwNumPlanes; pPlane = pRenderHal->pPlaneDefinitions[PlaneDefinition].Plane; if (*piNumEntries == 0) { return eStatus; } // Surface state allocation/setting loop for (i = 0; i < *piNumEntries; i++, pPlane++) { // Assign a New Surface State Entry MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pfnAssignSurfaceState(pRenderHal, pParams->Type, &pSurfaceEntry)); // Save surface entry ppSurfaceEntries[i] = pSurfaceEntry; // Adjust the surface height and width pRenderHal->pfnAdjustBoundary(pRenderHal, pRenderHalSurface, pParams->Boundary, &dwSurfaceWidth, &dwSurfaceHeight); //set dwSurfaceHeight = roundup(dwSurfaceHeight / pPlane->ui8ScaleHeight) to support NV12 format with odd height dwSurfaceHeight = (dwSurfaceHeight + pPlane->ui8ScaleHeight - 1) / pPlane->ui8ScaleHeight; dwSurfaceWidth = dwSurfaceWidth / pPlane->ui8ScaleWidth; // U/V/UV plane if (pPlane->ui8PlaneID == MHW_U_PLANE || pPlane->ui8PlaneID == MHW_V_PLANE) { bWidthInDword = pParams->bWidthInDword_UV; } else { bWidthInDword = pParams->bWidthInDword_Y; } // Adjust the width if (bWidthInDword) { if (pParams->forceCommonSurfaceMessage && (PlaneDefinition == RENDERHAL_PLANES_R8 || PlaneDefinition == RENDERHAL_PLANES_R16_UNORM)) { //For packed 422 formats, single channel format is used for writing, so the width need to be double. dwSurfaceWidth = dwSurfaceWidth << 1; } else if (PlaneDefinition == RENDERHAL_PLANES_R32G32B32A32F) { dwSurfaceWidth = dwSurfaceWidth << 2; } else if (PlaneDefinition == RENDERHAL_PLANES_A16B16G16R16 || PlaneDefinition == RENDERHAL_PLANES_A16B16G16R16_ADV || PlaneDefinition == RENDERHAL_PLANES_A16B16G16R16F || PlaneDefinition == RENDERHAL_PLANES_A16R16G16B16F || PlaneDefinition == RENDERHAL_PLANES_G32R32F || PlaneDefinition == RENDERHAL_PLANES_Y210_RT || PlaneDefinition == RENDERHAL_PLANES_Y416_RT || PlaneDefinition == RENDERHAL_PLANES_R32_FLOAT_X8X24_TYPELESS) { dwSurfaceWidth = dwSurfaceWidth << 1; } else if (MEDIA_IS_SKU(pRenderHal->pSkuTable, FtrDisableRenderTargetWidthAdjust) && (PlaneDefinition == RENDERHAL_PLANES_NV12_2PLANES || PlaneDefinition == RENDERHAL_PLANES_P010 || PlaneDefinition == RENDERHAL_PLANES_YUY2_2PLANES || PlaneDefinition == RENDERHAL_PLANES_YUY2 || PlaneDefinition == RENDERHAL_PLANES_RGBP || PlaneDefinition == RENDERHAL_PLANES_PL3 || PlaneDefinition == RENDERHAL_PLANES_YV12 || PlaneDefinition == RENDERHAL_PLANES_R16_UNORM || PlaneDefinition == RENDERHAL_PLANES_R8 || PlaneDefinition == RENDERHAL_PLANES_A8 || PlaneDefinition == RENDERHAL_PLANES_RGB16 || PlaneDefinition == RENDERHAL_PLANES_BGRP)) { dwSurfaceWidth = dwSurfaceWidth / OutputSurfaceWidthRatio; } else { dwSurfaceWidth = (dwSurfaceWidth + pPlane->ui8PixelsPerDword - 1) / pPlane->ui8PixelsPerDword; } } if (pParams->bVertStride) { dwSurfaceHeight /= 2; dwSurfaceHeight = MOS_MAX(dwSurfaceHeight, 1); } dwSurfaceHeight = MOS_ALIGN_FLOOR(dwSurfaceHeight, pPlane->ui8AlignHeight); dwSurfaceWidth = MOS_ALIGN_FLOOR(dwSurfaceWidth , pPlane->ui8AlignWidth); // Setup surface state entry *(pSurfaceEntry->pSurface) = *pSurface; pSurfaceEntry->dwFormat = pPlane->dwFormat; pSurfaceEntry->dwWidth = MOS_MAX(1, dwSurfaceWidth); pSurfaceEntry->dwHeight = MOS_MAX(1, dwSurfaceHeight); pSurfaceEntry->bWidthInDword = bWidthInDword; if (pPlane->ui8PlaneID == MHW_U_PLANE || pPlane->ui8PlaneID == MHW_V_PLANE) { if (bIsTri9YV12) { pSurfaceEntry->dwPitch = (pPlane->ui8PlaneID == MHW_U_PLANE) ? pSurface->dwUPitch : pSurface->dwVPitch; } else { pSurfaceEntry->dwPitch = dwUVPitch; } } else { pSurfaceEntry->dwPitch = bIsTri9YV12 ? pSurface->dwYPitch : pSurface->dwPitch; } pSurfaceEntry->dwQPitch = pSurface->dwQPitch; pSurfaceEntry->YUVPlane = pPlane->ui8PlaneID; pSurfaceEntry->bAVS = pPlane->bAdvanced; pSurfaceEntry->isOutput = pParams->isOutput; pSurfaceEntry->bVertStride = pParams->bVertStride; pSurfaceEntry->bVertStrideOffs = pParams->bVertStrideOffs; pSurfaceEntry->bTiledSurface = (pSurface->TileType != MOS_TILE_LINEAR) ? true : false; pSurfaceEntry->bTileWalk = IS_Y_MAJOR_TILE_FORMAT(pSurface->TileType) ? GFX3DSTATE_TILEWALK_YMAJOR : GFX3DSTATE_TILEWALK_XMAJOR; // AVS/ADI parameters pSurfaceEntry->bHalfPitchChroma = bHalfPitchForChroma; pSurfaceEntry->bInterleaveChroma = bInterleaveChroma; pSurfaceEntry->DirectionV = Direction & 0x7; pSurfaceEntry->DirectionU = Direction >> 0x3; pSurfaceEntry->wUXOffset = wUXOffset; pSurfaceEntry->wUYOffset = wUYOffset; pSurfaceEntry->wVXOffset = wVXOffset; pSurfaceEntry->wVYOffset = wVYOffset; pSurfaceEntry->AddressControl = pParams->AddressControl; } eStatus = MOS_STATUS_SUCCESS; return eStatus; } //! //! \brief Get Plane Definition For L0 FC //! \details Get Specific Plane Definition for L0 FC usage //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to Hardware Interface Structure //! \param MOS_FORMAT format //! [in] surface format //! \param bool isRenderTaget //! [in] the surface type is RENDERHAL_SURF_OUT_RENDERTARGET //! \param RENDERHAL_PLANE_DEFINITION &planeDefinition //! [out] Plane Definition //! \return MOS_STATUS //! Error code if invalid parameters, MOS_STATUS_SUCCESS otherwise //! MOS_STATUS RenderHal_GetPlaneDefinitionForCommonMessage( PRENDERHAL_INTERFACE pRenderHal, MOS_FORMAT format, PRENDERHAL_SURFACE_STATE_PARAMS &pParam, bool isRenderTarget, RENDERHAL_PLANE_DEFINITION &planeDefinition) { switch (format) { case Format_A8R8G8B8: case Format_X8R8G8B8: case Format_A16R16G16B16: case Format_R10G10B10A2: case Format_AYUV: case Format_A16R16G16B16F: case Format_A8B8G8R8: case Format_X8B8G8R8: case Format_A16B16G16R16: case Format_B10G10R10A2: case Format_A16B16G16R16F: case Format_Y410: case Format_P210: case Format_P216: case Format_R5G6B5: case Format_R8G8B8: case Format_RGBP: case Format_BGRP: case Format_444P: //already handled rightly in normal non-adv GetPlaneDefinition break; case Format_NV12: if (pParam->combineChannelY) { planeDefinition = RENDERHAL_PLANES_NV12_2PLANES_COMBINED; } break; case Format_P010: case Format_P016: if (pParam->combineChannelY) { planeDefinition = RENDERHAL_PLANES_P016_2PLANES_COMBINED; } break; case Format_400P: planeDefinition = RENDERHAL_PLANES_R8; break; case Format_YUY2: case Format_YUYV: case Format_YVYU: case Format_UYVY: case Format_VYUY: if (isRenderTarget) { //For writing, packed 422 formats use R8 to write each channel separately planeDefinition = RENDERHAL_PLANES_R8; } else { //For reading, packed 422 formats use R8G8 for Y and A8R8G8B8 for UV planeDefinition = RENDERHAL_PLANES_YUY2_2PLANES_WIDTH_UNALIGNED; } break; case Format_Y210: case Format_Y216: if (isRenderTarget) { //For writing, packed 422 formats use R16 to write each channel separately planeDefinition = RENDERHAL_PLANES_R16_UNORM; } else { //For reading, packed 422 formats use RG16 for Y and ARGB16 for UV planeDefinition = RENDERHAL_PLANES_Y210; } break; case Format_Y416: planeDefinition = RENDERHAL_PLANES_A16B16G16R16; break; default: return MOS_STATUS_INVALID_PARAMETER; } return MOS_STATUS_SUCCESS; } //! //! \brief Enable Palette //! \details Enable HW palette - reuse previous palette data //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to Hardware Interface Structure //! \param uint32_t uiPaletteID //! [in] Palette ID (0 to available palettes - 1) //! \param int32_t iPaletteSize //! [in] Palette Size (<=0 - disable palette) //! \return MOS_STATUS //! Error code if invalid parameters, MOS_STATUS_SUCCESS otherwise //! MOS_STATUS RenderHal_EnablePalette( PRENDERHAL_INTERFACE pRenderHal, int32_t iPaletteID, int32_t iPaletteSize) { PMHW_PALETTE_PARAMS pPalette; //------------------------------------- MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_ASSERT(iPaletteID >= 0); MHW_RENDERHAL_ASSERT(iPaletteID < pRenderHal->iMaxPalettes); //------------------------------------- // Palette ID provided invalid or allocation failed //pHwCommands = pRenderHal->pHwCommands; // Set palette size - 0 disables palette send command iPaletteSize = MOS_MAX(iPaletteSize, 0); iPaletteSize = MOS_MIN(iPaletteSize, pRenderHal->iMaxPaletteEntries); pPalette = &(pRenderHal->Palette[iPaletteID]); pPalette->iNumEntries = iPaletteSize; return MOS_STATUS_SUCCESS; } //! //! \brief Allocate Palette ID //! \details Allocate palette ID for Client //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to RenderHal Interface structure //! \param int32_t *pPaletteID //! [out] Pointer to Palette ID //! \return MOS_STATUS //! MOS_STATUS_SUCCESS, otherwise MOS_STATUS_NO_SPACE or MOS_STATUS_NULL_POINTER //! MOS_STATUS RenderHal_AllocatePaletteID( PRENDERHAL_INTERFACE pRenderHal, int32_t *pPaletteID) { int32_t i; PMHW_PALETTE_PARAMS pOutPalette; MOS_STATUS eStatus = MOS_STATUS_SUCCESS; MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(pPaletteID); *pPaletteID = -1; pOutPalette = pRenderHal->Palette; // search first palette not in use for (i = 0; i < pRenderHal->iMaxPalettes; i++, pOutPalette++) { if (pOutPalette->iNumEntries == 0) { pOutPalette->iNumEntries = -1; break; } } // Allocation failed if (i < 0 || i >= pRenderHal->iMaxPalettes) { MHW_RENDERHAL_ASSERTMESSAGE("cannot find valid palette ID."); eStatus = MOS_STATUS_NO_SPACE; return eStatus; } else { *pPaletteID = i; } return eStatus; } //! //! \brief Get Palette Entry Size and Address //! \details Get Palette Entry Size and Address for Client to load palette //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to RenderHal Interface structure //! \param int32_t iPaletteID //! [in] Input Palette ID //! \param int32_t iInNumEntries //! [in] Number of Input Palette entries //! \param int32_t *piOutNumEntries //! [out] Number of Output Palette entries //! \param void **pPaletteData //! [out] Pointer to Output Palette data address //! \return MOS_STATUS //! MOS_STATUS_SUCCESS, otherwise MOS_STATUS_INVALID_PARAMETER or MOS_STATUS_NULL_POINTER //! MOS_STATUS RenderHal_GetPaletteEntry( PRENDERHAL_INTERFACE pRenderHal, int32_t iPaletteID, int32_t iInNumEntries, int32_t *piOutNumEntries, void **pPaletteData) { PMHW_PALETTE_PARAMS pOutPalette; int32_t iSize; MOS_STATUS eStatus = MOS_STATUS_SUCCESS; MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(piOutNumEntries); MHW_RENDERHAL_CHK_NULL_RETURN(pPaletteData); *piOutNumEntries = -1; *pPaletteData = nullptr; // Palette Index provided invalid if (iPaletteID < 0 || iPaletteID >= pRenderHal->iMaxPalettes) { MHW_RENDERHAL_ASSERTMESSAGE("invalid palette ID."); eStatus = MOS_STATUS_INVALID_PARAMETER; return eStatus; } // Input Palette entry number invalid if (iInNumEntries < 1) { MHW_RENDERHAL_ASSERTMESSAGE("invalid Input Palette entries."); eStatus = MOS_STATUS_INVALID_PARAMETER; return eStatus; } // Get pointer to output palette pOutPalette = &(pRenderHal->Palette[iPaletteID]); // Pallete is too large - truncate if (iInNumEntries > pRenderHal->iMaxPaletteEntries) { iSize = pRenderHal->iMaxPaletteEntries; MHW_RENDERHAL_ASSERTMESSAGE("Palette truncated from %d to %d.", iInNumEntries, iSize); } else { iSize = iInNumEntries; } // Pallete is being overwritten - just log if (pOutPalette->iNumEntries != 0 && pOutPalette->iNumEntries != -1) { MHW_RENDERHAL_ASSERTMESSAGE("overwriting palette %d.", iPaletteID); } pOutPalette->iNumEntries = iSize; *piOutNumEntries = iSize; *pPaletteData = pOutPalette->pPaletteData; return eStatus; } //! //! \brief Free Palette ID //! \details Free palette ID //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to RenderHal Interface structure //! \param int32_t *pPaletteID //! [in/out] Pointer to Palette ID //! \return MOS_STATUS //! MOS_STATUS_SUCCESS, otherwise MOS_STATUS_INVALID_PARAMETER or MOS_STATUS_NULL_POINTER //! MOS_STATUS RenderHal_FreePaletteID( PRENDERHAL_INTERFACE pRenderHal, int32_t *pPaletteID) { PMHW_PALETTE_PARAMS pOutPalette; int32_t iPaletteID; MOS_STATUS eStatus = MOS_STATUS_SUCCESS; MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(pPaletteID); iPaletteID = *pPaletteID; if (iPaletteID < 0 || iPaletteID >= pRenderHal->iMaxPalettes) { MHW_RENDERHAL_ASSERTMESSAGE("invalid palette ID."); eStatus = MOS_STATUS_INVALID_PARAMETER; return eStatus; } pOutPalette = &(pRenderHal->Palette[iPaletteID]); pOutPalette->iNumEntries = 0; *pPaletteID = -1; return eStatus; } //! //! \brief Allocate ChromaKey //! \details Allocate chroma key for use with sampler //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to Hardware Interface Structure //! \param uint32_t dwLow //! Min Key Range //! \param uint32_t dwHigh //! Max Key Range //! \return int32_t //! Chroma key index //! -1 if not available //! int32_t RenderHal_AllocateChromaKey( PRENDERHAL_INTERFACE pRenderHal, uint32_t dwLow, uint32_t dwHigh) { PMHW_CHROMAKEY_PARAMS pChromaKey; int32_t iChromaKeyIndex = -1; // Validate parameters if (pRenderHal == nullptr) { MHW_RENDERHAL_ASSERTMESSAGE("Invalid RenderHal interface."); return iChromaKeyIndex; } if (pRenderHal->iChromaKeyCount > pRenderHal->iMaxChromaKeys) { MHW_RENDERHAL_ASSERTMESSAGE("Reached max number of chroma keys."); return iChromaKeyIndex; } // Get chroma index - setup command iChromaKeyIndex = pRenderHal->iChromaKeyCount++; pChromaKey = &pRenderHal->ChromaKey[iChromaKeyIndex]; pChromaKey->dwLow = dwLow; pChromaKey->dwHigh = dwHigh; // Return Chroma Key Index return iChromaKeyIndex; } //! //! \brief Assign Media State //! \details Gets a pointer to the next available media state in GSH; //! fails if not available //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to Hadrware Interface Structure //! \param RENDERHAL_COMPONENT componentID //! [in] Identifier of the requesting component //! \return PRENDERHAL_MEDIA_STATE //! gets a new Media State, returns pointer to Media State structure //! nullptr - invalid, no states available + timeout //! PRENDERHAL_MEDIA_STATE RenderHal_AssignMediaState( PRENDERHAL_INTERFACE pRenderHal, RENDERHAL_COMPONENT componentID) { uint32_t dwWaitMs, dwWaitTag; PMOS_INTERFACE pOsInterface = nullptr; // OS interface PRENDERHAL_STATE_HEAP pStateHeap = nullptr; // State Heap control struct PRENDERHAL_MEDIA_STATE pCurMediaState; // Media state control in GSH struct uint8_t *pCurrentPtr; int i; size_t mediaStateSize = 0; uint8_t *ptrMediaState = nullptr; pCurMediaState = nullptr; pCurrentPtr = nullptr; if (pRenderHal) { pOsInterface = pRenderHal->pOsInterface; pStateHeap = pRenderHal->pStateHeap; } // Validate state if (pRenderHal == nullptr || // invalid Hw state pOsInterface == nullptr || // invalid OS interface pStateHeap == nullptr || // invalid State Heap pStateHeap->pMediaStates == nullptr || // invalid Media State Array pStateHeap->bGshLocked == false || // State Heap not locked pRenderHal->pRenderHalPltInterface == nullptr || // invalid RenderHal Platform Interface pRenderHal->StateHeapSettings.iMediaStateHeaps == 0) { MHW_RENDERHAL_ASSERTMESSAGE("Invalid state."); return pCurMediaState; } mediaStateSize = pRenderHal->pRenderHalPltInterface->GetRenderHalMediaStateSize(); // Refresh sync tag for all media states pRenderHal->pfnRefreshSync(pRenderHal); // Get next media state and tag to check ptrMediaState = (uint8_t*)pStateHeap->pMediaStates; ptrMediaState += pStateHeap->iNextMediaState * mediaStateSize; pCurMediaState = (PRENDERHAL_MEDIA_STATE)ptrMediaState; // The code below is unlikely to be executed - unless all media states are in use // If this ever happens, please consider increasing the number of media states if (pCurMediaState->bBusy) { dwWaitTag = pCurMediaState->dwSyncTag; // Wait for Batch Buffer complete event OR timeout for (dwWaitMs = pRenderHal->dwTimeoutMs; dwWaitMs > 0; dwWaitMs--) { //MOS_GPU_CONTEXT_RENDER or MOS_GPU_CONTEXT_RENDER3 pOsInterface->pfnWaitForBBCompleteNotifyEvent(pOsInterface, pOsInterface->CurrentGpuContextOrdinal, RENDERHAL_EVENT_TIMEOUT_MS); // Wait for tag (end of command buffer, start of next command buffer) if ((int32_t)(pStateHeap->pSync[0] - dwWaitTag) > 0) break; } // Timeout if (dwWaitMs == 0) { MHW_RENDERHAL_ASSERTMESSAGE("Timeout for waiting free media state."); pStateHeap->pCurMediaState = pCurMediaState = nullptr; return pCurMediaState; } } // Setup the Current Media State pStateHeap->pCurMediaState = pCurMediaState; pStateHeap->iCurMediaState = pStateHeap->iNextMediaState; // Point to the next media state pStateHeap->iNextMediaState = (pStateHeap->iNextMediaState + 1) % (pRenderHal->StateHeapSettings.iMediaStateHeaps); // Reset media state pCurMediaState->dwSyncTag = pStateHeap->dwNextTag; pCurMediaState->dwSyncCount = 0; pCurMediaState->iCurbeOffset = 0; MOS_FillMemory( pCurMediaState->piAllocation, pRenderHal->StateHeapSettings.iMediaIDs * sizeof(int32_t), -1); // Reset HW allocations pRenderHal->iChromaKeyCount = 0; for (i = 0; i < pRenderHal->iMaxPalettes; i++) { pRenderHal->Palette[i].iNumEntries = 0; } // Zero Memory start time and end time pCurrentPtr = pStateHeap->pGshBuffer + // GSH base pStateHeap->pCurMediaState->dwOffset + pStateHeap->dwOffsetStartTime; if(pCurrentPtr) { // Start time *((uint64_t*)pCurrentPtr) = 0; } // End time pCurrentPtr += pStateHeap->dwStartTimeSize; *((uint64_t*)pCurrentPtr) = 0; // Component ID pCurrentPtr += pStateHeap->dwEndTimeSize; *((RENDERHAL_COMPONENT *)pCurrentPtr) = componentID; return pCurMediaState; } //! //! \brief Destroy //! \details Free all resources allocated by RenderHal //! \param PRENDERHAL_INTERFACE pRenderHal //! \return void //! MOS_STATUS RenderHal_Destroy(PRENDERHAL_INTERFACE pRenderHal) { MOS_STATUS eStatus; //------------------------------------------------ MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pRenderHalPltInterface); //------------------------------------------------ eStatus = MOS_STATUS_UNKNOWN; // Free State Heaps eStatus = (MOS_STATUS)(pRenderHal->pfnFreeStateHeaps(pRenderHal)); if (eStatus != MOS_STATUS_SUCCESS) { MHW_RENDERHAL_ASSERTMESSAGE("Failed to free state heeps, eStatus:%d.\n", eStatus); } // Destroy MHW Render Interface pRenderHal->pRenderHalPltInterface->DestoryMhwInterface(pRenderHal); // Release pBatchBufferMemPool if (pRenderHal->pBatchBufferMemPool) { MOS_Delete(pRenderHal->pBatchBufferMemPool); pRenderHal->pBatchBufferMemPool = nullptr; } // Release PredicationBuffer if (!Mos_ResourceIsNull(&pRenderHal->PredicationBuffer)) { pRenderHal->pOsInterface->pfnFreeResource( pRenderHal->pOsInterface, &pRenderHal->PredicationBuffer); } MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->DestroyPerfProfiler(pRenderHal)); // Destruct Platform Interface if (pRenderHal->pRenderHalPltInterface) { MOS_Delete(pRenderHal->pRenderHalPltInterface); pRenderHal->pRenderHalPltInterface = nullptr; } // Free multiple trackers pRenderHal->trackerProducer.~FrameTrackerProducer(); // Free Debug Surface RenderHal_FreeDebugSurface(pRenderHal); // Decrease reference count for shared pointer pRenderHal->userSettingPtr = nullptr; eStatus = MOS_STATUS_SUCCESS; return eStatus; } //! //! \brief Load Curbe Data //! \details Allocates and load CURBE data for Media //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to RenderHal Interface structure //! \param PRENDERHAL_MEDIA_STATE pCurMediaState //! [out] Pointer to Current Media State structure //! \param void *pData //! [in] Pointer to Data //! \param int32_t iSize //! [in] Number of bytes to allocate //! \return int32_t //! Offset of the CURBE block from CURBE base (in bytes) //! -1 if no CURBE space available in GSH //! int32_t RenderHal_LoadCurbeData( PRENDERHAL_INTERFACE pRenderHal, PRENDERHAL_MEDIA_STATE pCurMediaState, void *pData, int32_t iSize) { int32_t iOffset; int32_t iCurbeSize; uint8_t *pPtrCurbe; PRENDERHAL_STATE_HEAP pStateHeap; iOffset = -1; pStateHeap = (pRenderHal) ? pRenderHal->pStateHeap : nullptr; if (pStateHeap && pCurMediaState) { iCurbeSize = MOS_ALIGN_CEIL(iSize, pRenderHal->dwCurbeBlockAlign); if (pCurMediaState->iCurbeOffset + iCurbeSize <= (int)pStateHeap->dwSizeCurbe) { iOffset = pCurMediaState->iCurbeOffset; pCurMediaState->iCurbeOffset += iCurbeSize; if (pData) { pPtrCurbe = pStateHeap->pGshBuffer + // GSH base pStateHeap->pCurMediaState->dwOffset + // Offset to media state pStateHeap->dwOffsetCurbe + // Offset to curbe area iOffset; // Current curbe offset // Copy data to CURBE MOS_SecureMemcpy(pPtrCurbe, iSize, pData, iSize); // Zero remaining CURBE (for buffer alignment) iCurbeSize -= iSize; if (iCurbeSize > 0) { MOS_ZeroMemory(pPtrCurbe + iSize, iCurbeSize); } } } } return iOffset; } //! //! \brief Send Curbe Load //! \details Send Curbe Load command //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to Hardware Interface Structure //! \param PMOS_COMMAND_BUFFER pCmdBuffer //! [in] Pointer to Command Buffer //! \return MOS_STATUS //! MOS_STATUS RenderHal_SendCurbeLoad( PRENDERHAL_INTERFACE pRenderHal, PMOS_COMMAND_BUFFER pCmdBuffer) { MHW_CURBE_LOAD_PARAMS CurbeLoadParams; PRENDERHAL_STATE_HEAP pStateHeap; MOS_STATUS eStatus = MOS_STATUS_SUCCESS; PMOS_INTERFACE pOsInterface = nullptr; MOS_CONTEXT *pOsContext = nullptr; MOS_OCA_BUFFER_HANDLE hOcaBuf = 0; //----------------------------------------- MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(pCmdBuffer); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap->pCurMediaState); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface->pOsContext); //----------------------------------------- eStatus = MOS_STATUS_SUCCESS; pStateHeap = pRenderHal->pStateHeap; pOsInterface = pRenderHal->pOsInterface; pOsContext = pOsInterface->pOsContext; // CURBE size is in bytes if (pStateHeap->pCurMediaState->iCurbeOffset != 0) { CurbeLoadParams.pKernelState = nullptr; CurbeLoadParams.bOldInterface = false; CurbeLoadParams.dwCURBETotalDataLength = pStateHeap->pCurMediaState->iCurbeOffset; CurbeLoadParams.dwCURBEDataStartAddress = pStateHeap->pCurMediaState->dwOffset + pStateHeap->dwOffsetCurbe; MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->AddMediaCurbeLoadCmd(pRenderHal, pCmdBuffer, &CurbeLoadParams)); HalOcaInterfaceNext::OnIndirectState(*pCmdBuffer, (MOS_CONTEXT_HANDLE)pOsContext, pRenderHal->StateBaseAddressParams.presDynamicState, CurbeLoadParams.dwCURBEDataStartAddress, false, CurbeLoadParams.dwCURBETotalDataLength); } return eStatus; } MOS_STATUS RenderHal_SendMediaIdLoad( PRENDERHAL_INTERFACE pRenderHal, PMOS_COMMAND_BUFFER pCmdBuffer) { MHW_ID_LOAD_PARAMS IdLoadParams; PRENDERHAL_STATE_HEAP pStateHeap; MOS_STATUS eStatus = MOS_STATUS_SUCCESS; PMOS_INTERFACE pOsInterface = nullptr; MOS_CONTEXT *pOsContext = nullptr; MOS_OCA_BUFFER_HANDLE hOcaBuf = 0; //----------------------------------------- MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(pCmdBuffer); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap->pCurMediaState); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface->pOsContext); //----------------------------------------- eStatus = MOS_STATUS_SUCCESS; pStateHeap = pRenderHal->pStateHeap; pOsInterface = pRenderHal->pOsInterface; pOsContext = pOsInterface->pOsContext; IdLoadParams.pKernelState = nullptr; IdLoadParams.dwInterfaceDescriptorStartOffset = pStateHeap->pCurMediaState->dwOffset + pStateHeap->dwOffsetMediaID; IdLoadParams.dwInterfaceDescriptorLength = pRenderHal->StateHeapSettings.iMediaIDs * pStateHeap->dwSizeMediaID; MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->AddMediaIDLoadCmd(pRenderHal, pCmdBuffer, &IdLoadParams)); HalOcaInterfaceNext::OnIndirectState(*pCmdBuffer, (MOS_CONTEXT_HANDLE)pOsContext, pRenderHal->StateBaseAddressParams.presDynamicState, IdLoadParams.dwInterfaceDescriptorStartOffset, false, IdLoadParams.dwInterfaceDescriptorLength); return eStatus; } //! //! \brief Send Chroma Key //! \details Sends Chroma Key //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to Hardware Interface Structure //! \param PMOS_COMMAND_BUFFER pCmdBuffer //! [in] Pointer to Command Buffer //! \return MOS_STATUS //! MOS_STATUS RenderHal_SendChromaKey( PRENDERHAL_INTERFACE pRenderHal, PMOS_COMMAND_BUFFER pCmdBuffer) { PMHW_CHROMAKEY_PARAMS pChromaKeyParams; int32_t i; MOS_STATUS eStatus; //---------------------------------- MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(pCmdBuffer); //---------------------------------- eStatus = MOS_STATUS_SUCCESS; // Send Chroma Keys in use pChromaKeyParams = pRenderHal->ChromaKey; for (i = pRenderHal->iChromaKeyCount; i > 0; i--, pChromaKeyParams++) { MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->SendChromaKey(pRenderHal, pCmdBuffer, pChromaKeyParams)); } return eStatus; } //! //! \brief Send Palette //! \details Sends Palette //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to Hardware Interface Structure //! \param PMOS_COMMAND_BUFFER pCmdBuffer //! [in] Pointer to Command Buffer //! \return MOS_STATUS //! MOS_STATUS RenderHal_SendPalette( PRENDERHAL_INTERFACE pRenderHal, PMOS_COMMAND_BUFFER pCmdBuffer) { PMHW_PALETTE_PARAMS pPaletteLoadParams; int32_t i; MOS_STATUS eStatus; //----------------------------------------- MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(pCmdBuffer); //----------------------------------------- eStatus = MOS_STATUS_SUCCESS; // Send Palettes in use pPaletteLoadParams = pRenderHal->Palette; for (i = pRenderHal->iMaxPalettes; i > 0; i--, pPaletteLoadParams++) { if (pPaletteLoadParams->iNumEntries > 0) { MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->SendPalette(pRenderHal, pCmdBuffer, pPaletteLoadParams)); } } return eStatus; } //! //! \brief Reset RenderHal States //! \details Reset RenderHal States in preparation for a new command buffer //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to RenderHal Interface Structure //! \return MOS_STATUS //! MOS_STATUS RenderHal_Reset( PRENDERHAL_INTERFACE pRenderHal) { PMOS_INTERFACE pOsInterface; MOS_STATUS eStatus; //---------------------------------- MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface); //---------------------------------- eStatus = MOS_STATUS_SUCCESS; pOsInterface = pRenderHal->pOsInterface; if (pRenderHal->pStateHeap == nullptr) { MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pfnAllocateStateHeaps(pRenderHal, &pRenderHal->StateHeapSettings)); if (pRenderHal->pStateHeap) { MHW_STATE_BASE_ADDR_PARAMS *pStateBaseParams = &pRenderHal->StateBaseAddressParams; pStateBaseParams->presGeneralState = &pRenderHal->pStateHeap->GshOsResource; pStateBaseParams->dwGeneralStateSize = pRenderHal->pStateHeap->dwSizeGSH; pStateBaseParams->presDynamicState = &pRenderHal->pStateHeap->GshOsResource; pStateBaseParams->dwDynamicStateSize = pRenderHal->pStateHeap->dwSizeGSH; pStateBaseParams->bDynamicStateRenderTarget = false; pStateBaseParams->presIndirectObjectBuffer = &pRenderHal->pStateHeap->GshOsResource; pStateBaseParams->dwIndirectObjectBufferSize = pRenderHal->pStateHeap->dwSizeGSH; pStateBaseParams->presInstructionBuffer = &pRenderHal->pStateHeap->IshOsResource; pStateBaseParams->dwInstructionBufferSize = pRenderHal->pStateHeap->dwSizeISH; } } MHW_RENDERHAL_CHK_STATUS_RETURN(pOsInterface->pfnRegisterResource(pOsInterface, &pRenderHal->pStateHeap->GshOsResource, true, true)); MHW_RENDERHAL_CHK_STATUS_RETURN(pOsInterface->pfnRegisterResource(pOsInterface, &pRenderHal->pStateHeap->IshOsResource, true, true)); // Reset Slice Shutdown Mode pRenderHal->bRequestSingleSlice = false; pRenderHal->PowerOption.nSlice = 0; pRenderHal->PowerOption.nEU = 0; pRenderHal->PowerOption.nSubSlice = 0; return eStatus; } //! //! \brief Assign Ssh Instance //! \details Get a pointer to the next available SSH Buffer Instance in SSH, //! Reset SSH allocations //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to RenderHal Interface Structure //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if succeded, MOS_STATUS_UNKOWN otherwise //! MOS_STATUS RenderHal_AssignSshInstance( PRENDERHAL_INTERFACE pRenderHal) { MOS_STATUS eStatus; PRENDERHAL_STATE_HEAP pStateHeap; //----------------------------------------- MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap); //----------------------------------------- eStatus = MOS_STATUS_SUCCESS; pStateHeap = pRenderHal->pStateHeap; if (pRenderHal->isBindlessHeapInUse) { MHW_RENDERHAL_NORMALMESSAGE("BindlessHeap does not need SSH Instance!"); MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pfnAssignBindlessSurfaceStates(pRenderHal)); return eStatus; } // Init SSH Params if (pStateHeap) { pStateHeap->iCurrentBindingTable = 0; pStateHeap->iCurrentSurfaceState = 0; } else { eStatus = MOS_STATUS_UNKNOWN; } return eStatus; } //! //! \brief Initializes command buffer attributes and inserts prolog //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to RenderHal Interface Structure //! \param PMOS_COMMAND_BUFFER pCmdBuffer //! [in] Pointer to Command Buffer //! \param PRENDERHAL_GENERIC_PROLOG_PARAMS pGenericPrologParam //! [in] Pointer to MHW generic prolog parameters //! \return MOS_STATUS //! MOS_STATUS RenderHal_InitCommandBuffer( PRENDERHAL_INTERFACE pRenderHal, PMOS_COMMAND_BUFFER pCmdBuffer, PRENDERHAL_GENERIC_PROLOG_PARAMS pGenericPrologParams) { PMOS_INTERFACE pOsInterface; MHW_GENERIC_PROLOG_PARAMS genericPrologParams; MOS_STATUS eStatus; bool isRender; //--------------------------------------------- MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(pCmdBuffer); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pRenderHalPltInterface); //--------------------------------------------- eStatus = MOS_STATUS_SUCCESS; pOsInterface = pRenderHal->pOsInterface; // Send Start Marker command isRender = MOS_RCS_ENGINE_USED(pOsInterface->pfnGetGpuContext(pOsInterface)); if (pRenderHal->SetMarkerParams.setMarkerEnabled) { MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->SendMarkerCommand( pRenderHal, pCmdBuffer, isRender)); } // Init Cmd Buffer #ifdef _MMC_SUPPORTED if (isRender) { MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->SetCompositePrologCmd(pRenderHal, pCmdBuffer)); } #endif // _MMC_SUPPORTED if (isRender) { // Set indirect heap size - limits the size of the command buffer available for rendering MHW_RENDERHAL_CHK_STATUS_RETURN(pOsInterface->pfnSetIndirectStateSize(pOsInterface, pRenderHal->dwIndirectHeapSize)); } pCmdBuffer->Attributes.bIsMdfLoad = pRenderHal->IsMDFLoad; pCmdBuffer->Attributes.bTurboMode = pRenderHal->bTurboMode; // Set power option status MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->SetPowerOptionStatus(pRenderHal, pCmdBuffer)); // Preemption: Need to set UsesMediaPipeline, UsesGPGPUPipeline, NeedsMidBatchPreEmptionSupport in command buffer header // Use IsMDFLoad to distinguish MDF context from other Media Contexts pCmdBuffer->Attributes.bMediaPreemptionEnabled = (pRenderHal->bEnableGpgpuMidBatchPreEmption || pRenderHal->bEnableGpgpuMidThreadPreEmption || pRenderHal->pRenderHalPltInterface->IsPreemptionEnabled(pRenderHal)) && !pRenderHal->forceDisablePreemption; if (pGenericPrologParams) { if (pGenericPrologParams->bEnableMediaFrameTracking) { MHW_RENDERHAL_CHK_NULL_RETURN(pGenericPrologParams->presMediaFrameTrackingSurface); pCmdBuffer->Attributes.bEnableMediaFrameTracking = pGenericPrologParams->bEnableMediaFrameTracking; pCmdBuffer->Attributes.dwMediaFrameTrackingTag = pGenericPrologParams->dwMediaFrameTrackingTag; pCmdBuffer->Attributes.dwMediaFrameTrackingAddrOffset = pGenericPrologParams->dwMediaFrameTrackingAddrOffset; pCmdBuffer->Attributes.resMediaFrameTrackingSurface = pGenericPrologParams->presMediaFrameTrackingSurface; } else { pCmdBuffer->Attributes.bEnableMediaFrameTracking = false; } } // Check if Override is needed if (pRenderHal->pRenderHalPltInterface) { MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->IsOvrdNeeded(pRenderHal, pCmdBuffer, pGenericPrologParams)); } MOS_ZeroMemory(&genericPrologParams, sizeof(genericPrologParams)); genericPrologParams.pOsInterface = pRenderHal->pOsInterface; genericPrologParams.pvMiInterface = pRenderHal->pMhwMiInterface; genericPrologParams.bMmcEnabled = pGenericPrologParams ? pGenericPrologParams->bMmcEnabled : false; if (pRenderHal->pRenderHalPltInterface) { MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->SendGenericPrologCmd(pRenderHal, pCmdBuffer, &genericPrologParams)); } // Send predication command if (pRenderHal->pRenderHalPltInterface && pRenderHal->PredicationParams.predicationEnabled) { MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->SendPredicationCommand(pRenderHal, pCmdBuffer)); } return eStatus; } //! //! \brief Send Sync Tag //! \details Sends Synchronization Tags //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to RenderHal Interface Structure //! \param PMOS_COMMAND_BUFFER pCmdBuffer //! [in] Pointer to Command Buffer //! \return MOS_STATUS //! MOS_STATUS RenderHal_SendSyncTag( PRENDERHAL_INTERFACE pRenderHal, PMOS_COMMAND_BUFFER pCmdBuffer) { PRENDERHAL_STATE_HEAP pStateHeap; MOS_STATUS eStatus = MOS_STATUS_SUCCESS; MHW_PIPE_CONTROL_PARAMS PipeCtl; //------------------------------------- MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap); //------------------------------------- pStateHeap = pRenderHal->pStateHeap; // Send PIPE_CONTROL Token // CMD_MI_FLUSH is disabled by default on GT, use PIPE_CONTROL // Requires a token and the actual pipe control command // Flush write caches PipeCtl = g_cRenderHal_InitPipeControlParams; PipeCtl.presDest = &pStateHeap->GshOsResource; PipeCtl.dwPostSyncOp = MHW_FLUSH_NOWRITE; PipeCtl.dwFlushMode = MHW_FLUSH_WRITE_CACHE; MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->AddMiPipeControl(pRenderHal, pCmdBuffer, &PipeCtl)); // Invalidate read-only caches and perform a post sync write PipeCtl = g_cRenderHal_InitPipeControlParams; PipeCtl.presDest = &pStateHeap->GshOsResource; PipeCtl.dwResourceOffset = pStateHeap->dwOffsetSync; PipeCtl.dwPostSyncOp = MHW_FLUSH_WRITE_IMMEDIATE_DATA; PipeCtl.dwFlushMode = MHW_FLUSH_READ_CACHE; PipeCtl.dwDataDW1 = pStateHeap->dwNextTag; MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->AddMiPipeControl(pRenderHal, pCmdBuffer, &PipeCtl)); return eStatus; } MOS_STATUS RenderHal_SendSyncTagIndex( PRENDERHAL_INTERFACE pRenderHal, PMOS_COMMAND_BUFFER pCmdBuffer, int32_t iIndex) { PRENDERHAL_STATE_HEAP pStateHeap; MOS_STATUS eStatus = MOS_STATUS_SUCCESS; MHW_PIPE_CONTROL_PARAMS PipeCtl; //------------------------------------- MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap); //------------------------------------- pStateHeap = pRenderHal->pStateHeap; // Invalidate read-only caches and perform a post sync write PipeCtl = g_cRenderHal_InitPipeControlParams; PipeCtl.presDest = &pStateHeap->GshOsResource; PipeCtl.dwResourceOffset = pStateHeap->dwOffsetSync + iIndex * 8; PipeCtl.dwPostSyncOp = MHW_FLUSH_WRITE_IMMEDIATE_DATA; PipeCtl.dwFlushMode = MHW_FLUSH_READ_CACHE; PipeCtl.dwDataDW1 = pStateHeap->dwNextTag; MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->AddMiPipeControl(pRenderHal, pCmdBuffer, &PipeCtl)); return eStatus; } //! //! \brief Initialize //! \details Initialize HW states //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to RenderHal Interface Structure //! \param PCRENDERHAL_SETTINGS pSettings //! [in] Pointer to Settings //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if succeeded //! others if failed to allocate/initialize HW commands //! MOS_STATUS RenderHal_Initialize( PRENDERHAL_INTERFACE pRenderHal, PRENDERHAL_SETTINGS pSettings) { MOS_STATUS eStatus = MOS_STATUS_SUCCESS; PMOS_INTERFACE pOsInterface; MHW_STATE_BASE_ADDR_PARAMS *pStateBaseParams; MOS_ALLOC_GFXRES_PARAMS AllocParams; //------------------------------------------------ MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pRenderHalPltInterface); //------------------------------------------------ pOsInterface = pRenderHal->pOsInterface; // Apply settings if (pSettings) { pRenderHal->StateHeapSettings.iMediaStateHeaps = pSettings->iMediaStates; } // Apply SSH settings for the current platform pRenderHal->StateHeapSettings.iSurfaceStateHeaps = pRenderHal->StateHeapSettings.iMediaStateHeaps; if (pOsInterface->CurrentGpuContextOrdinal == MOS_GPU_CONTEXT_RENDER || pOsInterface->CurrentGpuContextOrdinal == MOS_GPU_CONTEXT_COMPUTE) { if ((pRenderHal->pOsInterface->osStreamState == nullptr) || (pRenderHal->pOsInterface->osStreamState && (pRenderHal->pOsInterface->osStreamState->component != COMPONENT_Encode && pRenderHal->pOsInterface->osStreamState->component != COMPONENT_Decode))) { // Initialize MHW interfaces // Allocate and initialize state heaps (GSH, SSH, ISH) MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pfnAllocateStateHeaps(pRenderHal, &pRenderHal->StateHeapSettings)); } } // If ASM debug is enabled, allocate debug resource MHW_RENDERHAL_CHK_STATUS_RETURN(RenderHal_AllocateDebugSurface(pRenderHal)); // Allocate Predication buffer MOS_ZeroMemory(&AllocParams, sizeof(AllocParams)); AllocParams.Type = MOS_GFXRES_BUFFER; AllocParams.TileType = MOS_TILE_LINEAR; AllocParams.Format = Format_Buffer; AllocParams.dwBytes = MHW_PAGE_SIZE; AllocParams.pBufName = "PredicationBuffer"; MHW_RENDERHAL_CHK_STATUS_RETURN(pOsInterface->pfnAllocateResource( pOsInterface, &AllocParams, &pRenderHal->PredicationBuffer)); // Setup State Base Address command pStateBaseParams = &pRenderHal->StateBaseAddressParams; if (pRenderHal->pStateHeap) { pStateBaseParams->presGeneralState = &pRenderHal->pStateHeap->GshOsResource; pStateBaseParams->dwGeneralStateSize = pRenderHal->pStateHeap->dwSizeGSH; pStateBaseParams->presDynamicState = &pRenderHal->pStateHeap->GshOsResource; pStateBaseParams->dwDynamicStateSize = pRenderHal->pStateHeap->dwSizeGSH; pStateBaseParams->bDynamicStateRenderTarget = false; pStateBaseParams->presIndirectObjectBuffer = &pRenderHal->pStateHeap->GshOsResource; pStateBaseParams->dwIndirectObjectBufferSize = pRenderHal->pStateHeap->dwSizeGSH; pStateBaseParams->presInstructionBuffer = &pRenderHal->pStateHeap->IshOsResource; pStateBaseParams->dwInstructionBufferSize = pRenderHal->pStateHeap->dwSizeISH; } MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->CreatePerfProfiler(pRenderHal)); new(&pRenderHal->trackerProducer) FrameTrackerProducer(); return eStatus; } //! //! \brief Send Rcs Status Tag //! \details Adds pipe control command in Command Buffer //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to RenderHal Interface Structure //! \param PMOS_COMMAND_BUFFER pCmdBuffer //! [in] Pointer to Command Buffer //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if succeeded //! MOS_STATUS_UNKNOWN if failed to allocate/initialize HW commands //! MOS_STATUS RenderHal_SendRcsStatusTag( PRENDERHAL_INTERFACE pRenderHal, PMOS_COMMAND_BUFFER pCmdBuffer) { MOS_STATUS eStatus = MOS_STATUS_SUCCESS; PMOS_INTERFACE pOsInterface; MHW_PIPE_CONTROL_PARAMS PipeCtl; PMOS_RESOURCE osResource = nullptr; //------------------------------------ MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface); MHW_RENDERHAL_CHK_NULL_RETURN(pCmdBuffer); //------------------------------------ pOsInterface = pRenderHal->pOsInterface; // Get the Os Resource MHW_RENDERHAL_CHK_STATUS_RETURN(pOsInterface->pfnGetGpuStatusBufferResource(pOsInterface, osResource)); MHW_RENDERHAL_CHK_NULL_RETURN(osResource); // Register the buffer MHW_RENDERHAL_CHK_STATUS_RETURN(pOsInterface->pfnRegisterResource(pOsInterface, osResource, true, true)); // Issue pipe control to write GPU Status Tag PipeCtl = g_cRenderHal_InitPipeControlParams; PipeCtl.presDest = osResource; PipeCtl.dwResourceOffset = pOsInterface->pfnGetGpuStatusTagOffset(pOsInterface, pOsInterface->CurrentGpuContextOrdinal); //MOS_GPU_CONTEXT_RENDER or MOS_GPU_CONTEXT_RENDER3 PipeCtl.dwDataDW1 = pOsInterface->pfnGetGpuStatusTag(pOsInterface, pOsInterface->CurrentGpuContextOrdinal); PipeCtl.dwPostSyncOp = MHW_FLUSH_WRITE_IMMEDIATE_DATA; PipeCtl.dwFlushMode = MHW_FLUSH_NONE; MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->AddMiPipeControl(pRenderHal, pCmdBuffer, &PipeCtl)); // Increment GPU Status Tag pOsInterface->pfnIncrementGpuStatusTag(pOsInterface, pOsInterface->CurrentGpuContextOrdinal); return eStatus; } //! //! \brief Send CSC Coefficient surface //! \details Adds pipe control command in Command Buffer //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to RenderHal Interface Structure //! \param PMOS_COMMAND_BUFFER pCmdBuffer //! [in] Pointer to Command Buffer //! \param PMOS_RESOURCE presCscCoeff //! [in] Pointer to CSC Coefficient Surface //! \param Kdll_CacheEntry *pKernelEntry //! [in] Pointer to Kernel Entry //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if succeeded //! MOS_STATUS_UNKNOWN if failed to allocate/initialize HW commands //! MOS_STATUS RenderHal_SendCscCoeffSurface( PRENDERHAL_INTERFACE pRenderHal, PMOS_COMMAND_BUFFER pCmdBuffer, PMOS_RESOURCE presCscCoeff, Kdll_CacheEntry *pKernelEntry) { MOS_STATUS eStatus = MOS_STATUS_SUCCESS; PMOS_INTERFACE pOsInterface; MHW_PIPE_CONTROL_PARAMS PipeCtl; MOS_SURFACE Surface; uint64_t *pTempCoeff; uint32_t dwLow; uint32_t dwHigh; uint32_t dwOffset; uint32_t dwCount; uint8_t uiPatchMatrixID; //------------------------------------ MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface); MHW_RENDERHAL_CHK_NULL_RETURN(pCmdBuffer); MHW_RENDERHAL_CHK_NULL_RETURN(presCscCoeff); MHW_RENDERHAL_CHK_NULL_RETURN(pKernelEntry); MHW_RENDERHAL_CHK_NULL_RETURN(pKernelEntry->pCscParams); //------------------------------------ pOsInterface = pRenderHal->pOsInterface; dwOffset = 0; static_assert( (sizeof(pKernelEntry->pCscParams->Matrix[0].Coeff) % sizeof(uint64_t)) == 0, "Coeff array size must be multiple of 8"); dwCount = sizeof(pKernelEntry->pCscParams->Matrix[0].Coeff) / (sizeof(uint64_t)); MOS_ZeroMemory(&Surface, sizeof(Surface)); // Register the buffer MHW_RENDERHAL_CHK_STATUS_RETURN(pOsInterface->pfnRegisterResource(pOsInterface, presCscCoeff, true, true)); MHW_RENDERHAL_CHK_STATUS_RETURN(pOsInterface->pfnGetResourceInfo(pOsInterface, presCscCoeff, &Surface)); PipeCtl = g_cRenderHal_InitPipeControlParams; PipeCtl.presDest = presCscCoeff; PipeCtl.dwPostSyncOp = MHW_FLUSH_WRITE_IMMEDIATE_DATA; PipeCtl.dwFlushMode = MHW_FLUSH_READ_CACHE; for (uint32_t j = 0; j < pKernelEntry->pCscParams->PatchMatrixNum; j++) { uiPatchMatrixID = pKernelEntry->pCscParams->PatchMatrixID[j]; pTempCoeff = (uint64_t *)pKernelEntry->pCscParams->Matrix[uiPatchMatrixID].Coeff; // Issue pipe control to write CSC Coefficient Surface for (uint16_t i = 0; i < dwCount; i++, pTempCoeff++) { dwLow = (uint32_t)((*pTempCoeff) & 0xFFFFFFFF); dwHigh = (uint32_t)(((*pTempCoeff) >> 32) & 0xFFFFFFFF); PipeCtl.dwResourceOffset = dwOffset + sizeof(uint64_t) * i; PipeCtl.dwDataDW1 = dwLow; PipeCtl.dwDataDW2 = dwHigh; MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->AddMiPipeControl(pRenderHal, pCmdBuffer, &PipeCtl)); } dwOffset += Surface.dwPitch; } return eStatus; } MOS_STATUS RenderHal_SendStateBaseAddress( PRENDERHAL_INTERFACE pRenderHal, PMOS_COMMAND_BUFFER pCmdBuffer) { MOS_STATUS eStatus; MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(pCmdBuffer); eStatus = pRenderHal->pRenderHalPltInterface->SendStateBaseAddress(pRenderHal, pCmdBuffer); return eStatus; } //! //! \brief Send Media States //! \details Send Media States //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to Hardware Interface Structure //! \param PMOS_COMMAND_BUFFER pCmdBuffer //! [in] Pointer to Command Buffer //! \param PRENDERHAL_GPGPU_WALKER_PARAMS pGpGpuWalkerParams //! [in] Pointer to GPGPU walker parameters //! \return MOS_STATUS //! MOS_STATUS RenderHal_SendMediaStates( PRENDERHAL_INTERFACE pRenderHal, PMOS_COMMAND_BUFFER pCmdBuffer, PMHW_WALKER_PARAMS pWalkerParams, PMHW_GPGPU_WALKER_PARAMS pGpGpuWalkerParams) { PMOS_INTERFACE pOsInterface = nullptr; PRENDERHAL_STATE_HEAP pStateHeap = nullptr; MOS_STATUS eStatus = MOS_STATUS_SUCCESS; MHW_VFE_PARAMS *pVfeStateParams = nullptr; MOS_CONTEXT *pOsContext = nullptr; MHW_MI_LOAD_REGISTER_IMM_PARAMS loadRegisterImmParams = {}; PMHW_MI_MMIOREGISTERS pMmioRegisters = nullptr; MOS_OCA_BUFFER_HANDLE hOcaBuf = 0; //--------------------------------------- MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pRenderHalPltInterface); MHW_RENDERHAL_ASSERT(pRenderHal->pStateHeap->bGshLocked); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pRenderHalPltInterface->GetMmioRegisters(pRenderHal)); //--------------------------------------- pOsInterface = pRenderHal->pOsInterface; pStateHeap = pRenderHal->pStateHeap; pOsContext = pOsInterface->pOsContext; pMmioRegisters = pRenderHal->pRenderHalPltInterface->GetMmioRegisters(pRenderHal); // This need not be secure, since PPGTT will be used here. But moving this after // L3 cache configuration will delay UMD from fetching another media state. // Send Sync Tag MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pfnSendSyncTag(pRenderHal, pCmdBuffer)); // Setup L3$ Config, LRI commands used here & hence must be launched from a secure bb pRenderHal->L3CacheSettings.bEnableSLM = (pGpGpuWalkerParams && pGpGpuWalkerParams->SLMSize > 0); MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pfnEnableL3Caching(pRenderHal, &pRenderHal->L3CacheSettings)); // Send L3 Cache Configuration MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->SetL3Cache(pRenderHal, pCmdBuffer)); // if forceDisablePreemption is true, preemption will be disabled by NeedsMidBatchPreEmptionSupport in command buffer header. // skip preemption control bit configure as it won't take effect. if (!pRenderHal->forceDisablePreemption) { MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->EnablePreemption(pRenderHal, pCmdBuffer)); } // Send Debug Control, LRI commands used here & hence must be launched from a secure bb MHW_RENDERHAL_CHK_STATUS_RETURN(RenderHal_AddDebugControl(pRenderHal, pCmdBuffer)); // Send Pipeline Select command MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->AddPipelineSelectCmd(pRenderHal, pCmdBuffer, (pGpGpuWalkerParams) ? true : false)); // The binding table for surface states is at end of command buffer. No need to add it to indirect state heap. HalOcaInterfaceNext::OnIndirectState(*pCmdBuffer, (MOS_CONTEXT_HANDLE)pOsContext, pRenderHal->StateBaseAddressParams.presInstructionBuffer, pStateHeap->CurIDEntryParams.dwKernelOffset, false, pStateHeap->iKernelUsedForDump); // Send State Base Address command MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pfnSendStateBaseAddress(pRenderHal, pCmdBuffer)); if (pRenderHal->bComputeContextInUse) { pRenderHal->pRenderHalPltInterface->SendTo3DStateBindingTablePoolAlloc(pRenderHal, pCmdBuffer); } // Send Surface States MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pfnSendSurfaces(pRenderHal, pCmdBuffer)); // Send SIP State if ASM debug enabled if (pRenderHal->bIsaAsmDebugEnable) { MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->AddSipStateCmd(pRenderHal, pCmdBuffer)); } pVfeStateParams = pRenderHal->pRenderHalPltInterface->GetVfeStateParameters(); if (!pRenderHal->bComputeContextInUse) { // set VFE State MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->AddMediaVfeCmd(pRenderHal, pCmdBuffer, pVfeStateParams)); } else { // set CFE State MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->AddCfeStateCmd(pRenderHal, pCmdBuffer, pVfeStateParams)); } // Send CURBE Load if (!pRenderHal->bComputeContextInUse) { MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pfnSendCurbeLoad(pRenderHal, pCmdBuffer)); } // Send Interface Descriptor Load if (!pRenderHal->bComputeContextInUse) { MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pfnSendMediaIdLoad(pRenderHal, pCmdBuffer)); } // Send Chroma Keys MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pfnSendChromaKey(pRenderHal, pCmdBuffer)); // Send Palettes in use MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pfnSendPalette(pRenderHal, pCmdBuffer)); pRenderHal->pRenderHalPltInterface->OnDispatch(pRenderHal, pCmdBuffer, pOsInterface, pMmioRegisters); // Send Media object walker if(pWalkerParams) { MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->AddMediaObjectWalkerCmd( pRenderHal, pCmdBuffer, pWalkerParams)); } else if (pGpGpuWalkerParams && (!pRenderHal->bComputeContextInUse)) { MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->AddGpGpuWalkerStateCmd( pRenderHal, pCmdBuffer, pGpGpuWalkerParams)); } else if (pGpGpuWalkerParams && pRenderHal->bComputeContextInUse) { MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->SendComputeWalker( pRenderHal, pCmdBuffer, pGpGpuWalkerParams)); } return eStatus; } MOS_STATUS RenderHal_AssignBindlessSurfaceStates( PRENDERHAL_INTERFACE pRenderHal) { PRENDERHAL_STATE_HEAP pStateHeap = nullptr; MOS_STATUS eStatus = MOS_STATUS_UNKNOWN; //---------------------------------------- MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap->surfaceStateMgr); pStateHeap = pRenderHal->pStateHeap; if (pStateHeap->surfaceStateMgr->m_usedStates.size() >0) { pStateHeap->surfaceStateMgr->m_usedStates.clear(); } eStatus = MOS_STATUS_SUCCESS; return eStatus; } MOS_STATUS RenderHal_SendSurfaces_Bindelss( PRENDERHAL_INTERFACE pRenderHal, bool bNeedNullPatch) { PRENDERHAL_STATE_HEAP pStateHeap = nullptr; MOS_STATUS eStatus = MOS_STATUS_SUCCESS; MHW_SURFACE_STATE_SEND_PARAMS SendSurfaceParams; PMOS_INTERFACE pOsInterface; //---------------------------------------- MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap->surfaceStateMgr); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap->surfaceStateMgr->m_surfStateHeap); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface); pStateHeap = pRenderHal->pStateHeap; pOsInterface = pRenderHal->pOsInterface; if (pStateHeap->surfaceStateMgr->m_usedStates.size() == 0) { MHW_RENDERHAL_NORMALMESSAGE("m_usedStates is null!"); return eStatus; } for (uint32_t i = 0; i < pStateHeap->surfaceStateMgr->m_usedStates.size(); i++) { uint32_t index = pStateHeap->surfaceStateMgr->m_usedStates[i]; // Null Patch is only enabled for Media Patchless SendSurfaceParams.bNeedNullPatch = bNeedNullPatch; SendSurfaceParams.pIndirectStateBase = pStateHeap->surfaceStateMgr->m_surfStateHeap->pLockedOsResourceMem; SendSurfaceParams.iIndirectStateBase = 0; // No need SendSurfaceParams.pSurfaceToken = (uint8_t *)&pStateHeap->pSurfaceEntry[index].SurfaceToken; SendSurfaceParams.pSurfaceStateSource = (uint8_t *)pStateHeap->pSurfaceEntry[index].pSurfaceState; SendSurfaceParams.iSurfaceStateOffset = index * pStateHeap->surfaceStateMgr->m_surfStateHeap->uiInstanceSize; pRenderHal->pfnSendSurfaceStateEntry(pRenderHal, nullptr, &SendSurfaceParams); } return eStatus; } //! //! \brief Assign binding Table //! \details Assigns binding Table //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to Hardware Interface Structure //! \param int32_t *piBindingTable //! [out] Pointer to Binding Table //! \return MOS_STATUS //! MOS_STATUS RenderHal_AssignBindingTable( PRENDERHAL_INTERFACE pRenderHal, int32_t *piBindingTable) { PRENDERHAL_STATE_HEAP pStateHeap; uint32_t dwOffset; MOS_STATUS eStatus; //---------------------------------------- MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(piBindingTable); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pMhwStateHeap); //---------------------------------------- *piBindingTable = -1; pStateHeap = pRenderHal->pStateHeap; eStatus = MOS_STATUS_UNKNOWN; if (pRenderHal->isBindlessHeapInUse) { MHW_RENDERHAL_NORMALMESSAGE("BindlessHeap does not need binding table!"); return MOS_STATUS_SUCCESS; } if (pStateHeap->iCurrentBindingTable >= pRenderHal->StateHeapSettings.iBindingTables) { MHW_RENDERHAL_ASSERTMESSAGE("Unable to allocate Binding Table. Exceeds Maximum."); return eStatus; } *piBindingTable = pStateHeap->iCurrentBindingTable; // Get Offset to Current Binding Table dwOffset = *piBindingTable * pStateHeap->iBindingTableSize; // Moves the pointer to a Particular Binding Table // Reset Binding Table MHW_RENDERHAL_CHK_NULL_RETURN(pStateHeap->pSshBuffer); MOS_ZeroMemory(pStateHeap->pSshBuffer + dwOffset, pStateHeap->iBindingTableSize); // Setup Debug surface state if needed MHW_RENDERHAL_CHK_STATUS_RETURN(RenderHal_SetupDebugSurfaceState(pRenderHal)); // Increment the Current Binding Table ++pStateHeap->iCurrentBindingTable; eStatus = MOS_STATUS_SUCCESS; return eStatus; } //! //! \brief Setup Buffer Surface State //! \details Setup Buffer Surface States //! For buffer surfaces, the number of entries in the buffer //! ranges from 1 to 2^27. After subtracting one from the number //! of entries, software must place the fields of the resulting //! 27-bit value into the Height, Width, and Depth fields as //! indicated, right-justified in each field. //! Unused upper bits must be set to zero. //! //! Width: contains bits [6:0] of the number of entries in the //! buffer 1 [0,127] --> 7 Bits //! Height: contains bits [20:7] of the number of entries in the //! buffer 1 [0,16383] --> 14 Bits //! Depth: contains bits [26:21] of the number of entries in the //! buffer 1 [0,63] --> 6 Bits //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to RenderHal Interface //! \param PMOS_COMMAND_BUFFER pCmdBuffer //! [in] Pointer to MOS Command Buffer //! \param PRENDERHAL_SURFACE pRenderHalSurface //! [in] Pointer to Render Hal Surface //! \param PRENDERHAL_SURFACE_STATE_PARAMS pParams //! [in] Pointer to Surface state parameters //! \param PRENDERHAL_SURFACE_STATE_ENTRY * ppSurfaceEntry //! [out] Pointer to Surface entry //! \return MOS_STATUS //! MOS_STATUS RenderHal_SetupBufferSurfaceState( PRENDERHAL_INTERFACE pRenderHal, PRENDERHAL_SURFACE pRenderHalSurface, PRENDERHAL_SURFACE_STATE_PARAMS pParams, PRENDERHAL_SURFACE_STATE_ENTRY *ppSurfaceEntry) { MOS_STATUS eStatus; PRENDERHAL_SURFACE_STATE_ENTRY pSurfaceEntry; MHW_RCS_SURFACE_PARAMS RcsSurfaceParams; //-------------------------------------- MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHalSurface); MHW_RENDERHAL_CHK_NULL_RETURN(pParams); MHW_RENDERHAL_CHK_NULL_RETURN(ppSurfaceEntry); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pHwSizes); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pMhwStateHeap); MHW_RENDERHAL_ASSERT(pRenderHalSurface->OsSurface.dwWidth > 0); //-------------------------------------- eStatus = MOS_STATUS_SUCCESS; // Force surface type to Default (non-AVS) pParams->Type = pRenderHal->SurfaceTypeDefault; // Assign Surface State // Assign a New Surface State Entry MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pfnAssignSurfaceState( pRenderHal, pRenderHal->SurfaceTypeDefault, ppSurfaceEntry)); pSurfaceEntry = *ppSurfaceEntry; MHW_RENDERHAL_CHK_NULL_RETURN(pSurfaceEntry); // Update surface state offset in SSH *pSurfaceEntry->pSurface = pRenderHalSurface->OsSurface; if (pRenderHal->isBindlessHeapInUse) { pSurfaceEntry->dwSurfStateOffset = pSurfaceEntry->iSurfStateID * pRenderHal->pHwSizes->dwSizeSurfaceState; // No binding table } else { pSurfaceEntry->dwSurfStateOffset = pRenderHal->pStateHeap->iSurfaceStateOffset + pSurfaceEntry->iSurfStateID * pRenderHal->pHwSizes->dwSizeSurfaceState; } // Setup MHW parameters MOS_ZeroMemory(&RcsSurfaceParams, sizeof(MHW_RCS_SURFACE_PARAMS)); RcsSurfaceParams.psSurface = &pRenderHalSurface->OsSurface; RcsSurfaceParams.dwOffsetInSSH = pSurfaceEntry->dwSurfStateOffset; RcsSurfaceParams.dwCacheabilityControl = pRenderHal->pfnGetSurfaceMemoryObjectControl(pRenderHal, pParams); if (pParams->surfaceType) { MOS_CACHE_ELEMENT element(MOS_CODEC_RESOURCE_USAGE_BEGIN_CODEC, MOS_CODEC_RESOURCE_USAGE_BEGIN_CODEC); bool res = pRenderHal->pOsInterface->pfnGetCacheSetting(pParams->Component, pParams->surfaceType, pParams->isOutput, RENDER_ENGINE, element, false); if (res) { RcsSurfaceParams.dwCacheabilityControl = (pRenderHal->pOsInterface->pfnCachePolicyGetMemoryObject( element.mocsUsageType, pRenderHal->pOsInterface->pfnGetGmmClientContext(pRenderHal->pOsInterface))) .DwordValue; } else { MHW_RENDERHAL_ASSERTMESSAGE("Not found cache settings!"); } } else { MHW_RENDERHAL_NORMALMESSAGE("Not implemented yet! Will use MemObjCtl value %d", pParams->MemObjCtl); } RcsSurfaceParams.bIsWritable = pParams->isOutput; RcsSurfaceParams.bRenderTarget = pParams->isOutput; // Call MHW to setup the Surface State Heap entry for Buffer MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pfnSetSurfaceStateBuffer(pRenderHal, &RcsSurfaceParams, pSurfaceEntry->pSurfaceState)); // Setup OS Specific States MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pfnSetupSurfaceStatesOs(pRenderHal, pParams, pSurfaceEntry)); return eStatus; } //! //! \brief Set surface state buffer //! \param [in] pRenderHal //! pointer to render hal //! [in] pParams //! pointer to surface parameters //! \param void *pSurfaceState //! [in/out] Surface State Pointer //! MOS_STATUS RenderHal_SetSurfaceStateBuffer( PRENDERHAL_INTERFACE pRenderHal, PMHW_RCS_SURFACE_PARAMS pParams, void *pSurfaceState) { MOS_STATUS eStatus = MOS_STATUS_SUCCESS; MHW_MI_CHK_NULL(pParams); MHW_MI_CHK_NULL(pParams->psSurface); MHW_MI_CHK_NULL(pSurfaceState); MHW_SURFACE_STATE_PARAMS Params; MOS_ZeroMemory(&Params, sizeof(Params)); PMOS_SURFACE pSurface = pParams->psSurface; uint32_t dwBufferSize = pSurface->dwWidth - 1; Params.SurfaceType3D = MOS_GFXRES_SCRATCH == pSurface->Type? GFX3DSTATE_SURFACETYPE_SCRATCH : GFX3DSTATE_SURFACETYPE_BUFFER; if (MOS_GFXRES_SCRATCH == pSurface->Type) { Params.dwPitch = 1023; uint32_t entry_count = pSurface->dwWidth/(Params.dwPitch + 1); Params.dwWidth = (entry_count - 1) & MOS_MASKBITS32(0, 6); Params.dwHeight = (((entry_count - 1) & MOS_MASKBITS32(7, 20)) >> 7); Params.dwDepth = (((entry_count - 1) & 0xFFE00000) >> 21); Params.dwFormat = MHW_GFX3DSTATE_SURFACEFORMAT_RAW; } else { // Width contains bits [ 6:0] of the number of entries in the buffer Params.dwWidth = (uint8_t)(dwBufferSize & MOS_MASKBITS32(0, 6)); // Height contains bits [20:7] of the number of entries in the buffer Params.dwHeight = (uint16_t)((dwBufferSize & MOS_MASKBITS32(7, 20)) >> 7); // For SURFTYPE_BUFFER, pitch is defaulted to 0. Resetting is unnecessary. uint32_t depthMaskBuffer = pRenderHal->pRenderHalPltInterface ->GetDepthBitMaskForBuffer(); uint32_t depthMaskRawBuffer = pRenderHal->pRenderHalPltInterface ->GetDepthBitMaskForRawBuffer(); switch (pSurface->Format) { // We consider MOS's Format_Buffer as MHW_GFX3DSTATE_SURFACEFORMAT_L8_UNORM // format for most of cases case Format_Buffer: Params.dwFormat = MHW_GFX3DSTATE_SURFACEFORMAT_L8_UNORM; Params.dwDepth = (uint16_t)((dwBufferSize & depthMaskBuffer) >> 21); break; case Format_RAW: Params.dwFormat = MHW_GFX3DSTATE_SURFACEFORMAT_RAW; Params.dwDepth = (uint16_t)((dwBufferSize & depthMaskRawBuffer) >> 21); break; case Format_L8: Params.dwFormat = MHW_GFX3DSTATE_SURFACEFORMAT_L8_UNORM; Params.dwDepth = (uint16_t)((dwBufferSize & depthMaskBuffer) >> 21); break; default: MHW_ASSERTMESSAGE("Invalid buffer Resource format"); break; } } Params.pSurfaceState = (uint8_t*)pSurfaceState; Params.dwCacheabilityControl = pParams->dwCacheabilityControl; // Default tile mode of surface state buffer is linear Params.bGMMTileEnabled = true; // Setup Surface State Entry via MHW state heap interface MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pMhwStateHeap->SetSurfaceStateEntry(&Params)); return eStatus; } //! //! \brief Setup Interface Descriptor //! \details Set interface descriptor //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to HW interface //! \param PRENDERHAL_MEDIA_STATE pMediaState //! [in] Pointer to media state //! \param PRENDERHAL_KRN_ALLOCATION pKernelAllocation //! [in] Pointer to kernel allocation //! \param PRENDERHAL_INTERFACE_DESCRIPTOR_PARAMS pInterfaceDescriptorParams //! [in] Pointer to interface descriptor parameters //! \param PMHW_GPGPU_WALKER_PARAMS pGpGpuWalkerParams //! [in] Pointer to gpgpu walker parameters //! \return MOS_STATUS //! MOS_STATUS RenderHal_SetupInterfaceDescriptor( PRENDERHAL_INTERFACE pRenderHal, PRENDERHAL_MEDIA_STATE pMediaState, PRENDERHAL_KRN_ALLOCATION pKernelAllocation, PRENDERHAL_INTERFACE_DESCRIPTOR_PARAMS pInterfaceDescriptorParams) { MOS_STATUS eStatus = MOS_STATUS_SUCCESS; PMHW_ID_ENTRY_PARAMS pParams = nullptr; PRENDERHAL_STATE_HEAP pStateHeap = nullptr; //----------------------------------------- MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pMhwStateHeap); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap); MHW_RENDERHAL_CHK_NULL_RETURN(pMediaState); MHW_RENDERHAL_CHK_NULL_RETURN(pKernelAllocation); MHW_RENDERHAL_CHK_NULL_RETURN(pInterfaceDescriptorParams); //----------------------------------------- // Get states, params pStateHeap = pRenderHal->pStateHeap; pParams = &pStateHeap->CurIDEntryParams; pParams->dwMediaIdOffset = pMediaState->dwOffset + pStateHeap->dwOffsetMediaID; pParams->iMediaId = pInterfaceDescriptorParams->iMediaID; pParams->dwKernelOffset = pKernelAllocation->dwOffset; pParams->dwSamplerOffset = pMediaState->dwOffset + pStateHeap->dwOffsetSampler + pInterfaceDescriptorParams->iMediaID * pStateHeap->dwSizeSamplers; pParams->dwSamplerCount = pKernelAllocation->Params.Sampler_Count; pParams->dwBindingTableOffset = pInterfaceDescriptorParams->iBindingTableID * pStateHeap->iBindingTableSize; pParams->iCurbeOffset = pInterfaceDescriptorParams->iCurbeOffset; pParams->iCurbeLength = pInterfaceDescriptorParams->iCurbeLength; pParams->bBarrierEnable = pInterfaceDescriptorParams->blBarrierEnable; pParams->bGlobalBarrierEnable = pInterfaceDescriptorParams->blGlobalBarrierEnable; //It's only applied for BDW+ pParams->dwNumberofThreadsInGPGPUGroup = pInterfaceDescriptorParams->iNumberThreadsInGroup; pParams->dwSharedLocalMemorySize = pRenderHal->pfnEncodeSLMSize(pRenderHal, pInterfaceDescriptorParams->iSLMSize); pParams->iCrsThdConDataRdLn = pInterfaceDescriptorParams->iCrsThrdConstDataLn; pParams->pGeneralStateHeap = nullptr; MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pMhwStateHeap->SetInterfaceDescriptorEntry(pParams)); return eStatus; } //! //! \brief Get Media Walker Status //! \details Returns Media Walker Enabled / Disabled //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to RenderHal Interface //! \return bool //! bool RenderHal_GetMediaWalkerStatus( PRENDERHAL_INTERFACE pRenderHal) { //----------------------------------------- if (pRenderHal == nullptr) { MHW_RENDERHAL_ASSERTMESSAGE("Invalid renderhal."); return false; } //----------------------------------------- if (pRenderHal->MediaWalkerMode == MHW_WALKER_MODE_DISABLED) { return false; } return true; } //! //! \brief Get surface memory object control \ //! \details Returns surface memory object control //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to RenderHal Interface //! \param PRENDERHAL_SURFACE_STATE_PARAMS pParams //! [in] Pointer to surface state params //! \return uint32_t //! uint32_t RenderHal_GetSurfaceMemoryObjectControl( PRENDERHAL_INTERFACE pRenderHal, PRENDERHAL_SURFACE_STATE_PARAMS pParams) { MHW_RENDERHAL_UNUSED(pRenderHal); //----------------------------------------- if (pParams == nullptr) { MHW_RENDERHAL_ASSERTMESSAGE("nullptr pointer."); return 0; } //----------------------------------------- return pParams->MemObjCtl; } //! //! \brief Get the size of Scratch Space //! \details Get scratch space size based on max gen config and scratch space //! size per thread //! FFTID is used by HW to access scratch space; since FFTID generated //! is not continuous, need to allocate scratch space based on maximum gen config //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Hardware interface //! \param uint32_t iPerThreadScratchSpaceSize //! [in] Per thread scratch space size //! \return uint32_t //! uint32_t RenderHal_GetScratchSpaceSize( PRENDERHAL_INTERFACE pRenderHal, uint32_t iPerThreadScratchSpaceSize) { MEDIA_SYSTEM_INFO *pGtSystemInfo; //----------------------------------------- if (pRenderHal == nullptr) { MHW_RENDERHAL_ASSERTMESSAGE("Invalid renderhal."); return 0; } //----------------------------------------- pGtSystemInfo = pRenderHal->pOsInterface->pfnGetGtSystemInfo(pRenderHal->pOsInterface); uint32_t numHWThreadsPerEU = pGtSystemInfo->ThreadCount / pGtSystemInfo->EUCount; uint32_t dwNumberOfScratchSpaceEntries = pGtSystemInfo->MaxEuPerSubSlice * numHWThreadsPerEU * pGtSystemInfo->MaxSubSlicesSupported; uint32_t dwScratchSpaceSize = dwNumberOfScratchSpaceEntries * iPerThreadScratchSpaceSize; return dwScratchSpaceSize; } //! //! \brief Setup OS specific surface state parameters //! \details Setup Platform and Operating System Specific Surface State //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to Hardware Interface Structure //! \param PRENDERHAL_SURFACE_STATE_PARAMS pParams //! [in] Pointer to Surface Params //! \param PRENDERHAL_SURFACE_STATE_ENTRY pSurfaceEntry //! [in] Pointer to Surface State Entry //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if successful //! MOS_STATUS RenderHal_SetupSurfaceStatesOs( PRENDERHAL_INTERFACE pRenderHal, PRENDERHAL_SURFACE_STATE_PARAMS pParams, PRENDERHAL_SURFACE_STATE_ENTRY pSurfaceEntry) { PMOS_SURFACE pSurface; MOS_STATUS eStatus = MOS_STATUS_SUCCESS; MHW_SURFACE_TOKEN_PARAMS TokenParams; uint32_t additional_plane_offset = 0; uint32_t vertical_offset_in_surface_state = 0; //----------------------------------------- MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(pParams); MHW_RENDERHAL_CHK_NULL_RETURN(pSurfaceEntry); //----------------------------------------- pSurface = pSurfaceEntry->pSurface; // Surface, plane, offset TokenParams.pOsSurface = pSurface; TokenParams.YUVPlane = pSurfaceEntry->YUVPlane; switch (pSurfaceEntry->YUVPlane) { case MHW_U_PLANE: vertical_offset_in_surface_state = pSurface->UPlaneOffset.iYOffset; vertical_offset_in_surface_state &= 0x1C; // The offset value in surface state commands. additional_plane_offset = pSurface->UPlaneOffset.iYOffset - vertical_offset_in_surface_state; additional_plane_offset *= pSurface->dwPitch; TokenParams.dwSurfaceOffset = pSurface->UPlaneOffset.iSurfaceOffset + additional_plane_offset; break; case MHW_V_PLANE: vertical_offset_in_surface_state = pSurface->VPlaneOffset.iYOffset; vertical_offset_in_surface_state &= 0x1C; additional_plane_offset = pSurface->VPlaneOffset.iYOffset - vertical_offset_in_surface_state; additional_plane_offset *= pSurface->dwPitch; TokenParams.dwSurfaceOffset = pSurface->VPlaneOffset.iSurfaceOffset + additional_plane_offset; break; default: vertical_offset_in_surface_state = pSurface->YPlaneOffset.iYOffset; vertical_offset_in_surface_state &= 0x1C; additional_plane_offset = pSurface->YPlaneOffset.iYOffset - vertical_offset_in_surface_state; additional_plane_offset *= pSurface->dwPitch; TokenParams.dwSurfaceOffset = pSurface->dwOffset + additional_plane_offset; //force it to 0 for 1D buffer if (pParams->bBufferUse) { TokenParams.dwSurfaceOffset = 0; } break; } // Surface type TokenParams.bRenderTarget = pParams->isOutput; TokenParams.bSurfaceTypeAvs = pSurfaceEntry->bAVS; MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pfnSetSurfaceStateToken( pRenderHal, &TokenParams, &pSurfaceEntry->SurfaceToken)); return eStatus; } //! //! \brief Bind Surface State //! \details Binds Surface State //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to RenderHal Interface //! \param int32_t iBindingTableIndex //! [in] Binding Table Index //! \param int32_t iBindingTableEntry //! [out] Binding Table Entry //! \param PRENDERHAL_SURFACE_STATE_ENTRY pSurfaceEntry //! [in] Pointer to Surface State Entry //! \return MOS_STATUS //! MOS_STATUS RenderHal_BindSurfaceState( PRENDERHAL_INTERFACE pRenderHal, int32_t iBindingTableIndex, int32_t iBindingTableEntry, PRENDERHAL_SURFACE_STATE_ENTRY pSurfaceEntry) { PRENDERHAL_STATE_HEAP pStateHeap; PMHW_RENDER_STATE_SIZES pHwSizes; MHW_BINDING_TABLE_PARAMS Params; uint32_t dwOffset; MOS_STATUS eStatus = MOS_STATUS_SUCCESS; //-------------------------------------------- MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(pSurfaceEntry); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pHwSizes); MHW_RENDERHAL_ASSERT(iBindingTableIndex >= 0); MHW_RENDERHAL_ASSERT(iBindingTableEntry >= 0); if (iBindingTableEntry >= pRenderHal->StateHeapSettings.iSurfacesPerBT) { MHW_RENDERHAL_ASSERTMESSAGE("Unable to Bind Surface State. Exceeds Maximum. BTI %d. Maximum %d", iBindingTableEntry, pRenderHal->StateHeapSettings.iSurfacesPerBT); return MOS_STATUS_INVALID_PARAMETER; } //-------------------------------------------- pStateHeap = pRenderHal->pStateHeap; pHwSizes = pRenderHal->pHwSizes; // Get Offset to Current Binding Table dwOffset = (pStateHeap->iCurSshBufferIndex * pStateHeap->dwSshIntanceSize) + // Points to the Base of Current SSH Buffer Instance (pStateHeap->iBindingTableOffset) + // Moves the pointer to Base of Array of Binding Tables (iBindingTableIndex * pStateHeap->iBindingTableSize) + // Moves the pointer to a Particular Binding Table (iBindingTableEntry * pHwSizes->dwSizeBindingTableState); // Move the pointer to correct entry MHW_RENDERHAL_CHK_NULL_RETURN(pStateHeap->pSshBuffer); Params.pBindingTableEntry = pStateHeap->pSshBuffer + dwOffset; Params.dwSurfaceStateOffset = pSurfaceEntry->dwSurfStateOffset; Params.bSurfaceStateAvs = (pSurfaceEntry->Type == pRenderHal->SurfaceTypeAdvanced ) ? true : false; Params.iBindingTableEntry = iBindingTableEntry; // Set binding table entry in MHW MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pMhwStateHeap->SetBindingTableEntry(&Params)); return eStatus; } //! //! \brief Set Vfe State Params //! \details Sets VFE State parameters //! this functions must be called to setup //! parameters for Mhw Render->AddMediaVfeCmd() //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to Hardware Interface Structure //! \param uint32_t dwDebugCounterControl //! [in] Debug Counter Control //! \param uint32_t dwMaximumNumberofThreads //! [in] Maximum Number of Threads //! \param uint32_t dwCURBEAllocationSize //! [in] CURBE Allocation Size //! \param uint32_t dwURBEntryAllocationSize //! [in] URB Entry Allocation Size //! \param PRENDERHAL_SCOREBOARD_PARAMS pScoreboardParams //! [in] Pointer to Scoreboard Params //! \return MOS_STATUS //! MOS_STATUS RenderHal_SetVfeStateParams( PRENDERHAL_INTERFACE pRenderHal, uint32_t dwDebugCounterControl, uint32_t dwMaximumNumberofThreads, uint32_t dwCURBEAllocationSize, uint32_t dwURBEntryAllocationSize, PMHW_VFE_SCOREBOARD pScoreboardParams) { PMHW_VFE_PARAMS pVfeParams; PRENDERHAL_STATE_HEAP pStateHeap; PMHW_RENDER_ENGINE_CAPS pHwCaps; PRENDERHAL_STATE_HEAP_SETTINGS pSettings; uint32_t dwMaxURBSize; uint32_t dwMaxCURBEAllocationSize; uint32_t dwMaxURBEntryAllocationSize; uint32_t dwNumberofURBEntries; uint32_t dwMaxURBEntries; uint32_t dwMaxInterfaceDescriptorEntries; MOS_STATUS eStatus; uint32_t i; //--------------------------------------------- MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pWaTable); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pHwCaps); //--------------------------------------------- eStatus = MOS_STATUS_SUCCESS; pStateHeap = pRenderHal->pStateHeap; pHwCaps = pRenderHal->pHwCaps; pVfeParams = pRenderHal->pRenderHalPltInterface->GetVfeStateParameters(); MHW_RENDERHAL_CHK_NULL_RETURN(pVfeParams); pSettings = &(pRenderHal->StateHeapSettings); pVfeParams->pKernelState = nullptr; pVfeParams->eVfeSliceDisable = MHW_VFE_SLICE_ALL; //------------------------------------------------------------------------- // --Gen6 GT1-- // In this calculation, URBEntryAllocationSize and CURBEAllocationSize are // in 256-bit units: // (URBEntryAllocationSize * NumberofURBEntries + CURBEAllocationSize + // MaxInterfaceDescriptorEntries) <= 1024 // // --Gen6 GT2 + Gen7-- // In this calculation, URBEntryAllocationSize and CURBEAllocationSize are // in 256-bit units: // (URBEntryAllocationSize * NumberofURBEntries + CURBEAllocationSize + // MaxInterfaceDescriptorEntries) <= 2048 //------------------------------------------------------------------------- // get the Max for all the fields dwMaxURBSize = pHwCaps->dwMaxURBSize; dwMaxURBEntries = pHwCaps->dwMaxURBEntries; dwMaxURBEntryAllocationSize = pHwCaps->dwMaxURBEntryAllocationSize; dwMaxCURBEAllocationSize = pHwCaps->dwMaxCURBEAllocationSize; dwMaxInterfaceDescriptorEntries = pHwCaps->dwMaxInterfaceDescriptorEntries; // CURBEAllocationSize must be >= CurbeTotalDataLength in CURBE_LOAD. MHW_RENDERHAL_CHK_NULL_RETURN(pStateHeap->pCurMediaState); dwCURBEAllocationSize = MOS_MAX(dwCURBEAllocationSize, (uint32_t)pStateHeap->pCurMediaState->iCurbeOffset); // CURBEAllocationSize is in 256-bit (32-byte) units, so we round up to // 32. We do not force it to be greater than zero because a Kernel may not // be using any CURBE parameters. dwCURBEAllocationSize = MOS_ROUNDUP_SHIFT(dwCURBEAllocationSize, 5); // URBEntryAllocationSize is in 256-bit (32-byte) units, so we round up to // 32. We ensure that it is greater than zero, because we will use this in // division when we calculate dwNumberofURBEntries, so we need a value // that is greater than zero. // URBEntryAllocationSize sets the size of the Inline Data. All the Inline // Data will be placed in the URB which is a buffer that is managed by the // hardware. When the thread is dispatched, the data in the URB will be // copied to the GRF. dwURBEntryAllocationSize = MOS_ROUNDUP_SHIFT(dwURBEntryAllocationSize, 5); dwURBEntryAllocationSize = MOS_MAX(1, dwURBEntryAllocationSize); // NumberofURBEntries defines the depth of the dispatch queue. Up to this // many threads can be in the queue. It's related to performance. For hardware, // we use the size of the Inline Data to calculate the maximum number of entries // we can use. We cap it to 32 URB entries, and then ensure that it is greater // than zero. dwNumberofURBEntries = (dwMaxURBSize - dwCURBEAllocationSize - dwMaxInterfaceDescriptorEntries) / dwURBEntryAllocationSize; dwNumberofURBEntries = MOS_CLAMP_MIN_MAX(dwNumberofURBEntries, 1, 32); pVfeParams->dwDebugCounterControl = dwDebugCounterControl; pVfeParams->dwNumberofURBEntries = dwNumberofURBEntries; pVfeParams->dwMaximumNumberofThreads = (dwMaximumNumberofThreads == RENDERHAL_USE_MEDIA_THREADS_MAX) ? pHwCaps->dwMaxThreads : MOS_MIN(dwMaximumNumberofThreads, pHwCaps->dwMaxThreads); pVfeParams->dwCURBEAllocationSize = dwCURBEAllocationSize << 5; pVfeParams->dwURBEntryAllocationSize = dwURBEntryAllocationSize; MHW_RENDERHAL_ASSERT(dwNumberofURBEntries <= dwMaxURBEntries); MHW_RENDERHAL_ASSERT(dwCURBEAllocationSize <= dwMaxCURBEAllocationSize); MHW_RENDERHAL_ASSERT(dwURBEntryAllocationSize <= dwMaxURBEntryAllocationSize); MHW_RENDERHAL_ASSERT(dwNumberofURBEntries * dwURBEntryAllocationSize + dwCURBEAllocationSize + dwMaxInterfaceDescriptorEntries <= dwMaxURBSize); // Setup Scoreboard Parameters if (pScoreboardParams) { MHW_RENDERHAL_ASSERT(pScoreboardParams->ScoreboardMask < 8); pRenderHal->VfeScoreboard.ScoreboardEnable = true; pRenderHal->VfeScoreboard.ScoreboardMask = (1 << pScoreboardParams->ScoreboardMask) - 1; pRenderHal->VfeScoreboard.ScoreboardType = pScoreboardParams->ScoreboardType; for (i = 0; i < pScoreboardParams->ScoreboardMask; i++) { pRenderHal->VfeScoreboard.ScoreboardDelta[i].x = pScoreboardParams->ScoreboardDelta[i].x; pRenderHal->VfeScoreboard.ScoreboardDelta[i].y = pScoreboardParams->ScoreboardDelta[i].y; } } else { pRenderHal->VfeScoreboard.ScoreboardEnable = true; pRenderHal->VfeScoreboard.ScoreboardMask = 0x0; } // Setup VFE Scoreboard parameters pVfeParams->Scoreboard = pRenderHal->VfeScoreboard; // Setup Kernel Scratch Space if (pSettings->iPerThreadScratchSize > 0) { int32_t iSize; int32_t iRemain; int32_t iPerThreadScratchSize; MHW_RENDERHAL_ASSERT(pSettings->iPerThreadScratchSize == MOS_ALIGN_CEIL(pSettings->iPerThreadScratchSize, 1024)); iPerThreadScratchSize = pSettings->iPerThreadScratchSize >> 10; iRemain = iPerThreadScratchSize % 2; iPerThreadScratchSize = iPerThreadScratchSize / 2; iSize = 0; while (!iRemain && (iPerThreadScratchSize / 2)) { iSize++; iRemain = iPerThreadScratchSize % 2; iPerThreadScratchSize = iPerThreadScratchSize / 2; } MHW_RENDERHAL_ASSERT(!iRemain && iPerThreadScratchSize); MHW_RENDERHAL_ASSERT(iSize < 12); // Specifies the amount of scratch space allowed to be used by each // thread. The driver must allocate enough contiguous scratch space, // pointed to by the Scratch Space Pointer, to ensure that the Maximum // Number of Threads each get Per Thread Scratch Space size without // exceeding the driver-allocated scratch space. // Range = [0,11] indicating [1k bytes, 12k bytes] pVfeParams->dwPerThreadScratchSpace = (uint32_t) iSize; // Specifies the 1k-byte aligned address offset to scratch space for // use by the kernel. This pointer is relative to the // General State Base Address (1k aligned) // Format = GeneralStateOffset[31:10] pVfeParams->dwScratchSpaceBasePointer = pStateHeap->dwScratchSpaceBase; } else { pVfeParams->dwPerThreadScratchSpace = 0; pVfeParams->dwScratchSpaceBasePointer = 0; } return eStatus; } //! //! \brief Is two Planes NV12 Needed //! \details Judge whether 2 plane NV12 is needed based on the width/height //! and its rectangle for each boundary type //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] pointer to RenderHal Interface //! \param PRENDERHAL_SURFACE pRenderHalSurface //! [in] pointer to input Surface //! \param RENDERHAL_SS_BOUNDARY Boundary //! [in] How the adjustment needs to be done //! \return bool //! bool RenderHal_Is2PlaneNV12Needed( PRENDERHAL_INTERFACE pRenderHal, PRENDERHAL_SURFACE pRenderHalSurface, RENDERHAL_SS_BOUNDARY Boundary) { PMOS_SURFACE pSurface; uint16_t wWidthAlignUnit; uint16_t wHeightAlignUnit; uint32_t dwSurfaceHeight; uint32_t dwSurfaceWidth; uint32_t widthAlignUnit; uint32_t heightAlignUnit; bool bRet = false; //--------------------------------------------- if (pRenderHal == nullptr || pRenderHalSurface == nullptr) { MHW_RENDERHAL_ASSERTMESSAGE("nullptr pointer detected."); return bRet; } //--------------------------------------------- pRenderHal->pfnGetAlignUnit(&wWidthAlignUnit, &wHeightAlignUnit, pRenderHalSurface); pSurface = &pRenderHalSurface->OsSurface; switch (Boundary) { case RENDERHAL_SS_BOUNDARY_SRCRECT: dwSurfaceHeight = pSurface->dwHeight; dwSurfaceWidth = MOS_ALIGN_CEIL(MOS_MIN(pSurface->dwWidth, (uint32_t)pRenderHalSurface->rcSrc.right), wWidthAlignUnit); break; // align with max src rect case RENDERHAL_SS_BOUNDARY_MAXSRCRECT: dwSurfaceHeight = pSurface->dwHeight; dwSurfaceWidth = MOS_ALIGN_CEIL(MOS_MIN(pSurface->dwWidth, (uint32_t)pRenderHalSurface->rcMaxSrc.right), wWidthAlignUnit); break; default: dwSurfaceHeight = MOS_ALIGN_CEIL(pSurface->dwHeight, wHeightAlignUnit); dwSurfaceWidth = MOS_ALIGN_CEIL(pSurface->dwWidth, wWidthAlignUnit); break; } // NV12 format needs the width and height to be a multiple for both 3D sampler and 8x8 sampler. // For AVS sampler, no limitation for 4 alignment. pRenderHal->pRenderHalPltInterface->GetSamplerResolutionAlignUnit(pRenderHal, RENDERHAL_SCALING_AVS == pRenderHalSurface->ScalingMode, widthAlignUnit, heightAlignUnit); bRet = (!MOS_IS_ALIGNED(dwSurfaceHeight, heightAlignUnit) || !MOS_IS_ALIGNED(dwSurfaceWidth, widthAlignUnit)); // Note: Always using 2 plane NV12 as WA for the corruption of NV12 input, of which the height is greater than 16352 // For 16k case, the height (16384) > 16383 which is the maximum capacity of DW (13:0). // Gmm (OS level) need 32 aligned for planar height in the driver and we are processing height as 16384 for the height from 16353 to 16384. bRet = bRet || (dwSurfaceHeight > 16352); return bRet; } //! //! \brief Print Sampler Params //! \details //! \param PMHW_SAMPLER_STATE_PARAM pSamplerParams //! [in] SamplerParams void PrintSamplerParams(int32_t iSamplerIndex, PMHW_SAMPLER_STATE_PARAM pSamplerParams) { #if (_DEBUG || _RELEASE_INTERNAL) if (pSamplerParams == nullptr) { MHW_RENDERHAL_ASSERTMESSAGE("The SamplerParams pointer is null"); return; } if (pSamplerParams->SamplerType == MHW_SAMPLER_TYPE_3D) { MHW_RENDERHAL_VERBOSEMESSAGE("SamplerParams: index = %x, bInUse = %x, SamplerType = %x, ElementType = %x, SamplerFilterMode = %x, MagFilter = %x, MinFilter = %x", iSamplerIndex, pSamplerParams->bInUse, pSamplerParams->SamplerType, pSamplerParams->ElementType, pSamplerParams->Unorm.SamplerFilterMode, pSamplerParams->Unorm.MagFilter, pSamplerParams->Unorm.MinFilter); MHW_RENDERHAL_VERBOSEMESSAGE("SamplerParams: index = %x, AddressU = %x, AddressV = %x, AddressW = %x, SurfaceFormat = %x, BorderColorRedU = %x, BorderColorGreenU = %x", iSamplerIndex, pSamplerParams->Unorm.AddressU, pSamplerParams->Unorm.AddressV, pSamplerParams->Unorm.AddressW, pSamplerParams->Unorm.SurfaceFormat, pSamplerParams->Unorm.BorderColorRedU, pSamplerParams->Unorm.BorderColorGreenU); MHW_RENDERHAL_VERBOSEMESSAGE("SamplerParams: index = %x, BorderColorBlueU = %x, BorderColorAlphaU = %x, IndirectStateOffset = %x, bBorderColorIsValid = %x, bChromaKeyEnable = %x, ChromaKeyIndex = %x, ChromaKeyMode = %x", iSamplerIndex, pSamplerParams->Unorm.BorderColorBlueU, pSamplerParams->Unorm.BorderColorAlphaU, pSamplerParams->Unorm.IndirectStateOffset, pSamplerParams->Unorm.bBorderColorIsValid, pSamplerParams->Unorm.bChromaKeyEnable, pSamplerParams->Unorm.ChromaKeyIndex, pSamplerParams->Unorm.ChromaKeyMode); } else { MHW_RENDERHAL_VERBOSEMESSAGE("SamplerParams: index = %x, bInUse = %x, SamplerType = %x, ElementType = %x", iSamplerIndex, pSamplerParams->bInUse, pSamplerParams->SamplerType, pSamplerParams->ElementType); } #endif } //! //! \brief Sets Sampler States for Gen8 //! \details Initialize and set sampler states //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to HW interface //! \param int32_t iMediaID //! [in] Media Interface Descriptor ID //! \param PRENDERHAL_SAMPLER_STATE_PARAMS pSamplerParams //! [in] Pointer to sampler state parameters //! \param int32_t iSamplers //! [in] Number of samplers //! \return MOS_STATUS MOS_STATUS_SUCCESS if success, otherwise MOS_STATUS_UNKNOWN //! MOS_STATUS RenderHal_SetSamplerStates( PRENDERHAL_INTERFACE pRenderHal, int32_t iMediaID, PMHW_SAMPLER_STATE_PARAM pSamplerParams, int32_t iSamplers) { MOS_STATUS eStatus; PRENDERHAL_STATE_HEAP pStateHeap; PMHW_SAMPLER_STATE_PARAM pSamplerStateParams; PRENDERHAL_MEDIA_STATE pMediaState; int32_t iOffsetSampler; uint8_t *pPtrSampler; uint8_t *pPtrSamplerAvs; int32_t i; eStatus = MOS_STATUS_UNKNOWN; //----------------------------------------------- MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(pSamplerParams); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap->pCurMediaState); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pHwSizes); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pMhwStateHeap); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap->pGshBuffer); MHW_RENDERHAL_ASSERT( iSamplers <= pRenderHal->StateHeapSettings.iSamplers ); MHW_RENDERHAL_ASSERT((iMediaID >= 0) && (iMediaID < pRenderHal->StateHeapSettings.iMediaIDs)); //----------------------------------------------- pStateHeap = pRenderHal->pStateHeap; pMediaState = pRenderHal->pStateHeap->pCurMediaState; // Offset/Pointer to Samplers iOffsetSampler = pMediaState->dwOffset + // Offset to media state pStateHeap->dwOffsetSampler + // Offset to sampler area iMediaID * pStateHeap->dwSizeSamplers; // Samplers for media ID pPtrSampler = pStateHeap->pGshBuffer + iOffsetSampler; // Pointer to Samplers iOffsetSampler = pMediaState->dwOffset + // Offset to media state pStateHeap->dwOffsetSamplerAVS + // Offset to sampler area iMediaID * pStateHeap->dwSizeSamplers; // Samplers for media ID pPtrSamplerAvs = pStateHeap->pGshBuffer + iOffsetSampler; // Pointer to AVS Samplers // Setup sampler states pSamplerStateParams = pSamplerParams; // Pointer to First Sampler State in array for (i = 0; i < iSamplers; i++, pSamplerStateParams++, pPtrSampler += pRenderHal->pHwSizes->dwSizeSamplerState) { PrintSamplerParams(i, pSamplerStateParams); if (pSamplerStateParams->bInUse) { MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pOsInterface->pfnSetCmdBufferDebugInfo( pRenderHal->pOsInterface, true, //bSamplerState false, //bSurfaceState i, pSamplerStateParams->SamplerType)); switch (pSamplerStateParams->SamplerType) { case MHW_SAMPLER_TYPE_3D: eStatus = pRenderHal->pMhwStateHeap->SetSamplerState(pPtrSampler, pSamplerStateParams); break; case MHW_SAMPLER_TYPE_AVS: eStatus = pRenderHal->pMhwStateHeap->SetSamplerState(pPtrSamplerAvs, pSamplerStateParams); pPtrSamplerAvs += pRenderHal->dwSamplerAvsIncrement; break; default: eStatus = MOS_STATUS_INVALID_PARAMETER; MHW_RENDERHAL_ASSERTMESSAGE("Unknown Sampler Type."); break; } if (MOS_FAILED(eStatus)) { MHW_RENDERHAL_ASSERTMESSAGE("Failed to setup Sampler"); return eStatus; } } } eStatus = MOS_STATUS_SUCCESS; return eStatus; } //! //! \brief Sets Sampler States for Gen8 //! \details Initialize and set sampler states //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to HW interface //! \param int32_t iMediaID //! [in] Media Interface Descriptor ID //! \param PRENDERHAL_SAMPLER_STATE_PARAMS pSamplerParams //! [in] Pointer to sampler state parameters //! \param int32_t iSamplers //! [in] Number of samplers //! \return MOS_STATUS MOS_STATUS_SUCCESS if success, otherwise MOS_STATUS_UNKNOWN //! MOS_STATUS RenderHal_SetAndGetSamplerStates( PRENDERHAL_INTERFACE pRenderHal, int32_t iMediaID, PMHW_SAMPLER_STATE_PARAM pSamplerParams, int32_t iSamplers, std::map &samplerMap) { MOS_STATUS eStatus; PRENDERHAL_STATE_HEAP pStateHeap; PMHW_SAMPLER_STATE_PARAM pSamplerStateParams; PRENDERHAL_MEDIA_STATE pMediaState; int32_t iOffsetSampler; uint8_t *pPtrSampler; int32_t i; uint32_t stateOffsets = 0; eStatus = MOS_STATUS_UNKNOWN; //----------------------------------------------- MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(pSamplerParams); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap->pCurMediaState); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pHwSizes); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pMhwStateHeap); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap->pGshBuffer); MHW_RENDERHAL_ASSERT(iSamplers <= pRenderHal->StateHeapSettings.iSamplers); MHW_RENDERHAL_ASSERT((iMediaID >= 0) && (iMediaID < pRenderHal->StateHeapSettings.iMediaIDs)); //----------------------------------------------- if (pRenderHal->isBindlessHeapInUse == false) { return RenderHal_SetSamplerStates(pRenderHal, iMediaID, pSamplerParams, iSamplers); } else { pStateHeap = pRenderHal->pStateHeap; pMediaState = pRenderHal->pStateHeap->pCurMediaState; // Offset/Pointer to Samplers iOffsetSampler = pMediaState->dwOffset + // Offset to media state pStateHeap->dwOffsetSampler + // Offset to sampler area iMediaID * pStateHeap->dwSizeSamplers; // Samplers for media ID pPtrSampler = pStateHeap->pGshBuffer + iOffsetSampler; // Pointer to Samplers // Setup sampler states pSamplerStateParams = pSamplerParams; // Pointer to First Sampler State in array if (samplerMap.size() != 0) { MHW_RENDERHAL_ASSERTMESSAGE("samplerMap is not empty!"); samplerMap.clear(); } for (i = 0; i < iSamplers; i++, pSamplerStateParams++, pPtrSampler += pRenderHal->pHwSizes->dwSizeSamplerState) { PrintSamplerParams(i, pSamplerStateParams); if (pSamplerStateParams->bInUse) { MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pOsInterface->pfnSetCmdBufferDebugInfo( pRenderHal->pOsInterface, true, //bSamplerState false, //bSurfaceState i, pSamplerStateParams->SamplerType)); switch (pSamplerStateParams->SamplerType) { case MHW_SAMPLER_TYPE_3D: stateOffsets = iOffsetSampler + i * pRenderHal->pHwSizes->dwSizeSamplerState; eStatus = pRenderHal->pMhwStateHeap->SetSamplerState(pPtrSampler, pSamplerStateParams); break; default: eStatus = MOS_STATUS_INVALID_PARAMETER; MHW_RENDERHAL_ASSERTMESSAGE("Unknown Sampler Type."); break; } samplerMap.insert(std::make_pair(i, stateOffsets)); if (MOS_FAILED(eStatus)) { MHW_RENDERHAL_ASSERTMESSAGE("Failed to setup Sampler"); return eStatus; } } } eStatus = MOS_STATUS_SUCCESS; return eStatus; } } //! //! \brief Setup Surface State //! \details Setup Surface States //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to Hardware Interface Structure //! \param PRENDERHAL_SURFACE pRenderHalSurface //! [in] Pointer to Render Hal Surface //! \param PRENDERHAL_SURFACE_STATE_PARAMS pParams //! [in] Pointer to Surface State Params //! \param int32_t *piNumEntries //! [out] Pointer to Number of Surface State Entries (Num Planes) //! \param PRENDERHAL_SURFACE_STATE_ENTRY * ppSurfaceEntries //! [out] Array of Surface State Entries //! \param PRENDERHAL_OFFSET_OVERRIDE pOffsetOverride //! [in] If not nullptr, provides adjustments to Y, UV plane offsets, //! used for kernel in a few cases. nullptr is the most common usage. //! \return MOS_STATUS //! MOS_STATUS RenderHal_SetupSurfaceState( PRENDERHAL_INTERFACE pRenderHal, PRENDERHAL_SURFACE pRenderHalSurface, PRENDERHAL_SURFACE_STATE_PARAMS pParams, int32_t *piNumEntries, PRENDERHAL_SURFACE_STATE_ENTRY *ppSurfaceEntries, PRENDERHAL_OFFSET_OVERRIDE pOffsetOverride) { MOS_STATUS eStatus = MOS_STATUS_SUCCESS; //----------------------------------------------- MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pRenderHalPltInterface); //----------------------------------------------- if (pParams->surfaceType) { MOS_CACHE_ELEMENT element(MOS_CODEC_RESOURCE_USAGE_BEGIN_CODEC, MOS_CODEC_RESOURCE_USAGE_BEGIN_CODEC); bool res = pRenderHal->pOsInterface->pfnGetCacheSetting(pParams->Component, pParams->surfaceType, pParams->isOutput, RENDER_ENGINE, element, false); if (res) { pParams->MemObjCtl = (pRenderHal->pOsInterface->pfnCachePolicyGetMemoryObject( element.mocsUsageType, pRenderHal->pOsInterface->pfnGetGmmClientContext(pRenderHal->pOsInterface))) .DwordValue; } else { MHW_RENDERHAL_ASSERTMESSAGE("Not found cache settings!"); } } else { MHW_RENDERHAL_NORMALMESSAGE("Not implemented yet! Will use MemObjCtl value %d", pParams->MemObjCtl); } MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->SetupSurfaceState( pRenderHal, pRenderHalSurface, pParams, piNumEntries, ppSurfaceEntries, pOffsetOverride)); return eStatus; } //! //! \brief Get offset and/or pointer to sampler state //! \details Get offset and/or pointer to sampler state in General State Heap //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to RenderHal Interface //! \param int32_t iMediaID //! [in] Media ID associated with sampler //! \param int32_t iSamplerID //! [in] Sampler ID //! \param uint32_t *pdwSamplerOffset //! [out] optional; offset of sampler state from GSH base //! \param void **ppSampler //! [out] optional; pointer to sampler state in GSH //! \return MOS_STATUS //! MOS_STATUS RenderHal_GetSamplerOffsetAndPtr( PRENDERHAL_INTERFACE pRenderHal, int32_t iMediaID, int32_t iSamplerID, PMHW_SAMPLER_STATE_PARAM pSamplerParams, uint32_t *pdwSamplerOffset, void **ppSampler) { PRENDERHAL_STATE_HEAP pStateHeap; uint32_t dwOffset = 0; MHW_SAMPLER_ELEMENT_TYPE ElementType; MHW_SAMPLER_TYPE SamplerType; MOS_STATUS eStatus = MOS_STATUS_SUCCESS; uint32_t ElementSize[MHW_SamplerTotalElements] = {1, 2, 4, 8, 64, 128}; MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pStateHeap); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pHwSizes); pStateHeap = pRenderHal->pStateHeap; MHW_RENDERHAL_CHK_NULL_RETURN(pStateHeap->pCurMediaState); MHW_RENDERHAL_CHK_NULL_RETURN(pStateHeap->pGshBuffer); MHW_ASSERT(iMediaID < pRenderHal->StateHeapSettings.iMediaIDs); MHW_ASSERT(iSamplerID < pRenderHal->StateHeapSettings.iSamplers); MHW_RENDERHAL_CHK_NULL_RETURN(pSamplerParams); ElementType = pSamplerParams->ElementType; SamplerType = pSamplerParams->SamplerType; if (SamplerType == MHW_SAMPLER_TYPE_VME) { dwOffset = pStateHeap->pCurMediaState->dwOffset + // Offset to current media state base pStateHeap->dwOffsetSampler + // Go to base of the sampler area iMediaID * pStateHeap->dwSizeSampler + // Go to base of media ID's sampler area iSamplerID * pRenderHal->pHwSizes->dwSizeSamplerState; // Goto to "samplerID" sampler state } else { switch (ElementType) { case MHW_Sampler1Element: case MHW_Sampler4Elements: { dwOffset = pStateHeap->pCurMediaState->dwOffset + // Offset to current media state base pStateHeap->dwOffsetSampler + // Go to base of the sampler area iMediaID * pStateHeap->dwSizeSampler + // Go to base of media ID's sampler area iSamplerID * pRenderHal->pHwSizes->dwSizeSamplerState; // Goto to "samplerID" sampler state if (pSamplerParams) { pSamplerParams->Unorm.IndirectStateOffset = pStateHeap->pCurMediaState->dwOffset + // Offset to current media state base pStateHeap->dwOffsetSamplerIndirect + // Go to base of the sampler indirect area iMediaID * pStateHeap->dwSizeSampler + // Go to base of media ID's sampler area iSamplerID * pRenderHal->pHwSizes->dwSizeSamplerIndirectState; // Goto to "samplerID" sampler indirect state pSamplerParams->Unorm.pIndirectState = (void *)(pStateHeap->pGshBuffer + pSamplerParams->Unorm.IndirectStateOffset); } break; } case MHW_Sampler2Elements: case MHW_Sampler8Elements: dwOffset = pStateHeap->pCurMediaState->dwOffset + // Offset to current media state base pStateHeap->dwOffsetSampler + // Go to base of the sampler area iMediaID * pStateHeap->dwSizeSampler + // Go to base of media ID's sampler area iSamplerID * ElementSize[ElementType] * 16; // Goto to "samplerID" sampler state break; case MHW_Sampler64Elements: dwOffset = pStateHeap->pCurMediaState->dwOffset + // Offset to current media state base pStateHeap->dwOffsetSampler + // Go to base of the sampler area iMediaID * pStateHeap->dwSizeSampler + // Go to base of media ID's sampler area iSamplerID * 32 * 16; // Goto to "samplerID" sampler state break; case MHW_Sampler128Elements: if (pRenderHal->pRenderHalPltInterface->IsSampler128ElementsSupported()) { dwOffset = pStateHeap->pCurMediaState->dwOffset + // Offset to current media state base pStateHeap->dwOffsetSampler + // Go to base of the sampler area iMediaID * pStateHeap->dwSizeSampler + // Go to base of media ID's sampler area iSamplerID * ElementSize[ElementType] * 16; // Goto to "samplerID" sampler state } else { MHW_RENDERHAL_NORMALMESSAGE("Platform doesn't have any 128 element sampler, quit!"); eStatus = MOS_STATUS_INVALID_PARAMETER; } break; default: MHW_RENDERHAL_NORMALMESSAGE("Failed to parse sampler - invalid sampler type."); eStatus = MOS_STATUS_INVALID_PARAMETER; break; } } if (pdwSamplerOffset) { *pdwSamplerOffset = dwOffset; } if (ppSampler) { *ppSampler = (void *)(pStateHeap->pGshBuffer + dwOffset); } return eStatus; } //! //! \brief Checks how per thread scratch space size bits in VFE state are interpreted by HW //! \details For BDW GT1/2/3 A0 steppings, per thread scratch space size in VFE state //! is 11 bits indicating [2k bytes, 2 Mbytes]: 0=2k, 1=4k, 2=8k ... 10=2M //! BDW+ excluding A0 step is 12 bits indicating [1k bytes, 2 Mbytes]: 0=1k, 1=2k, 2=4k, 3=8k ... 11=2M //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to RenderHal interface //! \return true if BDW A0 stepping, false otherwise //! bool RenderHal_PerThreadScratchSpaceStart2K( PRENDERHAL_INTERFACE pRenderHal) { if (pRenderHal == nullptr || pRenderHal->pRenderHalPltInterface == nullptr) { MHW_RENDERHAL_ASSERTMESSAGE("Invalid (nullptr) Pointer."); return false; } return pRenderHal->pRenderHalPltInterface->PerThreadScratchSpaceStart2K(pRenderHal); } //! //! \brief Encode SLM Size for Interface Descriptor //! \details Setup SLM size //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to RenderHal interface //! \param uint32_t SLMSize //! [in] SLM size in 1K //! \return encoded output //! uint32_t RenderHal_EncodeSLMSize( PRENDERHAL_INTERFACE pRenderHal, uint32_t SLMSize) { MOS_STATUS eStatus = MOS_STATUS_SUCCESS; if (pRenderHal == nullptr || pRenderHal->pRenderHalPltInterface == nullptr) { MHW_RENDERHAL_ASSERTMESSAGE("Invalid (nullptr) Pointer."); return 0; } return pRenderHal->pRenderHalPltInterface->EncodeSLMSize(SLMSize); } //! //! \brief Set Chroma Direction //! \details Setup Chroma Direction //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to Hardware Interface //! \param PRENDERHAL_SURFACE pRenderHalSurface //! [in] Pointer to Render Hal Surface //! \return uint8_t //! uint8_t RenderHal_SetChromaDirection( PRENDERHAL_INTERFACE pRenderHal, PRENDERHAL_SURFACE pRenderHalSurface) { if (pRenderHal == nullptr || pRenderHal->pRenderHalPltInterface == nullptr) { MHW_RENDERHAL_ASSERTMESSAGE("Invalid (nullptr) Pointer."); return false; } return pRenderHal->pRenderHalPltInterface->SetChromaDirection(pRenderHal, pRenderHalSurface); } //! //! \brief Convert To Nano Seconds //! \details Convert to Nano Seconds //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to Hardware Interface Structure //! \param uint64_t iTicks //! [in] Ticks //! \param uint64_t *piNs //! [in] Nano Seconds //! \return void //! void RenderHal_ConvertToNanoSeconds( PRENDERHAL_INTERFACE pRenderHal, uint64_t iTicks, uint64_t *piNs) { if (pRenderHal == nullptr || pRenderHal->pRenderHalPltInterface == nullptr) { MHW_RENDERHAL_ASSERTMESSAGE("Invalid (nullptr) Pointer."); return; } pRenderHal->pRenderHalPltInterface->ConvertToNanoSeconds(pRenderHal, iTicks, piNs); } //! //! \brief Enables L3 cacheing flag and sets related registers/values //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to Hardware Interface //! \param pCacheSettings //! [in] L3 Cache Configurations //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success, else fail reason //! MOS_STATUS RenderHal_EnableL3Caching( PRENDERHAL_INTERFACE pRenderHal, PRENDERHAL_L3_CACHE_SETTINGS pCacheSettings) { MOS_STATUS eStatus = MOS_STATUS_SUCCESS; MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pRenderHalPltInterface); MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->EnableL3Caching(pRenderHal, pCacheSettings)); return eStatus; } //! //! \brief Set L3 cache override config parameters //! \param [in] pRenderHal //! Pointer to RenderHal Interface Structure //! \param [in,out] pCacheSettings //! Pointer to pCacheSettings //! \param [in] bEnableSLM //! Flag to enable SLM //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success. Error code otherwise //! MOS_STATUS RenderHal_SetCacheOverrideParams( PRENDERHAL_INTERFACE pRenderHal, PRENDERHAL_L3_CACHE_SETTINGS pCacheSettings, bool bEnableSLM) { MOS_STATUS eStatus = MOS_STATUS_SUCCESS; MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pRenderHalPltInterface); MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pRenderHalPltInterface->SetCacheOverrideParams( pRenderHal, pCacheSettings, bEnableSLM) ); pCacheSettings->bOverride = pCacheSettings->bCntlRegOverride || pCacheSettings->bCntlReg2Override || pCacheSettings->bCntlReg3Override || pCacheSettings->bLra1RegOverride || pCacheSettings->bSqcReg1Override; return eStatus; } //! //! \brief Send Surface State Entry //! \param [in] pRenderHal //! pointer to render hal //! \param [in] pCmdBuffer //! pointer to command buffer //! \param [in] pParams //! pointer to surface state send parameters //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success, else fail reason //! MOS_STATUS RenderHal_SendSurfaceStateEntry( PRENDERHAL_INTERFACE pRenderHal, PMOS_COMMAND_BUFFER pCmdBuffer, PMHW_SURFACE_STATE_SEND_PARAMS pParams) { //----------------------------------------------- MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface); MHW_RENDERHAL_CHK_NULL_RETURN(pParams); //----------------------------------------------- uint8_t *pbPtrCmdBuf; if (pRenderHal->isBindlessHeapInUse) { MHW_RENDERHAL_CHK_NULL_RETURN(pParams->pIndirectStateBase); pbPtrCmdBuf = pParams->pIndirectStateBase; } else { MHW_RENDERHAL_CHK_NULL_RETURN(pCmdBuffer); pbPtrCmdBuf = (uint8_t *)pCmdBuffer->pCmdBase; } PMOS_INTERFACE pOsInterface = pRenderHal->pOsInterface; uint8_t *pSurfaceState = pParams->pSurfaceStateSource; int32_t iSurfaceStateOffset = pParams->iSurfaceStateOffset; int32_t iIndirectStateBase = pParams->iIndirectStateBase; SURFACE_STATE_TOKEN_COMMON *pSurfaceStateToken = (SURFACE_STATE_TOKEN_COMMON*)pParams->pSurfaceToken; uint32_t* pdwCmd = (uint32_t*)(pParams->pIndirectStateBase + iSurfaceStateOffset); uint32_t locationInCmd = 0; // Copy surface state from system memory to graphics memory/indirect state if (pSurfaceStateToken->DW3.SurfaceStateType == MEDIASTATE_BTS_DEFAULT_TYPE) { MOS_SecureMemcpy(pdwCmd, pRenderHal->pHwSizes->dwSizeSurfaceState, pSurfaceState, pRenderHal->pHwSizes->dwSizeSurfaceState); // Patch offset is 8 DW from the surface state base pdwCmd += 8; iSurfaceStateOffset += 8 * sizeof(uint32_t); locationInCmd = 8; } else { MOS_SecureMemcpy(pdwCmd, pRenderHal->pHwSizes->dwSizeSurfaceStateAvs, pSurfaceState, pRenderHal->pHwSizes->dwSizeSurfaceStateAvs); // Patch offset is 6 DW from the surface state base pdwCmd += 6; iSurfaceStateOffset += 6 * sizeof(uint32_t); locationInCmd = 6; } if (pOsInterface->bUsesGfxAddress) { *pdwCmd = pSurfaceStateToken->DW4.SurfaceBaseAddress; *(pdwCmd + 1) = pSurfaceStateToken->DW5.SurfaceBaseAddress64; } if (pSurfaceStateToken->pResourceInfo) { HalOcaInterfaceNext::DumpResourceInfo(*pCmdBuffer, *pOsInterface, *(PMOS_RESOURCE)(pSurfaceStateToken->pResourceInfo), (MOS_HW_COMMAND)pSurfaceStateToken->DW0.DriverID, locationInCmd, 0); } MOS_PATCH_ENTRY_PARAMS PatchEntryParams; MOS_ZeroMemory(&PatchEntryParams, sizeof(PatchEntryParams)); PatchEntryParams.uiAllocationIndex = pSurfaceStateToken->DW1.SurfaceAllocationIndex; PatchEntryParams.uiResourceOffset = pSurfaceStateToken->DW2.SurfaceOffset; PatchEntryParams.uiPatchOffset = iIndirectStateBase + iSurfaceStateOffset; PatchEntryParams.bWrite = pSurfaceStateToken->DW3.RenderTargetEnable; PatchEntryParams.HwCommandType = (MOS_HW_COMMAND)pSurfaceStateToken->DW0.DriverID; PatchEntryParams.forceDwordOffset = 0; PatchEntryParams.cmdBufBase = pbPtrCmdBuf; PatchEntryParams.presResource = (PMOS_RESOURCE)pSurfaceStateToken->pResourceInfo; // Set patch for surface state address pOsInterface->pfnSetPatchEntry( pOsInterface, &PatchEntryParams); MOS_MEMCOMP_STATE mmcMode = MOS_MEMCOMP_DISABLED; PMOS_RESOURCE pMosResource = (PMOS_RESOURCE)pSurfaceStateToken->pResourceInfo; MHW_RENDERHAL_CHK_NULL_RETURN(pMosResource); if (pOsInterface->pfnGetMemoryCompressionMode) { pOsInterface->pfnGetMemoryCompressionMode(pOsInterface, pMosResource, &mmcMode); } if (mmcMode == MOS_MEMCOMP_RC && pSurfaceStateToken->DW3.SurfaceStateType == MEDIASTATE_BTS_DEFAULT_TYPE) { # if !EMUL if (pOsInterface->bUsesGfxAddress) { uint64_t ui64GfxAddress = 0; uint64_t ui64GfxAddressWithoutOffset = 0; ui64GfxAddress |= (uint64_t)(pSurfaceStateToken->DW5.SurfaceBaseAddress64 & 0x0000FFFF) << 32; ui64GfxAddress |= (uint64_t)(pSurfaceStateToken->DW4.SurfaceBaseAddress); //Original Resouce Address without surface offset ui64GfxAddressWithoutOffset = ui64GfxAddress - pSurfaceStateToken->DW2.SurfaceOffset; pdwCmd = (uint32_t*)(pParams->pIndirectStateBase + pParams->iSurfaceStateOffset); //point to the start of current RENDER_SURFACE_STATE_CMD if (pMosResource->pGmmResInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CCS)) { // Set GFX address of AuxiliarySurfaceBaseAddress // Should use original resource address here uint64_t auxAddress = ui64GfxAddressWithoutOffset + (uint64_t)pMosResource->pGmmResInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CCS); *(pdwCmd + 10) = (*(pdwCmd + 10) & 0x00000FFF) | (uint32_t)(auxAddress & 0x00000000FFFFF000); *(pdwCmd + 11) = *(pdwCmd + 11) | (uint32_t)((auxAddress & 0x0000FFFF00000000) >> 32); } uint64_t clearAddress = 0; if (pOsInterface->trinityPath != TRINITY_DISABLED) { clearAddress = pOsInterface->pfnGetResourceClearAddress(pOsInterface, pMosResource); } else if (pMosResource->pGmmResInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CC)) { // Set GFX address of ClearAddress // Should use original resource address here clearAddress = ui64GfxAddressWithoutOffset + (uint32_t)pMosResource->pGmmResInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CC); } if (clearAddress) { *(pdwCmd + 12) = (*(pdwCmd + 12) & 0x0000001F) | (uint32_t)(clearAddress & 0x00000000FFFFFFE0); *(pdwCmd + 13) = *(pdwCmd + 13) | (uint32_t)((clearAddress & 0x0000FFFF00000000) >> 32); } } else { // Set patch for AuxiliarySurfaceBaseAddress MOS_ZeroMemory(&PatchEntryParams, sizeof(PatchEntryParams)); PatchEntryParams.uiAllocationIndex = pSurfaceStateToken->DW1.SurfaceAllocationIndex; PatchEntryParams.uiResourceOffset = pSurfaceStateToken->DW2.SurfaceOffset + (uint32_t)pMosResource->pGmmResInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CCS); PatchEntryParams.uiPatchOffset = iIndirectStateBase + pParams->iSurfaceStateOffset + 10 * sizeof(uint32_t); PatchEntryParams.bWrite = pSurfaceStateToken->DW3.RenderTargetEnable; PatchEntryParams.HwCommandType = (MOS_HW_COMMAND)pSurfaceStateToken->DW0.DriverID; PatchEntryParams.forceDwordOffset = 0; PatchEntryParams.cmdBufBase = pbPtrCmdBuf; PatchEntryParams.presResource = (PMOS_RESOURCE)pSurfaceStateToken->pResourceInfo; pOsInterface->pfnSetPatchEntry(pOsInterface, &PatchEntryParams); // Set patch for ClearAddress MOS_ZeroMemory(&PatchEntryParams, sizeof(PatchEntryParams)); PatchEntryParams.uiAllocationIndex = pSurfaceStateToken->DW1.SurfaceAllocationIndex; PatchEntryParams.uiResourceOffset = pSurfaceStateToken->DW2.SurfaceOffset + (uint32_t)pMosResource->pGmmResInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CC); PatchEntryParams.uiPatchOffset = iIndirectStateBase + pParams->iSurfaceStateOffset + 12 * sizeof(uint32_t); PatchEntryParams.bWrite = pSurfaceStateToken->DW3.RenderTargetEnable; PatchEntryParams.HwCommandType = (MOS_HW_COMMAND)pSurfaceStateToken->DW0.DriverID; PatchEntryParams.forceDwordOffset = 0; PatchEntryParams.cmdBufBase = pbPtrCmdBuf; PatchEntryParams.presResource = (PMOS_RESOURCE)pSurfaceStateToken->pResourceInfo; pOsInterface->pfnSetPatchEntry(pOsInterface, &PatchEntryParams); } #endif } return MOS_STATUS_SUCCESS; } //! //! \brief Init Interface //! \details Initializes RenderHal Interface structure, responsible for HW //! abstraction of HW Rendering Engine for CM(MDF) and VP. //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to RenderHal Interface Structure //! \param MhwCpInterface** ppCpInterface //! [in/out] Pointer of pointer to MHW CP Interface Structure, which //! is created during renderhal initialization //! \param PMOS_INTERFACE pOsInterface //! [in] Pointer to OS Interface Structure //! \return MOS_STATUS //! MOS_STATUS_UNKNOWN : Invalid parameters //! MOS_STATUS RenderHal_InitInterface( PRENDERHAL_INTERFACE pRenderHal, MhwCpInterface **ppCpInterface, PMOS_INTERFACE pOsInterface) { MOS_STATUS eStatus = MOS_STATUS_SUCCESS; MHW_VFE_PARAMS *pVfeStateParams = nullptr; //--------------------------------------- MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(ppCpInterface); MHW_RENDERHAL_CHK_NULL_RETURN(pOsInterface); //--------------------------------------- // Basic initialization pRenderHal->pOsInterface = pOsInterface; pRenderHal->bKerneltimeDump = false; MOS_ZeroMemory(&pRenderHal->kernelTime, sizeof(pRenderHal->kernelTime)); pOsInterface->pfnGetPlatform(pOsInterface, &pRenderHal->Platform); pRenderHal->pSkuTable = pOsInterface->pfnGetSkuTable(pOsInterface); pRenderHal->pWaTable = pOsInterface->pfnGetWaTable(pOsInterface); pRenderHal->userSettingPtr = pOsInterface->pfnGetUserSettingInstance(pOsInterface); // Initialize hardware resources for the current Os/Platform pRenderHal->pRenderHalPltInterface = RenderHalDevice::CreateFactory(pOsInterface); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pRenderHalPltInterface); // create mhw interfaces including mhw_render, cp, and mi pRenderHal->pRenderHalPltInterface->CreateMhwInterfaces(pRenderHal, pOsInterface); // Set Cp Interface *ppCpInterface = pRenderHal->pCpInterface; // Initialize MHW State Heap Interface // Note: there are two pStateHeapInterface in below line. First one is pointer to legacy MHW_STATE_HEAP // sturcture, while the last one points to the new class. if (pRenderHal->pRenderHalPltInterface->GetStateHeapInterface(pRenderHal) != nullptr) { pRenderHal->pMhwStateHeap = pRenderHal->pRenderHalPltInterface->GetStateHeapInterface(pRenderHal)->pStateHeapInterface; } pRenderHal->pHwCaps = pRenderHal->pRenderHalPltInterface->GetHwCaps(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pHwCaps); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pMhwStateHeap); pRenderHal->pHwSizes = pRenderHal->pMhwStateHeap->GetHwSizesPointer(); pRenderHal->dwTimeoutMs = RENDERHAL_TIMEOUT_MS_DEFAULT; pRenderHal->iMaxPalettes = RENDERHAL_PALETTE_MAX; pRenderHal->iMaxPaletteEntries = RENDERHAL_PALETTE_ENTRIES_MAX; pRenderHal->iMaxChromaKeys = RENDERHAL_CHROMA_KEY_MAX; //set MDF load to default value false pRenderHal->IsMDFLoad = false; //set AVS to default value false pRenderHal->bIsAVS = false; pRenderHal->iChromaKeyCount = 0; for (int i = 0; i < pRenderHal->iMaxChromaKeys; i++) { pRenderHal->ChromaKey[i].dwIndex = i; } pRenderHal->bVDIWalker = true; int32_t walkerMode = MHW_WALKER_MODE_NOT_SET; #if (_DEBUG || _RELEASE_INTERNAL) if (pRenderHal->userSettingPtr != nullptr) { // Read VDI Walker Regkey once during initialization ReadUserSettingForDebug( pRenderHal->userSettingPtr, pRenderHal->bVDIWalker, __MEDIA_USER_FEATURE_VALUE_VDI_MODE, MediaUserSetting::Group::Device, true, true); // Read Media Walker Mode from RegKey once in initialization ReadUserSettingForDebug( pRenderHal->userSettingPtr, walkerMode, __MEDIA_USER_FEATURE_VALUE_MEDIA_WALKER_MODE, MediaUserSetting::Group::Device, int32_t(-1), true); } #endif pRenderHal->MediaWalkerMode = (MHW_WALKER_MODE)walkerMode; pRenderHal->pPlaneDefinitions = g_cRenderHal_SurfacePlanes; // disable RenderHal kernel debugging. pRenderHal->bIsaAsmDebugEnable = false; pRenderHal->iMaxPalettes = RENDERHAL_PALETTE_COUNT; pRenderHal->iMaxPaletteEntries = RENDERHAL_PALETTE_ENTRIES; pRenderHal->iMaxChromaKeys = RENDERHAL_CHROMA_KEY_COUNT; MOS_ZeroMemory(&pRenderHal->PredicationParams, sizeof(pRenderHal->PredicationParams)); MOS_ZeroMemory(&pRenderHal->SetMarkerParams, sizeof(pRenderHal->SetMarkerParams)); // CMFC CSC Coefficient Surface update pRenderHal->bCmfcCoeffUpdate = false; pRenderHal->iKernelAllocationID = RENDERHAL_KERNEL_LOAD_FAIL; pRenderHal->pCmfcCoeffSurface = nullptr; // Initialization/Cleanup function pRenderHal->pfnInitialize = RenderHal_Initialize; pRenderHal->pfnDestroy = RenderHal_Destroy; // Allocate/Destroy state heaps pRenderHal->pfnAllocateStateHeaps = RenderHal_AllocateStateHeaps; pRenderHal->pfnFreeStateHeaps = RenderHal_FreeStateHeaps; pRenderHal->pfnReAllocateStateHeapsforAdvFeatureWithSshEnlarged = RenderHal_ReAllocateStateHeapsforAdvFeatureWithSshEnlarged; pRenderHal->pfnReAllocateStateHeapsforAdvFeatureWithAllHeapsEnlarged = RenderHal_ReAllocateStateHeapsforAdvFeatureWithAllHeapsEnlarged; // Slice Shutdown Mode pRenderHal->pfnSetSliceShutdownMode = RenderHal_SetSliceShutdownMode; pRenderHal->pfnSetPowerOptionMode = RenderHal_SetPowerOptionMode; // Preemption pRenderHal->pfnEnableGpgpuMiddleBatchBufferPreemption = RenderHal_EnableGpgpuMiddleBatchBufferPreemption; pRenderHal->pfnEnableGpgpuMiddleThreadPreemption = RenderHal_EnableGpgpuMiddleThreadPreemption; // Surface State and Binding Table management functions pRenderHal->pfnSetSurfacesPerBT = RenderHal_SetSurfacesPerBT; pRenderHal->pfnGetSurfaceStateEntries = RenderHal_GetSurfaceStateEntries; pRenderHal->pfnAssignSurfaceState = RenderHal_AssignSurfaceState; pRenderHal->pfnGetAlignUnit = RenderHal_GetAlignUnit; pRenderHal->pfnAdjustBoundary = RenderHal_AdjustBoundary; pRenderHal->pfnAssignBindingTable = RenderHal_AssignBindingTable; pRenderHal->pfnSetupBufferSurfaceState = RenderHal_SetupBufferSurfaceState; pRenderHal->pfnSetupSurfaceStatesOs = RenderHal_SetupSurfaceStatesOs; pRenderHal->pfnBindSurfaceState = RenderHal_BindSurfaceState; pRenderHal->pfnSendSurfaces = RenderHal_SendSurfaces_PatchList; pRenderHal->pfnSendSurfaceStateEntry = RenderHal_SendSurfaceStateEntry; pRenderHal->pfnSetSurfaceStateToken = RenderHal_SetSurfaceStateToken; pRenderHal->pfnSetSurfaceStateBuffer = RenderHal_SetSurfaceStateBuffer; pRenderHal->pfnCalculateYOffset = RenderHal_CalculateYOffset; pRenderHal->pfnAssignBindlessSurfaceStates = RenderHal_AssignBindlessSurfaceStates; pRenderHal->pfnSendBindlessSurfaceStates = RenderHal_SendSurfaces_Bindelss; pRenderHal->pfnGetPlaneDefinitionForCommonMessage = RenderHal_GetPlaneDefinitionForCommonMessage; // Media states management functions pRenderHal->pfnAllocateBB = RenderHal_AllocateBB; pRenderHal->pfnFreeBB = RenderHal_FreeBB; pRenderHal->pfnLockBB = RenderHal_LockBB; pRenderHal->pfnUnlockBB = RenderHal_UnlockBB; pRenderHal->pfnEnablePalette = RenderHal_EnablePalette; pRenderHal->pfnGetPaletteEntry = RenderHal_GetPaletteEntry; pRenderHal->pfnAllocatePaletteID = RenderHal_AllocatePaletteID; pRenderHal->pfnFreePaletteID = RenderHal_FreePaletteID; pRenderHal->pfnAllocateChromaKey = RenderHal_AllocateChromaKey; pRenderHal->pfnAssignMediaState = RenderHal_AssignMediaState; pRenderHal->pfnAllocateMediaID = RenderHal_AllocateMediaID; pRenderHal->pfnGetMediaID = RenderHal_GetMediaID; // Old-style Kernel management functions pRenderHal->pfnRefreshSync = RenderHal_RefreshSync; pRenderHal->pfnLoadKernel = RenderHal_LoadKernel; pRenderHal->pfnUnloadKernel = RenderHal_UnloadKernel; pRenderHal->pfnResetKernels = RenderHal_ResetKernels; pRenderHal->pfnTouchKernel = RenderHal_TouchKernel; pRenderHal->pfnGetKernelOffset = RenderHal_GetKernelOffset; // Command buffer programming functions pRenderHal->pfnLoadCurbeData = RenderHal_LoadCurbeData; pRenderHal->pfnSendCurbeLoad = RenderHal_SendCurbeLoad; pRenderHal->pfnSendMediaIdLoad = RenderHal_SendMediaIdLoad; pRenderHal->pfnSendChromaKey = RenderHal_SendChromaKey; pRenderHal->pfnSendPalette = RenderHal_SendPalette; pRenderHal->pfnSendMediaStates = RenderHal_SendMediaStates; pRenderHal->pfnSendStateBaseAddress = RenderHal_SendStateBaseAddress; // Initialize OS dependent RenderHal Interfaces common to all platforms pRenderHal->pfnReset = RenderHal_Reset; pRenderHal->pfnAssignSshInstance = RenderHal_AssignSshInstance; pRenderHal->pfnInitCommandBuffer = RenderHal_InitCommandBuffer; pRenderHal->pfnSendTimingData = RenderHal_SendTimingData; pRenderHal->pfnSendRcsStatusTag = RenderHal_SendRcsStatusTag; pRenderHal->pfnSendSyncTag = RenderHal_SendSyncTag; pRenderHal->pfnSendCscCoeffSurface = RenderHal_SendCscCoeffSurface; // InterfaceDescriptor pRenderHal->pfnSetupInterfaceDescriptor = RenderHal_SetupInterfaceDescriptor; // Media Walker pRenderHal->pfnGetMediaWalkerStatus = RenderHal_GetMediaWalkerStatus; //Surface Memory Object Control pRenderHal->pfnGetSurfaceMemoryObjectControl = RenderHal_GetSurfaceMemoryObjectControl; //Scratch Space pRenderHal->pfnGetScratchSpaceSize = RenderHal_GetScratchSpaceSize; // Other states pRenderHal->pfnSetVfeStateParams = RenderHal_SetVfeStateParams; pRenderHal->pfnSetSamplerStates = RenderHal_SetSamplerStates; pRenderHal->pfnSetAndGetSamplerStates = RenderHal_SetAndGetSamplerStates; pRenderHal->pfnIs2PlaneNV12Needed = RenderHal_Is2PlaneNV12Needed; // Set the platform-specific fields in renderhal // Set State Heap settings MOS_ZeroMemory(&pRenderHal->enlargeStateHeapSettingsForAdv, sizeof(pRenderHal->enlargeStateHeapSettingsForAdv)); pRenderHal->pRenderHalPltInterface->InitStateHeapSettings(pRenderHal); // Set default / advanced surface types pRenderHal->pRenderHalPltInterface->InitSurfaceTypes(pRenderHal); // Set MMC Enabled status pRenderHal->pRenderHalPltInterface->IsRenderHalMMCEnabled(pRenderHal); // Set platform dependent parameters pRenderHal->bHasCombinedAVSSamplerState = true; pRenderHal->bEnableYV12SinglePass = pRenderHal->pRenderHalPltInterface->IsEnableYV12SinglePass(pRenderHal); pRenderHal->dwSamplerAvsIncrement = pRenderHal->pRenderHalPltInterface->GetSizeSamplerStateAvs(pRenderHal); pRenderHal->bComputeContextInUse = pRenderHal->pRenderHalPltInterface->IsComputeContextInUse(pRenderHal); pRenderHal->isBindlessHeapInUse = pRenderHal->pRenderHalPltInterface->IsBindlessHeapInUse(pRenderHal); pRenderHal->dwMaskCrsThdConDataRdLn = (uint32_t) -1; pRenderHal->dwMinNumberThreadsInGroup = 1; pRenderHal->dwCurbeBlockAlign = RENDERHAL_CURBE_BLOCK_ALIGN; pRenderHal->dwScratchSpaceMaxThreads = pRenderHal->pHwCaps->dwMaxThreads; // Set palette data for (int i = 0; i < pRenderHal->iMaxPalettes; i++) { pRenderHal->Palette[i].iPaletteID = i; pRenderHal->Palette[i].iNumEntries = 0; pRenderHal->Palette[i].pPaletteData = pRenderHal->pRenderHalPltInterface->GetPaletteDataAddress(i); } // Set default VFEState Params pVfeStateParams = pRenderHal->pRenderHalPltInterface->GetVfeStateParameters(); pVfeStateParams->dwDebugCounterControl = MEDIASTATE_DEBUG_COUNTER_FREE_RUNNING; pVfeStateParams->dwMaximumNumberofThreads = pRenderHal->pHwCaps->dwMaxThreads; // Hardware dependent calls pRenderHal->pfnGetSamplerOffsetAndPtr = RenderHal_GetSamplerOffsetAndPtr; pRenderHal->pfnSetupSurfaceState = RenderHal_SetupSurfaceState; pRenderHal->pfnEncodeSLMSize = RenderHal_EncodeSLMSize; pRenderHal->pfnSetChromaDirection = RenderHal_SetChromaDirection; pRenderHal->pfnEnableL3Caching = RenderHal_EnableL3Caching; pRenderHal->pfnSetCacheOverrideParams = RenderHal_SetCacheOverrideParams; // CM specific function pRenderHal->pfnConvertToNanoSeconds = RenderHal_ConvertToNanoSeconds; pRenderHal->pfnPerThreadScratchSpaceStart2K = RenderHal_PerThreadScratchSpaceStart2K; // Special functions RenderHal_InitInterfaceEx(pRenderHal); return eStatus; } //! //! \brief Set Surface for HW Access //! \details Common Function for setting up surface state //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to RenderHal Interface Structure //! \param PRENDERHAL_SURFACE pRenderHalSurface //! [in] Pointer to RenderHal Surface //! \param PRENDERHAL_SURFACE_STATE_PARAMS pSurfaceParams //! [in] Pointer to Surface Params //! \param int32_t iBindingTable //! [in] Binding Table to bind surface //! \param int32_t iBTEntry //! [in] Binding Table Entry index //! \param bool bWrite //! [in] Write mode flag //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success. Error code otherwise //! MOS_STATUS RenderHal_SetSurfaceForHwAccess( PRENDERHAL_INTERFACE pRenderHal, PRENDERHAL_SURFACE pRenderHalSurface, PRENDERHAL_SURFACE_STATE_PARAMS pSurfaceParams, int32_t iBindingTable, int32_t iBTEntry, bool bWrite) { PMOS_INTERFACE pOsInterface; PRENDERHAL_SURFACE_STATE_ENTRY pSurfaceEntries[MHW_MAX_SURFACE_PLANES]; int32_t iSurfaceEntries; int32_t i; MOS_STATUS eStatus; //--------------------------------------- MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface); //--------------------------------------- // Initialize Variables eStatus = MOS_STATUS_SUCCESS; pOsInterface = pRenderHal->pOsInterface; // Register surfaces for rendering (GfxAddress/Allocation index) // Register resource MHW_RENDERHAL_CHK_STATUS_RETURN(pOsInterface->pfnRegisterResource( pOsInterface, &pRenderHalSurface->OsSurface.OsResource, bWrite, true)); // Setup surface states----------------------------------------------------- MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pfnSetupSurfaceState( pRenderHal, pRenderHalSurface, pSurfaceParams, &iSurfaceEntries, pSurfaceEntries, nullptr)); // Bind surface states------------------------------------------------------ for (i = 0; i < iSurfaceEntries; i++, iBTEntry++) { MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pfnBindSurfaceState( pRenderHal, iBindingTable, iBTEntry, pSurfaceEntries[i])); } return eStatus; } //! //! \brief Set Buffer Surface for HW Access //! \details Common Function for setting up buffer surface state //! \param PRENDERHAL_INTERFACE pRenderHal //! [in] Pointer to RenderHal Interface Structure //! \param PRENDERHAL_SURFACE pRenderHalSurface //! [in] Pointer to RenderHal Surface //! \param PRENDERHAL_SURFACE_STATE_PARAMS pSurfaceParams //! [in] Pointer to Surface Params //! \param int32_t iBindingTable //! [in] Binding Table to Bind Surface //! \param int32_t iBTEntry //! [in] Binding Table Entry index //! \param bool bWrite //! Write mode flag //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success. Error code otherwise //! MOS_STATUS RenderHal_SetBufferSurfaceForHwAccess( PRENDERHAL_INTERFACE pRenderHal, PRENDERHAL_SURFACE pRenderHalSurface, PRENDERHAL_SURFACE_STATE_PARAMS pSurfaceParams, int32_t iBindingTable, int32_t iBTEntry, bool bWrite) { PMOS_INTERFACE pOsInterface; RENDERHAL_SURFACE_STATE_PARAMS SurfaceParam; PRENDERHAL_SURFACE_STATE_ENTRY pSurfaceEntry; MOS_STATUS eStatus; //--------------------------------------- MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal); MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface); //--------------------------------------- // Initialize Variables eStatus = MOS_STATUS_SUCCESS; pOsInterface = pRenderHal->pOsInterface; // Register surfaces for rendering (GfxAddress/Allocation index) // Register resource MHW_RENDERHAL_CHK_STATUS_RETURN(pOsInterface->pfnRegisterResource( pOsInterface, &pRenderHalSurface->OsSurface.OsResource, bWrite, true)); // Setup Buffer surface----------------------------------------------------- if (pSurfaceParams == nullptr) { MOS_ZeroMemory(&SurfaceParam, sizeof(SurfaceParam)); auto memObjCtrlState = pOsInterface->pfnGetResourceCachePolicyMemoryObject(pRenderHal->pOsInterface, &pRenderHalSurface->OsSurface.OsResource); SurfaceParam.MemObjCtl = memObjCtrlState.DwordValue; pSurfaceParams = &SurfaceParam; } MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pfnSetupBufferSurfaceState( pRenderHal, pRenderHalSurface, pSurfaceParams, &pSurfaceEntry)); // Bind surface state------------------------------------------------------- MHW_RENDERHAL_CHK_STATUS_RETURN(pRenderHal->pfnBindSurfaceState( pRenderHal, iBindingTable, iBTEntry, pSurfaceEntry)); return eStatus; }