intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-18 22:08:53 +08:00
Code Issues Packages Projects Releases Wiki Activity

refactor: Merge prelim and non-prelim part for firmware

Browse Source 
Related-To: NEO-11203

Signed-off-by: Bellekallu Rajkiran <bellekallu.rajkiran@intel.com>
This commit is contained in:
Bellekallu Rajkiran
2024-05-17 12:26:12 +00:00
committed by Compute-Runtime-Automation
parent 101c914b1f
commit 9f4c1b3daf
8 changed files with 270 additions and 667 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
level_zero/sysman/source/api/firmware/linux/CMakeLists.txt
View File

@@ -1,5 +1,5 @@
#
# Copyright (C) 2020-2023 Intel Corporation
# Copyright (C) 2020-2024 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
@@ -10,17 +10,6 @@ if(UNIX)
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/sysman_os_firmware_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/sysman_os_firmware_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/sysman_os_firmware_imp_helper.cpp
)
if(NEO_ENABLE_i915_PRELIM_DETECTION)
target_sources(${L0_STATIC_LIB_NAME}
PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/sysman_os_firmware_imp_helper_prelim.cpp
)
else()
target_sources(${L0_STATIC_LIB_NAME}
PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/sysman_os_firmware_imp_helper.cpp
)
endif()
endif()

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

