Debian Codegraph @

media_driver/agnostic/gen8/hw/mhw_mi_g8_X.cpp

raw
1 /*
2 * Copyright (c) 2014-2018, Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included
12 * in all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 */
22 //!
23 //! \file mhw_mi_g8_X.cpp
24 //! \brief Constructs MI commands on Gen8-based platforms
25 //! \details Each client facing function both creates a HW command and adds
26 //! that command to a command or batch buffer.
27 //!
28
29 #include "mhw_mi_g8_X.h"
30 #include "mhw_mi_hwcmd_g8_X.h"
31 #include "mhw_mmio_g8.h"
32
33 MOS_STATUS MhwMiInterfaceG8::AddMiBatchBufferStartCmd(
34 PMOS_COMMAND_BUFFER cmdBuffer,
35 PMHW_BATCH_BUFFER batchBuffer)
36 {
37 MHW_FUNCTION_ENTER;
38
39 MHW_MI_CHK_NULL(m_osInterface);
40 MHW_MI_CHK_NULL(cmdBuffer);
41 MHW_MI_CHK_NULL(batchBuffer);
42
43 bool vcsEngineUsed =
44 MOS_VCS_ENGINE_USED(m_osInterface->pfnGetGpuContext(m_osInterface));
45
46 mhw_mi_g8_X::MI_BATCH_BUFFER_START_CMD cmd;
47 MHW_RESOURCE_PARAMS resourceParams;
48 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
49 resourceParams.presResource = &batchBuffer->OsResource;
50 resourceParams.dwOffset = batchBuffer->dwOffset;
51 resourceParams.pdwCmd = &(cmd.DW1.Value);
52 resourceParams.dwLocationInCmd = 1;
53 resourceParams.dwLsbNum = MHW_COMMON_MI_GENERAL_SHIFT;
54 resourceParams.HwCommandType = vcsEngineUsed ?
55 MOS_MI_BATCH_BUFFER_START : MOS_MI_BATCH_BUFFER_START_RCS;
56
57 MHW_MI_CHK_STATUS(AddResourceToCmd(
58 m_osInterface,
59 cmdBuffer,
60 &resourceParams));
61
62 // Set BB start
63 cmd.DW0.SecondLevelBatchBuffer = true;
64 cmd.DW0.AddressSpaceIndicator = !IsGlobalGttInUse();
65
66 // Send BB start command
67 MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, cmd.byteSize));
68
69 return MOS_STATUS_SUCCESS;
70 }
71
72 MOS_STATUS MhwMiInterfaceG8::AddMiConditionalBatchBufferEndCmd(
73 PMOS_COMMAND_BUFFER cmdBuffer,
74 PMHW_MI_CONDITIONAL_BATCH_BUFFER_END_PARAMS params)
75 {
76 MHW_FUNCTION_ENTER;
77
78 MHW_MI_CHK_NULL(m_osInterface);
79 MHW_MI_CHK_NULL(cmdBuffer);
80 MHW_MI_CHK_NULL(params);
81 MHW_MI_CHK_NULL(params->presSemaphoreBuffer);
82
83 // Case 1 - Batch buffer condition matches - If this is not present then conditional
84 // batch buffer will exit to ring with terminating CP.
85 // Case 2 - Batch buffer condition DOES NOT match - Although this will disable CP
86 // but after end of conditional batch buffer CP will be re-enabled.
87 MHW_MI_CHK_STATUS(m_cpInterface->AddEpilog(m_osInterface, cmdBuffer));
88
89 mhw_mi_g8_X::MI_CONDITIONAL_BATCH_BUFFER_END_CMD cmd;
90 cmd.DW0.UseGlobalGtt = IsGlobalGttInUse();
91 cmd.DW0.CompareSemaphore = 1; // CompareDataDword is always assumed to be set
92 cmd.DW1.CompareDataDword = params->dwValue;
93
94 MHW_RESOURCE_PARAMS resourceParams;
95 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
96 resourceParams.presResource = params->presSemaphoreBuffer;
97 resourceParams.dwOffset = params->dwOffset;
98 resourceParams.pdwCmd = &(cmd.DW2.Value);
99 resourceParams.dwLocationInCmd = 2;
100 resourceParams.dwLsbNum = MHW_COMMON_MI_CONDITIONAL_BATCH_BUFFER_END_SHIFT;
101 resourceParams.HwCommandType = MOS_MI_CONDITIONAL_BATCH_BUFFER_END;
102
103 MHW_MI_CHK_STATUS(AddResourceToCmd(
104 m_osInterface,
105 cmdBuffer,
106 &resourceParams));
107
108 // Send Conditional Batch Buffer End command
109 MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, cmd.byteSize));
110
111 //Re-enable CP for Case 2
112 MHW_MI_CHK_STATUS(m_cpInterface->AddProlog(m_osInterface, cmdBuffer));
113
114 return MOS_STATUS_SUCCESS;
115 }
116
117 MOS_STATUS MhwMiInterfaceG8::AddMediaStateFlush(
118 PMOS_COMMAND_BUFFER cmdBuffer,
119 PMHW_BATCH_BUFFER batchBuffer,
120 PMHW_MEDIA_STATE_FLUSH_PARAM params)
121 {
122 MHW_FUNCTION_ENTER;
123
124 mhw_mi_g8_X::MEDIA_STATE_FLUSH_CMD *cmd = nullptr;
125
126 if (cmdBuffer)
127 {
128 MHW_MI_CHK_NULL(cmdBuffer->pCmdPtr);
129 cmd = (mhw_mi_g8_X::MEDIA_STATE_FLUSH_CMD*)cmdBuffer->pCmdPtr;
130 }
131 else if (batchBuffer)
132 {
133 MHW_MI_CHK_NULL(batchBuffer->pData);
134 cmd = (mhw_mi_g8_X::MEDIA_STATE_FLUSH_CMD*)(batchBuffer->pData + batchBuffer->iCurrent);
135 }
136 else
137 {
138 MHW_ASSERTMESSAGE("No valid buffer to add the command to!");
139 return MOS_STATUS_INVALID_PARAMETER;
140 }
141
142 MHW_MI_CHK_STATUS(MhwMiInterfaceGeneric<mhw_mi_g8_X>::AddMediaStateFlush(cmdBuffer, batchBuffer, params));
143
144 mhw_mi_g8_X::MEDIA_STATE_FLUSH_CMD AddMediaStateFlushcmd;
145
146 if (params != nullptr)
147 {
148 AddMediaStateFlushcmd.DW1.FlushToGo = params->bFlushToGo;
149 AddMediaStateFlushcmd.DW1.InterfaceDescriptorOffset = params->ui8InterfaceDescriptorOffset;
150 }
151
152 MHW_MI_CHK_STATUS(Mhw_AddCommandCmdOrBB(m_osInterface, cmdBuffer, batchBuffer, &AddMediaStateFlushcmd, AddMediaStateFlushcmd.byteSize));
153
154 #if (_DEBUG || _RELEASE_INTERNAL)
155 if (batchBuffer)
156 {
157 batchBuffer->iLastCurrent = batchBuffer->iCurrent;
158 }
159 #endif
160
161 auto waTable = m_osInterface->pfnGetWaTable(m_osInterface);
162 MHW_MI_CHK_NULL(waTable);
163 MHW_MI_CHK_NULL(cmd);
164
165 if (MEDIA_IS_WA(waTable, WaMSFWithNoWatermarkTSGHang))
166 {
167 cmd->DW1.WatermarkRequired = 0;
168 cmd->DW1.FlushToGo = 1;
169 }
170
171 return MOS_STATUS_SUCCESS;
172 }
173
174 void MhwMiInterfaceG8::InitMmioRegisters()
175 {
176 MHW_MI_MMIOREGISTERS *mmioRegisters = &m_mmioRegisters;
177
178 mmioRegisters->generalPurposeRegister0LoOffset = GP_REGISTER0_LO_OFFSET_G8;
179 mmioRegisters->generalPurposeRegister0HiOffset = GP_REGISTER0_HI_OFFSET_G8;
180 mmioRegisters->generalPurposeRegister4LoOffset = GP_REGISTER4_LO_OFFSET_G8;
181 mmioRegisters->generalPurposeRegister4HiOffset = GP_REGISTER4_HI_OFFSET_G8;
182 mmioRegisters->generalPurposeRegister11LoOffset = GP_REGISTER11_LO_OFFSET_G8;
183 mmioRegisters->generalPurposeRegister11HiOffset = GP_REGISTER11_HI_OFFSET_G8;
184 mmioRegisters->generalPurposeRegister12LoOffset = GP_REGISTER12_LO_OFFSET_G8;
185 mmioRegisters->generalPurposeRegister12HiOffset = GP_REGISTER12_HI_OFFSET_G8;
186 }
187
188 MOS_STATUS MhwMiInterfaceG8::SkipMiBatchBufferEndBb(
189 PMHW_BATCH_BUFFER batchBuffer)
190 {
191 MHW_FUNCTION_ENTER;
192
193 MHW_MI_CHK_STATUS(MhwMiInterfaceGeneric<mhw_mi_g8_X>::SkipMiBatchBufferEndBb(batchBuffer));
194
195 auto waTable = m_osInterface->pfnGetWaTable(m_osInterface);
196 MHW_MI_CHK_NULL(waTable);
197
198 // This WA does not apply for video or other engines, render requirement only
199 bool isRender =
200 MOS_RCS_ENGINE_USED(m_osInterface->pfnGetGpuContext(m_osInterface));
201
202 if (isRender && (MEDIA_IS_WA(waTable, WaMSFWithNoWatermarkTSGHang) ||
203 MEDIA_IS_WA(waTable, WaAddMediaStateFlushCmd)))
204 {
205 mhw_mi_g8_X::MEDIA_STATE_FLUSH_CMD FlushCmd;
206 MHW_MI_CHK_STATUS(Mhw_AddCommandBB(
207 batchBuffer,
208 nullptr,
209 FlushCmd.byteSize));
210 }
211
212 mhw_mi_g8_X::MI_BATCH_BUFFER_END_CMD cmd;
213 MHW_MI_CHK_STATUS(Mhw_AddCommandBB(
214 batchBuffer,
215 nullptr,
216 cmd.byteSize));
217
218 return MOS_STATUS_SUCCESS;
219 }
220
221 MOS_STATUS MhwMiInterfaceG8::AddMiFlushDwCmd(
222 PMOS_COMMAND_BUFFER cmdBuffer,
223 PMHW_MI_FLUSH_DW_PARAMS params)
224 {
225 MHW_FUNCTION_ENTER;
226
227 MHW_MI_CHK_NULL(m_osInterface);
228 MHW_MI_CHK_STATUS(MhwMiInterfaceGeneric<mhw_mi_g8_X>::AddMiFlushDwCmd(cmdBuffer, params));
229
230 mhw_mi_g8_X::MI_FLUSH_DW_CMD cmd;
231
232 // set the protection bit based on CP status
233 MHW_MI_CHK_STATUS(m_cpInterface->SetProtectionSettingsForMiFlushDw(m_osInterface, &cmd));
234
235 cmd.DW0.VideoPipelineCacheInvalidate = params->bVideoPipelineCacheInvalidate;
236 cmd.DW0.PostSyncOperation = cmd.POST_SYNC_OPERATION_NOWRITE;
237 cmd.DW3_4.Value[0] = params->dwDataDW1;
238
239 if (params->pOsResource)
240 {
241 cmd.DW0.PostSyncOperation = cmd.POST_SYNC_OPERATION_WRITEIMMEDIATEDATA;
242 cmd.DW1_2.DestinationAddressType = UseGlobalGtt.m_vcs;
243
244 MHW_RESOURCE_PARAMS resourceParams;
245 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
246 resourceParams.presResource = params->pOsResource;
247 resourceParams.dwOffset = params->dwResourceOffset;
248 resourceParams.pdwCmd = cmd.DW1_2.Value;
249 resourceParams.dwLocationInCmd = 1;
250 resourceParams.dwLsbNum = MHW_COMMON_MI_FLUSH_DW_SHIFT;
251 resourceParams.HwCommandType = MOS_MI_FLUSH_DW;
252 resourceParams.bIsWritable = true;
253
254 MHW_MI_CHK_STATUS(AddResourceToCmd(
255 m_osInterface,
256 cmdBuffer,
257 &resourceParams));
258 }
259
260 if (params->postSyncOperation)
261 {
262 cmd.DW0.PostSyncOperation = params->postSyncOperation;
263 }
264
265 if (params->dwDataDW2 || params->bQWordEnable)
266 {
267 cmd.DW3_4.Value[1] = params->dwDataDW2;
268 }
269 else
270 {
271 cmd.DW0.DwordLength--;
272 }
273
274 MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, cmd.byteSize));
275
276 return MOS_STATUS_SUCCESS;
277 }