55 files changed, 1727 insertions, 1723 deletions

diff --git a/drivers/isdn/Kconfig b/drivers/isdn/Kconfig
index 022a19452953..4fb601670de3 100644
--- a/drivers/isdn/Kconfig
+++ b/drivers/isdn/Kconfig
@@ -7,15 +7,14 @@ menuconfig ISDN
         depends on NET
         depends on !S390
         ---help---
-          ISDN ("Integrated Services Digital Networks", called RNIS in France)
-          is a special type of fully digital telephone service; it's mostly
-          used to connect to your Internet service provider (with SLIP or
-          PPP).  The main advantage is that the speed is higher than ordinary
-          modem/telephone connections, and that you can have voice
-          conversations while downloading stuff.  It only works if your
-          computer is equipped with an ISDN card and both you and your service
-          provider purchased an ISDN line from the phone company.  For
-          details, read <http://www.alumni.caltech.edu/~dank/isdn/> on the WWW.
+          ISDN ("Integrated Services Digital Network", called RNIS in France)
+          is a fully digital telephone service that can be used for voice and
+          data connections.  If your computer is equipped with an ISDN
+          adapter you can use it to connect to your Internet service provider
+          (with SLIP or PPP) faster than via a conventional telephone modem
+          (though still much slower than with DSL) or to make and accept
+          voice calls (eg. turning your PC into a software answering machine
+          or PABX).
 
           Select this option if you want your kernel to support ISDN.
 
@@ -39,17 +38,22 @@ menuconfig ISDN_I4L
           It is still available, though, for use with adapters that are not
           supported by the new CAPI subsystem yet.
 
-source "drivers/isdn/mISDN/Kconfig"
-
 source "drivers/isdn/i4l/Kconfig"
 
 menuconfig ISDN_CAPI
         tristate "CAPI 2.0 subsystem"
         help
