diff --git a/extensions/openpower-pels/sbe_ffdc_handler.cpp b/extensions/openpower-pels/sbe_ffdc_handler.cpp
index a36b6cf..9e6a088 100644
--- a/extensions/openpower-pels/sbe_ffdc_handler.cpp
+++ b/extensions/openpower-pels/sbe_ffdc_handler.cpp
@@ -20,8 +20,10 @@
 #include "pel.hpp"
 #include "temporary_file.hpp"
 
+#include <ekb/hwpf/fapi2/include/return_code_defs.H>
 #include <fmt/format.h>
 
+#include <new>
 #include <phosphor-logging/log.hpp>
 
 namespace openpower
@@ -68,11 +70,87 @@
         if ((file.format == UserDataFormat::custom) &&
             (file.subType == sbeFFDCSubType))
         {
-            // TODO Process SBE file.
+            // Process SBE file.
+            parse(file.fd);
         }
     }
 }
 
+void SbeFFDC::parse(int fd)
+{
+    log<level::INFO>(
+        fmt::format("SBE FFDC file fd:({}), parsing started", fd).c_str());
+
+    uint32_t ffdcBufOffset = 0;
+    uint32_t pktCount = 0;
+    sbeFfdcPacketType ffdcPkt;
+
+    // get SBE FFDC data.
+    auto ffdcData = util::readFD(fd);
+    if (ffdcData.empty())
+    {
+        log<level::ERR>(
+            fmt::format("Empty SBE FFDC file fd:({}), skipping", fd).c_str());
+        return;
+    }
+
+    while ((ffdcBufOffset < ffdcData.size()) && (sbeMaxFfdcPackets != pktCount))
+    {
+        // Next un-extracted FFDC Packet
+        fapiFfdcBufType* ffdc =
+            reinterpret_cast<fapiFfdcBufType*>(ffdcData.data() + ffdcBufOffset);
+        auto magicBytes = ntohs(ffdc->magic_bytes);
+        auto lenWords = ntohs(ffdc->lengthinWords);
+        auto fapiRc = ntohl(ffdc->fapiRc);
+
+        auto msg = fmt::format("FFDC magic: {} length in words:{} Fapirc:{}",
+                               magicBytes, lenWords, fapiRc);
+        log<level::INFO>(msg.c_str());
+
+        if (magicBytes != ffdcMagicCode)
+        {
+            log<level::ERR>("Invalid FFDC magic code in Header: Skipping ");
+            return;
+        }
+        ffdcPkt.fapiRc = fapiRc;
+        // Not interested in the first 2 words (these are not ffdc)
+        auto pktLenWords = lenWords - (2 * ffdcPkgOneWord);
+        ffdcPkt.ffdcLengthInWords = pktLenWords;
+        if (pktLenWords)
+        {
+            // Memory freeing will be taking care by ffdcPkt structure
+            // destructor
+            ffdcPkt.ffdcData = new uint32_t[pktLenWords];
+            memcpy(ffdcPkt.ffdcData,
+                   ((reinterpret_cast<uint32_t*>(ffdc)) +
+                    (2 * ffdcPkgOneWord)), // skip first 2 words
+                   (pktLenWords * sizeof(uint32_t)));
+        }
+        else
+        {
+            log<level::ERR>("FFDC packet size is zero skipping");
+            return;
+        }
+
+        // SBE FFDC processing is not required for SBE Plat errors RCs.
+        // Plat errors processing is driven by SBE provided user data
+        // plugins, which need to link with PEL tool infrastructure.
+        if (ffdcPkt.fapiRc != fapi2::FAPI2_RC_PLAT_ERR_SEE_DATA)
+        {
+            process(ffdcPkt);
+        }
+        ffdcBufOffset += ffdc->lengthinWords;
+        ++pktCount;
+    }
+    if (pktCount == sbeMaxFfdcPackets)
+    {
+        log<level::ERR>(fmt::format("Received more than the limit of ({})"
+                                    " FFDC packets, processing only ({})",
+                                    sbeMaxFfdcPackets, pktCount)
+                            .c_str());
+    }
+}
+
 void SbeFFDC::process(const sbeFfdcPacketType& ffdcPkt)
 {
     using json = nlohmann::json;
diff --git a/extensions/openpower-pels/sbe_ffdc_handler.hpp b/extensions/openpower-pels/sbe_ffdc_handler.hpp
index f245947..bff206c 100644
--- a/extensions/openpower-pels/sbe_ffdc_handler.hpp
+++ b/extensions/openpower-pels/sbe_ffdc_handler.hpp
@@ -15,6 +15,47 @@
 // SBE FFDC sub type.
 constexpr uint8_t sbeFFDCSubType = 0xCB;
 
+/**
+ *   @brief FFDC Package structure and definitions based on SBE chip-op spec.
+ *
+ *   SBE FFDC Starts with a header word (Word 0) that has an unique magic
+ *   identifier code of 0xFFDC followed by the length of the FFDC package
+ *   including the header itself. Word 1 contains a sequence id ,
+ *   command-class and command fields.
+ *   The sequence id field is ignored on the BMC side.
+ *   Word 2 contains a 32 bit Return Code which acts like the key to the
+ *   contents of subsequent FFDC Data Words (0-N).
+ *
+ *   A FFDC package can typically contain debug data from either:
+ *    1. A failed hardware procedure (e.g. local variable values
+ *       at point of failure) or
+ *    2. SBE firmware (e.g. traces, attributes and other information).
+ *    ___________________________________________________________
+ *   |        |  Byte 0   |  Byte 1  |  Byte 2    |    Byte 3   |
+ *   |----------------------------------------------------------|
+ *   | Word 0 | Magic Bytes : 0xFFDC | Length in words (N+4)    |
+ *   | Word 1 | [Sequence ID]        | Command-Class | Command  |
+ *   | Word 2 |           Return Code 0..31                     |
+ *   | Word 3 |           FFDC Data – Word 0                    |
+ *   |  ...                                                     |
+ *   | Word N+3 |  FFDC Data – Word N                           |
+ *    -----------------------------------------------------------
+ **/
+
+constexpr uint32_t sbeMaxFfdcPackets = 20;
+constexpr uint32_t ffdcPkgOneWord = 1;
+const uint16_t ffdcMagicCode = 0xFFDC;
+
+typedef struct
+{
+    uint32_t magic_bytes : 16;
+    uint32_t lengthinWords : 16;
+    uint32_t seqId : 16;
+    uint32_t cmdClass : 8;
+    uint32_t cmd : 8;
+    uint32_t fapiRc;
+} __attribute__((packed)) fapiFfdcBufType;
+
 /** @class SbeFFDC
  *
  * @brief This class provides higher level interface to process SBE ffdc
@@ -89,6 +130,19 @@
 
   private:
     /**
+     * @brief Helper function to parse SBE FFDC file.
+     *        parsing is based on the FFDC structure definition
+     *        define initially in this file.
+     *
+     * @param fd  SBE ffdc file descriptor
+     *
+     * Any failure during the process stops the function
+     * execution to support the raw SBE FFDC data based
+     * PEL creation.
+     */
+    void parse(int fd);
+
+    /**
      * @brief Helper function to process SBE FFDC packet.
      * This function call libekb function to process the
      * FFDC packet and convert in to known format for PEL
@@ -103,6 +157,7 @@
      * PEL creation.
      */
     void process(const sbeFfdcPacketType& ffdcPkt);
+
     /**
      * @brief  Temporary files path information created as part of FFDC
      *         processing.