Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
layer2.c
Go to the documentation of this file.
1 /*
2  *
3  * Author Karsten Keil <[email protected]>
4  *
5  * Copyright 2008 by Karsten Keil <[email protected]>
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 }
Generated on Thu Jan 10 2013 13:42:33 for Linux Kernel by   doxygen 1.8.2