diff --git a/level_zero/sysman/source/api/frequency/linux/sysman_os_frequency_imp.cpp b/level_zero/sysman/source/api/frequency/linux/sysman_os_frequency_imp.cpp
index 3a4fceb62f..1910856acc 100644
--- a/level_zero/sysman/source/api/frequency/linux/sysman_os_frequency_imp.cpp
+++ b/level_zero/sysman/source/api/frequency/linux/sysman_os_frequency_imp.cpp
@@ -64,21 +64,25 @@ 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) {
-                NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr,
-                                      "error@<%s> <setMax(maxDefault) returned 0x%x>\n", __func__, result);
-                return result;
+
+    if (pSysmanKmdInterface->isDefaultFrequencyAvailable()) {
+        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) {
+                    NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr,
+                                          "error@<%s> <setMax(maxDefault) returned 0x%x>\n", __func__, result);
+                    return result;
+                }
+                return setMin(minDefault);
             }
-            return setMin(minDefault);
         }
     }
+
     double currentMax = 0.0;
     ze_result_t result = getMax(currentMax);
     if (ZE_RESULT_SUCCESS != result) {
@@ -279,7 +283,12 @@ ze_result_t LinuxFrequencyImp::setMax(double max) {
                               "error@<%s> <failed to write file %s> <result: 0x%x>\n", __func__, maxFreqFile.c_str(), result);
         return result;
     }
-    return pSysfsAccess->write(boostFreqFile, max);
+
+    if (pSysmanKmdInterface->isBoostFrequencyAvailable()) {
+        result = pSysfsAccess->write(boostFreqFile, max);
+    }
+
+    return result;
 }
 
 ze_result_t LinuxFrequencyImp::getRequest(double &request) {
@@ -299,19 +308,25 @@ ze_result_t LinuxFrequencyImp::getRequest(double &request) {
 }
 
 ze_result_t LinuxFrequencyImp::getTdp(double &tdp) {
-    double intval;
+    ze_result_t result = ZE_RESULT_ERROR_NOT_AVAILABLE;
+    double freqVal = 0;
 
-    ze_result_t result = pSysfsAccess->read(tdpFreqFile, intval);
-    if (ZE_RESULT_SUCCESS != result) {
-        if (result == ZE_RESULT_ERROR_NOT_AVAILABLE) {
-            result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+    if (pSysmanKmdInterface->isTdpFrequencyAvailable()) {
+        result = pSysfsAccess->read(tdpFreqFile, freqVal);
+        if (ZE_RESULT_SUCCESS != result) {
+            if (result == ZE_RESULT_ERROR_NOT_AVAILABLE) {
+                result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+            }
+            NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr,
+                                  "error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, tdpFreqFile.c_str(), result);
+            return result;
         }
-        NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr,
-                              "error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, tdpFreqFile.c_str(), result);
-        return result;
+        tdp = freqVal;
+    } else {
+        result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
     }
-    tdp = intval;
-    return ZE_RESULT_SUCCESS;
+
+    return result;
 }
 
 ze_result_t LinuxFrequencyImp::getActual(double &actual) {
@@ -383,12 +398,8 @@ void LinuxFrequencyImp::init() {
     bool baseDirectoryExists = pSysfsAccess->directoryExists(baseDir);
 
     minFreqFile = pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameMinFrequency, subdeviceId, baseDirectoryExists);
-    minDefaultFreqFile = pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameMinDefaultFrequency, subdeviceId, baseDirectoryExists);
     maxFreqFile = pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameMaxFrequency, subdeviceId, baseDirectoryExists);
-    maxDefaultFreqFile = pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameMaxDefaultFrequency, subdeviceId, baseDirectoryExists);
-    boostFreqFile = pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameBoostFrequency, subdeviceId, baseDirectoryExists);
     requestFreqFile = pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameCurrentFrequency, subdeviceId, baseDirectoryExists);
-    tdpFreqFile = pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameTdpFrequency, subdeviceId, baseDirectoryExists);
     actualFreqFile = pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameActualFrequency, subdeviceId, baseDirectoryExists);
     efficientFreqFile = pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameEfficientFrequency, subdeviceId, baseDirectoryExists);
     maxValFreqFile = pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameMaxValueFrequency, subdeviceId, baseDirectoryExists);
