Removed Collect FFDC & Abort State from SM implementation

Change-Id: Iefb1be8bdb33497814e529d44df2422334303085
Reviewed-on: http://ralgit01.raleigh.ibm.com/gerrit1/29235
Tested-by: Jenkins Server <pfd-jenkins+hostboot@us.ibm.com>
Tested-by: FSP CI Jenkins <fsp-CI-jenkins+hostboot@us.ibm.com>
Reviewed-by: Shakeeb A. Pasha B K <shakeebbk@in.ibm.com>
Reviewed-by: Sachin Gupta <sgupta2m@in.ibm.com>

9 files changed, 63 insertions, 210 deletions

diff --git a/src/sbefw/sbe_sp_intf.H b/src/sbefw/sbe_sp_intf.H
index b983b307..e58cb7bf 100644
--- a/src/sbefw/sbe_sp_intf.H
+++ b/src/sbefw/sbe_sp_intf.H
@@ -72,7 +72,6 @@ static const uint8_t SBE_CMD_UNKNOWN = 0x00;
 enum sbeIplControlCommands
 {
     SBE_CMD_EXECUTE_ISTEP      = 0x01, /* Execute istep */
-    SBE_CMD_CONTINUE_BOOT  = 0x02, /* Continue SBE Boot */
 };
 
 /**
@@ -160,7 +159,6 @@ enum sbeGenericMessageCommands
     SBE_CMD_GET_SBE_FFDC          = 0x01, /* Get FFDC */
     SBE_CMD_GET_SBE_CAPABILITIES  = 0x02, /* GET SBE capabilities */
     SBE_CMD_GET_FREQ_SUPPORTED    = 0x03, /* Get Supported frequencies */
-    SBE_CMD_ABORT                 = 0x05, /* Sbe Abort */
     SBE_CMD_QUIESCE               = 0x06, /* Sbe Quiesce */
 };
 
diff --git a/src/sbefw/sbecmdiplcontrol.C b/src/sbefw/sbecmdiplcontrol.C
index ea08419f..789d5374 100644
--- a/src/sbefw/sbecmdiplcontrol.C
+++ b/src/sbefw/sbecmdiplcontrol.C
@@ -689,68 +689,6 @@ ReturnCode istepNoOp( sbeIstepHwp_t i_hwp)
     return FAPI2_RC_SUCCESS ;
 }
 
