blob: cfff0c41d2986da7c3baf404b5e3a63b922127b1 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* $Id: isdnl2.c,v 2.30.2.4 2004/02/11 13:21:34 keil Exp $
2 *
3 * Author Karsten Keil
4 * based on the teles driver from Jan den Ouden
5 * Copyright by Karsten Keil <keil@isdn4linux.de>
6 *
7 * This software may be used and distributed according to the terms
8 * of the GNU General Public License, incorporated herein by reference.
9 *
10 * For changes and modifications please read
11 * Documentation/isdn/HiSax.cert
12 *
13 * Thanks to Jan den Ouden
14 * Fritz Elfert
15 *
16 */
17
18#include <linux/init.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090019#include <linux/gfp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include "hisax.h"
21#include "isdnl2.h"
22
23const char *l2_revision = "$Revision: 2.30.2.4 $";
24
25static void l2m_debug(struct FsmInst *fi, char *fmt, ...);
26
27static struct Fsm l2fsm;
28
29enum {
30 ST_L2_1,
31 ST_L2_2,
32 ST_L2_3,
33 ST_L2_4,
34 ST_L2_5,
35 ST_L2_6,
36 ST_L2_7,
37 ST_L2_8,
38};
39
40#define L2_STATE_COUNT (ST_L2_8+1)
41
42static char *strL2State[] =
43{
44 "ST_L2_1",
45 "ST_L2_2",
46 "ST_L2_3",
47 "ST_L2_4",
48 "ST_L2_5",
49 "ST_L2_6",
50 "ST_L2_7",
51 "ST_L2_8",
52};
53
54enum {
55 EV_L2_UI,
56 EV_L2_SABME,
57 EV_L2_DISC,
58 EV_L2_DM,
59 EV_L2_UA,
60 EV_L2_FRMR,
61 EV_L2_SUPER,
62 EV_L2_I,
63 EV_L2_DL_DATA,
64 EV_L2_ACK_PULL,
65 EV_L2_DL_UNIT_DATA,
66 EV_L2_DL_ESTABLISH_REQ,
67 EV_L2_DL_RELEASE_REQ,
68 EV_L2_MDL_ASSIGN,
69 EV_L2_MDL_REMOVE,
70 EV_L2_MDL_ERROR,
71 EV_L1_DEACTIVATE,
72 EV_L2_T200,
73 EV_L2_T203,
74 EV_L2_SET_OWN_BUSY,
75 EV_L2_CLEAR_OWN_BUSY,
76 EV_L2_FRAME_ERROR,
77};
78
79#define L2_EVENT_COUNT (EV_L2_FRAME_ERROR+1)
80
81static char *strL2Event[] =
82{
83 "EV_L2_UI",
84 "EV_L2_SABME",
85 "EV_L2_DISC",
86 "EV_L2_DM",
87 "EV_L2_UA",
88 "EV_L2_FRMR",
89 "EV_L2_SUPER",
90 "EV_L2_I",
91 "EV_L2_DL_DATA",
92 "EV_L2_ACK_PULL",
93 "EV_L2_DL_UNIT_DATA",
94 "EV_L2_DL_ESTABLISH_REQ",
95 "EV_L2_DL_RELEASE_REQ",
96 "EV_L2_MDL_ASSIGN",
97 "EV_L2_MDL_REMOVE",
98 "EV_L2_MDL_ERROR",
99 "EV_L1_DEACTIVATE",
100 "EV_L2_T200",
101 "EV_L2_T203",
102 "EV_L2_SET_OWN_BUSY",
103 "EV_L2_CLEAR_OWN_BUSY",
104 "EV_L2_FRAME_ERROR",
105};
106
107static int l2addrsize(struct Layer2 *l2);
108
109static void
110set_peer_busy(struct Layer2 *l2) {
111 test_and_set_bit(FLG_PEER_BUSY, &l2->flag);
David S. Millerb03efcf2005-07-08 14:57:23 -0700112 if (!skb_queue_empty(&l2->i_queue) ||
113 !skb_queue_empty(&l2->ui_queue))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 test_and_set_bit(FLG_L2BLOCK, &l2->flag);
115}
116
117static void
118clear_peer_busy(struct Layer2 *l2) {
119 if (test_and_clear_bit(FLG_PEER_BUSY, &l2->flag))
120 test_and_clear_bit(FLG_L2BLOCK, &l2->flag);
121}
122
123static void
124InitWin(struct Layer2 *l2)
125{
126 int i;
127
128 for (i = 0; i < MAX_WINDOW; i++)
129 l2->windowar[i] = NULL;
130}
131
132static int
133freewin1(struct Layer2 *l2)
134{
135 int i, cnt = 0;
136
137 for (i = 0; i < MAX_WINDOW; i++) {
138 if (l2->windowar[i]) {
139 cnt++;
140 dev_kfree_skb(l2->windowar[i]);
141 l2->windowar[i] = NULL;
142 }
143 }
144 return cnt;
145}
146
Adrian Bunk672c3fd2005-06-25 14:59:18 -0700147static inline void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148freewin(struct PStack *st)
149{
150 freewin1(&st->l2);
151}
152
153static void
154ReleaseWin(struct Layer2 *l2)
155{
156 int cnt;
157
158 if((cnt = freewin1(l2)))
159 printk(KERN_WARNING "isdl2 freed %d skbuffs in release\n", cnt);
160}
161
Adrian Bunk672c3fd2005-06-25 14:59:18 -0700162static inline unsigned int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163cansend(struct PStack *st)
164{
165 unsigned int p1;
166
167 if(test_bit(FLG_MOD128, &st->l2.flag))
168 p1 = (st->l2.vs - st->l2.va) % 128;
169 else
170 p1 = (st->l2.vs - st->l2.va) % 8;
171 return ((p1 < st->l2.window) && !test_bit(FLG_PEER_BUSY, &st->l2.flag));
172}
173
Adrian Bunk672c3fd2005-06-25 14:59:18 -0700174static inline void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175clear_exception(struct Layer2 *l2)
176{
177 test_and_clear_bit(FLG_ACK_PEND, &l2->flag);
178 test_and_clear_bit(FLG_REJEXC, &l2->flag);
179 test_and_clear_bit(FLG_OWN_BUSY, &l2->flag);
180 clear_peer_busy(l2);
181}
182
Adrian Bunk672c3fd2005-06-25 14:59:18 -0700183static inline int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184l2headersize(struct Layer2 *l2, int ui)
185{
186 return (((test_bit(FLG_MOD128, &l2->flag) && (!ui)) ? 2 : 1) +
187 (test_bit(FLG_LAPD, &l2->flag) ? 2 : 1));
188}
189
190inline int
191l2addrsize(struct Layer2 *l2)
192{
193 return (test_bit(FLG_LAPD, &l2->flag) ? 2 : 1);
194}
195
196static int
197sethdraddr(struct Layer2 *l2, u_char * header, int rsp)
198{
199 u_char *ptr = header;
200 int crbit = rsp;
201
202 if (test_bit(FLG_LAPD, &l2->flag)) {
203 *ptr++ = (l2->sap << 2) | (rsp ? 2 : 0);
204 *ptr++ = (l2->tei << 1) | 1;
205 return (2);
206 } else {
207 if (test_bit(FLG_ORIG, &l2->flag))
208 crbit = !crbit;
209 if (crbit)
210 *ptr++ = 1;
211 else
212 *ptr++ = 3;
213 return (1);
214 }
215}
216
Jesper Juhl77933d72005-07-27 11:46:09 -0700217static inline void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218enqueue_super(struct PStack *st,
219 struct sk_buff *skb)
220{
221 if (test_bit(FLG_LAPB, &st->l2.flag))
222 st->l1.bcs->tx_cnt += skb->len;
223 st->l2.l2l1(st, PH_DATA | REQUEST, skb);
224}
225
226#define enqueue_ui(a, b) enqueue_super(a, b)
227
Adrian Bunk672c3fd2005-06-25 14:59:18 -0700228static inline int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229IsUI(u_char * data)
230{
231 return ((data[0] & 0xef) == UI);
232}
233
Adrian Bunk672c3fd2005-06-25 14:59:18 -0700234static inline int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235IsUA(u_char * data)
236{
237 return ((data[0] & 0xef) == UA);
238}
239
Adrian Bunk672c3fd2005-06-25 14:59:18 -0700240static inline int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241IsDM(u_char * data)
242{
243 return ((data[0] & 0xef) == DM);
244}
245
Adrian Bunk672c3fd2005-06-25 14:59:18 -0700246static inline int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247IsDISC(u_char * data)
248{
249 return ((data[0] & 0xef) == DISC);
250}
251
Adrian Bunk672c3fd2005-06-25 14:59:18 -0700252static inline int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253IsSFrame(u_char * data, struct PStack *st)
254{
255 register u_char d = *data;
256
257 if (!test_bit(FLG_MOD128, &st->l2.flag))
258 d &= 0xf;
259 return(((d & 0xf3) == 1) && ((d & 0x0c) != 0x0c));
260}
261
Adrian Bunk672c3fd2005-06-25 14:59:18 -0700262static inline int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263IsSABME(u_char * data, struct PStack *st)
264{
265 u_char d = data[0] & ~0x10;
266
267 return (test_bit(FLG_MOD128, &st->l2.flag) ? d == SABME : d == SABM);
268}
269
Adrian Bunk672c3fd2005-06-25 14:59:18 -0700270static inline int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271IsREJ(u_char * data, struct PStack *st)
272{
273 return (test_bit(FLG_MOD128, &st->l2.flag) ? data[0] == REJ : (data[0] & 0xf) == REJ);
274}
275
Adrian Bunk672c3fd2005-06-25 14:59:18 -0700276static inline int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277IsFRMR(u_char * data)
278{
279 return ((data[0] & 0xef) == FRMR);
280}
281
Adrian Bunk672c3fd2005-06-25 14:59:18 -0700282static inline int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283IsRNR(u_char * data, struct PStack *st)
284{
285 return (test_bit(FLG_MOD128, &st->l2.flag) ? data[0] == RNR : (data[0] & 0xf) == RNR);
286}
287
Adrian Bunk672c3fd2005-06-25 14:59:18 -0700288static int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289iframe_error(struct PStack *st, struct sk_buff *skb)
290{
291 int i = l2addrsize(&st->l2) + (test_bit(FLG_MOD128, &st->l2.flag) ? 2 : 1);
292 int rsp = *skb->data & 0x2;
293
294 if (test_bit(FLG_ORIG, &st->l2.flag))
295 rsp = !rsp;
296
297 if (rsp)
298 return 'L';
299
300
301 if (skb->len < i)
302 return 'N';
303
304 if ((skb->len - i) > st->l2.maxlen)
305 return 'O';
306
307
308 return 0;
309}
310
Adrian Bunk672c3fd2005-06-25 14:59:18 -0700311static int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312super_error(struct PStack *st, struct sk_buff *skb)
313{
314 if (skb->len != l2addrsize(&st->l2) +
315 (test_bit(FLG_MOD128, &st->l2.flag) ? 2 : 1))
316 return 'N';
317
318 return 0;
319}
320
Adrian Bunk672c3fd2005-06-25 14:59:18 -0700321static int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322unnum_error(struct PStack *st, struct sk_buff *skb, int wantrsp)
323{
324 int rsp = (*skb->data & 0x2) >> 1;
325 if (test_bit(FLG_ORIG, &st->l2.flag))
326 rsp = !rsp;
327
328 if (rsp != wantrsp)
329 return 'L';
330
331 if (skb->len != l2addrsize(&st->l2) + 1)
332 return 'N';
333
334 return 0;
335}
336
Adrian Bunk672c3fd2005-06-25 14:59:18 -0700337static int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338UI_error(struct PStack *st, struct sk_buff *skb)
339{
340 int rsp = *skb->data & 0x2;
341 if (test_bit(FLG_ORIG, &st->l2.flag))
342 rsp = !rsp;
343
344 if (rsp)
345 return 'L';
346
347 if (skb->len > st->l2.maxlen + l2addrsize(&st->l2) + 1)
348 return 'O';
349
350 return 0;
351}
352
Adrian Bunk672c3fd2005-06-25 14:59:18 -0700353static int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354FRMR_error(struct PStack *st, struct sk_buff *skb)
355{
356 int headers = l2addrsize(&st->l2) + 1;
357 u_char *datap = skb->data + headers;
358 int rsp = *skb->data & 0x2;
359
360 if (test_bit(FLG_ORIG, &st->l2.flag))
361 rsp = !rsp;
362
363 if (!rsp)
364 return 'L';
365
366 if (test_bit(FLG_MOD128, &st->l2.flag)) {
367 if (skb->len < headers + 5)
368 return 'N';
369 else
370 l2m_debug(&st->l2.l2m, "FRMR information %2x %2x %2x %2x %2x",
371 datap[0], datap[1], datap[2],
372 datap[3], datap[4]);
373 } else {
374 if (skb->len < headers + 3)
375 return 'N';
376 else
377 l2m_debug(&st->l2.l2m, "FRMR information %2x %2x %2x",
378 datap[0], datap[1], datap[2]);
379 }
380
381 return 0;
382}
383
384static unsigned int
385legalnr(struct PStack *st, unsigned int nr)
386{
387 struct Layer2 *l2 = &st->l2;
388
389 if(test_bit(FLG_MOD128, &l2->flag))
390 return ((nr - l2->va) % 128) <= ((l2->vs - l2->va) % 128);
391 else
392 return ((nr - l2->va) % 8) <= ((l2->vs - l2->va) % 8);
393}
394
395static void
396setva(struct PStack *st, unsigned int nr)
397{
398 struct Layer2 *l2 = &st->l2;
399 int len;
400 u_long flags;
401
402 spin_lock_irqsave(&l2->lock, flags);
403 while (l2->va != nr) {
404 (l2->va)++;
405 if(test_bit(FLG_MOD128, &l2->flag))
406 l2->va %= 128;
407 else
408 l2->va %= 8;
409 len = l2->windowar[l2->sow]->len;
410 if (PACKET_NOACK == l2->windowar[l2->sow]->pkt_type)
411 len = -1;
412 dev_kfree_skb(l2->windowar[l2->sow]);
413 l2->windowar[l2->sow] = NULL;
414 l2->sow = (l2->sow + 1) % l2->window;
415 spin_unlock_irqrestore(&l2->lock, flags);
416 if (test_bit(FLG_LLI_L2WAKEUP, &st->lli.flag) && (len >=0))
417 lli_writewakeup(st, len);
418 spin_lock_irqsave(&l2->lock, flags);
419 }
420 spin_unlock_irqrestore(&l2->lock, flags);
421}
422
423static void
424send_uframe(struct PStack *st, u_char cmd, u_char cr)
425{
426 struct sk_buff *skb;
427 u_char tmp[MAX_HEADER_LEN];
428 int i;
429
430 i = sethdraddr(&st->l2, tmp, cr);
431 tmp[i++] = cmd;
432 if (!(skb = alloc_skb(i, GFP_ATOMIC))) {
433 printk(KERN_WARNING "isdl2 can't alloc sbbuff for send_uframe\n");
434 return;
435 }
436 memcpy(skb_put(skb, i), tmp, i);
437 enqueue_super(st, skb);
438}
439
Adrian Bunk672c3fd2005-06-25 14:59:18 -0700440static inline u_char
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441get_PollFlag(struct PStack * st, struct sk_buff * skb)
442{
443 return (skb->data[l2addrsize(&(st->l2))] & 0x10);
444}
445
Adrian Bunk672c3fd2005-06-25 14:59:18 -0700446static inline u_char
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447get_PollFlagFree(struct PStack *st, struct sk_buff *skb)
448{
449 u_char PF;
450
451 PF = get_PollFlag(st, skb);
Adrian Bunk672c3fd2005-06-25 14:59:18 -0700452 dev_kfree_skb(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 return (PF);
454}
455
Adrian Bunk672c3fd2005-06-25 14:59:18 -0700456static inline void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457start_t200(struct PStack *st, int i)
458{
459 FsmAddTimer(&st->l2.t200, st->l2.T200, EV_L2_T200, NULL, i);
460 test_and_set_bit(FLG_T200_RUN, &st->l2.flag);
461}
462
Adrian Bunk672c3fd2005-06-25 14:59:18 -0700463static inline void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464restart_t200(struct PStack *st, int i)
465{
466 FsmRestartTimer(&st->l2.t200, st->l2.T200, EV_L2_T200, NULL, i);
467 test_and_set_bit(FLG_T200_RUN, &st->l2.flag);
468}
469
Adrian Bunk672c3fd2005-06-25 14:59:18 -0700470static inline void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471stop_t200(struct PStack *st, int i)
472{
473 if(test_and_clear_bit(FLG_T200_RUN, &st->l2.flag))
474 FsmDelTimer(&st->l2.t200, i);
475}
476
Adrian Bunk672c3fd2005-06-25 14:59:18 -0700477static inline void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478st5_dl_release_l2l3(struct PStack *st)
479{
480 int pr;
481
482 if(test_and_clear_bit(FLG_PEND_REL, &st->l2.flag))
483 pr = DL_RELEASE | CONFIRM;
484 else
485 pr = DL_RELEASE | INDICATION;
486
487 st->l2.l2l3(st, pr, NULL);
488}
489
Adrian Bunk672c3fd2005-06-25 14:59:18 -0700490static inline void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491lapb_dl_release_l2l3(struct PStack *st, int f)
492{
493 if (test_bit(FLG_LAPB, &st->l2.flag))
494 st->l2.l2l1(st, PH_DEACTIVATE | REQUEST, NULL);
495 st->l2.l2l3(st, DL_RELEASE | f, NULL);
496}
497
498static void
499establishlink(struct FsmInst *fi)
500{
501 struct PStack *st = fi->userdata;
502 u_char cmd;
503
504 clear_exception(&st->l2);
505 st->l2.rc = 0;
506 cmd = (test_bit(FLG_MOD128, &st->l2.flag) ? SABME : SABM) | 0x10;
507 send_uframe(st, cmd, CMD);
508 FsmDelTimer(&st->l2.t203, 1);
509 restart_t200(st, 1);
510 test_and_clear_bit(FLG_PEND_REL, &st->l2.flag);
511 freewin(st);
512 FsmChangeState(fi, ST_L2_5);
513}
514
515static void
516l2_mdl_error_ua(struct FsmInst *fi, int event, void *arg)
517{
518 struct sk_buff *skb = arg;
519 struct PStack *st = fi->userdata;
520
521 if (get_PollFlagFree(st, skb))
522 st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'C');
523 else
524 st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'D');
525}
526
527static void
528l2_mdl_error_dm(struct FsmInst *fi, int event, void *arg)
529{
530 struct sk_buff *skb = arg;
531 struct PStack *st = fi->userdata;
532
533 if (get_PollFlagFree(st, skb))
534 st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'B');
535 else {
536 st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'E');
537 establishlink(fi);
538 test_and_clear_bit(FLG_L3_INIT, &st->l2.flag);
539 }
540}
541
542static void
543l2_st8_mdl_error_dm(struct FsmInst *fi, int event, void *arg)
544{
545 struct sk_buff *skb = arg;
546 struct PStack *st = fi->userdata;
547
548 if (get_PollFlagFree(st, skb))
549 st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'B');
550 else {
551 st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'E');
552 }
553 establishlink(fi);
554 test_and_clear_bit(FLG_L3_INIT, &st->l2.flag);
555}
556
557static void
558l2_go_st3(struct FsmInst *fi, int event, void *arg)
559{
560 FsmChangeState(fi, ST_L2_3);
561}
562
563static void
564l2_mdl_assign(struct FsmInst *fi, int event, void *arg)
565{
566 struct PStack *st = fi->userdata;
567
568 FsmChangeState(fi, ST_L2_3);
569 st->l2.l2tei(st, MDL_ASSIGN | INDICATION, NULL);
570}
571
572static void
573l2_queue_ui_assign(struct FsmInst *fi, int event, void *arg)
574{
575 struct PStack *st = fi->userdata;
576 struct sk_buff *skb = arg;
577
578 skb_queue_tail(&st->l2.ui_queue, skb);
579 FsmChangeState(fi, ST_L2_2);
580 st->l2.l2tei(st, MDL_ASSIGN | INDICATION, NULL);
581}
582
583static void
584l2_queue_ui(struct FsmInst *fi, int event, void *arg)
585{
586 struct PStack *st = fi->userdata;
587 struct sk_buff *skb = arg;
588
589 skb_queue_tail(&st->l2.ui_queue, skb);
590}
591
592static void
593tx_ui(struct PStack *st)
594{
595 struct sk_buff *skb;
596 u_char header[MAX_HEADER_LEN];
597 int i;
598
599 i = sethdraddr(&(st->l2), header, CMD);
600 header[i++] = UI;
601 while ((skb = skb_dequeue(&st->l2.ui_queue))) {
602 memcpy(skb_push(skb, i), header, i);
603 enqueue_ui(st, skb);
604 }
605}
606
607static void
608l2_send_ui(struct FsmInst *fi, int event, void *arg)
609{
610 struct PStack *st = fi->userdata;
611 struct sk_buff *skb = arg;
612
613 skb_queue_tail(&st->l2.ui_queue, skb);
614 tx_ui(st);
615}
616
617static void
618l2_got_ui(struct FsmInst *fi, int event, void *arg)
619{
620 struct PStack *st = fi->userdata;
621 struct sk_buff *skb = arg;
622
623 skb_pull(skb, l2headersize(&st->l2, 1));
624 st->l2.l2l3(st, DL_UNIT_DATA | INDICATION, skb);
625/* ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
626 * in states 1-3 for broadcast
627 */
628
629
630}
631
632static void
633l2_establish(struct FsmInst *fi, int event, void *arg)
634{
635 struct PStack *st = fi->userdata;
636
637 establishlink(fi);
638 test_and_set_bit(FLG_L3_INIT, &st->l2.flag);
639}
640
641static void
642l2_discard_i_setl3(struct FsmInst *fi, int event, void *arg)
643{
644 struct PStack *st = fi->userdata;
645
646 skb_queue_purge(&st->l2.i_queue);
647 test_and_set_bit(FLG_L3_INIT, &st->l2.flag);
648 test_and_clear_bit(FLG_PEND_REL, &st->l2.flag);
649}
650
651static void
652l2_l3_reestablish(struct FsmInst *fi, int event, void *arg)
653{
654 struct PStack *st = fi->userdata;
655
656 skb_queue_purge(&st->l2.i_queue);
657 establishlink(fi);
658 test_and_set_bit(FLG_L3_INIT, &st->l2.flag);
659}
660
661static void
662l2_release(struct FsmInst *fi, int event, void *arg)
663{
664 struct PStack *st = fi->userdata;
665
666 st->l2.l2l3(st, DL_RELEASE | CONFIRM, NULL);
667}
668
669static void
670l2_pend_rel(struct FsmInst *fi, int event, void *arg)
671{
672 struct PStack *st = fi->userdata;
673
674 test_and_set_bit(FLG_PEND_REL, &st->l2.flag);
675}
676
677static void
678l2_disconnect(struct FsmInst *fi, int event, void *arg)
679{
680 struct PStack *st = fi->userdata;
681
682 skb_queue_purge(&st->l2.i_queue);
683 freewin(st);
684 FsmChangeState(fi, ST_L2_6);
685 st->l2.rc = 0;
686 send_uframe(st, DISC | 0x10, CMD);
687 FsmDelTimer(&st->l2.t203, 1);
688 restart_t200(st, 2);
689}
690
691static void
692l2_start_multi(struct FsmInst *fi, int event, void *arg)
693{
694 struct PStack *st = fi->userdata;
695 struct sk_buff *skb = arg;
696
697 send_uframe(st, UA | get_PollFlagFree(st, skb), RSP);
698
699 clear_exception(&st->l2);
700 st->l2.vs = 0;
701 st->l2.va = 0;
702 st->l2.vr = 0;
703 st->l2.sow = 0;
704 FsmChangeState(fi, ST_L2_7);
705 FsmAddTimer(&st->l2.t203, st->l2.T203, EV_L2_T203, NULL, 3);
706
707 st->l2.l2l3(st, DL_ESTABLISH | INDICATION, NULL);
708}
709
710static void
711l2_send_UA(struct FsmInst *fi, int event, void *arg)
712{
713 struct PStack *st = fi->userdata;
714 struct sk_buff *skb = arg;
715
716 send_uframe(st, UA | get_PollFlagFree(st, skb), RSP);
717}
718
719static void
720l2_send_DM(struct FsmInst *fi, int event, void *arg)
721{
722 struct PStack *st = fi->userdata;
723 struct sk_buff *skb = arg;
724
725 send_uframe(st, DM | get_PollFlagFree(st, skb), RSP);
726}
727
728static void
729l2_restart_multi(struct FsmInst *fi, int event, void *arg)
730{
731 struct PStack *st = fi->userdata;
732 struct sk_buff *skb = arg;
733 int est = 0, state;
734
735 state = fi->state;
736
737 send_uframe(st, UA | get_PollFlagFree(st, skb), RSP);
738
739 st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'F');
740
741 if (st->l2.vs != st->l2.va) {
742 skb_queue_purge(&st->l2.i_queue);
743 est = 1;
744 }
745
746 clear_exception(&st->l2);
747 st->l2.vs = 0;
748 st->l2.va = 0;
749 st->l2.vr = 0;
750 st->l2.sow = 0;
751 FsmChangeState(fi, ST_L2_7);
752 stop_t200(st, 3);
753 FsmRestartTimer(&st->l2.t203, st->l2.T203, EV_L2_T203, NULL, 3);
754
755 if (est)
756 st->l2.l2l3(st, DL_ESTABLISH | INDICATION, NULL);
757
758 if ((ST_L2_7==state) || (ST_L2_8 == state))
David S. Millerb03efcf2005-07-08 14:57:23 -0700759 if (!skb_queue_empty(&st->l2.i_queue) && cansend(st))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760 st->l2.l2l1(st, PH_PULL | REQUEST, NULL);
761}
762
763static void
764l2_stop_multi(struct FsmInst *fi, int event, void *arg)
765{
766 struct PStack *st = fi->userdata;
767 struct sk_buff *skb = arg;
768
769 FsmChangeState(fi, ST_L2_4);
770 FsmDelTimer(&st->l2.t203, 3);
771 stop_t200(st, 4);
772
773 send_uframe(st, UA | get_PollFlagFree(st, skb), RSP);
774
775 skb_queue_purge(&st->l2.i_queue);
776 freewin(st);
777 lapb_dl_release_l2l3(st, INDICATION);
778}
779
780static void
781l2_connected(struct FsmInst *fi, int event, void *arg)
782{
783 struct PStack *st = fi->userdata;
784 struct sk_buff *skb = arg;
785 int pr=-1;
786
787 if (!get_PollFlag(st, skb)) {
788 l2_mdl_error_ua(fi, event, arg);
789 return;
790 }
Adrian Bunk672c3fd2005-06-25 14:59:18 -0700791 dev_kfree_skb(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792
793 if (test_and_clear_bit(FLG_PEND_REL, &st->l2.flag))
794 l2_disconnect(fi, event, arg);
795
796 if (test_and_clear_bit(FLG_L3_INIT, &st->l2.flag)) {
797 pr = DL_ESTABLISH | CONFIRM;
798 } else if (st->l2.vs != st->l2.va) {
799 skb_queue_purge(&st->l2.i_queue);
800 pr = DL_ESTABLISH | INDICATION;
801 }
802
803 stop_t200(st, 5);
804
805 st->l2.vr = 0;
806 st->l2.vs = 0;
807 st->l2.va = 0;
808 st->l2.sow = 0;
809 FsmChangeState(fi, ST_L2_7);
810 FsmAddTimer(&st->l2.t203, st->l2.T203, EV_L2_T203, NULL, 4);
811
812 if (pr != -1)
813 st->l2.l2l3(st, pr, NULL);
814
David S. Millerb03efcf2005-07-08 14:57:23 -0700815 if (!skb_queue_empty(&st->l2.i_queue) && cansend(st))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816 st->l2.l2l1(st, PH_PULL | REQUEST, NULL);
817}
818
819static void
820l2_released(struct FsmInst *fi, int event, void *arg)
821{
822 struct PStack *st = fi->userdata;
823 struct sk_buff *skb = arg;
824
825 if (!get_PollFlag(st, skb)) {
826 l2_mdl_error_ua(fi, event, arg);
827 return;
828 }
Adrian Bunk672c3fd2005-06-25 14:59:18 -0700829 dev_kfree_skb(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830
831 stop_t200(st, 6);
832 lapb_dl_release_l2l3(st, CONFIRM);
833 FsmChangeState(fi, ST_L2_4);
834}
835
836static void
837l2_reestablish(struct FsmInst *fi, int event, void *arg)
838{
839 struct PStack *st = fi->userdata;
840 struct sk_buff *skb = arg;
841
842 if (!get_PollFlagFree(st, skb)) {
843 establishlink(fi);
844 test_and_set_bit(FLG_L3_INIT, &st->l2.flag);
845 }
846}
847
848static void
849l2_st5_dm_release(struct FsmInst *fi, int event, void *arg)
850{
851 struct PStack *st = fi->userdata;
852 struct sk_buff *skb = arg;
853
854 if (get_PollFlagFree(st, skb)) {
855 stop_t200(st, 7);
856 if (!test_bit(FLG_L3_INIT, &st->l2.flag))
857 skb_queue_purge(&st->l2.i_queue);
858 if (test_bit(FLG_LAPB, &st->l2.flag))
859 st->l2.l2l1(st, PH_DEACTIVATE | REQUEST, NULL);
860 st5_dl_release_l2l3(st);
861 FsmChangeState(fi, ST_L2_4);
862 }
863}
864
865static void
866l2_st6_dm_release(struct FsmInst *fi, int event, void *arg)
867{
868 struct PStack *st = fi->userdata;
869 struct sk_buff *skb = arg;
870
871 if (get_PollFlagFree(st, skb)) {
872 stop_t200(st, 8);
873 lapb_dl_release_l2l3(st, CONFIRM);
874 FsmChangeState(fi, ST_L2_4);
875 }
876}
877
Adrian Bunk672c3fd2005-06-25 14:59:18 -0700878static inline void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879enquiry_cr(struct PStack *st, u_char typ, u_char cr, u_char pf)
880{
881 struct sk_buff *skb;
882 struct Layer2 *l2;
883 u_char tmp[MAX_HEADER_LEN];
884 int i;
885
886 l2 = &st->l2;
887 i = sethdraddr(l2, tmp, cr);
888 if (test_bit(FLG_MOD128, &l2->flag)) {
889 tmp[i++] = typ;
890 tmp[i++] = (l2->vr << 1) | (pf ? 1 : 0);
891 } else
892 tmp[i++] = (l2->vr << 5) | typ | (pf ? 0x10 : 0);
893 if (!(skb = alloc_skb(i, GFP_ATOMIC))) {
894 printk(KERN_WARNING "isdl2 can't alloc sbbuff for enquiry_cr\n");
895 return;
896 }
897 memcpy(skb_put(skb, i), tmp, i);
898 enqueue_super(st, skb);
899}
900
Adrian Bunk672c3fd2005-06-25 14:59:18 -0700901static inline void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902enquiry_response(struct PStack *st)
903{
904 if (test_bit(FLG_OWN_BUSY, &st->l2.flag))
905 enquiry_cr(st, RNR, RSP, 1);
906 else
907 enquiry_cr(st, RR, RSP, 1);
908 test_and_clear_bit(FLG_ACK_PEND, &st->l2.flag);
909}
910
Adrian Bunk672c3fd2005-06-25 14:59:18 -0700911static inline void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912transmit_enquiry(struct PStack *st)
913{
914 if (test_bit(FLG_OWN_BUSY, &st->l2.flag))
915 enquiry_cr(st, RNR, CMD, 1);
916 else
917 enquiry_cr(st, RR, CMD, 1);
918 test_and_clear_bit(FLG_ACK_PEND, &st->l2.flag);
919 start_t200(st, 9);
920}
921
922
923static void
924nrerrorrecovery(struct FsmInst *fi)
925{
926 struct PStack *st = fi->userdata;
927
928 st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'J');
929 establishlink(fi);
930 test_and_clear_bit(FLG_L3_INIT, &st->l2.flag);
931}
932
933static void
934invoke_retransmission(struct PStack *st, unsigned int nr)
935{
936 struct Layer2 *l2 = &st->l2;
937 u_int p1;
938 u_long flags;
939
940 spin_lock_irqsave(&l2->lock, flags);
941 if (l2->vs != nr) {
942 while (l2->vs != nr) {
943 (l2->vs)--;
944 if(test_bit(FLG_MOD128, &l2->flag)) {
945 l2->vs %= 128;
946 p1 = (l2->vs - l2->va) % 128;
947 } else {
948 l2->vs %= 8;
949 p1 = (l2->vs - l2->va) % 8;
950 }
951 p1 = (p1 + l2->sow) % l2->window;
952 if (test_bit(FLG_LAPB, &l2->flag))
953 st->l1.bcs->tx_cnt += l2->windowar[p1]->len + l2headersize(l2, 0);
954 skb_queue_head(&l2->i_queue, l2->windowar[p1]);
955 l2->windowar[p1] = NULL;
956 }
957 spin_unlock_irqrestore(&l2->lock, flags);
958 st->l2.l2l1(st, PH_PULL | REQUEST, NULL);
959 return;
960 }
961 spin_unlock_irqrestore(&l2->lock, flags);
962}
963
964static void
965l2_st7_got_super(struct FsmInst *fi, int event, void *arg)
966{
967 struct PStack *st = fi->userdata;
968 struct sk_buff *skb = arg;
969 int PollFlag, rsp, typ = RR;
970 unsigned int nr;
971 struct Layer2 *l2 = &st->l2;
972
973 rsp = *skb->data & 0x2;
974 if (test_bit(FLG_ORIG, &l2->flag))
975 rsp = !rsp;
976
977 skb_pull(skb, l2addrsize(l2));
978 if (IsRNR(skb->data, st)) {
979 set_peer_busy(l2);
980 typ = RNR;
981 } else
982 clear_peer_busy(l2);
983 if (IsREJ(skb->data, st))
984 typ = REJ;
985
986 if (test_bit(FLG_MOD128, &l2->flag)) {
987 PollFlag = (skb->data[1] & 0x1) == 0x1;
988 nr = skb->data[1] >> 1;
989 } else {
990 PollFlag = (skb->data[0] & 0x10);
991 nr = (skb->data[0] >> 5) & 0x7;
992 }
Adrian Bunk672c3fd2005-06-25 14:59:18 -0700993 dev_kfree_skb(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994
995 if (PollFlag) {
996 if (rsp)
997 st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'A');
998 else
999 enquiry_response(st);
1000 }
1001 if (legalnr(st, nr)) {
1002 if (typ == REJ) {
1003 setva(st, nr);
1004 invoke_retransmission(st, nr);
1005 stop_t200(st, 10);
1006 if (FsmAddTimer(&st->l2.t203, st->l2.T203,
1007 EV_L2_T203, NULL, 6))
1008 l2m_debug(&st->l2.l2m, "Restart T203 ST7 REJ");
1009 } else if ((nr == l2->vs) && (typ == RR)) {
1010 setva(st, nr);
1011 stop_t200(st, 11);
1012 FsmRestartTimer(&st->l2.t203, st->l2.T203,
1013 EV_L2_T203, NULL, 7);
1014 } else if ((l2->va != nr) || (typ == RNR)) {
1015 setva(st, nr);
1016 if(typ != RR) FsmDelTimer(&st->l2.t203, 9);
1017 restart_t200(st, 12);
1018 }
David S. Millerb03efcf2005-07-08 14:57:23 -07001019 if (!skb_queue_empty(&st->l2.i_queue) && (typ == RR))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020 st->l2.l2l1(st, PH_PULL | REQUEST, NULL);
1021 } else
1022 nrerrorrecovery(fi);
1023}
1024
1025static void
1026l2_feed_i_if_reest(struct FsmInst *fi, int event, void *arg)
1027{
1028 struct PStack *st = fi->userdata;
1029 struct sk_buff *skb = arg;
1030
1031 if (test_bit(FLG_LAPB, &st->l2.flag))
1032 st->l1.bcs->tx_cnt += skb->len + l2headersize(&st->l2, 0);
1033 if (!test_bit(FLG_L3_INIT, &st->l2.flag))
1034 skb_queue_tail(&st->l2.i_queue, skb);
1035 else
Adrian Bunk672c3fd2005-06-25 14:59:18 -07001036 dev_kfree_skb(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037}
1038
1039static void
1040l2_feed_i_pull(struct FsmInst *fi, int event, void *arg)
1041{
1042 struct PStack *st = fi->userdata;
1043 struct sk_buff *skb = arg;
1044
1045 if (test_bit(FLG_LAPB, &st->l2.flag))
1046 st->l1.bcs->tx_cnt += skb->len + l2headersize(&st->l2, 0);
1047 skb_queue_tail(&st->l2.i_queue, skb);
1048 st->l2.l2l1(st, PH_PULL | REQUEST, NULL);
1049}
1050
1051static void
1052l2_feed_iqueue(struct FsmInst *fi, int event, void *arg)
1053{
1054 struct PStack *st = fi->userdata;
1055 struct sk_buff *skb = arg;
1056
1057 if (test_bit(FLG_LAPB, &st->l2.flag))
1058 st->l1.bcs->tx_cnt += skb->len + l2headersize(&st->l2, 0);
1059 skb_queue_tail(&st->l2.i_queue, skb);
1060}
1061
1062static void
1063l2_got_iframe(struct FsmInst *fi, int event, void *arg)
1064{
1065 struct PStack *st = fi->userdata;
1066 struct sk_buff *skb = arg;
1067 struct Layer2 *l2 = &(st->l2);
1068 int PollFlag, ns, i;
1069 unsigned int nr;
1070
1071 i = l2addrsize(l2);
1072 if (test_bit(FLG_MOD128, &l2->flag)) {
1073 PollFlag = ((skb->data[i + 1] & 0x1) == 0x1);
1074 ns = skb->data[i] >> 1;
1075 nr = (skb->data[i + 1] >> 1) & 0x7f;
1076 } else {
1077 PollFlag = (skb->data[i] & 0x10);
1078 ns = (skb->data[i] >> 1) & 0x7;
1079 nr = (skb->data[i] >> 5) & 0x7;
1080 }
1081 if (test_bit(FLG_OWN_BUSY, &l2->flag)) {
Adrian Bunk672c3fd2005-06-25 14:59:18 -07001082 dev_kfree_skb(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083 if(PollFlag) enquiry_response(st);
1084 } else if (l2->vr == ns) {
1085 (l2->vr)++;
1086 if(test_bit(FLG_MOD128, &l2->flag))
1087 l2->vr %= 128;
1088 else
1089 l2->vr %= 8;
1090 test_and_clear_bit(FLG_REJEXC, &l2->flag);
1091
1092 if (PollFlag)
1093 enquiry_response(st);
1094 else
1095 test_and_set_bit(FLG_ACK_PEND, &l2->flag);
1096 skb_pull(skb, l2headersize(l2, 0));
1097 st->l2.l2l3(st, DL_DATA | INDICATION, skb);
1098 } else {
1099 /* n(s)!=v(r) */
Adrian Bunk672c3fd2005-06-25 14:59:18 -07001100 dev_kfree_skb(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101 if (test_and_set_bit(FLG_REJEXC, &l2->flag)) {
1102 if (PollFlag)
1103 enquiry_response(st);
1104 } else {
1105 enquiry_cr(st, REJ, RSP, PollFlag);
1106 test_and_clear_bit(FLG_ACK_PEND, &l2->flag);
1107 }
1108 }
1109
1110 if (legalnr(st, nr)) {
1111 if (!test_bit(FLG_PEER_BUSY, &st->l2.flag) && (fi->state == ST_L2_7)) {
1112 if (nr == st->l2.vs) {
1113 stop_t200(st, 13);
1114 FsmRestartTimer(&st->l2.t203, st->l2.T203,
1115 EV_L2_T203, NULL, 7);
1116 } else if (nr != st->l2.va)
1117 restart_t200(st, 14);
1118 }
1119 setva(st, nr);
1120 } else {
1121 nrerrorrecovery(fi);
1122 return;
1123 }
1124
David S. Millerb03efcf2005-07-08 14:57:23 -07001125 if (!skb_queue_empty(&st->l2.i_queue) && (fi->state == ST_L2_7))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126 st->l2.l2l1(st, PH_PULL | REQUEST, NULL);
1127 if (test_and_clear_bit(FLG_ACK_PEND, &st->l2.flag))
1128 enquiry_cr(st, RR, RSP, 0);
1129}
1130
1131static void
1132l2_got_tei(struct FsmInst *fi, int event, void *arg)
1133{
1134 struct PStack *st = fi->userdata;
1135
1136 st->l2.tei = (long) arg;
1137
1138 if (fi->state == ST_L2_3) {
1139 establishlink(fi);
1140 test_and_set_bit(FLG_L3_INIT, &st->l2.flag);
1141 } else
1142 FsmChangeState(fi, ST_L2_4);
David S. Millerb03efcf2005-07-08 14:57:23 -07001143 if (!skb_queue_empty(&st->l2.ui_queue))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144 tx_ui(st);
1145}
1146
1147static void
1148l2_st5_tout_200(struct FsmInst *fi, int event, void *arg)
1149{
1150 struct PStack *st = fi->userdata;
1151
1152 if (test_bit(FLG_LAPD, &st->l2.flag) &&
1153 test_bit(FLG_DCHAN_BUSY, &st->l2.flag)) {
1154 FsmAddTimer(&st->l2.t200, st->l2.T200, EV_L2_T200, NULL, 9);
1155 } else if (st->l2.rc == st->l2.N200) {
1156 FsmChangeState(fi, ST_L2_4);
1157 test_and_clear_bit(FLG_T200_RUN, &st->l2.flag);
1158 skb_queue_purge(&st->l2.i_queue);
1159 st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'G');
1160 if (test_bit(FLG_LAPB, &st->l2.flag))
1161 st->l2.l2l1(st, PH_DEACTIVATE | REQUEST, NULL);
1162 st5_dl_release_l2l3(st);
1163 } else {
1164 st->l2.rc++;
1165 FsmAddTimer(&st->l2.t200, st->l2.T200, EV_L2_T200, NULL, 9);
1166 send_uframe(st, (test_bit(FLG_MOD128, &st->l2.flag) ? SABME : SABM)
1167 | 0x10, CMD);
1168 }
1169}
1170
1171static void
1172l2_st6_tout_200(struct FsmInst *fi, int event, void *arg)
1173{
1174 struct PStack *st = fi->userdata;
1175
1176 if (test_bit(FLG_LAPD, &st->l2.flag) &&
1177 test_bit(FLG_DCHAN_BUSY, &st->l2.flag)) {
1178 FsmAddTimer(&st->l2.t200, st->l2.T200, EV_L2_T200, NULL, 9);
1179 } else if (st->l2.rc == st->l2.N200) {
1180 FsmChangeState(fi, ST_L2_4);
1181 test_and_clear_bit(FLG_T200_RUN, &st->l2.flag);
1182 st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'H');
1183 lapb_dl_release_l2l3(st, CONFIRM);
1184 } else {
1185 st->l2.rc++;
1186 FsmAddTimer(&st->l2.t200, st->l2.T200, EV_L2_T200,
1187 NULL, 9);
1188 send_uframe(st, DISC | 0x10, CMD);
1189 }
1190}
1191
1192static void
1193l2_st7_tout_200(struct FsmInst *fi, int event, void *arg)
1194{
1195 struct PStack *st = fi->userdata;
1196
1197 if (test_bit(FLG_LAPD, &st->l2.flag) &&
1198 test_bit(FLG_DCHAN_BUSY, &st->l2.flag)) {
1199 FsmAddTimer(&st->l2.t200, st->l2.T200, EV_L2_T200, NULL, 9);
1200 return;
1201 }
1202 test_and_clear_bit(FLG_T200_RUN, &st->l2.flag);
1203 st->l2.rc = 0;
1204 FsmChangeState(fi, ST_L2_8);
1205
1206 transmit_enquiry(st);
1207 st->l2.rc++;
1208}
1209
1210static void
1211l2_st8_tout_200(struct FsmInst *fi, int event, void *arg)
1212{
1213 struct PStack *st = fi->userdata;
1214
1215 if (test_bit(FLG_LAPD, &st->l2.flag) &&
1216 test_bit(FLG_DCHAN_BUSY, &st->l2.flag)) {
1217 FsmAddTimer(&st->l2.t200, st->l2.T200, EV_L2_T200, NULL, 9);
1218 return;
1219 }
1220 test_and_clear_bit(FLG_T200_RUN, &st->l2.flag);
1221 if (st->l2.rc == st->l2.N200) {
1222 st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'I');
1223 establishlink(fi);
1224 test_and_clear_bit(FLG_L3_INIT, &st->l2.flag);
1225 } else {
1226 transmit_enquiry(st);
1227 st->l2.rc++;
1228 }
1229}
1230
1231static void
1232l2_st7_tout_203(struct FsmInst *fi, int event, void *arg)
1233{
1234 struct PStack *st = fi->userdata;
1235
1236 if (test_bit(FLG_LAPD, &st->l2.flag) &&
1237 test_bit(FLG_DCHAN_BUSY, &st->l2.flag)) {
1238 FsmAddTimer(&st->l2.t203, st->l2.T203, EV_L2_T203, NULL, 9);
1239 return;
1240 }
1241 FsmChangeState(fi, ST_L2_8);
1242 transmit_enquiry(st);
1243 st->l2.rc = 0;
1244}
1245
1246static void
1247l2_pull_iqueue(struct FsmInst *fi, int event, void *arg)
1248{
1249 struct PStack *st = fi->userdata;
David S. Millerc978e7b2011-02-13 16:50:45 -08001250 struct sk_buff *skb;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001251 struct Layer2 *l2 = &st->l2;
1252 u_char header[MAX_HEADER_LEN];
David S. Millerc978e7b2011-02-13 16:50:45 -08001253 int i, hdr_space_needed;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254 int unsigned p1;
1255 u_long flags;
1256
1257 if (!cansend(st))
1258 return;
1259
1260 skb = skb_dequeue(&l2->i_queue);
1261 if (!skb)
1262 return;
1263
David S. Miller6d90e8f2011-02-15 12:18:09 -08001264 hdr_space_needed = l2headersize(l2, 0);
David S. Millerc978e7b2011-02-13 16:50:45 -08001265 if (hdr_space_needed > skb_headroom(skb)) {
1266 struct sk_buff *orig_skb = skb;
1267
1268 skb = skb_realloc_headroom(skb, hdr_space_needed);
1269 if (!skb) {
1270 dev_kfree_skb(orig_skb);
1271 return;
1272 }
1273 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001274 spin_lock_irqsave(&l2->lock, flags);
1275 if(test_bit(FLG_MOD128, &l2->flag))
1276 p1 = (l2->vs - l2->va) % 128;
1277 else
1278 p1 = (l2->vs - l2->va) % 8;
1279 p1 = (p1 + l2->sow) % l2->window;
1280 if (l2->windowar[p1]) {
1281 printk(KERN_WARNING "isdnl2 try overwrite ack queue entry %d\n",
1282 p1);
1283 dev_kfree_skb(l2->windowar[p1]);
1284 }
1285 l2->windowar[p1] = skb_clone(skb, GFP_ATOMIC);
1286
1287 i = sethdraddr(&st->l2, header, CMD);
1288
1289 if (test_bit(FLG_MOD128, &l2->flag)) {
1290 header[i++] = l2->vs << 1;
1291 header[i++] = l2->vr << 1;
1292 l2->vs = (l2->vs + 1) % 128;
1293 } else {
1294 header[i++] = (l2->vr << 5) | (l2->vs << 1);
1295 l2->vs = (l2->vs + 1) % 8;
1296 }
1297 spin_unlock_irqrestore(&l2->lock, flags);
David S. Millerc978e7b2011-02-13 16:50:45 -08001298 memcpy(skb_push(skb, i), header, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299 st->l2.l2l1(st, PH_PULL | INDICATION, skb);
1300 test_and_clear_bit(FLG_ACK_PEND, &st->l2.flag);
1301 if (!test_and_set_bit(FLG_T200_RUN, &st->l2.flag)) {
1302 FsmDelTimer(&st->l2.t203, 13);
1303 FsmAddTimer(&st->l2.t200, st->l2.T200, EV_L2_T200, NULL, 11);
1304 }
David S. Millerb03efcf2005-07-08 14:57:23 -07001305 if (!skb_queue_empty(&l2->i_queue) && cansend(st))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001306 st->l2.l2l1(st, PH_PULL | REQUEST, NULL);
1307}
1308
1309static void
1310l2_st8_got_super(struct FsmInst *fi, int event, void *arg)
1311{
1312 struct PStack *st = fi->userdata;
1313 struct sk_buff *skb = arg;
1314 int PollFlag, rsp, rnr = 0;
1315 unsigned int nr;
1316 struct Layer2 *l2 = &st->l2;
1317
1318 rsp = *skb->data & 0x2;
1319 if (test_bit(FLG_ORIG, &l2->flag))
1320 rsp = !rsp;
1321
1322 skb_pull(skb, l2addrsize(l2));
1323
1324 if (IsRNR(skb->data, st)) {
1325 set_peer_busy(l2);
1326 rnr = 1;
1327 } else
1328 clear_peer_busy(l2);
1329
1330 if (test_bit(FLG_MOD128, &l2->flag)) {
1331 PollFlag = (skb->data[1] & 0x1) == 0x1;
1332 nr = skb->data[1] >> 1;
1333 } else {
1334 PollFlag = (skb->data[0] & 0x10);
1335 nr = (skb->data[0] >> 5) & 0x7;
1336 }
Adrian Bunk672c3fd2005-06-25 14:59:18 -07001337 dev_kfree_skb(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338
1339 if (rsp && PollFlag) {
1340 if (legalnr(st, nr)) {
1341 if (rnr) {
1342 restart_t200(st, 15);
1343 } else {
1344 stop_t200(st, 16);
1345 FsmAddTimer(&l2->t203, l2->T203,
1346 EV_L2_T203, NULL, 5);
1347 setva(st, nr);
1348 }
1349 invoke_retransmission(st, nr);
1350 FsmChangeState(fi, ST_L2_7);
David S. Millerb03efcf2005-07-08 14:57:23 -07001351 if (!skb_queue_empty(&l2->i_queue) && cansend(st))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001352 st->l2.l2l1(st, PH_PULL | REQUEST, NULL);
1353 } else
1354 nrerrorrecovery(fi);
1355 } else {
1356 if (!rsp && PollFlag)
1357 enquiry_response(st);
1358 if (legalnr(st, nr)) {
1359 setva(st, nr);
1360 } else
1361 nrerrorrecovery(fi);
1362 }
1363}
1364
1365static void
1366l2_got_FRMR(struct FsmInst *fi, int event, void *arg)
1367{
1368 struct PStack *st = fi->userdata;
1369 struct sk_buff *skb = arg;
1370
1371 skb_pull(skb, l2addrsize(&st->l2) + 1);
1372
1373 if (!(skb->data[0] & 1) || ((skb->data[0] & 3) == 1) || /* I or S */
1374 (IsUA(skb->data) && (fi->state == ST_L2_7))) {
1375 st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'K');
1376 establishlink(fi);
1377 test_and_clear_bit(FLG_L3_INIT, &st->l2.flag);
1378 }
Adrian Bunk672c3fd2005-06-25 14:59:18 -07001379 dev_kfree_skb(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001380}
1381
1382static void
1383l2_st24_tei_remove(struct FsmInst *fi, int event, void *arg)
1384{
1385 struct PStack *st = fi->userdata;
1386
1387 skb_queue_purge(&st->l2.ui_queue);
1388 st->l2.tei = -1;
1389 FsmChangeState(fi, ST_L2_1);
1390}
1391
1392static void
1393l2_st3_tei_remove(struct FsmInst *fi, int event, void *arg)
1394{
1395 struct PStack *st = fi->userdata;
1396
1397 skb_queue_purge(&st->l2.ui_queue);
1398 st->l2.tei = -1;
1399 st->l2.l2l3(st, DL_RELEASE | INDICATION, NULL);
1400 FsmChangeState(fi, ST_L2_1);
1401}
1402
1403static void
1404l2_st5_tei_remove(struct FsmInst *fi, int event, void *arg)
1405{
1406 struct PStack *st = fi->userdata;
1407
1408 skb_queue_purge(&st->l2.i_queue);
1409 skb_queue_purge(&st->l2.ui_queue);
1410 freewin(st);
1411 st->l2.tei = -1;
1412 stop_t200(st, 17);
1413 st5_dl_release_l2l3(st);
1414 FsmChangeState(fi, ST_L2_1);
1415}
1416
1417static void
1418l2_st6_tei_remove(struct FsmInst *fi, int event, void *arg)
1419{
1420 struct PStack *st = fi->userdata;
1421
1422 skb_queue_purge(&st->l2.ui_queue);
1423 st->l2.tei = -1;
1424 stop_t200(st, 18);
1425 st->l2.l2l3(st, DL_RELEASE | CONFIRM, NULL);
1426 FsmChangeState(fi, ST_L2_1);
1427}
1428
1429static void
1430l2_tei_remove(struct FsmInst *fi, int event, void *arg)
1431{
1432 struct PStack *st = fi->userdata;
1433
1434 skb_queue_purge(&st->l2.i_queue);
1435 skb_queue_purge(&st->l2.ui_queue);
1436 freewin(st);
1437 st->l2.tei = -1;
1438 stop_t200(st, 17);
1439 FsmDelTimer(&st->l2.t203, 19);
1440 st->l2.l2l3(st, DL_RELEASE | INDICATION, NULL);
1441 FsmChangeState(fi, ST_L2_1);
1442}
1443
1444static void
Jan Engelhardt6b44d4e2006-11-30 05:33:40 +01001445l2_st14_persistent_da(struct FsmInst *fi, int event, void *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001446{
1447 struct PStack *st = fi->userdata;
1448
1449 skb_queue_purge(&st->l2.i_queue);
1450 skb_queue_purge(&st->l2.ui_queue);
1451 if (test_and_clear_bit(FLG_ESTAB_PEND, &st->l2.flag))
1452 st->l2.l2l3(st, DL_RELEASE | INDICATION, NULL);
1453}
1454
1455static void
Jan Engelhardt6b44d4e2006-11-30 05:33:40 +01001456l2_st5_persistent_da(struct FsmInst *fi, int event, void *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457{
1458 struct PStack *st = fi->userdata;
1459
1460 skb_queue_purge(&st->l2.i_queue);
1461 skb_queue_purge(&st->l2.ui_queue);
1462 freewin(st);
1463 stop_t200(st, 19);
1464 st5_dl_release_l2l3(st);
1465 FsmChangeState(fi, ST_L2_4);
1466}
1467
1468static void
Jan Engelhardt6b44d4e2006-11-30 05:33:40 +01001469l2_st6_persistent_da(struct FsmInst *fi, int event, void *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001470{
1471 struct PStack *st = fi->userdata;
1472
1473 skb_queue_purge(&st->l2.ui_queue);
1474 stop_t200(st, 20);
1475 st->l2.l2l3(st, DL_RELEASE | CONFIRM, NULL);
1476 FsmChangeState(fi, ST_L2_4);
1477}
1478
1479static void
Jan Engelhardt6b44d4e2006-11-30 05:33:40 +01001480l2_persistent_da(struct FsmInst *fi, int event, void *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001481{
1482 struct PStack *st = fi->userdata;
1483
1484 skb_queue_purge(&st->l2.i_queue);
1485 skb_queue_purge(&st->l2.ui_queue);
1486 freewin(st);
1487 stop_t200(st, 19);
1488 FsmDelTimer(&st->l2.t203, 19);
1489 st->l2.l2l3(st, DL_RELEASE | INDICATION, NULL);
1490 FsmChangeState(fi, ST_L2_4);
1491}
1492
1493static void
1494l2_set_own_busy(struct FsmInst *fi, int event, void *arg)
1495{
1496 struct PStack *st = fi->userdata;
1497
1498 if(!test_and_set_bit(FLG_OWN_BUSY, &st->l2.flag)) {
1499 enquiry_cr(st, RNR, RSP, 0);
1500 test_and_clear_bit(FLG_ACK_PEND, &st->l2.flag);
1501 }
1502}
1503
1504static void
1505l2_clear_own_busy(struct FsmInst *fi, int event, void *arg)
1506{
1507 struct PStack *st = fi->userdata;
1508
1509 if(!test_and_clear_bit(FLG_OWN_BUSY, &st->l2.flag)) {
1510 enquiry_cr(st, RR, RSP, 0);
1511 test_and_clear_bit(FLG_ACK_PEND, &st->l2.flag);
1512 }
1513}
1514
1515static void
1516l2_frame_error(struct FsmInst *fi, int event, void *arg)
1517{
1518 struct PStack *st = fi->userdata;
1519
1520 st->ma.layer(st, MDL_ERROR | INDICATION, arg);
1521}
1522
1523static void
1524l2_frame_error_reest(struct FsmInst *fi, int event, void *arg)
1525{
1526 struct PStack *st = fi->userdata;
1527
1528 st->ma.layer(st, MDL_ERROR | INDICATION, arg);
1529 establishlink(fi);
1530 test_and_clear_bit(FLG_L3_INIT, &st->l2.flag);
1531}
1532
1533static struct FsmNode L2FnList[] __initdata =
1534{
1535 {ST_L2_1, EV_L2_DL_ESTABLISH_REQ, l2_mdl_assign},
1536 {ST_L2_2, EV_L2_DL_ESTABLISH_REQ, l2_go_st3},
1537 {ST_L2_4, EV_L2_DL_ESTABLISH_REQ, l2_establish},
1538 {ST_L2_5, EV_L2_DL_ESTABLISH_REQ, l2_discard_i_setl3},
1539 {ST_L2_7, EV_L2_DL_ESTABLISH_REQ, l2_l3_reestablish},
1540 {ST_L2_8, EV_L2_DL_ESTABLISH_REQ, l2_l3_reestablish},
1541 {ST_L2_4, EV_L2_DL_RELEASE_REQ, l2_release},
1542 {ST_L2_5, EV_L2_DL_RELEASE_REQ, l2_pend_rel},
1543 {ST_L2_7, EV_L2_DL_RELEASE_REQ, l2_disconnect},
1544 {ST_L2_8, EV_L2_DL_RELEASE_REQ, l2_disconnect},
1545 {ST_L2_5, EV_L2_DL_DATA, l2_feed_i_if_reest},
1546 {ST_L2_7, EV_L2_DL_DATA, l2_feed_i_pull},
1547 {ST_L2_8, EV_L2_DL_DATA, l2_feed_iqueue},
1548 {ST_L2_1, EV_L2_DL_UNIT_DATA, l2_queue_ui_assign},
1549 {ST_L2_2, EV_L2_DL_UNIT_DATA, l2_queue_ui},
1550 {ST_L2_3, EV_L2_DL_UNIT_DATA, l2_queue_ui},
1551 {ST_L2_4, EV_L2_DL_UNIT_DATA, l2_send_ui},
1552 {ST_L2_5, EV_L2_DL_UNIT_DATA, l2_send_ui},
1553 {ST_L2_6, EV_L2_DL_UNIT_DATA, l2_send_ui},
1554 {ST_L2_7, EV_L2_DL_UNIT_DATA, l2_send_ui},
1555 {ST_L2_8, EV_L2_DL_UNIT_DATA, l2_send_ui},
1556 {ST_L2_1, EV_L2_MDL_ASSIGN, l2_got_tei},
1557 {ST_L2_2, EV_L2_MDL_ASSIGN, l2_got_tei},
1558 {ST_L2_3, EV_L2_MDL_ASSIGN, l2_got_tei},
1559 {ST_L2_2, EV_L2_MDL_ERROR, l2_st24_tei_remove},
1560 {ST_L2_3, EV_L2_MDL_ERROR, l2_st3_tei_remove},
1561 {ST_L2_4, EV_L2_MDL_REMOVE, l2_st24_tei_remove},
1562 {ST_L2_5, EV_L2_MDL_REMOVE, l2_st5_tei_remove},
1563 {ST_L2_6, EV_L2_MDL_REMOVE, l2_st6_tei_remove},
1564 {ST_L2_7, EV_L2_MDL_REMOVE, l2_tei_remove},
1565 {ST_L2_8, EV_L2_MDL_REMOVE, l2_tei_remove},
1566 {ST_L2_4, EV_L2_SABME, l2_start_multi},
1567 {ST_L2_5, EV_L2_SABME, l2_send_UA},
1568 {ST_L2_6, EV_L2_SABME, l2_send_DM},
1569 {ST_L2_7, EV_L2_SABME, l2_restart_multi},
1570 {ST_L2_8, EV_L2_SABME, l2_restart_multi},
1571 {ST_L2_4, EV_L2_DISC, l2_send_DM},
1572 {ST_L2_5, EV_L2_DISC, l2_send_DM},
1573 {ST_L2_6, EV_L2_DISC, l2_send_UA},
1574 {ST_L2_7, EV_L2_DISC, l2_stop_multi},
1575 {ST_L2_8, EV_L2_DISC, l2_stop_multi},
1576 {ST_L2_4, EV_L2_UA, l2_mdl_error_ua},
1577 {ST_L2_5, EV_L2_UA, l2_connected},
1578 {ST_L2_6, EV_L2_UA, l2_released},
1579 {ST_L2_7, EV_L2_UA, l2_mdl_error_ua},
1580 {ST_L2_8, EV_L2_UA, l2_mdl_error_ua},
1581 {ST_L2_4, EV_L2_DM, l2_reestablish},
1582 {ST_L2_5, EV_L2_DM, l2_st5_dm_release},
1583 {ST_L2_6, EV_L2_DM, l2_st6_dm_release},
1584 {ST_L2_7, EV_L2_DM, l2_mdl_error_dm},
1585 {ST_L2_8, EV_L2_DM, l2_st8_mdl_error_dm},
1586 {ST_L2_1, EV_L2_UI, l2_got_ui},
1587 {ST_L2_2, EV_L2_UI, l2_got_ui},
1588 {ST_L2_3, EV_L2_UI, l2_got_ui},
1589 {ST_L2_4, EV_L2_UI, l2_got_ui},
1590 {ST_L2_5, EV_L2_UI, l2_got_ui},
1591 {ST_L2_6, EV_L2_UI, l2_got_ui},
1592 {ST_L2_7, EV_L2_UI, l2_got_ui},
1593 {ST_L2_8, EV_L2_UI, l2_got_ui},
1594 {ST_L2_7, EV_L2_FRMR, l2_got_FRMR},
1595 {ST_L2_8, EV_L2_FRMR, l2_got_FRMR},
1596 {ST_L2_7, EV_L2_SUPER, l2_st7_got_super},
1597 {ST_L2_8, EV_L2_SUPER, l2_st8_got_super},
1598 {ST_L2_7, EV_L2_I, l2_got_iframe},
1599 {ST_L2_8, EV_L2_I, l2_got_iframe},
1600 {ST_L2_5, EV_L2_T200, l2_st5_tout_200},
1601 {ST_L2_6, EV_L2_T200, l2_st6_tout_200},
1602 {ST_L2_7, EV_L2_T200, l2_st7_tout_200},
1603 {ST_L2_8, EV_L2_T200, l2_st8_tout_200},
1604 {ST_L2_7, EV_L2_T203, l2_st7_tout_203},
1605 {ST_L2_7, EV_L2_ACK_PULL, l2_pull_iqueue},
1606 {ST_L2_7, EV_L2_SET_OWN_BUSY, l2_set_own_busy},
1607 {ST_L2_8, EV_L2_SET_OWN_BUSY, l2_set_own_busy},
1608 {ST_L2_7, EV_L2_CLEAR_OWN_BUSY, l2_clear_own_busy},
1609 {ST_L2_8, EV_L2_CLEAR_OWN_BUSY, l2_clear_own_busy},
1610 {ST_L2_4, EV_L2_FRAME_ERROR, l2_frame_error},
1611 {ST_L2_5, EV_L2_FRAME_ERROR, l2_frame_error},
1612 {ST_L2_6, EV_L2_FRAME_ERROR, l2_frame_error},
1613 {ST_L2_7, EV_L2_FRAME_ERROR, l2_frame_error_reest},
1614 {ST_L2_8, EV_L2_FRAME_ERROR, l2_frame_error_reest},
Jan Engelhardt6b44d4e2006-11-30 05:33:40 +01001615 {ST_L2_1, EV_L1_DEACTIVATE, l2_st14_persistent_da},
Linus Torvalds1da177e2005-04-16 15:20:36 -07001616 {ST_L2_2, EV_L1_DEACTIVATE, l2_st24_tei_remove},
1617 {ST_L2_3, EV_L1_DEACTIVATE, l2_st3_tei_remove},
Jan Engelhardt6b44d4e2006-11-30 05:33:40 +01001618 {ST_L2_4, EV_L1_DEACTIVATE, l2_st14_persistent_da},
1619 {ST_L2_5, EV_L1_DEACTIVATE, l2_st5_persistent_da},
1620 {ST_L2_6, EV_L1_DEACTIVATE, l2_st6_persistent_da},
1621 {ST_L2_7, EV_L1_DEACTIVATE, l2_persistent_da},
1622 {ST_L2_8, EV_L1_DEACTIVATE, l2_persistent_da},
Linus Torvalds1da177e2005-04-16 15:20:36 -07001623};
1624
Linus Torvalds1da177e2005-04-16 15:20:36 -07001625static void
1626isdnl2_l1l2(struct PStack *st, int pr, void *arg)
1627{
1628 struct sk_buff *skb = arg;
1629 u_char *datap;
1630 int ret = 1, len;
1631 int c = 0;
1632
1633 switch (pr) {
1634 case (PH_DATA | INDICATION):
1635 datap = skb->data;
1636 len = l2addrsize(&st->l2);
1637 if (skb->len > len)
1638 datap += len;
1639 else {
1640 FsmEvent(&st->l2.l2m, EV_L2_FRAME_ERROR, (void *) 'N');
Adrian Bunk672c3fd2005-06-25 14:59:18 -07001641 dev_kfree_skb(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001642 return;
1643 }
1644 if (!(*datap & 1)) { /* I-Frame */
1645 if(!(c = iframe_error(st, skb)))
1646 ret = FsmEvent(&st->l2.l2m, EV_L2_I, skb);
1647 } else if (IsSFrame(datap, st)) { /* S-Frame */
1648 if(!(c = super_error(st, skb)))
1649 ret = FsmEvent(&st->l2.l2m, EV_L2_SUPER, skb);
1650 } else if (IsUI(datap)) {
1651 if(!(c = UI_error(st, skb)))
1652 ret = FsmEvent(&st->l2.l2m, EV_L2_UI, skb);
1653 } else if (IsSABME(datap, st)) {
1654 if(!(c = unnum_error(st, skb, CMD)))
1655 ret = FsmEvent(&st->l2.l2m, EV_L2_SABME, skb);
1656 } else if (IsUA(datap)) {
1657 if(!(c = unnum_error(st, skb, RSP)))
1658 ret = FsmEvent(&st->l2.l2m, EV_L2_UA, skb);
1659 } else if (IsDISC(datap)) {
1660 if(!(c = unnum_error(st, skb, CMD)))
1661 ret = FsmEvent(&st->l2.l2m, EV_L2_DISC, skb);
1662 } else if (IsDM(datap)) {
1663 if(!(c = unnum_error(st, skb, RSP)))
1664 ret = FsmEvent(&st->l2.l2m, EV_L2_DM, skb);
1665 } else if (IsFRMR(datap)) {
1666 if(!(c = FRMR_error(st,skb)))
1667 ret = FsmEvent(&st->l2.l2m, EV_L2_FRMR, skb);
1668 } else {
1669 FsmEvent(&st->l2.l2m, EV_L2_FRAME_ERROR, (void *) 'L');
Adrian Bunk672c3fd2005-06-25 14:59:18 -07001670 dev_kfree_skb(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001671 ret = 0;
1672 }
1673 if(c) {
Adrian Bunk672c3fd2005-06-25 14:59:18 -07001674 dev_kfree_skb(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001675 FsmEvent(&st->l2.l2m, EV_L2_FRAME_ERROR, (void *)(long)c);
1676 ret = 0;
1677 }
1678 if (ret)
Adrian Bunk672c3fd2005-06-25 14:59:18 -07001679 dev_kfree_skb(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001680 break;
1681 case (PH_PULL | CONFIRM):
1682 FsmEvent(&st->l2.l2m, EV_L2_ACK_PULL, arg);
1683 break;
1684 case (PH_PAUSE | INDICATION):
1685 test_and_set_bit(FLG_DCHAN_BUSY, &st->l2.flag);
1686 break;
1687 case (PH_PAUSE | CONFIRM):
1688 test_and_clear_bit(FLG_DCHAN_BUSY, &st->l2.flag);
1689 break;
1690 case (PH_ACTIVATE | CONFIRM):
1691 case (PH_ACTIVATE | INDICATION):
1692 test_and_set_bit(FLG_L1_ACTIV, &st->l2.flag);
1693 if (test_and_clear_bit(FLG_ESTAB_PEND, &st->l2.flag))
1694 FsmEvent(&st->l2.l2m, EV_L2_DL_ESTABLISH_REQ, arg);
1695 break;
1696 case (PH_DEACTIVATE | INDICATION):
1697 case (PH_DEACTIVATE | CONFIRM):
1698 test_and_clear_bit(FLG_L1_ACTIV, &st->l2.flag);
1699 FsmEvent(&st->l2.l2m, EV_L1_DEACTIVATE, arg);
1700 break;
1701 default:
1702 l2m_debug(&st->l2.l2m, "l2 unknown pr %04x", pr);
1703 break;
1704 }
1705}
1706
1707static void
1708isdnl2_l3l2(struct PStack *st, int pr, void *arg)
1709{
1710 switch (pr) {
1711 case (DL_DATA | REQUEST):
1712 if (FsmEvent(&st->l2.l2m, EV_L2_DL_DATA, arg)) {
1713 dev_kfree_skb((struct sk_buff *) arg);
1714 }
1715 break;
1716 case (DL_UNIT_DATA | REQUEST):
1717 if (FsmEvent(&st->l2.l2m, EV_L2_DL_UNIT_DATA, arg)) {
1718 dev_kfree_skb((struct sk_buff *) arg);
1719 }
1720 break;
1721 case (DL_ESTABLISH | REQUEST):
1722 if (test_bit(FLG_L1_ACTIV, &st->l2.flag)) {
1723 if (test_bit(FLG_LAPD, &st->l2.flag) ||
1724 test_bit(FLG_ORIG, &st->l2.flag)) {
1725 FsmEvent(&st->l2.l2m, EV_L2_DL_ESTABLISH_REQ, arg);
1726 }
1727 } else {
1728 if (test_bit(FLG_LAPD, &st->l2.flag) ||
1729 test_bit(FLG_ORIG, &st->l2.flag)) {
1730 test_and_set_bit(FLG_ESTAB_PEND, &st->l2.flag);
1731 }
1732 st->l2.l2l1(st, PH_ACTIVATE, NULL);
1733 }
1734 break;
1735 case (DL_RELEASE | REQUEST):
1736 if (test_bit(FLG_LAPB, &st->l2.flag)) {
1737 st->l2.l2l1(st, PH_DEACTIVATE, NULL);
1738 }
1739 FsmEvent(&st->l2.l2m, EV_L2_DL_RELEASE_REQ, arg);
1740 break;
1741 case (MDL_ASSIGN | REQUEST):
1742 FsmEvent(&st->l2.l2m, EV_L2_MDL_ASSIGN, arg);
1743 break;
1744 case (MDL_REMOVE | REQUEST):
1745 FsmEvent(&st->l2.l2m, EV_L2_MDL_REMOVE, arg);
1746 break;
1747 case (MDL_ERROR | RESPONSE):
1748 FsmEvent(&st->l2.l2m, EV_L2_MDL_ERROR, arg);
1749 break;
1750 }
1751}
1752
1753void
1754releasestack_isdnl2(struct PStack *st)
1755{
1756 FsmDelTimer(&st->l2.t200, 21);
1757 FsmDelTimer(&st->l2.t203, 16);
1758 skb_queue_purge(&st->l2.i_queue);
1759 skb_queue_purge(&st->l2.ui_queue);
1760 ReleaseWin(&st->l2);
1761}
1762
1763static void
1764l2m_debug(struct FsmInst *fi, char *fmt, ...)
1765{
1766 va_list args;
1767 struct PStack *st = fi->userdata;
1768
1769 va_start(args, fmt);
1770 VHiSax_putstatus(st->l1.hardware, st->l2.debug_id, fmt, args);
1771 va_end(args);
1772}
1773
1774void
1775setstack_isdnl2(struct PStack *st, char *debug_id)
1776{
1777 spin_lock_init(&st->l2.lock);
1778 st->l1.l1l2 = isdnl2_l1l2;
1779 st->l3.l3l2 = isdnl2_l3l2;
1780
1781 skb_queue_head_init(&st->l2.i_queue);
1782 skb_queue_head_init(&st->l2.ui_queue);
1783 InitWin(&st->l2);
1784 st->l2.debug = 0;
1785
1786 st->l2.l2m.fsm = &l2fsm;
1787 if (test_bit(FLG_LAPB, &st->l2.flag))
1788 st->l2.l2m.state = ST_L2_4;
1789 else
1790 st->l2.l2m.state = ST_L2_1;
1791 st->l2.l2m.debug = 0;
1792 st->l2.l2m.userdata = st;
1793 st->l2.l2m.userint = 0;
1794 st->l2.l2m.printdebug = l2m_debug;
1795 strcpy(st->l2.debug_id, debug_id);
1796
1797 FsmInitTimer(&st->l2.l2m, &st->l2.t200);
1798 FsmInitTimer(&st->l2.l2m, &st->l2.t203);
1799}
1800
1801static void
1802transl2_l3l2(struct PStack *st, int pr, void *arg)
1803{
1804 switch (pr) {
1805 case (DL_DATA | REQUEST):
1806 case (DL_UNIT_DATA | REQUEST):
1807 st->l2.l2l1(st, PH_DATA | REQUEST, arg);
1808 break;
1809 case (DL_ESTABLISH | REQUEST):
1810 st->l2.l2l1(st, PH_ACTIVATE | REQUEST, NULL);
1811 break;
1812 case (DL_RELEASE | REQUEST):
1813 st->l2.l2l1(st, PH_DEACTIVATE | REQUEST, NULL);
1814 break;
1815 }
1816}
1817
1818void
1819setstack_transl2(struct PStack *st)
1820{
1821 st->l3.l3l2 = transl2_l3l2;
1822}
1823
1824void
1825releasestack_transl2(struct PStack *st)
1826{
1827}
1828
1829int __init
1830Isdnl2New(void)
1831{
1832 l2fsm.state_count = L2_STATE_COUNT;
1833 l2fsm.event_count = L2_EVENT_COUNT;
1834 l2fsm.strEvent = strL2Event;
1835 l2fsm.strState = strL2State;
Karsten Keilba2d6cc2009-07-24 18:26:08 +02001836 return FsmNew(&l2fsm, L2FnList, ARRAY_SIZE(L2FnList));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001837}
1838
1839void
1840Isdnl2Free(void)
1841{
1842 FsmFree(&l2fsm);
1843}