1 /* $Id: isdnl2.c,v 2.30.2.4 2004/02/11 13:21:34 keil Exp $
4 * based on the teles driver from Jan den Ouden
5 * Copyright by Karsten Keil <keil@isdn4linux.de>
7 * This software may be used and distributed according to the terms
8 * of the GNU General Public License, incorporated herein by reference.
10 * For changes and modifications please read
11 * Documentation/isdn/HiSax.cert
13 * Thanks to Jan den Ouden
18 #include <linux/init.h>
22 const char *l2_revision
= "$Revision: 2.30.2.4 $";
24 static void l2m_debug(struct FsmInst
*fi
, char *fmt
, ...);
26 static struct Fsm l2fsm
;
39 #define L2_STATE_COUNT (ST_L2_8+1)
41 static char *strL2State
[] =
65 EV_L2_DL_ESTABLISH_REQ
,
78 #define L2_EVENT_COUNT (EV_L2_FRAME_ERROR+1)
80 static char *strL2Event
[] =
93 "EV_L2_DL_ESTABLISH_REQ",
94 "EV_L2_DL_RELEASE_REQ",
101 "EV_L2_SET_OWN_BUSY",
102 "EV_L2_CLEAR_OWN_BUSY",
106 static int l2addrsize(struct Layer2
*l2
);
109 set_peer_busy(struct Layer2
*l2
) {
110 test_and_set_bit(FLG_PEER_BUSY
, &l2
->flag
);
111 if (skb_queue_len(&l2
->i_queue
) || skb_queue_len(&l2
->ui_queue
))
112 test_and_set_bit(FLG_L2BLOCK
, &l2
->flag
);
116 clear_peer_busy(struct Layer2
*l2
) {
117 if (test_and_clear_bit(FLG_PEER_BUSY
, &l2
->flag
))
118 test_and_clear_bit(FLG_L2BLOCK
, &l2
->flag
);
122 InitWin(struct Layer2
*l2
)
126 for (i
= 0; i
< MAX_WINDOW
; i
++)
127 l2
->windowar
[i
] = NULL
;
131 freewin1(struct Layer2
*l2
)
135 for (i
= 0; i
< MAX_WINDOW
; i
++) {
136 if (l2
->windowar
[i
]) {
138 dev_kfree_skb(l2
->windowar
[i
]);
139 l2
->windowar
[i
] = NULL
;
146 freewin(struct PStack
*st
)
152 ReleaseWin(struct Layer2
*l2
)
156 if((cnt
= freewin1(l2
)))
157 printk(KERN_WARNING
"isdl2 freed %d skbuffs in release\n", cnt
);
160 static inline unsigned int
161 cansend(struct PStack
*st
)
165 if(test_bit(FLG_MOD128
, &st
->l2
.flag
))
166 p1
= (st
->l2
.vs
- st
->l2
.va
) % 128;
168 p1
= (st
->l2
.vs
- st
->l2
.va
) % 8;
169 return ((p1
< st
->l2
.window
) && !test_bit(FLG_PEER_BUSY
, &st
->l2
.flag
));
173 clear_exception(struct Layer2
*l2
)
175 test_and_clear_bit(FLG_ACK_PEND
, &l2
->flag
);
176 test_and_clear_bit(FLG_REJEXC
, &l2
->flag
);
177 test_and_clear_bit(FLG_OWN_BUSY
, &l2
->flag
);
182 l2headersize(struct Layer2
*l2
, int ui
)
184 return (((test_bit(FLG_MOD128
, &l2
->flag
) && (!ui
)) ? 2 : 1) +
185 (test_bit(FLG_LAPD
, &l2
->flag
) ? 2 : 1));
189 l2addrsize(struct Layer2
*l2
)
191 return (test_bit(FLG_LAPD
, &l2
->flag
) ? 2 : 1);
195 sethdraddr(struct Layer2
*l2
, u_char
* header
, int rsp
)
197 u_char
*ptr
= header
;
200 if (test_bit(FLG_LAPD
, &l2
->flag
)) {
201 *ptr
++ = (l2
->sap
<< 2) | (rsp
? 2 : 0);
202 *ptr
++ = (l2
->tei
<< 1) | 1;
205 if (test_bit(FLG_ORIG
, &l2
->flag
))
216 enqueue_super(struct PStack
*st
,
219 if (test_bit(FLG_LAPB
, &st
->l2
.flag
))
220 st
->l1
.bcs
->tx_cnt
+= skb
->len
;
221 st
->l2
.l2l1(st
, PH_DATA
| REQUEST
, skb
);
224 #define enqueue_ui(a, b) enqueue_super(a, b)
229 return ((data
[0] & 0xef) == UI
);
235 return ((data
[0] & 0xef) == UA
);
241 return ((data
[0] & 0xef) == DM
);
245 IsDISC(u_char
* data
)
247 return ((data
[0] & 0xef) == DISC
);
251 IsSFrame(u_char
* data
, struct PStack
*st
)
253 register u_char d
= *data
;
255 if (!test_bit(FLG_MOD128
, &st
->l2
.flag
))
257 return(((d
& 0xf3) == 1) && ((d
& 0x0c) != 0x0c));
261 IsSABME(u_char
* data
, struct PStack
*st
)
263 u_char d
= data
[0] & ~0x10;
265 return (test_bit(FLG_MOD128
, &st
->l2
.flag
) ? d
== SABME
: d
== SABM
);
269 IsREJ(u_char
* data
, struct PStack
*st
)
271 return (test_bit(FLG_MOD128
, &st
->l2
.flag
) ? data
[0] == REJ
: (data
[0] & 0xf) == REJ
);
275 IsFRMR(u_char
* data
)
277 return ((data
[0] & 0xef) == FRMR
);
281 IsRNR(u_char
* data
, struct PStack
*st
)
283 return (test_bit(FLG_MOD128
, &st
->l2
.flag
) ? data
[0] == RNR
: (data
[0] & 0xf) == RNR
);
287 iframe_error(struct PStack
*st
, struct sk_buff
*skb
)
289 int i
= l2addrsize(&st
->l2
) + (test_bit(FLG_MOD128
, &st
->l2
.flag
) ? 2 : 1);
290 int rsp
= *skb
->data
& 0x2;
292 if (test_bit(FLG_ORIG
, &st
->l2
.flag
))
302 if ((skb
->len
- i
) > st
->l2
.maxlen
)
310 super_error(struct PStack
*st
, struct sk_buff
*skb
)
312 if (skb
->len
!= l2addrsize(&st
->l2
) +
313 (test_bit(FLG_MOD128
, &st
->l2
.flag
) ? 2 : 1))
320 unnum_error(struct PStack
*st
, struct sk_buff
*skb
, int wantrsp
)
322 int rsp
= (*skb
->data
& 0x2) >> 1;
323 if (test_bit(FLG_ORIG
, &st
->l2
.flag
))
329 if (skb
->len
!= l2addrsize(&st
->l2
) + 1)
336 UI_error(struct PStack
*st
, struct sk_buff
*skb
)
338 int rsp
= *skb
->data
& 0x2;
339 if (test_bit(FLG_ORIG
, &st
->l2
.flag
))
345 if (skb
->len
> st
->l2
.maxlen
+ l2addrsize(&st
->l2
) + 1)
352 FRMR_error(struct PStack
*st
, struct sk_buff
*skb
)
354 int headers
= l2addrsize(&st
->l2
) + 1;
355 u_char
*datap
= skb
->data
+ headers
;
356 int rsp
= *skb
->data
& 0x2;
358 if (test_bit(FLG_ORIG
, &st
->l2
.flag
))
364 if (test_bit(FLG_MOD128
, &st
->l2
.flag
)) {
365 if (skb
->len
< headers
+ 5)
368 l2m_debug(&st
->l2
.l2m
, "FRMR information %2x %2x %2x %2x %2x",
369 datap
[0], datap
[1], datap
[2],
372 if (skb
->len
< headers
+ 3)
375 l2m_debug(&st
->l2
.l2m
, "FRMR information %2x %2x %2x",
376 datap
[0], datap
[1], datap
[2]);
383 legalnr(struct PStack
*st
, unsigned int nr
)
385 struct Layer2
*l2
= &st
->l2
;
387 if(test_bit(FLG_MOD128
, &l2
->flag
))
388 return ((nr
- l2
->va
) % 128) <= ((l2
->vs
- l2
->va
) % 128);
390 return ((nr
- l2
->va
) % 8) <= ((l2
->vs
- l2
->va
) % 8);
394 setva(struct PStack
*st
, unsigned int nr
)
396 struct Layer2
*l2
= &st
->l2
;
400 spin_lock_irqsave(&l2
->lock
, flags
);
401 while (l2
->va
!= nr
) {
403 if(test_bit(FLG_MOD128
, &l2
->flag
))
407 len
= l2
->windowar
[l2
->sow
]->len
;
408 if (PACKET_NOACK
== l2
->windowar
[l2
->sow
]->pkt_type
)
410 dev_kfree_skb(l2
->windowar
[l2
->sow
]);
411 l2
->windowar
[l2
->sow
] = NULL
;
412 l2
->sow
= (l2
->sow
+ 1) % l2
->window
;
413 spin_unlock_irqrestore(&l2
->lock
, flags
);
414 if (test_bit(FLG_LLI_L2WAKEUP
, &st
->lli
.flag
) && (len
>=0))
415 lli_writewakeup(st
, len
);
416 spin_lock_irqsave(&l2
->lock
, flags
);
418 spin_unlock_irqrestore(&l2
->lock
, flags
);
422 send_uframe(struct PStack
*st
, u_char cmd
, u_char cr
)
425 u_char tmp
[MAX_HEADER_LEN
];
428 i
= sethdraddr(&st
->l2
, tmp
, cr
);
430 if (!(skb
= alloc_skb(i
, GFP_ATOMIC
))) {
431 printk(KERN_WARNING
"isdl2 can't alloc sbbuff for send_uframe\n");
434 memcpy(skb_put(skb
, i
), tmp
, i
);
435 enqueue_super(st
, skb
);
439 get_PollFlag(struct PStack
* st
, struct sk_buff
* skb
)
441 return (skb
->data
[l2addrsize(&(st
->l2
))] & 0x10);
445 get_PollFlagFree(struct PStack
*st
, struct sk_buff
*skb
)
449 PF
= get_PollFlag(st
, skb
);
455 start_t200(struct PStack
*st
, int i
)
457 FsmAddTimer(&st
->l2
.t200
, st
->l2
.T200
, EV_L2_T200
, NULL
, i
);
458 test_and_set_bit(FLG_T200_RUN
, &st
->l2
.flag
);
462 restart_t200(struct PStack
*st
, int i
)
464 FsmRestartTimer(&st
->l2
.t200
, st
->l2
.T200
, EV_L2_T200
, NULL
, i
);
465 test_and_set_bit(FLG_T200_RUN
, &st
->l2
.flag
);
469 stop_t200(struct PStack
*st
, int i
)
471 if(test_and_clear_bit(FLG_T200_RUN
, &st
->l2
.flag
))
472 FsmDelTimer(&st
->l2
.t200
, i
);
476 st5_dl_release_l2l3(struct PStack
*st
)
480 if(test_and_clear_bit(FLG_PEND_REL
, &st
->l2
.flag
))
481 pr
= DL_RELEASE
| CONFIRM
;
483 pr
= DL_RELEASE
| INDICATION
;
485 st
->l2
.l2l3(st
, pr
, NULL
);
489 lapb_dl_release_l2l3(struct PStack
*st
, int f
)
491 if (test_bit(FLG_LAPB
, &st
->l2
.flag
))
492 st
->l2
.l2l1(st
, PH_DEACTIVATE
| REQUEST
, NULL
);
493 st
->l2
.l2l3(st
, DL_RELEASE
| f
, NULL
);
497 establishlink(struct FsmInst
*fi
)
499 struct PStack
*st
= fi
->userdata
;
502 clear_exception(&st
->l2
);
504 cmd
= (test_bit(FLG_MOD128
, &st
->l2
.flag
) ? SABME
: SABM
) | 0x10;
505 send_uframe(st
, cmd
, CMD
);
506 FsmDelTimer(&st
->l2
.t203
, 1);
508 test_and_clear_bit(FLG_PEND_REL
, &st
->l2
.flag
);
510 FsmChangeState(fi
, ST_L2_5
);
514 l2_mdl_error_ua(struct FsmInst
*fi
, int event
, void *arg
)
516 struct sk_buff
*skb
= arg
;
517 struct PStack
*st
= fi
->userdata
;
519 if (get_PollFlagFree(st
, skb
))
520 st
->ma
.layer(st
, MDL_ERROR
| INDICATION
, (void *) 'C');
522 st
->ma
.layer(st
, MDL_ERROR
| INDICATION
, (void *) 'D');
526 l2_mdl_error_dm(struct FsmInst
*fi
, int event
, void *arg
)
528 struct sk_buff
*skb
= arg
;
529 struct PStack
*st
= fi
->userdata
;
531 if (get_PollFlagFree(st
, skb
))
532 st
->ma
.layer(st
, MDL_ERROR
| INDICATION
, (void *) 'B');
534 st
->ma
.layer(st
, MDL_ERROR
| INDICATION
, (void *) 'E');
536 test_and_clear_bit(FLG_L3_INIT
, &st
->l2
.flag
);
541 l2_st8_mdl_error_dm(struct FsmInst
*fi
, int event
, void *arg
)
543 struct sk_buff
*skb
= arg
;
544 struct PStack
*st
= fi
->userdata
;
546 if (get_PollFlagFree(st
, skb
))
547 st
->ma
.layer(st
, MDL_ERROR
| INDICATION
, (void *) 'B');
549 st
->ma
.layer(st
, MDL_ERROR
| INDICATION
, (void *) 'E');
552 test_and_clear_bit(FLG_L3_INIT
, &st
->l2
.flag
);
556 l2_go_st3(struct FsmInst
*fi
, int event
, void *arg
)
558 FsmChangeState(fi
, ST_L2_3
);
562 l2_mdl_assign(struct FsmInst
*fi
, int event
, void *arg
)
564 struct PStack
*st
= fi
->userdata
;
566 FsmChangeState(fi
, ST_L2_3
);
567 st
->l2
.l2tei(st
, MDL_ASSIGN
| INDICATION
, NULL
);
571 l2_queue_ui_assign(struct FsmInst
*fi
, int event
, void *arg
)
573 struct PStack
*st
= fi
->userdata
;
574 struct sk_buff
*skb
= arg
;
576 skb_queue_tail(&st
->l2
.ui_queue
, skb
);
577 FsmChangeState(fi
, ST_L2_2
);
578 st
->l2
.l2tei(st
, MDL_ASSIGN
| INDICATION
, NULL
);
582 l2_queue_ui(struct FsmInst
*fi
, int event
, void *arg
)
584 struct PStack
*st
= fi
->userdata
;
585 struct sk_buff
*skb
= arg
;
587 skb_queue_tail(&st
->l2
.ui_queue
, skb
);
591 tx_ui(struct PStack
*st
)
594 u_char header
[MAX_HEADER_LEN
];
597 i
= sethdraddr(&(st
->l2
), header
, CMD
);
599 while ((skb
= skb_dequeue(&st
->l2
.ui_queue
))) {
600 memcpy(skb_push(skb
, i
), header
, i
);
606 l2_send_ui(struct FsmInst
*fi
, int event
, void *arg
)
608 struct PStack
*st
= fi
->userdata
;
609 struct sk_buff
*skb
= arg
;
611 skb_queue_tail(&st
->l2
.ui_queue
, skb
);
616 l2_got_ui(struct FsmInst
*fi
, int event
, void *arg
)
618 struct PStack
*st
= fi
->userdata
;
619 struct sk_buff
*skb
= arg
;
621 skb_pull(skb
, l2headersize(&st
->l2
, 1));
622 st
->l2
.l2l3(st
, DL_UNIT_DATA
| INDICATION
, skb
);
623 /* ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
624 * in states 1-3 for broadcast
631 l2_establish(struct FsmInst
*fi
, int event
, void *arg
)
633 struct PStack
*st
= fi
->userdata
;
636 test_and_set_bit(FLG_L3_INIT
, &st
->l2
.flag
);
640 l2_discard_i_setl3(struct FsmInst
*fi
, int event
, void *arg
)
642 struct PStack
*st
= fi
->userdata
;
644 skb_queue_purge(&st
->l2
.i_queue
);
645 test_and_set_bit(FLG_L3_INIT
, &st
->l2
.flag
);
646 test_and_clear_bit(FLG_PEND_REL
, &st
->l2
.flag
);
650 l2_l3_reestablish(struct FsmInst
*fi
, int event
, void *arg
)
652 struct PStack
*st
= fi
->userdata
;
654 skb_queue_purge(&st
->l2
.i_queue
);
656 test_and_set_bit(FLG_L3_INIT
, &st
->l2
.flag
);
660 l2_release(struct FsmInst
*fi
, int event
, void *arg
)
662 struct PStack
*st
= fi
->userdata
;
664 st
->l2
.l2l3(st
, DL_RELEASE
| CONFIRM
, NULL
);
668 l2_pend_rel(struct FsmInst
*fi
, int event
, void *arg
)
670 struct PStack
*st
= fi
->userdata
;
672 test_and_set_bit(FLG_PEND_REL
, &st
->l2
.flag
);
676 l2_disconnect(struct FsmInst
*fi
, int event
, void *arg
)
678 struct PStack
*st
= fi
->userdata
;
680 skb_queue_purge(&st
->l2
.i_queue
);
682 FsmChangeState(fi
, ST_L2_6
);
684 send_uframe(st
, DISC
| 0x10, CMD
);
685 FsmDelTimer(&st
->l2
.t203
, 1);
690 l2_start_multi(struct FsmInst
*fi
, int event
, void *arg
)
692 struct PStack
*st
= fi
->userdata
;
693 struct sk_buff
*skb
= arg
;
695 send_uframe(st
, UA
| get_PollFlagFree(st
, skb
), RSP
);
697 clear_exception(&st
->l2
);
702 FsmChangeState(fi
, ST_L2_7
);
703 FsmAddTimer(&st
->l2
.t203
, st
->l2
.T203
, EV_L2_T203
, NULL
, 3);
705 st
->l2
.l2l3(st
, DL_ESTABLISH
| INDICATION
, NULL
);
709 l2_send_UA(struct FsmInst
*fi
, int event
, void *arg
)
711 struct PStack
*st
= fi
->userdata
;
712 struct sk_buff
*skb
= arg
;
714 send_uframe(st
, UA
| get_PollFlagFree(st
, skb
), RSP
);
718 l2_send_DM(struct FsmInst
*fi
, int event
, void *arg
)
720 struct PStack
*st
= fi
->userdata
;
721 struct sk_buff
*skb
= arg
;
723 send_uframe(st
, DM
| get_PollFlagFree(st
, skb
), RSP
);
727 l2_restart_multi(struct FsmInst
*fi
, int event
, void *arg
)
729 struct PStack
*st
= fi
->userdata
;
730 struct sk_buff
*skb
= arg
;
735 send_uframe(st
, UA
| get_PollFlagFree(st
, skb
), RSP
);
737 st
->ma
.layer(st
, MDL_ERROR
| INDICATION
, (void *) 'F');
739 if (st
->l2
.vs
!= st
->l2
.va
) {
740 skb_queue_purge(&st
->l2
.i_queue
);
744 clear_exception(&st
->l2
);
749 FsmChangeState(fi
, ST_L2_7
);
751 FsmRestartTimer(&st
->l2
.t203
, st
->l2
.T203
, EV_L2_T203
, NULL
, 3);
754 st
->l2
.l2l3(st
, DL_ESTABLISH
| INDICATION
, NULL
);
756 if ((ST_L2_7
==state
) || (ST_L2_8
== state
))
757 if (skb_queue_len(&st
->l2
.i_queue
) && cansend(st
))
758 st
->l2
.l2l1(st
, PH_PULL
| REQUEST
, NULL
);
762 l2_stop_multi(struct FsmInst
*fi
, int event
, void *arg
)
764 struct PStack
*st
= fi
->userdata
;
765 struct sk_buff
*skb
= arg
;
767 FsmChangeState(fi
, ST_L2_4
);
768 FsmDelTimer(&st
->l2
.t203
, 3);
771 send_uframe(st
, UA
| get_PollFlagFree(st
, skb
), RSP
);
773 skb_queue_purge(&st
->l2
.i_queue
);
775 lapb_dl_release_l2l3(st
, INDICATION
);
779 l2_connected(struct FsmInst
*fi
, int event
, void *arg
)
781 struct PStack
*st
= fi
->userdata
;
782 struct sk_buff
*skb
= arg
;
785 if (!get_PollFlag(st
, skb
)) {
786 l2_mdl_error_ua(fi
, event
, arg
);
791 if (test_and_clear_bit(FLG_PEND_REL
, &st
->l2
.flag
))
792 l2_disconnect(fi
, event
, arg
);
794 if (test_and_clear_bit(FLG_L3_INIT
, &st
->l2
.flag
)) {
795 pr
= DL_ESTABLISH
| CONFIRM
;
796 } else if (st
->l2
.vs
!= st
->l2
.va
) {
797 skb_queue_purge(&st
->l2
.i_queue
);
798 pr
= DL_ESTABLISH
| INDICATION
;
807 FsmChangeState(fi
, ST_L2_7
);
808 FsmAddTimer(&st
->l2
.t203
, st
->l2
.T203
, EV_L2_T203
, NULL
, 4);
811 st
->l2
.l2l3(st
, pr
, NULL
);
813 if (skb_queue_len(&st
->l2
.i_queue
) && cansend(st
))
814 st
->l2
.l2l1(st
, PH_PULL
| REQUEST
, NULL
);
818 l2_released(struct FsmInst
*fi
, int event
, void *arg
)
820 struct PStack
*st
= fi
->userdata
;
821 struct sk_buff
*skb
= arg
;
823 if (!get_PollFlag(st
, skb
)) {
824 l2_mdl_error_ua(fi
, event
, arg
);
830 lapb_dl_release_l2l3(st
, CONFIRM
);
831 FsmChangeState(fi
, ST_L2_4
);
835 l2_reestablish(struct FsmInst
*fi
, int event
, void *arg
)
837 struct PStack
*st
= fi
->userdata
;
838 struct sk_buff
*skb
= arg
;
840 if (!get_PollFlagFree(st
, skb
)) {
842 test_and_set_bit(FLG_L3_INIT
, &st
->l2
.flag
);
847 l2_st5_dm_release(struct FsmInst
*fi
, int event
, void *arg
)
849 struct PStack
*st
= fi
->userdata
;
850 struct sk_buff
*skb
= arg
;
852 if (get_PollFlagFree(st
, skb
)) {
854 if (!test_bit(FLG_L3_INIT
, &st
->l2
.flag
))
855 skb_queue_purge(&st
->l2
.i_queue
);
856 if (test_bit(FLG_LAPB
, &st
->l2
.flag
))
857 st
->l2
.l2l1(st
, PH_DEACTIVATE
| REQUEST
, NULL
);
858 st5_dl_release_l2l3(st
);
859 FsmChangeState(fi
, ST_L2_4
);
864 l2_st6_dm_release(struct FsmInst
*fi
, int event
, void *arg
)
866 struct PStack
*st
= fi
->userdata
;
867 struct sk_buff
*skb
= arg
;
869 if (get_PollFlagFree(st
, skb
)) {
871 lapb_dl_release_l2l3(st
, CONFIRM
);
872 FsmChangeState(fi
, ST_L2_4
);
877 enquiry_cr(struct PStack
*st
, u_char typ
, u_char cr
, u_char pf
)
881 u_char tmp
[MAX_HEADER_LEN
];
885 i
= sethdraddr(l2
, tmp
, cr
);
886 if (test_bit(FLG_MOD128
, &l2
->flag
)) {
888 tmp
[i
++] = (l2
->vr
<< 1) | (pf
? 1 : 0);
890 tmp
[i
++] = (l2
->vr
<< 5) | typ
| (pf
? 0x10 : 0);
891 if (!(skb
= alloc_skb(i
, GFP_ATOMIC
))) {
892 printk(KERN_WARNING
"isdl2 can't alloc sbbuff for enquiry_cr\n");
895 memcpy(skb_put(skb
, i
), tmp
, i
);
896 enqueue_super(st
, skb
);
900 enquiry_response(struct PStack
*st
)
902 if (test_bit(FLG_OWN_BUSY
, &st
->l2
.flag
))
903 enquiry_cr(st
, RNR
, RSP
, 1);
905 enquiry_cr(st
, RR
, RSP
, 1);
906 test_and_clear_bit(FLG_ACK_PEND
, &st
->l2
.flag
);
910 transmit_enquiry(struct PStack
*st
)
912 if (test_bit(FLG_OWN_BUSY
, &st
->l2
.flag
))
913 enquiry_cr(st
, RNR
, CMD
, 1);
915 enquiry_cr(st
, RR
, CMD
, 1);
916 test_and_clear_bit(FLG_ACK_PEND
, &st
->l2
.flag
);
922 nrerrorrecovery(struct FsmInst
*fi
)
924 struct PStack
*st
= fi
->userdata
;
926 st
->ma
.layer(st
, MDL_ERROR
| INDICATION
, (void *) 'J');
928 test_and_clear_bit(FLG_L3_INIT
, &st
->l2
.flag
);
932 invoke_retransmission(struct PStack
*st
, unsigned int nr
)
934 struct Layer2
*l2
= &st
->l2
;
938 spin_lock_irqsave(&l2
->lock
, flags
);
940 while (l2
->vs
!= nr
) {
942 if(test_bit(FLG_MOD128
, &l2
->flag
)) {
944 p1
= (l2
->vs
- l2
->va
) % 128;
947 p1
= (l2
->vs
- l2
->va
) % 8;
949 p1
= (p1
+ l2
->sow
) % l2
->window
;
950 if (test_bit(FLG_LAPB
, &l2
->flag
))
951 st
->l1
.bcs
->tx_cnt
+= l2
->windowar
[p1
]->len
+ l2headersize(l2
, 0);
952 skb_queue_head(&l2
->i_queue
, l2
->windowar
[p1
]);
953 l2
->windowar
[p1
] = NULL
;
955 spin_unlock_irqrestore(&l2
->lock
, flags
);
956 st
->l2
.l2l1(st
, PH_PULL
| REQUEST
, NULL
);
959 spin_unlock_irqrestore(&l2
->lock
, flags
);
963 l2_st7_got_super(struct FsmInst
*fi
, int event
, void *arg
)
965 struct PStack
*st
= fi
->userdata
;
966 struct sk_buff
*skb
= arg
;
967 int PollFlag
, rsp
, typ
= RR
;
969 struct Layer2
*l2
= &st
->l2
;
971 rsp
= *skb
->data
& 0x2;
972 if (test_bit(FLG_ORIG
, &l2
->flag
))
975 skb_pull(skb
, l2addrsize(l2
));
976 if (IsRNR(skb
->data
, st
)) {
981 if (IsREJ(skb
->data
, st
))
984 if (test_bit(FLG_MOD128
, &l2
->flag
)) {
985 PollFlag
= (skb
->data
[1] & 0x1) == 0x1;
986 nr
= skb
->data
[1] >> 1;
988 PollFlag
= (skb
->data
[0] & 0x10);
989 nr
= (skb
->data
[0] >> 5) & 0x7;
995 st
->ma
.layer(st
, MDL_ERROR
| INDICATION
, (void *) 'A');
997 enquiry_response(st
);
999 if (legalnr(st
, nr
)) {
1002 invoke_retransmission(st
, nr
);
1004 if (FsmAddTimer(&st
->l2
.t203
, st
->l2
.T203
,
1005 EV_L2_T203
, NULL
, 6))
1006 l2m_debug(&st
->l2
.l2m
, "Restart T203 ST7 REJ");
1007 } else if ((nr
== l2
->vs
) && (typ
== RR
)) {
1010 FsmRestartTimer(&st
->l2
.t203
, st
->l2
.T203
,
1011 EV_L2_T203
, NULL
, 7);
1012 } else if ((l2
->va
!= nr
) || (typ
== RNR
)) {
1014 if(typ
!= RR
) FsmDelTimer(&st
->l2
.t203
, 9);
1015 restart_t200(st
, 12);
1017 if (skb_queue_len(&st
->l2
.i_queue
) && (typ
== RR
))
1018 st
->l2
.l2l1(st
, PH_PULL
| REQUEST
, NULL
);
1020 nrerrorrecovery(fi
);
1024 l2_feed_i_if_reest(struct FsmInst
*fi
, int event
, void *arg
)
1026 struct PStack
*st
= fi
->userdata
;
1027 struct sk_buff
*skb
= arg
;
1029 if (test_bit(FLG_LAPB
, &st
->l2
.flag
))
1030 st
->l1
.bcs
->tx_cnt
+= skb
->len
+ l2headersize(&st
->l2
, 0);
1031 if (!test_bit(FLG_L3_INIT
, &st
->l2
.flag
))
1032 skb_queue_tail(&st
->l2
.i_queue
, skb
);
1038 l2_feed_i_pull(struct FsmInst
*fi
, int event
, void *arg
)
1040 struct PStack
*st
= fi
->userdata
;
1041 struct sk_buff
*skb
= arg
;
1043 if (test_bit(FLG_LAPB
, &st
->l2
.flag
))
1044 st
->l1
.bcs
->tx_cnt
+= skb
->len
+ l2headersize(&st
->l2
, 0);
1045 skb_queue_tail(&st
->l2
.i_queue
, skb
);
1046 st
->l2
.l2l1(st
, PH_PULL
| REQUEST
, NULL
);
1050 l2_feed_iqueue(struct FsmInst
*fi
, int event
, void *arg
)
1052 struct PStack
*st
= fi
->userdata
;
1053 struct sk_buff
*skb
= arg
;
1055 if (test_bit(FLG_LAPB
, &st
->l2
.flag
))
1056 st
->l1
.bcs
->tx_cnt
+= skb
->len
+ l2headersize(&st
->l2
, 0);
1057 skb_queue_tail(&st
->l2
.i_queue
, skb
);
1061 l2_got_iframe(struct FsmInst
*fi
, int event
, void *arg
)
1063 struct PStack
*st
= fi
->userdata
;
1064 struct sk_buff
*skb
= arg
;
1065 struct Layer2
*l2
= &(st
->l2
);
1066 int PollFlag
, ns
, i
;
1070 if (test_bit(FLG_MOD128
, &l2
->flag
)) {
1071 PollFlag
= ((skb
->data
[i
+ 1] & 0x1) == 0x1);
1072 ns
= skb
->data
[i
] >> 1;
1073 nr
= (skb
->data
[i
+ 1] >> 1) & 0x7f;
1075 PollFlag
= (skb
->data
[i
] & 0x10);
1076 ns
= (skb
->data
[i
] >> 1) & 0x7;
1077 nr
= (skb
->data
[i
] >> 5) & 0x7;
1079 if (test_bit(FLG_OWN_BUSY
, &l2
->flag
)) {
1081 if(PollFlag
) enquiry_response(st
);
1082 } else if (l2
->vr
== ns
) {
1084 if(test_bit(FLG_MOD128
, &l2
->flag
))
1088 test_and_clear_bit(FLG_REJEXC
, &l2
->flag
);
1091 enquiry_response(st
);
1093 test_and_set_bit(FLG_ACK_PEND
, &l2
->flag
);
1094 skb_pull(skb
, l2headersize(l2
, 0));
1095 st
->l2
.l2l3(st
, DL_DATA
| INDICATION
, skb
);
1099 if (test_and_set_bit(FLG_REJEXC
, &l2
->flag
)) {
1101 enquiry_response(st
);
1103 enquiry_cr(st
, REJ
, RSP
, PollFlag
);
1104 test_and_clear_bit(FLG_ACK_PEND
, &l2
->flag
);
1108 if (legalnr(st
, nr
)) {
1109 if (!test_bit(FLG_PEER_BUSY
, &st
->l2
.flag
) && (fi
->state
== ST_L2_7
)) {
1110 if (nr
== st
->l2
.vs
) {
1112 FsmRestartTimer(&st
->l2
.t203
, st
->l2
.T203
,
1113 EV_L2_T203
, NULL
, 7);
1114 } else if (nr
!= st
->l2
.va
)
1115 restart_t200(st
, 14);
1119 nrerrorrecovery(fi
);
1123 if (skb_queue_len(&st
->l2
.i_queue
) && (fi
->state
== ST_L2_7
))
1124 st
->l2
.l2l1(st
, PH_PULL
| REQUEST
, NULL
);
1125 if (test_and_clear_bit(FLG_ACK_PEND
, &st
->l2
.flag
))
1126 enquiry_cr(st
, RR
, RSP
, 0);
1130 l2_got_tei(struct FsmInst
*fi
, int event
, void *arg
)
1132 struct PStack
*st
= fi
->userdata
;
1134 st
->l2
.tei
= (long) arg
;
1136 if (fi
->state
== ST_L2_3
) {
1138 test_and_set_bit(FLG_L3_INIT
, &st
->l2
.flag
);
1140 FsmChangeState(fi
, ST_L2_4
);
1141 if (skb_queue_len(&st
->l2
.ui_queue
))
1146 l2_st5_tout_200(struct FsmInst
*fi
, int event
, void *arg
)
1148 struct PStack
*st
= fi
->userdata
;
1150 if (test_bit(FLG_LAPD
, &st
->l2
.flag
) &&
1151 test_bit(FLG_DCHAN_BUSY
, &st
->l2
.flag
)) {
1152 FsmAddTimer(&st
->l2
.t200
, st
->l2
.T200
, EV_L2_T200
, NULL
, 9);
1153 } else if (st
->l2
.rc
== st
->l2
.N200
) {
1154 FsmChangeState(fi
, ST_L2_4
);
1155 test_and_clear_bit(FLG_T200_RUN
, &st
->l2
.flag
);
1156 skb_queue_purge(&st
->l2
.i_queue
);
1157 st
->ma
.layer(st
, MDL_ERROR
| INDICATION
, (void *) 'G');
1158 if (test_bit(FLG_LAPB
, &st
->l2
.flag
))
1159 st
->l2
.l2l1(st
, PH_DEACTIVATE
| REQUEST
, NULL
);
1160 st5_dl_release_l2l3(st
);
1163 FsmAddTimer(&st
->l2
.t200
, st
->l2
.T200
, EV_L2_T200
, NULL
, 9);
1164 send_uframe(st
, (test_bit(FLG_MOD128
, &st
->l2
.flag
) ? SABME
: SABM
)
1170 l2_st6_tout_200(struct FsmInst
*fi
, int event
, void *arg
)
1172 struct PStack
*st
= fi
->userdata
;
1174 if (test_bit(FLG_LAPD
, &st
->l2
.flag
) &&
1175 test_bit(FLG_DCHAN_BUSY
, &st
->l2
.flag
)) {
1176 FsmAddTimer(&st
->l2
.t200
, st
->l2
.T200
, EV_L2_T200
, NULL
, 9);
1177 } else if (st
->l2
.rc
== st
->l2
.N200
) {
1178 FsmChangeState(fi
, ST_L2_4
);
1179 test_and_clear_bit(FLG_T200_RUN
, &st
->l2
.flag
);
1180 st
->ma
.layer(st
, MDL_ERROR
| INDICATION
, (void *) 'H');
1181 lapb_dl_release_l2l3(st
, CONFIRM
);
1184 FsmAddTimer(&st
->l2
.t200
, st
->l2
.T200
, EV_L2_T200
,
1186 send_uframe(st
, DISC
| 0x10, CMD
);
1191 l2_st7_tout_200(struct FsmInst
*fi
, int event
, void *arg
)
1193 struct PStack
*st
= fi
->userdata
;
1195 if (test_bit(FLG_LAPD
, &st
->l2
.flag
) &&
1196 test_bit(FLG_DCHAN_BUSY
, &st
->l2
.flag
)) {
1197 FsmAddTimer(&st
->l2
.t200
, st
->l2
.T200
, EV_L2_T200
, NULL
, 9);
1200 test_and_clear_bit(FLG_T200_RUN
, &st
->l2
.flag
);
1202 FsmChangeState(fi
, ST_L2_8
);
1204 transmit_enquiry(st
);
1209 l2_st8_tout_200(struct FsmInst
*fi
, int event
, void *arg
)
1211 struct PStack
*st
= fi
->userdata
;
1213 if (test_bit(FLG_LAPD
, &st
->l2
.flag
) &&
1214 test_bit(FLG_DCHAN_BUSY
, &st
->l2
.flag
)) {
1215 FsmAddTimer(&st
->l2
.t200
, st
->l2
.T200
, EV_L2_T200
, NULL
, 9);
1218 test_and_clear_bit(FLG_T200_RUN
, &st
->l2
.flag
);
1219 if (st
->l2
.rc
== st
->l2
.N200
) {
1220 st
->ma
.layer(st
, MDL_ERROR
| INDICATION
, (void *) 'I');
1222 test_and_clear_bit(FLG_L3_INIT
, &st
->l2
.flag
);
1224 transmit_enquiry(st
);
1230 l2_st7_tout_203(struct FsmInst
*fi
, int event
, void *arg
)
1232 struct PStack
*st
= fi
->userdata
;
1234 if (test_bit(FLG_LAPD
, &st
->l2
.flag
) &&
1235 test_bit(FLG_DCHAN_BUSY
, &st
->l2
.flag
)) {
1236 FsmAddTimer(&st
->l2
.t203
, st
->l2
.T203
, EV_L2_T203
, NULL
, 9);
1239 FsmChangeState(fi
, ST_L2_8
);
1240 transmit_enquiry(st
);
1245 l2_pull_iqueue(struct FsmInst
*fi
, int event
, void *arg
)
1247 struct PStack
*st
= fi
->userdata
;
1248 struct sk_buff
*skb
, *oskb
;
1249 struct Layer2
*l2
= &st
->l2
;
1250 u_char header
[MAX_HEADER_LEN
];
1258 skb
= skb_dequeue(&l2
->i_queue
);
1262 spin_lock_irqsave(&l2
->lock
, flags
);
1263 if(test_bit(FLG_MOD128
, &l2
->flag
))
1264 p1
= (l2
->vs
- l2
->va
) % 128;
1266 p1
= (l2
->vs
- l2
->va
) % 8;
1267 p1
= (p1
+ l2
->sow
) % l2
->window
;
1268 if (l2
->windowar
[p1
]) {
1269 printk(KERN_WARNING
"isdnl2 try overwrite ack queue entry %d\n",
1271 dev_kfree_skb(l2
->windowar
[p1
]);
1273 l2
->windowar
[p1
] = skb_clone(skb
, GFP_ATOMIC
);
1275 i
= sethdraddr(&st
->l2
, header
, CMD
);
1277 if (test_bit(FLG_MOD128
, &l2
->flag
)) {
1278 header
[i
++] = l2
->vs
<< 1;
1279 header
[i
++] = l2
->vr
<< 1;
1280 l2
->vs
= (l2
->vs
+ 1) % 128;
1282 header
[i
++] = (l2
->vr
<< 5) | (l2
->vs
<< 1);
1283 l2
->vs
= (l2
->vs
+ 1) % 8;
1285 spin_unlock_irqrestore(&l2
->lock
, flags
);
1286 p1
= skb
->data
- skb
->head
;
1288 memcpy(skb_push(skb
, i
), header
, i
);
1291 "isdl2 pull_iqueue skb header(%d/%d) too short\n", i
, p1
);
1293 skb
= alloc_skb(oskb
->len
+ i
, GFP_ATOMIC
);
1294 memcpy(skb_put(skb
, i
), header
, i
);
1295 memcpy(skb_put(skb
, oskb
->len
), oskb
->data
, oskb
->len
);
1296 dev_kfree_skb(oskb
);
1298 st
->l2
.l2l1(st
, PH_PULL
| INDICATION
, skb
);
1299 test_and_clear_bit(FLG_ACK_PEND
, &st
->l2
.flag
);
1300 if (!test_and_set_bit(FLG_T200_RUN
, &st
->l2
.flag
)) {
1301 FsmDelTimer(&st
->l2
.t203
, 13);
1302 FsmAddTimer(&st
->l2
.t200
, st
->l2
.T200
, EV_L2_T200
, NULL
, 11);
1304 if (skb_queue_len(&l2
->i_queue
) && cansend(st
))
1305 st
->l2
.l2l1(st
, PH_PULL
| REQUEST
, NULL
);
1309 l2_st8_got_super(struct FsmInst
*fi
, int event
, void *arg
)
1311 struct PStack
*st
= fi
->userdata
;
1312 struct sk_buff
*skb
= arg
;
1313 int PollFlag
, rsp
, rnr
= 0;
1315 struct Layer2
*l2
= &st
->l2
;
1317 rsp
= *skb
->data
& 0x2;
1318 if (test_bit(FLG_ORIG
, &l2
->flag
))
1321 skb_pull(skb
, l2addrsize(l2
));
1323 if (IsRNR(skb
->data
, st
)) {
1327 clear_peer_busy(l2
);
1329 if (test_bit(FLG_MOD128
, &l2
->flag
)) {
1330 PollFlag
= (skb
->data
[1] & 0x1) == 0x1;
1331 nr
= skb
->data
[1] >> 1;
1333 PollFlag
= (skb
->data
[0] & 0x10);
1334 nr
= (skb
->data
[0] >> 5) & 0x7;
1338 if (rsp
&& PollFlag
) {
1339 if (legalnr(st
, nr
)) {
1341 restart_t200(st
, 15);
1344 FsmAddTimer(&l2
->t203
, l2
->T203
,
1345 EV_L2_T203
, NULL
, 5);
1348 invoke_retransmission(st
, nr
);
1349 FsmChangeState(fi
, ST_L2_7
);
1350 if (skb_queue_len(&l2
->i_queue
) && cansend(st
))
1351 st
->l2
.l2l1(st
, PH_PULL
| REQUEST
, NULL
);
1353 nrerrorrecovery(fi
);
1355 if (!rsp
&& PollFlag
)
1356 enquiry_response(st
);
1357 if (legalnr(st
, nr
)) {
1360 nrerrorrecovery(fi
);
1365 l2_got_FRMR(struct FsmInst
*fi
, int event
, void *arg
)
1367 struct PStack
*st
= fi
->userdata
;
1368 struct sk_buff
*skb
= arg
;
1370 skb_pull(skb
, l2addrsize(&st
->l2
) + 1);
1372 if (!(skb
->data
[0] & 1) || ((skb
->data
[0] & 3) == 1) || /* I or S */
1373 (IsUA(skb
->data
) && (fi
->state
== ST_L2_7
))) {
1374 st
->ma
.layer(st
, MDL_ERROR
| INDICATION
, (void *) 'K');
1376 test_and_clear_bit(FLG_L3_INIT
, &st
->l2
.flag
);
1382 l2_st24_tei_remove(struct FsmInst
*fi
, int event
, void *arg
)
1384 struct PStack
*st
= fi
->userdata
;
1386 skb_queue_purge(&st
->l2
.ui_queue
);
1388 FsmChangeState(fi
, ST_L2_1
);
1392 l2_st3_tei_remove(struct FsmInst
*fi
, int event
, void *arg
)
1394 struct PStack
*st
= fi
->userdata
;
1396 skb_queue_purge(&st
->l2
.ui_queue
);
1398 st
->l2
.l2l3(st
, DL_RELEASE
| INDICATION
, NULL
);
1399 FsmChangeState(fi
, ST_L2_1
);
1403 l2_st5_tei_remove(struct FsmInst
*fi
, int event
, void *arg
)
1405 struct PStack
*st
= fi
->userdata
;
1407 skb_queue_purge(&st
->l2
.i_queue
);
1408 skb_queue_purge(&st
->l2
.ui_queue
);
1412 st5_dl_release_l2l3(st
);
1413 FsmChangeState(fi
, ST_L2_1
);
1417 l2_st6_tei_remove(struct FsmInst
*fi
, int event
, void *arg
)
1419 struct PStack
*st
= fi
->userdata
;
1421 skb_queue_purge(&st
->l2
.ui_queue
);
1424 st
->l2
.l2l3(st
, DL_RELEASE
| CONFIRM
, NULL
);
1425 FsmChangeState(fi
, ST_L2_1
);
1429 l2_tei_remove(struct FsmInst
*fi
, int event
, void *arg
)
1431 struct PStack
*st
= fi
->userdata
;
1433 skb_queue_purge(&st
->l2
.i_queue
);
1434 skb_queue_purge(&st
->l2
.ui_queue
);
1438 FsmDelTimer(&st
->l2
.t203
, 19);
1439 st
->l2
.l2l3(st
, DL_RELEASE
| INDICATION
, NULL
);
1440 FsmChangeState(fi
, ST_L2_1
);
1444 l2_st14_persistant_da(struct FsmInst
*fi
, int event
, void *arg
)
1446 struct PStack
*st
= fi
->userdata
;
1448 skb_queue_purge(&st
->l2
.i_queue
);
1449 skb_queue_purge(&st
->l2
.ui_queue
);
1450 if (test_and_clear_bit(FLG_ESTAB_PEND
, &st
->l2
.flag
))
1451 st
->l2
.l2l3(st
, DL_RELEASE
| INDICATION
, NULL
);
1455 l2_st5_persistant_da(struct FsmInst
*fi
, int event
, void *arg
)
1457 struct PStack
*st
= fi
->userdata
;
1459 skb_queue_purge(&st
->l2
.i_queue
);
1460 skb_queue_purge(&st
->l2
.ui_queue
);
1463 st5_dl_release_l2l3(st
);
1464 FsmChangeState(fi
, ST_L2_4
);
1468 l2_st6_persistant_da(struct FsmInst
*fi
, int event
, void *arg
)
1470 struct PStack
*st
= fi
->userdata
;
1472 skb_queue_purge(&st
->l2
.ui_queue
);
1474 st
->l2
.l2l3(st
, DL_RELEASE
| CONFIRM
, NULL
);
1475 FsmChangeState(fi
, ST_L2_4
);
1479 l2_persistant_da(struct FsmInst
*fi
, int event
, void *arg
)
1481 struct PStack
*st
= fi
->userdata
;
1483 skb_queue_purge(&st
->l2
.i_queue
);
1484 skb_queue_purge(&st
->l2
.ui_queue
);
1487 FsmDelTimer(&st
->l2
.t203
, 19);
1488 st
->l2
.l2l3(st
, DL_RELEASE
| INDICATION
, NULL
);
1489 FsmChangeState(fi
, ST_L2_4
);
1493 l2_set_own_busy(struct FsmInst
*fi
, int event
, void *arg
)
1495 struct PStack
*st
= fi
->userdata
;
1497 if(!test_and_set_bit(FLG_OWN_BUSY
, &st
->l2
.flag
)) {
1498 enquiry_cr(st
, RNR
, RSP
, 0);
1499 test_and_clear_bit(FLG_ACK_PEND
, &st
->l2
.flag
);
1504 l2_clear_own_busy(struct FsmInst
*fi
, int event
, void *arg
)
1506 struct PStack
*st
= fi
->userdata
;
1508 if(!test_and_clear_bit(FLG_OWN_BUSY
, &st
->l2
.flag
)) {
1509 enquiry_cr(st
, RR
, RSP
, 0);
1510 test_and_clear_bit(FLG_ACK_PEND
, &st
->l2
.flag
);
1515 l2_frame_error(struct FsmInst
*fi
, int event
, void *arg
)
1517 struct PStack
*st
= fi
->userdata
;
1519 st
->ma
.layer(st
, MDL_ERROR
| INDICATION
, arg
);
1523 l2_frame_error_reest(struct FsmInst
*fi
, int event
, void *arg
)
1525 struct PStack
*st
= fi
->userdata
;
1527 st
->ma
.layer(st
, MDL_ERROR
| INDICATION
, arg
);
1529 test_and_clear_bit(FLG_L3_INIT
, &st
->l2
.flag
);
1532 static struct FsmNode L2FnList
[] __initdata
=
1534 {ST_L2_1
, EV_L2_DL_ESTABLISH_REQ
, l2_mdl_assign
},
1535 {ST_L2_2
, EV_L2_DL_ESTABLISH_REQ
, l2_go_st3
},
1536 {ST_L2_4
, EV_L2_DL_ESTABLISH_REQ
, l2_establish
},
1537 {ST_L2_5
, EV_L2_DL_ESTABLISH_REQ
, l2_discard_i_setl3
},
1538 {ST_L2_7
, EV_L2_DL_ESTABLISH_REQ
, l2_l3_reestablish
},
1539 {ST_L2_8
, EV_L2_DL_ESTABLISH_REQ
, l2_l3_reestablish
},
1540 {ST_L2_4
, EV_L2_DL_RELEASE_REQ
, l2_release
},
1541 {ST_L2_5
, EV_L2_DL_RELEASE_REQ
, l2_pend_rel
},
1542 {ST_L2_7
, EV_L2_DL_RELEASE_REQ
, l2_disconnect
},
1543 {ST_L2_8
, EV_L2_DL_RELEASE_REQ
, l2_disconnect
},
1544 {ST_L2_5
, EV_L2_DL_DATA
, l2_feed_i_if_reest
},
1545 {ST_L2_7
, EV_L2_DL_DATA
, l2_feed_i_pull
},
1546 {ST_L2_8
, EV_L2_DL_DATA
, l2_feed_iqueue
},
1547 {ST_L2_1
, EV_L2_DL_UNIT_DATA
, l2_queue_ui_assign
},
1548 {ST_L2_2
, EV_L2_DL_UNIT_DATA
, l2_queue_ui
},
1549 {ST_L2_3
, EV_L2_DL_UNIT_DATA
, l2_queue_ui
},
1550 {ST_L2_4
, EV_L2_DL_UNIT_DATA
, l2_send_ui
},
1551 {ST_L2_5
, EV_L2_DL_UNIT_DATA
, l2_send_ui
},
1552 {ST_L2_6
, EV_L2_DL_UNIT_DATA
, l2_send_ui
},
1553 {ST_L2_7
, EV_L2_DL_UNIT_DATA
, l2_send_ui
},
1554 {ST_L2_8
, EV_L2_DL_UNIT_DATA
, l2_send_ui
},
1555 {ST_L2_1
, EV_L2_MDL_ASSIGN
, l2_got_tei
},
1556 {ST_L2_2
, EV_L2_MDL_ASSIGN
, l2_got_tei
},
1557 {ST_L2_3
, EV_L2_MDL_ASSIGN
, l2_got_tei
},
1558 {ST_L2_2
, EV_L2_MDL_ERROR
, l2_st24_tei_remove
},
1559 {ST_L2_3
, EV_L2_MDL_ERROR
, l2_st3_tei_remove
},
1560 {ST_L2_4
, EV_L2_MDL_REMOVE
, l2_st24_tei_remove
},
1561 {ST_L2_5
, EV_L2_MDL_REMOVE
, l2_st5_tei_remove
},
1562 {ST_L2_6
, EV_L2_MDL_REMOVE
, l2_st6_tei_remove
},
1563 {ST_L2_7
, EV_L2_MDL_REMOVE
, l2_tei_remove
},
1564 {ST_L2_8
, EV_L2_MDL_REMOVE
, l2_tei_remove
},
1565 {ST_L2_4
, EV_L2_SABME
, l2_start_multi
},
1566 {ST_L2_5
, EV_L2_SABME
, l2_send_UA
},
1567 {ST_L2_6
, EV_L2_SABME
, l2_send_DM
},
1568 {ST_L2_7
, EV_L2_SABME
, l2_restart_multi
},
1569 {ST_L2_8
, EV_L2_SABME
, l2_restart_multi
},
1570 {ST_L2_4
, EV_L2_DISC
, l2_send_DM
},
1571 {ST_L2_5
, EV_L2_DISC
, l2_send_DM
},
1572 {ST_L2_6
, EV_L2_DISC
, l2_send_UA
},
1573 {ST_L2_7
, EV_L2_DISC
, l2_stop_multi
},
1574 {ST_L2_8
, EV_L2_DISC
, l2_stop_multi
},
1575 {ST_L2_4
, EV_L2_UA
, l2_mdl_error_ua
},
1576 {ST_L2_5
, EV_L2_UA
, l2_connected
},
1577 {ST_L2_6
, EV_L2_UA
, l2_released
},
1578 {ST_L2_7
, EV_L2_UA
, l2_mdl_error_ua
},
1579 {ST_L2_8
, EV_L2_UA
, l2_mdl_error_ua
},
1580 {ST_L2_4
, EV_L2_DM
, l2_reestablish
},
1581 {ST_L2_5
, EV_L2_DM
, l2_st5_dm_release
},
1582 {ST_L2_6
, EV_L2_DM
, l2_st6_dm_release
},
1583 {ST_L2_7
, EV_L2_DM
, l2_mdl_error_dm
},
1584 {ST_L2_8
, EV_L2_DM
, l2_st8_mdl_error_dm
},
1585 {ST_L2_1
, EV_L2_UI
, l2_got_ui
},
1586 {ST_L2_2
, EV_L2_UI
, l2_got_ui
},
1587 {ST_L2_3
, EV_L2_UI
, l2_got_ui
},
1588 {ST_L2_4
, EV_L2_UI
, l2_got_ui
},
1589 {ST_L2_5
, EV_L2_UI
, l2_got_ui
},
1590 {ST_L2_6
, EV_L2_UI
, l2_got_ui
},
1591 {ST_L2_7
, EV_L2_UI
, l2_got_ui
},
1592 {ST_L2_8
, EV_L2_UI
, l2_got_ui
},
1593 {ST_L2_7
, EV_L2_FRMR
, l2_got_FRMR
},
1594 {ST_L2_8
, EV_L2_FRMR
, l2_got_FRMR
},
1595 {ST_L2_7
, EV_L2_SUPER
, l2_st7_got_super
},
1596 {ST_L2_8
, EV_L2_SUPER
, l2_st8_got_super
},
1597 {ST_L2_7
, EV_L2_I
, l2_got_iframe
},
1598 {ST_L2_8
, EV_L2_I
, l2_got_iframe
},
1599 {ST_L2_5
, EV_L2_T200
, l2_st5_tout_200
},
1600 {ST_L2_6
, EV_L2_T200
, l2_st6_tout_200
},
1601 {ST_L2_7
, EV_L2_T200
, l2_st7_tout_200
},
1602 {ST_L2_8
, EV_L2_T200
, l2_st8_tout_200
},
1603 {ST_L2_7
, EV_L2_T203
, l2_st7_tout_203
},
1604 {ST_L2_7
, EV_L2_ACK_PULL
, l2_pull_iqueue
},
1605 {ST_L2_7
, EV_L2_SET_OWN_BUSY
, l2_set_own_busy
},
1606 {ST_L2_8
, EV_L2_SET_OWN_BUSY
, l2_set_own_busy
},
1607 {ST_L2_7
, EV_L2_CLEAR_OWN_BUSY
, l2_clear_own_busy
},
1608 {ST_L2_8
, EV_L2_CLEAR_OWN_BUSY
, l2_clear_own_busy
},
1609 {ST_L2_4
, EV_L2_FRAME_ERROR
, l2_frame_error
},
1610 {ST_L2_5
, EV_L2_FRAME_ERROR
, l2_frame_error
},
1611 {ST_L2_6
, EV_L2_FRAME_ERROR
, l2_frame_error
},
1612 {ST_L2_7
, EV_L2_FRAME_ERROR
, l2_frame_error_reest
},
1613 {ST_L2_8
, EV_L2_FRAME_ERROR
, l2_frame_error_reest
},
1614 {ST_L2_1
, EV_L1_DEACTIVATE
, l2_st14_persistant_da
},
1615 {ST_L2_2
, EV_L1_DEACTIVATE
, l2_st24_tei_remove
},
1616 {ST_L2_3
, EV_L1_DEACTIVATE
, l2_st3_tei_remove
},
1617 {ST_L2_4
, EV_L1_DEACTIVATE
, l2_st14_persistant_da
},
1618 {ST_L2_5
, EV_L1_DEACTIVATE
, l2_st5_persistant_da
},
1619 {ST_L2_6
, EV_L1_DEACTIVATE
, l2_st6_persistant_da
},
1620 {ST_L2_7
, EV_L1_DEACTIVATE
, l2_persistant_da
},
1621 {ST_L2_8
, EV_L1_DEACTIVATE
, l2_persistant_da
},
1624 #define L2_FN_COUNT (sizeof(L2FnList)/sizeof(struct FsmNode))
1627 isdnl2_l1l2(struct PStack
*st
, int pr
, void *arg
)
1629 struct sk_buff
*skb
= arg
;
1635 case (PH_DATA
| INDICATION
):
1637 len
= l2addrsize(&st
->l2
);
1641 FsmEvent(&st
->l2
.l2m
, EV_L2_FRAME_ERROR
, (void *) 'N');
1645 if (!(*datap
& 1)) { /* I-Frame */
1646 if(!(c
= iframe_error(st
, skb
)))
1647 ret
= FsmEvent(&st
->l2
.l2m
, EV_L2_I
, skb
);
1648 } else if (IsSFrame(datap
, st
)) { /* S-Frame */
1649 if(!(c
= super_error(st
, skb
)))
1650 ret
= FsmEvent(&st
->l2
.l2m
, EV_L2_SUPER
, skb
);
1651 } else if (IsUI(datap
)) {
1652 if(!(c
= UI_error(st
, skb
)))
1653 ret
= FsmEvent(&st
->l2
.l2m
, EV_L2_UI
, skb
);
1654 } else if (IsSABME(datap
, st
)) {
1655 if(!(c
= unnum_error(st
, skb
, CMD
)))
1656 ret
= FsmEvent(&st
->l2
.l2m
, EV_L2_SABME
, skb
);
1657 } else if (IsUA(datap
)) {
1658 if(!(c
= unnum_error(st
, skb
, RSP
)))
1659 ret
= FsmEvent(&st
->l2
.l2m
, EV_L2_UA
, skb
);
1660 } else if (IsDISC(datap
)) {
1661 if(!(c
= unnum_error(st
, skb
, CMD
)))
1662 ret
= FsmEvent(&st
->l2
.l2m
, EV_L2_DISC
, skb
);
1663 } else if (IsDM(datap
)) {
1664 if(!(c
= unnum_error(st
, skb
, RSP
)))
1665 ret
= FsmEvent(&st
->l2
.l2m
, EV_L2_DM
, skb
);
1666 } else if (IsFRMR(datap
)) {
1667 if(!(c
= FRMR_error(st
,skb
)))
1668 ret
= FsmEvent(&st
->l2
.l2m
, EV_L2_FRMR
, skb
);
1670 FsmEvent(&st
->l2
.l2m
, EV_L2_FRAME_ERROR
, (void *) 'L');
1676 FsmEvent(&st
->l2
.l2m
, EV_L2_FRAME_ERROR
, (void *)(long)c
);
1682 case (PH_PULL
| CONFIRM
):
1683 FsmEvent(&st
->l2
.l2m
, EV_L2_ACK_PULL
, arg
);
1685 case (PH_PAUSE
| INDICATION
):
1686 test_and_set_bit(FLG_DCHAN_BUSY
, &st
->l2
.flag
);
1688 case (PH_PAUSE
| CONFIRM
):
1689 test_and_clear_bit(FLG_DCHAN_BUSY
, &st
->l2
.flag
);
1691 case (PH_ACTIVATE
| CONFIRM
):
1692 case (PH_ACTIVATE
| INDICATION
):
1693 test_and_set_bit(FLG_L1_ACTIV
, &st
->l2
.flag
);
1694 if (test_and_clear_bit(FLG_ESTAB_PEND
, &st
->l2
.flag
))
1695 FsmEvent(&st
->l2
.l2m
, EV_L2_DL_ESTABLISH_REQ
, arg
);
1697 case (PH_DEACTIVATE
| INDICATION
):
1698 case (PH_DEACTIVATE
| CONFIRM
):
1699 test_and_clear_bit(FLG_L1_ACTIV
, &st
->l2
.flag
);
1700 FsmEvent(&st
->l2
.l2m
, EV_L1_DEACTIVATE
, arg
);
1703 l2m_debug(&st
->l2
.l2m
, "l2 unknown pr %04x", pr
);
1709 isdnl2_l3l2(struct PStack
*st
, int pr
, void *arg
)
1712 case (DL_DATA
| REQUEST
):
1713 if (FsmEvent(&st
->l2
.l2m
, EV_L2_DL_DATA
, arg
)) {
1714 dev_kfree_skb((struct sk_buff
*) arg
);
1717 case (DL_UNIT_DATA
| REQUEST
):
1718 if (FsmEvent(&st
->l2
.l2m
, EV_L2_DL_UNIT_DATA
, arg
)) {
1719 dev_kfree_skb((struct sk_buff
*) arg
);
1722 case (DL_ESTABLISH
| REQUEST
):
1723 if (test_bit(FLG_L1_ACTIV
, &st
->l2
.flag
)) {
1724 if (test_bit(FLG_LAPD
, &st
->l2
.flag
) ||
1725 test_bit(FLG_ORIG
, &st
->l2
.flag
)) {
1726 FsmEvent(&st
->l2
.l2m
, EV_L2_DL_ESTABLISH_REQ
, arg
);
1729 if (test_bit(FLG_LAPD
, &st
->l2
.flag
) ||
1730 test_bit(FLG_ORIG
, &st
->l2
.flag
)) {
1731 test_and_set_bit(FLG_ESTAB_PEND
, &st
->l2
.flag
);
1733 st
->l2
.l2l1(st
, PH_ACTIVATE
, NULL
);
1736 case (DL_RELEASE
| REQUEST
):
1737 if (test_bit(FLG_LAPB
, &st
->l2
.flag
)) {
1738 st
->l2
.l2l1(st
, PH_DEACTIVATE
, NULL
);
1740 FsmEvent(&st
->l2
.l2m
, EV_L2_DL_RELEASE_REQ
, arg
);
1742 case (MDL_ASSIGN
| REQUEST
):
1743 FsmEvent(&st
->l2
.l2m
, EV_L2_MDL_ASSIGN
, arg
);
1745 case (MDL_REMOVE
| REQUEST
):
1746 FsmEvent(&st
->l2
.l2m
, EV_L2_MDL_REMOVE
, arg
);
1748 case (MDL_ERROR
| RESPONSE
):
1749 FsmEvent(&st
->l2
.l2m
, EV_L2_MDL_ERROR
, arg
);
1755 releasestack_isdnl2(struct PStack
*st
)
1757 FsmDelTimer(&st
->l2
.t200
, 21);
1758 FsmDelTimer(&st
->l2
.t203
, 16);
1759 skb_queue_purge(&st
->l2
.i_queue
);
1760 skb_queue_purge(&st
->l2
.ui_queue
);
1761 ReleaseWin(&st
->l2
);
1765 l2m_debug(struct FsmInst
*fi
, char *fmt
, ...)
1768 struct PStack
*st
= fi
->userdata
;
1770 va_start(args
, fmt
);
1771 VHiSax_putstatus(st
->l1
.hardware
, st
->l2
.debug_id
, fmt
, args
);
1776 setstack_isdnl2(struct PStack
*st
, char *debug_id
)
1778 spin_lock_init(&st
->l2
.lock
);
1779 st
->l1
.l1l2
= isdnl2_l1l2
;
1780 st
->l3
.l3l2
= isdnl2_l3l2
;
1782 skb_queue_head_init(&st
->l2
.i_queue
);
1783 skb_queue_head_init(&st
->l2
.ui_queue
);
1787 st
->l2
.l2m
.fsm
= &l2fsm
;
1788 if (test_bit(FLG_LAPB
, &st
->l2
.flag
))
1789 st
->l2
.l2m
.state
= ST_L2_4
;
1791 st
->l2
.l2m
.state
= ST_L2_1
;
1792 st
->l2
.l2m
.debug
= 0;
1793 st
->l2
.l2m
.userdata
= st
;
1794 st
->l2
.l2m
.userint
= 0;
1795 st
->l2
.l2m
.printdebug
= l2m_debug
;
1796 strcpy(st
->l2
.debug_id
, debug_id
);
1798 FsmInitTimer(&st
->l2
.l2m
, &st
->l2
.t200
);
1799 FsmInitTimer(&st
->l2
.l2m
, &st
->l2
.t203
);
1803 transl2_l3l2(struct PStack
*st
, int pr
, void *arg
)
1806 case (DL_DATA
| REQUEST
):
1807 case (DL_UNIT_DATA
| REQUEST
):
1808 st
->l2
.l2l1(st
, PH_DATA
| REQUEST
, arg
);
1810 case (DL_ESTABLISH
| REQUEST
):
1811 st
->l2
.l2l1(st
, PH_ACTIVATE
| REQUEST
, NULL
);
1813 case (DL_RELEASE
| REQUEST
):
1814 st
->l2
.l2l1(st
, PH_DEACTIVATE
| REQUEST
, NULL
);
1820 setstack_transl2(struct PStack
*st
)
1822 st
->l3
.l3l2
= transl2_l3l2
;
1826 releasestack_transl2(struct PStack
*st
)
1833 l2fsm
.state_count
= L2_STATE_COUNT
;
1834 l2fsm
.event_count
= L2_EVENT_COUNT
;
1835 l2fsm
.strEvent
= strL2Event
;
1836 l2fsm
.strState
= strL2State
;
1837 return FsmNew(&l2fsm
, L2FnList
, L2_FN_COUNT
);