-// Only allowed in PLCK Mode, since FFDC State mode is set only in PLCK
-//----------------------------------------------------------------------------
-uint32_t sbeContinueBoot (uint8_t *i_pArg)
-{
-    #define SBE_FUNC "sbeContinueBoot "
-    uint32_t rc = SBE_SEC_OPERATION_SUCCESSFUL;
-    uint32_t len = 0;
-    sbeRespGenHdr_t respHdr;
-    respHdr.init();
-
-    do
-    {
-        // Dequeue the EOT entry as no more data is expected.
-        rc = sbeUpFifoDeq_mult (len, NULL);
-        if(rc != SBE_SEC_OPERATION_SUCCESSFUL)
-        {
-            // let command processor routine handle the RC
-            break;
-        }
-
-        uint32_t distance = 1;
-        len = sizeof(respHdr)/sizeof(uint32_t);
-        rc = sbeDownFifoEnq_mult ( len, ( uint32_t *) &respHdr);
-        if (rc)
-        {
-            break;
-        }
-        distance += len;
-
-        len = sizeof(distance)/sizeof(uint32_t);
-        rc = sbeDownFifoEnq_mult ( len, &distance);
-        if (rc)
-        {
-            break;
-        }
-        rc = sbeDownFifoSignalEot();
-        if (rc)
-        {
-            break;
-        }
-
-        // Expecting this to be in PLCK Mode and not in Istep mode
-        if(SbeRegAccess::theSbeRegAccess().isDestBitRuntime())
-        {
-            (void)SbeRegAccess::theSbeRegAccess().stateTransition(
-                                    SBE_CONTINUE_BOOT_RUNTIME_EVENT);
-            // Nothing to do here.
-        }
-        else
-        {
-            SBE_INFO(SBE_FUNC"Continuous IPL Mode set... IPLing");
-            (void)SbeRegAccess::theSbeRegAccess().stateTransition(
-                                    SBE_CONTINUE_BOOT_PLCK_EVENT);
-            sbeDoContinuousIpl();
-        }
-    }while(0);
-
-    SBE_DEBUG(SBE_FUNC "RC = 0x%08X", rc);
-    return rc;
-    #undef SBE_FUNC
-}
-
 //----------------------------------------------------------------------------
 void sbeDoContinuousIpl()
 {
diff --git a/src/sbefw/sbecmdiplcontrol.H b/src/sbefw/sbecmdiplcontrol.H
index 07deac98..3a084065 100644
--- a/src/sbefw/sbecmdiplcontrol.H
+++ b/src/sbefw/sbecmdiplcontrol.H
@@ -48,17 +48,6 @@ namespace fapi2
   */
 uint32_t sbeHandleIstep(uint8_t *i_pArg);
 
-
-/**
-  * @brief  Handles Sbe continue boot after collect ffdc chip-op (0xA102)
-  *
-  * @param[in] i_pArg Buffer to be passed to the function (not used as of now)
-  *
-  * @return    Rc from the FIFO access utility
-  */
-uint32_t sbeContinueBoot(uint8_t *i_pArg);
-
-
 /**
  * @brief Executes IPL steps in continuous mode.
  *
@@ -105,14 +94,5 @@ uint32_t sbeGetSbeFfdc(uint8_t *i_pArg);
   */
 uint32_t sbeGetFreqSupported(uint8_t *i_pArg);
 
-/**
-  * @brief  Handles Sbe Abort chip-op (0xA804)
-  *
-  * @param[in] i_pArg Buffer to be passed to the function (not used as of now)
-  *
-  * @return    Rc from the FIFO access utility
-  */
-uint32_t sbeAbort(uint8_t *i_pArg);
-
 
 #endif // __SBEFW_SBECMDIPLCONTROL_H
diff --git a/src/sbefw/sbecmdparser.C b/src/sbefw/sbecmdparser.C
index 856a45f5..1b2235d0 100644
--- a/src/sbefw/sbecmdparser.C
+++ b/src/sbefw/sbecmdparser.C
@@ -61,23 +61,23 @@ static sbeCmdStruct_t g_sbeScomCmdArray [] =
 {
     {sbeGetScom,
      SBE_CMD_GETSCOM,
-     HARDWARE_FENCED_STATE|SBE_FENCE_AT_FFDC_COLLECT,
+     HARDWARE_FENCED_STATE,
     },
     {sbePutScom,
      SBE_CMD_PUTSCOM,
-     PUT_HARDWARE_FENCED_STATE|SBE_FENCE_AT_FFDC_COLLECT,
+     PUT_HARDWARE_FENCED_STATE,
     },
     {sbeModifyScom,
      SBE_CMD_MODIFYSCOM,
-     PUT_HARDWARE_FENCED_STATE|SBE_FENCE_AT_FFDC_COLLECT,
+     PUT_HARDWARE_FENCED_STATE,
     },
     {sbePutScomUnderMask,
      SBE_CMD_PUTSCOM_MASK,
-     PUT_HARDWARE_FENCED_STATE|SBE_FENCE_AT_FFDC_COLLECT,
+     PUT_HARDWARE_FENCED_STATE,
     },
     {sbeMultiScom,
      SBE_CMD_MULTISCOM,
-     PUT_HARDWARE_FENCED_STATE|SBE_FENCE_AT_FFDC_COLLECT,
+     PUT_HARDWARE_FENCED_STATE,
     },
 };
 
@@ -90,18 +90,9 @@ static sbeCmdStruct_t g_sbeIplControlCmdArray [] =
     {sbeHandleIstep,
      SBE_CMD_EXECUTE_ISTEP,
      PUT_HARDWARE_FENCED_STATE|SBE_FENCE_AT_RUNTIME|
-     SBE_FENCE_AT_DUMPING|SBE_FENCE_AT_QUIESCE,
-     // This is allowed in FFDC Collect state
+     SBE_FENCE_AT_DUMPING,
      // TODO - Issue 157287 - Allow MPIIPL in Isteps state
     },
-
-    {sbeContinueBoot,
-     SBE_CMD_CONTINUE_BOOT,
-     PUT_HARDWARE_FENCED_STATE|SBE_FENCE_AT_RUNTIME|
-     SBE_FENCE_AT_DUMPING|SBE_FENCE_AT_ISTEP|
-     SBE_FENCE_AT_QUIESCE,
-     // This is allowed only in FFDC Collect State in PLCK mode
-    },
 };
 
 ////////////////////////////////////////////////////////////////
