// SPDX-License-Identifier: GPL-2.0-or-later
/******************************************************************************
 *
 *      (C)Copyright 1998,1999 SysKonnect,
 *      a business unit of Schneider & Koch & Co. Datensysteme GmbH.
 *
 *      See the file "skfddi.c" for further information.
 *
 *      The information in this file is provided "AS IS" without warranty.
 *
 ******************************************************************************/

/*
        SMT ECM
        Entity Coordination Management
        Hardware independent state machine
*/

/*
 * Hardware independent state machine implemantation
 * The following external SMT functions are referenced :
 *
 *              queue_event()
 *              smt_timer_start()
 *              smt_timer_stop()
 *
 *      The following external HW dependent functions are referenced :
 *              sm_pm_bypass_req()
 *              sm_pm_get_ls()
 * 
 *      The following HW dependent events are required :
 *              NONE
 *
 */

#include "h/types.h"
#include "h/fddi.h"
#include "h/smc.h"

#define KERNEL
#include "h/smtstate.h"

/*
 * FSM Macros
 */
#define AFLAG   0x10
#define GO_STATE(x)     (smc->mib.fddiSMTECMState = (x)|AFLAG)
#define ACTIONS_DONE()  (smc->mib.fddiSMTECMState &= ~AFLAG)
#define ACTIONS(x)      (x|AFLAG)

#define EC0_OUT         0                       /* not inserted */
#define EC1_IN          1                       /* inserted */
#define EC2_TRACE       2                       /* tracing */
#define EC3_LEAVE       3                       /* leaving the ring */
#define EC4_PATH_TEST   4                       /* performing path test */
#define EC5_INSERT      5                       /* bypass being turned on */
#define EC6_CHECK       6                       /* checking bypass */
#define EC7_DEINSERT    7                       /* bypass being turnde off */

/*
 * symbolic state names
 */
static const char * const ecm_states[] = {
        "EC0_OUT","EC1_IN","EC2_TRACE","EC3_LEAVE","EC4_PATH_TEST",
        "EC5_INSERT","EC6_CHECK","EC7_DEINSERT"
} ;

/*
 * symbolic event names
 */
static const char * const ecm_events[] = {
        "NONE","EC_CONNECT","EC_DISCONNECT","EC_TRACE_PROP","EC_PATH_TEST",
        "EC_TIMEOUT_TD","EC_TIMEOUT_TMAX",
        "EC_TIMEOUT_IMAX","EC_TIMEOUT_INMAX","EC_TEST_DONE"
} ;

/*
 * all Globals  are defined in smc.h
 * struct s_ecm
 */

/*
 * function declarations
 */

static void ecm_fsm(struct s_smc *smc, int cmd);
static void start_ecm_timer(struct s_smc *smc, u_long value, int event);
static void stop_ecm_timer(struct s_smc *smc);
static void prop_actions(struct s_smc *smc);

/*
        init ECM state machine
        clear all ECM vars and flags
*/
void ecm_init(struct s_smc *smc)
{
        smc->e.path_test = PT_PASSED ;
        smc->e.trace_prop = 0 ;
        smc->e.sb_flag = 0 ;
        smc->mib.fddiSMTECMState = ACTIONS(EC0_OUT) ;
        smc->e.ecm_line_state = FALSE ;
}

/*
        ECM state machine
        called by dispatcher

        do
                display state change
                process event
        until SM is stable
*/
void ecm(struct s_smc *smc, int event)
{
        int     state ;

        do {
                DB_ECM("ECM : state %s%s event %s",
                       smc->mib.fddiSMTECMState & AFLAG ? "ACTIONS " : "",
                       ecm_states[smc->mib.fddiSMTECMState & ~AFLAG],
                       ecm_events[event]);
                state = smc->mib.fddiSMTECMState ;
                ecm_fsm(smc,event) ;
                event = 0 ;
        } while (state != smc->mib.fddiSMTECMState) ;
        ecm_state_change(smc,(int)smc->mib.fddiSMTECMState) ;
}

