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