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