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

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

嵌入式Linux

开发平台：

Unix_Linux

isdnl2.c：源码内容
  1. /* $Id: isdnl2.c,v 1.1.4.1 2001/11/20 14:19:36 kai Exp $
  2.  *
  3.  * Author       Karsten Keil
  4.  *              based on the teles driver from Jan den Ouden
  5.  * Copyright    by Karsten Keil      <keil@isdn4linux.de>
  6.  * 
  7.  * This software may be used and distributed according to the terms
  8.  * of the GNU General Public License, incorporated herein by reference.
  9.  *
  10.  * For changes and modifications please read
  11.  * ../../../Documentation/isdn/HiSax.cert
  12.  *
  13.  * Thanks to    Jan den Ouden
  14.  *              Fritz Elfert
  15.  *
  16.  */
  18. #define __NO_VERSION__
  19. #include <linux/init.h>
  20. #include "hisax.h"
  21. #include "isdnl2.h"
  23. const char *l2_revision = "$Revision: 1.1.4.1 $";
  25. static void l2m_debug(struct FsmInst *fi, char *fmt, ...);
  27. static struct Fsm l2fsm;
  29. enum {
  30. ST_L2_1,
  31. ST_L2_2,
  32. ST_L2_3,
  33. ST_L2_4,
  34. ST_L2_5,
  35. ST_L2_6,
  36. ST_L2_7,
  37. ST_L2_8,
  38. };
  40. #define L2_STATE_COUNT (ST_L2_8+1)
  42. static char *strL2State[] =
  43. {
  44. "ST_L2_1",
  45. "ST_L2_2",
  46. "ST_L2_3",
  47. "ST_L2_4",
  48. "ST_L2_5",
  49. "ST_L2_6",
  50. "ST_L2_7",
  51. "ST_L2_8",
  52. };
  54. enum {
  55. EV_L2_UI,
  56. EV_L2_SABME,
  57. EV_L2_DISC,
  58. EV_L2_DM,
  59. EV_L2_UA,
  60. EV_L2_FRMR,
  61. EV_L2_SUPER,
  62. EV_L2_I,
  63. EV_L2_DL_DATA,
  64. EV_L2_ACK_PULL,
  65. EV_L2_DL_UNIT_DATA,
  66. EV_L2_DL_ESTABLISH_REQ,
  67. EV_L2_DL_RELEASE_REQ,
  68. EV_L2_MDL_ASSIGN,
  69. EV_L2_MDL_REMOVE,
  70. EV_L2_MDL_ERROR,
  71. EV_L1_DEACTIVATE,
  72. EV_L2_T200,
  73. EV_L2_T203,
  74. EV_L2_SET_OWN_BUSY,
  75. EV_L2_CLEAR_OWN_BUSY,
  76. EV_L2_FRAME_ERROR,
  77. };
  79. #define L2_EVENT_COUNT (EV_L2_FRAME_ERROR+1)
  81. static char *strL2Event[] =
  82. {
  83. "EV_L2_UI",
  84. "EV_L2_SABME",
  85. "EV_L2_DISC",
  86. "EV_L2_DM",
  87. "EV_L2_UA",
  88. "EV_L2_FRMR",
  89. "EV_L2_SUPER",
  90. "EV_L2_I",
  91. "EV_L2_DL_DATA",
  92. "EV_L2_ACK_PULL",
  93. "EV_L2_DL_UNIT_DATA",
  94. "EV_L2_DL_ESTABLISH_REQ",
  95. "EV_L2_DL_RELEASE_REQ",
  96. "EV_L2_MDL_ASSIGN",
  97. "EV_L2_MDL_REMOVE",
  98. "EV_L2_MDL_ERROR",
  99. "EV_L1_DEACTIVATE",
  100. "EV_L2_T200",
  101. "EV_L2_T203",
  102. "EV_L2_SET_OWN_BUSY",
  103. "EV_L2_CLEAR_OWN_BUSY",
  104. "EV_L2_FRAME_ERROR",
  105. };
  107. static int l2addrsize(struct Layer2 *l2);
  109. static void
  110. set_peer_busy(struct Layer2 *l2) {
  111. test_and_set_bit(FLG_PEER_BUSY, &l2->flag);
  112. if (skb_queue_len(&l2->i_queue) || skb_queue_len(&l2->ui_queue))
  113. test_and_set_bit(FLG_L2BLOCK, &l2->flag);
  114. }
  116. static void
  117. clear_peer_busy(struct Layer2 *l2) {
  118. if (test_and_clear_bit(FLG_PEER_BUSY, &l2->flag))
  119. test_and_clear_bit(FLG_L2BLOCK, &l2->flag);
  120. }
  122. static void
  123. InitWin(struct Layer2 *l2)
  124. {
  125. int i;
  127. for (i = 0; i < MAX_WINDOW; i++)
  128. l2->windowar[i] = NULL;
  129. }
  131. static int
  132. freewin1(struct Layer2 *l2)
  133. {
  134. int i, cnt = 0;
  136. for (i = 0; i < MAX_WINDOW; i++) {
  137. if (l2->windowar[i]) {
  138. cnt++;
  139. dev_kfree_skb(l2->windowar[i]);
  140. l2->windowar[i] = NULL;
  141. }
  142. }
  143. return cnt;
  144. }
  146. inline void
  147. freewin(struct PStack *st)
  148. {
  149. freewin1(&st->l2);
  150. }
  152. static void
  153. ReleaseWin(struct Layer2 *l2)
  154. {
  155. int cnt;
  157. if((cnt = freewin1(l2)))
  158. printk(KERN_WARNING "isdl2 freed %d skbuffs in releasen", cnt);
  159. }
  161. inline unsigned int
  162. cansend(struct PStack *st)
  163. {
  164. unsigned int p1;
  166. if(test_bit(FLG_MOD128, &st->l2.flag))
  167. p1 = (st->l2.vs - st->l2.va) % 128;
  168. else
  169. p1 = (st->l2.vs - st->l2.va) % 8;
  170. return ((p1 < st->l2.window) && !test_bit(FLG_PEER_BUSY, &st->l2.flag));
  171. }
  173. inline void
  174. clear_exception(struct Layer2 *l2)
  175. {
  176. test_and_clear_bit(FLG_ACK_PEND, &l2->flag);
  177. test_and_clear_bit(FLG_REJEXC, &l2->flag);
  178. test_and_clear_bit(FLG_OWN_BUSY, &l2->flag);
  179. clear_peer_busy(l2);
  180. }
  182. inline int
  183. l2headersize(struct Layer2 *l2, int ui)
  184. {
  185. return (((test_bit(FLG_MOD128, &l2->flag) && (!ui)) ? 2 : 1) +
  186. (test_bit(FLG_LAPD, &l2->flag) ? 2 : 1));
  187. }
  189. inline int
  190. l2addrsize(struct Layer2 *l2)
  191. {
  192. return (test_bit(FLG_LAPD, &l2->flag) ? 2 : 1);
  193. }
  195. static int
  196. sethdraddr(struct Layer2 *l2, u_char * header, int rsp)
  197. {
  198. u_char *ptr = header;
  199. int crbit = rsp;
  201. if (test_bit(FLG_LAPD, &l2->flag)) {
  202. *ptr++ = (l2->sap << 2) | (rsp ? 2 : 0);
  203. *ptr++ = (l2->tei << 1) | 1;
  204. return (2);
  205. } else {
  206. if (test_bit(FLG_ORIG, &l2->flag))
  207. crbit = !crbit;
  208. if (crbit)
  209. *ptr++ = 1;
  210. else
  211. *ptr++ = 3;
  212. return (1);
  213. }
  214. }
  216. inline static void
  217. enqueue_super(struct PStack *st,
  218.       struct sk_buff *skb)
  219. {
  220. if (test_bit(FLG_LAPB, &st->l2.flag))
  221. st->l1.bcs->tx_cnt += skb->len;
  222. st->l2.l2l1(st, PH_DATA | REQUEST, skb);
  223. }
  225. #define enqueue_ui(a, b) enqueue_super(a, b)
  227. inline int
  228. IsUI(u_char * data)
  229. {
  230. return ((data[0] & 0xef) == UI);
  231. }
  233. inline int
  234. IsUA(u_char * data)
  235. {
  236. return ((data[0] & 0xef) == UA);
  237. }
  239. inline int
  240. IsDM(u_char * data)
  241. {
  242. return ((data[0] & 0xef) == DM);
  243. }
  245. inline int
  246. IsDISC(u_char * data)
  247. {
  248. return ((data[0] & 0xef) == DISC);
  249. }
  251. inline int
  252. IsRR(u_char * data, struct PStack *st)
  253. {
  254. if (test_bit(FLG_MOD128, &st->l2.flag))
  255. return (data[0] == RR);
  256. else
  257. return ((data[0] & 0xf) == 1);
  258. }
  260. inline int
  261. IsSFrame(u_char * data, struct PStack *st)
  262. {
  263. register u_char d = *data;
  265. if (!test_bit(FLG_MOD128, &st->l2.flag))
  266. d &= 0xf;
  267. return(((d & 0xf3) == 1) && ((d & 0x0c) != 0x0c));
  268. }
  270. inline int
  271. IsSABME(u_char * data, struct PStack *st)
  272. {
  273. u_char d = data[0] & ~0x10;
  275. return (test_bit(FLG_MOD128, &st->l2.flag) ? d == SABME : d == SABM);
  276. }
  278. inline int
  279. IsREJ(u_char * data, struct PStack *st)
  280. {
  281. return (test_bit(FLG_MOD128, &st->l2.flag) ? data[0] == REJ : (data[0] & 0xf) == REJ);
  282. }
  284. inline int
  285. IsFRMR(u_char * data)
  286. {
  287. return ((data[0] & 0xef) == FRMR);
  288. }
  290. inline int
  291. IsRNR(u_char * data, struct PStack *st)
  292. {
  293. return (test_bit(FLG_MOD128, &st->l2.flag) ? data[0] == RNR : (data[0] & 0xf) == RNR);
  294. }
  296. int
  297. iframe_error(struct PStack *st, struct sk_buff *skb)
  298. {
  299. int i = l2addrsize(&st->l2) + (test_bit(FLG_MOD128, &st->l2.flag) ? 2 : 1);
  300. int rsp = *skb->data & 0x2;
  302. if (test_bit(FLG_ORIG, &st->l2.flag))
  303. rsp = !rsp;
  305. if (rsp)
  306. return 'L';
  309. if (skb->len < i)
  310. return 'N';
  312. if ((skb->len - i) > st->l2.maxlen)
  313. return 'O';
  316. return 0;
  317. }
  319. int
  320. super_error(struct PStack *st, struct sk_buff *skb)
  321. {
  322. if (skb->len != l2addrsize(&st->l2) +
  323.     (test_bit(FLG_MOD128, &st->l2.flag) ? 2 : 1))
  324. return 'N';
  326. return 0;
  327. }
  329. int
  330. unnum_error(struct PStack *st, struct sk_buff *skb, int wantrsp)
  331. {
  332. int rsp = (*skb->data & 0x2) >> 1;
  333. if (test_bit(FLG_ORIG, &st->l2.flag))
  334. rsp = !rsp;
  336. if (rsp != wantrsp)
  337. return 'L';
  339. if (skb->len != l2addrsize(&st->l2) + 1)
  340. return 'N';
  342. return 0;
  343. }
  345. int
  346. UI_error(struct PStack *st, struct sk_buff *skb)
  347. {
  348. int rsp = *skb->data & 0x2;
  349. if (test_bit(FLG_ORIG, &st->l2.flag))
  350. rsp = !rsp;
  352. if (rsp)
  353. return 'L';
  355. if (skb->len > st->l2.maxlen + l2addrsize(&st->l2) + 1)
  356. return 'O';
  358. return 0;
  359. }
  361. int
  362. FRMR_error(struct PStack *st, struct sk_buff *skb)
  363. {
  364. int headers = l2addrsize(&st->l2) + 1;
  365. u_char *datap = skb->data + headers;
  366. int rsp = *skb->data & 0x2;
  368. if (test_bit(FLG_ORIG, &st->l2.flag))
  369. rsp = !rsp;
  371. if (!rsp)
  372. return 'L';
  374. if (test_bit(FLG_MOD128, &st->l2.flag)) {
  375. if (skb->len < headers + 5)
  376. return 'N';
  377. else
  378. l2m_debug(&st->l2.l2m, "FRMR information %2x %2x %2x %2x %2x",
  379. datap[0], datap[1], datap[2],
  380. datap[3], datap[4]);
  381. } else {
  382. if (skb->len < headers + 3)
  383. return 'N';
  384. else
  385. l2m_debug(&st->l2.l2m, "FRMR information %2x %2x %2x",
  386. datap[0], datap[1], datap[2]);
  387. }
  389. return 0;
  390. }
  392. static unsigned int
  393. legalnr(struct PStack *st, unsigned int nr)
  394. {
  395.         struct Layer2 *l2 = &st->l2;
  397. if(test_bit(FLG_MOD128, &l2->flag))
  398. return ((nr - l2->va) % 128) <= ((l2->vs - l2->va) % 128);
  399. else
  400. return ((nr - l2->va) % 8) <= ((l2->vs - l2->va) % 8);
  401. }
  403. static void
  404. setva(struct PStack *st, unsigned int nr)
  405. {
  406. struct Layer2 *l2 = &st->l2;
  407. int len;
  409. while (l2->va != nr) {
  410. (l2->va)++;
  411. if(test_bit(FLG_MOD128, &l2->flag))
  412. l2->va %= 128;
  413. else
  414. l2->va %= 8;
  415. len = l2->windowar[l2->sow]->len;
  416. if (PACKET_NOACK == l2->windowar[l2->sow]->pkt_type)
  417. len = -1;
  418. dev_kfree_skb(l2->windowar[l2->sow]);
  419. l2->windowar[l2->sow] = NULL;
  420. l2->sow = (l2->sow + 1) % l2->window;
  421. if (st->lli.l2writewakeup && (len >=0))
  422. st->lli.l2writewakeup(st, len);
  423. }
  424. }
  426. static void
  427. send_uframe(struct PStack *st, u_char cmd, u_char cr)
  428. {
  429. struct sk_buff *skb;
  430. u_char tmp[MAX_HEADER_LEN];
  431. int i;
  433. i = sethdraddr(&st->l2, tmp, cr);
  434. tmp[i++] = cmd;
  435. if (!(skb = alloc_skb(i, GFP_ATOMIC))) {
  436. printk(KERN_WARNING "isdl2 can't alloc sbbuff for send_uframen");
  437. return;
  438. }
  439. memcpy(skb_put(skb, i), tmp, i);
  440. enqueue_super(st, skb);
  441. }
  443. inline u_char
  444. get_PollFlag(struct PStack * st, struct sk_buff * skb)
  445. {
  446. return (skb->data[l2addrsize(&(st->l2))] & 0x10);
  447. }
  449. inline void
  450. FreeSkb(struct sk_buff *skb)
  451. {
  452. dev_kfree_skb(skb);
  453. }
  456. inline u_char
  457. get_PollFlagFree(struct PStack *st, struct sk_buff *skb)
  458. {
  459. u_char PF;
  461. PF = get_PollFlag(st, skb);
  462. FreeSkb(skb);
  463. return (PF);
  464. }
  466. inline void
  467. start_t200(struct PStack *st, int i)
  468. {
  469. FsmAddTimer(&st->l2.t200, st->l2.T200, EV_L2_T200, NULL, i);
  470. test_and_set_bit(FLG_T200_RUN, &st->l2.flag);
  471. }
  473. inline void
  474. restart_t200(struct PStack *st, int i)
  475. {
  476. FsmRestartTimer(&st->l2.t200, st->l2.T200, EV_L2_T200, NULL, i);
  477. test_and_set_bit(FLG_T200_RUN, &st->l2.flag);
  478. }
  480. inline void
  481. stop_t200(struct PStack *st, int i)
  482. {
  483. if(test_and_clear_bit(FLG_T200_RUN, &st->l2.flag))
  484. FsmDelTimer(&st->l2.t200, i);
  485. }
  487. inline void
  488. st5_dl_release_l2l3(struct PStack *st)
  489. {
  490. int pr;
  492. if(test_and_clear_bit(FLG_PEND_REL, &st->l2.flag))
  493. pr = DL_RELEASE | CONFIRM;
  494. else
  495. pr = DL_RELEASE | INDICATION;
  497. st->l2.l2l3(st, pr, NULL);
  498. }
  500. inline void
  501. lapb_dl_release_l2l3(struct PStack *st, int f)
  502. {
  503. if (test_bit(FLG_LAPB, &st->l2.flag))
  504. st->l2.l2l1(st, PH_DEACTIVATE | REQUEST, NULL);
  505. st->l2.l2l3(st, DL_RELEASE | f, NULL);
  506. }
  508. static void
  509. establishlink(struct FsmInst *fi)
  510. {
  511. struct PStack *st = fi->userdata;
  512. u_char cmd;
  514. clear_exception(&st->l2);
  515. st->l2.rc = 0;
  516. cmd = (test_bit(FLG_MOD128, &st->l2.flag) ? SABME : SABM) | 0x10;
  517. send_uframe(st, cmd, CMD);
  518. FsmDelTimer(&st->l2.t203, 1);
  519. restart_t200(st, 1);
  520. test_and_clear_bit(FLG_PEND_REL, &st->l2.flag);
  521. freewin(st);
  522. FsmChangeState(fi, ST_L2_5);
  523. }
  525. static void
  526. l2_mdl_error_ua(struct FsmInst *fi, int event, void *arg)
  527. {
  528. struct sk_buff *skb = arg;
  529. struct PStack *st = fi->userdata;
  531. if (get_PollFlagFree(st, skb))
  532. st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'C');
  533. else
  534. st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'D');
  535. }
  537. static void
  538. l2_mdl_error_dm(struct FsmInst *fi, int event, void *arg)
  539. {
  540. struct sk_buff *skb = arg;
  541. struct PStack *st = fi->userdata;
  543. if (get_PollFlagFree(st, skb))
  544. st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'B');
  545. else {
  546. st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'E');
  547. establishlink(fi);
  548. test_and_clear_bit(FLG_L3_INIT, &st->l2.flag);
  549. }
  550. }
  552. static void
  553. l2_st8_mdl_error_dm(struct FsmInst *fi, int event, void *arg)
  554. {
  555. struct sk_buff *skb = arg;
  556. struct PStack *st = fi->userdata;
  558. if (get_PollFlagFree(st, skb))
  559. st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'B');
  560. else {
  561. st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'E');
  562. }
  563. establishlink(fi);
  564. test_and_clear_bit(FLG_L3_INIT, &st->l2.flag);
  565. }
  567. static void
  568. l2_go_st3(struct FsmInst *fi, int event, void *arg)
  569. {
  570. FsmChangeState(fi, ST_L2_3); 
  571. }
  573. static void
  574. l2_mdl_assign(struct FsmInst *fi, int event, void *arg)
  575. {
  576. struct PStack *st = fi->userdata;
  578. FsmChangeState(fi, ST_L2_3); 
  579. st->l2.l2tei(st, MDL_ASSIGN | INDICATION, NULL);
  580. }
  582. static void
  583. l2_queue_ui_assign(struct FsmInst *fi, int event, void *arg)
  584. {
  585. struct PStack *st = fi->userdata;
  586. struct sk_buff *skb = arg;
  588. skb_queue_tail(&st->l2.ui_queue, skb);
  589. FsmChangeState(fi, ST_L2_2);
  590. st->l2.l2tei(st, MDL_ASSIGN | INDICATION, NULL);
  591. }
  593. static void
  594. l2_queue_ui(struct FsmInst *fi, int event, void *arg)
  595. {
  596. struct PStack *st = fi->userdata;
  597. struct sk_buff *skb = arg;
  599. skb_queue_tail(&st->l2.ui_queue, skb);
  600. }
  602. static void
  603. tx_ui(struct PStack *st)
  604. {
  605. struct sk_buff *skb;
  606. u_char header[MAX_HEADER_LEN];
  607. int i;
  609. i = sethdraddr(&(st->l2), header, CMD);
  610. header[i++] = UI;
  611. while ((skb = skb_dequeue(&st->l2.ui_queue))) {
  612. memcpy(skb_push(skb, i), header, i);
  613. enqueue_ui(st, skb);
  614. }
  615. }
  617. static void
  618. l2_send_ui(struct FsmInst *fi, int event, void *arg)
  619. {
  620. struct PStack *st = fi->userdata;
  621. struct sk_buff *skb = arg;
  623. skb_queue_tail(&st->l2.ui_queue, skb);
  624. tx_ui(st);
  625. }
  627. static void
  628. l2_got_ui(struct FsmInst *fi, int event, void *arg)
  629. {
  630. struct PStack *st = fi->userdata;
  631. struct sk_buff *skb = arg;
  633. skb_pull(skb, l2headersize(&st->l2, 1));
  634. st->l2.l2l3(st, DL_UNIT_DATA | INDICATION, skb);
  635. /* ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  636.  * in states 1-3 for broadcast
  637.  */
  640. }
  642. static void
  643. l2_establish(struct FsmInst *fi, int event, void *arg)
  644. {
  645. struct PStack *st = fi->userdata;
  647. establishlink(fi);
  648. test_and_set_bit(FLG_L3_INIT, &st->l2.flag);
  649. }
  651. static void
  652. l2_discard_i_setl3(struct FsmInst *fi, int event, void *arg)
  653. {
  654. struct PStack *st = fi->userdata;
  656. skb_queue_purge(&st->l2.i_queue);
  657. test_and_set_bit(FLG_L3_INIT, &st->l2.flag);
  658. test_and_clear_bit(FLG_PEND_REL, &st->l2.flag);
  659. }
  661. static void
  662. l2_l3_reestablish(struct FsmInst *fi, int event, void *arg)
  663. {
  664. struct PStack *st = fi->userdata;
  666. skb_queue_purge(&st->l2.i_queue);
  667. establishlink(fi);
  668. test_and_set_bit(FLG_L3_INIT, &st->l2.flag);
  669. }
  671. static void
  672. l2_release(struct FsmInst *fi, int event, void *arg)
  673. {
  674. struct PStack *st = fi->userdata;
  676. st->l2.l2l3(st, DL_RELEASE | CONFIRM, NULL);
  677. }
  679. static void
  680. l2_pend_rel(struct FsmInst *fi, int event, void *arg)
  681. {
  682. struct PStack *st = fi->userdata;
  684. test_and_set_bit(FLG_PEND_REL, &st->l2.flag);
  685. }
  687. static void
  688. l2_disconnect(struct FsmInst *fi, int event, void *arg)
  689. {
  690. struct PStack *st = fi->userdata;
  692. skb_queue_purge(&st->l2.i_queue);
  693. freewin(st);
  694. FsmChangeState(fi, ST_L2_6);
  695. st->l2.rc = 0;
  696. send_uframe(st, DISC | 0x10, CMD);
  697. FsmDelTimer(&st->l2.t203, 1);
  698. restart_t200(st, 2);
  699. }
  701. static void
  702. l2_start_multi(struct FsmInst *fi, int event, void *arg)
  703. {
  704. struct PStack *st = fi->userdata;
  705. struct sk_buff *skb = arg;
  707. send_uframe(st, UA | get_PollFlagFree(st, skb), RSP);
  709. clear_exception(&st->l2);
  710. st->l2.vs = 0;
  711. st->l2.va = 0;
  712. st->l2.vr = 0;
  713. st->l2.sow = 0;
  714. FsmChangeState(fi, ST_L2_7);
  715. FsmAddTimer(&st->l2.t203, st->l2.T203, EV_L2_T203, NULL, 3);
  717. st->l2.l2l3(st, DL_ESTABLISH | INDICATION, NULL);
  718. }
  720. static void
  721. l2_send_UA(struct FsmInst *fi, int event, void *arg)
  722. {
  723. struct PStack *st = fi->userdata;
  724. struct sk_buff *skb = arg;
  726. send_uframe(st, UA | get_PollFlagFree(st, skb), RSP);
  727. }
  729. static void
  730. l2_send_DM(struct FsmInst *fi, int event, void *arg)
  731. {
  732. struct PStack *st = fi->userdata;
  733. struct sk_buff *skb = arg;
  735. send_uframe(st, DM | get_PollFlagFree(st, skb), RSP);
  736. }
  738. static void
  739. l2_restart_multi(struct FsmInst *fi, int event, void *arg)
  740. {
  741. struct PStack *st = fi->userdata;
  742. struct sk_buff *skb = arg;
  743. int est = 0, state;
  745. state = fi->state;
  747. send_uframe(st, UA | get_PollFlagFree(st, skb), RSP);
  749. st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'F');
  751. if (st->l2.vs != st->l2.va) {
  752. skb_queue_purge(&st->l2.i_queue);
  753. est = 1;
  754. }
  756. clear_exception(&st->l2);
  757. st->l2.vs = 0;
  758. st->l2.va = 0;
  759. st->l2.vr = 0;
  760. st->l2.sow = 0;
  761. FsmChangeState(fi, ST_L2_7);
  762. stop_t200(st, 3);
  763. FsmRestartTimer(&st->l2.t203, st->l2.T203, EV_L2_T203, NULL, 3);
  765. if (est)
  766. st->l2.l2l3(st, DL_ESTABLISH | INDICATION, NULL);
  768. if ((ST_L2_7==state) || (ST_L2_8 == state))
  769. if (skb_queue_len(&st->l2.i_queue) && cansend(st))
  770. st->l2.l2l1(st, PH_PULL | REQUEST, NULL);
  771. }
  773. static void
  774. l2_stop_multi(struct FsmInst *fi, int event, void *arg)
  775. {
  776. struct PStack *st = fi->userdata;
  777. struct sk_buff *skb = arg;
  779. FsmChangeState(fi, ST_L2_4);
  780. FsmDelTimer(&st->l2.t203, 3);
  781. stop_t200(st, 4);
  783. send_uframe(st, UA | get_PollFlagFree(st, skb), RSP);
  785. skb_queue_purge(&st->l2.i_queue);
  786. freewin(st);
  787. lapb_dl_release_l2l3(st, INDICATION);
  788. }
  790. static void
  791. l2_connected(struct FsmInst *fi, int event, void *arg)
  792. {
  793. struct PStack *st = fi->userdata;
  794. struct sk_buff *skb = arg;
  795. int pr=-1;
  797. if (!get_PollFlag(st, skb)) {
  798. l2_mdl_error_ua(fi, event, arg);
  799. return;
  800. }
  801. FreeSkb(skb);
  803. if (test_and_clear_bit(FLG_PEND_REL, &st->l2.flag))
  804. l2_disconnect(fi, event, arg);
  806. if (test_and_clear_bit(FLG_L3_INIT, &st->l2.flag)) {
  807. pr = DL_ESTABLISH | CONFIRM;
  808. } else if (st->l2.vs != st->l2.va) {
  809. skb_queue_purge(&st->l2.i_queue);
  810. pr = DL_ESTABLISH | INDICATION;
  811. }
  813. stop_t200(st, 5);
  815. st->l2.vr = 0;
  816. st->l2.vs = 0;
  817. st->l2.va = 0;
  818. st->l2.sow = 0;
  819. FsmChangeState(fi, ST_L2_7);
  820. FsmAddTimer(&st->l2.t203, st->l2.T203, EV_L2_T203, NULL, 4);
  822. if (pr != -1)
  823. st->l2.l2l3(st, pr, NULL);
  825. if (skb_queue_len(&st->l2.i_queue) && cansend(st))
  826. st->l2.l2l1(st, PH_PULL | REQUEST, NULL);
  827. }
  829. static void
  830. l2_released(struct FsmInst *fi, int event, void *arg)
  831. {
  832. struct PStack *st = fi->userdata;
  833. struct sk_buff *skb = arg;
  835. if (!get_PollFlag(st, skb)) {
  836. l2_mdl_error_ua(fi, event, arg);
  837. return;
  838. }
  839. FreeSkb(skb);
  841. stop_t200(st, 6);
  842. lapb_dl_release_l2l3(st, CONFIRM);
  843. FsmChangeState(fi, ST_L2_4);
  844. }
  846. static void
  847. l2_reestablish(struct FsmInst *fi, int event, void *arg)
  848. {
  849. struct PStack *st = fi->userdata;
  850. struct sk_buff *skb = arg;
  852. if (!get_PollFlagFree(st, skb)) {
  853. establishlink(fi);
  854. test_and_set_bit(FLG_L3_INIT, &st->l2.flag);
  855. }
  856. }
  858. static void
  859. l2_st5_dm_release(struct FsmInst *fi, int event, void *arg)
  860. {
  861. struct PStack *st = fi->userdata;
  862. struct sk_buff *skb = arg;
  864. if (get_PollFlagFree(st, skb)) {
  865. stop_t200(st, 7);
  866.   if (!test_bit(FLG_L3_INIT, &st->l2.flag))
  867. skb_queue_purge(&st->l2.i_queue);
  868. if (test_bit(FLG_LAPB, &st->l2.flag))
  869. st->l2.l2l1(st, PH_DEACTIVATE | REQUEST, NULL);
  870. st5_dl_release_l2l3(st);
  871. FsmChangeState(fi, ST_L2_4);
  872. }
  873. }
  875. static void
  876. l2_st6_dm_release(struct FsmInst *fi, int event, void *arg)
  877. {
  878. struct PStack *st = fi->userdata;
  879. struct sk_buff *skb = arg;
  881. if (get_PollFlagFree(st, skb)) {
  882. stop_t200(st, 8);
  883. lapb_dl_release_l2l3(st, CONFIRM);
  884. FsmChangeState(fi, ST_L2_4);
  885. }
  886. }
  888. inline void
  889. enquiry_cr(struct PStack *st, u_char typ, u_char cr, u_char pf)
  890. {
  891. struct sk_buff *skb;
  892. struct Layer2 *l2;
  893. u_char tmp[MAX_HEADER_LEN];
  894. int i;
  896. l2 = &st->l2;
  897. i = sethdraddr(l2, tmp, cr);
  898. if (test_bit(FLG_MOD128, &l2->flag)) {
  899. tmp[i++] = typ;
  900. tmp[i++] = (l2->vr << 1) | (pf ? 1 : 0);
  901. } else
  902. tmp[i++] = (l2->vr << 5) | typ | (pf ? 0x10 : 0);
  903. if (!(skb = alloc_skb(i, GFP_ATOMIC))) {
  904. printk(KERN_WARNING "isdl2 can't alloc sbbuff for enquiry_crn");
  905. return;
  906. }
  907. memcpy(skb_put(skb, i), tmp, i);
  908. enqueue_super(st, skb);
  909. }
  911. inline void
  912. enquiry_response(struct PStack *st)
  913. {
  914. if (test_bit(FLG_OWN_BUSY, &st->l2.flag))
  915. enquiry_cr(st, RNR, RSP, 1);
  916. else
  917. enquiry_cr(st, RR, RSP, 1);
  918. test_and_clear_bit(FLG_ACK_PEND, &st->l2.flag);
  919. }
  921. inline void
  922. transmit_enquiry(struct PStack *st)
  923. {
  924. if (test_bit(FLG_OWN_BUSY, &st->l2.flag))
  925. enquiry_cr(st, RNR, CMD, 1);
  926. else
  927. enquiry_cr(st, RR, CMD, 1);
  928. test_and_clear_bit(FLG_ACK_PEND, &st->l2.flag);
  929. start_t200(st, 9);
  930. }
  933. static void
  934. nrerrorrecovery(struct FsmInst *fi)
  935. {
  936. struct PStack *st = fi->userdata;
  938. st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'J');
  939. establishlink(fi);
  940. test_and_clear_bit(FLG_L3_INIT, &st->l2.flag);
  941. }
  943. static void
  944. invoke_retransmission(struct PStack *st, unsigned int nr)
  945. {
  946. struct Layer2 *l2 = &st->l2;
  947. unsigned int p1;
  949. if (l2->vs != nr) {
  950. while (l2->vs != nr) {
  951. (l2->vs)--;
  952. if(test_bit(FLG_MOD128, &l2->flag)) {
  953. l2->vs %= 128;
  954. p1 = (l2->vs - l2->va) % 128;
  955. } else {
  956. l2->vs %= 8;
  957. p1 = (l2->vs - l2->va) % 8;
  958. }
  959. p1 = (p1 + l2->sow) % l2->window;
  960. if (test_bit(FLG_LAPB, &l2->flag))
  961. st->l1.bcs->tx_cnt += l2->windowar[p1]->len + l2headersize(l2, 0);
  962. skb_queue_head(&l2->i_queue, l2->windowar[p1]);
  963. l2->windowar[p1] = NULL;
  964. }
  965. st->l2.l2l1(st, PH_PULL | REQUEST, NULL);
  966. }
  967. }
  969. static void
  970. l2_st7_got_super(struct FsmInst *fi, int event, void *arg)
  971. {
  972. struct PStack *st = fi->userdata;
  973. struct sk_buff *skb = arg;
  974. int PollFlag, rsp, typ = RR;
  975. unsigned int nr;
  976. struct Layer2 *l2 = &st->l2;
  978. rsp = *skb->data & 0x2;
  979. if (test_bit(FLG_ORIG, &l2->flag))
  980. rsp = !rsp;
  982. skb_pull(skb, l2addrsize(l2));
  983. if (IsRNR(skb->data, st)) {
  984. set_peer_busy(l2);
  985. typ = RNR;
  986. } else
  987. clear_peer_busy(l2);
  988. if (IsREJ(skb->data, st))
  989. typ = REJ;
  991. if (test_bit(FLG_MOD128, &l2->flag)) {
  992. PollFlag = (skb->data[1] & 0x1) == 0x1;
  993. nr = skb->data[1] >> 1;
  994. } else {
  995. PollFlag = (skb->data[0] & 0x10);
  996. nr = (skb->data[0] >> 5) & 0x7;
  997. }
  998. FreeSkb(skb);
  1000. if (PollFlag) {
  1001. if (rsp)
  1002. st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'A');
  1003. else
  1004. enquiry_response(st);
  1005. }
  1006. if (legalnr(st, nr)) {
  1007. if (typ == REJ) {
  1008. setva(st, nr);
  1009. invoke_retransmission(st, nr);
  1010. stop_t200(st, 10);
  1011. if (FsmAddTimer(&st->l2.t203, st->l2.T203,
  1012. EV_L2_T203, NULL, 6))
  1013. l2m_debug(&st->l2.l2m, "Restart T203 ST7 REJ");
  1014. } else if ((nr == l2->vs) && (typ == RR)) {
  1015. setva(st, nr);
  1016. stop_t200(st, 11);
  1017. FsmRestartTimer(&st->l2.t203, st->l2.T203,
  1018. EV_L2_T203, NULL, 7);
  1019. } else if ((l2->va != nr) || (typ == RNR)) {
  1020. setva(st, nr);
  1021. if(typ != RR) FsmDelTimer(&st->l2.t203, 9);
  1022. restart_t200(st, 12);
  1023. }
  1024. if (skb_queue_len(&st->l2.i_queue) && (typ == RR))
  1025. st->l2.l2l1(st, PH_PULL | REQUEST, NULL);
  1026. } else
  1027. nrerrorrecovery(fi);
  1028. }
  1030. static void
  1031. l2_feed_i_if_reest(struct FsmInst *fi, int event, void *arg)
  1032. {
  1033. struct PStack *st = fi->userdata;
  1034. struct sk_buff *skb = arg;
  1036. if (test_bit(FLG_LAPB, &st->l2.flag))
  1037. st->l1.bcs->tx_cnt += skb->len + l2headersize(&st->l2, 0);
  1038. if (!test_bit(FLG_L3_INIT, &st->l2.flag))
  1039. skb_queue_tail(&st->l2.i_queue, skb);
  1040. else
  1041. FreeSkb(skb);
  1042. }
  1044. static void
  1045. l2_feed_i_pull(struct FsmInst *fi, int event, void *arg)
  1046. {
  1047. struct PStack *st = fi->userdata;
  1048. struct sk_buff *skb = arg;
  1050. if (test_bit(FLG_LAPB, &st->l2.flag))
  1051. st->l1.bcs->tx_cnt += skb->len + l2headersize(&st->l2, 0);
  1052. skb_queue_tail(&st->l2.i_queue, skb);
  1053. st->l2.l2l1(st, PH_PULL | REQUEST, NULL);
  1054. }
  1056. static void
  1057. l2_feed_iqueue(struct FsmInst *fi, int event, void *arg)
  1058. {
  1059. struct PStack *st = fi->userdata;
  1060. struct sk_buff *skb = arg;
  1062. if (test_bit(FLG_LAPB, &st->l2.flag))
  1063. st->l1.bcs->tx_cnt += skb->len + l2headersize(&st->l2, 0);
  1064. skb_queue_tail(&st->l2.i_queue, skb);
  1065. }
  1067. static void
  1068. l2_got_iframe(struct FsmInst *fi, int event, void *arg)
  1069. {
  1070. struct PStack *st = fi->userdata;
  1071. struct sk_buff *skb = arg;
  1072. struct Layer2 *l2 = &(st->l2);
  1073. int PollFlag, ns, i;
  1074. unsigned int nr;
  1076. i = l2addrsize(l2);
  1077. if (test_bit(FLG_MOD128, &l2->flag)) {
  1078. PollFlag = ((skb->data[i + 1] & 0x1) == 0x1);
  1079. ns = skb->data[i] >> 1;
  1080. nr = (skb->data[i + 1] >> 1) & 0x7f;
  1081. } else {
  1082. PollFlag = (skb->data[i] & 0x10);
  1083. ns = (skb->data[i] >> 1) & 0x7;
  1084. nr = (skb->data[i] >> 5) & 0x7;
  1085. }
  1086. if (test_bit(FLG_OWN_BUSY, &l2->flag)) {
  1087. FreeSkb(skb);
  1088. if(PollFlag) enquiry_response(st);
  1089. } else if (l2->vr == ns) {
  1090. (l2->vr)++;
  1091. if(test_bit(FLG_MOD128, &l2->flag))
  1092. l2->vr %= 128;
  1093. else
  1094. l2->vr %= 8;
  1095. test_and_clear_bit(FLG_REJEXC, &l2->flag);
  1097. if (PollFlag)
  1098. enquiry_response(st);
  1099. else
  1100. test_and_set_bit(FLG_ACK_PEND, &l2->flag);
  1101. skb_pull(skb, l2headersize(l2, 0));
  1102. st->l2.l2l3(st, DL_DATA | INDICATION, skb);
  1103. } else {
  1104. /* n(s)!=v(r) */
  1105. FreeSkb(skb);
  1106. if (test_and_set_bit(FLG_REJEXC, &l2->flag)) {
  1107. if (PollFlag)
  1108. enquiry_response(st);
  1109. } else {
  1110. enquiry_cr(st, REJ, RSP, PollFlag);
  1111. test_and_clear_bit(FLG_ACK_PEND, &l2->flag);
  1112. }
  1113. }
  1115. if (legalnr(st, nr)) {
  1116. if (!test_bit(FLG_PEER_BUSY, &st->l2.flag) && (fi->state == ST_L2_7)) {
  1117. if (nr == st->l2.vs) {
  1118. stop_t200(st, 13);
  1119. FsmRestartTimer(&st->l2.t203, st->l2.T203,
  1120. EV_L2_T203, NULL, 7);
  1121. } else if (nr != st->l2.va)
  1122. restart_t200(st, 14);
  1123. }
  1124. setva(st, nr);
  1125. } else {
  1126. nrerrorrecovery(fi);
  1127. return;
  1128. }
  1130. if (skb_queue_len(&st->l2.i_queue) && (fi->state == ST_L2_7))
  1131. st->l2.l2l1(st, PH_PULL | REQUEST, NULL);
  1132. if (test_and_clear_bit(FLG_ACK_PEND, &st->l2.flag))
  1133. enquiry_cr(st, RR, RSP, 0);
  1134. }
  1136. static void
  1137. l2_got_tei(struct FsmInst *fi, int event, void *arg)
  1138. {
  1139. struct PStack *st = fi->userdata;
  1141. st->l2.tei = (long) arg;
  1143. if (fi->state == ST_L2_3) {
  1144. establishlink(fi);
  1145. test_and_set_bit(FLG_L3_INIT, &st->l2.flag);
  1146. } else
  1147. FsmChangeState(fi, ST_L2_4);
  1148. if (skb_queue_len(&st->l2.ui_queue))
  1149. tx_ui(st);
  1150. }
  1152. static void
  1153. l2_st5_tout_200(struct FsmInst *fi, int event, void *arg)
  1154. {
  1155. struct PStack *st = fi->userdata;
  1157. if (test_bit(FLG_LAPD, &st->l2.flag) &&
  1158. test_bit(FLG_DCHAN_BUSY, &st->l2.flag)) {
  1159. FsmAddTimer(&st->l2.t200, st->l2.T200, EV_L2_T200, NULL, 9);
  1160. } else if (st->l2.rc == st->l2.N200) {
  1161. FsmChangeState(fi, ST_L2_4);
  1162. test_and_clear_bit(FLG_T200_RUN, &st->l2.flag);
  1163. skb_queue_purge(&st->l2.i_queue);
  1164. st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'G');
  1165. if (test_bit(FLG_LAPB, &st->l2.flag))
  1166. st->l2.l2l1(st, PH_DEACTIVATE | REQUEST, NULL);
  1167. st5_dl_release_l2l3(st);
  1168. } else {
  1169. st->l2.rc++;
  1170. FsmAddTimer(&st->l2.t200, st->l2.T200, EV_L2_T200, NULL, 9);
  1171. send_uframe(st, (test_bit(FLG_MOD128, &st->l2.flag) ? SABME : SABM)
  1172.     | 0x10, CMD);
  1173. }
  1174. }
  1176. static void
  1177. l2_st6_tout_200(struct FsmInst *fi, int event, void *arg)
  1178. {
  1179. struct PStack *st = fi->userdata;
  1181. if (test_bit(FLG_LAPD, &st->l2.flag) &&
  1182. test_bit(FLG_DCHAN_BUSY, &st->l2.flag)) {
  1183. FsmAddTimer(&st->l2.t200, st->l2.T200, EV_L2_T200, NULL, 9);
  1184. } else if (st->l2.rc == st->l2.N200) {
  1185. FsmChangeState(fi, ST_L2_4);
  1186. test_and_clear_bit(FLG_T200_RUN, &st->l2.flag);
  1187. st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'H');
  1188. lapb_dl_release_l2l3(st, CONFIRM);
  1189. } else {
  1190. st->l2.rc++;
  1191. FsmAddTimer(&st->l2.t200, st->l2.T200, EV_L2_T200,
  1192.     NULL, 9);
  1193. send_uframe(st, DISC | 0x10, CMD);
  1194. }
  1195. }
  1197. static void
  1198. l2_st7_tout_200(struct FsmInst *fi, int event, void *arg)
  1199. {
  1200. struct PStack *st = fi->userdata;
  1202. if (test_bit(FLG_LAPD, &st->l2.flag) &&
  1203. test_bit(FLG_DCHAN_BUSY, &st->l2.flag)) {
  1204. FsmAddTimer(&st->l2.t200, st->l2.T200, EV_L2_T200, NULL, 9);
  1205. return;
  1206. }
  1207. test_and_clear_bit(FLG_T200_RUN, &st->l2.flag);
  1208. st->l2.rc = 0;
  1209. FsmChangeState(fi, ST_L2_8);
  1211. transmit_enquiry(st);
  1212. st->l2.rc++;
  1213. }
  1215. static void
  1216. l2_st8_tout_200(struct FsmInst *fi, int event, void *arg)
  1217. {
  1218. struct PStack *st = fi->userdata;
  1220. if (test_bit(FLG_LAPD, &st->l2.flag) &&
  1221. test_bit(FLG_DCHAN_BUSY, &st->l2.flag)) {
  1222. FsmAddTimer(&st->l2.t200, st->l2.T200, EV_L2_T200, NULL, 9);
  1223. return;
  1224. }
  1225. test_and_clear_bit(FLG_T200_RUN, &st->l2.flag);
  1226. if (st->l2.rc == st->l2.N200) {
  1227. st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'I');
  1228. establishlink(fi);
  1229. test_and_clear_bit(FLG_L3_INIT, &st->l2.flag);
  1230. } else {
  1231. transmit_enquiry(st);
  1232. st->l2.rc++;
  1233. }
  1234. }
  1236. static void
  1237. l2_st7_tout_203(struct FsmInst *fi, int event, void *arg)
  1238. {
  1239. struct PStack *st = fi->userdata;
  1241. if (test_bit(FLG_LAPD, &st->l2.flag) &&
  1242. test_bit(FLG_DCHAN_BUSY, &st->l2.flag)) {
  1243. FsmAddTimer(&st->l2.t203, st->l2.T203, EV_L2_T203, NULL, 9);
  1244. return;
  1245. }
  1246. FsmChangeState(fi, ST_L2_8);
  1247. transmit_enquiry(st);
  1248. st->l2.rc = 0;
  1249. }
  1251. static void
  1252. l2_pull_iqueue(struct FsmInst *fi, int event, void *arg)
  1253. {
  1254. struct PStack *st = fi->userdata;
  1255. struct sk_buff *skb, *oskb;
  1256. struct Layer2 *l2 = &st->l2;
  1257. u_char header[MAX_HEADER_LEN];
  1258. int i;
  1259. int unsigned p1;
  1260. long flags;
  1262. if (!cansend(st))
  1263. return;
  1265. skb = skb_dequeue(&l2->i_queue);
  1266. if (!skb)
  1267. return;
  1269. save_flags(flags);
  1270. cli();
  1271. if(test_bit(FLG_MOD128, &l2->flag))
  1272. p1 = (l2->vs - l2->va) % 128;
  1273. else
  1274. p1 = (l2->vs - l2->va) % 8;
  1275. p1 = (p1 + l2->sow) % l2->window;
  1276. if (l2->windowar[p1]) {
  1277. printk(KERN_WARNING "isdnl2 try overwrite ack queue entry %dn",
  1278.        p1);
  1279. dev_kfree_skb(l2->windowar[p1]);
  1280. }
  1281. l2->windowar[p1] = skb_clone(skb, GFP_ATOMIC);
  1283. i = sethdraddr(&st->l2, header, CMD);
  1285. if (test_bit(FLG_MOD128, &l2->flag)) {
  1286. header[i++] = l2->vs << 1;
  1287. header[i++] = l2->vr << 1;
  1288. l2->vs = (l2->vs + 1) % 128;
  1289. } else {
  1290. header[i++] = (l2->vr << 5) | (l2->vs << 1);
  1291. l2->vs = (l2->vs + 1) % 8;
  1292. }
  1293. restore_flags(flags);
  1295. p1 = skb->data - skb->head;
  1296. if (p1 >= i)
  1297. memcpy(skb_push(skb, i), header, i);
  1298. else {
  1299. printk(KERN_WARNING
  1300. "isdl2 pull_iqueue skb header(%d/%d) too shortn", i, p1);
  1301. oskb = skb;
  1302. skb = alloc_skb(oskb->len + i, GFP_ATOMIC);
  1303. memcpy(skb_put(skb, i), header, i);
  1304. memcpy(skb_put(skb, oskb->len), oskb->data, oskb->len);
  1305. FreeSkb(oskb);
  1306. }
  1307. st->l2.l2l1(st, PH_PULL | INDICATION, skb);
  1308. test_and_clear_bit(FLG_ACK_PEND, &st->l2.flag);
  1309. if (!test_and_set_bit(FLG_T200_RUN, &st->l2.flag)) {
  1310. FsmDelTimer(&st->l2.t203, 13);
  1311. FsmAddTimer(&st->l2.t200, st->l2.T200, EV_L2_T200, NULL, 11);
  1312. }
  1313. if (skb_queue_len(&l2->i_queue) && cansend(st))
  1314. st->l2.l2l1(st, PH_PULL | REQUEST, NULL);
  1315. }
  1317. static void
  1318. l2_st8_got_super(struct FsmInst *fi, int event, void *arg)
  1319. {
  1320. struct PStack *st = fi->userdata;
  1321. struct sk_buff *skb = arg;
  1322. int PollFlag, rsp, rnr = 0;
  1323. unsigned int nr;
  1324. struct Layer2 *l2 = &st->l2;
  1326. rsp = *skb->data & 0x2;
  1327. if (test_bit(FLG_ORIG, &l2->flag))
  1328. rsp = !rsp;
  1330. skb_pull(skb, l2addrsize(l2));
  1332. if (IsRNR(skb->data, st)) {
  1333. set_peer_busy(l2);
  1334. rnr = 1;
  1335. } else
  1336. clear_peer_busy(l2);
  1338. if (test_bit(FLG_MOD128, &l2->flag)) {
  1339. PollFlag = (skb->data[1] & 0x1) == 0x1;
  1340. nr = skb->data[1] >> 1;
  1341. } else {
  1342. PollFlag = (skb->data[0] & 0x10);
  1343. nr = (skb->data[0] >> 5) & 0x7;
  1344. }
  1345. FreeSkb(skb);
  1347. if (rsp && PollFlag) {
  1348. if (legalnr(st, nr)) {
  1349. if (rnr) {
  1350. restart_t200(st, 15);
  1351. } else {
  1352. stop_t200(st, 16);
  1353. FsmAddTimer(&l2->t203, l2->T203,
  1354.     EV_L2_T203, NULL, 5);
  1355. setva(st, nr);
  1356. }
  1357. invoke_retransmission(st, nr);
  1358. FsmChangeState(fi, ST_L2_7);
  1359. if (skb_queue_len(&l2->i_queue) && cansend(st))
  1360. st->l2.l2l1(st, PH_PULL | REQUEST, NULL);
  1361. } else
  1362. nrerrorrecovery(fi);
  1363. } else {
  1364. if (!rsp && PollFlag)
  1365. enquiry_response(st);
  1366. if (legalnr(st, nr)) {
  1367. setva(st, nr);
  1368. } else
  1369. nrerrorrecovery(fi);
  1370. }
  1371. }
  1373. static void
  1374. l2_got_FRMR(struct FsmInst *fi, int event, void *arg)
  1375. {
  1376. struct PStack *st = fi->userdata;
  1377. struct sk_buff *skb = arg;
  1379. skb_pull(skb, l2addrsize(&st->l2) + 1);
  1381. if (!(skb->data[0] & 1) || ((skb->data[0] & 3) == 1) || /* I or S */
  1382.     (IsUA(skb->data) && (fi->state == ST_L2_7))) {
  1383. st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'K');
  1384. establishlink(fi);
  1385. test_and_clear_bit(FLG_L3_INIT, &st->l2.flag);
  1386. }
  1387. FreeSkb(skb);
  1388. }
  1390. static void
  1391. l2_st24_tei_remove(struct FsmInst *fi, int event, void *arg)
  1392. {
  1393. struct PStack *st = fi->userdata;
  1395. skb_queue_purge(&st->l2.ui_queue);
  1396. st->l2.tei = -1;
  1397. FsmChangeState(fi, ST_L2_1);
  1398. }
  1400. static void
  1401. l2_st3_tei_remove(struct FsmInst *fi, int event, void *arg)
  1402. {
  1403. struct PStack *st = fi->userdata;
  1405. skb_queue_purge(&st->l2.ui_queue);
  1406. st->l2.tei = -1;
  1407. st->l2.l2l3(st, DL_RELEASE | INDICATION, NULL);
  1408. FsmChangeState(fi, ST_L2_1);
  1409. }
  1411. static void
  1412. l2_st5_tei_remove(struct FsmInst *fi, int event, void *arg)
  1413. {
  1414. struct PStack *st = fi->userdata;
  1416. skb_queue_purge(&st->l2.i_queue);
  1417. skb_queue_purge(&st->l2.ui_queue);
  1418. freewin(st);
  1419. st->l2.tei = -1;
  1420. stop_t200(st, 17);
  1421. st5_dl_release_l2l3(st);
  1422. FsmChangeState(fi, ST_L2_1);
  1423. }
  1425. static void
  1426. l2_st6_tei_remove(struct FsmInst *fi, int event, void *arg)
  1427. {
  1428. struct PStack *st = fi->userdata;
  1430. skb_queue_purge(&st->l2.ui_queue);
  1431. st->l2.tei = -1;
  1432. stop_t200(st, 18);
  1433. st->l2.l2l3(st, DL_RELEASE | CONFIRM, NULL);
  1434. FsmChangeState(fi, ST_L2_1);
  1435. }
  1437. static void
  1438. l2_tei_remove(struct FsmInst *fi, int event, void *arg)
  1439. {
  1440. struct PStack *st = fi->userdata;
  1442. skb_queue_purge(&st->l2.i_queue);
  1443. skb_queue_purge(&st->l2.ui_queue);
  1444. freewin(st);
  1445. st->l2.tei = -1;
  1446. stop_t200(st, 17);
  1447. FsmDelTimer(&st->l2.t203, 19);
  1448. st->l2.l2l3(st, DL_RELEASE | INDICATION, NULL);
  1449. FsmChangeState(fi, ST_L2_1);
  1450. }
  1452. static void
  1453. l2_st14_persistant_da(struct FsmInst *fi, int event, void *arg)
  1454. {
  1455. struct PStack *st = fi->userdata;
  1457. skb_queue_purge(&st->l2.i_queue);
  1458. skb_queue_purge(&st->l2.ui_queue);
  1459. if (test_and_clear_bit(FLG_ESTAB_PEND, &st->l2.flag))
  1460. st->l2.l2l3(st, DL_RELEASE | INDICATION, NULL);
  1461. }
  1463. static void
  1464. l2_st5_persistant_da(struct FsmInst *fi, int event, void *arg)
  1465. {
  1466. struct PStack *st = fi->userdata;
  1468. skb_queue_purge(&st->l2.i_queue);
  1469. skb_queue_purge(&st->l2.ui_queue);
  1470. freewin(st);
  1471. stop_t200(st, 19);
  1472. st5_dl_release_l2l3(st);
  1473. FsmChangeState(fi, ST_L2_4);
  1474. }
  1476. static void
  1477. l2_st6_persistant_da(struct FsmInst *fi, int event, void *arg)
  1478. {
  1479. struct PStack *st = fi->userdata;
  1481. skb_queue_purge(&st->l2.ui_queue);
  1482. stop_t200(st, 20);
  1483. st->l2.l2l3(st, DL_RELEASE | CONFIRM, NULL);
  1484. FsmChangeState(fi, ST_L2_4);
  1485. }
  1487. static void
  1488. l2_persistant_da(struct FsmInst *fi, int event, void *arg)
  1489. {
  1490. struct PStack *st = fi->userdata;
  1492. skb_queue_purge(&st->l2.i_queue);
  1493. skb_queue_purge(&st->l2.ui_queue);
  1494. freewin(st);
  1495. stop_t200(st, 19);
  1496. FsmDelTimer(&st->l2.t203, 19);
  1497. st->l2.l2l3(st, DL_RELEASE | INDICATION, NULL);
  1498. FsmChangeState(fi, ST_L2_4);
  1499. }
  1501. static void
  1502. l2_set_own_busy(struct FsmInst *fi, int event, void *arg)
  1503. {
  1504. struct PStack *st = fi->userdata;
  1506. if(!test_and_set_bit(FLG_OWN_BUSY, &st->l2.flag)) {
  1507. enquiry_cr(st, RNR, RSP, 0);
  1508. test_and_clear_bit(FLG_ACK_PEND, &st->l2.flag);
  1509. }
  1510. }
  1512. static void
  1513. l2_clear_own_busy(struct FsmInst *fi, int event, void *arg)
  1514. {
  1515. struct PStack *st = fi->userdata;
  1517. if(!test_and_clear_bit(FLG_OWN_BUSY, &st->l2.flag)) {
  1518. enquiry_cr(st, RR, RSP, 0);
  1519. test_and_clear_bit(FLG_ACK_PEND, &st->l2.flag);
  1520. }
  1521. }
  1523. static void
  1524. l2_frame_error(struct FsmInst *fi, int event, void *arg)
  1525. {
  1526. struct PStack *st = fi->userdata;
  1528. st->ma.layer(st, MDL_ERROR | INDICATION, arg);
  1529. }
  1531. static void
  1532. l2_frame_error_reest(struct FsmInst *fi, int event, void *arg)
  1533. {
  1534. struct PStack *st = fi->userdata;
  1536. st->ma.layer(st, MDL_ERROR | INDICATION, arg);
  1537. establishlink(fi);
  1538. test_and_clear_bit(FLG_L3_INIT, &st->l2.flag);
  1539. }
  1541. static struct FsmNode L2FnList[] __initdata =
  1542. {
  1543. {ST_L2_1, EV_L2_DL_ESTABLISH_REQ, l2_mdl_assign},
  1544. {ST_L2_2, EV_L2_DL_ESTABLISH_REQ, l2_go_st3},
  1545. {ST_L2_4, EV_L2_DL_ESTABLISH_REQ, l2_establish},
  1546. {ST_L2_5, EV_L2_DL_ESTABLISH_REQ, l2_discard_i_setl3},
  1547. {ST_L2_7, EV_L2_DL_ESTABLISH_REQ, l2_l3_reestablish},
  1548. {ST_L2_8, EV_L2_DL_ESTABLISH_REQ, l2_l3_reestablish},
  1549. {ST_L2_4, EV_L2_DL_RELEASE_REQ, l2_release},
  1550. {ST_L2_5, EV_L2_DL_RELEASE_REQ, l2_pend_rel},
  1551. {ST_L2_7, EV_L2_DL_RELEASE_REQ, l2_disconnect},
  1552. {ST_L2_8, EV_L2_DL_RELEASE_REQ, l2_disconnect},
  1553. {ST_L2_5, EV_L2_DL_DATA, l2_feed_i_if_reest},
  1554. {ST_L2_7, EV_L2_DL_DATA, l2_feed_i_pull},
  1555. {ST_L2_8, EV_L2_DL_DATA, l2_feed_iqueue},
  1556. {ST_L2_1, EV_L2_DL_UNIT_DATA, l2_queue_ui_assign},
  1557. {ST_L2_2, EV_L2_DL_UNIT_DATA, l2_queue_ui},
  1558. {ST_L2_3, EV_L2_DL_UNIT_DATA, l2_queue_ui},
  1559. {ST_L2_4, EV_L2_DL_UNIT_DATA, l2_send_ui},
  1560. {ST_L2_5, EV_L2_DL_UNIT_DATA, l2_send_ui},
  1561. {ST_L2_6, EV_L2_DL_UNIT_DATA, l2_send_ui},
  1562. {ST_L2_7, EV_L2_DL_UNIT_DATA, l2_send_ui},
  1563. {ST_L2_8, EV_L2_DL_UNIT_DATA, l2_send_ui},
  1564. {ST_L2_1, EV_L2_MDL_ASSIGN, l2_got_tei},
  1565. {ST_L2_2, EV_L2_MDL_ASSIGN, l2_got_tei},
  1566. {ST_L2_3, EV_L2_MDL_ASSIGN, l2_got_tei},
  1567. {ST_L2_2, EV_L2_MDL_ERROR, l2_st24_tei_remove},
  1568. {ST_L2_3, EV_L2_MDL_ERROR, l2_st3_tei_remove},
  1569. {ST_L2_4, EV_L2_MDL_REMOVE, l2_st24_tei_remove},
  1570. {ST_L2_5, EV_L2_MDL_REMOVE, l2_st5_tei_remove},
  1571. {ST_L2_6, EV_L2_MDL_REMOVE, l2_st6_tei_remove},
  1572. {ST_L2_7, EV_L2_MDL_REMOVE, l2_tei_remove},
  1573. {ST_L2_8, EV_L2_MDL_REMOVE, l2_tei_remove},
  1574. {ST_L2_4, EV_L2_SABME, l2_start_multi},
  1575. {ST_L2_5, EV_L2_SABME, l2_send_UA},
  1576. {ST_L2_6, EV_L2_SABME, l2_send_DM},
  1577. {ST_L2_7, EV_L2_SABME, l2_restart_multi},
  1578. {ST_L2_8, EV_L2_SABME, l2_restart_multi},
  1579. {ST_L2_4, EV_L2_DISC, l2_send_DM},
  1580. {ST_L2_5, EV_L2_DISC, l2_send_DM},
  1581. {ST_L2_6, EV_L2_DISC, l2_send_UA},
  1582. {ST_L2_7, EV_L2_DISC, l2_stop_multi},
  1583. {ST_L2_8, EV_L2_DISC, l2_stop_multi},
  1584. {ST_L2_4, EV_L2_UA, l2_mdl_error_ua},
  1585. {ST_L2_5, EV_L2_UA, l2_connected},
  1586. {ST_L2_6, EV_L2_UA, l2_released},
  1587. {ST_L2_7, EV_L2_UA, l2_mdl_error_ua},
  1588. {ST_L2_8, EV_L2_UA, l2_mdl_error_ua},
  1589. {ST_L2_4, EV_L2_DM, l2_reestablish},
  1590. {ST_L2_5, EV_L2_DM, l2_st5_dm_release},
  1591. {ST_L2_6, EV_L2_DM, l2_st6_dm_release},
  1592. {ST_L2_7, EV_L2_DM, l2_mdl_error_dm},
  1593. {ST_L2_8, EV_L2_DM, l2_st8_mdl_error_dm},
  1594. {ST_L2_1, EV_L2_UI, l2_got_ui},
  1595. {ST_L2_2, EV_L2_UI, l2_got_ui},
  1596. {ST_L2_3, EV_L2_UI, l2_got_ui},
  1597. {ST_L2_4, EV_L2_UI, l2_got_ui},
  1598. {ST_L2_5, EV_L2_UI, l2_got_ui},
  1599. {ST_L2_6, EV_L2_UI, l2_got_ui},
  1600. {ST_L2_7, EV_L2_UI, l2_got_ui},
  1601. {ST_L2_8, EV_L2_UI, l2_got_ui},
  1602. {ST_L2_7, EV_L2_FRMR, l2_got_FRMR},
  1603. {ST_L2_8, EV_L2_FRMR, l2_got_FRMR},
  1604. {ST_L2_7, EV_L2_SUPER, l2_st7_got_super},
  1605. {ST_L2_8, EV_L2_SUPER, l2_st8_got_super},
  1606. {ST_L2_7, EV_L2_I, l2_got_iframe},
  1607. {ST_L2_8, EV_L2_I, l2_got_iframe},
  1608. {ST_L2_5, EV_L2_T200, l2_st5_tout_200},
  1609. {ST_L2_6, EV_L2_T200, l2_st6_tout_200},
  1610. {ST_L2_7, EV_L2_T200, l2_st7_tout_200},
  1611. {ST_L2_8, EV_L2_T200, l2_st8_tout_200},
  1612. {ST_L2_7, EV_L2_T203, l2_st7_tout_203},
  1613. {ST_L2_7, EV_L2_ACK_PULL, l2_pull_iqueue},
  1614. {ST_L2_7, EV_L2_SET_OWN_BUSY, l2_set_own_busy},
  1615. {ST_L2_8, EV_L2_SET_OWN_BUSY, l2_set_own_busy},
  1616. {ST_L2_7, EV_L2_CLEAR_OWN_BUSY, l2_clear_own_busy},
  1617. {ST_L2_8, EV_L2_CLEAR_OWN_BUSY, l2_clear_own_busy},
  1618. {ST_L2_4, EV_L2_FRAME_ERROR, l2_frame_error},
  1619. {ST_L2_5, EV_L2_FRAME_ERROR, l2_frame_error},
  1620. {ST_L2_6, EV_L2_FRAME_ERROR, l2_frame_error},
  1621. {ST_L2_7, EV_L2_FRAME_ERROR, l2_frame_error_reest},
  1622. {ST_L2_8, EV_L2_FRAME_ERROR, l2_frame_error_reest},
  1623. {ST_L2_1, EV_L1_DEACTIVATE, l2_st14_persistant_da},
  1624. {ST_L2_2, EV_L1_DEACTIVATE, l2_st24_tei_remove},
  1625. {ST_L2_3, EV_L1_DEACTIVATE, l2_st3_tei_remove},
  1626. {ST_L2_4, EV_L1_DEACTIVATE, l2_st14_persistant_da},
  1627. {ST_L2_5, EV_L1_DEACTIVATE, l2_st5_persistant_da},
  1628. {ST_L2_6, EV_L1_DEACTIVATE, l2_st6_persistant_da},
  1629. {ST_L2_7, EV_L1_DEACTIVATE, l2_persistant_da},
  1630. {ST_L2_8, EV_L1_DEACTIVATE, l2_persistant_da},
  1631. };
  1633. #define L2_FN_COUNT (sizeof(L2FnList)/sizeof(struct FsmNode))
  1635. static void
  1636. isdnl2_l1l2(struct PStack *st, int pr, void *arg)
  1637. {
  1638. struct sk_buff *skb = arg;
  1639. u_char *datap;
  1640. int ret = 1, len;
  1641. int c = 0;
  1643. switch (pr) {
  1644. case (PH_DATA | INDICATION):
  1645. datap = skb->data;
  1646. len = l2addrsize(&st->l2);
  1647. if (skb->len > len)
  1648. datap += len;
  1649. else {
  1650. FsmEvent(&st->l2.l2m, EV_L2_FRAME_ERROR, (void *) 'N');
  1651. FreeSkb(skb);
  1652. return;
  1653. }
  1654. if (!(*datap & 1)) { /* I-Frame */
  1655. if(!(c = iframe_error(st, skb)))
  1656. ret = FsmEvent(&st->l2.l2m, EV_L2_I, skb);
  1657. } else if (IsSFrame(datap, st)) { /* S-Frame */
  1658. if(!(c = super_error(st, skb)))
  1659. ret = FsmEvent(&st->l2.l2m, EV_L2_SUPER, skb);
  1660. } else if (IsUI(datap)) {
  1661. if(!(c = UI_error(st, skb)))
  1662. ret = FsmEvent(&st->l2.l2m, EV_L2_UI, skb);
  1663. } else if (IsSABME(datap, st)) {
  1664. if(!(c = unnum_error(st, skb, CMD)))
  1665. ret = FsmEvent(&st->l2.l2m, EV_L2_SABME, skb);
  1666. } else if (IsUA(datap)) {
  1667. if(!(c = unnum_error(st, skb, RSP)))
  1668. ret = FsmEvent(&st->l2.l2m, EV_L2_UA, skb);
  1669. } else if (IsDISC(datap)) {
  1670. if(!(c = unnum_error(st, skb, CMD)))
  1671. ret = FsmEvent(&st->l2.l2m, EV_L2_DISC, skb);
  1672. } else if (IsDM(datap)) {
  1673. if(!(c = unnum_error(st, skb, RSP)))
  1674. ret = FsmEvent(&st->l2.l2m, EV_L2_DM, skb);
  1675. } else if (IsFRMR(datap)) {
  1676. if(!(c = FRMR_error(st,skb)))
  1677. ret = FsmEvent(&st->l2.l2m, EV_L2_FRMR, skb);
  1678. } else {
  1679. FsmEvent(&st->l2.l2m, EV_L2_FRAME_ERROR, (void *) 'L');
  1680. FreeSkb(skb);
  1681. ret = 0;
  1682. }
  1683. if(c) {
  1684. FreeSkb(skb);
  1685. FsmEvent(&st->l2.l2m, EV_L2_FRAME_ERROR, (void *)(long)c);
  1686. ret = 0;
  1687. }
  1688. if (ret)
  1689. FreeSkb(skb);
  1690. break;
  1691. case (PH_PULL | CONFIRM):
  1692. FsmEvent(&st->l2.l2m, EV_L2_ACK_PULL, arg);
  1693. break;
  1694. case (PH_PAUSE | INDICATION):
  1695. test_and_set_bit(FLG_DCHAN_BUSY, &st->l2.flag);
  1696. break;
  1697. case (PH_PAUSE | CONFIRM):
  1698. test_and_clear_bit(FLG_DCHAN_BUSY, &st->l2.flag);
  1699. break;
  1700. case (PH_ACTIVATE | CONFIRM):
  1701. case (PH_ACTIVATE | INDICATION):
  1702. test_and_set_bit(FLG_L1_ACTIV, &st->l2.flag);
  1703. if (test_and_clear_bit(FLG_ESTAB_PEND, &st->l2.flag))
  1704. FsmEvent(&st->l2.l2m, EV_L2_DL_ESTABLISH_REQ, arg);
  1705. break;
  1706. case (PH_DEACTIVATE | INDICATION):
  1707. case (PH_DEACTIVATE | CONFIRM):
  1708. test_and_clear_bit(FLG_L1_ACTIV, &st->l2.flag);
  1709. FsmEvent(&st->l2.l2m, EV_L1_DEACTIVATE, arg);
  1710. break;
  1711. default:
  1712. l2m_debug(&st->l2.l2m, "l2 unknown pr %04x", pr);
  1713. break;
  1714. }
  1715. }
  1717. static void
  1718. isdnl2_l3l2(struct PStack *st, int pr, void *arg)
  1719. {
  1720. switch (pr) {
  1721. case (DL_DATA | REQUEST):
  1722. if (FsmEvent(&st->l2.l2m, EV_L2_DL_DATA, arg)) {
  1723. dev_kfree_skb((struct sk_buff *) arg);
  1724. }
  1725. break;
  1726. case (DL_UNIT_DATA | REQUEST):
  1727. if (FsmEvent(&st->l2.l2m, EV_L2_DL_UNIT_DATA, arg)) {
  1728. dev_kfree_skb((struct sk_buff *) arg);
  1729. }
  1730. break;
  1731. case (DL_ESTABLISH | REQUEST):
  1732. if (test_bit(FLG_L1_ACTIV, &st->l2.flag)) {
  1733. if (test_bit(FLG_LAPD, &st->l2.flag) ||
  1734. test_bit(FLG_ORIG, &st->l2.flag)) {
  1735. FsmEvent(&st->l2.l2m, EV_L2_DL_ESTABLISH_REQ, arg);
  1736. }
  1737. } else {
  1738. if (test_bit(FLG_LAPD, &st->l2.flag) ||
  1739. test_bit(FLG_ORIG, &st->l2.flag)) {
  1740. test_and_set_bit(FLG_ESTAB_PEND, &st->l2.flag);
  1741. }
  1742. st->l2.l2l1(st, PH_ACTIVATE, NULL);
  1743. }
  1744. break;
  1745. case (DL_RELEASE | REQUEST):
  1746. if (test_bit(FLG_LAPB, &st->l2.flag)) {
  1747. st->l2.l2l1(st, PH_DEACTIVATE, NULL);
  1748. }
  1749. FsmEvent(&st->l2.l2m, EV_L2_DL_RELEASE_REQ, arg);
  1750. break;
  1751. case (MDL_ASSIGN | REQUEST):
  1752. FsmEvent(&st->l2.l2m, EV_L2_MDL_ASSIGN, arg);
  1753. break;
  1754. case (MDL_REMOVE | REQUEST):
  1755. FsmEvent(&st->l2.l2m, EV_L2_MDL_REMOVE, arg);
  1756. break;
  1757. case (MDL_ERROR | RESPONSE):
  1758. FsmEvent(&st->l2.l2m, EV_L2_MDL_ERROR, arg);
  1759. break;
  1760. }
  1761. }
  1763. void
  1764. releasestack_isdnl2(struct PStack *st)
  1765. {
  1766. FsmDelTimer(&st->l2.t200, 21);
  1767. FsmDelTimer(&st->l2.t203, 16);
  1768. skb_queue_purge(&st->l2.i_queue);
  1769. skb_queue_purge(&st->l2.ui_queue);
  1770. ReleaseWin(&st->l2);
  1771. }
  1773. static void
  1774. l2m_debug(struct FsmInst *fi, char *fmt, ...)
  1775. {
  1776. va_list args;
  1777. struct PStack *st = fi->userdata;
  1779. va_start(args, fmt);
  1780. VHiSax_putstatus(st->l1.hardware, st->l2.debug_id, fmt, args);
  1781. va_end(args);
  1782. }
  1784. void
  1785. setstack_isdnl2(struct PStack *st, char *debug_id)
  1786. {
  1787. st->l1.l1l2 = isdnl2_l1l2;
  1788. st->l3.l3l2 = isdnl2_l3l2;
  1790. skb_queue_head_init(&st->l2.i_queue);
  1791. skb_queue_head_init(&st->l2.ui_queue);
  1792. InitWin(&st->l2);
  1793. st->l2.debug = 0;
  1795. st->l2.l2m.fsm = &l2fsm;
  1796. if (test_bit(FLG_LAPB, &st->l2.flag))
  1797. st->l2.l2m.state = ST_L2_4;
  1798. else
  1799. st->l2.l2m.state = ST_L2_1;
  1800. st->l2.l2m.debug = 0;
  1801. st->l2.l2m.userdata = st;
  1802. st->l2.l2m.userint = 0;
  1803. st->l2.l2m.printdebug = l2m_debug;
  1804. strcpy(st->l2.debug_id, debug_id);
  1806. FsmInitTimer(&st->l2.l2m, &st->l2.t200);
  1807. FsmInitTimer(&st->l2.l2m, &st->l2.t203);
  1808. }
  1810. static void
  1811. transl2_l3l2(struct PStack *st, int pr, void *arg)
  1812. {
  1813. switch (pr) {
  1814. case (DL_DATA | REQUEST):
  1815. case (DL_UNIT_DATA | REQUEST):
  1816. st->l2.l2l1(st, PH_DATA | REQUEST, arg);
  1817. break;
  1818. case (DL_ESTABLISH | REQUEST):
  1819. st->l2.l2l1(st, PH_ACTIVATE | REQUEST, NULL);
  1820. break;
  1821. case (DL_RELEASE | REQUEST):
  1822. st->l2.l2l1(st, PH_DEACTIVATE | REQUEST, NULL);
  1823. break;
  1824. }
  1825. }
  1827. void
  1828. setstack_transl2(struct PStack *st)
  1829. {
  1830. st->l3.l3l2 = transl2_l3l2;
  1831. }
  1833. void
  1834. releasestack_transl2(struct PStack *st)
  1835. {
  1836. }
  1838. int __init
  1839. Isdnl2New(void)
  1840. {
  1841. l2fsm.state_count = L2_STATE_COUNT;
  1842. l2fsm.event_count = L2_EVENT_COUNT;
  1843. l2fsm.strEvent = strL2Event;
  1844. l2fsm.strState = strL2State;
  1845. return FsmNew(&l2fsm, L2FnList, L2_FN_COUNT);
  1846. }
  1848. void
  1849. Isdnl2Free(void)
  1850. {
  1851. FsmFree(&l2fsm);
  1852. }