sysman: add support to enable IFR status.

vilvarajintel · Compute-Runtime-Automation · commit 699b5043788c · 2021-04-20T15:27:09.000+02:00
Signed-off-by: Vilvaraj, T J Vivek &lt;t.j.vivek.vilvaraj@intel.com&gt;
diff --git a/level_zero/CMakeLists.txt b/level_zero/CMakeLists.txt
@@ -86,12 +86,13 @@ if(BUILD_WITH_L0)
 
   if(UNIX)
     # Firmware Update Library
-    list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/tools/source/sysman/linux/firmware_util")
+    list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/tools/source/sysman/linux/firmware_util${BRANCH_DIR_SUFFIX}")
     find_package(libigsc)
     if(libigsc_LIBRARIES)
       set(libigsc_FOUND TRUE)
       add_definitions(-DIGSC_PRESENT=$(libigsc_FOUND))
       message(STATUS "libigsc Library headers directory: ${libigsc_INCLUDE_DIR}")
+      message(STATUS "libigsc version: ${libigsc_VERSION}")
     else()
       message(STATUS "libigsc Library headers not available. Building without")
     endif()
diff --git a/level_zero/tools/source/sysman/events/linux/os_events_imp.cpp b/level_zero/tools/source/sysman/events/linux/os_events_imp.cpp
@@ -18,9 +18,7 @@ const std::string LinuxEventsImp::attachEvent("add");
 
 bool LinuxEventsImp::isResetRequired(zes_event_type_flags_t &pEvent) {
     zes_device_state_t pState = {};
-    if (pLinuxSysmanImp->getSysmanDeviceImp()->deviceGetState(&pState) != ZE_RESULT_SUCCESS) {
-        return false;
-    }
+    pLinuxSysmanImp->getSysmanDeviceImp()->deviceGetState(&pState);
     if (pState.reset) {
         pEvent |= ZES_EVENT_TYPE_FLAG_DEVICE_RESET_REQUIRED;
         return true;
diff --git a/level_zero/tools/source/sysman/global_operations/linux/CMakeLists.txt b/level_zero/tools/source/sysman/global_operations/linux/CMakeLists.txt
@@ -6,6 +6,7 @@
 
 set(L0_SRCS_TOOLS_GLOBAL_OPERATIONS_LINUX
     ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+    ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}/os_global_operations_helper.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/os_global_operations_imp.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/os_global_operations_imp.h
 )
diff --git a/level_zero/tools/source/sysman/global_operations/linux/os_global_operations_helper.cpp b/level_zero/tools/source/sysman/global_operations/linux/os_global_operations_helper.cpp
@@ -0,0 +1,12 @@
+/*
+ * Copyright (C) 2020-2021 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "level_zero/tools/source/sysman/global_operations/linux/os_global_operations_imp.h"
+
+namespace L0 {
+void LinuxGlobalOperationsImp::getRepairStatus(zes_device_state_t *pState) {}
+} // namespace L0
diff --git a/level_zero/tools/source/sysman/global_operations/linux/os_global_operations_imp.cpp b/level_zero/tools/source/sysman/global_operations/linux/os_global_operations_imp.cpp
@@ -392,27 +392,31 @@ ze_result_t LinuxGlobalOperationsImp::scanProcessesState(std::vector<zes_process
     }
     return result;
 }
-ze_result_t LinuxGlobalOperationsImp::deviceGetState(zes_device_state_t *pState) {
+
+void LinuxGlobalOperationsImp::getWedgedStatus(zes_device_state_t *pState) {
     uint32_t valWedged = 0;
-    ze_result_t result = pFsAccess->read(ueventWedgedFile, valWedged);
-    if (result != ZE_RESULT_SUCCESS) {
-        if (result == ZE_RESULT_ERROR_NOT_AVAILABLE)
-            result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
-        return result;
-    }
-    pState->reset = 0;
-    if (valWedged != 0) {
-        pState->reset |= ZES_RESET_REASON_FLAG_WEDGED;
+    if (ZE_RESULT_SUCCESS == pFsAccess->read(ueventWedgedFile, valWedged)) {
+        if (valWedged != 0) {
+            pState->reset |= ZES_RESET_REASON_FLAG_WEDGED;
+        }
     }
-    return result;
 }
+ze_result_t LinuxGlobalOperationsImp::deviceGetState(zes_device_state_t *pState) {
+    memset(pState, 0, sizeof(zes_device_state_t));
+    pState->repaired = ZES_REPAIR_STATUS_UNSUPPORTED;
+    getWedgedStatus(pState);
+    getRepairStatus(pState);
+    return ZE_RESULT_SUCCESS;
+}
+
 LinuxGlobalOperationsImp::LinuxGlobalOperationsImp(OsSysman *pOsSysman) {
     pLinuxSysmanImp = static_cast<LinuxSysmanImp *>(pOsSysman);
 
     pSysfsAccess = &pLinuxSysmanImp->getSysfsAccess();
     pProcfsAccess = &pLinuxSysmanImp->getProcfsAccess();
     pFsAccess = &pLinuxSysmanImp->getFsAccess();
     pDevice = pLinuxSysmanImp->getDeviceHandle();
+    pFwInterface = pLinuxSysmanImp->getFwUtilInterface();
 }
 
 OsGlobalOperations *OsGlobalOperations::create(OsSysman *pOsSysman) {
diff --git a/level_zero/tools/source/sysman/global_operations/linux/os_global_operations_imp.h b/level_zero/tools/source/sysman/global_operations/linux/os_global_operations_imp.h
@@ -21,6 +21,8 @@ class LinuxGlobalOperationsImp : public OsGlobalOperations, NEO::NonCopyableOrMo
     void getModelName(char (&modelName)[ZES_STRING_PROPERTY_SIZE]) override;
     void getVendorName(char (&vendorName)[ZES_STRING_PROPERTY_SIZE]) override;
     void getDriverVersion(char (&driverVersion)[ZES_STRING_PROPERTY_SIZE]) override;
+    void getWedgedStatus(zes_device_state_t *pState) override;
+    void getRepairStatus(zes_device_state_t *pState) override;
     Device *getDevice() override;
     ze_result_t reset(ze_bool_t force) override;
     ze_result_t scanProcessesState(std::vector<zes_process_state_t> &pProcessList) override;
@@ -35,6 +37,7 @@ class LinuxGlobalOperationsImp : public OsGlobalOperations, NEO::NonCopyableOrMo
     SysfsAccess *pSysfsAccess = nullptr;
     LinuxSysmanImp *pLinuxSysmanImp = nullptr;
     Device *pDevice = nullptr;
+    FirmwareUtil *pFwInterface = nullptr;
 
     int resetTimeout = 10000; // in milliseconds
 
diff --git a/level_zero/tools/source/sysman/global_operations/os_global_operations.h b/level_zero/tools/source/sysman/global_operations/os_global_operations.h
@@ -24,6 +24,8 @@ class OsGlobalOperations {
     virtual void getModelName(char (&modelName)[ZES_STRING_PROPERTY_SIZE]) = 0;
     virtual void getVendorName(char (&vendorName)[ZES_STRING_PROPERTY_SIZE]) = 0;
     virtual void getDriverVersion(char (&driverVersion)[ZES_STRING_PROPERTY_SIZE]) = 0;
+    virtual void getWedgedStatus(zes_device_state_t *pState) = 0;
+    virtual void getRepairStatus(zes_device_state_t *pState) = 0;
     virtual Device *getDevice() = 0;
     virtual ze_result_t reset(ze_bool_t force) = 0;
     virtual ze_result_t scanProcessesState(std::vector<zes_process_state_t> &pProcessList) = 0;
diff --git a/level_zero/tools/source/sysman/global_operations/windows/os_global_operations_imp.cpp b/level_zero/tools/source/sysman/global_operations/windows/os_global_operations_imp.cpp
@@ -31,6 +31,10 @@ void WddmGlobalOperationsImp::getVendorName(char (&vendorName)[ZES_STRING_PROPER
 void WddmGlobalOperationsImp::getDriverVersion(char (&driverVersion)[ZES_STRING_PROPERTY_SIZE]) {
 }
 
+void WddmGlobalOperationsImp::getWedgedStatus(zes_device_state_t *pState) {
+}
+void WddmGlobalOperationsImp::getRepairStatus(zes_device_state_t *pState) {
+}
 ze_result_t WddmGlobalOperationsImp::reset(ze_bool_t force) {
     uint32_t value = 0;
     KmdSysman::RequestProperty request;
diff --git a/level_zero/tools/source/sysman/global_operations/windows/os_global_operations_imp.h b/level_zero/tools/source/sysman/global_operations/windows/os_global_operations_imp.h
@@ -22,6 +22,8 @@ class WddmGlobalOperationsImp : public OsGlobalOperations, NEO::NonCopyableOrMov
     void getModelName(char (&modelName)[ZES_STRING_PROPERTY_SIZE]) override;
     void getVendorName(char (&vendorName)[ZES_STRING_PROPERTY_SIZE]) override;
     void getDriverVersion(char (&driverVersion)[ZES_STRING_PROPERTY_SIZE]) override;
+    void getWedgedStatus(zes_device_state_t *pState) override;
+    void getRepairStatus(zes_device_state_t *pState) override;
     Device *getDevice() override;
     ze_result_t reset(ze_bool_t force) override;
     ze_result_t scanProcessesState(std::vector<zes_process_state_t> &pProcessList) override;
diff --git a/level_zero/tools/source/sysman/linux/firmware_util/CMakeLists.txt b/level_zero/tools/source/sysman/linux/firmware_util/CMakeLists.txt
@@ -10,7 +10,15 @@ if(libigsc_FOUND)
       ${CMAKE_CURRENT_SOURCE_DIR}/firmware_util_imp.h
       ${CMAKE_CURRENT_SOURCE_DIR}/firmware_util.h
   )
-
+  if($(libigsc_VERSION)GREATER "2")
+    set(L0_SRCS_TOOLS_SYSMAN_LINUX_FIRMWARE_UTIL_HELPER
+        ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}/firmware_util_imp_helper.cpp
+    )
+  else()
+    set(L0_SRCS_TOOLS_SYSMAN_LINUX_FIRMWARE_UTIL_HELPER
+        ${CMAKE_CURRENT_SOURCE_DIR}/firmware_util_imp_helper.cpp
+    )
+  endif()
 else()
   set(L0_SRCS_TOOLS_SYSMAN_LINUX_FIRMWARE_UTIL
       ${CMAKE_CURRENT_SOURCE_DIR}/firmware_util_imp_stub.cpp
@@ -22,6 +30,7 @@ if(UNIX)
   target_sources(${L0_STATIC_LIB_NAME}
                  PRIVATE
                  ${L0_SRCS_TOOLS_SYSMAN_LINUX_FIRMWARE_UTIL}
+                 ${L0_SRCS_TOOLS_SYSMAN_LINUX_FIRMWARE_UTIL_HELPER}
   )
 endif()
 
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
@@ -30,6 +30,7 @@ class FirmwareUtil {
     virtual ze_result_t opromGetVersion(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 fwIfrApplied(bool &ifrStatus) = 0;
     virtual ~FirmwareUtil() = default;
 };
 } // namespace L0
diff --git a/level_zero/tools/source/sysman/linux/firmware_util/firmware_util_imp.cpp b/level_zero/tools/source/sysman/linux/firmware_util/firmware_util_imp.cpp
@@ -8,18 +8,30 @@
 #include "level_zero/tools/source/sysman/linux/firmware_util/firmware_util_imp.h"
 
 namespace L0 {
-const std::string FirmwareUtilImp::fwUtilLibraryFile = "libigsc.so.0";
-const std::string FirmwareUtilImp::fwDeviceInitByDevice = "igsc_device_init_by_device_info";
-const std::string FirmwareUtilImp::fwDeviceGetDeviceInfo = "igsc_device_get_device_info";
-const std::string FirmwareUtilImp::fwDeviceFwVersion = "igsc_device_fw_version";
-const std::string FirmwareUtilImp::fwDeviceIteratorCreate = "igsc_device_iterator_create";
-const std::string FirmwareUtilImp::fwDeviceIteratorNext = "igsc_device_iterator_next";
-const std::string FirmwareUtilImp::fwDeviceIteratorDestroy = "igsc_device_iterator_destroy";
-const std::string FirmwareUtilImp::fwDeviceFwUpdate = "igsc_device_fw_update";
-const std::string FirmwareUtilImp::fwImageOpromInit = "igsc_image_oprom_init";
-const std::string FirmwareUtilImp::fwImageOpromType = "igsc_image_oprom_type";
-const std::string FirmwareUtilImp::fwDeviceOpromUpdate = "igsc_device_oprom_update";
-const std::string FirmwareUtilImp::fwDeviceOpromVersion = "igsc_device_oprom_version";
+const std::string fwUtilLibraryFile = "libigsc.so.0";
+const std::string fwDeviceInitByDevice = "igsc_device_init_by_device_info";
+const std::string fwDeviceGetDeviceInfo = "igsc_device_get_device_info";
+const std::string fwDeviceFwVersion = "igsc_device_fw_version";
+const std::string fwDeviceIteratorCreate = "igsc_device_iterator_create";
+const std::string fwDeviceIteratorNext = "igsc_device_iterator_next";
+const std::string fwDeviceIteratorDestroy = "igsc_device_iterator_destroy";
+const std::string fwDeviceFwUpdate = "igsc_device_fw_update";
+const std::string fwImageOpromInit = "igsc_image_oprom_init";
+const std::string fwImageOpromType = "igsc_image_oprom_type";
+const std::string fwDeviceOpromUpdate = "igsc_device_oprom_update";
+const std::string fwDeviceOpromVersion = "igsc_device_oprom_version";
+
+pIgscDeviceInitByDevice deviceInitByDevice;
+pIgscDeviceGetDeviceInfo deviceGetDeviceInfo;
+pIgscDeviceFwVersion deviceGetFwVersion;
+pIgscDeviceIteratorCreate deviceIteratorCreate;
+pIgscDeviceIteratorNext deviceItreatorNext;
+pIgscDeviceIteratorDestroy deviceItreatorDestroy;
+pIgscDeviceFwUpdate deviceFwUpdate;
+pIgscImageOpromInit imageOpromInit;
+pIgscImageOpromType imageOpromType;
+pIgscDeviceOpromUpdate deviceOpromUpdate;
+pIgscDeviceOpromVersion deviceOpromVersion;
 
 template <class T>
 bool FirmwareUtilImp::getSymbolAddr(const std::string name, T &proc) {
@@ -166,7 +178,7 @@ FirmwareUtilImp::~FirmwareUtilImp() {
 FirmwareUtil *FirmwareUtil::create() {
     FirmwareUtilImp *pFwUtilImp = new FirmwareUtilImp();
     UNRECOVERABLE_IF(nullptr == pFwUtilImp);
-    pFwUtilImp->libraryHandle = NEO::OsLibrary::load(pFwUtilImp->fwUtilLibraryFile);
+    pFwUtilImp->libraryHandle = NEO::OsLibrary::load(fwUtilLibraryFile);
     if (pFwUtilImp->libraryHandle == nullptr || pFwUtilImp->loadEntryPoints() == false) {
         if (nullptr != pFwUtilImp->libraryHandle) {
             delete pFwUtilImp->libraryHandle;
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
@@ -45,6 +45,18 @@ typedef int (*pIgscDeviceOpromVersion)(struct igsc_device_handle *handle,
                                        uint32_t oprom_type,
                                        struct igsc_oprom_version *version);
 
+extern pIgscDeviceInitByDevice deviceInitByDevice;
+extern pIgscDeviceGetDeviceInfo deviceGetDeviceInfo;
+extern pIgscDeviceFwVersion deviceGetFwVersion;
+extern pIgscDeviceIteratorCreate deviceIteratorCreate;
+extern pIgscDeviceIteratorNext deviceItreatorNext;
+extern pIgscDeviceIteratorDestroy deviceItreatorDestroy;
+extern pIgscDeviceFwUpdate deviceFwUpdate;
+extern pIgscImageOpromInit imageOpromInit;
+extern pIgscImageOpromType imageOpromType;
+extern pIgscDeviceOpromUpdate deviceOpromUpdate;
+extern pIgscDeviceOpromVersion deviceOpromVersion;
+
 class FirmwareUtilImp : public FirmwareUtil, NEO::NonCopyableOrMovableClass {
   public:
     FirmwareUtilImp();
@@ -55,6 +67,7 @@ class FirmwareUtilImp : public FirmwareUtil, NEO::NonCopyableOrMovableClass {
     ze_result_t opromGetVersion(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 fwIfrApplied(bool &ifrStatus) override;
 
     template <class T>
     bool getSymbolAddr(const std::string name, T &proc);
@@ -64,29 +77,5 @@ class FirmwareUtilImp : public FirmwareUtil, NEO::NonCopyableOrMovableClass {
     bool loadEntryPoints();
 
     NEO::OsLibrary *libraryHandle = nullptr;
-    static const std::string fwUtilLibraryFile;
-    static const std::string fwDeviceInitByDevice;
-    static const std::string fwDeviceGetDeviceInfo;
-    static const std::string fwDeviceFwVersion;
-    static const std::string fwDeviceIteratorCreate;
-    static const std::string fwDeviceIteratorNext;
-    static const std::string fwDeviceIteratorDestroy;
-    static const std::string fwDeviceFwUpdate;
-    static const std::string fwImageOpromInit;
-    static const std::string fwImageOpromType;
-    static const std::string fwDeviceOpromUpdate;
-    static const std::string fwDeviceOpromVersion;
-
-    pIgscDeviceInitByDevice deviceInitByDevice = nullptr;
-    pIgscDeviceGetDeviceInfo deviceGetDeviceInfo = nullptr;
-    pIgscDeviceFwVersion deviceGetFwVersion = nullptr;
-    pIgscDeviceIteratorCreate deviceIteratorCreate = nullptr;
-    pIgscDeviceIteratorNext deviceItreatorNext = nullptr;
-    pIgscDeviceIteratorDestroy deviceItreatorDestroy = nullptr;
-    pIgscDeviceFwUpdate deviceFwUpdate = nullptr;
-    pIgscImageOpromInit imageOpromInit = nullptr;
-    pIgscImageOpromType imageOpromType = nullptr;
-    pIgscDeviceOpromUpdate deviceOpromUpdate = nullptr;
-    pIgscDeviceOpromVersion deviceOpromVersion = nullptr;
 };
 } // namespace L0
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
@@ -0,0 +1,17 @@
+/*
+ * Copyright (C) 2020-2021 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/source/helpers/non_copyable_or_moveable.h"
+
+#include "level_zero/core/source/device/device.h"
+#include "level_zero/tools/source/sysman/linux/firmware_util/firmware_util_imp.h"
+
+namespace L0 {
+ze_result_t FirmwareUtilImp::fwIfrApplied(bool &ifrStatus) {
+    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
@@ -49,6 +49,7 @@ struct Mock<DiagnosticsInterface> : public FirmwareUtil {
     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, fwIfrApplied, (bool &ifrStatus), (override));
 };
 
 class PublicLinuxDiagnosticsImp : public L0::LinuxDiagnosticsImp {
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
@@ -70,6 +70,7 @@ struct Mock<FirmwareInterface> : public FirmwareUtil {
     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, fwIfrApplied, (bool &ifrStatus), (override));
 };
 
 class PublicLinuxFirmwareImp : public L0::LinuxFirmwareImp {
diff --git a/level_zero/tools/test/unit_tests/sources/sysman/global_operations/linux/CMakeLists.txt b/level_zero/tools/test/unit_tests/sources/sysman/global_operations/linux/CMakeLists.txt
@@ -10,5 +10,6 @@ if(UNIX)
                  ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
                  ${CMAKE_CURRENT_SOURCE_DIR}/test_zes_global_operations.cpp
                  ${CMAKE_CURRENT_SOURCE_DIR}/mock_global_operations.h
+                 ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}/test_zes_global_operations_helper.cpp
   )
 endif()
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
@@ -44,8 +44,8 @@ const std::string engine0("0");
 const std::string engine1("1");
 const std::string engine2("2");
 const std::string engine3("3");
-std::string driverVersion("5.0.0-37-generic SMP mod_unload");
-std::string srcVersion("5.0.0-37");
+const std::string driverVersion("5.0.0-37-generic SMP mod_unload");
+const std::string srcVersion("5.0.0-37");
 const std::string ueventWedgedFile("/var/lib/libze_intel_gpu/wedged_file");
 const std::string mockFunctionResetPath("/MOCK_FUNCTION_LEVEL_RESET_PATH");
 const std::string mockDeviceDir("/MOCK_DEVICE_DIR");
@@ -406,6 +406,38 @@ struct Mock<GlobalOperationsFsAccess> : public GlobalOperationsFsAccess {
     MOCK_METHOD(ze_result_t, canWrite, (const std::string file), (override));
 };
 
+class FirmwareInterface : public FirmwareUtil {};
+template <>
+struct Mock<FirmwareInterface> : public FirmwareUtil {
+
+    ze_result_t mockFwDeviceInit(void) {
+        return ZE_RESULT_SUCCESS;
+    }
+    ze_result_t mockFwDeviceInitFail(void) {
+        return ZE_RESULT_ERROR_UNKNOWN;
+    }
+    ze_result_t mockIfrReturnTrue(bool &ifrStatus) {
+        ifrStatus = true;
+        return ZE_RESULT_SUCCESS;
+    }
+    ze_result_t mockIfrReturnFail(bool &ifrStatus) {
+        return ZE_RESULT_ERROR_UNKNOWN;
+    }
+    ze_result_t mockIfrReturnFalse(bool &ifrStatus) {
+        ifrStatus = false;
+        return ZE_RESULT_SUCCESS;
+    }
+    Mock<FirmwareInterface>() = 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, 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, fwIfrApplied, (bool &ifrStatus), (override));
+};
+
 class PublicLinuxGlobalOperationsImp : public L0::LinuxGlobalOperationsImp {
   public:
     using LinuxGlobalOperationsImp::resetTimeout;
diff --git a/level_zero/tools/test/unit_tests/sources/sysman/global_operations/linux/test_zes_global_operations.cpp b/level_zero/tools/test/unit_tests/sources/sysman/global_operations/linux/test_zes_global_operations.cpp
@@ -268,20 +268,6 @@ TEST_F(SysmanGlobalOperationsFixture, GivenDeviceIsNotWedgedWhenCallingGetDevice
     EXPECT_EQ(0u, deviceState.reset);
 }
 
-TEST_F(SysmanGlobalOperationsFixture, GivenWedgedFileNotFoundWhenCallingGetDeviceStateThenZeResultErrorUnsupportedFeatureIsReturned) {
-    ON_CALL(*pFsAccess.get(), read(_, Matcher<uint32_t &>(_)))
-        .WillByDefault(::testing::Invoke(pFsAccess.get(), &Mock<GlobalOperationsFsAccess>::getValWedgedFileNotFound));
-    zes_device_state_t deviceState;
-    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesDeviceGetState(device, &deviceState));
-}
-
-TEST_F(SysmanGlobalOperationsFixture, GivenWedgedFileInsufficientPermissionsWhenCallingGetDeviceStateThenZeResultErrorInsufficientPermissionsIsReturned) {
-    ON_CALL(*pFsAccess.get(), read(_, Matcher<uint32_t &>(_)))
-        .WillByDefault(::testing::Invoke(pFsAccess.get(), &Mock<GlobalOperationsFsAccess>::getValWedgedFileInsufficientPermissions));
-    zes_device_state_t deviceState;
-    EXPECT_EQ(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS, zesDeviceGetState(device, &deviceState));
-}
-
 TEST_F(SysmanGlobalOperationsFixture, GivenPermissionDeniedWhenCallingGetDeviceStateThenZeResultErrorInsufficientPermissionsIsReturned) {
     ON_CALL(*pSysfsAccess.get(), getRealPath(_, Matcher<std::string &>(_)))
         .WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<GlobalOperationsSysfsAccess>::getRealPathVal));
diff --git a/level_zero/tools/test/unit_tests/sources/sysman/global_operations/linux/test_zes_global_operations_helper.cpp b/level_zero/tools/test/unit_tests/sources/sysman/global_operations/linux/test_zes_global_operations_helper.cpp
@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2021 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */

Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,7 @@`
`6`	`6`
`7`	`7`	`set(L0_SRCS_TOOLS_GLOBAL_OPERATIONS_LINUX`
`8`	`8`	`${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt`
	`9`	`+ ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}/os_global_operations_helper.cpp`
`9`	`10`	`${CMAKE_CURRENT_SOURCE_DIR}/os_global_operations_imp.cpp`
`10`	`11`	`${CMAKE_CURRENT_SOURCE_DIR}/os_global_operations_imp.h`
`11`	`12`	`)`