From 369312ea11f291f4f61a29d5a2dd03b163dba5cf Mon Sep 17 00:00:00 2001 From: Raja Das Date: Tue, 6 Sep 2016 00:01:35 -0500 Subject: Removed Collect FFDC & Abort State from SM implementation Change-Id: Iefb1be8bdb33497814e529d44df2422334303085 Reviewed-on: http://ralgit01.raleigh.ibm.com/gerrit1/29235 Tested-by: Jenkins Server Tested-by: FSP CI Jenkins Reviewed-by: Shakeeb A. Pasha B K Reviewed-by: Sachin Gupta --- src/sbefw/sbe_sp_intf.H | 2 -- src/sbefw/sbecmdiplcontrol.C | 62 --------------------------------------- src/sbefw/sbecmdiplcontrol.H | 20 ------------- src/sbefw/sbecmdparser.C | 70 ++++++++++++-------------------------------- src/sbefw/sbecmdparser.H | 16 +++++----- src/sbefw/sbecmdprocessor.C | 10 ------- src/sbefw/sbeevents.H | 58 ++++++++++++++++-------------------- src/sbefw/sberegaccess.C | 17 +++-------- src/sbefw/sbestates.H | 18 +++++------- 9 files changed, 63 insertions(+), 210 deletions(-) (limited to 'src') 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, }; -- cgit v1.2.1