Add sbe_psu FFDC error handling.

Turn sbe_psudd into singleton.
Add handle FFDCError function

Change-Id: If84bb2bafcca685c8d31c664f7005de056e96c4c
RTC: 144313
Reviewed-on: http://ralgit01.raleigh.ibm.com/gerrit1/31468
Reviewed-by: William G. Hoffa <wghoffa@us.ibm.com>
Tested-by: Jenkins Server <pfd-jenkins+hostboot@us.ibm.com>
Reviewed-by: Prachi Gupta <pragupta@us.ibm.com>
Tested-by: FSP CI Jenkins <fsp-CI-jenkins+hostboot@us.ibm.com>
Reviewed-by: Daniel M. Crowell <dcrowell@us.ibm.com>

6 files changed, 487 insertions, 50 deletions

diff --git a/src/usr/sbeio/makefile b/src/usr/sbeio/makefile
index 0f0fddd15..3fc386a3c 100644
--- a/src/usr/sbeio/makefile
+++ b/src/usr/sbeio/makefile
@@ -33,4 +33,6 @@ OBJS += sbe_fifodd.o
 OBJS += sbe_scomAccess.o
 OBJS += sbe_scomAccessdd.o
 
+SUBDIRS = test.d
+
 include ${ROOTPATH}/config.mk
diff --git a/src/usr/sbeio/sbe_coreStateControl.C b/src/usr/sbeio/sbe_coreStateControl.C
index 54f86d0a6..b449d6516 100644
--- a/src/usr/sbeio/sbe_coreStateControl.C
+++ b/src/usr/sbeio/sbe_coreStateControl.C
@@ -59,20 +59,21 @@ errlHndl_t startDeadmanLoop(const uint64_t i_waitTime )
 
     SBE_TRACD(ENTER_MRK "startDeadmanLoop waitTime=0x%x",i_waitTime);
 
-    psuCommand   l_psuCommand(
-         SBE_DMCONTROL_START | SBE_DMCONTROL_RESPONSE_REQUIRED, //control flags
-         SBE_PSU_CLASS_CORE_STATE,                              //command class
-         SBE_CMD_CONTROL_DEADMAN_LOOP);                         //command
-    psuResponse  l_psuResponse;
+    SbePsu::psuCommand   l_psuCommand(
+         SbePsu::SBE_DMCONTROL_START |
+             SbePsu::SBE_DMCONTROL_RESPONSE_REQUIRED,      //control flags
+         SbePsu::SBE_PSU_CLASS_CORE_STATE,                 //command class
+         SbePsu::SBE_CMD_CONTROL_DEADMAN_LOOP);            //command
+    SbePsu::psuResponse  l_psuResponse;
 
     // set up PSU command message
     l_psuCommand.cd1_ControlDeadmanLoop_WaitTime = i_waitTime;
 
-    errl = performPsuChipOp(&l_psuCommand,
+    errl = SBEIO::SbePsu::getTheInstance().performPsuChipOp(&l_psuCommand,
                             &l_psuResponse,
-                            MAX_PSU_SHORT_TIMEOUT_NS,
-                            SBE_DMCONTROL_START_REQ_USED_REGS,
-                            SBE_DMCONTROL_START_RSP_USED_REGS);
+                            SbePsu::MAX_PSU_SHORT_TIMEOUT_NS,
+                            SbePsu::SBE_DMCONTROL_START_REQ_USED_REGS,
+                            SbePsu::SBE_DMCONTROL_START_RSP_USED_REGS);
 
     SBE_TRACD(EXIT_MRK "startDeadmanLoop");
 
@@ -93,17 +94,18 @@ errlHndl_t stopDeadmanLoop()
 
     SBE_TRACD(ENTER_MRK "stopDeadmanLoop");
 
-    psuCommand   l_psuCommand(
-         SBE_DMCONTROL_STOP + SBE_DMCONTROL_RESPONSE_REQUIRED, //control flags
-         SBE_PSU_CLASS_CORE_STATE,                             //command class
-         SBE_CMD_CONTROL_DEADMAN_LOOP);                        //comand
-    psuResponse  l_psuResponse;
+    SbePsu::psuCommand   l_psuCommand(
+         SbePsu::SBE_DMCONTROL_STOP +
+             SbePsu::SBE_DMCONTROL_RESPONSE_REQUIRED,        //control flags
+         SbePsu::SBE_PSU_CLASS_CORE_STATE,                   //command class
+         SbePsu::SBE_CMD_CONTROL_DEADMAN_LOOP);              //comand
+    SbePsu::psuResponse  l_psuResponse;
 