@@ -398,6 +409,19 @@ void LinuxFrequencyImp::init() {
     throttleReasonPL2File = pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameThrottleReasonPL2, subdeviceId, baseDirectoryExists);
     throttleReasonPL4File = pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameThrottleReasonPL4, subdeviceId, baseDirectoryExists);
     throttleReasonThermalFile = pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameThrottleReasonThermal, subdeviceId, baseDirectoryExists);
+
+    if (pSysmanKmdInterface->isDefaultFrequencyAvailable()) {
+        minDefaultFreqFile = pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameMinDefaultFrequency, subdeviceId, baseDirectoryExists);
+        maxDefaultFreqFile = pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameMaxDefaultFrequency, subdeviceId, baseDirectoryExists);
+    }
+
+    if (pSysmanKmdInterface->isBoostFrequencyAvailable()) {
+        boostFreqFile = pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameBoostFrequency, subdeviceId, baseDirectoryExists);
+    }
+
+    if (pSysmanKmdInterface->isTdpFrequencyAvailable()) {
+        tdpFreqFile = pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameTdpFrequency, subdeviceId, baseDirectoryExists);
+    }
 }
 
 LinuxFrequencyImp::LinuxFrequencyImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_freq_domain_t frequencyDomainNumber) : isSubdevice(onSubdevice), subdeviceId(subdeviceId), frequencyDomainNumber(frequencyDomainNumber) {
diff --git a/level_zero/sysman/source/shared/linux/sysman_kmd_interface.h b/level_zero/sysman/source/shared/linux/sysman_kmd_interface.h
index fbd31f2b53..3b87b44124 100644
--- a/level_zero/sysman/source/shared/linux/sysman_kmd_interface.h
+++ b/level_zero/sysman/source/shared/linux/sysman_kmd_interface.h
@@ -133,6 +133,9 @@ class SysmanKmdInterface {
                                const uint64_t srcValue, uint64_t &dstValue) const;
     virtual std::optional<std::string> getEngineClassString(uint16_t engineClass) = 0;
     virtual uint32_t getEventType(const bool isIntegratedDevice) = 0;
+    virtual bool isDefaultFrequencyAvailable() const = 0;
+    virtual bool isBoostFrequencyAvailable() const = 0;
+    virtual bool isTdpFrequencyAvailable() const = 0;
 
   protected:
     std::unique_ptr<FsAccessInterface> pFsAccess;
@@ -176,6 +179,9 @@ class SysmanKmdInterfaceI915Upstream : public SysmanKmdInterface, SysmanKmdInter
     uint32_t getEventType(const bool isIntegratedDevice) override;
     bool isBaseFrequencyFactorAvailable() const override { return false; }
     bool isSystemPowerBalanceAvailable() const override { return false; }
+    bool isDefaultFrequencyAvailable() const override { return true; }
+    bool isBoostFrequencyAvailable() const override { return true; }
+    bool isTdpFrequencyAvailable() const override { return true; }
 
   protected:
     std::map<SysfsName, valuePair> sysfsNameToFileMap;
@@ -214,6 +220,9 @@ class SysmanKmdInterfaceI915Prelim : public SysmanKmdInterface, SysmanKmdInterfa
     uint32_t getEventType(const bool isIntegratedDevice) override;
     bool isBaseFrequencyFactorAvailable() const override { return false; }
     bool isSystemPowerBalanceAvailable() const override { return false; }
+    bool isDefaultFrequencyAvailable() const override { return true; }
+    bool isBoostFrequencyAvailable() const override { return true; }
+    bool isTdpFrequencyAvailable() const override { return true; }
 
   protected:
     std::map<SysfsName, valuePair> sysfsNameToFileMap;
@@ -252,6 +261,9 @@ class SysmanKmdInterfaceXe : public SysmanKmdInterface {
     uint32_t getEventType(const bool isIntegratedDevice) override;
     bool isBaseFrequencyFactorAvailable() const override { return true; }
     bool isSystemPowerBalanceAvailable() const override { return true; }
+    bool isDefaultFrequencyAvailable() const override { return false; }
+    bool isBoostFrequencyAvailable() const override { return false; }
+    bool isTdpFrequencyAvailable() const override { return false; }
 
   protected:
     std::map<SysfsName, valuePair> sysfsNameToFileMap;
diff --git a/level_zero/sysman/source/shared/linux/sysman_kmd_interface_xe.cpp b/level_zero/sysman/source/shared/linux/sysman_kmd_interface_xe.cpp
index d380fdd119..621ca27e94 100644
--- a/level_zero/sysman/source/shared/linux/sysman_kmd_interface_xe.cpp
+++ b/level_zero/sysman/source/shared/linux/sysman_kmd_interface_xe.cpp
@@ -76,22 +76,18 @@ std::string SysmanKmdInterfaceXe::getBasePath(uint32_t subDeviceId) const {
 }
 
 void SysmanKmdInterfaceXe::initSysfsNameToFileMap(const PRODUCT_FAMILY productFamily) {
-    sysfsNameToFileMap[SysfsName::sysfsNameMinFrequency] = std::make_pair("rps_min_freq_mhz", "");
-    sysfsNameToFileMap[SysfsName::sysfsNameMaxFrequency] = std::make_pair("rps_max_freq_mhz", "");
-    sysfsNameToFileMap[SysfsName::sysfsNameMinDefaultFrequency] = std::make_pair(".defaults/rps_min_freq_mhz", "");
-    sysfsNameToFileMap[SysfsName::sysfsNameMaxDefaultFrequency] = std::make_pair(".defaults/rps_max_freq_mhz", "");
-    sysfsNameToFileMap[SysfsName::sysfsNameBoostFrequency] = std::make_pair("rps_boost_freq_mhz", "");
-    sysfsNameToFileMap[SysfsName::sysfsNameCurrentFrequency] = std::make_pair("punit_req_freq_mhz", "");
-    sysfsNameToFileMap[SysfsName::sysfsNameTdpFrequency] = std::make_pair("rapl_PL1_freq_mhz", "");
-    sysfsNameToFileMap[SysfsName::sysfsNameActualFrequency] = std::make_pair("rps_act_freq_mhz", "");
-    sysfsNameToFileMap[SysfsName::sysfsNameEfficientFrequency] = std::make_pair("rps_RP1_freq_mhz", "");
-    sysfsNameToFileMap[SysfsName::sysfsNameMaxValueFrequency] = std::make_pair("rps_RP0_freq_mhz", "");
-    sysfsNameToFileMap[SysfsName::sysfsNameMinValueFrequency] = std::make_pair("rps_RPn_freq_mhz", "");
-    sysfsNameToFileMap[SysfsName::sysfsNameThrottleReasonStatus] = std::make_pair("throttle_reason_status", "");
-    sysfsNameToFileMap[SysfsName::sysfsNameThrottleReasonPL1] = std::make_pair("throttle_reason_pl1", "");
-    sysfsNameToFileMap[SysfsName::sysfsNameThrottleReasonPL2] = std::make_pair("throttle_reason_pl2", "");
-    sysfsNameToFileMap[SysfsName::sysfsNameThrottleReasonPL4] = std::make_pair("throttle_reason_pl4", "");
-    sysfsNameToFileMap[SysfsName::sysfsNameThrottleReasonThermal] = std::make_pair("throttle_reason_thermal", "");
+    sysfsNameToFileMap[SysfsName::sysfsNameMinFrequency] = std::make_pair("freq0/min_freq", "");
+    sysfsNameToFileMap[SysfsName::sysfsNameMaxFrequency] = std::make_pair("freq0/max_freq", "");
+    sysfsNameToFileMap[SysfsName::sysfsNameCurrentFrequency] = std::make_pair("freq0/cur_freq", "");
+    sysfsNameToFileMap[SysfsName::sysfsNameActualFrequency] = std::make_pair("freq0/act_freq", "");
+    sysfsNameToFileMap[SysfsName::sysfsNameEfficientFrequency] = std::make_pair("freq0/rpe_freq", "");
+    sysfsNameToFileMap[SysfsName::sysfsNameMaxValueFrequency] = std::make_pair("freq0/rp0_freq", "");
+    sysfsNameToFileMap[SysfsName::sysfsNameMinValueFrequency] = std::make_pair("freq0/rpn_freq", "");
+    sysfsNameToFileMap[SysfsName::sysfsNameThrottleReasonStatus] = std::make_pair("freq0/throttle/status", "");
+    sysfsNameToFileMap[SysfsName::sysfsNameThrottleReasonPL1] = std::make_pair("freq0/throttle/reason_pl1", "");
+    sysfsNameToFileMap[SysfsName::sysfsNameThrottleReasonPL2] = std::make_pair("freq0/throttle/reason_pl2", "");
+    sysfsNameToFileMap[SysfsName::sysfsNameThrottleReasonPL4] = std::make_pair("freq0/throttle/reason_pl4", "");
+    sysfsNameToFileMap[SysfsName::sysfsNameThrottleReasonThermal] = std::make_pair("freq0/throttle/reason_thermal", "");
     sysfsNameToFileMap[SysfsName::sysfsNameSustainedPowerLimit] = std::make_pair("", "power1_max");
     sysfsNameToFileMap[SysfsName::sysfsNameSustainedPowerLimitInterval] = std::make_pair("", "power1_max_interval");
     sysfsNameToFileMap[SysfsName::sysfsNameEnergyCounterNode] = std::make_pair("", "energy1_input");
diff --git a/level_zero/sysman/test/unit_tests/sources/shared/linux/sysman_kmd_interface_tests_i915_prelim.cpp b/level_zero/sysman/test/unit_tests/sources/shared/linux/sysman_kmd_interface_tests_i915_prelim.cpp
index 0c111f62dd..d2d4bb6d8c 100644
--- a/level_zero/sysman/test/unit_tests/sources/shared/linux/sysman_kmd_interface_tests_i915_prelim.cpp
+++ b/level_zero/sysman/test/unit_tests/sources/shared/linux/sysman_kmd_interface_tests_i915_prelim.cpp
@@ -107,6 +107,13 @@ TEST_F(SysmanFixtureDeviceI915Prelim, GivenSysmanKmdInterfaceInstanceWhenCalling
     EXPECT_EQ(0u, pSysmanKmdInterface->getEventType(true));
 }
 
+TEST_F(SysmanFixtureDeviceI915Prelim, GivenSysmanKmdInterfaceInstanceWhenCheckingAvailabilityOfFrequencyFilesThenTrueValueIsReturned) {
+    auto pSysmanKmdInterface = pLinuxSysmanImp->getSysmanKmdInterface();
+    EXPECT_TRUE(pSysmanKmdInterface->isDefaultFrequencyAvailable());
+    EXPECT_TRUE(pSysmanKmdInterface->isBoostFrequencyAvailable());
+    EXPECT_TRUE(pSysmanKmdInterface->isTdpFrequencyAvailable());
+}
+
 TEST_F(SysmanFixtureDeviceI915Prelim, GivenSysmanKmdInterfaceInstanceWhenCallingGetEngineClassStringThenInvalidValueIsReturned) {
     auto pSysmanKmdInterface = pLinuxSysmanImp->getSysmanKmdInterface();
     EXPECT_EQ(std::nullopt, pSysmanKmdInterface->getEngineClassString(EngineClass::ENGINE_CLASS_COMPUTE));
diff --git a/level_zero/sysman/test/unit_tests/sources/shared/linux/sysman_kmd_interface_tests_i915_upstream.cpp b/level_zero/sysman/test/unit_tests/sources/shared/linux/sysman_kmd_interface_tests_i915_upstream.cpp
index d6c3b44b1c..2829393697 100644
--- a/level_zero/sysman/test/unit_tests/sources/shared/linux/sysman_kmd_interface_tests_i915_upstream.cpp
+++ b/level_zero/sysman/test/unit_tests/sources/shared/linux/sysman_kmd_interface_tests_i915_upstream.cpp
@@ -145,6 +145,13 @@ TEST_F(SysmanFixtureDeviceI915Upstream, GivenSysmanKmdInterfaceInstanceWhenCheck
     EXPECT_FALSE(pSysmanKmdInterface->isSystemPowerBalanceAvailable());
 }
 
+TEST_F(SysmanFixtureDeviceI915Upstream, GivenSysmanKmdInterfaceInstanceWhenCheckingAvailabilityOfFrequencyFilesThenTrueValueIsReturned) {
+    auto pSysmanKmdInterface = pLinuxSysmanImp->pSysmanKmdInterface.get();
+    EXPECT_TRUE(pSysmanKmdInterface->isDefaultFrequencyAvailable());
+    EXPECT_TRUE(pSysmanKmdInterface->isBoostFrequencyAvailable());
+    EXPECT_TRUE(pSysmanKmdInterface->isTdpFrequencyAvailable());
+}
+
 TEST_F(SysmanFixtureDeviceI915Upstream, GivenSysmanKmdInterfaceInstanceWhenCallingGetNativeUnitWithProperSysfsNameThenValidValuesAreReturned) {
     auto pSysmanKmdInterface = pLinuxSysmanImp->getSysmanKmdInterface();
     EXPECT_EQ(SysmanKmdInterface::SysfsValueUnit::milliSecond, pSysmanKmdInterface->getNativeUnit(SysfsName::sysfsNameSchedulerTimeout));
diff --git a/level_zero/sysman/test/unit_tests/sources/shared/linux/sysman_kmd_interface_tests_xe.cpp b/level_zero/sysman/test/unit_tests/sources/shared/linux/sysman_kmd_interface_tests_xe.cpp
index a59045ba05..4f6e56190f 100644
--- a/level_zero/sysman/test/unit_tests/sources/shared/linux/sysman_kmd_interface_tests_xe.cpp
+++ b/level_zero/sysman/test/unit_tests/sources/shared/linux/sysman_kmd_interface_tests_xe.cpp
@@ -77,22 +77,18 @@ class SysmanFixtureDeviceXe : public SysmanDeviceFixture {
 TEST_F(SysmanFixtureDeviceXe, GivenSysmanKmdInterfaceWhenGettingSysfsFileNamesThenProperPathsAreReturned) {
     auto pSysmanKmdInterface = pLinuxSysmanImp->pSysmanKmdInterface.get();
     bool baseDirectoryExists = true;
-    EXPECT_STREQ("device/tile0/gt0/rps_min_freq_mhz", pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameMinFrequency, 0, baseDirectoryExists).c_str());
-    EXPECT_STREQ("device/tile0/gt0/rps_max_freq_mhz", pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameMaxFrequency, 0, baseDirectoryExists).c_str());
-    EXPECT_STREQ("device/tile0/gt0/.defaults/rps_min_freq_mhz", pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameMinDefaultFrequency, 0, baseDirectoryExists).c_str());
-    EXPECT_STREQ("device/tile0/gt0/.defaults/rps_max_freq_mhz", pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameMaxDefaultFrequency, 0, baseDirectoryExists).c_str());
-    EXPECT_STREQ("device/tile0/gt0/rps_boost_freq_mhz", pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameBoostFrequency, 0, baseDirectoryExists).c_str());
-    EXPECT_STREQ("device/tile0/gt0/punit_req_freq_mhz", pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameCurrentFrequency, 0, baseDirectoryExists).c_str());
-    EXPECT_STREQ("device/tile0/gt0/rapl_PL1_freq_mhz", pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameTdpFrequency, 0, baseDirectoryExists).c_str());
-    EXPECT_STREQ("device/tile0/gt0/rps_act_freq_mhz", pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameActualFrequency, 0, baseDirectoryExists).c_str());
-    EXPECT_STREQ("device/tile0/gt0/rps_RP1_freq_mhz", pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameEfficientFrequency, 0, baseDirectoryExists).c_str());
-    EXPECT_STREQ("device/tile0/gt0/rps_RP0_freq_mhz", pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameMaxValueFrequency, 0, baseDirectoryExists).c_str());
-    EXPECT_STREQ("device/tile0/gt0/rps_RPn_freq_mhz", pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameMinValueFrequency, 0, baseDirectoryExists).c_str());
-    EXPECT_STREQ("device/tile0/gt0/throttle_reason_status", pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameThrottleReasonStatus, 0, baseDirectoryExists).c_str());
-    EXPECT_STREQ("device/tile0/gt0/throttle_reason_pl1", pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameThrottleReasonPL1, 0, baseDirectoryExists).c_str());
-    EXPECT_STREQ("device/tile0/gt0/throttle_reason_pl2", pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameThrottleReasonPL2, 0, baseDirectoryExists).c_str());
-    EXPECT_STREQ("device/tile0/gt0/throttle_reason_pl4", pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameThrottleReasonPL4, 0, baseDirectoryExists).c_str());
-    EXPECT_STREQ("device/tile0/gt0/throttle_reason_thermal", pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameThrottleReasonThermal, 0, baseDirectoryExists).c_str());
+    EXPECT_STREQ("device/tile0/gt0/freq0/min_freq", pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameMinFrequency, 0, baseDirectoryExists).c_str());
+    EXPECT_STREQ("device/tile0/gt0/freq0/max_freq", pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameMaxFrequency, 0, baseDirectoryExists).c_str());
+    EXPECT_STREQ("device/tile0/gt0/freq0/cur_freq", pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameCurrentFrequency, 0, baseDirectoryExists).c_str());
+    EXPECT_STREQ("device/tile0/gt0/freq0/act_freq", pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameActualFrequency, 0, baseDirectoryExists).c_str());
+    EXPECT_STREQ("device/tile0/gt0/freq0/rpe_freq", pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameEfficientFrequency, 0, baseDirectoryExists).c_str());
+    EXPECT_STREQ("device/tile0/gt0/freq0/rp0_freq", pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameMaxValueFrequency, 0, baseDirectoryExists).c_str());
+    EXPECT_STREQ("device/tile0/gt0/freq0/rpn_freq", pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameMinValueFrequency, 0, baseDirectoryExists).c_str());
+    EXPECT_STREQ("device/tile0/gt0/freq0/throttle/status", pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameThrottleReasonStatus, 0, baseDirectoryExists).c_str());
+    EXPECT_STREQ("device/tile0/gt0/freq0/throttle/reason_pl1", pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameThrottleReasonPL1, 0, baseDirectoryExists).c_str());
+    EXPECT_STREQ("device/tile0/gt0/freq0/throttle/reason_pl2", pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameThrottleReasonPL2, 0, baseDirectoryExists).c_str());
+    EXPECT_STREQ("device/tile0/gt0/freq0/throttle/reason_pl4", pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameThrottleReasonPL4, 0, baseDirectoryExists).c_str());
+    EXPECT_STREQ("device/tile0/gt0/freq0/throttle/reason_thermal", pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameThrottleReasonThermal, 0, baseDirectoryExists).c_str());
     EXPECT_STREQ("device/tile0/physical_vram_size_bytes", pSysmanKmdInterface->getSysfsFilePathForPhysicalMemorySize(0).c_str());
     EXPECT_STREQ("device/tile0/gt0/freq_vram_rp0", pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameMaxMemoryFrequency, 0, baseDirectoryExists).c_str());
     EXPECT_STREQ("device/tile0/gt0/freq_vram_rpn", pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameMinMemoryFrequency, 0, baseDirectoryExists).c_str());
