diff --git a/Makefile.am b/Makefile.am
index 407815a..b82581c 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -72,6 +72,7 @@
 openpower_occ_control_LDFLAGS = $(generic_ld_flags)
 
 include pldm.mk
+include powermode.mk
 
 org/open_power/OCC/Device/error.hpp: ${top_srcdir}/org/open_power/OCC/Device.errors.yaml
 	@mkdir -p `dirname $@`
diff --git a/configure.ac b/configure.ac
index 0b96f56..892378c 100644
--- a/configure.ac
+++ b/configure.ac
@@ -86,6 +86,18 @@
         ]
         AC_SUBST([CPPFLAGS], [$cpp_flags])
     )
+
+    AC_ARG_ENABLE([power10-support],
+        AS_HELP_STRING([--with-power10-support], [To specify if system has power10 support])
+    )
+    AM_CONDITIONAL([POWER10_SUPPORT], [test "$with_power10_support" == "yes"])
+    AS_IF([test "x$with_power10_support" == "xyes"],
+        AC_MSG_NOTICE([Enabling POWER10])
+        [
+            cpp_flags="$CPPFLAGS -DPOWER10"
+        ]
+        AC_SUBST([CPPFLAGS], [$cpp_flags])
+    )
 ])
 
 AC_ARG_VAR(OCC_CONTROL_BUSNAME, [The Dbus busname to own])
diff --git a/occ_command.cpp b/occ_command.cpp
index d07c06f..5d693e7 100644
--- a/occ_command.cpp
+++ b/occ_command.cpp
@@ -139,107 +139,139 @@
 #else
     log<level::DEBUG>("OccCommand::send: calling write()");
 #endif
-    auto rc = write(fd, command.data(), command.size());
-    if ((rc < 0) || (rc != (int)command.size()))
-    {
-        const int write_errno = errno;
-        log<level::ERR>("OccCommand::send: write failed");
-        // This would log and terminate since its not handled.
-        elog<WriteFailure>(
-            phosphor::logging::org::open_power::OCC::Device::WriteFailure::
-                CALLOUT_ERRNO(write_errno),
-            phosphor::logging::org::open_power::OCC::Device::WriteFailure::
-                CALLOUT_DEVICE_PATH(devicePath.c_str()));
-    }
-    else
-    {
-        log<level::DEBUG>("OccCommand::send: write succeeded");
-    }
 