-    errl = performPsuChipOp(&l_psuCommand,
+    errl = SBEIO::SbePsu::getTheInstance().performPsuChipOp(&l_psuCommand,
                             &l_psuResponse,
-                            MAX_PSU_SHORT_TIMEOUT_NS,
-                            SBE_DMCONTROL_STOP_REQ_USED_REGS,
-                            SBE_DMCONTROL_STOP_RSP_USED_REGS);
+                            SbePsu::MAX_PSU_SHORT_TIMEOUT_NS,
+                            SbePsu::SBE_DMCONTROL_STOP_REQ_USED_REGS,
+                            SbePsu::SBE_DMCONTROL_STOP_RSP_USED_REGS);
 
     SBE_TRACD(EXIT_MRK "stopDeadmanLoop");
 
diff --git a/src/usr/sbeio/sbe_psudd.C b/src/usr/sbeio/sbe_psudd.C
index d5d9d4e7b..f1e200c34 100644
--- a/src/usr/sbeio/sbe_psudd.C
+++ b/src/usr/sbeio/sbe_psudd.C
@@ -36,10 +36,13 @@
 #include <errl/errludtarget.H>
 #include <targeting/common/target.H>
 #include <targeting/common/targetservice.H>
+#include <errl/errlreasoncodes.H>
 #include <sbeio/sbeioreasoncodes.H>
 #include <initservice/initserviceif.H> //@todo-RTC:149454-Remove
 #include <sbeio/sbe_psudd.H>
 #include <arch/ppc.H>
+#include <util/utilbyte.H>
+#include <kernel/pagemgr.H>
 
 trace_desc_t* g_trac_sbeio;
 TRAC_INIT(&g_trac_sbeio, SBEIO_COMP_NAME, 6*KILOBYTE, TRACE::BUFFER_SLOW);
@@ -51,11 +54,57 @@ TRAC_INIT(&g_trac_sbeio, SBEIO_COMP_NAME, 6*KILOBYTE, TRACE::BUFFER_SLOW);
 
 using namespace ERRORLOG;
 