/*
        process ECM event
*/
static void ecm_fsm(struct s_smc *smc, int cmd)
{
        int ls_a ;                      /* current line state PHY A */
        int ls_b ;                      /* current line state PHY B */
        int     p ;                     /* ports */


        smc->mib.fddiSMTBypassPresent = sm_pm_bypass_present(smc) ;
        if (cmd == EC_CONNECT)
                smc->mib.fddiSMTRemoteDisconnectFlag = FALSE ;

        /* For AIX event notification: */
        /* Is a disconnect  command remotely issued ? */
        if (cmd == EC_DISCONNECT &&
            smc->mib.fddiSMTRemoteDisconnectFlag == TRUE) {
                AIX_EVENT (smc, (u_long) CIO_HARD_FAIL, (u_long)
                        FDDI_REMOTE_DISCONNECT, smt_get_event_word(smc),
                        smt_get_error_word(smc) );
        }

        /*jd 05-Aug-1999 Bug #10419 "Port Disconnect fails at Dup MAc Cond."*/
        if (cmd == EC_CONNECT) {
                smc->e.DisconnectFlag = FALSE ;
        }
        else if (cmd == EC_DISCONNECT) {
                smc->e.DisconnectFlag = TRUE ;
        }
        
        switch(smc->mib.fddiSMTECMState) {
        case ACTIONS(EC0_OUT) :
                /*
                 * We do not perform a path test
                 */
                smc->e.path_test = PT_PASSED ;
                smc->e.ecm_line_state = FALSE ;
                stop_ecm_timer(smc) ;
                ACTIONS_DONE() ;
                break ;
        case EC0_OUT:
                /*EC01*/
                if (cmd == EC_CONNECT && !smc->mib.fddiSMTBypassPresent
                        && smc->e.path_test==PT_PASSED) {
                        GO_STATE(EC1_IN) ;
                        break ;
                }
                /*EC05*/
                else if (cmd == EC_CONNECT && (smc->e.path_test==PT_PASSED) &&
                        smc->mib.fddiSMTBypassPresent &&
                        (smc->s.sas == SMT_DAS)) {
                        GO_STATE(EC5_INSERT) ;
                        break ;
                }
                break;
        case ACTIONS(EC1_IN) :
                stop_ecm_timer(smc) ;
                smc->e.trace_prop = 0 ;
                sm_ma_control(smc,MA_TREQ) ;
                for (p = 0 ; p < NUMPHYS ; p++)
                        if (smc->mib.p[p].fddiPORTHardwarePresent)
                                queue_event(smc,EVENT_PCMA+p,PC_START) ;
                ACTIONS_DONE() ;
                break ;
        case EC1_IN:
                /*EC12*/
                if (cmd == EC_TRACE_PROP) {
                        prop_actions(smc) ;
                        GO_STATE(EC2_TRACE) ;
                        break ;
                }
                /*EC13*/
                else if (cmd == EC_DISCONNECT) {
                        GO_STATE(EC3_LEAVE) ;
                        break ;
                }
                break;
        case ACTIONS(EC2_TRACE) :
                start_ecm_timer(smc,MIB2US(smc->mib.fddiSMTTrace_MaxExpiration),
                        EC_TIMEOUT_TMAX) ;
                ACTIONS_DONE() ;
                break ;
        case EC2_TRACE :
                /*EC22*/
                if (cmd == EC_TRACE_PROP) {
                        prop_actions(smc) ;
                        GO_STATE(EC2_TRACE) ;
                        break ;
                }
                /*EC23a*/
                else if (cmd == EC_DISCONNECT) {
                        smc->e.path_test = PT_EXITING ;
                        GO_STATE(EC3_LEAVE) ;
                        break ;
                }
                /*EC23b*/
                else if (smc->e.path_test == PT_PENDING) {
                        GO_STATE(EC3_LEAVE) ;
                        break ;
                }
                /*EC23c*/
                else if (cmd == EC_TIMEOUT_TMAX) {
                        /* Trace_Max is expired */
                        /* -> send AIX_EVENT */
                        AIX_EVENT(smc, (u_long) FDDI_RING_STATUS,
                                (u_long) FDDI_SMT_ERROR, (u_long)
                                FDDI_TRACE_MAX, smt_get_error_word(smc));
                        smc->e.path_test = PT_PENDING ;
                        GO_STATE(EC3_LEAVE) ;
                        break ;
                }
                break ;
        case ACTIONS(EC3_LEAVE) :
                start_ecm_timer(smc,smc->s.ecm_td_min,EC_TIMEOUT_TD) ;
                for (p = 0 ; p < NUMPHYS ; p++)
                        queue_event(smc,EVENT_PCMA+p,PC_STOP) ;
                ACTIONS_DONE() ;
                break ;
        case EC3_LEAVE:
                /*EC30*/
                if (cmd == EC_TIMEOUT_TD && !smc->mib.fddiSMTBypassPresent &&
                        (smc->e.path_test != PT_PENDING)) {
                        GO_STATE(EC0_OUT) ;
                        break ;
                }
                /*EC34*/
                else if (cmd == EC_TIMEOUT_TD &&
                        (smc->e.path_test == PT_PENDING)) {
                        GO_STATE(EC4_PATH_TEST) ;
                        break ;
                }
                /*EC31*/
                else if (cmd == EC_CONNECT && smc->e.path_test == PT_PASSED) {
                        GO_STATE(EC1_IN) ;
                        break ;
                }
                /*EC33*/
                else if (cmd == EC_DISCONNECT &&
                        smc->e.path_test == PT_PENDING) {
                        smc->e.path_test = PT_EXITING ;
                        /*
                         * stay in state - state will be left via timeout
                         */
                }
                /*EC37*/
                else if (cmd == EC_TIMEOUT_TD &&
                        smc->mib.fddiSMTBypassPresent &&
                        smc->e.path_test != PT_PENDING) {
                        GO_STATE(EC7_DEINSERT) ;
                        break ;
                }
                break ;
        case ACTIONS(EC4_PATH_TEST) :
                stop_ecm_timer(smc) ;
                smc->e.path_test = PT_TESTING ;
                start_ecm_timer(smc,smc->s.ecm_test_done,EC_TEST_DONE) ;
                /* now perform path test ... just a simulation */
                ACTIONS_DONE() ;
                break ;
        case EC4_PATH_TEST :
                /* path test done delay */
                if (cmd == EC_TEST_DONE)
                        smc->e.path_test = PT_PASSED ;

                if (smc->e.path_test == PT_FAILED)
                        RS_SET(smc,RS_PATHTEST) ;

                /*EC40a*/
                if (smc->e.path_test == PT_FAILED &&
                        !smc->mib.fddiSMTBypassPresent) {
                        GO_STATE(EC0_OUT) ;
                        break ;
                }
                /*EC40b*/
                else if (cmd == EC_DISCONNECT &&
                        !smc->mib.fddiSMTBypassPresent) {
                        GO_STATE(EC0_OUT) ;
                        break ;
                }
                /*EC41*/
                else if (smc->e.path_test == PT_PASSED) {
                        GO_STATE(EC1_IN) ;
                        break ;
                }
                /*EC47a*/
                else if (smc->e.path_test == PT_FAILED &&
                        smc->mib.fddiSMTBypassPresent) {
                        GO_STATE(EC7_DEINSERT) ;
                        break ;
                }
                /*EC47b*/
                else if (cmd == EC_DISCONNECT &&
                        smc->mib.fddiSMTBypassPresent) {
                        GO_STATE(EC7_DEINSERT) ;
                        break ;
                }
                break ;
        case ACTIONS(EC5_INSERT) :
                sm_pm_bypass_req(smc,BP_INSERT);
                start_ecm_timer(smc,smc->s.ecm_in_max,EC_TIMEOUT_INMAX) ;
                ACTIONS_DONE() ;
                break ;
        case EC5_INSERT :
                /*EC56*/
                if (cmd == EC_TIMEOUT_INMAX) {
                        GO_STATE(EC6_CHECK) ;
                        break ;
                }
                /*EC57*/
                else if (cmd == EC_DISCONNECT) {
                        GO_STATE(EC7_DEINSERT) ;
                        break ;
                }
                break ;
        case ACTIONS(EC6_CHECK) :
                /*
                 * in EC6_CHECK, we *POLL* the line state !
                 * check whether both bypass switches have switched.
                 */
                start_ecm_timer(smc,smc->s.ecm_check_poll,0) ;
                smc->e.ecm_line_state = TRUE ;  /* flag to pcm: report Q/HLS */
                ACTIONS_DONE() ;
                break ;
        case EC6_CHECK :
                ls_a = sm_pm_get_ls(smc,PA) ;
                ls_b = sm_pm_get_ls(smc,PB) ;

                /*EC61*/
                if (((ls_a == PC_QLS) || (ls_a == PC_HLS)) &&
                    ((ls_b == PC_QLS) || (ls_b == PC_HLS)) ) {
                        smc->e.sb_flag = FALSE ;
                        smc->e.ecm_line_state = FALSE ;
                        GO_STATE(EC1_IN) ;
                        break ;
                }
                /*EC66*/
                else if (!smc->e.sb_flag &&
                         (((ls_a == PC_ILS) && (ls_b == PC_QLS)) ||
                          ((ls_a == PC_QLS) && (ls_b == PC_ILS)))){
                        smc->e.sb_flag = TRUE ;
                        DB_ECMN(1, "ECM : EC6_CHECK - stuck bypass");
                        AIX_EVENT(smc, (u_long) FDDI_RING_STATUS, (u_long)
                                FDDI_SMT_ERROR, (u_long) FDDI_BYPASS_STUCK,
                                smt_get_error_word(smc));
                }
                /*EC67*/
                else if (cmd == EC_DISCONNECT) {
                        smc->e.ecm_line_state = FALSE ;
                        GO_STATE(EC7_DEINSERT) ;
                        break ;
                }
                else {
                        /*
                         * restart poll
                         */
                        start_ecm_timer(smc,smc->s.ecm_check_poll,0) ;
                }
                break ;
        case ACTIONS(EC7_DEINSERT) :
                sm_pm_bypass_req(smc,BP_DEINSERT);
                start_ecm_timer(smc,smc->s.ecm_i_max,EC_TIMEOUT_IMAX) ;
                ACTIONS_DONE() ;
                break ;
        case EC7_DEINSERT:
                /*EC70*/
                if (cmd == EC_TIMEOUT_IMAX) {
                        GO_STATE(EC0_OUT) ;
                        break ;
                }
                /*EC75*/
                else if (cmd == EC_CONNECT && smc->e.path_test == PT_PASSED) {
                        GO_STATE(EC5_INSERT) ;
                        break ;
                }
                break;
        default:
                SMT_PANIC(smc,SMT_E0107, SMT_E0107_MSG) ;
                break;
        }
}

