Lines Matching refs:l2
92 struct layer2 *l2 = fi->userdata;
104 printk(KERN_DEBUG "%s l2 (sapi %d tei %d): %pV\n",
105 mISDNDevName4ch(&l2->ch), l2->sapi, l2->tei, &vaf);
111 l2headersize(struct layer2 *l2, int ui)
113 return ((test_bit(FLG_MOD128, &l2->flag) && (!ui)) ? 2 : 1) +
114 (test_bit(FLG_LAPD, &l2->flag) ? 2 : 1);
118 l2addrsize(struct layer2 *l2)
120 return test_bit(FLG_LAPD, &l2->flag) ? 2 : 1;
124 l2_newid(struct layer2 *l2)
128 id = l2->next_id++;
130 l2->next_id = 1;
132 id |= l2->tei << 8;
133 id |= l2->sapi;
138 l2up(struct layer2 *l2, u_int prim, struct sk_buff *skb)
142 if (!l2->up)
145 mISDN_HEAD_ID(skb) = (l2->ch.nr << 16) | l2->ch.addr;
146 err = l2->up->send(l2->up, skb);
149 mISDNDevName4ch(&l2->ch), err);
155 l2up_create(struct layer2 *l2, u_int prim, int len, void *arg)
161 if (!l2->up)
168 hh->id = (l2->ch.nr << 16) | l2->ch.addr;
171 err = l2->up->send(l2->up, skb);
174 mISDNDevName4ch(&l2->ch), err);
180 l2down_skb(struct layer2 *l2, struct sk_buff *skb) {
183 ret = l2->ch.recv(l2->ch.peer, skb);
186 mISDNDevName4ch(&l2->ch), ret);
191 l2down_raw(struct layer2 *l2, struct sk_buff *skb)
196 if (test_and_set_bit(FLG_L1_NOTREADY, &l2->flag)) {
197 skb_queue_tail(&l2->down_queue, skb);
200 l2->down_id = mISDN_HEAD_ID(skb);
202 return l2down_skb(l2, skb);
206 l2down(struct layer2 *l2, u_int prim, u_int id, struct sk_buff *skb)
212 return l2down_raw(l2, skb);
216 l2down_create(struct layer2 *l2, u_int prim, u_int id, int len, void *arg)
230 err = l2down_raw(l2, skb);
237 ph_data_confirm(struct layer2 *l2, struct mISDNhead *hh, struct sk_buff *skb) {
241 if (test_bit(FLG_L1_NOTREADY, &l2->flag)) {
242 if (hh->id == l2->down_id) {
243 nskb = skb_dequeue(&l2->down_queue);
245 l2->down_id = mISDN_HEAD_ID(nskb);
246 if (l2down_skb(l2, nskb)) {
248 l2->down_id = MISDN_ID_NONE;
251 l2->down_id = MISDN_ID_NONE;
256 if (l2->down_id == MISDN_ID_NONE) {
257 test_and_clear_bit(FLG_L1_NOTREADY, &l2->flag);
258 mISDN_FsmEvent(&l2->l2m, EV_L2_ACK_PULL, NULL);
262 if (!test_and_set_bit(FLG_L1_NOTREADY, &l2->flag)) {
263 nskb = skb_dequeue(&l2->down_queue);
265 l2->down_id = mISDN_HEAD_ID(nskb);
266 if (l2down_skb(l2, nskb)) {
268 l2->down_id = MISDN_ID_NONE;
269 test_and_clear_bit(FLG_L1_NOTREADY, &l2->flag);
272 test_and_clear_bit(FLG_L1_NOTREADY, &l2->flag);
280 struct layer2 *l2 = fi->userdata;
287 mISDNDevName4ch(&l2->ch), l2->sapi, l2->tei,
288 l2->ch.nr, event == EV_L2_T200 ? "T200" : "T203");
293 hh->id = l2->ch.nr;
296 mISDNDevName4ch(&l2->ch), l2->sapi, l2->tei,
297 l2->ch.nr, event == EV_L2_T200 ? "T200" : "T203");
298 if (l2->ch.st)
299 l2->ch.st->own.recv(&l2->ch.st->own, skb);
303 l2mgr(struct layer2 *l2, u_int prim, void *arg) {
307 mISDNDevName4ch(&l2->ch), l2->id, prim, (char)c);
308 if (test_bit(FLG_LAPD, &l2->flag) &&
309 !test_bit(FLG_FIXED_TEI, &l2->flag)) {
315 l2_tei(l2, prim, (u_long)arg);
323 set_peer_busy(struct layer2 *l2) {
324 test_and_set_bit(FLG_PEER_BUSY, &l2->flag);
325 if (skb_queue_len(&l2->i_queue) || skb_queue_len(&l2->ui_queue))
326 test_and_set_bit(FLG_L2BLOCK, &l2->flag);
330 clear_peer_busy(struct layer2 *l2) {
331 if (test_and_clear_bit(FLG_PEER_BUSY, &l2->flag))
332 test_and_clear_bit(FLG_L2BLOCK, &l2->flag);
336 InitWin(struct layer2 *l2)
341 l2->windowar[i] = NULL;
345 freewin(struct layer2 *l2)
350 if (l2->windowar[i]) {
352 dev_kfree_skb(l2->windowar[i]);
353 l2->windowar[i] = NULL;
360 ReleaseWin(struct layer2 *l2)
362 int cnt = freewin(l2);
370 cansend(struct layer2 *l2)
374 if (test_bit(FLG_MOD128, &l2->flag))
375 p1 = (l2->vs - l2->va) % 128;
377 p1 = (l2->vs - l2->va) % 8;
378 return (p1 < l2->window) && !test_bit(FLG_PEER_BUSY, &l2->flag);
382 clear_exception(struct layer2 *l2)
384 test_and_clear_bit(FLG_ACK_PEND, &l2->flag);
385 test_and_clear_bit(FLG_REJEXC, &l2->flag);
386 test_and_clear_bit(FLG_OWN_BUSY, &l2->flag);
387 clear_peer_busy(l2);
391 sethdraddr(struct layer2 *l2, u_char *header, int rsp)
396 if (test_bit(FLG_LAPD, &l2->flag)) {
397 if (test_bit(FLG_LAPD_NET, &l2->flag))
399 *ptr++ = (l2->sapi << 2) | (crbit ? 2 : 0);
400 *ptr++ = (l2->tei << 1) | 1;
403 if (test_bit(FLG_ORIG, &l2->flag))
406 *ptr++ = l2->addr.B;
408 *ptr++ = l2->addr.A;
414 enqueue_super(struct layer2 *l2, struct sk_buff *skb)
416 if (l2down(l2, PH_DATA_REQ, l2_newid(l2), skb))
421 enqueue_ui(struct layer2 *l2, struct sk_buff *skb)
423 if (l2->tm)
424 l2_tei(l2, MDL_STATUS_UI_IND, 0);
425 if (l2down(l2, PH_DATA_REQ, l2_newid(l2), skb))
454 IsRR(u_char *data, struct layer2 *l2)
456 if (test_bit(FLG_MOD128, &l2->flag))
463 IsSFrame(u_char *data, struct layer2 *l2)
467 if (!test_bit(FLG_MOD128, &l2->flag))
473 IsSABME(u_char *data, struct layer2 *l2)
477 return test_bit(FLG_MOD128, &l2->flag) ? d == SABME : d == SABM;
481 IsREJ(u_char *data, struct layer2 *l2)
483 return test_bit(FLG_MOD128, &l2->flag) ?
494 IsRNR(u_char *data, struct layer2 *l2)
496 return test_bit(FLG_MOD128, &l2->flag) ?
501 iframe_error(struct layer2 *l2, struct sk_buff *skb)
506 i = l2addrsize(l2) + (test_bit(FLG_MOD128, &l2->flag) ? 2 : 1);
507 if (test_bit(FLG_ORIG, &l2->flag))
513 if ((skb->len - i) > l2->maxlen)
519 super_error(struct layer2 *l2, struct sk_buff *skb)
521 if (skb->len != l2addrsize(l2) +
522 (test_bit(FLG_MOD128, &l2->flag) ? 2 : 1))
528 unnum_error(struct layer2 *l2, struct sk_buff *skb, int wantrsp)
531 if (test_bit(FLG_ORIG, &l2->flag))
535 if (skb->len != l2addrsize(l2) + 1)
541 UI_error(struct layer2 *l2, struct sk_buff *skb)
544 if (test_bit(FLG_ORIG, &l2->flag))
548 if (skb->len > l2->maxlen + l2addrsize(l2) + 1)
554 FRMR_error(struct layer2 *l2, struct sk_buff *skb)
556 u_int headers = l2addrsize(l2) + 1;
560 if (test_bit(FLG_ORIG, &l2->flag))
564 if (test_bit(FLG_MOD128, &l2->flag)) {
568 l2m_debug(&l2->l2m,
575 l2m_debug(&l2->l2m,
583 legalnr(struct layer2 *l2, unsigned int nr)
585 if (test_bit(FLG_MOD128, &l2->flag))
586 return ((nr - l2->va) % 128) <= ((l2->vs - l2->va) % 128);
588 return ((nr - l2->va) % 8) <= ((l2->vs - l2->va) % 8);
592 setva(struct layer2 *l2, unsigned int nr)
596 while (l2->va != nr) {
597 l2->va++;
598 if (test_bit(FLG_MOD128, &l2->flag))
599 l2->va %= 128;
601 l2->va %= 8;
602 if (l2->windowar[l2->sow]) {
603 skb_trim(l2->windowar[l2->sow], 0);
604 skb_queue_tail(&l2->tmp_queue, l2->windowar[l2->sow]);
605 l2->windowar[l2->sow] = NULL;
607 l2->sow = (l2->sow + 1) % l2->window;
609 skb = skb_dequeue(&l2->tmp_queue);
612 skb = skb_dequeue(&l2->tmp_queue);
617 send_uframe(struct layer2 *l2, struct sk_buff *skb, u_char cmd, u_char cr)
622 i = sethdraddr(l2, tmp, cr);
630 mISDNDevName4ch(&l2->ch), __func__);
635 enqueue_super(l2, skb);
640 get_PollFlag(struct layer2 *l2, struct sk_buff *skb)
642 return skb->data[l2addrsize(l2)] & 0x10;
646 get_PollFlagFree(struct layer2 *l2, struct sk_buff *skb)
650 PF = get_PollFlag(l2, skb);
656 start_t200(struct layer2 *l2, int i)
658 mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, i);
659 test_and_set_bit(FLG_T200_RUN, &l2->flag);
663 restart_t200(struct layer2 *l2, int i)
665 mISDN_FsmRestartTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, i);
666 test_and_set_bit(FLG_T200_RUN, &l2->flag);
670 stop_t200(struct layer2 *l2, int i)
672 if (test_and_clear_bit(FLG_T200_RUN, &l2->flag))
673 mISDN_FsmDelTimer(&l2->t200, i);
677 st5_dl_release_l2l3(struct layer2 *l2)
681 if (test_and_clear_bit(FLG_PEND_REL, &l2->flag))
685 l2up_create(l2, pr, 0, NULL);
689 lapb_dl_release_l2l3(struct layer2 *l2, int f)
691 if (test_bit(FLG_LAPB, &l2->flag))
692 l2down_create(l2, PH_DEACTIVATE_REQ, l2_newid(l2), 0, NULL);
693 l2up_create(l2, f, 0, NULL);
699 struct layer2 *l2 = fi->userdata;
702 clear_exception(l2);
703 l2->rc = 0;
704 cmd = (test_bit(FLG_MOD128, &l2->flag) ? SABME : SABM) | 0x10;
705 send_uframe(l2, NULL, cmd, CMD);
706 mISDN_FsmDelTimer(&l2->t203, 1);
707 restart_t200(l2, 1);
708 test_and_clear_bit(FLG_PEND_REL, &l2->flag);
709 freewin(l2);
717 struct layer2 *l2 = fi->userdata;
719 if (get_PollFlagFree(l2, skb))
720 l2mgr(l2, MDL_ERROR_IND, (void *) 'C');
722 l2mgr(l2, MDL_ERROR_IND, (void *) 'D');
730 struct layer2 *l2 = fi->userdata;
732 if (get_PollFlagFree(l2, skb))
733 l2mgr(l2, MDL_ERROR_IND, (void *) 'B');
735 l2mgr(l2, MDL_ERROR_IND, (void *) 'E');
737 test_and_clear_bit(FLG_L3_INIT, &l2->flag);
745 struct layer2 *l2 = fi->userdata;
747 if (get_PollFlagFree(l2, skb))
748 l2mgr(l2, MDL_ERROR_IND, (void *) 'B');
750 l2mgr(l2, MDL_ERROR_IND, (void *) 'E');
752 test_and_clear_bit(FLG_L3_INIT, &l2->flag);
765 struct layer2 *l2 = fi->userdata;
769 l2_tei(l2, MDL_ASSIGN_IND, 0);
775 struct layer2 *l2 = fi->userdata;
778 skb_queue_tail(&l2->ui_queue, skb);
780 l2_tei(l2, MDL_ASSIGN_IND, 0);
786 struct layer2 *l2 = fi->userdata;
789 skb_queue_tail(&l2->ui_queue, skb);
793 tx_ui(struct layer2 *l2)
799 i = sethdraddr(l2, header, CMD);
800 if (test_bit(FLG_LAPD_NET, &l2->flag))
803 while ((skb = skb_dequeue(&l2->ui_queue))) {
805 enqueue_ui(l2, skb);
812 struct layer2 *l2 = fi->userdata;
815 skb_queue_tail(&l2->ui_queue, skb);
816 tx_ui(l2);
822 struct layer2 *l2 = fi->userdata;
825 skb_pull(skb, l2headersize(l2, 1));
830 if (l2->tm)
831 l2_tei(l2, MDL_STATUS_UI_IND, 0);
832 l2up(l2, DL_UNITDATA_IND, skb);
839 struct layer2 *l2 = fi->userdata;
842 test_and_set_bit(FLG_L3_INIT, &l2->flag);
850 struct layer2 *l2 = fi->userdata;
852 skb_queue_purge(&l2->i_queue);
853 test_and_set_bit(FLG_L3_INIT, &l2->flag);
854 test_and_clear_bit(FLG_PEND_REL, &l2->flag);
862 struct layer2 *l2 = fi->userdata;
864 skb_queue_purge(&l2->i_queue);
866 test_and_set_bit(FLG_L3_INIT, &l2->flag);
873 struct layer2 *l2 = fi->userdata;
877 l2up(l2, DL_RELEASE_CNF, skb);
884 struct layer2 *l2 = fi->userdata;
886 test_and_set_bit(FLG_PEND_REL, &l2->flag);
893 struct layer2 *l2 = fi->userdata;
896 skb_queue_purge(&l2->i_queue);
897 freewin(l2);
899 l2->rc = 0;
900 send_uframe(l2, NULL, DISC | 0x10, CMD);
901 mISDN_FsmDelTimer(&l2->t203, 1);
902 restart_t200(l2, 2);
909 struct layer2 *l2 = fi->userdata;
912 l2->vs = 0;
913 l2->va = 0;
914 l2->vr = 0;
915 l2->sow = 0;
916 clear_exception(l2);
917 send_uframe(l2, NULL, UA | get_PollFlag(l2, skb), RSP);
919 mISDN_FsmAddTimer(&l2->t203, l2->T203, EV_L2_T203, NULL, 3);
921 l2up(l2, DL_ESTABLISH_IND, skb);
922 if (l2->tm)
923 l2_tei(l2, MDL_STATUS_UP_IND, 0);
929 struct layer2 *l2 = fi->userdata;
932 send_uframe(l2, skb, UA | get_PollFlag(l2, skb), RSP);
938 struct layer2 *l2 = fi->userdata;
941 send_uframe(l2, skb, DM | get_PollFlag(l2, skb), RSP);
947 struct layer2 *l2 = fi->userdata;
951 send_uframe(l2, skb, UA | get_PollFlag(l2, skb), RSP);
953 l2mgr(l2, MDL_ERROR_IND, (void *) 'F');
955 if (l2->vs != l2->va) {
956 skb_queue_purge(&l2->i_queue);
960 clear_exception(l2);
961 l2->vs = 0;
962 l2->va = 0;
963 l2->vr = 0;
964 l2->sow = 0;
966 stop_t200(l2, 3);
967 mISDN_FsmRestartTimer(&l2->t203, l2->T203, EV_L2_T203, NULL, 3);
970 l2up_create(l2, DL_ESTABLISH_IND, 0, NULL);
971 /* mISDN_queue_data(&l2->inst, l2->inst.id | MSG_BROADCAST,
975 if (skb_queue_len(&l2->i_queue) && cansend(l2))
982 struct layer2 *l2 = fi->userdata;
986 mISDN_FsmDelTimer(&l2->t203, 3);
987 stop_t200(l2, 4);
989 send_uframe(l2, skb, UA | get_PollFlag(l2, skb), RSP);
990 skb_queue_purge(&l2->i_queue);
991 freewin(l2);
992 lapb_dl_release_l2l3(l2, DL_RELEASE_IND);
993 if (l2->tm)
994 l2_tei(l2, MDL_STATUS_DOWN_IND, 0);
1000 struct layer2 *l2 = fi->userdata;
1004 if (!get_PollFlag(l2, skb)) {
1009 if (test_and_clear_bit(FLG_PEND_REL, &l2->flag))
1011 if (test_and_clear_bit(FLG_L3_INIT, &l2->flag)) {
1013 } else if (l2->vs != l2->va) {
1014 skb_queue_purge(&l2->i_queue);
1017 stop_t200(l2, 5);
1018 l2->vr = 0;
1019 l2->vs = 0;
1020 l2->va = 0;
1021 l2->sow = 0;
1023 mISDN_FsmAddTimer(&l2->t203, l2->T203, EV_L2_T203, NULL, 4);
1025 l2up_create(l2, pr, 0, NULL);
1027 if (skb_queue_len(&l2->i_queue) && cansend(l2))
1030 if (l2->tm)
1031 l2_tei(l2, MDL_STATUS_UP_IND, 0);
1037 struct layer2 *l2 = fi->userdata;
1040 if (!get_PollFlag(l2, skb)) {
1045 stop_t200(l2, 6);
1046 lapb_dl_release_l2l3(l2, DL_RELEASE_CNF);
1048 if (l2->tm)
1049 l2_tei(l2, MDL_STATUS_DOWN_IND, 0);
1055 struct layer2 *l2 = fi->userdata;
1058 if (!get_PollFlagFree(l2, skb)) {
1060 test_and_set_bit(FLG_L3_INIT, &l2->flag);
1067 struct layer2 *l2 = fi->userdata;
1070 if (get_PollFlagFree(l2, skb)) {
1071 stop_t200(l2, 7);
1072 if (!test_bit(FLG_L3_INIT, &l2->flag))
1073 skb_queue_purge(&l2->i_queue);
1074 if (test_bit(FLG_LAPB, &l2->flag))
1075 l2down_create(l2, PH_DEACTIVATE_REQ,
1076 l2_newid(l2), 0, NULL);
1077 st5_dl_release_l2l3(l2);
1079 if (l2->tm)
1080 l2_tei(l2, MDL_STATUS_DOWN_IND, 0);
1087 struct layer2 *l2 = fi->userdata;
1090 if (get_PollFlagFree(l2, skb)) {
1091 stop_t200(l2, 8);
1092 lapb_dl_release_l2l3(l2, DL_RELEASE_CNF);
1094 if (l2->tm)
1095 l2_tei(l2, MDL_STATUS_DOWN_IND, 0);
1100 enquiry_cr(struct layer2 *l2, u_char typ, u_char cr, u_char pf)
1106 i = sethdraddr(l2, tmp, cr);
1107 if (test_bit(FLG_MOD128, &l2->flag)) {
1109 tmp[i++] = (l2->vr << 1) | (pf ? 1 : 0);
1111 tmp[i++] = (l2->vr << 5) | typ | (pf ? 0x10 : 0);
1115 mISDNDevName4ch(&l2->ch), __func__);
1119 enqueue_super(l2, skb);
1123 enquiry_response(struct layer2 *l2)
1125 if (test_bit(FLG_OWN_BUSY, &l2->flag))
1126 enquiry_cr(l2, RNR, RSP, 1);
1128 enquiry_cr(l2, RR, RSP, 1);
1129 test_and_clear_bit(FLG_ACK_PEND, &l2->flag);
1133 transmit_enquiry(struct layer2 *l2)
1135 if (test_bit(FLG_OWN_BUSY, &l2->flag))
1136 enquiry_cr(l2, RNR, CMD, 1);
1138 enquiry_cr(l2, RR, CMD, 1);
1139 test_and_clear_bit(FLG_ACK_PEND, &l2->flag);
1140 start_t200(l2, 9);
1147 struct layer2 *l2 = fi->userdata;
1149 l2mgr(l2, MDL_ERROR_IND, (void *) 'J');
1151 test_and_clear_bit(FLG_L3_INIT, &l2->flag);
1155 invoke_retransmission(struct layer2 *l2, unsigned int nr)
1159 if (l2->vs != nr) {
1160 while (l2->vs != nr) {
1161 (l2->vs)--;
1162 if (test_bit(FLG_MOD128, &l2->flag)) {
1163 l2->vs %= 128;
1164 p1 = (l2->vs - l2->va) % 128;
1166 l2->vs %= 8;
1167 p1 = (l2->vs - l2->va) % 8;
1169 p1 = (p1 + l2->sow) % l2->window;
1170 if (l2->windowar[p1])
1171 skb_queue_head(&l2->i_queue, l2->windowar[p1]);
1175 mISDNDevName4ch(&l2->ch), p1);
1176 l2->windowar[p1] = NULL;
1178 mISDN_FsmEvent(&l2->l2m, EV_L2_ACK_PULL, NULL);
1185 struct layer2 *l2 = fi->userdata;
1191 if (test_bit(FLG_ORIG, &l2->flag))
1194 skb_pull(skb, l2addrsize(l2));
1195 if (IsRNR(skb->data, l2)) {
1196 set_peer_busy(l2);
1199 clear_peer_busy(l2);
1200 if (IsREJ(skb->data, l2))
1203 if (test_bit(FLG_MOD128, &l2->flag)) {
1214 l2mgr(l2, MDL_ERROR_IND, (void *) 'A');
1216 enquiry_response(l2);
1218 if (legalnr(l2, nr)) {
1220 setva(l2, nr);
1221 invoke_retransmission(l2, nr);
1222 stop_t200(l2, 10);
1223 if (mISDN_FsmAddTimer(&l2->t203, l2->T203,
1225 l2m_debug(&l2->l2m, "Restart T203 ST7 REJ");
1226 } else if ((nr == l2->vs) && (typ == RR)) {
1227 setva(l2, nr);
1228 stop_t200(l2, 11);
1229 mISDN_FsmRestartTimer(&l2->t203, l2->T203,
1231 } else if ((l2->va != nr) || (typ == RNR)) {
1232 setva(l2, nr);
1234 mISDN_FsmDelTimer(&l2->t203, 9);
1235 restart_t200(l2, 12);
1237 if (skb_queue_len(&l2->i_queue) && (typ == RR))
1246 struct layer2 *l2 = fi->userdata;
1249 if (!test_bit(FLG_L3_INIT, &l2->flag))
1250 skb_queue_tail(&l2->i_queue, skb);
1258 struct layer2 *l2 = fi->userdata;
1261 skb_queue_tail(&l2->i_queue, skb);
1268 struct layer2 *l2 = fi->userdata;
1271 skb_queue_tail(&l2->i_queue, skb);
1277 struct layer2 *l2 = fi->userdata;
1282 i = l2addrsize(l2);
1283 if (test_bit(FLG_MOD128, &l2->flag)) {
1292 if (test_bit(FLG_OWN_BUSY, &l2->flag)) {
1295 enquiry_response(l2);
1297 if (l2->vr == ns) {
1298 l2->vr++;
1299 if (test_bit(FLG_MOD128, &l2->flag))
1300 l2->vr %= 128;
1302 l2->vr %= 8;
1303 test_and_clear_bit(FLG_REJEXC, &l2->flag);
1305 enquiry_response(l2);
1307 test_and_set_bit(FLG_ACK_PEND, &l2->flag);
1308 skb_pull(skb, l2headersize(l2, 0));
1309 l2up(l2, DL_DATA_IND, skb);
1313 if (test_and_set_bit(FLG_REJEXC, &l2->flag)) {
1315 enquiry_response(l2);
1317 enquiry_cr(l2, REJ, RSP, PollFlag);
1318 test_and_clear_bit(FLG_ACK_PEND, &l2->flag);
1322 if (legalnr(l2, nr)) {
1323 if (!test_bit(FLG_PEER_BUSY, &l2->flag) &&
1325 if (nr == l2->vs) {
1326 stop_t200(l2, 13);
1327 mISDN_FsmRestartTimer(&l2->t203, l2->T203,
1329 } else if (nr != l2->va)
1330 restart_t200(l2, 14);
1332 setva(l2, nr);
1337 if (skb_queue_len(&l2->i_queue) && (fi->state == ST_L2_7))
1339 if (test_and_clear_bit(FLG_ACK_PEND, &l2->flag))
1340 enquiry_cr(l2, RR, RSP, 0);
1346 struct layer2 *l2 = fi->userdata;
1349 l2->tei = (signed char)(long)arg;
1350 set_channel_address(&l2->ch, l2->sapi, l2->tei);
1352 l2up_create(l2, DL_INFORMATION_IND, sizeof(info), &info);
1355 test_and_set_bit(FLG_L3_INIT, &l2->flag);
1358 if (skb_queue_len(&l2->ui_queue))
1359 tx_ui(l2);
1365 struct layer2 *l2 = fi->userdata;
1367 if (test_bit(FLG_LAPD, &l2->flag) &&
1368 test_bit(FLG_DCHAN_BUSY, &l2->flag)) {
1369 mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, 9);
1370 } else if (l2->rc == l2->N200) {
1372 test_and_clear_bit(FLG_T200_RUN, &l2->flag);
1373 skb_queue_purge(&l2->i_queue);
1374 l2mgr(l2, MDL_ERROR_IND, (void *) 'G');
1375 if (test_bit(FLG_LAPB, &l2->flag))
1376 l2down_create(l2, PH_DEACTIVATE_REQ,
1377 l2_newid(l2), 0, NULL);
1378 st5_dl_release_l2l3(l2);
1379 if (l2->tm)
1380 l2_tei(l2, MDL_STATUS_DOWN_IND, 0);
1382 l2->rc++;
1383 mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, 9);
1384 send_uframe(l2, NULL, (test_bit(FLG_MOD128, &l2->flag) ?
1392 struct layer2 *l2 = fi->userdata;
1394 if (test_bit(FLG_LAPD, &l2->flag) &&
1395 test_bit(FLG_DCHAN_BUSY, &l2->flag)) {
1396 mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, 9);
1397 } else if (l2->rc == l2->N200) {
1399 test_and_clear_bit(FLG_T200_RUN, &l2->flag);
1400 l2mgr(l2, MDL_ERROR_IND, (void *) 'H');
1401 lapb_dl_release_l2l3(l2, DL_RELEASE_CNF);
1402 if (l2->tm)
1403 l2_tei(l2, MDL_STATUS_DOWN_IND, 0);
1405 l2->rc++;
1406 mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200,
1408 send_uframe(l2, NULL, DISC | 0x10, CMD);
1415 struct layer2 *l2 = fi->userdata;
1417 if (test_bit(FLG_LAPD, &l2->flag) &&
1418 test_bit(FLG_DCHAN_BUSY, &l2->flag)) {
1419 mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, 9);
1422 test_and_clear_bit(FLG_T200_RUN, &l2->flag);
1423 l2->rc = 0;
1425 transmit_enquiry(l2);
1426 l2->rc++;
1432 struct layer2 *l2 = fi->userdata;
1434 if (test_bit(FLG_LAPD, &l2->flag) &&
1435 test_bit(FLG_DCHAN_BUSY, &l2->flag)) {
1436 mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, 9);
1439 test_and_clear_bit(FLG_T200_RUN, &l2->flag);
1440 if (l2->rc == l2->N200) {
1441 l2mgr(l2, MDL_ERROR_IND, (void *) 'I');
1443 test_and_clear_bit(FLG_L3_INIT, &l2->flag);
1445 transmit_enquiry(l2);
1446 l2->rc++;
1453 struct layer2 *l2 = fi->userdata;
1455 if (test_bit(FLG_LAPD, &l2->flag) &&
1456 test_bit(FLG_DCHAN_BUSY, &l2->flag)) {
1457 mISDN_FsmAddTimer(&l2->t203, l2->T203, EV_L2_T203, NULL, 9);
1461 transmit_enquiry(l2);
1462 l2->rc = 0;
1468 struct layer2 *l2 = fi->userdata;
1473 if (!cansend(l2))
1476 skb = skb_dequeue(&l2->i_queue);
1479 i = sethdraddr(l2, header, CMD);
1480 if (test_bit(FLG_MOD128, &l2->flag)) {
1481 header[i++] = l2->vs << 1;
1482 header[i++] = l2->vr << 1;
1484 header[i++] = (l2->vr << 5) | (l2->vs << 1);
1488 mISDNDevName4ch(&l2->ch), i);
1489 skb_queue_head(&l2->i_queue, skb);
1492 if (test_bit(FLG_MOD128, &l2->flag)) {
1493 p1 = (l2->vs - l2->va) % 128;
1494 l2->vs = (l2->vs + 1) % 128;
1496 p1 = (l2->vs - l2->va) % 8;
1497 l2->vs = (l2->vs + 1) % 8;
1499 p1 = (p1 + l2->sow) % l2->window;
1500 if (l2->windowar[p1]) {
1501 printk(KERN_WARNING "%s: l2 try overwrite ack queue entry %d\n",
1502 mISDNDevName4ch(&l2->ch), p1);
1503 dev_kfree_skb(l2->windowar[p1]);
1505 l2->windowar[p1] = skb;
1507 l2down(l2, PH_DATA_REQ, l2_newid(l2), nskb);
1508 test_and_clear_bit(FLG_ACK_PEND, &l2->flag);
1509 if (!test_and_set_bit(FLG_T200_RUN, &l2->flag)) {
1510 mISDN_FsmDelTimer(&l2->t203, 13);
1511 mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, 11);
1518 struct layer2 *l2 = fi->userdata;
1524 if (test_bit(FLG_ORIG, &l2->flag))
1527 skb_pull(skb, l2addrsize(l2));
1529 if (IsRNR(skb->data, l2)) {
1530 set_peer_busy(l2);
1533 clear_peer_busy(l2);
1535 if (test_bit(FLG_MOD128, &l2->flag)) {
1544 if (legalnr(l2, nr)) {
1546 restart_t200(l2, 15);
1548 stop_t200(l2, 16);
1549 mISDN_FsmAddTimer(&l2->t203, l2->T203,
1551 setva(l2, nr);
1553 invoke_retransmission(l2, nr);
1555 if (skb_queue_len(&l2->i_queue) && cansend(l2))
1561 enquiry_response(l2);
1562 if (legalnr(l2, nr))
1563 setva(l2, nr);
1572 struct layer2 *l2 = fi->userdata;
1575 skb_pull(skb, l2addrsize(l2) + 1);
1579 l2mgr(l2, MDL_ERROR_IND, (void *) 'K');
1581 test_and_clear_bit(FLG_L3_INIT, &l2->flag);
1589 struct layer2 *l2 = fi->userdata;
1591 skb_queue_purge(&l2->ui_queue);
1592 l2->tei = GROUP_TEI;
1599 struct layer2 *l2 = fi->userdata;
1601 skb_queue_purge(&l2->ui_queue);
1602 l2->tei = GROUP_TEI;
1603 l2up_create(l2, DL_RELEASE_IND, 0, NULL);
1610 struct layer2 *l2 = fi->userdata;
1612 skb_queue_purge(&l2->i_queue);
1613 skb_queue_purge(&l2->ui_queue);
1614 freewin(l2);
1615 l2->tei = GROUP_TEI;
1616 stop_t200(l2, 17);
1617 st5_dl_release_l2l3(l2);
1624 struct layer2 *l2 = fi->userdata;
1626 skb_queue_purge(&l2->ui_queue);
1627 l2->tei = GROUP_TEI;
1628 stop_t200(l2, 18);
1629 l2up_create(l2, DL_RELEASE_IND, 0, NULL);
1636 struct layer2 *l2 = fi->userdata;
1638 skb_queue_purge(&l2->i_queue);
1639 skb_queue_purge(&l2->ui_queue);
1640 freewin(l2);
1641 l2->tei = GROUP_TEI;
1642 stop_t200(l2, 17);
1643 mISDN_FsmDelTimer(&l2->t203, 19);
1644 l2up_create(l2, DL_RELEASE_IND, 0, NULL);
1645 /* mISDN_queue_data(&l2->inst, l2->inst.id | MSG_BROADCAST,
1655 struct layer2 *l2 = fi->userdata;
1658 skb_queue_purge(&l2->i_queue);
1659 skb_queue_purge(&l2->ui_queue);
1660 if (test_and_clear_bit(FLG_ESTAB_PEND, &l2->flag))
1661 l2up(l2, DL_RELEASE_IND, skb);
1669 struct layer2 *l2 = fi->userdata;
1672 skb_queue_purge(&l2->i_queue);
1673 skb_queue_purge(&l2->ui_queue);
1674 freewin(l2);
1675 stop_t200(l2, 19);
1676 st5_dl_release_l2l3(l2);
1678 if (l2->tm)
1679 l2_tei(l2, MDL_STATUS_DOWN_IND, 0);
1686 struct layer2 *l2 = fi->userdata;
1689 skb_queue_purge(&l2->ui_queue);
1690 stop_t200(l2, 20);
1691 l2up(l2, DL_RELEASE_CNF, skb);
1693 if (l2->tm)
1694 l2_tei(l2, MDL_STATUS_DOWN_IND, 0);
1700 struct layer2 *l2 = fi->userdata;
1703 skb_queue_purge(&l2->i_queue);
1704 skb_queue_purge(&l2->ui_queue);
1705 freewin(l2);
1706 stop_t200(l2, 19);
1707 mISDN_FsmDelTimer(&l2->t203, 19);
1708 l2up(l2, DL_RELEASE_IND, skb);
1710 if (l2->tm)
1711 l2_tei(l2, MDL_STATUS_DOWN_IND, 0);
1717 struct layer2 *l2 = fi->userdata;
1720 if (!test_and_set_bit(FLG_OWN_BUSY, &l2->flag)) {
1721 enquiry_cr(l2, RNR, RSP, 0);
1722 test_and_clear_bit(FLG_ACK_PEND, &l2->flag);
1730 struct layer2 *l2 = fi->userdata;
1733 if (!test_and_clear_bit(FLG_OWN_BUSY, &l2->flag)) {
1734 enquiry_cr(l2, RR, RSP, 0);
1735 test_and_clear_bit(FLG_ACK_PEND, &l2->flag);
1743 struct layer2 *l2 = fi->userdata;
1745 l2mgr(l2, MDL_ERROR_IND, arg);
1751 struct layer2 *l2 = fi->userdata;
1753 l2mgr(l2, MDL_ERROR_IND, arg);
1755 test_and_clear_bit(FLG_L3_INIT, &l2->flag);
1856 ph_data_indication(struct layer2 *l2, struct mISDNhead *hh, struct sk_buff *skb)
1864 l = l2addrsize(l2);
1866 mISDN_FsmEvent(&l2->l2m, EV_L2_FRAME_ERROR, (void *) 'N');
1869 if (test_bit(FLG_LAPD, &l2->flag)) { /* Maybe not needed */
1874 "%s l2 D-channel frame wrong EA0/EA1\n",
1875 mISDNDevName4ch(&l2->ch));
1880 if (psapi != l2->sapi) {
1884 mISDNDevName4ch(&l2->ch), psapi,
1885 l2->sapi);
1889 if ((ptei != l2->tei) && (ptei != GROUP_TEI)) {
1893 mISDNDevName4ch(&l2->ch), ptei, l2->tei);
1900 c = iframe_error(l2, skb);
1902 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_I, skb);
1903 } else if (IsSFrame(datap, l2)) { /* S-Frame */
1904 c = super_error(l2, skb);
1906 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_SUPER, skb);
1908 c = UI_error(l2, skb);
1910 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_UI, skb);
1911 } else if (IsSABME(datap, l2)) {
1912 c = unnum_error(l2, skb, CMD);
1914 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_SABME, skb);
1916 c = unnum_error(l2, skb, RSP);
1918 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_UA, skb);
1920 c = unnum_error(l2, skb, CMD);
1922 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_DISC, skb);
1924 c = unnum_error(l2, skb, RSP);
1926 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_DM, skb);
1928 c = FRMR_error(l2, skb);
1930 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_FRMR, skb);
1934 printk(KERN_WARNING "%s:l2 D-channel frame error %c\n",
1935 mISDNDevName4ch(&l2->ch), c);
1936 mISDN_FsmEvent(&l2->l2m, EV_L2_FRAME_ERROR, (void *)(long)c);
1944 struct layer2 *l2 = container_of(ch, struct layer2, ch);
1950 __func__, mISDNDevName4ch(&l2->ch), hh->prim, hh->id,
1951 l2->sapi, l2->tei);
1958 mISDNDevName4ch(&l2->ch), hh->prim, hh->id);
1962 ret = ph_data_indication(l2, hh, skb);
1965 ret = ph_data_confirm(l2, hh, skb);
1968 test_and_set_bit(FLG_L1_ACTIV, &l2->flag);
1969 l2up_create(l2, MPH_ACTIVATE_IND, 0, NULL);
1970 if (test_and_clear_bit(FLG_ESTAB_PEND, &l2->flag))
1971 ret = mISDN_FsmEvent(&l2->l2m,
1975 test_and_clear_bit(FLG_L1_ACTIV, &l2->flag);
1976 l2up_create(l2, MPH_DEACTIVATE_IND, 0, NULL);
1977 ret = mISDN_FsmEvent(&l2->l2m, EV_L1_DEACTIVATE, skb);
1980 if (!l2->up)
1982 ret = l2->up->send(l2->up, skb);
1985 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_DL_DATA, skb);
1988 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_DL_UNITDATA, skb);
1991 if (test_bit(FLG_LAPB, &l2->flag))
1992 test_and_set_bit(FLG_ORIG, &l2->flag);
1993 if (test_bit(FLG_L1_ACTIV, &l2->flag)) {
1994 if (test_bit(FLG_LAPD, &l2->flag) ||
1995 test_bit(FLG_ORIG, &l2->flag))
1996 ret = mISDN_FsmEvent(&l2->l2m,
1999 if (test_bit(FLG_LAPD, &l2->flag) ||
2000 test_bit(FLG_ORIG, &l2->flag)) {
2002 &l2->flag);
2004 ret = l2down(l2, PH_ACTIVATE_REQ, l2_newid(l2),
2009 if (test_bit(FLG_LAPB, &l2->flag))
2010 l2down_create(l2, PH_DEACTIVATE_REQ,
2011 l2_newid(l2), 0, NULL);
2012 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_DL_RELEASE_REQ,
2016 mISDN_FsmEvent(&l2->l2m, EV_L2_T200I, NULL);
2019 mISDN_FsmEvent(&l2->l2m, EV_L2_T203I, NULL);
2023 l2m_debug(&l2->l2m, "l2 unknown pr %04x",
2034 tei_l2(struct layer2 *l2, u_int cmd, u_long arg)
2040 mISDNDevName4ch(&l2->ch), cmd, __func__);
2043 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_MDL_ASSIGN, (void *)arg);
2046 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_MDL_REMOVE, NULL);
2049 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_MDL_ERROR, NULL);
2054 mISDNDevName4ch(&l2->ch));
2055 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_MDL_ERROR, NULL);
2062 release_l2(struct layer2 *l2)
2064 mISDN_FsmDelTimer(&l2->t200, 21);
2065 mISDN_FsmDelTimer(&l2->t203, 16);
2066 skb_queue_purge(&l2->i_queue);
2067 skb_queue_purge(&l2->ui_queue);
2068 skb_queue_purge(&l2->down_queue);
2069 ReleaseWin(l2);
2070 if (test_bit(FLG_LAPD, &l2->flag)) {
2071 TEIrelease(l2);
2072 if (l2->ch.st)
2073 l2->ch.st->dev->D.ctrl(&l2->ch.st->dev->D,
2076 kfree(l2);
2082 struct layer2 *l2 = container_of(ch, struct layer2, ch);
2091 if (test_bit(FLG_LAPD, &l2->flag)) {
2092 set_channel_address(&l2->ch, l2->sapi, l2->tei);
2094 l2up_create(l2, DL_INFORMATION_IND,
2099 if (l2->ch.peer)
2100 l2->ch.peer->ctrl(l2->ch.peer, CLOSE_CHANNEL, NULL);
2101 release_l2(l2);
2111 struct layer2 *l2;
2114 l2 = kzalloc(sizeof(struct layer2), GFP_KERNEL);
2115 if (!l2) {
2119 l2->next_id = 1;
2120 l2->down_id = MISDN_ID_NONE;
2121 l2->up = ch;
2122 l2->ch.st = ch->st;
2123 l2->ch.send = l2_send;
2124 l2->ch.ctrl = l2_ctrl;
2127 test_and_set_bit(FLG_LAPD, &l2->flag);
2128 test_and_set_bit(FLG_LAPD_NET, &l2->flag);
2129 test_and_set_bit(FLG_MOD128, &l2->flag);
2130 l2->sapi = sapi;
2131 l2->maxlen = MAX_DFRAME_LEN;
2133 l2->window = 7;
2135 l2->window = 1;
2137 test_and_set_bit(FLG_PTP, &l2->flag);
2139 test_and_set_bit(FLG_FIXED_TEI, &l2->flag);
2140 l2->tei = tei;
2141 l2->T200 = 1000;
2142 l2->N200 = 3;
2143 l2->T203 = 10000;
2149 l2->ch.st->dev->D.ctrl(&l2->ch.st->dev->D, OPEN_CHANNEL, &rq);
2152 test_and_set_bit(FLG_LAPD, &l2->flag);
2153 test_and_set_bit(FLG_MOD128, &l2->flag);
2154 test_and_set_bit(FLG_ORIG, &l2->flag);
2155 l2->sapi = sapi;
2156 l2->maxlen = MAX_DFRAME_LEN;
2158 l2->window = 7;
2160 l2->window = 1;
2162 test_and_set_bit(FLG_PTP, &l2->flag);
2164 test_and_set_bit(FLG_FIXED_TEI, &l2->flag);
2165 l2->tei = tei;
2166 l2->T200 = 1000;
2167 l2->N200 = 3;
2168 l2->T203 = 10000;
2174 l2->ch.st->dev->D.ctrl(&l2->ch.st->dev->D, OPEN_CHANNEL, &rq);
2177 test_and_set_bit(FLG_LAPB, &l2->flag);
2178 l2->window = 7;
2179 l2->maxlen = MAX_DATA_SIZE;
2180 l2->T200 = 1000;
2181 l2->N200 = 4;
2182 l2->T203 = 5000;
2183 l2->addr.A = 3;
2184 l2->addr.B = 1;
2189 kfree(l2);
2192 skb_queue_head_init(&l2->i_queue);
2193 skb_queue_head_init(&l2->ui_queue);
2194 skb_queue_head_init(&l2->down_queue);
2195 skb_queue_head_init(&l2->tmp_queue);
2196 InitWin(l2);
2197 l2->l2m.fsm = &l2fsm;
2198 if (test_bit(FLG_LAPB, &l2->flag) ||
2199 test_bit(FLG_FIXED_TEI, &l2->flag) ||
2200 test_bit(FLG_LAPD_NET, &l2->flag))
2201 l2->l2m.state = ST_L2_4;
2203 l2->l2m.state = ST_L2_1;
2204 l2->l2m.debug = *debug;
2205 l2->l2m.userdata = l2;
2206 l2->l2m.userint = 0;
2207 l2->l2m.printdebug = l2m_debug;
2209 mISDN_FsmInitTimer(&l2->l2m, &l2->t200);
2210 mISDN_FsmInitTimer(&l2->l2m, &l2->t203);
2211 return l2;
2217 struct layer2 *l2;
2221 l2 = create_l2(crq->ch, crq->protocol, 0, 0, 0);
2222 if (!l2)
2224 crq->ch = &l2->ch;