@@ -112,8 +103,7 @@ static sbeCmdStruct_t g_sbeGenericCmdArray [] =
 {
     {sbeGetCapabilities,
      SBE_CMD_GET_SBE_CAPABILITIES,
-     SBE_FENCE_AT_FFDC_COLLECT,
-     // Fence in FFDC Collect State, since it might over-write traces
+     SBE_NO_FENCE,
     },
 
      {sbeGetFfdc,
@@ -135,24 +125,22 @@ static sbeCmdStruct_t g_sbeMemoryAccessCmdArray [] =
 {
     {sbeGetMem,
      SBE_CMD_GETMEM,
-     HARDWARE_FENCED_STATE|SBE_FENCE_AT_FFDC_COLLECT,
+     HARDWARE_FENCED_STATE,
     },
 
     {sbePutMem,
      SBE_CMD_PUTMEM,
-     PUT_HARDWARE_FENCED_STATE|SBE_FENCE_AT_FFDC_COLLECT,
+     PUT_HARDWARE_FENCED_STATE,
     },
 
     {sbeGetOccSram,
      SBE_CMD_GETSRAM_OCC,
-     HARDWARE_FENCED_STATE|SBE_FENCE_AT_FFDC_COLLECT|
-     SBE_FENCE_AT_QUIESCE,
+     HARDWARE_FENCED_STATE,
     },
 
     {sbePutOccSram,
      SBE_CMD_PUTSRAM_OCC,
-     PUT_HARDWARE_FENCED_STATE|SBE_FENCE_AT_FFDC_COLLECT|
-     SBE_FENCE_AT_QUIESCE,
+     PUT_HARDWARE_FENCED_STATE,
     },
 };
 
@@ -164,7 +152,7 @@ static sbeCmdStruct_t g_sbeInstructionCntlCmdArray[] =
 {
     {sbeCntlInst,
      SBE_CMD_CONTROL_INSTRUCTIONS,
-     PUT_HARDWARE_FENCED_STATE|SBE_FENCE_AT_FFDC_COLLECT,
+     PUT_HARDWARE_FENCED_STATE,
     },
 };
 
@@ -176,14 +164,12 @@ static sbeCmdStruct_t g_sbeRegAccessCmdArray [] =
 {
     {sbeGetReg,
      SBE_CMD_GETREG,
-     PUT_HARDWARE_FENCED_STATE|SBE_FENCE_AT_FFDC_COLLECT|
-     SBE_FENCE_AT_QUIESCE,
+     PUT_HARDWARE_FENCED_STATE,
     },
 
     {sbePutReg,
      SBE_CMD_PUTREG,
-     PUT_HARDWARE_FENCED_STATE|SBE_FENCE_AT_FFDC_COLLECT|
-     SBE_FENCE_AT_QUIESCE,
+     PUT_HARDWARE_FENCED_STATE,
     },
 };
 
@@ -196,19 +182,15 @@ static sbeCmdStruct_t g_sbeMpiplCmdArray[] =
     {sbeEnterMpipl,
      SBE_CMD_MPIPL_ENTER,
      PUT_HARDWARE_FENCED_STATE|SBE_FENCE_AT_ISTEP|
-     SBE_FENCE_AT_DUMPING|SBE_FENCE_AT_ABORT|
-     SBE_FENCE_AT_QUIESCE,
+     SBE_FENCE_AT_DUMPING,
      // Allow Fspless system to enter MPIPL
-     // Honour MPIPL at FFDC Collect state
      // Issue 157287
     },
 
     {sbeContinueMpipl,
      SBE_CMD_MPIPL_CONTINUE,
      HARDWARE_FENCED_STATE|SBE_FENCE_AT_ISTEP|
-     SBE_FENCE_AT_RUNTIME|SBE_FENCE_AT_DUMPING|
-     SBE_FENCE_AT_ABORT|SBE_FENCE_AT_FFDC_COLLECT|
-     SBE_FENCE_AT_QUIESCE,
+     SBE_FENCE_AT_RUNTIME|SBE_FENCE_AT_DUMPING,
      // Only allowed State is MPIPL
     },
 };
@@ -235,8 +217,7 @@ static sbeCmdStruct_t g_sbeCoreStateControlCmdArray [] =
      SBE_PSU_CMD_CONTROL_DEADMAN,
      SBE_FENCE_AT_CONTINUOUS_IPL|SBE_FENCE_AT_QUIESCE|
      SBE_FENCE_AT_MPIPL|SBE_FENCE_AT_ISTEP|
-     SBE_FENCE_AT_DUMPING|SBE_FENCE_AT_ABORT|
-     SBE_FENCE_AT_FFDC_COLLECT|SBE_FENCE_AT_QUIESCE,
+     SBE_FENCE_AT_DUMPING,
     },
 };
 
