feature: Add support for late binding version on linux

Related-To: NEO-15216

Signed-off-by: shubham kumar <shubham.kumar@intel.com>

level_zero/sysman/source/api/firmware/linux/sysman_os_firmware_imp.cpp

@@ -30,9 +30,9 @@ void OsFirmware::getSupportedFwTypes(std::vector<std::string> &supportedFwTypes,
         } else {
             auto pSysmanProductHelper = pLinuxSysmanImp->getSysmanProductHelper();
             pSysmanProductHelper->getDeviceSupportedFwTypes(pFwInterface, supportedFwTypes);
-            if (pSysmanProductHelper->isLateBindingSupported()) {
-                pFwInterface->getLateBindingSupportedFwTypes(supportedFwTypes);
-            }
+            // get supported late binding fw handles
+            auto pSysmanKmdInterface = pLinuxSysmanImp->getSysmanKmdInterface();
+            pSysmanKmdInterface->getLateBindingSupportedFwTypes(supportedFwTypes);
         }
     }
 }
@@ -65,7 +65,7 @@ ze_result_t LinuxFirmwareImp::osGetFirmwareFlashProgress(uint32_t *pCompletionPe
 }
 
 LinuxFirmwareImp::LinuxFirmwareImp(OsSysman *pOsSysman, const std::string &fwType) : osFwType(fwType) {
-    LinuxSysmanImp *pLinuxSysmanImp = static_cast<LinuxSysmanImp *>(pOsSysman);
+    pLinuxSysmanImp = static_cast<LinuxSysmanImp *>(pOsSysman);
     if (!pLinuxSysmanImp->isDeviceInSurvivabilityMode()) {
         pSysfsAccess = &pLinuxSysmanImp->getSysfsAccess();
     }

level_zero/sysman/source/api/firmware/linux/sysman_os_firmware_imp.h

@@ -10,6 +10,7 @@
 
 #include "level_zero/sysman/source/api/firmware/sysman_firmware_imp.h"
 #include "level_zero/sysman/source/api/firmware/sysman_os_firmware.h"
+#include "level_zero/sysman/source/shared/linux/kmd_interface/sysman_kmd_interface.h"
 #include "level_zero/sysman/source/shared/linux/zes_os_sysman_imp.h"
 
 namespace L0 {
@@ -17,6 +18,7 @@ namespace Sysman {
 
 class FirmwareUtil;
 class SysFsAccessInterface;
+class LinuxSysmanImp;
 
 class LinuxFirmwareImp : public OsFirmware, NEO::NonCopyableAndNonMovableClass {
   public:
@@ -32,6 +34,7 @@ class LinuxFirmwareImp : public OsFirmware, NEO::NonCopyableAndNonMovableClass {
     ~LinuxFirmwareImp() override = default;
 
   protected:
+    LinuxSysmanImp *pLinuxSysmanImp = nullptr;
     FirmwareUtil *pFwInterface = nullptr;
     SysFsAccessInterface *pSysfsAccess = nullptr;
     std::string osFwType;

level_zero/sysman/source/api/firmware/linux/sysman_os_firmware_imp_helper.cpp

@@ -54,6 +54,10 @@ ze_result_t LinuxFirmwareImp::getFirmwareVersion(std::string fwType, zes_firmwar
         return result;
     }
     if (std::find(lateBindingFirmwareTypes.begin(), lateBindingFirmwareTypes.end(), fwType) != lateBindingFirmwareTypes.end()) {
+        if (pLinuxSysmanImp->getSysmanKmdInterface()->isLateBindingVersionAvailable(fwType, fwVersion)) {
+            strncpy_s(static_cast<char *>(pProperties->version), ZES_STRING_PROPERTY_SIZE, fwVersion.c_str(), ZES_STRING_PROPERTY_SIZE - 1);
+            return ZE_RESULT_SUCCESS;
+        }
         return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
     }
     ze_result_t result = pFwInterface->getFwVersion(fwType, fwVersion);

level_zero/sysman/source/shared/linux/kmd_interface/sysman_kmd_interface.h

@@ -195,6 +195,8 @@ class SysmanKmdInterface {
     const std::string getSysmanDeviceDirName() const;
     ze_result_t checkErrorNumberAndReturnStatus();
     virtual ze_result_t readPcieDowngradeAttribute(std::string sysfsName, uint32_t &val) { return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; }
+    virtual void getLateBindingSupportedFwTypes(std::vector<std::string> &fwTypes) {}
+    virtual bool isLateBindingVersionAvailable(std::string fwType, std::string &fwVersion) { return false; }
 
   protected:
     std::unique_ptr<FsAccessInterface> pFsAccess;
@@ -420,6 +422,8 @@ class SysmanKmdInterfaceXe : public SysmanKmdInterface {
     std::string getBurstPowerLimitFile(SysfsName sysfsName, uint32_t subDeviceId, bool baseDirectoryExists) override;
     std::string getFreqMediaDomainBasePath() override;
     ze_result_t readPcieDowngradeAttribute(std::string sysfsName, uint32_t &val) override;
+    void getLateBindingSupportedFwTypes(std::vector<std::string> &fwTypes) override;
+    bool isLateBindingVersionAvailable(std::string fwType, std::string &fwVersion) override;
 
   protected:
     std::map<SysfsName, valuePair> sysfsNameToFileMap;

level_zero/sysman/source/shared/linux/kmd_interface/sysman_kmd_interface_xe.cpp

@@ -25,6 +25,10 @@ static const std::map<__u16, std::string> xeEngineClassToSysfsEngineMap = {
     {DRM_XE_ENGINE_CLASS_VIDEO_DECODE, "vcs"},
     {DRM_XE_ENGINE_CLASS_VIDEO_ENHANCE, "vecs"}};
 
+static const std::map<std::string, std::string> lateBindingSysfsFileToNameMap = {
+    {"VRConfig", "device/lb_voltage_regulator_version"},
+    {"FanTable", "device/lb_fan_control_version"}};
+
 SysmanKmdInterfaceXe::SysmanKmdInterfaceXe(SysmanProductHelper *pSysmanProductHelper) {
     initSysfsNameToFileMap(pSysmanProductHelper);
     initSysfsNameToNativeUnitMap(pSysmanProductHelper);
@@ -406,5 +410,22 @@ ze_result_t SysmanKmdInterfaceXe::readPcieDowngradeAttribute(std::string sysfsNa
     return result;
 }
 
+void SysmanKmdInterfaceXe::getLateBindingSupportedFwTypes(std::vector<std::string> &fwTypes) {
+    for (auto it = lateBindingSysfsFileToNameMap.begin(); it != lateBindingSysfsFileToNameMap.end(); ++it) {
+        if (pSysfsAccess->canRead(it->second) == ZE_RESULT_SUCCESS) {
+            fwTypes.push_back(it->first);
+        }
+    }
+}
+
+bool SysmanKmdInterfaceXe::isLateBindingVersionAvailable(std::string fwType, std::string &fwVersion) {
+    auto key = lateBindingSysfsFileToNameMap.find(fwType);
+    if (key == lateBindingSysfsFileToNameMap.end()) {
+        return false;
+    }
+    ze_result_t result = pSysfsAccess->read(key->second.data(), fwVersion);
+    return result == ZE_RESULT_SUCCESS ? true : false;
+}
+
 } // namespace Sysman
 } // namespace L0

level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper.h

@@ -89,7 +89,6 @@ class SysmanProductHelper {
 
     // Firmware
     virtual void getDeviceSupportedFwTypes(FirmwareUtil *pFwInterface, std::vector<std::string> &fwTypes) = 0;
-    virtual bool isLateBindingSupported() = 0;
 
     // Ecc
     virtual bool isEccConfigurationSupported() = 0;

level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper_hw.h

@@ -63,7 +63,6 @@ class SysmanProductHelperHw : public SysmanProductHelper {
 
     // Firmware
     void getDeviceSupportedFwTypes(FirmwareUtil *pFwInterface, std::vector<std::string> &fwTypes) override;
-    bool isLateBindingSupported() override;
 
     // Ecc
     bool isEccConfigurationSupported() override;

level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper_hw.inl

@@ -353,11 +353,6 @@ void SysmanProductHelperHw<gfxProduct>::getDeviceSupportedFwTypes(FirmwareUtil *
     pFwInterface->getDeviceSupportedFwTypes(fwTypes);
 }
 
-template <PRODUCT_FAMILY gfxProduct>
-bool SysmanProductHelperHw<gfxProduct>::isLateBindingSupported() {
-    return false;
-}
-
 template <PRODUCT_FAMILY gfxProduct>
 bool SysmanProductHelperHw<gfxProduct>::isEccConfigurationSupported() {
     return false;

level_zero/sysman/source/shared/linux/product_helper/xe2_hpg_core/bmg/sysman_product_helper_bmg.cpp

@@ -1709,11 +1709,6 @@ bool SysmanProductHelperHw<gfxProduct>::isEccConfigurationSupported() {
     return true;
 }
 
-template <>
-bool SysmanProductHelperHw<gfxProduct>::isLateBindingSupported() {
-    return true;
-}
-
 template <>
 bool SysmanProductHelperHw<gfxProduct>::isPcieDowngradeSupported() {
     return true;

level_zero/sysman/test/unit_tests/sources/firmware/linux/mock_zes_sysman_firmware.h

@@ -18,10 +18,11 @@ constexpr uint32_t mockFwHandlesCount = 3;
 const std::string mockFwVersion("DG01->0->2026");
 const std::string mockOpromVersion("OPROM CODE VERSION:123_OPROM DATA VERSION:456");
 const std::string mockPscVersion("version 1 : 2021/09/15 00:43:12");
+const std::string mocklateBindingVersion("1.2.3.4");
 const std::string mockUnknownVersion("unknown");
-std::vector<std::string> mockSupportedFirmwareTypes = {"GSC", "OptionROM", "PSC"};
-std::vector<std::string> mockUnsupportedFwTypes = {"unknown"};
-std::string mockEmpty = {};
+const std::vector<std::string> mockSupportedFirmwareTypes = {"GSC", "OptionROM", "PSC"};
+const std::vector<std::string> mockUnsupportedFwTypes = {"unknown"};
+const std::string mockEmpty = {};
 class FirmwareInterface : public L0::Sysman::FirmwareUtil {};
 class FirmwareFsAccess : public L0::Sysman::FsAccessInterface {};
 class FirmwareSysfsAccess : public L0::Sysman::SysFsAccessInterface {};
@@ -31,6 +32,7 @@ struct MockFirmwareFsAccess : public FirmwareFsAccess {};
 struct MockFirmwareSysfsAccess : public L0::Sysman::SysFsAccessInterface {
 
     ze_result_t readResult = ZE_RESULT_SUCCESS;
+    ze_result_t canReadResult = ZE_RESULT_SUCCESS;
     ze_result_t scanDirEntriesResult = ZE_RESULT_SUCCESS;
     ze_bool_t isNullDirEntries = false;
 
@@ -43,6 +45,9 @@ struct MockFirmwareSysfsAccess : public L0::Sysman::SysFsAccessInterface {
         if (!file.compare("device/iaf.31/pscbin_version") || !file.compare("device/iaf.0/pscbin_version")) {
             val = mockPscVersion;
         }
+        if (!file.compare("device/lb_voltage_regulator_version") || !file.compare("device/lb_fan_control_version")) {
+            val = mocklateBindingVersion;
+        }
         return ZE_RESULT_SUCCESS;
     }
     ze_result_t scanDirEntries(const std::string dir, std::vector<std::string> &list) override {
@@ -62,6 +67,12 @@ struct MockFirmwareSysfsAccess : public L0::Sysman::SysFsAccessInterface {
         }
         return ZE_RESULT_SUCCESS;
     }
+    ze_result_t canRead(const std::string file) override {
+        if (canReadResult != ZE_RESULT_SUCCESS) {
+            return canReadResult;
+        }
+        return ZE_RESULT_SUCCESS;
+    }
 
     MockFirmwareSysfsAccess() = default;
     ~MockFirmwareSysfsAccess() override = default;

level_zero/sysman/test/unit_tests/sources/firmware/linux/test_zes_sysman_firmware.cpp

@@ -66,48 +66,6 @@ class ZesSysmanFirmwareFixture : public SysmanDeviceFixture {
     }
 };
 
-HWTEST2_F(ZesSysmanFirmwareFixture, GivenComponentCountZeroWhenCallingzesFirmwareGetThenZeroCountIsReturnedAndVerifyzesFirmwareGetCallSucceeds, IsXeCore) {
-    std::vector<zes_firmware_handle_t> firmwareHandle{};
-    uint32_t count = 0;
-
-    ze_result_t result = zesDeviceEnumFirmwares(device->toHandle(), &count, nullptr);
-
-    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
-    EXPECT_EQ(count, mockFwHandlesCount);
-
-    uint32_t testCount = count + 1;
-
-    result = zesDeviceEnumFirmwares(device->toHandle(), &testCount, nullptr);
-
-    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
-    EXPECT_EQ(testCount, count);
-
-    firmwareHandle.resize(count);
-    result = zesDeviceEnumFirmwares(device->toHandle(), &count, firmwareHandle.data());
-
-    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
-    EXPECT_EQ(count, mockFwHandlesCount);
-
-    L0::Sysman::FirmwareImp *ptestFirmwareImp = new L0::Sysman::FirmwareImp(pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman, mockSupportedFirmwareTypes[0]);
-    pSysmanDeviceImp->pFirmwareHandleContext->handleList.push_back(ptestFirmwareImp);
-    result = zesDeviceEnumFirmwares(device->toHandle(), &count, nullptr);
-
-    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
-    EXPECT_EQ(count, mockFwHandlesCount);
-
-    testCount = count;
-
-    firmwareHandle.resize(testCount);
-    result = zesDeviceEnumFirmwares(device->toHandle(), &testCount, firmwareHandle.data());
-
-    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
-    EXPECT_NE(nullptr, firmwareHandle.data());
-    EXPECT_EQ(testCount, mockFwHandlesCount);
-
-    pSysmanDeviceImp->pFirmwareHandleContext->handleList.pop_back();
-    delete ptestFirmwareImp;
-}
-
 TEST_F(ZesSysmanFirmwareFixture, GivenValidDeviceHandleAndFirmwareUnSupportedWhenCallingEnumerateThenVerifyFirmwareDomainsAreZero) {
 
     struct MockSysmanProductHelperFirmware : L0::Sysman::SysmanProductHelperHw<IGFX_UNKNOWN> {
@@ -126,125 +84,6 @@ TEST_F(ZesSysmanFirmwareFixture, GivenValidDeviceHandleAndFirmwareUnSupportedWhe
     EXPECT_EQ(count, 0u);
 }
 
-HWTEST2_F(ZesSysmanFirmwareFixture, GivenValidFirmwareHandleWhenGettingFirmwarePropertiesThenVersionIsReturned, IsXeCore) {
-    initFirmware();
-
-    L0::Sysman::FirmwareImp *ptestFirmwareImp = new L0::Sysman::FirmwareImp(pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman, mockSupportedFirmwareTypes[0]);
-    pSysmanDeviceImp->pFirmwareHandleContext->handleList.push_back(ptestFirmwareImp);
-
-    auto handles = getFirmwareHandles(mockFwHandlesCount);
-    ASSERT_NE(nullptr, handles[0]);
-    zes_firmware_properties_t properties = {};
-    EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareGetProperties(handles[0], &properties));
-    EXPECT_STREQ("GFX", properties.name);
-    EXPECT_STREQ(mockFwVersion.c_str(), properties.version);
-
-    pSysmanDeviceImp->pFirmwareHandleContext->handleList.pop_back();
-    delete ptestFirmwareImp;
-}
-
-HWTEST2_F(ZesSysmanFirmwareFixture, GivenValidFirmwareHandleWhenGettingPscPropertiesThenVersionIsReturned, IsXeCore) {
-    initFirmware();
-
-    L0::Sysman::FirmwareImp *ptestFirmwareImp = new L0::Sysman::FirmwareImp(pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman, mockSupportedFirmwareTypes[2]);
-    pSysmanDeviceImp->pFirmwareHandleContext->handleList.push_back(ptestFirmwareImp);
-
-    auto handles = getFirmwareHandles(mockFwHandlesCount);
-    ASSERT_NE(nullptr, handles[2]);
-
-    zes_firmware_properties_t properties = {};
-    EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareGetProperties(handles[2], &properties));
-    EXPECT_STREQ(mockSupportedFirmwareTypes[2].c_str(), properties.name);
-    EXPECT_STREQ(mockPscVersion.c_str(), properties.version);
-
-    pSysmanDeviceImp->pFirmwareHandleContext->handleList.pop_back();
-    delete ptestFirmwareImp;
-}
-
-HWTEST2_F(ZesSysmanFirmwareFixture, GivenNullDirEntriesWhenGettingPscPropertiesThenUnknownVersionIsReturned, IsXeCore) {
-    initFirmware();
-
-    L0::Sysman::FirmwareImp *ptestFirmwareImp = new L0::Sysman::FirmwareImp(pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman, mockSupportedFirmwareTypes[2]);
-    pSysmanDeviceImp->pFirmwareHandleContext->handleList.push_back(ptestFirmwareImp);
-
-    pMockSysfsAccess->isNullDirEntries = true;
-    auto handles = getFirmwareHandles(mockFwHandlesCount);
-
-    zes_firmware_properties_t properties = {};
-    ASSERT_NE(nullptr, handles[2]);
-    EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareGetProperties(handles[2], &properties));
-    EXPECT_STREQ(mockSupportedFirmwareTypes[2].c_str(), properties.name);
-    EXPECT_STREQ(mockUnknownVersion.c_str(), properties.version);
-
-    pSysmanDeviceImp->pFirmwareHandleContext->handleList.pop_back();
-    delete ptestFirmwareImp;
-}
-
-HWTEST2_F(ZesSysmanFirmwareFixture, GivenValidFirmwareHandleWhenFailedToReadPSCVersionFromSysfsThenUnknownVersionIsReturned, IsXeCore) {
-    initFirmware();
-
-    L0::Sysman::FirmwareImp *ptestFirmwareImp = new L0::Sysman::FirmwareImp(pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman, mockSupportedFirmwareTypes[2]);
-    pSysmanDeviceImp->pFirmwareHandleContext->handleList.push_back(ptestFirmwareImp);
-
-    pMockSysfsAccess->readResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
-    auto handles = getFirmwareHandles(mockFwHandlesCount);
-    ASSERT_NE(nullptr, handles[2]);
-
-    zes_firmware_properties_t properties = {};
-    EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareGetProperties(handles[2], &properties));
-    EXPECT_STREQ(mockSupportedFirmwareTypes[2].c_str(), properties.name);
-    EXPECT_STREQ(mockUnknownVersion.c_str(), properties.version);
-
-    pSysmanDeviceImp->pFirmwareHandleContext->handleList.pop_back();
-    delete ptestFirmwareImp;
-}
-
-HWTEST2_F(ZesSysmanFirmwareFixture, GivenFwVersionsUnsupportedWhenInitializingFirmwareContextThenExpectZeroHandles, IsXeCore) {
-    for (const auto &handle : pSysmanDeviceImp->pFirmwareHandleContext->handleList) {
-        delete handle;
-    }
-    pSysmanDeviceImp->pFirmwareHandleContext->handleList.clear();
-    pMockFwInterface->isFirmwareVersionsSupported = false;
-
-    pSysmanDeviceImp->pFirmwareHandleContext->init();
-
-    EXPECT_EQ(0u, pSysmanDeviceImp->pFirmwareHandleContext->handleList.size());
-}
-
-HWTEST2_F(ZesSysmanFirmwareFixture, GivenValidFirmwareHandleWhenFlashingGscFirmwareThenSuccessIsReturned, IsXeCore) {
-    initFirmware();
-
-    L0::Sysman::FirmwareImp *ptestFirmwareImp = new L0::Sysman::FirmwareImp(pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman, mockSupportedFirmwareTypes[0]);
-    pSysmanDeviceImp->pFirmwareHandleContext->handleList.push_back(ptestFirmwareImp);
-
-    auto handles = getFirmwareHandles(mockFwHandlesCount);
-    uint8_t testImage[ZES_STRING_PROPERTY_SIZE] = {};
-    memset(testImage, 0xA, ZES_STRING_PROPERTY_SIZE);
-    for (auto handle : handles) {
-        ASSERT_NE(nullptr, handle);
-        EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareFlash(handle, (void *)testImage, ZES_STRING_PROPERTY_SIZE));
-    }
-    pSysmanDeviceImp->pFirmwareHandleContext->handleList.pop_back();
-    delete ptestFirmwareImp;
-}
-
-HWTEST2_F(ZesSysmanFirmwareFixture, GivenValidFirmwareHandleWhenFlashingPscFirmwareThenSuccessIsReturned, IsXeCore) {
-    initFirmware();
-
-    L0::Sysman::FirmwareImp *ptestFirmwareImp = new L0::Sysman::FirmwareImp(pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman, mockSupportedFirmwareTypes[1]);
-    pSysmanDeviceImp->pFirmwareHandleContext->handleList.push_back(ptestFirmwareImp);
-
-    auto handles = getFirmwareHandles(mockFwHandlesCount);
-    uint8_t testImage[ZES_STRING_PROPERTY_SIZE] = {};
-    memset(testImage, 0xA, ZES_STRING_PROPERTY_SIZE);
-    for (auto handle : handles) {
-        ASSERT_NE(nullptr, handle);
-        EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareFlash(handle, (void *)testImage, ZES_STRING_PROPERTY_SIZE));
-    }
-    pSysmanDeviceImp->pFirmwareHandleContext->handleList.pop_back();
-    delete ptestFirmwareImp;
-}
-
 TEST_F(ZesSysmanFirmwareFixture, GivenValidFirmwareHandleWhenFlashingUnkownFirmwareThenFailureIsReturned) {
     for (const auto &handle : pSysmanDeviceImp->pFirmwareHandleContext->handleList) {
         delete handle;
@@ -264,158 +103,6 @@ TEST_F(ZesSysmanFirmwareFixture, GivenValidFirmwareHandleWhenFlashingUnkownFirmw
     delete ptestFirmwareImp;
 }
 
-HWTEST2_F(ZesSysmanFirmwareFixture, GivenValidFirmwareHandleFirmwareLibraryCallFailureWhenGettingFirmwarePropertiesThenUnknownIsReturned, IsXeCore) {
-    initFirmware();
-
-    for (const auto &handle : pSysmanDeviceImp->pFirmwareHandleContext->handleList) {
-        delete handle;
-    }
-    pSysmanDeviceImp->pFirmwareHandleContext->handleList.clear();
-    pMockSysfsAccess->scanDirEntriesResult = ZE_RESULT_ERROR_UNKNOWN;
-    pMockFwInterface->getFwVersionResult = ZE_RESULT_ERROR_UNINITIALIZED;
-
-    pSysmanDeviceImp->pFirmwareHandleContext->init();
-    auto handles = getFirmwareHandles(mockFwHandlesCount);
-
-    zes_firmware_properties_t properties = {};
-    ASSERT_NE(nullptr, handles[0]);
-    EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareGetProperties(handles[0], &properties));
-    EXPECT_STREQ("GFX", properties.name);
-    EXPECT_STREQ("unknown", properties.version);
-
-    ASSERT_NE(nullptr, handles[1]);
-    EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareGetProperties(handles[1], &properties));
-    EXPECT_STREQ(mockSupportedFirmwareTypes[1].c_str(), properties.name);
-    EXPECT_STREQ("unknown", properties.version);
-
-    ASSERT_NE(nullptr, handles[2]);
-    EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareGetProperties(handles[2], &properties));
-    EXPECT_STREQ(mockSupportedFirmwareTypes[2].c_str(), properties.name);
-    EXPECT_STREQ("unknown", properties.version);
-}
-
-HWTEST2_F(ZesSysmanFirmwareFixture, GivenNewFirmwareContextWithHandleSizeZeroWhenFirmwareEnumerateIsCalledThenSuccessResultIsReturned, IsXeCore) {
-    uint32_t count = 0;
-    L0::Sysman::OsSysman *pOsSysman = pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman;
-
-    for (const auto &handle : pSysmanDeviceImp->pFirmwareHandleContext->handleList) {
-        delete handle;
-    }
-    pSysmanDeviceImp->pFirmwareHandleContext->handleList.clear();
-    delete pSysmanDeviceImp->pFirmwareHandleContext;
-
-    pSysmanDeviceImp->pFirmwareHandleContext = new L0::Sysman::FirmwareHandleContext(pOsSysman);
-    EXPECT_EQ(0u, pSysmanDeviceImp->pFirmwareHandleContext->handleList.size());
-    ze_result_t result = zesDeviceEnumFirmwares(device->toHandle(), &count, nullptr);
-    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
-    EXPECT_EQ(3u, count);
-}
-
-HWTEST2_F(ZesSysmanFirmwareFixture, GivenValidFirmwareHandleWhenGettingFirmwareFlashProgressThenSuccessIsReturned, IsXeCore) {
-    initFirmware();
-
-    L0::Sysman::FirmwareImp *ptestFirmwareImp = new L0::Sysman::FirmwareImp(pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman, mockSupportedFirmwareTypes[1]);
-    pSysmanDeviceImp->pFirmwareHandleContext->handleList.push_back(ptestFirmwareImp);
-
-    auto handles = getFirmwareHandles(mockFwHandlesCount);
-    uint32_t completionPercent = 0;
-
-    ASSERT_NE(nullptr, handles[1]);
-    EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareGetFlashProgress(handles[1], &completionPercent));
-}
-
-HWTEST2_F(ZesSysmanFirmwareFixture, GivenValidFirmwareHandleWhenGettingFirmwareSecurityVersionThenUnSupportedIsReturned, IsXeCore) {
-    initFirmware();
-
-    L0::Sysman::FirmwareImp *ptestFirmwareImp = new L0::Sysman::FirmwareImp(pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman, mockSupportedFirmwareTypes[1]);
-    pSysmanDeviceImp->pFirmwareHandleContext->handleList.push_back(ptestFirmwareImp);
-
-    auto handles = getFirmwareHandles(mockFwHandlesCount);
-    ASSERT_NE(nullptr, handles[1]);
-    char pVersion[100];
-    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFirmwareGetSecurityVersionExp(handles[1], pVersion));
-}
-
-HWTEST2_F(ZesSysmanFirmwareFixture, GivenValidFirmwareHandleWhenSettingFirmwareSecurityVersionThenUnSupportedIsReturned, IsXeCore) {
-    initFirmware();
-
-    L0::Sysman::FirmwareImp *ptestFirmwareImp = new L0::Sysman::FirmwareImp(pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman, mockSupportedFirmwareTypes[1]);
-    pSysmanDeviceImp->pFirmwareHandleContext->handleList.push_back(ptestFirmwareImp);
-
-    auto handles = getFirmwareHandles(mockFwHandlesCount);
-    ASSERT_NE(nullptr, handles[1]);
-    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFirmwareSetSecurityVersionExp(handles[1]));
-}
-
-HWTEST2_F(ZesSysmanFirmwareFixture, GivenValidFirmwareHandleWhenGettingFirmwareConsoleLogsThenUnSupportedIsReturned, IsXeCore) {
-    initFirmware();
-
-    L0::Sysman::FirmwareImp *ptestFirmwareImp = new L0::Sysman::FirmwareImp(pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman, mockSupportedFirmwareTypes[1]);
-    pSysmanDeviceImp->pFirmwareHandleContext->handleList.push_back(ptestFirmwareImp);
-
-    auto handles = getFirmwareHandles(mockFwHandlesCount);
-    ASSERT_NE(nullptr, handles[1]);
-
-    size_t pSize;
-    char *pFirmwareLog = nullptr;
-    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFirmwareGetConsoleLogs(handles[1], &pSize, pFirmwareLog));
-}
-
-HWTEST2_F(ZesSysmanFirmwareFixture, GivenComponentCountZeroAndLateBindingIsSupportedThenWhenCallingZesFirmwareGetProperCountIsReturned, IsBMG) {
-    constexpr uint32_t mockFwHandlesCount = 5;
-    std::vector<zes_firmware_handle_t> firmwareHandle{};
-    uint32_t count = 0;
-
-    ze_result_t result = zesDeviceEnumFirmwares(device->toHandle(), &count, nullptr);
-
-    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
-    EXPECT_EQ(count, mockFwHandlesCount);
-
-    uint32_t testCount = count + 1;
-
-    result = zesDeviceEnumFirmwares(device->toHandle(), &testCount, nullptr);
-
-    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
-    EXPECT_EQ(testCount, count);
-
-    firmwareHandle.resize(count);
-    result = zesDeviceEnumFirmwares(device->toHandle(), &count, firmwareHandle.data());
-
-    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
-    EXPECT_EQ(count, mockFwHandlesCount);
-}
-
-HWTEST2_F(ZesSysmanFirmwareFixture, GivenValidLateBindingFirmwareHandleWhenFlashingFirmwareThenSuccessIsReturned, IsBMG) {
-    constexpr uint32_t mockFwHandlesCount = 5;
-    initFirmware();
-
-    auto handles = getFirmwareHandles(mockFwHandlesCount);
-    for (auto handle : handles) {
-        zes_firmware_properties_t properties = {};
-        EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareGetProperties(handle, &properties));
-        if (std::find(lateBindingFirmwareTypes.begin(), lateBindingFirmwareTypes.end(), properties.name) != lateBindingFirmwareTypes.end()) {
-            uint8_t testImage[ZES_STRING_PROPERTY_SIZE] = {};
-            memset(testImage, 0xA, ZES_STRING_PROPERTY_SIZE);
-            EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareFlash(handle, (void *)testImage, ZES_STRING_PROPERTY_SIZE));
-        }
-    }
-}
-
-HWTEST2_F(ZesSysmanFirmwareFixture, GivenValidLateBindingFirmwareHandleWhenGettingFirmwarePropertiesThenValidVersionIsReturned, IsBMG) {
-
-    constexpr uint32_t mockFwHandlesCount = 5;
-    initFirmware();
-
-    auto handles = getFirmwareHandles(mockFwHandlesCount);
-    for (auto handle : handles) {
-        zes_firmware_properties_t properties = {};
-        EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareGetProperties(handle, &properties));
-        if (std::find(lateBindingFirmwareTypes.begin(), lateBindingFirmwareTypes.end(), properties.name) != lateBindingFirmwareTypes.end()) {
-            EXPECT_STREQ(mockUnknownVersion.c_str(), properties.version);
-        }
-    }
-}
-
 using SysmanSurvivabilityDeviceTest = ::testing::Test;
 struct dirent mockSurvivabilityDevEntries[] = {
     {0, 0, 0, 0, "0000:03:00.0"},

level_zero/sysman/test/unit_tests/sources/shared/linux/kmd_interface/test_sysman_kmd_interface_i915_prelim.cpp

@@ -322,6 +322,13 @@ TEST_F(SysmanFixtureDeviceI915Prelim, GivenSysmanKmdInterfaceAndPmuReadFailsWhen
     EXPECT_EQ(pSysmanKmdInterface->readBusynessFromGroupFd(pPmuInterface.get(), fdList, &pStats), ZE_RESULT_ERROR_UNKNOWN);
 }
 
+TEST_F(SysmanFixtureDeviceI915Prelim, GivenSysmanKmdInterfaceWhenCallingIsLateBindingVersionAvailableThenFalseIsReturned) {
+    auto pSysmanKmdInterface = pLinuxSysmanImp->pSysmanKmdInterface.get();
+    std::string val;
+    EXPECT_FALSE(pSysmanKmdInterface->isLateBindingVersionAvailable("FanTable", val));
+    EXPECT_FALSE(pSysmanKmdInterface->isLateBindingVersionAvailable("VRConfig", val));
+}
+
 } // namespace ult
 } // namespace Sysman
 } // namespace L0

