1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * 4 * Author Karsten Keil <kkeil@novell.com> 5 * 6 * Copyright 2008 by Karsten Keil <kkeil@novell.com> 7 */ 8 9 #include <linux/mISDNif.h> 10 #include <linux/slab.h> 11 #include "core.h" 12 #include "fsm.h" 13 #include "layer2.h" 14 15 static u_int *debug; 16 17 static 18 struct Fsm l2fsm = {NULL, 0, 0, NULL, NULL}; 19 20 static char *strL2State[] = 21 { 22 "ST_L2_1", 23 "ST_L2_2", 24 "ST_L2_3", 25 "ST_L2_4", 26 "ST_L2_5", 27 "ST_L2_6", 28 "ST_L2_7", 29 "ST_L2_8", 30 }; 31 32 enum { 33 EV_L2_UI, 34 EV_L2_SABME, 35 EV_L2_DISC, 36 EV_L2_DM, 37 EV_L2_UA, 38 EV_L2_FRMR, 39 EV_L2_SUPER, 40 EV_L2_I, 41 EV_L2_DL_DATA, 42 EV_L2_ACK_PULL, 43 EV_L2_DL_UNITDATA, 44 EV_L2_DL_ESTABLISH_REQ, 45 EV_L2_DL_RELEASE_REQ, 46 EV_L2_MDL_ASSIGN, 47 EV_L2_MDL_REMOVE, 48 EV_L2_MDL_ERROR, 49 EV_L1_DEACTIVATE, 50 EV_L2_T200, 51 EV_L2_T203, 52 EV_L2_T200I, 53 EV_L2_T203I, 54 EV_L2_SET_OWN_BUSY, 55 EV_L2_CLEAR_OWN_BUSY, 56 EV_L2_FRAME_ERROR, 57 }; 58 59 #define L2_EVENT_COUNT (EV_L2_FRAME_ERROR + 1) 60 61 static char *strL2Event[] = 62 { 63 "EV_L2_UI", 64 "EV_L2_SABME", 65 "EV_L2_DISC", 66 "EV_L2_DM", 67 "EV_L2_UA", 68 "EV_L2_FRMR", 69 "EV_L2_SUPER", 70 "EV_L2_I", 71 "EV_L2_DL_DATA", 72 "EV_L2_ACK_PULL", 73 "EV_L2_DL_UNITDATA", 74 "EV_L2_DL_ESTABLISH_REQ", 75 "EV_L2_DL_RELEASE_REQ", 76 "EV_L2_MDL_ASSIGN", 77 "EV_L2_MDL_REMOVE", 78 "EV_L2_MDL_ERROR", 79 "EV_L1_DEACTIVATE", 80 "EV_L2_T200", 81 "EV_L2_T203", 82 "EV_L2_T200I", 83 "EV_L2_T203I", 84 "EV_L2_SET_OWN_BUSY", 85 "EV_L2_CLEAR_OWN_BUSY", 86 "EV_L2_FRAME_ERROR", 87 }; 88 89 static void 90 l2m_debug(struct FsmInst *fi, char *fmt, ...) 91 { 92 struct layer2 *l2 = fi->userdata; 93 struct va_format vaf; 94 va_list va; 95 96 if (!(*debug & DEBUG_L2_FSM)) 97 return; 98 99 va_start(va, fmt); 100 101 vaf.fmt = fmt; 102 vaf.va = &va; 103 104 printk(KERN_DEBUG "%s l2 (sapi %d tei %d): %pV\n", 105 mISDNDevName4ch(&l2->ch), l2->sapi, l2->tei, &vaf); 106 107 va_end(va); 108 } 109 110 inline u_int 111 l2headersize(struct layer2 *l2, int ui) 112 { 113 return ((test_bit(FLG_MOD128, &l2->flag) && (!ui)) ? 2 : 1) + 114 (test_bit(FLG_LAPD, &l2->flag) ? 2 : 1); 115 } 116 117 inline u_int 118 l2addrsize(struct layer2 *l2) 119 { 120 return test_bit(FLG_LAPD, &l2->flag) ? 2 : 1; 121 } 122 123 static u_int 124 l2_newid(struct layer2 *l2) 125 { 126 u_int id; 127 128 id = l2->next_id++; 129 if (id == 0x7fff) 130 l2->next_id = 1; 131 id <<= 16; 132 id |= l2->tei << 8; 133 id |= l2->sapi; 134 return id; 135 } 136 137 static void 138 l2up(struct layer2 *l2, u_int prim, struct sk_buff *skb) 139 { 140 int err; 141 142 if (!l2->up) 143 return; 144 mISDN_HEAD_PRIM(skb) = prim; 145 mISDN_HEAD_ID(skb) = (l2->ch.nr << 16) | l2->ch.addr; 146 err = l2->up->send(l2->up, skb); 147 if (err) { 148 printk(KERN_WARNING "%s: dev %s err=%d\n", __func__, 149 mISDNDevName4ch(&l2->ch), err); 150 dev_kfree_skb(skb); 151 } 152 } 153 154 static void 155 l2up_create(struct layer2 *l2, u_int prim, int len, void *arg) 156 { 157 struct sk_buff *skb; 158 struct mISDNhead *hh; 159 int err; 160 161 if (!l2->up) 162 return; 163 skb = mI_alloc_skb(len, GFP_ATOMIC); 164 if (!skb) 165 return; 166 hh = mISDN_HEAD_P(skb); 167 hh->prim = prim; 168 hh->id = (l2->ch.nr << 16) | l2->ch.addr; 169 if (len) 170 skb_put_data(skb, arg, len); 171 err = l2->up->send(l2->up, skb); 172 if (err) { 173 printk(KERN_WARNING "%s: dev %s err=%d\n", __func__, 174 mISDNDevName4ch(&l2->ch), err); 175 dev_kfree_skb(skb); 176 } 177 } 178 179 static int 180 l2down_skb(struct layer2 *l2, struct sk_buff *skb) { 181 int ret; 182 183 ret = l2->ch.recv(l2->ch.peer, skb); 184 if (ret && (*debug & DEBUG_L2_RECV)) 185 printk(KERN_DEBUG "l2down_skb: dev %s ret(%d)\n", 186 mISDNDevName4ch(&l2->ch), ret); 187 return ret; 188 } 189 190 static int 191 l2down_raw(struct layer2 *l2, struct sk_buff *skb) 192 { 193 struct mISDNhead *hh = mISDN_HEAD_P(skb); 194 195 if (hh->prim == PH_DATA_REQ) { 196 if (test_and_set_bit(FLG_L1_NOTREADY, &l2->flag)) { 197 skb_queue_tail(&l2->down_queue, skb); 198 return 0; 199 } 200 l2->down_id = mISDN_HEAD_ID(skb); 201 } 202 return l2down_skb(l2, skb); 203 } 204 205 static int 206 l2down(struct layer2 *l2, u_int prim, u_int id, struct sk_buff *skb) 207 { 208 struct mISDNhead *hh = mISDN_HEAD_P(skb); 209 210 hh->prim = prim; 211 hh->id = id; 212 return l2down_raw(l2, skb); 213 } 214 215 static int 216 l2down_create(struct layer2 *l2, u_int prim, u_int id, int len, void *arg) 217 { 218 struct sk_buff *skb; 219 int err; 220 struct mISDNhead *hh; 221 222 skb = mI_alloc_skb(len, GFP_ATOMIC); 223 if (!skb) 224 return -ENOMEM; 225 hh = mISDN_HEAD_P(skb); 226 hh->prim = prim; 227 hh->id = id; 228 if (len) 229 skb_put_data(skb, arg, len); 230 err = l2down_raw(l2, skb); 231 if (err) 232 dev_kfree_skb(skb); 233 return err; 234 } 235 236 static int 237 ph_data_confirm(struct layer2 *l2, struct mISDNhead *hh, struct sk_buff *skb) { 238 struct sk_buff *nskb = skb; 239 int ret = -EAGAIN; 240 241 if (test_bit(FLG_L1_NOTREADY, &l2->flag)) { 242 if (hh->id == l2->down_id) { 243 nskb = skb_dequeue(&l2->down_queue); 244 if (nskb) { 245 l2->down_id = mISDN_HEAD_ID(nskb); 246 if (l2down_skb(l2, nskb)) { 247 dev_kfree_skb(nskb); 248 l2->down_id = MISDN_ID_NONE; 249 } 250 } else 251 l2->down_id = MISDN_ID_NONE; 252 if (ret) { 253 dev_kfree_skb(skb); 254 ret = 0; 255 } 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); 259 } 260 } 261 } 262 if (!test_and_set_bit(FLG_L1_NOTREADY, &l2->flag)) { 263 nskb = skb_dequeue(&l2->down_queue); 264 if (nskb) { 265 l2->down_id = mISDN_HEAD_ID(nskb); 266 if (l2down_skb(l2, nskb)) { 267 dev_kfree_skb(nskb); 268 l2->down_id = MISDN_ID_NONE; 269 test_and_clear_bit(FLG_L1_NOTREADY, &l2->flag); 270 } 271 } else 272 test_and_clear_bit(FLG_L1_NOTREADY, &l2->flag); 273 } 274 return ret; 275 } 276 277 static void 278 l2_timeout(struct FsmInst *fi, int event, void *arg) 279 { 280 struct layer2 *l2 = fi->userdata; 281 struct sk_buff *skb; 282 struct mISDNhead *hh; 283 284 skb = mI_alloc_skb(0, GFP_ATOMIC); 285 if (!skb) { 286 printk(KERN_WARNING "%s: L2(%d,%d) nr:%x timer %s no skb\n", 287 mISDNDevName4ch(&l2->ch), l2->sapi, l2->tei, 288 l2->ch.nr, event == EV_L2_T200 ? "T200" : "T203"); 289 return; 290 } 291 hh = mISDN_HEAD_P(skb); 292 hh->prim = event == EV_L2_T200 ? DL_TIMER200_IND : DL_TIMER203_IND; 293 hh->id = l2->ch.nr; 294 if (*debug & DEBUG_TIMER) 295 printk(KERN_DEBUG "%s: L2(%d,%d) nr:%x timer %s expired\n", 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); 300 } 301 302 static int 303 l2mgr(struct layer2 *l2, u_int prim, void *arg) { 304 long c = (long)arg; 305 306 printk(KERN_WARNING "l2mgr: dev %s addr:%x prim %x %c\n", 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)) { 310 switch (c) { 311 case 'C': 312 case 'D': 313 case 'G': 314 case 'H': 315 l2_tei(l2, prim, (u_long)arg); 316 break; 317 } 318 } 319 return 0; 320 } 321 322 static void 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); 327 } 328 329 static void 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); 333 } 334 335 static void 336 InitWin(struct layer2 *l2) 337 { 338 int i; 339 340 for (i = 0; i < MAX_WINDOW; i++) 341 l2->windowar[i] = NULL; 342 } 343 344 static int 345 freewin(struct layer2 *l2) 346 { 347 int i, cnt = 0; 348 349 for (i = 0; i < MAX_WINDOW; i++) { 350 if (l2->windowar[i]) { 351 cnt++; 352 dev_kfree_skb(l2->windowar[i]); 353 l2->windowar[i] = NULL; 354 } 355 } 356 return cnt; 357 } 358 359 static void 360 ReleaseWin(struct layer2 *l2) 361 { 362 int cnt = freewin(l2); 363 364 if (cnt) 365 printk(KERN_WARNING 366 "isdnl2 freed %d skbuffs in release\n", cnt); 367 } 368 369 inline unsigned int 370 cansend(struct layer2 *l2) 371 { 372 unsigned int p1; 373 374 if (test_bit(FLG_MOD128, &l2->flag)) 375 p1 = (l2->vs - l2->va) % 128; 376 else 377 p1 = (l2->vs - l2->va) % 8; 378 return (p1 < l2->window) && !test_bit(FLG_PEER_BUSY, &l2->flag); 379 } 380 381 inline void 382 clear_exception(struct layer2 *l2) 383 { 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); 388 } 389 390 static int 391 sethdraddr(struct layer2 *l2, u_char *header, int rsp) 392 { 393 u_char *ptr = header; 394 int crbit = rsp; 395 396 if (test_bit(FLG_LAPD, &l2->flag)) { 397 if (test_bit(FLG_LAPD_NET, &l2->flag)) 398 crbit = !crbit; 399 *ptr++ = (l2->sapi << 2) | (crbit ? 2 : 0); 400 *ptr++ = (l2->tei << 1) | 1; 401 return 2; 402 } else { 403 if (test_bit(FLG_ORIG, &l2->flag)) 404 crbit = !crbit; 405 if (crbit) 406 *ptr++ = l2->addr.B; 407 else 408 *ptr++ = l2->addr.A; 409 return 1; 410 } 411 } 412 413 static inline void 414 enqueue_super(struct layer2 *l2, struct sk_buff *skb) 415 { 416 if (l2down(l2, PH_DATA_REQ, l2_newid(l2), skb)) 417 dev_kfree_skb(skb); 418 } 419 420 static inline void 421 enqueue_ui(struct layer2 *l2, struct sk_buff *skb) 422 { 423 if (l2->tm) 424 l2_tei(l2, MDL_STATUS_UI_IND, 0); 425 if (l2down(l2, PH_DATA_REQ, l2_newid(l2), skb)) 426 dev_kfree_skb(skb); 427 } 428 429 inline int 430 IsUI(u_char *data) 431 { 432 return (data[0] & 0xef) == UI; 433 } 434 435 inline int 436 IsUA(u_char *data) 437 { 438 return (data[0] & 0xef) == UA; 439 } 440 441 inline int 442 IsDM(u_char *data) 443 { 444 return (data[0] & 0xef) == DM; 445 } 446 447 inline int 448 IsDISC(u_char *data) 449 { 450 return (data[0] & 0xef) == DISC; 451 } 452 453 inline int 454 IsRR(u_char *data, struct layer2 *l2) 455 { 456 if (test_bit(FLG_MOD128, &l2->flag)) 457 return data[0] == RR; 458 else 459 return (data[0] & 0xf) == 1; 460 } 461 462 inline int 463 IsSFrame(u_char *data, struct layer2 *l2) 464 { 465 register u_char d = *data; 466 467 if (!test_bit(FLG_MOD128, &l2->flag)) 468 d &= 0xf; 469 return ((d & 0xf3) == 1) && ((d & 0x0c) != 0x0c); 470 } 471 472 inline int 473 IsSABME(u_char *data, struct layer2 *l2) 474 { 475 u_char d = data[0] & ~0x10; 476 477 return test_bit(FLG_MOD128, &l2->flag) ? d == SABME : d == SABM; 478 } 479 480 inline int 481 IsREJ(u_char *data, struct layer2 *l2) 482 { 483 return test_bit(FLG_MOD128, &l2->flag) ? 484 data[0] == REJ : (data[0] & 0xf) == REJ; 485 } 486 487 inline int 488 IsFRMR(u_char *data) 489 { 490 return (data[0] & 0xef) == FRMR; 491 } 492 493 inline int 494 IsRNR(u_char *data, struct layer2 *l2) 495 { 496 return test_bit(FLG_MOD128, &l2->flag) ? 497 data[0] == RNR : (data[0] & 0xf) == RNR; 498 } 499 500 static int 501 iframe_error(struct layer2 *l2, struct sk_buff *skb) 502 { 503 u_int i; 504 int rsp = *skb->data & 0x2; 505 506 i = l2addrsize(l2) + (test_bit(FLG_MOD128, &l2->flag) ? 2 : 1); 507 if (test_bit(FLG_ORIG, &l2->flag)) 508 rsp = !rsp; 509 if (rsp) 510 return 'L'; 511 if (skb->len < i) 512 return 'N'; 513 if ((skb->len - i) > l2->maxlen) 514 return 'O'; 515 return 0; 516 } 517 518 static int 519 super_error(struct layer2 *l2, struct sk_buff *skb) 520 { 521 if (skb->len != l2addrsize(l2) + 522 (test_bit(FLG_MOD128, &l2->flag) ? 2 : 1)) 523 return 'N'; 524 return 0; 525 } 526 527 static int 528 unnum_error(struct layer2 *l2, struct sk_buff *skb, int wantrsp) 529 { 530 int rsp = (*skb->data & 0x2) >> 1; 531 if (test_bit(FLG_ORIG, &l2->flag)) 532 rsp = !rsp; 533 if (rsp != wantrsp) 534 return 'L'; 535 if (skb->len != l2addrsize(l2) + 1) 536 return 'N'; 537 return 0; 538 } 539 540 static int 541 UI_error(struct layer2 *l2, struct sk_buff *skb) 542 { 543 int rsp = *skb->data & 0x2; 544 if (test_bit(FLG_ORIG, &l2->flag)) 545 rsp = !rsp; 546 if (rsp) 547 return 'L'; 548 if (skb->len > l2->maxlen + l2addrsize(l2) + 1) 549 return 'O'; 550 return 0; 551 } 552 553 static int 554 FRMR_error(struct layer2 *l2, struct sk_buff *skb) 555 { 556 u_int headers = l2addrsize(l2) + 1; 557 u_char *datap = skb->data + headers; 558 int rsp = *skb->data & 0x2; 559 560 if (test_bit(FLG_ORIG, &l2->flag)) 561 rsp = !rsp; 562 if (!rsp) 563 return 'L'; 564 if (test_bit(FLG_MOD128, &l2->flag)) { 565 if (skb->len < headers + 5) 566 return 'N'; 567 else if (*debug & DEBUG_L2) 568 l2m_debug(&l2->l2m, 569 "FRMR information %2x %2x %2x %2x %2x", 570 datap[0], datap[1], datap[2], datap[3], datap[4]); 571 } else { 572 if (skb->len < headers + 3) 573 return 'N'; 574 else if (*debug & DEBUG_L2) 575 l2m_debug(&l2->l2m, 576 "FRMR information %2x %2x %2x", 577 datap[0], datap[1], datap[2]); 578 } 579 return 0; 580 } 581 582 static unsigned int 583 legalnr(struct layer2 *l2, unsigned int nr) 584 { 585 if (test_bit(FLG_MOD128, &l2->flag)) 586 return ((nr - l2->va) % 128) <= ((l2->vs - l2->va) % 128); 587 else 588 return ((nr - l2->va) % 8) <= ((l2->vs - l2->va) % 8); 589 } 590 591 static void 592 setva(struct layer2 *l2, unsigned int nr) 593 { 594 struct sk_buff *skb; 595 596 while (l2->va != nr) { 597 l2->va++; 598 if (test_bit(FLG_MOD128, &l2->flag)) 599 l2->va %= 128; 600 else 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; 606 } 607 l2->sow = (l2->sow + 1) % l2->window; 608 } 609 skb = skb_dequeue(&l2->tmp_queue); 610 while (skb) { 611 dev_kfree_skb(skb); 612 skb = skb_dequeue(&l2->tmp_queue); 613 } 614 } 615 616 static void 617 send_uframe(struct layer2 *l2, struct sk_buff *skb, u_char cmd, u_char cr) 618 { 619 u_char tmp[MAX_L2HEADER_LEN]; 620 int i; 621 622 i = sethdraddr(l2, tmp, cr); 623 tmp[i++] = cmd; 624 if (skb) 625 skb_trim(skb, 0); 626 else { 627 skb = mI_alloc_skb(i, GFP_ATOMIC); 628 if (!skb) { 629 printk(KERN_WARNING "%s: can't alloc skbuff in %s\n", 630 mISDNDevName4ch(&l2->ch), __func__); 631 return; 632 } 633 } 634 skb_put_data(skb, tmp, i); 635 enqueue_super(l2, skb); 636 } 637 638 639 inline u_char 640 get_PollFlag(struct layer2 *l2, struct sk_buff *skb) 641 { 642 return skb->data[l2addrsize(l2)] & 0x10; 643 } 644 645 inline u_char 646 get_PollFlagFree(struct layer2 *l2, struct sk_buff *skb) 647 { 648 u_char PF; 649 650 PF = get_PollFlag(l2, skb); 651 dev_kfree_skb(skb); 652 return PF; 653 } 654 655 inline void 656 start_t200(struct layer2 *l2, int i) 657 { 658 mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, i); 659 test_and_set_bit(FLG_T200_RUN, &l2->flag); 660 } 661 662 inline void 663 restart_t200(struct layer2 *l2, int i) 664 { 665 mISDN_FsmRestartTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, i); 666 test_and_set_bit(FLG_T200_RUN, &l2->flag); 667 } 668 669 inline void 670 stop_t200(struct layer2 *l2, int i) 671 { 672 if (test_and_clear_bit(FLG_T200_RUN, &l2->flag)) 673 mISDN_FsmDelTimer(&l2->t200, i); 674 } 675 676 inline void 677 st5_dl_release_l2l3(struct layer2 *l2) 678 { 679 int pr; 680 681 if (test_and_clear_bit(FLG_PEND_REL, &l2->flag)) 682 pr = DL_RELEASE_CNF; 683 else 684 pr = DL_RELEASE_IND; 685 l2up_create(l2, pr, 0, NULL); 686 } 687 688 inline void 689 lapb_dl_release_l2l3(struct layer2 *l2, int f) 690 { 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); 694 } 695 696 static void 697 establishlink(struct FsmInst *fi) 698 { 699 struct layer2 *l2 = fi->userdata; 700 u_char cmd; 701 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); 710 mISDN_FsmChangeState(fi, ST_L2_5); 711 } 712 713 static void 714 l2_mdl_error_ua(struct FsmInst *fi, int event, void *arg) 715 { 716 struct sk_buff *skb = arg; 717 struct layer2 *l2 = fi->userdata; 718 719 if (get_PollFlagFree(l2, skb)) 720 l2mgr(l2, MDL_ERROR_IND, (void *) 'C'); 721 else 722 l2mgr(l2, MDL_ERROR_IND, (void *) 'D'); 723 724 } 725 726 static void 727 l2_mdl_error_dm(struct FsmInst *fi, int event, void *arg) 728 { 729 struct sk_buff *skb = arg; 730 struct layer2 *l2 = fi->userdata; 731 732 if (get_PollFlagFree(l2, skb)) 733 l2mgr(l2, MDL_ERROR_IND, (void *) 'B'); 734 else { 735 l2mgr(l2, MDL_ERROR_IND, (void *) 'E'); 736 establishlink(fi); 737 test_and_clear_bit(FLG_L3_INIT, &l2->flag); 738 } 739 } 740 741 static void 742 l2_st8_mdl_error_dm(struct FsmInst *fi, int event, void *arg) 743 { 744 struct sk_buff *skb = arg; 745 struct layer2 *l2 = fi->userdata; 746 747 if (get_PollFlagFree(l2, skb)) 748 l2mgr(l2, MDL_ERROR_IND, (void *) 'B'); 749 else 750 l2mgr(l2, MDL_ERROR_IND, (void *) 'E'); 751 establishlink(fi); 752 test_and_clear_bit(FLG_L3_INIT, &l2->flag); 753 } 754 755 static void 756 l2_go_st3(struct FsmInst *fi, int event, void *arg) 757 { 758 dev_kfree_skb((struct sk_buff *)arg); 759 mISDN_FsmChangeState(fi, ST_L2_3); 760 } 761 762 static void 763 l2_mdl_assign(struct FsmInst *fi, int event, void *arg) 764 { 765 struct layer2 *l2 = fi->userdata; 766 767 mISDN_FsmChangeState(fi, ST_L2_3); 768 dev_kfree_skb((struct sk_buff *)arg); 769 l2_tei(l2, MDL_ASSIGN_IND, 0); 770 } 771 772 static void 773 l2_queue_ui_assign(struct FsmInst *fi, int event, void *arg) 774 { 775 struct layer2 *l2 = fi->userdata; 776 struct sk_buff *skb = arg; 777 778 skb_queue_tail(&l2->ui_queue, skb); 779 mISDN_FsmChangeState(fi, ST_L2_2); 780 l2_tei(l2, MDL_ASSIGN_IND, 0); 781 } 782 783 static void 784 l2_queue_ui(struct FsmInst *fi, int event, void *arg) 785 { 786 struct layer2 *l2 = fi->userdata; 787 struct sk_buff *skb = arg; 788 789 skb_queue_tail(&l2->ui_queue, skb); 790 } 791 792 static void 793 tx_ui(struct layer2 *l2) 794 { 795 struct sk_buff *skb; 796 u_char header[MAX_L2HEADER_LEN]; 797 int i; 798 799 i = sethdraddr(l2, header, CMD); 800 if (test_bit(FLG_LAPD_NET, &l2->flag)) 801 header[1] = 0xff; /* tei 127 */ 802 header[i++] = UI; 803 while ((skb = skb_dequeue(&l2->ui_queue))) { 804 memcpy(skb_push(skb, i), header, i); 805 enqueue_ui(l2, skb); 806 } 807 } 808 809 static void 810 l2_send_ui(struct FsmInst *fi, int event, void *arg) 811 { 812 struct layer2 *l2 = fi->userdata; 813 struct sk_buff *skb = arg; 814 815 skb_queue_tail(&l2->ui_queue, skb); 816 tx_ui(l2); 817 } 818 819 static void 820 l2_got_ui(struct FsmInst *fi, int event, void *arg) 821 { 822 struct layer2 *l2 = fi->userdata; 823 struct sk_buff *skb = arg; 824 825 skb_pull(skb, l2headersize(l2, 1)); 826 /* 827 * in states 1-3 for broadcast 828 */ 829 830 if (l2->tm) 831 l2_tei(l2, MDL_STATUS_UI_IND, 0); 832 l2up(l2, DL_UNITDATA_IND, skb); 833 } 834 835 static void 836 l2_establish(struct FsmInst *fi, int event, void *arg) 837 { 838 struct sk_buff *skb = arg; 839 struct layer2 *l2 = fi->userdata; 840 841 establishlink(fi); 842 test_and_set_bit(FLG_L3_INIT, &l2->flag); 843 dev_kfree_skb(skb); 844 } 845 846 static void 847 l2_discard_i_setl3(struct FsmInst *fi, int event, void *arg) 848 { 849 struct sk_buff *skb = arg; 850 struct layer2 *l2 = fi->userdata; 851 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); 855 dev_kfree_skb(skb); 856 } 857 858 static void 859 l2_l3_reestablish(struct FsmInst *fi, int event, void *arg) 860 { 861 struct sk_buff *skb = arg; 862 struct layer2 *l2 = fi->userdata; 863 864 skb_queue_purge(&l2->i_queue); 865 establishlink(fi); 866 test_and_set_bit(FLG_L3_INIT, &l2->flag); 867 dev_kfree_skb(skb); 868 } 869 870 static void 871 l2_release(struct FsmInst *fi, int event, void *arg) 872 { 873 struct layer2 *l2 = fi->userdata; 874 struct sk_buff *skb = arg; 875 876 skb_trim(skb, 0); 877 l2up(l2, DL_RELEASE_CNF, skb); 878 } 879 880 static void 881 l2_pend_rel(struct FsmInst *fi, int event, void *arg) 882 { 883 struct sk_buff *skb = arg; 884 struct layer2 *l2 = fi->userdata; 885 886 test_and_set_bit(FLG_PEND_REL, &l2->flag); 887 dev_kfree_skb(skb); 888 } 889 890 static void 891 l2_disconnect(struct FsmInst *fi, int event, void *arg) 892 { 893 struct layer2 *l2 = fi->userdata; 894 struct sk_buff *skb = arg; 895 896 skb_queue_purge(&l2->i_queue); 897 freewin(l2); 898 mISDN_FsmChangeState(fi, ST_L2_6); 899 l2->rc = 0; 900 send_uframe(l2, NULL, DISC | 0x10, CMD); 901 mISDN_FsmDelTimer(&l2->t203, 1); 902 restart_t200(l2, 2); 903 if (skb) 904 dev_kfree_skb(skb); 905 } 906 907 static void 908 l2_start_multi(struct FsmInst *fi, int event, void *arg) 909 { 910 struct layer2 *l2 = fi->userdata; 911 struct sk_buff *skb = arg; 912 913 l2->vs = 0; 914 l2->va = 0; 915 l2->vr = 0; 916 l2->sow = 0; 917 clear_exception(l2); 918 send_uframe(l2, NULL, UA | get_PollFlag(l2, skb), RSP); 919 mISDN_FsmChangeState(fi, ST_L2_7); 920 mISDN_FsmAddTimer(&l2->t203, l2->T203, EV_L2_T203, NULL, 3); 921 skb_trim(skb, 0); 922 l2up(l2, DL_ESTABLISH_IND, skb); 923 if (l2->tm) 924 l2_tei(l2, MDL_STATUS_UP_IND, 0); 925 } 926 927 static void 928 l2_send_UA(struct FsmInst *fi, int event, void *arg) 929 { 930 struct layer2 *l2 = fi->userdata; 931 struct sk_buff *skb = arg; 932 933 send_uframe(l2, skb, UA | get_PollFlag(l2, skb), RSP); 934 } 935 936 static void 937 l2_send_DM(struct FsmInst *fi, int event, void *arg) 938 { 939 struct layer2 *l2 = fi->userdata; 940 struct sk_buff *skb = arg; 941 942 send_uframe(l2, skb, DM | get_PollFlag(l2, skb), RSP); 943 } 944 945 static void 946 l2_restart_multi(struct FsmInst *fi, int event, void *arg) 947 { 948 struct layer2 *l2 = fi->userdata; 949 struct sk_buff *skb = arg; 950 int est = 0; 951 952 send_uframe(l2, skb, UA | get_PollFlag(l2, skb), RSP); 953 954 l2mgr(l2, MDL_ERROR_IND, (void *) 'F'); 955 956 if (l2->vs != l2->va) { 957 skb_queue_purge(&l2->i_queue); 958 est = 1; 959 } 960 961 clear_exception(l2); 962 l2->vs = 0; 963 l2->va = 0; 964 l2->vr = 0; 965 l2->sow = 0; 966 mISDN_FsmChangeState(fi, ST_L2_7); 967 stop_t200(l2, 3); 968 mISDN_FsmRestartTimer(&l2->t203, l2->T203, EV_L2_T203, NULL, 3); 969 970 if (est) 971 l2up_create(l2, DL_ESTABLISH_IND, 0, NULL); 972 /* mISDN_queue_data(&l2->inst, l2->inst.id | MSG_BROADCAST, 973 * MGR_SHORTSTATUS | INDICATION, SSTATUS_L2_ESTABLISHED, 974 * 0, NULL, 0); 975 */ 976 if (skb_queue_len(&l2->i_queue) && cansend(l2)) 977 mISDN_FsmEvent(fi, EV_L2_ACK_PULL, NULL); 978 } 979 980 static void 981 l2_stop_multi(struct FsmInst *fi, int event, void *arg) 982 { 983 struct layer2 *l2 = fi->userdata; 984 struct sk_buff *skb = arg; 985 986 mISDN_FsmChangeState(fi, ST_L2_4); 987 mISDN_FsmDelTimer(&l2->t203, 3); 988 stop_t200(l2, 4); 989 990 send_uframe(l2, skb, UA | get_PollFlag(l2, skb), RSP); 991 skb_queue_purge(&l2->i_queue); 992 freewin(l2); 993 lapb_dl_release_l2l3(l2, DL_RELEASE_IND); 994 if (l2->tm) 995 l2_tei(l2, MDL_STATUS_DOWN_IND, 0); 996 } 997 998 static void 999 l2_connected(struct FsmInst *fi, int event, void *arg) 1000 { 1001 struct layer2 *l2 = fi->userdata; 1002 struct sk_buff *skb = arg; 1003 int pr = -1; 1004 1005 if (!get_PollFlag(l2, skb)) { 1006 l2_mdl_error_ua(fi, event, arg); 1007 return; 1008 } 1009 dev_kfree_skb(skb); 1010 if (test_and_clear_bit(FLG_PEND_REL, &l2->flag)) 1011 l2_disconnect(fi, event, NULL); 1012 if (test_and_clear_bit(FLG_L3_INIT, &l2->flag)) { 1013 pr = DL_ESTABLISH_CNF; 1014 } else if (l2->vs != l2->va) { 1015 skb_queue_purge(&l2->i_queue); 1016 pr = DL_ESTABLISH_IND; 1017 } 1018 stop_t200(l2, 5); 1019 l2->vr = 0; 1020 l2->vs = 0; 1021 l2->va = 0; 1022 l2->sow = 0; 1023 mISDN_FsmChangeState(fi, ST_L2_7); 1024 mISDN_FsmAddTimer(&l2->t203, l2->T203, EV_L2_T203, NULL, 4); 1025 if (pr != -1) 1026 l2up_create(l2, pr, 0, NULL); 1027 1028 if (skb_queue_len(&l2->i_queue) && cansend(l2)) 1029 mISDN_FsmEvent(fi, EV_L2_ACK_PULL, NULL); 1030 1031 if (l2->tm) 1032 l2_tei(l2, MDL_STATUS_UP_IND, 0); 1033 } 1034 1035 static void 1036 l2_released(struct FsmInst *fi, int event, void *arg) 1037 { 1038 struct layer2 *l2 = fi->userdata; 1039 struct sk_buff *skb = arg; 1040 1041 if (!get_PollFlag(l2, skb)) { 1042 l2_mdl_error_ua(fi, event, arg); 1043 return; 1044 } 1045 dev_kfree_skb(skb); 1046 stop_t200(l2, 6); 1047 lapb_dl_release_l2l3(l2, DL_RELEASE_CNF); 1048 mISDN_FsmChangeState(fi, ST_L2_4); 1049 if (l2->tm) 1050 l2_tei(l2, MDL_STATUS_DOWN_IND, 0); 1051 } 1052 1053 static void 1054 l2_reestablish(struct FsmInst *fi, int event, void *arg) 1055 { 1056 struct layer2 *l2 = fi->userdata; 1057 struct sk_buff *skb = arg; 1058 1059 if (!get_PollFlagFree(l2, skb)) { 1060 establishlink(fi); 1061 test_and_set_bit(FLG_L3_INIT, &l2->flag); 1062 } 1063 } 1064 1065 static void 1066 l2_st5_dm_release(struct FsmInst *fi, int event, void *arg) 1067 { 1068 struct layer2 *l2 = fi->userdata; 1069 struct sk_buff *skb = arg; 1070 1071 if (get_PollFlagFree(l2, skb)) { 1072 stop_t200(l2, 7); 1073 if (!test_bit(FLG_L3_INIT, &l2->flag)) 1074 skb_queue_purge(&l2->i_queue); 1075 if (test_bit(FLG_LAPB, &l2->flag)) 1076 l2down_create(l2, PH_DEACTIVATE_REQ, 1077 l2_newid(l2), 0, NULL); 1078 st5_dl_release_l2l3(l2); 1079 mISDN_FsmChangeState(fi, ST_L2_4); 1080 if (l2->tm) 1081 l2_tei(l2, MDL_STATUS_DOWN_IND, 0); 1082 } 1083 } 1084 1085 static void 1086 l2_st6_dm_release(struct FsmInst *fi, int event, void *arg) 1087 { 1088 struct layer2 *l2 = fi->userdata; 1089 struct sk_buff *skb = arg; 1090 1091 if (get_PollFlagFree(l2, skb)) { 1092 stop_t200(l2, 8); 1093 lapb_dl_release_l2l3(l2, DL_RELEASE_CNF); 1094 mISDN_FsmChangeState(fi, ST_L2_4); 1095 if (l2->tm) 1096 l2_tei(l2, MDL_STATUS_DOWN_IND, 0); 1097 } 1098 } 1099 1100 static void 1101 enquiry_cr(struct layer2 *l2, u_char typ, u_char cr, u_char pf) 1102 { 1103 struct sk_buff *skb; 1104 u_char tmp[MAX_L2HEADER_LEN]; 1105 int i; 1106 1107 i = sethdraddr(l2, tmp, cr); 1108 if (test_bit(FLG_MOD128, &l2->flag)) { 1109 tmp[i++] = typ; 1110 tmp[i++] = (l2->vr << 1) | (pf ? 1 : 0); 1111 } else 1112 tmp[i++] = (l2->vr << 5) | typ | (pf ? 0x10 : 0); 1113 skb = mI_alloc_skb(i, GFP_ATOMIC); 1114 if (!skb) { 1115 printk(KERN_WARNING "%s: isdnl2 can't alloc sbbuff in %s\n", 1116 mISDNDevName4ch(&l2->ch), __func__); 1117 return; 1118 } 1119 skb_put_data(skb, tmp, i); 1120 enqueue_super(l2, skb); 1121 } 1122 1123 inline void 1124 enquiry_response(struct layer2 *l2) 1125 { 1126 if (test_bit(FLG_OWN_BUSY, &l2->flag)) 1127 enquiry_cr(l2, RNR, RSP, 1); 1128 else 1129 enquiry_cr(l2, RR, RSP, 1); 1130 test_and_clear_bit(FLG_ACK_PEND, &l2->flag); 1131 } 1132 1133 inline void 1134 transmit_enquiry(struct layer2 *l2) 1135 { 1136 if (test_bit(FLG_OWN_BUSY, &l2->flag)) 1137 enquiry_cr(l2, RNR, CMD, 1); 1138 else 1139 enquiry_cr(l2, RR, CMD, 1); 1140 test_and_clear_bit(FLG_ACK_PEND, &l2->flag); 1141 start_t200(l2, 9); 1142 } 1143 1144 1145 static void 1146 nrerrorrecovery(struct FsmInst *fi) 1147 { 1148 struct layer2 *l2 = fi->userdata; 1149 1150 l2mgr(l2, MDL_ERROR_IND, (void *) 'J'); 1151 establishlink(fi); 1152 test_and_clear_bit(FLG_L3_INIT, &l2->flag); 1153 } 1154 1155 static void 1156 invoke_retransmission(struct layer2 *l2, unsigned int nr) 1157 { 1158 u_int p1; 1159 1160 if (l2->vs != nr) { 1161 while (l2->vs != nr) { 1162 (l2->vs)--; 1163 if (test_bit(FLG_MOD128, &l2->flag)) { 1164 l2->vs %= 128; 1165 p1 = (l2->vs - l2->va) % 128; 1166 } else { 1167 l2->vs %= 8; 1168 p1 = (l2->vs - l2->va) % 8; 1169 } 1170 p1 = (p1 + l2->sow) % l2->window; 1171 if (l2->windowar[p1]) 1172 skb_queue_head(&l2->i_queue, l2->windowar[p1]); 1173 else 1174 printk(KERN_WARNING 1175 "%s: windowar[%d] is NULL\n", 1176 mISDNDevName4ch(&l2->ch), p1); 1177 l2->windowar[p1] = NULL; 1178 } 1179 mISDN_FsmEvent(&l2->l2m, EV_L2_ACK_PULL, NULL); 1180 } 1181 } 1182 1183 static void 1184 l2_st7_got_super(struct FsmInst *fi, int event, void *arg) 1185 { 1186 struct layer2 *l2 = fi->userdata; 1187 struct sk_buff *skb = arg; 1188 int PollFlag, rsp, typ = RR; 1189 unsigned int nr; 1190 1191 rsp = *skb->data & 0x2; 1192 if (test_bit(FLG_ORIG, &l2->flag)) 1193 rsp = !rsp; 1194 1195 skb_pull(skb, l2addrsize(l2)); 1196 if (IsRNR(skb->data, l2)) { 1197 set_peer_busy(l2); 1198 typ = RNR; 1199 } else 1200 clear_peer_busy(l2); 1201 if (IsREJ(skb->data, l2)) 1202 typ = REJ; 1203 1204 if (test_bit(FLG_MOD128, &l2->flag)) { 1205 PollFlag = (skb->data[1] & 0x1) == 0x1; 1206 nr = skb->data[1] >> 1; 1207 } else { 1208 PollFlag = (skb->data[0] & 0x10); 1209 nr = (skb->data[0] >> 5) & 0x7; 1210 } 1211 dev_kfree_skb(skb); 1212 1213 if (PollFlag) { 1214 if (rsp) 1215 l2mgr(l2, MDL_ERROR_IND, (void *) 'A'); 1216 else 1217 enquiry_response(l2); 1218 } 1219 if (legalnr(l2, nr)) { 1220 if (typ == REJ) { 1221 setva(l2, nr); 1222 invoke_retransmission(l2, nr); 1223 stop_t200(l2, 10); 1224 if (mISDN_FsmAddTimer(&l2->t203, l2->T203, 1225 EV_L2_T203, NULL, 6)) 1226 l2m_debug(&l2->l2m, "Restart T203 ST7 REJ"); 1227 } else if ((nr == l2->vs) && (typ == RR)) { 1228 setva(l2, nr); 1229 stop_t200(l2, 11); 1230 mISDN_FsmRestartTimer(&l2->t203, l2->T203, 1231 EV_L2_T203, NULL, 7); 1232 } else if ((l2->va != nr) || (typ == RNR)) { 1233 setva(l2, nr); 1234 if (typ != RR) 1235 mISDN_FsmDelTimer(&l2->t203, 9); 1236 restart_t200(l2, 12); 1237 } 1238 if (skb_queue_len(&l2->i_queue) && (typ == RR)) 1239 mISDN_FsmEvent(fi, EV_L2_ACK_PULL, NULL); 1240 } else 1241 nrerrorrecovery(fi); 1242 } 1243 1244 static void 1245 l2_feed_i_if_reest(struct FsmInst *fi, int event, void *arg) 1246 { 1247 struct layer2 *l2 = fi->userdata; 1248 struct sk_buff *skb = arg; 1249 1250 if (!test_bit(FLG_L3_INIT, &l2->flag)) 1251 skb_queue_tail(&l2->i_queue, skb); 1252 else 1253 dev_kfree_skb(skb); 1254 } 1255 1256 static void 1257 l2_feed_i_pull(struct FsmInst *fi, int event, void *arg) 1258 { 1259 struct layer2 *l2 = fi->userdata; 1260 struct sk_buff *skb = arg; 1261 1262 skb_queue_tail(&l2->i_queue, skb); 1263 mISDN_FsmEvent(fi, EV_L2_ACK_PULL, NULL); 1264 } 1265 1266 static void 1267 l2_feed_iqueue(struct FsmInst *fi, int event, void *arg) 1268 { 1269 struct layer2 *l2 = fi->userdata; 1270 struct sk_buff *skb = arg; 1271 1272 skb_queue_tail(&l2->i_queue, skb); 1273 } 1274 1275 static void 1276 l2_got_iframe(struct FsmInst *fi, int event, void *arg) 1277 { 1278 struct layer2 *l2 = fi->userdata; 1279 struct sk_buff *skb = arg; 1280 int PollFlag, i; 1281 u_int ns, nr; 1282 1283 i = l2addrsize(l2); 1284 if (test_bit(FLG_MOD128, &l2->flag)) { 1285 PollFlag = ((skb->data[i + 1] & 0x1) == 0x1); 1286 ns = skb->data[i] >> 1; 1287 nr = (skb->data[i + 1] >> 1) & 0x7f; 1288 } else { 1289 PollFlag = (skb->data[i] & 0x10); 1290 ns = (skb->data[i] >> 1) & 0x7; 1291 nr = (skb->data[i] >> 5) & 0x7; 1292 } 1293 if (test_bit(FLG_OWN_BUSY, &l2->flag)) { 1294 dev_kfree_skb(skb); 1295 if (PollFlag) 1296 enquiry_response(l2); 1297 } else { 1298 if (l2->vr == ns) { 1299 l2->vr++; 1300 if (test_bit(FLG_MOD128, &l2->flag)) 1301 l2->vr %= 128; 1302 else 1303 l2->vr %= 8; 1304 test_and_clear_bit(FLG_REJEXC, &l2->flag); 1305 if (PollFlag) 1306 enquiry_response(l2); 1307 else 1308 test_and_set_bit(FLG_ACK_PEND, &l2->flag); 1309 skb_pull(skb, l2headersize(l2, 0)); 1310 l2up(l2, DL_DATA_IND, skb); 1311 } else { 1312 /* n(s)!=v(r) */ 1313 dev_kfree_skb(skb); 1314 if (test_and_set_bit(FLG_REJEXC, &l2->flag)) { 1315 if (PollFlag) 1316 enquiry_response(l2); 1317 } else { 1318 enquiry_cr(l2, REJ, RSP, PollFlag); 1319 test_and_clear_bit(FLG_ACK_PEND, &l2->flag); 1320 } 1321 } 1322 } 1323 if (legalnr(l2, nr)) { 1324 if (!test_bit(FLG_PEER_BUSY, &l2->flag) && 1325 (fi->state == ST_L2_7)) { 1326 if (nr == l2->vs) { 1327 stop_t200(l2, 13); 1328 mISDN_FsmRestartTimer(&l2->t203, l2->T203, 1329 EV_L2_T203, NULL, 7); 1330 } else if (nr != l2->va) 1331 restart_t200(l2, 14); 1332 } 1333 setva(l2, nr); 1334 } else { 1335 nrerrorrecovery(fi); 1336 return; 1337 } 1338 if (skb_queue_len(&l2->i_queue) && (fi->state == ST_L2_7)) 1339 mISDN_FsmEvent(fi, EV_L2_ACK_PULL, NULL); 1340 if (test_and_clear_bit(FLG_ACK_PEND, &l2->flag)) 1341 enquiry_cr(l2, RR, RSP, 0); 1342 } 1343 1344 static void 1345 l2_got_tei(struct FsmInst *fi, int event, void *arg) 1346 { 1347 struct layer2 *l2 = fi->userdata; 1348 u_int info; 1349 1350 l2->tei = (signed char)(long)arg; 1351 set_channel_address(&l2->ch, l2->sapi, l2->tei); 1352 info = DL_INFO_L2_CONNECT; 1353 l2up_create(l2, DL_INFORMATION_IND, sizeof(info), &info); 1354 if (fi->state == ST_L2_3) { 1355 establishlink(fi); 1356 test_and_set_bit(FLG_L3_INIT, &l2->flag); 1357 } else 1358 mISDN_FsmChangeState(fi, ST_L2_4); 1359 if (skb_queue_len(&l2->ui_queue)) 1360 tx_ui(l2); 1361 } 1362 1363 static void 1364 l2_st5_tout_200(struct FsmInst *fi, int event, void *arg) 1365 { 1366 struct layer2 *l2 = fi->userdata; 1367 1368 if (test_bit(FLG_LAPD, &l2->flag) && 1369 test_bit(FLG_DCHAN_BUSY, &l2->flag)) { 1370 mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, 9); 1371 } else if (l2->rc == l2->N200) { 1372 mISDN_FsmChangeState(fi, ST_L2_4); 1373 test_and_clear_bit(FLG_T200_RUN, &l2->flag); 1374 skb_queue_purge(&l2->i_queue); 1375 l2mgr(l2, MDL_ERROR_IND, (void *) 'G'); 1376 if (test_bit(FLG_LAPB, &l2->flag)) 1377 l2down_create(l2, PH_DEACTIVATE_REQ, 1378 l2_newid(l2), 0, NULL); 1379 st5_dl_release_l2l3(l2); 1380 if (l2->tm) 1381 l2_tei(l2, MDL_STATUS_DOWN_IND, 0); 1382 } else { 1383 l2->rc++; 1384 mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, 9); 1385 send_uframe(l2, NULL, (test_bit(FLG_MOD128, &l2->flag) ? 1386 SABME : SABM) | 0x10, CMD); 1387 } 1388 } 1389 1390 static void 1391 l2_st6_tout_200(struct FsmInst *fi, int event, void *arg) 1392 { 1393 struct layer2 *l2 = fi->userdata; 1394 1395 if (test_bit(FLG_LAPD, &l2->flag) && 1396 test_bit(FLG_DCHAN_BUSY, &l2->flag)) { 1397 mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, 9); 1398 } else if (l2->rc == l2->N200) { 1399 mISDN_FsmChangeState(fi, ST_L2_4); 1400 test_and_clear_bit(FLG_T200_RUN, &l2->flag); 1401 l2mgr(l2, MDL_ERROR_IND, (void *) 'H'); 1402 lapb_dl_release_l2l3(l2, DL_RELEASE_CNF); 1403 if (l2->tm) 1404 l2_tei(l2, MDL_STATUS_DOWN_IND, 0); 1405 } else { 1406 l2->rc++; 1407 mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200, 1408 NULL, 9); 1409 send_uframe(l2, NULL, DISC | 0x10, CMD); 1410 } 1411 } 1412 1413 static void 1414 l2_st7_tout_200(struct FsmInst *fi, int event, void *arg) 1415 { 1416 struct layer2 *l2 = fi->userdata; 1417 1418 if (test_bit(FLG_LAPD, &l2->flag) && 1419 test_bit(FLG_DCHAN_BUSY, &l2->flag)) { 1420 mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, 9); 1421 return; 1422 } 1423 test_and_clear_bit(FLG_T200_RUN, &l2->flag); 1424 l2->rc = 0; 1425 mISDN_FsmChangeState(fi, ST_L2_8); 1426 transmit_enquiry(l2); 1427 l2->rc++; 1428 } 1429 1430 static void 1431 l2_st8_tout_200(struct FsmInst *fi, int event, void *arg) 1432 { 1433 struct layer2 *l2 = fi->userdata; 1434 1435 if (test_bit(FLG_LAPD, &l2->flag) && 1436 test_bit(FLG_DCHAN_BUSY, &l2->flag)) { 1437 mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, 9); 1438 return; 1439 } 1440 test_and_clear_bit(FLG_T200_RUN, &l2->flag); 1441 if (l2->rc == l2->N200) { 1442 l2mgr(l2, MDL_ERROR_IND, (void *) 'I'); 1443 establishlink(fi); 1444 test_and_clear_bit(FLG_L3_INIT, &l2->flag); 1445 } else { 1446 transmit_enquiry(l2); 1447 l2->rc++; 1448 } 1449 } 1450 1451 static void 1452 l2_st7_tout_203(struct FsmInst *fi, int event, void *arg) 1453 { 1454 struct layer2 *l2 = fi->userdata; 1455 1456 if (test_bit(FLG_LAPD, &l2->flag) && 1457 test_bit(FLG_DCHAN_BUSY, &l2->flag)) { 1458 mISDN_FsmAddTimer(&l2->t203, l2->T203, EV_L2_T203, NULL, 9); 1459 return; 1460 } 1461 mISDN_FsmChangeState(fi, ST_L2_8); 1462 transmit_enquiry(l2); 1463 l2->rc = 0; 1464 } 1465 1466 static void 1467 l2_pull_iqueue(struct FsmInst *fi, int event, void *arg) 1468 { 1469 struct layer2 *l2 = fi->userdata; 1470 struct sk_buff *skb, *nskb; 1471 u_char header[MAX_L2HEADER_LEN]; 1472 u_int i, p1; 1473 1474 if (!cansend(l2)) 1475 return; 1476 1477 skb = skb_dequeue(&l2->i_queue); 1478 if (!skb) 1479 return; 1480 i = sethdraddr(l2, header, CMD); 1481 if (test_bit(FLG_MOD128, &l2->flag)) { 1482 header[i++] = l2->vs << 1; 1483 header[i++] = l2->vr << 1; 1484 } else 1485 header[i++] = (l2->vr << 5) | (l2->vs << 1); 1486 nskb = skb_realloc_headroom(skb, i); 1487 if (!nskb) { 1488 printk(KERN_WARNING "%s: no headroom(%d) copy for IFrame\n", 1489 mISDNDevName4ch(&l2->ch), i); 1490 skb_queue_head(&l2->i_queue, skb); 1491 return; 1492 } 1493 if (test_bit(FLG_MOD128, &l2->flag)) { 1494 p1 = (l2->vs - l2->va) % 128; 1495 l2->vs = (l2->vs + 1) % 128; 1496 } else { 1497 p1 = (l2->vs - l2->va) % 8; 1498 l2->vs = (l2->vs + 1) % 8; 1499 } 1500 p1 = (p1 + l2->sow) % l2->window; 1501 if (l2->windowar[p1]) { 1502 printk(KERN_WARNING "%s: l2 try overwrite ack queue entry %d\n", 1503 mISDNDevName4ch(&l2->ch), p1); 1504 dev_kfree_skb(l2->windowar[p1]); 1505 } 1506 l2->windowar[p1] = skb; 1507 memcpy(skb_push(nskb, i), header, i); 1508 l2down(l2, PH_DATA_REQ, l2_newid(l2), nskb); 1509 test_and_clear_bit(FLG_ACK_PEND, &l2->flag); 1510 if (!test_and_set_bit(FLG_T200_RUN, &l2->flag)) { 1511 mISDN_FsmDelTimer(&l2->t203, 13); 1512 mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, 11); 1513 } 1514 } 1515 1516 static void 1517 l2_st8_got_super(struct FsmInst *fi, int event, void *arg) 1518 { 1519 struct layer2 *l2 = fi->userdata; 1520 struct sk_buff *skb = arg; 1521 int PollFlag, rsp, rnr = 0; 1522 unsigned int nr; 1523 1524 rsp = *skb->data & 0x2; 1525 if (test_bit(FLG_ORIG, &l2->flag)) 1526 rsp = !rsp; 1527 1528 skb_pull(skb, l2addrsize(l2)); 1529 1530 if (IsRNR(skb->data, l2)) { 1531 set_peer_busy(l2); 1532 rnr = 1; 1533 } else 1534 clear_peer_busy(l2); 1535 1536 if (test_bit(FLG_MOD128, &l2->flag)) { 1537 PollFlag = (skb->data[1] & 0x1) == 0x1; 1538 nr = skb->data[1] >> 1; 1539 } else { 1540 PollFlag = (skb->data[0] & 0x10); 1541 nr = (skb->data[0] >> 5) & 0x7; 1542 } 1543 dev_kfree_skb(skb); 1544 if (rsp && PollFlag) { 1545 if (legalnr(l2, nr)) { 1546 if (rnr) { 1547 restart_t200(l2, 15); 1548 } else { 1549 stop_t200(l2, 16); 1550 mISDN_FsmAddTimer(&l2->t203, l2->T203, 1551 EV_L2_T203, NULL, 5); 1552 setva(l2, nr); 1553 } 1554 invoke_retransmission(l2, nr); 1555 mISDN_FsmChangeState(fi, ST_L2_7); 1556 if (skb_queue_len(&l2->i_queue) && cansend(l2)) 1557 mISDN_FsmEvent(fi, EV_L2_ACK_PULL, NULL); 1558 } else 1559 nrerrorrecovery(fi); 1560 } else { 1561 if (!rsp && PollFlag) 1562 enquiry_response(l2); 1563 if (legalnr(l2, nr)) 1564 setva(l2, nr); 1565 else 1566 nrerrorrecovery(fi); 1567 } 1568 } 1569 1570 static void 1571 l2_got_FRMR(struct FsmInst *fi, int event, void *arg) 1572 { 1573 struct layer2 *l2 = fi->userdata; 1574 struct sk_buff *skb = arg; 1575 1576 skb_pull(skb, l2addrsize(l2) + 1); 1577 1578 if (!(skb->data[0] & 1) || ((skb->data[0] & 3) == 1) || /* I or S */ 1579 (IsUA(skb->data) && (fi->state == ST_L2_7))) { 1580 l2mgr(l2, MDL_ERROR_IND, (void *) 'K'); 1581 establishlink(fi); 1582 test_and_clear_bit(FLG_L3_INIT, &l2->flag); 1583 } 1584 dev_kfree_skb(skb); 1585 } 1586 1587 static void 1588 l2_st24_tei_remove(struct FsmInst *fi, int event, void *arg) 1589 { 1590 struct layer2 *l2 = fi->userdata; 1591 1592 skb_queue_purge(&l2->ui_queue); 1593 l2->tei = GROUP_TEI; 1594 mISDN_FsmChangeState(fi, ST_L2_1); 1595 } 1596 1597 static void 1598 l2_st3_tei_remove(struct FsmInst *fi, int event, void *arg) 1599 { 1600 struct layer2 *l2 = fi->userdata; 1601 1602 skb_queue_purge(&l2->ui_queue); 1603 l2->tei = GROUP_TEI; 1604 l2up_create(l2, DL_RELEASE_IND, 0, NULL); 1605 mISDN_FsmChangeState(fi, ST_L2_1); 1606 } 1607 1608 static void 1609 l2_st5_tei_remove(struct FsmInst *fi, int event, void *arg) 1610 { 1611 struct layer2 *l2 = fi->userdata; 1612 1613 skb_queue_purge(&l2->i_queue); 1614 skb_queue_purge(&l2->ui_queue); 1615 freewin(l2); 1616 l2->tei = GROUP_TEI; 1617 stop_t200(l2, 17); 1618 st5_dl_release_l2l3(l2); 1619 mISDN_FsmChangeState(fi, ST_L2_1); 1620 } 1621 1622 static void 1623 l2_st6_tei_remove(struct FsmInst *fi, int event, void *arg) 1624 { 1625 struct layer2 *l2 = fi->userdata; 1626 1627 skb_queue_purge(&l2->ui_queue); 1628 l2->tei = GROUP_TEI; 1629 stop_t200(l2, 18); 1630 l2up_create(l2, DL_RELEASE_IND, 0, NULL); 1631 mISDN_FsmChangeState(fi, ST_L2_1); 1632 } 1633 1634 static void 1635 l2_tei_remove(struct FsmInst *fi, int event, void *arg) 1636 { 1637 struct layer2 *l2 = fi->userdata; 1638 1639 skb_queue_purge(&l2->i_queue); 1640 skb_queue_purge(&l2->ui_queue); 1641 freewin(l2); 1642 l2->tei = GROUP_TEI; 1643 stop_t200(l2, 17); 1644 mISDN_FsmDelTimer(&l2->t203, 19); 1645 l2up_create(l2, DL_RELEASE_IND, 0, NULL); 1646 /* mISDN_queue_data(&l2->inst, l2->inst.id | MSG_BROADCAST, 1647 * MGR_SHORTSTATUS_IND, SSTATUS_L2_RELEASED, 1648 * 0, NULL, 0); 1649 */ 1650 mISDN_FsmChangeState(fi, ST_L2_1); 1651 } 1652 1653 static void 1654 l2_st14_persistent_da(struct FsmInst *fi, int event, void *arg) 1655 { 1656 struct layer2 *l2 = fi->userdata; 1657 struct sk_buff *skb = arg; 1658 1659 skb_queue_purge(&l2->i_queue); 1660 skb_queue_purge(&l2->ui_queue); 1661 if (test_and_clear_bit(FLG_ESTAB_PEND, &l2->flag)) 1662 l2up(l2, DL_RELEASE_IND, skb); 1663 else 1664 dev_kfree_skb(skb); 1665 } 1666 1667 static void 1668 l2_st5_persistent_da(struct FsmInst *fi, int event, void *arg) 1669 { 1670 struct layer2 *l2 = fi->userdata; 1671 struct sk_buff *skb = arg; 1672 1673 skb_queue_purge(&l2->i_queue); 1674 skb_queue_purge(&l2->ui_queue); 1675 freewin(l2); 1676 stop_t200(l2, 19); 1677 st5_dl_release_l2l3(l2); 1678 mISDN_FsmChangeState(fi, ST_L2_4); 1679 if (l2->tm) 1680 l2_tei(l2, MDL_STATUS_DOWN_IND, 0); 1681 dev_kfree_skb(skb); 1682 } 1683 1684 static void 1685 l2_st6_persistent_da(struct FsmInst *fi, int event, void *arg) 1686 { 1687 struct layer2 *l2 = fi->userdata; 1688 struct sk_buff *skb = arg; 1689 1690 skb_queue_purge(&l2->ui_queue); 1691 stop_t200(l2, 20); 1692 l2up(l2, DL_RELEASE_CNF, skb); 1693 mISDN_FsmChangeState(fi, ST_L2_4); 1694 if (l2->tm) 1695 l2_tei(l2, MDL_STATUS_DOWN_IND, 0); 1696 } 1697 1698 static void 1699 l2_persistent_da(struct FsmInst *fi, int event, void *arg) 1700 { 1701 struct layer2 *l2 = fi->userdata; 1702 struct sk_buff *skb = arg; 1703 1704 skb_queue_purge(&l2->i_queue); 1705 skb_queue_purge(&l2->ui_queue); 1706 freewin(l2); 1707 stop_t200(l2, 19); 1708 mISDN_FsmDelTimer(&l2->t203, 19); 1709 l2up(l2, DL_RELEASE_IND, skb); 1710 mISDN_FsmChangeState(fi, ST_L2_4); 1711 if (l2->tm) 1712 l2_tei(l2, MDL_STATUS_DOWN_IND, 0); 1713 } 1714 1715 static void 1716 l2_set_own_busy(struct FsmInst *fi, int event, void *arg) 1717 { 1718 struct layer2 *l2 = fi->userdata; 1719 struct sk_buff *skb = arg; 1720 1721 if (!test_and_set_bit(FLG_OWN_BUSY, &l2->flag)) { 1722 enquiry_cr(l2, RNR, RSP, 0); 1723 test_and_clear_bit(FLG_ACK_PEND, &l2->flag); 1724 } 1725 if (skb) 1726 dev_kfree_skb(skb); 1727 } 1728 1729 static void 1730 l2_clear_own_busy(struct FsmInst *fi, int event, void *arg) 1731 { 1732 struct layer2 *l2 = fi->userdata; 1733 struct sk_buff *skb = arg; 1734 1735 if (!test_and_clear_bit(FLG_OWN_BUSY, &l2->flag)) { 1736 enquiry_cr(l2, RR, RSP, 0); 1737 test_and_clear_bit(FLG_ACK_PEND, &l2->flag); 1738 } 1739 if (skb) 1740 dev_kfree_skb(skb); 1741 } 1742 1743 static void 1744 l2_frame_error(struct FsmInst *fi, int event, void *arg) 1745 { 1746 struct layer2 *l2 = fi->userdata; 1747 1748 l2mgr(l2, MDL_ERROR_IND, arg); 1749 } 1750 1751 static void 1752 l2_frame_error_reest(struct FsmInst *fi, int event, void *arg) 1753 { 1754 struct layer2 *l2 = fi->userdata; 1755 1756 l2mgr(l2, MDL_ERROR_IND, arg); 1757 establishlink(fi); 1758 test_and_clear_bit(FLG_L3_INIT, &l2->flag); 1759 } 1760 1761 static struct FsmNode L2FnList[] = 1762 { 1763 {ST_L2_1, EV_L2_DL_ESTABLISH_REQ, l2_mdl_assign}, 1764 {ST_L2_2, EV_L2_DL_ESTABLISH_REQ, l2_go_st3}, 1765 {ST_L2_4, EV_L2_DL_ESTABLISH_REQ, l2_establish}, 1766 {ST_L2_5, EV_L2_DL_ESTABLISH_REQ, l2_discard_i_setl3}, 1767 {ST_L2_7, EV_L2_DL_ESTABLISH_REQ, l2_l3_reestablish}, 1768 {ST_L2_8, EV_L2_DL_ESTABLISH_REQ, l2_l3_reestablish}, 1769 {ST_L2_4, EV_L2_DL_RELEASE_REQ, l2_release}, 1770 {ST_L2_5, EV_L2_DL_RELEASE_REQ, l2_pend_rel}, 1771 {ST_L2_7, EV_L2_DL_RELEASE_REQ, l2_disconnect}, 1772 {ST_L2_8, EV_L2_DL_RELEASE_REQ, l2_disconnect}, 1773 {ST_L2_5, EV_L2_DL_DATA, l2_feed_i_if_reest}, 1774 {ST_L2_7, EV_L2_DL_DATA, l2_feed_i_pull}, 1775 {ST_L2_8, EV_L2_DL_DATA, l2_feed_iqueue}, 1776 {ST_L2_1, EV_L2_DL_UNITDATA, l2_queue_ui_assign}, 1777 {ST_L2_2, EV_L2_DL_UNITDATA, l2_queue_ui}, 1778 {ST_L2_3, EV_L2_DL_UNITDATA, l2_queue_ui}, 1779 {ST_L2_4, EV_L2_DL_UNITDATA, l2_send_ui}, 1780 {ST_L2_5, EV_L2_DL_UNITDATA, l2_send_ui}, 1781 {ST_L2_6, EV_L2_DL_UNITDATA, l2_send_ui}, 1782 {ST_L2_7, EV_L2_DL_UNITDATA, l2_send_ui}, 1783 {ST_L2_8, EV_L2_DL_UNITDATA, l2_send_ui}, 1784 {ST_L2_1, EV_L2_MDL_ASSIGN, l2_got_tei}, 1785 {ST_L2_2, EV_L2_MDL_ASSIGN, l2_got_tei}, 1786 {ST_L2_3, EV_L2_MDL_ASSIGN, l2_got_tei}, 1787 {ST_L2_2, EV_L2_MDL_ERROR, l2_st24_tei_remove}, 1788 {ST_L2_3, EV_L2_MDL_ERROR, l2_st3_tei_remove}, 1789 {ST_L2_4, EV_L2_MDL_REMOVE, l2_st24_tei_remove}, 1790 {ST_L2_5, EV_L2_MDL_REMOVE, l2_st5_tei_remove}, 1791 {ST_L2_6, EV_L2_MDL_REMOVE, l2_st6_tei_remove}, 1792 {ST_L2_7, EV_L2_MDL_REMOVE, l2_tei_remove}, 1793 {ST_L2_8, EV_L2_MDL_REMOVE, l2_tei_remove}, 1794 {ST_L2_4, EV_L2_SABME, l2_start_multi}, 1795 {ST_L2_5, EV_L2_SABME, l2_send_UA}, 1796 {ST_L2_6, EV_L2_SABME, l2_send_DM}, 1797 {ST_L2_7, EV_L2_SABME, l2_restart_multi}, 1798 {ST_L2_8, EV_L2_SABME, l2_restart_multi}, 1799 {ST_L2_4, EV_L2_DISC, l2_send_DM}, 1800 {ST_L2_5, EV_L2_DISC, l2_send_DM}, 1801 {ST_L2_6, EV_L2_DISC, l2_send_UA}, 1802 {ST_L2_7, EV_L2_DISC, l2_stop_multi}, 1803 {ST_L2_8, EV_L2_DISC, l2_stop_multi}, 1804 {ST_L2_4, EV_L2_UA, l2_mdl_error_ua}, 1805 {ST_L2_5, EV_L2_UA, l2_connected}, 1806 {ST_L2_6, EV_L2_UA, l2_released}, 1807 {ST_L2_7, EV_L2_UA, l2_mdl_error_ua}, 1808 {ST_L2_8, EV_L2_UA, l2_mdl_error_ua}, 1809 {ST_L2_4, EV_L2_DM, l2_reestablish}, 1810 {ST_L2_5, EV_L2_DM, l2_st5_dm_release}, 1811 {ST_L2_6, EV_L2_DM, l2_st6_dm_release}, 1812 {ST_L2_7, EV_L2_DM, l2_mdl_error_dm}, 1813 {ST_L2_8, EV_L2_DM, l2_st8_mdl_error_dm}, 1814 {ST_L2_1, EV_L2_UI, l2_got_ui}, 1815 {ST_L2_2, EV_L2_UI, l2_got_ui}, 1816 {ST_L2_3, EV_L2_UI, l2_got_ui}, 1817 {ST_L2_4, EV_L2_UI, l2_got_ui}, 1818 {ST_L2_5, EV_L2_UI, l2_got_ui}, 1819 {ST_L2_6, EV_L2_UI, l2_got_ui}, 1820 {ST_L2_7, EV_L2_UI, l2_got_ui}, 1821 {ST_L2_8, EV_L2_UI, l2_got_ui}, 1822 {ST_L2_7, EV_L2_FRMR, l2_got_FRMR}, 1823 {ST_L2_8, EV_L2_FRMR, l2_got_FRMR}, 1824 {ST_L2_7, EV_L2_SUPER, l2_st7_got_super}, 1825 {ST_L2_8, EV_L2_SUPER, l2_st8_got_super}, 1826 {ST_L2_7, EV_L2_I, l2_got_iframe}, 1827 {ST_L2_8, EV_L2_I, l2_got_iframe}, 1828 {ST_L2_5, EV_L2_T200, l2_timeout}, 1829 {ST_L2_6, EV_L2_T200, l2_timeout}, 1830 {ST_L2_7, EV_L2_T200, l2_timeout}, 1831 {ST_L2_8, EV_L2_T200, l2_timeout}, 1832 {ST_L2_7, EV_L2_T203, l2_timeout}, 1833 {ST_L2_5, EV_L2_T200I, l2_st5_tout_200}, 1834 {ST_L2_6, EV_L2_T200I, l2_st6_tout_200}, 1835 {ST_L2_7, EV_L2_T200I, l2_st7_tout_200}, 1836 {ST_L2_8, EV_L2_T200I, l2_st8_tout_200}, 1837 {ST_L2_7, EV_L2_T203I, l2_st7_tout_203}, 1838 {ST_L2_7, EV_L2_ACK_PULL, l2_pull_iqueue}, 1839 {ST_L2_7, EV_L2_SET_OWN_BUSY, l2_set_own_busy}, 1840 {ST_L2_8, EV_L2_SET_OWN_BUSY, l2_set_own_busy}, 1841 {ST_L2_7, EV_L2_CLEAR_OWN_BUSY, l2_clear_own_busy}, 1842 {ST_L2_8, EV_L2_CLEAR_OWN_BUSY, l2_clear_own_busy}, 1843 {ST_L2_4, EV_L2_FRAME_ERROR, l2_frame_error}, 1844 {ST_L2_5, EV_L2_FRAME_ERROR, l2_frame_error}, 1845 {ST_L2_6, EV_L2_FRAME_ERROR, l2_frame_error}, 1846 {ST_L2_7, EV_L2_FRAME_ERROR, l2_frame_error_reest}, 1847 {ST_L2_8, EV_L2_FRAME_ERROR, l2_frame_error_reest}, 1848 {ST_L2_1, EV_L1_DEACTIVATE, l2_st14_persistent_da}, 1849 {ST_L2_2, EV_L1_DEACTIVATE, l2_st24_tei_remove}, 1850 {ST_L2_3, EV_L1_DEACTIVATE, l2_st3_tei_remove}, 1851 {ST_L2_4, EV_L1_DEACTIVATE, l2_st14_persistent_da}, 1852 {ST_L2_5, EV_L1_DEACTIVATE, l2_st5_persistent_da}, 1853 {ST_L2_6, EV_L1_DEACTIVATE, l2_st6_persistent_da}, 1854 {ST_L2_7, EV_L1_DEACTIVATE, l2_persistent_da}, 1855 {ST_L2_8, EV_L1_DEACTIVATE, l2_persistent_da}, 1856 }; 1857 1858 static int 1859 ph_data_indication(struct layer2 *l2, struct mISDNhead *hh, struct sk_buff *skb) 1860 { 1861 u_char *datap = skb->data; 1862 int ret = -EINVAL; 1863 int psapi, ptei; 1864 u_int l; 1865 int c = 0; 1866 1867 l = l2addrsize(l2); 1868 if (skb->len <= l) { 1869 mISDN_FsmEvent(&l2->l2m, EV_L2_FRAME_ERROR, (void *) 'N'); 1870 return ret; 1871 } 1872 if (test_bit(FLG_LAPD, &l2->flag)) { /* Maybe not needed */ 1873 psapi = *datap++; 1874 ptei = *datap++; 1875 if ((psapi & 1) || !(ptei & 1)) { 1876 printk(KERN_WARNING 1877 "%s l2 D-channel frame wrong EA0/EA1\n", 1878 mISDNDevName4ch(&l2->ch)); 1879 return ret; 1880 } 1881 psapi >>= 2; 1882 ptei >>= 1; 1883 if (psapi != l2->sapi) { 1884 /* not our business */ 1885 if (*debug & DEBUG_L2) 1886 printk(KERN_DEBUG "%s: sapi %d/%d mismatch\n", 1887 mISDNDevName4ch(&l2->ch), psapi, 1888 l2->sapi); 1889 dev_kfree_skb(skb); 1890 return 0; 1891 } 1892 if ((ptei != l2->tei) && (ptei != GROUP_TEI)) { 1893 /* not our business */ 1894 if (*debug & DEBUG_L2) 1895 printk(KERN_DEBUG "%s: tei %d/%d mismatch\n", 1896 mISDNDevName4ch(&l2->ch), ptei, l2->tei); 1897 dev_kfree_skb(skb); 1898 return 0; 1899 } 1900 } else 1901 datap += l; 1902 if (!(*datap & 1)) { /* I-Frame */ 1903 c = iframe_error(l2, skb); 1904 if (!c) 1905 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_I, skb); 1906 } else if (IsSFrame(datap, l2)) { /* S-Frame */ 1907 c = super_error(l2, skb); 1908 if (!c) 1909 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_SUPER, skb); 1910 } else if (IsUI(datap)) { 1911 c = UI_error(l2, skb); 1912 if (!c) 1913 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_UI, skb); 1914 } else if (IsSABME(datap, l2)) { 1915 c = unnum_error(l2, skb, CMD); 1916 if (!c) 1917 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_SABME, skb); 1918 } else if (IsUA(datap)) { 1919 c = unnum_error(l2, skb, RSP); 1920 if (!c) 1921 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_UA, skb); 1922 } else if (IsDISC(datap)) { 1923 c = unnum_error(l2, skb, CMD); 1924 if (!c) 1925 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_DISC, skb); 1926 } else if (IsDM(datap)) { 1927 c = unnum_error(l2, skb, RSP); 1928 if (!c) 1929 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_DM, skb); 1930 } else if (IsFRMR(datap)) { 1931 c = FRMR_error(l2, skb); 1932 if (!c) 1933 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_FRMR, skb); 1934 } else 1935 c = 'L'; 1936 if (c) { 1937 printk(KERN_WARNING "%s:l2 D-channel frame error %c\n", 1938 mISDNDevName4ch(&l2->ch), c); 1939 mISDN_FsmEvent(&l2->l2m, EV_L2_FRAME_ERROR, (void *)(long)c); 1940 } 1941 return ret; 1942 } 1943 1944 static int 1945 l2_send(struct mISDNchannel *ch, struct sk_buff *skb) 1946 { 1947 struct layer2 *l2 = container_of(ch, struct layer2, ch); 1948 struct mISDNhead *hh = mISDN_HEAD_P(skb); 1949 int ret = -EINVAL; 1950 1951 if (*debug & DEBUG_L2_RECV) 1952 printk(KERN_DEBUG "%s: %s prim(%x) id(%x) sapi(%d) tei(%d)\n", 1953 __func__, mISDNDevName4ch(&l2->ch), hh->prim, hh->id, 1954 l2->sapi, l2->tei); 1955 if (hh->prim == DL_INTERN_MSG) { 1956 struct mISDNhead *chh = hh + 1; /* saved copy */ 1957 1958 *hh = *chh; 1959 if (*debug & DEBUG_L2_RECV) 1960 printk(KERN_DEBUG "%s: prim(%x) id(%x) internal msg\n", 1961 mISDNDevName4ch(&l2->ch), hh->prim, hh->id); 1962 } 1963 switch (hh->prim) { 1964 case PH_DATA_IND: 1965 ret = ph_data_indication(l2, hh, skb); 1966 break; 1967 case PH_DATA_CNF: 1968 ret = ph_data_confirm(l2, hh, skb); 1969 break; 1970 case PH_ACTIVATE_IND: 1971 test_and_set_bit(FLG_L1_ACTIV, &l2->flag); 1972 l2up_create(l2, MPH_ACTIVATE_IND, 0, NULL); 1973 if (test_and_clear_bit(FLG_ESTAB_PEND, &l2->flag)) 1974 ret = mISDN_FsmEvent(&l2->l2m, 1975 EV_L2_DL_ESTABLISH_REQ, skb); 1976 break; 1977 case PH_DEACTIVATE_IND: 1978 test_and_clear_bit(FLG_L1_ACTIV, &l2->flag); 1979 l2up_create(l2, MPH_DEACTIVATE_IND, 0, NULL); 1980 ret = mISDN_FsmEvent(&l2->l2m, EV_L1_DEACTIVATE, skb); 1981 break; 1982 case MPH_INFORMATION_IND: 1983 if (!l2->up) 1984 break; 1985 ret = l2->up->send(l2->up, skb); 1986 break; 1987 case DL_DATA_REQ: 1988 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_DL_DATA, skb); 1989 break; 1990 case DL_UNITDATA_REQ: 1991 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_DL_UNITDATA, skb); 1992 break; 1993 case DL_ESTABLISH_REQ: 1994 if (test_bit(FLG_LAPB, &l2->flag)) 1995 test_and_set_bit(FLG_ORIG, &l2->flag); 1996 if (test_bit(FLG_L1_ACTIV, &l2->flag)) { 1997 if (test_bit(FLG_LAPD, &l2->flag) || 1998 test_bit(FLG_ORIG, &l2->flag)) 1999 ret = mISDN_FsmEvent(&l2->l2m, 2000 EV_L2_DL_ESTABLISH_REQ, skb); 2001 } else { 2002 if (test_bit(FLG_LAPD, &l2->flag) || 2003 test_bit(FLG_ORIG, &l2->flag)) { 2004 test_and_set_bit(FLG_ESTAB_PEND, 2005 &l2->flag); 2006 } 2007 ret = l2down(l2, PH_ACTIVATE_REQ, l2_newid(l2), 2008 skb); 2009 } 2010 break; 2011 case DL_RELEASE_REQ: 2012 if (test_bit(FLG_LAPB, &l2->flag)) 2013 l2down_create(l2, PH_DEACTIVATE_REQ, 2014 l2_newid(l2), 0, NULL); 2015 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_DL_RELEASE_REQ, 2016 skb); 2017 break; 2018 case DL_TIMER200_IND: 2019 mISDN_FsmEvent(&l2->l2m, EV_L2_T200I, NULL); 2020 break; 2021 case DL_TIMER203_IND: 2022 mISDN_FsmEvent(&l2->l2m, EV_L2_T203I, NULL); 2023 break; 2024 default: 2025 if (*debug & DEBUG_L2) 2026 l2m_debug(&l2->l2m, "l2 unknown pr %04x", 2027 hh->prim); 2028 } 2029 if (ret) { 2030 dev_kfree_skb(skb); 2031 ret = 0; 2032 } 2033 return ret; 2034 } 2035 2036 int 2037 tei_l2(struct layer2 *l2, u_int cmd, u_long arg) 2038 { 2039 int ret = -EINVAL; 2040 2041 if (*debug & DEBUG_L2_TEI) 2042 printk(KERN_DEBUG "%s: cmd(%x) in %s\n", 2043 mISDNDevName4ch(&l2->ch), cmd, __func__); 2044 switch (cmd) { 2045 case (MDL_ASSIGN_REQ): 2046 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_MDL_ASSIGN, (void *)arg); 2047 break; 2048 case (MDL_REMOVE_REQ): 2049 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_MDL_REMOVE, NULL); 2050 break; 2051 case (MDL_ERROR_IND): 2052 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_MDL_ERROR, NULL); 2053 break; 2054 case (MDL_ERROR_RSP): 2055 /* ETS 300-125 5.3.2.1 Test: TC13010 */ 2056 printk(KERN_NOTICE "%s: MDL_ERROR|REQ (tei_l2)\n", 2057 mISDNDevName4ch(&l2->ch)); 2058 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_MDL_ERROR, NULL); 2059 break; 2060 } 2061 return ret; 2062 } 2063 2064 static void 2065 release_l2(struct layer2 *l2) 2066 { 2067 mISDN_FsmDelTimer(&l2->t200, 21); 2068 mISDN_FsmDelTimer(&l2->t203, 16); 2069 skb_queue_purge(&l2->i_queue); 2070 skb_queue_purge(&l2->ui_queue); 2071 skb_queue_purge(&l2->down_queue); 2072 ReleaseWin(l2); 2073 if (test_bit(FLG_LAPD, &l2->flag)) { 2074 TEIrelease(l2); 2075 if (l2->ch.st) 2076 l2->ch.st->dev->D.ctrl(&l2->ch.st->dev->D, 2077 CLOSE_CHANNEL, NULL); 2078 } 2079 kfree(l2); 2080 } 2081 2082 static int 2083 l2_ctrl(struct mISDNchannel *ch, u_int cmd, void *arg) 2084 { 2085 struct layer2 *l2 = container_of(ch, struct layer2, ch); 2086 u_int info; 2087 2088 if (*debug & DEBUG_L2_CTRL) 2089 printk(KERN_DEBUG "%s: %s cmd(%x)\n", 2090 mISDNDevName4ch(ch), __func__, cmd); 2091 2092 switch (cmd) { 2093 case OPEN_CHANNEL: 2094 if (test_bit(FLG_LAPD, &l2->flag)) { 2095 set_channel_address(&l2->ch, l2->sapi, l2->tei); 2096 info = DL_INFO_L2_CONNECT; 2097 l2up_create(l2, DL_INFORMATION_IND, 2098 sizeof(info), &info); 2099 } 2100 break; 2101 case CLOSE_CHANNEL: 2102 if (l2->ch.peer) 2103 l2->ch.peer->ctrl(l2->ch.peer, CLOSE_CHANNEL, NULL); 2104 release_l2(l2); 2105 break; 2106 } 2107 return 0; 2108 } 2109 2110 struct layer2 * 2111 create_l2(struct mISDNchannel *ch, u_int protocol, u_long options, int tei, 2112 int sapi) 2113 { 2114 struct layer2 *l2; 2115 struct channel_req rq; 2116 2117 l2 = kzalloc(sizeof(struct layer2), GFP_KERNEL); 2118 if (!l2) { 2119 printk(KERN_ERR "kzalloc layer2 failed\n"); 2120 return NULL; 2121 } 2122 l2->next_id = 1; 2123 l2->down_id = MISDN_ID_NONE; 2124 l2->up = ch; 2125 l2->ch.st = ch->st; 2126 l2->ch.send = l2_send; 2127 l2->ch.ctrl = l2_ctrl; 2128 switch (protocol) { 2129 case ISDN_P_LAPD_NT: 2130 test_and_set_bit(FLG_LAPD, &l2->flag); 2131 test_and_set_bit(FLG_LAPD_NET, &l2->flag); 2132 test_and_set_bit(FLG_MOD128, &l2->flag); 2133 l2->sapi = sapi; 2134 l2->maxlen = MAX_DFRAME_LEN; 2135 if (test_bit(OPTION_L2_PMX, &options)) 2136 l2->window = 7; 2137 else 2138 l2->window = 1; 2139 if (test_bit(OPTION_L2_PTP, &options)) 2140 test_and_set_bit(FLG_PTP, &l2->flag); 2141 if (test_bit(OPTION_L2_FIXEDTEI, &options)) 2142 test_and_set_bit(FLG_FIXED_TEI, &l2->flag); 2143 l2->tei = tei; 2144 l2->T200 = 1000; 2145 l2->N200 = 3; 2146 l2->T203 = 10000; 2147 if (test_bit(OPTION_L2_PMX, &options)) 2148 rq.protocol = ISDN_P_NT_E1; 2149 else 2150 rq.protocol = ISDN_P_NT_S0; 2151 rq.adr.channel = 0; 2152 l2->ch.st->dev->D.ctrl(&l2->ch.st->dev->D, OPEN_CHANNEL, &rq); 2153 break; 2154 case ISDN_P_LAPD_TE: 2155 test_and_set_bit(FLG_LAPD, &l2->flag); 2156 test_and_set_bit(FLG_MOD128, &l2->flag); 2157 test_and_set_bit(FLG_ORIG, &l2->flag); 2158 l2->sapi = sapi; 2159 l2->maxlen = MAX_DFRAME_LEN; 2160 if (test_bit(OPTION_L2_PMX, &options)) 2161 l2->window = 7; 2162 else 2163 l2->window = 1; 2164 if (test_bit(OPTION_L2_PTP, &options)) 2165 test_and_set_bit(FLG_PTP, &l2->flag); 2166 if (test_bit(OPTION_L2_FIXEDTEI, &options)) 2167 test_and_set_bit(FLG_FIXED_TEI, &l2->flag); 2168 l2->tei = tei; 2169 l2->T200 = 1000; 2170 l2->N200 = 3; 2171 l2->T203 = 10000; 2172 if (test_bit(OPTION_L2_PMX, &options)) 2173 rq.protocol = ISDN_P_TE_E1; 2174 else 2175 rq.protocol = ISDN_P_TE_S0; 2176 rq.adr.channel = 0; 2177 l2->ch.st->dev->D.ctrl(&l2->ch.st->dev->D, OPEN_CHANNEL, &rq); 2178 break; 2179 case ISDN_P_B_X75SLP: 2180 test_and_set_bit(FLG_LAPB, &l2->flag); 2181 l2->window = 7; 2182 l2->maxlen = MAX_DATA_SIZE; 2183 l2->T200 = 1000; 2184 l2->N200 = 4; 2185 l2->T203 = 5000; 2186 l2->addr.A = 3; 2187 l2->addr.B = 1; 2188 break; 2189 default: 2190 printk(KERN_ERR "layer2 create failed prt %x\n", 2191 protocol); 2192 kfree(l2); 2193 return NULL; 2194 } 2195 skb_queue_head_init(&l2->i_queue); 2196 skb_queue_head_init(&l2->ui_queue); 2197 skb_queue_head_init(&l2->down_queue); 2198 skb_queue_head_init(&l2->tmp_queue); 2199 InitWin(l2); 2200 l2->l2m.fsm = &l2fsm; 2201 if (test_bit(FLG_LAPB, &l2->flag) || 2202 test_bit(FLG_FIXED_TEI, &l2->flag) || 2203 test_bit(FLG_LAPD_NET, &l2->flag)) 2204 l2->l2m.state = ST_L2_4; 2205 else 2206 l2->l2m.state = ST_L2_1; 2207 l2->l2m.debug = *debug; 2208 l2->l2m.userdata = l2; 2209 l2->l2m.userint = 0; 2210 l2->l2m.printdebug = l2m_debug; 2211 2212 mISDN_FsmInitTimer(&l2->l2m, &l2->t200); 2213 mISDN_FsmInitTimer(&l2->l2m, &l2->t203); 2214 return l2; 2215 } 2216 2217 static int 2218 x75create(struct channel_req *crq) 2219 { 2220 struct layer2 *l2; 2221 2222 if (crq->protocol != ISDN_P_B_X75SLP) 2223 return -EPROTONOSUPPORT; 2224 l2 = create_l2(crq->ch, crq->protocol, 0, 0, 0); 2225 if (!l2) 2226 return -ENOMEM; 2227 crq->ch = &l2->ch; 2228 crq->protocol = ISDN_P_B_HDLC; 2229 return 0; 2230 } 2231 2232 static struct Bprotocol X75SLP = { 2233 .Bprotocols = (1 << (ISDN_P_B_X75SLP & ISDN_P_B_MASK)), 2234 .name = "X75SLP", 2235 .create = x75create 2236 }; 2237 2238 int 2239 Isdnl2_Init(u_int *deb) 2240 { 2241 int res; 2242 debug = deb; 2243 mISDN_register_Bprotocol(&X75SLP); 2244 l2fsm.state_count = L2_STATE_COUNT; 2245 l2fsm.event_count = L2_EVENT_COUNT; 2246 l2fsm.strEvent = strL2Event; 2247 l2fsm.strState = strL2State; 2248 res = mISDN_FsmNew(&l2fsm, L2FnList, ARRAY_SIZE(L2FnList)); 2249 if (res) 2250 goto error; 2251 res = TEIInit(deb); 2252 if (res) 2253 goto error_fsm; 2254 return 0; 2255 2256 error_fsm: 2257 mISDN_FsmFree(&l2fsm); 2258 error: 2259 mISDN_unregister_Bprotocol(&X75SLP); 2260 return res; 2261 } 2262 2263 void 2264 Isdnl2_cleanup(void) 2265 { 2266 mISDN_unregister_Bprotocol(&X75SLP); 2267 TEIFree(); 2268 mISDN_FsmFree(&l2fsm); 2269 } 2270