From 5dbe905e74ada5920f141793ff152f177a4251a3 Mon Sep 17 00:00:00 2001 From: Joshua Santosh Ranjan Date: Tue, 28 Mar 2023 15:04:08 +0000 Subject: [PATCH] [Sysman]Update Firmware module to support zesInit Related-To: LOCI-4227 Signed-off-by: Joshua Santosh Ranjan --- level_zero/api/sysman/zes_handles_struct.h | 4 + .../api/sysman/zes_sysman_api_entrypoints.h | 18 +- .../source/engine/windows/CMakeLists.txt | 6 +- .../sysman/source/firmware/CMakeLists.txt | 17 + .../sysman/source/firmware/firmware.cpp | 56 ++++ level_zero/sysman/source/firmware/firmware.h | 55 ++++ .../sysman/source/firmware/firmware_imp.cpp | 41 +++ .../sysman/source/firmware/firmware_imp.h | 34 ++ .../source/firmware/linux/CMakeLists.txt | 26 ++ .../source/firmware/linux/os_firmware_imp.cpp | 72 ++++ .../source/firmware/linux/os_firmware_imp.h | 36 ++ .../firmware/linux/os_firmware_imp_helper.cpp | 24 ++ .../linux/os_firmware_imp_helper_prelim.cpp | 60 ++++ .../sysman/source/firmware/os_firmware.h | 28 ++ .../source/firmware/windows/CMakeLists.txt | 14 + .../firmware/windows/os_firmware_imp.cpp | 29 ++ .../source/firmware/windows/os_firmware_imp.h | 26 ++ level_zero/sysman/source/sysman_device.cpp | 5 + level_zero/sysman/source/sysman_device.h | 4 + .../sysman/source/sysman_device_imp.cpp | 6 + level_zero/sysman/source/sysman_device_imp.h | 2 + .../sources/firmware/CMakeLists.txt | 11 + .../sources/firmware/linux/CMakeLists.txt | 29 ++ .../firmware/linux/mock_zes_sysman_firmware.h | 87 +++++ .../linux/mock_zes_sysman_firmware_prelim.h | 135 ++++++++ .../linux/test_zes_sysman_firmware.cpp | 258 +++++++++++++++ .../linux/test_zes_sysman_firmware_prelim.cpp | 307 ++++++++++++++++++ .../tools/source/sysman/firmware/firmware.h | 7 +- 28 files changed, 1386 insertions(+), 11 deletions(-) create mode 100644 level_zero/sysman/source/firmware/CMakeLists.txt create mode 100644 level_zero/sysman/source/firmware/firmware.cpp create mode 100644 level_zero/sysman/source/firmware/firmware.h create mode 100644 level_zero/sysman/source/firmware/firmware_imp.cpp create mode 100644 level_zero/sysman/source/firmware/firmware_imp.h create mode 100644 level_zero/sysman/source/firmware/linux/CMakeLists.txt create mode 100644 level_zero/sysman/source/firmware/linux/os_firmware_imp.cpp create mode 100644 level_zero/sysman/source/firmware/linux/os_firmware_imp.h create mode 100644 level_zero/sysman/source/firmware/linux/os_firmware_imp_helper.cpp create mode 100644 level_zero/sysman/source/firmware/linux/os_firmware_imp_helper_prelim.cpp create mode 100644 level_zero/sysman/source/firmware/os_firmware.h create mode 100644 level_zero/sysman/source/firmware/windows/CMakeLists.txt create mode 100644 level_zero/sysman/source/firmware/windows/os_firmware_imp.cpp create mode 100644 level_zero/sysman/source/firmware/windows/os_firmware_imp.h create mode 100644 level_zero/sysman/test/unit_tests/sources/firmware/CMakeLists.txt create mode 100644 level_zero/sysman/test/unit_tests/sources/firmware/linux/CMakeLists.txt create mode 100644 level_zero/sysman/test/unit_tests/sources/firmware/linux/mock_zes_sysman_firmware.h create mode 100644 level_zero/sysman/test/unit_tests/sources/firmware/linux/mock_zes_sysman_firmware_prelim.h create mode 100644 level_zero/sysman/test/unit_tests/sources/firmware/linux/test_zes_sysman_firmware.cpp create mode 100644 level_zero/sysman/test/unit_tests/sources/firmware/linux/test_zes_sysman_firmware_prelim.cpp diff --git a/level_zero/api/sysman/zes_handles_struct.h b/level_zero/api/sysman/zes_handles_struct.h index e45e5dda4c..460093d09c 100644 --- a/level_zero/api/sysman/zes_handles_struct.h +++ b/level_zero/api/sysman/zes_handles_struct.h @@ -31,3 +31,7 @@ struct _zes_freq_handle_t { struct _zes_sched_handle_t { virtual ~_zes_sched_handle_t() = default; }; + +struct _zes_firmware_handle_t { + virtual ~_zes_firmware_handle_t() = default; +}; diff --git a/level_zero/api/sysman/zes_sysman_api_entrypoints.h b/level_zero/api/sysman/zes_sysman_api_entrypoints.h index 0fd3658fad..0ed4f2778e 100644 --- a/level_zero/api/sysman/zes_sysman_api_entrypoints.h +++ b/level_zero/api/sysman/zes_sysman_api_entrypoints.h @@ -528,20 +528,32 @@ ze_result_t zesDeviceEnumFirmwares( zes_device_handle_t hDevice, uint32_t *pCount, zes_firmware_handle_t *phFirmware) { - return L0::SysmanDevice::firmwareGet(hDevice, pCount, phFirmware); + if (L0::sysmanInitFromCore) { + return L0::SysmanDevice::firmwareGet(hDevice, pCount, phFirmware); + } else { + return L0::Sysman::SysmanDevice::firmwareGet(hDevice, pCount, phFirmware); + } } ze_result_t zesFirmwareGetProperties( zes_firmware_handle_t hFirmware, zes_firmware_properties_t *pProperties) { - return L0::Firmware::fromHandle(hFirmware)->firmwareGetProperties(pProperties); + if (L0::sysmanInitFromCore) { + return L0::Firmware::fromHandle(hFirmware)->firmwareGetProperties(pProperties); + } else { + return L0::Sysman::Firmware::fromHandle(hFirmware)->firmwareGetProperties(pProperties); + } } ze_result_t zesFirmwareFlash( zes_firmware_handle_t hFirmware, void *pImage, uint32_t size) { - return L0::Firmware::fromHandle(hFirmware)->firmwareFlash(pImage, size); + if (L0::sysmanInitFromCore) { + return L0::Firmware::fromHandle(hFirmware)->firmwareFlash(pImage, size); + } else { + return L0::Sysman::Firmware::fromHandle(hFirmware)->firmwareFlash(pImage, size); + } } ze_result_t zesDeviceEnumMemoryModules( diff --git a/level_zero/sysman/source/engine/windows/CMakeLists.txt b/level_zero/sysman/source/engine/windows/CMakeLists.txt index 8b5ee7215d..afae0739fd 100755 --- a/level_zero/sysman/source/engine/windows/CMakeLists.txt +++ b/level_zero/sysman/source/engine/windows/CMakeLists.txt @@ -4,7 +4,7 @@ # SPDX-License-Identifier: MIT # -set(L0_SRCS_TOOLS_SYSMAN_ENGINE_WINDOWS +set(L0_SRCS_SYSMAN_ENGINE_WINDOWS ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt ${CMAKE_CURRENT_SOURCE_DIR}/os_engine_imp.h ${CMAKE_CURRENT_SOURCE_DIR}/os_engine_imp.cpp @@ -13,9 +13,9 @@ set(L0_SRCS_TOOLS_SYSMAN_ENGINE_WINDOWS if(WIN32) target_sources(${L0_STATIC_LIB_NAME} PRIVATE - ${L0_SRCS_TOOLS_SYSMAN_ENGINE_WINDOWS} + ${L0_SRCS_SYSMAN_ENGINE_WINDOWS} ) endif() # Make our source files visible to parent -set_property(GLOBAL PROPERTY L0_SRCS_TOOLS_SYSMAN_ENGINE_WINDOWS ${L0_SRCS_TOOLS_SYSMAN_ENGINE_WINDOWS}) +set_property(GLOBAL PROPERTY L0_SRCS_SYSMAN_ENGINE_WINDOWS ${L0_SRCS_SYSMAN_ENGINE_WINDOWS}) diff --git a/level_zero/sysman/source/firmware/CMakeLists.txt b/level_zero/sysman/source/firmware/CMakeLists.txt new file mode 100644 index 0000000000..1b1487d92d --- /dev/null +++ b/level_zero/sysman/source/firmware/CMakeLists.txt @@ -0,0 +1,17 @@ +# +# Copyright (C) 2020-2023 Intel Corporation +# +# SPDX-License-Identifier: MIT +# + +target_sources(${L0_STATIC_LIB_NAME} + PRIVATE + ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt + ${CMAKE_CURRENT_SOURCE_DIR}/firmware.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/firmware.h + ${CMAKE_CURRENT_SOURCE_DIR}/firmware_imp.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/firmware_imp.h + ${CMAKE_CURRENT_SOURCE_DIR}/os_firmware.h +) + +add_subdirectories() diff --git a/level_zero/sysman/source/firmware/firmware.cpp b/level_zero/sysman/source/firmware/firmware.cpp new file mode 100644 index 0000000000..1f15490baf --- /dev/null +++ b/level_zero/sysman/source/firmware/firmware.cpp @@ -0,0 +1,56 @@ +/* + * Copyright (C) 2020-2023 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#include "shared/source/helpers/basic_math.h" + +#include "level_zero/sysman/source/firmware/firmware_imp.h" + +namespace L0 { +namespace Sysman { +class OsFirmware; +FirmwareHandleContext::~FirmwareHandleContext() { + releaseFwHandles(); +} + +void FirmwareHandleContext::releaseFwHandles() { + for (Firmware *pFirmware : handleList) { + delete pFirmware; + } + handleList.clear(); +} +void FirmwareHandleContext::createHandle(const std::string &fwType) { + Firmware *pFirmware = new FirmwareImp(pOsSysman, fwType); + handleList.push_back(pFirmware); +} + +void FirmwareHandleContext::init() { + std::vector supportedFwTypes = {}; + OsFirmware::getSupportedFwTypes(supportedFwTypes, pOsSysman); + for (const std::string &fwType : supportedFwTypes) { + createHandle(fwType); + } +} + +ze_result_t FirmwareHandleContext::firmwareGet(uint32_t *pCount, zes_firmware_handle_t *phFirmware) { + std::call_once(initFirmwareOnce, [this]() { + this->init(); + this->firmwareInitDone = true; + }); + uint32_t handleListSize = static_cast(handleList.size()); + uint32_t numToCopy = std::min(*pCount, handleListSize); + if (0 == *pCount || *pCount > handleListSize) { + *pCount = handleListSize; + } + if (nullptr != phFirmware) { + for (uint32_t i = 0; i < numToCopy; i++) { + phFirmware[i] = handleList[i]->toHandle(); + } + } + return ZE_RESULT_SUCCESS; +} +} // namespace Sysman +} // namespace L0 diff --git a/level_zero/sysman/source/firmware/firmware.h b/level_zero/sysman/source/firmware/firmware.h new file mode 100644 index 0000000000..03a2b1658b --- /dev/null +++ b/level_zero/sysman/source/firmware/firmware.h @@ -0,0 +1,55 @@ +/* + * Copyright (C) 2020-2023 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#pragma once +#include "level_zero/api/sysman/zes_handles_struct.h" +#include + +#include +#include +#include + +namespace L0 { +namespace Sysman { +struct OsSysman; + +class Firmware : _zes_firmware_handle_t { + public: + ~Firmware() override {} + virtual ze_result_t firmwareGetProperties(zes_firmware_properties_t *pProperties) = 0; + virtual ze_result_t firmwareFlash(void *pImage, uint32_t size) = 0; + + inline zes_firmware_handle_t toHandle() { return this; } + + static Firmware *fromHandle(zes_firmware_handle_t handle) { + return static_cast(handle); + } +}; + +struct FirmwareHandleContext { + FirmwareHandleContext(OsSysman *pOsSysman) : pOsSysman(pOsSysman){}; + MOCKABLE_VIRTUAL ~FirmwareHandleContext(); + void releaseFwHandles(); + + MOCKABLE_VIRTUAL void init(); + + ze_result_t firmwareGet(uint32_t *pCount, zes_firmware_handle_t *phFirmware); + + OsSysman *pOsSysman = nullptr; + std::vector handleList = {}; + bool isFirmwareInitDone() { + return firmwareInitDone; + } + + private: + void createHandle(const std::string &fwType); + std::once_flag initFirmwareOnce; + bool firmwareInitDone = false; +}; + +} // namespace Sysman +} // namespace L0 diff --git a/level_zero/sysman/source/firmware/firmware_imp.cpp b/level_zero/sysman/source/firmware/firmware_imp.cpp new file mode 100644 index 0000000000..1b3178a230 --- /dev/null +++ b/level_zero/sysman/source/firmware/firmware_imp.cpp @@ -0,0 +1,41 @@ +/* + * Copyright (C) 2020-2023 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#include "level_zero/sysman/source/firmware/firmware_imp.h" + +#include "shared/source/helpers/debug_helpers.h" + +#include "level_zero/sysman/source/firmware/os_firmware.h" + +namespace L0 { +namespace Sysman { + +ze_result_t FirmwareImp::firmwareGetProperties(zes_firmware_properties_t *pProperties) { + pOsFirmware->osGetFwProperties(pProperties); + std::string fwName = fwType; + if (fwName == "GSC") { + fwName = "GFX"; + } + strncpy_s(pProperties->name, ZES_STRING_PROPERTY_SIZE, fwName.c_str(), fwName.size()); + return ZE_RESULT_SUCCESS; +} + +ze_result_t FirmwareImp::firmwareFlash(void *pImage, uint32_t size) { + return pOsFirmware->osFirmwareFlash(pImage, size); +} + +FirmwareImp::FirmwareImp(OsSysman *pOsSysman, const std::string &initalizedFwType) { + pOsFirmware = OsFirmware::create(pOsSysman, initalizedFwType); + fwType = initalizedFwType; + UNRECOVERABLE_IF(nullptr == pOsFirmware); +} + +FirmwareImp::~FirmwareImp() { +} + +} // namespace Sysman +} // namespace L0 diff --git a/level_zero/sysman/source/firmware/firmware_imp.h b/level_zero/sysman/source/firmware/firmware_imp.h new file mode 100644 index 0000000000..3a819ab4ff --- /dev/null +++ b/level_zero/sysman/source/firmware/firmware_imp.h @@ -0,0 +1,34 @@ +/* + * Copyright (C) 2020-2023 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#pragma once +#include "shared/source/helpers/non_copyable_or_moveable.h" +#include "shared/source/helpers/string.h" + +#include "level_zero/sysman/source/firmware/firmware.h" +#include "level_zero/sysman/source/firmware/os_firmware.h" +#include + +namespace L0 { +namespace Sysman { + +class OsFirmware; + +class FirmwareImp : public Firmware, NEO::NonCopyableOrMovableClass { + public: + ze_result_t firmwareGetProperties(zes_firmware_properties_t *pProperties) override; + ze_result_t firmwareFlash(void *pImage, uint32_t size) override; + FirmwareImp() = default; + FirmwareImp(OsSysman *pOsSysman, const std::string &fwType); + ~FirmwareImp() override; + std::unique_ptr pOsFirmware = nullptr; + std::string fwType = "Unknown"; + + void init(); +}; +} // namespace Sysman +} // namespace L0 diff --git a/level_zero/sysman/source/firmware/linux/CMakeLists.txt b/level_zero/sysman/source/firmware/linux/CMakeLists.txt new file mode 100644 index 0000000000..eca5c7bd62 --- /dev/null +++ b/level_zero/sysman/source/firmware/linux/CMakeLists.txt @@ -0,0 +1,26 @@ +# +# Copyright (C) 2020-2023 Intel Corporation +# +# SPDX-License-Identifier: MIT +# + +if(UNIX) + target_sources(${L0_STATIC_LIB_NAME} + PRIVATE + ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt + ${CMAKE_CURRENT_SOURCE_DIR}/os_firmware_imp.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/os_firmware_imp.h + ) + + if(NEO_ENABLE_i915_PRELIM_DETECTION) + target_sources(${L0_STATIC_LIB_NAME} + PRIVATE + ${CMAKE_CURRENT_SOURCE_DIR}/os_firmware_imp_helper_prelim.cpp + ) + else() + target_sources(${L0_STATIC_LIB_NAME} + PRIVATE + ${CMAKE_CURRENT_SOURCE_DIR}/os_firmware_imp_helper.cpp + ) + endif() +endif() diff --git a/level_zero/sysman/source/firmware/linux/os_firmware_imp.cpp b/level_zero/sysman/source/firmware/linux/os_firmware_imp.cpp new file mode 100644 index 0000000000..e716932a27 --- /dev/null +++ b/level_zero/sysman/source/firmware/linux/os_firmware_imp.cpp @@ -0,0 +1,72 @@ +/* + * Copyright (C) 2020-2023 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#include "level_zero/sysman/source/firmware/linux/os_firmware_imp.h" + +#include "shared/source/helpers/string.h" + +#include "level_zero/sysman/source/firmware_util/firmware_util.h" +#include "level_zero/sysman/source/linux/fs_access.h" +#include "level_zero/sysman/source/sysman_const.h" + +#include + +namespace L0 { +namespace Sysman { + +static const std::string mtdDescriptor("/proc/mtd"); + +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 = {}; + ze_result_t result = pFsAccess->read(mtdDescriptor, mtdDescriptorStrings); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + for (const auto &readByteLine : mtdDescriptorStrings) { + for (const auto &fwType : deviceSupportedFwTypes) { + if (std::string::npos != readByteLine.find(fwType)) { + if (std::find(supportedFwTypes.begin(), supportedFwTypes.end(), fwType) == supportedFwTypes.end()) { + supportedFwTypes.push_back(fwType); + } + } + } + } + return ZE_RESULT_SUCCESS; +} + +void LinuxFirmwareImp::osGetFwProperties(zes_firmware_properties_t *pProperties) { + if (ZE_RESULT_SUCCESS != getFirmwareVersion(osFwType, pProperties)) { + strncpy_s(static_cast(pProperties->version), ZES_STRING_PROPERTY_SIZE, unknown.c_str(), ZES_STRING_PROPERTY_SIZE - 1); + } + pProperties->canControl = true; // Assuming that user has permission to flash the firmware +} + +ze_result_t LinuxFirmwareImp::osFirmwareFlash(void *pImage, uint32_t size) { + return pFwInterface->flashFirmware(osFwType, pImage, size); +} + +LinuxFirmwareImp::LinuxFirmwareImp(OsSysman *pOsSysman, const std::string &fwType) : osFwType(fwType) { + LinuxSysmanImp *pLinuxSysmanImp = static_cast(pOsSysman); + pSysfsAccess = &pLinuxSysmanImp->getSysfsAccess(); + pFwInterface = pLinuxSysmanImp->getFwUtilInterface(); +} + +std::unique_ptr OsFirmware::create(OsSysman *pOsSysman, const std::string &fwType) { + std::unique_ptr pLinuxFirmwareImp = std::make_unique(pOsSysman, fwType); + return pLinuxFirmwareImp; +} + +} // namespace Sysman +} // namespace L0 diff --git a/level_zero/sysman/source/firmware/linux/os_firmware_imp.h b/level_zero/sysman/source/firmware/linux/os_firmware_imp.h new file mode 100644 index 0000000000..be9c147da8 --- /dev/null +++ b/level_zero/sysman/source/firmware/linux/os_firmware_imp.h @@ -0,0 +1,36 @@ +/* + * Copyright (C) 2020-2023 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#pragma once +#include "shared/source/helpers/non_copyable_or_moveable.h" + +#include "level_zero/sysman/source/firmware/firmware_imp.h" +#include "level_zero/sysman/source/firmware/os_firmware.h" +#include "level_zero/sysman/source/linux/os_sysman_imp.h" + +namespace L0 { +namespace Sysman { + +class FirmwareUtil; + +class LinuxFirmwareImp : public OsFirmware, NEO::NonCopyableOrMovableClass { + public: + void osGetFwProperties(zes_firmware_properties_t *pProperties) override; + ze_result_t osFirmwareFlash(void *pImage, uint32_t size) override; + ze_result_t getFirmwareVersion(std::string fwType, zes_firmware_properties_t *pProperties); + LinuxFirmwareImp() = default; + LinuxFirmwareImp(OsSysman *pOsSysman, const std::string &fwType); + ~LinuxFirmwareImp() override = default; + + protected: + FirmwareUtil *pFwInterface = nullptr; + SysfsAccess *pSysfsAccess = nullptr; + std::string osFwType; +}; + +} // namespace Sysman +} // namespace L0 diff --git a/level_zero/sysman/source/firmware/linux/os_firmware_imp_helper.cpp b/level_zero/sysman/source/firmware/linux/os_firmware_imp_helper.cpp new file mode 100644 index 0000000000..1aec12553c --- /dev/null +++ b/level_zero/sysman/source/firmware/linux/os_firmware_imp_helper.cpp @@ -0,0 +1,24 @@ +/* + * Copyright (C) 2021-2023 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#include "level_zero/sysman/source/firmware/linux/os_firmware_imp.h" +#include "level_zero/sysman/source/firmware_util/firmware_util.h" + +namespace L0 { +namespace Sysman { + +ze_result_t LinuxFirmwareImp::getFirmwareVersion(std::string fwType, zes_firmware_properties_t *pProperties) { + std::string fwVersion; + ze_result_t result = pFwInterface->getFwVersion(fwType, fwVersion); + if (ZE_RESULT_SUCCESS == result) { + strncpy_s(static_cast(pProperties->version), ZES_STRING_PROPERTY_SIZE, fwVersion.c_str(), ZES_STRING_PROPERTY_SIZE - 1); + } + return result; +} + +} // namespace Sysman +} // namespace L0 diff --git a/level_zero/sysman/source/firmware/linux/os_firmware_imp_helper_prelim.cpp b/level_zero/sysman/source/firmware/linux/os_firmware_imp_helper_prelim.cpp new file mode 100644 index 0000000000..b1ab9414ec --- /dev/null +++ b/level_zero/sysman/source/firmware/linux/os_firmware_imp_helper_prelim.cpp @@ -0,0 +1,60 @@ +/* + * Copyright (C) 2021-2023 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#include "level_zero/sysman/source/firmware/linux/os_firmware_imp.h" +#include "level_zero/sysman/source/firmware_util/firmware_util.h" +#include "level_zero/sysman/source/linux/fs_access.h" + +const std::string iafPath = "device/"; +const std::string iafDirectory = "iaf."; +const std::string pscbin_version = "/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 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 + 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 + pscbin_version; + } + } + if (path.empty()) { + // This device does not have a PSC Version + 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 + return result; + } + strncpy_s(static_cast(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(pProperties->version), ZES_STRING_PROPERTY_SIZE, fwVersion.c_str(), ZES_STRING_PROPERTY_SIZE - 1); + } + + return result; +} + +} // namespace Sysman +} // namespace L0 diff --git a/level_zero/sysman/source/firmware/os_firmware.h b/level_zero/sysman/source/firmware/os_firmware.h new file mode 100644 index 0000000000..2123d2fcbc --- /dev/null +++ b/level_zero/sysman/source/firmware/os_firmware.h @@ -0,0 +1,28 @@ +/* + * Copyright (C) 2020-2023 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#pragma once + +#include "level_zero/sysman/source/os_sysman.h" +#include + +#include +#include +#include + +namespace L0 { +namespace Sysman { +class OsFirmware { + public: + virtual void osGetFwProperties(zes_firmware_properties_t *pProperties) = 0; + virtual ze_result_t osFirmwareFlash(void *pImage, uint32_t size) = 0; + static std::unique_ptr create(OsSysman *pOsSysman, const std::string &fwType); + static ze_result_t getSupportedFwTypes(std::vector &supportedFwTypes, OsSysman *pOsSysman); + virtual ~OsFirmware() {} +}; +} // namespace Sysman +} // namespace L0 diff --git a/level_zero/sysman/source/firmware/windows/CMakeLists.txt b/level_zero/sysman/source/firmware/windows/CMakeLists.txt new file mode 100644 index 0000000000..3f522bdf49 --- /dev/null +++ b/level_zero/sysman/source/firmware/windows/CMakeLists.txt @@ -0,0 +1,14 @@ +# +# Copyright (C) 2020-2023 Intel Corporation +# +# SPDX-License-Identifier: MIT +# + +if(WIN32) + target_sources(${L0_STATIC_LIB_NAME} + PRIVATE + ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt + ${CMAKE_CURRENT_SOURCE_DIR}/os_firmware_imp.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/os_firmware_imp.h + ) +endif() diff --git a/level_zero/sysman/source/firmware/windows/os_firmware_imp.cpp b/level_zero/sysman/source/firmware/windows/os_firmware_imp.cpp new file mode 100644 index 0000000000..856aa38d62 --- /dev/null +++ b/level_zero/sysman/source/firmware/windows/os_firmware_imp.cpp @@ -0,0 +1,29 @@ +/* + * Copyright (C) 2020-2023 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#include "level_zero/sysman/source/firmware/windows/os_firmware_imp.h" + +#include "level_zero/sysman/source/windows/os_sysman_imp.h" + +namespace L0 { +namespace Sysman { + +ze_result_t WddmFirmwareImp::osFirmwareFlash(void *pImage, uint32_t size) { + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; +} + +std::unique_ptr OsFirmware::create(OsSysman *pOsSysman, const std::string &fwType) { + std::unique_ptr pWddmFirmwareImp = std::make_unique(pOsSysman, fwType); + return pWddmFirmwareImp; +} + +ze_result_t OsFirmware::getSupportedFwTypes(std::vector &supportedFwTypes, OsSysman *pOsSysman) { + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; +} + +} // namespace Sysman +} // namespace L0 diff --git a/level_zero/sysman/source/firmware/windows/os_firmware_imp.h b/level_zero/sysman/source/firmware/windows/os_firmware_imp.h new file mode 100644 index 0000000000..b87101fb0c --- /dev/null +++ b/level_zero/sysman/source/firmware/windows/os_firmware_imp.h @@ -0,0 +1,26 @@ +/* + * Copyright (C) 2020-2023 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#pragma once +#include "shared/source/helpers/non_copyable_or_moveable.h" + +#include "level_zero/sysman/source/firmware/os_firmware.h" + +namespace L0 { +namespace Sysman { +class FirmwareUtil; +class WddmFirmwareImp : public OsFirmware { + public: + void osGetFwProperties(zes_firmware_properties_t *pProperties) override {} + ze_result_t osFirmwareFlash(void *pImage, uint32_t size) override; + WddmFirmwareImp() = default; + WddmFirmwareImp(OsSysman *pOsSysman, const std::string &fwType) {} + ~WddmFirmwareImp() override = default; +}; + +} // namespace Sysman +} // namespace L0 diff --git a/level_zero/sysman/source/sysman_device.cpp b/level_zero/sysman/source/sysman_device.cpp index 80c758fa80..11f8e0bae8 100644 --- a/level_zero/sysman/source/sysman_device.cpp +++ b/level_zero/sysman/source/sysman_device.cpp @@ -60,5 +60,10 @@ ze_result_t SysmanDevice::schedulerGet(zes_device_handle_t hDevice, uint32_t *pC return pSysmanDevice->schedulerGet(pCount, phScheduler); } +ze_result_t SysmanDevice::firmwareGet(zes_device_handle_t hDevice, uint32_t *pCount, zes_firmware_handle_t *phFirmware) { + auto pSysmanDevice = L0::Sysman::SysmanDevice::fromHandle(hDevice); + return pSysmanDevice->firmwareGet(pCount, phFirmware); +} + } // namespace Sysman } // namespace L0 diff --git a/level_zero/sysman/source/sysman_device.h b/level_zero/sysman/source/sysman_device.h index bf52c43dd7..7648df2e16 100644 --- a/level_zero/sysman/source/sysman_device.h +++ b/level_zero/sysman/source/sysman_device.h @@ -11,6 +11,7 @@ #include "level_zero/core/source/device/device.h" #include "level_zero/sysman/source/engine/engine.h" #include "level_zero/sysman/source/fabric_port/fabric_port.h" +#include "level_zero/sysman/source/firmware/firmware.h" #include "level_zero/sysman/source/frequency/frequency.h" #include "level_zero/sysman/source/memory/memory.h" #include "level_zero/sysman/source/power/power.h" @@ -45,6 +46,9 @@ struct SysmanDevice : _ze_device_handle_t { static ze_result_t schedulerGet(zes_device_handle_t hDevice, uint32_t *pCount, zes_sched_handle_t *phScheduler); virtual ze_result_t schedulerGet(uint32_t *pCount, zes_sched_handle_t *phScheduler) = 0; + + static ze_result_t firmwareGet(zes_device_handle_t hDevice, uint32_t *pCount, zes_firmware_handle_t *phFirmware); + virtual ze_result_t firmwareGet(uint32_t *pCount, zes_firmware_handle_t *phFirmware) = 0; }; } // namespace Sysman diff --git a/level_zero/sysman/source/sysman_device_imp.cpp b/level_zero/sysman/source/sysman_device_imp.cpp index 8ad57a569c..9aa363ba35 100644 --- a/level_zero/sysman/source/sysman_device_imp.cpp +++ b/level_zero/sysman/source/sysman_device_imp.cpp @@ -27,6 +27,7 @@ SysmanDeviceImp::SysmanDeviceImp(NEO::ExecutionEnvironment *executionEnvironment pEngineHandleContext = new EngineHandleContext(pOsSysman); pFrequencyHandleContext = new FrequencyHandleContext(pOsSysman); pSchedulerHandleContext = new SchedulerHandleContext(pOsSysman); + pFirmwareHandleContext = new FirmwareHandleContext(pOsSysman); } SysmanDeviceImp::~SysmanDeviceImp() { @@ -37,6 +38,7 @@ SysmanDeviceImp::~SysmanDeviceImp() { freeResource(pFabricPortHandleContext); freeResource(pMemoryHandleContext); freeResource(pFrequencyHandleContext); + freeResource(pFirmwareHandleContext); freeResource(pOsSysman); } @@ -76,5 +78,9 @@ ze_result_t SysmanDeviceImp::schedulerGet(uint32_t *pCount, zes_sched_handle_t * return pSchedulerHandleContext->schedulerGet(pCount, phScheduler); } +ze_result_t SysmanDeviceImp::firmwareGet(uint32_t *pCount, zes_firmware_handle_t *phFirmware) { + return pFirmwareHandleContext->firmwareGet(pCount, phFirmware); +} + } // namespace Sysman } // namespace L0 diff --git a/level_zero/sysman/source/sysman_device_imp.h b/level_zero/sysman/source/sysman_device_imp.h index c2f6d7e0cc..cc922823b1 100644 --- a/level_zero/sysman/source/sysman_device_imp.h +++ b/level_zero/sysman/source/sysman_device_imp.h @@ -45,6 +45,7 @@ struct SysmanDeviceImp : SysmanDevice, NEO::NonCopyableOrMovableClass { MemoryHandleContext *pMemoryHandleContext = nullptr; EngineHandleContext *pEngineHandleContext = nullptr; SchedulerHandleContext *pSchedulerHandleContext = nullptr; + FirmwareHandleContext *pFirmwareHandleContext = nullptr; ze_result_t memoryGet(uint32_t *pCount, zes_mem_handle_t *phMemory) override; ze_result_t fabricPortGet(uint32_t *pCount, zes_fabric_port_handle_t *phPort) override; @@ -53,6 +54,7 @@ struct SysmanDeviceImp : SysmanDevice, NEO::NonCopyableOrMovableClass { FrequencyHandleContext *pFrequencyHandleContext = nullptr; ze_result_t frequencyGet(uint32_t *pCount, zes_freq_handle_t *phFrequency) override; + ze_result_t firmwareGet(uint32_t *pCount, zes_firmware_handle_t *phFirmware) override; private: NEO::ExecutionEnvironment *executionEnvironment = nullptr; diff --git a/level_zero/sysman/test/unit_tests/sources/firmware/CMakeLists.txt b/level_zero/sysman/test/unit_tests/sources/firmware/CMakeLists.txt new file mode 100644 index 0000000000..ffeb6e3a80 --- /dev/null +++ b/level_zero/sysman/test/unit_tests/sources/firmware/CMakeLists.txt @@ -0,0 +1,11 @@ +# +# Copyright (C) 2020-2023 Intel Corporation +# +# SPDX-License-Identifier: MIT +# + +target_sources(${TARGET_NAME} PRIVATE + ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt +) + +add_subdirectories() diff --git a/level_zero/sysman/test/unit_tests/sources/firmware/linux/CMakeLists.txt b/level_zero/sysman/test/unit_tests/sources/firmware/linux/CMakeLists.txt new file mode 100644 index 0000000000..5c0150a8b6 --- /dev/null +++ b/level_zero/sysman/test/unit_tests/sources/firmware/linux/CMakeLists.txt @@ -0,0 +1,29 @@ +# +# Copyright (C) 2020-2023 Intel Corporation +# +# SPDX-License-Identifier: MIT +# + +set(L0_TESTS_SYSMAN_FIRMWARE_LINUX + ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt +) + +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 + ${L0_TESTS_SYSMAN_FIRMWARE_LINUX} + ) +endif() diff --git a/level_zero/sysman/test/unit_tests/sources/firmware/linux/mock_zes_sysman_firmware.h b/level_zero/sysman/test/unit_tests/sources/firmware/linux/mock_zes_sysman_firmware.h new file mode 100644 index 0000000000..54a44716d3 --- /dev/null +++ b/level_zero/sysman/test/unit_tests/sources/firmware/linux/mock_zes_sysman_firmware.h @@ -0,0 +1,87 @@ +/* + * Copyright (C) 2020-2023 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#pragma once +#include "level_zero/sysman/source/firmware/linux/os_firmware_imp.h" +#include "level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_fixture.h" + +namespace L0 { +namespace ult { + +constexpr uint32_t mockHandleCount = 2; +const std::string mockFwVersion("DG01->0->2026"); +const std::string mockOpromVersion("OPROM CODE VERSION:123_OPROM DATA VERSION:456"); +std::vector mockSupportedFwTypes = {"GSC", "OptionROM"}; +std::vector mockUnsupportedFwTypes = {"unknown"}; +std::string mockEmpty = {}; +class FirmwareInterface : public L0::Sysman::FirmwareUtil {}; +class FirmwareFsAccess : public L0::Sysman::FsAccess {}; + +struct MockFirmwareFsAccess : public FirmwareFsAccess { + ze_bool_t isReadFwTypes = true; + ze_result_t read(const std::string file, std::vector &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\""); + } 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 MockFirmwareInterface : public L0::Sysman::FirmwareUtil { + + 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 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; + } + return ZE_RESULT_SUCCESS; + } + + void getDeviceSupportedFwTypes(std::vector &fwTypes) override { + fwTypes = mockSupportedFwTypes; + } + + MockFirmwareInterface() = default; + + ADDMETHOD_NOBASE(fwDeviceInit, ze_result_t, ZE_RESULT_SUCCESS, ()); + ADDMETHOD_NOBASE(getFirstDevice, ze_result_t, ZE_RESULT_SUCCESS, (igsc_device_info * info)); + 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 & 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 L0 diff --git a/level_zero/sysman/test/unit_tests/sources/firmware/linux/mock_zes_sysman_firmware_prelim.h b/level_zero/sysman/test/unit_tests/sources/firmware/linux/mock_zes_sysman_firmware_prelim.h new file mode 100644 index 0000000000..a59e38816b --- /dev/null +++ b/level_zero/sysman/test/unit_tests/sources/firmware/linux/mock_zes_sysman_firmware_prelim.h @@ -0,0 +1,135 @@ +/* + * Copyright (C) 2022-2023 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#pragma once +#include "level_zero/sysman/source/firmware/linux/os_firmware_imp.h" +#include "level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_fixture.h" + +namespace L0 { +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 mockSupportedFirmwareTypes = {"GSC", "OptionROM", "PSC"}; +std::vector mockUnsupportedFwTypes = {"unknown"}; +std::string mockEmpty = {}; +class FirmwareInterface : public L0::Sysman::FirmwareUtil {}; +class FirmwareFsAccess : public L0::Sysman::FsAccess {}; +class FirmwareSysfsAccess : public L0::Sysman::SysfsAccess {}; + +struct MockFirmwareFsAccess : public FirmwareFsAccess { + ze_bool_t isReadFwTypes = true; + ze_result_t read(const std::string file, std::vector &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::SysfsAccess { + + 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 &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 &fwTypes) override { + fwTypes = mockSupportedFirmwareTypes; + } + + MockFirmwareInterface() = default; + + ADDMETHOD_NOBASE(fwDeviceInit, ze_result_t, ZE_RESULT_SUCCESS, ()); + ADDMETHOD_NOBASE(getFirstDevice, ze_result_t, ZE_RESULT_SUCCESS, (igsc_device_info * info)); + 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 & 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 L0 diff --git a/level_zero/sysman/test/unit_tests/sources/firmware/linux/test_zes_sysman_firmware.cpp b/level_zero/sysman/test/unit_tests/sources/firmware/linux/test_zes_sysman_firmware.cpp new file mode 100644 index 0000000000..bfdd0b768d --- /dev/null +++ b/level_zero/sysman/test/unit_tests/sources/firmware/linux/test_zes_sysman_firmware.cpp @@ -0,0 +1,258 @@ +/* + * Copyright (C) 2020-2023 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#include "level_zero/sysman/test/unit_tests/sources/firmware/linux/mock_zes_sysman_firmware.h" + +namespace L0 { +namespace ult { + +class ZesFirmwareFixture : public SysmanDeviceFixture { + + protected: + zes_firmware_handle_t hSysmanFirmware = {}; + std::unique_ptr pMockFwInterface; + L0::Sysman::FirmwareUtil *pFwUtilInterfaceOld = nullptr; + std::unique_ptr pFsAccess; + L0::Sysman::FsAccess *pFsAccessOriginal = nullptr; + L0::Sysman::SysmanDevice *device = nullptr; + + void SetUp() override { + SysmanDeviceFixture::SetUp(); + pFsAccessOriginal = pLinuxSysmanImp->pFsAccess; + pFsAccess = std::make_unique(); + pLinuxSysmanImp->pFsAccess = pFsAccess.get(); + + pFwUtilInterfaceOld = pLinuxSysmanImp->pFwUtilInterface; + pMockFwInterface = std::make_unique(); + 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); + } + std::vector getFirmwareHandles(uint32_t count) { + std::vector handles(count, nullptr); + EXPECT_EQ(zesDeviceEnumFirmwares(device->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS); + return handles; + } +}; + +TEST_F(ZesFirmwareFixture, GivenComponentCountZeroWhenCallingzesFirmwareGetThenZeroCountIsReturnedAndVerifyzesFirmwareGetCallSucceeds) { + std::vector firmwareHandle{}; + uint32_t count = 0; + + ze_result_t result = zesDeviceEnumFirmwares(device->toHandle(), &count, nullptr); + + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + EXPECT_EQ(count, mockHandleCount); + + 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, mockHandleCount); + + L0::Sysman::FirmwareImp *ptestFirmwareImp = new L0::Sysman::FirmwareImp(pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman, mockSupportedFwTypes[0]); + pSysmanDeviceImp->pFirmwareHandleContext->handleList.push_back(ptestFirmwareImp); + result = zesDeviceEnumFirmwares(device->toHandle(), &count, nullptr); + + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + EXPECT_EQ(count, mockHandleCount); + + 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, mockHandleCount); + + pSysmanDeviceImp->pFirmwareHandleContext->handleList.pop_back(); + delete ptestFirmwareImp; +} + +TEST_F(ZesFirmwareFixture, GivenValidFirmwareHandleWhenGettingFirmwarePropertiesThenVersionIsReturned) { + initFirmware(); + + L0::Sysman::FirmwareImp *ptestFirmwareImp = new L0::Sysman::FirmwareImp(pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman, mockSupportedFwTypes[0]); + pSysmanDeviceImp->pFirmwareHandleContext->handleList.push_back(ptestFirmwareImp); + + auto handles = getFirmwareHandles(mockHandleCount); + + 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; +} + +TEST_F(ZesFirmwareFixture, GivenValidFirmwareHandleWhenGettingOptionRomPropertiesThenVersionIsReturned) { + 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 = {}; + 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; +} + +TEST_F(ZesFirmwareFixture, GivenValidFirmwareHandleWhenGettingOpromPropertiesThenVersionIsReturned) { + 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 = {}; + 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; +} + +TEST_F(ZesFirmwareFixture, GivenRepeatedFWTypesWhenInitializingFirmwareContextThenexpectNoHandles) { + 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()); +} + +TEST_F(ZesFirmwareFixture, GivenValidFirmwareHandleWhenFlashingGscFirmwareThenSuccessIsReturned) { + initFirmware(); + + L0::Sysman::FirmwareImp *ptestFirmwareImp = new L0::Sysman::FirmwareImp(pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman, mockSupportedFwTypes[0]); + pSysmanDeviceImp->pFirmwareHandleContext->handleList.push_back(ptestFirmwareImp); + + auto handles = getFirmwareHandles(mockHandleCount); + uint8_t testImage[ZES_STRING_PROPERTY_SIZE] = {}; + memset(testImage, 0xA, ZES_STRING_PROPERTY_SIZE); + for (auto handle : handles) { + EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareFlash(handle, (void *)testImage, ZES_STRING_PROPERTY_SIZE)); + } + pSysmanDeviceImp->pFirmwareHandleContext->handleList.pop_back(); + delete ptestFirmwareImp; +} + +TEST_F(ZesFirmwareFixture, 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; +} + +TEST_F(ZesFirmwareFixture, GivenNewFirmwareContextWithHandleSizeZeroWhenFirmwareEnumerateIsCalledThenSuccessResultIsReturned) { + 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(true, (count > 0)); +} + +TEST_F(ZesFirmwareFixture, GivenValidFirmwareHandleFirmwareLibraryCallFailureWhenGettingFirmwarePropertiesThenUnknownIsReturned) { + for (const auto &handle : pSysmanDeviceImp->pFirmwareHandleContext->handleList) { + delete handle; + } + pSysmanDeviceImp->pFirmwareHandleContext->handleList.clear(); + pMockFwInterface->getFwVersionResult = ZE_RESULT_ERROR_UNINITIALIZED; + + pSysmanDeviceImp->pFirmwareHandleContext->init(); + auto handles = getFirmwareHandles(mockHandleCount); + + zes_firmware_properties_t properties = {}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareGetProperties(handles[0], &properties)); + EXPECT_STREQ("GFX", properties.name); + EXPECT_STREQ("unknown", properties.version); + + EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareGetProperties(handles[1], &properties)); + EXPECT_STREQ(mockSupportedFwTypes[1].c_str(), properties.name); + EXPECT_STREQ("unknown", properties.version); +} + +class ZesFirmwareUninitializedFixture : public SysmanDeviceFixture { + + protected: + zes_firmware_handle_t hSysmanFirmware = {}; + std::unique_ptr pMockFwInterface; + L0::Sysman::FirmwareUtil *pFwUtilInterfaceOld = nullptr; + std::unique_ptr pFsAccess; + L0::Sysman::FsAccess *pFsAccessOriginal = nullptr; + + void SetUp() override { + SysmanDeviceFixture::SetUp(); + pFsAccessOriginal = pLinuxSysmanImp->pFsAccess; + pFsAccess = std::make_unique(); + pLinuxSysmanImp->pFsAccess = pFsAccess.get(); + + pFwUtilInterfaceOld = pLinuxSysmanImp->pFwUtilInterface; + pLinuxSysmanImp->pFwUtilInterface = nullptr; + } + void TearDown() override { + SysmanDeviceFixture::TearDown(); + pLinuxSysmanImp->pFwUtilInterface = pFwUtilInterfaceOld; + pLinuxSysmanImp->pFsAccess = pFsAccessOriginal; + } +}; + +} // namespace ult +} // namespace L0 diff --git a/level_zero/sysman/test/unit_tests/sources/firmware/linux/test_zes_sysman_firmware_prelim.cpp b/level_zero/sysman/test/unit_tests/sources/firmware/linux/test_zes_sysman_firmware_prelim.cpp new file mode 100644 index 0000000000..39e79c8e51 --- /dev/null +++ b/level_zero/sysman/test/unit_tests/sources/firmware/linux/test_zes_sysman_firmware_prelim.cpp @@ -0,0 +1,307 @@ +/* + * Copyright (C) 2022-2023 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#include "level_zero/sysman/test/unit_tests/sources/firmware/linux/mock_zes_sysman_firmware_prelim.h" + +namespace L0 { +namespace ult { + +class ZesSysmanFirmwareFixture : public SysmanDeviceFixture { + + protected: + zes_firmware_handle_t hSysmanFirmware = {}; + std::unique_ptr pMockFwInterface; + L0::Sysman::FirmwareUtil *pFwUtilInterfaceOld = nullptr; + std::unique_ptr pFsAccess; + L0::Sysman::FsAccess *pFsAccessOriginal = nullptr; + MockFirmwareSysfsAccess *pMockSysfsAccess = nullptr; + L0::Sysman::SysmanDevice *device = nullptr; + + void SetUp() override { + SysmanDeviceFixture::SetUp(); + pFsAccessOriginal = pLinuxSysmanImp->pFsAccess; + pFsAccess = std::make_unique(); + pLinuxSysmanImp->pFsAccess = pFsAccess.get(); + + pMockSysfsAccess = new MockFirmwareSysfsAccess(); + delete pLinuxSysmanImp->pSysfsAccess; + pLinuxSysmanImp->pSysfsAccess = pMockSysfsAccess; + + pFwUtilInterfaceOld = pLinuxSysmanImp->pFwUtilInterface; + pMockFwInterface = std::make_unique(); + 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; + SysmanDeviceFixture::TearDown(); + } + + std::vector getFirmwareHandles(uint32_t count) { + std::vector handles(count, nullptr); + EXPECT_EQ(zesDeviceEnumFirmwares(device->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS); + return handles; + } +}; + +TEST_F(ZesSysmanFirmwareFixture, GivenComponentCountZeroWhenCallingzesFirmwareGetThenZeroCountIsReturnedAndVerifyzesFirmwareGetCallSucceeds) { + std::vector 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, GivenValidFirmwareHandleWhenGettingFirmwarePropertiesThenVersionIsReturned) { + initFirmware(); + + L0::Sysman::FirmwareImp *ptestFirmwareImp = new L0::Sysman::FirmwareImp(pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman, mockSupportedFirmwareTypes[0]); + pSysmanDeviceImp->pFirmwareHandleContext->handleList.push_back(ptestFirmwareImp); + + auto handles = getFirmwareHandles(mockFwHandlesCount); + + 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; +} + +TEST_F(ZesSysmanFirmwareFixture, GivenValidFirmwareHandleWhenGettingPscPropertiesThenVersionIsReturned) { + initFirmware(); + + L0::Sysman::FirmwareImp *ptestFirmwareImp = new L0::Sysman::FirmwareImp(pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman, mockSupportedFirmwareTypes[2]); + pSysmanDeviceImp->pFirmwareHandleContext->handleList.push_back(ptestFirmwareImp); + + auto handles = getFirmwareHandles(mockFwHandlesCount); + + 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; +} + +TEST_F(ZesSysmanFirmwareFixture, GivenNullDirEntriesWhenGettingPscPropertiesThenUnknownVersionIsReturned) { + 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 = {}; + 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; +} + +TEST_F(ZesSysmanFirmwareFixture, GivenValidFirmwareHandleWhenFailedToReadPSCVersionFromSysfsThenUnknownVersionIsReturned) { + 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); + + 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; +} + +TEST_F(ZesSysmanFirmwareFixture, GivenRepeatedFWTypesWhenInitializingFirmwareContextThenexpectNoHandles) { + 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()); +} + +TEST_F(ZesSysmanFirmwareFixture, GivenValidFirmwareHandleWhenFlashingGscFirmwareThenSuccessIsReturned) { + 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) { + EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareFlash(handle, (void *)testImage, ZES_STRING_PROPERTY_SIZE)); + } + pSysmanDeviceImp->pFirmwareHandleContext->handleList.pop_back(); + delete ptestFirmwareImp; +} + +TEST_F(ZesSysmanFirmwareFixture, GivenValidFirmwareHandleWhenFlashingPscFirmwareThenSuccessIsReturned) { + 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) { + 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; +} + +TEST_F(ZesSysmanFirmwareFixture, GivenValidFirmwareHandleFirmwareLibraryCallFailureWhenGettingFirmwarePropertiesThenUnknownIsReturned) { + 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 = {}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareGetProperties(handles[0], &properties)); + EXPECT_STREQ("GFX", properties.name); + EXPECT_STREQ("unknown", properties.version); + + EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareGetProperties(handles[1], &properties)); + EXPECT_STREQ(mockSupportedFirmwareTypes[1].c_str(), properties.name); + EXPECT_STREQ("unknown", properties.version); + + EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareGetProperties(handles[2], &properties)); + EXPECT_STREQ(mockSupportedFirmwareTypes[2].c_str(), properties.name); + EXPECT_STREQ("unknown", properties.version); +} + +TEST_F(ZesSysmanFirmwareFixture, GivenNewFirmwareContextWithHandleSizeZeroWhenFirmwareEnumerateIsCalledThenSuccessResultIsReturned) { + 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); +} + +class ZesFirmwareUninitializedFixture : public SysmanDeviceFixture { + + protected: + zes_firmware_handle_t hSysmanFirmware = {}; + std::unique_ptr pMockFwInterface; + L0::Sysman::FirmwareUtil *pFwUtilInterfaceOld = nullptr; + std::unique_ptr pFsAccess; + L0::Sysman::FsAccess *pFsAccessOriginal = nullptr; + + void SetUp() override { + SysmanDeviceFixture::SetUp(); + pFsAccessOriginal = pLinuxSysmanImp->pFsAccess; + pFsAccess = std::make_unique(); + pLinuxSysmanImp->pFsAccess = pFsAccess.get(); + + pFwUtilInterfaceOld = pLinuxSysmanImp->pFwUtilInterface; + pLinuxSysmanImp->pFwUtilInterface = nullptr; + } + void TearDown() override { + SysmanDeviceFixture::TearDown(); + pLinuxSysmanImp->pFwUtilInterface = pFwUtilInterfaceOld; + pLinuxSysmanImp->pFsAccess = pFsAccessOriginal; + } +}; + +} // namespace ult +} // namespace L0 diff --git a/level_zero/tools/source/sysman/firmware/firmware.h b/level_zero/tools/source/sysman/firmware/firmware.h index 13dacfcca0..727a034248 100644 --- a/level_zero/tools/source/sysman/firmware/firmware.h +++ b/level_zero/tools/source/sysman/firmware/firmware.h @@ -1,21 +1,18 @@ /* - * Copyright (C) 2020-2022 Intel Corporation + * Copyright (C) 2020-2023 Intel Corporation * * SPDX-License-Identifier: MIT * */ #pragma once +#include "level_zero/api/sysman/zes_handles_struct.h" #include #include #include #include -struct _zes_firmware_handle_t { - virtual ~_zes_firmware_handle_t() = default; -}; - namespace L0 { struct OsSysman;