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 0704ebfeb3..4b755fbd90 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,10 +13,13 @@ 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 = {}; @@ -35,6 +38,7 @@ 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); @@ -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(pProperties->version), 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); } } + 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) { 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 f7406c16f3..27d784ae7d 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,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 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 569b5a70aa..1ca9dd29d4 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,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 &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 9efc30722a..baa620e908 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 *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 &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 fa7154054a..57012bb04e 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,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 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 &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 &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 5d348483ee..95e0943e51 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,12 +46,17 @@ 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 3c66816b8e..9a935d9931 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}/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() 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 774f2a15a2..a28529a949 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,20 +35,11 @@ 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; @@ -57,27 +48,31 @@ struct Mock : 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() = 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 0dba0d0847..fdfea605d9 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,17 +29,19 @@ class ZesFirmwareFixture : public SysmanDeviceFixture { pMockFwInterface = std::make_unique>>(); pLinuxSysmanImp->pFwUtilInterface = pMockFwInterface.get(); ON_CALL(*pMockFwInterface.get(), fwDeviceInit()) - .WillByDefault(::testing::Invoke(pMockFwInterface.get(), &Mock::mockFwDeviceInit)); + .WillByDefault(::testing::Return(ZE_RESULT_SUCCESS)); 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::Invoke(pMockFwInterface.get(), &Mock::mockGetFirstDevice)); + .WillByDefault(::testing::Return(ZE_RESULT_SUCCESS)); ON_CALL(*pMockFwInterface.get(), fwFlashGSC(_, _)) - .WillByDefault(::testing::Invoke(pMockFwInterface.get(), &Mock::mockFwFlash)); + .WillByDefault(::testing::Return(ZE_RESULT_SUCCESS)); ON_CALL(*pMockFwInterface.get(), fwFlashOprom(_, _)) - .WillByDefault(::testing::Invoke(pMockFwInterface.get(), &Mock::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::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::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::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::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::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::mockFwGetVersionFailed)); - ON_CALL(*pMockFwInterface.get(), opromGetVersion(_)) - .WillByDefault(::testing::Invoke(pMockFwInterface.get(), &Mock::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: 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 0a84d7e691..131eb76d88 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,12 +402,17 @@ 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 {