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