#ifndef CONCENTRATOR
/*
 * trace propagation actions for SAS & DAS
 */
static void prop_actions(struct s_smc *smc)
{
        int     port_in = 0 ;
        int     port_out = 0 ;

        RS_SET(smc,RS_EVENT) ;
        switch (smc->s.sas) {
        case SMT_SAS :
                port_in = port_out = pcm_get_s_port(smc) ;
                break ;
        case SMT_DAS :
                port_in = cfm_get_mac_input(smc) ;      /* PA or PB */
                port_out = cfm_get_mac_output(smc) ;    /* PA or PB */
                break ;
        case SMT_NAC :
                SMT_PANIC(smc,SMT_E0108, SMT_E0108_MSG) ;
                return ;
        }

        DB_ECM("ECM : prop_actions - trace_prop %lu", smc->e.trace_prop);
        DB_ECM("ECM : prop_actions - in %d out %d", port_in, port_out);

        if (smc->e.trace_prop & ENTITY_BIT(ENTITY_MAC)) {
                /* trace initiatior */
                DB_ECM("ECM : initiate TRACE on PHY %c", 'A' + port_in - PA);
                queue_event(smc,EVENT_PCM+port_in,PC_TRACE) ;
        }
        else if ((smc->e.trace_prop & ENTITY_BIT(ENTITY_PHY(PA))) &&
                port_out != PA) {
                /* trace propagate upstream */
                DB_ECM("ECM : propagate TRACE on PHY B");
                queue_event(smc,EVENT_PCMB,PC_TRACE) ;
        }
        else if ((smc->e.trace_prop & ENTITY_BIT(ENTITY_PHY(PB))) &&
                port_out != PB) {
                /* trace propagate upstream */
                DB_ECM("ECM : propagate TRACE on PHY A");
                queue_event(smc,EVENT_PCMA,PC_TRACE) ;
        }
        else {
                /* signal trace termination */
                DB_ECM("ECM : TRACE terminated");
                smc->e.path_test = PT_PENDING ;
        }
        smc->e.trace_prop = 0 ;
}
#else
/*
 * trace propagation actions for Concentrator
 */
