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