cregit-Linux how code gets into the kernel

Release 4.11 drivers/net/fddi/skfp/rmt.c

Directory: drivers/net/fddi/skfp
/******************************************************************************
 *
 *      (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 */

/*
 * 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"
} ;

/*
 * 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 ;
}


Contributors
PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)9498.95%150.00%


Stephen Hemminger11.05%150.00%


Total95100.00%2100.00%



/*
        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 event %s",
		       smc->mib.m[MAC0].fddiMACRMTState & AFLAG ? "ACTIONS " : "",
		       rmt_states[smc->mib.m[MAC0].fddiMACRMTState & ~AFLAG],
		       rmt_events[event]);
		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) ;
}


Contributors
PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)11997.54%133.33%


Stephen Hemminger21.64%133.33%


Joe Perches10.82%133.33%


Total122100.00%3100.00%



/*
        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");
		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");
		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");
		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");
		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");
				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)",
				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");
		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");
				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)",
				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");
		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");
		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");
		ACTIONS_DONE() ;
		break ;
	case RM7_TRACE :
		break ;
	default:
		SMT_PANIC(smc,SMT_E0122, SMT_E0122_MSG) ;
		break;
	}
}


Contributors
PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)163199.15%133.33%


Joe Perches120.73%133.33%


Stephen Hemminger20.12%133.33%


Total1645100.00%3100.00%



/*
 * (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) ;
		}
	}
}


Contributors
PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)6398.44%150.00%


Stephen Hemminger11.56%150.00%


Total64100.00%2100.00%



/*
 * 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) ;
}


Contributors
PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)2896.55%150.00%


Stephen Hemminger13.45%150.00%


Total29100.00%2100.00%



/*
 * 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) ;
	}
}



Contributors
PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)7698.70%150.00%


Stephen Hemminger11.30%150.00%


Total77100.00%2100.00%



/*
 * 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!
         */
}


Contributors
PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)2095.24%150.00%


Stephen Hemminger14.76%150.00%


Total21100.00%2100.00%



/*
 * 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));
}


Contributors
PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)4493.62%150.00%


Stephen Hemminger36.38%150.00%


Total47100.00%2100.00%



/*
 * 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));
}


Contributors
PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)4493.62%150.00%


Stephen Hemminger36.38%150.00%


Total47100.00%2100.00%



/*
 * 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));
}


Contributors
PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)4493.62%150.00%


Stephen Hemminger36.38%150.00%


Total47100.00%2100.00%



/*
 * 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) ;
}


Contributors
PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)3296.97%150.00%


Stephen Hemminger13.03%150.00%


Total33100.00%2100.00%



/*
 * 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) ;
}


Contributors
PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)3296.97%150.00%


Stephen Hemminger13.03%150.00%


Total33100.00%2100.00%



/*
 * 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) ;
}


Contributors
PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)3296.97%150.00%


Stephen Hemminger13.03%150.00%


Total33100.00%2100.00%




Overall Contributors
PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)249895.34%125.00%


Stephen Hemminger1084.12%125.00%


Joe Perches130.50%125.00%


Steven Cole10.04%125.00%


Total2620100.00%4100.00%


Directory: drivers/net/fddi/skfp



Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.