Media
/
compute-runtime
mirror of https://github.com/intel/compute-runtime.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

firmware: Add support for new firmware type 

- This commit adds the support of new firmware flashing
- And also added the support in ULTs for the new firmware
flash APIs.

Related-To: LOCI-2381
Signed-off-by: Pichika Uday Kiran <pichika.uday.kiran@intel.com>
This commit is contained in:
Pichika Uday Kiran 2021-10-12 16:59:39 +00:00 committed by Compute-Runtime-Automation
parent 19b8a03d30
commit 3357b8b916
10 changed files with 120 additions and 72 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
level_zero/tools/source/sysman/firmware/linux/os_firmware_imp.cpp
View File

@ -13,10 +13,13 @@ namespace L0 {
static const std::string mtdDescriptor("/proc/mtd");
std::vector<std ::string> deviceSupportedFwTypes = {"GSC", "OptionROM"};
ze_result_t OsFirmware::getSupportedFwTypes(std::vector<std::string> &supportedFwTypes, OsSysman *pOsSysman) {
LinuxSysmanImp *pLinuxSysmanImp = static_cast<LinuxSysmanImp *>(pOsSysman);
FirmwareUtil *pFwInterface = pLinuxSysmanImp->getFwUtilInterface();
std::vector<std ::string> deviceSupportedFwTypes;
if (pFwInterface != nullptr) {
pFwInterface->getDeviceSupportedFwTypes(deviceSupportedFwTypes);
}
FsAccess *pFsAccess = &pLinuxSysmanImp->getFsAccess();
std::vector<std::string> mtdDescriptorStrings = {};
@ -35,6 +38,7 @@ ze_result_t OsFirmware::getSupportedFwTypes(std::vector<std::string> &supportedF
}
return ZE_RESULT_SUCCESS;
}
bool LinuxFirmwareImp::isFirmwareSupported(void) {
if (pFwInterface != nullptr) {
isFWInitalized = ((ZE_RESULT_SUCCESS == pFwInterface->fwDeviceInit()) ? true : false);
@ -44,39 +48,16 @@ bool LinuxFirmwareImp::isFirmwareSupported(void) {
}
void LinuxFirmwareImp::osGetFwProperties(zes_firmware_properties_t *pProperties) {
if (osFwType == deviceSupportedFwTypes[0]) { //GSC
getFirmwareVersion(pProperties->version);
}
if (osFwType == deviceSupportedFwTypes[1]) { //oprom
getOpromVersion(pProperties->version);
std::string fwVersion;
if (ZE_RESULT_SUCCESS == pFwInterface->getFwVersion(osFwType, fwVersion)) {
strncpy_s(static_cast<char *>(pProperties->version), ZES_STRING_PROPERTY_SIZE, fwVersion.c_str(), ZES_STRING_PROPERTY_SIZE);
} else {
strncpy_s(static_cast<char *>(pProperties->version), ZES_STRING_PROPERTY_SIZE, unknown.c_str(), ZES_STRING_PROPERTY_SIZE);
}
}
ze_result_t LinuxFirmwareImp::osFirmwareFlash(void *pImage, uint32_t size) {
if (osFwType == deviceSupportedFwTypes[0]) { //GSC
return pFwInterface->fwFlashGSC(pImage, size);
}
if (osFwType == deviceSupportedFwTypes[1]) { //oprom
return pFwInterface->fwFlashOprom(pImage, size);
}
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
void LinuxFirmwareImp::getFirmwareVersion(char *firmwareVersion) {
std::string fwVersion;
if (ZE_RESULT_SUCCESS == pFwInterface->fwGetVersion(fwVersion)) {
strncpy_s(firmwareVersion, ZES_STRING_PROPERTY_SIZE, fwVersion.c_str(), ZES_STRING_PROPERTY_SIZE);
} else {
strncpy_s(firmwareVersion, ZES_STRING_PROPERTY_SIZE, unknown.c_str(), ZES_STRING_PROPERTY_SIZE);
}
}
void LinuxFirmwareImp::getOpromVersion(char *firmwareVersion) {
std::string fwVersion;
if (ZE_RESULT_SUCCESS == pFwInterface->opromGetVersion(fwVersion)) {
strncpy_s(firmwareVersion, ZES_STRING_PROPERTY_SIZE, fwVersion.c_str(), ZES_STRING_PROPERTY_SIZE);
} else {
strncpy_s(firmwareVersion, ZES_STRING_PROPERTY_SIZE, unknown.c_str(), ZES_STRING_PROPERTY_SIZE);
}
return pFwInterface->flashFirmware(osFwType, pImage, size);
}
LinuxFirmwareImp::LinuxFirmwareImp(OsSysman *pOsSysman, const std::string &fwType) : osFwType(fwType) {

4
level_zero/tools/source/sysman/firmware/linux/os_firmware_imp.h
View File

@ -27,10 +27,6 @@ class LinuxFirmwareImp : public OsFirmware, NEO::NonCopyableOrMovableClass {
FirmwareUtil *pFwInterface = nullptr;
bool isFWInitalized = false;
std::string osFwType;
private:
void getFirmwareVersion(char *);
void getOpromVersion(char *);
};
} // namespace L0

5
level_zero/tools/source/sysman/linux/firmware_util/firmware_util.h
View File

@ -28,11 +28,16 @@ class FirmwareUtil {
virtual ze_result_t getFirstDevice(igsc_device_info *) = 0;
virtual ze_result_t fwGetVersion(std::string &fwVersion) = 0;
virtual ze_result_t opromGetVersion(std::string &fwVersion) = 0;
virtual ze_result_t pscGetVersion(std::string &fwVersion) = 0;
virtual ze_result_t fwFlashGSC(void *pImage, uint32_t size) = 0;
virtual ze_result_t fwFlashOprom(void *pImage, uint32_t size) = 0;
virtual ze_result_t fwFlashIafPsc(void *pImage, uint32_t size) = 0;
virtual ze_result_t getFwVersion(std::string fwType, std::string &firmwareVersion) = 0;
virtual ze_result_t flashFirmware(std::string fwType, void *pImage, uint32_t size) = 0;
virtual ze_result_t fwIfrApplied(bool &ifrStatus) = 0;
virtual ze_result_t fwSupportedDiagTests(std::vector<std::string> &supportedDiagTests) = 0;
virtual ze_result_t fwRunDiagTests(std::string &osDiagType, zes_diag_result_t *pDiagResult, uint32_t subDeviceId) = 0;
virtual void getDeviceSupportedFwTypes(std::vector<std::string> &fwTypes) = 0;
virtual ~FirmwareUtil() = default;
};
} // namespace L0

21
level_zero/tools/source/sysman/linux/firmware_util/firmware_util_imp.h
View File

@ -18,7 +18,7 @@
namespace L0 {
typedef int (*pIgscDeviceInitByDevice)(struct igsc_device_handle *handle,
const char *device_path);
const char *devicePath);
typedef int (*pIgscDeviceGetDeviceInfo)(struct igsc_device_handle *handle,
struct igsc_info_device *info);
typedef int (*pIgscDeviceFwVersion)(struct igsc_device_handle *handle,
@ -29,21 +29,21 @@ typedef int (*pIgscDeviceIteratorNext)(struct igsc_device_iterator *iter,
typedef void (*pIgscDeviceIteratorDestroy)(struct igsc_device_iterator *iter);
typedef int (*pIgscDeviceFwUpdate)(struct igsc_device_handle *handle,
const uint8_t *buffer,
const uint32_t buffer_len,
igsc_progress_func_t progress_f,
const uint32_t bufferLen,
igsc_progress_func_t progressFunc,
void *ctx);
typedef int (*pIgscImageOpromInit)(struct igsc_oprom_image **img,
const uint8_t *buffer,
uint32_t buffer_len);
uint32_t bufferLen);
typedef int (*pIgscImageOpromType)(struct igsc_oprom_image *img,
uint32_t *oprom_type);
uint32_t *opromType);
typedef int (*pIgscDeviceOpromUpdate)(struct igsc_device_handle *handle,
uint32_t oprom_type,
uint32_t opromType,
struct igsc_oprom_image *img,
igsc_progress_func_t progress_f,
igsc_progress_func_t progressFunc,
void *ctx);
typedef int (*pIgscDeviceOpromVersion)(struct igsc_device_handle *handle,
uint32_t oprom_type,
uint32_t opromType,
struct igsc_oprom_version *version);
extern pIgscDeviceInitByDevice deviceInitByDevice;
@ -66,11 +66,16 @@ class FirmwareUtilImp : public FirmwareUtil, NEO::NonCopyableOrMovableClass {
ze_result_t getFirstDevice(igsc_device_info *) override;
ze_result_t fwGetVersion(std::string &fwVersion) override;
ze_result_t opromGetVersion(std::string &fwVersion) override;
ze_result_t pscGetVersion(std::string &fwVersion) override;
ze_result_t fwFlashGSC(void *pImage, uint32_t size) override;
ze_result_t fwFlashOprom(void *pImage, uint32_t size) override;
ze_result_t fwFlashIafPsc(void *pImage, uint32_t size) override;
ze_result_t getFwVersion(std::string fwType, std::string &firmwareVersion) override;
ze_result_t flashFirmware(std::string fwType, void *pImage, uint32_t size) override;
ze_result_t fwIfrApplied(bool &ifrStatus) override;
ze_result_t fwSupportedDiagTests(std::vector<std::string> &supportedDiagTests) override;
ze_result_t fwRunDiagTests(std::string &osDiagType, zes_diag_result_t *pDiagResult, uint32_t subDeviceId) override;
void getDeviceSupportedFwTypes(std::vector<std::string> &fwTypes) override;
template <class T>
bool getSymbolAddr(const std::string name, T &proc);

35
level_zero/tools/source/sysman/linux/firmware_util/firmware_util_imp_helper.cpp
View File

@ -10,6 +10,8 @@
#include "level_zero/core/source/device/device.h"
#include "level_zero/tools/source/sysman/linux/firmware_util/firmware_util_imp.h"
std::vector<std ::string> deviceSupportedFwTypes = {"GSC", "OptionROM"};
namespace L0 {
ze_result_t FirmwareUtilImp::fwIfrApplied(bool &ifrStatus) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
@ -22,4 +24,37 @@ ze_result_t FirmwareUtilImp::fwSupportedDiagTests(std::vector<std::string> &supp
ze_result_t FirmwareUtilImp::fwRunDiagTests(std::string &osDiagType, zes_diag_result_t *pDiagResult, uint32_t subDeviceId) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
void FirmwareUtilImp::getDeviceSupportedFwTypes(std::vector<std::string> &fwTypes) {
fwTypes = deviceSupportedFwTypes;
}
ze_result_t FirmwareUtilImp::getFwVersion(std::string fwType, std::string &firmwareVersion) {
if (fwType == deviceSupportedFwTypes[0]) { //GSC
return fwGetVersion(firmwareVersion);
}
if (fwType == deviceSupportedFwTypes[1]) { //OPROM
return opromGetVersion(firmwareVersion);
}
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t FirmwareUtilImp::flashFirmware(std::string fwType, void *pImage, uint32_t size) {
if (fwType == deviceSupportedFwTypes[0]) { //GSC
return fwFlashGSC(pImage, size);
}
if (fwType == deviceSupportedFwTypes[1]) { //OPROM
return fwFlashOprom(pImage, size);
}
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t FirmwareUtilImp::fwFlashIafPsc(void *pImage, uint32_t size) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t FirmwareUtilImp::pscGetVersion(std::string &fwVersion) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
} // namespace L0

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

@ -46,12 +46,17 @@ struct Mock<DiagnosticsInterface> : public FirmwareUtil {
MOCK_METHOD(ze_result_t, fwDeviceInit, (), (override));
MOCK_METHOD(ze_result_t, fwGetVersion, (std::string & fwVersion), (override));
MOCK_METHOD(ze_result_t, opromGetVersion, (std::string & fwVersion), (override));
MOCK_METHOD(ze_result_t, pscGetVersion, (std::string & fwVersion), (override));
MOCK_METHOD(ze_result_t, getFirstDevice, (igsc_device_info * info), (override));
MOCK_METHOD(ze_result_t, fwFlashGSC, (void *pImage, uint32_t size), (override));
MOCK_METHOD(ze_result_t, fwFlashOprom, (void *pImage, uint32_t size), (override));
MOCK_METHOD(ze_result_t, fwFlashIafPsc, (void *pImage, uint32_t size), (override));
MOCK_METHOD(ze_result_t, getFwVersion, (std::string fwType, std::string &firmwareVersion), (override));
MOCK_METHOD(ze_result_t, flashFirmware, (std::string fwType, void *pImage, uint32_t size), (override));
MOCK_METHOD(ze_result_t, fwIfrApplied, (bool &ifrStatus), (override));
MOCK_METHOD(ze_result_t, fwSupportedDiagTests, (std::vector<std::string> & supportedDiagTests), (override));
MOCK_METHOD(ze_result_t, fwRunDiagTests, (std::string & osDiagType, zes_diag_result_t *pResult, uint32_t subDeviceId), (override));
MOCK_METHOD(void, getDeviceSupportedFwTypes, (std::vector<std::string> & fwTypes), (override));
};
class DiagSysfsAccess : public SysfsAccess {};

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

@ -8,7 +8,7 @@ if(UNIX)
target_sources(${TARGET_NAME}
PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/mock_zes_sysman_firmware.h
${CMAKE_CURRENT_SOURCE_DIR}/test_zes_sysman_firmware.cpp
${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}mock_zes_sysman_firmware.h
${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}test_zes_sysman_firmware.cpp
)
endif()

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

@ -35,20 +35,11 @@ struct Mock<FirmwareFsAccess> : public FirmwareFsAccess {
val.push_back("mtd3: 005ef000 00001000 \"i915-spi.42.auto.GSC\"");
return ZE_RESULT_SUCCESS;
}
ze_result_t readValFailure(const std::string file, std::vector<std::string> &val) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
};
template <>
struct Mock<FirmwareInterface> : public FirmwareUtil {
ze_result_t mockFwDeviceInit(void) {
return ZE_RESULT_SUCCESS;
}
ze_result_t mockFwDeviceInitFail(void) {
return ZE_RESULT_ERROR_UNKNOWN;
}
ze_result_t mockFwGetVersion(std::string &fwVersion) {
fwVersion = mockFwVersion;
return ZE_RESULT_SUCCESS;
@ -57,27 +48,31 @@ struct Mock<FirmwareInterface> : public FirmwareUtil {
fwVersion = mockOpromVersion;
return ZE_RESULT_SUCCESS;
}
ze_result_t mockGetFirstDevice(igsc_device_info *info) {
ze_result_t mockGetFwVersion(std::string fwType, std::string &firmwareVersion) {
if (fwType == "GSC") {
firmwareVersion = mockFwVersion;
} else if (fwType == "OptionROM") {
firmwareVersion = mockOpromVersion;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t mockFwFlash(void *pImage, uint32_t size) {
return ZE_RESULT_SUCCESS;
}
ze_result_t mockFwGetVersionFailed(std::string &fwVersion) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
Mock<FirmwareInterface>() = default;
MOCK_METHOD(ze_result_t, fwDeviceInit, (), (override));
MOCK_METHOD(ze_result_t, fwGetVersion, (std::string & fwVersion), (override));
MOCK_METHOD(ze_result_t, opromGetVersion, (std::string & fwVersion), (override));
MOCK_METHOD(ze_result_t, pscGetVersion, (std::string & fwVersion), (override));
MOCK_METHOD(ze_result_t, getFirstDevice, (igsc_device_info * info), (override));
MOCK_METHOD(ze_result_t, fwFlashGSC, (void *pImage, uint32_t size), (override));
MOCK_METHOD(ze_result_t, fwFlashOprom, (void *pImage, uint32_t size), (override));
MOCK_METHOD(ze_result_t, fwFlashIafPsc, (void *pImage, uint32_t size), (override));
MOCK_METHOD(ze_result_t, getFwVersion, (std::string fwType, std::string &firmwareVersion), (override));
MOCK_METHOD(ze_result_t, flashFirmware, (std::string fwType, void *pImage, uint32_t size), (override));
MOCK_METHOD(ze_result_t, fwIfrApplied, (bool &ifrStatus), (override));
MOCK_METHOD(ze_result_t, fwSupportedDiagTests, (std::vector<std::string> & supportedDiagTests), (override));
MOCK_METHOD(ze_result_t, fwRunDiagTests, (std::string & osDiagType, zes_diag_result_t *pResult, uint32_t subdeviceId), (override));
MOCK_METHOD(void, getDeviceSupportedFwTypes, (std::vector<std::string> & fwTypes), (override));
};
class PublicLinuxFirmwareImp : public L0::LinuxFirmwareImp {

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

@ -29,17 +29,19 @@ class ZesFirmwareFixture : public SysmanDeviceFixture {
pMockFwInterface = std::make_unique<NiceMock<Mock<FirmwareInterface>>>();
pLinuxSysmanImp->pFwUtilInterface = pMockFwInterface.get();
ON_CALL(*pMockFwInterface.get(), fwDeviceInit())
.WillByDefault(::testing::Invoke(pMockFwInterface.get(), &Mock<FirmwareInterface>::mockFwDeviceInit));
.WillByDefault(::testing::Return(ZE_RESULT_SUCCESS));
ON_CALL(*pMockFwInterface.get(), fwGetVersion(_))
.WillByDefault(::testing::Invoke(pMockFwInterface.get(), &Mock<FirmwareInterface>::mockFwGetVersion));
ON_CALL(*pMockFwInterface.get(), opromGetVersion(_))
.WillByDefault(::testing::Invoke(pMockFwInterface.get(), &Mock<FirmwareInterface>::mockOpromGetVersion));
ON_CALL(*pMockFwInterface.get(), getFirstDevice(_))
.WillByDefault(::testing::Invoke(pMockFwInterface.get(), &Mock<FirmwareInterface>::mockGetFirstDevice));
.WillByDefault(::testing::Return(ZE_RESULT_SUCCESS));
ON_CALL(*pMockFwInterface.get(), fwFlashGSC(_, _))
.WillByDefault(::testing::Invoke(pMockFwInterface.get(), &Mock<FirmwareInterface>::mockFwFlash));
.WillByDefault(::testing::Return(ZE_RESULT_SUCCESS));
ON_CALL(*pMockFwInterface.get(), fwFlashOprom(_, _))
.WillByDefault(::testing::Invoke(pMockFwInterface.get(), &Mock<FirmwareInterface>::mockFwFlash));
.WillByDefault(::testing::Return(ZE_RESULT_SUCCESS));
ON_CALL(*pMockFwInterface.get(), getDeviceSupportedFwTypes(_))
.WillByDefault(::testing::SetArgReferee<0>(mockSupportedFwTypes));
ON_CALL(*pFsAccess.get(), read(_, _))
.WillByDefault(::testing::Invoke(pFsAccess.get(), &Mock<FirmwareFsAccess>::readValSuccess));
for (const auto &handle : pSysmanDeviceImp->pFirmwareHandleContext->handleList) {
@ -107,6 +109,9 @@ TEST_F(ZesFirmwareFixture, GivenValidFirmwareHandleWhenGettingFirmwareProperties
FirmwareImp *ptestFirmwareImp = new FirmwareImp(pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman, mockSupportedFwTypes[0]);
pSysmanDeviceImp->pFirmwareHandleContext->handleList.push_back(ptestFirmwareImp);
ON_CALL(*pMockFwInterface.get(), getFwVersion(_, _))
.WillByDefault(::testing::Invoke(pMockFwInterface.get(), &Mock<FirmwareInterface>::mockGetFwVersion));
auto handles = get_firmware_handles(mockHandleCount);
zes_firmware_properties_t properties = {};
@ -122,6 +127,9 @@ TEST_F(ZesFirmwareFixture, GivenValidFirmwareHandleWhenGettingOpromPropertiesThe
FirmwareImp *ptestFirmwareImp = new FirmwareImp(pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman, mockSupportedFwTypes[1]);
pSysmanDeviceImp->pFirmwareHandleContext->handleList.push_back(ptestFirmwareImp);
ON_CALL(*pMockFwInterface.get(), getFwVersion(_, _))
.WillByDefault(::testing::Invoke(pMockFwInterface.get(), &Mock<FirmwareInterface>::mockGetFwVersion));
auto handles = get_firmware_handles(mockHandleCount);
zes_firmware_properties_t properties = {};
@ -139,7 +147,7 @@ TEST_F(ZesFirmwareFixture, GivenFailedFirmwareInitializationWhenInitializingFirm
}
pSysmanDeviceImp->pFirmwareHandleContext->handleList.clear();
ON_CALL(*pMockFwInterface.get(), fwDeviceInit())
.WillByDefault(::testing::Invoke(pMockFwInterface.get(), &Mock<FirmwareInterface>::mockFwDeviceInitFail));
.WillByDefault(::testing::Return(ZE_RESULT_ERROR_UNKNOWN));
pSysmanDeviceImp->pFirmwareHandleContext->init();
@ -163,6 +171,9 @@ TEST_F(ZesFirmwareFixture, GivenValidFirmwareHandleWhenFlashingGscFirmwareThenSu
FirmwareImp *ptestFirmwareImp = new FirmwareImp(pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman, mockSupportedFwTypes[0]);
pSysmanDeviceImp->pFirmwareHandleContext->handleList.push_back(ptestFirmwareImp);
ON_CALL(*pMockFwInterface.get(), flashFirmware(_, _, _))
.WillByDefault(::testing::Return(ZE_RESULT_SUCCESS));
auto handles = get_firmware_handles(mockHandleCount);
uint8_t testImage[ZES_STRING_PROPERTY_SIZE] = {};
memset(testImage, 0xA, ZES_STRING_PROPERTY_SIZE);
@ -181,6 +192,9 @@ TEST_F(ZesFirmwareFixture, GivenValidFirmwareHandleWhenFlashingUnkownFirmwareThe
FirmwareImp *ptestFirmwareImp = new FirmwareImp(pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman, mockUnsupportedFwTypes[0]);
pSysmanDeviceImp->pFirmwareHandleContext->handleList.push_back(ptestFirmwareImp);
ON_CALL(*pMockFwInterface.get(), flashFirmware(_, _, _))
.WillByDefault(::testing::Return(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();
@ -196,7 +210,7 @@ TEST_F(ZesFirmwareFixture, GivenFirmwareInitializationFailureThenCreateHandleMus
}
pSysmanDeviceImp->pFirmwareHandleContext->handleList.clear();
ON_CALL(*pMockFwInterface.get(), fwDeviceInit())
.WillByDefault(::testing::Invoke(pMockFwInterface.get(), &Mock<FirmwareInterface>::mockFwDeviceInitFail));
.WillByDefault(::testing::Return(ZE_RESULT_ERROR_UNKNOWN));
pSysmanDeviceImp->pFirmwareHandleContext->init();
EXPECT_EQ(0u, pSysmanDeviceImp->pFirmwareHandleContext->handleList.size());
}
@ -206,10 +220,9 @@ TEST_F(ZesFirmwareFixture, GivenValidFirmwareHandleFirmwareLibraryCallFailureWhe
delete handle;
}
pSysmanDeviceImp->pFirmwareHandleContext->handleList.clear();
ON_CALL(*pMockFwInterface.get(), fwGetVersion(_))
.WillByDefault(::testing::Invoke(pMockFwInterface.get(), &Mock<FirmwareInterface>::mockFwGetVersionFailed));
ON_CALL(*pMockFwInterface.get(), opromGetVersion(_))
.WillByDefault(::testing::Invoke(pMockFwInterface.get(), &Mock<FirmwareInterface>::mockFwGetVersionFailed));
ON_CALL(*pMockFwInterface.get(), getFwVersion(_, _))
.WillByDefault(::testing::Return(ZE_RESULT_ERROR_UNINITIALIZED));
pSysmanDeviceImp->pFirmwareHandleContext->init();
auto handles = get_firmware_handles(mockHandleCount);
@ -223,6 +236,14 @@ TEST_F(ZesFirmwareFixture, GivenValidFirmwareHandleFirmwareLibraryCallFailureWhe
EXPECT_STREQ("unknown", properties.version);
}
TEST_F(ZesFirmwareFixture, GivenFwUtilInterfaceNullWhenCreatingFirmwareImpThenIsFirmwareSupportedShouldFail) {
pLinuxSysmanImp->pFwUtilInterface = nullptr;
FirmwareImp *ptestFirmwareImp = new FirmwareImp(pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman, mockSupportedFwTypes[0]);
EXPECT_EQ(nullptr, pLinuxSysmanImp->pFwUtilInterface);
delete ptestFirmwareImp;
pLinuxSysmanImp->pFwUtilInterface = pMockFwInterface.get();
}
class ZesFirmwareUninitializedFixture : public SysmanDeviceFixture {
protected:

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

@ -402,12 +402,17 @@ struct Mock<FirmwareInterface> : public FirmwareUtil {
MOCK_METHOD(ze_result_t, fwDeviceInit, (), (override));
MOCK_METHOD(ze_result_t, fwGetVersion, (std::string & fwVersion), (override));
MOCK_METHOD(ze_result_t, opromGetVersion, (std::string & fwVersion), (override));
MOCK_METHOD(ze_result_t, pscGetVersion, (std::string & fwVersion), (override));
MOCK_METHOD(ze_result_t, getFirstDevice, (igsc_device_info * info), (override));
MOCK_METHOD(ze_result_t, fwFlashGSC, (void *pImage, uint32_t size), (override));
MOCK_METHOD(ze_result_t, fwFlashOprom, (void *pImage, uint32_t size), (override));
MOCK_METHOD(ze_result_t, fwFlashIafPsc, (void *pImage, uint32_t size), (override));
MOCK_METHOD(ze_result_t, getFwVersion, (std::string fwType, std::string &firmwareVersion), (override));
MOCK_METHOD(ze_result_t, flashFirmware, (std::string fwType, void *pImage, uint32_t size), (override));
MOCK_METHOD(ze_result_t, fwIfrApplied, (bool &ifrStatus), (override));
MOCK_METHOD(ze_result_t, fwSupportedDiagTests, (std::vector<std::string> & supportedDiagTests), (override));
MOCK_METHOD(ze_result_t, fwRunDiagTests, (std::string & osDiagType, zes_diag_result_t *pResult, uint32_t subdeviceId), (override));
MOCK_METHOD(void, getDeviceSupportedFwTypes, (std::vector<std::string> & fwTypes), (override));
};
class PublicLinuxGlobalOperationsImp : public L0::LinuxGlobalOperationsImp {