level_zero/sysman/test/unit_tests/sources/shared/linux/kmd_interface/test_sysman_kmd_interface_i915_upstream.cpp

@@ -325,6 +325,13 @@ TEST_F(SysmanFixtureDeviceI915Upstream, GivenSysmanKmdInterfaceWhenGetEnergyCoun
     EXPECT_EQ(expectedFilePath, pSysmanKmdInterface->getEnergyCounterNodeFile(ZES_POWER_DOMAIN_CARD));
 }
 
+TEST_F(SysmanFixtureDeviceI915Upstream, GivenSysmanKmdInterfaceWhenCallingIsLateBindingVersionAvailableThenFalseIsReturned) {
+    auto pSysmanKmdInterface = pLinuxSysmanImp->pSysmanKmdInterface.get();
+    std::string val;
+    EXPECT_FALSE(pSysmanKmdInterface->isLateBindingVersionAvailable("FanTable", val));
+    EXPECT_FALSE(pSysmanKmdInterface->isLateBindingVersionAvailable("VRConfig", val));
+}
+
 } // namespace ult
 } // namespace Sysman
 } // namespace L0

level_zero/sysman/test/unit_tests/sources/shared/linux/kmd_interface/test_sysman_kmd_interface_xe.cpp

@@ -414,6 +414,12 @@ TEST_F(SysmanFixtureDeviceXe, GivenSysmanKmdInterfaceWhenCallingReadPcieDowngrad
     EXPECT_EQ(pSysmanKmdInterface->readPcieDowngradeAttribute("unknown", val), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
 }
 
+TEST_F(SysmanFixtureDeviceXe, GivenSysmanKmdInterfaceWhenCallingIsLateBindingVersionAvailableWithInvalidSysfsNodeThenUnsupportedIsReturned) {
+    auto pSysmanKmdInterface = pLinuxSysmanImp->pSysmanKmdInterface.get();
+    std::string val;
+    EXPECT_FALSE(pSysmanKmdInterface->isLateBindingVersionAvailable("unknown", val));
+}
+
 } // namespace ult
 } // namespace Sysman
 } // namespace L0

