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