diff --git a/meson.build b/meson.build
index e6b6c6c..7d48b5d 100644
--- a/meson.build
+++ b/meson.build
@@ -10,6 +10,8 @@
     ]
 )
 
+cxx = meson.get_compiler('cpp')
+
 conf_data = configuration_data()
 conf_data.set_quoted('OCC_CONTROL_BUSNAME', 'org.open_power.OCC.Control')
 conf_data.set_quoted('OCC_CONTROL_ROOT', '/org/open_power/control')
@@ -155,6 +157,8 @@
         )
         deps += [
             libpldm_dep,
+            cxx.find_library('pdbg'),
+            cxx.find_library('phal'),
         ]
         sources += [
             'pldm.cpp',
diff --git a/occ_device.cpp b/occ_device.cpp
index 2ee5f34..c95c0f3 100644
--- a/occ_device.cpp
+++ b/occ_device.cpp
@@ -1,5 +1,6 @@
 #include "occ_device.hpp"
 
+#include "occ_manager.hpp"
 #include "occ_status.hpp"
 
 #include <iostream>
@@ -48,6 +49,24 @@
     return (master != 0);
 }
 
+void Device::errorCallback(bool error)
+{
+    if (error)
+    {
+        statusObject.deviceError();
+    }
+}
+
+#ifdef PLDM
+void Device::timeoutCallback(bool error)
+{
+    if (error)
+    {
+        managerObject.sbeTimeout(instance);
+    }
+}
+#endif
+
 void Device::throttleProcTempCallback(bool error)
 {
     statusObject.throttleProcTemp(error);
diff --git a/occ_device.hpp b/occ_device.hpp
index ef2fb06..106604e 100644
--- a/occ_device.hpp
+++ b/occ_device.hpp
@@ -42,16 +42,30 @@
      *  @param[in] manager  - OCC manager instance
      *  @param[in] status   - Status instance
      *  @param[in] instance - OCC instance number
-     *  @param[in] callback - Optional callback on errors
      */
-    Device(EventPtr& event, const fs::path& path, const Manager& manager,
-           Status& status, unsigned int instance = 0,
-           std::function<void(bool)> callBack = nullptr) :
+    Device(EventPtr& event, const fs::path& path, Manager& manager,
+           Status& status, unsigned int instance = 0) :
         config(getPathBack(path)),
-        devPath(path), statusObject(status),
-        error(event, path / "occ_error", callBack),
+        devPath(path), instance(instance), statusObject(status),
+        managerObject(manager),
+        error(event, path / "occ_error",
+              std::bind(std::mem_fn(&Device::errorCallback), this,
+                        std::placeholders::_1)),
+        timeout(event,
+                path /
+                    fs::path("../../sbefifo" + std::to_string(instance + 1)) /
+                    "timeout",
+#ifdef PLDM
+                std::bind(std::mem_fn(&Device::timeoutCallback), this,
+                          std::placeholders::_1)
+#else
+                nullptr
+#endif
+                    ),
         ffdc(event, path / "ffdc", instance),
-        presence(event, path / "occs_present", manager, callBack),
+        presence(event, path / "occs_present", manager,
+                 std::bind(std::mem_fn(&Device::errorCallback), this,
+                           std::placeholders::_1)),
         throttleProcTemp(
             event, path / "occ_dvfs_overtemp",
             std::bind(std::mem_fn(&Device::throttleProcTempCallback), this,
@@ -126,6 +140,15 @@
             // nothing to do if there is no FFDC file
         }
 
+        try
+        {
+            timeout.addWatch(poll);
+        }
+        catch (const std::exception& e)
+        {
+            // nothing to do if there is no SBE timeout file
+        }
+
         error.addWatch(poll);
     }
 
@@ -136,6 +159,7 @@
         presence.removeWatch();
         ffdc.removeWatch();
         error.removeWatch();
+        timeout.removeWatch();
         throttleMemTemp.removeWatch();
         throttleProcPower.removeWatch();
         throttleProcTemp.removeWatch();
@@ -167,6 +191,9 @@
     /** @brief This directory contains the error files */
     const fs::path devPath;
 
+    /** @brief OCC instance ID */
+    const unsigned int instance;
+
     /**  @brief To bind the device to the OCC driver, do:
      *
      *    Write occ<#>-dev0 to: /sys/bus/platform/drivers/occ-hwmon/bind
@@ -181,9 +208,15 @@
     /**  Store the associated Status instance */
     Status& statusObject;
 
+    /** Store the parent Manager instance */
+    Manager& managerObject;
+
     /** Abstraction of error monitoring */
     Error error;
 
+    /** Abstraction of SBE timeout monitoring */
+    Error timeout;
+
     /** SBE FFDC monitoring */
     FFDC ffdc;
 
@@ -210,6 +243,20 @@
         return;
     }
 
