intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-12 17:33:00 +08:00
Code Issues Packages Projects Releases Wiki Activity

feature: Add support for dynamic late binding config update (1/2)

Browse Source 
Related-To: NEO-14207

Signed-off-by: shubham kumar <shubham.kumar@intel.com>
This commit is contained in:
shubham kumar
2025-06-03 10:37:26 +00:00
committed by Compute-Runtime-Automation
parent 953639411a
commit c24f63151b
29 changed files with 396 additions and 83 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
level_zero/sysman/source/api/firmware/linux/sysman_os_firmware_imp.cpp
View File

@@ -27,6 +27,9 @@ void OsFirmware::getSupportedFwTypes(std::vector<std::string> &supportedFwTypes,
if (pFwInterface != nullptr) {
auto pSysmanProductHelper = pLinuxSysmanImp->getSysmanProductHelper();
pSysmanProductHelper->getDeviceSupportedFwTypes(pFwInterface, supportedFwTypes);
if (pSysmanProductHelper->isLateBindingSupported()) {
pFwInterface->getLateBindingSupportedFwTypes(supportedFwTypes);
}
}
}

5
level_zero/sysman/source/api/firmware/linux/sysman_os_firmware_imp_helper.cpp
View File

@@ -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<char *>(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<char *>(pProperties->version), ZES_STRING_PROPERTY_SIZE, fwVersion.c_str(), ZES_STRING_PROPERTY_SIZE - 1);

10
level_zero/sysman/source/api/firmware/windows/sysman_os_firmware_imp.cpp
View File

@@ -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<std ::string> 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<char *>(pProperties->version), ZES_STRING_PROPERTY_SIZE, fwVersion.c_str(), ZES_STRING_PROPERTY_SIZE);
@@ -65,9 +69,13 @@ std::unique_ptr<OsFirmware> OsFirmware::create(OsSysman *pOsSysman, const std::s
void OsFirmware::getSupportedFwTypes(std::vector<std::string> &supportedFwTypes, OsSysman *pOsSysman) {
WddmSysmanImp *pWddmSysmanImp = static_cast<WddmSysmanImp *>(pOsSysman);
FirmwareUtil *pFwInterface = pWddmSysmanImp->getFwUtilInterface();
auto pSysmanProductHelper = pWddmSysmanImp->getSysmanProductHelper();
supportedFwTypes.clear();
if (pFwInterface != nullptr) {
supportedFwTypes = deviceSupportedFwTypes;
if (pSysmanProductHelper->isLateBindingSupported()) {
pFwInterface->getLateBindingSupportedFwTypes(supportedFwTypes);
}
}
}

3
level_zero/sysman/source/shared/firmware_util/sysman_firmware_util.h
View File

@@ -17,6 +17,8 @@
namespace L0 {
namespace Sysman {
static std::vector<std ::string> 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<std::string> &fwTypes) = 0;
virtual void fwGetMemoryHealthIndicator(zes_mem_health_t *health) = 0;
virtual void getLateBindingSupportedFwTypes(std::vector<std::string> &fwTypes) = 0;
virtual ~FirmwareUtil() = default;
};
} // namespace Sysman

23
level_zero/sysman/source/shared/firmware_util/sysman_firmware_util_imp.cpp
View File

