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