feature(sysman): Add firmware update support for GFX_DATA firmware type

Related-To: NEO-15618

Signed-off-by: Anvesh Bakwad <anvesh.bakwad@intel.com>

level_zero/sysman/source/shared/firmware_util/sysman_firmware_util_imp.cpp

@@ -23,10 +23,12 @@ static const std::map<std::string, csc_late_binding_type> lateBindingTypeToEnumM
 const std::string fwDeviceInitByDevice = "igsc_device_init_by_device_info";
 const std::string fwDeviceGetDeviceInfo = "igsc_device_get_device_info";
 const std::string fwDeviceFwVersion = "igsc_device_fw_version";
+const std::string fwDeviceFwDataVersion = "igsc_device_fwdata_version";
 const std::string fwDeviceIteratorCreate = "igsc_device_iterator_create";
 const std::string fwDeviceIteratorNext = "igsc_device_iterator_next";
 const std::string fwDeviceIteratorDestroy = "igsc_device_iterator_destroy";
 const std::string fwDeviceFwUpdate = "igsc_device_fw_update";
+const std::string fwDeviceFwDataUpdate = "igsc_device_fwdata_update";
 const std::string fwImageOpromInit = "igsc_image_oprom_init";
 const std::string fwImageOpromType = "igsc_image_oprom_type";
 const std::string fwDeviceOpromUpdate = "igsc_device_oprom_update";
@@ -38,10 +40,12 @@ const std::string fwDeviceUpdateLateBindingConfig = "igsc_device_update_late_bin
 pIgscDeviceInitByDevice deviceInitByDevice;
 pIgscDeviceGetDeviceInfo deviceGetDeviceInfo;
 pIgscDeviceFwVersion deviceGetFwVersion;
+pIgscDeviceFwDataVersion deviceGetFwDataVersion;
 pIgscDeviceIteratorCreate deviceIteratorCreate;
 pIgscDeviceIteratorNext deviceItreatorNext;
 pIgscDeviceIteratorDestroy deviceItreatorDestroy;
 pIgscDeviceFwUpdate deviceFwUpdate;
+pIgscDeviceFwDataUpdate deviceFwDataUpdate;
 pIgscImageOpromInit imageOpromInit;
 pIgscImageOpromType imageOpromType;
 pIgscDeviceOpromUpdate deviceOpromUpdate;
