1/* $Id: isdnl2.c,v 2.30.2.4 2004/02/11 13:21:34 Exp $ 2 * 3 * Author Karsten Keil 4 * based on the teles driver from Jan den Ouden 5 * Copyright by Karsten Keil <keil@isdn4linux.de> 6 * 7 * This software may be used and distributed according to the terms 8 * of the GNU General Public License, incorporated herein by reference. 9 * 10 * For changes and modifications please read 11 * Documentation/isdn/HiSax.cert 12 * 13 * Thanks to Jan den Ouden 14 * Fritz Elfert 15 * 16 */ 17 18#include <linux/init.h> 19#include <linux/gfp.h> 20#include "hisax.h" 21#include "isdnl2.h" 22 23const char *l2_revision = "$Revision: 2.30.2.4 $"; 24 25static void l2m_debug(struct FsmInst *fi, char *fmt, ...); 26 27static struct Fsm l2fsm; 28 29enum { 30 ST_L2_1, 31 ST_L2_2, 32 ST_L2_3, 33 ST_L2_4, 34 ST_L2_5, 35 ST_L2_6, 36 ST_L2_7, 37 ST_L2_8, 38}; 39 40#define L2_STATE_COUNT (ST_L2_8+1) 41 42static char *strL2State[] = 43{ 44 "ST_L2_1", 45 "ST_L2_2", 46 "ST_L2_3", 47 "ST_L2_4", 48 "ST_L2_5", 49 "ST_L2_6", 50 "ST_L2_7", 51 "ST_L2_8", 52}; 53 54enum { 55 EV_L2_UI, 56 EV_L2_SABME, 57 EV_L2_DISC, 58 EV_L2_DM, 59 EV_L2_UA, 60 EV_L2_FRMR, 61 EV_L2_SUPER, 62 EV_L2_I, 63 EV_L2_DL_DATA, 64 EV_L2_ACK_PULL, 65 EV_L2_DL_UNIT_DATA, 66 EV_L2_DL_ESTABLISH_REQ, 67 EV_L2_DL_RELEASE_REQ, 68 EV_L2_MDL_ASSIGN, 69 EV_L2_MDL_REMOVE, 70 EV_L2_MDL_ERROR, 71 EV_L1_DEACTIVATE, 72 EV_L2_T200, 73 EV_L2_T203, 74 EV_L2_SET_OWN_BUSY, 75 EV_L2_CLEAR_OWN_BUSY, 76 EV_L2_FRAME_ERROR, 77}; 78 79#define L2_EVENT_COUNT (EV_L2_FRAME_ERROR+1) 80 81static char *strL2Event[] = 82{ 83 "EV_L2_UI", 84 "EV_L2_SABME", 85 "EV_L2_DISC", 86 "EV_L2_DM", 87 "EV_L2_UA", 88 "EV_L2_FRMR", 89 "EV_L2_SUPER", 90 "EV_L2_I", 91 "EV_L2_DL_DATA", 92 "EV_L2_ACK_PULL", 93 "EV_L2_DL_UNIT_DATA", 94 "EV_L2_DL_ESTABLISH_REQ", 95 "EV_L2_DL_RELEASE_REQ", 96 "EV_L2_MDL_ASSIGN", 97 "EV_L2_MDL_REMOVE", 98 "EV_L2_MDL_ERROR", 99 "EV_L1_DEACTIVATE", 100 "EV_L2_T200", 101 "EV_L2_T203", 102 "EV_L2_SET_OWN_BUSY", 103 "EV_L2_CLEAR_OWN_BUSY", 104 "EV_L2_FRAME_ERROR", 105}; 106 107static int l2addrsize(struct Layer2 *l2); 108 109static void 110set_peer_busy(struct Layer2 *l2) { 111 test_and_set_bit(FLG_PEER_BUSY, &l2->flag); 112 if (!skb_queue_empty(&l2->i_queue) || 113 !skb_queue_empty(&l2->ui_queue)) 114 test_and_set_bit(FLG_L2BLOCK, &l2->flag); 115} 116 117static void 118clear_peer_busy(struct Layer2 *l2) { 119 if (test_and_clear_bit(FLG_PEER_BUSY, &l2->flag)) 120 test_and_clear_bit(FLG_L2BLOCK, &l2->flag); 121} 122 123static void 124InitWin(struct Layer2 *l2) 125{ 126 int i; 127 128 for (i = 0; i < MAX_WINDOW; i++) 129 l2->windowar[i] = NULL; 130} 131 132static int 133freewin1(struct Layer2 *l2) 134{ 135 int i, cnt = 0; 136 137 for (i = 0; i < MAX_WINDOW; i++) { 138 if (l2->windowar[i]) { 139 cnt++; 140 dev_kfree_skb(l2->windowar[i]); 141 l2->windowar[i] = NULL; 142 } 143 } 144 return cnt; 145} 146 147static inline void 148freewin(struct PStack *st) 149{ 150 freewin1(&st->l2); 151} 152 153static void 154ReleaseWin(struct Layer2 *l2) 155{ 156 int cnt; 157 158 if((cnt = freewin1(l2))) 159 printk(KERN_WARNING "isdl2 freed %d skbuffs in release\n", cnt); 160} 161 162static inline unsigned int 163cansend(struct PStack *st) 164{ 165 unsigned int p1; 166 167 if(test_bit(FLG_MOD128, &st->l2.flag)) 168 p1 = (st->l2.vs - st->l2.va) % 128; 169 else 170 p1 = (st->l2.vs - st->l2.va) % 8; 171 return ((p1 < st->l2.window) && !test_bit(FLG_PEER_BUSY, &st->l2.flag)); 172} 173 174static inline void 175clear_exception(struct Layer2 *l2) 176{ 177 test_and_clear_bit(FLG_ACK_PEND, &l2->flag); 178 test_and_clear_bit(FLG_REJEXC, &l2->flag); 179 test_and_clear_bit(FLG_OWN_BUSY, &l2->flag); 180 clear_peer_busy(l2); 181} 182 183static inline int 184l2headersize(struct Layer2 *l2, int ui) 185{ 186 return (((test_bit(FLG_MOD128, &l2->flag) && (!ui)) ? 2 : 1) + 187 (test_bit(FLG_LAPD, &l2->flag) ? 2 : 1)); 188} 189 190inline int 191l2addrsize(struct Layer2 *l2) 192{ 193 return (test_bit(FLG_LAPD, &l2->flag) ? 2 : 1); 194} 195 196static int 197sethdraddr(struct Layer2 *l2, u_char * header, int rsp) 198{ 199 u_char *ptr = header; 200 int crbit = rsp; 201 202 if (test_bit(FLG_LAPD, &l2->flag)) { 203 *ptr++ = (l2->sap << 2) | (rsp ? 2 : 0); 204 *ptr++ = (l2->tei << 1) | 1; 205 return (2); 206 } else { 207 if (test_bit(FLG_ORIG, &l2->flag)) 208 crbit = !crbit; 209 if (crbit) 210 *ptr++ = 1; 211 else 212 *ptr++ = 3; 213 return (1); 214 } 215} 216 217static inline void 218enqueue_super(struct PStack *st, 219 struct sk_buff *skb) 220{ 221 if (test_bit(FLG_LAPB, &st->l2.flag)) 222 st->l1.bcs->tx_cnt += skb->len; 223 st->l2.l2l1(st, PH_DATA | REQUEST, skb); 224} 225 226#define enqueue_ui(a, b) enqueue_super(a, b) 227 228static inline int 229IsUI(u_char * data) 230{ 231 return ((data[0] & 0xef) == UI); 232} 233 234static inline int 235IsUA(u_char * data) 236{ 237 return ((data[0] & 0xef) == UA); 238} 239 240static inline int 241IsDM(u_char * data) 242{ 243 return ((data[0] & 0xef) == DM); 244} 245 246static inline int 247IsDISC(u_char * data) 248{ 249 return ((data[0] & 0xef) == DISC); 250} 251 252static inline int 253IsSFrame(u_char * data, struct PStack *st) 254{ 255 register u_char d = *data; 256 257 if (!test_bit(FLG_MOD128, &st->l2.flag)) 258 d &= 0xf; 259 return(((d & 0xf3) == 1) && ((d & 0x0c) != 0x0c)); 260} 261 262static inline int 263IsSABME(u_char * data, struct PStack *st) 264{ 265 u_char d = data[0] & ~0x10; 266 267 return (test_bit(FLG_MOD128, &st->l2.flag) ? d == SABME : d == SABM); 268} 269 270static inline int 271IsREJ(u_char * data, struct PStack *st) 272{ 273 return (test_bit(FLG_MOD128, &st->l2.flag) ? data[0] == REJ : (data[0] & 0xf) == REJ); 274} 275 276static inline int 277IsFRMR(u_char * data) 278{ 279 return ((data[0] & 0xef) == FRMR); 280} 281 282static inline int 283IsRNR(u_char * data, struct PStack *st) 284{ 285 return (test_bit(FLG_MOD128, &st->l2.flag) ? data[0] == RNR : (data[0] & 0xf) == RNR); 286} 287 288static int 289iframe_error(struct PStack *st, struct sk_buff *skb) 290{ 291 int i = l2addrsize(&st->l2) + (test_bit(FLG_MOD128, &st->l2.flag) ? 2 : 1); 292 int rsp = *skb->data & 0x2; 293 294 if (test_bit(FLG_ORIG, &st->l2.flag)) 295 rsp = !rsp; 296 297 if (rsp) 298 return 'L'; 299 300 301 if (skb->len < i) 302 return 'N'; 303 304 if ((skb->len - i) > st->l2.maxlen) 305 return 'O'; 306 307 308 return 0; 309} 310 311static int 312super_error(struct PStack *st, struct sk_buff *skb) 313{ 314 if (skb->len != l2addrsize(&st->l2) + 315 (test_bit(FLG_MOD128, &st->l2.flag) ? 2 : 1)) 316 return 'N'; 317 318 return 0; 319} 320 321static int 322unnum_error(struct PStack *st, struct sk_buff *skb, int wantrsp) 323{ 324 int rsp = (*skb->data & 0x2) >> 1; 325 if (test_bit(FLG_ORIG, &st->l2.flag)) 326 rsp = !rsp; 327 328 if (rsp != wantrsp) 329 return 'L'; 330 331 if (skb->len != l2addrsize(&st->l2) + 1) 332 return 'N'; 333 334 return 0; 335} 336 337static int 338UI_error(struct PStack *st, struct sk_buff *skb) 339{ 340 int rsp = *skb->data & 0x2; 341 if (test_bit(FLG_ORIG, &st->l2.flag)) 342 rsp = !rsp; 343 344 if (rsp) 345 return 'L'; 346 347 if (skb->len > st->l2.maxlen + l2addrsize(&st->l2) + 1) 348 return 'O'; 349 350 return 0; 351} 352 353static int 354FRMR_error(struct PStack *st, struct sk_buff *skb) 355{ 356 int headers = l2addrsize(&st->l2) + 1; 357 u_char *datap = skb->data + headers; 358 int rsp = *skb->data & 0x2; 359 360 if (test_bit(FLG_ORIG, &st->l2.flag)) 361 rsp = !rsp; 362 363 if (!rsp) 364 return 'L'; 365 366 if (test_bit(FLG_MOD128, &st->l2.flag)) { 367 if (skb->len < headers + 5) 368 return 'N'; 369 else 370 l2m_debug(&st->l2.l2m, "FRMR information %2x %2x %2x %2x %2x", 371 datap[0], datap[1], datap[2], 372 datap[3], datap[4]); 373 } else { 374 if (skb->len < headers + 3) 375 return 'N'; 376 else 377 l2m_debug(&st->l2.l2m, "FRMR information %2x %2x %2x", 378 datap[0], datap[1], datap[2]); 379 } 380 381 return 0; 382} 383 384static unsigned int 385legalnr(struct PStack *st, unsigned int nr) 386{ 387 struct Layer2 *l2 = &st->l2; 388 389 if(test_bit(FLG_MOD128, &l2->flag)) 390 return ((nr - l2->va) % 128) <= ((l2->vs - l2->va) % 128); 391 else 392 return ((nr - l2->va) % 8) <= ((l2->vs - l2->va) % 8); 393} 394 395static void 396setva(struct PStack *st, unsigned int nr) 397{ 398 struct Layer2 *l2 = &st->l2; 399 int len; 400 u_long flags; 401 402 spin_lock_irqsave(&l2->lock, flags); 403 while (l2->va != nr) { 404 (l2->va)++; 405 if(test_bit(FLG_MOD128, &l2->flag)) 406 l2->va %= 128; 407 else 408 l2->va %= 8; 409 len = l2->windowar[l2->sow]->len; 410 if (PACKET_NOACK == l2->windowar[l2->sow]->pkt_type) 411 len = -1; 412 dev_kfree_skb(l2->windowar[l2->sow]); 413 l2->windowar[l2->sow] = NULL; 414 l2->sow = (l2->sow + 1) % l2->window; 415 spin_unlock_irqrestore(&l2->lock, flags); 416 if (test_bit(FLG_LLI_L2WAKEUP, &st->lli.flag) && (len >=0)) 417 lli_writewakeup(st, len); 418 spin_lock_irqsave(&l2->lock, flags); 419 } 420 spin_unlock_irqrestore(&l2->lock, flags); 421} 422 423static void 424send_uframe(struct PStack *st, u_char cmd, u_char cr) 425{ 426 struct sk_buff *skb; 427 u_char tmp[MAX_HEADER_LEN]; 428 int i; 429 430 i = sethdraddr(&st->l2, tmp, cr); 431 tmp[i++] = cmd; 432 if (!(skb = alloc_skb(i, GFP_ATOMIC))) { 433 printk(KERN_WARNING "isdl2 can't alloc sbbuff for send_uframe\n"); 434 return; 435 } 436 memcpy(skb_put(skb, i), tmp, i); 437 enqueue_super(st, skb); 438} 439 440static inline u_char 441get_PollFlag(struct PStack * st, struct sk_buff * skb) 442{ 443 return (skb->data[l2addrsize(&(st->l2))] & 0x10); 444} 445 446static inline u_char 447get_PollFlagFree(struct PStack *st, struct sk_buff *skb) 448{ 449 u_char PF; 450 451 PF = get_PollFlag(st, skb); 452 dev_kfree_skb(skb); 453 return (PF); 454} 455 456static inline void 457start_t200(struct PStack *st, int i) 458{ 459 FsmAddTimer(&st->l2.t200, st->l2.T200, EV_L2_T200, NULL, i); 460 test_and_set_bit(FLG_T200_RUN, &st->l2.flag); 461} 462 463static inline void 464restart_t200(struct PStack *st, int i) 465{ 466 FsmRestartTimer(&st->l2.t200, st->l2.T200, EV_L2_T200, NULL, i); 467 test_and_set_bit(FLG_T200_RUN, &st->l2.flag); 468} 469 470static inline void 471stop_t200(struct PStack *st, int i) 472{ 473 if(test_and_clear_bit(FLG_T200_RUN, &st->l2.flag)) 474 FsmDelTimer(&st->l2.t200, i); 475} 476 477static inline void 478st5_dl_release_l2l3(struct PStack *st) 479{ 480 int pr; 481 482 if(test_and_clear_bit(FLG_PEND_REL, &st->l2.flag)) 483 pr = DL_RELEASE | CONFIRM; 484 else 485 pr = DL_RELEASE | INDICATION; 486 487 st->l2.l2l3(st, pr, NULL); 488} 489 490static inline void 491lapb_dl_release_l2l3(struct PStack *st, int f) 492{ 493 if (test_bit(FLG_LAPB, &st->l2.flag)) 494 st->l2.l2l1(st, PH_DEACTIVATE | REQUEST, NULL); 495 st->l2.l2l3(st, DL_RELEASE | f, NULL); 496} 497 498static void 499establishlink(struct FsmInst *fi) 500{ 501 struct PStack *st = fi->userdata; 502 u_char cmd; 503 504 clear_exception(&st->l2); 505 st->l2.rc = 0; 506 cmd = (test_bit(FLG_MOD128, &st->l2.flag) ? SABME : SABM) | 0x10; 507 send_uframe(st, cmd, CMD); 508 FsmDelTimer(&st->l2.t203, 1); 509 restart_t200(st, 1); 510 test_and_clear_bit(FLG_PEND_REL, &st->l2.flag); 511 freewin(st); 512 FsmChangeState(fi, ST_L2_5); 513} 514 515static void 516l2_mdl_error_ua(struct FsmInst *fi, int event, void *arg) 517{ 518 struct sk_buff *skb = arg; 519 struct PStack *st = fi->userdata; 520 521 if (get_PollFlagFree(st, skb)) 522 st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'C'); 523 else 524 st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'D'); 525} 526 527static void 528l2_mdl_error_dm(struct FsmInst *fi, int event, void *arg) 529{ 530 struct sk_buff *skb = arg; 531 struct PStack *st = fi->userdata; 532 533 if (get_PollFlagFree(st, skb)) 534 st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'B'); 535 else { 536 st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'E'); 537 establishlink(fi); 538 test_and_clear_bit(FLG_L3_INIT, &st->l2.flag); 539 } 540} 541 542static void 543l2_st8_mdl_error_dm(struct FsmInst *fi, int event, void *arg) 544{ 545 struct sk_buff *skb = arg; 546 struct PStack *st = fi->userdata; 547 548 if (get_PollFlagFree(st, skb)) 549 st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'B'); 550 else { 551 st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'E'); 552 } 553 establishlink(fi); 554 test_and_clear_bit(FLG_L3_INIT, &st->l2.flag); 555} 556 557static void 558l2_go_st3(struct FsmInst *fi, int event, void *arg) 559{ 560 FsmChangeState(fi, ST_L2_3); 561} 562 563static void 564l2_mdl_assign(struct FsmInst *fi, int event, void *arg) 565{ 566 struct PStack *st = fi->userdata; 567 568 FsmChangeState(fi, ST_L2_3); 569 st->l2.l2tei(st, MDL_ASSIGN | INDICATION, NULL); 570} 571 572static void 573l2_queue_ui_assign(struct FsmInst *fi, int event, void *arg) 574{ 575 struct PStack *st = fi->userdata; 576 struct sk_buff *skb = arg; 577 578 skb_queue_tail(&st->l2.ui_queue, skb); 579 FsmChangeState(fi, ST_L2_2); 580 st->l2.l2tei(st, MDL_ASSIGN | INDICATION, NULL); 581} 582 583static void 584l2_queue_ui(struct FsmInst *fi, int event, void *arg) 585{ 586 struct PStack *st = fi->userdata; 587 struct sk_buff *skb = arg; 588 589 skb_queue_tail(&st->l2.ui_queue, skb); 590} 591 592static void 593tx_ui(struct PStack *st) 594{ 595 struct sk_buff *skb; 596 u_char header[MAX_HEADER_LEN]; 597 int i; 598 599 i = sethdraddr(&(st->l2), header, CMD); 600 header[i++] = UI; 601 while ((skb = skb_dequeue(&st->l2.ui_queue))) { 602 memcpy(skb_push(skb, i), header, i); 603 enqueue_ui(st, skb); 604 } 605} 606 607static void 608l2_send_ui(struct FsmInst *fi, int event, void *arg) 609{ 610 struct PStack *st = fi->userdata; 611 struct sk_buff *skb = arg; 612 613 skb_queue_tail(&st->l2.ui_queue, skb); 614 tx_ui(st); 615} 616 617static void 618l2_got_ui(struct FsmInst *fi, int event, void *arg) 619{ 620 struct PStack *st = fi->userdata; 621 struct sk_buff *skb = arg; 622 623 skb_pull(skb, l2headersize(&st->l2, 1)); 624 st->l2.l2l3(st, DL_UNIT_DATA | INDICATION, skb); 625/* ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 626 * in states 1-3 for broadcast 627 */ 628 629 630} 631 632static void 633l2_establish(struct FsmInst *fi, int event, void *arg) 634{ 635 struct PStack *st = fi->userdata; 636 637 establishlink(fi); 638 test_and_set_bit(FLG_L3_INIT, &st->l2.flag); 639} 640 641static void 642l2_discard_i_setl3(struct FsmInst *fi, int event, void *arg) 643{ 644 struct PStack *st = fi->userdata; 645 646 skb_queue_purge(&st->l2.i_queue); 647 test_and_set_bit(FLG_L3_INIT, &st->l2.flag); 648 test_and_clear_bit(FLG_PEND_REL, &st->l2.flag); 649} 650 651static void 652l2_l3_reestablish(struct FsmInst *fi, int event, void *arg) 653{ 654 struct PStack *st = fi->userdata; 655 656 skb_queue_purge(&st->l2.i_queue); 657 establishlink(fi); 658 test_and_set_bit(FLG_L3_INIT, &st->l2.flag); 659} 660 661static void 662l2_release(struct FsmInst *fi, int event, void *arg) 663{ 664 struct PStack *st = fi->userdata; 665 666 st->l2.l2l3(st, DL_RELEASE | CONFIRM, NULL); 667} 668 669static void 670l2_pend_rel(struct FsmInst *fi, int event, void *arg) 671{ 672 struct PStack *st = fi->userdata; 673 674 test_and_set_bit(FLG_PEND_REL, &st->l2.flag); 675} 676 677static void 678l2_disconnect(struct FsmInst *fi, int event, void *arg) 679{ 680 struct PStack *st = fi->userdata; 681 682 skb_queue_purge(&st->l2.i_queue); 683 freewin(st); 684 FsmChangeState(fi, ST_L2_6); 685 st->l2.rc = 0; 686 send_uframe(st, DISC | 0x10, CMD); 687 FsmDelTimer(&st->l2.t203, 1); 688 restart_t200(st, 2); 689} 690 691static void 692l2_start_multi(struct FsmInst *fi, int event, void *arg) 693{ 694 struct PStack *st = fi->userdata; 695 struct sk_buff *skb = arg; 696 697 send_uframe(st, UA | get_PollFlagFree(st, skb), RSP); 698 699 clear_exception(&st->l2); 700 st->l2.vs = 0; 701 st->l2.va = 0; 702 st->l2.vr = 0; 703 st->l2.sow = 0; 704 FsmChangeState(fi, ST_L2_7); 705 FsmAddTimer(&st->l2.t203, st->l2.T203, EV_L2_T203, NULL, 3); 706 707 st->l2.l2l3(st, DL_ESTABLISH | INDICATION, NULL); 708} 709 710static void 711l2_send_UA(struct FsmInst *fi, int event, void *arg) 712{ 713 struct PStack *st = fi->userdata; 714 struct sk_buff *skb = arg; 715 716 send_uframe(st, UA | get_PollFlagFree(st, skb), RSP); 717} 718 719static void 720l2_send_DM(struct FsmInst *fi, int event, void *arg) 721{ 722 struct PStack *st = fi->userdata; 723 struct sk_buff *skb = arg; 724 725 send_uframe(st, DM | get_PollFlagFree(st, skb), RSP); 726} 727 728static void 729l2_restart_multi(struct FsmInst *fi, int event, void *arg) 730{ 731 struct PStack *st = fi->userdata; 732 struct sk_buff *skb = arg; 733 int est = 0, state; 734 735 state = fi->state; 736 737 send_uframe(st, UA | get_PollFlagFree(st, skb), RSP); 738 739 st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'F'); 740 741 if (st->l2.vs != st->l2.va) { 742 skb_queue_purge(&st->l2.i_queue); 743 est = 1; 744 } 745 746 clear_exception(&st->l2); 747 st->l2.vs = 0; 748 st->l2.va = 0; 749 st->l2.vr = 0; 750 st->l2.sow = 0; 751 FsmChangeState(fi, ST_L2_7); 752 stop_t200(st, 3); 753 FsmRestartTimer(&st->l2.t203, st->l2.T203, EV_L2_T203, NULL, 3); 754 755 if (est) 756 st->l2.l2l3(st, DL_ESTABLISH | INDICATION, NULL); 757 758 if ((ST_L2_7==state) || (ST_L2_8 == state)) 759 if (!skb_queue_empty(&st->l2.i_queue) && cansend(st)) 760 st->l2.l2l1(st, PH_PULL | REQUEST, NULL); 761} 762 763static void 764l2_stop_multi(struct FsmInst *fi, int event, void *arg) 765{ 766 struct PStack *st = fi->userdata; 767 struct sk_buff *skb = arg; 768 769 FsmChangeState(fi, ST_L2_4); 770 FsmDelTimer(&st->l2.t203, 3); 771 stop_t200(st, 4); 772 773 send_uframe(st, UA | get_PollFlagFree(st, skb), RSP); 774 775 skb_queue_purge(&st->l2.i_queue); 776 freewin(st); 777 lapb_dl_release_l2l3(st, INDICATION); 778} 779 780static void 781l2_connected(struct FsmInst *fi, int event, void *arg) 782{ 783 struct PStack *st = fi->userdata; 784 struct sk_buff *skb = arg; 785 int pr=-1; 786 787 if (!get_PollFlag(st, skb)) { 788 l2_mdl_error_ua(fi, event, arg); 789 return; 790 } 791 dev_kfree_skb(skb); 792 793 if (test_and_clear_bit(FLG_PEND_REL, &st->l2.flag)) 794 l2_disconnect(fi, event, arg); 795 796 if (test_and_clear_bit(FLG_L3_INIT, &st->l2.flag)) { 797 pr = DL_ESTABLISH | CONFIRM; 798 } else if (st->l2.vs != st->l2.va) { 799 skb_queue_purge(&st->l2.i_queue); 800 pr = DL_ESTABLISH | INDICATION; 801 } 802 803 stop_t200(st, 5); 804 805 st->l2.vr = 0; 806 st->l2.vs = 0; 807 st->l2.va = 0; 808 st->l2.sow = 0; 809 FsmChangeState(fi, ST_L2_7); 810 FsmAddTimer(&st->l2.t203, st->l2.T203, EV_L2_T203, NULL, 4); 811 812 if (pr != -1) 813 st->l2.l2l3(st, pr, NULL); 814 815 if (!skb_queue_empty(&st->l2.i_queue) && cansend(st)) 816 st->l2.l2l1(st, PH_PULL | REQUEST, NULL); 817} 818 819static void 820l2_released(struct FsmInst *fi, int event, void *arg) 821{ 822 struct PStack *st = fi->userdata; 823 struct sk_buff *skb = arg; 824 825 if (!get_PollFlag(st, skb)) { 826 l2_mdl_error_ua(fi, event, arg); 827 return; 828 } 829 dev_kfree_skb(skb); 830 831 stop_t200(st, 6); 832 lapb_dl_release_l2l3(st, CONFIRM); 833 FsmChangeState(fi, ST_L2_4); 834} 835 836static void 837l2_reestablish(struct FsmInst *fi, int event, void *arg) 838{ 839 struct PStack *st = fi->userdata; 840 struct sk_buff *skb = arg; 841 842 if (!get_PollFlagFree(st, skb)) { 843 establishlink(fi); 844 test_and_set_bit(FLG_L3_INIT, &st->l2.flag); 845 } 846} 847 848static void 849l2_st5_dm_release(struct FsmInst *fi, int event, void *arg) 850{ 851 struct PStack *st = fi->userdata; 852 struct sk_buff *skb = arg; 853 854 if (get_PollFlagFree(st, skb)) { 855 stop_t200(st, 7); 856 if (!test_bit(FLG_L3_INIT, &st->l2.flag)) 857 skb_queue_purge(&st->l2.i_queue); 858 if (test_bit(FLG_LAPB, &st->l2.flag)) 859 st->l2.l2l1(st, PH_DEACTIVATE | REQUEST, NULL); 860 st5_dl_release_l2l3(st); 861 FsmChangeState(fi, ST_L2_4); 862 } 863} 864 865static void 866l2_st6_dm_release(struct FsmInst *fi, int event, void *arg) 867{ 868 struct PStack *st = fi->userdata; 869 struct sk_buff *skb = arg; 870 871 if (get_PollFlagFree(st, skb)) { 872 stop_t200(st, 8); 873 lapb_dl_release_l2l3(st, CONFIRM); 874 FsmChangeState(fi, ST_L2_4); 875 } 876} 877 878static inline void 879enquiry_cr(struct PStack *st, u_char typ, u_char cr, u_char pf) 880{ 881 struct sk_buff *skb; 882 struct Layer2 *l2; 883 u_char tmp[MAX_HEADER_LEN]; 884 int i; 885 886 l2 = &st->l2; 887 i = sethdraddr(l2, tmp, cr); 888 if (test_bit(FLG_MOD128, &l2->flag)) { 889 tmp[i++] = typ; 890 tmp[i++] = (l2->vr << 1) | (pf ? 1 : 0); 891 } else 892 tmp[i++] = (l2->vr << 5) | typ | (pf ? 0x10 : 0); 893 if (!(skb = alloc_skb(i, GFP_ATOMIC))) { 894 printk(KERN_WARNING "isdl2 can't alloc sbbuff for enquiry_cr\n"); 895 return; 896 } 897 memcpy(skb_put(skb, i), tmp, i); 898 enqueue_super(st, skb); 899} 900 901static inline void 902enquiry_response(struct PStack *st) 903{ 904 if (test_bit(FLG_OWN_BUSY, &st->l2.flag)) 905 enquiry_cr(st, RNR, RSP, 1); 906 else 907 enquiry_cr(st, RR, RSP, 1); 908 test_and_clear_bit(FLG_ACK_PEND, &st->l2.flag); 909} 910 911static inline void 912transmit_enquiry(struct PStack *st) 913{ 914 if (test_bit(FLG_OWN_BUSY, &st->l2.flag)) 915 enquiry_cr(st, RNR, CMD, 1); 916 else 917 enquiry_cr(st, RR, CMD, 1); 918 test_and_clear_bit(FLG_ACK_PEND, &st->l2.flag); 919 start_t200(st, 9); 920} 921 922 923static void 924nrerrorrecovery(struct FsmInst *fi) 925{ 926 struct PStack *st = fi->userdata; 927 928 st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'J'); 929 establishlink(fi); 930 test_and_clear_bit(FLG_L3_INIT, &st->l2.flag); 931} 932 933static void 934invoke_retransmission(struct PStack *st, unsigned int nr) 935{ 936 struct Layer2 *l2 = &st->l2; 937 u_int p1; 938 u_long flags; 939 940 spin_lock_irqsave(&l2->lock, flags); 941 if (l2->vs != nr) { 942 while (l2->vs != nr) { 943 (l2->vs)--; 944 if(test_bit(FLG_MOD128, &l2->flag)) { 945 l2->vs %= 128; 946 p1 = (l2->vs - l2->va) % 128; 947 } else { 948 l2->vs %= 8; 949 p1 = (l2->vs - l2->va) % 8; 950 } 951 p1 = (p1 + l2->sow) % l2->window; 952 if (test_bit(FLG_LAPB, &l2->flag)) 953 st->l1.bcs->tx_cnt += l2->windowar[p1]->len + l2headersize(l2, 0); 954 skb_queue_head(&l2->i_queue, l2->windowar[p1]); 955 l2->windowar[p1] = NULL; 956 } 957 spin_unlock_irqrestore(&l2->lock, flags); 958 st->l2.l2l1(st, PH_PULL | REQUEST, NULL); 959 return; 960 } 961 spin_unlock_irqrestore(&l2->lock, flags); 962} 963 964static void 965l2_st7_got_super(struct FsmInst *fi, int event, void *arg) 966{ 967 struct PStack *st = fi->userdata; 968 struct sk_buff *skb = arg; 969 int PollFlag, rsp, typ = RR; 970 unsigned int nr; 971 struct Layer2 *l2 = &st->l2; 972 973 rsp = *skb->data & 0x2; 974 if (test_bit(FLG_ORIG, &l2->flag)) 975 rsp = !rsp; 976 977 skb_pull(skb, l2addrsize(l2)); 978 if (IsRNR(skb->data, st)) { 979 set_peer_busy(l2); 980 typ = RNR; 981 } else 982 clear_peer_busy(l2); 983 if (IsREJ(skb->data, st)) 984 typ = REJ; 985 986 if (test_bit(FLG_MOD128, &l2->flag)) { 987 PollFlag = (skb->data[1] & 0x1) == 0x1; 988 nr = skb->data[1] >> 1; 989 } else { 990 PollFlag = (skb->data[0] & 0x10); 991 nr = (skb->data[0] >> 5) & 0x7; 992 } 993 dev_kfree_skb(skb); 994 995 if (PollFlag) { 996 if (rsp) 997 st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'A'); 998 else 999 enquiry_response(st); 1000 } 1001 if (legalnr(st, nr)) { 1002 if (typ == REJ) { 1003 setva(st, nr); 1004 invoke_retransmission(st, nr); 1005 stop_t200(st, 10); 1006 if (FsmAddTimer(&st->l2.t203, st->l2.T203, 1007 EV_L2_T203, NULL, 6)) 1008 l2m_debug(&st->l2.l2m, "Restart T203 ST7 REJ"); 1009 } else if ((nr == l2->vs) && (typ == RR)) { 1010 setva(st, nr); 1011 stop_t200(st, 11); 1012 FsmRestartTimer(&st->l2.t203, st->l2.T203, 1013 EV_L2_T203, NULL, 7); 1014 } else if ((l2->va != nr) || (typ == RNR)) { 1015 setva(st, nr); 1016 if(typ != RR) FsmDelTimer(&st->l2.t203, 9); 1017 restart_t200(st, 12); 1018 } 1019 if (!skb_queue_empty(&st->l2.i_queue) && (typ == RR)) 1020 st->l2.l2l1(st, PH_PULL | REQUEST, NULL); 1021 } else 1022 nrerrorrecovery(fi); 1023} 1024 1025static void 1026l2_feed_i_if_reest(struct FsmInst *fi, int event, void *arg) 1027{ 1028 struct PStack *st = fi->userdata; 1029 struct sk_buff *skb = arg; 1030 1031 if (test_bit(FLG_LAPB, &st->l2.flag)) 1032 st->l1.bcs->tx_cnt += skb->len + l2headersize(&st->l2, 0); 1033 if (!test_bit(FLG_L3_INIT, &st->l2.flag)) 1034 skb_queue_tail(&st->l2.i_queue, skb); 1035 else 1036 dev_kfree_skb(skb); 1037} 1038 1039static void 1040l2_feed_i_pull(struct FsmInst *fi, int event, void *arg) 1041{ 1042 struct PStack *st = fi->userdata; 1043 struct sk_buff *skb = arg; 1044 1045 if (test_bit(FLG_LAPB, &st->l2.flag)) 1046 st->l1.bcs->tx_cnt += skb->len + l2headersize(&st->l2, 0); 1047 skb_queue_tail(&st->l2.i_queue, skb); 1048 st->l2.l2l1(st, PH_PULL | REQUEST, NULL); 1049} 1050 1051static void 1052l2_feed_iqueue(struct FsmInst *fi, int event, void *arg) 1053{ 1054 struct PStack *st = fi->userdata; 1055 struct sk_buff *skb = arg; 1056 1057 if (test_bit(FLG_LAPB, &st->l2.flag)) 1058 st->l1.bcs->tx_cnt += skb->len + l2headersize(&st->l2, 0); 1059 skb_queue_tail(&st->l2.i_queue, skb); 1060} 1061 1062static void 1063l2_got_iframe(struct FsmInst *fi, int event, void *arg) 1064{ 1065 struct PStack *st = fi->userdata; 1066 struct sk_buff *skb = arg; 1067 struct Layer2 *l2 = &(st->l2); 1068 int PollFlag, ns, i; 1069 unsigned int nr; 1070 1071 i = l2addrsize(l2); 1072 if (test_bit(FLG_MOD128, &l2->flag)) { 1073 PollFlag = ((skb->data[i + 1] & 0x1) == 0x1); 1074 ns = skb->data[i] >> 1; 1075 nr = (skb->data[i + 1] >> 1) & 0x7f; 1076 } else { 1077 PollFlag = (skb->data[i] & 0x10); 1078 ns = (skb->data[i] >> 1) & 0x7; 1079 nr = (skb->data[i] >> 5) & 0x7; 1080 } 1081 if (test_bit(FLG_OWN_BUSY, &l2->flag)) { 1082 dev_kfree_skb(skb); 1083 if(PollFlag) enquiry_response(st); 1084 } else if (l2->vr == ns) { 1085 (l2->vr)++; 1086 if(test_bit(FLG_MOD128, &l2->flag)) 1087 l2->vr %= 128; 1088 else 1089 l2->vr %= 8; 1090 test_and_clear_bit(FLG_REJEXC, &l2->flag); 1091 1092 if (PollFlag) 1093 enquiry_response(st); 1094 else 1095 test_and_set_bit(FLG_ACK_PEND, &l2->flag); 1096 skb_pull(skb, l2headersize(l2, 0)); 1097 st->l2.l2l3(st, DL_DATA | INDICATION, skb); 1098 } else { 1099 /* n(s)!=v(r) */ 1100 dev_kfree_skb(skb); 1101 if (test_and_set_bit(FLG_REJEXC, &l2->flag)) { 1102 if (PollFlag) 1103 enquiry_response(st); 1104 } else { 1105 enquiry_cr(st, REJ, RSP, PollFlag); 1106 test_and_clear_bit(FLG_ACK_PEND, &l2->flag); 1107 } 1108 } 1109 1110 if (legalnr(st, nr)) { 1111 if (!test_bit(FLG_PEER_BUSY, &st->l2.flag) && (fi->state == ST_L2_7)) { 1112 if (nr == st->l2.vs) { 1113 stop_t200(st, 13); 1114 FsmRestartTimer(&st->l2.t203, st->l2.T203, 1115 EV_L2_T203, NULL, 7); 1116 } else if (nr != st->l2.va) 1117 restart_t200(st, 14); 1118 } 1119 setva(st, nr); 1120 } else { 1121 nrerrorrecovery(fi); 1122 return; 1123 } 1124 1125 if (!skb_queue_empty(&st->l2.i_queue) && (fi->state == ST_L2_7)) 1126 st->l2.l2l1(st, PH_PULL | REQUEST, NULL); 1127 if (test_and_clear_bit(FLG_ACK_PEND, &st->l2.flag)) 1128 enquiry_cr(st, RR, RSP, 0); 1129} 1130 1131static void 1132l2_got_tei(struct FsmInst *fi, int event, void *arg) 1133{ 1134 struct PStack *st = fi->userdata; 1135 1136 st->l2.tei = (long) arg; 1137 1138 if (fi->state == ST_L2_3) { 1139 establishlink(fi); 1140 test_and_set_bit(FLG_L3_INIT, &st->l2.flag); 1141 } else 1142 FsmChangeState(fi, ST_L2_4); 1143 if (!skb_queue_empty(&st->l2.ui_queue)) 1144 tx_ui(st); 1145} 1146 1147static void 1148l2_st5_tout_200(struct FsmInst *fi, int event, void *arg) 1149{ 1150 struct PStack *st = fi->userdata; 1151 1152 if (test_bit(FLG_LAPD, &st->l2.flag) && 1153 test_bit(FLG_DCHAN_BUSY, &st->l2.flag)) { 1154 FsmAddTimer(&st->l2.t200, st->l2.T200, EV_L2_T200, NULL, 9); 1155 } else if (st->l2.rc == st->l2.N200) { 1156 FsmChangeState(fi, ST_L2_4); 1157 test_and_clear_bit(FLG_T200_RUN, &st->l2.flag); 1158 skb_queue_purge(&st->l2.i_queue); 1159 st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'G'); 1160 if (test_bit(FLG_LAPB, &st->l2.flag)) 1161 st->l2.l2l1(st, PH_DEACTIVATE | REQUEST, NULL); 1162 st5_dl_release_l2l3(st); 1163 } else { 1164 st->l2.rc++; 1165 FsmAddTimer(&st->l2.t200, st->l2.T200, EV_L2_T200, NULL, 9); 1166 send_uframe(st, (test_bit(FLG_MOD128, &st->l2.flag) ? SABME : SABM) 1167 | 0x10, CMD); 1168 } 1169} 1170 1171static void 1172l2_st6_tout_200(struct FsmInst *fi, int event, void *arg) 1173{ 1174 struct PStack *st = fi->userdata; 1175 1176 if (test_bit(FLG_LAPD, &st->l2.flag) && 1177 test_bit(FLG_DCHAN_BUSY, &st->l2.flag)) { 1178 FsmAddTimer(&st->l2.t200, st->l2.T200, EV_L2_T200, NULL, 9); 1179 } else if (st->l2.rc == st->l2.N200) { 1180 FsmChangeState(fi, ST_L2_4); 1181 test_and_clear_bit(FLG_T200_RUN, &st->l2.flag); 1182 st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'H'); 1183 lapb_dl_release_l2l3(st, CONFIRM); 1184 } else { 1185 st->l2.rc++; 1186 FsmAddTimer(&st->l2.t200, st->l2.T200, EV_L2_T200, 1187 NULL, 9); 1188 send_uframe(st, DISC | 0x10, CMD); 1189 } 1190} 1191 1192static void 1193l2_st7_tout_200(struct FsmInst *fi, int event, void *arg) 1194{ 1195 struct PStack *st = fi->userdata; 1196 1197 if (test_bit(FLG_LAPD, &st->l2.flag) && 1198 test_bit(FLG_DCHAN_BUSY, &st->l2.flag)) { 1199 FsmAddTimer(&st->l2.t200, st->l2.T200, EV_L2_T200, NULL, 9); 1200 return; 1201 } 1202 test_and_clear_bit(FLG_T200_RUN, &st->l2.flag); 1203 st->l2.rc = 0; 1204 FsmChangeState(fi, ST_L2_8); 1205 1206 transmit_enquiry(st); 1207 st->l2.rc++; 1208} 1209 1210static void 1211l2_st8_tout_200(struct FsmInst *fi, int event, void *arg) 1212{ 1213 struct PStack *st = fi->userdata; 1214 1215 if (test_bit(FLG_LAPD, &st->l2.flag) && 1216 test_bit(FLG_DCHAN_BUSY, &st->l2.flag)) { 1217 FsmAddTimer(&st->l2.t200, st->l2.T200, EV_L2_T200, NULL, 9); 1218 return; 1219 } 1220 test_and_clear_bit(FLG_T200_RUN, &st->l2.flag); 1221 if (st->l2.rc == st->l2.N200) { 1222 st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'I'); 1223 establishlink(fi); 1224 test_and_clear_bit(FLG_L3_INIT, &st->l2.flag); 1225 } else { 1226 transmit_enquiry(st); 1227 st->l2.rc++; 1228 } 1229} 1230 1231static void 1232l2_st7_tout_203(struct FsmInst *fi, int event, void *arg) 1233{ 1234 struct PStack *st = fi->userdata; 1235 1236 if (test_bit(FLG_LAPD, &st->l2.flag) && 1237 test_bit(FLG_DCHAN_BUSY, &st->l2.flag)) { 1238 FsmAddTimer(&st->l2.t203, st->l2.T203, EV_L2_T203, NULL, 9); 1239 return; 1240 } 1241 FsmChangeState(fi, ST_L2_8); 1242 transmit_enquiry(st); 1243 st->l2.rc = 0; 1244} 1245 1246static void 1247l2_pull_iqueue(struct FsmInst *fi, int event, void *arg) 1248{ 1249 struct PStack *st = fi->userdata; 1250 struct sk_buff *skb, *oskb; 1251 struct Layer2 *l2 = &st->l2; 1252 u_char header[MAX_HEADER_LEN]; 1253 int i; 1254 int unsigned p1; 1255 u_long flags; 1256 1257 if (!cansend(st)) 1258 return; 1259 1260 skb = skb_dequeue(&l2->i_queue); 1261 if (!skb) 1262 return; 1263 1264 spin_lock_irqsave(&l2->lock, flags); 1265 if(test_bit(FLG_MOD128, &l2->flag)) 1266 p1 = (l2->vs - l2->va) % 128; 1267 else 1268 p1 = (l2->vs - l2->va) % 8; 1269 p1 = (p1 + l2->sow) % l2->window; 1270 if (l2->windowar[p1]) { 1271 printk(KERN_WARNING "isdnl2 try overwrite ack queue entry %d\n", 1272 p1); 1273 dev_kfree_skb(l2->windowar[p1]); 1274 } 1275 l2->windowar[p1] = skb_clone(skb, GFP_ATOMIC); 1276 1277 i = sethdraddr(&st->l2, header, CMD); 1278 1279 if (test_bit(FLG_MOD128, &l2->flag)) { 1280 header[i++] = l2->vs << 1; 1281 header[i++] = l2->vr << 1; 1282 l2->vs = (l2->vs + 1) % 128; 1283 } else { 1284 header[i++] = (l2->vr << 5) | (l2->vs << 1); 1285 l2->vs = (l2->vs + 1) % 8; 1286 } 1287 spin_unlock_irqrestore(&l2->lock, flags); 1288 p1 = skb->data - skb->head; 1289 if (p1 >= i) 1290 memcpy(skb_push(skb, i), header, i); 1291 else { 1292 printk(KERN_WARNING 1293 "isdl2 pull_iqueue skb header(%d/%d) too short\n", i, p1); 1294 oskb = skb; 1295 skb = alloc_skb(oskb->len + i, GFP_ATOMIC); 1296 memcpy(skb_put(skb, i), header, i); 1297 skb_copy_from_linear_data(oskb, 1298 skb_put(skb, oskb->len), oskb->len); 1299 dev_kfree_skb(oskb); 1300 } 1301 st->l2.l2l1(st, PH_PULL | INDICATION, skb); 1302 test_and_clear_bit(FLG_ACK_PEND, &st->l2.flag); 1303 if (!test_and_set_bit(FLG_T200_RUN, &st->l2.flag)) { 1304 FsmDelTimer(&st->l2.t203, 13); 1305 FsmAddTimer(&st->l2.t200, st->l2.T200, EV_L2_T200, NULL, 11); 1306 } 1307 if (!skb_queue_empty(&l2->i_queue) && cansend(st)) 1308 st->l2.l2l1(st, PH_PULL | REQUEST, NULL); 1309} 1310 1311static void 1312l2_st8_got_super(struct FsmInst *fi, int event, void *arg) 1313{ 1314 struct PStack *st = fi->userdata; 1315 struct sk_buff *skb = arg; 1316 int PollFlag, rsp, rnr = 0; 1317 unsigned int nr; 1318 struct Layer2 *l2 = &st->l2; 1319 1320 rsp = *skb->data & 0x2; 1321 if (test_bit(FLG_ORIG, &l2->flag)) 1322 rsp = !rsp; 1323 1324 skb_pull(skb, l2addrsize(l2)); 1325 1326 if (IsRNR(skb->data, st)) { 1327 set_peer_busy(l2); 1328 rnr = 1; 1329 } else 1330 clear_peer_busy(l2); 1331 1332 if (test_bit(FLG_MOD128, &l2->flag)) { 1333 PollFlag = (skb->data[1] & 0x1) == 0x1; 1334 nr = skb->data[1] >> 1; 1335 } else { 1336 PollFlag = (skb->data[0] & 0x10); 1337 nr = (skb->data[0] >> 5) & 0x7; 1338 } 1339 dev_kfree_skb(skb); 1340 1341 if (rsp && PollFlag) { 1342 if (legalnr(st, nr)) { 1343 if (rnr) { 1344 restart_t200(st, 15); 1345 } else { 1346 stop_t200(st, 16); 1347 FsmAddTimer(&l2->t203, l2->T203, 1348 EV_L2_T203, NULL, 5); 1349 setva(st, nr); 1350 } 1351 invoke_retransmission(st, nr); 1352 FsmChangeState(fi, ST_L2_7); 1353 if (!skb_queue_empty(&l2->i_queue) && cansend(st)) 1354 st->l2.l2l1(st, PH_PULL | REQUEST, NULL); 1355 } else 1356 nrerrorrecovery(fi); 1357 } else { 1358 if (!rsp && PollFlag) 1359 enquiry_response(st); 1360 if (legalnr(st, nr)) { 1361 setva(st, nr); 1362 } else 1363 nrerrorrecovery(fi); 1364 } 1365} 1366 1367static void 1368l2_got_FRMR(struct FsmInst *fi, int event, void *arg) 1369{ 1370 struct PStack *st = fi->userdata; 1371 struct sk_buff *skb = arg; 1372 1373 skb_pull(skb, l2addrsize(&st->l2) + 1); 1374 1375 if (!(skb->data[0] & 1) || ((skb->data[0] & 3) == 1) || /* I or S */ 1376 (IsUA(skb->data) && (fi->state == ST_L2_7))) { 1377 st->ma.layer(st, MDL_ERROR | INDICATION, (void *) 'K'); 1378 establishlink(fi); 1379 test_and_clear_bit(FLG_L3_INIT, &st->l2.flag); 1380 } 1381 dev_kfree_skb(skb); 1382} 1383 1384static void 1385l2_st24_tei_remove(struct FsmInst *fi, int event, void *arg) 1386{ 1387 struct PStack *st = fi->userdata; 1388 1389 skb_queue_purge(&st->l2.ui_queue); 1390 st->l2.tei = -1; 1391 FsmChangeState(fi, ST_L2_1); 1392} 1393 1394static void 1395l2_st3_tei_remove(struct FsmInst *fi, int event, void *arg) 1396{ 1397 struct PStack *st = fi->userdata; 1398 1399 skb_queue_purge(&st->l2.ui_queue); 1400 st->l2.tei = -1; 1401 st->l2.l2l3(st, DL_RELEASE | INDICATION, NULL); 1402 FsmChangeState(fi, ST_L2_1); 1403} 1404 1405static void 1406l2_st5_tei_remove(struct FsmInst *fi, int event, void *arg) 1407{ 1408 struct PStack *st = fi->userdata; 1409 1410 skb_queue_purge(&st->l2.i_queue); 1411 skb_queue_purge(&st->l2.ui_queue); 1412 freewin(st); 1413 st->l2.tei = -1; 1414 stop_t200(st, 17); 1415 st5_dl_release_l2l3(st); 1416 FsmChangeState(fi, ST_L2_1); 1417} 1418 1419static void 1420l2_st6_tei_remove(struct FsmInst *fi, int event, void *arg) 1421{ 1422 struct PStack *st = fi->userdata; 1423 1424 skb_queue_purge(&st->l2.ui_queue); 1425 st->l2.tei = -1; 1426 stop_t200(st, 18); 1427 st->l2.l2l3(st, DL_RELEASE | CONFIRM, NULL); 1428 FsmChangeState(fi, ST_L2_1); 1429} 1430 1431static void 1432l2_tei_remove(struct FsmInst *fi, int event, void *arg) 1433{ 1434 struct PStack *st = fi->userdata; 1435 1436 skb_queue_purge(&st->l2.i_queue); 1437 skb_queue_purge(&st->l2.ui_queue); 1438 freewin(st); 1439 st->l2.tei = -1; 1440 stop_t200(st, 17); 1441 FsmDelTimer(&st->l2.t203, 19); 1442 st->l2.l2l3(st, DL_RELEASE | INDICATION, NULL); 1443 FsmChangeState(fi, ST_L2_1); 1444} 1445 1446static void 1447l2_st14_persistent_da(struct FsmInst *fi, int event, void *arg) 1448{ 1449 struct PStack *st = fi->userdata; 1450 1451 skb_queue_purge(&st->l2.i_queue); 1452 skb_queue_purge(&st->l2.ui_queue); 1453 if (test_and_clear_bit(FLG_ESTAB_PEND, &st->l2.flag)) 1454 st->l2.l2l3(st, DL_RELEASE | INDICATION, NULL); 1455} 1456 1457static void 1458l2_st5_persistent_da(struct FsmInst *fi, int event, void *arg) 1459{ 1460 struct PStack *st = fi->userdata; 1461 1462 skb_queue_purge(&st->l2.i_queue); 1463 skb_queue_purge(&st->l2.ui_queue); 1464 freewin(st); 1465 stop_t200(st, 19); 1466 st5_dl_release_l2l3(st); 1467 FsmChangeState(fi, ST_L2_4); 1468} 1469 1470static void 1471l2_st6_persistent_da(struct FsmInst *fi, int event, void *arg) 1472{ 1473 struct PStack *st = fi->userdata; 1474 1475 skb_queue_purge(&st->l2.ui_queue); 1476 stop_t200(st, 20); 1477 st->l2.l2l3(st, DL_RELEASE | CONFIRM, NULL); 1478 FsmChangeState(fi, ST_L2_4); 1479} 1480 1481static void 1482l2_persistent_da(struct FsmInst *fi, int event, void *arg) 1483{ 1484 struct PStack *st = fi->userdata; 1485 1486 skb_queue_purge(&st->l2.i_queue); 1487 skb_queue_purge(&st->l2.ui_queue); 1488 freewin(st); 1489 stop_t200(st, 19); 1490 FsmDelTimer(&st->l2.t203, 19); 1491 st->l2.l2l3(st, DL_RELEASE | INDICATION, NULL); 1492 FsmChangeState(fi, ST_L2_4); 1493} 1494 1495static void 1496l2_set_own_busy(struct FsmInst *fi, int event, void *arg) 1497{ 1498 struct PStack *st = fi->userdata; 1499 1500 if(!test_and_set_bit(FLG_OWN_BUSY, &st->l2.flag)) { 1501 enquiry_cr(st, RNR, RSP, 0); 1502 test_and_clear_bit(FLG_ACK_PEND, &st->l2.flag); 1503 } 1504} 1505 1506static void 1507l2_clear_own_busy(struct FsmInst *fi, int event, void *arg) 1508{ 1509 struct PStack *st = fi->userdata; 1510 1511 if(!test_and_clear_bit(FLG_OWN_BUSY, &st->l2.flag)) { 1512 enquiry_cr(st, RR, RSP, 0); 1513 test_and_clear_bit(FLG_ACK_PEND, &st->l2.flag); 1514 } 1515} 1516 1517static void 1518l2_frame_error(struct FsmInst *fi, int event, void *arg) 1519{ 1520 struct PStack *st = fi->userdata; 1521 1522 st->ma.layer(st, MDL_ERROR | INDICATION, arg); 1523} 1524 1525static void 1526l2_frame_error_reest(struct FsmInst *fi, int event, void *arg) 1527{ 1528 struct PStack *st = fi->userdata; 1529 1530 st->ma.layer(st, MDL_ERROR | INDICATION, arg); 1531 establishlink(fi); 1532 test_and_clear_bit(FLG_L3_INIT, &st->l2.flag); 1533} 1534 1535static struct FsmNode L2FnList[] __initdata = 1536{ 1537 {ST_L2_1, EV_L2_DL_ESTABLISH_REQ, l2_mdl_assign}, 1538 {ST_L2_2, EV_L2_DL_ESTABLISH_REQ, l2_go_st3}, 1539 {ST_L2_4, EV_L2_DL_ESTABLISH_REQ, l2_establish}, 1540 {ST_L2_5, EV_L2_DL_ESTABLISH_REQ, l2_discard_i_setl3}, 1541 {ST_L2_7, EV_L2_DL_ESTABLISH_REQ, l2_l3_reestablish}, 1542 {ST_L2_8, EV_L2_DL_ESTABLISH_REQ, l2_l3_reestablish}, 1543 {ST_L2_4, EV_L2_DL_RELEASE_REQ, l2_release}, 1544 {ST_L2_5, EV_L2_DL_RELEASE_REQ, l2_pend_rel}, 1545 {ST_L2_7, EV_L2_DL_RELEASE_REQ, l2_disconnect}, 1546 {ST_L2_8, EV_L2_DL_RELEASE_REQ, l2_disconnect}, 1547 {ST_L2_5, EV_L2_DL_DATA, l2_feed_i_if_reest}, 1548 {ST_L2_7, EV_L2_DL_DATA, l2_feed_i_pull}, 1549 {ST_L2_8, EV_L2_DL_DATA, l2_feed_iqueue}, 1550 {ST_L2_1, EV_L2_DL_UNIT_DATA, l2_queue_ui_assign}, 1551 {ST_L2_2, EV_L2_DL_UNIT_DATA, l2_queue_ui}, 1552 {ST_L2_3, EV_L2_DL_UNIT_DATA, l2_queue_ui}, 1553 {ST_L2_4, EV_L2_DL_UNIT_DATA, l2_send_ui}, 1554 {ST_L2_5, EV_L2_DL_UNIT_DATA, l2_send_ui}, 1555 {ST_L2_6, EV_L2_DL_UNIT_DATA, l2_send_ui}, 1556 {ST_L2_7, EV_L2_DL_UNIT_DATA, l2_send_ui}, 1557 {ST_L2_8, EV_L2_DL_UNIT_DATA, l2_send_ui}, 1558 {ST_L2_1, EV_L2_MDL_ASSIGN, l2_got_tei}, 1559 {ST_L2_2, EV_L2_MDL_ASSIGN, l2_got_tei}, 1560 {ST_L2_3, EV_L2_MDL_ASSIGN, l2_got_tei}, 1561 {ST_L2_2, EV_L2_MDL_ERROR, l2_st24_tei_remove}, 1562 {ST_L2_3, EV_L2_MDL_ERROR, l2_st3_tei_remove}, 1563 {ST_L2_4, EV_L2_MDL_REMOVE, l2_st24_tei_remove}, 1564 {ST_L2_5, EV_L2_MDL_REMOVE, l2_st5_tei_remove}, 1565 {ST_L2_6, EV_L2_MDL_REMOVE, l2_st6_tei_remove}, 1566 {ST_L2_7, EV_L2_MDL_REMOVE, l2_tei_remove}, 1567 {ST_L2_8, EV_L2_MDL_REMOVE, l2_tei_remove}, 1568 {ST_L2_4, EV_L2_SABME, l2_start_multi}, 1569 {ST_L2_5, EV_L2_SABME, l2_send_UA}, 1570 {ST_L2_6, EV_L2_SABME, l2_send_DM}, 1571 {ST_L2_7, EV_L2_SABME, l2_restart_multi}, 1572 {ST_L2_8, EV_L2_SABME, l2_restart_multi}, 1573 {ST_L2_4, EV_L2_DISC, l2_send_DM}, 1574 {ST_L2_5, EV_L2_DISC, l2_send_DM}, 1575 {ST_L2_6, EV_L2_DISC, l2_send_UA}, 1576 {ST_L2_7, EV_L2_DISC, l2_stop_multi}, 1577 {ST_L2_8, EV_L2_DISC, l2_stop_multi}, 1578 {ST_L2_4, EV_L2_UA, l2_mdl_error_ua}, 1579 {ST_L2_5, EV_L2_UA, l2_connected}, 1580 {ST_L2_6, EV_L2_UA, l2_released}, 1581 {ST_L2_7, EV_L2_UA, l2_mdl_error_ua}, 1582 {ST_L2_8, EV_L2_UA, l2_mdl_error_ua}, 1583 {ST_L2_4, EV_L2_DM, l2_reestablish}, 1584 {ST_L2_5, EV_L2_DM, l2_st5_dm_release}, 1585 {ST_L2_6, EV_L2_DM, l2_st6_dm_release}, 1586 {ST_L2_7, EV_L2_DM, l2_mdl_error_dm}, 1587 {ST_L2_8, EV_L2_DM, l2_st8_mdl_error_dm}, 1588 {ST_L2_1, EV_L2_UI, l2_got_ui}, 1589 {ST_L2_2, EV_L2_UI, l2_got_ui}, 1590 {ST_L2_3, EV_L2_UI, l2_got_ui}, 1591 {ST_L2_4, EV_L2_UI, l2_got_ui}, 1592 {ST_L2_5, EV_L2_UI, l2_got_ui}, 1593 {ST_L2_6, EV_L2_UI, l2_got_ui}, 1594 {ST_L2_7, EV_L2_UI, l2_got_ui}, 1595 {ST_L2_8, EV_L2_UI, l2_got_ui}, 1596 {ST_L2_7, EV_L2_FRMR, l2_got_FRMR}, 1597 {ST_L2_8, EV_L2_FRMR, l2_got_FRMR}, 1598 {ST_L2_7, EV_L2_SUPER, l2_st7_got_super}, 1599 {ST_L2_8, EV_L2_SUPER, l2_st8_got_super}, 1600 {ST_L2_7, EV_L2_I, l2_got_iframe}, 1601 {ST_L2_8, EV_L2_I, l2_got_iframe}, 1602 {ST_L2_5, EV_L2_T200, l2_st5_tout_200}, 1603 {ST_L2_6, EV_L2_T200, l2_st6_tout_200}, 1604 {ST_L2_7, EV_L2_T200, l2_st7_tout_200}, 1605 {ST_L2_8, EV_L2_T200, l2_st8_tout_200}, 1606 {ST_L2_7, EV_L2_T203, l2_st7_tout_203}, 1607 {ST_L2_7, EV_L2_ACK_PULL, l2_pull_iqueue}, 1608 {ST_L2_7, EV_L2_SET_OWN_BUSY, l2_set_own_busy}, 1609 {ST_L2_8, EV_L2_SET_OWN_BUSY, l2_set_own_busy}, 1610 {ST_L2_7, EV_L2_CLEAR_OWN_BUSY, l2_clear_own_busy}, 1611 {ST_L2_8, EV_L2_CLEAR_OWN_BUSY, l2_clear_own_busy}, 1612 {ST_L2_4, EV_L2_FRAME_ERROR, l2_frame_error}, 1613 {ST_L2_5, EV_L2_FRAME_ERROR, l2_frame_error}, 1614 {ST_L2_6, EV_L2_FRAME_ERROR, l2_frame_error}, 1615 {ST_L2_7, EV_L2_FRAME_ERROR, l2_frame_error_reest}, 1616 {ST_L2_8, EV_L2_FRAME_ERROR, l2_frame_error_reest}, 1617 {ST_L2_1, EV_L1_DEACTIVATE, l2_st14_persistent_da}, 1618 {ST_L2_2, EV_L1_DEACTIVATE, l2_st24_tei_remove}, 1619 {ST_L2_3, EV_L1_DEACTIVATE, l2_st3_tei_remove}, 1620 {ST_L2_4, EV_L1_DEACTIVATE, l2_st14_persistent_da}, 1621 {ST_L2_5, EV_L1_DEACTIVATE, l2_st5_persistent_da}, 1622 {ST_L2_6, EV_L1_DEACTIVATE, l2_st6_persistent_da}, 1623 {ST_L2_7, EV_L1_DEACTIVATE, l2_persistent_da}, 1624 {ST_L2_8, EV_L1_DEACTIVATE, l2_persistent_da}, 1625}; 1626 1627static void 1628isdnl2_l1l2(struct PStack *st, int pr, void *arg) 1629{ 1630 struct sk_buff *skb = arg; 1631 u_char *datap; 1632 int ret = 1, len; 1633 int c = 0; 1634 1635 switch (pr) { 1636 case (PH_DATA | INDICATION): 1637 datap = skb->data; 1638 len = l2addrsize(&st->l2); 1639 if (skb->len > len) 1640 datap += len; 1641 else { 1642 FsmEvent(&st->l2.l2m, EV_L2_FRAME_ERROR, (void *) 'N'); 1643 dev_kfree_skb(skb); 1644 return; 1645 } 1646 if (!(*datap & 1)) { /* I-Frame */ 1647 if(!(c = iframe_error(st, skb))) 1648 ret = FsmEvent(&st->l2.l2m, EV_L2_I, skb); 1649 } else if (IsSFrame(datap, st)) { /* S-Frame */ 1650 if(!(c = super_error(st, skb))) 1651 ret = FsmEvent(&st->l2.l2m, EV_L2_SUPER, skb); 1652 } else if (IsUI(datap)) { 1653 if(!(c = UI_error(st, skb))) 1654 ret = FsmEvent(&st->l2.l2m, EV_L2_UI, skb); 1655 } else if (IsSABME(datap, st)) { 1656 if(!(c = unnum_error(st, skb, CMD))) 1657 ret = FsmEvent(&st->l2.l2m, EV_L2_SABME, skb); 1658 } else if (IsUA(datap)) { 1659 if(!(c = unnum_error(st, skb, RSP))) 1660 ret = FsmEvent(&st->l2.l2m, EV_L2_UA, skb); 1661 } else if (IsDISC(datap)) { 1662 if(!(c = unnum_error(st, skb, CMD))) 1663 ret = FsmEvent(&st->l2.l2m, EV_L2_DISC, skb); 1664 } else if (IsDM(datap)) { 1665 if(!(c = unnum_error(st, skb, RSP))) 1666 ret = FsmEvent(&st->l2.l2m, EV_L2_DM, skb); 1667 } else if (IsFRMR(datap)) { 1668 if(!(c = FRMR_error(st,skb))) 1669 ret = FsmEvent(&st->l2.l2m, EV_L2_FRMR, skb); 1670 } else { 1671 FsmEvent(&st->l2.l2m, EV_L2_FRAME_ERROR, (void *) 'L'); 1672 dev_kfree_skb(skb); 1673 ret = 0; 1674 } 1675 if(c) { 1676 dev_kfree_skb(skb); 1677 FsmEvent(&st->l2.l2m, EV_L2_FRAME_ERROR, (void *)(long)c); 1678 ret = 0; 1679 } 1680 if (ret) 1681 dev_kfree_skb(skb); 1682 break; 1683 case (PH_PULL | CONFIRM): 1684 FsmEvent(&st->l2.l2m, EV_L2_ACK_PULL, arg); 1685 break; 1686 case (PH_PAUSE | INDICATION): 1687 test_and_set_bit(FLG_DCHAN_BUSY, &st->l2.flag); 1688 break; 1689 case (PH_PAUSE | CONFIRM): 1690 test_and_clear_bit(FLG_DCHAN_BUSY, &st->l2.flag); 1691 break; 1692 case (PH_ACTIVATE | CONFIRM): 1693 case (PH_ACTIVATE | INDICATION): 1694 test_and_set_bit(FLG_L1_ACTIV, &st->l2.flag); 1695 if (test_and_clear_bit(FLG_ESTAB_PEND, &st->l2.flag)) 1696 FsmEvent(&st->l2.l2m, EV_L2_DL_ESTABLISH_REQ, arg); 1697 break; 1698 case (PH_DEACTIVATE | INDICATION): 1699 case (PH_DEACTIVATE | CONFIRM): 1700 test_and_clear_bit(FLG_L1_ACTIV, &st->l2.flag); 1701 FsmEvent(&st->l2.l2m, EV_L1_DEACTIVATE, arg); 1702 break; 1703 default: 1704 l2m_debug(&st->l2.l2m, "l2 unknown pr %04x", pr); 1705 break; 1706 } 1707} 1708 1709static void 1710isdnl2_l3l2(struct PStack *st, int pr, void *arg) 1711{ 1712 switch (pr) { 1713 case (DL_DATA | REQUEST): 1714 if (FsmEvent(&st->l2.l2m, EV_L2_DL_DATA, arg)) { 1715 dev_kfree_skb((struct sk_buff *) arg); 1716 } 1717 break; 1718 case (DL_UNIT_DATA | REQUEST): 1719 if (FsmEvent(&st->l2.l2m, EV_L2_DL_UNIT_DATA, arg)) { 1720 dev_kfree_skb((struct sk_buff *) arg); 1721 } 1722 break; 1723 case (DL_ESTABLISH | REQUEST): 1724 if (test_bit(FLG_L1_ACTIV, &st->l2.flag)) { 1725 if (test_bit(FLG_LAPD, &st->l2.flag) || 1726 test_bit(FLG_ORIG, &st->l2.flag)) { 1727 FsmEvent(&st->l2.l2m, EV_L2_DL_ESTABLISH_REQ, arg); 1728 } 1729 } else { 1730 if (test_bit(FLG_LAPD, &st->l2.flag) || 1731 test_bit(FLG_ORIG, &st->l2.flag)) { 1732 test_and_set_bit(FLG_ESTAB_PEND, &st->l2.flag); 1733 } 1734 st->l2.l2l1(st, PH_ACTIVATE, NULL); 1735 } 1736 break; 1737 case (DL_RELEASE | REQUEST): 1738 if (test_bit(FLG_LAPB, &st->l2.flag)) { 1739 st->l2.l2l1(st, PH_DEACTIVATE, NULL); 1740 } 1741 FsmEvent(&st->l2.l2m, EV_L2_DL_RELEASE_REQ, arg); 1742 break; 1743 case (MDL_ASSIGN | REQUEST): 1744 FsmEvent(&st->l2.l2m, EV_L2_MDL_ASSIGN, arg); 1745 break; 1746 case (MDL_REMOVE | REQUEST): 1747 FsmEvent(&st->l2.l2m, EV_L2_MDL_REMOVE, arg); 1748 break; 1749 case (MDL_ERROR | RESPONSE): 1750 FsmEvent(&st->l2.l2m, EV_L2_MDL_ERROR, arg); 1751 break; 1752 } 1753} 1754 1755void 1756releasestack_isdnl2(struct PStack *st) 1757{ 1758 FsmDelTimer(&st->l2.t200, 21); 1759 FsmDelTimer(&st->l2.t203, 16); 1760 skb_queue_purge(&st->l2.i_queue); 1761 skb_queue_purge(&st->l2.ui_queue); 1762 ReleaseWin(&st->l2); 1763} 1764 1765static void 1766l2m_debug(struct FsmInst *fi, char *fmt, ...) 1767{ 1768 va_list args; 1769 struct PStack *st = fi->userdata; 1770 1771 va_start(args, fmt); 1772 VHiSax_putstatus(st->l1.hardware, st->l2.debug_id, fmt, args); 1773 va_end(args); 1774} 1775 1776void 1777setstack_isdnl2(struct PStack *st, char *debug_id) 1778{ 1779 spin_lock_init(&st->l2.lock); 1780 st->l1.l1l2 = isdnl2_l1l2; 1781 st->l3.l3l2 = isdnl2_l3l2; 1782 1783 skb_queue_head_init(&st->l2.i_queue); 1784 skb_queue_head_init(&st->l2.ui_queue); 1785 InitWin(&st->l2); 1786 st->l2.debug = 0; 1787 1788 st->l2.l2m.fsm = &l2fsm; 1789 if (test_bit(FLG_LAPB, &st->l2.flag)) 1790 st->l2.l2m.state = ST_L2_4; 1791 else 1792 st->l2.l2m.state = ST_L2_1; 1793 st->l2.l2m.debug = 0; 1794 st->l2.l2m.userdata = st; 1795 st->l2.l2m.userint = 0; 1796 st->l2.l2m.printdebug = l2m_debug; 1797 strcpy(st->l2.debug_id, debug_id); 1798 1799 FsmInitTimer(&st->l2.l2m, &st->l2.t200); 1800 FsmInitTimer(&st->l2.l2m, &st->l2.t203); 1801} 1802 1803static void 1804transl2_l3l2(struct PStack *st, int pr, void *arg) 1805{ 1806 switch (pr) { 1807 case (DL_DATA | REQUEST): 1808 case (DL_UNIT_DATA | REQUEST): 1809 st->l2.l2l1(st, PH_DATA | REQUEST, arg); 1810 break; 1811 case (DL_ESTABLISH | REQUEST): 1812 st->l2.l2l1(st, PH_ACTIVATE | REQUEST, NULL); 1813 break; 1814 case (DL_RELEASE | REQUEST): 1815 st->l2.l2l1(st, PH_DEACTIVATE | REQUEST, NULL); 1816 break; 1817 } 1818} 1819 1820void 1821setstack_transl2(struct PStack *st) 1822{ 1823 st->l3.l3l2 = transl2_l3l2; 1824} 1825 1826void 1827releasestack_transl2(struct PStack *st) 1828{ 1829} 1830 1831int __init 1832Isdnl2New(void) 1833{ 1834 l2fsm.state_count = L2_STATE_COUNT; 1835 l2fsm.event_count = L2_EVENT_COUNT; 1836 l2fsm.strEvent = strL2Event; 1837 l2fsm.strState = strL2State; 1838 return FsmNew(&l2fsm, L2FnList, ARRAY_SIZE(L2FnList)); 1839} 1840 1841void 1842Isdnl2Free(void) 1843{ 1844 FsmFree(&l2fsm); 1845} 1846