-    // Now read the response. This would be the content of occ-sram
-    while (1)
+    int retries = 1; // Allow a retry if a command fails to get valid response
+    do
     {
-        uint8_t data{};
-        auto len = read(fd, &data, sizeof(data));
-        const int read_errno = errno;
-        if (len > 0)
+        auto rc = write(fd, command.data(), command.size());
+        if ((rc < 0) || (rc != (int)command.size()))
         {
-            response.emplace_back(data);
-        }
-        else if (len < 0 && read_errno == EAGAIN)
-        {
-            // We may have data coming still.
-            // This driver does not need a sleep for a retry.
-            continue;
-        }
-        else if (len == 0)
-        {
-            log<level::DEBUG>("OccCommand::send: read completed");
-            // We have read all that we can.
-            status = CmdStatus::SUCCESS;
-            break;
-        }
-        else
-        {
-            log<level::ERR>("OccCommand::send: read failed");
+            const int write_errno = errno;
+            log<level::ERR>("OccCommand::send: write failed");
             // This would log and terminate since its not handled.
-            elog<ReadFailure>(
-                phosphor::logging::org::open_power::OCC::Device::ReadFailure::
-                    CALLOUT_ERRNO(read_errno),
-                phosphor::logging::org::open_power::OCC::Device::ReadFailure::
+            elog<WriteFailure>(
+                phosphor::logging::org::open_power::OCC::Device::WriteFailure::
+                    CALLOUT_ERRNO(write_errno),
+                phosphor::logging::org::open_power::OCC::Device::WriteFailure::
                     CALLOUT_DEVICE_PATH(devicePath.c_str()));
         }
-    }
+        else
+        {
+            log<level::DEBUG>("OccCommand::send: write succeeded");
+        }
 
-    if (response.size() > 2)
-    {
+        // Now read the response. This would be the content of occ-sram
+        while (1)
+        {
+            uint8_t data{};
+            auto len = read(fd, &data, sizeof(data));
+            const int read_errno = errno;
+            if (len > 0)
+            {
+                response.emplace_back(data);
+            }
+            else if (len < 0 && read_errno == EAGAIN)
+            {
+                // We may have data coming still.
+                // This driver does not need a sleep for a retry.
+                continue;
+            }
+            else if (len == 0)
+            {
+                log<level::DEBUG>("OccCommand::send: read completed");
+                // We have read all that we can.
+                status = CmdStatus::SUCCESS;
+                break;
+            }
+            else
+            {
+                log<level::ERR>("OccCommand::send: read failed");
+                // This would log and terminate since its not handled.
+                elog<ReadFailure>(
+                    phosphor::logging::org::open_power::OCC::Device::
+                        ReadFailure::CALLOUT_ERRNO(read_errno),
+                    phosphor::logging::org::open_power::OCC::Device::
+                        ReadFailure::CALLOUT_DEVICE_PATH(devicePath.c_str()));
+            }
+        }
+
+        if (response.size() > 2)
+        {
 #ifdef TRACE_PACKETS
-        log<level::INFO>(
-            fmt::format(
-                "OCC{}: Received 0x{:02X} response (length={} w/checksum)",
-                occInstance, cmd_type, response.size())
-                .c_str());
-        dump_hex(response, 64);
+            log<level::INFO>(
+                fmt::format(
+                    "OCC{}: Received 0x{:02X} response (length={} w/checksum)",
+                    occInstance, cmd_type, response.size())
+                    .c_str());
+            dump_hex(response, 64);
 #endif
 
-        // Validate checksum (last 2 bytes of response)
-        const unsigned int csumIndex = response.size() - 2;
-        const uint32_t rspChecksum =
-            (response[csumIndex] << 8) + response[csumIndex + 1];
-        uint32_t calcChecksum = 0;
-        for (unsigned int index = 0; index < csumIndex; ++index)
-        {
-            calcChecksum += response[index];
-        }
-        while (calcChecksum > 0xFFFF)
-        {
-            calcChecksum = (calcChecksum & 0xFFFF) + (calcChecksum >> 16);
-        }
-        if (calcChecksum != rspChecksum)
-        {
-            log<level::ERR>(fmt::format("OCC{}: Checksum Mismatch: response "
-                                        "0x{:04X}, calculated 0x{:04X}",
-                                        occInstance, rspChecksum, calcChecksum)
-                                .c_str());
-            dump_hex(response);
-            status = CmdStatus::INVALID_CHECKSUM;
+            // Validate checksum (last 2 bytes of response)
+            const unsigned int csumIndex = response.size() - 2;
+            const uint32_t rspChecksum =
+                (response[csumIndex] << 8) + response[csumIndex + 1];
+            uint32_t calcChecksum = 0;
+            for (unsigned int index = 0; index < csumIndex; ++index)
+            {
+                calcChecksum += response[index];
+            }
+            while (calcChecksum > 0xFFFF)
+            {
+                calcChecksum = (calcChecksum & 0xFFFF) + (calcChecksum >> 16);
+            }
+            if (calcChecksum != rspChecksum)
+            {
+                log<level::ERR>(
+                    fmt::format("OCC{}: Checksum Mismatch: response "
+                                "0x{:04X}, calculated 0x{:04X}",
+                                occInstance, rspChecksum, calcChecksum)
+                        .c_str());
+                dump_hex(response);
+                status = CmdStatus::INVALID_CHECKSUM;
+            }
+            else
+            {
+                // Validate response was for the specified command
+                if (command[0] == response[1])
+                {
+                    // Valid response received
+
+                    // Strip off 2 byte checksum
+                    response.pop_back();
+                    response.pop_back();
+                    break;
+                }
+                else
+                {
+                    log<level::ERR>(
+                        fmt::format(
+                            "OccCommand::send: Response command mismatch "
+                            "(sent: "
+                            "0x{:02X}, rsp: 0x{:02X}, rsp seq#: 0x{:02X}",
+                            command[0], response[1], response[0])
+                            .c_str());
+                    dump_hex(response, 64);
+                }
+            }
         }
         else
         {
-            // Strip off 2 byte checksum
-            response.pop_back();
-            response.pop_back();
+            log<level::ERR>(
+                fmt::format(
+                    "OccCommand::send: Invalid OCC{} response length: {}",
+                    occInstance, response.size())
+                    .c_str());
+            status = CmdStatus::FAILURE;
+            dump_hex(response);
         }
-    }
-    else
-    {
-        log<level::ERR>(
-            fmt::format("OccCommand::send: Invalid OCC{} response length: {}",
-                        occInstance, response.size())
-                .c_str());
-        status = CmdStatus::FAILURE;
-        dump_hex(response);
-    }
+
+        if (retries > 0)
+        {
+            log<level::ERR>("OccCommand::send: Command will be retried");
+            response.clear();
+        }
+
+    } while (retries-- > 0);
 
     closeDevice();
 
diff --git a/occ_command.hpp b/occ_command.hpp
index 2c925f6..42962d9 100644
--- a/occ_command.hpp
+++ b/occ_command.hpp
@@ -16,6 +16,60 @@
 // For waiting on signals
 namespace sdbusRule = sdbusplus::bus::match::rules;
 
+enum class CmdType
+{
+    POLL = 0x00,
+    CLEAR_ERROR_LOG = 0x12,
+    SET_MODE_AND_STATE = 0x20,
+    SET_CONFIG_DATA = 0x21,
+    SET_USER_PCAP = 0x22,
+    RESET_PREP = 0x25,
+    DEBUG_PASS_THROUGH = 0x40,
+    AME_PASS_THROUGH = 0x41,
+    GET_FIELD_DEBUG_DATA = 0x42,
+    MFG_TEST = 0x53
+};
+
+enum class OccState
+{
+    NO_CHANGE = 0x00,
+    STANDBY = 0x01,
+    OBSERVATION = 0x02,
+    ACTIVE = 0x03,
+    SAFE = 0x04,
+    CHARACTERIZATION = 0x05,
+};
+
+enum class SysPwrMode
+{
+    NO_CHANGE = 0,
+    DISABLE = 0x01,      // Disable / Static Base Frequencey
+    SFP = 0x03,          // Static Frequency Point (requires freqPt)
+    SAFE = 0x04,         // reported when system is in SAFE mode (not settable)
+    POWER_SAVING = 0x05, // Static Power Saving
+    DYNAMIC_PERF = 0x0A, // Dynamic / Balanced Performance
+    FFO = 0x0B,          // Fixed Frequency Override (requires freqPt)
+    MAX_PERF = 0x0C      // Maximum Performance
+};
+
+// Only some of the SysPwrModes are currently supported and allowed to be set
+#define VALID_POWER_MODE_SETTING(mode)                                         \
+    ((mode == SysPwrMode::DISABLE) || (mode == SysPwrMode::POWER_SAVING) ||    \
+     (mode == SysPwrMode::DYNAMIC_PERF) || (mode == SysPwrMode::MAX_PERF))
+
+enum class RspStatus
+{
+    SUCCESS = 0x00,
+    CONDITIONAL_SUCCESS = 0x01,
+    INVALID_COMMAND = 0x11,
+    INVALID_COMMAND_LENGTH = 0x12,
+    INVALID_DATA_FIELD = 0x13,
+    CHECKSUM_FAILURE = 0x14,
+    INTERNAL_ERROR = 0x15,
+    PRESENT_STATE_PROHIBITS = 0x16,
+    COMMAND_IN_PROGRESS = 0xFF
+};
+
 enum class CmdStatus
 {
     SUCCESS,
diff --git a/occ_device.hpp b/occ_device.hpp
index 937c6dc..50dd11d 100644
--- a/occ_device.hpp
+++ b/occ_device.hpp
@@ -140,6 +140,9 @@
      */
     static std::string getPathBack(const fs::path& path);
 
+    /** @brief Returns true if device represents the master OCC */
+    bool master() const;
+
   private:
     /** @brief Config value to be used to do bind and unbind */
     const std::string config;
@@ -187,9 +190,6 @@
         return;
     }
 
-    /** @brief Returns if device represents the master OCC */
-    bool master() const;
-
     /** @brief callback for the proc temp throttle event
      *
      *  @param[in] error - True if an error is reported, false otherwise
diff --git a/occ_manager.cpp b/occ_manager.cpp
index 4b209da..3ebd90a 100644
--- a/occ_manager.cpp
+++ b/occ_manager.cpp
@@ -68,6 +68,15 @@
         pcap = std::make_unique<open_power::occ::powercap::PowerCap>(
             *statusObjects.front());
     }
+
+#ifdef POWER10
+    // Create the power mode monitor object for master occ (0)
+    if (!pmode)
+    {
+        pmode = std::make_unique<open_power::occ::powermode::PowerMode>(
+            *statusObjects.front());
+    }
+#endif
 }
 
 void Manager::statusCallBack(bool status)
@@ -132,6 +141,10 @@
     // The first device is master occ
     pcap = std::make_unique<open_power::occ::powercap::PowerCap>(
         *statusObjects.front(), occMasterName);
+#ifdef POWER10
+    pmode = std::make_unique<open_power::occ::powermode::PowerMode>(
+        *statusObjects.front());
+#endif
 }
 #endif
 
diff --git a/occ_manager.hpp b/occ_manager.hpp
index c4218c9..ece7fb7 100644
--- a/occ_manager.hpp
+++ b/occ_manager.hpp
@@ -7,6 +7,9 @@
 #endif
 #include "powercap.hpp"
 #include "utils.hpp"
+#ifdef POWER10
+#include "powermode.hpp"
+#endif
 
 #include <cstring>
 #include <functional>
@@ -119,6 +122,11 @@
     /** @brief Power cap monitor and occ notification object */
     std::unique_ptr<open_power::occ::powercap::PowerCap> pcap;
 
+#ifdef POWER10
+    /** @brief Power mode monitor and notification object */
+    std::unique_ptr<open_power::occ::powermode::PowerMode> pmode;
+#endif
+
     /** @brief sbdbusplus match objects */
     std::vector<sdbusplus::bus::match_t> cpuMatches;
 
diff --git a/occ_status.cpp b/occ_status.cpp
index f4bf8a9..1ac5212 100644
--- a/occ_status.cpp
+++ b/occ_status.cpp
@@ -1,15 +1,21 @@
 #include "occ_status.hpp"
 
 #include "occ_sensor.hpp"
+#include "powermode.hpp"
 #include "utils.hpp"
 
 #include <fmt/core.h>
 
+#ifdef POWER10
+#include <com/ibm/Host/Target/server.hpp>
+#endif
 #include <phosphor-logging/log.hpp>
+
 namespace open_power
 {
 namespace occ
 {
+
 using namespace phosphor::logging;
 
 // Handles updates to occActive property
@@ -135,8 +141,6 @@
 // status of the executed command
 void Status::hostControlEvent(sdbusplus::message::message& msg)
 {
-    using namespace phosphor::logging;
-
     std::string cmdCompleted{};
     std::string cmdStatus{};
 
@@ -186,6 +190,14 @@
                             instance, state)
                     .c_str());
             lastState = state;
+
+#ifdef POWER10
+            if ((OccState(state) == OccState::ACTIVE) && (device.master()))
+            {
+                // Kernel detected that the master OCC went to active state
+                occsWentActive();
+            }
+#endif
         }
         file.close();
     }
