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(cmdBuffer);
43     MHW_MI_CHK_NULL(params);
44 
45     mhw_render_xe_xpm_base::CFE_STATE_CMD cmd;
46 
47     if (params->pKernelState)
48     {
49         MHW_MI_CHK_NULL(params->pKernelState);
50 
51         cmd.DW3.MaximumNumberOfThreads = (params->dwMaximumNumberofThreads) ?
52                                          params->dwMaximumNumberofThreads - 1 :
53                                          params->pKernelState->KernelParams.iThreadCount - 1;
54     }
55     else
56     {
57         cmd.DW3.MaximumNumberOfThreads = (params->dwMaximumNumberofThreads) ?
58                                          params->dwMaximumNumberofThreads - 1 :
59                                          m_hwCaps.dwMaxThreads - 1;
60     }
61 
62     MHW_VFE_PARAMS_G12 *paramsG12 = dynamic_cast<MHW_VFE_PARAMS_G12 *> (params);
63     if (paramsG12 != nullptr)
64     {
65         cmd.DW1_2.ScratchSpaceBuffer = paramsG12->scratchStateOffset >> 6;
66         cmd.DW3.FusedEuDispatch = false; // enabled Fused EU Mode
67         cmd.DW3.NumberOfWalkers = paramsG12->numOfWalkers;
68         cmd.DW3.SingleSliceDispatchCcsMode = paramsG12->enableSingleSliceDispatchCcsMode;
69     }
70     else
71     {
72         MHW_ASSERTMESSAGE("Gen12-Specific CFE Params are needed.");
73         return MOS_STATUS_INVALID_PARAMETER;
74     }
75 
76     MHW_MI_CHK_STATUS(Mos_AddCommand(cmdBuffer, &cmd, cmd.byteSize));
77 
78     return MOS_STATUS_SUCCESS;
79 }
80 
81 MOS_STATUS
AddComputeWalkerCmd(MOS_COMMAND_BUFFER * cmdBuffer,MHW_GPGPU_WALKER_PARAMS * gpgpuWalkerParams,MHW_ID_ENTRY_PARAMS * interfaceDescriptorParams,MOS_RESOURCE * postsyncResource,uint32_t resourceOffset)82 MhwRenderInterfaceXe_Hpg::AddComputeWalkerCmd(MOS_COMMAND_BUFFER *cmdBuffer,
83                                               MHW_GPGPU_WALKER_PARAMS *gpgpuWalkerParams,
84                                               MHW_ID_ENTRY_PARAMS *interfaceDescriptorParams,
85                                               MOS_RESOURCE *postsyncResource,
86                                               uint32_t resourceOffset)
87 {
88     MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
89 
90     MHW_FUNCTION_ENTER;
91 
92     MHW_MI_CHK_NULL(cmdBuffer);
93     MHW_MI_CHK_NULL(gpgpuWalkerParams);
94     MHW_MI_CHK_NULL(interfaceDescriptorParams);
95     MHW_MI_CHK_NULL(m_osInterface);
96     MHW_MI_CHK_NULL(m_osInterface->pfnGetPlatform);
97 
98     if (gpgpuWalkerParams->ThreadDepth == 0)
99     {
100         gpgpuWalkerParams->ThreadDepth = 1;
101     }
102     if (gpgpuWalkerParams->GroupDepth == 0)
103     {
104         gpgpuWalkerParams->GroupDepth = 1;
105     }
106 
107     mhw_render_xe_xpm_base::COMPUTE_WALKER_CMD cmd;
108     cmd.DW2.IndirectDataLength = gpgpuWalkerParams->IndirectDataLength;
109     cmd.DW3.IndirectDataStartAddress
110             = gpgpuWalkerParams->IndirectDataStartAddress >> MHW_COMPUTE_INDIRECT_SHIFT;
111 
112     cmd.DW4.SIMDSize = mhw_render_xe_xpm_base::COMPUTE_WALKER_CMD::SIMD_SIZE_SIMD32;
113     cmd.DW5.ExecutionMask = 0xffffffff;
114     cmd.DW6.LocalXMaximum = gpgpuWalkerParams->ThreadWidth - 1;
115     cmd.DW6.LocalYMaximum = gpgpuWalkerParams->ThreadHeight - 1;
116     cmd.DW6.LocalZMaximum = gpgpuWalkerParams->ThreadDepth - 1;
117     cmd.DW7.ThreadGroupIDXDimension = gpgpuWalkerParams->GroupWidth;
118     cmd.DW8.ThreadGroupIDYDimension = gpgpuWalkerParams->GroupHeight;
119     cmd.DW9.ThreadGroupIDZDimension = gpgpuWalkerParams->GroupDepth;
120     cmd.DW10.ThreadGroupIDStartingX = gpgpuWalkerParams->GroupStartingX;
121     cmd.DW11.ThreadGroupIDStartingY = gpgpuWalkerParams->GroupStartingY;
122     cmd.DW12.ThreadGroupIDStartingZ = gpgpuWalkerParams->GroupStartingZ;
123 
124     cmd.interface_descriptor_data.DW0_1.KernelStartPointer
125             = interfaceDescriptorParams->dwKernelOffset >> MHW_KERNEL_OFFSET_SHIFT;
126     cmd.interface_descriptor_data.DW3.SamplerCount = interfaceDescriptorParams->dwSamplerCount;
127     cmd.interface_descriptor_data.DW3.SamplerStatePointer
128             = interfaceDescriptorParams->dwSamplerOffset >> MHW_SAMPLER_SHIFT;
129     cmd.interface_descriptor_data.DW4.BindingTablePointer
130             = MOS_ROUNDUP_SHIFT(interfaceDescriptorParams->dwBindingTableOffset,
131                                 MHW_BINDING_TABLE_ID_SHIFT);
132 
133     cmd.interface_descriptor_data.DW5.NumberOfThreadsInGpgpuThreadGroup
134             = interfaceDescriptorParams->dwNumberofThreadsInGPGPUGroup;
135     cmd.interface_descriptor_data.DW5.SharedLocalMemorySize
136             = interfaceDescriptorParams->dwSharedLocalMemorySize;
137 
138     // when Barriers is not 0, the EU fusion will close.
139     // Assigns barrier count.
140     MHW_NORMALMESSAGE(" bBarrierEnable  = %d", interfaceDescriptorParams->bBarrierEnable);
141     if (interfaceDescriptorParams->bBarrierEnable)
142     {   // Bits [28:30] represent the number of barriers on DG2.
143         cmd.interface_descriptor_data.DW5.Reserved188 = 1;
144     }
145 
146     if (nullptr != postsyncResource)
147     {
148         MHW_RESOURCE_PARAMS resourceParams;
149         MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
150         InitMocsParams(resourceParams, &cmd.postsync_data.DW0.Value, 5, 10);
151         resourceParams.presResource = postsyncResource;
152         resourceParams.pdwCmd = cmd.postsync_data.DW1_2.Value;
153         resourceParams.dwLocationInCmd = 24;
154         resourceParams.dwOffset = resourceOffset;
155         resourceParams.bIsWritable = true;
156         MHW_MI_CHK_STATUS(AddResourceToCmd(m_osInterface, cmdBuffer, &resourceParams));
157         cmd.postsync_data.DW0.Operation
158                 = mhw_render_xe_xpm_base::COMPUTE_WALKER_CMD::POSTSYNC_DATA_CMD
159                 ::POSTSYNC_OPERATION_WRITE_TIMESTAMP;
160     }
161 
162     MHW_MI_CHK_STATUS(Mos_AddCommand(cmdBuffer, &cmd, cmd.byteSize));
163     return eStatus;
164 }
165 
AddChromaKeyCmd(PMOS_COMMAND_BUFFER cmdBuffer,PMHW_CHROMAKEY_PARAMS params)166 MOS_STATUS MhwRenderInterfaceXe_Hpg::AddChromaKeyCmd(
167     PMOS_COMMAND_BUFFER             cmdBuffer,
168     PMHW_CHROMAKEY_PARAMS           params)
169 {
170     MHW_FUNCTION_ENTER;
171 
172     MHW_MI_CHK_NULL(cmdBuffer);
173     MHW_MI_CHK_NULL(params);
174     MHW_MI_CHK_NULL(m_osInterface);
175     MEDIA_WA_TABLE *pWaTable = m_osInterface->pfnGetWaTable(m_osInterface);
176     MHW_MI_CHK_NULL(pWaTable);
177     MOS_GPU_CONTEXT renderGpuContext = m_osInterface->pfnGetGpuContext(m_osInterface);
178 
179     // Program stalling pipecontrol with HDC pipeline flush enabled before programming 3DSTATE_CHROMA_KEY for CCS W/L.
180     if ((renderGpuContext == MOS_GPU_CONTEXT_COMPUTE)    ||
181         (renderGpuContext == MOS_GPU_CONTEXT_CM_COMPUTE) ||
182         (renderGpuContext == MOS_GPU_CONTEXT_COMPUTE_RA))
183     {
184         if (MEDIA_IS_WA(pWaTable, Wa_16011481064))
185         {
186             MHW_PIPE_CONTROL_PARAMS PipeControlParams;
187 
188             MOS_ZeroMemory(&PipeControlParams, sizeof(PipeControlParams));
189             PipeControlParams.dwFlushMode                   = MHW_FLUSH_WRITE_CACHE;
190             PipeControlParams.bGenericMediaStateClear       = true;
191             PipeControlParams.bIndirectStatePointersDisable = true;
192             PipeControlParams.bDisableCSStall               = false;
193             PipeControlParams.bHdcPipelineFlush             = true;
194             MHW_MI_CHK_STATUS(m_miInterface->AddPipeControl(cmdBuffer, nullptr, &PipeControlParams));
195         }
196     }
197 
198     mhw_render_xe_xpm_base::_3DSTATE_CHROMA_KEY_CMD cmd;
199     cmd.DW1.ChromakeyTableIndex = params->dwIndex;
200     cmd.DW2.ChromakeyLowValue   = params->dwLow;
201     cmd.DW3.ChromakeyHighValue  = params->dwHigh;
202 
203     MHW_MI_CHK_STATUS(Mos_AddCommand(cmdBuffer, &cmd, cmd.byteSize));
204 
205     return MOS_STATUS_SUCCESS;
206 }
207