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