Debian Codegraph @

media_softlet/agnostic/common/hw/vdbox/mhw_vdbox_huc_impl.h

raw
1 /*
2 * Copyright (c) 2021, 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_vdbox_huc_impl.h
24 //! \brief MHW VDBOX HUC interface common base
25 //! \details
26 //!
27
28 #ifndef __MHW_VDBOX_HUC_IMPL_H__
29 #define __MHW_VDBOX_HUC_IMPL_H__
30
31 #include "mhw_vdbox_huc_itf.h"
32 #include "mhw_impl.h"
33
34 namespace mhw
35 {
36 namespace vdbox
37 {
38 namespace huc
39 {
40 static constexpr uint32_t MEMORY_ADDRESS_ATTRIBUTES_MOCS_CLEAN_MASK = 0xFFFFFF81;
41
42 static constexpr uint32_t HUC_UKERNEL_HDR_INFO_REG_OFFSET_NODE_1_INIT = 0x1C2014;
43 static constexpr uint32_t HUC_STATUS_REG_OFFSET_NODE_1_INIT = 0x1C2000;
44 static constexpr uint32_t HUC_STATUS2_REG_OFFSET_NODE_1_INIT = 0x1C23B0;
45 static constexpr uint32_t HUC_LOAD_INFO_REG_OFFSET_NODE_1_INIT = 0xC1DC;
46
47 template <typename cmd_t>
48 class Impl : public Itf, public mhw::Impl
49 {
50 _HUC_CMD_DEF(_MHW_CMD_ALL_DEF_FOR_IMPL);
51
52 public:
53 MOS_STATUS SetCacheabilitySettings(MHW_MEMORY_OBJECT_CONTROL_PARAMS settings[MOS_CODEC_RESOURCE_USAGE_END_CODEC]) override
54 {
55 MHW_FUNCTION_ENTER;
56
57 MHW_CHK_NULL_RETURN(settings);
58
59 size_t size = MOS_CODEC_RESOURCE_USAGE_END_CODEC * sizeof(MHW_MEMORY_OBJECT_CONTROL_PARAMS);
60
61 return MOS_SecureMemcpy(m_cacheabilitySettings, size, settings, size);
62 }
63
64 //!
65 //! \brief Get mmio registers
66 //!
67 //! \param [in] index
68 //! mmio registers index.
69 //!
70 //! \return [out] MmioRegistersHuc*
71 //! mmio registers got.
72 //!
73 HucMmioRegisters* GetMmioRegisters(MHW_VDBOX_NODE_IND index) override
74 {
75 MHW_FUNCTION_ENTER;
76
77 if (index < MHW_VDBOX_NODE_MAX)
78 {
79 return &m_mmioRegisters[index];
80 }
81 else
82 {
83 MHW_ASSERT("index is out of range!");
84 return &m_mmioRegisters[MHW_VDBOX_NODE_1];
85 }
86 }
87
88 private:
89 void InitMmioRegisters()
90 {
91 MHW_FUNCTION_ENTER;
92
93 HucMmioRegisters *mmioRegisters = &m_mmioRegisters[MHW_VDBOX_NODE_1];
94
95 mmioRegisters->hucUKernelHdrInfoRegOffset = HUC_UKERNEL_HDR_INFO_REG_OFFSET_NODE_1_INIT;
96 mmioRegisters->hucStatusRegOffset = HUC_STATUS_REG_OFFSET_NODE_1_INIT;
97 mmioRegisters->hucStatus2RegOffset = HUC_STATUS2_REG_OFFSET_NODE_1_INIT;
98 mmioRegisters->hucLoadInfoOffset = HUC_LOAD_INFO_REG_OFFSET_NODE_1_INIT;
99
100 m_mmioRegisters[MHW_VDBOX_NODE_2] = m_mmioRegisters[MHW_VDBOX_NODE_1];
101 }
102
103 uint32_t GetHucStatusReEncodeMask() override
104 {
105 return m_hucStatusReEncodeMask;
106 }
107
108 uint32_t GetHucStatusHevcS2lFailureMask() override
109 {
110 return m_hucStatusHevcS2lFailureMask;
111 }
112
113 uint32_t GetHucStatus2ImemLoadedMask() override
114 {
115 return m_hucStatus2ImemLoadedMask;
116 }
117
118 uint32_t GetHucErrorFlagsMask() override
119 {
120 return m_hucErrorFlagsMask;
121 }
122
123 uint32_t GetHucProductFamily() override
124 {
125 return m_hucFamily;
126 }
127
128 protected:
129 using base_t = Itf;
130 HucMmioRegisters m_mmioRegisters[MHW_VDBOX_NODE_MAX] = {}; //!< HuC mmio registers
131 MhwCpInterface *m_cpItf = nullptr;
132 static const uint32_t m_hucStatusReEncodeMask = 0x80000000;
133 static const uint32_t m_hucStatusHevcS2lFailureMask = 0x8000;
134 static const uint32_t m_hucStatus2ImemLoadedMask = 0x40;
135 static const uint32_t m_hucErrorFlagsMask = 0xFFFE; //!< HuC error 2 flags mask
136 static const uint32_t m_hucFamily = 8;
137
138 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_END_CODEC] = {};
139
140 Impl(PMOS_INTERFACE osItf, MhwCpInterface *cpItf) : mhw::Impl(osItf)
141 {
142 m_cpItf = cpItf;
143
144 InitMmioRegisters();
145 }
146
147 _MHW_SETCMD_OVERRIDE_DECL(HUC_PIPE_MODE_SELECT)
148 {
149 _MHW_SETCMD_CALLBASE(HUC_PIPE_MODE_SELECT);
150
151 if (!params.disableProtectionSetting)
152 {
153 MHW_MI_CHK_STATUS(m_cpItf->SetProtectionSettingsForHucPipeModeSelect((uint32_t *)&cmd));
154 }
155
156 #define DO_FIELDS() \
157 DO_FIELD(DW1, IndirectStreamOutEnable, params.streamOutEnabled ? 1 : 0); \
158 DO_FIELD(DW2, MediaSoftResetCounterPer1000Clocks, params.mediaSoftResetCounterValue);
159
160 #include "mhw_hwcmd_process_cmdfields.h"
161 }
162
163 _MHW_SETCMD_OVERRIDE_DECL(HUC_IND_OBJ_BASE_ADDR_STATE)
164 {
165 _MHW_SETCMD_CALLBASE(HUC_IND_OBJ_BASE_ADDR_STATE);
166
167 MHW_RESOURCE_PARAMS resourceParams = {};
168
169 resourceParams.dwLsbNum = MHW_VDBOX_HUC_UPPER_BOUND_STATE_SHIFT;
170 resourceParams.dwUpperBoundLocationOffsetFromCmd = 3;
171 resourceParams.HwCommandType = MOS_HUC_IND_OBJ_BASE_ADDR;
172
173 if (!Mos_ResourceIsNull(params.DataBuffer))
174 {
175 resourceParams.presResource = params.DataBuffer;
176 resourceParams.dwOffset = params.DataOffset;
177 resourceParams.pdwCmd = cmd.HucIndirectStreamInObjectbaseAddress.DW0_1.Value;
178 resourceParams.dwLocationInCmd = 1;
179 resourceParams.bIsWritable = false;
180 resourceParams.dwSize = params.DataSize;
181
182 InitMocsParams(resourceParams, &cmd.HucIndirectStreamInObjectbaseAttributes.DW0.Value, 1, 6);
183
184 MHW_MI_CHK_STATUS(AddResourceToCmd(
185 this->m_osItf,
186 this->m_currentCmdBuf,
187 &resourceParams));
188 }
189
190 if (!Mos_ResourceIsNull(params.StreamOutObjectBuffer))
191 {
192 resourceParams.presResource = params.StreamOutObjectBuffer;
193 resourceParams.dwOffset = params.StreamOutObjectOffset;
194 resourceParams.pdwCmd = cmd.HucIndirectStreamOutObjectbaseAddress.DW0_1.Value;
195 resourceParams.dwLocationInCmd = 6;
196 resourceParams.bIsWritable = true;
197 resourceParams.dwSize = params.StreamOutObjectSize;
198
199 InitMocsParams(resourceParams, &cmd.HucIndirectStreamOutObjectbaseAttributes.DW0.Value, 1, 6);
200
201 MHW_MI_CHK_STATUS(AddResourceToCmd(
202 this->m_osItf,
203 this->m_currentCmdBuf,
204 &resourceParams));
205 }
206
207 return MOS_STATUS_SUCCESS;
208 }
209
210 _MHW_SETCMD_OVERRIDE_DECL(HUC_STREAM_OBJECT)
211 {
212 _MHW_SETCMD_CALLBASE(HUC_STREAM_OBJECT);
213 #define DO_FIELDS() \
214 DO_FIELD(DW1, IndirectStreamInDataLength, params.IndirectStreamInDataLength); \
215 DO_FIELD(DW2, IndirectStreamInStartAddress, params.IndirectStreamInStartAddress); \
216 DO_FIELD(DW2, HucProcessing, params.HucProcessing); \
217 DO_FIELD(DW3, IndirectStreamOutStartAddress, params.IndirectStreamOutStartAddress); \
218 DO_FIELD(DW4, HucBitstreamEnable, params.HucBitstreamEnable); \
219 DO_FIELD(DW4, StreamOut, params.StreamOut); \
220 DO_FIELD(DW4, EmulationPreventionByteRemoval, params.EmulationPreventionByteRemoval); \
221 DO_FIELD(DW4, StartCodeSearchEngine, params.StartCodeSearchEngine); \
222 DO_FIELD(DW4, Drmlengthmode, params.Drmlengthmode); \
223 DO_FIELD(DW4, StartCodeByte2, params.StartCodeByte2); \
224 DO_FIELD(DW4, StartCodeByte1, params.StartCodeByte1); \
225 DO_FIELD(DW4, StartCodeByte0, params.StartCodeByte0);
226
227 #include "mhw_hwcmd_process_cmdfields.h"
228 }
229
230 _MHW_SETCMD_OVERRIDE_DECL(HUC_IMEM_STATE)
231 {
232 _MHW_SETCMD_CALLBASE(HUC_IMEM_STATE);
233
234 #define DO_FIELDS() \
235 DO_FIELD(DW4, HucFirmwareDescriptor, params.kernelDescriptor);
236
237 #include "mhw_hwcmd_process_cmdfields.h"
238 }
239
240 _MHW_SETCMD_OVERRIDE_DECL(HUC_DMEM_STATE)
241 {
242 _MHW_SETCMD_CALLBASE(HUC_DMEM_STATE);
243
244 MHW_RESOURCE_PARAMS resourceParams = {};
245 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
246 resourceParams.dwLsbNum = MHW_VDBOX_HUC_GENERAL_STATE_SHIFT;
247 resourceParams.HwCommandType = MOS_HUC_DMEM;
248
249 if (!Mos_ResourceIsNull(params.hucDataSource))
250 {
251 resourceParams.presResource = params.hucDataSource;
252 resourceParams.dwOffset = 0;
253 resourceParams.pdwCmd = (cmd.HucDataSourceBaseAddress.DW0_1.Value);
254 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(HucDataSourceBaseAddress);
255 resourceParams.bIsWritable = false;
256
257 InitMocsParams(resourceParams, &cmd.HucDataSourceAttributes.DW0.Value, 1, 6);
258
259 MHW_MI_CHK_STATUS(AddResourceToCmd(
260 this->m_osItf,
261 this->m_currentCmdBuf,
262 &resourceParams));
263
264 // set HuC data destination address
265 cmd.DW4.HucDataDestinationBaseAddress = params.dmemOffset >> MHW_VDBOX_HUC_GENERAL_STATE_SHIFT;
266
267 // set data length
268 cmd.DW5.HucDataLength = params.dataLength >> MHW_VDBOX_HUC_GENERAL_STATE_SHIFT;
269 }
270 return MOS_STATUS_SUCCESS;
271 }
272
273 _MHW_SETCMD_OVERRIDE_DECL(HUC_VIRTUAL_ADDR_STATE)
274 {
275 _MHW_SETCMD_CALLBASE(HUC_VIRTUAL_ADDR_STATE);
276
277 MHW_RESOURCE_PARAMS resourceParams = {};
278
279 // set up surface 0~15
280 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
281 resourceParams.dwLsbNum = MHW_VDBOX_HUC_UPPER_BOUND_STATE_SHIFT;
282 resourceParams.HwCommandType = MOS_HUC_VIRTUAL_ADDR;
283
284 for (int i = 0; i < 16; i++)
285 {
286 if (params.regionParams[i].presRegion)
287 {
288 resourceParams.presResource = params.regionParams[i].presRegion;
289 resourceParams.dwOffset = params.regionParams[i].dwOffset;
290 resourceParams.bIsWritable = params.regionParams[i].isWritable;
291 resourceParams.pdwCmd = cmd.HucVirtualAddressRegion[i].HucSurfaceBaseAddressVirtualaddrregion015.DW0_1.Value;
292 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(HucVirtualAddressRegion[i].HucSurfaceBaseAddressVirtualaddrregion015);
293
294 InitMocsParams(resourceParams, &cmd.HucVirtualAddressRegion[i].HucSurfaceVirtualaddrregion015.DW0.Value, 1, 6);
295
296 MHW_MI_CHK_STATUS(AddResourceToCmd(
297 this->m_osItf,
298 this->m_currentCmdBuf,
299 &resourceParams));
300 }
301 }
302 return MOS_STATUS_SUCCESS;
303 }
304
305 _MHW_SETCMD_OVERRIDE_DECL(HUC_START)
306 {
307 _MHW_SETCMD_CALLBASE(HUC_START);
308
309 #define DO_FIELDS() \
310 DO_FIELD(DW1, Laststreamobject, params.lastStreamObject ? 1 : 0);
311
312 #include "mhw_hwcmd_process_cmdfields.h"
313 }
314 MEDIA_CLASS_DEFINE_END(mhw__vdbox__huc__Impl)
315 };
316 } // namespace huc
317 } // namespace vdbox
318 } // namespace mhw
319
320 #endif // __MHW_VDBOX_HUC_IMPL_H__