tty: The big operations rework

- Operations are now a shared const function block as with most other Linux
  objects

- Introduce wrappers for some optional functions to get consistent behaviour

- Wrap put_char which used to be patched by the tty layer

- Document which functions are needed/optional

- Make put_char report success/fail

- Cache the driver->ops pointer in the tty as tty->ops

- Remove various surplus lock calls we no longer need

- Remove proc_write method as noted by Alexey Dobriyan

- Introduce some missing sanity checks where certain driver/ldisc
  combinations would oops as they didn't check needed methods were present

[akpm@linux-foundation.org: fix fs/compat_ioctl.c build]
[akpm@linux-foundation.org: fix isicom]
[akpm@linux-foundation.org: fix arch/ia64/hp/sim/simserial.c build]
[akpm@linux-foundation.org: fix kgdb]
Signed-off-by: Alan Cox <alan@redhat.com>
Acked-by: Greg Kroah-Hartman <gregkh@suse.de>
Cc: Jason Wessel <jason.wessel@windriver.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

7 files changed, 209 insertions, 247 deletions

diff --git a/drivers/net/hamradio/6pack.c b/drivers/net/hamradio/6pack.c
index 1da55dd2a5a0..82a36266dfc9 100644
--- a/drivers/net/hamradio/6pack.c
+++ b/drivers/net/hamradio/6pack.c
@@ -148,13 +148,13 @@ static void sp_xmit_on_air(unsigned long channel)
 
         if (((sp->status1 & SIXP_DCD_MASK) == 0) && (random < sp->persistence)) {
                 sp->led_state = 0x70;
-                sp->tty->driver->write(sp->tty, &sp->led_state, 1);
+                sp->tty->ops->write(sp->tty, &sp->led_state, 1);
                 sp->tx_enable = 1;
-                actual = sp->tty->driver->write(sp->tty, sp->xbuff, sp->status2);
+                actual = sp->tty->ops->write(sp->tty, sp->xbuff, sp->status2);
                 sp->xleft -= actual;
                 sp->xhead += actual;
                 sp->led_state = 0x60;
-                sp->tty->driver->write(sp->tty, &sp->led_state, 1);
+                sp->tty->ops->write(sp->tty, &sp->led_state, 1);
                 sp->status2 = 0;
         } else
                 mod_timer(&sp->tx_t, jiffies + ((when + 1) * HZ) / 100);
@@ -220,13 +220,13 @@ static void sp_encaps(struct sixpack *sp, unsigned char *icp, int len)
          */
         if (sp->duplex == 1) {
                 sp->led_state = 0x70;
-                sp->tty->driver->write(sp->tty, &sp->led_state, 1);
+                sp->tty->ops->write(sp->tty, &sp->led_state, 1);
                 sp->tx_enable = 1;
-                actual = sp->tty->driver->write(sp->tty, sp->xbuff, count);
+                actual = sp->tty->ops->write(sp->tty, sp->xbuff, count);
                 sp->xleft = count - actual;
                 sp->xhead = sp->xbuff + actual;
                 sp->led_state = 0x60;
-                sp->tty->driver->write(sp->tty, &sp->led_state, 1);
+                sp->tty->ops->write(sp->tty, &sp->led_state, 1);
         } else {
                 sp->xleft = count;
                 sp->xhead = sp->xbuff;
@@ -444,7 +444,7 @@ static void sixpack_write_wakeup(struct tty_struct *tty)
         }
 
         if (sp->tx_enable) {
-                actual = tty->driver->write(tty, sp->xhead, sp->xleft);
+                actual = tty->ops->write(tty, sp->xhead, sp->xleft);
                 sp->xleft -= actual;
                 sp->xhead += actual;
         }
@@ -492,8 +492,8 @@ static void sixpack_receive_buf(struct tty_struct *tty,
 
         sp_put(sp);
         if (test_and_clear_bit(TTY_THROTTLED, &tty->flags)
-            && tty->driver->unthrottle)
-                tty->driver->unthrottle(tty);
+            && tty->ops->unthrottle)
+                tty->ops->unthrottle(tty);
 }
 
 /*
@@ -554,8 +554,8 @@ static void resync_tnc(unsigned long channel)
         /* resync the TNC */
 
         sp->led_state = 0x60;
-        sp->tty->driver->write(sp->tty, &sp->led_state, 1);
-        sp->tty->driver->write(sp->tty, &resync_cmd, 1);
+        sp->tty->ops->write(sp->tty, &sp->led_state, 1);
+        sp->tty->ops->write(sp->tty, &resync_cmd, 1);
 
 
         /* Start resync timer again -- the TNC might be still absent */
@@ -573,7 +573,7 @@ static inline int tnc_init(struct sixpack *sp)
 
         tnc_set_sync_state(sp, TNC_UNSYNC_STARTUP);
 
-        sp->tty->driver->write(sp->tty, &inbyte, 1);
+        sp->tty->ops->write(sp->tty, &inbyte, 1);
 
         del_timer(&sp->resync_t);
         sp->resync_t.data = (unsigned long) sp;
@@ -601,6 +601,8 @@ static int sixpack_open(struct tty_struct *tty)
 
         if (!capable(CAP_NET_ADMIN))
                 return -EPERM;
