Quelle  cfm.c   Sprache: C

// 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 CFM
Configuration Management
DAS with single MAC
*/

/*
 * Hardware independent state machine implemantation
 * The following external SMT functions are referenced :
 *
 * queue_event()
 *
 * The following external HW dependent functions are referenced :
 * config_mux()
 *
 * 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.fddiSMTCF_State = (x)|AFLAG)
#define ACTIONS_DONE() (smc->mib.fddiSMTCF_State &= ~AFLAG)
#define ACTIONS(x) (x|AFLAG)

/*
 * symbolic state names
 */
static const char * const cfm_states[] = {
 "SC0_ISOLATED","CF1","CF2","CF3","CF4",
 "SC1_WRAP_A","SC2_WRAP_B","SC5_TRHU_B","SC7_WRAP_S",
 "SC9_C_WRAP_A","SC10_C_WRAP_B","SC11_C_WRAP_S","SC4_THRU_A"
} ;

/*
 * symbolic event names
 */
static const char * const cfm_events[] = {
 "NONE","CF_LOOP_A","CF_LOOP_B","CF_JOIN_A","CF_JOIN_B"
} ;

/*
 * map from state to downstream port type
 */
static const unsigned char cf_to_ptype[] = {
 TNONE,TNONE,TNONE,TNONE,TNONE,
 TNONE,TB,TB,TS,
 TA,TB,TS,TB
} ;

/*
 * CEM port states
 */
#define CEM_PST_DOWN 0
#define CEM_PST_UP 1
#define CEM_PST_HOLD 2
/* define portstate array only for A and B port */
/* Do this within the smc structure (use in multiple cards) */

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

/*
 * function declarations
 */
static void cfm_fsm(struct s_smc *smc, int cmd);

/*
init CFM state machine
clear all CFM vars and flags
*/
void cfm_init(struct s_smc *smc)
{
 smc->mib.fddiSMTCF_State = ACTIONS(SC0_ISOLATED) ;
 smc->r.rm_join = 0 ;
 smc->r.rm_loop = 0 ;
 smc->y[PA].scrub = 0 ;
 smc->y[PB].scrub = 0 ;
 smc->y[PA].cem_pst = CEM_PST_DOWN ;
 smc->y[PB].cem_pst = CEM_PST_DOWN ;
}

/* Some terms conditions used by the selection criteria */
#define THRU_ENABLED(smc) (smc->y[PA].pc_mode != PM_TREE && \
     smc->y[PB].pc_mode != PM_TREE)
/* Selection criteria for the ports */
static void selection_criteria (struct s_smc *smc, struct s_phy *phy)
{

 switch (phy->mib->fddiPORTMy_Type) {
 case TA:
  if ( !THRU_ENABLED(smc) && smc->y[PB].cf_join ) {
   phy->wc_flag = TRUE ;
  } else {
   phy->wc_flag = FALSE ;
  }

  break;
 case TB:
  /* take precedence over PA */
  phy->wc_flag = FALSE ;
  break;
 case TS:
  phy->wc_flag = FALSE ;
  break;
 case TM:
  phy->wc_flag = FALSE ;
  break;
 }

}

void all_selection_criteria(struct s_smc *smc)
{
 struct s_phy *phy ;
 int  p ;

 for ( p = 0,phy = smc->y ; p < NUMPHYS; p++, phy++ ) {
  /* Do the selection criteria */
  selection_criteria (smc,phy);
 }
}

