diff --git a/Redfish.md b/Redfish.md
index 238ac77..d09927f 100644
--- a/Redfish.md
+++ b/Redfish.md
@@ -454,6 +454,7 @@
   - EfficiencyPercent
 - FirmwareVersion
 - Location
+- LocationIndicatorActive
 - Manufacturer
 - Model
 - PartNumber
diff --git a/redfish-core/lib/led.hpp b/redfish-core/lib/led.hpp
index 2bb2cc8..e868bf3 100644
--- a/redfish-core/lib/led.hpp
+++ b/redfish-core/lib/led.hpp
@@ -11,13 +11,22 @@
 #include "logging.hpp"
 #include "utils/dbus_utils.hpp"
 
+#include <asm-generic/errno.h>
+
+#include <boost/system/error_code.hpp>
 #include <sdbusplus/asio/property.hpp>
 #include <sdbusplus/message/native_types.hpp>
 
+#include <array>
+#include <functional>
 #include <memory>
+#include <string_view>
+#include <utility>
 
 namespace redfish
 {
+static constexpr std::array<std::string_view, 1> ledGroupInterface = {
+    "xyz.openbmc_project.Led.Group"};
 /**
  * @brief Retrieves identify led group properties over dbus
  *
@@ -232,4 +241,185 @@
             }
         });
 }
+
+inline void handleLedGroupSubtree(
+    const std::string& objPath, const boost::system::error_code& ec,
+    const dbus::utility::MapperGetSubTreeResponse& subtree,
+    const std::function<void(const boost::system::error_code& ec,
+                             const std::string& ledGroupPath,
+                             const std::string& service)>& callback)
+{
+    if (ec)
+    {
+        // Callback will handle the error
+        callback(ec, "", "");
+        return;
+    }
+
+    if (subtree.empty())
+    {
+        // Callback will handle the error
+        BMCWEB_LOG_DEBUG(
+            "No LED group associated with the specified object path: {}",
+            objPath);
+        callback(ec, "", "");
+        return;
+    }
+
+    if (subtree.size() > 1)
+    {
+        // Callback will handle the error
+        BMCWEB_LOG_DEBUG(
+            "More than one LED group associated with the object {}: {}",
+            objPath, subtree.size());
+        callback(ec, "", "");
+        return;
+    }
+
+    const auto& [ledGroupPath, serviceMap] = *subtree.begin();
+    const auto& [service, interfaces] = *serviceMap.begin();
+    callback(ec, ledGroupPath, service);
+}
+
+inline void getLedGroupPath(
+    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
+    const std::string& objPath,
+    std::function<void(const boost::system::error_code& ec,
+                       const std::string& ledGroupPath,
+                       const std::string& service)>&& callback)
+{
+    static constexpr const char* ledObjectPath =
+        "/xyz/openbmc_project/led/groups";
+    sdbusplus::message::object_path ledGroupAssociatedPath =
+        objPath + "/identifying";
+
+    dbus::utility::getAssociatedSubTree(
+        ledGroupAssociatedPath, sdbusplus::message::object_path(ledObjectPath),
+        0, ledGroupInterface,
+        [asyncResp, objPath, callback{std::move(callback)}](
+            const boost::system::error_code& ec,
+            const dbus::utility::MapperGetSubTreeResponse& subtree) {
+            handleLedGroupSubtree(objPath, ec, subtree, callback);
+        });
+}
+
+inline void afterGetLedState(
+    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
+    const boost::system::error_code& ec, bool assert)
+{
+    if (ec)
+    {
+        if (ec.value() != EBADR)
+        {
+            BMCWEB_LOG_ERROR("DBUS response error for get ledState {}",
+                             ec.value());
+            messages::internalError(asyncResp->res);
+        }
+        return;
+    }
+
+    asyncResp->res.jsonValue["LocationIndicatorActive"] = assert;
+}
+
+inline void getLedState(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
+                        const boost::system::error_code& ec,
+                        const std::string& ledGroupPath,
+                        const std::string& service)
+{
+    if (ec)
+    {
+        if (ec.value() != EBADR)
+        {
+            BMCWEB_LOG_ERROR("DBUS response error {}", ec.value());
+            messages::internalError(asyncResp->res);
+        }
+        return;
+    }
+
+    if (ledGroupPath.empty() || service.empty())
+    {
+        // No LED group associated, not an error
+        return;
+    }
+
+    sdbusplus::asio::getProperty<bool>(
+        *crow::connections::systemBus, service, ledGroupPath,
+        "xyz.openbmc_project.Led.Group", "Asserted",
+        std::bind_front(afterGetLedState, asyncResp));
+}
+
+/**
+ * @brief Retrieves identify led group properties over dbus
+ *
+ * @param[in] asyncResp Shared pointer for generating response
+ * message.
+ * @param[in] objPath   Object path on PIM
+ *
+ * @return None.
+ */
+inline void getLocationIndicatorActive(
+    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
+    const std::string& objPath)
+{
+    BMCWEB_LOG_DEBUG("Get LocationIndicatorActive for {}", objPath);
+    getLedGroupPath(asyncResp, objPath,
+                    [asyncResp](const boost::system::error_code& ec,
+                                const std::string& ledGroupPath,
+                                const std::string& service) {
+                        getLedState(asyncResp, ec, ledGroupPath, service);
+                    });
+}
+
+inline void setLedState(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
+                        bool ledState, const boost::system::error_code& ec,
+                        const std::string& ledGroupPath,
+                        const std::string& service)
+{
+    if (ec)
+    {
+        if (ec.value() == EBADR)
+        {
+            messages::propertyUnknown(asyncResp->res,
+                                      "LocationIndicatorActive");
+            return;
+        }
+        BMCWEB_LOG_ERROR("DBUS response error {}", ec.value());
+        messages::internalError(asyncResp->res);
+        return;
+    }
+
+    if (ledGroupPath.empty() || service.empty())
+    {
+        messages::propertyUnknown(asyncResp->res, "LocationIndicatorActive");
+        return;
+    }
+
+    setDbusProperty(asyncResp, "LocationIndicatorActive", service, ledGroupPath,
+                    "xyz.openbmc_project.Led.Group", "Asserted", ledState);
+}
+
+/**
+ * @brief Sets identify led group properties
+ *
+ * @param[in] asyncResp     Shared pointer for generating response
+ * message.
+ * @param[in] objPath       Object path on PIM
+ * @param[in] ledState      LED state passed from request
+ *
+ * @return None.
+ */
+inline void setLocationIndicatorActive(
+    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
+    const std::string& objPath, bool ledState)
+{
+    BMCWEB_LOG_DEBUG("Set LocationIndicatorActive for {}", objPath);
+    getLedGroupPath(
+        asyncResp, objPath,
+        [asyncResp, ledState](const boost::system::error_code& ec,
+                              const std::string& ledGroupPath,
+                              const std::string& service) {
+            setLedState(asyncResp, ledState, ec, ledGroupPath, service);
+        });
+}
+
 } // namespace redfish
