1 /*===================== begin_copyright_notice ==================================
2 
3 # Copyright (c) 2021, Intel Corporation
4 
5 # Permission is hereby granted, free of charge, to any person obtaining a
6 # copy of this software and associated documentation files (the "Software"),
7 # to deal in the Software without restriction, including without limitation
8 # the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 # and/or sell copies of the Software, and to permit persons to whom the
10 # Software is furnished to do so, subject to the following conditions:
11 
12 # The above copyright notice and this permission notice shall be included
13 # in all copies or substantial portions of the Software.
14 
15 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
16 # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 # THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
19 # OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
20 # ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
21 # OTHER DEALINGS IN THE SOFTWARE.
22 
23 ======================= end_copyright_notice ==================================*/
24 
25 //!
26 //! \file     mhw_render_xe_hpg.cpp
27 //! \brief    Constructs render engine commands on Xe_HPG platforms
28 //! \details  Each client facing function both creates a HW command and adds
29 //!           that command to a command or batch buffer.
30 //!
31 
32 #include "mhw_render_xe_hpg.h"
33 
AddCfeStateCmd(PMOS_COMMAND_BUFFER cmdBuffer,PMHW_VFE_PARAMS params)34 MOS_STATUS MhwRenderInterfaceXe_Hpg::AddCfeStateCmd(
35     PMOS_COMMAND_BUFFER cmdBuffer,
36     PMHW_VFE_PARAMS params)
37 {
38     MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
39 
40     MHW_FUNCTION_ENTER;
41 
42     MHW_MI_CHK_NULL(m_osInterface);
43     MHW_MI_CHK_NULL(cmdBuffer);
44     MHW_MI_CHK_NULL(params);
45 
46     mhw_render_xe_xpm_base::CFE_STATE_CMD cmd;
47 
48     if (params->pKernelState)
49     {
50         MHW_MI_CHK_NULL(params->pKernelState);
51 
52         cmd.DW3.MaximumNumberOfThreads = (params->dwMaximumNumberofThreads) ?
53                                          params->dwMaximumNumberofThreads - 1 :
54                                          params->pKernelState->KernelParams.iThreadCount - 1;
55     }
56     else
57     {
58         cmd.DW3.MaximumNumberOfThreads = (params->dwMaximumNumberofThreads) ?
59                                          params->dwMaximumNumberofThreads - 1 :
60                                          m_hwCaps.dwMaxThreads - 1;
61     }
62 
63     MHW_VFE_PARAMS_G12 *paramsG12 = dynamic_cast<MHW_VFE_PARAMS_G12 *> (params);
64     if (paramsG12 != nullptr)
65     {
66         cmd.DW1_2.ScratchSpaceBuffer = paramsG12->scratchStateOffset >> 6;
67         cmd.DW3.FusedEuDispatch = false; // enabled Fused EU Mode
68         cmd.DW3.NumberOfWalkers = paramsG12->numOfWalkers;
69         cmd.DW3.SingleSliceDispatchCcsMode = paramsG12->enableSingleSliceDispatchCcsMode;
70     }
71     else
72     {
73         MHW_ASSERTMESSAGE("Gen12-Specific CFE Params are needed.");
74         return MOS_STATUS_INVALID_PARAMETER;
75     }
76 
77     MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, cmd.byteSize));
78 
79     return MOS_STATUS_SUCCESS;
80 }
81 
82 MOS_STATUS
AddComputeWalkerCmd(MOS_COMMAND_BUFFER * cmdBuffer,MHW_GPGPU_WALKER_PARAMS * gpgpuWalkerParams,MHW_ID_ENTRY_PARAMS * interfaceDescriptorParams,MOS_RESOURCE * postsyncResource,uint32_t resourceOffset)83 MhwRenderInterfaceXe_Hpg::AddComputeWalkerCmd(MOS_COMMAND_BUFFER *cmdBuffer,
84                                               MHW_GPGPU_WALKER_PARAMS *gpgpuWalkerParams,
85                                               MHW_ID_ENTRY_PARAMS *interfaceDescriptorParams,
86                                               MOS_RESOURCE *postsyncResource,
87                                               uint32_t resourceOffset)
88 {
89     MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
90 
91     MHW_FUNCTION_ENTER;
92 
93     MHW_MI_CHK_NULL(cmdBuffer);
94     MHW_MI_CHK_NULL(gpgpuWalkerParams);
95     MHW_MI_CHK_NULL(interfaceDescriptorParams);
96     MHW_MI_CHK_NULL(m_osInterface);
97     MHW_MI_CHK_NULL(m_osInterface->pfnGetPlatform);
98 
99     if (gpgpuWalkerParams->ThreadDepth == 0)
100     {
101         gpgpuWalkerParams->ThreadDepth = 1;
102     }
103     if (gpgpuWalkerParams->GroupDepth == 0)
104     {
105         gpgpuWalkerParams->GroupDepth = 1;
106     }
107 
108     mhw_render_xe_xpm_base::COMPUTE_WALKER_CMD cmd;
109     cmd.DW2.IndirectDataLength = gpgpuWalkerParams->IndirectDataLength;
110     cmd.DW3.IndirectDataStartAddress
111             = gpgpuWalkerParams->IndirectDataStartAddress >> MHW_COMPUTE_INDIRECT_SHIFT;
112 
113     cmd.DW4.SIMDSize = mhw_render_xe_xpm_base::COMPUTE_WALKER_CMD::SIMD_SIZE_SIMD32;
114     cmd.DW5.ExecutionMask = 0xffffffff;
115     cmd.DW6.LocalXMaximum = gpgpuWalkerParams->ThreadWidth - 1;
116     cmd.DW6.LocalYMaximum = gpgpuWalkerParams->ThreadHeight - 1;
117     cmd.DW6.LocalZMaximum = gpgpuWalkerParams->ThreadDepth - 1;
118     cmd.DW7.ThreadGroupIDXDimension = gpgpuWalkerParams->GroupWidth;
119     cmd.DW8.ThreadGroupIDYDimension = gpgpuWalkerParams->GroupHeight;
120     cmd.DW9.ThreadGroupIDZDimension = gpgpuWalkerParams->GroupDepth;
121     cmd.DW10.ThreadGroupIDStartingX = gpgpuWalkerParams->GroupStartingX;
122     cmd.DW11.ThreadGroupIDStartingY = gpgpuWalkerParams->GroupStartingY;
123     cmd.DW12.ThreadGroupIDStartingZ = gpgpuWalkerParams->GroupStartingZ;
124 
125     cmd.interface_descriptor_data.DW0_1.KernelStartPointer
126             = interfaceDescriptorParams->dwKernelOffset >> MHW_KERNEL_OFFSET_SHIFT;
127     cmd.interface_descriptor_data.DW3.SamplerCount = interfaceDescriptorParams->dwSamplerCount;
128     cmd.interface_descriptor_data.DW3.SamplerStatePointer
129             = interfaceDescriptorParams->dwSamplerOffset >> MHW_SAMPLER_SHIFT;
130     cmd.interface_descriptor_data.DW4.BindingTablePointer
131             = MOS_ROUNDUP_SHIFT(interfaceDescriptorParams->dwBindingTableOffset,
132                                 MHW_BINDING_TABLE_ID_SHIFT);
133 
134     cmd.interface_descriptor_data.DW5.NumberOfThreadsInGpgpuThreadGroup
135             = interfaceDescriptorParams->dwNumberofThreadsInGPGPUGroup;
136     cmd.interface_descriptor_data.DW5.SharedLocalMemorySize
137             = interfaceDescriptorParams->dwSharedLocalMemorySize;
138 
139     // when Barriers is not 0, the EU fusion will close.
140     // Assigns barrier count.
141     MHW_NORMALMESSAGE(" bBarrierEnable  = %d, block threads x=%d, y = %d", interfaceDescriptorParams->bBarrierEnable,
142         cmd.DW7.ThreadGroupIDXDimension, cmd.DW8.ThreadGroupIDYDimension);
143 
144     if (interfaceDescriptorParams->bBarrierEnable)
145     {   // Bits [28:30] represent the number of barriers on DG2.
146         cmd.interface_descriptor_data.DW5.Reserved188 = 1;
147     }
148 
149     if (nullptr != postsyncResource)
150     {
151         MHW_RESOURCE_PARAMS resourceParams;
152         MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
153         InitMocsParams(resourceParams, &cmd.postsync_data.DW0.Value, 5, 10);
154         resourceParams.presResource = postsyncResource;
155         resourceParams.pdwCmd = cmd.postsync_data.DW1_2.Value;
156         resourceParams.dwLocationInCmd = 24;
157         resourceParams.dwOffset = resourceOffset;
158         resourceParams.bIsWritable = true;
159         MHW_MI_CHK_STATUS(AddResourceToCmd(m_osInterface, cmdBuffer, &resourceParams));
160         cmd.postsync_data.DW0.Operation
161                 = mhw_render_xe_xpm_base::COMPUTE_WALKER_CMD::POSTSYNC_DATA_CMD
162                 ::POSTSYNC_OPERATION_WRITE_TIMESTAMP;
163     }
164 
165     MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, cmd.byteSize));
166     return eStatus;
167 }
168 
AddChromaKeyCmd(PMOS_COMMAND_BUFFER cmdBuffer,PMHW_CHROMAKEY_PARAMS params)169 MOS_STATUS MhwRenderInterfaceXe_Hpg::AddChromaKeyCmd(
170     PMOS_COMMAND_BUFFER             cmdBuffer,
171     PMHW_CHROMAKEY_PARAMS           params)
172 {
173     MHW_FUNCTION_ENTER;
174 
175     MHW_MI_CHK_NULL(cmdBuffer);
176     MHW_MI_CHK_NULL(params);
177     MHW_MI_CHK_NULL(m_osInterface);
178     MEDIA_WA_TABLE *pWaTable = m_osInterface->pfnGetWaTable(m_osInterface);
179     MHW_MI_CHK_NULL(pWaTable);
180     MOS_GPU_CONTEXT renderGpuContext = m_osInterface->pfnGetGpuContext(m_osInterface);
181 
182     // Program stalling pipecontrol with HDC pipeline flush enabled before programming 3DSTATE_CHROMA_KEY for CCS W/L.
183     if ((renderGpuContext == MOS_GPU_CONTEXT_COMPUTE)    ||
184         (renderGpuContext == MOS_GPU_CONTEXT_CM_COMPUTE) ||
185         (renderGpuContext == MOS_GPU_CONTEXT_COMPUTE_RA))
186     {
187         if (MEDIA_IS_WA(pWaTable, Wa_16011481064))
188         {
189             MHW_PIPE_CONTROL_PARAMS PipeControlParams;
190 
191             MOS_ZeroMemory(&PipeControlParams, sizeof(PipeControlParams));
192             PipeControlParams.dwFlushMode                   = MHW_FLUSH_WRITE_CACHE;
193             PipeControlParams.bGenericMediaStateClear       = true;
194             PipeControlParams.bIndirectStatePointersDisable = true;
195             PipeControlParams.bDisableCSStall               = false;
196             PipeControlParams.bHdcPipelineFlush             = true;
197             MHW_MI_CHK_STATUS(m_miInterface->AddPipeControl(cmdBuffer, nullptr, &PipeControlParams));
198         }
199     }
200 
201     mhw_render_xe_xpm_base::_3DSTATE_CHROMA_KEY_CMD cmd;
202     cmd.DW1.ChromakeyTableIndex = params->dwIndex;
203     cmd.DW2.ChromakeyLowValue   = params->dwLow;
204     cmd.DW3.ChromakeyHighValue  = params->dwHigh;
205 
206     MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, cmd.byteSize));
207 
208     return MOS_STATUS_SUCCESS;
209 }
210