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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [uclinux/] [uClinux-2.0.x/] [drivers/] [isdn/] [hisax/] [isdnl2.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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