+        if (tty->ops->write == NULL)
+                return -EOPNOTSUPP;
 
         dev = alloc_netdev(sizeof(struct sixpack), "sp%d", sp_setup);
         if (!dev) {
@@ -914,9 +916,9 @@ static void decode_prio_command(struct sixpack *sp, unsigned char cmd)
         } else { /* output watchdog char if idle */
                 if ((sp->status2 != 0) && (sp->duplex == 1)) {
                         sp->led_state = 0x70;
-                        sp->tty->driver->write(sp->tty, &sp->led_state, 1);
+                        sp->tty->ops->write(sp->tty, &sp->led_state, 1);
                         sp->tx_enable = 1;
-                        actual = sp->tty->driver->write(sp->tty, sp->xbuff, sp->status2);
+                        actual = sp->tty->ops->write(sp->tty, sp->xbuff, sp->status2);
                         sp->xleft -= actual;
                         sp->xhead += actual;
                         sp->led_state = 0x60;
@@ -926,7 +928,7 @@ static void decode_prio_command(struct sixpack *sp, unsigned char cmd)
         }
 
         /* needed to trigger the TNC watchdog */
-        sp->tty->driver->write(sp->tty, &sp->led_state, 1);
+        sp->tty->ops->write(sp->tty, &sp->led_state, 1);
 
         /* if the state byte has been received, the TNC is present,
            so the resync timer can be reset. */
@@ -956,12 +958,12 @@ static void decode_std_command(struct sixpack *sp, unsigned char cmd)
                         if ((sp->status & SIXP_RX_DCD_MASK) ==
                                 SIXP_RX_DCD_MASK) {
                                 sp->led_state = 0x68;
-                                sp->tty->driver->write(sp->tty, &sp->led_state, 1);
+                                sp->tty->ops->write(sp->tty, &sp->led_state, 1);
                         }
                 } else {
                         sp->led_state = 0x60;
                         /* fill trailing bytes with zeroes */
-                        sp->tty->driver->write(sp->tty, &sp->led_state, 1);
+                        sp->tty->ops->write(sp->tty, &sp->led_state, 1);
                         rest = sp->rx_count;
                         if (rest != 0)
                                  for (i = rest; i <= 3; i++)
diff --git a/drivers/net/hamradio/mkiss.c b/drivers/net/hamradio/mkiss.c
index 30c9b3b0d131..ebcc5adee7cc 100644
--- a/drivers/net/hamradio/mkiss.c
+++ b/drivers/net/hamradio/mkiss.c
@@ -516,7 +516,7 @@ static void ax_encaps(struct net_device *dev, unsigned char *icp, int len)
         spin_unlock_bh(&ax->buflock);
 
         set_bit(TTY_DO_WRITE_WAKEUP, &ax->tty->flags);
-        actual = ax->tty->driver->write(ax->tty, ax->xbuff, count);
+        actual = ax->tty->ops->write(ax->tty, ax->xbuff, count);
         ax->stats.tx_packets++;
         ax->stats.tx_bytes += actual;
 
@@ -546,7 +546,7 @@ static int ax_xmit(struct sk_buff *skb, struct net_device *dev)
                 }
 
                 printk(KERN_ERR "mkiss: %s: transmit timed out, %s?\n", dev->name,
-                       (ax->tty->driver->chars_in_buffer(ax->tty) || ax->xleft) ?
+                       (ax->tty->ops->chars_in_buffer(ax->tty) || ax->xleft) ?
                        "bad line quality" : "driver error");
 
                 ax->xleft = 0;
@@ -736,6 +736,8 @@ static int mkiss_open(struct tty_struct *tty)
 
         if (!capable(CAP_NET_ADMIN))
                 return -EPERM;
+        if (tty->ops->write == NULL)
+                return -EOPNOTSUPP;
 
         dev = alloc_netdev(sizeof(struct mkiss), "ax%d", ax_setup);
         if (!dev) {
@@ -754,8 +756,7 @@ static int mkiss_open(struct tty_struct *tty)
         tty->disc_data = ax;
         tty->receive_room = 65535;
 
-        if (tty->driver->flush_buffer)
-                tty->driver->flush_buffer(tty);
+        tty_driver_flush_buffer(tty);
 
         /* Restore default settings */
         dev->type = ARPHRD_AX25;
@@ -936,8 +937,8 @@ static void mkiss_receive_buf(struct tty_struct *tty, const unsigned char *cp,
 
         mkiss_put(ax);
         if (test_and_clear_bit(TTY_THROTTLED, &tty->flags)
-            && tty->driver->unthrottle)
-                tty->driver->unthrottle(tty);
+            && tty->ops->unthrottle)
+                tty->ops->unthrottle(tty);
 }
 
 /*
@@ -962,7 +963,7 @@ static void mkiss_write_wakeup(struct tty_struct *tty)
                 goto out;
         }
 
-        actual = tty->driver->write(tty, ax->xhead, ax->xleft);
+        actual = tty->ops->write(tty, ax->xhead, ax->xleft);
         ax->xleft -= actual;
         ax->xhead += actual;
 
diff --git a/drivers/net/irda/irtty-sir.c b/drivers/net/irda/irtty-sir.c
index fc753d7f674e..e6f40b7f9041 100644
--- a/drivers/net/irda/irtty-sir.c
+++ b/drivers/net/irda/irtty-sir.c
@@ -64,7 +64,7 @@ static int irtty_chars_in_buffer(struct sir_dev *dev)
         IRDA_ASSERT(priv != NULL, return -1;);
         IRDA_ASSERT(priv->magic == IRTTY_MAGIC, return -1;);
 
-        return priv->tty->driver->chars_in_buffer(priv->tty);
+        return tty_chars_in_buffer(priv->tty);
 }
 
 /* Wait (sleep) until underlaying hardware finished transmission
@@ -93,10 +93,8 @@ static void irtty_wait_until_sent(struct sir_dev *dev)
         IRDA_ASSERT(priv->magic == IRTTY_MAGIC, return;);
 
         tty = priv->tty;
-        if (tty->driver->wait_until_sent) {
-                lock_kernel();
-                tty->driver->wait_until_sent(tty, msecs_to_jiffies(100));
-                unlock_kernel();
+        if (tty->ops->wait_until_sent) {
+                tty->ops->wait_until_sent(tty, msecs_to_jiffies(100));
         }
         else {
                 msleep(USBSERIAL_TX_DONE_DELAY);
@@ -125,48 +123,14 @@ static int irtty_change_speed(struct sir_dev *dev, unsigned speed)
 
         tty = priv->tty;
 
-        lock_kernel();
+        mutex_lock(&tty->termios_mutex);
         old_termios = *(tty->termios);
         cflag = tty->termios->c_cflag;
-
-        cflag &= ~CBAUD;
-
-        IRDA_DEBUG(2, "%s(), Setting speed to %d\n", __FUNCTION__, speed);
-
-        switch (speed) {
-        case 1200:
-                cflag |= B1200;
-                break;
-        case 2400:
-                cflag |= B2400;
-                break;
-        case 4800:
-                cflag |= B4800;
-                break;
-        case 19200:
-                cflag |= B19200;
-                break;
-        case 38400:
-                cflag |= B38400;
-                break;
-        case 57600:
-                cflag |= B57600;
-                break;
-        case 115200:
-                cflag |= B115200;
-                break;
-        case 9600:
-        default:
-                cflag |= B9600;
-                break;
-        }       
-
-        tty->termios->c_cflag = cflag;
-        if (tty->driver->set_termios)
-                tty->driver->set_termios(tty, &old_termios);
-        unlock_kernel();
-
+        tty_encode_baud_rate(tty, speed, speed);
+        if (tty->ops->set_termios)
+                tty->ops->set_termios(tty, &old_termios);
         priv->io.speed = speed;
+        mutex_unlock(&tty->termios_mutex);
 
         return 0;
 }
@@ -202,8 +166,8 @@ static int irtty_set_dtr_rts(struct sir_dev *dev, int dtr, int rts)
          * This function is not yet defined for all tty driver, so
          * let's be careful... Jean II
          */
