1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18#include <linux/mISDNif.h>
19#include <linux/slab.h>
20#include "core.h"
21#include "fsm.h"
22#include "layer2.h"
23
24static u_int *debug;
25
26static
27struct Fsm l2fsm = {NULL, 0, 0, NULL, NULL};
28
29static char *strL2State[] =
30{
31 "ST_L2_1",
32 "ST_L2_2",
33 "ST_L2_3",
34 "ST_L2_4",
35 "ST_L2_5",
36 "ST_L2_6",
37 "ST_L2_7",
38 "ST_L2_8",
39};
40
41enum {
42 EV_L2_UI,
43 EV_L2_SABME,
44 EV_L2_DISC,
45 EV_L2_DM,
46 EV_L2_UA,
47 EV_L2_FRMR,
48 EV_L2_SUPER,
49 EV_L2_I,
50 EV_L2_DL_DATA,
51 EV_L2_ACK_PULL,
52 EV_L2_DL_UNITDATA,
53 EV_L2_DL_ESTABLISH_REQ,
54 EV_L2_DL_RELEASE_REQ,
55 EV_L2_MDL_ASSIGN,
56 EV_L2_MDL_REMOVE,
57 EV_L2_MDL_ERROR,
58 EV_L1_DEACTIVATE,
59 EV_L2_T200,
60 EV_L2_T203,
61 EV_L2_SET_OWN_BUSY,
62 EV_L2_CLEAR_OWN_BUSY,
63 EV_L2_FRAME_ERROR,
64};
65
66#define L2_EVENT_COUNT (EV_L2_FRAME_ERROR+1)
67
68static char *strL2Event[] =
69{
70 "EV_L2_UI",
71 "EV_L2_SABME",
72 "EV_L2_DISC",
73 "EV_L2_DM",
74 "EV_L2_UA",
75 "EV_L2_FRMR",
76 "EV_L2_SUPER",
77 "EV_L2_I",
78 "EV_L2_DL_DATA",
79 "EV_L2_ACK_PULL",
80 "EV_L2_DL_UNITDATA",
81 "EV_L2_DL_ESTABLISH_REQ",
82 "EV_L2_DL_RELEASE_REQ",
83 "EV_L2_MDL_ASSIGN",
84 "EV_L2_MDL_REMOVE",
85 "EV_L2_MDL_ERROR",
86 "EV_L1_DEACTIVATE",
87 "EV_L2_T200",
88 "EV_L2_T203",
89 "EV_L2_SET_OWN_BUSY",
90 "EV_L2_CLEAR_OWN_BUSY",
91 "EV_L2_FRAME_ERROR",
92};
93
94static void
95l2m_debug(struct FsmInst *fi, char *fmt, ...)
96{
97 struct layer2 *l2 = fi->userdata;
98 struct va_format vaf;
99 va_list va;
100
101 if (!(*debug & DEBUG_L2_FSM))
102 return;
103
104 va_start(va, fmt);
105
106 vaf.fmt = fmt;
107 vaf.va = &va;
108
109 printk(KERN_DEBUG "l2 (sapi %d tei %d): %pV\n",
110 l2->sapi, l2->tei, &vaf);
111
112 va_end(va);
113}
114
115inline u_int
116l2headersize(struct layer2 *l2, int ui)
117{
118 return ((test_bit(FLG_MOD128, &l2->flag) && (!ui)) ? 2 : 1) +
119 (test_bit(FLG_LAPD, &l2->flag) ? 2 : 1);
120}
121
122inline u_int
123l2addrsize(struct layer2 *l2)
124{
125 return test_bit(FLG_LAPD, &l2->flag) ? 2 : 1;
126}
127
128static u_int
129l2_newid(struct layer2 *l2)
130{
131 u_int id;
132
133 id = l2->next_id++;
134 if (id == 0x7fff)
135 l2->next_id = 1;
136 id <<= 16;
137 id |= l2->tei << 8;
138 id |= l2->sapi;
139 return id;
140}
141
142static void
143l2up(struct layer2 *l2, u_int prim, struct sk_buff *skb)
144{
145 int err;
146
147 if (!l2->up)
148 return;
149 mISDN_HEAD_PRIM(skb) = prim;
150 mISDN_HEAD_ID(skb) = (l2->ch.nr << 16) | l2->ch.addr;
151 err = l2->up->send(l2->up, skb);
152 if (err) {
153 printk(KERN_WARNING "%s: err=%d\n", __func__, err);
154 dev_kfree_skb(skb);
155 }
156}
157
158static void
159l2up_create(struct layer2 *l2, u_int prim, int len, void *arg)
160{
161 struct sk_buff *skb;
162 struct mISDNhead *hh;
163 int err;
164
165 if (!l2->up)
166 return;
167 skb = mI_alloc_skb(len, GFP_ATOMIC);
168 if (!skb)
169 return;
170 hh = mISDN_HEAD_P(skb);
171 hh->prim = prim;
172 hh->id = (l2->ch.nr << 16) | l2->ch.addr;
173 if (len)
174 memcpy(skb_put(skb, len), arg, len);
175 err = l2->up->send(l2->up, skb);
176 if (err) {
177 printk(KERN_WARNING "%s: err=%d\n", __func__, err);
178 dev_kfree_skb(skb);
179 }
180}
181
182static int
183l2down_skb(struct layer2 *l2, struct sk_buff *skb) {
184 int ret;
185
186 ret = l2->ch.recv(l2->ch.peer, skb);
187 if (ret && (*debug & DEBUG_L2_RECV))
188 printk(KERN_DEBUG "l2down_skb: ret(%d)\n", ret);
189 return ret;
190}
191
192static int
193l2down_raw(struct layer2 *l2, struct sk_buff *skb)
194{
195 struct mISDNhead *hh = mISDN_HEAD_P(skb);
196
197 if (hh->prim == PH_DATA_REQ) {
198 if (test_and_set_bit(FLG_L1_NOTREADY, &l2->flag)) {
199 skb_queue_tail(&l2->down_queue, skb);
200 return 0;
201 }
202 l2->down_id = mISDN_HEAD_ID(skb);
203 }
204 return l2down_skb(l2, skb);
205}
206
207static int
208l2down(struct layer2 *l2, u_int prim, u_int id, struct sk_buff *skb)
209{
210 struct mISDNhead *hh = mISDN_HEAD_P(skb);
211
212 hh->prim = prim;
213 hh->id = id;
214 return l2down_raw(l2, skb);
215}
216
217static int
218l2down_create(struct layer2 *l2, u_int prim, u_int id, int len, void *arg)
219{
220 struct sk_buff *skb;
221 int err;
222 struct mISDNhead *hh;
223
224 skb = mI_alloc_skb(len, GFP_ATOMIC);
225 if (!skb)
226 return -ENOMEM;
227 hh = mISDN_HEAD_P(skb);
228 hh->prim = prim;
229 hh->id = id;
230 if (len)
231 memcpy(skb_put(skb, len), arg, len);
232 err = l2down_raw(l2, skb);
233 if (err)
234 dev_kfree_skb(skb);
235 return err;
236}
237
238static int
239ph_data_confirm(struct layer2 *l2, struct mISDNhead *hh, struct sk_buff *skb) {
240 struct sk_buff *nskb = skb;
241 int ret = -EAGAIN;
242
243 if (test_bit(FLG_L1_NOTREADY, &l2->flag)) {
244 if (hh->id == l2->down_id) {
245 nskb = skb_dequeue(&l2->down_queue);
246 if (nskb) {
247 l2->down_id = mISDN_HEAD_ID(nskb);
248 if (l2down_skb(l2, nskb)) {
249 dev_kfree_skb(nskb);
250 l2->down_id = MISDN_ID_NONE;
251 }
252 } else
253 l2->down_id = MISDN_ID_NONE;
254 if (ret) {
255 dev_kfree_skb(skb);
256 ret = 0;
257 }
258 if (l2->down_id == MISDN_ID_NONE) {
259 test_and_clear_bit(FLG_L1_NOTREADY, &l2->flag);
260 mISDN_FsmEvent(&l2->l2m, EV_L2_ACK_PULL, NULL);
261 }
262 }
263 }
264 if (!test_and_set_bit(FLG_L1_NOTREADY, &l2->flag)) {
265 nskb = skb_dequeue(&l2->down_queue);
266 if (nskb) {
267 l2->down_id = mISDN_HEAD_ID(nskb);
268 if (l2down_skb(l2, nskb)) {
269 dev_kfree_skb(nskb);
270 l2->down_id = MISDN_ID_NONE;
271 test_and_clear_bit(FLG_L1_NOTREADY, &l2->flag);
272 }
273 } else
274 test_and_clear_bit(FLG_L1_NOTREADY, &l2->flag);
275 }
276 return ret;
277}
278
279static int
280l2mgr(struct layer2 *l2, u_int prim, void *arg) {
281 long c = (long)arg;
282
283 printk(KERN_WARNING
284 "l2mgr: addr:%x prim %x %c\n", l2->id, prim, (char)c);
285 if (test_bit(FLG_LAPD, &l2->flag) &&
286 !test_bit(FLG_FIXED_TEI, &l2->flag)) {
287 switch (c) {
288 case 'C':
289 case 'D':
290 case 'G':
291 case 'H':
292 l2_tei(l2, prim, (u_long)arg);
293 break;
294 }
295 }
296 return 0;
297}
298
299static void
300set_peer_busy(struct layer2 *l2) {
301 test_and_set_bit(FLG_PEER_BUSY, &l2->flag);
302 if (skb_queue_len(&l2->i_queue) || skb_queue_len(&l2->ui_queue))
303 test_and_set_bit(FLG_L2BLOCK, &l2->flag);
304}
305
306static void
307clear_peer_busy(struct layer2 *l2) {
308 if (test_and_clear_bit(FLG_PEER_BUSY, &l2->flag))
309 test_and_clear_bit(FLG_L2BLOCK, &l2->flag);
310}
311
312static void
313InitWin(struct layer2 *l2)
314{
315 int i;
316
317 for (i = 0; i < MAX_WINDOW; i++)
318 l2->windowar[i] = NULL;
319}
320
321static int
322freewin(struct layer2 *l2)
323{
324 int i, cnt = 0;
325
326 for (i = 0; i < MAX_WINDOW; i++) {
327 if (l2->windowar[i]) {
328 cnt++;
329 dev_kfree_skb(l2->windowar[i]);
330 l2->windowar[i] = NULL;
331 }
332 }
333 return cnt;
334}
335
336static void
337ReleaseWin(struct layer2 *l2)
338{
339 int cnt = freewin(l2);
340
341 if (cnt)
342 printk(KERN_WARNING
343 "isdnl2 freed %d skbuffs in release\n", cnt);
344}
345
346inline unsigned int
347cansend(struct layer2 *l2)
348{
349 unsigned int p1;
350
351 if (test_bit(FLG_MOD128, &l2->flag))
352 p1 = (l2->vs - l2->va) % 128;
353 else
354 p1 = (l2->vs - l2->va) % 8;
355 return (p1 < l2->window) && !test_bit(FLG_PEER_BUSY, &l2->flag);
356}
357
358inline void
359clear_exception(struct layer2 *l2)
360{
361 test_and_clear_bit(FLG_ACK_PEND, &l2->flag);
362 test_and_clear_bit(FLG_REJEXC, &l2->flag);
363 test_and_clear_bit(FLG_OWN_BUSY, &l2->flag);
364 clear_peer_busy(l2);
365}
366
367static int
368sethdraddr(struct layer2 *l2, u_char *header, int rsp)
369{
370 u_char *ptr = header;
371 int crbit = rsp;
372
373 if (test_bit(FLG_LAPD, &l2->flag)) {
374 if (test_bit(FLG_LAPD_NET, &l2->flag))
375 crbit = !crbit;
376 *ptr++ = (l2->sapi << 2) | (crbit ? 2 : 0);
377 *ptr++ = (l2->tei << 1) | 1;
378 return 2;
379 } else {
380 if (test_bit(FLG_ORIG, &l2->flag))
381 crbit = !crbit;
382 if (crbit)
383 *ptr++ = l2->addr.B;
384 else
385 *ptr++ = l2->addr.A;
386 return 1;
387 }
388}
389
390static inline void
391enqueue_super(struct layer2 *l2, struct sk_buff *skb)
392{
393 if (l2down(l2, PH_DATA_REQ, l2_newid(l2), skb))
394 dev_kfree_skb(skb);
395}
396
397static inline void
398enqueue_ui(struct layer2 *l2, struct sk_buff *skb)
399{
400 if (l2->tm)
401 l2_tei(l2, MDL_STATUS_UI_IND, 0);
402 if (l2down(l2, PH_DATA_REQ, l2_newid(l2), skb))
403 dev_kfree_skb(skb);
404}
405
406inline int
407IsUI(u_char *data)
408{
409 return (data[0] & 0xef) == UI;
410}
411
412inline int
413IsUA(u_char *data)
414{
415 return (data[0] & 0xef) == UA;
416}
417
418inline int
419IsDM(u_char *data)
420{
421 return (data[0] & 0xef) == DM;
422}
423
424inline int
425IsDISC(u_char *data)
426{
427 return (data[0] & 0xef) == DISC;
428}
429
430inline int
431IsRR(u_char *data, struct layer2 *l2)
432{
433 if (test_bit(FLG_MOD128, &l2->flag))
434 return data[0] == RR;
435 else
436 return (data[0] & 0xf) == 1;
437}
438
439inline int
440IsSFrame(u_char *data, struct layer2 *l2)
441{
442 register u_char d = *data;
443
444 if (!test_bit(FLG_MOD128, &l2->flag))
445 d &= 0xf;
446 return ((d & 0xf3) == 1) && ((d & 0x0c) != 0x0c);
447}
448
449inline int
450IsSABME(u_char *data, struct layer2 *l2)
451{
452 u_char d = data[0] & ~0x10;
453
454 return test_bit(FLG_MOD128, &l2->flag) ? d == SABME : d == SABM;
455}
456
457inline int
458IsREJ(u_char *data, struct layer2 *l2)
459{
460 return test_bit(FLG_MOD128, &l2->flag) ?
461 data[0] == REJ : (data[0] & 0xf) == REJ;
462}
463
464inline int
465IsFRMR(u_char *data)
466{
467 return (data[0] & 0xef) == FRMR;
468}
469
470inline int
471IsRNR(u_char *data, struct layer2 *l2)
472{
473 return test_bit(FLG_MOD128, &l2->flag) ?
474 data[0] == RNR : (data[0] & 0xf) == RNR;
475}
476
477static int
478iframe_error(struct layer2 *l2, struct sk_buff *skb)
479{
480 u_int i;
481 int rsp = *skb->data & 0x2;
482
483 i = l2addrsize(l2) + (test_bit(FLG_MOD128, &l2->flag) ? 2 : 1);
484 if (test_bit(FLG_ORIG, &l2->flag))
485 rsp = !rsp;
486 if (rsp)
487 return 'L';
488 if (skb->len < i)
489 return 'N';
490 if ((skb->len - i) > l2->maxlen)
491 return 'O';
492 return 0;
493}
494
495static int
496super_error(struct layer2 *l2, struct sk_buff *skb)
497{
498 if (skb->len != l2addrsize(l2) +
499 (test_bit(FLG_MOD128, &l2->flag) ? 2 : 1))
500 return 'N';
501 return 0;
502}
503
504static int
505unnum_error(struct layer2 *l2, struct sk_buff *skb, int wantrsp)
506{
507 int rsp = (*skb->data & 0x2) >> 1;
508 if (test_bit(FLG_ORIG, &l2->flag))
509 rsp = !rsp;
510 if (rsp != wantrsp)
511 return 'L';
512 if (skb->len != l2addrsize(l2) + 1)
513 return 'N';
514 return 0;
515}
516
517static int
518UI_error(struct layer2 *l2, struct sk_buff *skb)
519{
520 int rsp = *skb->data & 0x2;
521 if (test_bit(FLG_ORIG, &l2->flag))
522 rsp = !rsp;
523 if (rsp)
524 return 'L';
525 if (skb->len > l2->maxlen + l2addrsize(l2) + 1)
526 return 'O';
527 return 0;
528}
529
530static int
531FRMR_error(struct layer2 *l2, struct sk_buff *skb)
532{
533 u_int headers = l2addrsize(l2) + 1;
534 u_char *datap = skb->data + headers;
535 int rsp = *skb->data & 0x2;
536
537 if (test_bit(FLG_ORIG, &l2->flag))
538 rsp = !rsp;
539 if (!rsp)
540 return 'L';
541 if (test_bit(FLG_MOD128, &l2->flag)) {
542 if (skb->len < headers + 5)
543 return 'N';
544 else if (*debug & DEBUG_L2)
545 l2m_debug(&l2->l2m,
546 "FRMR information %2x %2x %2x %2x %2x",
547 datap[0], datap[1], datap[2], datap[3], datap[4]);
548 } else {
549 if (skb->len < headers + 3)
550 return 'N';
551 else if (*debug & DEBUG_L2)
552 l2m_debug(&l2->l2m,
553 "FRMR information %2x %2x %2x",
554 datap[0], datap[1], datap[2]);
555 }
556 return 0;
557}
558
559static unsigned int
560legalnr(struct layer2 *l2, unsigned int nr)
561{
562 if (test_bit(FLG_MOD128, &l2->flag))
563 return ((nr - l2->va) % 128) <= ((l2->vs - l2->va) % 128);
564 else
565 return ((nr - l2->va) % 8) <= ((l2->vs - l2->va) % 8);
566}
567
568static void
569setva(struct layer2 *l2, unsigned int nr)
570{
571 struct sk_buff *skb;
572
573 while (l2->va != nr) {
574 l2->va++;
575 if (test_bit(FLG_MOD128, &l2->flag))
576 l2->va %= 128;
577 else
578 l2->va %= 8;
579 if (l2->windowar[l2->sow]) {
580 skb_trim(l2->windowar[l2->sow], 0);
581 skb_queue_tail(&l2->tmp_queue, l2->windowar[l2->sow]);
582 l2->windowar[l2->sow] = NULL;
583 }
584 l2->sow = (l2->sow + 1) % l2->window;
585 }
586 skb = skb_dequeue(&l2->tmp_queue);
587 while (skb) {
588 dev_kfree_skb(skb);
589 skb = skb_dequeue(&l2->tmp_queue);
590 }
591}
592
593static void
594send_uframe(struct layer2 *l2, struct sk_buff *skb, u_char cmd, u_char cr)
595{
596 u_char tmp[MAX_L2HEADER_LEN];
597 int i;
598
599 i = sethdraddr(l2, tmp, cr);
600 tmp[i++] = cmd;
601 if (skb)
602 skb_trim(skb, 0);
603 else {
604 skb = mI_alloc_skb(i, GFP_ATOMIC);
605 if (!skb) {
606 printk(KERN_WARNING "%s: can't alloc skbuff\n",
607 __func__);
608 return;
609 }
610 }
611 memcpy(skb_put(skb, i), tmp, i);
612 enqueue_super(l2, skb);
613}
614
615
616inline u_char
617get_PollFlag(struct layer2 *l2, struct sk_buff *skb)
618{
619 return skb->data[l2addrsize(l2)] & 0x10;
620}
621
622inline u_char
623get_PollFlagFree(struct layer2 *l2, struct sk_buff *skb)
624{
625 u_char PF;
626
627 PF = get_PollFlag(l2, skb);
628 dev_kfree_skb(skb);
629 return PF;
630}
631
632inline void
633start_t200(struct layer2 *l2, int i)
634{
635 mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, i);
636 test_and_set_bit(FLG_T200_RUN, &l2->flag);
637}
638
639inline void
640restart_t200(struct layer2 *l2, int i)
641{
642 mISDN_FsmRestartTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, i);
643 test_and_set_bit(FLG_T200_RUN, &l2->flag);
644}
645
646inline void
647stop_t200(struct layer2 *l2, int i)
648{
649 if (test_and_clear_bit(FLG_T200_RUN, &l2->flag))
650 mISDN_FsmDelTimer(&l2->t200, i);
651}
652
653inline void
654st5_dl_release_l2l3(struct layer2 *l2)
655{
656 int pr;
657
658 if (test_and_clear_bit(FLG_PEND_REL, &l2->flag))
659 pr = DL_RELEASE_CNF;
660 else
661 pr = DL_RELEASE_IND;
662 l2up_create(l2, pr, 0, NULL);
663}
664
665inline void
666lapb_dl_release_l2l3(struct layer2 *l2, int f)
667{
668 if (test_bit(FLG_LAPB, &l2->flag))
669 l2down_create(l2, PH_DEACTIVATE_REQ, l2_newid(l2), 0, NULL);
670 l2up_create(l2, f, 0, NULL);
671}
672
673static void
674establishlink(struct FsmInst *fi)
675{
676 struct layer2 *l2 = fi->userdata;
677 u_char cmd;
678
679 clear_exception(l2);
680 l2->rc = 0;
681 cmd = (test_bit(FLG_MOD128, &l2->flag) ? SABME : SABM) | 0x10;
682 send_uframe(l2, NULL, cmd, CMD);
683 mISDN_FsmDelTimer(&l2->t203, 1);
684 restart_t200(l2, 1);
685 test_and_clear_bit(FLG_PEND_REL, &l2->flag);
686 freewin(l2);
687 mISDN_FsmChangeState(fi, ST_L2_5);
688}
689
690static void
691l2_mdl_error_ua(struct FsmInst *fi, int event, void *arg)
692{
693 struct sk_buff *skb = arg;
694 struct layer2 *l2 = fi->userdata;
695
696 if (get_PollFlagFree(l2, skb))
697 l2mgr(l2, MDL_ERROR_IND, (void *) 'C');
698 else
699 l2mgr(l2, MDL_ERROR_IND, (void *) 'D');
700
701}
702
703static void
704l2_mdl_error_dm(struct FsmInst *fi, int event, void *arg)
705{
706 struct sk_buff *skb = arg;
707 struct layer2 *l2 = fi->userdata;
708
709 if (get_PollFlagFree(l2, skb))
710 l2mgr(l2, MDL_ERROR_IND, (void *) 'B');
711 else {
712 l2mgr(l2, MDL_ERROR_IND, (void *) 'E');
713 establishlink(fi);
714 test_and_clear_bit(FLG_L3_INIT, &l2->flag);
715 }
716}
717
718static void
719l2_st8_mdl_error_dm(struct FsmInst *fi, int event, void *arg)
720{
721 struct sk_buff *skb = arg;
722 struct layer2 *l2 = fi->userdata;
723
724 if (get_PollFlagFree(l2, skb))
725 l2mgr(l2, MDL_ERROR_IND, (void *) 'B');
726 else
727 l2mgr(l2, MDL_ERROR_IND, (void *) 'E');
728 establishlink(fi);
729 test_and_clear_bit(FLG_L3_INIT, &l2->flag);
730}
731
732static void
733l2_go_st3(struct FsmInst *fi, int event, void *arg)
734{
735 dev_kfree_skb((struct sk_buff *)arg);
736 mISDN_FsmChangeState(fi, ST_L2_3);
737}
738
739static void
740l2_mdl_assign(struct FsmInst *fi, int event, void *arg)
741{
742 struct layer2 *l2 = fi->userdata;
743
744 mISDN_FsmChangeState(fi, ST_L2_3);
745 dev_kfree_skb((struct sk_buff *)arg);
746 l2_tei(l2, MDL_ASSIGN_IND, 0);
747}
748
749static void
750l2_queue_ui_assign(struct FsmInst *fi, int event, void *arg)
751{
752 struct layer2 *l2 = fi->userdata;
753 struct sk_buff *skb = arg;
754
755 skb_queue_tail(&l2->ui_queue, skb);
756 mISDN_FsmChangeState(fi, ST_L2_2);
757 l2_tei(l2, MDL_ASSIGN_IND, 0);
758}
759
760static void
761l2_queue_ui(struct FsmInst *fi, int event, void *arg)
762{
763 struct layer2 *l2 = fi->userdata;
764 struct sk_buff *skb = arg;
765
766 skb_queue_tail(&l2->ui_queue, skb);
767}
768
769static void
770tx_ui(struct layer2 *l2)
771{
772 struct sk_buff *skb;
773 u_char header[MAX_L2HEADER_LEN];
774 int i;
775
776 i = sethdraddr(l2, header, CMD);
777 if (test_bit(FLG_LAPD_NET, &l2->flag))
778 header[1] = 0xff;
779 header[i++] = UI;
780 while ((skb = skb_dequeue(&l2->ui_queue))) {
781 memcpy(skb_push(skb, i), header, i);
782 enqueue_ui(l2, skb);
783 }
784}
785
786static void
787l2_send_ui(struct FsmInst *fi, int event, void *arg)
788{
789 struct layer2 *l2 = fi->userdata;
790 struct sk_buff *skb = arg;
791
792 skb_queue_tail(&l2->ui_queue, skb);
793 tx_ui(l2);
794}
795
796static void
797l2_got_ui(struct FsmInst *fi, int event, void *arg)
798{
799 struct layer2 *l2 = fi->userdata;
800 struct sk_buff *skb = arg;
801
802 skb_pull(skb, l2headersize(l2, 1));
803
804
805
806
807 if (l2->tm)
808 l2_tei(l2, MDL_STATUS_UI_IND, 0);
809 l2up(l2, DL_UNITDATA_IND, skb);
810}
811
812static void
813l2_establish(struct FsmInst *fi, int event, void *arg)
814{
815 struct sk_buff *skb = arg;
816 struct layer2 *l2 = fi->userdata;
817
818 establishlink(fi);
819 test_and_set_bit(FLG_L3_INIT, &l2->flag);
820 dev_kfree_skb(skb);
821}
822
823static void
824l2_discard_i_setl3(struct FsmInst *fi, int event, void *arg)
825{
826 struct sk_buff *skb = arg;
827 struct layer2 *l2 = fi->userdata;
828
829 skb_queue_purge(&l2->i_queue);
830 test_and_set_bit(FLG_L3_INIT, &l2->flag);
831 test_and_clear_bit(FLG_PEND_REL, &l2->flag);
832 dev_kfree_skb(skb);
833}
834
835static void
836l2_l3_reestablish(struct FsmInst *fi, int event, void *arg)
837{
838 struct sk_buff *skb = arg;
839 struct layer2 *l2 = fi->userdata;
840
841 skb_queue_purge(&l2->i_queue);
842 establishlink(fi);
843 test_and_set_bit(FLG_L3_INIT, &l2->flag);
844 dev_kfree_skb(skb);
845}
846
847static void
848l2_release(struct FsmInst *fi, int event, void *arg)
849{
850 struct layer2 *l2 = fi->userdata;
851 struct sk_buff *skb = arg;
852
853 skb_trim(skb, 0);
854 l2up(l2, DL_RELEASE_CNF, skb);
855}
856
857static void
858l2_pend_rel(struct FsmInst *fi, int event, void *arg)
859{
860 struct sk_buff *skb = arg;
861 struct layer2 *l2 = fi->userdata;
862
863 test_and_set_bit(FLG_PEND_REL, &l2->flag);
864 dev_kfree_skb(skb);
865}
866
867static void
868l2_disconnect(struct FsmInst *fi, int event, void *arg)
869{
870 struct layer2 *l2 = fi->userdata;
871 struct sk_buff *skb = arg;
872
873 skb_queue_purge(&l2->i_queue);
874 freewin(l2);
875 mISDN_FsmChangeState(fi, ST_L2_6);
876 l2->rc = 0;
877 send_uframe(l2, NULL, DISC | 0x10, CMD);
878 mISDN_FsmDelTimer(&l2->t203, 1);
879 restart_t200(l2, 2);
880 if (skb)
881 dev_kfree_skb(skb);
882}
883
884static void
885l2_start_multi(struct FsmInst *fi, int event, void *arg)
886{
887 struct layer2 *l2 = fi->userdata;
888 struct sk_buff *skb = arg;
889
890 l2->vs = 0;
891 l2->va = 0;
892 l2->vr = 0;
893 l2->sow = 0;
894 clear_exception(l2);
895 send_uframe(l2, NULL, UA | get_PollFlag(l2, skb), RSP);
896 mISDN_FsmChangeState(fi, ST_L2_7);
897 mISDN_FsmAddTimer(&l2->t203, l2->T203, EV_L2_T203, NULL, 3);
898 skb_trim(skb, 0);
899 l2up(l2, DL_ESTABLISH_IND, skb);
900 if (l2->tm)
901 l2_tei(l2, MDL_STATUS_UP_IND, 0);
902}
903
904static void
905l2_send_UA(struct FsmInst *fi, int event, void *arg)
906{
907 struct layer2 *l2 = fi->userdata;
908 struct sk_buff *skb = arg;
909
910 send_uframe(l2, skb, UA | get_PollFlag(l2, skb), RSP);
911}
912
913static void
914l2_send_DM(struct FsmInst *fi, int event, void *arg)
915{
916 struct layer2 *l2 = fi->userdata;
917 struct sk_buff *skb = arg;
918
919 send_uframe(l2, skb, DM | get_PollFlag(l2, skb), RSP);
920}
921
922static void
923l2_restart_multi(struct FsmInst *fi, int event, void *arg)
924{
925 struct layer2 *l2 = fi->userdata;
926 struct sk_buff *skb = arg;
927 int est = 0;
928
929 send_uframe(l2, skb, UA | get_PollFlag(l2, skb), RSP);
930
931 l2mgr(l2, MDL_ERROR_IND, (void *) 'F');
932
933 if (l2->vs != l2->va) {
934 skb_queue_purge(&l2->i_queue);
935 est = 1;
936 }
937
938 clear_exception(l2);
939 l2->vs = 0;
940 l2->va = 0;
941 l2->vr = 0;
942 l2->sow = 0;
943 mISDN_FsmChangeState(fi, ST_L2_7);
944 stop_t200(l2, 3);
945 mISDN_FsmRestartTimer(&l2->t203, l2->T203, EV_L2_T203, NULL, 3);
946
947 if (est)
948 l2up_create(l2, DL_ESTABLISH_IND, 0, NULL);
949
950
951
952
953 if (skb_queue_len(&l2->i_queue) && cansend(l2))
954 mISDN_FsmEvent(fi, EV_L2_ACK_PULL, NULL);
955}
956
957static void
958l2_stop_multi(struct FsmInst *fi, int event, void *arg)
959{
960 struct layer2 *l2 = fi->userdata;
961 struct sk_buff *skb = arg;
962
963 mISDN_FsmChangeState(fi, ST_L2_4);
964 mISDN_FsmDelTimer(&l2->t203, 3);
965 stop_t200(l2, 4);
966
967 send_uframe(l2, skb, UA | get_PollFlag(l2, skb), RSP);
968 skb_queue_purge(&l2->i_queue);
969 freewin(l2);
970 lapb_dl_release_l2l3(l2, DL_RELEASE_IND);
971 if (l2->tm)
972 l2_tei(l2, MDL_STATUS_DOWN_IND, 0);
973}
974
975static void
976l2_connected(struct FsmInst *fi, int event, void *arg)
977{
978 struct layer2 *l2 = fi->userdata;
979 struct sk_buff *skb = arg;
980 int pr = -1;
981
982 if (!get_PollFlag(l2, skb)) {
983 l2_mdl_error_ua(fi, event, arg);
984 return;
985 }
986 dev_kfree_skb(skb);
987 if (test_and_clear_bit(FLG_PEND_REL, &l2->flag))
988 l2_disconnect(fi, event, NULL);
989 if (test_and_clear_bit(FLG_L3_INIT, &l2->flag)) {
990 pr = DL_ESTABLISH_CNF;
991 } else if (l2->vs != l2->va) {
992 skb_queue_purge(&l2->i_queue);
993 pr = DL_ESTABLISH_IND;
994 }
995 stop_t200(l2, 5);
996 l2->vr = 0;
997 l2->vs = 0;
998 l2->va = 0;
999 l2->sow = 0;
1000 mISDN_FsmChangeState(fi, ST_L2_7);
1001 mISDN_FsmAddTimer(&l2->t203, l2->T203, EV_L2_T203, NULL, 4);
1002 if (pr != -1)
1003 l2up_create(l2, pr, 0, NULL);
1004
1005 if (skb_queue_len(&l2->i_queue) && cansend(l2))
1006 mISDN_FsmEvent(fi, EV_L2_ACK_PULL, NULL);
1007
1008 if (l2->tm)
1009 l2_tei(l2, MDL_STATUS_UP_IND, 0);
1010}
1011
1012static void
1013l2_released(struct FsmInst *fi, int event, void *arg)
1014{
1015 struct layer2 *l2 = fi->userdata;
1016 struct sk_buff *skb = arg;
1017
1018 if (!get_PollFlag(l2, skb)) {
1019 l2_mdl_error_ua(fi, event, arg);
1020 return;
1021 }
1022 dev_kfree_skb(skb);
1023 stop_t200(l2, 6);
1024 lapb_dl_release_l2l3(l2, DL_RELEASE_CNF);
1025 mISDN_FsmChangeState(fi, ST_L2_4);
1026 if (l2->tm)
1027 l2_tei(l2, MDL_STATUS_DOWN_IND, 0);
1028}
1029
1030static void
1031l2_reestablish(struct FsmInst *fi, int event, void *arg)
1032{
1033 struct layer2 *l2 = fi->userdata;
1034 struct sk_buff *skb = arg;
1035
1036 if (!get_PollFlagFree(l2, skb)) {
1037 establishlink(fi);
1038 test_and_set_bit(FLG_L3_INIT, &l2->flag);
1039 }
1040}
1041
1042static void
1043l2_st5_dm_release(struct FsmInst *fi, int event, void *arg)
1044{
1045 struct layer2 *l2 = fi->userdata;
1046 struct sk_buff *skb = arg;
1047
1048 if (get_PollFlagFree(l2, skb)) {
1049 stop_t200(l2, 7);
1050 if (!test_bit(FLG_L3_INIT, &l2->flag))
1051 skb_queue_purge(&l2->i_queue);
1052 if (test_bit(FLG_LAPB, &l2->flag))
1053 l2down_create(l2, PH_DEACTIVATE_REQ,
1054 l2_newid(l2), 0, NULL);
1055 st5_dl_release_l2l3(l2);
1056 mISDN_FsmChangeState(fi, ST_L2_4);
1057 if (l2->tm)
1058 l2_tei(l2, MDL_STATUS_DOWN_IND, 0);
1059 }
1060}
1061
1062static void
1063l2_st6_dm_release(struct FsmInst *fi, int event, void *arg)
1064{
1065 struct layer2 *l2 = fi->userdata;
1066 struct sk_buff *skb = arg;
1067
1068 if (get_PollFlagFree(l2, skb)) {
1069 stop_t200(l2, 8);
1070 lapb_dl_release_l2l3(l2, DL_RELEASE_CNF);
1071 mISDN_FsmChangeState(fi, ST_L2_4);
1072 if (l2->tm)
1073 l2_tei(l2, MDL_STATUS_DOWN_IND, 0);
1074 }
1075}
1076
1077static void
1078enquiry_cr(struct layer2 *l2, u_char typ, u_char cr, u_char pf)
1079{
1080 struct sk_buff *skb;
1081 u_char tmp[MAX_L2HEADER_LEN];
1082 int i;
1083
1084 i = sethdraddr(l2, tmp, cr);
1085 if (test_bit(FLG_MOD128, &l2->flag)) {
1086 tmp[i++] = typ;
1087 tmp[i++] = (l2->vr << 1) | (pf ? 1 : 0);
1088 } else
1089 tmp[i++] = (l2->vr << 5) | typ | (pf ? 0x10 : 0);
1090 skb = mI_alloc_skb(i, GFP_ATOMIC);
1091 if (!skb) {
1092 printk(KERN_WARNING
1093 "isdnl2 can't alloc sbbuff for enquiry_cr\n");
1094 return;
1095 }
1096 memcpy(skb_put(skb, i), tmp, i);
1097 enqueue_super(l2, skb);
1098}
1099
1100inline void
1101enquiry_response(struct layer2 *l2)
1102{
1103 if (test_bit(FLG_OWN_BUSY, &l2->flag))
1104 enquiry_cr(l2, RNR, RSP, 1);
1105 else
1106 enquiry_cr(l2, RR, RSP, 1);
1107 test_and_clear_bit(FLG_ACK_PEND, &l2->flag);
1108}
1109
1110inline void
1111transmit_enquiry(struct layer2 *l2)
1112{
1113 if (test_bit(FLG_OWN_BUSY, &l2->flag))
1114 enquiry_cr(l2, RNR, CMD, 1);
1115 else
1116 enquiry_cr(l2, RR, CMD, 1);
1117 test_and_clear_bit(FLG_ACK_PEND, &l2->flag);
1118 start_t200(l2, 9);
1119}
1120
1121
1122static void
1123nrerrorrecovery(struct FsmInst *fi)
1124{
1125 struct layer2 *l2 = fi->userdata;
1126
1127 l2mgr(l2, MDL_ERROR_IND, (void *) 'J');
1128 establishlink(fi);
1129 test_and_clear_bit(FLG_L3_INIT, &l2->flag);
1130}
1131
1132static void
1133invoke_retransmission(struct layer2 *l2, unsigned int nr)
1134{
1135 u_int p1;
1136
1137 if (l2->vs != nr) {
1138 while (l2->vs != nr) {
1139 (l2->vs)--;
1140 if (test_bit(FLG_MOD128, &l2->flag)) {
1141 l2->vs %= 128;
1142 p1 = (l2->vs - l2->va) % 128;
1143 } else {
1144 l2->vs %= 8;
1145 p1 = (l2->vs - l2->va) % 8;
1146 }
1147 p1 = (p1 + l2->sow) % l2->window;
1148 if (l2->windowar[p1])
1149 skb_queue_head(&l2->i_queue, l2->windowar[p1]);
1150 else
1151 printk(KERN_WARNING
1152 "%s: windowar[%d] is NULL\n",
1153 __func__, p1);
1154 l2->windowar[p1] = NULL;
1155 }
1156 mISDN_FsmEvent(&l2->l2m, EV_L2_ACK_PULL, NULL);
1157 }
1158}
1159
1160static void
1161l2_st7_got_super(struct FsmInst *fi, int event, void *arg)
1162{
1163 struct layer2 *l2 = fi->userdata;
1164 struct sk_buff *skb = arg;
1165 int PollFlag, rsp, typ = RR;
1166 unsigned int nr;
1167
1168 rsp = *skb->data & 0x2;
1169 if (test_bit(FLG_ORIG, &l2->flag))
1170 rsp = !rsp;
1171
1172 skb_pull(skb, l2addrsize(l2));
1173 if (IsRNR(skb->data, l2)) {
1174 set_peer_busy(l2);
1175 typ = RNR;
1176 } else
1177 clear_peer_busy(l2);
1178 if (IsREJ(skb->data, l2))
1179 typ = REJ;
1180
1181 if (test_bit(FLG_MOD128, &l2->flag)) {
1182 PollFlag = (skb->data[1] & 0x1) == 0x1;
1183 nr = skb->data[1] >> 1;
1184 } else {
1185 PollFlag = (skb->data[0] & 0x10);
1186 nr = (skb->data[0] >> 5) & 0x7;
1187 }
1188 dev_kfree_skb(skb);
1189
1190 if (PollFlag) {
1191 if (rsp)
1192 l2mgr(l2, MDL_ERROR_IND, (void *) 'A');
1193 else
1194 enquiry_response(l2);
1195 }
1196 if (legalnr(l2, nr)) {
1197 if (typ == REJ) {
1198 setva(l2, nr);
1199 invoke_retransmission(l2, nr);
1200 stop_t200(l2, 10);
1201 if (mISDN_FsmAddTimer(&l2->t203, l2->T203,
1202 EV_L2_T203, NULL, 6))
1203 l2m_debug(&l2->l2m, "Restart T203 ST7 REJ");
1204 } else if ((nr == l2->vs) && (typ == RR)) {
1205 setva(l2, nr);
1206 stop_t200(l2, 11);
1207 mISDN_FsmRestartTimer(&l2->t203, l2->T203,
1208 EV_L2_T203, NULL, 7);
1209 } else if ((l2->va != nr) || (typ == RNR)) {
1210 setva(l2, nr);
1211 if (typ != RR)
1212 mISDN_FsmDelTimer(&l2->t203, 9);
1213 restart_t200(l2, 12);
1214 }
1215 if (skb_queue_len(&l2->i_queue) && (typ == RR))
1216 mISDN_FsmEvent(fi, EV_L2_ACK_PULL, NULL);
1217 } else
1218 nrerrorrecovery(fi);
1219}
1220
1221static void
1222l2_feed_i_if_reest(struct FsmInst *fi, int event, void *arg)
1223{
1224 struct layer2 *l2 = fi->userdata;
1225 struct sk_buff *skb = arg;
1226
1227 if (!test_bit(FLG_L3_INIT, &l2->flag))
1228 skb_queue_tail(&l2->i_queue, skb);
1229 else
1230 dev_kfree_skb(skb);
1231}
1232
1233static void
1234l2_feed_i_pull(struct FsmInst *fi, int event, void *arg)
1235{
1236 struct layer2 *l2 = fi->userdata;
1237 struct sk_buff *skb = arg;
1238
1239 skb_queue_tail(&l2->i_queue, skb);
1240 mISDN_FsmEvent(fi, EV_L2_ACK_PULL, NULL);
1241}
1242
1243static void
1244l2_feed_iqueue(struct FsmInst *fi, int event, void *arg)
1245{
1246 struct layer2 *l2 = fi->userdata;
1247 struct sk_buff *skb = arg;
1248
1249 skb_queue_tail(&l2->i_queue, skb);
1250}
1251
1252static void
1253l2_got_iframe(struct FsmInst *fi, int event, void *arg)
1254{
1255 struct layer2 *l2 = fi->userdata;
1256 struct sk_buff *skb = arg;
1257 int PollFlag, i;
1258 u_int ns, nr;
1259
1260 i = l2addrsize(l2);
1261 if (test_bit(FLG_MOD128, &l2->flag)) {
1262 PollFlag = ((skb->data[i + 1] & 0x1) == 0x1);
1263 ns = skb->data[i] >> 1;
1264 nr = (skb->data[i + 1] >> 1) & 0x7f;
1265 } else {
1266 PollFlag = (skb->data[i] & 0x10);
1267 ns = (skb->data[i] >> 1) & 0x7;
1268 nr = (skb->data[i] >> 5) & 0x7;
1269 }
1270 if (test_bit(FLG_OWN_BUSY, &l2->flag)) {
1271 dev_kfree_skb(skb);
1272 if (PollFlag)
1273 enquiry_response(l2);
1274 } else {
1275 if (l2->vr == ns) {
1276 l2->vr++;
1277 if (test_bit(FLG_MOD128, &l2->flag))
1278 l2->vr %= 128;
1279 else
1280 l2->vr %= 8;
1281 test_and_clear_bit(FLG_REJEXC, &l2->flag);
1282 if (PollFlag)
1283 enquiry_response(l2);
1284 else
1285 test_and_set_bit(FLG_ACK_PEND, &l2->flag);
1286 skb_pull(skb, l2headersize(l2, 0));
1287 l2up(l2, DL_DATA_IND, skb);
1288 } else {
1289
1290 dev_kfree_skb(skb);
1291 if (test_and_set_bit(FLG_REJEXC, &l2->flag)) {
1292 if (PollFlag)
1293 enquiry_response(l2);
1294 } else {
1295 enquiry_cr(l2, REJ, RSP, PollFlag);
1296 test_and_clear_bit(FLG_ACK_PEND, &l2->flag);
1297 }
1298 }
1299 }
1300 if (legalnr(l2, nr)) {
1301 if (!test_bit(FLG_PEER_BUSY, &l2->flag) &&
1302 (fi->state == ST_L2_7)) {
1303 if (nr == l2->vs) {
1304 stop_t200(l2, 13);
1305 mISDN_FsmRestartTimer(&l2->t203, l2->T203,
1306 EV_L2_T203, NULL, 7);
1307 } else if (nr != l2->va)
1308 restart_t200(l2, 14);
1309 }
1310 setva(l2, nr);
1311 } else {
1312 nrerrorrecovery(fi);
1313 return;
1314 }
1315 if (skb_queue_len(&l2->i_queue) && (fi->state == ST_L2_7))
1316 mISDN_FsmEvent(fi, EV_L2_ACK_PULL, NULL);
1317 if (test_and_clear_bit(FLG_ACK_PEND, &l2->flag))
1318 enquiry_cr(l2, RR, RSP, 0);
1319}
1320
1321static void
1322l2_got_tei(struct FsmInst *fi, int event, void *arg)
1323{
1324 struct layer2 *l2 = fi->userdata;
1325 u_int info;
1326
1327 l2->tei = (signed char)(long)arg;
1328 set_channel_address(&l2->ch, l2->sapi, l2->tei);
1329 info = DL_INFO_L2_CONNECT;
1330 l2up_create(l2, DL_INFORMATION_IND, sizeof(info), &info);
1331 if (fi->state == ST_L2_3) {
1332 establishlink(fi);
1333 test_and_set_bit(FLG_L3_INIT, &l2->flag);
1334 } else
1335 mISDN_FsmChangeState(fi, ST_L2_4);
1336 if (skb_queue_len(&l2->ui_queue))
1337 tx_ui(l2);
1338}
1339
1340static void
1341l2_st5_tout_200(struct FsmInst *fi, int event, void *arg)
1342{
1343 struct layer2 *l2 = fi->userdata;
1344
1345 if (test_bit(FLG_LAPD, &l2->flag) &&
1346 test_bit(FLG_DCHAN_BUSY, &l2->flag)) {
1347 mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, 9);
1348 } else if (l2->rc == l2->N200) {
1349 mISDN_FsmChangeState(fi, ST_L2_4);
1350 test_and_clear_bit(FLG_T200_RUN, &l2->flag);
1351 skb_queue_purge(&l2->i_queue);
1352 l2mgr(l2, MDL_ERROR_IND, (void *) 'G');
1353 if (test_bit(FLG_LAPB, &l2->flag))
1354 l2down_create(l2, PH_DEACTIVATE_REQ,
1355 l2_newid(l2), 0, NULL);
1356 st5_dl_release_l2l3(l2);
1357 if (l2->tm)
1358 l2_tei(l2, MDL_STATUS_DOWN_IND, 0);
1359 } else {
1360 l2->rc++;
1361 mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, 9);
1362 send_uframe(l2, NULL, (test_bit(FLG_MOD128, &l2->flag) ?
1363 SABME : SABM) | 0x10, CMD);
1364 }
1365}
1366
1367static void
1368l2_st6_tout_200(struct FsmInst *fi, int event, void *arg)
1369{
1370 struct layer2 *l2 = fi->userdata;
1371
1372 if (test_bit(FLG_LAPD, &l2->flag) &&
1373 test_bit(FLG_DCHAN_BUSY, &l2->flag)) {
1374 mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, 9);
1375 } else if (l2->rc == l2->N200) {
1376 mISDN_FsmChangeState(fi, ST_L2_4);
1377 test_and_clear_bit(FLG_T200_RUN, &l2->flag);
1378 l2mgr(l2, MDL_ERROR_IND, (void *) 'H');
1379 lapb_dl_release_l2l3(l2, DL_RELEASE_CNF);
1380 if (l2->tm)
1381 l2_tei(l2, MDL_STATUS_DOWN_IND, 0);
1382 } else {
1383 l2->rc++;
1384 mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200,
1385 NULL, 9);
1386 send_uframe(l2, NULL, DISC | 0x10, CMD);
1387 }
1388}
1389
1390static void
1391l2_st7_tout_200(struct FsmInst *fi, int event, void *arg)
1392{
1393 struct layer2 *l2 = fi->userdata;
1394
1395 if (test_bit(FLG_LAPD, &l2->flag) &&
1396 test_bit(FLG_DCHAN_BUSY, &l2->flag)) {
1397 mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, 9);
1398 return;
1399 }
1400 test_and_clear_bit(FLG_T200_RUN, &l2->flag);
1401 l2->rc = 0;
1402 mISDN_FsmChangeState(fi, ST_L2_8);
1403 transmit_enquiry(l2);
1404 l2->rc++;
1405}
1406
1407static void
1408l2_st8_tout_200(struct FsmInst *fi, int event, void *arg)
1409{
1410 struct layer2 *l2 = fi->userdata;
1411
1412 if (test_bit(FLG_LAPD, &l2->flag) &&
1413 test_bit(FLG_DCHAN_BUSY, &l2->flag)) {
1414 mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, 9);
1415 return;
1416 }
1417 test_and_clear_bit(FLG_T200_RUN, &l2->flag);
1418 if (l2->rc == l2->N200) {
1419 l2mgr(l2, MDL_ERROR_IND, (void *) 'I');
1420 establishlink(fi);
1421 test_and_clear_bit(FLG_L3_INIT, &l2->flag);
1422 } else {
1423 transmit_enquiry(l2);
1424 l2->rc++;
1425 }
1426}
1427
1428static void
1429l2_st7_tout_203(struct FsmInst *fi, int event, void *arg)
1430{
1431 struct layer2 *l2 = fi->userdata;
1432
1433 if (test_bit(FLG_LAPD, &l2->flag) &&
1434 test_bit(FLG_DCHAN_BUSY, &l2->flag)) {
1435 mISDN_FsmAddTimer(&l2->t203, l2->T203, EV_L2_T203, NULL, 9);
1436 return;
1437 }
1438 mISDN_FsmChangeState(fi, ST_L2_8);
1439 transmit_enquiry(l2);
1440 l2->rc = 0;
1441}
1442
1443static void
1444l2_pull_iqueue(struct FsmInst *fi, int event, void *arg)
1445{
1446 struct layer2 *l2 = fi->userdata;
1447 struct sk_buff *skb, *nskb, *oskb;
1448 u_char header[MAX_L2HEADER_LEN];
1449 u_int i, p1;
1450
1451 if (!cansend(l2))
1452 return;
1453
1454 skb = skb_dequeue(&l2->i_queue);
1455 if (!skb)
1456 return;
1457
1458 if (test_bit(FLG_MOD128, &l2->flag))
1459 p1 = (l2->vs - l2->va) % 128;
1460 else
1461 p1 = (l2->vs - l2->va) % 8;
1462 p1 = (p1 + l2->sow) % l2->window;
1463 if (l2->windowar[p1]) {
1464 printk(KERN_WARNING "isdnl2 try overwrite ack queue entry %d\n",
1465 p1);
1466 dev_kfree_skb(l2->windowar[p1]);
1467 }
1468 l2->windowar[p1] = skb;
1469 i = sethdraddr(l2, header, CMD);
1470 if (test_bit(FLG_MOD128, &l2->flag)) {
1471 header[i++] = l2->vs << 1;
1472 header[i++] = l2->vr << 1;
1473 l2->vs = (l2->vs + 1) % 128;
1474 } else {
1475 header[i++] = (l2->vr << 5) | (l2->vs << 1);
1476 l2->vs = (l2->vs + 1) % 8;
1477 }
1478
1479 nskb = skb_clone(skb, GFP_ATOMIC);
1480 p1 = skb_headroom(nskb);
1481 if (p1 >= i)
1482 memcpy(skb_push(nskb, i), header, i);
1483 else {
1484 printk(KERN_WARNING
1485 "isdnl2 pull_iqueue skb header(%d/%d) too short\n", i, p1);
1486 oskb = nskb;
1487 nskb = mI_alloc_skb(oskb->len + i, GFP_ATOMIC);
1488 if (!nskb) {
1489 dev_kfree_skb(oskb);
1490 printk(KERN_WARNING "%s: no skb mem\n", __func__);
1491 return;
1492 }
1493 memcpy(skb_put(nskb, i), header, i);
1494 memcpy(skb_put(nskb, oskb->len), oskb->data, oskb->len);
1495 dev_kfree_skb(oskb);
1496 }
1497 l2down(l2, PH_DATA_REQ, l2_newid(l2), nskb);
1498 test_and_clear_bit(FLG_ACK_PEND, &l2->flag);
1499 if (!test_and_set_bit(FLG_T200_RUN, &l2->flag)) {
1500 mISDN_FsmDelTimer(&l2->t203, 13);
1501 mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, 11);
1502 }
1503}
1504
1505static void
1506l2_st8_got_super(struct FsmInst *fi, int event, void *arg)
1507{
1508 struct layer2 *l2 = fi->userdata;
1509 struct sk_buff *skb = arg;
1510 int PollFlag, rsp, rnr = 0;
1511 unsigned int nr;
1512
1513 rsp = *skb->data & 0x2;
1514 if (test_bit(FLG_ORIG, &l2->flag))
1515 rsp = !rsp;
1516
1517 skb_pull(skb, l2addrsize(l2));
1518
1519 if (IsRNR(skb->data, l2)) {
1520 set_peer_busy(l2);
1521 rnr = 1;
1522 } else
1523 clear_peer_busy(l2);
1524
1525 if (test_bit(FLG_MOD128, &l2->flag)) {
1526 PollFlag = (skb->data[1] & 0x1) == 0x1;
1527 nr = skb->data[1] >> 1;
1528 } else {
1529 PollFlag = (skb->data[0] & 0x10);
1530 nr = (skb->data[0] >> 5) & 0x7;
1531 }
1532 dev_kfree_skb(skb);
1533 if (rsp && PollFlag) {
1534 if (legalnr(l2, nr)) {
1535 if (rnr) {
1536 restart_t200(l2, 15);
1537 } else {
1538 stop_t200(l2, 16);
1539 mISDN_FsmAddTimer(&l2->t203, l2->T203,
1540 EV_L2_T203, NULL, 5);
1541 setva(l2, nr);
1542 }
1543 invoke_retransmission(l2, nr);
1544 mISDN_FsmChangeState(fi, ST_L2_7);
1545 if (skb_queue_len(&l2->i_queue) && cansend(l2))
1546 mISDN_FsmEvent(fi, EV_L2_ACK_PULL, NULL);
1547 } else
1548 nrerrorrecovery(fi);
1549 } else {
1550 if (!rsp && PollFlag)
1551 enquiry_response(l2);
1552 if (legalnr(l2, nr))
1553 setva(l2, nr);
1554 else
1555 nrerrorrecovery(fi);
1556 }
1557}
1558
1559static void
1560l2_got_FRMR(struct FsmInst *fi, int event, void *arg)
1561{
1562 struct layer2 *l2 = fi->userdata;
1563 struct sk_buff *skb = arg;
1564
1565 skb_pull(skb, l2addrsize(l2) + 1);
1566
1567 if (!(skb->data[0] & 1) || ((skb->data[0] & 3) == 1) ||
1568 (IsUA(skb->data) && (fi->state == ST_L2_7))) {
1569 l2mgr(l2, MDL_ERROR_IND, (void *) 'K');
1570 establishlink(fi);
1571 test_and_clear_bit(FLG_L3_INIT, &l2->flag);
1572 }
1573 dev_kfree_skb(skb);
1574}
1575
1576static void
1577l2_st24_tei_remove(struct FsmInst *fi, int event, void *arg)
1578{
1579 struct layer2 *l2 = fi->userdata;
1580
1581 skb_queue_purge(&l2->ui_queue);
1582 l2->tei = GROUP_TEI;
1583 mISDN_FsmChangeState(fi, ST_L2_1);
1584}
1585
1586static void
1587l2_st3_tei_remove(struct FsmInst *fi, int event, void *arg)
1588{
1589 struct layer2 *l2 = fi->userdata;
1590
1591 skb_queue_purge(&l2->ui_queue);
1592 l2->tei = GROUP_TEI;
1593 l2up_create(l2, DL_RELEASE_IND, 0, NULL);
1594 mISDN_FsmChangeState(fi, ST_L2_1);
1595}
1596
1597static void
1598l2_st5_tei_remove(struct FsmInst *fi, int event, void *arg)
1599{
1600 struct layer2 *l2 = fi->userdata;
1601
1602 skb_queue_purge(&l2->i_queue);
1603 skb_queue_purge(&l2->ui_queue);
1604 freewin(l2);
1605 l2->tei = GROUP_TEI;
1606 stop_t200(l2, 17);
1607 st5_dl_release_l2l3(l2);
1608 mISDN_FsmChangeState(fi, ST_L2_1);
1609}
1610
1611static void
1612l2_st6_tei_remove(struct FsmInst *fi, int event, void *arg)
1613{
1614 struct layer2 *l2 = fi->userdata;
1615
1616 skb_queue_purge(&l2->ui_queue);
1617 l2->tei = GROUP_TEI;
1618 stop_t200(l2, 18);
1619 l2up_create(l2, DL_RELEASE_IND, 0, NULL);
1620 mISDN_FsmChangeState(fi, ST_L2_1);
1621}
1622
1623static void
1624l2_tei_remove(struct FsmInst *fi, int event, void *arg)
1625{
1626 struct layer2 *l2 = fi->userdata;
1627
1628 skb_queue_purge(&l2->i_queue);
1629 skb_queue_purge(&l2->ui_queue);
1630 freewin(l2);
1631 l2->tei = GROUP_TEI;
1632 stop_t200(l2, 17);
1633 mISDN_FsmDelTimer(&l2->t203, 19);
1634 l2up_create(l2, DL_RELEASE_IND, 0, NULL);
1635
1636
1637
1638
1639 mISDN_FsmChangeState(fi, ST_L2_1);
1640}
1641
1642static void
1643l2_st14_persistant_da(struct FsmInst *fi, int event, void *arg)
1644{
1645 struct layer2 *l2 = fi->userdata;
1646 struct sk_buff *skb = arg;
1647
1648 skb_queue_purge(&l2->i_queue);
1649 skb_queue_purge(&l2->ui_queue);
1650 if (test_and_clear_bit(FLG_ESTAB_PEND, &l2->flag))
1651 l2up(l2, DL_RELEASE_IND, skb);
1652 else
1653 dev_kfree_skb(skb);
1654}
1655
1656static void
1657l2_st5_persistant_da(struct FsmInst *fi, int event, void *arg)
1658{
1659 struct layer2 *l2 = fi->userdata;
1660 struct sk_buff *skb = arg;
1661
1662 skb_queue_purge(&l2->i_queue);
1663 skb_queue_purge(&l2->ui_queue);
1664 freewin(l2);
1665 stop_t200(l2, 19);
1666 st5_dl_release_l2l3(l2);
1667 mISDN_FsmChangeState(fi, ST_L2_4);
1668 if (l2->tm)
1669 l2_tei(l2, MDL_STATUS_DOWN_IND, 0);
1670 dev_kfree_skb(skb);
1671}
1672
1673static void
1674l2_st6_persistant_da(struct FsmInst *fi, int event, void *arg)
1675{
1676 struct layer2 *l2 = fi->userdata;
1677 struct sk_buff *skb = arg;
1678
1679 skb_queue_purge(&l2->ui_queue);
1680 stop_t200(l2, 20);
1681 l2up(l2, DL_RELEASE_CNF, skb);
1682 mISDN_FsmChangeState(fi, ST_L2_4);
1683 if (l2->tm)
1684 l2_tei(l2, MDL_STATUS_DOWN_IND, 0);
1685}
1686
1687static void
1688l2_persistant_da(struct FsmInst *fi, int event, void *arg)
1689{
1690 struct layer2 *l2 = fi->userdata;
1691 struct sk_buff *skb = arg;
1692
1693 skb_queue_purge(&l2->i_queue);
1694 skb_queue_purge(&l2->ui_queue);
1695 freewin(l2);
1696 stop_t200(l2, 19);
1697 mISDN_FsmDelTimer(&l2->t203, 19);
1698 l2up(l2, DL_RELEASE_IND, skb);
1699 mISDN_FsmChangeState(fi, ST_L2_4);
1700 if (l2->tm)
1701 l2_tei(l2, MDL_STATUS_DOWN_IND, 0);
1702}
1703
1704static void
1705l2_set_own_busy(struct FsmInst *fi, int event, void *arg)
1706{
1707 struct layer2 *l2 = fi->userdata;
1708 struct sk_buff *skb = arg;
1709
1710 if (!test_and_set_bit(FLG_OWN_BUSY, &l2->flag)) {
1711 enquiry_cr(l2, RNR, RSP, 0);
1712 test_and_clear_bit(FLG_ACK_PEND, &l2->flag);
1713 }
1714 if (skb)
1715 dev_kfree_skb(skb);
1716}
1717
1718static void
1719l2_clear_own_busy(struct FsmInst *fi, int event, void *arg)
1720{
1721 struct layer2 *l2 = fi->userdata;
1722 struct sk_buff *skb = arg;
1723
1724 if (!test_and_clear_bit(FLG_OWN_BUSY, &l2->flag)) {
1725 enquiry_cr(l2, RR, RSP, 0);
1726 test_and_clear_bit(FLG_ACK_PEND, &l2->flag);
1727 }
1728 if (skb)
1729 dev_kfree_skb(skb);
1730}
1731
1732static void
1733l2_frame_error(struct FsmInst *fi, int event, void *arg)
1734{
1735 struct layer2 *l2 = fi->userdata;
1736
1737 l2mgr(l2, MDL_ERROR_IND, arg);
1738}
1739
1740static void
1741l2_frame_error_reest(struct FsmInst *fi, int event, void *arg)
1742{
1743 struct layer2 *l2 = fi->userdata;
1744
1745 l2mgr(l2, MDL_ERROR_IND, arg);
1746 establishlink(fi);
1747 test_and_clear_bit(FLG_L3_INIT, &l2->flag);
1748}
1749
1750static struct FsmNode L2FnList[] =
1751{
1752 {ST_L2_1, EV_L2_DL_ESTABLISH_REQ, l2_mdl_assign},
1753 {ST_L2_2, EV_L2_DL_ESTABLISH_REQ, l2_go_st3},
1754 {ST_L2_4, EV_L2_DL_ESTABLISH_REQ, l2_establish},
1755 {ST_L2_5, EV_L2_DL_ESTABLISH_REQ, l2_discard_i_setl3},
1756 {ST_L2_7, EV_L2_DL_ESTABLISH_REQ, l2_l3_reestablish},
1757 {ST_L2_8, EV_L2_DL_ESTABLISH_REQ, l2_l3_reestablish},
1758 {ST_L2_4, EV_L2_DL_RELEASE_REQ, l2_release},
1759 {ST_L2_5, EV_L2_DL_RELEASE_REQ, l2_pend_rel},
1760 {ST_L2_7, EV_L2_DL_RELEASE_REQ, l2_disconnect},
1761 {ST_L2_8, EV_L2_DL_RELEASE_REQ, l2_disconnect},
1762 {ST_L2_5, EV_L2_DL_DATA, l2_feed_i_if_reest},
1763 {ST_L2_7, EV_L2_DL_DATA, l2_feed_i_pull},
1764 {ST_L2_8, EV_L2_DL_DATA, l2_feed_iqueue},
1765 {ST_L2_1, EV_L2_DL_UNITDATA, l2_queue_ui_assign},
1766 {ST_L2_2, EV_L2_DL_UNITDATA, l2_queue_ui},
1767 {ST_L2_3, EV_L2_DL_UNITDATA, l2_queue_ui},
1768 {ST_L2_4, EV_L2_DL_UNITDATA, l2_send_ui},
1769 {ST_L2_5, EV_L2_DL_UNITDATA, l2_send_ui},
1770 {ST_L2_6, EV_L2_DL_UNITDATA, l2_send_ui},
1771 {ST_L2_7, EV_L2_DL_UNITDATA, l2_send_ui},
1772 {ST_L2_8, EV_L2_DL_UNITDATA, l2_send_ui},
1773 {ST_L2_1, EV_L2_MDL_ASSIGN, l2_got_tei},
1774 {ST_L2_2, EV_L2_MDL_ASSIGN, l2_got_tei},
1775 {ST_L2_3, EV_L2_MDL_ASSIGN, l2_got_tei},
1776 {ST_L2_2, EV_L2_MDL_ERROR, l2_st24_tei_remove},
1777 {ST_L2_3, EV_L2_MDL_ERROR, l2_st3_tei_remove},
1778 {ST_L2_4, EV_L2_MDL_REMOVE, l2_st24_tei_remove},
1779 {ST_L2_5, EV_L2_MDL_REMOVE, l2_st5_tei_remove},
1780 {ST_L2_6, EV_L2_MDL_REMOVE, l2_st6_tei_remove},
1781 {ST_L2_7, EV_L2_MDL_REMOVE, l2_tei_remove},
1782 {ST_L2_8, EV_L2_MDL_REMOVE, l2_tei_remove},
1783 {ST_L2_4, EV_L2_SABME, l2_start_multi},
1784 {ST_L2_5, EV_L2_SABME, l2_send_UA},
1785 {ST_L2_6, EV_L2_SABME, l2_send_DM},
1786 {ST_L2_7, EV_L2_SABME, l2_restart_multi},
1787 {ST_L2_8, EV_L2_SABME, l2_restart_multi},
1788 {ST_L2_4, EV_L2_DISC, l2_send_DM},
1789 {ST_L2_5, EV_L2_DISC, l2_send_DM},
1790 {ST_L2_6, EV_L2_DISC, l2_send_UA},
1791 {ST_L2_7, EV_L2_DISC, l2_stop_multi},
1792 {ST_L2_8, EV_L2_DISC, l2_stop_multi},
1793 {ST_L2_4, EV_L2_UA, l2_mdl_error_ua},
1794 {ST_L2_5, EV_L2_UA, l2_connected},
1795 {ST_L2_6, EV_L2_UA, l2_released},
1796 {ST_L2_7, EV_L2_UA, l2_mdl_error_ua},
1797 {ST_L2_8, EV_L2_UA, l2_mdl_error_ua},
1798 {ST_L2_4, EV_L2_DM, l2_reestablish},
1799 {ST_L2_5, EV_L2_DM, l2_st5_dm_release},
1800 {ST_L2_6, EV_L2_DM, l2_st6_dm_release},
1801 {ST_L2_7, EV_L2_DM, l2_mdl_error_dm},
1802 {ST_L2_8, EV_L2_DM, l2_st8_mdl_error_dm},
1803 {ST_L2_1, EV_L2_UI, l2_got_ui},
1804 {ST_L2_2, EV_L2_UI, l2_got_ui},
1805 {ST_L2_3, EV_L2_UI, l2_got_ui},
1806 {ST_L2_4, EV_L2_UI, l2_got_ui},
1807 {ST_L2_5, EV_L2_UI, l2_got_ui},
1808 {ST_L2_6, EV_L2_UI, l2_got_ui},
1809 {ST_L2_7, EV_L2_UI, l2_got_ui},
1810 {ST_L2_8, EV_L2_UI, l2_got_ui},
1811 {ST_L2_7, EV_L2_FRMR, l2_got_FRMR},
1812 {ST_L2_8, EV_L2_FRMR, l2_got_FRMR},
1813 {ST_L2_7, EV_L2_SUPER, l2_st7_got_super},
1814 {ST_L2_8, EV_L2_SUPER, l2_st8_got_super},
1815 {ST_L2_7, EV_L2_I, l2_got_iframe},
1816 {ST_L2_8, EV_L2_I, l2_got_iframe},
1817 {ST_L2_5, EV_L2_T200, l2_st5_tout_200},
1818 {ST_L2_6, EV_L2_T200, l2_st6_tout_200},
1819 {ST_L2_7, EV_L2_T200, l2_st7_tout_200},
1820 {ST_L2_8, EV_L2_T200, l2_st8_tout_200},
1821 {ST_L2_7, EV_L2_T203, l2_st7_tout_203},
1822 {ST_L2_7, EV_L2_ACK_PULL, l2_pull_iqueue},
1823 {ST_L2_7, EV_L2_SET_OWN_BUSY, l2_set_own_busy},
1824 {ST_L2_8, EV_L2_SET_OWN_BUSY, l2_set_own_busy},
1825 {ST_L2_7, EV_L2_CLEAR_OWN_BUSY, l2_clear_own_busy},
1826 {ST_L2_8, EV_L2_CLEAR_OWN_BUSY, l2_clear_own_busy},
1827 {ST_L2_4, EV_L2_FRAME_ERROR, l2_frame_error},
1828 {ST_L2_5, EV_L2_FRAME_ERROR, l2_frame_error},
1829 {ST_L2_6, EV_L2_FRAME_ERROR, l2_frame_error},
1830 {ST_L2_7, EV_L2_FRAME_ERROR, l2_frame_error_reest},
1831 {ST_L2_8, EV_L2_FRAME_ERROR, l2_frame_error_reest},
1832 {ST_L2_1, EV_L1_DEACTIVATE, l2_st14_persistant_da},
1833 {ST_L2_2, EV_L1_DEACTIVATE, l2_st24_tei_remove},
1834 {ST_L2_3, EV_L1_DEACTIVATE, l2_st3_tei_remove},
1835 {ST_L2_4, EV_L1_DEACTIVATE, l2_st14_persistant_da},
1836 {ST_L2_5, EV_L1_DEACTIVATE, l2_st5_persistant_da},
1837 {ST_L2_6, EV_L1_DEACTIVATE, l2_st6_persistant_da},
1838 {ST_L2_7, EV_L1_DEACTIVATE, l2_persistant_da},
1839 {ST_L2_8, EV_L1_DEACTIVATE, l2_persistant_da},
1840};
1841
1842static int
1843ph_data_indication(struct layer2 *l2, struct mISDNhead *hh, struct sk_buff *skb)
1844{
1845 u_char *datap = skb->data;
1846 int ret = -EINVAL;
1847 int psapi, ptei;
1848 u_int l;
1849 int c = 0;
1850
1851 l = l2addrsize(l2);
1852 if (skb->len <= l) {
1853 mISDN_FsmEvent(&l2->l2m, EV_L2_FRAME_ERROR, (void *) 'N');
1854 return ret;
1855 }
1856 if (test_bit(FLG_LAPD, &l2->flag)) {
1857 psapi = *datap++;
1858 ptei = *datap++;
1859 if ((psapi & 1) || !(ptei & 1)) {
1860 printk(KERN_WARNING
1861 "l2 D-channel frame wrong EA0/EA1\n");
1862 return ret;
1863 }
1864 psapi >>= 2;
1865 ptei >>= 1;
1866 if (psapi != l2->sapi) {
1867
1868 if (*debug & DEBUG_L2)
1869 printk(KERN_DEBUG "%s: sapi %d/%d mismatch\n",
1870 __func__, psapi, l2->sapi);
1871 dev_kfree_skb(skb);
1872 return 0;
1873 }
1874 if ((ptei != l2->tei) && (ptei != GROUP_TEI)) {
1875
1876 if (*debug & DEBUG_L2)
1877 printk(KERN_DEBUG "%s: tei %d/%d mismatch\n",
1878 __func__, ptei, l2->tei);
1879 dev_kfree_skb(skb);
1880 return 0;
1881 }
1882 } else
1883 datap += l;
1884 if (!(*datap & 1)) {
1885 c = iframe_error(l2, skb);
1886 if (!c)
1887 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_I, skb);
1888 } else if (IsSFrame(datap, l2)) {
1889 c = super_error(l2, skb);
1890 if (!c)
1891 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_SUPER, skb);
1892 } else if (IsUI(datap)) {
1893 c = UI_error(l2, skb);
1894 if (!c)
1895 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_UI, skb);
1896 } else if (IsSABME(datap, l2)) {
1897 c = unnum_error(l2, skb, CMD);
1898 if (!c)
1899 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_SABME, skb);
1900 } else if (IsUA(datap)) {
1901 c = unnum_error(l2, skb, RSP);
1902 if (!c)
1903 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_UA, skb);
1904 } else if (IsDISC(datap)) {
1905 c = unnum_error(l2, skb, CMD);
1906 if (!c)
1907 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_DISC, skb);
1908 } else if (IsDM(datap)) {
1909 c = unnum_error(l2, skb, RSP);
1910 if (!c)
1911 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_DM, skb);
1912 } else if (IsFRMR(datap)) {
1913 c = FRMR_error(l2, skb);
1914 if (!c)
1915 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_FRMR, skb);
1916 } else
1917 c = 'L';
1918 if (c) {
1919 printk(KERN_WARNING "l2 D-channel frame error %c\n", c);
1920 mISDN_FsmEvent(&l2->l2m, EV_L2_FRAME_ERROR, (void *)(long)c);
1921 }
1922 return ret;
1923}
1924
1925static int
1926l2_send(struct mISDNchannel *ch, struct sk_buff *skb)
1927{
1928 struct layer2 *l2 = container_of(ch, struct layer2, ch);
1929 struct mISDNhead *hh = mISDN_HEAD_P(skb);
1930 int ret = -EINVAL;
1931
1932 if (*debug & DEBUG_L2_RECV)
1933 printk(KERN_DEBUG "%s: prim(%x) id(%x) sapi(%d) tei(%d)\n",
1934 __func__, hh->prim, hh->id, l2->sapi, l2->tei);
1935 switch (hh->prim) {
1936 case PH_DATA_IND:
1937 ret = ph_data_indication(l2, hh, skb);
1938 break;
1939 case PH_DATA_CNF:
1940 ret = ph_data_confirm(l2, hh, skb);
1941 break;
1942 case PH_ACTIVATE_IND:
1943 test_and_set_bit(FLG_L1_ACTIV, &l2->flag);
1944 l2up_create(l2, MPH_ACTIVATE_IND, 0, NULL);
1945 if (test_and_clear_bit(FLG_ESTAB_PEND, &l2->flag))
1946 ret = mISDN_FsmEvent(&l2->l2m,
1947 EV_L2_DL_ESTABLISH_REQ, skb);
1948 break;
1949 case PH_DEACTIVATE_IND:
1950 test_and_clear_bit(FLG_L1_ACTIV, &l2->flag);
1951 l2up_create(l2, MPH_DEACTIVATE_IND, 0, NULL);
1952 ret = mISDN_FsmEvent(&l2->l2m, EV_L1_DEACTIVATE, skb);
1953 break;
1954 case MPH_INFORMATION_IND:
1955 if (!l2->up)
1956 break;
1957 ret = l2->up->send(l2->up, skb);
1958 break;
1959 case DL_DATA_REQ:
1960 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_DL_DATA, skb);
1961 break;
1962 case DL_UNITDATA_REQ:
1963 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_DL_UNITDATA, skb);
1964 break;
1965 case DL_ESTABLISH_REQ:
1966 if (test_bit(FLG_LAPB, &l2->flag))
1967 test_and_set_bit(FLG_ORIG, &l2->flag);
1968 if (test_bit(FLG_L1_ACTIV, &l2->flag)) {
1969 if (test_bit(FLG_LAPD, &l2->flag) ||
1970 test_bit(FLG_ORIG, &l2->flag))
1971 ret = mISDN_FsmEvent(&l2->l2m,
1972 EV_L2_DL_ESTABLISH_REQ, skb);
1973 } else {
1974 if (test_bit(FLG_LAPD, &l2->flag) ||
1975 test_bit(FLG_ORIG, &l2->flag)) {
1976 test_and_set_bit(FLG_ESTAB_PEND,
1977 &l2->flag);
1978 }
1979 ret = l2down(l2, PH_ACTIVATE_REQ, l2_newid(l2),
1980 skb);
1981 }
1982 break;
1983 case DL_RELEASE_REQ:
1984 if (test_bit(FLG_LAPB, &l2->flag))
1985 l2down_create(l2, PH_DEACTIVATE_REQ,
1986 l2_newid(l2), 0, NULL);
1987 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_DL_RELEASE_REQ,
1988 skb);
1989 break;
1990 default:
1991 if (*debug & DEBUG_L2)
1992 l2m_debug(&l2->l2m, "l2 unknown pr %04x",
1993 hh->prim);
1994 }
1995 if (ret) {
1996 dev_kfree_skb(skb);
1997 ret = 0;
1998 }
1999 return ret;
2000}
2001
2002int
2003tei_l2(struct layer2 *l2, u_int cmd, u_long arg)
2004{
2005 int ret = -EINVAL;
2006
2007 if (*debug & DEBUG_L2_TEI)
2008 printk(KERN_DEBUG "%s: cmd(%x)\n", __func__, cmd);
2009 switch (cmd) {
2010 case (MDL_ASSIGN_REQ):
2011 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_MDL_ASSIGN, (void *)arg);
2012 break;
2013 case (MDL_REMOVE_REQ):
2014 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_MDL_REMOVE, NULL);
2015 break;
2016 case (MDL_ERROR_IND):
2017 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_MDL_ERROR, NULL);
2018 break;
2019 case (MDL_ERROR_RSP):
2020
2021 printk(KERN_NOTICE "MDL_ERROR|REQ (tei_l2)\n");
2022 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_MDL_ERROR, NULL);
2023 break;
2024 }
2025 return ret;
2026}
2027
2028static void
2029release_l2(struct layer2 *l2)
2030{
2031 mISDN_FsmDelTimer(&l2->t200, 21);
2032 mISDN_FsmDelTimer(&l2->t203, 16);
2033 skb_queue_purge(&l2->i_queue);
2034 skb_queue_purge(&l2->ui_queue);
2035 skb_queue_purge(&l2->down_queue);
2036 ReleaseWin(l2);
2037 if (test_bit(FLG_LAPD, &l2->flag)) {
2038 TEIrelease(l2);
2039 if (l2->ch.st)
2040 l2->ch.st->dev->D.ctrl(&l2->ch.st->dev->D,
2041 CLOSE_CHANNEL, NULL);
2042 }
2043 kfree(l2);
2044}
2045
2046static int
2047l2_ctrl(struct mISDNchannel *ch, u_int cmd, void *arg)
2048{
2049 struct layer2 *l2 = container_of(ch, struct layer2, ch);
2050 u_int info;
2051
2052 if (*debug & DEBUG_L2_CTRL)
2053 printk(KERN_DEBUG "%s:(%x)\n", __func__, cmd);
2054
2055 switch (cmd) {
2056 case OPEN_CHANNEL:
2057 if (test_bit(FLG_LAPD, &l2->flag)) {
2058 set_channel_address(&l2->ch, l2->sapi, l2->tei);
2059 info = DL_INFO_L2_CONNECT;
2060 l2up_create(l2, DL_INFORMATION_IND,
2061 sizeof(info), &info);
2062 }
2063 break;
2064 case CLOSE_CHANNEL:
2065 if (l2->ch.peer)
2066 l2->ch.peer->ctrl(l2->ch.peer, CLOSE_CHANNEL, NULL);
2067 release_l2(l2);
2068 break;
2069 }
2070 return 0;
2071}
2072
2073struct layer2 *
2074create_l2(struct mISDNchannel *ch, u_int protocol, u_long options, int tei,
2075 int sapi)
2076{
2077 struct layer2 *l2;
2078 struct channel_req rq;
2079
2080 l2 = kzalloc(sizeof(struct layer2), GFP_KERNEL);
2081 if (!l2) {
2082 printk(KERN_ERR "kzalloc layer2 failed\n");
2083 return NULL;
2084 }
2085 l2->next_id = 1;
2086 l2->down_id = MISDN_ID_NONE;
2087 l2->up = ch;
2088 l2->ch.st = ch->st;
2089 l2->ch.send = l2_send;
2090 l2->ch.ctrl = l2_ctrl;
2091 switch (protocol) {
2092 case ISDN_P_LAPD_NT:
2093 test_and_set_bit(FLG_LAPD, &l2->flag);
2094 test_and_set_bit(FLG_LAPD_NET, &l2->flag);
2095 test_and_set_bit(FLG_MOD128, &l2->flag);
2096 l2->sapi = sapi;
2097 l2->maxlen = MAX_DFRAME_LEN;
2098 if (test_bit(OPTION_L2_PMX, &options))
2099 l2->window = 7;
2100 else
2101 l2->window = 1;
2102 if (test_bit(OPTION_L2_PTP, &options))
2103 test_and_set_bit(FLG_PTP, &l2->flag);
2104 if (test_bit(OPTION_L2_FIXEDTEI, &options))
2105 test_and_set_bit(FLG_FIXED_TEI, &l2->flag);
2106 l2->tei = tei;
2107 l2->T200 = 1000;
2108 l2->N200 = 3;
2109 l2->T203 = 10000;
2110 if (test_bit(OPTION_L2_PMX, &options))
2111 rq.protocol = ISDN_P_NT_E1;
2112 else
2113 rq.protocol = ISDN_P_NT_S0;
2114 rq.adr.channel = 0;
2115 l2->ch.st->dev->D.ctrl(&l2->ch.st->dev->D, OPEN_CHANNEL, &rq);
2116 break;
2117 case ISDN_P_LAPD_TE:
2118 test_and_set_bit(FLG_LAPD, &l2->flag);
2119 test_and_set_bit(FLG_MOD128, &l2->flag);
2120 test_and_set_bit(FLG_ORIG, &l2->flag);
2121 l2->sapi = sapi;
2122 l2->maxlen = MAX_DFRAME_LEN;
2123 if (test_bit(OPTION_L2_PMX, &options))
2124 l2->window = 7;
2125 else
2126 l2->window = 1;
2127 if (test_bit(OPTION_L2_PTP, &options))
2128 test_and_set_bit(FLG_PTP, &l2->flag);
2129 if (test_bit(OPTION_L2_FIXEDTEI, &options))
2130 test_and_set_bit(FLG_FIXED_TEI, &l2->flag);
2131 l2->tei = tei;
2132 l2->T200 = 1000;
2133 l2->N200 = 3;
2134 l2->T203 = 10000;
2135 if (test_bit(OPTION_L2_PMX, &options))
2136 rq.protocol = ISDN_P_TE_E1;
2137 else
2138 rq.protocol = ISDN_P_TE_S0;
2139 rq.adr.channel = 0;
2140 l2->ch.st->dev->D.ctrl(&l2->ch.st->dev->D, OPEN_CHANNEL, &rq);
2141 break;
2142 case ISDN_P_B_X75SLP:
2143 test_and_set_bit(FLG_LAPB, &l2->flag);
2144 l2->window = 7;
2145 l2->maxlen = MAX_DATA_SIZE;
2146 l2->T200 = 1000;
2147 l2->N200 = 4;
2148 l2->T203 = 5000;
2149 l2->addr.A = 3;
2150 l2->addr.B = 1;
2151 break;
2152 default:
2153 printk(KERN_ERR "layer2 create failed prt %x\n",
2154 protocol);
2155 kfree(l2);
2156 return NULL;
2157 }
2158 skb_queue_head_init(&l2->i_queue);
2159 skb_queue_head_init(&l2->ui_queue);
2160 skb_queue_head_init(&l2->down_queue);
2161 skb_queue_head_init(&l2->tmp_queue);
2162 InitWin(l2);
2163 l2->l2m.fsm = &l2fsm;
2164 if (test_bit(FLG_LAPB, &l2->flag) ||
2165 test_bit(FLG_PTP, &l2->flag) ||
2166 test_bit(FLG_LAPD_NET, &l2->flag))
2167 l2->l2m.state = ST_L2_4;
2168 else
2169 l2->l2m.state = ST_L2_1;
2170 l2->l2m.debug = *debug;
2171 l2->l2m.userdata = l2;
2172 l2->l2m.userint = 0;
2173 l2->l2m.printdebug = l2m_debug;
2174
2175 mISDN_FsmInitTimer(&l2->l2m, &l2->t200);
2176 mISDN_FsmInitTimer(&l2->l2m, &l2->t203);
2177 return l2;
2178}
2179
2180static int
2181x75create(struct channel_req *crq)
2182{
2183 struct layer2 *l2;
2184
2185 if (crq->protocol != ISDN_P_B_X75SLP)
2186 return -EPROTONOSUPPORT;
2187 l2 = create_l2(crq->ch, crq->protocol, 0, 0, 0);
2188 if (!l2)
2189 return -ENOMEM;
2190 crq->ch = &l2->ch;
2191 crq->protocol = ISDN_P_B_HDLC;
2192 return 0;
2193}
2194
2195static struct Bprotocol X75SLP = {
2196 .Bprotocols = (1 << (ISDN_P_B_X75SLP & ISDN_P_B_MASK)),
2197 .name = "X75SLP",
2198 .create = x75create
2199};
2200
2201int
2202Isdnl2_Init(u_int *deb)
2203{
2204 debug = deb;
2205 mISDN_register_Bprotocol(&X75SLP);
2206 l2fsm.state_count = L2_STATE_COUNT;
2207 l2fsm.event_count = L2_EVENT_COUNT;
2208 l2fsm.strEvent = strL2Event;
2209 l2fsm.strState = strL2State;
2210 mISDN_FsmNew(&l2fsm, L2FnList, ARRAY_SIZE(L2FnList));
2211 TEIInit(deb);
2212 return 0;
2213}
2214
2215void
2216Isdnl2_cleanup(void)
2217{
2218 mISDN_unregister_Bprotocol(&X75SLP);
2219 TEIFree();
2220 mISDN_FsmFree(&l2fsm);
2221}
2222
2223
