diff --git a/level_zero/sysman/source/memory/linux/sysman_os_memory_imp_prelim.cpp b/level_zero/sysman/source/memory/linux/sysman_os_memory_imp_prelim.cpp
index 08ee1795bf..3c72b4106b 100644
--- a/level_zero/sysman/source/memory/linux/sysman_os_memory_imp_prelim.cpp
+++ b/level_zero/sysman/source/memory/linux/sysman_os_memory_imp_prelim.cpp
@@ -17,6 +17,7 @@
 
 #include "level_zero/sysman/source/firmware_util/sysman_firmware_util.h"
 #include "level_zero/sysman/source/linux/zes_os_sysman_imp.h"
+#include "level_zero/sysman/source/shared/linux/sysman_kmd_interface.h"
 #include "level_zero/sysman/source/sysman_const.h"
 
 #include "drm/intel_hwconfig_types.h"
@@ -33,6 +34,7 @@ LinuxMemoryImp::LinuxMemoryImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint3
     pDevice = pLinuxSysmanImp->getSysmanDeviceImp();
     pSysfsAccess = &pLinuxSysmanImp->getSysfsAccess();
     pPmt = pLinuxSysmanImp->getPlatformMonitoringTechAccess(subdeviceId);
+    pSysmanKmdInterface = pLinuxSysmanImp->getSysmanKmdInterface();
 }
 
 bool LinuxMemoryImp::isMemoryModuleSupported() {
@@ -78,7 +80,7 @@ ze_result_t LinuxMemoryImp::getProperties(zes_mem_properties_t *pProperties) {
     pProperties->physicalSize = 0;
     if (isSubdevice) {
         std::string memval;
-        physicalSizeFile = pDrm->getIoctlHelper()->getFileForMemoryAddrRange(subdeviceId);
+        physicalSizeFile = pSysmanKmdInterface->getSysfsFilePathForPhysicalMemorySize(subdeviceId);
         ze_result_t result = pSysfsAccess->read(physicalSizeFile, memval);
         uint64_t intval = strtoull(memval.c_str(), nullptr, 16);
         if (ZE_RESULT_SUCCESS != result) {
@@ -157,7 +159,7 @@ void LinuxMemoryImp::getHbmFrequency(PRODUCT_FAMILY productFamily, unsigned shor
     hbmFrequency = 0;
     if (productFamily == IGFX_PVC) {
         if (stepping >= REVISION_B) {
-            const std::string hbmRP0FreqFile = pDrm->getIoctlHelper()->getFileForMaxMemoryFrequencyOfSubDevice(subdeviceId);
+            const std::string hbmRP0FreqFile = pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameMaxMemoryFrequency, subdeviceId, true);
             uint64_t hbmFreqValue = 0;
             ze_result_t result = pSysfsAccess->read(hbmRP0FreqFile, hbmFreqValue);
             if (ZE_RESULT_SUCCESS == result) {
diff --git a/level_zero/sysman/source/memory/linux/sysman_os_memory_imp_prelim.h b/level_zero/sysman/source/memory/linux/sysman_os_memory_imp_prelim.h
index ac0872bb94..802c7a93c1 100644
--- a/level_zero/sysman/source/memory/linux/sysman_os_memory_imp_prelim.h
+++ b/level_zero/sysman/source/memory/linux/sysman_os_memory_imp_prelim.h
@@ -23,6 +23,8 @@ class SysfsAccess;
 struct Device;
 class PlatformMonitoringTech;
 class LinuxSysmanImp;
+class SysmanKmdInterface;
+
 class LinuxMemoryImp : public OsMemory, NEO::NonCopyableOrMovableClass {
   public:
     ze_result_t getProperties(zes_mem_properties_t *pProperties) override;
@@ -39,6 +41,7 @@ class LinuxMemoryImp : public OsMemory, NEO::NonCopyableOrMovableClass {
     NEO::Drm *pDrm = nullptr;
     SysmanDeviceImp *pDevice = nullptr;
     PlatformMonitoringTech *pPmt = nullptr;
+    SysmanKmdInterface *pSysmanKmdInterface = nullptr;
     void getHbmFrequency(PRODUCT_FAMILY productFamily, unsigned short stepping, uint64_t &hbmFrequency);
 
   private:
diff --git a/level_zero/sysman/source/shared/linux/sysman_kmd_interface.cpp b/level_zero/sysman/source/shared/linux/sysman_kmd_interface.cpp
index 2f80fc2dbb..3155ab5eb7 100644
--- a/level_zero/sysman/source/shared/linux/sysman_kmd_interface.cpp
+++ b/level_zero/sysman/source/shared/linux/sysman_kmd_interface.cpp
@@ -63,6 +63,9 @@ void SysmanKmdInterfaceI915::initSysfsNameToFileMap(const PRODUCT_FAMILY product
     sysfsNameToFileMap[SysfsName::sysfsNameDefaultPowerLimit] = std::make_pair("", "power1_rated_max");
     sysfsNameToFileMap[SysfsName::sysfsNameCriticalPowerLimit] = std::make_pair("", (productFamily == IGFX_PVC) ? "curr1_crit" : "power1_crit");
     sysfsNameToFileMap[SysfsName::sysfsNameStandbyModeControl] = std::make_pair("rc6_enable", "power/rc6_enable");
+    sysfsNameToFileMap[SysfsName::sysfsNameMemoryAddressRange] = std::make_pair("addr_range", "");
+    sysfsNameToFileMap[SysfsName::sysfsNameMaxMemoryFrequency] = std::make_pair("mem_RP0_freq_mhz", "");
+    sysfsNameToFileMap[SysfsName::sysfsNameMinMemoryFrequency] = std::make_pair("mem_RPn_freq_mhz", "");
 }
 
 void SysmanKmdInterfaceXe::initSysfsNameToFileMap(const PRODUCT_FAMILY productFamily) {
@@ -87,6 +90,9 @@ void SysmanKmdInterfaceXe::initSysfsNameToFileMap(const PRODUCT_FAMILY productFa
     sysfsNameToFileMap[SysfsName::sysfsNameEnergyCounterNode] = std::make_pair("", "energy1_input");
     sysfsNameToFileMap[SysfsName::sysfsNameDefaultPowerLimit] = std::make_pair("", "power1_rated_max");
     sysfsNameToFileMap[SysfsName::sysfsNameCriticalPowerLimit] = std::make_pair("", (productFamily == IGFX_PVC) ? "curr1_crit" : "power1_crit");
+    sysfsNameToFileMap[SysfsName::sysfsNameMemoryAddressRange] = std::make_pair("physical_vram_size_bytes", "");
+    sysfsNameToFileMap[SysfsName::sysfsNameMaxMemoryFrequency] = std::make_pair("freq_vram_rp0", "");
+    sysfsNameToFileMap[SysfsName::sysfsNameMinMemoryFrequency] = std::make_pair("freq_vram_rpn", "");
 }
 
 std::string SysmanKmdInterfaceI915::getSysfsFilePath(SysfsName sysfsName, uint32_t subDeviceId, bool baseDirectoryExists) {
@@ -99,6 +105,18 @@ std::string SysmanKmdInterfaceXe::getSysfsFilePath(SysfsName sysfsName, uint32_t
     return filePath;
 }
 
+std::string SysmanKmdInterfaceI915::getSysfsFilePathForPhysicalMemorySize(uint32_t subDeviceId) {
+    std::string filePathPhysicalMemorySize = getBasePath(subDeviceId) +
+                                             sysfsNameToFileMap[SysfsName::sysfsNameMemoryAddressRange].first;
+    return filePathPhysicalMemorySize;
+}
+
+std::string SysmanKmdInterfaceXe::getSysfsFilePathForPhysicalMemorySize(uint32_t subDeviceId) {
+    std::string filePathPhysicalMemorySize = "device/tile" + std::to_string(subDeviceId) + "/" +
+                                             sysfsNameToFileMap[SysfsName::sysfsNameMemoryAddressRange].first;
+    return filePathPhysicalMemorySize;
+}
+
 int64_t SysmanKmdInterfaceI915::getEngineActivityFd(zes_engine_group_t engineGroup, uint32_t engineInstance, uint32_t subDeviceId, PmuInterface *const &pPmuInterface) {
     uint64_t config = UINT64_MAX;
     switch (engineGroup) {
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 cedf52fb46..f40f2bbbe4 100644
--- a/level_zero/sysman/source/shared/linux/sysman_kmd_interface.h
+++ b/level_zero/sysman/source/shared/linux/sysman_kmd_interface.h
@@ -72,6 +72,9 @@ enum class SysfsName {
     sysfsNameDefaultPowerLimit,
     sysfsNameCriticalPowerLimit,
     sysfsNameStandbyModeControl,
+    sysfsNameMemoryAddressRange,
+    sysfsNameMaxMemoryFrequency,
+    sysfsNameMinMemoryFrequency,
 };
 
 class SysmanKmdInterface {
@@ -81,6 +84,7 @@ class SysmanKmdInterface {
 
     virtual std::string getBasePath(uint32_t subDeviceId) const = 0;
     virtual std::string getSysfsFilePath(SysfsName sysfsName, uint32_t subDeviceId, bool baseDirectoryExists) = 0;
+    virtual std::string getSysfsFilePathForPhysicalMemorySize(uint32_t subDeviceId) = 0;
     virtual int64_t getEngineActivityFd(zes_engine_group_t engineGroup, uint32_t engineInstance, uint32_t subDeviceId, PmuInterface *const &pmuInterface) = 0;
     virtual std::string getHwmonName(uint32_t subDeviceId, bool isSubdevice) const = 0;
     virtual bool isStandbyModeControlAvailable() const = 0;
@@ -93,6 +97,7 @@ class SysmanKmdInterfaceI915 : public SysmanKmdInterface {
 
     std::string getBasePath(uint32_t subDeviceId) const override;
     std::string getSysfsFilePath(SysfsName sysfsName, uint32_t subDeviceId, bool baseDirectoryExists) override;
+    std::string getSysfsFilePathForPhysicalMemorySize(uint32_t subDeviceId) override;
     int64_t getEngineActivityFd(zes_engine_group_t engineGroup, uint32_t engineInstance, uint32_t subDeviceId, PmuInterface *const &pmuInterface) override;
     std::string getHwmonName(uint32_t subDeviceId, bool isSubdevice) const override;
     bool isStandbyModeControlAvailable() const override { return true; }
@@ -109,6 +114,7 @@ class SysmanKmdInterfaceXe : public SysmanKmdInterface {
 
     std::string getBasePath(uint32_t subDeviceId) const override;
     std::string getSysfsFilePath(SysfsName sysfsName, uint32_t subDeviceId, bool baseDirectoryExists) override;
+    std::string getSysfsFilePathForPhysicalMemorySize(uint32_t subDeviceId) override;
     int64_t getEngineActivityFd(zes_engine_group_t engineGroup, uint32_t engineInstance, uint32_t subDeviceId, PmuInterface *const &pmuInterface) override;
     std::string getHwmonName(uint32_t subDeviceId, bool isSubdevice) const override;
     bool isStandbyModeControlAvailable() const override { return false; }
diff --git a/level_zero/sysman/test/unit_tests/sources/memory/linux/test_sysman_memory_prelim.cpp b/level_zero/sysman/test/unit_tests/sources/memory/linux/test_sysman_memory_prelim.cpp
index cf6b2aeb97..ec2ad10e65 100644
--- a/level_zero/sysman/test/unit_tests/sources/memory/linux/test_sysman_memory_prelim.cpp
+++ b/level_zero/sysman/test/unit_tests/sources/memory/linux/test_sysman_memory_prelim.cpp
@@ -11,6 +11,7 @@
 
 #include "level_zero/sysman/source/linux/pmt/sysman_pmt_xml_offsets.h"
 #include "level_zero/sysman/source/memory/linux/sysman_os_memory_imp_prelim.h"
+#include "level_zero/sysman/source/shared/linux/sysman_kmd_interface.h"
 #include "level_zero/sysman/source/sysman_const.h"
 #include "level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_fixture.h"
 #include "level_zero/sysman/test/unit_tests/sources/memory/linux/mock_memory_prelim.h"
@@ -97,6 +98,20 @@ class SysmanDeviceMemoryFixture : public SysmanDeviceFixture {
     }
 };
 
+TEST_F(SysmanDeviceMemoryFixture, GivenKmdInterfaceWhenGettingSysfsFileNamesForI915VersionThenProperPathsAreReturned) {
+    auto pSysmanKmdInterface = std::make_unique<SysmanKmdInterfaceI915>(productFamily);
+    EXPECT_STREQ("gt/gt0/addr_range", pSysmanKmdInterface->getSysfsFilePathForPhysicalMemorySize(0).c_str());
+    EXPECT_STREQ("gt/gt0/mem_RP0_freq_mhz", pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameMaxMemoryFrequency, 0, true).c_str());
+    EXPECT_STREQ("gt/gt0/mem_RPn_freq_mhz", pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameMinMemoryFrequency, 0, true).c_str());
+}
+
+TEST_F(SysmanDeviceMemoryFixture, GivenKmdInterfaceWhenGettingSysfsFileNamesForXeVersionThenProperPathsAreReturned) {
+    auto pSysmanKmdInterface = std::make_unique<SysmanKmdInterfaceXe>(productFamily);
+    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, true).c_str());
+    EXPECT_STREQ("device/tile0/gt0/freq_vram_rpn", pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameMinMemoryFrequency, 0, true).c_str());
+}
+
 TEST_F(SysmanDeviceMemoryFixture, GivenComponentCountZeroWhenEnumeratingMemoryModulesWithLocalMemorySupportThenValidCountIsReturned) {
     setLocalSupportedAndReinit(true);
 
diff --git a/level_zero/tools/source/sysman/memory/linux/os_memory_imp_prelim.cpp b/level_zero/tools/source/sysman/memory/linux/os_memory_imp_prelim.cpp
index fc650f8d1d..1eb81ba81c 100644
--- a/level_zero/tools/source/sysman/memory/linux/os_memory_imp_prelim.cpp
+++ b/level_zero/tools/source/sysman/memory/linux/os_memory_imp_prelim.cpp
@@ -34,12 +34,20 @@ void memoryGetTimeStamp(uint64_t &timestamp) {
     timestamp = std::chrono::duration_cast<std::chrono::microseconds>(ts.time_since_epoch()).count();
 }
 
+void LinuxMemoryImp::init() {
+    if (isSubdevice) {
+        const std::string baseDir = "gt/gt" + std::to_string(subdeviceId) + "/";
+        physicalSizeFile = baseDir + "addr_range";
+    }
+}
+
 LinuxMemoryImp::LinuxMemoryImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId) : isSubdevice(onSubdevice), subdeviceId(subdeviceId) {
     pLinuxSysmanImp = static_cast<LinuxSysmanImp *>(pOsSysman);
     pDrm = &pLinuxSysmanImp->getDrm();
     pDevice = pLinuxSysmanImp->getDeviceHandle();
     pSysfsAccess = &pLinuxSysmanImp->getSysfsAccess();
     pPmt = pLinuxSysmanImp->getPlatformMonitoringTechAccess(subdeviceId);
+    init();
 }
 
 bool LinuxMemoryImp::isMemoryModuleSupported() {
@@ -79,7 +87,6 @@ ze_result_t LinuxMemoryImp::getProperties(zes_mem_properties_t *pProperties) {
     pProperties->physicalSize = 0;
     if (isSubdevice) {
         std::string memval;
-        physicalSizeFile = pDrm->getIoctlHelper()->getFileForMemoryAddrRange(subdeviceId);
         ze_result_t result = pSysfsAccess->read(physicalSizeFile, memval);
         uint64_t intval = strtoull(memval.c_str(), nullptr, 16);
         if (ZE_RESULT_SUCCESS != result) {
@@ -158,7 +165,9 @@ void LinuxMemoryImp::getHbmFrequency(PRODUCT_FAMILY productFamily, unsigned shor
     hbmFrequency = 0;
     if (productFamily == IGFX_PVC) {
         if (stepping >= REVISION_B) {
-            const std::string hbmRP0FreqFile = pDrm->getIoctlHelper()->getFileForMaxMemoryFrequencyOfSubDevice(subdeviceId);
+            const std::string baseDir = "gt/gt" + std::to_string(subdeviceId) + "/";
+            // Calculating bandwidth based on HBM max frequency
+            const std::string hbmRP0FreqFile = baseDir + "mem_RP0_freq_mhz";
             uint64_t hbmFreqValue = 0;
             ze_result_t result = pSysfsAccess->read(hbmRP0FreqFile, hbmFreqValue);
             if (ZE_RESULT_SUCCESS == result) {
diff --git a/level_zero/tools/source/sysman/memory/linux/os_memory_imp_prelim.h b/level_zero/tools/source/sysman/memory/linux/os_memory_imp_prelim.h
index cfeac5cc4f..d122997311 100644
--- a/level_zero/tools/source/sysman/memory/linux/os_memory_imp_prelim.h
+++ b/level_zero/tools/source/sysman/memory/linux/os_memory_imp_prelim.h
@@ -45,6 +45,7 @@ class LinuxMemoryImp : public OsMemory, NEO::NonCopyableOrMovableClass {
     ze_result_t getHbmBandwidth(uint32_t numHbmModules, zes_mem_bandwidth_t *pBandwidth);
     ze_result_t getHbmBandwidthPVC(uint32_t numHbmModules, zes_mem_bandwidth_t *pBandwidth);
     ze_result_t getHbmBandwidthEx(uint32_t numHbmModules, uint32_t counterMaxValue, uint64_t *pReadCounters, uint64_t *pWriteCounters, uint64_t *pMaxBandwidth, uint64_t timeout);
+    void init();
     static const std::string deviceMemoryHealth;
     bool isSubdevice = false;
     uint32_t subdeviceId = 0;
diff --git a/level_zero/tools/test/unit_tests/sources/sysman/memory/linux/test_sysman_memory_prelim.cpp b/level_zero/tools/test/unit_tests/sources/sysman/memory/linux/test_sysman_memory_prelim.cpp
index 2a7f98a03a..4ae288f2de 100644
--- a/level_zero/tools/test/unit_tests/sources/sysman/memory/linux/test_sysman_memory_prelim.cpp
+++ b/level_zero/tools/test/unit_tests/sources/sysman/memory/linux/test_sysman_memory_prelim.cpp
@@ -138,6 +138,12 @@ class SysmanDeviceMemoryFixture : public SysmanDeviceFixture {
     MemoryManager *pMemoryManagerOld;
 };
 
+TEST_F(SysmanDeviceMemoryFixture, GivenWhenGettingMemoryPropertiesThenSuccessIsReturned) {
+    zes_mem_properties_t properties = {};
+    auto pLinuxMemoryImp = std::make_unique<LinuxMemoryImp>(pOsSysman, true, 0);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, pLinuxMemoryImp->getProperties(&properties));
+}
+
 TEST_F(SysmanDeviceMemoryFixture, GivenComponentCountZeroWhenEnumeratingMemoryModulesWithLocalMemorySupportThenValidCountIsReturned) {
     setLocalSupportedAndReinit(true);
 
diff --git a/shared/source/os_interface/linux/ioctl_helper.cpp b/shared/source/os_interface/linux/ioctl_helper.cpp
index 24b5bb49ac..00b6647c50 100644
--- a/shared/source/os_interface/linux/ioctl_helper.cpp
+++ b/shared/source/os_interface/linux/ioctl_helper.cpp
@@ -387,10 +387,6 @@ std::string IoctlHelper::getFileForMaxMemoryFrequencyOfSubDevice(int subDeviceId
     return "/gt/gt" + std::to_string(subDeviceId) + "/mem_RP0_freq_mhz";
 }
 
-std::string IoctlHelper::getFileForMemoryAddrRange(int subDeviceId) const {
-    return "gt/gt" + std::to_string(subDeviceId) + "/addr_range";
-}
-
 bool IoctlHelper::checkIfIoctlReinvokeRequired(int error, DrmIoctl ioctlRequest) const {
     return (error == EINTR || error == EAGAIN || error == EBUSY || error == -EBUSY);
 }
diff --git a/shared/source/os_interface/linux/ioctl_helper.h b/shared/source/os_interface/linux/ioctl_helper.h
index ec4c0303fb..b6d1b04e9e 100644
--- a/shared/source/os_interface/linux/ioctl_helper.h
+++ b/shared/source/os_interface/linux/ioctl_helper.h
@@ -145,7 +145,6 @@ class IoctlHelper {
     virtual std::string getFileForMaxGpuFrequency() const;
     virtual std::string getFileForMaxGpuFrequencyOfSubDevice(int subDeviceId) const;
     virtual std::string getFileForMaxMemoryFrequencyOfSubDevice(int subDeviceId) const;
-    virtual std::string getFileForMemoryAddrRange(int subdeviceId) const;
     virtual bool getFabricLatency(uint32_t fabricId, uint32_t &latency, uint32_t &bandwidth) = 0;
     virtual bool isWaitBeforeBindRequired(bool bind) const = 0;
     virtual void *pciBarrierMmap() { return nullptr; };
diff --git a/shared/source/os_interface/linux/xe/ioctl_helper_xe.cpp b/shared/source/os_interface/linux/xe/ioctl_helper_xe.cpp
index d9db55b7e3..0c2b5479ff 100644
--- a/shared/source/os_interface/linux/xe/ioctl_helper_xe.cpp
+++ b/shared/source/os_interface/linux/xe/ioctl_helper_xe.cpp
@@ -1423,10 +1423,6 @@ std::string IoctlHelperXe::getFileForMaxMemoryFrequencyOfSubDevice(int subDevice
     return "/device/gt" + std::to_string(subDeviceId) + "/freq_rp0";
 }
 
-std::string IoctlHelperXe::getFileForMemoryAddrRange(int subDeviceId) const {
-    return "device/tile" + std::to_string(subDeviceId) + "/addr_range";
-}
-
 struct drm_xe_engine_class_instance *
 IoctlHelperXe::xeFindMatchingEngine(uint16_t engineClass, uint16_t engineInstance) {
     for (auto &engine : allEngines) {
diff --git a/shared/source/os_interface/linux/xe/ioctl_helper_xe.h b/shared/source/os_interface/linux/xe/ioctl_helper_xe.h
index 35c533ec73..90df0ea2b4 100644
--- a/shared/source/os_interface/linux/xe/ioctl_helper_xe.h
+++ b/shared/source/os_interface/linux/xe/ioctl_helper_xe.h
@@ -96,7 +96,6 @@ class IoctlHelperXe : public IoctlHelper {
     std::string getFileForMaxGpuFrequency() const override;
     std::string getFileForMaxGpuFrequencyOfSubDevice(int subDeviceId) const override;
     std::string getFileForMaxMemoryFrequencyOfSubDevice(int subDeviceId) const override;
-    std::string getFileForMemoryAddrRange(int subdeviceId) const override;
     bool getFabricLatency(uint32_t fabricId, uint32_t &latency, uint32_t &bandwidth) override;
     bool isWaitBeforeBindRequired(bool bind) const override;
     std::unique_ptr<EngineInfo> createEngineInfo(bool isSysmanEnabled) override;
diff --git a/shared/test/unit_test/os_interface/linux/drm_tests.cpp b/shared/test/unit_test/os_interface/linux/drm_tests.cpp
index f9dd24a819..e1dc77c6db 100644
--- a/shared/test/unit_test/os_interface/linux/drm_tests.cpp
+++ b/shared/test/unit_test/os_interface/linux/drm_tests.cpp
@@ -1563,13 +1563,6 @@ TEST(IoctlHelperTest, whenGettingFileNameForFrequencyFilesThenProperStringIsRetu
     EXPECT_STREQ("/gt/gt1/mem_RP0_freq_mhz", ioctlHelper->getFileForMaxMemoryFrequencyOfSubDevice(1).c_str());
 }
 
-TEST(IoctlHelperTest, whenGettingFileNameForMemoryAddrRangeThenProperStringIsReturned) {
-    auto executionEnvironment = std::make_unique<MockExecutionEnvironment>();
-    DrmMock drm{*executionEnvironment->rootDeviceEnvironments[0]};
-    auto ioctlHelper = drm.getIoctlHelper();
-    EXPECT_STREQ("gt/gt0/addr_range", ioctlHelper->getFileForMemoryAddrRange(0).c_str());
-}
-
 TEST(DistanceInfoTest, givenDistanceInfosWhenAssignRegionsFromDistancesThenCorrectRegionsSet) {
     auto executionEnvironment = std::make_unique<MockExecutionEnvironment>();
     DrmMock drm{*executionEnvironment->rootDeviceEnvironments[0]};
diff --git a/shared/test/unit_test/os_interface/linux/xe/ioctl_helper_xe_tests.cpp b/shared/test/unit_test/os_interface/linux/xe/ioctl_helper_xe_tests.cpp
index 4409686d29..f251d37304 100644
--- a/shared/test/unit_test/os_interface/linux/xe/ioctl_helper_xe_tests.cpp
+++ b/shared/test/unit_test/os_interface/linux/xe/ioctl_helper_xe_tests.cpp
@@ -413,13 +413,6 @@ TEST(IoctlHelperXeTest, whenGettingFileNamesForFrequencyThenProperStringIsReturn
     EXPECT_STREQ("/device/gt1/freq_rp0", ioctlHelper->getFileForMaxMemoryFrequencyOfSubDevice(1).c_str());
 }
 
-TEST(IoctlHelperXeTest, whenGettingFileNameForMemoryAddrRangeThenProperStringIsReturned) {
-    auto executionEnvironment = std::make_unique<MockExecutionEnvironment>();
-    DrmMock drm{*executionEnvironment->rootDeviceEnvironments[0]};
-    auto ioctlHelper = std::make_unique<IoctlHelperXe>(drm);
-    EXPECT_STREQ("device/tile0/addr_range", ioctlHelper->getFileForMemoryAddrRange(0).c_str());
-}
-
 inline constexpr int testValueVmId = 0x5764;
 inline constexpr int testValueMapOff = 0x7788;
 inline constexpr int testValuePrime = 0x4321;