-        IRDA_ASSERT(priv->tty->driver->tiocmset != NULL, return -1;);
-        priv->tty->driver->tiocmset(priv->tty, NULL, set, clear);
+        IRDA_ASSERT(priv->tty->ops->tiocmset != NULL, return -1;);
+        priv->tty->ops->tiocmset(priv->tty, NULL, set, clear);
 
         return 0;
 }
@@ -225,17 +189,13 @@ static int irtty_do_write(struct sir_dev *dev, const unsigned char *ptr, size_t
         IRDA_ASSERT(priv->magic == IRTTY_MAGIC, return -1;);
 
         tty = priv->tty;
-        if (!tty->driver->write)
+        if (!tty->ops->write)
                 return 0;
         tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
-        if (tty->driver->write_room) {
-                writelen = tty->driver->write_room(tty);
-                if (writelen > len)
-                        writelen = len;
-        }
-        else
+        writelen = tty_write_room(tty);
+        if (writelen > len)
                 writelen = len;
-        return tty->driver->write(tty, ptr, writelen);
+        return tty->ops->write(tty, ptr, writelen);
 }
 
 /* ------------------------------------------------------- */
@@ -321,7 +281,7 @@ static inline void irtty_stop_receiver(struct tty_struct *tty, int stop)
         struct ktermios old_termios;
         int cflag;
 
-        lock_kernel();
+        mutex_lock(&tty->termios_mutex);
         old_termios = *(tty->termios);
         cflag = tty->termios->c_cflag;
         
@@ -331,9 +291,9 @@ static inline void irtty_stop_receiver(struct tty_struct *tty, int stop)
                 cflag |= CREAD;
 
         tty->termios->c_cflag = cflag;
-        if (tty->driver->set_termios)
-                tty->driver->set_termios(tty, &old_termios);
-        unlock_kernel();
+        if (tty->ops->set_termios)
+                tty->ops->set_termios(tty, &old_termios);
+        mutex_unlock(&tty->termios_mutex);
 }
 
 /*****************************************************************/
@@ -359,8 +319,8 @@ static int irtty_start_dev(struct sir_dev *dev)
 
         tty = priv->tty;
 
-        if (tty->driver->start)
-                tty->driver->start(tty);
+        if (tty->ops->start)
+                tty->ops->start(tty);
         /* Make sure we can receive more data */
         irtty_stop_receiver(tty, FALSE);
 
@@ -388,8 +348,8 @@ static int irtty_stop_dev(struct sir_dev *dev)
 
         /* Make sure we don't receive more data */
         irtty_stop_receiver(tty, TRUE);
-        if (tty->driver->stop)
-                tty->driver->stop(tty);
+        if (tty->ops->stop)
+                tty->ops->stop(tty);
 
         mutex_unlock(&irtty_mutex);
 
@@ -483,11 +443,10 @@ static int irtty_open(struct tty_struct *tty)
 
         /* stop the underlying  driver */
         irtty_stop_receiver(tty, TRUE);
-        if (tty->driver->stop)
-                tty->driver->stop(tty);
+        if (tty->ops->stop)
+                tty->ops->stop(tty);
 
-        if (tty->driver->flush_buffer)
-                tty->driver->flush_buffer(tty);
+        tty_driver_flush_buffer(tty);
         
         /* apply mtt override */
         sir_tty_drv.qos_mtt_bits = qos_mtt_bits;
@@ -564,8 +523,8 @@ static void irtty_close(struct tty_struct *tty)
         /* Stop tty */
         irtty_stop_receiver(tty, TRUE);
         tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
-        if (tty->driver->stop)
-                tty->driver->stop(tty);
+        if (tty->ops->stop)
+                tty->ops->stop(tty);
 
         kfree(priv);
 
diff --git a/drivers/net/ppp_async.c b/drivers/net/ppp_async.c
index f023d5b67e6e..1c4b7e37912c 100644
--- a/drivers/net/ppp_async.c
+++ b/drivers/net/ppp_async.c
@@ -158,6 +158,9 @@ ppp_asynctty_open(struct tty_struct *tty)
         struct asyncppp *ap;
         int err;
 
