text: /******************************************************************************
   *
   *	(C)Copyright 1998,1999 SysKonnect,
   *	a business unit of Schneider & Koch & Co. Datensysteme GmbH.
   *
   *	See the file "skfddi.c" for further information.
   *
   *	This program is free software; you can redistribute it and/or modify
   *	it under the terms of the GNU General Public License as published by
   *	the Free Software Foundation; either version 2 of the License, or
   *	(at your option) any later version.
   *
   *	The information in this file is provided "AS IS" without warranty.
   *
   ******************************************************************************/
  
  /*
  	SMT RMT
  	Ring Management
  */
  
  /*
   * 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_ma_control()
   *		sm_mac_check_beacon_claim()
   *
   * 	The following HW dependent events are required :
   *		RM_RING_OP
   *		RM_RING_NON_OP
   *		RM_MY_BEACON
   *		RM_OTHER_BEACON
   *		RM_MY_CLAIM
   *		RM_TRT_EXP
   *		RM_VALID_CLAIM
   *
   */
  
  #include "h/types.h"
  #include "h/fddi.h"
  #include "h/smc.h"
  
  #define KERNEL
  #include "h/smtstate.h"
  
  #ifndef	lint
  static const char ID_sccs[] = "@(#)rmt.c	2.13 99/07/02 (C) SK " ;
  #endif
  
  /*
   * FSM Macros
   */
  #define AFLAG	0x10
  #define GO_STATE(x)	(smc->mib.m[MAC0].fddiMACRMTState = (x)|AFLAG)
  #define ACTIONS_DONE()	(smc->mib.m[MAC0].fddiMACRMTState &= ~AFLAG)
  #define ACTIONS(x)	(x|AFLAG)
  
  #define RM0_ISOLATED	0
  #define RM1_NON_OP	1		/* not operational */
  #define RM2_RING_OP	2		/* ring operational */
  #define RM3_DETECT	3		/* detect dupl addresses */
  #define RM4_NON_OP_DUP	4		/* dupl. addr detected */
  #define RM5_RING_OP_DUP	5		/* ring oper. with dupl. addr */
  #define RM6_DIRECTED	6		/* sending directed beacons */
  #define RM7_TRACE	7		/* trace initiated */
  
  #ifdef	DEBUG
  /*
   * symbolic state names
   */
  static const char * const rmt_states[] = {
  	"RM0_ISOLATED","RM1_NON_OP","RM2_RING_OP","RM3_DETECT",
  	"RM4_NON_OP_DUP","RM5_RING_OP_DUP","RM6_DIRECTED",
  	"RM7_TRACE"
  } ;
  
  /*
   * symbolic event names
   */
  static const char * const rmt_events[] = {
  	"NONE","RM_RING_OP","RM_RING_NON_OP","RM_MY_BEACON",
  	"RM_OTHER_BEACON","RM_MY_CLAIM","RM_TRT_EXP","RM_VALID_CLAIM",
  	"RM_JOIN","RM_LOOP","RM_DUP_ADDR","RM_ENABLE_FLAG",
  	"RM_TIMEOUT_NON_OP","RM_TIMEOUT_T_STUCK",
  	"RM_TIMEOUT_ANNOUNCE","RM_TIMEOUT_T_DIRECT",
  	"RM_TIMEOUT_D_MAX","RM_TIMEOUT_POLL","RM_TX_STATE_CHANGE"
  } ;
  #endif
  
  /*
   * Globals
   * in struct s_rmt
   */
  
  
  /*
   * function declarations
   */
  static void rmt_fsm(struct s_smc *smc, int cmd);
  static void start_rmt_timer0(struct s_smc *smc, u_long value, int event);
  static void start_rmt_timer1(struct s_smc *smc, u_long value, int event);
  static void start_rmt_timer2(struct s_smc *smc, u_long value, int event);
  static void stop_rmt_timer0(struct s_smc *smc);
  static void stop_rmt_timer1(struct s_smc *smc);
  static void stop_rmt_timer2(struct s_smc *smc);
  static void rmt_dup_actions(struct s_smc *smc);
  static void rmt_reinsert_actions(struct s_smc *smc);
  static void rmt_leave_actions(struct s_smc *smc);
  static void rmt_new_dup_actions(struct s_smc *smc);
  
  #ifndef SUPERNET_3
  extern void restart_trt_for_dbcn() ;
  #endif /*SUPERNET_3*/
  
  /*
  	init RMT state machine
  	clear all RMT vars and flags
  */
  void rmt_init(struct s_smc *smc)
  {
  	smc->mib.m[MAC0].fddiMACRMTState = ACTIONS(RM0_ISOLATED) ;
  	smc->r.dup_addr_test = DA_NONE ;
  	smc->r.da_flag = 0 ;
  	smc->mib.m[MAC0].fddiMACMA_UnitdataAvailable = FALSE ;
  	smc->r.sm_ma_avail = FALSE ;
  	smc->r.loop_avail = 0 ;
  	smc->r.bn_flag = 0 ;
  	smc->r.jm_flag = 0 ;
  	smc->r.no_flag = TRUE ;
  }
  
  /*
  	RMT state machine
  	called by dispatcher
  
  	do
  		display state change
  		process event
  	until SM is stable
  */
  void rmt(struct s_smc *smc, int event)
  {
  	int	state ;
  
  	do {
  		DB_RMT("RMT : state %s%s",
  			(smc->mib.m[MAC0].fddiMACRMTState & AFLAG) ? "ACTIONS " : "",
  			rmt_states[smc->mib.m[MAC0].fddiMACRMTState & ~AFLAG]) ;
  		DB_RMT(" event %s\n",rmt_events[event],0) ;
  		state = smc->mib.m[MAC0].fddiMACRMTState ;
  		rmt_fsm(smc,event) ;
  		event = 0 ;
  	} while (state != smc->mib.m[MAC0].fddiMACRMTState) ;
  	rmt_state_change(smc,(int)smc->mib.m[MAC0].fddiMACRMTState) ;
  }
  
  /*
  	process RMT event
  */
  static void rmt_fsm(struct s_smc *smc, int cmd)
  {
  	/*
  	 * RM00-RM70 : from all states
  	 */
  	if (!smc->r.rm_join && !smc->r.rm_loop &&
  		smc->mib.m[MAC0].fddiMACRMTState != ACTIONS(RM0_ISOLATED) &&
  		smc->mib.m[MAC0].fddiMACRMTState != RM0_ISOLATED) {
  		RS_SET(smc,RS_NORINGOP) ;
  		rmt_indication(smc,0) ;
  		GO_STATE(RM0_ISOLATED) ;
  		return ;
  	}
  
  	switch(smc->mib.m[MAC0].fddiMACRMTState) {
  	case ACTIONS(RM0_ISOLATED) :
  		stop_rmt_timer0(smc) ;
  		stop_rmt_timer1(smc) ;
  		stop_rmt_timer2(smc) ;
  
  		/*
  		 * Disable MAC.
  		 */
  		sm_ma_control(smc,MA_OFFLINE) ;
  		smc->mib.m[MAC0].fddiMACMA_UnitdataAvailable = FALSE ;
  		smc->r.loop_avail = FALSE ;
  		smc->r.sm_ma_avail = FALSE ;
  		smc->r.no_flag = TRUE ;
  		DB_RMTN(1,"RMT : ISOLATED\n",0,0) ;
  		ACTIONS_DONE() ;
  		break ;
  	case RM0_ISOLATED :
  		/*RM01*/
  		if (smc->r.rm_join || smc->r.rm_loop) {
  			/*
  			 * According to the standard the MAC must be reset
  			 * here. The FORMAC will be initialized and Claim
  			 * and Beacon Frames will be uploaded to the MAC.
  			 * So any change of Treq will take effect NOW.
  			 */
  			sm_ma_control(smc,MA_RESET) ;
  			GO_STATE(RM1_NON_OP) ;
  			break ;
  		}
  		break ;
  	case ACTIONS(RM1_NON_OP) :
  		start_rmt_timer0(smc,smc->s.rmt_t_non_op,RM_TIMEOUT_NON_OP) ;
  		stop_rmt_timer1(smc) ;
  		stop_rmt_timer2(smc) ;
  		sm_ma_control(smc,MA_BEACON) ;
  		DB_RMTN(1,"RMT : RING DOWN\n",0,0) ;
  		RS_SET(smc,RS_NORINGOP) ;
  		smc->r.sm_ma_avail = FALSE ;
  		rmt_indication(smc,0) ;
  		ACTIONS_DONE() ;
  		break ;
  	case RM1_NON_OP :
  		/*RM12*/
  		if (cmd == RM_RING_OP) {
  			RS_SET(smc,RS_RINGOPCHANGE) ;
  			GO_STATE(RM2_RING_OP) ;
  			break ;
  		}
  		/*RM13*/
  		else if (cmd == RM_TIMEOUT_NON_OP) {
  			smc->r.bn_flag = FALSE ;
  			smc->r.no_flag = TRUE ;
  			GO_STATE(RM3_DETECT) ;
  			break ;
  		}
  		break ;
  	case ACTIONS(RM2_RING_OP) :
  		stop_rmt_timer0(smc) ;
  		stop_rmt_timer1(smc) ;
  		stop_rmt_timer2(smc) ;
  		smc->r.no_flag = FALSE ;
  		if (smc->r.rm_loop)
  			smc->r.loop_avail = TRUE ;
  		if (smc->r.rm_join) {
  			smc->r.sm_ma_avail = TRUE ;
  			if (smc->mib.m[MAC0].fddiMACMA_UnitdataEnable)
  			smc->mib.m[MAC0].fddiMACMA_UnitdataAvailable = TRUE ;
  				else
  			smc->mib.m[MAC0].fddiMACMA_UnitdataAvailable = FALSE ;
  		}
  		DB_RMTN(1,"RMT : RING UP\n",0,0) ;
  		RS_CLEAR(smc,RS_NORINGOP) ;
  		RS_SET(smc,RS_RINGOPCHANGE) ;
  		rmt_indication(smc,1) ;
  		smt_stat_counter(smc,0) ;
  		ACTIONS_DONE() ;
  		break ;
  	case RM2_RING_OP :
  		/*RM21*/
  		if (cmd == RM_RING_NON_OP) {
  			smc->mib.m[MAC0].fddiMACMA_UnitdataAvailable = FALSE ;
  			smc->r.loop_avail = FALSE ;
  			RS_SET(smc,RS_RINGOPCHANGE) ;
  			GO_STATE(RM1_NON_OP) ;
  			break ;
  		}
  		/*RM22a*/
  		else if (cmd == RM_ENABLE_FLAG) {
  			if (smc->mib.m[MAC0].fddiMACMA_UnitdataEnable)
  			smc->mib.m[MAC0].fddiMACMA_UnitdataAvailable = TRUE ;
  				else
  			smc->mib.m[MAC0].fddiMACMA_UnitdataAvailable = FALSE ;
  		}
  		/*RM25*/
  		else if (smc->r.dup_addr_test == DA_FAILED) {
  			smc->mib.m[MAC0].fddiMACMA_UnitdataAvailable = FALSE ;
  			smc->r.loop_avail = FALSE ;
  			smc->r.da_flag = TRUE ;
  			GO_STATE(RM5_RING_OP_DUP) ;
  			break ;
  		}
  		break ;
  	case ACTIONS(RM3_DETECT) :
  		start_rmt_timer0(smc,smc->s.mac_d_max*2,RM_TIMEOUT_D_MAX) ;
  		start_rmt_timer1(smc,smc->s.rmt_t_stuck,RM_TIMEOUT_T_STUCK) ;
  		start_rmt_timer2(smc,smc->s.rmt_t_poll,RM_TIMEOUT_POLL) ;
  		sm_mac_check_beacon_claim(smc) ;
  		DB_RMTN(1,"RMT : RM3_DETECT\n",0,0) ;
  		ACTIONS_DONE() ;
  		break ;
  	case RM3_DETECT :
  		if (cmd == RM_TIMEOUT_POLL) {
  			start_rmt_timer2(smc,smc->s.rmt_t_poll,RM_TIMEOUT_POLL);
  			sm_mac_check_beacon_claim(smc) ;
  			break ;
  		}
  		if (cmd == RM_TIMEOUT_D_MAX) {
  			smc->r.timer0_exp = TRUE ;
  		}
  		/*
  		 *jd(22-Feb-1999)
  		 * We need a time ">= 2*mac_d_max" since we had finished
  		 * Claim or Beacon state. So we will restart timer0 at
  		 * every state change.
  		 */
  		if (cmd == RM_TX_STATE_CHANGE) {
  			start_rmt_timer0(smc,
  					 smc->s.mac_d_max*2,
  					 RM_TIMEOUT_D_MAX) ;
  		}
  		/*RM32*/
  		if (cmd == RM_RING_OP) {
  			GO_STATE(RM2_RING_OP) ;
  			break ;
  		}
  		/*RM33a*/
  		else if ((cmd == RM_MY_BEACON || cmd == RM_OTHER_BEACON)
  			&& smc->r.bn_flag) {
  			smc->r.bn_flag = FALSE ;
  		}
  		/*RM33b*/
  		else if (cmd == RM_TRT_EXP && !smc->r.bn_flag) {
  			int	tx ;
  			/*
  			 * set bn_flag only if in state T4 or T5:
  			 * only if we're the beaconer should we start the
  			 * trace !
  			 */
  			if ((tx =  sm_mac_get_tx_state(smc)) == 4 || tx == 5) {
  			DB_RMTN(2,"RMT : DETECT && TRT_EXPIRED && T4/T5\n",0,0);
  				smc->r.bn_flag = TRUE ;
  				/*
  				 * If one of the upstream stations beaconed
  				 * and the link to the upstream neighbor is
  				 * lost we need to restart the stuck timer to
  				 * check the "stuck beacon" condition.
  				 */
  				start_rmt_timer1(smc,smc->s.rmt_t_stuck,
  					RM_TIMEOUT_T_STUCK) ;
  			}
  			/*
  			 * We do NOT need to clear smc->r.bn_flag in case of
  			 * not being in state T4 or T5, because the flag
  			 * must be cleared in order to get in this condition.
  			 */
  
  			DB_RMTN(2,
  			"RMT : sm_mac_get_tx_state() = %d (bn_flag = %d)\n",
  			tx,smc->r.bn_flag) ;
  		}
  		/*RM34a*/
  		else if (cmd == RM_MY_CLAIM && smc->r.timer0_exp) {
  			rmt_new_dup_actions(smc) ;
  			GO_STATE(RM4_NON_OP_DUP) ;
  			break ;
  		}
  		/*RM34b*/
  		else if (cmd == RM_MY_BEACON && smc->r.timer0_exp) {
  			rmt_new_dup_actions(smc) ;
  			GO_STATE(RM4_NON_OP_DUP) ;
  			break ;
  		}
  		/*RM34c*/
  		else if (cmd == RM_VALID_CLAIM) {
  			rmt_new_dup_actions(smc) ;
  			GO_STATE(RM4_NON_OP_DUP) ;
  			break ;
  		}
  		/*RM36*/
  		else if (cmd == RM_TIMEOUT_T_STUCK &&
  			smc->r.rm_join && smc->r.bn_flag) {
  			GO_STATE(RM6_DIRECTED) ;
  			break ;
  		}
  		break ;
  	case ACTIONS(RM4_NON_OP_DUP) :
  		start_rmt_timer0(smc,smc->s.rmt_t_announce,RM_TIMEOUT_ANNOUNCE);
  		start_rmt_timer1(smc,smc->s.rmt_t_stuck,RM_TIMEOUT_T_STUCK) ;
  		start_rmt_timer2(smc,smc->s.rmt_t_poll,RM_TIMEOUT_POLL) ;
  		sm_mac_check_beacon_claim(smc) ;
  		DB_RMTN(1,"RMT : RM4_NON_OP_DUP\n",0,0) ;
  		ACTIONS_DONE() ;
  		break ;
  	case RM4_NON_OP_DUP :
  		if (cmd == RM_TIMEOUT_POLL) {
  			start_rmt_timer2(smc,smc->s.rmt_t_poll,RM_TIMEOUT_POLL);
  			sm_mac_check_beacon_claim(smc) ;
  			break ;
  		}
  		/*RM41*/
  		if (!smc->r.da_flag) {
  			GO_STATE(RM1_NON_OP) ;
  			break ;
  		}
  		/*RM44a*/
  		else if ((cmd == RM_MY_BEACON || cmd == RM_OTHER_BEACON) &&
  			smc->r.bn_flag) {
  			smc->r.bn_flag = FALSE ;
  		}
  		/*RM44b*/
  		else if (cmd == RM_TRT_EXP && !smc->r.bn_flag) {
  			int	tx ;
  			/*
  			 * set bn_flag only if in state T4 or T5:
  			 * only if we're the beaconer should we start the
  			 * trace !
  			 */
  			if ((tx =  sm_mac_get_tx_state(smc)) == 4 || tx == 5) {
  			DB_RMTN(2,"RMT : NOPDUP && TRT_EXPIRED && T4/T5\n",0,0);
  				smc->r.bn_flag = TRUE ;
  				/*
  				 * If one of the upstream stations beaconed
  				 * and the link to the upstream neighbor is
  				 * lost we need to restart the stuck timer to
  				 * check the "stuck beacon" condition.
  				 */
  				start_rmt_timer1(smc,smc->s.rmt_t_stuck,
  					RM_TIMEOUT_T_STUCK) ;
  			}
  			/*
  			 * We do NOT need to clear smc->r.bn_flag in case of
  			 * not being in state T4 or T5, because the flag
  			 * must be cleared in order to get in this condition.
  			 */
  
  			DB_RMTN(2,
  			"RMT : sm_mac_get_tx_state() = %d (bn_flag = %d)\n",
  			tx,smc->r.bn_flag) ;
  		}
  		/*RM44c*/
  		else if (cmd == RM_TIMEOUT_ANNOUNCE && !smc->r.bn_flag) {
  			rmt_dup_actions(smc) ;
  		}
  		/*RM45*/
  		else if (cmd == RM_RING_OP) {
  			smc->r.no_flag = FALSE ;
  			GO_STATE(RM5_RING_OP_DUP) ;
  			break ;
  		}
  		/*RM46*/
  		else if (cmd == RM_TIMEOUT_T_STUCK &&
  			smc->r.rm_join && smc->r.bn_flag) {
  			GO_STATE(RM6_DIRECTED) ;
  			break ;
  		}
  		break ;
  	case ACTIONS(RM5_RING_OP_DUP) :
  		stop_rmt_timer0(smc) ;
  		stop_rmt_timer1(smc) ;
  		stop_rmt_timer2(smc) ;
  		DB_RMTN(1,"RMT : RM5_RING_OP_DUP\n",0,0) ;
  		ACTIONS_DONE() ;
  		break;
  	case RM5_RING_OP_DUP :
  		/*RM52*/
  		if (smc->r.dup_addr_test == DA_PASSED) {
  			smc->r.da_flag = FALSE ;
  			GO_STATE(RM2_RING_OP) ;
  			break ;
  		}
  		/*RM54*/
  		else if (cmd == RM_RING_NON_OP) {
  			smc->r.jm_flag = FALSE ;
  			smc->r.bn_flag = FALSE ;
  			GO_STATE(RM4_NON_OP_DUP) ;
  			break ;
  		}
  		break ;
  	case ACTIONS(RM6_DIRECTED) :
  		start_rmt_timer0(smc,smc->s.rmt_t_direct,RM_TIMEOUT_T_DIRECT) ;
  		stop_rmt_timer1(smc) ;
  		start_rmt_timer2(smc,smc->s.rmt_t_poll,RM_TIMEOUT_POLL) ;
  		sm_ma_control(smc,MA_DIRECTED) ;
  		RS_SET(smc,RS_BEACON) ;
  		DB_RMTN(1,"RMT : RM6_DIRECTED\n",0,0) ;
  		ACTIONS_DONE() ;
  		break ;
  	case RM6_DIRECTED :
  		/*RM63*/
  		if (cmd == RM_TIMEOUT_POLL) {
  			start_rmt_timer2(smc,smc->s.rmt_t_poll,RM_TIMEOUT_POLL);
  			sm_mac_check_beacon_claim(smc) ;
  #ifndef SUPERNET_3
  			/* Because of problems with the Supernet II chip set
  			 * sending of Directed Beacon will stop after 165ms
  			 * therefore restart_trt_for_dbcn(smc) will be called
  			 * to prevent this.
  			 */
  			restart_trt_for_dbcn(smc) ;
  #endif /*SUPERNET_3*/
  			break ;
  		}
  		if ((cmd == RM_MY_BEACON || cmd == RM_OTHER_BEACON) &&
  			!smc->r.da_flag) {
  			smc->r.bn_flag = FALSE ;
  			GO_STATE(RM3_DETECT) ;
  			break ;
  		}
  		/*RM64*/
  		else if ((cmd == RM_MY_BEACON || cmd == RM_OTHER_BEACON) &&
  			smc->r.da_flag) {
  			smc->r.bn_flag = FALSE ;
  			GO_STATE(RM4_NON_OP_DUP) ;
  			break ;
  		}
  		/*RM67*/
  		else if (cmd == RM_TIMEOUT_T_DIRECT) {
  			GO_STATE(RM7_TRACE) ;
  			break ;
  		}
  		break ;
  	case ACTIONS(RM7_TRACE) :
  		stop_rmt_timer0(smc) ;
  		stop_rmt_timer1(smc) ;
  		stop_rmt_timer2(smc) ;
  		smc->e.trace_prop |= ENTITY_BIT(ENTITY_MAC) ;
  		queue_event(smc,EVENT_ECM,EC_TRACE_PROP) ;
  		DB_RMTN(1,"RMT : RM7_TRACE\n",0,0) ;
  		ACTIONS_DONE() ;
  		break ;
  	case RM7_TRACE :
  		break ;
  	default:
  		SMT_PANIC(smc,SMT_E0122, SMT_E0122_MSG) ;
  		break;
  	}
  }
  
  /*
   * (jd) RMT duplicate address actions
   * leave the ring or reinsert just as configured
   */
  static void rmt_dup_actions(struct s_smc *smc)
  {
  	if (smc->r.jm_flag) {
  	}
  	else {
  		if (smc->s.rmt_dup_mac_behavior) {
  			SMT_ERR_LOG(smc,SMT_E0138, SMT_E0138_MSG) ;
                          rmt_reinsert_actions(smc) ;
  		}
  		else {
  			SMT_ERR_LOG(smc,SMT_E0135, SMT_E0135_MSG) ;
  			rmt_leave_actions(smc) ;
  		}
  	}
  }
  
  /*
   * Reconnect to the Ring
   */
  static void rmt_reinsert_actions(struct s_smc *smc)
  {
  	queue_event(smc,EVENT_ECM,EC_DISCONNECT) ;
  	queue_event(smc,EVENT_ECM,EC_CONNECT) ;
  }
  
  /*
   * duplicate address detected
   */
  static void rmt_new_dup_actions(struct s_smc *smc)
  {
  	smc->r.da_flag = TRUE ;
  	smc->r.bn_flag = FALSE ;
  	smc->r.jm_flag = FALSE ;
  	/*
  	 * we have three options : change address, jam or leave
  	 * we leave the ring as default 
  	 * Optionally it's possible to reinsert after leaving the Ring
  	 * but this will not conform with SMT Spec.
  	 */
  	if (smc->s.rmt_dup_mac_behavior) {
  		SMT_ERR_LOG(smc,SMT_E0138, SMT_E0138_MSG) ;
  		rmt_reinsert_actions(smc) ;
  	}
  	else {
  		SMT_ERR_LOG(smc,SMT_E0135, SMT_E0135_MSG) ;
  		rmt_leave_actions(smc) ;
  	}
  }
  
  
  /*
   * leave the ring
   */
  static void rmt_leave_actions(struct s_smc *smc)
  {
  	queue_event(smc,EVENT_ECM,EC_DISCONNECT) ;
  	/*
  	 * Note: Do NOT try again later. (with please reconnect)
  	 * The station must be left from the ring!
  	 */
  }
  
  /*
   * SMT timer interface
   *	start RMT timer 0
   */
  static void start_rmt_timer0(struct s_smc *smc, u_long value, int event)
  {
  	smc->r.timer0_exp = FALSE ;		/* clear timer event flag */
  	smt_timer_start(smc,&smc->r.rmt_timer0,value,EV_TOKEN(EVENT_RMT,event));
  }
  
  /*
   * SMT timer interface
   *	start RMT timer 1
   */
  static void start_rmt_timer1(struct s_smc *smc, u_long value, int event)
  {
  	smc->r.timer1_exp = FALSE ;	/* clear timer event flag */
  	smt_timer_start(smc,&smc->r.rmt_timer1,value,EV_TOKEN(EVENT_RMT,event));
  }
  
  /*
   * SMT timer interface
   *	start RMT timer 2
   */
  static void start_rmt_timer2(struct s_smc *smc, u_long value, int event)
  {
  	smc->r.timer2_exp = FALSE ;		/* clear timer event flag */
  	smt_timer_start(smc,&smc->r.rmt_timer2,value,EV_TOKEN(EVENT_RMT,event));
  }
  
  /*
   * SMT timer interface
   *	stop RMT timer 0
   */
  static void stop_rmt_timer0(struct s_smc *smc)
  {
  	if (smc->r.rmt_timer0.tm_active)
  		smt_timer_stop(smc,&smc->r.rmt_timer0) ;
  }
  
  /*
   * SMT timer interface
   *	stop RMT timer 1
   */
  static void stop_rmt_timer1(struct s_smc *smc)
  {
  	if (smc->r.rmt_timer1.tm_active)
  		smt_timer_stop(smc,&smc->r.rmt_timer1) ;
  }
  
  /*
   * SMT timer interface
   *	stop RMT timer 2
   */
  static void stop_rmt_timer2(struct s_smc *smc)
  {
  	if (smc->r.rmt_timer2.tm_active)
  		smt_timer_stop(smc,&smc->r.rmt_timer2) ;
  }
  
  