Add support for setting default values for min and max frquency

Related-To: LOCI-3170

Signed-off-by: Mayank Raghuwanshi <mayank.raghuwanshi@intel.com>

Author: mraghuwa

level_zero/tools/source/sysman/frequency/linux/os_frequency_imp.cpp

@@ -51,6 +51,19 @@ ze_result_t LinuxFrequencyImp::osFrequencyGetRange(zes_freq_range_t *pLimits) {
 ze_result_t LinuxFrequencyImp::osFrequencySetRange(const zes_freq_range_t *pLimits) {
     double newMin = round(pLimits->min);
     double newMax = round(pLimits->max);
+    if (newMax == -1 && newMin == -1) {
+        double maxDefault = 0, minDefault = 0;
+        ze_result_t result1, result2, result;
+        result1 = pSysfsAccess->read(maxDefaultFreqFile, maxDefault);
+        result2 = pSysfsAccess->read(minDefaultFreqFile, minDefault);
+        if (result1 == ZE_RESULT_SUCCESS && result2 == ZE_RESULT_SUCCESS) {
+            result = setMax(maxDefault);
+            if (ZE_RESULT_SUCCESS != result) {
+                return result;
+            }
+            return setMin(minDefault);
+        }
+    }
     double currentMax = 0.0;
     ze_result_t result = getMax(currentMax);
     if (ZE_RESULT_SUCCESS != result) {
@@ -319,6 +332,8 @@ void LinuxFrequencyImp::init() {
     if (pSysfsAccess->directoryExists(baseDir)) {
         minFreqFile = baseDir + "rps_min_freq_mhz";
         maxFreqFile = baseDir + "rps_max_freq_mhz";
+        minDefaultFreqFile = baseDir + ".defaults/rps_min_freq_mhz";
+        maxDefaultFreqFile = baseDir + ".defaults/rps_max_freq_mhz";
         boostFreqFile = baseDir + "rps_boost_freq_mhz";
         requestFreqFile = baseDir + "punit_req_freq_mhz";
         tdpFreqFile = baseDir + "rapl_PL1_freq_mhz";

level_zero/tools/source/sysman/frequency/linux/os_frequency_imp.h

@@ -54,6 +54,8 @@ class LinuxFrequencyImp : public OsFrequency, NEO::NonCopyableOrMovableClass {
   private:
     std::string minFreqFile;
     std::string maxFreqFile;
+    std::string minDefaultFreqFile;
+    std::string maxDefaultFreqFile;
     std::string boostFreqFile;
     std::string requestFreqFile;
     std::string tdpFreqFile;

level_zero/tools/test/unit_tests/sources/sysman/frequency/linux/mock_sysfs_frequency.h

@@ -13,6 +13,8 @@ namespace ult {
 
 const std::string minFreqFile("gt/gt0/rps_min_freq_mhz");
 const std::string maxFreqFile("gt/gt0/rps_max_freq_mhz");
+const std::string minDefaultFreqFile("gt/gt0/.defaults/rps_min_freq_mhz");
+const std::string maxDefaultFreqFile("gt/gt0/.defaults/rps_max_freq_mhz");
 const std::string boostFreqFile("gt/gt0/rps_boost_freq_mhz");
 const std::string requestFreqFile("gt/gt0/punit_req_freq_mhz");
 const std::string tdpFreqFile("gt/gt0/rapl_PL1_freq_mhz");
@@ -49,6 +51,8 @@ struct Mock<FrequencySysfsAccess> : public FrequencySysfsAccess {
     double mockMax = 0;
     double mockBoost = 0;
     double mockRequest = 0;
+    double mockDefaultMin = 1;
+    double mockDefaultMax = 1000;
     double mockTdp = 0;
     double mockActual = 0;
     double mockEfficient = 0;
@@ -66,6 +70,8 @@ struct Mock<FrequencySysfsAccess> : public FrequencySysfsAccess {
     ze_result_t mockReadActualResult = ZE_RESULT_SUCCESS;
     ze_result_t mockReadMinValResult = ZE_RESULT_SUCCESS;
     ze_result_t mockReadMaxValResult = ZE_RESULT_SUCCESS;
+    ze_result_t mockReadDefaultMinResult = ZE_RESULT_SUCCESS;
+    ze_result_t mockReadDefaultMaxResult = ZE_RESULT_SUCCESS;
     ze_result_t mockReadMaxResult = ZE_RESULT_SUCCESS;
     ze_result_t mockReadVal32Result = ZE_RESULT_SUCCESS;
     ze_result_t mockWriteMaxResult = ZE_RESULT_SUCCESS;
@@ -218,6 +224,16 @@ struct Mock<FrequencySysfsAccess> : public FrequencySysfsAccess {
                 return mockReadMinValResult;
             }
             val = mockMinVal;
+        } else if (file.compare(minDefaultFreqFile) == 0) {
+            if (mockReadDefaultMinResult != ZE_RESULT_SUCCESS) {
+                return mockReadDefaultMinResult;
+            }
+            val = mockDefaultMin;
+        } else if (file.compare(maxDefaultFreqFile) == 0) {
+            if (mockReadDefaultMaxResult != ZE_RESULT_SUCCESS) {
+                return mockReadDefaultMaxResult;
+            }
+            val = mockDefaultMax;
         } else {
             return ZE_RESULT_ERROR_NOT_AVAILABLE;
         }

level_zero/tools/test/unit_tests/sources/sysman/frequency/linux/test_zes_frequency.cpp

@@ -269,6 +269,54 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFreq
     }
 }
 
+TEST_F(SysmanDeviceFrequencyFixture, GivenNegativeRangeSetWhenGetRangeIsCalledThenReturnsValueFromDefaultPath) {
+    auto handles = getFreqHandles(handleComponentCount);
+    for (auto &handle : handles) {
+        const double negativeMin = -1;
+        const double negativeMax = -1;
+        zes_freq_range_t limits;
+
+        limits.min = negativeMin;
+        limits.max = negativeMax;
+        EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencySetRange(handle, &limits));
+        EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetRange(handle, &limits));
+        EXPECT_EQ(pSysfsAccess->mockDefaultMin, limits.min);
+        EXPECT_EQ(pSysfsAccess->mockDefaultMax, limits.max);
+        EXPECT_DOUBLE_EQ(pSysfsAccess->mockBoost, limits.max);
+    }
+}
+
+TEST_F(SysmanDeviceFrequencyFixture, GivenNegativeRangeWhenSetRangeIsCalledAndSettingMaxValueFailsThenFailureIsReturned) {
+    pSysfsAccess->mockWriteMaxResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
+    auto handles = getFreqHandles(handleComponentCount);
+    for (auto &handle : handles) {
+        const double negativeMin = -1;
+        const double negativeMax = -1;
+        zes_freq_range_t limits;
+
+        limits.min = negativeMin;
+        limits.max = negativeMax;
+        EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFrequencySetRange(handle, &limits));
+    }
+}
+
+TEST_F(SysmanDeviceFrequencyFixture, GivenNegativeRangeWhenSetRangeIsCalledAndGettingDefaultMaxValueFailsThenNoFreqRangeIsInEffect) {
+    pSysfsAccess->mockReadDefaultMaxResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
+    auto handles = getFreqHandles(handleComponentCount);
+    for (auto &handle : handles) {
+        const double negativeMin = -1;
+        const double negativeMax = -1;
+        zes_freq_range_t limits;
+
+        limits.min = negativeMin;
+        limits.max = negativeMax;
+        EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencySetRange(handle, &limits));
+        EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetRange(handle, &limits));
+        EXPECT_DOUBLE_EQ(-1, limits.min);
+        EXPECT_DOUBLE_EQ(-1, limits.max);
+    }
+}
+
 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencySetRangeThenVerifyzesFrequencySetRangeTest2CallSucceeds) {
     auto handles = getFreqHandles(handleComponentCount);
     for (auto handle : handles) {