1 /*
2 * Copyright (c) 2009-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 renderhal.cpp
24 //! \brief Render Engine state heap manager for VP and CM
25 //! \details Platform/OS Independent Render Engine state heap management interfaces
26 //!
27
28 #include "mos_os.h"
29 #include "renderhal.h"
30 #include "hal_kerneldll.h"
31 #include "renderhal_platform_interface.h"
32 #include "media_interfaces_renderhal.h"
33 #include "media_interfaces_mhw.h"
34 #include "hal_oca_interface.h"
35 #include "vphal_render_common.h"
36
37 #define OutputSurfaceWidthRatio 1
38 extern const SURFACE_STATE_TOKEN_COMMON g_cInit_SURFACE_STATE_TOKEN_COMMON =
39 {
40 // DWORD 0
41 {
42 OP_LENGTH(SIZE32(SURFACE_STATE_TOKEN_COMMON)), // Length
43 GFXSUBOP_SURFACE_STATE_TOKEN, // InstructionSubOpcode
44 GFXOP_PIPELINED, // InstructionOpcode
45 PIPE_3D, // InstructionPipeline
46 INSTRUCTION_GFX, // InstructionType
47 1 // Token
48 },
49
50 // DWORD 1
51 {
52 0, // SurfaceStateHeapOffset
53 0 // SurfaceAllocationIndex
54 },
55
56 // DWORD 2
57 {
58 0 // SurfaceOffset
59 },
60
61 // DWORD 3
62 {
63 0, // RenderTargetEnable
64 0, // YUVPlane
65 0 // SurfaceStateType
66 },
67
68 // DWORD 4
69 {
70 0 // SurfaceBaseAddress
71 },
72
73 // DWORD 5
74 {
75 0 // SurfaceBaseAddress64
76 },
77 };
78
79 const MHW_PIPE_CONTROL_PARAMS g_cRenderHal_InitPipeControlParams =
80 {
81 nullptr, // presDest
82 0, // dwResourceOffset
83 0, // dwDataDW1
84 0, // dwDataDW2
85 MHW_FLUSH_NONE, // dwFlushMode
86 MHW_FLUSH_NOWRITE, // dwPostSyncOp
87 false, // bDisableCSStall
88 false, // bInvalidateStateCache
89 false, // bInvalidateConstantCache
90 false, // bInvalidateVFECache
91 false, // bInvalidateInstructionCache
92 true, // bFlushRenderTargetCache
93 false, // bTlbInvalidate
94 false, // bInvalidateTextureCache
95 false, // bGenericMediaStateClear
96 false, // bIndirectStatePointersDisable
97 false, // bHdcPipelineFlush
98 false, // bKernelFenceEnabled
99 };
100
101 extern const RENDERHAL_SURFACE_STATE_ENTRY g_cInitSurfaceStateEntry =
102 {
103 RENDERHAL_SURFACE_TYPE_INVALID, // Type
104 nullptr, // pSurface
105 nullptr, // pSurfaceState
106 { // SurfaceS Token
107 {}, //DW0
108 {}, //DW1
109 {}, //DW2
110 {}, //DW3
111 {}, //DW4
112 {}, //DW5
113 nullptr, // pResourceInfo
114 },
115 -1, // iSurfStateID
116 0, // dwSurfStateOffset
117 0, // dwFormat
118 0, // dwWidth
119 0, // dwHeight
120 0, // dwPitch
121 0, // dwQPitch
122 0, // YUVPlane
123 false, // bAVS
124 false, // bRenderTarget
125 false, // bVertStride
126 false, // bVertStrideOffs
127 false, // bWidthInDword
128 false, // bTiledSurface
129 false, // bTileWalk
130 false, // bHalfPitchChroma
131 false, // bInterleaveChroma
132 0, // DirectionV
133 0, // DirectionU
134 0, // AddressControl
135 0, // wUXOffset
136 0, // wUYOffset
137 0, // wVXOffset
138 0 // wVYOffset
139 };
140
141 const MHW_MEDIA_STATE_FLUSH_PARAM g_cRenderHal_InitMediaStateFlushParams =
142 {
143 false, // bFlushToGo
144 0 // ui8InterfaceDescriptorOffset
145 };
146
147 const RENDERHAL_KERNEL_PARAM g_cRenderHal_InitKernelParams =
148 {
149 0, // GRF_Count;
150 0, // BT_Count;
151 0, // Sampler_Count
152 0, // Thread_Count
153 0, // GRF_Start_Register
154 0, // CURBE_Length
155 0, // block_width
156 0, // block_height
157 0, // blocks_x
158 0 // blocks_y
159 };
160
161 //!
162 //! \brief Table only used on HSW (look @ renderhal.c for HSW- table)
163 //! Constants used for setting up surface states ui8PlaneID,
164 //! ui8ScaleWidth, ui8ScaleHeight, ui8AlignWidth, ui8AlignHeight,
165 //! ui8PixelsPerDword, bAdvanced, dwFormat
166 //!
167 extern const MHW_SURFACE_PLANES g_cRenderHal_SurfacePlanes[RENDERHAL_PLANES_DEFINITION_COUNT] =
168 {
169 // RENDERHAL_PLANES_PL3
170 { 3,
171 {
172 { MHW_Y_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM },
173 { MHW_U_PLANE , 2, 2, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM },
174 { MHW_V_PLANE , 2, 2, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM }
175 }
176 },
177 // RENDERHAL_PLANES_NV12
178 { 1,
179 {
180 { MHW_Y_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_PLANAR_420_8 }
181 }
182 },
183 // RENDERHAL_PLANES_YUY2
184 { 1,
185 {
186 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_YCRCB_NORMAL }
187 }
188 },
189 // RENDERHAL_PLANES_UYVY
190 { 1,
191 {
192 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_YCRCB_SWAPY }
193 }
194 },
195 // RENDERHAL_PLANES_YVYU
196 { 1,
197 {
198 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_YCRCB_SWAPUV }
199 }
200 },
201 // RENDERHAL_PLANES_VYUY
202 { 1,
203 {
204 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_YCRCB_SWAPUVY }
205 }
206 },
207 // RENDERHAL_PLANES_ARGB
208 { 1,
209 {
210 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_B8G8R8A8_UNORM }
211 }
212 },
213 // RENDERHAL_PLANES_XRGB
214 { 1,
215 {
216 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_B8G8R8X8_UNORM }
217 }
218 },
219 // RENDERHAL_PLANES_ABGR
220 { 1,
221 {
222 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_UNORM }
223 }
224 },
225 // RENDERHAL_PLANES_XBGR
226 { 1,
227 {
228 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8G8B8X8_UNORM }
229 }
230 },
231 // RENDERHAL_PLANES_RGB16
232 { 1,
233 {
234 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_B5G6R5_UNORM }
235 }
236 },
237 // RENDERHAL_PLANES_RGB24
238 { 1,
239 {
240 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8G8B8_UNORM }
241 }
242 },
243 // RENDERHAL_PLANES_R16U
244 { 1,
245 {
246 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16_UINT }
247 }
248 },
249 // RENDERHAL_PLANES_R16S
250 { 1,
251 {
252 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16_SINT }
253 }
254 },
255 // RENDERHAL_PLANES_R32U
256 { 1,
257 {
258 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R32_UINT }
259 }
260 },
261 // RENDERHAL_PLANES_R32S
262 { 1,
263 {
264 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R32_SINT }
265 }
266 },
267 // RENDERHAL_PLANES_R32F
268 { 1,
269 {
270 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R32_FLOAT }
271 }
272 },
273 // RENDERHAL_PLANES_V8U8
274 { 1,
275 {
276 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8G8_SNORM }
277 }
278 },
279 // RENDERHAL_PLANES_R8G8_UNORM
280 { 1,
281 {
282 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8G8_UNORM }
283 }
284 },
285 // RENDERHAL_PLANES_411P
286 { 3,
287 {
288 { MHW_Y_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM },
289 { MHW_U_PLANE , 4, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM },
290 { MHW_V_PLANE , 4, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM }
291 }
292 },
293 // RENDERHAL_PLANES_411R
294 { 3,
295 {
296 { MHW_Y_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM },
297 { MHW_U_PLANE , 1, 4, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM },
298 { MHW_V_PLANE , 1, 4, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM }
299 }
300 },
301 // RENDERHAL_PLANES_422H
302 { 3,
303 {
304 { MHW_Y_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM },
305 { MHW_U_PLANE , 2, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM },
306 { MHW_V_PLANE , 2, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM }
307 }
308 },
309 // RENDERHAL_PLANES_422V
310 { 3,
311 {
312 { MHW_Y_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM },
313 { MHW_U_PLANE , 1, 2, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM },
314 { MHW_V_PLANE , 1, 2, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM }
315 }
316 },
317 // RENDERHAL_PLANES_444P
318 { 3,
319 {
320 { MHW_Y_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM },
321 { MHW_U_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM },
322 { MHW_V_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM }
323 }
324 },
325 // RENDERHAL_PLANES_RGBP
326 { 3,
327 {
328 { MHW_U_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM },
329 { MHW_V_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM },
330 { MHW_Y_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM }
331 }
332 },
333 // RENDERHAL_PLANES_BGRP
334 { 3,
335 {
336 { MHW_U_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM },
337 { MHW_Y_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM },
338 { MHW_V_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM }
339 }
340 },
341 // RENDERHAL_PLANES_AI44_PALLETE_0
342 { 1,
343 {
344 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_P4A4_UNORM_PALETTE_0 }
345 }
346 },
347 // RENDERHAL_PLANES_IA44_PALLETE_0
348 { 1,
349 {
350 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_A4P4_UNORM_PALETTE_0 }
351 }
352 },
353 // RENDERHAL_PLANES_P8_PALLETE_0
354 { 1,
355 {
356 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_P8_UNORM_PALETTE_0 }
357 }
358 },
359 // RENDERHAL_PLANES_A8P8_PALLETE_0
360 { 1,
361 {
362 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_P8A8_UNORM_PALETTE_0 }
363 }
364 },
365 // RENDERHAL_PLANES_AI44_PALLETE_1
366 { 1,
367 {
368 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_P4A4_UNORM_PALETTE_1 }
369 }
370 },
371 // RENDERHAL_PLANES_IA44_PALLETE_1
372 { 1,
373 {
374 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_A4P4_UNORM_PALETTE_1 }
375 }
376 },
377 // RENDERHAL_PLANES_P8_PALLETE_1
378 { 1,
379 {
380 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_P8_UNORM_PALETTE_1 }
381 }
382 },
383 // RENDERHAL_PLANES_A8P8_PALLETE_1
384 { 1,
385 {
386 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_P8A8_UNORM_PALETTE_1 }
387 }
388 },
389 // RENDERHAL_PLANES_AYUV
390 { 1,
391 {
392 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8B8G8A8_UNORM }
393 }
394 },
395 // RENDERHAL_PLANES_STMM
396 { 1,
397 {
398 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_L8_UNORM }
399 }
400 },
401 // RENDERHAL_PLANES_L8
402 { 1,
403 {
404 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_L8_UNORM }
405 }
406 },
407 // RENDERHAL_PLANES_PL3_ADV
408 { 3,
409 {
410 { MHW_Y_PLANE , 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_Y8_UNORM },
411 { MHW_U_PLANE , 2, 2, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM },
412 { MHW_V_PLANE , 2, 2, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM }
413 }
414 },
415 // RENDERHAL_PLANES_NV12_ADV
416 { 1,
417 {
418 { MHW_Y_PLANE , 1, 1, 2, 2, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_PLANAR_420_8 }
419 }
420 },
421 // RENDERHAL_PLANES_YUY2_ADV
422 { 1,
423 {
424 { MHW_GENERIC_PLANE, 1, 1, 2, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_YCRCB_NORMAL }
425 }
426 },
427 // RENDERHAL_PLANES_UYVY_ADV
428 { 1,
429 {
430 { MHW_GENERIC_PLANE, 1, 1, 2, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_YCRCB_SWAPY }
431 }
432 },
433 // RENDERHAL_PLANES_YVYU_ADV
434 { 1,
435 {
436 { MHW_GENERIC_PLANE, 1, 1, 2, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_YCRCB_SWAPUV }
437 }
438 },
439 // RENDERHAL_PLANES_VYUY_ADV
440 { 1,
441 {
442 { MHW_GENERIC_PLANE, 1, 1, 2, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_YCRCB_SWAPUVY }
443 }
444 },
445 // RENDERHAL_PLANES_ARGB_ADV
446 { 1,
447 {
448 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_B8G8R8A8_UNORM }
449 }
450 },
451 // RENDERHAL_PLANES_ABGR_ADV
452 { 1,
453 {
454 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8G8B8A8_UNORM }
455 }
456 },
457 // RENDERHAL_PLANES_AYUV_ADV
458 { 1,
459 {
460 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 1, MHW_MEDIASTATE_SURFACEFORMAT_A8Y8U8V8_UNORM }
461 }
462 },
463 // RENDERHAL_PLANES_STMM_ADV
464 { 1,
465 {
466 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_STMM_DN_STATISTICS }
467 }
468 },
469 // RENDERHAL_PLANES_L8_ADV
470 { 1,
471 {
472 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM }
473 }
474 },
475 // RENDERHAL_PLANES_A8_ADV
476 { 1,
477 {
478 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_PLANAR_411_8 }
479 }
480 },
481 // RENDERHAL_PLANES_A8
482 { 1,
483 {
484 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_A8_UNORM }
485 }
486 },
487 // RENDERHAL_PLANES_R8
488 { 1,
489 {
490 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM }
491 }
492 },
493 // RENDERHAL_PLANES_NV12_2PLANES
494 { 2,
495 {
496 { MHW_Y_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM },
497 { MHW_U_PLANE , 2, 2, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8G8_UNORM }
498 }
499 },
500 // RENDERHAL_PLANES_NV12_2PLANES_ADV
501 { 2,
502 {
503 { MHW_Y_PLANE , 1, 1, 2, 2, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_Y8_UNORM },
504 { MHW_U_PLANE , 2, 2, 1, 1, 2, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8B8_UNORM }
505 }
506 },
507 // RENDERHAL_PLANES_411P_ADV
508 { 3,
509 {
510 { MHW_Y_PLANE , 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_Y8_UNORM },
511 { MHW_U_PLANE , 4, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM },
512 { MHW_V_PLANE , 4, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM }
513 }
514 },
515 // RENDERHAL_PLANES_411R_ADV
516 { 3,
517 {
518 { MHW_Y_PLANE , 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_Y8_UNORM },
519 { MHW_U_PLANE , 1, 4, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM },
520 { MHW_V_PLANE , 1, 4, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM }
521 }
522 },
523 // RENDERHAL_PLANES_422H_ADV
524 { 3,
525 {
526 { MHW_Y_PLANE , 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_Y8_UNORM },
527 { MHW_U_PLANE , 2, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM },
528 { MHW_V_PLANE , 2, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM }
529 }
530 },
531 // RENDERHAL_PLANES_422V_ADV
532 { 3,
533 {
534 { MHW_Y_PLANE , 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_Y8_UNORM },
535 { MHW_U_PLANE , 1, 2, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM },
536 { MHW_V_PLANE , 1, 2, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM }
537 }
538 },
539 // RENDERHAL_PLANES_444P_ADV
540 { 3,
541 {
542 { MHW_Y_PLANE , 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_Y8_UNORM },
543 { MHW_U_PLANE , 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM },
544 { MHW_V_PLANE , 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM }
545 }
546 },
547 // RENDERHAL_PLANES_RGBP_ADV
548 { 3,
549 {
550 { MHW_U_PLANE , 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_Y8_UNORM },
551 { MHW_V_PLANE , 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM },
552 { MHW_Y_PLANE , 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM }
553 }
554 },
555 // RENDERHAL_PLANES_BGRP_ADV
556 { 3,
557 {
558 { MHW_U_PLANE , 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_Y8_UNORM },
559 { MHW_Y_PLANE , 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM },
560 { MHW_V_PLANE , 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_R8_UNORM }
561 }
562 },
563 // RENDERHAL_PLANES_R16_UNORM
564 { 1,
565 {
566 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16_UNORM }
567 }
568 },
569 // RENDERHAL_PLANES_Y8
570 { 1,
571 {
572 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_PLANAR_411_8 }
573 }
574 },
575 // RENDERHAL_PLANES_Y1
576 { 1,
577 {
578 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 1, 16 }
579 }
580 },
581 // RENDERHAL_PLANES_Y16U
582 { 1,
583 {
584 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 1, MHW_MEDIASTATE_SURFACEFORMAT_STMM_DN_STATISTICS }
585 }
586 },
587 // RENDERHAL_PLANES_Y16S
588 { 1,
589 {
590 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 1, MHW_MEDIASTATE_SURFACEFORMAT_PLANAR_422_8 }
591 }
592 },
593 // RENDERHAL_PLANES_A16B16G16R16
594 { 1,
595 {
596 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 0, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_UNORM } //setting "PixelsPerDword = 0" for sampler_8x8 use
597 }
598 },
599 // RENDERHAL_PLANES_A16B16G16R16_ADV
600 { 1,
601 {
602 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 0, 1, MHW_MEDIASTATE_SURFACEFORMAT_R16G16B16A16 } //setting "PixelsPerDword = 0" for sampler_8x8 use
603 }
604 },
605 // RENDERHAL_PLANES_R10G10B10A2
606 { 1,
607 {
608 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R10G10B10A2_UNORM }
609 }
610 },
611 // RENDERHAL_PLANES_R10G10B10A2_ADV
612 { 1,
613 {
614 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 0, 1, MHW_MEDIASTATE_SURFACEFORMAT_R10G10B10A2_UNORM }
615 }
616 },
617 // RENDERHAL_PLANES_B10G10R10A2
618 { 1,
619 {
620 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_B10G10R10A2_UNORM }
621 }
622 },
623 // RENDERHAL_PLANES_L16
624 { 1,
625 {
626 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_L16_UNORM }
627 }
628 },
629 // RENDERHAL_PLANES_NV21
630 { 2,
631 {
632 { MHW_Y_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM },
633 { MHW_U_PLANE , 2, 2, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8G8_UNORM }
634 }
635 },
636 // RENDERHAL_PLANES_YV12
637 { 1,
638 {
639 { MHW_Y_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_PLANAR_420_8 }
640 }
641 },
642 // RENDERHAL_PLANES_P016
643 { 2,
644 {
645 { MHW_Y_PLANE , 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16_UNORM },
646 { MHW_U_PLANE , 2, 2, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16G16_UNORM }
647 }
648 },
649 // RENDERHAL_PLANES_P016_2PLANES_ADV
650 { 2,
651 {
652 { MHW_Y_PLANE , 1, 1, 2, 2, 2, 1, MHW_MEDIASTATE_SURFACEFORMAT_Y16_UNORM },
653 { MHW_U_PLANE , 2, 2, 2, 2, 1, 1, MHW_MEDIASTATE_SURFACEFORMAT_R16B16_UNORM }
654 }
655 },
656 // RENDERHAL_PLANES_P010
657 { 2,
658 {
659 { MHW_Y_PLANE , 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16_UNORM },
660 { MHW_U_PLANE , 2, 2, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16G16_UNORM }
661 }
662 },
663 // RENDERHAL_PLANES_P010_1PLANE
664 { 1,
665 {
666 { MHW_Y_PLANE , 1, 1, 2, 2, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_PLANAR_420_16 }
667 }
668 },
669 // RENDERHAL_PLANES_P010_1PLANE_ADV
670 { 1,
671 {
672 { MHW_Y_PLANE , 1, 1, 2, 2, 2, 1, MHW_MEDIASTATE_SURFACEFORMAT_PLANAR_420_16 }
673 }
674 },
675 // RENDERHAL_PLANES_IRW0
676 { 1,
677 {
678 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16_UNORM }
679 }
680 },
681 // RENDERHAL_PLANES_IRW1
682 { 1,
683 {
684 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16_UNORM }
685 }
686 },
687 // RENDERHAL_PLANES_IRW2
688 { 1,
689 {
690 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16_UNORM }
691 }
692 },
693 // RENDERHAL_PLANES_IRW3
694 { 1,
695 {
696 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16_UNORM }
697 }
698 },
699 // RENDERHAL_PLANES_A16B16G16R16F
700 {1,
701 {
702 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 0, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_FLOAT } //setting "PixelsPerDword = 0" in DP R/W usage, "0" means no need to adjust dwSurfaceWidth. already DWord aligned.
703 }
704 },
705 // RENDERHAL_PLANES_R16G16_UNORM
706 {1,
707 {
708 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16G16_UNORM }
709 }
710 },
711 // RENDERHAL_PLANES_R16F
712 { 1,
713 {
714 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16_FLOAT }
715 }
716 },
717 // RENDERHAL_PLANES_A16R16G16B16F
718 {1,
719 {
720 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 0, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_FLOAT } //setting "PixelsPerDword = 0" in DP R/W usage, "0" means no need to adjust dwSurfaceWidth. already DWord aligned.
721 }
722 },
723 // RENDERHAL_PLANES_YUY2_2PLANES
724 { 2,
725 {
726 { MHW_Y_PLANE, 1, 1, 2, 2, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8G8_UNORM },
727 { MHW_U_PLANE, 2, 1, 2, 2, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_UNORM }
728 }
729 },
730 // RENDERHAL_PLANES_Y210_ADV
731 { 2,
732 {
733 { MHW_Y_PLANE, 1, 1, 1, 1, 1, 1, MHW_MEDIASTATE_SURFACEFORMAT_R16B16_UNORM },
734 { MHW_U_PLANE, 2, 1, 1, 1, 0, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_UNORM }
735 }
736 },
737 // RENDERHAL_PLANES_Y210_RT
738 { 1,
739 {
740 { MHW_GENERIC_PLANE, 2, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_UNORM }
741 }
742 },
743 // RENDERHAL_PLANES_Y210
744 { 2,
745 {
746 { MHW_Y_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16G16_UNORM },
747 { MHW_U_PLANE, 2, 1, 1, 1, 0, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_UNORM }
748 }
749 },
750 // RENDERHAL_PLANES_Y210_1PLANE_ADV
751 { 1,
752 {
753 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 1, MHW_MEDIASTATE_SURFACEFORMAT_R16B16_UNORM }
754 }
755 },
756 // RENDERHAL_PLANES_R16G16_SINT
757 { 1,
758 {
759 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R16G16_SINT }
760 }
761 },
762 // RENDERHAL_PLANES_R24_UNORM_X8_TYPELESS
763 { 1,
764 {
765 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R24_UNORM_X8_TYPELESS }
766 }
767 },
768 // RENDERHAL_PLANES_R32_FLOAT_X8X24_TYPELESS
769 { 1,
770 {
771 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 0, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R32_FLOAT_X8X24_TYPELESS }
772 }
773 },
774 // RENDERHAL_PLANES_P208
775 { 2,
776 {
777 { MHW_Y_PLANE , 1, 1, 1, 1, 4, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM },
778 { MHW_U_PLANE , 2, 1, 1, 1, 2, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8G8_UNORM }
779 }
780 },
781 // RENDERHAL_PLANES_P208_1PLANE_ADV
782 { 1,
783 {
784 { MHW_GENERIC_PLANE, 1, 1, 2, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_YCRCB_NORMAL }
785 }
786 },
787 // RENDERHAL_PLANES_Y416_RT
788 { 1,
789 {
790 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 1, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_UNORM }
791 }
792 },
793 // RENDERHAL_PLANES_R32G32B32A32
794 { 1,
795 {
796 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 0, 0, MHW_GFX3DSTATE_SURFACEFORMAT_R32G32B32A32_FLOAT }
797 }
798 },
799 //RENDERHAL_PLANES_Y8_ADV
800 { 1,
801 {
802 { MHW_GENERIC_PLANE, 1, 1, 1, 1, 4, 1, MHW_MEDIASTATE_SURFACEFORMAT_Y8_UNORM }
803 }
804 }
805 };
806
807 //!
808 //! \brief Get Y Offset according to the planeOffset struct and surface pitch
809 //! \details Get Y Offset according to the planeOffset struct and surface pitch
810 //! \param pOsInterface
811 //! [in] pointer to OS Interface
812 //! \param pOsResource
813 //! [in] Pointers to Surface OsResource
814 //! \return uint16_t
815 //! [out] the plane Y offset
816 //!
817 uint16_t RenderHal_CalculateYOffset(PMOS_INTERFACE pOsInterface, PMOS_RESOURCE pOsResource);
818
819 MOS_STATUS RenderHal_AllocateDebugSurface(
820 PRENDERHAL_INTERFACE pRenderHal);
821
822 MOS_STATUS RenderHal_SetupDebugSurfaceState(
823 PRENDERHAL_INTERFACE pRenderHal);
824
825 void RenderHal_FreeDebugSurface(
826 PRENDERHAL_INTERFACE pRenderHal);
827
828 int32_t RenderHal_LoadDebugKernel(
829 PRENDERHAL_INTERFACE pRenderHal,
830 PMHW_KERNEL_PARAM pSipKernel);
831
832 MOS_STATUS RenderHal_LoadSipKernel(
833 PRENDERHAL_INTERFACE pRenderHal,
834 void *pSipKernel,
835 uint32_t dwSipSize);
836
837 MOS_STATUS RenderHal_SendSipStateCmd(
838 PRENDERHAL_INTERFACE pRenderHal,
839 PMOS_COMMAND_BUFFER pCmdBuffer);
840
841 MOS_STATUS RenderHal_AddDebugControl(
842 PRENDERHAL_INTERFACE pRenderHal,
843 PMOS_COMMAND_BUFFER pCmdBuffer);
844
845 //Forward declaration
846 MOS_STATUS RenderHal_SetSurfaceStateToken(
847 PRENDERHAL_INTERFACE pRenderHal,
848 PMHW_SURFACE_TOKEN_PARAMS pParams,
849 void *pSurfaceStateToken);
850
851 //!
852 //! \brief Get Align Unit
853 //! \details Set HW alignment Unit
854 //! \param uint16_t *pwWidthAlignUnit
855 //! [out] Width Align Unit
856 //! \param uint16_t *pwHeightAlignUnit
857 //! [out] Height Align Unit
858 //! \param PRENDERHAL_SURFACE pRenderHalSurface
859 //! [in] Pointer to Surface
860 //! \return void
861 //!
RenderHal_GetAlignUnit(uint16_t * pwWidthAlignUnit,uint16_t * pwHeightAlignUnit,PRENDERHAL_SURFACE pRenderHalSurface)862 void RenderHal_GetAlignUnit(
863 uint16_t *pwWidthAlignUnit,
864 uint16_t *pwHeightAlignUnit,
865 PRENDERHAL_SURFACE pRenderHalSurface)
866 {
867 MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pRenderHalSurface);
868
869 switch (pRenderHalSurface->OsSurface.Format)
870 {
871 case Format_YUY2:
872 case Format_UYVY:
873 case Format_YVYU:
874 case Format_VYUY:
875 case Format_P208:
876 *pwWidthAlignUnit = 1;
877
878 // Height alignment should be 1 but is currently set to 2 because
879 // of an issue in AVS scaling.
880 *pwHeightAlignUnit = 2;
881 break;
882
883 default:
884 *pwWidthAlignUnit = 1;
885 *pwHeightAlignUnit = 1;
886 break;
887 }
888
889 // For deinterlace messages, the width must be a multiple of 8.
890 if (pRenderHalSurface->bDeinterlaceEnable)
891 {
892 *pwWidthAlignUnit = 8;
893 }
894 }
895
896 //!
897 //! \brief Adjust Boundary
898 //! \details Adjust the height and width of the surface based on Boundary
899 //! \param PRENDERHAL_INTERFACE pRenderHal
900 //! [in] Pointer to Hardware Interface
901 //! \param PRENDERHAL_SURFACE pRenderHalSurface
902 //! [in] Pointer to Input Surface
903 //! \param RENDERHAL_SS_BOUNDARY Boundary
904 //! [in] How the adjustment needs to be done
905 //! \param uint32_t *pdwSurfaceWidth
906 //! [out] Adjusted surface width
907 //! \param uint32_t *pdwSurfaceHeight
908 //! [out] Adjusted surface height
909 //! \return void
910 //!
RenderHal_AdjustBoundary(PRENDERHAL_INTERFACE pRenderHal,PRENDERHAL_SURFACE pRenderHalSurface,RENDERHAL_SS_BOUNDARY Boundary,uint32_t * pdwSurfaceWidth,uint32_t * pdwSurfaceHeight)911 void RenderHal_AdjustBoundary(
912 PRENDERHAL_INTERFACE pRenderHal,
913 PRENDERHAL_SURFACE pRenderHalSurface,
914 RENDERHAL_SS_BOUNDARY Boundary,
915 uint32_t *pdwSurfaceWidth,
916 uint32_t *pdwSurfaceHeight)
917 {
918 uint16_t wWidthAlignUnit;
919 uint16_t wHeightAlignUnit;
920
921 MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pRenderHal);
922 MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pRenderHalSurface);
923 MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pdwSurfaceWidth);
924 MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pdwSurfaceHeight);
925
926 PMOS_SURFACE pSurface = &(pRenderHalSurface->OsSurface);
927
928 pRenderHal->pfnGetAlignUnit(&wWidthAlignUnit, &wHeightAlignUnit, pRenderHalSurface);
929
930 switch (Boundary)
931 {
932 case RENDERHAL_SS_BOUNDARY_SRCRECT:
933 *pdwSurfaceHeight = MOS_ALIGN_CEIL(MOS_MIN(pSurface->dwHeight, (uint32_t)pRenderHalSurface->rcSrc.bottom), wHeightAlignUnit);
934 *pdwSurfaceWidth = MOS_ALIGN_CEIL(MOS_MIN(pSurface->dwWidth, (uint32_t)pRenderHalSurface->rcSrc.right), wWidthAlignUnit);
935 break;
936
937 case RENDERHAL_SS_BOUNDARY_DSTRECT:
938 *pdwSurfaceHeight = MOS_ALIGN_CEIL(MOS_MIN(pSurface->dwHeight, (uint32_t)pRenderHalSurface->rcDst.bottom), wHeightAlignUnit);
939 *pdwSurfaceWidth = MOS_ALIGN_CEIL(MOS_MIN(pSurface->dwWidth, (uint32_t)pRenderHalSurface->rcDst.right), wWidthAlignUnit);
940 break;
941
942 // align with max src rect
943 case RENDERHAL_SS_BOUNDARY_MAXSRCRECT:
944 *pdwSurfaceHeight = MOS_ALIGN_CEIL(MOS_MIN(pSurface->dwHeight, (uint32_t)pRenderHalSurface->rcMaxSrc.bottom), wHeightAlignUnit);
945 *pdwSurfaceWidth = MOS_ALIGN_CEIL(MOS_MIN(pSurface->dwWidth, (uint32_t)pRenderHalSurface->rcMaxSrc.right), wWidthAlignUnit);
946 break;
947
948 case RENDERHAL_SS_BOUNDARY_ORIGINAL:
949 default:
950 *pdwSurfaceHeight = (pRenderHalSurface->dwHeightInUse == 0) ? MOS_ALIGN_CEIL(pSurface->dwHeight, wHeightAlignUnit) : pRenderHalSurface->dwHeightInUse;
951 *pdwSurfaceWidth = (pRenderHalSurface->dwWidthInUse == 0) ? MOS_ALIGN_CEIL(pSurface->dwWidth, wWidthAlignUnit) : pRenderHalSurface->dwWidthInUse;
952 break;
953 }
954 }
955
956 //!
957 //! \brief Get Pixels Per Sample
958 //! \details Get Number of Pixels per Dataport Sample
959 //! \param MOS_FORMAT format
960 //! [in] Surface Format
961 //! \param uint32_t *pdwPixelsPerSampleUV
962 //! [in] Pointer to dwPixelsPerSampleUV
963 //! \return void
964 //!
RenderHal_GetPixelsPerSample(MOS_FORMAT format,uint32_t * pdwPixelsPerSampleUV)965 void RenderHal_GetPixelsPerSample(
966 MOS_FORMAT format,
967 uint32_t *pdwPixelsPerSampleUV)
968 {
969 MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pdwPixelsPerSampleUV);
970
971 *pdwPixelsPerSampleUV = 0;
972 switch (format)
973 {
974 CASE_PL3_FORMAT:
975 CASE_PL3_RGB_FORMAT:
976 *pdwPixelsPerSampleUV = 4; // 4 U/V pixels per dataport sample (uint32_t)
977 break;
978
979 // Y and UV surfaces have different formats
980 CASE_PL2_FORMAT:
981 case Format_400P:
982 *pdwPixelsPerSampleUV = 2; // 2 UV pixels per dataport sample (uint32_t)
983 break;
984
985 default:
986 *pdwPixelsPerSampleUV = 1;
987 MHW_RENDERHAL_ASSERTMESSAGE("Incorrect Filter Format.");
988 break;
989 }
990 }
991
992 //!
993 //! \brief Allocate GSH, SSH, ISH control structures and heaps
994 //! \details Allocates State Heap control structure (system memory)
995 //! and associated State Buffer in gfx/sys memory (GSH,ISH,SSH)
996 //! initializes the State Heap control structure and state buffers
997 /*-----------------------------------------------------------------------------
998 |
999 | GSH ORGANIZATION (GSH block in GFX memory)
1000 |
1001 | |===========================================|
1002 | | SYNC/PERF TAGS (SY) |
1003 | |-------------------------------------------|
1004 | | |
1005 | | MEDIA STATE [0] (MS) |
1006 | | |
1007 | |-------------------------------------------|
1008 | | |
1009 | | ... |
1010 | | |
1011 | |-------------------------------------------|
1012 | | |
1013 | | MEDIA STATE [Q-1] |
1014 | | |
1015 | |-------------------------------------------|
1016 | | |
1017 | | KERNEL SPILL AREA |
1018 | | |
1019 | |===========================================|
1020 | where SY = (sSettings.iSyncSize) bytes
1021 | MS = Media state heap entry shown below.
1022 | Q = (sSettings.iMediaStateHeaps) Media States
1023 |
1024 | ISH ORGANIZATION (ISH block in GFX memory)
1025 | ~~~~~~~~~~~~~~~~~~~~~~~~
1026 |
1027 | |===========================================|
1028 | | | | | | | | | | | | |
1029 | |---+---+---+---+---+---+---+---+---+---+---|
1030 | | | | | | | | | | | | |
1031 | |---+---+-- --+---+---|
1032 | | KERNEL HEAP (KH) |
1033 | |---+---+-- --+---+---|
1034 | | | | | | | | | | | | |
1035 | |---+---+---+---+---+---+---+---+---+---+---|
1036 | | | | | | | | | | | | |
1037 | |-------------------------------------------|
1038 | | |
1039 | | SYSTEM ROUTINE (SIP Kernel) |
1040 | | |
1041 | |===========================================|
1042 | where KH = (sSettings.iKernelHeapSize) bytes in allocation
1043 | blocks of (sSettings.iKernelBlockSize) bytes
1044 |
1045 | MEDIA STATE ORGANIZATION (Media States in GFX memory)
1046 | ~~~~~~~~~~~~~~~~~~~~~~~~
1047 | (Gen6, Gen7, Gen75 Layout)
1048 | |================================================|
1049 | | |
1050 | | CURBE DATA (C) |
1051 | | |
1052 | |------------------------------------------------|
1053 | | SAMPLER STATES [0] to [S-1] - for ID[0] |
1054 | | . |
1055 | | . |
1056 | | SAMPLER STATES [0] to [S-1] - for ID[M-1] |
1057 | |------------------------------------------------|
1058 | | SAMPLER 8x8 TABLE [0] |
1059 | | . |
1060 | | SAMPLER 8x8 TABLE [AS-1] |
1061 | |------------------------------------------------|
1062 | | MEDIA INTERFACE DESCRIPTOR [0] |
1063 | | . |
1064 | | . |
1065 | | MEDIA INTERFACE DESCRIPTOR [M-1] |
1066 | |------------------------------------------------|
1067 | | Kernel Execution start time (8 Bytes) |
1068 | |------------------------------------------------|
1069 | | Kernel Execution end time (8 Bytes) |
1070 | |------------------------------------------------|
1071 | | Component ID (4 Bytes) |
1072 | |------------------------------------------------|
1073 | | Reserved (44 Bytes) |
1074 | |================================================|
1075 |
1076 | (Gen8+ Layout)
1077 | |================================================|
1078 | | |
1079 | | CURBE DATA (C) |
1080 | | |
1081 | |------------------------------------------------|
1082 | | SAMPLER STATES [0] to [S-1] |
1083 | | VA SAMPLER 8x8 STATE [0] to [VA-1] | ID[0]
1084 | | AVS SAMPLER 8x8 STATE [0] to [AS-1] |
1085 | |------------------------------------------------|
1086 | | . |
1087 | | . |
1088 | | . |
1089 | |------------------------------------------------|
1090 | | SAMPLER STATES [0] to [S-1] | ID[M-1]
1091 | | VA SAMPLER 8x8 STATE [0] to [VA-1] |
1092 | | AVS SAMPLER 8x8 STATE [0] to [AS-1] |
1093 | |------------------------------------------------|
1094 | | MEDIA INTERFACE DESCRIPTOR [0] |
1095 | | . |
1096 | | . |
1097 | | MEDIA INTERFACE DESCRIPTOR [M-1] |
1098 | |------------------------------------------------|
1099 | | Kernel Execution start time (8 Bytes) |
1100 | |------------------------------------------------|
1101 | | Kernel Execution end time (8 Bytes) |
1102 | |------------------------------------------------|
1103 | | Component ID (4 Bytes) |
1104 | |------------------------------------------------|
1105 | | Reserved (44 Bytes) |
1106 | |================================================|
1107 |
1108 | where C = (sSettings.iCurbeSize) bytes for static parameters
1109 | S = (sSettings.iSamplers) samplers per Media ID
1110 | AS = (sSettings.iSamplersAVS) advanced sampler 8x8 tables (preGen8)
1111 | AS = (sSettings.iSamplersAVS) advanced sampler 8x8 states (Gen8+)
1112 | VA = (sSettings.iSamplersVA) video analytics sampler
1113 | M = (sSettings.iMediaIDs) Media Interface Descriptors (ID)
1114 |
1115 |
1116 | STATE HEAP CONTROL STRUCTURE ORGANIZATION (in system memory)
1117 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1118 | |===========================================|
1119 | | RENDERHAL_STATE_HEAP STRUCTURE |
1120 | | |
1121 | +---------| pSshBuffer |
1122 | | |-------------------------------------------|
1123 | | | Kernel Allocation [0] |
1124 | | | . |
1125 | | | . |
1126 | | | Kernel Allocation [K-1] |
1127 | | |-------------------------------------------|
1128 | | | Media State Control Structure [0] |--+
1129 | | | Media State Control Structure [1] |--|--+
1130 | | | . | | |
1131 | | | . | | |
1132 | | | Media State Control Structure [Q-1] |--|--|--+
1133 | | |-------------------------------------------| | | |
1134 | | | KAID[0] to KAID[M-1] for Media State[0] |<-+ | |
1135 | | | KAID[0] to KAID[M-1] for Media State[1] |<----+ |
1136 | | | . | |
1137 | | | . | |
1138 | | | KAID[0] to KAID[M-1] for Media State[Q-1] |<-------+
1139 | | |-------------------------------------------|
1140 | | +------| SurfStateEntry[0] |
1141 | | | | . |
1142 | | | | . |
1143 | | | +---| SurfStateEntry[P-1] |
1144 | | | | |===========================================|
1145 | | | |
1146 | | | | SSH BUFFER for HW (or SW) - or IndirectBuffer
1147 | +--|--|-->|==============================| <-- iBindingTableOffset = 0
1148 | | | | BI[0] ...... BI[T-1] | <- BT[0] (iBindingTableSize)
1149 | | | | BI[0] ...... BI[T-1] | <- BT[1]
1150 | | | | . |
1151 | | | | BI[0] ...... BI[T-1] | <- BT[N-1]
1152 | | | |------------------------------| <-- iSurfaceStateOffset
1153 | +--|-->| SurfState[0] |
1154 | | | . |
1155 | | | . |
1156 | +-->| SurfState[P-1] |
1157 | |==============================|
1158 |
1159 | where K = (sSettings.iKernelCount) Kernel Allocation Entries
1160 | Q = (sSettings.iMediaStateHeaps) Media States
1161 | M = (sSettings.iMediaIDs) Media Interface Descriptors (ID)
1162 | P = (sSettings.iSurfaceStates) Surface States
1163 | T = (sSettings.iSurfacesPerBT) Binding Index entries per Binding Table
1164 | N = (sSettings.iBindingTables) Binding Tables
1165 |
1166 | BT = Binding Table (Each Binding Table contains M Binding Indices)
1167 | BI = Binding Index
1168 |
1169 | KAID => Kernel Allocation ID - each value determines the kernel
1170 | allocation entry in StateHeap (0 to sSettings.iKernelCount - 1)
1171 |
1172 |-----------------------------------------------------------------------------*/
1173 //! \param PRENDERHAL_INTERFACE pRenderHal
1174 //! [in] Pointer to Rendering Interface Structure
1175 //! \param PRENDERHAL_STATE_HEAP_SETTINGS pSettings
1176 //! [in] Pointer to state heap settings (GSH/SSH/ISH)
1177 //! \return MOS_STATUS
1178 //! MOS_STATUS_SUCCESS if state heaps were successfully allocated and initialized
1179 //! others if bad parameters or allocation failed
1180 //!
RenderHal_AllocateStateHeaps(PRENDERHAL_INTERFACE pRenderHal,PRENDERHAL_STATE_HEAP_SETTINGS pSettings)1181 MOS_STATUS RenderHal_AllocateStateHeaps(
1182 PRENDERHAL_INTERFACE pRenderHal,
1183 PRENDERHAL_STATE_HEAP_SETTINGS pSettings)
1184 {
1185 MHW_STATE_HEAP_SETTINGS MhwStateHeapSettings;
1186 PMHW_RENDER_STATE_SIZES pHwSizes;
1187 PRENDERHAL_STATE_HEAP pStateHeap;
1188 int32_t *pAllocations;
1189 uint32_t dwSizeAlloc;
1190 uint32_t dwSizeGSH;
1191 uint32_t dwSizeSSH;
1192 uint32_t dwSizeISH;
1193 uint32_t dwSizeMediaState;
1194 PMHW_STATE_HEAP pDshHeap;
1195 PMHW_STATE_HEAP pIshHeap;
1196 int32_t i;
1197 uint8_t *ptr;
1198 MOS_STATUS eStatus;
1199
1200 // Initialize locals
1201 eStatus = MOS_STATUS_UNKNOWN;
1202 pStateHeap = nullptr;
1203
1204 //---------------------------------------
1205 MHW_RENDERHAL_CHK_NULL(pRenderHal);
1206 MHW_RENDERHAL_CHK_NULL(pRenderHal->pOsInterface);
1207 MHW_RENDERHAL_CHK_NULL(pRenderHal->pMhwRenderInterface);
1208 MHW_RENDERHAL_CHK_NULL(pSettings);
1209 // verify GSH parameters and alignments
1210 MHW_RENDERHAL_ASSERT((pSettings->iSyncSize % RENDERHAL_SYNC_BLOCK_ALIGN) == 0);
1211 MHW_RENDERHAL_ASSERT((pSettings->iCurbeSize % RENDERHAL_URB_BLOCK_ALIGN) == 0);
1212 MHW_RENDERHAL_ASSERT((pSettings->iKernelHeapSize % RENDERHAL_KERNEL_BLOCK_ALIGN) == 0);
1213 MHW_RENDERHAL_ASSERT((pSettings->iKernelBlockSize % RENDERHAL_KERNEL_BLOCK_ALIGN) == 0);
1214 // verify SSH parameters
1215 MHW_RENDERHAL_ASSERT(pSettings->iBindingTables >= RENDERHAL_SSH_BINDING_TABLES_MIN);
1216 MHW_RENDERHAL_ASSERT(pSettings->iBindingTables <= RENDERHAL_SSH_BINDING_TABLES_MAX);
1217 MHW_RENDERHAL_ASSERT(pSettings->iSurfaceStates >= RENDERHAL_SSH_SURFACE_STATES_MIN);
1218 MHW_RENDERHAL_ASSERT(pSettings->iSurfaceStates <= RENDERHAL_SSH_SURFACE_STATES_MAX);
1219 MHW_RENDERHAL_ASSERT(pSettings->iSurfacesPerBT >= RENDERHAL_SSH_SURFACES_PER_BT_MIN);
1220 MHW_RENDERHAL_ASSERT(pSettings->iSurfacesPerBT <= RENDERHAL_SSH_SURFACES_PER_BT_MAX);
1221 //---------------------------------------
1222
1223 pHwSizes = pRenderHal->pHwSizes;
1224
1225 //---------------------------------------
1226 // Setup General State Heap
1227 //---------------------------------------
1228 // Calculate size of State Heap control structure
1229 dwSizeAlloc = MOS_ALIGN_CEIL(sizeof(RENDERHAL_STATE_HEAP) , 16);
1230 dwSizeAlloc += MOS_ALIGN_CEIL(pSettings->iKernelCount * sizeof(RENDERHAL_KRN_ALLOCATION) , 16);
1231 dwSizeAlloc += MOS_ALIGN_CEIL(pSettings->iMediaStateHeaps * sizeof(RENDERHAL_MEDIA_STATE) , 16);
1232 dwSizeAlloc += MOS_ALIGN_CEIL(pSettings->iMediaStateHeaps * pSettings->iMediaIDs * sizeof(int32_t) , 16);
1233 dwSizeAlloc += MOS_ALIGN_CEIL(pSettings->iSurfaceStates * sizeof(RENDERHAL_SURFACE_STATE_ENTRY), 16);
1234
1235 // Allocate State Heap control structure (aligned)
1236 pRenderHal->pStateHeap = pStateHeap = (PRENDERHAL_STATE_HEAP)MOS_AlignedAllocMemory(dwSizeAlloc, 16);
1237 pRenderHal->dwStateHeapSize = dwSizeAlloc;
1238
1239 MHW_RENDERHAL_CHK_NULL(pStateHeap);
1240 MOS_ZeroMemory(pStateHeap, dwSizeAlloc);
1241
1242 //-------------------------------------------------------------------------
1243 // Reset resource allocations
1244 //-------------------------------------------------------------------------
1245 Mos_ResetResource(&pStateHeap->GshOsResource);
1246 pStateHeap->bGshLocked = false;
1247 pStateHeap->pGshBuffer = nullptr;
1248
1249 Mos_ResetResource(&pStateHeap->SshOsResource);
1250 pStateHeap->pSshBuffer = nullptr;
1251 pStateHeap->bSshLocked = false;
1252
1253 Mos_ResetResource(&pStateHeap->IshOsResource);
1254 pStateHeap->bIshLocked = false;
1255 pStateHeap->pIshBuffer = nullptr;
1256
1257 //-------------------------------------------------------------------------
1258 // Setup State Heap control structures
1259 //-------------------------------------------------------------------------
1260 // Skip RENDERHAL_STATE_HEAP structure
1261 ptr = (uint8_t*)pStateHeap;
1262 ptr += MOS_ALIGN_CEIL(sizeof(RENDERHAL_STATE_HEAP), 16);
1263
1264 // Pointer to Kernel allocations
1265 pStateHeap->pKernelAllocation = (PRENDERHAL_KRN_ALLOCATION) ptr;
1266 ptr += MOS_ALIGN_CEIL(pSettings->iKernelCount * sizeof(RENDERHAL_KRN_ALLOCATION), 16);
1267
1268 // Pointer to Media State allocations
1269 pStateHeap->pMediaStates = (PRENDERHAL_MEDIA_STATE) ptr;
1270 ptr += MOS_ALIGN_CEIL(pSettings->iMediaStateHeaps * sizeof(RENDERHAL_MEDIA_STATE), 16);
1271
1272 // Pointer to Media ID allocations
1273 pAllocations = (int32_t*) ptr;
1274 ptr += MOS_ALIGN_CEIL(pSettings->iMediaStateHeaps * pSettings->iMediaIDs * sizeof(int32_t), 16);
1275
1276 // Pointer to Surface State allocations
1277 pStateHeap->pSurfaceEntry = (PRENDERHAL_SURFACE_STATE_ENTRY) ptr;
1278
1279 //-------------------------------------------------------------------------
1280 // Calculate offsets/sizes in GSH
1281 //-------------------------------------------------------------------------
1282 // Synchronization, debugging data
1283 pStateHeap->dwOffsetSync = 0;
1284 pStateHeap->dwSizeSync = pSettings->iSyncSize;
1285 pStateHeap->dwNextTag = 0;
1286 pStateHeap->dwSyncTag = 0;
1287 dwSizeGSH = pStateHeap->dwSizeSync;
1288
1289 // Align Media State base
1290 dwSizeGSH = MOS_ALIGN_CEIL(dwSizeGSH, MHW_MEDIA_STATE_ALIGN);
1291
1292 dwSizeMediaState = 0;
1293
1294 // Reset current media state
1295 pStateHeap->iCurMediaState = 0;
1296 pStateHeap->iNextMediaState = 0;
1297
1298 // Constant URBs
1299 pStateHeap->dwOffsetCurbe = dwSizeMediaState;
1300 pStateHeap->dwSizeCurbe = pSettings->iCurbeSize;
1301 dwSizeMediaState += pStateHeap->dwSizeCurbe;
1302
1303 // Allocate Samplers
1304 if (pRenderHal->bHasCombinedAVSSamplerState == false)
1305 {
1306 // Sampler states
1307 pStateHeap->dwOffsetSampler = dwSizeMediaState;
1308 pStateHeap->dwSizeSampler = MOS_ALIGN_CEIL(pSettings->iSamplers * pHwSizes->dwSizeSamplerState, MHW_SAMPLER_STATE_ALIGN);
1309 pStateHeap->dwSizeSamplers = pStateHeap->dwSizeSampler;
1310 dwSizeMediaState += pSettings->iMediaIDs * pStateHeap->dwSizeSamplers;
1311
1312 // Sampler 8x8 State table is allocated in this area
1313 pStateHeap->dwOffsetSampler8x8Table = dwSizeMediaState;
1314 pStateHeap->dwSizeSampler8x8Table = MOS_ALIGN_CEIL(pHwSizes->dwSizeSamplerStateTable8x8, MHW_SAMPLER_STATE_ALIGN);
1315 dwSizeMediaState += pSettings->iSamplersAVS * pHwSizes->dwSizeSampler8x8Table;
1316 }
1317 else
1318 {
1319 // Sampler states - Start of this area to be aligned on MHW_SAMPLER_STATE_ALIGN byte boundary
1320 uint32_t dwOffsetSamplers = dwSizeMediaState;
1321 pStateHeap->dwOffsetSampler = dwSizeMediaState;
1322 pStateHeap->dwSizeSampler = MOS_ALIGN_CEIL(pSettings->iSamplers * pHwSizes->dwSizeSamplerState, MHW_SAMPLER_STATE_ALIGN);
1323 dwSizeMediaState += pStateHeap->dwSizeSampler;
1324
1325 // Sampler for MinMax, Erode and Dilate - Start of this area to be aligned on MHW_SAMPLER_STATE_VA_ALIGN byte boundary
1326 pStateHeap->dwOffsetSamplerVA = dwSizeMediaState;
1327 pStateHeap->dwSizeSamplerVA = MOS_ALIGN_CEIL(pSettings->iSamplersVA * pHwSizes->dwSizeSamplerStateVA, MHW_SAMPLER_STATE_VA_ALIGN);
1328 dwSizeMediaState += pStateHeap->dwSizeSamplerVA;
1329
1330 // Sampler for AVS - Start of this area to be aligned on 64 byte boundary
1331 if(GFX_IS_GEN_9_OR_LATER(pRenderHal->Platform))
1332 {
1333 // AVS state should begin on MHW_SAMPLER_STATE_AVS_ALIGN_G9 byte boundary in g9+
1334 dwSizeMediaState = MOS_ALIGN_CEIL((dwSizeMediaState - pStateHeap->dwSizeCurbe), MHW_SAMPLER_STATE_AVS_ALIGN_G9) + pStateHeap->dwSizeCurbe;
1335 }
1336
1337 pStateHeap->dwOffsetSamplerAVS = dwSizeMediaState;
1338 pStateHeap->dwSizeSamplerAVS = MOS_ALIGN_CEIL(pSettings->iSamplersAVS *
1339 pHwSizes->dwSizeSamplerStateAvs, MHW_SAMPLER_STATE_AVS_ALIGN);
1340 dwSizeMediaState += pStateHeap->dwSizeSamplerAVS;
1341
1342 // Sampler Indirect State
1343 pStateHeap->dwOffsetSamplerIndirect = dwSizeMediaState;
1344 pStateHeap->dwSizeSamplerIndirect = MOS_ALIGN_CEIL(pSettings->iSamplers * pHwSizes->dwSizeSamplerIndirectState, MHW_SAMPLER_STATE_ALIGN);
1345 dwSizeMediaState += pStateHeap->dwSizeSamplerIndirect;
1346
1347 // Get the total size of all the samplers
1348 pStateHeap->dwSizeSamplers = MOS_ALIGN_CEIL((dwSizeMediaState - dwOffsetSamplers), MHW_SAMPLER_STATE_ALIGN);
1349 dwSizeMediaState += pSettings->iMediaIDs * pStateHeap->dwSizeSamplers;
1350
1351 // Sampler 8x8 State table is part of Sampler8x8 state
1352 pStateHeap->dwOffsetSampler8x8Table = 0;
1353 pStateHeap->dwSizeSampler8x8Table = pHwSizes->dwSizeSamplerStateTable8x8;
1354 }
1355
1356 // Interface Descriptors
1357 pStateHeap->dwOffsetMediaID = dwSizeMediaState;
1358 pStateHeap->dwSizeMediaID = pHwSizes->dwSizeInterfaceDescriptor;
1359 dwSizeMediaState += pSettings->iMediaIDs * pStateHeap->dwSizeMediaID;
1360
1361 // 3P Budget
1362 pStateHeap->dwOffsetStartTime = dwSizeMediaState;
1363 pStateHeap->dwStartTimeSize = sizeof(uint64_t);
1364 dwSizeMediaState += pStateHeap->dwStartTimeSize;
1365
1366 pStateHeap->dwOffsetEndTime = dwSizeMediaState;
1367 pStateHeap->dwEndTimeSize = sizeof(uint64_t);
1368 dwSizeMediaState += pStateHeap->dwEndTimeSize;
1369
1370 pStateHeap->dwOffsetComponentID = dwSizeMediaState;
1371 pStateHeap->dwComponentIDSize = sizeof(uint32_t);
1372 dwSizeMediaState += pStateHeap->dwComponentIDSize;
1373
1374 pStateHeap->dwOffsetReserved = dwSizeMediaState;
1375 pStateHeap->dwReservedSize = 44; // 64 - 2 * sizeof(uint64_t) - sizeof(uint32_t);
1376 dwSizeMediaState += pStateHeap->dwReservedSize;
1377
1378 // Ensure correct alignment of consecutive Media States
1379 if(GFX_IS_GEN_9_OR_LATER(pRenderHal->Platform))
1380 {
1381 dwSizeMediaState = MOS_ALIGN_CEIL(dwSizeMediaState, MHW_SAMPLER_STATE_AVS_ALIGN_G9);
1382 }
1383 else
1384 {
1385 dwSizeMediaState = MOS_ALIGN_CEIL(dwSizeMediaState, MHW_SAMPLER_STATE_AVS_ALIGN);
1386 }
1387
1388 // Create multiple instances of Media state heaps for Dynamic GSH
1389 for (i = 0; i < pSettings->iMediaStateHeaps; i++)
1390 {
1391 pStateHeap->pMediaStates[i].dwOffset = dwSizeGSH;
1392 pStateHeap->pMediaStates[i].piAllocation = pAllocations;
1393 dwSizeGSH += dwSizeMediaState;
1394 pAllocations += pSettings->iMediaIDs;
1395 }
1396
1397 // Kernel Spill Area
1398 if (pSettings->iPerThreadScratchSize > 0)
1399 {
1400 // Scratch Space Base Pointer. Specifies the MHW_SCRATCH_SPACE_ALIGN
1401 // aligned address offset to scratch space for use by the kernel.
1402 // This pointer is relative to the General State Base Address.
1403 dwSizeGSH = MOS_ALIGN_CEIL(dwSizeGSH, MHW_SCRATCH_SPACE_ALIGN);
1404
1405 MHW_RENDERHAL_ASSERT(pSettings->iPerThreadScratchSize ==
1406 MOS_ALIGN_CEIL(pSettings->iPerThreadScratchSize, MHW_SCRATCH_SPACE_ALIGN));
1407
1408 pStateHeap->dwScratchSpaceSize = pRenderHal->pfnGetScratchSpaceSize(pRenderHal, pSettings->iPerThreadScratchSize);
1409 pStateHeap->dwScratchSpaceBase = dwSizeGSH;
1410 dwSizeGSH += pStateHeap->dwScratchSpaceSize;
1411 }
1412
1413 pStateHeap->dwSizeGSH = dwSizeGSH;
1414
1415 //----------------------------------
1416 // Instruction State Heap (Kernel Heap)
1417 //----------------------------------
1418 pStateHeap->dwKernelBase = 0;
1419 dwSizeISH = MOS_ALIGN_CEIL(pSettings->iKernelHeapSize, RENDERHAL_KERNEL_BLOCK_ALIGN);
1420
1421 // System Routine Area, always loaded for Cm
1422 // Don't put the allocation under bIsaAsmDebugEnable
1423 pStateHeap->dwSipBase = dwSizeISH;
1424 pRenderHal->SipStateParams.bSipKernel = false;
1425 pRenderHal->SipStateParams.dwSipBase = dwSizeISH;
1426 dwSizeISH += MOS_ALIGN_CEIL(pSettings->iSipSize, RENDERHAL_KERNEL_BLOCK_ALIGN);
1427
1428 pStateHeap->dwSizeISH = dwSizeISH;
1429
1430 //----------------------------------
1431 // Surface State Heap
1432 //----------------------------------
1433 // Reset initial SSH allocations
1434 pStateHeap->iCurSshBufferIndex = 0;
1435 pStateHeap->iCurrentBindingTable = 0;
1436 pStateHeap->iCurrentSurfaceState = 0;
1437
1438 // Set BT sizes
1439 pStateHeap->iBindingTableSize = MOS_ALIGN_CEIL(pSettings->iSurfacesPerBT * pHwSizes->dwSizeBindingTableState,
1440 pSettings->iBTAlignment);
1441
1442 // Set offsets to BT and SS entries
1443 pStateHeap->iBindingTableOffset = 0;
1444 pStateHeap->iSurfaceStateOffset = pSettings->iBindingTables * pStateHeap->iBindingTableSize;
1445
1446 // Calculate size of a single SSH instance and total SSH buffer size
1447 dwSizeSSH = pStateHeap->iSurfaceStateOffset +
1448 pSettings->iSurfaceStates * pRenderHal->pRenderHalPltInterface->GetSurfaceStateCmdSize();
1449 pStateHeap->dwSshIntanceSize = dwSizeSSH;
1450 pRenderHal->dwIndirectHeapSize = MOS_ALIGN_CEIL(dwSizeSSH, MHW_PAGE_SIZE);
1451
1452 // Allocate SSH buffer in system memory, not Gfx
1453 pStateHeap->dwSizeSSH = dwSizeSSH; // Single SSH instance
1454 pStateHeap->pSshBuffer = (uint8_t*)MOS_AllocAndZeroMemory(dwSizeSSH);
1455 if (!pStateHeap->pSshBuffer)
1456 {
1457 MHW_RENDERHAL_ASSERTMESSAGE("Fail to Allocate SSH buffer.");
1458 eStatus = MOS_STATUS_NO_SPACE;
1459 goto finish;
1460 }
1461
1462 pStateHeap->bSshLocked = true;
1463
1464 //----------------------------------
1465 // Allocate State Heap in MHW
1466 //----------------------------------
1467 MOS_ZeroMemory(&MhwStateHeapSettings, sizeof(MhwStateHeapSettings));
1468 MhwStateHeapSettings.dwDshSize = pStateHeap->dwSizeGSH;
1469 MhwStateHeapSettings.dwIshSize = pStateHeap->dwSizeISH;
1470 MhwStateHeapSettings.dwNumSyncTags = pStateHeap->dwSizeSync;
1471
1472 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwRenderInterface->AllocateHeaps(MhwStateHeapSettings));
1473 MHW_RENDERHAL_CHK_NULL(pRenderHal->pMhwRenderInterface->m_stateHeapInterface);
1474
1475 pDshHeap = pRenderHal->pMhwStateHeap->GetDSHPointer();
1476 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwStateHeap->LockStateHeap(pDshHeap));
1477 pStateHeap->GshOsResource = pDshHeap->resHeap;
1478 pStateHeap->pGshBuffer = (uint8_t*)pDshHeap->pvLockedHeap;
1479 pStateHeap->bGshLocked = true;
1480
1481 pIshHeap = pRenderHal->pMhwStateHeap->GetISHPointer();
1482 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwStateHeap->LockStateHeap(pIshHeap));
1483 pStateHeap->IshOsResource = pIshHeap->resHeap;
1484 pStateHeap->pIshBuffer = (uint8_t*)pIshHeap->pvLockedHeap;
1485 pStateHeap->bIshLocked = true;
1486
1487 //-----------------------------
1488 // Heap initialization
1489 //-----------------------------
1490
1491 // Reset GSH contents until scratch space (excluding)
1492 MOS_ZeroMemory(pStateHeap->pGshBuffer, pStateHeap->dwScratchSpaceBase);
1493
1494 // Setup pointer to sync tags
1495 pStateHeap->pSync = (uint32_t*) (pStateHeap->pGshBuffer + pStateHeap->dwOffsetSync);
1496
1497 // Reset kernel allocations
1498 pRenderHal->pfnResetKernels(pRenderHal);
1499
1500 eStatus = MOS_STATUS_SUCCESS;
1501
1502 finish:
1503 if (eStatus != MOS_STATUS_SUCCESS)
1504 {
1505 if (pStateHeap)
1506 {
1507 // Free SSH buffer
1508 if (pStateHeap->pSshBuffer)
1509 {
1510 MOS_FreeMemory(pStateHeap->pSshBuffer);
1511 }
1512
1513 // Free State Heap control structure
1514 MOS_AlignedFreeMemory(pStateHeap);
1515 pRenderHal->pStateHeap = nullptr;
1516 }
1517 }
1518
1519 return eStatus;
1520 }
1521
1522 //!
1523 //! \brief Free State Heaps (including MHW interfaces)
1524 //! \details Free State Heap resources allocated by RenderHal
1525 //! \param PRENDERHAL_INTERFACE pRenderHal
1526 //! [in] Pointer to Render Hal Interface
1527 //! \return MOS_STATUS
1528 //!
RenderHal_FreeStateHeaps(PRENDERHAL_INTERFACE pRenderHal)1529 MOS_STATUS RenderHal_FreeStateHeaps(PRENDERHAL_INTERFACE pRenderHal)
1530 {
1531 PMOS_INTERFACE pOsInterface;
1532 PRENDERHAL_STATE_HEAP pStateHeap;
1533 MOS_STATUS eStatus;
1534
1535 //------------------------------------------------
1536 MHW_RENDERHAL_CHK_NULL(pRenderHal);
1537 MHW_RENDERHAL_CHK_NULL(pRenderHal->pOsInterface);
1538 MHW_RENDERHAL_CHK_NULL(pRenderHal->pStateHeap);
1539 //------------------------------------------------
1540
1541 eStatus = MOS_STATUS_UNKNOWN;
1542
1543 pOsInterface = pRenderHal->pOsInterface;
1544 pStateHeap = pRenderHal->pStateHeap;
1545
1546 // Free SSH Resource
1547 if (pStateHeap->pSshBuffer)
1548 {
1549 MOS_FreeMemory(pStateHeap->pSshBuffer);
1550 pStateHeap->pSshBuffer = nullptr;
1551 }
1552
1553 // Free MOS surface in surface state entry
1554 for (int32_t index = 0; index < pRenderHal->StateHeapSettings.iSurfaceStates; ++index) {
1555 PRENDERHAL_SURFACE_STATE_ENTRY entry = pStateHeap->pSurfaceEntry + index;
1556 MOS_SafeFreeMemory(entry->pSurface);
1557 entry->pSurface = nullptr;
1558 }
1559
1560 // Free State Heap Control structure
1561 MOS_AlignedFreeMemory(pStateHeap);
1562 pRenderHal->pStateHeap = nullptr;
1563
1564 eStatus = MOS_STATUS_SUCCESS;
1565
1566 finish:
1567 return eStatus;
1568 }
1569
1570 //!
1571 //! \brief Allocate BB
1572 //! \details Allocate Batch Buffer resource (not BB structure),
1573 //! attaching it to head of linked list in RenderHal.
1574 //! \param PRENDERHAL_INTERFACE pRenderHal
1575 //! [in] Pointer to Hardwaew interface structure
1576 //! \param PMHW_BATCH_BUFFER pBatchBuffer
1577 //! [out] Pointer to batch buffer structure to be initialized
1578 //! \param int32_t iSize
1579 //! [in] Size of the batch buffer to be allocated
1580 //! \return MOS_STATUS
1581 //! MOS_STATUS_SUCCESS if the Batch Buffer was successfully allocated
1582 //! others if failed
1583 //!
RenderHal_AllocateBB(PRENDERHAL_INTERFACE pRenderHal,PMHW_BATCH_BUFFER pBatchBuffer,int32_t iSize)1584 MOS_STATUS RenderHal_AllocateBB(
1585 PRENDERHAL_INTERFACE pRenderHal,
1586 PMHW_BATCH_BUFFER pBatchBuffer,
1587 int32_t iSize)
1588 {
1589 PMOS_INTERFACE pOsInterface;
1590 MOS_RESOURCE OsResource;
1591 MOS_ALLOC_GFXRES_PARAMS AllocParams;
1592 MOS_STATUS eStatus;
1593
1594 //---------------------------------------------
1595 MHW_RENDERHAL_CHK_NULL(pRenderHal);
1596 MHW_RENDERHAL_CHK_NULL(pRenderHal->pOsInterface);
1597 MHW_RENDERHAL_CHK_NULL(pBatchBuffer);
1598 //---------------------------------------------
1599
1600 eStatus = MOS_STATUS_UNKNOWN;
1601 pOsInterface = pRenderHal->pOsInterface;
1602
1603 MOS_ZeroMemory(&OsResource, sizeof(OsResource));
1604
1605 MOS_ZeroMemory(&AllocParams, sizeof(MOS_ALLOC_GFXRES_PARAMS));
1606
1607 AllocParams.Type = MOS_GFXRES_BUFFER;
1608 AllocParams.TileType = MOS_TILE_LINEAR;
1609 AllocParams.Format = Format_Buffer;
1610 AllocParams.dwBytes = iSize;
1611 AllocParams.pBufName = "RenderHalBB";
1612 AllocParams.ResUsageType = MOS_HW_RESOURCE_USAGE_MEDIA_BATCH_BUFFERS;
1613
1614 MHW_RENDERHAL_CHK_STATUS(pOsInterface->pfnAllocateResource(
1615 pOsInterface,
1616 &AllocParams,
1617 &OsResource));
1618
1619 // Reset Allocation
1620 pOsInterface->pfnResetResourceAllocationIndex(
1621 pOsInterface,
1622 &OsResource);
1623
1624 pBatchBuffer->OsResource = OsResource;
1625 pBatchBuffer->iRemaining = iSize;
1626 pBatchBuffer->iSize = iSize;
1627 pBatchBuffer->iCurrent = 0;
1628 pBatchBuffer->bLocked = false;
1629 pBatchBuffer->pData = nullptr;
1630
1631 pBatchBuffer->dwOffset = 0;
1632
1633 pBatchBuffer->bBusy = false;
1634 pBatchBuffer->dwCmdBufId = 0;
1635
1636 // Link BB to beginning of linked list
1637 pBatchBuffer->pPrev = nullptr;
1638 pBatchBuffer->pNext = pRenderHal->pBatchBufferList;
1639 pRenderHal->pBatchBufferList = pBatchBuffer;
1640 if (pBatchBuffer->pNext)
1641 {
1642 pBatchBuffer->pNext->pPrev = pBatchBuffer;
1643 }
1644
1645 // Reset Sync/BB Reuse data
1646 pBatchBuffer->dwSyncTag = 0;
1647 pBatchBuffer->bMatch = false;
1648
1649 eStatus = MOS_STATUS_SUCCESS;
1650
1651 finish:
1652 return eStatus;
1653 }
1654
1655 //!
1656 //! \brief Free BB
1657 //! \details Frees Batch Buffer Resource (not structure),
1658 //! detaching it from linked list in RenderHal.
1659 //! \param PRENDERHAL_INTERFACE pRenderHal
1660 //! [in] Pointer to Hardware Interface Structure
1661 //! \param PMHW_BATCH_BUFFER pBatchBuffer
1662 //! [in] Pointer to Batch Buffer
1663 //! \return MOS_STATUS
1664 //!
RenderHal_FreeBB(PRENDERHAL_INTERFACE pRenderHal,PMHW_BATCH_BUFFER pBatchBuffer)1665 MOS_STATUS RenderHal_FreeBB(
1666 PRENDERHAL_INTERFACE pRenderHal,
1667 PMHW_BATCH_BUFFER pBatchBuffer)
1668 {
1669 PMOS_INTERFACE pOsInterface;
1670 MOS_STATUS eStatus;
1671
1672 //----------------------------------------------
1673 MHW_RENDERHAL_CHK_NULL(pRenderHal);
1674 MHW_RENDERHAL_CHK_NULL(pRenderHal->pOsInterface);
1675 MHW_RENDERHAL_CHK_NULL(pBatchBuffer);
1676 //----------------------------------------------
1677
1678 eStatus = MOS_STATUS_UNKNOWN;
1679 pOsInterface = pRenderHal->pOsInterface;
1680
1681 if (pBatchBuffer->bLocked)
1682 {
1683 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pfnUnlockBB(pRenderHal, pBatchBuffer));
1684 }
1685
1686 pOsInterface->pfnFreeResource(pOsInterface, &pBatchBuffer->OsResource);
1687
1688 pBatchBuffer->dwSyncTag = 0;
1689 pBatchBuffer->iSize = 0;
1690 pBatchBuffer->iCurrent = 0;
1691 pBatchBuffer->bMatch = 0;
1692
1693 // Unlink BB from synchronization list
1694 if (pBatchBuffer->pNext)
1695 {
1696 pBatchBuffer->pNext->pPrev = pBatchBuffer->pPrev;
1697 }
1698
1699 if (pBatchBuffer->pPrev)
1700 {
1701 pBatchBuffer->pPrev->pNext = pBatchBuffer->pNext;
1702 }
1703 else
1704 {
1705 pRenderHal->pBatchBufferList = pBatchBuffer->pNext;
1706 }
1707
1708 pBatchBuffer->pPrev = pBatchBuffer->pNext = nullptr;
1709
1710 eStatus = MOS_STATUS_SUCCESS;
1711
1712 finish:
1713 return eStatus;
1714 }
1715
1716 //!
1717 //! \brief Lock BB
1718 //! \details Locks Batch Buffer
1719 //! \param PRENDERHAL_INTERFACE pRenderHal
1720 //! [in] Pointer to Hardware Interface Structure
1721 //! \param PMHW_BATCH_BUFFER pBatchBuffer
1722 //! [in] Pointer to Batch Buffer
1723 //! \return MOS_STATUS
1724 //!
RenderHal_LockBB(PRENDERHAL_INTERFACE pRenderHal,PMHW_BATCH_BUFFER pBatchBuffer)1725 MOS_STATUS RenderHal_LockBB(
1726 PRENDERHAL_INTERFACE pRenderHal,
1727 PMHW_BATCH_BUFFER pBatchBuffer)
1728 {
1729 PMOS_INTERFACE pOsInterface;
1730 MOS_LOCK_PARAMS LockFlags;
1731 MOS_STATUS eStatus;
1732
1733 //-----------------------------------
1734 MHW_RENDERHAL_CHK_NULL(pRenderHal);
1735 MHW_RENDERHAL_CHK_NULL(pBatchBuffer);
1736 MHW_RENDERHAL_CHK_NULL(pRenderHal->pOsInterface);
1737 //-----------------------------------
1738
1739 eStatus = MOS_STATUS_UNKNOWN;
1740 pOsInterface = pRenderHal->pOsInterface;
1741
1742 if (pBatchBuffer->bLocked)
1743 {
1744 MHW_RENDERHAL_ASSERTMESSAGE("Batch Buffer is already locked.");
1745 goto finish;
1746 }
1747
1748 MOS_ZeroMemory(&LockFlags, sizeof(MOS_LOCK_PARAMS));
1749
1750 LockFlags.WriteOnly = 1;
1751
1752 pBatchBuffer->pData = (uint8_t*)pOsInterface->pfnLockResource(
1753 pOsInterface,
1754 &pBatchBuffer->OsResource,
1755 &LockFlags);
1756
1757 MHW_RENDERHAL_CHK_NULL(pBatchBuffer->pData);
1758
1759 pBatchBuffer->bLocked = true;
1760 eStatus = MOS_STATUS_SUCCESS;
1761
1762 finish:
1763 return eStatus;
1764 }
1765
1766 //!
1767 //! \brief Unlock BB
1768 //! \details Unlocks Batch Buffer
1769 //! \param PRENDERHAL_INTERFACE pRenderHal
1770 //! [in] Pointer to Hardware Interface Structure
1771 //! \param PMHW_BATCH_BUFFER pBatchBuffer
1772 //! [in] Pointer to Batch Buffer
1773 //! \return MOS_STATUS
1774 //!
RenderHal_UnlockBB(PRENDERHAL_INTERFACE pRenderHal,PMHW_BATCH_BUFFER pBatchBuffer)1775 MOS_STATUS RenderHal_UnlockBB(
1776 PRENDERHAL_INTERFACE pRenderHal,
1777 PMHW_BATCH_BUFFER pBatchBuffer)
1778 {
1779 PMOS_INTERFACE pOsInterface;
1780 MOS_STATUS eStatus;
1781
1782 //---------------------------------
1783 MHW_RENDERHAL_CHK_NULL(pRenderHal);
1784 MHW_RENDERHAL_CHK_NULL(pBatchBuffer);
1785 MHW_RENDERHAL_CHK_NULL(pRenderHal->pOsInterface);
1786 //---------------------------------
1787
1788 eStatus = MOS_STATUS_UNKNOWN;
1789 pOsInterface = pRenderHal->pOsInterface;
1790
1791 if (!pBatchBuffer->bLocked)
1792 {
1793 MHW_RENDERHAL_ASSERTMESSAGE("Batch buffer is locked.");
1794 goto finish;
1795 }
1796
1797 MHW_RENDERHAL_CHK_STATUS(pOsInterface->pfnUnlockResource(
1798 pOsInterface,
1799 &pBatchBuffer->OsResource));
1800
1801 pBatchBuffer->bLocked = false;
1802
1803 eStatus = MOS_STATUS_SUCCESS;
1804
1805 finish:
1806 return eStatus;
1807 }
1808
1809 //!
1810 //! \brief Refresh Sync
1811 //! \details Update Sync tags
1812 //! \param PRENDERHAL_INTERFACE pRenderHal
1813 //! [in] Pointer to Hardware Interface Structure
1814 //! \return MOS_STATUS
1815 //!
RenderHal_RefreshSync(PRENDERHAL_INTERFACE pRenderHal)1816 MOS_STATUS RenderHal_RefreshSync(PRENDERHAL_INTERFACE pRenderHal)
1817 {
1818 PRENDERHAL_STATE_HEAP pStateHeap;
1819 PRENDERHAL_MEDIA_STATE pCurMediaState;
1820 PMHW_BATCH_BUFFER pBatchBuffer;
1821 uint32_t dwCurrentTag;
1822 int32_t i;
1823 int32_t iStatesInUse;
1824 int32_t iBuffersInUse;
1825 MOS_STATUS eStatus;
1826 MOS_NULL_RENDERING_FLAGS NullRenderingFlags;
1827 uint8_t *pCurrentPtr;
1828 uint64_t uiStartTime;
1829 uint64_t uiEndTime;
1830 uint64_t uiDiff;
1831 uint64_t uiNS;
1832 double TimeMS;
1833 uint32_t uiComponent;
1834
1835 //----------------------------------
1836 MHW_RENDERHAL_CHK_NULL(pRenderHal);
1837 MHW_RENDERHAL_CHK_NULL(pRenderHal->pStateHeap);
1838 MHW_RENDERHAL_CHK_NULL(pRenderHal->pOsInterface);
1839 //----------------------------------
1840
1841 eStatus = MOS_STATUS_UNKNOWN;
1842 pCurrentPtr = nullptr;
1843 uiNS = 0;
1844
1845 // GSH must be locked
1846 pStateHeap = pRenderHal->pStateHeap;
1847 if (!pStateHeap->bGshLocked)
1848 {
1849 goto finish;
1850 }
1851
1852 // Most recent tag
1853 dwCurrentTag = pStateHeap->pSync[0];
1854 pStateHeap->dwSyncTag = dwCurrentTag - 1;
1855
1856 // Refresh batch buffers
1857 iBuffersInUse = 0;
1858 pBatchBuffer = pRenderHal->pBatchBufferList;
1859
1860 NullRenderingFlags = pRenderHal->pOsInterface->pfnGetNullHWRenderFlags(
1861 pRenderHal->pOsInterface);
1862
1863 for (; pBatchBuffer != nullptr; pBatchBuffer = pBatchBuffer->pNext)
1864 {
1865 if (!pBatchBuffer->bBusy) continue;
1866
1867 // Clear BB busy flag when Sync Tag is reached
1868 if ((int32_t)(dwCurrentTag - pBatchBuffer->dwSyncTag) > 0 ||
1869 NullRenderingFlags.VPGobal)
1870 {
1871 pBatchBuffer->bBusy = false;
1872 }
1873 else
1874 {
1875 iBuffersInUse++;
1876 }
1877 }
1878
1879 // Refresh media states
1880 pCurMediaState = pStateHeap->pMediaStates;
1881 iStatesInUse = 0;
1882 for (i = pRenderHal->StateHeapSettings.iMediaStateHeaps; i > 0; i--, pCurMediaState++)
1883 {
1884 if (!pCurMediaState->bBusy) continue;
1885
1886 // The condition below is valid when sync tag wraps from 2^32-1 to 0
1887 if ((int32_t)(dwCurrentTag - pCurMediaState->dwSyncTag) > 0)
1888 {
1889 pCurMediaState->bBusy = false;
1890 if (pRenderHal->bKerneltimeDump)
1891 {
1892 // Dump Kernel execution time when media state is being freed
1893 pCurrentPtr = pStateHeap->pGshBuffer +
1894 pCurMediaState->dwOffset +
1895 pStateHeap->dwOffsetStartTime;
1896 if (pCurrentPtr)
1897 {
1898 uiStartTime = *((uint64_t *) pCurrentPtr);
1899 pCurrentPtr += pStateHeap->dwStartTimeSize;
1900
1901 uiEndTime = *((uint64_t *) pCurrentPtr);
1902 pCurrentPtr += pStateHeap->dwEndTimeSize;
1903
1904 uiComponent = *((RENDERHAL_COMPONENT *) pCurrentPtr);
1905 if (uiComponent < (uint32_t)RENDERHAL_COMPONENT_COUNT)
1906 {
1907 // Convert ticks to ns
1908 uiDiff = uiEndTime - uiStartTime;
1909 uiNS = 0;
1910 pRenderHal->pfnConvertToNanoSeconds(pRenderHal, uiDiff, &uiNS);
1911
1912 TimeMS = ((double)uiNS) / (1000 * 1000); // Convert to ms (double)
1913
1914 pRenderHal->kernelTime[uiComponent] += TimeMS;
1915 }
1916 }
1917 }
1918 }
1919 else
1920 {
1921 iStatesInUse++;
1922 }
1923 }
1924
1925 // Save number of states/buffers in use
1926 pRenderHal->iBuffersInUse = iBuffersInUse;
1927 pRenderHal->iMediaStatesInUse = iStatesInUse;
1928
1929 eStatus = MOS_STATUS_SUCCESS;
1930
1931 finish:
1932 return eStatus;
1933 }
1934
1935 //!
1936 //! \brief Load Kernel
1937 //! \details Load a kernel from cache into GSH; searches for unused space in
1938 //! the kernel heap; deallocates kernels identified as no longer in use.
1939 //! \param PRENDERHAL_INTERFACE pRenderHal
1940 //! [in] Pointer to Hardware Interface Structure
1941 //! \param PCRENDERHAL_KERNEL_PARAM pParameters
1942 //! [in] Pointer to Kernel Parameters
1943 //! \param PMHW_KERNEL_PARAMS pKernel
1944 //! [in] Pointer to Kernel entry
1945 //! \param Kdll_CacheEntry pKernelEntry
1946 //! [in] The cache entry pointer maintaining the load status.
1947 //! For cache entries from local variable,
1948 //! set it to nullptr to avoid memory corruption
1949 //! \return int32_t
1950 //! Index to a kernel allocation index
1951 //! -1 if invalid parameters, no available space and no
1952 //! deallocation possible
1953 //!
RenderHal_LoadKernel(PRENDERHAL_INTERFACE pRenderHal,PCRENDERHAL_KERNEL_PARAM pParameters,PMHW_KERNEL_PARAM pKernel,Kdll_CacheEntry * pKernelEntry)1954 int32_t RenderHal_LoadKernel(
1955 PRENDERHAL_INTERFACE pRenderHal,
1956 PCRENDERHAL_KERNEL_PARAM pParameters,
1957 PMHW_KERNEL_PARAM pKernel,
1958 Kdll_CacheEntry *pKernelEntry)
1959 {
1960 PRENDERHAL_STATE_HEAP pStateHeap;
1961 PRENDERHAL_KRN_ALLOCATION pKernelAllocation;
1962
1963 int32_t iKernelAllocationID; // Kernel allocation ID in GSH
1964 int32_t iKernelCacheID; // Kernel cache ID
1965 int32_t iKernelUniqueID; // Kernel unique ID
1966 void *pKernelPtr;
1967 int32_t iKernelSize;
1968 int32_t iSearchIndex;
1969 int32_t iMaxKernels; // Max number of kernels allowed in GSH
1970 uint32_t dwOffset;
1971 int32_t iSize;
1972 MOS_STATUS eStatus;
1973
1974 iKernelAllocationID = RENDERHAL_KERNEL_LOAD_FAIL;
1975 eStatus = MOS_STATUS_SUCCESS;
1976
1977 MHW_RENDERHAL_CHK_NULL(pRenderHal);
1978 MHW_RENDERHAL_CHK_NULL(pRenderHal->pStateHeap);
1979 MHW_RENDERHAL_CHK_NULL(pRenderHal->pStateHeap->pKernelAllocation);
1980 MHW_RENDERHAL_CHK_NULL(pParameters);
1981 MHW_RENDERHAL_CHK_NULL(pKernel);
1982
1983 pStateHeap = pRenderHal->pStateHeap;
1984
1985 // Validate parameters
1986 if (pStateHeap->bGshLocked == false ||
1987 pKernel->iSize == 0)
1988 {
1989 eStatus = MOS_STATUS_INVALID_PARAMETER;
1990 MHW_RENDERHAL_NORMALMESSAGE("Failed to load kernel - invalid parameters.");
1991 goto finish;
1992 }
1993
1994 // Kernel parameters
1995 pKernelPtr = pKernel->pBinary;
1996 iKernelSize = pKernel->iSize;
1997 iKernelUniqueID = pKernel->iKUID;
1998 iKernelCacheID = pKernel->iKCID;
1999
2000 // Check if kernel is already loaded; Search free allocation index
2001 iSearchIndex = -1;
2002 iMaxKernels = pRenderHal->StateHeapSettings.iKernelCount;
2003 pKernelAllocation = pStateHeap->pKernelAllocation;
2004 for (iKernelAllocationID = 0;
2005 iKernelAllocationID < iMaxKernels;
2006 iKernelAllocationID++, pKernelAllocation++)
2007 {
2008 if (pKernelAllocation->iKUID == iKernelUniqueID &&
2009 pKernelAllocation->iKCID == iKernelCacheID)
2010 {
2011 break;
2012 }
2013
2014 if (iSearchIndex < 0 &&
2015 pKernelAllocation->dwFlags == RENDERHAL_KERNEL_ALLOCATION_FREE)
2016 {
2017 iSearchIndex = iKernelAllocationID;
2018 }
2019 }
2020
2021 // The kernel size to be dumped in oca buffer.
2022 pStateHeap->iKernelUsedForDump = iKernelSize;
2023
2024 // Kernel already loaded: refresh timer; return allocation index
2025 if (iKernelAllocationID < iMaxKernels)
2026 {
2027 // To reload the kernel forcibly if needed
2028 if (pKernel->bForceReload)
2029 {
2030 dwOffset = pKernelAllocation->dwOffset;
2031 MOS_SecureMemcpy(pStateHeap->pIshBuffer + dwOffset, iKernelSize, pKernelPtr, iKernelSize);
2032
2033 pKernel->bForceReload = false;
2034 }
2035 goto finish;
2036 }
2037
2038 // Simple allocation: allocation index available, space available
2039 if ((iSearchIndex >= 0) &&
2040 (pStateHeap->iKernelUsed + iKernelSize <= pStateHeap->iKernelSize))
2041 {
2042 // Allocate kernel at the end of the heap
2043 iKernelAllocationID = iSearchIndex;
2044 pKernelAllocation = &(pStateHeap->pKernelAllocation[iSearchIndex]);
2045
2046 // Allocate block from the end of the heap
2047 dwOffset = pStateHeap->dwKernelBase + pStateHeap->iKernelUsed;
2048 iSize = MOS_ALIGN_CEIL(iKernelSize, pRenderHal->StateHeapSettings.iKernelBlockSize);
2049
2050 // Update heap
2051 pStateHeap->iKernelUsed += iSize;
2052
2053 // Load kernel
2054 goto loadkernel;
2055 }
2056
2057 // Search block from deallocated entry
2058 if (iSearchIndex >= 0)
2059 {
2060 int32_t iMinSize = 0;
2061
2062 iSearchIndex = -1;
2063 pKernelAllocation = pStateHeap->pKernelAllocation;
2064 for (iKernelAllocationID = 0;
2065 iKernelAllocationID < iMaxKernels;
2066 iKernelAllocationID++, pKernelAllocation++)
2067 {
2068 // Skip allocated/empty entries
2069 if (pKernelAllocation->dwFlags != RENDERHAL_KERNEL_ALLOCATION_FREE ||
2070 pKernelAllocation->iSize == 0)
2071 {
2072 continue;
2073 }
2074
2075 // Allocate minimum available block
2076 if (pKernelAllocation->iSize >= iKernelSize)
2077 {
2078 if (iSearchIndex < 0 ||
2079 pKernelAllocation->iSize < iMinSize)
2080 {
2081 iSearchIndex = iKernelAllocationID;
2082 iMinSize = pKernelAllocation->iSize;
2083 }
2084 }
2085 }
2086 }
2087
2088 // Did not find block, try to deallocate a kernel not recently used
2089 if (iSearchIndex < 0)
2090 {
2091 uint32_t dwOldest = 0;
2092 uint32_t dwLastUsed;
2093
2094 // Search and deallocate least used kernel
2095 pKernelAllocation = pStateHeap->pKernelAllocation;
2096 for (iKernelAllocationID = 0;
2097 iKernelAllocationID < iMaxKernels;
2098 iKernelAllocationID++, pKernelAllocation++)
2099 {
2100 // Skip unused entries and entries that would not fit
2101 // Skip kernels flagged as locked (cannot be automatically deallocated)
2102 if (pKernelAllocation->dwFlags == RENDERHAL_KERNEL_ALLOCATION_FREE ||
2103 pKernelAllocation->dwFlags == RENDERHAL_KERNEL_ALLOCATION_LOCKED ||
2104 pKernelAllocation->iSize < iKernelSize)
2105 {
2106 continue;
2107 }
2108
2109 // Check if kernel may be replaced (not in use by GPU)
2110 if ((int32_t)(pStateHeap->dwSyncTag - pKernelAllocation->dwSync) < 0)
2111 {
2112 continue;
2113 }
2114
2115 // Find kernel not used for the greater amount of time (measured in number of operations)
2116 // Must not unload recently allocated kernels
2117 dwLastUsed = (uint32_t)(pStateHeap->dwAccessCounter - pKernelAllocation->dwCount);
2118 if (dwLastUsed > dwOldest)
2119 {
2120 iSearchIndex = iKernelAllocationID;
2121 dwOldest = dwLastUsed;
2122 }
2123 }
2124
2125 // Did not found any entry for deallocation
2126 if (iSearchIndex < 0)
2127 {
2128 MHW_RENDERHAL_NORMALMESSAGE("Failed to load kernel - no space available in GSH.");
2129 iKernelAllocationID = RENDERHAL_KERNEL_LOAD_FAIL;
2130 goto finish;
2131 }
2132
2133 // Free kernel entry and states associated with the kernel (if any)
2134 if (pRenderHal->pfnUnloadKernel(pRenderHal, iSearchIndex) != MOS_STATUS_SUCCESS)
2135 {
2136 MHW_RENDERHAL_NORMALMESSAGE("Failed to load kernel - no space available in GSH.");
2137 iKernelAllocationID = RENDERHAL_KERNEL_LOAD_FAIL;
2138 goto finish;
2139 }
2140 }
2141
2142 // Allocate the entry
2143 iKernelAllocationID = iSearchIndex;
2144 pKernelAllocation = &(pStateHeap->pKernelAllocation[iSearchIndex]);
2145
2146 dwOffset = pKernelAllocation->dwOffset;
2147 iSize = pKernelAllocation->iSize;
2148
2149 loadkernel:
2150 // Allocate kernel
2151 pKernelAllocation->iKID = -1;
2152 pKernelAllocation->iKUID = iKernelUniqueID;
2153 pKernelAllocation->iKCID = iKernelCacheID;
2154 pKernelAllocation->dwSync = 0;
2155 FrameTrackerTokenFlat_Clear(&pKernelAllocation->trackerToken);
2156 pKernelAllocation->dwOffset = dwOffset;
2157 pKernelAllocation->iSize = iSize;
2158 pKernelAllocation->dwFlags = RENDERHAL_KERNEL_ALLOCATION_USED;
2159 pKernelAllocation->dwCount = 0; // will be updated by "TouchKernel"
2160 pKernelAllocation->Params = *pParameters;
2161 pKernelAllocation->pKernelEntry = pKernelEntry;
2162 pKernelAllocation->iAllocIndex = iKernelAllocationID;
2163
2164 // Copy kernel data
2165 MOS_SecureMemcpy(pStateHeap->pIshBuffer + dwOffset, iKernelSize, pKernelPtr, iKernelSize);
2166 if (iKernelSize < iSize)
2167 {
2168 MOS_ZeroMemory(pStateHeap->pIshBuffer + dwOffset + iKernelSize, iSize - iKernelSize);
2169 }
2170
2171 finish:
2172 if (iKernelAllocationID != RENDERHAL_KERNEL_LOAD_FAIL)
2173 {
2174 // Update kernel usage
2175 pRenderHal->pfnTouchKernel(pRenderHal, iKernelAllocationID);
2176
2177 // Increment reference counter
2178 if (pKernelEntry)
2179 {
2180 pKernelEntry->dwLoaded = 1;
2181 }
2182 pRenderHal->iKernelAllocationID = iKernelAllocationID;
2183 }
2184
2185 // Return kernel allocation index
2186 return iKernelAllocationID;
2187 }
2188
2189 //!
2190 //! \brief Unload Kernel
2191 //! \details Unload a kernel from GSH, free kernel heap space
2192 //! Notify that the kernel has been unloaded (for tracking)
2193 //! \param PRENDERHAL_INTERFACE pRenderHal
2194 //! [in] Pointer to Hardware Interface Structure
2195 //! \param int32_t iKernelAllocationID
2196 //! [in] Kernel allocation index in GSH
2197 //! \return MOS_STATUS
2198 //! MOS_STATUS_SUCCESS if success
2199 //! others if invalid parameters or if kernel cannot be unloaded
2200 //!
RenderHal_UnloadKernel(PRENDERHAL_INTERFACE pRenderHal,int32_t iKernelAllocationID)2201 MOS_STATUS RenderHal_UnloadKernel(
2202 PRENDERHAL_INTERFACE pRenderHal,
2203 int32_t iKernelAllocationID)
2204 {
2205 PRENDERHAL_STATE_HEAP pStateHeap;
2206 PRENDERHAL_KRN_ALLOCATION pKernelAllocation;
2207 MOS_STATUS eStatus;
2208
2209 //---------------------------------------
2210 MHW_RENDERHAL_CHK_NULL(pRenderHal);
2211 MHW_RENDERHAL_CHK_NULL(pRenderHal->pStateHeap);
2212 MHW_RENDERHAL_CHK_NULL((void*)(iKernelAllocationID >= 0));
2213 //---------------------------------------
2214
2215 eStatus = MOS_STATUS_UNKNOWN;
2216 pStateHeap = pRenderHal->pStateHeap;
2217
2218 //---------------------------------------
2219 MHW_RENDERHAL_CHK_NULL(pStateHeap->pKernelAllocation);
2220 MHW_RENDERHAL_ASSERT(iKernelAllocationID < pRenderHal->StateHeapSettings.iKernelCount);
2221 //---------------------------------------
2222
2223 pKernelAllocation = &(pStateHeap->pKernelAllocation[iKernelAllocationID]);
2224
2225 if (pKernelAllocation->dwFlags == RENDERHAL_KERNEL_ALLOCATION_FREE)
2226 {
2227 goto finish;
2228 }
2229
2230 // Update Sync tags
2231 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pfnRefreshSync(pRenderHal));
2232
2233 // Check if kernel may be unloaded
2234 if ((int32_t)(pStateHeap->dwSyncTag - pKernelAllocation->dwSync) < 0)
2235 {
2236 goto finish;
2237 }
2238
2239 // Unload kernel
2240 if (pKernelAllocation->pKernelEntry)
2241 {
2242 pKernelAllocation->pKernelEntry->dwLoaded = 0;
2243 }
2244
2245 // Release kernel entry (Offset/size may be used for reallocation)
2246 pKernelAllocation->iKID = -1;
2247 pKernelAllocation->iKUID = -1;
2248 pKernelAllocation->iKCID = -1;
2249 pKernelAllocation->dwSync = 0;
2250 FrameTrackerTokenFlat_Clear(&pKernelAllocation->trackerToken);
2251 pKernelAllocation->dwFlags = RENDERHAL_KERNEL_ALLOCATION_FREE;
2252 pKernelAllocation->dwCount = 0;
2253 pKernelAllocation->pKernelEntry = nullptr;
2254
2255 eStatus = MOS_STATUS_SUCCESS;
2256
2257 finish:
2258 return eStatus;
2259 }
2260
2261 //!
2262 //! \brief Touch Kernel
2263 //! \details Touch Kernel
2264 //! \param PRENDERHAL_INTERFACE pRenderHal
2265 //! [in] Pointer to Hardware Interface Structure
2266 //! \param int32_t iKernelAllocationID
2267 //! [in] Kernel Allocation ID
2268 //! \return void
2269 //!
RenderHal_TouchKernel(PRENDERHAL_INTERFACE pRenderHal,int32_t iKernelAllocationID)2270 void RenderHal_TouchKernel(
2271 PRENDERHAL_INTERFACE pRenderHal,
2272 int32_t iKernelAllocationID)
2273 {
2274 PRENDERHAL_STATE_HEAP pStateHeap;
2275 PRENDERHAL_KRN_ALLOCATION pKernelAllocation;
2276
2277 pStateHeap = (pRenderHal) ? pRenderHal->pStateHeap : nullptr;
2278 if (pStateHeap == nullptr ||
2279 pStateHeap->pKernelAllocation == nullptr ||
2280 iKernelAllocationID < 0 ||
2281 iKernelAllocationID >= pRenderHal->StateHeapSettings.iKernelCount)
2282 {
2283 return;
2284 }
2285
2286 // Update usage
2287 pKernelAllocation = &(pStateHeap->pKernelAllocation[iKernelAllocationID]);
2288 if (pKernelAllocation->dwFlags != RENDERHAL_KERNEL_ALLOCATION_FREE &&
2289 pKernelAllocation->dwFlags != RENDERHAL_KERNEL_ALLOCATION_LOCKED)
2290 {
2291 pKernelAllocation->dwCount = pStateHeap->dwAccessCounter++;
2292 }
2293
2294 // Set sync tag, for deallocation control
2295 pKernelAllocation->dwSync = pStateHeap->dwNextTag;
2296 }
2297
2298 //!
2299 //! \brief Reset Kernels
2300 //! \details Reset Kernels
2301 //! \param PRENDERHAL_INTERFACE pRenderHal
2302 //! [in] Pointer to Hardware Interface Structure
2303 //! \return void
2304 //!
RenderHal_ResetKernels(PRENDERHAL_INTERFACE pRenderHal)2305 void RenderHal_ResetKernels(
2306 PRENDERHAL_INTERFACE pRenderHal)
2307 {
2308 PRENDERHAL_STATE_HEAP pStateHeap;
2309 PRENDERHAL_KRN_ALLOCATION pKernelAllocation;
2310 int32_t i;
2311 MOS_STATUS eStatus = MOS_STATUS_UNKNOWN;
2312
2313 //---------------------------------------
2314 MHW_RENDERHAL_CHK_NULL(pRenderHal);
2315 MHW_RENDERHAL_CHK_NULL(pRenderHal->pStateHeap);
2316 MHW_RENDERHAL_CHK_NULL(pRenderHal->pStateHeap->pKernelAllocation);
2317 //---------------------------------------
2318
2319 pStateHeap = pRenderHal->pStateHeap;
2320
2321 // Unload kernels and notify HAL layer
2322 pKernelAllocation = pStateHeap->pKernelAllocation;
2323 for (i = 0; i< pRenderHal->StateHeapSettings.iKernelCount; i++, pKernelAllocation++)
2324 {
2325 // Unload kernel
2326 if (pKernelAllocation->pKernelEntry)
2327 {
2328 pKernelAllocation->pKernelEntry->dwLoaded = 0;
2329 }
2330
2331 pKernelAllocation->iKID = -1;
2332 pKernelAllocation->iKUID = -1;
2333 pKernelAllocation->iKCID = -1;
2334 pKernelAllocation->dwSync = 0;
2335 FrameTrackerTokenFlat_Clear(&pKernelAllocation->trackerToken);
2336 pKernelAllocation->dwOffset = 0;
2337 pKernelAllocation->iSize = 0;
2338 pKernelAllocation->dwFlags = RENDERHAL_KERNEL_ALLOCATION_FREE;
2339 pKernelAllocation->dwCount = 0;
2340 pKernelAllocation->pKernelEntry = nullptr;
2341 pKernelAllocation->iAllocIndex = i;
2342 pKernelAllocation->Params = g_cRenderHal_InitKernelParams;
2343 }
2344
2345 // Free Kernel Heap
2346 pStateHeap->dwAccessCounter = 0;
2347 pStateHeap->iKernelSize = pRenderHal->StateHeapSettings.iKernelHeapSize;
2348 pStateHeap->iKernelUsed = 0;
2349 pStateHeap->iKernelUsedForDump = 0;
2350
2351 finish:
2352 return;
2353 }
2354
2355 //!
2356 //! \brief Get Kernel Offset
2357 //! \details Get Kernel Offset
2358 //! \param PRENDERHAL_INTERFACE pRenderHal
2359 //! [in] Pointer to Hardware Interface Structure
2360 //! \param int32_t iKernelAllocationIndex
2361 //! [in] Kernel Allocation Index
2362 //! \return int32_t
2363 //!
RenderHal_GetKernelOffset(PRENDERHAL_INTERFACE pRenderHal,int32_t iKernelAllocationIndex)2364 int32_t RenderHal_GetKernelOffset(
2365 PRENDERHAL_INTERFACE pRenderHal,
2366 int32_t iKernelAllocationIndex)
2367 {
2368 PRENDERHAL_STATE_HEAP pStateHeap;
2369 int32_t iResult;
2370
2371 pStateHeap = (pRenderHal) ? pRenderHal->pStateHeap : nullptr;
2372 if (pStateHeap &&
2373 pStateHeap->pKernelAllocation &&
2374 iKernelAllocationIndex >= 0 &&
2375 iKernelAllocationIndex < pRenderHal->StateHeapSettings.iKernelCount)
2376 {
2377 iResult = pStateHeap->pKernelAllocation[iKernelAllocationIndex].dwOffset;
2378 }
2379 else
2380 {
2381 iResult = -1;
2382 }
2383
2384 return iResult;
2385 }
2386
2387 //!
2388 //! \brief Allocate Media ID
2389 //! \details Allocates an setup Interface Descriptor for Media Pipeline
2390 //! Kernel must be preloaded using pfnLoadKernel
2391 //! Curbe must be allocated using pfnAllocateCurbe
2392 //! Binding Table must be allocated using pfnAllocateBindingTable
2393 //! \param PRENDERHAL_INTERFACE pRenderHal
2394 //! [in] Pointer to Hardware Interface Structure
2395 //! \param int32_t iKernelAllocationID
2396 //! [in] Kernel Allocation ID
2397 //! \param int32_t iBindingTableID
2398 //! [in] Binding Table ID
2399 //! \param int32_t iCurbeOffset
2400 //! [in] Curbe Offset (from Curbe base)
2401 //! \param int32_t iCurbeLength
2402 //! [in] Curbe Length
2403 //! \param int32_t iCrsThrdConstDataLn
2404 //! [in] Cross Thread constant data length
2405 //! \param PMHW_GPGPU_WALKER_PARAMS pGpGpuWalkerParams
2406 //! [in] Pointer to GpGpu Walker Params
2407 //! \return int32_t
2408 //! Media Interface descriptor ID
2409 //! -1 if invalid parameters, no ID entry available in GSH
2410 //!
RenderHal_AllocateMediaID(PRENDERHAL_INTERFACE pRenderHal,int32_t iKernelAllocationID,int32_t iBindingTableID,int32_t iCurbeOffset,int32_t iCurbeLength,int32_t iCrsThrdConstDataLn,PMHW_GPGPU_WALKER_PARAMS pGpGpuWalkerParams)2411 int32_t RenderHal_AllocateMediaID(
2412 PRENDERHAL_INTERFACE pRenderHal,
2413 int32_t iKernelAllocationID,
2414 int32_t iBindingTableID,
2415 int32_t iCurbeOffset,
2416 int32_t iCurbeLength,
2417 int32_t iCrsThrdConstDataLn,
2418 PMHW_GPGPU_WALKER_PARAMS pGpGpuWalkerParams)
2419 {
2420 PRENDERHAL_STATE_HEAP pStateHeap;
2421 PRENDERHAL_KRN_ALLOCATION pKernelAllocation;
2422 PRENDERHAL_MEDIA_STATE pCurMediaState;
2423 int32_t iCurbeSize;
2424 int32_t iInterfaceDescriptor;
2425 RENDERHAL_INTERFACE_DESCRIPTOR_PARAMS InterfaceDescriptorParams;
2426
2427 iInterfaceDescriptor = -1;
2428
2429 // Validate GSH
2430 pStateHeap = (pRenderHal) ? pRenderHal->pStateHeap : nullptr;
2431 if (pStateHeap == nullptr ||
2432 pStateHeap->pKernelAllocation == nullptr ||
2433 pStateHeap->bGshLocked == false)
2434 {
2435 MHW_RENDERHAL_ASSERTMESSAGE("Invalid GSH State.");
2436 goto finish;
2437 }
2438
2439 // Obtain pointer to current media state
2440 pCurMediaState = pStateHeap->pCurMediaState;
2441 if (pCurMediaState == nullptr ||
2442 pCurMediaState->piAllocation == nullptr)
2443 {
2444 MHW_RENDERHAL_ASSERTMESSAGE("Invalid Media State.");
2445 goto finish;
2446 }
2447
2448 // Validate kernel allocation ID (kernel must be pre-loaded into GSH)
2449 if (iKernelAllocationID < 0 ||
2450 iKernelAllocationID >= pRenderHal->StateHeapSettings.iKernelCount)
2451 {
2452 MHW_RENDERHAL_ASSERTMESSAGE("Invalid Kernel Allocation ID.");
2453 goto finish;
2454 }
2455
2456 // Obtain pointer to kernel allocation control and kernel parameters
2457 pKernelAllocation = &(pStateHeap->pKernelAllocation[iKernelAllocationID]);
2458 if (pKernelAllocation->dwFlags == RENDERHAL_KERNEL_ALLOCATION_FREE ||
2459 pKernelAllocation->iSize == 0)
2460 {
2461 MHW_RENDERHAL_ASSERTMESSAGE("Invalid Kernel Allocation.");
2462 goto finish;
2463 }
2464
2465 // Check Curbe allocation (CURBE_Lenght is in 256-bit count -> convert to bytes)
2466 iCurbeSize = iCurbeLength;
2467 if (iCurbeSize <= 0)
2468 {
2469 // Curbe is not used by the kernel
2470 iCurbeSize = iCurbeOffset = 0;
2471 }
2472 // Validate Curbe Offset (curbe must be pre-allocated)
2473 else if ( iCurbeOffset < 0 || // Not allocated
2474 (iCurbeOffset & 0x1F) != 0 || // Invalid alignment
2475 (iCurbeOffset + iCurbeSize) > pCurMediaState->iCurbeOffset) // Invalid size
2476 {
2477 MHW_RENDERHAL_ASSERTMESSAGE("Invalid Curbe Allocation.");
2478 goto finish;
2479 }
2480
2481 // Search available ID in current media state heap, try to reuse index (2nd level BB reuse)
2482 iInterfaceDescriptor = pRenderHal->pfnGetMediaID(pRenderHal, pCurMediaState, pKernelAllocation);
2483 if (iInterfaceDescriptor < 0)
2484 {
2485 MHW_RENDERHAL_ASSERTMESSAGE("No Interface Descriptor available.");
2486 goto finish;
2487 }
2488
2489 MOS_ZeroMemory((void *)&InterfaceDescriptorParams, sizeof(InterfaceDescriptorParams));
2490
2491 InterfaceDescriptorParams.iMediaID = iInterfaceDescriptor;
2492 InterfaceDescriptorParams.iBindingTableID = iBindingTableID;
2493 InterfaceDescriptorParams.iCurbeOffset = iCurbeOffset;
2494 InterfaceDescriptorParams.iCurbeLength = iCurbeLength;
2495 InterfaceDescriptorParams.iCrsThrdConstDataLn = iCrsThrdConstDataLn;
2496
2497 // barrier and slm
2498 if (pGpGpuWalkerParams && pGpGpuWalkerParams->GpGpuEnable)
2499 {
2500 InterfaceDescriptorParams.blBarrierEnable = true;
2501 InterfaceDescriptorParams.iNumberThreadsInGroup = pGpGpuWalkerParams->ThreadWidth * pGpGpuWalkerParams->ThreadHeight;
2502 InterfaceDescriptorParams.iSLMSize = pGpGpuWalkerParams->SLMSize; // The shift will be handled by pfnEncodeSLMSize()
2503 InterfaceDescriptorParams.blGlobalBarrierEnable = false;
2504 }
2505 else //Reset barrier and slm setting since they may be set before
2506 {
2507 InterfaceDescriptorParams.blBarrierEnable = false;
2508 InterfaceDescriptorParams.iNumberThreadsInGroup = pRenderHal->dwMinNumberThreadsInGroup;
2509 InterfaceDescriptorParams.iSLMSize = 0;
2510 InterfaceDescriptorParams.iCrsThrdConstDataLn &= pRenderHal->dwMaskCrsThdConDataRdLn;
2511 InterfaceDescriptorParams.blGlobalBarrierEnable = false;
2512 }
2513
2514 // Setup Media ID entry - this call could be HW dependent
2515 if (MOS_STATUS_SUCCESS != pRenderHal->pfnSetupInterfaceDescriptor(
2516 pRenderHal,
2517 pCurMediaState,
2518 pKernelAllocation,
2519 &InterfaceDescriptorParams))
2520 {
2521 MHW_RENDERHAL_ASSERTMESSAGE("Failed to setup interface descriptor.");
2522 goto finish;
2523 }
2524
2525 // Update kernel usage
2526 pRenderHal->pfnTouchKernel(pRenderHal, iInterfaceDescriptor);
2527
2528 finish:
2529 return iInterfaceDescriptor;
2530 }
2531
RenderHal_GetMediaID(PRENDERHAL_INTERFACE pRenderHal,PRENDERHAL_MEDIA_STATE pMediaState,PRENDERHAL_KRN_ALLOCATION pKernelAllocation)2532 int32_t RenderHal_GetMediaID(
2533 PRENDERHAL_INTERFACE pRenderHal,
2534 PRENDERHAL_MEDIA_STATE pMediaState,
2535 PRENDERHAL_KRN_ALLOCATION pKernelAllocation)
2536 {
2537 int32_t iInterfaceDescriptor = -1;
2538 int32_t *Allocation;
2539 MOS_STATUS eStatus = MOS_STATUS_UNKNOWN;
2540
2541 MHW_RENDERHAL_CHK_NULL(pMediaState);
2542 MHW_RENDERHAL_CHK_NULL(pMediaState->piAllocation);
2543 MHW_RENDERHAL_CHK_NULL(pKernelAllocation);
2544
2545 iInterfaceDescriptor = pKernelAllocation->iKID;
2546 Allocation = pMediaState->piAllocation;
2547
2548 // Try to reuse interface descriptor (for 2nd level buffer optimizations)
2549 // Check if ID already in use by another kernel - must use a different ID
2550 if (iInterfaceDescriptor >= 0 &&
2551 Allocation[iInterfaceDescriptor] >= 0 &&
2552 Allocation[iInterfaceDescriptor] != pKernelAllocation->iAllocIndex)
2553 {
2554 iInterfaceDescriptor = -1;
2555 }
2556
2557 // Search available ID in current media state heap
2558 if (iInterfaceDescriptor < 0)
2559 {
2560 int32_t iMax = pRenderHal->StateHeapSettings.iMediaIDs;
2561 for (iInterfaceDescriptor = 0;
2562 iInterfaceDescriptor < iMax;
2563 iInterfaceDescriptor++)
2564 {
2565 if (Allocation[iInterfaceDescriptor] < 0)
2566 {
2567 break;
2568 }
2569 }
2570
2571 // All IDs are in use - fail
2572 if (iInterfaceDescriptor >= iMax)
2573 {
2574 MHW_RENDERHAL_ASSERT("No Interface Descriptor available.");
2575 iInterfaceDescriptor = -1;
2576 goto finish;
2577 }
2578 }
2579
2580 // Set kernel allocation for the current Media ID
2581 Allocation[iInterfaceDescriptor] = pKernelAllocation->iAllocIndex;
2582
2583 // Set preferred Media ID for the current kernel
2584 // This is necessary for 2nd level BB optimization.
2585 if (pKernelAllocation->iKID < 0)
2586 {
2587 pKernelAllocation->iKID = iInterfaceDescriptor;
2588 }
2589
2590 finish:
2591 return iInterfaceDescriptor;
2592 }
2593
RenderHal_SetSurfacesPerBT(PRENDERHAL_INTERFACE pRenderHal,uint32_t dwSurfacesPerBT)2594 uint32_t RenderHal_SetSurfacesPerBT(PRENDERHAL_INTERFACE pRenderHal, uint32_t dwSurfacesPerBT)
2595 {
2596 if (pRenderHal == nullptr)
2597 {
2598 MHW_RENDERHAL_ASSERT("Invalid renderhal interface.");
2599 return dwSurfacesPerBT;
2600 }
2601
2602 // Set number of surfaces per Binding Table
2603 uint32_t dwSizeBT = (uint32_t)pRenderHal->StateHeapSettings.iBTAlignment/pRenderHal->pRenderHalPltInterface->GetBTStateCmdSize();
2604 while (dwSizeBT < dwSurfacesPerBT) dwSizeBT <<= 1;
2605 dwSurfacesPerBT = dwSizeBT;
2606
2607 // Reconfigure the binding table size
2608 pRenderHal->pStateHeap->iBindingTableSize = MOS_ALIGN_CEIL(dwSizeBT * pRenderHal->pRenderHalPltInterface->GetBTStateCmdSize(),
2609 pRenderHal->StateHeapSettings.iBTAlignment);
2610
2611 // Reconfigure the binding table number, surface per BT
2612 pRenderHal->StateHeapSettings.iBindingTables = pRenderHal->StateHeapSettings.iBindingTables *
2613 pRenderHal->StateHeapSettings.iSurfacesPerBT / dwSurfacesPerBT;
2614 pRenderHal->StateHeapSettings.iSurfacesPerBT = (int32_t) dwSurfacesPerBT;
2615
2616 return dwSurfacesPerBT;
2617 }
2618
2619 //!
2620 //! \brief Assign Surface State
2621 //! \details Assign a new surface state from already allocated surfState pool
2622 //! Setup the surface state to default
2623 //! \param PRENDERHAL_INTERFACE pRenderHal
2624 //! [in] Pointer to Hardware Interface Structure
2625 //! \param RENDERHAL_SURFACE_STATE_TYPE Type
2626 //! [in] Surface State Type
2627 //! \param PRENDERHAL_SURFACE_STATE_ENTRY * ppSurfaceEntry
2628 //! [in] Pointer to Surface State Entry
2629 //! \return MOS_STATUS
2630 //!
RenderHal_AssignSurfaceState(PRENDERHAL_INTERFACE pRenderHal,RENDERHAL_SURFACE_STATE_TYPE Type,PRENDERHAL_SURFACE_STATE_ENTRY * ppSurfaceEntry)2631 MOS_STATUS RenderHal_AssignSurfaceState(
2632 PRENDERHAL_INTERFACE pRenderHal,
2633 RENDERHAL_SURFACE_STATE_TYPE Type,
2634 PRENDERHAL_SURFACE_STATE_ENTRY *ppSurfaceEntry)
2635 {
2636 PRENDERHAL_STATE_HEAP pStateHeap;
2637 int32_t iSurfaceEntry;
2638 PRENDERHAL_SURFACE_STATE_ENTRY pSurfaceEntry;
2639 uint32_t dwOffset;
2640 MOS_STATUS eStatus;
2641
2642 //----------------------------------------------
2643 MHW_RENDERHAL_CHK_NULL(pRenderHal);
2644 MHW_RENDERHAL_CHK_NULL(ppSurfaceEntry);
2645 MHW_RENDERHAL_CHK_NULL(pRenderHal->pStateHeap);
2646 //----------------------------------------------
2647
2648 eStatus = MOS_STATUS_UNKNOWN;
2649 pStateHeap = pRenderHal->pStateHeap;
2650
2651 if (pStateHeap->iCurrentSurfaceState >= pRenderHal->StateHeapSettings.iSurfaceStates)
2652 {
2653 MHW_RENDERHAL_ASSERTMESSAGE("Unable to allocate Surface State. Exceeds Maximum.");
2654 goto finish;
2655 }
2656
2657 // Calculate the Offset to the Surface State
2658 MHW_RENDERHAL_CHK_NULL(pRenderHal->pRenderHalPltInterface);
2659 dwOffset = pStateHeap->iSurfaceStateOffset +
2660 (pStateHeap->iCurrentSurfaceState *
2661 pRenderHal->pRenderHalPltInterface->GetSurfaceStateCmdSize()); // Moves the pointer to a Currently assigned Surface State
2662
2663 // Obtain new surface entry and initialize
2664 iSurfaceEntry = pStateHeap->iCurrentSurfaceState;
2665 pSurfaceEntry = &pStateHeap->pSurfaceEntry[iSurfaceEntry];
2666 if (pSurfaceEntry->pSurface)
2667 {
2668 MOS_SafeFreeMemory(pSurfaceEntry->pSurface);
2669 pSurfaceEntry->pSurface = nullptr;
2670 }
2671 *pSurfaceEntry = g_cInitSurfaceStateEntry;
2672
2673 // Setup Surface Entry parameters
2674 pSurfaceEntry->iSurfStateID = iSurfaceEntry;
2675 pSurfaceEntry->Type = Type;
2676 pSurfaceEntry->dwSurfStateOffset = (uint32_t)-1; // Each platform to setup
2677 pSurfaceEntry->pSurfaceState = pStateHeap->pSshBuffer + dwOffset;
2678 pSurfaceEntry->pSurface = (PMOS_SURFACE)MOS_AllocAndZeroMemory(sizeof(MOS_SURFACE));
2679 if (pSurfaceEntry->pSurface == nullptr)
2680 {
2681 MHW_RENDERHAL_ASSERTMESSAGE("Allocating Surface failed!");
2682 eStatus = MOS_STATUS_NO_SPACE;
2683 goto finish;
2684 }
2685
2686 *ppSurfaceEntry = pSurfaceEntry;
2687
2688 // Increment the Current Surface State Entry
2689 ++pStateHeap->iCurrentSurfaceState;
2690
2691 eStatus = MOS_STATUS_SUCCESS;
2692
2693 finish:
2694 return eStatus;
2695 }
2696
2697 //!
2698 //! \brief Get DI UV Offset
2699 //! \details Get DI UV Offset
2700 //! \param PRENDERHAL_SURFACE pRenderHalSurface
2701 //! [in] Pointer to Surface
2702 //! \param uint16_t *pUXOffset
2703 //! [out] X Offset for U Plane
2704 //! \param uint16_t *pUYOffset
2705 //! [out] Y Offset for U Plane
2706 //! \param uint16_t *pVXOffset
2707 //! [out] X Offset for V Plane
2708 //! \param uint16_t *pVYOffset
2709 //! [out] Y Offset for V Plane
2710 //! \return void
2711 //!
RenderHal_Get_DI_UVOffSet(PRENDERHAL_SURFACE pRenderHalSurface,uint16_t * pUXOffset,uint16_t * pUYOffset,uint16_t * pVXOffset,uint16_t * pVYOffset)2712 void RenderHal_Get_DI_UVOffSet(
2713 PRENDERHAL_SURFACE pRenderHalSurface,
2714 uint16_t *pUXOffset,
2715 uint16_t *pUYOffset,
2716 uint16_t *pVXOffset,
2717 uint16_t *pVYOffset)
2718 {
2719 MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pRenderHalSurface);
2720 MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pUXOffset);
2721 MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pUYOffset);
2722 MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pVXOffset);
2723 MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pVXOffset);
2724
2725 PMOS_SURFACE pSurface = &pRenderHalSurface->OsSurface;
2726 MOS_FORMAT fmt = pSurface->Format;
2727 uint32_t dwNumRowsFromTopV = 0;
2728 uint32_t dwNumRowsFromTopU = 0;
2729 uint32_t dwNumColsFromLeftV = 0;
2730 uint32_t dwNumColsFromLeftU = 0;
2731 uint32_t dwHeight = pSurface->dwHeight;
2732 uint32_t dwPitch = pSurface->dwPitch;
2733
2734 switch (fmt)
2735 {
2736 // YY
2737 // YY
2738 // V-
2739 // U-
2740 case Format_IMC1:
2741 dwNumRowsFromTopV = dwHeight;
2742 dwNumRowsFromTopU = dwHeight + (dwHeight >> 1);
2743 break;
2744
2745 // YY
2746 // YY
2747 // VU
2748 case Format_IMC2:
2749 dwNumRowsFromTopV = dwNumRowsFromTopU = dwHeight;
2750 dwNumColsFromLeftU = dwPitch >> 1;
2751 break;
2752
2753 // YY
2754 // YY
2755 // U-
2756 // V-
2757 case Format_IMC3:
2758 dwNumRowsFromTopU = dwHeight;
2759 dwNumRowsFromTopV = dwHeight + (dwHeight >> 1);
2760 break;
2761
2762 // YY
2763 // YY
2764 // UV
2765 case Format_IMC4:
2766 dwNumRowsFromTopU = dwNumRowsFromTopV = dwHeight;
2767 dwNumColsFromLeftV = dwPitch >> 1;
2768 break;
2769
2770 // YY
2771 // YY
2772 // U
2773 // V
2774 case Format_I420:
2775 case Format_IYUV:
2776 dwNumRowsFromTopU = dwHeight;
2777 dwNumRowsFromTopV = dwHeight + (dwHeight >> 1);
2778 break;
2779
2780 // YY
2781 // YY
2782 // V
2783 // U
2784 case Format_YV12:
2785 dwNumRowsFromTopU = dwHeight + (dwHeight >> 1);
2786 dwNumRowsFromTopV = dwHeight;
2787 break;
2788
2789 // YYYY
2790 // YYYY
2791 // YYYY
2792 // YYYY
2793 // V
2794 // U
2795 case Format_YVU9:
2796 dwNumRowsFromTopU = dwHeight;
2797 dwNumRowsFromTopV = dwHeight + (dwHeight >> 2);
2798 break;
2799
2800 // NV12 P208
2801 // ---- ----
2802 // YY YY
2803 // YY UV (interleaved)
2804 // UV (interleaved)
2805 case Format_NV12:
2806 case Format_P208:
2807 case Format_P016:
2808 case Format_P010:
2809 dwNumRowsFromTopU = dwNumRowsFromTopV = dwHeight;
2810 break;
2811
2812 // NV11
2813 // ----
2814 // YYYY
2815 // UV (interleaved)
2816 case Format_NV11:
2817 dwNumRowsFromTopU = dwNumRowsFromTopV = dwHeight;
2818 break;
2819
2820 default:
2821 MHW_RENDERHAL_ASSERTMESSAGE("called with Packed or Unknown format.");
2822 break;
2823 }
2824
2825 // the Offsets must be even numbers so we round down
2826 dwNumRowsFromTopU = MOS_ALIGN_FLOOR(dwNumRowsFromTopU, 2);
2827 dwNumColsFromLeftU = MOS_ALIGN_FLOOR(dwNumColsFromLeftU, 2);
2828 dwNumRowsFromTopV = MOS_ALIGN_FLOOR(dwNumRowsFromTopV, 2);
2829 dwNumColsFromLeftV = MOS_ALIGN_FLOOR(dwNumColsFromLeftV, 2);
2830
2831 *pVYOffset = (uint16_t)dwNumRowsFromTopV;
2832 *pUYOffset = (uint16_t)dwNumRowsFromTopU;
2833 *pVXOffset = (uint16_t)dwNumColsFromLeftV;
2834 *pUXOffset = (uint16_t)dwNumColsFromLeftU;
2835 }
2836
2837 //!
2838 //! \brief Set Slice Shutdown Mode
2839 //! \details Sets Slice Shutdown Mode
2840 //! \param PRENDERHAL_INTERFACE pRenderHal
2841 //! [in] Pointer to RenderHal Interface Structure
2842 //! \param bool bMode
2843 //! [in] Slice Shutdown Mode
2844 //! \return void
2845 //!
RenderHal_SetSliceShutdownMode(PRENDERHAL_INTERFACE pRenderHal,bool bMode)2846 void RenderHal_SetSliceShutdownMode(
2847 PRENDERHAL_INTERFACE pRenderHal,
2848 bool bMode)
2849 {
2850 MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pRenderHal);
2851 pRenderHal->bRequestSingleSlice = bMode;
2852 }
2853
2854 //!
2855 //! \brief Set General Slice Shutdown Mode
2856 //! \details Sets General Slice Shutdown Mode
2857 //! \param PRENDERHAL_INTERFACE pRenderHal
2858 //! [in] Pointer to RenderHal Interface Structure
2859 //! \param PRENDERHAL_POWEROPTION pMode
2860 //! [in] Slice Shutdown Mode
2861 //! \return void
2862 //!
RenderHal_SetPowerOptionMode(PRENDERHAL_INTERFACE pRenderHal,PRENDERHAL_POWEROPTION pMode)2863 void RenderHal_SetPowerOptionMode(
2864 PRENDERHAL_INTERFACE pRenderHal,
2865 PRENDERHAL_POWEROPTION pMode )
2866 {
2867 MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pRenderHal);
2868 MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pMode);
2869 pRenderHal->PowerOption = *pMode;
2870 }
2871
2872 //!
2873 //! \brief Enable Middle Batch Buffer Preemption
2874 //! \details Enable Middle Batch Buffer Preemption
2875 //! \param PRENDERHAL_INTERFACE pRenderHal
2876 //! [in] Pointer to Hardware Interface Structurev
2877 //! \return void
2878 //!
RenderHal_EnableGpgpuMiddleBatchBufferPreemption(PRENDERHAL_INTERFACE pRenderHal)2879 void RenderHal_EnableGpgpuMiddleBatchBufferPreemption(
2880 PRENDERHAL_INTERFACE pRenderHal)
2881 {
2882 MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pRenderHal);
2883 pRenderHal->bEnableGpgpuMidBatchPreEmption = MEDIA_IS_SKU(pRenderHal->pSkuTable, FtrGpGpuMidBatchPreempt) ? true : false;
2884 }
2885
2886 //!
2887 //! \brief Enable Middle Thread Preemption
2888 //! \details Enable Middle Thread Preemption
2889 //! \param PRENDERHAL_INTERFACE pRenderHal
2890 //! [in] Pointer to Hardware Interface Structurev
2891 //! \return void
2892 //!
RenderHal_EnableGpgpuMiddleThreadPreemption(PRENDERHAL_INTERFACE pRenderHal)2893 void RenderHal_EnableGpgpuMiddleThreadPreemption(
2894 PRENDERHAL_INTERFACE pRenderHal)
2895 {
2896 MHW_RENDERHAL_CHK_NULL_NO_STATUS_RETURN(pRenderHal);
2897 pRenderHal->bEnableGpgpuMidThreadPreEmption = MEDIA_IS_SKU(pRenderHal->pSkuTable, FtrGpGpuMidThreadLevelPreempt) ? true : false;
2898 }
2899
2900 //!
2901 //! \brief Get Surface State Entries
2902 //! \details Gets the Surface State Entries
2903 //! \param PRENDERHAL_INTERFACE pRenderHal
2904 //! [in] Pointer to Hardware Interface structure
2905 //! \param PRENDERHAL_SURFACE pRenderHalSurface
2906 //! [in] Pointer to Render Hal Surface
2907 //! \param PRENDERHAL_SURFACE_STATE_PARAMS pParams
2908 //! [in] Pointer to Surface State Params
2909 //! \param int32_t *piNumEntries
2910 //! [out] Number of Surface Entries (one entry per surface plane)
2911 //! \param PRENDERHAL_SURFACE_STATE_ENTRY * ppSurfaceEntries
2912 //! [out] Array of Surface State Entries
2913 //! \return MOS_STATUS
2914 //!
RenderHal_GetSurfaceStateEntries(PRENDERHAL_INTERFACE pRenderHal,PRENDERHAL_SURFACE pRenderHalSurface,PRENDERHAL_SURFACE_STATE_PARAMS pParams,int32_t * piNumEntries,PRENDERHAL_SURFACE_STATE_ENTRY * ppSurfaceEntries)2915 MOS_STATUS RenderHal_GetSurfaceStateEntries(
2916 PRENDERHAL_INTERFACE pRenderHal,
2917 PRENDERHAL_SURFACE pRenderHalSurface,
2918 PRENDERHAL_SURFACE_STATE_PARAMS pParams,
2919 int32_t *piNumEntries,
2920 PRENDERHAL_SURFACE_STATE_ENTRY *ppSurfaceEntries)
2921 {
2922 MOS_STATUS eStatus;
2923 PCMHW_PLANE_SETTING pPlane;
2924 PMOS_SURFACE pSurface;
2925 RENDERHAL_PLANE_DEFINITION PlaneDefinition;
2926 PRENDERHAL_SURFACE_STATE_ENTRY pSurfaceEntry;
2927 uint32_t dwSurfaceWidth;
2928 uint32_t dwSurfaceHeight;
2929 uint32_t dwUVPitch;
2930 int32_t i;
2931 bool bHalfPitchForChroma;
2932 bool bInterleaveChroma;
2933 bool bWidthInDword;
2934 uint8_t Direction;
2935 uint16_t wUXOffset;
2936 uint16_t wUYOffset;
2937 uint16_t wVXOffset;
2938 uint16_t wVYOffset;
2939 bool bIsChromaSitEnabled;
2940
2941 //------------------------------------------------
2942 MHW_RENDERHAL_CHK_NULL(pRenderHal);
2943 MHW_RENDERHAL_CHK_NULL(pRenderHalSurface);
2944 MHW_RENDERHAL_CHK_NULL(pParams);
2945 MHW_RENDERHAL_CHK_NULL(piNumEntries);
2946 MHW_RENDERHAL_CHK_NULL(ppSurfaceEntries);
2947 //------------------------------------------------
2948
2949 eStatus = MOS_STATUS_UNKNOWN;
2950 pSurface = &pRenderHalSurface->OsSurface;
2951 dwUVPitch = pSurface->dwPitch;
2952 bHalfPitchForChroma = false;
2953 bInterleaveChroma = false;
2954 Direction = MEDIASTATE_VDIRECTION_FULL_FRAME;
2955 wUXOffset = 0;
2956 wUYOffset = 0;
2957 wVXOffset = 0;
2958 wVYOffset = 0;
2959 *piNumEntries = -1;
2960 PlaneDefinition = RENDERHAL_PLANES_DEFINITION_COUNT;
2961 bIsChromaSitEnabled = 0;
2962
2963 pRenderHal->bIsAVS = pParams->bAVS;
2964
2965 // Check palette allocations
2966 if (IS_PAL_FORMAT(pSurface->Format))
2967 {
2968 if (pRenderHalSurface->iPaletteID < 0 ||
2969 pRenderHalSurface->iPaletteID >= pRenderHal->iMaxPalettes)
2970 {
2971 MHW_RENDERHAL_ASSERTMESSAGE("Invalid palette.");
2972 goto finish;
2973 }
2974 }
2975
2976 // adjust the U/V-Pitch for formats that have U/V-Pitch smaller than Y-Pitch
2977 if (pSurface->Format == Format_I420 ||
2978 pSurface->Format == Format_IYUV ||
2979 pSurface->Format == Format_YV12 ||
2980 pSurface->Format == Format_NV11)
2981 {
2982 dwUVPitch >>= 1;
2983 }
2984 else if (pSurface->Format == Format_YVU9)
2985 {
2986 dwUVPitch >>= 2;
2987 }
2988
2989 if (pParams->Type == RENDERHAL_SURFACE_TYPE_ADV_G8 ||
2990 pParams->Type == RENDERHAL_SURFACE_TYPE_ADV_G9 ||
2991 pParams->Type == RENDERHAL_SURFACE_TYPE_ADV_G10)
2992 {
2993 // Select the surface/plane description
2994 switch (pSurface->Format)
2995 {
2996 case Format_NV12:
2997 // On G8, NV12 format needs the width and Height to be a multiple
2998 // of 4 for both 3D sampler and 8x8 sampler; G75 needs the width
2999 // of NV12 input surface to be a multiple of 4 for 3D sampler;
3000 // G9+ does not has such restriction; to simplify the implementation,
3001 // we enable 2 plane NV12 for all of the platform when the width
3002 // or Height is not a multiple of 4
3003 if (pRenderHal->pfnIs2PlaneNV12Needed(pRenderHal,
3004 pRenderHalSurface,
3005 pParams->Boundary))
3006 {
3007 PlaneDefinition = RENDERHAL_PLANES_NV12_2PLANES_ADV;
3008 }
3009 else
3010 {
3011 PlaneDefinition = RENDERHAL_PLANES_NV12_ADV;
3012 wUYOffset = RenderHal_CalculateYOffset(pRenderHal->pOsInterface, &pSurface->OsResource);
3013 }
3014
3015 bHalfPitchForChroma = false;
3016 bInterleaveChroma = true;
3017
3018 // Set up chroma direction
3019 Direction = pRenderHal->pfnSetChromaDirection(pRenderHal, pRenderHalSurface);
3020 break;
3021
3022 case Format_P208:
3023 PlaneDefinition = RENDERHAL_PLANES_P208_1PLANE_ADV;
3024 break;
3025
3026 case Format_IMC1:
3027 case Format_IMC2:
3028 case Format_IMC3:
3029 case Format_IMC4:
3030 case Format_I420:
3031 case Format_IYUV:
3032 case Format_YV12:
3033 case Format_YVU9:
3034 PlaneDefinition = RENDERHAL_PLANES_PL3_ADV;
3035 bHalfPitchForChroma = false;
3036
3037 if (pSurface->Format == Format_I420 ||
3038 pSurface->Format == Format_IYUV ||
3039 pSurface->Format == Format_YV12 ||
3040 pSurface->Format == Format_NV11)
3041 {
3042 bHalfPitchForChroma = true;
3043 }
3044
3045 // Set up chroma direction
3046 Direction = pRenderHal->pfnSetChromaDirection(pRenderHal, pRenderHalSurface);
3047
3048 if (!pParams->bAVS)
3049 {
3050 // Get U/V offset for PL3 DNDI
3051 RenderHal_Get_DI_UVOffSet(pRenderHalSurface,
3052 &wUXOffset,
3053 &wUYOffset,
3054 &wVXOffset,
3055 &wVYOffset);
3056 PlaneDefinition = RENDERHAL_PLANES_NV12_ADV;
3057 }
3058 break;
3059
3060 case Format_400P:
3061 // Single Y plane here is treated like a NV12 surface.
3062 // U and V offsets fall inside this Y plane. Eventhough false UV pixels are
3063 // picked by the kernel, CSC coeffecients are such that the effect of these
3064 // are nullified.
3065 PlaneDefinition = RENDERHAL_PLANES_NV12_ADV;
3066 break;
3067
3068 case Format_411P:
3069 PlaneDefinition = RENDERHAL_PLANES_411P_ADV;
3070 break;
3071
3072 case Format_411R:
3073 PlaneDefinition = RENDERHAL_PLANES_411R_ADV;
3074 break;
3075
3076 case Format_422H:
3077 PlaneDefinition = RENDERHAL_PLANES_422H_ADV;
3078 break;
3079
3080 case Format_422V:
3081 PlaneDefinition = RENDERHAL_PLANES_422V_ADV;
3082 break;
3083
3084 case Format_444P:
3085 PlaneDefinition = RENDERHAL_PLANES_444P_ADV;
3086 break;
3087
3088 case Format_RGBP:
3089 PlaneDefinition = RENDERHAL_PLANES_RGBP_ADV;
3090 break;
3091
3092 case Format_BGRP:
3093 PlaneDefinition = RENDERHAL_PLANES_BGRP_ADV;
3094 break;
3095
3096 case Format_AYUV:
3097 PlaneDefinition = RENDERHAL_PLANES_AYUV_ADV;
3098 break;
3099
3100 case Format_YUYV:
3101 case Format_YUY2:
3102 if (pParams->bVmeUse)
3103 {
3104 //Since 422 planar is not supported on application side.
3105 //App is using 422 packed as WA with w=w/2 and h=h*2
3106 pSurface->dwWidth = pSurface->dwWidth * 2;
3107 pSurface->dwHeight = pSurface->dwHeight / 2;
3108 pRenderHalSurface->rcSrc.right = pSurface->dwWidth;
3109 pRenderHalSurface->rcSrc.bottom = pSurface->dwHeight;
3110 pRenderHalSurface->rcDst = pRenderHalSurface->rcSrc;
3111 PlaneDefinition = RENDERHAL_PLANES_YUY2_ADV;
3112
3113 // Set up chroma direction
3114 Direction = pRenderHal->pfnSetChromaDirection(pRenderHal, pRenderHalSurface);
3115 }
3116 else
3117 {
3118 PlaneDefinition = RENDERHAL_PLANES_YUY2_ADV;
3119
3120 // Set up chroma direction
3121 Direction = pRenderHal->pfnSetChromaDirection(pRenderHal, pRenderHalSurface);
3122 }
3123 break;
3124
3125 case Format_UYVY:
3126 PlaneDefinition = RENDERHAL_PLANES_UYVY_ADV;
3127
3128 // Set up chroma direction
3129 Direction = pRenderHal->pfnSetChromaDirection(pRenderHal, pRenderHalSurface);
3130 break;
3131
3132 case Format_YVYU:
3133 PlaneDefinition = RENDERHAL_PLANES_YVYU_ADV;
3134
3135 // Set up chroma direction
3136 Direction = pRenderHal->pfnSetChromaDirection(pRenderHal, pRenderHalSurface);
3137 break;
3138
3139 case Format_VYUY:
3140 PlaneDefinition = RENDERHAL_PLANES_VYUY_ADV;
3141
3142 // Set up chroma direction
3143 Direction = pRenderHal->pfnSetChromaDirection(pRenderHal, pRenderHalSurface);
3144 break;
3145
3146 case Format_A8R8G8B8:
3147 case Format_X8R8G8B8:
3148 if (pParams->bVASurface)
3149 {
3150 pSurface->dwWidth *= 32;
3151 PlaneDefinition = RENDERHAL_PLANES_Y1;
3152 }
3153 else
3154 {
3155 PlaneDefinition = RENDERHAL_PLANES_ARGB_ADV;
3156 }
3157 break;
3158
3159 case Format_R8G8SN:
3160 if ( pParams->bVASurface )
3161 {
3162 PlaneDefinition = RENDERHAL_PLANES_Y16S;
3163 }
3164 break;
3165
3166 case Format_V8U8:
3167 if ( pParams->bVASurface )
3168 {
3169 PlaneDefinition = RENDERHAL_PLANES_Y16U;
3170 }
3171 break;
3172
3173 case Format_A8B8G8R8:
3174 case Format_X8B8G8R8:
3175 PlaneDefinition = RENDERHAL_PLANES_ABGR_ADV;
3176 break;
3177
3178 case Format_STMM:
3179 PlaneDefinition = RENDERHAL_PLANES_STMM_ADV;
3180 break;
3181
3182 case Format_A8:
3183 case Format_Buffer_2D:
3184 if (pParams->bVASurface)
3185 {
3186 PlaneDefinition = RENDERHAL_PLANES_Y8;
3187 }
3188 break;
3189 case Format_Y8:
3190 PlaneDefinition = RENDERHAL_PLANES_Y8_ADV;
3191 break;
3192
3193 case Format_L8:
3194 case Format_R8UN:
3195 if (pParams->bForceNV12)
3196 {
3197 PlaneDefinition = RENDERHAL_PLANES_NV12_ADV;
3198 bHalfPitchForChroma = false;
3199 bInterleaveChroma = true;
3200 wUYOffset = (uint16_t) pSurface->dwHeight;
3201 }
3202 else
3203 {
3204 PlaneDefinition = RENDERHAL_PLANES_L8_ADV;
3205 }
3206 break;
3207
3208 case Format_A16B16G16R16:
3209 case Format_Y416:
3210 PlaneDefinition = RENDERHAL_PLANES_A16B16G16R16_ADV;
3211 break;
3212
3213 case Format_R10G10B10A2:
3214 case Format_Y410:
3215 PlaneDefinition = RENDERHAL_PLANES_R10G10B10A2_ADV;
3216 break;
3217
3218 case Format_L16:
3219 case Format_R16S:
3220 if (pParams->bVASurface)
3221 {
3222 PlaneDefinition = RENDERHAL_PLANES_Y16S;
3223 }
3224 break;
3225
3226 case Format_D16:
3227 case Format_R16U:
3228 if (pParams->bVASurface)
3229 {
3230 PlaneDefinition = RENDERHAL_PLANES_Y16U;
3231 }
3232 break;
3233
3234 case Format_P010:
3235 case Format_P016:
3236 if (pParams->bVmeUse)
3237 {
3238 PlaneDefinition = RENDERHAL_PLANES_P010_1PLANE_ADV;
3239 }
3240 else if (pRenderHal->bEnableP010SinglePass &&
3241 (pRenderHalSurface->SurfType != RENDERHAL_SURF_OUT_RENDERTARGET))
3242 {
3243 PlaneDefinition = RENDERHAL_PLANES_P010_1PLANE_ADV;
3244 bHalfPitchForChroma = false;
3245 bInterleaveChroma = true;
3246 wUYOffset = RenderHal_CalculateYOffset(pRenderHal->pOsInterface, &pSurface->OsResource);
3247
3248 // Set up chroma direction
3249 Direction = pRenderHal->pfnSetChromaDirection(pRenderHal, pRenderHalSurface);
3250 }
3251 else
3252 {
3253 // Format not supported with AVS - use regular format
3254 MHW_RENDERHAL_NORMALMESSAGE("Format not supported with AVS.");
3255
3256 pParams->bAVS = false;
3257
3258 // Since the format is not supported with AVS, set the scaling mode as bilinear.
3259 pRenderHalSurface->ScalingMode = RENDERHAL_SCALING_BILINEAR;
3260
3261 if (pParams->Type == RENDERHAL_SURFACE_TYPE_ADV_G8)
3262 {
3263 pParams->Type = RENDERHAL_SURFACE_TYPE_G8;
3264 }
3265 else if (pParams->Type == RENDERHAL_SURFACE_TYPE_ADV_G9)
3266 {
3267 pParams->Type = RENDERHAL_SURFACE_TYPE_G9;
3268 }
3269 else if (pParams->Type == RENDERHAL_SURFACE_TYPE_ADV_G10)
3270 {
3271 pParams->Type = RENDERHAL_SURFACE_TYPE_G10;
3272 }
3273 else
3274 {
3275 MHW_RENDERHAL_ASSERTMESSAGE("Unsupported surface type");
3276 }
3277 }
3278 break;
3279 case Format_Y210:
3280 case Format_Y216:
3281 if (pParams->bVmeUse)
3282 {
3283 //Since 422 planar is not supported on application side.
3284 //App is using 422 packed as WA with w=w/2 and h=h*2
3285 pSurface->dwWidth = pSurface->dwWidth * 2;
3286 pSurface->dwHeight = pSurface->dwHeight / 2;
3287 pRenderHalSurface->rcSrc.right = pSurface->dwWidth;
3288 pRenderHalSurface->rcSrc.bottom = pSurface->dwHeight;
3289 pRenderHalSurface->rcDst = pRenderHalSurface->rcSrc;
3290 PlaneDefinition = RENDERHAL_PLANES_Y210_1PLANE_ADV;
3291 }
3292 else
3293 {
3294 PlaneDefinition = RENDERHAL_PLANES_Y210_ADV;
3295 }
3296 break;
3297 default:
3298 // Format not supported with AVS - use regular format
3299 MHW_RENDERHAL_NORMALMESSAGE("Format not supported with AVS.");
3300
3301 pParams->bAVS = false;
3302
3303 // Since the format is not supported with AVS, set the scaling mode as bilinear.
3304 pRenderHalSurface->ScalingMode = RENDERHAL_SCALING_BILINEAR;
3305
3306 if (pParams->Type == RENDERHAL_SURFACE_TYPE_ADV_G8)
3307 {
3308 pParams->Type = RENDERHAL_SURFACE_TYPE_G8;
3309 }
3310 else if (pParams->Type == RENDERHAL_SURFACE_TYPE_ADV_G9)
3311 {
3312 pParams->Type = RENDERHAL_SURFACE_TYPE_G9;
3313 }
3314 else if (pParams->Type == RENDERHAL_SURFACE_TYPE_ADV_G10)
3315 {
3316 pParams->Type = RENDERHAL_SURFACE_TYPE_G10;
3317 }
3318 else
3319 {
3320 MHW_RENDERHAL_ASSERTMESSAGE("Unsupported surface type");
3321 }
3322
3323 break;
3324 }
3325 }
3326
3327 // Select the surface/plane description
3328 if (pParams->Type == RENDERHAL_SURFACE_TYPE_G8 ||
3329 pParams->Type == RENDERHAL_SURFACE_TYPE_G9 ||
3330 pParams->Type == RENDERHAL_SURFACE_TYPE_G10)
3331 {
3332 bIsChromaSitEnabled = pRenderHal->pRenderHalPltInterface->IsChromasitingEnabled(pRenderHal, pParams);
3333
3334 switch (pSurface->Format)
3335 {
3336 case Format_IMC1:
3337 case Format_IMC2:
3338 case Format_IMC3:
3339 case Format_IMC4:
3340 case Format_I420:
3341 case Format_IYUV:
3342 case Format_YVU9:
3343 PlaneDefinition = RENDERHAL_PLANES_PL3;
3344 break;
3345
3346 case Format_YV12:
3347 bHalfPitchForChroma = true;
3348
3349 // Y_Uoffset(Height*2 + Height/2) of RENDERHAL_PLANES_YV12 define Bitfield_Range(0, 13) on gen9+.
3350 // The max value is 16383. So use PL3 kernel to avoid out of range when Y_Uoffset is larger than 16383.
3351 // Use PL3 plane to avoid YV12 blending issue with DI enabled and U channel shift issue with not 4-aligned height
3352 PlaneDefinition = (pRenderHal->bEnableYV12SinglePass &&
3353 !pRenderHalSurface->pDeinterlaceParams &&
3354 !pRenderHalSurface->bInterlacedScaling &&
3355 MOS_IS_ALIGNED(pSurface->dwHeight, 4) &&
3356 pRenderHalSurface->SurfType != RENDERHAL_SURF_OUT_RENDERTARGET &&
3357 (pSurface->dwHeight * 2 + pSurface->dwHeight / 2) < RENDERHAL_MAX_YV12_PLANE_Y_U_OFFSET_G9)?
3358 RENDERHAL_PLANES_YV12 : RENDERHAL_PLANES_PL3;
3359 break;
3360
3361 case Format_400P:
3362 // Single Y plane here is treated like a NV12 surface.
3363 // U and V offsets fall inside this Y plane. Eventhough false UV pixels are
3364 // picked by the kernel, CSC coeffecients are such that the effect of these
3365 // are nullified.
3366 PlaneDefinition = RENDERHAL_PLANES_NV12;
3367 break;
3368
3369 case Format_P208:
3370 PlaneDefinition = RENDERHAL_PLANES_P208;
3371 break;
3372
3373 case Format_P010:
3374 case Format_P016:
3375 if (pParams->bUseSinglePlane == true)
3376 {
3377 PlaneDefinition = RENDERHAL_PLANES_R16_UNORM;
3378 }
3379 else if (pRenderHal->bEnableP010SinglePass &&
3380 (pRenderHalSurface->SurfType != RENDERHAL_SURF_OUT_RENDERTARGET))
3381 {
3382 PlaneDefinition = RENDERHAL_PLANES_P010_1PLANE;
3383 }
3384 else
3385 {
3386 PlaneDefinition = RENDERHAL_PLANES_P010;
3387 }
3388 break;
3389
3390 case Format_411P:
3391 PlaneDefinition = RENDERHAL_PLANES_411P;
3392 break;
3393
3394 case Format_411R:
3395 PlaneDefinition = RENDERHAL_PLANES_411R;
3396 break;
3397
3398 case Format_422H:
3399 PlaneDefinition = RENDERHAL_PLANES_422H;
3400 break;
3401
3402 case Format_422V:
3403 PlaneDefinition = RENDERHAL_PLANES_422V;
3404 break;
3405
3406 case Format_444P:
3407 PlaneDefinition = RENDERHAL_PLANES_444P;
3408 break;
3409
3410 case Format_RGBP:
3411 PlaneDefinition = RENDERHAL_PLANES_RGBP;
3412 break;
3413
3414 case Format_BGRP:
3415 PlaneDefinition = RENDERHAL_PLANES_BGRP;
3416 break;
3417
3418 case Format_NV12:
3419 // On Gen7.5 (Haswell) NV12 format needs a single plane instead
3420 // of two (listed in renderhal_g75.c for RENDERHAL_PLANES_NV12), and
3421 // is also expected by the Sampler or Media Kernels. Yet, the
3422 // Data Port works with two planes instead. Besides, the Sampler
3423 // uses it for input only (as there is no output) while the Data
3424 // Port uses it for input as well as output or both for the same
3425 // surface. Hence the check added for bWidthInDword_Y &&
3426 // bWidthInDword_UV, which are set in vphal_render_3P.c for the
3427 // above reason. Two plane NV12 can also be explicitly spcified.
3428
3429 // On G8, NV12 format needs the width and Height to be a multiple
3430 // of 4 for both 3D sampler and 8x8 sampler; G75 needs the width
3431 // of NV12 input surface to be a multiple of 4 for 3D sampler;
3432 // On G9+, width need to be a multiple of 2, while height still need
3433 // be a multiple of 4; since G9 already post PV, just keep the old logic
3434 // to enable 2 plane NV12 when the width or Height is not a multiple of 4.
3435 // For G10+, enable 2 plane NV12 when width is not multiple of 2 or height
3436 // is not multiple of 4.
3437 if (pParams->bUseSinglePlane == true)
3438 {
3439 PlaneDefinition = RENDERHAL_PLANES_R8;
3440 }
3441 else if (pRenderHalSurface->SurfType == RENDERHAL_SURF_OUT_RENDERTARGET ||
3442 (pParams->bWidthInDword_Y && pParams->bWidthInDword_UV) ||
3443 pParams->b2PlaneNV12NeededByKernel ||
3444 bIsChromaSitEnabled ||
3445 pRenderHal->pfnIs2PlaneNV12Needed(pRenderHal,
3446 pRenderHalSurface,
3447 pParams->Boundary))
3448 {
3449 PlaneDefinition = RENDERHAL_PLANES_NV12_2PLANES;
3450 }
3451 else
3452 {
3453 PlaneDefinition = RENDERHAL_PLANES_NV12;
3454 MHW_RENDERHAL_CHK_NULL(pRenderHal->pRenderHalPltInterface);
3455 pRenderHal->pRenderHalPltInterface->GetPlaneDefForFormatNV12(
3456 PlaneDefinition);
3457 }
3458 break;
3459
3460 case Format_YUYV :
3461 case Format_YUY2 :
3462 if (bIsChromaSitEnabled)
3463 {
3464 PlaneDefinition = RENDERHAL_PLANES_YUY2_2PLANES;
3465 }
3466 else
3467 {
3468 PlaneDefinition = RENDERHAL_PLANES_YUY2;
3469 }
3470 break;
3471
3472 case Format_G8R8_G8B8:
3473 case Format_UYVY :
3474 PlaneDefinition = RENDERHAL_PLANES_UYVY;
3475 break;
3476
3477 case Format_YVYU:
3478 PlaneDefinition = RENDERHAL_PLANES_YVYU;
3479 break;
3480
3481 case Format_VYUY:
3482 PlaneDefinition = RENDERHAL_PLANES_VYUY;
3483 break;
3484
3485 case Format_A8R8G8B8:
3486 PlaneDefinition = RENDERHAL_PLANES_ARGB;
3487 break;
3488
3489 case Format_R32U:
3490 PlaneDefinition = RENDERHAL_PLANES_R32U;
3491 break;
3492
3493 case Format_R32S:
3494 PlaneDefinition = RENDERHAL_PLANES_R32S;
3495 break;
3496
3497 case Format_R32F:
3498 case Format_D32F:
3499 case Format_R32:
3500 PlaneDefinition = RENDERHAL_PLANES_R32F;
3501 break;
3502
3503 case Format_Y8:
3504 PlaneDefinition = RENDERHAL_PLANES_R8;
3505 break;
3506
3507 case Format_Y1:
3508 PlaneDefinition = RENDERHAL_PLANES_Y1;
3509 break;
3510
3511 case Format_Y16U:
3512 PlaneDefinition = RENDERHAL_PLANES_Y16U;
3513 break;
3514
3515 case Format_Y16S:
3516 PlaneDefinition = RENDERHAL_PLANES_Y16S;
3517 break;
3518
3519 case Format_R8G8SN:
3520 case Format_V8U8:
3521 PlaneDefinition = RENDERHAL_PLANES_V8U8;
3522 break;
3523
3524 case Format_R16U:
3525 PlaneDefinition = RENDERHAL_PLANES_R16U;
3526 break;
3527
3528 case Format_R16S:
3529 PlaneDefinition = RENDERHAL_PLANES_R16S;
3530 break;
3531
3532 case Format_R8G8UN:
3533 PlaneDefinition = RENDERHAL_PLANES_R8G8_UNORM;
3534 break;
3535
3536 case Format_X8R8G8B8:
3537 // h/w doesn't support XRGB render target
3538 PlaneDefinition =
3539 (pParams->bRenderTarget) ? RENDERHAL_PLANES_ARGB : RENDERHAL_PLANES_XRGB;
3540 break;
3541
3542 case Format_A8B8G8R8:
3543 PlaneDefinition = RENDERHAL_PLANES_ABGR;
3544 break;
3545
3546 case Format_X8B8G8R8:
3547 // h/w doesn't support XBGR render target
3548 PlaneDefinition =
3549 (pParams->bRenderTarget) ? RENDERHAL_PLANES_ABGR : RENDERHAL_PLANES_XBGR;
3550 break;
3551
3552 case Format_R5G6B5:
3553 PlaneDefinition = RENDERHAL_PLANES_RGB16;
3554 break;
3555
3556 case Format_R8G8B8:
3557 PlaneDefinition = RENDERHAL_PLANES_RGB24;
3558 break;
3559
3560 case Format_AYUV :
3561 PlaneDefinition = RENDERHAL_PLANES_AYUV;
3562 break;
3563
3564 case Format_AI44 :
3565 PlaneDefinition = (pRenderHalSurface->iPaletteID == 0) ?
3566 RENDERHAL_PLANES_AI44_PALLETE_0 :
3567 RENDERHAL_PLANES_AI44_PALLETE_1;
3568 break;
3569
3570 case Format_IA44:
3571 PlaneDefinition = (pRenderHalSurface->iPaletteID == 0) ?
3572 RENDERHAL_PLANES_IA44_PALLETE_0 :
3573 RENDERHAL_PLANES_IA44_PALLETE_1;
3574 break;
3575
3576 case Format_P8:
3577 PlaneDefinition = (pRenderHalSurface->iPaletteID == 0) ?
3578 RENDERHAL_PLANES_P8_PALLETE_0 :
3579 RENDERHAL_PLANES_P8_PALLETE_1;
3580 break;
3581
3582 case Format_A8P8:
3583 PlaneDefinition = (pRenderHalSurface->iPaletteID == 0) ?
3584 RENDERHAL_PLANES_A8P8_PALLETE_0 :
3585 RENDERHAL_PLANES_A8P8_PALLETE_1;
3586 break;
3587
3588 case Format_STMM:
3589 PlaneDefinition = RENDERHAL_PLANES_STMM;
3590 break;
3591
3592 case Format_L8:
3593 PlaneDefinition = RENDERHAL_PLANES_L8;
3594 break;
3595
3596 case Format_A8:
3597 case Format_Buffer_2D:
3598 PlaneDefinition = RENDERHAL_PLANES_A8;
3599 break;
3600
3601 case Format_R8U:
3602 case Format_R8UN:
3603 PlaneDefinition = RENDERHAL_PLANES_R8;
3604 break;
3605
3606 case Format_R16UN:
3607 case Format_D16:
3608 case Format_R16:
3609 PlaneDefinition = RENDERHAL_PLANES_R16_UNORM;
3610 break;
3611
3612 case Format_A16B16G16R16:
3613 PlaneDefinition = RENDERHAL_PLANES_A16B16G16R16;
3614 break;
3615 case Format_Y416:
3616 if (pRenderHalSurface->SurfType == RENDERHAL_SURF_OUT_RENDERTARGET)
3617 {
3618 PlaneDefinition = RENDERHAL_PLANES_Y416_RT;
3619 }
3620 else
3621 {
3622 PlaneDefinition = RENDERHAL_PLANES_A16B16G16R16;
3623 }
3624 break;
3625 case Format_A16B16G16R16F:
3626 PlaneDefinition = RENDERHAL_PLANES_A16B16G16R16F;
3627 break;
3628 case Format_A16R16G16B16F:
3629 PlaneDefinition = RENDERHAL_PLANES_A16R16G16B16F;
3630 break;
3631 case Format_R32G32B32A32F:
3632 PlaneDefinition = RENDERHAL_PLANES_R32G32B32A32F;
3633 break;
3634
3635 case Format_NV21:
3636 PlaneDefinition = RENDERHAL_PLANES_NV21;
3637 break;
3638 case Format_L16:
3639 PlaneDefinition = RENDERHAL_PLANES_L16;
3640 break;
3641
3642 case Format_R10G10B10A2:
3643 case Format_Y410:
3644 PlaneDefinition = RENDERHAL_PLANES_R10G10B10A2;
3645 break;
3646
3647 case Format_Y210:
3648 case Format_Y216:
3649 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pRenderHalPltInterface->GetPlaneDefForFormatY216(
3650 (pRenderHalSurface->SurfType == RENDERHAL_SURF_OUT_RENDERTARGET),
3651 pRenderHal,
3652 PlaneDefinition));
3653 break;
3654
3655 case Format_B10G10R10A2:
3656 PlaneDefinition = RENDERHAL_PLANES_B10G10R10A2;
3657 break;
3658
3659 case Format_IRW0:
3660 PlaneDefinition = RENDERHAL_PLANES_IRW0;
3661 break;
3662
3663 case Format_IRW1:
3664 PlaneDefinition = RENDERHAL_PLANES_IRW1;
3665 break;
3666
3667 case Format_IRW2:
3668 PlaneDefinition = RENDERHAL_PLANES_IRW2;
3669 break;
3670
3671 case Format_IRW3:
3672 PlaneDefinition = RENDERHAL_PLANES_IRW3;
3673 break;
3674
3675 case Format_R16G16UN:
3676 PlaneDefinition = RENDERHAL_PLANES_R16G16_UNORM;
3677 break;
3678
3679 case Format_R16G16S:
3680 PlaneDefinition = RENDERHAL_PLANES_R16G16_SINT;
3681 break;
3682
3683 case Format_R16F:
3684 PlaneDefinition = RENDERHAL_PLANES_R16_FLOAT;
3685 break;
3686
3687 case Format_R24G8:
3688 case Format_D24S8UN:
3689 PlaneDefinition = RENDERHAL_PLANES_R24_UNORM_X8_TYPELESS;
3690 break;
3691
3692 case Format_R32G8X24:
3693 case Format_D32S8X24_FLOAT:
3694 PlaneDefinition = RENDERHAL_PLANES_R32_FLOAT_X8X24_TYPELESS;
3695 break;
3696
3697 default:
3698 goto finish;
3699 }
3700 }
3701
3702 // Get plane definitions
3703 MHW_RENDERHAL_ASSERT(PlaneDefinition < RENDERHAL_PLANES_DEFINITION_COUNT);
3704 *piNumEntries = pRenderHal->pPlaneDefinitions[PlaneDefinition].dwNumPlanes;
3705 pPlane = pRenderHal->pPlaneDefinitions[PlaneDefinition].Plane;
3706 if (*piNumEntries == 0)
3707 {
3708 goto finish;
3709 }
3710
3711 // Surface state allocation/setting loop
3712 for (i = 0; i < *piNumEntries; i++, pPlane++)
3713 {
3714 // Assign a New Surface State Entry
3715 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pfnAssignSurfaceState(pRenderHal,
3716 pParams->Type,
3717 &pSurfaceEntry));
3718
3719 // Save surface entry
3720 ppSurfaceEntries[i] = pSurfaceEntry;
3721
3722 // Adjust the surface height and width
3723 pRenderHal->pfnAdjustBoundary(pRenderHal,
3724 pRenderHalSurface,
3725 pParams->Boundary,
3726 &dwSurfaceWidth,
3727 &dwSurfaceHeight);
3728
3729 //set dwSurfaceHeight = roundup(dwSurfaceHeight / pPlane->ui8ScaleHeight) to support NV12 format with odd height
3730 dwSurfaceHeight = (dwSurfaceHeight + pPlane->ui8ScaleHeight - 1) / pPlane->ui8ScaleHeight;
3731 dwSurfaceWidth = dwSurfaceWidth / pPlane->ui8ScaleWidth;
3732
3733 // U/V/UV plane
3734 if (pPlane->ui8PlaneID == MHW_U_PLANE ||
3735 pPlane->ui8PlaneID == MHW_V_PLANE)
3736 {
3737 bWidthInDword = pParams->bWidthInDword_UV;
3738 }
3739 else
3740 {
3741 bWidthInDword = pParams->bWidthInDword_Y;
3742 }
3743
3744 // Adjust the width
3745 if (bWidthInDword)
3746 {
3747 if (PlaneDefinition == RENDERHAL_PLANES_R32G32B32A32F)
3748 {
3749 dwSurfaceWidth = dwSurfaceWidth << 2;
3750 }
3751 else if (PlaneDefinition == RENDERHAL_PLANES_A16B16G16R16 ||
3752 PlaneDefinition == RENDERHAL_PLANES_A16B16G16R16_ADV ||
3753 PlaneDefinition == RENDERHAL_PLANES_A16B16G16R16F ||
3754 PlaneDefinition == RENDERHAL_PLANES_A16R16G16B16F ||
3755 PlaneDefinition == RENDERHAL_PLANES_Y210_RT ||
3756 PlaneDefinition == RENDERHAL_PLANES_Y416_RT ||
3757 PlaneDefinition == RENDERHAL_PLANES_R32_FLOAT_X8X24_TYPELESS)
3758 {
3759 dwSurfaceWidth = dwSurfaceWidth << 1;
3760 }
3761 else if (MEDIA_IS_SKU(pRenderHal->pSkuTable, FtrDisableRenderTargetWidthAdjust) &&
3762 (PlaneDefinition == RENDERHAL_PLANES_NV12_2PLANES ||
3763 PlaneDefinition == RENDERHAL_PLANES_P010 ||
3764 PlaneDefinition == RENDERHAL_PLANES_YUY2_2PLANES ||
3765 PlaneDefinition == RENDERHAL_PLANES_YUY2))
3766 {
3767 dwSurfaceWidth = dwSurfaceWidth / OutputSurfaceWidthRatio;
3768 }
3769 else
3770 {
3771 dwSurfaceWidth = (dwSurfaceWidth + pPlane->ui8PixelsPerDword - 1) /
3772 pPlane->ui8PixelsPerDword;
3773 }
3774 }
3775
3776 if (pParams->bVertStride)
3777 {
3778 dwSurfaceHeight /= 2;
3779 dwSurfaceHeight = MOS_MAX(dwSurfaceHeight, 1);
3780 }
3781
3782 dwSurfaceHeight = MOS_ALIGN_FLOOR(dwSurfaceHeight, pPlane->ui8AlignHeight);
3783 dwSurfaceWidth = MOS_ALIGN_FLOOR(dwSurfaceWidth , pPlane->ui8AlignWidth);
3784
3785 // Setup surface state entry
3786 *(pSurfaceEntry->pSurface) = *pSurface;
3787 pSurfaceEntry->dwFormat = pPlane->dwFormat;
3788 pSurfaceEntry->dwWidth = MOS_MAX(1, dwSurfaceWidth);
3789 pSurfaceEntry->dwHeight = MOS_MAX(1, dwSurfaceHeight);
3790 pSurfaceEntry->bWidthInDword = bWidthInDword;
3791
3792 if (pPlane->ui8PlaneID == MHW_U_PLANE ||
3793 pPlane->ui8PlaneID == MHW_V_PLANE)
3794 {
3795 pSurfaceEntry->dwPitch = dwUVPitch;
3796 }
3797 else
3798 {
3799 pSurfaceEntry->dwPitch = pSurface->dwPitch;
3800 }
3801
3802 pSurfaceEntry->dwQPitch = pSurface->dwQPitch;
3803
3804 pSurfaceEntry->YUVPlane = pPlane->ui8PlaneID;
3805 pSurfaceEntry->bAVS = pPlane->bAdvanced;
3806 pSurfaceEntry->bRenderTarget = pParams->bRenderTarget;
3807 pSurfaceEntry->bVertStride = pParams->bVertStride;
3808 pSurfaceEntry->bVertStrideOffs = pParams->bVertStrideOffs;
3809 pSurfaceEntry->bTiledSurface = (pSurface->TileType != MOS_TILE_LINEAR)
3810 ? true
3811 : false;
3812 pSurfaceEntry->bTileWalk = IS_Y_MAJOR_TILE_FORMAT(pSurface->TileType)
3813 ? GFX3DSTATE_TILEWALK_YMAJOR
3814 : GFX3DSTATE_TILEWALK_XMAJOR;
3815 // AVS/ADI parameters
3816 pSurfaceEntry->bHalfPitchChroma = bHalfPitchForChroma;
3817 pSurfaceEntry->bInterleaveChroma = bInterleaveChroma;
3818 pSurfaceEntry->DirectionV = Direction & 0x7;
3819 pSurfaceEntry->DirectionU = Direction >> 0x3;
3820 pSurfaceEntry->wUXOffset = wUXOffset;
3821 pSurfaceEntry->wUYOffset = wUYOffset;
3822 pSurfaceEntry->wVXOffset = wVXOffset;
3823 pSurfaceEntry->wVYOffset = wVYOffset;
3824 pSurfaceEntry->AddressControl = pParams->AddressControl;
3825 }
3826
3827 eStatus = MOS_STATUS_SUCCESS;
3828
3829 finish:
3830 return eStatus;
3831 }
3832
3833 //!
3834 //! \brief Enable Palette
3835 //! \details Enable HW palette - reuse previous palette data
3836 //! \param PRENDERHAL_INTERFACE pRenderHal
3837 //! [in] Pointer to Hardware Interface Structure
3838 //! \param uint32_t uiPaletteID
3839 //! [in] Palette ID (0 to available palettes - 1)
3840 //! \param int32_t iPaletteSize
3841 //! [in] Palette Size (<=0 - disable palette)
3842 //! \return MOS_STATUS
3843 //! Error code if invalid parameters, MOS_STATUS_SUCCESS otherwise
3844 //!
RenderHal_EnablePalette(PRENDERHAL_INTERFACE pRenderHal,int32_t iPaletteID,int32_t iPaletteSize)3845 MOS_STATUS RenderHal_EnablePalette(
3846 PRENDERHAL_INTERFACE pRenderHal,
3847 int32_t iPaletteID,
3848 int32_t iPaletteSize)
3849 {
3850 PMHW_PALETTE_PARAMS pPalette;
3851
3852 //-------------------------------------
3853 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
3854 MHW_RENDERHAL_ASSERT(iPaletteID >= 0);
3855 MHW_RENDERHAL_ASSERT(iPaletteID < pRenderHal->iMaxPalettes);
3856 //-------------------------------------
3857
3858 // Palette ID provided invalid or allocation failed
3859 //pHwCommands = pRenderHal->pHwCommands;
3860
3861 // Set palette size - 0 disables palette send command
3862 iPaletteSize = MOS_MAX(iPaletteSize, 0);
3863 iPaletteSize = MOS_MIN(iPaletteSize, pRenderHal->iMaxPaletteEntries);
3864 pPalette = &(pRenderHal->Palette[iPaletteID]);
3865 pPalette->iNumEntries = iPaletteSize;
3866
3867 return MOS_STATUS_SUCCESS;
3868 }
3869
3870 //!
3871 //! \brief Allocate Palette ID
3872 //! \details Allocate palette ID for Client
3873 //! \param PRENDERHAL_INTERFACE pRenderHal
3874 //! [in] Pointer to RenderHal Interface structure
3875 //! \param int32_t *pPaletteID
3876 //! [out] Pointer to Palette ID
3877 //! \return MOS_STATUS
3878 //! MOS_STATUS_SUCCESS, otherwise MOS_STATUS_NO_SPACE or MOS_STATUS_NULL_POINTER
3879 //!
RenderHal_AllocatePaletteID(PRENDERHAL_INTERFACE pRenderHal,int32_t * pPaletteID)3880 MOS_STATUS RenderHal_AllocatePaletteID(
3881 PRENDERHAL_INTERFACE pRenderHal,
3882 int32_t *pPaletteID)
3883 {
3884 int32_t i;
3885 PMHW_PALETTE_PARAMS pOutPalette;
3886 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3887
3888 MHW_RENDERHAL_CHK_NULL(pRenderHal);
3889 MHW_RENDERHAL_CHK_NULL(pPaletteID);
3890
3891 *pPaletteID = -1;
3892
3893 pOutPalette = pRenderHal->Palette;
3894 // search first palette not in use
3895 for (i = 0;
3896 i < pRenderHal->iMaxPalettes;
3897 i++, pOutPalette++)
3898 {
3899 if (pOutPalette->iNumEntries == 0)
3900 {
3901 pOutPalette->iNumEntries = -1;
3902 break;
3903 }
3904 }
3905
3906 // Allocation failed
3907 if (i < 0 || i >= pRenderHal->iMaxPalettes)
3908 {
3909 MHW_RENDERHAL_ASSERTMESSAGE("cannot find valid palette ID.");
3910 eStatus = MOS_STATUS_NO_SPACE;
3911 goto finish;
3912 }
3913 else
3914 {
3915 *pPaletteID = i;
3916 }
3917
3918 finish:
3919 return eStatus;
3920 }
3921
3922 //!
3923 //! \brief Get Palette Entry Size and Address
3924 //! \details Get Palette Entry Size and Address for Client to load palette
3925 //! \param PRENDERHAL_INTERFACE pRenderHal
3926 //! [in] Pointer to RenderHal Interface structure
3927 //! \param int32_t iPaletteID
3928 //! [in] Input Palette ID
3929 //! \param int32_t iInNumEntries
3930 //! [in] Number of Input Palette entries
3931 //! \param int32_t *piOutNumEntries
3932 //! [out] Number of Output Palette entries
3933 //! \param void **pPaletteData
3934 //! [out] Pointer to Output Palette data address
3935 //! \return MOS_STATUS
3936 //! MOS_STATUS_SUCCESS, otherwise MOS_STATUS_INVALID_PARAMETER or MOS_STATUS_NULL_POINTER
3937 //!
RenderHal_GetPaletteEntry(PRENDERHAL_INTERFACE pRenderHal,int32_t iPaletteID,int32_t iInNumEntries,int32_t * piOutNumEntries,void ** pPaletteData)3938 MOS_STATUS RenderHal_GetPaletteEntry(
3939 PRENDERHAL_INTERFACE pRenderHal,
3940 int32_t iPaletteID,
3941 int32_t iInNumEntries,
3942 int32_t *piOutNumEntries,
3943 void **pPaletteData)
3944 {
3945 PMHW_PALETTE_PARAMS pOutPalette;
3946 int32_t iSize;
3947 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3948
3949 MHW_RENDERHAL_CHK_NULL(pRenderHal);
3950 MHW_RENDERHAL_CHK_NULL(piOutNumEntries);
3951 MHW_RENDERHAL_CHK_NULL(pPaletteData);
3952
3953 *piOutNumEntries = -1;
3954 *pPaletteData = nullptr;
3955 // Palette Index provided invalid
3956 if (iPaletteID < 0 || iPaletteID >= pRenderHal->iMaxPalettes)
3957 {
3958 MHW_RENDERHAL_ASSERTMESSAGE("invalid palette ID.");
3959 eStatus = MOS_STATUS_INVALID_PARAMETER;
3960 goto finish;
3961 }
3962
3963 // Input Palette entry number invalid
3964 if (iInNumEntries < 1)
3965 {
3966 MHW_RENDERHAL_ASSERTMESSAGE("invalid Input Palette entries.");
3967 eStatus = MOS_STATUS_INVALID_PARAMETER;
3968 goto finish;
3969 }
3970
3971 // Get pointer to output palette
3972 pOutPalette = &(pRenderHal->Palette[iPaletteID]);
3973
3974 // Pallete is too large - truncate
3975 if (iInNumEntries > pRenderHal->iMaxPaletteEntries)
3976 {
3977 iSize = pRenderHal->iMaxPaletteEntries;
3978 MHW_RENDERHAL_ASSERTMESSAGE("Palette truncated from %d to %d.", iInNumEntries, iSize);
3979 }
3980 else
3981 {
3982 iSize = iInNumEntries;
3983 }
3984 // Pallete is being overwritten - just log
3985 if (pOutPalette->iNumEntries != 0 &&
3986 pOutPalette->iNumEntries != -1)
3987 {
3988 MHW_RENDERHAL_ASSERTMESSAGE("overwriting palette %d.", iPaletteID);
3989 }
3990
3991 pOutPalette->iNumEntries = iSize;
3992 *piOutNumEntries = iSize;
3993 *pPaletteData = pOutPalette->pPaletteData;
3994
3995 finish:
3996 return eStatus;
3997 }
3998 //!
3999 //! \brief Free Palette ID
4000 //! \details Free palette ID
4001 //! \param PRENDERHAL_INTERFACE pRenderHal
4002 //! [in] Pointer to RenderHal Interface structure
4003 //! \param int32_t *pPaletteID
4004 //! [in/out] Pointer to Palette ID
4005 //! \return MOS_STATUS
4006 //! MOS_STATUS_SUCCESS, otherwise MOS_STATUS_INVALID_PARAMETER or MOS_STATUS_NULL_POINTER
4007 //!
RenderHal_FreePaletteID(PRENDERHAL_INTERFACE pRenderHal,int32_t * pPaletteID)4008 MOS_STATUS RenderHal_FreePaletteID(
4009 PRENDERHAL_INTERFACE pRenderHal,
4010 int32_t *pPaletteID)
4011 {
4012 PMHW_PALETTE_PARAMS pOutPalette;
4013 int32_t iPaletteID;
4014 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
4015
4016 MHW_RENDERHAL_CHK_NULL(pRenderHal);
4017 MHW_RENDERHAL_CHK_NULL(pPaletteID);
4018
4019 iPaletteID = *pPaletteID;
4020 if (iPaletteID < 0 || iPaletteID >= pRenderHal->iMaxPalettes)
4021 {
4022 MHW_RENDERHAL_ASSERTMESSAGE("invalid palette ID.");
4023 eStatus = MOS_STATUS_INVALID_PARAMETER;
4024 goto finish;
4025 }
4026
4027 pOutPalette = &(pRenderHal->Palette[iPaletteID]);
4028 pOutPalette->iNumEntries = 0;
4029 *pPaletteID = -1;
4030
4031 finish:
4032 return eStatus;
4033 }
4034
4035 //!
4036 //! \brief Allocate ChromaKey
4037 //! \details Allocate chroma key for use with sampler
4038 //! \param PRENDERHAL_INTERFACE pRenderHal
4039 //! [in] Pointer to Hardware Interface Structure
4040 //! \param uint32_t dwLow
4041 //! Min Key Range
4042 //! \param uint32_t dwHigh
4043 //! Max Key Range
4044 //! \return int32_t
4045 //! Chroma key index
4046 //! -1 if not available
4047 //!
RenderHal_AllocateChromaKey(PRENDERHAL_INTERFACE pRenderHal,uint32_t dwLow,uint32_t dwHigh)4048 int32_t RenderHal_AllocateChromaKey(
4049 PRENDERHAL_INTERFACE pRenderHal,
4050 uint32_t dwLow,
4051 uint32_t dwHigh)
4052 {
4053 PMHW_CHROMAKEY_PARAMS pChromaKey;
4054 int32_t iChromaKeyIndex = -1;
4055
4056 // Validate parameters
4057 if (pRenderHal == nullptr)
4058 {
4059 MHW_RENDERHAL_ASSERTMESSAGE("Invalid RenderHal interface.");
4060 goto finish;
4061 }
4062
4063 if (pRenderHal->iChromaKeyCount > pRenderHal->iMaxChromaKeys)
4064 {
4065 MHW_RENDERHAL_ASSERTMESSAGE("Reached max number of chroma keys.");
4066 goto finish;
4067 }
4068
4069 // Get chroma index - setup command
4070 iChromaKeyIndex = pRenderHal->iChromaKeyCount++;
4071 pChromaKey = &pRenderHal->ChromaKey[iChromaKeyIndex];
4072 pChromaKey->dwLow = dwLow;
4073 pChromaKey->dwHigh = dwHigh;
4074
4075 finish:
4076 // Return Chroma Key Index
4077 return iChromaKeyIndex;
4078 }
4079
4080 //!
4081 //! \brief Assign Media State
4082 //! \details Gets a pointer to the next available media state in GSH;
4083 //! fails if not available
4084 //! \param PRENDERHAL_INTERFACE pRenderHal
4085 //! [in] Pointer to Hadrware Interface Structure
4086 //! \param RENDERHAL_COMPONENT componentID
4087 //! [in] Identifier of the requesting component
4088 //! \return PRENDERHAL_MEDIA_STATE
4089 //! gets a new Media State, returns pointer to Media State structure
4090 //! nullptr - invalid, no states available + timeout
4091 //!
RenderHal_AssignMediaState(PRENDERHAL_INTERFACE pRenderHal,RENDERHAL_COMPONENT componentID)4092 PRENDERHAL_MEDIA_STATE RenderHal_AssignMediaState(
4093 PRENDERHAL_INTERFACE pRenderHal,
4094 RENDERHAL_COMPONENT componentID)
4095 {
4096 uint32_t dwWaitMs, dwWaitTag;
4097 PMOS_INTERFACE pOsInterface = nullptr; // OS interface
4098 PRENDERHAL_STATE_HEAP pStateHeap = nullptr; // State Heap control struct
4099 PRENDERHAL_MEDIA_STATE pCurMediaState; // Media state control in GSH struct
4100 uint8_t *pCurrentPtr;
4101 int i;
4102
4103 pCurMediaState = nullptr;
4104 pCurrentPtr = nullptr;
4105
4106 if (pRenderHal)
4107 {
4108 pOsInterface = pRenderHal->pOsInterface;
4109 pStateHeap = pRenderHal->pStateHeap;
4110 }
4111
4112 // Validate state
4113 if (pRenderHal == nullptr || // invalid Hw state
4114 pOsInterface == nullptr || // invalid OS interface
4115 pStateHeap == nullptr || // invalid State Heap
4116 pStateHeap->pMediaStates == nullptr || // invalid Media State Array
4117 pStateHeap->bGshLocked == false || // State Heap not locked
4118 pRenderHal->StateHeapSettings.iMediaStateHeaps == 0)
4119 {
4120 MHW_RENDERHAL_ASSERTMESSAGE("Invalid state.");
4121 goto finish;
4122 }
4123
4124 // Refresh sync tag for all media states
4125 pRenderHal->pfnRefreshSync(pRenderHal);
4126
4127 // Get next media state and tag to check
4128 pCurMediaState = &pStateHeap->pMediaStates[pStateHeap->iNextMediaState];
4129
4130 // The code below is unlikely to be executed - unless all media states are in use
4131 // If this ever happens, please consider increasing the number of media states
4132 if (pCurMediaState->bBusy)
4133 {
4134 dwWaitTag = pCurMediaState->dwSyncTag;
4135
4136 // Wait for Batch Buffer complete event OR timeout
4137 for (dwWaitMs = pRenderHal->dwTimeoutMs; dwWaitMs > 0; dwWaitMs--)
4138 {
4139 //MOS_GPU_CONTEXT_RENDER or MOS_GPU_CONTEXT_RENDER3
4140 pOsInterface->pfnWaitForBBCompleteNotifyEvent(pOsInterface, pOsInterface->CurrentGpuContextOrdinal, RENDERHAL_EVENT_TIMEOUT_MS);
4141
4142 // Wait for tag (end of command buffer, start of next command buffer)
4143 if ((int32_t)(pStateHeap->pSync[0] - dwWaitTag) > 0) break;
4144 }
4145
4146 // Timeout
4147 if (dwWaitMs == 0)
4148 {
4149 MHW_RENDERHAL_ASSERTMESSAGE("Timeout for waiting free media state.");
4150 pStateHeap->pCurMediaState = pCurMediaState = nullptr;
4151 goto finish;
4152 }
4153 }
4154
4155 // Setup the Current Media State
4156 pStateHeap->pCurMediaState = pCurMediaState;
4157 pStateHeap->iCurMediaState = pStateHeap->iNextMediaState;
4158
4159 // Point to the next media state
4160 pStateHeap->iNextMediaState = (pStateHeap->iNextMediaState + 1) %
4161 (pRenderHal->StateHeapSettings.iMediaStateHeaps);
4162
4163 // Reset media state
4164 pCurMediaState->dwSyncTag = pStateHeap->dwNextTag;
4165 pCurMediaState->dwSyncCount = 0;
4166 pCurMediaState->iCurbeOffset = 0;
4167 MOS_FillMemory( pCurMediaState->piAllocation,
4168 pRenderHal->StateHeapSettings.iMediaIDs * sizeof(int32_t),
4169 -1);
4170
4171 // Reset HW allocations
4172 pRenderHal->iChromaKeyCount = 0;
4173 for (i = 0; i < pRenderHal->iMaxPalettes; i++)
4174 {
4175 pRenderHal->Palette[i].iNumEntries = 0;
4176 }
4177
4178 // Zero Memory start time and end time
4179 pCurrentPtr = pStateHeap->pGshBuffer + // GSH base
4180 pStateHeap->pCurMediaState->dwOffset +
4181 pStateHeap->dwOffsetStartTime;
4182
4183 if(pCurrentPtr)
4184 {
4185 // Start time
4186 *((uint64_t*)pCurrentPtr) = 0;
4187 }
4188
4189 // End time
4190 pCurrentPtr += pStateHeap->dwStartTimeSize;
4191 *((uint64_t*)pCurrentPtr) = 0;
4192
4193 // Component ID
4194 pCurrentPtr += pStateHeap->dwEndTimeSize;
4195 *((RENDERHAL_COMPONENT *)pCurrentPtr) = componentID;
4196
4197 finish:
4198 return pCurMediaState;
4199 }
4200
4201 //!
4202 //! \brief Destroy
4203 //! \details Free all resources allocated by RenderHal
4204 //! \param PRENDERHAL_INTERFACE pRenderHal
4205 //! \return void
4206 //!
RenderHal_Destroy(PRENDERHAL_INTERFACE pRenderHal)4207 MOS_STATUS RenderHal_Destroy(PRENDERHAL_INTERFACE pRenderHal)
4208 {
4209 MOS_STATUS eStatus;
4210
4211 //------------------------------------------------
4212 MHW_RENDERHAL_CHK_NULL(pRenderHal);
4213 MHW_RENDERHAL_CHK_NULL(pRenderHal->pOsInterface);
4214 //------------------------------------------------
4215 eStatus = MOS_STATUS_UNKNOWN;
4216
4217 // Free State Heaps
4218 eStatus = (MOS_STATUS)(pRenderHal->pfnFreeStateHeaps(pRenderHal));
4219 if (eStatus != MOS_STATUS_SUCCESS)
4220 {
4221 MHW_RENDERHAL_ASSERTMESSAGE("Failed to free state heeps, eStatus:%d.\n", eStatus);
4222 }
4223
4224 // Destroy MHW Render Interface
4225 if (pRenderHal->pMhwRenderInterface)
4226 {
4227 MOS_Delete(pRenderHal->pMhwRenderInterface);
4228 pRenderHal->pMhwRenderInterface = nullptr;
4229 }
4230
4231 // Destroy MHW MI Interface
4232 if (pRenderHal->pMhwMiInterface)
4233 {
4234 MOS_Delete(pRenderHal->pMhwMiInterface);
4235 pRenderHal->pMhwMiInterface = nullptr;
4236 }
4237
4238 // Release pBatchBufferMemPool
4239 if (pRenderHal->pBatchBufferMemPool)
4240 {
4241 MOS_Delete(pRenderHal->pBatchBufferMemPool);
4242 pRenderHal->pBatchBufferMemPool = nullptr;
4243 }
4244
4245 // Release PredicationBuffer
4246 if (!Mos_ResourceIsNull(&pRenderHal->PredicationBuffer))
4247 {
4248 pRenderHal->pOsInterface->pfnFreeResource(
4249 pRenderHal->pOsInterface,
4250 &pRenderHal->PredicationBuffer);
4251 }
4252
4253 // Destruct Platform Interface
4254 if (pRenderHal->pRenderHalPltInterface)
4255 {
4256 MOS_Delete(pRenderHal->pRenderHalPltInterface);
4257 pRenderHal->pRenderHalPltInterface = nullptr;
4258 }
4259
4260 if (pRenderHal->pPerfProfiler)
4261 {
4262 MediaPerfProfiler::Destroy(pRenderHal->pPerfProfiler, (void*)pRenderHal, pRenderHal->pOsInterface);
4263 pRenderHal->pPerfProfiler = nullptr;
4264 }
4265
4266 // Free multiple trackers
4267 pRenderHal->trackerProducer.~FrameTrackerProducer();
4268
4269 // Free Debug Surface
4270 RenderHal_FreeDebugSurface(pRenderHal);
4271
4272 eStatus = MOS_STATUS_SUCCESS;
4273
4274 finish:
4275 return eStatus;
4276 }
4277
4278 //!
4279 //! \brief Load Curbe Data
4280 //! \details Allocates and load CURBE data for Media
4281 //! \param PRENDERHAL_INTERFACE pRenderHal
4282 //! [in] Pointer to RenderHal Interface structure
4283 //! \param PRENDERHAL_MEDIA_STATE pCurMediaState
4284 //! [out] Pointer to Current Media State structure
4285 //! \param void *pData
4286 //! [in] Pointer to Data
4287 //! \param int32_t iSize
4288 //! [in] Number of bytes to allocate
4289 //! \return int32_t
4290 //! Offset of the CURBE block from CURBE base (in bytes)
4291 //! -1 if no CURBE space available in GSH
4292 //!
RenderHal_LoadCurbeData(PRENDERHAL_INTERFACE pRenderHal,PRENDERHAL_MEDIA_STATE pCurMediaState,void * pData,int32_t iSize)4293 int32_t RenderHal_LoadCurbeData(
4294 PRENDERHAL_INTERFACE pRenderHal,
4295 PRENDERHAL_MEDIA_STATE pCurMediaState,
4296 void *pData,
4297 int32_t iSize)
4298 {
4299 int32_t iOffset;
4300 int32_t iCurbeSize;
4301 uint8_t *pPtrCurbe;
4302 PRENDERHAL_STATE_HEAP pStateHeap;
4303
4304 iOffset = -1;
4305 pStateHeap = (pRenderHal) ? pRenderHal->pStateHeap : nullptr;
4306 if (pStateHeap && pCurMediaState)
4307 {
4308 iCurbeSize = MOS_ALIGN_CEIL(iSize, pRenderHal->dwCurbeBlockAlign);
4309 if (pCurMediaState->iCurbeOffset + iCurbeSize <= (int)pStateHeap->dwSizeCurbe)
4310 {
4311 iOffset = pCurMediaState->iCurbeOffset;
4312 pCurMediaState->iCurbeOffset += iCurbeSize;
4313
4314 if (pData)
4315 {
4316 pPtrCurbe = pStateHeap->pGshBuffer + // GSH base
4317 pStateHeap->pCurMediaState->dwOffset + // Offset to media state
4318 pStateHeap->dwOffsetCurbe + // Offset to curbe area
4319 iOffset; // Current curbe offset
4320
4321 // Copy data to CURBE
4322 MOS_SecureMemcpy(pPtrCurbe, iSize, pData, iSize);
4323
4324 // Zero remaining CURBE (for buffer alignment)
4325 iCurbeSize -= iSize;
4326 if (iCurbeSize > 0)
4327 {
4328 MOS_ZeroMemory(pPtrCurbe + iSize, iCurbeSize);
4329 }
4330 }
4331 }
4332 }
4333
4334 return iOffset;
4335 }
4336
4337 //!
4338 //! \brief Send Curbe Load
4339 //! \details Send Curbe Load command
4340 //! \param PRENDERHAL_INTERFACE pRenderHal
4341 //! [in] Pointer to Hardware Interface Structure
4342 //! \param PMOS_COMMAND_BUFFER pCmdBuffer
4343 //! [in] Pointer to Command Buffer
4344 //! \return MOS_STATUS
4345 //!
RenderHal_SendCurbeLoad(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer)4346 MOS_STATUS RenderHal_SendCurbeLoad(
4347 PRENDERHAL_INTERFACE pRenderHal,
4348 PMOS_COMMAND_BUFFER pCmdBuffer)
4349 {
4350 MHW_CURBE_LOAD_PARAMS CurbeLoadParams;
4351 PRENDERHAL_STATE_HEAP pStateHeap;
4352 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
4353 PMOS_INTERFACE pOsInterface = nullptr;
4354 MOS_CONTEXT *pOsContext = nullptr;
4355 MOS_OCA_BUFFER_HANDLE hOcaBuf = 0;
4356
4357 //-----------------------------------------
4358 MHW_RENDERHAL_CHK_NULL(pRenderHal);
4359 MHW_RENDERHAL_CHK_NULL(pCmdBuffer);
4360 MHW_RENDERHAL_CHK_NULL(pRenderHal->pStateHeap);
4361 MHW_RENDERHAL_CHK_NULL(pRenderHal->pMhwRenderInterface);
4362 MHW_RENDERHAL_CHK_NULL(pRenderHal->pStateHeap->pCurMediaState);
4363 MHW_RENDERHAL_CHK_NULL(pRenderHal->pOsInterface);
4364 MHW_RENDERHAL_CHK_NULL(pRenderHal->pOsInterface->pOsContext);
4365 //-----------------------------------------
4366
4367 eStatus = MOS_STATUS_SUCCESS;
4368 pStateHeap = pRenderHal->pStateHeap;
4369 pOsInterface = pRenderHal->pOsInterface;
4370 pOsContext = pOsInterface->pOsContext;
4371
4372 // CURBE size is in bytes
4373 if (pStateHeap->pCurMediaState->iCurbeOffset != 0)
4374 {
4375 CurbeLoadParams.pKernelState = nullptr;
4376 CurbeLoadParams.bOldInterface = false;
4377 CurbeLoadParams.dwCURBETotalDataLength = pStateHeap->pCurMediaState->iCurbeOffset;
4378 CurbeLoadParams.dwCURBEDataStartAddress = pStateHeap->pCurMediaState->dwOffset + pStateHeap->dwOffsetCurbe;
4379
4380 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwRenderInterface->AddMediaCurbeLoadCmd(pCmdBuffer, &CurbeLoadParams));
4381
4382 HalOcaInterface::OnIndirectState(*pCmdBuffer, *pOsContext,pRenderHal->StateBaseAddressParams.presDynamicState,
4383 CurbeLoadParams.dwCURBEDataStartAddress, false, CurbeLoadParams.dwCURBETotalDataLength);
4384 }
4385
4386 finish:
4387 return eStatus;
4388 }
4389
RenderHal_SendMediaIdLoad(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer)4390 MOS_STATUS RenderHal_SendMediaIdLoad(
4391 PRENDERHAL_INTERFACE pRenderHal,
4392 PMOS_COMMAND_BUFFER pCmdBuffer)
4393 {
4394 MHW_ID_LOAD_PARAMS IdLoadParams;
4395 PRENDERHAL_STATE_HEAP pStateHeap;
4396 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
4397 PMOS_INTERFACE pOsInterface = nullptr;
4398 MOS_CONTEXT *pOsContext = nullptr;
4399 MOS_OCA_BUFFER_HANDLE hOcaBuf = 0;
4400
4401 //-----------------------------------------
4402 MHW_RENDERHAL_CHK_NULL(pRenderHal);
4403 MHW_RENDERHAL_CHK_NULL(pCmdBuffer);
4404 MHW_RENDERHAL_CHK_NULL(pRenderHal->pStateHeap);
4405 MHW_RENDERHAL_CHK_NULL(pRenderHal->pStateHeap->pCurMediaState);
4406 MHW_RENDERHAL_CHK_NULL(pRenderHal->pMhwRenderInterface);
4407 MHW_RENDERHAL_CHK_NULL(pRenderHal->pOsInterface);
4408 MHW_RENDERHAL_CHK_NULL(pRenderHal->pOsInterface->pOsContext);
4409 //-----------------------------------------
4410
4411 eStatus = MOS_STATUS_SUCCESS;
4412 pStateHeap = pRenderHal->pStateHeap;
4413 pOsInterface = pRenderHal->pOsInterface;
4414 pOsContext = pOsInterface->pOsContext;
4415
4416 IdLoadParams.pKernelState = nullptr;
4417 IdLoadParams.dwInterfaceDescriptorStartOffset = pStateHeap->pCurMediaState->dwOffset + pStateHeap->dwOffsetMediaID;
4418 IdLoadParams.dwInterfaceDescriptorLength = pRenderHal->StateHeapSettings.iMediaIDs * pStateHeap->dwSizeMediaID;
4419
4420 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwRenderInterface->AddMediaIDLoadCmd(pCmdBuffer, &IdLoadParams));
4421
4422 HalOcaInterface::OnIndirectState(*pCmdBuffer, *pOsContext, pRenderHal->StateBaseAddressParams.presDynamicState,
4423 IdLoadParams.dwInterfaceDescriptorStartOffset, false, IdLoadParams.dwInterfaceDescriptorLength);
4424
4425 finish:
4426 return eStatus;
4427 }
4428
4429 //!
4430 //! \brief Send Chroma Key
4431 //! \details Sends Chroma Key
4432 //! \param PRENDERHAL_INTERFACE pRenderHal
4433 //! [in] Pointer to Hardware Interface Structure
4434 //! \param PMOS_COMMAND_BUFFER pCmdBuffer
4435 //! [in] Pointer to Command Buffer
4436 //! \return MOS_STATUS
4437 //!
RenderHal_SendChromaKey(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer)4438 MOS_STATUS RenderHal_SendChromaKey(
4439 PRENDERHAL_INTERFACE pRenderHal,
4440 PMOS_COMMAND_BUFFER pCmdBuffer)
4441 {
4442 MhwRenderInterface *pMhwRender;
4443 PMHW_CHROMAKEY_PARAMS pChromaKeyParams;
4444 int32_t i;
4445 MOS_STATUS eStatus;
4446
4447 //----------------------------------
4448 MHW_RENDERHAL_CHK_NULL(pRenderHal);
4449 MHW_RENDERHAL_CHK_NULL(pCmdBuffer);
4450 MHW_RENDERHAL_CHK_NULL(pRenderHal->pMhwRenderInterface);
4451 //----------------------------------
4452
4453 eStatus = MOS_STATUS_SUCCESS;
4454 pMhwRender = pRenderHal->pMhwRenderInterface;
4455
4456 // Send Chroma Keys in use
4457 pChromaKeyParams = pRenderHal->ChromaKey;
4458 for (i = pRenderHal->iChromaKeyCount; i > 0; i--, pChromaKeyParams++)
4459 {
4460 MHW_RENDERHAL_CHK_STATUS(pMhwRender->AddChromaKeyCmd(pCmdBuffer, pChromaKeyParams));
4461 }
4462
4463 finish:
4464 return eStatus;
4465 }
4466
4467 //!
4468 //! \brief Send Palette
4469 //! \details Sends Palette
4470 //! \param PRENDERHAL_INTERFACE pRenderHal
4471 //! [in] Pointer to Hardware Interface Structure
4472 //! \param PMOS_COMMAND_BUFFER pCmdBuffer
4473 //! [in] Pointer to Command Buffer
4474 //! \return MOS_STATUS
4475 //!
RenderHal_SendPalette(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer)4476 MOS_STATUS RenderHal_SendPalette(
4477 PRENDERHAL_INTERFACE pRenderHal,
4478 PMOS_COMMAND_BUFFER pCmdBuffer)
4479 {
4480 MhwRenderInterface *pMhwRender;
4481 PMHW_PALETTE_PARAMS pPaletteLoadParams;
4482 int32_t i;
4483 MOS_STATUS eStatus;
4484
4485 //-----------------------------------------
4486 MHW_RENDERHAL_CHK_NULL(pRenderHal);
4487 MHW_RENDERHAL_CHK_NULL(pCmdBuffer);
4488 MHW_RENDERHAL_CHK_NULL(pRenderHal->pMhwRenderInterface);
4489 //-----------------------------------------
4490
4491 eStatus = MOS_STATUS_SUCCESS;
4492 pMhwRender = pRenderHal->pMhwRenderInterface;
4493
4494 // Send Palettes in use
4495 pPaletteLoadParams = pRenderHal->Palette;
4496 for (i = pRenderHal->iMaxPalettes; i > 0; i--, pPaletteLoadParams++)
4497 {
4498 if (pPaletteLoadParams->iNumEntries > 0)
4499 {
4500 MHW_RENDERHAL_CHK_STATUS(pMhwRender->AddPaletteLoadCmd(pCmdBuffer, pPaletteLoadParams));
4501 }
4502 }
4503
4504 finish:
4505 return eStatus;
4506 }
4507
4508 //!
4509 //! \brief Reset RenderHal States
4510 //! \details Reset RenderHal States in preparation for a new command buffer
4511 //! \param PRENDERHAL_INTERFACE pRenderHal
4512 //! [in] Pointer to RenderHal Interface Structure
4513 //! \return MOS_STATUS
4514 //!
RenderHal_Reset(PRENDERHAL_INTERFACE pRenderHal)4515 MOS_STATUS RenderHal_Reset(
4516 PRENDERHAL_INTERFACE pRenderHal)
4517 {
4518 PMOS_INTERFACE pOsInterface;
4519 PRENDERHAL_STATE_HEAP pStateHeap;
4520 MOS_STATUS eStatus;
4521
4522 //----------------------------------
4523 MHW_RENDERHAL_CHK_NULL(pRenderHal);
4524 MHW_RENDERHAL_CHK_NULL(pRenderHal->pOsInterface);
4525 MHW_RENDERHAL_CHK_NULL(pRenderHal->pStateHeap);
4526 //----------------------------------
4527
4528 eStatus = MOS_STATUS_SUCCESS;
4529 pOsInterface = pRenderHal->pOsInterface;
4530 pStateHeap = pRenderHal->pStateHeap;
4531
4532 MHW_RENDERHAL_CHK_STATUS(pOsInterface->pfnRegisterResource(pOsInterface,
4533 &pStateHeap->GshOsResource,
4534 true,
4535 true));
4536
4537 MHW_RENDERHAL_CHK_STATUS(pOsInterface->pfnRegisterResource(pOsInterface,
4538 &pStateHeap->IshOsResource,
4539 true,
4540 true));
4541
4542 // Reset Slice Shutdown Mode
4543 pRenderHal->bRequestSingleSlice = false;
4544 pRenderHal->PowerOption.nSlice = 0;
4545 pRenderHal->PowerOption.nEU = 0;
4546 pRenderHal->PowerOption.nSubSlice = 0;
4547
4548 finish:
4549 return eStatus;
4550 }
4551
4552 //!
4553 //! \brief Assign Ssh Instance
4554 //! \details Get a pointer to the next available SSH Buffer Instance in SSH,
4555 //! Reset SSH allocations
4556 //! \param PRENDERHAL_INTERFACE pRenderHal
4557 //! [in] Pointer to RenderHal Interface Structure
4558 //! \return MOS_STATUS
4559 //! MOS_STATUS_SUCCESS if succeded, MOS_STATUS_UNKOWN otherwise
4560 //!
RenderHal_AssignSshInstance(PRENDERHAL_INTERFACE pRenderHal)4561 MOS_STATUS RenderHal_AssignSshInstance(
4562 PRENDERHAL_INTERFACE pRenderHal)
4563 {
4564 MOS_STATUS eStatus;
4565 PRENDERHAL_STATE_HEAP pStateHeap;
4566
4567 //-----------------------------------------
4568 MHW_RENDERHAL_CHK_NULL(pRenderHal);
4569 MHW_RENDERHAL_CHK_NULL(pRenderHal->pStateHeap);
4570 //-----------------------------------------
4571
4572 eStatus = MOS_STATUS_SUCCESS;
4573 pStateHeap = pRenderHal->pStateHeap;
4574
4575 // Init SSH Params
4576 if (pStateHeap)
4577 {
4578 pStateHeap->iCurrentBindingTable = 0;
4579 pStateHeap->iCurrentSurfaceState = 0;
4580 }
4581 else
4582 {
4583 eStatus = MOS_STATUS_UNKNOWN;
4584 }
4585
4586 finish:
4587 return eStatus;
4588 }
4589
4590 //!
4591 //! \brief Adds predication attributes in command buffer
4592 //! \param PRENDERHAL_INTERFACE pRenderHal
4593 //! [in] Pointer to RenderHal Interface Structure
4594 //! \param PMOS_COMMAND_BUFFER pcmdBuffer
4595 //! [in] Pointer to Command Buffer
4596 //! \return MOS_STATUS
4597 //!
RenderHal_SendPredicationCommand(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer)4598 MOS_STATUS RenderHal_SendPredicationCommand(
4599 PRENDERHAL_INTERFACE pRenderHal,
4600 PMOS_COMMAND_BUFFER pCmdBuffer)
4601 {
4602 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
4603
4604 //-----------------------------------------
4605 MHW_RENDERHAL_CHK_NULL(pRenderHal);
4606 MHW_RENDERHAL_CHK_NULL(pRenderHal->pOsInterface);
4607 MHW_RENDERHAL_CHK_NULL(pRenderHal->pMhwMiInterface);
4608 MHW_RENDERHAL_CHK_NULL(pRenderHal->pMhwMiInterface->GetMmioRegisters());
4609 //-----------------------------------------
4610
4611 MHW_MI_CONDITIONAL_BATCH_BUFFER_END_PARAMS condBBEndParams;
4612 MOS_ZeroMemory(&condBBEndParams, sizeof(condBBEndParams));
4613
4614 MOS_SYNC_PARAMS syncParams;
4615 MOS_ZeroMemory(&syncParams, sizeof(syncParams));
4616 syncParams.uiSemaphoreCount = 1;
4617 // Currently only sync between VEBOX and 3D, also need to consider sync between Render Engine and 3D
4618 // low priority since current VP Predication test case does not cover this scenario.
4619 syncParams.GpuContext = MOS_GPU_CONTEXT_VEBOX;
4620 syncParams.presSyncResource = pRenderHal->PredicationParams.pPredicationResource;
4621 syncParams.bReadOnly = true;
4622 syncParams.bDisableDecodeSyncLock = false;
4623 syncParams.bDisableLockForTranscode = false;
4624
4625 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pOsInterface->pfnPerformOverlaySync(pRenderHal->pOsInterface, &syncParams));
4626 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pOsInterface->pfnResourceWait(pRenderHal->pOsInterface, &syncParams));
4627
4628 // This function is only support VEBox right now, since register returned by pMhwMiInterface->GetMmioRegisters() is for VEBox.
4629 // Keep implementation same between Render and VEBox engines - for Render it is highly inefficient
4630 // Skip current frame if presPredication is not equal to zero
4631 if (pRenderHal->PredicationParams.predicationNotEqualZero)
4632 {
4633 auto mmioRegistersRender = pRenderHal->pMhwMiInterface->GetMmioRegisters();
4634 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
4635 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
4636 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiFlushDwCmd(pCmdBuffer, &flushDwParams));
4637
4638 // load presPredication to general purpose register0
4639 MHW_MI_STORE_REGISTER_MEM_PARAMS loadRegisterMemParams;
4640 MOS_ZeroMemory(&loadRegisterMemParams, sizeof(loadRegisterMemParams));
4641 loadRegisterMemParams.presStoreBuffer = pRenderHal->PredicationParams.pPredicationResource;
4642 loadRegisterMemParams.dwOffset = (uint32_t)pRenderHal->PredicationParams.predicationResOffset;
4643 loadRegisterMemParams.dwRegister = mmioRegistersRender->generalPurposeRegister0LoOffset;
4644 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiLoadRegisterMemCmd(
4645 pCmdBuffer,
4646 &loadRegisterMemParams));
4647
4648 MHW_MI_LOAD_REGISTER_IMM_PARAMS loadRegisterImmParams;
4649 MOS_ZeroMemory(&loadRegisterImmParams, sizeof(loadRegisterImmParams));
4650 loadRegisterImmParams.dwData = 0;
4651 loadRegisterImmParams.dwRegister = mmioRegistersRender->generalPurposeRegister0HiOffset;
4652 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiLoadRegisterImmCmd(
4653 pCmdBuffer,
4654 &loadRegisterImmParams));
4655
4656 // load 0 to general purpose register4
4657 MOS_ZeroMemory(&loadRegisterImmParams, sizeof(loadRegisterImmParams));
4658 loadRegisterImmParams.dwData = 0;
4659 loadRegisterImmParams.dwRegister = mmioRegistersRender->generalPurposeRegister4LoOffset;
4660 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiLoadRegisterImmCmd(
4661 pCmdBuffer,
4662 &loadRegisterImmParams));
4663
4664 MOS_ZeroMemory(&loadRegisterImmParams, sizeof(loadRegisterImmParams));
4665 loadRegisterImmParams.dwData = 0;
4666 loadRegisterImmParams.dwRegister = mmioRegistersRender->generalPurposeRegister4HiOffset;
4667 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiLoadRegisterImmCmd(
4668 pCmdBuffer,
4669 &loadRegisterImmParams));
4670
4671 //perform the add operation
4672 MHW_MI_MATH_PARAMS miMathParams;
4673 MHW_MI_ALU_PARAMS miAluParams[4];
4674 MOS_ZeroMemory(&miMathParams, sizeof(miMathParams));
4675 MOS_ZeroMemory(&miAluParams, sizeof(miAluParams));
4676 // load srcA, reg0
4677 miAluParams[0].AluOpcode = MHW_MI_ALU_LOAD;
4678 miAluParams[0].Operand1 = MHW_MI_ALU_SRCA;
4679 miAluParams[0].Operand2 = MHW_MI_ALU_GPREG0;
4680 // load srcB, reg4
4681 miAluParams[1].AluOpcode = MHW_MI_ALU_LOAD;
4682 miAluParams[1].Operand1 = MHW_MI_ALU_SRCB;
4683 miAluParams[1].Operand2 = MHW_MI_ALU_GPREG4;
4684 // add srcA, srcB
4685 miAluParams[2].AluOpcode = MHW_MI_ALU_ADD;
4686 miAluParams[2].Operand1 = MHW_MI_ALU_SRCB;
4687 miAluParams[2].Operand2 = MHW_MI_ALU_GPREG4;
4688 // store reg0, ZF
4689 miAluParams[3].AluOpcode = MHW_MI_ALU_STORE;
4690 miAluParams[3].Operand1 = MHW_MI_ALU_GPREG0;
4691 miAluParams[3].Operand2 = MHW_MI_ALU_ZF;
4692 miMathParams.pAluPayload = miAluParams;
4693 miMathParams.dwNumAluParams = 4; // four ALU commands needed for this substract opertaion. see following ALU commands.
4694 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiMathCmd(
4695 pCmdBuffer,
4696 &miMathParams));
4697
4698 // if zero, the zero flag will be 0xFFFFFFFF, else zero flag will be 0x0.
4699 MHW_MI_STORE_REGISTER_MEM_PARAMS storeRegParams;
4700 MOS_ZeroMemory(&storeRegParams, sizeof(storeRegParams));
4701 storeRegParams.presStoreBuffer = &pRenderHal->PredicationBuffer;
4702 storeRegParams.dwOffset = 0x10;
4703 storeRegParams.dwRegister = mmioRegistersRender->generalPurposeRegister0LoOffset;
4704 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiStoreRegisterMemCmd(
4705 pCmdBuffer,
4706 &storeRegParams));
4707
4708 // Programming of 4 dummy MI_STORE_DATA_IMM commands prior to programming of MiConditionalBatchBufferEnd
4709 MHW_MI_STORE_DATA_PARAMS dataParams;
4710 MOS_ZeroMemory(&dataParams, sizeof(dataParams));
4711 dataParams.pOsResource = &pRenderHal->PredicationBuffer;
4712 dataParams.dwValue = 1;
4713 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiStoreDataImmCmd(
4714 pCmdBuffer,
4715 &dataParams));
4716
4717 dataParams.dwValue = 2;
4718 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiStoreDataImmCmd(
4719 pCmdBuffer,
4720 &dataParams));
4721
4722 dataParams.dwValue = 3;
4723 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiStoreDataImmCmd(
4724 pCmdBuffer,
4725 &dataParams));
4726
4727 dataParams.dwValue = 4;
4728 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiStoreDataImmCmd(
4729 pCmdBuffer,
4730 &dataParams));
4731
4732 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
4733 flushDwParams.postSyncOperation = 1;
4734 flushDwParams.pOsResource = &pRenderHal->PredicationBuffer;
4735 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiFlushDwCmd(pCmdBuffer, &flushDwParams));
4736
4737 condBBEndParams.presSemaphoreBuffer = &pRenderHal->PredicationBuffer;
4738 condBBEndParams.dwOffset = 0x10;
4739 condBBEndParams.dwValue = 0;
4740 condBBEndParams.bDisableCompareMask = true;
4741 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiConditionalBatchBufferEndCmd(
4742 pCmdBuffer,
4743 &condBBEndParams));
4744
4745 pRenderHal->PredicationParams.ptempPredicationBuffer = &pRenderHal->PredicationBuffer;
4746 }
4747 else
4748 {
4749 auto mmioRegistersRender = pRenderHal->pMhwMiInterface->GetMmioRegisters();
4750
4751 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
4752 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
4753 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiFlushDwCmd(pCmdBuffer, &flushDwParams));
4754
4755 // load presPredication to general purpose register0
4756 MHW_MI_STORE_REGISTER_MEM_PARAMS loadRegisterMemParams;
4757 MOS_ZeroMemory(&loadRegisterMemParams, sizeof(loadRegisterMemParams));
4758 loadRegisterMemParams.presStoreBuffer = pRenderHal->PredicationParams.pPredicationResource;
4759 loadRegisterMemParams.dwOffset = (uint32_t)pRenderHal->PredicationParams.predicationResOffset;
4760 loadRegisterMemParams.dwRegister = mmioRegistersRender->generalPurposeRegister0LoOffset;
4761 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiLoadRegisterMemCmd(
4762 pCmdBuffer,
4763 &loadRegisterMemParams));
4764
4765 // if zero, the zero flag will be 0xFFFFFFFF, else zero flag will be 0x0.
4766 MHW_MI_STORE_REGISTER_MEM_PARAMS storeRegParams;
4767 MOS_ZeroMemory(&storeRegParams, sizeof(storeRegParams));
4768 storeRegParams.presStoreBuffer = &pRenderHal->PredicationBuffer;
4769 storeRegParams.dwOffset = 0x10;
4770 storeRegParams.dwRegister = mmioRegistersRender->generalPurposeRegister0LoOffset;
4771 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiStoreRegisterMemCmd(
4772 pCmdBuffer,
4773 &storeRegParams));
4774
4775 // Programming of 4 dummy MI_STORE_DATA_IMM commands prior to programming of MiConditionalBatchBufferEnd
4776 MHW_MI_STORE_DATA_PARAMS dataParams;
4777 MOS_ZeroMemory(&dataParams, sizeof(dataParams));
4778 dataParams.pOsResource = &pRenderHal->PredicationBuffer;
4779 dataParams.dwValue = 1;
4780 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiStoreDataImmCmd(
4781 pCmdBuffer,
4782 &dataParams));
4783
4784 dataParams.dwValue = 2;
4785 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiStoreDataImmCmd(
4786 pCmdBuffer,
4787 &dataParams));
4788
4789 dataParams.dwValue = 3;
4790 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiStoreDataImmCmd(
4791 pCmdBuffer,
4792 &dataParams));
4793
4794 dataParams.dwValue = 4;
4795 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiStoreDataImmCmd(
4796 pCmdBuffer,
4797 &dataParams));
4798
4799 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
4800 flushDwParams.postSyncOperation = 1;
4801 flushDwParams.pOsResource = &pRenderHal->PredicationBuffer;
4802 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiFlushDwCmd(pCmdBuffer, &flushDwParams));
4803
4804 // Skip current frame if presPredication is equal to zero
4805 condBBEndParams.presSemaphoreBuffer = &pRenderHal->PredicationBuffer;
4806 condBBEndParams.dwOffset = 0x10;
4807 condBBEndParams.bDisableCompareMask = true;
4808 condBBEndParams.dwValue = 0;
4809 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiConditionalBatchBufferEndCmd(
4810 pCmdBuffer,
4811 &condBBEndParams));
4812 }
4813
4814 finish:
4815 return eStatus;
4816 }
4817
4818 //!
4819 //! \brief Adds marker attributes in command buffer
4820 //! \param PRENDERHAL_INTERFACE pRenderHal
4821 //! [in] Pointer to RenderHal Interface Structure
4822 //! \param PMOS_COMMAND_BUFFER pcmdBuffer
4823 //! [in] Pointer to Command Buffer
4824 //! \param bool isRender
4825 //! [in] Flag of Render Engine
4826 //! \return MOS_STATUS
4827 //!
RenderHal_SendMarkerCommand(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER cmdBuffer,bool isRender)4828 MOS_STATUS RenderHal_SendMarkerCommand(
4829 PRENDERHAL_INTERFACE pRenderHal,
4830 PMOS_COMMAND_BUFFER cmdBuffer,
4831 bool isRender)
4832 {
4833 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
4834
4835 //-----------------------------------------
4836 MHW_RENDERHAL_CHK_NULL(pRenderHal);
4837 MHW_RENDERHAL_CHK_NULL(pRenderHal->pMhwMiInterface);
4838 //-----------------------------------------
4839
4840 if (isRender)
4841 {
4842 // Send pipe_control to get the timestamp
4843 MHW_PIPE_CONTROL_PARAMS pipeControlParams;
4844 MOS_ZeroMemory(&pipeControlParams, sizeof(pipeControlParams));
4845 pipeControlParams.presDest = pRenderHal->SetMarkerParams.pSetMarkerResource;
4846 pipeControlParams.dwResourceOffset = 0;
4847 pipeControlParams.dwPostSyncOp = MHW_FLUSH_WRITE_TIMESTAMP_REG;
4848 pipeControlParams.dwFlushMode = MHW_FLUSH_WRITE_CACHE;
4849
4850 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddPipeControl(cmdBuffer, NULL, &pipeControlParams));
4851 }
4852 else
4853 {
4854 // Send flush_dw to get the timestamp
4855 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
4856 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
4857 flushDwParams.pOsResource = pRenderHal->SetMarkerParams.pSetMarkerResource;
4858 flushDwParams.dwResourceOffset = 0;
4859 flushDwParams.postSyncOperation = MHW_FLUSH_WRITE_TIMESTAMP_REG;
4860 flushDwParams.bQWordEnable = 1;
4861
4862 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwMiInterface->AddMiFlushDwCmd(cmdBuffer, &flushDwParams));
4863 }
4864
4865 finish:
4866 return eStatus;
4867 }
4868
4869 //!
4870 //! \brief Initializes command buffer attributes and inserts prolog
4871 //! \param PRENDERHAL_INTERFACE pRenderHal
4872 //! [in] Pointer to RenderHal Interface Structure
4873 //! \param PMOS_COMMAND_BUFFER pCmdBuffer
4874 //! [in] Pointer to Command Buffer
4875 //! \param PRENDERHAL_GENERIC_PROLOG_PARAMS pGenericPrologParam
4876 //! [in] Pointer to MHW generic prolog parameters
4877 //! \return MOS_STATUS
4878 //!
RenderHal_InitCommandBuffer(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer,PRENDERHAL_GENERIC_PROLOG_PARAMS pGenericPrologParams)4879 MOS_STATUS RenderHal_InitCommandBuffer(
4880 PRENDERHAL_INTERFACE pRenderHal,
4881 PMOS_COMMAND_BUFFER pCmdBuffer,
4882 PRENDERHAL_GENERIC_PROLOG_PARAMS pGenericPrologParams)
4883 {
4884 PMOS_INTERFACE pOsInterface;
4885 MHW_GENERIC_PROLOG_PARAMS genericPrologParams;
4886 MOS_STATUS eStatus;
4887 bool isRender;
4888
4889 //---------------------------------------------
4890 MHW_RENDERHAL_CHK_NULL(pRenderHal);
4891 MHW_RENDERHAL_CHK_NULL(pCmdBuffer);
4892 MHW_RENDERHAL_CHK_NULL(pRenderHal->pOsInterface);
4893 MHW_RENDERHAL_CHK_NULL(pRenderHal->pMhwMiInterface);
4894 MHW_RENDERHAL_CHK_NULL(pRenderHal->pMhwRenderInterface);
4895 MHW_RENDERHAL_CHK_NULL(pRenderHal->pRenderHalPltInterface);
4896 //---------------------------------------------
4897
4898 eStatus = MOS_STATUS_SUCCESS;
4899 pOsInterface = pRenderHal->pOsInterface;
4900
4901 // Send Start Marker command
4902 isRender = MOS_RCS_ENGINE_USED(pOsInterface->pfnGetGpuContext(pOsInterface));
4903 if (pRenderHal->SetMarkerParams.setMarkerEnabled)
4904 {
4905 MHW_RENDERHAL_CHK_STATUS(RenderHal_SendMarkerCommand(
4906 pRenderHal, pCmdBuffer, isRender));
4907 }
4908
4909 // Init Cmd Buffer
4910 #ifdef _MMC_SUPPORTED
4911 if (isRender)
4912 {
4913 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pRenderHalPltInterface->SetCompositePrologCmd(pRenderHal, pCmdBuffer));
4914 }
4915 #endif // _MMC_SUPPORTED
4916
4917 // Set indirect heap size - limits the size of the command buffer available for rendering
4918 MHW_RENDERHAL_CHK_STATUS(pOsInterface->pfnSetIndirectStateSize(pOsInterface, pRenderHal->dwIndirectHeapSize));
4919
4920 pCmdBuffer->Attributes.bIsMdfLoad = pRenderHal->IsMDFLoad;
4921 pCmdBuffer->Attributes.bTurboMode = pRenderHal->bTurboMode;
4922
4923 // Set power option status
4924 if (pRenderHal->pRenderHalPltInterface)
4925 {
4926 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pRenderHalPltInterface->SetPowerOptionStatus(pRenderHal, pCmdBuffer));
4927 }
4928
4929 // Preemption: Need to set UsesMediaPipeline, UsesGPGPUPipeline, NeedsMidBatchPreEmptionSupport in command buffer header
4930 // Use IsMDFLoad to distinguish MDF context from other Media Contexts
4931 pCmdBuffer->Attributes.bMediaPreemptionEnabled =
4932 (pRenderHal->bEnableGpgpuMidBatchPreEmption ||
4933 pRenderHal->bEnableGpgpuMidThreadPreEmption ||
4934 pRenderHal->pMhwRenderInterface->IsPreemptionEnabled());
4935
4936 if (pGenericPrologParams)
4937 {
4938 if (pGenericPrologParams->bEnableMediaFrameTracking)
4939 {
4940 MHW_RENDERHAL_CHK_NULL(pGenericPrologParams->presMediaFrameTrackingSurface);
4941 pCmdBuffer->Attributes.bEnableMediaFrameTracking = pGenericPrologParams->bEnableMediaFrameTracking;
4942 pCmdBuffer->Attributes.dwMediaFrameTrackingTag = pGenericPrologParams->dwMediaFrameTrackingTag;
4943 pCmdBuffer->Attributes.dwMediaFrameTrackingAddrOffset = pGenericPrologParams->dwMediaFrameTrackingAddrOffset;
4944 pCmdBuffer->Attributes.resMediaFrameTrackingSurface = pGenericPrologParams->presMediaFrameTrackingSurface;
4945 }
4946 else
4947 {
4948 pCmdBuffer->Attributes.bEnableMediaFrameTracking = false;
4949 }
4950 }
4951
4952 // Check if Override is needed
4953 if (pRenderHal->pRenderHalPltInterface)
4954 {
4955 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pRenderHalPltInterface->IsOvrdNeeded(pRenderHal, pCmdBuffer, pGenericPrologParams));
4956 }
4957
4958 MOS_ZeroMemory(&genericPrologParams, sizeof(genericPrologParams));
4959 genericPrologParams.pOsInterface = pRenderHal->pOsInterface;
4960 genericPrologParams.pvMiInterface = pRenderHal->pMhwMiInterface;
4961 genericPrologParams.bMmcEnabled = pGenericPrologParams ? pGenericPrologParams->bMmcEnabled : false;
4962 MHW_RENDERHAL_CHK_STATUS(Mhw_SendGenericPrologCmd(pCmdBuffer, &genericPrologParams));
4963
4964 // Send predication command
4965 if (pRenderHal->PredicationParams.predicationEnabled)
4966 {
4967 MHW_RENDERHAL_CHK_STATUS(RenderHal_SendPredicationCommand(pRenderHal, pCmdBuffer));
4968 }
4969
4970 finish:
4971 return eStatus;
4972 }
4973
4974 //!
4975 //! \brief Send Sync Tag
4976 //! \details Sends Synchronization Tags
4977 //! \param PRENDERHAL_INTERFACE pRenderHal
4978 //! [in] Pointer to RenderHal Interface Structure
4979 //! \param PMOS_COMMAND_BUFFER pCmdBuffer
4980 //! [in] Pointer to Command Buffer
4981 //! \return MOS_STATUS
4982 //!
RenderHal_SendSyncTag(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer)4983 MOS_STATUS RenderHal_SendSyncTag(
4984 PRENDERHAL_INTERFACE pRenderHal,
4985 PMOS_COMMAND_BUFFER pCmdBuffer)
4986 {
4987 PRENDERHAL_STATE_HEAP pStateHeap;
4988 MOS_STATUS eStatus;
4989 PMHW_MI_INTERFACE pMhwMiInterface;
4990 MHW_PIPE_CONTROL_PARAMS PipeCtl;
4991
4992 //-------------------------------------
4993 MHW_RENDERHAL_CHK_NULL(pRenderHal);
4994 MHW_RENDERHAL_CHK_NULL(pRenderHal->pMhwMiInterface);
4995 MHW_RENDERHAL_CHK_NULL(pRenderHal->pStateHeap);
4996 //-------------------------------------
4997
4998 pStateHeap = pRenderHal->pStateHeap;
4999 pMhwMiInterface = pRenderHal->pMhwMiInterface;
5000
5001 // Send PIPE_CONTROL Token
5002 // CMD_MI_FLUSH is disabled by default on GT, use PIPE_CONTROL
5003 // Requires a token and the actual pipe control command
5004 // Flush write caches
5005 PipeCtl = g_cRenderHal_InitPipeControlParams;
5006 PipeCtl.presDest = &pStateHeap->GshOsResource;
5007 PipeCtl.dwPostSyncOp = MHW_FLUSH_NOWRITE;
5008 PipeCtl.dwFlushMode = MHW_FLUSH_WRITE_CACHE;
5009 MHW_RENDERHAL_CHK_STATUS(pMhwMiInterface->AddPipeControl(pCmdBuffer, nullptr, &PipeCtl));
5010
5011 // Invalidate read-only caches and perform a post sync write
5012 PipeCtl = g_cRenderHal_InitPipeControlParams;
5013 PipeCtl.presDest = &pStateHeap->GshOsResource;
5014 PipeCtl.dwResourceOffset = pStateHeap->dwOffsetSync;
5015 PipeCtl.dwPostSyncOp = MHW_FLUSH_WRITE_IMMEDIATE_DATA;
5016 PipeCtl.dwFlushMode = MHW_FLUSH_READ_CACHE;
5017 PipeCtl.dwDataDW1 = pStateHeap->dwNextTag;
5018 MHW_RENDERHAL_CHK_STATUS(pMhwMiInterface->AddPipeControl(pCmdBuffer, nullptr, &PipeCtl));
5019
5020 finish:
5021 return eStatus;
5022 }
5023
RenderHal_SendSyncTagIndex(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer,int32_t iIndex)5024 MOS_STATUS RenderHal_SendSyncTagIndex(
5025 PRENDERHAL_INTERFACE pRenderHal,
5026 PMOS_COMMAND_BUFFER pCmdBuffer,
5027 int32_t iIndex)
5028 {
5029 PRENDERHAL_STATE_HEAP pStateHeap;
5030 MOS_STATUS eStatus;
5031 MHW_PIPE_CONTROL_PARAMS PipeCtl;
5032 PMHW_MI_INTERFACE pMhwMiInterface;
5033
5034 //-------------------------------------
5035 MHW_RENDERHAL_CHK_NULL(pRenderHal);
5036 MHW_RENDERHAL_CHK_NULL(pRenderHal->pMhwMiInterface);
5037 MHW_RENDERHAL_CHK_NULL(pRenderHal->pStateHeap);
5038 //-------------------------------------
5039
5040 pStateHeap = pRenderHal->pStateHeap;
5041 pMhwMiInterface = pRenderHal->pMhwMiInterface;
5042
5043 // Invalidate read-only caches and perform a post sync write
5044 PipeCtl = g_cRenderHal_InitPipeControlParams;
5045 PipeCtl.presDest = &pStateHeap->GshOsResource;
5046 PipeCtl.dwResourceOffset = pStateHeap->dwOffsetSync + iIndex * 8;
5047 PipeCtl.dwPostSyncOp = MHW_FLUSH_WRITE_IMMEDIATE_DATA;
5048 PipeCtl.dwFlushMode = MHW_FLUSH_READ_CACHE;
5049 PipeCtl.dwDataDW1 = pStateHeap->dwNextTag;
5050 MHW_RENDERHAL_CHK_STATUS(pMhwMiInterface->AddPipeControl(pCmdBuffer, nullptr, &PipeCtl));
5051
5052 finish:
5053 return eStatus;
5054 }
5055
5056 void RenderHal_SetupPrologParams(
5057 PRENDERHAL_INTERFACE renderHal,
5058 RENDERHAL_GENERIC_PROLOG_PARAMS *prologParams,
5059 PMOS_RESOURCE osResource,
5060 uint32_t offset,
5061 uint32_t tag);
5062
5063 //!
5064 //! \brief Initialize
5065 //! \details Initialize HW states
5066 //! \param PRENDERHAL_INTERFACE pRenderHal
5067 //! [in] Pointer to RenderHal Interface Structure
5068 //! \param PCRENDERHAL_SETTINGS pSettings
5069 //! [in] Pointer to Settings
5070 //! \return MOS_STATUS
5071 //! MOS_STATUS_SUCCESS if succeeded
5072 //! others if failed to allocate/initialize HW commands
5073 //!
RenderHal_Initialize(PRENDERHAL_INTERFACE pRenderHal,PRENDERHAL_SETTINGS pSettings)5074 MOS_STATUS RenderHal_Initialize(
5075 PRENDERHAL_INTERFACE pRenderHal,
5076 PRENDERHAL_SETTINGS pSettings)
5077 {
5078 MOS_STATUS eStatus;
5079 PMOS_INTERFACE pOsInterface;
5080 MHW_STATE_BASE_ADDR_PARAMS *pStateBaseParams;
5081 MOS_ALLOC_GFXRES_PARAMS AllocParams;
5082
5083 //------------------------------------------------
5084 MHW_RENDERHAL_CHK_NULL(pRenderHal);
5085 MHW_RENDERHAL_CHK_NULL(pRenderHal->pOsInterface);
5086 //------------------------------------------------
5087
5088 pOsInterface = pRenderHal->pOsInterface;
5089
5090 // Apply settings
5091 if (pSettings)
5092 {
5093 pRenderHal->StateHeapSettings.iMediaStateHeaps = pSettings->iMediaStates;
5094 }
5095
5096 // Apply SSH settings for the current platform
5097 pRenderHal->StateHeapSettings.iSurfaceStateHeaps =
5098 pRenderHal->StateHeapSettings.iMediaStateHeaps;
5099
5100 // Initialize MHW interfaces
5101 // Allocate and initialize state heaps (GSH, SSH, ISH)
5102 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pfnAllocateStateHeaps(pRenderHal, &pRenderHal->StateHeapSettings));
5103
5104 // If ASM debug is enabled, allocate debug resource
5105 MHW_RENDERHAL_CHK_STATUS(RenderHal_AllocateDebugSurface(pRenderHal));
5106
5107 // Allocate Predication buffer
5108 MOS_ZeroMemory(&AllocParams, sizeof(AllocParams));
5109 AllocParams.Type = MOS_GFXRES_BUFFER;
5110 AllocParams.TileType = MOS_TILE_LINEAR;
5111 AllocParams.Format = Format_Buffer;
5112 AllocParams.dwBytes = MHW_PAGE_SIZE;
5113 AllocParams.pBufName = "PredicationBuffer";
5114
5115 MHW_RENDERHAL_CHK_STATUS(pOsInterface->pfnAllocateResource(
5116 pOsInterface,
5117 &AllocParams,
5118 &pRenderHal->PredicationBuffer));
5119
5120 // Setup State Base Address command
5121 pStateBaseParams = &pRenderHal->StateBaseAddressParams;
5122 pStateBaseParams->presGeneralState = &pRenderHal->pStateHeap->GshOsResource;
5123 pStateBaseParams->dwGeneralStateSize = pRenderHal->pStateHeap->dwSizeGSH;
5124 pStateBaseParams->presDynamicState = &pRenderHal->pStateHeap->GshOsResource;
5125 pStateBaseParams->dwDynamicStateSize = pRenderHal->pStateHeap->dwSizeGSH;
5126 pStateBaseParams->bDynamicStateRenderTarget = false;
5127 pStateBaseParams->presIndirectObjectBuffer = &pRenderHal->pStateHeap->GshOsResource;
5128 pStateBaseParams->dwIndirectObjectBufferSize = pRenderHal->pStateHeap->dwSizeGSH;
5129 pStateBaseParams->presInstructionBuffer = &pRenderHal->pStateHeap->IshOsResource;
5130 pStateBaseParams->dwInstructionBufferSize = pRenderHal->pStateHeap->dwSizeISH;
5131
5132 if (!pRenderHal->pPerfProfiler)
5133 {
5134 pRenderHal->pPerfProfiler = MediaPerfProfiler::Instance();
5135 MHW_RENDERHAL_CHK_NULL(pRenderHal->pPerfProfiler);
5136
5137 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pPerfProfiler->Initialize((void*)pRenderHal, pOsInterface));
5138 }
5139
5140 new(&pRenderHal->trackerProducer) FrameTrackerProducer();
5141
5142 finish:
5143 return eStatus;
5144 }
5145
5146 //!
5147 //! \brief Send Rcs Status Tag
5148 //! \details Adds pipe control command in Command Buffer
5149 //! \param PRENDERHAL_INTERFACE pRenderHal
5150 //! [in] Pointer to RenderHal Interface Structure
5151 //! \param PMOS_COMMAND_BUFFER pCmdBuffer
5152 //! [in] Pointer to Command Buffer
5153 //! \return MOS_STATUS
5154 //! MOS_STATUS_SUCCESS if succeeded
5155 //! MOS_STATUS_UNKNOWN if failed to allocate/initialize HW commands
5156 //!
RenderHal_SendRcsStatusTag(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer)5157 MOS_STATUS RenderHal_SendRcsStatusTag(
5158 PRENDERHAL_INTERFACE pRenderHal,
5159 PMOS_COMMAND_BUFFER pCmdBuffer)
5160 {
5161 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
5162 PMOS_INTERFACE pOsInterface;
5163 PMHW_MI_INTERFACE pMhwMiInterface;
5164 MHW_PIPE_CONTROL_PARAMS PipeCtl;
5165 PMOS_RESOURCE osResource = nullptr;
5166
5167 //------------------------------------
5168 MHW_RENDERHAL_CHK_NULL(pRenderHal);
5169 MHW_RENDERHAL_CHK_NULL(pRenderHal->pOsInterface);
5170 MHW_RENDERHAL_CHK_NULL(pRenderHal->pMhwMiInterface);
5171 MHW_RENDERHAL_CHK_NULL(pCmdBuffer);
5172 //------------------------------------
5173
5174 pOsInterface = pRenderHal->pOsInterface;
5175 pMhwMiInterface = pRenderHal->pMhwMiInterface;
5176
5177 // Get the Os Resource
5178 MHW_RENDERHAL_CHK_STATUS(pOsInterface->pfnGetGpuStatusBufferResource(pOsInterface, osResource));
5179 MHW_RENDERHAL_CHK_NULL(osResource);
5180
5181 // Register the buffer
5182 MHW_RENDERHAL_CHK_STATUS(pOsInterface->pfnRegisterResource(pOsInterface, osResource, true, true));
5183
5184 // Issue pipe control to write GPU Status Tag
5185 PipeCtl = g_cRenderHal_InitPipeControlParams;
5186 PipeCtl.presDest = osResource;
5187 PipeCtl.dwResourceOffset = pOsInterface->pfnGetGpuStatusTagOffset(pOsInterface, pOsInterface->CurrentGpuContextOrdinal); //MOS_GPU_CONTEXT_RENDER or MOS_GPU_CONTEXT_RENDER3
5188 PipeCtl.dwDataDW1 = pOsInterface->pfnGetGpuStatusTag(pOsInterface, pOsInterface->CurrentGpuContextOrdinal);
5189 PipeCtl.dwPostSyncOp = MHW_FLUSH_WRITE_IMMEDIATE_DATA;
5190 PipeCtl.dwFlushMode = MHW_FLUSH_NONE;
5191 MHW_RENDERHAL_CHK_STATUS(pMhwMiInterface->AddPipeControl(pCmdBuffer, nullptr, &PipeCtl));
5192
5193 // Increment GPU Status Tag
5194 pOsInterface->pfnIncrementGpuStatusTag(pOsInterface, pOsInterface->CurrentGpuContextOrdinal);
5195
5196 finish:
5197 return eStatus;
5198 }
5199
5200 //!
5201 //! \brief Send CSC Coefficient surface
5202 //! \details Adds pipe control command in Command Buffer
5203 //! \param PRENDERHAL_INTERFACE pRenderHal
5204 //! [in] Pointer to RenderHal Interface Structure
5205 //! \param PMOS_COMMAND_BUFFER pCmdBuffer
5206 //! [in] Pointer to Command Buffer
5207 //! \param PMOS_RESOURCE presCscCoeff
5208 //! [in] Pointer to CSC Coefficient Surface
5209 //! \param Kdll_CacheEntry *pKernelEntry
5210 //! [in] Pointer to Kernel Entry
5211 //! \return MOS_STATUS
5212 //! MOS_STATUS_SUCCESS if succeeded
5213 //! MOS_STATUS_UNKNOWN if failed to allocate/initialize HW commands
5214 //!
RenderHal_SendCscCoeffSurface(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer,PMOS_RESOURCE presCscCoeff,Kdll_CacheEntry * pKernelEntry)5215 MOS_STATUS RenderHal_SendCscCoeffSurface(
5216 PRENDERHAL_INTERFACE pRenderHal,
5217 PMOS_COMMAND_BUFFER pCmdBuffer,
5218 PMOS_RESOURCE presCscCoeff,
5219 Kdll_CacheEntry *pKernelEntry)
5220 {
5221 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
5222 PMOS_INTERFACE pOsInterface;
5223 PMHW_MI_INTERFACE pMhwMiInterface;
5224 MHW_PIPE_CONTROL_PARAMS PipeCtl;
5225 MOS_SURFACE Surface;
5226 uint64_t *pTempCoeff;
5227 uint32_t dwLow;
5228 uint32_t dwHigh;
5229 uint32_t dwOffset;
5230 uint32_t dwCount;
5231 uint8_t uiPatchMatrixID;
5232
5233 //------------------------------------
5234 MHW_RENDERHAL_CHK_NULL(pRenderHal);
5235 MHW_RENDERHAL_CHK_NULL(pRenderHal->pOsInterface);
5236 MHW_RENDERHAL_CHK_NULL(pRenderHal->pMhwMiInterface);
5237 MHW_RENDERHAL_CHK_NULL(pCmdBuffer);
5238 MHW_RENDERHAL_CHK_NULL(presCscCoeff);
5239 MHW_RENDERHAL_CHK_NULL(pKernelEntry);
5240 MHW_RENDERHAL_CHK_NULL(pKernelEntry->pCscParams);
5241 //------------------------------------
5242
5243 pOsInterface = pRenderHal->pOsInterface;
5244 pMhwMiInterface = pRenderHal->pMhwMiInterface;
5245 dwOffset = 0;
5246 static_assert(
5247 (sizeof(pKernelEntry->pCscParams->Matrix[0].Coeff) % sizeof(uint64_t)) == 0,
5248 "Coeff array size must be multiple of 8");
5249 dwCount = sizeof(pKernelEntry->pCscParams->Matrix[0].Coeff) / (sizeof(uint64_t));
5250 MOS_ZeroMemory(&Surface, sizeof(Surface));
5251
5252 // Register the buffer
5253 MHW_RENDERHAL_CHK_STATUS(pOsInterface->pfnRegisterResource(pOsInterface, presCscCoeff, true, true));
5254 MHW_RENDERHAL_CHK_STATUS(pOsInterface->pfnGetResourceInfo(pOsInterface, presCscCoeff, &Surface));
5255
5256 PipeCtl = g_cRenderHal_InitPipeControlParams;
5257 PipeCtl.presDest = presCscCoeff;
5258 PipeCtl.dwPostSyncOp = MHW_FLUSH_WRITE_IMMEDIATE_DATA;
5259 PipeCtl.dwFlushMode = MHW_FLUSH_READ_CACHE;
5260
5261 for (uint32_t j = 0; j < pKernelEntry->pCscParams->PatchMatrixNum; j++)
5262 {
5263 uiPatchMatrixID = pKernelEntry->pCscParams->PatchMatrixID[j];
5264 pTempCoeff = (uint64_t *)pKernelEntry->pCscParams->Matrix[uiPatchMatrixID].Coeff;
5265
5266 // Issue pipe control to write CSC Coefficient Surface
5267 for (uint16_t i = 0; i < dwCount; i++, pTempCoeff++)
5268 {
5269 dwLow = (uint32_t)((*pTempCoeff) & 0xFFFFFFFF);
5270 dwHigh = (uint32_t)(((*pTempCoeff) >> 32) & 0xFFFFFFFF);
5271 PipeCtl.dwResourceOffset = dwOffset + sizeof(uint64_t) * i;
5272 PipeCtl.dwDataDW1 = dwLow;
5273 PipeCtl.dwDataDW2 = dwHigh;
5274
5275 MHW_RENDERHAL_CHK_STATUS(pMhwMiInterface->AddPipeControl(pCmdBuffer, nullptr, &PipeCtl));
5276 }
5277
5278 dwOffset += Surface.dwPitch;
5279 }
5280
5281 finish:
5282 return eStatus;
5283 }
5284
5285 //!
5286 //! \brief Issue command to write timestamp
5287 //! \param [in] pRenderHal
5288 //! \param [in] pCmdBuffer
5289 //! \param [in] bStartTime
5290 //! \return MOS_STATUS
5291 //!
5292 MOS_STATUS RenderHal_SendTimingData(
5293 PRENDERHAL_INTERFACE pRenderHal,
5294 PMOS_COMMAND_BUFFER pCmdBuffer,
5295 bool bStartTime);
5296
RenderHal_SendStateBaseAddress(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer)5297 MOS_STATUS RenderHal_SendStateBaseAddress(
5298 PRENDERHAL_INTERFACE pRenderHal,
5299 PMOS_COMMAND_BUFFER pCmdBuffer)
5300 {
5301 MhwRenderInterface *pMhwRender;
5302 MOS_STATUS eStatus;
5303
5304 MHW_RENDERHAL_CHK_NULL(pRenderHal);
5305 MHW_RENDERHAL_CHK_NULL(pCmdBuffer);
5306 MHW_RENDERHAL_CHK_NULL(pRenderHal->pMhwRenderInterface);
5307
5308 pMhwRender = pRenderHal->pMhwRenderInterface;
5309 eStatus = pMhwRender->AddStateBaseAddrCmd(pCmdBuffer,
5310 &pRenderHal->StateBaseAddressParams);
5311 finish:
5312 return eStatus;
5313 }
5314
5315 //!
5316 //! \brief Send Media States
5317 //! \details Send Media States
5318 //! \param PRENDERHAL_INTERFACE pRenderHal
5319 //! [in] Pointer to Hardware Interface Structure
5320 //! \param PMOS_COMMAND_BUFFER pCmdBuffer
5321 //! [in] Pointer to Command Buffer
5322 //! \param PRENDERHAL_GPGPU_WALKER_PARAMS pGpGpuWalkerParams
5323 //! [in] Pointer to GPGPU walker parameters
5324 //! \return MOS_STATUS
5325 //!
RenderHal_SendMediaStates(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer,PMHW_WALKER_PARAMS pWalkerParams,PMHW_GPGPU_WALKER_PARAMS pGpGpuWalkerParams)5326 MOS_STATUS RenderHal_SendMediaStates(
5327 PRENDERHAL_INTERFACE pRenderHal,
5328 PMOS_COMMAND_BUFFER pCmdBuffer,
5329 PMHW_WALKER_PARAMS pWalkerParams,
5330 PMHW_GPGPU_WALKER_PARAMS pGpGpuWalkerParams)
5331 {
5332 PMOS_INTERFACE pOsInterface = nullptr;
5333 MhwRenderInterface *pMhwRender = nullptr;
5334 PMHW_MI_INTERFACE pMhwMiInterface = nullptr;
5335 PRENDERHAL_STATE_HEAP pStateHeap = nullptr;
5336 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
5337 MHW_VFE_PARAMS *pVfeStateParams = nullptr;
5338 MOS_CONTEXT *pOsContext = nullptr;
5339 MHW_MI_LOAD_REGISTER_IMM_PARAMS loadRegisterImmParams = {};
5340 PMHW_MI_MMIOREGISTERS pMmioRegisters = nullptr;
5341 MOS_OCA_BUFFER_HANDLE hOcaBuf = 0;
5342
5343 //---------------------------------------
5344 MHW_RENDERHAL_CHK_NULL(pRenderHal);
5345 MHW_RENDERHAL_CHK_NULL(pRenderHal->pMhwRenderInterface);
5346 MHW_RENDERHAL_CHK_NULL(pRenderHal->pMhwMiInterface);
5347 MHW_RENDERHAL_CHK_NULL(pRenderHal->pStateHeap);
5348 MHW_RENDERHAL_CHK_NULL(pRenderHal->pRenderHalPltInterface);
5349 MHW_RENDERHAL_ASSERT(pRenderHal->pStateHeap->bGshLocked);
5350 MHW_RENDERHAL_CHK_NULL(pRenderHal->pRenderHalPltInterface->GetMmioRegisters(pRenderHal));
5351
5352 //---------------------------------------
5353 pOsInterface = pRenderHal->pOsInterface;
5354 pMhwRender = pRenderHal->pMhwRenderInterface;
5355 pMhwMiInterface = pRenderHal->pMhwMiInterface;
5356 pStateHeap = pRenderHal->pStateHeap;
5357 pOsContext = pOsInterface->pOsContext;
5358 pMmioRegisters = pRenderHal->pRenderHalPltInterface->GetMmioRegisters(pRenderHal);
5359
5360 // This need not be secure, since PPGTT will be used here. But moving this after
5361 // L3 cache configuration will delay UMD from fetching another media state.
5362 // Send Sync Tag
5363 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pfnSendSyncTag(pRenderHal, pCmdBuffer));
5364
5365 // Setup L3$ Config, LRI commands used here & hence must be launched from a secure bb
5366 pRenderHal->L3CacheSettings.bEnableSLM = (pGpGpuWalkerParams && pGpGpuWalkerParams->SLMSize > 0);
5367 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pfnEnableL3Caching(pRenderHal, &pRenderHal->L3CacheSettings));
5368
5369 // Send L3 Cache Configuration
5370 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pRenderHalPltInterface->SetL3Cache(pRenderHal, pCmdBuffer));
5371
5372 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pRenderHalPltInterface->EnablePreemption(pRenderHal, pCmdBuffer));
5373
5374 // Send Debug Control, LRI commands used here & hence must be launched from a secure bb
5375 MHW_RENDERHAL_CHK_STATUS(RenderHal_AddDebugControl(pRenderHal, pCmdBuffer));
5376
5377 // Send Pipeline Select command
5378 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pRenderHalPltInterface->AddPipelineSelectCmd(pRenderHal, pCmdBuffer, (pGpGpuWalkerParams) ? true : false));
5379
5380 // The binding table for surface states is at end of command buffer. No need to add it to indirect state heap.
5381 HalOcaInterface::OnIndirectState(*pCmdBuffer, *pOsContext, pRenderHal->StateBaseAddressParams.presInstructionBuffer,
5382 pStateHeap->CurIDEntryParams.dwKernelOffset, false, pStateHeap->iKernelUsedForDump);
5383
5384 // Send State Base Address command
5385 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pRenderHalPltInterface->SendStateBaseAddress(pRenderHal, pCmdBuffer));
5386
5387 if (pRenderHal->bComputeContextInUse)
5388 {
5389 pRenderHal->pRenderHalPltInterface->SendTo3DStateBindingTablePoolAlloc(pRenderHal, pCmdBuffer);
5390 }
5391
5392 // Send Surface States
5393 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pfnSendSurfaces(pRenderHal, pCmdBuffer));
5394
5395 // Send SIP State if ASM debug enabled
5396 if (pRenderHal->bIsaAsmDebugEnable)
5397 {
5398 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pRenderHalPltInterface->AddSipStateCmd(pRenderHal, pCmdBuffer));
5399 }
5400
5401 pVfeStateParams = pRenderHal->pRenderHalPltInterface->GetVfeStateParameters();
5402 if (!pRenderHal->bComputeContextInUse)
5403 {
5404 // set VFE State
5405 MHW_RENDERHAL_CHK_STATUS(pMhwRender->AddMediaVfeCmd(pCmdBuffer, pVfeStateParams));
5406 }
5407 else
5408 {
5409 // set CFE State
5410 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pRenderHalPltInterface->AddCfeStateCmd(pRenderHal, pCmdBuffer, pVfeStateParams));
5411 }
5412
5413 // Send CURBE Load
5414 if (!pRenderHal->bComputeContextInUse)
5415 {
5416 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pfnSendCurbeLoad(pRenderHal, pCmdBuffer));
5417 }
5418
5419 // Send Interface Descriptor Load
5420 if (!pRenderHal->bComputeContextInUse)
5421 {
5422 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pfnSendMediaIdLoad(pRenderHal, pCmdBuffer));
5423 }
5424
5425 // Send Chroma Keys
5426 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pRenderHalPltInterface->SendChromaKey(pRenderHal, pCmdBuffer));
5427
5428 // Send Palettes in use
5429 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pRenderHalPltInterface->SendPalette(pRenderHal, pCmdBuffer));
5430
5431 HalOcaInterface::OnDispatch(*pCmdBuffer, *pOsContext, *pRenderHal->pMhwMiInterface, *pMmioRegisters);
5432
5433 // Send Media object walker
5434 if(pWalkerParams)
5435 {
5436 MHW_RENDERHAL_CHK_STATUS(pMhwRender->AddMediaObjectWalkerCmd(
5437 pCmdBuffer,
5438 pWalkerParams));
5439 }
5440 else if (pGpGpuWalkerParams && (!pRenderHal->bComputeContextInUse))
5441 {
5442 MHW_RENDERHAL_CHK_STATUS(pMhwRender->AddGpGpuWalkerStateCmd(
5443 pCmdBuffer,
5444 pGpGpuWalkerParams));
5445 }
5446 else if (pGpGpuWalkerParams && pRenderHal->bComputeContextInUse)
5447 {
5448 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pRenderHalPltInterface->SendComputeWalker(
5449 pRenderHal,
5450 pCmdBuffer,
5451 pGpGpuWalkerParams));
5452 }
5453
5454 finish:
5455 return eStatus;
5456 }
5457
5458 //!
5459 //! \brief Assign binding Table
5460 //! \details Assigns binding Table
5461 //! \param PRENDERHAL_INTERFACE pRenderHal
5462 //! [in] Pointer to Hardware Interface Structure
5463 //! \param int32_t *piBindingTable
5464 //! [out] Pointer to Binding Table
5465 //! \return MOS_STATUS
5466 //!
RenderHal_AssignBindingTable(PRENDERHAL_INTERFACE pRenderHal,int32_t * piBindingTable)5467 MOS_STATUS RenderHal_AssignBindingTable(
5468 PRENDERHAL_INTERFACE pRenderHal,
5469 int32_t *piBindingTable)
5470 {
5471 PRENDERHAL_STATE_HEAP pStateHeap;
5472 uint32_t dwOffset;
5473 MOS_STATUS eStatus;
5474
5475 //----------------------------------------
5476 MHW_RENDERHAL_CHK_NULL(pRenderHal);
5477 MHW_RENDERHAL_CHK_NULL(piBindingTable);
5478 MHW_RENDERHAL_CHK_NULL(pRenderHal->pStateHeap);
5479 MHW_RENDERHAL_CHK_NULL(pRenderHal->pMhwStateHeap);
5480 //----------------------------------------
5481
5482 *piBindingTable = -1;
5483 pStateHeap = pRenderHal->pStateHeap;
5484 eStatus = MOS_STATUS_UNKNOWN;
5485
5486 if (pStateHeap->iCurrentBindingTable >= pRenderHal->StateHeapSettings.iBindingTables)
5487 {
5488 MHW_RENDERHAL_ASSERTMESSAGE("Unable to allocate Binding Table. Exceeds Maximum.");
5489 goto finish;
5490 }
5491
5492 *piBindingTable = pStateHeap->iCurrentBindingTable;
5493
5494 // Get Offset to Current Binding Table
5495 dwOffset = *piBindingTable * pStateHeap->iBindingTableSize; // Moves the pointer to a Particular Binding Table
5496
5497 // Reset Binding Table
5498 MHW_RENDERHAL_CHK_NULL(pStateHeap->pSshBuffer);
5499 MOS_ZeroMemory(pStateHeap->pSshBuffer + dwOffset, pStateHeap->iBindingTableSize);
5500
5501 // Setup Debug surface state if needed
5502 MHW_RENDERHAL_CHK_STATUS(RenderHal_SetupDebugSurfaceState(pRenderHal));
5503
5504 // Increment the Current Binding Table
5505 ++pStateHeap->iCurrentBindingTable;
5506
5507 eStatus = MOS_STATUS_SUCCESS;
5508
5509 finish:
5510 return eStatus;
5511 }
5512
5513 //!
5514 //! \brief Setup Buffer Surface State
5515 //! \details Setup Buffer Surface States
5516 //! For buffer surfaces, the number of entries in the buffer
5517 //! ranges from 1 to 2^27. After subtracting one from the number
5518 //! of entries, software must place the fields of the resulting
5519 //! 27-bit value into the Height, Width, and Depth fields as
5520 //! indicated, right-justified in each field.
5521 //! Unused upper bits must be set to zero.
5522 //!
5523 //! Width: contains bits [6:0] of the number of entries in the
5524 //! buffer 1 [0,127] --> 7 Bits
5525 //! Height: contains bits [20:7] of the number of entries in the
5526 //! buffer 1 [0,16383] --> 14 Bits
5527 //! Depth: contains bits [26:21] of the number of entries in the
5528 //! buffer 1 [0,63] --> 6 Bits
5529 //! \param PRENDERHAL_INTERFACE pRenderHal
5530 //! [in] Pointer to RenderHal Interface
5531 //! \param PMOS_COMMAND_BUFFER pCmdBuffer
5532 //! [in] Pointer to MOS Command Buffer
5533 //! \param PRENDERHAL_SURFACE pRenderHalSurface
5534 //! [in] Pointer to Render Hal Surface
5535 //! \param PRENDERHAL_SURFACE_STATE_PARAMS pParams
5536 //! [in] Pointer to Surface state parameters
5537 //! \param PRENDERHAL_SURFACE_STATE_ENTRY * ppSurfaceEntry
5538 //! [out] Pointer to Surface entry
5539 //! \return MOS_STATUS
5540 //!
RenderHal_SetupBufferSurfaceState(PRENDERHAL_INTERFACE pRenderHal,PRENDERHAL_SURFACE pRenderHalSurface,PRENDERHAL_SURFACE_STATE_PARAMS pParams,PRENDERHAL_SURFACE_STATE_ENTRY * ppSurfaceEntry)5541 MOS_STATUS RenderHal_SetupBufferSurfaceState(
5542 PRENDERHAL_INTERFACE pRenderHal,
5543 PRENDERHAL_SURFACE pRenderHalSurface,
5544 PRENDERHAL_SURFACE_STATE_PARAMS pParams,
5545 PRENDERHAL_SURFACE_STATE_ENTRY *ppSurfaceEntry)
5546 {
5547 MOS_STATUS eStatus;
5548 PRENDERHAL_SURFACE_STATE_ENTRY pSurfaceEntry;
5549 MHW_RCS_SURFACE_PARAMS RcsSurfaceParams;
5550
5551 //--------------------------------------
5552 MHW_RENDERHAL_CHK_NULL(pRenderHal);
5553 MHW_RENDERHAL_CHK_NULL(pRenderHalSurface);
5554 MHW_RENDERHAL_CHK_NULL(pParams);
5555 MHW_RENDERHAL_CHK_NULL(ppSurfaceEntry);
5556 MHW_RENDERHAL_CHK_NULL(pRenderHal->pHwSizes);
5557 MHW_RENDERHAL_CHK_NULL(pRenderHal->pMhwStateHeap);
5558 MHW_RENDERHAL_ASSERT(pRenderHalSurface->OsSurface.dwWidth > 0);
5559 //--------------------------------------
5560
5561 eStatus = MOS_STATUS_SUCCESS;
5562
5563 // Force surface type to Default (non-AVS)
5564 pParams->Type = pRenderHal->SurfaceTypeDefault;
5565
5566 // Assign Surface State
5567 // Assign a New Surface State Entry
5568 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pfnAssignSurfaceState(
5569 pRenderHal,
5570 pRenderHal->SurfaceTypeDefault,
5571 ppSurfaceEntry));
5572
5573 pSurfaceEntry = *ppSurfaceEntry;
5574 MHW_RENDERHAL_CHK_NULL(pSurfaceEntry);
5575
5576 // Update surface state offset in SSH
5577 *pSurfaceEntry->pSurface = pRenderHalSurface->OsSurface;
5578 pSurfaceEntry->dwSurfStateOffset =
5579 pRenderHal->pStateHeap->iSurfaceStateOffset +
5580 pSurfaceEntry->iSurfStateID * pRenderHal->pHwSizes->dwSizeSurfaceState;
5581
5582 // Setup MHW parameters
5583 MOS_ZeroMemory(&RcsSurfaceParams, sizeof(MHW_RCS_SURFACE_PARAMS));
5584 RcsSurfaceParams.psSurface = &pRenderHalSurface->OsSurface;
5585 RcsSurfaceParams.dwOffsetInSSH = pSurfaceEntry->dwSurfStateOffset;
5586 RcsSurfaceParams.dwCacheabilityControl = pRenderHal->pfnGetSurfaceMemoryObjectControl(pRenderHal, pParams);
5587 RcsSurfaceParams.bIsWritable = pParams->bRenderTarget;
5588 RcsSurfaceParams.bRenderTarget = pParams->bRenderTarget;
5589
5590 // Call MHW to setup the Surface State Heap entry for Buffer
5591 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pfnSetSurfaceStateBuffer(pRenderHal, &RcsSurfaceParams, pSurfaceEntry->pSurfaceState));
5592
5593 // Setup OS Specific States
5594 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pfnSetupSurfaceStatesOs(pRenderHal, pParams, pSurfaceEntry));
5595
5596 finish:
5597 return eStatus;
5598 }
5599
5600 //!
5601 //! \brief Set surface state buffer
5602 //! \param [in] pRenderHal
5603 //! pointer to render hal
5604 //! [in] pParams
5605 //! pointer to surface parameters
5606 //! \param void *pSurfaceState
5607 //! [in/out] Surface State Pointer
5608 //!
RenderHal_SetSurfaceStateBuffer(PRENDERHAL_INTERFACE pRenderHal,PMHW_RCS_SURFACE_PARAMS pParams,void * pSurfaceState)5609 MOS_STATUS RenderHal_SetSurfaceStateBuffer(
5610 PRENDERHAL_INTERFACE pRenderHal,
5611 PMHW_RCS_SURFACE_PARAMS pParams,
5612 void *pSurfaceState)
5613 {
5614 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
5615
5616 MHW_MI_CHK_NULL(pParams);
5617 MHW_MI_CHK_NULL(pParams->psSurface);
5618 MHW_MI_CHK_NULL(pSurfaceState);
5619
5620 MHW_SURFACE_STATE_PARAMS Params;
5621 MOS_ZeroMemory(&Params, sizeof(Params));
5622 PMOS_SURFACE pSurface = pParams->psSurface;
5623 uint32_t dwBufferSize = pSurface->dwWidth - 1;
5624 Params.SurfaceType3D = MOS_GFXRES_SCRATCH == pSurface->Type?
5625 GFX3DSTATE_SURFACETYPE_SCRATCH
5626 : GFX3DSTATE_SURFACETYPE_BUFFER;
5627
5628 if (MOS_GFXRES_SCRATCH == pSurface->Type)
5629 {
5630 Params.dwPitch = 1023;
5631 uint32_t entry_count = pSurface->dwWidth/(Params.dwPitch + 1);
5632 Params.dwWidth = (entry_count - 1) & MOS_MASKBITS32(0, 6);
5633 Params.dwHeight = (((entry_count - 1) & MOS_MASKBITS32(7, 20)) >> 7);
5634 Params.dwDepth = (((entry_count - 1) & 0xFFE00000) >> 21);
5635 Params.dwFormat = MHW_GFX3DSTATE_SURFACEFORMAT_RAW;
5636 }
5637 else
5638 {
5639 // Width contains bits [ 6:0] of the number of entries in the buffer
5640 Params.dwWidth = (uint8_t)(dwBufferSize & MOS_MASKBITS32(0, 6));
5641 // Height contains bits [20:7] of the number of entries in the buffer
5642 Params.dwHeight = (uint16_t)((dwBufferSize & MOS_MASKBITS32(7, 20)) >> 7);
5643 // For SURFTYPE_BUFFER, pitch is defaulted to 0. Resetting is unnecessary.
5644
5645 uint32_t depthMaskBuffer = pRenderHal->pRenderHalPltInterface
5646 ->GetDepthBitMaskForBuffer();
5647 uint32_t depthMaskRawBuffer = pRenderHal->pRenderHalPltInterface
5648 ->GetDepthBitMaskForRawBuffer();
5649 switch (pSurface->Format)
5650 {
5651 // We consider MOS's Format_Buffer as MHW_GFX3DSTATE_SURFACEFORMAT_L8_UNORM
5652 // format for most of cases
5653 case Format_Buffer:
5654 Params.dwFormat = MHW_GFX3DSTATE_SURFACEFORMAT_L8_UNORM;
5655 Params.dwDepth
5656 = (uint16_t)((dwBufferSize & depthMaskBuffer) >> 21);
5657 break;
5658
5659 case Format_RAW:
5660 Params.dwFormat = MHW_GFX3DSTATE_SURFACEFORMAT_RAW;
5661 Params.dwDepth
5662 = (uint16_t)((dwBufferSize & depthMaskRawBuffer) >> 21);
5663 break;
5664
5665 case Format_L8:
5666 Params.dwFormat = MHW_GFX3DSTATE_SURFACEFORMAT_L8_UNORM;
5667 Params.dwDepth
5668 = (uint16_t)((dwBufferSize & depthMaskBuffer) >> 21);
5669 break;
5670
5671 default:
5672 MHW_ASSERTMESSAGE("Invalid buffer Resource format");
5673 break;
5674 }
5675 }
5676
5677 Params.pSurfaceState = (uint8_t*)pSurfaceState;
5678 Params.dwCacheabilityControl = pParams->dwCacheabilityControl;
5679
5680 // Default tile mode of surface state buffer is linear
5681 Params.bGMMTileEnabled = true;
5682
5683 // Setup Surface State Entry via MHW state heap interface
5684 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwStateHeap->SetSurfaceStateEntry(&Params));
5685
5686 finish:
5687 return eStatus;
5688 }
5689
5690 //!
5691 //! \brief Setup Interface Descriptor
5692 //! \details Set interface descriptor
5693 //! \param PRENDERHAL_INTERFACE pRenderHal
5694 //! [in] Pointer to HW interface
5695 //! \param PRENDERHAL_MEDIA_STATE pMediaState
5696 //! [in] Pointer to media state
5697 //! \param PRENDERHAL_KRN_ALLOCATION pKernelAllocation
5698 //! [in] Pointer to kernel allocation
5699 //! \param PRENDERHAL_INTERFACE_DESCRIPTOR_PARAMS pInterfaceDescriptorParams
5700 //! [in] Pointer to interface descriptor parameters
5701 //! \param PMHW_GPGPU_WALKER_PARAMS pGpGpuWalkerParams
5702 //! [in] Pointer to gpgpu walker parameters
5703 //! \return MOS_STATUS
5704 //!
RenderHal_SetupInterfaceDescriptor(PRENDERHAL_INTERFACE pRenderHal,PRENDERHAL_MEDIA_STATE pMediaState,PRENDERHAL_KRN_ALLOCATION pKernelAllocation,PRENDERHAL_INTERFACE_DESCRIPTOR_PARAMS pInterfaceDescriptorParams)5705 MOS_STATUS RenderHal_SetupInterfaceDescriptor(
5706 PRENDERHAL_INTERFACE pRenderHal,
5707 PRENDERHAL_MEDIA_STATE pMediaState,
5708 PRENDERHAL_KRN_ALLOCATION pKernelAllocation,
5709 PRENDERHAL_INTERFACE_DESCRIPTOR_PARAMS pInterfaceDescriptorParams)
5710 {
5711 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
5712 PMHW_ID_ENTRY_PARAMS pParams = nullptr;
5713 PRENDERHAL_STATE_HEAP pStateHeap = nullptr;
5714
5715 //-----------------------------------------
5716 MHW_RENDERHAL_CHK_NULL(pRenderHal);
5717 MHW_RENDERHAL_CHK_NULL(pRenderHal->pMhwStateHeap);
5718 MHW_RENDERHAL_CHK_NULL(pRenderHal->pStateHeap);
5719 MHW_RENDERHAL_CHK_NULL(pMediaState);
5720 MHW_RENDERHAL_CHK_NULL(pKernelAllocation);
5721 MHW_RENDERHAL_CHK_NULL(pInterfaceDescriptorParams);
5722 //-----------------------------------------
5723
5724 // Get states, params
5725 pStateHeap = pRenderHal->pStateHeap;
5726 pParams = &pStateHeap->CurIDEntryParams;
5727
5728 pParams->dwMediaIdOffset = pMediaState->dwOffset + pStateHeap->dwOffsetMediaID;
5729 pParams->iMediaId = pInterfaceDescriptorParams->iMediaID;
5730 pParams->dwKernelOffset = pKernelAllocation->dwOffset;
5731 pParams->dwSamplerOffset = pMediaState->dwOffset + pStateHeap->dwOffsetSampler +
5732 pInterfaceDescriptorParams->iMediaID * pStateHeap->dwSizeSamplers;
5733 pParams->dwSamplerCount = pKernelAllocation->Params.Sampler_Count;
5734 pParams->dwBindingTableOffset = pInterfaceDescriptorParams->iBindingTableID * pStateHeap->iBindingTableSize;
5735 pParams->iCurbeOffset = pInterfaceDescriptorParams->iCurbeOffset;
5736 pParams->iCurbeLength = pInterfaceDescriptorParams->iCurbeLength;
5737
5738 pParams->bBarrierEnable = pInterfaceDescriptorParams->blBarrierEnable;
5739 pParams->bGlobalBarrierEnable = pInterfaceDescriptorParams->blGlobalBarrierEnable; //It's only applied for BDW+
5740 pParams->dwNumberofThreadsInGPGPUGroup = pInterfaceDescriptorParams->iNumberThreadsInGroup;
5741 pParams->dwSharedLocalMemorySize = pRenderHal->pfnEncodeSLMSize(pRenderHal, pInterfaceDescriptorParams->iSLMSize);
5742 pParams->iCrsThdConDataRdLn = pInterfaceDescriptorParams->iCrsThrdConstDataLn;
5743 pParams->pGeneralStateHeap = nullptr;
5744
5745 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwStateHeap->SetInterfaceDescriptorEntry(pParams));
5746
5747 finish:
5748 return eStatus;
5749 }
5750
5751 //!
5752 //! \brief Get Media Walker Status
5753 //! \details Returns Media Walker Enabled / Disabled
5754 //! \param PRENDERHAL_INTERFACE pRenderHal
5755 //! [in] Pointer to RenderHal Interface
5756 //! \return bool
5757 //!
RenderHal_GetMediaWalkerStatus(PRENDERHAL_INTERFACE pRenderHal)5758 bool RenderHal_GetMediaWalkerStatus(
5759 PRENDERHAL_INTERFACE pRenderHal)
5760 {
5761 //-----------------------------------------
5762 if (pRenderHal == nullptr)
5763 {
5764 MHW_RENDERHAL_ASSERTMESSAGE("Invalid renderhal.");
5765 return false;
5766 }
5767 //-----------------------------------------
5768
5769 if (pRenderHal->MediaWalkerMode == MHW_WALKER_MODE_DISABLED)
5770 {
5771 return false;
5772 }
5773
5774 return true;
5775 }
5776
5777 //!
5778 //! \brief Get surface memory object control \
5779 //! \details Returns surface memory object control
5780 //! \param PRENDERHAL_INTERFACE pRenderHal
5781 //! [in] Pointer to RenderHal Interface
5782 //! \param PRENDERHAL_SURFACE_STATE_PARAMS pParams
5783 //! [in] Pointer to surface state params
5784 //! \return uint32_t
5785 //!
RenderHal_GetSurfaceMemoryObjectControl(PRENDERHAL_INTERFACE pRenderHal,PRENDERHAL_SURFACE_STATE_PARAMS pParams)5786 uint32_t RenderHal_GetSurfaceMemoryObjectControl(
5787 PRENDERHAL_INTERFACE pRenderHal,
5788 PRENDERHAL_SURFACE_STATE_PARAMS pParams)
5789 {
5790 MHW_RENDERHAL_UNUSED(pRenderHal);
5791
5792 //-----------------------------------------
5793 if (pParams == nullptr)
5794 {
5795 MHW_RENDERHAL_ASSERTMESSAGE("nullptr pointer.");
5796 return 0;
5797 }
5798 //-----------------------------------------
5799
5800 return pParams->MemObjCtl;
5801 }
5802
5803 //!
5804 //! \brief Get the size of Scratch Space
5805 //! \details Get scratch space size based on max gen config and scratch space
5806 //! size per thread
5807 //! FFTID is used by HW to access scratch space; since FFTID generated
5808 //! is not continuous, need to allocate scratch space based on maximum gen config
5809 //! \param PRENDERHAL_INTERFACE pRenderHal
5810 //! [in] Hardware interface
5811 //! \param uint32_t iPerThreadScratchSpaceSize
5812 //! [in] Per thread scratch space size
5813 //! \return uint32_t
5814 //!
RenderHal_GetScratchSpaceSize(PRENDERHAL_INTERFACE pRenderHal,uint32_t iPerThreadScratchSpaceSize)5815 uint32_t RenderHal_GetScratchSpaceSize(
5816 PRENDERHAL_INTERFACE pRenderHal,
5817 uint32_t iPerThreadScratchSpaceSize)
5818 {
5819 MEDIA_SYSTEM_INFO *pGtSystemInfo;
5820
5821 //-----------------------------------------
5822 if (pRenderHal == nullptr)
5823 {
5824 MHW_RENDERHAL_ASSERTMESSAGE("Invalid renderhal.");
5825 return 0;
5826 }
5827 //-----------------------------------------
5828
5829 pGtSystemInfo = pRenderHal->pOsInterface->pfnGetGtSystemInfo(pRenderHal->pOsInterface);
5830 uint32_t numHWThreadsPerEU = pGtSystemInfo->ThreadCount / pGtSystemInfo->EUCount;
5831
5832 uint32_t dwNumberOfScratchSpaceEntries = pGtSystemInfo->MaxEuPerSubSlice * numHWThreadsPerEU * pGtSystemInfo->MaxSubSlicesSupported;
5833 uint32_t dwScratchSpaceSize = dwNumberOfScratchSpaceEntries * iPerThreadScratchSpaceSize;
5834
5835 return dwScratchSpaceSize;
5836 }
5837
5838 //!
5839 //! \brief Setup OS specific surface state parameters
5840 //! \details Setup Platform and Operating System Specific Surface State
5841 //! \param PRENDERHAL_INTERFACE pRenderHal
5842 //! [in] Pointer to Hardware Interface Structure
5843 //! \param PRENDERHAL_SURFACE_STATE_PARAMS pParams
5844 //! [in] Pointer to Surface Params
5845 //! \param PRENDERHAL_SURFACE_STATE_ENTRY pSurfaceEntry
5846 //! [in] Pointer to Surface State Entry
5847 //! \return MOS_STATUS
5848 //! MOS_STATUS_SUCCESS if successful
5849 //!
RenderHal_SetupSurfaceStatesOs(PRENDERHAL_INTERFACE pRenderHal,PRENDERHAL_SURFACE_STATE_PARAMS pParams,PRENDERHAL_SURFACE_STATE_ENTRY pSurfaceEntry)5850 MOS_STATUS RenderHal_SetupSurfaceStatesOs(
5851 PRENDERHAL_INTERFACE pRenderHal,
5852 PRENDERHAL_SURFACE_STATE_PARAMS pParams,
5853 PRENDERHAL_SURFACE_STATE_ENTRY pSurfaceEntry)
5854 {
5855 PMOS_SURFACE pSurface;
5856 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
5857 MHW_SURFACE_TOKEN_PARAMS TokenParams;
5858
5859 uint32_t additional_plane_offset = 0;
5860 uint32_t vertical_offset_in_surface_state = 0;
5861
5862 //-----------------------------------------
5863 MHW_RENDERHAL_CHK_NULL(pRenderHal);
5864 MHW_RENDERHAL_CHK_NULL(pParams);
5865 MHW_RENDERHAL_CHK_NULL(pSurfaceEntry);
5866 //-----------------------------------------
5867
5868 pSurface = pSurfaceEntry->pSurface;
5869
5870 // Surface, plane, offset
5871 TokenParams.pOsSurface = pSurface;
5872 TokenParams.YUVPlane = pSurfaceEntry->YUVPlane;
5873
5874 switch (pSurfaceEntry->YUVPlane)
5875 {
5876 case MHW_U_PLANE:
5877 vertical_offset_in_surface_state = pSurface->UPlaneOffset.iYOffset;
5878 vertical_offset_in_surface_state &= 0x1C; // The offset value in surface state commands.
5879 additional_plane_offset = pSurface->UPlaneOffset.iYOffset
5880 - vertical_offset_in_surface_state;
5881 additional_plane_offset *= pSurface->dwPitch;
5882 TokenParams.dwSurfaceOffset = pSurface->UPlaneOffset.iSurfaceOffset
5883 + additional_plane_offset;
5884 break;
5885 case MHW_V_PLANE:
5886 vertical_offset_in_surface_state = pSurface->VPlaneOffset.iYOffset;
5887 vertical_offset_in_surface_state &= 0x1C;
5888 additional_plane_offset = pSurface->VPlaneOffset.iYOffset
5889 - vertical_offset_in_surface_state;
5890 additional_plane_offset *= pSurface->dwPitch;
5891 TokenParams.dwSurfaceOffset = pSurface->VPlaneOffset.iSurfaceOffset
5892 + additional_plane_offset;
5893 break;
5894 default:
5895 vertical_offset_in_surface_state = pSurface->YPlaneOffset.iYOffset;
5896 vertical_offset_in_surface_state &= 0x1C;
5897 additional_plane_offset = pSurface->YPlaneOffset.iYOffset
5898 - vertical_offset_in_surface_state;
5899 additional_plane_offset *= pSurface->dwPitch;
5900 TokenParams.dwSurfaceOffset
5901 = pSurface->dwOffset + additional_plane_offset;
5902 //force it to 0 for 1D buffer
5903 if (pParams->bBufferUse)
5904 {
5905 TokenParams.dwSurfaceOffset = 0;
5906 }
5907 break;
5908 }
5909
5910 // Surface type
5911 TokenParams.bRenderTarget = pParams->bRenderTarget;
5912 TokenParams.bSurfaceTypeAvs = pSurfaceEntry->bAVS;
5913
5914 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pfnSetSurfaceStateToken(
5915 pRenderHal,
5916 &TokenParams,
5917 &pSurfaceEntry->SurfaceToken));
5918
5919 finish:
5920 return eStatus;
5921 }
5922
5923 //!
5924 //! \brief Bind Surface State
5925 //! \details Binds Surface State
5926 //! \param PRENDERHAL_INTERFACE pRenderHal
5927 //! [in] Pointer to RenderHal Interface
5928 //! \param int32_t iBindingTableIndex
5929 //! [in] Binding Table Index
5930 //! \param int32_t iBindingTableEntry
5931 //! [out] Binding Table Entry
5932 //! \param PRENDERHAL_SURFACE_STATE_ENTRY pSurfaceEntry
5933 //! [in] Pointer to Surface State Entry
5934 //! \return MOS_STATUS
5935 //!
RenderHal_BindSurfaceState(PRENDERHAL_INTERFACE pRenderHal,int32_t iBindingTableIndex,int32_t iBindingTableEntry,PRENDERHAL_SURFACE_STATE_ENTRY pSurfaceEntry)5936 MOS_STATUS RenderHal_BindSurfaceState(
5937 PRENDERHAL_INTERFACE pRenderHal,
5938 int32_t iBindingTableIndex,
5939 int32_t iBindingTableEntry,
5940 PRENDERHAL_SURFACE_STATE_ENTRY pSurfaceEntry)
5941 {
5942 PRENDERHAL_STATE_HEAP pStateHeap;
5943 PMHW_RENDER_STATE_SIZES pHwSizes;
5944 MHW_BINDING_TABLE_PARAMS Params;
5945 uint32_t dwOffset;
5946 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
5947
5948 //--------------------------------------------
5949 MHW_RENDERHAL_CHK_NULL(pRenderHal);
5950 MHW_RENDERHAL_CHK_NULL(pSurfaceEntry);
5951 MHW_RENDERHAL_CHK_NULL(pRenderHal->pStateHeap);
5952 MHW_RENDERHAL_CHK_NULL(pRenderHal->pHwSizes);
5953 MHW_RENDERHAL_ASSERT(iBindingTableIndex >= 0);
5954 MHW_RENDERHAL_ASSERT(iBindingTableEntry >= 0);
5955 //--------------------------------------------
5956
5957 pStateHeap = pRenderHal->pStateHeap;
5958 pHwSizes = pRenderHal->pHwSizes;
5959
5960 // Get Offset to Current Binding Table
5961 dwOffset = (pStateHeap->iCurSshBufferIndex * pStateHeap->dwSshIntanceSize) + // Points to the Base of Current SSH Buffer Instance
5962 (pStateHeap->iBindingTableOffset) + // Moves the pointer to Base of Array of Binding Tables
5963 (iBindingTableIndex * pStateHeap->iBindingTableSize) + // Moves the pointer to a Particular Binding Table
5964 (iBindingTableEntry * pHwSizes->dwSizeBindingTableState); // Move the pointer to correct entry
5965
5966 MHW_RENDERHAL_CHK_NULL(pStateHeap->pSshBuffer);
5967 Params.pBindingTableEntry = pStateHeap->pSshBuffer + dwOffset;
5968 Params.dwSurfaceStateOffset = pSurfaceEntry->dwSurfStateOffset;
5969 Params.bSurfaceStateAvs = (pSurfaceEntry->Type == pRenderHal->SurfaceTypeAdvanced ) ? true : false;
5970 Params.iBindingTableEntry = iBindingTableEntry;
5971
5972 // Set binding table entry in MHW
5973 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pMhwStateHeap->SetBindingTableEntry(&Params));
5974
5975 finish:
5976 return eStatus;
5977 }
5978
5979 //!
5980 //! \brief Send Surfaces PatchList
5981 //! \details Send Surface State commands
5982 //! \param PRENDERHAL_INTERFACE pRenderHal
5983 //! [in] Pointer to Hardware Interface Structure
5984 //! \param PMOS_COMMAND_BUFFER pCmdBuffer
5985 //! [in] Pointer to Command Buffer
5986 //! \return MOS_STATUS
5987 //!
5988 MOS_STATUS RenderHal_SendSurfaces_PatchList(
5989 PRENDERHAL_INTERFACE pRenderHal,
5990 PMOS_COMMAND_BUFFER pCmdBuffer);
5991
5992 //!
5993 //! \brief Set Vfe State Params
5994 //! \details Sets VFE State parameters
5995 //! this functions must be called to setup
5996 //! parameters for pMhwRender->AddMediaVfeCmd()
5997 //! \param PRENDERHAL_INTERFACE pRenderHal
5998 //! [in] Pointer to Hardware Interface Structure
5999 //! \param uint32_t dwDebugCounterControl
6000 //! [in] Debug Counter Control
6001 //! \param uint32_t dwMaximumNumberofThreads
6002 //! [in] Maximum Number of Threads
6003 //! \param uint32_t dwCURBEAllocationSize
6004 //! [in] CURBE Allocation Size
6005 //! \param uint32_t dwURBEntryAllocationSize
6006 //! [in] URB Entry Allocation Size
6007 //! \param PRENDERHAL_SCOREBOARD_PARAMS pScoreboardParams
6008 //! [in] Pointer to Scoreboard Params
6009 //! \return MOS_STATUS
6010 //!
RenderHal_SetVfeStateParams(PRENDERHAL_INTERFACE pRenderHal,uint32_t dwDebugCounterControl,uint32_t dwMaximumNumberofThreads,uint32_t dwCURBEAllocationSize,uint32_t dwURBEntryAllocationSize,PMHW_VFE_SCOREBOARD pScoreboardParams)6011 MOS_STATUS RenderHal_SetVfeStateParams(
6012 PRENDERHAL_INTERFACE pRenderHal,
6013 uint32_t dwDebugCounterControl,
6014 uint32_t dwMaximumNumberofThreads,
6015 uint32_t dwCURBEAllocationSize,
6016 uint32_t dwURBEntryAllocationSize,
6017 PMHW_VFE_SCOREBOARD pScoreboardParams)
6018 {
6019 PMHW_VFE_PARAMS pVfeParams;
6020 PRENDERHAL_STATE_HEAP pStateHeap;
6021 PMHW_RENDER_ENGINE_CAPS pHwCaps;
6022 PRENDERHAL_STATE_HEAP_SETTINGS pSettings;
6023 uint32_t dwMaxURBSize;
6024 uint32_t dwMaxCURBEAllocationSize;
6025 uint32_t dwMaxURBEntryAllocationSize;
6026 uint32_t dwNumberofURBEntries;
6027 uint32_t dwMaxURBEntries;
6028 uint32_t dwMaxInterfaceDescriptorEntries;
6029 MOS_STATUS eStatus;
6030 uint32_t i;
6031
6032 //---------------------------------------------
6033 MHW_RENDERHAL_CHK_NULL(pRenderHal);
6034 MHW_RENDERHAL_CHK_NULL(pRenderHal->pWaTable);
6035 MHW_RENDERHAL_CHK_NULL(pRenderHal->pStateHeap);
6036 MHW_RENDERHAL_CHK_NULL(pRenderHal->pHwCaps);
6037 //---------------------------------------------
6038
6039 eStatus = MOS_STATUS_SUCCESS;
6040 pStateHeap = pRenderHal->pStateHeap;
6041 pHwCaps = pRenderHal->pHwCaps;
6042 pVfeParams = pRenderHal->pRenderHalPltInterface->GetVfeStateParameters();
6043 MHW_RENDERHAL_CHK_NULL(pVfeParams);
6044 pSettings = &(pRenderHal->StateHeapSettings);
6045
6046 pVfeParams->pKernelState = nullptr;
6047 pVfeParams->eVfeSliceDisable = MHW_VFE_SLICE_ALL;
6048
6049 //-------------------------------------------------------------------------
6050 // --Gen6 GT1--
6051 // In this calculation, URBEntryAllocationSize and CURBEAllocationSize are
6052 // in 256-bit units:
6053 // (URBEntryAllocationSize * NumberofURBEntries + CURBEAllocationSize +
6054 // MaxInterfaceDescriptorEntries) <= 1024
6055 //
6056 // --Gen6 GT2 + Gen7--
6057 // In this calculation, URBEntryAllocationSize and CURBEAllocationSize are
6058 // in 256-bit units:
6059 // (URBEntryAllocationSize * NumberofURBEntries + CURBEAllocationSize +
6060 // MaxInterfaceDescriptorEntries) <= 2048
6061 //-------------------------------------------------------------------------
6062
6063 // get the Max for all the fields
6064 dwMaxURBSize = pHwCaps->dwMaxURBSize;
6065 dwMaxURBEntries = pHwCaps->dwMaxURBEntries;
6066 dwMaxURBEntryAllocationSize = pHwCaps->dwMaxURBEntryAllocationSize;
6067 dwMaxCURBEAllocationSize = pHwCaps->dwMaxCURBEAllocationSize;
6068 dwMaxInterfaceDescriptorEntries = pHwCaps->dwMaxInterfaceDescriptorEntries;
6069
6070 // CURBEAllocationSize must be >= CurbeTotalDataLength in CURBE_LOAD.
6071 MHW_RENDERHAL_CHK_NULL(pStateHeap->pCurMediaState);
6072 dwCURBEAllocationSize = MOS_MAX(dwCURBEAllocationSize, (uint32_t)pStateHeap->pCurMediaState->iCurbeOffset);
6073
6074 // CURBEAllocationSize is in 256-bit (32-byte) units, so we round up to
6075 // 32. We do not force it to be greater than zero because a Kernel may not
6076 // be using any CURBE parameters.
6077 dwCURBEAllocationSize = MOS_ROUNDUP_SHIFT(dwCURBEAllocationSize, 5);
6078
6079 // URBEntryAllocationSize is in 256-bit (32-byte) units, so we round up to
6080 // 32. We ensure that it is greater than zero, because we will use this in
6081 // division when we calculate dwNumberofURBEntries, so we need a value
6082 // that is greater than zero.
6083 // URBEntryAllocationSize sets the size of the Inline Data. All the Inline
6084 // Data will be placed in the URB which is a buffer that is managed by the
6085 // hardware. When the thread is dispatched, the data in the URB will be
6086 // copied to the GRF.
6087 dwURBEntryAllocationSize = MOS_ROUNDUP_SHIFT(dwURBEntryAllocationSize, 5);
6088 dwURBEntryAllocationSize = MOS_MAX(1, dwURBEntryAllocationSize);
6089
6090 // NumberofURBEntries defines the depth of the dispatch queue. Up to this
6091 // many threads can be in the queue. It's related to performance. For hardware,
6092 // we use the size of the Inline Data to calculate the maximum number of entries
6093 // we can use. We cap it to 32 URB entries, and then ensure that it is greater
6094 // than zero.
6095 dwNumberofURBEntries =
6096 (dwMaxURBSize - dwCURBEAllocationSize - dwMaxInterfaceDescriptorEntries) /
6097 dwURBEntryAllocationSize;
6098 dwNumberofURBEntries = MOS_CLAMP_MIN_MAX(dwNumberofURBEntries, 1, 32);
6099
6100 pVfeParams->dwDebugCounterControl = dwDebugCounterControl;
6101 pVfeParams->dwNumberofURBEntries = dwNumberofURBEntries;
6102 pVfeParams->dwMaximumNumberofThreads = (dwMaximumNumberofThreads == RENDERHAL_USE_MEDIA_THREADS_MAX) ?
6103 pHwCaps->dwMaxThreads :
6104 MOS_MIN(dwMaximumNumberofThreads, pHwCaps->dwMaxThreads);
6105 pVfeParams->dwCURBEAllocationSize = dwCURBEAllocationSize << 5;
6106 pVfeParams->dwURBEntryAllocationSize = dwURBEntryAllocationSize;
6107
6108 MHW_RENDERHAL_ASSERT(dwNumberofURBEntries <= dwMaxURBEntries);
6109 MHW_RENDERHAL_ASSERT(dwCURBEAllocationSize <= dwMaxCURBEAllocationSize);
6110 MHW_RENDERHAL_ASSERT(dwURBEntryAllocationSize <= dwMaxURBEntryAllocationSize);
6111 MHW_RENDERHAL_ASSERT(dwNumberofURBEntries * dwURBEntryAllocationSize +
6112 dwCURBEAllocationSize + dwMaxInterfaceDescriptorEntries <= dwMaxURBSize);
6113
6114 // Setup Scoreboard Parameters
6115 if (pScoreboardParams)
6116 {
6117 MHW_RENDERHAL_ASSERT(pScoreboardParams->ScoreboardMask < 8);
6118
6119 pRenderHal->VfeScoreboard.ScoreboardEnable = true;
6120 pRenderHal->VfeScoreboard.ScoreboardMask = (1 << pScoreboardParams->ScoreboardMask) - 1;
6121 pRenderHal->VfeScoreboard.ScoreboardType = pScoreboardParams->ScoreboardType;
6122 for (i = 0; i < pScoreboardParams->ScoreboardMask; i++)
6123 {
6124 pRenderHal->VfeScoreboard.ScoreboardDelta[i].x = pScoreboardParams->ScoreboardDelta[i].x;
6125 pRenderHal->VfeScoreboard.ScoreboardDelta[i].y = pScoreboardParams->ScoreboardDelta[i].y;
6126 }
6127 }
6128 else
6129 {
6130 pRenderHal->VfeScoreboard.ScoreboardEnable = true;
6131 pRenderHal->VfeScoreboard.ScoreboardMask = 0x0;
6132 }
6133
6134 // Setup VFE Scoreboard parameters
6135 pVfeParams->Scoreboard = pRenderHal->VfeScoreboard;
6136
6137 // Setup Kernel Scratch Space
6138 if (pSettings->iPerThreadScratchSize > 0)
6139 {
6140 int32_t iSize;
6141 int32_t iRemain;
6142 int32_t iPerThreadScratchSize;
6143
6144 MHW_RENDERHAL_ASSERT(pSettings->iPerThreadScratchSize ==
6145 MOS_ALIGN_CEIL(pSettings->iPerThreadScratchSize, 1024));
6146
6147 iPerThreadScratchSize = pSettings->iPerThreadScratchSize >> 10;
6148
6149 iRemain = iPerThreadScratchSize % 2;
6150 iPerThreadScratchSize = iPerThreadScratchSize / 2;
6151 iSize = 0;
6152 while (!iRemain && (iPerThreadScratchSize / 2))
6153 {
6154 iSize++;
6155 iRemain = iPerThreadScratchSize % 2;
6156 iPerThreadScratchSize = iPerThreadScratchSize / 2;
6157 }
6158
6159 MHW_RENDERHAL_ASSERT(!iRemain && iPerThreadScratchSize);
6160 MHW_RENDERHAL_ASSERT(iSize < 12);
6161 // Specifies the amount of scratch space allowed to be used by each
6162 // thread. The driver must allocate enough contiguous scratch space,
6163 // pointed to by the Scratch Space Pointer, to ensure that the Maximum
6164 // Number of Threads each get Per Thread Scratch Space size without
6165 // exceeding the driver-allocated scratch space.
6166 // Range = [0,11] indicating [1k bytes, 12k bytes]
6167 pVfeParams->dwPerThreadScratchSpace = (uint32_t) iSize;
6168
6169 // Specifies the 1k-byte aligned address offset to scratch space for
6170 // use by the kernel. This pointer is relative to the
6171 // General State Base Address (1k aligned)
6172 // Format = GeneralStateOffset[31:10]
6173 pVfeParams->dwScratchSpaceBasePointer = pStateHeap->dwScratchSpaceBase;
6174 }
6175 else
6176 {
6177 pVfeParams->dwPerThreadScratchSpace = 0;
6178 pVfeParams->dwScratchSpaceBasePointer = 0;
6179 }
6180
6181 finish:
6182 return eStatus;
6183 }
6184
6185 //!
6186 //! \brief Is two Planes NV12 Needed
6187 //! \details Judge whether 2 plane NV12 is needed based on the width/height
6188 //! and its rectangle for each boundary type
6189 //! \param PRENDERHAL_INTERFACE pRenderHal
6190 //! [in] pointer to RenderHal Interface
6191 //! \param PRENDERHAL_SURFACE pRenderHalSurface
6192 //! [in] pointer to input Surface
6193 //! \param RENDERHAL_SS_BOUNDARY Boundary
6194 //! [in] How the adjustment needs to be done
6195 //! \return bool
6196 //!
RenderHal_Is2PlaneNV12Needed(PRENDERHAL_INTERFACE pRenderHal,PRENDERHAL_SURFACE pRenderHalSurface,RENDERHAL_SS_BOUNDARY Boundary)6197 bool RenderHal_Is2PlaneNV12Needed(
6198 PRENDERHAL_INTERFACE pRenderHal,
6199 PRENDERHAL_SURFACE pRenderHalSurface,
6200 RENDERHAL_SS_BOUNDARY Boundary)
6201 {
6202 PMOS_SURFACE pSurface;
6203 uint16_t wWidthAlignUnit;
6204 uint16_t wHeightAlignUnit;
6205 uint32_t dwSurfaceHeight;
6206 uint32_t dwSurfaceWidth;
6207 uint32_t widthAlignUnit;
6208 uint32_t heightAlignUnit;
6209 bool bRet = false;
6210
6211 //---------------------------------------------
6212 if (pRenderHal == nullptr
6213 || pRenderHalSurface == nullptr)
6214 {
6215 MHW_RENDERHAL_ASSERTMESSAGE("nullptr pointer detected.");
6216 goto finish;
6217 }
6218 //---------------------------------------------
6219
6220 pRenderHal->pfnGetAlignUnit(&wWidthAlignUnit, &wHeightAlignUnit, pRenderHalSurface);
6221 pSurface = &pRenderHalSurface->OsSurface;
6222
6223 switch (Boundary)
6224 {
6225 case RENDERHAL_SS_BOUNDARY_SRCRECT:
6226 dwSurfaceHeight = pSurface->dwHeight;
6227 dwSurfaceWidth = MOS_ALIGN_CEIL(MOS_MIN(pSurface->dwWidth, (uint32_t)pRenderHalSurface->rcSrc.right), wWidthAlignUnit);
6228 break;
6229
6230 // align with max src rect
6231 case RENDERHAL_SS_BOUNDARY_MAXSRCRECT:
6232 dwSurfaceHeight = pSurface->dwHeight;
6233 dwSurfaceWidth = MOS_ALIGN_CEIL(MOS_MIN(pSurface->dwWidth, (uint32_t)pRenderHalSurface->rcMaxSrc.right), wWidthAlignUnit);
6234 break;
6235
6236 default:
6237 dwSurfaceHeight = MOS_ALIGN_CEIL(pSurface->dwHeight, wHeightAlignUnit);
6238 dwSurfaceWidth = MOS_ALIGN_CEIL(pSurface->dwWidth, wWidthAlignUnit);
6239 break;
6240 }
6241
6242 // NV12 format needs the width and height to be a multiple for both 3D sampler and 8x8 sampler.
6243 // For AVS sampler, no limitation for 4 alignment.
6244 pRenderHal->pMhwRenderInterface->GetSamplerResolutionAlignUnit(RENDERHAL_SCALING_AVS == pRenderHalSurface->ScalingMode, widthAlignUnit, heightAlignUnit);
6245 bRet = (!MOS_IS_ALIGNED(dwSurfaceHeight, heightAlignUnit) || !MOS_IS_ALIGNED(dwSurfaceWidth, widthAlignUnit));
6246
6247 // Note: Always using 2 plane NV12 as WA for the corruption of NV12 input
6248 // of which the height is greater than 16352
6249 bRet = bRet || (MEDIA_IS_WA(pRenderHal->pWaTable, Wa16KInputHeightNV12Planar420) && dwSurfaceHeight > 16352);
6250
6251 finish:
6252 return bRet;
6253 }
6254
6255 //!
6256 //! \brief Print Sampler Params
6257 //! \details
6258 //! \param PMHW_SAMPLER_STATE_PARAM pSamplerParams
6259 //! [in] SamplerParams
PrintSamplerParams(int32_t iSamplerIndex,PMHW_SAMPLER_STATE_PARAM pSamplerParams)6260 void PrintSamplerParams(int32_t iSamplerIndex, PMHW_SAMPLER_STATE_PARAM pSamplerParams)
6261 {
6262 #if (_DEBUG || _RELEASE_INTERNAL)
6263 if (pSamplerParams == nullptr)
6264 {
6265 MHW_RENDERHAL_ASSERTMESSAGE("The SamplerParams pointer is null");
6266 return;
6267 }
6268
6269 if (pSamplerParams->SamplerType == MHW_SAMPLER_TYPE_3D)
6270 {
6271 MHW_RENDERHAL_VERBOSEMESSAGE("SamplerParams: index = %x, bInUse = %x, SamplerType = %x, ElementType = %x, SamplerFilterMode = %x, MagFilter = %x, MinFilter = %x",
6272 iSamplerIndex,
6273 pSamplerParams->bInUse,
6274 pSamplerParams->SamplerType,
6275 pSamplerParams->ElementType,
6276 pSamplerParams->Unorm.SamplerFilterMode,
6277 pSamplerParams->Unorm.MagFilter,
6278 pSamplerParams->Unorm.MinFilter);
6279 MHW_RENDERHAL_VERBOSEMESSAGE("SamplerParams: index = %x, AddressU = %x, AddressV = %x, AddressW = %x, SurfaceFormat = %x, BorderColorRedU = %x, BorderColorGreenU = %x",
6280 iSamplerIndex,
6281 pSamplerParams->Unorm.AddressU,
6282 pSamplerParams->Unorm.AddressV,
6283 pSamplerParams->Unorm.AddressW,
6284 pSamplerParams->Unorm.SurfaceFormat,
6285 pSamplerParams->Unorm.BorderColorRedU,
6286 pSamplerParams->Unorm.BorderColorGreenU);
6287 MHW_RENDERHAL_VERBOSEMESSAGE("SamplerParams: index = %x, BorderColorBlueU = %x, BorderColorAlphaU = %x, IndirectStateOffset = %x, bBorderColorIsValid = %x, bChromaKeyEnable = %x, ChromaKeyIndex = %x, ChromaKeyMode = %x",
6288 iSamplerIndex,
6289 pSamplerParams->Unorm.BorderColorBlueU,
6290 pSamplerParams->Unorm.BorderColorAlphaU,
6291 pSamplerParams->Unorm.IndirectStateOffset,
6292 pSamplerParams->Unorm.bBorderColorIsValid,
6293 pSamplerParams->Unorm.bChromaKeyEnable,
6294 pSamplerParams->Unorm.ChromaKeyIndex,
6295 pSamplerParams->Unorm.ChromaKeyMode);
6296 }
6297 else
6298 {
6299 MHW_RENDERHAL_VERBOSEMESSAGE("SamplerParams: index = %x, bInUse = %x, SamplerType = %x, ElementType = %x",
6300 iSamplerIndex,
6301 pSamplerParams->bInUse,
6302 pSamplerParams->SamplerType,
6303 pSamplerParams->ElementType);
6304 }
6305 #endif
6306 }
6307
6308 //!
6309 //! \brief Sets Sampler States for Gen8
6310 //! \details Initialize and set sampler states
6311 //! \param PRENDERHAL_INTERFACE pRenderHal
6312 //! [in] Pointer to HW interface
6313 //! \param int32_t iMediaID
6314 //! [in] Media Interface Descriptor ID
6315 //! \param PRENDERHAL_SAMPLER_STATE_PARAMS pSamplerParams
6316 //! [in] Pointer to sampler state parameters
6317 //! \param int32_t iSamplers
6318 //! [in] Number of samplers
6319 //! \return MOS_STATUS MOS_STATUS_SUCCESS if success, otherwise MOS_STATUS_UNKNOWN
6320 //!
RenderHal_SetSamplerStates(PRENDERHAL_INTERFACE pRenderHal,int32_t iMediaID,PMHW_SAMPLER_STATE_PARAM pSamplerParams,int32_t iSamplers)6321 MOS_STATUS RenderHal_SetSamplerStates(
6322 PRENDERHAL_INTERFACE pRenderHal,
6323 int32_t iMediaID,
6324 PMHW_SAMPLER_STATE_PARAM pSamplerParams,
6325 int32_t iSamplers)
6326 {
6327 MOS_STATUS eStatus;
6328 PRENDERHAL_STATE_HEAP pStateHeap;
6329 PMHW_SAMPLER_STATE_PARAM pSamplerStateParams;
6330 PRENDERHAL_MEDIA_STATE pMediaState;
6331 int32_t iOffsetSampler;
6332 uint8_t *pPtrSampler;
6333 uint8_t *pPtrSamplerAvs;
6334 int32_t i;
6335
6336 eStatus = MOS_STATUS_UNKNOWN;
6337
6338 //-----------------------------------------------
6339 MHW_RENDERHAL_CHK_NULL(pRenderHal);
6340 MHW_RENDERHAL_CHK_NULL(pSamplerParams);
6341 MHW_RENDERHAL_CHK_NULL(pRenderHal->pStateHeap);
6342 MHW_RENDERHAL_CHK_NULL(pRenderHal->pStateHeap->pCurMediaState);
6343 MHW_RENDERHAL_CHK_NULL(pRenderHal->pHwSizes);
6344 MHW_RENDERHAL_CHK_NULL(pRenderHal->pMhwStateHeap);
6345 MHW_RENDERHAL_CHK_NULL(pRenderHal->pStateHeap->pGshBuffer);
6346 MHW_RENDERHAL_ASSERT( iSamplers <= pRenderHal->StateHeapSettings.iSamplers );
6347 MHW_RENDERHAL_ASSERT((iMediaID >= 0) && (iMediaID < pRenderHal->StateHeapSettings.iMediaIDs));
6348 //-----------------------------------------------
6349
6350 pStateHeap = pRenderHal->pStateHeap;
6351 pMediaState = pRenderHal->pStateHeap->pCurMediaState;
6352
6353 // Offset/Pointer to Samplers
6354 iOffsetSampler = pMediaState->dwOffset + // Offset to media state
6355 pStateHeap->dwOffsetSampler + // Offset to sampler area
6356 iMediaID * pStateHeap->dwSizeSamplers; // Samplers for media ID
6357 pPtrSampler = pStateHeap->pGshBuffer + iOffsetSampler; // Pointer to Samplers
6358
6359 iOffsetSampler = pMediaState->dwOffset + // Offset to media state
6360 pStateHeap->dwOffsetSamplerAVS + // Offset to sampler area
6361 iMediaID * pStateHeap->dwSizeSamplers; // Samplers for media ID
6362 pPtrSamplerAvs = pStateHeap->pGshBuffer + iOffsetSampler; // Pointer to AVS Samplers
6363
6364 // Setup sampler states
6365 pSamplerStateParams = pSamplerParams; // Pointer to First Sampler State in array
6366 for (i = 0; i < iSamplers; i++, pSamplerStateParams++,
6367 pPtrSampler += pRenderHal->pHwSizes->dwSizeSamplerState)
6368 {
6369 PrintSamplerParams(i, pSamplerStateParams);
6370 if (pSamplerStateParams->bInUse)
6371 {
6372 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pOsInterface->pfnSetCmdBufferDebugInfo(
6373 pRenderHal->pOsInterface,
6374 true, //bSamplerState
6375 false, //bSurfaceState
6376 i,
6377 pSamplerStateParams->SamplerType));
6378
6379 switch (pSamplerStateParams->SamplerType)
6380 {
6381 case MHW_SAMPLER_TYPE_3D:
6382 eStatus = pRenderHal->pMhwStateHeap->SetSamplerState(pPtrSampler, pSamplerStateParams);
6383 break;
6384 case MHW_SAMPLER_TYPE_AVS:
6385 eStatus = pRenderHal->pMhwStateHeap->SetSamplerState(pPtrSamplerAvs, pSamplerStateParams);
6386 pPtrSamplerAvs += pRenderHal->dwSamplerAvsIncrement;
6387 break;
6388 default:
6389 eStatus = MOS_STATUS_INVALID_PARAMETER;
6390 MHW_RENDERHAL_ASSERTMESSAGE("Unknown Sampler Type.");
6391 break;
6392 }
6393
6394 if (MOS_FAILED(eStatus))
6395 {
6396 MHW_RENDERHAL_ASSERTMESSAGE("Failed to setup Sampler");
6397 goto finish;
6398 }
6399 }
6400 }
6401
6402 eStatus = MOS_STATUS_SUCCESS;
6403
6404 finish:
6405 MHW_RENDERHAL_ASSERT(eStatus == MOS_STATUS_SUCCESS);
6406 return eStatus;
6407 }
6408
6409 //!
6410 //! \brief Setup Surface State
6411 //! \details Setup Surface States
6412 //! \param PRENDERHAL_INTERFACE pRenderHal
6413 //! [in] Pointer to Hardware Interface Structure
6414 //! \param PRENDERHAL_SURFACE pRenderHalSurface
6415 //! [in] Pointer to Render Hal Surface
6416 //! \param PRENDERHAL_SURFACE_STATE_PARAMS pParams
6417 //! [in] Pointer to Surface State Params
6418 //! \param int32_t *piNumEntries
6419 //! [out] Pointer to Number of Surface State Entries (Num Planes)
6420 //! \param PRENDERHAL_SURFACE_STATE_ENTRY * ppSurfaceEntries
6421 //! [out] Array of Surface State Entries
6422 //! \param PRENDERHAL_OFFSET_OVERRIDE pOffsetOverride
6423 //! [in] If not nullptr, provides adjustments to Y, UV plane offsets,
6424 //! used for kernel in a few cases. nullptr is the most common usage.
6425 //! \return MOS_STATUS
6426 //!
RenderHal_SetupSurfaceState(PRENDERHAL_INTERFACE pRenderHal,PRENDERHAL_SURFACE pRenderHalSurface,PRENDERHAL_SURFACE_STATE_PARAMS pParams,int32_t * piNumEntries,PRENDERHAL_SURFACE_STATE_ENTRY * ppSurfaceEntries,PRENDERHAL_OFFSET_OVERRIDE pOffsetOverride)6427 MOS_STATUS RenderHal_SetupSurfaceState(
6428 PRENDERHAL_INTERFACE pRenderHal,
6429 PRENDERHAL_SURFACE pRenderHalSurface,
6430 PRENDERHAL_SURFACE_STATE_PARAMS pParams,
6431 int32_t *piNumEntries,
6432 PRENDERHAL_SURFACE_STATE_ENTRY *ppSurfaceEntries,
6433 PRENDERHAL_OFFSET_OVERRIDE pOffsetOverride)
6434 {
6435 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
6436
6437 //-----------------------------------------------
6438 MHW_RENDERHAL_CHK_NULL(pRenderHal);
6439 MHW_RENDERHAL_CHK_NULL(pRenderHal->pRenderHalPltInterface);
6440 //-----------------------------------------------
6441
6442 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pRenderHalPltInterface->SetupSurfaceState(
6443 pRenderHal, pRenderHalSurface, pParams, piNumEntries, ppSurfaceEntries, pOffsetOverride));
6444 finish:
6445 return eStatus;
6446 }
6447
6448 //!
6449 //! \brief Get offset and/or pointer to sampler state
6450 //! \details Get offset and/or pointer to sampler state in General State Heap
6451 //! \param PRENDERHAL_INTERFACE pRenderHal
6452 //! [in] Pointer to RenderHal Interface
6453 //! \param int32_t iMediaID
6454 //! [in] Media ID associated with sampler
6455 //! \param int32_t iSamplerID
6456 //! [in] Sampler ID
6457 //! \param uint32_t *pdwSamplerOffset
6458 //! [out] optional; offset of sampler state from GSH base
6459 //! \param void **ppSampler
6460 //! [out] optional; pointer to sampler state in GSH
6461 //! \return MOS_STATUS
6462 //!
RenderHal_GetSamplerOffsetAndPtr(PRENDERHAL_INTERFACE pRenderHal,int32_t iMediaID,int32_t iSamplerID,PMHW_SAMPLER_STATE_PARAM pSamplerParams,uint32_t * pdwSamplerOffset,void ** ppSampler)6463 MOS_STATUS RenderHal_GetSamplerOffsetAndPtr(
6464 PRENDERHAL_INTERFACE pRenderHal,
6465 int32_t iMediaID,
6466 int32_t iSamplerID,
6467 PMHW_SAMPLER_STATE_PARAM pSamplerParams,
6468 uint32_t *pdwSamplerOffset,
6469 void **ppSampler)
6470 {
6471 PRENDERHAL_STATE_HEAP pStateHeap;
6472 uint32_t dwOffset = 0;
6473 MHW_SAMPLER_ELEMENT_TYPE ElementType;
6474 MHW_SAMPLER_TYPE SamplerType;
6475 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
6476 uint32_t ElementSize[MHW_SamplerTotalElements] = {1, 2, 4, 8, 64, 128};
6477
6478 MHW_RENDERHAL_CHK_NULL(pRenderHal);
6479 MHW_RENDERHAL_CHK_NULL(pRenderHal->pStateHeap);
6480 MHW_RENDERHAL_CHK_NULL(pRenderHal->pHwSizes);
6481 pStateHeap = pRenderHal->pStateHeap;
6482
6483 MHW_RENDERHAL_CHK_NULL(pStateHeap->pCurMediaState);
6484 MHW_RENDERHAL_CHK_NULL(pStateHeap->pGshBuffer);
6485 MHW_ASSERT(iMediaID < pRenderHal->StateHeapSettings.iMediaIDs);
6486 MHW_ASSERT(iSamplerID < pRenderHal->StateHeapSettings.iSamplers);
6487 MHW_RENDERHAL_CHK_NULL(pSamplerParams);
6488
6489 ElementType = pSamplerParams->ElementType;
6490 SamplerType = (pSamplerParams) ? pSamplerParams->SamplerType : MHW_SAMPLER_TYPE_3D;
6491
6492 if (SamplerType == MHW_SAMPLER_TYPE_VME)
6493 {
6494 dwOffset = pStateHeap->pCurMediaState->dwOffset + // Offset to current media state base
6495 pStateHeap->dwOffsetSampler + // Go to base of the sampler area
6496 iMediaID * pStateHeap->dwSizeSampler + // Go to base of media ID's sampler area
6497 iSamplerID * pRenderHal->pHwSizes->dwSizeSamplerState; // Goto to "samplerID" sampler state
6498 }
6499 else
6500 {
6501 switch (ElementType)
6502 {
6503 case MHW_Sampler1Element:
6504 case MHW_Sampler4Elements:
6505 {
6506 dwOffset = pStateHeap->pCurMediaState->dwOffset + // Offset to current media state base
6507 pStateHeap->dwOffsetSampler + // Go to base of the sampler area
6508 iMediaID * pStateHeap->dwSizeSampler + // Go to base of media ID's sampler area
6509 iSamplerID * pRenderHal->pHwSizes->dwSizeSamplerState; // Goto to "samplerID" sampler state
6510 if (pSamplerParams)
6511 {
6512 pSamplerParams->Unorm.IndirectStateOffset =
6513 pStateHeap->pCurMediaState->dwOffset + // Offset to current media state base
6514 pStateHeap->dwOffsetSamplerIndirect + // Go to base of the sampler indirect area
6515 iMediaID * pStateHeap->dwSizeSampler + // Go to base of media ID's sampler area
6516 iSamplerID * pRenderHal->pHwSizes->dwSizeSamplerIndirectState; // Goto to "samplerID" sampler indirect state
6517 pSamplerParams->Unorm.pIndirectState = (void *)(pStateHeap->pGshBuffer + pSamplerParams->Unorm.IndirectStateOffset);
6518 }
6519 break;
6520 }
6521 case MHW_Sampler2Elements:
6522 case MHW_Sampler8Elements:
6523 dwOffset = pStateHeap->pCurMediaState->dwOffset + // Offset to current media state base
6524 pStateHeap->dwOffsetSampler + // Go to base of the sampler area
6525 iMediaID * pStateHeap->dwSizeSampler + // Go to base of media ID's sampler area
6526 iSamplerID * ElementSize[ElementType] * 16; // Goto to "samplerID" sampler state
6527 break;
6528
6529 case MHW_Sampler64Elements:
6530 dwOffset = pStateHeap->pCurMediaState->dwOffset + // Offset to current media state base
6531 pStateHeap->dwOffsetSampler + // Go to base of the sampler area
6532 iMediaID * pStateHeap->dwSizeSampler + // Go to base of media ID's sampler area
6533 iSamplerID * 32 * 16; // Goto to "samplerID" sampler state
6534 break;
6535
6536 case MHW_Sampler128Elements:
6537 if (pRenderHal->pRenderHalPltInterface->IsSampler128ElementsSupported())
6538 {
6539 dwOffset = pStateHeap->pCurMediaState->dwOffset + // Offset to current media state base
6540 pStateHeap->dwOffsetSampler + // Go to base of the sampler area
6541 iMediaID * pStateHeap->dwSizeSampler + // Go to base of media ID's sampler area
6542 iSamplerID * ElementSize[ElementType] * 16; // Goto to "samplerID" sampler state
6543 } else
6544 {
6545 MHW_RENDERHAL_NORMALMESSAGE("Platform doesn't have any 128 element sampler, quit!");
6546 eStatus = MOS_STATUS_INVALID_PARAMETER;
6547 }
6548 break;
6549 default:
6550 MHW_RENDERHAL_NORMALMESSAGE("Failed to parse sampler - invalid sampler type.");
6551 eStatus = MOS_STATUS_INVALID_PARAMETER;
6552 break;
6553 }
6554 }
6555 if (pdwSamplerOffset)
6556 {
6557 *pdwSamplerOffset = dwOffset;
6558 }
6559
6560 if (ppSampler)
6561 {
6562 *ppSampler = (void *)(pStateHeap->pGshBuffer + dwOffset);
6563 }
6564
6565 finish:
6566 return eStatus;
6567 }
6568
6569 //!
6570 //! \brief Checks how per thread scratch space size bits in VFE state are interpreted by HW
6571 //! \details For BDW GT1/2/3 A0 steppings, per thread scratch space size in VFE state
6572 //! is 11 bits indicating [2k bytes, 2 Mbytes]: 0=2k, 1=4k, 2=8k � 10=2M
6573 //! BDW+ excluding A0 step is 12 bits indicating [1k bytes, 2 Mbytes]: 0=1k, 1=2k, 2=4k, 3=8k � 11=2M
6574 //! \param PRENDERHAL_INTERFACE pRenderHal
6575 //! [in] Pointer to RenderHal interface
6576 //! \return true if BDW A0 stepping, false otherwise
6577 //!
RenderHal_PerThreadScratchSpaceStart2K(PRENDERHAL_INTERFACE pRenderHal)6578 bool RenderHal_PerThreadScratchSpaceStart2K(
6579 PRENDERHAL_INTERFACE pRenderHal)
6580 {
6581 if (pRenderHal == nullptr || pRenderHal->pRenderHalPltInterface == nullptr)
6582 {
6583 MHW_RENDERHAL_ASSERTMESSAGE("Invalid (nullptr) Pointer.");
6584 return false;
6585 }
6586
6587 return pRenderHal->pRenderHalPltInterface->PerThreadScratchSpaceStart2K(pRenderHal);
6588 }
6589
6590 //!
6591 //! \brief Encode SLM Size for Interface Descriptor
6592 //! \details Setup SLM size
6593 //! \param PRENDERHAL_INTERFACE pRenderHal
6594 //! [in] Pointer to RenderHal interface
6595 //! \param uint32_t SLMSize
6596 //! [in] SLM size in 1K
6597 //! \return encoded output
6598 //!
RenderHal_EncodeSLMSize(PRENDERHAL_INTERFACE pRenderHal,uint32_t SLMSize)6599 uint32_t RenderHal_EncodeSLMSize(
6600 PRENDERHAL_INTERFACE pRenderHal,
6601 uint32_t SLMSize)
6602 {
6603 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
6604 if (pRenderHal == nullptr || pRenderHal->pRenderHalPltInterface == nullptr)
6605 {
6606 MHW_RENDERHAL_ASSERTMESSAGE("Invalid (nullptr) Pointer.");
6607 return 0;
6608 }
6609
6610 return pRenderHal->pRenderHalPltInterface->EncodeSLMSize(SLMSize);
6611 }
6612
6613 //!
6614 //! \brief Set Chroma Direction
6615 //! \details Setup Chroma Direction
6616 //! \param PRENDERHAL_INTERFACE pRenderHal
6617 //! [in] Pointer to Hardware Interface
6618 //! \param PRENDERHAL_SURFACE pRenderHalSurface
6619 //! [in] Pointer to Render Hal Surface
6620 //! \return uint8_t
6621 //!
RenderHal_SetChromaDirection(PRENDERHAL_INTERFACE pRenderHal,PRENDERHAL_SURFACE pRenderHalSurface)6622 uint8_t RenderHal_SetChromaDirection(
6623 PRENDERHAL_INTERFACE pRenderHal,
6624 PRENDERHAL_SURFACE pRenderHalSurface)
6625 {
6626 if (pRenderHal == nullptr || pRenderHal->pRenderHalPltInterface == nullptr)
6627 {
6628 MHW_RENDERHAL_ASSERTMESSAGE("Invalid (nullptr) Pointer.");
6629 return false;
6630 }
6631
6632 return pRenderHal->pRenderHalPltInterface->SetChromaDirection(pRenderHal, pRenderHalSurface);
6633 }
6634
6635 //!
6636 //! \brief Convert To Nano Seconds
6637 //! \details Convert to Nano Seconds
6638 //! \param PRENDERHAL_INTERFACE pRenderHal
6639 //! [in] Pointer to Hardware Interface Structure
6640 //! \param uint64_t iTicks
6641 //! [in] Ticks
6642 //! \param uint64_t *piNs
6643 //! [in] Nano Seconds
6644 //! \return void
6645 //!
RenderHal_ConvertToNanoSeconds(PRENDERHAL_INTERFACE pRenderHal,uint64_t iTicks,uint64_t * piNs)6646 void RenderHal_ConvertToNanoSeconds(
6647 PRENDERHAL_INTERFACE pRenderHal,
6648 uint64_t iTicks,
6649 uint64_t *piNs)
6650 {
6651 if (pRenderHal == nullptr || pRenderHal->pRenderHalPltInterface == nullptr)
6652 {
6653 MHW_RENDERHAL_ASSERTMESSAGE("Invalid (nullptr) Pointer.");
6654 return;
6655 }
6656 pRenderHal->pRenderHalPltInterface->ConvertToNanoSeconds(pRenderHal, iTicks, piNs);
6657 }
6658
6659 //!
6660 //! \brief Enables L3 cacheing flag and sets related registers/values
6661 //! \param PRENDERHAL_INTERFACE pRenderHal
6662 //! [in] Pointer to Hardware Interface
6663 //! \param pCacheSettings
6664 //! [in] L3 Cache Configurations
6665 //! \return MOS_STATUS
6666 //! MOS_STATUS_SUCCESS if success, else fail reason
6667 //!
RenderHal_EnableL3Caching(PRENDERHAL_INTERFACE pRenderHal,PRENDERHAL_L3_CACHE_SETTINGS pCacheSettings)6668 MOS_STATUS RenderHal_EnableL3Caching(
6669 PRENDERHAL_INTERFACE pRenderHal,
6670 PRENDERHAL_L3_CACHE_SETTINGS pCacheSettings)
6671 {
6672 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
6673 MHW_RENDERHAL_CHK_NULL(pRenderHal);
6674 MHW_RENDERHAL_CHK_NULL(pRenderHal->pRenderHalPltInterface);
6675
6676 MHW_RENDERHAL_CHK_STATUS( pRenderHal->pRenderHalPltInterface->EnableL3Caching(pRenderHal, pCacheSettings));
6677 finish:
6678 return eStatus;
6679 }
6680
6681 //!
6682 //! \brief Set L3 cache override config parameters
6683 //! \param [in] pRenderHal
6684 //! Pointer to RenderHal Interface Structure
6685 //! \param [in,out] pCacheSettings
6686 //! Pointer to pCacheSettings
6687 //! \param [in] bEnableSLM
6688 //! Flag to enable SLM
6689 //! \return MOS_STATUS
6690 //! MOS_STATUS_SUCCESS if success. Error code otherwise
6691 //!
RenderHal_SetCacheOverrideParams(PRENDERHAL_INTERFACE pRenderHal,PRENDERHAL_L3_CACHE_SETTINGS pCacheSettings,bool bEnableSLM)6692 MOS_STATUS RenderHal_SetCacheOverrideParams(
6693 PRENDERHAL_INTERFACE pRenderHal,
6694 PRENDERHAL_L3_CACHE_SETTINGS pCacheSettings,
6695 bool bEnableSLM)
6696 {
6697 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
6698
6699 MHW_RENDERHAL_CHK_NULL(pRenderHal);
6700 MHW_RENDERHAL_CHK_NULL(pRenderHal->pRenderHalPltInterface);
6701
6702 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pRenderHalPltInterface->SetCacheOverrideParams(
6703 pRenderHal,
6704 pCacheSettings,
6705 bEnableSLM)
6706 );
6707
6708 pCacheSettings->bOverride =
6709 pCacheSettings->bCntlRegOverride ||
6710 pCacheSettings->bCntlReg2Override ||
6711 pCacheSettings->bCntlReg3Override ||
6712 pCacheSettings->bLra1RegOverride ||
6713 pCacheSettings->bSqcReg1Override;
6714
6715 finish:
6716 return eStatus;
6717 }
6718
6719 //!
6720 //! \brief Send Surface State Entry
6721 //! \param [in] pRenderHal
6722 //! pointer to render hal
6723 //! \param [in] pCmdBuffer
6724 //! pointer to command buffer
6725 //! \param [in] pParams
6726 //! pointer to surface state send parameters
6727 //! \return MOS_STATUS
6728 //! MOS_STATUS_SUCCESS if success, else fail reason
6729 //!
RenderHal_SendSurfaceStateEntry(PRENDERHAL_INTERFACE pRenderHal,PMOS_COMMAND_BUFFER pCmdBuffer,PMHW_SURFACE_STATE_SEND_PARAMS pParams)6730 MOS_STATUS RenderHal_SendSurfaceStateEntry(
6731 PRENDERHAL_INTERFACE pRenderHal,
6732 PMOS_COMMAND_BUFFER pCmdBuffer,
6733 PMHW_SURFACE_STATE_SEND_PARAMS pParams)
6734 {
6735 //-----------------------------------------------
6736 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
6737 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal->pOsInterface);
6738 MHW_RENDERHAL_CHK_NULL_RETURN(pCmdBuffer);
6739 MHW_RENDERHAL_CHK_NULL_RETURN(pParams);
6740 //-----------------------------------------------
6741
6742 PMOS_INTERFACE pOsInterface = pRenderHal->pOsInterface;
6743 uint8_t *pSurfaceState = pParams->pSurfaceStateSource;
6744 int32_t iSurfaceStateOffset = pParams->iSurfaceStateOffset;
6745 int32_t iIndirectStateBase = pParams->iIndirectStateBase;
6746
6747 SURFACE_STATE_TOKEN_COMMON *pSurfaceStateToken = (SURFACE_STATE_TOKEN_COMMON*)pParams->pSurfaceToken;
6748
6749 uint32_t* pdwCmd = (uint32_t*)(pParams->pIndirectStateBase + iSurfaceStateOffset);
6750 uint32_t locationInCmd = 0;
6751
6752 // Copy surface state from system memory to graphics memory/indirect state
6753 if (pSurfaceStateToken->DW3.SurfaceStateType == MEDIASTATE_BTS_DEFAULT_TYPE)
6754 {
6755 MOS_SecureMemcpy(pdwCmd, pRenderHal->pHwSizes->dwSizeSurfaceState,
6756 pSurfaceState, pRenderHal->pHwSizes->dwSizeSurfaceState);
6757
6758 // Patch offset is 8 DW from the surface state base
6759 pdwCmd += 8;
6760 iSurfaceStateOffset += 8 * sizeof(uint32_t);
6761 locationInCmd = 8;
6762 }
6763 else
6764 {
6765 MOS_SecureMemcpy(pdwCmd, pRenderHal->pHwSizes->dwSizeSurfaceStateAvs,
6766 pSurfaceState, pRenderHal->pHwSizes->dwSizeSurfaceStateAvs);
6767
6768 // Patch offset is 6 DW from the surface state base
6769 pdwCmd += 6;
6770 iSurfaceStateOffset += 6 * sizeof(uint32_t);
6771 locationInCmd = 6;
6772 }
6773
6774 if (pOsInterface->bUsesGfxAddress)
6775 {
6776 *pdwCmd = pSurfaceStateToken->DW4.SurfaceBaseAddress;
6777 *(pdwCmd + 1) = pSurfaceStateToken->DW5.SurfaceBaseAddress64;
6778 }
6779
6780 if (pSurfaceStateToken->pResourceInfo)
6781 {
6782 HalOcaInterface::DumpResourceInfo(*pCmdBuffer, *pOsInterface, *(PMOS_RESOURCE)(pSurfaceStateToken->pResourceInfo), (MOS_HW_COMMAND)pSurfaceStateToken->DW0.DriverID,
6783 locationInCmd, 0);
6784 }
6785
6786 MOS_PATCH_ENTRY_PARAMS PatchEntryParams;
6787
6788 uint8_t *pbPtrCmdBuf = (uint8_t *)pCmdBuffer->pCmdBase;
6789
6790 MOS_ZeroMemory(&PatchEntryParams, sizeof(PatchEntryParams));
6791 PatchEntryParams.uiAllocationIndex = pSurfaceStateToken->DW1.SurfaceAllocationIndex;
6792 PatchEntryParams.uiResourceOffset = pSurfaceStateToken->DW2.SurfaceOffset;
6793 PatchEntryParams.uiPatchOffset = iIndirectStateBase + iSurfaceStateOffset;
6794 PatchEntryParams.bWrite = pSurfaceStateToken->DW3.RenderTargetEnable;
6795 PatchEntryParams.HwCommandType = (MOS_HW_COMMAND)pSurfaceStateToken->DW0.DriverID;
6796 PatchEntryParams.forceDwordOffset = 0;
6797 PatchEntryParams.cmdBufBase = pbPtrCmdBuf;
6798 PatchEntryParams.presResource = (PMOS_RESOURCE)pSurfaceStateToken->pResourceInfo;
6799
6800 // Set patch for surface state address
6801 pOsInterface->pfnSetPatchEntry(
6802 pOsInterface,
6803 &PatchEntryParams);
6804
6805 MOS_MEMCOMP_STATE mmcMode = MOS_MEMCOMP_DISABLED;
6806 PMOS_RESOURCE pMosResource = (PMOS_RESOURCE)pSurfaceStateToken->pResourceInfo;
6807 MHW_RENDERHAL_CHK_NULL_RETURN(pMosResource);
6808 if (pOsInterface->pfnGetMemoryCompressionMode)
6809 {
6810 pOsInterface->pfnGetMemoryCompressionMode(pOsInterface, pMosResource, &mmcMode);
6811 }
6812
6813 if (mmcMode == MOS_MEMCOMP_RC && pSurfaceStateToken->DW3.SurfaceStateType == MEDIASTATE_BTS_DEFAULT_TYPE)
6814 {
6815 # if !EMUL
6816 if (pOsInterface->bUsesGfxAddress)
6817 {
6818 uint64_t ui64GfxAddress = 0;
6819 ui64GfxAddress |= (uint64_t)(pSurfaceStateToken->DW5.SurfaceBaseAddress64 & 0x0000FFFF) << 32;
6820 ui64GfxAddress |= (uint64_t)(pSurfaceStateToken->DW4.SurfaceBaseAddress);
6821 pdwCmd = (uint32_t*)(pParams->pIndirectStateBase + pParams->iSurfaceStateOffset); //point to the start of current RENDER_SURFACE_STATE_CMD
6822
6823 if (pMosResource->pGmmResInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CCS))
6824 {
6825 // Set GFX address of AuxiliarySurfaceBaseAddress
6826 uint64_t auxAddress = ui64GfxAddress + (uint64_t)pMosResource->pGmmResInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CCS);
6827 *(pdwCmd + 10) = (*(pdwCmd + 10) & 0x00000FFF) | (uint32_t)(auxAddress & 0x00000000FFFFF000);
6828 *(pdwCmd + 11) = *(pdwCmd + 11) | (uint32_t)((auxAddress & 0x0000FFFF00000000) >> 32);
6829 }
6830
6831 if (pMosResource->pGmmResInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CC))
6832 {
6833 // Set GFX address of ClearAddress
6834 uint64_t clearAddress = ui64GfxAddress + (uint32_t)pMosResource->pGmmResInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CC);
6835 *(pdwCmd + 12) = (*(pdwCmd + 12) & 0x0000001F) | (uint32_t)(clearAddress & 0x00000000FFFFFFE0);
6836 *(pdwCmd + 13) = *(pdwCmd + 13) | (uint32_t)((clearAddress & 0x0000FFFF00000000) >> 32);
6837 }
6838 }
6839 else
6840 {
6841 // Set patch for AuxiliarySurfaceBaseAddress
6842 MOS_ZeroMemory(&PatchEntryParams, sizeof(PatchEntryParams));
6843 PatchEntryParams.uiAllocationIndex = pSurfaceStateToken->DW1.SurfaceAllocationIndex;
6844 PatchEntryParams.uiResourceOffset = pSurfaceStateToken->DW2.SurfaceOffset
6845 + (uint32_t)pMosResource->pGmmResInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CCS);
6846 PatchEntryParams.uiPatchOffset = iIndirectStateBase + pParams->iSurfaceStateOffset + 10 * sizeof(uint32_t);
6847 PatchEntryParams.bWrite = pSurfaceStateToken->DW3.RenderTargetEnable;
6848 PatchEntryParams.HwCommandType = (MOS_HW_COMMAND)pSurfaceStateToken->DW0.DriverID;
6849 PatchEntryParams.forceDwordOffset = 0;
6850 PatchEntryParams.cmdBufBase = pbPtrCmdBuf;
6851 PatchEntryParams.presResource = (PMOS_RESOURCE)pSurfaceStateToken->pResourceInfo;
6852 pOsInterface->pfnSetPatchEntry(pOsInterface, &PatchEntryParams);
6853
6854 // Set patch for ClearAddress
6855 MOS_ZeroMemory(&PatchEntryParams, sizeof(PatchEntryParams));
6856 PatchEntryParams.uiAllocationIndex = pSurfaceStateToken->DW1.SurfaceAllocationIndex;
6857 PatchEntryParams.uiResourceOffset = pSurfaceStateToken->DW2.SurfaceOffset
6858 + (uint32_t)pMosResource->pGmmResInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CC);
6859 PatchEntryParams.uiPatchOffset = iIndirectStateBase + pParams->iSurfaceStateOffset + 12 * sizeof(uint32_t);
6860 PatchEntryParams.bWrite = pSurfaceStateToken->DW3.RenderTargetEnable;
6861 PatchEntryParams.HwCommandType = (MOS_HW_COMMAND)pSurfaceStateToken->DW0.DriverID;
6862 PatchEntryParams.forceDwordOffset = 0;
6863 PatchEntryParams.cmdBufBase = pbPtrCmdBuf;
6864 PatchEntryParams.presResource = (PMOS_RESOURCE)pSurfaceStateToken->pResourceInfo;
6865 pOsInterface->pfnSetPatchEntry(pOsInterface, &PatchEntryParams);
6866 }
6867 #endif
6868 }
6869
6870 return MOS_STATUS_SUCCESS;
6871 }
6872
6873 //!
6874 //! \brief Init Special Interface
6875 //! \details Initializes RenderHal Interface structure, responsible for HW
6876 //! abstraction of HW Rendering Engine for CM(MDF) and VP.
6877 //! \param PRENDERHAL_INTERFACE pRenderHal
6878 //! [in] Pointer to RenderHal Interface Structure
6879 //!
6880 void RenderHal_InitInterfaceEx(PRENDERHAL_INTERFACE pRenderHal);
6881
6882 //!
6883 //! \brief Init Interface
6884 //! \details Initializes RenderHal Interface structure, responsible for HW
6885 //! abstraction of HW Rendering Engine for CM(MDF) and VP.
6886 //! \param PRENDERHAL_INTERFACE pRenderHal
6887 //! [in] Pointer to RenderHal Interface Structure
6888 //! \param MhwCpInterface** ppCpInterface
6889 //! [in/out] Pointer of pointer to MHW CP Interface Structure, which
6890 //! is created during renderhal initialization
6891 //! \param PMOS_INTERFACE pOsInterface
6892 //! [in] Pointer to OS Interface Structure
6893 //! \return MOS_STATUS
6894 //! MOS_STATUS_UNKNOWN : Invalid parameters
6895 //!
RenderHal_InitInterface(PRENDERHAL_INTERFACE pRenderHal,MhwCpInterface ** ppCpInterface,PMOS_INTERFACE pOsInterface)6896 MOS_STATUS RenderHal_InitInterface(
6897 PRENDERHAL_INTERFACE pRenderHal,
6898 MhwCpInterface **ppCpInterface,
6899 PMOS_INTERFACE pOsInterface)
6900 {
6901 PMOS_USER_FEATURE_INTERFACE pUserFeatureInterface = nullptr;
6902 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
6903 MHW_VFE_PARAMS *pVfeStateParams = nullptr;
6904
6905 //---------------------------------------
6906 MHW_RENDERHAL_CHK_NULL_RETURN(pRenderHal);
6907 MHW_RENDERHAL_CHK_NULL_RETURN(ppCpInterface);
6908 MHW_RENDERHAL_CHK_NULL_RETURN(pOsInterface);
6909 //---------------------------------------
6910
6911 // Basic initialization
6912 pRenderHal->pOsInterface = pOsInterface;
6913
6914 pRenderHal->bKerneltimeDump = false;
6915 MOS_ZeroMemory(&pRenderHal->kernelTime, sizeof(pRenderHal->kernelTime));
6916
6917 pOsInterface->pfnGetPlatform(pOsInterface, &pRenderHal->Platform);
6918
6919 pRenderHal->pSkuTable = pOsInterface->pfnGetSkuTable(pOsInterface);
6920 pRenderHal->pWaTable = pOsInterface->pfnGetWaTable(pOsInterface);
6921
6922 // create mhw interfaces including mhw_render, cp, and mi
6923 MhwInterfaces::CreateParams params;
6924 MOS_ZeroMemory(¶ms, sizeof(params));
6925 params.Flags.m_render = true;
6926 params.m_heapMode = pRenderHal->bDynamicStateHeap;
6927 MhwInterfaces *mhwInterfaces = MhwInterfaces::CreateFactory(params, pOsInterface);
6928 MHW_RENDERHAL_CHK_NULL(mhwInterfaces);
6929 MHW_RENDERHAL_CHK_NULL(mhwInterfaces->m_cpInterface);
6930 MHW_RENDERHAL_CHK_NULL(mhwInterfaces->m_miInterface);
6931 MHW_RENDERHAL_CHK_NULL(mhwInterfaces->m_renderInterface);
6932 pRenderHal->pCpInterface = mhwInterfaces->m_cpInterface;
6933 pRenderHal->pMhwMiInterface = mhwInterfaces->m_miInterface;
6934 pRenderHal->pMhwRenderInterface = mhwInterfaces->m_renderInterface;
6935
6936 MOS_Delete(mhwInterfaces);
6937
6938 // Set Cp Interface
6939 *ppCpInterface = pRenderHal->pCpInterface;
6940
6941 // Initialize MHW State Heap Interface
6942 // Note: there are two pStateHeapInterface in below line. First one is pointer to legacy MHW_STATE_HEAP
6943 // sturcture, while the last one points to the new class.
6944 if (pRenderHal->pMhwRenderInterface->m_stateHeapInterface != nullptr)
6945 {
6946 pRenderHal->pMhwStateHeap = pRenderHal->pMhwRenderInterface->m_stateHeapInterface->pStateHeapInterface;
6947 }
6948
6949 pRenderHal->pHwCaps = pRenderHal->pMhwRenderInterface->GetHwCaps();
6950
6951 pRenderHal->pHwSizes = pRenderHal->pMhwStateHeap->GetHwSizesPointer();
6952
6953 pRenderHal->dwTimeoutMs = RENDERHAL_TIMEOUT_MS_DEFAULT;
6954 pRenderHal->iMaxPalettes = RENDERHAL_PALETTE_MAX;
6955 pRenderHal->iMaxPaletteEntries = RENDERHAL_PALETTE_ENTRIES_MAX;
6956 pRenderHal->iMaxChromaKeys = RENDERHAL_CHROMA_KEY_MAX;
6957
6958 //set MDF load to default value false
6959 pRenderHal->IsMDFLoad = false;
6960
6961 //set AVS to default value false
6962 pRenderHal->bIsAVS = false;
6963
6964 pRenderHal->iChromaKeyCount = 0;
6965 for (int i = 0; i < pRenderHal->iMaxChromaKeys; i++)
6966 {
6967 pRenderHal->ChromaKey[i].dwIndex = i;
6968 }
6969
6970 // Read VDI Walker Regkey once during initialization
6971 MOS_USER_FEATURE_VALUE_DATA userFeatureValueData;
6972
6973 MOS_ZeroMemory(&userFeatureValueData, sizeof(userFeatureValueData));
6974 userFeatureValueData.u32Data = true; // Init as default value
6975 userFeatureValueData.i32DataFlag = MOS_USER_FEATURE_VALUE_DATA_FLAG_CUSTOM_DEFAULT_VALUE_TYPE;
6976 #if (_DEBUG || _RELEASE_INTERNAL)
6977 MOS_UserFeature_ReadValue_ID(
6978 nullptr,
6979 __MEDIA_USER_FEATURE_VALUE_VDI_MODE_ID,
6980 &userFeatureValueData,
6981 pOsInterface->pOsContext);
6982 #endif
6983 pRenderHal->bVDIWalker = userFeatureValueData.u32Data ? true : false;
6984
6985 MOS_ZeroMemory(&userFeatureValueData, sizeof(userFeatureValueData));
6986 userFeatureValueData.u32Data = MHW_WALKER_MODE_NOT_SET; // Init as default value
6987 userFeatureValueData.i32DataFlag = MOS_USER_FEATURE_VALUE_DATA_FLAG_CUSTOM_DEFAULT_VALUE_TYPE;
6988 #if (_DEBUG || _RELEASE_INTERNAL)
6989 // Read Media Walker Mode from RegKey once in initialization
6990 MOS_UserFeature_ReadValue_ID(
6991 nullptr,
6992 __MEDIA_USER_FEATURE_VALUE_MEDIA_WALKER_MODE_ID,
6993 &userFeatureValueData,
6994 pOsInterface->pOsContext);
6995 #endif
6996 pRenderHal->MediaWalkerMode = (MHW_WALKER_MODE)userFeatureValueData.u32Data;
6997
6998 pRenderHal->pPlaneDefinitions = g_cRenderHal_SurfacePlanes;
6999
7000 // disable RenderHal kernel debugging.
7001 pRenderHal->bIsaAsmDebugEnable = false;
7002
7003 pRenderHal->iMaxPalettes = RENDERHAL_PALETTE_COUNT;
7004 pRenderHal->iMaxPaletteEntries = RENDERHAL_PALETTE_ENTRIES;
7005 pRenderHal->iMaxChromaKeys = RENDERHAL_CHROMA_KEY_COUNT;
7006
7007 MOS_ZeroMemory(&pRenderHal->PredicationParams, sizeof(pRenderHal->PredicationParams));
7008 MOS_ZeroMemory(&pRenderHal->SetMarkerParams, sizeof(pRenderHal->SetMarkerParams));
7009
7010 // CMFC CSC Coefficient Surface update
7011 pRenderHal->bCmfcCoeffUpdate = false;
7012 pRenderHal->iKernelAllocationID = RENDERHAL_KERNEL_LOAD_FAIL;
7013 pRenderHal->pCmfcCoeffSurface = nullptr;
7014
7015 // Initialization/Cleanup function
7016 pRenderHal->pfnInitialize = RenderHal_Initialize;
7017 pRenderHal->pfnDestroy = RenderHal_Destroy;
7018
7019 // Allocate/Destroy state heaps
7020 pRenderHal->pfnAllocateStateHeaps = RenderHal_AllocateStateHeaps;
7021 pRenderHal->pfnFreeStateHeaps = RenderHal_FreeStateHeaps;
7022
7023 // Slice Shutdown Mode
7024 pRenderHal->pfnSetSliceShutdownMode = RenderHal_SetSliceShutdownMode;
7025 pRenderHal->pfnSetPowerOptionMode = RenderHal_SetPowerOptionMode;
7026
7027 // Preemption
7028 pRenderHal->pfnEnableGpgpuMiddleBatchBufferPreemption =
7029 RenderHal_EnableGpgpuMiddleBatchBufferPreemption;
7030 pRenderHal->pfnEnableGpgpuMiddleThreadPreemption =
7031 RenderHal_EnableGpgpuMiddleThreadPreemption;
7032
7033 // Surface State and Binding Table management functions
7034 pRenderHal->pfnSetSurfacesPerBT = RenderHal_SetSurfacesPerBT;
7035 pRenderHal->pfnGetSurfaceStateEntries = RenderHal_GetSurfaceStateEntries;
7036 pRenderHal->pfnAssignSurfaceState = RenderHal_AssignSurfaceState;
7037 pRenderHal->pfnGetAlignUnit = RenderHal_GetAlignUnit;
7038 pRenderHal->pfnAdjustBoundary = RenderHal_AdjustBoundary;
7039 pRenderHal->pfnAssignBindingTable = RenderHal_AssignBindingTable;
7040 pRenderHal->pfnSetupBufferSurfaceState = RenderHal_SetupBufferSurfaceState;
7041 pRenderHal->pfnSetupSurfaceStatesOs = RenderHal_SetupSurfaceStatesOs;
7042 pRenderHal->pfnBindSurfaceState = RenderHal_BindSurfaceState;
7043 pRenderHal->pfnSendSurfaces = RenderHal_SendSurfaces_PatchList;
7044 pRenderHal->pfnSendSurfaceStateEntry = RenderHal_SendSurfaceStateEntry;
7045 pRenderHal->pfnSetSurfaceStateToken = RenderHal_SetSurfaceStateToken;
7046 pRenderHal->pfnSetSurfaceStateBuffer = RenderHal_SetSurfaceStateBuffer;
7047 pRenderHal->pfnCalculateYOffset = RenderHal_CalculateYOffset;
7048
7049 // Media states management functions
7050 pRenderHal->pfnAllocateBB = RenderHal_AllocateBB;
7051 pRenderHal->pfnFreeBB = RenderHal_FreeBB;
7052 pRenderHal->pfnLockBB = RenderHal_LockBB;
7053 pRenderHal->pfnUnlockBB = RenderHal_UnlockBB;
7054 pRenderHal->pfnEnablePalette = RenderHal_EnablePalette;
7055 pRenderHal->pfnGetPaletteEntry = RenderHal_GetPaletteEntry;
7056 pRenderHal->pfnAllocatePaletteID = RenderHal_AllocatePaletteID;
7057 pRenderHal->pfnFreePaletteID = RenderHal_FreePaletteID;
7058 pRenderHal->pfnAllocateChromaKey = RenderHal_AllocateChromaKey;
7059 pRenderHal->pfnAssignMediaState = RenderHal_AssignMediaState;
7060 pRenderHal->pfnAllocateMediaID = RenderHal_AllocateMediaID;
7061 pRenderHal->pfnGetMediaID = RenderHal_GetMediaID;
7062
7063 // Old-style Kernel management functions
7064 pRenderHal->pfnRefreshSync = RenderHal_RefreshSync;
7065 pRenderHal->pfnLoadKernel = RenderHal_LoadKernel;
7066 pRenderHal->pfnUnloadKernel = RenderHal_UnloadKernel;
7067 pRenderHal->pfnResetKernels = RenderHal_ResetKernels;
7068 pRenderHal->pfnTouchKernel = RenderHal_TouchKernel;
7069 pRenderHal->pfnGetKernelOffset = RenderHal_GetKernelOffset;
7070
7071 // ISA ASM Debug support functions
7072 pRenderHal->pfnLoadDebugKernel = RenderHal_LoadDebugKernel;
7073 pRenderHal->pfnLoadSipKernel = RenderHal_LoadSipKernel;
7074 pRenderHal->pfnSendSipStateCmd = RenderHal_SendSipStateCmd;
7075
7076 // Command buffer programming functions
7077 pRenderHal->pfnLoadCurbeData = RenderHal_LoadCurbeData;
7078 pRenderHal->pfnSendCurbeLoad = RenderHal_SendCurbeLoad;
7079 pRenderHal->pfnSendMediaIdLoad = RenderHal_SendMediaIdLoad;
7080 pRenderHal->pfnSendChromaKey = RenderHal_SendChromaKey;
7081 pRenderHal->pfnSendPalette = RenderHal_SendPalette;
7082 pRenderHal->pfnSendMediaStates = RenderHal_SendMediaStates;
7083 pRenderHal->pfnSendStateBaseAddress = RenderHal_SendStateBaseAddress;
7084
7085 // Initialize OS dependent RenderHal Interfaces common to all platforms
7086 pRenderHal->pfnReset = RenderHal_Reset;
7087 pRenderHal->pfnAssignSshInstance = RenderHal_AssignSshInstance;
7088 pRenderHal->pfnInitCommandBuffer = RenderHal_InitCommandBuffer;
7089 pRenderHal->pfnSendTimingData = RenderHal_SendTimingData;
7090 pRenderHal->pfnSendRcsStatusTag = RenderHal_SendRcsStatusTag;
7091 pRenderHal->pfnSendSyncTag = RenderHal_SendSyncTag;
7092 pRenderHal->pfnSendCscCoeffSurface = RenderHal_SendCscCoeffSurface;
7093
7094 // Tracker tag
7095 pRenderHal->pfnSetupPrologParams = RenderHal_SetupPrologParams;
7096
7097 // InterfaceDescriptor
7098 pRenderHal->pfnSetupInterfaceDescriptor = RenderHal_SetupInterfaceDescriptor;
7099
7100 // Media Walker
7101 pRenderHal->pfnGetMediaWalkerStatus = RenderHal_GetMediaWalkerStatus;
7102
7103 //Surface Memory Object Control
7104 pRenderHal->pfnGetSurfaceMemoryObjectControl
7105 = RenderHal_GetSurfaceMemoryObjectControl;
7106 //Scratch Space
7107 pRenderHal->pfnGetScratchSpaceSize = RenderHal_GetScratchSpaceSize;
7108
7109 // Other states
7110 pRenderHal->pfnSetVfeStateParams = RenderHal_SetVfeStateParams;
7111 pRenderHal->pfnSetSamplerStates = RenderHal_SetSamplerStates;
7112
7113 pRenderHal->pfnIs2PlaneNV12Needed = RenderHal_Is2PlaneNV12Needed;
7114
7115 // Initialize hardware resources for the current Os/Platform
7116 pRenderHal->pRenderHalPltInterface = RenderHalDevice::CreateFactory(pOsInterface);
7117 MHW_RENDERHAL_CHK_NULL(pRenderHal->pRenderHalPltInterface);
7118
7119 // Set the platform-specific fields in renderhal
7120 // Set State Heap settings
7121 pRenderHal->pRenderHalPltInterface->InitStateHeapSettings(pRenderHal);
7122
7123 // Set default / advanced surface types
7124 pRenderHal->pRenderHalPltInterface->InitSurfaceTypes(pRenderHal);
7125
7126 // Set MMC Enabled status
7127 pRenderHal->pRenderHalPltInterface->IsRenderHalMMCEnabled(pRenderHal);
7128
7129 // Set platform dependent parameters
7130 pRenderHal->bHasCombinedAVSSamplerState = true;
7131 pRenderHal->bEnableYV12SinglePass = pRenderHal->pRenderHalPltInterface->IsEnableYV12SinglePass(pRenderHal);
7132 pRenderHal->dwSamplerAvsIncrement = pRenderHal->pRenderHalPltInterface->GetSizeSamplerStateAvs(pRenderHal);
7133 pRenderHal->bComputeContextInUse = pRenderHal->pRenderHalPltInterface->IsComputeContextInUse(pRenderHal);
7134
7135 pRenderHal->dwMaskCrsThdConDataRdLn = (uint32_t) -1;
7136 pRenderHal->dwMinNumberThreadsInGroup = 1;
7137 pRenderHal->dwCurbeBlockAlign = RENDERHAL_CURBE_BLOCK_ALIGN;
7138 pRenderHal->dwScratchSpaceMaxThreads = pRenderHal->pHwCaps->dwMaxThreads;
7139
7140 // Set palette data
7141 for (int i = 0; i < pRenderHal->iMaxPalettes; i++)
7142 {
7143 pRenderHal->Palette[i].iPaletteID = i;
7144 pRenderHal->Palette[i].iNumEntries = 0;
7145 pRenderHal->Palette[i].pPaletteData =
7146 pRenderHal->pRenderHalPltInterface->GetPaletteDataAddress(i);
7147 }
7148
7149 // Set default VFEState Params
7150 pVfeStateParams = pRenderHal->pRenderHalPltInterface->GetVfeStateParameters();
7151 pVfeStateParams->dwDebugCounterControl = MEDIASTATE_DEBUG_COUNTER_FREE_RUNNING;
7152 pVfeStateParams->dwMaximumNumberofThreads = pRenderHal->pHwCaps->dwMaxThreads;
7153
7154 // Hardware dependent calls
7155 pRenderHal->pfnGetSamplerOffsetAndPtr = RenderHal_GetSamplerOffsetAndPtr;
7156 pRenderHal->pfnSetupSurfaceState = RenderHal_SetupSurfaceState;
7157 pRenderHal->pfnEncodeSLMSize = RenderHal_EncodeSLMSize;
7158 pRenderHal->pfnSetChromaDirection = RenderHal_SetChromaDirection;
7159 pRenderHal->pfnEnableL3Caching = RenderHal_EnableL3Caching;
7160 pRenderHal->pfnSetCacheOverrideParams = RenderHal_SetCacheOverrideParams;
7161
7162 // CM specific function
7163 pRenderHal->pfnConvertToNanoSeconds = RenderHal_ConvertToNanoSeconds;
7164
7165 pRenderHal->pfnPerThreadScratchSpaceStart2K = RenderHal_PerThreadScratchSpaceStart2K;
7166
7167 // Special functions
7168 RenderHal_InitInterfaceEx(pRenderHal);
7169
7170 finish:
7171 return eStatus;
7172 }
7173
7174 //!
7175 //! \brief Set Surface for HW Access
7176 //! \details Common Function for setting up surface state
7177 //! \param PRENDERHAL_INTERFACE pRenderHal
7178 //! [in] Pointer to RenderHal Interface Structure
7179 //! \param PRENDERHAL_SURFACE pRenderHalSurface
7180 //! [in] Pointer to RenderHal Surface
7181 //! \param PRENDERHAL_SURFACE_STATE_PARAMS pSurfaceParams
7182 //! [in] Pointer to Surface Params
7183 //! \param int32_t iBindingTable
7184 //! [in] Binding Table to bind surface
7185 //! \param int32_t iBTEntry
7186 //! [in] Binding Table Entry index
7187 //! \param bool bWrite
7188 //! [in] Write mode flag
7189 //! \return MOS_STATUS
7190 //! MOS_STATUS_SUCCESS if success. Error code otherwise
7191 //!
RenderHal_SetSurfaceForHwAccess(PRENDERHAL_INTERFACE pRenderHal,PRENDERHAL_SURFACE pRenderHalSurface,PRENDERHAL_SURFACE_STATE_PARAMS pSurfaceParams,int32_t iBindingTable,int32_t iBTEntry,bool bWrite)7192 MOS_STATUS RenderHal_SetSurfaceForHwAccess(
7193 PRENDERHAL_INTERFACE pRenderHal,
7194 PRENDERHAL_SURFACE pRenderHalSurface,
7195 PRENDERHAL_SURFACE_STATE_PARAMS pSurfaceParams,
7196 int32_t iBindingTable,
7197 int32_t iBTEntry,
7198 bool bWrite)
7199 {
7200
7201 PMOS_INTERFACE pOsInterface;
7202 PRENDERHAL_SURFACE_STATE_ENTRY pSurfaceEntries[MHW_MAX_SURFACE_PLANES];
7203 int32_t iSurfaceEntries;
7204 int32_t i;
7205 MOS_STATUS eStatus;
7206
7207 //---------------------------------------
7208 MHW_RENDERHAL_CHK_NULL(pRenderHal);
7209 MHW_RENDERHAL_CHK_NULL(pRenderHal->pOsInterface);
7210 //---------------------------------------
7211
7212 // Initialize Variables
7213 eStatus = MOS_STATUS_SUCCESS;
7214 pOsInterface = pRenderHal->pOsInterface;
7215
7216 // Register surfaces for rendering (GfxAddress/Allocation index)
7217 // Register resource
7218 MHW_RENDERHAL_CHK_STATUS(pOsInterface->pfnRegisterResource(
7219 pOsInterface,
7220 &pRenderHalSurface->OsSurface.OsResource,
7221 bWrite,
7222 true));
7223
7224 // Setup surface states-----------------------------------------------------
7225 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pfnSetupSurfaceState(
7226 pRenderHal,
7227 pRenderHalSurface,
7228 pSurfaceParams,
7229 &iSurfaceEntries,
7230 pSurfaceEntries,
7231 nullptr));
7232
7233 // Bind surface states------------------------------------------------------
7234 for (i = 0; i < iSurfaceEntries; i++, iBTEntry++)
7235 {
7236 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pfnBindSurfaceState(
7237 pRenderHal,
7238 iBindingTable,
7239 iBTEntry,
7240 pSurfaceEntries[i]));
7241 }
7242
7243 finish:
7244 return eStatus;
7245 }
7246
7247 //!
7248 //! \brief Set Buffer Surface for HW Access
7249 //! \details Common Function for setting up buffer surface state
7250 //! \param PRENDERHAL_INTERFACE pRenderHal
7251 //! [in] Pointer to RenderHal Interface Structure
7252 //! \param PRENDERHAL_SURFACE pRenderHalSurface
7253 //! [in] Pointer to RenderHal Surface
7254 //! \param PRENDERHAL_SURFACE_STATE_PARAMS pSurfaceParams
7255 //! [in] Pointer to Surface Params
7256 //! \param int32_t iBindingTable
7257 //! [in] Binding Table to Bind Surface
7258 //! \param int32_t iBTEntry
7259 //! [in] Binding Table Entry index
7260 //! \param bool bWrite
7261 //! Write mode flag
7262 //! \return MOS_STATUS
7263 //! MOS_STATUS_SUCCESS if success. Error code otherwise
7264 //!
RenderHal_SetBufferSurfaceForHwAccess(PRENDERHAL_INTERFACE pRenderHal,PRENDERHAL_SURFACE pRenderHalSurface,PRENDERHAL_SURFACE_STATE_PARAMS pSurfaceParams,int32_t iBindingTable,int32_t iBTEntry,bool bWrite)7265 MOS_STATUS RenderHal_SetBufferSurfaceForHwAccess(
7266 PRENDERHAL_INTERFACE pRenderHal,
7267 PRENDERHAL_SURFACE pRenderHalSurface,
7268 PRENDERHAL_SURFACE_STATE_PARAMS pSurfaceParams,
7269 int32_t iBindingTable,
7270 int32_t iBTEntry,
7271 bool bWrite)
7272 {
7273 PMOS_INTERFACE pOsInterface;
7274 RENDERHAL_SURFACE_STATE_PARAMS SurfaceParam;
7275 PRENDERHAL_SURFACE_STATE_ENTRY pSurfaceEntry;
7276 MOS_STATUS eStatus;
7277
7278 //---------------------------------------
7279 MHW_RENDERHAL_CHK_NULL(pRenderHal);
7280 MHW_RENDERHAL_CHK_NULL(pRenderHal->pOsInterface);
7281 //---------------------------------------
7282
7283 // Initialize Variables
7284 eStatus = MOS_STATUS_SUCCESS;
7285 pOsInterface = pRenderHal->pOsInterface;
7286
7287 // Register surfaces for rendering (GfxAddress/Allocation index)
7288 // Register resource
7289 MHW_RENDERHAL_CHK_STATUS(pOsInterface->pfnRegisterResource(
7290 pOsInterface,
7291 &pRenderHalSurface->OsSurface.OsResource,
7292 bWrite,
7293 true));
7294
7295 // Setup Buffer surface-----------------------------------------------------
7296 if (pSurfaceParams == nullptr)
7297 {
7298 MOS_ZeroMemory(&SurfaceParam, sizeof(SurfaceParam));
7299 if (pRenderHalSurface->OsSurface.OsResource.mocsMosResUsageType == MOS_CODEC_RESOURCE_USAGE_BEGIN_CODEC ||
7300 pRenderHalSurface->OsSurface.OsResource.mocsMosResUsageType >= MOS_HW_RESOURCE_USAGE_MEDIA_BATCH_BUFFERS ||
7301 pRenderHalSurface->OsSurface.OsResource.memObjCtrlState.DwordValue == 0)
7302 {
7303 //set mem object control for cache
7304 SurfaceParam.MemObjCtl = (pRenderHal->pOsInterface->pfnCachePolicyGetMemoryObject(
7305 MOS_MP_RESOURCE_USAGE_DEFAULT,
7306 pRenderHal->pOsInterface->pfnGetGmmClientContext(pRenderHal->pOsInterface)))
7307 .DwordValue;
7308 }
7309 else
7310 {
7311 SurfaceParam.MemObjCtl = pRenderHalSurface->OsSurface.OsResource.memObjCtrlState.DwordValue;
7312 }
7313
7314 pSurfaceParams = &SurfaceParam;
7315 }
7316
7317 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pfnSetupBufferSurfaceState(
7318 pRenderHal,
7319 pRenderHalSurface,
7320 pSurfaceParams,
7321 &pSurfaceEntry));
7322
7323 // Bind surface state-------------------------------------------------------
7324 MHW_RENDERHAL_CHK_STATUS(pRenderHal->pfnBindSurfaceState(
7325 pRenderHal,
7326 iBindingTable,
7327 iBTEntry,
7328 pSurfaceEntry));
7329
7330 finish:
7331 return eStatus;
7332 }
7333
7334