static void cem_priv_state(struct s_smc *smc, int event)
/* State machine for private PORT states: used to optimize dual homing */
{
 int np; /* Number of the port */
 int i;

 /* Do this only in a DAS */
 if (smc->s.sas != SMT_DAS )
  return ;

 np = event - CF_JOIN;

 if (np != PA && np != PB) {
  return ;
 }
 /* Change the port state according to the event (portnumber) */
 if (smc->y[np].cf_join) {
  smc->y[np].cem_pst = CEM_PST_UP ;
 } else if (!smc->y[np].wc_flag) {
  /* set the port to done only if it is not withheld */
  smc->y[np].cem_pst = CEM_PST_DOWN ;
 }

 /* Don't set an hold port to down */

 /* Check all ports of restart conditions */
 for (i = 0 ; i < 2 ; i ++ ) {
  /* Check all port for PORT is on hold and no withhold is done */
  if ( smc->y[i].cem_pst == CEM_PST_HOLD && !smc->y[i].wc_flag ) {
   smc->y[i].cem_pst = CEM_PST_DOWN;
   queue_event(smc,(int)(EVENT_PCM+i),PC_START) ;
  }
  if ( smc->y[i].cem_pst == CEM_PST_UP && smc->y[i].wc_flag ) {
   smc->y[i].cem_pst = CEM_PST_HOLD;
   queue_event(smc,(int)(EVENT_PCM+i),PC_START) ;
  }
  if ( smc->y[i].cem_pst == CEM_PST_DOWN && smc->y[i].wc_flag ) {
   /*
 * The port must be restarted when the wc_flag
 * will be reset. So set the port on hold.
 */
   smc->y[i].cem_pst = CEM_PST_HOLD;
  }
 }
 return ;
}

/*
CFM state machine
called by dispatcher

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

 /* We will do the following: */
 /*  - compute the variable WC_Flag for every port (This is where */
 /*    we can extend the requested path checking !!) */
 /*  - do the old (SMT 6.2 like) state machine */
 /*  - do the resulting station states */

 all_selection_criteria (smc);

 /* We will check now whether a state transition is allowed or not */
 /*  - change the portstates */
 cem_priv_state (smc, event);

 do {
  DB_CFM("CFM : state %s%s event %s",
         smc->mib.fddiSMTCF_State & AFLAG ? "ACTIONS " : "",
         cfm_states[smc->mib.fddiSMTCF_State & ~AFLAG],
         cfm_events[event]);
  state = smc->mib.fddiSMTCF_State ;
  cfm_fsm(smc,event) ;
  event = 0 ;
 } while (state != smc->mib.fddiSMTCF_State) ;

#ifndef SLIM_SMT
 /*
 * check peer wrap condition
 */
 cond = FALSE ;
 if ( (smc->mib.fddiSMTCF_State == SC9_C_WRAP_A &&
  smc->y[PA].pc_mode == PM_PEER)  ||
  (smc->mib.fddiSMTCF_State == SC10_C_WRAP_B &&
  smc->y[PB].pc_mode == PM_PEER)  ||
  (smc->mib.fddiSMTCF_State == SC11_C_WRAP_S &&
  smc->y[PS].pc_mode == PM_PEER &&
  smc->y[PS].mib->fddiPORTNeighborType != TS ) ) {
   cond = TRUE ;
 }
 if (cond != smc->mib.fddiSMTPeerWrapFlag)
  smt_srf_event(smc,SMT_COND_SMT_PEER_WRAP,0,cond) ;

 /*
 * Don't ever send MAC_PATH_CHANGE events. Our MAC is hard-wired
 * to the primary path.
 */

#endif /* no SLIM_SMT */

 /*
 * set MAC port type
 */
 smc->mib.m[MAC0].fddiMACDownstreamPORTType =
  cf_to_ptype[smc->mib.fddiSMTCF_State] ;
 cfm_state_change(smc,(int)smc->mib.fddiSMTCF_State) ;
}