+    /** @brief callback for OCC error and presence monitoring
+     *
+     * @param[in] error - True if an error is reported, false otherwise
+     */
+    void errorCallback(bool error);
+
+#ifdef PLDM
+    /** @brief callback for SBE timeout monitoring
+     *
+     * @param[in] error - True if an error is reported, false otherwise
+     */
+    void timeoutCallback(bool error);
+#endif
+
     /** @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 b83feb3..ed69274 100644
--- a/occ_manager.cpp
+++ b/occ_manager.cpp
@@ -248,10 +248,163 @@
 #endif
 
 #ifdef PLDM
+void Manager::sbeTimeout(unsigned int instance)
+{
+    log<level::INFO>("SBE timeout, requesting HRESET",
+                     entry("SBE=%d", instance));
+
+    setSBEState(instance, SBE_STATE_NOT_USABLE);
+
+    pldmHandle->sendHRESET(instance);
+}
+
 bool Manager::updateOCCActive(instanceID instance, bool status)
 {
     return (statusObjects[instance])->occActive(status);
 }
+
+void Manager::sbeHRESETResult(instanceID instance, bool success)
+{
+    if (success)
+    {
+        log<level::INFO>("HRESET succeeded", entry("SBE=%d", instance));
+
+        setSBEState(instance, SBE_STATE_BOOTED);
+
+        return;
+    }
+
+    setSBEState(instance, SBE_STATE_FAILED);
+
+    if (sbeCanDump(instance))
+    {
+        constexpr auto path = "/org/openpower/dump";
+        constexpr auto interface = "xyz.openbmc_project.Dump.Create";
+        constexpr auto function = "CreateDump";
+
+        log<level::INFO>("HRESET failed, triggering SBE dump",
+                         entry("SBE=%d", instance));
+
+        auto& bus = utils::getBus();
+        uint32_t src6 = instance << 16;
+        uint32_t logId =
+            FFDC::createPEL("org.open_power.Processor.Error.SbeChipOpTimeout",
+                            src6, "SBE command timeout");
+
+        try
+        {
+            std::string service = utils::getService(path, interface);
+            auto method =
+                bus.new_method_call(service.c_str(), path, interface, function);
+
+            std::map<std::string, std::variant<std::string, uint64_t>>
+                createParams{
+                    {"com.ibm.Dump.Create.CreateParameters.ErrorLogId",
+                     uint64_t(logId)},
+                    {"com.ibm.Dump.Create.CreateParameters.DumpType",
+                     "com.ibm.Dump.Create.DumpType.SBE"},
+                    {"com.ibm.Dump.Create.CreateParameters.FailingUnitId",
+                     uint64_t(instance)},
+                };
+
+            method.append(createParams);
+
+            auto response = bus.call(method);
+        }
+        catch (const sdbusplus::exception::exception& e)
+        {
+            constexpr auto ERROR_DUMP_DISABLED =
+                "xyz.openbmc_project.Dump.Create.Error.Disabled";
+            if (e.name() == ERROR_DUMP_DISABLED)
+            {
+                log<level::INFO>("Dump is disabled, skipping");
+            }
+            else
+            {
+                log<level::ERR>("Dump failed");
+            }
+        }
+    }
+}
+
+bool Manager::sbeCanDump(unsigned int instance)
+{
+    struct pdbg_target* proc = getPdbgTarget(instance);
+
+    if (!proc)
+    {
+        // allow the dump in the error case
+        return true;
+    }
+
+    try
+    {
+        if (!openpower::phal::sbe::isDumpAllowed(proc))
+        {
+            return false;
+        }
+
+        if (openpower::phal::pdbg::isSbeVitalAttnActive(proc))
+        {
+            return false;
+        }
+    }
+    catch (openpower::phal::exception::SbeError& e)
+    {
+        log<level::INFO>("Failed to query SBE state");
+    }
+
+    // allow the dump in the error case
+    return true;
+}
+
+void Manager::setSBEState(unsigned int instance, enum sbe_state state)
+{
+    struct pdbg_target* proc = getPdbgTarget(instance);
+
+    if (!proc)
+    {
+        return;
+    }
+
+    try
+    {
+        openpower::phal::sbe::setState(proc, state);
+    }
+    catch (const openpower::phal::exception::SbeError& e)
+    {
+        log<level::ERR>("Failed to set SBE state");
+    }
+}
+
+struct pdbg_target* Manager::getPdbgTarget(unsigned int instance)
+{
+    if (!pdbgInitialized)
+    {
+        try
+        {
+            openpower::phal::pdbg::init();
+            pdbgInitialized = true;
+        }
+        catch (const openpower::phal::exception::PdbgError& e)
+        {
+            log<level::ERR>("pdbg initialization failed");
+            return nullptr;
+        }
+    }
+
+    struct pdbg_target* proc = nullptr;
+    pdbg_for_each_class_target("proc", proc)
+    {
+        if (pdbg_target_index(proc) == instance)
+        {
+            return proc;
+        }
+    }
+
+    log<level::ERR>("Failed to get pdbg target");
+    return nullptr;
+}
 #endif
 
 void Manager::pollerTimerExpired()
@@ -591,6 +744,5 @@
     return;
 }
 #endif
-
 } // namespace occ
 } // namespace open_power
diff --git a/occ_manager.hpp b/occ_manager.hpp
index 5b97abc..e6e7a18 100644
--- a/occ_manager.hpp
+++ b/occ_manager.hpp
@@ -4,6 +4,8 @@
 #include "occ_status.hpp"
 #ifdef PLDM
 #include "pldm.hpp"
+
+#include <libphal.H>
 #endif
 #include "powercap.hpp"
 #include "utils.hpp"
@@ -74,6 +76,8 @@
         ,
         pldmHandle(std::make_unique<pldm::Interface>(
             std::bind(std::mem_fn(&Manager::updateOCCActive), this,
+                      std::placeholders::_1, std::placeholders::_2),
+            std::bind(std::mem_fn(&Manager::sbeHRESETResult), this,
                       std::placeholders::_1, std::placeholders::_2)))
 #endif
 #ifdef POWER10
@@ -98,6 +102,15 @@
         return activeCount;
     }
 
+#ifdef PLDM
+    /** @brief Called by a Device to report that the SBE timed out
+     *         and appropriate action should be taken
+     *
+     * @param[in] instance - the OCC instance id
+     */
+    void sbeTimeout(unsigned int instance);
+#endif
+
   private:
     /** @brief Creates the OCC D-Bus objects.
      */
