Add ults for windows sysman firmware

Related-To: LOCI-3436

Signed-off-by: Mayank Raghuwanshi <mayank.raghuwanshi@intel.com>

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()

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<std::string> mockSupportedFwTypes = {"GSC", "OptionROM"};
+std::vector<std::string> mockUnsupportedFwTypes = {"unknown"};
+std::string mockEmpty = {};
+class FirmwareInterface : public FirmwareUtil {};
+
+template <>
+struct Mock<FirmwareInterface> : 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<std::string> &fwTypes) override {
+        fwTypes = mockSupportedFwTypes;
+    }
+
+    Mock<FirmwareInterface>() = 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<std::string> & 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

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<Mock<FirmwareInterface>> pMockFwInterface;
+    FirmwareUtil *pFwUtilInterfaceOld = nullptr;
+
+    void SetUp() override {
+        if (!sysmanUltsEnable) {
+            GTEST_SKIP();
+        }
+        SysmanDeviceFixture::SetUp();
+
+        pFwUtilInterfaceOld = pWddmSysmanImp->pFwUtilInterface;
+        pMockFwInterface.reset(new Mock<FirmwareInterface>);
+        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<zes_firmware_handle_t> getFirmwareHandles(uint32_t count) {
+        std::vector<zes_firmware_handle_t> handles(count, nullptr);
+        EXPECT_EQ(zesDeviceEnumFirmwares(device->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS);
+        return handles;
+    }
+};
+
+TEST_F(ZesFirmwareFixture, GivenComponentCountZeroWhenCallingzesFirmwareGetThenZeroCountIsReturnedAndVerifyzesFirmwareGetCallSucceeds) {
+    std::vector<zes_firmware_handle_t> 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