Lines Matching defs:l2
97 struct layer2 *l2 = fi->userdata;
103 printk(KERN_DEBUG "l2 (sapi %d tei %d): ", l2->sapi, l2->tei);
110 l2headersize(struct layer2 *l2, int ui)
112 return ((test_bit(FLG_MOD128, &l2->flag) && (!ui)) ? 2 : 1) +
113 (test_bit(FLG_LAPD, &l2->flag) ? 2 : 1);
117 l2addrsize(struct layer2 *l2)
119 return test_bit(FLG_LAPD, &l2->flag) ? 2 : 1;
123 l2_newid(struct layer2 *l2)
127 id = l2->next_id++;
129 l2->next_id = 1;
131 id |= l2->tei << 8;
132 id |= l2->sapi;
137 l2up(struct layer2 *l2, u_int prim, struct sk_buff *skb)
141 if (!l2->up)
144 mISDN_HEAD_ID(skb) = (l2->ch.nr << 16) | l2->ch.addr;
145 err = l2->up->send(l2->up, skb);
153 l2up_create(struct layer2 *l2, u_int prim, int len, void *arg)
159 if (!l2->up)
166 hh->id = (l2->ch.nr << 16) | l2->ch.addr;
169 err = l2->up->send(l2->up, skb);
177 l2down_skb(struct layer2 *l2, struct sk_buff *skb) {
180 ret = l2->ch.recv(l2->ch.peer, skb);
187 l2down_raw(struct layer2 *l2, struct sk_buff *skb)
192 if (test_and_set_bit(FLG_L1_NOTREADY, &l2->flag)) {
193 skb_queue_tail(&l2->down_queue, skb);
196 l2->down_id = mISDN_HEAD_ID(skb);
198 return l2down_skb(l2, skb);
202 l2down(struct layer2 *l2, u_int prim, u_int id, struct sk_buff *skb)
208 return l2down_raw(l2, skb);
212 l2down_create(struct layer2 *l2, u_int prim, u_int id, int len, void *arg)
226 err = l2down_raw(l2, skb);
233 ph_data_confirm(struct layer2 *l2, struct mISDNhead *hh, struct sk_buff *skb) {
237 if (test_bit(FLG_L1_NOTREADY, &l2->flag)) {
238 if (hh->id == l2->down_id) {
239 nskb = skb_dequeue(&l2->down_queue);
241 l2->down_id = mISDN_HEAD_ID(nskb);
242 if (l2down_skb(l2, nskb)) {
244 l2->down_id = MISDN_ID_NONE;
247 l2->down_id = MISDN_ID_NONE;
252 if (l2->down_id == MISDN_ID_NONE) {
253 test_and_clear_bit(FLG_L1_NOTREADY, &l2->flag);
254 mISDN_FsmEvent(&l2->l2m, EV_L2_ACK_PULL, NULL);
258 if (!test_and_set_bit(FLG_L1_NOTREADY, &l2->flag)) {
259 nskb = skb_dequeue(&l2->down_queue);
261 l2->down_id = mISDN_HEAD_ID(nskb);
262 if (l2down_skb(l2, nskb)) {
264 l2->down_id = MISDN_ID_NONE;
265 test_and_clear_bit(FLG_L1_NOTREADY, &l2->flag);
268 test_and_clear_bit(FLG_L1_NOTREADY, &l2->flag);
274 l2mgr(struct layer2 *l2, u_int prim, void *arg) {
278 "l2mgr: addr:%x prim %x %c\n", l2->id, prim, (char)c);
279 if (test_bit(FLG_LAPD, &l2->flag) &&
280 !test_bit(FLG_FIXED_TEI, &l2->flag)) {
286 l2_tei(l2, prim, (u_long)arg);
294 set_peer_busy(struct layer2 *l2) {
295 test_and_set_bit(FLG_PEER_BUSY, &l2->flag);
296 if (skb_queue_len(&l2->i_queue) || skb_queue_len(&l2->ui_queue))
297 test_and_set_bit(FLG_L2BLOCK, &l2->flag);
301 clear_peer_busy(struct layer2 *l2) {
302 if (test_and_clear_bit(FLG_PEER_BUSY, &l2->flag))
303 test_and_clear_bit(FLG_L2BLOCK, &l2->flag);
307 InitWin(struct layer2 *l2)
312 l2->windowar[i] = NULL;
316 freewin(struct layer2 *l2)
321 if (l2->windowar[i]) {
323 dev_kfree_skb(l2->windowar[i]);
324 l2->windowar[i] = NULL;
331 ReleaseWin(struct layer2 *l2)
333 int cnt = freewin(l2);
341 cansend(struct layer2 *l2)
345 if (test_bit(FLG_MOD128, &l2->flag))
346 p1 = (l2->vs - l2->va) % 128;
348 p1 = (l2->vs - l2->va) % 8;
349 return (p1 < l2->window) && !test_bit(FLG_PEER_BUSY, &l2->flag);
353 clear_exception(struct layer2 *l2)
355 test_and_clear_bit(FLG_ACK_PEND, &l2->flag);
356 test_and_clear_bit(FLG_REJEXC, &l2->flag);
357 test_and_clear_bit(FLG_OWN_BUSY, &l2->flag);
358 clear_peer_busy(l2);
362 sethdraddr(struct layer2 *l2, u_char *header, int rsp)
367 if (test_bit(FLG_LAPD, &l2->flag)) {
368 if (test_bit(FLG_LAPD_NET, &l2->flag))
370 *ptr++ = (l2->sapi << 2) | (crbit ? 2 : 0);
371 *ptr++ = (l2->tei << 1) | 1;
374 if (test_bit(FLG_ORIG, &l2->flag))
377 *ptr++ = l2->addr.B;
379 *ptr++ = l2->addr.A;
385 enqueue_super(struct layer2 *l2, struct sk_buff *skb)
387 if (l2down(l2, PH_DATA_REQ, l2_newid(l2), skb))
392 enqueue_ui(struct layer2 *l2, struct sk_buff *skb)
394 if (l2->tm)
395 l2_tei(l2, MDL_STATUS_UI_IND, 0);
396 if (l2down(l2, PH_DATA_REQ, l2_newid(l2), skb))
425 IsRR(u_char *data, struct layer2 *l2)
427 if (test_bit(FLG_MOD128, &l2->flag))
434 IsSFrame(u_char *data, struct layer2 *l2)
438 if (!test_bit(FLG_MOD128, &l2->flag))
444 IsSABME(u_char *data, struct layer2 *l2)
448 return test_bit(FLG_MOD128, &l2->flag) ? d == SABME : d == SABM;
452 IsREJ(u_char *data, struct layer2 *l2)
454 return test_bit(FLG_MOD128, &l2->flag) ?
465 IsRNR(u_char *data, struct layer2 *l2)
467 return test_bit(FLG_MOD128, &l2->flag) ?
472 iframe_error(struct layer2 *l2, struct sk_buff *skb)
477 i = l2addrsize(l2) + (test_bit(FLG_MOD128, &l2->flag) ? 2 : 1);
478 if (test_bit(FLG_ORIG, &l2->flag))
484 if ((skb->len - i) > l2->maxlen)
490 super_error(struct layer2 *l2, struct sk_buff *skb)
492 if (skb->len != l2addrsize(l2) +
493 (test_bit(FLG_MOD128, &l2->flag) ? 2 : 1))
499 unnum_error(struct layer2 *l2, struct sk_buff *skb, int wantrsp)
502 if (test_bit(FLG_ORIG, &l2->flag))
506 if (skb->len != l2addrsize(l2) + 1)
512 UI_error(struct layer2 *l2, struct sk_buff *skb)
515 if (test_bit(FLG_ORIG, &l2->flag))
519 if (skb->len > l2->maxlen + l2addrsize(l2) + 1)
525 FRMR_error(struct layer2 *l2, struct sk_buff *skb)
527 u_int headers = l2addrsize(l2) + 1;
531 if (test_bit(FLG_ORIG, &l2->flag))
535 if (test_bit(FLG_MOD128, &l2->flag)) {
539 l2m_debug(&l2->l2m,
546 l2m_debug(&l2->l2m,
554 legalnr(struct layer2 *l2, unsigned int nr)
556 if (test_bit(FLG_MOD128, &l2->flag))
557 return ((nr - l2->va) % 128) <= ((l2->vs - l2->va) % 128);
559 return ((nr - l2->va) % 8) <= ((l2->vs - l2->va) % 8);
563 setva(struct layer2 *l2, unsigned int nr)
567 while (l2->va != nr) {
568 l2->va++;
569 if (test_bit(FLG_MOD128, &l2->flag))
570 l2->va %= 128;
572 l2->va %= 8;
573 if (l2->windowar[l2->sow]) {
574 skb_trim(l2->windowar[l2->sow], 0);
575 skb_queue_tail(&l2->tmp_queue, l2->windowar[l2->sow]);
576 l2->windowar[l2->sow] = NULL;
578 l2->sow = (l2->sow + 1) % l2->window;
580 skb = skb_dequeue(&l2->tmp_queue);
583 skb = skb_dequeue(&l2->tmp_queue);
588 send_uframe(struct layer2 *l2, struct sk_buff *skb, u_char cmd, u_char cr)
593 i = sethdraddr(l2, tmp, cr);
606 enqueue_super(l2, skb);
611 get_PollFlag(struct layer2 *l2, struct sk_buff *skb)
613 return skb->data[l2addrsize(l2)] & 0x10;
617 get_PollFlagFree(struct layer2 *l2, struct sk_buff *skb)
621 PF = get_PollFlag(l2, skb);
627 start_t200(struct layer2 *l2, int i)
629 mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, i);
630 test_and_set_bit(FLG_T200_RUN, &l2->flag);
634 restart_t200(struct layer2 *l2, int i)
636 mISDN_FsmRestartTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, i);
637 test_and_set_bit(FLG_T200_RUN, &l2->flag);
641 stop_t200(struct layer2 *l2, int i)
643 if (test_and_clear_bit(FLG_T200_RUN, &l2->flag))
644 mISDN_FsmDelTimer(&l2->t200, i);
648 st5_dl_release_l2l3(struct layer2 *l2)
652 if (test_and_clear_bit(FLG_PEND_REL, &l2->flag))
656 l2up_create(l2, pr, 0, NULL);
660 lapb_dl_release_l2l3(struct layer2 *l2, int f)
662 if (test_bit(FLG_LAPB, &l2->flag))
663 l2down_create(l2, PH_DEACTIVATE_REQ, l2_newid(l2), 0, NULL);
664 l2up_create(l2, f, 0, NULL);
670 struct layer2 *l2 = fi->userdata;
673 clear_exception(l2);
674 l2->rc = 0;
675 cmd = (test_bit(FLG_MOD128, &l2->flag) ? SABME : SABM) | 0x10;
676 send_uframe(l2, NULL, cmd, CMD);
677 mISDN_FsmDelTimer(&l2->t203, 1);
678 restart_t200(l2, 1);
679 test_and_clear_bit(FLG_PEND_REL, &l2->flag);
680 freewin(l2);
688 struct layer2 *l2 = fi->userdata;
690 if (get_PollFlagFree(l2, skb))
691 l2mgr(l2, MDL_ERROR_IND, (void *) 'C');
693 l2mgr(l2, MDL_ERROR_IND, (void *) 'D');
701 struct layer2 *l2 = fi->userdata;
703 if (get_PollFlagFree(l2, skb))
704 l2mgr(l2, MDL_ERROR_IND, (void *) 'B');
706 l2mgr(l2, MDL_ERROR_IND, (void *) 'E');
708 test_and_clear_bit(FLG_L3_INIT, &l2->flag);
716 struct layer2 *l2 = fi->userdata;
718 if (get_PollFlagFree(l2, skb))
719 l2mgr(l2, MDL_ERROR_IND, (void *) 'B');
721 l2mgr(l2, MDL_ERROR_IND, (void *) 'E');
723 test_and_clear_bit(FLG_L3_INIT, &l2->flag);
736 struct layer2 *l2 = fi->userdata;
740 l2_tei(l2, MDL_ASSIGN_IND, 0);
746 struct layer2 *l2 = fi->userdata;
749 skb_queue_tail(&l2->ui_queue, skb);
751 l2_tei(l2, MDL_ASSIGN_IND, 0);
757 struct layer2 *l2 = fi->userdata;
760 skb_queue_tail(&l2->ui_queue, skb);
764 tx_ui(struct layer2 *l2)
770 i = sethdraddr(l2, header, CMD);
771 if (test_bit(FLG_LAPD_NET, &l2->flag))
774 while ((skb = skb_dequeue(&l2->ui_queue))) {
776 enqueue_ui(l2, skb);
783 struct layer2 *l2 = fi->userdata;
786 skb_queue_tail(&l2->ui_queue, skb);
787 tx_ui(l2);
793 struct layer2 *l2 = fi->userdata;
796 skb_pull(skb, l2headersize(l2, 1));
801 if (l2->tm)
802 l2_tei(l2, MDL_STATUS_UI_IND, 0);
803 l2up(l2, DL_UNITDATA_IND, skb);
810 struct layer2 *l2 = fi->userdata;
813 test_and_set_bit(FLG_L3_INIT, &l2->flag);
821 struct layer2 *l2 = fi->userdata;
823 skb_queue_purge(&l2->i_queue);
824 test_and_set_bit(FLG_L3_INIT, &l2->flag);
825 test_and_clear_bit(FLG_PEND_REL, &l2->flag);
833 struct layer2 *l2 = fi->userdata;
835 skb_queue_purge(&l2->i_queue);
837 test_and_set_bit(FLG_L3_INIT, &l2->flag);
844 struct layer2 *l2 = fi->userdata;
848 l2up(l2, DL_RELEASE_CNF, skb);
855 struct layer2 *l2 = fi->userdata;
857 test_and_set_bit(FLG_PEND_REL, &l2->flag);
864 struct layer2 *l2 = fi->userdata;
867 skb_queue_purge(&l2->i_queue);
868 freewin(l2);
870 l2->rc = 0;
871 send_uframe(l2, NULL, DISC | 0x10, CMD);
872 mISDN_FsmDelTimer(&l2->t203, 1);
873 restart_t200(l2, 2);
881 struct layer2 *l2 = fi->userdata;
884 l2->vs = 0;
885 l2->va = 0;
886 l2->vr = 0;
887 l2->sow = 0;
888 clear_exception(l2);
889 send_uframe(l2, NULL, UA | get_PollFlag(l2, skb), RSP);
891 mISDN_FsmAddTimer(&l2->t203, l2->T203, EV_L2_T203, NULL, 3);
893 l2up(l2, DL_ESTABLISH_IND, skb);
894 if (l2->tm)
895 l2_tei(l2, MDL_STATUS_UP_IND, 0);
901 struct layer2 *l2 = fi->userdata;
904 send_uframe(l2, skb, UA | get_PollFlag(l2, skb), RSP);
910 struct layer2 *l2 = fi->userdata;
913 send_uframe(l2, skb, DM | get_PollFlag(l2, skb), RSP);
919 struct layer2 *l2 = fi->userdata;
923 send_uframe(l2, skb, UA | get_PollFlag(l2, skb), RSP);
925 l2mgr(l2, MDL_ERROR_IND, (void *) 'F');
927 if (l2->vs != l2->va) {
928 skb_queue_purge(&l2->i_queue);
932 clear_exception(l2);
933 l2->vs = 0;
934 l2->va = 0;
935 l2->vr = 0;
936 l2->sow = 0;
938 stop_t200(l2, 3);
939 mISDN_FsmRestartTimer(&l2->t203, l2->T203, EV_L2_T203, NULL, 3);
942 l2up_create(l2, DL_ESTABLISH_IND, 0, NULL);
943 /* mISDN_queue_data(&l2->inst, l2->inst.id | MSG_BROADCAST,
947 if (skb_queue_len(&l2->i_queue) && cansend(l2))
954 struct layer2 *l2 = fi->userdata;
958 mISDN_FsmDelTimer(&l2->t203, 3);
959 stop_t200(l2, 4);
961 send_uframe(l2, skb, UA | get_PollFlag(l2, skb), RSP);
962 skb_queue_purge(&l2->i_queue);
963 freewin(l2);
964 lapb_dl_release_l2l3(l2, DL_RELEASE_IND);
965 if (l2->tm)
966 l2_tei(l2, MDL_STATUS_DOWN_IND, 0);
972 struct layer2 *l2 = fi->userdata;
976 if (!get_PollFlag(l2, skb)) {
981 if (test_and_clear_bit(FLG_PEND_REL, &l2->flag))
983 if (test_and_clear_bit(FLG_L3_INIT, &l2->flag)) {
985 } else if (l2->vs != l2->va) {
986 skb_queue_purge(&l2->i_queue);
989 stop_t200(l2, 5);
990 l2->vr = 0;
991 l2->vs = 0;
992 l2->va = 0;
993 l2->sow = 0;
995 mISDN_FsmAddTimer(&l2->t203, l2->T203, EV_L2_T203, NULL, 4);
997 l2up_create(l2, pr, 0, NULL);
999 if (skb_queue_len(&l2->i_queue) && cansend(l2))
1002 if (l2->tm)
1003 l2_tei(l2, MDL_STATUS_UP_IND, 0);
1009 struct layer2 *l2 = fi->userdata;
1012 if (!get_PollFlag(l2, skb)) {
1017 stop_t200(l2, 6);
1018 lapb_dl_release_l2l3(l2, DL_RELEASE_CNF);
1020 if (l2->tm)
1021 l2_tei(l2, MDL_STATUS_DOWN_IND, 0);
1027 struct layer2 *l2 = fi->userdata;
1030 if (!get_PollFlagFree(l2, skb)) {
1032 test_and_set_bit(FLG_L3_INIT, &l2->flag);
1039 struct layer2 *l2 = fi->userdata;
1042 if (get_PollFlagFree(l2, skb)) {
1043 stop_t200(l2, 7);
1044 if (!test_bit(FLG_L3_INIT, &l2->flag))
1045 skb_queue_purge(&l2->i_queue);
1046 if (test_bit(FLG_LAPB, &l2->flag))
1047 l2down_create(l2, PH_DEACTIVATE_REQ,
1048 l2_newid(l2), 0, NULL);
1049 st5_dl_release_l2l3(l2);
1051 if (l2->tm)
1052 l2_tei(l2, MDL_STATUS_DOWN_IND, 0);
1059 struct layer2 *l2 = fi->userdata;
1062 if (get_PollFlagFree(l2, skb)) {
1063 stop_t200(l2, 8);
1064 lapb_dl_release_l2l3(l2, DL_RELEASE_CNF);
1066 if (l2->tm)
1067 l2_tei(l2, MDL_STATUS_DOWN_IND, 0);
1072 enquiry_cr(struct layer2 *l2, u_char typ, u_char cr, u_char pf)
1078 i = sethdraddr(l2, tmp, cr);
1079 if (test_bit(FLG_MOD128, &l2->flag)) {
1081 tmp[i++] = (l2->vr << 1) | (pf ? 1 : 0);
1083 tmp[i++] = (l2->vr << 5) | typ | (pf ? 0x10 : 0);
1091 enqueue_super(l2, skb);
1095 enquiry_response(struct layer2 *l2)
1097 if (test_bit(FLG_OWN_BUSY, &l2->flag))
1098 enquiry_cr(l2, RNR, RSP, 1);
1100 enquiry_cr(l2, RR, RSP, 1);
1101 test_and_clear_bit(FLG_ACK_PEND, &l2->flag);
1105 transmit_enquiry(struct layer2 *l2)
1107 if (test_bit(FLG_OWN_BUSY, &l2->flag))
1108 enquiry_cr(l2, RNR, CMD, 1);
1110 enquiry_cr(l2, RR, CMD, 1);
1111 test_and_clear_bit(FLG_ACK_PEND, &l2->flag);
1112 start_t200(l2, 9);
1119 struct layer2 *l2 = fi->userdata;
1121 l2mgr(l2, MDL_ERROR_IND, (void *) 'J');
1123 test_and_clear_bit(FLG_L3_INIT, &l2->flag);
1127 invoke_retransmission(struct layer2 *l2, unsigned int nr)
1131 if (l2->vs != nr) {
1132 while (l2->vs != nr) {
1133 (l2->vs)--;
1134 if (test_bit(FLG_MOD128, &l2->flag)) {
1135 l2->vs %= 128;
1136 p1 = (l2->vs - l2->va) % 128;
1138 l2->vs %= 8;
1139 p1 = (l2->vs - l2->va) % 8;
1141 p1 = (p1 + l2->sow) % l2->window;
1142 if (l2->windowar[p1])
1143 skb_queue_head(&l2->i_queue, l2->windowar[p1]);
1148 l2->windowar[p1] = NULL;
1150 mISDN_FsmEvent(&l2->l2m, EV_L2_ACK_PULL, NULL);
1157 struct layer2 *l2 = fi->userdata;
1163 if (test_bit(FLG_ORIG, &l2->flag))
1166 skb_pull(skb, l2addrsize(l2));
1167 if (IsRNR(skb->data, l2)) {
1168 set_peer_busy(l2);
1171 clear_peer_busy(l2);
1172 if (IsREJ(skb->data, l2))
1175 if (test_bit(FLG_MOD128, &l2->flag)) {
1186 l2mgr(l2, MDL_ERROR_IND, (void *) 'A');
1188 enquiry_response(l2);
1190 if (legalnr(l2, nr)) {
1192 setva(l2, nr);
1193 invoke_retransmission(l2, nr);
1194 stop_t200(l2, 10);
1195 if (mISDN_FsmAddTimer(&l2->t203, l2->T203,
1197 l2m_debug(&l2->l2m, "Restart T203 ST7 REJ");
1198 } else if ((nr == l2->vs) && (typ == RR)) {
1199 setva(l2, nr);
1200 stop_t200(l2, 11);
1201 mISDN_FsmRestartTimer(&l2->t203, l2->T203,
1203 } else if ((l2->va != nr) || (typ == RNR)) {
1204 setva(l2, nr);
1206 mISDN_FsmDelTimer(&l2->t203, 9);
1207 restart_t200(l2, 12);
1209 if (skb_queue_len(&l2->i_queue) && (typ == RR))
1218 struct layer2 *l2 = fi->userdata;
1221 if (!test_bit(FLG_L3_INIT, &l2->flag))
1222 skb_queue_tail(&l2->i_queue, skb);
1230 struct layer2 *l2 = fi->userdata;
1233 skb_queue_tail(&l2->i_queue, skb);
1240 struct layer2 *l2 = fi->userdata;
1243 skb_queue_tail(&l2->i_queue, skb);
1249 struct layer2 *l2 = fi->userdata;
1254 i = l2addrsize(l2);
1255 if (test_bit(FLG_MOD128, &l2->flag)) {
1264 if (test_bit(FLG_OWN_BUSY, &l2->flag)) {
1267 enquiry_response(l2);
1269 if (l2->vr == ns) {
1270 l2->vr++;
1271 if (test_bit(FLG_MOD128, &l2->flag))
1272 l2->vr %= 128;
1274 l2->vr %= 8;
1275 test_and_clear_bit(FLG_REJEXC, &l2->flag);
1277 enquiry_response(l2);
1279 test_and_set_bit(FLG_ACK_PEND, &l2->flag);
1280 skb_pull(skb, l2headersize(l2, 0));
1281 l2up(l2, DL_DATA_IND, skb);
1285 if (test_and_set_bit(FLG_REJEXC, &l2->flag)) {
1287 enquiry_response(l2);
1289 enquiry_cr(l2, REJ, RSP, PollFlag);
1290 test_and_clear_bit(FLG_ACK_PEND, &l2->flag);
1294 if (legalnr(l2, nr)) {
1295 if (!test_bit(FLG_PEER_BUSY, &l2->flag) &&
1297 if (nr == l2->vs) {
1298 stop_t200(l2, 13);
1299 mISDN_FsmRestartTimer(&l2->t203, l2->T203,
1301 } else if (nr != l2->va)
1302 restart_t200(l2, 14);
1304 setva(l2, nr);
1309 if (skb_queue_len(&l2->i_queue) && (fi->state == ST_L2_7))
1311 if (test_and_clear_bit(FLG_ACK_PEND, &l2->flag))
1312 enquiry_cr(l2, RR, RSP, 0);
1318 struct layer2 *l2 = fi->userdata;
1321 l2->tei = (signed char)(long)arg;
1322 set_channel_address(&l2->ch, l2->sapi, l2->tei);
1324 l2up_create(l2, DL_INFORMATION_IND, sizeof(info), &info);
1327 test_and_set_bit(FLG_L3_INIT, &l2->flag);
1330 if (skb_queue_len(&l2->ui_queue))
1331 tx_ui(l2);
1337 struct layer2 *l2 = fi->userdata;
1339 if (test_bit(FLG_LAPD, &l2->flag) &&
1340 test_bit(FLG_DCHAN_BUSY, &l2->flag)) {
1341 mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, 9);
1342 } else if (l2->rc == l2->N200) {
1344 test_and_clear_bit(FLG_T200_RUN, &l2->flag);
1345 skb_queue_purge(&l2->i_queue);
1346 l2mgr(l2, MDL_ERROR_IND, (void *) 'G');
1347 if (test_bit(FLG_LAPB, &l2->flag))
1348 l2down_create(l2, PH_DEACTIVATE_REQ,
1349 l2_newid(l2), 0, NULL);
1350 st5_dl_release_l2l3(l2);
1351 if (l2->tm)
1352 l2_tei(l2, MDL_STATUS_DOWN_IND, 0);
1354 l2->rc++;
1355 mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, 9);
1356 send_uframe(l2, NULL, (test_bit(FLG_MOD128, &l2->flag) ?
1364 struct layer2 *l2 = fi->userdata;
1366 if (test_bit(FLG_LAPD, &l2->flag) &&
1367 test_bit(FLG_DCHAN_BUSY, &l2->flag)) {
1368 mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, 9);
1369 } else if (l2->rc == l2->N200) {
1371 test_and_clear_bit(FLG_T200_RUN, &l2->flag);
1372 l2mgr(l2, MDL_ERROR_IND, (void *) 'H');
1373 lapb_dl_release_l2l3(l2, DL_RELEASE_CNF);
1374 if (l2->tm)
1375 l2_tei(l2, MDL_STATUS_DOWN_IND, 0);
1377 l2->rc++;
1378 mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200,
1380 send_uframe(l2, NULL, DISC | 0x10, CMD);
1387 struct layer2 *l2 = fi->userdata;
1389 if (test_bit(FLG_LAPD, &l2->flag) &&
1390 test_bit(FLG_DCHAN_BUSY, &l2->flag)) {
1391 mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, 9);
1394 test_and_clear_bit(FLG_T200_RUN, &l2->flag);
1395 l2->rc = 0;
1397 transmit_enquiry(l2);
1398 l2->rc++;
1404 struct layer2 *l2 = fi->userdata;
1406 if (test_bit(FLG_LAPD, &l2->flag) &&
1407 test_bit(FLG_DCHAN_BUSY, &l2->flag)) {
1408 mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, 9);
1411 test_and_clear_bit(FLG_T200_RUN, &l2->flag);
1412 if (l2->rc == l2->N200) {
1413 l2mgr(l2, MDL_ERROR_IND, (void *) 'I');
1415 test_and_clear_bit(FLG_L3_INIT, &l2->flag);
1417 transmit_enquiry(l2);
1418 l2->rc++;
1425 struct layer2 *l2 = fi->userdata;
1427 if (test_bit(FLG_LAPD, &l2->flag) &&
1428 test_bit(FLG_DCHAN_BUSY, &l2->flag)) {
1429 mISDN_FsmAddTimer(&l2->t203, l2->T203, EV_L2_T203, NULL, 9);
1433 transmit_enquiry(l2);
1434 l2->rc = 0;
1440 struct layer2 *l2 = fi->userdata;
1445 if (!cansend(l2))
1448 skb = skb_dequeue(&l2->i_queue);
1452 if (test_bit(FLG_MOD128, &l2->flag))
1453 p1 = (l2->vs - l2->va) % 128;
1455 p1 = (l2->vs - l2->va) % 8;
1456 p1 = (p1 + l2->sow) % l2->window;
1457 if (l2->windowar[p1]) {
1460 dev_kfree_skb(l2->windowar[p1]);
1462 l2->windowar[p1] = skb;
1463 i = sethdraddr(l2, header, CMD);
1464 if (test_bit(FLG_MOD128, &l2->flag)) {
1465 header[i++] = l2->vs << 1;
1466 header[i++] = l2->vr << 1;
1467 l2->vs = (l2->vs + 1) % 128;
1469 header[i++] = (l2->vr << 5) | (l2->vs << 1);
1470 l2->vs = (l2->vs + 1) % 8;
1491 l2down(l2, PH_DATA_REQ, l2_newid(l2), nskb);
1492 test_and_clear_bit(FLG_ACK_PEND, &l2->flag);
1493 if (!test_and_set_bit(FLG_T200_RUN, &l2->flag)) {
1494 mISDN_FsmDelTimer(&l2->t203, 13);
1495 mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, 11);
1502 struct layer2 *l2 = fi->userdata;
1508 if (test_bit(FLG_ORIG, &l2->flag))
1511 skb_pull(skb, l2addrsize(l2));
1513 if (IsRNR(skb->data, l2)) {
1514 set_peer_busy(l2);
1517 clear_peer_busy(l2);
1519 if (test_bit(FLG_MOD128, &l2->flag)) {
1528 if (legalnr(l2, nr)) {
1530 restart_t200(l2, 15);
1532 stop_t200(l2, 16);
1533 mISDN_FsmAddTimer(&l2->t203, l2->T203,
1535 setva(l2, nr);
1537 invoke_retransmission(l2, nr);
1539 if (skb_queue_len(&l2->i_queue) && cansend(l2))
1545 enquiry_response(l2);
1546 if (legalnr(l2, nr))
1547 setva(l2, nr);
1556 struct layer2 *l2 = fi->userdata;
1559 skb_pull(skb, l2addrsize(l2) + 1);
1563 l2mgr(l2, MDL_ERROR_IND, (void *) 'K');
1565 test_and_clear_bit(FLG_L3_INIT, &l2->flag);
1573 struct layer2 *l2 = fi->userdata;
1575 skb_queue_purge(&l2->ui_queue);
1576 l2->tei = GROUP_TEI;
1583 struct layer2 *l2 = fi->userdata;
1585 skb_queue_purge(&l2->ui_queue);
1586 l2->tei = GROUP_TEI;
1587 l2up_create(l2, DL_RELEASE_IND, 0, NULL);
1594 struct layer2 *l2 = fi->userdata;
1596 skb_queue_purge(&l2->i_queue);
1597 skb_queue_purge(&l2->ui_queue);
1598 freewin(l2);
1599 l2->tei = GROUP_TEI;
1600 stop_t200(l2, 17);
1601 st5_dl_release_l2l3(l2);
1608 struct layer2 *l2 = fi->userdata;
1610 skb_queue_purge(&l2->ui_queue);
1611 l2->tei = GROUP_TEI;
1612 stop_t200(l2, 18);
1613 l2up_create(l2, DL_RELEASE_IND, 0, NULL);
1620 struct layer2 *l2 = fi->userdata;
1622 skb_queue_purge(&l2->i_queue);
1623 skb_queue_purge(&l2->ui_queue);
1624 freewin(l2);
1625 l2->tei = GROUP_TEI;
1626 stop_t200(l2, 17);
1627 mISDN_FsmDelTimer(&l2->t203, 19);
1628 l2up_create(l2, DL_RELEASE_IND, 0, NULL);
1629 /* mISDN_queue_data(&l2->inst, l2->inst.id | MSG_BROADCAST,
1639 struct layer2 *l2 = fi->userdata;
1642 skb_queue_purge(&l2->i_queue);
1643 skb_queue_purge(&l2->ui_queue);
1644 if (test_and_clear_bit(FLG_ESTAB_PEND, &l2->flag))
1645 l2up(l2, DL_RELEASE_IND, skb);
1653 struct layer2 *l2 = fi->userdata;
1656 skb_queue_purge(&l2->i_queue);
1657 skb_queue_purge(&l2->ui_queue);
1658 freewin(l2);
1659 stop_t200(l2, 19);
1660 st5_dl_release_l2l3(l2);
1662 if (l2->tm)
1663 l2_tei(l2, MDL_STATUS_DOWN_IND, 0);
1670 struct layer2 *l2 = fi->userdata;
1673 skb_queue_purge(&l2->ui_queue);
1674 stop_t200(l2, 20);
1675 l2up(l2, DL_RELEASE_CNF, skb);
1677 if (l2->tm)
1678 l2_tei(l2, MDL_STATUS_DOWN_IND, 0);
1684 struct layer2 *l2 = fi->userdata;
1687 skb_queue_purge(&l2->i_queue);
1688 skb_queue_purge(&l2->ui_queue);
1689 freewin(l2);
1690 stop_t200(l2, 19);
1691 mISDN_FsmDelTimer(&l2->t203, 19);
1692 l2up(l2, DL_RELEASE_IND, skb);
1694 if (l2->tm)
1695 l2_tei(l2, MDL_STATUS_DOWN_IND, 0);
1701 struct layer2 *l2 = fi->userdata;
1704 if (!test_and_set_bit(FLG_OWN_BUSY, &l2->flag)) {
1705 enquiry_cr(l2, RNR, RSP, 0);
1706 test_and_clear_bit(FLG_ACK_PEND, &l2->flag);
1715 struct layer2 *l2 = fi->userdata;
1718 if (!test_and_clear_bit(FLG_OWN_BUSY, &l2->flag)) {
1719 enquiry_cr(l2, RR, RSP, 0);
1720 test_and_clear_bit(FLG_ACK_PEND, &l2->flag);
1729 struct layer2 *l2 = fi->userdata;
1731 l2mgr(l2, MDL_ERROR_IND, arg);
1737 struct layer2 *l2 = fi->userdata;
1739 l2mgr(l2, MDL_ERROR_IND, arg);
1741 test_and_clear_bit(FLG_L3_INIT, &l2->flag);
1837 ph_data_indication(struct layer2 *l2, struct mISDNhead *hh, struct sk_buff *skb)
1845 l = l2addrsize(l2);
1847 mISDN_FsmEvent(&l2->l2m, EV_L2_FRAME_ERROR, (void *) 'N');
1850 if (test_bit(FLG_LAPD, &l2->flag)) { /* Maybe not needed */
1855 "l2 D-channel frame wrong EA0/EA1\n");
1860 if (psapi != l2->sapi) {
1864 __func__, psapi, l2->sapi);
1868 if ((ptei != l2->tei) && (ptei != GROUP_TEI)) {
1872 __func__, ptei, l2->tei);
1879 c = iframe_error(l2, skb);
1881 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_I, skb);
1882 } else if (IsSFrame(datap, l2)) { /* S-Frame */
1883 c = super_error(l2, skb);
1885 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_SUPER, skb);
1887 c = UI_error(l2, skb);
1889 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_UI, skb);
1890 } else if (IsSABME(datap, l2)) {
1891 c = unnum_error(l2, skb, CMD);
1893 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_SABME, skb);
1895 c = unnum_error(l2, skb, RSP);
1897 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_UA, skb);
1899 c = unnum_error(l2, skb, CMD);
1901 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_DISC, skb);
1903 c = unnum_error(l2, skb, RSP);
1905 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_DM, skb);
1907 c = FRMR_error(l2, skb);
1909 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_FRMR, skb);
1913 printk(KERN_WARNING "l2 D-channel frame error %c\n", c);
1914 mISDN_FsmEvent(&l2->l2m, EV_L2_FRAME_ERROR, (void *)(long)c);
1922 struct layer2 *l2 = container_of(ch, struct layer2, ch);
1928 __func__, hh->prim, hh->id, l2->sapi, l2->tei);
1931 ret = ph_data_indication(l2, hh, skb);
1934 ret = ph_data_confirm(l2, hh, skb);
1937 test_and_set_bit(FLG_L1_ACTIV, &l2->flag);
1938 l2up_create(l2, MPH_ACTIVATE_IND, 0, NULL);
1939 if (test_and_clear_bit(FLG_ESTAB_PEND, &l2->flag))
1940 ret = mISDN_FsmEvent(&l2->l2m,
1944 test_and_clear_bit(FLG_L1_ACTIV, &l2->flag);
1945 l2up_create(l2, MPH_DEACTIVATE_IND, 0, NULL);
1946 ret = mISDN_FsmEvent(&l2->l2m, EV_L1_DEACTIVATE, skb);
1949 if (!l2->up)
1951 ret = l2->up->send(l2->up, skb);
1954 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_DL_DATA, skb);
1957 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_DL_UNITDATA, skb);
1960 if (test_bit(FLG_LAPB, &l2->flag))
1961 test_and_set_bit(FLG_ORIG, &l2->flag);
1962 if (test_bit(FLG_L1_ACTIV, &l2->flag)) {
1963 if (test_bit(FLG_LAPD, &l2->flag) ||
1964 test_bit(FLG_ORIG, &l2->flag))
1965 ret = mISDN_FsmEvent(&l2->l2m,
1968 if (test_bit(FLG_LAPD, &l2->flag) ||
1969 test_bit(FLG_ORIG, &l2->flag)) {
1971 &l2->flag);
1973 ret = l2down(l2, PH_ACTIVATE_REQ, l2_newid(l2),
1978 if (test_bit(FLG_LAPB, &l2->flag))
1979 l2down_create(l2, PH_DEACTIVATE_REQ,
1980 l2_newid(l2), 0, NULL);
1981 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_DL_RELEASE_REQ,
1986 l2m_debug(&l2->l2m, "l2 unknown pr %04x",
1997 tei_l2(struct layer2 *l2, u_int cmd, u_long arg)
2005 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_MDL_ASSIGN, (void *)arg);
2008 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_MDL_REMOVE, NULL);
2011 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_MDL_ERROR, NULL);
2016 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_MDL_ERROR, NULL);
2023 release_l2(struct layer2 *l2)
2025 mISDN_FsmDelTimer(&l2->t200, 21);
2026 mISDN_FsmDelTimer(&l2->t203, 16);
2027 skb_queue_purge(&l2->i_queue);
2028 skb_queue_purge(&l2->ui_queue);
2029 skb_queue_purge(&l2->down_queue);
2030 ReleaseWin(l2);
2031 if (test_bit(FLG_LAPD, &l2->flag)) {
2032 TEIrelease(l2);
2033 if (l2->ch.st)
2034 l2->ch.st->dev->D.ctrl(&l2->ch.st->dev->D,
2037 kfree(l2);
2043 struct layer2 *l2 = container_of(ch, struct layer2, ch);
2051 if (test_bit(FLG_LAPD, &l2->flag)) {
2052 set_channel_address(&l2->ch, l2->sapi, l2->tei);
2054 l2up_create(l2, DL_INFORMATION_IND,
2059 if (l2->ch.peer)
2060 l2->ch.peer->ctrl(l2->ch.peer, CLOSE_CHANNEL, NULL);
2061 release_l2(l2);
2071 struct layer2 *l2;
2074 l2 = kzalloc(sizeof(struct layer2), GFP_KERNEL);
2075 if (!l2) {
2079 l2->next_id = 1;
2080 l2->down_id = MISDN_ID_NONE;
2081 l2->up = ch;
2082 l2->ch.st = ch->st;
2083 l2->ch.send = l2_send;
2084 l2->ch.ctrl = l2_ctrl;
2087 test_and_set_bit(FLG_LAPD, &l2->flag);
2088 test_and_set_bit(FLG_LAPD_NET, &l2->flag);
2089 test_and_set_bit(FLG_MOD128, &l2->flag);
2090 l2->sapi = sapi;
2091 l2->maxlen = MAX_DFRAME_LEN;
2093 l2->window = 7;
2095 l2->window = 1;
2097 test_and_set_bit(FLG_PTP, &l2->flag);
2099 test_and_set_bit(FLG_FIXED_TEI, &l2->flag);
2100 l2->tei = tei;
2101 l2->T200 = 1000;
2102 l2->N200 = 3;
2103 l2->T203 = 10000;
2109 l2->ch.st->dev->D.ctrl(&l2->ch.st->dev->D, OPEN_CHANNEL, &rq);
2112 test_and_set_bit(FLG_LAPD, &l2->flag);
2113 test_and_set_bit(FLG_MOD128, &l2->flag);
2114 test_and_set_bit(FLG_ORIG, &l2->flag);
2115 l2->sapi = sapi;
2116 l2->maxlen = MAX_DFRAME_LEN;
2118 l2->window = 7;
2120 l2->window = 1;
2122 test_and_set_bit(FLG_PTP, &l2->flag);
2124 test_and_set_bit(FLG_FIXED_TEI, &l2->flag);
2125 l2->tei = tei;
2126 l2->T200 = 1000;
2127 l2->N200 = 3;
2128 l2->T203 = 10000;
2134 l2->ch.st->dev->D.ctrl(&l2->ch.st->dev->D, OPEN_CHANNEL, &rq);
2137 test_and_set_bit(FLG_LAPB, &l2->flag);
2138 l2->window = 7;
2139 l2->maxlen = MAX_DATA_SIZE;
2140 l2->T200 = 1000;
2141 l2->N200 = 4;
2142 l2->T203 = 5000;
2143 l2->addr.A = 3;
2144 l2->addr.B = 1;
2149 kfree(l2);
2152 skb_queue_head_init(&l2->i_queue);
2153 skb_queue_head_init(&l2->ui_queue);
2154 skb_queue_head_init(&l2->down_queue);
2155 skb_queue_head_init(&l2->tmp_queue);
2156 InitWin(l2);
2157 l2->l2m.fsm = &l2fsm;
2158 if (test_bit(FLG_LAPB, &l2->flag) ||
2159 test_bit(FLG_PTP, &l2->flag) ||
2160 test_bit(FLG_LAPD_NET, &l2->flag))
2161 l2->l2m.state = ST_L2_4;
2163 l2->l2m.state = ST_L2_1;
2164 l2->l2m.debug = *debug;
2165 l2->l2m.userdata = l2;
2166 l2->l2m.userint = 0;
2167 l2->l2m.printdebug = l2m_debug;
2169 mISDN_FsmInitTimer(&l2->l2m, &l2->t200);
2170 mISDN_FsmInitTimer(&l2->l2m, &l2->t203);
2171 return l2;
2177 struct layer2 *l2;
2181 l2 = create_l2(crq->ch, crq->protocol, 0, 0, 0);
2182 if (!l2)
2184 crq->ch = &l2->ch;