1 /* $Id: capi.c,v 1.1.2.7 2004/04/28 09:48:59 armin Exp $ 2 * 3 * CAPI 2.0 Interface for Linux 4 * 5 * Copyright 1996 by Carsten Paeth <calle@calle.de> 6 * 7 * This software may be used and distributed according to the terms 8 * of the GNU General Public License, incorporated herein by reference. 9 * 10 */ 11 12 #include <linux/module.h> 13 #include <linux/errno.h> 14 #include <linux/kernel.h> 15 #include <linux/major.h> 16 #include <linux/sched.h> 17 #include <linux/slab.h> 18 #include <linux/fcntl.h> 19 #include <linux/fs.h> 20 #include <linux/signal.h> 21 #include <linux/mutex.h> 22 #include <linux/mm.h> 23 #include <linux/timer.h> 24 #include <linux/wait.h> 25 #include <linux/tty.h> 26 #include <linux/netdevice.h> 27 #include <linux/ppp_defs.h> 28 #include <linux/ppp-ioctl.h> 29 #include <linux/skbuff.h> 30 #include <linux/proc_fs.h> 31 #include <linux/seq_file.h> 32 #include <linux/poll.h> 33 #include <linux/capi.h> 34 #include <linux/kernelcapi.h> 35 #include <linux/init.h> 36 #include <linux/device.h> 37 #include <linux/moduleparam.h> 38 #include <linux/isdn/capiutil.h> 39 #include <linux/isdn/capicmd.h> 40 41 MODULE_DESCRIPTION("CAPI4Linux: Userspace /dev/capi20 interface"); 42 MODULE_AUTHOR("Carsten Paeth"); 43 MODULE_LICENSE("GPL"); 44 45 /* -------- driver information -------------------------------------- */ 46 47 static DEFINE_MUTEX(capi_mutex); 48 static struct class *capi_class; 49 static int capi_major = 68; /* allocated */ 50 51 module_param_named(major, capi_major, uint, 0); 52 53 #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE 54 #define CAPINC_NR_PORTS 32 55 #define CAPINC_MAX_PORTS 256 56 57 static int capi_ttyminors = CAPINC_NR_PORTS; 58 59 module_param_named(ttyminors, capi_ttyminors, uint, 0); 60 #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */ 61 62 /* -------- defines ------------------------------------------------- */ 63 64 #define CAPINC_MAX_RECVQUEUE 10 65 #define CAPINC_MAX_SENDQUEUE 10 66 #define CAPI_MAX_BLKSIZE 2048 67 68 /* -------- data structures ----------------------------------------- */ 69 70 struct capidev; 71 struct capincci; 72 struct capiminor; 73 74 struct ackqueue_entry { 75 struct list_head list; 76 u16 datahandle; 77 }; 78 79 struct capiminor { 80 unsigned int minor; 81 82 struct capi20_appl *ap; 83 u32 ncci; 84 atomic_t datahandle; 85 atomic_t msgid; 86 87 struct tty_port port; 88 int ttyinstop; 89 int ttyoutstop; 90 91 struct sk_buff_head inqueue; 92 93 struct sk_buff_head outqueue; 94 int outbytes; 95 struct sk_buff *outskb; 96 spinlock_t outlock; 97 98 /* transmit path */ 99 struct list_head ackqueue; 100 int nack; 101 spinlock_t ackqlock; 102 }; 103 104 struct capincci { 105 struct list_head list; 106 u32 ncci; 107 struct capidev *cdev; 108 #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE 109 struct capiminor *minorp; 110 #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */ 111 }; 112 113 struct capidev { 114 struct list_head list; 115 struct capi20_appl ap; 116 u16 errcode; 117 unsigned userflags; 118 119 struct sk_buff_head recvqueue; 120 wait_queue_head_t recvwait; 121 122 struct list_head nccis; 123 124 struct mutex lock; 125 }; 126 127 /* -------- global variables ---------------------------------------- */ 128 129 static DEFINE_MUTEX(capidev_list_lock); 130 static LIST_HEAD(capidev_list); 131 132 #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE 133 134 static DEFINE_SPINLOCK(capiminors_lock); 135 static struct capiminor **capiminors; 136 137 static struct tty_driver *capinc_tty_driver; 138 139 /* -------- datahandles --------------------------------------------- */ 140 141 static int capiminor_add_ack(struct capiminor *mp, u16 datahandle) 142 { 143 struct ackqueue_entry *n; 144 145 n = kmalloc(sizeof(*n), GFP_ATOMIC); 146 if (unlikely(!n)) { 147 printk(KERN_ERR "capi: alloc datahandle failed\n"); 148 return -1; 149 } 150 n->datahandle = datahandle; 151 INIT_LIST_HEAD(&n->list); 152 spin_lock_bh(&mp->ackqlock); 153 list_add_tail(&n->list, &mp->ackqueue); 154 mp->nack++; 155 spin_unlock_bh(&mp->ackqlock); 156 return 0; 157 } 158 159 static int capiminor_del_ack(struct capiminor *mp, u16 datahandle) 160 { 161 struct ackqueue_entry *p, *tmp; 162 163 spin_lock_bh(&mp->ackqlock); 164 list_for_each_entry_safe(p, tmp, &mp->ackqueue, list) { 165 if (p->datahandle == datahandle) { 166 list_del(&p->list); 167 mp->nack--; 168 spin_unlock_bh(&mp->ackqlock); 169 kfree(p); 170 return 0; 171 } 172 } 173 spin_unlock_bh(&mp->ackqlock); 174 return -1; 175 } 176 177 static void capiminor_del_all_ack(struct capiminor *mp) 178 { 179 struct ackqueue_entry *p, *tmp; 180 181 list_for_each_entry_safe(p, tmp, &mp->ackqueue, list) { 182 list_del(&p->list); 183 kfree(p); 184 mp->nack--; 185 } 186 } 187 188 189 /* -------- struct capiminor ---------------------------------------- */ 190 191 static void capiminor_destroy(struct tty_port *port) 192 { 193 struct capiminor *mp = container_of(port, struct capiminor, port); 194 195 kfree_skb(mp->outskb); 196 skb_queue_purge(&mp->inqueue); 197 skb_queue_purge(&mp->outqueue); 198 capiminor_del_all_ack(mp); 199 kfree(mp); 200 } 201 202 static const struct tty_port_operations capiminor_port_ops = { 203 .destruct = capiminor_destroy, 204 }; 205 206 static struct capiminor *capiminor_alloc(struct capi20_appl *ap, u32 ncci) 207 { 208 struct capiminor *mp; 209 struct device *dev; 210 unsigned int minor; 211 212 mp = kzalloc(sizeof(*mp), GFP_KERNEL); 213 if (!mp) { 214 printk(KERN_ERR "capi: can't alloc capiminor\n"); 215 return NULL; 216 } 217 218 mp->ap = ap; 219 mp->ncci = ncci; 220 INIT_LIST_HEAD(&mp->ackqueue); 221 spin_lock_init(&mp->ackqlock); 222 223 skb_queue_head_init(&mp->inqueue); 224 skb_queue_head_init(&mp->outqueue); 225 spin_lock_init(&mp->outlock); 226 227 tty_port_init(&mp->port); 228 mp->port.ops = &capiminor_port_ops; 229 230 /* Allocate the least unused minor number. */ 231 spin_lock(&capiminors_lock); 232 for (minor = 0; minor < capi_ttyminors; minor++) 233 if (!capiminors[minor]) { 234 capiminors[minor] = mp; 235 break; 236 } 237 spin_unlock(&capiminors_lock); 238 239 if (minor == capi_ttyminors) { 240 printk(KERN_NOTICE "capi: out of minors\n"); 241 goto err_out1; 242 } 243 244 mp->minor = minor; 245 246 dev = tty_port_register_device(&mp->port, capinc_tty_driver, minor, 247 NULL); 248 if (IS_ERR(dev)) 249 goto err_out2; 250 251 return mp; 252 253 err_out2: 254 spin_lock(&capiminors_lock); 255 capiminors[minor] = NULL; 256 spin_unlock(&capiminors_lock); 257 258 err_out1: 259 tty_port_put(&mp->port); 260 return NULL; 261 } 262 263 static struct capiminor *capiminor_get(unsigned int minor) 264 { 265 struct capiminor *mp; 266 267 spin_lock(&capiminors_lock); 268 mp = capiminors[minor]; 269 if (mp) 270 tty_port_get(&mp->port); 271 spin_unlock(&capiminors_lock); 272 273 return mp; 274 } 275 276 static inline void capiminor_put(struct capiminor *mp) 277 { 278 tty_port_put(&mp->port); 279 } 280 281 static void capiminor_free(struct capiminor *mp) 282 { 283 tty_unregister_device(capinc_tty_driver, mp->minor); 284 285 spin_lock(&capiminors_lock); 286 capiminors[mp->minor] = NULL; 287 spin_unlock(&capiminors_lock); 288 289 capiminor_put(mp); 290 } 291 292 /* -------- struct capincci ----------------------------------------- */ 293 294 static void capincci_alloc_minor(struct capidev *cdev, struct capincci *np) 295 { 296 if (cdev->userflags & CAPIFLAG_HIGHJACKING) 297 np->minorp = capiminor_alloc(&cdev->ap, np->ncci); 298 } 299 300 static void capincci_free_minor(struct capincci *np) 301 { 302 struct capiminor *mp = np->minorp; 303 struct tty_struct *tty; 304 305 if (mp) { 306 tty = tty_port_tty_get(&mp->port); 307 if (tty) { 308 tty_vhangup(tty); 309 tty_kref_put(tty); 310 } 311 312 capiminor_free(mp); 313 } 314 } 315 316 static inline unsigned int capincci_minor_opencount(struct capincci *np) 317 { 318 struct capiminor *mp = np->minorp; 319 unsigned int count = 0; 320 struct tty_struct *tty; 321 322 if (mp) { 323 tty = tty_port_tty_get(&mp->port); 324 if (tty) { 325 count = tty->count; 326 tty_kref_put(tty); 327 } 328 } 329 return count; 330 } 331 332 #else /* !CONFIG_ISDN_CAPI_MIDDLEWARE */ 333 334 static inline void 335 capincci_alloc_minor(struct capidev *cdev, struct capincci *np) { } 336 static inline void capincci_free_minor(struct capincci *np) { } 337 338 #endif /* !CONFIG_ISDN_CAPI_MIDDLEWARE */ 339 340 static struct capincci *capincci_alloc(struct capidev *cdev, u32 ncci) 341 { 342 struct capincci *np; 343 344 np = kzalloc(sizeof(*np), GFP_KERNEL); 345 if (!np) 346 return NULL; 347 np->ncci = ncci; 348 np->cdev = cdev; 349 350 capincci_alloc_minor(cdev, np); 351 352 list_add_tail(&np->list, &cdev->nccis); 353 354 return np; 355 } 356 357 static void capincci_free(struct capidev *cdev, u32 ncci) 358 { 359 struct capincci *np, *tmp; 360 361 list_for_each_entry_safe(np, tmp, &cdev->nccis, list) 362 if (ncci == 0xffffffff || np->ncci == ncci) { 363 capincci_free_minor(np); 364 list_del(&np->list); 365 kfree(np); 366 } 367 } 368 369 #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE 370 static struct capincci *capincci_find(struct capidev *cdev, u32 ncci) 371 { 372 struct capincci *np; 373 374 list_for_each_entry(np, &cdev->nccis, list) 375 if (np->ncci == ncci) 376 return np; 377 return NULL; 378 } 379 380 /* -------- handle data queue --------------------------------------- */ 381 382 static struct sk_buff * 383 gen_data_b3_resp_for(struct capiminor *mp, struct sk_buff *skb) 384 { 385 struct sk_buff *nskb; 386 nskb = alloc_skb(CAPI_DATA_B3_RESP_LEN, GFP_KERNEL); 387 if (nskb) { 388 u16 datahandle = CAPIMSG_U16(skb->data, CAPIMSG_BASELEN + 4 + 4 + 2); 389 unsigned char *s = skb_put(nskb, CAPI_DATA_B3_RESP_LEN); 390 capimsg_setu16(s, 0, CAPI_DATA_B3_RESP_LEN); 391 capimsg_setu16(s, 2, mp->ap->applid); 392 capimsg_setu8 (s, 4, CAPI_DATA_B3); 393 capimsg_setu8 (s, 5, CAPI_RESP); 394 capimsg_setu16(s, 6, atomic_inc_return(&mp->msgid)); 395 capimsg_setu32(s, 8, mp->ncci); 396 capimsg_setu16(s, 12, datahandle); 397 } 398 return nskb; 399 } 400 401 static int handle_recv_skb(struct capiminor *mp, struct sk_buff *skb) 402 { 403 unsigned int datalen = skb->len - CAPIMSG_LEN(skb->data); 404 struct tty_struct *tty; 405 struct sk_buff *nskb; 406 u16 errcode, datahandle; 407 struct tty_ldisc *ld; 408 int ret = -1; 409 410 tty = tty_port_tty_get(&mp->port); 411 if (!tty) { 412 pr_debug("capi: currently no receiver\n"); 413 return -1; 414 } 415 416 ld = tty_ldisc_ref(tty); 417 if (!ld) { 418 /* fatal error, do not requeue */ 419 ret = 0; 420 kfree_skb(skb); 421 goto deref_tty; 422 } 423 424 if (ld->ops->receive_buf == NULL) { 425 pr_debug("capi: ldisc has no receive_buf function\n"); 426 /* fatal error, do not requeue */ 427 goto free_skb; 428 } 429 if (mp->ttyinstop) { 430 pr_debug("capi: recv tty throttled\n"); 431 goto deref_ldisc; 432 } 433 434 if (tty->receive_room < datalen) { 435 pr_debug("capi: no room in tty\n"); 436 goto deref_ldisc; 437 } 438 439 nskb = gen_data_b3_resp_for(mp, skb); 440 if (!nskb) { 441 printk(KERN_ERR "capi: gen_data_b3_resp failed\n"); 442 goto deref_ldisc; 443 } 444 445 datahandle = CAPIMSG_U16(skb->data, CAPIMSG_BASELEN + 4); 446 447 errcode = capi20_put_message(mp->ap, nskb); 448 449 if (errcode == CAPI_NOERROR) { 450 skb_pull(skb, CAPIMSG_LEN(skb->data)); 451 pr_debug("capi: DATA_B3_RESP %u len=%d => ldisc\n", 452 datahandle, skb->len); 453 ld->ops->receive_buf(tty, skb->data, NULL, skb->len); 454 } else { 455 printk(KERN_ERR "capi: send DATA_B3_RESP failed=%x\n", 456 errcode); 457 kfree_skb(nskb); 458 459 if (errcode == CAPI_SENDQUEUEFULL) 460 goto deref_ldisc; 461 } 462 463 free_skb: 464 ret = 0; 465 kfree_skb(skb); 466 467 deref_ldisc: 468 tty_ldisc_deref(ld); 469 470 deref_tty: 471 tty_kref_put(tty); 472 return ret; 473 } 474 475 static void handle_minor_recv(struct capiminor *mp) 476 { 477 struct sk_buff *skb; 478 479 while ((skb = skb_dequeue(&mp->inqueue)) != NULL) 480 if (handle_recv_skb(mp, skb) < 0) { 481 skb_queue_head(&mp->inqueue, skb); 482 return; 483 } 484 } 485 486 static void handle_minor_send(struct capiminor *mp) 487 { 488 struct tty_struct *tty; 489 struct sk_buff *skb; 490 u16 len; 491 u16 errcode; 492 u16 datahandle; 493 494 tty = tty_port_tty_get(&mp->port); 495 if (!tty) 496 return; 497 498 if (mp->ttyoutstop) { 499 pr_debug("capi: send: tty stopped\n"); 500 tty_kref_put(tty); 501 return; 502 } 503 504 while (1) { 505 spin_lock_bh(&mp->outlock); 506 skb = __skb_dequeue(&mp->outqueue); 507 if (!skb) { 508 spin_unlock_bh(&mp->outlock); 509 break; 510 } 511 len = (u16)skb->len; 512 mp->outbytes -= len; 513 spin_unlock_bh(&mp->outlock); 514 515 datahandle = atomic_inc_return(&mp->datahandle); 516 skb_push(skb, CAPI_DATA_B3_REQ_LEN); 517 memset(skb->data, 0, CAPI_DATA_B3_REQ_LEN); 518 capimsg_setu16(skb->data, 0, CAPI_DATA_B3_REQ_LEN); 519 capimsg_setu16(skb->data, 2, mp->ap->applid); 520 capimsg_setu8 (skb->data, 4, CAPI_DATA_B3); 521 capimsg_setu8 (skb->data, 5, CAPI_REQ); 522 capimsg_setu16(skb->data, 6, atomic_inc_return(&mp->msgid)); 523 capimsg_setu32(skb->data, 8, mp->ncci); /* NCCI */ 524 capimsg_setu32(skb->data, 12, (u32)(long)skb->data);/* Data32 */ 525 capimsg_setu16(skb->data, 16, len); /* Data length */ 526 capimsg_setu16(skb->data, 18, datahandle); 527 capimsg_setu16(skb->data, 20, 0); /* Flags */ 528 529 if (capiminor_add_ack(mp, datahandle) < 0) { 530 skb_pull(skb, CAPI_DATA_B3_REQ_LEN); 531 532 spin_lock_bh(&mp->outlock); 533 __skb_queue_head(&mp->outqueue, skb); 534 mp->outbytes += len; 535 spin_unlock_bh(&mp->outlock); 536 537 break; 538 } 539 errcode = capi20_put_message(mp->ap, skb); 540 if (errcode == CAPI_NOERROR) { 541 pr_debug("capi: DATA_B3_REQ %u len=%u\n", 542 datahandle, len); 543 continue; 544 } 545 capiminor_del_ack(mp, datahandle); 546 547 if (errcode == CAPI_SENDQUEUEFULL) { 548 skb_pull(skb, CAPI_DATA_B3_REQ_LEN); 549 550 spin_lock_bh(&mp->outlock); 551 __skb_queue_head(&mp->outqueue, skb); 552 mp->outbytes += len; 553 spin_unlock_bh(&mp->outlock); 554 555 break; 556 } 557 558 /* ups, drop packet */ 559 printk(KERN_ERR "capi: put_message = %x\n", errcode); 560 kfree_skb(skb); 561 } 562 tty_kref_put(tty); 563 } 564 565 #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */ 566 /* -------- function called by lower level -------------------------- */ 567 568 static void capi_recv_message(struct capi20_appl *ap, struct sk_buff *skb) 569 { 570 struct capidev *cdev = ap->private; 571 #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE 572 struct tty_struct *tty; 573 struct capiminor *mp; 574 u16 datahandle; 575 struct capincci *np; 576 #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */ 577 578 mutex_lock(&cdev->lock); 579 580 if (CAPIMSG_CMD(skb->data) == CAPI_CONNECT_B3_CONF) { 581 u16 info = CAPIMSG_U16(skb->data, 12); // Info field 582 if ((info & 0xff00) == 0) 583 capincci_alloc(cdev, CAPIMSG_NCCI(skb->data)); 584 } 585 if (CAPIMSG_CMD(skb->data) == CAPI_CONNECT_B3_IND) 586 capincci_alloc(cdev, CAPIMSG_NCCI(skb->data)); 587 588 if (CAPIMSG_COMMAND(skb->data) != CAPI_DATA_B3) { 589 skb_queue_tail(&cdev->recvqueue, skb); 590 wake_up_interruptible(&cdev->recvwait); 591 goto unlock_out; 592 } 593 594 #ifndef CONFIG_ISDN_CAPI_MIDDLEWARE 595 skb_queue_tail(&cdev->recvqueue, skb); 596 wake_up_interruptible(&cdev->recvwait); 597 598 #else /* CONFIG_ISDN_CAPI_MIDDLEWARE */ 599 600 np = capincci_find(cdev, CAPIMSG_CONTROL(skb->data)); 601 if (!np) { 602 printk(KERN_ERR "BUG: capi_signal: ncci not found\n"); 603 skb_queue_tail(&cdev->recvqueue, skb); 604 wake_up_interruptible(&cdev->recvwait); 605 goto unlock_out; 606 } 607 608 mp = np->minorp; 609 if (!mp) { 610 skb_queue_tail(&cdev->recvqueue, skb); 611 wake_up_interruptible(&cdev->recvwait); 612 goto unlock_out; 613 } 614 if (CAPIMSG_SUBCOMMAND(skb->data) == CAPI_IND) { 615 datahandle = CAPIMSG_U16(skb->data, CAPIMSG_BASELEN + 4 + 4 + 2); 616 pr_debug("capi_signal: DATA_B3_IND %u len=%d\n", 617 datahandle, skb->len-CAPIMSG_LEN(skb->data)); 618 skb_queue_tail(&mp->inqueue, skb); 619 620 handle_minor_recv(mp); 621 622 } else if (CAPIMSG_SUBCOMMAND(skb->data) == CAPI_CONF) { 623 624 datahandle = CAPIMSG_U16(skb->data, CAPIMSG_BASELEN + 4); 625 pr_debug("capi_signal: DATA_B3_CONF %u 0x%x\n", 626 datahandle, 627 CAPIMSG_U16(skb->data, CAPIMSG_BASELEN + 4 + 2)); 628 kfree_skb(skb); 629 capiminor_del_ack(mp, datahandle); 630 tty = tty_port_tty_get(&mp->port); 631 if (tty) { 632 tty_wakeup(tty); 633 tty_kref_put(tty); 634 } 635 handle_minor_send(mp); 636 637 } else { 638 /* ups, let capi application handle it :-) */ 639 skb_queue_tail(&cdev->recvqueue, skb); 640 wake_up_interruptible(&cdev->recvwait); 641 } 642 #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */ 643 644 unlock_out: 645 mutex_unlock(&cdev->lock); 646 } 647 648 /* -------- file_operations for capidev ----------------------------- */ 649 650 static ssize_t 651 capi_read(struct file *file, char __user *buf, size_t count, loff_t *ppos) 652 { 653 struct capidev *cdev = file->private_data; 654 struct sk_buff *skb; 655 size_t copied; 656 int err; 657 658 if (!cdev->ap.applid) 659 return -ENODEV; 660 661 skb = skb_dequeue(&cdev->recvqueue); 662 if (!skb) { 663 if (file->f_flags & O_NONBLOCK) 664 return -EAGAIN; 665 err = wait_event_interruptible(cdev->recvwait, 666 (skb = skb_dequeue(&cdev->recvqueue))); 667 if (err) 668 return err; 669 } 670 if (skb->len > count) { 671 skb_queue_head(&cdev->recvqueue, skb); 672 return -EMSGSIZE; 673 } 674 if (copy_to_user(buf, skb->data, skb->len)) { 675 skb_queue_head(&cdev->recvqueue, skb); 676 return -EFAULT; 677 } 678 copied = skb->len; 679 680 kfree_skb(skb); 681 682 return copied; 683 } 684 685 static ssize_t 686 capi_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos) 687 { 688 struct capidev *cdev = file->private_data; 689 struct sk_buff *skb; 690 u16 mlen; 691 692 if (!cdev->ap.applid) 693 return -ENODEV; 694 695 skb = alloc_skb(count, GFP_USER); 696 if (!skb) 697 return -ENOMEM; 698 699 if (copy_from_user(skb_put(skb, count), buf, count)) { 700 kfree_skb(skb); 701 return -EFAULT; 702 } 703 mlen = CAPIMSG_LEN(skb->data); 704 if (CAPIMSG_CMD(skb->data) == CAPI_DATA_B3_REQ) { 705 if ((size_t)(mlen + CAPIMSG_DATALEN(skb->data)) != count) { 706 kfree_skb(skb); 707 return -EINVAL; 708 } 709 } else { 710 if (mlen != count) { 711 kfree_skb(skb); 712 return -EINVAL; 713 } 714 } 715 CAPIMSG_SETAPPID(skb->data, cdev->ap.applid); 716 717 if (CAPIMSG_CMD(skb->data) == CAPI_DISCONNECT_B3_RESP) { 718 mutex_lock(&cdev->lock); 719 capincci_free(cdev, CAPIMSG_NCCI(skb->data)); 720 mutex_unlock(&cdev->lock); 721 } 722 723 cdev->errcode = capi20_put_message(&cdev->ap, skb); 724 725 if (cdev->errcode) { 726 kfree_skb(skb); 727 return -EIO; 728 } 729 return count; 730 } 731 732 static unsigned int 733 capi_poll(struct file *file, poll_table *wait) 734 { 735 struct capidev *cdev = file->private_data; 736 unsigned int mask = 0; 737 738 if (!cdev->ap.applid) 739 return POLLERR; 740 741 poll_wait(file, &(cdev->recvwait), wait); 742 mask = POLLOUT | POLLWRNORM; 743 if (!skb_queue_empty(&cdev->recvqueue)) 744 mask |= POLLIN | POLLRDNORM; 745 return mask; 746 } 747 748 static int 749 capi_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 750 { 751 struct capidev *cdev = file->private_data; 752 capi_ioctl_struct data; 753 int retval = -EINVAL; 754 void __user *argp = (void __user *)arg; 755 756 switch (cmd) { 757 case CAPI_REGISTER: 758 mutex_lock(&cdev->lock); 759 760 if (cdev->ap.applid) { 761 retval = -EEXIST; 762 goto register_out; 763 } 764 if (copy_from_user(&cdev->ap.rparam, argp, 765 sizeof(struct capi_register_params))) { 766 retval = -EFAULT; 767 goto register_out; 768 } 769 cdev->ap.private = cdev; 770 cdev->ap.recv_message = capi_recv_message; 771 cdev->errcode = capi20_register(&cdev->ap); 772 retval = (int)cdev->ap.applid; 773 if (cdev->errcode) { 774 cdev->ap.applid = 0; 775 retval = -EIO; 776 } 777 778 register_out: 779 mutex_unlock(&cdev->lock); 780 return retval; 781 782 case CAPI_GET_VERSION: 783 if (copy_from_user(&data.contr, argp, 784 sizeof(data.contr))) 785 return -EFAULT; 786 cdev->errcode = capi20_get_version(data.contr, &data.version); 787 if (cdev->errcode) 788 return -EIO; 789 if (copy_to_user(argp, &data.version, 790 sizeof(data.version))) 791 return -EFAULT; 792 return 0; 793 794 case CAPI_GET_SERIAL: 795 if (copy_from_user(&data.contr, argp, 796 sizeof(data.contr))) 797 return -EFAULT; 798 cdev->errcode = capi20_get_serial(data.contr, data.serial); 799 if (cdev->errcode) 800 return -EIO; 801 if (copy_to_user(argp, data.serial, 802 sizeof(data.serial))) 803 return -EFAULT; 804 return 0; 805 806 case CAPI_GET_PROFILE: 807 if (copy_from_user(&data.contr, argp, 808 sizeof(data.contr))) 809 return -EFAULT; 810 811 if (data.contr == 0) { 812 cdev->errcode = capi20_get_profile(data.contr, &data.profile); 813 if (cdev->errcode) 814 return -EIO; 815 816 retval = copy_to_user(argp, 817 &data.profile.ncontroller, 818 sizeof(data.profile.ncontroller)); 819 820 } else { 821 cdev->errcode = capi20_get_profile(data.contr, &data.profile); 822 if (cdev->errcode) 823 return -EIO; 824 825 retval = copy_to_user(argp, &data.profile, 826 sizeof(data.profile)); 827 } 828 if (retval) 829 return -EFAULT; 830 return 0; 831 832 case CAPI_GET_MANUFACTURER: 833 if (copy_from_user(&data.contr, argp, 834 sizeof(data.contr))) 835 return -EFAULT; 836 cdev->errcode = capi20_get_manufacturer(data.contr, data.manufacturer); 837 if (cdev->errcode) 838 return -EIO; 839 840 if (copy_to_user(argp, data.manufacturer, 841 sizeof(data.manufacturer))) 842 return -EFAULT; 843 844 return 0; 845 846 case CAPI_GET_ERRCODE: 847 data.errcode = cdev->errcode; 848 cdev->errcode = CAPI_NOERROR; 849 if (arg) { 850 if (copy_to_user(argp, &data.errcode, 851 sizeof(data.errcode))) 852 return -EFAULT; 853 } 854 return data.errcode; 855 856 case CAPI_INSTALLED: 857 if (capi20_isinstalled() == CAPI_NOERROR) 858 return 0; 859 return -ENXIO; 860 861 case CAPI_MANUFACTURER_CMD: { 862 struct capi_manufacturer_cmd mcmd; 863 if (!capable(CAP_SYS_ADMIN)) 864 return -EPERM; 865 if (copy_from_user(&mcmd, argp, sizeof(mcmd))) 866 return -EFAULT; 867 return capi20_manufacturer(mcmd.cmd, mcmd.data); 868 } 869 case CAPI_SET_FLAGS: 870 case CAPI_CLR_FLAGS: { 871 unsigned userflags; 872 873 if (copy_from_user(&userflags, argp, sizeof(userflags))) 874 return -EFAULT; 875 876 mutex_lock(&cdev->lock); 877 if (cmd == CAPI_SET_FLAGS) 878 cdev->userflags |= userflags; 879 else 880 cdev->userflags &= ~userflags; 881 mutex_unlock(&cdev->lock); 882 return 0; 883 } 884 case CAPI_GET_FLAGS: 885 if (copy_to_user(argp, &cdev->userflags, 886 sizeof(cdev->userflags))) 887 return -EFAULT; 888 return 0; 889 890 #ifndef CONFIG_ISDN_CAPI_MIDDLEWARE 891 case CAPI_NCCI_OPENCOUNT: 892 return 0; 893 894 #else /* CONFIG_ISDN_CAPI_MIDDLEWARE */ 895 case CAPI_NCCI_OPENCOUNT: { 896 struct capincci *nccip; 897 unsigned ncci; 898 int count = 0; 899 900 if (copy_from_user(&ncci, argp, sizeof(ncci))) 901 return -EFAULT; 902 903 mutex_lock(&cdev->lock); 904 nccip = capincci_find(cdev, (u32)ncci); 905 if (nccip) 906 count = capincci_minor_opencount(nccip); 907 mutex_unlock(&cdev->lock); 908 return count; 909 } 910 911 case CAPI_NCCI_GETUNIT: { 912 struct capincci *nccip; 913 struct capiminor *mp; 914 unsigned ncci; 915 int unit = -ESRCH; 916 917 if (copy_from_user(&ncci, argp, sizeof(ncci))) 918 return -EFAULT; 919 920 mutex_lock(&cdev->lock); 921 nccip = capincci_find(cdev, (u32)ncci); 922 if (nccip) { 923 mp = nccip->minorp; 924 if (mp) 925 unit = mp->minor; 926 } 927 mutex_unlock(&cdev->lock); 928 return unit; 929 } 930 #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */ 931 932 default: 933 return -EINVAL; 934 } 935 } 936 937 static long 938 capi_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 939 { 940 int ret; 941 942 mutex_lock(&capi_mutex); 943 ret = capi_ioctl(file, cmd, arg); 944 mutex_unlock(&capi_mutex); 945 946 return ret; 947 } 948 949 static int capi_open(struct inode *inode, struct file *file) 950 { 951 struct capidev *cdev; 952 953 cdev = kzalloc(sizeof(*cdev), GFP_KERNEL); 954 if (!cdev) 955 return -ENOMEM; 956 957 mutex_init(&cdev->lock); 958 skb_queue_head_init(&cdev->recvqueue); 959 init_waitqueue_head(&cdev->recvwait); 960 INIT_LIST_HEAD(&cdev->nccis); 961 file->private_data = cdev; 962 963 mutex_lock(&capidev_list_lock); 964 list_add_tail(&cdev->list, &capidev_list); 965 mutex_unlock(&capidev_list_lock); 966 967 return nonseekable_open(inode, file); 968 } 969 970 static int capi_release(struct inode *inode, struct file *file) 971 { 972 struct capidev *cdev = file->private_data; 973 974 mutex_lock(&capidev_list_lock); 975 list_del(&cdev->list); 976 mutex_unlock(&capidev_list_lock); 977 978 if (cdev->ap.applid) 979 capi20_release(&cdev->ap); 980 skb_queue_purge(&cdev->recvqueue); 981 capincci_free(cdev, 0xffffffff); 982 983 kfree(cdev); 984 return 0; 985 } 986 987 static const struct file_operations capi_fops = 988 { 989 .owner = THIS_MODULE, 990 .llseek = no_llseek, 991 .read = capi_read, 992 .write = capi_write, 993 .poll = capi_poll, 994 .unlocked_ioctl = capi_unlocked_ioctl, 995 .open = capi_open, 996 .release = capi_release, 997 }; 998 999 #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE 1000 /* -------- tty_operations for capincci ----------------------------- */ 1001 1002 static int 1003 capinc_tty_install(struct tty_driver *driver, struct tty_struct *tty) 1004 { 1005 struct capiminor *mp = capiminor_get(tty->index); 1006 int ret = tty_standard_install(driver, tty); 1007 1008 if (ret == 0) 1009 tty->driver_data = mp; 1010 else 1011 capiminor_put(mp); 1012 return ret; 1013 } 1014 1015 static void capinc_tty_cleanup(struct tty_struct *tty) 1016 { 1017 struct capiminor *mp = tty->driver_data; 1018 tty->driver_data = NULL; 1019 capiminor_put(mp); 1020 } 1021 1022 static int capinc_tty_open(struct tty_struct *tty, struct file *filp) 1023 { 1024 struct capiminor *mp = tty->driver_data; 1025 int err; 1026 1027 err = tty_port_open(&mp->port, tty, filp); 1028 if (err) 1029 return err; 1030 1031 handle_minor_recv(mp); 1032 return 0; 1033 } 1034 1035 static void capinc_tty_close(struct tty_struct *tty, struct file *filp) 1036 { 1037 struct capiminor *mp = tty->driver_data; 1038 1039 tty_port_close(&mp->port, tty, filp); 1040 } 1041 1042 static int capinc_tty_write(struct tty_struct *tty, 1043 const unsigned char *buf, int count) 1044 { 1045 struct capiminor *mp = tty->driver_data; 1046 struct sk_buff *skb; 1047 1048 pr_debug("capinc_tty_write(count=%d)\n", count); 1049 1050 spin_lock_bh(&mp->outlock); 1051 skb = mp->outskb; 1052 if (skb) { 1053 mp->outskb = NULL; 1054 __skb_queue_tail(&mp->outqueue, skb); 1055 mp->outbytes += skb->len; 1056 } 1057 1058 skb = alloc_skb(CAPI_DATA_B3_REQ_LEN + count, GFP_ATOMIC); 1059 if (!skb) { 1060 printk(KERN_ERR "capinc_tty_write: alloc_skb failed\n"); 1061 spin_unlock_bh(&mp->outlock); 1062 return -ENOMEM; 1063 } 1064 1065 skb_reserve(skb, CAPI_DATA_B3_REQ_LEN); 1066 memcpy(skb_put(skb, count), buf, count); 1067 1068 __skb_queue_tail(&mp->outqueue, skb); 1069 mp->outbytes += skb->len; 1070 spin_unlock_bh(&mp->outlock); 1071 1072 handle_minor_send(mp); 1073 1074 return count; 1075 } 1076 1077 static int capinc_tty_put_char(struct tty_struct *tty, unsigned char ch) 1078 { 1079 struct capiminor *mp = tty->driver_data; 1080 bool invoke_send = false; 1081 struct sk_buff *skb; 1082 int ret = 1; 1083 1084 pr_debug("capinc_put_char(%u)\n", ch); 1085 1086 spin_lock_bh(&mp->outlock); 1087 skb = mp->outskb; 1088 if (skb) { 1089 if (skb_tailroom(skb) > 0) { 1090 *(skb_put(skb, 1)) = ch; 1091 goto unlock_out; 1092 } 1093 mp->outskb = NULL; 1094 __skb_queue_tail(&mp->outqueue, skb); 1095 mp->outbytes += skb->len; 1096 invoke_send = true; 1097 } 1098 1099 skb = alloc_skb(CAPI_DATA_B3_REQ_LEN + CAPI_MAX_BLKSIZE, GFP_ATOMIC); 1100 if (skb) { 1101 skb_reserve(skb, CAPI_DATA_B3_REQ_LEN); 1102 *(skb_put(skb, 1)) = ch; 1103 mp->outskb = skb; 1104 } else { 1105 printk(KERN_ERR "capinc_put_char: char %u lost\n", ch); 1106 ret = 0; 1107 } 1108 1109 unlock_out: 1110 spin_unlock_bh(&mp->outlock); 1111 1112 if (invoke_send) 1113 handle_minor_send(mp); 1114 1115 return ret; 1116 } 1117 1118 static void capinc_tty_flush_chars(struct tty_struct *tty) 1119 { 1120 struct capiminor *mp = tty->driver_data; 1121 struct sk_buff *skb; 1122 1123 pr_debug("capinc_tty_flush_chars\n"); 1124 1125 spin_lock_bh(&mp->outlock); 1126 skb = mp->outskb; 1127 if (skb) { 1128 mp->outskb = NULL; 1129 __skb_queue_tail(&mp->outqueue, skb); 1130 mp->outbytes += skb->len; 1131 spin_unlock_bh(&mp->outlock); 1132 1133 handle_minor_send(mp); 1134 } else 1135 spin_unlock_bh(&mp->outlock); 1136 1137 handle_minor_recv(mp); 1138 } 1139 1140 static int capinc_tty_write_room(struct tty_struct *tty) 1141 { 1142 struct capiminor *mp = tty->driver_data; 1143 int room; 1144 1145 room = CAPINC_MAX_SENDQUEUE-skb_queue_len(&mp->outqueue); 1146 room *= CAPI_MAX_BLKSIZE; 1147 pr_debug("capinc_tty_write_room = %d\n", room); 1148 return room; 1149 } 1150 1151 static int capinc_tty_chars_in_buffer(struct tty_struct *tty) 1152 { 1153 struct capiminor *mp = tty->driver_data; 1154 1155 pr_debug("capinc_tty_chars_in_buffer = %d nack=%d sq=%d rq=%d\n", 1156 mp->outbytes, mp->nack, 1157 skb_queue_len(&mp->outqueue), 1158 skb_queue_len(&mp->inqueue)); 1159 return mp->outbytes; 1160 } 1161 1162 static int capinc_tty_ioctl(struct tty_struct *tty, 1163 unsigned int cmd, unsigned long arg) 1164 { 1165 return -ENOIOCTLCMD; 1166 } 1167 1168 static void capinc_tty_set_termios(struct tty_struct *tty, struct ktermios *old) 1169 { 1170 pr_debug("capinc_tty_set_termios\n"); 1171 } 1172 1173 static void capinc_tty_throttle(struct tty_struct *tty) 1174 { 1175 struct capiminor *mp = tty->driver_data; 1176 pr_debug("capinc_tty_throttle\n"); 1177 mp->ttyinstop = 1; 1178 } 1179 1180 static void capinc_tty_unthrottle(struct tty_struct *tty) 1181 { 1182 struct capiminor *mp = tty->driver_data; 1183 1184 pr_debug("capinc_tty_unthrottle\n"); 1185 mp->ttyinstop = 0; 1186 handle_minor_recv(mp); 1187 } 1188 1189 static void capinc_tty_stop(struct tty_struct *tty) 1190 { 1191 struct capiminor *mp = tty->driver_data; 1192 1193 pr_debug("capinc_tty_stop\n"); 1194 mp->ttyoutstop = 1; 1195 } 1196 1197 static void capinc_tty_start(struct tty_struct *tty) 1198 { 1199 struct capiminor *mp = tty->driver_data; 1200 1201 pr_debug("capinc_tty_start\n"); 1202 mp->ttyoutstop = 0; 1203 handle_minor_send(mp); 1204 } 1205 1206 static void capinc_tty_hangup(struct tty_struct *tty) 1207 { 1208 struct capiminor *mp = tty->driver_data; 1209 1210 pr_debug("capinc_tty_hangup\n"); 1211 tty_port_hangup(&mp->port); 1212 } 1213 1214 static int capinc_tty_break_ctl(struct tty_struct *tty, int state) 1215 { 1216 pr_debug("capinc_tty_break_ctl(%d)\n", state); 1217 return 0; 1218 } 1219 1220 static void capinc_tty_flush_buffer(struct tty_struct *tty) 1221 { 1222 pr_debug("capinc_tty_flush_buffer\n"); 1223 } 1224 1225 static void capinc_tty_set_ldisc(struct tty_struct *tty) 1226 { 1227 pr_debug("capinc_tty_set_ldisc\n"); 1228 } 1229 1230 static void capinc_tty_send_xchar(struct tty_struct *tty, char ch) 1231 { 1232 pr_debug("capinc_tty_send_xchar(%d)\n", ch); 1233 } 1234 1235 static const struct tty_operations capinc_ops = { 1236 .open = capinc_tty_open, 1237 .close = capinc_tty_close, 1238 .write = capinc_tty_write, 1239 .put_char = capinc_tty_put_char, 1240 .flush_chars = capinc_tty_flush_chars, 1241 .write_room = capinc_tty_write_room, 1242 .chars_in_buffer = capinc_tty_chars_in_buffer, 1243 .ioctl = capinc_tty_ioctl, 1244 .set_termios = capinc_tty_set_termios, 1245 .throttle = capinc_tty_throttle, 1246 .unthrottle = capinc_tty_unthrottle, 1247 .stop = capinc_tty_stop, 1248 .start = capinc_tty_start, 1249 .hangup = capinc_tty_hangup, 1250 .break_ctl = capinc_tty_break_ctl, 1251 .flush_buffer = capinc_tty_flush_buffer, 1252 .set_ldisc = capinc_tty_set_ldisc, 1253 .send_xchar = capinc_tty_send_xchar, 1254 .install = capinc_tty_install, 1255 .cleanup = capinc_tty_cleanup, 1256 }; 1257 1258 static int __init capinc_tty_init(void) 1259 { 1260 struct tty_driver *drv; 1261 int err; 1262 1263 if (capi_ttyminors > CAPINC_MAX_PORTS) 1264 capi_ttyminors = CAPINC_MAX_PORTS; 1265 if (capi_ttyminors <= 0) 1266 capi_ttyminors = CAPINC_NR_PORTS; 1267 1268 capiminors = kzalloc(sizeof(struct capi_minor *) * capi_ttyminors, 1269 GFP_KERNEL); 1270 if (!capiminors) 1271 return -ENOMEM; 1272 1273 drv = alloc_tty_driver(capi_ttyminors); 1274 if (!drv) { 1275 kfree(capiminors); 1276 return -ENOMEM; 1277 } 1278 drv->driver_name = "capi_nc"; 1279 drv->name = "capi"; 1280 drv->major = 0; 1281 drv->minor_start = 0; 1282 drv->type = TTY_DRIVER_TYPE_SERIAL; 1283 drv->subtype = SERIAL_TYPE_NORMAL; 1284 drv->init_termios = tty_std_termios; 1285 drv->init_termios.c_iflag = ICRNL; 1286 drv->init_termios.c_oflag = OPOST | ONLCR; 1287 drv->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL; 1288 drv->init_termios.c_lflag = 0; 1289 drv->flags = 1290 TTY_DRIVER_REAL_RAW | TTY_DRIVER_RESET_TERMIOS | 1291 TTY_DRIVER_DYNAMIC_DEV; 1292 tty_set_operations(drv, &capinc_ops); 1293 1294 err = tty_register_driver(drv); 1295 if (err) { 1296 put_tty_driver(drv); 1297 kfree(capiminors); 1298 printk(KERN_ERR "Couldn't register capi_nc driver\n"); 1299 return err; 1300 } 1301 capinc_tty_driver = drv; 1302 return 0; 1303 } 1304 1305 static void __exit capinc_tty_exit(void) 1306 { 1307 tty_unregister_driver(capinc_tty_driver); 1308 put_tty_driver(capinc_tty_driver); 1309 kfree(capiminors); 1310 } 1311 1312 #else /* !CONFIG_ISDN_CAPI_MIDDLEWARE */ 1313 1314 static inline int capinc_tty_init(void) 1315 { 1316 return 0; 1317 } 1318 1319 static inline void capinc_tty_exit(void) { } 1320 1321 #endif /* !CONFIG_ISDN_CAPI_MIDDLEWARE */ 1322 1323 /* -------- /proc functions ----------------------------------------- */ 1324 1325 /* 1326 * /proc/capi/capi20: 1327 * minor applid nrecvctlpkt nrecvdatapkt nsendctlpkt nsenddatapkt 1328 */ 1329 static int capi20_proc_show(struct seq_file *m, void *v) 1330 { 1331 struct capidev *cdev; 1332 struct list_head *l; 1333 1334 mutex_lock(&capidev_list_lock); 1335 list_for_each(l, &capidev_list) { 1336 cdev = list_entry(l, struct capidev, list); 1337 seq_printf(m, "0 %d %lu %lu %lu %lu\n", 1338 cdev->ap.applid, 1339 cdev->ap.nrecvctlpkt, 1340 cdev->ap.nrecvdatapkt, 1341 cdev->ap.nsentctlpkt, 1342 cdev->ap.nsentdatapkt); 1343 } 1344 mutex_unlock(&capidev_list_lock); 1345 return 0; 1346 } 1347 1348 static int capi20_proc_open(struct inode *inode, struct file *file) 1349 { 1350 return single_open(file, capi20_proc_show, NULL); 1351 } 1352 1353 static const struct file_operations capi20_proc_fops = { 1354 .owner = THIS_MODULE, 1355 .open = capi20_proc_open, 1356 .read = seq_read, 1357 .llseek = seq_lseek, 1358 .release = single_release, 1359 }; 1360 1361 /* 1362 * /proc/capi/capi20ncci: 1363 * applid ncci 1364 */ 1365 static int capi20ncci_proc_show(struct seq_file *m, void *v) 1366 { 1367 struct capidev *cdev; 1368 struct capincci *np; 1369 1370 mutex_lock(&capidev_list_lock); 1371 list_for_each_entry(cdev, &capidev_list, list) { 1372 mutex_lock(&cdev->lock); 1373 list_for_each_entry(np, &cdev->nccis, list) 1374 seq_printf(m, "%d 0x%x\n", cdev->ap.applid, np->ncci); 1375 mutex_unlock(&cdev->lock); 1376 } 1377 mutex_unlock(&capidev_list_lock); 1378 return 0; 1379 } 1380 1381 static int capi20ncci_proc_open(struct inode *inode, struct file *file) 1382 { 1383 return single_open(file, capi20ncci_proc_show, NULL); 1384 } 1385 1386 static const struct file_operations capi20ncci_proc_fops = { 1387 .owner = THIS_MODULE, 1388 .open = capi20ncci_proc_open, 1389 .read = seq_read, 1390 .llseek = seq_lseek, 1391 .release = single_release, 1392 }; 1393 1394 static void __init proc_init(void) 1395 { 1396 proc_create("capi/capi20", 0, NULL, &capi20_proc_fops); 1397 proc_create("capi/capi20ncci", 0, NULL, &capi20ncci_proc_fops); 1398 } 1399 1400 static void __exit proc_exit(void) 1401 { 1402 remove_proc_entry("capi/capi20", NULL); 1403 remove_proc_entry("capi/capi20ncci", NULL); 1404 } 1405 1406 /* -------- init function and module interface ---------------------- */ 1407 1408 1409 static int __init capi_init(void) 1410 { 1411 const char *compileinfo; 1412 int major_ret; 1413 1414 major_ret = register_chrdev(capi_major, "capi20", &capi_fops); 1415 if (major_ret < 0) { 1416 printk(KERN_ERR "capi20: unable to get major %d\n", capi_major); 1417 return major_ret; 1418 } 1419 capi_class = class_create(THIS_MODULE, "capi"); 1420 if (IS_ERR(capi_class)) { 1421 unregister_chrdev(capi_major, "capi20"); 1422 return PTR_ERR(capi_class); 1423 } 1424 1425 device_create(capi_class, NULL, MKDEV(capi_major, 0), NULL, "capi"); 1426 1427 if (capinc_tty_init() < 0) { 1428 device_destroy(capi_class, MKDEV(capi_major, 0)); 1429 class_destroy(capi_class); 1430 unregister_chrdev(capi_major, "capi20"); 1431 return -ENOMEM; 1432 } 1433 1434 proc_init(); 1435 1436 #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE 1437 compileinfo = " (middleware)"; 1438 #else 1439 compileinfo = " (no middleware)"; 1440 #endif 1441 printk(KERN_NOTICE "CAPI 2.0 started up with major %d%s\n", 1442 capi_major, compileinfo); 1443 1444 return 0; 1445 } 1446 1447 static void __exit capi_exit(void) 1448 { 1449 proc_exit(); 1450 1451 device_destroy(capi_class, MKDEV(capi_major, 0)); 1452 class_destroy(capi_class); 1453 unregister_chrdev(capi_major, "capi20"); 1454 1455 capinc_tty_exit(); 1456 } 1457 1458 module_init(capi_init); 1459 module_exit(capi_exit); 1460