sysman: add support to handle multiple firmwares

Signed-off-by: T J Vivek Vilvaraj <t.j.vivek.vilvaraj@intel.com>

Author: vilvarajintel

level_zero/tools/source/sysman/firmware/firmware.cpp

@@ -1,34 +1,40 @@
 /*
- * Copyright (C) 2020 Intel Corporation
+ * Copyright (C) 2020-2021 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
  */
 
-#include "firmware.h"
-
 #include "shared/source/helpers/basic_math.h"
 
-#include "firmware_imp.h"
+#include "level_zero/tools/source/sysman/firmware/firmware_imp.h"
 
 namespace L0 {
-
+class OsFirmware;
 FirmwareHandleContext::~FirmwareHandleContext() {
     for (Firmware *pFirmware : handleList) {
         delete pFirmware;
     }
     handleList.clear();
 }
 
-void FirmwareHandleContext::init() {
-    Firmware *pFirmware = new FirmwareImp(pOsSysman);
+void FirmwareHandleContext::createHandle(const std::string &fwType) {
+    Firmware *pFirmware = new FirmwareImp(pOsSysman, fwType);
     if (pFirmware->isFirmwareEnabled == true) {
         handleList.push_back(pFirmware);
     } else {
         delete pFirmware;
     }
 }
 
+void FirmwareHandleContext::init() {
+    std::vector<std::string> 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) {
     uint32_t handleListSize = static_cast<uint32_t>(handleList.size());
     uint32_t numToCopy = std::min(*pCount, handleListSize);

level_zero/tools/source/sysman/firmware/firmware.h

@@ -8,6 +8,7 @@
 #pragma once
 #include <level_zero/zes_api.h>
 
+#include <string>
 #include <vector>
 
 struct _zes_firmware_handle_t {
@@ -42,6 +43,9 @@ struct FirmwareHandleContext {
 
     OsSysman *pOsSysman = nullptr;
     std::vector<Firmware *> handleList = {};
+
+  private:
+    void createHandle(const std::string &fwType);
 };
 
 } // namespace L0

level_zero/tools/source/sysman/firmware/firmware_imp.cpp

@@ -17,6 +17,7 @@ namespace L0 {
 
 ze_result_t FirmwareImp::firmwareGetProperties(zes_firmware_properties_t *pProperties) {
     pOsFirmware->osGetFwProperties(pProperties);
+    strncpy_s(pProperties->name, ZES_STRING_PROPERTY_SIZE, fwType.c_str(), fwType.size());
     return ZE_RESULT_SUCCESS;
 }
 
@@ -28,17 +29,14 @@ void FirmwareImp::init() {
     this->isFirmwareEnabled = pOsFirmware->isFirmwareSupported();
 }
 
-FirmwareImp::FirmwareImp(OsSysman *pOsSysman) {
-    pOsFirmware = OsFirmware::create(pOsSysman);
+FirmwareImp::FirmwareImp(OsSysman *pOsSysman, const std::string &initalizedFwType) {
+    pOsFirmware = OsFirmware::create(pOsSysman, initalizedFwType);
+    fwType = initalizedFwType;
     UNRECOVERABLE_IF(nullptr == pOsFirmware);
     init();
 }
 
 FirmwareImp::~FirmwareImp() {
-    if (pOsFirmware != nullptr) {
-        delete pOsFirmware;
-        pOsFirmware = nullptr;
-    }
 }
 
 } // namespace L0

level_zero/tools/source/sysman/firmware/firmware_imp.h

@@ -7,11 +7,12 @@
 
 #pragma once
 #include "shared/source/helpers/non_copyable_or_moveable.h"
+#include "shared/source/helpers/string.h"
 
+#include "level_zero/tools/source/sysman/firmware/firmware.h"
+#include "level_zero/tools/source/sysman/firmware/os_firmware.h"
 #include <level_zero/zes_api.h>
 
-#include "firmware.h"
-
 namespace L0 {
 
 class OsFirmware;
@@ -21,9 +22,10 @@ class FirmwareImp : public Firmware, NEO::NonCopyableOrMovableClass {
     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);
+    FirmwareImp(OsSysman *pOsSysman, const std::string &fwType);
     ~FirmwareImp() override;
-    OsFirmware *pOsFirmware = nullptr;
+    std::unique_ptr<OsFirmware> pOsFirmware = nullptr;
+    std::string fwType = "Unknown";
 
     void init();
 };

level_zero/tools/source/sysman/firmware/linux/os_firmware_imp.cpp

@@ -11,41 +11,77 @@
 
 namespace L0 {
 
-bool LinuxFirmwareImp::isFirmwareSupported(void) {
-    if (pFwInterface != nullptr) {
-        isFWInitalized = ((ZE_RESULT_SUCCESS == pFwInterface->fwDeviceInit()) ? true : false);
+static const std::string mtdDescriptor("/proc/mtd");
+
+std::vector<std ::string> deviceSupportedFwTypes = {"GSC", "OptionROM"};
+
+ze_result_t OsFirmware::getSupportedFwTypes(std::vector<std::string> &supportedFwTypes, OsSysman *pOsSysman) {
+    LinuxSysmanImp *pLinuxSysmanImp = static_cast<LinuxSysmanImp *>(pOsSysman);
+
+    FsAccess *pFsAccess = &pLinuxSysmanImp->getFsAccess();
+    std::vector<std::string> mtdDescriptorStrings;
+    ze_result_t result = pFsAccess->read(mtdDescriptor, mtdDescriptorStrings);
+    if (result != ZE_RESULT_SUCCESS) {
+        return result;
     }
-    return isFWInitalized;
+    for (std::string readByteLine : mtdDescriptorStrings) {
+        for (std::string fwType : deviceSupportedFwTypes) {
+            if (std::string::npos != readByteLine.find(fwType)) {
+                supportedFwTypes.push_back(fwType);
+            }
+        }
+    }
+    return ZE_RESULT_SUCCESS;
+}
+bool LinuxFirmwareImp::isFirmwareSupported(void) {
+    isFWInitalized = ((ZE_RESULT_SUCCESS == pFwInterface->fwDeviceInit()) ? true : false);
+    return this->isFWInitalized;
 }
 
 void LinuxFirmwareImp::osGetFwProperties(zes_firmware_properties_t *pProperties) {
-    if (isFWInitalized) {
-        getFirmwareVersion(pProperties->name);
+    if (osFwType == deviceSupportedFwTypes[0]) { //GSC
         getFirmwareVersion(pProperties->version);
-    } else {
-        strncpy_s(pProperties->name, ZES_STRING_PROPERTY_SIZE, unknown.c_str(), ZES_STRING_PROPERTY_SIZE);
-        strncpy_s(pProperties->version, ZES_STRING_PROPERTY_SIZE, unknown.c_str(), ZES_STRING_PROPERTY_SIZE);
+    }
+    if (osFwType == deviceSupportedFwTypes[1]) { //oprom
+        getOpromVersion(pProperties->version);
     }
 }
-
 ze_result_t LinuxFirmwareImp::osFirmwareFlash(void *pImage, uint32_t size) {
-    return pFwInterface->fwFlashGSC(pImage, size);
+    if (osFwType == deviceSupportedFwTypes[0]) { //GSC
+        return pFwInterface->fwFlashGSC(pImage, size);
+    }
+    if (osFwType == deviceSupportedFwTypes[1]) { //oprom
+        return pFwInterface->fwFlashOprom(pImage, size);
+    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 void LinuxFirmwareImp::getFirmwareVersion(char *firmwareVersion) {
     std::string fwVersion;
-    pFwInterface->fwGetVersion(fwVersion);
-    strncpy_s(firmwareVersion, ZES_STRING_PROPERTY_SIZE, fwVersion.c_str(), ZES_STRING_PROPERTY_SIZE);
+    if (ZE_RESULT_SUCCESS == pFwInterface->fwGetVersion(fwVersion)) {
+        strncpy_s(firmwareVersion, ZES_STRING_PROPERTY_SIZE, fwVersion.c_str(), ZES_STRING_PROPERTY_SIZE);
+    } else {
+        strncpy_s(firmwareVersion, ZES_STRING_PROPERTY_SIZE, unknown.c_str(), ZES_STRING_PROPERTY_SIZE);
+    }
+}
+
+void LinuxFirmwareImp::getOpromVersion(char *firmwareVersion) {
+    std::string fwVersion;
+    if (ZE_RESULT_SUCCESS == pFwInterface->opromGetVersion(fwVersion)) {
+        strncpy_s(firmwareVersion, ZES_STRING_PROPERTY_SIZE, fwVersion.c_str(), ZES_STRING_PROPERTY_SIZE);
+    } else {
+        strncpy_s(firmwareVersion, ZES_STRING_PROPERTY_SIZE, unknown.c_str(), ZES_STRING_PROPERTY_SIZE);
+    }
 }
 
-LinuxFirmwareImp::LinuxFirmwareImp(OsSysman *pOsSysman) {
+LinuxFirmwareImp::LinuxFirmwareImp(OsSysman *pOsSysman, const std::string &fwType) : osFwType(fwType) {
     LinuxSysmanImp *pLinuxSysmanImp = static_cast<LinuxSysmanImp *>(pOsSysman);
     pFwInterface = pLinuxSysmanImp->getFwUtilInterface();
 }
 
-OsFirmware *OsFirmware::create(OsSysman *pOsSysman) {
-    LinuxFirmwareImp *pLinuxFirmwareImp = new LinuxFirmwareImp(pOsSysman);
-    return static_cast<OsFirmware *>(pLinuxFirmwareImp);
+std::unique_ptr<OsFirmware> OsFirmware::create(OsSysman *pOsSysman, const std::string &fwType) {
+    std::unique_ptr<LinuxFirmwareImp> pLinuxFirmwareImp = std::make_unique<LinuxFirmwareImp>(pOsSysman, fwType);
+    return pLinuxFirmwareImp;
 }
 
 } // namespace L0

level_zero/tools/source/sysman/firmware/linux/os_firmware_imp.h

@@ -20,15 +20,17 @@ class LinuxFirmwareImp : public OsFirmware, NEO::NonCopyableOrMovableClass {
     void osGetFwProperties(zes_firmware_properties_t *pProperties) override;
     ze_result_t osFirmwareFlash(void *pImage, uint32_t size) override;
     LinuxFirmwareImp() = default;
-    LinuxFirmwareImp(OsSysman *pOsSysman);
+    LinuxFirmwareImp(OsSysman *pOsSysman, const std::string &fwType);
     ~LinuxFirmwareImp() override = default;
 
   protected:
     FirmwareUtil *pFwInterface = nullptr;
     bool isFWInitalized = false;
+    std::string osFwType;
 
   private:
     void getFirmwareVersion(char *);
+    void getOpromVersion(char *);
 };
 
 } // namespace L0

level_zero/tools/source/sysman/firmware/os_firmware.h

@@ -10,14 +10,19 @@
 #include "level_zero/tools/source/sysman/os_sysman.h"
 #include <level_zero/zes_api.h>
 
+#include <memory>
+#include <string>
+#include <vector>
+
 namespace L0 {
 
 class OsFirmware {
   public:
     virtual bool isFirmwareSupported(void) = 0;
     virtual void osGetFwProperties(zes_firmware_properties_t *pProperties) = 0;
     virtual ze_result_t osFirmwareFlash(void *pImage, uint32_t size) = 0;
-    static OsFirmware *create(OsSysman *pOsSysman);
+    static std::unique_ptr<OsFirmware> create(OsSysman *pOsSysman, const std::string &fwType);
+    static ze_result_t getSupportedFwTypes(std::vector<std::string> &supportedFwTypes, OsSysman *pOsSysman);
     virtual ~OsFirmware() {}
 };
 

level_zero/tools/source/sysman/firmware/windows/os_firmware_imp.cpp

@@ -18,9 +18,13 @@ ze_result_t WddmFirmwareImp::osFirmwareFlash(void *pImage, uint32_t size) {
     return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 };
 
-OsFirmware *OsFirmware::create(OsSysman *pOsSysman) {
-    WddmFirmwareImp *pWddmFirmwareImp = new WddmFirmwareImp();
-    return static_cast<OsFirmware *>(pWddmFirmwareImp);
+std::unique_ptr<OsFirmware> OsFirmware::create(OsSysman *pOsSysman, const std::string &fwType) {
+    std::unique_ptr<WddmFirmwareImp> pWddmFirmwareImp = std::make_unique<WddmFirmwareImp>();
+    return pWddmFirmwareImp;
+}
+
+ze_result_t OsFirmware::getSupportedFwTypes(std::vector<std::string> &supportedFwTypes, OsSysman *pOsSysman) {
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 } // namespace L0

level_zero/tools/source/sysman/linux/firmware_util/firmware_util.h

@@ -27,7 +27,9 @@ class FirmwareUtil {
     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 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 ~FirmwareUtil() = default;
 };
 } // namespace L0

level_zero/tools/source/sysman/linux/firmware_util/firmware_util_imp.cpp

@@ -16,6 +16,10 @@ const std::string FirmwareUtilImp::fwDeviceIteratorCreate = "igsc_device_iterato
 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";
 
 template <class T>
 bool FirmwareUtilImp::getSymbolAddr(const std::string name, T &proc) {
@@ -32,6 +36,10 @@ bool FirmwareUtilImp::loadEntryPoints() {
     ok = ok && getSymbolAddr(fwDeviceIteratorNext, deviceItreatorNext);
     ok = ok && getSymbolAddr(fwDeviceIteratorDestroy, deviceItreatorDestroy);
     ok = ok && getSymbolAddr(fwDeviceFwUpdate, deviceFwUpdate);
+    ok = ok && getSymbolAddr(fwImageOpromInit, imageOpromInit);
+    ok = ok && getSymbolAddr(fwImageOpromType, imageOpromType);
+    ok = ok && getSymbolAddr(fwDeviceOpromUpdate, deviceOpromUpdate);
+    ok = ok && getSymbolAddr(fwDeviceOpromVersion, deviceOpromVersion);
     return ok;
 }
 
@@ -90,13 +98,62 @@ ze_result_t FirmwareUtilImp::fwGetVersion(std::string &fwVersion) {
     return ZE_RESULT_SUCCESS;
 }
 
+ze_result_t FirmwareUtilImp::opromGetVersion(std::string &fwVersion) {
+    igsc_oprom_version opromVersion;
+    memset(&opromVersion, 0, sizeof(opromVersion));
+    int ret = deviceOpromVersion(&fwDeviceHandle, IGSC_OPROM_CODE, &opromVersion);
+    if (ret != IGSC_SUCCESS) {
+        return ZE_RESULT_ERROR_UNINITIALIZED;
+    }
+    fwVersion.append("OPROM CODE VERSION:");
+    for (int i = 0; i < IGSC_OPROM_VER_SIZE; i++) {
+        fwVersion.append(std::to_string(static_cast<unsigned int>(opromVersion.version[i])));
+    }
+    fwVersion.append("_");
+    memset(&opromVersion, 0, sizeof(opromVersion));
+    ret = deviceOpromVersion(&fwDeviceHandle, IGSC_OPROM_DATA, &opromVersion);
+    if (ret != IGSC_SUCCESS) {
+        return ZE_RESULT_ERROR_UNINITIALIZED;
+    }
+    fwVersion.append("OPROM DATA VERSION:");
+    for (int i = 0; i < IGSC_OPROM_VER_SIZE; i++) {
+        fwVersion.append(std::to_string(static_cast<unsigned int>(opromVersion.version[i])));
+    }
+    return ZE_RESULT_SUCCESS;
+}
+
 ze_result_t FirmwareUtilImp::fwFlashGSC(void *pImage, uint32_t size) {
     int ret = deviceFwUpdate(&fwDeviceHandle, static_cast<const uint8_t *>(pImage), size, progressFunc, nullptr);
     if (ret != IGSC_SUCCESS) {
         return ZE_RESULT_ERROR_UNINITIALIZED;
     }
     return ZE_RESULT_SUCCESS;
 }
+
+ze_result_t FirmwareUtilImp::fwFlashOprom(void *pImage, uint32_t size) {
+    struct igsc_oprom_image *opromImg = nullptr;
+    uint32_t opromImgType = 0;
+    int retData = 0, retCode = 0;
+    int ret = imageOpromInit(&opromImg, static_cast<const uint8_t *>(pImage), size);
+    if (ret != IGSC_SUCCESS) {
+        return ZE_RESULT_ERROR_UNINITIALIZED;
+    }
+    ret = imageOpromType(opromImg, &opromImgType);
+    if (ret != IGSC_SUCCESS) {
+        return ZE_RESULT_ERROR_UNINITIALIZED;
+    }
+    if (opromImgType & IGSC_OPROM_DATA) {
+        retData = deviceOpromUpdate(&fwDeviceHandle, IGSC_OPROM_DATA, opromImg, progressFunc, nullptr);
+    }
+    if (opromImgType & IGSC_OPROM_CODE) {
+        retCode = deviceOpromUpdate(&fwDeviceHandle, IGSC_OPROM_CODE, opromImg, progressFunc, nullptr);
+    }
+    if ((retData != IGSC_SUCCESS) && (retCode != IGSC_SUCCESS)) {
+        return ZE_RESULT_ERROR_UNINITIALIZED;
+    }
+    return ZE_RESULT_SUCCESS;
+}
+
 FirmwareUtilImp::FirmwareUtilImp(){};
 
 FirmwareUtilImp::~FirmwareUtilImp() {