1 /* $Id: kcapi.c,v 1.1.2.8 2004/03/26 19:57:20 armin Exp $ 2 * 3 * Kernel CAPI 2.0 Module 4 * 5 * Copyright 1999 by Carsten Paeth <calle@calle.de> 6 * Copyright 2002 by Kai Germaschewski <kai@germaschewski.name> 7 * 8 * This software may be used and distributed according to the terms 9 * of the GNU General Public License, incorporated herein by reference. 10 * 11 */ 12 13 #define AVMB1_COMPAT 14 15 #include "kcapi.h" 16 #include <linux/module.h> 17 #include <linux/mm.h> 18 #include <linux/interrupt.h> 19 #include <linux/ioport.h> 20 #include <linux/proc_fs.h> 21 #include <linux/sched.h> 22 #include <linux/seq_file.h> 23 #include <linux/skbuff.h> 24 #include <linux/workqueue.h> 25 #include <linux/capi.h> 26 #include <linux/kernelcapi.h> 27 #include <linux/init.h> 28 #include <linux/moduleparam.h> 29 #include <linux/delay.h> 30 #include <linux/slab.h> 31 #include <asm/uaccess.h> 32 #include <linux/isdn/capicmd.h> 33 #include <linux/isdn/capiutil.h> 34 #ifdef AVMB1_COMPAT 35 #include <linux/b1lli.h> 36 #endif 37 #include <linux/mutex.h> 38 #include <linux/rcupdate.h> 39 40 static int showcapimsgs = 0; 41 static struct workqueue_struct *kcapi_wq; 42 43 MODULE_DESCRIPTION("CAPI4Linux: kernel CAPI layer"); 44 MODULE_AUTHOR("Carsten Paeth"); 45 MODULE_LICENSE("GPL"); 46 module_param(showcapimsgs, uint, 0); 47 48 /* ------------------------------------------------------------- */ 49 50 struct capictr_event { 51 struct work_struct work; 52 unsigned int type; 53 u32 controller; 54 }; 55 56 /* ------------------------------------------------------------- */ 57 58 static struct capi_version driver_version = {2, 0, 1, 1 << 4}; 59 static char driver_serial[CAPI_SERIAL_LEN] = "0004711"; 60 static char capi_manufakturer[64] = "AVM Berlin"; 61 62 #define NCCI2CTRL(ncci) (((ncci) >> 24) & 0x7f) 63 64 LIST_HEAD(capi_drivers); 65 DEFINE_MUTEX(capi_drivers_lock); 66 67 struct capi_ctr *capi_controller[CAPI_MAXCONTR]; 68 DEFINE_MUTEX(capi_controller_lock); 69 70 struct capi20_appl *capi_applications[CAPI_MAXAPPL]; 71 72 static int ncontrollers; 73 74 static BLOCKING_NOTIFIER_HEAD(ctr_notifier_list); 75 76 /* -------- controller ref counting -------------------------------------- */ 77 78 static inline struct capi_ctr * 79 capi_ctr_get(struct capi_ctr *ctr) 80 { 81 if (!try_module_get(ctr->owner)) 82 return NULL; 83 return ctr; 84 } 85 86 static inline void 87 capi_ctr_put(struct capi_ctr *ctr) 88 { 89 module_put(ctr->owner); 90 } 91 92 /* ------------------------------------------------------------- */ 93 94 static inline struct capi_ctr *get_capi_ctr_by_nr(u16 contr) 95 { 96 if (contr < 1 || contr - 1 >= CAPI_MAXCONTR) 97 return NULL; 98 99 return capi_controller[contr - 1]; 100 } 101 102 static inline struct capi20_appl *__get_capi_appl_by_nr(u16 applid) 103 { 104 lockdep_assert_held(&capi_controller_lock); 105 106 if (applid < 1 || applid - 1 >= CAPI_MAXAPPL) 107 return NULL; 108 109 return capi_applications[applid - 1]; 110 } 111 112 static inline struct capi20_appl *get_capi_appl_by_nr(u16 applid) 113 { 114 if (applid < 1 || applid - 1 >= CAPI_MAXAPPL) 115 return NULL; 116 117 return rcu_dereference(capi_applications[applid - 1]); 118 } 119 120 /* -------- util functions ------------------------------------ */ 121 122 static inline int capi_cmd_valid(u8 cmd) 123 { 124 switch (cmd) { 125 case CAPI_ALERT: 126 case CAPI_CONNECT: 127 case CAPI_CONNECT_ACTIVE: 128 case CAPI_CONNECT_B3_ACTIVE: 129 case CAPI_CONNECT_B3: 130 case CAPI_CONNECT_B3_T90_ACTIVE: 131 case CAPI_DATA_B3: 132 case CAPI_DISCONNECT_B3: 133 case CAPI_DISCONNECT: 134 case CAPI_FACILITY: 135 case CAPI_INFO: 136 case CAPI_LISTEN: 137 case CAPI_MANUFACTURER: 138 case CAPI_RESET_B3: 139 case CAPI_SELECT_B_PROTOCOL: 140 return 1; 141 } 142 return 0; 143 } 144 145 static inline int capi_subcmd_valid(u8 subcmd) 146 { 147 switch (subcmd) { 148 case CAPI_REQ: 149 case CAPI_CONF: 150 case CAPI_IND: 151 case CAPI_RESP: 152 return 1; 153 } 154 return 0; 155 } 156 157 /* ------------------------------------------------------------ */ 158 159 static void 160 register_appl(struct capi_ctr *ctr, u16 applid, capi_register_params *rparam) 161 { 162 ctr = capi_ctr_get(ctr); 163 164 if (ctr) 165 ctr->register_appl(ctr, applid, rparam); 166 else 167 printk(KERN_WARNING "%s: cannot get controller resources\n", 168 __func__); 169 } 170 171 172 static void release_appl(struct capi_ctr *ctr, u16 applid) 173 { 174 DBG("applid %#x", applid); 175 176 ctr->release_appl(ctr, applid); 177 capi_ctr_put(ctr); 178 } 179 180 static void notify_up(u32 contr) 181 { 182 struct capi20_appl *ap; 183 struct capi_ctr *ctr; 184 u16 applid; 185 186 mutex_lock(&capi_controller_lock); 187 188 if (showcapimsgs & 1) 189 printk(KERN_DEBUG "kcapi: notify up contr %d\n", contr); 190 191 ctr = get_capi_ctr_by_nr(contr); 192 if (ctr) { 193 if (ctr->state == CAPI_CTR_RUNNING) 194 goto unlock_out; 195 196 ctr->state = CAPI_CTR_RUNNING; 197 198 for (applid = 1; applid <= CAPI_MAXAPPL; applid++) { 199 ap = __get_capi_appl_by_nr(applid); 200 if (ap) 201 register_appl(ctr, applid, &ap->rparam); 202 } 203 204 wake_up_interruptible_all(&ctr->state_wait_queue); 205 } else 206 printk(KERN_WARNING "%s: invalid contr %d\n", __func__, contr); 207 208 unlock_out: 209 mutex_unlock(&capi_controller_lock); 210 } 211 212 static void ctr_down(struct capi_ctr *ctr, int new_state) 213 { 214 struct capi20_appl *ap; 215 u16 applid; 216 217 if (ctr->state == CAPI_CTR_DETECTED || ctr->state == CAPI_CTR_DETACHED) 218 return; 219 220 ctr->state = new_state; 221 222 memset(ctr->manu, 0, sizeof(ctr->manu)); 223 memset(&ctr->version, 0, sizeof(ctr->version)); 224 memset(&ctr->profile, 0, sizeof(ctr->profile)); 225 memset(ctr->serial, 0, sizeof(ctr->serial)); 226 227 for (applid = 1; applid <= CAPI_MAXAPPL; applid++) { 228 ap = __get_capi_appl_by_nr(applid); 229 if (ap) 230 capi_ctr_put(ctr); 231 } 232 233 wake_up_interruptible_all(&ctr->state_wait_queue); 234 } 235 236 static void notify_down(u32 contr) 237 { 238 struct capi_ctr *ctr; 239 240 mutex_lock(&capi_controller_lock); 241 242 if (showcapimsgs & 1) 243 printk(KERN_DEBUG "kcapi: notify down contr %d\n", contr); 244 245 ctr = get_capi_ctr_by_nr(contr); 246 if (ctr) 247 ctr_down(ctr, CAPI_CTR_DETECTED); 248 else 249 printk(KERN_WARNING "%s: invalid contr %d\n", __func__, contr); 250 251 mutex_unlock(&capi_controller_lock); 252 } 253 254 static int 255 notify_handler(struct notifier_block *nb, unsigned long val, void *v) 256 { 257 u32 contr = (long)v; 258 259 switch (val) { 260 case CAPICTR_UP: 261 notify_up(contr); 262 break; 263 case CAPICTR_DOWN: 264 notify_down(contr); 265 break; 266 } 267 return NOTIFY_OK; 268 } 269 270 static void do_notify_work(struct work_struct *work) 271 { 272 struct capictr_event *event = 273 container_of(work, struct capictr_event, work); 274 275 blocking_notifier_call_chain(&ctr_notifier_list, event->type, 276 (void *)(long)event->controller); 277 kfree(event); 278 } 279 280 /* 281 * The notifier will result in adding/deleteing of devices. Devices can 282 * only removed in user process, not in bh. 283 */ 284 static int notify_push(unsigned int event_type, u32 controller) 285 { 286 struct capictr_event *event = kmalloc(sizeof(*event), GFP_ATOMIC); 287 288 if (!event) 289 return -ENOMEM; 290 291 INIT_WORK(&event->work, do_notify_work); 292 event->type = event_type; 293 event->controller = controller; 294 295 queue_work(kcapi_wq, &event->work); 296 return 0; 297 } 298 299 int register_capictr_notifier(struct notifier_block *nb) 300 { 301 return blocking_notifier_chain_register(&ctr_notifier_list, nb); 302 } 303 EXPORT_SYMBOL_GPL(register_capictr_notifier); 304 305 int unregister_capictr_notifier(struct notifier_block *nb) 306 { 307 return blocking_notifier_chain_unregister(&ctr_notifier_list, nb); 308 } 309 EXPORT_SYMBOL_GPL(unregister_capictr_notifier); 310 311 /* -------- Receiver ------------------------------------------ */ 312 313 static void recv_handler(struct work_struct *work) 314 { 315 struct sk_buff *skb; 316 struct capi20_appl *ap = 317 container_of(work, struct capi20_appl, recv_work); 318 319 if ((!ap) || (ap->release_in_progress)) 320 return; 321 322 mutex_lock(&ap->recv_mtx); 323 while ((skb = skb_dequeue(&ap->recv_queue))) { 324 if (CAPIMSG_CMD(skb->data) == CAPI_DATA_B3_IND) 325 ap->nrecvdatapkt++; 326 else 327 ap->nrecvctlpkt++; 328 329 ap->recv_message(ap, skb); 330 } 331 mutex_unlock(&ap->recv_mtx); 332 } 333 334 /** 335 * capi_ctr_handle_message() - handle incoming CAPI message 336 * @ctr: controller descriptor structure. 337 * @appl: application ID. 338 * @skb: message. 339 * 340 * Called by hardware driver to pass a CAPI message to the application. 341 */ 342 343 void capi_ctr_handle_message(struct capi_ctr *ctr, u16 appl, 344 struct sk_buff *skb) 345 { 346 struct capi20_appl *ap; 347 int showctl = 0; 348 u8 cmd, subcmd; 349 _cdebbuf *cdb; 350 351 if (ctr->state != CAPI_CTR_RUNNING) { 352 cdb = capi_message2str(skb->data); 353 if (cdb) { 354 printk(KERN_INFO "kcapi: controller [%03d] not active, got: %s", 355 ctr->cnr, cdb->buf); 356 cdebbuf_free(cdb); 357 } else 358 printk(KERN_INFO "kcapi: controller [%03d] not active, cannot trace\n", 359 ctr->cnr); 360 goto error; 361 } 362 363 cmd = CAPIMSG_COMMAND(skb->data); 364 subcmd = CAPIMSG_SUBCOMMAND(skb->data); 365 if (cmd == CAPI_DATA_B3 && subcmd == CAPI_IND) { 366 ctr->nrecvdatapkt++; 367 if (ctr->traceflag > 2) 368 showctl |= 2; 369 } else { 370 ctr->nrecvctlpkt++; 371 if (ctr->traceflag) 372 showctl |= 2; 373 } 374 showctl |= (ctr->traceflag & 1); 375 if (showctl & 2) { 376 if (showctl & 1) { 377 printk(KERN_DEBUG "kcapi: got [%03d] id#%d %s len=%u\n", 378 ctr->cnr, CAPIMSG_APPID(skb->data), 379 capi_cmd2str(cmd, subcmd), 380 CAPIMSG_LEN(skb->data)); 381 } else { 382 cdb = capi_message2str(skb->data); 383 if (cdb) { 384 printk(KERN_DEBUG "kcapi: got [%03d] %s\n", 385 ctr->cnr, cdb->buf); 386 cdebbuf_free(cdb); 387 } else 388 printk(KERN_DEBUG "kcapi: got [%03d] id#%d %s len=%u, cannot trace\n", 389 ctr->cnr, CAPIMSG_APPID(skb->data), 390 capi_cmd2str(cmd, subcmd), 391 CAPIMSG_LEN(skb->data)); 392 } 393 394 } 395 396 rcu_read_lock(); 397 ap = get_capi_appl_by_nr(CAPIMSG_APPID(skb->data)); 398 if (!ap) { 399 rcu_read_unlock(); 400 cdb = capi_message2str(skb->data); 401 if (cdb) { 402 printk(KERN_ERR "kcapi: handle_message: applid %d state released (%s)\n", 403 CAPIMSG_APPID(skb->data), cdb->buf); 404 cdebbuf_free(cdb); 405 } else 406 printk(KERN_ERR "kcapi: handle_message: applid %d state released (%s) cannot trace\n", 407 CAPIMSG_APPID(skb->data), 408 capi_cmd2str(cmd, subcmd)); 409 goto error; 410 } 411 skb_queue_tail(&ap->recv_queue, skb); 412 queue_work(kcapi_wq, &ap->recv_work); 413 rcu_read_unlock(); 414 415 return; 416 417 error: 418 kfree_skb(skb); 419 } 420 421 EXPORT_SYMBOL(capi_ctr_handle_message); 422 423 /** 424 * capi_ctr_ready() - signal CAPI controller ready 425 * @ctr: controller descriptor structure. 426 * 427 * Called by hardware driver to signal that the controller is up and running. 428 */ 429 430 void capi_ctr_ready(struct capi_ctr *ctr) 431 { 432 printk(KERN_NOTICE "kcapi: controller [%03d] \"%s\" ready.\n", 433 ctr->cnr, ctr->name); 434 435 notify_push(CAPICTR_UP, ctr->cnr); 436 } 437 438 EXPORT_SYMBOL(capi_ctr_ready); 439 440 /** 441 * capi_ctr_down() - signal CAPI controller not ready 442 * @ctr: controller descriptor structure. 443 * 444 * Called by hardware driver to signal that the controller is down and 445 * unavailable for use. 446 */ 447 448 void capi_ctr_down(struct capi_ctr *ctr) 449 { 450 printk(KERN_NOTICE "kcapi: controller [%03d] down.\n", ctr->cnr); 451 452 notify_push(CAPICTR_DOWN, ctr->cnr); 453 } 454 455 EXPORT_SYMBOL(capi_ctr_down); 456 457 /** 458 * capi_ctr_suspend_output() - suspend controller 459 * @ctr: controller descriptor structure. 460 * 461 * Called by hardware driver to stop data flow. 462 * 463 * Note: The caller is responsible for synchronizing concurrent state changes 464 * as well as invocations of capi_ctr_handle_message. 465 */ 466 467 void capi_ctr_suspend_output(struct capi_ctr *ctr) 468 { 469 if (!ctr->blocked) { 470 printk(KERN_DEBUG "kcapi: controller [%03d] suspend\n", 471 ctr->cnr); 472 ctr->blocked = 1; 473 } 474 } 475 476 EXPORT_SYMBOL(capi_ctr_suspend_output); 477 478 /** 479 * capi_ctr_resume_output() - resume controller 480 * @ctr: controller descriptor structure. 481 * 482 * Called by hardware driver to resume data flow. 483 * 484 * Note: The caller is responsible for synchronizing concurrent state changes 485 * as well as invocations of capi_ctr_handle_message. 486 */ 487 488 void capi_ctr_resume_output(struct capi_ctr *ctr) 489 { 490 if (ctr->blocked) { 491 printk(KERN_DEBUG "kcapi: controller [%03d] resumed\n", 492 ctr->cnr); 493 ctr->blocked = 0; 494 } 495 } 496 497 EXPORT_SYMBOL(capi_ctr_resume_output); 498 499 /* ------------------------------------------------------------- */ 500 501 /** 502 * attach_capi_ctr() - register CAPI controller 503 * @ctr: controller descriptor structure. 504 * 505 * Called by hardware driver to register a controller with the CAPI subsystem. 506 * Return value: 0 on success, error code < 0 on error 507 */ 508 509 int attach_capi_ctr(struct capi_ctr *ctr) 510 { 511 int i; 512 513 mutex_lock(&capi_controller_lock); 514 515 for (i = 0; i < CAPI_MAXCONTR; i++) { 516 if (!capi_controller[i]) 517 break; 518 } 519 if (i == CAPI_MAXCONTR) { 520 mutex_unlock(&capi_controller_lock); 521 printk(KERN_ERR "kcapi: out of controller slots\n"); 522 return -EBUSY; 523 } 524 capi_controller[i] = ctr; 525 526 ctr->nrecvctlpkt = 0; 527 ctr->nrecvdatapkt = 0; 528 ctr->nsentctlpkt = 0; 529 ctr->nsentdatapkt = 0; 530 ctr->cnr = i + 1; 531 ctr->state = CAPI_CTR_DETECTED; 532 ctr->blocked = 0; 533 ctr->traceflag = showcapimsgs; 534 init_waitqueue_head(&ctr->state_wait_queue); 535 536 sprintf(ctr->procfn, "capi/controllers/%d", ctr->cnr); 537 ctr->procent = proc_create_data(ctr->procfn, 0, NULL, ctr->proc_fops, ctr); 538 539 ncontrollers++; 540 541 mutex_unlock(&capi_controller_lock); 542 543 printk(KERN_NOTICE "kcapi: controller [%03d]: %s attached\n", 544 ctr->cnr, ctr->name); 545 return 0; 546 } 547 548 EXPORT_SYMBOL(attach_capi_ctr); 549 550 /** 551 * detach_capi_ctr() - unregister CAPI controller 552 * @ctr: controller descriptor structure. 553 * 554 * Called by hardware driver to remove the registration of a controller 555 * with the CAPI subsystem. 556 * Return value: 0 on success, error code < 0 on error 557 */ 558 559 int detach_capi_ctr(struct capi_ctr *ctr) 560 { 561 int err = 0; 562 563 mutex_lock(&capi_controller_lock); 564 565 ctr_down(ctr, CAPI_CTR_DETACHED); 566 567 if (capi_controller[ctr->cnr - 1] != ctr) { 568 err = -EINVAL; 569 goto unlock_out; 570 } 571 capi_controller[ctr->cnr - 1] = NULL; 572 ncontrollers--; 573 574 if (ctr->procent) 575 remove_proc_entry(ctr->procfn, NULL); 576 577 printk(KERN_NOTICE "kcapi: controller [%03d]: %s unregistered\n", 578 ctr->cnr, ctr->name); 579 580 unlock_out: 581 mutex_unlock(&capi_controller_lock); 582 583 return err; 584 } 585 586 EXPORT_SYMBOL(detach_capi_ctr); 587 588 /** 589 * register_capi_driver() - register CAPI driver 590 * @driver: driver descriptor structure. 591 * 592 * Called by hardware driver to register itself with the CAPI subsystem. 593 */ 594 595 void register_capi_driver(struct capi_driver *driver) 596 { 597 mutex_lock(&capi_drivers_lock); 598 list_add_tail(&driver->list, &capi_drivers); 599 mutex_unlock(&capi_drivers_lock); 600 } 601 602 EXPORT_SYMBOL(register_capi_driver); 603 604 /** 605 * unregister_capi_driver() - unregister CAPI driver 606 * @driver: driver descriptor structure. 607 * 608 * Called by hardware driver to unregister itself from the CAPI subsystem. 609 */ 610 611 void unregister_capi_driver(struct capi_driver *driver) 612 { 613 mutex_lock(&capi_drivers_lock); 614 list_del(&driver->list); 615 mutex_unlock(&capi_drivers_lock); 616 } 617 618 EXPORT_SYMBOL(unregister_capi_driver); 619 620 /* ------------------------------------------------------------- */ 621 /* -------- CAPI2.0 Interface ---------------------------------- */ 622 /* ------------------------------------------------------------- */ 623 624 /** 625 * capi20_isinstalled() - CAPI 2.0 operation CAPI_INSTALLED 626 * 627 * Return value: CAPI result code (CAPI_NOERROR if at least one ISDN controller 628 * is ready for use, CAPI_REGNOTINSTALLED otherwise) 629 */ 630 631 u16 capi20_isinstalled(void) 632 { 633 u16 ret = CAPI_REGNOTINSTALLED; 634 int i; 635 636 mutex_lock(&capi_controller_lock); 637 638 for (i = 0; i < CAPI_MAXCONTR; i++) 639 if (capi_controller[i] && 640 capi_controller[i]->state == CAPI_CTR_RUNNING) { 641 ret = CAPI_NOERROR; 642 break; 643 } 644 645 mutex_unlock(&capi_controller_lock); 646 647 return ret; 648 } 649 650 EXPORT_SYMBOL(capi20_isinstalled); 651 652 /** 653 * capi20_register() - CAPI 2.0 operation CAPI_REGISTER 654 * @ap: CAPI application descriptor structure. 655 * 656 * Register an application's presence with CAPI. 657 * A unique application ID is assigned and stored in @ap->applid. 658 * After this function returns successfully, the message receive 659 * callback function @ap->recv_message() may be called at any time 660 * until capi20_release() has been called for the same @ap. 661 * Return value: CAPI result code 662 */ 663 664 u16 capi20_register(struct capi20_appl *ap) 665 { 666 int i; 667 u16 applid; 668 669 DBG(""); 670 671 if (ap->rparam.datablklen < 128) 672 return CAPI_LOGBLKSIZETOSMALL; 673 674 ap->nrecvctlpkt = 0; 675 ap->nrecvdatapkt = 0; 676 ap->nsentctlpkt = 0; 677 ap->nsentdatapkt = 0; 678 mutex_init(&ap->recv_mtx); 679 skb_queue_head_init(&ap->recv_queue); 680 INIT_WORK(&ap->recv_work, recv_handler); 681 ap->release_in_progress = 0; 682 683 mutex_lock(&capi_controller_lock); 684 685 for (applid = 1; applid <= CAPI_MAXAPPL; applid++) { 686 if (capi_applications[applid - 1] == NULL) 687 break; 688 } 689 if (applid > CAPI_MAXAPPL) { 690 mutex_unlock(&capi_controller_lock); 691 return CAPI_TOOMANYAPPLS; 692 } 693 694 ap->applid = applid; 695 capi_applications[applid - 1] = ap; 696 697 for (i = 0; i < CAPI_MAXCONTR; i++) { 698 if (!capi_controller[i] || 699 capi_controller[i]->state != CAPI_CTR_RUNNING) 700 continue; 701 register_appl(capi_controller[i], applid, &ap->rparam); 702 } 703 704 mutex_unlock(&capi_controller_lock); 705 706 if (showcapimsgs & 1) { 707 printk(KERN_DEBUG "kcapi: appl %d up\n", applid); 708 } 709 710 return CAPI_NOERROR; 711 } 712 713 EXPORT_SYMBOL(capi20_register); 714 715 /** 716 * capi20_release() - CAPI 2.0 operation CAPI_RELEASE 717 * @ap: CAPI application descriptor structure. 718 * 719 * Terminate an application's registration with CAPI. 720 * After this function returns successfully, the message receive 721 * callback function @ap->recv_message() will no longer be called. 722 * Return value: CAPI result code 723 */ 724 725 u16 capi20_release(struct capi20_appl *ap) 726 { 727 int i; 728 729 DBG("applid %#x", ap->applid); 730 731 mutex_lock(&capi_controller_lock); 732 733 ap->release_in_progress = 1; 734 capi_applications[ap->applid - 1] = NULL; 735 736 synchronize_rcu(); 737 738 for (i = 0; i < CAPI_MAXCONTR; i++) { 739 if (!capi_controller[i] || 740 capi_controller[i]->state != CAPI_CTR_RUNNING) 741 continue; 742 release_appl(capi_controller[i], ap->applid); 743 } 744 745 mutex_unlock(&capi_controller_lock); 746 747 flush_workqueue(kcapi_wq); 748 skb_queue_purge(&ap->recv_queue); 749 750 if (showcapimsgs & 1) { 751 printk(KERN_DEBUG "kcapi: appl %d down\n", ap->applid); 752 } 753 754 return CAPI_NOERROR; 755 } 756 757 EXPORT_SYMBOL(capi20_release); 758 759 /** 760 * capi20_put_message() - CAPI 2.0 operation CAPI_PUT_MESSAGE 761 * @ap: CAPI application descriptor structure. 762 * @skb: CAPI message. 763 * 764 * Transfer a single message to CAPI. 765 * Return value: CAPI result code 766 */ 767 768 u16 capi20_put_message(struct capi20_appl *ap, struct sk_buff *skb) 769 { 770 struct capi_ctr *ctr; 771 int showctl = 0; 772 u8 cmd, subcmd; 773 774 DBG("applid %#x", ap->applid); 775 776 if (ncontrollers == 0) 777 return CAPI_REGNOTINSTALLED; 778 if ((ap->applid == 0) || ap->release_in_progress) 779 return CAPI_ILLAPPNR; 780 if (skb->len < 12 781 || !capi_cmd_valid(CAPIMSG_COMMAND(skb->data)) 782 || !capi_subcmd_valid(CAPIMSG_SUBCOMMAND(skb->data))) 783 return CAPI_ILLCMDORSUBCMDORMSGTOSMALL; 784 785 /* 786 * The controller reference is protected by the existence of the 787 * application passed to us. We assume that the caller properly 788 * synchronizes this service with capi20_release. 789 */ 790 ctr = get_capi_ctr_by_nr(CAPIMSG_CONTROLLER(skb->data)); 791 if (!ctr || ctr->state != CAPI_CTR_RUNNING) 792 return CAPI_REGNOTINSTALLED; 793 if (ctr->blocked) 794 return CAPI_SENDQUEUEFULL; 795 796 cmd = CAPIMSG_COMMAND(skb->data); 797 subcmd = CAPIMSG_SUBCOMMAND(skb->data); 798 799 if (cmd == CAPI_DATA_B3 && subcmd == CAPI_REQ) { 800 ctr->nsentdatapkt++; 801 ap->nsentdatapkt++; 802 if (ctr->traceflag > 2) 803 showctl |= 2; 804 } else { 805 ctr->nsentctlpkt++; 806 ap->nsentctlpkt++; 807 if (ctr->traceflag) 808 showctl |= 2; 809 } 810 showctl |= (ctr->traceflag & 1); 811 if (showctl & 2) { 812 if (showctl & 1) { 813 printk(KERN_DEBUG "kcapi: put [%03d] id#%d %s len=%u\n", 814 CAPIMSG_CONTROLLER(skb->data), 815 CAPIMSG_APPID(skb->data), 816 capi_cmd2str(cmd, subcmd), 817 CAPIMSG_LEN(skb->data)); 818 } else { 819 _cdebbuf *cdb = capi_message2str(skb->data); 820 if (cdb) { 821 printk(KERN_DEBUG "kcapi: put [%03d] %s\n", 822 CAPIMSG_CONTROLLER(skb->data), 823 cdb->buf); 824 cdebbuf_free(cdb); 825 } else 826 printk(KERN_DEBUG "kcapi: put [%03d] id#%d %s len=%u cannot trace\n", 827 CAPIMSG_CONTROLLER(skb->data), 828 CAPIMSG_APPID(skb->data), 829 capi_cmd2str(cmd, subcmd), 830 CAPIMSG_LEN(skb->data)); 831 } 832 } 833 return ctr->send_message(ctr, skb); 834 } 835 836 EXPORT_SYMBOL(capi20_put_message); 837 838 /** 839 * capi20_get_manufacturer() - CAPI 2.0 operation CAPI_GET_MANUFACTURER 840 * @contr: controller number. 841 * @buf: result buffer (64 bytes). 842 * 843 * Retrieve information about the manufacturer of the specified ISDN controller 844 * or (for @contr == 0) the driver itself. 845 * Return value: CAPI result code 846 */ 847 848 u16 capi20_get_manufacturer(u32 contr, u8 *buf) 849 { 850 struct capi_ctr *ctr; 851 u16 ret; 852 853 if (contr == 0) { 854 strlcpy(buf, capi_manufakturer, CAPI_MANUFACTURER_LEN); 855 return CAPI_NOERROR; 856 } 857 858 mutex_lock(&capi_controller_lock); 859 860 ctr = get_capi_ctr_by_nr(contr); 861 if (ctr && ctr->state == CAPI_CTR_RUNNING) { 862 strlcpy(buf, ctr->manu, CAPI_MANUFACTURER_LEN); 863 ret = CAPI_NOERROR; 864 } else 865 ret = CAPI_REGNOTINSTALLED; 866 867 mutex_unlock(&capi_controller_lock); 868 return ret; 869 } 870 871 EXPORT_SYMBOL(capi20_get_manufacturer); 872 873 /** 874 * capi20_get_version() - CAPI 2.0 operation CAPI_GET_VERSION 875 * @contr: controller number. 876 * @verp: result structure. 877 * 878 * Retrieve version information for the specified ISDN controller 879 * or (for @contr == 0) the driver itself. 880 * Return value: CAPI result code 881 */ 882 883 u16 capi20_get_version(u32 contr, struct capi_version *verp) 884 { 885 struct capi_ctr *ctr; 886 u16 ret; 887 888 if (contr == 0) { 889 *verp = driver_version; 890 return CAPI_NOERROR; 891 } 892 893 mutex_lock(&capi_controller_lock); 894 895 ctr = get_capi_ctr_by_nr(contr); 896 if (ctr && ctr->state == CAPI_CTR_RUNNING) { 897 memcpy(verp, &ctr->version, sizeof(capi_version)); 898 ret = CAPI_NOERROR; 899 } else 900 ret = CAPI_REGNOTINSTALLED; 901 902 mutex_unlock(&capi_controller_lock); 903 return ret; 904 } 905 906 EXPORT_SYMBOL(capi20_get_version); 907 908 /** 909 * capi20_get_serial() - CAPI 2.0 operation CAPI_GET_SERIAL_NUMBER 910 * @contr: controller number. 911 * @serial: result buffer (8 bytes). 912 * 913 * Retrieve the serial number of the specified ISDN controller 914 * or (for @contr == 0) the driver itself. 915 * Return value: CAPI result code 916 */ 917 918 u16 capi20_get_serial(u32 contr, u8 *serial) 919 { 920 struct capi_ctr *ctr; 921 u16 ret; 922 923 if (contr == 0) { 924 strlcpy(serial, driver_serial, CAPI_SERIAL_LEN); 925 return CAPI_NOERROR; 926 } 927 928 mutex_lock(&capi_controller_lock); 929 930 ctr = get_capi_ctr_by_nr(contr); 931 if (ctr && ctr->state == CAPI_CTR_RUNNING) { 932 strlcpy(serial, ctr->serial, CAPI_SERIAL_LEN); 933 ret = CAPI_NOERROR; 934 } else 935 ret = CAPI_REGNOTINSTALLED; 936 937 mutex_unlock(&capi_controller_lock); 938 return ret; 939 } 940 941 EXPORT_SYMBOL(capi20_get_serial); 942 943 /** 944 * capi20_get_profile() - CAPI 2.0 operation CAPI_GET_PROFILE 945 * @contr: controller number. 946 * @profp: result structure. 947 * 948 * Retrieve capability information for the specified ISDN controller 949 * or (for @contr == 0) the number of installed controllers. 950 * Return value: CAPI result code 951 */ 952 953 u16 capi20_get_profile(u32 contr, struct capi_profile *profp) 954 { 955 struct capi_ctr *ctr; 956 u16 ret; 957 958 if (contr == 0) { 959 profp->ncontroller = ncontrollers; 960 return CAPI_NOERROR; 961 } 962 963 mutex_lock(&capi_controller_lock); 964 965 ctr = get_capi_ctr_by_nr(contr); 966 if (ctr && ctr->state == CAPI_CTR_RUNNING) { 967 memcpy(profp, &ctr->profile, sizeof(struct capi_profile)); 968 ret = CAPI_NOERROR; 969 } else 970 ret = CAPI_REGNOTINSTALLED; 971 972 mutex_unlock(&capi_controller_lock); 973 return ret; 974 } 975 976 EXPORT_SYMBOL(capi20_get_profile); 977 978 /* Must be called with capi_controller_lock held. */ 979 static int wait_on_ctr_state(struct capi_ctr *ctr, unsigned int state) 980 { 981 DEFINE_WAIT(wait); 982 int retval = 0; 983 984 ctr = capi_ctr_get(ctr); 985 if (!ctr) 986 return -ESRCH; 987 988 for (;;) { 989 prepare_to_wait(&ctr->state_wait_queue, &wait, 990 TASK_INTERRUPTIBLE); 991 992 if (ctr->state == state) 993 break; 994 if (ctr->state == CAPI_CTR_DETACHED) { 995 retval = -ESRCH; 996 break; 997 } 998 if (signal_pending(current)) { 999 retval = -EINTR; 1000 break; 1001 } 1002 1003 mutex_unlock(&capi_controller_lock); 1004 schedule(); 1005 mutex_lock(&capi_controller_lock); 1006 } 1007 finish_wait(&ctr->state_wait_queue, &wait); 1008 1009 capi_ctr_put(ctr); 1010 1011 return retval; 1012 } 1013 1014 #ifdef AVMB1_COMPAT 1015 static int old_capi_manufacturer(unsigned int cmd, void __user *data) 1016 { 1017 avmb1_loadandconfigdef ldef; 1018 avmb1_extcarddef cdef; 1019 avmb1_resetdef rdef; 1020 capicardparams cparams; 1021 struct capi_ctr *ctr; 1022 struct capi_driver *driver = NULL; 1023 capiloaddata ldata; 1024 struct list_head *l; 1025 int retval; 1026 1027 switch (cmd) { 1028 case AVMB1_ADDCARD: 1029 case AVMB1_ADDCARD_WITH_TYPE: 1030 if (cmd == AVMB1_ADDCARD) { 1031 if ((retval = copy_from_user(&cdef, data, 1032 sizeof(avmb1_carddef)))) 1033 return -EFAULT; 1034 cdef.cardtype = AVM_CARDTYPE_B1; 1035 } else { 1036 if ((retval = copy_from_user(&cdef, data, 1037 sizeof(avmb1_extcarddef)))) 1038 return -EFAULT; 1039 } 1040 cparams.port = cdef.port; 1041 cparams.irq = cdef.irq; 1042 cparams.cardnr = cdef.cardnr; 1043 1044 mutex_lock(&capi_drivers_lock); 1045 1046 switch (cdef.cardtype) { 1047 case AVM_CARDTYPE_B1: 1048 list_for_each(l, &capi_drivers) { 1049 driver = list_entry(l, struct capi_driver, list); 1050 if (strcmp(driver->name, "b1isa") == 0) 1051 break; 1052 } 1053 break; 1054 case AVM_CARDTYPE_T1: 1055 list_for_each(l, &capi_drivers) { 1056 driver = list_entry(l, struct capi_driver, list); 1057 if (strcmp(driver->name, "t1isa") == 0) 1058 break; 1059 } 1060 break; 1061 default: 1062 driver = NULL; 1063 break; 1064 } 1065 if (!driver) { 1066 printk(KERN_ERR "kcapi: driver not loaded.\n"); 1067 retval = -EIO; 1068 } else if (!driver->add_card) { 1069 printk(KERN_ERR "kcapi: driver has no add card function.\n"); 1070 retval = -EIO; 1071 } else 1072 retval = driver->add_card(driver, &cparams); 1073 1074 mutex_unlock(&capi_drivers_lock); 1075 return retval; 1076 1077 case AVMB1_LOAD: 1078 case AVMB1_LOAD_AND_CONFIG: 1079 1080 if (cmd == AVMB1_LOAD) { 1081 if (copy_from_user(&ldef, data, 1082 sizeof(avmb1_loaddef))) 1083 return -EFAULT; 1084 ldef.t4config.len = 0; 1085 ldef.t4config.data = NULL; 1086 } else { 1087 if (copy_from_user(&ldef, data, 1088 sizeof(avmb1_loadandconfigdef))) 1089 return -EFAULT; 1090 } 1091 1092 mutex_lock(&capi_controller_lock); 1093 1094 ctr = get_capi_ctr_by_nr(ldef.contr); 1095 if (!ctr) { 1096 retval = -EINVAL; 1097 goto load_unlock_out; 1098 } 1099 1100 if (ctr->load_firmware == NULL) { 1101 printk(KERN_DEBUG "kcapi: load: no load function\n"); 1102 retval = -ESRCH; 1103 goto load_unlock_out; 1104 } 1105 1106 if (ldef.t4file.len <= 0) { 1107 printk(KERN_DEBUG "kcapi: load: invalid parameter: length of t4file is %d ?\n", ldef.t4file.len); 1108 retval = -EINVAL; 1109 goto load_unlock_out; 1110 } 1111 if (ldef.t4file.data == NULL) { 1112 printk(KERN_DEBUG "kcapi: load: invalid parameter: dataptr is 0\n"); 1113 retval = -EINVAL; 1114 goto load_unlock_out; 1115 } 1116 1117 ldata.firmware.user = 1; 1118 ldata.firmware.data = ldef.t4file.data; 1119 ldata.firmware.len = ldef.t4file.len; 1120 ldata.configuration.user = 1; 1121 ldata.configuration.data = ldef.t4config.data; 1122 ldata.configuration.len = ldef.t4config.len; 1123 1124 if (ctr->state != CAPI_CTR_DETECTED) { 1125 printk(KERN_INFO "kcapi: load: contr=%d not in detect state\n", ldef.contr); 1126 retval = -EBUSY; 1127 goto load_unlock_out; 1128 } 1129 ctr->state = CAPI_CTR_LOADING; 1130 1131 retval = ctr->load_firmware(ctr, &ldata); 1132 if (retval) { 1133 ctr->state = CAPI_CTR_DETECTED; 1134 goto load_unlock_out; 1135 } 1136 1137 retval = wait_on_ctr_state(ctr, CAPI_CTR_RUNNING); 1138 1139 load_unlock_out: 1140 mutex_unlock(&capi_controller_lock); 1141 return retval; 1142 1143 case AVMB1_RESETCARD: 1144 if (copy_from_user(&rdef, data, sizeof(avmb1_resetdef))) 1145 return -EFAULT; 1146 1147 retval = 0; 1148 1149 mutex_lock(&capi_controller_lock); 1150 1151 ctr = get_capi_ctr_by_nr(rdef.contr); 1152 if (!ctr) { 1153 retval = -ESRCH; 1154 goto reset_unlock_out; 1155 } 1156 1157 if (ctr->state == CAPI_CTR_DETECTED) 1158 goto reset_unlock_out; 1159 1160 if (ctr->reset_ctr == NULL) { 1161 printk(KERN_DEBUG "kcapi: reset: no reset function\n"); 1162 retval = -ESRCH; 1163 goto reset_unlock_out; 1164 } 1165 1166 ctr->reset_ctr(ctr); 1167 1168 retval = wait_on_ctr_state(ctr, CAPI_CTR_DETECTED); 1169 1170 reset_unlock_out: 1171 mutex_unlock(&capi_controller_lock); 1172 return retval; 1173 } 1174 return -EINVAL; 1175 } 1176 #endif 1177 1178 /** 1179 * capi20_manufacturer() - CAPI 2.0 operation CAPI_MANUFACTURER 1180 * @cmd: command. 1181 * @data: parameter. 1182 * 1183 * Perform manufacturer specific command. 1184 * Return value: CAPI result code 1185 */ 1186 1187 int capi20_manufacturer(unsigned int cmd, void __user *data) 1188 { 1189 struct capi_ctr *ctr; 1190 int retval; 1191 1192 switch (cmd) { 1193 #ifdef AVMB1_COMPAT 1194 case AVMB1_LOAD: 1195 case AVMB1_LOAD_AND_CONFIG: 1196 case AVMB1_RESETCARD: 1197 case AVMB1_GET_CARDINFO: 1198 case AVMB1_REMOVECARD: 1199 return old_capi_manufacturer(cmd, data); 1200 #endif 1201 case KCAPI_CMD_TRACE: 1202 { 1203 kcapi_flagdef fdef; 1204 1205 if (copy_from_user(&fdef, data, sizeof(kcapi_flagdef))) 1206 return -EFAULT; 1207 1208 mutex_lock(&capi_controller_lock); 1209 1210 ctr = get_capi_ctr_by_nr(fdef.contr); 1211 if (ctr) { 1212 ctr->traceflag = fdef.flag; 1213 printk(KERN_INFO "kcapi: contr [%03d] set trace=%d\n", 1214 ctr->cnr, ctr->traceflag); 1215 retval = 0; 1216 } else 1217 retval = -ESRCH; 1218 1219 mutex_unlock(&capi_controller_lock); 1220 1221 return retval; 1222 } 1223 case KCAPI_CMD_ADDCARD: 1224 { 1225 struct list_head *l; 1226 struct capi_driver *driver = NULL; 1227 capicardparams cparams; 1228 kcapi_carddef cdef; 1229 1230 if ((retval = copy_from_user(&cdef, data, sizeof(cdef)))) 1231 return -EFAULT; 1232 1233 cparams.port = cdef.port; 1234 cparams.irq = cdef.irq; 1235 cparams.membase = cdef.membase; 1236 cparams.cardnr = cdef.cardnr; 1237 cparams.cardtype = 0; 1238 cdef.driver[sizeof(cdef.driver) - 1] = 0; 1239 1240 mutex_lock(&capi_drivers_lock); 1241 1242 list_for_each(l, &capi_drivers) { 1243 driver = list_entry(l, struct capi_driver, list); 1244 if (strcmp(driver->name, cdef.driver) == 0) 1245 break; 1246 } 1247 if (driver == NULL) { 1248 printk(KERN_ERR "kcapi: driver \"%s\" not loaded.\n", 1249 cdef.driver); 1250 retval = -ESRCH; 1251 } else if (!driver->add_card) { 1252 printk(KERN_ERR "kcapi: driver \"%s\" has no add card function.\n", cdef.driver); 1253 retval = -EIO; 1254 } else 1255 retval = driver->add_card(driver, &cparams); 1256 1257 mutex_unlock(&capi_drivers_lock); 1258 return retval; 1259 } 1260 1261 default: 1262 printk(KERN_ERR "kcapi: manufacturer command %d unknown.\n", 1263 cmd); 1264 break; 1265 1266 } 1267 return -EINVAL; 1268 } 1269 1270 EXPORT_SYMBOL(capi20_manufacturer); 1271 1272 /* ------------------------------------------------------------- */ 1273 /* -------- Init & Cleanup ------------------------------------- */ 1274 /* ------------------------------------------------------------- */ 1275 1276 /* 1277 * init / exit functions 1278 */ 1279 1280 static struct notifier_block capictr_nb = { 1281 .notifier_call = notify_handler, 1282 .priority = INT_MAX, 1283 }; 1284 1285 static int __init kcapi_init(void) 1286 { 1287 int err; 1288 1289 kcapi_wq = alloc_workqueue("kcapi", 0, 0); 1290 if (!kcapi_wq) 1291 return -ENOMEM; 1292 1293 register_capictr_notifier(&capictr_nb); 1294 1295 err = cdebug_init(); 1296 if (err) { 1297 unregister_capictr_notifier(&capictr_nb); 1298 destroy_workqueue(kcapi_wq); 1299 return err; 1300 } 1301 1302 kcapi_proc_init(); 1303 return 0; 1304 } 1305 1306 static void __exit kcapi_exit(void) 1307 { 1308 kcapi_proc_exit(); 1309 1310 unregister_capictr_notifier(&capictr_nb); 1311 cdebug_exit(); 1312 destroy_workqueue(kcapi_wq); 1313 } 1314 1315 module_init(kcapi_init); 1316 module_exit(kcapi_exit); 1317