diff --git a/level_zero/tools/source/sysman/standby/linux/CMakeLists.txt b/level_zero/tools/source/sysman/standby/linux/CMakeLists.txt
index 5a82b234e2..d76013d1ef 100644
--- a/level_zero/tools/source/sysman/standby/linux/CMakeLists.txt
+++ b/level_zero/tools/source/sysman/standby/linux/CMakeLists.txt
@@ -6,7 +6,7 @@
 
 set(L0_SRCS_TOOLS_SYSMAN_STANDBY_LINUX
     ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
-    ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}/os_standby_imp.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/os_standby_imp.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/os_standby_imp.h
 )
 
diff --git a/level_zero/tools/source/sysman/standby/linux/os_standby_imp.cpp b/level_zero/tools/source/sysman/standby/linux/os_standby_imp.cpp
index 6355e05cda..3ebc84700c 100644
--- a/level_zero/tools/source/sysman/standby/linux/os_standby_imp.cpp
+++ b/level_zero/tools/source/sysman/standby/linux/os_standby_imp.cpp
@@ -47,12 +47,17 @@ ze_result_t LinuxStandbyImp::getMode(zes_standby_promo_mode_t &mode) {
 }
 
 ze_result_t LinuxStandbyImp::setMode(zes_standby_promo_mode_t mode) {
-    // standbyModeFile is not writable.
-    // Mode cannot be set from L0.
-    // To set the mode, user must reload
-    // the i915 module and set module parameter
-    // enable_rc6 appropriately.
-    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+    ze_result_t result = ZE_RESULT_ERROR_UNKNOWN;
+    if (ZES_STANDBY_PROMO_MODE_DEFAULT == mode) {
+        result = pSysfsAccess->write(standbyModeFile, standbyModeDefault);
+    } else {
+        result = pSysfsAccess->write(standbyModeFile, standbyModeNever);
+    }
+
+    if (ZE_RESULT_ERROR_NOT_AVAILABLE == result) {
+        result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+    }
+    return result;
 }
 
 LinuxStandbyImp::LinuxStandbyImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId) : isSubdevice(onSubdevice), subdeviceId(subdeviceId) {
diff --git a/level_zero/tools/test/unit_tests/sources/sysman/standby/linux/CMakeLists.txt b/level_zero/tools/test/unit_tests/sources/sysman/standby/linux/CMakeLists.txt
index e9bd5a459d..c8fbe4848c 100644
--- a/level_zero/tools/test/unit_tests/sources/sysman/standby/linux/CMakeLists.txt
+++ b/level_zero/tools/test/unit_tests/sources/sysman/standby/linux/CMakeLists.txt
@@ -1,5 +1,5 @@
 #
-# Copyright (C) 2020 Intel Corporation
+# Copyright (C) 2020-2021 Intel Corporation
 #
 # SPDX-License-Identifier: MIT
 #
@@ -8,8 +8,8 @@ if(UNIX)
   target_sources(${TARGET_NAME}
                  PRIVATE
                  ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
-                 ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}/mock_sysfs_standby.h
-                 ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}/test_zes_sysman_standby.cpp
+                 ${CMAKE_CURRENT_SOURCE_DIR}/mock_sysfs_standby.h
+                 ${CMAKE_CURRENT_SOURCE_DIR}/test_zes_sysman_standby.cpp
 
   )
 endif()