+        if (tty->ops->write == NULL)
+                return -EOPNOTSUPP;
+
         err = -ENOMEM;
         ap = kzalloc(sizeof(*ap), GFP_KERNEL);
         if (!ap)
@@ -359,8 +362,8 @@ ppp_asynctty_receive(struct tty_struct *tty, const unsigned char *buf,
                 tasklet_schedule(&ap->tsk);
         ap_put(ap);
         if (test_and_clear_bit(TTY_THROTTLED, &tty->flags)
-            && tty->driver->unthrottle)
-                tty->driver->unthrottle(tty);
+            && tty->ops->unthrottle)
+                tty->ops->unthrottle(tty);
 }
 
 static void
@@ -676,7 +679,7 @@ ppp_async_push(struct asyncppp *ap)
                 if (!tty_stuffed && ap->optr < ap->olim) {
                         avail = ap->olim - ap->optr;
                         set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
-                        sent = tty->driver->write(tty, ap->optr, avail);
+                        sent = tty->ops->write(tty, ap->optr, avail);
                         if (sent < 0)
                                 goto flush;     /* error, e.g. loss of CD */
                         ap->optr += sent;
diff --git a/drivers/net/ppp_synctty.c b/drivers/net/ppp_synctty.c
index 0d80fa546719..48ed5fdbfe18 100644
--- a/drivers/net/ppp_synctty.c
+++ b/drivers/net/ppp_synctty.c
@@ -207,6 +207,9 @@ ppp_sync_open(struct tty_struct *tty)
         struct syncppp *ap;
         int err;
 
+        if (tty->ops->write == NULL)
+                return -EOPNOTSUPP;
+
         ap = kzalloc(sizeof(*ap), GFP_KERNEL);
         err = -ENOMEM;
         if (!ap)
@@ -399,8 +402,8 @@ ppp_sync_receive(struct tty_struct *tty, const unsigned char *buf,
                 tasklet_schedule(&ap->tsk);
         sp_put(ap);
         if (test_and_clear_bit(TTY_THROTTLED, &tty->flags)
-            && tty->driver->unthrottle)
-                tty->driver->unthrottle(tty);
+            && tty->ops->unthrottle)
+                tty->ops->unthrottle(tty);
 }
 
 static void
@@ -653,7 +656,7 @@ ppp_sync_push(struct syncppp *ap)
                         tty_stuffed = 0;
                 if (!tty_stuffed && ap->tpkt) {
                         set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
-                        sent = tty->driver->write(tty, ap->tpkt->data, ap->tpkt->len);
+                        sent = tty->ops->write(tty, ap->tpkt->data, ap->tpkt->len);
                         if (sent < 0)
                                 goto flush;     /* error, e.g. loss of CD */
                         if (sent < ap->tpkt->len) {
diff --git a/drivers/net/slip.c b/drivers/net/slip.c
index 5a55ede352f4..84af68fdb6c2 100644
--- a/drivers/net/slip.c
+++ b/drivers/net/slip.c
@@ -396,14 +396,14 @@ static void sl_encaps(struct slip *sl, unsigned char *icp, int len)
 
         /* Order of next two lines is *very* important.
          * When we are sending a little amount of data,
-         * the transfer may be completed inside driver.write()
+         * the transfer may be completed inside the ops->write()
          * routine, because it's running with interrupts enabled.
          * In this case we *never* got WRITE_WAKEUP event,
          * if we did not request it before write operation.
          *       14 Oct 1994  Dmitry Gorodchanin.
          */
         sl->tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
-        actual = sl->tty->driver->write(sl->tty, sl->xbuff, count);
+        actual = sl->tty->ops->write(sl->tty, sl->xbuff, count);
 #ifdef SL_CHECK_TRANSMIT
         sl->dev->trans_start = jiffies;
 #endif
@@ -437,7 +437,7 @@ static void slip_write_wakeup(struct tty_struct *tty)
                 return;
         }
 
-        actual = tty->driver->write(tty, sl->xhead, sl->xleft);
+        actual = tty->ops->write(tty, sl->xhead, sl->xleft);
         sl->xleft -= actual;
         sl->xhead += actual;
 }
@@ -462,7 +462,7 @@ static void sl_tx_timeout(struct net_device *dev)
                 }
                 printk(KERN_WARNING "%s: transmit timed out, %s?\n",
                         dev->name,
-                        (sl->tty->driver->chars_in_buffer(sl->tty) || sl->xleft) ?
+                        (tty_chars_in_buffer(sl->tty) || sl->xleft) ?
                                 "bad line quality" : "driver error");
                 sl->xleft = 0;
                 sl->tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
@@ -830,6 +830,9 @@ static int slip_open(struct tty_struct *tty)
         if (!capable(CAP_NET_ADMIN))
                 return -EPERM;
 
+        if (tty->ops->write == NULL)
+                return -EOPNOTSUPP;
+
         /* RTnetlink lock is misused here to serialize concurrent
            opens of slip channels. There are better ways, but it is
            the simplest one.
@@ -1432,7 +1435,7 @@ static void sl_outfill(unsigned long sls)
                         /* put END into tty queue. Is it right ??? */
                         if (!netif_queue_stopped(sl->dev)) {
                                 /* if device busy no outfill */
-                                sl->tty->driver->write(sl->tty, &s, 1);
+                                sl->tty->ops->write(sl->tty, &s, 1);
                         }
                 } else
                         set_bit(SLF_OUTWAIT, &sl->flags);
