From 5d4c23c4fbb95c9a00babf173872c697520d8260 Mon Sep 17 00:00:00 2001 From: shubham kumar Date: Mon, 28 Jul 2025 17:03:52 +0000 Subject: [PATCH] feature: Add support for late binding version on linux Related-To: NEO-15216 Signed-off-by: shubham kumar --- .../firmware/linux/sysman_os_firmware_imp.cpp | 8 +- .../firmware/linux/sysman_os_firmware_imp.h | 3 + .../linux/sysman_os_firmware_imp_helper.cpp | 4 + .../kmd_interface/sysman_kmd_interface.h | 4 + .../kmd_interface/sysman_kmd_interface_xe.cpp | 21 ++ .../product_helper/sysman_product_helper.h | 1 - .../product_helper/sysman_product_helper_hw.h | 1 - .../sysman_product_helper_hw.inl | 5 - .../bmg/sysman_product_helper_bmg.cpp | 5 - .../firmware/linux/mock_zes_sysman_firmware.h | 17 +- .../linux/test_zes_sysman_firmware.cpp | 313 ----------------- .../test_sysman_kmd_interface_i915_prelim.cpp | 7 + ...est_sysman_kmd_interface_i915_upstream.cpp | 7 + .../test_sysman_kmd_interface_xe.cpp | 6 + .../linux/product_helper/CMakeLists.txt | 2 + .../sysman_product_helper_firmware_tests.cpp | 329 ++++++++++++++++++ ...ysman_product_helper_firmware_tests_xe.cpp | 161 +++++++++ 17 files changed, 562 insertions(+), 332 deletions(-) create mode 100644 level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/sysman_product_helper_firmware_tests.cpp create mode 100644 level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/sysman_product_helper_firmware_tests_xe.cpp diff --git a/level_zero/sysman/source/api/firmware/linux/sysman_os_firmware_imp.cpp b/level_zero/sysman/source/api/firmware/linux/sysman_os_firmware_imp.cpp index 39523140f5..4020d6681c 100644 --- a/level_zero/sysman/source/api/firmware/linux/sysman_os_firmware_imp.cpp +++ b/level_zero/sysman/source/api/firmware/linux/sysman_os_firmware_imp.cpp @@ -30,9 +30,9 @@ void OsFirmware::getSupportedFwTypes(std::vector &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(pOsSysman); + pLinuxSysmanImp = static_cast(pOsSysman); if (!pLinuxSysmanImp->isDeviceInSurvivabilityMode()) { pSysfsAccess = &pLinuxSysmanImp->getSysfsAccess(); } diff --git a/level_zero/sysman/source/api/firmware/linux/sysman_os_firmware_imp.h b/level_zero/sysman/source/api/firmware/linux/sysman_os_firmware_imp.h index d57877a67c..0d76d087ef 100644 --- a/level_zero/sysman/source/api/firmware/linux/sysman_os_firmware_imp.h +++ b/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; diff --git a/level_zero/sysman/source/api/firmware/linux/sysman_os_firmware_imp_helper.cpp b/level_zero/sysman/source/api/firmware/linux/sysman_os_firmware_imp_helper.cpp index 1ef52ddfd6..71d90815ab 100644 --- a/level_zero/sysman/source/api/firmware/linux/sysman_os_firmware_imp_helper.cpp +++ b/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(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); diff --git a/level_zero/sysman/source/shared/linux/kmd_interface/sysman_kmd_interface.h b/level_zero/sysman/source/shared/linux/kmd_interface/sysman_kmd_interface.h index 5f43d8f599..7f94d72350 100644 --- a/level_zero/sysman/source/shared/linux/kmd_interface/sysman_kmd_interface.h +++ b/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 &fwTypes) {} + virtual bool isLateBindingVersionAvailable(std::string fwType, std::string &fwVersion) { return false; } protected: std::unique_ptr 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 &fwTypes) override; + bool isLateBindingVersionAvailable(std::string fwType, std::string &fwVersion) override; protected: std::map sysfsNameToFileMap; diff --git a/level_zero/sysman/source/shared/linux/kmd_interface/sysman_kmd_interface_xe.cpp b/level_zero/sysman/source/shared/linux/kmd_interface/sysman_kmd_interface_xe.cpp index a405a6b12f..70eeb23f5e 100644 --- a/level_zero/sysman/source/shared/linux/kmd_interface/sysman_kmd_interface_xe.cpp +++ b/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 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 &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 diff --git a/level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper.h b/level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper.h index 36f9d20fad..20df1f879f 100644 --- a/level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper.h +++ b/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 &fwTypes) = 0; - virtual bool isLateBindingSupported() = 0; // Ecc virtual bool isEccConfigurationSupported() = 0; diff --git a/level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper_hw.h b/level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper_hw.h index 90df5333de..637e86b09e 100644 --- a/level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper_hw.h +++ b/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 &fwTypes) override; - bool isLateBindingSupported() override; // Ecc bool isEccConfigurationSupported() override; diff --git a/level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper_hw.inl b/level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper_hw.inl index d8564ad169..02df0b81c1 100644 --- a/level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper_hw.inl +++ b/level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper_hw.inl @@ -353,11 +353,6 @@ void SysmanProductHelperHw::getDeviceSupportedFwTypes(FirmwareUtil * pFwInterface->getDeviceSupportedFwTypes(fwTypes); } -template -bool SysmanProductHelperHw::isLateBindingSupported() { - return false; -} - template bool SysmanProductHelperHw::isEccConfigurationSupported() { return false; diff --git a/level_zero/sysman/source/shared/linux/product_helper/xe2_hpg_core/bmg/sysman_product_helper_bmg.cpp b/level_zero/sysman/source/shared/linux/product_helper/xe2_hpg_core/bmg/sysman_product_helper_bmg.cpp index fb6a7990bc..cc0abf5695 100644 --- a/level_zero/sysman/source/shared/linux/product_helper/xe2_hpg_core/bmg/sysman_product_helper_bmg.cpp +++ b/level_zero/sysman/source/shared/linux/product_helper/xe2_hpg_core/bmg/sysman_product_helper_bmg.cpp @@ -1709,11 +1709,6 @@ bool SysmanProductHelperHw::isEccConfigurationSupported() { return true; } -template <> -bool SysmanProductHelperHw::isLateBindingSupported() { - return true; -} - template <> bool SysmanProductHelperHw::isPcieDowngradeSupported() { return true; diff --git a/level_zero/sysman/test/unit_tests/sources/firmware/linux/mock_zes_sysman_firmware.h b/level_zero/sysman/test/unit_tests/sources/firmware/linux/mock_zes_sysman_firmware.h index 4813140974..c36bc47ac3 100644 --- a/level_zero/sysman/test/unit_tests/sources/firmware/linux/mock_zes_sysman_firmware.h +++ b/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 mockSupportedFirmwareTypes = {"GSC", "OptionROM", "PSC"}; -std::vector mockUnsupportedFwTypes = {"unknown"}; -std::string mockEmpty = {}; +const std::vector mockSupportedFirmwareTypes = {"GSC", "OptionROM", "PSC"}; +const std::vector 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 &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; diff --git a/level_zero/sysman/test/unit_tests/sources/firmware/linux/test_zes_sysman_firmware.cpp b/level_zero/sysman/test/unit_tests/sources/firmware/linux/test_zes_sysman_firmware.cpp index bac10a019b..dfb4343942 100644 --- a/level_zero/sysman/test/unit_tests/sources/firmware/linux/test_zes_sysman_firmware.cpp +++ b/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 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 { @@ -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 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"}, diff --git a/level_zero/sysman/test/unit_tests/sources/shared/linux/kmd_interface/test_sysman_kmd_interface_i915_prelim.cpp b/level_zero/sysman/test/unit_tests/sources/shared/linux/kmd_interface/test_sysman_kmd_interface_i915_prelim.cpp index 695116d872..533e8aafcd 100644 --- a/level_zero/sysman/test/unit_tests/sources/shared/linux/kmd_interface/test_sysman_kmd_interface_i915_prelim.cpp +++ b/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 diff --git a/level_zero/sysman/test/unit_tests/sources/shared/linux/kmd_interface/test_sysman_kmd_interface_i915_upstream.cpp b/level_zero/sysman/test/unit_tests/sources/shared/linux/kmd_interface/test_sysman_kmd_interface_i915_upstream.cpp index c66b094452..2cdeb4cb2c 100644 --- a/level_zero/sysman/test/unit_tests/sources/shared/linux/kmd_interface/test_sysman_kmd_interface_i915_upstream.cpp +++ b/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 \ No newline at end of file diff --git a/level_zero/sysman/test/unit_tests/sources/shared/linux/kmd_interface/test_sysman_kmd_interface_xe.cpp b/level_zero/sysman/test/unit_tests/sources/shared/linux/kmd_interface/test_sysman_kmd_interface_xe.cpp index 300e737885..0bfd79d346 100644 --- a/level_zero/sysman/test/unit_tests/sources/shared/linux/kmd_interface/test_sysman_kmd_interface_xe.cpp +++ b/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 diff --git a/level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/CMakeLists.txt b/level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/CMakeLists.txt index a6a11b6e07..e35be9c10d 100644 --- a/level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/CMakeLists.txt +++ b/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() diff --git a/level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/sysman_product_helper_firmware_tests.cpp b/level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/sysman_product_helper_firmware_tests.cpp new file mode 100644 index 0000000000..94e5420316 --- /dev/null +++ b/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 + +namespace L0 { +namespace Sysman { +namespace ult { + +class ZesSysmanProductHelperFirmwareFixture : public SysmanDeviceFixture { + + protected: + zes_firmware_handle_t hSysmanFirmware = {}; + std::unique_ptr pMockFwInterface; + L0::Sysman::FirmwareUtil *pFwUtilInterfaceOld = nullptr; + std::unique_ptr pFsAccess; + L0::Sysman::FsAccessInterface *pFsAccessOriginal = nullptr; + L0::Sysman::SysFsAccessInterface *pSysFsAccessOriginal = nullptr; + std::unique_ptr pMockSysfsAccess; + L0::Sysman::SysmanDevice *device = nullptr; + + void SetUp() override { + SysmanDeviceFixture::SetUp(); + pFsAccessOriginal = pLinuxSysmanImp->pFsAccess; + pFsAccess = std::make_unique(); + pLinuxSysmanImp->pFsAccess = pFsAccess.get(); + + pSysFsAccessOriginal = pLinuxSysmanImp->pSysfsAccess; + pMockSysfsAccess = std::make_unique(); + pLinuxSysmanImp->pSysfsAccess = pMockSysfsAccess.get(); + + pFwUtilInterfaceOld = pLinuxSysmanImp->pFwUtilInterface; + pMockFwInterface = std::make_unique(); + 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 getFirmwareHandles(uint32_t count) { + std::vector handles(count, nullptr); + EXPECT_EQ(zesDeviceEnumFirmwares(device->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS); + return handles; + } +}; + +HWTEST2_F(ZesSysmanProductHelperFirmwareFixture, GivenComponentCountZeroWhenCallingzesFirmwareGetThenZeroCountIsReturnedAndVerifyzesFirmwareGetCallSucceeds, IsXeCore) { + std::vector 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 diff --git a/level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/sysman_product_helper_firmware_tests_xe.cpp b/level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/sysman_product_helper_firmware_tests_xe.cpp new file mode 100644 index 0000000000..c0430114d5 --- /dev/null +++ b/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 + +namespace L0 { +namespace Sysman { +namespace ult { + +class ZesSysmanProductHelperFirmwareFixtureXe : public SysmanDeviceFixture { + + protected: + zes_firmware_handle_t hSysmanFirmware = {}; + std::unique_ptr pMockFwInterface; + MockFirmwareSysfsAccess *pSysfsAccess = nullptr; + MockSysmanKmdInterfaceXe *pSysmanKmdInterface = nullptr; + L0::Sysman::FirmwareUtil *pFwUtilInterfaceOld = nullptr; + std::unique_ptr pFsAccess; + L0::Sysman::FsAccessInterface *pFsAccessOriginal = nullptr; + L0::Sysman::SysFsAccessInterface *pSysFsAccessOriginal = nullptr; + std::unique_ptr pMockSysfsAccess; + L0::Sysman::SysmanDevice *device = nullptr; + + void SetUp() override { + SysmanDeviceFixture::SetUp(); + pFsAccessOriginal = pLinuxSysmanImp->pFsAccess; + pFsAccess = std::make_unique(); + pLinuxSysmanImp->pFsAccess = pFsAccess.get(); + + pSysFsAccessOriginal = pLinuxSysmanImp->pSysfsAccess; + pSysmanKmdInterface = new MockSysmanKmdInterfaceXe(pLinuxSysmanImp->getSysmanProductHelper()); + pSysmanKmdInterface->pSysfsAccess = std::make_unique(); + pLinuxSysmanImp->pSysfsAccess = pSysmanKmdInterface->pSysfsAccess.get(); + pLinuxSysmanImp->pSysmanKmdInterface.reset(pSysmanKmdInterface); + pSysfsAccess = static_cast(pSysmanKmdInterface->pSysfsAccess.get()); + + pFwUtilInterfaceOld = pLinuxSysmanImp->pFwUtilInterface; + pMockFwInterface = std::make_unique(); + 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 getFirmwareHandles(uint32_t count) { + std::vector 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 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 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