/*
process CFM event
*/
/*ARGSUSED1*/
static void cfm_fsm(struct s_smc *smc, int cmd)
{
 switch(smc->mib.fddiSMTCF_State) {
 case ACTIONS(SC0_ISOLATED) :
  smc->mib.p[PA].fddiPORTCurrentPath = MIB_PATH_ISOLATED ;
  smc->mib.p[PB].fddiPORTCurrentPath = MIB_PATH_ISOLATED ;
  smc->mib.p[PA].fddiPORTMACPlacement = 0 ;
  smc->mib.p[PB].fddiPORTMACPlacement = 0 ;
  smc->mib.fddiSMTStationStatus = MIB_SMT_STASTA_SEPA ;
  config_mux(smc,MUX_ISOLATE) ; /* configure PHY Mux */
  smc->r.rm_loop = FALSE ;
  smc->r.rm_join = FALSE ;
  queue_event(smc,EVENT_RMT,RM_JOIN) ;/* signal RMT */
  /* Don't do the WC-Flag changing here */
  ACTIONS_DONE() ;
  DB_CFMN(1, "CFM : %s", cfm_states[smc->mib.fddiSMTCF_State]);
  break;
 case SC0_ISOLATED :
  /*SC07*/
  /*SAS port can be PA or PB ! */
  if (smc->s.sas && (smc->y[PA].cf_join || smc->y[PA].cf_loop ||
    smc->y[PB].cf_join || smc->y[PB].cf_loop)) {
   GO_STATE(SC11_C_WRAP_S) ;
   break ;
  }
  /*SC01*/
  if ((smc->y[PA].cem_pst == CEM_PST_UP && smc->y[PA].cf_join &&
       !smc->y[PA].wc_flag) || smc->y[PA].cf_loop) {
   GO_STATE(SC9_C_WRAP_A) ;
   break ;
  }
  /*SC02*/
  if ((smc->y[PB].cem_pst == CEM_PST_UP && smc->y[PB].cf_join &&
       !smc->y[PB].wc_flag) || smc->y[PB].cf_loop) {
   GO_STATE(SC10_C_WRAP_B) ;
   break ;
  }
  break ;
 case ACTIONS(SC9_C_WRAP_A) :
  smc->mib.p[PA].fddiPORTCurrentPath = MIB_PATH_CONCATENATED ;
  smc->mib.p[PB].fddiPORTCurrentPath = MIB_PATH_ISOLATED ;
  smc->mib.p[PA].fddiPORTMACPlacement = INDEX_MAC ;
  smc->mib.p[PB].fddiPORTMACPlacement = 0 ;
  smc->mib.fddiSMTStationStatus = MIB_SMT_STASTA_CON ;
  config_mux(smc,MUX_WRAPA) ;  /* configure PHY mux */
  if (smc->y[PA].cf_loop) {
   smc->r.rm_join = FALSE ;
   smc->r.rm_loop = TRUE ;
   queue_event(smc,EVENT_RMT,RM_LOOP) ;/* signal RMT */
  }
  if (smc->y[PA].cf_join) {
   smc->r.rm_loop = FALSE ;
   smc->r.rm_join = TRUE ;
   queue_event(smc,EVENT_RMT,RM_JOIN) ;/* signal RMT */
  }
  ACTIONS_DONE() ;
  DB_CFMN(1, "CFM : %s", cfm_states[smc->mib.fddiSMTCF_State]);
  break ;
 case SC9_C_WRAP_A :
  /*SC10*/
  if ( (smc->y[PA].wc_flag || !smc->y[PA].cf_join) &&
        !smc->y[PA].cf_loop ) {
   GO_STATE(SC0_ISOLATED) ;
   break ;
  }
  /*SC12*/
  else if ( (smc->y[PB].cf_loop && smc->y[PA].cf_join &&
      smc->y[PA].cem_pst == CEM_PST_UP) ||
     ((smc->y[PB].cf_loop ||
      (smc->y[PB].cf_join &&
       smc->y[PB].cem_pst == CEM_PST_UP)) &&
       (smc->y[PA].pc_mode == PM_TREE ||
        smc->y[PB].pc_mode == PM_TREE))) {
   smc->y[PA].scrub = TRUE ;
   GO_STATE(SC10_C_WRAP_B) ;
   break ;
  }
  /*SC14*/
  else if (!smc->s.attach_s &&
     smc->y[PA].cf_join &&
     smc->y[PA].cem_pst == CEM_PST_UP &&
     smc->y[PA].pc_mode == PM_PEER && smc->y[PB].cf_join &&
     smc->y[PB].cem_pst == CEM_PST_UP &&
     smc->y[PB].pc_mode == PM_PEER) {
   smc->y[PA].scrub = TRUE ;
   smc->y[PB].scrub = TRUE ;
   GO_STATE(SC4_THRU_A) ;
   break ;
  }
  /*SC15*/
  else if ( smc->s.attach_s &&
     smc->y[PA].cf_join &&
     smc->y[PA].cem_pst == CEM_PST_UP &&
     smc->y[PA].pc_mode == PM_PEER &&
     smc->y[PB].cf_join &&
     smc->y[PB].cem_pst == CEM_PST_UP &&
     smc->y[PB].pc_mode == PM_PEER) {
   smc->y[PA].scrub = TRUE ;
   smc->y[PB].scrub = TRUE ;
   GO_STATE(SC5_THRU_B) ;
   break ;
  }
  break ;
 case ACTIONS(SC10_C_WRAP_B) :
  smc->mib.p[PA].fddiPORTCurrentPath = MIB_PATH_ISOLATED ;
  smc->mib.p[PB].fddiPORTCurrentPath = MIB_PATH_CONCATENATED ;
  smc->mib.p[PA].fddiPORTMACPlacement = 0 ;
  smc->mib.p[PB].fddiPORTMACPlacement = INDEX_MAC ;
  smc->mib.fddiSMTStationStatus = MIB_SMT_STASTA_CON ;
  config_mux(smc,MUX_WRAPB) ;  /* configure PHY mux */
  if (smc->y[PB].cf_loop) {
   smc->r.rm_join = FALSE ;
   smc->r.rm_loop = TRUE ;
   queue_event(smc,EVENT_RMT,RM_LOOP) ;/* signal RMT */
  }
  if (smc->y[PB].cf_join) {
   smc->r.rm_loop = FALSE ;
   smc->r.rm_join = TRUE ;
   queue_event(smc,EVENT_RMT,RM_JOIN) ;/* signal RMT */
  }
  ACTIONS_DONE() ;
  DB_CFMN(1, "CFM : %s", cfm_states[smc->mib.fddiSMTCF_State]);
  break ;
 case SC10_C_WRAP_B :
  /*SC20*/
  if ( !smc->y[PB].cf_join && !smc->y[PB].cf_loop ) {
   GO_STATE(SC0_ISOLATED) ;
   break ;
  }
  /*SC21*/
  else if ( smc->y[PA].cf_loop && smc->y[PA].pc_mode == PM_PEER &&
     smc->y[PB].cf_join && smc->y[PB].pc_mode == PM_PEER) {
   smc->y[PB].scrub = TRUE ;
   GO_STATE(SC9_C_WRAP_A) ;
   break ;
  }
  /*SC24*/
  else if (!smc->s.attach_s &&
    smc->y[PA].cf_join && smc->y[PA].pc_mode == PM_PEER &&
    smc->y[PB].cf_join && smc->y[PB].pc_mode == PM_PEER) {
   smc->y[PA].scrub = TRUE ;
   smc->y[PB].scrub = TRUE ;
   GO_STATE(SC4_THRU_A) ;
   break ;
  }
  /*SC25*/
  else if ( smc->s.attach_s &&
    smc->y[PA].cf_join && smc->y[PA].pc_mode == PM_PEER &&
    smc->y[PB].cf_join && smc->y[PB].pc_mode == PM_PEER) {
   smc->y[PA].scrub = TRUE ;
   smc->y[PB].scrub = TRUE ;
   GO_STATE(SC5_THRU_B) ;
   break ;
  }
  break ;
 case ACTIONS(SC4_THRU_A) :
  smc->mib.p[PA].fddiPORTCurrentPath = MIB_PATH_THRU ;
  smc->mib.p[PB].fddiPORTCurrentPath = MIB_PATH_THRU ;
  smc->mib.p[PA].fddiPORTMACPlacement = 0 ;
  smc->mib.p[PB].fddiPORTMACPlacement = INDEX_MAC ;
  smc->mib.fddiSMTStationStatus = MIB_SMT_STASTA_THRU ;
  config_mux(smc,MUX_THRUA) ;  /* configure PHY mux */
  smc->r.rm_loop = FALSE ;
  smc->r.rm_join = TRUE ;
  queue_event(smc,EVENT_RMT,RM_JOIN) ;/* signal RMT */
  ACTIONS_DONE() ;
  DB_CFMN(1, "CFM : %s", cfm_states[smc->mib.fddiSMTCF_State]);
  break ;
 case SC4_THRU_A :
  /*SC41*/
  if (smc->y[PB].wc_flag || !smc->y[PB].cf_join) {
   smc->y[PA].scrub = TRUE ;
   GO_STATE(SC9_C_WRAP_A) ;
   break ;
  }
  /*SC42*/
  else if (!smc->y[PA].cf_join || smc->y[PA].wc_flag) {
   smc->y[PB].scrub = TRUE ;
   GO_STATE(SC10_C_WRAP_B) ;
   break ;
  }
  /*SC45*/
  else if (smc->s.attach_s) {
   smc->y[PB].scrub = TRUE ;
   GO_STATE(SC5_THRU_B) ;
   break ;
  }
  break ;
 case ACTIONS(SC5_THRU_B) :
  smc->mib.p[PA].fddiPORTCurrentPath = MIB_PATH_THRU ;
  smc->mib.p[PB].fddiPORTCurrentPath = MIB_PATH_THRU ;
  smc->mib.p[PA].fddiPORTMACPlacement = INDEX_MAC ;
  smc->mib.p[PB].fddiPORTMACPlacement = 0 ;
  smc->mib.fddiSMTStationStatus = MIB_SMT_STASTA_THRU ;
  config_mux(smc,MUX_THRUB) ;  /* configure PHY mux */
  smc->r.rm_loop = FALSE ;
  smc->r.rm_join = TRUE ;
  queue_event(smc,EVENT_RMT,RM_JOIN) ;/* signal RMT */
  ACTIONS_DONE() ;
  DB_CFMN(1, "CFM : %s", cfm_states[smc->mib.fddiSMTCF_State]);
  break ;
 case SC5_THRU_B :
  /*SC51*/
  if (!smc->y[PB].cf_join || smc->y[PB].wc_flag) {
   smc->y[PA].scrub = TRUE ;
   GO_STATE(SC9_C_WRAP_A) ;
   break ;
  }
  /*SC52*/
  else if (!smc->y[PA].cf_join || smc->y[PA].wc_flag) {
   smc->y[PB].scrub = TRUE ;
   GO_STATE(SC10_C_WRAP_B) ;
   break ;
  }
  /*SC54*/
  else if (!smc->s.attach_s) {
   smc->y[PA].scrub = TRUE ;
   GO_STATE(SC4_THRU_A) ;
   break ;
  }
  break ;
 case ACTIONS(SC11_C_WRAP_S) :
  smc->mib.p[PS].fddiPORTCurrentPath = MIB_PATH_CONCATENATED ;
  smc->mib.p[PS].fddiPORTMACPlacement = INDEX_MAC ;
  smc->mib.fddiSMTStationStatus = MIB_SMT_STASTA_CON ;
  config_mux(smc,MUX_WRAPS) ;  /* configure PHY mux */
  if (smc->y[PA].cf_loop || smc->y[PB].cf_loop) {
   smc->r.rm_join = FALSE ;
   smc->r.rm_loop = TRUE ;
   queue_event(smc,EVENT_RMT,RM_LOOP) ;/* signal RMT */
  }
  if (smc->y[PA].cf_join || smc->y[PB].cf_join) {
   smc->r.rm_loop = FALSE ;
   smc->r.rm_join = TRUE ;
   queue_event(smc,EVENT_RMT,RM_JOIN) ;/* signal RMT */
  }
  ACTIONS_DONE() ;
  DB_CFMN(1, "CFM : %s", cfm_states[smc->mib.fddiSMTCF_State]);
  break ;
 case SC11_C_WRAP_S :
  /*SC70*/
  if ( !smc->y[PA].cf_join && !smc->y[PA].cf_loop &&
       !smc->y[PB].cf_join && !smc->y[PB].cf_loop) {
   GO_STATE(SC0_ISOLATED) ;
   break ;
  }
  break ;
 default:
  SMT_PANIC(smc,SMT_E0106, SMT_E0106_MSG) ;
  break;
 }
}

