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