@@ -195,6 +208,42 @@
      */
     bool updateOCCActive(instanceID instance, bool status);
 
+    /** @brief Callback handler invoked by PLDM sensor change when
+     *         the HRESET succeeds or fails.
+     *
+     *  @param[in] instance - the SBE instance id
+     *  @param[in] success - true if the HRESET succeeded, otherwise false
+     */
+    void sbeHRESETResult(instanceID instance, bool success);
+
+    /** @brief Helper function to check whether an SBE dump should be collected
+     *         now.
+     *
+     *  @param[in] instance - the SBE instance id
+     *
+     *  @return true if an SBE dump should be collected and false if not
+     */
+    bool sbeCanDump(unsigned int instance);
+
+    /** @brief Helper function to set the SBE state through PDBG/PHAL
+     *
+     * @param[in] instance - instance of the SBE
+     * @param[in] state - the state to which the SBE should be set
+     *
+     */
+    void setSBEState(unsigned int instance, enum sbe_state state);
+
+    /** @brief Helper function to get the SBE instance PDBG processor target
+     *
+     * @param[in] instance - the SBE instance id
+     *
+     * @return a pointer to the PDBG target
+     */
+    struct pdbg_target* getPdbgTarget(unsigned int instance);
+
+    /** @brief Whether pdbg_targets_init has been called */
+    bool pdbgInitialized = false;
+
     std::unique_ptr<pldm::Interface> pldmHandle = nullptr;
 #endif
 
diff --git a/occ_status.cpp b/occ_status.cpp
index b1893fd..eaa6080 100644
--- a/occ_status.cpp
+++ b/occ_status.cpp
@@ -92,17 +92,13 @@
 }
 
 // Callback handler when a device error is reported.
-void Status::deviceErrorHandler(bool error)
+void Status::deviceError()
 {
-    // Make sure we have an error
-    if (error)
-    {
-        // This would deem OCC inactive
-        this->occActive(false);
+    // This would deem OCC inactive
+    this->occActive(false);
 
-        // Reset the OCC
-        this->resetOCC();
-    }
+    // Reset the OCC
+    this->resetOCC();
 }
 
 // Sends message to host control command handler to reset OCC
diff --git a/occ_status.hpp b/occ_status.hpp
index 606a890..7356add 100644
--- a/occ_status.hpp
+++ b/occ_status.hpp
@@ -69,7 +69,7 @@
      *                             OCC if PLDM is the host communication
      *                             protocol
      */
