kernel/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 capiminor *mp;
 573         u16 datahandle;
 574         struct capincci *np;
 575 #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
 576
 577         mutex_lock(&cdev->lock);
 578
 579         if (CAPIMSG_CMD(skb->data) == CAPI_CONNECT_B3_CONF) {
 580                 u16 info = CAPIMSG_U16(skb->data, 12); // Info field
 581                 if ((info & 0xff00) == 0)
 582                         capincci_alloc(cdev, CAPIMSG_NCCI(skb->data));
 583         }
 584         if (CAPIMSG_CMD(skb->data) == CAPI_CONNECT_B3_IND)
 585                 capincci_alloc(cdev, CAPIMSG_NCCI(skb->data));
 586
 587         if (CAPIMSG_COMMAND(skb->data) != CAPI_DATA_B3) {
 588                 skb_queue_tail(&cdev->recvqueue, skb);
 589                 wake_up_interruptible(&cdev->recvwait);
 590                 goto unlock_out;
 591         }
 592
 593 #ifndef CONFIG_ISDN_CAPI_MIDDLEWARE
 594         skb_queue_tail(&cdev->recvqueue, skb);
 595         wake_up_interruptible(&cdev->recvwait);
 596
 597 #else /* CONFIG_ISDN_CAPI_MIDDLEWARE */
 598
 599         np = capincci_find(cdev, CAPIMSG_CONTROL(skb->data));
 600         if (!np) {
 601                 printk(KERN_ERR "BUG: capi_signal: ncci not found\n");
 602                 skb_queue_tail(&cdev->recvqueue, skb);
 603                 wake_up_interruptible(&cdev->recvwait);
 604                 goto unlock_out;
 605         }
 606
 607         mp = np->minorp;
 608         if (!mp) {
 609                 skb_queue_tail(&cdev->recvqueue, skb);
 610                 wake_up_interruptible(&cdev->recvwait);
 611                 goto unlock_out;
 612         }
 613         if (CAPIMSG_SUBCOMMAND(skb->data) == CAPI_IND) {
 614                 datahandle = CAPIMSG_U16(skb->data, CAPIMSG_BASELEN + 4 + 4 + 2);
 615                 pr_debug("capi_signal: DATA_B3_IND %u len=%d\n",
 616                          datahandle, skb->len-CAPIMSG_LEN(skb->data));
 617                 skb_queue_tail(&mp->inqueue, skb);
 618
 619                 handle_minor_recv(mp);
 620
 621         } else if (CAPIMSG_SUBCOMMAND(skb->data) == CAPI_CONF) {
 622
 623                 datahandle = CAPIMSG_U16(skb->data, CAPIMSG_BASELEN + 4);
 624                 pr_debug("capi_signal: DATA_B3_CONF %u 0x%x\n",
 625                          datahandle,
 626                          CAPIMSG_U16(skb->data, CAPIMSG_BASELEN + 4 + 2));
 627                 kfree_skb(skb);
 628                 capiminor_del_ack(mp, datahandle);
 629                 tty_port_tty_wakeup(&mp->port);
 630                 handle_minor_send(mp);
 631
 632         } else {
 633                 /* ups, let capi application handle it :-) */
 634                 skb_queue_tail(&cdev->recvqueue, skb);
 635                 wake_up_interruptible(&cdev->recvwait);
 636         }
 637 #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
 638
 639 unlock_out:
 640         mutex_unlock(&cdev->lock);
 641 }
 642
 643 /* -------- file_operations for capidev ----------------------------- */
 644
 645 static ssize_t
 646 capi_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
 647 {
 648         struct capidev *cdev = file->private_data;
 649         struct sk_buff *skb;
 650         size_t copied;
 651         int err;
 652
 653         if (!cdev->ap.applid)
 654                 return -ENODEV;
 655
 656         skb = skb_dequeue(&cdev->recvqueue);
 657         if (!skb) {
 658                 if (file->f_flags & O_NONBLOCK)
 659                         return -EAGAIN;
 660                 err = wait_event_interruptible(cdev->recvwait,
 661                                                (skb = skb_dequeue(&cdev->recvqueue)));
 662                 if (err)
 663                         return err;
 664         }
 665         if (skb->len > count) {
 666                 skb_queue_head(&cdev->recvqueue, skb);
 667                 return -EMSGSIZE;
 668         }
 669         if (copy_to_user(buf, skb->data, skb->len)) {
 670                 skb_queue_head(&cdev->recvqueue, skb);
 671                 return -EFAULT;
 672         }
 673         copied = skb->len;
 674
 675         kfree_skb(skb);
 676
 677         return copied;
 678 }
 679
 680 static ssize_t
 681 capi_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
 682 {
 683         struct capidev *cdev = file->private_data;
 684         struct sk_buff *skb;
 685         u16 mlen;
 686
 687         if (!cdev->ap.applid)
 688                 return -ENODEV;
 689
 690         skb = alloc_skb(count, GFP_USER);
 691         if (!skb)
 692                 return -ENOMEM;
 693
 694         if (copy_from_user(skb_put(skb, count), buf, count)) {
 695                 kfree_skb(skb);
 696                 return -EFAULT;
 697         }
 698         mlen = CAPIMSG_LEN(skb->data);
 699         if (CAPIMSG_CMD(skb->data) == CAPI_DATA_B3_REQ) {
 700                 if ((size_t)(mlen + CAPIMSG_DATALEN(skb->data)) != count) {
 701                         kfree_skb(skb);
 702                         return -EINVAL;
 703                 }
 704         } else {
 705                 if (mlen != count) {
 706                         kfree_skb(skb);
 707                         return -EINVAL;
 708                 }
 709         }
 710         CAPIMSG_SETAPPID(skb->data, cdev->ap.applid);
 711
 712         if (CAPIMSG_CMD(skb->data) == CAPI_DISCONNECT_B3_RESP) {
 713                 mutex_lock(&cdev->lock);
 714                 capincci_free(cdev, CAPIMSG_NCCI(skb->data));
 715                 mutex_unlock(&cdev->lock);
 716         }
 717
 718         cdev->errcode = capi20_put_message(&cdev->ap, skb);
 719
 720         if (cdev->errcode) {
 721                 kfree_skb(skb);
 722                 return -EIO;
 723         }
 724         return count;
 725 }
 726
 727 static unsigned int
 728 capi_poll(struct file *file, poll_table *wait)
 729 {
 730         struct capidev *cdev = file->private_data;
 731         unsigned int mask = 0;
 732
 733         if (!cdev->ap.applid)
 734                 return POLLERR;
 735
 736         poll_wait(file, &(cdev->recvwait), wait);
 737         mask = POLLOUT | POLLWRNORM;
 738         if (!skb_queue_empty(&cdev->recvqueue))
 739                 mask |= POLLIN | POLLRDNORM;
 740         return mask;
 741 }
 742
 743 static int
 744 capi_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 745 {
 746         struct capidev *cdev = file->private_data;
 747         capi_ioctl_struct data;
 748         int retval = -EINVAL;
 749         void __user *argp = (void __user *)arg;
 750
 751         switch (cmd) {
 752         case CAPI_REGISTER:
 753                 mutex_lock(&cdev->lock);
 754
 755                 if (cdev->ap.applid) {
 756                         retval = -EEXIST;
 757                         goto register_out;
 758                 }
 759                 if (copy_from_user(&cdev->ap.rparam, argp,
 760                                    sizeof(struct capi_register_params))) {
 761                         retval = -EFAULT;
 762                         goto register_out;
 763                 }
 764                 cdev->ap.private = cdev;
 765                 cdev->ap.recv_message = capi_recv_message;
 766                 cdev->errcode = capi20_register(&cdev->ap);
 767                 retval = (int)cdev->ap.applid;
 768                 if (cdev->errcode) {
 769                         cdev->ap.applid = 0;
 770                         retval = -EIO;
 771                 }
 772
 773 register_out:
 774                 mutex_unlock(&cdev->lock);
 775                 return retval;
 776
 777         case CAPI_GET_VERSION:
 778                 if (copy_from_user(&data.contr, argp,
 779                                    sizeof(data.contr)))
 780                         return -EFAULT;
 781                 cdev->errcode = capi20_get_version(data.contr, &data.version);
 782                 if (cdev->errcode)
 783                         return -EIO;
 784                 if (copy_to_user(argp, &data.version,
 785                                  sizeof(data.version)))
 786                         return -EFAULT;
 787                 return 0;
 788
 789         case CAPI_GET_SERIAL:
 790                 if (copy_from_user(&data.contr, argp,
 791                                    sizeof(data.contr)))
 792                         return -EFAULT;
 793                 cdev->errcode = capi20_get_serial(data.contr, data.serial);
 794                 if (cdev->errcode)
 795                         return -EIO;
 796                 if (copy_to_user(argp, data.serial,
 797                                  sizeof(data.serial)))
 798                         return -EFAULT;
 799                 return 0;
 800
 801         case CAPI_GET_PROFILE:
 802                 if (copy_from_user(&data.contr, argp,
 803                                    sizeof(data.contr)))
 804                         return -EFAULT;
 805
 806                 if (data.contr == 0) {
 807                         cdev->errcode = capi20_get_profile(data.contr, &data.profile);
 808                         if (cdev->errcode)
 809                                 return -EIO;
 810
 811                         retval = copy_to_user(argp,
 812                                               &data.profile.ncontroller,
 813                                               sizeof(data.profile.ncontroller));
 814
 815                 } else {
 816                         cdev->errcode = capi20_get_profile(data.contr, &data.profile);
 817                         if (cdev->errcode)
 818                                 return -EIO;
 819
 820                         retval = copy_to_user(argp, &data.profile,
 821                                               sizeof(data.profile));
 822                 }
 823                 if (retval)
 824                         return -EFAULT;
 825                 return 0;
 826
 827         case CAPI_GET_MANUFACTURER:
 828                 if (copy_from_user(&data.contr, argp,
 829                                    sizeof(data.contr)))
 830                         return -EFAULT;
 831                 cdev->errcode = capi20_get_manufacturer(data.contr, data.manufacturer);
 832                 if (cdev->errcode)
 833                         return -EIO;
 834
 835                 if (copy_to_user(argp, data.manufacturer,
 836                                  sizeof(data.manufacturer)))
 837                         return -EFAULT;
 838
 839                 return 0;
 840
 841         case CAPI_GET_ERRCODE:
 842                 data.errcode = cdev->errcode;
 843                 cdev->errcode = CAPI_NOERROR;
 844                 if (arg) {
 845                         if (copy_to_user(argp, &data.errcode,
 846                                          sizeof(data.errcode)))
 847                                 return -EFAULT;
 848                 }
 849                 return data.errcode;
 850
 851         case CAPI_INSTALLED:
 852                 if (capi20_isinstalled() == CAPI_NOERROR)
 853                         return 0;
 854                 return -ENXIO;
 855
 856         case CAPI_MANUFACTURER_CMD: {
 857                 struct capi_manufacturer_cmd mcmd;
 858                 if (!capable(CAP_SYS_ADMIN))
 859                         return -EPERM;
 860                 if (copy_from_user(&mcmd, argp, sizeof(mcmd)))
 861                         return -EFAULT;
 862                 return capi20_manufacturer(mcmd.cmd, mcmd.data);
 863         }
 864         case CAPI_SET_FLAGS:
 865         case CAPI_CLR_FLAGS: {
 866                 unsigned userflags;
 867
 868                 if (copy_from_user(&userflags, argp, sizeof(userflags)))
 869                         return -EFAULT;
 870
 871                 mutex_lock(&cdev->lock);
 872                 if (cmd == CAPI_SET_FLAGS)
 873                         cdev->userflags |= userflags;
 874                 else
 875                         cdev->userflags &= ~userflags;
 876                 mutex_unlock(&cdev->lock);
 877                 return 0;
 878         }
 879         case CAPI_GET_FLAGS:
 880                 if (copy_to_user(argp, &cdev->userflags,
 881                                  sizeof(cdev->userflags)))
 882                         return -EFAULT;
 883                 return 0;
 884
 885 #ifndef CONFIG_ISDN_CAPI_MIDDLEWARE
 886         case CAPI_NCCI_OPENCOUNT:
 887                 return 0;
 888
 889 #else /* CONFIG_ISDN_CAPI_MIDDLEWARE */
 890         case CAPI_NCCI_OPENCOUNT: {
 891                 struct capincci *nccip;
 892                 unsigned ncci;
 893                 int count = 0;
 894
 895                 if (copy_from_user(&ncci, argp, sizeof(ncci)))
 896                         return -EFAULT;
 897
 898                 mutex_lock(&cdev->lock);
 899                 nccip = capincci_find(cdev, (u32)ncci);
 900                 if (nccip)
 901                         count = capincci_minor_opencount(nccip);
 902                 mutex_unlock(&cdev->lock);
 903                 return count;
 904         }
 905
 906         case CAPI_NCCI_GETUNIT: {
 907                 struct capincci *nccip;
 908                 struct capiminor *mp;
 909                 unsigned ncci;
 910                 int unit = -ESRCH;
 911
 912                 if (copy_from_user(&ncci, argp, sizeof(ncci)))
 913                         return -EFAULT;
 914
 915                 mutex_lock(&cdev->lock);
 916                 nccip = capincci_find(cdev, (u32)ncci);
 917                 if (nccip) {
 918                         mp = nccip->minorp;
 919                         if (mp)
 920                                 unit = mp->minor;
 921                 }
 922                 mutex_unlock(&cdev->lock);
 923                 return unit;
 924         }
 925 #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
 926
 927         default:
 928                 return -EINVAL;
 929         }
 930 }
 931
 932 static long
 933 capi_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 934 {
 935         int ret;
 936
 937         mutex_lock(&capi_mutex);
 938         ret = capi_ioctl(file, cmd, arg);
 939         mutex_unlock(&capi_mutex);
 940
 941         return ret;
 942 }
 943
 944 static int capi_open(struct inode *inode, struct file *file)
 945 {
 946         struct capidev *cdev;
 947
 948         cdev = kzalloc(sizeof(*cdev), GFP_KERNEL);
 949         if (!cdev)
 950                 return -ENOMEM;
 951
 952         mutex_init(&cdev->lock);
 953         skb_queue_head_init(&cdev->recvqueue);
 954         init_waitqueue_head(&cdev->recvwait);
 955         INIT_LIST_HEAD(&cdev->nccis);
 956         file->private_data = cdev;
 957
 958         mutex_lock(&capidev_list_lock);
 959         list_add_tail(&cdev->list, &capidev_list);
 960         mutex_unlock(&capidev_list_lock);
 961
 962         return nonseekable_open(inode, file);
 963 }
 964
 965 static int capi_release(struct inode *inode, struct file *file)
 966 {
 967         struct capidev *cdev = file->private_data;
 968
 969         mutex_lock(&capidev_list_lock);
 970         list_del(&cdev->list);
 971         mutex_unlock(&capidev_list_lock);
 972
 973         if (cdev->ap.applid)
 974                 capi20_release(&cdev->ap);
 975         skb_queue_purge(&cdev->recvqueue);
 976         capincci_free(cdev, 0xffffffff);
 977
 978         kfree(cdev);
 979         return 0;
 980 }
 981
 982 static const struct file_operations capi_fops =
 983 {
 984         .owner          = THIS_MODULE,
 985         .llseek         = no_llseek,
 986         .read           = capi_read,
 987         .write          = capi_write,
 988         .poll           = capi_poll,
 989         .unlocked_ioctl = capi_unlocked_ioctl,
 990         .open           = capi_open,
 991         .release        = capi_release,
 992 };
 993
 994 #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
 995 /* -------- tty_operations for capincci ----------------------------- */
 996
 997 static int
 998 capinc_tty_install(struct tty_driver *driver, struct tty_struct *tty)
 999 {
1000         struct capiminor *mp = capiminor_get(tty->index);
1001         int ret = tty_standard_install(driver, tty);
1002
1003         if (ret == 0)
1004                 tty->driver_data = mp;
1005         else
1006                 capiminor_put(mp);
1007         return ret;
1008 }
1009
1010 static void capinc_tty_cleanup(struct tty_struct *tty)
1011 {
1012         struct capiminor *mp = tty->driver_data;
1013         tty->driver_data = NULL;
1014         capiminor_put(mp);
1015 }
1016
1017 static int capinc_tty_open(struct tty_struct *tty, struct file *filp)
1018 {
1019         struct capiminor *mp = tty->driver_data;
1020         int err;
1021
1022         err = tty_port_open(&mp->port, tty, filp);
1023         if (err)
1024                 return err;
1025
1026         handle_minor_recv(mp);
1027         return 0;
1028 }
1029
1030 static void capinc_tty_close(struct tty_struct *tty, struct file *filp)
1031 {
1032         struct capiminor *mp = tty->driver_data;
1033
1034         tty_port_close(&mp->port, tty, filp);
1035 }
1036
1037 static int capinc_tty_write(struct tty_struct *tty,
1038                             const unsigned char *buf, int count)
1039 {
1040         struct capiminor *mp = tty->driver_data;
1041         struct sk_buff *skb;
1042
1043         pr_debug("capinc_tty_write(count=%d)\n", count);
1044
1045         spin_lock_bh(&mp->outlock);
1046         skb = mp->outskb;
1047         if (skb) {
1048                 mp->outskb = NULL;
1049                 __skb_queue_tail(&mp->outqueue, skb);
1050                 mp->outbytes += skb->len;
1051         }
1052
1053         skb = alloc_skb(CAPI_DATA_B3_REQ_LEN + count, GFP_ATOMIC);
1054         if (!skb) {
1055                 printk(KERN_ERR "capinc_tty_write: alloc_skb failed\n");
1056                 spin_unlock_bh(&mp->outlock);
1057                 return -ENOMEM;
1058         }
1059
1060         skb_reserve(skb, CAPI_DATA_B3_REQ_LEN);
1061         memcpy(skb_put(skb, count), buf, count);
1062
1063         __skb_queue_tail(&mp->outqueue, skb);
1064         mp->outbytes += skb->len;
1065         spin_unlock_bh(&mp->outlock);
1066
1067         handle_minor_send(mp);
1068
1069         return count;
1070 }
1071
1072 static int capinc_tty_put_char(struct tty_struct *tty, unsigned char ch)
1073 {
1074         struct capiminor *mp = tty->driver_data;
1075         bool invoke_send = false;
1076         struct sk_buff *skb;
1077         int ret = 1;
1078
1079         pr_debug("capinc_put_char(%u)\n", ch);
1080
1081         spin_lock_bh(&mp->outlock);
1082         skb = mp->outskb;
1083         if (skb) {
1084                 if (skb_tailroom(skb) > 0) {
1085                         *(skb_put(skb, 1)) = ch;
1086                         goto unlock_out;
1087                 }
1088                 mp->outskb = NULL;
1089                 __skb_queue_tail(&mp->outqueue, skb);
1090                 mp->outbytes += skb->len;
1091                 invoke_send = true;
1092         }
1093
1094         skb = alloc_skb(CAPI_DATA_B3_REQ_LEN + CAPI_MAX_BLKSIZE, GFP_ATOMIC);
1095         if (skb) {
1096                 skb_reserve(skb, CAPI_DATA_B3_REQ_LEN);
1097                 *(skb_put(skb, 1)) = ch;
1098                 mp->outskb = skb;
1099         } else {
1100                 printk(KERN_ERR "capinc_put_char: char %u lost\n", ch);
1101                 ret = 0;
1102         }
1103
1104 unlock_out:
1105         spin_unlock_bh(&mp->outlock);
1106
1107         if (invoke_send)
1108                 handle_minor_send(mp);
1109
1110         return ret;
1111 }
1112
1113 static void capinc_tty_flush_chars(struct tty_struct *tty)
1114 {
1115         struct capiminor *mp = tty->driver_data;
1116         struct sk_buff *skb;
1117
1118         pr_debug("capinc_tty_flush_chars\n");
1119
1120         spin_lock_bh(&mp->outlock);
1121         skb = mp->outskb;
1122         if (skb) {
1123                 mp->outskb = NULL;
1124                 __skb_queue_tail(&mp->outqueue, skb);
1125                 mp->outbytes += skb->len;
1126                 spin_unlock_bh(&mp->outlock);
1127
1128                 handle_minor_send(mp);
1129         } else
1130                 spin_unlock_bh(&mp->outlock);
1131
1132         handle_minor_recv(mp);
1133 }
1134
1135 static int capinc_tty_write_room(struct tty_struct *tty)
1136 {
1137         struct capiminor *mp = tty->driver_data;
1138         int room;
1139
1140         room = CAPINC_MAX_SENDQUEUE-skb_queue_len(&mp->outqueue);
1141         room *= CAPI_MAX_BLKSIZE;
1142         pr_debug("capinc_tty_write_room = %d\n", room);
1143         return room;
1144 }
1145
1146 static int capinc_tty_chars_in_buffer(struct tty_struct *tty)
1147 {
1148         struct capiminor *mp = tty->driver_data;
1149
1150         pr_debug("capinc_tty_chars_in_buffer = %d nack=%d sq=%d rq=%d\n",
1151                  mp->outbytes, mp->nack,
1152                  skb_queue_len(&mp->outqueue),
1153                  skb_queue_len(&mp->inqueue));
1154         return mp->outbytes;
1155 }
1156
1157 static int capinc_tty_ioctl(struct tty_struct *tty,
1158                             unsigned int cmd, unsigned long arg)
1159 {
1160         return -ENOIOCTLCMD;
1161 }
1162
1163 static void capinc_tty_set_termios(struct tty_struct *tty, struct ktermios *old)
1164 {
1165         pr_debug("capinc_tty_set_termios\n");
1166 }
1167
1168 static void capinc_tty_throttle(struct tty_struct *tty)
1169 {
1170         struct capiminor *mp = tty->driver_data;
1171         pr_debug("capinc_tty_throttle\n");
1172         mp->ttyinstop = 1;
1173 }
1174
1175 static void capinc_tty_unthrottle(struct tty_struct *tty)
1176 {
1177         struct capiminor *mp = tty->driver_data;
1178
1179         pr_debug("capinc_tty_unthrottle\n");
1180         mp->ttyinstop = 0;
1181         handle_minor_recv(mp);
1182 }
1183
1184 static void capinc_tty_stop(struct tty_struct *tty)
1185 {
1186         struct capiminor *mp = tty->driver_data;
1187
1188         pr_debug("capinc_tty_stop\n");
1189         mp->ttyoutstop = 1;
1190 }
1191
1192 static void capinc_tty_start(struct tty_struct *tty)
1193 {
1194         struct capiminor *mp = tty->driver_data;
1195
1196         pr_debug("capinc_tty_start\n");
1197         mp->ttyoutstop = 0;
1198         handle_minor_send(mp);
1199 }
1200
1201 static void capinc_tty_hangup(struct tty_struct *tty)
1202 {
1203         struct capiminor *mp = tty->driver_data;
1204
1205         pr_debug("capinc_tty_hangup\n");
1206         tty_port_hangup(&mp->port);
1207 }
1208
1209 static int capinc_tty_break_ctl(struct tty_struct *tty, int state)
1210 {
1211         pr_debug("capinc_tty_break_ctl(%d)\n", state);
1212         return 0;
1213 }
1214
1215 static void capinc_tty_flush_buffer(struct tty_struct *tty)
1216 {
1217         pr_debug("capinc_tty_flush_buffer\n");
1218 }
1219
1220 static void capinc_tty_set_ldisc(struct tty_struct *tty)
1221 {
1222         pr_debug("capinc_tty_set_ldisc\n");
1223 }
1224
1225 static void capinc_tty_send_xchar(struct tty_struct *tty, char ch)
1226 {
1227         pr_debug("capinc_tty_send_xchar(%d)\n", ch);
1228 }
1229
1230 static const struct tty_operations capinc_ops = {
1231         .open = capinc_tty_open,
1232         .close = capinc_tty_close,
1233         .write = capinc_tty_write,
1234         .put_char = capinc_tty_put_char,
1235         .flush_chars = capinc_tty_flush_chars,
1236         .write_room = capinc_tty_write_room,
1237         .chars_in_buffer = capinc_tty_chars_in_buffer,
1238         .ioctl = capinc_tty_ioctl,
1239         .set_termios = capinc_tty_set_termios,
1240         .throttle = capinc_tty_throttle,
1241         .unthrottle = capinc_tty_unthrottle,
1242         .stop = capinc_tty_stop,
1243         .start = capinc_tty_start,
1244         .hangup = capinc_tty_hangup,
1245         .break_ctl = capinc_tty_break_ctl,
1246         .flush_buffer = capinc_tty_flush_buffer,
1247         .set_ldisc = capinc_tty_set_ldisc,
1248         .send_xchar = capinc_tty_send_xchar,
1249         .install = capinc_tty_install,
1250         .cleanup = capinc_tty_cleanup,
1251 };
1252
1253 static int __init capinc_tty_init(void)
1254 {
1255         struct tty_driver *drv;
1256         int err;
1257
1258         if (capi_ttyminors > CAPINC_MAX_PORTS)
1259                 capi_ttyminors = CAPINC_MAX_PORTS;
1260         if (capi_ttyminors <= 0)
1261                 capi_ttyminors = CAPINC_NR_PORTS;
1262
1263         capiminors = kzalloc(sizeof(struct capiminor *) * capi_ttyminors,
1264                              GFP_KERNEL);
1265         if (!capiminors)
1266                 return -ENOMEM;
1267
1268         drv = alloc_tty_driver(capi_ttyminors);
1269         if (!drv) {
1270                 kfree(capiminors);
1271                 return -ENOMEM;
1272         }
1273         drv->driver_name = "capi_nc";
1274         drv->name = "capi!";
1275         drv->major = 0;
1276         drv->minor_start = 0;
1277         drv->type = TTY_DRIVER_TYPE_SERIAL;
1278         drv->subtype = SERIAL_TYPE_NORMAL;
1279         drv->init_termios = tty_std_termios;
1280         drv->init_termios.c_iflag = ICRNL;
1281         drv->init_termios.c_oflag = OPOST | ONLCR;
1282         drv->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1283         drv->init_termios.c_lflag = 0;
1284         drv->flags =
1285                 TTY_DRIVER_REAL_RAW | TTY_DRIVER_RESET_TERMIOS |
1286                 TTY_DRIVER_DYNAMIC_DEV;
1287         tty_set_operations(drv, &capinc_ops);
1288
1289         err = tty_register_driver(drv);
1290         if (err) {
1291                 put_tty_driver(drv);
1292                 kfree(capiminors);
1293                 printk(KERN_ERR "Couldn't register capi_nc driver\n");
1294                 return err;
1295         }
1296         capinc_tty_driver = drv;
1297         return 0;
1298 }
1299
1300 static void __exit capinc_tty_exit(void)
1301 {
1302         tty_unregister_driver(capinc_tty_driver);
1303         put_tty_driver(capinc_tty_driver);
1304         kfree(capiminors);
1305 }
1306
1307 #else /* !CONFIG_ISDN_CAPI_MIDDLEWARE */
1308
1309 static inline int capinc_tty_init(void)
1310 {
1311         return 0;
1312 }
1313
1314 static inline void capinc_tty_exit(void) { }
1315
1316 #endif /* !CONFIG_ISDN_CAPI_MIDDLEWARE */
1317
1318 /* -------- /proc functions ----------------------------------------- */
1319
1320 /*
1321  * /proc/capi/capi20:
1322  *  minor applid nrecvctlpkt nrecvdatapkt nsendctlpkt nsenddatapkt
1323  */
1324 static int capi20_proc_show(struct seq_file *m, void *v)
1325 {
1326         struct capidev *cdev;
1327         struct list_head *l;
1328
1329         mutex_lock(&capidev_list_lock);
1330         list_for_each(l, &capidev_list) {
1331                 cdev = list_entry(l, struct capidev, list);
1332                 seq_printf(m, "0 %d %lu %lu %lu %lu\n",
1333                            cdev->ap.applid,
1334                            cdev->ap.nrecvctlpkt,
1335                            cdev->ap.nrecvdatapkt,
1336                            cdev->ap.nsentctlpkt,
1337                            cdev->ap.nsentdatapkt);
1338         }
1339         mutex_unlock(&capidev_list_lock);
1340         return 0;
1341 }
1342
1343 static int capi20_proc_open(struct inode *inode, struct file *file)
1344 {
1345         return single_open(file, capi20_proc_show, NULL);
1346 }
1347
1348 static const struct file_operations capi20_proc_fops = {
1349         .owner          = THIS_MODULE,
1350         .open           = capi20_proc_open,
1351         .read           = seq_read,
1352         .llseek         = seq_lseek,
1353         .release        = single_release,
1354 };
1355
1356 /*
1357  * /proc/capi/capi20ncci:
1358  *  applid ncci
1359  */
1360 static int capi20ncci_proc_show(struct seq_file *m, void *v)
1361 {
1362         struct capidev *cdev;
1363         struct capincci *np;
1364
1365         mutex_lock(&capidev_list_lock);
1366         list_for_each_entry(cdev, &capidev_list, list) {
1367                 mutex_lock(&cdev->lock);
1368                 list_for_each_entry(np, &cdev->nccis, list)
1369                         seq_printf(m, "%d 0x%x\n", cdev->ap.applid, np->ncci);
1370                 mutex_unlock(&cdev->lock);
1371         }
1372         mutex_unlock(&capidev_list_lock);
1373         return 0;
1374 }
1375
1376 static int capi20ncci_proc_open(struct inode *inode, struct file *file)
1377 {
1378         return single_open(file, capi20ncci_proc_show, NULL);
1379 }
1380
1381 static const struct file_operations capi20ncci_proc_fops = {
1382         .owner          = THIS_MODULE,
1383         .open           = capi20ncci_proc_open,
1384         .read           = seq_read,
1385         .llseek         = seq_lseek,
1386         .release        = single_release,
1387 };
1388
1389 static void __init proc_init(void)
1390 {
1391         proc_create("capi/capi20", 0, NULL, &capi20_proc_fops);
1392         proc_create("capi/capi20ncci", 0, NULL, &capi20ncci_proc_fops);
1393 }
1394
1395 static void __exit proc_exit(void)
1396 {
1397         remove_proc_entry("capi/capi20", NULL);
1398         remove_proc_entry("capi/capi20ncci", NULL);
1399 }
1400
1401 /* -------- init function and module interface ---------------------- */
1402
1403
1404 static int __init capi_init(void)
1405 {
1406         const char *compileinfo;
1407         int major_ret;
1408
1409         major_ret = register_chrdev(capi_major, "capi20", &capi_fops);
1410         if (major_ret < 0) {
1411                 printk(KERN_ERR "capi20: unable to get major %d\n", capi_major);
1412                 return major_ret;
1413         }
1414         capi_class = class_create(THIS_MODULE, "capi");
1415         if (IS_ERR(capi_class)) {
1416                 unregister_chrdev(capi_major, "capi20");
1417                 return PTR_ERR(capi_class);
1418         }
1419
1420         device_create(capi_class, NULL, MKDEV(capi_major, 0), NULL, "capi20");
1421
1422         if (capinc_tty_init() < 0) {
1423                 device_destroy(capi_class, MKDEV(capi_major, 0));
1424                 class_destroy(capi_class);
1425                 unregister_chrdev(capi_major, "capi20");
1426                 return -ENOMEM;
1427         }
1428
1429         proc_init();
1430
1431 #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
1432         compileinfo = " (middleware)";
1433 #else
1434         compileinfo = " (no middleware)";
1435 #endif
1436         printk(KERN_NOTICE "CAPI 2.0 started up with major %d%s\n",
1437                capi_major, compileinfo);
1438
1439         return 0;
1440 }
1441
1442 static void __exit capi_exit(void)
1443 {
1444         proc_exit();
1445
1446         device_destroy(capi_class, MKDEV(capi_major, 0));
1447         class_destroy(capi_class);
1448         unregister_chrdev(capi_major, "capi20");
1449
1450         capinc_tty_exit();
1451 }
1452
1453 module_init(capi_init);
1454 module_exit(capi_exit);