@@ -54,10 +58,12 @@ bool FirmwareUtilImp::loadEntryPoints() {
     bool ok = getSymbolAddr(fwDeviceInitByDevice, deviceInitByDevice);
     ok = ok && getSymbolAddr(fwDeviceGetDeviceInfo, deviceGetDeviceInfo);
     ok = ok && getSymbolAddr(fwDeviceFwVersion, deviceGetFwVersion);
+    ok = ok && getSymbolAddr(fwDeviceFwDataVersion, deviceGetFwDataVersion);
     ok = ok && getSymbolAddr(fwDeviceIteratorCreate, deviceIteratorCreate);
     ok = ok && getSymbolAddr(fwDeviceIteratorNext, deviceItreatorNext);
     ok = ok && getSymbolAddr(fwDeviceIteratorDestroy, deviceItreatorDestroy);
     ok = ok && getSymbolAddr(fwDeviceFwUpdate, deviceFwUpdate);
+    ok = ok && getSymbolAddr(fwDeviceFwDataUpdate, deviceFwDataUpdate);
     ok = ok && getSymbolAddr(fwImageOpromInit, imageOpromInit);
     ok = ok && getSymbolAddr(fwImageOpromType, imageOpromType);
     ok = ok && getSymbolAddr(fwDeviceOpromUpdate, deviceOpromUpdate);
@@ -147,6 +153,23 @@ ze_result_t FirmwareUtilImp::fwGetVersion(std::string &fwVersion) {
     return ZE_RESULT_SUCCESS;
 }
 
+ze_result_t FirmwareUtilImp::fwDataGetVersion(std::string &fwDataVersion) {
+    const std::lock_guard<std::mutex> lock(this->fwLock);
+    igsc_fwdata_version deviceFwDataVersion;
+    memset(&deviceFwDataVersion, 0, sizeof(deviceFwDataVersion));
+    int ret = deviceGetFwDataVersion(&fwDeviceHandle, &deviceFwDataVersion);
+    if (ret != IGSC_SUCCESS) {
+        return ZE_RESULT_ERROR_UNINITIALIZED;
+    }
+    fwDataVersion.append("Major : ");
+    fwDataVersion.append(std::to_string(deviceFwDataVersion.major_version));
+    fwDataVersion.append(", OEM Manufacturing Data : ");
+    fwDataVersion.append(std::to_string(deviceFwDataVersion.oem_manuf_data_version));
+    fwDataVersion.append(", Major VCN : ");
+    fwDataVersion.append(std::to_string(deviceFwDataVersion.major_vcn));
+    return ZE_RESULT_SUCCESS;
+}
+
 ze_result_t FirmwareUtilImp::opromGetVersion(std::string &fwVersion) {
     const std::lock_guard<std::mutex> lock(this->fwLock);
     igsc_oprom_version opromVersion;
@@ -181,6 +204,15 @@ ze_result_t FirmwareUtilImp::fwFlashGSC(void *pImage, uint32_t size) {
     return ZE_RESULT_SUCCESS;
 }
 
+ze_result_t FirmwareUtilImp::fwFlashGfxData(void *pImage, uint32_t size) {
+    const std::lock_guard<std::mutex> lock(this->fwLock);
+    int ret = deviceFwDataUpdate(&fwDeviceHandle, static_cast<const uint8_t *>(pImage), size, firmwareFlashProgressFunc, this);
+    if (ret != IGSC_SUCCESS) {
+        return ZE_RESULT_ERROR_UNINITIALIZED;
+    }
+    return ZE_RESULT_SUCCESS;
+}
+
 ze_result_t FirmwareUtilImp::fwFlashOprom(void *pImage, uint32_t size) {
     const std::lock_guard<std::mutex> lock(this->fwLock);
     struct igsc_oprom_image *opromImg = nullptr;

level_zero/sysman/source/shared/firmware_util/sysman_firmware_util_imp.h

@@ -26,6 +26,8 @@ typedef int (*pIgscDeviceGetDeviceInfo)(struct igsc_device_handle *handle,
                                         struct igsc_info_device *info);
 typedef int (*pIgscDeviceFwVersion)(struct igsc_device_handle *handle,
                                     struct igsc_fw_version *version);
+typedef int (*pIgscDeviceFwDataVersion)(struct igsc_device_handle *handle,
+                                        struct igsc_fwdata_version *version);
 typedef int (*pIgscDeviceIteratorCreate)(struct igsc_device_iterator **iter);
 typedef int (*pIgscDeviceIteratorNext)(struct igsc_device_iterator *iter,
                                        IgscDeviceInfo *info);
@@ -35,6 +37,11 @@ typedef int (*pIgscDeviceFwUpdate)(struct igsc_device_handle *handle,
                                    const uint32_t bufferLen,
                                    igsc_progress_func_t progressFunc,
                                    void *ctx);
+typedef int (*pIgscDeviceFwDataUpdate)(struct igsc_device_handle *handle,
+                                       const uint8_t *buffer,
+                                       const uint32_t bufferLen,
+                                       igsc_progress_func_t progressFunc,
+                                       void *ctx);
 typedef int (*pIgscImageOpromInit)(struct igsc_oprom_image **img,
                                    const uint8_t *buffer,
                                    uint32_t bufferLen);
@@ -93,16 +100,19 @@ typedef int (*pIgscGfspHeciCmd)(struct igsc_device_handle *handle,
                                 size_t *actualOutBufferSize);
 
 extern const std::string fwDeviceFwVersion;
+extern const std::string fwDeviceFwDataVersion;
 extern const std::string fwDeviceOpromVersion;
 extern const std::string fwDevicePscVersion;
 
 extern pIgscDeviceInitByDevice deviceInitByDevice;
 extern pIgscDeviceGetDeviceInfo deviceGetDeviceInfo;
 extern pIgscDeviceFwVersion deviceGetFwVersion;
+extern pIgscDeviceFwDataVersion deviceGetFwDataVersion;
 extern pIgscDeviceIteratorCreate deviceIteratorCreate;
 extern pIgscDeviceIteratorNext deviceItreatorNext;
 extern pIgscDeviceIteratorDestroy deviceItreatorDestroy;
 extern pIgscDeviceFwUpdate deviceFwUpdate;
+extern pIgscDeviceFwDataUpdate deviceFwDataUpdate;
 extern pIgscImageOpromInit imageOpromInit;
 extern pIgscImageOpromType imageOpromType;
 extern pIgscDeviceOpromUpdate deviceOpromUpdate;
@@ -157,9 +167,11 @@ class FirmwareUtilImp : public FirmwareUtil, NEO::NonCopyableAndNonMovableClass
   protected:
     ze_result_t getFirstDevice(IgscDeviceInfo *);
     ze_result_t fwGetVersion(std::string &fwVersion);
+    ze_result_t fwDataGetVersion(std::string &fwDataVersion);
     ze_result_t opromGetVersion(std::string &fwVersion);
     ze_result_t pscGetVersion(std::string &fwVersion);
     ze_result_t fwFlashGSC(void *pImage, uint32_t size);
+    ze_result_t fwFlashGfxData(void *pImage, uint32_t size);
     ze_result_t fwFlashOprom(void *pImage, uint32_t size);
     ze_result_t fwFlashIafPsc(void *pImage, uint32_t size);
     ze_result_t fwFlashLateBinding(void *pImage, uint32_t size, std::string fwType);

level_zero/sysman/source/shared/firmware_util/sysman_firmware_util_imp_helper.cpp

@@ -11,9 +11,9 @@
 
 #include <algorithm>
 
-static std::vector<std ::string> deviceSupportedFirmwareTypes = {"GSC", "OptionROM", "PSC"};
+static std::vector<std::string> deviceSupportedFirmwareTypes = {"GSC", "OptionROM", "PSC", "GFX_DATA"};
 static constexpr uint8_t eccStateNone = 0xFF;
-static std::vector<std ::string> lateBindingFirmwareTypes = {"FanTable", "VRConfig"};
+static std::vector<std::string> lateBindingFirmwareTypes = {"FanTable", "VRConfig"};
 
 namespace L0 {
 namespace Sysman {
@@ -345,6 +345,9 @@ ze_result_t FirmwareUtilImp::flashFirmware(std::string fwType, void *pImage, uin
     if (fwType == deviceSupportedFirmwareTypes[2]) { // PSC
         return fwFlashIafPsc(pImage, size);
     }
+    if (fwType == deviceSupportedFirmwareTypes[3]) { // GFX_DATA
+        return fwFlashGfxData(pImage, size);
+    }
     if (std::find(lateBindingFirmwareTypes.begin(), lateBindingFirmwareTypes.end(), fwType) != lateBindingFirmwareTypes.end()) { // FanTable and VRConfig
         return fwFlashLateBinding(pImage, size, fwType);
     }
@@ -381,6 +384,14 @@ void FirmwareUtilImp::getDeviceSupportedFwTypes(std::vector<std::string> &fwType
     if (ret == IGSC_SUCCESS) {
         fwTypes.push_back(deviceSupportedFirmwareTypes[2]);
     }
+
+    igsc_fwdata_version deviceFwDataVersion;
+    memset(&deviceFwDataVersion, 0, sizeof(deviceFwDataVersion));
+    deviceGetFwDataVersion = reinterpret_cast<pIgscDeviceFwDataVersion>(libraryHandle->getProcAddress(fwDeviceFwDataVersion));
+    ret = deviceGetFwDataVersion(&fwDeviceHandle, &deviceFwDataVersion);
+    if (ret == IGSC_SUCCESS) {
+        fwTypes.push_back(deviceSupportedFirmwareTypes[3]);
+    }
 }
 
 void FirmwareUtilImp::getLateBindingSupportedFwTypes(std::vector<std::string> &fwTypes) {
@@ -397,6 +408,9 @@ ze_result_t FirmwareUtilImp::getFwVersion(std::string fwType, std::string &firmw
     if (fwType == deviceSupportedFirmwareTypes[2]) { // PSC
         return pscGetVersion(firmwareVersion);
     }
+    if (fwType == deviceSupportedFirmwareTypes[3]) { // GFX_DATA
+        return fwDataGetVersion(firmwareVersion);
+    }
     return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 

level_zero/sysman/test/unit_tests/sources/firmware_util/test_fw_util.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022-2024 Intel Corporation
+ * Copyright (C) 2022-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -11,12 +11,41 @@
 #include "level_zero/sysman/source/shared/firmware_util/sysman_firmware_util_imp.h"
 #include "level_zero/sysman/test/unit_tests/sources/firmware_util/mock_fw_util_fixture.h"
 
+#include <algorithm>
+
 namespace L0 {
 namespace Sysman {
 namespace ult {
 
 static uint32_t mockFwUtilDeviceCloseCallCount = 0;
 bool MockFwUtilOsLibrary::mockLoad = true;
+constexpr uint32_t fwDataMajorVersion = 10;
+constexpr uint16_t fwDataOemVersion = 10;
+constexpr uint16_t fwDataVcnVersion = 1;
+
+static int mockIgscDeviceFwVersion(struct igsc_device_handle *handle,
+                                   struct igsc_fw_version *version) {
+    return IGSC_SUCCESS;
+}
+
+static int mockIgscDeviceFwDataVersion(struct igsc_device_handle *handle,
+                                       struct igsc_fwdata_version *version) {
+    version->major_version = fwDataMajorVersion;
+    version->oem_manuf_data_version = fwDataOemVersion;
+    version->major_vcn = fwDataVcnVersion;
+    return IGSC_SUCCESS;
+}
+
+static int mockIgscDeviceOpromVersion(struct igsc_device_handle *handle,
+                                      uint32_t opromType,
+                                      struct igsc_oprom_version *version) {
+    return IGSC_SUCCESS;
+}
+
+static int mockIgscDevicePscVersion(struct igsc_device_handle *handle,
+                                    struct igsc_psc_version *version) {
+    return IGSC_SUCCESS;
+}
 
 TEST(FwUtilDeleteTest, GivenLibraryWasNotSetWhenFirmwareUtilInterfaceIsDeletedThenLibraryFunctionIsNotAccessed) {
 
@@ -49,25 +78,102 @@ TEST(FwUtilDeleteTest, GivenLibraryWasSetWhenFirmwareUtilInterfaceIsDeletedThenL
     EXPECT_EQ(mockFwUtilDeviceCloseCallCount, 1u);
 }
 
-TEST(FwUtilTest, GivenLibraryWasSetWhenCreatingFirmwareUtilInterfaceAndGetProcAddressFailsThenFirmwareUtilInterfaceIsNotCreated) {
+class FwUtilTestFixture : public ::testing::Test {
+  protected:
+    L0::Sysman::FirmwareUtilImp *pFwUtilImp = nullptr;
+    MockFwUtilOsLibrary *osLibHandle = nullptr;
+    std::vector<std::string> fwTypes;
+    void SetUp() override {
+        pFwUtilImp = new L0::Sysman::FirmwareUtilImp(0, 0, 0, 0);
+        osLibHandle = new MockFwUtilOsLibrary();
+        osLibHandle->funcMap["igsc_device_fw_version"] = reinterpret_cast<void *>(&mockIgscDeviceFwVersion);
+        osLibHandle->funcMap["igsc_device_fwdata_version"] = reinterpret_cast<void *>(&mockIgscDeviceFwDataVersion);
+        osLibHandle->funcMap["igsc_device_oprom_version"] = reinterpret_cast<void *>(&mockIgscDeviceOpromVersion);
+        osLibHandle->funcMap["igsc_device_psc_version"] = reinterpret_cast<void *>(&mockIgscDevicePscVersion);
+        pFwUtilImp->libraryHandle = static_cast<OsLibrary *>(osLibHandle);
+        pFwUtilImp->getDeviceSupportedFwTypes(fwTypes);
+    }
+
+    void TearDown() override {
+        delete pFwUtilImp->libraryHandle;
+        pFwUtilImp->libraryHandle = nullptr;
+        delete pFwUtilImp;
+    }
+};
+
+TEST_F(FwUtilTestFixture, GivenLibraryWasSetWhenCreatingFirmwareUtilInterfaceAndGetProcAddressFailsThenFirmwareUtilInterfaceIsNotCreated) {
     VariableBackup<decltype(NEO::OsLibrary::loadFunc)> funcBackup{&NEO::OsLibrary::loadFunc, MockFwUtilOsLibrary::load};
     L0::Sysman::FirmwareUtil *pFwUtil = L0::Sysman::FirmwareUtil::create(0, 0, 0, 0);
     EXPECT_EQ(pFwUtil, nullptr);
 }
 
-TEST(FwUtilTest, GivenLibraryWasSetWhenCreatingFirmwareUtilInterfaceAndIgscDeviceIterCreateFailsThenFirmwareUtilInterfaceIsNotCreated) {
+TEST_F(FwUtilTestFixture, GivenLibraryWasSetWhenCreatingFirmwareUtilInterfaceAndIgscDeviceIterCreateFailsThenFirmwareUtilInterfaceIsNotCreated) {
     VariableBackup<decltype(NEO::OsLibrary::loadFunc)> funcBackup{&NEO::OsLibrary::loadFunc, MockFwUtilOsLibrary::load};
     L0::Sysman::FirmwareUtil *pFwUtil = L0::Sysman::FirmwareUtil::create(0, 0, 0, 0);
     EXPECT_EQ(pFwUtil, nullptr);
 }
 
-TEST(FwUtilTest, GivenLibraryWasNotSetWhenCreatingFirmwareUtilInterfaceThenFirmwareUtilInterfaceIsNotCreated) {
+TEST_F(FwUtilTestFixture, GivenLibraryWasNotSetWhenCreatingFirmwareUtilInterfaceThenFirmwareUtilInterfaceIsNotCreated) {
     L0::Sysman::ult::MockFwUtilOsLibrary::mockLoad = false;
     VariableBackup<decltype(NEO::OsLibrary::loadFunc)> funcBackup{&NEO::OsLibrary::loadFunc, MockFwUtilOsLibrary::load};
     L0::Sysman::FirmwareUtil *pFwUtil = L0::Sysman::FirmwareUtil::create(0, 0, 0, 0);
     EXPECT_EQ(pFwUtil, nullptr);
 }
 
+TEST_F(FwUtilTestFixture, GivenFirmwareUtilInstanceWhenGetVersionIsCalledForGfxDataTypeAndIgscCallFailsThenCallReturnsError) {
+    VariableBackup<decltype(L0::Sysman::deviceGetFwDataVersion)> mockFirmwareVersionFailure(&L0::Sysman::deviceGetFwDataVersion, [](struct igsc_device_handle *handle, struct igsc_fwdata_version *version) -> int {
+        return IGSC_ERROR_BAD_IMAGE;
+    });
+
+    auto gfxDataIt = std::find(fwTypes.begin(), fwTypes.end(), std::string("GFX_DATA"));
+    EXPECT_NE(gfxDataIt, fwTypes.end());
+
+    std::string firmwareVersion;
+    ze_result_t result = pFwUtilImp->getFwVersion(*gfxDataIt, firmwareVersion);
+    EXPECT_EQ(result, ZE_RESULT_ERROR_UNINITIALIZED);
+}
+
+TEST_F(FwUtilTestFixture, GivenFirmwareUtilInstanceWhenGetVersionIsCalledForGfxDataTypeThenProperVersionIsReturned) {
+    auto gfxDataIt = std::find(fwTypes.begin(), fwTypes.end(), std::string("GFX_DATA"));
+    EXPECT_NE(gfxDataIt, fwTypes.end());
+
+    std::string firmwareVersion;
+    ze_result_t result = pFwUtilImp->getFwVersion(*gfxDataIt, firmwareVersion);
+    EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+
+    std::string expectedFirmwareVersion = "Major : " + std::to_string(fwDataMajorVersion) + ", OEM Manufacturing Data : " + std::to_string(fwDataOemVersion) + ", Major VCN : " + std::to_string(fwDataVcnVersion);
+    EXPECT_EQ(expectedFirmwareVersion, firmwareVersion);
+}
+
+TEST_F(FwUtilTestFixture, GivenFirmwareUtilInstanceWhenFirmwareFlashIsCalledForGfxDataTypeAndIgscCallFailsThenFlashingFails) {
+    VariableBackup<decltype(L0::Sysman::deviceFwDataUpdate)> mockFirmwareFlashFailure(&L0::Sysman::deviceFwDataUpdate, [](struct igsc_device_handle *handle, const uint8_t *buffer, const uint32_t bufferLen, igsc_progress_func_t progressFunc, void *ctx) -> int {
+        return IGSC_ERROR_BAD_IMAGE;
+    });
+
+    auto gfxDataIt = std::find(fwTypes.begin(), fwTypes.end(), std::string("GFX_DATA"));
+    EXPECT_NE(gfxDataIt, fwTypes.end());
+
+    uint8_t testImage[ZES_STRING_PROPERTY_SIZE] = {};
+    memset(testImage, 0xA, ZES_STRING_PROPERTY_SIZE);
+    auto result = pFwUtilImp->flashFirmware(*gfxDataIt, (void *)testImage, ZES_STRING_PROPERTY_SIZE);
+    EXPECT_EQ(result, ZE_RESULT_ERROR_UNINITIALIZED);
+}
+
+TEST_F(FwUtilTestFixture, GivenFirmwareUtilInstanceWhenFirmwareFlashIsCalledForGfxDataTypeAndIgscCallSucceedsThenFlashingIsSuccessful) {
+    VariableBackup<decltype(L0::Sysman::deviceFwDataUpdate)> mockFirmwareFlashSuccess(&L0::Sysman::deviceFwDataUpdate, [](struct igsc_device_handle *handle, const uint8_t *buffer, const uint32_t bufferLen, igsc_progress_func_t progressFunc, void *ctx) -> int {
+        return IGSC_SUCCESS;
+    });
+
+    auto gfxDataIt = std::find(fwTypes.begin(), fwTypes.end(), std::string("GFX_DATA"));
+    EXPECT_NE(gfxDataIt, fwTypes.end());
+
+    uint8_t testImage[ZES_STRING_PROPERTY_SIZE] = {};
+    memset(testImage, 0xA, ZES_STRING_PROPERTY_SIZE);
+
+    auto result = pFwUtilImp->flashFirmware(*gfxDataIt, (void *)testImage, ZES_STRING_PROPERTY_SIZE);
+    EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+}
+
 } // namespace ult
 } // namespace Sysman
 } // namespace L0

level_zero/sysman/test/unit_tests/sources/firmware_util/test_fw_util_helper.cpp

@@ -26,6 +26,7 @@ namespace ult {
 constexpr static uint32_t mockMaxTileCount = 2;
 static int mockMemoryHealthIndicator = IGSC_HEALTH_INDICATOR_HEALTHY;
 static int mockGetFwVersion = IGSC_SUCCESS;
+static int mockGetFwDataVersion = IGSC_SUCCESS;
 static int mockGetOpromCodeVersion = IGSC_SUCCESS;
 static int mockGetOpromDataVersion = IGSC_SUCCESS;
 static int mockGetPscVersion = IGSC_SUCCESS;
@@ -157,6 +158,11 @@ static int mockIgscDeviceFwVersion(struct igsc_device_handle *handle,
     return mockGetFwVersion;
 }
 
+static int mockIgscDeviceFwDataVersion(struct igsc_device_handle *handle,
+                                       struct igsc_fwdata_version *version) {
+    return mockGetFwDataVersion;
+}
+
 static int mockIgscDeviceOpromVersion(struct igsc_device_handle *handle,
                                       uint32_t opromType,
                                       struct igsc_oprom_version *version) {
@@ -965,18 +971,20 @@ TEST(FwGetSupportedFwTypesTest, GivenFirmwareUtilAndAllFwTypesSupportedWhenCalli
     L0::Sysman::FirmwareUtilImp *pFwUtilImp = new L0::Sysman::FirmwareUtilImp(0, 0, 0, 0);
     MockFwUtilOsLibrary *osLibHandle = new MockFwUtilOsLibrary();
     osLibHandle->funcMap["igsc_device_fw_version"] = reinterpret_cast<void *>(&mockIgscDeviceFwVersion);
+    osLibHandle->funcMap["igsc_device_fwdata_version"] = reinterpret_cast<void *>(&mockIgscDeviceFwDataVersion);
     osLibHandle->funcMap["igsc_device_oprom_version"] = reinterpret_cast<void *>(&mockIgscDeviceOpromVersion);
     osLibHandle->funcMap["igsc_device_psc_version"] = reinterpret_cast<void *>(&mockIgscDevicePscVersion);
     pFwUtilImp->libraryHandle = static_cast<OsLibrary *>(osLibHandle);
 
     mockGetFwVersion = IGSC_SUCCESS;
+    mockGetFwDataVersion = IGSC_SUCCESS;
     mockGetOpromCodeVersion = IGSC_SUCCESS;
     mockGetOpromDataVersion = IGSC_SUCCESS;
     mockGetPscVersion = IGSC_SUCCESS;
 
     std::vector<std::string> fwTypes{};
     pFwUtilImp->getDeviceSupportedFwTypes(fwTypes);
-    EXPECT_EQ(fwTypes.size(), 3u);
+    EXPECT_EQ(fwTypes.size(), 4u);
 
     delete pFwUtilImp->libraryHandle;
     pFwUtilImp->libraryHandle = nullptr;
@@ -987,11 +995,13 @@ TEST(FwGetSupportedFwTypesTest, GivenFirmwareUtilAndAllFwTypesUnsupportedWhenCal
     L0::Sysman::FirmwareUtilImp *pFwUtilImp = new L0::Sysman::FirmwareUtilImp(0, 0, 0, 0);
     MockFwUtilOsLibrary *osLibHandle = new MockFwUtilOsLibrary();
     osLibHandle->funcMap["igsc_device_fw_version"] = reinterpret_cast<void *>(&mockIgscDeviceFwVersion);
+    osLibHandle->funcMap["igsc_device_fwdata_version"] = reinterpret_cast<void *>(&mockIgscDeviceFwDataVersion);
     osLibHandle->funcMap["igsc_device_oprom_version"] = reinterpret_cast<void *>(&mockIgscDeviceOpromVersion);
     osLibHandle->funcMap["igsc_device_psc_version"] = reinterpret_cast<void *>(&mockIgscDevicePscVersion);
     pFwUtilImp->libraryHandle = static_cast<OsLibrary *>(osLibHandle);
 
     mockGetFwVersion = IGSC_ERROR_NOT_SUPPORTED;
+    mockGetFwDataVersion = IGSC_ERROR_NOT_SUPPORTED;
     mockGetOpromCodeVersion = IGSC_ERROR_NOT_SUPPORTED;
     mockGetOpromDataVersion = IGSC_ERROR_NOT_SUPPORTED;
     mockGetPscVersion = IGSC_ERROR_NOT_SUPPORTED;
@@ -1009,18 +1019,20 @@ TEST(FwGetSupportedFwTypesTest, GivenFirmwareUtilAndOnlyOpromCodeSupportedWhenCa
     L0::Sysman::FirmwareUtilImp *pFwUtilImp = new L0::Sysman::FirmwareUtilImp(0, 0, 0, 0);
     MockFwUtilOsLibrary *osLibHandle = new MockFwUtilOsLibrary();
     osLibHandle->funcMap["igsc_device_fw_version"] = reinterpret_cast<void *>(&mockIgscDeviceFwVersion);
+    osLibHandle->funcMap["igsc_device_fwdata_version"] = reinterpret_cast<void *>(&mockIgscDeviceFwDataVersion);
     osLibHandle->funcMap["igsc_device_oprom_version"] = reinterpret_cast<void *>(&mockIgscDeviceOpromVersion);
     osLibHandle->funcMap["igsc_device_psc_version"] = reinterpret_cast<void *>(&mockIgscDevicePscVersion);
     pFwUtilImp->libraryHandle = static_cast<OsLibrary *>(osLibHandle);
 
     mockGetFwVersion = IGSC_SUCCESS;
+    mockGetFwDataVersion = IGSC_SUCCESS;
     mockGetOpromCodeVersion = IGSC_SUCCESS;
     mockGetOpromDataVersion = IGSC_ERROR_NOT_SUPPORTED;
     mockGetPscVersion = IGSC_SUCCESS;
 
     std::vector<std::string> fwTypes{};
     pFwUtilImp->getDeviceSupportedFwTypes(fwTypes);
-    EXPECT_EQ(fwTypes.size(), 2u);
+    EXPECT_EQ(fwTypes.size(), 3u);
 
     delete pFwUtilImp->libraryHandle;
     pFwUtilImp->libraryHandle = nullptr;

level_zero/tools/test/black_box_tests/zello_sysman.cpp

@@ -1267,6 +1267,7 @@ void testSysmanFirmware(ze_device_handle_t &device, std::string imagePath) {
         }
         if (imagePath.size() != 0 && imgSize > 0) {
             std::vector<char> img(imgSize);
+            imageFile.seekg(0, std::ios::beg);
             imageFile.read(img.data(), imgSize);
 
             flashData.flashComplete = false;