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