@@ -1,22 +1,63 @@
/*
* Copyright (C) 2021-2023 Intel Corporation
* Copyright (C) 2021-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/debug_settings/debug_settings_manager.h"
#include "level_zero/sysman/source/api/firmware/linux/sysman_os_firmware_imp.h"
#include "level_zero/sysman/source/shared/firmware_util/sysman_firmware_util.h"
#include "level_zero/sysman/source/shared/linux/sysman_fs_access_interface.h"
const std::string iafPath = "device/";
const std::string iafDirectory = "iaf.";
const std::string pscbinVersion = "/pscbin_version";
namespace L0 {
namespace Sysman {
ze_result_t LinuxFirmwareImp::getFirmwareVersion(std::string fwType, zes_firmware_properties_t *pProperties) {
std::string fwVersion;
if (fwType == "PSC") {
std::string path;
path.clear();
std::vector<std::string> list;
// scans the directories present in /sys/class/drm/cardX/device/
ze_result_t result = pSysfsAccess->scanDirEntries(iafPath, list);
if (ZE_RESULT_SUCCESS != result) {
// There should be a device directory
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Failed to scan directories at %s and returning error:0x%x \n", __FUNCTION__, iafPath.c_str(), result);
return result;
}
for (const auto &entry : list) {
if (!iafDirectory.compare(entry.substr(0, iafDirectory.length()))) {
// device/iaf.X/pscbin_version, where X is the hardware slot number
path = iafPath + entry + pscbinVersion;
}
}
if (path.empty()) {
// This device does not have a PSC Version
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): device does not have a PSC version and returning error:0x%x \n", __FUNCTION__, ZE_RESULT_ERROR_NOT_AVAILABLE);
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
std::string pscVersion;
pscVersion.clear();
result = pSysfsAccess->read(path, pscVersion);
if (ZE_RESULT_SUCCESS != result) {
// not able to read PSC version from iaf.x
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Failed to read PSC version from iaf.x at %s and returning error:0x%x \n", __FUNCTION__, path.c_str(), result);
return result;
}
strncpy_s(static_cast<char *>(pProperties->version), ZES_STRING_PROPERTY_SIZE, pscVersion.c_str(), ZES_STRING_PROPERTY_SIZE - 1);
return result;
}
ze_result_t result = pFwInterface->getFwVersion(fwType, fwVersion);
if (ZE_RESULT_SUCCESS == result) {
if (result == ZE_RESULT_SUCCESS) {
strncpy_s(static_cast<char *>(pProperties->version), ZES_STRING_PROPERTY_SIZE, fwVersion.c_str(), ZES_STRING_PROPERTY_SIZE - 1);
}
return result;
}

65
level_zero/sysman/source/api/firmware/linux/sysman_os_firmware_imp_helper_prelim.cpp
View File

@@ -1,65 +0,0 @@
/*
* Copyright (C) 2021-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/debug_settings/debug_settings_manager.h"
#include "level_zero/sysman/source/api/firmware/linux/sysman_os_firmware_imp.h"
#include "level_zero/sysman/source/shared/firmware_util/sysman_firmware_util.h"
#include "level_zero/sysman/source/shared/linux/sysman_fs_access_interface.h"
const std::string iafPath = "device/";
const std::string iafDirectory = "iaf.";
const std::string pscbinVersion = "/pscbin_version";
namespace L0 {
namespace Sysman {
ze_result_t LinuxFirmwareImp::getFirmwareVersion(std::string fwType, zes_firmware_properties_t *pProperties) {
std::string fwVersion;
if (fwType == "PSC") {
std::string path;
path.clear();
std::vector<std::string> list;
// scans the directories present in /sys/class/drm/cardX/device/
ze_result_t result = pSysfsAccess->scanDirEntries(iafPath, list);
if (ZE_RESULT_SUCCESS != result) {
// There should be a device directory
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Failed to scan directories at %s and returning error:0x%x \n", __FUNCTION__, iafPath.c_str(), result);
return result;
}
for (const auto &entry : list) {
if (!iafDirectory.compare(entry.substr(0, iafDirectory.length()))) {
// device/iaf.X/pscbin_version, where X is the hardware slot number
path = iafPath + entry + pscbinVersion;
}
}
if (path.empty()) {
// This device does not have a PSC Version
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): device does not have a PSC version and returning error:0x%x \n", __FUNCTION__, ZE_RESULT_ERROR_NOT_AVAILABLE);
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
std::string pscVersion;
pscVersion.clear();
result = pSysfsAccess->read(path, pscVersion);
if (ZE_RESULT_SUCCESS != result) {
// not able to read PSC version from iaf.x
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Failed to read PSC version from iaf.x at %s and returning error:0x%x \n", __FUNCTION__, path.c_str(), result);
return result;
}
strncpy_s(static_cast<char *>(pProperties->version), ZES_STRING_PROPERTY_SIZE, pscVersion.c_str(), ZES_STRING_PROPERTY_SIZE - 1);
return result;
}
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);
}
return result;
}
} // namespace Sysman
} // namespace L0

17
level_zero/sysman/test/unit_tests/sources/firmware/linux/CMakeLists.txt
View File

@@ -1,26 +1,15 @@
#
# Copyright (C) 2020-2023 Intel Corporation
# Copyright (C) 2020-2024 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
set(L0_TESTS_SYSMAN_FIRMWARE_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/test_zes_sysman_firmware.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_zes_sysman_firmware.h
)
if(NEO_ENABLE_i915_PRELIM_DETECTION)
list(APPEND L0_TESTS_SYSMAN_FIRMWARE_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/test_zes_sysman_firmware_prelim.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_zes_sysman_firmware_prelim.h
)
else()
list(APPEND L0_TESTS_SYSMAN_FIRMWARE_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/test_zes_sysman_firmware.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_zes_sysman_firmware.h
)
endif()
if(UNIX)
target_sources(${TARGET_NAME}
PRIVATE

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

@@ -14,21 +14,25 @@ namespace L0 {
namespace Sysman {
namespace ult {
constexpr uint32_t mockHandleCount = 2;
constexpr uint32_t mockFwHandlesCount = 3;
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"};
const std::string mockPscVersion("version 1 : 2021/09/15 00:43:12");
const std::string mockUnknownVersion("unknown");
std::vector<std::string> mockSupportedFirmwareTypes = {"GSC", "OptionROM", "PSC"};
std::vector<std::string> mockUnsupportedFwTypes = {"unknown"};
std::string mockEmpty = {};
class FirmwareInterface : public L0::Sysman::FirmwareUtil {};
class FirmwareFsAccess : public L0::Sysman::FsAccessInterface {};
class FirmwareSysfsAccess : public L0::Sysman::SysFsAccessInterface {};
struct MockFirmwareFsAccess : public FirmwareFsAccess {
ze_bool_t isReadFwTypes = true;
ze_result_t read(const std::string file, std::vector<std::string> &val) override {
if (isReadFwTypes) {
val.push_back("mtd3: 005ef000 00001000 \"i915-spi.42.auto.GSC\"");
val.push_back("mtd5: 00200000 00001000 \"i915-spi.42.auto.OptionROM\"");
val.push_back("mtd4: 00200000 00001000 \"i915-spi.42.auto.OptionROM\"");
val.push_back("mtd5: 00200000 00001000 \"i915-spi.42.auto.PSC\"");
} else {
val.push_back("mtd3: 005ef000 00001000 \"i915-spi.42.auto.GSC\"");
val.push_back("mtd3: 005ef000 00001000 \"i915-spi.42.auto.GSC\"");
@@ -37,18 +41,60 @@ struct MockFirmwareFsAccess : public FirmwareFsAccess {
}
};
struct MockFirmwareInterface : public L0::Sysman::FirmwareUtil {
struct MockFirmwareSysfsAccess : public L0::Sysman::SysFsAccessInterface {
ze_result_t readResult = ZE_RESULT_SUCCESS;
ze_result_t scanDirEntriesResult = ZE_RESULT_SUCCESS;
ze_bool_t isNullDirEntries = false;
ze_result_t read(const std::string file, std::string &val) override {
if (readResult != ZE_RESULT_SUCCESS) {
return readResult;
}
if (!file.compare("device/iaf.31/pscbin_version") || !file.compare("device/iaf.0/pscbin_version")) {
val = mockPscVersion;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t scanDirEntries(const std::string dir, std::vector<std::string> &list) override {
if (scanDirEntriesResult != ZE_RESULT_SUCCESS) {
return scanDirEntriesResult;
}
if (!isNullDirEntries) {
if (!dir.compare("device/")) {
list.push_back(std::string("unusedfile"));
list.push_back(std::string("iaf.31"));
list.push_back(std::string("iaf.0"));
}
} else {
if (!dir.compare("device/")) {
list.clear();
}
}
return ZE_RESULT_SUCCESS;
}
MockFirmwareSysfsAccess() = default;
~MockFirmwareSysfsAccess() override = default;
};
struct MockFirmwareInterface : public FirmwareInterface {
ze_result_t getFwVersionResult = ZE_RESULT_SUCCESS;
ze_result_t mockFwGetVersion(std::string &fwVersion) {
fwVersion = mockFwVersion;
return ZE_RESULT_SUCCESS;
}
ze_result_t mockOpromGetVersion(std::string &fwVersion) {
fwVersion = mockOpromVersion;
return ZE_RESULT_SUCCESS;
}
ze_result_t mockPscGetVersion(std::string &fwVersion) {
fwVersion = mockPscVersion;
return ZE_RESULT_SUCCESS;
}
ze_result_t getFwVersion(std::string fwType, std::string &firmwareVersion) override {
if (getFwVersionResult != ZE_RESULT_SUCCESS) {
@@ -59,12 +105,14 @@ struct MockFirmwareInterface : public L0::Sysman::FirmwareUtil {
firmwareVersion = mockFwVersion;
} else if (fwType == "OptionROM") {
firmwareVersion = mockOpromVersion;
} else if (fwType == "PSC") {
firmwareVersion = mockPscVersion;
}
return ZE_RESULT_SUCCESS;
}
void getDeviceSupportedFwTypes(std::vector<std::string> &fwTypes) override {
fwTypes = mockSupportedFwTypes;
fwTypes = mockSupportedFirmwareTypes;
}
MockFirmwareInterface() = default;

139
level_zero/sysman/test/unit_tests/sources/firmware/linux/mock_zes_sysman_firmware_prelim.h
View File

@@ -1,139 +0,0 @@
/*
* Copyright (C) 2022-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "level_zero/sysman/source/api/firmware/linux/sysman_os_firmware_imp.h"
#include "level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_fixture.h"
namespace L0 {
namespace Sysman {
namespace ult {
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 mockUnknownVersion("unknown");
std::vector<std::string> mockSupportedFirmwareTypes = {"GSC", "OptionROM", "PSC"};
std::vector<std::string> mockUnsupportedFwTypes = {"unknown"};
std::string mockEmpty = {};
class FirmwareInterface : public L0::Sysman::FirmwareUtil {};
class FirmwareFsAccess : public L0::Sysman::FsAccessInterface {};
class FirmwareSysfsAccess : public L0::Sysman::SysFsAccessInterface {};
struct MockFirmwareFsAccess : public FirmwareFsAccess {
ze_bool_t isReadFwTypes = true;
ze_result_t read(const std::string file, std::vector<std::string> &val) override {
if (isReadFwTypes) {
val.push_back("mtd3: 005ef000 00001000 \"i915-spi.42.auto.GSC\"");
val.push_back("mtd4: 00200000 00001000 \"i915-spi.42.auto.OptionROM\"");
val.push_back("mtd5: 00200000 00001000 \"i915-spi.42.auto.PSC\"");
} else {
val.push_back("mtd3: 005ef000 00001000 \"i915-spi.42.auto.GSC\"");
val.push_back("mtd3: 005ef000 00001000 \"i915-spi.42.auto.GSC\"");
}
return ZE_RESULT_SUCCESS;
}
};
struct MockFirmwareSysfsAccess : public L0::Sysman::SysFsAccessInterface {
ze_result_t readResult = ZE_RESULT_SUCCESS;
ze_result_t scanDirEntriesResult = ZE_RESULT_SUCCESS;
ze_bool_t isNullDirEntries = false;
ze_result_t read(const std::string file, std::string &val) override {
if (readResult != ZE_RESULT_SUCCESS) {
return readResult;
}
if (!file.compare("device/iaf.31/pscbin_version") || !file.compare("device/iaf.0/pscbin_version")) {
val = mockPscVersion;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t scanDirEntries(const std::string dir, std::vector<std::string> &list) override {
if (scanDirEntriesResult != ZE_RESULT_SUCCESS) {
return scanDirEntriesResult;
}
if (!isNullDirEntries) {
if (!dir.compare("device/")) {
list.push_back(std::string("unusedfile"));
list.push_back(std::string("iaf.31"));
list.push_back(std::string("iaf.0"));
}
} else {
if (!dir.compare("device/")) {
list.clear();
}
}
return ZE_RESULT_SUCCESS;
}
MockFirmwareSysfsAccess() = default;
~MockFirmwareSysfsAccess() override = default;
};
struct MockFirmwareInterface : public FirmwareInterface {
ze_result_t getFwVersionResult = ZE_RESULT_SUCCESS;
ze_result_t mockFwGetVersion(std::string &fwVersion) {
return ZE_RESULT_SUCCESS;
}
ze_result_t mockOpromGetVersion(std::string &fwVersion) {
fwVersion = mockOpromVersion;
return ZE_RESULT_SUCCESS;
}
ze_result_t mockPscGetVersion(std::string &fwVersion) {
fwVersion = mockPscVersion;
return ZE_RESULT_SUCCESS;
}
ze_result_t getFwVersion(std::string fwType, std::string &firmwareVersion) override {
if (getFwVersionResult != ZE_RESULT_SUCCESS) {
return getFwVersionResult;
}
if (fwType == "GSC") {
firmwareVersion = mockFwVersion;
} else if (fwType == "OptionROM") {
firmwareVersion = mockOpromVersion;
} else if (fwType == "PSC") {
firmwareVersion = mockPscVersion;
}
return ZE_RESULT_SUCCESS;
}
void getDeviceSupportedFwTypes(std::vector<std::string> &fwTypes) override {
fwTypes = mockSupportedFirmwareTypes;
}
MockFirmwareInterface() = default;
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));
ADDMETHOD_NOBASE(fwIfrApplied, ze_result_t, ZE_RESULT_SUCCESS, (bool &ifrStatus));
ADDMETHOD_NOBASE(fwSupportedDiagTests, ze_result_t, ZE_RESULT_SUCCESS, (std::vector<std::string> & supportedDiagTests));
ADDMETHOD_NOBASE(fwRunDiagTests, ze_result_t, ZE_RESULT_SUCCESS, (std::string & osDiagType, zes_diag_result_t *pResult));
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(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));
};
class PublicLinuxFirmwareImp : public L0::Sysman::LinuxFirmwareImp {
public:
using LinuxFirmwareImp::pFwInterface;
};
} // namespace ult
} // namespace Sysman
} // namespace L0

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

@@ -12,7 +12,7 @@ namespace L0 {
namespace Sysman {
namespace ult {
class ZesFirmwareFixture : public SysmanDeviceFixture {
class ZesSysmanFirmwareFixture : public SysmanDeviceFixture {
protected:
zes_firmware_handle_t hSysmanFirmware = {};
@@ -20,6 +20,8 @@ class ZesFirmwareFixture : public SysmanDeviceFixture {
L0::Sysman::FirmwareUtil *pFwUtilInterfaceOld = nullptr;
std::unique_ptr<MockFirmwareFsAccess> pFsAccess;
L0::Sysman::FsAccessInterface *pFsAccessOriginal = nullptr;
L0::Sysman::SysFsAccessInterface *pSysFsAccessOriginal = nullptr;
std::unique_ptr<MockFirmwareSysfsAccess> pMockSysfsAccess;
L0::Sysman::SysmanDevice *device = nullptr;
void SetUp() override {
@@ -28,25 +30,32 @@ class ZesFirmwareFixture : public SysmanDeviceFixture {
pFsAccess = std::make_unique<MockFirmwareFsAccess>();
pLinuxSysmanImp->pFsAccess = pFsAccess.get();
pSysFsAccessOriginal = pLinuxSysmanImp->pSysfsAccess;
pMockSysfsAccess = std::make_unique<MockFirmwareSysfsAccess>();
pLinuxSysmanImp->pSysfsAccess = pMockSysfsAccess.get();
pFwUtilInterfaceOld = pLinuxSysmanImp->pFwUtilInterface;
pMockFwInterface = std::make_unique<MockFirmwareInterface>();
pLinuxSysmanImp->pFwUtilInterface = pMockFwInterface.get();
for (const auto &handle : pSysmanDeviceImp->pFirmwareHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pFirmwareHandleContext->handleList.clear();
device = pSysmanDeviceImp;
}
void TearDown() override {
pLinuxSysmanImp->pFwUtilInterface = pFwUtilInterfaceOld;
pLinuxSysmanImp->pFsAccess = pFsAccessOriginal;
SysmanDeviceFixture::TearDown();
}
void initFirmware() {
uint32_t count = 0;
ze_result_t result = zesDeviceEnumFirmwares(device->toHandle(), &count, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
}
void TearDown() override {
pLinuxSysmanImp->pFwUtilInterface = pFwUtilInterfaceOld;
pLinuxSysmanImp->pFsAccess = pFsAccessOriginal;
pLinuxSysmanImp->pSysfsAccess = pSysFsAccessOriginal;
SysmanDeviceFixture::TearDown();
}
std::vector<zes_firmware_handle_t> getFirmwareHandles(uint32_t count) {
std::vector<zes_firmware_handle_t> handles(count, nullptr);
EXPECT_EQ(zesDeviceEnumFirmwares(device->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS);
@@ -54,14 +63,14 @@ class ZesFirmwareFixture : public SysmanDeviceFixture {
}
};
HWTEST2_F(ZesFirmwareFixture, GivenComponentCountZeroWhenCallingzesFirmwareGetThenZeroCountIsReturnedAndVerifyzesFirmwareGetCallSucceeds, IsXeHpcOrXeHpgCore) {
HWTEST2_F(ZesSysmanFirmwareFixture, GivenComponentCountZeroWhenCallingzesFirmwareGetThenZeroCountIsReturnedAndVerifyzesFirmwareGetCallSucceeds, IsXeHpcOrXeHpgCore) {
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, mockHandleCount);
EXPECT_EQ(count, mockFwHandlesCount);
uint32_t testCount = count + 1;
@@ -74,14 +83,14 @@ HWTEST2_F(ZesFirmwareFixture, GivenComponentCountZeroWhenCallingzesFirmwareGetTh
result = zesDeviceEnumFirmwares(device->toHandle(), &count, firmwareHandle.data());
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, mockHandleCount);
EXPECT_EQ(count, mockFwHandlesCount);
L0::Sysman::FirmwareImp *ptestFirmwareImp = new L0::Sysman::FirmwareImp(pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman, mockSupportedFwTypes[0]);
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, mockHandleCount);
EXPECT_EQ(count, mockFwHandlesCount);
testCount = count;
@@ -90,13 +99,13 @@ HWTEST2_F(ZesFirmwareFixture, GivenComponentCountZeroWhenCallingzesFirmwareGetTh
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, firmwareHandle.data());
EXPECT_EQ(testCount, mockHandleCount);
EXPECT_EQ(testCount, mockFwHandlesCount);
pSysmanDeviceImp->pFirmwareHandleContext->handleList.pop_back();
delete ptestFirmwareImp;
}
TEST_F(ZesFirmwareFixture, GivenValidDeviceHandleAndFirmwareUnSupportedWhenCallingEnumerateThenVerifyFirmwareDomainsAreZero) {
TEST_F(ZesSysmanFirmwareFixture, GivenValidDeviceHandleAndFirmwareUnSupportedWhenCallingEnumerateThenVerifyFirmwareDomainsAreZero) {
struct MockSysmanProductHelperFirmware : L0::Sysman::SysmanProductHelperHw<IGFX_UNKNOWN> {
MockSysmanProductHelperFirmware() = default;
@@ -114,15 +123,14 @@ TEST_F(ZesFirmwareFixture, GivenValidDeviceHandleAndFirmwareUnSupportedWhenCalli
EXPECT_EQ(count, 0u);
}
HWTEST2_F(ZesFirmwareFixture, GivenValidFirmwareHandleWhenGettingFirmwarePropertiesThenVersionIsReturned, IsXeHpcOrXeHpgCore) {
HWTEST2_F(ZesSysmanFirmwareFixture, GivenValidFirmwareHandleWhenGettingFirmwarePropertiesThenVersionIsReturned, IsXeHpcOrXeHpgCore) {
initFirmware();
L0::Sysman::FirmwareImp *ptestFirmwareImp = new L0::Sysman::FirmwareImp(pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman, mockSupportedFwTypes[0]);
L0::Sysman::FirmwareImp *ptestFirmwareImp = new L0::Sysman::FirmwareImp(pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman, mockSupportedFirmwareTypes[0]);
pSysmanDeviceImp->pFirmwareHandleContext->handleList.push_back(ptestFirmwareImp);
auto handles = getFirmwareHandles(mockHandleCount);
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);
@@ -132,43 +140,63 @@ HWTEST2_F(ZesFirmwareFixture, GivenValidFirmwareHandleWhenGettingFirmwarePropert
delete ptestFirmwareImp;
}
HWTEST2_F(ZesFirmwareFixture, GivenValidFirmwareHandleWhenGettingOptionRomPropertiesThenVersionIsReturned, IsXeHpcOrXeHpgCore) {
HWTEST2_F(ZesSysmanFirmwareFixture, GivenValidFirmwareHandleWhenGettingPscPropertiesThenVersionIsReturned, IsXeHpcOrXeHpgCore) {
initFirmware();
L0::Sysman::FirmwareImp *pTestFirmwareImp = new L0::Sysman::FirmwareImp(pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman, mockSupportedFwTypes[1]);
pSysmanDeviceImp->pFirmwareHandleContext->handleList.push_back(pTestFirmwareImp);
auto handles = getFirmwareHandles(mockHandleCount);
zes_firmware_properties_t properties = {};
ASSERT_NE(nullptr, handles[1]);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareGetProperties(handles[1], &properties));
EXPECT_STREQ(mockSupportedFwTypes[1].c_str(), properties.name);
EXPECT_STREQ(mockOpromVersion.c_str(), properties.version);
pSysmanDeviceImp->pFirmwareHandleContext->handleList.pop_back();
delete pTestFirmwareImp;
}
HWTEST2_F(ZesFirmwareFixture, GivenValidFirmwareHandleWhenGettingOpromPropertiesThenVersionIsReturned, IsXeHpcOrXeHpgCore) {
initFirmware();
L0::Sysman::FirmwareImp *ptestFirmwareImp = new L0::Sysman::FirmwareImp(pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman, mockSupportedFwTypes[1]);
L0::Sysman::FirmwareImp *ptestFirmwareImp = new L0::Sysman::FirmwareImp(pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman, mockSupportedFirmwareTypes[2]);
pSysmanDeviceImp->pFirmwareHandleContext->handleList.push_back(ptestFirmwareImp);
auto handles = getFirmwareHandles(mockHandleCount);
auto handles = getFirmwareHandles(mockFwHandlesCount);
ASSERT_NE(nullptr, handles[2]);
zes_firmware_properties_t properties = {};
ASSERT_NE(nullptr, handles[1]);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareGetProperties(handles[1], &properties));
EXPECT_STREQ(mockSupportedFwTypes[1].c_str(), properties.name);
EXPECT_STREQ(mockOpromVersion.c_str(), properties.version);
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(ZesFirmwareFixture, GivenRepeatedFWTypesWhenInitializingFirmwareContextThenexpectNoHandles, IsXeHpcOrXeHpgCore) {
HWTEST2_F(ZesSysmanFirmwareFixture, GivenNullDirEntriesWhenGettingPscPropertiesThenUnknownVersionIsReturned, IsXeHpcOrXeHpgCore) {
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, IsXeHpcOrXeHpgCore) {
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, GivenRepeatedFWTypesWhenInitializingFirmwareContextThenexpectNoHandles, IsXeHpcOrXeHpgCore) {
for (const auto &handle : pSysmanDeviceImp->pFirmwareHandleContext->handleList) {
delete handle;
}
@@ -180,13 +208,13 @@ HWTEST2_F(ZesFirmwareFixture, GivenRepeatedFWTypesWhenInitializingFirmwareContex
EXPECT_EQ(1u, pSysmanDeviceImp->pFirmwareHandleContext->handleList.size());
}
HWTEST2_F(ZesFirmwareFixture, GivenValidFirmwareHandleWhenFlashingGscFirmwareThenSuccessIsReturned, IsXeHpcOrXeHpgCore) {
HWTEST2_F(ZesSysmanFirmwareFixture, GivenValidFirmwareHandleWhenFlashingGscFirmwareThenSuccessIsReturned, IsXeHpcOrXeHpgCore) {
initFirmware();
L0::Sysman::FirmwareImp *ptestFirmwareImp = new L0::Sysman::FirmwareImp(pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman, mockSupportedFwTypes[0]);
L0::Sysman::FirmwareImp *ptestFirmwareImp = new L0::Sysman::FirmwareImp(pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman, mockSupportedFirmwareTypes[0]);
pSysmanDeviceImp->pFirmwareHandleContext->handleList.push_back(ptestFirmwareImp);
auto handles = getFirmwareHandles(mockHandleCount);
auto handles = getFirmwareHandles(mockFwHandlesCount);
uint8_t testImage[ZES_STRING_PROPERTY_SIZE] = {};
memset(testImage, 0xA, ZES_STRING_PROPERTY_SIZE);
for (auto handle : handles) {
@@ -197,7 +225,24 @@ HWTEST2_F(ZesFirmwareFixture, GivenValidFirmwareHandleWhenFlashingGscFirmwareThe
delete ptestFirmwareImp;
}
TEST_F(ZesFirmwareFixture, GivenValidFirmwareHandleWhenFlashingUnkownFirmwareThenFailureIsReturned) {
HWTEST2_F(ZesSysmanFirmwareFixture, GivenValidFirmwareHandleWhenFlashingPscFirmwareThenSuccessIsReturned, IsXeHpcOrXeHpgCore) {
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;
}
@@ -216,7 +261,37 @@ TEST_F(ZesFirmwareFixture, GivenValidFirmwareHandleWhenFlashingUnkownFirmwareThe
delete ptestFirmwareImp;
}
HWTEST2_F(ZesFirmwareFixture, GivenNewFirmwareContextWithHandleSizeZeroWhenFirmwareEnumerateIsCalledThenSuccessResultIsReturned, IsXeHpcOrXeHpgCore) {
HWTEST2_F(ZesSysmanFirmwareFixture, GivenValidFirmwareHandleFirmwareLibraryCallFailureWhenGettingFirmwarePropertiesThenUnknownIsReturned, IsXeHpcOrXeHpgCore) {
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, IsXeHpcOrXeHpgCore) {
uint32_t count = 0;
L0::Sysman::OsSysman *pOsSysman = pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman;
@@ -230,29 +305,57 @@ HWTEST2_F(ZesFirmwareFixture, GivenNewFirmwareContextWithHandleSizeZeroWhenFirmw
EXPECT_EQ(0u, pSysmanDeviceImp->pFirmwareHandleContext->handleList.size());
ze_result_t result = zesDeviceEnumFirmwares(device->toHandle(), &count, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(true, (count > 0));
EXPECT_EQ(3u, count);
}
HWTEST2_F(ZesFirmwareFixture, GivenValidFirmwareHandleFirmwareLibraryCallFailureWhenGettingFirmwarePropertiesThenUnknownIsReturned, IsXeHpcOrXeHpgCore) {
for (const auto &handle : pSysmanDeviceImp->pFirmwareHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pFirmwareHandleContext->handleList.clear();
pMockFwInterface->getFwVersionResult = ZE_RESULT_ERROR_UNINITIALIZED;
HWTEST2_F(ZesSysmanFirmwareFixture, GivenValidFirmwareHandleWhenGettingFirmwareFlashProgressThenSuccessIsReturned, IsXeHpcOrXeHpgCore) {
initFirmware();
pSysmanDeviceImp->pFirmwareHandleContext->init();
auto handles = getFirmwareHandles(mockHandleCount);
L0::Sysman::FirmwareImp *ptestFirmwareImp = new L0::Sysman::FirmwareImp(pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman, mockSupportedFirmwareTypes[1]);
pSysmanDeviceImp->pFirmwareHandleContext->handleList.push_back(ptestFirmwareImp);
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);
auto handles = getFirmwareHandles(mockFwHandlesCount);
uint32_t completionPercent = 0;
ASSERT_NE(nullptr, handles[1]);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareGetProperties(handles[1], &properties));
EXPECT_STREQ(mockSupportedFwTypes[1].c_str(), properties.name);
EXPECT_STREQ("unknown", properties.version);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareGetFlashProgress(handles[1], &completionPercent));
}
HWTEST2_F(ZesSysmanFirmwareFixture, GivenValidFirmwareHandleWhenGettingFirmwareSecurityVersionThenUnSupportedIsReturned, IsXeHpcOrXeHpgCore) {
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, IsXeHpcOrXeHpgCore) {
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, IsXeHpcOrXeHpgCore) {
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

363
level_zero/sysman/test/unit_tests/sources/firmware/linux/test_zes_sysman_firmware_prelim.cpp
View File

@@ -1,363 +0,0 @@
/*
* Copyright (C) 2022-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#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_prelim.h"
namespace L0 {
namespace Sysman {
namespace ult {
class ZesSysmanFirmwareFixture : public SysmanDeviceFixture {
protected:
zes_firmware_handle_t hSysmanFirmware = {};
std::unique_ptr<MockFirmwareInterface> pMockFwInterface;
L0::Sysman::FirmwareUtil *pFwUtilInterfaceOld = nullptr;
std::unique_ptr<MockFirmwareFsAccess> pFsAccess;
L0::Sysman::FsAccessInterface *pFsAccessOriginal = nullptr;
L0::Sysman::SysFsAccessInterface *pSysFsAccessOriginal = nullptr;
std::unique_ptr<MockFirmwareSysfsAccess> pMockSysfsAccess;
L0::Sysman::SysmanDevice *device = nullptr;
void SetUp() override {
SysmanDeviceFixture::SetUp();
pFsAccessOriginal = pLinuxSysmanImp->pFsAccess;
pFsAccess = std::make_unique<MockFirmwareFsAccess>();
pLinuxSysmanImp->pFsAccess = pFsAccess.get();
pSysFsAccessOriginal = pLinuxSysmanImp->pSysfsAccess;
pMockSysfsAccess = std::make_unique<MockFirmwareSysfsAccess>();
pLinuxSysmanImp->pSysfsAccess = pMockSysfsAccess.get();
pFwUtilInterfaceOld = pLinuxSysmanImp->pFwUtilInterface;
pMockFwInterface = std::make_unique<MockFirmwareInterface>();
pLinuxSysmanImp->pFwUtilInterface = pMockFwInterface.get();
for (const auto &handle : pSysmanDeviceImp->pFirmwareHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pFirmwareHandleContext->handleList.clear();
device = pSysmanDeviceImp;
}
void initFirmware() {
uint32_t count = 0;
ze_result_t result = zesDeviceEnumFirmwares(device->toHandle(), &count, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
}
void TearDown() override {
pLinuxSysmanImp->pFwUtilInterface = pFwUtilInterfaceOld;
pLinuxSysmanImp->pFsAccess = pFsAccessOriginal;
pLinuxSysmanImp->pSysfsAccess = pSysFsAccessOriginal;
SysmanDeviceFixture::TearDown();
}
std::vector<zes_firmware_handle_t> getFirmwareHandles(uint32_t count) {
std::vector<zes_firmware_handle_t> handles(count, nullptr);
EXPECT_EQ(zesDeviceEnumFirmwares(device->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS);
return handles;
}
};
HWTEST2_F(ZesSysmanFirmwareFixture, GivenComponentCountZeroWhenCallingzesFirmwareGetThenZeroCountIsReturnedAndVerifyzesFirmwareGetCallSucceeds, IsXeHpcOrXeHpgCore) {
std::vector<zes_firmware_handle_t> firmwareHandle{};
uint32_t count = 0;
ze_result_t result = zesDeviceEnumFirmwares(device->toHandle(), &count, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, mockFwHandlesCount);
uint32_t testCount = count + 1;
result = zesDeviceEnumFirmwares(device->toHandle(), &testCount, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(testCount, count);
firmwareHandle.resize(count);
result = zesDeviceEnumFirmwares(device->toHandle(), &count, firmwareHandle.data());
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, mockFwHandlesCount);
L0::Sysman::FirmwareImp *ptestFirmwareImp = new L0::Sysman::FirmwareImp(pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman, mockSupportedFirmwareTypes[0]);
pSysmanDeviceImp->pFirmwareHandleContext->handleList.push_back(ptestFirmwareImp);
result = zesDeviceEnumFirmwares(device->toHandle(), &count, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, mockFwHandlesCount);
testCount = count;
firmwareHandle.resize(testCount);
result = zesDeviceEnumFirmwares(device->toHandle(), &testCount, firmwareHandle.data());
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, firmwareHandle.data());
EXPECT_EQ(testCount, mockFwHandlesCount);
pSysmanDeviceImp->pFirmwareHandleContext->handleList.pop_back();
delete ptestFirmwareImp;
}
TEST_F(ZesSysmanFirmwareFixture, GivenValidDeviceHandleAndFirmwareUnSupportedWhenCallingEnumerateThenVerifyFirmwareDomainsAreZero) {
struct MockSysmanProductHelperFirmware : L0::Sysman::SysmanProductHelperHw<IGFX_UNKNOWN> {
MockSysmanProductHelperFirmware() = default;
void getDeviceSupportedFwTypes(FirmwareUtil *pFwInterface, std::vector<std::string> &fwTypes) override {
return;
}
};
std::unique_ptr<SysmanProductHelper> pSysmanProductHelper = std::make_unique<MockSysmanProductHelperFirmware>();
std::swap(pLinuxSysmanImp->pSysmanProductHelper, pSysmanProductHelper);
uint32_t count = 0;
ze_result_t result = zesDeviceEnumFirmwares(device->toHandle(), &count, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, 0u);
}
HWTEST2_F(ZesSysmanFirmwareFixture, GivenValidFirmwareHandleWhenGettingFirmwarePropertiesThenVersionIsReturned, IsXeHpcOrXeHpgCore) {
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, IsXeHpcOrXeHpgCore) {
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, IsXeHpcOrXeHpgCore) {
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, IsXeHpcOrXeHpgCore) {
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, GivenRepeatedFWTypesWhenInitializingFirmwareContextThenexpectNoHandles, IsXeHpcOrXeHpgCore) {
for (const auto &handle : pSysmanDeviceImp->pFirmwareHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pFirmwareHandleContext->handleList.clear();
pFsAccess->isReadFwTypes = false;
pSysmanDeviceImp->pFirmwareHandleContext->init();
EXPECT_EQ(1u, pSysmanDeviceImp->pFirmwareHandleContext->handleList.size());
}
HWTEST2_F(ZesSysmanFirmwareFixture, GivenValidFirmwareHandleWhenFlashingGscFirmwareThenSuccessIsReturned, IsXeHpcOrXeHpgCore) {
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, IsXeHpcOrXeHpgCore) {
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;
}
pSysmanDeviceImp->pFirmwareHandleContext->handleList.clear();
L0::Sysman::FirmwareImp *ptestFirmwareImp = new L0::Sysman::FirmwareImp(pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman, mockUnsupportedFwTypes[0]);
pSysmanDeviceImp->pFirmwareHandleContext->handleList.push_back(ptestFirmwareImp);
pMockFwInterface->flashFirmwareResult = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
uint8_t testImage[ZES_STRING_PROPERTY_SIZE] = {};
memset(testImage, 0xA, ZES_STRING_PROPERTY_SIZE);
auto handle = pSysmanDeviceImp->pFirmwareHandleContext->handleList[0]->toHandle();
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFirmwareFlash(handle, (void *)testImage, ZES_STRING_PROPERTY_SIZE));
pSysmanDeviceImp->pFirmwareHandleContext->handleList.pop_back();
delete ptestFirmwareImp;
}
HWTEST2_F(ZesSysmanFirmwareFixture, GivenValidFirmwareHandleFirmwareLibraryCallFailureWhenGettingFirmwarePropertiesThenUnknownIsReturned, IsXeHpcOrXeHpgCore) {
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, IsXeHpcOrXeHpgCore) {
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, IsXeHpcOrXeHpgCore) {
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, IsXeHpcOrXeHpgCore) {
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, IsXeHpcOrXeHpgCore) {
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, IsXeHpcOrXeHpgCore) {
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