diff --git a/redfish-core/lib/power_supply.hpp b/redfish-core/lib/power_supply.hpp
index 7316b5f..89c84e1 100644
--- a/redfish-core/lib/power_supply.hpp
+++ b/redfish-core/lib/power_supply.hpp
@@ -8,11 +8,13 @@
 #include "error_messages.hpp"
 #include "generated/enums/resource.hpp"
 #include "http_request.hpp"
+#include "led.hpp"
 #include "logging.hpp"
 #include "query.hpp"
 #include "registries/privilege_registry.hpp"
 #include "utils/chassis_utils.hpp"
 #include "utils/dbus_utils.hpp"
+#include "utils/json_utils.hpp"
 #include "utils/time_utils.hpp"
 
 #include <asm-generic/errno.h>
@@ -505,6 +507,7 @@
     getPowerSupplyFirmwareVersion(asyncResp, service, powerSupplyPath);
     getPowerSupplyLocation(asyncResp, service, powerSupplyPath);
     getEfficiencyPercent(asyncResp);
+    getLocationIndicatorActive(asyncResp, powerSupplyPath);
 }
 
 inline void handlePowerSupplyHead(
@@ -549,6 +552,43 @@
         std::bind_front(doPowerSupplyGet, asyncResp, chassisId, powerSupplyId));
 }
 
+inline void doPatchPowerSupply(
+    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
+    const bool locationIndicatorActive, const std::string& powerSupplyPath,
+    const std::string& /*service*/)
+{
+    setLocationIndicatorActive(asyncResp, powerSupplyPath,
+                               locationIndicatorActive);
+}
+
+inline void handlePowerSupplyPatch(
+    App& app, const crow::Request& req,
+    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
+    const std::string& chassisId, const std::string& powerSupplyId)
+{
+    if (!redfish::setUpRedfishRoute(app, req, asyncResp))
+    {
+        return;
+    }
+
+    std::optional<bool> locationIndicatorActive;
+    if (!json_util::readJsonPatch(                             //
+            req, asyncResp->res,                               //
+            "LocationIndicatorActive", locationIndicatorActive //
+            ))
+    {
+        return;
+    }
+
+    if (locationIndicatorActive)
+    {
+        // Get the correct power supply Path that match the input parameters
+        getValidPowerSupplyPath(asyncResp, chassisId, powerSupplyId,
+                                std::bind_front(doPatchPowerSupply, asyncResp,
+                                                *locationIndicatorActive));
+    }
+}
+
 inline void requestRoutesPowerSupply(App& app)
 {
     BMCWEB_ROUTE(
@@ -562,6 +602,12 @@
         .privileges(redfish::privileges::getPowerSupply)
         .methods(boost::beast::http::verb::get)(
             std::bind_front(handlePowerSupplyGet, std::ref(app)));
+
+    BMCWEB_ROUTE(
+        app, "/redfish/v1/Chassis/<str>/PowerSubsystem/PowerSupplies/<str>/")
+        .privileges(redfish::privileges::patchPowerSupply)
+        .methods(boost::beast::http::verb::patch)(
+            std::bind_front(handlePowerSupplyPatch, std::ref(app)));
 }
 
 } // namespace redfish