Debian Codegraph @

media_softlet/agnostic/common/renderhal/renderhal.cpp

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