drivers/isdn/capi/capi.c

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