开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
rmt.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：16k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

rmt.c：源码内容
  1. /******************************************************************************
  2.  *
  3.  * (C)Copyright 1998,1999 SysKonnect,
  4.  * a business unit of Schneider & Koch & Co. Datensysteme GmbH.
  5.  *
  6.  * See the file "skfddi.c" for further information.
  7.  *
  8.  * This program is free software; you can redistribute it and/or modify
  9.  * it under the terms of the GNU General Public License as published by
  10.  * the Free Software Foundation; either version 2 of the License, or
  11.  * (at your option) any later version.
  12.  *
  13.  * The information in this file is provided "AS IS" without warranty.
  14.  *
  15.  ******************************************************************************/
  17. /*
  18. SMT RMT
  19. Ring Management
  20. */
  22. /*
  23.  * Hardware independant state machine implemantation
  24.  * The following external SMT functions are referenced :
  25.  *
  26.  *  queue_event()
  27.  *  smt_timer_start()
  28.  *  smt_timer_stop()
  29.  *
  30.  *  The following external HW dependant functions are referenced :
  31.  * sm_ma_control()
  32.  * sm_mac_check_beacon_claim()
  33.  *
  34.  *  The following HW dependant events are required :
  35.  * RM_RING_OP
  36.  * RM_RING_NON_OP
  37.  * RM_MY_BEACON
  38.  * RM_OTHER_BEACON
  39.  * RM_MY_CLAIM
  40.  * RM_TRT_EXP
  41.  * RM_VALID_CLAIM
  42.  *
  43.  */
  45. #include "h/types.h"
  46. #include "h/fddi.h"
  47. #include "h/smc.h"
  49. #define KERNEL
  50. #include "h/smtstate.h"
  52. #ifndef lint
  53. static const char ID_sccs[] = "@(#)rmt.c 2.13 99/07/02 (C) SK " ;
  54. #endif
  56. /*
  57.  * FSM Macros
  58.  */
  59. #define AFLAG 0x10
  60. #define GO_STATE(x) (smc->mib.m[MAC0].fddiMACRMTState = (x)|AFLAG)
  61. #define ACTIONS_DONE() (smc->mib.m[MAC0].fddiMACRMTState &= ~AFLAG)
  62. #define ACTIONS(x) (x|AFLAG)
  64. #define RM0_ISOLATED 0
  65. #define RM1_NON_OP 1 /* not operational */
  66. #define RM2_RING_OP 2 /* ring operational */
  67. #define RM3_DETECT 3 /* detect dupl addresses */
  68. #define RM4_NON_OP_DUP 4 /* dupl. addr detected */
  69. #define RM5_RING_OP_DUP 5 /* ring oper. with dupl. addr */
  70. #define RM6_DIRECTED 6 /* sending directed beacons */
  71. #define RM7_TRACE 7 /* trace initiated */
  73. #ifdef DEBUG
  74. /*
  75.  * symbolic state names
  76.  */
  77. static const char * const rmt_states[] = {
  78. "RM0_ISOLATED","RM1_NON_OP","RM2_RING_OP","RM3_DETECT",
  79. "RM4_NON_OP_DUP","RM5_RING_OP_DUP","RM6_DIRECTED",
  80. "RM7_TRACE"
  81. } ;
  83. /*
  84.  * symbolic event names
  85.  */
  86. static const char * const rmt_events[] = {
  87. "NONE","RM_RING_OP","RM_RING_NON_OP","RM_MY_BEACON",
  88. "RM_OTHER_BEACON","RM_MY_CLAIM","RM_TRT_EXP","RM_VALID_CLAIM",
  89. "RM_JOIN","RM_LOOP","RM_DUP_ADDR","RM_ENABLE_FLAG",
  90. "RM_TIMEOUT_NON_OP","RM_TIMEOUT_T_STUCK",
  91. "RM_TIMEOUT_ANNOUNCE","RM_TIMEOUT_T_DIRECT",
  92. "RM_TIMEOUT_D_MAX","RM_TIMEOUT_POLL","RM_TX_STATE_CHANGE"
  93. } ;
  94. #endif
  96. /*
  97.  * Globals
  98.  * in struct s_rmt
  99.  */
  102. /*
  103.  * function declarations
  104.  */
  105. static void rmt_fsm() ;
  106. static void start_rmt_timer0() ;
  107. static void start_rmt_timer1() ;
  108. static void start_rmt_timer2() ;
  109. static void stop_rmt_timer0() ;
  110. static void stop_rmt_timer1() ;
  111. static void stop_rmt_timer2() ;
  112. static void rmt_dup_actions() ;
  113. static void rmt_reinsert_actions() ;
  114. static void rmt_leave_actions() ;
  115. static void rmt_new_dup_actions() ;
  117. #ifndef SUPERNET_3
  118. extern void restart_trt_for_dbcn() ;
  119. #endif /*SUPERNET_3*/
  121. /*
  122. init RMT state machine
  123. clear all RMT vars and flags
  124. */
  125. void rmt_init(smc)
  126. struct s_smc *smc ;
  127. {
  128. smc->mib.m[MAC0].fddiMACRMTState = ACTIONS(RM0_ISOLATED) ;
  129. smc->r.dup_addr_test = DA_NONE ;
  130. smc->r.da_flag = 0 ;
  131. smc->mib.m[MAC0].fddiMACMA_UnitdataAvailable = FALSE ;
  132. smc->r.sm_ma_avail = FALSE ;
  133. smc->r.loop_avail = 0 ;
  134. smc->r.bn_flag = 0 ;
  135. smc->r.jm_flag = 0 ;
  136. smc->r.no_flag = TRUE ;
  137. }
  139. /*
  140. RMT state machine
  141. called by dispatcher
  143. do
  144. display state change
  145. process event
  146. until SM is stable
  147. */
  148. void rmt(smc,event)
  149. struct s_smc *smc ;
  150. int event ;
  151. {
  152. int state ;
  154. do {
  155. DB_RMT("RMT : state %s%s",
  156. (smc->mib.m[MAC0].fddiMACRMTState & AFLAG) ? "ACTIONS " : "",
  157. rmt_states[smc->mib.m[MAC0].fddiMACRMTState & ~AFLAG]) ;
  158. DB_RMT(" event %sn",rmt_events[event],0) ;
  159. state = smc->mib.m[MAC0].fddiMACRMTState ;
  160. rmt_fsm(smc,event) ;
  161. event = 0 ;
  162. } while (state != smc->mib.m[MAC0].fddiMACRMTState) ;
  163. rmt_state_change(smc,(int)smc->mib.m[MAC0].fddiMACRMTState) ;
  164. }
  166. /*
  167. process RMT event
  168. */
  169. static void rmt_fsm(smc,cmd)
  170. struct s_smc *smc ;
  171. int cmd ;
  172. {
  173. /*
  174.  * RM00-RM70 : from all states
  175.  */
  176. if (!smc->r.rm_join && !smc->r.rm_loop &&
  177. smc->mib.m[MAC0].fddiMACRMTState != ACTIONS(RM0_ISOLATED) &&
  178. smc->mib.m[MAC0].fddiMACRMTState != RM0_ISOLATED) {
  179. RS_SET(smc,RS_NORINGOP) ;
  180. rmt_indication(smc,0) ;
  181. GO_STATE(RM0_ISOLATED) ;
  182. return ;
  183. }
  185. switch(smc->mib.m[MAC0].fddiMACRMTState) {
  186. case ACTIONS(RM0_ISOLATED) :
  187. stop_rmt_timer0(smc) ;
  188. stop_rmt_timer1(smc) ;
  189. stop_rmt_timer2(smc) ;
  191. /*
  192.  * Disable MAC.
  193.  */
  194. sm_ma_control(smc,MA_OFFLINE) ;
  195. smc->mib.m[MAC0].fddiMACMA_UnitdataAvailable = FALSE ;
  196. smc->r.loop_avail = FALSE ;
  197. smc->r.sm_ma_avail = FALSE ;
  198. smc->r.no_flag = TRUE ;
  199. DB_RMTN(1,"RMT : ISOLATEDn",0,0) ;
  200. ACTIONS_DONE() ;
  201. break ;
  202. case RM0_ISOLATED :
  203. /*RM01*/
  204. if (smc->r.rm_join || smc->r.rm_loop) {
  205. /*
  206.  * According to the standard the MAC must be reset
  207.  * here. The FORMAC will be initialized and Claim
  208.  * and Beacon Frames will be uploaded to the MAC.
  209.  * So any change of Treq will take effect NOW.
  210.  */
  211. sm_ma_control(smc,MA_RESET) ;
  212. GO_STATE(RM1_NON_OP) ;
  213. break ;
  214. }
  215. break ;
  216. case ACTIONS(RM1_NON_OP) :
  217. start_rmt_timer0(smc,smc->s.rmt_t_non_op,RM_TIMEOUT_NON_OP) ;
  218. stop_rmt_timer1(smc) ;
  219. stop_rmt_timer2(smc) ;
  220. sm_ma_control(smc,MA_BEACON) ;
  221. DB_RMTN(1,"RMT : RING DOWNn",0,0) ;
  222. RS_SET(smc,RS_NORINGOP) ;
  223. smc->r.sm_ma_avail = FALSE ;
  224. rmt_indication(smc,0) ;
  225. ACTIONS_DONE() ;
  226. break ;
  227. case RM1_NON_OP :
  228. /*RM12*/
  229. if (cmd == RM_RING_OP) {
  230. RS_SET(smc,RS_RINGOPCHANGE) ;
  231. GO_STATE(RM2_RING_OP) ;
  232. break ;
  233. }
  234. /*RM13*/
  235. else if (cmd == RM_TIMEOUT_NON_OP) {
  236. smc->r.bn_flag = FALSE ;
  237. smc->r.no_flag = TRUE ;
  238. GO_STATE(RM3_DETECT) ;
  239. break ;
  240. }
  241. break ;
  242. case ACTIONS(RM2_RING_OP) :
  243. stop_rmt_timer0(smc) ;
  244. stop_rmt_timer1(smc) ;
  245. stop_rmt_timer2(smc) ;
  246. smc->r.no_flag = FALSE ;
  247. if (smc->r.rm_loop)
  248. smc->r.loop_avail = TRUE ;
  249. if (smc->r.rm_join) {
  250. smc->r.sm_ma_avail = TRUE ;
  251. if (smc->mib.m[MAC0].fddiMACMA_UnitdataEnable)
  252. smc->mib.m[MAC0].fddiMACMA_UnitdataAvailable = TRUE ;
  253. else
  254. smc->mib.m[MAC0].fddiMACMA_UnitdataAvailable = FALSE ;
  255. }
  256. DB_RMTN(1,"RMT : RING UPn",0,0) ;
  257. RS_CLEAR(smc,RS_NORINGOP) ;
  258. RS_SET(smc,RS_RINGOPCHANGE) ;
  259. rmt_indication(smc,1) ;
  260. smt_stat_counter(smc,0) ;
  261. ACTIONS_DONE() ;
  262. break ;
  263. case RM2_RING_OP :
  264. /*RM21*/
  265. if (cmd == RM_RING_NON_OP) {
  266. smc->mib.m[MAC0].fddiMACMA_UnitdataAvailable = FALSE ;
  267. smc->r.loop_avail = FALSE ;
  268. RS_SET(smc,RS_RINGOPCHANGE) ;
  269. GO_STATE(RM1_NON_OP) ;
  270. break ;
  271. }
  272. /*RM22a*/
  273. else if (cmd == RM_ENABLE_FLAG) {
  274. if (smc->mib.m[MAC0].fddiMACMA_UnitdataEnable)
  275. smc->mib.m[MAC0].fddiMACMA_UnitdataAvailable = TRUE ;
  276. else
  277. smc->mib.m[MAC0].fddiMACMA_UnitdataAvailable = FALSE ;
  278. }
  279. /*RM25*/
  280. else if (smc->r.dup_addr_test == DA_FAILED) {
  281. smc->mib.m[MAC0].fddiMACMA_UnitdataAvailable = FALSE ;
  282. smc->r.loop_avail = FALSE ;
  283. smc->r.da_flag = TRUE ;
  284. GO_STATE(RM5_RING_OP_DUP) ;
  285. break ;
  286. }
  287. break ;
  288. case ACTIONS(RM3_DETECT) :
  289. start_rmt_timer0(smc,smc->s.mac_d_max*2,RM_TIMEOUT_D_MAX) ;
  290. start_rmt_timer1(smc,smc->s.rmt_t_stuck,RM_TIMEOUT_T_STUCK) ;
  291. start_rmt_timer2(smc,smc->s.rmt_t_poll,RM_TIMEOUT_POLL) ;
  292. sm_mac_check_beacon_claim(smc) ;
  293. DB_RMTN(1,"RMT : RM3_DETECTn",0,0) ;
  294. ACTIONS_DONE() ;
  295. break ;
  296. case RM3_DETECT :
  297. if (cmd == RM_TIMEOUT_POLL) {
  298. start_rmt_timer2(smc,smc->s.rmt_t_poll,RM_TIMEOUT_POLL);
  299. sm_mac_check_beacon_claim(smc) ;
  300. break ;
  301. }
  302. if (cmd == RM_TIMEOUT_D_MAX) {
  303. smc->r.timer0_exp = TRUE ;
  304. }
  305. /*
  306.  *jd(22-Feb-1999)
  307.  * We need a time ">= 2*mac_d_max" since we had finished
  308.  * Claim or Beacon state. So we will restart timer0 at
  309.  * every state change.
  310.  */
  311. if (cmd == RM_TX_STATE_CHANGE) {
  312. start_rmt_timer0(smc,
  313.  smc->s.mac_d_max*2,
  314.  RM_TIMEOUT_D_MAX) ;
  315. }
  316. /*RM32*/
  317. if (cmd == RM_RING_OP) {
  318. GO_STATE(RM2_RING_OP) ;
  319. break ;
  320. }
  321. /*RM33a*/
  322. else if ((cmd == RM_MY_BEACON || cmd == RM_OTHER_BEACON)
  323. && smc->r.bn_flag) {
  324. smc->r.bn_flag = FALSE ;
  325. }
  326. /*RM33b*/
  327. else if (cmd == RM_TRT_EXP && !smc->r.bn_flag) {
  328. int tx ;
  329. /*
  330.  * set bn_flag only if in state T4 or T5:
  331.  * only if we're the beaconer should we start the
  332.  * trace !
  333.  */
  334. if ((tx =  sm_mac_get_tx_state(smc)) == 4 || tx == 5) {
  335. DB_RMTN(2,"RMT : DETECT && TRT_EXPIRED && T4/T5n",0,0);
  336. smc->r.bn_flag = TRUE ;
  337. /*
  338.  * If one of the upstream stations beaconed
  339.  * and the link to the upstream neighbor is
  340.  * lost we need to restart the stuck timer to
  341.  * check the "stuck beacon" condition.
  342.  */
  343. start_rmt_timer1(smc,smc->s.rmt_t_stuck,
  344. RM_TIMEOUT_T_STUCK) ;
  345. }
  346. /*
  347.  * We do NOT need to clear smc->r.bn_flag in case of
  348.  * not being in state T4 or T5, because the flag
  349.  * must be cleared in order to get in this condition.
  350.  */
  352. DB_RMTN(2,
  353. "RMT : sm_mac_get_tx_state() = %d (bn_flag = %d)n",
  354. tx,smc->r.bn_flag) ;
  355. }
  356. /*RM34a*/
  357. else if (cmd == RM_MY_CLAIM && smc->r.timer0_exp) {
  358. rmt_new_dup_actions(smc) ;
  359. GO_STATE(RM4_NON_OP_DUP) ;
  360. break ;
  361. }
  362. /*RM34b*/
  363. else if (cmd == RM_MY_BEACON && smc->r.timer0_exp) {
  364. rmt_new_dup_actions(smc) ;
  365. GO_STATE(RM4_NON_OP_DUP) ;
  366. break ;
  367. }
  368. /*RM34c*/
  369. else if (cmd == RM_VALID_CLAIM) {
  370. rmt_new_dup_actions(smc) ;
  371. GO_STATE(RM4_NON_OP_DUP) ;
  372. break ;
  373. }
  374. /*RM36*/
  375. else if (cmd == RM_TIMEOUT_T_STUCK &&
  376. smc->r.rm_join && smc->r.bn_flag) {
  377. GO_STATE(RM6_DIRECTED) ;
  378. break ;
  379. }
  380. break ;
  381. case ACTIONS(RM4_NON_OP_DUP) :
  382. start_rmt_timer0(smc,smc->s.rmt_t_announce,RM_TIMEOUT_ANNOUNCE);
  383. start_rmt_timer1(smc,smc->s.rmt_t_stuck,RM_TIMEOUT_T_STUCK) ;
  384. start_rmt_timer2(smc,smc->s.rmt_t_poll,RM_TIMEOUT_POLL) ;
  385. sm_mac_check_beacon_claim(smc) ;
  386. DB_RMTN(1,"RMT : RM4_NON_OP_DUPn",0,0) ;
  387. ACTIONS_DONE() ;
  388. break ;
  389. case RM4_NON_OP_DUP :
  390. if (cmd == RM_TIMEOUT_POLL) {
  391. start_rmt_timer2(smc,smc->s.rmt_t_poll,RM_TIMEOUT_POLL);
  392. sm_mac_check_beacon_claim(smc) ;
  393. break ;
  394. }
  395. /*RM41*/
  396. if (!smc->r.da_flag) {
  397. GO_STATE(RM1_NON_OP) ;
  398. break ;
  399. }
  400. /*RM44a*/
  401. else if ((cmd == RM_MY_BEACON || cmd == RM_OTHER_BEACON) &&
  402. smc->r.bn_flag) {
  403. smc->r.bn_flag = FALSE ;
  404. }
  405. /*RM44b*/
  406. else if (cmd == RM_TRT_EXP && !smc->r.bn_flag) {
  407. int tx ;
  408. /*
  409.  * set bn_flag only if in state T4 or T5:
  410.  * only if we're the beaconer should we start the
  411.  * trace !
  412.  */
  413. if ((tx =  sm_mac_get_tx_state(smc)) == 4 || tx == 5) {
  414. DB_RMTN(2,"RMT : NOPDUP && TRT_EXPIRED && T4/T5n",0,0);
  415. smc->r.bn_flag = TRUE ;
  416. /*
  417.  * If one of the upstream stations beaconed
  418.  * and the link to the upstream neighbor is
  419.  * lost we need to restart the stuck timer to
  420.  * check the "stuck beacon" condition.
  421.  */
  422. start_rmt_timer1(smc,smc->s.rmt_t_stuck,
  423. RM_TIMEOUT_T_STUCK) ;
  424. }
  425. /*
  426.  * We do NOT need to clear smc->r.bn_flag in case of
  427.  * not being in state T4 or T5, because the flag
  428.  * must be cleared in order to get in this condition.
  429.  */
  431. DB_RMTN(2,
  432. "RMT : sm_mac_get_tx_state() = %d (bn_flag = %d)n",
  433. tx,smc->r.bn_flag) ;
  434. }
  435. /*RM44c*/
  436. else if (cmd == RM_TIMEOUT_ANNOUNCE && !smc->r.bn_flag) {
  437. rmt_dup_actions(smc) ;
  438. }
  439. /*RM45*/
  440. else if (cmd == RM_RING_OP) {
  441. smc->r.no_flag = FALSE ;
  442. GO_STATE(RM5_RING_OP_DUP) ;
  443. break ;
  444. }
  445. /*RM46*/
  446. else if (cmd == RM_TIMEOUT_T_STUCK &&
  447. smc->r.rm_join && smc->r.bn_flag) {
  448. GO_STATE(RM6_DIRECTED) ;
  449. break ;
  450. }
  451. break ;
  452. case ACTIONS(RM5_RING_OP_DUP) :
  453. stop_rmt_timer0(smc) ;
  454. stop_rmt_timer1(smc) ;
  455. stop_rmt_timer2(smc) ;
  456. DB_RMTN(1,"RMT : RM5_RING_OP_DUPn",0,0) ;
  457. ACTIONS_DONE() ;
  458. break;
  459. case RM5_RING_OP_DUP :
  460. /*RM52*/
  461. if (smc->r.dup_addr_test == DA_PASSED) {
  462. smc->r.da_flag = FALSE ;
  463. GO_STATE(RM2_RING_OP) ;
  464. break ;
  465. }
  466. /*RM54*/
  467. else if (cmd == RM_RING_NON_OP) {
  468. smc->r.jm_flag = FALSE ;
  469. smc->r.bn_flag = FALSE ;
  470. GO_STATE(RM4_NON_OP_DUP) ;
  471. break ;
  472. }
  473. break ;
  474. case ACTIONS(RM6_DIRECTED) :
  475. start_rmt_timer0(smc,smc->s.rmt_t_direct,RM_TIMEOUT_T_DIRECT) ;
  476. stop_rmt_timer1(smc) ;
  477. start_rmt_timer2(smc,smc->s.rmt_t_poll,RM_TIMEOUT_POLL) ;
  478. sm_ma_control(smc,MA_DIRECTED) ;
  479. RS_SET(smc,RS_BEACON) ;
  480. DB_RMTN(1,"RMT : RM6_DIRECTEDn",0,0) ;
  481. ACTIONS_DONE() ;
  482. break ;
  483. case RM6_DIRECTED :
  484. /*RM63*/
  485. if (cmd == RM_TIMEOUT_POLL) {
  486. start_rmt_timer2(smc,smc->s.rmt_t_poll,RM_TIMEOUT_POLL);
  487. sm_mac_check_beacon_claim(smc) ;
  488. #ifndef SUPERNET_3
  489. /* Because of problems with the Supernet II chip set
  490.  * sending of Directed Beacon will stop after 165ms
  491.  * therefore restart_trt_for_dbcn(smc) will be called
  492.  * to prevent this.
  493.  */
  494. restart_trt_for_dbcn(smc) ;
  495. #endif /*SUPERNET_3*/
  496. break ;
  497. }
  498. if ((cmd == RM_MY_BEACON || cmd == RM_OTHER_BEACON) &&
  499. !smc->r.da_flag) {
  500. smc->r.bn_flag = FALSE ;
  501. GO_STATE(RM3_DETECT) ;
  502. break ;
  503. }
  504. /*RM64*/
  505. else if ((cmd == RM_MY_BEACON || cmd == RM_OTHER_BEACON) &&
  506. smc->r.da_flag) {
  507. smc->r.bn_flag = FALSE ;
  508. GO_STATE(RM4_NON_OP_DUP) ;
  509. break ;
  510. }
  511. /*RM67*/
  512. else if (cmd == RM_TIMEOUT_T_DIRECT) {
  513. GO_STATE(RM7_TRACE) ;
  514. break ;
  515. }
  516. break ;
  517. case ACTIONS(RM7_TRACE) :
  518. stop_rmt_timer0(smc) ;
  519. stop_rmt_timer1(smc) ;
  520. stop_rmt_timer2(smc) ;
  521. smc->e.trace_prop |= ENTITY_BIT(ENTITY_MAC) ;
  522. queue_event(smc,EVENT_ECM,EC_TRACE_PROP) ;
  523. DB_RMTN(1,"RMT : RM7_TRACEn",0,0) ;
  524. ACTIONS_DONE() ;
  525. break ;
  526. case RM7_TRACE :
  527. break ;
  528. default:
  529. SMT_PANIC(smc,SMT_E0122, SMT_E0122_MSG) ;
  530. break;
  531. }
  532. }
  534. /*
  535.  * (jd) RMT duplicate address actions
  536.  * leave the ring or reinsert just as configured
  537.  */
  538. static void rmt_dup_actions(smc)
  539. struct s_smc *smc ;
  540. {
  541. if (smc->r.jm_flag) {
  542. }
  543. else {
  544. if (smc->s.rmt_dup_mac_behavior) {
  545. SMT_ERR_LOG(smc,SMT_E0138, SMT_E0138_MSG) ;
  546.                         rmt_reinsert_actions(smc) ;
  547. }
  548. else {
  549. SMT_ERR_LOG(smc,SMT_E0135, SMT_E0135_MSG) ;
  550. rmt_leave_actions(smc) ;
  551. }
  552. }
  553. }
  555. /*
  556.  * Reconnect to the Ring
  557.  */
  558. static void rmt_reinsert_actions(smc)
  559. struct s_smc *smc ;
  560. {
  561. queue_event(smc,EVENT_ECM,EC_DISCONNECT) ;
  562. queue_event(smc,EVENT_ECM,EC_CONNECT) ;
  563. }
  565. /*
  566.  * duplicate address detected
  567.  */
  568. static void rmt_new_dup_actions(smc)
  569. struct s_smc *smc ;
  570. {
  571. smc->r.da_flag = TRUE ;
  572. smc->r.bn_flag = FALSE ;
  573. smc->r.jm_flag = FALSE ;
  574. /*
  575.  * we have three options : change address, jam or leave
  576.  * we leave the ring as default 
  577.  * Optionally it's possible to reinsert after leaving the Ring
  578.  * but this will not conform with SMT Spec.
  579.  */
  580. if (smc->s.rmt_dup_mac_behavior) {
  581. SMT_ERR_LOG(smc,SMT_E0138, SMT_E0138_MSG) ;
  582. rmt_reinsert_actions(smc) ;
  583. }
  584. else {
  585. SMT_ERR_LOG(smc,SMT_E0135, SMT_E0135_MSG) ;
  586. rmt_leave_actions(smc) ;
  587. }
  588. }
  591. /*
  592.  * leave the ring
  593.  */
  594. static void rmt_leave_actions(smc)
  595. struct s_smc *smc ;
  596. {
  597. queue_event(smc,EVENT_ECM,EC_DISCONNECT) ;
  598. /*
  599.  * Note: Do NOT try again later. (with please reconnect)
  600.  * The station must be left from the ring!
  601.  */
  602. }
  604. /*
  605.  * SMT timer interface
  606.  * start RMT timer 0
  607.  */
  608. static void start_rmt_timer0(smc,value,event)
  609. struct s_smc *smc ;
  610. u_long value ;
  611. int event ;
  612. {
  613. smc->r.timer0_exp = FALSE ; /* clear timer event flag */
  614. smt_timer_start(smc,&smc->r.rmt_timer0,value,EV_TOKEN(EVENT_RMT,event));
  615. }
  617. /*
  618.  * SMT timer interface
  619.  * start RMT timer 1
  620.  */
  621. static void start_rmt_timer1(smc,value,event)
  622. struct s_smc *smc ;
  623. u_long value ;
  624. int event ;
  625. {
  626. smc->r.timer1_exp = FALSE ; /* clear timer event flag */
  627. smt_timer_start(smc,&smc->r.rmt_timer1,value,EV_TOKEN(EVENT_RMT,event));
  628. }
  630. /*
  631.  * SMT timer interface
  632.  * start RMT timer 2
  633.  */
  634. static void start_rmt_timer2(smc,value,event)
  635. struct s_smc *smc ;
  636. u_long value ;
  637. int event ;
  638. {
  639. smc->r.timer2_exp = FALSE ; /* clear timer event flag */
  640. smt_timer_start(smc,&smc->r.rmt_timer2,value,EV_TOKEN(EVENT_RMT,event));
  641. }
  643. /*
  644.  * SMT timer interface
  645.  * stop RMT timer 0
  646.  */
  647. static void stop_rmt_timer0(smc)
  648. struct s_smc *smc ;
  649. {
  650. if (smc->r.rmt_timer0.tm_active)
  651. smt_timer_stop(smc,&smc->r.rmt_timer0) ;
  652. }
  654. /*
  655.  * SMT timer interface
  656.  * stop RMT timer 1
  657.  */
  658. static void stop_rmt_timer1(smc)
  659. struct s_smc *smc ;
  660. {
  661. if (smc->r.rmt_timer1.tm_active)
  662. smt_timer_stop(smc,&smc->r.rmt_timer1) ;
  663. }
  665. /*
  666.  * SMT timer interface
  667.  * stop RMT timer 2
  668.  */
  669. static void stop_rmt_timer2(smc)
  670. struct s_smc *smc ;
  671. {
  672. if (smc->r.rmt_timer2.tm_active)
  673. smt_timer_stop(smc,&smc->r.rmt_timer2) ;
  674. }