@@ -11,8 +11,15 @@
#include "shared/source/helpers/debug_helpers.h"
#include "shared/source/utilities/directory.h"
#include <map>
namespace L0 {
namespace Sysman {
static const std::map<std::string, csc_late_binding_type> 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<std::mutex> lock(this->fwLock);
uint32_t lateBindingFlashStatus = 0;
int ret = deviceUpdateLateBindingConfig(&fwDeviceHandle, lateBindingTypeToEnumMap.at(fwType), CSC_LATE_BINDING_FLAGS_IS_PERSISTENT_MASK, static_cast<uint8_t *>(pImage), static_cast<size_t>(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) {
}

9
level_zero/sysman/source/shared/firmware_util/sysman_firmware_util_imp.h
View File

@@ -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<std::string> &fwTypes) override;
void fwGetMemoryHealthIndicator(zes_mem_health_t *health) override;
void getLateBindingSupportedFwTypes(std::vector<std::string> &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{};

10
level_zero/sysman/source/shared/firmware_util/sysman_firmware_util_imp_helper.cpp
View File

@@ -9,10 +9,13 @@
#include "level_zero/sysman/source/shared/firmware_util/sysman_firmware_util_imp.h"
#include <algorithm>
static std::vector<std ::string> deviceSupportedFirmwareTypes = {"GSC", "OptionROM", "PSC"};
static constexpr uint8_t eccStateNone = 0xFF;
constexpr uint8_t maxGfspHeciOutBuffer = UINT8_MAX;
constexpr uint8_t maxGfspHeciInBuffer = 4;
static std::vector<std ::string> 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<std::string> &fwType
}
}
void FirmwareUtilImp::getLateBindingSupportedFwTypes(std::vector<std::string> &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);

1
level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper.h
View File

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

1
level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper_hw.h
View File

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

5
level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper_hw.inl
View File

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

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

@@ -1086,6 +1086,11 @@ bool SysmanProductHelperHw<gfxProduct>::isEccConfigurationSupported() {
return true;
}
template <>
bool SysmanProductHelperHw<gfxProduct>::isLateBindingSupported() {
return true;
}
template class SysmanProductHelperHw<gfxProduct>;
} // namespace Sysman

3
level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper.h
View File

@@ -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<unsigned long, std::map<std::string, uint32_t>> *getGuidToKeyOffsetMap() = 0;

3
level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper_hw.h
View File

@@ -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<unsigned long, std::map<std::string, uint32_t>> *getGuidToKeyOffsetMap() override;

5
level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper_hw.inl
View File

@@ -193,5 +193,10 @@ bool SysmanProductHelperHw<gfxProduct>::isZesInitSupported() {
return false;
}
template <PRODUCT_FAMILY gfxProduct>
bool SysmanProductHelperHw<gfxProduct>::isLateBindingSupported() {
return false;
}
} // namespace Sysman
} // namespace L0

5
level_zero/sysman/source/shared/windows/product_helper/xe2_hpg_core/bmg/sysman_product_helper_bmg.cpp
View File

@@ -982,6 +982,11 @@ bool SysmanProductHelperHw<gfxProduct>::isZesInitSupported() {
return true;
}
template <>
bool SysmanProductHelperHw<gfxProduct>::isLateBindingSupported() {
return true;
}
template class SysmanProductHelperHw<gfxProduct>;
} // namespace Sysman

1
level_zero/sysman/test/unit_tests/sources/diagnostics/linux/mock_zes_sysman_diagnostics.h
View File

@@ -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<std::string> & fwTypes));
ADDMETHOD_NOBASE_VOIDRETURN(fwGetMemoryHealthIndicator, (zes_mem_health_t * health));
ADDMETHOD_NOBASE_VOIDRETURN(getLateBindingSupportedFwTypes, (std::vector<std::string> & fwTypes));
};
struct MockGlobalOperationsEngineHandleContext : public L0::Sysman::EngineHandleContext {
MockGlobalOperationsEngineHandleContext(L0::Sysman::OsSysman *pOsSysman) : EngineHandleContext(pOsSysman) {}

1
level_zero/sysman/test/unit_tests/sources/ecc/linux/mock_ecc.h
View File

@@ -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<std::string> & fwTypes));
ADDMETHOD_NOBASE_VOIDRETURN(fwGetMemoryHealthIndicator, (zes_mem_health_t * health));
ADDMETHOD_NOBASE_VOIDRETURN(getLateBindingSupportedFwTypes, (std::vector<std::string> & fwTypes));
MockEccFwInterface() = default;
~MockEccFwInterface() override = default;

1
level_zero/sysman/test/unit_tests/sources/ecc/windows/mock_ecc.h
View File