-    Status(EventPtr& event, const char* path, const Manager& manager,
+    Status(EventPtr& event, const char* path, Manager& manager,
            std::function<void(bool)> callBack = nullptr
 #ifdef PLDM
            ,
@@ -86,9 +86,7 @@
                fs::path(DEV_PATH) /
                    fs::path(sysfsName + "." + std::to_string(instance + 1)),
 #endif
-               manager, *this, instance,
-               std::bind(std::mem_fn(&Status::deviceErrorHandler), this,
-                         std::placeholders::_1)),
+               manager, *this, instance),
         hostControlSignal(
             utils::getBus(),
             sdbusRule::type::signal() + sdbusRule::member("CommandComplete") +
@@ -163,6 +161,9 @@
     /** @brief Read OCC state (will trigger kernel to poll the OCC) */
     void readOccState();
 
+    /** @brief Called when device errors are detected */
+    void deviceError();
+
 #ifdef POWER10
     /** @brief Handle additional tasks when the OCCs reach active state */
     void occsWentActive();
@@ -210,12 +211,6 @@
     /** @brief Command object to send commands to the OCC */
     OccCommand occCmd;
 
-    /** @brief Callback handler when device errors are detected
-     *
-     *  @param[in]  error - True if an error is reported, false otherwise
-     */
-    void deviceErrorHandler(bool error);
-
     /** @brief Callback function on host control signals
      *
      *  @param[in]  msg - Data associated with subscribed signal
diff --git a/pldm.cpp b/pldm.cpp
index 093869d..085e19e 100644
--- a/pldm.cpp
+++ b/pldm.cpp
@@ -9,15 +9,48 @@
 
 #include <phosphor-logging/log.hpp>
 
+#define PLDM_OEM_IBM_SBE_MAINTENANCE_STATE 32772
+#define SBE_RETRY_REQUIRED 0x2
+
+#define PLDM_OEM_IBM_SBE_HRESET_STATE 32775
+#define SBE_HRESET_NOT_READY 0x1
+#define SBE_HRESET_READY 0x2
+#define SBE_HRESET_FAILED 0x3
+
 namespace pldm
 {
 
 using namespace phosphor::logging;
 
-void Interface::fetchOCCSensorInfo(const PdrList& pdrs,
-                                   SensorToOCCInstance& sensorInstanceMap,
-                                   SensorOffset& sensorOffset)
+void Interface::fetchSensorInfo(uint16_t stateSetId,
+                                SensorToInstance& sensorInstanceMap,
+                                SensorOffset& sensorOffset)
 {
+    PdrList pdrs{};
+
+    auto& bus = open_power::occ::utils::getBus();
+    try
+    {
+        auto method = bus.new_method_call(
+            "xyz.openbmc_project.PLDM", "/xyz/openbmc_project/pldm",
+            "xyz.openbmc_project.PLDM.PDR", "FindStateSensorPDR");
+        method.append(tid, (uint16_t)PLDM_ENTITY_PROC, stateSetId);
+
+        auto responseMsg = bus.call(method);
+        responseMsg.read(pdrs);
+    }
+    catch (const sdbusplus::exception::exception& e)
+    {
+        log<level::ERR>("pldm: Failed to fetch the state sensor PDRs",
+                        entry("ERROR=%s", e.what()));
+    }
+
+    if (pdrs.empty())
+    {
+        log<level::ERR>("pldm: state sensor PDRs not present");
+        return;
+    }
+
     bool offsetFound = false;
     auto pdr =
         reinterpret_cast<const pldm_state_sensor_pdr*>(pdrs.front().data());
@@ -28,8 +61,7 @@
             reinterpret_cast<const state_sensor_possible_states*>(
                 possibleStatesPtr);
 
-        if (possibleStates->state_set_id ==
-            PLDM_STATE_SET_OPERATIONAL_RUNNING_STATUS)
+        if (possibleStates->state_set_id == stateSetId)
         {
             sensorOffset = offset;
             offsetFound = true;
@@ -42,8 +74,7 @@
 
     if (!offsetFound)
     {
-        log<level::ERR>(
-            "pldm: OCC state sensor PDR with StateSetId PLDM_STATE_SET_OPERATIONAL_RUNNING_STATUS not found");
+        log<level::ERR>("pldm: state sensor PDR not found");
         return;
     }
 
@@ -72,33 +103,14 @@
 {
     if (!isOCCSensorCacheValid())
     {
-        PdrList pdrs{};
+        fetchSensorInfo(PLDM_STATE_SET_OPERATIONAL_RUNNING_STATUS,
+                        sensorToOCCInstance, OCCSensorOffset);
+    }
 
-        auto& bus = open_power::occ::utils::getBus();
-        try
-        {
-            auto method = bus.new_method_call(
-                "xyz.openbmc_project.PLDM", "/xyz/openbmc_project/pldm",
-                "xyz.openbmc_project.PLDM.PDR", "FindStateSensorPDR");
-            method.append(tid, (uint16_t)PLDM_ENTITY_PROC,
-                          (uint16_t)PLDM_STATE_SET_OPERATIONAL_RUNNING_STATUS);
-
-            auto responseMsg = bus.call(method);
-            responseMsg.read(pdrs);
-        }
-        catch (const sdbusplus::exception::exception& e)
-        {
-            log<level::ERR>("pldm: Failed to fetch the OCC state sensor PDRs",
-                            entry("ERROR=%s", e.what()));
-        }
-
-        if (!pdrs.size())
-        {
-            log<level::ERR>("pldm: OCC state sensor PDRs not present");
-            return;
-        }
-
-        fetchOCCSensorInfo(pdrs, sensorToOCCInstance, sensorOffset);
+    if (sensorToSBEInstance.empty())
+    {
+        fetchSensorInfo(PLDM_OEM_IBM_SBE_HRESET_STATE, sensorToSBEInstance,
+                        SBESensorOffset);
     }
 
     TerminusID tid{};
@@ -109,32 +121,57 @@
 
     msg.read(tid, sensorId, msgSensorOffset, eventState, previousEventState);
 
-    auto sensorEntry = sensorToOCCInstance.find(sensorId);
-    if (sensorEntry == sensorToOCCInstance.end() ||
-        (msgSensorOffset != sensorOffset))
+    if (msgSensorOffset == OCCSensorOffset)
     {
-        // No action for non matching sensorEvents
-        return;
-    }
+        auto sensorEntry = sensorToOCCInstance.find(sensorId);
 
-    if (eventState == static_cast<EventState>(
-                          PLDM_STATE_SET_OPERATIONAL_RUNNING_STATUS_IN_SERVICE))
-    {
-        log<level::INFO>(
-            fmt::format("PLDM: OCC{} is RUNNING", sensorEntry->second).c_str());
-        callBack(sensorEntry->second, true);
-    }
-    else if (eventState ==
-             static_cast<EventState>(
-                 PLDM_STATE_SET_OPERATIONAL_RUNNING_STATUS_STOPPED))
-    {
-        log<level::INFO>(
-            fmt::format("PLDM: OCC{} has now STOPPED", sensorEntry->second)
-                .c_str());
-        callBack(sensorEntry->second, false);
-    }
+        if (sensorEntry == sensorToOCCInstance.end())
+        {
+            return;
+        }
 
-    return;
+        if (eventState ==
+            static_cast<EventState>(
+                PLDM_STATE_SET_OPERATIONAL_RUNNING_STATUS_IN_SERVICE))
+        {
+            log<level::INFO>(
+                fmt::format("PLDM: OCC{} is RUNNING", sensorEntry->second)
+                    .c_str());
+            callBack(sensorEntry->second, true);
+        }
+        else if (eventState ==
+                 static_cast<EventState>(
+                     PLDM_STATE_SET_OPERATIONAL_RUNNING_STATUS_STOPPED))
+        {
+            log<level::INFO>(
+                fmt::format("PLDM: OCC{} has now STOPPED", sensorEntry->second)
+                    .c_str());
+            callBack(sensorEntry->second, false);
+        }
+    }
+    else if (msgSensorOffset == SBESensorOffset)
+    {
+        auto sensorEntry = sensorToSBEInstance.find(sensorId);
+
+        if (sensorEntry == sensorToSBEInstance.end())
+        {
+            return;
+        }
+
+        if (eventState == static_cast<EventState>(SBE_HRESET_NOT_READY))
+        {
+            log<level::INFO>("pldm: HRESET is NOT READY",
+                             entry("SBE=%d", sensorEntry->second));
+        }
+        else if (eventState == static_cast<EventState>(SBE_HRESET_READY))
+        {
+            sbeCallBack(sensorEntry->second, true);
+        }
+        else if (eventState == static_cast<EventState>(SBE_HRESET_FAILED))
+        {
+            sbeCallBack(sensorEntry->second, false);
+        }
+    }
 }
 
 void Interface::hostStateEvent(sdbusplus::message::message& msg)
@@ -151,14 +188,43 @@
         {
             sensorToOCCInstance.clear();
             occInstanceToEffecter.clear();
+
+            sensorToSBEInstance.clear();
+            sbeInstanceToEffecter.clear();
         }
     }
 }
 
-void Interface::fetchOCCEffecterInfo(
-    const PdrList& pdrs, OccInstanceToEffecter& /*instanceToEffecterMap*/,
-    CompositeEffecterCount& /*count*/, uint8_t& bootRestartPos)
+void Interface::fetchEffecterInfo(uint16_t entityId, uint16_t stateSetId,
+                                  InstanceToEffecter& instanceToEffecterMap,
+                                  CompositeEffecterCount& effecterCount,
+                                  uint8_t& stateIdPos)
 {
+    PdrList pdrs{};
+
+    auto& bus = open_power::occ::utils::getBus();
+    try
+    {
+        auto method = bus.new_method_call(
+            "xyz.openbmc_project.PLDM", "/xyz/openbmc_project/pldm",
+            "xyz.openbmc_project.PLDM.PDR", "FindStateEffecterPDR");
+        method.append(tid, entityId, stateSetId);
+
+        auto responseMsg = bus.call(method);
+        responseMsg.read(pdrs);
+    }
+    catch (const sdbusplus::exception::exception& e)
+    {
+        log<level::ERR>("pldm: Failed to fetch the state effecter PDRs",
+                        entry("ERROR=%s", e.what()));
+    }
+
+    if (!pdrs.size())
+    {
+        log<level::ERR>("pldm: state effecter PDRs not present");
+        return;
+    }
+
     bool offsetFound = false;
     auto pdr =
         reinterpret_cast<const pldm_state_effecter_pdr*>(pdrs.front().data());
@@ -169,9 +235,9 @@
             reinterpret_cast<const state_effecter_possible_states*>(
                 possibleStatesPtr);
 
-        if (possibleStates->state_set_id == PLDM_STATE_SET_BOOT_RESTART_CAUSE)
+        if (possibleStates->state_set_id == stateSetId)
         {
-            bootRestartPos = offset;
+            stateIdPos = offset;
             effecterCount = pdr->composite_effecter_count;
             offsetFound = true;
             break;
@@ -199,7 +265,7 @@
     open_power::occ::instanceID position = start;
     for (auto const& pair : entityInstMap)
     {
-        occInstanceToEffecter.emplace(position, pair.second);
+        instanceToEffecterMap.emplace(position, pair.second);
         position++;
     }
 }
@@ -207,7 +273,7 @@
 std::vector<uint8_t>
     Interface::prepareSetEffecterReq(uint8_t instanceId, EffecterID effecterId,
                                      CompositeEffecterCount effecterCount,
-                                     uint8_t bootRestartPos)
+                                     uint8_t stateIdPos, uint8_t stateSetValue)
 {
     std::vector<uint8_t> request(
         sizeof(pldm_msg_hdr) + sizeof(effecterId) + sizeof(effecterCount) +
@@ -217,11 +283,10 @@
 
     for (uint8_t effecterPos = 0; effecterPos < effecterCount; effecterPos++)
     {
-        if (effecterPos == bootRestartPos)
+        if (effecterPos == stateIdPos)
         {
-            stateField.emplace_back(set_effecter_state_field{
-                PLDM_REQUEST_SET,
-                PLDM_STATE_SET_BOOT_RESTART_CAUSE_WARM_RESET});
+            stateField.emplace_back(
+                set_effecter_state_field{PLDM_REQUEST_SET, stateSetValue});
         }
         else
         {
@@ -244,34 +309,9 @@
 {
     if (!isPDREffecterCacheValid())
     {
-        PdrList pdrs{};
-
-        auto& bus = open_power::occ::utils::getBus();
-        try
-        {
-            auto method = bus.new_method_call(
-                "xyz.openbmc_project.PLDM", "/xyz/openbmc_project/pldm",
-                "xyz.openbmc_project.PLDM.PDR", "FindStateEffecterPDR");
-            method.append(tid, (uint16_t)PLDM_ENTITY_PROC_MODULE,
-                          (uint16_t)PLDM_STATE_SET_BOOT_RESTART_CAUSE);
-
-            auto responseMsg = bus.call(method);
-            responseMsg.read(pdrs);
-        }
-        catch (const sdbusplus::exception::exception& e)
-        {
-            log<level::ERR>("pldm: Failed to fetch the OCC state effecter PDRs",
-                            entry("ERROR=%s", e.what()));
-        }
-
-        if (!pdrs.size())
-        {
-            log<level::ERR>("pldm: OCC state effecter PDRs not present");
-            return;
-        }
-
-        fetchOCCEffecterInfo(pdrs, occInstanceToEffecter, effecterCount,
-                             bootRestartPosition);
+        fetchEffecterInfo(
+            PLDM_ENTITY_PROC_MODULE, PLDM_STATE_SET_BOOT_RESTART_CAUSE,
+            occInstanceToEffecter, OCCEffecterCount, bootRestartPosition);
     }
 
     // Find the matching effecter for the OCC instance
@@ -286,7 +326,65 @@
     }
 
     uint8_t instanceId{};
+    if (!getMctpInstanceId(instanceId))
+    {
+        return;
+    }
 
+    // Prepare the SetStateEffecterStates request to reset the OCC
+    auto request = prepareSetEffecterReq(
+        instanceId, effecterEntry->second, OCCEffecterCount,
+        bootRestartPosition, PLDM_STATE_SET_BOOT_RESTART_CAUSE_WARM_RESET);
+
+    if (request.empty())
+    {
+        log<level::ERR>("pldm: SetStateEffecterStates OCC reset request empty");
+        return;
+    }
+
+    sendPldm(request);
+}
+
+void Interface::sendHRESET(open_power::occ::instanceID sbeInstanceId)
+{
+    if (sbeInstanceToEffecter.empty())
+    {
+        fetchEffecterInfo(PLDM_ENTITY_PROC, PLDM_OEM_IBM_SBE_MAINTENANCE_STATE,
+                          sbeInstanceToEffecter, SBEEffecterCount,
+                          sbeMaintenanceStatePosition);
+    }
+
+    auto effecterEntry = sbeInstanceToEffecter.find(sbeInstanceId);
+    if (effecterEntry == sbeInstanceToEffecter.end())
+    {
+        log<level::ERR>(
+            "pldm: Failed to find a matching effecter for SBE instance",
+            entry("SBE=%d", sbeInstanceId));
+        return;
+    }
+
+    uint8_t instanceId{};
+    if (!getMctpInstanceId(instanceId))
+    {
+        return;
+    }
+
+    // Prepare the SetStateEffecterStates request to HRESET the SBE
+    auto request = prepareSetEffecterReq(
+        instanceId, effecterEntry->second, SBEEffecterCount,
+        sbeMaintenanceStatePosition, SBE_RETRY_REQUIRED);
+
+    if (request.empty())
+    {
+        log<level::ERR>("pldm: SetStateEffecterStates HRESET request empty");
+        return;
+    }
+
+    sendPldm(request);
+}
+
+bool Interface::getMctpInstanceId(uint8_t& instanceId)
+{
     auto& bus = open_power::occ::utils::getBus();
     try
     {
@@ -301,19 +399,14 @@
     {
         log<level::ERR>("pldm: GetInstanceId returned error",
                         entry("ERROR=%s", e.what()));
-        return;
+        return false;
     }
 
-    // Prepare the SetStateEffecterStates request to reset the OCC
-    auto request = prepareSetEffecterReq(instanceId, effecterEntry->second,
-                                         effecterCount, bootRestartPosition);
+    return true;
+}
 
-    if (request.empty())
-    {
-        log<level::ERR>("pldm: SetStateEffecterStates request message empty");
-        return;
-    }
-
+void Interface::sendPldm(const std::vector<uint8_t>& request)
+{
     // Connect to MCTP scoket
     int fd = pldm_open();
     if (fd == -1)
@@ -321,6 +414,7 @@
         log<level::ERR>("pldm: Failed to connect to MCTP socket");
         return;
     }
+
     open_power::occ::FileDescriptor fileFd(fd);
 
     // Send the PLDM request message to HBRT
@@ -332,8 +426,7 @@
                                                                std::free};
     if (rc)
     {
-        log<level::ERR>("pldm: pldm_send_recv failed for OCC reset",
-                        entry("RC=%d", rc));
+        log<level::ERR>("pldm: pldm_send_recv failed", entry("RC=%d", rc));
     }
 
     uint8_t completionCode{};
@@ -347,8 +440,6 @@
             entry("RC=%d", rcDecode),
             entry("COMPLETION_CODE=%d", completionCode));
     }
-
-    return;
 }
 
 } // namespace pldm