-          This provides the CAPI (Common ISDN Application Programming
-          Interface, a standard making it easy for programs to access ISDN
-          hardware, see <http://www.capi.org/>.  This is needed for AVM's set
-          of active ISDN controllers like B1, T1, M1.
+          This provides CAPI (the Common ISDN Application Programming
+          Interface) Version 2.0, a standard making it easy for programs to
+          access ISDN hardware in a device independent way. (For details see
+          <http://www.capi.org/>.)  CAPI supports making and accepting voice
+          and data connections, controlling call options and protocols,
+          as well as ISDN supplementary services like call forwarding or
+          three-party conferences (if supported by the specific hardware
+          driver).
+
+          Select this option and the appropriate hardware driver below if
+          you have an ISDN adapter supported by the CAPI subsystem.
 
 if ISDN_CAPI
 
@@ -61,4 +65,13 @@ endif # ISDN_CAPI
 
 source "drivers/isdn/gigaset/Kconfig"
 
+source "drivers/isdn/hysdn/Kconfig"
+
+source "drivers/isdn/mISDN/Kconfig"
+
+config ISDN_HDLC
+        tristate
+        select CRC_CCITT
+        select BITREVERSE
+
 endif # ISDN
diff --git a/drivers/isdn/capi/Kconfig b/drivers/isdn/capi/Kconfig
index b2a04755c96a..a168e8a891be 100644
--- a/drivers/isdn/capi/Kconfig
+++ b/drivers/isdn/capi/Kconfig
@@ -17,8 +17,7 @@ config CAPI_TRACE
           If unsure, say Y.
 
 config ISDN_CAPI_MIDDLEWARE
-        bool "CAPI2.0 Middleware support (EXPERIMENTAL)"
-        depends on EXPERIMENTAL
+        bool "CAPI2.0 Middleware support"
         help
           This option will enhance the capabilities of the /dev/capi20
           interface.  It will provide a means of moving a data connection,
@@ -35,18 +34,19 @@ config ISDN_CAPI_CAPI20
           Y/M here.
 
 config ISDN_CAPI_CAPIFS_BOOL
-        bool "CAPI2.0 filesystem support"
+        bool "CAPI2.0 filesystem support (DEPRECATED)"
         depends on ISDN_CAPI_MIDDLEWARE && ISDN_CAPI_CAPI20
+        help
+          This option provides a special file system, similar to /dev/pts with
+          device nodes for the special ttys established by using the
+          middleware extension above.
+          You no longer need this, udev fully replaces it. This feature is
+          scheduled for removal.
 
 config ISDN_CAPI_CAPIFS
         tristate
         depends on ISDN_CAPI_CAPIFS_BOOL
         default ISDN_CAPI_CAPI20
-        help
-          This option provides a special file system, similar to /dev/pts with
-          device nodes for the special ttys established by using the
-          middleware extension above. If you want to use pppd with
-          pppdcapiplugin to dial up to your ISP, say Y here.
 
 config ISDN_CAPI_CAPIDRV
         tristate "CAPI2.0 capidrv interface support"
diff --git a/drivers/isdn/capi/capi.c b/drivers/isdn/capi/capi.c
index 65bf91e16a42..ee5837522f5a 100644
--- a/drivers/isdn/capi/capi.c
+++ b/drivers/isdn/capi/capi.c
@@ -23,16 +23,13 @@
 #include <linux/smp_lock.h>
 #include <linux/timer.h>
 #include <linux/wait.h>
-#ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
 #include <linux/tty.h>
-#ifdef CONFIG_PPP
 #include <linux/netdevice.h>
 #include <linux/ppp_defs.h>
 #include <linux/if_ppp.h>
-#endif /* CONFIG_PPP */
-#endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
 #include <linux/skbuff.h>
 #include <linux/proc_fs.h>
+#include <linux/seq_file.h>
 #include <linux/poll.h>
 #include <linux/capi.h>
 #include <linux/kernelcapi.h>
@@ -41,35 +38,29 @@
 #include <linux/moduleparam.h>
 #include <linux/isdn/capiutil.h>
 #include <linux/isdn/capicmd.h>
-#if defined(CONFIG_ISDN_CAPI_CAPIFS) || defined(CONFIG_ISDN_CAPI_CAPIFS_MODULE)
-#include "capifs.h"
-#endif
 
-static char *revision = "$Revision: 1.1.2.7 $";
+#include "capifs.h"
 
 MODULE_DESCRIPTION("CAPI4Linux: Userspace /dev/capi20 interface");
 MODULE_AUTHOR("Carsten Paeth");
 MODULE_LICENSE("GPL");
 
-#undef _DEBUG_REFCOUNT          /* alloc/free and open/close debug */
 #undef _DEBUG_TTYFUNCS          /* call to tty_driver */
 #undef _DEBUG_DATAFLOW          /* data flow */
 
 /* -------- driver information -------------------------------------- */
 
 static struct class *capi_class;
-
 static int capi_major = 68;             /* allocated */
+
+module_param_named(major, capi_major, uint, 0);
+
 #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
-#define CAPINC_NR_PORTS 32
+#define CAPINC_NR_PORTS         32
 #define CAPINC_MAX_PORTS        256
-static int capi_ttymajor = 191;
+
 static int capi_ttyminors = CAPINC_NR_PORTS;
-#endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
 
-module_param_named(major, capi_major, uint, 0);
-#ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
-module_param_named(ttymajor, capi_ttymajor, uint, 0);
 module_param_named(ttyminors, capi_ttyminors, uint, 0);
 #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
 
@@ -83,53 +74,43 @@ module_param_named(ttyminors, capi_ttyminors, uint, 0);
 
 struct capidev;
 struct capincci;
-#ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
 struct capiminor;
 
-struct datahandle_queue {
+struct ackqueue_entry {
         struct list_head        list;
         u16                     datahandle;
 };
 
 struct capiminor {
-        struct list_head list;
-        struct capincci  *nccip;
+        struct kref kref;
+
         unsigned int      minor;
+        struct dentry *capifs_dentry;
 
-        struct capi20_appl *ap;
-        u32              ncci;
-        u16              datahandle;
-        u16              msgid;
+        struct capi20_appl      *ap;
+        u32                     ncci;
+        atomic_t                datahandle;
+        atomic_t                msgid;
 
-        struct tty_struct *tty;
+        struct tty_port port;
         int                ttyinstop;
         int                ttyoutstop;
-        struct sk_buff    *ttyskb;
-        atomic_t           ttyopencount;
 
-        struct sk_buff_head inqueue;
-        int                 inbytes;
-        struct sk_buff_head outqueue;
-        int                 outbytes;
+        struct sk_buff_head     inqueue;
+
+        struct sk_buff_head     outqueue;
+        int                     outbytes;
+        struct sk_buff          *outskb;
+        spinlock_t              outlock;
 
         /* transmit path */
         struct list_head ackqueue;
         int nack;
         spinlock_t ackqlock;
 };
-#endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
-
-/* FIXME: The following lock is a sledgehammer-workaround to a
- * locking issue with the capiminor (and maybe other) data structure(s).
- * Access to this data is done in a racy way and crashes the machine with
- * a FritzCard DSL driver; sooner or later. This is a workaround
- * which trades scalability vs stability, so it doesn't crash the kernel anymore.
- * The correct (and scalable) fix for the issue seems to require
- * an API change to the drivers... . */
-static DEFINE_SPINLOCK(workaround_lock);
 
 struct capincci {
-        struct capincci *next;
+        struct list_head list;
         u32              ncci;
         struct capidev  *cdev;
 #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
@@ -146,28 +127,28 @@ struct capidev {
         struct sk_buff_head recvqueue;
         wait_queue_head_t recvwait;
 
-        struct capincci *nccis;
+        struct list_head nccis;
 
-        struct mutex ncci_list_mtx;
+        struct mutex lock;
 };
 
 /* -------- global variables ---------------------------------------- */
 
-static DEFINE_RWLOCK(capidev_list_lock);
+static DEFINE_MUTEX(capidev_list_lock);
 static LIST_HEAD(capidev_list);
 
 #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
-static DEFINE_RWLOCK(capiminor_list_lock);
-static LIST_HEAD(capiminor_list);
-#endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
 
-#ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
+static DEFINE_SPINLOCK(capiminors_lock);
+static struct capiminor **capiminors;
+
+static struct tty_driver *capinc_tty_driver;
+
 /* -------- datahandles --------------------------------------------- */
 
-static int capincci_add_ack(struct capiminor *mp, u16 datahandle)
+static int capiminor_add_ack(struct capiminor *mp, u16 datahandle)
 {
-        struct datahandle_queue *n;
-        unsigned long flags;
+        struct ackqueue_entry *n;
 
         n = kmalloc(sizeof(*n), GFP_ATOMIC);
         if (unlikely(!n)) {
@@ -176,253 +157,246 @@ static int capincci_add_ack(struct capiminor *mp, u16 datahandle)
         }
         n->datahandle = datahandle;
         INIT_LIST_HEAD(&n->list);
-        spin_lock_irqsave(&mp->ackqlock, flags);
+        spin_lock_bh(&mp->ackqlock);
         list_add_tail(&n->list, &mp->ackqueue);
         mp->nack++;
-        spin_unlock_irqrestore(&mp->ackqlock, flags);
+        spin_unlock_bh(&mp->ackqlock);
         return 0;
 }
 
 static int capiminor_del_ack(struct capiminor *mp, u16 datahandle)
 {
-        struct datahandle_queue *p, *tmp;
-        unsigned long flags;
+        struct ackqueue_entry *p, *tmp;
 
-        spin_lock_irqsave(&mp->ackqlock, flags);
+        spin_lock_bh(&mp->ackqlock);
         list_for_each_entry_safe(p, tmp, &mp->ackqueue, list) {
                 if (p->datahandle == datahandle) {
                         list_del(&p->list);
-                        kfree(p);
                         mp->nack--;
-                        spin_unlock_irqrestore(&mp->ackqlock, flags);
+                        spin_unlock_bh(&mp->ackqlock);
+                        kfree(p);
                         return 0;
                 }
         }
-        spin_unlock_irqrestore(&mp->ackqlock, flags);
+        spin_unlock_bh(&mp->ackqlock);
         return -1;
 }
 
 static void capiminor_del_all_ack(struct capiminor *mp)
 {
-        struct datahandle_queue *p, *tmp;
-        unsigned long flags;
+        struct ackqueue_entry *p, *tmp;
 
-        spin_lock_irqsave(&mp->ackqlock, flags);
         list_for_each_entry_safe(p, tmp, &mp->ackqueue, list) {
                 list_del(&p->list);
                 kfree(p);
                 mp->nack--;
         }
-        spin_unlock_irqrestore(&mp->ackqlock, flags);
 }
 
 
 /* -------- struct capiminor ---------------------------------------- */
 
+static const struct tty_port_operations capiminor_port_ops; /* we have none */
+
 static struct capiminor *capiminor_alloc(struct capi20_appl *ap, u32 ncci)
 {
-        struct capiminor *mp, *p;
-        unsigned int minor = 0;
-        unsigned long flags;
+        struct capiminor *mp;
+        struct device *dev;
+        unsigned int minor;
 
-        mp = kzalloc(sizeof(*mp), GFP_ATOMIC);
+        mp = kzalloc(sizeof(*mp), GFP_KERNEL);
         if (!mp) {
                 printk(KERN_ERR "capi: can't alloc capiminor\n");
                 return NULL;
         }
 
+        kref_init(&mp->kref);
+
         mp->ap = ap;
         mp->ncci = ncci;
-        mp->msgid = 0;
-        atomic_set(&mp->ttyopencount,0);
         INIT_LIST_HEAD(&mp->ackqueue);
         spin_lock_init(&mp->ackqlock);
 
         skb_queue_head_init(&mp->inqueue);
         skb_queue_head_init(&mp->outqueue);
+        spin_lock_init(&mp->outlock);
 
-        /* Allocate the least unused minor number.
-         */
-        write_lock_irqsave(&capiminor_list_lock, flags);
-        if (list_empty(&capiminor_list))
-                list_add(&mp->list, &capiminor_list);
-        else {
-                list_for_each_entry(p, &capiminor_list, list) {
-                        if (p->minor > minor)
-                                break;
-                        minor++;
-                }
-                
-                if (minor < capi_ttyminors) {
-                        mp->minor = minor;
-                        list_add(&mp->list, p->list.prev);
+        tty_port_init(&mp->port);
+        mp->port.ops = &capiminor_port_ops;
+
+        /* Allocate the least unused minor number. */
+        spin_lock(&capiminors_lock);
+        for (minor = 0; minor < capi_ttyminors; minor++)
+                if (!capiminors[minor]) {
+                        capiminors[minor] = mp;
+                        break;
                 }
-        }
-                write_unlock_irqrestore(&capiminor_list_lock, flags);
+        spin_unlock(&capiminors_lock);
 
-        if (!(minor < capi_ttyminors)) {
+        if (minor == capi_ttyminors) {
                 printk(KERN_NOTICE "capi: out of minors\n");
-                        kfree(mp);
-                return NULL;
+                goto err_out1;
         }
 
+        mp->minor = minor;
+
+        dev = tty_register_device(capinc_tty_driver, minor, NULL);
+        if (IS_ERR(dev))
+                goto err_out2;
+
         return mp;
+
+err_out2:
+        spin_lock(&capiminors_lock);
+        capiminors[minor] = NULL;
+        spin_unlock(&capiminors_lock);
+
+err_out1:
+        kfree(mp);
+        return NULL;
 }
 
-static void capiminor_free(struct capiminor *mp)
+static void capiminor_destroy(struct kref *kref)
 {
-        unsigned long flags;
-
-        write_lock_irqsave(&capiminor_list_lock, flags);
-        list_del(&mp->list);
-        write_unlock_irqrestore(&capiminor_list_lock, flags);
+        struct capiminor *mp = container_of(kref, struct capiminor, kref);
 
-        kfree_skb(mp->ttyskb);
-        mp->ttyskb = NULL;
+        kfree_skb(mp->outskb);
         skb_queue_purge(&mp->inqueue);
         skb_queue_purge(&mp->outqueue);
         capiminor_del_all_ack(mp);
         kfree(mp);
 }
 
-static struct capiminor *capiminor_find(unsigned int minor)
+static struct capiminor *capiminor_get(unsigned int minor)
 {
-        struct list_head *l;
-        struct capiminor *p = NULL;
+        struct capiminor *mp;
 
-        read_lock(&capiminor_list_lock);
-        list_for_each(l, &capiminor_list) {
-                p = list_entry(l, struct capiminor, list);
-                if (p->minor == minor)
-                        break;
-        }
-        read_unlock(&capiminor_list_lock);
-        if (l == &capiminor_list)
-                return NULL;
+        spin_lock(&capiminors_lock);
+        mp = capiminors[minor];
+        if (mp)
+                kref_get(&mp->kref);
+        spin_unlock(&capiminors_lock);
 
-        return p;
+        return mp;
+}
+
+static inline void capiminor_put(struct capiminor *mp)
+{
+        kref_put(&mp->kref, capiminor_destroy);
+}
+
+static void capiminor_free(struct capiminor *mp)
+{
+        tty_unregister_device(capinc_tty_driver, mp->minor);
+
+        spin_lock(&capiminors_lock);
+        capiminors[mp->minor] = NULL;
+        spin_unlock(&capiminors_lock);
+
+        capiminor_put(mp);
 }
-#endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
 
 /* -------- struct capincci ----------------------------------------- */
 
-static struct capincci *capincci_alloc(struct capidev *cdev, u32 ncci)
+static void capincci_alloc_minor(struct capidev *cdev, struct capincci *np)
 {
-        struct capincci *np, **pp;
-#ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
-        struct capiminor *mp = NULL;
-#endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
+        struct capiminor *mp;
+        dev_t device;
 
-        np = kzalloc(sizeof(*np), GFP_ATOMIC);
-        if (!np)
-                return NULL;
-        np->ncci = ncci;
-        np->cdev = cdev;
-#ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
-        mp = NULL;
-        if (cdev->userflags & CAPIFLAG_HIGHJACKING)
-                mp = np->minorp = capiminor_alloc(&cdev->ap, ncci);
+        if (!(cdev->userflags & CAPIFLAG_HIGHJACKING))
+                return;
+
+        mp = np->minorp = capiminor_alloc(&cdev->ap, np->ncci);
         if (mp) {
-                mp->nccip = np;
-#ifdef _DEBUG_REFCOUNT
-                printk(KERN_DEBUG "set mp->nccip\n");
-#endif
-#if defined(CONFIG_ISDN_CAPI_CAPIFS) || defined(CONFIG_ISDN_CAPI_CAPIFS_MODULE)
-                capifs_new_ncci(mp->minor, MKDEV(capi_ttymajor, mp->minor));
-#endif
+                device = MKDEV(capinc_tty_driver->major, mp->minor);
+                mp->capifs_dentry = capifs_new_ncci(mp->minor, device);
         }
-#endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
-        for (pp=&cdev->nccis; *pp; pp = &(*pp)->next)
-                ;
-        *pp = np;
-        return np;
 }
 
-static void capincci_free(struct capidev *cdev, u32 ncci)
+static void capincci_free_minor(struct capincci *np)
 {
-        struct capincci *np, **pp;
-#ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
-        struct capiminor *mp;
-#endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
+        struct capiminor *mp = np->minorp;
+        struct tty_struct *tty;
 
-        pp=&cdev->nccis;
-        while (*pp) {
-                np = *pp;
-                if (ncci == 0xffffffff || np->ncci == ncci) {
-                        *pp = (*pp)->next;
-#ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
-                        if ((mp = np->minorp) != NULL) {
-#if defined(CONFIG_ISDN_CAPI_CAPIFS) || defined(CONFIG_ISDN_CAPI_CAPIFS_MODULE)
-                                capifs_free_ncci(mp->minor);
-#endif
-                                if (mp->tty) {
-                                        mp->nccip = NULL;
-#ifdef _DEBUG_REFCOUNT
-                                        printk(KERN_DEBUG "reset mp->nccip\n");
-#endif
-                                        tty_hangup(mp->tty);
-                                } else {
-                                        capiminor_free(mp);
-                                }
-                        }
-#endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
-                        kfree(np);
-                        if (*pp == NULL) return;
-                } else {
-                        pp = &(*pp)->next;
+        if (mp) {
+                capifs_free_ncci(mp->capifs_dentry);
+
+                tty = tty_port_tty_get(&mp->port);
+                if (tty) {
+                        tty_vhangup(tty);
+                        tty_kref_put(tty);
                 }
+
+                capiminor_free(mp);
         }
 }
 
-static struct capincci *capincci_find(struct capidev *cdev, u32 ncci)
+static inline unsigned int capincci_minor_opencount(struct capincci *np)
 {
-        struct capincci *p;
+        struct capiminor *mp = np->minorp;
+        unsigned int count = 0;
+        struct tty_struct *tty;
 
-        for (p=cdev->nccis; p ; p = p->next) {
-                if (p->ncci == ncci)
-                        break;
+        if (mp) {
+                tty = tty_port_tty_get(&mp->port);
+                if (tty) {
+                        count = tty->count;
+                        tty_kref_put(tty);
+                }
         }
-        return p;
+        return count;
 }
 
-/* -------- struct capidev ------------------------------------------ */
+#else /* !CONFIG_ISDN_CAPI_MIDDLEWARE */
+
+static inline void
+capincci_alloc_minor(struct capidev *cdev, struct capincci *np) { }
+static inline void capincci_free_minor(struct capincci *np) { }
 
-static struct capidev *capidev_alloc(void)
+static inline unsigned int capincci_minor_opencount(struct capincci *np)
 {
-        struct capidev *cdev;
-        unsigned long flags;
+        return 0;
+}
 
-        cdev = kzalloc(sizeof(*cdev), GFP_KERNEL);
-        if (!cdev)
+#endif /* !CONFIG_ISDN_CAPI_MIDDLEWARE */
+
+static struct capincci *capincci_alloc(struct capidev *cdev, u32 ncci)
+{
+        struct capincci *np;
+
+        np = kzalloc(sizeof(*np), GFP_KERNEL);
+        if (!np)
                 return NULL;
+        np->ncci = ncci;
+        np->cdev = cdev;
 
-        mutex_init(&cdev->ncci_list_mtx);
-        skb_queue_head_init(&cdev->recvqueue);
-        init_waitqueue_head(&cdev->recvwait);
-        write_lock_irqsave(&capidev_list_lock, flags);
-        list_add_tail(&cdev->list, &capidev_list);
-        write_unlock_irqrestore(&capidev_list_lock, flags);
-        return cdev;
+        capincci_alloc_minor(cdev, np);
+
+        list_add_tail(&np->list, &cdev->nccis);
+
+        return np;
 }
 
-static void capidev_free(struct capidev *cdev)
+static void capincci_free(struct capidev *cdev, u32 ncci)
 {
-        unsigned long flags;
+        struct capincci *np, *tmp;
 
-        if (cdev->ap.applid) {
-                capi20_release(&cdev->ap);
-                cdev->ap.applid = 0;
-        }
-        skb_queue_purge(&cdev->recvqueue);
+        list_for_each_entry_safe(np, tmp, &cdev->nccis, list)
+                if (ncci == 0xffffffff || np->ncci == ncci) {
+                        capincci_free_minor(np);
+                        list_del(&np->list);
+                        kfree(np);
+                }
+}
 
-        mutex_lock(&cdev->ncci_list_mtx);
-        capincci_free(cdev, 0xffffffff);
-        mutex_unlock(&cdev->ncci_list_mtx);
+static struct capincci *capincci_find(struct capidev *cdev, u32 ncci)
+{
+        struct capincci *np;
 
-        write_lock_irqsave(&capidev_list_lock, flags);
-        list_del(&cdev->list);
-        write_unlock_irqrestore(&capidev_list_lock, flags);
-        kfree(cdev);
+        list_for_each_entry(np, &cdev->nccis, list)
+                if (np->ncci == ncci)
+                        return np;
+        return NULL;
 }
 
 #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
@@ -432,7 +406,7 @@ static struct sk_buff *
 gen_data_b3_resp_for(struct capiminor *mp, struct sk_buff *skb)
 {
         struct sk_buff *nskb;
-        nskb = alloc_skb(CAPI_DATA_B3_RESP_LEN, GFP_ATOMIC);
+        nskb = alloc_skb(CAPI_DATA_B3_RESP_LEN, GFP_KERNEL);
         if (nskb) {
                 u16 datahandle = CAPIMSG_U16(skb->data,CAPIMSG_BASELEN+4+4+2);
                 unsigned char *s = skb_put(nskb, CAPI_DATA_B3_RESP_LEN);
@@ -440,7 +414,7 @@ gen_data_b3_resp_for(struct capiminor *mp, struct sk_buff *skb)
                 capimsg_setu16(s, 2, mp->ap->applid);
                 capimsg_setu8 (s, 4, CAPI_DATA_B3);
                 capimsg_setu8 (s, 5, CAPI_RESP);
-                capimsg_setu16(s, 6, mp->msgid++);
+                capimsg_setu16(s, 6, atomic_inc_return(&mp->msgid));
                 capimsg_setu32(s, 8, mp->ncci);
                 capimsg_setu16(s, 12, datahandle);
         }
@@ -449,122 +423,156 @@ gen_data_b3_resp_for(struct capiminor *mp, struct sk_buff *skb)
 
 static int handle_recv_skb(struct capiminor *mp, struct sk_buff *skb)
 {
+        unsigned int datalen = skb->len - CAPIMSG_LEN(skb->data);
+        struct tty_struct *tty;
         struct sk_buff *nskb;
-        int datalen;
         u16 errcode, datahandle;
         struct tty_ldisc *ld;
-        
-        datalen = skb->len - CAPIMSG_LEN(skb->data);
-        if (mp->tty == NULL)
-        {
+        int ret = -1;
+
+        tty = tty_port_tty_get(&mp->port);
+        if (!tty) {
 #ifdef _DEBUG_DATAFLOW
                 printk(KERN_DEBUG "capi: currently no receiver\n");
 #endif
                 return -1;
         }
         
-        ld = tty_ldisc_ref(mp->tty);
-        if (ld == NULL)
-                return -1;
+        ld = tty_ldisc_ref(tty);
+        if (!ld) {
+                /* fatal error, do not requeue */
+                ret = 0;
+                kfree_skb(skb);
+                goto deref_tty;
+        }
+
         if (ld->ops->receive_buf == NULL) {
 #if defined(_DEBUG_DATAFLOW) || defined(_DEBUG_TTYFUNCS)
                 printk(KERN_DEBUG "capi: ldisc has no receive_buf function\n");
 #endif
-                goto bad;
+                /* fatal error, do not requeue */
+                goto free_skb;
         }
         if (mp->ttyinstop) {
 #if defined(_DEBUG_DATAFLOW) || defined(_DEBUG_TTYFUNCS)
                 printk(KERN_DEBUG "capi: recv tty throttled\n");
 #endif
-                goto bad;
+                goto deref_ldisc;
         }
-        if (mp->tty->receive_room < datalen) {
+
+        if (tty->receive_room < datalen) {
 #if defined(_DEBUG_DATAFLOW) || defined(_DEBUG_TTYFUNCS)
                 printk(KERN_DEBUG "capi: no room in tty\n");
 #endif
-                goto bad;
+                goto deref_ldisc;
         }
-        if ((nskb = gen_data_b3_resp_for(mp, skb)) == NULL) {
+
+        nskb = gen_data_b3_resp_for(mp, skb);
+        if (!nskb) {
                 printk(KERN_ERR "capi: gen_data_b3_resp failed\n");
-                goto bad;
+                goto deref_ldisc;
         }
-        datahandle = CAPIMSG_U16(skb->data,CAPIMSG_BASELEN+4);
+
+        datahandle = CAPIMSG_U16(skb->data, CAPIMSG_BASELEN + 4);
+
         errcode = capi20_put_message(mp->ap, nskb);
-        if (errcode != CAPI_NOERROR) {
+
+        if (errcode == CAPI_NOERROR) {
+                skb_pull(skb, CAPIMSG_LEN(skb->data));
+#ifdef _DEBUG_DATAFLOW
+                printk(KERN_DEBUG "capi: DATA_B3_RESP %u len=%d => ldisc\n",
+                                        datahandle, skb->len);
+#endif
+                ld->ops->receive_buf(tty, skb->data, NULL, skb->len);
+        } else {
                 printk(KERN_ERR "capi: send DATA_B3_RESP failed=%x\n",
                                 errcode);
                 kfree_skb(nskb);
-                goto bad;
+
+                if (errcode == CAPI_SENDQUEUEFULL)
+                        goto deref_ldisc;
         }
-        (void)skb_pull(skb, CAPIMSG_LEN(skb->data));
-#ifdef _DEBUG_DATAFLOW
-        printk(KERN_DEBUG "capi: DATA_B3_RESP %u len=%d => ldisc\n",
-                                datahandle, skb->len);
-#endif
-        ld->ops->receive_buf(mp->tty, skb->data, NULL, skb->len);
+
+free_skb:
+        ret = 0;
         kfree_skb(skb);
+
+deref_ldisc:
         tty_ldisc_deref(ld);
-        return 0;
-bad:
-        tty_ldisc_deref(ld);
-        return -1;
+
+deref_tty:
+        tty_kref_put(tty);
+        return ret;
 }
 
 static void handle_minor_recv(struct capiminor *mp)
 {
         struct sk_buff *skb;
-        while ((skb = skb_dequeue(&mp->inqueue)) != NULL) {
-                unsigned int len = skb->len;
-                mp->inbytes -= len;
+
+        while ((skb = skb_dequeue(&mp->inqueue)) != NULL)
                 if (handle_recv_skb(mp, skb) < 0) {
                         skb_queue_head(&mp->inqueue, skb);
-                        mp->inbytes += len;
                         return;
                 }
-        }
 }
 
-static int handle_minor_send(struct capiminor *mp)
+static void handle_minor_send(struct capiminor *mp)
 {
+        struct tty_struct *tty;
         struct sk_buff *skb;
         u16 len;
-        int count = 0;
         u16 errcode;
         u16 datahandle;
 
-        if (mp->tty && mp->ttyoutstop) {
+        tty = tty_port_tty_get(&mp->port);
+        if (!tty)
+                return;
+
+        if (mp->ttyoutstop) {
 #if defined(_DEBUG_DATAFLOW) || defined(_DEBUG_TTYFUNCS)
                 printk(KERN_DEBUG "capi: send: tty stopped\n");
 #endif
-                return 0;
+                tty_kref_put(tty);
+                return;
         }
 
-        while ((skb = skb_dequeue(&mp->outqueue)) != NULL) {
-                datahandle = mp->datahandle;
+        while (1) {
+                spin_lock_bh(&mp->outlock);
+                skb = __skb_dequeue(&mp->outqueue);
+                if (!skb) {
+                        spin_unlock_bh(&mp->outlock);
+                        break;
+                }
                 len = (u16)skb->len;
+                mp->outbytes -= len;
+                spin_unlock_bh(&mp->outlock);
+
+                datahandle = atomic_inc_return(&mp->datahandle);
                 skb_push(skb, CAPI_DATA_B3_REQ_LEN);
                 memset(skb->data, 0, CAPI_DATA_B3_REQ_LEN);
                 capimsg_setu16(skb->data, 0, CAPI_DATA_B3_REQ_LEN);
                 capimsg_setu16(skb->data, 2, mp->ap->applid);
                 capimsg_setu8 (skb->data, 4, CAPI_DATA_B3);
                 capimsg_setu8 (skb->data, 5, CAPI_REQ);
-                capimsg_setu16(skb->data, 6, mp->msgid++);
+                capimsg_setu16(skb->data, 6, atomic_inc_return(&mp->msgid));
                 capimsg_setu32(skb->data, 8, mp->ncci); /* NCCI */
                 capimsg_setu32(skb->data, 12, (u32)(long)skb->data);/* Data32 */
                 capimsg_setu16(skb->data, 16, len);     /* Data length */
                 capimsg_setu16(skb->data, 18, datahandle);
                 capimsg_setu16(skb->data, 20, 0);       /* Flags */
 
-                if (capincci_add_ack(mp, datahandle) < 0) {
+                if (capiminor_add_ack(mp, datahandle) < 0) {
                         skb_pull(skb, CAPI_DATA_B3_REQ_LEN);
-                        skb_queue_head(&mp->outqueue, skb);
-                        return count;
+
+                        spin_lock_bh(&mp->outlock);
+                        __skb_queue_head(&mp->outqueue, skb);
+                        mp->outbytes += len;
+                        spin_unlock_bh(&mp->outlock);
+
+                        break;
                 }
                 errcode = capi20_put_message(mp->ap, skb);
                 if (errcode == CAPI_NOERROR) {
-                        mp->datahandle++;
-                        count++;
-                        mp->outbytes -= len;
 #ifdef _DEBUG_DATAFLOW
                         printk(KERN_DEBUG "capi: DATA_B3_REQ %u len=%u\n",
                                                         datahandle, len);
@@ -575,16 +583,20 @@ static int handle_minor_send(struct capiminor *mp)
 
                 if (errcode == CAPI_SENDQUEUEFULL) {
                         skb_pull(skb, CAPI_DATA_B3_REQ_LEN);
-                        skb_queue_head(&mp->outqueue, skb);
+
+                        spin_lock_bh(&mp->outlock);
+                        __skb_queue_head(&mp->outqueue, skb);
+                        mp->outbytes += len;
+                        spin_unlock_bh(&mp->outlock);
+
                         break;
                 }
 
                 /* ups, drop packet */
                 printk(KERN_ERR "capi: put_message = %x\n", errcode);
-                mp->outbytes -= len;
                 kfree_skb(skb);
         }
-        return count;
+        tty_kref_put(tty);
 }
 
 #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
@@ -594,65 +606,56 @@ static void capi_recv_message(struct capi20_appl *ap, struct sk_buff *skb)
 {
         struct capidev *cdev = ap->private;
 #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
+        struct tty_struct *tty;
         struct capiminor *mp;
         u16 datahandle;
 #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
         struct capincci *np;
-        u32 ncci;
-        unsigned long flags;
+
+        mutex_lock(&cdev->lock);
 
         if (CAPIMSG_CMD(skb->data) == CAPI_CONNECT_B3_CONF) {
                 u16 info = CAPIMSG_U16(skb->data, 12); // Info field
-                if ((info & 0xff00) == 0) {
-                        mutex_lock(&cdev->ncci_list_mtx);
+                if ((info & 0xff00) == 0)
                         capincci_alloc(cdev, CAPIMSG_NCCI(skb->data));
-                        mutex_unlock(&cdev->ncci_list_mtx);
-                }
         }
-        if (CAPIMSG_CMD(skb->data) == CAPI_CONNECT_B3_IND) {
-                mutex_lock(&cdev->ncci_list_mtx);
+        if (CAPIMSG_CMD(skb->data) == CAPI_CONNECT_B3_IND)
                 capincci_alloc(cdev, CAPIMSG_NCCI(skb->data));
-                mutex_unlock(&cdev->ncci_list_mtx);
-        }
-        spin_lock_irqsave(&workaround_lock, flags);
+
         if (CAPIMSG_COMMAND(skb->data) != CAPI_DATA_B3) {
                 skb_queue_tail(&cdev->recvqueue, skb);
                 wake_up_interruptible(&cdev->recvwait);
-                spin_unlock_irqrestore(&workaround_lock, flags);
-                return;
+                goto unlock_out;
         }
-        ncci = CAPIMSG_CONTROL(skb->data);
-        for (np = cdev->nccis; np && np->ncci != ncci; np = np->next)
-                ;
+
+        np = capincci_find(cdev, CAPIMSG_CONTROL(skb->data));
         if (!np) {
                 printk(KERN_ERR "BUG: capi_signal: ncci not found\n");
                 skb_queue_tail(&cdev->recvqueue, skb);
                 wake_up_interruptible(&cdev->recvwait);
-                spin_unlock_irqrestore(&workaround_lock, flags);
-                return;
+                goto unlock_out;
         }
+
 #ifndef CONFIG_ISDN_CAPI_MIDDLEWARE
         skb_queue_tail(&cdev->recvqueue, skb);
         wake_up_interruptible(&cdev->recvwait);
+
 #else /* CONFIG_ISDN_CAPI_MIDDLEWARE */
+
         mp = np->minorp;
         if (!mp) {
                 skb_queue_tail(&cdev->recvqueue, skb);
                 wake_up_interruptible(&cdev->recvwait);
-                spin_unlock_irqrestore(&workaround_lock, flags);
-                return;
+                goto unlock_out;
         }
-
-
         if (CAPIMSG_SUBCOMMAND(skb->data) == CAPI_IND) {
-                
                 datahandle = CAPIMSG_U16(skb->data, CAPIMSG_BASELEN+4+4+2);
 #ifdef _DEBUG_DATAFLOW
                 printk(KERN_DEBUG "capi_signal: DATA_B3_IND %u len=%d\n",
                                 datahandle, skb->len-CAPIMSG_LEN(skb->data));
 #endif
                 skb_queue_tail(&mp->inqueue, skb);
-                mp->inbytes += skb->len;
+
                 handle_minor_recv(mp);
 
         } else if (CAPIMSG_SUBCOMMAND(skb->data) == CAPI_CONF) {
@@ -664,10 +667,13 @@ static void capi_recv_message(struct capi20_appl *ap, struct sk_buff *skb)
                                 CAPIMSG_U16(skb->data, CAPIMSG_BASELEN+4+2));
 #endif
                 kfree_skb(skb);
-                (void)capiminor_del_ack(mp, datahandle);
-                if (mp->tty)
-                        tty_wakeup(mp->tty);
-                (void)handle_minor_send(mp);
+                capiminor_del_ack(mp, datahandle);
+                tty = tty_port_tty_get(&mp->port);
+                if (tty) {
+                        tty_wakeup(tty);
+                        tty_kref_put(tty);
+                }
+                handle_minor_send(mp);
 
         } else {
                 /* ups, let capi application handle it :-) */
@@ -675,7 +681,9 @@ static void capi_recv_message(struct capi20_appl *ap, struct sk_buff *skb)
                 wake_up_interruptible(&cdev->recvwait);
         }
 #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
-        spin_unlock_irqrestore(&workaround_lock, flags);
+
+unlock_out:
+        mutex_unlock(&cdev->lock);
 }
 
 /* -------- file_operations for capidev ----------------------------- */
@@ -686,24 +694,19 @@ capi_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
         struct capidev *cdev = (struct capidev *)file->private_data;
         struct sk_buff *skb;
         size_t copied;
+        int err;
 
         if (!cdev->ap.applid)
                 return -ENODEV;
 
-        if ((skb = skb_dequeue(&cdev->recvqueue)) == NULL) {
-
+        skb = skb_dequeue(&cdev->recvqueue);
+        if (!skb) {
                 if (file->f_flags & O_NONBLOCK)
                         return -EAGAIN;
-
-                for (;;) {
-                        interruptible_sleep_on(&cdev->recvwait);
-                        if ((skb = skb_dequeue(&cdev->recvqueue)) != NULL)
-                                break;
-                        if (signal_pending(current))
-                                break;
-                }
-                if (skb == NULL)
-                        return -ERESTARTNOHAND;
+                err = wait_event_interruptible(cdev->recvwait,
+                                (skb = skb_dequeue(&cdev->recvqueue)));
+                if (err)
+                        return err;
         }
         if (skb->len > count) {
                 skb_queue_head(&cdev->recvqueue, skb);
@@ -753,9 +756,9 @@ capi_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos
         CAPIMSG_SETAPPID(skb->data, cdev->ap.applid);
 
         if (CAPIMSG_CMD(skb->data) == CAPI_DISCONNECT_B3_RESP) {
-                mutex_lock(&cdev->ncci_list_mtx);
+                mutex_lock(&cdev->lock);
                 capincci_free(cdev, CAPIMSG_NCCI(skb->data));
-                mutex_unlock(&cdev->ncci_list_mtx);
+                mutex_unlock(&cdev->lock);
         }
 
         cdev->errcode = capi20_put_message(&cdev->ap, skb);
@@ -788,30 +791,35 @@ capi_ioctl(struct inode *inode, struct file *file,
            unsigned int cmd, unsigned long arg)
 {
         struct capidev *cdev = file->private_data;
-        struct capi20_appl *ap = &cdev->ap;
         capi_ioctl_struct data;
         int retval = -EINVAL;
         void __user *argp = (void __user *)arg;
 
         switch (cmd) {
         case CAPI_REGISTER:
-                {
-                        if (ap->applid)
-                                return -EEXIST;
+                mutex_lock(&cdev->lock);
 
-                        if (copy_from_user(&cdev->ap.rparam, argp,
-                                           sizeof(struct capi_register_params)))
-                                return -EFAULT;
-                        
-                        cdev->ap.private = cdev;
-                        cdev->ap.recv_message = capi_recv_message;
-                        cdev->errcode = capi20_register(ap);
-                        if (cdev->errcode) {
-                                ap->applid = 0;
-                                return -EIO;
-                        }
+                if (cdev->ap.applid) {
+                        retval = -EEXIST;
+                        goto register_out;
+                }
+                if (copy_from_user(&cdev->ap.rparam, argp,
+                                   sizeof(struct capi_register_params))) {
+                        retval = -EFAULT;
+                        goto register_out;
+                }
+                cdev->ap.private = cdev;
+                cdev->ap.recv_message = capi_recv_message;
+                cdev->errcode = capi20_register(&cdev->ap);
+                retval = (int)cdev->ap.applid;
+                if (cdev->errcode) {
+                        cdev->ap.applid = 0;
+                        retval = -EIO;
                 }
-                return (int)ap->applid;
+
+register_out:
+                mutex_unlock(&cdev->lock);
+                return retval;
 
         case CAPI_GET_VERSION:
                 {
@@ -910,101 +918,104 @@ capi_ioctl(struct inode *inode, struct file *file,
                 return 0;
 
         case CAPI_SET_FLAGS:
-        case CAPI_CLR_FLAGS:
-                {
-                        unsigned userflags;
-                        if (copy_from_user(&userflags, argp,
-                                           sizeof(userflags)))
-                                return -EFAULT;
-                        if (cmd == CAPI_SET_FLAGS)
-                                cdev->userflags |= userflags;
-                        else
-                                cdev->userflags &= ~userflags;
-                }
-                return 0;
+        case CAPI_CLR_FLAGS: {
+                unsigned userflags;
+
+                if (copy_from_user(&userflags, argp, sizeof(userflags)))
+                        return -EFAULT;
 
+                mutex_lock(&cdev->lock);
+                if (cmd == CAPI_SET_FLAGS)
+                        cdev->userflags |= userflags;
+                else
+                        cdev->userflags &= ~userflags;
+                mutex_unlock(&cdev->lock);
+                return 0;
+        }
         case CAPI_GET_FLAGS:
                 if (copy_to_user(argp, &cdev->userflags,
                                  sizeof(cdev->userflags)))
                         return -EFAULT;
                 return 0;
 
-        case CAPI_NCCI_OPENCOUNT:
-                {
-                        struct capincci *nccip;
-#ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
-                        struct capiminor *mp;
-#endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
-                        unsigned ncci;
-                        int count = 0;
-                        if (copy_from_user(&ncci, argp, sizeof(ncci)))
-                                return -EFAULT;
+        case CAPI_NCCI_OPENCOUNT: {
+                struct capincci *nccip;
+                unsigned ncci;
+                int count = 0;
 
-                        mutex_lock(&cdev->ncci_list_mtx);
-                        if ((nccip = capincci_find(cdev, (u32) ncci)) == NULL) {
-                                mutex_unlock(&cdev->ncci_list_mtx);
-                                return 0;
-                        }
-#ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
-                        if ((mp = nccip->minorp) != NULL) {
-                                count += atomic_read(&mp->ttyopencount);
-                        }
-#endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
-                        mutex_unlock(&cdev->ncci_list_mtx);
-                        return count;
-                }
-                return 0;
+                if (copy_from_user(&ncci, argp, sizeof(ncci)))
+                        return -EFAULT;
+
+                mutex_lock(&cdev->lock);
+                nccip = capincci_find(cdev, (u32)ncci);
+                if (nccip)
+                        count = capincci_minor_opencount(nccip);
+                mutex_unlock(&cdev->lock);
+                return count;
+        }
 
 #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
-        case CAPI_NCCI_GETUNIT:
-                {
-                        struct capincci *nccip;
-                        struct capiminor *mp;
-                        unsigned ncci;
-                        int unit = 0;
-                        if (copy_from_user(&ncci, argp,
-                                           sizeof(ncci)))
-                                return -EFAULT;
-                        mutex_lock(&cdev->ncci_list_mtx);
-                        nccip = capincci_find(cdev, (u32) ncci);
-                        if (!nccip || (mp = nccip->minorp) == NULL) {
-                                mutex_unlock(&cdev->ncci_list_mtx);
-                                return -ESRCH;
-                        }
-                        unit = mp->minor;
-                        mutex_unlock(&cdev->ncci_list_mtx);
-                        return unit;
+        case CAPI_NCCI_GETUNIT: {
+                struct capincci *nccip;
+                struct capiminor *mp;
+                unsigned ncci;
+                int unit = -ESRCH;
+
+                if (copy_from_user(&ncci, argp, sizeof(ncci)))
+                        return -EFAULT;
+
+                mutex_lock(&cdev->lock);
+                nccip = capincci_find(cdev, (u32)ncci);
+                if (nccip) {
+                        mp = nccip->minorp;
+                        if (mp)
+                                unit = mp->minor;
                 }
-                return 0;
+                mutex_unlock(&cdev->lock);
+                return unit;
+        }
 #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
+
+        default:
+                return -EINVAL;
         }
-        return -EINVAL;
 }
 
-static int
-capi_open(struct inode *inode, struct file *file)
+static int capi_open(struct inode *inode, struct file *file)
 {
-        int ret;
-        
-        lock_kernel();
-        if (file->private_data)
-                ret = -EEXIST;
-        else if ((file->private_data = capidev_alloc()) == NULL)
-                ret = -ENOMEM;
-        else
-                ret = nonseekable_open(inode, file);
-        unlock_kernel();
-        return ret;
+        struct capidev *cdev;
+
+        cdev = kzalloc(sizeof(*cdev), GFP_KERNEL);
+        if (!cdev)
+                return -ENOMEM;
+
+        mutex_init(&cdev->lock);
+        skb_queue_head_init(&cdev->recvqueue);
+        init_waitqueue_head(&cdev->recvwait);
+        INIT_LIST_HEAD(&cdev->nccis);
+        file->private_data = cdev;
+
+        mutex_lock(&capidev_list_lock);
+        list_add_tail(&cdev->list, &capidev_list);
+        mutex_unlock(&capidev_list_lock);
+
+        return nonseekable_open(inode, file);
 }
 
-static int
-capi_release(struct inode *inode, struct file *file)
+static int capi_release(struct inode *inode, struct file *file)
 {
-        struct capidev *cdev = (struct capidev *)file->private_data;
+        struct capidev *cdev = file->private_data;
 
-        capidev_free(cdev);
-        file->private_data = NULL;
-        
+        mutex_lock(&capidev_list_lock);
+        list_del(&cdev->list);
+        mutex_unlock(&capidev_list_lock);
+
+        if (cdev->ap.applid)
+                capi20_release(&cdev->ap);
+        skb_queue_purge(&cdev->recvqueue);
+        capincci_free(cdev, 0xffffffff);
+
+        kfree(cdev);
         return 0;
 }
 
@@ -1023,182 +1034,159 @@ static const struct file_operations capi_fops =
 #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
 /* -------- tty_operations for capincci ----------------------------- */
 
-static int capinc_tty_open(struct tty_struct * tty, struct file * file)
+static int
+capinc_tty_install(struct tty_driver *driver, struct tty_struct *tty)
 {
-        struct capiminor *mp;
-        unsigned long flags;
+        int idx = tty->index;
+        struct capiminor *mp = capiminor_get(idx);
+        int ret = tty_init_termios(tty);
+
+        if (ret == 0) {
+                tty_driver_kref_get(driver);
+                tty->count++;
+                tty->driver_data = mp;
+                driver->ttys[idx] = tty;
+        } else
+                capiminor_put(mp);
+        return ret;
+}
 
-        if ((mp = capiminor_find(iminor(file->f_path.dentry->d_inode))) == NULL)
-                return -ENXIO;
-        if (mp->nccip == NULL)
-                return -ENXIO;
+static void capinc_tty_cleanup(struct tty_struct *tty)
+{
+        struct capiminor *mp = tty->driver_data;
+        tty->driver_data = NULL;
+        capiminor_put(mp);
+}
 
-        tty->driver_data = (void *)mp;
+static int capinc_tty_open(struct tty_struct *tty, struct file *filp)
+{
+        struct capiminor *mp = tty->driver_data;
+        int err;
+
+        err = tty_port_open(&mp->port, tty, filp);
+        if (err)
+                return err;
 
-        spin_lock_irqsave(&workaround_lock, flags);
-        if (atomic_read(&mp->ttyopencount) == 0)
-                mp->tty = tty;
-        atomic_inc(&mp->ttyopencount);
-#ifdef _DEBUG_REFCOUNT
-        printk(KERN_DEBUG "capinc_tty_open ocount=%d\n", atomic_read(&mp->ttyopencount));
-#endif
         handle_minor_recv(mp);
-        spin_unlock_irqrestore(&workaround_lock, flags);
         return 0;
 }
 
-static void capinc_tty_close(struct tty_struct * tty, struct file * file)
+static void capinc_tty_close(struct tty_struct *tty, struct file *filp)
 {
-        struct capiminor *mp;
-
-        mp = (struct capiminor *)tty->driver_data;
-        if (mp) {
-                if (atomic_dec_and_test(&mp->ttyopencount)) {
-#ifdef _DEBUG_REFCOUNT
-                        printk(KERN_DEBUG "capinc_tty_close lastclose\n");
-#endif
-                        tty->driver_data = NULL;
-                        mp->tty = NULL;
-                }
-#ifdef _DEBUG_REFCOUNT
-                printk(KERN_DEBUG "capinc_tty_close ocount=%d\n", atomic_read(&mp->ttyopencount));
-#endif
-                if (mp->nccip == NULL)
-                        capiminor_free(mp);
-        }
+        struct capiminor *mp = tty->driver_data;
 
-#ifdef _DEBUG_REFCOUNT
-        printk(KERN_DEBUG "capinc_tty_close\n");
-#endif
+        tty_port_close(&mp->port, tty, filp);
 }
 
-static int capinc_tty_write(struct tty_struct * tty,
+static int capinc_tty_write(struct tty_struct *tty,
                             const unsigned char *buf, int count)
 {
-        struct capiminor *mp = (struct capiminor *)tty->driver_data;
+        struct capiminor *mp = tty->driver_data;
         struct sk_buff *skb;
-        unsigned long flags;
 
 #ifdef _DEBUG_TTYFUNCS
         printk(KERN_DEBUG "capinc_tty_write(count=%d)\n", count);
 #endif
 
-        if (!mp || !mp->nccip) {
-#ifdef _DEBUG_TTYFUNCS
-                printk(KERN_DEBUG "capinc_tty_write: mp or mp->ncci NULL\n");
-#endif
-                return 0;
-        }
-
-        spin_lock_irqsave(&workaround_lock, flags);
-        skb = mp->ttyskb;
+        spin_lock_bh(&mp->outlock);
+        skb = mp->outskb;
         if (skb) {
-                mp->ttyskb = NULL;
-                skb_queue_tail(&mp->outqueue, skb);
+                mp->outskb = NULL;
+                __skb_queue_tail(&mp->outqueue, skb);
                 mp->outbytes += skb->len;
         }
 
         skb = alloc_skb(CAPI_DATA_B3_REQ_LEN+count, GFP_ATOMIC);
         if (!skb) {
                 printk(KERN_ERR "capinc_tty_write: alloc_skb failed\n");
-                spin_unlock_irqrestore(&workaround_lock, flags);
+                spin_unlock_bh(&mp->outlock);
                 return -ENOMEM;
         }
 
         skb_reserve(skb, CAPI_DATA_B3_REQ_LEN);
         memcpy(skb_put(skb, count), buf, count);
 
-        skb_queue_tail(&mp->outqueue, skb);
+        __skb_queue_tail(&mp->outqueue, skb);
         mp->outbytes += skb->len;
-        (void)handle_minor_send(mp);
-        (void)handle_minor_recv(mp);
-        spin_unlock_irqrestore(&workaround_lock, flags);
+        spin_unlock_bh(&mp->outlock);
+
+        handle_minor_send(mp);
+
         return count;
 }
 
 static int capinc_tty_put_char(struct tty_struct *tty, unsigned char ch)
 {
-        struct capiminor *mp = (struct capiminor *)tty->driver_data;
+        struct capiminor *mp = tty->driver_data;
+        bool invoke_send = false;
         struct sk_buff *skb;
-        unsigned long flags;
         int ret = 1;
 
 #ifdef _DEBUG_TTYFUNCS
         printk(KERN_DEBUG "capinc_put_char(%u)\n", ch);
 #endif
 
-        if (!mp || !mp->nccip) {
-#ifdef _DEBUG_TTYFUNCS
-                printk(KERN_DEBUG "capinc_tty_put_char: mp or mp->ncci NULL\n");
-#endif
-                return 0;
-        }
-
-        spin_lock_irqsave(&workaround_lock, flags);
-        skb = mp->ttyskb;
+        spin_lock_bh(&mp->outlock);
+        skb = mp->outskb;
         if (skb) {
                 if (skb_tailroom(skb) > 0) {
                         *(skb_put(skb, 1)) = ch;
-                        spin_unlock_irqrestore(&workaround_lock, flags);
-                        return 1;
+                        goto unlock_out;
                 }
-                mp->ttyskb = NULL;
-                skb_queue_tail(&mp->outqueue, skb);
+                mp->outskb = NULL;
+                __skb_queue_tail(&mp->outqueue, skb);
                 mp->outbytes += skb->len;
-                (void)handle_minor_send(mp);
+                invoke_send = true;
         }
+
         skb = alloc_skb(CAPI_DATA_B3_REQ_LEN+CAPI_MAX_BLKSIZE, GFP_ATOMIC);
         if (skb) {
                 skb_reserve(skb, CAPI_DATA_B3_REQ_LEN);
                 *(skb_put(skb, 1)) = ch;
-                mp->ttyskb = skb;
+                mp->outskb = skb;
         } else {
                 printk(KERN_ERR "capinc_put_char: char %u lost\n", ch);
                 ret = 0;
         }
-        spin_unlock_irqrestore(&workaround_lock, flags);
+
+unlock_out:
+        spin_unlock_bh(&mp->outlock);
+
+        if (invoke_send)
+                handle_minor_send(mp);
+
         return ret;
 }
 
 static void capinc_tty_flush_chars(struct tty_struct *tty)
 {
-        struct capiminor *mp = (struct capiminor *)tty->driver_data;
+        struct capiminor *mp = tty->driver_data;
         struct sk_buff *skb;
-        unsigned long flags;
 
 #ifdef _DEBUG_TTYFUNCS
         printk(KERN_DEBUG "capinc_tty_flush_chars\n");
 #endif
 
-        if (!mp || !mp->nccip) {
-#ifdef _DEBUG_TTYFUNCS
-                printk(KERN_DEBUG "capinc_tty_flush_chars: mp or mp->ncci NULL\n");
-#endif
-                return;
-        }
-
-        spin_lock_irqsave(&workaround_lock, flags);
-        skb = mp->ttyskb;
+        spin_lock_bh(&mp->outlock);
+        skb = mp->outskb;
         if (skb) {
-                mp->ttyskb = NULL;
-                skb_queue_tail(&mp->outqueue, skb);
+                mp->outskb = NULL;
+                __skb_queue_tail(&mp->outqueue, skb);
                 mp->outbytes += skb->len;
-                (void)handle_minor_send(mp);
-        }
-        (void)handle_minor_recv(mp);
-        spin_unlock_irqrestore(&workaround_lock, flags);
+                spin_unlock_bh(&mp->outlock);
+
+                handle_minor_send(mp);
+        } else
+                spin_unlock_bh(&mp->outlock);
+
+        handle_minor_recv(mp);
 }
 
 static int capinc_tty_write_room(struct tty_struct *tty)
 {
-        struct capiminor *mp = (struct capiminor *)tty->driver_data;
+        struct capiminor *mp = tty->driver_data;
         int room;
-        if (!mp || !mp->nccip) {
-#ifdef _DEBUG_TTYFUNCS
-                printk(KERN_DEBUG "capinc_tty_write_room: mp or mp->ncci NULL\n");
-#endif
-                return 0;
-        }
+
         room = CAPINC_MAX_SENDQUEUE-skb_queue_len(&mp->outqueue);
         room *= CAPI_MAX_BLKSIZE;
 #ifdef _DEBUG_TTYFUNCS
@@ -1209,13 +1197,8 @@ static int capinc_tty_write_room(struct tty_struct *tty)
 
 static int capinc_tty_chars_in_buffer(struct tty_struct *tty)
 {
-        struct capiminor *mp = (struct capiminor *)tty->driver_data;
-        if (!mp || !mp->nccip) {
-#ifdef _DEBUG_TTYFUNCS
-                printk(KERN_DEBUG "capinc_tty_chars_in_buffer: mp or mp->ncci NULL\n");
-#endif
-                return 0;
-        }
+        struct capiminor *mp = tty->driver_data;
+
 #ifdef _DEBUG_TTYFUNCS
         printk(KERN_DEBUG "capinc_tty_chars_in_buffer = %d nack=%d sq=%d rq=%d\n",
                         mp->outbytes, mp->nack,
@@ -1244,62 +1227,55 @@ static void capinc_tty_set_termios(struct tty_struct *tty, struct ktermios * old
 #endif
 }
 
-static void capinc_tty_throttle(struct tty_struct * tty)
+static void capinc_tty_throttle(struct tty_struct *tty)
 {
-        struct capiminor *mp = (struct capiminor *)tty->driver_data;
+        struct capiminor *mp = tty->driver_data;
 #ifdef _DEBUG_TTYFUNCS
         printk(KERN_DEBUG "capinc_tty_throttle\n");
 #endif
-        if (mp)
-                mp->ttyinstop = 1;
+        mp->ttyinstop = 1;
 }
 
-static void capinc_tty_unthrottle(struct tty_struct * tty)
+static void capinc_tty_unthrottle(struct tty_struct *tty)
 {
-        struct capiminor *mp = (struct capiminor *)tty->driver_data;
-        unsigned long flags;
+        struct capiminor *mp = tty->driver_data;
+
 #ifdef _DEBUG_TTYFUNCS
         printk(KERN_DEBUG "capinc_tty_unthrottle\n");
 #endif
-        if (mp) {
-                spin_lock_irqsave(&workaround_lock, flags);
-                mp->ttyinstop = 0;
-                handle_minor_recv(mp);
-                spin_unlock_irqrestore(&workaround_lock, flags);
-        }
+        mp->ttyinstop = 0;
+        handle_minor_recv(mp);
 }
 
 static void capinc_tty_stop(struct tty_struct *tty)
 {
-        struct capiminor *mp = (struct capiminor *)tty->driver_data;
+        struct capiminor *mp = tty->driver_data;
+
 #ifdef _DEBUG_TTYFUNCS
         printk(KERN_DEBUG "capinc_tty_stop\n");
 #endif
-        if (mp) {
-                mp->ttyoutstop = 1;
-        }
+        mp->ttyoutstop = 1;
 }
 
 static void capinc_tty_start(struct tty_struct *tty)
 {
-        struct capiminor *mp = (struct capiminor *)tty->driver_data;
-        unsigned long flags;
+        struct capiminor *mp = tty->driver_data;
+
 #ifdef _DEBUG_TTYFUNCS
         printk(KERN_DEBUG "capinc_tty_start\n");
 #endif
-        if (mp) {
-                spin_lock_irqsave(&workaround_lock, flags);
-                mp->ttyoutstop = 0;
-                (void)handle_minor_send(mp);
-                spin_unlock_irqrestore(&workaround_lock, flags);
-        }
+        mp->ttyoutstop = 0;
+        handle_minor_send(mp);
 }
 
 static void capinc_tty_hangup(struct tty_struct *tty)
 {
+        struct capiminor *mp = tty->driver_data;
+
 #ifdef _DEBUG_TTYFUNCS
         printk(KERN_DEBUG "capinc_tty_hangup\n");
 #endif
+        tty_port_hangup(&mp->port);
 }
 
 static int capinc_tty_break_ctl(struct tty_struct *tty, int state)
@@ -1331,8 +1307,6 @@ static void capinc_tty_send_xchar(struct tty_struct *tty, char ch)
 #endif
 }
 
-static struct tty_driver *capinc_tty_driver;
-
 static const struct tty_operations capinc_ops = {
         .open = capinc_tty_open,
         .close = capinc_tty_close,
@@ -1352,25 +1326,34 @@ static const struct tty_operations capinc_ops = {
         .flush_buffer = capinc_tty_flush_buffer,
         .set_ldisc = capinc_tty_set_ldisc,
         .send_xchar = capinc_tty_send_xchar,
+        .install = capinc_tty_install,
+        .cleanup = capinc_tty_cleanup,
 };
 
-static int capinc_tty_init(void)
+static int __init capinc_tty_init(void)
 {
         struct tty_driver *drv;
-        
+        int err;
+
         if (capi_ttyminors > CAPINC_MAX_PORTS)
                 capi_ttyminors = CAPINC_MAX_PORTS;
         if (capi_ttyminors <= 0)
                 capi_ttyminors = CAPINC_NR_PORTS;
 
-        drv = alloc_tty_driver(capi_ttyminors);
-        if (!drv)
+        capiminors = kzalloc(sizeof(struct capi_minor *) * capi_ttyminors,
+                             GFP_KERNEL);
+        if (!capiminors)
                 return -ENOMEM;
 
+        drv = alloc_tty_driver(capi_ttyminors);
+        if (!drv) {
+                kfree(capiminors);
+                return -ENOMEM;
+        }
         drv->owner = THIS_MODULE;
         drv->driver_name = "capi_nc";
         drv->name = "capi";
-        drv->major = capi_ttymajor;
+        drv->major = 0;
         drv->minor_start = 0;
         drv->type = TTY_DRIVER_TYPE_SERIAL;
         drv->subtype = SERIAL_TYPE_NORMAL;
@@ -1379,27 +1362,39 @@ static int capinc_tty_init(void)
         drv->init_termios.c_oflag = OPOST | ONLCR;
         drv->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
         drv->init_termios.c_lflag = 0;
-        drv->flags = TTY_DRIVER_REAL_RAW|TTY_DRIVER_RESET_TERMIOS;
+        drv->flags =
+                TTY_DRIVER_REAL_RAW | TTY_DRIVER_RESET_TERMIOS |
+                TTY_DRIVER_DYNAMIC_DEV;
         tty_set_operations(drv, &capinc_ops);
-        if (tty_register_driver(drv)) {
+
+        err = tty_register_driver(drv);
+        if (err) {
                 put_tty_driver(drv);
+                kfree(capiminors);
                 printk(KERN_ERR "Couldn't register capi_nc driver\n");
-                return -1;
+                return err;
         }
         capinc_tty_driver = drv;
         return 0;
 }
 
-static void capinc_tty_exit(void)
+static void __exit capinc_tty_exit(void)
 {
-        struct tty_driver *drv = capinc_tty_driver;
-        int retval;
-        if ((retval = tty_unregister_driver(drv)))
-                printk(KERN_ERR "capi: failed to unregister capi_nc driver (%d)\n", retval);
-        put_tty_driver(drv);
+        tty_unregister_driver(capinc_tty_driver);
+        put_tty_driver(capinc_tty_driver);
+        kfree(capiminors);
 }
 
-#endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
+#else /* !CONFIG_ISDN_CAPI_MIDDLEWARE */
+
+static inline int capinc_tty_init(void)
+{
+        return 0;
+}
+
+static inline void capinc_tty_exit(void) { }
+
+#endif /* !CONFIG_ISDN_CAPI_MIDDLEWARE */
 
 /* -------- /proc functions ----------------------------------------- */
 
@@ -1407,134 +1402,91 @@ static void capinc_tty_exit(void)
  * /proc/capi/capi20:
  *  minor applid nrecvctlpkt nrecvdatapkt nsendctlpkt nsenddatapkt
  */
-static int proc_capidev_read_proc(char *page, char **start, off_t off,
-                                       int count, int *eof, void *data)
+static int capi20_proc_show(struct seq_file *m, void *v)
 {
         struct capidev *cdev;
         struct list_head *l;
-        int len = 0;
 
-        read_lock(&capidev_list_lock);
+        mutex_lock(&capidev_list_lock);
         list_for_each(l, &capidev_list) {
                 cdev = list_entry(l, struct capidev, list);
-                len += sprintf(page+len, "0 %d %lu %lu %lu %lu\n",
+                seq_printf(m, "0 %d %lu %lu %lu %lu\n",
                         cdev->ap.applid,
                         cdev->ap.nrecvctlpkt,
                         cdev->ap.nrecvdatapkt,
                         cdev->ap.nsentctlpkt,
                         cdev->ap.nsentdatapkt);
-                if (len <= off) {
-                        off -= len;
-                        len = 0;
-                } else {
-                        if (len-off > count)
-                                goto endloop;
-                }
         }
+        mutex_unlock(&capidev_list_lock);
+        return 0;
+}
 
-endloop:
-        read_unlock(&capidev_list_lock);
-        if (len < count)
-                *eof = 1;
-        if (len > count) len = count;
-        if (len < 0) len = 0;
-        return len;
+static int capi20_proc_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, capi20_proc_show, NULL);
 }
 
+static const struct file_operations capi20_proc_fops = {
+        .owner          = THIS_MODULE,
+        .open           = capi20_proc_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
+
 /*
  * /proc/capi/capi20ncci:
  *  applid ncci
  */
-static int proc_capincci_read_proc(char *page, char **start, off_t off,
-                                       int count, int *eof, void *data)
+static int capi20ncci_proc_show(struct seq_file *m, void *v)
 {
-        struct capidev *cdev;
-        struct capincci *np;
-        struct list_head *l;
-        int len = 0;
+        struct capidev *cdev;
+        struct capincci *np;
 
-        read_lock(&capidev_list_lock);
-        list_for_each(l, &capidev_list) {
-                cdev = list_entry(l, struct capidev, list);
-                for (np=cdev->nccis; np; np = np->next) {
-                        len += sprintf(page+len, "%d 0x%x\n",
-                                       cdev->ap.applid,
-                                       np->ncci);
-                        if (len <= off) {
-                                off -= len;
-                                len = 0;
-                        } else {
-                                if (len-off > count)
-                                        goto endloop;
-                        }
-                }
+        mutex_lock(&capidev_list_lock);
+        list_for_each_entry(cdev, &capidev_list, list) {
+                mutex_lock(&cdev->lock);
+                list_for_each_entry(np, &cdev->nccis, list)
+                        seq_printf(m, "%d 0x%x\n", cdev->ap.applid, np->ncci);
+                mutex_unlock(&cdev->lock);
         }
-endloop:
-        read_unlock(&capidev_list_lock);
-        *start = page+off;
-        if (len < count)
-                *eof = 1;
-        if (len>count) len = count;
-        if (len<0) len = 0;
-        return len;
+        mutex_unlock(&capidev_list_lock);
+        return 0;
+}
+
+static int capi20ncci_proc_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, capi20ncci_proc_show, NULL);
 }
 
-static struct procfsentries {
-  char *name;
-  mode_t mode;
-  int (*read_proc)(char *page, char **start, off_t off,
-                                       int count, int *eof, void *data);
-  struct proc_dir_entry *procent;
-} procfsentries[] = {
-   /* { "capi",           S_IFDIR, 0 }, */
-   { "capi/capi20",       0      , proc_capidev_read_proc },
-   { "capi/capi20ncci",   0      , proc_capincci_read_proc },
+static const struct file_operations capi20ncci_proc_fops = {
+        .owner          = THIS_MODULE,
+        .open           = capi20ncci_proc_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
 };
 
 static void __init proc_init(void)
 {
-    int nelem = ARRAY_SIZE(procfsentries);
-    int i;
-
-    for (i=0; i < nelem; i++) {
-        struct procfsentries *p = procfsentries + i;
-        p->procent = create_proc_entry(p->name, p->mode, NULL);
-        if (p->procent) p->procent->read_proc = p->read_proc;
-    }
+        proc_create("capi/capi20", 0, NULL, &capi20_proc_fops);
+        proc_create("capi/capi20ncci", 0, NULL, &capi20ncci_proc_fops);
 }
 
 static void __exit proc_exit(void)
 {
-    int nelem = ARRAY_SIZE(procfsentries);
-    int i;
-
-    for (i=nelem-1; i >= 0; i--) {
-        struct procfsentries *p = procfsentries + i;
-        if (p->procent) {
-           remove_proc_entry(p->name, NULL);
-           p->procent = NULL;
-        }
-    }
+        remove_proc_entry("capi/capi20", NULL);
+        remove_proc_entry("capi/capi20ncci", NULL);
 }
 
 /* -------- init function and module interface ---------------------- */
 
 
-static char rev[32];
-
 static int __init capi_init(void)
 {
-        char *p;
-        char *compileinfo;
+        const char *compileinfo;
         int major_ret;
 
-        if ((p = strchr(revision, ':')) != NULL && p[1]) {
-                strlcpy(rev, p + 2, sizeof(rev));
-                if ((p = strchr(rev, '$')) != NULL && p > rev)
-                   *(p-1) = 0;
-        } else
-                strcpy(rev, "1.0");
-
         major_ret = register_chrdev(capi_major, "capi20", &capi_fops);
         if (major_ret < 0) {
                 printk(KERN_ERR "capi20: unable to get major %d\n", capi_major);
@@ -1548,28 +1500,24 @@ static int __init capi_init(void)
 
         device_create(capi_class, NULL, MKDEV(capi_major, 0), NULL, "capi");
 
-#ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
         if (capinc_tty_init() < 0) {
                 device_destroy(capi_class, MKDEV(capi_major, 0));
                 class_destroy(capi_class);
                 unregister_chrdev(capi_major, "capi20");
                 return -ENOMEM;
         }
-#endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
 
         proc_init();
 
-#ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
 #if defined(CONFIG_ISDN_CAPI_CAPIFS) || defined(CONFIG_ISDN_CAPI_CAPIFS_MODULE)
         compileinfo = " (middleware+capifs)";
-#else
+#elif defined(CONFIG_ISDN_CAPI_MIDDLEWARE)
         compileinfo = " (no capifs)";
-#endif
 #else
         compileinfo = " (no middleware)";
 #endif
-        printk(KERN_NOTICE "capi20: Rev %s: started up with major %d%s\n",
-                                rev, capi_major, compileinfo);
+        printk(KERN_NOTICE "CAPI 2.0 started up with major %d%s\n",
+               capi_major, compileinfo);
 
         return 0;
 }
@@ -1582,10 +1530,7 @@ static void __exit capi_exit(void)
         class_destroy(capi_class);
         unregister_chrdev(capi_major, "capi20");
 
-#ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
         capinc_tty_exit();
-#endif
-        printk(KERN_NOTICE "capi: Rev %s: unloaded\n", rev);
 }
 
 module_init(capi_init);
diff --git a/drivers/isdn/capi/capidrv.c b/drivers/isdn/capi/capidrv.c
index 66b7d7a86474..bf55ed5f38e3 100644
--- a/drivers/isdn/capi/capidrv.c
+++ b/drivers/isdn/capi/capidrv.c
@@ -24,6 +24,7 @@
 #include <linux/isdn.h>
 #include <linux/isdnif.h>
 #include <linux/proc_fs.h>
+#include <linux/seq_file.h>
 #include <linux/capi.h>
 #include <linux/kernelcapi.h>
 #include <linux/ctype.h>
@@ -34,7 +35,6 @@
 #include <linux/isdn/capicmd.h>
 #include "capidrv.h"
 
-static char *revision = "$Revision: 1.1.2.2 $";
 static int debugmode = 0;
 
 MODULE_DESCRIPTION("CAPI4Linux: Interface to ISDN4Linux");
@@ -2210,96 +2210,73 @@ static int capidrv_delcontr(u16 contr)
 }
 
 
-static void lower_callback(unsigned int cmd, u32 contr, void *data)
+static int
+lower_callback(struct notifier_block *nb, unsigned long val, void *v)
 {
+        capi_profile profile;
+        u32 contr = (long)v;
 
-        switch (cmd) {
-        case KCI_CONTRUP:
+        switch (val) {
+        case CAPICTR_UP:
                 printk(KERN_INFO "capidrv: controller %hu up\n", contr);
-                (void) capidrv_addcontr(contr, (capi_profile *) data);
+                if (capi20_get_profile(contr, &profile) == CAPI_NOERROR)
+                        (void) capidrv_addcontr(contr, &profile);
                 break;
-        case KCI_CONTRDOWN:
+        case CAPICTR_DOWN:
                 printk(KERN_INFO "capidrv: controller %hu down\n", contr);
                 (void) capidrv_delcontr(contr);
                 break;
         }
+        return NOTIFY_OK;
 }
 
 /*
  * /proc/capi/capidrv:
  * nrecvctlpkt nrecvdatapkt nsendctlpkt nsenddatapkt
  */
-static int proc_capidrv_read_proc(char *page, char **start, off_t off,
-                                       int count, int *eof, void *data)
+static int capidrv_proc_show(struct seq_file *m, void *v)
 {
-        int len = 0;
-
-        len += sprintf(page+len, "%lu %lu %lu %lu\n",
+        seq_printf(m, "%lu %lu %lu %lu\n",
                         global.ap.nrecvctlpkt,
                         global.ap.nrecvdatapkt,
                         global.ap.nsentctlpkt,
                         global.ap.nsentdatapkt);
-        if (off+count >= len)
-           *eof = 1;
-        if (len < off)
-           return 0;
-        *start = page + off;
-        return ((count < len-off) ? count : len-off);
+        return 0;
 }
 
-static struct procfsentries {
-  char *name;
-  mode_t mode;
-  int (*read_proc)(char *page, char **start, off_t off,
-                                       int count, int *eof, void *data);
-  struct proc_dir_entry *procent;
-} procfsentries[] = {
-   /* { "capi",           S_IFDIR, 0 }, */
-   { "capi/capidrv",      0      , proc_capidrv_read_proc },
+static int capidrv_proc_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, capidrv_proc_show, NULL);
+}
+
+static const struct file_operations capidrv_proc_fops = {
+        .owner          = THIS_MODULE,
+        .open           = capidrv_proc_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
 };
 
 static void __init proc_init(void)
 {
-    int nelem = ARRAY_SIZE(procfsentries);
-    int i;
-
-    for (i=0; i < nelem; i++) {
-        struct procfsentries *p = procfsentries + i;
-        p->procent = create_proc_entry(p->name, p->mode, NULL);
-        if (p->procent) p->procent->read_proc = p->read_proc;
-    }
+        proc_create("capi/capidrv", 0, NULL, &capidrv_proc_fops);
 }
 
 static void __exit proc_exit(void)
 {
-    int nelem = ARRAY_SIZE(procfsentries);
-    int i;
-
-    for (i=nelem-1; i >= 0; i--) {
-        struct procfsentries *p = procfsentries + i;
-        if (p->procent) {
-           remove_proc_entry(p->name, NULL);
-           p->procent = NULL;
-        }
-    }
+        remove_proc_entry("capi/capidrv", NULL);
 }
 
+static struct notifier_block capictr_nb = {
+        .notifier_call = lower_callback,
+};
+
 static int __init capidrv_init(void)
 {
         capi_profile profile;
-        char rev[32];
-        char *p;
         u32 ncontr, contr;
         u16 errcode;
 
-        if ((p = strchr(revision, ':')) != NULL && p[1]) {
-                strncpy(rev, p + 2, sizeof(rev));
-                rev[sizeof(rev)-1] = 0;
-                if ((p = strchr(rev, '$')) != NULL && p > rev)
-                   *(p-1) = 0;
-        } else
-                strcpy(rev, "1.0");
-
         global.ap.rparam.level3cnt = -2;  /* number of bchannels twice */
         global.ap.rparam.datablkcnt = 16;
         global.ap.rparam.datablklen = 2048;
@@ -2310,7 +2287,7 @@ static int __init capidrv_init(void)
                 return -EIO;
         }
 
-        capi20_set_callback(&global.ap, lower_callback);
+        register_capictr_notifier(&capictr_nb);
 
         errcode = capi20_get_profile(0, &profile);
         if (errcode != CAPI_NOERROR) {
@@ -2327,29 +2304,15 @@ static int __init capidrv_init(void)
         }
         proc_init();
 
-        printk(KERN_NOTICE "capidrv: Rev %s: loaded\n", rev);
         return 0;
 }
 
 static void __exit capidrv_exit(void)
 {
-        char rev[32];
-        char *p;
-
-        if ((p = strchr(revision, ':')) != NULL) {
-                strncpy(rev, p + 1, sizeof(rev));
-                rev[sizeof(rev)-1] = 0;
-                if ((p = strchr(rev, '$')) != NULL)
-                        *p = 0;
-        } else {
-                strcpy(rev, " ??? ");
-        }
-
+        unregister_capictr_notifier(&capictr_nb);
         capi20_release(&global.ap);
 
         proc_exit();
-
-        printk(KERN_NOTICE "capidrv: Rev%s: unloaded\n", rev);
 }
 
 module_init(capidrv_init);
diff --git a/drivers/isdn/capi/capifs.c b/drivers/isdn/capi/capifs.c
index 9f8f67b6c07f..8596bd1a4d26 100644
--- a/drivers/isdn/capi/capifs.c
+++ b/drivers/isdn/capi/capifs.c
@@ -25,14 +25,10 @@ MODULE_LICENSE("GPL");
 
 /* ------------------------------------------------------------------ */
 
-static char *revision = "$Revision: 1.1.2.3 $";
-
-/* ------------------------------------------------------------------ */
-
 #define CAPIFS_SUPER_MAGIC (('C'<<8)|'N')
 
 static struct vfsmount *capifs_mnt;
-static struct dentry *capifs_root;
+static int capifs_mnt_count;
 
 static struct {
         int setuid;
@@ -118,7 +114,7 @@ capifs_fill_super(struct super_block *s, void *data, int silent)
         inode->i_fop = &simple_dir_operations;
         inode->i_nlink = 2;
 
-        capifs_root = s->s_root = d_alloc_root(inode);
+        s->s_root = d_alloc_root(inode);
         if (s->s_root)
                 return 0;
         
@@ -141,82 +137,98 @@ static struct file_system_type capifs_fs_type = {
         .kill_sb        = kill_anon_super,
 };
 
-static struct dentry *get_node(int num)
+static struct dentry *new_ncci(unsigned int number, dev_t device)
 {
-        char s[10];
-        struct dentry *root = capifs_root;
+        struct super_block *s = capifs_mnt->mnt_sb;
+        struct dentry *root = s->s_root;
+        struct dentry *dentry;
+        struct inode *inode;
+        char name[10];
+        int namelen;
+
         mutex_lock(&root->d_inode->i_mutex);
-        return lookup_one_len(s, root, sprintf(s, "%d", num));
-}
 
-void capifs_new_ncci(unsigned int number, dev_t device)
-{
-        struct dentry *dentry;
-        struct inode *inode = new_inode(capifs_mnt->mnt_sb);
-        if (!inode)
-                return;
-        inode->i_ino = number+2;
+        namelen = sprintf(name, "%d", number);
+        dentry = lookup_one_len(name, root, namelen);
+        if (IS_ERR(dentry)) {
+                dentry = NULL;
+                goto unlock_out;
+        }
 
-        dentry = get_node(number);
+        if (dentry->d_inode) {
+                dput(dentry);
+                dentry = NULL;
+                goto unlock_out;
+        }
+
+        inode = new_inode(s);
+        if (!inode) {
+                dput(dentry);
+                dentry = NULL;
+                goto unlock_out;
+        }
 
         /* config contents is protected by root's i_mutex */
         inode->i_uid = config.setuid ? config.uid : current_fsuid();
         inode->i_gid = config.setgid ? config.gid : current_fsgid();
         inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
+        inode->i_ino = number + 2;
         init_special_inode(inode, S_IFCHR|config.mode, device);
-        //inode->i_op = &capifs_file_inode_operations;
 
-        if (!IS_ERR(dentry) && !dentry->d_inode)
-                d_instantiate(dentry, inode);
-        mutex_unlock(&capifs_root->d_inode->i_mutex);
+        d_instantiate(dentry, inode);
+        dget(dentry);
+
+unlock_out:
+        mutex_unlock(&root->d_inode->i_mutex);
+
+        return dentry;
 }
 
-void capifs_free_ncci(unsigned int number)
+struct dentry *capifs_new_ncci(unsigned int number, dev_t device)
 {
-        struct dentry *dentry = get_node(number);
-
-        if (!IS_ERR(dentry)) {
-                struct inode *inode = dentry->d_inode;
-                if (inode) {
-                        inode->i_nlink--;
-                        d_delete(dentry);
-                        dput(dentry);
-                }
+        struct dentry *dentry;
+
+        if (simple_pin_fs(&capifs_fs_type, &capifs_mnt, &capifs_mnt_count) < 0)
+                return NULL;
+
+        dentry = new_ncci(number, device);
+        if (!dentry)
+                simple_release_fs(&capifs_mnt, &capifs_mnt_count);
+
+        return dentry;
+}
+
+void capifs_free_ncci(struct dentry *dentry)
+{
+        struct dentry *root = capifs_mnt->mnt_sb->s_root;
+        struct inode *inode;
+
+        if (!dentry)
+                return;
+
+        mutex_lock(&root->d_inode->i_mutex);
+
+        inode = dentry->d_inode;
+        if (inode) {
+                drop_nlink(inode);
+                d_delete(dentry);
                 dput(dentry);
         }
-        mutex_unlock(&capifs_root->d_inode->i_mutex);
+        dput(dentry);
+
+        mutex_unlock(&root->d_inode->i_mutex);
+
+        simple_release_fs(&capifs_mnt, &capifs_mnt_count);
 }
 
 static int __init capifs_init(void)
 {
-        char rev[32];
-        char *p;
-        int err;
-
-        if ((p = strchr(revision, ':')) != NULL && p[1]) {
-                strlcpy(rev, p + 2, sizeof(rev));
-                if ((p = strchr(rev, '$')) != NULL && p > rev)
-                   *(p-1) = 0;
-        } else
-                strcpy(rev, "1.0");
-
-        err = register_filesystem(&capifs_fs_type);
-        if (!err) {
-                capifs_mnt = kern_mount(&capifs_fs_type);
-                if (IS_ERR(capifs_mnt)) {
-                        err = PTR_ERR(capifs_mnt);
-                        unregister_filesystem(&capifs_fs_type);
-                }
-        }
-        if (!err)
-                printk(KERN_NOTICE "capifs: Rev %s\n", rev);
-        return err;
+        return register_filesystem(&capifs_fs_type);
 }
 
 static void __exit capifs_exit(void)
 {
         unregister_filesystem(&capifs_fs_type);
-        mntput(capifs_mnt);
 }
 
 EXPORT_SYMBOL(capifs_new_ncci);
diff --git a/drivers/isdn/capi/capifs.h b/drivers/isdn/capi/capifs.h
index d0bd4c3c430a..e193d1189531 100644
--- a/drivers/isdn/capi/capifs.h
+++ b/drivers/isdn/capi/capifs.h
@@ -7,5 +7,22 @@
  *
  */
 
-void capifs_new_ncci(unsigned int num, dev_t device);
-void capifs_free_ncci(unsigned int num);
+#include <linux/dcache.h>
+
+#if defined(CONFIG_ISDN_CAPI_CAPIFS) || defined(CONFIG_ISDN_CAPI_CAPIFS_MODULE)
+
+struct dentry *capifs_new_ncci(unsigned int num, dev_t device);
+void capifs_free_ncci(struct dentry *dentry);
+
+#else
+
+static inline struct dentry *capifs_new_ncci(unsigned int num, dev_t device)
+{
+        return NULL;
+}
+
+static inline void capifs_free_ncci(struct dentry *dentry)
+{
+}
+
+#endif
diff --git a/drivers/isdn/capi/kcapi.c b/drivers/isdn/capi/kcapi.c
index dc506ab99cac..ce9b05b9e93a 100644
--- a/drivers/isdn/capi/kcapi.c
+++ b/drivers/isdn/capi/kcapi.c
@@ -34,10 +34,7 @@
 #include <linux/b1lli.h>
 #endif
 #include <linux/mutex.h>
-
-static char *revision = "$Revision: 1.1.2.8 $";
-
-/* ------------------------------------------------------------- */
+#include <linux/rcupdate.h>
 
 static int showcapimsgs = 0;
 
@@ -48,12 +45,10 @@ module_param(showcapimsgs, uint, 0);
 
 /* ------------------------------------------------------------- */
 
-struct capi_notifier {
+struct capictr_event {
         struct work_struct work;
-        unsigned int cmd;
+        unsigned int type;
         u32 controller;
-        u16 applid;
-        u32 ncci;
 };
 
 /* ------------------------------------------------------------- */
@@ -65,30 +60,31 @@ static char capi_manufakturer[64] = "AVM Berlin";
 #define NCCI2CTRL(ncci)    (((ncci) >> 24) & 0x7f)
 
 LIST_HEAD(capi_drivers);
-DEFINE_RWLOCK(capi_drivers_list_lock);
+DEFINE_MUTEX(capi_drivers_lock);
 
-static DEFINE_RWLOCK(application_lock);
-static DEFINE_MUTEX(controller_mutex);
+struct capi_ctr *capi_controller[CAPI_MAXCONTR];
+DEFINE_MUTEX(capi_controller_lock);
 
 struct capi20_appl *capi_applications[CAPI_MAXAPPL];
-struct capi_ctr *capi_cards[CAPI_MAXCONTR];
 
-static int ncards;
+static int ncontrollers;
+
+static BLOCKING_NOTIFIER_HEAD(ctr_notifier_list);
 
 /* -------- controller ref counting -------------------------------------- */
 
 static inline struct capi_ctr *
-capi_ctr_get(struct capi_ctr *card)
+capi_ctr_get(struct capi_ctr *ctr)
 {
-        if (!try_module_get(card->owner))
+        if (!try_module_get(ctr->owner))
                 return NULL;
-        return card;
+        return ctr;
 }
 
 static inline void
-capi_ctr_put(struct capi_ctr *card)
+capi_ctr_put(struct capi_ctr *ctr)
 {
-        module_put(card->owner);
+        module_put(ctr->owner);
 }
 
 /* ------------------------------------------------------------- */
@@ -98,7 +94,7 @@ static inline struct capi_ctr *get_capi_ctr_by_nr(u16 contr)
         if (contr - 1 >= CAPI_MAXCONTR)
                 return NULL;
 
-        return capi_cards[contr - 1];
+        return capi_controller[contr - 1];
 }
 
 static inline struct capi20_appl *get_capi_appl_by_nr(u16 applid)
@@ -106,7 +102,7 @@ static inline struct capi20_appl *get_capi_appl_by_nr(u16 applid)
         if (applid - 1 >= CAPI_MAXAPPL)
                 return NULL;
 
-        return capi_applications[applid - 1];
+        return rcu_dereference(capi_applications[applid - 1]);
 }
 
 /* -------- util functions ------------------------------------ */
@@ -148,106 +144,159 @@ static inline int capi_subcmd_valid(u8 subcmd)
 
 /* ------------------------------------------------------------ */
 
-static void register_appl(struct capi_ctr *card, u16 applid, capi_register_params *rparam)
+static void
+register_appl(struct capi_ctr *ctr, u16 applid, capi_register_params *rparam)
 {
-        card = capi_ctr_get(card);
+        ctr = capi_ctr_get(ctr);
 
-        if (card)
-                card->register_appl(card, applid, rparam);
+        if (ctr)
+                ctr->register_appl(ctr, applid, rparam);
         else
-                printk(KERN_WARNING "%s: cannot get card resources\n", __func__);
+                printk(KERN_WARNING "%s: cannot get controller resources\n",
+                       __func__);
 }
 
 
-static void release_appl(struct capi_ctr *card, u16 applid)
+static void release_appl(struct capi_ctr *ctr, u16 applid)
 {
         DBG("applid %#x", applid);
         
-        card->release_appl(card, applid);
-        capi_ctr_put(card);
+        ctr->release_appl(ctr, applid);
+        capi_ctr_put(ctr);
 }
 
-/* -------- KCI_CONTRUP --------------------------------------- */
-
 static void notify_up(u32 contr)
 {
-        struct capi_ctr *card = get_capi_ctr_by_nr(contr);
         struct capi20_appl *ap;
+        struct capi_ctr *ctr;
         u16 applid;
 
-        if (showcapimsgs & 1) {
+        mutex_lock(&capi_controller_lock);
+
+        if (showcapimsgs & 1)
                 printk(KERN_DEBUG "kcapi: notify up contr %d\n", contr);
-        }
-        if (!card) {
+
+        ctr = get_capi_ctr_by_nr(contr);
+        if (ctr) {
+                if (ctr->state == CAPI_CTR_RUNNING)
+                        goto unlock_out;
+
+                ctr->state = CAPI_CTR_RUNNING;
+
+                for (applid = 1; applid <= CAPI_MAXAPPL; applid++) {
+                        ap = get_capi_appl_by_nr(applid);
+                        if (!ap)
+                                continue;
+                        register_appl(ctr, applid, &ap->rparam);
+                }
+
+                wake_up_interruptible_all(&ctr->state_wait_queue);
+        } else
                 printk(KERN_WARNING "%s: invalid contr %d\n", __func__, contr);
-                return;
-        }
-        for (applid = 1; applid <= CAPI_MAXAPPL; applid++) {
-                ap = get_capi_appl_by_nr(applid);
-                if (!ap || ap->release_in_progress) continue;
-                register_appl(card, applid, &ap->rparam);
-                if (ap->callback && !ap->release_in_progress)
-                        ap->callback(KCI_CONTRUP, contr, &card->profile);
-        }
-}
 
-/* -------- KCI_CONTRDOWN ------------------------------------- */
+unlock_out:
+        mutex_unlock(&capi_controller_lock);
+}
 
-static void notify_down(u32 contr)
+static void ctr_down(struct capi_ctr *ctr, int new_state)
 {
         struct capi20_appl *ap;
         u16 applid;
 
-        if (showcapimsgs & 1) {
-                printk(KERN_DEBUG "kcapi: notify down contr %d\n", contr);
-        }
+        if (ctr->state == CAPI_CTR_DETECTED || ctr->state == CAPI_CTR_DETACHED)
+                return;
+
+        ctr->state = new_state;
+
+        memset(ctr->manu, 0, sizeof(ctr->manu));
+        memset(&ctr->version, 0, sizeof(ctr->version));
+        memset(&ctr->profile, 0, sizeof(ctr->profile));
+        memset(ctr->serial, 0, sizeof(ctr->serial));
 
         for (applid = 1; applid <= CAPI_MAXAPPL; applid++) {
                 ap = get_capi_appl_by_nr(applid);
-                if (ap && ap->callback && !ap->release_in_progress)
-                        ap->callback(KCI_CONTRDOWN, contr, NULL);
+                if (ap)
+                        capi_ctr_put(ctr);
         }
+
+        wake_up_interruptible_all(&ctr->state_wait_queue);
 }
 
-static void notify_handler(struct work_struct *work)
+static void notify_down(u32 contr)
 {
-        struct capi_notifier *np =
-                container_of(work, struct capi_notifier, work);
+        struct capi_ctr *ctr;
 
-        switch (np->cmd) {
-        case KCI_CONTRUP:
-                notify_up(np->controller);
+        mutex_lock(&capi_controller_lock);
+
+        if (showcapimsgs & 1)
+                printk(KERN_DEBUG "kcapi: notify down contr %d\n", contr);
+
+        ctr = get_capi_ctr_by_nr(contr);
+        if (ctr)
+                ctr_down(ctr, CAPI_CTR_DETECTED);
+        else
+                printk(KERN_WARNING "%s: invalid contr %d\n", __func__, contr);
+
+        mutex_unlock(&capi_controller_lock);
+}
+
+static int
+notify_handler(struct notifier_block *nb, unsigned long val, void *v)
+{
+        u32 contr = (long)v;
+
+        switch (val) {
+        case CAPICTR_UP:
+                notify_up(contr);
                 break;
-        case KCI_CONTRDOWN:
-                notify_down(np->controller);
+        case CAPICTR_DOWN:
+                notify_down(contr);
                 break;
         }
+        return NOTIFY_OK;
+}
+
+static void do_notify_work(struct work_struct *work)
+{
+        struct capictr_event *event =
+                container_of(work, struct capictr_event, work);
 
-        kfree(np);
+        blocking_notifier_call_chain(&ctr_notifier_list, event->type,
+                                     (void *)(long)event->controller);
+        kfree(event);
 }
 
 /*
  * The notifier will result in adding/deleteing of devices. Devices can
  * only removed in user process, not in bh.
  */
-static int notify_push(unsigned int cmd, u32 controller, u16 applid, u32 ncci)
+static int notify_push(unsigned int event_type, u32 controller)
 {
-        struct capi_notifier *np = kmalloc(sizeof(*np), GFP_ATOMIC);
+        struct capictr_event *event = kmalloc(sizeof(*event), GFP_ATOMIC);
 
-        if (!np)
+        if (!event)
                 return -ENOMEM;
 
-        INIT_WORK(&np->work, notify_handler);
-        np->cmd = cmd;
-        np->controller = controller;
-        np->applid = applid;
-        np->ncci = ncci;
+        INIT_WORK(&event->work, do_notify_work);
+        event->type = event_type;
+        event->controller = controller;
 
-        schedule_work(&np->work);
+        schedule_work(&event->work);
         return 0;
 }
 
-        
+int register_capictr_notifier(struct notifier_block *nb)
+{
+        return blocking_notifier_chain_register(&ctr_notifier_list, nb);
+}
+EXPORT_SYMBOL_GPL(register_capictr_notifier);
+
+int unregister_capictr_notifier(struct notifier_block *nb)
+{
+        return blocking_notifier_chain_unregister(&ctr_notifier_list, nb);
+}
+EXPORT_SYMBOL_GPL(unregister_capictr_notifier);
+
 /* -------- Receiver ------------------------------------------ */
 
 static void recv_handler(struct work_struct *work)
@@ -273,68 +322,70 @@ static void recv_handler(struct work_struct *work)
 
 /**
  * capi_ctr_handle_message() - handle incoming CAPI message
- * @card:       controller descriptor structure.
+ * @ctr:        controller descriptor structure.
  * @appl:       application ID.
  * @skb:        message.
  *
  * Called by hardware driver to pass a CAPI message to the application.
  */
 
-void capi_ctr_handle_message(struct capi_ctr * card, u16 appl, struct sk_buff *skb)
+void capi_ctr_handle_message(struct capi_ctr *ctr, u16 appl,
+                             struct sk_buff *skb)
 {
         struct capi20_appl *ap;
         int showctl = 0;
         u8 cmd, subcmd;
-        unsigned long flags;
         _cdebbuf *cdb;
 
-        if (card->cardstate != CARD_RUNNING) {
+        if (ctr->state != CAPI_CTR_RUNNING) {
                 cdb = capi_message2str(skb->data);
                 if (cdb) {
                         printk(KERN_INFO "kcapi: controller [%03d] not active, got: %s",
-                                card->cnr, cdb->buf);
+                                ctr->cnr, cdb->buf);
                         cdebbuf_free(cdb);
                 } else
                         printk(KERN_INFO "kcapi: controller [%03d] not active, cannot trace\n",
-                                card->cnr);
+                                ctr->cnr);
                 goto error;
         }
 
         cmd = CAPIMSG_COMMAND(skb->data);
         subcmd = CAPIMSG_SUBCOMMAND(skb->data);
         if (cmd == CAPI_DATA_B3 && subcmd == CAPI_IND) {
-                card->nrecvdatapkt++;
-                if (card->traceflag > 2) showctl |= 2;
+                ctr->nrecvdatapkt++;
+                if (ctr->traceflag > 2)
+                        showctl |= 2;
         } else {
-                card->nrecvctlpkt++;
-                if (card->traceflag) showctl |= 2;
+                ctr->nrecvctlpkt++;
+                if (ctr->traceflag)
+                        showctl |= 2;
         }
-        showctl |= (card->traceflag & 1);
+        showctl |= (ctr->traceflag & 1);
         if (showctl & 2) {
                 if (showctl & 1) {
                         printk(KERN_DEBUG "kcapi: got [%03d] id#%d %s len=%u\n",
-                               card->cnr, CAPIMSG_APPID(skb->data),
+                               ctr->cnr, CAPIMSG_APPID(skb->data),
                                capi_cmd2str(cmd, subcmd),
                                CAPIMSG_LEN(skb->data));
                 } else {
                         cdb = capi_message2str(skb->data);
                         if (cdb) {
                                 printk(KERN_DEBUG "kcapi: got [%03d] %s\n",
-                                        card->cnr, cdb->buf);
+                                        ctr->cnr, cdb->buf);
                                 cdebbuf_free(cdb);
                         } else
                                 printk(KERN_DEBUG "kcapi: got [%03d] id#%d %s len=%u, cannot trace\n",
-                                        card->cnr, CAPIMSG_APPID(skb->data),
+                                        ctr->cnr, CAPIMSG_APPID(skb->data),
                                         capi_cmd2str(cmd, subcmd),
                                         CAPIMSG_LEN(skb->data));
                 }
 
         }
 
-        read_lock_irqsave(&application_lock, flags);
+        rcu_read_lock();
         ap = get_capi_appl_by_nr(CAPIMSG_APPID(skb->data));
-        if ((!ap) || (ap->release_in_progress)) {
-                read_unlock_irqrestore(&application_lock, flags);
+        if (!ap) {
+                rcu_read_unlock();
                 cdb = capi_message2str(skb->data);
                 if (cdb) {
                         printk(KERN_ERR "kcapi: handle_message: applid %d state released (%s)\n",
@@ -348,7 +399,7 @@ void capi_ctr_handle_message(struct capi_ctr * card, u16 appl, struct sk_buff *s
         }
         skb_queue_tail(&ap->recv_queue, skb);
         schedule_work(&ap->recv_work);
-        read_unlock_irqrestore(&application_lock, flags);
+        rcu_read_unlock();
 
         return;
 
@@ -360,74 +411,54 @@ EXPORT_SYMBOL(capi_ctr_handle_message);
 
 /**
  * capi_ctr_ready() - signal CAPI controller ready
- * @card:       controller descriptor structure.
+ * @ctr:        controller descriptor structure.
  *
  * Called by hardware driver to signal that the controller is up and running.
  */
 
-void capi_ctr_ready(struct capi_ctr * card)
+void capi_ctr_ready(struct capi_ctr *ctr)
 {
-        card->cardstate = CARD_RUNNING;
-
-        printk(KERN_NOTICE "kcapi: card [%03d] \"%s\" ready.\n",
-               card->cnr, card->name);
+        printk(KERN_NOTICE "kcapi: controller [%03d] \"%s\" ready.\n",
+               ctr->cnr, ctr->name);
 
-        notify_push(KCI_CONTRUP, card->cnr, 0, 0);
+        notify_push(CAPICTR_UP, ctr->cnr);
 }
 
 EXPORT_SYMBOL(capi_ctr_ready);
 
 /**
  * capi_ctr_down() - signal CAPI controller not ready
- * @card:       controller descriptor structure.
+ * @ctr:        controller descriptor structure.
  *
  * Called by hardware driver to signal that the controller is down and
  * unavailable for use.
  */
 
-void capi_ctr_down(struct capi_ctr * card)
+void capi_ctr_down(struct capi_ctr *ctr)
 {
-        u16 appl;
-
-        DBG("");
-
-        if (card->cardstate == CARD_DETECTED)
-                return;
-
-        card->cardstate = CARD_DETECTED;
-
-        memset(card->manu, 0, sizeof(card->manu));
-        memset(&card->version, 0, sizeof(card->version));
-        memset(&card->profile, 0, sizeof(card->profile));
-        memset(card->serial, 0, sizeof(card->serial));
-
-        for (appl = 1; appl <= CAPI_MAXAPPL; appl++) {
-                struct capi20_appl *ap = get_capi_appl_by_nr(appl);
-                if (!ap || ap->release_in_progress)
-                        continue;
-
-                capi_ctr_put(card);
-        }
-
-        printk(KERN_NOTICE "kcapi: card [%03d] down.\n", card->cnr);
+        printk(KERN_NOTICE "kcapi: controller [%03d] down.\n", ctr->cnr);
 
-        notify_push(KCI_CONTRDOWN, card->cnr, 0, 0);
+        notify_push(CAPICTR_DOWN, ctr->cnr);
 }
 
 EXPORT_SYMBOL(capi_ctr_down);
 
 /**
  * capi_ctr_suspend_output() - suspend controller
- * @card:       controller descriptor structure.
+ * @ctr:        controller descriptor structure.
  *
  * Called by hardware driver to stop data flow.
+ *
+ * Note: The caller is responsible for synchronizing concurrent state changes
+ * as well as invocations of capi_ctr_handle_message.
  */
 
-void capi_ctr_suspend_output(struct capi_ctr *card)
+void capi_ctr_suspend_output(struct capi_ctr *ctr)
 {
-        if (!card->blocked) {
-                printk(KERN_DEBUG "kcapi: card [%03d] suspend\n", card->cnr);
-                card->blocked = 1;
+        if (!ctr->blocked) {
+                printk(KERN_DEBUG "kcapi: controller [%03d] suspend\n",
+                       ctr->cnr);
+                ctr->blocked = 1;
         }
 }
 
@@ -435,16 +466,20 @@ EXPORT_SYMBOL(capi_ctr_suspend_output);
 
 /**
  * capi_ctr_resume_output() - resume controller
- * @card:       controller descriptor structure.
+ * @ctr:        controller descriptor structure.
  *
  * Called by hardware driver to resume data flow.
+ *
+ * Note: The caller is responsible for synchronizing concurrent state changes
+ * as well as invocations of capi_ctr_handle_message.
  */
 
-void capi_ctr_resume_output(struct capi_ctr *card)
+void capi_ctr_resume_output(struct capi_ctr *ctr)
 {
-        if (card->blocked) {
-                printk(KERN_DEBUG "kcapi: card [%03d] resume\n", card->cnr);
-                card->blocked = 0;
+        if (ctr->blocked) {
+                printk(KERN_DEBUG "kcapi: controller [%03d] resumed\n",
+                       ctr->cnr);
+                ctr->blocked = 0;
         }
 }
 
@@ -454,53 +489,48 @@ EXPORT_SYMBOL(capi_ctr_resume_output);
 
 /**
  * attach_capi_ctr() - register CAPI controller
- * @card:       controller descriptor structure.
+ * @ctr:        controller descriptor structure.
  *
  * Called by hardware driver to register a controller with the CAPI subsystem.
  * Return value: 0 on success, error code < 0 on error
  */
 
-int
-attach_capi_ctr(struct capi_ctr *card)
+int attach_capi_ctr(struct capi_ctr *ctr)
 {
         int i;
 
-        mutex_lock(&controller_mutex);
+        mutex_lock(&capi_controller_lock);
 
         for (i = 0; i < CAPI_MAXCONTR; i++) {
-                if (capi_cards[i] == NULL)
+                if (!capi_controller[i])
                         break;
         }
         if (i == CAPI_MAXCONTR) {
-                mutex_unlock(&controller_mutex);
+                mutex_unlock(&capi_controller_lock);
                 printk(KERN_ERR "kcapi: out of controller slots\n");
                 return -EBUSY;
         }
-        capi_cards[i] = card;
-
-        mutex_unlock(&controller_mutex);
-
-        card->nrecvctlpkt = 0;
-        card->nrecvdatapkt = 0;
-        card->nsentctlpkt = 0;
-        card->nsentdatapkt = 0;
-        card->cnr = i + 1;
-        card->cardstate = CARD_DETECTED;
-        card->blocked = 0;
-        card->traceflag = showcapimsgs;
-
-        sprintf(card->procfn, "capi/controllers/%d", card->cnr);
-        card->procent = create_proc_entry(card->procfn, 0, NULL);
-        if (card->procent) {
-           card->procent->read_proc = 
-                (int (*)(char *,char **,off_t,int,int *,void *))
-                        card->ctr_read_proc;
-           card->procent->data = card;
-        }
+        capi_controller[i] = ctr;
+
+        ctr->nrecvctlpkt = 0;
+        ctr->nrecvdatapkt = 0;
+        ctr->nsentctlpkt = 0;
+        ctr->nsentdatapkt = 0;
+        ctr->cnr = i + 1;
+        ctr->state = CAPI_CTR_DETECTED;
+        ctr->blocked = 0;
+        ctr->traceflag = showcapimsgs;
+        init_waitqueue_head(&ctr->state_wait_queue);
 
-        ncards++;
-        printk(KERN_NOTICE "kcapi: Controller [%03d]: %s attached\n",
-                        card->cnr, card->name);
+        sprintf(ctr->procfn, "capi/controllers/%d", ctr->cnr);
+        ctr->procent = proc_create_data(ctr->procfn, 0, NULL, ctr->proc_fops, ctr);
+
+        ncontrollers++;
+
+        mutex_unlock(&capi_controller_lock);
+
+        printk(KERN_NOTICE "kcapi: controller [%03d]: %s attached\n",
+                        ctr->cnr, ctr->name);
         return 0;
 }
 
@@ -508,29 +538,38 @@ EXPORT_SYMBOL(attach_capi_ctr);
 
 /**
  * detach_capi_ctr() - unregister CAPI controller
- * @card:       controller descriptor structure.
+ * @ctr:        controller descriptor structure.
  *
  * Called by hardware driver to remove the registration of a controller
  * with the CAPI subsystem.
  * Return value: 0 on success, error code < 0 on error
  */
 
-int detach_capi_ctr(struct capi_ctr *card)
+int detach_capi_ctr(struct capi_ctr *ctr)
 {
-        if (card->cardstate != CARD_DETECTED)
-                capi_ctr_down(card);
+        int err = 0;
 
-        ncards--;
+        mutex_lock(&capi_controller_lock);
 
-        if (card->procent) {
-           remove_proc_entry(card->procfn, NULL);
-           card->procent = NULL;
+        ctr_down(ctr, CAPI_CTR_DETACHED);
+
+        if (capi_controller[ctr->cnr - 1] != ctr) {
+                err = -EINVAL;
+                goto unlock_out;
         }
-        capi_cards[card->cnr - 1] = NULL;
-        printk(KERN_NOTICE "kcapi: Controller [%03d]: %s unregistered\n",
-                        card->cnr, card->name);
+        capi_controller[ctr->cnr - 1] = NULL;
+        ncontrollers--;
 
-        return 0;
+        if (ctr->procent)
+                remove_proc_entry(ctr->procfn, NULL);
+
+        printk(KERN_NOTICE "kcapi: controller [%03d]: %s unregistered\n",
+               ctr->cnr, ctr->name);
+
+unlock_out:
+        mutex_unlock(&capi_controller_lock);
+
+        return err;
 }
 
 EXPORT_SYMBOL(detach_capi_ctr);
@@ -544,11 +583,9 @@ EXPORT_SYMBOL(detach_capi_ctr);
 
 void register_capi_driver(struct capi_driver *driver)
 {
-        unsigned long flags;
-
-        write_lock_irqsave(&capi_drivers_list_lock, flags);
+        mutex_lock(&capi_drivers_lock);
         list_add_tail(&driver->list, &capi_drivers);
-        write_unlock_irqrestore(&capi_drivers_list_lock, flags);
+        mutex_unlock(&capi_drivers_lock);
 }
 
 EXPORT_SYMBOL(register_capi_driver);
@@ -562,11 +599,9 @@ EXPORT_SYMBOL(register_capi_driver);
 
 void unregister_capi_driver(struct capi_driver *driver)
 {
-        unsigned long flags;
-
-        write_lock_irqsave(&capi_drivers_list_lock, flags);
+        mutex_lock(&capi_drivers_lock);
         list_del(&driver->list);
-        write_unlock_irqrestore(&capi_drivers_list_lock, flags);
+        mutex_unlock(&capi_drivers_lock);
 }
 
 EXPORT_SYMBOL(unregister_capi_driver);
@@ -584,12 +619,21 @@ EXPORT_SYMBOL(unregister_capi_driver);
 
 u16 capi20_isinstalled(void)
 {
+        u16 ret = CAPI_REGNOTINSTALLED;
         int i;
-        for (i = 0; i < CAPI_MAXCONTR; i++) {
-                if (capi_cards[i] && capi_cards[i]->cardstate == CARD_RUNNING)
-                        return CAPI_NOERROR;
-        }
-        return CAPI_REGNOTINSTALLED;
+
+        mutex_lock(&capi_controller_lock);
+
+        for (i = 0; i < CAPI_MAXCONTR; i++)
+                if (capi_controller[i] &&
+                    capi_controller[i]->state == CAPI_CTR_RUNNING) {
+                        ret = CAPI_NOERROR;
+                        break;
+                }
+
+        mutex_unlock(&capi_controller_lock);
+
+        return ret;
 }
 
 EXPORT_SYMBOL(capi20_isinstalled);
@@ -610,46 +654,43 @@ u16 capi20_register(struct capi20_appl *ap)
 {
         int i;
         u16 applid;
-        unsigned long flags;
 
         DBG("");
 
         if (ap->rparam.datablklen < 128)
                 return CAPI_LOGBLKSIZETOSMALL;
 
-        write_lock_irqsave(&application_lock, flags);
+        ap->nrecvctlpkt = 0;
+        ap->nrecvdatapkt = 0;
+        ap->nsentctlpkt = 0;
+        ap->nsentdatapkt = 0;
+        mutex_init(&ap->recv_mtx);
+        skb_queue_head_init(&ap->recv_queue);
+        INIT_WORK(&ap->recv_work, recv_handler);
+        ap->release_in_progress = 0;
+
+        mutex_lock(&capi_controller_lock);
 
         for (applid = 1; applid <= CAPI_MAXAPPL; applid++) {
                 if (capi_applications[applid - 1] == NULL)
                         break;
         }
         if (applid > CAPI_MAXAPPL) {
-                write_unlock_irqrestore(&application_lock, flags);
+                mutex_unlock(&capi_controller_lock);
                 return CAPI_TOOMANYAPPLS;
         }
 
         ap->applid = applid;
         capi_applications[applid - 1] = ap;
 
-        ap->nrecvctlpkt = 0;
-        ap->nrecvdatapkt = 0;
-        ap->nsentctlpkt = 0;
-        ap->nsentdatapkt = 0;
-        ap->callback = NULL;
-        mutex_init(&ap->recv_mtx);
-        skb_queue_head_init(&ap->recv_queue);
-        INIT_WORK(&ap->recv_work, recv_handler);
-        ap->release_in_progress = 0;
-
-        write_unlock_irqrestore(&application_lock, flags);
-        
-        mutex_lock(&controller_mutex);
         for (i = 0; i < CAPI_MAXCONTR; i++) {
-                if (!capi_cards[i] || capi_cards[i]->cardstate != CARD_RUNNING)
+                if (!capi_controller[i] ||
+                    capi_controller[i]->state != CAPI_CTR_RUNNING)
                         continue;
-                register_appl(capi_cards[i], applid, &ap->rparam);
+                register_appl(capi_controller[i], applid, &ap->rparam);
         }
-        mutex_unlock(&controller_mutex);
+
+        mutex_unlock(&capi_controller_lock);
 
         if (showcapimsgs & 1) {
                 printk(KERN_DEBUG "kcapi: appl %d up\n", applid);
@@ -673,22 +714,24 @@ EXPORT_SYMBOL(capi20_register);
 u16 capi20_release(struct capi20_appl *ap)
 {
         int i;
-        unsigned long flags;
 
         DBG("applid %#x", ap->applid);
 
-        write_lock_irqsave(&application_lock, flags);
+        mutex_lock(&capi_controller_lock);
+
         ap->release_in_progress = 1;
         capi_applications[ap->applid - 1] = NULL;
-        write_unlock_irqrestore(&application_lock, flags);
 
-        mutex_lock(&controller_mutex);
+        synchronize_rcu();
+
         for (i = 0; i < CAPI_MAXCONTR; i++) {
-                if (!capi_cards[i] || capi_cards[i]->cardstate != CARD_RUNNING)
+                if (!capi_controller[i] ||
+                    capi_controller[i]->state != CAPI_CTR_RUNNING)
                         continue;
-                release_appl(capi_cards[i], ap->applid);
+                release_appl(capi_controller[i], ap->applid);
         }
-        mutex_unlock(&controller_mutex);
+
+        mutex_unlock(&capi_controller_lock);
 
         flush_scheduled_work();
         skb_queue_purge(&ap->recv_queue);
@@ -713,13 +756,13 @@ EXPORT_SYMBOL(capi20_release);
 
 u16 capi20_put_message(struct capi20_appl *ap, struct sk_buff *skb)
 {
-        struct capi_ctr *card;
+        struct capi_ctr *ctr;
         int showctl = 0;
         u8 cmd, subcmd;
 
         DBG("applid %#x", ap->applid);
  
-        if (ncards == 0)
+        if (ncontrollers == 0)
                 return CAPI_REGNOTINSTALLED;
         if ((ap->applid == 0) || ap->release_in_progress)
                 return CAPI_ILLAPPNR;
@@ -727,28 +770,33 @@ u16 capi20_put_message(struct capi20_appl *ap, struct sk_buff *skb)
             || !capi_cmd_valid(CAPIMSG_COMMAND(skb->data))
             || !capi_subcmd_valid(CAPIMSG_SUBCOMMAND(skb->data)))
                 return CAPI_ILLCMDORSUBCMDORMSGTOSMALL;
-        card = get_capi_ctr_by_nr(CAPIMSG_CONTROLLER(skb->data));
-        if (!card || card->cardstate != CARD_RUNNING) {
-                card = get_capi_ctr_by_nr(1); // XXX why?
-                if (!card || card->cardstate != CARD_RUNNING) 
-                        return CAPI_REGNOTINSTALLED;
-        }
-        if (card->blocked)
+
+        /*
+         * The controller reference is protected by the existence of the
+         * application passed to us. We assume that the caller properly
+         * synchronizes this service with capi20_release.
+         */
+        ctr = get_capi_ctr_by_nr(CAPIMSG_CONTROLLER(skb->data));
+        if (!ctr || ctr->state != CAPI_CTR_RUNNING)
+                return CAPI_REGNOTINSTALLED;
+        if (ctr->blocked)
                 return CAPI_SENDQUEUEFULL;
 
         cmd = CAPIMSG_COMMAND(skb->data);
         subcmd = CAPIMSG_SUBCOMMAND(skb->data);
 
         if (cmd == CAPI_DATA_B3 && subcmd== CAPI_REQ) {
-                card->nsentdatapkt++;
+                ctr->nsentdatapkt++;
                 ap->nsentdatapkt++;
-                if (card->traceflag > 2) showctl |= 2;
+                if (ctr->traceflag > 2)
+                        showctl |= 2;
         } else {
-                card->nsentctlpkt++;
+                ctr->nsentctlpkt++;
                 ap->nsentctlpkt++;
-                if (card->traceflag) showctl |= 2;
+                if (ctr->traceflag)
+                        showctl |= 2;
         }
-        showctl |= (card->traceflag & 1);
+        showctl |= (ctr->traceflag & 1);
         if (showctl & 2) {
                 if (showctl & 1) {
                         printk(KERN_DEBUG "kcapi: put [%03d] id#%d %s len=%u\n",
@@ -771,7 +819,7 @@ u16 capi20_put_message(struct capi20_appl *ap, struct sk_buff *skb)
                                         CAPIMSG_LEN(skb->data));
                 }
         }
-        return card->send_message(card, skb);
+        return ctr->send_message(ctr, skb);
 }
 
 EXPORT_SYMBOL(capi20_put_message);
@@ -788,17 +836,25 @@ EXPORT_SYMBOL(capi20_put_message);
 
 u16 capi20_get_manufacturer(u32 contr, u8 *buf)
 {
-        struct capi_ctr *card;
+        struct capi_ctr *ctr;
+        u16 ret;
 
         if (contr == 0) {
                 strlcpy(buf, capi_manufakturer, CAPI_MANUFACTURER_LEN);
                 return CAPI_NOERROR;
         }
-        card = get_capi_ctr_by_nr(contr);
-        if (!card || card->cardstate != CARD_RUNNING) 
-                return CAPI_REGNOTINSTALLED;
-        strlcpy(buf, card->manu, CAPI_MANUFACTURER_LEN);
-        return CAPI_NOERROR;
+
+        mutex_lock(&capi_controller_lock);
+
+        ctr = get_capi_ctr_by_nr(contr);
+        if (ctr && ctr->state == CAPI_CTR_RUNNING) {
+                strlcpy(buf, ctr->manu, CAPI_MANUFACTURER_LEN);
+                ret = CAPI_NOERROR;
+        } else
+                ret = CAPI_REGNOTINSTALLED;
+
+        mutex_unlock(&capi_controller_lock);
+        return ret;
 }
 
 EXPORT_SYMBOL(capi20_get_manufacturer);
@@ -815,18 +871,25 @@ EXPORT_SYMBOL(capi20_get_manufacturer);
 
 u16 capi20_get_version(u32 contr, struct capi_version *verp)
 {
-        struct capi_ctr *card;
+        struct capi_ctr *ctr;
+        u16 ret;
 
         if (contr == 0) {
                 *verp = driver_version;
                 return CAPI_NOERROR;
         }
-        card = get_capi_ctr_by_nr(contr);
-        if (!card || card->cardstate != CARD_RUNNING) 
-                return CAPI_REGNOTINSTALLED;
 
-        memcpy((void *) verp, &card->version, sizeof(capi_version));
-        return CAPI_NOERROR;
+        mutex_lock(&capi_controller_lock);
+
+        ctr = get_capi_ctr_by_nr(contr);
+        if (ctr && ctr->state == CAPI_CTR_RUNNING) {
+                memcpy(verp, &ctr->version, sizeof(capi_version));
+                ret = CAPI_NOERROR;
+        } else
+                ret = CAPI_REGNOTINSTALLED;
+
+        mutex_unlock(&capi_controller_lock);
+        return ret;
 }
 
 EXPORT_SYMBOL(capi20_get_version);
@@ -843,18 +906,25 @@ EXPORT_SYMBOL(capi20_get_version);
 
 u16 capi20_get_serial(u32 contr, u8 *serial)
 {
-        struct capi_ctr *card;
+        struct capi_ctr *ctr;
+        u16 ret;
 
         if (contr == 0) {
                 strlcpy(serial, driver_serial, CAPI_SERIAL_LEN);
                 return CAPI_NOERROR;
         }
-        card = get_capi_ctr_by_nr(contr);
-        if (!card || card->cardstate != CARD_RUNNING) 
-                return CAPI_REGNOTINSTALLED;
 
-        strlcpy((void *) serial, card->serial, CAPI_SERIAL_LEN);
-        return CAPI_NOERROR;
+        mutex_lock(&capi_controller_lock);
+
+        ctr = get_capi_ctr_by_nr(contr);
+        if (ctr && ctr->state == CAPI_CTR_RUNNING) {
+                strlcpy(serial, ctr->serial, CAPI_SERIAL_LEN);
+                ret = CAPI_NOERROR;
+        } else
+                ret = CAPI_REGNOTINSTALLED;
+
+        mutex_unlock(&capi_controller_lock);
+        return ret;
 }
 
 EXPORT_SYMBOL(capi20_get_serial);
@@ -871,23 +941,65 @@ EXPORT_SYMBOL(capi20_get_serial);
 
 u16 capi20_get_profile(u32 contr, struct capi_profile *profp)
 {
-        struct capi_ctr *card;
+        struct capi_ctr *ctr;
+        u16 ret;
 
         if (contr == 0) {
-                profp->ncontroller = ncards;
+                profp->ncontroller = ncontrollers;
                 return CAPI_NOERROR;
         }
-        card = get_capi_ctr_by_nr(contr);
-        if (!card || card->cardstate != CARD_RUNNING) 
-                return CAPI_REGNOTINSTALLED;
 
-        memcpy((void *) profp, &card->profile,
-                        sizeof(struct capi_profile));
-        return CAPI_NOERROR;
+        mutex_lock(&capi_controller_lock);
+
+        ctr = get_capi_ctr_by_nr(contr);
+        if (ctr && ctr->state == CAPI_CTR_RUNNING) {
+                memcpy(profp, &ctr->profile, sizeof(struct capi_profile));
+                ret = CAPI_NOERROR;
+        } else
+                ret = CAPI_REGNOTINSTALLED;
+
+        mutex_unlock(&capi_controller_lock);
+        return ret;
 }
 
 EXPORT_SYMBOL(capi20_get_profile);
 
+/* Must be called with capi_controller_lock held. */
+static int wait_on_ctr_state(struct capi_ctr *ctr, unsigned int state)
+{
+        DEFINE_WAIT(wait);
+        int retval = 0;
+
+        ctr = capi_ctr_get(ctr);
+        if (!ctr)
+                return -ESRCH;
+
+        for (;;) {
+                prepare_to_wait(&ctr->state_wait_queue, &wait,
+                                TASK_INTERRUPTIBLE);
+
+                if (ctr->state == state)
+                        break;
+                if (ctr->state == CAPI_CTR_DETACHED) {
+                        retval = -ESRCH;
+                        break;
+                }
+                if (signal_pending(current)) {
+                        retval = -EINTR;
+                        break;
+                }
+
+                mutex_unlock(&capi_controller_lock);
+                schedule();
+                mutex_lock(&capi_controller_lock);
+        }
+        finish_wait(&ctr->state_wait_queue, &wait);
+
+        capi_ctr_put(ctr);
+
+        return retval;
+}
+
 #ifdef AVMB1_COMPAT
 static int old_capi_manufacturer(unsigned int cmd, void __user *data)
 {
@@ -895,11 +1007,10 @@ static int old_capi_manufacturer(unsigned int cmd, void __user *data)
         avmb1_extcarddef cdef;
         avmb1_resetdef rdef;
         capicardparams cparams;
-        struct capi_ctr *card;
+        struct capi_ctr *ctr;
         struct capi_driver *driver = NULL;
         capiloaddata ldata;
         struct list_head *l;
-        unsigned long flags;
         int retval;
 
         switch (cmd) {
@@ -919,7 +1030,8 @@ static int old_capi_manufacturer(unsigned int cmd, void __user *data)
                 cparams.irq = cdef.irq;
                 cparams.cardnr = cdef.cardnr;
 
-                read_lock_irqsave(&capi_drivers_list_lock, flags);
+                mutex_lock(&capi_drivers_lock);
+
                 switch (cdef.cardtype) {
                         case AVM_CARDTYPE_B1:
                                 list_for_each(l, &capi_drivers) {
@@ -940,18 +1052,15 @@ static int old_capi_manufacturer(unsigned int cmd, void __user *data)
                                 break;
                 }
                 if (!driver) {
-                        read_unlock_irqrestore(&capi_drivers_list_lock, flags);
                         printk(KERN_ERR "kcapi: driver not loaded.\n");
-                        return -EIO;
-                }
-                if (!driver->add_card) {
-                        read_unlock_irqrestore(&capi_drivers_list_lock, flags);
+                        retval = -EIO;
+                } else if (!driver->add_card) {
                         printk(KERN_ERR "kcapi: driver has no add card function.\n");
-                        return -EIO;
-                }
+                        retval = -EIO;
+                } else
+                        retval = driver->add_card(driver, &cparams);
 
-                retval = driver->add_card(driver, &cparams);
-                read_unlock_irqrestore(&capi_drivers_list_lock, flags);
+                mutex_unlock(&capi_drivers_lock);
                 return retval;
 
         case AVMB1_LOAD:
@@ -968,27 +1077,30 @@ static int old_capi_manufacturer(unsigned int cmd, void __user *data)
                                            sizeof(avmb1_loadandconfigdef)))
                                 return -EFAULT;
                 }
-                card = get_capi_ctr_by_nr(ldef.contr);
-                if (!card)
-                        return -EINVAL;
-                card = capi_ctr_get(card);
-                if (!card)
-                        return -ESRCH;
-                if (card->load_firmware == NULL) {
+
+                mutex_lock(&capi_controller_lock);
+
+                ctr = get_capi_ctr_by_nr(ldef.contr);
+                if (!ctr) {
+                        retval = -EINVAL;
+                        goto load_unlock_out;
+                }
+
+                if (ctr->load_firmware == NULL) {
                         printk(KERN_DEBUG "kcapi: load: no load function\n");
-                        capi_ctr_put(card);
-                        return -ESRCH;
+                        retval = -ESRCH;
+                        goto load_unlock_out;
                 }
 
                 if (ldef.t4file.len <= 0) {
                         printk(KERN_DEBUG "kcapi: load: invalid parameter: length of t4file is %d ?\n", ldef.t4file.len);
-                        capi_ctr_put(card);
-                        return -EINVAL;
+                        retval = -EINVAL;
+                        goto load_unlock_out;
                 }
                 if (ldef.t4file.data == NULL) {
                         printk(KERN_DEBUG "kcapi: load: invalid parameter: dataptr is 0\n");
-                        capi_ctr_put(card);
-                        return -EINVAL;
+                        retval = -EINVAL;
+                        goto load_unlock_out;
                 }
 
                 ldata.firmware.user = 1;
@@ -998,54 +1110,49 @@ static int old_capi_manufacturer(unsigned int cmd, void __user *data)
                 ldata.configuration.data = ldef.t4config.data;
                 ldata.configuration.len = ldef.t4config.len;
 
-                if (card->cardstate != CARD_DETECTED) {
+                if (ctr->state != CAPI_CTR_DETECTED) {
                         printk(KERN_INFO "kcapi: load: contr=%d not in detect state\n", ldef.contr);
-                        capi_ctr_put(card);
-                        return -EBUSY;
+                        retval = -EBUSY;
+                        goto load_unlock_out;
                 }
-                card->cardstate = CARD_LOADING;
-
-                retval = card->load_firmware(card, &ldata);
+                ctr->state = CAPI_CTR_LOADING;
 
+                retval = ctr->load_firmware(ctr, &ldata);
                 if (retval) {
-                        card->cardstate = CARD_DETECTED;
-                        capi_ctr_put(card);
-                        return retval;
+                        ctr->state = CAPI_CTR_DETECTED;
+                        goto load_unlock_out;
                 }
 
-                while (card->cardstate != CARD_RUNNING) {
-
-                        msleep_interruptible(100);      /* 0.1 sec */
+                retval = wait_on_ctr_state(ctr, CAPI_CTR_RUNNING);
 
-                        if (signal_pending(current)) {
-                                capi_ctr_put(card);
-                                return -EINTR;
-                        }
-                }
-                capi_ctr_put(card);
-                return 0;
+load_unlock_out:
+                mutex_unlock(&capi_controller_lock);
+                return retval;
 
         case AVMB1_RESETCARD:
                 if (copy_from_user(&rdef, data, sizeof(avmb1_resetdef)))
                         return -EFAULT;
-                card = get_capi_ctr_by_nr(rdef.contr);
-                if (!card)
-                        return -ESRCH;
 
-                if (card->cardstate == CARD_DETECTED)
-                        return 0;
+                retval = 0;
 
-                card->reset_ctr(card);
+                mutex_lock(&capi_controller_lock);
 
-                while (card->cardstate > CARD_DETECTED) {
+                ctr = get_capi_ctr_by_nr(rdef.contr);
+                if (!ctr) {
+                        retval = -ESRCH;
+                        goto reset_unlock_out;
+                }
 
-                        msleep_interruptible(100);      /* 0.1 sec */
+                if (ctr->state == CAPI_CTR_DETECTED)
+                        goto reset_unlock_out;
 
-                        if (signal_pending(current))
-                                return -EINTR;
-                }
-                return 0;
+                ctr->reset_ctr(ctr);
+
+                retval = wait_on_ctr_state(ctr, CAPI_CTR_DETECTED);
 
+reset_unlock_out:
+                mutex_unlock(&capi_controller_lock);
+                return retval;
         }
         return -EINVAL;
 }
@@ -1062,7 +1169,8 @@ static int old_capi_manufacturer(unsigned int cmd, void __user *data)
 
 int capi20_manufacturer(unsigned int cmd, void __user *data)
 {
-        struct capi_ctr *card;
+        struct capi_ctr *ctr;
+        int retval;
 
         switch (cmd) {
 #ifdef AVMB1_COMPAT
@@ -1080,14 +1188,20 @@ int capi20_manufacturer(unsigned int cmd, void __user *data)
                 if (copy_from_user(&fdef, data, sizeof(kcapi_flagdef)))
                         return -EFAULT;
 
-                card = get_capi_ctr_by_nr(fdef.contr);
-                if (!card)
-                        return -ESRCH;
+                mutex_lock(&capi_controller_lock);
+
+                ctr = get_capi_ctr_by_nr(fdef.contr);
+                if (ctr) {
+                        ctr->traceflag = fdef.flag;
+                        printk(KERN_INFO "kcapi: contr [%03d] set trace=%d\n",
+                               ctr->cnr, ctr->traceflag);
+                        retval = 0;
+                } else
+                        retval = -ESRCH;
+
+                mutex_unlock(&capi_controller_lock);
 
-                card->traceflag = fdef.flag;
-                printk(KERN_INFO "kcapi: contr [%03d] set trace=%d\n",
-                        card->cnr, card->traceflag);
-                return 0;
+                return retval;
         }
         case KCAPI_CMD_ADDCARD:
         {
@@ -1095,7 +1209,6 @@ int capi20_manufacturer(unsigned int cmd, void __user *data)
                 struct capi_driver *driver = NULL;
                 capicardparams cparams;
                 kcapi_carddef cdef;
-                int retval;
 
                 if ((retval = copy_from_user(&cdef, data, sizeof(cdef))))
                         return retval;
@@ -1107,6 +1220,8 @@ int capi20_manufacturer(unsigned int cmd, void __user *data)
                 cparams.cardtype = 0;
                 cdef.driver[sizeof(cdef.driver)-1] = 0;
 
+                mutex_lock(&capi_drivers_lock);
+
                 list_for_each(l, &capi_drivers) {
                         driver = list_entry(l, struct capi_driver, list);
                         if (strcmp(driver->name, cdef.driver) == 0)
@@ -1115,15 +1230,15 @@ int capi20_manufacturer(unsigned int cmd, void __user *data)
                 if (driver == NULL) {
                         printk(KERN_ERR "kcapi: driver \"%s\" not loaded.\n",
                                         cdef.driver);
-                        return -ESRCH;
-                }
-
-                if (!driver->add_card) {
+                        retval = -ESRCH;
+                } else if (!driver->add_card) {
                         printk(KERN_ERR "kcapi: driver \"%s\" has no add card function.\n", cdef.driver);
-                        return -EIO;
-                }
+                        retval = -EIO;
+                } else
+                        retval = driver->add_card(driver, &cparams);
 
-                return driver->add_card(driver, &cparams);
+                mutex_unlock(&capi_drivers_lock);
+                return retval;
         }
 
         default:
@@ -1137,30 +1252,6 @@ int capi20_manufacturer(unsigned int cmd, void __user *data)
 
 EXPORT_SYMBOL(capi20_manufacturer);
 
-/* temporary hack */
-
-/**
- * capi20_set_callback() - set CAPI application notification callback function
- * @ap:         CAPI application descriptor structure.
- * @callback:   callback function (NULL to remove).
- *
- * If not NULL, the callback function will be called to notify the
- * application of the addition or removal of a controller.
- * The first argument (cmd) will tell whether the controller was added
- * (KCI_CONTRUP) or removed (KCI_CONTRDOWN).
- * The second argument (contr) will be the controller number.
- * For cmd==KCI_CONTRUP the third argument (data) will be a pointer to the
- * new controller's capability profile structure.
- */
-
-void capi20_set_callback(struct capi20_appl *ap,
-                         void (*callback) (unsigned int cmd, __u32 contr, void *data))
-{
-        ap->callback = callback;
-}
-
-EXPORT_SYMBOL(capi20_set_callback);
-
 /* ------------------------------------------------------------- */
 /* -------- Init & Cleanup ------------------------------------- */
 /* ------------------------------------------------------------- */
@@ -1169,27 +1260,21 @@ EXPORT_SYMBOL(capi20_set_callback);
  * init / exit functions
  */
 
+static struct notifier_block capictr_nb = {
+        .notifier_call = notify_handler,
+        .priority = INT_MAX,
+};
+
 static int __init kcapi_init(void)
 {
-        char *p;
-        char rev[32];
-        int ret;
-
-        ret = cdebug_init();
-        if (ret)
-                return ret;
-        kcapi_proc_init();
-
-        if ((p = strchr(revision, ':')) != NULL && p[1]) {
-                strlcpy(rev, p + 2, sizeof(rev));
-                if ((p = strchr(rev, '$')) != NULL && p > rev)
-                   *(p-1) = 0;
-        } else
-                strcpy(rev, "1.0");
+        int err;
 
-        printk(KERN_NOTICE "CAPI Subsystem Rev %s\n", rev);
+        register_capictr_notifier(&capictr_nb);
 
-        return 0;
+        err = cdebug_init();
+        if (!err)
+                kcapi_proc_init();
+        return err;
 }
 
 static void __exit kcapi_exit(void)
diff --git a/drivers/isdn/capi/kcapi.h b/drivers/isdn/capi/kcapi.h
index 244711f7f838..f4620b38ec51 100644
--- a/drivers/isdn/capi/kcapi.h
+++ b/drivers/isdn/capi/kcapi.h
@@ -24,16 +24,19 @@ printk(KERN_DEBUG "%s: " format "\n" , __func__ , ## arg); \
 #endif
 
 enum {
-        CARD_DETECTED = 1,
-        CARD_LOADING  = 2,
-        CARD_RUNNING  = 3,
+        CAPI_CTR_DETACHED = 0,
+        CAPI_CTR_DETECTED = 1,
+        CAPI_CTR_LOADING  = 2,
+        CAPI_CTR_RUNNING  = 3,
 };
 
 extern struct list_head capi_drivers;
-extern rwlock_t capi_drivers_list_lock;
+extern struct mutex capi_drivers_lock;
+
+extern struct capi_ctr *capi_controller[CAPI_MAXCONTR];
+extern struct mutex capi_controller_lock;
 
 extern struct capi20_appl *capi_applications[CAPI_MAXAPPL];
-extern struct capi_ctr *capi_cards[CAPI_MAXCONTR];
 
 #ifdef CONFIG_PROC_FS
 
diff --git a/drivers/isdn/capi/kcapi_proc.c b/drivers/isdn/capi/kcapi_proc.c
index 09d4db764d22..ea2dff602e49 100644
--- a/drivers/isdn/capi/kcapi_proc.c
+++ b/drivers/isdn/capi/kcapi_proc.c
@@ -15,13 +15,12 @@
 #include <linux/seq_file.h>
 #include <linux/init.h>
 
-static char *
-cardstate2str(unsigned short cardstate)
+static char *state2str(unsigned short state)
 {
-        switch (cardstate) {
-        case CARD_DETECTED:     return "detected";
-        case CARD_LOADING:      return "loading";
-        case CARD_RUNNING:      return "running";
+        switch (state) {
+        case CAPI_CTR_DETECTED: return "detected";
+        case CAPI_CTR_LOADING:  return "loading";
+        case CAPI_CTR_RUNNING:  return "running";
         default:                return "???";
         }
 }
@@ -36,9 +35,12 @@ cardstate2str(unsigned short cardstate)
 // ---------------------------------------------------------------------------
 
 static void *controller_start(struct seq_file *seq, loff_t *pos)
+        __acquires(capi_controller_lock)
 {
+        mutex_lock(&capi_controller_lock);
+
         if (*pos < CAPI_MAXCONTR)
-                return &capi_cards[*pos];
+                return &capi_controller[*pos];
 
         return NULL;
 }
@@ -47,13 +49,15 @@ static void *controller_next(struct seq_file *seq, void *v, loff_t *pos)
 {
         ++*pos;
         if (*pos < CAPI_MAXCONTR)
-                return &capi_cards[*pos];
+                return &capi_controller[*pos];
 
         return NULL;
 }
 
 static void controller_stop(struct seq_file *seq, void *v)
+        __releases(capi_controller_lock)
 {
+        mutex_unlock(&capi_controller_lock);
 }
 
 static int controller_show(struct seq_file *seq, void *v)
@@ -65,7 +69,7 @@ static int controller_show(struct seq_file *seq, void *v)
 
         seq_printf(seq, "%d %-10s %-8s %-16s %s\n",
                    ctr->cnr, ctr->driver_name,
-                   cardstate2str(ctr->cardstate),
+                   state2str(ctr->state),
                    ctr->name,
                    ctr->procinfo ?  ctr->procinfo(ctr) : "");
 
@@ -135,9 +139,11 @@ static const struct file_operations proc_contrstats_ops = {
 //      applid nrecvctlpkt nrecvdatapkt nsentctlpkt nsentdatapkt
 // ---------------------------------------------------------------------------
 
-static void *
-applications_start(struct seq_file *seq, loff_t *pos)
+static void *applications_start(struct seq_file *seq, loff_t *pos)
+        __acquires(capi_controller_lock)
 {
+        mutex_lock(&capi_controller_lock);
+
         if (*pos < CAPI_MAXAPPL)
                 return &capi_applications[*pos];
 
@@ -154,9 +160,10 @@ applications_next(struct seq_file *seq, void *v, loff_t *pos)
         return NULL;
 }
 
-static void
-applications_stop(struct seq_file *seq, void *v)
+static void applications_stop(struct seq_file *seq, void *v)
+        __releases(capi_controller_lock)
 {
+        mutex_unlock(&capi_controller_lock);
 }
 
 static int
@@ -239,9 +246,9 @@ static const struct file_operations proc_applstats_ops = {
 // ---------------------------------------------------------------------------
 
 static void *capi_driver_start(struct seq_file *seq, loff_t *pos)
-        __acquires(&capi_drivers_list_lock)
+        __acquires(&capi_drivers_lock)
 {
-        read_lock(&capi_drivers_list_lock);
+        mutex_lock(&capi_drivers_lock);
         return seq_list_start(&capi_drivers, *pos);
 }
 
@@ -251,9 +258,9 @@ static void *capi_driver_next(struct seq_file *seq, void *v, loff_t *pos)
 }
 
 static void capi_driver_stop(struct seq_file *seq, void *v)
-        __releases(&capi_drivers_list_lock)
+        __releases(&capi_drivers_lock)
 {
-        read_unlock(&capi_drivers_list_lock);
+        mutex_unlock(&capi_drivers_lock);
 }
 
 static int capi_driver_show(struct seq_file *seq, void *v)
diff --git a/drivers/isdn/gigaset/asyncdata.c b/drivers/isdn/gigaset/asyncdata.c
index ccb2a7b7c41d..c5016bd2d94f 100644
--- a/drivers/isdn/gigaset/asyncdata.c
+++ b/drivers/isdn/gigaset/asyncdata.c
@@ -40,6 +40,8 @@ static inline int muststuff(unsigned char c)
  * Append received bytes to the command response buffer and forward them
  * line by line to the response handler. Exit whenever a mode/state change
  * might have occurred.
+ * Note: Received lines may be terminated by CR, LF, or CR LF, which will be
+ * removed before passing the line to the response handler.
  * Return value:
  *      number of processed bytes
  */
@@ -65,14 +67,14 @@ static unsigned cmd_loop(unsigned numbytes, struct inbuf_t *inbuf)
                         /* --v-- fall through --v-- */
                 case '\r':
                         /* end of message line, pass to response handler */
-                        gig_dbg(DEBUG_TRANSCMD, "%s: End of Message (%d Bytes)",
-                                __func__, cbytes);
                         if (cbytes >= MAX_RESP_SIZE) {
                                 dev_warn(cs->dev, "response too large (%d)\n",
                                          cbytes);
                                 cbytes = MAX_RESP_SIZE;
                         }
                         cs->cbytes = cbytes;
+                        gigaset_dbg_buffer(DEBUG_TRANSCMD, "received response",
+                                           cbytes, cs->respdata);
                         gigaset_handle_modem_response(cs);
                         cbytes = 0;
 
diff --git a/drivers/isdn/gigaset/bas-gigaset.c b/drivers/isdn/gigaset/bas-gigaset.c
index 95ebc5129895..0be15c70c16d 100644
--- a/drivers/isdn/gigaset/bas-gigaset.c
+++ b/drivers/isdn/gigaset/bas-gigaset.c
@@ -347,12 +347,7 @@ static inline void error_hangup(struct bc_state *bcs)
 {
         struct cardstate *cs = bcs->cs;
 
-        gig_dbg(DEBUG_ANY, "%s: scheduling HUP for channel %d",
-                __func__, bcs->channel);
-
-        if (!gigaset_add_event(cs, &bcs->at_state, EV_HUP, NULL, 0, NULL))
-                dev_err(cs->dev, "event queue full\n");
-
+        gigaset_add_event(cs, &bcs->at_state, EV_HUP, NULL, 0, NULL);
         gigaset_schedule_event(cs);
 }
 
@@ -1706,8 +1701,7 @@ static void complete_cb(struct cardstate *cs)
 
         /* unqueue completed buffer */
         cs->cmdbytes -= cs->curlen;
-        gig_dbg(DEBUG_TRANSCMD|DEBUG_LOCKCMD,
-                "write_command: sent %u bytes, %u left",
+        gig_dbg(DEBUG_OUTPUT, "write_command: sent %u bytes, %u left",
                 cs->curlen, cs->cmdbytes);
         if (cb->next != NULL) {
                 cs->cmdbuf = cb->next;
@@ -1881,13 +1875,13 @@ static int start_cbsend(struct cardstate *cs)
 
         /* check if suspend requested */
         if (ucs->basstate & BS_SUSPEND) {
-                gig_dbg(DEBUG_TRANSCMD|DEBUG_LOCKCMD, "suspending");
+                gig_dbg(DEBUG_OUTPUT, "suspending");
                 return -EHOSTUNREACH;
         }
 
         /* check if AT channel is open */
         if (!(ucs->basstate & BS_ATOPEN)) {
-                gig_dbg(DEBUG_TRANSCMD|DEBUG_LOCKCMD, "AT channel not open");
+                gig_dbg(DEBUG_OUTPUT, "AT channel not open");
                 rc = req_submit(cs->bcs, HD_OPEN_ATCHANNEL, 0, BAS_TIMEOUT);
                 if (rc < 0) {
                         /* flush command queue */
@@ -2251,7 +2245,7 @@ static int gigaset_probe(struct usb_interface *interface,
         int i, j;
         int rc;
 
-        gig_dbg(DEBUG_ANY,
+        gig_dbg(DEBUG_INIT,
                 "%s: Check if device matches .. (Vendor: 0x%x, Product: 0x%x)",
                 __func__, le16_to_cpu(udev->descriptor.idVendor),
                 le16_to_cpu(udev->descriptor.idProduct));
@@ -2259,7 +2253,7 @@ static int gigaset_probe(struct usb_interface *interface,
         /* set required alternate setting */
         hostif = interface->cur_altsetting;
         if (hostif->desc.bAlternateSetting != 3) {
-                gig_dbg(DEBUG_ANY,
+                gig_dbg(DEBUG_INIT,
                         "%s: wrong alternate setting %d - trying to switch",
                         __func__, hostif->desc.bAlternateSetting);
                 if (usb_set_interface(udev, hostif->desc.bInterfaceNumber, 3)
diff --git a/drivers/isdn/gigaset/capi.c b/drivers/isdn/gigaset/capi.c
index 3f5cd06af104..6643d6533ccb 100644
--- a/drivers/isdn/gigaset/capi.c
+++ b/drivers/isdn/gigaset/capi.c
@@ -13,6 +13,8 @@
 
 #include "gigaset.h"
 #include <linux/ctype.h>
+#include <linux/proc_fs.h>
+#include <linux/seq_file.h>
 #include <linux/isdn/capilli.h>
 #include <linux/isdn/capicmd.h>
 #include <linux/isdn/capiutil.h>
@@ -169,20 +171,6 @@ static inline void ignore_cstruct_param(struct cardstate *cs, _cstruct param,
 }
 
 /*
- * check for legal hex digit
- */
-static inline int ishexdigit(char c)
-{
-        if (c >= '0' && c <= '9')
-                return 1;
-        if (c >= 'A' && c <= 'F')
-                return 1;
-        if (c >= 'a' && c <= 'f')
-                return 1;
-        return 0;
-}
-
-/*
  * convert hex to binary
  */
 static inline u8 hex2bin(char c)
@@ -202,7 +190,7 @@ static int encode_ie(char *in, u8 *out, int maxlen)
 {
         int l = 0;
         while (*in) {
-                if (!ishexdigit(in[0]) || !ishexdigit(in[1]) || l >= maxlen)
+                if (!isxdigit(in[0]) || !isxdigit(in[1]) || l >= maxlen)
                         return -1;
                 out[++l] = (hex2bin(in[0]) << 4) + hex2bin(in[1]);
                 in += 2;
@@ -1425,9 +1413,10 @@ static void do_connect_req(struct gigaset_capi_ctr *iif,
 
         /* queue & schedule EV_DIAL event */
         if (!gigaset_add_event(cs, &bcs->at_state, EV_DIAL, commands,
-                               bcs->at_state.seq_index, NULL))
-                goto oom;
-        gig_dbg(DEBUG_CMD, "scheduling DIAL");
+                               bcs->at_state.seq_index, NULL)) {
+                info = CAPI_MSGOSRESOURCEERR;
+                goto error;
+        }
         gigaset_schedule_event(cs);
         ap->connected = APCONN_SETUP;
         send_conf(iif, ap, skb, CapiSuccess);
@@ -1541,7 +1530,6 @@ static void do_connect_resp(struct gigaset_capi_ctr *iif,
                 if (!gigaset_add_event(cs, &cs->bcs[channel-1].at_state,
                                        EV_ACCEPT, NULL, 0, NULL))
                         return;
-                gig_dbg(DEBUG_CMD, "scheduling ACCEPT");
                 gigaset_schedule_event(cs);
                 return;
 
@@ -1582,7 +1570,6 @@ static void do_connect_resp(struct gigaset_capi_ctr *iif,
                 if (!gigaset_add_event(cs, &cs->bcs[channel-1].at_state,
                                        EV_HUP, NULL, 0, NULL))
                         return;
-                gig_dbg(DEBUG_CMD, "scheduling HUP");
                 gigaset_schedule_event(cs);
                 return;
         }
@@ -1665,11 +1652,9 @@ static void do_connect_b3_resp(struct gigaset_capi_ctr *iif,
                 /* trigger hangup, causing eventual DISCONNECT_IND */
                 if (!gigaset_add_event(cs, &bcs->at_state,
                                        EV_HUP, NULL, 0, NULL)) {
-                        dev_err(cs->dev, "%s: out of memory\n", __func__);
                         dev_kfree_skb_any(skb);
                         return;
                 }
-                gig_dbg(DEBUG_CMD, "scheduling HUP");
                 gigaset_schedule_event(cs);
 
                 /* emit DISCONNECT_B3_IND */
@@ -1768,11 +1753,9 @@ static void do_disconnect_req(struct gigaset_capi_ctr *iif,
 
         /* trigger hangup, causing eventual DISCONNECT_IND */
         if (!gigaset_add_event(cs, &bcs->at_state, EV_HUP, NULL, 0, NULL)) {
-                dev_err(cs->dev, "%s: out of memory\n", __func__);
                 send_conf(iif, ap, skb, CAPI_MSGOSRESOURCEERR);
                 return;
         }
-        gig_dbg(DEBUG_CMD, "scheduling HUP");
         gigaset_schedule_event(cs);
 
         /* emit reply */
@@ -1815,11 +1798,9 @@ static void do_disconnect_b3_req(struct gigaset_capi_ctr *iif,
         /* trigger hangup, causing eventual DISCONNECT_B3_IND */
         if (!gigaset_add_event(cs, &cs->bcs[channel-1].at_state,
                                EV_HUP, NULL, 0, NULL)) {
-                dev_err(cs->dev, "%s: out of memory\n", __func__);
                 send_conf(iif, ap, skb, CAPI_MSGOSRESOURCEERR);
                 return;
         }
-        gig_dbg(DEBUG_CMD, "scheduling HUP");
         gigaset_schedule_event(cs);
 
         /* NCPI parameter: not applicable for B3 Transparent */
@@ -2106,35 +2087,22 @@ static char *gigaset_procinfo(struct capi_ctr *ctr)
         return ctr->name;       /* ToDo: more? */
 }
 
-/**
- * gigaset_ctr_read_proc() - build controller proc file entry
- * @page:       buffer of PAGE_SIZE bytes for receiving the entry.
- * @start:      unused.
- * @off:        unused.
- * @count:      unused.
- * @eof:        unused.
- * @ctr:        controller descriptor structure.
- *
- * Return value: length of generated entry
- */
-static int gigaset_ctr_read_proc(char *page, char **start, off_t off,
-                          int count, int *eof, struct capi_ctr *ctr)
+static int gigaset_proc_show(struct seq_file *m, void *v)
 {
+        struct capi_ctr *ctr = m->private;
         struct cardstate *cs = ctr->driverdata;
         char *s;
         int i;
-        int len = 0;
-        len += sprintf(page+len, "%-16s %s\n", "name", ctr->name);
-        len += sprintf(page+len, "%-16s %s %s\n", "dev",
+
+        seq_printf(m, "%-16s %s\n", "name", ctr->name);
+        seq_printf(m, "%-16s %s %s\n", "dev",
                         dev_driver_string(cs->dev), dev_name(cs->dev));
-        len += sprintf(page+len, "%-16s %d\n", "id", cs->myid);
+        seq_printf(m, "%-16s %d\n", "id", cs->myid);
         if (cs->gotfwver)
-                len += sprintf(page+len, "%-16s %d.%d.%d.%d\n", "firmware",
+                seq_printf(m, "%-16s %d.%d.%d.%d\n", "firmware",
                         cs->fwver[0], cs->fwver[1], cs->fwver[2], cs->fwver[3]);
-        len += sprintf(page+len, "%-16s %d\n", "channels",
-                        cs->channels);
-        len += sprintf(page+len, "%-16s %s\n", "onechannel",
-                        cs->onechannel ? "yes" : "no");
+        seq_printf(m, "%-16s %d\n", "channels", cs->channels);
+        seq_printf(m, "%-16s %s\n", "onechannel", cs->onechannel ? "yes" : "no");
 
         switch (cs->mode) {
         case M_UNKNOWN:
@@ -2152,7 +2120,7 @@ static int gigaset_ctr_read_proc(char *page, char **start, off_t off,
         default:
                 s = "??";
         }
-        len += sprintf(page+len, "%-16s %s\n", "mode", s);
+        seq_printf(m, "%-16s %s\n", "mode", s);
 
         switch (cs->mstate) {
         case MS_UNINITIALIZED:
@@ -2176,25 +2144,21 @@ static int gigaset_ctr_read_proc(char *page, char **start, off_t off,
         default:
                 s = "??";
         }
-        len += sprintf(page+len, "%-16s %s\n", "mstate", s);
+        seq_printf(m, "%-16s %s\n", "mstate", s);
 
-        len += sprintf(page+len, "%-16s %s\n", "running",
-                        cs->running ? "yes" : "no");
-        len += sprintf(page+len, "%-16s %s\n", "connected",
-                        cs->connected ? "yes" : "no");
-        len += sprintf(page+len, "%-16s %s\n", "isdn_up",
-                        cs->isdn_up ? "yes" : "no");
-        len += sprintf(page+len, "%-16s %s\n", "cidmode",
-                        cs->cidmode ? "yes" : "no");
+        seq_printf(m, "%-16s %s\n", "running", cs->running ? "yes" : "no");
+        seq_printf(m, "%-16s %s\n", "connected", cs->connected ? "yes" : "no");
+        seq_printf(m, "%-16s %s\n", "isdn_up", cs->isdn_up ? "yes" : "no");
+        seq_printf(m, "%-16s %s\n", "cidmode", cs->cidmode ? "yes" : "no");
 
         for (i = 0; i < cs->channels; i++) {
-                len += sprintf(page+len, "[%d]%-13s %d\n", i, "corrupted",
+                seq_printf(m, "[%d]%-13s %d\n", i, "corrupted",
                                 cs->bcs[i].corrupted);
-                len += sprintf(page+len, "[%d]%-13s %d\n", i, "trans_down",
+                seq_printf(m, "[%d]%-13s %d\n", i, "trans_down",
                                 cs->bcs[i].trans_down);
-                len += sprintf(page+len, "[%d]%-13s %d\n", i, "trans_up",
+                seq_printf(m, "[%d]%-13s %d\n", i, "trans_up",
                                 cs->bcs[i].trans_up);
-                len += sprintf(page+len, "[%d]%-13s %d\n", i, "chstate",
+                seq_printf(m, "[%d]%-13s %d\n", i, "chstate",
                                 cs->bcs[i].chstate);
                 switch (cs->bcs[i].proto2) {
                 case L2_BITSYNC:
@@ -2209,11 +2173,23 @@ static int gigaset_ctr_read_proc(char *page, char **start, off_t off,
                 default:
                         s = "??";
                 }
-                len += sprintf(page+len, "[%d]%-13s %s\n", i, "proto2", s);
+                seq_printf(m, "[%d]%-13s %s\n", i, "proto2", s);
         }
-        return len;
+        return 0;
 }
 
+static int gigaset_proc_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, gigaset_proc_show, PDE(inode)->data);
+}
+
+static const struct file_operations gigaset_proc_fops = {
+        .owner          = THIS_MODULE,
+        .open           = gigaset_proc_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
 
 static struct capi_driver capi_driver_gigaset = {
         .name           = "gigaset",
@@ -2256,7 +2232,7 @@ int gigaset_isdn_register(struct cardstate *cs, const char *isdnid)
         iif->ctr.release_appl  = gigaset_release_appl;
         iif->ctr.send_message  = gigaset_send_message;
         iif->ctr.procinfo      = gigaset_procinfo;
-        iif->ctr.ctr_read_proc = gigaset_ctr_read_proc;
+        iif->ctr.proc_fops = &gigaset_proc_fops;
         INIT_LIST_HEAD(&iif->appls);
         skb_queue_head_init(&iif->sendqueue);
         atomic_set(&iif->sendqlen, 0);
diff --git a/drivers/isdn/gigaset/common.c b/drivers/isdn/gigaset/common.c
index 664b0c519c3e..85de3399a2f2 100644
--- a/drivers/isdn/gigaset/common.c
+++ b/drivers/isdn/gigaset/common.c
@@ -149,10 +149,8 @@ static int test_timeout(struct at_state_t *at_state)
                 return 0;
         }
 
-        if (!gigaset_add_event(at_state->cs, at_state, EV_TIMEOUT, NULL,
-                               at_state->timer_index, NULL))
-                        dev_err(at_state->cs->dev, "%s: out of memory\n",
-                                __func__);
+        gigaset_add_event(at_state->cs, at_state, EV_TIMEOUT, NULL,
+                          at_state->timer_index, NULL);
         return 1;
 }
 
@@ -180,7 +178,7 @@ static void timer_tick(unsigned long data)
         if (cs->running) {
                 mod_timer(&cs->timer, jiffies + msecs_to_jiffies(GIG_TICK));
                 if (timeout) {
-                        gig_dbg(DEBUG_CMD, "scheduling timeout");
+                        gig_dbg(DEBUG_EVENT, "scheduling timeout");
                         tasklet_schedule(&cs->event_tasklet);
                 }
         }
@@ -194,14 +192,14 @@ int gigaset_get_channel(struct bc_state *bcs)
 
         spin_lock_irqsave(&bcs->cs->lock, flags);
         if (bcs->use_count || !try_module_get(bcs->cs->driver->owner)) {
-                gig_dbg(DEBUG_ANY, "could not allocate channel %d",
+                gig_dbg(DEBUG_CHANNEL, "could not allocate channel %d",
                         bcs->channel);
                 spin_unlock_irqrestore(&bcs->cs->lock, flags);
                 return 0;
         }
         ++bcs->use_count;
         bcs->busy = 1;
-        gig_dbg(DEBUG_ANY, "allocated channel %d", bcs->channel);
+        gig_dbg(DEBUG_CHANNEL, "allocated channel %d", bcs->channel);
         spin_unlock_irqrestore(&bcs->cs->lock, flags);
         return 1;
 }
@@ -213,7 +211,7 @@ struct bc_state *gigaset_get_free_channel(struct cardstate *cs)
 
         spin_lock_irqsave(&cs->lock, flags);
         if (!try_module_get(cs->driver->owner)) {
-                gig_dbg(DEBUG_ANY,
+                gig_dbg(DEBUG_CHANNEL,
                         "could not get module for allocating channel");
                 spin_unlock_irqrestore(&cs->lock, flags);
                 return NULL;
@@ -223,12 +221,12 @@ struct bc_state *gigaset_get_free_channel(struct cardstate *cs)
                         ++cs->bcs[i].use_count;
                         cs->bcs[i].busy = 1;
                         spin_unlock_irqrestore(&cs->lock, flags);
-                        gig_dbg(DEBUG_ANY, "allocated channel %d", i);
+                        gig_dbg(DEBUG_CHANNEL, "allocated channel %d", i);
                         return cs->bcs + i;
                 }
         module_put(cs->driver->owner);
         spin_unlock_irqrestore(&cs->lock, flags);
-        gig_dbg(DEBUG_ANY, "no free channel");
+        gig_dbg(DEBUG_CHANNEL, "no free channel");
         return NULL;
 }
 
@@ -238,14 +236,15 @@ void gigaset_free_channel(struct bc_state *bcs)
 
         spin_lock_irqsave(&bcs->cs->lock, flags);
         if (!bcs->busy) {
-                gig_dbg(DEBUG_ANY, "could not free channel %d", bcs->channel);
+                gig_dbg(DEBUG_CHANNEL, "could not free channel %d",
+                        bcs->channel);
                 spin_unlock_irqrestore(&bcs->cs->lock, flags);
                 return;
         }
         --bcs->use_count;
         bcs->busy = 0;
         module_put(bcs->cs->driver->owner);
-        gig_dbg(DEBUG_ANY, "freed channel %d", bcs->channel);
+        gig_dbg(DEBUG_CHANNEL, "freed channel %d", bcs->channel);
         spin_unlock_irqrestore(&bcs->cs->lock, flags);
 }
 
@@ -258,14 +257,15 @@ int gigaset_get_channels(struct cardstate *cs)
         for (i = 0; i < cs->channels; ++i)
                 if (cs->bcs[i].use_count) {
                         spin_unlock_irqrestore(&cs->lock, flags);
-                        gig_dbg(DEBUG_ANY, "could not allocate all channels");
+                        gig_dbg(DEBUG_CHANNEL,
+                                "could not allocate all channels");
                         return 0;
                 }
         for (i = 0; i < cs->channels; ++i)
                 ++cs->bcs[i].use_count;
         spin_unlock_irqrestore(&cs->lock, flags);
 
-        gig_dbg(DEBUG_ANY, "allocated all channels");
+        gig_dbg(DEBUG_CHANNEL, "allocated all channels");
 
         return 1;
 }
@@ -275,7 +275,7 @@ void gigaset_free_channels(struct cardstate *cs)
         unsigned long flags;
         int i;
 
-        gig_dbg(DEBUG_ANY, "unblocking all channels");
+        gig_dbg(DEBUG_CHANNEL, "unblocking all channels");
         spin_lock_irqsave(&cs->lock, flags);
         for (i = 0; i < cs->channels; ++i)
                 --cs->bcs[i].use_count;
@@ -287,7 +287,7 @@ void gigaset_block_channels(struct cardstate *cs)
         unsigned long flags;
         int i;
 
-        gig_dbg(DEBUG_ANY, "blocking all channels");
+        gig_dbg(DEBUG_CHANNEL, "blocking all channels");
         spin_lock_irqsave(&cs->lock, flags);
         for (i = 0; i < cs->channels; ++i)
                 ++cs->bcs[i].use_count;
@@ -338,6 +338,8 @@ struct event_t *gigaset_add_event(struct cardstate *cs,
         unsigned next, tail;
         struct event_t *event = NULL;
 
+        gig_dbg(DEBUG_EVENT, "queueing event %d", type);
+
         spin_lock_irqsave(&cs->ev_lock, flags);
 
         tail = cs->ev_tail;
@@ -934,11 +936,8 @@ int gigaset_start(struct cardstate *cs)
 
         if (!gigaset_add_event(cs, &cs->at_state, EV_START, NULL, 0, NULL)) {
                 cs->waiting = 0;
-                dev_err(cs->dev, "%s: out of memory\n", __func__);
                 goto error;
         }
-
-        gig_dbg(DEBUG_CMD, "scheduling START");
         gigaset_schedule_event(cs);
 
         wait_event(cs->waitqueue, !cs->waiting);
@@ -973,12 +972,8 @@ int gigaset_shutdown(struct cardstate *cs)
 
         cs->waiting = 1;
 
-        if (!gigaset_add_event(cs, &cs->at_state, EV_SHUTDOWN, NULL, 0, NULL)) {
-                dev_err(cs->dev, "%s: out of memory\n", __func__);
+        if (!gigaset_add_event(cs, &cs->at_state, EV_SHUTDOWN, NULL, 0, NULL))
                 goto exit;
-        }
-
-        gig_dbg(DEBUG_CMD, "scheduling SHUTDOWN");
         gigaset_schedule_event(cs);
 
         wait_event(cs->waitqueue, !cs->waiting);
@@ -1004,12 +999,8 @@ void gigaset_stop(struct cardstate *cs)
 
         cs->waiting = 1;
 
-        if (!gigaset_add_event(cs, &cs->at_state, EV_STOP, NULL, 0, NULL)) {
-                dev_err(cs->dev, "%s: out of memory\n", __func__);
+        if (!gigaset_add_event(cs, &cs->at_state, EV_STOP, NULL, 0, NULL))
                 goto exit;
-        }
-
-        gig_dbg(DEBUG_CMD, "scheduling STOP");
         gigaset_schedule_event(cs);
 
         wait_event(cs->waitqueue, !cs->waiting);
diff --git a/drivers/isdn/gigaset/ev-layer.c b/drivers/isdn/gigaset/ev-layer.c
index ddeb0456d202..c8f89b78b233 100644
--- a/drivers/isdn/gigaset/ev-layer.c
+++ b/drivers/isdn/gigaset/ev-layer.c
@@ -427,7 +427,7 @@ static int isdn_getnum(char *p)
 {
         int v = -1;
 
-        gig_dbg(DEBUG_TRANSCMD, "string: %s", p);
+        gig_dbg(DEBUG_EVENT, "string: %s", p);
 
         while (*p >= '0' && *p <= '9')
                 v = ((v < 0) ? 0 : (v * 10)) + (int) ((*p++) - '0');
@@ -444,7 +444,7 @@ static int isdn_gethex(char *p)
         int v = 0;
         int c;
 
-        gig_dbg(DEBUG_TRANSCMD, "string: %s", p);
+        gig_dbg(DEBUG_EVENT, "string: %s", p);
 
         if (!*p)
                 return -1;
@@ -517,7 +517,6 @@ void gigaset_handle_modem_response(struct cardstate *cs)
                 return;
         }
         cs->respdata[len] = 0;
-        gig_dbg(DEBUG_TRANSCMD, "raw string: '%s'", cs->respdata);
         argv[0] = cs->respdata;
         params = 1;
         if (cs->at_state.getstring) {
@@ -552,14 +551,14 @@ void gigaset_handle_modem_response(struct cardstate *cs)
                 for (j = 1; j < params; ++j)
                         argv[j][-1] = 0;
 
-                gig_dbg(DEBUG_TRANSCMD, "CMD received: %s", argv[0]);
+                gig_dbg(DEBUG_EVENT, "CMD received: %s", argv[0]);
                 if (cid) {
                         --params;
-                        gig_dbg(DEBUG_TRANSCMD, "CID: %s", argv[params]);
+                        gig_dbg(DEBUG_EVENT, "CID: %s", argv[params]);
                 }
-                gig_dbg(DEBUG_TRANSCMD, "available params: %d", params - 1);
+                gig_dbg(DEBUG_EVENT, "available params: %d", params - 1);
                 for (j = 1; j < params; j++)
-                        gig_dbg(DEBUG_TRANSCMD, "param %d: %s", j, argv[j]);
+                        gig_dbg(DEBUG_EVENT, "param %d: %s", j, argv[j]);
         }
 
         spin_lock_irqsave(&cs->ev_lock, flags);
@@ -642,7 +641,7 @@ void gigaset_handle_modem_response(struct cardstate *cs)
                                         dev_err(cs->dev, "out of memory\n");
                                 ++curarg;
                         }
-                        gig_dbg(DEBUG_CMD, "string==%s",
+                        gig_dbg(DEBUG_EVENT, "string==%s",
                                 event->ptr ? (char *) event->ptr : "NULL");
                         break;
                 case RT_ZCAU:
@@ -669,7 +668,7 @@ void gigaset_handle_modem_response(struct cardstate *cs)
                                 ++curarg;
                         } else
                                 event->parameter = -1;
-                        gig_dbg(DEBUG_CMD, "parameter==%d", event->parameter);
+                        gig_dbg(DEBUG_EVENT, "parameter==%d", event->parameter);
                         break;
                 }
 
@@ -684,7 +683,7 @@ void gigaset_handle_modem_response(struct cardstate *cs)
         spin_unlock_irqrestore(&cs->ev_lock, flags);
 
         if (curarg != params)
-                gig_dbg(DEBUG_ANY,
+                gig_dbg(DEBUG_EVENT,
                         "invalid number of processed parameters: %d/%d",
                         curarg, params);
 }
@@ -705,8 +704,8 @@ static void disconnect(struct at_state_t **at_state_p)
         /* revert to selected idle mode */
         if (!cs->cidmode) {
                 cs->at_state.pending_commands |= PC_UMMODE;
+                gig_dbg(DEBUG_EVENT, "Scheduling PC_UMMODE");
                 cs->commands_pending = 1;
-                gig_dbg(DEBUG_CMD, "Scheduling PC_UMMODE");
         }
         spin_unlock_irqrestore(&cs->lock, flags);
 
@@ -784,15 +783,15 @@ static void init_failed(struct cardstate *cs, int mode)
 static void schedule_init(struct cardstate *cs, int state)
 {
         if (cs->at_state.pending_commands & PC_INIT) {
-                gig_dbg(DEBUG_CMD, "not scheduling PC_INIT again");
+                gig_dbg(DEBUG_EVENT, "not scheduling PC_INIT again");
                 return;
         }
         cs->mstate = state;
         cs->mode = M_UNKNOWN;
         gigaset_block_channels(cs);
         cs->at_state.pending_commands |= PC_INIT;
+        gig_dbg(DEBUG_EVENT, "Scheduling PC_INIT");
         cs->commands_pending = 1;
-        gig_dbg(DEBUG_CMD, "Scheduling PC_INIT");
 }
 
 /* Add "AT" to a command, add the cid, dle encode it, send the result to the
@@ -923,7 +922,7 @@ static void start_dial(struct at_state_t *at_state, void *data,
         }
 
         at_state->pending_commands |= PC_CID;
-        gig_dbg(DEBUG_CMD, "Scheduling PC_CID");
+        gig_dbg(DEBUG_EVENT, "Scheduling PC_CID");
         cs->commands_pending = 1;
         return;
 
@@ -933,7 +932,7 @@ error:
                 commands[i] = NULL;
         }
         at_state->pending_commands |= PC_NOCID;
-        gig_dbg(DEBUG_CMD, "Scheduling PC_NOCID");
+        gig_dbg(DEBUG_EVENT, "Scheduling PC_NOCID");
         cs->commands_pending = 1;
         return;
 }
@@ -955,7 +954,7 @@ static void start_accept(struct at_state_t *at_state)
                 dev_err(at_state->cs->dev, "out of memory\n");
                 /* error reset */
                 at_state->pending_commands |= PC_HUP;
-                gig_dbg(DEBUG_CMD, "Scheduling PC_HUP");
+                gig_dbg(DEBUG_EVENT, "Scheduling PC_HUP");
                 cs->commands_pending = 1;
                 return;
         }
@@ -964,7 +963,7 @@ static void start_accept(struct at_state_t *at_state)
         snprintf(bcs->commands[AT_ISO], 9, "^SISO=%u\r", bcs->channel + 1);
 
         at_state->pending_commands |= PC_ACCEPT;
-        gig_dbg(DEBUG_CMD, "Scheduling PC_ACCEPT");
+        gig_dbg(DEBUG_EVENT, "Scheduling PC_ACCEPT");
         cs->commands_pending = 1;
 }
 
@@ -1009,8 +1008,8 @@ static void do_shutdown(struct cardstate *cs)
         if (cs->mstate == MS_READY) {
                 cs->mstate = MS_SHUTDOWN;
                 cs->at_state.pending_commands |= PC_SHUTDOWN;
+                gig_dbg(DEBUG_EVENT, "Scheduling PC_SHUTDOWN");
                 cs->commands_pending = 1;
-                gig_dbg(DEBUG_CMD, "Scheduling PC_SHUTDOWN");
         } else
                 finish_shutdown(cs);
 }
@@ -1191,8 +1190,8 @@ static void do_action(int action, struct cardstate *cs,
                 }
                 spin_unlock_irqrestore(&cs->lock, flags);
                 cs->at_state.pending_commands |= PC_CIDMODE;
+                gig_dbg(DEBUG_EVENT, "Scheduling PC_CIDMODE");
                 cs->commands_pending = 1;
-                gig_dbg(DEBUG_CMD, "Scheduling PC_CIDMODE");
                 break;
         case ACT_FAILINIT:
                 dev_warn(cs->dev, "Could not initialize the device.\n");
@@ -1443,7 +1442,7 @@ static void do_action(int action, struct cardstate *cs,
         case ACT_GOTVER:
                 if (cs->gotfwver == 0) {
                         cs->gotfwver = 1;
-                        gig_dbg(DEBUG_ANY,
+                        gig_dbg(DEBUG_EVENT,
                                 "firmware version %02d.%03d.%02d.%02d",
                                 cs->fwver[0], cs->fwver[1],
                                 cs->fwver[2], cs->fwver[3]);
@@ -1481,8 +1480,8 @@ static void do_action(int action, struct cardstate *cs,
                 break;
         case ACT_HUP:
                 at_state->pending_commands |= PC_HUP;
+                gig_dbg(DEBUG_EVENT, "Scheduling PC_HUP");
                 cs->commands_pending = 1;
-                gig_dbg(DEBUG_CMD, "Scheduling PC_HUP");
                 break;
 
         /* hotplug events */
@@ -1519,10 +1518,10 @@ static void do_action(int action, struct cardstate *cs,
                         cs->cidmode = ev->parameter;
                         if (ev->parameter) {
                                 cs->at_state.pending_commands |= PC_CIDMODE;
-                                gig_dbg(DEBUG_CMD, "Scheduling PC_CIDMODE");
+                                gig_dbg(DEBUG_EVENT, "Scheduling PC_CIDMODE");
                         } else {
                                 cs->at_state.pending_commands |= PC_UMMODE;
-                                gig_dbg(DEBUG_CMD, "Scheduling PC_UMMODE");
+                                gig_dbg(DEBUG_EVENT, "Scheduling PC_UMMODE");
                         }
                         cs->commands_pending = 1;
                 }
@@ -1573,6 +1572,8 @@ static void process_event(struct cardstate *cs, struct event_t *ev)
         if (ev->cid >= 0) {
                 at_state = at_state_from_cid(cs, ev->cid);
                 if (!at_state) {
+                        gig_dbg(DEBUG_EVENT, "event %d for invalid cid %d",
+                                ev->type, ev->cid);
                         gigaset_add_event(cs, &cs->at_state, RSP_WRONG_CID,
                                           NULL, 0, NULL);
                         return;
@@ -1580,13 +1581,13 @@ static void process_event(struct cardstate *cs, struct event_t *ev)
         } else {
                 at_state = ev->at_state;
                 if (at_state_invalid(cs, at_state)) {
-                        gig_dbg(DEBUG_ANY, "event for invalid at_state %p",
+                        gig_dbg(DEBUG_EVENT, "event for invalid at_state %p",
                                 at_state);
                         return;
                 }
         }
 
-        gig_dbg(DEBUG_CMD, "connection state %d, event %d",
+        gig_dbg(DEBUG_EVENT, "connection state %d, event %d",
                 at_state->ConState, ev->type);
 
         bcs = at_state->bcs;
@@ -1600,11 +1601,11 @@ static void process_event(struct cardstate *cs, struct event_t *ev)
                 if (ev->parameter != at_state->timer_index
                     || !at_state->timer_active) {
                         ev->type = RSP_NONE; /* old timeout */
-                        gig_dbg(DEBUG_ANY, "old timeout");
+                        gig_dbg(DEBUG_EVENT, "old timeout");
                 } else if (!at_state->waiting)
-                        gig_dbg(DEBUG_ANY, "timeout occurred");
+                        gig_dbg(DEBUG_EVENT, "timeout occurred");
                 else
-                        gig_dbg(DEBUG_ANY, "stopped waiting");
+                        gig_dbg(DEBUG_EVENT, "stopped waiting");
         }
         spin_unlock_irqrestore(&cs->lock, flags);
 
@@ -1712,11 +1713,11 @@ static void process_command_flags(struct cardstate *cs)
         cs->commands_pending = 0;
 
         if (cs->cur_at_seq) {
-                gig_dbg(DEBUG_CMD, "not searching scheduled commands: busy");
+                gig_dbg(DEBUG_EVENT, "not searching scheduled commands: busy");
                 return;
         }
 
-        gig_dbg(DEBUG_CMD, "searching scheduled commands");
+        gig_dbg(DEBUG_EVENT, "searching scheduled commands");
 
         sequence = SEQ_NONE;
 
@@ -1857,7 +1858,7 @@ static void process_command_flags(struct cardstate *cs)
                         switch (cs->mode) {
                         case M_UNIMODEM:
                                 cs->at_state.pending_commands |= PC_CIDMODE;
-                                gig_dbg(DEBUG_CMD, "Scheduling PC_CIDMODE");
+                                gig_dbg(DEBUG_EVENT, "Scheduling PC_CIDMODE");
                                 cs->commands_pending = 1;
                                 return;
 #ifdef GIG_MAYINITONDIAL
diff --git a/drivers/isdn/gigaset/gigaset.h b/drivers/isdn/gigaset/gigaset.h
index e963a6c2e86d..1875ab80b335 100644
--- a/drivers/isdn/gigaset/gigaset.h
+++ b/drivers/isdn/gigaset/gigaset.h
@@ -38,7 +38,7 @@
 #define GIG_COMPAT  {0, 4, 0, 0}
 
 #define MAX_REC_PARAMS 10       /* Max. number of params in response string */
-#define MAX_RESP_SIZE 512       /* Max. size of a response string */
+#define MAX_RESP_SIZE 511       /* Max. size of a response string */
 
 #define MAX_EVENTS 64           /* size of event queue */
 
@@ -78,9 +78,10 @@ enum debuglevel {
         DEBUG_STREAM      = 0x00040, /* application data stream I/O events */
         DEBUG_STREAM_DUMP = 0x00080, /* application data stream content */
         DEBUG_LLDATA      = 0x00100, /* sent/received LL data */
+        DEBUG_EVENT       = 0x00200, /* event processing */
         DEBUG_DRIVER      = 0x00400, /* driver structure */
         DEBUG_HDLC        = 0x00800, /* M10x HDLC processing */
-        DEBUG_WRITE       = 0x01000, /* M105 data write */
+        DEBUG_CHANNEL     = 0x01000, /* channel allocation/deallocation */
         DEBUG_TRANSCMD    = 0x02000, /* AT-COMMANDS+RESPONSES */
         DEBUG_MCMD        = 0x04000, /* COMMANDS THAT ARE SENT VERY OFTEN */
         DEBUG_INIT        = 0x08000, /* (de)allocation+initialization of data
@@ -498,7 +499,7 @@ struct cardstate {
         spinlock_t ev_lock;
 
         /* current modem response */
-        unsigned char respdata[MAX_RESP_SIZE];
+        unsigned char respdata[MAX_RESP_SIZE+1];
         unsigned cbytes;
 
         /* private data of hardware drivers */
@@ -785,8 +786,6 @@ static inline void gigaset_schedule_event(struct cardstate *cs)
 static inline void gigaset_bchannel_down(struct bc_state *bcs)
 {
         gigaset_add_event(bcs->cs, &bcs->at_state, EV_BC_CLOSED, NULL, 0, NULL);
-
-        gig_dbg(DEBUG_CMD, "scheduling BC_CLOSED");
         gigaset_schedule_event(bcs->cs);
 }
 
@@ -795,8 +794,6 @@ static inline void gigaset_bchannel_down(struct bc_state *bcs)
 static inline void gigaset_bchannel_up(struct bc_state *bcs)
 {
         gigaset_add_event(bcs->cs, &bcs->at_state, EV_BC_OPEN, NULL, 0, NULL);
-
-        gig_dbg(DEBUG_CMD, "scheduling BC_OPEN");
         gigaset_schedule_event(bcs->cs);
 }
 
diff --git a/drivers/isdn/gigaset/i4l.c b/drivers/isdn/gigaset/i4l.c
index c129ee47a8fb..f0acb9dc9e33 100644
--- a/drivers/isdn/gigaset/i4l.c
+++ b/drivers/isdn/gigaset/i4l.c
@@ -216,7 +216,7 @@ static int command_from_LL(isdn_ctrl *cntrl)
                 return -EINVAL;
 
         case ISDN_CMD_DIAL:
-                gig_dbg(DEBUG_ANY,
+                gig_dbg(DEBUG_CMD,
                         "ISDN_CMD_DIAL (phone: %s, msn: %s, si1: %d, si2: %d)",
                         cntrl->parm.setup.phone, cntrl->parm.setup.eazmsn,
                         cntrl->parm.setup.si1, cntrl->parm.setup.si2);
@@ -304,11 +304,10 @@ static int command_from_LL(isdn_ctrl *cntrl)
                         gigaset_free_channel(bcs);
                         return -ENOMEM;
                 }
-
-                gig_dbg(DEBUG_CMD, "scheduling DIAL");
                 gigaset_schedule_event(cs);
                 break;
         case ISDN_CMD_ACCEPTD:
+                gig_dbg(DEBUG_CMD, "ISDN_CMD_ACCEPTD");
                 if (ch >= cs->channels) {
                         dev_err(cs->dev,
                                 "ISDN_CMD_ACCEPTD: invalid channel (%d)\n", ch);
@@ -318,14 +317,11 @@ static int command_from_LL(isdn_ctrl *cntrl)
                 if (!gigaset_add_event(cs, &bcs->at_state,
                                        EV_ACCEPT, NULL, 0, NULL))
                         return -ENOMEM;
-
-                gig_dbg(DEBUG_CMD, "scheduling ACCEPT");
                 gigaset_schedule_event(cs);
 
                 break;
-        case ISDN_CMD_ACCEPTB:
-                break;
         case ISDN_CMD_HANGUP:
+                gig_dbg(DEBUG_CMD, "ISDN_CMD_HANGUP");
                 if (ch >= cs->channels) {
                         dev_err(cs->dev,
                                 "ISDN_CMD_HANGUP: invalid channel (%d)\n", ch);
@@ -335,8 +331,6 @@ static int command_from_LL(isdn_ctrl *cntrl)
                 if (!gigaset_add_event(cs, &bcs->at_state,
                                        EV_HUP, NULL, 0, NULL))
                         return -ENOMEM;
-
-                gig_dbg(DEBUG_CMD, "scheduling HUP");
                 gigaset_schedule_event(cs);
 
                 break;
@@ -376,6 +370,7 @@ static int command_from_LL(isdn_ctrl *cntrl)
                 }
                 break;
         case ISDN_CMD_SETL3: /* Set L3 to given protocol */
+                gig_dbg(DEBUG_CMD, "ISDN_CMD_SETL3");
                 if (ch >= cs->channels) {
                         dev_err(cs->dev,
                                 "ISDN_CMD_SETL3: invalid channel (%d)\n", ch);
@@ -390,44 +385,9 @@ static int command_from_LL(isdn_ctrl *cntrl)
                 }
 
                 break;
-        case ISDN_CMD_PROCEED:
-                gig_dbg(DEBUG_ANY, "ISDN_CMD_PROCEED");
-                break;
-        case ISDN_CMD_ALERT:
-                gig_dbg(DEBUG_ANY, "ISDN_CMD_ALERT");
-                if (cntrl->arg >= cs->channels) {
-                        dev_err(cs->dev,
-                                "ISDN_CMD_ALERT: invalid channel (%d)\n",
-                                (int) cntrl->arg);
-                        return -EINVAL;
-                }
-                break;
-        case ISDN_CMD_REDIR:
-                gig_dbg(DEBUG_ANY, "ISDN_CMD_REDIR");
-                break;
-        case ISDN_CMD_PROT_IO:
-                gig_dbg(DEBUG_ANY, "ISDN_CMD_PROT_IO");
-                break;
-        case ISDN_CMD_FAXCMD:
-                gig_dbg(DEBUG_ANY, "ISDN_CMD_FAXCMD");
-                break;
-        case ISDN_CMD_GETL2:
-                gig_dbg(DEBUG_ANY, "ISDN_CMD_GETL2");
-                break;
-        case ISDN_CMD_GETL3:
-                gig_dbg(DEBUG_ANY, "ISDN_CMD_GETL3");
-                break;
-        case ISDN_CMD_GETEAZ:
-                gig_dbg(DEBUG_ANY, "ISDN_CMD_GETEAZ");
-                break;
-        case ISDN_CMD_SETSIL:
-                gig_dbg(DEBUG_ANY, "ISDN_CMD_SETSIL");
-                break;
-        case ISDN_CMD_GETSIL:
-                gig_dbg(DEBUG_ANY, "ISDN_CMD_GETSIL");
-                break;
+
         default:
-                dev_err(cs->dev, "unknown command %d from LL\n",
+                gig_dbg(DEBUG_CMD, "unknown command %d from LL",
                         cntrl->command);
                 return -EINVAL;
         }
diff --git a/drivers/isdn/gigaset/interface.c b/drivers/isdn/gigaset/interface.c
index d2260b0055fc..a1bcbc21ff71 100644
--- a/drivers/isdn/gigaset/interface.c
+++ b/drivers/isdn/gigaset/interface.c
@@ -45,8 +45,6 @@ static int if_lock(struct cardstate *cs, int *arg)
                 cs->waiting = 0;
                 return -ENOMEM;
         }
-
-        gig_dbg(DEBUG_CMD, "scheduling IF_LOCK");
         gigaset_schedule_event(cs);
 
         wait_event(cs->waitqueue, !cs->waiting);
@@ -81,8 +79,6 @@ static int if_version(struct cardstate *cs, unsigned arg[4])
                         cs->waiting = 0;
                         return -ENOMEM;
                 }
-
-                gig_dbg(DEBUG_CMD, "scheduling IF_VER");
                 gigaset_schedule_event(cs);
 
                 wait_event(cs->waitqueue, !cs->waiting);
@@ -274,7 +270,7 @@ static int if_ioctl(struct tty_struct *tty, struct file *file,
                                         ? -EFAULT : 0;
                         break;
                 default:
-                        gig_dbg(DEBUG_ANY, "%s: arg not supported - 0x%04x",
+                        gig_dbg(DEBUG_IF, "%s: arg not supported - 0x%04x",
                                 __func__, cmd);
                         retval = -ENOIOCTLCMD;
                 }
@@ -455,7 +451,7 @@ static void if_throttle(struct tty_struct *tty)
         else if (!cs->open_count)
                 dev_warn(cs->dev, "%s: device not opened\n", __func__);
         else
-                gig_dbg(DEBUG_ANY, "%s: not implemented\n", __func__);
+                gig_dbg(DEBUG_IF, "%s: not implemented\n", __func__);
 
         mutex_unlock(&cs->mutex);
 }
@@ -479,7 +475,7 @@ static void if_unthrottle(struct tty_struct *tty)
         else if (!cs->open_count)
                 dev_warn(cs->dev, "%s: device not opened\n", __func__);
         else
-                gig_dbg(DEBUG_ANY, "%s: not implemented\n", __func__);
+                gig_dbg(DEBUG_IF, "%s: not implemented\n", __func__);
 
         mutex_unlock(&cs->mutex);
 }
@@ -630,7 +626,7 @@ void gigaset_if_receive(struct cardstate *cs,
         spin_lock_irqsave(&cs->lock, flags);
         tty = cs->tty;
         if (tty == NULL)
-                gig_dbg(DEBUG_ANY, "receive on closed device");
+                gig_dbg(DEBUG_IF, "receive on closed device");
         else {
                 tty_buffer_request_room(tty, len);
                 tty_insert_flip_string(tty, buffer, len);
diff --git a/drivers/isdn/gigaset/isocdata.c b/drivers/isdn/gigaset/isocdata.c
index 85394a6ebae8..16fd3bd48883 100644
--- a/drivers/isdn/gigaset/isocdata.c
+++ b/drivers/isdn/gigaset/isocdata.c
@@ -905,29 +905,49 @@ void gigaset_isoc_receive(unsigned char *src, unsigned count,
 
 /* == data input =========================================================== */
 
+/* process a block of received bytes in command mode (mstate != MS_LOCKED)
+ * Append received bytes to the command response buffer and forward them
+ * line by line to the response handler.
+ * Note: Received lines may be terminated by CR, LF, or CR LF, which will be
+ * removed before passing the line to the response handler.
+ */
 static void cmd_loop(unsigned char *src, int numbytes, struct inbuf_t *inbuf)
 {
         struct cardstate *cs = inbuf->cs;
         unsigned cbytes      = cs->cbytes;
+        unsigned char c;
 
         while (numbytes--) {
-                /* copy next character, check for end of line */
-                switch (cs->respdata[cbytes] = *src++) {
-                case '\r':
+                c = *src++;
+                switch (c) {
                 case '\n':
-                        /* end of line */
-                        gig_dbg(DEBUG_TRANSCMD, "%s: End of Command (%d Bytes)",
-                                __func__, cbytes);
-                        if (cbytes >= MAX_RESP_SIZE - 1)
-                                dev_warn(cs->dev, "response too large\n");
+                        if (cbytes == 0 && cs->respdata[0] == '\r') {
+                                /* collapse LF with preceding CR */
+                                cs->respdata[0] = 0;
+                                break;
+                        }
+                        /* --v-- fall through --v-- */
+                case '\r':
+                        /* end of message line, pass to response handler */
+                        if (cbytes >= MAX_RESP_SIZE) {
+                                dev_warn(cs->dev, "response too large (%d)\n",
+                                         cbytes);
+                                cbytes = MAX_RESP_SIZE;
+                        }
                         cs->cbytes = cbytes;
+                        gigaset_dbg_buffer(DEBUG_TRANSCMD, "received response",
+                                           cbytes, cs->respdata);
                         gigaset_handle_modem_response(cs);
                         cbytes = 0;
+
+                        /* store EOL byte for CRLF collapsing */
+                        cs->respdata[0] = c;
                         break;
                 default:
-                        /* advance in line buffer, checking for overflow */
-                        if (cbytes < MAX_RESP_SIZE - 1)
-                                cbytes++;
+                        /* append to line buffer if possible */
+                        if (cbytes < MAX_RESP_SIZE)
+                                cs->respdata[cbytes] = c;
+                        cbytes++;
                 }
         }
 
@@ -958,8 +978,6 @@ void gigaset_isoc_input(struct inbuf_t *inbuf)
                                            numbytes, src);
                         gigaset_if_receive(inbuf->cs, src, numbytes);
                 } else {
-                        gigaset_dbg_buffer(DEBUG_CMD, "received response",
-                                           numbytes, src);
                         cmd_loop(src, numbytes, inbuf);
                 }
 
diff --git a/drivers/isdn/gigaset/proc.c b/drivers/isdn/gigaset/proc.c
index 758a00c1d2e2..b69f73a0668f 100644
--- a/drivers/isdn/gigaset/proc.c
+++ b/drivers/isdn/gigaset/proc.c
@@ -48,8 +48,6 @@ static ssize_t set_cidmode(struct device *dev, struct device_attribute *attr,
                 mutex_unlock(&cs->mutex);
                 return -ENOMEM;
         }
-
-        gig_dbg(DEBUG_CMD, "scheduling PROC_CIDMODE");
         gigaset_schedule_event(cs);
 
         wait_event(cs->waitqueue, !cs->waiting);
diff --git a/drivers/isdn/gigaset/usb-gigaset.c b/drivers/isdn/gigaset/usb-gigaset.c
index 3ab1daeb276b..9430a2bbb523 100644
--- a/drivers/isdn/gigaset/usb-gigaset.c
+++ b/drivers/isdn/gigaset/usb-gigaset.c
@@ -628,7 +628,7 @@ static int write_modem(struct cardstate *cs)
         struct usb_cardstate *ucs = cs->hw.usb;
         unsigned long flags;
 
-        gig_dbg(DEBUG_WRITE, "len: %d...", bcs->tx_skb->len);
+        gig_dbg(DEBUG_OUTPUT, "len: %d...", bcs->tx_skb->len);
 
         if (!bcs->tx_skb->len) {
                 dev_kfree_skb_any(bcs->tx_skb);
diff --git a/drivers/isdn/hardware/avm/avmcard.h b/drivers/isdn/hardware/avm/avmcard.h
index d964f07e4a56..a70e8854461d 100644
--- a/drivers/isdn/hardware/avm/avmcard.h
+++ b/drivers/isdn/hardware/avm/avmcard.h
@@ -556,8 +556,7 @@ u16  b1_send_message(struct capi_ctr *ctrl, struct sk_buff *skb);
 void b1_parse_version(avmctrl_info *card);
 irqreturn_t b1_interrupt(int interrupt, void *devptr);
 
-int b1ctl_read_proc(char *page, char **start, off_t off,
-                        int count, int *eof, struct capi_ctr *ctrl);
+extern const struct file_operations b1ctl_proc_fops;
 
 avmcard_dmainfo *avmcard_dma_alloc(char *name, struct pci_dev *,
                                    long rsize, long ssize);
@@ -577,7 +576,6 @@ void b1dma_register_appl(struct capi_ctr *ctrl,
                                 capi_register_params *rp);
 void b1dma_release_appl(struct capi_ctr *ctrl, u16 appl);
 u16  b1dma_send_message(struct capi_ctr *ctrl, struct sk_buff *skb);
-int b1dmactl_read_proc(char *page, char **start, off_t off,
-                        int count, int *eof, struct capi_ctr *ctrl);
+extern const struct file_operations b1dmactl_proc_fops;
 
 #endif /* _AVMCARD_H_ */
diff --git a/drivers/isdn/hardware/avm/b1.c b/drivers/isdn/hardware/avm/b1.c
index a7c0083e78a7..c38fa0f4c729 100644
--- a/drivers/isdn/hardware/avm/b1.c
+++ b/drivers/isdn/hardware/avm/b1.c
@@ -12,6 +12,8 @@
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/pci.h>
+#include <linux/proc_fs.h>
+#include <linux/seq_file.h>
 #include <linux/skbuff.h>
 #include <linux/delay.h>
 #include <linux/mm.h>
@@ -634,18 +636,17 @@ irqreturn_t b1_interrupt(int interrupt, void *devptr)
 }
 
 /* ------------------------------------------------------------- */
-int b1ctl_read_proc(char *page, char **start, off_t off,
-                        int count, int *eof, struct capi_ctr *ctrl)
+static int b1ctl_proc_show(struct seq_file *m, void *v)
 {
+        struct capi_ctr *ctrl = m->private;
         avmctrl_info *cinfo = (avmctrl_info *)(ctrl->driverdata);
         avmcard *card = cinfo->card;
         u8 flag;
-        int len = 0;
         char *s;
 
-        len += sprintf(page+len, "%-16s %s\n", "name", card->name);
-        len += sprintf(page+len, "%-16s 0x%x\n", "io", card->port);
-        len += sprintf(page+len, "%-16s %d\n", "irq", card->irq);
+        seq_printf(m, "%-16s %s\n", "name", card->name);
+        seq_printf(m, "%-16s 0x%x\n", "io", card->port);
+        seq_printf(m, "%-16s %d\n", "irq", card->irq);
         switch (card->cardtype) {
         case avm_b1isa: s = "B1 ISA"; break;
         case avm_b1pci: s = "B1 PCI"; break;
@@ -658,20 +659,20 @@ int b1ctl_read_proc(char *page, char **start, off_t off,
         case avm_c2: s = "C2"; break;
         default: s = "???"; break;
         }
-        len += sprintf(page+len, "%-16s %s\n", "type", s);
+        seq_printf(m, "%-16s %s\n", "type", s);
         if (card->cardtype == avm_t1isa)
-           len += sprintf(page+len, "%-16s %d\n", "cardnr", card->cardnr);
+                seq_printf(m, "%-16s %d\n", "cardnr", card->cardnr);
         if ((s = cinfo->version[VER_DRIVER]) != NULL)
-           len += sprintf(page+len, "%-16s %s\n", "ver_driver", s);
+                seq_printf(m, "%-16s %s\n", "ver_driver", s);
         if ((s = cinfo->version[VER_CARDTYPE]) != NULL)
-           len += sprintf(page+len, "%-16s %s\n", "ver_cardtype", s);
+                seq_printf(m, "%-16s %s\n", "ver_cardtype", s);
         if ((s = cinfo->version[VER_SERIAL]) != NULL)
-           len += sprintf(page+len, "%-16s %s\n", "ver_serial", s);
+                seq_printf(m, "%-16s %s\n", "ver_serial", s);
 
         if (card->cardtype != avm_m1) {
                 flag = ((u8 *)(ctrl->profile.manu))[3];
                 if (flag)
-                        len += sprintf(page+len, "%-16s%s%s%s%s%s%s%s\n",
+                        seq_printf(m, "%-16s%s%s%s%s%s%s%s\n",
                         "protocol",
                         (flag & 0x01) ? " DSS1" : "",
                         (flag & 0x02) ? " CT1" : "",
@@ -685,7 +686,7 @@ int b1ctl_read_proc(char *page, char **start, off_t off,
         if (card->cardtype != avm_m1) {
                 flag = ((u8 *)(ctrl->profile.manu))[5];
                 if (flag)
-                        len += sprintf(page+len, "%-16s%s%s%s%s\n",
+                        seq_printf(m, "%-16s%s%s%s%s\n",
                         "linetype",
                         (flag & 0x01) ? " point to point" : "",
                         (flag & 0x02) ? " point to multipoint" : "",
@@ -693,16 +694,25 @@ int b1ctl_read_proc(char *page, char **start, off_t off,
                         (flag & 0x04) ? " leased line with D-channel" : ""
                         );
         }
-        len += sprintf(page+len, "%-16s %s\n", "cardname", cinfo->cardname);
-
-        if (off+count >= len)
-           *eof = 1;
-        if (len < off)
-           return 0;
-        *start = page + off;
-        return ((count < len-off) ? count : len-off);
+        seq_printf(m, "%-16s %s\n", "cardname", cinfo->cardname);
+
+        return 0;
+}
+
+static int b1ctl_proc_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, b1ctl_proc_show, PDE(inode)->data);
 }
 
+const struct file_operations b1ctl_proc_fops = {
+        .owner          = THIS_MODULE,
+        .open           = b1ctl_proc_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
+EXPORT_SYMBOL(b1ctl_proc_fops);
+
 /* ------------------------------------------------------------- */
 
 #ifdef CONFIG_PCI
@@ -781,8 +791,6 @@ EXPORT_SYMBOL(b1_send_message);
 EXPORT_SYMBOL(b1_parse_version);
 EXPORT_SYMBOL(b1_interrupt);
 
-EXPORT_SYMBOL(b1ctl_read_proc);
-
 static int __init b1_init(void)
 {
         char *p;
diff --git a/drivers/isdn/hardware/avm/b1dma.c b/drivers/isdn/hardware/avm/b1dma.c
index 0e84aaae43fd..124550d0dbf3 100644
--- a/drivers/isdn/hardware/avm/b1dma.c
+++ b/drivers/isdn/hardware/avm/b1dma.c
@@ -11,6 +11,8 @@
 
 #include <linux/module.h>
 #include <linux/kernel.h>
+#include <linux/proc_fs.h>
+#include <linux/seq_file.h>
 #include <linux/skbuff.h>
 #include <linux/delay.h>
 #include <linux/mm.h>
@@ -855,21 +857,20 @@ u16 b1dma_send_message(struct capi_ctr *ctrl, struct sk_buff *skb)
 
 /* ------------------------------------------------------------- */
 
-int b1dmactl_read_proc(char *page, char **start, off_t off,
-                        int count, int *eof, struct capi_ctr *ctrl)
+static int b1dmactl_proc_show(struct seq_file *m, void *v)
 {
+        struct capi_ctr *ctrl = m->private;
         avmctrl_info *cinfo = (avmctrl_info *)(ctrl->driverdata);
         avmcard *card = cinfo->card;
         u8 flag;
-        int len = 0;
         char *s;
         u32 txoff, txlen, rxoff, rxlen, csr;
         unsigned long flags;
 
-        len += sprintf(page+len, "%-16s %s\n", "name", card->name);
-        len += sprintf(page+len, "%-16s 0x%x\n", "io", card->port);
-        len += sprintf(page+len, "%-16s %d\n", "irq", card->irq);
-        len += sprintf(page+len, "%-16s 0x%lx\n", "membase", card->membase);
+        seq_printf(m, "%-16s %s\n", "name", card->name);
+        seq_printf(m, "%-16s 0x%x\n", "io", card->port);
+        seq_printf(m, "%-16s %d\n", "irq", card->irq);
+        seq_printf(m, "%-16s 0x%lx\n", "membase", card->membase);
         switch (card->cardtype) {
         case avm_b1isa: s = "B1 ISA"; break;
         case avm_b1pci: s = "B1 PCI"; break;
@@ -882,18 +883,18 @@ int b1dmactl_read_proc(char *page, char **start, off_t off,
         case avm_c2: s = "C2"; break;
         default: s = "???"; break;
         }
-        len += sprintf(page+len, "%-16s %s\n", "type", s);
+        seq_printf(m, "%-16s %s\n", "type", s);
         if ((s = cinfo->version[VER_DRIVER]) != NULL)
-           len += sprintf(page+len, "%-16s %s\n", "ver_driver", s);
+                seq_printf(m, "%-16s %s\n", "ver_driver", s);
         if ((s = cinfo->version[VER_CARDTYPE]) != NULL)
-           len += sprintf(page+len, "%-16s %s\n", "ver_cardtype", s);
+                seq_printf(m, "%-16s %s\n", "ver_cardtype", s);
         if ((s = cinfo->version[VER_SERIAL]) != NULL)
-           len += sprintf(page+len, "%-16s %s\n", "ver_serial", s);
+                seq_printf(m, "%-16s %s\n", "ver_serial", s);
 
         if (card->cardtype != avm_m1) {
                 flag = ((u8 *)(ctrl->profile.manu))[3];
                 if (flag)
-                        len += sprintf(page+len, "%-16s%s%s%s%s%s%s%s\n",
+                        seq_printf(m, "%-16s%s%s%s%s%s%s%s\n",
                         "protocol",
                         (flag & 0x01) ? " DSS1" : "",
                         (flag & 0x02) ? " CT1" : "",
@@ -907,7 +908,7 @@ int b1dmactl_read_proc(char *page, char **start, off_t off,
         if (card->cardtype != avm_m1) {
                 flag = ((u8 *)(ctrl->profile.manu))[5];
                 if (flag)
-                        len += sprintf(page+len, "%-16s%s%s%s%s\n",
+                        seq_printf(m, "%-16s%s%s%s%s\n",
                         "linetype",
                         (flag & 0x01) ? " point to point" : "",
                         (flag & 0x02) ? " point to multipoint" : "",
@@ -915,7 +916,7 @@ int b1dmactl_read_proc(char *page, char **start, off_t off,
                         (flag & 0x04) ? " leased line with D-channel" : ""
                         );
         }
-        len += sprintf(page+len, "%-16s %s\n", "cardname", cinfo->cardname);
+        seq_printf(m, "%-16s %s\n", "cardname", cinfo->cardname);
 
 
         spin_lock_irqsave(&card->lock, flags);
@@ -930,27 +931,30 @@ int b1dmactl_read_proc(char *page, char **start, off_t off,
 
         spin_unlock_irqrestore(&card->lock, flags);
 
-        len += sprintf(page+len, "%-16s 0x%lx\n",
-                                "csr (cached)", (unsigned long)card->csr);
-        len += sprintf(page+len, "%-16s 0x%lx\n",
-                                "csr", (unsigned long)csr);
-        len += sprintf(page+len, "%-16s %lu\n",
-                                "txoff", (unsigned long)txoff);
-        len += sprintf(page+len, "%-16s %lu\n",
-                                "txlen", (unsigned long)txlen);
-        len += sprintf(page+len, "%-16s %lu\n",
-                                "rxoff", (unsigned long)rxoff);
-        len += sprintf(page+len, "%-16s %lu\n",
-                                "rxlen", (unsigned long)rxlen);
-
-        if (off+count >= len)
-           *eof = 1;
-        if (len < off)
-           return 0;
-        *start = page + off;
-        return ((count < len-off) ? count : len-off);
+        seq_printf(m, "%-16s 0x%lx\n", "csr (cached)", (unsigned long)card->csr);
+        seq_printf(m, "%-16s 0x%lx\n", "csr", (unsigned long)csr);
+        seq_printf(m, "%-16s %lu\n", "txoff", (unsigned long)txoff);
+        seq_printf(m, "%-16s %lu\n", "txlen", (unsigned long)txlen);
+        seq_printf(m, "%-16s %lu\n", "rxoff", (unsigned long)rxoff);
+        seq_printf(m, "%-16s %lu\n", "rxlen", (unsigned long)rxlen);
+
+        return 0;
+}
+
+static int b1dmactl_proc_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, b1dmactl_proc_show, PDE(inode)->data);
 }
 
+const struct file_operations b1dmactl_proc_fops = {
+        .owner          = THIS_MODULE,
+        .open           = b1dmactl_proc_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
+EXPORT_SYMBOL(b1dmactl_proc_fops);
+
 /* ------------------------------------------------------------- */
 
 EXPORT_SYMBOL(b1dma_reset);
@@ -963,7 +967,6 @@ EXPORT_SYMBOL(b1dma_reset_ctr);
 EXPORT_SYMBOL(b1dma_register_appl);
 EXPORT_SYMBOL(b1dma_release_appl);
 EXPORT_SYMBOL(b1dma_send_message);
-EXPORT_SYMBOL(b1dmactl_read_proc);
 
 static int __init b1dma_init(void)
 {
diff --git a/drivers/isdn/hardware/avm/b1isa.c b/drivers/isdn/hardware/avm/b1isa.c
index 6461a32bc838..ff5390546f92 100644
--- a/drivers/isdn/hardware/avm/b1isa.c
+++ b/drivers/isdn/hardware/avm/b1isa.c
@@ -121,7 +121,7 @@ static int b1isa_probe(struct pci_dev *pdev)
         cinfo->capi_ctrl.load_firmware = b1_load_firmware;
         cinfo->capi_ctrl.reset_ctr     = b1_reset_ctr;
         cinfo->capi_ctrl.procinfo      = b1isa_procinfo;
-        cinfo->capi_ctrl.ctr_read_proc = b1ctl_read_proc;
+        cinfo->capi_ctrl.proc_fops = &b1ctl_proc_fops;
         strcpy(cinfo->capi_ctrl.name, card->name);
 
         retval = attach_capi_ctr(&cinfo->capi_ctrl);
diff --git a/drivers/isdn/hardware/avm/b1pci.c b/drivers/isdn/hardware/avm/b1pci.c
index 5b314a2c4049..c97e4315079d 100644
--- a/drivers/isdn/hardware/avm/b1pci.c
+++ b/drivers/isdn/hardware/avm/b1pci.c
@@ -112,7 +112,7 @@ static int b1pci_probe(struct capicardparams *p, struct pci_dev *pdev)
         cinfo->capi_ctrl.load_firmware = b1_load_firmware;
         cinfo->capi_ctrl.reset_ctr     = b1_reset_ctr;
         cinfo->capi_ctrl.procinfo      = b1pci_procinfo;
-        cinfo->capi_ctrl.ctr_read_proc = b1ctl_read_proc;
+        cinfo->capi_ctrl.proc_fops = &b1ctl_proc_fops;
         strcpy(cinfo->capi_ctrl.name, card->name);
         cinfo->capi_ctrl.owner         = THIS_MODULE;
 
@@ -251,7 +251,7 @@ static int b1pciv4_probe(struct capicardparams *p, struct pci_dev *pdev)
         cinfo->capi_ctrl.load_firmware = b1dma_load_firmware;
         cinfo->capi_ctrl.reset_ctr     = b1dma_reset_ctr;
         cinfo->capi_ctrl.procinfo      = b1pciv4_procinfo;
-        cinfo->capi_ctrl.ctr_read_proc = b1dmactl_read_proc;
+        cinfo->capi_ctrl.proc_fops = &b1dmactl_proc_fops;
         strcpy(cinfo->capi_ctrl.name, card->name);
 
         retval = attach_capi_ctr(&cinfo->capi_ctrl);
diff --git a/drivers/isdn/hardware/avm/b1pcmcia.c b/drivers/isdn/hardware/avm/b1pcmcia.c
index 7740403b40e1..d6391e0afeea 100644
--- a/drivers/isdn/hardware/avm/b1pcmcia.c
+++ b/drivers/isdn/hardware/avm/b1pcmcia.c
@@ -108,7 +108,7 @@ static int b1pcmcia_add_card(unsigned int port, unsigned irq,
         cinfo->capi_ctrl.load_firmware = b1_load_firmware;
         cinfo->capi_ctrl.reset_ctr     = b1_reset_ctr;
         cinfo->capi_ctrl.procinfo      = b1pcmcia_procinfo;
-        cinfo->capi_ctrl.ctr_read_proc = b1ctl_read_proc;
+        cinfo->capi_ctrl.proc_fops = &b1ctl_proc_fops;
         strcpy(cinfo->capi_ctrl.name, card->name);
 
         retval = attach_capi_ctr(&cinfo->capi_ctrl);
diff --git a/drivers/isdn/hardware/avm/c4.c b/drivers/isdn/hardware/avm/c4.c
index 6833301a45fc..de6e6b311819 100644
--- a/drivers/isdn/hardware/avm/c4.c
+++ b/drivers/isdn/hardware/avm/c4.c
@@ -11,6 +11,8 @@
 
 #include <linux/module.h>
 #include <linux/kernel.h>
+#include <linux/proc_fs.h>
+#include <linux/seq_file.h>
 #include <linux/skbuff.h>
 #include <linux/delay.h>
 #include <linux/mm.h>
@@ -1062,19 +1064,18 @@ static char *c4_procinfo(struct capi_ctr *ctrl)
         return cinfo->infobuf;
 }
 
-static int c4_read_proc(char *page, char **start, off_t off,
-                        int count, int *eof, struct capi_ctr *ctrl)
+static int c4_proc_show(struct seq_file *m, void *v)
 {
+        struct capi_ctr *ctrl = m->private;
         avmctrl_info *cinfo = (avmctrl_info *)(ctrl->driverdata);
         avmcard *card = cinfo->card;
         u8 flag;
-        int len = 0;
         char *s;
 
-        len += sprintf(page+len, "%-16s %s\n", "name", card->name);
-        len += sprintf(page+len, "%-16s 0x%x\n", "io", card->port);
-        len += sprintf(page+len, "%-16s %d\n", "irq", card->irq);
-        len += sprintf(page+len, "%-16s 0x%lx\n", "membase", card->membase);
+        seq_printf(m, "%-16s %s\n", "name", card->name);
+        seq_printf(m, "%-16s 0x%x\n", "io", card->port);
+        seq_printf(m, "%-16s %d\n", "irq", card->irq);
+        seq_printf(m, "%-16s 0x%lx\n", "membase", card->membase);
         switch (card->cardtype) {
         case avm_b1isa: s = "B1 ISA"; break;
         case avm_b1pci: s = "B1 PCI"; break;
@@ -1087,18 +1088,18 @@ static int c4_read_proc(char *page, char **start, off_t off,
         case avm_c2: s = "C2"; break;
         default: s = "???"; break;
         }
-        len += sprintf(page+len, "%-16s %s\n", "type", s);
+        seq_printf(m, "%-16s %s\n", "type", s);
         if ((s = cinfo->version[VER_DRIVER]) != NULL)
-           len += sprintf(page+len, "%-16s %s\n", "ver_driver", s);
+                seq_printf(m, "%-16s %s\n", "ver_driver", s);
         if ((s = cinfo->version[VER_CARDTYPE]) != NULL)
-           len += sprintf(page+len, "%-16s %s\n", "ver_cardtype", s);
+                seq_printf(m, "%-16s %s\n", "ver_cardtype", s);
         if ((s = cinfo->version[VER_SERIAL]) != NULL)
-           len += sprintf(page+len, "%-16s %s\n", "ver_serial", s);
+                seq_printf(m, "%-16s %s\n", "ver_serial", s);
 
         if (card->cardtype != avm_m1) {
                 flag = ((u8 *)(ctrl->profile.manu))[3];
                 if (flag)
-                        len += sprintf(page+len, "%-16s%s%s%s%s%s%s%s\n",
+                        seq_printf(m, "%-16s%s%s%s%s%s%s%s\n",
                         "protocol",
                         (flag & 0x01) ? " DSS1" : "",
                         (flag & 0x02) ? " CT1" : "",
@@ -1112,7 +1113,7 @@ static int c4_read_proc(char *page, char **start, off_t off,
         if (card->cardtype != avm_m1) {
                 flag = ((u8 *)(ctrl->profile.manu))[5];
                 if (flag)
-                        len += sprintf(page+len, "%-16s%s%s%s%s\n",
+                        seq_printf(m, "%-16s%s%s%s%s\n",
                         "linetype",
                         (flag & 0x01) ? " point to point" : "",
                         (flag & 0x02) ? " point to multipoint" : "",
@@ -1120,16 +1121,24 @@ static int c4_read_proc(char *page, char **start, off_t off,
                         (flag & 0x04) ? " leased line with D-channel" : ""
                         );
         }
-        len += sprintf(page+len, "%-16s %s\n", "cardname", cinfo->cardname);
-
-        if (off+count >= len)
-           *eof = 1;
-        if (len < off)
-           return 0;
-        *start = page + off;
-        return ((count < len-off) ? count : len-off);
+        seq_printf(m, "%-16s %s\n", "cardname", cinfo->cardname);
+
+        return 0;
 }
 
+static int c4_proc_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, c4_proc_show, PDE(inode)->data);
+}
+
+static const struct file_operations c4_proc_fops = {
+        .owner          = THIS_MODULE,
+        .open           = c4_proc_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
+
 /* ------------------------------------------------------------- */
 
 static int c4_add_card(struct capicardparams *p, struct pci_dev *dev,
@@ -1201,7 +1210,7 @@ static int c4_add_card(struct capicardparams *p, struct pci_dev *dev,
                 cinfo->capi_ctrl.load_firmware = c4_load_firmware;
                 cinfo->capi_ctrl.reset_ctr     = c4_reset_ctr;
                 cinfo->capi_ctrl.procinfo      = c4_procinfo;
-                cinfo->capi_ctrl.ctr_read_proc = c4_read_proc;
+                cinfo->capi_ctrl.proc_fops = &c4_proc_fops;
                 strcpy(cinfo->capi_ctrl.name, card->name);
 
                 retval = attach_capi_ctr(&cinfo->capi_ctrl);
diff --git a/drivers/isdn/hardware/avm/t1isa.c b/drivers/isdn/hardware/avm/t1isa.c
index 1c53fd49adb6..baeeb3c2a3ee 100644
--- a/drivers/isdn/hardware/avm/t1isa.c
+++ b/drivers/isdn/hardware/avm/t1isa.c
@@ -429,7 +429,7 @@ static int t1isa_probe(struct pci_dev *pdev, int cardnr)
         cinfo->capi_ctrl.load_firmware = t1isa_load_firmware;
         cinfo->capi_ctrl.reset_ctr     = t1isa_reset_ctr;
         cinfo->capi_ctrl.procinfo      = t1isa_procinfo;
-        cinfo->capi_ctrl.ctr_read_proc = b1ctl_read_proc;
+        cinfo->capi_ctrl.proc_fops = &b1ctl_proc_fops;
         strcpy(cinfo->capi_ctrl.name, card->name);
 
         retval = attach_capi_ctr(&cinfo->capi_ctrl);
diff --git a/drivers/isdn/hardware/avm/t1pci.c b/drivers/isdn/hardware/avm/t1pci.c
index e6d298d75146..5a3f83098018 100644
--- a/drivers/isdn/hardware/avm/t1pci.c
+++ b/drivers/isdn/hardware/avm/t1pci.c
@@ -119,7 +119,7 @@ static int t1pci_add_card(struct capicardparams *p, struct pci_dev *pdev)
         cinfo->capi_ctrl.load_firmware = b1dma_load_firmware;
         cinfo->capi_ctrl.reset_ctr     = b1dma_reset_ctr;
         cinfo->capi_ctrl.procinfo      = t1pci_procinfo;
-        cinfo->capi_ctrl.ctr_read_proc = b1dmactl_read_proc;
+        cinfo->capi_ctrl.proc_fops = &b1dmactl_proc_fops;
         strcpy(cinfo->capi_ctrl.name, card->name);
 
         retval = attach_capi_ctr(&cinfo->capi_ctrl);
diff --git a/drivers/isdn/hardware/eicon/capimain.c b/drivers/isdn/hardware/eicon/capimain.c
index 98fcdfc7ca55..0f073cd73763 100644
--- a/drivers/isdn/hardware/eicon/capimain.c
+++ b/drivers/isdn/hardware/eicon/capimain.c
@@ -13,6 +13,7 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <asm/uaccess.h>
+#include <linux/seq_file.h>
 #include <linux/skbuff.h>
 
 #include "os_capi.h"
@@ -75,25 +76,32 @@ void diva_os_free_message_buffer(diva_os_message_buffer_s * dmb)
 /*
  * proc function for controller info
  */
-static int diva_ctl_read_proc(char *page, char **start, off_t off,
-                              int count, int *eof, struct capi_ctr *ctrl)
+static int diva_ctl_proc_show(struct seq_file *m, void *v)
 {
+        struct capi_ctr *ctrl = m->private;
         diva_card *card = (diva_card *) ctrl->driverdata;
-        int len = 0;
-
-        len += sprintf(page + len, "%s\n", ctrl->name);
-        len += sprintf(page + len, "Serial No. : %s\n", ctrl->serial);
-        len += sprintf(page + len, "Id         : %d\n", card->Id);
-        len += sprintf(page + len, "Channels   : %d\n", card->d.channels);
-
-        if (off + count >= len)
-                *eof = 1;
-        if (len < off)
-                return 0;
-        *start = page + off;
-        return ((count < len - off) ? count : len - off);
+
+        seq_printf(m, "%s\n", ctrl->name);
+        seq_printf(m, "Serial No. : %s\n", ctrl->serial);
+        seq_printf(m, "Id         : %d\n", card->Id);
+        seq_printf(m, "Channels   : %d\n", card->d.channels);
+
+        return 0;
+}
+
+static int diva_ctl_proc_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, diva_ctl_proc_show, NULL);
 }
 
+static const struct file_operations diva_ctl_proc_fops = {
+        .owner          = THIS_MODULE,
+        .open           = diva_ctl_proc_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
+
 /*
  * set additional os settings in capi_ctr struct
  */
@@ -102,7 +110,7 @@ void diva_os_set_controller_struct(struct capi_ctr *ctrl)
         ctrl->driver_name = DRIVERLNAME;
         ctrl->load_firmware = NULL;
         ctrl->reset_ctr = NULL;
-        ctrl->ctr_read_proc = diva_ctl_read_proc;
+        ctrl->proc_fops = &diva_ctl_proc_fops;
         ctrl->owner = THIS_MODULE;
 }
 
diff --git a/drivers/isdn/hardware/eicon/diva_didd.c b/drivers/isdn/hardware/eicon/diva_didd.c
index 993b14cf1778..5d06a7437824 100644
--- a/drivers/isdn/hardware/eicon/diva_didd.c
+++ b/drivers/isdn/hardware/eicon/diva_didd.c
@@ -15,6 +15,7 @@
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/proc_fs.h>
+#include <linux/seq_file.h>
 #include <net/net_namespace.h>
 
 #include "platform.h"
@@ -62,39 +63,41 @@ static char *getrev(const char *revision)
         return rev;
 }
 
-static int
-proc_read(char *page, char **start, off_t off, int count, int *eof,
-          void *data)
+static int divadidd_proc_show(struct seq_file *m, void *v)
 {
-        int len = 0;
         char tmprev[32];
 
         strcpy(tmprev, main_revision);
-        len += sprintf(page + len, "%s\n", DRIVERNAME);
-        len += sprintf(page + len, "name     : %s\n", DRIVERLNAME);
-        len += sprintf(page + len, "release  : %s\n", DRIVERRELEASE_DIDD);
-        len += sprintf(page + len, "build    : %s(%s)\n",
+        seq_printf(m, "%s\n", DRIVERNAME);
+        seq_printf(m, "name     : %s\n", DRIVERLNAME);
+        seq_printf(m, "release  : %s\n", DRIVERRELEASE_DIDD);
+        seq_printf(m, "build    : %s(%s)\n",
                        diva_didd_common_code_build, DIVA_BUILD);
-        len += sprintf(page + len, "revision : %s\n", getrev(tmprev));
-
-        if (off + count >= len)
-                *eof = 1;
-        if (len < off)
-                return 0;
-        *start = page + off;
-        return ((count < len - off) ? count : len - off);
+        seq_printf(m, "revision : %s\n", getrev(tmprev));
+
+        return 0;
 }
 
+static int divadidd_proc_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, divadidd_proc_show, NULL);
+}
+
+static const struct file_operations divadidd_proc_fops = {
+        .owner          = THIS_MODULE,
+        .open           = divadidd_proc_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
+
 static int DIVA_INIT_FUNCTION create_proc(void)
 {
         proc_net_eicon = proc_mkdir("eicon", init_net.proc_net);
 
         if (proc_net_eicon) {
-                if ((proc_didd =
-                     create_proc_entry(DRIVERLNAME, S_IFREG | S_IRUGO,
-                                       proc_net_eicon))) {
-                        proc_didd->read_proc = proc_read;
-                }
+                proc_didd = proc_create(DRIVERLNAME, S_IRUGO, proc_net_eicon,
+                                        &divadidd_proc_fops);
                 return (1);
         }
         return (0);
diff --git a/drivers/isdn/hardware/eicon/divasi.c b/drivers/isdn/hardware/eicon/divasi.c
index 69e71ebe7841..f577719ab3fa 100644
--- a/drivers/isdn/hardware/eicon/divasi.c
+++ b/drivers/isdn/hardware/eicon/divasi.c
@@ -17,6 +17,7 @@
 #include <linux/poll.h>
 #include <linux/proc_fs.h>
 #include <linux/skbuff.h>
+#include <linux/seq_file.h>
 #include <linux/smp_lock.h>
 #include <asm/uaccess.h>
 
@@ -86,39 +87,40 @@ static void diva_um_timer_function(unsigned long data);
 extern struct proc_dir_entry *proc_net_eicon;
 static struct proc_dir_entry *um_idi_proc_entry = NULL;
 
-static int
-um_idi_proc_read(char *page, char **start, off_t off, int count, int *eof,
-                 void *data)
+static int um_idi_proc_show(struct seq_file *m, void *v)
 {
-        int len = 0;
         char tmprev[32];
 
-        len += sprintf(page + len, "%s\n", DRIVERNAME);
-        len += sprintf(page + len, "name     : %s\n", DRIVERLNAME);
-        len += sprintf(page + len, "release  : %s\n", DRIVERRELEASE_IDI);
+        seq_printf(m, "%s\n", DRIVERNAME);
+        seq_printf(m, "name     : %s\n", DRIVERLNAME);
+        seq_printf(m, "release  : %s\n", DRIVERRELEASE_IDI);
         strcpy(tmprev, main_revision);
-        len += sprintf(page + len, "revision : %s\n", getrev(tmprev));
-        len += sprintf(page + len, "build    : %s\n", DIVA_BUILD);
-        len += sprintf(page + len, "major    : %d\n", major);
-
-        if (off + count >= len)
-                *eof = 1;
-        if (len < off)
-                return 0;
-        *start = page + off;
-        return ((count < len - off) ? count : len - off);
+        seq_printf(m, "revision : %s\n", getrev(tmprev));
+        seq_printf(m, "build    : %s\n", DIVA_BUILD);
+        seq_printf(m, "major    : %d\n", major);
+
+        return 0;
+}
+
+static int um_idi_proc_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, um_idi_proc_show, NULL);
 }
 
+static const struct file_operations um_idi_proc_fops = {
+        .owner          = THIS_MODULE,
+        .open           = um_idi_proc_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
+
 static int DIVA_INIT_FUNCTION create_um_idi_proc(void)
 {
-        um_idi_proc_entry = create_proc_entry(DRIVERLNAME,
-                                              S_IFREG | S_IRUGO | S_IWUSR,
-                                              proc_net_eicon);
+        um_idi_proc_entry = proc_create(DRIVERLNAME, S_IRUGO, proc_net_eicon,
+                                        &um_idi_proc_fops);
         if (!um_idi_proc_entry)
                 return (0);
-
-        um_idi_proc_entry->read_proc = um_idi_proc_read;
-
         return (1);
 }
 
diff --git a/drivers/isdn/hardware/eicon/divasproc.c b/drivers/isdn/hardware/eicon/divasproc.c
index 040827288ec9..46d44a942624 100644
--- a/drivers/isdn/hardware/eicon/divasproc.c
+++ b/drivers/isdn/hardware/eicon/divasproc.c
@@ -14,6 +14,7 @@
 #include <linux/kernel.h>
 #include <linux/poll.h>
 #include <linux/proc_fs.h>
+#include <linux/seq_file.h>
 #include <linux/list.h>
 #include <asm/uaccess.h>
 
@@ -141,14 +142,10 @@ void remove_divas_proc(void)
         }
 }
 
-/*
-** write group_optimization 
-*/
-static int
-write_grp_opt(struct file *file, const char __user *buffer, unsigned long count,
-              void *data)
+static ssize_t grp_opt_proc_write(struct file *file, const char __user *buffer,
+                                  size_t count, loff_t *pos)
 {
-        diva_os_xdi_adapter_t *a = (diva_os_xdi_adapter_t *) data;
+        diva_os_xdi_adapter_t *a = PDE(file->f_path.dentry->d_inode)->data;
         PISDN_ADAPTER IoAdapter = IoAdapters[a->controller - 1];
 
         if ((count == 1) || (count == 2)) {
@@ -172,14 +169,10 @@ write_grp_opt(struct file *file, const char __user *buffer, unsigned long count,
         return (-EINVAL);
 }
 
-/*
-** write dynamic_l1_down
-*/
-static int
-write_d_l1_down(struct file *file, const char __user *buffer, unsigned long count,
-                void *data)
+static ssize_t d_l1_down_proc_write(struct file *file, const char __user *buffer,
+                                    size_t count, loff_t *pos)
 {
-        diva_os_xdi_adapter_t *a = (diva_os_xdi_adapter_t *) data;
+        diva_os_xdi_adapter_t *a = PDE(file->f_path.dentry->d_inode)->data;
         PISDN_ADAPTER IoAdapter = IoAdapters[a->controller - 1];
 
         if ((count == 1) || (count == 2)) {
@@ -203,63 +196,62 @@ write_d_l1_down(struct file *file, const char __user *buffer, unsigned long coun
         return (-EINVAL);
 }
 
-
-/*
-** read dynamic_l1_down 
-*/
-static int
-read_d_l1_down(char *page, char **start, off_t off, int count, int *eof,
-               void *data)
+static int d_l1_down_proc_show(struct seq_file *m, void *v)
 {
-        int len = 0;
-        diva_os_xdi_adapter_t *a = (diva_os_xdi_adapter_t *) data;
+        diva_os_xdi_adapter_t *a = m->private;
         PISDN_ADAPTER IoAdapter = IoAdapters[a->controller - 1];
 
-        len += sprintf(page + len, "%s\n",
+        seq_printf(m, "%s\n",
                        (IoAdapter->capi_cfg.
                         cfg_1 & DIVA_XDI_CAPI_CFG_1_DYNAMIC_L1_ON) ? "1" :
                        "0");
+        return 0;
+}
 
-        if (off + count >= len)
-                *eof = 1;
-        if (len < off)
-                return 0;
-        *start = page + off;
-        return ((count < len - off) ? count : len - off);
+static int d_l1_down_proc_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, d_l1_down_proc_show, PDE(inode)->data);
 }
 
-/*
-** read group_optimization
-*/
-static int
-read_grp_opt(char *page, char **start, off_t off, int count, int *eof,
-             void *data)
+static const struct file_operations d_l1_down_proc_fops = {
+        .owner          = THIS_MODULE,
+        .open           = d_l1_down_proc_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+        .write          = d_l1_down_proc_write,
+};
+
+static int grp_opt_proc_show(struct seq_file *m, void *v)
 {
-        int len = 0;
-        diva_os_xdi_adapter_t *a = (diva_os_xdi_adapter_t *) data;
+        diva_os_xdi_adapter_t *a = m->private;
         PISDN_ADAPTER IoAdapter = IoAdapters[a->controller - 1];
 
-        len += sprintf(page + len, "%s\n",
+        seq_printf(m, "%s\n",
                        (IoAdapter->capi_cfg.
                         cfg_1 & DIVA_XDI_CAPI_CFG_1_GROUP_POPTIMIZATION_ON)
                        ? "1" : "0");
+        return 0;
+}
 
-        if (off + count >= len)
-                *eof = 1;
-        if (len < off)
-                return 0;
-        *start = page + off;
-        return ((count < len - off) ? count : len - off);
+static int grp_opt_proc_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, grp_opt_proc_show, PDE(inode)->data);
 }
 
-/*
-** info write
-*/
-static int
-info_write(struct file *file, const char __user *buffer, unsigned long count,
-           void *data)
+static const struct file_operations grp_opt_proc_fops = {
+        .owner          = THIS_MODULE,
+        .open           = grp_opt_proc_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+        .write          = grp_opt_proc_write,
+};
+
+static ssize_t info_proc_write(struct file *file, const char __user *buffer,
+                               size_t count, loff_t *pos)
 {
-        diva_os_xdi_adapter_t *a = (diva_os_xdi_adapter_t *) data;
+        diva_os_xdi_adapter_t *a = PDE(file->f_path.dentry->d_inode)->data;
         PISDN_ADAPTER IoAdapter = IoAdapters[a->controller - 1];
         char c[4];
 
@@ -277,63 +269,46 @@ info_write(struct file *file, const char __user *buffer, unsigned long count,
         return (-EINVAL);
 }
 
-/*
-** info read
-*/
-static int
-info_read(char *page, char **start, off_t off, int count, int *eof,
-          void *data)
+static int info_proc_show(struct seq_file *m, void *v)
 {
         int i = 0;
-        int len = 0;
         char *p;
         char tmpser[16];
-        diva_os_xdi_adapter_t *a = (diva_os_xdi_adapter_t *) data;
+        diva_os_xdi_adapter_t *a = m->private;
         PISDN_ADAPTER IoAdapter = IoAdapters[a->controller - 1];
 
-        len +=
-            sprintf(page + len, "Name        : %s\n",
-                    IoAdapter->Properties.Name);
-        len += sprintf(page + len, "DSP state   : %08x\n", a->dsp_mask);
-        len += sprintf(page + len, "Channels    : %02d\n",
-                       IoAdapter->Properties.Channels);
-        len += sprintf(page + len, "E. max/used : %03d/%03d\n",
+        seq_printf(m, "Name        : %s\n", IoAdapter->Properties.Name);
+        seq_printf(m, "DSP state   : %08x\n", a->dsp_mask);
+        seq_printf(m, "Channels    : %02d\n", IoAdapter->Properties.Channels);
+        seq_printf(m, "E. max/used : %03d/%03d\n",
                        IoAdapter->e_max, IoAdapter->e_count);
         diva_get_vserial_number(IoAdapter, tmpser);
-        len += sprintf(page + len, "Serial      : %s\n", tmpser);
-        len +=
-            sprintf(page + len, "IRQ         : %d\n",
-                    IoAdapter->irq_info.irq_nr);
-        len += sprintf(page + len, "CardIndex   : %d\n", a->CardIndex);
-        len += sprintf(page + len, "CardOrdinal : %d\n", a->CardOrdinal);
-        len += sprintf(page + len, "Controller  : %d\n", a->controller);
-        len += sprintf(page + len, "Bus-Type    : %s\n",
+        seq_printf(m, "Serial      : %s\n", tmpser);
+        seq_printf(m, "IRQ         : %d\n", IoAdapter->irq_info.irq_nr);
+        seq_printf(m, "CardIndex   : %d\n", a->CardIndex);
+        seq_printf(m, "CardOrdinal : %d\n", a->CardOrdinal);
+        seq_printf(m, "Controller  : %d\n", a->controller);
+        seq_printf(m, "Bus-Type    : %s\n",
                        (a->Bus ==
                         DIVAS_XDI_ADAPTER_BUS_ISA) ? "ISA" : "PCI");
-        len += sprintf(page + len, "Port-Name   : %s\n", a->port_name);
+        seq_printf(m, "Port-Name   : %s\n", a->port_name);
         if (a->Bus == DIVAS_XDI_ADAPTER_BUS_PCI) {
-                len +=
-                    sprintf(page + len, "PCI-bus     : %d\n",
-                            a->resources.pci.bus);
-                len +=
-                    sprintf(page + len, "PCI-func    : %d\n",
-                            a->resources.pci.func);
+                seq_printf(m, "PCI-bus     : %d\n", a->resources.pci.bus);
+                seq_printf(m, "PCI-func    : %d\n", a->resources.pci.func);
                 for (i = 0; i < 8; i++) {
                         if (a->resources.pci.bar[i]) {
-                                len +=
-                                    sprintf(page + len,
+                                seq_printf(m,
                                             "Mem / I/O %d : 0x%x / mapped : 0x%lx",
                                             i, a->resources.pci.bar[i],
                                             (unsigned long) a->resources.
                                             pci.addr[i]);
                                 if (a->resources.pci.length[i]) {
-                                        len +=
-                                            sprintf(page + len,
+                                        seq_printf(m,
                                                     " / length : %d",
                                                     a->resources.pci.
                                                     length[i]);
                                 }
-                                len += sprintf(page + len, "\n");
+                                seq_putc(m, '\n');
                         }
                 }
         }
@@ -353,16 +328,25 @@ info_read(char *page, char **start, off_t off, int count, int *eof,
         } else {
                 p = "ready";
         }
-        len += sprintf(page + len, "State       : %s\n", p);
+        seq_printf(m, "State       : %s\n", p);
 
-        if (off + count >= len)
-                *eof = 1;
-        if (len < off)
-                return 0;
-        *start = page + off;
-        return ((count < len - off) ? count : len - off);
+        return 0;
+}
+
+static int info_proc_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, info_proc_show, PDE(inode)->data);
 }
 
+static const struct file_operations info_proc_fops = {
+        .owner          = THIS_MODULE,
+        .open           = info_proc_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+        .write          = info_proc_write,
+};
+
 /*
 ** adapter proc init/de-init
 */
@@ -380,28 +364,20 @@ int create_adapter_proc(diva_os_xdi_adapter_t * a)
                 return (0);
         a->proc_adapter_dir = (void *) de;
 
-        if (!(pe =
-             create_proc_entry(info_proc_name, S_IFREG | S_IRUGO | S_IWUSR, de)))
+        pe = proc_create_data(info_proc_name, S_IRUGO | S_IWUSR, de,
+                              &info_proc_fops, a);
+        if (!pe)
                 return (0);
         a->proc_info = (void *) pe;
-        pe->write_proc = info_write;
-        pe->read_proc = info_read;
-        pe->data = a;
 
-        if ((pe = create_proc_entry(grp_opt_proc_name,
-                               S_IFREG | S_IRUGO | S_IWUSR, de))) {
+        pe = proc_create_data(grp_opt_proc_name, S_IRUGO | S_IWUSR, de,
+                              &grp_opt_proc_fops, a);
+        if (pe)
                 a->proc_grp_opt = (void *) pe;
-                pe->write_proc = write_grp_opt;
-                pe->read_proc = read_grp_opt;
-                pe->data = a;
-        }
-        if ((pe = create_proc_entry(d_l1_down_proc_name,
-                               S_IFREG | S_IRUGO | S_IWUSR, de))) {
+        pe = proc_create_data(d_l1_down_proc_name, S_IRUGO | S_IWUSR, de,
+                              &d_l1_down_proc_fops, a);
+        if (pe)
                 a->proc_d_l1_down = (void *) pe;
-                pe->write_proc = write_d_l1_down;
-                pe->read_proc = read_d_l1_down;
-                pe->data = a;
-        }
 
         DBG_TRC(("proc entry %s created", tmp));
 
diff --git a/drivers/isdn/hardware/mISDN/hfcmulti.c b/drivers/isdn/hardware/mISDN/hfcmulti.c
index 1a1420d7a828..ad36df9b759c 100644
--- a/drivers/isdn/hardware/mISDN/hfcmulti.c
+++ b/drivers/isdn/hardware/mISDN/hfcmulti.c
@@ -2846,7 +2846,7 @@ mode_hfcmulti(struct hfc_multi *hc, int ch, int protocol, int slot_tx,
         int conf;
 
         if (ch < 0 || ch > 31)
-                return EINVAL;
+                return -EINVAL;
         oslot_tx = hc->chan[ch].slot_tx;
         oslot_rx = hc->chan[ch].slot_rx;
         conf = hc->chan[ch].conf;
diff --git a/drivers/isdn/hardware/mISDN/mISDNinfineon.c b/drivers/isdn/hardware/mISDN/mISDNinfineon.c
index 62441ba53b95..36c6c616a655 100644
--- a/drivers/isdn/hardware/mISDN/mISDNinfineon.c
+++ b/drivers/isdn/hardware/mISDN/mISDNinfineon.c
@@ -1133,6 +1133,7 @@ inf_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                         if (err) {
                                 kfree(sc);
                                 release_card(card);
+                                break;
                         } else
                                 card->sc[i - 1] = sc;
                 }
diff --git a/drivers/isdn/hardware/mISDN/w6692.c b/drivers/isdn/hardware/mISDN/w6692.c
index d3f1077b709b..2952a58c7a61 100644
--- a/drivers/isdn/hardware/mISDN/w6692.c
+++ b/drivers/isdn/hardware/mISDN/w6692.c
@@ -529,6 +529,7 @@ W6692_fill_Bfifo(struct w6692_ch *wch)
         }
 }
 
+#if 0
 static int
 setvolume(struct w6692_ch *wch, int mic, struct sk_buff *skb)
 {
@@ -571,6 +572,7 @@ enable_pots(struct w6692_ch *wch)
         WriteW6692(card, W_PCTL, card->pctl);
         return 0;
 }
+#endif
 
 static int
 disable_pots(struct w6692_ch *wch)
diff --git a/drivers/isdn/hisax/Kconfig b/drivers/isdn/hisax/Kconfig
index 3464ebc4cdbc..452fde9edf86 100644
--- a/drivers/isdn/hisax/Kconfig
+++ b/drivers/isdn/hisax/Kconfig
@@ -109,7 +109,7 @@ config HISAX_16_3
 
 config HISAX_TELESPCI
         bool "Teles PCI"
-        depends on PCI && PCI_LEGACY && (BROKEN || !(SPARC || PPC || PARISC || M68K || (MIPS && !CPU_LITTLE_ENDIAN) || FRV))
+        depends on PCI && (BROKEN || !(SPARC || PPC || PARISC || M68K || (MIPS && !CPU_LITTLE_ENDIAN) || FRV))
         help
           This enables HiSax support for the Teles PCI.
           See <file:Documentation/isdn/README.HiSax> on how to configure it.
@@ -237,7 +237,7 @@ config HISAX_MIC
 
 config HISAX_NETJET
         bool "NETjet card"
-        depends on PCI && PCI_LEGACY && (BROKEN || !(SPARC || PPC || PARISC || M68K || (MIPS && !CPU_LITTLE_ENDIAN) || FRV))
+        depends on PCI && (BROKEN || !(SPARC || PPC || PARISC || M68K || (MIPS && !CPU_LITTLE_ENDIAN) || FRV))
         help
           This enables HiSax support for the NetJet from Traverse
           Technologies.
@@ -248,7 +248,7 @@ config HISAX_NETJET
 
 config HISAX_NETJET_U
         bool "NETspider U card"
-        depends on PCI && PCI_LEGACY && (BROKEN || !(SPARC || PPC || PARISC || M68K || (MIPS && !CPU_LITTLE_ENDIAN) || FRV))
+        depends on PCI && (BROKEN || !(SPARC || PPC || PARISC || M68K || (MIPS && !CPU_LITTLE_ENDIAN) || FRV))
         help
           This enables HiSax support for the Netspider U interface ISDN card
           from Traverse Technologies.
@@ -287,7 +287,7 @@ config HISAX_HSTSAPHIR
 
 config HISAX_BKM_A4T
         bool "Telekom A4T card"
-        depends on PCI && PCI_LEGACY
+        depends on PCI
         help
           This enables HiSax support for the Telekom A4T card.
 
@@ -297,7 +297,7 @@ config HISAX_BKM_A4T
 
 config HISAX_SCT_QUADRO
         bool "Scitel Quadro card"
-        depends on PCI && PCI_LEGACY
+        depends on PCI
         help
           This enables HiSax support for the Scitel Quadro card.
 
@@ -316,7 +316,7 @@ config HISAX_GAZEL
 
 config HISAX_HFC_PCI
         bool "HFC PCI-Bus cards"
-        depends on PCI && PCI_LEGACY && (BROKEN || !(SPARC || PPC || PARISC || M68K || (MIPS && !CPU_LITTLE_ENDIAN) || FRV))
+        depends on PCI && (BROKEN || !(SPARC || PPC || PARISC || M68K || (MIPS && !CPU_LITTLE_ENDIAN) || FRV))
         help
           This enables HiSax support for the HFC-S PCI 2BDS0 based cards.
 
@@ -325,7 +325,7 @@ config HISAX_HFC_PCI
 
 config HISAX_W6692
         bool "Winbond W6692 based cards"
-        depends on PCI && PCI_LEGACY
+        depends on PCI
         help
           This enables HiSax support for Winbond W6692 based PCI ISDN cards.
 
@@ -341,7 +341,7 @@ config HISAX_HFC_SX
 
 config HISAX_ENTERNOW_PCI
         bool "Formula-n enter:now PCI card"
-        depends on HISAX_NETJET && PCI && PCI_LEGACY && (BROKEN || !(SPARC || PPC || PARISC || M68K || (MIPS && !CPU_LITTLE_ENDIAN) || FRV))
+        depends on HISAX_NETJET && PCI && (BROKEN || !(SPARC || PPC || PARISC || M68K || (MIPS && !CPU_LITTLE_ENDIAN) || FRV))
         help
           This enables HiSax support for the Formula-n enter:now PCI
           ISDN card.
@@ -412,7 +412,7 @@ config HISAX_HFC4S8S
 
 config HISAX_FRITZ_PCIPNP
         tristate "AVM Fritz!Card PCI/PCIv2/PnP support (EXPERIMENTAL)"
-        depends on PCI && PCI_LEGACY && EXPERIMENTAL
+        depends on PCI && EXPERIMENTAL
         help
           This enables the driver for the AVM Fritz!Card PCI,
           Fritz!Card PCI v2 and Fritz!Card PnP.
diff --git a/drivers/isdn/hisax/avm_pci.c b/drivers/isdn/hisax/avm_pci.c
index 7cabc5a19492..14295a155e71 100644
--- a/drivers/isdn/hisax/avm_pci.c
+++ b/drivers/isdn/hisax/avm_pci.c
@@ -822,7 +822,7 @@ static int __devinit avm_pnp_setup(struct IsdnCardState *cs)
 
 #endif /* __ISAPNP__ */
 
-#ifndef CONFIG_PCI_LEGACY
+#ifndef CONFIG_PCI
 
 static int __devinit avm_pci_setup(struct IsdnCardState *cs)
 {
@@ -835,7 +835,7 @@ static struct pci_dev *dev_avm __devinitdata = NULL;
 
 static int __devinit avm_pci_setup(struct IsdnCardState *cs)
 {
-        if ((dev_avm = pci_find_device(PCI_VENDOR_ID_AVM,
+        if ((dev_avm = hisax_find_pci_device(PCI_VENDOR_ID_AVM,
                 PCI_DEVICE_ID_AVM_A1, dev_avm))) {
 
                 if (pci_enable_device(dev_avm))
@@ -864,7 +864,7 @@ static int __devinit avm_pci_setup(struct IsdnCardState *cs)
         return (1);
 }
 
-#endif /* CONFIG_PCI_LEGACY */
+#endif /* CONFIG_PCI */
 
 int __devinit
 setup_avm_pcipnp(struct IsdnCard *card)
diff --git a/drivers/isdn/hisax/bkm_a4t.c b/drivers/isdn/hisax/bkm_a4t.c
index 9ca2ee54cc94..9f2009c0b69c 100644
--- a/drivers/isdn/hisax/bkm_a4t.c
+++ b/drivers/isdn/hisax/bkm_a4t.c
@@ -340,7 +340,7 @@ setup_bkm_a4t(struct IsdnCard *card)
         } else
                 return (0);
 
-        while ((dev_a4t = pci_find_device(PCI_VENDOR_ID_ZORAN,
+        while ((dev_a4t = hisax_find_pci_device(PCI_VENDOR_ID_ZORAN,
                 PCI_DEVICE_ID_ZORAN_36120, dev_a4t))) {
                 ret = a4t_pci_probe(dev_a4t, cs, &found, &pci_memaddr);
                 if (!ret)
diff --git a/drivers/isdn/hisax/bkm_a8.c b/drivers/isdn/hisax/bkm_a8.c
index e1ff4717a8a6..e775706c60e3 100644
--- a/drivers/isdn/hisax/bkm_a8.c
+++ b/drivers/isdn/hisax/bkm_a8.c
@@ -301,7 +301,7 @@ setup_sct_quadro(struct IsdnCard *card)
                 (sub_vendor_id != PCI_VENDOR_ID_BERKOM)))
                 return (0);
         if (cs->subtyp == SCT_1) {
-                while ((dev_a8 = pci_find_device(PCI_VENDOR_ID_PLX,
+                while ((dev_a8 = hisax_find_pci_device(PCI_VENDOR_ID_PLX,
                         PCI_DEVICE_ID_PLX_9050, dev_a8))) {
                         
                         sub_vendor_id = dev_a8->subsystem_vendor;
diff --git a/drivers/isdn/hisax/diva.c b/drivers/isdn/hisax/diva.c
index 0b0c2e5d806b..780da9bda915 100644
--- a/drivers/isdn/hisax/diva.c
+++ b/drivers/isdn/hisax/diva.c
@@ -1148,7 +1148,7 @@ static int __devinit setup_diva_isapnp(struct IsdnCard *card)
 
 #endif  /* ISAPNP */
 
-#ifdef CONFIG_PCI_LEGACY
+#ifdef CONFIG_PCI
 static struct pci_dev *dev_diva __devinitdata = NULL;
 static struct pci_dev *dev_diva_u __devinitdata = NULL;
 static struct pci_dev *dev_diva201 __devinitdata = NULL;
@@ -1159,21 +1159,21 @@ static int __devinit setup_diva_pci(struct IsdnCard *card)
         struct IsdnCardState *cs = card->cs;
 
         cs->subtyp = 0;
-        if ((dev_diva = pci_find_device(PCI_VENDOR_ID_EICON,
+        if ((dev_diva = hisax_find_pci_device(PCI_VENDOR_ID_EICON,
                 PCI_DEVICE_ID_EICON_DIVA20, dev_diva))) {
                 if (pci_enable_device(dev_diva))
                         return(0);
                 cs->subtyp = DIVA_PCI;
                 cs->irq = dev_diva->irq;
                 cs->hw.diva.cfg_reg = pci_resource_start(dev_diva, 2);
-        } else if ((dev_diva_u = pci_find_device(PCI_VENDOR_ID_EICON,
+        } else if ((dev_diva_u = hisax_find_pci_device(PCI_VENDOR_ID_EICON,
                 PCI_DEVICE_ID_EICON_DIVA20_U, dev_diva_u))) {
                 if (pci_enable_device(dev_diva_u))
                         return(0);
                 cs->subtyp = DIVA_PCI;
                 cs->irq = dev_diva_u->irq;
                 cs->hw.diva.cfg_reg = pci_resource_start(dev_diva_u, 2);
-        } else if ((dev_diva201 = pci_find_device(PCI_VENDOR_ID_EICON,
+        } else if ((dev_diva201 = hisax_find_pci_device(PCI_VENDOR_ID_EICON,
                 PCI_DEVICE_ID_EICON_DIVA201, dev_diva201))) {
                 if (pci_enable_device(dev_diva201))
                         return(0);
@@ -1183,7 +1183,7 @@ static int __devinit setup_diva_pci(struct IsdnCard *card)
                         (ulong) ioremap(pci_resource_start(dev_diva201, 0), 4096);
                 cs->hw.diva.cfg_reg =
                         (ulong) ioremap(pci_resource_start(dev_diva201, 1), 4096);
-        } else if ((dev_diva202 = pci_find_device(PCI_VENDOR_ID_EICON,
+        } else if ((dev_diva202 = hisax_find_pci_device(PCI_VENDOR_ID_EICON,
                 PCI_DEVICE_ID_EICON_DIVA202, dev_diva202))) {
                 if (pci_enable_device(dev_diva202))
                         return(0);
@@ -1229,14 +1229,14 @@ static int __devinit setup_diva_pci(struct IsdnCard *card)
         return (1);             /* card found */
 }
 
-#else   /* if !CONFIG_PCI_LEGACY */
+#else   /* if !CONFIG_PCI */
 
 static int __devinit setup_diva_pci(struct IsdnCard *card)
 {
         return (-1);    /* card not found; continue search */
 }
 
-#endif  /* CONFIG_PCI_LEGACY */
+#endif  /* CONFIG_PCI */
 
 int __devinit
 setup_diva(struct IsdnCard *card)
diff --git a/drivers/isdn/hisax/elsa.c b/drivers/isdn/hisax/elsa.c
index aa29d1cf16af..23c41fcd864e 100644
--- a/drivers/isdn/hisax/elsa.c
+++ b/drivers/isdn/hisax/elsa.c
@@ -1025,7 +1025,7 @@ setup_elsa_pcmcia(struct IsdnCard *card)
                cs->irq);
 }
 
-#ifdef CONFIG_PCI_LEGACY
+#ifdef CONFIG_PCI
 static  struct pci_dev *dev_qs1000 __devinitdata = NULL;
 static  struct pci_dev *dev_qs3000 __devinitdata = NULL;
 
@@ -1035,7 +1035,7 @@ setup_elsa_pci(struct IsdnCard *card)
         struct IsdnCardState *cs = card->cs;
 
         cs->subtyp = 0;
-        if ((dev_qs1000 = pci_find_device(PCI_VENDOR_ID_ELSA,
+        if ((dev_qs1000 = hisax_find_pci_device(PCI_VENDOR_ID_ELSA,
                 PCI_DEVICE_ID_ELSA_MICROLINK, dev_qs1000))) {
                 if (pci_enable_device(dev_qs1000))
                         return(0);
@@ -1043,7 +1043,7 @@ setup_elsa_pci(struct IsdnCard *card)
                 cs->irq = dev_qs1000->irq;
                 cs->hw.elsa.cfg = pci_resource_start(dev_qs1000, 1);
                 cs->hw.elsa.base = pci_resource_start(dev_qs1000, 3);
-        } else if ((dev_qs3000 = pci_find_device(PCI_VENDOR_ID_ELSA,
+        } else if ((dev_qs3000 = hisax_find_pci_device(PCI_VENDOR_ID_ELSA,
                 PCI_DEVICE_ID_ELSA_QS3000, dev_qs3000))) {
                 if (pci_enable_device(dev_qs3000))
                         return(0);
@@ -1093,7 +1093,7 @@ setup_elsa_pci(struct IsdnCard *card)
 {
         return (1);
 }
-#endif /* CONFIG_PCI_LEGACY */
+#endif /* CONFIG_PCI */
 
 static int __devinit
 setup_elsa_common(struct IsdnCard *card)
diff --git a/drivers/isdn/hisax/enternow_pci.c b/drivers/isdn/hisax/enternow_pci.c
index 39f421ed8de8..26264abf1f58 100644
--- a/drivers/isdn/hisax/enternow_pci.c
+++ b/drivers/isdn/hisax/enternow_pci.c
@@ -406,7 +406,7 @@ setup_enternow_pci(struct IsdnCard *card)
 
         for ( ;; )
         {
-                if ((dev_netjet = pci_find_device(PCI_VENDOR_ID_TIGERJET,
+                if ((dev_netjet = hisax_find_pci_device(PCI_VENDOR_ID_TIGERJET,
                         PCI_DEVICE_ID_TIGERJET_300,  dev_netjet))) {
                         ret = en_pci_probe(dev_netjet, cs);
                         if (!ret)
diff --git a/drivers/isdn/hisax/gazel.c b/drivers/isdn/hisax/gazel.c
index 0ea3b4607680..353982fc1436 100644
--- a/drivers/isdn/hisax/gazel.c
+++ b/drivers/isdn/hisax/gazel.c
@@ -531,7 +531,7 @@ setup_gazelisa(struct IsdnCard *card, struct IsdnCardState *cs)
         return (0);
 }
 
-#ifdef CONFIG_PCI_LEGACY
+#ifdef CONFIG_PCI
 static struct pci_dev *dev_tel __devinitdata = NULL;
 
 static int __devinit
@@ -546,7 +546,7 @@ setup_gazelpci(struct IsdnCardState *cs)
         found = 0;
         seekcard = PCI_DEVICE_ID_PLX_R685;
         for (nbseek = 0; nbseek < 4; nbseek++) {
-                if ((dev_tel = pci_find_device(PCI_VENDOR_ID_PLX,
+                if ((dev_tel = hisax_find_pci_device(PCI_VENDOR_ID_PLX,
                                         seekcard, dev_tel))) {
                         if (pci_enable_device(dev_tel))
                                 return 1;
@@ -620,7 +620,7 @@ setup_gazelpci(struct IsdnCardState *cs)
 
         return (0);
 }
-#endif /* CONFIG_PCI_LEGACY */
+#endif /* CONFIG_PCI */
 
 int __devinit
 setup_gazel(struct IsdnCard *card)
@@ -640,7 +640,7 @@ setup_gazel(struct IsdnCard *card)
                         return (0);
         } else {
 
-#ifdef CONFIG_PCI_LEGACY
+#ifdef CONFIG_PCI
                 if (setup_gazelpci(cs))
                         return (0);
 #else
diff --git a/drivers/isdn/hisax/hfc_pci.c b/drivers/isdn/hisax/hfc_pci.c
index 10914731b304..917cc84065bd 100644
--- a/drivers/isdn/hisax/hfc_pci.c
+++ b/drivers/isdn/hisax/hfc_pci.c
@@ -1658,7 +1658,7 @@ setup_hfcpci(struct IsdnCard *card)
 
         i = 0;
         while (id_list[i].vendor_id) {
-                tmp_hfcpci = pci_find_device(id_list[i].vendor_id,
+                tmp_hfcpci = hisax_find_pci_device(id_list[i].vendor_id,
                                              id_list[i].device_id,
                                              dev_hfcpci);
                 i++;
diff --git a/drivers/isdn/hisax/hisax.h b/drivers/isdn/hisax/hisax.h
index 0685c1946969..832a87855ffb 100644
--- a/drivers/isdn/hisax/hisax.h
+++ b/drivers/isdn/hisax/hisax.h
@@ -1323,3 +1323,26 @@ void release_tei(struct IsdnCardState *cs);
 char *HiSax_getrev(const char *revision);
 int TeiNew(void);
 void TeiFree(void);
+
+#ifdef CONFIG_PCI
+
+#include <linux/pci.h>
+
+/* adaptation wrapper for old usage
+ * WARNING! This is unfit for use in a PCI hotplug environment,
+ * as the returned PCI device can disappear at any moment in time.
+ * Callers should be converted to use pci_get_device() instead.
+ */
+static inline struct pci_dev *hisax_find_pci_device(unsigned int vendor,
+                                                    unsigned int device,
+                                                    struct pci_dev *from)
+{
+        struct pci_dev *pdev;
+
+        pci_dev_get(from);
+        pdev = pci_get_subsys(vendor, device, PCI_ANY_ID, PCI_ANY_ID, from);
+        pci_dev_put(pdev);
+        return pdev;
+}
+
+#endif
diff --git a/drivers/isdn/hisax/isar.c b/drivers/isdn/hisax/isar.c
index bfeb9b6aa043..6bde16c00fb5 100644
--- a/drivers/isdn/hisax/isar.c
+++ b/drivers/isdn/hisax/isar.c
@@ -138,7 +138,7 @@ waitrecmsg(struct IsdnCardState *cs, u_char *len,
         while((!(cs->BC_Read_Reg(cs, 0, ISAR_IRQBIT) & ISAR_IRQSTA)) &&
                 (timeout++ < maxdelay))
                 udelay(1);
-        if (timeout >= maxdelay) {
+        if (timeout > maxdelay) {
                 printk(KERN_WARNING"isar recmsg IRQSTA timeout\n");
                 return(0);
         }
diff --git a/drivers/isdn/hisax/niccy.c b/drivers/isdn/hisax/niccy.c
index ef00633e1d2a..ccaa6e13310f 100644
--- a/drivers/isdn/hisax/niccy.c
+++ b/drivers/isdn/hisax/niccy.c
@@ -297,12 +297,12 @@ int __devinit setup_niccy(struct IsdnCard *card)
                         return 0;
                 }
         } else {
-#ifdef CONFIG_PCI_LEGACY
+#ifdef CONFIG_PCI
                 static struct pci_dev *niccy_dev __devinitdata;
 
                 u_int pci_ioaddr;
                 cs->subtyp = 0;
-                if ((niccy_dev = pci_find_device(PCI_VENDOR_ID_SATSAGEM,
+                if ((niccy_dev = hisax_find_pci_device(PCI_VENDOR_ID_SATSAGEM,
                                                  PCI_DEVICE_ID_SATSAGEM_NICCY,
                                                  niccy_dev))) {
                         if (pci_enable_device(niccy_dev))
@@ -354,7 +354,7 @@ int __devinit setup_niccy(struct IsdnCard *card)
                 printk(KERN_WARNING "Niccy: io0 0 and NO_PCI_BIOS\n");
                 printk(KERN_WARNING "Niccy: unable to config NICCY PCI\n");
                 return 0;
-#endif                          /* CONFIG_PCI_LEGACY */
+#endif                          /* CONFIG_PCI */
         }
         printk(KERN_INFO "HiSax: NICCY %s config irq:%d data:0x%X ale:0x%X\n",
                 (cs->subtyp == 1) ? "PnP" : "PCI",
diff --git a/drivers/isdn/hisax/nj_s.c b/drivers/isdn/hisax/nj_s.c
index 8d36ccc87d81..2344e7b33448 100644
--- a/drivers/isdn/hisax/nj_s.c
+++ b/drivers/isdn/hisax/nj_s.c
@@ -276,7 +276,7 @@ setup_netjet_s(struct IsdnCard *card)
 
         for ( ;; )
         {
-                if ((dev_netjet = pci_find_device(PCI_VENDOR_ID_TIGERJET,
+                if ((dev_netjet = hisax_find_pci_device(PCI_VENDOR_ID_TIGERJET,
                         PCI_DEVICE_ID_TIGERJET_300,  dev_netjet))) {
                         ret = njs_pci_probe(dev_netjet, cs);
                         if (!ret)
diff --git a/drivers/isdn/hisax/nj_u.c b/drivers/isdn/hisax/nj_u.c
index d306c946ffba..095e974aed80 100644
--- a/drivers/isdn/hisax/nj_u.c
+++ b/drivers/isdn/hisax/nj_u.c
@@ -240,7 +240,7 @@ setup_netjet_u(struct IsdnCard *card)
 
         for ( ;; )
         {
-                if ((dev_netjet = pci_find_device(PCI_VENDOR_ID_TIGERJET,
+                if ((dev_netjet = hisax_find_pci_device(PCI_VENDOR_ID_TIGERJET,
                         PCI_DEVICE_ID_TIGERJET_300,  dev_netjet))) {
                         ret = nju_pci_probe(dev_netjet, cs);
                         if (!ret)
diff --git a/drivers/isdn/hisax/sedlbauer.c b/drivers/isdn/hisax/sedlbauer.c
index 5569a522e2a1..69dfc8d29017 100644
--- a/drivers/isdn/hisax/sedlbauer.c
+++ b/drivers/isdn/hisax/sedlbauer.c
@@ -598,7 +598,7 @@ setup_sedlbauer_isapnp(struct IsdnCard *card, int *bytecnt)
 }
 #endif /* __ISAPNP__ */
 
-#ifdef CONFIG_PCI_LEGACY
+#ifdef CONFIG_PCI
 static struct pci_dev *dev_sedl __devinitdata = NULL;
 
 static int __devinit
@@ -607,7 +607,7 @@ setup_sedlbauer_pci(struct IsdnCard *card)
         struct IsdnCardState *cs = card->cs;
         u16 sub_vendor_id, sub_id;
 
-        if ((dev_sedl = pci_find_device(PCI_VENDOR_ID_TIGERJET,
+        if ((dev_sedl = hisax_find_pci_device(PCI_VENDOR_ID_TIGERJET,
                         PCI_DEVICE_ID_TIGERJET_100, dev_sedl))) {
                 if (pci_enable_device(dev_sedl))
                         return(0);
@@ -673,7 +673,7 @@ setup_sedlbauer_pci(struct IsdnCard *card)
         return (1);
 }
 
-#endif /* CONFIG_PCI_LEGACY */
+#endif /* CONFIG_PCI */
 
 int __devinit
 setup_sedlbauer(struct IsdnCard *card)
diff --git a/drivers/isdn/hisax/telespci.c b/drivers/isdn/hisax/telespci.c
index 28b08de4673d..b85ceb3746ce 100644
--- a/drivers/isdn/hisax/telespci.c
+++ b/drivers/isdn/hisax/telespci.c
@@ -300,7 +300,7 @@ setup_telespci(struct IsdnCard *card)
         if (cs->typ != ISDN_CTYPE_TELESPCI)
                 return (0);
 
-        if ((dev_tel = pci_find_device (PCI_VENDOR_ID_ZORAN, PCI_DEVICE_ID_ZORAN_36120, dev_tel))) {
+        if ((dev_tel = hisax_find_pci_device (PCI_VENDOR_ID_ZORAN, PCI_DEVICE_ID_ZORAN_36120, dev_tel))) {
                 if (pci_enable_device(dev_tel))
                         return(0);
                 cs->irq = dev_tel->irq;
diff --git a/drivers/isdn/hisax/w6692.c b/drivers/isdn/hisax/w6692.c
index c4d862c11a60..9d6e864023fe 100644
--- a/drivers/isdn/hisax/w6692.c
+++ b/drivers/isdn/hisax/w6692.c
@@ -1007,7 +1007,7 @@ setup_w6692(struct IsdnCard *card)
                 return (0);
 
         while (id_list[id_idx].vendor_id) {
-                dev_w6692 = pci_find_device(id_list[id_idx].vendor_id,
+                dev_w6692 = hisax_find_pci_device(id_list[id_idx].vendor_id,
                                             id_list[id_idx].device_id,
                                             dev_w6692);
                 if (dev_w6692) {
diff --git a/drivers/isdn/hysdn/hycapi.c b/drivers/isdn/hysdn/hycapi.c
index 4ffaa14b9fc4..fe874afa4f81 100644
--- a/drivers/isdn/hysdn/hycapi.c
+++ b/drivers/isdn/hysdn/hycapi.c
@@ -11,6 +11,8 @@
  */
 
 #include <linux/module.h>
+#include <linux/proc_fs.h>
+#include <linux/seq_file.h>
 #include <linux/signal.h>
 #include <linux/kernel.h>
 #include <linux/skbuff.h>
@@ -432,26 +434,16 @@ static u16 hycapi_send_message(struct capi_ctr *ctrl, struct sk_buff *skb)
         return retval;
 }
 
-/*********************************************************************
-hycapi_read_proc
-
-Informations provided in the /proc/capi-entries.
-
-*********************************************************************/
-
-static int hycapi_read_proc(char *page, char **start, off_t off,
-                            int count, int *eof, struct capi_ctr *ctrl)
+static int hycapi_proc_show(struct seq_file *m, void *v)
 {
+        struct capi_ctr *ctrl = m->private;
         hycapictrl_info *cinfo = (hycapictrl_info *)(ctrl->driverdata);
         hysdn_card *card = cinfo->card;
-        int len = 0;
         char *s;
-#ifdef HYCAPI_PRINTFNAMES
-        printk(KERN_NOTICE "hycapi_read_proc\n");    
-#endif
-        len += sprintf(page+len, "%-16s %s\n", "name", cinfo->cardname);
-        len += sprintf(page+len, "%-16s 0x%x\n", "io", card->iobase);
-        len += sprintf(page+len, "%-16s %d\n", "irq", card->irq);
+
+        seq_printf(m, "%-16s %s\n", "name", cinfo->cardname);
+        seq_printf(m, "%-16s 0x%x\n", "io", card->iobase);
+        seq_printf(m, "%-16s %d\n", "irq", card->irq);
     
         switch (card->brdtype) {
                 case BD_PCCARD:  s = "HYSDN Hycard"; break;
@@ -461,24 +453,32 @@ static int hycapi_read_proc(char *page, char **start, off_t off,
                 case BD_PLEXUS: s = "HYSDN Plexus30"; break;
                 default: s = "???"; break;
         }
-        len += sprintf(page+len, "%-16s %s\n", "type", s);
+        seq_printf(m, "%-16s %s\n", "type", s);
         if ((s = cinfo->version[VER_DRIVER]) != NULL)
-                len += sprintf(page+len, "%-16s %s\n", "ver_driver", s);
+                seq_printf(m, "%-16s %s\n", "ver_driver", s);
         if ((s = cinfo->version[VER_CARDTYPE]) != NULL)
-                len += sprintf(page+len, "%-16s %s\n", "ver_cardtype", s);
+                seq_printf(m, "%-16s %s\n", "ver_cardtype", s);
         if ((s = cinfo->version[VER_SERIAL]) != NULL)
-                len += sprintf(page+len, "%-16s %s\n", "ver_serial", s);
+                seq_printf(m, "%-16s %s\n", "ver_serial", s);
     
-        len += sprintf(page+len, "%-16s %s\n", "cardname", cinfo->cardname);
+        seq_printf(m, "%-16s %s\n", "cardname", cinfo->cardname);
     
-        if (off+count >= len)
-                *eof = 1;
-        if (len < off)
-                return 0;
-        *start = page + off;
-        return ((count < len-off) ? count : len-off);
+        return 0;
+}
+
+static int hycapi_proc_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, hycapi_proc_show, PDE(inode)->data);
 }
 
+static const struct file_operations hycapi_proc_fops = {
+        .owner          = THIS_MODULE,
+        .open           = hycapi_proc_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
+
 /**************************************************************
 hycapi_load_firmware
 
@@ -774,7 +774,7 @@ hycapi_capi_create(hysdn_card *card)
                 ctrl->load_firmware = hycapi_load_firmware;
                 ctrl->reset_ctr     = hycapi_reset_ctr;
                 ctrl->procinfo      = hycapi_procinfo;
-                ctrl->ctr_read_proc = hycapi_read_proc;
+                ctrl->proc_fops = &hycapi_proc_fops;
                 strcpy(ctrl->name, cinfo->cardname);
                 ctrl->owner = THIS_MODULE;
 
diff --git a/drivers/isdn/i4l/Kconfig b/drivers/isdn/i4l/Kconfig
index 07c4e49f9e77..9c6650ea848e 100644
--- a/drivers/isdn/i4l/Kconfig
+++ b/drivers/isdn/i4l/Kconfig
@@ -134,14 +134,7 @@ source "drivers/isdn/sc/Kconfig"
 
 source "drivers/isdn/act2000/Kconfig"
 
-source "drivers/isdn/hysdn/Kconfig"
-
 endmenu
 # end ISDN_I4L
 endif
 
-config ISDN_HDLC
-        tristate
-        select CRC_CCITT
-        select BITREVERSE
-