From d3ebf4677bea5f66bde3d74de65528397e129b58 Mon Sep 17 00:00:00 2001 From: Mayank Raghuwanshi Date: Tue, 20 Sep 2022 11:54:50 +0000 Subject: [PATCH] Add ults for windows sysman firmware Related-To: LOCI-3436 Signed-off-by: Mayank Raghuwanshi --- .../sysman/firmware/windows/CMakeLists.txt | 14 ++ .../windows/mock_zes_sysman_firmware.h | 75 ++++++ .../windows/test_zes_sysman_firmware.cpp | 222 ++++++++++++++++++ 3 files changed, 311 insertions(+) create mode 100644 level_zero/tools/test/unit_tests/sources/sysman/firmware/windows/CMakeLists.txt create mode 100644 level_zero/tools/test/unit_tests/sources/sysman/firmware/windows/mock_zes_sysman_firmware.h create mode 100644 level_zero/tools/test/unit_tests/sources/sysman/firmware/windows/test_zes_sysman_firmware.cpp diff --git a/level_zero/tools/test/unit_tests/sources/sysman/firmware/windows/CMakeLists.txt b/level_zero/tools/test/unit_tests/sources/sysman/firmware/windows/CMakeLists.txt new file mode 100644 index 0000000000..792baadffa --- /dev/null +++ b/level_zero/tools/test/unit_tests/sources/sysman/firmware/windows/CMakeLists.txt @@ -0,0 +1,14 @@ +# +# Copyright (C) 2022 Intel Corporation +# +# SPDX-License-Identifier: MIT +# + +if(WIN32) + target_sources(${TARGET_NAME} + PRIVATE + ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt + ${CMAKE_CURRENT_SOURCE_DIR}/test_zes_sysman_firmware.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/mock_zes_sysman_firmware.h + ) +endif() diff --git a/level_zero/tools/test/unit_tests/sources/sysman/firmware/windows/mock_zes_sysman_firmware.h b/level_zero/tools/test/unit_tests/sources/sysman/firmware/windows/mock_zes_sysman_firmware.h new file mode 100644 index 0000000000..36c84ccb1b --- /dev/null +++ b/level_zero/tools/test/unit_tests/sources/sysman/firmware/windows/mock_zes_sysman_firmware.h @@ -0,0 +1,75 @@ +/* + * Copyright (C) 2022 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#pragma once +#include "level_zero/core/test/unit_tests/mock.h" +#include "level_zero/tools/source/sysman/firmware/firmware_imp.h" +#include "level_zero/tools/source/sysman/firmware/windows/os_firmware_imp.h" +#include "level_zero/tools/source/sysman/firmware_util/firmware_util.h" +#include "level_zero/tools/test/unit_tests/sources/sysman/windows/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 FirmwareUtil {}; + +template <> +struct Mock : public FirmwareInterface { + + ze_result_t getFwVersionResult = ZE_RESULT_SUCCESS; + + ze_result_t mockFwGetVersion(std::string &fwVersion) { + fwVersion = mockFwVersion; + return ZE_RESULT_SUCCESS; + } + ze_result_t mockOpromGetVersion(std::string &fwVersion) { + fwVersion = mockOpromVersion; + return ZE_RESULT_SUCCESS; + } + ze_result_t 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; + } + + Mock() = 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)); +}; + +class PublicWddmFirmwareImp : public L0::WddmFirmwareImp { + public: + using WddmFirmwareImp::pFwInterface; +}; +} // namespace ult +} // namespace L0 diff --git a/level_zero/tools/test/unit_tests/sources/sysman/firmware/windows/test_zes_sysman_firmware.cpp b/level_zero/tools/test/unit_tests/sources/sysman/firmware/windows/test_zes_sysman_firmware.cpp new file mode 100644 index 0000000000..510b16bdd5 --- /dev/null +++ b/level_zero/tools/test/unit_tests/sources/sysman/firmware/windows/test_zes_sysman_firmware.cpp @@ -0,0 +1,222 @@ +/* + * Copyright (C) 2022 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#include "level_zero/tools/test/unit_tests/sources/sysman/firmware/windows/mock_zes_sysman_firmware.h" + +extern bool sysmanUltsEnable; + +using ::testing::_; +namespace L0 { +namespace ult { + +class ZesFirmwareFixture : public SysmanDeviceFixture { + + protected: + zes_firmware_handle_t hSysmanFirmware = {}; + std::unique_ptr> pMockFwInterface; + FirmwareUtil *pFwUtilInterfaceOld = nullptr; + + void SetUp() override { + if (!sysmanUltsEnable) { + GTEST_SKIP(); + } + SysmanDeviceFixture::SetUp(); + + pFwUtilInterfaceOld = pWddmSysmanImp->pFwUtilInterface; + pMockFwInterface.reset(new Mock); + pWddmSysmanImp->pFwUtilInterface = pMockFwInterface.get(); + for (const auto &handle : pSysmanDeviceImp->pFirmwareHandleContext->handleList) { + delete handle; + } + pSysmanDeviceImp->pFirmwareHandleContext->handleList.clear(); + } + void TearDown() override { + if (!sysmanUltsEnable) { + GTEST_SKIP(); + } + pWddmSysmanImp->pFwUtilInterface = pFwUtilInterfaceOld; + 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); + + FirmwareImp *ptestFirmwareImp = new 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(); + + FirmwareImp *ptestFirmwareImp = new 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(); + + FirmwareImp *pTestFirmwareImp = new 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(); + + FirmwareImp *ptestFirmwareImp = new 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, GivenValidFirmwareHandleWhenFlashingGscFirmwareThenSuccessIsReturned) { + initFirmware(); + + FirmwareImp *ptestFirmwareImp = new 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(); + FirmwareImp *ptestFirmwareImp = new 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; + OsSysman *pOsSysman = pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman; + + for (const auto &handle : pSysmanDeviceImp->pFirmwareHandleContext->handleList) { + delete handle; + } + pSysmanDeviceImp->pFirmwareHandleContext->handleList.clear(); + delete pSysmanDeviceImp->pFirmwareHandleContext; + + pSysmanDeviceImp->pFirmwareHandleContext = new 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); +} + +} // namespace ult +} // namespace L0