diff --git a/pldm.hpp b/pldm.hpp
index 811ed47..3add821 100644
--- a/pldm.hpp
+++ b/pldm.hpp
@@ -17,11 +17,11 @@
 using EntityType = uint16_t;
 using EntityInstance = uint16_t;
 using EventState = uint8_t;
-using OccInstanceToEffecter = std::map<open_power::occ::instanceID, EffecterID>;
+using InstanceToEffecter = std::map<open_power::occ::instanceID, EffecterID>;
 using PdrList = std::vector<std::vector<uint8_t>>;
 using SensorID = uint16_t;
 using SensorOffset = uint8_t;
-using SensorToOCCInstance = std::map<SensorID, open_power::occ::instanceID>;
+using SensorToInstance = std::map<SensorID, open_power::occ::instanceID>;
 using TerminusID = uint8_t;
 
 /** @brief Hardcoded TID */
@@ -53,8 +53,10 @@
      *                        changes.
      */
     explicit Interface(
-        std::function<bool(open_power::occ::instanceID, bool)> callBack) :
+        std::function<bool(open_power::occ::instanceID, bool)> callBack,
+        std::function<void(open_power::occ::instanceID, bool)> sbeCallBack) :
         callBack(callBack),
+        sbeCallBack(sbeCallBack),
         pldmEventSignal(
             open_power::occ::utils::getBus(),
             MatchRules::type::signal() +
@@ -71,45 +73,46 @@
                       std::placeholders::_1))
     {}
 