@@ -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<std::string> & fwTypes));
ADDMETHOD_NOBASE_VOIDRETURN(fwGetMemoryHealthIndicator, (zes_mem_health_t * health));
ADDMETHOD_NOBASE_VOIDRETURN(getLateBindingSupportedFwTypes, (std::vector<std::string> & fwTypes));
};
} // namespace ult

1
level_zero/sysman/test/unit_tests/sources/events/linux/mock_events.h
View File

@@ -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<std::string> & fwTypes));
ADDMETHOD_NOBASE_VOIDRETURN(fwGetMemoryHealthIndicator, (zes_mem_health_t * health));
ADDMETHOD_NOBASE_VOIDRETURN(getLateBindingSupportedFwTypes, (std::vector<std::string> & fwTypes));
};
struct MockEventNeoDrm : public Drm {

4
level_zero/sysman/test/unit_tests/sources/firmware/linux/mock_zes_sysman_firmware.h
View File

@@ -105,6 +105,10 @@ struct MockFirmwareInterface : public FirmwareInterface {
}
}
void getLateBindingSupportedFwTypes(std::vector<std::string> &fwTypes) override {
fwTypes.insert(fwTypes.end(), lateBindingFirmwareTypes.begin(), lateBindingFirmwareTypes.end());
}
MockFirmwareInterface() = default;
ADDMETHOD_NOBASE(fwDeviceInit, ze_result_t, ZE_RESULT_SUCCESS, ());

57
level_zero/sysman/test/unit_tests/sources/firmware/linux/test_zes_sysman_firmware.cpp
View File

@@ -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 <algorithm>
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<zes_firmware_handle_t> firmwareHandle{};
uint32_t count = 0;
ze_result_t result = zesDeviceEnumFirmwares(device->toHandle(), &count, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, mockFwHandlesCount);
uint32_t testCount = count + 1;
result = zesDeviceEnumFirmwares(device->toHandle(), &testCount, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(testCount, count);
firmwareHandle.resize(count);
result = zesDeviceEnumFirmwares(device->toHandle(), &count, firmwareHandle.data());
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, mockFwHandlesCount);
}
HWTEST2_F(ZesSysmanFirmwareFixture, GivenValidLateBindingFirmwareHandleWhenFlashingFirmwareThenSuccessIsReturned, IsBMG) {
constexpr uint32_t mockFwHandlesCount = 5;
initFirmware();
auto handles = getFirmwareHandles(mockFwHandlesCount);
for (auto handle : handles) {
zes_firmware_properties_t properties = {};
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareGetProperties(handle, &properties));
if (std::find(lateBindingFirmwareTypes.begin(), lateBindingFirmwareTypes.end(), properties.name) != lateBindingFirmwareTypes.end()) {
uint8_t testImage[ZES_STRING_PROPERTY_SIZE] = {};
memset(testImage, 0xA, ZES_STRING_PROPERTY_SIZE);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareFlash(handle, (void *)testImage, ZES_STRING_PROPERTY_SIZE));
}
}
}
HWTEST2_F(ZesSysmanFirmwareFixture, GivenValidLateBindingFirmwareHandleWhenGettingFirmwarePropertiesThenValidVersionIsReturned, IsBMG) {
constexpr uint32_t mockFwHandlesCount = 5;
initFirmware();
auto handles = getFirmwareHandles(mockFwHandlesCount);
for (auto handle : handles) {
zes_firmware_properties_t properties = {};
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareGetProperties(handle, &properties));
if (std::find(lateBindingFirmwareTypes.begin(), lateBindingFirmwareTypes.end(), properties.name) != lateBindingFirmwareTypes.end()) {
EXPECT_STREQ(mockUnknownVersion.c_str(), properties.version);
}
}
}
} // namespace ult
} // namespace Sysman
} // namespace L0

44
level_zero/sysman/test/unit_tests/sources/firmware/windows/mock_zes_sysman_firmware.h
View File

