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