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 #include "kcapi.h" 14 #include <linux/module.h> 15 #include <linux/mm.h> 16 #include <linux/interrupt.h> 17 #include <linux/ioport.h> 18 #include <linux/proc_fs.h> 19 #include <linux/sched/signal.h> 20 #include <linux/seq_file.h> 21 #include <linux/skbuff.h> 22 #include <linux/workqueue.h> 23 #include <linux/capi.h> 24 #include <linux/kernelcapi.h> 25 #include <linux/init.h> 26 #include <linux/moduleparam.h> 27 #include <linux/delay.h> 28 #include <linux/slab.h> 29 #include <linux/uaccess.h> 30 #include <linux/isdn/capicmd.h> 31 #include <linux/isdn/capiutil.h> 32 #include <linux/mutex.h> 33 #include <linux/rcupdate.h> 34 35 static int showcapimsgs = 0; 36 static struct workqueue_struct *kcapi_wq; 37 38 module_param(showcapimsgs, uint, 0); 39 40 /* ------------------------------------------------------------- */ 41 42 struct capictr_event { 43 struct work_struct work; 44 unsigned int type; 45 u32 controller; 46 }; 47 48 /* ------------------------------------------------------------- */ 49 50 static const struct capi_version driver_version = {2, 0, 1, 1 << 4}; 51 static char driver_serial[CAPI_SERIAL_LEN] = "0004711"; 52 static char capi_manufakturer[64] = "AVM Berlin"; 53 54 #define NCCI2CTRL(ncci) (((ncci) >> 24) & 0x7f) 55 56 struct capi_ctr *capi_controller[CAPI_MAXCONTR]; 57 DEFINE_MUTEX(capi_controller_lock); 58 59 struct capi20_appl *capi_applications[CAPI_MAXAPPL]; 60 61 static int ncontrollers; 62 63 /* -------- controller ref counting -------------------------------------- */ 64 65 static inline struct capi_ctr * 66 capi_ctr_get(struct capi_ctr *ctr) 67 { 68 if (!try_module_get(ctr->owner)) 69 return NULL; 70 return ctr; 71 } 72 73 static inline void 74 capi_ctr_put(struct capi_ctr *ctr) 75 { 76 module_put(ctr->owner); 77 } 78 79 /* ------------------------------------------------------------- */ 80 81 static inline struct capi_ctr *get_capi_ctr_by_nr(u16 contr) 82 { 83 if (contr < 1 || contr - 1 >= CAPI_MAXCONTR) 84 return NULL; 85 86 return capi_controller[contr - 1]; 87 } 88 89 static inline struct capi20_appl *__get_capi_appl_by_nr(u16 applid) 90 { 91 lockdep_assert_held(&capi_controller_lock); 92 93 if (applid < 1 || applid - 1 >= CAPI_MAXAPPL) 94 return NULL; 95 96 return capi_applications[applid - 1]; 97 } 98 99 static inline struct capi20_appl *get_capi_appl_by_nr(u16 applid) 100 { 101 if (applid < 1 || applid - 1 >= CAPI_MAXAPPL) 102 return NULL; 103 104 return rcu_dereference(capi_applications[applid - 1]); 105 } 106 107 /* -------- util functions ------------------------------------ */ 108 109 static inline int capi_cmd_valid(u8 cmd) 110 { 111 switch (cmd) { 112 case CAPI_ALERT: 113 case CAPI_CONNECT: 114 case CAPI_CONNECT_ACTIVE: 115 case CAPI_CONNECT_B3_ACTIVE: 116 case CAPI_CONNECT_B3: 117 case CAPI_CONNECT_B3_T90_ACTIVE: 118 case CAPI_DATA_B3: 119 case CAPI_DISCONNECT_B3: 120 case CAPI_DISCONNECT: 121 case CAPI_FACILITY: 122 case CAPI_INFO: 123 case CAPI_LISTEN: 124 case CAPI_MANUFACTURER: 125 case CAPI_RESET_B3: 126 case CAPI_SELECT_B_PROTOCOL: 127 return 1; 128 } 129 return 0; 130 } 131 132 static inline int capi_subcmd_valid(u8 subcmd) 133 { 134 switch (subcmd) { 135 case CAPI_REQ: 136 case CAPI_CONF: 137 case CAPI_IND: 138 case CAPI_RESP: 139 return 1; 140 } 141 return 0; 142 } 143 144 /* ------------------------------------------------------------ */ 145 146 static void 147 register_appl(struct capi_ctr *ctr, u16 applid, capi_register_params *rparam) 148 { 149 ctr = capi_ctr_get(ctr); 150 151 if (ctr) 152 ctr->register_appl(ctr, applid, rparam); 153 else 154 printk(KERN_WARNING "%s: cannot get controller resources\n", 155 __func__); 156 } 157 158 159 static void release_appl(struct capi_ctr *ctr, u16 applid) 160 { 161 DBG("applid %#x", applid); 162 163 ctr->release_appl(ctr, applid); 164 capi_ctr_put(ctr); 165 } 166 167 static void notify_up(u32 contr) 168 { 169 struct capi20_appl *ap; 170 struct capi_ctr *ctr; 171 u16 applid; 172 173 mutex_lock(&capi_controller_lock); 174 175 if (showcapimsgs & 1) 176 printk(KERN_DEBUG "kcapi: notify up contr %d\n", contr); 177 178 ctr = get_capi_ctr_by_nr(contr); 179 if (ctr) { 180 if (ctr->state == CAPI_CTR_RUNNING) 181 goto unlock_out; 182 183 ctr->state = CAPI_CTR_RUNNING; 184 185 for (applid = 1; applid <= CAPI_MAXAPPL; applid++) { 186 ap = __get_capi_appl_by_nr(applid); 187 if (ap) 188 register_appl(ctr, applid, &ap->rparam); 189 } 190 } else 191 printk(KERN_WARNING "%s: invalid contr %d\n", __func__, contr); 192 193 unlock_out: 194 mutex_unlock(&capi_controller_lock); 195 } 196 197 static void ctr_down(struct capi_ctr *ctr, int new_state) 198 { 199 struct capi20_appl *ap; 200 u16 applid; 201 202 if (ctr->state == CAPI_CTR_DETECTED || ctr->state == CAPI_CTR_DETACHED) 203 return; 204 205 ctr->state = new_state; 206 207 memset(ctr->manu, 0, sizeof(ctr->manu)); 208 memset(&ctr->version, 0, sizeof(ctr->version)); 209 memset(&ctr->profile, 0, sizeof(ctr->profile)); 210 memset(ctr->serial, 0, sizeof(ctr->serial)); 211 212 for (applid = 1; applid <= CAPI_MAXAPPL; applid++) { 213 ap = __get_capi_appl_by_nr(applid); 214 if (ap) 215 capi_ctr_put(ctr); 216 } 217 } 218 219 static void notify_down(u32 contr) 220 { 221 struct capi_ctr *ctr; 222 223 mutex_lock(&capi_controller_lock); 224 225 if (showcapimsgs & 1) 226 printk(KERN_DEBUG "kcapi: notify down contr %d\n", contr); 227 228 ctr = get_capi_ctr_by_nr(contr); 229 if (ctr) 230 ctr_down(ctr, CAPI_CTR_DETECTED); 231 else 232 printk(KERN_WARNING "%s: invalid contr %d\n", __func__, contr); 233 234 mutex_unlock(&capi_controller_lock); 235 } 236 237 static void do_notify_work(struct work_struct *work) 238 { 239 struct capictr_event *event = 240 container_of(work, struct capictr_event, work); 241 242 switch (event->type) { 243 case CAPICTR_UP: 244 notify_up(event->controller); 245 break; 246 case CAPICTR_DOWN: 247 notify_down(event->controller); 248 break; 249 } 250 251 kfree(event); 252 } 253 254 static int notify_push(unsigned int event_type, u32 controller) 255 { 256 struct capictr_event *event = kmalloc(sizeof(*event), GFP_ATOMIC); 257 258 if (!event) 259 return -ENOMEM; 260 261 INIT_WORK(&event->work, do_notify_work); 262 event->type = event_type; 263 event->controller = controller; 264 265 queue_work(kcapi_wq, &event->work); 266 return 0; 267 } 268 269 /* -------- Receiver ------------------------------------------ */ 270 271 static void recv_handler(struct work_struct *work) 272 { 273 struct sk_buff *skb; 274 struct capi20_appl *ap = 275 container_of(work, struct capi20_appl, recv_work); 276 277 if ((!ap) || (ap->release_in_progress)) 278 return; 279 280 mutex_lock(&ap->recv_mtx); 281 while ((skb = skb_dequeue(&ap->recv_queue))) { 282 if (CAPIMSG_CMD(skb->data) == CAPI_DATA_B3_IND) 283 ap->nrecvdatapkt++; 284 else 285 ap->nrecvctlpkt++; 286 287 ap->recv_message(ap, skb); 288 } 289 mutex_unlock(&ap->recv_mtx); 290 } 291 292 /** 293 * capi_ctr_handle_message() - handle incoming CAPI message 294 * @ctr: controller descriptor structure. 295 * @appl: application ID. 296 * @skb: message. 297 * 298 * Called by hardware driver to pass a CAPI message to the application. 299 */ 300 301 void capi_ctr_handle_message(struct capi_ctr *ctr, u16 appl, 302 struct sk_buff *skb) 303 { 304 struct capi20_appl *ap; 305 int showctl = 0; 306 u8 cmd, subcmd; 307 _cdebbuf *cdb; 308 309 if (ctr->state != CAPI_CTR_RUNNING) { 310 cdb = capi_message2str(skb->data); 311 if (cdb) { 312 printk(KERN_INFO "kcapi: controller [%03d] not active, got: %s", 313 ctr->cnr, cdb->buf); 314 cdebbuf_free(cdb); 315 } else 316 printk(KERN_INFO "kcapi: controller [%03d] not active, cannot trace\n", 317 ctr->cnr); 318 goto error; 319 } 320 321 cmd = CAPIMSG_COMMAND(skb->data); 322 subcmd = CAPIMSG_SUBCOMMAND(skb->data); 323 if (cmd == CAPI_DATA_B3 && subcmd == CAPI_IND) { 324 ctr->nrecvdatapkt++; 325 if (ctr->traceflag > 2) 326 showctl |= 2; 327 } else { 328 ctr->nrecvctlpkt++; 329 if (ctr->traceflag) 330 showctl |= 2; 331 } 332 showctl |= (ctr->traceflag & 1); 333 if (showctl & 2) { 334 if (showctl & 1) { 335 printk(KERN_DEBUG "kcapi: got [%03d] id#%d %s len=%u\n", 336 ctr->cnr, CAPIMSG_APPID(skb->data), 337 capi_cmd2str(cmd, subcmd), 338 CAPIMSG_LEN(skb->data)); 339 } else { 340 cdb = capi_message2str(skb->data); 341 if (cdb) { 342 printk(KERN_DEBUG "kcapi: got [%03d] %s\n", 343 ctr->cnr, cdb->buf); 344 cdebbuf_free(cdb); 345 } else 346 printk(KERN_DEBUG "kcapi: got [%03d] id#%d %s len=%u, cannot trace\n", 347 ctr->cnr, CAPIMSG_APPID(skb->data), 348 capi_cmd2str(cmd, subcmd), 349 CAPIMSG_LEN(skb->data)); 350 } 351 352 } 353 354 rcu_read_lock(); 355 ap = get_capi_appl_by_nr(CAPIMSG_APPID(skb->data)); 356 if (!ap) { 357 rcu_read_unlock(); 358 cdb = capi_message2str(skb->data); 359 if (cdb) { 360 printk(KERN_ERR "kcapi: handle_message: applid %d state released (%s)\n", 361 CAPIMSG_APPID(skb->data), cdb->buf); 362 cdebbuf_free(cdb); 363 } else 364 printk(KERN_ERR "kcapi: handle_message: applid %d state released (%s) cannot trace\n", 365 CAPIMSG_APPID(skb->data), 366 capi_cmd2str(cmd, subcmd)); 367 goto error; 368 } 369 skb_queue_tail(&ap->recv_queue, skb); 370 queue_work(kcapi_wq, &ap->recv_work); 371 rcu_read_unlock(); 372 373 return; 374 375 error: 376 kfree_skb(skb); 377 } 378 379 EXPORT_SYMBOL(capi_ctr_handle_message); 380 381 /** 382 * capi_ctr_ready() - signal CAPI controller ready 383 * @ctr: controller descriptor structure. 384 * 385 * Called by hardware driver to signal that the controller is up and running. 386 */ 387 388 void capi_ctr_ready(struct capi_ctr *ctr) 389 { 390 printk(KERN_NOTICE "kcapi: controller [%03d] \"%s\" ready.\n", 391 ctr->cnr, ctr->name); 392 393 notify_push(CAPICTR_UP, ctr->cnr); 394 } 395 396 EXPORT_SYMBOL(capi_ctr_ready); 397 398 /** 399 * capi_ctr_down() - signal CAPI controller not ready 400 * @ctr: controller descriptor structure. 401 * 402 * Called by hardware driver to signal that the controller is down and 403 * unavailable for use. 404 */ 405 406 void capi_ctr_down(struct capi_ctr *ctr) 407 { 408 printk(KERN_NOTICE "kcapi: controller [%03d] down.\n", ctr->cnr); 409 410 notify_push(CAPICTR_DOWN, ctr->cnr); 411 } 412 413 EXPORT_SYMBOL(capi_ctr_down); 414 415 /* ------------------------------------------------------------- */ 416 417 /** 418 * attach_capi_ctr() - register CAPI controller 419 * @ctr: controller descriptor structure. 420 * 421 * Called by hardware driver to register a controller with the CAPI subsystem. 422 * Return value: 0 on success, error code < 0 on error 423 */ 424 425 int attach_capi_ctr(struct capi_ctr *ctr) 426 { 427 int i; 428 429 mutex_lock(&capi_controller_lock); 430 431 for (i = 0; i < CAPI_MAXCONTR; i++) { 432 if (!capi_controller[i]) 433 break; 434 } 435 if (i == CAPI_MAXCONTR) { 436 mutex_unlock(&capi_controller_lock); 437 printk(KERN_ERR "kcapi: out of controller slots\n"); 438 return -EBUSY; 439 } 440 capi_controller[i] = ctr; 441 442 ctr->nrecvctlpkt = 0; 443 ctr->nrecvdatapkt = 0; 444 ctr->nsentctlpkt = 0; 445 ctr->nsentdatapkt = 0; 446 ctr->cnr = i + 1; 447 ctr->state = CAPI_CTR_DETECTED; 448 ctr->blocked = 0; 449 ctr->traceflag = showcapimsgs; 450 451 sprintf(ctr->procfn, "capi/controllers/%d", ctr->cnr); 452 ctr->procent = proc_create_single_data(ctr->procfn, 0, NULL, 453 ctr->proc_show, ctr); 454 455 ncontrollers++; 456 457 mutex_unlock(&capi_controller_lock); 458 459 printk(KERN_NOTICE "kcapi: controller [%03d]: %s attached\n", 460 ctr->cnr, ctr->name); 461 return 0; 462 } 463 464 EXPORT_SYMBOL(attach_capi_ctr); 465 466 /** 467 * detach_capi_ctr() - unregister CAPI controller 468 * @ctr: controller descriptor structure. 469 * 470 * Called by hardware driver to remove the registration of a controller 471 * with the CAPI subsystem. 472 * Return value: 0 on success, error code < 0 on error 473 */ 474 475 int detach_capi_ctr(struct capi_ctr *ctr) 476 { 477 int err = 0; 478 479 mutex_lock(&capi_controller_lock); 480 481 ctr_down(ctr, CAPI_CTR_DETACHED); 482 483 if (capi_controller[ctr->cnr - 1] != ctr) { 484 err = -EINVAL; 485 goto unlock_out; 486 } 487 capi_controller[ctr->cnr - 1] = NULL; 488 ncontrollers--; 489 490 if (ctr->procent) 491 remove_proc_entry(ctr->procfn, NULL); 492 493 printk(KERN_NOTICE "kcapi: controller [%03d]: %s unregistered\n", 494 ctr->cnr, ctr->name); 495 496 unlock_out: 497 mutex_unlock(&capi_controller_lock); 498 499 return err; 500 } 501 502 EXPORT_SYMBOL(detach_capi_ctr); 503 504 /* ------------------------------------------------------------- */ 505 /* -------- CAPI2.0 Interface ---------------------------------- */ 506 /* ------------------------------------------------------------- */ 507 508 /** 509 * capi20_isinstalled() - CAPI 2.0 operation CAPI_INSTALLED 510 * 511 * Return value: CAPI result code (CAPI_NOERROR if at least one ISDN controller 512 * is ready for use, CAPI_REGNOTINSTALLED otherwise) 513 */ 514 515 u16 capi20_isinstalled(void) 516 { 517 u16 ret = CAPI_REGNOTINSTALLED; 518 int i; 519 520 mutex_lock(&capi_controller_lock); 521 522 for (i = 0; i < CAPI_MAXCONTR; i++) 523 if (capi_controller[i] && 524 capi_controller[i]->state == CAPI_CTR_RUNNING) { 525 ret = CAPI_NOERROR; 526 break; 527 } 528 529 mutex_unlock(&capi_controller_lock); 530 531 return ret; 532 } 533 534 /** 535 * capi20_register() - CAPI 2.0 operation CAPI_REGISTER 536 * @ap: CAPI application descriptor structure. 537 * 538 * Register an application's presence with CAPI. 539 * A unique application ID is assigned and stored in @ap->applid. 540 * After this function returns successfully, the message receive 541 * callback function @ap->recv_message() may be called at any time 542 * until capi20_release() has been called for the same @ap. 543 * Return value: CAPI result code 544 */ 545 546 u16 capi20_register(struct capi20_appl *ap) 547 { 548 int i; 549 u16 applid; 550 551 DBG(""); 552 553 if (ap->rparam.datablklen < 128) 554 return CAPI_LOGBLKSIZETOSMALL; 555 556 ap->nrecvctlpkt = 0; 557 ap->nrecvdatapkt = 0; 558 ap->nsentctlpkt = 0; 559 ap->nsentdatapkt = 0; 560 mutex_init(&ap->recv_mtx); 561 skb_queue_head_init(&ap->recv_queue); 562 INIT_WORK(&ap->recv_work, recv_handler); 563 ap->release_in_progress = 0; 564 565 mutex_lock(&capi_controller_lock); 566 567 for (applid = 1; applid <= CAPI_MAXAPPL; applid++) { 568 if (capi_applications[applid - 1] == NULL) 569 break; 570 } 571 if (applid > CAPI_MAXAPPL) { 572 mutex_unlock(&capi_controller_lock); 573 return CAPI_TOOMANYAPPLS; 574 } 575 576 ap->applid = applid; 577 capi_applications[applid - 1] = ap; 578 579 for (i = 0; i < CAPI_MAXCONTR; i++) { 580 if (!capi_controller[i] || 581 capi_controller[i]->state != CAPI_CTR_RUNNING) 582 continue; 583 register_appl(capi_controller[i], applid, &ap->rparam); 584 } 585 586 mutex_unlock(&capi_controller_lock); 587 588 if (showcapimsgs & 1) { 589 printk(KERN_DEBUG "kcapi: appl %d up\n", applid); 590 } 591 592 return CAPI_NOERROR; 593 } 594 595 /** 596 * capi20_release() - CAPI 2.0 operation CAPI_RELEASE 597 * @ap: CAPI application descriptor structure. 598 * 599 * Terminate an application's registration with CAPI. 600 * After this function returns successfully, the message receive 601 * callback function @ap->recv_message() will no longer be called. 602 * Return value: CAPI result code 603 */ 604 605 u16 capi20_release(struct capi20_appl *ap) 606 { 607 int i; 608 609 DBG("applid %#x", ap->applid); 610 611 mutex_lock(&capi_controller_lock); 612 613 ap->release_in_progress = 1; 614 capi_applications[ap->applid - 1] = NULL; 615 616 synchronize_rcu(); 617 618 for (i = 0; i < CAPI_MAXCONTR; i++) { 619 if (!capi_controller[i] || 620 capi_controller[i]->state != CAPI_CTR_RUNNING) 621 continue; 622 release_appl(capi_controller[i], ap->applid); 623 } 624 625 mutex_unlock(&capi_controller_lock); 626 627 flush_workqueue(kcapi_wq); 628 skb_queue_purge(&ap->recv_queue); 629 630 if (showcapimsgs & 1) { 631 printk(KERN_DEBUG "kcapi: appl %d down\n", ap->applid); 632 } 633 634 return CAPI_NOERROR; 635 } 636 637 /** 638 * capi20_put_message() - CAPI 2.0 operation CAPI_PUT_MESSAGE 639 * @ap: CAPI application descriptor structure. 640 * @skb: CAPI message. 641 * 642 * Transfer a single message to CAPI. 643 * Return value: CAPI result code 644 */ 645 646 u16 capi20_put_message(struct capi20_appl *ap, struct sk_buff *skb) 647 { 648 struct capi_ctr *ctr; 649 int showctl = 0; 650 u8 cmd, subcmd; 651 652 DBG("applid %#x", ap->applid); 653 654 if (ncontrollers == 0) 655 return CAPI_REGNOTINSTALLED; 656 if ((ap->applid == 0) || ap->release_in_progress) 657 return CAPI_ILLAPPNR; 658 if (skb->len < 12 659 || !capi_cmd_valid(CAPIMSG_COMMAND(skb->data)) 660 || !capi_subcmd_valid(CAPIMSG_SUBCOMMAND(skb->data))) 661 return CAPI_ILLCMDORSUBCMDORMSGTOSMALL; 662 663 /* 664 * The controller reference is protected by the existence of the 665 * application passed to us. We assume that the caller properly 666 * synchronizes this service with capi20_release. 667 */ 668 ctr = get_capi_ctr_by_nr(CAPIMSG_CONTROLLER(skb->data)); 669 if (!ctr || ctr->state != CAPI_CTR_RUNNING) 670 return CAPI_REGNOTINSTALLED; 671 if (ctr->blocked) 672 return CAPI_SENDQUEUEFULL; 673 674 cmd = CAPIMSG_COMMAND(skb->data); 675 subcmd = CAPIMSG_SUBCOMMAND(skb->data); 676 677 if (cmd == CAPI_DATA_B3 && subcmd == CAPI_REQ) { 678 ctr->nsentdatapkt++; 679 ap->nsentdatapkt++; 680 if (ctr->traceflag > 2) 681 showctl |= 2; 682 } else { 683 ctr->nsentctlpkt++; 684 ap->nsentctlpkt++; 685 if (ctr->traceflag) 686 showctl |= 2; 687 } 688 showctl |= (ctr->traceflag & 1); 689 if (showctl & 2) { 690 if (showctl & 1) { 691 printk(KERN_DEBUG "kcapi: put [%03d] id#%d %s len=%u\n", 692 CAPIMSG_CONTROLLER(skb->data), 693 CAPIMSG_APPID(skb->data), 694 capi_cmd2str(cmd, subcmd), 695 CAPIMSG_LEN(skb->data)); 696 } else { 697 _cdebbuf *cdb = capi_message2str(skb->data); 698 if (cdb) { 699 printk(KERN_DEBUG "kcapi: put [%03d] %s\n", 700 CAPIMSG_CONTROLLER(skb->data), 701 cdb->buf); 702 cdebbuf_free(cdb); 703 } else 704 printk(KERN_DEBUG "kcapi: put [%03d] id#%d %s len=%u cannot trace\n", 705 CAPIMSG_CONTROLLER(skb->data), 706 CAPIMSG_APPID(skb->data), 707 capi_cmd2str(cmd, subcmd), 708 CAPIMSG_LEN(skb->data)); 709 } 710 } 711 return ctr->send_message(ctr, skb); 712 } 713 714 /** 715 * capi20_get_manufacturer() - CAPI 2.0 operation CAPI_GET_MANUFACTURER 716 * @contr: controller number. 717 * @buf: result buffer (64 bytes). 718 * 719 * Retrieve information about the manufacturer of the specified ISDN controller 720 * or (for @contr == 0) the driver itself. 721 * Return value: CAPI result code 722 */ 723 724 u16 capi20_get_manufacturer(u32 contr, u8 buf[CAPI_MANUFACTURER_LEN]) 725 { 726 struct capi_ctr *ctr; 727 u16 ret; 728 729 if (contr == 0) { 730 strncpy(buf, capi_manufakturer, CAPI_MANUFACTURER_LEN); 731 return CAPI_NOERROR; 732 } 733 734 mutex_lock(&capi_controller_lock); 735 736 ctr = get_capi_ctr_by_nr(contr); 737 if (ctr && ctr->state == CAPI_CTR_RUNNING) { 738 strncpy(buf, ctr->manu, CAPI_MANUFACTURER_LEN); 739 ret = CAPI_NOERROR; 740 } else 741 ret = CAPI_REGNOTINSTALLED; 742 743 mutex_unlock(&capi_controller_lock); 744 return ret; 745 } 746 747 /** 748 * capi20_get_version() - CAPI 2.0 operation CAPI_GET_VERSION 749 * @contr: controller number. 750 * @verp: result structure. 751 * 752 * Retrieve version information for the specified ISDN controller 753 * or (for @contr == 0) the driver itself. 754 * Return value: CAPI result code 755 */ 756 757 u16 capi20_get_version(u32 contr, struct capi_version *verp) 758 { 759 struct capi_ctr *ctr; 760 u16 ret; 761 762 if (contr == 0) { 763 *verp = driver_version; 764 return CAPI_NOERROR; 765 } 766 767 mutex_lock(&capi_controller_lock); 768 769 ctr = get_capi_ctr_by_nr(contr); 770 if (ctr && ctr->state == CAPI_CTR_RUNNING) { 771 memcpy(verp, &ctr->version, sizeof(capi_version)); 772 ret = CAPI_NOERROR; 773 } else 774 ret = CAPI_REGNOTINSTALLED; 775 776 mutex_unlock(&capi_controller_lock); 777 return ret; 778 } 779 780 /** 781 * capi20_get_serial() - CAPI 2.0 operation CAPI_GET_SERIAL_NUMBER 782 * @contr: controller number. 783 * @serial: result buffer (8 bytes). 784 * 785 * Retrieve the serial number of the specified ISDN controller 786 * or (for @contr == 0) the driver itself. 787 * Return value: CAPI result code 788 */ 789 790 u16 capi20_get_serial(u32 contr, u8 serial[CAPI_SERIAL_LEN]) 791 { 792 struct capi_ctr *ctr; 793 u16 ret; 794 795 if (contr == 0) { 796 strlcpy(serial, driver_serial, CAPI_SERIAL_LEN); 797 return CAPI_NOERROR; 798 } 799 800 mutex_lock(&capi_controller_lock); 801 802 ctr = get_capi_ctr_by_nr(contr); 803 if (ctr && ctr->state == CAPI_CTR_RUNNING) { 804 strlcpy(serial, ctr->serial, CAPI_SERIAL_LEN); 805 ret = CAPI_NOERROR; 806 } else 807 ret = CAPI_REGNOTINSTALLED; 808 809 mutex_unlock(&capi_controller_lock); 810 return ret; 811 } 812 813 /** 814 * capi20_get_profile() - CAPI 2.0 operation CAPI_GET_PROFILE 815 * @contr: controller number. 816 * @profp: result structure. 817 * 818 * Retrieve capability information for the specified ISDN controller 819 * or (for @contr == 0) the number of installed controllers. 820 * Return value: CAPI result code 821 */ 822 823 u16 capi20_get_profile(u32 contr, struct capi_profile *profp) 824 { 825 struct capi_ctr *ctr; 826 u16 ret; 827 828 if (contr == 0) { 829 profp->ncontroller = ncontrollers; 830 return CAPI_NOERROR; 831 } 832 833 mutex_lock(&capi_controller_lock); 834 835 ctr = get_capi_ctr_by_nr(contr); 836 if (ctr && ctr->state == CAPI_CTR_RUNNING) { 837 memcpy(profp, &ctr->profile, sizeof(struct capi_profile)); 838 ret = CAPI_NOERROR; 839 } else 840 ret = CAPI_REGNOTINSTALLED; 841 842 mutex_unlock(&capi_controller_lock); 843 return ret; 844 } 845 846 /** 847 * capi20_manufacturer() - CAPI 2.0 operation CAPI_MANUFACTURER 848 * @cmd: command. 849 * @data: parameter. 850 * 851 * Perform manufacturer specific command. 852 * Return value: CAPI result code 853 */ 854 855 int capi20_manufacturer(unsigned long cmd, void __user *data) 856 { 857 struct capi_ctr *ctr; 858 int retval; 859 860 switch (cmd) { 861 case KCAPI_CMD_TRACE: 862 { 863 kcapi_flagdef fdef; 864 865 if (copy_from_user(&fdef, data, sizeof(kcapi_flagdef))) 866 return -EFAULT; 867 868 mutex_lock(&capi_controller_lock); 869 870 ctr = get_capi_ctr_by_nr(fdef.contr); 871 if (ctr) { 872 ctr->traceflag = fdef.flag; 873 printk(KERN_INFO "kcapi: contr [%03d] set trace=%d\n", 874 ctr->cnr, ctr->traceflag); 875 retval = 0; 876 } else 877 retval = -ESRCH; 878 879 mutex_unlock(&capi_controller_lock); 880 881 return retval; 882 } 883 884 default: 885 printk(KERN_ERR "kcapi: manufacturer command %lu unknown.\n", 886 cmd); 887 break; 888 889 } 890 return -EINVAL; 891 } 892 893 /* ------------------------------------------------------------- */ 894 /* -------- Init & Cleanup ------------------------------------- */ 895 /* ------------------------------------------------------------- */ 896 897 /* 898 * init / exit functions 899 */ 900 901 int __init kcapi_init(void) 902 { 903 int err; 904 905 kcapi_wq = alloc_workqueue("kcapi", 0, 0); 906 if (!kcapi_wq) 907 return -ENOMEM; 908 909 err = cdebug_init(); 910 if (err) { 911 destroy_workqueue(kcapi_wq); 912 return err; 913 } 914 915 kcapi_proc_init(); 916 return 0; 917 } 918 919 void kcapi_exit(void) 920 { 921 kcapi_proc_exit(); 922 923 cdebug_exit(); 924 destroy_workqueue(kcapi_wq); 925 } 926