From e063b120de78e5774fc2879002efed7dbb5af660 Mon Sep 17 00:00:00 2001 From: Pichika Uday Kiran Date: Mon, 18 Oct 2021 15:48:26 +0000 Subject: [PATCH] Revert "firmware: Add support for new firmware type" This reverts commit 3c739cf687b9d47185c131231316e51a71cbefa0. Related-To: LOCI-2381 Signed-off-by: Pichika Uday Kiran --- .../sysman/firmware/linux/os_firmware_imp.cpp | 41 ++++++++++++++----- .../sysman/firmware/linux/os_firmware_imp.h | 4 ++ .../linux/firmware_util/firmware_util.h | 5 --- .../linux/firmware_util/firmware_util_imp.h | 21 ++++------ .../firmware_util_imp_helper.cpp | 35 ---------------- .../linux/mock_zes_sysman_diagnostics.h | 5 --- .../sysman/firmware/linux/CMakeLists.txt | 4 +- .../firmware/linux/mock_zes_sysman_firmware.h | 27 +++++++----- .../linux/test_zes_sysman_firmware.cpp | 41 +++++-------------- .../linux/mock_global_operations.h | 5 --- 10 files changed, 70 insertions(+), 118 deletions(-) diff --git a/level_zero/tools/source/sysman/firmware/linux/os_firmware_imp.cpp b/level_zero/tools/source/sysman/firmware/linux/os_firmware_imp.cpp index 4b755fbd90..0704ebfeb3 100644 --- a/level_zero/tools/source/sysman/firmware/linux/os_firmware_imp.cpp +++ b/level_zero/tools/source/sysman/firmware/linux/os_firmware_imp.cpp @@ -13,13 +13,10 @@ namespace L0 { static const std::string mtdDescriptor("/proc/mtd"); +std::vector deviceSupportedFwTypes = {"GSC", "OptionROM"}; + ze_result_t OsFirmware::getSupportedFwTypes(std::vector &supportedFwTypes, OsSysman *pOsSysman) { LinuxSysmanImp *pLinuxSysmanImp = static_cast(pOsSysman); - FirmwareUtil *pFwInterface = pLinuxSysmanImp->getFwUtilInterface(); - std::vector deviceSupportedFwTypes; - if (pFwInterface != nullptr) { - pFwInterface->getDeviceSupportedFwTypes(deviceSupportedFwTypes); - } FsAccess *pFsAccess = &pLinuxSysmanImp->getFsAccess(); std::vector mtdDescriptorStrings = {}; @@ -38,7 +35,6 @@ ze_result_t OsFirmware::getSupportedFwTypes(std::vector &supportedF } return ZE_RESULT_SUCCESS; } - bool LinuxFirmwareImp::isFirmwareSupported(void) { if (pFwInterface != nullptr) { isFWInitalized = ((ZE_RESULT_SUCCESS == pFwInterface->fwDeviceInit()) ? true : false); @@ -48,16 +44,39 @@ 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); + } +} +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->getFwVersion(osFwType, fwVersion)) { - strncpy_s(static_cast(pProperties->version), ZES_STRING_PROPERTY_SIZE, fwVersion.c_str(), ZES_STRING_PROPERTY_SIZE); + if (ZE_RESULT_SUCCESS == pFwInterface->fwGetVersion(fwVersion)) { + strncpy_s(firmwareVersion, ZES_STRING_PROPERTY_SIZE, fwVersion.c_str(), ZES_STRING_PROPERTY_SIZE); } else { - strncpy_s(static_cast(pProperties->version), ZES_STRING_PROPERTY_SIZE, unknown.c_str(), ZES_STRING_PROPERTY_SIZE); + strncpy_s(firmwareVersion, ZES_STRING_PROPERTY_SIZE, unknown.c_str(), ZES_STRING_PROPERTY_SIZE); } } -ze_result_t LinuxFirmwareImp::osFirmwareFlash(void *pImage, uint32_t size) { - return pFwInterface->flashFirmware(osFwType, pImage, 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); + } } LinuxFirmwareImp::LinuxFirmwareImp(OsSysman *pOsSysman, const std::string &fwType) : osFwType(fwType) { diff --git a/level_zero/tools/source/sysman/firmware/linux/os_firmware_imp.h b/level_zero/tools/source/sysman/firmware/linux/os_firmware_imp.h index 27d784ae7d..f7406c16f3 100644 --- a/level_zero/tools/source/sysman/firmware/linux/os_firmware_imp.h +++ b/level_zero/tools/source/sysman/firmware/linux/os_firmware_imp.h @@ -27,6 +27,10 @@ class LinuxFirmwareImp : public OsFirmware, NEO::NonCopyableOrMovableClass { FirmwareUtil *pFwInterface = nullptr; bool isFWInitalized = false; std::string osFwType; + + private: + void getFirmwareVersion(char *); + void getOpromVersion(char *); }; } // namespace L0 diff --git a/level_zero/tools/source/sysman/linux/firmware_util/firmware_util.h b/level_zero/tools/source/sysman/linux/firmware_util/firmware_util.h index 689add4a9e..569b5a70aa 100644 --- a/level_zero/tools/source/sysman/linux/firmware_util/firmware_util.h +++ b/level_zero/tools/source/sysman/linux/firmware_util/firmware_util.h @@ -28,16 +28,11 @@ 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 &supportedDiagTests) = 0; virtual ze_result_t fwRunDiagTests(std::string &osDiagType, zes_diag_result_t *pDiagResult, uint32_t subDeviceId) = 0; - virtual void getDeviceSupportedFwTypes(std::vector &fwTypes) = 0; virtual ~FirmwareUtil() = default; }; } // namespace L0 diff --git a/level_zero/tools/source/sysman/linux/firmware_util/firmware_util_imp.h b/level_zero/tools/source/sysman/linux/firmware_util/firmware_util_imp.h index 2cd535ac89..9efc30722a 100644 --- a/level_zero/tools/source/sysman/linux/firmware_util/firmware_util_imp.h +++ b/level_zero/tools/source/sysman/linux/firmware_util/firmware_util_imp.h @@ -18,7 +18,7 @@ namespace L0 { typedef int (*pIgscDeviceInitByDevice)(struct igsc_device_handle *handle, - const char *devicePath); + const char *device_path); 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 bufferLen, - igsc_progress_func_t progressFunc, + const uint32_t buffer_len, + igsc_progress_func_t progress_f, void *ctx); typedef int (*pIgscImageOpromInit)(struct igsc_oprom_image **img, const uint8_t *buffer, - uint32_t bufferLen); + uint32_t buffer_len); typedef int (*pIgscImageOpromType)(struct igsc_oprom_image *img, - uint32_t *opromType); + uint32_t *oprom_type); typedef int (*pIgscDeviceOpromUpdate)(struct igsc_device_handle *handle, - uint32_t opromType, + uint32_t oprom_type, struct igsc_oprom_image *img, - igsc_progress_func_t progressFunc, + igsc_progress_func_t progress_f, void *ctx); typedef int (*pIgscDeviceOpromVersion)(struct igsc_device_handle *handle, - uint32_t opromType, + uint32_t oprom_type, struct igsc_oprom_version *version); extern pIgscDeviceInitByDevice deviceInitByDevice; @@ -66,16 +66,11 @@ 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 &supportedDiagTests) override; ze_result_t fwRunDiagTests(std::string &osDiagType, zes_diag_result_t *pDiagResult, uint32_t subDeviceId) override; - void getDeviceSupportedFwTypes(std::vector &fwTypes) override; template bool getSymbolAddr(const std::string name, T &proc); diff --git a/level_zero/tools/source/sysman/linux/firmware_util/firmware_util_imp_helper.cpp b/level_zero/tools/source/sysman/linux/firmware_util/firmware_util_imp_helper.cpp index c22f035eb4..fa7154054a 100644 --- a/level_zero/tools/source/sysman/linux/firmware_util/firmware_util_imp_helper.cpp +++ b/level_zero/tools/source/sysman/linux/firmware_util/firmware_util_imp_helper.cpp @@ -10,8 +10,6 @@ #include "level_zero/core/source/device/device.h" #include "level_zero/tools/source/sysman/linux/firmware_util/firmware_util_imp.h" -std::vector deviceSupportedFwTypes = {"GSC", "OptionROM"}; - namespace L0 { ze_result_t FirmwareUtilImp::fwIfrApplied(bool &ifrStatus) { return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; @@ -24,37 +22,4 @@ ze_result_t FirmwareUtilImp::fwSupportedDiagTests(std::vector &supp ze_result_t FirmwareUtilImp::fwRunDiagTests(std::string &osDiagType, zes_diag_result_t *pDiagResult, uint32_t subDeviceId) { return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; } - -void FirmwareUtil::getDeviceSupportedFwTypes(std::vector &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 diff --git a/level_zero/tools/test/unit_tests/sources/sysman/diagnostics/linux/mock_zes_sysman_diagnostics.h b/level_zero/tools/test/unit_tests/sources/sysman/diagnostics/linux/mock_zes_sysman_diagnostics.h index aca345f5fc..5d348483ee 100644 --- a/level_zero/tools/test/unit_tests/sources/sysman/diagnostics/linux/mock_zes_sysman_diagnostics.h +++ b/level_zero/tools/test/unit_tests/sources/sysman/diagnostics/linux/mock_zes_sysman_diagnostics.h @@ -46,17 +46,12 @@ struct Mock : 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 & 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 & fwTypes), (override)); }; class DiagSysfsAccess : public SysfsAccess {}; diff --git a/level_zero/tools/test/unit_tests/sources/sysman/firmware/linux/CMakeLists.txt b/level_zero/tools/test/unit_tests/sources/sysman/firmware/linux/CMakeLists.txt index 9a935d9931..3c66816b8e 100644 --- a/level_zero/tools/test/unit_tests/sources/sysman/firmware/linux/CMakeLists.txt +++ b/level_zero/tools/test/unit_tests/sources/sysman/firmware/linux/CMakeLists.txt @@ -8,7 +8,7 @@ if(UNIX) target_sources(${TARGET_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt - ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}mock_zes_sysman_firmware.h - ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}test_zes_sysman_firmware.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/mock_zes_sysman_firmware.h + ${CMAKE_CURRENT_SOURCE_DIR}/test_zes_sysman_firmware.cpp ) endif() diff --git a/level_zero/tools/test/unit_tests/sources/sysman/firmware/linux/mock_zes_sysman_firmware.h b/level_zero/tools/test/unit_tests/sources/sysman/firmware/linux/mock_zes_sysman_firmware.h index a488f2daa0..774f2a15a2 100644 --- a/level_zero/tools/test/unit_tests/sources/sysman/firmware/linux/mock_zes_sysman_firmware.h +++ b/level_zero/tools/test/unit_tests/sources/sysman/firmware/linux/mock_zes_sysman_firmware.h @@ -35,11 +35,20 @@ struct Mock : 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 &val) { + return ZE_RESULT_ERROR_NOT_AVAILABLE; + } }; template <> struct Mock : 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; @@ -48,31 +57,27 @@ struct Mock : public FirmwareUtil { fwVersion = mockOpromVersion; return ZE_RESULT_SUCCESS; } - ze_result_t mockGetFwVersion(std::string fwType, std::string &firmwareVersion) { - if (fwType == "GSC") { - firmwareVersion = mockFwVersion; - } else if (fwType == "OptionROM") { - firmwareVersion = mockOpromVersion; - } + ze_result_t mockGetFirstDevice(igsc_device_info *info) { 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() = 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 & 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 & fwTypes), (override)); }; class PublicLinuxFirmwareImp : public L0::LinuxFirmwareImp { diff --git a/level_zero/tools/test/unit_tests/sources/sysman/firmware/linux/test_zes_sysman_firmware.cpp b/level_zero/tools/test/unit_tests/sources/sysman/firmware/linux/test_zes_sysman_firmware.cpp index fdfea605d9..0dba0d0847 100644 --- a/level_zero/tools/test/unit_tests/sources/sysman/firmware/linux/test_zes_sysman_firmware.cpp +++ b/level_zero/tools/test/unit_tests/sources/sysman/firmware/linux/test_zes_sysman_firmware.cpp @@ -29,19 +29,17 @@ class ZesFirmwareFixture : public SysmanDeviceFixture { pMockFwInterface = std::make_unique>>(); pLinuxSysmanImp->pFwUtilInterface = pMockFwInterface.get(); ON_CALL(*pMockFwInterface.get(), fwDeviceInit()) - .WillByDefault(::testing::Return(ZE_RESULT_SUCCESS)); + .WillByDefault(::testing::Invoke(pMockFwInterface.get(), &Mock::mockFwDeviceInit)); ON_CALL(*pMockFwInterface.get(), fwGetVersion(_)) .WillByDefault(::testing::Invoke(pMockFwInterface.get(), &Mock::mockFwGetVersion)); ON_CALL(*pMockFwInterface.get(), opromGetVersion(_)) .WillByDefault(::testing::Invoke(pMockFwInterface.get(), &Mock::mockOpromGetVersion)); ON_CALL(*pMockFwInterface.get(), getFirstDevice(_)) - .WillByDefault(::testing::Return(ZE_RESULT_SUCCESS)); + .WillByDefault(::testing::Invoke(pMockFwInterface.get(), &Mock::mockGetFirstDevice)); ON_CALL(*pMockFwInterface.get(), fwFlashGSC(_, _)) - .WillByDefault(::testing::Return(ZE_RESULT_SUCCESS)); + .WillByDefault(::testing::Invoke(pMockFwInterface.get(), &Mock::mockFwFlash)); ON_CALL(*pMockFwInterface.get(), fwFlashOprom(_, _)) - .WillByDefault(::testing::Return(ZE_RESULT_SUCCESS)); - ON_CALL(*pMockFwInterface.get(), getDeviceSupportedFwTypes(_)) - .WillByDefault(::testing::SetArgReferee<0>(mockSupportedFwTypes)); + .WillByDefault(::testing::Invoke(pMockFwInterface.get(), &Mock::mockFwFlash)); ON_CALL(*pFsAccess.get(), read(_, _)) .WillByDefault(::testing::Invoke(pFsAccess.get(), &Mock::readValSuccess)); for (const auto &handle : pSysmanDeviceImp->pFirmwareHandleContext->handleList) { @@ -109,9 +107,6 @@ 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::mockGetFwVersion)); - auto handles = get_firmware_handles(mockHandleCount); zes_firmware_properties_t properties = {}; @@ -127,9 +122,6 @@ 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::mockGetFwVersion)); - auto handles = get_firmware_handles(mockHandleCount); zes_firmware_properties_t properties = {}; @@ -147,7 +139,7 @@ TEST_F(ZesFirmwareFixture, GivenFailedFirmwareInitializationWhenInitializingFirm } pSysmanDeviceImp->pFirmwareHandleContext->handleList.clear(); ON_CALL(*pMockFwInterface.get(), fwDeviceInit()) - .WillByDefault(::testing::Return(ZE_RESULT_ERROR_UNKNOWN)); + .WillByDefault(::testing::Invoke(pMockFwInterface.get(), &Mock::mockFwDeviceInitFail)); pSysmanDeviceImp->pFirmwareHandleContext->init(); @@ -171,9 +163,6 @@ 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); @@ -192,9 +181,6 @@ 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(); @@ -210,7 +196,7 @@ TEST_F(ZesFirmwareFixture, GivenFirmwareInitializationFailureThenCreateHandleMus } pSysmanDeviceImp->pFirmwareHandleContext->handleList.clear(); ON_CALL(*pMockFwInterface.get(), fwDeviceInit()) - .WillByDefault(::testing::Return(ZE_RESULT_ERROR_UNKNOWN)); + .WillByDefault(::testing::Invoke(pMockFwInterface.get(), &Mock::mockFwDeviceInitFail)); pSysmanDeviceImp->pFirmwareHandleContext->init(); EXPECT_EQ(0u, pSysmanDeviceImp->pFirmwareHandleContext->handleList.size()); } @@ -220,9 +206,10 @@ TEST_F(ZesFirmwareFixture, GivenValidFirmwareHandleFirmwareLibraryCallFailureWhe delete handle; } pSysmanDeviceImp->pFirmwareHandleContext->handleList.clear(); - ON_CALL(*pMockFwInterface.get(), getFwVersion(_, _)) - .WillByDefault(::testing::Return(ZE_RESULT_ERROR_UNINITIALIZED)); - + ON_CALL(*pMockFwInterface.get(), fwGetVersion(_)) + .WillByDefault(::testing::Invoke(pMockFwInterface.get(), &Mock::mockFwGetVersionFailed)); + ON_CALL(*pMockFwInterface.get(), opromGetVersion(_)) + .WillByDefault(::testing::Invoke(pMockFwInterface.get(), &Mock::mockFwGetVersionFailed)); pSysmanDeviceImp->pFirmwareHandleContext->init(); auto handles = get_firmware_handles(mockHandleCount); @@ -236,14 +223,6 @@ 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: diff --git a/level_zero/tools/test/unit_tests/sources/sysman/global_operations/linux/mock_global_operations.h b/level_zero/tools/test/unit_tests/sources/sysman/global_operations/linux/mock_global_operations.h index 9fdcbf71b0..0a84d7e691 100644 --- a/level_zero/tools/test/unit_tests/sources/sysman/global_operations/linux/mock_global_operations.h +++ b/level_zero/tools/test/unit_tests/sources/sysman/global_operations/linux/mock_global_operations.h @@ -402,17 +402,12 @@ struct Mock : 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 & 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 & fwTypes), (override)); }; class PublicLinuxGlobalOperationsImp : public L0::LinuxGlobalOperationsImp {