From c24f63151bce4dbef1fdc62ed584b28f63354b55 Mon Sep 17 00:00:00 2001 From: shubham kumar Date: Tue, 3 Jun 2025 10:37:26 +0000 Subject: [PATCH] feature: Add support for dynamic late binding config update (1/2) Related-To: NEO-14207 Signed-off-by: shubham kumar --- .../firmware/linux/sysman_os_firmware_imp.cpp | 3 + .../linux/sysman_os_firmware_imp_helper.cpp | 5 +- .../windows/sysman_os_firmware_imp.cpp | 10 +- .../firmware_util/sysman_firmware_util.h | 3 + .../sysman_firmware_util_imp.cpp | 23 ++++ .../firmware_util/sysman_firmware_util_imp.h | 9 ++ .../sysman_firmware_util_imp_helper.cpp | 10 ++ .../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 + .../product_helper/sysman_product_helper.h | 3 + .../product_helper/sysman_product_helper_hw.h | 3 + .../sysman_product_helper_hw.inl | 5 + .../bmg/sysman_product_helper_bmg.cpp | 5 + .../linux/mock_zes_sysman_diagnostics.h | 1 + .../unit_tests/sources/ecc/linux/mock_ecc.h | 1 + .../unit_tests/sources/ecc/windows/mock_ecc.h | 1 + .../sources/events/linux/mock_events.h | 1 + .../firmware/linux/mock_zes_sysman_firmware.h | 4 + .../linux/test_zes_sysman_firmware.cpp | 57 +++++++++ .../windows/mock_zes_sysman_firmware.h | 44 ++++++- .../windows/test_zes_sysman_firmware.cpp | 78 +----------- .../firmware_util/mock_fw_util_fixture.h | 1 + .../firmware_util/test_fw_util_helper.cpp | 78 ++++++++++++ .../linux/mock_global_operations.h | 1 + .../sources/ras/linux/mock_sysman_ras.h | 1 + .../windows/product_helper/CMakeLists.txt | 3 +- .../sysman_product_helper_firmware_tests.cpp | 117 ++++++++++++++++++ 29 files changed, 396 insertions(+), 83 deletions(-) create mode 100644 level_zero/sysman/test/unit_tests/sources/shared/windows/product_helper/sysman_product_helper_firmware_tests.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 96e93036f3..9fcebe756e 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 @@ -27,6 +27,9 @@ void OsFirmware::getSupportedFwTypes(std::vector &supportedFwTypes, if (pFwInterface != nullptr) { auto pSysmanProductHelper = pLinuxSysmanImp->getSysmanProductHelper(); pSysmanProductHelper->getDeviceSupportedFwTypes(pFwInterface, supportedFwTypes); + if (pSysmanProductHelper->isLateBindingSupported()) { + pFwInterface->getLateBindingSupportedFwTypes(supportedFwTypes); + } } } 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 7d41ef4e41..1ef52ddfd6 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 @@ -1,5 +1,5 @@ /* - * Copyright (C) 2021-2024 Intel Corporation + * Copyright (C) 2021-2025 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -53,6 +53,9 @@ ze_result_t LinuxFirmwareImp::getFirmwareVersion(std::string fwType, zes_firmwar strncpy_s(static_cast(pProperties->version), ZES_STRING_PROPERTY_SIZE, pscVersion.c_str(), ZES_STRING_PROPERTY_SIZE - 1); return result; } + if (std::find(lateBindingFirmwareTypes.begin(), lateBindingFirmwareTypes.end(), fwType) != lateBindingFirmwareTypes.end()) { + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + } ze_result_t result = pFwInterface->getFwVersion(fwType, fwVersion); if (result == ZE_RESULT_SUCCESS) { strncpy_s(static_cast(pProperties->version), ZES_STRING_PROPERTY_SIZE, fwVersion.c_str(), ZES_STRING_PROPERTY_SIZE - 1); diff --git a/level_zero/sysman/source/api/firmware/windows/sysman_os_firmware_imp.cpp b/level_zero/sysman/source/api/firmware/windows/sysman_os_firmware_imp.cpp index 7a0355b0bf..2efb03349e 100644 --- a/level_zero/sysman/source/api/firmware/windows/sysman_os_firmware_imp.cpp +++ b/level_zero/sysman/source/api/firmware/windows/sysman_os_firmware_imp.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2023-2024 Intel Corporation + * Copyright (C) 2023-2025 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -8,6 +8,7 @@ #include "level_zero/sysman/source/api/firmware/windows/sysman_os_firmware_imp.h" #include "level_zero/sysman/source/shared/firmware_util/sysman_firmware_util.h" +#include "level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper.h" #include "level_zero/sysman/source/shared/windows/zes_os_sysman_imp.h" #include "level_zero/sysman/source/sysman_const.h" @@ -18,6 +19,9 @@ const std::vector deviceSupportedFwTypes = {"GSC", "OptionROM"}; ze_result_t WddmFirmwareImp::getFirmwareVersion(std::string fwType, zes_firmware_properties_t *pProperties) { std::string fwVersion; + if (std::find(lateBindingFirmwareTypes.begin(), lateBindingFirmwareTypes.end(), fwType) != lateBindingFirmwareTypes.end()) { + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + } ze_result_t result = pFwInterface->getFwVersion(fwType, fwVersion); if (ZE_RESULT_SUCCESS == result) { strncpy_s(static_cast(pProperties->version), ZES_STRING_PROPERTY_SIZE, fwVersion.c_str(), ZES_STRING_PROPERTY_SIZE); @@ -65,9 +69,13 @@ std::unique_ptr OsFirmware::create(OsSysman *pOsSysman, const std::s void OsFirmware::getSupportedFwTypes(std::vector &supportedFwTypes, OsSysman *pOsSysman) { WddmSysmanImp *pWddmSysmanImp = static_cast(pOsSysman); FirmwareUtil *pFwInterface = pWddmSysmanImp->getFwUtilInterface(); + auto pSysmanProductHelper = pWddmSysmanImp->getSysmanProductHelper(); supportedFwTypes.clear(); if (pFwInterface != nullptr) { supportedFwTypes = deviceSupportedFwTypes; + if (pSysmanProductHelper->isLateBindingSupported()) { + pFwInterface->getLateBindingSupportedFwTypes(supportedFwTypes); + } } } diff --git a/level_zero/sysman/source/shared/firmware_util/sysman_firmware_util.h b/level_zero/sysman/source/shared/firmware_util/sysman_firmware_util.h index 7ab6ade642..34ed7f81ed 100644 --- a/level_zero/sysman/source/shared/firmware_util/sysman_firmware_util.h +++ b/level_zero/sysman/source/shared/firmware_util/sysman_firmware_util.h @@ -17,6 +17,8 @@ namespace L0 { namespace Sysman { +static std::vector lateBindingFirmwareTypes = {"FanTable", "VRConfig"}; + class FirmwareUtil { public: static FirmwareUtil *create(uint16_t domain, uint8_t bus, uint8_t device, uint8_t function); @@ -34,6 +36,7 @@ class FirmwareUtil { virtual ze_result_t fwSetEccConfig(uint8_t newState, uint8_t *currentState, uint8_t *pendingState) = 0; virtual void getDeviceSupportedFwTypes(std::vector &fwTypes) = 0; virtual void fwGetMemoryHealthIndicator(zes_mem_health_t *health) = 0; + virtual void getLateBindingSupportedFwTypes(std::vector &fwTypes) = 0; virtual ~FirmwareUtil() = default; }; } // namespace Sysman diff --git a/level_zero/sysman/source/shared/firmware_util/sysman_firmware_util_imp.cpp b/level_zero/sysman/source/shared/firmware_util/sysman_firmware_util_imp.cpp index 2d714c7c51..1aee02f920 100644 --- a/level_zero/sysman/source/shared/firmware_util/sysman_firmware_util_imp.cpp +++ b/level_zero/sysman/source/shared/firmware_util/sysman_firmware_util_imp.cpp @@ -11,8 +11,15 @@ #include "shared/source/helpers/debug_helpers.h" #include "shared/source/utilities/directory.h" +#include + namespace L0 { namespace Sysman { +static const std::map lateBindingTypeToEnumMap = { + {"FanTable", CSC_LATE_BINDING_TYPE_FAN_TABLE}, + {"VRConfig", CSC_LATE_BINDING_TYPE_VR_CONFIG}, +}; + 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"; @@ -26,6 +33,7 @@ const std::string fwDeviceOpromUpdate = "igsc_device_oprom_update"; const std::string fwDeviceOpromVersion = "igsc_device_oprom_version"; const std::string fwDevicePscVersion = "igsc_device_psc_version"; const std::string fwDeviceClose = "igsc_device_close"; +const std::string fwDeviceUpdateLateBindingConfig = "igsc_device_update_late_binding_config"; pIgscDeviceInitByDevice deviceInitByDevice; pIgscDeviceGetDeviceInfo deviceGetDeviceInfo; @@ -40,6 +48,7 @@ pIgscDeviceOpromUpdate deviceOpromUpdate; pIgscDeviceOpromVersion deviceOpromVersion; pIgscDevicePscVersion deviceGetPscVersion; pIgscDeviceClose deviceClose; +pIgscDeviceUpdateLateBindingConfig deviceUpdateLateBindingConfig; bool FirmwareUtilImp::loadEntryPoints() { bool ok = getSymbolAddr(fwDeviceInitByDevice, deviceInitByDevice); @@ -55,6 +64,7 @@ bool FirmwareUtilImp::loadEntryPoints() { ok = ok && getSymbolAddr(fwDeviceOpromVersion, deviceOpromVersion); ok = ok && getSymbolAddr(fwDevicePscVersion, deviceGetPscVersion); ok = ok && getSymbolAddr(fwDeviceClose, deviceClose); + ok = ok && getSymbolAddr(fwDeviceUpdateLateBindingConfig, deviceUpdateLateBindingConfig); ok = ok && loadEntryPointsExt(); return ok; @@ -196,6 +206,19 @@ ze_result_t FirmwareUtilImp::fwFlashOprom(void *pImage, uint32_t size) { return ZE_RESULT_SUCCESS; } +ze_result_t FirmwareUtilImp::fwFlashLateBinding(void *pImage, uint32_t size, std::string fwType) { + const std::lock_guard lock(this->fwLock); + uint32_t lateBindingFlashStatus = 0; + int ret = deviceUpdateLateBindingConfig(&fwDeviceHandle, lateBindingTypeToEnumMap.at(fwType), CSC_LATE_BINDING_FLAGS_IS_PERSISTENT_MASK, static_cast(pImage), static_cast(size), &lateBindingFlashStatus); + if (ret != IGSC_SUCCESS || lateBindingFlashStatus != CSC_LATE_BINDING_STATUS_SUCCESS) { + if (ret == IGSC_ERROR_BUSY) { + return ZE_RESULT_ERROR_HANDLE_OBJECT_IN_USE; + } + return ZE_RESULT_ERROR_UNINITIALIZED; + } + return ZE_RESULT_SUCCESS; +} + FirmwareUtilImp::FirmwareUtilImp(uint16_t domain, uint8_t bus, uint8_t device, uint8_t function) : domain(domain), bus(bus), device(device), function(function) { } diff --git a/level_zero/sysman/source/shared/firmware_util/sysman_firmware_util_imp.h b/level_zero/sysman/source/shared/firmware_util/sysman_firmware_util_imp.h index 3144adf457..89610ef5ef 100644 --- a/level_zero/sysman/source/shared/firmware_util/sysman_firmware_util_imp.h +++ b/level_zero/sysman/source/shared/firmware_util/sysman_firmware_util_imp.h @@ -49,6 +49,12 @@ typedef int (*pIgscDeviceOpromVersion)(struct igsc_device_handle *handle, struct igsc_oprom_version *version); typedef int (*pIgscDeviceClose)(struct igsc_device_handle *handle); +typedef int (*pIgscDeviceUpdateLateBindingConfig)(struct igsc_device_handle *handle, + uint32_t type, + uint32_t flags, + uint8_t *payload, + size_t payloadSize, + uint32_t *status); typedef int (*pIgscIfrGetStatusExt)(struct igsc_device_handle *handle, uint32_t *supportedTests, uint32_t *hwCapabilities, @@ -101,6 +107,7 @@ extern pIgscImageOpromType imageOpromType; extern pIgscDeviceOpromUpdate deviceOpromUpdate; extern pIgscDeviceOpromVersion deviceOpromVersion; extern pIgscDeviceClose deviceClose; +extern pIgscDeviceUpdateLateBindingConfig deviceUpdateLateBindingConfig; extern pIgscIfrGetStatusExt deviceIfrGetStatusExt; extern pIgscDevicePscVersion deviceGetPscVersion; extern pIgscIafPscUpdate iafPscUpdate; @@ -166,6 +173,7 @@ class FirmwareUtilImp : public FirmwareUtil, NEO::NonCopyableAndNonMovableClass ze_result_t fwSetEccConfig(uint8_t newState, uint8_t *currentState, uint8_t *pendingState) override; void getDeviceSupportedFwTypes(std::vector &fwTypes) override; void fwGetMemoryHealthIndicator(zes_mem_health_t *health) override; + void getLateBindingSupportedFwTypes(std::vector &fwTypes) override; static int fwUtilLoadFlags; static std::string fwUtilLibraryName; @@ -183,6 +191,7 @@ class FirmwareUtilImp : public FirmwareUtil, NEO::NonCopyableAndNonMovableClass ze_result_t fwFlashGSC(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); ze_result_t fwCallGetstatusExt(uint32_t &supportedTests, uint32_t &ifrApplied, uint32_t &prevErrors, uint32_t &pendingReset); std::string fwDevicePath{}; diff --git a/level_zero/sysman/source/shared/firmware_util/sysman_firmware_util_imp_helper.cpp b/level_zero/sysman/source/shared/firmware_util/sysman_firmware_util_imp_helper.cpp index 962e0234bb..3c352c4a1c 100644 --- a/level_zero/sysman/source/shared/firmware_util/sysman_firmware_util_imp_helper.cpp +++ b/level_zero/sysman/source/shared/firmware_util/sysman_firmware_util_imp_helper.cpp @@ -9,10 +9,13 @@ #include "level_zero/sysman/source/shared/firmware_util/sysman_firmware_util_imp.h" +#include + static std::vector deviceSupportedFirmwareTypes = {"GSC", "OptionROM", "PSC"}; static constexpr uint8_t eccStateNone = 0xFF; constexpr uint8_t maxGfspHeciOutBuffer = UINT8_MAX; constexpr uint8_t maxGfspHeciInBuffer = 4; +static std::vector lateBindingFirmwareTypes = {"FanTable", "VRConfig"}; namespace L0 { namespace Sysman { @@ -339,6 +342,9 @@ ze_result_t FirmwareUtilImp::flashFirmware(std::string fwType, void *pImage, uin if (fwType == deviceSupportedFirmwareTypes[2]) { // PSC return fwFlashIafPsc(pImage, size); } + if (std::find(lateBindingFirmwareTypes.begin(), lateBindingFirmwareTypes.end(), fwType) != lateBindingFirmwareTypes.end()) { // FanTable and VRConfig + return fwFlashLateBinding(pImage, size, fwType); + } return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; } @@ -374,6 +380,10 @@ void FirmwareUtilImp::getDeviceSupportedFwTypes(std::vector &fwType } } +void FirmwareUtilImp::getLateBindingSupportedFwTypes(std::vector &fwTypes) { + fwTypes.insert(fwTypes.end(), lateBindingFirmwareTypes.begin(), lateBindingFirmwareTypes.end()); +} + ze_result_t FirmwareUtilImp::getFwVersion(std::string fwType, std::string &firmwareVersion) { if (fwType == deviceSupportedFirmwareTypes[0]) { // GSC return fwGetVersion(firmwareVersion); 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 c2c0a45c75..3a7f87e42e 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,6 +89,7 @@ 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 1c5847c93c..b7ce3e7523 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,6 +63,7 @@ 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 7f29442e17..e033e4d1b0 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 @@ -337,6 +337,11 @@ 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 2174f415e4..32901298e8 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 @@ -1086,6 +1086,11 @@ bool SysmanProductHelperHw::isEccConfigurationSupported() { return true; } +template <> +bool SysmanProductHelperHw::isLateBindingSupported() { + return true; +} + template class SysmanProductHelperHw; } // namespace Sysman diff --git a/level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper.h b/level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper.h index 78228803b7..d624e1c8d0 100644 --- a/level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper.h +++ b/level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper.h @@ -60,6 +60,9 @@ class SysmanProductHelper { virtual ze_result_t getPowerPropertiesExtFromPmt(zes_power_ext_properties_t *pExtPoperties, zes_power_domain_t powerDomain) = 0; virtual ze_result_t getPowerEnergyCounter(zes_power_energy_counter_t *pEnergy, zes_power_domain_t powerDomain, WddmSysmanImp *pWddmSysmanImp) = 0; + // Firmware + virtual bool isLateBindingSupported() = 0; + // Pmt virtual std::map> *getGuidToKeyOffsetMap() = 0; diff --git a/level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper_hw.h b/level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper_hw.h index b70f471f66..d59d72d712 100644 --- a/level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper_hw.h +++ b/level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper_hw.h @@ -40,6 +40,9 @@ class SysmanProductHelperHw : public SysmanProductHelper { ze_result_t getPowerPropertiesExtFromPmt(zes_power_ext_properties_t *pExtPoperties, zes_power_domain_t powerDomain) override; ze_result_t getPowerEnergyCounter(zes_power_energy_counter_t *pEnergy, zes_power_domain_t powerDomain, WddmSysmanImp *pWddmSysmanImp) override; + // Firmware + bool isLateBindingSupported() override; + // Pmt std::map> *getGuidToKeyOffsetMap() override; diff --git a/level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper_hw.inl b/level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper_hw.inl index 5ec3ba1402..fdad613bba 100644 --- a/level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper_hw.inl +++ b/level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper_hw.inl @@ -193,5 +193,10 @@ bool SysmanProductHelperHw::isZesInitSupported() { return false; } +template +bool SysmanProductHelperHw::isLateBindingSupported() { + return false; +} + } // namespace Sysman } // namespace L0 diff --git a/level_zero/sysman/source/shared/windows/product_helper/xe2_hpg_core/bmg/sysman_product_helper_bmg.cpp b/level_zero/sysman/source/shared/windows/product_helper/xe2_hpg_core/bmg/sysman_product_helper_bmg.cpp index fdcf24ca0d..cc62550ff5 100644 --- a/level_zero/sysman/source/shared/windows/product_helper/xe2_hpg_core/bmg/sysman_product_helper_bmg.cpp +++ b/level_zero/sysman/source/shared/windows/product_helper/xe2_hpg_core/bmg/sysman_product_helper_bmg.cpp @@ -982,6 +982,11 @@ bool SysmanProductHelperHw::isZesInitSupported() { return true; } +template <> +bool SysmanProductHelperHw::isLateBindingSupported() { + return true; +} + template class SysmanProductHelperHw; } // namespace Sysman diff --git a/level_zero/sysman/test/unit_tests/sources/diagnostics/linux/mock_zes_sysman_diagnostics.h b/level_zero/sysman/test/unit_tests/sources/diagnostics/linux/mock_zes_sysman_diagnostics.h index e7686aef7e..0bf884ebd6 100644 --- a/level_zero/sysman/test/unit_tests/sources/diagnostics/linux/mock_zes_sysman_diagnostics.h +++ b/level_zero/sysman/test/unit_tests/sources/diagnostics/linux/mock_zes_sysman_diagnostics.h @@ -66,6 +66,7 @@ struct MockDiagnosticsFwInterface : public L0::Sysman::FirmwareUtil { ADDMETHOD_NOBASE(fwSetEccConfig, ze_result_t, ZE_RESULT_SUCCESS, (uint8_t newState, uint8_t *currentState, uint8_t *pendingState)); ADDMETHOD_NOBASE_VOIDRETURN(getDeviceSupportedFwTypes, (std::vector & fwTypes)); ADDMETHOD_NOBASE_VOIDRETURN(fwGetMemoryHealthIndicator, (zes_mem_health_t * health)); + ADDMETHOD_NOBASE_VOIDRETURN(getLateBindingSupportedFwTypes, (std::vector & fwTypes)); }; struct MockGlobalOperationsEngineHandleContext : public L0::Sysman::EngineHandleContext { MockGlobalOperationsEngineHandleContext(L0::Sysman::OsSysman *pOsSysman) : EngineHandleContext(pOsSysman) {} diff --git a/level_zero/sysman/test/unit_tests/sources/ecc/linux/mock_ecc.h b/level_zero/sysman/test/unit_tests/sources/ecc/linux/mock_ecc.h index 17cb984815..da511a6482 100644 --- a/level_zero/sysman/test/unit_tests/sources/ecc/linux/mock_ecc.h +++ b/level_zero/sysman/test/unit_tests/sources/ecc/linux/mock_ecc.h @@ -82,6 +82,7 @@ struct MockEccFwInterface : public L0::Sysman::FirmwareUtil { ADDMETHOD_NOBASE(fwGetMemoryErrorCount, ze_result_t, ZE_RESULT_SUCCESS, (zes_ras_error_type_t category, uint32_t subDeviceCount, uint32_t subDeviceId, uint64_t &count)); ADDMETHOD_NOBASE_VOIDRETURN(getDeviceSupportedFwTypes, (std::vector & fwTypes)); ADDMETHOD_NOBASE_VOIDRETURN(fwGetMemoryHealthIndicator, (zes_mem_health_t * health)); + ADDMETHOD_NOBASE_VOIDRETURN(getLateBindingSupportedFwTypes, (std::vector & fwTypes)); MockEccFwInterface() = default; ~MockEccFwInterface() override = default; diff --git a/level_zero/sysman/test/unit_tests/sources/ecc/windows/mock_ecc.h b/level_zero/sysman/test/unit_tests/sources/ecc/windows/mock_ecc.h index 24beaa4650..9d47b2d3a8 100644 --- a/level_zero/sysman/test/unit_tests/sources/ecc/windows/mock_ecc.h +++ b/level_zero/sysman/test/unit_tests/sources/ecc/windows/mock_ecc.h @@ -85,6 +85,7 @@ struct EccFwInterface : public L0::Sysman::FirmwareUtil { ADDMETHOD_NOBASE(fwGetMemoryErrorCount, ze_result_t, ZE_RESULT_SUCCESS, (zes_ras_error_type_t category, uint32_t subDeviceCount, uint32_t subDeviceId, uint64_t &count)); ADDMETHOD_NOBASE_VOIDRETURN(getDeviceSupportedFwTypes, (std::vector & fwTypes)); ADDMETHOD_NOBASE_VOIDRETURN(fwGetMemoryHealthIndicator, (zes_mem_health_t * health)); + ADDMETHOD_NOBASE_VOIDRETURN(getLateBindingSupportedFwTypes, (std::vector & fwTypes)); }; } // namespace ult diff --git a/level_zero/sysman/test/unit_tests/sources/events/linux/mock_events.h b/level_zero/sysman/test/unit_tests/sources/events/linux/mock_events.h index 39602ee179..cf6610f51b 100644 --- a/level_zero/sysman/test/unit_tests/sources/events/linux/mock_events.h +++ b/level_zero/sysman/test/unit_tests/sources/events/linux/mock_events.h @@ -258,6 +258,7 @@ struct MockEventsFwInterface : public L0::Sysman::FirmwareUtil { ADDMETHOD_NOBASE(fwSetEccConfig, ze_result_t, ZE_RESULT_SUCCESS, (uint8_t newState, uint8_t *currentState, uint8_t *pendingState)); ADDMETHOD_NOBASE_VOIDRETURN(getDeviceSupportedFwTypes, (std::vector & fwTypes)); ADDMETHOD_NOBASE_VOIDRETURN(fwGetMemoryHealthIndicator, (zes_mem_health_t * health)); + ADDMETHOD_NOBASE_VOIDRETURN(getLateBindingSupportedFwTypes, (std::vector & fwTypes)); }; struct MockEventNeoDrm : public Drm { 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 30018ce0cf..7990c90049 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 @@ -105,6 +105,10 @@ struct MockFirmwareInterface : public FirmwareInterface { } } + void getLateBindingSupportedFwTypes(std::vector &fwTypes) override { + fwTypes.insert(fwTypes.end(), lateBindingFirmwareTypes.begin(), lateBindingFirmwareTypes.end()); + } + MockFirmwareInterface() = default; ADDMETHOD_NOBASE(fwDeviceInit, ze_result_t, ZE_RESULT_SUCCESS, ()); 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 c842ac12e0..b0d70e7a03 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 @@ -8,6 +8,8 @@ #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 { @@ -358,6 +360,61 @@ HWTEST2_F(ZesSysmanFirmwareFixture, GivenValidFirmwareHandleWhenGettingFirmwareC 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); + } + } +} + } // namespace ult } // namespace Sysman } // namespace L0 diff --git a/level_zero/sysman/test/unit_tests/sources/firmware/windows/mock_zes_sysman_firmware.h b/level_zero/sysman/test/unit_tests/sources/firmware/windows/mock_zes_sysman_firmware.h index f46399b11a..76a838f055 100644 --- a/level_zero/sysman/test/unit_tests/sources/firmware/windows/mock_zes_sysman_firmware.h +++ b/level_zero/sysman/test/unit_tests/sources/firmware/windows/mock_zes_sysman_firmware.h @@ -19,9 +19,9 @@ namespace ult { constexpr uint32_t mockHandleCount = 2; const std::string mockFwVersion("DG01->0->2026"); const std::string mockOpromVersion("OPROM CODE VERSION:123_OPROM DATA VERSION:456"); -std::vector mockSupportedFwTypes = {"GSC", "OptionROM"}; -std::vector mockUnsupportedFwTypes = {"unknown"}; -std::string mockEmpty = {}; +const std::vector mockSupportedFwTypes = {"GSC", "OptionROM"}; +const std::string mockUnknownVersion("unknown"); +const std::vector mockUnsupportedFwTypes = {"unknown"}; struct FirmwareInterface : public L0::Sysman::FirmwareUtil { @@ -53,6 +53,10 @@ struct FirmwareInterface : public L0::Sysman::FirmwareUtil { fwTypes = mockSupportedFwTypes; } + void getLateBindingSupportedFwTypes(std::vector &fwTypes) override { + fwTypes.insert(fwTypes.end(), lateBindingFirmwareTypes.begin(), lateBindingFirmwareTypes.end()); + } + ADDMETHOD_NOBASE(fwDeviceInit, ze_result_t, ZE_RESULT_SUCCESS, ()); ADDMETHOD_NOBASE(getFlashFirmwareProgress, ze_result_t, ZE_RESULT_SUCCESS, (uint32_t * pCompletionPercent)); ADDMETHOD_NOBASE(flashFirmware, ze_result_t, ZE_RESULT_SUCCESS, (std::string fwType, void *pImage, uint32_t size)); @@ -72,6 +76,40 @@ class PublicWddmFirmwareImp : public L0::Sysman::WddmFirmwareImp { using WddmFirmwareImp::pFwInterface; }; +class ZesFirmwareFixture : public SysmanDeviceFixture { + + protected: + zes_firmware_handle_t hSysmanFirmware = {}; + std::unique_ptr pMockFwInterface; + L0::Sysman::FirmwareUtil *pFwUtilInterfaceOld = nullptr; + + void SetUp() override { + SysmanDeviceFixture::SetUp(); + + pFwUtilInterfaceOld = pWddmSysmanImp->pFwUtilInterface; + pMockFwInterface.reset(new FirmwareInterface); + pWddmSysmanImp->pFwUtilInterface = pMockFwInterface.get(); + for (const auto &handle : pSysmanDeviceImp->pFirmwareHandleContext->handleList) { + delete handle; + } + pSysmanDeviceImp->pFirmwareHandleContext->handleList.clear(); + } + void TearDown() override { + pWddmSysmanImp->pFwUtilInterface = pFwUtilInterfaceOld; + SysmanDeviceFixture::TearDown(); + } + void initFirmware() { + uint32_t count = 0; + ze_result_t result = zesDeviceEnumFirmwares(pSysmanDevice->toHandle(), &count, nullptr); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + } + std::vector getFirmwareHandles(uint32_t count) { + std::vector handles(count, nullptr); + EXPECT_EQ(zesDeviceEnumFirmwares(pSysmanDevice->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS); + return handles; + } +}; + } // namespace ult } // namespace Sysman } // namespace L0 diff --git a/level_zero/sysman/test/unit_tests/sources/firmware/windows/test_zes_sysman_firmware.cpp b/level_zero/sysman/test/unit_tests/sources/firmware/windows/test_zes_sysman_firmware.cpp index 72774fdb03..232e8f60a1 100644 --- a/level_zero/sysman/test/unit_tests/sources/firmware/windows/test_zes_sysman_firmware.cpp +++ b/level_zero/sysman/test/unit_tests/sources/firmware/windows/test_zes_sysman_firmware.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2023-2024 Intel Corporation + * Copyright (C) 2023-2025 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -11,82 +11,6 @@ namespace L0 { namespace Sysman { namespace ult { -class ZesFirmwareFixture : public SysmanDeviceFixture { - - protected: - zes_firmware_handle_t hSysmanFirmware = {}; - std::unique_ptr pMockFwInterface; - L0::Sysman::FirmwareUtil *pFwUtilInterfaceOld = nullptr; - - void SetUp() override { - SysmanDeviceFixture::SetUp(); - - pFwUtilInterfaceOld = pWddmSysmanImp->pFwUtilInterface; - pMockFwInterface.reset(new FirmwareInterface); - pWddmSysmanImp->pFwUtilInterface = pMockFwInterface.get(); - for (const auto &handle : pSysmanDeviceImp->pFirmwareHandleContext->handleList) { - delete handle; - } - pSysmanDeviceImp->pFirmwareHandleContext->handleList.clear(); - } - void TearDown() override { - pWddmSysmanImp->pFwUtilInterface = pFwUtilInterfaceOld; - SysmanDeviceFixture::TearDown(); - } - void initFirmware() { - uint32_t count = 0; - ze_result_t result = zesDeviceEnumFirmwares(pSysmanDevice->toHandle(), &count, nullptr); - EXPECT_EQ(ZE_RESULT_SUCCESS, result); - } - std::vector getFirmwareHandles(uint32_t count) { - std::vector handles(count, nullptr); - EXPECT_EQ(zesDeviceEnumFirmwares(pSysmanDevice->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS); - return handles; - } -}; - -TEST_F(ZesFirmwareFixture, GivenComponentCountZeroWhenCallingzesFirmwareGetThenZeroCountIsReturnedAndVerifyzesFirmwareGetCallSucceeds) { - std::vector firmwareHandle{}; - uint32_t count = 0; - - ze_result_t result = zesDeviceEnumFirmwares(pSysmanDevice->toHandle(), &count, nullptr); - - EXPECT_EQ(ZE_RESULT_SUCCESS, result); - EXPECT_EQ(count, mockHandleCount); - - uint32_t testCount = count + 1; - - result = zesDeviceEnumFirmwares(pSysmanDevice->toHandle(), &testCount, nullptr); - - EXPECT_EQ(ZE_RESULT_SUCCESS, result); - EXPECT_EQ(testCount, count); - - firmwareHandle.resize(count); - result = zesDeviceEnumFirmwares(pSysmanDevice->toHandle(), &count, firmwareHandle.data()); - - EXPECT_EQ(ZE_RESULT_SUCCESS, result); - EXPECT_EQ(count, mockHandleCount); - - L0::Sysman::FirmwareImp *ptestFirmwareImp = new L0::Sysman::FirmwareImp(pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman, mockSupportedFwTypes[0]); - pSysmanDeviceImp->pFirmwareHandleContext->handleList.push_back(ptestFirmwareImp); - result = zesDeviceEnumFirmwares(pSysmanDevice->toHandle(), &count, nullptr); - - EXPECT_EQ(ZE_RESULT_SUCCESS, result); - EXPECT_EQ(count, mockHandleCount); - - testCount = count; - - firmwareHandle.resize(testCount); - result = zesDeviceEnumFirmwares(pSysmanDevice->toHandle(), &testCount, firmwareHandle.data()); - - EXPECT_EQ(ZE_RESULT_SUCCESS, result); - EXPECT_NE(nullptr, firmwareHandle.data()); - EXPECT_EQ(testCount, mockHandleCount); - - pSysmanDeviceImp->pFirmwareHandleContext->handleList.pop_back(); - delete ptestFirmwareImp; -} - TEST_F(ZesFirmwareFixture, GivenValidFirmwareHandleWhenGettingFirmwarePropertiesThenVersionIsReturned) { initFirmware(); diff --git a/level_zero/sysman/test/unit_tests/sources/firmware_util/mock_fw_util_fixture.h b/level_zero/sysman/test/unit_tests/sources/firmware_util/mock_fw_util_fixture.h index af4be3fa22..2efda0cbde 100644 --- a/level_zero/sysman/test/unit_tests/sources/firmware_util/mock_fw_util_fixture.h +++ b/level_zero/sysman/test/unit_tests/sources/firmware_util/mock_fw_util_fixture.h @@ -36,6 +36,7 @@ struct MockFwUtilInterface : public L0::Sysman::FirmwareUtil { ADDMETHOD_NOBASE(fwGetEccConfig, ze_result_t, ZE_RESULT_SUCCESS, (uint8_t * currentState, uint8_t *pendingState)); ADDMETHOD_NOBASE(fwSetEccConfig, ze_result_t, ZE_RESULT_SUCCESS, (uint8_t newState, uint8_t *currentState, uint8_t *pendingState)); ADDMETHOD_NOBASE_VOIDRETURN(getDeviceSupportedFwTypes, (std::vector & fwTypes)); + ADDMETHOD_NOBASE_VOIDRETURN(getLateBindingSupportedFwTypes, (std::vector & fwTypes)); void fwGetMemoryHealthIndicator(zes_mem_health_t *health) override { *health = fwGetMemoryHealthIndicatorResult; diff --git a/level_zero/sysman/test/unit_tests/sources/firmware_util/test_fw_util_helper.cpp b/level_zero/sysman/test/unit_tests/sources/firmware_util/test_fw_util_helper.cpp index ff5aae989f..5f4f3da7f9 100644 --- a/level_zero/sysman/test/unit_tests/sources/firmware_util/test_fw_util_helper.cpp +++ b/level_zero/sysman/test/unit_tests/sources/firmware_util/test_fw_util_helper.cpp @@ -18,6 +18,7 @@ namespace L0 { extern L0::Sysman::pIgscIfrGetStatusExt L0::Sysman::deviceIfrGetStatusExt; extern L0::Sysman::pIgscIfrRunMemPPRTest L0::Sysman::deviceIfrRunMemPPRTest; extern L0::Sysman::pIgscGfspHeciCmd gfspHeciCmd; +extern L0::Sysman::pIgscDeviceUpdateLateBindingConfig deviceUpdateLateBindingConfig; namespace Sysman { namespace ult { @@ -986,6 +987,83 @@ TEST(FwGetSupportedFwTypesTest, GivenFirmwareUtilAndOnlyOpromCodeSupportedWhenCa delete pFwUtilImp; } +TEST(FwFlashLateBindingTest, GivenFirmwareUtilImpAndLateBindingIsSupportedWhenCallingFlashFirmwareThenCallSucceeds) { + VariableBackup mockDeviceUpdateLateBindingConfig(&L0::Sysman::deviceUpdateLateBindingConfig, [](struct igsc_device_handle *handle, uint32_t type, uint32_t flags, uint8_t *payload, size_t payloadSize, uint32_t *status) -> int { + *status = CSC_LATE_BINDING_STATUS_SUCCESS; + return IGSC_SUCCESS; + }); + + L0::Sysman::FirmwareUtilImp *pFwUtilImp = new L0::Sysman::FirmwareUtilImp(0, 0, 0, 0); + uint8_t testImage[ZES_STRING_PROPERTY_SIZE] = {}; + memset(testImage, 0xA, ZES_STRING_PROPERTY_SIZE); + pFwUtilImp->libraryHandle = static_cast(new MockFwUtilOsLibrary()); + + for (auto type : lateBindingFirmwareTypes) { + auto ret = pFwUtilImp->flashFirmware(type, (void *)testImage, ZES_STRING_PROPERTY_SIZE); + EXPECT_EQ(ZE_RESULT_SUCCESS, ret); + } + + delete pFwUtilImp->libraryHandle; + pFwUtilImp->libraryHandle = nullptr; + delete pFwUtilImp; +} + +TEST(FwFlashLateBindingTest, GivenFirmwareUtilImpAndLateBindingIsSupportedWhenCallingFlashFirmwareAndIgscIsBusyThenCallFailsWithProperReturnCode) { + VariableBackup mockDeviceUpdateLateBindingConfig(&L0::Sysman::deviceUpdateLateBindingConfig, [](struct igsc_device_handle *handle, uint32_t type, uint32_t flags, uint8_t *payload, size_t payloadSize, uint32_t *status) -> int { + *status = CSC_LATE_BINDING_STATUS_SUCCESS; + return IGSC_ERROR_BUSY; + }); + + L0::Sysman::FirmwareUtilImp *pFwUtilImp = new L0::Sysman::FirmwareUtilImp(0, 0, 0, 0); + uint8_t testImage[ZES_STRING_PROPERTY_SIZE] = {}; + memset(testImage, 0xA, ZES_STRING_PROPERTY_SIZE); + pFwUtilImp->libraryHandle = static_cast(new MockFwUtilOsLibrary()); + + for (auto type : lateBindingFirmwareTypes) { + auto ret = pFwUtilImp->flashFirmware(type, (void *)testImage, ZES_STRING_PROPERTY_SIZE); + EXPECT_EQ(ZE_RESULT_ERROR_HANDLE_OBJECT_IN_USE, ret); + } + + delete pFwUtilImp->libraryHandle; + pFwUtilImp->libraryHandle = nullptr; + delete pFwUtilImp; +} + +TEST(FwFlashLateBindingTest, GivenFirmwareUtilImpAndLateBindingIsSupportedWhenCallingFlashFirmwareAndStatusRetunedIsInvalidThenCallFailsWithProperReturnCode) { + VariableBackup mockDeviceUpdateLateBindingConfig(&L0::Sysman::deviceUpdateLateBindingConfig, [](struct igsc_device_handle *handle, uint32_t type, uint32_t flags, uint8_t *payload, size_t payloadSize, uint32_t *status) -> int { + *status = CSC_LATE_BINDING_STATUS_TIMEOUT; + return IGSC_SUCCESS; + }); + + L0::Sysman::FirmwareUtilImp *pFwUtilImp = new L0::Sysman::FirmwareUtilImp(0, 0, 0, 0); + uint8_t testImage[ZES_STRING_PROPERTY_SIZE] = {}; + memset(testImage, 0xA, ZES_STRING_PROPERTY_SIZE); + pFwUtilImp->libraryHandle = static_cast(new MockFwUtilOsLibrary()); + + for (auto type : lateBindingFirmwareTypes) { + auto ret = pFwUtilImp->flashFirmware(type, (void *)testImage, ZES_STRING_PROPERTY_SIZE); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, ret); + } + + delete pFwUtilImp->libraryHandle; + pFwUtilImp->libraryHandle = nullptr; + delete pFwUtilImp; +} + +TEST(FwFlashLateBindingTest, GivenFirmwareUtilImpAndLateBindingIsSupportedWhenCallingGetLateBindingSupportedFwTypesThenProperFwTypesAreReturned) { + L0::Sysman::FirmwareUtilImp *pFwUtilImp = new L0::Sysman::FirmwareUtilImp(0, 0, 0, 0); + pFwUtilImp->libraryHandle = static_cast(new MockFwUtilOsLibrary()); + std::vector deviceSupportedFwTypes = {}; + pFwUtilImp->getLateBindingSupportedFwTypes(deviceSupportedFwTypes); + EXPECT_EQ(deviceSupportedFwTypes.size(), lateBindingFirmwareTypes.size()); + for (auto type : deviceSupportedFwTypes) { + EXPECT_NE(std::find(lateBindingFirmwareTypes.begin(), lateBindingFirmwareTypes.end(), type), lateBindingFirmwareTypes.end()); + } + delete pFwUtilImp->libraryHandle; + pFwUtilImp->libraryHandle = nullptr; + delete pFwUtilImp; +} + } // namespace ult } // namespace Sysman } // namespace L0 diff --git a/level_zero/sysman/test/unit_tests/sources/global_operations/linux/mock_global_operations.h b/level_zero/sysman/test/unit_tests/sources/global_operations/linux/mock_global_operations.h index 71c339a6f9..770a68538f 100644 --- a/level_zero/sysman/test/unit_tests/sources/global_operations/linux/mock_global_operations.h +++ b/level_zero/sysman/test/unit_tests/sources/global_operations/linux/mock_global_operations.h @@ -609,6 +609,7 @@ struct MockGlobalOpsFwInterface : public L0::Sysman::FirmwareUtil { ADDMETHOD_NOBASE(fwSetEccConfig, ze_result_t, ZE_RESULT_SUCCESS, (uint8_t newState, uint8_t *currentState, uint8_t *pendingState)); ADDMETHOD_NOBASE_VOIDRETURN(getDeviceSupportedFwTypes, (std::vector & fwTypes)); ADDMETHOD_NOBASE_VOIDRETURN(fwGetMemoryHealthIndicator, (zes_mem_health_t * health)); + ADDMETHOD_NOBASE_VOIDRETURN(getLateBindingSupportedFwTypes, (std::vector & fwTypes)); }; struct MockGlobalOpsLinuxSysmanImp : public L0::Sysman::LinuxSysmanImp { diff --git a/level_zero/sysman/test/unit_tests/sources/ras/linux/mock_sysman_ras.h b/level_zero/sysman/test/unit_tests/sources/ras/linux/mock_sysman_ras.h index 0139cc637d..9659bdb648 100644 --- a/level_zero/sysman/test/unit_tests/sources/ras/linux/mock_sysman_ras.h +++ b/level_zero/sysman/test/unit_tests/sources/ras/linux/mock_sysman_ras.h @@ -672,6 +672,7 @@ struct MockRasFwInterface : public L0::Sysman::FirmwareUtil { ADDMETHOD_NOBASE(fwGetEccConfig, ze_result_t, ZE_RESULT_SUCCESS, (uint8_t * currentState, uint8_t *pendingState)); ADDMETHOD_NOBASE(fwSetEccConfig, ze_result_t, ZE_RESULT_SUCCESS, (uint8_t newState, uint8_t *currentState, uint8_t *pendingState)); ADDMETHOD_NOBASE_VOIDRETURN(fwGetMemoryHealthIndicator, (zes_mem_health_t * health)); + ADDMETHOD_NOBASE_VOIDRETURN(getLateBindingSupportedFwTypes, (std::vector & fwTypes)); }; struct MockRasNeoDrm : public Drm { diff --git a/level_zero/sysman/test/unit_tests/sources/shared/windows/product_helper/CMakeLists.txt b/level_zero/sysman/test/unit_tests/sources/shared/windows/product_helper/CMakeLists.txt index 7882d170fd..e22cd4d355 100644 --- a/level_zero/sysman/test/unit_tests/sources/shared/windows/product_helper/CMakeLists.txt +++ b/level_zero/sysman/test/unit_tests/sources/shared/windows/product_helper/CMakeLists.txt @@ -1,5 +1,5 @@ # -# Copyright (C) 2024 Intel Corporation +# Copyright (C) 2024-2025 Intel Corporation # # SPDX-License-Identifier: MIT # @@ -12,6 +12,7 @@ if(WIN32) ${CMAKE_CURRENT_SOURCE_DIR}/sysman_product_helper_memory_tests.cpp ${CMAKE_CURRENT_SOURCE_DIR}/sysman_product_helper_power_tests.cpp ${CMAKE_CURRENT_SOURCE_DIR}/sysman_product_helper_init_tests.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/sysman_product_helper_firmware_tests.cpp ) endif() add_subdirectories() diff --git a/level_zero/sysman/test/unit_tests/sources/shared/windows/product_helper/sysman_product_helper_firmware_tests.cpp b/level_zero/sysman/test/unit_tests/sources/shared/windows/product_helper/sysman_product_helper_firmware_tests.cpp new file mode 100644 index 0000000000..a6664896c3 --- /dev/null +++ b/level_zero/sysman/test/unit_tests/sources/shared/windows/product_helper/sysman_product_helper_firmware_tests.cpp @@ -0,0 +1,117 @@ +/* + * Copyright (C) 2023-2025 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#include "shared/test/common/test_macros/hw_test.h" + +#include "level_zero/sysman/test/unit_tests/sources/firmware/windows/mock_zes_sysman_firmware.h" + +#include + +namespace L0 { +namespace Sysman { +namespace ult { + +HWTEST2_F(ZesFirmwareFixture, GivenComponentCountZeroWhenCallingZesFirmwareGetThenZeroCountIsReturnedAndVerifyZesFirmwareGetCallSucceeds, IsNotBMG) { + std::vector firmwareHandle{}; + uint32_t count = 0; + + ze_result_t result = zesDeviceEnumFirmwares(pSysmanDevice->toHandle(), &count, nullptr); + + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + EXPECT_EQ(count, mockHandleCount); + + uint32_t testCount = count + 1; + + result = zesDeviceEnumFirmwares(pSysmanDevice->toHandle(), &testCount, nullptr); + + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + EXPECT_EQ(testCount, count); + + firmwareHandle.resize(count); + result = zesDeviceEnumFirmwares(pSysmanDevice->toHandle(), &count, firmwareHandle.data()); + + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + EXPECT_EQ(count, mockHandleCount); + + L0::Sysman::FirmwareImp *ptestFirmwareImp = new L0::Sysman::FirmwareImp(pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman, mockSupportedFwTypes[0]); + pSysmanDeviceImp->pFirmwareHandleContext->handleList.push_back(ptestFirmwareImp); + result = zesDeviceEnumFirmwares(pSysmanDevice->toHandle(), &count, nullptr); + + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + EXPECT_EQ(count, mockHandleCount); + + testCount = count; + + firmwareHandle.resize(testCount); + result = zesDeviceEnumFirmwares(pSysmanDevice->toHandle(), &testCount, firmwareHandle.data()); + + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + EXPECT_NE(nullptr, firmwareHandle.data()); + EXPECT_EQ(testCount, mockHandleCount); + + pSysmanDeviceImp->pFirmwareHandleContext->handleList.pop_back(); + delete ptestFirmwareImp; +} + +HWTEST2_F(ZesFirmwareFixture, GivenComponentCountZeroAndLateBindingIsSupportedThenWhenCallingZesFirmwareGetProperCountIsReturned, IsBMG) { + constexpr uint32_t mockFwHandlesCount = 4; + std::vector firmwareHandle{}; + uint32_t count = 0; + + ze_result_t result = zesDeviceEnumFirmwares(pSysmanDevice->toHandle(), &count, nullptr); + + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + EXPECT_EQ(count, mockFwHandlesCount); + + uint32_t testCount = count + 1; + + result = zesDeviceEnumFirmwares(pSysmanDevice->toHandle(), &testCount, nullptr); + + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + EXPECT_EQ(testCount, count); + + firmwareHandle.resize(count); + result = zesDeviceEnumFirmwares(pSysmanDevice->toHandle(), &count, firmwareHandle.data()); + + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + EXPECT_EQ(count, mockFwHandlesCount); +} + +HWTEST2_F(ZesFirmwareFixture, GivenValidLateBindingFirmwareHandleWhenFlashingFirmwareThenSuccessIsReturned, IsBMG) { + constexpr uint32_t mockFwHandlesCount = 4; + 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(ZesFirmwareFixture, GivenValidLateBindingFirmwareHandleWhenGettingFirmwarePropertiesThenValidVersionIsReturned, IsBMG) { + + constexpr uint32_t mockFwHandlesCount = 4; + 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