intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-03 23:03:02 +08:00
Code Issues Packages Projects Releases Wiki Activity

fix: Implemented Get Fan Config to retrieve Default Fan Table

Browse Source 
Related-To: NEO-11667

Signed-off-by: Ezhilsivam Shanmugam <ezhilsivam.shanmugam@intel.com>
This commit is contained in:
Ezhilsivam Shanmugam
2024-07-09 18:00:04 +00:00
committed by Compute-Runtime-Automation
parent 4cabc9e4d2
commit ae49a4f1fd
6 changed files with 332 additions and 26 deletions
Download Patch File Download Diff File Expand all files Collapse all files

35
level_zero/sysman/source/api/fan/windows/sysman_os_fan_imp.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2023 Intel Corporation
* Copyright (C) 2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -83,6 +83,39 @@ ze_result_t WddmFanImp::getConfig(zes_fan_config_t *pConfig) {
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
if (value == 0) {
pConfig->mode = ZES_FAN_SPEED_MODE_DEFAULT;
pConfig->speedTable.numPoints = 0;
request.commandId = KmdSysman::Command::Get;
request.componentId = KmdSysman::Component::FanComponent;
request.requestId = KmdSysman::Requests::Fans::MaxFanControlPointsSupported;
status = pKmdSysManager->requestSingle(request, response);
if (status == ZE_RESULT_SUCCESS) {
uint32_t maxFanPoints = 0;
memcpy_s(&maxFanPoints, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
pConfig->speedTable.numPoints = static_cast<int32_t>(maxFanPoints);
if (maxFanPoints != 0) {
request.requestId = KmdSysman::Requests::Fans::CurrentFanPoint;
// Try reading Default Fan table if the platform supports
// If platform doesn't support reading default fan table we still return valid FanConfig.Mode
// but not the table filled with default fan table entries
for (int32_t i = 0; i < pConfig->speedTable.numPoints; i++) {
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
FanPoint point = {};
memcpy_s(&point.data, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
pConfig->speedTable.table[i].speed.speed = point.fanSpeedPercent;
pConfig->speedTable.table[i].speed.units = ZES_FAN_SPEED_UNITS_PERCENT;
pConfig->speedTable.table[i].temperature = point.temperatureDegreesCelsius;
} else {
pConfig->speedTable.numPoints = i;
break;
}
}
}
} // else, return Success. We still return valid FanConfig.mode
} else {
pConfig->mode = ZES_FAN_SPEED_MODE_TABLE;
pConfig->speedTable.numPoints = value;

62
level_zero/sysman/test/unit_tests/sources/fan/windows/mock_fan.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2023 Intel Corporation
* Copyright (C) 2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -22,10 +22,17 @@ struct MockFanKmdSysManager : public MockKmdSysManager {
uint32_t FanSpeedPercent : 16;
};
uint32_t Data;
} mockFanTempSpeed;
} mockFanTempSpeed[10], mockStockFanTable[10];
uint32_t mockFanMaxPoints = 10;
uint32_t mockFanCurrentPulses = 523436;
uint32_t mockFanCurrentFanPoints = 0;
uint32_t mockCurrentReadIndex = 0;
uint32_t mockCurrentWriteIndex = 0;
bool isFanTableSet = false;
bool isStockFanTableAvailable = false;
bool failMaxPointsGet = false;
bool retZeroMaxPoints = false;
bool smallStockTable = false;
void getFanProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) override {
uint8_t *pBuffer = reinterpret_cast<uint8_t *>(pResponse);
@@ -35,8 +42,17 @@ struct MockFanKmdSysManager : public MockKmdSysManager {
case KmdSysman::Requests::Fans::MaxFanControlPointsSupported: {
uint32_t *pValue = reinterpret_cast<uint32_t *>(pBuffer);
*pValue = mockFanMaxPoints;
pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
pResponse->outDataSize = sizeof(uint32_t);
if (retZeroMaxPoints) {
*pValue = 0;
}
if (!failMaxPointsGet) {
pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
pResponse->outDataSize = sizeof(uint32_t);
} else {
pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
pResponse->outDataSize = 0;
}
} break;
case KmdSysman::Requests::Fans::CurrentFanSpeed: {
if (fanSupported) {
@@ -52,16 +68,37 @@ struct MockFanKmdSysManager : public MockKmdSysManager {
case KmdSysman::Requests::Fans::CurrentNumOfControlPoints: {
uint32_t *pValue = reinterpret_cast<uint32_t *>(pBuffer);
*pValue = mockFanCurrentFanPoints;
mockCurrentReadIndex = 0;
pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
pResponse->outDataSize = sizeof(uint32_t);
} break;
case KmdSysman::Requests::Fans::CurrentFanPoint: {
uint32_t *pValue = reinterpret_cast<uint32_t *>(pBuffer);
mockFanTempSpeed.FanSpeedPercent = 25;
mockFanTempSpeed.TemperatureDegreesCelsius = 50;
*pValue = mockFanTempSpeed.Data;
pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
pResponse->outDataSize = sizeof(uint32_t);
if (isFanTableSet) {
mockFanTempSpeed[mockCurrentReadIndex].FanSpeedPercent = mockCurrentReadIndex * 10;
mockFanTempSpeed[mockCurrentReadIndex].TemperatureDegreesCelsius = mockCurrentReadIndex * 10 + 20;
*pValue = mockFanTempSpeed[mockCurrentReadIndex].Data;
mockCurrentReadIndex++;
pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
pResponse->outDataSize = sizeof(uint32_t);
} else if (isStockFanTableAvailable) {
mockStockFanTable[mockCurrentReadIndex].FanSpeedPercent = mockCurrentReadIndex * 10 - 5;
mockStockFanTable[mockCurrentReadIndex].TemperatureDegreesCelsius = mockCurrentReadIndex * 10 + 15;
*pValue = mockStockFanTable[mockCurrentReadIndex].Data;
mockCurrentReadIndex++;
if (smallStockTable && mockCurrentReadIndex == 6) {
// only return 5 points for smallStockTable
*pValue = 0;
pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
pResponse->outDataSize = 0;
} else {
pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
pResponse->outDataSize = sizeof(uint32_t);
}
} else {
pResponse->outDataSize = 0;
pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
}
} break;
default: {
pResponse->outDataSize = 0;
@@ -80,8 +117,12 @@ struct MockFanKmdSysManager : public MockKmdSysManager {
mockFanCurrentFanPoints = *pValue;
pResponse->outDataSize = 0;
if ((mockFanCurrentFanPoints % 2 == 0) && (mockFanCurrentFanPoints > 0) && (mockFanCurrentFanPoints <= mockFanMaxPoints)) {
mockCurrentWriteIndex = 0;
pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
} else if (mockFanCurrentFanPoints == 0) {
isFanTableSet = false;
mockCurrentReadIndex = 0;
mockCurrentWriteIndex = 0;
pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
} else {
pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
@@ -89,7 +130,8 @@ struct MockFanKmdSysManager : public MockKmdSysManager {
} break;
case KmdSysman::Requests::Fans::CurrentFanPoint: {
uint32_t *pValue = reinterpret_cast<uint32_t *>(pBuffer);
mockFanTempSpeed.Data = *pValue;
mockFanTempSpeed[mockCurrentWriteIndex++].Data = *pValue;
isFanTableSet = true;
pResponse->outDataSize = 0;
pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
} break;

82
level_zero/sysman/test/unit_tests/sources/fan/windows/test_zes_sysman_fan.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2023 Intel Corporation
* Copyright (C) 2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -149,17 +149,95 @@ TEST_F(SysmanDeviceFanFixture, GivenValidFanHandleWhenGettingFanPropertiesAllowS
}
}
TEST_F(SysmanDeviceFanFixture, GivenValidFanHandleWhenGettingFanConfigThenSuccessIsReturnedDefaultFanTable) {
TEST_F(SysmanDeviceFanFixture, GivenValidFanHandleWhenGettingFanConfigThenSuccessIsReturnedWithoutDefaultFanTable) {
// Setting allow set calls or not
init(true, true);
auto handles = getFanHandles();
pKmdSysManager->isStockFanTableAvailable = false;
for (auto handle : handles) {
zes_fan_config_t fanConfig;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFanSetDefaultMode(handle));
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFanGetConfig(handle, &fanConfig));
EXPECT_EQ(fanConfig.mode, ZES_FAN_SPEED_MODE_DEFAULT);
EXPECT_EQ(fanConfig.speedTable.numPoints, 0);
}
}
TEST_F(SysmanDeviceFanFixture, GivenValidFanHandleWithStockTableWhenGettingFanConfigThenSuccessIsReturnedWithDefaultFanTable) {
// Setting allow set calls or not
init(true, true);
auto handles = getFanHandles();
pKmdSysManager->isStockFanTableAvailable = true;
for (auto handle : handles) {
zes_fan_config_t fanConfig;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFanSetDefaultMode(handle));
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFanGetConfig(handle, &fanConfig));
EXPECT_EQ(fanConfig.mode, ZES_FAN_SPEED_MODE_DEFAULT);
EXPECT_EQ(fanConfig.speedTable.numPoints, 10);
EXPECT_EQ(fanConfig.speedTable.table[0].speed.units, ZES_FAN_SPEED_UNITS_PERCENT);
EXPECT_EQ(fanConfig.speedTable.table[1].speed.units, ZES_FAN_SPEED_UNITS_PERCENT);
EXPECT_EQ(fanConfig.speedTable.table[2].speed.units, ZES_FAN_SPEED_UNITS_PERCENT);
EXPECT_EQ(fanConfig.speedTable.table[3].speed.units, ZES_FAN_SPEED_UNITS_PERCENT);
}
}
TEST_F(SysmanDeviceFanFixture, GivenValidFanHandleWithMaxPointEscapeFailureWhenGettingFanConfigThenSuccessIsReturnedWithoutDefaultFanTable) {
// Setting allow set calls or not
init(true, true);
auto handles = getFanHandles();
pKmdSysManager->isStockFanTableAvailable = true;
pKmdSysManager->failMaxPointsGet = true;
for (auto handle : handles) {
zes_fan_config_t fanConfig;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFanSetDefaultMode(handle));
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFanGetConfig(handle, &fanConfig));
EXPECT_EQ(fanConfig.mode, ZES_FAN_SPEED_MODE_DEFAULT);
EXPECT_EQ(fanConfig.speedTable.numPoints, 0);
}
}
TEST_F(SysmanDeviceFanFixture, GivenValidFanHandleWithZeroMaxPointsTableWhenGettingFanConfigThenSuccessIsReturnedWithoutDefaultFanTable) {
// Setting allow set calls or not
init(true, true);
auto handles = getFanHandles();
pKmdSysManager->isStockFanTableAvailable = true;
pKmdSysManager->retZeroMaxPoints = true;
for (auto handle : handles) {
zes_fan_config_t fanConfig;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFanSetDefaultMode(handle));
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFanGetConfig(handle, &fanConfig));
EXPECT_EQ(fanConfig.mode, ZES_FAN_SPEED_MODE_DEFAULT);
EXPECT_EQ(fanConfig.speedTable.numPoints, 0);
}
}
TEST_F(SysmanDeviceFanFixture, GivenValidFanHandleWithSmallStockTableAvailableWhenGettingFanConfigThenSuccessIsReturnedWithDefaultFanTable) {
// Setting allow set calls or not
init(true, true);
auto handles = getFanHandles();
pKmdSysManager->isStockFanTableAvailable = true;
pKmdSysManager->smallStockTable = true;
for (auto handle : handles) {
zes_fan_config_t fanConfig;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFanSetDefaultMode(handle));
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFanGetConfig(handle, &fanConfig));
EXPECT_EQ(fanConfig.mode, ZES_FAN_SPEED_MODE_DEFAULT);
EXPECT_EQ(fanConfig.speedTable.numPoints, 5);
}
}