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