diff --git a/drivers/net/wan/x25_asy.c b/drivers/net/wan/x25_asy.c
index 0f8aca8a4d43..249e18053d5f 100644
--- a/drivers/net/wan/x25_asy.c
+++ b/drivers/net/wan/x25_asy.c
@@ -17,7 +17,7 @@
 #include <linux/module.h>
 
 #include <asm/system.h>
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
 #include <linux/bitops.h>
 #include <linux/string.h>
 #include <linux/mm.h>
@@ -95,7 +95,7 @@ static struct x25_asy *x25_asy_alloc(void)
                         x25_asy_devs[i] = dev;
                         return sl;
                 } else {
-                        printk("x25_asy_alloc() - register_netdev() failure.\n");
+                        printk(KERN_WARNING "x25_asy_alloc() - register_netdev() failure.\n");
                         free_netdev(dev);
                 }
         }
@@ -112,23 +112,22 @@ static void x25_asy_free(struct x25_asy *sl)
         kfree(sl->xbuff);
         sl->xbuff = NULL;
 
-        if (!test_and_clear_bit(SLF_INUSE, &sl->flags)) {
-                printk("%s: x25_asy_free for already free unit.\n", sl->dev->name);
-        }
+        if (!test_and_clear_bit(SLF_INUSE, &sl->flags))
+                printk(KERN_ERR "%s: x25_asy_free for already free unit.\n",
+                        sl->dev->name);
 }
 
 static int x25_asy_change_mtu(struct net_device *dev, int newmtu)
 {
         struct x25_asy *sl = dev->priv;
         unsigned char *xbuff, *rbuff;
-        int len = 2* newmtu;
+        int len = 2 * newmtu;
 
         xbuff = kmalloc(len + 4, GFP_ATOMIC);
         rbuff = kmalloc(len + 4, GFP_ATOMIC);
 
-        if (xbuff == NULL || rbuff == NULL)  
-        {
-                printk("%s: unable to grow X.25 buffers, MTU change cancelled.\n",
+        if (xbuff == NULL || rbuff == NULL) {
+                printk(KERN_WARNING "%s: unable to grow X.25 buffers, MTU change cancelled.\n",
                        dev->name);
                 kfree(xbuff);
                 kfree(rbuff);
@@ -193,25 +192,23 @@ static void x25_asy_bump(struct x25_asy *sl)
         int err;
 
         count = sl->rcount;
-        sl->stats.rx_bytes+=count;
-        
+        sl->stats.rx_bytes += count;
+
         skb = dev_alloc_skb(count+1);
-        if (skb == NULL)  
-        {
-                printk("%s: memory squeeze, dropping packet.\n", sl->dev->name);
+        if (skb == NULL) {
+                printk(KERN_WARNING "%s: memory squeeze, dropping packet.\n",
+                        sl->dev->name);
                 sl->stats.rx_dropped++;
                 return;
         }
-        skb_push(skb,1);        /* LAPB internal control */
-        memcpy(skb_put(skb,count), sl->rbuff, count);
+        skb_push(skb, 1);       /* LAPB internal control */
+        memcpy(skb_put(skb, count), sl->rbuff, count);
         skb->protocol = x25_type_trans(skb, sl->dev);
-        if((err=lapb_data_received(skb->dev, skb))!=LAPB_OK)
-        {
+        err = lapb_data_received(skb->dev, skb);
+        if (err != LAPB_OK) {
                 kfree_skb(skb);
-                printk(KERN_DEBUG "x25_asy: data received err - %d\n",err);
-        }
-        else
-        {
+                printk(KERN_DEBUG "x25_asy: data received err - %d\n", err);
+        } else {
                 netif_rx(skb);
                 sl->dev->last_rx = jiffies;
                 sl->stats.rx_packets++;
@@ -224,10 +221,11 @@ static void x25_asy_encaps(struct x25_asy *sl, unsigned char *icp, int len)
         unsigned char *p;
         int actual, count, mtu = sl->dev->mtu;
 
-        if (len > mtu) 
-        {               /* Sigh, shouldn't occur BUT ... */
+        if (len > mtu) {
+                /* Sigh, shouldn't occur BUT ... */
                 len = mtu;
-                printk ("%s: truncating oversized transmit packet!\n", sl->dev->name);
+                printk(KERN_DEBUG "%s: truncating oversized transmit packet!\n",
+                                        sl->dev->name);
                 sl->stats.tx_dropped++;
                 x25_asy_unlock(sl);
                 return;
@@ -245,7 +243,7 @@ static void x25_asy_encaps(struct x25_asy *sl, unsigned char *icp, int len)
          *       14 Oct 1994  Dmitry Gorodchanin.
          */
         sl->tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
-        actual = sl->tty->driver->write(sl->tty, sl->xbuff, count);
+        actual = sl->tty->ops->write(sl->tty, sl->xbuff, count);
         sl->xleft = count - actual;
         sl->xhead = sl->xbuff + actual;
         /* VSV */
@@ -265,8 +263,7 @@ static void x25_asy_write_wakeup(struct tty_struct *tty)
         if (!sl || sl->magic != X25_ASY_MAGIC || !netif_running(sl->dev))
                 return;
 
-        if (sl->xleft <= 0)  
-        {
+        if (sl->xleft <= 0) {
                 /* Now serial buffer is almost free & we can start
                  * transmission of another packet */
                 sl->stats.tx_packets++;
@@ -275,14 +272,14 @@ static void x25_asy_write_wakeup(struct tty_struct *tty)
                 return;
         }
 
-        actual = tty->driver->write(tty, sl->xhead, sl->xleft);
+        actual = tty->ops->write(tty, sl->xhead, sl->xleft);
         sl->xleft -= actual;
         sl->xhead += actual;
 }
 
 static void x25_asy_timeout(struct net_device *dev)
 {
-        struct x25_asy *sl = (struct x25_asy*)(dev->priv);
+        struct x25_asy *sl = dev->priv;
 
         spin_lock(&sl->lock);
         if (netif_queue_stopped(dev)) {
@@ -290,7 +287,7 @@ static void x25_asy_timeout(struct net_device *dev)
                  *      14 Oct 1994 Dmitry Gorodchanin.
                  */
                 printk(KERN_WARNING "%s: transmit timed out, %s?\n", dev->name,
-                       (sl->tty->driver->chars_in_buffer(sl->tty) || sl->xleft) ?
+                       (tty_chars_in_buffer(sl->tty) || sl->xleft) ?
                        "bad line quality" : "driver error");
                 sl->xleft = 0;
                 sl->tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
@@ -303,31 +300,34 @@ static void x25_asy_timeout(struct net_device *dev)
 
 static int x25_asy_xmit(struct sk_buff *skb, struct net_device *dev)
 {
-        struct x25_asy *sl = (struct x25_asy*)(dev->priv);
+        struct x25_asy *sl = dev->priv;
         int err;
 
         if (!netif_running(sl->dev)) {
-                printk("%s: xmit call when iface is down\n", dev->name);
+                printk(KERN_ERR "%s: xmit call when iface is down\n",
+                        dev->name);
                 kfree_skb(skb);
                 return 0;
         }
-        
-        switch(skb->data[0])
-        {
-                case 0x00:break;
-                case 0x01: /* Connection request .. do nothing */
-                        if((err=lapb_connect_request(dev))!=LAPB_OK)
-                                printk(KERN_ERR "x25_asy: lapb_connect_request error - %d\n", err);
-                        kfree_skb(skb);
-                        return 0;
-                case 0x02: /* Disconnect request .. do nothing - hang up ?? */
-                        if((err=lapb_disconnect_request(dev))!=LAPB_OK)
-                                printk(KERN_ERR "x25_asy: lapb_disconnect_request error - %d\n", err);
-                default:
-                        kfree_skb(skb);
-                        return  0;
+
+        switch (skb->data[0]) {
+        case 0x00:
+                break;
+        case 0x01: /* Connection request .. do nothing */
+                err = lapb_connect_request(dev);
+                if (err != LAPB_OK)
+                        printk(KERN_ERR "x25_asy: lapb_connect_request error - %d\n", err);
+                kfree_skb(skb);
+                return 0;
+        case 0x02: /* Disconnect request .. do nothing - hang up ?? */
+                err = lapb_disconnect_request(dev);
+                if (err != LAPB_OK)
+                        printk(KERN_ERR "x25_asy: lapb_disconnect_request error - %d\n", err);
+        default:
+                kfree_skb(skb);
+                return  0;
         }
-        skb_pull(skb,1);        /* Remove control byte */
+        skb_pull(skb, 1);       /* Remove control byte */
         /*
          * If we are busy already- too bad.  We ought to be able
          * to queue things at this point, to allow for a little
@@ -338,10 +338,10 @@ static int x25_asy_xmit(struct sk_buff *skb, struct net_device *dev)
          * So, no queues !
          *        14 Oct 1994  Dmitry Gorodchanin.
          */
-        
-        if((err=lapb_data_request(dev,skb))!=LAPB_OK)
-        {
-                printk(KERN_ERR "lapbeth: lapb_data_request error - %d\n", err);
+
+        err = lapb_data_request(dev, skb);
+        if (err != LAPB_OK) {
+                printk(KERN_ERR "x25_asy: lapb_data_request error - %d\n", err);
                 kfree_skb(skb);
                 return 0;
         }
@@ -357,7 +357,7 @@ static int x25_asy_xmit(struct sk_buff *skb, struct net_device *dev)
  *      Called when I frame data arrives. We did the work above - throw it
  *      at the net layer.
  */
-  
+
 static int x25_asy_data_indication(struct net_device *dev, struct sk_buff *skb)
 {
         skb->dev->last_rx = jiffies;
@@ -369,24 +369,22 @@ static int x25_asy_data_indication(struct net_device *dev, struct sk_buff *skb)
  *      busy cases too well. Its tricky to see how to do this nicely -
  *      perhaps lapb should allow us to bounce this ?
  */
- 
+
 static void x25_asy_data_transmit(struct net_device *dev, struct sk_buff *skb)
 {
-        struct x25_asy *sl=dev->priv;
-        
+        struct x25_asy *sl = dev->priv;
+
         spin_lock(&sl->lock);
-        if (netif_queue_stopped(sl->dev) || sl->tty == NULL)
-        {
+        if (netif_queue_stopped(sl->dev) || sl->tty == NULL) {
                 spin_unlock(&sl->lock);
                 printk(KERN_ERR "x25_asy: tbusy drop\n");
                 kfree_skb(skb);
                 return;
         }
         /* We were not busy, so we are now... :-) */
-        if (skb != NULL) 
-        {
+        if (skb != NULL) {
                 x25_asy_lock(sl);
-                sl->stats.tx_bytes+=skb->len;
+                sl->stats.tx_bytes += skb->len;
                 x25_asy_encaps(sl, skb->data, skb->len);
                 dev_kfree_skb(skb);
         }
@@ -396,15 +394,16 @@ static void x25_asy_data_transmit(struct net_device *dev, struct sk_buff *skb)
 /*
  *      LAPB connection establish/down information.
  */
- 
+
 static void x25_asy_connected(struct net_device *dev, int reason)
 {
         struct x25_asy *sl = dev->priv;
         struct sk_buff *skb;
         unsigned char *ptr;
 
-        if ((skb = dev_alloc_skb(1)) == NULL) {
-                printk(KERN_ERR "lapbeth: out of memory\n");
+        skb = dev_alloc_skb(1);
+        if (skb == NULL) {
+                printk(KERN_ERR "x25_asy: out of memory\n");
                 return;
         }
 
@@ -422,7 +421,8 @@ static void x25_asy_disconnected(struct net_device *dev, int reason)
         struct sk_buff *skb;
         unsigned char *ptr;
 
-        if ((skb = dev_alloc_skb(1)) == NULL) {
+        skb = dev_alloc_skb(1);
+        if (skb == NULL) {
                 printk(KERN_ERR "x25_asy: out of memory\n");
                 return;
         }
@@ -449,7 +449,7 @@ static struct lapb_register_struct x25_asy_callbacks = {
 /* Open the low-level part of the X.25 channel. Easy! */
 static int x25_asy_open(struct net_device *dev)
 {
-        struct x25_asy *sl = (struct x25_asy*)(dev->priv);
+        struct x25_asy *sl = dev->priv;
         unsigned long len;
         int err;
 
@@ -466,13 +466,11 @@ static int x25_asy_open(struct net_device *dev)
         len = dev->mtu * 2;
 
         sl->rbuff = kmalloc(len + 4, GFP_KERNEL);
-        if (sl->rbuff == NULL)   {
+        if (sl->rbuff == NULL)
                 goto norbuff;
-        }
         sl->xbuff = kmalloc(len + 4, GFP_KERNEL);
-        if (sl->xbuff == NULL)   {
+        if (sl->xbuff == NULL)
                 goto noxbuff;
-        }
 
         sl->buffsize = len;
         sl->rcount   = 0;
@@ -480,11 +478,12 @@ static int x25_asy_open(struct net_device *dev)
         sl->flags   &= (1 << SLF_INUSE);      /* Clear ESCAPE & ERROR flags */
 
         netif_start_queue(dev);
-                        
+
         /*
          *      Now attach LAPB
          */
-        if((err=lapb_register(dev, &x25_asy_callbacks))==LAPB_OK)
+        err = lapb_register(dev, &x25_asy_callbacks);
+        if (err == LAPB_OK)
                 return 0;
 
         /* Cleanup */
@@ -499,18 +498,20 @@ norbuff:
 /* Close the low-level part of the X.25 channel. Easy! */
 static int x25_asy_close(struct net_device *dev)
 {
-        struct x25_asy *sl = (struct x25_asy*)(dev->priv);
+        struct x25_asy *sl = dev->priv;
         int err;
 
         spin_lock(&sl->lock);
-        if (sl->tty) 
+        if (sl->tty)
                 sl->tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
 
         netif_stop_queue(dev);
         sl->rcount = 0;
         sl->xleft  = 0;
-        if((err=lapb_unregister(dev))!=LAPB_OK)
-                printk(KERN_ERR "x25_asy_close: lapb_unregister error -%d\n",err);
+        err = lapb_unregister(dev);
+        if (err != LAPB_OK)
+                printk(KERN_ERR "x25_asy_close: lapb_unregister error -%d\n",
+                        err);
         spin_unlock(&sl->lock);
         return 0;
 }
@@ -521,8 +522,9 @@ static int x25_asy_close(struct net_device *dev)
  * a block of X.25 data has been received, which can now be decapsulated
  * and sent on to some IP layer for further processing.
  */
- 
-static void x25_asy_receive_buf(struct tty_struct *tty, const unsigned char *cp, char *fp, int count)
+
+static void x25_asy_receive_buf(struct tty_struct *tty,
+                                const unsigned char *cp, char *fp, int count)
 {
         struct x25_asy *sl = (struct x25_asy *) tty->disc_data;
 
@@ -533,9 +535,8 @@ static void x25_asy_receive_buf(struct tty_struct *tty, const unsigned char *cp,
         /* Read the characters out of the buffer */
         while (count--) {
                 if (fp && *fp++) {
-                        if (!test_and_set_bit(SLF_ERROR, &sl->flags))  {
+                        if (!test_and_set_bit(SLF_ERROR, &sl->flags))
                                 sl->stats.rx_errors++;
-                        }
                         cp++;
                         continue;
                 }
@@ -556,31 +557,31 @@ static int x25_asy_open_tty(struct tty_struct *tty)
         struct x25_asy *sl = (struct x25_asy *) tty->disc_data;
         int err;
 
+        if (tty->ops->write == NULL)
+                return -EOPNOTSUPP;
+
         /* First make sure we're not already connected. */
-        if (sl && sl->magic == X25_ASY_MAGIC) {
+        if (sl && sl->magic == X25_ASY_MAGIC)
                 return -EEXIST;
-        }
 
         /* OK.  Find a free X.25 channel to use. */
-        if ((sl = x25_asy_alloc()) == NULL) {
+        sl = x25_asy_alloc();
+        if (sl == NULL)
                 return -ENFILE;
-        }
 
         sl->tty = tty;
         tty->disc_data = sl;
         tty->receive_room = 65536;
-        if (tty->driver->flush_buffer)  {
-                tty->driver->flush_buffer(tty);
-        }
+        tty_driver_flush_buffer(tty);
         tty_ldisc_flush(tty);
 
         /* Restore default settings */
         sl->dev->type = ARPHRD_X25;
-        
+
         /* Perform the low-level X.25 async init */
-        if ((err = x25_asy_open(sl->dev)))
+        err = x25_asy_open(sl->dev);
+        if (err)
                 return err;
-
         /* Done.  We have linked the TTY line to a channel. */
         return sl->dev->base_addr;
 }
@@ -601,9 +602,7 @@ static void x25_asy_close_tty(struct tty_struct *tty)
                 return;
 
         if (sl->dev->flags & IFF_UP)
-        {
-                (void) dev_close(sl->dev);
-        }
+                dev_close(sl->dev);
 
         tty->disc_data = NULL;
         sl->tty = NULL;
@@ -613,8 +612,7 @@ static void x25_asy_close_tty(struct tty_struct *tty)
 
 static struct net_device_stats *x25_asy_get_stats(struct net_device *dev)
 {
-        struct x25_asy *sl = (struct x25_asy*)(dev->priv);
-
+        struct x25_asy *sl = dev->priv;
         return &sl->stats;
 }
 
@@ -641,21 +639,19 @@ int x25_asy_esc(unsigned char *s, unsigned char *d, int len)
          * character sequence, according to the X.25 protocol.
          */
 
-        while (len-- > 0) 
-        {
-                switch(c = *s++) 
-                {
-                        case X25_END:
-                                *ptr++ = X25_ESC;
-                                *ptr++ = X25_ESCAPE(X25_END);
-                                break;
-                        case X25_ESC:
-                                *ptr++ = X25_ESC;
-                                *ptr++ = X25_ESCAPE(X25_ESC);
-                                break;
-                         default:
-                                *ptr++ = c;
-                                break;
+        while (len-- > 0) {
+                switch (c = *s++) {
+                case X25_END:
+                        *ptr++ = X25_ESC;
+                        *ptr++ = X25_ESCAPE(X25_END);
+                        break;
+                case X25_ESC:
+                        *ptr++ = X25_ESC;
+                        *ptr++ = X25_ESCAPE(X25_ESC);
+                        break;
+                default:
+                        *ptr++ = c;
+                        break;
                 }
         }
         *ptr++ = X25_END;
@@ -665,31 +661,25 @@ int x25_asy_esc(unsigned char *s, unsigned char *d, int len)
 static void x25_asy_unesc(struct x25_asy *sl, unsigned char s)
 {
 
-        switch(s) 
-        {
-                case X25_END:
-                        if (!test_and_clear_bit(SLF_ERROR, &sl->flags) && (sl->rcount > 2))  
-                        {
-                                x25_asy_bump(sl);
-                        }
-                        clear_bit(SLF_ESCAPE, &sl->flags);
-                        sl->rcount = 0;
-                        return;
-
-                case X25_ESC:
-                        set_bit(SLF_ESCAPE, &sl->flags);
-                        return;
-                        
-                case X25_ESCAPE(X25_ESC):
-                case X25_ESCAPE(X25_END):
-                        if (test_and_clear_bit(SLF_ESCAPE, &sl->flags))
-                                s = X25_UNESCAPE(s);
-                        break;
-        }
-        if (!test_bit(SLF_ERROR, &sl->flags))  
-        {
-                if (sl->rcount < sl->buffsize)  
-                {
+        switch (s) {
+        case X25_END:
+                if (!test_and_clear_bit(SLF_ERROR, &sl->flags)
+                        && sl->rcount > 2)
+                        x25_asy_bump(sl);
+                clear_bit(SLF_ESCAPE, &sl->flags);
+                sl->rcount = 0;
+                return;
+        case X25_ESC:
+                set_bit(SLF_ESCAPE, &sl->flags);
+                return;
+        case X25_ESCAPE(X25_ESC):
+        case X25_ESCAPE(X25_END):
+                if (test_and_clear_bit(SLF_ESCAPE, &sl->flags))
+                        s = X25_UNESCAPE(s);
+                break;
+        }
+        if (!test_bit(SLF_ERROR, &sl->flags)) {
+                if (sl->rcount < sl->buffsize) {
                         sl->rbuff[sl->rcount++] = s;
                         return;
                 }
@@ -709,7 +699,7 @@ static int x25_asy_ioctl(struct tty_struct *tty, struct file *file,
         if (!sl || sl->magic != X25_ASY_MAGIC)
                 return -EINVAL;
 
-        switch(cmd) {
+        switch (cmd) {
         case SIOCGIFNAME:
                 if (copy_to_user((void __user *)arg, sl->dev->name,
                                         strlen(sl->dev->name) + 1))
@@ -724,8 +714,8 @@ static int x25_asy_ioctl(struct tty_struct *tty, struct file *file,
 
 static int x25_asy_open_dev(struct net_device *dev)
 {
-        struct x25_asy *sl = (struct x25_asy*)(dev->priv);
-        if(sl->tty==NULL)
+        struct x25_asy *sl = dev->priv;
+        if (sl->tty == NULL)
                 return -ENODEV;
         return 0;
 }
@@ -741,9 +731,9 @@ static void x25_asy_setup(struct net_device *dev)
         set_bit(SLF_INUSE, &sl->flags);
 
         /*
-         *      Finish setting up the DEVICE info. 
+         *      Finish setting up the DEVICE info.
          */
-         
+
         dev->mtu                = SL_MTU;
         dev->hard_start_xmit    = x25_asy_xmit;
         dev->tx_timeout         = x25_asy_timeout;
@@ -778,9 +768,10 @@ static int __init init_x25_asy(void)
                 x25_asy_maxdev = 4; /* Sanity */
 
         printk(KERN_INFO "X.25 async: version 0.00 ALPHA "
-                        "(dynamic channels, max=%d).\n", x25_asy_maxdev );
+                        "(dynamic channels, max=%d).\n", x25_asy_maxdev);
 
-        x25_asy_devs = kcalloc(x25_asy_maxdev, sizeof(struct net_device*), GFP_KERNEL);
+        x25_asy_devs = kcalloc(x25_asy_maxdev, sizeof(struct net_device *),
+                                GFP_KERNEL);
         if (!x25_asy_devs) {
                 printk(KERN_WARNING "X25 async: Can't allocate x25_asy_ctrls[] "
                                 "array! Uaargh! (-> No X.25 available)\n");
@@ -802,7 +793,7 @@ static void __exit exit_x25_asy(void)
                         struct x25_asy *sl = dev->priv;
 
                         spin_lock_bh(&sl->lock);
-                        if (sl->tty) 
+                        if (sl->tty)
                                 tty_hangup(sl->tty);
 
                         spin_unlock_bh(&sl->lock);