-    /** @brief Fetch the OCC state sensor PDRs and populate the cache with
-     *         sensorId to OCC instance mapping information and the sensor
-     *         offset for Operational Running Status.
+    /** @brief Fetch the state sensor PDRs and populate the cache with
+     *         sensorId to OCC/SBE instance mapping information and the sensor
+     *         offset for the relevent state set.
      *
-     *  @param[in] pdrs - OCC state sensor PDRs
-     *  @param[out] sensorInstanceMap - map of sensorID to OCC instance
+     *  @param[in] stateSetId - the state set ID to look for
+     *  @param[out] sensorInstanceMap - map of sensorID to instance
      *  @param[out] sensorOffset - sensor offset of interested state set ID
      */
-    void fetchOCCSensorInfo(const PdrList& pdrs,
-                            SensorToOCCInstance& sensorInstanceMap,
-                            SensorOffset& sensorOffset);
+    void fetchSensorInfo(uint16_t stateSetId,
+                         SensorToInstance& sensorInstanceMap,
+                         SensorOffset& sensorOffset);
 
-    /** @brief Fetch the OCC state effecter PDRs and populate the cache with
-     *         OCC instance to EffecterID information.
+    /** @brief Fetch the OCC/SBE state effecter PDRs and populate the cache
+     *         with OCC/SBE instance to EffecterID information.
      *
-     *  @param[in] pdrs - OCC state effecter PDRs
-     *  @param[out] instanceToEffecterMap - map of OCC instance to effecterID
+     *  @param[in] entityId - the entity ID to query
+     *  @param[in] stateSetId - the state set ID to look for
+     *  @param[out] instanceToEffecterMap - map of instance to effecterID
      *  @param[out] count - sensor offset of interested state set ID
-     *  @param[out] bootRestartPos - position of Boot/Restart Cause stateSetID
+     *  @param[out] stateIdPos - position of the stateSetID
      */
