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