feature: support SPI flash during survivability

Related-To: NEO-16095

Signed-off-by: shubham kumar <shubham.kumar@intel.com>

level_zero/sysman/source/api/firmware/linux/CMakeLists.txt

@@ -1,5 +1,5 @@
 #
-# Copyright (C) 2020-2024 Intel Corporation
+# Copyright (C) 2020-2025 Intel Corporation
 #
 # SPDX-License-Identifier: MIT
 #
@@ -11,5 +11,6 @@ if(UNIX)
                  ${CMAKE_CURRENT_SOURCE_DIR}/sysman_os_firmware_imp.cpp
                  ${CMAKE_CURRENT_SOURCE_DIR}/sysman_os_firmware_imp.h
                  ${CMAKE_CURRENT_SOURCE_DIR}/sysman_os_firmware_imp_helper.cpp
+                 ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}sysman_os_firmware_imp_extended.cpp
   )
 endif()

level_zero/sysman/source/api/firmware/linux/sysman_os_firmware_imp.cpp

@@ -16,18 +16,27 @@
 namespace L0 {
 namespace Sysman {
 
+static const std::string fdoFwType = "Flash_Override";
+
 void OsFirmware::getSupportedFwTypes(std::vector<std::string> &supportedFwTypes, OsSysman *pOsSysman) {
     LinuxSysmanImp *pLinuxSysmanImp = static_cast<LinuxSysmanImp *>(pOsSysman);
     FirmwareUtil *pFwInterface = pLinuxSysmanImp->getFwUtilInterface();
+    auto pSysmanKmdInterface = pLinuxSysmanImp->getSysmanKmdInterface();
     supportedFwTypes.clear();
+    bool isDeviceInSurvivabilityMode = pLinuxSysmanImp->isDeviceInSurvivabilityMode();
+
+    if (isDeviceInSurvivabilityMode && pSysmanKmdInterface->isDeviceInFdoMode()) {
+        supportedFwTypes.push_back(fdoFwType);
+        return;
+    }
+
     if (pFwInterface != nullptr) {
-        if (pLinuxSysmanImp->isDeviceInSurvivabilityMode()) {
+        if (isDeviceInSurvivabilityMode) {
             pFwInterface->getDeviceSupportedFwTypes(supportedFwTypes);
         } else {
             auto pSysmanProductHelper = pLinuxSysmanImp->getSysmanProductHelper();
             pSysmanProductHelper->getDeviceSupportedFwTypes(pFwInterface, supportedFwTypes);
             // get supported late binding fw handles
-            auto pSysmanKmdInterface = pLinuxSysmanImp->getSysmanKmdInterface();
             pSysmanKmdInterface->getLateBindingSupportedFwTypes(supportedFwTypes);
         }
     }
@@ -41,6 +50,9 @@ void LinuxFirmwareImp::osGetFwProperties(zes_firmware_properties_t *pProperties)
 }
 
 ze_result_t LinuxFirmwareImp::osFirmwareFlash(void *pImage, uint32_t size) {
+    if (osFwType == fdoFwType) {
+        return osFirmwareFlashExtended(pImage, size);
+    }
     return pFwInterface->flashFirmware(osFwType, pImage, size);
 }
 

level_zero/sysman/source/api/firmware/linux/sysman_os_firmware_imp.h

@@ -26,6 +26,7 @@ class LinuxFirmwareImp : public OsFirmware, NEO::NonCopyableAndNonMovableClass {
   public:
     void osGetFwProperties(zes_firmware_properties_t *pProperties) override;
     ze_result_t osFirmwareFlash(void *pImage, uint32_t size) override;
+    ze_result_t osFirmwareFlashExtended(void *pImage, uint32_t size);
     ze_result_t osGetFirmwareFlashProgress(uint32_t *pCompletionPercent) override;
     ze_result_t osGetSecurityVersion(char *pVersion) override;
     ze_result_t osSetSecurityVersion() override;

level_zero/sysman/source/api/firmware/linux/sysman_os_firmware_imp_extended.cpp

@@ -0,0 +1,18 @@
+/*
+ * Copyright (C) 2025 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "level_zero/sysman/source/api/firmware/linux/sysman_os_firmware_imp.h"
+
+namespace L0 {
+namespace Sysman {
+
+ze_result_t LinuxFirmwareImp::osFirmwareFlashExtended(void *pImage, uint32_t size) {
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+} // namespace Sysman
+} // namespace L0

level_zero/sysman/source/api/firmware/linux/sysman_os_firmware_imp_helper.cpp

@@ -20,6 +20,9 @@ namespace Sysman {
 
 ze_result_t LinuxFirmwareImp::getFirmwareVersion(std::string fwType, zes_firmware_properties_t *pProperties) {
     std::string fwVersion;
+    if (fwType == "Flash_Override") {
+        return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+    }
     if (fwType == "PSC") {
         std::string path;
         path.clear();

level_zero/sysman/source/shared/linux/kmd_interface/CMakeLists.txt

@@ -1,5 +1,5 @@
 #
-# Copyright (C) 2024 Intel Corporation
+# Copyright (C) 2024-2025 Intel Corporation
 #
 # SPDX-License-Identifier: MIT
 #
@@ -12,5 +12,6 @@ if(UNIX)
                  ${CMAKE_CURRENT_SOURCE_DIR}/sysman_kmd_interface_i915_upstream.cpp
                  ${CMAKE_CURRENT_SOURCE_DIR}/sysman_kmd_interface_xe.cpp
                  ${CMAKE_CURRENT_SOURCE_DIR}/sysman_kmd_interface.h
+                 ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}sysman_kmd_interface_xe_extended.cpp
   )
 endif()

level_zero/sysman/source/shared/linux/kmd_interface/sysman_kmd_interface.h

@@ -197,6 +197,7 @@ class SysmanKmdInterface {
     virtual ze_result_t readPcieDowngradeAttribute(std::string sysfsName, uint32_t &val) { return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; }
     virtual void getLateBindingSupportedFwTypes(std::vector<std::string> &fwTypes) {}
     virtual bool isLateBindingVersionAvailable(std::string fwType, std::string &fwVersion) { return false; }
+    virtual bool isDeviceInFdoMode() { return false; }
 
   protected:
     std::unique_ptr<FsAccessInterface> pFsAccess;
@@ -424,6 +425,7 @@ class SysmanKmdInterfaceXe : public SysmanKmdInterface {
     ze_result_t readPcieDowngradeAttribute(std::string sysfsName, uint32_t &val) override;
     void getLateBindingSupportedFwTypes(std::vector<std::string> &fwTypes) override;
     bool isLateBindingVersionAvailable(std::string fwType, std::string &fwVersion) override;
+    bool isDeviceInFdoMode() override;
 
   protected:
     std::map<SysfsName, valuePair> sysfsNameToFileMap;

level_zero/sysman/source/shared/linux/kmd_interface/sysman_kmd_interface_xe_extended.cpp

@@ -0,0 +1,18 @@
+/*
+ * Copyright (C) 2025 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "level_zero/sysman/source/shared/linux/kmd_interface/sysman_kmd_interface.h"
+
+namespace L0 {
+namespace Sysman {
+
+bool SysmanKmdInterfaceXe::isDeviceInFdoMode() {
+    return false;
+}
+
+} // namespace Sysman
+} // namespace L0

level_zero/sysman/test/unit_tests/sources/firmware/linux/CMakeLists.txt

@@ -1,5 +1,5 @@
 #
-# Copyright (C) 2020-2024 Intel Corporation
+# Copyright (C) 2020-2025 Intel Corporation
 #
 # SPDX-License-Identifier: MIT
 #
@@ -8,6 +8,7 @@ set(L0_TESTS_SYSMAN_FIRMWARE_LINUX
     ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
     ${CMAKE_CURRENT_SOURCE_DIR}/test_zes_sysman_firmware.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/mock_zes_sysman_firmware.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/${BRANCH_DIR_SUFFIX}test_zes_sysman_firmware_extended.cpp
 )
 
 if(UNIX)
@@ -16,3 +17,5 @@ if(UNIX)
                  ${L0_TESTS_SYSMAN_FIRMWARE_LINUX}
   )
 endif()
+
+add_subdirectories()

level_zero/sysman/test/unit_tests/sources/firmware/linux/test_zes_sysman_firmware.cpp

@@ -8,6 +8,7 @@
 #include "level_zero/sysman/source/driver/sysman_os_driver.h"
 #include "level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper_hw.h"
 #include "level_zero/sysman/test/unit_tests/sources/firmware/linux/mock_zes_sysman_firmware.h"
+#include "level_zero/sysman/test/unit_tests/sources/linux/mocks/mock_sysman_product_helper.h"
 
 #include <algorithm>
 
@@ -148,6 +149,9 @@ TEST_F(SysmanSurvivabilityDeviceTest, GivenSurvivabilityDeviceWhenFirmwareEnumer
     auto pOsSysman = pSysmanDeviceImp->pOsSysman;
     auto pLinuxSysmanImp = static_cast<PublicLinuxSysmanImp *>(pOsSysman);
     pLinuxSysmanImp->pFwUtilInterface = new MockFirmwareInterface();
+    std::unique_ptr<SysmanProductHelper> pSysmanProductHelper = std::make_unique<MockSysmanProductHelper>();
+    std::swap(pLinuxSysmanImp->pSysmanProductHelper, pSysmanProductHelper);
+    pLinuxSysmanImp->pSysmanKmdInterface.reset(new SysmanKmdInterfaceI915Prelim(pLinuxSysmanImp->getSysmanProductHelper()));
 
     uint32_t count = 0;
     EXPECT_EQ(ZE_RESULT_SUCCESS, SysmanDevice::firmwareGet(pSysmanDevice->toHandle(), &count, nullptr));

level_zero/sysman/test/unit_tests/sources/firmware/linux/test_zes_sysman_firmware_extended.cpp

@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2020-2025 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "level_zero/sysman/source/api/firmware/linux/sysman_os_firmware_imp.h"
+#include "level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_fixture.h"
+
+#include "gtest/gtest.h"
+
+namespace L0 {
+namespace Sysman {
+namespace ult {
+
+class SysmanFirmwareExtendedFixture : public SysmanDeviceFixture {
+  protected:
+    void SetUp() override {
+        SysmanDeviceFixture::SetUp();
+    }
+
+    void TearDown() override {
+        SysmanDeviceFixture::TearDown();
+    }
+};
+
+TEST_F(SysmanFirmwareExtendedFixture, GivenLinuxFirmwareImpWhenCallingOsFirmwareFlashExtendedThenUnsupportedFeatureIsReturned) {
+    // Create LinuxFirmwareImp object with Flash_Override firmware type
+    auto pLinuxFirmwareImp = std::make_unique<LinuxFirmwareImp>(pOsSysman, "Flash_Override");
+
+    // Create test firmware image data
+    std::vector<uint8_t> firmwareData(1024, 0xDD); // 1KB test data
+
+    // Call osFirmwareFlashExtended and expect unsupported feature error
+    ze_result_t result = pLinuxFirmwareImp->osFirmwareFlashExtended(firmwareData.data(), static_cast<uint32_t>(firmwareData.size()));
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result);
+}
+
+} // namespace ult
+} // namespace Sysman
+} // namespace L0

level_zero/sysman/test/unit_tests/sources/shared/linux/kmd_interface/CMakeLists.txt

@@ -11,6 +11,7 @@ set(L0_SYSMAN_SHARED_TESTS
     ${CMAKE_CURRENT_SOURCE_DIR}/test_sysman_kmd_interface_i915_prelim.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/test_sysman_kmd_interface_i915_upstream.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/test_sysman_kmd_interface_xe.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/${BRANCH_DIR_SUFFIX}test_sysman_kmd_interface_xe_extended.cpp
 )
 
 if(UNIX)
@@ -18,4 +19,4 @@ if(UNIX)
                  PRIVATE
                  ${L0_SYSMAN_SHARED_TESTS}
   )
-endif()
+endif()

level_zero/sysman/test/unit_tests/sources/shared/linux/kmd_interface/test_sysman_kmd_interface_xe_extended.cpp

@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2025 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_fixture.h"
+
+namespace L0 {
+namespace Sysman {
+namespace ult {
+
+class SysmanKmdInterfaceXeExtendedFixture : public SysmanDeviceFixture {
+  public:
+    void SetUp() override {
+        SysmanDeviceFixture::SetUp();
+        pLinuxSysmanImp->pSysmanKmdInterface.reset(new SysmanKmdInterfaceXe(pLinuxSysmanImp->getSysmanProductHelper()));
+    }
+};
+
+TEST_F(SysmanKmdInterfaceXeExtendedFixture, GivenSysmanKmdInterfaceWhenCallingIsDeviceInFdoModeThenFalseIsReturned) {
+    // Test the main implementation which simply returns false
+    auto pSysmanKmdInterface = pLinuxSysmanImp->pSysmanKmdInterface.get();
+    EXPECT_FALSE(pSysmanKmdInterface->isDeviceInFdoMode());
+}
+
+} // namespace ult
+} // namespace Sysman
+} // namespace L0

shared/test/common/os_interface/linux/sys_calls_linux_ult.cpp

@@ -118,6 +118,7 @@ int (*sysCallsGetDevicePath)(int deviceFd, char *buf, size_t &bufSize) = nullptr
 int (*sysCallsPidfdOpen)(pid_t pid, unsigned int flags) = nullptr;
 int (*sysCallsPidfdGetfd)(int pidfd, int fd, unsigned int flags) = nullptr;
 int (*sysCallsPrctl)(int option, unsigned long arg) = nullptr;
+off_t (*sysCallsLseek)(int fd, off_t offset, int whence) = nullptr;
 off_t lseekReturn = 4096u;
 std::atomic<int> lseekCalledCount(0);
 long sysconfReturn = 1ull << 30;
@@ -520,6 +521,9 @@ int closedir(DIR *dir) {
 
 off_t lseek(int fd, off_t offset, int whence) noexcept {
     lseekCalledCount++;
+    if (sysCallsLseek != nullptr) {
+        return sysCallsLseek(fd, offset, whence);
+    }
     return lseekReturn;
 }
 long sysconf(int name) {

shared/test/common/os_interface/linux/sys_calls_linux_ult.h

@@ -58,6 +58,7 @@ extern int (*sysCallsClose)(int fileDescriptor);
 extern int (*sysCallsPidfdOpen)(pid_t pid, unsigned int flags);
 extern int (*sysCallsPidfdGetfd)(int pidfd, int fd, unsigned int flags);
 extern int (*sysCallsPrctl)(int option, unsigned long arg);
+extern off_t (*sysCallsLseek)(int fd, off_t offset, int whence);
 
 extern bool allowFakeDevicePath;
 extern int flockRetVal;