@@ -200,5 +212,265 @@
     }
 }
 
+#ifdef POWER10
+// Check if Hypervisor target is PowerVM
+bool Status::isPowerVM()
+{
+    using namespace open_power::occ::powermode;
+    namespace Hyper = sdbusplus::com::ibm::Host::server;
+    constexpr auto HYPE_PATH = "/com/ibm/host0/hypervisor";
+    constexpr auto HYPE_INTERFACE = "com.ibm.Host.Target";
+    constexpr auto HYPE_PROP = "Target";
+
+    bool powerVmTarget = false;
+
+    // This will throw exception on failure
+    auto& bus = utils::getBus();
+    auto service = utils::getService(HYPE_PATH, HYPE_INTERFACE);
+    auto method = bus.new_method_call(service.c_str(), HYPE_PATH,
+                                      "org.freedesktop.DBus.Properties", "Get");
+    method.append(HYPE_INTERFACE, HYPE_PROP);
+    auto reply = bus.call(method);
+
+    std::variant<std::string> hyperEntryValue;
+    reply.read(hyperEntryValue);
+    auto propVal = std::get<std::string>(hyperEntryValue);
+    if (Hyper::Target::convertHypervisorFromString(propVal) ==
+        Hyper::Target::Hypervisor::PowerVM)
+    {
+        powerVmTarget = true;
+    }
+
+    log<level::DEBUG>(
+        fmt::format("Status::isPowerVM returning {}", powerVmTarget).c_str());
+
+    return powerVmTarget;
+}
+
+// Get the requested power mode
+SysPwrMode Status::getMode()
+{
+    using namespace open_power::occ::powermode;
+    SysPwrMode pmode = SysPwrMode::NO_CHANGE;
+
+    // This will throw exception on failure
+    auto& bus = utils::getBus();
+    auto service = utils::getService(PMODE_PATH, PMODE_INTERFACE);
+    auto method = bus.new_method_call(service.c_str(), PMODE_PATH,
+                                      "org.freedesktop.DBus.Properties", "Get");
+    method.append(PMODE_INTERFACE, POWER_MODE_PROP);
+    auto reply = bus.call(method);
+
+    std::variant<std::string> stateEntryValue;
+    reply.read(stateEntryValue);
+    auto propVal = std::get<std::string>(stateEntryValue);
+    pmode = powermode::convertStringToMode(propVal);
+
+    log<level::DEBUG>(
+        fmt::format("Status::getMode returning {}", pmode).c_str());
+
+    return pmode;
+}
+
+// Special processing that needs to happen once the OCCs change to ACTIVE state
+void Status::occsWentActive()
+{
+    CmdStatus status = CmdStatus::SUCCESS;
+
+    status = sendModeChange();
+    if (status != CmdStatus::SUCCESS)
+    {
+        log<level::ERR>(fmt::format("Status::occsWentActive: OCC mode "
+                                    "change failed with status {}",
+                                    status)
+                            .c_str());
+    }
+
+    status = sendIpsData();
+    if (status != CmdStatus::SUCCESS)
+    {
+        log<level::ERR>(
+            fmt::format(
+                "Status::occsWentActive: Sending Idle Power Save Config data"
+                " failed with status {}",
+                status)
+                .c_str());
+    }
+}
+
+// Send mode change request to the master OCC
+CmdStatus Status::sendModeChange()
+{
+    CmdStatus status = CmdStatus::FAILURE;
+
+    if (!device.master())
+    {
+        log<level::ERR>(
+            fmt::format("Status::sendModeChange: MODE CHANGE does not "
+                        "get sent to slave OCC{}",
+                        instance)
+                .c_str());
+        return status;
+    }
+    if (!isPowerVM())
+    {
+        // Mode change is only supported on PowerVM systems
+        log<level::DEBUG>("Status::sendModeChange: MODE CHANGE does not "
+                          "get sent on non-PowerVM systems");
+        return CmdStatus::SUCCESS;
+    }
+
+    const SysPwrMode newMode = getMode();
+
+    if (VALID_POWER_MODE_SETTING(newMode))
+    {
+        std::vector<std::uint8_t> cmd, rsp;
+        cmd.push_back(uint8_t(CmdType::SET_MODE_AND_STATE));
+        cmd.push_back(0x00); // Data Length (2 bytes)
+        cmd.push_back(0x06);
+        cmd.push_back(0x30); // Data (Version)
+        cmd.push_back(uint8_t(OccState::NO_CHANGE));
+        cmd.push_back(uint8_t(newMode));
+        cmd.push_back(0x00); // Mode Data (Freq Point)
+        cmd.push_back(0x00); //
+        cmd.push_back(0x00); // reserved
+        log<level::INFO>(fmt::format("Status::sendModeChange: SET_MODE({}) "
+                                     "command to OCC{} ({} bytes)",
+                                     newMode, instance, cmd.size())
+                             .c_str());
+        status = occCmd.send(cmd, rsp);
+        if (status == CmdStatus::SUCCESS)
+        {
+            if (rsp.size() == 5)
+            {
+                if (RspStatus::SUCCESS == RspStatus(rsp[2]))
+                {
+                    log<level::DEBUG>("Status::sendModeChange: - Mode change "
+                                      "completed successfully");
+                }
+                else
+                {
+                    log<level::ERR>(
+                        fmt::format("Status::sendModeChange: SET MODE "
+                                    "failed with status 0x{:02X}",
+                                    rsp[2])
+                            .c_str());
+                }
+            }
+            else
+            {
+                log<level::ERR>(
+                    "Status::sendModeChange: INVALID SET MODE response");
+                dump_hex(rsp);
+            }
+        }
+        else
+        {
+            if (status == CmdStatus::OPEN_FAILURE)
+            {
+                log<level::WARNING>(
+                    "Status::sendModeChange: OCC not active yet");
+            }
+            else
+            {
+                log<level::ERR>("Status::sendModeChange: SET_MODE FAILED!");
+            }
+        }
+    }
+    else
+    {
+        log<level::ERR>(
+            fmt::format(
+                "Status::sendModeChange: Unable to set power mode to {}",
+                newMode)
+                .c_str());
+    }
+
+    return status;
+}
+
+// Send Idle Power Saver config data to the master OCC
+CmdStatus Status::sendIpsData()
+{
+    CmdStatus status = CmdStatus::FAILURE;
+
+    if (!device.master())
+    {
+        log<level::ERR>(
+            fmt::format("Status::sendIpsData: SET_CFG_DATA[IPS] does not "
+                        "get sent to slave OCC{}",
+                        instance)
+                .c_str());
+        return status;
+    }
+    if (!isPowerVM())
+    {
+        // Idle Power Saver data is only supported on PowerVM systems
+        log<level::DEBUG>("Status::sendIpsData: SET_CFG_DATA[IPS] does not "
+                          "get sent on non-PowerVM systems");
+        return CmdStatus::SUCCESS;
+    }
+
+    std::vector<std::uint8_t> cmd, rsp;
+    cmd.push_back(uint8_t(CmdType::SET_CONFIG_DATA));
+    cmd.push_back(0x00); // Data Length (2 bytes)
+    cmd.push_back(0x09);
+    // Data:
+    cmd.push_back(0x11); // Config Format: IPS Settings
+    cmd.push_back(0x00); // Version
+    cmd.push_back(0x01); // IPS Enable: enabled
+    cmd.push_back(0x00); // Enter Delay Time (240s)
+    cmd.push_back(0xF0); //
+    cmd.push_back(0x08); // Enter Utilization (8%)
+    cmd.push_back(0x00); // Exit Delay Time (10s)
+    cmd.push_back(0x0A); //
+    cmd.push_back(0x0C); // Exit Utilization (12%)
+    log<level::INFO>(fmt::format("Status::sendIpsData: SET_CFG_DATA[IPS] "
+                                 "command to OCC{} ({} bytes)",
+                                 instance, cmd.size())
+                         .c_str());
+    status = occCmd.send(cmd, rsp);
+    if (status == CmdStatus::SUCCESS)
+    {
+        if (rsp.size() == 5)
+        {
+            if (RspStatus::SUCCESS == RspStatus(rsp[2]))
+            {
+                log<level::DEBUG>("Status::sendIpsData: - SET_CFG_DATA[IPS] "
+                                  "completed successfully");
+            }
+            else
+            {
+                log<level::ERR>(
+                    fmt::format("Status::sendIpsData: SET_CFG_DATA[IPS] "
+                                "failed with status 0x{:02X}",
+                                rsp[2])
+                        .c_str());
+            }
+        }
+        else
+        {
+            log<level::ERR>(
+                "Status::sendIpsData: INVALID SET_CFG_DATA[IPS] response");
+            dump_hex(rsp);
+        }
+    }
+    else
+    {
+        if (status == CmdStatus::OPEN_FAILURE)
+        {
+            log<level::WARNING>("Status::sendIpsData: OCC not active yet");
+        }
+        else
+        {
+            log<level::ERR>("Status::sendIpsData: SET_CFG_DATA[IPS] FAILED!");
+        }
+    }
+
+    return status;
+}
+
+#endif // POWER10
+
 } // namespace occ
 } // namespace open_power
