OpenCores
URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [isdn/] [hisax/] [isdnl2.c] - Blame information for rev 62

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2025 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.