@@ -426,19 +407,6 @@ bool sbeIsCmdAllowedAtState (const uint8_t i_cmdClass,
                     // Reset is the only Option available
                     break;
 
-                case SBE_STATE_QUIESCE:
-                {
-                    l_ret = ((l_pCmd->cmd_state_fence &
-                             SBE_FENCE_AT_QUIESCE)? false:true);
-                    break;
-                }
-                case SBE_STATE_FFDC_COLLECT:
-                {
-                    l_ret = ((l_pCmd->cmd_state_fence &
-                             SBE_FENCE_AT_FFDC_COLLECT)? false:true);
-                    break;
-                }
-
                 case SBE_STATE_IPLING:
                 {
                     l_ret = ((l_pCmd->cmd_state_fence &
@@ -481,10 +449,10 @@ bool sbeIsCmdAllowedAtState (const uint8_t i_cmdClass,
                     break;
                 }
 
-                case SBE_STATE_ABORT:
+                case SBE_STATE_QUIESCE:
                 {
                     l_ret = ((l_pCmd->cmd_state_fence &
-                             SBE_FENCE_AT_ABORT)? false:true);
+                              SBE_FENCE_AT_QUIESCE)? false:true);
                     break;
                 }
 
diff --git a/src/sbefw/sbecmdparser.H b/src/sbefw/sbecmdparser.H
index 70b4e697..7ecffb07 100644
--- a/src/sbefw/sbecmdparser.H
+++ b/src/sbefw/sbecmdparser.H
@@ -55,15 +55,13 @@ typedef struct {
 enum sbe_command_fence_attrs
 {
     SBE_NO_FENCE                = 0x0000, ///< Allow cmd in all states
-    SBE_FENCE_AT_ABORT          = 0x0001, ///< Fence off at SBE Abort State
-    SBE_FENCE_AT_FFDC_COLLECT   = 0x0002, ///< Fence off at FFDC Collect State
-    SBE_FENCE_AT_DUMPING        = 0x0004, ///< Fence off at DUMPING State
-    SBE_FENCE_AT_MPIPL          = 0x0010, ///< Fence off at MPIPL state
-    SBE_FENCE_AT_CONTINUOUS_IPL = 0x0040, ///< Fence off at cont IPL
-    SBE_FENCE_AT_ISTEP          = 0x0080, ///< Fence off at istep state
-    SBE_FENCE_AT_RUNTIME        = 0x0100, ///< Fence off at Runtime state
-    SBE_FENCE_AT_QUIESCE        = 0x0200, ///< Fense off at Quiesce state
-    SBE_FENCE_AT_DMT            = 0x0400, ///< Fense off at DMT state
+    SBE_FENCE_AT_DUMPING        = 0x0001, ///< Fence off at DUMPING State
+    SBE_FENCE_AT_MPIPL          = 0x0002, ///< Fence off at MPIPL state
+    SBE_FENCE_AT_CONTINUOUS_IPL = 0x0004, ///< Fence off at cont IPL
+    SBE_FENCE_AT_ISTEP          = 0x0008, ///< Fence off at istep state
+    SBE_FENCE_AT_RUNTIME        = 0x0010, ///< Fence off at Runtime state
+    SBE_FENCE_AT_QUIESCE        = 0x0020, ///< Fense off at Quiesce state
+    SBE_FENCE_AT_DMT            = 0x0040, ///< Fense off at DMT state
 };
 
 /**
diff --git a/src/sbefw/sbecmdprocessor.C b/src/sbefw/sbecmdprocessor.C
index ab02c957..7285134d 100644
--- a/src/sbefw/sbecmdprocessor.C
+++ b/src/sbefw/sbecmdprocessor.C
@@ -225,8 +225,6 @@ void sbeSyncCommandProcessor_routine(void *i_pArg)
     // Check the destination bit at the start
     if(SbeRegAccess::theSbeRegAccess().isIstepMode())
     {
-        // In this state, we need not take care of FFDC State, User may
-        // or may not fetch FFDC and may not issue sbeContinueboot
         SBE_INFO(SBE_FUNC"Continuous IPL mode not set, will wait for "
                 "commands...");
         (void)SbeRegAccess::theSbeRegAccess().
@@ -240,14 +238,6 @@ void sbeSyncCommandProcessor_routine(void *i_pArg)
         (void)SbeRegAccess::theSbeRegAccess().
               updateSbeState(SBE_STATE_RUNTIME);
     }
-    // Now we can assume that we are in Continuous IPL mode, just check if
-    // FFDC needs to be collected before continuing with IPL
-    else if(true == SbeRegAccess::theSbeRegAccess().isCollectFFDCSet())
-    {
-        SBE_INFO(SBE_FUNC"FFDC Collect State - Waiting for FFDC to be picked");
-        (void)SbeRegAccess::theSbeRegAccess().
-              updateSbeState(SBE_STATE_FFDC_COLLECT);
-    }
     else
     {
         SBE_INFO(SBE_FUNC"Continuous IPL Mode set... IPLing");
diff --git a/src/sbefw/sbeevents.H b/src/sbefw/sbeevents.H
index 233bc6ad..37b40cdf 100644
--- a/src/sbefw/sbeevents.H
+++ b/src/sbefw/sbeevents.H
@@ -39,39 +39,33 @@
  */
 enum sbeEvent
 {
-    SBE_CONTINUE_BOOT_PLCK_EVENT           = 0x0, // From FFDC State
-    SBE_CONTINUE_BOOT_RUNTIME_EVENT        = 0x1, // From FFDC State
-    SBE_RUNTIME_EVENT                      = 0x2, // From FFDC/Unknown/ISTEP/IPLING State
-    SBE_ISTEP_EVENT                        = 0x3, // From FFDC/Unknown State
-    SBE_PLCK_EVENT                         = 0x4, // From FFDC/Unknown state
-    SBE_DUMP_FAILURE_EVENT                 = 0x5, // From IPLING/RUNTIME/MPIPL/DMT/Unknown State
-    SBE_ENTER_MPIPL_EVENT                  = 0x6, // From Runtime State
-    SBE_CONTINUE_MPIPL_EVENT               = 0x7, // From MPIPL Wait State
-    SBE_ABORT_EVENT                        = 0x8, // From Any state
-    SBE_DMT_ENTER_EVENT                    = 0x9, // From Runtime State
-    SBE_DMT_COMP_EVENT                     = 0xA, // From DMT State
-    SBE_FAILURE_EVENT                      = 0xB, // From Any State
-    SBE_FFDC_COLLECT_EVENT                 = 0xC, // From Unknown State
-    SBE_QUIESCE_EVENT                      = 0xD, // From Any State
+    SBE_RUNTIME_EVENT          = 0x0, // From Unknown/ISTEP/IPLING State
+    SBE_ISTEP_EVENT            = 0x1, // From Unknown State
+    SBE_PLCK_EVENT             = 0x2, // From Unknown state
+    SBE_DUMP_FAILURE_EVENT     = 0x3, // From IPLING/RUNTIME/MPIPL/DMT/Unknown State
+    SBE_ENTER_MPIPL_EVENT      = 0x4, // From Runtime State
+    SBE_CONTINUE_MPIPL_EVENT   = 0x5, // From MPIPL Wait State
+    SBE_DMT_ENTER_EVENT        = 0x6, // From Runtime State
+    SBE_DMT_COMP_EVENT         = 0x7, // From DMT State
+    SBE_FAILURE_EVENT          = 0x8, // From Any State
+    SBE_QUIESCE_EVENT          = 0x9, // From Any State
 };
 
 // Maximum number of Events per State
 enum maxEventPerState
 {
-    SBE_STATE_UNKNOWN_MAX_EVENT = 5,
-    SBE_STATE_FFDC_COLLECT_MAX_EVENT = 4,
-    SBE_STATE_IPLING_MAX_EVENT = 5,
-    SBE_STATE_ISTEP_MAX_EVENT = 4,
+    SBE_STATE_UNKNOWN_MAX_EVENT = 4,
+    SBE_STATE_IPLING_MAX_EVENT  = 4,
+    SBE_STATE_ISTEP_MAX_EVENT   = 3,
+    SBE_STATE_MPIPL_MAX_EVENT   = 3,
     SBE_STATE_RUNTIME_MAX_EVENT = 5,
-    SBE_STATE_MPIPL_MAX_EVENT = 3,
-    SBE_STATE_DMT_MAX_EVENT = 2,
-    SBE_STATE_DUMP_MAX_EVENT = 0,
+    SBE_STATE_DMT_MAX_EVENT     = 2,
+    SBE_STATE_DUMP_MAX_EVENT    = 0,
     SBE_STATE_FAILURE_MAX_EVENT = 0,
     SBE_STATE_QUIESCE_MAX_EVENT = 0,
-    SBE_STATE_ABORT_MAX_EVENT = 0,
 
     // Total number of State Transition Events, Addition of all the above
-    SBE_MAX_TRANSITIONS = 28,
+    SBE_MAX_TRANSITIONS = 21,
 };
 
 
@@ -82,16 +76,14 @@ enum maxEventPerState
 enum entryToStateMap
 {
     SBE_STATE_UNKNOWN_ENTRY_TO_MAP = 0,
-    SBE_STATE_FFDC_COLLECT_ENTRY_TO_MAP = SBE_STATE_UNKNOWN_ENTRY_TO_MAP + SBE_STATE_UNKNOWN_MAX_EVENT, // 5
-    SBE_STATE_IPLING_ENTRY_TO_MAP = SBE_STATE_FFDC_COLLECT_ENTRY_TO_MAP + SBE_STATE_FFDC_COLLECT_MAX_EVENT, //9
-    SBE_STATE_ISTEP_ENTRY_TO_MAP = SBE_STATE_IPLING_ENTRY_TO_MAP + SBE_STATE_IPLING_MAX_EVENT, //14
-    SBE_STATE_RUNTIME_ENTRY_TO_MAP = SBE_STATE_ISTEP_ENTRY_TO_MAP + SBE_STATE_ISTEP_MAX_EVENT, //18
-    SBE_STATE_MPIPL_ENTRY_TO_MAP = SBE_STATE_RUNTIME_ENTRY_TO_MAP + SBE_STATE_RUNTIME_MAX_EVENT, //23
-    SBE_STATE_DMT_ENTRY_TO_MAP = SBE_STATE_MPIPL_ENTRY_TO_MAP + SBE_STATE_MPIPL_MAX_EVENT, //26
-    SBE_STATE_DUMP_ENTRY_TO_MAP = SBE_STATE_DMT_ENTRY_TO_MAP + SBE_STATE_DMT_MAX_EVENT, //28
-    SBE_STATE_FAILURE_ENTRY_TO_MAP = SBE_STATE_DUMP_ENTRY_TO_MAP + SBE_STATE_DUMP_MAX_EVENT, //28
-    SBE_STATE_QUIESCE_ENTRY_TO_MAP = SBE_STATE_FAILURE_ENTRY_TO_MAP + SBE_STATE_FAILURE_MAX_EVENT, //28
-    SBE_STATE_ABORT_ENTRY_TO_MAP = SBE_STATE_QUIESCE_ENTRY_TO_MAP + SBE_STATE_QUIESCE_MAX_EVENT, //28
+    SBE_STATE_IPLING_ENTRY_TO_MAP  = SBE_STATE_UNKNOWN_ENTRY_TO_MAP + SBE_STATE_UNKNOWN_MAX_EVENT, // 4
+    SBE_STATE_ISTEP_ENTRY_TO_MAP   = SBE_STATE_IPLING_ENTRY_TO_MAP + SBE_STATE_IPLING_MAX_EVENT, //8
+    SBE_STATE_MPIPL_ENTRY_TO_MAP   = SBE_STATE_ISTEP_ENTRY_TO_MAP + SBE_STATE_ISTEP_MAX_EVENT, //11
+    SBE_STATE_RUNTIME_ENTRY_TO_MAP = SBE_STATE_MPIPL_ENTRY_TO_MAP + SBE_STATE_MPIPL_MAX_EVENT, //14
+    SBE_STATE_DMT_ENTRY_TO_MAP     = SBE_STATE_RUNTIME_ENTRY_TO_MAP + SBE_STATE_RUNTIME_MAX_EVENT, //19
+    SBE_STATE_DUMP_ENTRY_TO_MAP    = SBE_STATE_DMT_ENTRY_TO_MAP + SBE_STATE_DMT_MAX_EVENT, //21
+    SBE_STATE_FAILURE_ENTRY_TO_MAP = SBE_STATE_DUMP_ENTRY_TO_MAP + SBE_STATE_DUMP_MAX_EVENT, //21
+    SBE_STATE_QUIESCE_ENTRY_TO_MAP = SBE_STATE_FAILURE_ENTRY_TO_MAP + SBE_STATE_FAILURE_MAX_EVENT, //21
 };
 
 #endif //__SBEFW_SBEEVENTS_H
diff --git a/src/sbefw/sberegaccess.C b/src/sbefw/sberegaccess.C
index 2fa26c5e..71b2b3bf 100644
--- a/src/sbefw/sberegaccess.C
+++ b/src/sbefw/sberegaccess.C
@@ -59,16 +59,14 @@ typedef struct stateEventRangeStr
 static const stateEventRangeStr_t eventRangePerState[SBE_MAX_STATE] =
 {
     {SBE_STATE_UNKNOWN_ENTRY_TO_MAP, SBE_STATE_UNKNOWN_MAX_EVENT},
-    {SBE_STATE_FFDC_COLLECT_ENTRY_TO_MAP, SBE_STATE_FFDC_COLLECT_MAX_EVENT},
     {SBE_STATE_IPLING_ENTRY_TO_MAP, SBE_STATE_IPLING_MAX_EVENT},
     {SBE_STATE_ISTEP_ENTRY_TO_MAP, SBE_STATE_ISTEP_MAX_EVENT},
-    {SBE_STATE_RUNTIME_ENTRY_TO_MAP, SBE_STATE_RUNTIME_MAX_EVENT},
     {SBE_STATE_MPIPL_ENTRY_TO_MAP, SBE_STATE_MPIPL_MAX_EVENT},
+    {SBE_STATE_RUNTIME_ENTRY_TO_MAP, SBE_STATE_RUNTIME_MAX_EVENT},
     {SBE_STATE_DMT_ENTRY_TO_MAP, SBE_STATE_DMT_MAX_EVENT},
     {SBE_STATE_DUMP_ENTRY_TO_MAP, SBE_STATE_DUMP_MAX_EVENT},
     {SBE_STATE_FAILURE_ENTRY_TO_MAP, SBE_STATE_FAILURE_MAX_EVENT},
     {SBE_STATE_QUIESCE_ENTRY_TO_MAP, SBE_STATE_QUIESCE_MAX_EVENT},
-    {SBE_STATE_ABORT_ENTRY_TO_MAP, SBE_STATE_ABORT_MAX_EVENT},
 };
 
 // Map to connect the current State with an event along with the final state
@@ -79,28 +77,21 @@ static const stateTransitionStr_t stateTransMap[SBE_MAX_TRANSITIONS] = {
     {SBE_STATE_UNKNOWN, SBE_RUNTIME_EVENT, SBE_STATE_RUNTIME},
     {SBE_STATE_UNKNOWN, SBE_ISTEP_EVENT, SBE_STATE_ISTEP},
     {SBE_STATE_UNKNOWN, SBE_PLCK_EVENT, SBE_STATE_IPLING},
-    {SBE_STATE_UNKNOWN, SBE_FFDC_COLLECT_EVENT, SBE_STATE_FFDC_COLLECT},
-    {SBE_STATE_FFDC_COLLECT, SBE_CONTINUE_BOOT_PLCK_EVENT, SBE_STATE_IPLING},
-    {SBE_STATE_FFDC_COLLECT, SBE_CONTINUE_BOOT_RUNTIME_EVENT, SBE_STATE_RUNTIME},
-    {SBE_STATE_FFDC_COLLECT, SBE_ISTEP_EVENT, SBE_STATE_ISTEP},
-    {SBE_STATE_FFDC_COLLECT, SBE_FAILURE_EVENT, SBE_STATE_DUMP},
     {SBE_STATE_IPLING, SBE_RUNTIME_EVENT, SBE_STATE_RUNTIME},
     {SBE_STATE_IPLING, SBE_DUMP_FAILURE_EVENT, SBE_STATE_DUMP},
     {SBE_STATE_IPLING, SBE_FAILURE_EVENT, SBE_STATE_FAILURE},
-    {SBE_STATE_IPLING, SBE_ABORT_EVENT, SBE_STATE_ABORT},
     {SBE_STATE_IPLING, SBE_QUIESCE_EVENT, SBE_STATE_QUIESCE},
     {SBE_STATE_ISTEP, SBE_RUNTIME_EVENT, SBE_STATE_RUNTIME},
-    {SBE_STATE_ISTEP, SBE_ABORT_EVENT, SBE_STATE_ABORT},
     {SBE_STATE_ISTEP, SBE_FAILURE_EVENT, SBE_STATE_FAILURE},
     {SBE_STATE_ISTEP, SBE_QUIESCE_EVENT, SBE_STATE_QUIESCE},
+    {SBE_STATE_MPIPL, SBE_CONTINUE_MPIPL_EVENT, SBE_STATE_RUNTIME},
+    {SBE_STATE_MPIPL, SBE_DUMP_FAILURE_EVENT, SBE_STATE_DUMP},
+    {SBE_STATE_MPIPL, SBE_QUIESCE_EVENT, SBE_STATE_QUIESCE},
     {SBE_STATE_RUNTIME, SBE_DUMP_FAILURE_EVENT, SBE_STATE_DUMP},
     {SBE_STATE_RUNTIME, SBE_ENTER_MPIPL_EVENT, SBE_STATE_MPIPL},
     {SBE_STATE_RUNTIME, SBE_DMT_ENTER_EVENT, SBE_STATE_DMT},
     {SBE_STATE_RUNTIME, SBE_FAILURE_EVENT, SBE_STATE_FAILURE},
     {SBE_STATE_RUNTIME, SBE_QUIESCE_EVENT, SBE_STATE_QUIESCE},
-    {SBE_STATE_MPIPL, SBE_CONTINUE_MPIPL_EVENT, SBE_STATE_RUNTIME},
-    {SBE_STATE_MPIPL, SBE_DUMP_FAILURE_EVENT, SBE_STATE_DUMP},
-    {SBE_STATE_MPIPL, SBE_QUIESCE_EVENT, SBE_STATE_QUIESCE},
     {SBE_STATE_DMT, SBE_DMT_COMP_EVENT, SBE_STATE_RUNTIME},
     {SBE_STATE_DMT, SBE_QUIESCE_EVENT, SBE_STATE_QUIESCE},
 };
diff --git a/src/sbefw/sbestates.H b/src/sbefw/sbestates.H
index b2916914..204b73af 100644
--- a/src/sbefw/sbestates.H
+++ b/src/sbefw/sbestates.H
@@ -39,19 +39,17 @@
 enum sbeState
 {
     SBE_STATE_UNKNOWN = 0x0, // Unkown, initial state
-    SBE_STATE_FFDC_COLLECT = 0x1, // Waiting for FFDC collection after a reset
-    SBE_STATE_IPLING = 0x2, // IPL'ing - autonomous mode (transient)
-    SBE_STATE_ISTEP = 0x3, // ISTEP - Running IPL by steps (transient)
+    SBE_STATE_IPLING  = 0x1, // IPL'ing - autonomous mode (transient)
+    SBE_STATE_ISTEP   = 0x2, // ISTEP - Running IPL by steps (transient)
+    SBE_STATE_MPIPL   = 0x3, // MPIPL
     SBE_STATE_RUNTIME = 0x4, // SBE Runtime
-    SBE_STATE_MPIPL = 0x5, // MPIPL
-    SBE_STATE_DMT = 0x6, // Dead Man Timer State (transient)
-    SBE_STATE_DUMP = 0x7, // Dumping
-    SBE_STATE_FAILURE = 0x8, // Internal SBE failure
-    SBE_STATE_QUIESCE = 0x9, // Final state - needs SBE reset to get out
-    SBE_STATE_ABORT = 0xA, // SBE was asked to abort - need reset to get out
+    SBE_STATE_DMT     = 0x5, // Dead Man Timer State (transient)
+    SBE_STATE_DUMP    = 0x6, // Dumping
+    SBE_STATE_FAILURE = 0x7, // Internal SBE failure
+    SBE_STATE_QUIESCE = 0x8, // Final state - needs SBE reset to get out
 
     // Max States, Always keep it at the last of the enum and sequential
-    SBE_MAX_STATE = 0xB,
+    SBE_MAX_STATE     = 0x9,
     // Don't count this in the state, just to intialize the state variables
     SBE_INVALID_STATE = 0xF,
 };