/*
 * get MAC's input Port
 * return :
 * PA or PB
 */
int cfm_get_mac_input(struct s_smc *smc)
{
 return (smc->mib.fddiSMTCF_State == SC10_C_WRAP_B ||
  smc->mib.fddiSMTCF_State == SC5_THRU_B) ? PB : PA;
}

/*
 * get MAC's output Port
 * return :
 * PA or PB
 */
int cfm_get_mac_output(struct s_smc *smc)
{
 return (smc->mib.fddiSMTCF_State == SC10_C_WRAP_B ||
  smc->mib.fddiSMTCF_State == SC4_THRU_A) ? PB : PA;
}

static char path_iso[] = {
 0,0, 0,RES_PORT, 0,PA + INDEX_PORT, 0,PATH_ISO,
 0,0, 0,RES_MAC, 0,INDEX_MAC,  0,PATH_ISO,
 0,0, 0,RES_PORT, 0,PB + INDEX_PORT, 0,PATH_ISO
} ;

static char path_wrap_a[] = {
 0,0, 0,RES_PORT, 0,PA + INDEX_PORT, 0,PATH_PRIM,
 0,0, 0,RES_MAC, 0,INDEX_MAC,  0,PATH_PRIM,
 0,0, 0,RES_PORT, 0,PB + INDEX_PORT, 0,PATH_ISO
} ;

