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 #include "layer2.h" 18 #include <linux/random.h> 19 #include "core.h" 20 21 #define ID_REQUEST 1 22 #define ID_ASSIGNED 2 23 #define ID_DENIED 3 24 #define ID_CHK_REQ 4 25 #define ID_CHK_RES 5 26 #define ID_REMOVE 6 27 #define ID_VERIFY 7 28 29 #define TEI_ENTITY_ID 0xf 30 31 #define MGR_PH_ACTIVE 16 32 #define MGR_PH_NOTREADY 17 33 34 #define DATIMER_VAL 10000 35 36 static u_int *debug; 37 38 static struct Fsm deactfsm = {NULL, 0, 0, NULL, NULL}; 39 static struct Fsm teifsmu = {NULL, 0, 0, NULL, NULL}; 40 static struct Fsm teifsmn = {NULL, 0, 0, NULL, NULL}; 41 42 enum { 43 ST_L1_DEACT, 44 ST_L1_DEACT_PENDING, 45 ST_L1_ACTIV, 46 }; 47 #define DEACT_STATE_COUNT (ST_L1_ACTIV+1) 48 49 static char *strDeactState[] = 50 { 51 "ST_L1_DEACT", 52 "ST_L1_DEACT_PENDING", 53 "ST_L1_ACTIV", 54 }; 55 56 enum { 57 EV_ACTIVATE, 58 EV_ACTIVATE_IND, 59 EV_DEACTIVATE, 60 EV_DEACTIVATE_IND, 61 EV_UI, 62 EV_DATIMER, 63 }; 64 65 #define DEACT_EVENT_COUNT (EV_DATIMER+1) 66 67 static char *strDeactEvent[] = 68 { 69 "EV_ACTIVATE", 70 "EV_ACTIVATE_IND", 71 "EV_DEACTIVATE", 72 "EV_DEACTIVATE_IND", 73 "EV_UI", 74 "EV_DATIMER", 75 }; 76 77 static void 78 da_debug(struct FsmInst *fi, char *fmt, ...) 79 { 80 struct manager *mgr = fi->userdata; 81 va_list va; 82 83 if (!(*debug & DEBUG_L2_TEIFSM)) 84 return; 85 va_start(va, fmt); 86 printk(KERN_DEBUG "mgr(%d): ", mgr->ch.st->dev->id); 87 vprintk(fmt, va); 88 printk("\n"); 89 va_end(va); 90 } 91 92 static void 93 da_activate(struct FsmInst *fi, int event, void *arg) 94 { 95 struct manager *mgr = fi->userdata; 96 97 if (fi->state == ST_L1_DEACT_PENDING) 98 mISDN_FsmDelTimer(&mgr->datimer, 1); 99 mISDN_FsmChangeState(fi, ST_L1_ACTIV); 100 } 101 102 static void 103 da_deactivate_ind(struct FsmInst *fi, int event, void *arg) 104 { 105 mISDN_FsmChangeState(fi, ST_L1_DEACT); 106 } 107 108 static void 109 da_deactivate(struct FsmInst *fi, int event, void *arg) 110 { 111 struct manager *mgr = fi->userdata; 112 struct layer2 *l2; 113 u_long flags; 114 115 read_lock_irqsave(&mgr->lock, flags); 116 list_for_each_entry(l2, &mgr->layer2, list) { 117 if (l2->l2m.state > ST_L2_4) { 118 /* have still activ TEI */ 119 read_unlock_irqrestore(&mgr->lock, flags); 120 return; 121 } 122 } 123 read_unlock_irqrestore(&mgr->lock, flags); 124 /* All TEI are inactiv */ 125 mISDN_FsmAddTimer(&mgr->datimer, DATIMER_VAL, EV_DATIMER, NULL, 1); 126 mISDN_FsmChangeState(fi, ST_L1_DEACT_PENDING); 127 } 128 129 static void 130 da_ui(struct FsmInst *fi, int event, void *arg) 131 { 132 struct manager *mgr = fi->userdata; 133 134 /* restart da timer */ 135 mISDN_FsmDelTimer(&mgr->datimer, 2); 136 mISDN_FsmAddTimer(&mgr->datimer, DATIMER_VAL, EV_DATIMER, NULL, 2); 137 138 } 139 140 static void 141 da_timer(struct FsmInst *fi, int event, void *arg) 142 { 143 struct manager *mgr = fi->userdata; 144 struct layer2 *l2; 145 u_long flags; 146 147 /* check again */ 148 read_lock_irqsave(&mgr->lock, flags); 149 list_for_each_entry(l2, &mgr->layer2, list) { 150 if (l2->l2m.state > ST_L2_4) { 151 /* have still activ TEI */ 152 read_unlock_irqrestore(&mgr->lock, flags); 153 mISDN_FsmChangeState(fi, ST_L1_ACTIV); 154 return; 155 } 156 } 157 read_unlock_irqrestore(&mgr->lock, flags); 158 /* All TEI are inactiv */ 159 mISDN_FsmChangeState(fi, ST_L1_DEACT); 160 _queue_data(&mgr->ch, PH_DEACTIVATE_REQ, MISDN_ID_ANY, 0, NULL, 161 GFP_ATOMIC); 162 } 163 164 static struct FsmNode DeactFnList[] = 165 { 166 {ST_L1_DEACT, EV_ACTIVATE_IND, da_activate}, 167 {ST_L1_ACTIV, EV_DEACTIVATE_IND, da_deactivate_ind}, 168 {ST_L1_ACTIV, EV_DEACTIVATE, da_deactivate}, 169 {ST_L1_DEACT_PENDING, EV_ACTIVATE, da_activate}, 170 {ST_L1_DEACT_PENDING, EV_UI, da_ui}, 171 {ST_L1_DEACT_PENDING, EV_DATIMER, da_timer}, 172 }; 173 174 enum { 175 ST_TEI_NOP, 176 ST_TEI_IDREQ, 177 ST_TEI_IDVERIFY, 178 }; 179 180 #define TEI_STATE_COUNT (ST_TEI_IDVERIFY+1) 181 182 static char *strTeiState[] = 183 { 184 "ST_TEI_NOP", 185 "ST_TEI_IDREQ", 186 "ST_TEI_IDVERIFY", 187 }; 188 189 enum { 190 EV_IDREQ, 191 EV_ASSIGN, 192 EV_ASSIGN_REQ, 193 EV_DENIED, 194 EV_CHKREQ, 195 EV_CHKRESP, 196 EV_REMOVE, 197 EV_VERIFY, 198 EV_TIMER, 199 }; 200 201 #define TEI_EVENT_COUNT (EV_TIMER+1) 202 203 static char *strTeiEvent[] = 204 { 205 "EV_IDREQ", 206 "EV_ASSIGN", 207 "EV_ASSIGN_REQ", 208 "EV_DENIED", 209 "EV_CHKREQ", 210 "EV_CHKRESP", 211 "EV_REMOVE", 212 "EV_VERIFY", 213 "EV_TIMER", 214 }; 215 216 static void 217 tei_debug(struct FsmInst *fi, char *fmt, ...) 218 { 219 struct teimgr *tm = fi->userdata; 220 va_list va; 221 222 if (!(*debug & DEBUG_L2_TEIFSM)) 223 return; 224 va_start(va, fmt); 225 printk(KERN_DEBUG "tei(%d): ", tm->l2->tei); 226 vprintk(fmt, va); 227 printk("\n"); 228 va_end(va); 229 } 230 231 232 233 static int 234 get_free_id(struct manager *mgr) 235 { 236 u64 ids = 0; 237 int i; 238 struct layer2 *l2; 239 240 list_for_each_entry(l2, &mgr->layer2, list) { 241 if (l2->ch.nr > 63) { 242 printk(KERN_WARNING 243 "%s: more as 63 layer2 for one device\n", 244 __func__); 245 return -EBUSY; 246 } 247 test_and_set_bit(l2->ch.nr, (u_long *)&ids); 248 } 249 for (i = 1; i < 64; i++) 250 if (!test_bit(i, (u_long *)&ids)) 251 return i; 252 printk(KERN_WARNING "%s: more as 63 layer2 for one device\n", 253 __func__); 254 return -EBUSY; 255 } 256 257 static int 258 get_free_tei(struct manager *mgr) 259 { 260 u64 ids = 0; 261 int i; 262 struct layer2 *l2; 263 264 list_for_each_entry(l2, &mgr->layer2, list) { 265 if (l2->ch.nr == 0) 266 continue; 267 if ((l2->ch.addr & 0xff) != 0) 268 continue; 269 i = l2->ch.addr >> 8; 270 if (i < 64) 271 continue; 272 i -= 64; 273 274 test_and_set_bit(i, (u_long *)&ids); 275 } 276 for (i = 0; i < 64; i++) 277 if (!test_bit(i, (u_long *)&ids)) 278 return i + 64; 279 printk(KERN_WARNING "%s: more as 63 dynamic tei for one device\n", 280 __func__); 281 return -1; 282 } 283 284 static void 285 teiup_create(struct manager *mgr, u_int prim, int len, void *arg) 286 { 287 struct sk_buff *skb; 288 struct mISDNhead *hh; 289 int err; 290 291 skb = mI_alloc_skb(len, GFP_ATOMIC); 292 if (!skb) 293 return; 294 hh = mISDN_HEAD_P(skb); 295 hh->prim = prim; 296 hh->id = (mgr->ch.nr << 16) | mgr->ch.addr; 297 if (len) 298 memcpy(skb_put(skb, len), arg, len); 299 err = mgr->up->send(mgr->up, skb); 300 if (err) { 301 printk(KERN_WARNING "%s: err=%d\n", __func__, err); 302 dev_kfree_skb(skb); 303 } 304 } 305 306 static u_int 307 new_id(struct manager *mgr) 308 { 309 u_int id; 310 311 id = mgr->nextid++; 312 if (id == 0x7fff) 313 mgr->nextid = 1; 314 id <<= 16; 315 id |= GROUP_TEI << 8; 316 id |= TEI_SAPI; 317 return id; 318 } 319 320 static void 321 do_send(struct manager *mgr) 322 { 323 if (!test_bit(MGR_PH_ACTIVE, &mgr->options)) 324 return; 325 326 if (!test_and_set_bit(MGR_PH_NOTREADY, &mgr->options)) { 327 struct sk_buff *skb = skb_dequeue(&mgr->sendq); 328 329 if (!skb) { 330 test_and_clear_bit(MGR_PH_NOTREADY, &mgr->options); 331 return; 332 } 333 mgr->lastid = mISDN_HEAD_ID(skb); 334 mISDN_FsmEvent(&mgr->deact, EV_UI, NULL); 335 if (mgr->ch.recv(mgr->ch.peer, skb)) { 336 dev_kfree_skb(skb); 337 test_and_clear_bit(MGR_PH_NOTREADY, &mgr->options); 338 mgr->lastid = MISDN_ID_NONE; 339 } 340 } 341 } 342 343 static void 344 do_ack(struct manager *mgr, u_int id) 345 { 346 if (test_bit(MGR_PH_NOTREADY, &mgr->options)) { 347 if (id == mgr->lastid) { 348 if (test_bit(MGR_PH_ACTIVE, &mgr->options)) { 349 struct sk_buff *skb; 350 351 skb = skb_dequeue(&mgr->sendq); 352 if (skb) { 353 mgr->lastid = mISDN_HEAD_ID(skb); 354 if (!mgr->ch.recv(mgr->ch.peer, skb)) 355 return; 356 dev_kfree_skb(skb); 357 } 358 } 359 mgr->lastid = MISDN_ID_NONE; 360 test_and_clear_bit(MGR_PH_NOTREADY, &mgr->options); 361 } 362 } 363 } 364 365 static void 366 mgr_send_down(struct manager *mgr, struct sk_buff *skb) 367 { 368 skb_queue_tail(&mgr->sendq, skb); 369 if (!test_bit(MGR_PH_ACTIVE, &mgr->options)) { 370 _queue_data(&mgr->ch, PH_ACTIVATE_REQ, MISDN_ID_ANY, 0, 371 NULL, GFP_KERNEL); 372 } else { 373 do_send(mgr); 374 } 375 } 376 377 static int 378 dl_unit_data(struct manager *mgr, struct sk_buff *skb) 379 { 380 if (!test_bit(MGR_OPT_NETWORK, &mgr->options)) /* only net send UI */ 381 return -EINVAL; 382 if (!test_bit(MGR_PH_ACTIVE, &mgr->options)) 383 _queue_data(&mgr->ch, PH_ACTIVATE_REQ, MISDN_ID_ANY, 0, 384 NULL, GFP_KERNEL); 385 skb_push(skb, 3); 386 skb->data[0] = 0x02; /* SAPI 0 C/R = 1 */ 387 skb->data[1] = 0xff; /* TEI 127 */ 388 skb->data[2] = UI; /* UI frame */ 389 mISDN_HEAD_PRIM(skb) = PH_DATA_REQ; 390 mISDN_HEAD_ID(skb) = new_id(mgr); 391 skb_queue_tail(&mgr->sendq, skb); 392 do_send(mgr); 393 return 0; 394 } 395 396 unsigned int 397 random_ri(void) 398 { 399 u16 x; 400 401 get_random_bytes(&x, sizeof(x)); 402 return x; 403 } 404 405 static struct layer2 * 406 findtei(struct manager *mgr, int tei) 407 { 408 struct layer2 *l2; 409 u_long flags; 410 411 read_lock_irqsave(&mgr->lock, flags); 412 list_for_each_entry(l2, &mgr->layer2, list) { 413 if ((l2->sapi == 0) && (l2->tei > 0) && 414 (l2->tei != GROUP_TEI) && (l2->tei == tei)) 415 goto done; 416 } 417 l2 = NULL; 418 done: 419 read_unlock_irqrestore(&mgr->lock, flags); 420 return l2; 421 } 422 423 static void 424 put_tei_msg(struct manager *mgr, u_char m_id, unsigned int ri, u_char tei) 425 { 426 struct sk_buff *skb; 427 u_char bp[8]; 428 429 bp[0] = (TEI_SAPI << 2); 430 if (test_bit(MGR_OPT_NETWORK, &mgr->options)) 431 bp[0] |= 2; /* CR:=1 for net command */ 432 bp[1] = (GROUP_TEI << 1) | 0x1; 433 bp[2] = UI; 434 bp[3] = TEI_ENTITY_ID; 435 bp[4] = ri >> 8; 436 bp[5] = ri & 0xff; 437 bp[6] = m_id; 438 bp[7] = (tei << 1) | 1; 439 skb = _alloc_mISDN_skb(PH_DATA_REQ, new_id(mgr), 440 8, bp, GFP_ATOMIC); 441 if (!skb) { 442 printk(KERN_WARNING "%s: no skb for tei msg\n", __func__); 443 return; 444 } 445 mgr_send_down(mgr, skb); 446 } 447 448 static void 449 tei_id_request(struct FsmInst *fi, int event, void *arg) 450 { 451 struct teimgr *tm = fi->userdata; 452 453 if (tm->l2->tei != GROUP_TEI) { 454 tm->tei_m.printdebug(&tm->tei_m, 455 "assign request for allready assigned tei %d", 456 tm->l2->tei); 457 return; 458 } 459 tm->ri = random_ri(); 460 if (*debug & DEBUG_L2_TEI) 461 tm->tei_m.printdebug(&tm->tei_m, 462 "assign request ri %d", tm->ri); 463 put_tei_msg(tm->mgr, ID_REQUEST, tm->ri, GROUP_TEI); 464 mISDN_FsmChangeState(fi, ST_TEI_IDREQ); 465 mISDN_FsmAddTimer(&tm->timer, tm->tval, EV_TIMER, NULL, 1); 466 tm->nval = 3; 467 } 468 469 static void 470 tei_id_assign(struct FsmInst *fi, int event, void *arg) 471 { 472 struct teimgr *tm = fi->userdata; 473 struct layer2 *l2; 474 u_char *dp = arg; 475 int ri, tei; 476 477 ri = ((unsigned int) *dp++ << 8); 478 ri += *dp++; 479 dp++; 480 tei = *dp >> 1; 481 if (*debug & DEBUG_L2_TEI) 482 tm->tei_m.printdebug(fi, "identity assign ri %d tei %d", 483 ri, tei); 484 l2 = findtei(tm->mgr, tei); 485 if (l2) { /* same tei is in use */ 486 if (ri != l2->tm->ri) { 487 tm->tei_m.printdebug(fi, 488 "possible duplicate assignment tei %d", tei); 489 tei_l2(l2, MDL_ERROR_RSP, 0); 490 } 491 } else if (ri == tm->ri) { 492 mISDN_FsmDelTimer(&tm->timer, 1); 493 mISDN_FsmChangeState(fi, ST_TEI_NOP); 494 tei_l2(tm->l2, MDL_ASSIGN_REQ, tei); 495 } 496 } 497 498 static void 499 tei_id_test_dup(struct FsmInst *fi, int event, void *arg) 500 { 501 struct teimgr *tm = fi->userdata; 502 struct layer2 *l2; 503 u_char *dp = arg; 504 int tei, ri; 505 506 ri = ((unsigned int) *dp++ << 8); 507 ri += *dp++; 508 dp++; 509 tei = *dp >> 1; 510 if (*debug & DEBUG_L2_TEI) 511 tm->tei_m.printdebug(fi, "foreign identity assign ri %d tei %d", 512 ri, tei); 513 l2 = findtei(tm->mgr, tei); 514 if (l2) { /* same tei is in use */ 515 if (ri != l2->tm->ri) { /* and it wasn't our request */ 516 tm->tei_m.printdebug(fi, 517 "possible duplicate assignment tei %d", tei); 518 mISDN_FsmEvent(&l2->tm->tei_m, EV_VERIFY, NULL); 519 } 520 } 521 } 522 523 static void 524 tei_id_denied(struct FsmInst *fi, int event, void *arg) 525 { 526 struct teimgr *tm = fi->userdata; 527 u_char *dp = arg; 528 int ri, tei; 529 530 ri = ((unsigned int) *dp++ << 8); 531 ri += *dp++; 532 dp++; 533 tei = *dp >> 1; 534 if (*debug & DEBUG_L2_TEI) 535 tm->tei_m.printdebug(fi, "identity denied ri %d tei %d", 536 ri, tei); 537 } 538 539 static void 540 tei_id_chk_req(struct FsmInst *fi, int event, void *arg) 541 { 542 struct teimgr *tm = fi->userdata; 543 u_char *dp = arg; 544 int tei; 545 546 tei = *(dp+3) >> 1; 547 if (*debug & DEBUG_L2_TEI) 548 tm->tei_m.printdebug(fi, "identity check req tei %d", tei); 549 if ((tm->l2->tei != GROUP_TEI) && ((tei == GROUP_TEI) || 550 (tei == tm->l2->tei))) { 551 mISDN_FsmDelTimer(&tm->timer, 4); 552 mISDN_FsmChangeState(&tm->tei_m, ST_TEI_NOP); 553 put_tei_msg(tm->mgr, ID_CHK_RES, random_ri(), tm->l2->tei); 554 } 555 } 556 557 static void 558 tei_id_remove(struct FsmInst *fi, int event, void *arg) 559 { 560 struct teimgr *tm = fi->userdata; 561 u_char *dp = arg; 562 int tei; 563 564 tei = *(dp+3) >> 1; 565 if (*debug & DEBUG_L2_TEI) 566 tm->tei_m.printdebug(fi, "identity remove tei %d", tei); 567 if ((tm->l2->tei != GROUP_TEI) && 568 ((tei == GROUP_TEI) || (tei == tm->l2->tei))) { 569 mISDN_FsmDelTimer(&tm->timer, 5); 570 mISDN_FsmChangeState(&tm->tei_m, ST_TEI_NOP); 571 tei_l2(tm->l2, MDL_REMOVE_REQ, 0); 572 } 573 } 574 575 static void 576 tei_id_verify(struct FsmInst *fi, int event, void *arg) 577 { 578 struct teimgr *tm = fi->userdata; 579 580 if (*debug & DEBUG_L2_TEI) 581 tm->tei_m.printdebug(fi, "id verify request for tei %d", 582 tm->l2->tei); 583 put_tei_msg(tm->mgr, ID_VERIFY, 0, tm->l2->tei); 584 mISDN_FsmChangeState(&tm->tei_m, ST_TEI_IDVERIFY); 585 mISDN_FsmAddTimer(&tm->timer, tm->tval, EV_TIMER, NULL, 2); 586 tm->nval = 2; 587 } 588 589 static void 590 tei_id_req_tout(struct FsmInst *fi, int event, void *arg) 591 { 592 struct teimgr *tm = fi->userdata; 593 594 if (--tm->nval) { 595 tm->ri = random_ri(); 596 if (*debug & DEBUG_L2_TEI) 597 tm->tei_m.printdebug(fi, "assign req(%d) ri %d", 598 4 - tm->nval, tm->ri); 599 put_tei_msg(tm->mgr, ID_REQUEST, tm->ri, GROUP_TEI); 600 mISDN_FsmAddTimer(&tm->timer, tm->tval, EV_TIMER, NULL, 3); 601 } else { 602 tm->tei_m.printdebug(fi, "assign req failed"); 603 tei_l2(tm->l2, MDL_ERROR_RSP, 0); 604 mISDN_FsmChangeState(fi, ST_TEI_NOP); 605 } 606 } 607 608 static void 609 tei_id_ver_tout(struct FsmInst *fi, int event, void *arg) 610 { 611 struct teimgr *tm = fi->userdata; 612 613 if (--tm->nval) { 614 if (*debug & DEBUG_L2_TEI) 615 tm->tei_m.printdebug(fi, 616 "id verify req(%d) for tei %d", 617 3 - tm->nval, tm->l2->tei); 618 put_tei_msg(tm->mgr, ID_VERIFY, 0, tm->l2->tei); 619 mISDN_FsmAddTimer(&tm->timer, tm->tval, EV_TIMER, NULL, 4); 620 } else { 621 tm->tei_m.printdebug(fi, "verify req for tei %d failed", 622 tm->l2->tei); 623 tei_l2(tm->l2, MDL_REMOVE_REQ, 0); 624 mISDN_FsmChangeState(fi, ST_TEI_NOP); 625 } 626 } 627 628 static struct FsmNode TeiFnListUser[] = 629 { 630 {ST_TEI_NOP, EV_IDREQ, tei_id_request}, 631 {ST_TEI_NOP, EV_ASSIGN, tei_id_test_dup}, 632 {ST_TEI_NOP, EV_VERIFY, tei_id_verify}, 633 {ST_TEI_NOP, EV_REMOVE, tei_id_remove}, 634 {ST_TEI_NOP, EV_CHKREQ, tei_id_chk_req}, 635 {ST_TEI_IDREQ, EV_TIMER, tei_id_req_tout}, 636 {ST_TEI_IDREQ, EV_ASSIGN, tei_id_assign}, 637 {ST_TEI_IDREQ, EV_DENIED, tei_id_denied}, 638 {ST_TEI_IDVERIFY, EV_TIMER, tei_id_ver_tout}, 639 {ST_TEI_IDVERIFY, EV_REMOVE, tei_id_remove}, 640 {ST_TEI_IDVERIFY, EV_CHKREQ, tei_id_chk_req}, 641 }; 642 643 static void 644 tei_l2remove(struct layer2 *l2) 645 { 646 put_tei_msg(l2->tm->mgr, ID_REMOVE, 0, l2->tei); 647 tei_l2(l2, MDL_REMOVE_REQ, 0); 648 list_del(&l2->ch.list); 649 l2->ch.ctrl(&l2->ch, CLOSE_CHANNEL, NULL); 650 } 651 652 static void 653 tei_assign_req(struct FsmInst *fi, int event, void *arg) 654 { 655 struct teimgr *tm = fi->userdata; 656 u_char *dp = arg; 657 658 if (tm->l2->tei == GROUP_TEI) { 659 tm->tei_m.printdebug(&tm->tei_m, 660 "net tei assign request without tei"); 661 return; 662 } 663 tm->ri = ((unsigned int) *dp++ << 8); 664 tm->ri += *dp++; 665 if (*debug & DEBUG_L2_TEI) 666 tm->tei_m.printdebug(&tm->tei_m, 667 "net assign request ri %d teim %d", tm->ri, *dp); 668 put_tei_msg(tm->mgr, ID_ASSIGNED, tm->ri, tm->l2->tei); 669 mISDN_FsmChangeState(fi, ST_TEI_NOP); 670 } 671 672 static void 673 tei_id_chk_req_net(struct FsmInst *fi, int event, void *arg) 674 { 675 struct teimgr *tm = fi->userdata; 676 677 if (*debug & DEBUG_L2_TEI) 678 tm->tei_m.printdebug(fi, "id check request for tei %d", 679 tm->l2->tei); 680 tm->rcnt = 0; 681 put_tei_msg(tm->mgr, ID_CHK_REQ, 0, tm->l2->tei); 682 mISDN_FsmChangeState(&tm->tei_m, ST_TEI_IDVERIFY); 683 mISDN_FsmAddTimer(&tm->timer, tm->tval, EV_TIMER, NULL, 2); 684 tm->nval = 2; 685 } 686 687 static void 688 tei_id_chk_resp(struct FsmInst *fi, int event, void *arg) 689 { 690 struct teimgr *tm = fi->userdata; 691 u_char *dp = arg; 692 int tei; 693 694 tei = dp[3] >> 1; 695 if (*debug & DEBUG_L2_TEI) 696 tm->tei_m.printdebug(fi, "identity check resp tei %d", tei); 697 if (tei == tm->l2->tei) 698 tm->rcnt++; 699 } 700 701 static void 702 tei_id_verify_net(struct FsmInst *fi, int event, void *arg) 703 { 704 struct teimgr *tm = fi->userdata; 705 u_char *dp = arg; 706 int tei; 707 708 tei = dp[3] >> 1; 709 if (*debug & DEBUG_L2_TEI) 710 tm->tei_m.printdebug(fi, "identity verify req tei %d/%d", 711 tei, tm->l2->tei); 712 if (tei == tm->l2->tei) 713 tei_id_chk_req_net(fi, event, arg); 714 } 715 716 static void 717 tei_id_ver_tout_net(struct FsmInst *fi, int event, void *arg) 718 { 719 struct teimgr *tm = fi->userdata; 720 721 if (tm->rcnt == 1) { 722 if (*debug & DEBUG_L2_TEI) 723 tm->tei_m.printdebug(fi, 724 "check req for tei %d sucessful\n", tm->l2->tei); 725 mISDN_FsmChangeState(fi, ST_TEI_NOP); 726 } else if (tm->rcnt > 1) { 727 /* duplicate assignment; remove */ 728 tei_l2remove(tm->l2); 729 } else if (--tm->nval) { 730 if (*debug & DEBUG_L2_TEI) 731 tm->tei_m.printdebug(fi, 732 "id check req(%d) for tei %d", 733 3 - tm->nval, tm->l2->tei); 734 put_tei_msg(tm->mgr, ID_CHK_REQ, 0, tm->l2->tei); 735 mISDN_FsmAddTimer(&tm->timer, tm->tval, EV_TIMER, NULL, 4); 736 } else { 737 tm->tei_m.printdebug(fi, "check req for tei %d failed", 738 tm->l2->tei); 739 mISDN_FsmChangeState(fi, ST_TEI_NOP); 740 tei_l2remove(tm->l2); 741 } 742 } 743 744 static struct FsmNode TeiFnListNet[] = 745 { 746 {ST_TEI_NOP, EV_ASSIGN_REQ, tei_assign_req}, 747 {ST_TEI_NOP, EV_VERIFY, tei_id_verify_net}, 748 {ST_TEI_NOP, EV_CHKREQ, tei_id_chk_req_net}, 749 {ST_TEI_IDVERIFY, EV_TIMER, tei_id_ver_tout_net}, 750 {ST_TEI_IDVERIFY, EV_CHKRESP, tei_id_chk_resp}, 751 }; 752 753 static void 754 tei_ph_data_ind(struct teimgr *tm, u_int mt, u_char *dp, int len) 755 { 756 if (test_bit(FLG_FIXED_TEI, &tm->l2->flag)) 757 return; 758 if (*debug & DEBUG_L2_TEI) 759 tm->tei_m.printdebug(&tm->tei_m, "tei handler mt %x", mt); 760 if (mt == ID_ASSIGNED) 761 mISDN_FsmEvent(&tm->tei_m, EV_ASSIGN, dp); 762 else if (mt == ID_DENIED) 763 mISDN_FsmEvent(&tm->tei_m, EV_DENIED, dp); 764 else if (mt == ID_CHK_REQ) 765 mISDN_FsmEvent(&tm->tei_m, EV_CHKREQ, dp); 766 else if (mt == ID_REMOVE) 767 mISDN_FsmEvent(&tm->tei_m, EV_REMOVE, dp); 768 else if (mt == ID_VERIFY) 769 mISDN_FsmEvent(&tm->tei_m, EV_VERIFY, dp); 770 else if (mt == ID_CHK_RES) 771 mISDN_FsmEvent(&tm->tei_m, EV_CHKRESP, dp); 772 } 773 774 static struct layer2 * 775 create_new_tei(struct manager *mgr, int tei) 776 { 777 u_long opt = 0; 778 u_long flags; 779 int id; 780 struct layer2 *l2; 781 782 if (!mgr->up) 783 return NULL; 784 if (tei < 64) 785 test_and_set_bit(OPTION_L2_FIXEDTEI, &opt); 786 if (mgr->ch.st->dev->Dprotocols 787 & ((1 << ISDN_P_TE_E1) | (1 << ISDN_P_NT_E1))) 788 test_and_set_bit(OPTION_L2_PMX, &opt); 789 l2 = create_l2(mgr->up, ISDN_P_LAPD_NT, (u_int)opt, (u_long)tei); 790 if (!l2) { 791 printk(KERN_WARNING "%s:no memory for layer2\n", __func__); 792 return NULL; 793 } 794 l2->tm = kzalloc(sizeof(struct teimgr), GFP_KERNEL); 795 if (!l2->tm) { 796 kfree(l2); 797 printk(KERN_WARNING "%s:no memory for teimgr\n", __func__); 798 return NULL; 799 } 800 l2->tm->mgr = mgr; 801 l2->tm->l2 = l2; 802 l2->tm->tei_m.debug = *debug & DEBUG_L2_TEIFSM; 803 l2->tm->tei_m.userdata = l2->tm; 804 l2->tm->tei_m.printdebug = tei_debug; 805 l2->tm->tei_m.fsm = &teifsmn; 806 l2->tm->tei_m.state = ST_TEI_NOP; 807 l2->tm->tval = 2000; /* T202 2 sec */ 808 mISDN_FsmInitTimer(&l2->tm->tei_m, &l2->tm->timer); 809 write_lock_irqsave(&mgr->lock, flags); 810 id = get_free_id(mgr); 811 list_add_tail(&l2->list, &mgr->layer2); 812 write_unlock_irqrestore(&mgr->lock, flags); 813 if (id < 0) { 814 l2->ch.ctrl(&l2->ch, CLOSE_CHANNEL, NULL); 815 printk(KERN_WARNING "%s:no free id\n", __func__); 816 return NULL; 817 } else { 818 l2->ch.nr = id; 819 __add_layer2(&l2->ch, mgr->ch.st); 820 l2->ch.recv = mgr->ch.recv; 821 l2->ch.peer = mgr->ch.peer; 822 l2->ch.ctrl(&l2->ch, OPEN_CHANNEL, NULL); 823 } 824 return l2; 825 } 826 827 static void 828 new_tei_req(struct manager *mgr, u_char *dp) 829 { 830 int tei, ri; 831 struct layer2 *l2; 832 833 ri = dp[0] << 8; 834 ri += dp[1]; 835 if (!mgr->up) 836 goto denied; 837 tei = get_free_tei(mgr); 838 if (tei < 0) { 839 printk(KERN_WARNING "%s:No free tei\n", __func__); 840 goto denied; 841 } 842 l2 = create_new_tei(mgr, tei); 843 if (!l2) 844 goto denied; 845 else 846 mISDN_FsmEvent(&l2->tm->tei_m, EV_ASSIGN_REQ, dp); 847 return; 848 denied: 849 put_tei_msg(mgr, ID_DENIED, ri, GROUP_TEI); 850 } 851 852 static int 853 ph_data_ind(struct manager *mgr, struct sk_buff *skb) 854 { 855 int ret = -EINVAL; 856 struct layer2 *l2; 857 u_long flags; 858 u_char mt; 859 860 if (skb->len < 8) { 861 if (*debug & DEBUG_L2_TEI) 862 printk(KERN_DEBUG "%s: short mgr frame %d/8\n", 863 __func__, skb->len); 864 goto done; 865 } 866 if (*debug & DEBUG_L2_TEI) 867 868 if ((skb->data[0] >> 2) != TEI_SAPI) /* not for us */ 869 goto done; 870 if (skb->data[0] & 1) /* EA0 formal error */ 871 goto done; 872 if (!(skb->data[1] & 1)) /* EA1 formal error */ 873 goto done; 874 if ((skb->data[1] >> 1) != GROUP_TEI) /* not for us */ 875 goto done; 876 if ((skb->data[2] & 0xef) != UI) /* not UI */ 877 goto done; 878 if (skb->data[3] != TEI_ENTITY_ID) /* not tei entity */ 879 goto done; 880 mt = skb->data[6]; 881 switch (mt) { 882 case ID_REQUEST: 883 case ID_CHK_RES: 884 case ID_VERIFY: 885 if (!test_bit(MGR_OPT_NETWORK, &mgr->options)) 886 goto done; 887 break; 888 case ID_ASSIGNED: 889 case ID_DENIED: 890 case ID_CHK_REQ: 891 case ID_REMOVE: 892 if (test_bit(MGR_OPT_NETWORK, &mgr->options)) 893 goto done; 894 break; 895 default: 896 goto done; 897 } 898 ret = 0; 899 if (mt == ID_REQUEST) { 900 new_tei_req(mgr, &skb->data[4]); 901 goto done; 902 } 903 read_lock_irqsave(&mgr->lock, flags); 904 list_for_each_entry(l2, &mgr->layer2, list) { 905 tei_ph_data_ind(l2->tm, mt, &skb->data[4], skb->len - 4); 906 } 907 read_unlock_irqrestore(&mgr->lock, flags); 908 done: 909 return ret; 910 } 911 912 int 913 l2_tei(struct layer2 *l2, u_int cmd, u_long arg) 914 { 915 struct teimgr *tm = l2->tm; 916 917 if (test_bit(FLG_FIXED_TEI, &l2->flag)) 918 return 0; 919 if (*debug & DEBUG_L2_TEI) 920 printk(KERN_DEBUG "%s: cmd(%x)\n", __func__, cmd); 921 switch (cmd) { 922 case MDL_ASSIGN_IND: 923 mISDN_FsmEvent(&tm->tei_m, EV_IDREQ, NULL); 924 break; 925 case MDL_ERROR_IND: 926 if (test_bit(MGR_OPT_NETWORK, &tm->mgr->options)) 927 mISDN_FsmEvent(&tm->tei_m, EV_CHKREQ, &l2->tei); 928 if (test_bit(MGR_OPT_USER, &tm->mgr->options)) 929 mISDN_FsmEvent(&tm->tei_m, EV_VERIFY, NULL); 930 break; 931 case MDL_STATUS_UP_IND: 932 if (test_bit(MGR_OPT_NETWORK, &tm->mgr->options)) 933 mISDN_FsmEvent(&tm->mgr->deact, EV_ACTIVATE, NULL); 934 break; 935 case MDL_STATUS_DOWN_IND: 936 if (test_bit(MGR_OPT_NETWORK, &tm->mgr->options)) 937 mISDN_FsmEvent(&tm->mgr->deact, EV_DEACTIVATE, NULL); 938 break; 939 case MDL_STATUS_UI_IND: 940 if (test_bit(MGR_OPT_NETWORK, &tm->mgr->options)) 941 mISDN_FsmEvent(&tm->mgr->deact, EV_UI, NULL); 942 break; 943 } 944 return 0; 945 } 946 947 void 948 TEIrelease(struct layer2 *l2) 949 { 950 struct teimgr *tm = l2->tm; 951 u_long flags; 952 953 mISDN_FsmDelTimer(&tm->timer, 1); 954 write_lock_irqsave(&tm->mgr->lock, flags); 955 list_del(&l2->list); 956 write_unlock_irqrestore(&tm->mgr->lock, flags); 957 l2->tm = NULL; 958 kfree(tm); 959 } 960 961 static int 962 create_teimgr(struct manager *mgr, struct channel_req *crq) 963 { 964 struct layer2 *l2; 965 u_long opt = 0; 966 u_long flags; 967 int id; 968 969 if (*debug & DEBUG_L2_TEI) 970 printk(KERN_DEBUG "%s: %s proto(%x) adr(%d %d %d %d)\n", 971 __func__, mgr->ch.st->dev->name, crq->protocol, 972 crq->adr.dev, crq->adr.channel, crq->adr.sapi, 973 crq->adr.tei); 974 if (crq->adr.sapi != 0) /* not supported yet */ 975 return -EINVAL; 976 if (crq->adr.tei > GROUP_TEI) 977 return -EINVAL; 978 if (crq->adr.tei < 64) 979 test_and_set_bit(OPTION_L2_FIXEDTEI, &opt); 980 if (crq->adr.tei == 0) 981 test_and_set_bit(OPTION_L2_PTP, &opt); 982 if (test_bit(MGR_OPT_NETWORK, &mgr->options)) { 983 if (crq->protocol == ISDN_P_LAPD_TE) 984 return -EPROTONOSUPPORT; 985 if ((crq->adr.tei != 0) && (crq->adr.tei != 127)) 986 return -EINVAL; 987 if (mgr->up) { 988 printk(KERN_WARNING 989 "%s: only one network manager is allowed\n", 990 __func__); 991 return -EBUSY; 992 } 993 } else if (test_bit(MGR_OPT_USER, &mgr->options)) { 994 if (crq->protocol == ISDN_P_LAPD_NT) 995 return -EPROTONOSUPPORT; 996 if ((crq->adr.tei >= 64) && (crq->adr.tei < GROUP_TEI)) 997 return -EINVAL; /* dyn tei */ 998 } else { 999 if (crq->protocol == ISDN_P_LAPD_NT) 1000 test_and_set_bit(MGR_OPT_NETWORK, &mgr->options); 1001 if (crq->protocol == ISDN_P_LAPD_TE) 1002 test_and_set_bit(MGR_OPT_USER, &mgr->options); 1003 } 1004 if (mgr->ch.st->dev->Dprotocols 1005 & ((1 << ISDN_P_TE_E1) | (1 << ISDN_P_NT_E1))) 1006 test_and_set_bit(OPTION_L2_PMX, &opt); 1007 if ((crq->protocol == ISDN_P_LAPD_NT) && (crq->adr.tei == 127)) { 1008 mgr->up = crq->ch; 1009 id = DL_INFO_L2_CONNECT; 1010 teiup_create(mgr, DL_INFORMATION_IND, sizeof(id), &id); 1011 crq->ch = NULL; 1012 if (!list_empty(&mgr->layer2)) { 1013 read_lock_irqsave(&mgr->lock, flags); 1014 list_for_each_entry(l2, &mgr->layer2, list) { 1015 l2->up = mgr->up; 1016 l2->ch.ctrl(&l2->ch, OPEN_CHANNEL, NULL); 1017 } 1018 read_unlock_irqrestore(&mgr->lock, flags); 1019 } 1020 return 0; 1021 } 1022 l2 = create_l2(crq->ch, crq->protocol, (u_int)opt, 1023 (u_long)crq->adr.tei); 1024 if (!l2) 1025 return -ENOMEM; 1026 l2->tm = kzalloc(sizeof(struct teimgr), GFP_KERNEL); 1027 if (!l2->tm) { 1028 kfree(l2); 1029 printk(KERN_ERR "kmalloc teimgr failed\n"); 1030 return -ENOMEM; 1031 } 1032 l2->tm->mgr = mgr; 1033 l2->tm->l2 = l2; 1034 l2->tm->tei_m.debug = *debug & DEBUG_L2_TEIFSM; 1035 l2->tm->tei_m.userdata = l2->tm; 1036 l2->tm->tei_m.printdebug = tei_debug; 1037 if (crq->protocol == ISDN_P_LAPD_TE) { 1038 l2->tm->tei_m.fsm = &teifsmu; 1039 l2->tm->tei_m.state = ST_TEI_NOP; 1040 l2->tm->tval = 1000; /* T201 1 sec */ 1041 } else { 1042 l2->tm->tei_m.fsm = &teifsmn; 1043 l2->tm->tei_m.state = ST_TEI_NOP; 1044 l2->tm->tval = 2000; /* T202 2 sec */ 1045 } 1046 mISDN_FsmInitTimer(&l2->tm->tei_m, &l2->tm->timer); 1047 write_lock_irqsave(&mgr->lock, flags); 1048 id = get_free_id(mgr); 1049 list_add_tail(&l2->list, &mgr->layer2); 1050 write_unlock_irqrestore(&mgr->lock, flags); 1051 if (id < 0) { 1052 l2->ch.ctrl(&l2->ch, CLOSE_CHANNEL, NULL); 1053 } else { 1054 l2->ch.nr = id; 1055 l2->up->nr = id; 1056 crq->ch = &l2->ch; 1057 id = 0; 1058 } 1059 return id; 1060 } 1061 1062 static int 1063 mgr_send(struct mISDNchannel *ch, struct sk_buff *skb) 1064 { 1065 struct manager *mgr; 1066 struct mISDNhead *hh = mISDN_HEAD_P(skb); 1067 int ret = -EINVAL; 1068 1069 mgr = container_of(ch, struct manager, ch); 1070 if (*debug & DEBUG_L2_RECV) 1071 printk(KERN_DEBUG "%s: prim(%x) id(%x)\n", 1072 __func__, hh->prim, hh->id); 1073 switch (hh->prim) { 1074 case PH_DATA_IND: 1075 mISDN_FsmEvent(&mgr->deact, EV_UI, NULL); 1076 ret = ph_data_ind(mgr, skb); 1077 break; 1078 case PH_DATA_CNF: 1079 do_ack(mgr, hh->id); 1080 ret = 0; 1081 break; 1082 case PH_ACTIVATE_IND: 1083 test_and_set_bit(MGR_PH_ACTIVE, &mgr->options); 1084 mISDN_FsmEvent(&mgr->deact, EV_ACTIVATE_IND, NULL); 1085 do_send(mgr); 1086 ret = 0; 1087 break; 1088 case PH_DEACTIVATE_IND: 1089 test_and_clear_bit(MGR_PH_ACTIVE, &mgr->options); 1090 mISDN_FsmEvent(&mgr->deact, EV_DEACTIVATE_IND, NULL); 1091 ret = 0; 1092 break; 1093 case DL_UNITDATA_REQ: 1094 return dl_unit_data(mgr, skb); 1095 } 1096 if (!ret) 1097 dev_kfree_skb(skb); 1098 return ret; 1099 } 1100 1101 static int 1102 free_teimanager(struct manager *mgr) 1103 { 1104 struct layer2 *l2, *nl2; 1105 1106 if (test_bit(MGR_OPT_NETWORK, &mgr->options)) { 1107 /* not locked lock is taken in release tei */ 1108 mgr->up = NULL; 1109 if (test_bit(OPTION_L2_CLEANUP, &mgr->options)) { 1110 list_for_each_entry_safe(l2, nl2, &mgr->layer2, list) { 1111 put_tei_msg(mgr, ID_REMOVE, 0, l2->tei); 1112 mutex_lock(&mgr->ch.st->lmutex); 1113 list_del(&l2->ch.list); 1114 mutex_unlock(&mgr->ch.st->lmutex); 1115 l2->ch.ctrl(&l2->ch, CLOSE_CHANNEL, NULL); 1116 } 1117 test_and_clear_bit(MGR_OPT_NETWORK, &mgr->options); 1118 } else { 1119 list_for_each_entry_safe(l2, nl2, &mgr->layer2, list) { 1120 l2->up = NULL; 1121 } 1122 } 1123 } 1124 if (test_bit(MGR_OPT_USER, &mgr->options)) { 1125 if (list_empty(&mgr->layer2)) 1126 test_and_clear_bit(MGR_OPT_USER, &mgr->options); 1127 } 1128 mgr->ch.st->dev->D.ctrl(&mgr->ch.st->dev->D, CLOSE_CHANNEL, NULL); 1129 return 0; 1130 } 1131 1132 static int 1133 ctrl_teimanager(struct manager *mgr, void *arg) 1134 { 1135 /* currently we only have one option */ 1136 int clean = *((int *)arg); 1137 1138 if (clean) 1139 test_and_set_bit(OPTION_L2_CLEANUP, &mgr->options); 1140 else 1141 test_and_clear_bit(OPTION_L2_CLEANUP, &mgr->options); 1142 return 0; 1143 } 1144 1145 /* This function does create a L2 for fixed TEI in NT Mode */ 1146 static int 1147 check_data(struct manager *mgr, struct sk_buff *skb) 1148 { 1149 struct mISDNhead *hh = mISDN_HEAD_P(skb); 1150 int ret, tei; 1151 struct layer2 *l2; 1152 1153 if (*debug & DEBUG_L2_CTRL) 1154 printk(KERN_DEBUG "%s: prim(%x) id(%x)\n", 1155 __func__, hh->prim, hh->id); 1156 if (test_bit(MGR_OPT_USER, &mgr->options)) 1157 return -ENOTCONN; 1158 if (hh->prim != PH_DATA_IND) 1159 return -ENOTCONN; 1160 if (skb->len != 3) 1161 return -ENOTCONN; 1162 if (skb->data[0] != 0) 1163 /* only SAPI 0 command */ 1164 return -ENOTCONN; 1165 if (!(skb->data[1] & 1)) /* invalid EA1 */ 1166 return -EINVAL; 1167 tei = skb->data[1] >> 0; 1168 if (tei > 63) /* not a fixed tei */ 1169 return -ENOTCONN; 1170 if ((skb->data[2] & ~0x10) != SABME) 1171 return -ENOTCONN; 1172 /* We got a SABME for a fixed TEI */ 1173 l2 = create_new_tei(mgr, tei); 1174 if (!l2) 1175 return -ENOMEM; 1176 ret = l2->ch.send(&l2->ch, skb); 1177 return ret; 1178 } 1179 1180 void 1181 delete_teimanager(struct mISDNchannel *ch) 1182 { 1183 struct manager *mgr; 1184 struct layer2 *l2, *nl2; 1185 1186 mgr = container_of(ch, struct manager, ch); 1187 /* not locked lock is taken in release tei */ 1188 list_for_each_entry_safe(l2, nl2, &mgr->layer2, list) { 1189 mutex_lock(&mgr->ch.st->lmutex); 1190 list_del(&l2->ch.list); 1191 mutex_unlock(&mgr->ch.st->lmutex); 1192 l2->ch.ctrl(&l2->ch, CLOSE_CHANNEL, NULL); 1193 } 1194 list_del(&mgr->ch.list); 1195 list_del(&mgr->bcast.list); 1196 skb_queue_purge(&mgr->sendq); 1197 kfree(mgr); 1198 } 1199 1200 static int 1201 mgr_ctrl(struct mISDNchannel *ch, u_int cmd, void *arg) 1202 { 1203 struct manager *mgr; 1204 int ret = -EINVAL; 1205 1206 mgr = container_of(ch, struct manager, ch); 1207 if (*debug & DEBUG_L2_CTRL) 1208 printk(KERN_DEBUG "%s(%x, %p)\n", __func__, cmd, arg); 1209 switch (cmd) { 1210 case OPEN_CHANNEL: 1211 ret = create_teimgr(mgr, arg); 1212 break; 1213 case CLOSE_CHANNEL: 1214 ret = free_teimanager(mgr); 1215 break; 1216 case CONTROL_CHANNEL: 1217 ret = ctrl_teimanager(mgr, arg); 1218 break; 1219 case CHECK_DATA: 1220 ret = check_data(mgr, arg); 1221 break; 1222 } 1223 return ret; 1224 } 1225 1226 static int 1227 mgr_bcast(struct mISDNchannel *ch, struct sk_buff *skb) 1228 { 1229 struct manager *mgr = container_of(ch, struct manager, bcast); 1230 struct mISDNhead *hh = mISDN_HEAD_P(skb); 1231 struct sk_buff *cskb = NULL; 1232 struct layer2 *l2; 1233 u_long flags; 1234 int ret; 1235 1236 read_lock_irqsave(&mgr->lock, flags); 1237 list_for_each_entry(l2, &mgr->layer2, list) { 1238 if ((hh->id & MISDN_ID_SAPI_MASK) == 1239 (l2->ch.addr & MISDN_ID_SAPI_MASK)) { 1240 if (list_is_last(&l2->list, &mgr->layer2)) { 1241 cskb = skb; 1242 skb = NULL; 1243 } else { 1244 if (!cskb) 1245 cskb = skb_copy(skb, GFP_KERNEL); 1246 } 1247 if (cskb) { 1248 ret = l2->ch.send(&l2->ch, cskb); 1249 if (ret) { 1250 if (*debug & DEBUG_SEND_ERR) 1251 printk(KERN_DEBUG 1252 "%s ch%d prim(%x) addr(%x)" 1253 " err %d\n", 1254 __func__, l2->ch.nr, 1255 hh->prim, l2->ch.addr, ret); 1256 } else 1257 cskb = NULL; 1258 } else { 1259 printk(KERN_WARNING "%s ch%d addr %x no mem\n", 1260 __func__, ch->nr, ch->addr); 1261 goto out; 1262 } 1263 } 1264 } 1265 out: 1266 read_unlock_irqrestore(&mgr->lock, flags); 1267 if (cskb) 1268 dev_kfree_skb(cskb); 1269 if (skb) 1270 dev_kfree_skb(skb); 1271 return 0; 1272 } 1273 1274 static int 1275 mgr_bcast_ctrl(struct mISDNchannel *ch, u_int cmd, void *arg) 1276 { 1277 1278 return -EINVAL; 1279 } 1280 1281 int 1282 create_teimanager(struct mISDNdevice *dev) 1283 { 1284 struct manager *mgr; 1285 1286 mgr = kzalloc(sizeof(struct manager), GFP_KERNEL); 1287 if (!mgr) 1288 return -ENOMEM; 1289 INIT_LIST_HEAD(&mgr->layer2); 1290 mgr->lock = __RW_LOCK_UNLOCKED(mgr->lock); 1291 skb_queue_head_init(&mgr->sendq); 1292 mgr->nextid = 1; 1293 mgr->lastid = MISDN_ID_NONE; 1294 mgr->ch.send = mgr_send; 1295 mgr->ch.ctrl = mgr_ctrl; 1296 mgr->ch.st = dev->D.st; 1297 set_channel_address(&mgr->ch, TEI_SAPI, GROUP_TEI); 1298 add_layer2(&mgr->ch, dev->D.st); 1299 mgr->bcast.send = mgr_bcast; 1300 mgr->bcast.ctrl = mgr_bcast_ctrl; 1301 mgr->bcast.st = dev->D.st; 1302 set_channel_address(&mgr->bcast, 0, GROUP_TEI); 1303 add_layer2(&mgr->bcast, dev->D.st); 1304 mgr->deact.debug = *debug & DEBUG_MANAGER; 1305 mgr->deact.userdata = mgr; 1306 mgr->deact.printdebug = da_debug; 1307 mgr->deact.fsm = &deactfsm; 1308 mgr->deact.state = ST_L1_DEACT; 1309 mISDN_FsmInitTimer(&mgr->deact, &mgr->datimer); 1310 dev->teimgr = &mgr->ch; 1311 return 0; 1312 } 1313 1314 int TEIInit(u_int *deb) 1315 { 1316 debug = deb; 1317 teifsmu.state_count = TEI_STATE_COUNT; 1318 teifsmu.event_count = TEI_EVENT_COUNT; 1319 teifsmu.strEvent = strTeiEvent; 1320 teifsmu.strState = strTeiState; 1321 mISDN_FsmNew(&teifsmu, TeiFnListUser, ARRAY_SIZE(TeiFnListUser)); 1322 teifsmn.state_count = TEI_STATE_COUNT; 1323 teifsmn.event_count = TEI_EVENT_COUNT; 1324 teifsmn.strEvent = strTeiEvent; 1325 teifsmn.strState = strTeiState; 1326 mISDN_FsmNew(&teifsmn, TeiFnListNet, ARRAY_SIZE(TeiFnListNet)); 1327 deactfsm.state_count = DEACT_STATE_COUNT; 1328 deactfsm.event_count = DEACT_EVENT_COUNT; 1329 deactfsm.strEvent = strDeactEvent; 1330 deactfsm.strState = strDeactState; 1331 mISDN_FsmNew(&deactfsm, DeactFnList, ARRAY_SIZE(DeactFnList)); 1332 return 0; 1333 } 1334 1335 void TEIFree(void) 1336 { 1337 mISDN_FsmFree(&teifsmu); 1338 mISDN_FsmFree(&teifsmn); 1339 mISDN_FsmFree(&deactfsm); 1340 } 1341