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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
isdnl1.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：20k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

isdnl1.c：源码内容
  1. /* $Id: isdnl1.c,v 1.1.4.1 2001/11/20 14:19:36 kai Exp $
  2.  *
  3.  * common low level stuff for Siemens Chipsetbased isdn cards
  4.  *
  5.  * Author       Karsten Keil
  6.  *              based on the teles driver from Jan den Ouden
  7.  * Copyright    by Karsten Keil      <keil@isdn4linux.de>
  8.  * 
  9.  * This software may be used and distributed according to the terms
  10.  * of the GNU General Public License, incorporated herein by reference.
  11.  *
  12.  * For changes and modifications please read
  13.  * ../../../Documentation/isdn/HiSax.cert
  14.  *
  15.  * Thanks to    Jan den Ouden
  16.  *              Fritz Elfert
  17.  *              Beat Doebeli
  18.  *
  19.  */
  21. const char *l1_revision = "$Revision: 1.1.4.1 $";
  23. #define __NO_VERSION__
  24. #include <linux/init.h>
  25. #include "hisax.h"
  26. #include "isdnl1.h"
  28. #define TIMER3_VALUE 7000
  30. static struct Fsm l1fsm_b;
  31. static struct Fsm l1fsm_s;
  33. enum {
  34. ST_L1_F2,
  35. ST_L1_F3,
  36. ST_L1_F4,
  37. ST_L1_F5,
  38. ST_L1_F6,
  39. ST_L1_F7,
  40. ST_L1_F8,
  41. };
  43. #define L1S_STATE_COUNT (ST_L1_F8+1)
  45. static char *strL1SState[] =
  46. {
  47. "ST_L1_F2",
  48. "ST_L1_F3",
  49. "ST_L1_F4",
  50. "ST_L1_F5",
  51. "ST_L1_F6",
  52. "ST_L1_F7",
  53. "ST_L1_F8",
  54. };
  56. #ifdef HISAX_UINTERFACE
  57. static
  58. struct Fsm l1fsm_u =
  59. {NULL, 0, 0, NULL, NULL};
  61. enum {
  62. ST_L1_RESET,
  63. ST_L1_DEACT,
  64. ST_L1_SYNC2,
  65. ST_L1_TRANS,
  66. };
  68. #define L1U_STATE_COUNT (ST_L1_TRANS+1)
  70. static char *strL1UState[] =
  71. {
  72. "ST_L1_RESET",
  73. "ST_L1_DEACT",
  74. "ST_L1_SYNC2",
  75. "ST_L1_TRANS",
  76. };
  77. #endif
  79. enum {
  80. ST_L1_NULL,
  81. ST_L1_WAIT_ACT,
  82. ST_L1_WAIT_DEACT,
  83. ST_L1_ACTIV,
  84. };
  86. #define L1B_STATE_COUNT (ST_L1_ACTIV+1)
  88. static char *strL1BState[] =
  89. {
  90. "ST_L1_NULL",
  91. "ST_L1_WAIT_ACT",
  92. "ST_L1_WAIT_DEACT",
  93. "ST_L1_ACTIV",
  94. };
  96. enum {
  97. EV_PH_ACTIVATE,
  98. EV_PH_DEACTIVATE,
  99. EV_RESET_IND,
  100. EV_DEACT_CNF,
  101. EV_DEACT_IND,
  102. EV_POWER_UP,
  103. EV_RSYNC_IND, 
  104. EV_INFO2_IND,
  105. EV_INFO4_IND,
  106. EV_TIMER_DEACT,
  107. EV_TIMER_ACT,
  108. EV_TIMER3,
  109. };
  111. #define L1_EVENT_COUNT (EV_TIMER3 + 1)
  113. static char *strL1Event[] =
  114. {
  115. "EV_PH_ACTIVATE",
  116. "EV_PH_DEACTIVATE",
  117. "EV_RESET_IND",
  118. "EV_DEACT_CNF",
  119. "EV_DEACT_IND",
  120. "EV_POWER_UP",
  121. "EV_RSYNC_IND", 
  122. "EV_INFO2_IND",
  123. "EV_INFO4_IND",
  124. "EV_TIMER_DEACT",
  125. "EV_TIMER_ACT",
  126. "EV_TIMER3",
  127. };
  129. void
  130. debugl1(struct IsdnCardState *cs, char *fmt, ...)
  131. {
  132. va_list args;
  133. char tmp[8];
  135. va_start(args, fmt);
  136. sprintf(tmp, "Card%d ", cs->cardnr + 1);
  137. VHiSax_putstatus(cs, tmp, fmt, args);
  138. va_end(args);
  139. }
  141. static void
  142. l1m_debug(struct FsmInst *fi, char *fmt, ...)
  143. {
  144. va_list args;
  145. struct PStack *st = fi->userdata;
  146. struct IsdnCardState *cs = st->l1.hardware;
  147. char tmp[8];
  149. va_start(args, fmt);
  150. sprintf(tmp, "Card%d ", cs->cardnr + 1);
  151. VHiSax_putstatus(cs, tmp, fmt, args);
  152. va_end(args);
  153. }
  155. void
  156. L1activated(struct IsdnCardState *cs)
  157. {
  158. struct PStack *st;
  160. st = cs->stlist;
  161. while (st) {
  162. if (test_and_clear_bit(FLG_L1_ACTIVATING, &st->l1.Flags))
  163. st->l1.l1l2(st, PH_ACTIVATE | CONFIRM, NULL);
  164. else
  165. st->l1.l1l2(st, PH_ACTIVATE | INDICATION, NULL);
  166. st = st->next;
  167. }
  168. }
  170. void
  171. L1deactivated(struct IsdnCardState *cs)
  172. {
  173. struct PStack *st;
  175. st = cs->stlist;
  176. while (st) {
  177. if (test_bit(FLG_L1_DBUSY, &cs->HW_Flags))
  178. st->l1.l1l2(st, PH_PAUSE | CONFIRM, NULL);
  179. st->l1.l1l2(st, PH_DEACTIVATE | INDICATION, NULL);
  180. st = st->next;
  181. }
  182. test_and_clear_bit(FLG_L1_DBUSY, &cs->HW_Flags);
  183. }
  185. void
  186. DChannel_proc_xmt(struct IsdnCardState *cs)
  187. {
  188. struct PStack *stptr;
  190. if (cs->tx_skb)
  191. return;
  193. stptr = cs->stlist;
  194. while (stptr != NULL)
  195. if (test_and_clear_bit(FLG_L1_PULL_REQ, &stptr->l1.Flags)) {
  196. stptr->l1.l1l2(stptr, PH_PULL | CONFIRM, NULL);
  197. break;
  198. } else
  199. stptr = stptr->next;
  200. }
  202. void
  203. DChannel_proc_rcv(struct IsdnCardState *cs)
  204. {
  205. struct sk_buff *skb, *nskb;
  206. struct PStack *stptr = cs->stlist;
  207. int found, tei, sapi;
  209. if (stptr)
  210. if (test_bit(FLG_L1_ACTTIMER, &stptr->l1.Flags))
  211. FsmEvent(&stptr->l1.l1m, EV_TIMER_ACT, NULL);
  212. while ((skb = skb_dequeue(&cs->rq))) {
  213. #ifdef L2FRAME_DEBUG /* psa */
  214. if (cs->debug & L1_DEB_LAPD)
  215. Logl2Frame(cs, skb, "PH_DATA", 1);
  216. #endif
  217. stptr = cs->stlist;
  218. if (skb->len<3) {
  219. debugl1(cs, "D-channel frame too short(%d)",skb->len);
  220. dev_kfree_skb(skb);
  221. return;
  222. }
  223. if ((skb->data[0] & 1) || !(skb->data[1] &1)) {
  224. debugl1(cs, "D-channel frame wrong EA0/EA1");
  225. dev_kfree_skb(skb);
  226. return;
  227. }
  228. sapi = skb->data[0] >> 2;
  229. tei = skb->data[1] >> 1;
  230. if (cs->debug & DEB_DLOG_HEX)
  231. LogFrame(cs, skb->data, skb->len);
  232. if (cs->debug & DEB_DLOG_VERBOSE)
  233. dlogframe(cs, skb, 1);
  234. if (tei == GROUP_TEI) {
  235. if (sapi == CTRL_SAPI) { /* sapi 0 */
  236. while (stptr != NULL) {
  237. if ((nskb = skb_clone(skb, GFP_ATOMIC)))
  238. stptr->l1.l1l2(stptr, PH_DATA | INDICATION, nskb);
  239. else
  240. printk(KERN_WARNING "HiSax: isdn broadcast buffer shortagen");
  241. stptr = stptr->next;
  242. }
  243. } else if (sapi == TEI_SAPI) {
  244. while (stptr != NULL) {
  245. if ((nskb = skb_clone(skb, GFP_ATOMIC)))
  246. stptr->l1.l1tei(stptr, PH_DATA | INDICATION, nskb);
  247. else
  248. printk(KERN_WARNING "HiSax: tei broadcast buffer shortagen");
  249. stptr = stptr->next;
  250. }
  251. }
  252. dev_kfree_skb(skb);
  253. } else if (sapi == CTRL_SAPI) { /* sapi 0 */
  254. found = 0;
  255. while (stptr != NULL)
  256. if (tei == stptr->l2.tei) {
  257. stptr->l1.l1l2(stptr, PH_DATA | INDICATION, skb);
  258. found = !0;
  259. break;
  260. } else
  261. stptr = stptr->next;
  262. if (!found)
  263. dev_kfree_skb(skb);
  264. } else
  265. dev_kfree_skb(skb);
  266. }
  267. }
  269. static void
  270. BChannel_proc_xmt(struct BCState *bcs)
  271. {
  272. struct PStack *st = bcs->st;
  274. if (test_bit(BC_FLG_BUSY, &bcs->Flag)) {
  275. debugl1(bcs->cs, "BC_BUSY Error");
  276. return;
  277. }
  279. if (test_and_clear_bit(FLG_L1_PULL_REQ, &st->l1.Flags))
  280. st->l1.l1l2(st, PH_PULL | CONFIRM, NULL);
  281. if (!test_bit(BC_FLG_ACTIV, &bcs->Flag)) {
  282. if (!test_bit(BC_FLG_BUSY, &bcs->Flag) && (!skb_queue_len(&bcs->squeue))) {
  283. st->l2.l2l1(st, PH_DEACTIVATE | CONFIRM, NULL);
  284. }
  285. }
  286. }
  288. static void
  289. BChannel_proc_rcv(struct BCState *bcs)
  290. {
  291. struct sk_buff *skb;
  293. if (bcs->st->l1.l1m.state == ST_L1_WAIT_ACT) {
  294. FsmDelTimer(&bcs->st->l1.timer, 4);
  295. FsmEvent(&bcs->st->l1.l1m, EV_TIMER_ACT, NULL);
  296. }
  297. while ((skb = skb_dequeue(&bcs->rqueue))) {
  298. bcs->st->l1.l1l2(bcs->st, PH_DATA | INDICATION, skb);
  299. }
  300. }
  302. void
  303. BChannel_bh(struct BCState *bcs)
  304. {
  305. if (!bcs)
  306. return;
  307. if (test_and_clear_bit(B_RCVBUFREADY, &bcs->event))
  308. BChannel_proc_rcv(bcs);
  309. if (test_and_clear_bit(B_XMTBUFREADY, &bcs->event))
  310. BChannel_proc_xmt(bcs);
  311. }
  313. void
  314. HiSax_addlist(struct IsdnCardState *cs,
  315.       struct PStack *st)
  316. {
  317. st->next = cs->stlist;
  318. cs->stlist = st;
  319. }
  321. void
  322. HiSax_rmlist(struct IsdnCardState *cs,
  323.      struct PStack *st)
  324. {
  325. struct PStack *p;
  327. FsmDelTimer(&st->l1.timer, 0);
  328. if (cs->stlist == st)
  329. cs->stlist = st->next;
  330. else {
  331. p = cs->stlist;
  332. while (p)
  333. if (p->next == st) {
  334. p->next = st->next;
  335. return;
  336. } else
  337. p = p->next;
  338. }
  339. }
  341. void
  342. init_bcstate(struct IsdnCardState *cs,
  343.      int bc)
  344. {
  345. struct BCState *bcs = cs->bcs + bc;
  347. bcs->cs = cs;
  348. bcs->channel = bc;
  349. bcs->tqueue.sync = 0;
  350. bcs->tqueue.routine = (void *) (void *) BChannel_bh;
  351. bcs->tqueue.data = bcs;
  352. bcs->BC_SetStack = NULL;
  353. bcs->BC_Close = NULL;
  354. bcs->Flag = 0;
  355. }
  357. #ifdef L2FRAME_DEBUG /* psa */
  359. char *
  360. l2cmd(u_char cmd)
  361. {
  362. switch (cmd & ~0x10) {
  363. case 1:
  364. return "RR";
  365. case 5:
  366. return "RNR";
  367. case 9:
  368. return "REJ";
  369. case 0x6f:
  370. return "SABME";
  371. case 0x0f:
  372. return "DM";
  373. case 3:
  374. return "UI";
  375. case 0x43:
  376. return "DISC";
  377. case 0x63:
  378. return "UA";
  379. case 0x87:
  380. return "FRMR";
  381. case 0xaf:
  382. return "XID";
  383. default:
  384. if (!(cmd & 1))
  385. return "I";
  386. else
  387. return "invalid command";
  388. }
  389. }
  391. static char tmpdeb[32];
  393. char *
  394. l2frames(u_char * ptr)
  395. {
  396. switch (ptr[2] & ~0x10) {
  397. case 1:
  398. case 5:
  399. case 9:
  400. sprintf(tmpdeb, "%s[%d](nr %d)", l2cmd(ptr[2]), ptr[3] & 1, ptr[3] >> 1);
  401. break;
  402. case 0x6f:
  403. case 0x0f:
  404. case 3:
  405. case 0x43:
  406. case 0x63:
  407. case 0x87:
  408. case 0xaf:
  409. sprintf(tmpdeb, "%s[%d]", l2cmd(ptr[2]), (ptr[2] & 0x10) >> 4);
  410. break;
  411. default:
  412. if (!(ptr[2] & 1)) {
  413. sprintf(tmpdeb, "I[%d](ns %d, nr %d)", ptr[3] & 1, ptr[2] >> 1, ptr[3] >> 1);
  414. break;
  415. } else
  416. return "invalid command";
  417. }
  420. return tmpdeb;
  421. }
  423. void
  424. Logl2Frame(struct IsdnCardState *cs, struct sk_buff *skb, char *buf, int dir)
  425. {
  426. u_char *ptr;
  428. ptr = skb->data;
  430. if (ptr[0] & 1 || !(ptr[1] & 1))
  431. debugl1(cs, "Address not LAPD");
  432. else
  433. debugl1(cs, "%s %s: %s%c (sapi %d, tei %d)",
  434. (dir ? "<-" : "->"), buf, l2frames(ptr),
  435. ((ptr[0] & 2) >> 1) == dir ? 'C' : 'R', ptr[0] >> 2, ptr[1] >> 1);
  436. }
  437. #endif
  439. static void
  440. l1_reset(struct FsmInst *fi, int event, void *arg)
  441. {
  442. FsmChangeState(fi, ST_L1_F3);
  443. }
  445. static void
  446. l1_deact_cnf(struct FsmInst *fi, int event, void *arg)
  447. {
  448. struct PStack *st = fi->userdata;
  450. FsmChangeState(fi, ST_L1_F3);
  451. if (test_bit(FLG_L1_ACTIVATING, &st->l1.Flags))
  452. st->l1.l1hw(st, HW_ENABLE | REQUEST, NULL);
  453. }
  455. static void
  456. l1_deact_req_s(struct FsmInst *fi, int event, void *arg)
  457. {
  458. struct PStack *st = fi->userdata;
  460. FsmChangeState(fi, ST_L1_F3);
  461. FsmRestartTimer(&st->l1.timer, 550, EV_TIMER_DEACT, NULL, 2);
  462. test_and_set_bit(FLG_L1_DEACTTIMER, &st->l1.Flags);
  463. }
  465. static void
  466. l1_power_up_s(struct FsmInst *fi, int event, void *arg)
  467. {
  468. struct PStack *st = fi->userdata;
  470. if (test_bit(FLG_L1_ACTIVATING, &st->l1.Flags)) {
  471. FsmChangeState(fi, ST_L1_F4);
  472. st->l1.l1hw(st, HW_INFO3 | REQUEST, NULL);
  473. FsmRestartTimer(&st->l1.timer, TIMER3_VALUE, EV_TIMER3, NULL, 2);
  474. test_and_set_bit(FLG_L1_T3RUN, &st->l1.Flags);
  475. } else
  476. FsmChangeState(fi, ST_L1_F3);
  477. }
  479. static void
  480. l1_go_F5(struct FsmInst *fi, int event, void *arg)
  481. {
  482. FsmChangeState(fi, ST_L1_F5);
  483. }
  485. static void
  486. l1_go_F8(struct FsmInst *fi, int event, void *arg)
  487. {
  488. FsmChangeState(fi, ST_L1_F8);
  489. }
  491. static void
  492. l1_info2_ind(struct FsmInst *fi, int event, void *arg)
  493. {
  494. struct PStack *st = fi->userdata;
  496. #ifdef HISAX_UINTERFACE
  497. if (test_bit(FLG_L1_UINT, &st->l1.Flags))
  498. FsmChangeState(fi, ST_L1_SYNC2);
  499. else
  500. #endif
  501. FsmChangeState(fi, ST_L1_F6);
  502. st->l1.l1hw(st, HW_INFO3 | REQUEST, NULL);
  503. }
  505. static void
  506. l1_info4_ind(struct FsmInst *fi, int event, void *arg)
  507. {
  508. struct PStack *st = fi->userdata;
  510. #ifdef HISAX_UINTERFACE
  511. if (test_bit(FLG_L1_UINT, &st->l1.Flags))
  512. FsmChangeState(fi, ST_L1_TRANS);
  513. else
  514. #endif
  515. FsmChangeState(fi, ST_L1_F7);
  516. st->l1.l1hw(st, HW_INFO3 | REQUEST, NULL);
  517. if (test_and_clear_bit(FLG_L1_DEACTTIMER, &st->l1.Flags))
  518. FsmDelTimer(&st->l1.timer, 4);
  519. if (!test_bit(FLG_L1_ACTIVATED, &st->l1.Flags)) {
  520. if (test_and_clear_bit(FLG_L1_T3RUN, &st->l1.Flags))
  521. FsmDelTimer(&st->l1.timer, 3);
  522. FsmRestartTimer(&st->l1.timer, 110, EV_TIMER_ACT, NULL, 2);
  523. test_and_set_bit(FLG_L1_ACTTIMER, &st->l1.Flags);
  524. }
  525. }
  527. static void
  528. l1_timer3(struct FsmInst *fi, int event, void *arg)
  529. {
  530. struct PStack *st = fi->userdata;
  532. test_and_clear_bit(FLG_L1_T3RUN, &st->l1.Flags);
  533. if (test_and_clear_bit(FLG_L1_ACTIVATING, &st->l1.Flags))
  534. L1deactivated(st->l1.hardware);
  536. #ifdef HISAX_UINTERFACE
  537. if (!test_bit(FLG_L1_UINT, &st->l1.Flags))
  538. #endif
  539. if (st->l1.l1m.state != ST_L1_F6) {
  540. FsmChangeState(fi, ST_L1_F3);
  541. st->l1.l1hw(st, HW_ENABLE | REQUEST, NULL);
  542. }
  543. }
  545. static void
  546. l1_timer_act(struct FsmInst *fi, int event, void *arg)
  547. {
  548. struct PStack *st = fi->userdata;
  550. test_and_clear_bit(FLG_L1_ACTTIMER, &st->l1.Flags);
  551. test_and_set_bit(FLG_L1_ACTIVATED, &st->l1.Flags);
  552. L1activated(st->l1.hardware);
  553. }
  555. static void
  556. l1_timer_deact(struct FsmInst *fi, int event, void *arg)
  557. {
  558. struct PStack *st = fi->userdata;
  560. test_and_clear_bit(FLG_L1_DEACTTIMER, &st->l1.Flags);
  561. test_and_clear_bit(FLG_L1_ACTIVATED, &st->l1.Flags);
  562. L1deactivated(st->l1.hardware);
  563. st->l1.l1hw(st, HW_DEACTIVATE | RESPONSE, NULL);
  564. }
  566. static void
  567. l1_activate_s(struct FsmInst *fi, int event, void *arg)
  568. {
  569. struct PStack *st = fi->userdata;
  570.                 
  571. st->l1.l1hw(st, HW_RESET | REQUEST, NULL);
  572. }
  574. static void
  575. l1_activate_no(struct FsmInst *fi, int event, void *arg)
  576. {
  577. struct PStack *st = fi->userdata;
  579. if ((!test_bit(FLG_L1_DEACTTIMER, &st->l1.Flags)) && (!test_bit(FLG_L1_T3RUN, &st->l1.Flags))) {
  580. test_and_clear_bit(FLG_L1_ACTIVATING, &st->l1.Flags);
  581. L1deactivated(st->l1.hardware);
  582. }
  583. }
  585. static struct FsmNode L1SFnList[] __initdata =
  586. {
  587. {ST_L1_F3, EV_PH_ACTIVATE, l1_activate_s},
  588. {ST_L1_F6, EV_PH_ACTIVATE, l1_activate_no},
  589. {ST_L1_F8, EV_PH_ACTIVATE, l1_activate_no},
  590. {ST_L1_F3, EV_RESET_IND, l1_reset},
  591. {ST_L1_F4, EV_RESET_IND, l1_reset},
  592. {ST_L1_F5, EV_RESET_IND, l1_reset},
  593. {ST_L1_F6, EV_RESET_IND, l1_reset},
  594. {ST_L1_F7, EV_RESET_IND, l1_reset},
  595. {ST_L1_F8, EV_RESET_IND, l1_reset},
  596. {ST_L1_F3, EV_DEACT_CNF, l1_deact_cnf},
  597. {ST_L1_F4, EV_DEACT_CNF, l1_deact_cnf},
  598. {ST_L1_F5, EV_DEACT_CNF, l1_deact_cnf},
  599. {ST_L1_F6, EV_DEACT_CNF, l1_deact_cnf},
  600. {ST_L1_F7, EV_DEACT_CNF, l1_deact_cnf},
  601. {ST_L1_F8, EV_DEACT_CNF, l1_deact_cnf},
  602. {ST_L1_F6, EV_DEACT_IND, l1_deact_req_s},
  603. {ST_L1_F7, EV_DEACT_IND, l1_deact_req_s},
  604. {ST_L1_F8, EV_DEACT_IND, l1_deact_req_s},
  605. {ST_L1_F3, EV_POWER_UP, l1_power_up_s},
  606. {ST_L1_F4, EV_RSYNC_IND, l1_go_F5},
  607. {ST_L1_F6, EV_RSYNC_IND, l1_go_F8},
  608. {ST_L1_F7, EV_RSYNC_IND, l1_go_F8},
  609. {ST_L1_F3, EV_INFO2_IND, l1_info2_ind},
  610. {ST_L1_F4, EV_INFO2_IND, l1_info2_ind},
  611. {ST_L1_F5, EV_INFO2_IND, l1_info2_ind},
  612. {ST_L1_F7, EV_INFO2_IND, l1_info2_ind},
  613. {ST_L1_F8, EV_INFO2_IND, l1_info2_ind},
  614. {ST_L1_F3, EV_INFO4_IND, l1_info4_ind},
  615. {ST_L1_F4, EV_INFO4_IND, l1_info4_ind},
  616. {ST_L1_F5, EV_INFO4_IND, l1_info4_ind},
  617. {ST_L1_F6, EV_INFO4_IND, l1_info4_ind},
  618. {ST_L1_F8, EV_INFO4_IND, l1_info4_ind},
  619. {ST_L1_F3, EV_TIMER3, l1_timer3},
  620. {ST_L1_F4, EV_TIMER3, l1_timer3},
  621. {ST_L1_F5, EV_TIMER3, l1_timer3},
  622. {ST_L1_F6, EV_TIMER3, l1_timer3},
  623. {ST_L1_F8, EV_TIMER3, l1_timer3},
  624. {ST_L1_F7, EV_TIMER_ACT, l1_timer_act},
  625. {ST_L1_F3, EV_TIMER_DEACT, l1_timer_deact},
  626. {ST_L1_F4, EV_TIMER_DEACT, l1_timer_deact},
  627. {ST_L1_F5, EV_TIMER_DEACT, l1_timer_deact},
  628. {ST_L1_F6, EV_TIMER_DEACT, l1_timer_deact},
  629. {ST_L1_F7, EV_TIMER_DEACT, l1_timer_deact},
  630. {ST_L1_F8, EV_TIMER_DEACT, l1_timer_deact},
  631. };
  633. #define L1S_FN_COUNT (sizeof(L1SFnList)/sizeof(struct FsmNode))
  635. #ifdef HISAX_UINTERFACE
  636. static void
  637. l1_deact_req_u(struct FsmInst *fi, int event, void *arg)
  638. {
  639. struct PStack *st = fi->userdata;
  641. FsmChangeState(fi, ST_L1_RESET);
  642. FsmRestartTimer(&st->l1.timer, 550, EV_TIMER_DEACT, NULL, 2);
  643. test_and_set_bit(FLG_L1_DEACTTIMER, &st->l1.Flags);
  644. st->l1.l1hw(st, HW_ENABLE | REQUEST, NULL);
  645. }
  647. static void
  648. l1_power_up_u(struct FsmInst *fi, int event, void *arg)
  649. {
  650. struct PStack *st = fi->userdata;
  652. FsmRestartTimer(&st->l1.timer, TIMER3_VALUE, EV_TIMER3, NULL, 2);
  653. test_and_set_bit(FLG_L1_T3RUN, &st->l1.Flags);
  654. }
  656. static void
  657. l1_info0_ind(struct FsmInst *fi, int event, void *arg)
  658. {
  659. FsmChangeState(fi, ST_L1_DEACT);
  660. }
  662. static void
  663. l1_activate_u(struct FsmInst *fi, int event, void *arg)
  664. {
  665. struct PStack *st = fi->userdata;
  666.                 
  667. st->l1.l1hw(st, HW_INFO1 | REQUEST, NULL);
  668. }
  670. static struct FsmNode L1UFnList[] __initdata =
  671. {
  672. {ST_L1_RESET, EV_DEACT_IND, l1_deact_req_u},
  673. {ST_L1_DEACT, EV_DEACT_IND, l1_deact_req_u},
  674. {ST_L1_SYNC2, EV_DEACT_IND, l1_deact_req_u},
  675. {ST_L1_TRANS, EV_DEACT_IND, l1_deact_req_u},
  676. {ST_L1_DEACT, EV_PH_ACTIVATE, l1_activate_u},
  677. {ST_L1_DEACT, EV_POWER_UP, l1_power_up_u},
  678. {ST_L1_DEACT, EV_INFO2_IND, l1_info2_ind},
  679. {ST_L1_TRANS, EV_INFO2_IND, l1_info2_ind},
  680. {ST_L1_RESET, EV_DEACT_CNF, l1_info0_ind},
  681. {ST_L1_DEACT, EV_INFO4_IND, l1_info4_ind},
  682. {ST_L1_SYNC2, EV_INFO4_IND, l1_info4_ind},
  683. {ST_L1_RESET, EV_INFO4_IND, l1_info4_ind},
  684. {ST_L1_DEACT, EV_TIMER3, l1_timer3},
  685. {ST_L1_SYNC2, EV_TIMER3, l1_timer3},
  686. {ST_L1_TRANS, EV_TIMER_ACT, l1_timer_act},
  687. {ST_L1_DEACT, EV_TIMER_DEACT, l1_timer_deact},
  688. {ST_L1_SYNC2, EV_TIMER_DEACT, l1_timer_deact},
  689. {ST_L1_RESET, EV_TIMER_DEACT, l1_timer_deact},
  690. };
  692. #define L1U_FN_COUNT (sizeof(L1UFnList)/sizeof(struct FsmNode))
  694. #endif
  696. static void
  697. l1b_activate(struct FsmInst *fi, int event, void *arg)
  698. {
  699. struct PStack *st = fi->userdata;
  701. FsmChangeState(fi, ST_L1_WAIT_ACT);
  702. FsmRestartTimer(&st->l1.timer, st->l1.delay, EV_TIMER_ACT, NULL, 2);
  703. }
  705. static void
  706. l1b_deactivate(struct FsmInst *fi, int event, void *arg)
  707. {
  708. struct PStack *st = fi->userdata;
  710. FsmChangeState(fi, ST_L1_WAIT_DEACT);
  711. FsmRestartTimer(&st->l1.timer, 10, EV_TIMER_DEACT, NULL, 2);
  712. }
  714. static void
  715. l1b_timer_act(struct FsmInst *fi, int event, void *arg)
  716. {
  717. struct PStack *st = fi->userdata;
  719. FsmChangeState(fi, ST_L1_ACTIV);
  720. st->l1.l1l2(st, PH_ACTIVATE | CONFIRM, NULL);
  721. }
  723. static void
  724. l1b_timer_deact(struct FsmInst *fi, int event, void *arg)
  725. {
  726. struct PStack *st = fi->userdata;
  728. FsmChangeState(fi, ST_L1_NULL);
  729. st->l2.l2l1(st, PH_DEACTIVATE | CONFIRM, NULL);
  730. }
  732. static struct FsmNode L1BFnList[] __initdata =
  733. {
  734. {ST_L1_NULL, EV_PH_ACTIVATE, l1b_activate},
  735. {ST_L1_WAIT_ACT, EV_TIMER_ACT, l1b_timer_act},
  736. {ST_L1_ACTIV, EV_PH_DEACTIVATE, l1b_deactivate},
  737. {ST_L1_WAIT_DEACT, EV_TIMER_DEACT, l1b_timer_deact},
  738. };
  740. #define L1B_FN_COUNT (sizeof(L1BFnList)/sizeof(struct FsmNode))
  742. int __init 
  743. Isdnl1New(void)
  744. {
  745. int retval;
  747. l1fsm_s.state_count = L1S_STATE_COUNT;
  748. l1fsm_s.event_count = L1_EVENT_COUNT;
  749. l1fsm_s.strEvent = strL1Event;
  750. l1fsm_s.strState = strL1SState;
  751. retval = FsmNew(&l1fsm_s, L1SFnList, L1S_FN_COUNT);
  752. if (retval)
  753. return retval;
  755. l1fsm_b.state_count = L1B_STATE_COUNT;
  756. l1fsm_b.event_count = L1_EVENT_COUNT;
  757. l1fsm_b.strEvent = strL1Event;
  758. l1fsm_b.strState = strL1BState;
  759. retval = FsmNew(&l1fsm_b, L1BFnList, L1B_FN_COUNT);
  760. if (retval) {
  761. FsmFree(&l1fsm_s);
  762. return retval;
  763. }
  764. #ifdef HISAX_UINTERFACE
  765. l1fsm_u.state_count = L1U_STATE_COUNT;
  766. l1fsm_u.event_count = L1_EVENT_COUNT;
  767. l1fsm_u.strEvent = strL1Event;
  768. l1fsm_u.strState = strL1UState;
  769. retval = FsmNew(&l1fsm_u, L1UFnList, L1U_FN_COUNT);
  770. if (retval) {
  771. FsmFree(&l1fsm_s);
  772. FsmFree(&l1fsm_b);
  773. return retval;
  774. }
  775. #endif
  776. return 0;
  777. }
  779. void Isdnl1Free(void)
  780. {
  781. #ifdef HISAX_UINTERFACE
  782. FsmFree(&l1fsm_u);
  783. #endif
  784. FsmFree(&l1fsm_s);
  785. FsmFree(&l1fsm_b);
  786. }
  788. static void
  789. dch_l2l1(struct PStack *st, int pr, void *arg)
  790. {
  791. struct IsdnCardState *cs = (struct IsdnCardState *) st->l1.hardware;
  793. switch (pr) {
  794. case (PH_DATA | REQUEST):
  795. case (PH_PULL | REQUEST):
  796. case (PH_PULL |INDICATION):
  797. st->l1.l1hw(st, pr, arg);
  798. break;
  799. case (PH_ACTIVATE | REQUEST):
  800. if (cs->debug)
  801. debugl1(cs, "PH_ACTIVATE_REQ %s",
  802. st->l1.l1m.fsm->strState[st->l1.l1m.state]);
  803. if (test_bit(FLG_L1_ACTIVATED, &st->l1.Flags))
  804. st->l1.l1l2(st, PH_ACTIVATE | CONFIRM, NULL);
  805. else {
  806. test_and_set_bit(FLG_L1_ACTIVATING, &st->l1.Flags);
  807. FsmEvent(&st->l1.l1m, EV_PH_ACTIVATE, arg);
  808. }
  809. break;
  810. case (PH_TESTLOOP | REQUEST):
  811. if (1 & (long) arg)
  812. debugl1(cs, "PH_TEST_LOOP B1");
  813. if (2 & (long) arg)
  814. debugl1(cs, "PH_TEST_LOOP B2");
  815. if (!(3 & (long) arg))
  816. debugl1(cs, "PH_TEST_LOOP DISABLED");
  817. st->l1.l1hw(st, HW_TESTLOOP | REQUEST, arg);
  818. break;
  819. default:
  820. if (cs->debug)
  821. debugl1(cs, "dch_l2l1 msg %04X unhandled", pr);
  822. break;
  823. }
  824. }
  826. void
  827. l1_msg(struct IsdnCardState *cs, int pr, void *arg) {
  828. struct PStack *st;
  830. st = cs->stlist;
  832. while (st) {
  833. switch(pr) {
  834. case (HW_RESET | INDICATION):
  835. FsmEvent(&st->l1.l1m, EV_RESET_IND, arg);
  836. break;
  837. case (HW_DEACTIVATE | CONFIRM):
  838. FsmEvent(&st->l1.l1m, EV_DEACT_CNF, arg);
  839. break;
  840. case (HW_DEACTIVATE | INDICATION):
  841. FsmEvent(&st->l1.l1m, EV_DEACT_IND, arg);
  842. break;
  843. case (HW_POWERUP | CONFIRM):
  844. FsmEvent(&st->l1.l1m, EV_POWER_UP, arg);
  845. break;
  846. case (HW_RSYNC | INDICATION):
  847. FsmEvent(&st->l1.l1m, EV_RSYNC_IND, arg);
  848. break;
  849. case (HW_INFO2 | INDICATION):
  850. FsmEvent(&st->l1.l1m, EV_INFO2_IND, arg);
  851. break;
  852. case (HW_INFO4_P8 | INDICATION):
  853. case (HW_INFO4_P10 | INDICATION):
  854. FsmEvent(&st->l1.l1m, EV_INFO4_IND, arg);
  855. break;
  856. default:
  857. if (cs->debug)
  858. debugl1(cs, "l1msg %04X unhandled", pr);
  859. break;
  860. }
  861. st = st->next;
  862. }
  863. }
  865. void
  866. l1_msg_b(struct PStack *st, int pr, void *arg) {
  867. switch(pr) {
  868. case (PH_ACTIVATE | REQUEST):
  869. FsmEvent(&st->l1.l1m, EV_PH_ACTIVATE, NULL);
  870. break;
  871. case (PH_DEACTIVATE | REQUEST):
  872. FsmEvent(&st->l1.l1m, EV_PH_DEACTIVATE, NULL);
  873. break;
  874. }
  875. }
  877. void
  878. setstack_HiSax(struct PStack *st, struct IsdnCardState *cs)
  879. {
  880. st->l1.hardware = cs;
  881. st->protocol = cs->protocol;
  882. st->l1.l1m.fsm = &l1fsm_s;
  883. st->l1.l1m.state = ST_L1_F3;
  884. st->l1.Flags = 0;
  885. #ifdef HISAX_UINTERFACE
  886. if (test_bit(FLG_HW_L1_UINT, &cs->HW_Flags)) {
  887. st->l1.l1m.fsm = &l1fsm_u;
  888. st->l1.l1m.state = ST_L1_RESET;
  889. st->l1.Flags = FLG_L1_UINT;
  890. }
  891. #endif
  892. st->l1.l1m.debug = cs->debug;
  893. st->l1.l1m.userdata = st;
  894. st->l1.l1m.userint = 0;
  895. st->l1.l1m.printdebug = l1m_debug;
  896. FsmInitTimer(&st->l1.l1m, &st->l1.timer);
  897. setstack_tei(st);
  898. setstack_manager(st);
  899. st->l1.stlistp = &(cs->stlist);
  900. st->l2.l2l1  = dch_l2l1;
  901. if (cs->setstack_d)
  902. cs->setstack_d(st, cs);
  903. }
  905. void
  906. setstack_l1_B(struct PStack *st)
  907. {
  908. struct IsdnCardState *cs = st->l1.hardware;
  910. st->l1.l1m.fsm = &l1fsm_b;
  911. st->l1.l1m.state = ST_L1_NULL;
  912. st->l1.l1m.debug = cs->debug;
  913. st->l1.l1m.userdata = st;
  914. st->l1.l1m.userint = 0;
  915. st->l1.l1m.printdebug = l1m_debug;
  916. st->l1.Flags = 0;
  917. FsmInitTimer(&st->l1.l1m, &st->l1.timer);
  918. }