static void prop_actions(struct s_smc *smc)
{
        int     initiator ;
        int     upstream ;
        int     p ;

        RS_SET(smc,RS_EVENT) ;
        while (smc->e.trace_prop) {
                DB_ECM("ECM : prop_actions - trace_prop %d",
                       smc->e.trace_prop);

                if (smc->e.trace_prop & ENTITY_BIT(ENTITY_MAC)) {
                        initiator = ENTITY_MAC ;
                        smc->e.trace_prop &= ~ENTITY_BIT(ENTITY_MAC) ;
                        DB_ECM("ECM: MAC initiates trace");
                }
                else {
                        for (p = NUMPHYS-1 ; p >= 0 ; p--) {
                                if (smc->e.trace_prop &
                                        ENTITY_BIT(ENTITY_PHY(p)))
                                        break ;
                        }
                        initiator = ENTITY_PHY(p) ;
                        smc->e.trace_prop &= ~ENTITY_BIT(ENTITY_PHY(p)) ;
                }
                upstream = cem_get_upstream(smc,initiator) ;

                if (upstream == ENTITY_MAC) {
                        /* signal trace termination */
                        DB_ECM("ECM : TRACE terminated");
                        smc->e.path_test = PT_PENDING ;
                }
                else {
                        /* trace propagate upstream */
                        DB_ECM("ECM : propagate TRACE on PHY %d", upstream);
                        queue_event(smc,EVENT_PCM+upstream,PC_TRACE) ;
                }
        }
}
#endif


/*
 * SMT timer interface
 *      start ECM timer
 */
static void start_ecm_timer(struct s_smc *smc, u_long value, int event)
{
        smt_timer_start(smc,&smc->e.ecm_timer,value,EV_TOKEN(EVENT_ECM,event));
}

/*
 * SMT timer interface
 *      stop ECM timer
 */
static void stop_ecm_timer(struct s_smc *smc)
{
        if (smc->e.ecm_timer.tm_active)
                smt_timer_stop(smc,&smc->e.ecm_timer) ;
}