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