static char path_wrap_b[] = {
 0,0, 0,RES_PORT, 0,PB + INDEX_PORT, 0,PATH_PRIM,
 0,0, 0,RES_MAC, 0,INDEX_MAC,  0,PATH_PRIM,
 0,0, 0,RES_PORT, 0,PA + INDEX_PORT, 0,PATH_ISO
} ;

static char path_thru[] = {
 0,0, 0,RES_PORT, 0,PA + INDEX_PORT, 0,PATH_PRIM,
 0,0, 0,RES_MAC, 0,INDEX_MAC,  0,PATH_PRIM,
 0,0, 0,RES_PORT, 0,PB + INDEX_PORT, 0,PATH_PRIM
} ;

static char path_wrap_s[] = {
 0,0, 0,RES_PORT, 0,PS + INDEX_PORT, 0,PATH_PRIM,
 0,0, 0,RES_MAC, 0,INDEX_MAC,  0,PATH_PRIM,
} ;

static char path_iso_s[] = {
 0,0, 0,RES_PORT, 0,PS + INDEX_PORT, 0,PATH_ISO,
 0,0, 0,RES_MAC, 0,INDEX_MAC,  0,PATH_ISO,
} ;

int cem_build_path(struct s_smc *smc, char *to, int path_index)
{
 char *path ;
 int len ;

 switch (smc->mib.fddiSMTCF_State) {
 default :
 case SC0_ISOLATED :
  path = smc->s.sas ? path_iso_s : path_iso ;
  len = smc->s.sas ? sizeof(path_iso_s) :  sizeof(path_iso) ;
  break ;
 case SC9_C_WRAP_A :
  path = path_wrap_a ;
  len = sizeof(path_wrap_a) ;
  break ;
 case SC10_C_WRAP_B :
  path = path_wrap_b ;
  len = sizeof(path_wrap_b) ;
  break ;
 case SC4_THRU_A :
  path = path_thru ;
  len = sizeof(path_thru) ;
  break ;
 case SC11_C_WRAP_S :
  path = path_wrap_s ;
  len = sizeof(path_wrap_s) ;
  break ;
 }
 memcpy(to,path,len) ;

 LINT_USE(path_index);

 return len;
}