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/signal.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 <linux/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 const 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_single_data(ctr->procfn, 0, NULL, 538 ctr->proc_show, ctr); 539 540 ncontrollers++; 541 542 mutex_unlock(&capi_controller_lock); 543 544 printk(KERN_NOTICE "kcapi: controller [%03d]: %s attached\n", 545 ctr->cnr, ctr->name); 546 return 0; 547 } 548 549 EXPORT_SYMBOL(attach_capi_ctr); 550 551 /** 552 * detach_capi_ctr() - unregister CAPI controller 553 * @ctr: controller descriptor structure. 554 * 555 * Called by hardware driver to remove the registration of a controller 556 * with the CAPI subsystem. 557 * Return value: 0 on success, error code < 0 on error 558 */ 559 560 int detach_capi_ctr(struct capi_ctr *ctr) 561 { 562 int err = 0; 563 564 mutex_lock(&capi_controller_lock); 565 566 ctr_down(ctr, CAPI_CTR_DETACHED); 567 568 if (capi_controller[ctr->cnr - 1] != ctr) { 569 err = -EINVAL; 570 goto unlock_out; 571 } 572 capi_controller[ctr->cnr - 1] = NULL; 573 ncontrollers--; 574 575 if (ctr->procent) 576 remove_proc_entry(ctr->procfn, NULL); 577 578 printk(KERN_NOTICE "kcapi: controller [%03d]: %s unregistered\n", 579 ctr->cnr, ctr->name); 580 581 unlock_out: 582 mutex_unlock(&capi_controller_lock); 583 584 return err; 585 } 586 587 EXPORT_SYMBOL(detach_capi_ctr); 588 589 /** 590 * register_capi_driver() - register CAPI driver 591 * @driver: driver descriptor structure. 592 * 593 * Called by hardware driver to register itself with the CAPI subsystem. 594 */ 595 596 void register_capi_driver(struct capi_driver *driver) 597 { 598 mutex_lock(&capi_drivers_lock); 599 list_add_tail(&driver->list, &capi_drivers); 600 mutex_unlock(&capi_drivers_lock); 601 } 602 603 EXPORT_SYMBOL(register_capi_driver); 604 605 /** 606 * unregister_capi_driver() - unregister CAPI driver 607 * @driver: driver descriptor structure. 608 * 609 * Called by hardware driver to unregister itself from the CAPI subsystem. 610 */ 611 612 void unregister_capi_driver(struct capi_driver *driver) 613 { 614 mutex_lock(&capi_drivers_lock); 615 list_del(&driver->list); 616 mutex_unlock(&capi_drivers_lock); 617 } 618 619 EXPORT_SYMBOL(unregister_capi_driver); 620 621 /* ------------------------------------------------------------- */ 622 /* -------- CAPI2.0 Interface ---------------------------------- */ 623 /* ------------------------------------------------------------- */ 624 625 /** 626 * capi20_isinstalled() - CAPI 2.0 operation CAPI_INSTALLED 627 * 628 * Return value: CAPI result code (CAPI_NOERROR if at least one ISDN controller 629 * is ready for use, CAPI_REGNOTINSTALLED otherwise) 630 */ 631 632 u16 capi20_isinstalled(void) 633 { 634 u16 ret = CAPI_REGNOTINSTALLED; 635 int i; 636 637 mutex_lock(&capi_controller_lock); 638 639 for (i = 0; i < CAPI_MAXCONTR; i++) 640 if (capi_controller[i] && 641 capi_controller[i]->state == CAPI_CTR_RUNNING) { 642 ret = CAPI_NOERROR; 643 break; 644 } 645 646 mutex_unlock(&capi_controller_lock); 647 648 return ret; 649 } 650 651 EXPORT_SYMBOL(capi20_isinstalled); 652 653 /** 654 * capi20_register() - CAPI 2.0 operation CAPI_REGISTER 655 * @ap: CAPI application descriptor structure. 656 * 657 * Register an application's presence with CAPI. 658 * A unique application ID is assigned and stored in @ap->applid. 659 * After this function returns successfully, the message receive 660 * callback function @ap->recv_message() may be called at any time 661 * until capi20_release() has been called for the same @ap. 662 * Return value: CAPI result code 663 */ 664 665 u16 capi20_register(struct capi20_appl *ap) 666 { 667 int i; 668 u16 applid; 669 670 DBG(""); 671 672 if (ap->rparam.datablklen < 128) 673 return CAPI_LOGBLKSIZETOSMALL; 674 675 ap->nrecvctlpkt = 0; 676 ap->nrecvdatapkt = 0; 677 ap->nsentctlpkt = 0; 678 ap->nsentdatapkt = 0; 679 mutex_init(&ap->recv_mtx); 680 skb_queue_head_init(&ap->recv_queue); 681 INIT_WORK(&ap->recv_work, recv_handler); 682 ap->release_in_progress = 0; 683 684 mutex_lock(&capi_controller_lock); 685 686 for (applid = 1; applid <= CAPI_MAXAPPL; applid++) { 687 if (capi_applications[applid - 1] == NULL) 688 break; 689 } 690 if (applid > CAPI_MAXAPPL) { 691 mutex_unlock(&capi_controller_lock); 692 return CAPI_TOOMANYAPPLS; 693 } 694 695 ap->applid = applid; 696 capi_applications[applid - 1] = ap; 697 698 for (i = 0; i < CAPI_MAXCONTR; i++) { 699 if (!capi_controller[i] || 700 capi_controller[i]->state != CAPI_CTR_RUNNING) 701 continue; 702 register_appl(capi_controller[i], applid, &ap->rparam); 703 } 704 705 mutex_unlock(&capi_controller_lock); 706 707 if (showcapimsgs & 1) { 708 printk(KERN_DEBUG "kcapi: appl %d up\n", applid); 709 } 710 711 return CAPI_NOERROR; 712 } 713 714 EXPORT_SYMBOL(capi20_register); 715 716 /** 717 * capi20_release() - CAPI 2.0 operation CAPI_RELEASE 718 * @ap: CAPI application descriptor structure. 719 * 720 * Terminate an application's registration with CAPI. 721 * After this function returns successfully, the message receive 722 * callback function @ap->recv_message() will no longer be called. 723 * Return value: CAPI result code 724 */ 725 726 u16 capi20_release(struct capi20_appl *ap) 727 { 728 int i; 729 730 DBG("applid %#x", ap->applid); 731 732 mutex_lock(&capi_controller_lock); 733 734 ap->release_in_progress = 1; 735 capi_applications[ap->applid - 1] = NULL; 736 737 synchronize_rcu(); 738 739 for (i = 0; i < CAPI_MAXCONTR; i++) { 740 if (!capi_controller[i] || 741 capi_controller[i]->state != CAPI_CTR_RUNNING) 742 continue; 743 release_appl(capi_controller[i], ap->applid); 744 } 745 746 mutex_unlock(&capi_controller_lock); 747 748 flush_workqueue(kcapi_wq); 749 skb_queue_purge(&ap->recv_queue); 750 751 if (showcapimsgs & 1) { 752 printk(KERN_DEBUG "kcapi: appl %d down\n", ap->applid); 753 } 754 755 return CAPI_NOERROR; 756 } 757 758 EXPORT_SYMBOL(capi20_release); 759 760 /** 761 * capi20_put_message() - CAPI 2.0 operation CAPI_PUT_MESSAGE 762 * @ap: CAPI application descriptor structure. 763 * @skb: CAPI message. 764 * 765 * Transfer a single message to CAPI. 766 * Return value: CAPI result code 767 */ 768 769 u16 capi20_put_message(struct capi20_appl *ap, struct sk_buff *skb) 770 { 771 struct capi_ctr *ctr; 772 int showctl = 0; 773 u8 cmd, subcmd; 774 775 DBG("applid %#x", ap->applid); 776 777 if (ncontrollers == 0) 778 return CAPI_REGNOTINSTALLED; 779 if ((ap->applid == 0) || ap->release_in_progress) 780 return CAPI_ILLAPPNR; 781 if (skb->len < 12 782 || !capi_cmd_valid(CAPIMSG_COMMAND(skb->data)) 783 || !capi_subcmd_valid(CAPIMSG_SUBCOMMAND(skb->data))) 784 return CAPI_ILLCMDORSUBCMDORMSGTOSMALL; 785 786 /* 787 * The controller reference is protected by the existence of the 788 * application passed to us. We assume that the caller properly 789 * synchronizes this service with capi20_release. 790 */ 791 ctr = get_capi_ctr_by_nr(CAPIMSG_CONTROLLER(skb->data)); 792 if (!ctr || ctr->state != CAPI_CTR_RUNNING) 793 return CAPI_REGNOTINSTALLED; 794 if (ctr->blocked) 795 return CAPI_SENDQUEUEFULL; 796 797 cmd = CAPIMSG_COMMAND(skb->data); 798 subcmd = CAPIMSG_SUBCOMMAND(skb->data); 799 800 if (cmd == CAPI_DATA_B3 && subcmd == CAPI_REQ) { 801 ctr->nsentdatapkt++; 802 ap->nsentdatapkt++; 803 if (ctr->traceflag > 2) 804 showctl |= 2; 805 } else { 806 ctr->nsentctlpkt++; 807 ap->nsentctlpkt++; 808 if (ctr->traceflag) 809 showctl |= 2; 810 } 811 showctl |= (ctr->traceflag & 1); 812 if (showctl & 2) { 813 if (showctl & 1) { 814 printk(KERN_DEBUG "kcapi: put [%03d] id#%d %s len=%u\n", 815 CAPIMSG_CONTROLLER(skb->data), 816 CAPIMSG_APPID(skb->data), 817 capi_cmd2str(cmd, subcmd), 818 CAPIMSG_LEN(skb->data)); 819 } else { 820 _cdebbuf *cdb = capi_message2str(skb->data); 821 if (cdb) { 822 printk(KERN_DEBUG "kcapi: put [%03d] %s\n", 823 CAPIMSG_CONTROLLER(skb->data), 824 cdb->buf); 825 cdebbuf_free(cdb); 826 } else 827 printk(KERN_DEBUG "kcapi: put [%03d] id#%d %s len=%u cannot trace\n", 828 CAPIMSG_CONTROLLER(skb->data), 829 CAPIMSG_APPID(skb->data), 830 capi_cmd2str(cmd, subcmd), 831 CAPIMSG_LEN(skb->data)); 832 } 833 } 834 return ctr->send_message(ctr, skb); 835 } 836 837 EXPORT_SYMBOL(capi20_put_message); 838 839 /** 840 * capi20_get_manufacturer() - CAPI 2.0 operation CAPI_GET_MANUFACTURER 841 * @contr: controller number. 842 * @buf: result buffer (64 bytes). 843 * 844 * Retrieve information about the manufacturer of the specified ISDN controller 845 * or (for @contr == 0) the driver itself. 846 * Return value: CAPI result code 847 */ 848 849 u16 capi20_get_manufacturer(u32 contr, u8 *buf) 850 { 851 struct capi_ctr *ctr; 852 u16 ret; 853 854 if (contr == 0) { 855 strlcpy(buf, capi_manufakturer, CAPI_MANUFACTURER_LEN); 856 return CAPI_NOERROR; 857 } 858 859 mutex_lock(&capi_controller_lock); 860 861 ctr = get_capi_ctr_by_nr(contr); 862 if (ctr && ctr->state == CAPI_CTR_RUNNING) { 863 strlcpy(buf, ctr->manu, CAPI_MANUFACTURER_LEN); 864 ret = CAPI_NOERROR; 865 } else 866 ret = CAPI_REGNOTINSTALLED; 867 868 mutex_unlock(&capi_controller_lock); 869 return ret; 870 } 871 872 EXPORT_SYMBOL(capi20_get_manufacturer); 873 874 /** 875 * capi20_get_version() - CAPI 2.0 operation CAPI_GET_VERSION 876 * @contr: controller number. 877 * @verp: result structure. 878 * 879 * Retrieve version information for the specified ISDN controller 880 * or (for @contr == 0) the driver itself. 881 * Return value: CAPI result code 882 */ 883 884 u16 capi20_get_version(u32 contr, struct capi_version *verp) 885 { 886 struct capi_ctr *ctr; 887 u16 ret; 888 889 if (contr == 0) { 890 *verp = driver_version; 891 return CAPI_NOERROR; 892 } 893 894 mutex_lock(&capi_controller_lock); 895 896 ctr = get_capi_ctr_by_nr(contr); 897 if (ctr && ctr->state == CAPI_CTR_RUNNING) { 898 memcpy(verp, &ctr->version, sizeof(capi_version)); 899 ret = CAPI_NOERROR; 900 } else 901 ret = CAPI_REGNOTINSTALLED; 902 903 mutex_unlock(&capi_controller_lock); 904 return ret; 905 } 906 907 EXPORT_SYMBOL(capi20_get_version); 908 909 /** 910 * capi20_get_serial() - CAPI 2.0 operation CAPI_GET_SERIAL_NUMBER 911 * @contr: controller number. 912 * @serial: result buffer (8 bytes). 913 * 914 * Retrieve the serial number of the specified ISDN controller 915 * or (for @contr == 0) the driver itself. 916 * Return value: CAPI result code 917 */ 918 919 u16 capi20_get_serial(u32 contr, u8 *serial) 920 { 921 struct capi_ctr *ctr; 922 u16 ret; 923 924 if (contr == 0) { 925 strlcpy(serial, driver_serial, CAPI_SERIAL_LEN); 926 return CAPI_NOERROR; 927 } 928 929 mutex_lock(&capi_controller_lock); 930 931 ctr = get_capi_ctr_by_nr(contr); 932 if (ctr && ctr->state == CAPI_CTR_RUNNING) { 933 strlcpy(serial, ctr->serial, CAPI_SERIAL_LEN); 934 ret = CAPI_NOERROR; 935 } else 936 ret = CAPI_REGNOTINSTALLED; 937 938 mutex_unlock(&capi_controller_lock); 939 return ret; 940 } 941 942 EXPORT_SYMBOL(capi20_get_serial); 943 944 /** 945 * capi20_get_profile() - CAPI 2.0 operation CAPI_GET_PROFILE 946 * @contr: controller number. 947 * @profp: result structure. 948 * 949 * Retrieve capability information for the specified ISDN controller 950 * or (for @contr == 0) the number of installed controllers. 951 * Return value: CAPI result code 952 */ 953 954 u16 capi20_get_profile(u32 contr, struct capi_profile *profp) 955 { 956 struct capi_ctr *ctr; 957 u16 ret; 958 959 if (contr == 0) { 960 profp->ncontroller = ncontrollers; 961 return CAPI_NOERROR; 962 } 963 964 mutex_lock(&capi_controller_lock); 965 966 ctr = get_capi_ctr_by_nr(contr); 967 if (ctr && ctr->state == CAPI_CTR_RUNNING) { 968 memcpy(profp, &ctr->profile, sizeof(struct capi_profile)); 969 ret = CAPI_NOERROR; 970 } else 971 ret = CAPI_REGNOTINSTALLED; 972 973 mutex_unlock(&capi_controller_lock); 974 return ret; 975 } 976 977 EXPORT_SYMBOL(capi20_get_profile); 978 979 /* Must be called with capi_controller_lock held. */ 980 static int wait_on_ctr_state(struct capi_ctr *ctr, unsigned int state) 981 { 982 DEFINE_WAIT(wait); 983 int retval = 0; 984 985 ctr = capi_ctr_get(ctr); 986 if (!ctr) 987 return -ESRCH; 988 989 for (;;) { 990 prepare_to_wait(&ctr->state_wait_queue, &wait, 991 TASK_INTERRUPTIBLE); 992 993 if (ctr->state == state) 994 break; 995 if (ctr->state == CAPI_CTR_DETACHED) { 996 retval = -ESRCH; 997 break; 998 } 999 if (signal_pending(current)) { 1000 retval = -EINTR; 1001 break; 1002 } 1003 1004 mutex_unlock(&capi_controller_lock); 1005 schedule(); 1006 mutex_lock(&capi_controller_lock); 1007 } 1008 finish_wait(&ctr->state_wait_queue, &wait); 1009 1010 capi_ctr_put(ctr); 1011 1012 return retval; 1013 } 1014 1015 #ifdef AVMB1_COMPAT 1016 static int old_capi_manufacturer(unsigned int cmd, void __user *data) 1017 { 1018 avmb1_loadandconfigdef ldef; 1019 avmb1_extcarddef cdef; 1020 avmb1_resetdef rdef; 1021 capicardparams cparams; 1022 struct capi_ctr *ctr; 1023 struct capi_driver *driver = NULL; 1024 capiloaddata ldata; 1025 struct list_head *l; 1026 int retval; 1027 1028 switch (cmd) { 1029 case AVMB1_ADDCARD: 1030 case AVMB1_ADDCARD_WITH_TYPE: 1031 if (cmd == AVMB1_ADDCARD) { 1032 if ((retval = copy_from_user(&cdef, data, 1033 sizeof(avmb1_carddef)))) 1034 return -EFAULT; 1035 cdef.cardtype = AVM_CARDTYPE_B1; 1036 cdef.cardnr = 0; 1037 } else { 1038 if ((retval = copy_from_user(&cdef, data, 1039 sizeof(avmb1_extcarddef)))) 1040 return -EFAULT; 1041 } 1042 cparams.port = cdef.port; 1043 cparams.irq = cdef.irq; 1044 cparams.cardnr = cdef.cardnr; 1045 1046 mutex_lock(&capi_drivers_lock); 1047 1048 switch (cdef.cardtype) { 1049 case AVM_CARDTYPE_B1: 1050 list_for_each(l, &capi_drivers) { 1051 driver = list_entry(l, struct capi_driver, list); 1052 if (strcmp(driver->name, "b1isa") == 0) 1053 break; 1054 } 1055 break; 1056 case AVM_CARDTYPE_T1: 1057 list_for_each(l, &capi_drivers) { 1058 driver = list_entry(l, struct capi_driver, list); 1059 if (strcmp(driver->name, "t1isa") == 0) 1060 break; 1061 } 1062 break; 1063 default: 1064 driver = NULL; 1065 break; 1066 } 1067 if (!driver) { 1068 printk(KERN_ERR "kcapi: driver not loaded.\n"); 1069 retval = -EIO; 1070 } else if (!driver->add_card) { 1071 printk(KERN_ERR "kcapi: driver has no add card function.\n"); 1072 retval = -EIO; 1073 } else 1074 retval = driver->add_card(driver, &cparams); 1075 1076 mutex_unlock(&capi_drivers_lock); 1077 return retval; 1078 1079 case AVMB1_LOAD: 1080 case AVMB1_LOAD_AND_CONFIG: 1081 1082 if (cmd == AVMB1_LOAD) { 1083 if (copy_from_user(&ldef, data, 1084 sizeof(avmb1_loaddef))) 1085 return -EFAULT; 1086 ldef.t4config.len = 0; 1087 ldef.t4config.data = NULL; 1088 } else { 1089 if (copy_from_user(&ldef, data, 1090 sizeof(avmb1_loadandconfigdef))) 1091 return -EFAULT; 1092 } 1093 1094 mutex_lock(&capi_controller_lock); 1095 1096 ctr = get_capi_ctr_by_nr(ldef.contr); 1097 if (!ctr) { 1098 retval = -EINVAL; 1099 goto load_unlock_out; 1100 } 1101 1102 if (ctr->load_firmware == NULL) { 1103 printk(KERN_DEBUG "kcapi: load: no load function\n"); 1104 retval = -ESRCH; 1105 goto load_unlock_out; 1106 } 1107 1108 if (ldef.t4file.len <= 0) { 1109 printk(KERN_DEBUG "kcapi: load: invalid parameter: length of t4file is %d ?\n", ldef.t4file.len); 1110 retval = -EINVAL; 1111 goto load_unlock_out; 1112 } 1113 if (ldef.t4file.data == NULL) { 1114 printk(KERN_DEBUG "kcapi: load: invalid parameter: dataptr is 0\n"); 1115 retval = -EINVAL; 1116 goto load_unlock_out; 1117 } 1118 1119 ldata.firmware.user = 1; 1120 ldata.firmware.data = ldef.t4file.data; 1121 ldata.firmware.len = ldef.t4file.len; 1122 ldata.configuration.user = 1; 1123 ldata.configuration.data = ldef.t4config.data; 1124 ldata.configuration.len = ldef.t4config.len; 1125 1126 if (ctr->state != CAPI_CTR_DETECTED) { 1127 printk(KERN_INFO "kcapi: load: contr=%d not in detect state\n", ldef.contr); 1128 retval = -EBUSY; 1129 goto load_unlock_out; 1130 } 1131 ctr->state = CAPI_CTR_LOADING; 1132 1133 retval = ctr->load_firmware(ctr, &ldata); 1134 if (retval) { 1135 ctr->state = CAPI_CTR_DETECTED; 1136 goto load_unlock_out; 1137 } 1138 1139 retval = wait_on_ctr_state(ctr, CAPI_CTR_RUNNING); 1140 1141 load_unlock_out: 1142 mutex_unlock(&capi_controller_lock); 1143 return retval; 1144 1145 case AVMB1_RESETCARD: 1146 if (copy_from_user(&rdef, data, sizeof(avmb1_resetdef))) 1147 return -EFAULT; 1148 1149 retval = 0; 1150 1151 mutex_lock(&capi_controller_lock); 1152 1153 ctr = get_capi_ctr_by_nr(rdef.contr); 1154 if (!ctr) { 1155 retval = -ESRCH; 1156 goto reset_unlock_out; 1157 } 1158 1159 if (ctr->state == CAPI_CTR_DETECTED) 1160 goto reset_unlock_out; 1161 1162 if (ctr->reset_ctr == NULL) { 1163 printk(KERN_DEBUG "kcapi: reset: no reset function\n"); 1164 retval = -ESRCH; 1165 goto reset_unlock_out; 1166 } 1167 1168 ctr->reset_ctr(ctr); 1169 1170 retval = wait_on_ctr_state(ctr, CAPI_CTR_DETECTED); 1171 1172 reset_unlock_out: 1173 mutex_unlock(&capi_controller_lock); 1174 return retval; 1175 } 1176 return -EINVAL; 1177 } 1178 #endif 1179 1180 /** 1181 * capi20_manufacturer() - CAPI 2.0 operation CAPI_MANUFACTURER 1182 * @cmd: command. 1183 * @data: parameter. 1184 * 1185 * Perform manufacturer specific command. 1186 * Return value: CAPI result code 1187 */ 1188 1189 int capi20_manufacturer(unsigned long cmd, void __user *data) 1190 { 1191 struct capi_ctr *ctr; 1192 int retval; 1193 1194 switch (cmd) { 1195 #ifdef AVMB1_COMPAT 1196 case AVMB1_LOAD: 1197 case AVMB1_LOAD_AND_CONFIG: 1198 case AVMB1_RESETCARD: 1199 case AVMB1_GET_CARDINFO: 1200 case AVMB1_REMOVECARD: 1201 return old_capi_manufacturer(cmd, data); 1202 #endif 1203 case KCAPI_CMD_TRACE: 1204 { 1205 kcapi_flagdef fdef; 1206 1207 if (copy_from_user(&fdef, data, sizeof(kcapi_flagdef))) 1208 return -EFAULT; 1209 1210 mutex_lock(&capi_controller_lock); 1211 1212 ctr = get_capi_ctr_by_nr(fdef.contr); 1213 if (ctr) { 1214 ctr->traceflag = fdef.flag; 1215 printk(KERN_INFO "kcapi: contr [%03d] set trace=%d\n", 1216 ctr->cnr, ctr->traceflag); 1217 retval = 0; 1218 } else 1219 retval = -ESRCH; 1220 1221 mutex_unlock(&capi_controller_lock); 1222 1223 return retval; 1224 } 1225 case KCAPI_CMD_ADDCARD: 1226 { 1227 struct list_head *l; 1228 struct capi_driver *driver = NULL; 1229 capicardparams cparams; 1230 kcapi_carddef cdef; 1231 1232 if ((retval = copy_from_user(&cdef, data, sizeof(cdef)))) 1233 return -EFAULT; 1234 1235 cparams.port = cdef.port; 1236 cparams.irq = cdef.irq; 1237 cparams.membase = cdef.membase; 1238 cparams.cardnr = cdef.cardnr; 1239 cparams.cardtype = 0; 1240 cdef.driver[sizeof(cdef.driver) - 1] = 0; 1241 1242 mutex_lock(&capi_drivers_lock); 1243 1244 list_for_each(l, &capi_drivers) { 1245 driver = list_entry(l, struct capi_driver, list); 1246 if (strcmp(driver->name, cdef.driver) == 0) 1247 break; 1248 } 1249 if (driver == NULL) { 1250 printk(KERN_ERR "kcapi: driver \"%s\" not loaded.\n", 1251 cdef.driver); 1252 retval = -ESRCH; 1253 } else if (!driver->add_card) { 1254 printk(KERN_ERR "kcapi: driver \"%s\" has no add card function.\n", cdef.driver); 1255 retval = -EIO; 1256 } else 1257 retval = driver->add_card(driver, &cparams); 1258 1259 mutex_unlock(&capi_drivers_lock); 1260 return retval; 1261 } 1262 1263 default: 1264 printk(KERN_ERR "kcapi: manufacturer command %lu unknown.\n", 1265 cmd); 1266 break; 1267 1268 } 1269 return -EINVAL; 1270 } 1271 1272 EXPORT_SYMBOL(capi20_manufacturer); 1273 1274 /* ------------------------------------------------------------- */ 1275 /* -------- Init & Cleanup ------------------------------------- */ 1276 /* ------------------------------------------------------------- */ 1277 1278 /* 1279 * init / exit functions 1280 */ 1281 1282 static struct notifier_block capictr_nb = { 1283 .notifier_call = notify_handler, 1284 .priority = INT_MAX, 1285 }; 1286 1287 static int __init kcapi_init(void) 1288 { 1289 int err; 1290 1291 kcapi_wq = alloc_workqueue("kcapi", 0, 0); 1292 if (!kcapi_wq) 1293 return -ENOMEM; 1294 1295 register_capictr_notifier(&capictr_nb); 1296 1297 err = cdebug_init(); 1298 if (err) { 1299 unregister_capictr_notifier(&capictr_nb); 1300 destroy_workqueue(kcapi_wq); 1301 return err; 1302 } 1303 1304 kcapi_proc_init(); 1305 return 0; 1306 } 1307 1308 static void __exit kcapi_exit(void) 1309 { 1310 kcapi_proc_exit(); 1311 1312 unregister_capictr_notifier(&capictr_nb); 1313 cdebug_exit(); 1314 destroy_workqueue(kcapi_wq); 1315 } 1316 1317 module_init(kcapi_init); 1318 module_exit(kcapi_exit); 1319