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_lnl.cpp
26 
27 //! \brief    Helps with LNL factory creation.
28 //!
29 
30 #include "media_interfaces_lnl.h"
31 
32 #include "codechal_common.h"
33 #include "codechal_debug.h"
34 
35 #include "vp_pipeline_adapter_xe2_lpm.h"
36 #include "vp_platform_interface_xe2_lpm.h"
37 #include "vp_kernel_config_xe2_hpg.h"
38 #include "mhw_mi_xe2_lpm_base_next_impl.h"
39 #include "mhw_sfc_xe2_lpm_base_next_impl.h"
40 #include "mhw_vebox_xe2_lpm_base_next_impl.h"
41 #include "mhw_render_xe2_hpg_next_impl.h"
42 #include "mhw_blt_xe2_lpm_impl.h"
43 #include "media_interfaces_mcpy_next.h"
44 
45 // use vdenc from Xe_LPM_plus instead of Xe2_LPM
46 #ifdef _MEDIA_RESERVED
47 #include "mhw_vdbox_vdenc_impl_xe_lpm_plus.h"
48 #endif
49 
50 #if defined(ENABLE_KERNELS) && !defined(_FULL_OPEN_SOURCE)
51 #include "igvpkrn_xe2_hpg.h"
52 #include "igvpkrn_xe2_hpg_cmfcpatch.h"
53 #include "igvpkrn_l0_xe2_hpg.h"
54 #include "igvpfc_common_xe2.h"
55 #include "igvpfc_fp_xe2.h"
56 #include "igvpfc_444PL3_input_xe2.h"
57 #endif
58 
59 using namespace mhw::vdbox::avp::xe2_lpm_base;
60 #ifdef _MEDIA_RESERVED
61 using namespace mhw::vdbox::vdenc::xe2_lpm_base;
62 #endif
63 using namespace mhw::vdbox::huc::xe2_lpm_base;
64 
65 extern template class MediaFactory<uint32_t, CodechalDeviceNext>;
66 extern template class MediaFactory<uint32_t, VphalDevice>;
67 extern template class MediaFactory<uint32_t, RenderHalDevice>;
68 extern template class MediaFactory<uint32_t, MediaInterfacesHwInfoDevice>;
69 
70 // Swith to use new media factory template
71 extern template class MediaFactory<uint32_t, MhwInterfacesNext>;
72 
73 static bool lnlRegisteredVphal =
74     MediaFactory<uint32_t, VphalDevice>::
75         Register<VphalInterfacesXe2_Lpm>((uint32_t)IGFX_LUNARLAKE);
76 
Initialize(PMOS_INTERFACE osInterface,bool bInitVphalState,MOS_STATUS * eStatus,bool clearViewMode)77 MOS_STATUS VphalInterfacesXe2_Lpm::Initialize(
78     PMOS_INTERFACE osInterface,
79     bool           bInitVphalState,
80     MOS_STATUS *   eStatus,
81     bool           clearViewMode)
82 {
83     vp::VpPlatformInterface* vpPlatformInterface = MOS_New(vp::VpPlatformInterfacsXe2_Lpm, osInterface);
84     if (nullptr == vpPlatformInterface)
85     {
86         *eStatus = MOS_STATUS_NULL_POINTER;
87         return *eStatus;
88     }
89 
90     InitPlatformKernelBinary(vpPlatformInterface);
91 
92     if (!bInitVphalState)
93     {
94         m_vpPipeline = MOS_New(vp::VpPipeline, osInterface);
95         if (nullptr == m_vpPipeline)
96         {
97             MOS_Delete(vpPlatformInterface);
98             MOS_OS_CHK_NULL_RETURN(m_vpPipeline);
99         }
100         m_vpPlatformInterface = vpPlatformInterface;
101         *eStatus = MOS_STATUS_SUCCESS;
102         return *eStatus;
103     }
104 
105     m_vpBase = MOS_New(
106         VpPipelineAdapterXe2_Lpm,
107         osInterface,
108         *vpPlatformInterface,
109         *eStatus);
110     if (nullptr == m_vpBase)
111     {
112         MOS_Delete(vpPlatformInterface);
113         *eStatus = MOS_STATUS_NULL_POINTER;
114         return *eStatus;
115     }
116     m_isNextEnabled = true;
117 
118     return *eStatus;
119 }
120 
CreateVpPlatformInterface(PMOS_INTERFACE osInterface,MOS_STATUS * eStatus)121 MOS_STATUS VphalInterfacesXe2_Lpm::CreateVpPlatformInterface(
122     PMOS_INTERFACE osInterface,
123     MOS_STATUS *   eStatus)
124 {
125     vp::VpPlatformInterface *vpPlatformInterface = MOS_New(vp::VpPlatformInterfacsXe2_Lpm, osInterface);
126     if (nullptr == vpPlatformInterface)
127     {
128         *eStatus = MOS_STATUS_NULL_POINTER;
129     }
130     else
131     {
132         InitPlatformKernelBinary(vpPlatformInterface);
133 
134         m_vpPlatformInterface = vpPlatformInterface;
135         *eStatus              = MOS_STATUS_SUCCESS;
136     }
137     return *eStatus;
138 }
139 
InitPlatformKernelBinary(vp::VpPlatformInterface * & vpPlatformInterface)140 void VphalInterfacesXe2_Lpm::InitPlatformKernelBinary(
141     vp::VpPlatformInterface  *&vpPlatformInterface)
142 {
143     static vp::VpKernelConfigXe2_Hpg kernelConfig;
144     vpPlatformInterface->SetKernelConfig(&kernelConfig);
145 #if defined(ENABLE_KERNELS) && !defined(_FULL_OPEN_SOURCE)
146     vpPlatformInterface->SetVpFCKernelBinary(
147                         IGVPKRN_XE2_HPG,
148                         IGVPKRN_XE2_HPG_SIZE,
149                         IGVPKRN_XE2_HPG_CMFCPATCH,
150                         IGVPKRN_XE2_HPG_CMFCPATCH_SIZE);
151 
152     vpPlatformInterface->AddVpNativeAdvKernelEntryToList(IGVP3DLUT_GENERATION_XE2_HPG, IGVP3DLUT_GENERATION_XE2_HPG_SIZE, "hdr_3dlut_l0");
153     AddVpNativeKernelEntryToListFc_commonXe2(*vpPlatformInterface);
154     AddVpNativeKernelEntryToListFc_fpXe2(*vpPlatformInterface);
155     AddVpNativeKernelEntryToListFc_444pl3_inputXe2(*vpPlatformInterface);
156 #endif
157 }
158 
159 static bool lnlRegisteredMhwNext =
160     MediaFactory<uint32_t, MhwInterfacesNext>::
161         Register<MhwInterfacesLnl_Next>((uint32_t)IGFX_LUNARLAKE);
162 
Initialize(CreateParams params,PMOS_INTERFACE osInterface)163 MOS_STATUS MhwInterfacesLnl_Next::Initialize(
164     CreateParams   params,
165     PMOS_INTERFACE osInterface)
166 {
167     if (osInterface == nullptr)
168     {
169         MHW_ASSERTMESSAGE("The OS interface is not valid!");
170         return MOS_STATUS_INVALID_PARAMETER;
171     }
172     m_osInterface = osInterface;
173 
174     auto gtSystemInfo = osInterface->pfnGetGtSystemInfo(osInterface);
175     if (gtSystemInfo == nullptr)
176     {
177         MHW_ASSERTMESSAGE("The OS interface is not valid!");
178         return MOS_STATUS_INVALID_PARAMETER;
179     }
180 
181     if ((params.m_isCp == false) && (params.Flags.m_value == 0))
182     {
183         MHW_ASSERTMESSAGE("No MHW interfaces were requested for creation.");
184         return MOS_STATUS_INVALID_PARAMETER;
185     }
186 
187     // MHW_CP and MHW_MI must always be created
188     MOS_STATUS status;
189     m_cpInterface = osInterface->pfnCreateMhwCpInterface(osInterface);
190     MHW_MI_CHK_NULL(m_cpInterface);
191     auto ptr      = std::make_shared<mhw::mi::xe2_lpm_base_next::Impl>(osInterface);
192     m_miItf       = std::static_pointer_cast<mhw::mi::Itf>(ptr);
193     ptr->SetCpInterface(m_cpInterface, m_miItf);
194 
195     if (params.Flags.m_render)
196     {
197         auto renderPtr = std::make_shared<mhw::render::xe2_hpg_next::Impl>(osInterface);
198         m_renderItf    = std::static_pointer_cast<mhw::render::Itf>(renderPtr);
199     }
200     if (params.Flags.m_stateHeap)
201     {
202         m_stateHeapInterface =
203             MOS_New(StateHeap, osInterface, params.m_heapMode);
204     }
205     if (params.Flags.m_sfc)
206     {
207         auto sfcPtr    = std::make_shared<mhw::sfc::xe2_lpm_base_next::Impl>(osInterface);
208         m_sfcItf       = std::static_pointer_cast<mhw::sfc::Itf>(sfcPtr);
209     }
210     if (params.Flags.m_vebox)
211     {
212         auto veboxPtr    = std::make_shared<mhw::vebox::xe2_lpm_base_next::Impl>(osInterface);
213         m_veboxItf       = std::static_pointer_cast<mhw::vebox::Itf>(veboxPtr);
214     }
215 
216     if (params.Flags.m_vdboxAll || params.Flags.m_mfx)
217     {
218         auto ptr = std::make_shared<mhw::vdbox::mfx::xe2_lpm_base::xe2_lpm::Impl>(osInterface, m_cpInterface);
219         m_mfxItf = std::static_pointer_cast<mhw::vdbox::mfx::Itf>(ptr);
220     }
221     if (params.Flags.m_vdboxAll || params.Flags.m_hcp)
222     {
223         m_hcpItf = std::make_shared<mhw::vdbox::hcp::xe2_lpm_base::xe2_lpm::Impl>(osInterface);
224     }
225     if (params.Flags.m_vdboxAll)
226     {
227         auto ptr = std::make_shared<mhw::vdbox::avp::xe2_lpm_base::xe2_lpm::Impl>(osInterface);
228         m_avpItf = std::static_pointer_cast<mhw::vdbox::avp::Itf>(ptr);
229     }
230     if (params.Flags.m_vdboxAll)
231     {
232         auto ptr  = std::make_shared<mhw::vdbox::vvcp::xe2_lpm_base::xe2_lpm::Impl>(osInterface, m_cpInterface);
233         m_vvcpItf = std::static_pointer_cast<mhw::vdbox::vvcp::Itf>(ptr);
234     }
235     if (params.Flags.m_vdboxAll || params.Flags.m_huc)
236     {
237         auto ptr = std::make_shared<mhw::vdbox::huc::xe2_lpm_base::xe2_lpm::Impl>(osInterface, m_cpInterface);
238         m_hucItf = std::static_pointer_cast<mhw::vdbox::huc::Itf>(ptr);
239     }
240     if (params.Flags.m_vdboxAll || params.Flags.m_vdenc)
241     {
242         auto ptr = std::make_shared<mhw::vdbox::vdenc::xe2_lpm_base::xe2_lpm::Impl>(osInterface);
243         m_vdencItf = std::static_pointer_cast<mhw::vdbox::vdenc::Itf>(ptr);
244     }
245     if (params.Flags.m_blt)
246     {
247         auto bltptr = std::make_shared<mhw::blt::xe2_lpm::Impl>(osInterface);
248         m_bltItf = std::static_pointer_cast<mhw::blt::Itf>(bltptr);
249     }
250 
251     return MOS_STATUS_SUCCESS;
252 }
253 
254 //!
255 //! \brief    Destroys all created MHW interfaces
256 //! \details  If the HAL creation fails, this is used for cleanup
257 //!
Destroy()258 void MhwInterfacesLnl_Next::Destroy()
259 {
260     MhwInterfacesNext::Destroy();
261 }
262 
263 static bool lnlRegisteredCodecHal =
264     MediaFactory<uint32_t, CodechalDeviceNext>::
265         Register<CodechalInterfacesXe2_Lpm>((uint32_t)IGFX_LUNARLAKE);
266 
Initialize(void * standardInfo,void * settings,MhwInterfacesNext * mhwInterfaces,PMOS_INTERFACE osInterface)267 MOS_STATUS CodechalInterfacesXe2_Lpm::Initialize(
268     void *         standardInfo,
269     void *         settings,
270     MhwInterfacesNext *mhwInterfaces,
271     PMOS_INTERFACE osInterface)
272 {
273     if (standardInfo == nullptr ||
274         mhwInterfaces == nullptr ||
275         osInterface == nullptr)
276     {
277         CODECHAL_PUBLIC_ASSERTMESSAGE("CodecHal device is not valid!");
278         return MOS_STATUS_INVALID_PARAMETER;
279     }
280 
281     // This part should be moved back to media_intefaces.cpp for softlet build
282     PCODECHAL_STANDARD_INFO info          = ((PCODECHAL_STANDARD_INFO)standardInfo);
283     CODECHAL_FUNCTION       CodecFunction = info->CodecFunction;
284 
285 #ifdef _MEDIA_RESERVED
286 #ifdef _VP9_ENCODE_VDENC_SUPPORTED  // use vdenc from Xe_LPM_plus instead of Xe2_LPM
287     if (mhwInterfaces != nullptr && info->Mode == CODECHAL_ENCODE_MODE_VP9)
288     {
289         auto ptr                      = std::make_shared<mhw::vdbox::vdenc::xe_lpm_plus_base::v0::Impl>(osInterface);
290         mhwInterfaces->m_vdencItf = std::dynamic_pointer_cast<mhw::vdbox::vdenc::Itf>(ptr);
291         CODECHAL_PUBLIC_CHK_NULL_RETURN(mhwInterfaces->m_vdencItf);
292     }
293 #endif
294 #endif
295     bool disableScalability = true;
296 
297     CodechalHwInterfaceNext *hwInterface = MOS_New(Hw, osInterface, CodecFunction, mhwInterfaces, disableScalability);
298 
299     if (hwInterface == nullptr)
300     {
301         CODECHAL_PUBLIC_ASSERTMESSAGE("hwInterface is not valid!");
302         return MOS_STATUS_NO_SPACE;
303     }
304     hwInterface->pfnCreateDecodeSinglePipe = decode::DecodeScalabilitySinglePipeNext::CreateDecodeSinglePipe;
305     hwInterface->pfnCreateDecodeMultiPipe  = decode::DecodeScalabilityMultiPipeNext::CreateDecodeMultiPipe;
306 
307 #if USE_CODECHAL_DEBUG_TOOL
308     CodechalDebugInterface *debugInterface = MOS_New(CodechalDebugInterface);
309     if (debugInterface == nullptr)
310     {
311         MOS_Delete(hwInterface);
312         CODECHAL_PUBLIC_ASSERTMESSAGE("debugInterface is not valid!");
313         return MOS_STATUS_NO_SPACE;
314     }
315     if (debugInterface->Initialize(hwInterface, CodecFunction) != MOS_STATUS_SUCCESS)
316     {
317         MOS_Delete(hwInterface);
318         MOS_Delete(debugInterface);
319         CODECHAL_PUBLIC_ASSERTMESSAGE("Debug interface creation failed!");
320         return MOS_STATUS_INVALID_PARAMETER;
321     }
322 #else
323     CodechalDebugInterface *debugInterface = nullptr;
324 #endif  // USE_CODECHAL_DEBUG_TOOL
325 
326     auto release_func = [&]()
327     {
328         MOS_Delete(hwInterface);
329 #if USE_CODECHAL_DEBUG_TOOL
330         MOS_Delete(debugInterface);
331 #endif  // USE_CODECHAL_DEBUG_TOOL
332     };
333 
334     if (CodecHalIsDecode(CodecFunction))
335     {
336 #ifdef _MPEG2_DECODE_SUPPORTED
337         if (info->Mode == CODECHAL_DECODE_MODE_MPEG2IDCT ||
338             info->Mode == CODECHAL_DECODE_MODE_MPEG2VLD)
339         {
340             m_codechalDevice = MOS_New(Decode::Mpeg2, hwInterface, debugInterface);
341         }
342         else
343 #endif
344 #ifdef _VC1_DECODE_SUPPORTED
345         if (info->Mode == CODECHAL_DECODE_MODE_VC1IT ||
346             info->Mode == CODECHAL_DECODE_MODE_VC1VLD)
347         {
348             CODECHAL_PUBLIC_ASSERTMESSAGE("LNL doesn't support VC1!");
349         }
350         else
351 #endif
352 #ifdef _AVC_DECODE_SUPPORTED
353         if (info->Mode == CODECHAL_DECODE_MODE_AVCVLD)
354         {
355            m_codechalDevice = MOS_New(Decode::Avc, hwInterface, debugInterface);
356         }
357         else
358 #endif
359 #ifdef _JPEG_DECODE_SUPPORTED
360         if (info->Mode == CODECHAL_DECODE_MODE_JPEG)
361         {
362             m_codechalDevice = MOS_New(Decode::Jpeg, hwInterface, debugInterface);
363         }
364         else
365 #endif
366 #ifdef _VP8_DECODE_SUPPORTED
367         if (info->Mode == CODECHAL_DECODE_MODE_VP8VLD)
368         {
369             m_codechalDevice = MOS_New(Decode::Vp8, hwInterface, debugInterface);
370         }
371         else
372 #endif
373 #ifdef _HEVC_DECODE_SUPPORTED
374         if (info->Mode == CODECHAL_DECODE_MODE_HEVCVLD)
375         {
376             m_codechalDevice = MOS_New(Decode::Hevc, hwInterface, debugInterface);
377         }
378         else
379 #endif
380 #ifdef _VP9_DECODE_SUPPORTED
381             if (info->Mode == CODECHAL_DECODE_MODE_VP9VLD)
382         {
383             m_codechalDevice = MOS_New(Decode::Vp9, hwInterface, debugInterface);
384         }
385         else
386 #endif
387 #ifdef _AV1_DECODE_SUPPORTED
388         if (info->Mode == CODECHAL_DECODE_MODE_AV1VLD)
389         {
390             m_codechalDevice = MOS_New(Decode::Av1, hwInterface, debugInterface);
391         }
392         else
393 #endif
394 #ifdef _VVC_DECODE_SUPPORTED
395         if (info->Mode == CODECHAL_DECODE_MODE_VVCVLD)
396         {
397             m_codechalDevice = MOS_New(Decode::Vvc, hwInterface, debugInterface);
398         }
399         else
400 #endif
401         {
402             CODECHAL_PUBLIC_ASSERTMESSAGE("Decode mode requested invalid!");
403             CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
404         }
405 
406         if (m_codechalDevice == nullptr)
407         {
408             CODECHAL_PUBLIC_ASSERTMESSAGE("Decoder device creation failed!");
409             CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_NO_SPACE, release_func);
410         }
411     }
412     else if (CodecHalIsEncode(CodecFunction))
413     {
414 #if defined (_AVC_ENCODE_VDENC_SUPPORTED)
415         if (info->Mode == CODECHAL_ENCODE_MODE_AVC)
416         {
417             if (CodecHalUsesVdencEngine(info->CodecFunction))
418             {
419                 m_codechalDevice = MOS_New(EncodeAvcVdencPipelineAdapterXe2_Lpm, hwInterface, debugInterface);
420                 if (m_codechalDevice == nullptr)
421                 {
422                     CODECHAL_PUBLIC_ASSERTMESSAGE("Encode state creation failed!");
423                     CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
424                 }
425                 return MOS_STATUS_SUCCESS;
426             }
427         }
428         else
429 #endif
430 #ifdef _MEDIA_RESERVED
431 #ifdef _VP9_ENCODE_VDENC_SUPPORTED
432         if (info->Mode == CODECHAL_ENCODE_MODE_VP9)
433         {
434             m_codechalDevice = MOS_New(EncodeVp9VdencPipelineAdapterXe2_Lpm, hwInterface, debugInterface);
435             if (m_codechalDevice == nullptr)
436             {
437                 CODECHAL_PUBLIC_ASSERTMESSAGE("Encode state creation failed!");
438                 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
439             }
440             return MOS_STATUS_SUCCESS;
441         }
442         else
443 #endif
444 #endif
445 
446 #if defined(_AV1_ENCODE_VDENC_SUPPORTED)
447         if (info->Mode == codechalEncodeModeAv1)
448         {
449             if (CodecHalUsesVdencEngine(info->CodecFunction))
450             {
451                 m_codechalDevice = MOS_New(EncodeAv1VdencPipelineAdapterXe2_Lpm, hwInterface, debugInterface);
452                 if (m_codechalDevice == nullptr)
453                 {
454                     CODECHAL_PUBLIC_ASSERTMESSAGE("Encode state creation failed!");
455                     CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
456                 }
457                 return MOS_STATUS_SUCCESS;
458             }
459             else
460             {
461                 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
462             }
463         }
464         else
465 #endif
466 
467 #ifdef _JPEG_ENCODE_SUPPORTED
468         if (info->Mode == CODECHAL_ENCODE_MODE_JPEG)
469         {
470             m_codechalDevice = MOS_New(EncodeJpegPipelineAdapter, hwInterface, debugInterface);
471             if (m_codechalDevice == nullptr)
472             {
473                 CODECHAL_PUBLIC_ASSERTMESSAGE("Encode state creation failed!");
474                 CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
475             }
476             return MOS_STATUS_SUCCESS;
477         }
478         else
479 #endif
480 
481 #if defined(_HEVC_ENCODE_VDENC_SUPPORTED)
482         if (info->Mode == CODECHAL_ENCODE_MODE_HEVC)
483         {
484             if (CodecHalUsesVdencEngine(info->CodecFunction))
485             {
486                 m_codechalDevice = MOS_New(EncodeHevcVdencPipelineAdapterXe2_Lpm_Base, hwInterface, debugInterface);
487                 if (m_codechalDevice == nullptr)
488                 {
489                     CODECHAL_PUBLIC_ASSERTMESSAGE("Encode state creation failed!");
490                     CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
491                 }
492                 return MOS_STATUS_SUCCESS;
493             }
494         }
495         else
496 #endif
497         {
498             CODECHAL_PUBLIC_ASSERTMESSAGE("Unsupported encode function requested.");
499             CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
500         }
501     }
502     else
503     {
504         CODECHAL_PUBLIC_ASSERTMESSAGE("Unsupported codec function requested.");
505         CODECHAL_PUBLIC_CHK_STATUS_WITH_DESTROY_RETURN(MOS_STATUS_INVALID_PARAMETER, release_func);
506     }
507 
508     return MOS_STATUS_SUCCESS;
509 }
510 
511 static bool lnlRegisteredRenderHal =
512     MediaFactory<uint32_t, RenderHalDevice>::
513         Register<RenderHalInterfacesXe2_Lpc>((uint32_t)IGFX_LUNARLAKE);
514 
Initialize()515 MOS_STATUS RenderHalInterfacesXe2_Lpc::Initialize()
516 {
517     m_renderhalDevice = MOS_New(XRenderHal);
518     if (m_renderhalDevice == nullptr)
519     {
520         MHW_ASSERTMESSAGE("Create Render Hal interfaces failed.")
521         return MOS_STATUS_NO_SPACE;
522     }
523     return MOS_STATUS_SUCCESS;
524 }
525 
526 #define IP_VERSION_XE2_LPM 0x1500
527 static bool lnlRegisteredHwInfo =
528     MediaFactory<uint32_t, MediaInterfacesHwInfoDevice>::Register<MediaInterfacesHwInfoDeviceXe2_Lpm>((uint32_t)IGFX_LUNARLAKE);
529 
Initialize(PLATFORM platform)530 MOS_STATUS MediaInterfacesHwInfoDeviceXe2_Lpm::Initialize(PLATFORM platform)
531 {
532     m_hwInfo.SetDeviceInfo(IP_VERSION_XE2_LPM, platform.usRevId);
533     return MOS_STATUS_SUCCESS;
534 }
535 
536 static bool lnlRegisteredMcpy =
537     MediaFactory<uint32_t, McpyDeviceNext>::
538         Register<McpyDeviceXe2_Lpm>((uint32_t)IGFX_LUNARLAKE);
539 
Initialize(PMOS_INTERFACE osInterface,MhwInterfacesNext * mhwInterfaces)540 MOS_STATUS McpyDeviceXe2_Lpm::Initialize(
541     PMOS_INTERFACE     osInterface,
542     MhwInterfacesNext *mhwInterfaces)
543 {
544 #define MCPY_FAILURE()              \
545     {                               \
546         if (device != nullptr)      \
547         {                           \
548             MOS_Delete(device);     \
549         }                           \
550         return MOS_STATUS_NO_SPACE; \
551     }
552 
553     MHW_FUNCTION_ENTER;
554 
555     Mcpy *device = nullptr;
556 
557     if (nullptr == mhwInterfaces->m_miItf)
558     {
559         MCPY_FAILURE();
560     }
561 
562     if (nullptr == mhwInterfaces->m_veboxItf)
563     {
564         MCPY_FAILURE();
565     }
566 
567     if (nullptr == mhwInterfaces->m_bltItf)
568     {
569         MCPY_FAILURE();
570     }
571 
572     device = MOS_New(Mcpy);
573 
574     if (device == nullptr)
575     {
576         MCPY_FAILURE();
577     }
578 
579     if (device->Initialize(
580             osInterface, mhwInterfaces) != MOS_STATUS_SUCCESS)
581     {
582         MOS_Delete(device);
583         MOS_OS_CHK_STATUS_RETURN(MOS_STATUS_UNINITIALIZED);
584     }
585 
586     m_mcpyDevice = device;
587 
588     return MOS_STATUS_SUCCESS;
589 }
590