1 /*===================== begin_copyright_notice ==================================
2
3 * Copyright (c) 2024, Intel Corporation
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
11 *
12 * The above copyright notice and this permission notice shall be included
13 * in all copies or substantial portions of the Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
16 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
19 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
20 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
21 * OTHER DEALINGS IN THE SOFTWARE.
22
23 ======================= end_copyright_notice ==================================*/
24 //!
25 //! \file media_interfaces_bmg.cpp
26
27 //! \brief Helps with BMG factory creation.
28 //!
29
30 #include "media_interfaces_bmg.h"
31
32 #include "codechal_common.h"
33 #include "codechal_debug.h"
34
35 #include "vp_pipeline_adapter_xe2_hpm.h"
36 #include "vp_platform_interface_xe2_hpm.h"
37 #include "vp_kernel_config_xe2_hpg.h"
38 #include "mhw_mi_xe_lpm_plus_base_next_impl.h"
39 #include "mhw_sfc_xe2_hpm_next_impl.h"
40 #include "mhw_vebox_xe2_hpm_next_impl.h"
41 #include "mhw_render_xe2_hpg_next_impl.h"
42 #include "mhw_blt_xe2_hpm_impl.h"
43
44 //use vdenc from Xe_LPM_plus instead of Xe2_HPM
45 #ifdef _MEDIA_RESERVED
46 #include "mhw_vdbox_vdenc_impl_xe_lpm_plus.h"
47 #endif
48
49 #if defined(ENABLE_KERNELS) && !defined(_FULL_OPEN_SOURCE)
50 #include "igvpkrn_xe2_hpg.h"
51 #include "igvpkrn_xe2_hpg_cmfcpatch.h"
52 #include "igvpkrn_l0_xe2_hpg.h"
53 #endif
54
55 using namespace mhw::vdbox::avp::xe_lpm_plus_base;
56 using namespace mhw::vdbox::huc::xe_lpm_plus_base;
57 using namespace mhw::vdbox::mfx::xe_lpm_plus_base;
58
59 extern template class MediaFactory<uint32_t, CodechalDeviceNext>;
60 extern template class MediaFactory<uint32_t, VphalDevice>;
61 extern template class MediaFactory<uint32_t, RenderHalDevice>;
62 extern template class MediaFactory<uint32_t, MediaInterfacesHwInfoDevice>;
63
64 // Swith to use new media factory template
65 extern template class MediaFactory<uint32_t, MhwInterfacesNext>;
66 extern template class MediaFactory<uint32_t, McpyDeviceNext>;
67
68 static bool bmgRegisteredVphal =
69 MediaFactory<uint32_t, VphalDevice>::
70 Register<VphalInterfacesXe2_Hpm>((uint32_t)IGFX_BMG);
71
Initialize(PMOS_INTERFACE osInterface,bool bInitVphalState,MOS_STATUS * eStatus,bool clearViewMode)72 MOS_STATUS VphalInterfacesXe2_Hpm::Initialize(
73 PMOS_INTERFACE osInterface,
74 bool bInitVphalState,
75 MOS_STATUS * eStatus,
76 bool clearViewMode)
77 {
78 vp::VpPlatformInterface *vpPlatformInterface = MOS_New(vp::VpPlatformInterfaceXe2_Hpm, osInterface);
79 if (nullptr == vpPlatformInterface)
80 {
81 *eStatus = MOS_STATUS_NULL_POINTER;
82 return *eStatus;
83 }
84
85 InitPlatformKernelBinary(vpPlatformInterface);
86
87 if (!bInitVphalState)
88 {
89 m_vpPipeline = MOS_New(vp::VpPipeline, osInterface);
90 if (nullptr == m_vpPipeline)
91 {
92 MOS_Delete(vpPlatformInterface);
93 MOS_OS_CHK_NULL_RETURN(m_vpPipeline);
94 }
95 m_vpPlatformInterface = vpPlatformInterface;
96 *eStatus = MOS_STATUS_SUCCESS;
97 return *eStatus;
98 }
99
100 m_vpBase = MOS_New(
101 VpPipelineAdapterXe2_Hpm,
102 osInterface,
103 *vpPlatformInterface,
104 *eStatus);
105 if (nullptr == m_vpBase)
106 {
107 MOS_Delete(vpPlatformInterface);
108 *eStatus = MOS_STATUS_NULL_POINTER;
109 return *eStatus;
110 }
111 m_isNextEnabled = true;
112 return *eStatus;
113 }
114
CreateVpPlatformInterface(PMOS_INTERFACE osInterface,MOS_STATUS * eStatus)115 MOS_STATUS VphalInterfacesXe2_Hpm::CreateVpPlatformInterface(
116 PMOS_INTERFACE osInterface,
117 MOS_STATUS * eStatus)
118 {
119 vp::VpPlatformInterface *vpPlatformInterface = MOS_New(vp::VpPlatformInterfaceXe2_Hpm, osInterface);
120 if (nullptr == vpPlatformInterface)
121 {
122 *eStatus = MOS_STATUS_NULL_POINTER;
123 }
124 else
125 {
126 InitPlatformKernelBinary(vpPlatformInterface);
127
128 m_vpPlatformInterface = vpPlatformInterface;
129 *eStatus = MOS_STATUS_SUCCESS;
130 }
131 return *eStatus;
132 }
133
InitPlatformKernelBinary(vp::VpPlatformInterface * & vpPlatformInterface)134 void VphalInterfacesXe2_Hpm::InitPlatformKernelBinary(
135 vp::VpPlatformInterface *&vpPlatformInterface)
136 {
137 static vp::VpKernelConfigXe2_Hpg kernelConfig;
138 vpPlatformInterface->SetKernelConfig(&kernelConfig);
139 #if defined(ENABLE_KERNELS) && !defined(_FULL_OPEN_SOURCE)
140 vpPlatformInterface->SetVpFCKernelBinary(
141 IGVPKRN_XE2_HPG,
142 IGVPKRN_XE2_HPG_SIZE,
143 IGVPKRN_XE2_HPG_CMFCPATCH,
144 IGVPKRN_XE2_HPG_CMFCPATCH_SIZE);
145 vpPlatformInterface->AddVpNativeAdvKernelEntryToList(IGVP3DLUT_GENERATION_XE2_HPG, IGVP3DLUT_GENERATION_XE2_HPG_SIZE, "hdr_3dlut_l0");
146 #endif
147 }
148
149 static bool bmgRegisteredMhwNext =
150 MediaFactory<uint32_t, MhwInterfacesNext>::
151 Register<MhwInterfacesBmg_Next>((uint32_t)IGFX_BMG);
152
Initialize(CreateParams params,PMOS_INTERFACE osInterface)153 MOS_STATUS MhwInterfacesBmg_Next::Initialize(
154 CreateParams params,
155 PMOS_INTERFACE osInterface)
156 {
157 if (osInterface == nullptr)
158 {
159 MHW_ASSERTMESSAGE("The OS interface is not valid!");
160 return MOS_STATUS_INVALID_PARAMETER;
161 }
162 m_osInterface = osInterface;
163
164 auto gtSystemInfo = osInterface->pfnGetGtSystemInfo(osInterface);
165 if (gtSystemInfo == nullptr)
166 {
167 MHW_ASSERTMESSAGE("The OS interface is not valid!");
168 return MOS_STATUS_INVALID_PARAMETER;
169 }
170
171 if ((params.m_isCp == false) && (params.Flags.m_value == 0))
172 {
173 MHW_ASSERTMESSAGE("No MHW interfaces were requested for creation.");
174 return MOS_STATUS_INVALID_PARAMETER;
175 }
176
177 // MHW_CP and MHW_MI must always be created
178 MOS_STATUS status;
179 m_cpInterface = osInterface->pfnCreateMhwCpInterface(osInterface);
180 MHW_MI_CHK_NULL(m_cpInterface);
181 auto ptr = std::make_shared<mhw::mi::xe_lpm_plus_base_next::Impl>(osInterface);
182 m_miItf = std::static_pointer_cast<mhw::mi::Itf>(ptr);
183 ptr->SetCpInterface(m_cpInterface, m_miItf);
184
185 if (params.Flags.m_render)
186 {
187 auto renderPtr = std::make_shared<mhw::render::xe2_hpg_next::Impl>(osInterface);
188 m_renderItf = std::static_pointer_cast<mhw::render::Itf>(renderPtr);
189 }
190 if (params.Flags.m_stateHeap)
191 {
192 m_stateHeapInterface =
193 MOS_New(StateHeap, osInterface, params.m_heapMode);
194 }
195 if (params.Flags.m_sfc)
196 {
197 auto sfcPtr = std::make_shared<mhw::sfc::xe2_hpm_next::Impl>(osInterface);
198 m_sfcItf = std::static_pointer_cast<mhw::sfc::Itf>(sfcPtr);
199 }
200 if (params.Flags.m_vebox)
201 {
202 auto veboxPtr = std::make_shared<mhw::vebox::xe2_hpm_next::Impl>(osInterface);
203 m_veboxItf = std::static_pointer_cast<mhw::vebox::Itf>(veboxPtr);
204 }
205
206 if (params.Flags.m_vdboxAll || params.Flags.m_mfx)
207 {
208 auto ptr = std::make_shared<mhw::vdbox::mfx::xe_lpm_plus_base::v1::Impl>(osInterface, m_cpInterface);
209 m_mfxItf = std::static_pointer_cast<mhw::vdbox::mfx::Itf>(ptr);
210 }
211 if (params.Flags.m_vdboxAll || params.Flags.m_hcp)
212 {
213 m_hcpItf = std::make_shared<mhw::vdbox::hcp::xe_lpm_plus_base::v1::Impl>(osInterface);
214 }
215 if (params.Flags.m_vdboxAll)
216 {
217 auto ptr = std::make_shared<mhw::vdbox::avp::xe_lpm_plus_base::v1::Impl>(osInterface);
218 m_avpItf = std::static_pointer_cast<mhw::vdbox::avp::Itf>(ptr);
219 }
220 if (params.Flags.m_vdboxAll || params.Flags.m_huc)
221 {
222 auto ptr = std::make_shared<mhw::vdbox::huc::xe_lpm_plus_base::v1::Impl>(osInterface, m_cpInterface);
223 m_hucItf = std::static_pointer_cast<mhw::vdbox::huc::Itf>(ptr);
224 }
225 if (params.Flags.m_vdboxAll || params.Flags.m_vdenc)
226 {
227 auto ptr = std::make_shared<mhw::vdbox::vdenc::xe_lpm_plus_base::v1::Impl>(osInterface);
228 m_vdencItf = std::static_pointer_cast<mhw::vdbox::vdenc::Itf>(ptr);
229 }
230 if (params.Flags.m_blt)
231 {
232 auto bltptr = std::make_shared<mhw::blt::xe2_hpm::Impl>(osInterface);
233 m_bltItf = std::static_pointer_cast<mhw::blt::Itf>(bltptr);
234 }
235
236 return MOS_STATUS_SUCCESS;
237 }
238
239 //!
240 //! \brief Destroys all created MHW interfaces
241 //! \details If the HAL creation fails, this is used for cleanup
242 //!
Destroy()243 void MhwInterfacesBmg_Next::Destroy()
244 {
245 MhwInterfacesNext::Destroy();
246 }
247
248 static bool bmgRegisteredCodecHal =
249 MediaFactory<uint32_t, CodechalDeviceNext>::
250 Register<CodechalInterfacesXe2_Hpm>((uint32_t)IGFX_BMG);
251
Initialize(void * standardInfo,void * settings,MhwInterfacesNext * mhwInterfaces,PMOS_INTERFACE osInterface)252 MOS_STATUS CodechalInterfacesXe2_Hpm::Initialize(
253 void * standardInfo,
254 void * settings,
255 MhwInterfacesNext *mhwInterfaces,
256 PMOS_INTERFACE osInterface)
257 {
258 if (standardInfo == nullptr ||
259 mhwInterfaces == nullptr ||
260 osInterface == nullptr)
261 {
262 CODECHAL_PUBLIC_ASSERTMESSAGE("CodecHal device is not valid!");
263 return MOS_STATUS_INVALID_PARAMETER;
264 }
265
266 // This part should be moved back to media_intefaces.cpp for softlet build
267 PCODECHAL_STANDARD_INFO info = ((PCODECHAL_STANDARD_INFO)standardInfo);
268 CODECHAL_FUNCTION CodecFunction = info->CodecFunction;
269
270 #ifdef _MEDIA_RESERVED
271 #ifdef _VP9_ENCODE_VDENC_SUPPORTED //use vdenc from Xe_LPM_plus instead of Xe2_HPM
272 if (mhwInterfaces != nullptr && info->Mode == CODECHAL_ENCODE_MODE_VP9)
273 {
274 auto ptr = std::make_shared<mhw::vdbox::vdenc::xe_lpm_plus_base::v0::Impl>(osInterface);
275 mhwInterfaces->m_vdencItf = std::dynamic_pointer_cast<mhw::vdbox::vdenc::Itf>(ptr);
276 CODECHAL_PUBLIC_CHK_NULL_RETURN(mhwInterfaces->m_vdencItf);
277 }
278 #endif
279 #endif
280
281 bool disableScalability = false;
282 #ifdef _MEDIA_RESERVED
283 #ifdef _VP9_ENCODE_VDENC_SUPPORTED
284 if (info->Mode == CODECHAL_ENCODE_MODE_VP9)
285 disableScalability = true;
286 #endif
287 #endif
288
289 CodechalHwInterfaceNext *hwInterface = MOS_New(Hw, osInterface, CodecFunction, mhwInterfaces, disableScalability);
290
291 if (hwInterface == nullptr)
292 {
293 CODECHAL_PUBLIC_ASSERTMESSAGE("hwInterface is not valid!");
294 return MOS_STATUS_NO_SPACE;
295 }
296 hwInterface->pfnCreateDecodeSinglePipe = decode::DecodeScalabilitySinglePipeNext::CreateDecodeSinglePipe;
297 hwInterface->pfnCreateDecodeMultiPipe = decode::DecodeScalabilityMultiPipeNext::CreateDecodeMultiPipe;
298
299 #if USE_CODECHAL_DEBUG_TOOL
300 CodechalDebugInterface *debugInterface = MOS_New(CodechalDebugInterface);
301 if (debugInterface == nullptr)
302 {
303 MOS_Delete(hwInterface);
304 CODECHAL_PUBLIC_ASSERTMESSAGE("debugInterface is not valid!");
305 return MOS_STATUS_NO_SPACE;
306 }
307 if (debugInterface->Initialize(hwInterface, CodecFunction) != MOS_STATUS_SUCCESS)
308 {
309 MOS_Delete(hwInterface);
310 MOS_Delete(debugInterface);
311 CODECHAL_PUBLIC_ASSERTMESSAGE("Debug interface creation failed!");
312 return MOS_STATUS_INVALID_PARAMETER;
313 }
314 #else
315 CodechalDebugInterface *debugInterface = nullptr;
316 #endif // USE_CODECHAL_DEBUG_TOOL
317
318 auto release_func = [&]()
319 {
320 MOS_Delete(hwInterface);
321 #if USE_CODECHAL_DEBUG_TOOL
322 MOS_Delete(debugInterface);
323 #endif // USE_CODECHAL_DEBUG_TOOL
324 };
325
326 if (CodecHalIsDecode(CodecFunction))
327 {
328 #ifdef _MPEG2_DECODE_SUPPORTED
329 if (info->Mode == CODECHAL_DECODE_MODE_MPEG2IDCT ||
330 info->Mode == CODECHAL_DECODE_MODE_MPEG2VLD)
331 {
332 m_codechalDevice = MOS_New(DecodeMpeg2PipelineAdapterXe2_Hpm, hwInterface, debugInterface);
333 if (m_codechalDevice == nullptr)
334 {
335 CODECHAL_PUBLIC_ASSERTMESSAGE("Failed to create decode device!");
336 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_NO_SPACE, release_func);
337 }
338 }
339 else
340 #endif
341 #ifdef _VC1_DECODE_SUPPORTED
342 if (info->Mode == CODECHAL_DECODE_MODE_VC1IT ||
343 info->Mode == CODECHAL_DECODE_MODE_VC1VLD)
344 {
345 CODECHAL_PUBLIC_ASSERTMESSAGE("BMG doesn't support VC1!");
346 }
347 else
348 #endif
349 #ifdef _AVC_DECODE_SUPPORTED
350 if (info->Mode == CODECHAL_DECODE_MODE_AVCVLD)
351 {
352 m_codechalDevice = MOS_New(DecodeAvcPipelineAdapterXe2_Hpm, hwInterface, debugInterface);
353
354 if (m_codechalDevice == nullptr)
355 {
356 CODECHAL_PUBLIC_ASSERTMESSAGE("Failed to create decode device!");
357 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_NO_SPACE, release_func);
358 }
359 }
360 else
361 #endif
362 #ifdef _JPEG_DECODE_SUPPORTED
363 if (info->Mode == CODECHAL_DECODE_MODE_JPEG)
364 {
365 m_codechalDevice = MOS_New(DecodeJpegPipelineAdapterXe2_Hpm, hwInterface, debugInterface);
366 }
367 else
368 #endif
369 #ifdef _VP8_DECODE_SUPPORTED
370 if (info->Mode == CODECHAL_DECODE_MODE_VP8VLD)
371 {
372 m_codechalDevice = MOS_New(DecodeVp8PipelineAdapterXe2_Hpm, hwInterface, debugInterface);
373 }
374 else
375 #endif
376 #ifdef _HEVC_DECODE_SUPPORTED
377 if (info->Mode == CODECHAL_DECODE_MODE_HEVCVLD)
378 {
379 m_codechalDevice = MOS_New(DecodeHevcPipelineAdapterXe2_Hpm, hwInterface, debugInterface);
380 }
381 else
382 #endif
383 #ifdef _VP9_DECODE_SUPPORTED
384 if (info->Mode == CODECHAL_DECODE_MODE_VP9VLD)
385 {
386 m_codechalDevice = MOS_New(DecodeVp9PipelineAdapterXe2_Hpm, hwInterface, debugInterface);
387 }
388 else
389 #endif
390 #ifdef _AV1_DECODE_SUPPORTED
391 if (info->Mode == CODECHAL_DECODE_MODE_AV1VLD)
392 {
393 m_codechalDevice = MOS_New(DecodeAv1PipelineAdapterXe2_Hpm, hwInterface, debugInterface);
394 }
395 else
396 #endif
397 {
398 CODECHAL_PUBLIC_ASSERTMESSAGE("Decode mode requested invalid!");
399 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
400 }
401
402 if (m_codechalDevice == nullptr)
403 {
404 CODECHAL_PUBLIC_ASSERTMESSAGE("Decoder device creation failed!");
405 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_NO_SPACE, release_func);
406 }
407 }
408 else if (CodecHalIsEncode(CodecFunction))
409 {
410 #ifdef _MEDIA_RESERVED
411 #if defined (_AVC_ENCODE_VDENC_SUPPORTED)
412 if (info->Mode == CODECHAL_ENCODE_MODE_AVC)
413 {
414 if (CodecHalUsesVdencEngine(info->CodecFunction))
415 {
416 m_codechalDevice = MOS_New(EncodeAvcVdencPipelineAdapterXe2_Hpm, hwInterface, debugInterface);
417 if (m_codechalDevice == nullptr)
418 {
419 CODECHAL_PUBLIC_ASSERTMESSAGE("Encode state creation failed!");
420 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
421 }
422 return MOS_STATUS_SUCCESS;
423 }
424 }
425 else
426 #endif
427 #ifdef _VP9_ENCODE_VDENC_SUPPORTED
428 if (info->Mode == CODECHAL_ENCODE_MODE_VP9)
429 {
430 m_codechalDevice = MOS_New(EncodeVp9VdencPipelineAdapterXe2_Hpm, hwInterface, debugInterface);
431 if (m_codechalDevice == nullptr)
432 {
433 CODECHAL_PUBLIC_ASSERTMESSAGE("Encode state creation failed!");
434 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
435 }
436 return MOS_STATUS_SUCCESS;
437 }
438 else
439 #endif
440 #ifdef _JPEG_ENCODE_SUPPORTED
441 if (info->Mode == CODECHAL_ENCODE_MODE_JPEG)
442 {
443 m_codechalDevice = MOS_New(EncodeJpegPipelineAdapter, hwInterface, debugInterface);
444 if (m_codechalDevice == nullptr)
445 {
446 CODECHAL_PUBLIC_ASSERTMESSAGE("Encode state creation failed!");
447 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
448 }
449 return MOS_STATUS_SUCCESS;
450 }
451 else
452 #endif
453 #if defined(_AV1_ENCODE_VDENC_SUPPORTED)
454 if (info->Mode == codechalEncodeModeAv1)
455 {
456 if (CodecHalUsesVdencEngine(info->CodecFunction))
457 {
458 m_codechalDevice = MOS_New(EncodeAv1VdencPipelineAdapterXe2_Hpm, hwInterface, debugInterface);
459 if (m_codechalDevice == nullptr)
460 {
461 CODECHAL_PUBLIC_ASSERTMESSAGE("Encode state creation failed!");
462 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
463 }
464 return MOS_STATUS_SUCCESS;
465 }
466 else
467 {
468 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
469 }
470 }
471 else
472 #endif
473 #if defined(_HEVC_ENCODE_VDENC_SUPPORTED)
474 if (info->Mode == CODECHAL_ENCODE_MODE_HEVC)
475 {
476 if (CodecHalUsesVdencEngine(info->CodecFunction))
477 {
478 m_codechalDevice = MOS_New(EncodeHevcVdencPipelineAdapterXe2_Hpm, hwInterface, debugInterface);
479 if (m_codechalDevice == nullptr)
480 {
481 CODECHAL_PUBLIC_ASSERTMESSAGE("Encode state creation failed!");
482 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
483 }
484 return MOS_STATUS_SUCCESS;
485 }
486 }
487 else
488 #endif
489 #endif
490 {
491 CODECHAL_PUBLIC_ASSERTMESSAGE("Unsupported encode function requested.");
492 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
493 }
494 }
495 else
496 {
497 CODECHAL_PUBLIC_ASSERTMESSAGE("Unsupported codec function requested.");
498 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
499 }
500
501 return MOS_STATUS_SUCCESS;
502 }
503
504 static bool bmgRegisteredRenderHal =
505 MediaFactory<uint32_t, RenderHalDevice>::
506 Register<RenderHalInterfacesXe2_Hpg>((uint32_t)IGFX_BMG);
507
Initialize()508 MOS_STATUS RenderHalInterfacesXe2_Hpg::Initialize()
509 {
510 m_renderhalDevice = MOS_New(XRenderHal);
511 if (m_renderhalDevice == nullptr)
512 {
513 MHW_ASSERTMESSAGE("Create Render Hal interfaces failed.")
514 return MOS_STATUS_NO_SPACE;
515 }
516 return MOS_STATUS_SUCCESS;
517 }
518
519 #define IP_VERSION_XE2_HPM 0x1301
520 static bool bmgRegisteredHwInfo =
521 MediaFactory<uint32_t, MediaInterfacesHwInfoDevice>::
522 Register<MediaInterfacesHwInfoDeviceXe2_Hpm>((uint32_t)IGFX_BMG);
523
Initialize(PLATFORM platform)524 MOS_STATUS MediaInterfacesHwInfoDeviceXe2_Hpm::Initialize(PLATFORM platform)
525 {
526 m_hwInfo.SetDeviceInfo(IP_VERSION_XE2_HPM, platform.usRevId);
527 return MOS_STATUS_SUCCESS;
528 }
529
530 static bool bmgRegisteredMcpy =
531 MediaFactory<uint32_t, McpyDeviceNext>::
532 Register<McpyDeviceXe2_Hpm>((uint32_t)IGFX_BMG);
533
Initialize(PMOS_INTERFACE osInterface,MhwInterfacesNext * mhwInterfaces)534 MOS_STATUS McpyDeviceXe2_Hpm::Initialize(
535 PMOS_INTERFACE osInterface,
536 MhwInterfacesNext* mhwInterfaces)
537 {
538 #define MCPY_FAILURE() \
539 { \
540 if (device != nullptr) \
541 { \
542 MOS_Delete(device); \
543 } \
544 return MOS_STATUS_NO_SPACE; \
545 }
546
547 MHW_FUNCTION_ENTER;
548
549 Mcpy* device = nullptr;
550
551 if (nullptr == mhwInterfaces->m_miItf)
552 {
553 MCPY_FAILURE();
554 }
555
556 if (nullptr == mhwInterfaces->m_veboxItf)
557 {
558 MCPY_FAILURE();
559 }
560
561 if (nullptr == mhwInterfaces->m_bltItf)
562 {
563 MCPY_FAILURE();
564 }
565
566 device = MOS_New(Mcpy);
567
568 if (device == nullptr)
569 {
570 MCPY_FAILURE();
571 }
572
573 if (device->Initialize(
574 osInterface, mhwInterfaces) != MOS_STATUS_SUCCESS)
575 {
576 MOS_Delete(device);
577 MOS_OS_CHK_STATUS_RETURN(MOS_STATUS_UNINITIALIZED);
578 }
579
580 m_mcpyDevice = device;
581
582 return MOS_STATUS_SUCCESS;
583 }