@@ -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<std::string> mockSupportedFwTypes = {"GSC", "OptionROM"};
std::vector<std::string> mockUnsupportedFwTypes = {"unknown"};
std::string mockEmpty = {};
const std::vector<std::string> mockSupportedFwTypes = {"GSC", "OptionROM"};
const std::string mockUnknownVersion("unknown");
const std::vector<std::string> mockUnsupportedFwTypes = {"unknown"};
struct FirmwareInterface : public L0::Sysman::FirmwareUtil {
@@ -53,6 +53,10 @@ struct FirmwareInterface : public L0::Sysman::FirmwareUtil {
fwTypes = mockSupportedFwTypes;
}
void getLateBindingSupportedFwTypes(std::vector<std::string> &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<FirmwareInterface> 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<zes_firmware_handle_t> getFirmwareHandles(uint32_t count) {
std::vector<zes_firmware_handle_t> handles(count, nullptr);
EXPECT_EQ(zesDeviceEnumFirmwares(pSysmanDevice->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS);
return handles;
}
};
} // namespace ult
} // namespace Sysman
} // namespace L0

78
level_zero/sysman/test/unit_tests/sources/firmware/windows/test_zes_sysman_firmware.cpp
View File

@@ -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<FirmwareInterface> 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<zes_firmware_handle_t> getFirmwareHandles(uint32_t count) {
std::vector<zes_firmware_handle_t> handles(count, nullptr);
EXPECT_EQ(zesDeviceEnumFirmwares(pSysmanDevice->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS);
return handles;
}
};
TEST_F(ZesFirmwareFixture, GivenComponentCountZeroWhenCallingzesFirmwareGetThenZeroCountIsReturnedAndVerifyzesFirmwareGetCallSucceeds) {
std::vector<zes_firmware_handle_t> 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();

1
level_zero/sysman/test/unit_tests/sources/firmware_util/mock_fw_util_fixture.h
View File

@@ -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<std::string> & fwTypes));
ADDMETHOD_NOBASE_VOIDRETURN(getLateBindingSupportedFwTypes, (std::vector<std::string> & fwTypes));
void fwGetMemoryHealthIndicator(zes_mem_health_t *health) override {
*health = fwGetMemoryHealthIndicatorResult;

78
level_zero/sysman/test/unit_tests/sources/firmware_util/test_fw_util_helper.cpp
View File

@@ -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<decltype(L0::Sysman::deviceUpdateLateBindingConfig)> 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<OsLibrary *>(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<decltype(L0::Sysman::deviceUpdateLateBindingConfig)> 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<OsLibrary *>(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<decltype(L0::Sysman::deviceUpdateLateBindingConfig)> 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<OsLibrary *>(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<OsLibrary *>(new MockFwUtilOsLibrary());
std::vector<std ::string> 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

1
level_zero/sysman/test/unit_tests/sources/global_operations/linux/mock_global_operations.h
View File

@@ -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<std::string> & fwTypes));
ADDMETHOD_NOBASE_VOIDRETURN(fwGetMemoryHealthIndicator, (zes_mem_health_t * health));
ADDMETHOD_NOBASE_VOIDRETURN(getLateBindingSupportedFwTypes, (std::vector<std::string> & fwTypes));
};
struct MockGlobalOpsLinuxSysmanImp : public L0::Sysman::LinuxSysmanImp {

1
level_zero/sysman/test/unit_tests/sources/ras/linux/mock_sysman_ras.h
View File

@@ -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<std::string> & fwTypes));
};
struct MockRasNeoDrm : public Drm {

3
level_zero/sysman/test/unit_tests/sources/shared/windows/product_helper/CMakeLists.txt
View File

@@ -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()

117
level_zero/sysman/test/unit_tests/sources/shared/windows/product_helper/sysman_product_helper_firmware_tests.cpp Normal file
View File

@@ -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 <algorithm>
namespace L0 {
namespace Sysman {
namespace ult {
HWTEST2_F(ZesFirmwareFixture, GivenComponentCountZeroWhenCallingZesFirmwareGetThenZeroCountIsReturnedAndVerifyZesFirmwareGetCallSucceeds, IsNotBMG) {
std::vector<zes_firmware_handle_t> 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<zes_firmware_handle_t> 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