@@ -131,6 +127,13 @@ TEST_F(SysmanFixtureDeviceXe, GivenSysmanKmdInterfaceInstanceWhenCheckingAvailab
     EXPECT_TRUE(pSysmanKmdInterface->isSystemPowerBalanceAvailable());
 }
 
+TEST_F(SysmanFixtureDeviceXe, GivenSysmanKmdInterfaceInstanceWhenCheckingAvailabilityOfFrequencyFilesThenFalseValueIsReturned) {
+    auto pSysmanKmdInterface = pLinuxSysmanImp->pSysmanKmdInterface.get();
+    EXPECT_FALSE(pSysmanKmdInterface->isDefaultFrequencyAvailable());
+    EXPECT_FALSE(pSysmanKmdInterface->isBoostFrequencyAvailable());
+    EXPECT_FALSE(pSysmanKmdInterface->isTdpFrequencyAvailable());
+}
+
 TEST_F(SysmanFixtureDeviceXe, GivenSysmanKmdInterfaceInstanceWhenCallingGetNativeUnitWithProperSysfsNameThenValidValuesAreReturned) {
     auto pSysmanKmdInterface = pLinuxSysmanImp->getSysmanKmdInterface();
     EXPECT_EQ(SysmanKmdInterface::SysfsValueUnit::microSecond, pSysmanKmdInterface->getNativeUnit(SysfsName::sysfsNameSchedulerTimeout));