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