add firmware flashing utility interface

vilvarajintel · Compute-Runtime-Automation · commit bddc63e8bdef · 2020-12-22T09:10:11.000+01: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
@@ -80,6 +80,19 @@ if(BUILD_WITH_L0)
     endif()
   endif()
 
+  if(UNIX)
+    # Firmware Update Library
+    list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/tools/source/sysman/linux/firmware_util")
+    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}")
+    else()
+      message(STATUS "libigsc Library headers not available. Building without")
+    endif()
+  endif()
+
   if(UNIX)
     # Load GNUInstallDirs to determine install targets for Linux packages
     include(GNUInstallDirs)
diff --git a/level_zero/tools/source/sysman/firmware/firmware_imp.cpp b/level_zero/tools/source/sysman/firmware/firmware_imp.cpp
@@ -16,7 +16,8 @@
 namespace L0 {
 
 ze_result_t FirmwareImp::firmwareGetProperties(zes_firmware_properties_t *pProperties) {
-    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+    pOsFirmware->osGetFwProperties(pProperties);
+    return ZE_RESULT_SUCCESS;
 }
 
 void FirmwareImp::init() {
diff --git a/level_zero/tools/source/sysman/firmware/linux/os_firmware_imp.cpp b/level_zero/tools/source/sysman/firmware/linux/os_firmware_imp.cpp
@@ -10,10 +10,30 @@
 namespace L0 {
 
 bool LinuxFirmwareImp::isFirmwareSupported(void) {
-    return false;
+    if (pFwInterface != nullptr) {
+        isFWInitalized = ((ZE_RESULT_SUCCESS == pFwInterface->fwDeviceInit()) ? true : false);
+    }
+    return isFWInitalized;
+}
+
+void LinuxFirmwareImp::osGetFwProperties(zes_firmware_properties_t *pProperties) {
+    if (isFWInitalized) {
+        getFirmwareVersion(pProperties->name);
+        getFirmwareVersion(pProperties->version);
+    } else {
+        std::strncpy(pProperties->name, unknown.c_str(), (ZES_STRING_PROPERTY_SIZE - 1));
+        std::strncpy(pProperties->version, unknown.c_str(), (ZES_STRING_PROPERTY_SIZE - 1));
+    }
+}
+void LinuxFirmwareImp::getFirmwareVersion(char *firmwareVersion) {
+    std::string fwVersion;
+    pFwInterface->fwGetVersion(fwVersion);
+    std::strncpy(firmwareVersion, fwVersion.c_str(), (ZES_STRING_PROPERTY_SIZE - 1));
 }
 
 LinuxFirmwareImp::LinuxFirmwareImp(OsSysman *pOsSysman) {
+    LinuxSysmanImp *pLinuxSysmanImp = static_cast<LinuxSysmanImp *>(pOsSysman);
+    pFwInterface = pLinuxSysmanImp->getFwUtilInterface();
 }
 
 OsFirmware *OsFirmware::create(OsSysman *pOsSysman) {
diff --git a/level_zero/tools/source/sysman/firmware/linux/os_firmware_imp.h b/level_zero/tools/source/sysman/firmware/linux/os_firmware_imp.h
@@ -17,10 +17,17 @@ namespace L0 {
 class LinuxFirmwareImp : public OsFirmware, NEO::NonCopyableOrMovableClass {
   public:
     bool isFirmwareSupported(void) override;
-
+    void osGetFwProperties(zes_firmware_properties_t *pProperties) override;
     LinuxFirmwareImp() = default;
     LinuxFirmwareImp(OsSysman *pOsSysman);
     ~LinuxFirmwareImp() override = default;
+
+  protected:
+    FirmwareUtil *pFwInterface = nullptr;
+    bool isFWInitalized = false;
+
+  private:
+    void getFirmwareVersion(char *);
 };
 
 } // namespace L0
diff --git a/level_zero/tools/source/sysman/firmware/os_firmware.h b/level_zero/tools/source/sysman/firmware/os_firmware.h
@@ -15,6 +15,7 @@ namespace L0 {
 class OsFirmware {
   public:
     virtual bool isFirmwareSupported(void) = 0;
+    virtual void osGetFwProperties(zes_firmware_properties_t *pProperties) = 0;
 
     static OsFirmware *create(OsSysman *pOsSysman);
     virtual ~OsFirmware() {}
diff --git a/level_zero/tools/source/sysman/firmware/windows/os_firmware_imp.cpp b/level_zero/tools/source/sysman/firmware/windows/os_firmware_imp.cpp
@@ -13,6 +13,8 @@ bool WddmFirmwareImp::isFirmwareSupported(void) {
     return false;
 }
 
+void WddmFirmwareImp::osGetFwProperties(zes_firmware_properties_t *pProperties){};
+
 OsFirmware *OsFirmware::create(OsSysman *pOsSysman) {
     WddmFirmwareImp *pWddmFirmwareImp = new WddmFirmwareImp();
     return static_cast<OsFirmware *>(pWddmFirmwareImp);
diff --git a/level_zero/tools/source/sysman/firmware/windows/os_firmware_imp.h b/level_zero/tools/source/sysman/firmware/windows/os_firmware_imp.h
@@ -15,6 +15,7 @@ namespace L0 {
 class WddmFirmwareImp : public OsFirmware {
   public:
     bool isFirmwareSupported(void) override;
+    void osGetFwProperties(zes_firmware_properties_t *pProperties) override;
 };
 
 } // namespace L0
diff --git a/level_zero/tools/source/sysman/linux/firmware_util/CMakeLists.txt b/level_zero/tools/source/sysman/linux/firmware_util/CMakeLists.txt
@@ -0,0 +1,29 @@
+#
+# Copyright (C) 2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+#
+
+if(libigsc_FOUND)
+  set(L0_SRCS_TOOLS_SYSMAN_LINUX_FIRMWARE_UTIL
+      ${CMAKE_CURRENT_SOURCE_DIR}/firmware_util_imp.cpp
+      ${CMAKE_CURRENT_SOURCE_DIR}/firmware_util_imp.h
+      ${CMAKE_CURRENT_SOURCE_DIR}/firmware_util.h
+  )
+
+else()
+  set(L0_SRCS_TOOLS_SYSMAN_LINUX_FIRMWARE_UTIL
+      ${CMAKE_CURRENT_SOURCE_DIR}/firmware_util_imp_stub.cpp
+      ${CMAKE_CURRENT_SOURCE_DIR}/firmware_util.h
+  )
+endif()
+
+if(UNIX)
+  target_sources(${L0_STATIC_LIB_NAME}
+                 PRIVATE
+                 ${L0_SRCS_TOOLS_SYSMAN_LINUX_FIRMWARE_UTIL}
+  )
+endif()
+
+# Make our source files visible to parent
+set_property(GLOBAL PROPERTY L0_SRCS_TOOLS_SYSMAN_FIRMWARE_UTIL_LINUX ${L0_SRCS_TOOLS_SYSMAN_FIRMWARE_UTIL_LINUX})
diff --git a/level_zero/tools/source/sysman/linux/firmware_util/Findlibigsc.cmake b/level_zero/tools/source/sysman/linux/firmware_util/Findlibigsc.cmake
@@ -0,0 +1,11 @@
+#
+# Copyright (C) 2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+#
+
+find_path(libigsc_INCLUDE_DIR NAMES igsc_lib.h PATHS /usr/local/include /usr/include)
+find_library(libigsc_LIBRARIES NAMES igsc libigsc PATHS /usr/local/lib /usr/lib)
+
+include(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(libigsc DEFAULT_MSG libigsc_LIBRARIES libigsc_INCLUDE_DIR)
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
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+
+#include "shared/source/helpers/non_copyable_or_moveable.h"
+
+#include "level_zero/core/source/device/device.h"
+
+#ifdef IGSC_PRESENT
+#include "igsc_lib.h"
+#else
+typedef struct igsc_device_info {
+} igsc_device_info_t;
+#endif
+#include <string>
+#include <vector>
+
+namespace L0 {
+class FirmwareUtil {
+  public:
+    static FirmwareUtil *create();
+    virtual ze_result_t fwDeviceInit() = 0;
+    virtual ze_result_t getFirstDevice(igsc_device_info *) = 0;
+    virtual ze_result_t fwGetVersion(std::string &fwVersion) = 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
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#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";
+
+template <class T>
+bool FirmwareUtilImp::getSymbolAddr(const std::string name, T &proc) {
+    void *addr = libraryHandle->getProcAddress(name);
+    proc = reinterpret_cast<T>(addr);
+    return nullptr != proc;
+}
+
+bool FirmwareUtilImp::loadEntryPoints() {
+    bool ok = getSymbolAddr(fwDeviceInitByDevice, deviceInitByDevice);
+    ok = ok && getSymbolAddr(fwDeviceGetDeviceInfo, deviceGetDeviceInfo);
+    ok = ok && getSymbolAddr(fwDeviceFwVersion, deviceGetFwVersion);
+    ok = ok && getSymbolAddr(fwDeviceIteratorCreate, deviceIteratorCreate);
+    ok = ok && getSymbolAddr(fwDeviceIteratorNext, deviceItreatorNext);
+    ok = ok && getSymbolAddr(fwDeviceIteratorDestroy, deviceItreatorDestroy);
+    return ok;
+}
+
+ze_result_t FirmwareUtilImp::getFirstDevice(igsc_device_info *info) {
+    igsc_device_iterator *iter;
+    int ret = deviceIteratorCreate(&iter);
+    if (ret != IGSC_SUCCESS) {
+        return ZE_RESULT_ERROR_UNINITIALIZED;
+    }
+
+    info->name[0] = '\0';
+    ret = deviceItreatorNext(iter, info);
+    if (ret == IGSC_SUCCESS) {
+        deviceItreatorDestroy(iter);
+        return ZE_RESULT_SUCCESS;
+    }
+    deviceItreatorDestroy(iter);
+    return ZE_RESULT_ERROR_UNKNOWN;
+}
+
+ze_result_t FirmwareUtilImp::fwDeviceInit() {
+    char *devicePath = nullptr;
+    int ret;
+    igsc_device_info info;
+    ze_result_t result = getFirstDevice(&info);
+    if (result != ZE_RESULT_SUCCESS) {
+        return result;
+    }
+    devicePath = strdup(info.name);
+    ret = deviceInitByDevice(&fwDeviceHandle, devicePath);
+    if (ret != 0) {
+        return ZE_RESULT_ERROR_UNINITIALIZED;
+    }
+    fwDevicePath = *devicePath;
+    free(devicePath);
+    return ZE_RESULT_SUCCESS;
+}
+
+ze_result_t FirmwareUtilImp::fwGetVersion(std::string &fwVersion) {
+    igsc_fw_version deviceFwVersion;
+    memset(&deviceFwVersion, 0, sizeof(deviceFwVersion));
+    int ret = deviceGetFwVersion(&fwDeviceHandle, &deviceFwVersion);
+    if (ret != IGSC_SUCCESS) {
+        return ZE_RESULT_ERROR_UNINITIALIZED;
+    }
+    fwVersion.append(deviceFwVersion.project);
+    fwVersion.append("_");
+    fwVersion.append(std::to_string(deviceFwVersion.hotfix));
+    fwVersion.append(".");
+    fwVersion.append(std::to_string(deviceFwVersion.build));
+    return ZE_RESULT_SUCCESS;
+}
+FirmwareUtilImp::FirmwareUtilImp(){};
+
+FirmwareUtilImp::~FirmwareUtilImp() {
+    if (nullptr != libraryHandle) {
+        delete libraryHandle;
+        libraryHandle = nullptr;
+    }
+};
+
+FirmwareUtil *FirmwareUtil::create() {
+    FirmwareUtilImp *pFwUtilImp = new FirmwareUtilImp();
+    UNRECOVERABLE_IF(nullptr == pFwUtilImp);
+    pFwUtilImp->libraryHandle = NEO::OsLibrary::load(pFwUtilImp->fwUtilLibraryFile);
+    if (pFwUtilImp->libraryHandle == nullptr || pFwUtilImp->loadEntryPoints() == false) {
+        if (nullptr != pFwUtilImp->libraryHandle) {
+            delete pFwUtilImp->libraryHandle;
+            pFwUtilImp->libraryHandle = nullptr;
+        }
+        delete pFwUtilImp;
+        return nullptr;
+    }
+
+    return static_cast<FirmwareUtil *>(pFwUtilImp);
+}
+} // namespace L0
diff --git a/level_zero/tools/source/sysman/linux/firmware_util/firmware_util_imp.h b/level_zero/tools/source/sysman/linux/firmware_util/firmware_util_imp.h
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+
+#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.h"
+
+#include <string>
+#include <vector>
+
+namespace L0 {
+typedef int (*pIgscDeviceInitByDevice)(struct igsc_device_handle *handle,
+                                       const char *device_path);
+typedef int (*pIgscDeviceGetDeviceInfo)(struct igsc_device_handle *handle,
+                                        struct igsc_info_device *info);
+typedef int (*pIgscDeviceFwVersion)(struct igsc_device_handle *handle,
+                                    struct igsc_fw_version *version);
+typedef int (*pIgscDeviceIteratorCreate)(struct igsc_device_iterator **iter);
+typedef int (*pIgscDeviceIteratorNext)(struct igsc_device_iterator *iter,
+                                       struct igsc_device_info *info);
+typedef void (*pIgscDeviceIteratorDestroy)(struct igsc_device_iterator *iter);
+
+class FirmwareUtilImp : public FirmwareUtil, NEO::NonCopyableOrMovableClass {
+  public:
+    FirmwareUtilImp();
+    ~FirmwareUtilImp();
+    ze_result_t fwDeviceInit() override;
+    ze_result_t getFirstDevice(igsc_device_info *) override;
+    ze_result_t fwGetVersion(std::string &fwVersion) override;
+
+    template <class T>
+    bool getSymbolAddr(const std::string name, T &proc);
+
+    std::string fwDevicePath;
+    struct igsc_device_handle fwDeviceHandle;
+    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;
+
+    pIgscDeviceInitByDevice deviceInitByDevice = nullptr;
+    pIgscDeviceGetDeviceInfo deviceGetDeviceInfo = nullptr;
+    pIgscDeviceFwVersion deviceGetFwVersion = nullptr;
+    pIgscDeviceIteratorCreate deviceIteratorCreate = nullptr;
+    pIgscDeviceIteratorNext deviceItreatorNext = nullptr;
+    pIgscDeviceIteratorDestroy deviceItreatorDestroy = nullptr;
+};
+} // namespace L0
diff --git a/level_zero/tools/source/sysman/linux/firmware_util/firmware_util_imp_stub.cpp b/level_zero/tools/source/sysman/linux/firmware_util/firmware_util_imp_stub.cpp
@@ -0,0 +1,13 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "level_zero/tools/source/sysman/linux/firmware_util/firmware_util.h"
+namespace L0 {
+FirmwareUtil *FirmwareUtil::create() {
+    return nullptr;
+}
+} // namespace L0
diff --git a/level_zero/tools/source/sysman/linux/os_sysman_imp.cpp b/level_zero/tools/source/sysman/linux/os_sysman_imp.cpp
@@ -13,7 +13,7 @@ namespace L0 {
 
 ze_result_t LinuxSysmanImp::init() {
     pXmlParser = XmlParser::create();
-
+    pFwUtilInterface = FirmwareUtil::create();
     pFsAccess = FsAccess::create();
     UNRECOVERABLE_IF(nullptr == pFsAccess);
 
@@ -51,6 +51,10 @@ XmlParser *LinuxSysmanImp::getXmlParser() {
     return pXmlParser;
 }
 
+FirmwareUtil *LinuxSysmanImp::getFwUtilInterface() {
+    return pFwUtilInterface;
+}
+
 FsAccess &LinuxSysmanImp::getFsAccess() {
     UNRECOVERABLE_IF(nullptr == pFsAccess);
     return *pFsAccess;
@@ -105,6 +109,10 @@ LinuxSysmanImp::~LinuxSysmanImp() {
         delete pXmlParser;
         pXmlParser = nullptr;
     }
+    if (nullptr != pFwUtilInterface) {
+        delete pFwUtilInterface;
+        pFwUtilInterface = nullptr;
+    }
     if (nullptr != pPmt) {
         delete pPmt;
         pPmt = nullptr;
diff --git a/level_zero/tools/source/sysman/linux/os_sysman_imp.h b/level_zero/tools/source/sysman/linux/os_sysman_imp.h
diff --git a/level_zero/tools/test/black_box_tests/zello_sysman.cpp b/level_zero/tools/test/black_box_tests/zello_sysman.cpp
diff --git a/level_zero/tools/test/unit_tests/sources/sysman/firmware/linux/CMakeLists.txt b/level_zero/tools/test/unit_tests/sources/sysman/firmware/linux/CMakeLists.txt
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
diff --git a/level_zero/tools/test/unit_tests/sources/sysman/firmware/linux/test_zes_sysman_firmware.cpp b/level_zero/tools/test/unit_tests/sources/sysman/firmware/linux/test_zes_sysman_firmware.cpp
diff --git a/level_zero/tools/test/unit_tests/sources/sysman/linux/mock_sysman_fixture.h b/level_zero/tools/test/unit_tests/sources/sysman/linux/mock_sysman_fixture.h

Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,8 @@`
`16`	`16`	`namespace L0 {`
`17`	`17`
`18`	`18`	`ze_result_t FirmwareImp::firmwareGetProperties(zes_firmware_properties_t *pProperties) {`
`19`		`- return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;`
	`19`	`+ pOsFirmware->osGetFwProperties(pProperties);`
	`20`	`+ return ZE_RESULT_SUCCESS;`
`20`	`21`	`}`
`21`	`22`
`22`	`23`	`void FirmwareImp::init() {`
Original file line number	Diff line number	Diff line change
`@@ -13,6 +13,8 @@ bool WddmFirmwareImp::isFirmwareSupported(void) {`
`13`	`13`	`return false;`
`14`	`14`	`}`
`15`	`15`
	`16`	`+void WddmFirmwareImp::osGetFwProperties(zes_firmware_properties_t *pProperties){};`
	`17`	`+`
`16`	`18`	`OsFirmware OsFirmware::create(OsSysman pOsSysman) {`
`17`	`19`	`WddmFirmwareImp *pWddmFirmwareImp = new WddmFirmwareImp();`
`18`	`20`	`return static_cast<OsFirmware *>(pWddmFirmwareImp);`