-//TODO RTC 144313 implement error recovery and ffdc.
-
 namespace SBEIO
 {
 
+SbePsu & SbePsu::getTheInstance()
+{
+    return Singleton<SbePsu>::instance();
+}
+
+/**
+ * @brief  Constructor
+ **/
+SbePsu::SbePsu()
+{
+    iv_ffdcPackageBuffer = PageManager::allocatePage(ffdcPackageSize, true);
+    initFFDCPackageBuffer();
+
+    /*
+    * TODO RTC 164405
+    *
+    * call performPsuChipOp to tell SBE where to write when SBE is ready
+    *
+    * psuCommand   l_psuCommand(
+    *         SBE_REQUIRE_RESPONSE,
+    *         SBE_PSU_GENERIC_MESSAGE,
+    *         SBE_CMD_CONTROL_SYSTEM_CONFIG);
+    *
+    * psuResponse  l_psuResponse;
+    *
+    * // Create FFDCPackage struct in psuCommand union
+    * uint64_t cd4_FFDCPackage_MbxReg2reserved = &iv_ffdcPackageBuffer;
+    *
+    * performPsuChipOp(&l_psuCommand,
+    *        &l_psuResponse,
+    *        MAX_PSU_SHORT_TIMEOUT_NS,
+    *        SBE_SYSTEM_CONFIG_REQ_USED_REGS,
+    *        SBE_SYSTEM_CONFIG_RSP_USED_REGS);
+    *
+    */
+}
+
+/**
+ * @brief  Destructor
+ **/
+SbePsu::~SbePsu()
+{
+    if(iv_ffdcPackageBuffer != NULL)
+    {
+        PageManager::freePage(iv_ffdcPackageBuffer);
+    }
+}
+
 /**
  * @brief perform SBE PSU chip-op
  *
@@ -65,7 +114,7 @@ namespace SBEIO
  * @param[in]  i_reqMsgs      4 bit mask telling which regs to write
  * @param[in]  i_rspMsgs      4 bit mask telling which regs to read
  */
-errlHndl_t performPsuChipOp(psuCommand     * i_pPsuRequest,
+errlHndl_t SbePsu::performPsuChipOp(psuCommand     * i_pPsuRequest,
                             psuResponse    * o_pPsuResponse,
                             const uint64_t   i_timeout,
                             uint8_t          i_reqMsgs,
@@ -155,9 +204,9 @@ errlHndl_t performPsuChipOp(psuCommand     * i_pPsuRequest,
 /**
  * @brief write PSU Request message
  */
-errlHndl_t writeRequest(TARGETING::Target * i_target,
-                        psuCommand        * i_pPsuRequest,
-                        uint8_t             i_reqMsgs)
+errlHndl_t SbePsu::writeRequest(TARGETING::Target * i_target,
+                                psuCommand        * i_pPsuRequest,
+                                uint8_t             i_reqMsgs)
 {
     errlHndl_t errl = NULL;
     static uint16_t l_seqID = 0;
@@ -203,7 +252,8 @@ errlHndl_t writeRequest(TARGETING::Target * i_target,
                                  SBEIO_PSU_NOT_READY,
                                  i_pPsuRequest->mbxReg0,
                                  l_data);
-            //TODO RTC 144313 review callouts and ffdc
+
+            handleFFDCError(errl);
             errl->addProcedureCallout(HWAS::EPUB_PRC_HB_CODE,
                                  HWAS::SRCI_PRIORITY_HIGH);
             errl->collectTrace(SBEIO_COMP_NAME);
@@ -246,11 +296,11 @@ errlHndl_t writeRequest(TARGETING::Target * i_target,
 /**
  * @brief Read PSU response messages
  */
-errlHndl_t readResponse(TARGETING::Target  * i_target,
-                        psuCommand         * i_pPsuRequest,
-                        psuResponse        * o_pPsuResponse,
-                        const uint64_t       i_timeout,
-                        uint8_t              i_rspMsgs)
+errlHndl_t SbePsu::readResponse(TARGETING::Target  * i_target,
+                                psuCommand         * i_pPsuRequest,
+                                psuResponse        * o_pPsuResponse,
+                                const uint64_t       i_timeout,
+                                uint8_t              i_rspMsgs)
 {
     errlHndl_t errl = NULL;
 
@@ -321,7 +371,8 @@ errlHndl_t readResponse(TARGETING::Target  * i_target,
                                  SBEIO_PSU_RESPONSE_ERROR,
                                  i_pPsuRequest->mbxReg0,
                                  o_pPsuResponse->mbxReg4);
-            //TODO RTC 144313 review callouts and ffdc
+
+            handleFFDCError(errl);
             errl->addProcedureCallout(HWAS::EPUB_PRC_HB_CODE,
                                  HWAS::SRCI_PRIORITY_HIGH);
             errl->collectTrace(SBEIO_COMP_NAME);
@@ -342,8 +393,8 @@ errlHndl_t readResponse(TARGETING::Target  * i_target,
 /**
  * @brief poll for PSU to complete command
  */
-errlHndl_t pollForPsuComplete(TARGETING::Target * i_target,
-                              const uint64_t i_timeout)
+errlHndl_t SbePsu::pollForPsuComplete(TARGETING::Target * i_target,
+                                      const uint64_t i_timeout)
 {
     errlHndl_t errl = NULL;
 
@@ -385,7 +436,8 @@ errlHndl_t pollForPsuComplete(TARGETING::Target * i_target,
                                  SBEIO_PSU_RESPONSE_TIMEOUT,
                                  i_timeout,
                                  0);
-            //TODO RTC 144313 review callouts and ffdc
+
+            handleFFDCError(errl);
             errl->addProcedureCallout(HWAS::EPUB_PRC_HB_CODE,
                                  HWAS::SRCI_PRIORITY_HIGH);
             errl->collectTrace(SBEIO_COMP_NAME);
@@ -418,10 +470,10 @@ errlHndl_t pollForPsuComplete(TARGETING::Target * i_target,
 /**
  * @brief read Scom
  */
-errlHndl_t readScom(TARGETING::Target * i_target,
-                     uint64_t   i_addr,
-                     uint64_t * o_pData,
-                     bool       i_trace)
+errlHndl_t SbePsu::readScom(TARGETING::Target * i_target,
+                             uint64_t   i_addr,
+                             uint64_t * o_pData,
+                             bool       i_trace)
 {
     errlHndl_t errl = NULL;
 
@@ -444,9 +496,9 @@ errlHndl_t readScom(TARGETING::Target * i_target,
 /**
  * @brief write Scom
  */
-errlHndl_t writeScom(TARGETING::Target * i_target,
-                     uint64_t   i_addr,
-                     uint64_t * i_pData)
+errlHndl_t SbePsu::writeScom(TARGETING::Target * i_target,
+                             uint64_t   i_addr,
+                             uint64_t * i_pData)
 {
     errlHndl_t errl = NULL;
 
@@ -462,4 +514,131 @@ errlHndl_t writeScom(TARGETING::Target * i_target,
     return errl;
 }
 
+/**
+ * @brief zero out FFDC Package Buffer
+ */
+
+void SbePsu::initFFDCPackageBuffer()
+{
+    memset(iv_ffdcPackageBuffer, 0x00, PAGESIZE * ffdcPackageSize);
+}
+
+/**
+ * @brief populate FFDC package buffer
+ * @param[in]  i_data        FFDC error data
+ * @param[in]  i_len         data buffer len to copy
+ */
+void SbePsu::writeFFDCBuffer( void * i_data, uint8_t i_len) {
+    if(i_len <= PAGESIZE * ffdcPackageSize)
+    {
+        initFFDCPackageBuffer();
+        memcpy(iv_ffdcPackageBuffer, i_data, i_len);
+    }
+    else
+    {
+        SBE_TRACF(ERR_MRK"writeFFDCBuffer: Buffer size too large: %d",
+                      i_len);
+    }
+}
+
+/**
+ * @brief Read FFDC package(s) iv_ffdcPackageBuffer
+ *
+ * @param[in]  io_errl Error entry object to inject FFDC errors
+ *
+ * FFDC package according to the SBE Interface Specification:
+ * Dword 0:
+ *     byte 0,1: Magic Byte: 0xFFDC
+ *     byte 2,3: Length in words (N + 6)
+ *     byte 4,5: Sequence Id
+ *     byte 6  : Command Class
+ *     byte 7  : Command
+ * Dword 1:
+ *     byte 0-3: Return Code
+ *     byte 4-7: Word 0
+ * Dword M:
+ *     byte 0-3: Word N - 1
+ *     byte 4-7: Word N
+ */
+
+bool SbePsu::handleFFDCError(ERRORLOG::ErrlEntry * io_errl)
+{
+    uint16_t l_magicByte = 0x00;
+    uint8_t            i = 0;
+    bool              rc = true;
+
+    SBE_TRACD(ENTER_MRK "handleFFDCError");
+    do {
+        // Magic Byte is 1st 2 bytes
+        l_magicByte = UtilByte::bufferTo16uint(
+                    static_cast<char *>(iv_ffdcPackageBuffer) + i);
+
+        if(l_magicByte == ffdcMagicByte)
+        {
+            // Length is next 2 bytes (in words, each word is 4 bytes)
+            uint16_t l_packageLen = UtilByte::bufferTo16uint(
+                    static_cast<char *>(iv_ffdcPackageBuffer) + (i + 2));
+            // In FFDC packet, byte 2 & byte 3 holds the length in words,
+            // which is 6 bytes less than the total package length.
+            uint8_t l_words = l_packageLen - ffdcPadLen;
+            uint8_t l_wordLen = ffdcWordLen * l_words;
+            SBE_TRACD(INFO_MRK"handleFFDCError: Package length: %d, Words: %d", l_packageLen, l_words);
+
+            // Check to see if what we're copying is beyond the buffer size
+            if((uint8_t) (i + wordPadding + l_wordLen) >
+                  PAGESIZE * ffdcPackageSize)
+            {
+                SBE_TRACF(ERR_MRK"handleFFDCError: FFDC Package buffer overflow detected.");
+                rc = false;
+                break;
+            }
+            else
+            {
+                // Extract the words and add to errl
+                void * l_wordBuffer = (void *) malloc(l_wordLen);
+                if(l_wordBuffer == NULL)
+                {
+                    SBE_TRACF(ERR_MRK"handleFFDCError: Failure to allocate memory.");
+                    rc = false;
+                    break;
+                }
+                // Copy data from ffdcPackageBuffer to wordBuffer
+                // starting at 12th byte from current pointer
+                memcpy(static_cast<char *>(iv_ffdcPackageBuffer) + wordPadding,
+                                           l_wordBuffer, l_wordLen);
+
+                ErrlUD *l_errlud = io_errl->addFFDC( SBE_COMP_ID,
+                               l_wordBuffer,
+                               sizeof(l_wordBuffer),
+                               0,                           // version
+                               ERRL_UDT_NOFORMAT,           // subversion
+                               false );
+
+                if(l_errlud == NULL)
+                {
+                    SBE_TRACF(ERR_MRK"handleFFDCError: Failure to add FFDC to error log.");
+                    rc = false;
+                }
+
+                free(l_wordBuffer);
+            }
+            // Skip length of whole package
+            i += l_wordLen + wordPadding;
+        }
+        else
+        {
+            SBE_TRACD(ERR_MRK"handleFFDCError: Invalid FFDC Magic Byte: 0x%04lx",
+                      l_magicByte);
+            break;
+        }
+    } while (l_magicByte != 0x00);
+
+    // zero out the whole thing
+    initFFDCPackageBuffer();
+
+    SBE_TRACD(EXIT_MRK "handleFFDCError");
+    return rc;
+
+}
+
 } //end of namespace SBEIO
diff --git a/src/usr/sbeio/sbe_systemConfig.C b/src/usr/sbeio/sbe_systemConfig.C
index 64774c64c..1e9a00a26 100644
--- a/src/usr/sbeio/sbe_systemConfig.C
+++ b/src/usr/sbeio/sbe_systemConfig.C
@@ -63,20 +63,20 @@ namespace SBEIO
 
         SBE_TRACD(ENTER_MRK "sending system configuration from HB -> SBE  i_systemConfig=0x%x",i_systemConfig);
 
-        psuCommand   l_psuCommand(
-                                  SBE_REQUIRE_RESPONSE,             //control flags
-                                  SBE_PSU_GENERIC_MESSAGE,          //command class
-                                  SBE_CMD_CONTROL_SYSTEM_CONFIG);   //command
-        psuResponse  l_psuResponse;
+        SbePsu::psuCommand   l_psuCommand(
+                                  SbePsu::SBE_REQUIRE_RESPONSE,  //control flags
+                                  SbePsu::SBE_PSU_GENERIC_MESSAGE, //command class
+                                  SbePsu::SBE_CMD_CONTROL_SYSTEM_CONFIG); //command
+        SbePsu::psuResponse  l_psuResponse;
 
         // set up PSU command message
         l_psuCommand.cd2_SetSystemConfig_SystemFabricIdMap = i_systemConfig;
 
-        errl = performPsuChipOp(&l_psuCommand,
+        errl =  SBEIO::SbePsu::getTheInstance().performPsuChipOp(&l_psuCommand,
                                 &l_psuResponse,
-                                MAX_PSU_SHORT_TIMEOUT_NS,
-                                SBE_SYSTEM_CONFIG_REQ_USED_REGS,
-                                SBE_SYSTEM_CONFIG_RSP_USED_REGS);
+                                SbePsu::MAX_PSU_SHORT_TIMEOUT_NS,
+                                SbePsu::SBE_SYSTEM_CONFIG_REQ_USED_REGS,
+                                SbePsu::SBE_SYSTEM_CONFIG_RSP_USED_REGS);
 
         SBE_TRACD(EXIT_MRK "sendSystemConfig");
 
diff --git a/src/usr/sbeio/test/makefile b/src/usr/sbeio/test/makefile
new file mode 100644
index 000000000..2017d8aab
--- /dev/null
+++ b/src/usr/sbeio/test/makefile
@@ -0,0 +1,33 @@
+# IBM_PROLOG_BEGIN_TAG
+# This is an automatically generated prolog.
+#
+# $Source: src/usr/sbeio/test/makefile $
+#
+# OpenPOWER HostBoot Project
+#
+# Contributors Listed Below - COPYRIGHT 2011,2016
+# [+] International Business Machines Corp.
+#
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# permissions and limitations under the License.
+#
+# IBM_PROLOG_END_TAG
+ROOTPATH = ../../../..
+
+EXTRAINCDIR += ${ROOTPATH}/src/usr/sbeio/
+
+MODULE = testsbeio
+
+TESTS = *.H
+
+include ${ROOTPATH}/config.mk
diff --git a/src/usr/sbeio/test/sbe_ffdctest.H b/src/usr/sbeio/test/sbe_ffdctest.H
new file mode 100644
index 000000000..51105f997
--- /dev/null
+++ b/src/usr/sbeio/test/sbe_ffdctest.H
@@ -0,0 +1,221 @@
+/* IBM_PROLOG_BEGIN_TAG                                                   */
+/* This is an automatically generated prolog.                             */
+/*                                                                        */
+/* $Source: src/usr/sbeio/test/sbe_ffdctest.H $                           */
+/*                                                                        */
+/* OpenPOWER HostBoot Project                                             */
+/*                                                                        */
+/* Contributors Listed Below - COPYRIGHT 2014,2016                        */
+/* [+] International Business Machines Corp.                              */
+/*                                                                        */
+/*                                                                        */
+/* Licensed under the Apache License, Version 2.0 (the "License");        */
+/* you may not use this file except in compliance with the License.       */
+/* You may obtain a copy of the License at                                */
+/*                                                                        */
+/*     http://www.apache.org/licenses/LICENSE-2.0                         */
+/*                                                                        */
+/* Unless required by applicable law or agreed to in writing, software    */
+/* distributed under the License is distributed on an "AS IS" BASIS,      */
+/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        */
+/* implied. See the License for the specific language governing           */
+/* permissions and limitations under the License.                         */
+/*                                                                        */
+/* IBM_PROLOG_END_TAG                                                     */
+#ifndef __SBE_FFDCTEST_H
+#define __SBE_FFDCTEST_H
+
+/**
+ *  @file sbe_ffdctest.H
+ *
+ *  @brief Test cases for sbe/hb ffdc package exchange
+*/
+
+#include <cxxtest/TestSuite.H>
+#include <errl/errlentry.H>
+#include <errl/errlmanager.H>
+#include <sbeio/sbe_psudd.H>
+
+extern trace_desc_t* g_trac_sbeio;
+
+class SbeFFDCTest : public CxxTest::TestSuite, public SBEIO::SbePsu
+{
+  public:
+
+      /**
+       *  @brief Test with zero data
+       */
+      void testSBEFFDC1(void)
+      {
+           TS_TRACE(ENTER_MRK "sbeioTestFFDC test 1: no data");
+
+           errlHndl_t l_errl = new ERRORLOG::ErrlEntry(
+                   ERRORLOG::ERRL_SEV_UNRECOVERABLE,
+                   0,
+                   0,
+                   0,
+                   0);
+
+           if(!SBEIO::SbePsu::handleFFDCError(l_errl))
+           {
+               TS_FAIL(EXIT_MRK "sbeioTestFFDC test 1 failed.");
+           }
+
+           delete l_errl;
+           TS_TRACE(EXIT_MRK "sbeioTestFFDC test 1: no data");
+      }
+
+      /**
+       *  @brief Test with valid magic byte, 1 package, 1 word data
+       */
+      void testSBEFFDC2(void)
+      {
+           uint8_t data[16] = {
+               255, 220,         // magic byte
+               0, 7,             // length of 1 word + 6
+               0, 1,             // arbitrary sequence ID
+               1, 1,             // arbitrary command class and commamd
+               0, 1, 0, 1,       // arbitrary return code
+               1, 1, 1, 1        // arbitrary data
+           };
+
+           TS_TRACE(ENTER_MRK "sbeioTestFFDC test 2: 1 package, 1 word data");
+
+           errlHndl_t l_errl = new ERRORLOG::ErrlEntry(
+                   ERRORLOG::ERRL_SEV_UNRECOVERABLE,
+                   0,
+                   0,
+                   0,
+                   0);
+
+           SBEIO::SbePsu::writeFFDCBuffer(&data, 16);
+           if(!SBEIO::SbePsu::handleFFDCError(l_errl))
+           {
+               TS_FAIL(EXIT_MRK "sbeioTestFFDC test 2 failed.");
+           }
+
+           delete l_errl;
+           TS_TRACE(EXIT_MRK "sbeioTestFFDC test 2: 1 package, 1 word data");
+      }
+
+      /**
+       *  @brief Test with valid magic byte, 1 package, 2 word data
+       */
+      void testSBEFFDC3(void)
+      {
+
+           uint8_t data[20] = {
+               255, 220,        // magic byte
+               0, 8,            // length of 2 word + 6
+               0, 2,            // arbitrary sequence ID
+               1, 1,            // arbitrary command class and commamd
+               0, 1, 0, 1,      // arbitrary return code
+               1, 1, 1, 1,      // arbitrary data
+               1, 1, 1, 1       // arbitrary data
+           };
+
+           errlHndl_t l_errl = new ERRORLOG::ErrlEntry(
+                   ERRORLOG::ERRL_SEV_UNRECOVERABLE,
+                   0,
+                   0,
+                   0,
+                   0);
+           TS_TRACE(ENTER_MRK "sbeioTestFFDC test 3: 1 package, 2 word data");
+
+           SBEIO::SbePsu::writeFFDCBuffer(&data, 20);
+           if(!SBEIO::SbePsu::handleFFDCError(l_errl))
+           {
+               TS_FAIL(EXIT_MRK "sbeioTestFFDC test 3 failed.");
+           }
+
+           delete l_errl;
+           TS_TRACE(EXIT_MRK "sbeioTestFFDC test 3: 1 package, 2 word data");
+
+      }
+
+      /**
+       *  @brief Test with valid magic byte, 2 package
+       */
+      void testSBEFFDC4(void)
+      {
+
+           uint8_t data[36] = {
+               255, 220,         // magic byte
+               0, 8,             // length of 1 word + 6
+               0, 2,             // arbitrary sequence ID
+               1, 1,             // arbitrary command class and commamd
+               0, 1, 0, 1,       // arbitrary return code
+               1, 1, 1, 1,       // arbitrary data
+               1, 1, 1, 1,
+               255, 220,         // package 2
+               0, 7,             // length of 1 word + 6
+               0, 2,             // arbitrary sequence ID
+               1, 1,             // arbitrary command class and commamd
+               0, 1, 0, 1,       // arbitrary return code
+               2, 2, 2, 2
+           };
+
+           TS_TRACE(ENTER_MRK "sbeioTestFFDC test 4: 2 packages, 2 word data");
+
+           errlHndl_t l_errl = new ERRORLOG::ErrlEntry(
+                   ERRORLOG::ERRL_SEV_UNRECOVERABLE,
+                   0,
+                   0,
+                   0,
+                   0);
+           SBEIO::SbePsu::writeFFDCBuffer(&data, 36);
+           if(!SBEIO::SbePsu::handleFFDCError(l_errl))
+           {
+               TS_FAIL(EXIT_MRK "sbeioTestFFDC test 4 failed.");
+           }
+
+           delete l_errl;
+           TS_TRACE(EXIT_MRK "sbeioTestFFDC test 4: 2 packages, 2 word data");
+
+      }
+      /**
+       *  @brief Test with valid magic byte, 2 package, 2nd magic byte is bad
+       */
+      void testSBEFFDC5(void)
+      {
+
+           uint8_t data[40] = {
+               255, 220,          // magic byte
+               0, 8,              // length of 1 word + 6
+               0, 2,              // arbitrary sequence ID
+               1, 1,              // arbitrary command class and commamd
+               0, 1, 0, 1,        // arbitrary return code
+               1, 1, 1, 1,        // arbitrary data
+               1, 1, 1, 1,
+               220, 220,          // package 2 - bad magic byte
+               0, 7,              // length of 1 word + 6
+               0, 2,              // arbitrary sequence ID
+               1, 1,              // arbitrary command class and commamd
+               0, 1, 0, 1,        // arbitrary return code
+               1, 1, 1, 1,        // arbitrary data
+               2, 2, 2, 2
+           };
+
+           TS_TRACE(ENTER_MRK"sbeioTestFFDC test 5:\
+                   2 packages, bad 2nd magic byte");
+
+           errlHndl_t l_errl = new ERRORLOG::ErrlEntry(
+                   ERRORLOG::ERRL_SEV_UNRECOVERABLE,
+                   0,
+                   0,
+                   0,
+                   0);
+           SBEIO::SbePsu::writeFFDCBuffer(&data, 40);
+           if(!SBEIO::SbePsu::handleFFDCError(l_errl))
+           {
+               TS_FAIL(EXIT_MRK "sbeioTestFFDC test 5 failed.");
+           }
+
+           delete l_errl;
+           TS_TRACE(EXIT_MRK"sbeioTestFFDC test 5:\
+                   2 packages, bad 2nd magic byte");
+
+      }
+};
+
+#endif