-    void fetchOCCEffecterInfo(const PdrList& pdrs,
-                              OccInstanceToEffecter& instanceToEffecterMap,
-                              CompositeEffecterCount& count,
-                              uint8_t& bootRestartPos);
+    void fetchEffecterInfo(uint16_t entityId, uint16_t stateSetId,
+                           InstanceToEffecter& instanceToEffecterMap,
+                           CompositeEffecterCount& count, uint8_t& stateIdPos);
 
     /** @brief Prepare the request for SetStateEffecterStates command
      *
      *  @param[in] instanceId - PLDM instanceID
-     *  @param[in] instanceToEffecterMap - map of OCC instance to effecterID
-     *  @param[in] count - compositeEffecterCount for OCC reset effecter PDR
-     *  @param[in] bootRestartPos - position of Boot/Restart Cause stateSetID
+     *  @param[in] effecterId - the instance effecter ID
+     *  @param[in] effecterCount - compositeEffecterCount for the effecter PDR
+     *  @param[in] stateIdPos - position of the stateSetID
+     *  @param[in] stateSetValue - the value to set the state set to
      *
-     *  @return PLDM request message to be sent to host for OCC reset, empty
-     *          response in the case of failure.
+     *  @return PLDM request message to be sent to host for OCC reset or SBE
+     *          HRESET, empty response in the case of failure.
      */
     std::vector<uint8_t>
         prepareSetEffecterReq(uint8_t instanceId, EffecterID effecterId,
                               CompositeEffecterCount effecterCount,
-                              uint8_t bootRestartPos);
+                              uint8_t stateIdPos, uint8_t stateSetValue);
 
     /** @brief Send the PLDM message to reset the OCC
      *
@@ -118,12 +121,24 @@
      */
     void resetOCC(open_power::occ::instanceID occInstanceId);
 
