diff --git a/level_zero/sysman/source/api/ecc/sysman_ecc_imp.cpp b/level_zero/sysman/source/api/ecc/sysman_ecc_imp.cpp index 253dad056e..825fb43d73 100644 --- a/level_zero/sysman/source/api/ecc/sysman_ecc_imp.cpp +++ b/level_zero/sysman/source/api/ecc/sysman_ecc_imp.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2023 Intel Corporation + * Copyright (C) 2023-2025 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -37,34 +37,29 @@ ze_result_t EccImp::deviceEccAvailable(ze_bool_t *pAvailable) { if (pFwInterface == nullptr) { ze_result_t result = getEccFwUtilInterface(pFwInterface); if (result != ZE_RESULT_SUCCESS) { - NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Failed while getting EccFwUtilInterface() and returning error:0x%x \n", __FUNCTION__, ZE_RESULT_ERROR_UNSUPPORTED_FEATURE); - return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + return result; } } - *pAvailable = false; - uint8_t currentState = 0; - uint8_t pendingState = 0; - ze_result_t result = pFwInterface->fwGetEccConfig(¤tState, &pendingState); - if (ZE_RESULT_SUCCESS == result) { - if ((currentState != eccStateNone) && (pendingState != eccStateNone)) { - *pAvailable = true; - } - } - - return result; + return pFwInterface->fwGetEccAvailable(pAvailable); } ze_result_t EccImp::deviceEccConfigurable(ze_bool_t *pConfigurable) { - return deviceEccAvailable(pConfigurable); + if (pFwInterface == nullptr) { + ze_result_t result = getEccFwUtilInterface(pFwInterface); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + } + + return pFwInterface->fwGetEccConfigurable(pConfigurable); } ze_result_t EccImp::getEccState(zes_device_ecc_properties_t *pState) { if (pFwInterface == nullptr) { ze_result_t result = getEccFwUtilInterface(pFwInterface); if (result != ZE_RESULT_SUCCESS) { - NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Failed while getting EccFwUtilInterface() and returning error \n", __FUNCTION__, ZE_RESULT_ERROR_UNSUPPORTED_FEATURE); - return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + return result; } } @@ -72,7 +67,6 @@ ze_result_t EccImp::getEccState(zes_device_ecc_properties_t *pState) { uint8_t pendingState = 0; ze_result_t result = pFwInterface->fwGetEccConfig(¤tState, &pendingState); if (result != ZE_RESULT_SUCCESS) { - NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Failed to get ecc configuration and returning error:0x%x \n", __FUNCTION__, result); return result; } pState->currentState = getEccState(currentState); diff --git a/level_zero/sysman/source/shared/firmware_util/sysman_firmware_util.h b/level_zero/sysman/source/shared/firmware_util/sysman_firmware_util.h index 232a9a694a..7ab6ade642 100644 --- a/level_zero/sysman/source/shared/firmware_util/sysman_firmware_util.h +++ b/level_zero/sysman/source/shared/firmware_util/sysman_firmware_util.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2022-2024 Intel Corporation + * Copyright (C) 2022-2025 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -28,6 +28,8 @@ class FirmwareUtil { virtual ze_result_t fwSupportedDiagTests(std::vector &supportedDiagTests) = 0; virtual ze_result_t fwRunDiagTests(std::string &osDiagType, zes_diag_result_t *pDiagResult) = 0; virtual ze_result_t fwGetMemoryErrorCount(zes_ras_error_type_t type, uint32_t subDeviceCount, uint32_t subDeviceId, uint64_t &count) = 0; + virtual ze_result_t fwGetEccAvailable(ze_bool_t *pAvailable) = 0; + virtual ze_result_t fwGetEccConfigurable(ze_bool_t *pConfigurable) = 0; virtual ze_result_t fwGetEccConfig(uint8_t *currentState, uint8_t *pendingState) = 0; virtual ze_result_t fwSetEccConfig(uint8_t newState, uint8_t *currentState, uint8_t *pendingState) = 0; virtual void getDeviceSupportedFwTypes(std::vector &fwTypes) = 0; diff --git a/level_zero/sysman/source/shared/firmware_util/sysman_firmware_util_imp.h b/level_zero/sysman/source/shared/firmware_util/sysman_firmware_util_imp.h index 8355894ff1..5803ab8992 100644 --- a/level_zero/sysman/source/shared/firmware_util/sysman_firmware_util_imp.h +++ b/level_zero/sysman/source/shared/firmware_util/sysman_firmware_util_imp.h @@ -74,14 +74,13 @@ typedef int (*pIgscIfrRunMemPPRTest)(struct igsc_device_handle *handle, uint32_t *pendingReset, uint32_t *errorCode); -typedef int (*pIgscGetEccConfig)(struct igsc_device_handle *handle, - uint8_t *curEccState, - uint8_t *penEccState); - -typedef int (*pIgscSetEccConfig)(struct igsc_device_handle *handle, - uint8_t reqEccState, - uint8_t *curEccState, - uint8_t *penEccState); +typedef int (*pIgscGfspHeciCmd)(struct igsc_device_handle *handle, + uint32_t gfspCmd, + uint8_t *inBuffer, + size_t inBufferSize, + uint8_t *outBuffer, + size_t outBufferSize, + size_t *actualOutBufferSize); extern pIgscDeviceInitByDevice deviceInitByDevice; extern pIgscDeviceGetDeviceInfo deviceGetDeviceInfo; @@ -100,8 +99,7 @@ extern pIgscIafPscUpdate iafPscUpdate; extern pIgscGfspMemoryErrors gfspMemoryErrors; extern pIgscGfspCountTiles gfspCountTiles; extern pIgscIfrRunMemPPRTest deviceIfrRunMemPPRTest; -extern pIgscGetEccConfig getEccConfig; -extern pIgscSetEccConfig setEccConfig; +extern pIgscGfspHeciCmd gfspHeciCmd; extern void firmwareFlashProgressFunc(uint32_t done, uint32_t total, void *ctx); @@ -110,6 +108,38 @@ typedef struct { std::mutex fwProgressLock; } FlashProgressInfo; +namespace GfspHeciConstants { +enum Cmd { + setEccConfigurationCmd8 = 0x8, + getEccConfigurationCmd9 = 0x9, + setEccConfigurationCmd15 = 0xf, + getEccConfigurationCmd16 = 0x10 +}; + +enum SetEccCmd15BytePostition { + request = 0, + response = 0 +}; + +enum SetEccCmd8BytePostition { + setRequest = 0, + responseCurrentState = 0, + responsePendingState = 1 +}; + +enum GetEccCmd16BytePostition { + eccAvailable = 0, + eccCurrentState = 4, + eccConfigurable = 8, + eccPendingState = 12 +}; + +enum GetEccCmd9BytePostition { + currentState = 0, + pendingState = 1 +}; +} // namespace GfspHeciConstants + class FirmwareUtilImp : public FirmwareUtil, NEO::NonCopyableAndNonMovableClass { public: FirmwareUtilImp(uint16_t domain, uint8_t bus, uint8_t device, uint8_t function); @@ -122,6 +152,8 @@ class FirmwareUtilImp : public FirmwareUtil, NEO::NonCopyableAndNonMovableClass ze_result_t fwSupportedDiagTests(std::vector &supportedDiagTests) override; ze_result_t fwRunDiagTests(std::string &osDiagType, zes_diag_result_t *pDiagResult) override; ze_result_t fwGetMemoryErrorCount(zes_ras_error_type_t type, uint32_t subDeviceCount, uint32_t subDeviceId, uint64_t &count) override; + ze_result_t fwGetEccAvailable(ze_bool_t *pAvailable) override; + ze_result_t fwGetEccConfigurable(ze_bool_t *pConfigurable) override; ze_result_t fwGetEccConfig(uint8_t *currentState, uint8_t *pendingState) override; ze_result_t fwSetEccConfig(uint8_t newState, uint8_t *currentState, uint8_t *pendingState) override; void getDeviceSupportedFwTypes(std::vector &fwTypes) override; diff --git a/level_zero/sysman/source/shared/firmware_util/sysman_firmware_util_imp_helper.cpp b/level_zero/sysman/source/shared/firmware_util/sysman_firmware_util_imp_helper.cpp index 33f60f656a..2b7815e02d 100644 --- a/level_zero/sysman/source/shared/firmware_util/sysman_firmware_util_imp_helper.cpp +++ b/level_zero/sysman/source/shared/firmware_util/sysman_firmware_util_imp_helper.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2020-2024 Intel Corporation + * Copyright (C) 2020-2025 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -10,6 +10,9 @@ #include "level_zero/sysman/source/shared/firmware_util/sysman_firmware_util_imp.h" static std::vector deviceSupportedFirmwareTypes = {"GSC", "OptionROM", "PSC"}; +static constexpr uint8_t eccStateNone = 0xFF; +constexpr uint8_t maxGfspHeciOutBuffer = UINT8_MAX; +constexpr uint8_t maxGfspHeciInBuffer = 4; namespace L0 { namespace Sysman { @@ -20,8 +23,7 @@ const std::string fwGfspMemoryErrors = "igsc_gfsp_memory_errors"; const std::string fwGfspGetHealthIndicator = "igsc_gfsp_get_health_indicator"; const std::string fwGfspCountTiles = "igsc_gfsp_count_tiles"; const std::string fwDeviceIfrRunMemPPRTest = "igsc_ifr_run_mem_ppr_test"; -const std::string fwEccConfigGet = "igsc_ecc_config_get"; -const std::string fwEccConfigSet = "igsc_ecc_config_set"; +const std::string fwGfspHeciCmd = "igsc_gfsp_heci_cmd"; pIgscIfrGetStatusExt deviceIfrGetStatusExt; pIgscIafPscUpdate iafPscUpdate; @@ -29,8 +31,7 @@ pIgscGfspMemoryErrors gfspMemoryErrors; pIgscGfspCountTiles gfspCountTiles; pIgscGfspGetHealthIndicator gfspGetHealthIndicator; pIgscIfrRunMemPPRTest deviceIfrRunMemPPRTest; -pIgscGetEccConfig getEccConfig; -pIgscSetEccConfig setEccConfig; +pIgscGfspHeciCmd gfspHeciCmd; ze_result_t FirmwareUtilImp::fwIfrApplied(bool &ifrStatus) { uint32_t supportedTests = 0; // Bitmap holding the tests supported on the platform @@ -143,26 +144,129 @@ void FirmwareUtilImp::fwGetMemoryHealthIndicator(zes_mem_health_t *health) { ze_result_t FirmwareUtilImp::fwGetEccConfig(uint8_t *currentState, uint8_t *pendingState) { const std::lock_guard lock(this->fwLock); - getEccConfig = reinterpret_cast(libraryHandle->getProcAddress(fwEccConfigGet)); - if (getEccConfig != nullptr) { - int ret = getEccConfig(&fwDeviceHandle, currentState, pendingState); - if (ret != IGSC_SUCCESS) { - return ZE_RESULT_ERROR_UNINITIALIZED; + gfspHeciCmd = reinterpret_cast(libraryHandle->getProcAddress(fwGfspHeciCmd)); + if (gfspHeciCmd != nullptr) { + std::vector outBuf(maxGfspHeciOutBuffer, 0); + size_t receivedSize = 0; + // Need to call gfspHeciCmd 0x10 cmd first and if not available, fallback and call 0x9. + int ret = gfspHeciCmd(&fwDeviceHandle, GfspHeciConstants::Cmd::getEccConfigurationCmd16, nullptr, 0, outBuf.data(), maxGfspHeciOutBuffer, &receivedSize); + + if (ret == IGSC_SUCCESS) { + *currentState = outBuf[GfspHeciConstants::GetEccCmd16BytePostition::eccCurrentState] & 0x1; + *pendingState = outBuf[GfspHeciConstants::GetEccCmd16BytePostition::eccPendingState] & 0x1; + return ZE_RESULT_SUCCESS; } - return ZE_RESULT_SUCCESS; + receivedSize = 0; + std::fill(outBuf.begin(), outBuf.end(), 0); + ret = gfspHeciCmd(&fwDeviceHandle, GfspHeciConstants::Cmd::getEccConfigurationCmd9, nullptr, 0, outBuf.data(), maxGfspHeciOutBuffer, &receivedSize); + + if (ret == IGSC_SUCCESS) { + *currentState = outBuf[GfspHeciConstants::GetEccCmd9BytePostition::currentState]; + *pendingState = outBuf[GfspHeciConstants::GetEccCmd9BytePostition::pendingState]; + return ZE_RESULT_SUCCESS; + } + return ZE_RESULT_ERROR_UNINITIALIZED; + } + return ZE_RESULT_ERROR_UNINITIALIZED; +} + +ze_result_t FirmwareUtilImp::fwGetEccAvailable(ze_bool_t *pAvailable) { + *pAvailable = false; + const std::lock_guard lock(this->fwLock); + gfspHeciCmd = reinterpret_cast(libraryHandle->getProcAddress(fwGfspHeciCmd)); + if (gfspHeciCmd != nullptr) { + std::vector outBuf(maxGfspHeciOutBuffer, 0); + size_t receivedSize = 0; + // Need to call gfspHeciCmd 0x10 cmd first and if not available, fallback and call 0x9. + int ret = gfspHeciCmd(&fwDeviceHandle, GfspHeciConstants::Cmd::getEccConfigurationCmd16, nullptr, 0, outBuf.data(), maxGfspHeciOutBuffer, &receivedSize); + + if (ret == IGSC_SUCCESS) { + *pAvailable = outBuf[GfspHeciConstants::GetEccCmd16BytePostition::eccAvailable] & 0x1; + return ZE_RESULT_SUCCESS; + } + receivedSize = 0; + std::fill(outBuf.begin(), outBuf.end(), 0); + ret = gfspHeciCmd(&fwDeviceHandle, GfspHeciConstants::Cmd::getEccConfigurationCmd9, nullptr, 0, outBuf.data(), maxGfspHeciOutBuffer, &receivedSize); + + if (ret == IGSC_SUCCESS) { + uint8_t currentState = outBuf[GfspHeciConstants::GetEccCmd9BytePostition::currentState]; + uint8_t pendingState = outBuf[GfspHeciConstants::GetEccCmd9BytePostition::pendingState]; + + if ((currentState != eccStateNone) && (pendingState != eccStateNone)) { + *pAvailable = true; + } + return ZE_RESULT_SUCCESS; + } + return ZE_RESULT_ERROR_UNINITIALIZED; + } + return ZE_RESULT_ERROR_UNINITIALIZED; +} + +ze_result_t FirmwareUtilImp::fwGetEccConfigurable(ze_bool_t *pConfigurable) { + *pConfigurable = false; + const std::lock_guard lock(this->fwLock); + gfspHeciCmd = reinterpret_cast(libraryHandle->getProcAddress(fwGfspHeciCmd)); + if (gfspHeciCmd != nullptr) { + std::vector outBuf(maxGfspHeciOutBuffer, 0); + size_t receivedSize = 0; + // Need to call gfspHeciCmd 0x10 cmd first and if not available, fallback and call 0x9. + int ret = gfspHeciCmd(&fwDeviceHandle, GfspHeciConstants::Cmd::getEccConfigurationCmd16, nullptr, 0, outBuf.data(), maxGfspHeciOutBuffer, &receivedSize); + + if (ret == IGSC_SUCCESS) { + *pConfigurable = outBuf[GfspHeciConstants::GetEccCmd16BytePostition::eccConfigurable] & 0x1; + return ZE_RESULT_SUCCESS; + } + receivedSize = 0; + std::fill(outBuf.begin(), outBuf.end(), 0); + ret = gfspHeciCmd(&fwDeviceHandle, GfspHeciConstants::Cmd::getEccConfigurationCmd9, nullptr, 0, outBuf.data(), maxGfspHeciOutBuffer, &receivedSize); + + if (ret == IGSC_SUCCESS) { + uint8_t currentState = outBuf[GfspHeciConstants::GetEccCmd9BytePostition::currentState]; + uint8_t pendingState = outBuf[GfspHeciConstants::GetEccCmd9BytePostition::pendingState]; + + if ((currentState != eccStateNone) && (pendingState != eccStateNone)) { + *pConfigurable = true; + } + return ZE_RESULT_SUCCESS; + } + return ZE_RESULT_ERROR_UNINITIALIZED; } return ZE_RESULT_ERROR_UNINITIALIZED; } ze_result_t FirmwareUtilImp::fwSetEccConfig(uint8_t newState, uint8_t *currentState, uint8_t *pendingState) { - const std::lock_guard lock(this->fwLock); - setEccConfig = reinterpret_cast(libraryHandle->getProcAddress(fwEccConfigSet)); - if (setEccConfig != nullptr) { - int ret = setEccConfig(&fwDeviceHandle, newState, currentState, pendingState); - if (ret != IGSC_SUCCESS) { - return ZE_RESULT_ERROR_UNINITIALIZED; + std::unique_lock lock(this->fwLock); + gfspHeciCmd = reinterpret_cast(libraryHandle->getProcAddress(fwGfspHeciCmd)); + if (gfspHeciCmd != nullptr) { + std::vector inBuf(maxGfspHeciInBuffer, 0); + std::vector outBuf(maxGfspHeciOutBuffer, 0); + size_t receivedSize = 0; + inBuf[GfspHeciConstants::SetEccCmd15BytePostition::request] = newState; + // Need to call gfspHeciCmd 0x15 cmd first and if not available, fallback and call 0x8. + int ret = gfspHeciCmd(&fwDeviceHandle, GfspHeciConstants::Cmd::setEccConfigurationCmd15, inBuf.data(), maxGfspHeciInBuffer, outBuf.data(), maxGfspHeciOutBuffer, &receivedSize); + + if (ret == IGSC_SUCCESS) { + lock.unlock(); + ze_result_t status = fwGetEccConfig(currentState, pendingState); + lock.lock(); + if (status != ZE_RESULT_SUCCESS) { + return status; + } + *pendingState = outBuf[GfspHeciConstants::SetEccCmd15BytePostition::response] & 0x1; + return ZE_RESULT_SUCCESS; } - return ZE_RESULT_SUCCESS; + receivedSize = 0; + std::fill(inBuf.begin(), inBuf.end(), 0); + inBuf[GfspHeciConstants::SetEccCmd8BytePostition::setRequest] = newState; + std::fill(outBuf.begin(), outBuf.end(), 0); + ret = gfspHeciCmd(&fwDeviceHandle, GfspHeciConstants::Cmd::setEccConfigurationCmd8, inBuf.data(), maxGfspHeciInBuffer, outBuf.data(), maxGfspHeciOutBuffer, &receivedSize); + + if (ret == IGSC_SUCCESS) { + *currentState = outBuf[GfspHeciConstants::SetEccCmd8BytePostition::responseCurrentState]; + *pendingState = outBuf[GfspHeciConstants::SetEccCmd8BytePostition::responsePendingState]; + return ZE_RESULT_SUCCESS; + } + return ZE_RESULT_ERROR_UNINITIALIZED; } return ZE_RESULT_ERROR_UNINITIALIZED; } diff --git a/level_zero/sysman/source/shared/linux/product_helper/xe2_hpg_core/bmg/sysman_product_helper_bmg.cpp b/level_zero/sysman/source/shared/linux/product_helper/xe2_hpg_core/bmg/sysman_product_helper_bmg.cpp index 406cd27789..11bb18dfb3 100644 --- a/level_zero/sysman/source/shared/linux/product_helper/xe2_hpg_core/bmg/sysman_product_helper_bmg.cpp +++ b/level_zero/sysman/source/shared/linux/product_helper/xe2_hpg_core/bmg/sysman_product_helper_bmg.cpp @@ -1073,6 +1073,11 @@ ze_result_t SysmanProductHelperHw::getPowerEnergyCounter(zes_power_e return ZE_RESULT_SUCCESS; } +template <> +bool SysmanProductHelperHw::isEccConfigurationSupported() { + return true; +} + template class SysmanProductHelperHw; } // namespace Sysman diff --git a/level_zero/sysman/test/unit_tests/sources/diagnostics/linux/mock_zes_sysman_diagnostics.h b/level_zero/sysman/test/unit_tests/sources/diagnostics/linux/mock_zes_sysman_diagnostics.h index 7229db6d74..e7686aef7e 100644 --- a/level_zero/sysman/test/unit_tests/sources/diagnostics/linux/mock_zes_sysman_diagnostics.h +++ b/level_zero/sysman/test/unit_tests/sources/diagnostics/linux/mock_zes_sysman_diagnostics.h @@ -60,6 +60,8 @@ struct MockDiagnosticsFwInterface : public L0::Sysman::FirmwareUtil { ADDMETHOD_NOBASE(flashFirmware, ze_result_t, ZE_RESULT_SUCCESS, (std::string fwType, void *pImage, uint32_t size)); ADDMETHOD_NOBASE(fwIfrApplied, ze_result_t, ZE_RESULT_SUCCESS, (bool &ifrStatus)); ADDMETHOD_NOBASE(fwGetMemoryErrorCount, ze_result_t, ZE_RESULT_SUCCESS, (zes_ras_error_type_t category, uint32_t subDeviceCount, uint32_t subDeviceId, uint64_t &count)); + ADDMETHOD_NOBASE(fwGetEccAvailable, ze_result_t, ZE_RESULT_SUCCESS, (ze_bool_t * pAvailable)); + ADDMETHOD_NOBASE(fwGetEccConfigurable, ze_result_t, ZE_RESULT_SUCCESS, (ze_bool_t * pConfigurable)); ADDMETHOD_NOBASE(fwGetEccConfig, ze_result_t, ZE_RESULT_SUCCESS, (uint8_t * currentState, uint8_t *pendingState)); ADDMETHOD_NOBASE(fwSetEccConfig, ze_result_t, ZE_RESULT_SUCCESS, (uint8_t newState, uint8_t *currentState, uint8_t *pendingState)); ADDMETHOD_NOBASE_VOIDRETURN(getDeviceSupportedFwTypes, (std::vector & fwTypes)); diff --git a/level_zero/sysman/test/unit_tests/sources/ecc/linux/mock_ecc.h b/level_zero/sysman/test/unit_tests/sources/ecc/linux/mock_ecc.h index 03f982cb6f..17cb984815 100644 --- a/level_zero/sysman/test/unit_tests/sources/ecc/linux/mock_ecc.h +++ b/level_zero/sysman/test/unit_tests/sources/ecc/linux/mock_ecc.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2023-2024 Intel Corporation + * Copyright (C) 2023-2025 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -20,8 +20,12 @@ namespace ult { struct MockEccFwInterface : public L0::Sysman::FirmwareUtil { ze_result_t mockFwGetEccConfigResult = ZE_RESULT_SUCCESS; ze_result_t mockFwSetEccConfigResult = ZE_RESULT_SUCCESS; + ze_result_t mockFwGetEccAvailableResult = ZE_RESULT_SUCCESS; + ze_result_t mockFwGetEccConfigurableResult = ZE_RESULT_SUCCESS; ze_bool_t mockSetConfig = true; + ze_bool_t mockEccAvailable = true; + ze_bool_t mockEccConfigurable = true; uint8_t mockCurrentState = 0; uint8_t mockPendingState = 0; @@ -50,6 +54,24 @@ struct MockEccFwInterface : public L0::Sysman::FirmwareUtil { return ZE_RESULT_SUCCESS; } + ze_result_t fwGetEccAvailable(ze_bool_t *pAvailable) override { + if (mockFwGetEccAvailableResult != ZE_RESULT_SUCCESS) { + return mockFwGetEccAvailableResult; + } + + *pAvailable = mockEccAvailable; + return ZE_RESULT_SUCCESS; + } + + ze_result_t fwGetEccConfigurable(ze_bool_t *pAvailable) override { + if (mockFwGetEccConfigurableResult != ZE_RESULT_SUCCESS) { + return mockFwGetEccConfigurableResult; + } + + *pAvailable = mockEccConfigurable; + return ZE_RESULT_SUCCESS; + } + ADDMETHOD_NOBASE(getFwVersion, ze_result_t, ZE_RESULT_SUCCESS, (std::string fwType, std::string &firmwareVersion)); ADDMETHOD_NOBASE(getFlashFirmwareProgress, ze_result_t, ZE_RESULT_SUCCESS, (uint32_t * pCompletionPercent)); ADDMETHOD_NOBASE(flashFirmware, ze_result_t, ZE_RESULT_SUCCESS, (std::string fwType, void *pImage, uint32_t size)); diff --git a/level_zero/sysman/test/unit_tests/sources/ecc/linux/test_zes_ecc.cpp b/level_zero/sysman/test/unit_tests/sources/ecc/linux/test_zes_ecc.cpp index 05c5046bf6..f2db014aa3 100644 --- a/level_zero/sysman/test/unit_tests/sources/ecc/linux/test_zes_ecc.cpp +++ b/level_zero/sysman/test/unit_tests/sources/ecc/linux/test_zes_ecc.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2023-2024 Intel Corporation + * Copyright (C) 2023-2025 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -39,13 +39,6 @@ class ZesEccFixture : public SysmanDeviceFixture { } }; -HWTEST2_F(ZesEccFixture, GivenValidSysmanHandleAndFwInterfaceIsPresentWhenCallingzesDeviceEccAvailableThenVerifyApiCallSucceeds, IsDG2) { - ze_bool_t eccAvailable = false; - - EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEccAvailable(device, &eccAvailable)); - EXPECT_EQ(true, eccAvailable); -} - TEST_F(ZesEccFixture, GivenValidSysmanHandleAndEccUnsupportedWhenCallingzesDeviceEccAvailableThenVerifyApiCallFails) { struct MockSysmanProductHelperEcc : L0::Sysman::SysmanProductHelperHw { MockSysmanProductHelperEcc() = default; @@ -59,138 +52,6 @@ TEST_F(ZesEccFixture, GivenValidSysmanHandleAndEccUnsupportedWhenCallingzesDevic EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesDeviceEccAvailable(device, &eccAvailable)); } -HWTEST2_F(ZesEccFixture, GivenValidSysmanHandleAndFwInterfaceIsPresentWhenCallingzesDeviceEccConfigurableThenVerifyApiCallSucceeds, IsDG2) { - ze_bool_t eccConfigurable = false; - - EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEccConfigurable(device, &eccConfigurable)); - EXPECT_EQ(true, eccConfigurable); -} - -HWTEST2_F(ZesEccFixture, GivenValidSysmanHandleAndFwInterfaceIsAbsentWhenCallingEccApiThenVerifyApiCallReturnFailure, IsDG2) { - ze_bool_t eccConfigurable = true; - ze_bool_t eccAvailable = true; - L0::Sysman::EccImp *tempEccImp = new L0::Sysman::EccImp(pOsSysman); - pLinuxSysmanImp->pFwUtilInterface = nullptr; - tempEccImp->init(); - EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, tempEccImp->deviceEccAvailable(&eccAvailable)); - EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, tempEccImp->deviceEccConfigurable(&eccConfigurable)); - - zes_device_ecc_desc_t newState = {}; - zes_device_ecc_properties_t props = {}; - EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, tempEccImp->setEccState(&newState, &props)); - EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, tempEccImp->getEccState(&props)); - delete tempEccImp; -} - -HWTEST2_F(ZesEccFixture, GivenValidSysmanHandleAndFwGetEccConfigFailsWhenCallingzesDeviceEccConfigurableAndAvailableThenVerifyApiCallReturnsFailure, IsDG2) { - ze_bool_t eccConfigurable = true; - ze_bool_t eccAvailable = true; - pMockFwInterface->mockFwGetEccConfigResult = ZE_RESULT_ERROR_UNINITIALIZED; - - EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, zesDeviceEccAvailable(device, &eccAvailable)); - EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, zesDeviceEccConfigurable(device, &eccConfigurable)); -} - -HWTEST2_F(ZesEccFixture, GivenValidSysmanHandleAndCurrentStateIsNoneWhenCallingzesDeviceEccConfigurableAndAvailableThenNotSupportedEccIsReturned, IsDG2) { - ze_bool_t eccConfigurable = true; - ze_bool_t eccAvailable = true; - pMockFwInterface->mockCurrentState = eccStateNone; - - EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEccAvailable(device, &eccAvailable)); - EXPECT_EQ(false, eccAvailable); - EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEccConfigurable(device, &eccConfigurable)); - EXPECT_EQ(false, eccConfigurable); -} - -HWTEST2_F(ZesEccFixture, GivenValidSysmanHandleAndPendingStateIsNoneWhenCallingzesDeviceEccConfigurableAndAvailableThenNotSupportedEccIsReturned, IsDG2) { - ze_bool_t eccConfigurable = true; - ze_bool_t eccAvailable = true; - pMockFwInterface->mockPendingState = eccStateNone; - - EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEccAvailable(device, &eccAvailable)); - EXPECT_EQ(false, eccAvailable); - EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEccConfigurable(device, &eccConfigurable)); - EXPECT_EQ(false, eccConfigurable); -} - -HWTEST2_F(ZesEccFixture, GivenValidSysmanHandleAndFwInterfaceIsPresentWhenCallingzesDeviceGetEccStateThenApiCallSucceeds, IsDG2) { - zes_device_ecc_properties_t props = {}; - EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceGetEccState(device, &props)); - EXPECT_EQ(ZES_DEVICE_ECC_STATE_DISABLED, props.currentState); - EXPECT_EQ(ZES_DEVICE_ECC_STATE_DISABLED, props.pendingState); - EXPECT_EQ(ZES_DEVICE_ACTION_NONE, props.pendingAction); -} - -HWTEST2_F(ZesEccFixture, GivenValidSysmanHandleAndFwGetEccConfigFailsWhenCallingzesDeviceGetEccStateThenApiCallReturnFailure, IsDG2) { - zes_device_ecc_properties_t props = {}; - pMockFwInterface->mockFwGetEccConfigResult = ZE_RESULT_ERROR_UNINITIALIZED; - EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, zesDeviceGetEccState(device, &props)); -} - -HWTEST2_F(ZesEccFixture, GivenValidSysmanHandleAndFwInterfaceIsPresentWhenCallingzesDeviceSetEccStateThenApiCallSucceeds, IsDG2) { - zes_device_ecc_desc_t newState = {ZES_STRUCTURE_TYPE_DEVICE_STATE, nullptr, ZES_DEVICE_ECC_STATE_ENABLED}; - zes_device_ecc_properties_t props = {}; - EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceSetEccState(device, &newState, &props)); - - newState.state = ZES_DEVICE_ECC_STATE_DISABLED; - EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceSetEccState(device, &newState, &props)); -} - -HWTEST2_F(ZesEccFixture, GivenValidSysmanHandleAndFwInterfaceIsPresentWhenCallingzesDeviceSetEccStateWithInvalidEnumThenFailureIsReturned, IsDG2) { - zes_device_ecc_desc_t newState = {ZES_STRUCTURE_TYPE_DEVICE_STATE, nullptr, ZES_DEVICE_ECC_STATE_UNAVAILABLE}; - zes_device_ecc_properties_t props = {}; - EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ENUMERATION, zesDeviceSetEccState(device, &newState, &props)); -} - -HWTEST2_F(ZesEccFixture, GivenValidSysmanHandleAndFwSetEccConfigFailsWhenCallingzesDeviceSetEccStateThenFailureIsReturned, IsDG2) { - zes_device_ecc_desc_t newState = {ZES_STRUCTURE_TYPE_DEVICE_STATE, nullptr, ZES_DEVICE_ECC_STATE_ENABLED}; - zes_device_ecc_properties_t props = {}; - pMockFwInterface->mockFwSetEccConfigResult = ZE_RESULT_ERROR_UNINITIALIZED; - EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, zesDeviceSetEccState(device, &newState, &props)); -} - -HWTEST2_F(ZesEccFixture, GivenValidSysmanHandleWhenCallingEccSetStateAndEccGetStateThenVerifyApiCallSuccedsAndValidStatesAreReturned, IsDG2) { - zes_device_ecc_desc_t newState = {ZES_STRUCTURE_TYPE_DEVICE_STATE, nullptr, ZES_DEVICE_ECC_STATE_ENABLED}; - zes_device_ecc_properties_t props = {}; - EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceSetEccState(device, &newState, &props)); - - EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceGetEccState(device, &props)); - EXPECT_EQ(ZES_DEVICE_ECC_STATE_ENABLED, props.pendingState); - - newState.state = ZES_DEVICE_ECC_STATE_DISABLED; - EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceSetEccState(device, &newState, &props)); - - EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceGetEccState(device, &props)); - EXPECT_EQ(ZES_DEVICE_ECC_STATE_DISABLED, props.pendingState); - - pMockFwInterface->mockSetConfig = false; - pMockFwInterface->mockCurrentState = eccStateNone; - pMockFwInterface->mockPendingState = eccStateNone; - EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceSetEccState(device, &newState, &props)); - - EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceGetEccState(device, &props)); - EXPECT_EQ(ZES_DEVICE_ECC_STATE_UNAVAILABLE, props.pendingState); - EXPECT_EQ(ZES_DEVICE_ECC_STATE_UNAVAILABLE, props.currentState); -} - -HWTEST2_F(ZesEccFixture, GivenValidSysmanHandleWhenCallingEccSetStateAndEccGetStateThenVerifyApiCallSuccedsAndValidActionIsReturned, IsDG2) { - zes_device_ecc_desc_t newState = {ZES_STRUCTURE_TYPE_DEVICE_STATE, nullptr, ZES_DEVICE_ECC_STATE_ENABLED}; - zes_device_ecc_properties_t props = {}; - pMockFwInterface->mockCurrentState = eccStateEnable; - EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceSetEccState(device, &newState, &props)); - - EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceGetEccState(device, &props)); - EXPECT_EQ(ZES_DEVICE_ECC_STATE_ENABLED, props.pendingState); - EXPECT_EQ(ZES_DEVICE_ACTION_NONE, props.pendingAction); - - newState.state = ZES_DEVICE_ECC_STATE_DISABLED; - EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceSetEccState(device, &newState, &props)); - - EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceGetEccState(device, &props)); - EXPECT_EQ(ZES_DEVICE_ECC_STATE_DISABLED, props.pendingState); - EXPECT_EQ(ZES_DEVICE_ACTION_WARM_CARD_RESET, props.pendingAction); -} - } // namespace ult } // namespace Sysman } // namespace L0 diff --git a/level_zero/sysman/test/unit_tests/sources/ecc/windows/mock_ecc.h b/level_zero/sysman/test/unit_tests/sources/ecc/windows/mock_ecc.h index 9f10ca8019..24beaa4650 100644 --- a/level_zero/sysman/test/unit_tests/sources/ecc/windows/mock_ecc.h +++ b/level_zero/sysman/test/unit_tests/sources/ecc/windows/mock_ecc.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2023-2024 Intel Corporation + * Copyright (C) 2023-2025 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -19,9 +19,13 @@ struct EccFwInterface : public L0::Sysman::FirmwareUtil { ze_result_t mockFwGetEccConfigResult = ZE_RESULT_SUCCESS; ze_result_t mockFwSetEccConfigResult = ZE_RESULT_SUCCESS; + ze_result_t mockFwGetEccAvailableResult = ZE_RESULT_SUCCESS; + ze_result_t mockFwGetEccConfigurableResult = ZE_RESULT_SUCCESS; ze_result_t mockFwDeviceInit = ZE_RESULT_SUCCESS; ze_bool_t mockSetConfig = true; + ze_bool_t mockEccAvailable = true; + ze_bool_t mockEccConfigurable = true; uint8_t mockCurrentState = 0; uint8_t mockPendingState = 0; @@ -54,6 +58,24 @@ struct EccFwInterface : public L0::Sysman::FirmwareUtil { return ZE_RESULT_SUCCESS; } + ze_result_t fwGetEccAvailable(ze_bool_t *pAvailable) override { + if (mockFwGetEccAvailableResult != ZE_RESULT_SUCCESS) { + return mockFwGetEccAvailableResult; + } + + *pAvailable = mockEccAvailable; + return ZE_RESULT_SUCCESS; + } + + ze_result_t fwGetEccConfigurable(ze_bool_t *pAvailable) override { + if (mockFwGetEccConfigurableResult != ZE_RESULT_SUCCESS) { + return mockFwGetEccConfigurableResult; + } + + *pAvailable = mockEccConfigurable; + return ZE_RESULT_SUCCESS; + } + ADDMETHOD_NOBASE(getFwVersion, ze_result_t, ZE_RESULT_SUCCESS, (std::string fwType, std::string &firmwareVersion)); ADDMETHOD_NOBASE(getFlashFirmwareProgress, ze_result_t, ZE_RESULT_SUCCESS, (uint32_t * pCompletionPercent)); ADDMETHOD_NOBASE(flashFirmware, ze_result_t, ZE_RESULT_SUCCESS, (std::string fwType, void *pImage, uint32_t size)); diff --git a/level_zero/sysman/test/unit_tests/sources/ecc/windows/test_zes_ecc.cpp b/level_zero/sysman/test/unit_tests/sources/ecc/windows/test_zes_ecc.cpp index 89375a3f82..18f1e0d752 100644 --- a/level_zero/sysman/test/unit_tests/sources/ecc/windows/test_zes_ecc.cpp +++ b/level_zero/sysman/test/unit_tests/sources/ecc/windows/test_zes_ecc.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2023 Intel Corporation + * Copyright (C) 2023-2025 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -43,16 +43,22 @@ class ZesEccFixture : public SysmanDeviceFixture { } }; -TEST_F(ZesEccFixture, GivenValidSysmanHandleAndFwInterfaceIsPresentWhenCallingzesDeviceEccAvailableThenVerifyApiCallSucceeds) { +TEST_F(ZesEccFixture, GivenValidSysmanHandleAndFwInterfaceIsPresentWhenCallingzesDeviceEccAvailableTwiceThenVerifyApiCallSucceeds) { ze_bool_t eccAvailable = false; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEccAvailable(pSysmanDevice->toHandle(), &eccAvailable)); + EXPECT_EQ(true, eccAvailable); + eccAvailable = false; EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEccAvailable(pSysmanDevice->toHandle(), &eccAvailable)); EXPECT_EQ(true, eccAvailable); } -TEST_F(ZesEccFixture, GivenValidSysmanHandleAndFwInterfaceIsPresentWhenCallingzesDeviceEccConfigurableThenVerifyApiCallSucceeds) { +TEST_F(ZesEccFixture, GivenValidSysmanHandleAndFwInterfaceIsPresentWhenCallingzesDeviceEccConfigurableTwiceThenVerifyApiCallSucceeds) { ze_bool_t eccConfigurable = false; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEccConfigurable(pSysmanDevice->toHandle(), &eccConfigurable)); + EXPECT_EQ(true, eccConfigurable); + eccConfigurable = false; EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEccConfigurable(pSysmanDevice->toHandle(), &eccConfigurable)); EXPECT_EQ(true, eccConfigurable); } @@ -76,7 +82,8 @@ TEST_F(ZesEccFixture, GivenValidSysmanHandleAndFwInterfaceIsAbsentWhenCallingEcc TEST_F(ZesEccFixture, GivenValidSysmanHandleAndFwGetEccConfigFailsWhenCallingzesDeviceEccConfigurableAndAvailableThenVerifyApiCallReturnsFailure) { ze_bool_t eccConfigurable = true; ze_bool_t eccAvailable = true; - pMockFwInterface->mockFwGetEccConfigResult = ZE_RESULT_ERROR_UNINITIALIZED; + pMockFwInterface->mockFwGetEccAvailableResult = ZE_RESULT_ERROR_UNINITIALIZED; + pMockFwInterface->mockFwGetEccConfigurableResult = ZE_RESULT_ERROR_UNINITIALIZED; EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, zesDeviceEccAvailable(pSysmanDevice->toHandle(), &eccAvailable)); EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, zesDeviceEccConfigurable(pSysmanDevice->toHandle(), &eccConfigurable)); @@ -85,18 +92,8 @@ TEST_F(ZesEccFixture, GivenValidSysmanHandleAndFwGetEccConfigFailsWhenCallingzes TEST_F(ZesEccFixture, GivenValidSysmanHandleAndCurrentStateIsNoneWhenCallingzesDeviceEccConfigurableAndAvailableThenNotSupportedEccIsReturned) { ze_bool_t eccConfigurable = true; ze_bool_t eccAvailable = true; - pMockFwInterface->mockCurrentState = eccStateNone; - - EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEccAvailable(pSysmanDevice->toHandle(), &eccAvailable)); - EXPECT_EQ(false, eccAvailable); - EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEccConfigurable(pSysmanDevice->toHandle(), &eccConfigurable)); - EXPECT_EQ(false, eccConfigurable); -} - -TEST_F(ZesEccFixture, GivenValidSysmanHandleAndPendingStateIsNoneWhenCallingzesDeviceEccConfigurableAndAvailableThenNotSupportedEccIsReturned) { - ze_bool_t eccConfigurable = true; - ze_bool_t eccAvailable = true; - pMockFwInterface->mockPendingState = eccStateNone; + pMockFwInterface->mockEccAvailable = false; + pMockFwInterface->mockEccConfigurable = false; EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEccAvailable(pSysmanDevice->toHandle(), &eccAvailable)); EXPECT_EQ(false, eccAvailable); diff --git a/level_zero/sysman/test/unit_tests/sources/events/linux/mock_events.h b/level_zero/sysman/test/unit_tests/sources/events/linux/mock_events.h index d873709fca..39602ee179 100644 --- a/level_zero/sysman/test/unit_tests/sources/events/linux/mock_events.h +++ b/level_zero/sysman/test/unit_tests/sources/events/linux/mock_events.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2023-2024 Intel Corporation + * Copyright (C) 2023-2025 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -252,6 +252,8 @@ struct MockEventsFwInterface : public L0::Sysman::FirmwareUtil { ADDMETHOD_NOBASE(fwSupportedDiagTests, ze_result_t, ZE_RESULT_SUCCESS, (std::vector & supportedDiagTests)); ADDMETHOD_NOBASE(fwRunDiagTests, ze_result_t, ZE_RESULT_SUCCESS, (std::string & osDiagType, zes_diag_result_t *pResult)); ADDMETHOD_NOBASE(fwGetMemoryErrorCount, ze_result_t, ZE_RESULT_SUCCESS, (zes_ras_error_type_t category, uint32_t subDeviceCount, uint32_t subDeviceId, uint64_t &count)); + ADDMETHOD_NOBASE(fwGetEccAvailable, ze_result_t, ZE_RESULT_SUCCESS, (ze_bool_t * pAvailable)); + ADDMETHOD_NOBASE(fwGetEccConfigurable, ze_result_t, ZE_RESULT_SUCCESS, (ze_bool_t * pConfigurable)); ADDMETHOD_NOBASE(fwGetEccConfig, ze_result_t, ZE_RESULT_SUCCESS, (uint8_t * currentState, uint8_t *pendingState)); ADDMETHOD_NOBASE(fwSetEccConfig, ze_result_t, ZE_RESULT_SUCCESS, (uint8_t newState, uint8_t *currentState, uint8_t *pendingState)); ADDMETHOD_NOBASE_VOIDRETURN(getDeviceSupportedFwTypes, (std::vector & fwTypes)); diff --git a/level_zero/sysman/test/unit_tests/sources/firmware/linux/mock_zes_sysman_firmware.h b/level_zero/sysman/test/unit_tests/sources/firmware/linux/mock_zes_sysman_firmware.h index cd49377167..440e420e65 100644 --- a/level_zero/sysman/test/unit_tests/sources/firmware/linux/mock_zes_sysman_firmware.h +++ b/level_zero/sysman/test/unit_tests/sources/firmware/linux/mock_zes_sysman_firmware.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2020-2024 Intel Corporation + * Copyright (C) 2020-2025 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -124,6 +124,8 @@ struct MockFirmwareInterface : public FirmwareInterface { ADDMETHOD_NOBASE(fwSupportedDiagTests, ze_result_t, ZE_RESULT_SUCCESS, (std::vector & supportedDiagTests)); ADDMETHOD_NOBASE(fwRunDiagTests, ze_result_t, ZE_RESULT_SUCCESS, (std::string & osDiagType, zes_diag_result_t *pResult)); ADDMETHOD_NOBASE(fwGetMemoryErrorCount, ze_result_t, ZE_RESULT_SUCCESS, (zes_ras_error_type_t category, uint32_t subDeviceCount, uint32_t subDeviceId, uint64_t &count)); + ADDMETHOD_NOBASE(fwGetEccAvailable, ze_result_t, ZE_RESULT_SUCCESS, (ze_bool_t * pAvailable)); + ADDMETHOD_NOBASE(fwGetEccConfigurable, ze_result_t, ZE_RESULT_SUCCESS, (ze_bool_t * pConfigurable)); ADDMETHOD_NOBASE(fwGetEccConfig, ze_result_t, ZE_RESULT_SUCCESS, (uint8_t * currentState, uint8_t *pendingState)); ADDMETHOD_NOBASE(fwSetEccConfig, ze_result_t, ZE_RESULT_SUCCESS, (uint8_t newState, uint8_t *currentState, uint8_t *pendingState)); ADDMETHOD_NOBASE_VOIDRETURN(fwGetMemoryHealthIndicator, (zes_mem_health_t * health)); diff --git a/level_zero/sysman/test/unit_tests/sources/firmware/windows/mock_zes_sysman_firmware.h b/level_zero/sysman/test/unit_tests/sources/firmware/windows/mock_zes_sysman_firmware.h index e4579896f6..f46399b11a 100644 --- a/level_zero/sysman/test/unit_tests/sources/firmware/windows/mock_zes_sysman_firmware.h +++ b/level_zero/sysman/test/unit_tests/sources/firmware/windows/mock_zes_sysman_firmware.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2023-2024 Intel Corporation + * Copyright (C) 2023-2025 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -60,6 +60,8 @@ struct FirmwareInterface : public L0::Sysman::FirmwareUtil { ADDMETHOD_NOBASE(fwSupportedDiagTests, ze_result_t, ZE_RESULT_SUCCESS, (std::vector & supportedDiagTests)); ADDMETHOD_NOBASE(fwRunDiagTests, ze_result_t, ZE_RESULT_SUCCESS, (std::string & osDiagType, zes_diag_result_t *pResult)); ADDMETHOD_NOBASE(fwGetMemoryErrorCount, ze_result_t, ZE_RESULT_SUCCESS, (zes_ras_error_type_t category, uint32_t subDeviceCount, uint32_t subDeviceId, uint64_t &count)); + ADDMETHOD_NOBASE(fwGetEccAvailable, ze_result_t, ZE_RESULT_SUCCESS, (ze_bool_t * pAvailable)); + ADDMETHOD_NOBASE(fwGetEccConfigurable, ze_result_t, ZE_RESULT_SUCCESS, (ze_bool_t * pConfigurable)); ADDMETHOD_NOBASE(fwGetEccConfig, ze_result_t, ZE_RESULT_SUCCESS, (uint8_t * currentState, uint8_t *pendingState)); ADDMETHOD_NOBASE(fwSetEccConfig, ze_result_t, ZE_RESULT_SUCCESS, (uint8_t newState, uint8_t *currentState, uint8_t *pendingState)); ADDMETHOD_NOBASE_VOIDRETURN(fwGetMemoryHealthIndicator, (zes_mem_health_t * health)); diff --git a/level_zero/sysman/test/unit_tests/sources/firmware_util/mock_fw_util_fixture.h b/level_zero/sysman/test/unit_tests/sources/firmware_util/mock_fw_util_fixture.h index 421ad2623d..af4be3fa22 100644 --- a/level_zero/sysman/test/unit_tests/sources/firmware_util/mock_fw_util_fixture.h +++ b/level_zero/sysman/test/unit_tests/sources/firmware_util/mock_fw_util_fixture.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2022-2024 Intel Corporation + * Copyright (C) 2022-2025 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -31,6 +31,8 @@ struct MockFwUtilInterface : public L0::Sysman::FirmwareUtil { ADDMETHOD_NOBASE(fwSupportedDiagTests, ze_result_t, ZE_RESULT_SUCCESS, (std::vector & supportedDiagTests)); ADDMETHOD_NOBASE(fwRunDiagTests, ze_result_t, ZE_RESULT_SUCCESS, (std::string & osDiagType, zes_diag_result_t *pResult)); ADDMETHOD_NOBASE(fwGetMemoryErrorCount, ze_result_t, ZE_RESULT_SUCCESS, (zes_ras_error_type_t category, uint32_t subDeviceCount, uint32_t subDeviceId, uint64_t &count)); + ADDMETHOD_NOBASE(fwGetEccAvailable, ze_result_t, ZE_RESULT_SUCCESS, (ze_bool_t * pAvailable)); + ADDMETHOD_NOBASE(fwGetEccConfigurable, ze_result_t, ZE_RESULT_SUCCESS, (ze_bool_t * pConfigurable)); ADDMETHOD_NOBASE(fwGetEccConfig, ze_result_t, ZE_RESULT_SUCCESS, (uint8_t * currentState, uint8_t *pendingState)); ADDMETHOD_NOBASE(fwSetEccConfig, ze_result_t, ZE_RESULT_SUCCESS, (uint8_t newState, uint8_t *currentState, uint8_t *pendingState)); ADDMETHOD_NOBASE_VOIDRETURN(getDeviceSupportedFwTypes, (std::vector & fwTypes)); diff --git a/level_zero/sysman/test/unit_tests/sources/firmware_util/test_fw_util_helper.cpp b/level_zero/sysman/test/unit_tests/sources/firmware_util/test_fw_util_helper.cpp index d5c17d1ee9..4b6be4b57d 100644 --- a/level_zero/sysman/test/unit_tests/sources/firmware_util/test_fw_util_helper.cpp +++ b/level_zero/sysman/test/unit_tests/sources/firmware_util/test_fw_util_helper.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2022-2024 Intel Corporation + * Copyright (C) 2022-2025 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -11,18 +11,31 @@ #include "level_zero/sysman/source/shared/firmware_util/sysman_firmware_util_imp.h" #include "level_zero/sysman/test/unit_tests/sources/firmware_util/mock_fw_util_fixture.h" +#include + namespace L0 { extern L0::Sysman::pIgscIfrGetStatusExt L0::Sysman::deviceIfrGetStatusExt; extern L0::Sysman::pIgscIfrRunMemPPRTest L0::Sysman::deviceIfrRunMemPPRTest; -extern L0::Sysman::pIgscGetEccConfig getEccConfig; -extern L0::Sysman::pIgscSetEccConfig setEccConfig; +extern L0::Sysman::pIgscGfspHeciCmd gfspHeciCmd; namespace Sysman { namespace ult { constexpr static uint32_t mockMaxTileCount = 2; static int mockMemoryHealthIndicator = IGSC_HEALTH_INDICATOR_HEALTHY; +std::vector mockSupportedHeciCmds = {GfspHeciConstants::Cmd::getEccConfigurationCmd16, GfspHeciConstants::Cmd::setEccConfigurationCmd15}; +uint8_t mockEccCurrentState = 1; +uint8_t mockEccPendingState = 1; +uint8_t mockEccHeciCmd16Val = 1; + +void restoreEccMockVars() { + mockSupportedHeciCmds.clear(); + mockSupportedHeciCmds.insert(mockSupportedHeciCmds.end(), {GfspHeciConstants::Cmd::getEccConfigurationCmd16, GfspHeciConstants::Cmd::setEccConfigurationCmd15}); + mockEccCurrentState = 1; + mockEccPendingState = 1; + mockEccHeciCmd16Val = 1; +} int mockDeviceIfrGetStatusExt(struct igsc_device_handle *handle, uint32_t *supportedTests, uint32_t *hwCapabilities, uint32_t *ifrApplied, uint32_t *prevErrors, uint32_t *pendingReset) { return 0; @@ -32,19 +45,11 @@ int mockdeviceIfrRunMemPPRTest(struct igsc_device_handle *handle, uint32_t *stat return 0; } -static inline int mockEccConfigGetSuccess(struct igsc_device_handle *handle, uint8_t *currentState, uint8_t *pendingState) { +static inline int mockEccConfigGetSuccess(struct igsc_device_handle *handle, uint32_t gfspCmd, uint8_t *inBuffer, size_t inBufferSize, uint8_t *outBuffer, size_t outBufferSize, size_t *actualOutBufferSize) { return 0; } -static inline int mockEccConfigSetSuccess(struct igsc_device_handle *handle, uint8_t newState, uint8_t *currentState, uint8_t *pendingState) { - return 0; -} - -static inline int mockEccConfigGetFailure(struct igsc_device_handle *handle, uint8_t *currentState, uint8_t *pendingState) { - return -1; -} - -static inline int mockEccConfigSetFailure(struct igsc_device_handle *handle, uint8_t newState, uint8_t *currentState, uint8_t *pendingState) { +static inline int mockEccConfigGetFailure(struct igsc_device_handle *handle, uint32_t gfspCmd, uint8_t *inBuffer, size_t inBufferSize, uint8_t *outBuffer, size_t outBufferSize, size_t *actualOutBufferSize) { return -1; } @@ -66,6 +71,71 @@ static inline int mockGetHealthIndicatorFailure(struct igsc_device_handle *handl return -1; } +static int mockGetEccAvailable(struct igsc_device_handle *handle, uint32_t gfspCmd, uint8_t *inBuffer, size_t inBufferSize, uint8_t *outBuffer, size_t outBufferSize, size_t *actualOutBufferSize) { + + if (std::find(mockSupportedHeciCmds.begin(), mockSupportedHeciCmds.end(), gfspCmd) == mockSupportedHeciCmds.end()) { + return IGSC_ERROR_NOT_SUPPORTED; + } + + switch (gfspCmd) { + case GfspHeciConstants::Cmd::getEccConfigurationCmd16: + outBuffer[GfspHeciConstants::GetEccCmd16BytePostition::eccAvailable] = mockEccHeciCmd16Val; + return IGSC_SUCCESS; + case GfspHeciConstants::Cmd::getEccConfigurationCmd9: + outBuffer[GfspHeciConstants::GetEccCmd9BytePostition::currentState] = mockEccCurrentState; + outBuffer[GfspHeciConstants::GetEccCmd9BytePostition::pendingState] = mockEccPendingState; + return IGSC_SUCCESS; + default: + return IGSC_ERROR_NOT_SUPPORTED; + } +} + +static int mockGetEccConfigurable(struct igsc_device_handle *handle, uint32_t gfspCmd, uint8_t *inBuffer, size_t inBufferSize, uint8_t *outBuffer, size_t outBufferSize, size_t *actualOutBufferSize) { + + if (std::find(mockSupportedHeciCmds.begin(), mockSupportedHeciCmds.end(), gfspCmd) == mockSupportedHeciCmds.end()) { + return IGSC_ERROR_NOT_SUPPORTED; + } + + switch (gfspCmd) { + case GfspHeciConstants::Cmd::getEccConfigurationCmd16: + outBuffer[GfspHeciConstants::GetEccCmd16BytePostition::eccConfigurable] = mockEccHeciCmd16Val; + return IGSC_SUCCESS; + case GfspHeciConstants::Cmd::getEccConfigurationCmd9: + outBuffer[GfspHeciConstants::GetEccCmd9BytePostition::currentState] = mockEccCurrentState; + outBuffer[GfspHeciConstants::GetEccCmd9BytePostition::pendingState] = mockEccPendingState; + return IGSC_SUCCESS; + default: + return IGSC_ERROR_NOT_SUPPORTED; + } +} + +static int mockGetEccConfig(struct igsc_device_handle *handle, uint32_t gfspCmd, uint8_t *inBuffer, size_t inBufferSize, uint8_t *outBuffer, size_t outBufferSize, size_t *actualOutBufferSize) { + + if (std::find(mockSupportedHeciCmds.begin(), mockSupportedHeciCmds.end(), gfspCmd) == mockSupportedHeciCmds.end()) { + return IGSC_ERROR_NOT_SUPPORTED; + } + + switch (gfspCmd) { + case GfspHeciConstants::Cmd::getEccConfigurationCmd16: + outBuffer[GfspHeciConstants::GetEccCmd16BytePostition::eccCurrentState] = mockEccCurrentState; + outBuffer[GfspHeciConstants::GetEccCmd16BytePostition::eccPendingState] = mockEccPendingState; + return IGSC_SUCCESS; + case GfspHeciConstants::Cmd::getEccConfigurationCmd9: + outBuffer[GfspHeciConstants::GetEccCmd9BytePostition::currentState] = mockEccCurrentState; + outBuffer[GfspHeciConstants::GetEccCmd9BytePostition::pendingState] = mockEccPendingState; + return IGSC_SUCCESS; + case GfspHeciConstants::Cmd::setEccConfigurationCmd15: + outBuffer[GfspHeciConstants::SetEccCmd15BytePostition::response] = inBuffer[GfspHeciConstants::SetEccCmd15BytePostition::request]; + return IGSC_SUCCESS; + case GfspHeciConstants::Cmd::setEccConfigurationCmd8: + outBuffer[GfspHeciConstants::SetEccCmd8BytePostition::responsePendingState] = inBuffer[GfspHeciConstants::SetEccCmd8BytePostition::setRequest]; + outBuffer[GfspHeciConstants::SetEccCmd8BytePostition::responseCurrentState] = mockEccCurrentState; + return IGSC_SUCCESS; + default: + return IGSC_ERROR_NOT_SUPPORTED; + } +} + TEST(FwStatusExtTest, GivenIFRWasSetWhenFirmwareUtilChecksIFRThenIFRStatusIsUpdated) { VariableBackup mockDeviceIfrGetStatusExt(&L0::Sysman::deviceIfrGetStatusExt, [](struct igsc_device_handle *handle, uint32_t *supportedTests, uint32_t *hwCapabilities, uint32_t *ifrApplied, uint32_t *prevErrors, uint32_t *pendingReset) -> int { @@ -169,8 +239,7 @@ TEST(FwEccTest, GivenFwEccConfigCallFailsWhenCallingFirmwareUtilSetAndGetEccThen public: ~IgscEccMockOsLibrary() override = default; void *getProcAddress(const std::string &procName) override { - eccFuncMap["igsc_ecc_config_get"] = reinterpret_cast(&mockEccConfigGetFailure); - eccFuncMap["igsc_ecc_config_set"] = reinterpret_cast(&mockEccConfigSetFailure); + eccFuncMap["igsc_gfsp_heci_cmd"] = reinterpret_cast(&mockEccConfigGetFailure); auto it = eccFuncMap.find(procName); if (eccFuncMap.end() == it) { return nullptr; @@ -211,8 +280,7 @@ TEST(LinuxFwEccTest, GivenValidFwUtilMethodWhenCallingFirmwareUtilSetAndGetEccTh public: ~IgscEccMockOsLibrary() override = default; void *getProcAddress(const std::string &procName) override { - eccFuncMap["igsc_ecc_config_get"] = reinterpret_cast(&mockEccConfigGetSuccess); - eccFuncMap["igsc_ecc_config_set"] = reinterpret_cast(&mockEccConfigSetSuccess); + eccFuncMap["igsc_gfsp_heci_cmd"] = reinterpret_cast(&mockEccConfigGetSuccess); auto it = eccFuncMap.find(procName); if (eccFuncMap.end() == it) { return nullptr; @@ -474,6 +542,356 @@ TEST(FwUtilImpProgressTest, GivenFirmwareUtilImpAndNullContextWhenSettingProgres delete pFwUtilImp; } +TEST(LinuxFwEccTest, GivenHeciCmd16IsSupportedThenWhenCallingFwGetEccAvailableSucessIsReturned) { + restoreEccMockVars(); + L0::Sysman::FirmwareUtilImp *pFwUtilImp = new L0::Sysman::FirmwareUtilImp(0, 0, 0, 0); + MockFwUtilOsLibrary *osLibHandle = new MockFwUtilOsLibrary(); + osLibHandle->funcMap["igsc_gfsp_heci_cmd"] = reinterpret_cast(&mockGetEccAvailable); + pFwUtilImp->libraryHandle = static_cast(osLibHandle); + mockSupportedHeciCmds.clear(); + mockSupportedHeciCmds.push_back(GfspHeciConstants::Cmd::getEccConfigurationCmd16); + ze_bool_t pAvailable; + + std::vector possibleEccStates = {0, 1}; + + for (auto iterEccAvailableStates : possibleEccStates) { + mockEccHeciCmd16Val = iterEccAvailableStates; + + auto ret = pFwUtilImp->fwGetEccAvailable(&pAvailable); + EXPECT_EQ(pAvailable, mockEccHeciCmd16Val); + EXPECT_EQ(ZE_RESULT_SUCCESS, ret); + } + + delete pFwUtilImp->libraryHandle; + pFwUtilImp->libraryHandle = nullptr; + delete pFwUtilImp; +} + +TEST(LinuxFwEccTest, GivenHeciCmd16IsNotSupportedBut9IsSupportedThenWhenCallingFwGetEccAvailableSucessIsReturned) { + restoreEccMockVars(); + L0::Sysman::FirmwareUtilImp *pFwUtilImp = new L0::Sysman::FirmwareUtilImp(0, 0, 0, 0); + MockFwUtilOsLibrary *osLibHandle = new MockFwUtilOsLibrary(); + osLibHandle->funcMap["igsc_gfsp_heci_cmd"] = reinterpret_cast(&mockGetEccAvailable); + pFwUtilImp->libraryHandle = static_cast(osLibHandle); + mockSupportedHeciCmds.clear(); + mockSupportedHeciCmds.push_back(GfspHeciConstants::Cmd::getEccConfigurationCmd9); + + ze_bool_t pAvailable; + auto ret = pFwUtilImp->fwGetEccAvailable(&pAvailable); + EXPECT_TRUE(pAvailable); + EXPECT_EQ(ZE_RESULT_SUCCESS, ret); + + delete pFwUtilImp->libraryHandle; + pFwUtilImp->libraryHandle = nullptr; + delete pFwUtilImp; +} + +TEST(LinuxFwEccTest, GivenHeciCmd16IsNotSupportedBut9IsSupportedAndEccStateIsNoneThenWhenCallingFwGetEccAvailableCorrectReturnValueIsReturned) { + restoreEccMockVars(); + L0::Sysman::FirmwareUtilImp *pFwUtilImp = new L0::Sysman::FirmwareUtilImp(0, 0, 0, 0); + MockFwUtilOsLibrary *osLibHandle = new MockFwUtilOsLibrary(); + osLibHandle->funcMap["igsc_gfsp_heci_cmd"] = reinterpret_cast(&mockGetEccAvailable); + pFwUtilImp->libraryHandle = static_cast(osLibHandle); + + ze_bool_t pAvailable; + mockSupportedHeciCmds.clear(); + mockSupportedHeciCmds.push_back(GfspHeciConstants::Cmd::getEccConfigurationCmd9); + mockEccCurrentState = 0xff; + mockEccPendingState = 0x1; + + auto ret = pFwUtilImp->fwGetEccAvailable(&pAvailable); + EXPECT_FALSE(pAvailable); + EXPECT_EQ(ZE_RESULT_SUCCESS, ret); + + mockEccCurrentState = 0x1; + mockEccPendingState = 0xff; + ret = pFwUtilImp->fwGetEccAvailable(&pAvailable); + EXPECT_FALSE(pAvailable); + EXPECT_EQ(ZE_RESULT_SUCCESS, ret); + + delete pFwUtilImp->libraryHandle; + pFwUtilImp->libraryHandle = nullptr; + delete pFwUtilImp; +} + +TEST(LinuxFwEccTest, GivenHeciCmd9AndCmd16AreUnsupportedWhenCallingFwGetEccAvailableThenUninitializedIsReturned) { + restoreEccMockVars(); + L0::Sysman::FirmwareUtilImp *pFwUtilImp = new L0::Sysman::FirmwareUtilImp(0, 0, 0, 0); + MockFwUtilOsLibrary *osLibHandle = new MockFwUtilOsLibrary(); + osLibHandle->funcMap["igsc_gfsp_heci_cmd"] = reinterpret_cast(&mockGetEccConfigurable); + pFwUtilImp->libraryHandle = static_cast(osLibHandle); + mockSupportedHeciCmds.clear(); + mockSupportedHeciCmds.push_back(0xff); + + ze_bool_t pAvailable; + auto ret = pFwUtilImp->fwGetEccAvailable(&pAvailable); + EXPECT_FALSE(pAvailable); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, ret); + + delete pFwUtilImp->libraryHandle; + pFwUtilImp->libraryHandle = nullptr; + delete pFwUtilImp; +} + +TEST(LinuxFwEccTest, GivenHeciCmd16IsSupportedThenWhenCallingFwGetEccConfigurableSucessIsReturned) { + restoreEccMockVars(); + L0::Sysman::FirmwareUtilImp *pFwUtilImp = new L0::Sysman::FirmwareUtilImp(0, 0, 0, 0); + MockFwUtilOsLibrary *osLibHandle = new MockFwUtilOsLibrary(); + osLibHandle->funcMap["igsc_gfsp_heci_cmd"] = reinterpret_cast(&mockGetEccConfigurable); + pFwUtilImp->libraryHandle = static_cast(osLibHandle); + mockSupportedHeciCmds.clear(); + mockSupportedHeciCmds.push_back(GfspHeciConstants::Cmd::getEccConfigurationCmd16); + ze_bool_t pConfigurable; + + std::vector possibleEccStates = {0, 1}; + + for (auto iterEccConfigurableStates : possibleEccStates) { + mockEccHeciCmd16Val = iterEccConfigurableStates; + + auto ret = pFwUtilImp->fwGetEccConfigurable(&pConfigurable); + EXPECT_EQ(pConfigurable, mockEccHeciCmd16Val); + EXPECT_EQ(ZE_RESULT_SUCCESS, ret); + } + + delete pFwUtilImp->libraryHandle; + pFwUtilImp->libraryHandle = nullptr; + delete pFwUtilImp; +} + +TEST(LinuxFwEccTest, GivenHeciCmd16IsNotSupportedBut9IsSupportedThenWhenCallingFwGetEccConfigurableSucessIsReturned) { + restoreEccMockVars(); + L0::Sysman::FirmwareUtilImp *pFwUtilImp = new L0::Sysman::FirmwareUtilImp(0, 0, 0, 0); + MockFwUtilOsLibrary *osLibHandle = new MockFwUtilOsLibrary(); + osLibHandle->funcMap["igsc_gfsp_heci_cmd"] = reinterpret_cast(&mockGetEccConfigurable); + pFwUtilImp->libraryHandle = static_cast(osLibHandle); + mockSupportedHeciCmds.clear(); + mockSupportedHeciCmds.push_back(GfspHeciConstants::Cmd::getEccConfigurationCmd9); + + ze_bool_t pConfigurable; + auto ret = pFwUtilImp->fwGetEccConfigurable(&pConfigurable); + EXPECT_TRUE(pConfigurable); + EXPECT_EQ(ZE_RESULT_SUCCESS, ret); + + delete pFwUtilImp->libraryHandle; + pFwUtilImp->libraryHandle = nullptr; + delete pFwUtilImp; +} + +TEST(LinuxFwEccTest, GivenHeciCmd16IsNotSupportedBut9IsSupportedAndEccStateIsNoneThenWhenCallingFwGetEccConfigurableCorrectReturnValueIsReturned) { + restoreEccMockVars(); + L0::Sysman::FirmwareUtilImp *pFwUtilImp = new L0::Sysman::FirmwareUtilImp(0, 0, 0, 0); + MockFwUtilOsLibrary *osLibHandle = new MockFwUtilOsLibrary(); + osLibHandle->funcMap["igsc_gfsp_heci_cmd"] = reinterpret_cast(&mockGetEccConfigurable); + pFwUtilImp->libraryHandle = static_cast(osLibHandle); + + ze_bool_t pConfigurable; + mockSupportedHeciCmds.clear(); + mockSupportedHeciCmds.push_back(GfspHeciConstants::Cmd::getEccConfigurationCmd9); + mockEccCurrentState = 0xff; + mockEccPendingState = 0x1; + + auto ret = pFwUtilImp->fwGetEccConfigurable(&pConfigurable); + EXPECT_FALSE(pConfigurable); + EXPECT_EQ(ZE_RESULT_SUCCESS, ret); + + mockEccCurrentState = 0x1; + mockEccPendingState = 0xff; + ret = pFwUtilImp->fwGetEccConfigurable(&pConfigurable); + EXPECT_FALSE(pConfigurable); + EXPECT_EQ(ZE_RESULT_SUCCESS, ret); + + delete pFwUtilImp->libraryHandle; + pFwUtilImp->libraryHandle = nullptr; + delete pFwUtilImp; +} + +TEST(LinuxFwEccTest, GivenHeciCmd9AndCmd16AreUnsupportedWhenCallingFwGetEccConfigurableThenUninitializedIsReturned) { + restoreEccMockVars(); + L0::Sysman::FirmwareUtilImp *pFwUtilImp = new L0::Sysman::FirmwareUtilImp(0, 0, 0, 0); + MockFwUtilOsLibrary *osLibHandle = new MockFwUtilOsLibrary(); + osLibHandle->funcMap["igsc_gfsp_heci_cmd"] = reinterpret_cast(&mockGetEccConfigurable); + pFwUtilImp->libraryHandle = static_cast(osLibHandle); + mockSupportedHeciCmds.clear(); + mockSupportedHeciCmds.push_back(0xff); + + ze_bool_t pConfigurable; + auto ret = pFwUtilImp->fwGetEccConfigurable(&pConfigurable); + EXPECT_FALSE(pConfigurable); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, ret); + + delete pFwUtilImp->libraryHandle; + pFwUtilImp->libraryHandle = nullptr; + delete pFwUtilImp; +} + +TEST(LinuxFwEccTest, GivenHeciCmd16IsSupportedThenWhenCallingFwGetEccConfigSucessIsReturned) { + restoreEccMockVars(); + L0::Sysman::FirmwareUtilImp *pFwUtilImp = new L0::Sysman::FirmwareUtilImp(0, 0, 0, 0); + MockFwUtilOsLibrary *osLibHandle = new MockFwUtilOsLibrary(); + osLibHandle->funcMap["igsc_gfsp_heci_cmd"] = reinterpret_cast(&mockGetEccConfig); + pFwUtilImp->libraryHandle = static_cast(osLibHandle); + mockSupportedHeciCmds.clear(); + mockSupportedHeciCmds.push_back(GfspHeciConstants::Cmd::getEccConfigurationCmd16); + mockEccCurrentState = 1; + mockEccPendingState = 1; + + uint8_t currentState; + uint8_t pendingState; + auto ret = pFwUtilImp->fwGetEccConfig(¤tState, &pendingState); + EXPECT_EQ(currentState, mockEccCurrentState); + EXPECT_EQ(pendingState, mockEccPendingState); + EXPECT_EQ(ZE_RESULT_SUCCESS, ret); + + delete pFwUtilImp->libraryHandle; + pFwUtilImp->libraryHandle = nullptr; + delete pFwUtilImp; +} + +TEST(LinuxFwEccTest, GivenHeciCmd16IsNotSupportedBut9IsSupportedThenWhenCallingFwGetEccConfigSucessIsReturned) { + restoreEccMockVars(); + L0::Sysman::FirmwareUtilImp *pFwUtilImp = new L0::Sysman::FirmwareUtilImp(0, 0, 0, 0); + MockFwUtilOsLibrary *osLibHandle = new MockFwUtilOsLibrary(); + osLibHandle->funcMap["igsc_gfsp_heci_cmd"] = reinterpret_cast(&mockGetEccConfig); + pFwUtilImp->libraryHandle = static_cast(osLibHandle); + mockSupportedHeciCmds.clear(); + mockSupportedHeciCmds.push_back(GfspHeciConstants::Cmd::getEccConfigurationCmd9); + uint8_t currentState; + uint8_t pendingState; + + std::vector possibleEccStates = {0, 1, 0xff}; + + for (auto iterCurrentState : possibleEccStates) { + for (auto iterPendingState : possibleEccStates) { + mockEccCurrentState = iterCurrentState; + mockEccPendingState = iterPendingState; + + auto ret = pFwUtilImp->fwGetEccConfig(¤tState, &pendingState); + EXPECT_EQ(currentState, mockEccCurrentState); + EXPECT_EQ(pendingState, mockEccPendingState); + EXPECT_EQ(ZE_RESULT_SUCCESS, ret); + } + } + + delete pFwUtilImp->libraryHandle; + pFwUtilImp->libraryHandle = nullptr; + delete pFwUtilImp; +} + +TEST(LinuxFwEccTest, GivenUnavailableHeciFunctionPointersWhenCallingEccMethodsThenFailureIsReturned) { + restoreEccMockVars(); + L0::Sysman::FirmwareUtilImp *pFwUtilImp = new L0::Sysman::FirmwareUtilImp(0, 0, 0, 0); + MockFwUtilOsLibrary *osLibHandle = new MockFwUtilOsLibrary(); + pFwUtilImp->libraryHandle = static_cast(osLibHandle); + + ze_bool_t pAvailable; + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, pFwUtilImp->fwGetEccAvailable(&pAvailable)); + + ze_bool_t pConfigurable; + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, pFwUtilImp->fwGetEccConfigurable(&pConfigurable)); + + uint8_t currentState; + uint8_t pendingState; + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, pFwUtilImp->fwGetEccConfig(¤tState, &pendingState)); + + uint8_t newState = 1; + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, pFwUtilImp->fwSetEccConfig(newState, ¤tState, &pendingState)); + + delete pFwUtilImp->libraryHandle; + pFwUtilImp->libraryHandle = nullptr; + delete pFwUtilImp; +} + +TEST(LinuxFwEccTest, GivenHeciCmd15IsSupportedThenWhenCallingFwSetEccConfigSucessIsReturned) { + restoreEccMockVars(); + L0::Sysman::FirmwareUtilImp *pFwUtilImp = new L0::Sysman::FirmwareUtilImp(0, 0, 0, 0); + MockFwUtilOsLibrary *osLibHandle = new MockFwUtilOsLibrary(); + osLibHandle->funcMap["igsc_gfsp_heci_cmd"] = reinterpret_cast(&mockGetEccConfig); + pFwUtilImp->libraryHandle = static_cast(osLibHandle); + mockSupportedHeciCmds.clear(); + mockSupportedHeciCmds.push_back(GfspHeciConstants::Cmd::getEccConfigurationCmd16); + mockSupportedHeciCmds.push_back(GfspHeciConstants::Cmd::setEccConfigurationCmd15); + mockEccCurrentState = 0; + + uint8_t currentState; + uint8_t pendingState; + uint8_t newState = 1; + auto ret = pFwUtilImp->fwSetEccConfig(newState, ¤tState, &pendingState); + EXPECT_EQ(currentState, mockEccCurrentState); + EXPECT_EQ(pendingState, newState); + EXPECT_EQ(ZE_RESULT_SUCCESS, ret); + + delete pFwUtilImp->libraryHandle; + pFwUtilImp->libraryHandle = nullptr; + delete pFwUtilImp; +} + +TEST(LinuxFwEccTest, GivenHeciCmd15IsSupportedThenWhenCallingFwSetEccConfigAndFwGetEccConfigFailsThenFailureReturned) { + restoreEccMockVars(); + L0::Sysman::FirmwareUtilImp *pFwUtilImp = new L0::Sysman::FirmwareUtilImp(0, 0, 0, 0); + MockFwUtilOsLibrary *osLibHandle = new MockFwUtilOsLibrary(); + osLibHandle->funcMap["igsc_gfsp_heci_cmd"] = reinterpret_cast(&mockGetEccConfig); + pFwUtilImp->libraryHandle = static_cast(osLibHandle); + mockSupportedHeciCmds.clear(); + mockSupportedHeciCmds.push_back(0xff); + mockSupportedHeciCmds.push_back(GfspHeciConstants::Cmd::setEccConfigurationCmd15); + mockEccCurrentState = 0; + + uint8_t currentState; + uint8_t pendingState; + uint8_t newState = 1; + auto ret = pFwUtilImp->fwSetEccConfig(newState, ¤tState, &pendingState); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, ret); + + delete pFwUtilImp->libraryHandle; + pFwUtilImp->libraryHandle = nullptr; + delete pFwUtilImp; +} + +TEST(LinuxFwEccTest, GivenHeciSetCommandsAreNotSupportedThenWhenCallingFwSetEccConfigFailureReturned) { + restoreEccMockVars(); + L0::Sysman::FirmwareUtilImp *pFwUtilImp = new L0::Sysman::FirmwareUtilImp(0, 0, 0, 0); + MockFwUtilOsLibrary *osLibHandle = new MockFwUtilOsLibrary(); + osLibHandle->funcMap["igsc_gfsp_heci_cmd"] = reinterpret_cast(&mockGetEccConfig); + pFwUtilImp->libraryHandle = static_cast(osLibHandle); + mockSupportedHeciCmds.clear(); + mockSupportedHeciCmds.push_back(0xff); + mockEccCurrentState = 0; + + uint8_t currentState; + uint8_t pendingState; + uint8_t newState = 1; + auto ret = pFwUtilImp->fwSetEccConfig(newState, ¤tState, &pendingState); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, ret); + + delete pFwUtilImp->libraryHandle; + pFwUtilImp->libraryHandle = nullptr; + delete pFwUtilImp; +} + +TEST(LinuxFwEccTest, GivenHeciCmd15IsNotSupportedButCmd8IsSupportedThenWhenCallingFwSetEccConfigSucessIsReturned) { + restoreEccMockVars(); + L0::Sysman::FirmwareUtilImp *pFwUtilImp = new L0::Sysman::FirmwareUtilImp(0, 0, 0, 0); + MockFwUtilOsLibrary *osLibHandle = new MockFwUtilOsLibrary(); + osLibHandle->funcMap["igsc_gfsp_heci_cmd"] = reinterpret_cast(&mockGetEccConfig); + pFwUtilImp->libraryHandle = static_cast(osLibHandle); + mockSupportedHeciCmds.clear(); + mockSupportedHeciCmds.push_back(GfspHeciConstants::Cmd::getEccConfigurationCmd9); + mockSupportedHeciCmds.push_back(GfspHeciConstants::Cmd::setEccConfigurationCmd8); + mockEccCurrentState = 0; + + uint8_t currentState; + uint8_t pendingState; + uint8_t newState = 1; + auto ret = pFwUtilImp->fwSetEccConfig(newState, ¤tState, &pendingState); + EXPECT_EQ(currentState, mockEccCurrentState); + EXPECT_EQ(pendingState, newState); + EXPECT_EQ(ZE_RESULT_SUCCESS, ret); + + delete pFwUtilImp->libraryHandle; + pFwUtilImp->libraryHandle = nullptr; + delete pFwUtilImp; +} + } // namespace ult } // namespace Sysman } // namespace L0 diff --git a/level_zero/sysman/test/unit_tests/sources/global_operations/linux/mock_global_operations.h b/level_zero/sysman/test/unit_tests/sources/global_operations/linux/mock_global_operations.h index 3df5397d6f..71c339a6f9 100644 --- a/level_zero/sysman/test/unit_tests/sources/global_operations/linux/mock_global_operations.h +++ b/level_zero/sysman/test/unit_tests/sources/global_operations/linux/mock_global_operations.h @@ -603,6 +603,8 @@ struct MockGlobalOpsFwInterface : public L0::Sysman::FirmwareUtil { ADDMETHOD_NOBASE(fwSupportedDiagTests, ze_result_t, ZE_RESULT_SUCCESS, (std::vector & supportedDiagTests)); ADDMETHOD_NOBASE(fwRunDiagTests, ze_result_t, ZE_RESULT_SUCCESS, (std::string & osDiagType, zes_diag_result_t *pResult)); ADDMETHOD_NOBASE(fwGetMemoryErrorCount, ze_result_t, ZE_RESULT_SUCCESS, (zes_ras_error_type_t category, uint32_t subDeviceCount, uint32_t subDeviceId, uint64_t &count)); + ADDMETHOD_NOBASE(fwGetEccAvailable, ze_result_t, ZE_RESULT_SUCCESS, (ze_bool_t * pAvailable)); + ADDMETHOD_NOBASE(fwGetEccConfigurable, ze_result_t, ZE_RESULT_SUCCESS, (ze_bool_t * pConfigurable)); ADDMETHOD_NOBASE(fwGetEccConfig, ze_result_t, ZE_RESULT_SUCCESS, (uint8_t * currentState, uint8_t *pendingState)); ADDMETHOD_NOBASE(fwSetEccConfig, ze_result_t, ZE_RESULT_SUCCESS, (uint8_t newState, uint8_t *currentState, uint8_t *pendingState)); ADDMETHOD_NOBASE_VOIDRETURN(getDeviceSupportedFwTypes, (std::vector & fwTypes)); diff --git a/level_zero/sysman/test/unit_tests/sources/ras/linux/mock_sysman_ras.h b/level_zero/sysman/test/unit_tests/sources/ras/linux/mock_sysman_ras.h index 2161923e76..0139cc637d 100644 --- a/level_zero/sysman/test/unit_tests/sources/ras/linux/mock_sysman_ras.h +++ b/level_zero/sysman/test/unit_tests/sources/ras/linux/mock_sysman_ras.h @@ -667,6 +667,8 @@ struct MockRasFwInterface : public L0::Sysman::FirmwareUtil { ADDMETHOD_NOBASE(fwSupportedDiagTests, ze_result_t, ZE_RESULT_SUCCESS, (std::vector & supportedDiagTests)); ADDMETHOD_NOBASE(fwRunDiagTests, ze_result_t, ZE_RESULT_SUCCESS, (std::string & osDiagType, zes_diag_result_t *pResult)); ADDMETHOD_NOBASE_VOIDRETURN(getDeviceSupportedFwTypes, (std::vector & fwTypes)); + ADDMETHOD_NOBASE(fwGetEccAvailable, ze_result_t, ZE_RESULT_SUCCESS, (ze_bool_t * pAvailable)); + ADDMETHOD_NOBASE(fwGetEccConfigurable, ze_result_t, ZE_RESULT_SUCCESS, (ze_bool_t * pConfigurable)); ADDMETHOD_NOBASE(fwGetEccConfig, ze_result_t, ZE_RESULT_SUCCESS, (uint8_t * currentState, uint8_t *pendingState)); ADDMETHOD_NOBASE(fwSetEccConfig, ze_result_t, ZE_RESULT_SUCCESS, (uint8_t newState, uint8_t *currentState, uint8_t *pendingState)); ADDMETHOD_NOBASE_VOIDRETURN(fwGetMemoryHealthIndicator, (zes_mem_health_t * health)); diff --git a/level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/CMakeLists.txt b/level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/CMakeLists.txt index ea05109097..b1ddf04723 100644 --- a/level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/CMakeLists.txt +++ b/level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/CMakeLists.txt @@ -21,6 +21,7 @@ if(UNIX) ${CMAKE_CURRENT_SOURCE_DIR}/sysman_product_helper_init_tests.cpp ${CMAKE_CURRENT_SOURCE_DIR}/sysman_product_helper_engine_tests.cpp ${CMAKE_CURRENT_SOURCE_DIR}/sysman_product_helper_engine_tests_xe.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/sysman_product_helper_ecc_tests.cpp ) endif() add_subdirectories() diff --git a/level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/sysman_product_helper_ecc_tests.cpp b/level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/sysman_product_helper_ecc_tests.cpp new file mode 100644 index 0000000000..018f161946 --- /dev/null +++ b/level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/sysman_product_helper_ecc_tests.cpp @@ -0,0 +1,182 @@ +/* + * Copyright (C) 2025 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#include "shared/source/os_interface/driver_info.h" + +#include "level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper_hw.h" +#include "level_zero/sysman/test/unit_tests/sources/ecc/linux/mock_ecc.h" + +namespace L0 { +namespace Sysman { +namespace ult { + +using isDg2OrBmg = IsAnyProducts; + +class ZesEccFixture : public SysmanDeviceFixture { + protected: + L0::Sysman::SysmanDevice *device = nullptr; + std::unique_ptr pMockFwInterface; + L0::Sysman::FirmwareUtil *pFwUtilInterfaceOld = nullptr; + L0::Sysman::EccImp *pEccImp; + + void SetUp() override { + SysmanDeviceFixture::SetUp(); + device = pSysmanDevice; + pFwUtilInterfaceOld = pLinuxSysmanImp->pFwUtilInterface; + pMockFwInterface = std::make_unique(); + pLinuxSysmanImp->pFwUtilInterface = pMockFwInterface.get(); + + pEccImp = static_cast(pSysmanDeviceImp->pEcc); + } + + void TearDown() override { + pEccImp = nullptr; + + pLinuxSysmanImp->pFwUtilInterface = pFwUtilInterfaceOld; + SysmanDeviceFixture::TearDown(); + } +}; + +HWTEST2_F(ZesEccFixture, GivenValidSysmanHandleAndFwInterfaceIsPresentWhenCallingzesDeviceEccAvailableTwiceThenVerifyApiCallSucceeds, isDg2OrBmg) { + ze_bool_t eccAvailable = false; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEccAvailable(device, &eccAvailable)); + EXPECT_EQ(true, eccAvailable); + + eccAvailable = false; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEccAvailable(device, &eccAvailable)); + EXPECT_EQ(true, eccAvailable); +} + +HWTEST2_F(ZesEccFixture, GivenValidSysmanHandleAndFwInterfaceIsPresentWhenCallingzesDeviceEccConfigurableTwiceThenVerifyApiCallSucceeds, isDg2OrBmg) { + ze_bool_t eccConfigurable = false; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEccConfigurable(device, &eccConfigurable)); + EXPECT_EQ(true, eccConfigurable); + + eccConfigurable = false; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEccConfigurable(device, &eccConfigurable)); + EXPECT_EQ(true, eccConfigurable); +} + +HWTEST2_F(ZesEccFixture, GivenValidSysmanHandleAndFwInterfaceIsAbsentWhenCallingEccApiThenVerifyApiCallReturnFailure, isDg2OrBmg) { + ze_bool_t eccConfigurable = true; + ze_bool_t eccAvailable = true; + L0::Sysman::EccImp *tempEccImp = new L0::Sysman::EccImp(pOsSysman); + pLinuxSysmanImp->pFwUtilInterface = nullptr; + tempEccImp->init(); + EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, tempEccImp->deviceEccAvailable(&eccAvailable)); + EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, tempEccImp->deviceEccConfigurable(&eccConfigurable)); + + zes_device_ecc_desc_t newState = {}; + zes_device_ecc_properties_t props = {}; + EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, tempEccImp->setEccState(&newState, &props)); + EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, tempEccImp->getEccState(&props)); + delete tempEccImp; +} + +HWTEST2_F(ZesEccFixture, GivenValidSysmanHandleAndFwGetEccConfigFailsWhenCallingzesDeviceEccConfigurableAndAvailableThenVerifyApiCallReturnsFailure, isDg2OrBmg) { + ze_bool_t eccConfigurable = true; + ze_bool_t eccAvailable = true; + pMockFwInterface->mockFwGetEccAvailableResult = ZE_RESULT_ERROR_UNINITIALIZED; + pMockFwInterface->mockFwGetEccConfigurableResult = ZE_RESULT_ERROR_UNINITIALIZED; + + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, zesDeviceEccAvailable(device, &eccAvailable)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, zesDeviceEccConfigurable(device, &eccConfigurable)); +} + +HWTEST2_F(ZesEccFixture, GivenValidSysmanHandleAndCurrentStateIsNoneWhenCallingzesDeviceEccConfigurableAndAvailableThenNotSupportedEccIsReturned, isDg2OrBmg) { + ze_bool_t eccConfigurable = true; + ze_bool_t eccAvailable = true; + pMockFwInterface->mockEccAvailable = false; + pMockFwInterface->mockEccConfigurable = false; + + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEccAvailable(device, &eccAvailable)); + EXPECT_EQ(false, eccAvailable); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEccConfigurable(device, &eccConfigurable)); + EXPECT_EQ(false, eccConfigurable); +} + +HWTEST2_F(ZesEccFixture, GivenValidSysmanHandleAndFwInterfaceIsPresentWhenCallingzesDeviceGetEccStateThenApiCallSucceeds, isDg2OrBmg) { + zes_device_ecc_properties_t props = {}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceGetEccState(device, &props)); + EXPECT_EQ(ZES_DEVICE_ECC_STATE_DISABLED, props.currentState); + EXPECT_EQ(ZES_DEVICE_ECC_STATE_DISABLED, props.pendingState); + EXPECT_EQ(ZES_DEVICE_ACTION_NONE, props.pendingAction); +} + +HWTEST2_F(ZesEccFixture, GivenValidSysmanHandleAndFwGetEccConfigFailsWhenCallingzesDeviceGetEccStateThenApiCallReturnFailure, isDg2OrBmg) { + zes_device_ecc_properties_t props = {}; + pMockFwInterface->mockFwGetEccConfigResult = ZE_RESULT_ERROR_UNINITIALIZED; + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, zesDeviceGetEccState(device, &props)); +} + +HWTEST2_F(ZesEccFixture, GivenValidSysmanHandleAndFwInterfaceIsPresentWhenCallingzesDeviceSetEccStateThenApiCallSucceeds, isDg2OrBmg) { + zes_device_ecc_desc_t newState = {ZES_STRUCTURE_TYPE_DEVICE_STATE, nullptr, ZES_DEVICE_ECC_STATE_ENABLED}; + zes_device_ecc_properties_t props = {}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceSetEccState(device, &newState, &props)); + + newState.state = ZES_DEVICE_ECC_STATE_DISABLED; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceSetEccState(device, &newState, &props)); +} + +HWTEST2_F(ZesEccFixture, GivenValidSysmanHandleAndFwInterfaceIsPresentWhenCallingzesDeviceSetEccStateWithInvalidEnumThenFailureIsReturned, isDg2OrBmg) { + zes_device_ecc_desc_t newState = {ZES_STRUCTURE_TYPE_DEVICE_STATE, nullptr, ZES_DEVICE_ECC_STATE_UNAVAILABLE}; + zes_device_ecc_properties_t props = {}; + EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ENUMERATION, zesDeviceSetEccState(device, &newState, &props)); +} + +HWTEST2_F(ZesEccFixture, GivenValidSysmanHandleAndFwSetEccConfigFailsWhenCallingzesDeviceSetEccStateThenFailureIsReturned, isDg2OrBmg) { + zes_device_ecc_desc_t newState = {ZES_STRUCTURE_TYPE_DEVICE_STATE, nullptr, ZES_DEVICE_ECC_STATE_ENABLED}; + zes_device_ecc_properties_t props = {}; + pMockFwInterface->mockFwSetEccConfigResult = ZE_RESULT_ERROR_UNINITIALIZED; + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, zesDeviceSetEccState(device, &newState, &props)); +} + +HWTEST2_F(ZesEccFixture, GivenValidSysmanHandleWhenCallingEccSetStateAndEccGetStateThenVerifyApiCallSuccedsAndValidStatesAreReturned, isDg2OrBmg) { + zes_device_ecc_desc_t newState = {ZES_STRUCTURE_TYPE_DEVICE_STATE, nullptr, ZES_DEVICE_ECC_STATE_ENABLED}; + zes_device_ecc_properties_t props = {}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceSetEccState(device, &newState, &props)); + + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceGetEccState(device, &props)); + EXPECT_EQ(ZES_DEVICE_ECC_STATE_ENABLED, props.pendingState); + + newState.state = ZES_DEVICE_ECC_STATE_DISABLED; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceSetEccState(device, &newState, &props)); + + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceGetEccState(device, &props)); + EXPECT_EQ(ZES_DEVICE_ECC_STATE_DISABLED, props.pendingState); + + pMockFwInterface->mockSetConfig = false; + pMockFwInterface->mockCurrentState = eccStateNone; + pMockFwInterface->mockPendingState = eccStateNone; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceSetEccState(device, &newState, &props)); + + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceGetEccState(device, &props)); + EXPECT_EQ(ZES_DEVICE_ECC_STATE_UNAVAILABLE, props.pendingState); + EXPECT_EQ(ZES_DEVICE_ECC_STATE_UNAVAILABLE, props.currentState); +} + +HWTEST2_F(ZesEccFixture, GivenValidSysmanHandleWhenCallingEccSetStateAndEccGetStateThenVerifyApiCallSuccedsAndValidActionIsReturned, isDg2OrBmg) { + zes_device_ecc_desc_t newState = {ZES_STRUCTURE_TYPE_DEVICE_STATE, nullptr, ZES_DEVICE_ECC_STATE_ENABLED}; + zes_device_ecc_properties_t props = {}; + pMockFwInterface->mockCurrentState = eccStateEnable; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceSetEccState(device, &newState, &props)); + + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceGetEccState(device, &props)); + EXPECT_EQ(ZES_DEVICE_ECC_STATE_ENABLED, props.pendingState); + EXPECT_EQ(ZES_DEVICE_ACTION_NONE, props.pendingAction); + + newState.state = ZES_DEVICE_ECC_STATE_DISABLED; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceSetEccState(device, &newState, &props)); + + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceGetEccState(device, &props)); + EXPECT_EQ(ZES_DEVICE_ECC_STATE_DISABLED, props.pendingState); + EXPECT_EQ(ZES_DEVICE_ACTION_WARM_CARD_RESET, props.pendingAction); +} + +} // namespace ult +} // namespace Sysman +} // namespace L0