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