+    /** @brief Send the PLDM message to perform the HRESET
+     *
+     *  @param[in] instanceID - SBE instance to HRESET
+     */
+    void sendHRESET(open_power::occ::instanceID sbeInstanceId);
+
   private:
     /** @brief Callback handler to be invoked when the state of the OCC
      *         changes
      */
     std::function<bool(open_power::occ::instanceID, bool)> callBack = nullptr;
 
+    /** @brief Callback handler to be invoked when the maintenance state of the
+     *         SBE changes
+     */
+    std::function<void(open_power::occ::instanceID, bool)> sbeCallBack =
+        nullptr;
+
     /** @brief Used to subscribe to D-Bus PLDM StateSensorEvent signal and
      *         processes if the event corresponds to OCC state change.
      */
@@ -134,25 +149,46 @@
 
     /** @brief PLDM Sensor ID to OCC Instance mapping
      */
-    SensorToOCCInstance sensorToOCCInstance;
+    SensorToInstance sensorToOCCInstance;
 
-    /** @brief Sensor offset of state set ID
+    /** @brief PLDM Sensor ID to SBE Instance mapping
+     */
+    SensorToInstance sensorToSBEInstance;
+
+    /** @brief Sensor offset of OCC state set ID
      * PLDM_STATE_SET_OPERATIONAL_RUNNING_STATUS in state sensor PDR.
      */
-    SensorOffset sensorOffset;
+    SensorOffset OCCSensorOffset;
+
+    /** @brief Sensor offset of the SBE state set ID
+     * PLDM_OEM_IBM_SBE_HRESET_STATE in state sensor PDR.
+     */
+    SensorOffset SBESensorOffset;
 
     /** @brief OCC Instance mapping to PLDM Effecter ID
      */
-    OccInstanceToEffecter occInstanceToEffecter;
+    InstanceToEffecter occInstanceToEffecter;
+
+    /** @brief SBE instance mapping to PLDM Effecter ID
+     */
+    InstanceToEffecter sbeInstanceToEffecter;
 
     /** @brief compositeEffecterCount for OCC reset state effecter PDR */
-    CompositeEffecterCount effecterCount = 0;
+    CompositeEffecterCount OCCEffecterCount = 0;
+
+    /** @brief compositeEffecterCount for SBE HRESET state effecter PDR */
+    CompositeEffecterCount SBEEffecterCount = 0;
 
     /** @brief Position of Boot/Restart Cause stateSetID in OCC state
      *         effecter PDR
      */
     uint8_t bootRestartPosition = 0;
 
+    /** @brief Position of the SBE maintenance stateSetID in the state
+     *         effecter PDR
+     */
+    uint8_t sbeMaintenanceStatePosition = 0;
+
     /** @brief When the OCC state changes host sends PlatformEventMessage
      *         StateSensorEvent, this function processes the D-Bus signal
      *         with the sensor event information and invokes the callback
@@ -189,6 +225,20 @@
     {
         return (occInstanceToEffecter.empty() ? false : true);
     }
+
+    /** @brief Query PLDM for the MCTP requester instance id
+     *
+     * @param[out] - the instance id
+     *
+     * @return true if the id was found and false if not
+     */
+    bool getMctpInstanceId(uint8_t& instanceId);
+
+    /** @brief Send the PLDM request
+     *
+     * @param[in] - the request data
+     */
+    void sendPldm(const std::vector<uint8_t>& request);
 };
 
 } // namespace pldm