Debian Codegraph @

media_softlet/agnostic/common/hw/mhw_utilities_next.h

raw
1 /*
2 * Copyright (c) 2021-2025, 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_utilities_next.h
24 //! \brief This modules implements utilities which are shared by both the HW interface and the state heap interface.
25 //!
26 #ifndef __MHW_UTILITIES_NEXT_H__
27 #define __MHW_UTILITIES_NEXT_H__
28
29 #include <memory>
30 #include "mos_defs.h"
31 #include "mos_os.h"
32 #include "mos_util_debug.h"
33 #include "mhw_mmio.h"
34 #include "mos_os_hw.h"
35 #include "mos_os_specific.h"
36 #include "mos_resource_defs.h"
37 #include "mos_utilities.h"
38 struct _MHW_BATCH_BUFFER;
39
40 typedef struct _MHW_RCS_SURFACE_PARAMS MHW_RCS_SURFACE_PARAMS, * PMHW_RCS_SURFACE_PARAMS;
41 typedef struct _MHW_BATCH_BUFFER MHW_BATCH_BUFFER, * PMHW_BATCH_BUFFER;
42
43 #define MHW_CACHELINE_SIZE 64
44 #define MHW_PAGE_SIZE 0x1000
45
46 #define MHW_TIMEOUT_MS_DEFAULT 1000
47 #define MHW_EVENT_TIMEOUT_MS 5
48
49 #define MHW_WIDTH_IN_DW(w) ((w + 0x3) >> 2)
50
51 #define MHW_AVS_TBL_COEF_PREC 6 //!< Table coef precision (after decimal point
52 #define MHW_TABLE_PHASE_PREC 5
53 #define MHW_TABLE_PHASE_COUNT (1 << MHW_TABLE_PHASE_PREC)
54 #define MHW_SCALER_UV_WIN_SIZE 4
55 #define MHW_TBL_COEF_PREC 6
56
57 #define NUM_HW_POLYPHASE_TABLES 32 //!< must be the same as NUM_HW_POLYPHASE_TABLES_G9
58 #define NUM_POLYPHASE_TABLES 32
59 #define NUM_POLYPHASE_Y_ENTRIES 8
60 #define NUM_POLYPHASE_5x5_Y_ENTRIES 5
61 #define NUM_POLYPHASE_UV_ENTRIES 4
62
63 #define NUM_HW_POLYPHASE_TABLES_G8 17
64 #define POLYPHASE_Y_COEFFICIENT_TABLE_SIZE_G8 (NUM_POLYPHASE_Y_ENTRIES * NUM_HW_POLYPHASE_TABLES_G8 * sizeof(int32_t))
65 #define POLYPHASE_UV_COEFFICIENT_TABLE_SIZE_G8 (NUM_POLYPHASE_UV_ENTRIES * NUM_HW_POLYPHASE_TABLES_G8 * sizeof(int32_t))
66
67 #define NUM_HW_POLYPHASE_TABLES_G9 32
68 #define POLYPHASE_Y_COEFFICIENT_TABLE_SIZE_G9 (NUM_POLYPHASE_Y_ENTRIES * NUM_HW_POLYPHASE_TABLES_G9 * sizeof(int32_t))
69 #define POLYPHASE_UV_COEFFICIENT_TABLE_SIZE_G9 (NUM_POLYPHASE_UV_ENTRIES * NUM_HW_POLYPHASE_TABLES_G9 * sizeof(int32_t))
70
71 #define NUM_HW_POLYPHASE_TABLES_G10 32
72 #define POLYPHASE_Y_COEFFICIENT_TABLE_SIZE_G10 (NUM_POLYPHASE_Y_ENTRIES * NUM_HW_POLYPHASE_TABLES_G10 * sizeof(int32_t))
73 #define POLYPHASE_UV_COEFFICIENT_TABLE_SIZE_G10 (NUM_POLYPHASE_UV_ENTRIES * NUM_HW_POLYPHASE_TABLES_G10 * sizeof(int32_t))
74
75
76
77 // Calculates the number of bits between the startbit and the endbit (0 based).
78 #ifndef MHW_BITFIELD_RANGE
79 #define MHW_BITFIELD_RANGE( startbit, endbit ) ((endbit)-(startbit)+1)
80 #endif
81
82 #define _NAME_MERGE_(x, y) x ## y
83 #define _NAME_LABEL_(name, id) _NAME_MERGE_(name, id)
84 #define __CODEGEN_UNIQUE(name) _NAME_LABEL_(name, __LINE__)
85
86 #ifndef SIZE32
87 #define SIZE32( x ) ((uint32_t)( sizeof(x) / sizeof(uint32_t) ))
88 #endif // SIZE32
89
90 #ifndef OP_LENGTH
91 #define OP_LENGTH( x ) ((uint32_t)(x) - 2 )
92 #endif // OP_LENGTH
93
94 // Calculates the number of bits between the startbit and the endbit (0 based).
95 #ifndef BITFIELD_RANGE
96 #define BITFIELD_RANGE( startbit, endbit ) ((endbit)-(startbit)+1)
97 #endif
98
99 // Definition declared for clarity when creating structs.
100 #ifndef BITFIELD_BIT
101 #define BITFIELD_BIT( bit ) 1
102 #endif
103
104 #define MHW_ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
105
106 //------------------------------------------------------------------------------
107 // Macros specific to MOS_CODEC_SUBCOMP_HW sub-comp
108 //------------------------------------------------------------------------------
109 #ifndef MHW_ASSERT
110 #define MHW_ASSERT(_expr) \
111 MOS_ASSERT(MOS_COMPONENT_HW, MOS_HW_SUBCOMP_ALL, _expr)
112 #endif
113
114 #ifndef MHW_ASSERTMESSAGE
115 #define MHW_ASSERTMESSAGE(_message, ...) \
116 MOS_ASSERTMESSAGE(MOS_COMPONENT_HW, MOS_HW_SUBCOMP_ALL, _message, ##__VA_ARGS__)
117 #endif
118
119 #ifndef MHW_WARNINGMESSAGE
120 #define MHW_WARNINGMESSAGE(_message, ...) \
121 MOS_WARNINGMESSAGE(MOS_COMPONENT_HW, MOS_HW_SUBCOMP_ALL, _message, ##__VA_ARGS__)
122 #endif
123
124 #ifndef MHW_NORMALMESSAGE
125 #define MHW_NORMALMESSAGE(_message, ...) \
126 MOS_NORMALMESSAGE(MOS_COMPONENT_HW, MOS_HW_SUBCOMP_ALL, _message, ##__VA_ARGS__)
127 #endif
128
129 #ifndef MHW_VERBOSEMESSAGE
130 #define MHW_VERBOSEMESSAGE(_message, ...) \
131 MOS_VERBOSEMESSAGE(MOS_COMPONENT_HW, MOS_HW_SUBCOMP_ALL, _message, ##__VA_ARGS__)
132 #endif
133
134 #ifndef MHW_FUNCTION_ENTER
135 #define MHW_FUNCTION_ENTER \
136 MOS_FUNCTION_ENTER(MOS_COMPONENT_HW, MOS_HW_SUBCOMP_ALL)
137 #endif
138
139 #ifndef MHW_FUNCTION_EXIT
140 #define MHW_FUNCTION_EXIT \
141 MOS_FUNCTION_EXIT(MOS_COMPONENT_HW, MOS_HW_SUBCOMP_ALL, eStatus)
142 #endif
143
144 #ifndef MHW_CHK_STATUS
145 #define MHW_CHK_STATUS(_stmt) \
146 MOS_CHK_STATUS(MOS_COMPONENT_HW, MOS_HW_SUBCOMP_ALL, _stmt)
147 #endif
148
149 #ifndef MHW_CHK_STATUS_RETURN
150 #define MHW_CHK_STATUS_RETURN(_stmt) \
151 MOS_CHK_STATUS_RETURN(MOS_COMPONENT_HW, MOS_HW_SUBCOMP_ALL, _stmt)
152 #endif
153
154 #ifndef MHW_CHK_STATUS_MESSAGE
155 #define MHW_CHK_STATUS_MESSAGE(_stmt, _message, ...) \
156 MOS_CHK_STATUS_MESSAGE(MOS_COMPONENT_HW, MOS_HW_SUBCOMP_ALL, _stmt, _message, ##__VA_ARGS__)
157 #endif
158
159 #ifndef MHW_CHK_NULL
160 #define MHW_CHK_NULL(_ptr) \
161 MOS_CHK_NULL(MOS_COMPONENT_HW, MOS_HW_SUBCOMP_ALL, _ptr)
162 #endif
163
164 #ifndef MHW_CHK_NULL_NO_STATUS
165 #define MHW_CHK_NULL_NO_STATUS(_ptr) \
166 MOS_CHK_NULL_NO_STATUS(MOS_COMPONENT_HW, MOS_HW_SUBCOMP_ALL, _ptr)
167 #endif
168
169 #ifndef MHW_CHK_NULL_NO_STATUS_RETURN
170 #define MHW_CHK_NULL_NO_STATUS_RETURN(_ptr) \
171 MOS_CHK_NULL_NO_STATUS_RETURN(MOS_COMPONENT_HW, MOS_HW_SUBCOMP_ALL, _ptr)
172 #endif
173
174 #ifndef MHW_CHK_COND
175 #define MHW_CHK_COND(_condition, _message, ...) \
176 MOS_CHK_COND_RETURN(MOS_COMPONENT_HW, MOS_HW_SUBCOMP_ALL, (_condition), (_message), ##__VA_ARGS__)
177 #endif
178
179 #ifndef MHW_CHK_NULL_RETURN
180 #define MHW_CHK_NULL_RETURN(_ptr) \
181 MOS_CHK_NULL_RETURN(MOS_COMPONENT_HW, MOS_HW_SUBCOMP_ALL, _ptr)
182 #endif
183
184 #ifndef MHW_CHK_STATUS_RETURN
185 #define MHW_CHK_STATUS_RETURN(_stmt) \
186 MOS_CHK_STATUS_RETURN(MOS_COMPONENT_HW, MOS_HW_SUBCOMP_ALL, _stmt)
187 #endif
188
189 #ifndef MHW_MI_CHK_STATUS
190 #define MHW_MI_CHK_STATUS(_stmt) \
191 MOS_CHK_STATUS_RETURN(MOS_COMPONENT_HW, MOS_HW_SUBCOMP_ALL, _stmt)
192 #endif
193
194 #ifndef MHW_MI_CHK_STATUS_MESSAGE
195 #define MHW_MI_CHK_STATUS_MESSAGE(_stmt, _message, ...) \
196 MOS_CHK_STATUS_MESSAGE_RETURN(MOS_COMPONENT_HW, MOS_HW_SUBCOMP_ALL, _stmt, _message, ##__VA_ARGS__)
197 #endif
198
199 #ifndef MHW_MI_CHK_NULL
200 #define MHW_MI_CHK_NULL(_ptr) \
201 MOS_CHK_NULL_RETURN(MOS_COMPONENT_HW, MOS_HW_SUBCOMP_ALL, _ptr)
202 #endif
203
204 enum GFX_OPCODE
205 {
206 GFXOP_PIPELINED = 0x0,
207 GFXOP_VEBOX = 0x4,
208 GFXOP_MFX_VEBOX_SFC = 0xA // Media MFX/VEBOX+SFC Mode
209 };
210
211 enum INSTRUCTION_PIPELINE
212 {
213 PIPE_COMMON = 0x0,
214 PIPE_SINGLE_DWORD = 0x1,
215 PIPE_COMMON_CTG = 0x1,
216 PIPE_MEDIA = 0x2,
217 PIPE_3D = 0x3
218 };
219
220 enum INSTRUCTION_TYPE
221 {
222 INSTRUCTION_MI = 0x0,
223 INSTRUCTION_2D = 0x2,
224 INSTRUCTION_GFX = 0x3
225 };
226
227 enum MHW_GFX3DSTATE_SURFACEFORMAT
228 {
229 MHW_GFX3DSTATE_SURFACEFORMAT_R32G32B32A32_FLOAT = 0x000,
230 MHW_GFX3DSTATE_SURFACEFORMAT_R32G32B32A32_SINT = 0x001,
231 MHW_GFX3DSTATE_SURFACEFORMAT_R32G32B32A32_UINT = 0x002,
232 MHW_GFX3DSTATE_SURFACEFORMAT_R32G32B32A32_UNORM = 0x003,
233 MHW_GFX3DSTATE_SURFACEFORMAT_R32G32B32A32_SNORM = 0x004,
234 MHW_GFX3DSTATE_SURFACEFORMAT_R64G64_FLOAT = 0x005,
235 MHW_GFX3DSTATE_SURFACEFORMAT_R32G32B32X32_FLOAT = 0x006,
236 MHW_GFX3DSTATE_SURFACEFORMAT_R32G32B32A32_SSCALED = 0x007,
237 MHW_GFX3DSTATE_SURFACEFORMAT_R32G32B32A32_USCALED = 0x008,
238 MHW_GFX3DSTATE_SURFACEFORMAT_R16B16_UNORM_SAMPLE_8X8 = 0x017,
239 MHW_GFX3DSTATE_SURFACEFORMAT_R32G32B32_FLOAT = 0x040,
240 MHW_GFX3DSTATE_SURFACEFORMAT_R32G32B32_SINT = 0x041,
241 MHW_GFX3DSTATE_SURFACEFORMAT_R32G32B32_UINT = 0x042,
242 MHW_GFX3DSTATE_SURFACEFORMAT_R32G32B32_UNORM = 0x043,
243 MHW_GFX3DSTATE_SURFACEFORMAT_R32G32B32_SNORM = 0x044,
244 MHW_GFX3DSTATE_SURFACEFORMAT_R32G32B32_SSCALED = 0x045,
245 MHW_GFX3DSTATE_SURFACEFORMAT_R32G32B32_USCALED = 0x046,
246 MHW_GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_UNORM = 0x080,
247 MHW_GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_SNORM = 0x081,
248 MHW_GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_SINT = 0x082,
249 MHW_GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_UINT = 0x083,
250 MHW_GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_FLOAT = 0x084,
251 MHW_GFX3DSTATE_SURFACEFORMAT_R32G32_FLOAT = 0x085,
252 MHW_GFX3DSTATE_SURFACEFORMAT_R32G32_SINT = 0x086,
253 MHW_GFX3DSTATE_SURFACEFORMAT_R32G32_UINT = 0x087,
254 MHW_GFX3DSTATE_SURFACEFORMAT_R32_FLOAT_X8X24_TYPELESS = 0x088,
255 MHW_GFX3DSTATE_SURFACEFORMAT_X32_TYPELESS_G8X24_UINT = 0x089,
256 MHW_GFX3DSTATE_SURFACEFORMAT_L32A32_FLOAT = 0x08A,
257 MHW_GFX3DSTATE_SURFACEFORMAT_R32G32_UNORM = 0x08B,
258 MHW_GFX3DSTATE_SURFACEFORMAT_R32G32_SNORM = 0x08C,
259 MHW_GFX3DSTATE_SURFACEFORMAT_R64_FLOAT = 0x08D,
260 MHW_GFX3DSTATE_SURFACEFORMAT_R16G16B16X16_UNORM = 0x08E,
261 MHW_GFX3DSTATE_SURFACEFORMAT_R16G16B16X16_FLOAT = 0x08F,
262 MHW_GFX3DSTATE_SURFACEFORMAT_A32X32_FLOAT = 0x090,
263 MHW_GFX3DSTATE_SURFACEFORMAT_L32X32_FLOAT = 0x091,
264 MHW_GFX3DSTATE_SURFACEFORMAT_I32X32_FLOAT = 0x092,
265 MHW_GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_SSCALED = 0x093,
266 MHW_GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_USCALED = 0x094,
267 MHW_GFX3DSTATE_SURFACEFORMAT_R32G32_SSCALED = 0x095,
268 MHW_GFX3DSTATE_SURFACEFORMAT_R32G32_USCALED = 0x096,
269 MHW_GFX3DSTATE_SURFACEFORMAT_B8G8R8A8_UNORM = 0x0C0,
270 MHW_GFX3DSTATE_SURFACEFORMAT_B8G8R8A8_UNORM_SRGB = 0x0C1,
271 MHW_GFX3DSTATE_SURFACEFORMAT_R10G10B10A2_UNORM = 0x0C2,
272 MHW_GFX3DSTATE_SURFACEFORMAT_R10G10B10A2_UNORM_SRGB = 0x0C3,
273 MHW_GFX3DSTATE_SURFACEFORMAT_R10G10B10A2_UINT = 0x0C4,
274 MHW_GFX3DSTATE_SURFACEFORMAT_R10G10B10_SNORM_A2_UNORM = 0x0C5,
275 MHW_GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_UNORM = 0x0C7,
276 MHW_GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_UNORM_SRGB = 0x0C8,
277 MHW_GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_SNORM = 0x0C9,
278 MHW_GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_SINT = 0x0CA,
279 MHW_GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_UINT = 0x0CB,
280 MHW_GFX3DSTATE_SURFACEFORMAT_R16G16_UNORM = 0x0CC,
281 MHW_GFX3DSTATE_SURFACEFORMAT_R16G16_SNORM = 0x0CD,
282 MHW_GFX3DSTATE_SURFACEFORMAT_R16G16_SINT = 0x0CE,
283 MHW_GFX3DSTATE_SURFACEFORMAT_R16G16_UINT = 0x0CF,
284 MHW_GFX3DSTATE_SURFACEFORMAT_R16G16_FLOAT = 0x0D0,
285 MHW_GFX3DSTATE_SURFACEFORMAT_B10G10R10A2_UNORM = 0x0D1,
286 MHW_GFX3DSTATE_SURFACEFORMAT_B10G10R10A2_UNORM_SRGB = 0x0D2,
287 MHW_GFX3DSTATE_SURFACEFORMAT_R11G11B10_FLOAT = 0x0D3,
288 MHW_GFX3DSTATE_SURFACEFORMAT_R32_SINT = 0x0D6,
289 MHW_GFX3DSTATE_SURFACEFORMAT_R32_UINT = 0x0D7,
290 MHW_GFX3DSTATE_SURFACEFORMAT_R32_FLOAT = 0x0D8,
291 MHW_GFX3DSTATE_SURFACEFORMAT_R24_UNORM_X8_TYPELESS = 0x0D9,
292 MHW_GFX3DSTATE_SURFACEFORMAT_X24_TYPELESS_G8_UINT = 0x0DA,
293 MHW_GFX3DSTATE_SURFACEFORMAT_L16A16_UNORM = 0x0DF,
294 MHW_GFX3DSTATE_SURFACEFORMAT_I24X8_UNORM = 0x0E0,
295 MHW_GFX3DSTATE_SURFACEFORMAT_L24X8_UNORM = 0x0E1,
296 MHW_GFX3DSTATE_SURFACEFORMAT_A24X8_UNORM = 0x0E2,
297 MHW_GFX3DSTATE_SURFACEFORMAT_I32_FLOAT = 0x0E3,
298 MHW_GFX3DSTATE_SURFACEFORMAT_L32_FLOAT = 0x0E4,
299 MHW_GFX3DSTATE_SURFACEFORMAT_A32_FLOAT = 0x0E5,
300 MHW_GFX3DSTATE_SURFACEFORMAT_B8G8R8X8_UNORM = 0x0E9,
301 MHW_GFX3DSTATE_SURFACEFORMAT_B8G8R8X8_UNORM_SRGB = 0x0EA,
302 MHW_GFX3DSTATE_SURFACEFORMAT_R8G8B8X8_UNORM = 0x0EB,
303 MHW_GFX3DSTATE_SURFACEFORMAT_R8G8B8X8_UNORM_SRGB = 0x0EC,
304 MHW_GFX3DSTATE_SURFACEFORMAT_R9G9B9E5_SHAREDEXP = 0x0ED,
305 MHW_GFX3DSTATE_SURFACEFORMAT_B10G10R10X2_UNORM = 0x0EE,
306 MHW_GFX3DSTATE_SURFACEFORMAT_L16A16_FLOAT = 0x0F0,
307 MHW_GFX3DSTATE_SURFACEFORMAT_R32_UNORM = 0x0F1,
308 MHW_GFX3DSTATE_SURFACEFORMAT_R32_SNORM = 0x0F2,
309 MHW_GFX3DSTATE_SURFACEFORMAT_R10G10B10X2_USCALED = 0x0F3,
310 MHW_GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_SSCALED = 0x0F4,
311 MHW_GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_USCALED = 0x0F5,
312 MHW_GFX3DSTATE_SURFACEFORMAT_R16G16_SSCALED = 0x0F6,
313 MHW_GFX3DSTATE_SURFACEFORMAT_R16G16_USCALED = 0x0F7,
314 MHW_GFX3DSTATE_SURFACEFORMAT_R32_SSCALED = 0x0F8,
315 MHW_GFX3DSTATE_SURFACEFORMAT_R32_USCALED = 0x0F9,
316 MHW_GFX3DSTATE_SURFACEFORMAT_R8B8G8A8_UNORM = 0x0FA,
317 MHW_GFX3DSTATE_SURFACEFORMAT_B5G6R5_UNORM = 0x100,
318 MHW_GFX3DSTATE_SURFACEFORMAT_B5G6R5_UNORM_SRGB = 0x101,
319 MHW_GFX3DSTATE_SURFACEFORMAT_B5G5R5A1_UNORM = 0x102,
320 MHW_GFX3DSTATE_SURFACEFORMAT_B5G5R5A1_UNORM_SRGB = 0x103,
321 MHW_GFX3DSTATE_SURFACEFORMAT_B4G4R4A4_UNORM = 0x104,
322 MHW_GFX3DSTATE_SURFACEFORMAT_B4G4R4A4_UNORM_SRGB = 0x105,
323 MHW_GFX3DSTATE_SURFACEFORMAT_R8G8_UNORM = 0x106,
324 MHW_GFX3DSTATE_SURFACEFORMAT_R8G8_SNORM = 0x107,
325 MHW_GFX3DSTATE_SURFACEFORMAT_R8G8_SINT = 0x108,
326 MHW_GFX3DSTATE_SURFACEFORMAT_R8G8_UINT = 0x109,
327 MHW_GFX3DSTATE_SURFACEFORMAT_R16_UNORM = 0x10A,
328 MHW_GFX3DSTATE_SURFACEFORMAT_R16_SNORM = 0x10B,
329 MHW_GFX3DSTATE_SURFACEFORMAT_R16_SINT = 0x10C,
330 MHW_GFX3DSTATE_SURFACEFORMAT_R16_UINT = 0x10D,
331 MHW_GFX3DSTATE_SURFACEFORMAT_R16_FLOAT = 0x10E,
332 MHW_GFX3DSTATE_SURFACEFORMAT_I16_UNORM = 0x111,
333 MHW_GFX3DSTATE_SURFACEFORMAT_L16_UNORM = 0x112,
334 MHW_GFX3DSTATE_SURFACEFORMAT_A16_UNORM = 0x113,
335 MHW_GFX3DSTATE_SURFACEFORMAT_L8A8_UNORM = 0x114,
336 MHW_GFX3DSTATE_SURFACEFORMAT_I16_FLOAT = 0x115,
337 MHW_GFX3DSTATE_SURFACEFORMAT_L16_FLOAT = 0x116,
338 MHW_GFX3DSTATE_SURFACEFORMAT_A16_FLOAT = 0x117,
339 MHW_GFX3DSTATE_SURFACEFORMAT_L8A8_UNORM_SRGB = 0x118,
340 MHW_GFX3DSTATE_SURFACEFORMAT_R5G5_SNORM_B6_UNORM = 0x119,
341 MHW_GFX3DSTATE_SURFACEFORMAT_B5G5R5X1_UNORM = 0x11A,
342 MHW_GFX3DSTATE_SURFACEFORMAT_B5G5R5X1_UNORM_SRGB = 0x11B,
343 MHW_GFX3DSTATE_SURFACEFORMAT_R8G8_SSCALED = 0x11C,
344 MHW_GFX3DSTATE_SURFACEFORMAT_R8G8_USCALED = 0x11D,
345 MHW_GFX3DSTATE_SURFACEFORMAT_R16_SSCALED = 0x11E,
346 MHW_GFX3DSTATE_SURFACEFORMAT_R16_USCALED = 0x11F,
347 MHW_GFX3DSTATE_SURFACEFORMAT_P8A8_UNORM_PALETTE_0 = 0x122,
348 MHW_GFX3DSTATE_SURFACEFORMAT_P8A8_UNORM_PALETTE_1 = 0x123,
349 MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM = 0x140,
350 MHW_GFX3DSTATE_SURFACEFORMAT_R8_SNORM = 0x141,
351 MHW_GFX3DSTATE_SURFACEFORMAT_R8_SINT = 0x142,
352 MHW_GFX3DSTATE_SURFACEFORMAT_R8_UINT = 0x143,
353 MHW_GFX3DSTATE_SURFACEFORMAT_A8_UNORM = 0x144,
354 MHW_GFX3DSTATE_SURFACEFORMAT_I8_UNORM = 0x145,
355 MHW_GFX3DSTATE_SURFACEFORMAT_L8_UNORM = 0x146,
356 MHW_GFX3DSTATE_SURFACEFORMAT_P4A4_UNORM_PALETTE_0 = 0x147,
357 MHW_GFX3DSTATE_SURFACEFORMAT_A4P4_UNORM_PALETTE_0 = 0x148,
358 MHW_GFX3DSTATE_SURFACEFORMAT_R8_SSCALED = 0x149,
359 MHW_GFX3DSTATE_SURFACEFORMAT_R8_USCALED = 0x14A,
360 MHW_GFX3DSTATE_SURFACEFORMAT_P8_UNORM_PALETTE_0 = 0x14B,
361 MHW_GFX3DSTATE_SURFACEFORMAT_L8_UNORM_SRGB = 0x14C,
362 MHW_GFX3DSTATE_SURFACEFORMAT_P8_UNORM_PALETTE_1 = 0x14D,
363 MHW_GFX3DSTATE_SURFACEFORMAT_P4A4_UNORM_PALETTE_1 = 0x14E,
364 MHW_GFX3DSTATE_SURFACEFORMAT_A4P4_UNORM_PALETTE_1 = 0x14F,
365 MHW_GFX3DSTATE_SURFACEFORMAT_DXT1_RGB_SRGB = 0x180,
366 MHW_GFX3DSTATE_SURFACEFORMAT_R1_UINT = 0x181,
367 MHW_GFX3DSTATE_SURFACEFORMAT_YCRCB_NORMAL = 0x182,
368 MHW_GFX3DSTATE_SURFACEFORMAT_YCRCB_SWAPUVY = 0x183,
369 MHW_GFX3DSTATE_SURFACEFORMAT_P2_UNORM_PALETTE_0 = 0x184,
370 MHW_GFX3DSTATE_SURFACEFORMAT_P2_UNORM_PALETTE_1 = 0x185,
371 MHW_GFX3DSTATE_SURFACEFORMAT_BC1_UNORM = 0x186,
372 MHW_GFX3DSTATE_SURFACEFORMAT_BC2_UNORM = 0x187,
373 MHW_GFX3DSTATE_SURFACEFORMAT_BC3_UNORM = 0x188,
374 MHW_GFX3DSTATE_SURFACEFORMAT_BC4_UNORM = 0x189,
375 MHW_GFX3DSTATE_SURFACEFORMAT_BC5_UNORM = 0x18A,
376 MHW_GFX3DSTATE_SURFACEFORMAT_BC1_UNORM_SRGB = 0x18B,
377 MHW_GFX3DSTATE_SURFACEFORMAT_BC2_UNORM_SRGB = 0x18C,
378 MHW_GFX3DSTATE_SURFACEFORMAT_BC3_UNORM_SRGB = 0x18D,
379 MHW_GFX3DSTATE_SURFACEFORMAT_MONO8 = 0x18E,
380 MHW_GFX3DSTATE_SURFACEFORMAT_YCRCB_SWAPUV = 0x18F,
381 MHW_GFX3DSTATE_SURFACEFORMAT_YCRCB_SWAPY = 0x190,
382 MHW_GFX3DSTATE_SURFACEFORMAT_DXT1_RGB = 0x191,
383 MHW_GFX3DSTATE_SURFACEFORMAT_FXT1 = 0x192,
384 MHW_GFX3DSTATE_SURFACEFORMAT_R8G8B8_UNORM = 0x193,
385 MHW_GFX3DSTATE_SURFACEFORMAT_R8G8B8_SNORM = 0x194,
386 MHW_GFX3DSTATE_SURFACEFORMAT_R8G8B8_SSCALED = 0x195,
387 MHW_GFX3DSTATE_SURFACEFORMAT_R8G8B8_USCALED = 0x196,
388 MHW_GFX3DSTATE_SURFACEFORMAT_R64G64B64A64_FLOAT = 0x197,
389 MHW_GFX3DSTATE_SURFACEFORMAT_R64G64B64_FLOAT = 0x198,
390 MHW_GFX3DSTATE_SURFACEFORMAT_BC4_SNORM = 0x199,
391 MHW_GFX3DSTATE_SURFACEFORMAT_BC5_SNORM = 0x19A,
392 MHW_GFX3DSTATE_SURFACEFORMAT_R16G16B16_UNORM = 0x19C,
393 MHW_GFX3DSTATE_SURFACEFORMAT_R16G16B16_SNORM = 0x19D,
394 MHW_GFX3DSTATE_SURFACEFORMAT_R16G16B16_SSCALED = 0x19E,
395 MHW_GFX3DSTATE_SURFACEFORMAT_R16G16B16_USCALED = 0x19F,
396 MHW_GFX3DSTATE_SURFACEFORMAT_PLANAR_420_8 = 0x1A5,
397 MHW_GFX3DSTATE_SURFACEFORMAT_PLANAR_420_16 = 0x1A6,
398 MHW_GFX3DSTATE_SURFACEFORMAT_R8G8B8_UNORM_SRGB = 0x1A8,
399 MHW_GFX3DSTATE_SURFACEFORMAT_RAW = 0x1FF,
400 NUM_MHW_GFX3DSTATE_SURFACEFORMATS
401 };
402
403 enum MHW_MEDIASTATE_SURFACEFORMAT
404 {
405 MHW_MEDIASTATE_SURFACEFORMAT_YCRCB_NORMAL = 0,
406 MHW_MEDIASTATE_SURFACEFORMAT_YCRCB_SWAPUVY = 1,
407 MHW_MEDIASTATE_SURFACEFORMAT_YCRCB_SWAPUV = 2,
408 MHW_MEDIASTATE_SURFACEFORMAT_YCRCB_SWAPY = 3,
409 MHW_MEDIASTATE_SURFACEFORMAT_PLANAR_420_8 = 4,
410 MHW_MEDIASTATE_SURFACEFORMAT_PLANAR_411_8 = 5, // deinterlace only
411 MHW_MEDIASTATE_SURFACEFORMAT_PLANAR_422_8 = 6, // deinterlace only
412 MHW_MEDIASTATE_SURFACEFORMAT_STMM_DN_STATISTICS = 7, // deinterlace only
413 MHW_MEDIASTATE_SURFACEFORMAT_R10G10B10A2_UNORM = 8, // sample_8x8 only
414 MHW_MEDIASTATE_SURFACEFORMAT_R8G8B8A8_UNORM = 9, // sample_8x8 only
415 MHW_MEDIASTATE_SURFACEFORMAT_R8B8_UNORM = 10, // CrCb, sample_8x8 only
416 MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM = 11, // Cr/Cb, sample_8x8 only
417 MHW_MEDIASTATE_SURFACEFORMAT_Y8_UNORM = 12, // sample_8x8 only
418 MHW_MEDIASTATE_SURFACEFORMAT_A8Y8U8V8_UNORM = 13, // sample_8x8 only
419 MHW_MEDIASTATE_SURFACEFORMAT_B8G8R8A8_UNORM = 14, // sample_8x8 only
420 MHW_MEDIASTATE_SURFACEFORMAT_R16G16B16A16 = 15, // Sample_8x8 only
421 MHW_MEDIASTATE_SURFACEFORMAT_PLANAR_420_16 = 23, // Sample_8x8 only
422 MHW_MEDIASTATE_SURFACEFORMAT_R16B16_UNORM = 24, // Sample_8x8 only
423 MHW_MEDIASTATE_SURFACEFORMAT_R16_UNORM = 25, // Sample_8x8 only
424 MHW_MEDIASTATE_SURFACEFORMAT_Y16_UNORM = 26 // Sample_8x8 only
425 };
426
427 enum GFX3DSTATE_SURFACETYPE
428 {
429 GFX3DSTATE_SURFACETYPE_1D = 0,
430 GFX3DSTATE_SURFACETYPE_2D = 1,
431 GFX3DSTATE_SURFACETYPE_3D = 2,
432 GFX3DSTATE_SURFACETYPE_CUBE = 3,
433 GFX3DSTATE_SURFACETYPE_BUFFER = 4,
434 GFX3DSTATE_SURFACETYPE_SREBUF = 5, // Structured buffer surface.
435 GFX3DSTATE_SURFACETYPE_SCRATCH = 6, // Scratch space buffer.
436 GFX3DSTATE_SURFACETYPE_NULL = 7
437 };
438
439 enum SurfaceCacheabilityControl
440 {
441 surfaceCacheabilityControlBitsFromGtt = 0x0,
442 surfaceCacheabilityControlL3Cache = 0x1,
443 surfaceCacheabilityControlLLCCache = 0x2
444 };
445
446 enum GFX3DSTATE_MEDIA_BOUNDARY_PIXEL_MODE
447 {
448 GFX3DSTATE_BOUNDARY_NORMAL = 0x0,
449 GFX3DSTATE_BOUNDARY_PROGRESSIVE_FRAME = 0x2,
450 GFX3DSTATE_BOUNDARY_INTERLACED_FRAME = 0x3
451 };
452
453 enum TILED_RESOURCE_MODE_LEGACY
454 {
455 TRMODE_NONE = 0,
456 TRMODE_TILEYF = 1,
457 TRMODE_TILEYS = 2,
458 };
459
460 enum MEDIASTATE_SFC_PIPE_MODE
461 {
462 MEDIASTATE_SFC_PIPE_VD_TO_SFC = 0,
463 MEDIASTATE_SFC_PIPE_VE_TO_SFC = 1,
464 MEDIASTATE_SFC_PIPE_VE_TO_SFC_INTEGRAL = 4
465 };
466
467 enum MEDIASTATE_SFC_AVS_FILTER_MODE
468 {
469 MEDIASTATE_SFC_AVS_FILTER_5x5 = 0,
470 MEDIASTATE_SFC_AVS_FILTER_8x8 = 1,
471 MEDIASTATE_SFC_AVS_FILTER_BILINEAR = 2
472 };
473
474 enum MEDIASTATE_SFC_CHROMA_SUBSAMPLING_MODE
475 {
476 MEDIASTATE_SFC_CHROMA_SUBSAMPLING_400 = 0,
477 MEDIASTATE_SFC_CHROMA_SUBSAMPLING_420 = 1,
478 MEDIASTATE_SFC_CHROMA_SUBSAMPLING_422H = 2,
479 MEDIASTATE_SFC_CHROMA_SUBSAMPLING_444 = 4,
480 MEDIASTATE_SFC_CHROMA_SUBSAMPLING_411 = 5
481 };
482
483 enum MEDIASTATE_SFC_INPUT_ORDERING_MODE
484 {
485 MEDIASTATE_SFC_INPUT_ORDERING_VE_4x8 = 0,
486 MEDIASTATE_SFC_INPUT_ORDERING_VE_4x4 = 1,
487 MEDIASTATE_SFC_INPUT_ORDERING_VE_4x8_128pixel = 2,
488 MEDIASTATE_SFC_INPUT_ORDERING_VE_4x4_128pixel = 3,
489 MEDIASTATE_SFC_INPUT_ORDERING_VD_16x16_NOSHIFT = 0,
490 MEDIASTATE_SFC_INPUT_ORDERING_VD_16x16_SHIFT = 1,
491 MEDIASTATE_SFC_INPUT_ORDERING_VD_8x8_JPEG = 2,
492 MEDIASTATE_SFC_INPUT_ORDERING_VD_16x16_JPEG = 3,
493 MEDIASTATE_SFC_INPUT_ORDERING_VD_16x16_VP8 = 4
494 };
495
496 // SFC Pre-AVS Chroma Downsampling Mode
497 enum MEDIASTATE_SFC_CHROMA_DOWNSAMPLING_MODE
498 {
499 MEDIASTATE_SFC_CHROMA_DOWNSAMPLING_DISABLED = 0x0,
500 MEDIASTATE_SFC_CHROMA_DOWNSAMPLING_444TO420 = 0x1,
501 MEDIASTATE_SFC_CHROMA_DOWNSAMPLING_444TO422 = 0x2,
502 MEDIASTATE_SFC_CHROMA_DOWNSAMPLING_422TO420 = 0x3
503 };
504
505 // SFC Pre-AVS Chroma Downsampling Coefficient -- Fractional Position of the Bilinear Filter
506 enum MEDIASTATE_SFC_CHROMA_DOWNSAMPLING_COEF
507 {
508 MEDIASTATE_SFC_CHROMA_DOWNSAMPLING_COEF_0_OVER_8 = 0x0,
509 MEDIASTATE_SFC_CHROMA_DOWNSAMPLING_COEF_1_OVER_8 = 0x1,
510 MEDIASTATE_SFC_CHROMA_DOWNSAMPLING_COEF_2_OVER_8 = 0x2,
511 MEDIASTATE_SFC_CHROMA_DOWNSAMPLING_COEF_3_OVER_8 = 0x3,
512 MEDIASTATE_SFC_CHROMA_DOWNSAMPLING_COEF_4_OVER_8 = 0x4,
513 MEDIASTATE_SFC_CHROMA_DOWNSAMPLING_COEF_5_OVER_8 = 0x5,
514 MEDIASTATE_SFC_CHROMA_DOWNSAMPLING_COEF_6_OVER_8 = 0x6,
515 MEDIASTATE_SFC_CHROMA_DOWNSAMPLING_COEF_7_OVER_8 = 0x7,
516 MEDIASTATE_SFC_CHROMA_DOWNSAMPLING_COEF_8_OVER_8 = 0x8
517 };
518
519 enum MEDIASTATE_VDIRECTION
520 {
521 MEDIASTATE_VDIRECTION_TOP_FIELD = 1,
522 MEDIASTATE_VDIRECTION_FULL_FRAME = 2,
523 MEDIASTATE_VDIRECTION_BOTTOM_FIELD = 3
524 };
525
526 typedef union _MHW_MEMORY_OBJECT_CONTROL_PARAMS
527 {
528 struct
529 {
530 uint32_t L3 : 1;
531 uint32_t CacheControl : 1;
532 uint32_t GFDT : 1;
533 uint32_t : 1;
534 uint32_t : 28;
535 } Gen7;
536 struct
537 {
538 uint32_t L3 : 1;
539 uint32_t CacheControl : 2;
540 uint32_t : 1;
541 uint32_t : 28;
542 } Gen7_5;
543 struct
544 {
545 uint32_t Age : 2;
546 uint32_t : 1;
547 uint32_t TargetCache : 2;
548 uint32_t CacheControl : 2;
549 uint32_t : 25;
550 } Gen8;
551 struct
552 {
553 uint32_t : 1;
554 uint32_t Index : 6;
555 uint32_t : 25;
556 } Gen9, Gen10, Gen11, Gen12, Gen12_5, Gen12_7;
557 uint32_t Value;
558
559 _MHW_MEMORY_OBJECT_CONTROL_PARAMS()
560 {
561 Value = 0;
562 }
563 } MHW_MEMORY_OBJECT_CONTROL_PARAMS, * PMHW_MEMORY_OBJECT_CONTROL_PARAMS;
564
565 typedef struct _MHW_RENDER_PWR_CLK_STATE_PARAMS
566 {
567 union
568 {
569 struct
570 {
571 // 0010: 2 EUs
572 // 0100: 4 EUs
573 // 0110: 6 EUs
574 // 1000: 8 EUs
575 uint32_t EUmin : BITFIELD_RANGE(0, 3); // Minimum number of EUs to power (per subslice if multiple subslices enabled)
576 uint32_t EUmax : BITFIELD_RANGE(4, 7); // Maximum number of EUs to power (per subslice if multiple subslices enabled)
577 // To specify an exact number of subslices, set EUmax equal to EUmin
578
579 uint32_t SubSliceCount : BITFIELD_RANGE(8, 10);
580
581 uint32_t SSCountEn : BITFIELD_RANGE(11, 11);
582
583 uint32_t SliceCount : BITFIELD_RANGE(12, 17);
584
585 uint32_t SCountEn : BITFIELD_RANGE(18, 18);
586
587 uint32_t Reserved1 : BITFIELD_RANGE(19, 30);
588
589 // Main trigger: Power Clock State Enable
590 // 0: No specific power state set, no message/wait with PMunit
591 // 1: CSunit sends the contents of this register to PMunit each time it is written, Send contents of this register to PMunit, wait for Ack.
592 uint32_t PowerClkStateEn : BITFIELD_RANGE(31, 31);
593 };
594
595 uint32_t Data;
596 };
597
598 }MHW_RENDER_PWR_CLK_STATE_PARAMS;
599
600 struct _MHW_BATCH_BUFFER
601 {
602 MOS_RESOURCE OsResource;
603 int32_t iRemaining; //!< Remaining space in the BB
604 int32_t iSize; //!< Command buffer size
605 uint32_t count; //!< Actual batch count in this resource. If larger than 1, multiple buffer has equal size and resource size count * size.
606 int32_t iCurrent; //!< Current offset in CB
607 bool bLocked; //!< True if locked in memory (pData must be valid)
608 uint8_t* pData; //!< Pointer to BB data
609 #if (_DEBUG || _RELEASE_INTERNAL)
610 int32_t iLastCurrent; //!< Save offset in CB (for debug plug-in/out)
611 #endif
612
613 // User defined
614 bool bSecondLevel; // REMOVE REMOVE
615 uint32_t dwOffset; //!< Offset to the data in the OS resource
616
617 // Batch Buffer synchronization logic
618 bool bBusy; //!< Busy flag (clear when Sync Tag is reached)
619 uint32_t dwCmdBufId; //!< Command Buffer ID for the workload
620 PMHW_BATCH_BUFFER pNext; //!< Next BB in the sync list
621 PMHW_BATCH_BUFFER pPrev; //!< Prev BB in the sync list
622
623 // Batch Buffer Client Private Data
624 uint32_t dwSyncTag;
625 bool bMatch;
626 int32_t iPrivateType; //!< Indicates the BB client
627 int32_t iPrivateSize; //!< Size of the current render args
628 void* pPrivateData; //!< Pointer to private BB data
629 };
630
631 typedef struct _MHW_BATCH_BUFFER_LIST
632 {
633 PMHW_BATCH_BUFFER pHead; //!< First element in the list
634 PMHW_BATCH_BUFFER pTail; //!< Last element in the list
635 int32_t iCount; //!< Number of BBs in this list
636 uint32_t dwSize; //!< Total BB memory in this list
637 } MHW_BATCH_BUFFER_LIST, * PMHW_BATCH_BUFFER_LIST;
638
639 enum WRITE_FLAG
640 {
641 WRITE = 0x1,
642 WRITE_WA = 0x2,
643 };
644
645 typedef struct _MHW_MOCS_PARAMS
646 {
647 uint32_t* mocsTableIndex;
648 uint8_t bitFieldLow;
649 uint8_t bitFieldHigh;
650 } MHW_MOCS_PARAMS;
651
652 struct MHW_INDIRECT_STATE_RESOURCE_PARAMS
653 {
654 PMOS_RESOURCE stateHeap = nullptr;
655 uint8_t *stateBasePtr = nullptr;
656 uint32_t stateOffset = 0;
657 PMOS_RESOURCE resource = nullptr;
658 uint32_t resourceOffset = 0;
659 bool isWrite = false;
660 #if MOS_COMMAND_BUFFER_DUMP_SUPPORTED
661 bool needDump = false;
662 uint32_t dumpSize = 0;
663 const char *dumpName = nullptr;
664 uint8_t *resourceBasePtr = nullptr;
665 #endif
666 };
667 using PMHW_INDIRECT_STATE_RESOURCE_PARAMS = MHW_INDIRECT_STATE_RESOURCE_PARAMS*;
668
669 typedef struct _MHW_RESOURCE_PARAMS
670 {
671 PMOS_RESOURCE presResource;
672 uint32_t dwOffset;
673 uint32_t* pdwCmd;
674 uint32_t dwLocationInCmd;
675 uint32_t dwLsbNum;
676 uint32_t dwOffsetInSSH;
677
678 // Location of upper bound value relative to
679 // allocated resource address. The upper bound
680 // value will be set if this parameter is > zero
681 uint32_t dwUpperBoundLocationOffsetFromCmd;
682 uint32_t dwSize;
683
684 MOS_HW_COMMAND HwCommandType;
685 uint32_t dwSharedMocsOffset;
686 uint32_t bIsWritable;
687
688 // If the patching location does not start at bit 0 then the value to be patched needs to be shifted
689 uint32_t shiftAmount;
690 uint32_t shiftDirection;
691 MOS_PATCH_TYPE patchType;
692 MHW_MOCS_PARAMS mocsParams;
693 }MHW_RESOURCE_PARAMS, * PMHW_RESOURCE_PARAMS;
694
695 typedef struct _MHW_GENERIC_PROLOG_PARAMS
696 {
697 PMOS_INTERFACE pOsInterface;
698 void* pvMiInterface;
699 bool bMmcEnabled;
700 PMOS_RESOURCE presStoreData;
701 uint32_t dwStoreDataOffset;
702 uint32_t dwStoreDataValue;
703 } MHW_GENERIC_PROLOG_PARAMS, * PMHW_GENERIC_PROLOG_PARAMS;
704
705 void inline InitMocsParams(
706 MHW_RESOURCE_PARAMS& hwResourceParam,
707 uint32_t* addr,
708 uint8_t bitFieldLow,
709 uint8_t bitFieldHigh)
710 {
711 hwResourceParam.mocsParams.mocsTableIndex = addr;
712 hwResourceParam.mocsParams.bitFieldLow = bitFieldLow;
713 hwResourceParam.mocsParams.bitFieldHigh = bitFieldHigh;
714 return;
715 }
716
717 MOS_STATUS Mhw_AddResourceToCmd_GfxAddress(
718 PMOS_INTERFACE pOsInterface,
719 PMOS_COMMAND_BUFFER pCmdBuffer,
720 PMHW_RESOURCE_PARAMS pParams);
721
722 MOS_STATUS Mhw_AddResourceToCmd_PatchList(
723 PMOS_INTERFACE pOsInterface,
724 PMOS_COMMAND_BUFFER pCmdBuffer,
725 PMHW_RESOURCE_PARAMS pParams);
726
727 MOS_STATUS Mhw_SurfaceFormatToType(
728 uint32_t dwForceSurfaceFormat,
729 PMOS_SURFACE psSurface,
730 uint32_t* pdwSurfaceType);
731
732 MOS_STATUS Mhw_SendNativeFenceSyncBBStartCmd(
733 PMOS_COMMAND_BUFFER pCmdBuffer,
734 PMOS_INTERFACE pOsInterface,
735 std::shared_ptr<void> pMiItf);
736
737 MOS_STATUS Mhw_SendGenericPrologCmdNext(
738 PMOS_COMMAND_BUFFER pCmdBuffer,
739 PMHW_GENERIC_PROLOG_PARAMS pParams,
740 std::shared_ptr<void> pMiItf,
741 MHW_MI_MMIOREGISTERS *pMmioReg = nullptr);
742
743 MOS_STATUS Mhw_SetNearestModeTable(
744 int32_t* iCoefs,
745 uint32_t dwPlane,
746 bool bBalancedFilter);
747
748 MOS_STATUS Mhw_CalcPolyphaseTablesY(
749 int32_t* iCoefs,
750 float fScaleFactor,
751 uint32_t dwPlane,
752 MOS_FORMAT srcFmt,
753 float fHPStrength,
754 bool bUse8x8Filter,
755 uint32_t dwHwPhase,
756 float fLanczosT);
757
758 MOS_STATUS Mhw_CalcPolyphaseTablesUV(
759 int32_t* piCoefs,
760 float fLanczosT,
761 float fInverseScaleFactor);
762
763 MOS_STATUS Mhw_CalcPolyphaseTablesUVOffset(
764 int32_t* piCoefs,
765 float fLanczosT,
766 float fInverseScaleFactor,
767 int32_t iUvPhaseOffset);
768
769 MOS_STATUS Mhw_AllocateBb(
770 PMOS_INTERFACE pOsInterface,
771 PMHW_BATCH_BUFFER pBatchBuffer,
772 PMHW_BATCH_BUFFER pBatchBufferList,
773 uint32_t dwSize,
774 uint32_t batchCount = 1,
775 bool notLockable = false,
776 bool inSystemMem = false);
777
778 MOS_STATUS Mhw_FreeBb(
779 PMOS_INTERFACE pOsInterface,
780 PMHW_BATCH_BUFFER pBatchBuffer,
781 PMHW_BATCH_BUFFER pBatchBufferList);
782
783 MOS_STATUS Mhw_LockBb(
784 PMOS_INTERFACE pOsInterface,
785 PMHW_BATCH_BUFFER pBatchBuffer);
786
787 MOS_STATUS Mhw_UnlockBb(
788 PMOS_INTERFACE pOsInterface,
789 PMHW_BATCH_BUFFER pBatchBuffer,
790 bool bResetBuffer);
791
792 uint32_t Mhw_ConvertToTRMode(
793 MOS_TILE_TYPE Type);
794
795 //*-----------------------------------------------------------------------------
796 //| Purpose: Function to add command to batch buffer
797 //| Also used to skip commands if pCmd provided is nullptr
798 //| Return: MOS_STATUS_SUCCESS if call succeeds
799 //*-----------------------------------------------------------------------------
800 static __inline MOS_STATUS Mhw_AddCommandBB(
801 PMHW_BATCH_BUFFER pBatchBuffer, // [in] Pointer to Batch Buffer
802 const void* pCmd, // [in] Command Pointer
803 uint32_t dwCmdSize) // [in] Size of command in bytes
804 {
805 uint8_t* pbBatchPtr;
806 uint32_t dwCmdSizeDwAligned;
807 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
808
809 //---------------------------------------------
810 MHW_CHK_NULL_RETURN(pBatchBuffer);
811 MHW_CHK_NULL_RETURN(pBatchBuffer->pData);
812 //---------------------------------------------
813
814 pbBatchPtr = pBatchBuffer->pData + pBatchBuffer->iCurrent;
815
816 dwCmdSizeDwAligned = MOS_ALIGN_CEIL(dwCmdSize, sizeof(uint32_t));
817
818 pBatchBuffer->iCurrent += dwCmdSizeDwAligned;
819
820 if (pCmd)
821 {
822 pBatchBuffer->iRemaining -= dwCmdSizeDwAligned;
823 if (pBatchBuffer->iRemaining < 0)
824 {
825 MHW_ASSERTMESSAGE("Unable to add command (no space).");
826 return MOS_STATUS_UNKNOWN;
827 }
828
829 eStatus = MOS_SecureMemcpy(pbBatchPtr, dwCmdSize, pCmd, dwCmdSize);
830 if (eStatus != MOS_STATUS_SUCCESS)
831 {
832 MHW_ASSERTMESSAGE("Failed to copy memory.");
833 return eStatus;
834 }
835 }
836
837 return eStatus;
838 }
839
840 //*-----------------------------------------------------------------------------
841 //| Purpose: Function to add command to batch buffer
842 //| Return: MOS_STATUS_SUCCESS if call succeeds
843 //*-----------------------------------------------------------------------------
844 static __inline MOS_STATUS Mhw_AddCommandCmdOrBB(
845 PMOS_INTERFACE pOsInterface, // [in] Pointer to mos interface
846 void* pCmdBuffer, // [in] Pointer to Command Buffer
847 void* pBatchBuffer, // [in] Pointer to Batch Buffer
848 const void* pCmd, // [in] Command Pointer
849 uint32_t dwCmdSize) // [in] Size of command in bytes
850 {
851 if (pCmdBuffer)
852 {
853 MHW_CHK_NULL_RETURN(pOsInterface);
854 return pOsInterface->pfnAddCommand((PMOS_COMMAND_BUFFER)pCmdBuffer, pCmd, dwCmdSize);
855 }
856 else if (pBatchBuffer)
857 {
858 return (Mhw_AddCommandBB((PMHW_BATCH_BUFFER)pBatchBuffer, pCmd, dwCmdSize));
859 }
860 else
861 {
862 MHW_ASSERTMESSAGE("There is no valid command buffer or batch buffer.");
863 return MOS_STATUS_NULL_POINTER;
864 }
865 }
866
867 struct MHW_SEMAPHORE_WATI_REGISTERS
868 {
869 uint32_t m_tokenRegister = 0;
870 uint32_t m_gpr0Lo = 0;
871 uint32_t m_gpr0Hi = 0;
872 uint32_t m_gpr1Lo = 0;
873 uint32_t m_gpr1Hi = 0;
874 uint32_t m_gpr2Lo = 0;
875 uint32_t m_gpr2Hi = 0;
876 uint32_t m_gpr3Lo = 0;
877 uint32_t m_gpr3Hi = 0;
878 uint32_t m_predicateResult2 = 0;
879 bool m_bMMIORemap = 0;
880 };
881 #endif // __MHW_UTILITIES_NEXT_H__