level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/CMakeLists.txt

@@ -24,6 +24,8 @@ if(UNIX)
                  ${CMAKE_CURRENT_SOURCE_DIR}/sysman_product_helper_engine_tests_xe.cpp
                  ${CMAKE_CURRENT_SOURCE_DIR}/sysman_product_helper_vf_management_tests.cpp
                  ${CMAKE_CURRENT_SOURCE_DIR}/sysman_product_helper_ecc_tests.cpp
+                 ${CMAKE_CURRENT_SOURCE_DIR}/sysman_product_helper_firmware_tests.cpp
+                 ${CMAKE_CURRENT_SOURCE_DIR}/sysman_product_helper_firmware_tests_xe.cpp
   )
 endif()
 add_subdirectories()

level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/sysman_product_helper_firmware_tests.cpp

@@ -0,0 +1,329 @@
+/*
+ * Copyright (C) 2025 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "level_zero/sysman/source/driver/sysman_os_driver.h"
+#include "level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper_hw.h"
+#include "level_zero/sysman/test/unit_tests/sources/firmware/linux/mock_zes_sysman_firmware.h"
+
+#include <algorithm>
+
+namespace L0 {
+namespace Sysman {
+namespace ult {
+
+class ZesSysmanProductHelperFirmwareFixture : public SysmanDeviceFixture {
+
+  protected:
+    zes_firmware_handle_t hSysmanFirmware = {};
+    std::unique_ptr<MockFirmwareInterface> pMockFwInterface;
+    L0::Sysman::FirmwareUtil *pFwUtilInterfaceOld = nullptr;
+    std::unique_ptr<MockFirmwareFsAccess> pFsAccess;
+    L0::Sysman::FsAccessInterface *pFsAccessOriginal = nullptr;
+    L0::Sysman::SysFsAccessInterface *pSysFsAccessOriginal = nullptr;
+    std::unique_ptr<MockFirmwareSysfsAccess> pMockSysfsAccess;
+    L0::Sysman::SysmanDevice *device = nullptr;
+
+    void SetUp() override {
+        SysmanDeviceFixture::SetUp();
+        pFsAccessOriginal = pLinuxSysmanImp->pFsAccess;
+        pFsAccess = std::make_unique<MockFirmwareFsAccess>();
+        pLinuxSysmanImp->pFsAccess = pFsAccess.get();
+
+        pSysFsAccessOriginal = pLinuxSysmanImp->pSysfsAccess;
+        pMockSysfsAccess = std::make_unique<MockFirmwareSysfsAccess>();
+        pLinuxSysmanImp->pSysfsAccess = pMockSysfsAccess.get();
+
+        pFwUtilInterfaceOld = pLinuxSysmanImp->pFwUtilInterface;
+        pMockFwInterface = std::make_unique<MockFirmwareInterface>();
+        pLinuxSysmanImp->pFwUtilInterface = pMockFwInterface.get();
+
+        for (const auto &handle : pSysmanDeviceImp->pFirmwareHandleContext->handleList) {
+            delete handle;
+        }
+        pSysmanDeviceImp->pFirmwareHandleContext->handleList.clear();
+        device = pSysmanDeviceImp;
+    }
+    void initFirmware() {
+        uint32_t count = 0;
+        ze_result_t result = zesDeviceEnumFirmwares(device->toHandle(), &count, nullptr);
+        EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    }
+    void TearDown() override {
+        pLinuxSysmanImp->pFwUtilInterface = pFwUtilInterfaceOld;
+        pLinuxSysmanImp->pFsAccess = pFsAccessOriginal;
+        pLinuxSysmanImp->pSysfsAccess = pSysFsAccessOriginal;
+        SysmanDeviceFixture::TearDown();
+    }
+
+    std::vector<zes_firmware_handle_t> getFirmwareHandles(uint32_t count) {
+        std::vector<zes_firmware_handle_t> handles(count, nullptr);
+        EXPECT_EQ(zesDeviceEnumFirmwares(device->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS);
+        return handles;
+    }
+};
+
+HWTEST2_F(ZesSysmanProductHelperFirmwareFixture, GivenComponentCountZeroWhenCallingzesFirmwareGetThenZeroCountIsReturnedAndVerifyzesFirmwareGetCallSucceeds, IsXeCore) {
+    std::vector<zes_firmware_handle_t> firmwareHandle{};
+    uint32_t count = 0;
+
+    ze_result_t result = zesDeviceEnumFirmwares(device->toHandle(), &count, nullptr);
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(count, mockFwHandlesCount);
+
+    uint32_t testCount = count + 1;
+
+    result = zesDeviceEnumFirmwares(device->toHandle(), &testCount, nullptr);
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(testCount, count);
+
+    firmwareHandle.resize(count);
+    result = zesDeviceEnumFirmwares(device->toHandle(), &count, firmwareHandle.data());
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(count, mockFwHandlesCount);
+
+    L0::Sysman::FirmwareImp *ptestFirmwareImp = new L0::Sysman::FirmwareImp(pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman, mockSupportedFirmwareTypes[0]);
+    pSysmanDeviceImp->pFirmwareHandleContext->handleList.push_back(ptestFirmwareImp);
+    result = zesDeviceEnumFirmwares(device->toHandle(), &count, nullptr);
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(count, mockFwHandlesCount);
+
+    testCount = count;
+
+    firmwareHandle.resize(testCount);
+    result = zesDeviceEnumFirmwares(device->toHandle(), &testCount, firmwareHandle.data());
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_NE(nullptr, firmwareHandle.data());
+    EXPECT_EQ(testCount, mockFwHandlesCount);
+
+    pSysmanDeviceImp->pFirmwareHandleContext->handleList.pop_back();
+    delete ptestFirmwareImp;
+}
+
+HWTEST2_F(ZesSysmanProductHelperFirmwareFixture, GivenValidFirmwareHandleWhenGettingFirmwarePropertiesThenVersionIsReturned, IsXeCore) {
+    initFirmware();
+
+    L0::Sysman::FirmwareImp *ptestFirmwareImp = new L0::Sysman::FirmwareImp(pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman, mockSupportedFirmwareTypes[0]);
+    pSysmanDeviceImp->pFirmwareHandleContext->handleList.push_back(ptestFirmwareImp);
+
+    auto handles = getFirmwareHandles(mockFwHandlesCount);
+    ASSERT_NE(nullptr, handles[0]);
+    zes_firmware_properties_t properties = {};
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareGetProperties(handles[0], &properties));
+    EXPECT_STREQ("GFX", properties.name);
+    EXPECT_STREQ(mockFwVersion.c_str(), properties.version);
+
+    pSysmanDeviceImp->pFirmwareHandleContext->handleList.pop_back();
+    delete ptestFirmwareImp;
+}
+
+HWTEST2_F(ZesSysmanProductHelperFirmwareFixture, GivenValidFirmwareHandleWhenGettingPscPropertiesThenVersionIsReturned, IsXeCore) {
+    initFirmware();
+
+    L0::Sysman::FirmwareImp *ptestFirmwareImp = new L0::Sysman::FirmwareImp(pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman, mockSupportedFirmwareTypes[2]);
+    pSysmanDeviceImp->pFirmwareHandleContext->handleList.push_back(ptestFirmwareImp);
+
+    auto handles = getFirmwareHandles(mockFwHandlesCount);
+    ASSERT_NE(nullptr, handles[2]);
+
+    zes_firmware_properties_t properties = {};
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareGetProperties(handles[2], &properties));
+    EXPECT_STREQ(mockSupportedFirmwareTypes[2].c_str(), properties.name);
+    EXPECT_STREQ(mockPscVersion.c_str(), properties.version);
+
+    pSysmanDeviceImp->pFirmwareHandleContext->handleList.pop_back();
+    delete ptestFirmwareImp;
+}
+
+HWTEST2_F(ZesSysmanProductHelperFirmwareFixture, GivenNullDirEntriesWhenGettingPscPropertiesThenUnknownVersionIsReturned, IsXeCore) {
+    initFirmware();
+
+    L0::Sysman::FirmwareImp *ptestFirmwareImp = new L0::Sysman::FirmwareImp(pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman, mockSupportedFirmwareTypes[2]);
+    pSysmanDeviceImp->pFirmwareHandleContext->handleList.push_back(ptestFirmwareImp);
+
+    pMockSysfsAccess->isNullDirEntries = true;
+    auto handles = getFirmwareHandles(mockFwHandlesCount);
+
+    zes_firmware_properties_t properties = {};
+    ASSERT_NE(nullptr, handles[2]);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareGetProperties(handles[2], &properties));
+    EXPECT_STREQ(mockSupportedFirmwareTypes[2].c_str(), properties.name);
+    EXPECT_STREQ(mockUnknownVersion.c_str(), properties.version);
+
+    pSysmanDeviceImp->pFirmwareHandleContext->handleList.pop_back();
+    delete ptestFirmwareImp;
+}
+
+HWTEST2_F(ZesSysmanProductHelperFirmwareFixture, GivenValidFirmwareHandleWhenFailedToReadPSCVersionFromSysfsThenUnknownVersionIsReturned, IsXeCore) {
+    initFirmware();
+
+    L0::Sysman::FirmwareImp *ptestFirmwareImp = new L0::Sysman::FirmwareImp(pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman, mockSupportedFirmwareTypes[2]);
+    pSysmanDeviceImp->pFirmwareHandleContext->handleList.push_back(ptestFirmwareImp);
+
+    pMockSysfsAccess->readResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
+    auto handles = getFirmwareHandles(mockFwHandlesCount);
+    ASSERT_NE(nullptr, handles[2]);
+
+    zes_firmware_properties_t properties = {};
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareGetProperties(handles[2], &properties));
+    EXPECT_STREQ(mockSupportedFirmwareTypes[2].c_str(), properties.name);
+    EXPECT_STREQ(mockUnknownVersion.c_str(), properties.version);
+
+    pSysmanDeviceImp->pFirmwareHandleContext->handleList.pop_back();
+    delete ptestFirmwareImp;
+}
+
+HWTEST2_F(ZesSysmanProductHelperFirmwareFixture, GivenFwVersionsUnsupportedWhenInitializingFirmwareContextThenExpectZeroHandles, IsXeCore) {
+    for (const auto &handle : pSysmanDeviceImp->pFirmwareHandleContext->handleList) {
+        delete handle;
+    }
+    pSysmanDeviceImp->pFirmwareHandleContext->handleList.clear();
+    pMockFwInterface->isFirmwareVersionsSupported = false;
+
+    pSysmanDeviceImp->pFirmwareHandleContext->init();
+
+    EXPECT_EQ(0u, pSysmanDeviceImp->pFirmwareHandleContext->handleList.size());
+}
+
+HWTEST2_F(ZesSysmanProductHelperFirmwareFixture, GivenValidFirmwareHandleWhenFlashingGscFirmwareThenSuccessIsReturned, IsXeCore) {
+    initFirmware();
+
+    L0::Sysman::FirmwareImp *ptestFirmwareImp = new L0::Sysman::FirmwareImp(pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman, mockSupportedFirmwareTypes[0]);
+    pSysmanDeviceImp->pFirmwareHandleContext->handleList.push_back(ptestFirmwareImp);
+
+    auto handles = getFirmwareHandles(mockFwHandlesCount);
+    uint8_t testImage[ZES_STRING_PROPERTY_SIZE] = {};
+    memset(testImage, 0xA, ZES_STRING_PROPERTY_SIZE);
+    for (auto handle : handles) {
+        ASSERT_NE(nullptr, handle);
+        EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareFlash(handle, (void *)testImage, ZES_STRING_PROPERTY_SIZE));
+    }
+    pSysmanDeviceImp->pFirmwareHandleContext->handleList.pop_back();
+    delete ptestFirmwareImp;
+}
+
+HWTEST2_F(ZesSysmanProductHelperFirmwareFixture, GivenValidFirmwareHandleWhenFlashingPscFirmwareThenSuccessIsReturned, IsXeCore) {
+    initFirmware();
+
+    L0::Sysman::FirmwareImp *ptestFirmwareImp = new L0::Sysman::FirmwareImp(pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman, mockSupportedFirmwareTypes[1]);
+    pSysmanDeviceImp->pFirmwareHandleContext->handleList.push_back(ptestFirmwareImp);
+
+    auto handles = getFirmwareHandles(mockFwHandlesCount);
+    uint8_t testImage[ZES_STRING_PROPERTY_SIZE] = {};
+    memset(testImage, 0xA, ZES_STRING_PROPERTY_SIZE);
+    for (auto handle : handles) {
+        ASSERT_NE(nullptr, handle);
+        EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareFlash(handle, (void *)testImage, ZES_STRING_PROPERTY_SIZE));
+    }
+    pSysmanDeviceImp->pFirmwareHandleContext->handleList.pop_back();
+    delete ptestFirmwareImp;
+}
+
+HWTEST2_F(ZesSysmanProductHelperFirmwareFixture, GivenValidFirmwareHandleFirmwareLibraryCallFailureWhenGettingFirmwarePropertiesThenUnknownIsReturned, IsXeCore) {
+    initFirmware();
+
+    for (const auto &handle : pSysmanDeviceImp->pFirmwareHandleContext->handleList) {
+        delete handle;
+    }
+    pSysmanDeviceImp->pFirmwareHandleContext->handleList.clear();
+    pMockSysfsAccess->scanDirEntriesResult = ZE_RESULT_ERROR_UNKNOWN;
+    pMockFwInterface->getFwVersionResult = ZE_RESULT_ERROR_UNINITIALIZED;
+
+    pSysmanDeviceImp->pFirmwareHandleContext->init();
+    auto handles = getFirmwareHandles(mockFwHandlesCount);
+
+    zes_firmware_properties_t properties = {};
+    ASSERT_NE(nullptr, handles[0]);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareGetProperties(handles[0], &properties));
+    EXPECT_STREQ("GFX", properties.name);
+    EXPECT_STREQ("unknown", properties.version);
+
+    ASSERT_NE(nullptr, handles[1]);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareGetProperties(handles[1], &properties));
+    EXPECT_STREQ(mockSupportedFirmwareTypes[1].c_str(), properties.name);
+    EXPECT_STREQ("unknown", properties.version);
+
+    ASSERT_NE(nullptr, handles[2]);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareGetProperties(handles[2], &properties));
+    EXPECT_STREQ(mockSupportedFirmwareTypes[2].c_str(), properties.name);
+    EXPECT_STREQ("unknown", properties.version);
+}
+
+HWTEST2_F(ZesSysmanProductHelperFirmwareFixture, GivenNewFirmwareContextWithHandleSizeZeroWhenFirmwareEnumerateIsCalledThenSuccessResultIsReturned, IsXeCore) {
+    uint32_t count = 0;
+    L0::Sysman::OsSysman *pOsSysman = pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman;
+
+    for (const auto &handle : pSysmanDeviceImp->pFirmwareHandleContext->handleList) {
+        delete handle;
+    }
+    pSysmanDeviceImp->pFirmwareHandleContext->handleList.clear();
+    delete pSysmanDeviceImp->pFirmwareHandleContext;
+
+    pSysmanDeviceImp->pFirmwareHandleContext = new L0::Sysman::FirmwareHandleContext(pOsSysman);
+    EXPECT_EQ(0u, pSysmanDeviceImp->pFirmwareHandleContext->handleList.size());
+    ze_result_t result = zesDeviceEnumFirmwares(device->toHandle(), &count, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(3u, count);
+}
+
+HWTEST2_F(ZesSysmanProductHelperFirmwareFixture, GivenValidFirmwareHandleWhenGettingFirmwareFlashProgressThenSuccessIsReturned, IsXeCore) {
+    initFirmware();
+
+    L0::Sysman::FirmwareImp *ptestFirmwareImp = new L0::Sysman::FirmwareImp(pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman, mockSupportedFirmwareTypes[1]);
+    pSysmanDeviceImp->pFirmwareHandleContext->handleList.push_back(ptestFirmwareImp);
+
+    auto handles = getFirmwareHandles(mockFwHandlesCount);
+    uint32_t completionPercent = 0;
+
+    ASSERT_NE(nullptr, handles[1]);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareGetFlashProgress(handles[1], &completionPercent));
+}
+
+HWTEST2_F(ZesSysmanProductHelperFirmwareFixture, GivenValidFirmwareHandleWhenGettingFirmwareSecurityVersionThenUnSupportedIsReturned, IsXeCore) {
+    initFirmware();
+
+    L0::Sysman::FirmwareImp *ptestFirmwareImp = new L0::Sysman::FirmwareImp(pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman, mockSupportedFirmwareTypes[1]);
+    pSysmanDeviceImp->pFirmwareHandleContext->handleList.push_back(ptestFirmwareImp);
+
+    auto handles = getFirmwareHandles(mockFwHandlesCount);
+    ASSERT_NE(nullptr, handles[1]);
+    char pVersion[100];
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFirmwareGetSecurityVersionExp(handles[1], pVersion));
+}
+
+HWTEST2_F(ZesSysmanProductHelperFirmwareFixture, GivenValidFirmwareHandleWhenSettingFirmwareSecurityVersionThenUnSupportedIsReturned, IsXeCore) {
+    initFirmware();
+
+    L0::Sysman::FirmwareImp *ptestFirmwareImp = new L0::Sysman::FirmwareImp(pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman, mockSupportedFirmwareTypes[1]);
+    pSysmanDeviceImp->pFirmwareHandleContext->handleList.push_back(ptestFirmwareImp);
+
+    auto handles = getFirmwareHandles(mockFwHandlesCount);
+    ASSERT_NE(nullptr, handles[1]);
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFirmwareSetSecurityVersionExp(handles[1]));
+}
+
+HWTEST2_F(ZesSysmanProductHelperFirmwareFixture, GivenValidFirmwareHandleWhenGettingFirmwareConsoleLogsThenUnSupportedIsReturned, IsXeCore) {
+    initFirmware();
+
+    L0::Sysman::FirmwareImp *ptestFirmwareImp = new L0::Sysman::FirmwareImp(pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman, mockSupportedFirmwareTypes[1]);
+    pSysmanDeviceImp->pFirmwareHandleContext->handleList.push_back(ptestFirmwareImp);
+
+    auto handles = getFirmwareHandles(mockFwHandlesCount);
+    ASSERT_NE(nullptr, handles[1]);
+
+    size_t pSize;
+    char *pFirmwareLog = nullptr;
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFirmwareGetConsoleLogs(handles[1], &pSize, pFirmwareLog));
+}
+
+} // namespace ult
+} // namespace Sysman
+} // namespace L0

level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/sysman_product_helper_firmware_tests_xe.cpp

@@ -0,0 +1,161 @@
+/*
+ * Copyright (C) 2025 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "level_zero/sysman/source/driver/sysman_os_driver.h"
+#include "level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper_hw.h"
+#include "level_zero/sysman/test/unit_tests/sources/firmware/linux/mock_zes_sysman_firmware.h"
+#include "level_zero/sysman/test/unit_tests/sources/shared/linux/kmd_interface/mock_sysman_kmd_interface_xe.h"
+
+#include <algorithm>
+
+namespace L0 {
+namespace Sysman {
+namespace ult {
+
+class ZesSysmanProductHelperFirmwareFixtureXe : public SysmanDeviceFixture {
+
+  protected:
+    zes_firmware_handle_t hSysmanFirmware = {};
+    std::unique_ptr<MockFirmwareInterface> pMockFwInterface;
+    MockFirmwareSysfsAccess *pSysfsAccess = nullptr;
+    MockSysmanKmdInterfaceXe *pSysmanKmdInterface = nullptr;
+    L0::Sysman::FirmwareUtil *pFwUtilInterfaceOld = nullptr;
+    std::unique_ptr<MockFirmwareFsAccess> pFsAccess;
+    L0::Sysman::FsAccessInterface *pFsAccessOriginal = nullptr;
+    L0::Sysman::SysFsAccessInterface *pSysFsAccessOriginal = nullptr;
+    std::unique_ptr<MockFirmwareSysfsAccess> pMockSysfsAccess;
+    L0::Sysman::SysmanDevice *device = nullptr;
+
+    void SetUp() override {
+        SysmanDeviceFixture::SetUp();
+        pFsAccessOriginal = pLinuxSysmanImp->pFsAccess;
+        pFsAccess = std::make_unique<MockFirmwareFsAccess>();
+        pLinuxSysmanImp->pFsAccess = pFsAccess.get();
+
+        pSysFsAccessOriginal = pLinuxSysmanImp->pSysfsAccess;
+        pSysmanKmdInterface = new MockSysmanKmdInterfaceXe(pLinuxSysmanImp->getSysmanProductHelper());
+        pSysmanKmdInterface->pSysfsAccess = std::make_unique<MockFirmwareSysfsAccess>();
+        pLinuxSysmanImp->pSysfsAccess = pSysmanKmdInterface->pSysfsAccess.get();
+        pLinuxSysmanImp->pSysmanKmdInterface.reset(pSysmanKmdInterface);
+        pSysfsAccess = static_cast<MockFirmwareSysfsAccess *>(pSysmanKmdInterface->pSysfsAccess.get());
+
+        pFwUtilInterfaceOld = pLinuxSysmanImp->pFwUtilInterface;
+        pMockFwInterface = std::make_unique<MockFirmwareInterface>();
+        pLinuxSysmanImp->pFwUtilInterface = pMockFwInterface.get();
+
+        for (const auto &handle : pSysmanDeviceImp->pFirmwareHandleContext->handleList) {
+            delete handle;
+        }
+        pSysmanDeviceImp->pFirmwareHandleContext->handleList.clear();
+        device = pSysmanDeviceImp;
+    }
+    void initFirmware() {
+        uint32_t count = 0;
+        ze_result_t result = zesDeviceEnumFirmwares(device->toHandle(), &count, nullptr);
+        EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    }
+    void TearDown() override {
+        pLinuxSysmanImp->pFwUtilInterface = pFwUtilInterfaceOld;
+        pLinuxSysmanImp->pFsAccess = pFsAccessOriginal;
+        pLinuxSysmanImp->pSysfsAccess = pSysFsAccessOriginal;
+        SysmanDeviceFixture::TearDown();
+    }
+
+    std::vector<zes_firmware_handle_t> getFirmwareHandles(uint32_t count) {
+        std::vector<zes_firmware_handle_t> handles(count, nullptr);
+        EXPECT_EQ(zesDeviceEnumFirmwares(device->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS);
+        return handles;
+    }
+};
+
+HWTEST2_F(ZesSysmanProductHelperFirmwareFixtureXe, GivenComponentCountZeroAndLateBindingIsSupportedThenWhenCallingZesFirmwareGetProperCountIsReturned, IsBMG) {
+    constexpr uint32_t mockFwHandlesCount = 5;
+    std::vector<zes_firmware_handle_t> firmwareHandle{};
+    uint32_t count = 0;
+
+    ze_result_t result = zesDeviceEnumFirmwares(device->toHandle(), &count, nullptr);
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(count, mockFwHandlesCount);
+
+    uint32_t testCount = count + 1;
+
+    result = zesDeviceEnumFirmwares(device->toHandle(), &testCount, nullptr);
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(testCount, count);
+
+    firmwareHandle.resize(count);
+    result = zesDeviceEnumFirmwares(device->toHandle(), &count, firmwareHandle.data());
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(count, mockFwHandlesCount);
+}
+
+HWTEST2_F(ZesSysmanProductHelperFirmwareFixtureXe, GivenLateBindingFirmwareIsNotSupportedThenValidCountIsReturned, IsBMG) {
+
+    constexpr uint32_t mockFwHandlesCount = 3;
+    pSysfsAccess->canReadResult = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+    std::vector<zes_firmware_handle_t> firmwareHandle{};
+    uint32_t count = 0;
+
+    ze_result_t result = zesDeviceEnumFirmwares(device->toHandle(), &count, nullptr);
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(count, mockFwHandlesCount);
+}
+
+HWTEST2_F(ZesSysmanProductHelperFirmwareFixtureXe, GivenValidLateBindingFirmwareHandleWhenFlashingFirmwareThenSuccessIsReturned, IsBMG) {
+    constexpr uint32_t mockFwHandlesCount = 5;
+    initFirmware();
+
+    auto handles = getFirmwareHandles(mockFwHandlesCount);
+    for (auto handle : handles) {
+        zes_firmware_properties_t properties = {};
+        EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareGetProperties(handle, &properties));
+        if (std::find(lateBindingFirmwareTypes.begin(), lateBindingFirmwareTypes.end(), properties.name) != lateBindingFirmwareTypes.end()) {
+            uint8_t testImage[ZES_STRING_PROPERTY_SIZE] = {};
+            memset(testImage, 0xA, ZES_STRING_PROPERTY_SIZE);
+            EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareFlash(handle, (void *)testImage, ZES_STRING_PROPERTY_SIZE));
+        }
+    }
+}
+
+HWTEST2_F(ZesSysmanProductHelperFirmwareFixtureXe, GivenValidLateBindingFirmwareHandleWhenGettingFirmwarePropertiesThenValidVersionIsReturned, IsBMG) {
+
+    constexpr uint32_t mockFwHandlesCount = 5;
+    initFirmware();
+
+    auto handles = getFirmwareHandles(mockFwHandlesCount);
+    for (auto handle : handles) {
+        zes_firmware_properties_t properties = {};
+        EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareGetProperties(handle, &properties));
+        if (std::find(lateBindingFirmwareTypes.begin(), lateBindingFirmwareTypes.end(), properties.name) != lateBindingFirmwareTypes.end()) {
+            EXPECT_STREQ(mocklateBindingVersion.c_str(), properties.version);
+        }
+    }
+}
+
+HWTEST2_F(ZesSysmanProductHelperFirmwareFixtureXe, GivenValidLateBindingFirmwareHandleWhenGettingFirmwarePropertiesAndSysFsReadFailsThenVersionIsUnknown, IsBMG) {
+
+    constexpr uint32_t mockFwHandlesCount = 5;
+    pSysfsAccess->readResult = ZE_RESULT_ERROR_UNKNOWN;
+    initFirmware();
+
+    auto handles = getFirmwareHandles(mockFwHandlesCount);
+    for (auto handle : handles) {
+        zes_firmware_properties_t properties = {};
+        EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareGetProperties(handle, &properties));
+        if (std::find(lateBindingFirmwareTypes.begin(), lateBindingFirmwareTypes.end(), properties.name) != lateBindingFirmwareTypes.end()) {
+            EXPECT_STREQ(mockUnknownVersion.c_str(), properties.version);
+        }
+    }
+}
+
+} // namespace ult
+} // namespace Sysman
+} // namespace L0