diff --git a/occ_status.hpp b/occ_status.hpp
index df2ef51..415e0b7 100644
--- a/occ_status.hpp
+++ b/occ_status.hpp
@@ -149,6 +149,16 @@
     /** @brief Read OCC state (will trigger kernel to poll the OCC) */
     void readOccState();
 
+#ifdef POWER10
+    /** @brief Handle additional tasks when the OCCs reach active state */
+    void occsWentActive();
+
+    /** @brief Send mode change command to the master OCC
+     *  @return SUCCESS on success
+     */
+    CmdStatus sendModeChange();
+#endif // POWER10
+
   private:
     /** @brief OCC dbus object path */
     std::string path;
@@ -206,6 +216,23 @@
         return (path.empty() ? 0 : path.back() - '0');
     }
 
+#ifdef POWER10
+    /** @brief Query the current Hypervisor target
+     * @return true if the current Hypervisor target is PowerVM
+     */
+    bool isPowerVM();
+
+    /** @brief Get the requested power mode property
+     * @return Power mode
+     */
+    SysPwrMode getMode();
+
+    /** @brief Send Idle Power Saver config data to the master OCC
+     *  @return SUCCESS on success
+     */
+    CmdStatus sendIpsData();
+#endif // POWER10
+
     /** @brief Override the sensor name with name from the definition.
      *  @param[in]  estimatedPath - Estimated OCC Dbus object path
      *  @return  Fixed OCC DBus object path
diff --git a/powermode.cpp b/powermode.cpp
new file mode 100644
index 0000000..af739cb
--- /dev/null
+++ b/powermode.cpp
@@ -0,0 +1,87 @@
+#include <fmt/core.h>
+
+#include <cassert>
+#include <phosphor-logging/log.hpp>
+#include <powermode.hpp>
+#include <regex>
+#include <xyz/openbmc_project/Control/Power/Mode/server.hpp>
+
+namespace open_power
+{
+namespace occ
+{
+namespace powermode
+{
+
+using namespace phosphor::logging;
+using Mode = sdbusplus::xyz::openbmc_project::Control::Power::server::Mode;
+
+void PowerMode::modeChanged(sdbusplus::message::message& msg)
+{
+    if (!occStatus.occActive())
+    {
+        // Nothing to  do
+        return;
+    }
+
+    SysPwrMode pmode = SysPwrMode::NO_CHANGE;
+
+    std::map<std::string, std::variant<std::string>> properties{};
+    std::string interface;
+    std::string propVal;
+    msg.read(interface, properties);
+    const auto modeEntry = properties.find(POWER_MODE_PROP);
+    if (modeEntry != properties.end())
+    {
+        auto modeEntryValue = modeEntry->second;
+        propVal = std::get<std::string>(modeEntryValue);
+        pmode = convertStringToMode(propVal);
+
+        if (pmode != SysPwrMode::NO_CHANGE)
+        {
+            log<level::INFO>(
+                fmt::format("Power Mode Change Requested: {}", propVal)
+                    .c_str());
+
+            // Trigger mode change to OCC
+            occStatus.sendModeChange();
+        }
+    }
+
+    return;
+}
+
+// Convert PowerMode string to OCC SysPwrMode
+SysPwrMode convertStringToMode(const std::string& i_modeString)
+{
+    SysPwrMode pmode = SysPwrMode::NO_CHANGE;
+
+    Mode::PowerMode mode = Mode::convertPowerModeFromString(i_modeString);
+    if (mode == Mode::PowerMode::MaximumPerformance)
+    {
+        pmode = SysPwrMode::MAX_PERF;
+    }
+    else if (mode == Mode::PowerMode::PowerSaving)
+    {
+        pmode = SysPwrMode::POWER_SAVING;
+    }
+    else if (mode == Mode::PowerMode::Static)
+    {
+        pmode = SysPwrMode::DISABLE;
+    }
+    else
+    {
+        log<level::ERR>(
+            fmt::format("convertStringToMode: Invalid Power Mode specified: {}",
+                        i_modeString)
+                .c_str());
+    }
+
+    return pmode;
+}
+
+} // namespace powermode
+
+} // namespace occ
+
+} // namespace open_power
diff --git a/powermode.hpp b/powermode.hpp
new file mode 100644
index 0000000..472fd3e
--- /dev/null
+++ b/powermode.hpp
@@ -0,0 +1,79 @@
+#pragma once
+
+#ifdef POWER10
+#include "config.h"
+
+#include "occ_status.hpp"
+
+#include <experimental/filesystem>
+#include <sdbusplus/bus.hpp>
+#include <sdbusplus/bus/match.hpp>
+
+namespace open_power
+{
+namespace occ
+{
+namespace powermode
+{
+
+constexpr auto PMODE_PATH = "/xyz/openbmc_project/control/host0/power_mode";
+constexpr auto PMODE_INTERFACE = "xyz.openbmc_project.Control.Power.Mode";
+constexpr auto POWER_MODE_PROP = "PowerMode";
+
+/** @brief Convert power mode string to OCC SysPwrMode value
+ *
+ * @param[in] i_modeString - power mode string
+ *
+ * @return  SysPwrMode or SysPwrMode::NO_CHANGE if not found
+ */
+SysPwrMode convertStringToMode(const std::string& i_modeString);
+
+/** @class PowerMode
+ *  @brief Monitors for changes to the power mode and notifies occ
+ *
+ *  The customer power mode is provided to the OCC by host TMGT when the occ
+ *  first goes active or is reset.  This code is responsible for sending
+ *  the power mode to the OCC if the mode is changed while the occ is active.
+ */
+
+class PowerMode
+{
+  public:
+    /** @brief PowerMode object to inform occ of changes to mode
+     *
+     * This object will monitor for changes to the power mode setting.
+     * If a change is detected, and the occ is active, then this object will
+     * notify the OCC of the change.
+     *
+     * @param[in] occStatus - The occ status object
+     */
+    PowerMode(Status& occStatus) :
+        occStatus(occStatus),
+        pmodeMatch(utils::getBus(),
+                   sdbusplus::bus::match::rules::propertiesChanged(
+                       PMODE_PATH, PMODE_INTERFACE),
+                   [this](auto& msg) { this->modeChanged(msg); }){};
+
+  private:
+    /** @brief Callback for pmode setting changes
+     *
+     * Process change and inform OCC
+     *
+     * @param[in]  msg       - Data associated with pmode change signal
+     *
+     */
+    void modeChanged(sdbusplus::message::message& msg);
+
+    /* @brief OCC Status object */
+    Status& occStatus;
+
+    /** @brief Used to subscribe to dbus pmode property changes **/
+    sdbusplus::bus::match_t pmodeMatch;
+};
+
+} // namespace powermode
+
+} // namespace occ
+
+} // namespace open_power
+#endif
diff --git a/powermode.mk b/powermode.mk
new file mode 100644
index 0000000..ffa3aa9
--- /dev/null
+++ b/powermode.mk
@@ -0,0 +1,8 @@
+if POWER10_SUPPORT
+
+noinst_HEADERS += \
+	powermode.hpp
+libocc_control_la_SOURCES += \
+	powermode.cpp
+
+endif