intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-20 00:24:58 +08:00
Code Issues Packages Projects Releases Wiki Activity

feature: support SPI flash during survivability

Browse Source 
Related-To: NEO-16095

Signed-off-by: shubham kumar <shubham.kumar@intel.com>
This commit is contained in:
shubham kumar
2025-11-18 07:29:18 +00:00
committed by Compute-Runtime-Automation
parent 864ba10e8a
commit a0deb9cbe2
15 changed files with 147 additions and 6 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
level_zero/sysman/source/api/firmware/linux/CMakeLists.txt
View File

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

16
level_zero/sysman/source/api/firmware/linux/sysman_os_firmware_imp.cpp
View File

@@ -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);
}

1
level_zero/sysman/source/api/firmware/linux/sysman_os_firmware_imp.h
View File

@@ -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;

18
level_zero/sysman/source/api/firmware/linux/sysman_os_firmware_imp_extended.cpp Normal file
View File

@@ -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

3
level_zero/sysman/source/api/firmware/linux/sysman_os_firmware_imp_helper.cpp
View File

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

3
level_zero/sysman/source/shared/linux/kmd_interface/CMakeLists.txt
View File

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

2
level_zero/sysman/source/shared/linux/kmd_interface/sysman_kmd_interface.h
View File

@@ -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;

18
level_zero/sysman/source/shared/linux/kmd_interface/sysman_kmd_interface_xe_extended.cpp Normal file
View File

@@ -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

5
level_zero/sysman/test/unit_tests/sources/firmware/linux/CMakeLists.txt
View File

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

4
level_zero/sysman/test/unit_tests/sources/firmware/linux/test_zes_sysman_firmware.cpp
View File

@@ -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));

42
level_zero/sysman/test/unit_tests/sources/firmware/linux/test_zes_sysman_firmware_extended.cpp Normal file
View File

@@ -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

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

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

30
level_zero/sysman/test/unit_tests/sources/shared/linux/kmd_interface/test_sysman_kmd_interface_xe_extended.cpp Normal file
View File

@@ -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

4
shared/test/common/os_interface/linux/sys_calls_linux_ult.cpp
View File

@@ -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) {

1
shared/test/common/os_interface/linux/sys_calls_linux_ult.h
View File

@@ -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;