diff --git a/dump/dump_collect_main.cpp b/dump/dump_collect_main.cpp
index 319309a..d33fd30 100644
--- a/dump/dump_collect_main.cpp
+++ b/dump/dump_collect_main.cpp
@@ -77,14 +77,7 @@
 
     try
     {
-        if ((type == SBE_DUMP_TYPE_SBE) || (type == SBE_DUMP_TYPE_MSBE))
-        {
-            collectSBEDump(id, failingUnitId, pathStr, type);
-        }
-        else
-        {
-            dumpCollector.collectDump(type, id, failingUnitId, pathStr);
-        }
+        dumpCollector.collectDump(type, id, failingUnitId, pathStr);
     }
     catch (const std::exception& e)
     {
diff --git a/dump/sbe_dump_collector.cpp b/dump/sbe_dump_collector.cpp
index 8beda76..7e1a50c 100644
--- a/dump/sbe_dump_collector.cpp
+++ b/dump/sbe_dump_collector.cpp
@@ -24,6 +24,7 @@
 #include <filesystem>
 #include <format>
 #include <fstream>
+#include <map>
 #include <stdexcept>
 
 namespace openpower::dump::sbe_chipop
@@ -31,12 +32,25 @@
 
 using namespace phosphor::logging;
 using namespace openpower::dump::SBE;
+using namespace openpower::phal::dump;
 using Severity = sdbusplus::xyz::openbmc_project::Logging::server::Entry::Level;
 
 void SbeDumpCollector::collectDump(uint8_t type, uint32_t id,
-                                   uint64_t failingUnit,
+                                   uint32_t failingUnit,
                                    const std::filesystem::path& path)
 {
+    if ((type == SBE_DUMP_TYPE_SBE) || (type == SBE_DUMP_TYPE_MSBE))
+    {
+        collectSBEDump(id, failingUnit, path, type);
+        return;
+    }
+    collectHWHBDump(type, id, failingUnit, path);
+}
+
+void SbeDumpCollector::collectHWHBDump(uint8_t type, uint32_t id,
+                                       uint64_t failingUnit,
+                                       const std::filesystem::path& path)
+{
     lg2::error("Starting dump collection: type:{TYPE} id:{ID} "
                "failingUnit:{FAILINGUNIT}, path:{PATH}",
                "TYPE", type, "ID", id, "FAILINGUNIT", failingUnit, "PATH",
@@ -129,6 +143,78 @@
     lg2::info("Dump collection completed");
 }
 
+void SbeDumpCollector::collectSBEDump(uint32_t id, uint32_t failingUnit,
+                                      const std::filesystem::path& dumpPath,
+                                      const int sbeTypeId)
+{
+    lg2::info("Collecting SBE dump: path={PATH}, id={ID}, "
+              "chip position={FAILINGUNIT}",
+              "PATH", dumpPath.string().c_str(), "ID", id, "FAILINGUNIT",
+              failingUnit);
+
+    struct pdbg_target* proc_ody = nullptr;
+    struct pdbg_target* pibFsiTarget = nullptr;
+    std::string sbeChipType;
+
+    try
+    {
+        // Execute pre-collection steps and get the proc target
+        initializePdbgLibEkb();
+
+        proc_ody = getTargetFromFailingId(failingUnit, sbeTypeId);
+        if (PROC_SBE_DUMP == sbeTypeId)
+        {
+            pibFsiTarget = probeTarget(proc_ody, "pib", sbeTypeId);
+            sbeChipType = "_p10_";
+        }
+        else
+        {
+            pibFsiTarget = probeTarget(proc_ody, "fsi", sbeTypeId);
+            sbeChipType = "_ody_";
+        }
+    }
+    catch (const std::exception& e)
+    {
+        lg2::error("Failed to collect the SBE dump: {ERROR}", "ERROR",
+                   e.what());
+        throw;
+    }
+
+    std::stringstream ss;
+    ss << std::setw(8) << std::setfill('0') << id;
+
+    std::string baseFilename = ss.str() + ".0_" + std::to_string(failingUnit) +
+                               "_SbeData" + sbeChipType;
+
+    try
+    {
+        checkSbeState(pibFsiTarget, sbeTypeId);
+
+        executeSbeExtractRc(proc_ody, dumpPath, sbeTypeId);
+
+        // Collect various dumps
+        collectLocalRegDump(proc_ody, dumpPath, baseFilename, sbeTypeId);
+        collectPIBMSRegDump(proc_ody, dumpPath, baseFilename, sbeTypeId);
+        collectPIBMEMDump(proc_ody, dumpPath, baseFilename, sbeTypeId);
+        collectPPEState(proc_ody, dumpPath, baseFilename, sbeTypeId);
+
+        // Finalize the collection process and indicate successful completion
+        finalizeCollection(pibFsiTarget, dumpPath, true, sbeTypeId);
+
+        lg2::info("SBE dump collection completed successfully");
+    }
+    catch (const std::exception& e)
+    {
+        lg2::error("Failed to collect the SBE dump: {ERROR}", "ERROR",
+                   e.what());
+        // In case of any exception, attempt to finalize with a failure
+        // state
+        if (proc_ody)
+            finalizeCollection(pibFsiTarget, dumpPath, false, sbeTypeId);
+        throw;
+    }
+}
+
 void SbeDumpCollector::initializePdbg()
 {
     openpower::phal::pdbg::init();
diff --git a/dump/sbe_dump_collector.hpp b/dump/sbe_dump_collector.hpp
index c8a41cd..a912c57 100644
--- a/dump/sbe_dump_collector.hpp
+++ b/dump/sbe_dump_collector.hpp
@@ -45,6 +45,23 @@
     ~SbeDumpCollector() = default;
 
     /**
+     * @brief Drives all type of dump collection process from SBEs.
+     *
+     * Triggers SBE, Hardware/Hostboot dump collection process from SBEs.
+     * Internally calls private method collectHWHBDump(for Hardware/Hostboot
+     * dump) or collectSBEDump(for SBE dump) based on the parameter type's value
+     *
+     * @param type The type of dump which needs to be collected.
+     * @param id ID of the collected dump.
+     * @param failingUnit ID of the failing unit from which the dump is
+     * collected.
+     * @param path Path where the collected dump will be stored.
+     */
+    void collectDump(uint8_t type, uint32_t id, uint32_t failingUnit,
+                     const std::filesystem::path& path);
+
+  private:
+    /**
      * @brief Orchestrates the collection of dumps from all available SBEs.
      *
      * Initiates the process of collecting diagnostic dumps from SBEs. This
@@ -57,10 +74,24 @@
      * collection.
      * @param path The filesystem path where collected dumps should be stored.
      */
-    void collectDump(uint8_t type, uint32_t id, uint64_t failingUnit,
-                     const std::filesystem::path& path);
+    void collectHWHBDump(uint8_t type, uint32_t id, uint64_t failingUnit,
+                         const std::filesystem::path& path);
 
-  private:
+    /**
+     * @brief Execute HWPs to collect SBE dump.
+     *
+     * @param[in] id Id of the dump.
+     * @param[in] failingUnit Id of proc containing failing SBE.
+     * @param[in] dumpPath Path to stored the dump files.
+     * @param[in] sbeTypeId ID for SBE type i.e.; Odyssey or normal memory chip
+     *                                             0xA-->Normal SBE type,
+     * 0xB-->Odyssey SBE type Exceptions: PDBG_INIT_FAIL for any pdbg init
+     * related failure.
+     */
+    void collectSBEDump(uint32_t id, uint32_t failingUnit,
+                        const std::filesystem::path& dumpPath,
+                        const int sbeTypeId);
+
     /**
      * @brief Collects a dump from a single SBE.
      *
@@ -231,5 +262,4 @@
     void addLogDataToDump(uint32_t logId, std::string src, std::string chipName,
                           uint64_t chipPos, const std::filesystem::path& path);
 };
-
 } // namespace openpower::dump::sbe_chipop