diff --git a/level_zero/tools/test/unit_tests/sources/sysman/standby/linux/mock_sysfs_standby.h b/level_zero/tools/test/unit_tests/sources/sysman/standby/linux/mock_sysfs_standby.h
index be314426c5..0ba9b9b8f9 100644
--- a/level_zero/tools/test/unit_tests/sources/sysman/standby/linux/mock_sysfs_standby.h
+++ b/level_zero/tools/test/unit_tests/sources/sysman/standby/linux/mock_sysfs_standby.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020 Intel Corporation
+ * Copyright (C) 2020-2021 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -19,33 +19,57 @@ class StandbySysfsAccess : public SysfsAccess {};
 template <>
 struct Mock<StandbySysfsAccess> : public StandbySysfsAccess {
     int mockStandbyMode = -1;
+    bool isStandbyModeFileAvailable = true;
+    ::mode_t mockStandbyFileMode = S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR;
     MOCK_METHOD(ze_result_t, read, (const std::string file, int &val), (override));
+    MOCK_METHOD(ze_result_t, write, (const std::string file, int val), (override));
     MOCK_METHOD(ze_result_t, canRead, (const std::string file), (override));
 
     ze_result_t getCanReadStatus(const std::string file) {
-        if (file.compare(standbyModeFile) == 0) {
+        if (isFileAccessible(file) == true) {
             return ZE_RESULT_SUCCESS;
         }
         return ZE_RESULT_ERROR_UNKNOWN;
     }
+
     ze_result_t getVal(const std::string file, int &val) {
-        if (file.compare(standbyModeFile) == 0) {
+        if ((isFileAccessible(file) == true) &&
+            (mockStandbyFileMode & S_IRUSR) != 0) {
             val = mockStandbyMode;
             return ZE_RESULT_SUCCESS;
         }
-        return ZE_RESULT_ERROR_NOT_AVAILABLE;
+
+        if (isStandbyModeFileAvailable == false) {
+            return ZE_RESULT_ERROR_NOT_AVAILABLE;
+        }
+
+        if ((mockStandbyFileMode & S_IRUSR) == 0) {
+            return ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS;
+        }
+
+        return ZE_RESULT_ERROR_UNKNOWN;
     }
 
     ze_result_t setVal(const std::string file, const int val) {
-        if (file.compare(standbyModeFile) == 0) {
+        if ((isFileAccessible(file) == true) &&
+            (mockStandbyFileMode & S_IWUSR) != 0) {
             mockStandbyMode = val;
             return ZE_RESULT_SUCCESS;
         }
-        return ZE_RESULT_ERROR_NOT_AVAILABLE;
+
+        if (isFileAccessible(file) == false) {
+            return ZE_RESULT_ERROR_NOT_AVAILABLE;
+        }
+
+        if ((mockStandbyFileMode & S_IWUSR) == 0) {
+            return ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS;
+        }
+
+        return ZE_RESULT_ERROR_UNKNOWN;
     }
 
     ze_result_t setValReturnError(const std::string file, const int val) {
-        if (file.compare(standbyModeFile) == 0) {
+        if (isFileAccessible(file) == true) {
             return ZE_RESULT_ERROR_NOT_AVAILABLE;
         }
         return ZE_RESULT_ERROR_NOT_AVAILABLE;
@@ -53,6 +77,14 @@ struct Mock<StandbySysfsAccess> : public StandbySysfsAccess {
 
     Mock() = default;
     ~Mock() override = default;
+
+  private:
+    bool isFileAccessible(const std::string file) {
+        if ((file.compare(standbyModeFile) == 0) && (isStandbyModeFileAvailable == true)) {
+            return true;
+        }
+        return false;
+    }
 };
 
 class PublicLinuxStandbyImp : public L0::LinuxStandbyImp {
diff --git a/level_zero/tools/test/unit_tests/sources/sysman/standby/linux/test_zes_sysman_standby.cpp b/level_zero/tools/test/unit_tests/sources/sysman/standby/linux/test_zes_sysman_standby.cpp
index 881bec79f9..1710ee0d58 100644
--- a/level_zero/tools/test/unit_tests/sources/sysman/standby/linux/test_zes_sysman_standby.cpp
+++ b/level_zero/tools/test/unit_tests/sources/sysman/standby/linux/test_zes_sysman_standby.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020 Intel Corporation
+ * Copyright (C) 2020-2021 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -34,6 +34,8 @@ class ZesStandbyFixture : public SysmanDeviceFixture {
         ptestSysfsAccess->setVal(standbyModeFile, standbyModeDefault);
         ON_CALL(*ptestSysfsAccess.get(), read(_, Matcher<int &>(_)))
             .WillByDefault(::testing::Invoke(ptestSysfsAccess.get(), &Mock<StandbySysfsAccess>::getVal));
+        ON_CALL(*ptestSysfsAccess.get(), write(_, Matcher<int>(_)))
+            .WillByDefault(::testing::Invoke(ptestSysfsAccess.get(), &Mock<StandbySysfsAccess>::setVal));
         ON_CALL(*ptestSysfsAccess.get(), canRead(_))
             .WillByDefault(::testing::Invoke(ptestSysfsAccess.get(), &Mock<StandbySysfsAccess>::getCanReadStatus));
         for (const auto &handle : pSysmanDeviceImp->pStandbyHandleContext->handleList) {
@@ -163,13 +165,80 @@ TEST_F(ZesStandbyFixture, GivenValidStandbyHandleWhenCallingzesStandbyGetModeThe
     }
 }
 
-TEST_F(ZesStandbyFixture, GivenValidStandbyHandleWhenCallingzesStandbySetModeThenVerifySysmanzesySetModeCallFailsWithUnsupported) {
+TEST_F(ZesStandbyFixture, GivenValidStandbyHandleWhenCallingzesStandbyGetModeOnUnavailableFileThenVerifyzesStandbyGetModeCallFailsForUnsupportedFeature) {
+    zes_standby_promo_mode_t mode = {};
+    ptestSysfsAccess->setVal(standbyModeFile, standbyModeInvalid);
     auto handles = get_standby_handles(mockHandleCount);
 
+    ptestSysfsAccess->isStandbyModeFileAvailable = false;
+
+    for (auto hSysmanStandby : handles) {
+        EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesStandbyGetMode(hSysmanStandby, &mode));
+    }
+}
+
+TEST_F(ZesStandbyFixture, GivenValidStandbyHandleWhenCallingzesStandbyGetModeWithInsufficientPermissionsThenVerifyzesStandbyGetModeCallFailsForInsufficientPermissions) {
+    zes_standby_promo_mode_t mode = {};
+    ptestSysfsAccess->setVal(standbyModeFile, standbyModeInvalid);
+    auto handles = get_standby_handles(mockHandleCount);
+
+    ptestSysfsAccess->mockStandbyFileMode &= ~S_IRUSR;
+
+    for (auto hSysmanStandby : handles) {
+        EXPECT_EQ(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS, zesStandbyGetMode(hSysmanStandby, &mode));
+    }
+}
+
+TEST_F(ZesStandbyFixture, GivenValidStandbyHandleWhenCallingzesStandbySetModeThenwithUnwritableFileVerifySysmanzesySetModeCallFailedWithInsufficientPermissions) {
+    auto handles = get_standby_handles(mockHandleCount);
+    ptestSysfsAccess->mockStandbyFileMode &= ~S_IWUSR;
+
+    for (auto hSysmanStandby : handles) {
+        EXPECT_EQ(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS, zesStandbySetMode(hSysmanStandby, ZES_STANDBY_PROMO_MODE_NEVER));
+    }
+}
+
+TEST_F(ZesStandbyFixture, GivenValidStandbyHandleWhenCallingzesStandbySetModeOnUnavailableFileThenVerifyzesStandbySetModeCallFailsForUnsupportedFeature) {
+    auto handles = get_standby_handles(mockHandleCount);
+
+    ptestSysfsAccess->isStandbyModeFileAvailable = false;
     for (auto hSysmanStandby : handles) {
         EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesStandbySetMode(hSysmanStandby, ZES_STANDBY_PROMO_MODE_NEVER));
     }
 }
+
+TEST_F(ZesStandbyFixture, GivenValidStandbyHandleWhenCallingzesStandbySetModeNeverThenVerifySysmanzesySetModeCallSucceeds) {
+    auto handles = get_standby_handles(mockHandleCount);
+
+    for (auto hSysmanStandby : handles) {
+        zes_standby_promo_mode_t mode;
+        ptestSysfsAccess->setVal(standbyModeFile, standbyModeDefault);
+        EXPECT_EQ(ZE_RESULT_SUCCESS, zesStandbyGetMode(hSysmanStandby, &mode));
+        EXPECT_EQ(ZES_STANDBY_PROMO_MODE_DEFAULT, mode);
+
+        EXPECT_EQ(ZE_RESULT_SUCCESS, zesStandbySetMode(hSysmanStandby, ZES_STANDBY_PROMO_MODE_NEVER));
+
+        EXPECT_EQ(ZE_RESULT_SUCCESS, zesStandbyGetMode(hSysmanStandby, &mode));
+        EXPECT_EQ(ZES_STANDBY_PROMO_MODE_NEVER, mode);
+    }
+}
+
+TEST_F(ZesStandbyFixture, GivenValidStandbyHandleWhenCallingzesStandbySetModeDefaultThenVerifySysmanzesySetModeCallSucceeds) {
+    auto handles = get_standby_handles(mockHandleCount);
+
+    for (auto hSysmanStandby : handles) {
+        zes_standby_promo_mode_t mode;
+        ptestSysfsAccess->setVal(standbyModeFile, standbyModeNever);
+        EXPECT_EQ(ZE_RESULT_SUCCESS, zesStandbyGetMode(hSysmanStandby, &mode));
+        EXPECT_EQ(ZES_STANDBY_PROMO_MODE_NEVER, mode);
+
+        EXPECT_EQ(ZE_RESULT_SUCCESS, zesStandbySetMode(hSysmanStandby, ZES_STANDBY_PROMO_MODE_DEFAULT));
+
+        EXPECT_EQ(ZE_RESULT_SUCCESS, zesStandbyGetMode(hSysmanStandby, &mode));
+        EXPECT_EQ(ZES_STANDBY_PROMO_MODE_DEFAULT, mode);
+    }
+}
+
 TEST_F(ZesStandbyFixture, GivenOnSubdeviceNotSetWhenValidatingosStandbyGetPropertiesThenSuccessIsReturned) {
     zes_standby_properties_t properties = {};
     ze_device_properties_t deviceProperties = {};
@@ -260,5 +329,6 @@ TEST_F(ZesStandbyMultiDeviceFixture, GivenOnSubdeviceNotSetWhenValidatingosStand
     EXPECT_EQ(properties.onSubdevice, isSubDevice);
     delete pLinuxStandbyImp;
 }
+
 } // namespace ult
 } // namespace L0