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