41 files changed, 1790 insertions, 1694 deletions

diff --git a/drivers/usb/serial/aircable.c b/drivers/usb/serial/aircable.c
index db6f97a93c02..79ea98c66fa8 100644
--- a/drivers/usb/serial/aircable.c
+++ b/drivers/usb/serial/aircable.c
@@ -272,7 +272,7 @@ static void aircable_read(struct work_struct *work)
          * 64 bytes, to ensure I do not get throttled.
          * Ask USB mailing list for better aproach.
          */
-        tty = port->tty;
+        tty = port->port.tty;
 
         if (!tty) {
                 schedule_work(&priv->rx_work);
@@ -378,13 +378,14 @@ static void aircable_shutdown(struct usb_serial *serial)
         }
 }
 
-static int aircable_write_room(struct usb_serial_port *port)
+static int aircable_write_room(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct aircable_private *priv = usb_get_serial_port_data(port);
         return serial_buf_data_avail(priv->tx_buf);
 }
 
-static int aircable_write(struct usb_serial_port *port,
+static int aircable_write(struct tty_struct *tty, struct usb_serial_port *port,
                           const unsigned char *source, int count)
 {
         struct aircable_private *priv = usb_get_serial_port_data(port);
@@ -466,7 +467,7 @@ static void aircable_read_bulk_callback(struct urb *urb)
 
         if (status) {
                 dbg("%s - urb status = %d", __func__, status);
-                if (!port->open_count) {
+                if (!port->port.count) {
                         dbg("%s - port is closed, exiting.", __func__);
                         return;
                 }
@@ -494,7 +495,7 @@ static void aircable_read_bulk_callback(struct urb *urb)
         usb_serial_debug_data(debug, &port->dev, __func__,
                                 urb->actual_length, urb->transfer_buffer);
 
-        tty = port->tty;
+        tty = port->port.tty;
         if (tty && urb->actual_length) {
                 if (urb->actual_length <= 2) {
                         /* This is an incomplete package */
@@ -528,7 +529,7 @@ static void aircable_read_bulk_callback(struct urb *urb)
         }
 
         /* Schedule the next read _if_ we are still open */
-        if (port->open_count) {
+        if (port->port.count) {
                 usb_fill_bulk_urb(port->read_urb, port->serial->dev,
                                   usb_rcvbulkpipe(port->serial->dev,
                                           port->bulk_in_endpointAddress),
@@ -547,8 +548,9 @@ static void aircable_read_bulk_callback(struct urb *urb)
 }
 
 /* Based on ftdi_sio.c throttle */
-static void aircable_throttle(struct usb_serial_port *port)
+static void aircable_throttle(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct aircable_private *priv = usb_get_serial_port_data(port);
         unsigned long flags;
 
@@ -560,8 +562,9 @@ static void aircable_throttle(struct usb_serial_port *port)
 }
 
 /* Based on ftdi_sio.c unthrottle */
-static void aircable_unthrottle(struct usb_serial_port *port)
+static void aircable_unthrottle(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct aircable_private *priv = usb_get_serial_port_data(port);
         int actually_throttled;
         unsigned long flags;
diff --git a/drivers/usb/serial/airprime.c b/drivers/usb/serial/airprime.c
new file mode 100644
index 000000000000..b3f1d1e82468
--- /dev/null
+++ b/drivers/usb/serial/airprime.c
@@ -0,0 +1,355 @@
+/*
+ * AirPrime CDMA Wireless Serial USB driver
+ *
+ * Copyright (C) 2005-2006 Greg Kroah-Hartman <gregkh@suse.de>
+ *
+ *      This program is free software; you can redistribute it and/or
+ *      modify it under the terms of the GNU General Public License version
+ *      2 as published by the Free Software Foundation.
+ */
+
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/tty.h>
+#include <linux/tty_flip.h>
+#include <linux/module.h>
+#include <linux/usb.h>
+#include <linux/usb/serial.h>
+
+static struct usb_device_id id_table [] = {
+        { USB_DEVICE(0x0c88, 0x17da) }, /* Kyocera Wireless KPC650/Passport */
+        { },
+};
+MODULE_DEVICE_TABLE(usb, id_table);
+
+#define URB_TRANSFER_BUFFER_SIZE        4096
+#define NUM_READ_URBS                   4
+#define NUM_WRITE_URBS                  4
+#define NUM_BULK_EPS                    3
+#define MAX_BULK_EPS                    6
+
+/* if overridden by the user, then use their value for the size of the
+ * read and write urbs, and the number of endpoints */
+static int buffer_size = URB_TRANSFER_BUFFER_SIZE;
+static int endpoints = NUM_BULK_EPS;
+static int debug;
+struct airprime_private {
+        spinlock_t lock;
+        int outstanding_urbs;
+        int throttled;
+        struct urb *read_urbp[NUM_READ_URBS];
+
+        /* Settings for the port */
+        int rts_state;  /* Handshaking pins (outputs) */
+        int dtr_state;
+        int cts_state;  /* Handshaking pins (inputs) */
+        int dsr_state;
+        int dcd_state;
+        int ri_state;
+};
+
+static int airprime_send_setup(struct usb_serial_port *port)
+{
+        struct usb_serial *serial = port->serial;
+        struct airprime_private *priv;
+
+        dbg("%s", __func__);
+
+        if (port->number != 0)
+                return 0;
+
+        priv = usb_get_serial_port_data(port);
+
+        if (port->port.tty) {
+                int val = 0;
+                if (priv->dtr_state)
+                        val |= 0x01;
+                if (priv->rts_state)
+                        val |= 0x02;
+
+                return usb_control_msg(serial->dev,
+                                        usb_rcvctrlpipe(serial->dev, 0),
+                                        0x22, 0x21, val, 0, NULL, 0,
+                                        USB_CTRL_SET_TIMEOUT);
+        }
+
+        return 0;
+}
+
+static void airprime_read_bulk_callback(struct urb *urb)
+{
+        struct usb_serial_port *port = urb->context;
+        unsigned char *data = urb->transfer_buffer;
+        struct tty_struct *tty;
+        int result;
+        int status = urb->status;
+
+        dbg("%s - port %d", __func__, port->number);
+
+        if (status) {
+                dbg("%s - nonzero read bulk status received: %d",
+                    __func__, status);
+                return;
+        }
+        usb_serial_debug_data(debug, &port->dev, __func__,
+                                                urb->actual_length, data);
+
+        tty = port->port.tty;
+        if (tty && urb->actual_length) {
+                tty_insert_flip_string(tty, data, urb->actual_length);
+                tty_flip_buffer_push(tty);
+        }
+
+        result = usb_submit_urb(urb, GFP_ATOMIC);
+        if (result)
+                dev_err(&port->dev,
+                        "%s - failed resubmitting read urb, error %d\n",
+                        __func__, result);
+        return;
+}
+
+static void airprime_write_bulk_callback(struct urb *urb)
+{
+        struct usb_serial_port *port = urb->context;
+        struct airprime_private *priv = usb_get_serial_port_data(port);
+        int status = urb->status;
+        unsigned long flags;
+
+        dbg("%s - port %d", __func__, port->number);
+
+        /* free up the transfer buffer, as usb_free_urb() does not do this */
+        kfree(urb->transfer_buffer);
+
+        if (status)
+                dbg("%s - nonzero write bulk status received: %d",
+                    __func__, status);
+        spin_lock_irqsave(&priv->lock, flags);
+        --priv->outstanding_urbs;
+        spin_unlock_irqrestore(&priv->lock, flags);
+
+        usb_serial_port_softint(port);
+}
+
+static int airprime_open(struct tty_struct *tty, struct usb_serial_port *port,
+                                                        struct file *filp)
+{
+        struct airprime_private *priv = usb_get_serial_port_data(port);
+        struct usb_serial *serial = port->serial;
+        struct urb *urb;
+        char *buffer = NULL;
+        int i;
+        int result = 0;
+
+        dbg("%s - port %d", __func__, port->number);
+
+        /* initialize our private data structure if it isn't already created */
+        if (!priv) {
+                priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+                if (!priv) {
+                        result = -ENOMEM;
+                        goto out;
+                }
+                spin_lock_init(&priv->lock);
+                usb_set_serial_port_data(port, priv);
+        }
+
+        /* Set some sane defaults */
+        priv->rts_state = 1;
+        priv->dtr_state = 1;
+
+        for (i = 0; i < NUM_READ_URBS; ++i) {
+                buffer = kmalloc(buffer_size, GFP_KERNEL);
+                if (!buffer) {
+                        dev_err(&port->dev, "%s - out of memory.\n",
+                                __func__);
+                        result = -ENOMEM;
+                        goto errout;
+                }
+                urb = usb_alloc_urb(0, GFP_KERNEL);
+                if (!urb) {
+                        kfree(buffer);
+                        dev_err(&port->dev, "%s - no more urbs?\n",
+                                __func__);
+                        result = -ENOMEM;
+                        goto errout;
+                }
+                usb_fill_bulk_urb(urb, serial->dev,
+                                  usb_rcvbulkpipe(serial->dev,
+                                          port->bulk_out_endpointAddress),
+                                  buffer, buffer_size,
+                                  airprime_read_bulk_callback, port);
+                result = usb_submit_urb(urb, GFP_KERNEL);
+                if (result) {
+                        usb_free_urb(urb);
+                        kfree(buffer);
+                        dev_err(&port->dev,
+                                "%s - failed submitting read urb %d for port %d, error %d\n",
+                                __func__, i, port->number, result);
+                        goto errout;
+                }
+                /* remember this urb so we can kill it when the
+                   port is closed */
+                priv->read_urbp[i] = urb;
+        }
+
+        airprime_send_setup(port);
+
+        goto out;
+
+ errout:
+        /* some error happened, cancel any submitted urbs and clean up
+           anything that got allocated successfully */
+
+        while (i-- != 0) {
+                urb = priv->read_urbp[i];
+                buffer = urb->transfer_buffer;
+                usb_kill_urb(urb);
+                usb_free_urb(urb);
+                kfree(buffer);
+        }
+
+ out:
+        return result;
+}
+
+static void airprime_close(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
+{
+        struct airprime_private *priv = usb_get_serial_port_data(port);
+        int i;
+
+        dbg("%s - port %d", __func__, port->number);
+
+        priv->rts_state = 0;
+        priv->dtr_state = 0;
+
+        mutex_lock(&port->serial->disc_mutex);
+        if (!port->serial->disconnected)
+                airprime_send_setup(port);
+        mutex_unlock(&port->serial->disc_mutex);
+
+        for (i = 0; i < NUM_READ_URBS; ++i) {
+                usb_kill_urb(priv->read_urbp[i]);
+                kfree(priv->read_urbp[i]->transfer_buffer);
+                usb_free_urb(priv->read_urbp[i]);
+        }
+
+        /* free up private structure */
+        kfree(priv);
+        usb_set_serial_port_data(port, NULL);
+}
+
+static int airprime_write(struct tty_struct *tty, struct usb_serial_port *port,
+                          const unsigned char *buf, int count)
+{
+        struct airprime_private *priv = usb_get_serial_port_data(port);
+        struct usb_serial *serial = port->serial;
+        struct urb *urb;
+        unsigned char *buffer;
+        unsigned long flags;
+        int status;
+        dbg("%s - port %d", __func__, port->number);
+
+        spin_lock_irqsave(&priv->lock, flags);
+        if (priv->outstanding_urbs > NUM_WRITE_URBS) {
+                spin_unlock_irqrestore(&priv->lock, flags);
+                dbg("%s - write limit hit\n", __func__);
+                return 0;
+        }
+        spin_unlock_irqrestore(&priv->lock, flags);
+        buffer = kmalloc(count, GFP_ATOMIC);
+        if (!buffer) {
+                dev_err(&port->dev, "out of memory\n");
+                return -ENOMEM;
+        }
+        urb = usb_alloc_urb(0, GFP_ATOMIC);
+        if (!urb) {
+                dev_err(&port->dev, "no more free urbs\n");
+                kfree(buffer);
+                return -ENOMEM;
+        }
+        memcpy(buffer, buf, count);
+
+        usb_serial_debug_data(debug, &port->dev, __func__, count, buffer);
+
+        usb_fill_bulk_urb(urb, serial->dev,
+                          usb_sndbulkpipe(serial->dev,
+                                          port->bulk_out_endpointAddress),
+                          buffer, count,
+                          airprime_write_bulk_callback, port);
+
+        /* send it down the pipe */
+        status = usb_submit_urb(urb, GFP_ATOMIC);
+        if (status) {
+                dev_err(&port->dev,
+                        "%s - usb_submit_urb(write bulk) failed with status = %d\n",
+                        __func__, status);
+                count = status;
+                kfree(buffer);
+        } else {
+                spin_lock_irqsave(&priv->lock, flags);
+                ++priv->outstanding_urbs;
+                spin_unlock_irqrestore(&priv->lock, flags);
+        }
+        /* we are done with this urb, so let the host driver
+         * really free it when it is finished with it */
+        usb_free_urb(urb);
+        return count;
+}
+
+static struct usb_driver airprime_driver = {
+        .name =         "airprime",
+        .probe =        usb_serial_probe,
+        .disconnect =   usb_serial_disconnect,
+        .id_table =     id_table,
+        .no_dynamic_id =        1,
+};
+
+static struct usb_serial_driver airprime_device = {
+        .driver = {
+                .owner =        THIS_MODULE,
+                .name =         "airprime",
+        },
+        .usb_driver =           &airprime_driver,
+        .id_table =             id_table,
+        .open =                 airprime_open,
+        .close =                airprime_close,
+        .write =                airprime_write,
+};
+
+static int __init airprime_init(void)
+{
+        int retval;
+
+        airprime_device.num_ports = endpoints;
+        if (endpoints < 0 || endpoints >= MAX_BULK_EPS)
+                airprime_device.num_ports = NUM_BULK_EPS;
+
+        retval = usb_serial_register(&airprime_device);
+        if (retval)
+                return retval;
+        retval = usb_register(&airprime_driver);
+        if (retval)
+                usb_serial_deregister(&airprime_device);
+        return retval;
+}
+
+static void __exit airprime_exit(void)
+{
+        dbg("%s", __func__);
+
+        usb_deregister(&airprime_driver);
+        usb_serial_deregister(&airprime_device);
+}
+
+module_init(airprime_init);
+module_exit(airprime_exit);
+MODULE_LICENSE("GPL");
+
+module_param(debug, bool, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(debug, "Debug enabled");
+module_param(buffer_size, int, 0);
+MODULE_PARM_DESC(buffer_size,
+                "Size of the transfer buffers in bytes (default 4096)");
+module_param(endpoints, int, 0);
+MODULE_PARM_DESC(endpoints, "Number of bulk EPs to configure (default 3)");
diff --git a/drivers/usb/serial/ark3116.c b/drivers/usb/serial/ark3116.c
index 77895c8f8f31..aec61880f36c 100644
--- a/drivers/usb/serial/ark3116.c
+++ b/drivers/usb/serial/ark3116.c
@@ -158,12 +158,13 @@ cleanup:
         return -ENOMEM;
 }
 
-static void ark3116_set_termios(struct usb_serial_port *port,
+static void ark3116_set_termios(struct tty_struct *tty,
+                                struct usb_serial_port *port,
                                 struct ktermios *old_termios)
 {
         struct usb_serial *serial = port->serial;
         struct ark3116_private *priv = usb_get_serial_port_data(port);
-        struct ktermios *termios = port->tty->termios;
+        struct ktermios *termios = tty->termios;
         unsigned int cflag = termios->c_cflag;
         unsigned long flags;
         int baud;
@@ -177,8 +178,8 @@ static void ark3116_set_termios(struct usb_serial_port *port,
 
         spin_lock_irqsave(&priv->lock, flags);
         if (!priv->termios_initialized) {
-                *(port->tty->termios) = tty_std_termios;
-                port->tty->termios->c_cflag = B9600 | CS8
+                *termios = tty_std_termios;
+                termios->c_cflag = B9600 | CS8
                                               | CREAD | HUPCL | CLOCAL;
                 termios->c_ispeed = 9600;
                 termios->c_ospeed = 9600;
@@ -192,7 +193,7 @@ static void ark3116_set_termios(struct usb_serial_port *port,
         buf = kmalloc(1, GFP_KERNEL);
         if (!buf) {
                 dbg("error kmalloc");
-                *port->tty->termios = *old_termios;
+                *termios = *old_termios;
                 return;
         }
 
@@ -243,7 +244,7 @@ static void ark3116_set_termios(struct usb_serial_port *port,
         }
 
         /* set baudrate */
-        baud = tty_get_baud_rate(port->tty);
+        baud = tty_get_baud_rate(tty);
 
         switch (baud) {
         case 75:
@@ -262,11 +263,11 @@ static void ark3116_set_termios(struct usb_serial_port *port,
         case 230400:
         case 460800:
                 /* Report the resulting rate back to the caller */
-                tty_encode_baud_rate(port->tty, baud, baud);
+                tty_encode_baud_rate(tty, baud, baud);
                 break;
         /* set 9600 as default (if given baudrate is invalid for example) */
         default:
-                tty_encode_baud_rate(port->tty, 9600, 9600);
+                tty_encode_baud_rate(tty, 9600, 9600);
         case 0:
                 baud = 9600;
         }
@@ -317,7 +318,8 @@ static void ark3116_set_termios(struct usb_serial_port *port,
         return;
 }
 
-static int ark3116_open(struct usb_serial_port *port, struct file *filp)
+static int ark3116_open(struct tty_struct *tty, struct usb_serial_port *port,
+                                        struct file *filp)
 {
         struct ktermios tmp_termios;
         struct usb_serial *serial = port->serial;
@@ -332,7 +334,7 @@ static int ark3116_open(struct usb_serial_port *port, struct file *filp)
                 return -ENOMEM;
         }
 
-        result = usb_serial_generic_open(port, filp);
+        result = usb_serial_generic_open(tty, port, filp);
         if (result)
                 goto err_out;
 
@@ -362,8 +364,8 @@ static int ark3116_open(struct usb_serial_port *port, struct file *filp)
         ARK3116_RCV(serial, 124, 0xFE, 0xC0, 0x0000, 0x0006, 0xFF, buf);
 
         /* initialise termios */
-        if (port->tty)
-                ark3116_set_termios(port, &tmp_termios);
+        if (tty)
+                ark3116_set_termios(tty, port, &tmp_termios);
 
 err_out:
         kfree(buf);
@@ -371,9 +373,10 @@ err_out:
         return result;
 }
 
-static int ark3116_ioctl(struct usb_serial_port *port, struct file *file,
+static int ark3116_ioctl(struct tty_struct *tty, struct file *file,
                          unsigned int cmd, unsigned long arg)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct serial_struct serstruct;
         void __user *user_arg = (void __user *)arg;
 
@@ -403,8 +406,9 @@ static int ark3116_ioctl(struct usb_serial_port *port, struct file *file,
         return -ENOIOCTLCMD;
 }
 
-static int ark3116_tiocmget(struct usb_serial_port *port, struct file *file)
+static int ark3116_tiocmget(struct tty_struct *tty, struct file *file)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct usb_serial *serial = port->serial;
         char *buf;
         char temp;
diff --git a/drivers/usb/serial/belkin_sa.c b/drivers/usb/serial/belkin_sa.c
index 0a322fc53d6e..1a762692c739 100644
--- a/drivers/usb/serial/belkin_sa.c
+++ b/drivers/usb/serial/belkin_sa.c
@@ -89,14 +89,13 @@ static int debug;
 /* function prototypes for a Belkin USB Serial Adapter F5U103 */
 static int  belkin_sa_startup           (struct usb_serial *serial);
 static void belkin_sa_shutdown          (struct usb_serial *serial);
-static int  belkin_sa_open              (struct usb_serial_port *port, struct file *filp);
-static void belkin_sa_close             (struct usb_serial_port *port, struct file *filp);
+static int  belkin_sa_open              (struct tty_struct *tty, struct usb_serial_port *port, struct file *filp);
+static void belkin_sa_close             (struct tty_struct *tty, struct usb_serial_port *port, struct file *filp);
 static void belkin_sa_read_int_callback (struct urb *urb);
-static void belkin_sa_set_termios       (struct usb_serial_port *port, struct ktermios * old);
-static int  belkin_sa_ioctl             (struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg);
-static void belkin_sa_break_ctl         (struct usb_serial_port *port, int break_state );
-static int  belkin_sa_tiocmget          (struct usb_serial_port *port, struct file *file);
-static int  belkin_sa_tiocmset          (struct usb_serial_port *port, struct file *file, unsigned int set, unsigned int clear);
+static void belkin_sa_set_termios       (struct tty_struct *tty, struct usb_serial_port *port, struct ktermios * old);
+static void belkin_sa_break_ctl         (struct tty_struct *tty, int break_state );
+static int  belkin_sa_tiocmget          (struct tty_struct *tty, struct file *file);
+static int  belkin_sa_tiocmset          (struct tty_struct *tty, struct file *file, unsigned int set, unsigned int clear);
 
 
 static struct usb_device_id id_table_combined [] = {
@@ -132,7 +131,6 @@ static struct usb_serial_driver belkin_device = {
         .open =                 belkin_sa_open,
         .close =                belkin_sa_close,
         .read_int_callback =    belkin_sa_read_int_callback,    /* How we get the status info */
-        .ioctl =                belkin_sa_ioctl,
         .set_termios =          belkin_sa_set_termios,
         .break_ctl =            belkin_sa_break_ctl,
         .tiocmget =             belkin_sa_tiocmget,
@@ -190,7 +188,7 @@ static int belkin_sa_startup (struct usb_serial *serial)
 }
 
 
-static void belkin_sa_shutdown (struct usb_serial *serial)
+static void belkin_sa_shutdown(struct usb_serial *serial)
 {
         struct belkin_sa_private *priv;
         int i;
@@ -206,7 +204,7 @@ static void belkin_sa_shutdown (struct usb_serial *serial)
 }
 
 
-static int  belkin_sa_open (struct usb_serial_port *port, struct file *filp)
+static int  belkin_sa_open(struct tty_struct *tty, struct usb_serial_port *port, struct file *filp)
 {
         int retval = 0;
 
@@ -235,7 +233,8 @@ exit:
 } /* belkin_sa_open */
 
 
-static void belkin_sa_close (struct usb_serial_port *port, struct file *filp)
+static void belkin_sa_close (struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 {
         dbg("%s port %d", __func__, port->number);
 
@@ -246,7 +245,7 @@ static void belkin_sa_close (struct usb_serial_port *port, struct file *filp)
 } /* belkin_sa_close */
 
 
-static void belkin_sa_read_int_callback (struct urb *urb)
+static void belkin_sa_read_int_callback(struct urb *urb)
 {
         struct usb_serial_port *port = urb->context;
         struct belkin_sa_private *priv;
@@ -311,7 +310,7 @@ static void belkin_sa_read_int_callback (struct urb *urb)
          * to look in to this before committing any code.
          */
         if (priv->last_lsr & BELKIN_SA_LSR_ERR) {
-                tty = port->tty;
+                tty = port->port.tty;
                 /* Overrun Error */
                 if (priv->last_lsr & BELKIN_SA_LSR_OE) {
                 }
@@ -334,7 +333,8 @@ exit:
                      __func__, retval);
 }
 
-static void belkin_sa_set_termios (struct usb_serial_port *port, struct ktermios *old_termios)
+static void belkin_sa_set_termios(struct tty_struct *tty,
+                struct usb_serial_port *port, struct ktermios *old_termios)
 {
         struct usb_serial *serial = port->serial;
         struct belkin_sa_private *priv = usb_get_serial_port_data(port);
@@ -347,7 +347,7 @@ static void belkin_sa_set_termios (struct usb_serial_port *port, struct ktermios
         unsigned long control_state;
         int bad_flow_control;
         speed_t baud;
-        struct ktermios *termios = port->tty->termios;
+        struct ktermios *termios = tty->termios;
         
         iflag = termios->c_iflag;
         cflag = termios->c_cflag;
@@ -377,7 +377,7 @@ static void belkin_sa_set_termios (struct usb_serial_port *port, struct ktermios
                 }
         }
 
-        baud = tty_get_baud_rate(port->tty);
+        baud = tty_get_baud_rate(tty);
         if (baud) {
                 urb_value = BELKIN_SA_BAUD(baud);
                 /* Clip to maximum speed */
@@ -387,7 +387,7 @@ static void belkin_sa_set_termios (struct usb_serial_port *port, struct ktermios
                 baud = BELKIN_SA_BAUD(urb_value);
 
                 /* Report the actual baud rate back to the caller */
-                tty_encode_baud_rate(port->tty, baud, baud);
+                tty_encode_baud_rate(tty, baud, baud);
                 if (BSA_USB_CMD(BELKIN_SA_SET_BAUDRATE_REQUEST, urb_value) < 0)
                         err("Set baudrate error");
         } else {
@@ -463,8 +463,9 @@ static void belkin_sa_set_termios (struct usb_serial_port *port, struct ktermios
 } /* belkin_sa_set_termios */
 
 
-static void belkin_sa_break_ctl( struct usb_serial_port *port, int break_state )
+static void belkin_sa_break_ctl(struct tty_struct *tty, int break_state)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct usb_serial *serial = port->serial;
 
         if (BSA_USB_CMD(BELKIN_SA_SET_BREAK_REQUEST, break_state ? 1 : 0) < 0)
@@ -472,8 +473,9 @@ static void belkin_sa_break_ctl( struct usb_serial_port *port, int break_state )
 }
 
 
-static int belkin_sa_tiocmget (struct usb_serial_port *port, struct file *file)
+static int belkin_sa_tiocmget(struct tty_struct *tty, struct file *file)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct belkin_sa_private *priv = usb_get_serial_port_data(port);
         unsigned long control_state;
         unsigned long flags;
@@ -488,9 +490,10 @@ static int belkin_sa_tiocmget (struct usb_serial_port *port, struct file *file)
 }
 
 
-static int belkin_sa_tiocmset (struct usb_serial_port *port, struct file *file,
+static int belkin_sa_tiocmset(struct tty_struct *tty, struct file *file,
                                unsigned int set, unsigned int clear)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct usb_serial *serial = port->serial;
         struct belkin_sa_private *priv = usb_get_serial_port_data(port);
         unsigned long control_state;
@@ -540,29 +543,7 @@ exit:
 }
 
 
-static int belkin_sa_ioctl (struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg)
-{
-        switch (cmd) {
-        case TIOCMIWAIT:
-                /* wait for any of the 4 modem inputs (DCD,RI,DSR,CTS)*/
-                /* TODO */
-                return( 0 );
-
-        case TIOCGICOUNT:
-                /* return count of modemline transitions */
-                /* TODO */
-                return 0;
-
-        default:
-                dbg("belkin_sa_ioctl arg not supported - 0x%04x",cmd);
-                return(-ENOIOCTLCMD);
-                break;
-        }
-        return 0;
-} /* belkin_sa_ioctl */
-
-
-static int __init belkin_sa_init (void)
+static int __init belkin_sa_init(void)
 {
         int retval;
         retval = usb_serial_register(&belkin_device);
@@ -583,7 +564,7 @@ failed_usb_serial_register:
 static void __exit belkin_sa_exit (void)
 {
         usb_deregister (&belkin_driver);
-        usb_serial_deregister (&belkin_device);
+        usb_serial_deregister(&belkin_device);
 }
 
 
diff --git a/drivers/usb/serial/ch341.c b/drivers/usb/serial/ch341.c
index 1f7c86bd8297..f61e3ca64305 100644
--- a/drivers/usb/serial/ch341.c
+++ b/drivers/usb/serial/ch341.c
@@ -232,7 +232,8 @@ error:	kfree(priv);
 }
 
 /* open this device, set default parameters */
-static int ch341_open(struct usb_serial_port *port, struct file *filp)
+static int ch341_open(struct tty_struct *tty, struct usb_serial_port *port,
+                                struct file *filp)
 {
         struct usb_serial *serial = port->serial;
         struct ch341_private *priv = usb_get_serial_port_data(serial->port[0]);
@@ -256,7 +257,7 @@ static int ch341_open(struct usb_serial_port *port, struct file *filp)
         if (r)
                 goto out;
 
-        r = usb_serial_generic_open(port, filp);
+        r = usb_serial_generic_open(tty, port, filp);
 
 out:    return r;
 }
@@ -264,11 +265,10 @@ out:	return r;
 /* Old_termios contains the original termios settings and
  * tty->termios contains the new setting to be used.
  */
-static void ch341_set_termios(struct usb_serial_port *port,
-                              struct ktermios *old_termios)
+static void ch341_set_termios(struct tty_struct *tty,
+                struct usb_serial_port *port, struct ktermios *old_termios)
 {
         struct ch341_private *priv = usb_get_serial_port_data(port);
-        struct tty_struct *tty = port->tty;
         unsigned baud_rate;
 
         dbg("ch341_set_termios()");
diff --git a/drivers/usb/serial/console.c b/drivers/usb/serial/console.c
index 201184c3fb87..940f5de68980 100644
--- a/drivers/usb/serial/console.c
+++ b/drivers/usb/serial/console.c
@@ -145,12 +145,12 @@ static int usb_console_setup(struct console *co, char *options)
         }
 
         port = serial->port[0];
-        port->tty = NULL;
+        port->port.tty = NULL;
 
         info->port = port;
          
-        ++port->open_count;
-        if (port->open_count == 1) {
+        ++port->port.count;
+        if (port->port.count == 1) {
                 if (serial->type->set_termios) {
                         /*
                          * allocate a fake tty so the driver can initialize
@@ -171,15 +171,15 @@ static int usb_console_setup(struct console *co, char *options)
                         }
                         memset(&dummy, 0, sizeof(struct ktermios));
                         tty->termios = termios;
-                        port->tty = tty;
+                        port->port.tty = tty;
                 }
 
                 /* only call the device specific open if this 
                  * is the first time the port is opened */
                 if (serial->type->open)
-                        retval = serial->type->open(port, NULL);
+                        retval = serial->type->open(NULL, port, NULL);
                 else
-                        retval = usb_serial_generic_open(port, NULL);
+                        retval = usb_serial_generic_open(NULL, port, NULL);
 
                 if (retval) {
                         err("could not open USB console port");
@@ -188,9 +188,9 @@ static int usb_console_setup(struct console *co, char *options)
 
                 if (serial->type->set_termios) {
                         termios->c_cflag = cflag;
-                        serial->type->set_termios(port, &dummy);
+                        serial->type->set_termios(NULL, port, &dummy);
 
-                        port->tty = NULL;
+                        port->port.tty = NULL;
                         kfree(termios);
                         kfree(tty);
                 }
@@ -203,11 +203,11 @@ out:
         return retval;
 free_termios:
         kfree(termios);
-        port->tty = NULL;
+        port->port.tty = NULL;
 free_tty:
         kfree(tty);
 reset_open_count:
-        port->open_count = 0;
+        port->port.count = 0;
 goto out;
 }
 
@@ -227,7 +227,7 @@ static void usb_console_write(struct console *co, const char *buf, unsigned coun
 
         dbg("%s - port %d, %d byte(s)", __func__, port->number, count);
 
-        if (!port->open_count) {
+        if (!port->port.count) {
                 dbg ("%s - port not opened", __func__);
                 return;
         }
@@ -245,17 +245,17 @@ static void usb_console_write(struct console *co, const char *buf, unsigned coun
                 }
                 /* pass on to the driver specific version of this function if it is available */
                 if (serial->type->write)
-                        retval = serial->type->write(port, buf, i);
+                        retval = serial->type->write(NULL, port, buf, i);
                 else
-                        retval = usb_serial_generic_write(port, buf, i);
+                        retval = usb_serial_generic_write(NULL, port, buf, i);
                 dbg("%s - return value : %d", __func__, retval);
                 if (lf) {
                         /* append CR after LF */
                         unsigned char cr = 13;
                         if (serial->type->write)
-                                retval = serial->type->write(port, &cr, 1);
+                                retval = serial->type->write(NULL, port, &cr, 1);
                         else
-                                retval = usb_serial_generic_write(port, &cr, 1);
+                                retval = usb_serial_generic_write(NULL, port, &cr, 1);
                         dbg("%s - return value : %d", __func__, retval);
                 }
                 buf += i;
@@ -306,8 +306,8 @@ void usb_serial_console_exit (void)
 {
         if (usbcons_info.port) {
                 unregister_console(&usbcons);
-                if (usbcons_info.port->open_count)
-                        usbcons_info.port->open_count--;
+                if (usbcons_info.port->port.count)
+                        usbcons_info.port->port.count--;
                 usbcons_info.port = NULL;
         }
 }
diff --git a/drivers/usb/serial/cp2101.c b/drivers/usb/serial/cp2101.c
index 2bc5576c443a..46c33fc9f6ce 100644
--- a/drivers/usb/serial/cp2101.c
+++ b/drivers/usb/serial/cp2101.c
@@ -37,15 +37,18 @@
 /*
  * Function Prototypes
  */
-static int cp2101_open(struct usb_serial_port*, struct file*);
-static void cp2101_cleanup(struct usb_serial_port*);
-static void cp2101_close(struct usb_serial_port*, struct file*);
-static void cp2101_get_termios(struct usb_serial_port*);
-static void cp2101_set_termios(struct usb_serial_port*, struct ktermios*);
-static int cp2101_tiocmget (struct usb_serial_port *, struct file *);
-static int cp2101_tiocmset (struct usb_serial_port *, struct file *,
+static int cp2101_open(struct tty_struct *, struct usb_serial_port *,
+                                                        struct file *);
+static void cp2101_cleanup(struct usb_serial_port *);
+static void cp2101_close(struct tty_struct *, struct usb_serial_port *,
+                                                        struct file*);
+static void cp2101_get_termios(struct tty_struct *);
+static void cp2101_set_termios(struct tty_struct *, struct usb_serial_port *,
+                                                        struct ktermios*);
+static int cp2101_tiocmget (struct tty_struct *, struct file *);
+static int cp2101_tiocmset (struct tty_struct *, struct file *,
                 unsigned int, unsigned int);
-static void cp2101_break_ctl(struct usb_serial_port*, int);
+static void cp2101_break_ctl(struct tty_struct *, int);
 static int cp2101_startup (struct usb_serial *);
 static void cp2101_shutdown(struct usb_serial*);
 
@@ -182,7 +185,7 @@ static struct usb_serial_driver cp2101_device = {
  * 'data' is a pointer to a pre-allocated array of integers large
  * enough to hold 'size' bytes (with 4 bytes to each integer)
  */
-static int cp2101_get_config(struct usb_serial_port* port, u8 request,
+static int cp2101_get_config(struct usb_serial_port *port, u8 request,
                 unsigned int *data, int size)
 {
         struct usb_serial *serial = port->serial;
@@ -228,7 +231,7 @@ static int cp2101_get_config(struct usb_serial_port* port, u8 request,
  * Values less than 16 bits wide are sent directly
  * 'size' is specified in bytes.
  */
-static int cp2101_set_config(struct usb_serial_port* port, u8 request,
+static int cp2101_set_config(struct usb_serial_port *port, u8 request,
                 unsigned int *data, int size)
 {
         struct usb_serial *serial = port->serial;
@@ -283,13 +286,14 @@ static int cp2101_set_config(struct usb_serial_port* port, u8 request,
  * Convenience function for calling cp2101_set_config on single data values
  * without requiring an integer pointer
  */
-static inline int cp2101_set_config_single(struct usb_serial_port* port,
+static inline int cp2101_set_config_single(struct usb_serial_port *port,
                 u8 request, unsigned int data)
 {
         return cp2101_set_config(port, request, &data, 2);
 }
 
-static int cp2101_open (struct usb_serial_port *port, struct file *filp)
+static int cp2101_open (struct tty_struct *tty, struct usb_serial_port *port,
+                                struct file *filp)
 {
         struct usb_serial *serial = port->serial;
         int result;
@@ -318,10 +322,10 @@ static int cp2101_open (struct usb_serial_port *port, struct file *filp)
         }
 
         /* Configure the termios structure */
-        cp2101_get_termios(port);
+        cp2101_get_termios(tty);
 
         /* Set the DTR and RTS pins low */
-        cp2101_tiocmset(port, NULL, TIOCM_DTR | TIOCM_RTS, 0);
+        cp2101_tiocmset(tty, NULL, TIOCM_DTR | TIOCM_RTS, 0);
 
         return 0;
 }
@@ -341,7 +345,8 @@ static void cp2101_cleanup (struct usb_serial_port *port)
         }
 }
 
-static void cp2101_close (struct usb_serial_port *port, struct file * filp)
+static void cp2101_close(struct tty_struct *tty, struct usb_serial_port *port,
+                                        struct file * filp)
 {
         dbg("%s - port %d", __func__, port->number);
 
@@ -362,19 +367,15 @@ static void cp2101_close (struct usb_serial_port *port, struct file * filp)
  * from the device, corrects any unsupported values, and configures the
  * termios structure to reflect the state of the device
  */
-static void cp2101_get_termios (struct usb_serial_port *port)
+static void cp2101_get_termios (struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         unsigned int cflag, modem_ctl[4];
         unsigned int baud;
         unsigned int bits;
 
         dbg("%s - port %d", __func__, port->number);
 
-        if (!port->tty || !port->tty->termios) {
-                dbg("%s - no tty structures", __func__);
-                return;
-        }
-
         cp2101_get_config(port, CP2101_BAUDRATE, &baud, 2);
         /* Convert to baudrate */
         if (baud)
@@ -382,8 +383,8 @@ static void cp2101_get_termios (struct usb_serial_port *port)
 
         dbg("%s - baud rate = %d", __func__, baud);
 
-        tty_encode_baud_rate(port->tty, baud, baud);
-        cflag = port->tty->termios->c_cflag;
+        tty_encode_baud_rate(tty, baud, baud);
+        cflag = tty->termios->c_cflag;
 
         cp2101_get_config(port, CP2101_BITS, &bits, 2);
         cflag &= ~CSIZE;
@@ -491,11 +492,11 @@ static void cp2101_get_termios (struct usb_serial_port *port)
                 cflag &= ~CRTSCTS;
         }
 
-        port->tty->termios->c_cflag = cflag;
+        tty->termios->c_cflag = cflag;
 }
 
-static void cp2101_set_termios (struct usb_serial_port *port,
-                struct ktermios *old_termios)
+static void cp2101_set_termios (struct tty_struct *tty,
+                struct usb_serial_port *port, struct ktermios *old_termios)
 {
         unsigned int cflag, old_cflag;
         unsigned int baud = 0, bits;
@@ -503,15 +504,13 @@ static void cp2101_set_termios (struct usb_serial_port *port,
 
         dbg("%s - port %d", __func__, port->number);
 
-        if (!port->tty || !port->tty->termios) {
-                dbg("%s - no tty structures", __func__);
+        if (!tty)
                 return;
-        }
-        port->tty->termios->c_cflag &= ~CMSPAR;
 
-        cflag = port->tty->termios->c_cflag;
+        tty->termios->c_cflag &= ~CMSPAR;
+        cflag = tty->termios->c_cflag;
         old_cflag = old_termios->c_cflag;
-        baud = tty_get_baud_rate(port->tty);
+        baud = tty_get_baud_rate(tty);
 
         /* If the baud rate is to be updated*/
         if (baud != tty_termios_baud_rate(old_termios)) {
@@ -554,7 +553,7 @@ static void cp2101_set_termios (struct usb_serial_port *port,
                 }
         }
         /* Report back the resulting baud rate */
-        tty_encode_baud_rate(port->tty, baud, baud);
+        tty_encode_baud_rate(tty, baud, baud);
 
         /* If the number of data bits is to be updated */
         if ((cflag & CSIZE) != (old_cflag & CSIZE)) {
@@ -651,9 +650,10 @@ static void cp2101_set_termios (struct usb_serial_port *port,
 
 }
 
-static int cp2101_tiocmset (struct usb_serial_port *port, struct file *file,
+static int cp2101_tiocmset (struct tty_struct *tty, struct file *file,
                 unsigned int set, unsigned int clear)
 {
+        struct usb_serial_port *port = tty->driver_data;
         unsigned int control = 0;
 
         dbg("%s - port %d", __func__, port->number);
@@ -681,8 +681,9 @@ static int cp2101_tiocmset (struct usb_serial_port *port, struct file *file,
 
 }
 
-static int cp2101_tiocmget (struct usb_serial_port *port, struct file *file)
+static int cp2101_tiocmget (struct tty_struct *tty, struct file *file)
 {
+        struct usb_serial_port *port = tty->driver_data;
         unsigned int control;
         int result;
 
@@ -702,8 +703,9 @@ static int cp2101_tiocmget (struct usb_serial_port *port, struct file *file)
         return result;
 }
 
-static void cp2101_break_ctl (struct usb_serial_port *port, int break_state)
+static void cp2101_break_ctl (struct tty_struct *tty, int break_state)
 {
+        struct usb_serial_port *port = tty->driver_data;
         unsigned int state;
 
         dbg("%s - port %d", __func__, port->number);
diff --git a/drivers/usb/serial/cyberjack.c b/drivers/usb/serial/cyberjack.c
index c164e2cf2752..546178ea6f2d 100644
--- a/drivers/usb/serial/cyberjack.c
+++ b/drivers/usb/serial/cyberjack.c
@@ -57,15 +57,18 @@ static int debug;
 #define CYBERJACK_PRODUCT_ID    0x0100
 
 /* Function prototypes */
-static int cyberjack_startup (struct usb_serial *serial);
-static void cyberjack_shutdown (struct usb_serial *serial);
-static int  cyberjack_open (struct usb_serial_port *port, struct file *filp);
-static void cyberjack_close (struct usb_serial_port *port, struct file *filp);
-static int cyberjack_write (struct usb_serial_port *port, const unsigned char *buf, int count);
-static int cyberjack_write_room( struct usb_serial_port *port );
-static void cyberjack_read_int_callback (struct urb *urb);
-static void cyberjack_read_bulk_callback (struct urb *urb);
-static void cyberjack_write_bulk_callback (struct urb *urb);
+static int cyberjack_startup(struct usb_serial *serial);
+static void cyberjack_shutdown(struct usb_serial *serial);
+static int  cyberjack_open(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp);
+static void cyberjack_close(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp);
+static int cyberjack_write(struct tty_struct *tty,
+        struct usb_serial_port *port, const unsigned char *buf, int count);
+static int cyberjack_write_room( struct tty_struct *tty);
+static void cyberjack_read_int_callback(struct urb *urb);
+static void cyberjack_read_bulk_callback(struct urb *urb);
+static void cyberjack_write_bulk_callback(struct urb *urb);
 
 static struct usb_device_id id_table [] = {
         { USB_DEVICE(CYBERJACK_VENDOR_ID, CYBERJACK_PRODUCT_ID) },
@@ -111,7 +114,7 @@ struct cyberjack_private {
 };
 
 /* do some startup allocations not currently performed by usb_serial_probe() */
-static int cyberjack_startup (struct usb_serial *serial)
+static int cyberjack_startup(struct usb_serial *serial)
 {
         struct cyberjack_private *priv;
         int i;
@@ -145,7 +148,7 @@ static int cyberjack_startup (struct usb_serial *serial)
         return( 0 );
 }
 
-static void cyberjack_shutdown (struct usb_serial *serial)
+static void cyberjack_shutdown(struct usb_serial *serial)
 {
         int i;
         
@@ -159,7 +162,8 @@ static void cyberjack_shutdown (struct usb_serial *serial)
         }
 }
         
-static int  cyberjack_open (struct usb_serial_port *port, struct file *filp)
+static int  cyberjack_open(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 {
         struct cyberjack_private *priv;
         unsigned long flags;
@@ -174,7 +178,8 @@ static int  cyberjack_open (struct usb_serial_port *port, struct file *filp)
          * the data through, otherwise it is scheduled, and with high
          * data rates (like with OHCI) data can get lost.
          */
-        port->tty->low_latency = 1;
+        if (tty)
+                tty->low_latency = 1;
 
         priv = usb_get_serial_port_data(port);
         spin_lock_irqsave(&priv->lock, flags);
@@ -186,7 +191,8 @@ static int  cyberjack_open (struct usb_serial_port *port, struct file *filp)
         return result;
 }
 
-static void cyberjack_close (struct usb_serial_port *port, struct file *filp)
+static void cyberjack_close(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 {
         dbg("%s - port %d", __func__, port->number);
 
@@ -197,7 +203,8 @@ static void cyberjack_close (struct usb_serial_port *port, struct file *filp)
         }
 }
 
-static int cyberjack_write (struct usb_serial_port *port, const unsigned char *buf, int count)
+static int cyberjack_write(struct tty_struct *tty,
+        struct usb_serial_port *port, const unsigned char *buf, int count)
 {
         struct usb_serial *serial = port->serial;
         struct cyberjack_private *priv = usb_get_serial_port_data(port);
@@ -292,13 +299,13 @@ static int cyberjack_write (struct usb_serial_port *port, const unsigned char *b
         return (count);
 } 
 
-static int cyberjack_write_room( struct usb_serial_port *port )
+static int cyberjack_write_room(struct tty_struct *tty)
 {
         /* FIXME: .... */
         return CYBERJACK_LOCAL_BUF_SIZE;
 }
 
-static void cyberjack_read_int_callback( struct urb *urb )
+static void cyberjack_read_int_callback(struct urb *urb)
 {
         struct usb_serial_port *port = urb->context;
         struct cyberjack_private *priv = usb_get_serial_port_data(port);
@@ -355,7 +362,7 @@ resubmit:
         dbg("%s - usb_submit_urb(int urb)", __func__);
 }
 
-static void cyberjack_read_bulk_callback (struct urb *urb)
+static void cyberjack_read_bulk_callback(struct urb *urb)
 {
         struct usb_serial_port *port = urb->context;
         struct cyberjack_private *priv = usb_get_serial_port_data(port);
@@ -374,7 +381,7 @@ static void cyberjack_read_bulk_callback (struct urb *urb)
                 return;
         }
 
-        tty = port->tty;
+        tty = port->port.tty;
         if (!tty) {
                 dbg("%s - ignoring since device not open\n", __func__);
                 return;
@@ -407,7 +414,7 @@ static void cyberjack_read_bulk_callback (struct urb *urb)
         }
 }
 
-static void cyberjack_write_bulk_callback (struct urb *urb)
+static void cyberjack_write_bulk_callback(struct urb *urb)
 {
         struct usb_serial_port *port = urb->context;
         struct cyberjack_private *priv = usb_get_serial_port_data(port);
diff --git a/drivers/usb/serial/cypress_m8.c b/drivers/usb/serial/cypress_m8.c
index 0230d3c0888a..6999d3372d85 100644
--- a/drivers/usb/serial/cypress_m8.c
+++ b/drivers/usb/serial/cypress_m8.c
@@ -167,18 +167,18 @@ static int  cypress_earthmate_startup	(struct usb_serial *serial);
 static int  cypress_hidcom_startup      (struct usb_serial *serial);
 static int  cypress_ca42v2_startup      (struct usb_serial *serial);
 static void cypress_shutdown            (struct usb_serial *serial);
-static int  cypress_open                (struct usb_serial_port *port, struct file *filp);
-static void cypress_close               (struct usb_serial_port *port, struct file *filp);
-static int  cypress_write               (struct usb_serial_port *port, const unsigned char *buf, int count);
+static int  cypress_open                (struct tty_struct *tty, struct usb_serial_port *port, struct file *filp);
+static void cypress_close               (struct tty_struct *tty, struct usb_serial_port *port, struct file *filp);
+static int  cypress_write               (struct tty_struct *tty, struct usb_serial_port *port, const unsigned char *buf, int count);
 static void cypress_send                (struct usb_serial_port *port);
-static int  cypress_write_room          (struct usb_serial_port *port);
-static int  cypress_ioctl               (struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg);
-static void cypress_set_termios         (struct usb_serial_port *port, struct ktermios * old);
-static int  cypress_tiocmget            (struct usb_serial_port *port, struct file *file);
-static int  cypress_tiocmset            (struct usb_serial_port *port, struct file *file, unsigned int set, unsigned int clear);
-static int  cypress_chars_in_buffer     (struct usb_serial_port *port);
-static void cypress_throttle            (struct usb_serial_port *port);
-static void cypress_unthrottle          (struct usb_serial_port *port);
+static int  cypress_write_room          (struct tty_struct *tty);
+static int  cypress_ioctl               (struct tty_struct *tty, struct file * file, unsigned int cmd, unsigned long arg);
+static void cypress_set_termios         (struct tty_struct *tty, struct usb_serial_port *port, struct ktermios * old);
+static int  cypress_tiocmget            (struct tty_struct *tty, struct file *file);
+static int  cypress_tiocmset            (struct tty_struct *tty, struct file *file, unsigned int set, unsigned int clear);
+static int  cypress_chars_in_buffer     (struct tty_struct *tty);
+static void cypress_throttle            (struct tty_struct *tty);
+static void cypress_unthrottle          (struct tty_struct *tty);
 static void cypress_set_dead            (struct usb_serial_port *port);
 static void cypress_read_int_callback   (struct urb *urb);
 static void cypress_write_int_callback  (struct urb *urb);
@@ -322,8 +322,10 @@ static int analyze_baud_rate(struct usb_serial_port *port, speed_t new_rate)
 
 
 /* This function can either set or retrieve the current serial line settings */
-static int cypress_serial_control (struct usb_serial_port *port, speed_t baud_rate, int data_bits, int stop_bits,
-                                   int parity_enable, int parity_type, int reset, int cypress_request_type)
+static int cypress_serial_control (struct tty_struct *tty,
+        struct usb_serial_port *port, speed_t baud_rate, int data_bits,
+        int stop_bits, int parity_enable, int parity_type, int reset,
+        int cypress_request_type)
 {
         int new_baudrate = 0, retval = 0, tries = 0;
         struct cypress_private *priv;
@@ -395,7 +397,7 @@ static int cypress_serial_control (struct usb_serial_port *port, speed_t baud_ra
                                 spin_unlock_irqrestore(&priv->lock, flags);
                                 /* If we asked for a speed change encode it */
                                 if (baud_rate)
-                                        tty_encode_baud_rate(port->tty,
+                                        tty_encode_baud_rate(tty,
                                                         new_baudrate, new_baudrate);
                         }
                 break;
@@ -611,7 +613,8 @@ static void cypress_shutdown (struct usb_serial *serial)
 }
 
 
-static int cypress_open (struct usb_serial_port *port, struct file *filp)
+static int cypress_open(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 {
         struct cypress_private *priv = usb_get_serial_port_data(port);
         struct usb_serial *serial = port->serial;
@@ -636,14 +639,15 @@ static int cypress_open (struct usb_serial_port *port, struct file *filp)
         spin_unlock_irqrestore(&priv->lock, flags);
 
         /* setting to zero could cause data loss */
-        port->tty->low_latency = 1;
+        if (tty)
+                tty->low_latency = 1;
 
         /* raise both lines and set termios */
         spin_lock_irqsave(&priv->lock, flags);
         priv->line_control = CONTROL_DTR | CONTROL_RTS;
         priv->cmd_ctrl = 1;
         spin_unlock_irqrestore(&priv->lock, flags);
-        result = cypress_write(port, NULL, 0);
+        result = cypress_write(tty, port, NULL, 0);
 
         if (result) {
                 dev_err(&port->dev, "%s - failed setting the control lines - error %d\n", __func__, result);
@@ -651,7 +655,8 @@ static int cypress_open (struct usb_serial_port *port, struct file *filp)
         } else
                 dbg("%s - success setting the control lines", __func__);
 
-        cypress_set_termios(port, &priv->tmp_termios);
+        if (tty)
+                cypress_set_termios(tty, port, &priv->tmp_termios);
 
         /* setup the port and start reading from the device */
         if(!port->interrupt_in_urb){
@@ -674,7 +679,8 @@ static int cypress_open (struct usb_serial_port *port, struct file *filp)
 } /* cypress_open */
 
 
-static void cypress_close(struct usb_serial_port *port, struct file * filp)
+static void cypress_close(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file * filp)
 {
         struct cypress_private *priv = usb_get_serial_port_data(port);
         unsigned int c_cflag;
@@ -688,7 +694,7 @@ static void cypress_close(struct usb_serial_port *port, struct file * filp)
         spin_lock_irq(&priv->lock);
         timeout = CYPRESS_CLOSING_WAIT;
         init_waitqueue_entry(&wait, current);
-        add_wait_queue(&port->tty->write_wait, &wait);
+        add_wait_queue(&tty->write_wait, &wait);
         for (;;) {
                 set_current_state(TASK_INTERRUPTIBLE);
                 if (cypress_buf_data_avail(priv->buf) == 0
@@ -701,7 +707,7 @@ static void cypress_close(struct usb_serial_port *port, struct file * filp)
                 spin_lock_irq(&priv->lock);
         }
         set_current_state(TASK_RUNNING);
-        remove_wait_queue(&port->tty->write_wait, &wait);
+        remove_wait_queue(&tty->write_wait, &wait);
         /* clear out any remaining data in the buffer */
         cypress_buf_clear(priv->buf);
         spin_unlock_irq(&priv->lock);
@@ -713,19 +719,21 @@ static void cypress_close(struct usb_serial_port *port, struct file * filp)
                 return;
         }
         /* wait for characters to drain from device */
-        bps = tty_get_baud_rate(port->tty);
-        if (bps > 1200)
-                timeout = max((HZ*2560)/bps,HZ/10);
-        else
-                timeout = 2*HZ;
-        schedule_timeout_interruptible(timeout);
+        if (tty) {
+                bps = tty_get_baud_rate(tty);
+                if (bps > 1200)
+                        timeout = max((HZ*2560)/bps,HZ/10);
+                else
+                        timeout = 2*HZ;
+                schedule_timeout_interruptible(timeout);
+        }
 
         dbg("%s - stopping urbs", __func__);
         usb_kill_urb (port->interrupt_in_urb);
         usb_kill_urb (port->interrupt_out_urb);
 
-        if (port->tty) {
-                c_cflag = port->tty->termios->c_cflag;
+        if (tty) {
+                c_cflag = tty->termios->c_cflag;
                 if (c_cflag & HUPCL) {
                         /* drop dtr and rts */
                         priv = usb_get_serial_port_data(port);
@@ -733,7 +741,7 @@ static void cypress_close(struct usb_serial_port *port, struct file * filp)
                         priv->line_control = 0;
                         priv->cmd_ctrl = 1;
                         spin_unlock_irq(&priv->lock);
-                        cypress_write(port, NULL, 0);
+                        cypress_write(tty, port, NULL, 0);
                 }
         }
 
@@ -744,7 +752,8 @@ static void cypress_close(struct usb_serial_port *port, struct file * filp)
 } /* cypress_close */
 
 
-static int cypress_write(struct usb_serial_port *port, const unsigned char *buf, int count)
+static int cypress_write(struct tty_struct *tty, struct usb_serial_port *port,
+                                        const unsigned char *buf, int count)
 {
         struct cypress_private *priv = usb_get_serial_port_data(port);
         unsigned long flags;
@@ -878,8 +887,9 @@ send:
 
 
 /* returns how much space is available in the soft buffer */
-static int cypress_write_room(struct usb_serial_port *port)
+static int cypress_write_room(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct cypress_private *priv = usb_get_serial_port_data(port);
         int room = 0;
         unsigned long flags;
@@ -895,8 +905,9 @@ static int cypress_write_room(struct usb_serial_port *port)
 }
 
 
-static int cypress_tiocmget (struct usb_serial_port *port, struct file *file)
+static int cypress_tiocmget(struct tty_struct *tty, struct file *file)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct cypress_private *priv = usb_get_serial_port_data(port);
         __u8 status, control;
         unsigned int result = 0;
@@ -922,9 +933,10 @@ static int cypress_tiocmget (struct usb_serial_port *port, struct file *file)
 }
 
 
-static int cypress_tiocmset (struct usb_serial_port *port, struct file *file,
+static int cypress_tiocmset(struct tty_struct *tty, struct file *file,
                                unsigned int set, unsigned int clear)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct cypress_private *priv = usb_get_serial_port_data(port);
         unsigned long flags;
         
@@ -942,12 +954,14 @@ static int cypress_tiocmset (struct usb_serial_port *port, struct file *file,
         priv->cmd_ctrl = 1;
         spin_unlock_irqrestore(&priv->lock, flags);
 
-        return cypress_write(port, NULL, 0);
+        return cypress_write(tty, port, NULL, 0);
 }
 
 
-static int cypress_ioctl (struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg)
+static int cypress_ioctl(struct tty_struct *tty, struct file * file,
+                                        unsigned int cmd, unsigned long arg)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct cypress_private *priv = usb_get_serial_port_data(port);
 
         dbg("%s - port %d, cmd 0x%.4x", __func__, port->number, cmd);
@@ -983,22 +997,18 @@ static int cypress_ioctl (struct usb_serial_port *port, struct file * file, unsi
                                 }
                         }
                         return 0;
-                        break;
                 default:
                         break;
         }
-
         dbg("%s - arg not supported - it was 0x%04x - check include/asm/ioctls.h", __func__, cmd);
-
         return -ENOIOCTLCMD;
 } /* cypress_ioctl */
 
 
-static void cypress_set_termios (struct usb_serial_port *port,
-                struct ktermios *old_termios)
+static void cypress_set_termios(struct tty_struct *tty,
+        struct usb_serial_port *port, struct ktermios *old_termios)
 {
         struct cypress_private *priv = usb_get_serial_port_data(port);
-        struct tty_struct *tty;
         int data_bits, stop_bits, parity_type, parity_enable;
         unsigned cflag, iflag;
         unsigned long flags;
@@ -1007,8 +1017,6 @@ static void cypress_set_termios (struct usb_serial_port *port,
 
         dbg("%s - port %d", __func__, port->number);
 
-        tty = port->tty;
-
         spin_lock_irqsave(&priv->lock, flags);
         if (!priv->termios_initialized) {
                 if (priv->chiptype == CT_EARTHMATE) {
@@ -1096,13 +1104,13 @@ static void cypress_set_termios (struct usb_serial_port *port,
                         "%d data_bits (+5)", __func__, stop_bits,
                         parity_enable, parity_type, data_bits);
 
-        cypress_serial_control(port, tty_get_baud_rate(tty), data_bits, stop_bits,
+        cypress_serial_control(tty, port, tty_get_baud_rate(tty), data_bits, stop_bits,
                         parity_enable, parity_type, 0, CYPRESS_SET_CONFIG);
 
         /* we perform a CYPRESS_GET_CONFIG so that the current settings are
          * filled into the private structure this should confirm that all is
          * working if it returns what we just set */
-        cypress_serial_control(port, 0, 0, 0, 0, 0, 0, CYPRESS_GET_CONFIG);
+        cypress_serial_control(tty, port, 0, 0, 0, 0, 0, 0, CYPRESS_GET_CONFIG);
 
         /* Here we can define custom tty settings for devices; the main tty
          * termios flag base comes from empeg.c */
@@ -1142,14 +1150,15 @@ static void cypress_set_termios (struct usb_serial_port *port,
         /* if necessary, set lines */
         if (linechange) {
                 priv->cmd_ctrl = 1;
-                cypress_write(port, NULL, 0);
+                cypress_write(tty, port, NULL, 0);
         }
 } /* cypress_set_termios */
 
 
 /* returns amount of data still left in soft buffer */
-static int cypress_chars_in_buffer(struct usb_serial_port *port)
+static int cypress_chars_in_buffer(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct cypress_private *priv = usb_get_serial_port_data(port);
         int chars = 0;
         unsigned long flags;
@@ -1165,8 +1174,9 @@ static int cypress_chars_in_buffer(struct usb_serial_port *port)
 }
 
 
-static void cypress_throttle (struct usb_serial_port *port)
+static void cypress_throttle(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct cypress_private *priv = usb_get_serial_port_data(port);
         unsigned long flags;
 
@@ -1178,8 +1188,9 @@ static void cypress_throttle (struct usb_serial_port *port)
 }
 
 
-static void cypress_unthrottle (struct usb_serial_port *port)
+static void cypress_unthrottle(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct cypress_private *priv = usb_get_serial_port_data(port);
         int actually_throttled, result;
         unsigned long flags;
@@ -1251,7 +1262,7 @@ static void cypress_read_int_callback(struct urb *urb)
         }
         spin_unlock_irqrestore(&priv->lock, flags);
 
-        tty = port->tty;
+        tty = port->port.tty;
         if (!tty) {
                 dbg("%s - bad tty pointer - exiting", __func__);
                 return;
@@ -1327,7 +1338,7 @@ static void cypress_read_int_callback(struct urb *urb)
                                         data[i]);
                         tty_insert_flip_char(tty, data[i], tty_flag);
                 }
-                tty_flip_buffer_push(port->tty);
+                tty_flip_buffer_push(port->port.tty);
         }
 
         spin_lock_irqsave(&priv->lock, flags);
@@ -1339,7 +1350,7 @@ continue_read:
 
         /* Continue trying to always read... unless the port has closed. */
 
-        if (port->open_count > 0 && priv->comm_is_ok) {
+        if (port->port.count > 0 && priv->comm_is_ok) {
                 usb_fill_int_urb(port->interrupt_in_urb, port->serial->dev,
                                 usb_rcvintpipe(port->serial->dev,
                                         port->interrupt_in_endpointAddress),
diff --git a/drivers/usb/serial/digi_acceleport.c b/drivers/usb/serial/digi_acceleport.c
index 28bc6fcf44f0..dc92dbfc962e 100644
--- a/drivers/usb/serial/digi_acceleport.c
+++ b/drivers/usb/serial/digi_acceleport.c
@@ -15,7 +15,7 @@
 *  Al Borchers (borchers@steinerpoint.com)
 * 
 * (12/03/2001) gkh
-*       switched to using port->open_count instead of private version.
+*       switched to using port->port.count instead of private version.
 *       Removed port->active
 *
 * (04/08/2001) gb
@@ -441,22 +441,23 @@ static int digi_set_modem_signals(struct usb_serial_port *port,
         unsigned int modem_signals, int interruptible);
 static int digi_transmit_idle(struct usb_serial_port *port,
         unsigned long timeout);
-static void digi_rx_throttle (struct usb_serial_port *port);
-static void digi_rx_unthrottle (struct usb_serial_port *port);
-static void digi_set_termios(struct usb_serial_port *port,
-        struct ktermios *old_termios);
-static void digi_break_ctl(struct usb_serial_port *port, int break_state);
-static int digi_ioctl(struct usb_serial_port *port, struct file *file,
-        unsigned int cmd, unsigned long arg);
-static int digi_tiocmget(struct usb_serial_port *port, struct file *file);
-static int digi_tiocmset(struct usb_serial_port *port, struct file *file,
+static void digi_rx_throttle (struct tty_struct *tty);
+static void digi_rx_unthrottle (struct tty_struct *tty);
+static void digi_set_termios(struct tty_struct *tty,
+                struct usb_serial_port *port, struct ktermios *old_termios);
+static void digi_break_ctl(struct tty_struct *tty, int break_state);
+static int digi_tiocmget(struct tty_struct *tty, struct file *file);
+static int digi_tiocmset(struct tty_struct *tty, struct file *file,
         unsigned int set, unsigned int clear);
-static int digi_write(struct usb_serial_port *port, const unsigned char *buf, int count);
+static int digi_write(struct tty_struct *tty, struct usb_serial_port *port,
+        const unsigned char *buf, int count);
 static void digi_write_bulk_callback(struct urb *urb);
-static int digi_write_room(struct usb_serial_port *port);
-static int digi_chars_in_buffer(struct usb_serial_port *port);
-static int digi_open(struct usb_serial_port *port, struct file *filp);
-static void digi_close(struct usb_serial_port *port, struct file *filp);
+static int digi_write_room(struct tty_struct *tty);
+static int digi_chars_in_buffer(struct tty_struct *tty);
+static int digi_open(struct tty_struct *tty, struct usb_serial_port *port,
+        struct file *filp);
+static void digi_close(struct tty_struct *tty, struct usb_serial_port *port,
+        struct file *filp);
 static int digi_startup_device(struct usb_serial *serial);
 static int digi_startup(struct usb_serial *serial);
 static void digi_shutdown(struct usb_serial *serial);
@@ -516,7 +517,6 @@ static struct usb_serial_driver digi_acceleport_2_device = {
         .chars_in_buffer =              digi_chars_in_buffer,
         .throttle =                     digi_rx_throttle,
         .unthrottle =                   digi_rx_unthrottle,
-        .ioctl =                        digi_ioctl,
         .set_termios =                  digi_set_termios,
         .break_ctl =                    digi_break_ctl,
         .tiocmget =                     digi_tiocmget,
@@ -543,7 +543,6 @@ static struct usb_serial_driver digi_acceleport_4_device = {
         .chars_in_buffer =              digi_chars_in_buffer,
         .throttle =                     digi_rx_throttle,
         .unthrottle =                   digi_rx_unthrottle,
-        .ioctl =                        digi_ioctl,
         .set_termios =                  digi_set_termios,
         .break_ctl =                    digi_break_ctl,
         .tiocmget =                     digi_tiocmget,
@@ -604,7 +603,7 @@ static void digi_wakeup_write_lock(struct work_struct *work)
 
 static void digi_wakeup_write(struct usb_serial_port *port)
 {
-        tty_wakeup(port->tty);
+        tty_wakeup(port->port.tty);
 }
 
 
@@ -856,9 +855,10 @@ static int digi_transmit_idle(struct usb_serial_port *port,
 }
 
 
-static void digi_rx_throttle(struct usb_serial_port *port)
+static void digi_rx_throttle(struct tty_struct *tty)
 {
         unsigned long flags;
+        struct usb_serial_port *port = tty->driver_data;
         struct digi_port *priv = usb_get_serial_port_data(port);
 
 
@@ -872,10 +872,11 @@ static void digi_rx_throttle(struct usb_serial_port *port)
 }
 
 
-static void digi_rx_unthrottle(struct usb_serial_port *port)
+static void digi_rx_unthrottle(struct tty_struct *tty)
 {
         int ret = 0;
         unsigned long flags;
+        struct usb_serial_port *port = tty->driver_data;
         struct digi_port *priv = usb_get_serial_port_data(port);
 
         dbg("digi_rx_unthrottle: TOP: port=%d", priv->dp_port_num);
@@ -900,12 +901,10 @@ static void digi_rx_unthrottle(struct usb_serial_port *port)
 }
 
 
-static void digi_set_termios(struct usb_serial_port *port,
-                                        struct ktermios *old_termios)
+static void digi_set_termios(struct tty_struct *tty, 
+                struct usb_serial_port *port, struct ktermios *old_termios)
 {
-
         struct digi_port *priv = usb_get_serial_port_data(port);
-        struct tty_struct *tty = port->tty;
         unsigned int iflag = tty->termios->c_iflag;
         unsigned int cflag = tty->termios->c_cflag;
         unsigned int old_iflag = old_termios->c_iflag;
@@ -1088,8 +1087,9 @@ static void digi_set_termios(struct usb_serial_port *port,
 }
 
 
-static void digi_break_ctl(struct usb_serial_port *port, int break_state)
+static void digi_break_ctl(struct tty_struct *tty, int break_state)
 {
+        struct usb_serial_port *port = tty->driver_data;
         unsigned char buf[4];
 
         buf[0] = DIGI_CMD_BREAK_CONTROL;
@@ -1100,8 +1100,9 @@ static void digi_break_ctl(struct usb_serial_port *port, int break_state)
 }
 
 
-static int digi_tiocmget(struct usb_serial_port *port, struct file *file)
+static int digi_tiocmget(struct tty_struct *tty, struct file *file)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct digi_port *priv = usb_get_serial_port_data(port);
         unsigned int val;
         unsigned long flags;
@@ -1115,9 +1116,10 @@ static int digi_tiocmget(struct usb_serial_port *port, struct file *file)
 }
 
 
-static int digi_tiocmset(struct usb_serial_port *port, struct file *file,
+static int digi_tiocmset(struct tty_struct *tty, struct file *file,
         unsigned int set, unsigned int clear)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct digi_port *priv = usb_get_serial_port_data(port);
         unsigned int val;
         unsigned long flags;
@@ -1131,27 +1133,8 @@ static int digi_tiocmset(struct usb_serial_port *port, struct file *file,
 }
 
 
-static int digi_ioctl(struct usb_serial_port *port, struct file *file,
-        unsigned int cmd, unsigned long arg)
-{
-        struct digi_port *priv = usb_get_serial_port_data(port);
-        dbg("digi_ioctl: TOP: port=%d, cmd=0x%x", priv->dp_port_num, cmd);
-
-        switch (cmd) {
-        case TIOCMIWAIT:
-                /* wait for any of the 4 modem inputs (DCD,RI,DSR,CTS)*/
-                /* TODO */
-                return 0;
-        case TIOCGICOUNT:
-                /* return count of modemline transitions */
-                /* TODO */
-                return 0;
-        }
-        return -ENOIOCTLCMD;
-
-}
-
-static int digi_write(struct usb_serial_port *port, const unsigned char *buf, int count)
+static int digi_write(struct tty_struct *tty, struct usb_serial_port *port,
+                                        const unsigned char *buf, int count)
 {
 
         int ret,data_len,new_len;
@@ -1261,7 +1244,7 @@ static void digi_write_bulk_callback(struct urb *urb)
         /* try to send any buffered data on this port, if it is open */
         spin_lock(&priv->dp_port_lock);
         priv->dp_write_urb_in_use = 0;
-        if (port->open_count && port->write_urb->status != -EINPROGRESS
+        if (port->port.count && port->write_urb->status != -EINPROGRESS
             && priv->dp_out_buf_len > 0) {
                 *((unsigned char *)(port->write_urb->transfer_buffer))
                         = (unsigned char)DIGI_CMD_SEND_DATA;
@@ -1288,11 +1271,11 @@ static void digi_write_bulk_callback(struct urb *urb)
                         __func__, ret, priv->dp_port_num);
 }
 
-static int digi_write_room(struct usb_serial_port *port)
+static int digi_write_room(struct tty_struct *tty)
 {
-
-        int room;
+        struct usb_serial_port *port = tty->driver_data;
         struct digi_port *priv = usb_get_serial_port_data(port);
+        int room;
         unsigned long flags = 0;
 
         spin_lock_irqsave(&priv->dp_port_lock, flags);
@@ -1308,12 +1291,11 @@ static int digi_write_room(struct usb_serial_port *port)
 
 }
 
-static int digi_chars_in_buffer(struct usb_serial_port *port)
+static int digi_chars_in_buffer(struct tty_struct *tty)
 {
-
+        struct usb_serial_port *port = tty->driver_data;
         struct digi_port *priv = usb_get_serial_port_data(port);
 
-
         if (port->write_urb->status == -EINPROGRESS
             || priv->dp_write_urb_in_use) {
                 dbg("digi_chars_in_buffer: port=%d, chars=%d",
@@ -1329,7 +1311,8 @@ static int digi_chars_in_buffer(struct usb_serial_port *port)
 }
 
 
-static int digi_open(struct usb_serial_port *port, struct file *filp)
+static int digi_open(struct tty_struct *tty, struct usb_serial_port *port,
+                                struct file *filp)
 {
         int ret;
         unsigned char buf[32];
@@ -1338,7 +1321,7 @@ static int digi_open(struct usb_serial_port *port, struct file *filp)
         unsigned long flags = 0;
 
         dbg("digi_open: TOP: port=%d, open_count=%d",
-                priv->dp_port_num, port->open_count);
+                priv->dp_port_num, port->port.count);
 
         /* be sure the device is started up */
         if (digi_startup_device(port->serial) != 0)
@@ -1380,9 +1363,11 @@ static int digi_open(struct usb_serial_port *port, struct file *filp)
                 dbg("digi_open: write oob failed, ret=%d", ret);
 
         /* set termios settings */
-        not_termios.c_cflag = ~port->tty->termios->c_cflag;
-        not_termios.c_iflag = ~port->tty->termios->c_iflag;
-        digi_set_termios(port, &not_termios);
+        if (tty) {
+                not_termios.c_cflag = ~tty->termios->c_cflag;
+                not_termios.c_iflag = ~tty->termios->c_iflag;
+                digi_set_termios(tty, port, &not_termios);
+        }
 
         /* set DTR and RTS */
         digi_set_modem_signals(port, TIOCM_DTR|TIOCM_RTS, 1);
@@ -1391,16 +1376,16 @@ static int digi_open(struct usb_serial_port *port, struct file *filp)
 }
 
 
-static void digi_close(struct usb_serial_port *port, struct file *filp)
+static void digi_close(struct tty_struct *tty, struct usb_serial_port *port,
+                                struct file *filp)
 {
         DEFINE_WAIT(wait);
         int ret;
         unsigned char buf[32];
-        struct tty_struct *tty = port->tty;
         struct digi_port *priv = usb_get_serial_port_data(port);
 
         dbg("digi_close: TOP: port=%d, open_count=%d",
-                priv->dp_port_num, port->open_count);
+                priv->dp_port_num, port->port.count);
 
         mutex_lock(&port->serial->disc_mutex);
         /* if disconnected, just clear flags */
@@ -1663,7 +1648,7 @@ static int digi_read_inb_callback(struct urb *urb)
 {
 
         struct usb_serial_port *port = urb->context;
-        struct tty_struct *tty = port->tty;
+        struct tty_struct *tty = port->port.tty;
         struct digi_port *priv = usb_get_serial_port_data(port);
         int opcode = ((unsigned char *)urb->transfer_buffer)[0];
         int len = ((unsigned char *)urb->transfer_buffer)[1];
@@ -1675,7 +1660,7 @@ static int digi_read_inb_callback(struct urb *urb)
 
         /* do not process callbacks on closed ports */
         /* but do continue the read chain */
-        if (port->open_count == 0)
+        if (port->port.count == 0)
                 return 0;
 
         /* short/multiple packet check */
@@ -1785,17 +1770,17 @@ static int digi_read_oob_callback(struct urb *urb)
                         if (val & DIGI_READ_INPUT_SIGNALS_CTS) {
                                 priv->dp_modem_signals |= TIOCM_CTS;
                                 /* port must be open to use tty struct */
-                                if (port->open_count
-                                        && port->tty->termios->c_cflag & CRTSCTS) {
-                                        port->tty->hw_stopped = 0;
+                                if (port->port.count
+                                        && port->port.tty->termios->c_cflag & CRTSCTS) {
+                                        port->port.tty->hw_stopped = 0;
                                         digi_wakeup_write(port);
                                 }
                         } else {
                                 priv->dp_modem_signals &= ~TIOCM_CTS;
                                 /* port must be open to use tty struct */
-                                if (port->open_count
-                                        && port->tty->termios->c_cflag & CRTSCTS) {
-                                        port->tty->hw_stopped = 1;
+                                if (port->port.count
+                                        && port->port.tty->termios->c_cflag & CRTSCTS) {
+                                        port->port.tty->hw_stopped = 1;
                                 }
                         }
                         if (val & DIGI_READ_INPUT_SIGNALS_DSR)
diff --git a/drivers/usb/serial/empeg.c b/drivers/usb/serial/empeg.c
index c5ec309a3cb1..47ebdf5fad8e 100644
--- a/drivers/usb/serial/empeg.c
+++ b/drivers/usb/serial/empeg.c
@@ -31,7 +31,7 @@
  *      Moved MOD_DEC_USE_COUNT to end of empeg_close().
  * 
  * (12/03/2000) gb
- *      Added port->tty->ldisc.set_termios(port->tty, NULL) to empeg_open()
+ *      Added port->port.tty->ldisc.set_termios(port->port.tty, NULL) to empeg_open()
  *      This notifies the tty driver that the termios have changed.
  * 
  * (11/13/2000) gb
@@ -77,22 +77,18 @@ static int debug;
 #define EMPEG_PRODUCT_ID                0x0001
 
 /* function prototypes for an empeg-car player */
-static int  empeg_open                  (struct usb_serial_port *port, struct file *filp);
-static void empeg_close                 (struct usb_serial_port *port, struct file *filp);
-static int  empeg_write                 (struct usb_serial_port *port,
+static int  empeg_open                  (struct tty_struct *tty, struct usb_serial_port *port, struct file *filp);
+static void empeg_close                 (struct tty_struct *tty, struct usb_serial_port *port, struct file *filp);
+static int  empeg_write                 (struct tty_struct *tty, struct usb_serial_port *port,
                                         const unsigned char *buf,
                                         int count);
-static int  empeg_write_room            (struct usb_serial_port *port);
-static int  empeg_chars_in_buffer       (struct usb_serial_port *port);
-static void empeg_throttle              (struct usb_serial_port *port);
-static void empeg_unthrottle            (struct usb_serial_port *port);
+static int  empeg_write_room            (struct tty_struct *tty);
+static int  empeg_chars_in_buffer       (struct tty_struct *tty);
+static void empeg_throttle              (struct tty_struct *tty);
+static void empeg_unthrottle            (struct tty_struct *tty);
 static int  empeg_startup               (struct usb_serial *serial);
 static void empeg_shutdown              (struct usb_serial *serial);
-static int  empeg_ioctl                 (struct usb_serial_port *port,
-                                        struct file * file,
-                                        unsigned int cmd,
-                                        unsigned long arg);
-static void empeg_set_termios           (struct usb_serial_port *port, struct ktermios *old_termios);
+static void empeg_set_termios           (struct tty_struct *tty, struct usb_serial_port *port, struct ktermios *old_termios);
 static void empeg_write_bulk_callback   (struct urb *urb);
 static void empeg_read_bulk_callback    (struct urb *urb);
 
@@ -125,7 +121,6 @@ static struct usb_serial_driver empeg_device = {
         .unthrottle =           empeg_unthrottle,
         .attach =               empeg_startup,
         .shutdown =             empeg_shutdown,
-        .ioctl =                empeg_ioctl,
         .set_termios =          empeg_set_termios,
         .write =                empeg_write,
         .write_room =           empeg_write_room,
@@ -145,7 +140,8 @@ static int		bytes_out;
 /******************************************************************************
  * Empeg specific driver functions
  ******************************************************************************/
-static int empeg_open (struct usb_serial_port *port, struct file *filp)
+static int empeg_open(struct tty_struct *tty, struct usb_serial_port *port,
+                                struct file *filp)
 {
         struct usb_serial *serial = port->serial;
         int result = 0;
@@ -153,7 +149,7 @@ static int empeg_open (struct usb_serial_port *port, struct file *filp)
         dbg("%s - port %d", __func__, port->number);
 
         /* Force default termio settings */
-        empeg_set_termios (port, NULL) ;
+        empeg_set_termios (tty, port, NULL) ;
 
         bytes_in = 0;
         bytes_out = 0;
@@ -178,7 +174,8 @@ static int empeg_open (struct usb_serial_port *port, struct file *filp)
 }
 
 
-static void empeg_close (struct usb_serial_port *port, struct file * filp)
+static void empeg_close(struct tty_struct *tty, struct usb_serial_port *port,
+                                struct file * filp)
 {
         dbg("%s - port %d", __func__, port->number);
 
@@ -189,7 +186,7 @@ static void empeg_close (struct usb_serial_port *port, struct file * filp)
 }
 
 
-static int empeg_write (struct usb_serial_port *port, const unsigned char *buf, int count)
+static int empeg_write(struct tty_struct *tty, struct usb_serial_port *port, const unsigned char *buf, int count)
 {
         struct usb_serial *serial = port->serial;
         struct urb *urb;
@@ -203,7 +200,6 @@ static int empeg_write (struct usb_serial_port *port, const unsigned char *buf,
         dbg("%s - port %d", __func__, port->number);
 
         while (count > 0) {
-
                 /* try to find a free urb in our list of them */
                 urb = NULL;
 
@@ -262,15 +258,14 @@ static int empeg_write (struct usb_serial_port *port, const unsigned char *buf,
                 bytes_out += transfer_size;
 
         }
-
 exit:
         return bytes_sent;
-
 } 
 
 
-static int empeg_write_room (struct usb_serial_port *port)
+static int empeg_write_room(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         unsigned long flags;
         int i;
         int room = 0;
@@ -278,25 +273,22 @@ static int empeg_write_room (struct usb_serial_port *port)
         dbg("%s - port %d", __func__, port->number);
 
         spin_lock_irqsave (&write_urb_pool_lock, flags);
-
         /* tally up the number of bytes available */
         for (i = 0; i < NUM_URBS; ++i) {
                 if (write_urb_pool[i]->status != -EINPROGRESS) {
                         room += URB_TRANSFER_BUFFER_SIZE;
                 }
         } 
-
         spin_unlock_irqrestore (&write_urb_pool_lock, flags);
-
         dbg("%s - returns %d", __func__, room);
-
-        return (room);
+        return room;
 
 }
 
 
-static int empeg_chars_in_buffer (struct usb_serial_port *port)
+static int empeg_chars_in_buffer(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         unsigned long flags;
         int i;
         int chars = 0;
@@ -356,7 +348,7 @@ static void empeg_read_bulk_callback (struct urb *urb)
 
         usb_serial_debug_data(debug, &port->dev, __func__, urb->actual_length, data);
 
-        tty = port->tty;
+        tty = port->port.tty;
 
         if (urb->actual_length) {
                 tty_buffer_request_room(tty, urb->actual_length);
@@ -386,27 +378,24 @@ static void empeg_read_bulk_callback (struct urb *urb)
 }
 
 
-static void empeg_throttle (struct usb_serial_port *port)
+static void empeg_throttle(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         dbg("%s - port %d", __func__, port->number);
         usb_kill_urb(port->read_urb);
 }
 
 
-static void empeg_unthrottle (struct usb_serial_port *port)
+static void empeg_unthrottle(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         int result;
-
         dbg("%s - port %d", __func__, port->number);
 
         port->read_urb->dev = port->serial->dev;
-
         result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
-
         if (result)
                 dev_err(&port->dev, "%s - failed submitting read urb, error %d\n", __func__, result);
-
-        return;
 }
 
 
@@ -436,17 +425,10 @@ static void empeg_shutdown (struct usb_serial *serial)
 }
 
 
-static int empeg_ioctl (struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg)
-{
-        dbg("%s - port %d, cmd 0x%.4x", __func__, port->number, cmd);
-
-        return -ENOIOCTLCMD;
-}
-
-
-static void empeg_set_termios (struct usb_serial_port *port, struct ktermios *old_termios)
+static void empeg_set_termios(struct tty_struct *tty,
+                struct usb_serial_port *port, struct ktermios *old_termios)
 {
-        struct ktermios *termios = port->tty->termios;
+        struct ktermios *termios = tty->termios;
         dbg("%s - port %d", __func__, port->number);
 
         /*
@@ -491,8 +473,8 @@ static void empeg_set_termios (struct usb_serial_port *port, struct ktermios *ol
          * this is bad as it opens up the possibility of dropping bytes
          * on the floor.  We don't want to drop bytes on the floor. :)
          */
-        port->tty->low_latency = 1;
-        tty_encode_baud_rate(port->tty, 115200, 115200);
+        tty->low_latency = 1;
+        tty_encode_baud_rate(tty, 115200, 115200);
 }
 
 
diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
index 0ff4a3971e45..abbb447e5375 100644
--- a/drivers/usb/serial/ftdi_sio.c
+++ b/drivers/usb/serial/ftdi_sio.c
@@ -682,21 +682,21 @@ static int  ftdi_sio_probe	(struct usb_serial *serial, const struct usb_device_i
 static void ftdi_shutdown               (struct usb_serial *serial);
 static int  ftdi_sio_port_probe (struct usb_serial_port *port);
 static int  ftdi_sio_port_remove        (struct usb_serial_port *port);
-static int  ftdi_open                   (struct usb_serial_port *port, struct file *filp);
-static void ftdi_close                  (struct usb_serial_port *port, struct file *filp);
-static int  ftdi_write                  (struct usb_serial_port *port, const unsigned char *buf, int count);
-static int  ftdi_write_room             (struct usb_serial_port *port);
-static int  ftdi_chars_in_buffer        (struct usb_serial_port *port);
+static int  ftdi_open                   (struct tty_struct *tty, struct usb_serial_port *port, struct file *filp);
+static void ftdi_close                  (struct tty_struct *tty, struct usb_serial_port *port, struct file *filp);
+static int  ftdi_write                  (struct tty_struct *tty, struct usb_serial_port *port, const unsigned char *buf, int count);
+static int  ftdi_write_room             (struct tty_struct *tty);
+static int  ftdi_chars_in_buffer        (struct tty_struct *tty);
 static void ftdi_write_bulk_callback    (struct urb *urb);
 static void ftdi_read_bulk_callback     (struct urb *urb);
 static void ftdi_process_read           (struct work_struct *work);
-static void ftdi_set_termios            (struct usb_serial_port *port, struct ktermios * old);
-static int  ftdi_tiocmget               (struct usb_serial_port *port, struct file *file);
-static int  ftdi_tiocmset               (struct usb_serial_port *port, struct file * file, unsigned int set, unsigned int clear);
-static int  ftdi_ioctl                  (struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg);
-static void ftdi_break_ctl              (struct usb_serial_port *port, int break_state );
-static void ftdi_throttle               (struct usb_serial_port *port);
-static void ftdi_unthrottle             (struct usb_serial_port *port);
+static void ftdi_set_termios            (struct tty_struct *tty, struct usb_serial_port *port, struct ktermios * old);
+static int  ftdi_tiocmget               (struct tty_struct *tty, struct file *file);
+static int  ftdi_tiocmset               (struct tty_struct *tty, struct file * file, unsigned int set, unsigned int clear);
+static int  ftdi_ioctl                  (struct tty_struct *tty, struct file * file, unsigned int cmd, unsigned long arg);
+static void ftdi_break_ctl              (struct tty_struct *tty, int break_state );
+static void ftdi_throttle               (struct tty_struct *tty);
+static void ftdi_unthrottle             (struct tty_struct *tty);
 
 static unsigned short int ftdi_232am_baud_base_to_divisor (int baud, int base);
 static unsigned short int ftdi_232am_baud_to_divisor (int baud);
@@ -843,42 +843,7 @@ static int update_mctrl(struct usb_serial_port *port, unsigned int set, unsigned
 }
 
 
-static __u32 get_ftdi_divisor(struct usb_serial_port * port);
-
-
-static int change_speed(struct usb_serial_port *port)
-{
-        struct ftdi_private *priv = usb_get_serial_port_data(port);
-        char *buf;
-        __u16 urb_value;
-        __u16 urb_index;
-        __u32 urb_index_value;
-        int rv;
-
-        buf = kmalloc(1, GFP_NOIO);
-        if (!buf)
-                return -ENOMEM;
-
-        urb_index_value = get_ftdi_divisor(port);
-        urb_value = (__u16)urb_index_value;
-        urb_index = (__u16)(urb_index_value >> 16);
-        if (priv->interface) {  /* FT2232C */
-                urb_index = (__u16)((urb_index << 8) | priv->interface);
-        }
-
-        rv = usb_control_msg(port->serial->dev,
-                            usb_sndctrlpipe(port->serial->dev, 0),
-                            FTDI_SIO_SET_BAUDRATE_REQUEST,
-                            FTDI_SIO_SET_BAUDRATE_REQUEST_TYPE,
-                            urb_value, urb_index,
-                            buf, 0, WDR_SHORT_TIMEOUT);
-
-        kfree(buf);
-        return rv;
-}
-
-
-static __u32 get_ftdi_divisor(struct usb_serial_port * port)
+static __u32 get_ftdi_divisor(struct tty_struct *tty, struct usb_serial_port *port)
 { /* get_ftdi_divisor */
         struct ftdi_private *priv = usb_get_serial_port_data(port);
         __u32 div_value = 0;
@@ -910,7 +875,7 @@ static __u32 get_ftdi_divisor(struct usb_serial_port * port)
 
         /* 1. Get the baud rate from the tty settings, this observes alt_speed hack */
 
-        baud = tty_get_baud_rate(port->tty);
+        baud = tty_get_baud_rate(tty);
         dbg("%s - tty_get_baud_rate reports speed %d", __func__, baud);
 
         /* 2. Observe async-compatible custom_divisor hack, update baudrate if needed */
@@ -976,10 +941,42 @@ static __u32 get_ftdi_divisor(struct usb_serial_port * port)
                         ftdi_chip_name[priv->chip_type]);
         }
 
-        tty_encode_baud_rate(port->tty, baud, baud);
+        tty_encode_baud_rate(tty, baud, baud);
         return(div_value);
 }
 
+static int change_speed(struct tty_struct *tty, struct usb_serial_port *port)
+{
+        struct ftdi_private *priv = usb_get_serial_port_data(port);
+        char *buf;
+        __u16 urb_value;
+        __u16 urb_index;
+        __u32 urb_index_value;
+        int rv;
+
+        buf = kmalloc(1, GFP_NOIO);
+        if (!buf)
+                return -ENOMEM;
+
+        urb_index_value = get_ftdi_divisor(tty, port);
+        urb_value = (__u16)urb_index_value;
+        urb_index = (__u16)(urb_index_value >> 16);
+        if (priv->interface) {  /* FT2232C */
+                urb_index = (__u16)((urb_index << 8) | priv->interface);
+        }
+
+        rv = usb_control_msg(port->serial->dev,
+                            usb_sndctrlpipe(port->serial->dev, 0),
+                            FTDI_SIO_SET_BAUDRATE_REQUEST,
+                            FTDI_SIO_SET_BAUDRATE_REQUEST_TYPE,
+                            urb_value, urb_index,
+                            buf, 0, WDR_SHORT_TIMEOUT);
+
+        kfree(buf);
+        return rv;
+}
+
+
 
 static int get_serial_info(struct usb_serial_port * port, struct serial_struct __user * retinfo)
 {
@@ -998,7 +995,8 @@ static int get_serial_info(struct usb_serial_port * port, struct serial_struct _
 } /* get_serial_info */
 
 
-static int set_serial_info(struct usb_serial_port * port, struct serial_struct __user * newinfo)
+static int set_serial_info(struct tty_struct *tty,
+        struct usb_serial_port * port, struct serial_struct __user * newinfo)
 { /* set_serial_info */
         struct ftdi_private *priv = usb_get_serial_port_data(port);
         struct serial_struct new_serial;
@@ -1030,30 +1028,29 @@ static int set_serial_info(struct usb_serial_port * port, struct serial_struct _
                        (new_serial.flags & ASYNC_FLAGS));
         priv->custom_divisor = new_serial.custom_divisor;
 
-        port->tty->low_latency = (priv->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
+        tty->low_latency = (priv->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
 
 check_and_exit:
         if ((old_priv.flags & ASYNC_SPD_MASK) !=
              (priv->flags & ASYNC_SPD_MASK)) {
                 if ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
-                        port->tty->alt_speed = 57600;
+                        tty->alt_speed = 57600;
                 else if ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
-                        port->tty->alt_speed = 115200;
+                        tty->alt_speed = 115200;
                 else if ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
-                        port->tty->alt_speed = 230400;
+                        tty->alt_speed = 230400;
                 else if ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
-                        port->tty->alt_speed = 460800;
+                        tty->alt_speed = 460800;
                 else
-                        port->tty->alt_speed = 0;
+                        tty->alt_speed = 0;
         }
         if (((old_priv.flags & ASYNC_SPD_MASK) !=
              (priv->flags & ASYNC_SPD_MASK)) ||
             (((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST) &&
              (old_priv.custom_divisor != priv->custom_divisor))) {
-                change_speed(port);
+                change_speed(tty, port);
         }
-
-        return (0);
+        return 0;
 
 } /* set_serial_info */
 
@@ -1415,7 +1412,8 @@ static int ftdi_sio_port_remove(struct usb_serial_port *port)
         return 0;
 }
 
-static int  ftdi_open (struct usb_serial_port *port, struct file *filp)
+static int ftdi_open(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 { /* ftdi_open */
         struct usb_device *dev = port->serial->dev;
         struct ftdi_private *priv = usb_get_serial_port_data(port);
@@ -1433,8 +1431,8 @@ static int  ftdi_open (struct usb_serial_port *port, struct file *filp)
         priv->rx_bytes = 0;
         spin_unlock_irqrestore(&priv->rx_lock, flags);
 
-        if (port->tty)
-                port->tty->low_latency = (priv->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
+        if (tty)
+                tty->low_latency = (priv->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
 
         /* No error checking for this (will get errors later anyway) */
         /* See ftdi_sio.h for description of what is reset */
@@ -1448,8 +1446,8 @@ static int  ftdi_open (struct usb_serial_port *port, struct file *filp)
            This is same behaviour as serial.c/rs_open() - Kuba */
 
         /* ftdi_set_termios  will send usb control messages */
-        if (port->tty)
-                ftdi_set_termios(port, port->tty->termios);
+        if (tty)
+                ftdi_set_termios(tty, port, tty->termios);
 
         /* FIXME: Flow control might be enabled, so it should be checked -
            we have no control of defaults! */
@@ -1485,9 +1483,10 @@ static int  ftdi_open (struct usb_serial_port *port, struct file *filp)
  *
  */
 
-static void ftdi_close (struct usb_serial_port *port, struct file *filp)
+static void ftdi_close(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 { /* ftdi_close */
-        unsigned int c_cflag = port->tty->termios->c_cflag;
+        unsigned int c_cflag = tty->termios->c_cflag;
         struct ftdi_private *priv = usb_get_serial_port_data(port);
         char buf[1];
 
@@ -1527,7 +1526,7 @@ static void ftdi_close (struct usb_serial_port *port, struct file *filp)
  *
  * The new devices do not require this byte
  */
-static int ftdi_write (struct usb_serial_port *port,
+static int ftdi_write(struct tty_struct *tty, struct usb_serial_port *port,
                            const unsigned char *buf, int count)
 { /* ftdi_write */
         struct ftdi_private *priv = usb_get_serial_port_data(port);
@@ -1686,8 +1685,9 @@ static void ftdi_write_bulk_callback (struct urb *urb)
 } /* ftdi_write_bulk_callback */
 
 
-static int ftdi_write_room( struct usb_serial_port *port )
+static int ftdi_write_room(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct ftdi_private *priv = usb_get_serial_port_data(port);
         int room;
         unsigned long flags;
@@ -1707,11 +1707,11 @@ static int ftdi_write_room( struct usb_serial_port *port )
         }
         spin_unlock_irqrestore(&priv->tx_lock, flags);
         return room;
-} /* ftdi_write_room */
-
+}
 
-static int ftdi_chars_in_buffer (struct usb_serial_port *port)
-{ /* ftdi_chars_in_buffer */
+static int ftdi_chars_in_buffer(struct tty_struct *tty)
+{
+        struct usb_serial_port *port = tty->driver_data;
         struct ftdi_private *priv = usb_get_serial_port_data(port);
         int buffered;
         unsigned long flags;
@@ -1726,12 +1726,10 @@ static int ftdi_chars_in_buffer (struct usb_serial_port *port)
                 buffered = 0;
         }
         return buffered;
-} /* ftdi_chars_in_buffer */
-
-
+}
 
-static void ftdi_read_bulk_callback (struct urb *urb)
-{ /* ftdi_read_bulk_callback */
+static void ftdi_read_bulk_callback(struct urb *urb)
+{
         struct usb_serial_port *port = urb->context;
         struct tty_struct *tty;
         struct ftdi_private *priv;
@@ -1747,10 +1745,10 @@ static void ftdi_read_bulk_callback (struct urb *urb)
 
         dbg("%s - port %d", __func__, port->number);
 
-        if (port->open_count <= 0)
+        if (port->port.count <= 0)
                 return;
 
-        tty = port->tty;
+        tty = port->port.tty;
         if (!tty) {
                 dbg("%s - bad tty pointer - exiting",__func__);
                 return;
@@ -1803,10 +1801,10 @@ static void ftdi_process_read (struct work_struct *work)
 
         dbg("%s - port %d", __func__, port->number);
 
-        if (port->open_count <= 0)
+        if (port->port.count <= 0)
                 return;
 
-        tty = port->tty;
+        tty = port->port.tty;
         if (!tty) {
                 dbg("%s - bad tty pointer - exiting",__func__);
                 return;
@@ -1954,7 +1952,7 @@ static void ftdi_process_read (struct work_struct *work)
                 }
                 spin_unlock_irqrestore(&priv->rx_lock, flags);
                 /* if the port is closed stop trying to read */
-                if (port->open_count > 0){
+                if (port->port.count > 0){
                         /* delay processing of remainder */
                         schedule_delayed_work(&priv->rx_work, 1);
                 } else {
@@ -1967,7 +1965,7 @@ static void ftdi_process_read (struct work_struct *work)
         priv->rx_processed = 0;
 
         /* if the port is closed stop trying to read */
-        if (port->open_count > 0){
+        if (port->port.count > 0){
                 /* Continue trying to always read  */
                 usb_fill_bulk_urb(port->read_urb, port->serial->dev,
                               usb_rcvbulkpipe(port->serial->dev, port->bulk_in_endpointAddress),
@@ -1983,8 +1981,9 @@ static void ftdi_process_read (struct work_struct *work)
 } /* ftdi_process_read */
 
 
-static void ftdi_break_ctl( struct usb_serial_port *port, int break_state )
+static void ftdi_break_ctl(struct tty_struct *tty, int break_state)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct ftdi_private *priv = usb_get_serial_port_data(port);
         __u16 urb_value = 0;
         char buf[1];
@@ -2018,11 +2017,12 @@ static void ftdi_break_ctl( struct usb_serial_port *port, int break_state )
  * WARNING: set_termios calls this with old_termios in kernel space
  */
 
-static void ftdi_set_termios (struct usb_serial_port *port, struct ktermios *old_termios)
+static void ftdi_set_termios(struct tty_struct *tty,
+                struct usb_serial_port *port, struct ktermios *old_termios)
 { /* ftdi_termios */
         struct usb_device *dev = port->serial->dev;
         struct ftdi_private *priv = usb_get_serial_port_data(port);
-        struct ktermios *termios = port->tty->termios;
+        struct ktermios *termios = tty->termios;
         unsigned int cflag = termios->c_cflag;
         __u16 urb_value; /* will hold the new flags */
         char buf[1]; /* Perhaps I should dynamically alloc this? */
@@ -2037,7 +2037,7 @@ static void ftdi_set_termios (struct usb_serial_port *port, struct ktermios *old
         /* Force baud rate if this device requires it, unless it is set to B0. */
         if (priv->force_baud && ((termios->c_cflag & CBAUD) != B0)) {
                 dbg("%s: forcing baud rate for this device", __func__);
-                tty_encode_baud_rate(port->tty, priv->force_baud,
+                tty_encode_baud_rate(tty, priv->force_baud,
                                         priv->force_baud);
         }
 
@@ -2104,7 +2104,7 @@ static void ftdi_set_termios (struct usb_serial_port *port, struct ktermios *old
                 clear_mctrl(port, TIOCM_DTR | TIOCM_RTS);
         } else {
                 /* set the baudrate determined before */
-                if (change_speed(port)) {
+                if (change_speed(tty, port)) {
                         err("%s urb failed to set baudrate", __func__);
                 }
                 /* Ensure RTS and DTR are raised when baudrate changed from 0 */
@@ -2168,11 +2168,11 @@ static void ftdi_set_termios (struct usb_serial_port *port, struct ktermios *old
 
         }
         return;
-} /* ftdi_termios */
-
+}
 
-static int ftdi_tiocmget (struct usb_serial_port *port, struct file *file)
+static int ftdi_tiocmget(struct tty_struct *tty, struct file *file)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct ftdi_private *priv = usb_get_serial_port_data(port);
         unsigned char buf[2];
         int ret;
@@ -2221,15 +2221,18 @@ static int ftdi_tiocmget (struct usb_serial_port *port, struct file *file)
                 priv->last_dtr_rts;
 }
 
-static int ftdi_tiocmset(struct usb_serial_port *port, struct file * file, unsigned int set, unsigned int clear)
+static int ftdi_tiocmset(struct tty_struct *tty, struct file * file,
+                        unsigned int set, unsigned int clear)
 {
+        struct usb_serial_port *port = tty->driver_data;
         dbg("%s TIOCMSET", __func__);
         return update_mctrl(port, set, clear);
 }
 
 
-static int ftdi_ioctl (struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg)
+static int ftdi_ioctl(struct tty_struct *tty, struct file * file, unsigned int cmd, unsigned long arg)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct ftdi_private *priv = usb_get_serial_port_data(port);
 
         dbg("%s cmd 0x%04x", __func__, cmd);
@@ -2241,7 +2244,7 @@ static int ftdi_ioctl (struct usb_serial_port *port, struct file * file, unsigne
                 return get_serial_info(port, (struct serial_struct __user *) arg);
 
         case TIOCSSERIAL: /* sets serial port data */
-                return set_serial_info(port, (struct serial_struct __user *) arg);
+                return set_serial_info(tty, port, (struct serial_struct __user *) arg);
 
         /*
          * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
@@ -2280,25 +2283,20 @@ static int ftdi_ioctl (struct usb_serial_port *port, struct file * file, unsigne
                                  */
                         }
                 }
-                return(0);
-                break;
+                return 0;
         default:
                 break;
-
         }
-
-
         /* This is not necessarily an error - turns out the higher layers will do
          *  some ioctls itself (see comment above)
          */
         dbg("%s arg not supported - it was 0x%04x - check /usr/include/asm/ioctls.h", __func__, cmd);
+        return -ENOIOCTLCMD;
+}
 
-        return(-ENOIOCTLCMD);
-} /* ftdi_ioctl */
-
-
-static void ftdi_throttle (struct usb_serial_port *port)
+static void ftdi_throttle(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct ftdi_private *priv = usb_get_serial_port_data(port);
         unsigned long flags;
 
@@ -2310,8 +2308,9 @@ static void ftdi_throttle (struct usb_serial_port *port)
 }
 
 
-static void ftdi_unthrottle (struct usb_serial_port *port)
+static void ftdi_unthrottle(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct ftdi_private *priv = usb_get_serial_port_data(port);
         int actually_throttled;
         unsigned long flags;
diff --git a/drivers/usb/serial/garmin_gps.c b/drivers/usb/serial/garmin_gps.c
index 8ce5a56a48e3..06cfa43c6f02 100644
--- a/drivers/usb/serial/garmin_gps.c
+++ b/drivers/usb/serial/garmin_gps.c
@@ -275,7 +275,7 @@ static inline int isAbortTrfCmnd(const unsigned char *buf)
 static void send_to_tty(struct usb_serial_port *port,
                         char *data, unsigned int actual_length)
 {
-        struct tty_struct *tty = port->tty;
+        struct tty_struct *tty = port->port.tty;
 
         if (tty && actual_length) {
 
@@ -970,7 +970,8 @@ static int garmin_init_session(struct usb_serial_port *port)
 
 
 
-static int garmin_open (struct usb_serial_port *port, struct file *filp)
+static int garmin_open (struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 {
         unsigned long flags;
         int status = 0;
@@ -983,8 +984,8 @@ static int garmin_open (struct usb_serial_port *port, struct file *filp)
          * through, otherwise it is scheduled, and with high data rates (like
          * with OHCI) data can get lost.
          */
-        if (port->tty)
-                port->tty->low_latency = 1;
+        if (tty)
+                tty->low_latency = 1;
 
         spin_lock_irqsave(&garmin_data_p->lock, flags);
         garmin_data_p->mode  = initial_mode;
@@ -998,17 +999,16 @@ static int garmin_open (struct usb_serial_port *port, struct file *filp)
         usb_kill_urb (port->write_urb);
         usb_kill_urb (port->read_urb);
 
-        if (garmin_data_p->state == STATE_RESET) {
+        if (garmin_data_p->state == STATE_RESET)
                 status = garmin_init_session(port);
-        }
 
         garmin_data_p->state = STATE_ACTIVE;
-
         return status;
 }
 
 
-static void garmin_close (struct usb_serial_port *port, struct file * filp)
+static void garmin_close(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file * filp)
 {
         struct usb_serial *serial = port->serial;
         struct garmin_data * garmin_data_p = usb_get_serial_port_data(port);
@@ -1042,7 +1042,6 @@ static void garmin_close (struct usb_serial_port *port, struct file * filp)
         mutex_unlock(&port->serial->disc_mutex);
 }
 
-
 static void garmin_write_bulk_callback (struct urb *urb)
 {
         unsigned long flags;
@@ -1145,10 +1144,8 @@ static int garmin_write_bulk (struct usb_serial_port *port,
         return count;
 }
 
-
-
-static int garmin_write (struct usb_serial_port *port,
-                         const unsigned char *buf, int count)
+static int garmin_write (struct tty_struct *tty, struct usb_serial_port *port,
+                                         const unsigned char *buf, int count)
 {
         int pktid, pktsiz, len;
         struct garmin_data * garmin_data_p = usb_get_serial_port_data(port);
@@ -1158,7 +1155,6 @@ static int garmin_write (struct usb_serial_port *port,
 
         /* check for our private packets */
         if (count >= GARMIN_PKTHDR_LENGTH) {
-
                 len = PRIVPKTSIZ;
                 if (count < len)
                         len = count;
@@ -1226,8 +1222,9 @@ static int garmin_write (struct usb_serial_port *port,
 }
 
 
-static int garmin_write_room (struct usb_serial_port *port)
+static int garmin_write_room(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         /*
          * Report back the bytes currently available in the output buffer.
          */
@@ -1236,20 +1233,6 @@ static int garmin_write_room (struct usb_serial_port *port)
 }
 
 
-static int garmin_chars_in_buffer (struct usb_serial_port *port)
-{
-        /*
-         * Report back the number of bytes currently in our input buffer.
-         * Will this lock up the driver - the buffer contains an incomplete
-         * package which will not be written to the device until it
-         * has been completed ?
-         */
-        //struct garmin_data * garmin_data_p = usb_get_serial_port_data(port);
-        //return garmin_data_p->insize;
-        return 0;
-}
-
-
 static void garmin_read_process(struct garmin_data * garmin_data_p,
                                  unsigned char *data, unsigned data_length)
 {
@@ -1468,10 +1451,11 @@ static int garmin_flush_queue(struct garmin_data * garmin_data_p)
 }
 
 
-static void garmin_throttle (struct usb_serial_port *port)
+static void garmin_throttle(struct tty_struct *tty)
 {
-        unsigned long flags;
+        struct usb_serial_port *port = tty->driver_data;
         struct garmin_data * garmin_data_p = usb_get_serial_port_data(port);
+        unsigned long flags;
 
         dbg("%s - port %d", __func__, port->number);
         /* set flag, data received will be put into a queue
@@ -1482,10 +1466,11 @@ static void garmin_throttle (struct usb_serial_port *port)
 }
 
 
-static void garmin_unthrottle (struct usb_serial_port *port)
+static void garmin_unthrottle (struct tty_struct *tty)
 {
-        unsigned long flags;
+        struct usb_serial_port *port = tty->driver_data;
         struct garmin_data * garmin_data_p = usb_get_serial_port_data(port);
+        unsigned long flags;
         int status;
 
         dbg("%s - port %d", __func__, port->number);
@@ -1507,8 +1492,6 @@ static void garmin_unthrottle (struct usb_serial_port *port)
         }
 }
 
-
-
 /*
  * The timer is currently only used to send queued packets to
  * the tty in cases where the protocol provides no own handshaking
@@ -1526,7 +1509,7 @@ static void timeout_handler(unsigned long data)
 
 
 
-static int garmin_attach (struct usb_serial *serial)
+static int garmin_attach(struct usb_serial *serial)
 {
         int status = 0;
         struct usb_serial_port *port = serial->port[0];
@@ -1556,7 +1539,7 @@ static int garmin_attach (struct usb_serial *serial)
 }
 
 
-static void garmin_shutdown (struct usb_serial *serial)
+static void garmin_shutdown(struct usb_serial *serial)
 {
         struct usb_serial_port *port = serial->port[0];
         struct garmin_data * garmin_data_p = usb_get_serial_port_data(port);
@@ -1588,7 +1571,6 @@ static struct usb_serial_driver garmin_device = {
         .shutdown            = garmin_shutdown,
         .write               = garmin_write,
         .write_room          = garmin_write_room,
-        .chars_in_buffer     = garmin_chars_in_buffer,
         .write_bulk_callback = garmin_write_bulk_callback,
         .read_bulk_callback  = garmin_read_bulk_callback,
         .read_int_callback   = garmin_read_int_callback,
diff --git a/drivers/usb/serial/generic.c b/drivers/usb/serial/generic.c
index 537f12a027c2..5128018c2766 100644
--- a/drivers/usb/serial/generic.c
+++ b/drivers/usb/serial/generic.c
@@ -112,7 +112,8 @@ void usb_serial_generic_deregister (void)
 #endif
 }
 
-int usb_serial_generic_open (struct usb_serial_port *port, struct file *filp)
+int usb_serial_generic_open(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 {
         struct usb_serial *serial = port->serial;
         int result = 0;
@@ -123,8 +124,8 @@ int usb_serial_generic_open (struct usb_serial_port *port, struct file *filp)
         /* force low_latency on so that our tty_push actually forces the data through, 
            otherwise it is scheduled, and with high data rates (like with OHCI) data
            can get lost. */
-        if (port->tty)
-                port->tty->low_latency = 1;
+        if (tty)
+                tty->low_latency = 1;
 
         /* clear the throttle flags */
         spin_lock_irqsave(&port->lock, flags);
@@ -152,7 +153,7 @@ int usb_serial_generic_open (struct usb_serial_port *port, struct file *filp)
 }
 EXPORT_SYMBOL_GPL(usb_serial_generic_open);
 
-static void generic_cleanup (struct usb_serial_port *port)
+static void generic_cleanup(struct usb_serial_port *port)
 {
         struct usb_serial *serial = port->serial;
 
@@ -182,7 +183,7 @@ int usb_serial_generic_resume(struct usb_serial *serial)
 #endif
         for (i = 0; i < serial->num_ports; i++) {
                 port = serial->port[i];
-                if (port->open_count && port->read_urb) {
+                if (port->port.count && port->read_urb) {
                         r = usb_submit_urb(port->read_urb, GFP_NOIO);
                         if (r < 0)
                                 c++;
@@ -192,13 +193,15 @@ int usb_serial_generic_resume(struct usb_serial *serial)
         return c ? -EIO : 0;
 }
 
-void usb_serial_generic_close (struct usb_serial_port *port, struct file * filp)
+void usb_serial_generic_close(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file * filp)
 {
         dbg("%s - port %d", __func__, port->number);
         generic_cleanup (port);
 }
 
-int usb_serial_generic_write(struct usb_serial_port *port, const unsigned char *buf, int count)
+int usb_serial_generic_write(struct tty_struct *tty,
+        struct usb_serial_port *port, const unsigned char *buf, int count)
 {
         struct usb_serial *serial = port->serial;
         int result;
@@ -255,8 +258,9 @@ int usb_serial_generic_write(struct usb_serial_port *port, const unsigned char *
         return 0;
 }
 
-int usb_serial_generic_write_room (struct usb_serial_port *port)
+int usb_serial_generic_write_room (struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct usb_serial *serial = port->serial;
         int room = 0;
 
@@ -272,8 +276,9 @@ int usb_serial_generic_write_room (struct usb_serial_port *port)
         return room;
 }
 
-int usb_serial_generic_chars_in_buffer (struct usb_serial_port *port)
+int usb_serial_generic_chars_in_buffer(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct usb_serial *serial = port->serial;
         int chars = 0;
 
@@ -286,7 +291,7 @@ int usb_serial_generic_chars_in_buffer (struct usb_serial_port *port)
         }
 
         dbg("%s - returns %d", __func__, chars);
-        return (chars);
+        return chars;
 }
 
 
@@ -311,10 +316,10 @@ static void resubmit_read_urb(struct usb_serial_port *port, gfp_t mem_flags)
 }
 
 /* Push data to tty layer and resubmit the bulk read URB */
-static void flush_and_resubmit_read_urb (struct usb_serial_port *port)
+static void flush_and_resubmit_read_urb(struct usb_serial_port *port)
 {
         struct urb *urb = port->read_urb;
-        struct tty_struct *tty = port->tty;
+        struct tty_struct *tty = port->port.tty;
         int room;
 
         /* Push data to tty */
@@ -329,7 +334,7 @@ static void flush_and_resubmit_read_urb (struct usb_serial_port *port)
         resubmit_read_urb(port, GFP_ATOMIC);
 }
 
-void usb_serial_generic_read_bulk_callback (struct urb *urb)
+void usb_serial_generic_read_bulk_callback(struct urb *urb)
 {
         struct usb_serial_port *port = urb->context;
         unsigned char *data = urb->transfer_buffer;
@@ -357,7 +362,7 @@ void usb_serial_generic_read_bulk_callback (struct urb *urb)
 }
 EXPORT_SYMBOL_GPL(usb_serial_generic_read_bulk_callback);
 
-void usb_serial_generic_write_bulk_callback (struct urb *urb)
+void usb_serial_generic_write_bulk_callback(struct urb *urb)
 {
         struct usb_serial_port *port = urb->context;
         int status = urb->status;
@@ -374,8 +379,9 @@ void usb_serial_generic_write_bulk_callback (struct urb *urb)
 }
 EXPORT_SYMBOL_GPL(usb_serial_generic_write_bulk_callback);
 
-void usb_serial_generic_throttle (struct usb_serial_port *port)
+void usb_serial_generic_throttle(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         unsigned long flags;
 
         dbg("%s - port %d", __func__, port->number);
@@ -387,8 +393,9 @@ void usb_serial_generic_throttle (struct usb_serial_port *port)
         spin_unlock_irqrestore(&port->lock, flags);
 }
 
-void usb_serial_generic_unthrottle (struct usb_serial_port *port)
+void usb_serial_generic_unthrottle(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         int was_throttled;
         unsigned long flags;
 
diff --git a/drivers/usb/serial/io_edgeport.c b/drivers/usb/serial/io_edgeport.c
index 2fd449bcfa35..29346d79df7b 100644
--- a/drivers/usb/serial/io_edgeport.c
+++ b/drivers/usb/serial/io_edgeport.c
@@ -206,18 +206,18 @@ static void edge_bulk_out_data_callback	(struct urb *urb);
 static void edge_bulk_out_cmd_callback  (struct urb *urb);
 
 /* function prototypes for the usbserial callbacks */
-static int  edge_open                   (struct usb_serial_port *port, struct file *filp);
-static void edge_close                  (struct usb_serial_port *port, struct file *filp);
-static int  edge_write                  (struct usb_serial_port *port, const unsigned char *buf, int count);
-static int  edge_write_room             (struct usb_serial_port *port);
-static int  edge_chars_in_buffer        (struct usb_serial_port *port);
-static void edge_throttle               (struct usb_serial_port *port);
-static void edge_unthrottle             (struct usb_serial_port *port);
-static void edge_set_termios            (struct usb_serial_port *port, struct ktermios *old_termios);
-static int  edge_ioctl                  (struct usb_serial_port *port, struct file *file, unsigned int cmd, unsigned long arg);
-static void edge_break                  (struct usb_serial_port *port, int break_state);
-static int  edge_tiocmget               (struct usb_serial_port *port, struct file *file);
-static int  edge_tiocmset               (struct usb_serial_port *port, struct file *file, unsigned int set, unsigned int clear);
+static int  edge_open                   (struct tty_struct *tty, struct usb_serial_port *port, struct file *filp);
+static void edge_close                  (struct tty_struct *tty, struct usb_serial_port *port, struct file *filp);
+static int  edge_write                  (struct tty_struct *tty, struct usb_serial_port *port, const unsigned char *buf, int count);
+static int  edge_write_room             (struct tty_struct *tty);
+static int  edge_chars_in_buffer        (struct tty_struct *tty);
+static void edge_throttle               (struct tty_struct *tty);
+static void edge_unthrottle             (struct tty_struct *tty);
+static void edge_set_termios            (struct tty_struct *tty, struct usb_serial_port *port, struct ktermios *old_termios);
+static int  edge_ioctl                  (struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg);
+static void edge_break                  (struct tty_struct *tty, int break_state);
+static int  edge_tiocmget               (struct tty_struct *tty, struct file *file);
+static int  edge_tiocmset               (struct tty_struct *tty, struct file *file, unsigned int set, unsigned int clear);
 static int  edge_startup                (struct usb_serial *serial);
 static void edge_shutdown               (struct usb_serial *serial);
 
@@ -233,7 +233,8 @@ static void handle_new_lsr		(struct edgeport_port *edge_port, __u8 lsrData, __u8
 static int  send_iosp_ext_cmd           (struct edgeport_port *edge_port, __u8 command, __u8 param);
 static int  calc_baud_rate_divisor      (int baud_rate, int *divisor);
 static int  send_cmd_write_baud_rate    (struct edgeport_port *edge_port, int baudRate);
-static void change_port_settings        (struct edgeport_port *edge_port, struct ktermios *old_termios);
+static void change_port_settings        (struct tty_struct *tty, struct edgeport_port *edge_port,
+                                         struct ktermios *old_termios);
 static int  send_cmd_write_uart_register        (struct edgeport_port *edge_port, __u8 regNum, __u8 regValue);
 static int  write_cmd_usb               (struct edgeport_port *edge_port, unsigned char *buffer, int writeLength);
 static void send_more_port_data         (struct edgeport_serial *edge_serial, struct edgeport_port *edge_port);
@@ -639,8 +640,8 @@ static void edge_interrupt_callback (struct urb *urb)
                                         dbg("%s - txcredits for port%d = %d", __func__, portNumber, edge_port->txCredits);
 
                                         /* tell the tty driver that something has changed */
-                                        if (edge_port->port->tty)
-                                                tty_wakeup(edge_port->port->tty);
+                                        if (edge_port->port->port.tty)
+                                                tty_wakeup(edge_port->port->port.tty);
 
                                         // Since we have more credit, check if more data can be sent
                                         send_more_port_data(edge_serial, edge_port);
@@ -737,7 +738,7 @@ static void edge_bulk_out_data_callback (struct urb *urb)
                     __func__, status);
         }
 
-        tty = edge_port->port->tty;
+        tty = edge_port->port->port.tty;
 
         if (tty && edge_port->open) {
                 /* let the tty driver wakeup if it has a special write_wakeup function */
@@ -781,7 +782,7 @@ static void edge_bulk_out_cmd_callback (struct urb *urb)
         }
 
         /* Get pointer to tty */
-        tty = edge_port->port->tty;
+        tty = edge_port->port->port.tty;
 
         /* tell the tty driver that something has changed */
         if (tty && edge_port->open)
@@ -803,7 +804,8 @@ static void edge_bulk_out_cmd_callback (struct urb *urb)
  *      If successful, we return 0
  *      Otherwise we return a negative error number.
  *****************************************************************************/
-static int edge_open (struct usb_serial_port *port, struct file * filp)
+static int edge_open(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file * filp)
 {
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
         struct usb_serial *serial;
@@ -815,16 +817,15 @@ static int edge_open (struct usb_serial_port *port, struct file * filp)
         if (edge_port == NULL)
                 return -ENODEV;
 
-        if (port->tty)
-                port->tty->low_latency = low_latency;
+        if (tty)
+                tty->low_latency = low_latency;
 
         /* see if we've set up our endpoint info yet (can't set it up in edge_startup
            as the structures were not set up at that time.) */
         serial = port->serial;
         edge_serial = usb_get_serial_data(serial);
-        if (edge_serial == NULL) {
+        if (edge_serial == NULL)
                 return -ENODEV;
-        }
         if (edge_serial->interrupt_in_buffer == NULL) {
                 struct usb_serial_port *port0 = serial->port[0];
                 
@@ -908,7 +909,7 @@ static int edge_open (struct usb_serial_port *port, struct file * filp)
 
         if (!edge_port->txfifo.fifo) {
                 dbg("%s - no memory", __func__);
-                edge_close (port, filp);
+                edge_close (tty, port, filp);
                 return -ENOMEM;
         }
 
@@ -918,7 +919,7 @@ static int edge_open (struct usb_serial_port *port, struct file * filp)
 
         if (!edge_port->write_urb) {
                 dbg("%s - no memory", __func__);
-                edge_close (port, filp);
+                edge_close (tty, port, filp);
                 return -ENOMEM;
         }
 
@@ -1038,7 +1039,8 @@ static void block_until_tx_empty (struct edgeport_port *edge_port)
  * edge_close
  *      this function is called by the tty driver when a port is closed
  *****************************************************************************/
-static void edge_close (struct usb_serial_port *port, struct file * filp)
+static void edge_close(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file * filp)
 {
         struct edgeport_serial *edge_serial;
         struct edgeport_port *edge_port;
@@ -1106,7 +1108,8 @@ static void edge_close (struct usb_serial_port *port, struct file * filp)
  *      If successful, we return the number of bytes written, otherwise we return
  *      a negative error number.
  *****************************************************************************/
-static int edge_write (struct usb_serial_port *port, const unsigned char *data, int count)
+static int edge_write(struct tty_struct *tty, struct usb_serial_port *port,
+                                        const unsigned char *data, int count)
 {
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
         struct TxFifo *fifo;
@@ -1308,8 +1311,9 @@ exit_send:
  *      (the txCredits), 
  *      Otherwise we return a negative error number.
  *****************************************************************************/
-static int edge_write_room (struct usb_serial_port *port)
+static int edge_write_room(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
         int room;
         unsigned long flags;
@@ -1347,8 +1351,9 @@ static int edge_write_room (struct usb_serial_port *port)
  *      system, 
  *      Otherwise we return a negative error number.
  *****************************************************************************/
-static int edge_chars_in_buffer (struct usb_serial_port *port)
+static int edge_chars_in_buffer(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
         int num_chars;
         unsigned long flags;
@@ -1381,10 +1386,10 @@ static int edge_chars_in_buffer (struct usb_serial_port *port)
  *      this function is called by the tty driver when it wants to stop the data
  *      being read from the port.
  *****************************************************************************/
-static void edge_throttle (struct usb_serial_port *port)
+static void edge_throttle(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
-        struct tty_struct *tty;
         int status;
 
         dbg("%s - port %d", __func__, port->number);
@@ -1397,16 +1402,10 @@ static void edge_throttle (struct usb_serial_port *port)
                 return;
         }
 
-        tty = port->tty;
-        if (!tty) {
-                dbg ("%s - no tty available", __func__);
-                return;
-        }
-
         /* if we are implementing XON/XOFF, send the stop character */
         if (I_IXOFF(tty)) {
                 unsigned char stop_char = STOP_CHAR(tty);
-                status = edge_write (port, &stop_char, 1);
+                status = edge_write (tty, port, &stop_char, 1);
                 if (status <= 0) {
                         return;
                 }
@@ -1430,10 +1429,10 @@ static void edge_throttle (struct usb_serial_port *port)
  *      this function is called by the tty driver when it wants to resume the data
  *      being read from the port (called after SerialThrottle is called)
  *****************************************************************************/
-static void edge_unthrottle (struct usb_serial_port *port)
+static void edge_unthrottle(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
-        struct tty_struct *tty;
         int status;
 
         dbg("%s - port %d", __func__, port->number);
@@ -1446,31 +1445,18 @@ static void edge_unthrottle (struct usb_serial_port *port)
                 return;
         }
 
-        tty = port->tty;
-        if (!tty) {
-                dbg ("%s - no tty available", __func__);
-                return;
-        }
-
         /* if we are implementing XON/XOFF, send the start character */
         if (I_IXOFF(tty)) {
                 unsigned char start_char = START_CHAR(tty);
-                status = edge_write (port, &start_char, 1);
-                if (status <= 0) {
+                status = edge_write(tty, port, &start_char, 1);
+                if (status <= 0)
                         return;
-                }
         }
-
         /* if we are implementing RTS/CTS, toggle that line */
         if (tty->termios->c_cflag & CRTSCTS) {
                 edge_port->shadowMCR |= MCR_RTS;
-                status = send_cmd_write_uart_register(edge_port, MCR, edge_port->shadowMCR);
-                if (status != 0) {
-                        return;
-                }
+                send_cmd_write_uart_register(edge_port, MCR, edge_port->shadowMCR);
         }
-
-        return;
 }
 
 
@@ -1478,11 +1464,10 @@ static void edge_unthrottle (struct usb_serial_port *port)
  * SerialSetTermios
  *      this function is called by the tty driver when it wants to change the termios structure
  *****************************************************************************/
-static void edge_set_termios (struct usb_serial_port *port, struct ktermios *old_termios)
+static void edge_set_termios(struct tty_struct *tty,
+        struct usb_serial_port *port, struct ktermios *old_termios)
 {
-        /* FIXME: This function appears unused ?? */
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
-        struct tty_struct *tty = port->tty;
         unsigned int cflag;
 
         cflag = tty->termios->c_cflag;
@@ -1502,9 +1487,7 @@ static void edge_set_termios (struct usb_serial_port *port, struct ktermios *old
         }
 
         /* change the port settings to the new ones specified */
-        change_port_settings (edge_port, old_termios);
-
-        return;
+        change_port_settings(tty, edge_port, old_termios);
 }
 
 
@@ -1536,25 +1519,9 @@ static int get_lsr_info(struct edgeport_port *edge_port, unsigned int __user *va
         return 0;
 }
 
-static int get_number_bytes_avail(struct edgeport_port *edge_port, unsigned int __user *value)
-{
-        unsigned int result = 0;
-        struct tty_struct *tty = edge_port->port->tty;
-
-        if (!tty)
-                return -ENOIOCTLCMD;
-
-        result = tty->read_cnt;
-
-        dbg("%s(%d) = %d", __func__,  edge_port->port->number, result);
-        if (copy_to_user(value, &result, sizeof(int)))
-                return -EFAULT;
-        //return 0;
-        return -ENOIOCTLCMD;
-}
-
-static int edge_tiocmset (struct usb_serial_port *port, struct file *file, unsigned int set, unsigned int clear)
+static int edge_tiocmset(struct tty_struct *tty, struct file *file, unsigned int set, unsigned int clear)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
         unsigned int mcr;
 
@@ -1582,8 +1549,9 @@ static int edge_tiocmset (struct usb_serial_port *port, struct file *file, unsig
         return 0;
 }
 
-static int edge_tiocmget(struct usb_serial_port *port, struct file *file)
+static int edge_tiocmget(struct tty_struct *tty, struct file *file)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
         unsigned int result = 0;
         unsigned int msr;
@@ -1624,9 +1592,6 @@ static int get_serial_info(struct edgeport_port *edge_port, struct serial_struct
         tmp.baud_base           = 9600;
         tmp.close_delay         = 5*HZ;
         tmp.closing_wait        = 30*HZ;
-//      tmp.custom_divisor      = state->custom_divisor;
-//      tmp.hub6                = state->hub6;
-//      tmp.io_type             = state->io_type;
 
         if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
                 return -EFAULT;
@@ -1639,8 +1604,10 @@ static int get_serial_info(struct edgeport_port *edge_port, struct serial_struct
  * SerialIoctl
  *      this function handles any ioctl calls to the driver
  *****************************************************************************/
-static int edge_ioctl (struct usb_serial_port *port, struct file *file, unsigned int cmd, unsigned long arg)
+static int edge_ioctl(struct tty_struct *tty, struct file *file,
+                                        unsigned int cmd, unsigned long arg)
 {
+        struct usb_serial_port *port = tty->driver_data;
         DEFINE_WAIT(wait);
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
         struct async_icount cnow;
@@ -1650,25 +1617,14 @@ static int edge_ioctl (struct usb_serial_port *port, struct file *file, unsigned
         dbg("%s - port %d, cmd = 0x%x", __func__, port->number, cmd);
 
         switch (cmd) {
-                // return number of bytes available
-                case TIOCINQ:
-                        dbg("%s (%d) TIOCINQ", __func__,  port->number);
-                        return get_number_bytes_avail(edge_port, (unsigned int __user *) arg);
-                        break;
-
                 case TIOCSERGETLSR:
                         dbg("%s (%d) TIOCSERGETLSR", __func__,  port->number);
                         return get_lsr_info(edge_port, (unsigned int __user *) arg);
-                        return 0;
 
                 case TIOCGSERIAL:
                         dbg("%s (%d) TIOCGSERIAL", __func__,  port->number);
                         return get_serial_info(edge_port, (struct serial_struct __user *) arg);
 
-                case TIOCSSERIAL:
-                        dbg("%s (%d) TIOCSSERIAL", __func__,  port->number);
-                        break;
-
                 case TIOCMIWAIT:
                         dbg("%s (%d) TIOCMIWAIT", __func__,  port->number);
                         cprev = edge_port->icount;
@@ -1723,8 +1679,9 @@ static int edge_ioctl (struct usb_serial_port *port, struct file *file, unsigned
  * SerialBreak
  *      this function sends a break to the port
  *****************************************************************************/
-static void edge_break (struct usb_serial_port *port, int break_state)
+static void edge_break (struct tty_struct *tty, int break_state)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
         struct edgeport_serial *edge_serial = usb_get_serial_data(port->serial);
         int status;
@@ -1866,7 +1823,7 @@ static void process_rcvd_data (struct edgeport_serial *edge_serial, unsigned cha
                                         port = edge_serial->serial->port[edge_serial->rxPort];
                                         edge_port = usb_get_serial_port_data(port);
                                         if (edge_port->open) {
-                                                tty = edge_port->port->tty;
+                                                tty = edge_port->port->port.tty;
                                                 if (tty) {
                                                         dbg("%s - Sending %d bytes to TTY for port %d", __func__, rxLen, edge_serial->rxPort);
                                                         edge_tty_recv(&edge_serial->serial->dev->dev, tty, buffer, rxLen);
@@ -1941,8 +1898,9 @@ static void process_rcvd_status (struct edgeport_serial *edge_serial, __u8 byte2
                 handle_new_msr (edge_port, byte2);
 
                 /* send the current line settings to the port so we are in sync with any further termios calls */
-                if (edge_port->port->tty)
-                        change_port_settings (edge_port, edge_port->port->tty->termios);
+                /* FIXME: locking on tty */
+                if (edge_port->port->port.tty)
+                        change_port_settings(edge_port->port->port.tty, edge_port, edge_port->port->port.tty->termios);
 
                 /* we have completed the open */
                 edge_port->openPending = false;
@@ -2078,8 +2036,8 @@ static void handle_new_lsr(struct edgeport_port *edge_port, __u8 lsrData, __u8 l
         }
 
         /* Place LSR data byte into Rx buffer */
-        if (lsrData && edge_port->port->tty)
-                edge_tty_recv(&edge_port->port->dev, edge_port->port->tty, &data, 1);
+        if (lsrData && edge_port->port->port.tty)
+                edge_tty_recv(&edge_port->port->dev, edge_port->port->port.tty, &data, 1);
 
         /* update input line counters */
         icount = &edge_port->icount;
@@ -2473,13 +2431,11 @@ static int send_cmd_write_uart_register (struct edgeport_port *edge_port, __u8 r
  *      This routine is called to set the UART on the device to match the specified
  *      new settings.
  *****************************************************************************/
-#ifndef CMSPAR
-#define CMSPAR 0
-#endif
-static void change_port_settings (struct edgeport_port *edge_port, struct ktermios *old_termios)
+
+static void change_port_settings(struct tty_struct *tty,
+        struct edgeport_port *edge_port, struct ktermios *old_termios)
 {
         struct edgeport_serial *edge_serial = usb_get_serial_data(edge_port->port->serial);
-        struct tty_struct *tty;
         int baud;
         unsigned cflag;
         __u8 mask = 0xff;
@@ -2498,13 +2454,6 @@ static void change_port_settings (struct edgeport_port *edge_port, struct ktermi
                 return;
         }
 
-        tty = edge_port->port->tty;
-        if ((!tty) ||
-            (!tty->termios)) {
-                dbg("%s - no tty structures", __func__);
-                return;
-        }
-
         cflag = tty->termios->c_cflag;
 
         switch (cflag & CSIZE) {
diff --git a/drivers/usb/serial/io_ti.c b/drivers/usb/serial/io_ti.c
index a58822a14a87..7cf383a2a556 100644
--- a/drivers/usb/serial/io_ti.c
+++ b/drivers/usb/serial/io_ti.c
@@ -243,9 +243,9 @@ static void edge_tty_recv(struct device *dev, struct tty_struct *tty,
 static void stop_read(struct edgeport_port *edge_port);
 static int restart_read(struct edgeport_port *edge_port);
 
-static void edge_set_termios(struct usb_serial_port *port,
-                             struct ktermios *old_termios);
-static void edge_send(struct usb_serial_port *port);
+static void edge_set_termios(struct tty_struct *tty,
+                struct usb_serial_port *port, struct ktermios *old_termios);
+static void edge_send(struct tty_struct *tty);
 
 /* sysfs attributes */
 static int edge_create_sysfs_attrs(struct usb_serial_port *port);
@@ -572,7 +572,7 @@ static void chase_port(struct edgeport_port *port, unsigned long timeout,
                                                                 int flush)
 {
         int baud_rate;
-        struct tty_struct *tty = port->port->tty;
+        struct tty_struct *tty = port->port->port.tty;
         wait_queue_t wait;
         unsigned long flags;
 
@@ -1554,7 +1554,7 @@ static void handle_new_msr(struct edgeport_port *edge_port, __u8 msr)
         /* Save the new modem status */
         edge_port->shadow_msr = msr & 0xf0;
 
-        tty = edge_port->port->tty;
+        tty = edge_port->port->port.tty;
         /* handle CTS flow control */
         if (tty && C_CRTSCTS(tty)) {
                 if (msr & EDGEPORT_MSR_CTS) {
@@ -1587,9 +1587,8 @@ static void handle_new_lsr(struct edgeport_port *edge_port, int lsr_data,
                 new_lsr &= (__u8)(LSR_OVER_ERR | LSR_BREAK);
 
         /* Place LSR data byte into Rx buffer */
-        if (lsr_data && edge_port->port->tty)
-                edge_tty_recv(&edge_port->port->dev, edge_port->port->tty,
-                                                                &data, 1);
+        if (lsr_data && edge_port->port->port.tty)
+                edge_tty_recv(&edge_port->port->dev, edge_port->port->port.tty, &data, 1);
 
         /* update input line counters */
         icount = &edge_port->icount;
@@ -1750,7 +1749,7 @@ static void edge_bulk_in_callback(struct urb *urb)
                 ++data;
         }
 
-        tty = edge_port->port->tty;
+        tty = edge_port->port->port.tty;
         if (tty && urb->actual_length) {
                 usb_serial_debug_data(debug, &edge_port->port->dev,
                                         __func__, urb->actual_length, data);
@@ -1819,10 +1818,11 @@ static void edge_bulk_out_callback(struct urb *urb)
         }
 
         /* send any buffered data */
-        edge_send(port);
+        edge_send(port->port.tty);
 }
 
-static int edge_open(struct usb_serial_port *port, struct file *filp)
+static int edge_open(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 {
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
         struct edgeport_serial *edge_serial;
@@ -1838,7 +1838,8 @@ static int edge_open(struct usb_serial_port *port, struct file *filp)
         if (edge_port == NULL)
                 return -ENODEV;
 
-        port->tty->low_latency = low_latency;
+        if (tty)
+                tty->low_latency = low_latency;
 
         port_number = port->number - port->serial->minor;
         switch (port_number) {
@@ -1874,7 +1875,8 @@ static int edge_open(struct usb_serial_port *port, struct file *filp)
         }
 
         /* set up the port settings */
-        edge_set_termios(port, port->tty->termios);
+        if (tty)
+                edge_set_termios(tty, port, port->port.tty->termios);
 
         /* open up the port */
 
@@ -2000,7 +2002,8 @@ release_es_lock:
         return status;
 }
 
-static void edge_close(struct usb_serial_port *port, struct file *filp)
+static void edge_close(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 {
         struct edgeport_serial *edge_serial;
         struct edgeport_port *edge_port;
@@ -2048,8 +2051,8 @@ static void edge_close(struct usb_serial_port *port, struct file *filp)
         dbg("%s - exited", __func__);
 }
 
-static int edge_write(struct usb_serial_port *port, const unsigned char *data,
-                                                                int count)
+static int edge_write(struct tty_struct *tty, struct usb_serial_port *port,
+                                const unsigned char *data, int count)
 {
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
         unsigned long flags;
@@ -2070,16 +2073,16 @@ static int edge_write(struct usb_serial_port *port, const unsigned char *data,
         count = edge_buf_put(edge_port->ep_out_buf, data, count);
         spin_unlock_irqrestore(&edge_port->ep_lock, flags);
 
-        edge_send(port);
+        edge_send(tty);
 
         return count;
 }
 
-static void edge_send(struct usb_serial_port *port)
+static void edge_send(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         int count, result;
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
-        struct tty_struct *tty = port->tty;
         unsigned long flags;
 
 
@@ -2133,8 +2136,9 @@ static void edge_send(struct usb_serial_port *port)
                 tty_wakeup(tty);
 }
 
-static int edge_write_room(struct usb_serial_port *port)
+static int edge_write_room(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
         int room = 0;
         unsigned long flags;
@@ -2154,8 +2158,9 @@ static int edge_write_room(struct usb_serial_port *port)
         return room;
 }
 
-static int edge_chars_in_buffer(struct usb_serial_port *port)
+static int edge_chars_in_buffer(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
         int chars = 0;
         unsigned long flags;
@@ -2175,10 +2180,10 @@ static int edge_chars_in_buffer(struct usb_serial_port *port)
         return chars;
 }
 
-static void edge_throttle(struct usb_serial_port *port)
+static void edge_throttle(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
-        struct tty_struct *tty = port->tty;
         int status;
 
         dbg("%s - port %d", __func__, port->number);
@@ -2189,11 +2194,10 @@ static void edge_throttle(struct usb_serial_port *port)
         /* if we are implementing XON/XOFF, send the stop character */
         if (I_IXOFF(tty)) {
                 unsigned char stop_char = STOP_CHAR(tty);
-                status = edge_write(port, &stop_char, 1);
-                if (status <= 0)
-                        dev_err(&port->dev,
-                                "%s - failed to write stop character, %d\n",
-                                                        __func__, status);
+                status = edge_write(tty, port, &stop_char, 1);
+                if (status <= 0) {
+                        dev_err(&port->dev, "%s - failed to write stop character, %d\n", __func__, status);
+                }
         }
 
         /* if we are implementing RTS/CTS, stop reads */
@@ -2203,10 +2207,10 @@ static void edge_throttle(struct usb_serial_port *port)
 
 }
 
-static void edge_unthrottle(struct usb_serial_port *port)
+static void edge_unthrottle(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
-        struct tty_struct *tty = port->tty;
         int status;
 
         dbg("%s - port %d", __func__, port->number);
@@ -2217,11 +2221,10 @@ static void edge_unthrottle(struct usb_serial_port *port)
         /* if we are implementing XON/XOFF, send the start character */
         if (I_IXOFF(tty)) {
                 unsigned char start_char = START_CHAR(tty);
-                status = edge_write(port, &start_char, 1);
-                if (status <= 0)
-                        dev_err(&port->dev,
-                                "%s - failed to write start character, %d\n",
-                                                        __func__, status);
+                status = edge_write(tty, port, &start_char, 1);
+                if (status <= 0) {
+                        dev_err(&port->dev, "%s - failed to write start character, %d\n", __func__, status);
+                }
         }
         /* if we are implementing RTS/CTS, restart reads */
         /* are the Edgeport will assert the RTS line */
@@ -2271,11 +2274,10 @@ static int restart_read(struct edgeport_port *edge_port)
         return status;
 }
 
-static void change_port_settings(struct edgeport_port *edge_port,
-                                                struct ktermios *old_termios)
+static void change_port_settings(struct tty_struct *tty,
+                struct edgeport_port *edge_port, struct ktermios *old_termios)
 {
         struct ump_uart_config *config;
-        struct tty_struct *tty;
         int baud;
         unsigned cflag;
         int status;
@@ -2284,9 +2286,7 @@ static void change_port_settings(struct edgeport_port *edge_port,
 
         dbg("%s - port %d", __func__, edge_port->port->number);
 
-        tty = edge_port->port->tty;
-
-        config = kmalloc(sizeof(*config), GFP_KERNEL);
+        config = kmalloc (sizeof (*config), GFP_KERNEL);
         if (!config) {
                 *tty->termios = *old_termios;
                 dev_err(&edge_port->port->dev, "%s - out of memory\n",
@@ -2419,11 +2419,13 @@ static void change_port_settings(struct edgeport_port *edge_port,
         return;
 }
 
-static void edge_set_termios(struct usb_serial_port *port,
-                                        struct ktermios *old_termios)
+static void edge_set_termios(struct tty_struct *tty, 
+                struct usb_serial_port *port, struct ktermios *old_termios)
 {
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
-        struct tty_struct *tty = port->tty;
+        unsigned int cflag;
+
+        cflag = tty->termios->c_cflag;
 
         dbg("%s - clfag %08x iflag %08x", __func__,
             tty->termios->c_cflag, tty->termios->c_iflag);
@@ -2434,12 +2436,14 @@ static void edge_set_termios(struct usb_serial_port *port,
         if (edge_port == NULL)
                 return;
         /* change the port settings to the new ones specified */
-        change_port_settings(edge_port, old_termios);
+        change_port_settings(tty, edge_port, old_termios);
+        return;
 }
 
-static int edge_tiocmset(struct usb_serial_port *port, struct file *file,
+static int edge_tiocmset(struct tty_struct *tty, struct file *file,
                                         unsigned int set, unsigned int clear)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
         unsigned int mcr;
         unsigned long flags;
@@ -2469,8 +2473,9 @@ static int edge_tiocmset(struct usb_serial_port *port, struct file *file,
         return 0;
 }
 
-static int edge_tiocmget(struct usb_serial_port *port, struct file *file)
+static int edge_tiocmget(struct tty_struct *tty, struct file *file)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
         unsigned int result = 0;
         unsigned int msr;
@@ -2522,9 +2527,10 @@ static int get_serial_info(struct edgeport_port *edge_port,
         return 0;
 }
 
-static int edge_ioctl(struct usb_serial_port *port, struct file *file,
+static int edge_ioctl(struct tty_struct *tty, struct file *file,
                                         unsigned int cmd, unsigned long arg)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
         struct async_icount cnow;
         struct async_icount cprev;
@@ -2569,18 +2575,19 @@ static int edge_ioctl(struct usb_serial_port *port, struct file *file,
         return -ENOIOCTLCMD;
 }
 
-static void edge_break(struct usb_serial_port *port, int on)
+static void edge_break(struct tty_struct *tty, int break_state)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
         int status;
         int bv = 0;     /* Off */
 
-        dbg("%s - state = %d", __func__, on);
+        dbg("%s - state = %d", __func__, break_state);
 
         /* chase the port close */
         chase_port(edge_port, 0, 0);
 
-        if (on == -1)
+        if (break_state == -1)
                 bv = 1; /* On */
         status = ti_do_config(edge_port, UMPC_SET_CLR_BREAK, bv);
         if (status)
diff --git a/drivers/usb/serial/ipaq.c b/drivers/usb/serial/ipaq.c
index 80d9ec5570d6..a7784642d6a1 100644
--- a/drivers/usb/serial/ipaq.c
+++ b/drivers/usb/serial/ipaq.c
@@ -74,19 +74,21 @@ static int connect_retries = KP_RETRIES;
 static int initial_wait;
 
 /* Function prototypes for an ipaq */
-static int  ipaq_open (struct usb_serial_port *port, struct file *filp);
-static void ipaq_close (struct usb_serial_port *port, struct file *filp);
-static int  ipaq_startup (struct usb_serial *serial);
-static void ipaq_shutdown (struct usb_serial *serial);
-static int ipaq_write(struct usb_serial_port *port, const unsigned char *buf,
-                       int count);
+static int  ipaq_open(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp);
+static void ipaq_close(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp);
+static int  ipaq_startup(struct usb_serial *serial);
+static void ipaq_shutdown(struct usb_serial *serial);
+static int ipaq_write(struct tty_struct *tty, struct usb_serial_port *port,
+                        const unsigned char *buf, int count);
 static int ipaq_write_bulk(struct usb_serial_port *port, const unsigned char *buf,
-                           int count);
+                        int count);
 static void ipaq_write_gather(struct usb_serial_port *port);
 static void ipaq_read_bulk_callback (struct urb *urb);
 static void ipaq_write_bulk_callback(struct urb *urb);
-static int ipaq_write_room(struct usb_serial_port *port);
-static int ipaq_chars_in_buffer(struct usb_serial_port *port);
+static int ipaq_write_room(struct tty_struct *tty);
+static int ipaq_chars_in_buffer(struct tty_struct *tty);
 static void ipaq_destroy_lists(struct usb_serial_port *port);
 
 
@@ -591,7 +593,8 @@ static spinlock_t	write_list_lock;
 static int              bytes_in;
 static int              bytes_out;
 
-static int ipaq_open(struct usb_serial_port *port, struct file *filp)
+static int ipaq_open(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 {
         struct usb_serial       *serial = port->serial;
         struct ipaq_private     *priv;
@@ -637,10 +640,12 @@ static int ipaq_open(struct usb_serial_port *port, struct file *filp)
          * discipline instead of queueing.
          */
 
-        port->tty->low_latency = 1;
-        port->tty->raw = 1;
-        port->tty->real_raw = 1;
-
+        if (tty) {
+                tty->low_latency = 1;
+                /* FIXME: These two are bogus */
+                tty->raw = 1;
+                tty->real_raw = 1;
+        }
         /*
          * Lose the small buffers usbserial provides. Make larger ones.
          */
@@ -714,7 +719,8 @@ error:
 }
 
 
-static void ipaq_close(struct usb_serial_port *port, struct file *filp)
+static void ipaq_close(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 {
         struct ipaq_private     *priv = usb_get_serial_port_data(port);
 
@@ -751,7 +757,7 @@ static void ipaq_read_bulk_callback(struct urb *urb)
 
         usb_serial_debug_data(debug, &port->dev, __func__, urb->actual_length, data);
 
-        tty = port->tty;
+        tty = port->port.tty;
         if (tty && urb->actual_length) {
                 tty_buffer_request_room(tty, urb->actual_length);
                 tty_insert_flip_string(tty, data, urb->actual_length);
@@ -770,8 +776,8 @@ static void ipaq_read_bulk_callback(struct urb *urb)
         return;
 }
 
-static int ipaq_write(struct usb_serial_port *port, const unsigned char *buf,
-                       int count)
+static int ipaq_write(struct tty_struct *tty, struct usb_serial_port *port,
+                        const unsigned char *buf, int count)
 {
         const unsigned char     *current_position = buf;
         int                     bytes_sent = 0;
@@ -905,16 +911,18 @@ static void ipaq_write_bulk_callback(struct urb *urb)
         usb_serial_port_softint(port);
 }
 
-static int ipaq_write_room(struct usb_serial_port *port)
+static int ipaq_write_room(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct ipaq_private     *priv = usb_get_serial_port_data(port);
 
         dbg("%s - freelen %d", __func__, priv->free_len);
         return priv->free_len;
 }
 
-static int ipaq_chars_in_buffer(struct usb_serial_port *port)
+static int ipaq_chars_in_buffer(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct ipaq_private     *priv = usb_get_serial_port_data(port);
 
         dbg("%s - queuelen %d", __func__, priv->queue_len);
diff --git a/drivers/usb/serial/ipw.c b/drivers/usb/serial/ipw.c
index bc85ca5c1c37..a89ebfe9e915 100644
--- a/drivers/usb/serial/ipw.c
+++ b/drivers/usb/serial/ipw.c
@@ -179,7 +179,7 @@ static void ipw_read_bulk_callback(struct urb *urb)
 
         usb_serial_debug_data(debug, &port->dev, __func__, urb->actual_length, data);
 
-        tty = port->tty;
+        tty = port->port.tty;
         if (tty && urb->actual_length) {
                 tty_buffer_request_room(tty, urb->actual_length);
                 tty_insert_flip_string(tty, data, urb->actual_length);
@@ -199,7 +199,8 @@ static void ipw_read_bulk_callback(struct urb *urb)
         return;
 }
 
-static int ipw_open(struct usb_serial_port *port, struct file *filp)
+static int ipw_open(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 {
         struct usb_device *dev = port->serial->dev;
         u8 buf_flow_static[16] = IPW_BYTES_FLOWINIT;
@@ -212,8 +213,8 @@ static int ipw_open(struct usb_serial_port *port, struct file *filp)
         if (!buf_flow_init)
                 return -ENOMEM;
 
-        if (port->tty)
-                port->tty->low_latency = 1;
+        if (tty)
+                tty->low_latency = 1;
 
         /* --1: Tell the modem to initialize (we think) From sniffs this is always the
          * first thing that gets sent to the modem during opening of the device */
@@ -301,7 +302,8 @@ static int ipw_open(struct usb_serial_port *port, struct file *filp)
         return 0;
 }
 
-static void ipw_close(struct usb_serial_port *port, struct file * filp)
+static void ipw_close(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file * filp)
 {
         struct usb_device *dev = port->serial->dev;
         int result;
@@ -384,7 +386,8 @@ static void ipw_write_bulk_callback(struct urb *urb)
         usb_serial_port_softint(port);
 }
 
-static int ipw_write(struct usb_serial_port *port, const unsigned char *buf, int count)
+static int ipw_write(struct tty_struct *tty, struct usb_serial_port *port,
+                                        const unsigned char *buf, int count)
 {
         struct usb_device *dev = port->serial->dev;
         int ret;
diff --git a/drivers/usb/serial/ir-usb.c b/drivers/usb/serial/ir-usb.c
index 0063c11c8081..e59155c6607d 100644
--- a/drivers/usb/serial/ir-usb.c
+++ b/drivers/usb/serial/ir-usb.c
@@ -85,15 +85,17 @@ static int buffer_size;
 /* if overridden by the user, then use the specified number of XBOFs */
 static int xbof = -1;
 
-static int ir_startup(struct usb_serial *serial);
-static int ir_open(struct usb_serial_port *port, struct file *filep);
-static void ir_close(struct usb_serial_port *port, struct file *filep);
-static int ir_write(struct usb_serial_port *port,
-                const unsigned char *buf, int count);
-static void ir_write_bulk_callback(struct urb *urb);
-static void ir_read_bulk_callback(struct urb *urb);
-static void ir_set_termios(struct usb_serial_port *port,
-                struct ktermios *old_termios);
+static int  ir_startup (struct usb_serial *serial);
+static int  ir_open(struct tty_struct *tty, struct usb_serial_port *port,
+                                        struct file *filep);
+static void ir_close(struct tty_struct *tty, struct usb_serial_port *port,
+                                        struct file *filep);
+static int  ir_write(struct tty_struct *tty, struct usb_serial_port *port,
+                                        const unsigned char *buf, int count);
+static void ir_write_bulk_callback (struct urb *urb);
+static void ir_read_bulk_callback (struct urb *urb);
+static void ir_set_termios(struct tty_struct *tty,
+                struct usb_serial_port *port, struct ktermios *old_termios);
 
 /* Not that this lot means you can only have one per system */
 static u8 ir_baud;
@@ -295,7 +297,8 @@ static int ir_startup(struct usb_serial *serial)
         return 0;
 }
 
-static int ir_open(struct usb_serial_port *port, struct file *filp)
+static int ir_open(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 {
         char *buffer;
         int result = 0;
@@ -343,7 +346,8 @@ static int ir_open(struct usb_serial_port *port, struct file *filp)
         return result;
 }
 
-static void ir_close(struct usb_serial_port *port, struct file *filp)
+static void ir_close(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file * filp)
 {
         dbg("%s - port %d", __func__, port->number);
 
@@ -351,8 +355,8 @@ static void ir_close(struct usb_serial_port *port, struct file *filp)
         usb_kill_urb(port->read_urb);
 }
 
-static int ir_write(struct usb_serial_port *port,
-                const unsigned char *buf, int count)
+static int ir_write(struct tty_struct *tty, struct usb_serial_port *port,
+                                        const unsigned char *buf, int count)
 {
         unsigned char *transfer_buffer;
         int result;
@@ -360,11 +364,6 @@ static int ir_write(struct usb_serial_port *port,
 
         dbg("%s - port = %d, count = %d", __func__, port->number, count);
 
-        if (!port->tty) {
-                dev_err(&port->dev, "%s - no tty???\n", __func__);
-                return 0;
-        }
-
         if (count == 0)
                 return 0;
 
@@ -450,14 +449,13 @@ static void ir_read_bulk_callback(struct urb *urb)
 
         dbg("%s - port %d", __func__, port->number);
 
-        if (!port->open_count) {
+        if (!port->port.count) {
                 dbg("%s - port closed.", __func__);
                 return;
         }
 
         switch (status) {
         case 0: /* Successful */
-
                 /*
                  * The first byte of the packet we get from the device
                  * contains a busy indicator and baud rate change.
@@ -465,19 +463,11 @@ static void ir_read_bulk_callback(struct urb *urb)
                  */
                 if ((*data & 0x0f) > 0)
                         ir_baud = *data & 0x0f;
-
-                usb_serial_debug_data(
-                        debug,
-                        &port->dev,
-                        __func__,
-                        urb->actual_length,
-                        data);
-
-                tty = port->tty;
-
+                usb_serial_debug_data(debug, &port->dev, __func__,
+                                                urb->actual_length, data);
+                tty = port->port.tty;
                 if (tty_buffer_request_room(tty, urb->actual_length - 1)) {
-                        tty_insert_flip_string(tty, data + 1,
-                                        urb->actual_length - 1);
+                        tty_insert_flip_string(tty, data+1, urb->actual_length - 1);
                         tty_flip_buffer_push(tty);
                 }
 
@@ -488,11 +478,10 @@ static void ir_read_bulk_callback(struct urb *urb)
                  */
 
         case -EPROTO: /* taking inspiration from pl2303.c */
-
-                /* Continue trying to always read */
+                        /* Continue trying to always read */
                 usb_fill_bulk_urb(
                         port->read_urb,
-                        port->serial->dev,
+                        port->serial->dev, 
                         usb_rcvbulkpipe(port->serial->dev,
                                 port->bulk_in_endpointAddress),
                         port->read_urb->transfer_buffer,
@@ -502,23 +491,19 @@ static void ir_read_bulk_callback(struct urb *urb)
 
                 result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
                 if (result)
-                        dev_err(&port->dev,
-                                "%s - failed resubmitting read urb, error %d\n",
+                        dev_err(&port->dev, "%s - failed resubmitting read urb, error %d\n",
                                 __func__, result);
-                break;
-
+                        break ;
         default:
                 dbg("%s - nonzero read bulk status received: %d",
-                        __func__,
-                        status);
-                break;
+                        __func__, status);
+                break ;
         }
-
         return;
 }
 
-static void ir_set_termios(struct usb_serial_port *port,
-                struct ktermios *old_termios)
+static void ir_set_termios(struct tty_struct *tty,
+                struct usb_serial_port *port, struct ktermios *old_termios)
 {
         unsigned char *transfer_buffer;
         int result;
@@ -527,7 +512,7 @@ static void ir_set_termios(struct usb_serial_port *port,
 
         dbg("%s - port %d", __func__, port->number);
 
-        baud = tty_get_baud_rate(port->tty);
+        baud = tty_get_baud_rate(tty);
 
         /*
          * FIXME, we should compare the baud request against the
@@ -600,8 +585,8 @@ static void ir_set_termios(struct usb_serial_port *port,
                                 __func__, result);
 
         /* Only speed changes are supported */
-        tty_termios_copy_hw(port->tty->termios, old_termios);
-        tty_encode_baud_rate(port->tty, baud, baud);
+        tty_termios_copy_hw(tty->termios, old_termios);
+        tty_encode_baud_rate(tty, baud, baud);
 }
 
 static int __init ir_init(void)
diff --git a/drivers/usb/serial/iuu_phoenix.c b/drivers/usb/serial/iuu_phoenix.c
index a01e987c7d32..d65414888349 100644
--- a/drivers/usb/serial/iuu_phoenix.c
+++ b/drivers/usb/serial/iuu_phoenix.c
@@ -144,9 +144,10 @@ static void iuu_shutdown(struct usb_serial *serial)
         }
 }
 
-static int iuu_tiocmset(struct usb_serial_port *port, struct file *file,
+static int iuu_tiocmset(struct tty_struct *tty, struct file *file,
                         unsigned int set, unsigned int clear)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct iuu_private *priv = usb_get_serial_port_data(port);
         unsigned long flags;
 
@@ -171,8 +172,9 @@ static int iuu_tiocmset(struct usb_serial_port *port, struct file *file,
  * When no card , the reader respond with TIOCM_CD
  * This is known as CD autodetect mechanism
  */
-static int iuu_tiocmget(struct usb_serial_port *port, struct file *file)
+static int iuu_tiocmget(struct tty_struct *tty, struct file *file)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct iuu_private *priv = usb_get_serial_port_data(port);
         unsigned long flags;
         int rc;
@@ -630,7 +632,7 @@ static void read_buf_callback(struct urb *urb)
         }
 
         dbg("%s - %i chars to write", __func__, urb->actual_length);
-        tty = port->tty;
+        tty = port->port.tty;
         if (data == NULL)
                 dbg("%s - data is NULL !!!", __func__);
         if (tty && urb->actual_length && data) {
@@ -752,11 +754,10 @@ static void iuu_uart_read_callback(struct urb *urb)
         /* if nothing to write call again rxcmd */
         dbg("%s - rxcmd recall", __func__);
         iuu_led_activity_off(urb);
-        return;
 }
 
-static int iuu_uart_write(struct usb_serial_port *port, const u8 *buf,
-                          int count)
+static int iuu_uart_write(struct tty_struct *tty, struct usb_serial_port *port,
+                          const u8 *buf, int count)
 {
         struct iuu_private *priv = usb_get_serial_port_data(port);
         unsigned long flags;
@@ -948,7 +949,8 @@ static int set_control_lines(struct usb_device *dev, u8 value)
         return 0;
 }
 
-static void iuu_close(struct usb_serial_port *port, struct file *filp)
+static void iuu_close(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 {
         /* iuu_led (port,255,0,0,0); */
         struct usb_serial *serial;
@@ -964,8 +966,8 @@ static void iuu_close(struct usb_serial_port *port, struct file *filp)
 
         iuu_uart_off(port);
         if (serial->dev) {
-                if (port->tty) {
-                        c_cflag = port->tty->termios->c_cflag;
+                if (tty) {
+                        c_cflag = tty->termios->c_cflag;
                         if (c_cflag & HUPCL) {
                                 /* drop DTR and RTS */
                                 priv = usb_get_serial_port_data(port);
@@ -989,7 +991,8 @@ static void iuu_close(struct usb_serial_port *port, struct file *filp)
         }
 }
 
-static int iuu_open(struct usb_serial_port *port, struct file *filp)
+static int iuu_open(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 {
         struct usb_serial *serial = port->serial;
         u8 *buf;
@@ -1036,15 +1039,17 @@ static int iuu_open(struct usb_serial_port *port, struct file *filp)
 
         /* set the termios structure */
         spin_lock_irqsave(&priv->lock, flags);
-        if (!priv->termios_initialized) {
-                *(port->tty->termios) = tty_std_termios;
-                port->tty->termios->c_cflag = CLOCAL | CREAD | CS8 | B9600
-                                                | TIOCM_CTS | CSTOPB | PARENB;
-                port->tty->termios->c_lflag = 0;
-                port->tty->termios->c_oflag = 0;
-                port->tty->termios->c_iflag = 0;
+        if (tty && !priv->termios_initialized) {
+                *(tty->termios) = tty_std_termios;
+                tty->termios->c_cflag = CLOCAL | CREAD | CS8 | B9600
+                                        | TIOCM_CTS | CSTOPB | PARENB;
+                tty->termios->c_ispeed = 9600;
+                tty->termios->c_ospeed = 9600;
+                tty->termios->c_lflag = 0;
+                tty->termios->c_oflag = 0;
+                tty->termios->c_iflag = 0;
                 priv->termios_initialized = 1;
-                port->tty->low_latency = 1;
+                tty->low_latency = 1;
                 priv->poll = 0;
          }
         spin_unlock_irqrestore(&priv->lock, flags);
@@ -1148,7 +1153,7 @@ static int iuu_open(struct usb_serial_port *port, struct file *filp)
         if (result) {
                 dev_err(&port->dev, "%s - failed submitting read urb,"
                         " error %d\n", __func__, result);
-                iuu_close(port, NULL);
+                iuu_close(tty, port, NULL);
                 return -EPROTO;
         } else {
                 dbg("%s - rxcmd OK", __func__);
diff --git a/drivers/usb/serial/keyspan.c b/drivers/usb/serial/keyspan.c
index 11e439b90eac..a371c41bb3ab 100644
--- a/drivers/usb/serial/keyspan.c
+++ b/drivers/usb/serial/keyspan.c
@@ -244,20 +244,9 @@ static void __exit keyspan_exit (void)
 module_init(keyspan_init);
 module_exit(keyspan_exit);
 
-static void keyspan_rx_throttle (struct usb_serial_port *port)
-{
-        dbg("%s - port %d", __func__, port->number);
-}
-
-
-static void keyspan_rx_unthrottle (struct usb_serial_port *port)
-{
-        dbg("%s - port %d", __func__, port->number);
-}
-
-
-static void keyspan_break_ctl (struct usb_serial_port *port, int break_state)
+static void keyspan_break_ctl(struct tty_struct *tty, int break_state)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct keyspan_port_private     *p_priv;
 
         dbg("%s", __func__);
@@ -273,14 +262,13 @@ static void keyspan_break_ctl (struct usb_serial_port *port, int break_state)
 }
 
 
-static void keyspan_set_termios (struct usb_serial_port *port, 
-                                     struct ktermios *old_termios)
+static void keyspan_set_termios (struct tty_struct *tty,
+                struct usb_serial_port *port, struct ktermios *old_termios)
 {
         int                             baud_rate, device_port;
         struct keyspan_port_private     *p_priv;
         const struct keyspan_device_details     *d_details;
         unsigned int                    cflag;
-        struct tty_struct               *tty = port->tty;
 
         dbg("%s", __func__);
 
@@ -312,12 +300,11 @@ static void keyspan_set_termios (struct usb_serial_port *port,
         keyspan_send_setup(port, 0);
 }
 
-static int keyspan_tiocmget(struct usb_serial_port *port, struct file *file)
+static int keyspan_tiocmget(struct tty_struct *tty, struct file *file)
 {
+        struct usb_serial_port *port = tty->driver_data;
+        struct keyspan_port_private *p_priv = usb_get_serial_port_data(port);
         unsigned int                    value;
-        struct keyspan_port_private     *p_priv;
-
-        p_priv = usb_get_serial_port_data(port);
         
         value = ((p_priv->rts_state) ? TIOCM_RTS : 0) |
                 ((p_priv->dtr_state) ? TIOCM_DTR : 0) |
@@ -329,18 +316,16 @@ static int keyspan_tiocmget(struct usb_serial_port *port, struct file *file)
         return value;
 }
 
-static int keyspan_tiocmset(struct usb_serial_port *port, struct file *file,
+static int keyspan_tiocmset(struct tty_struct *tty, struct file *file,
                             unsigned int set, unsigned int clear)
 {
-        struct keyspan_port_private     *p_priv;
-
-        p_priv = usb_get_serial_port_data(port);
+        struct usb_serial_port *port = tty->driver_data;
+        struct keyspan_port_private *p_priv = usb_get_serial_port_data(port);
         
         if (set & TIOCM_RTS)
                 p_priv->rts_state = 1;
         if (set & TIOCM_DTR)
                 p_priv->dtr_state = 1;
-
         if (clear & TIOCM_RTS)
                 p_priv->rts_state = 0;
         if (clear & TIOCM_DTR)
@@ -349,16 +334,10 @@ static int keyspan_tiocmset(struct usb_serial_port *port, struct file *file,
         return 0;
 }
 
-static int keyspan_ioctl(struct usb_serial_port *port, struct file *file,
-                             unsigned int cmd, unsigned long arg)
-{
-        return -ENOIOCTLCMD;
-}
-
-        /* Write function is similar for the four protocols used
-           with only a minor change for usa90 (usa19hs) required */
-static int keyspan_write(struct usb_serial_port *port, 
-                         const unsigned char *buf, int count)
+/* Write function is similar for the four protocols used
+   with only a minor change for usa90 (usa19hs) required */
+static int keyspan_write(struct tty_struct *tty,
+        struct usb_serial_port *port, const unsigned char *buf, int count)
 {
         struct keyspan_port_private     *p_priv;
         const struct keyspan_device_details     *d_details;
@@ -448,7 +427,7 @@ static void	usa26_indat_callback(struct urb *urb)
         }
 
         port =  urb->context;
-        tty = port->tty;
+        tty = port->port.tty;
         if (tty && urb->actual_length) {
                 /* 0x80 bit is error flag */
                 if ((data[0] & 0x80) == 0) {
@@ -479,7 +458,7 @@ static void	usa26_indat_callback(struct urb *urb)
                                 
                 /* Resubmit urb so we continue receiving */
         urb->dev = port->serial->dev;
-        if (port->open_count)
+        if (port->port.count)
                 if ((err = usb_submit_urb(urb, GFP_ATOMIC)) != 0) {
                         dbg("%s - resubmit read urb failed. (%d)", __func__, err);
                 }
@@ -496,7 +475,7 @@ static void	usa2x_outdat_callback(struct urb *urb)
         p_priv = usb_get_serial_port_data(port);
         dbg ("%s - urb %d", __func__, urb == p_priv->out_urbs[1]);
 
-        if (port->open_count)
+        if (port->port.count)
                 usb_serial_port_softint(port);
 }
 
@@ -567,10 +546,10 @@ static void	usa26_instat_callback(struct urb *urb)
         p_priv->dcd_state = ((msg->gpia_dcd) ? 1 : 0);
         p_priv->ri_state = ((msg->ri) ? 1 : 0);
 
-        if (port->tty && !C_CLOCAL(port->tty)
+        if (port->port.tty && !C_CLOCAL(port->port.tty)
             && old_dcd_state != p_priv->dcd_state) {
                 if (old_dcd_state)
-                        tty_hangup(port->tty);
+                        tty_hangup(port->port.tty);
                 /*  else */
                 /*      wake_up_interruptible(&p_priv->open_wait); */
         }
@@ -619,7 +598,7 @@ static void usa28_indat_callback(struct urb *urb)
                 p_priv = usb_get_serial_port_data(port);
                 data = urb->transfer_buffer;
 
-                tty = port->tty;
+                tty = port->port.tty;
                 if (urb->actual_length) {
                         for (i = 0; i < urb->actual_length ; ++i) {
                                 tty_insert_flip_char(tty, data[i], 0);
@@ -629,7 +608,7 @@ static void usa28_indat_callback(struct urb *urb)
 
                 /* Resubmit urb so we continue receiving */
                 urb->dev = port->serial->dev;
-                if (port->open_count)
+                if (port->port.count)
                         if ((err = usb_submit_urb(urb, GFP_ATOMIC)) != 0) {
                                 dbg("%s - resubmit read urb failed. (%d)", __func__, err);
                         }
@@ -704,10 +683,10 @@ static void	usa28_instat_callback(struct urb *urb)
         p_priv->dcd_state = ((msg->dcd) ? 1 : 0);
         p_priv->ri_state = ((msg->ri) ? 1 : 0);
 
-        if (port->tty && !C_CLOCAL(port->tty)
+        if (port->port.tty && !C_CLOCAL(port->port.tty)
             && old_dcd_state != p_priv->dcd_state) {
                 if (old_dcd_state)
-                        tty_hangup(port->tty);
+                        tty_hangup(port->port.tty);
                 /*  else */
                 /*      wake_up_interruptible(&p_priv->open_wait); */
         }
@@ -797,10 +776,10 @@ static void	usa49_instat_callback(struct urb *urb)
         p_priv->dcd_state = ((msg->dcd) ? 1 : 0);
         p_priv->ri_state = ((msg->ri) ? 1 : 0);
 
-        if (port->tty && !C_CLOCAL(port->tty)
+        if (port->port.tty && !C_CLOCAL(port->port.tty)
             && old_dcd_state != p_priv->dcd_state) {
                 if (old_dcd_state)
-                        tty_hangup(port->tty);
+                        tty_hangup(port->port.tty);
                 /*  else */
                 /*      wake_up_interruptible(&p_priv->open_wait); */
         }
@@ -839,7 +818,7 @@ static void	usa49_indat_callback(struct urb *urb)
         }
 
         port =  urb->context;
-        tty = port->tty;
+        tty = port->port.tty;
         if (tty && urb->actual_length) {
                 /* 0x80 bit is error flag */
                 if ((data[0] & 0x80) == 0) {
@@ -866,7 +845,7 @@ static void	usa49_indat_callback(struct urb *urb)
                                 
                 /* Resubmit urb so we continue receiving */
         urb->dev = port->serial->dev;
-        if (port->open_count)
+        if (port->port.count)
                 if ((err = usb_submit_urb(urb, GFP_ATOMIC)) != 0) {
                         dbg("%s - resubmit read urb failed. (%d)", __func__, err);
                 }
@@ -904,7 +883,7 @@ static void usa49wg_indat_callback(struct urb *urb)
                                 return;
                         }
                         port = serial->port[data[i++]];
-                        tty = port->tty;
+                        tty = port->port.tty;
                         len = data[i++];
 
                         /* 0x80 bit is error flag */
@@ -912,7 +891,7 @@ static void usa49wg_indat_callback(struct urb *urb)
                                 /* no error on any byte */
                                 i++;
                                 for (x = 1; x < len ; ++x)
-                                        if (port->open_count)
+                                        if (port->port.count)
                                                 tty_insert_flip_char(tty,
                                                                 data[i++], 0);
                                         else
@@ -930,13 +909,13 @@ static void usa49wg_indat_callback(struct urb *urb)
                                         if (stat & RXERROR_PARITY)
                                                 flag |= TTY_PARITY;
                                         /* XXX should handle break (0x10) */
-                                        if (port->open_count)
+                                        if (port->port.count)
                                                 tty_insert_flip_char(tty,
                                                         data[i+1], flag);
                                         i += 2;
                                 }
                         }
-                        if (port->open_count)
+                        if (port->port.count)
                                 tty_flip_buffer_push(tty);
                 }
         }
@@ -978,7 +957,7 @@ static void usa90_indat_callback(struct urb *urb)
         port =  urb->context;
         p_priv = usb_get_serial_port_data(port);
 
-        tty = port->tty;
+        tty = port->port.tty;
         if (urb->actual_length) {
         
                 /* if current mode is DMA, looks like usa28 format
@@ -1021,7 +1000,7 @@ static void usa90_indat_callback(struct urb *urb)
                                 
         /* Resubmit urb so we continue receiving */
         urb->dev = port->serial->dev;
-        if (port->open_count)
+        if (port->port.count)
                 if ((err = usb_submit_urb(urb, GFP_ATOMIC)) != 0) {
                         dbg("%s - resubmit read urb failed. (%d)", __func__, err);
                 }
@@ -1064,10 +1043,10 @@ static void	usa90_instat_callback(struct urb *urb)
         p_priv->dcd_state = ((msg->dcd) ? 1 : 0);
         p_priv->ri_state = ((msg->ri) ? 1 : 0);
 
-        if (port->tty && !C_CLOCAL(port->tty)
+        if (port->port.tty && !C_CLOCAL(port->port.tty)
             && old_dcd_state != p_priv->dcd_state) {
                 if (old_dcd_state)
-                        tty_hangup(port->tty);
+                        tty_hangup(port->port.tty);
                 /*  else */
                 /*      wake_up_interruptible(&p_priv->open_wait); */
         }
@@ -1139,10 +1118,10 @@ static void	usa67_instat_callback(struct urb *urb)
         p_priv->cts_state = ((msg->hskia_cts) ? 1 : 0);
         p_priv->dcd_state = ((msg->gpia_dcd) ? 1 : 0);
 
-        if (port->tty && !C_CLOCAL(port->tty)
+        if (port->port.tty && !C_CLOCAL(port->port.tty)
             && old_dcd_state != p_priv->dcd_state) {
                 if (old_dcd_state)
-                        tty_hangup(port->tty);
+                        tty_hangup(port->port.tty);
                 /*  else */
                 /*      wake_up_interruptible(&p_priv->open_wait); */
         }
@@ -1177,8 +1156,9 @@ static void usa67_glocont_callback(struct urb *urb)
         }
 }
 
-static int keyspan_write_room (struct usb_serial_port *port)
+static int keyspan_write_room(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct keyspan_port_private     *p_priv;
         const struct keyspan_device_details     *d_details;
         int                             flip;
@@ -1210,13 +1190,8 @@ static int keyspan_write_room (struct usb_serial_port *port)
 }
 
 
-static int keyspan_chars_in_buffer (struct usb_serial_port *port)
-{
-        return 0;
-}
-
-
-static int keyspan_open (struct usb_serial_port *port, struct file *filp)
+static int keyspan_open(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 {
         struct keyspan_port_private     *p_priv;
         struct keyspan_serial_private   *s_priv;
@@ -1225,7 +1200,7 @@ static int keyspan_open (struct usb_serial_port *port, struct file *filp)
         int                             i, err;
         int                             baud_rate, device_port;
         struct urb                      *urb;
-        unsigned int                    cflag;
+        unsigned int                    cflag = 0;
 
         s_priv = usb_get_serial_data(serial);
         p_priv = usb_get_serial_port_data(port);
@@ -1271,19 +1246,19 @@ static int keyspan_open (struct usb_serial_port *port, struct file *filp)
         /* get the terminal config for the setup message now so we don't
          * need to send 2 of them */
 
-        cflag = port->tty->termios->c_cflag;
         device_port = port->number - port->serial->minor;
-
-        /* Baud rate calculation takes baud rate as an integer
-           so other rates can be generated if desired. */
-        baud_rate = tty_get_baud_rate(port->tty);
-        /* If no match or invalid, leave as default */
-        if (baud_rate >= 0
-            && d_details->calculate_baud_rate(baud_rate, d_details->baudclk,
-                                NULL, NULL, NULL, device_port) == KEYSPAN_BAUD_RATE_OK) {
-                p_priv->baud = baud_rate;
+        if (tty) {
+                cflag = tty->termios->c_cflag;
+                /* Baud rate calculation takes baud rate as an integer
+                   so other rates can be generated if desired. */
+                baud_rate = tty_get_baud_rate(tty);
+                /* If no match or invalid, leave as default */
+                if (baud_rate >= 0
+                    && d_details->calculate_baud_rate(baud_rate, d_details->baudclk,
+                                        NULL, NULL, NULL, device_port) == KEYSPAN_BAUD_RATE_OK) {
+                        p_priv->baud = baud_rate;
+                }
         }
-
         /* set CTS/RTS handshake etc. */
         p_priv->cflag = cflag;
         p_priv->flow_control = (cflag & CRTSCTS)? flow_cts: flow_none;
@@ -1301,7 +1276,8 @@ static inline void stop_urb(struct urb *urb)
                 usb_kill_urb(urb);
 }
 
-static void keyspan_close(struct usb_serial_port *port, struct file *filp)
+static void keyspan_close(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 {
         int                     i;
         struct usb_serial       *serial = port->serial;
@@ -1338,7 +1314,7 @@ static void keyspan_close(struct usb_serial_port *port, struct file *filp)
                         stop_urb(p_priv->out_urbs[i]);
                 }
         }
-        port->tty = NULL;
+        port->port.tty = NULL;
 }
 
         /* download the firmware to a pre-renumeration device */
@@ -2427,7 +2403,7 @@ static int keyspan_usa90_send_setup(struct usb_serial *serial,
         }
         /* Sending intermediate configs */
         else {
-                if (port->open_count)
+                if (port->port.count)
                         msg.portEnabled = 1;
                 msg.txBreak = (p_priv->break_on);
         }
diff --git a/drivers/usb/serial/keyspan.h b/drivers/usb/serial/keyspan.h
index 8bf72639b148..38b4582e0734 100644
--- a/drivers/usb/serial/keyspan.h
+++ b/drivers/usb/serial/keyspan.h
@@ -35,17 +35,18 @@
 
 
 /* Function prototypes for Keyspan serial converter */
-static int  keyspan_open                (struct usb_serial_port *port,
+static int  keyspan_open                (struct tty_struct *tty,
+                                         struct usb_serial_port *port,
                                          struct file *filp);
-static void keyspan_close               (struct usb_serial_port *port,
+static void keyspan_close               (struct tty_struct *tty,
+                                         struct usb_serial_port *port,
                                          struct file *filp);
 static int  keyspan_startup             (struct usb_serial *serial);
 static void keyspan_shutdown            (struct usb_serial *serial);
-static void keyspan_rx_throttle         (struct usb_serial_port *port);
-static void keyspan_rx_unthrottle       (struct usb_serial_port *port);
-static int  keyspan_write_room          (struct usb_serial_port *port);
+static int  keyspan_write_room          (struct tty_struct *tty);
 
-static int  keyspan_write               (struct usb_serial_port *port,
+static int  keyspan_write               (struct tty_struct *tty,
+                                         struct usb_serial_port *port,
                                          const unsigned char *buf,
                                          int count);
 
@@ -53,18 +54,14 @@ static void keyspan_send_setup		(struct usb_serial_port *port,
                                          int reset_port);
 
 
-static int  keyspan_chars_in_buffer     (struct usb_serial_port *port);
-static int  keyspan_ioctl               (struct usb_serial_port *port,
-                                         struct file *file,
-                                         unsigned int cmd,
-                                         unsigned long arg);
-static void keyspan_set_termios         (struct usb_serial_port *port,
+static void keyspan_set_termios         (struct tty_struct *tty,
+                                         struct usb_serial_port *port,
                                          struct ktermios *old);
-static void keyspan_break_ctl           (struct usb_serial_port *port,
+static void keyspan_break_ctl           (struct tty_struct *tty,
                                          int break_state);
-static int  keyspan_tiocmget            (struct usb_serial_port *port,
+static int  keyspan_tiocmget            (struct tty_struct *tty,
                                          struct file *file);
-static int  keyspan_tiocmset            (struct usb_serial_port *port,
+static int  keyspan_tiocmset            (struct tty_struct *tty,
                                          struct file *file, unsigned int set,
                                          unsigned int clear);
 static int  keyspan_fake_startup        (struct usb_serial *serial);
@@ -567,10 +564,6 @@ static struct usb_serial_driver keyspan_1port_device = {
         .close                  = keyspan_close,
         .write                  = keyspan_write,
         .write_room             = keyspan_write_room,
-        .chars_in_buffer        = keyspan_chars_in_buffer,
-        .throttle               = keyspan_rx_throttle,
-        .unthrottle             = keyspan_rx_unthrottle,
-        .ioctl                  = keyspan_ioctl,
         .set_termios            = keyspan_set_termios,
         .break_ctl              = keyspan_break_ctl,
         .tiocmget               = keyspan_tiocmget,
@@ -591,10 +584,6 @@ static struct usb_serial_driver keyspan_2port_device = {
         .close                  = keyspan_close,
         .write                  = keyspan_write,
         .write_room             = keyspan_write_room,
-        .chars_in_buffer        = keyspan_chars_in_buffer,
-        .throttle               = keyspan_rx_throttle,
-        .unthrottle             = keyspan_rx_unthrottle,
-        .ioctl                  = keyspan_ioctl,
         .set_termios            = keyspan_set_termios,
         .break_ctl              = keyspan_break_ctl,
         .tiocmget               = keyspan_tiocmget,
@@ -615,10 +604,6 @@ static struct usb_serial_driver keyspan_4port_device = {
         .close                  = keyspan_close,
         .write                  = keyspan_write,
         .write_room             = keyspan_write_room,
-        .chars_in_buffer        = keyspan_chars_in_buffer,
-        .throttle               = keyspan_rx_throttle,
-        .unthrottle             = keyspan_rx_unthrottle,
-        .ioctl                  = keyspan_ioctl,
         .set_termios            = keyspan_set_termios,
         .break_ctl              = keyspan_break_ctl,
         .tiocmget               = keyspan_tiocmget,
diff --git a/drivers/usb/serial/keyspan_pda.c b/drivers/usb/serial/keyspan_pda.c
index 60b3e22bd633..24a08ac2e4ee 100644
--- a/drivers/usb/serial/keyspan_pda.c
+++ b/drivers/usb/serial/keyspan_pda.c
@@ -171,7 +171,7 @@ static void keyspan_pda_wakeup_write(struct work_struct *work)
                 container_of(work, struct keyspan_pda_private, wakeup_work);
         struct usb_serial_port *port = priv->port;
 
-        tty_wakeup(port->tty);
+        tty_wakeup(port->port.tty);
 }
 
 static void keyspan_pda_request_unthrottle(struct work_struct *work)
@@ -203,7 +203,7 @@ static void keyspan_pda_request_unthrottle(struct work_struct *work)
 static void keyspan_pda_rx_interrupt (struct urb *urb)
 {
         struct usb_serial_port *port = urb->context;
-        struct tty_struct *tty = port->tty;
+        struct tty_struct *tty = port->port.tty;
         unsigned char *data = urb->transfer_buffer;
         int i;
         int retval;
@@ -266,7 +266,7 @@ exit:
 }
 
 
-static void keyspan_pda_rx_throttle (struct usb_serial_port *port)
+static void keyspan_pda_rx_throttle(struct tty_struct *tty)
 {
         /* stop receiving characters. We just turn off the URB request, and
            let chars pile up in the device. If we're doing hardware
@@ -274,14 +274,15 @@ static void keyspan_pda_rx_throttle (struct usb_serial_port *port)
            fills up. If we're doing XON/XOFF, this would be a good time to
            send an XOFF, although it might make sense to foist that off
            upon the device too. */
-
+        struct usb_serial_port *port = tty->driver_data;
         dbg("keyspan_pda_rx_throttle port %d", port->number);
         usb_kill_urb(port->interrupt_in_urb);
 }
 
 
-static void keyspan_pda_rx_unthrottle (struct usb_serial_port *port)
+static void keyspan_pda_rx_unthrottle(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         /* just restart the receive interrupt URB */
         dbg("keyspan_pda_rx_unthrottle port %d", port->number);
         port->interrupt_in_urb->dev = port->serial->dev;
@@ -330,8 +331,9 @@ static speed_t keyspan_pda_setbaud (struct usb_serial *serial, speed_t baud)
 }
 
 
-static void keyspan_pda_break_ctl (struct usb_serial_port *port, int break_state)
+static void keyspan_pda_break_ctl(struct tty_struct *tty, int break_state)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct usb_serial *serial = port->serial;
         int value;
         int result;
@@ -354,8 +356,8 @@ static void keyspan_pda_break_ctl (struct usb_serial_port *port, int break_state
 }
 
 
-static void keyspan_pda_set_termios (struct usb_serial_port *port, 
-                                     struct ktermios *old_termios)
+static void keyspan_pda_set_termios(struct tty_struct *tty,
+                struct usb_serial_port *port, struct ktermios *old_termios)
 {
         struct usb_serial *serial = port->serial;
         speed_t speed;
@@ -380,7 +382,7 @@ static void keyspan_pda_set_termios (struct usb_serial_port *port,
 
            For now, just do baud. */
 
-        speed = tty_get_baud_rate(port->tty);
+        speed = tty_get_baud_rate(tty);
         speed = keyspan_pda_setbaud(serial, speed);
 
         if (speed == 0) {
@@ -390,8 +392,8 @@ static void keyspan_pda_set_termios (struct usb_serial_port *port,
         }
         /* Only speed can change so copy the old h/w parameters
            then encode the new speed */
-        tty_termios_copy_hw(port->tty->termios, old_termios);
-        tty_encode_baud_rate(port->tty, speed, speed);
+        tty_termios_copy_hw(tty->termios, old_termios);
+        tty_encode_baud_rate(tty, speed, speed);
 }
 
 
@@ -425,8 +427,9 @@ static int keyspan_pda_set_modem_info(struct usb_serial *serial,
         return rc;
 }
 
-static int keyspan_pda_tiocmget(struct usb_serial_port *port, struct file *file)
+static int keyspan_pda_tiocmget(struct tty_struct *tty, struct file *file)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct usb_serial *serial = port->serial;
         int rc;
         unsigned char status;
@@ -445,9 +448,10 @@ static int keyspan_pda_tiocmget(struct usb_serial_port *port, struct file *file)
         return value;
 }
 
-static int keyspan_pda_tiocmset(struct usb_serial_port *port, struct file *file,
+static int keyspan_pda_tiocmset(struct tty_struct *tty, struct file *file,
                                 unsigned int set, unsigned int clear)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct usb_serial *serial = port->serial;
         int rc;
         unsigned char status;
@@ -469,23 +473,8 @@ static int keyspan_pda_tiocmset(struct usb_serial_port *port, struct file *file,
         return rc;
 }
 
-static int keyspan_pda_ioctl(struct usb_serial_port *port, struct file *file,
-                             unsigned int cmd, unsigned long arg)
-{
-        switch (cmd) {
-        case TIOCMIWAIT:
-                /* wait for any of the 4 modem inputs (DCD,RI,DSR,CTS)*/
-                /* TODO */
-        case TIOCGICOUNT:
-                /* return count of modemline transitions */
-                return 0; /* TODO */
-        }
-        
-        return -ENOIOCTLCMD;
-}
-
-static int keyspan_pda_write(struct usb_serial_port *port, 
-                             const unsigned char *buf, int count)
+static int keyspan_pda_write(struct tty_struct *tty,
+        struct usb_serial_port *port, const unsigned char *buf, int count)
 {
         struct usb_serial *serial = port->serial;
         int request_unthrottle = 0;
@@ -607,22 +596,21 @@ static void keyspan_pda_write_bulk_callback (struct urb *urb)
 }
 
 
-static int keyspan_pda_write_room (struct usb_serial_port *port)
+static int keyspan_pda_write_room(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct keyspan_pda_private *priv;
-
         priv = usb_get_serial_port_data(port);
-
         /* used by n_tty.c for processing of tabs and such. Giving it our
            conservative guess is probably good enough, but needs testing by
            running a console through the device. */
-
         return (priv->tx_room);
 }
 
 
-static int keyspan_pda_chars_in_buffer (struct usb_serial_port *port)
+static int keyspan_pda_chars_in_buffer(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct keyspan_pda_private *priv;
         unsigned long flags;
         int ret = 0;
@@ -640,7 +628,8 @@ static int keyspan_pda_chars_in_buffer (struct usb_serial_port *port)
 }
 
 
-static int keyspan_pda_open (struct usb_serial_port *port, struct file *filp)
+static int keyspan_pda_open(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 {
         struct usb_serial *serial = port->serial;
         unsigned char room;
@@ -672,7 +661,7 @@ static int keyspan_pda_open (struct usb_serial_port *port, struct file *filp)
 
         /* the normal serial device seems to always turn on DTR and RTS here,
            so do the same */
-        if (port->tty->termios->c_cflag & CBAUD)
+        if (tty && (tty->termios->c_cflag & CBAUD))
                 keyspan_pda_set_modem_info(serial, (1<<7) | (1<<2) );
         else
                 keyspan_pda_set_modem_info(serial, 0);
@@ -690,13 +679,14 @@ error:
 }
 
 
-static void keyspan_pda_close(struct usb_serial_port *port, struct file *filp)
+static void keyspan_pda_close(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 {
         struct usb_serial *serial = port->serial;
 
         if (serial->dev) {
                 /* the normal serial device seems to always shut off DTR and RTS now */
-                if (port->tty->termios->c_cflag & HUPCL)
+                if (tty->termios->c_cflag & HUPCL)
                         keyspan_pda_set_modem_info(serial, 0);
 
                 /* shutdown our bulk reads and writes */
@@ -832,7 +822,6 @@ static struct usb_serial_driver keyspan_pda_device = {
         .chars_in_buffer =      keyspan_pda_chars_in_buffer,
         .throttle =             keyspan_pda_rx_throttle,
         .unthrottle =           keyspan_pda_rx_unthrottle,
-        .ioctl =                keyspan_pda_ioctl,
         .set_termios =          keyspan_pda_set_termios,
         .break_ctl =            keyspan_pda_break_ctl,
         .tiocmget =             keyspan_pda_tiocmget,
diff --git a/drivers/usb/serial/kl5kusb105.c b/drivers/usb/serial/kl5kusb105.c
index 79787eda9524..4a38ec8f5fe3 100644
--- a/drivers/usb/serial/kl5kusb105.c
+++ b/drivers/usb/serial/kl5kusb105.c
@@ -74,29 +74,33 @@ static int debug;
  */
 static int  klsi_105_startup             (struct usb_serial *serial);
 static void klsi_105_shutdown            (struct usb_serial *serial);
-static int  klsi_105_open                (struct usb_serial_port *port,
+static int  klsi_105_open                (struct tty_struct *tty,
+                                          struct usb_serial_port *port,
                                           struct file *filp);
-static void klsi_105_close               (struct usb_serial_port *port,
+static void klsi_105_close               (struct tty_struct *tty,
+                                          struct usb_serial_port *port,
                                           struct file *filp);
-static int  klsi_105_write               (struct usb_serial_port *port,
+static int  klsi_105_write               (struct tty_struct *tty,
+                                          struct usb_serial_port *port,
                                           const unsigned char *buf,
                                           int count);
 static void klsi_105_write_bulk_callback (struct urb *urb);
-static int  klsi_105_chars_in_buffer     (struct usb_serial_port *port);
-static int  klsi_105_write_room          (struct usb_serial_port *port);
+static int  klsi_105_chars_in_buffer     (struct tty_struct *tty);
+static int  klsi_105_write_room          (struct tty_struct *tty);
 
 static void klsi_105_read_bulk_callback  (struct urb *urb);
-static void klsi_105_set_termios         (struct usb_serial_port *port,
+static void klsi_105_set_termios         (struct tty_struct *tty,
+                                          struct usb_serial_port *port,
                                           struct ktermios *old);
-static void klsi_105_throttle            (struct usb_serial_port *port);
-static void klsi_105_unthrottle          (struct usb_serial_port *port);
+static void klsi_105_throttle            (struct tty_struct *tty);
+static void klsi_105_unthrottle          (struct tty_struct *tty);
 /*
-static void klsi_105_break_ctl           (struct usb_serial_port *port,
+static void klsi_105_break_ctl           (struct tty_struct *tty,
                                           int break_state );
  */
-static int  klsi_105_tiocmget            (struct usb_serial_port *port,
+static int  klsi_105_tiocmget            (struct tty_struct *tty,
                                           struct file *file);
-static int  klsi_105_tiocmset            (struct usb_serial_port *port,
+static int  klsi_105_tiocmset            (struct tty_struct *tty,
                                           struct file *file, unsigned int set,
                                           unsigned int clear);
 
@@ -361,7 +365,8 @@ static void klsi_105_shutdown (struct usb_serial *serial)
         }
 } /* klsi_105_shutdown */
 
-static int  klsi_105_open (struct usb_serial_port *port, struct file *filp)
+static int  klsi_105_open(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 {
         struct klsi_105_private *priv = usb_get_serial_port_data(port);
         int retval = 0;
@@ -375,7 +380,7 @@ static int  klsi_105_open (struct usb_serial_port *port, struct file *filp)
 
         /* force low_latency on so that our tty_push actually forces
          * the data through
-         * port->tty->low_latency = 1; */
+         * tty->low_latency = 1; */
 
         /* Do a defined restart:
          * Set up sane default baud rate and send the 'READ_ON'
@@ -393,12 +398,12 @@ static int  klsi_105_open (struct usb_serial_port *port, struct file *filp)
         
         /* set up termios structure */
         spin_lock_irqsave (&priv->lock, flags);
-        priv->termios.c_iflag = port->tty->termios->c_iflag;
-        priv->termios.c_oflag = port->tty->termios->c_oflag;
-        priv->termios.c_cflag = port->tty->termios->c_cflag;
-        priv->termios.c_lflag = port->tty->termios->c_lflag;
+        priv->termios.c_iflag = tty->termios->c_iflag;
+        priv->termios.c_oflag = tty->termios->c_oflag;
+        priv->termios.c_cflag = tty->termios->c_cflag;
+        priv->termios.c_lflag = tty->termios->c_lflag;
         for (i=0; i<NCCS; i++)
-                priv->termios.c_cc[i] = port->tty->termios->c_cc[i];
+                priv->termios.c_cc[i] = tty->termios->c_cc[i];
         priv->cfg.pktlen   = cfg.pktlen;
         priv->cfg.baudrate = cfg.baudrate;
         priv->cfg.databits = cfg.databits;
@@ -452,7 +457,8 @@ exit:
 } /* klsi_105_open */
 
 
-static void klsi_105_close (struct usb_serial_port *port, struct file *filp)
+static void klsi_105_close(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 {
         struct klsi_105_private *priv = usb_get_serial_port_data(port);
         int rc;
@@ -493,8 +499,8 @@ static void klsi_105_close (struct usb_serial_port *port, struct file *filp)
 #define KLSI_105_DATA_OFFSET    2   /* in the bulk urb data block */
 
 
-static int klsi_105_write (struct usb_serial_port *port,
-                           const unsigned char *buf, int count)
+static int klsi_105_write(struct tty_struct *tty,
+        struct usb_serial_port *port, const unsigned char *buf, int count)
 {
         struct klsi_105_private *priv = usb_get_serial_port_data(port);
         int result, size;
@@ -584,8 +590,9 @@ static void klsi_105_write_bulk_callback ( struct urb *urb)
 
 
 /* return number of characters currently in the writing process */
-static int klsi_105_chars_in_buffer (struct usb_serial_port *port)
+static int klsi_105_chars_in_buffer (struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         int chars = 0;
         int i;
         unsigned long flags;
@@ -605,8 +612,9 @@ static int klsi_105_chars_in_buffer (struct usb_serial_port *port)
         return (chars);
 }
 
-static int klsi_105_write_room (struct usb_serial_port *port)
+static int klsi_105_write_room (struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         unsigned long flags;
         int i;
         int room = 0;
@@ -660,7 +668,7 @@ static void klsi_105_read_bulk_callback (struct urb *urb)
         } else {
                 int bytes_sent = ((__u8 *) data)[0] +
                                  ((unsigned int) ((__u8 *) data)[1] << 8);
-                tty = port->tty;
+                tty = port->port.tty;
                 /* we should immediately resubmit the URB, before attempting
                  * to pass the data on to the tty layer. But that needs locking
                  * against re-entry an then mixed-up data because of
@@ -699,11 +707,11 @@ static void klsi_105_read_bulk_callback (struct urb *urb)
 } /* klsi_105_read_bulk_callback */
 
 
-static void klsi_105_set_termios (struct usb_serial_port *port,
+static void klsi_105_set_termios (struct tty_struct *tty,
+                                  struct usb_serial_port *port,
                                   struct ktermios *old_termios)
 {
         struct klsi_105_private *priv = usb_get_serial_port_data(port);
-        struct tty_struct *tty = port->tty;
         unsigned int iflag = tty->termios->c_iflag;
         unsigned int old_iflag = old_termios->c_iflag;
         unsigned int cflag = tty->termios->c_cflag;
@@ -863,8 +871,9 @@ static void klsi_105_set_termios (struct usb_serial_port *port,
 
 
 #if 0
-static void mct_u232_break_ctl( struct usb_serial_port *port, int break_state )
+static void mct_u232_break_ctl( struct tty_struct *tty, int break_state )
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct usb_serial *serial = port->serial;
         struct mct_u232_private *priv = (struct mct_u232_private *)port->private;
         unsigned char lcr = priv->last_lcr;
@@ -878,8 +887,9 @@ static void mct_u232_break_ctl( struct usb_serial_port *port, int break_state )
 } /* mct_u232_break_ctl */
 #endif
 
-static int klsi_105_tiocmget (struct usb_serial_port *port, struct file *file)
+static int klsi_105_tiocmget (struct tty_struct *tty, struct file *file)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct klsi_105_private *priv = usb_get_serial_port_data(port);
         unsigned long flags;
         int rc;
@@ -900,7 +910,7 @@ static int klsi_105_tiocmget (struct usb_serial_port *port, struct file *file)
         return (int)line_state;
 }
 
-static int klsi_105_tiocmset (struct usb_serial_port *port, struct file *file,
+static int klsi_105_tiocmset (struct tty_struct *tty, struct file *file,
                               unsigned int set, unsigned int clear)
 {
         int retval = -EINVAL;
@@ -929,14 +939,16 @@ static int klsi_105_tiocmset (struct usb_serial_port *port, struct file *file,
         return retval;
 }
 
-static void klsi_105_throttle (struct usb_serial_port *port)
+static void klsi_105_throttle (struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         dbg("%s - port %d", __func__, port->number);
         usb_kill_urb(port->read_urb);
 }
 
-static void klsi_105_unthrottle (struct usb_serial_port *port)
+static void klsi_105_unthrottle (struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         int result;
 
         dbg("%s - port %d", __func__, port->number);
diff --git a/drivers/usb/serial/kobil_sct.c b/drivers/usb/serial/kobil_sct.c
index 693f00da7c03..40c67f0096b1 100644
--- a/drivers/usb/serial/kobil_sct.c
+++ b/drivers/usb/serial/kobil_sct.c
@@ -70,19 +70,22 @@ static int debug;
 /* Function prototypes */
 static int  kobil_startup (struct usb_serial *serial);
 static void kobil_shutdown (struct usb_serial *serial);
-static int  kobil_open (struct usb_serial_port *port, struct file *filp);
-static void kobil_close (struct usb_serial_port *port, struct file *filp);
-static int  kobil_write (struct usb_serial_port *port, 
+static int  kobil_open (struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp);
+static void kobil_close (struct tty_struct *tty, struct usb_serial_port *port,
+                        struct file *filp);
+static int  kobil_write (struct tty_struct *tty, struct usb_serial_port *port, 
                          const unsigned char *buf, int count);
-static int  kobil_write_room(struct usb_serial_port *port);
-static int  kobil_ioctl(struct usb_serial_port *port, struct file *file,
+static int  kobil_write_room(struct tty_struct *tty);
+static int  kobil_ioctl(struct tty_struct *tty, struct file *file,
                         unsigned int cmd, unsigned long arg);
-static int  kobil_tiocmget(struct usb_serial_port *port, struct file *file);
-static int  kobil_tiocmset(struct usb_serial_port *port, struct file *file,
+static int  kobil_tiocmget(struct tty_struct *tty, struct file *file);
+static int  kobil_tiocmset(struct tty_struct *tty, struct file *file,
                            unsigned int set, unsigned int clear);
 static void kobil_read_int_callback( struct urb *urb );
 static void kobil_write_callback( struct urb *purb );
-static void kobil_set_termios(struct usb_serial_port *port, struct ktermios *old);
+static void kobil_set_termios(struct tty_struct *tty, 
+                        struct usb_serial_port *port, struct ktermios *old);
 
 
 static struct usb_device_id id_table [] = {
@@ -201,8 +204,8 @@ static void kobil_shutdown (struct usb_serial *serial)
         dbg("%s - port %d", __func__, serial->port[0]->number);
 
         for (i=0; i < serial->num_ports; ++i) {
-                while (serial->port[i]->open_count > 0) {
-                        kobil_close (serial->port[i], NULL);
+                while (serial->port[i]->port.count > 0) {
+                        kobil_close (NULL, serial->port[i], NULL);
                 }
                 kfree(usb_get_serial_port_data(serial->port[i]));
                 usb_set_serial_port_data(serial->port[i], NULL);
@@ -210,7 +213,8 @@ static void kobil_shutdown (struct usb_serial *serial)
 }
 
 
-static int kobil_open (struct usb_serial_port *port, struct file *filp)
+static int kobil_open(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 {
         int result = 0;
         struct kobil_private *priv;
@@ -229,14 +233,15 @@ static int kobil_open (struct usb_serial_port *port, struct file *filp)
          * the data through, otherwise it is scheduled, and with high
          * data rates (like with OHCI) data can get lost.
          */
-        port->tty->low_latency = 1;
-
-        // without this, every push_tty_char is echoed :-(  
-        port->tty->termios->c_lflag = 0;
-        port->tty->termios->c_lflag &= ~(ISIG | ICANON | ECHO | IEXTEN | XCASE);
-        port->tty->termios->c_iflag = IGNBRK | IGNPAR | IXOFF;
-        port->tty->termios->c_oflag &= ~ONLCR; // do NOT translate CR to CR-NL (0x0A -> 0x0A 0x0D)
-        
+        if (tty) {
+                tty->low_latency = 1;
+
+                /* Default to echo off and other sane device settings */
+                tty->termios->c_lflag = 0;
+                tty->termios->c_lflag &= ~(ISIG | ICANON | ECHO | IEXTEN | XCASE);
+                tty->termios->c_iflag = IGNBRK | IGNPAR | IXOFF;
+                tty->termios->c_oflag &= ~ONLCR; // do NOT translate CR to CR-NL (0x0A -> 0x0A 0x0D)
+        }       
         // allocate memory for transfer buffer
         transfer_buffer = kzalloc(transfer_buffer_length, GFP_KERNEL);
         if (! transfer_buffer) {
@@ -330,7 +335,8 @@ static int kobil_open (struct usb_serial_port *port, struct file *filp)
 }
 
 
-static void kobil_close (struct usb_serial_port *port, struct file *filp)
+static void kobil_close(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 {
         dbg("%s - port %d", __func__, port->number);
 
@@ -360,7 +366,7 @@ static void kobil_read_int_callback(struct urb *urb)
                 return;
         }
 
-        tty = port->tty;
+        tty = port->port.tty;
         if (urb->actual_length) {
 
                 // BEGIN DEBUG
@@ -395,7 +401,7 @@ static void kobil_write_callback( struct urb *purb )
 }
 
 
-static int kobil_write (struct usb_serial_port *port, 
+static int kobil_write (struct tty_struct *tty, struct usb_serial_port *port, 
                         const unsigned char *buf, int count)
 {
         int length = 0;
@@ -417,12 +423,9 @@ static int kobil_write (struct usb_serial_port *port,
 
         // Copy data to buffer
         memcpy (priv->buf + priv->filled, buf, count);
-
         usb_serial_debug_data(debug, &port->dev, __func__, count, priv->buf + priv->filled);
-
         priv->filled = priv->filled + count;
 
-
         // only send complete block. TWIN, KAAN SIM and adapter K use the same protocol.
         if ( ((priv->device_type != KOBIL_ADAPTER_B_PRODUCT_ID) && (priv->filled > 2) && (priv->filled >= (priv->buf[1] + 3))) || 
              ((priv->device_type == KOBIL_ADAPTER_B_PRODUCT_ID) && (priv->filled > 3) && (priv->filled >= (priv->buf[2] + 4))) ) {
@@ -478,15 +481,17 @@ static int kobil_write (struct usb_serial_port *port,
 }
 
 
-static int kobil_write_room (struct usb_serial_port *port)
+static int kobil_write_room (struct tty_struct *tty)
 {
         //dbg("%s - port %d", __func__, port->number);
+        /* FIXME */
         return 8;
 }
 
 
-static int kobil_tiocmget(struct usb_serial_port *port, struct file *file)
+static int kobil_tiocmget(struct tty_struct *tty, struct file *file)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct kobil_private * priv;
         int result;
         unsigned char *transfer_buffer;
@@ -524,9 +529,10 @@ static int kobil_tiocmget(struct usb_serial_port *port, struct file *file)
         return result;
 }
 
-static int  kobil_tiocmset(struct usb_serial_port *port, struct file *file,
+static int kobil_tiocmset(struct tty_struct *tty, struct file *file,
                            unsigned int set, unsigned int clear)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct kobil_private * priv;
         int result;
         int dtr = 0;
@@ -590,12 +596,13 @@ static int  kobil_tiocmset(struct usb_serial_port *port, struct file *file,
         return (result < 0) ? result : 0;
 }
 
-static void kobil_set_termios(struct usb_serial_port *port, struct ktermios *old)
+static void kobil_set_termios(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct ktermios *old)
 {
         struct kobil_private * priv;
         int result;
         unsigned short urb_val = 0;
-        int c_cflag = port->tty->termios->c_cflag;
+        int c_cflag = tty->termios->c_cflag;
         speed_t speed;
         void * settings;
 
@@ -604,7 +611,7 @@ static void kobil_set_termios(struct usb_serial_port *port, struct ktermios *old
                 // This device doesn't support ioctl calls
                 return;
 
-        switch (speed = tty_get_baud_rate(port->tty)) {
+        switch (speed = tty_get_baud_rate(tty)) {
                 case 1200:
                         urb_val = SUSBCR_SBR_1200;
                         break;
@@ -634,8 +641,8 @@ static void kobil_set_termios(struct usb_serial_port *port, struct ktermios *old
                 urb_val |= SUSBCR_SPASB_NoParity;
                 strcat(settings, "No Parity");
         }
-        port->tty->termios->c_cflag &= ~CMSPAR;
-        tty_encode_baud_rate(port->tty, speed, speed);
+        tty->termios->c_cflag &= ~CMSPAR;
+        tty_encode_baud_rate(tty, speed, speed);
 
         result = usb_control_msg( port->serial->dev,
                                   usb_rcvctrlpipe(port->serial->dev, 0 ),
@@ -650,8 +657,9 @@ static void kobil_set_termios(struct usb_serial_port *port, struct ktermios *old
         kfree(settings);
 }
 
-static int kobil_ioctl(struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg)
+static int kobil_ioctl(struct tty_struct *tty, struct file * file, unsigned int cmd, unsigned long arg)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct kobil_private * priv = usb_get_serial_port_data(port);
         unsigned char *transfer_buffer;
         int transfer_buffer_length = 8;
@@ -662,7 +670,7 @@ static int kobil_ioctl(struct usb_serial_port *port, struct file * file, unsigne
                 return 0;
 
         switch (cmd) {
-        case TCFLSH:   // 0x540B
+        case TCFLSH:
                 transfer_buffer = kmalloc(transfer_buffer_length, GFP_KERNEL);
                 if (! transfer_buffer)
                         return -ENOBUFS;
@@ -680,7 +688,7 @@ static int kobil_ioctl(struct usb_serial_port *port, struct file * file, unsigne
                 
                 dbg("%s - port %d Send reset_all_queues (FLUSH) URB returns: %i", __func__, port->number, result);
                 kfree(transfer_buffer);
-                return (result < 0) ? -EFAULT : 0;
+                return (result < 0) ? -EIO: 0;
         default:
                 return -ENOIOCTLCMD;
         }
diff --git a/drivers/usb/serial/mct_u232.c b/drivers/usb/serial/mct_u232.c
index 5fc2cef30e39..7bce4302a5f9 100644
--- a/drivers/usb/serial/mct_u232.c
+++ b/drivers/usb/serial/mct_u232.c
@@ -92,26 +92,25 @@ static int debug;
  */
 static int  mct_u232_startup             (struct usb_serial *serial);
 static void mct_u232_shutdown            (struct usb_serial *serial);
-static int  mct_u232_open                (struct usb_serial_port *port,
+static int  mct_u232_open                (struct tty_struct *tty,
+                                          struct usb_serial_port *port,
                                           struct file *filp);
-static void mct_u232_close               (struct usb_serial_port *port,
+static void mct_u232_close               (struct tty_struct *tty,
+                                          struct usb_serial_port *port,
                                           struct file *filp);
 static void mct_u232_read_int_callback   (struct urb *urb);
-static void mct_u232_set_termios         (struct usb_serial_port *port,
+static void mct_u232_set_termios         (struct tty_struct *tty,
+                                          struct usb_serial_port *port,
                                           struct ktermios * old);
-static int  mct_u232_ioctl               (struct usb_serial_port *port,
-                                          struct file * file,
-                                          unsigned int cmd,
-                                          unsigned long arg);
-static void mct_u232_break_ctl           (struct usb_serial_port *port,
+static void mct_u232_break_ctl           (struct tty_struct *tty,
                                           int break_state );
-static int  mct_u232_tiocmget            (struct usb_serial_port *port,
+static int  mct_u232_tiocmget            (struct tty_struct *tty,
                                           struct file *file);
-static int  mct_u232_tiocmset            (struct usb_serial_port *port,
+static int  mct_u232_tiocmset            (struct tty_struct *tty,
                                           struct file *file, unsigned int set,
                                           unsigned int clear);
-static void mct_u232_throttle            (struct usb_serial_port *port);
-static void mct_u232_unthrottle          (struct usb_serial_port *port);
+static void mct_u232_throttle            (struct tty_struct *tty);
+static void mct_u232_unthrottle          (struct tty_struct *tty);
 
 
 /*
@@ -149,7 +148,6 @@ static struct usb_serial_driver mct_u232_device = {
         .throttle =          mct_u232_throttle,
         .unthrottle =        mct_u232_unthrottle,
         .read_int_callback = mct_u232_read_int_callback,
-        .ioctl =             mct_u232_ioctl,
         .set_termios =       mct_u232_set_termios,
         .break_ctl =         mct_u232_break_ctl,
         .tiocmget =          mct_u232_tiocmget,
@@ -224,8 +222,8 @@ static int mct_u232_calculate_baud_rate(struct usb_serial *serial, speed_t value
         }
 }
 
-static int mct_u232_set_baud_rate(struct usb_serial *serial, struct usb_serial_port *port,
-                                  speed_t value)
+static int mct_u232_set_baud_rate(struct tty_struct *tty,
+        struct usb_serial *serial, struct usb_serial_port *port, speed_t value)
 {
         __le32 divisor;
         int rc;
@@ -243,7 +241,7 @@ static int mct_u232_set_baud_rate(struct usb_serial *serial, struct usb_serial_p
         if (rc < 0)     /*FIXME: What value speed results */
                 err("Set BAUD RATE %d failed (error = %d)", value, rc);
         else
-                tty_encode_baud_rate(port->tty, speed, speed);
+                tty_encode_baud_rate(tty, speed, speed);
         dbg("set_baud_rate: value: 0x%x, divisor: 0x%x", value, divisor);
 
         /* Mimic the MCT-supplied Windows driver (version 1.21P.0104), which
@@ -272,7 +270,7 @@ static int mct_u232_set_baud_rate(struct usb_serial *serial, struct usb_serial_p
                 err("Sending USB device request code %d failed (error = %d)", 
                     MCT_U232_SET_UNKNOWN1_REQUEST, rc);
 
-        if (port && C_CRTSCTS(port->tty)) {
+        if (port && C_CRTSCTS(tty)) {
            cts_enable_byte = 1;
         }
 
@@ -411,7 +409,8 @@ static void mct_u232_shutdown (struct usb_serial *serial)
         }
 } /* mct_u232_shutdown */
 
-static int  mct_u232_open (struct usb_serial_port *port, struct file *filp)
+static int  mct_u232_open (struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 {
         struct usb_serial *serial = port->serial;
         struct mct_u232_private *priv = usb_get_serial_port_data(port);
@@ -437,7 +436,7 @@ static int  mct_u232_open (struct usb_serial_port *port, struct file *filp)
          * either.
          */
         spin_lock_irqsave(&priv->lock, flags);
-        if (port->tty->termios->c_cflag & CBAUD)
+        if (tty && (tty->termios->c_cflag & CBAUD))
                 priv->control_state = TIOCM_DTR | TIOCM_RTS;
         else
                 priv->control_state = 0;
@@ -481,15 +480,16 @@ error:
 } /* mct_u232_open */
 
 
-static void mct_u232_close (struct usb_serial_port *port, struct file *filp)
+static void mct_u232_close(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 {
         unsigned int c_cflag;
         unsigned int control_state;
         struct mct_u232_private *priv = usb_get_serial_port_data(port);
         dbg("%s port %d", __func__, port->number);
 
-        if (port->tty) {
-                c_cflag = port->tty->termios->c_cflag;
+        if (tty) {
+                c_cflag = tty->termios->c_cflag;
                 mutex_lock(&port->serial->disc_mutex);
                 if (c_cflag & HUPCL && !port->serial->disconnected) {
                         /* drop DTR and RTS */
@@ -553,7 +553,7 @@ static void mct_u232_read_int_callback (struct urb *urb)
          */
         if (urb->transfer_buffer_length > 2) {
                 int i;
-                tty = port->tty;
+                tty = port->port.tty;
                 if (urb->actual_length) {
                         for (i = 0; i < urb->actual_length ; ++i) {
                                 tty_insert_flip_char(tty, data[i], 0);
@@ -583,7 +583,7 @@ static void mct_u232_read_int_callback (struct urb *urb)
          * to look in to this before committing any code.
          */
         if (priv->last_lsr & MCT_U232_LSR_ERR) {
-                tty = port->tty;
+                tty = port->port.tty;
                 /* Overrun Error */
                 if (priv->last_lsr & MCT_U232_LSR_OE) {
                 }
@@ -606,12 +606,13 @@ exit:
                      __func__, retval);
 } /* mct_u232_read_int_callback */
 
-static void mct_u232_set_termios (struct usb_serial_port *port,
+static void mct_u232_set_termios (struct tty_struct *tty,
+                                  struct usb_serial_port *port,
                                   struct ktermios *old_termios)
 {
         struct usb_serial *serial = port->serial;
         struct mct_u232_private *priv = usb_get_serial_port_data(port);
-        struct ktermios *termios = port->tty->termios;
+        struct ktermios *termios = tty->termios;
         unsigned int cflag = termios->c_cflag;
         unsigned int old_cflag = old_termios->c_cflag;
         unsigned long flags;
@@ -638,7 +639,7 @@ static void mct_u232_set_termios (struct usb_serial_port *port,
                 mct_u232_set_modem_ctrl(serial, control_state);
         }
 
-        mct_u232_set_baud_rate(serial, port, tty_get_baud_rate(port->tty));
+        mct_u232_set_baud_rate(tty, serial, port, tty_get_baud_rate(tty));
 
         if ((cflag & CBAUD) == B0 ) {
                 dbg("%s: baud is B0", __func__);
@@ -689,8 +690,9 @@ static void mct_u232_set_termios (struct usb_serial_port *port,
         spin_unlock_irqrestore(&priv->lock, flags);
 } /* mct_u232_set_termios */
 
-static void mct_u232_break_ctl( struct usb_serial_port *port, int break_state )
+static void mct_u232_break_ctl(struct tty_struct *tty, int break_state)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct usb_serial *serial = port->serial;
         struct mct_u232_private *priv = usb_get_serial_port_data(port);
         unsigned char lcr;
@@ -709,8 +711,9 @@ static void mct_u232_break_ctl( struct usb_serial_port *port, int break_state )
 } /* mct_u232_break_ctl */
 
 
-static int mct_u232_tiocmget (struct usb_serial_port *port, struct file *file)
+static int mct_u232_tiocmget(struct tty_struct *tty, struct file *file)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct mct_u232_private *priv = usb_get_serial_port_data(port);
         unsigned int control_state;
         unsigned long flags;
@@ -724,9 +727,10 @@ static int mct_u232_tiocmget (struct usb_serial_port *port, struct file *file)
         return control_state;
 }
 
-static int mct_u232_tiocmset (struct usb_serial_port *port, struct file *file,
+static int mct_u232_tiocmset(struct tty_struct *tty, struct file *file,
                               unsigned int set, unsigned int clear)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct usb_serial *serial = port->serial;
         struct mct_u232_private *priv = usb_get_serial_port_data(port);
         unsigned int control_state;
@@ -751,73 +755,46 @@ static int mct_u232_tiocmset (struct usb_serial_port *port, struct file *file,
         return mct_u232_set_modem_ctrl(serial, control_state);
 }
 
-static int mct_u232_ioctl (struct usb_serial_port *port, struct file * file,
-                           unsigned int cmd, unsigned long arg)
-{
-        dbg("%scmd=0x%x", __func__, cmd);
-
-        /* Based on code from acm.c and others */
-        switch (cmd) {
-        case TIOCMIWAIT:
-                /* wait for any of the 4 modem inputs (DCD,RI,DSR,CTS)*/
-                /* TODO */
-                return( 0 );
-
-        case TIOCGICOUNT:
-                /* return count of modemline transitions */
-                /* TODO */
-                return 0;
-
-        default:
-                dbg("%s: arg not supported - 0x%04x", __func__,cmd);
-                return(-ENOIOCTLCMD);
-                break;
-        }
-        return 0;
-} /* mct_u232_ioctl */
-
-static void mct_u232_throttle (struct usb_serial_port *port)
+static void mct_u232_throttle(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct mct_u232_private *priv = usb_get_serial_port_data(port);
         unsigned long flags;
         unsigned int control_state;
-        struct tty_struct *tty;
 
-        tty = port->tty;
         dbg("%s - port %d", __func__, port->number);
 
         spin_lock_irqsave(&priv->lock, flags);
         priv->rx_flags |= THROTTLED;
         if (C_CRTSCTS(tty)) {
-          priv->control_state &= ~TIOCM_RTS;
-          control_state = priv->control_state;
-          spin_unlock_irqrestore(&priv->lock, flags);
-          (void) mct_u232_set_modem_ctrl(port->serial, control_state);
+                priv->control_state &= ~TIOCM_RTS;
+                control_state = priv->control_state;
+                spin_unlock_irqrestore(&priv->lock, flags);
+                (void) mct_u232_set_modem_ctrl(port->serial, control_state);
         } else {
-          spin_unlock_irqrestore(&priv->lock, flags);
+                spin_unlock_irqrestore(&priv->lock, flags);
         }
 }
 
 
-static void mct_u232_unthrottle (struct usb_serial_port *port)
+static void mct_u232_unthrottle(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct mct_u232_private *priv = usb_get_serial_port_data(port);
         unsigned long flags;
         unsigned int control_state;
-        struct tty_struct *tty;
 
         dbg("%s - port %d", __func__, port->number);
 
-        tty = port->tty;
         spin_lock_irqsave(&priv->lock, flags);
         if ((priv->rx_flags & THROTTLED) && C_CRTSCTS(tty)) {
-          priv->rx_flags &= ~THROTTLED;
-          priv->control_state |= TIOCM_RTS;
-          control_state = priv->control_state;
-          spin_unlock_irqrestore(&priv->lock, flags);
-          (void) mct_u232_set_modem_ctrl(port->serial, control_state);
+                priv->rx_flags &= ~THROTTLED;
+                priv->control_state |= TIOCM_RTS;
+                control_state = priv->control_state;
+                spin_unlock_irqrestore(&priv->lock, flags);
+                (void) mct_u232_set_modem_ctrl(port->serial, control_state);
         } else {
-          spin_unlock_irqrestore(&priv->lock, flags);
+                spin_unlock_irqrestore(&priv->lock, flags);
         }
 }
 
diff --git a/drivers/usb/serial/mos7720.c b/drivers/usb/serial/mos7720.c
index 50f1fe263338..d47f0814ce2d 100644
--- a/drivers/usb/serial/mos7720.c
+++ b/drivers/usb/serial/mos7720.c
@@ -218,7 +218,7 @@ static void mos7720_bulk_in_callback(struct urb *urb)
 
         data = urb->transfer_buffer;
 
-        tty = port->tty;
+        tty = port->port.tty;
         if (tty && urb->actual_length) {
                 tty_buffer_request_room(tty, urb->actual_length);
                 tty_insert_flip_string(tty, data, urb->actual_length);
@@ -264,7 +264,7 @@ static void mos7720_bulk_out_data_callback(struct urb *urb)
 
         dbg("Entering .........");
 
-        tty = mos7720_port->port->tty;
+        tty = mos7720_port->port->port.tty;
 
         if (tty && mos7720_port->open)
                 tty_wakeup(tty);
@@ -320,7 +320,8 @@ static int send_mos_cmd(struct usb_serial *serial, __u8 request, __u16 value,
         return status;
 }
 
-static int mos7720_open(struct usb_serial_port *port, struct file * filp)
+static int mos7720_open(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file * filp)
 {
         struct usb_serial *serial;
         struct usb_serial_port *port0;
@@ -443,14 +444,12 @@ static int mos7720_open(struct usb_serial_port *port, struct file * filp)
         data = 0x0c;
         send_mos_cmd(serial, MOS_WRITE, port_number, 0x01, &data);
 
-//Matrix
-
         /* force low_latency on so that our tty_push actually forces *
          * the data through,otherwise it is scheduled, and with      *
          * high data rates (like with OHCI) data can get lost.       */
 
-        if (port->tty)
-                port->tty->low_latency = 1;
+        if (tty)
+                tty->low_latency = 1;
 
         /* see if we've set up our endpoint info yet   *
          * (can't set it up in mos7720_startup as the  *
@@ -515,8 +514,9 @@ static int mos7720_open(struct usb_serial_port *port, struct file * filp)
  *      system,
  *      Otherwise we return a negative error number.
  */
-static int mos7720_chars_in_buffer(struct usb_serial_port *port)
+static int mos7720_chars_in_buffer(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         int i;
         int chars = 0;
         struct moschip_port *mos7720_port;
@@ -537,7 +537,8 @@ static int mos7720_chars_in_buffer(struct usb_serial_port *port)
         return chars;
 }
 
-static void mos7720_close(struct usb_serial_port *port, struct file *filp)
+static void mos7720_close(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 {
         struct usb_serial *serial;
         struct moschip_port *mos7720_port;
@@ -588,8 +589,9 @@ static void mos7720_close(struct usb_serial_port *port, struct file *filp)
         dbg("Leaving %s", __func__);
 }
 
-static void mos7720_break(struct usb_serial_port *port, int break_state)
+static void mos7720_break(struct tty_struct *tty, int break_state)
 {
+        struct usb_serial_port *port = tty->driver_data;
         unsigned char data;
         struct usb_serial *serial;
         struct moschip_port *mos7720_port;
@@ -621,8 +623,9 @@ static void mos7720_break(struct usb_serial_port *port, int break_state)
  *      If successful, we return the amount of room that we have for this port
  *      Otherwise we return a negative error number.
  */
-static int mos7720_write_room(struct usb_serial_port *port)
+static int mos7720_write_room(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct moschip_port *mos7720_port;
         int room = 0;
         int i;
@@ -645,8 +648,8 @@ static int mos7720_write_room(struct usb_serial_port *port)
         return room;
 }
 
-static int mos7720_write(struct usb_serial_port *port,
-                         const unsigned char *data, int count)
+static int mos7720_write(struct tty_struct *tty, struct usb_serial_port *port,
+                                 const unsigned char *data, int count)
 {
         int status;
         int i;
@@ -719,10 +722,10 @@ exit:
         return bytes_sent;
 }
 
-static void mos7720_throttle(struct usb_serial_port *port)
+static void mos7720_throttle(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct moschip_port *mos7720_port;
-        struct tty_struct *tty;
         int status;
 
         dbg("%s- port %d\n", __func__, port->number);
@@ -739,16 +742,10 @@ static void mos7720_throttle(struct usb_serial_port *port)
 
         dbg("%s: Entering ..........", __func__);
 
-        tty = port->tty;
-        if (!tty) {
-                dbg("%s - no tty available", __func__);
-                return;
-        }
-
         /* if we are implementing XON/XOFF, send the stop character */
         if (I_IXOFF(tty)) {
                 unsigned char stop_char = STOP_CHAR(tty);
-                status = mos7720_write(port, &stop_char, 1);
+                status = mos7720_write(tty, port, &stop_char, 1);
                 if (status <= 0)
                         return;
         }
@@ -764,11 +761,11 @@ static void mos7720_throttle(struct usb_serial_port *port)
         }
 }
 
-static void mos7720_unthrottle(struct usb_serial_port *port)
+static void mos7720_unthrottle(struct tty_struct *tty)
 {
-        struct tty_struct *tty;
-        int status;
+        struct usb_serial_port *port = tty->driver_data;
         struct moschip_port *mos7720_port = usb_get_serial_port_data(port);
+        int status;
 
         if (mos7720_port == NULL)
                 return;
@@ -780,16 +777,10 @@ static void mos7720_unthrottle(struct usb_serial_port *port)
 
         dbg("%s: Entering ..........", __func__);
 
-        tty = port->tty;
-        if (!tty) {
-                dbg("%s - no tty available", __func__);
-                return;
-        }
-
         /* if we are implementing XON/XOFF, send the start character */
         if (I_IXOFF(tty)) {
                 unsigned char start_char = START_CHAR(tty);
-                status = mos7720_write(port, &start_char, 1);
+                status = mos7720_write(tty, port, &start_char, 1);
                 if (status <= 0)
                         return;
         }
@@ -1011,12 +1002,12 @@ static int send_cmd_write_baud_rate(struct moschip_port *mos7720_port,
  *      This routine is called to set the UART on the device to match
  *      the specified new settings.
  */
-static void change_port_settings(struct moschip_port *mos7720_port,
+static void change_port_settings(struct tty_struct *tty,
+                                 struct moschip_port *mos7720_port,
                                  struct ktermios *old_termios)
 {
         struct usb_serial_port *port;
         struct usb_serial *serial;
-        struct tty_struct *tty;
         int baud;
         unsigned cflag;
         unsigned iflag;
@@ -1042,8 +1033,6 @@ static void change_port_settings(struct moschip_port *mos7720_port,
                 return;
         }
 
-        tty = mos7720_port->port->tty;
-
         dbg("%s: Entering ..........", __func__);
 
         lData = UART_LCR_WLEN8;
@@ -1198,14 +1187,13 @@ static void change_port_settings(struct moschip_port *mos7720_port,
  *      this function is called by the tty driver when it wants to change the
  *      termios structure.
  */
-static void mos7720_set_termios(struct usb_serial_port *port,
-                                struct ktermios *old_termios)
+static void mos7720_set_termios(struct tty_struct *tty,
+                struct usb_serial_port *port, struct ktermios *old_termios)
 {
         int status;
         unsigned int cflag;
         struct usb_serial *serial;
         struct moschip_port *mos7720_port;
-        struct tty_struct *tty;
 
         serial = port->serial;
 
@@ -1214,9 +1202,6 @@ static void mos7720_set_termios(struct usb_serial_port *port,
         if (mos7720_port == NULL)
                 return;
 
-        tty = port->tty;
-
-
         if (!mos7720_port->open) {
                 dbg("%s - port not opened", __func__);
                 return;
@@ -1237,7 +1222,7 @@ static void mos7720_set_termios(struct usb_serial_port *port,
         dbg("%s - port %d", __func__, port->number);
 
         /* change the port settings to the new ones specified */
-        change_port_settings(mos7720_port, old_termios);
+        change_port_settings(tty, mos7720_port, old_termios);
 
         if(!port->read_urb) {
                 dbg("%s","URB KILLED !!!!!\n");
@@ -1264,13 +1249,13 @@ static void mos7720_set_termios(struct usb_serial_port *port,
  *          transmit holding register is empty.  This functionality
  *          allows an RS485 driver to be written in user space.
  */
-static int get_lsr_info(struct moschip_port *mos7720_port,
+static int get_lsr_info(struct tty_struct *tty, struct moschip_port *mos7720_port,
                         unsigned int __user *value)
 {
         int count;
         unsigned int result = 0;
 
-        count = mos7720_chars_in_buffer(mos7720_port->port);
+        count = mos7720_chars_in_buffer(tty);
         if (count == 0) {
                 dbg("%s -- Empty", __func__);
                 result = TIOCSER_TEMT;
@@ -1290,7 +1275,7 @@ static int get_number_bytes_avail(struct moschip_port *mos7720_port,
                                   unsigned int __user *value)
 {
         unsigned int result = 0;
-        struct tty_struct *tty = mos7720_port->port->tty;
+        struct tty_struct *tty = mos7720_port->port->port.tty;
 
         if (!tty)
                 return -ENOIOCTLCMD;
@@ -1407,9 +1392,10 @@ static int get_serial_info(struct moschip_port *mos7720_port,
         return 0;
 }
 
-static int mos7720_ioctl(struct usb_serial_port *port, struct file *file,
+static int mos7720_ioctl(struct tty_struct *tty, struct file *file,
                          unsigned int cmd, unsigned long arg)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct moschip_port *mos7720_port;
         struct async_icount cnow;
         struct async_icount cprev;
@@ -1431,9 +1417,10 @@ static int mos7720_ioctl(struct usb_serial_port *port, struct file *file,
 
         case TIOCSERGETLSR:
                 dbg("%s (%d) TIOCSERGETLSR", __func__,  port->number);
-                return get_lsr_info(mos7720_port, (unsigned int __user *)arg);
+                return get_lsr_info(tty, mos7720_port, (unsigned int __user *)arg);
                 return 0;
 
+        /* FIXME: These should be using the mode methods */
         case TIOCMBIS:
         case TIOCMBIC:
         case TIOCMSET:
@@ -1452,10 +1439,6 @@ static int mos7720_ioctl(struct usb_serial_port *port, struct file *file,
                 return get_serial_info(mos7720_port,
                                        (struct serial_struct __user *)arg);
 
-        case TIOCSSERIAL:
-                dbg("%s (%d) TIOCSSERIAL", __func__,  port->number);
-                break;
-
         case TIOCMIWAIT:
                 dbg("%s (%d) TIOCMIWAIT", __func__,  port->number);
                 cprev = mos7720_port->icount;
diff --git a/drivers/usb/serial/mos7840.c b/drivers/usb/serial/mos7840.c
index 78f2f6db494d..2b1fded6619d 100644
--- a/drivers/usb/serial/mos7840.c
+++ b/drivers/usb/serial/mos7840.c
@@ -710,7 +710,7 @@ static void mos7840_bulk_in_callback(struct urb *urb)
         dbg("%s", "Entering ........... \n");
 
         if (urb->actual_length) {
-                tty = mos7840_port->port->tty;
+                tty = mos7840_port->port->port.tty;
                 if (tty) {
                         tty_buffer_request_room(tty, urb->actual_length);
                         tty_insert_flip_string(tty, data, urb->actual_length);
@@ -774,7 +774,7 @@ static void mos7840_bulk_out_data_callback(struct urb *urb)
 
         dbg("%s \n", "Entering .........");
 
-        tty = mos7840_port->port->tty;
+        tty = mos7840_port->port->port.tty;
 
         if (tty && mos7840_port->open)
                 tty_wakeup(tty);
@@ -804,7 +804,8 @@ static int mos7840_serial_probe(struct usb_serial *serial,
  *      Otherwise we return a negative error number.
  *****************************************************************************/
 
-static int mos7840_open(struct usb_serial_port *port, struct file *filp)
+static int mos7840_open(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 {
         int response;
         int j;
@@ -1008,8 +1009,8 @@ static int mos7840_open(struct usb_serial_port *port, struct file *filp)
          * the data through,otherwise it is scheduled, and with      *
          * high data rates (like with OHCI) data can get lost.       */
 
-        if (port->tty)
-                port->tty->low_latency = 1;
+        if (tty)
+                tty->low_latency = 1;
 /* Check to see if we've set up our endpoint info yet    *
      * (can't set it up in mos7840_startup as the structures *
      * were not set up at that time.)                        */
@@ -1104,11 +1105,12 @@ static int mos7840_open(struct usb_serial_port *port, struct file *filp)
  *      been written, but hasn't made it out the port yet)
  *      If successful, we return the number of bytes left to be written in the
  *      system,
- *      Otherwise we return a negative error number.
+ *      Otherwise we return zero.
  *****************************************************************************/
 
-static int mos7840_chars_in_buffer(struct usb_serial_port *port)
+static int mos7840_chars_in_buffer(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         int i;
         int chars = 0;
         unsigned long flags;
@@ -1118,21 +1120,19 @@ static int mos7840_chars_in_buffer(struct usb_serial_port *port)
 
         if (mos7840_port_paranoia_check(port, __func__)) {
                 dbg("%s", "Invalid port \n");
-                return -1;
+                return 0;
         }
 
         mos7840_port = mos7840_get_port_private(port);
         if (mos7840_port == NULL) {
                 dbg("%s \n", "mos7840_break:leaving ...........");
-                return -1;
+                return 0;
         }
 
         spin_lock_irqsave(&mos7840_port->pool_lock,flags);
-        for (i = 0; i < NUM_URBS; ++i) {
-                if (mos7840_port->busy[i]) {
+        for (i = 0; i < NUM_URBS; ++i)
+                if (mos7840_port->busy[i])
                         chars += URB_TRANSFER_BUFFER_SIZE;
-                }
-        }
         spin_unlock_irqrestore(&mos7840_port->pool_lock,flags);
         dbg("%s - returns %d", __func__, chars);
         return chars;
@@ -1149,7 +1149,8 @@ static int mos7840_chars_in_buffer(struct usb_serial_port *port)
  *              3. A timeout of 3 seconds without activity has expired
  *
  ************************************************************************/
-static void mos7840_block_until_tx_empty(struct moschip_port *mos7840_port)
+static void mos7840_block_until_tx_empty(struct tty_struct *tty,
+                                struct moschip_port *mos7840_port)
 {
         int timeout = HZ / 10;
         int wait = 30;
@@ -1157,7 +1158,7 @@ static void mos7840_block_until_tx_empty(struct moschip_port *mos7840_port)
 
         while (1) {
 
-                count = mos7840_chars_in_buffer(mos7840_port->port);
+                count = mos7840_chars_in_buffer(tty);
 
                 /* Check for Buffer status */
                 if (count <= 0) {
@@ -1185,7 +1186,8 @@ static void mos7840_block_until_tx_empty(struct moschip_port *mos7840_port)
  *      this function is called by the tty driver when a port is closed
  *****************************************************************************/
 
-static void mos7840_close(struct usb_serial_port *port, struct file *filp)
+static void mos7840_close(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 {
         struct usb_serial *serial;
         struct moschip_port *mos7840_port;
@@ -1226,20 +1228,17 @@ static void mos7840_close(struct usb_serial_port *port, struct file *filp)
                 }
         }
 
-        if (serial->dev) {
+        if (serial->dev)
                 /* flush and block until tx is empty */
-                mos7840_block_until_tx_empty(mos7840_port);
-        }
+                mos7840_block_until_tx_empty(tty, mos7840_port);
 
         /* While closing port, shutdown all bulk read, write  *
          * and interrupt read if they exists                  */
         if (serial->dev) {
-
                 if (mos7840_port->write_urb) {
                         dbg("%s", "Shutdown bulk write\n");
                         usb_kill_urb(mos7840_port->write_urb);
                 }
-
                 if (mos7840_port->read_urb) {
                         dbg("%s", "Shutdown bulk read\n");
                         usb_kill_urb(mos7840_port->read_urb);
@@ -1247,11 +1246,10 @@ static void mos7840_close(struct usb_serial_port *port, struct file *filp)
                 if ((&mos7840_port->control_urb)) {
                         dbg("%s", "Shutdown control read\n");
                         //      usb_kill_urb (mos7840_port->control_urb);
-
                 }
         }
-//              if(mos7840_port->ctrl_buf != NULL)
-//                      kfree(mos7840_port->ctrl_buf);
+//      if(mos7840_port->ctrl_buf != NULL)
+//              kfree(mos7840_port->ctrl_buf);
         port0->open_ports--;
         dbg("mos7840_num_open_ports in close%d:in port%d\n",
             port0->open_ports, port->number);
@@ -1293,15 +1291,15 @@ static void mos7840_close(struct usb_serial_port *port, struct file *filp)
  *
  ************************************************************************/
 
-static void mos7840_block_until_chase_response(struct moschip_port
-                                               *mos7840_port)
+static void mos7840_block_until_chase_response(struct tty_struct *tty,
+                                        struct moschip_port *mos7840_port)
 {
         int timeout = 1 * HZ;
         int wait = 10;
         int count;
 
         while (1) {
-                count = mos7840_chars_in_buffer(mos7840_port->port);
+                count = mos7840_chars_in_buffer(tty);
 
                 /* Check for Buffer status */
                 if (count <= 0) {
@@ -1328,8 +1326,9 @@ static void mos7840_block_until_chase_response(struct moschip_port
  * mos7840_break
  *      this function sends a break to the port
  *****************************************************************************/
-static void mos7840_break(struct usb_serial_port *port, int break_state)
+static void mos7840_break(struct tty_struct *tty, int break_state)
 {
+        struct usb_serial_port *port = tty->driver_data;
         unsigned char data;
         struct usb_serial *serial;
         struct moschip_port *mos7840_port;
@@ -1354,17 +1353,14 @@ static void mos7840_break(struct usb_serial_port *port, int break_state)
                 return;
         }
 
-        if (serial->dev) {
-
+        if (serial->dev)
                 /* flush and block until tx is empty */
-                mos7840_block_until_chase_response(mos7840_port);
-        }
+                mos7840_block_until_chase_response(tty, mos7840_port);
 
-        if (break_state == -1) {
+        if (break_state == -1)
                 data = mos7840_port->shadowLCR | LCR_SET_BREAK;
-        } else {
+        else
                 data = mos7840_port->shadowLCR & ~LCR_SET_BREAK;
-        }
 
         mos7840_port->shadowLCR = data;
         dbg("mcs7840_break mos7840_port->shadowLCR is %x\n",
@@ -1383,8 +1379,9 @@ static void mos7840_break(struct usb_serial_port *port, int break_state)
  *      Otherwise we return a negative error number.
  *****************************************************************************/
 
-static int mos7840_write_room(struct usb_serial_port *port)
+static int mos7840_write_room(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         int i;
         int room = 0;
         unsigned long flags;
@@ -1426,7 +1423,7 @@ static int mos7840_write_room(struct usb_serial_port *port)
  *      return a negative error number.
  *****************************************************************************/
 
-static int mos7840_write(struct usb_serial_port *port,
+static int mos7840_write(struct tty_struct *tty, struct usb_serial_port *port,
                          const unsigned char *data, int count)
 {
         int status;
@@ -1555,8 +1552,7 @@ static int mos7840_write(struct usb_serial_port *port,
         mos7840_port->icount.tx += transfer_size;
         smp_wmb();
         dbg("mos7840_port->icount.tx is %d:\n", mos7840_port->icount.tx);
-      exit:
-
+exit:
         return bytes_sent;
 
 }
@@ -1567,10 +1563,10 @@ static int mos7840_write(struct usb_serial_port *port,
  *      being read from the port.
  *****************************************************************************/
 
-static void mos7840_throttle(struct usb_serial_port *port)
+static void mos7840_throttle(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct moschip_port *mos7840_port;
-        struct tty_struct *tty;
         int status;
 
         if (mos7840_port_paranoia_check(port, __func__)) {
@@ -1592,32 +1588,21 @@ static void mos7840_throttle(struct usb_serial_port *port)
 
         dbg("%s", "Entering .......... \n");
 
-        tty = port->tty;
-        if (!tty) {
-                dbg("%s - no tty available", __func__);
-                return;
-        }
-
         /* if we are implementing XON/XOFF, send the stop character */
         if (I_IXOFF(tty)) {
                 unsigned char stop_char = STOP_CHAR(tty);
-                status = mos7840_write(port, &stop_char, 1);
-                if (status <= 0) {
+                status = mos7840_write(tty, port, &stop_char, 1);
+                if (status <= 0)
                         return;
-                }
         }
-
         /* if we are implementing RTS/CTS, toggle that line */
         if (tty->termios->c_cflag & CRTSCTS) {
                 mos7840_port->shadowMCR &= ~MCR_RTS;
                 status = 0;
-                status =
-                    mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER,
+                status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER,
                                          mos7840_port->shadowMCR);
-
-                if (status < 0) {
+                if (status < 0)
                         return;
-                }
         }
 
         return;
@@ -1628,9 +1613,9 @@ static void mos7840_throttle(struct usb_serial_port *port)
  *      this function is called by the tty driver when it wants to resume the data
  *      being read from the port (called after SerialThrottle is called)
  *****************************************************************************/
-static void mos7840_unthrottle(struct usb_serial_port *port)
+static void mos7840_unthrottle(struct tty_struct *tty)
 {
-        struct tty_struct *tty;
+        struct usb_serial_port *port = tty->driver_data;
         int status;
         struct moschip_port *mos7840_port = mos7840_get_port_private(port);
 
@@ -1649,38 +1634,28 @@ static void mos7840_unthrottle(struct usb_serial_port *port)
 
         dbg("%s", "Entering .......... \n");
 
-        tty = port->tty;
-        if (!tty) {
-                dbg("%s - no tty available", __func__);
-                return;
-        }
-
         /* if we are implementing XON/XOFF, send the start character */
         if (I_IXOFF(tty)) {
                 unsigned char start_char = START_CHAR(tty);
-                status = mos7840_write(port, &start_char, 1);
-                if (status <= 0) {
+                status = mos7840_write(tty, port, &start_char, 1);
+                if (status <= 0)
                         return;
-                }
         }
 
         /* if we are implementing RTS/CTS, toggle that line */
         if (tty->termios->c_cflag & CRTSCTS) {
                 mos7840_port->shadowMCR |= MCR_RTS;
                 status = 0;
-                status =
-                    mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER,
+                status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER,
                                          mos7840_port->shadowMCR);
-                if (status < 0) {
+                if (status < 0)
                         return;
-                }
         }
-
-        return;
 }
 
-static int mos7840_tiocmget(struct usb_serial_port *port, struct file *file)
+static int mos7840_tiocmget(struct tty_struct *tty, struct file *file)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct moschip_port *mos7840_port;
         unsigned int result;
         __u16 msr;
@@ -1708,9 +1683,10 @@ static int mos7840_tiocmget(struct usb_serial_port *port, struct file *file)
         return result;
 }
 
-static int mos7840_tiocmset(struct usb_serial_port *port, struct file *file,
+static int mos7840_tiocmset(struct tty_struct *tty, struct file *file,
                             unsigned int set, unsigned int clear)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct moschip_port *mos7840_port;
         unsigned int mcr;
         int status;
@@ -1949,10 +1925,9 @@ static int mos7840_send_cmd_write_baud_rate(struct moschip_port *mos7840_port,
  *      the specified new settings.
  *****************************************************************************/
 
-static void mos7840_change_port_settings(struct moschip_port *mos7840_port,
-                                         struct ktermios *old_termios)
+static void mos7840_change_port_settings(struct tty_struct *tty,
+        struct moschip_port *mos7840_port, struct ktermios *old_termios)
 {
-        struct tty_struct *tty;
         int baud;
         unsigned cflag;
         unsigned iflag;
@@ -1988,8 +1963,6 @@ static void mos7840_change_port_settings(struct moschip_port *mos7840_port,
                 return;
         }
 
-        tty = mos7840_port->port->tty;
-
         dbg("%s", "Entering .......... \n");
 
         lData = LCR_BITS_8;
@@ -2131,14 +2104,14 @@ static void mos7840_change_port_settings(struct moschip_port *mos7840_port,
  *      the termios structure
  *****************************************************************************/
 
-static void mos7840_set_termios(struct usb_serial_port *port,
+static void mos7840_set_termios(struct tty_struct *tty,
+                                struct usb_serial_port *port,
                                 struct ktermios *old_termios)
 {
         int status;
         unsigned int cflag;
         struct usb_serial *serial;
         struct moschip_port *mos7840_port;
-        struct tty_struct *tty;
         dbg("mos7840_set_termios: START\n");
         if (mos7840_port_paranoia_check(port, __func__)) {
                 dbg("%s", "Invalid port \n");
@@ -2157,8 +2130,6 @@ static void mos7840_set_termios(struct usb_serial_port *port,
         if (mos7840_port == NULL)
                 return;
 
-        tty = port->tty;
-
         if (!mos7840_port->open) {
                 dbg("%s - port not opened", __func__);
                 return;
@@ -2176,7 +2147,7 @@ static void mos7840_set_termios(struct usb_serial_port *port,
 
         /* change the port settings to the new ones specified */
 
-        mos7840_change_port_settings(mos7840_port, old_termios);
+        mos7840_change_port_settings(tty, mos7840_port, old_termios);
 
         if (!mos7840_port->read_urb) {
                 dbg("%s", "URB KILLED !!!!!\n");
@@ -2205,13 +2176,13 @@ static void mos7840_set_termios(struct usb_serial_port *port,
  *          allows an RS485 driver to be written in user space.
  *****************************************************************************/
 
-static int mos7840_get_lsr_info(struct moschip_port *mos7840_port,
+static int mos7840_get_lsr_info(struct tty_struct *tty,
                                 unsigned int __user *value)
 {
         int count;
         unsigned int result = 0;
 
-        count = mos7840_chars_in_buffer(mos7840_port->port);
+        count = mos7840_chars_in_buffer(tty);
         if (count == 0) {
                 dbg("%s -- Empty", __func__);
                 result = TIOCSER_TEMT;
@@ -2227,6 +2198,8 @@ static int mos7840_get_lsr_info(struct moschip_port *mos7840_port,
  *      function to set modem info
  *****************************************************************************/
 
+/* FIXME: Should be using the model control hooks */
+
 static int mos7840_set_modem_info(struct moschip_port *mos7840_port,
                                   unsigned int cmd, unsigned int __user *value)
 {
@@ -2304,9 +2277,8 @@ static int mos7840_get_modem_info(struct moschip_port *mos7840_port,
         __u16 msr;
         unsigned int mcr = mos7840_port->shadowMCR;
         int status = 0;
-        status =
-            mos7840_get_uart_reg(mos7840_port->port, MODEM_STATUS_REGISTER,
-                                 &msr);
+        status = mos7840_get_uart_reg(mos7840_port->port,
+                                                MODEM_STATUS_REGISTER, &msr);
         result = ((mcr & MCR_DTR) ? TIOCM_DTR : 0)      /* 0x002 */
             |((mcr & MCR_RTS) ? TIOCM_RTS : 0)  /* 0x004 */
             |((msr & MOS7840_MSR_CTS) ? TIOCM_CTS : 0)  /* 0x020 */
@@ -2359,12 +2331,12 @@ static int mos7840_get_serial_info(struct moschip_port *mos7840_port,
  *      this function handles any ioctl calls to the driver
  *****************************************************************************/
 
-static int mos7840_ioctl(struct usb_serial_port *port, struct file *file,
+static int mos7840_ioctl(struct tty_struct *tty, struct file *file,
                          unsigned int cmd, unsigned long arg)
 {
+        struct usb_serial_port *port = tty->driver_data;
         void __user *argp = (void __user *)arg;
         struct moschip_port *mos7840_port;
-        struct tty_struct *tty;
 
         struct async_icount cnow;
         struct async_icount cprev;
@@ -2381,8 +2353,6 @@ static int mos7840_ioctl(struct usb_serial_port *port, struct file *file,
         if (mos7840_port == NULL)
                 return -1;
 
-        tty = mos7840_port->port->tty;
-
         dbg("%s - port %d, cmd = 0x%x", __func__, port->number, cmd);
 
         switch (cmd) {
@@ -2390,9 +2360,10 @@ static int mos7840_ioctl(struct usb_serial_port *port, struct file *file,
 
         case TIOCSERGETLSR:
                 dbg("%s (%d) TIOCSERGETLSR", __func__, port->number);
-                return mos7840_get_lsr_info(mos7840_port, argp);
+                return mos7840_get_lsr_info(tty, argp);
                 return 0;
 
+        /* FIXME: use the modem hooks and remove this */
         case TIOCMBIS:
         case TIOCMBIC:
         case TIOCMSET:
@@ -2463,13 +2434,9 @@ static int mos7840_ioctl(struct usb_serial_port *port, struct file *file,
                 if (copy_to_user(argp, &icount, sizeof(icount)))
                         return -EFAULT;
                 return 0;
-
-        case TIOCEXBAUD:
-                return 0;
         default:
                 break;
         }
-
         return -ENOIOCTLCMD;
 }
 
diff --git a/drivers/usb/serial/navman.c b/drivers/usb/serial/navman.c
index 43c8894353bf..d6736531a0fa 100644
--- a/drivers/usb/serial/navman.c
+++ b/drivers/usb/serial/navman.c
@@ -64,7 +64,7 @@ static void navman_read_int_callback(struct urb *urb)
         usb_serial_debug_data(debug, &port->dev, __func__,
                               urb->actual_length, data);
 
-        tty = port->tty;
+        tty = port->port.tty;
         if (tty && urb->actual_length) {
                 tty_buffer_request_room(tty, urb->actual_length);
                 tty_insert_flip_string(tty, data, urb->actual_length);
@@ -79,7 +79,8 @@ exit:
                         __func__, result);
 }
 
-static int navman_open(struct usb_serial_port *port, struct file *filp)
+static int navman_open(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 {
         int result = 0;
 
@@ -96,14 +97,15 @@ static int navman_open(struct usb_serial_port *port, struct file *filp)
         return result;
 }
 
-static void navman_close(struct usb_serial_port *port, struct file *filp)
+static void navman_close(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 {
         dbg("%s - port %d", __func__, port->number);
 
         usb_kill_urb(port->interrupt_in_urb);
 }
 
-static int navman_write(struct usb_serial_port *port,
+static int navman_write(struct tty_struct *tty, struct usb_serial_port *port,
                         const unsigned char *buf, int count)
 {
         dbg("%s - port %d", __func__, port->number);
diff --git a/drivers/usb/serial/omninet.c b/drivers/usb/serial/omninet.c
index 7b7422f49478..5a2d045562f0 100644
--- a/drivers/usb/serial/omninet.c
+++ b/drivers/usb/serial/omninet.c
@@ -61,12 +61,12 @@ static int debug;
 #define BT_IGNITIONPRO_ID       0x2000  /* This one seems to be a re-branded ZyXEL device */
 
 /* function prototypes */
-static int  omninet_open                (struct usb_serial_port *port, struct file *filp);
-static void omninet_close               (struct usb_serial_port *port, struct file *filp);
+static int  omninet_open                (struct tty_struct *tty, struct usb_serial_port *port, struct file *filp);
+static void omninet_close               (struct tty_struct *tty, struct usb_serial_port *port, struct file *filp);
 static void omninet_read_bulk_callback  (struct urb *urb);
 static void omninet_write_bulk_callback (struct urb *urb);
-static int  omninet_write               (struct usb_serial_port *port, const unsigned char *buf, int count);
-static int  omninet_write_room          (struct usb_serial_port *port);
+static int  omninet_write               (struct tty_struct *tty, struct usb_serial_port *port, const unsigned char *buf, int count);
+static int  omninet_write_room          (struct tty_struct *tty);
 static void omninet_shutdown            (struct usb_serial *serial);
 static int omninet_attach               (struct usb_serial *serial);
 
@@ -157,7 +157,8 @@ static int omninet_attach (struct usb_serial *serial)
         return 0;
 }
 
-static int omninet_open (struct usb_serial_port *port, struct file *filp)
+static int omninet_open(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 {
         struct usb_serial       *serial = port->serial;
         struct usb_serial_port  *wport;
@@ -166,7 +167,7 @@ static int omninet_open (struct usb_serial_port *port, struct file *filp)
         dbg("%s - port %d", __func__, port->number);
 
         wport = serial->port[1];
-        wport->tty = port->tty;
+        wport->port.tty = tty;          /* FIXME */
 
         /* Start reading from the device */
         usb_fill_bulk_urb(port->read_urb, serial->dev, 
@@ -181,7 +182,8 @@ static int omninet_open (struct usb_serial_port *port, struct file *filp)
         return result;
 }
 
-static void omninet_close (struct usb_serial_port *port, struct file * filp)
+static void omninet_close(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file * filp)
 {
         dbg("%s - port %d", __func__, port->number);
         usb_kill_urb(port->read_urb);
@@ -221,9 +223,9 @@ static void omninet_read_bulk_callback (struct urb *urb)
 
         if (urb->actual_length && header->oh_len) {
                 for (i = 0; i < header->oh_len; i++) {
-                         tty_insert_flip_char(port->tty, data[OMNINET_DATAOFFSET + i], 0);
+                         tty_insert_flip_char(port->port.tty, data[OMNINET_DATAOFFSET + i], 0);
                 }
-                tty_flip_buffer_push(port->tty);
+                tty_flip_buffer_push(port->port.tty);
         }
 
         /* Continue trying to always read  */
@@ -238,7 +240,8 @@ static void omninet_read_bulk_callback (struct urb *urb)
         return;
 }
 
-static int omninet_write (struct usb_serial_port *port, const unsigned char *buf, int count)
+static int omninet_write(struct tty_struct *tty, struct usb_serial_port *port,
+                                        const unsigned char *buf, int count)
 {
         struct usb_serial       *serial = port->serial;
         struct usb_serial_port  *wport  = serial->port[1];
@@ -290,8 +293,9 @@ static int omninet_write (struct usb_serial_port *port, const unsigned char *buf
 }
 
 
-static int omninet_write_room (struct usb_serial_port *port)
+static int omninet_write_room (struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct usb_serial       *serial = port->serial;
         struct usb_serial_port  *wport  = serial->port[1];
 
diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
index 1e936a1cbe0b..4350990abf14 100644
--- a/drivers/usb/serial/option.c
+++ b/drivers/usb/serial/option.c
@@ -43,29 +43,23 @@
 #include <linux/usb/serial.h>
 
 /* Function prototypes */
-static int  option_open(struct usb_serial_port *port, struct file *filp);
-static void option_close(struct usb_serial_port *port, struct file *filp);
+static int  option_open(struct tty_struct *tty, struct usb_serial_port *port, struct file *filp);
+static void option_close(struct tty_struct *tty, struct usb_serial_port *port, struct file *filp);
 static int  option_startup(struct usb_serial *serial);
 static void option_shutdown(struct usb_serial *serial);
-static void option_rx_throttle(struct usb_serial_port *port);
-static void option_rx_unthrottle(struct usb_serial_port *port);
-static int  option_write_room(struct usb_serial_port *port);
+static int  option_write_room(struct tty_struct *tty);
 
 static void option_instat_callback(struct urb *urb);
 
-static int option_write(struct usb_serial_port *port,
+static int option_write(struct tty_struct *tty, struct usb_serial_port *port,
                         const unsigned char *buf, int count);
-
-static int  option_chars_in_buffer(struct usb_serial_port *port);
-static int  option_ioctl(struct usb_serial_port *port, struct file *file,
-                        unsigned int cmd, unsigned long arg);
-static void option_set_termios(struct usb_serial_port *port,
-                                struct ktermios *old);
-static void option_break_ctl(struct usb_serial_port *port, int break_state);
-static int  option_tiocmget(struct usb_serial_port *port, struct file *file);
-static int  option_tiocmset(struct usb_serial_port *port, struct file *file,
+static int  option_chars_in_buffer(struct tty_struct *tty);
+static void option_set_termios(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct ktermios *old);
+static int  option_tiocmget(struct tty_struct *tty, struct file *file);
+static int  option_tiocmset(struct tty_struct *tty, struct file *file,
                                 unsigned int set, unsigned int clear);
-static int  option_send_setup(struct usb_serial_port *port);
+static int  option_send_setup(struct tty_struct *tty, struct usb_serial_port *port);
 
 /* Vendor and product IDs */
 #define OPTION_VENDOR_ID                        0x0AF0
@@ -342,11 +336,7 @@ static struct usb_serial_driver option_1port_device = {
         .write             = option_write,
         .write_room        = option_write_room,
         .chars_in_buffer   = option_chars_in_buffer,
-        .throttle          = option_rx_throttle,
-        .unthrottle        = option_rx_unthrottle,
-        .ioctl             = option_ioctl,
         .set_termios       = option_set_termios,
-        .break_ctl         = option_break_ctl,
         .tiocmget          = option_tiocmget,
         .tiocmset          = option_tiocmset,
         .attach            = option_startup,
@@ -417,33 +407,18 @@ static void __exit option_exit(void)
 module_init(option_init);
 module_exit(option_exit);
 
-static void option_rx_throttle(struct usb_serial_port *port)
-{
-        dbg("%s", __func__);
-}
-
-static void option_rx_unthrottle(struct usb_serial_port *port)
-{
-        dbg("%s", __func__);
-}
-
-static void option_break_ctl(struct usb_serial_port *port, int break_state)
-{
-        /* Unfortunately, I don't know how to send a break */
-        dbg("%s", __func__);
-}
-
-static void option_set_termios(struct usb_serial_port *port,
-                        struct ktermios *old_termios)
+static void option_set_termios(struct tty_struct *tty,
+                struct usb_serial_port *port, struct ktermios *old_termios)
 {
         dbg("%s", __func__);
         /* Doesn't support option setting */
-        tty_termios_copy_hw(port->tty->termios, old_termios);
-        option_send_setup(port);
+        tty_termios_copy_hw(tty->termios, old_termios);
+        option_send_setup(tty, port);
 }
 
-static int option_tiocmget(struct usb_serial_port *port, struct file *file)
+static int option_tiocmget(struct tty_struct *tty, struct file *file)
 {
+        struct usb_serial_port *port = tty->driver_data;
         unsigned int value;
         struct option_port_private *portdata;
 
@@ -459,9 +434,10 @@ static int option_tiocmget(struct usb_serial_port *port, struct file *file)
         return value;
 }
 
-static int option_tiocmset(struct usb_serial_port *port, struct file *file,
+static int option_tiocmset(struct tty_struct *tty, struct file *file,
                         unsigned int set, unsigned int clear)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct option_port_private *portdata;
 
         portdata = usb_get_serial_port_data(port);
@@ -476,17 +452,11 @@ static int option_tiocmset(struct usb_serial_port *port, struct file *file,
                 portdata->rts_state = 0;
         if (clear & TIOCM_DTR)
                 portdata->dtr_state = 0;
-        return option_send_setup(port);
-}
-
-static int option_ioctl(struct usb_serial_port *port, struct file *file,
-                        unsigned int cmd, unsigned long arg)
-{
-        return -ENOIOCTLCMD;
+        return option_send_setup(tty, port);
 }
 
 /* Write */
-static int option_write(struct usb_serial_port *port,
+static int option_write(struct tty_struct *tty, struct usb_serial_port *port,
                         const unsigned char *buf, int count)
 {
         struct option_port_private *portdata;
@@ -562,7 +532,7 @@ static void option_indat_callback(struct urb *urb)
                 dbg("%s: nonzero status: %d on endpoint %02x.",
                     __func__, status, endpoint);
         } else {
-                tty = port->tty;
+                tty = port->port.tty;
                 if (urb->actual_length) {
                         tty_buffer_request_room(tty, urb->actual_length);
                         tty_insert_flip_string(tty, data, urb->actual_length);
@@ -572,7 +542,7 @@ static void option_indat_callback(struct urb *urb)
                 }
 
                 /* Resubmit urb so we continue receiving */
-                if (port->open_count && status != -ESHUTDOWN) {
+                if (port->port.count && status != -ESHUTDOWN) {
                         err = usb_submit_urb(urb, GFP_ATOMIC);
                         if (err)
                                 printk(KERN_ERR "%s: resubmit read urb failed. "
@@ -638,9 +608,9 @@ static void option_instat_callback(struct urb *urb)
                         portdata->dsr_state = ((signals & 0x02) ? 1 : 0);
                         portdata->ri_state = ((signals & 0x08) ? 1 : 0);
 
-                        if (port->tty && !C_CLOCAL(port->tty) &&
+                        if (port->port.tty && !C_CLOCAL(port->port.tty) &&
                                         old_dcd_state && !portdata->dcd_state)
-                                tty_hangup(port->tty);
+                                tty_hangup(port->port.tty);
                 } else {
                         dbg("%s: type %x req %x", __func__,
                                 req_pkt->bRequestType,req_pkt->bRequest);
@@ -658,8 +628,9 @@ static void option_instat_callback(struct urb *urb)
         }
 }
 
-static int option_write_room(struct usb_serial_port *port)
+static int option_write_room(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct option_port_private *portdata;
         int i;
         int data_len = 0;
@@ -678,8 +649,9 @@ static int option_write_room(struct usb_serial_port *port)
         return data_len;
 }
 
-static int option_chars_in_buffer(struct usb_serial_port *port)
+static int option_chars_in_buffer(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct option_port_private *portdata;
         int i;
         int data_len = 0;
@@ -698,7 +670,8 @@ static int option_chars_in_buffer(struct usb_serial_port *port)
         return data_len;
 }
 
-static int option_open(struct usb_serial_port *port, struct file *filp)
+static int option_open(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 {
         struct option_port_private *portdata;
         struct usb_serial *serial = port->serial;
@@ -748,14 +721,16 @@ static int option_open(struct usb_serial_port *port, struct file *filp)
                                 usb_pipeout(urb->pipe), 0); */
         }
 
-        port->tty->low_latency = 1;
+        if (tty)
+                tty->low_latency = 1;
 
-        option_send_setup(port);
+        option_send_setup(tty, port);
 
         return (0);
 }
 
-static void option_close(struct usb_serial_port *port, struct file *filp)
+static void option_close(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 {
         int i;
         struct usb_serial *serial = port->serial;
@@ -770,7 +745,7 @@ static void option_close(struct usb_serial_port *port, struct file *filp)
         if (serial->dev) {
                 mutex_lock(&serial->disc_mutex);
                 if (!serial->disconnected)
-                        option_send_setup(port);
+                        option_send_setup(tty, port);
                 mutex_unlock(&serial->disc_mutex);
 
                 /* Stop reading/writing urbs */
@@ -779,7 +754,7 @@ static void option_close(struct usb_serial_port *port, struct file *filp)
                 for (i = 0; i < N_OUT_URB; i++)
                         usb_kill_urb(portdata->out_urbs[i]);
         }
-        port->tty = NULL;
+        port->port.tty = NULL;  /* FIXME */
 }
 
 /* Helper functions used by option_setup_urbs */
@@ -841,7 +816,8 @@ static void option_setup_urbs(struct usb_serial *serial)
  * This is exactly the same as SET_CONTROL_LINE_STATE from the PSTN
  * CDC.
 */
-static int option_send_setup(struct usb_serial_port *port)
+static int option_send_setup(struct tty_struct *tty,
+                                                struct usb_serial_port *port)
 {
         struct usb_serial *serial = port->serial;
         struct option_port_private *portdata;
@@ -850,7 +826,7 @@ static int option_send_setup(struct usb_serial_port *port)
 
         portdata = usb_get_serial_port_data(port);
 
-        if (port->tty) {
+        if (tty) {
                 int val = 0;
                 if (portdata->dtr_state)
                         val |= 0x01;
@@ -861,7 +837,6 @@ static int option_send_setup(struct usb_serial_port *port)
                                 usb_rcvctrlpipe(serial->dev, 0),
                                 0x22,0x21,val,ifNum,NULL,0,USB_CTRL_SET_TIMEOUT);
         }
-
         return 0;
 }
 
diff --git a/drivers/usb/serial/oti6858.c b/drivers/usb/serial/oti6858.c
index a9625c180dc3..069d276a5276 100644
--- a/drivers/usb/serial/oti6858.c
+++ b/drivers/usb/serial/oti6858.c
@@ -140,22 +140,23 @@ struct oti6858_control_pkt {
           && ((a)->frame_fmt == (priv)->pending_setup.frame_fmt) )
 
 /* function prototypes */
-static int oti6858_open(struct usb_serial_port *port, struct file *filp);
-static void oti6858_close(struct usb_serial_port *port, struct file *filp);
-static void oti6858_set_termios(struct usb_serial_port *port,
-                                struct ktermios *old);
-static int oti6858_ioctl(struct usb_serial_port *port, struct file *file,
+static int oti6858_open(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp);
+static void oti6858_close(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp);
+static void oti6858_set_termios(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct ktermios *old);
+static int oti6858_ioctl(struct tty_struct *tty, struct file *file,
                         unsigned int cmd, unsigned long arg);
 static void oti6858_read_int_callback(struct urb *urb);
 static void oti6858_read_bulk_callback(struct urb *urb);
 static void oti6858_write_bulk_callback(struct urb *urb);
-static int oti6858_write(struct usb_serial_port *port,
+static int oti6858_write(struct tty_struct *tty, struct usb_serial_port *port,
                         const unsigned char *buf, int count);
-static int oti6858_write_room(struct usb_serial_port *port);
-static void oti6858_break_ctl(struct usb_serial_port *port, int break_state);
-static int oti6858_chars_in_buffer(struct usb_serial_port *port);
-static int oti6858_tiocmget(struct usb_serial_port *port, struct file *file);
-static int oti6858_tiocmset(struct usb_serial_port *port, struct file *file,
+static int oti6858_write_room(struct tty_struct *tty);
+static int oti6858_chars_in_buffer(struct tty_struct *tty);
+static int oti6858_tiocmget(struct tty_struct *tty, struct file *file);
+static int oti6858_tiocmset(struct tty_struct *tty, struct file *file,
                                 unsigned int set, unsigned int clear);
 static int oti6858_startup(struct usb_serial *serial);
 static void oti6858_shutdown(struct usb_serial *serial);
@@ -184,7 +185,6 @@ static struct usb_serial_driver oti6858_device = {
         .close =                oti6858_close,
         .write =                oti6858_write,
         .ioctl =                oti6858_ioctl,
-        .break_ctl =            oti6858_break_ctl,
         .set_termios =          oti6858_set_termios,
         .tiocmget =             oti6858_tiocmget,
         .tiocmset =             oti6858_tiocmset,
@@ -395,7 +395,7 @@ static int oti6858_startup(struct usb_serial *serial)
         return -ENOMEM;
 }
 
-static int oti6858_write(struct usb_serial_port *port,
+static int oti6858_write(struct tty_struct *tty, struct usb_serial_port *port,
                         const unsigned char *buf, int count)
 {
         struct oti6858_private *priv = usb_get_serial_port_data(port);
@@ -413,8 +413,9 @@ static int oti6858_write(struct usb_serial_port *port,
         return count;
 }
 
-static int oti6858_write_room(struct usb_serial_port *port)
+static int oti6858_write_room(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct oti6858_private *priv = usb_get_serial_port_data(port);
         int room = 0;
         unsigned long flags;
@@ -428,8 +429,9 @@ static int oti6858_write_room(struct usb_serial_port *port)
         return room;
 }
 
-static int oti6858_chars_in_buffer(struct usb_serial_port *port)
+static int oti6858_chars_in_buffer(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct oti6858_private *priv = usb_get_serial_port_data(port);
         int chars = 0;
         unsigned long flags;
@@ -443,8 +445,8 @@ static int oti6858_chars_in_buffer(struct usb_serial_port *port)
         return chars;
 }
 
-static void oti6858_set_termios(struct usb_serial_port *port,
-                                struct ktermios *old_termios)
+static void oti6858_set_termios(struct tty_struct *tty,
+                struct usb_serial_port *port, struct ktermios *old_termios)
 {
         struct oti6858_private *priv = usb_get_serial_port_data(port);
         unsigned long flags;
@@ -455,22 +457,22 @@ static void oti6858_set_termios(struct usb_serial_port *port,
 
         dbg("%s(port = %d)", __func__, port->number);
 
-        if (!port->tty || !port->tty->termios) {
+        if (!tty) {
                 dbg("%s(): no tty structures", __func__);
                 return;
         }
 
         spin_lock_irqsave(&priv->lock, flags);
         if (!priv->flags.termios_initialized) {
-                *(port->tty->termios) = tty_std_termios;
-                port->tty->termios->c_cflag = B38400 | CS8 | CREAD | HUPCL | CLOCAL;
+                *(tty->termios) = tty_std_termios;
+                tty->termios->c_cflag = B38400 | CS8 | CREAD | HUPCL | CLOCAL;
+                tty->termios->c_ispeed = 38400;
+                tty->termios->c_ospeed = 38400;
                 priv->flags.termios_initialized = 1;
-                port->tty->termios->c_ispeed = 38400;
-                port->tty->termios->c_ospeed = 38400;
         }
         spin_unlock_irqrestore(&priv->lock, flags);
 
-        cflag = port->tty->termios->c_cflag;
+        cflag = tty->termios->c_cflag;
 
         spin_lock_irqsave(&priv->lock, flags);
         divisor = priv->pending_setup.divisor;
@@ -500,7 +502,7 @@ static void oti6858_set_termios(struct usb_serial_port *port,
          * guarantee that any other baud rate will work (especially
          * the higher ones)
          */
-        br = tty_get_baud_rate(port->tty);
+        br = tty_get_baud_rate(tty);
         if (br == 0) {
                 divisor = 0;
         } else {
@@ -511,7 +513,7 @@ static void oti6858_set_termios(struct usb_serial_port *port,
                 new_divisor = (96000000 + 8 * br) / (16 * br);
                 real_br = 96000000 / (16 * new_divisor);
                 divisor = cpu_to_le16(new_divisor);
-                tty_encode_baud_rate(port->tty, real_br, real_br);
+                tty_encode_baud_rate(tty, real_br, real_br);
         }
 
         frame_fmt &= ~FMT_STOP_BITS_MASK;
@@ -564,7 +566,8 @@ static void oti6858_set_termios(struct usb_serial_port *port,
         spin_unlock_irqrestore(&priv->lock, flags);
 }
 
-static int oti6858_open(struct usb_serial_port *port, struct file *filp)
+static int oti6858_open(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 {
         struct oti6858_private *priv = usb_get_serial_port_data(port);
         struct ktermios tmp_termios;
@@ -578,7 +581,7 @@ static int oti6858_open(struct usb_serial_port *port, struct file *filp)
         usb_clear_halt(serial->dev, port->write_urb->pipe);
         usb_clear_halt(serial->dev, port->read_urb->pipe);
 
-        if (port->open_count != 1)
+        if (port->port.count != 1)
                 return 0;
 
         if ((buf = kmalloc(OTI6858_CTRL_PKT_SIZE, GFP_KERNEL)) == NULL) {
@@ -617,18 +620,19 @@ static int oti6858_open(struct usb_serial_port *port, struct file *filp)
         if (result != 0) {
                 dev_err(&port->dev, "%s(): usb_submit_urb() failed"
                                " with error %d\n", __func__, result);
-                oti6858_close(port, NULL);
+                oti6858_close(tty, port, NULL);
                 return -EPROTO;
         }
 
         /* setup termios */
-        if (port->tty)
-                oti6858_set_termios(port, &tmp_termios);
+        if (tty)
+                oti6858_set_termios(tty, port, &tmp_termios);
 
         return 0;
 }
 
-static void oti6858_close(struct usb_serial_port *port, struct file *filp)
+static void oti6858_close(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 {
         struct oti6858_private *priv = usb_get_serial_port_data(port);
         unsigned long flags;
@@ -641,7 +645,7 @@ static void oti6858_close(struct usb_serial_port *port, struct file *filp)
         spin_lock_irqsave(&priv->lock, flags);
         timeout = 30 * HZ;      /* PL2303_CLOSING_WAIT */
         init_waitqueue_entry(&wait, current);
-        add_wait_queue(&port->tty->write_wait, &wait);
+        add_wait_queue(&tty->write_wait, &wait);
         dbg("%s(): entering wait loop", __func__);
         for (;;) {
                 set_current_state(TASK_INTERRUPTIBLE);
@@ -654,7 +658,7 @@ static void oti6858_close(struct usb_serial_port *port, struct file *filp)
                 spin_lock_irqsave(&priv->lock, flags);
         }
         set_current_state(TASK_RUNNING);
-        remove_wait_queue(&port->tty->write_wait, &wait);
+        remove_wait_queue(&tty->write_wait, &wait);
         dbg("%s(): after wait loop", __func__);
 
         /* clear out any remaining data in the buffer */
@@ -669,7 +673,7 @@ static void oti6858_close(struct usb_serial_port *port, struct file *filp)
         /* data is in the buffer to compute a delay */
         /* that is not unnecessarily long) */
         /* FIXME
-        bps = tty_get_baud_rate(port->tty);
+        bps = tty_get_baud_rate(tty);
         if (bps > 1200)
                 timeout = max((HZ*2560)/bps,HZ/10);
         else
@@ -690,7 +694,7 @@ static void oti6858_close(struct usb_serial_port *port, struct file *filp)
         usb_kill_urb(port->interrupt_in_urb);
 
         /*
-        if (port->tty && (port->tty->termios->c_cflag) & HUPCL) {
+        if (tty && (tty->termios->c_cflag) & HUPCL) {
                 // drop DTR and RTS
                 spin_lock_irqsave(&priv->lock, flags);
                 priv->pending_setup.control &= ~CONTROL_MASK;
@@ -699,9 +703,10 @@ static void oti6858_close(struct usb_serial_port *port, struct file *filp)
         */
 }
 
-static int oti6858_tiocmset(struct usb_serial_port *port, struct file *file,
+static int oti6858_tiocmset(struct tty_struct *tty, struct file *file,
                                 unsigned int set, unsigned int clear)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct oti6858_private *priv = usb_get_serial_port_data(port);
         unsigned long flags;
         u8 control;
@@ -732,8 +737,9 @@ static int oti6858_tiocmset(struct usb_serial_port *port, struct file *file,
         return 0;
 }
 
-static int oti6858_tiocmget(struct usb_serial_port *port, struct file *file)
+static int oti6858_tiocmget(struct tty_struct *tty, struct file *file)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct oti6858_private *priv = usb_get_serial_port_data(port);
         unsigned long flags;
         unsigned pin_state;
@@ -802,26 +808,15 @@ static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
         return 0;
 }
 
-static int oti6858_ioctl(struct usb_serial_port *port, struct file *file,
+static int oti6858_ioctl(struct tty_struct *tty, struct file *file,
                         unsigned int cmd, unsigned long arg)
 {
-        void __user *user_arg = (void __user *) arg;
-        unsigned int x;
+        struct usb_serial_port *port = tty->driver_data;
 
         dbg("%s(port = %d, cmd = 0x%04x, arg = 0x%08lx)",
                                 __func__, port->number, cmd, arg);
 
         switch (cmd) {
-                case TIOCMBIS:
-                        if (copy_from_user(&x, user_arg, sizeof(x)))
-                                return -EFAULT;
-                        return oti6858_tiocmset(port, NULL, x, 0);
-
-                case TIOCMBIC:
-                        if (copy_from_user(&x, user_arg, sizeof(x)))
-                                return -EFAULT;
-                        return oti6858_tiocmset(port, NULL, 0, x);
-
                 case TIOCMIWAIT:
                         dbg("%s(): TIOCMIWAIT", __func__);
                         return wait_modem_info(port, arg);
@@ -834,24 +829,6 @@ static int oti6858_ioctl(struct usb_serial_port *port, struct file *file,
         return -ENOIOCTLCMD;
 }
 
-static void oti6858_break_ctl(struct usb_serial_port *port, int break_state)
-{
-        int state;
-
-        dbg("%s(port = %d)", __func__, port->number);
-
-        state = (break_state == 0) ? 0 : 1;
-        dbg("%s(): turning break %s", __func__, state ? "on" : "off");
-
-        /* FIXME */
-/*
-        result = usb_control_msg (serial->dev, usb_sndctrlpipe (serial->dev, 0),
-                                  BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
-                                  0, NULL, 0, 100);
-        if (result != 0)
-                dbg("%s(): error sending break", __func__);
- */
-}
 
 static void oti6858_shutdown(struct usb_serial *serial)
 {
@@ -1002,7 +979,7 @@ static void oti6858_read_bulk_callback(struct urb *urb)
         spin_unlock_irqrestore(&priv->lock, flags);
 
         if (status != 0) {
-                if (!port->open_count) {
+                if (!port->port.count) {
                         dbg("%s(): port is closed, exiting", __func__);
                         return;
                 }
@@ -1020,14 +997,14 @@ static void oti6858_read_bulk_callback(struct urb *urb)
                 return;
         }
 
-        tty = port->tty;
+        tty = port->port.tty;
         if (tty != NULL && urb->actual_length > 0) {
                 tty_insert_flip_string(tty, data, urb->actual_length);
                 tty_flip_buffer_push(tty);
         }
 
         // schedule the interrupt urb if we are still open */
-        if (port->open_count != 0) {
+        if (port->port.count != 0) {
                 port->interrupt_in_urb->dev = port->serial->dev;
                 result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC);
                 if (result != 0) {
diff --git a/drivers/usb/serial/pl2303.c b/drivers/usb/serial/pl2303.c
index 2a0dd1b50dc4..a0016725d314 100644
--- a/drivers/usb/serial/pl2303.c
+++ b/drivers/usb/serial/pl2303.c
@@ -458,8 +458,8 @@ static void pl2303_send(struct usb_serial_port *port)
         usb_serial_port_softint(port);
 }
 
-static int pl2303_write(struct usb_serial_port *port, const unsigned char *buf,
-                        int count)
+static int pl2303_write(struct tty_struct *tty, struct usb_serial_port *port,
+                                const unsigned char *buf, int count)
 {
         struct pl2303_private *priv = usb_get_serial_port_data(port);
         unsigned long flags;
@@ -478,8 +478,9 @@ static int pl2303_write(struct usb_serial_port *port, const unsigned char *buf,
         return count;
 }
 
-static int pl2303_write_room(struct usb_serial_port *port)
+static int pl2303_write_room(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct pl2303_private *priv = usb_get_serial_port_data(port);
         int room = 0;
         unsigned long flags;
@@ -494,8 +495,9 @@ static int pl2303_write_room(struct usb_serial_port *port)
         return room;
 }
 
-static int pl2303_chars_in_buffer(struct usb_serial_port *port)
+static int pl2303_chars_in_buffer(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct pl2303_private *priv = usb_get_serial_port_data(port);
         int chars = 0;
         unsigned long flags;
@@ -510,8 +512,8 @@ static int pl2303_chars_in_buffer(struct usb_serial_port *port)
         return chars;
 }
 
-static void pl2303_set_termios(struct usb_serial_port *port,
-                               struct ktermios *old_termios)
+static void pl2303_set_termios(struct tty_struct *tty,
+                struct usb_serial_port *port, struct ktermios *old_termios)
 {
         struct usb_serial *serial = port->serial;
         struct pl2303_private *priv = usb_get_serial_port_data(port);
@@ -526,11 +528,10 @@ static void pl2303_set_termios(struct usb_serial_port *port,
 
         spin_lock_irqsave(&priv->lock, flags);
         if (!priv->termios_initialized) {
-                *(port->tty->termios) = tty_std_termios;
-                port->tty->termios->c_cflag = B9600 | CS8 | CREAD |
-                                              HUPCL | CLOCAL;
-                port->tty->termios->c_ispeed = 9600;
-                port->tty->termios->c_ospeed = 9600;
+                *(tty->termios) = tty_std_termios;
+                tty->termios->c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
+                tty->termios->c_ispeed = 9600;
+                tty->termios->c_ospeed = 9600;
                 priv->termios_initialized = 1;
         }
         spin_unlock_irqrestore(&priv->lock, flags);
@@ -539,16 +540,16 @@ static void pl2303_set_termios(struct usb_serial_port *port,
            serial settings even to the same values as before. Thus
            we actually need to filter in this specific case */
 
-        if (!tty_termios_hw_change(port->tty->termios, old_termios))
+        if (!tty_termios_hw_change(tty->termios, old_termios))
                 return;
 
-        cflag = port->tty->termios->c_cflag;
+        cflag = tty->termios->c_cflag;
 
         buf = kzalloc(7, GFP_KERNEL);
         if (!buf) {
                 dev_err(&port->dev, "%s - out of memory.\n", __func__);
                 /* Report back no change occurred */
-                *port->tty->termios = *old_termios;
+                *tty->termios = *old_termios;
                 return;
         }
 
@@ -569,7 +570,7 @@ static void pl2303_set_termios(struct usb_serial_port *port,
                 dbg("%s - data bits = %d", __func__, buf[6]);
         }
 
-        baud = tty_get_baud_rate(port->tty);;
+        baud = tty_get_baud_rate(tty);
         dbg("%s - baud = %d", __func__, baud);
         if (baud) {
                 buf[0] = baud & 0xff;
@@ -646,12 +647,13 @@ static void pl2303_set_termios(struct usb_serial_port *port,
 
         /* FIXME: Need to read back resulting baud rate */
         if (baud)
-                tty_encode_baud_rate(port->tty, baud, baud);
+                tty_encode_baud_rate(tty, baud, baud);
 
         kfree(buf);
 }
 
-static void pl2303_close(struct usb_serial_port *port, struct file *filp)
+static void pl2303_close(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 {
         struct pl2303_private *priv = usb_get_serial_port_data(port);
         unsigned long flags;
@@ -666,7 +668,7 @@ static void pl2303_close(struct usb_serial_port *port, struct file *filp)
         spin_lock_irqsave(&priv->lock, flags);
         timeout = PL2303_CLOSING_WAIT;
         init_waitqueue_entry(&wait, current);
-        add_wait_queue(&port->tty->write_wait, &wait);
+        add_wait_queue(&tty->write_wait, &wait);
         for (;;) {
                 set_current_state(TASK_INTERRUPTIBLE);
                 if (pl2303_buf_data_avail(priv->buf) == 0 ||
@@ -678,7 +680,7 @@ static void pl2303_close(struct usb_serial_port *port, struct file *filp)
                 spin_lock_irqsave(&priv->lock, flags);
         }
         set_current_state(TASK_RUNNING);
-        remove_wait_queue(&port->tty->write_wait, &wait);
+        remove_wait_queue(&tty->write_wait, &wait);
         /* clear out any remaining data in the buffer */
         pl2303_buf_clear(priv->buf);
         spin_unlock_irqrestore(&priv->lock, flags);
@@ -690,7 +692,7 @@ static void pl2303_close(struct usb_serial_port *port, struct file *filp)
         /* for lower rates we should really know how much */
         /* data is in the buffer to compute a delay */
         /* that is not unnecessarily long) */
-        bps = tty_get_baud_rate(port->tty);
+        bps = tty_get_baud_rate(tty);
         if (bps > 1200)
                 timeout = max((HZ*2560)/bps,HZ/10);
         else
@@ -703,8 +705,8 @@ static void pl2303_close(struct usb_serial_port *port, struct file *filp)
         usb_kill_urb(port->read_urb);
         usb_kill_urb(port->interrupt_in_urb);
 
-        if (port->tty) {
-                c_cflag = port->tty->termios->c_cflag;
+        if (tty) {
+                c_cflag = tty->termios->c_cflag;
                 if (c_cflag & HUPCL) {
                         /* drop DTR and RTS */
                         spin_lock_irqsave(&priv->lock, flags);
@@ -715,7 +717,8 @@ static void pl2303_close(struct usb_serial_port *port, struct file *filp)
         }
 }
 
-static int pl2303_open(struct usb_serial_port *port, struct file *filp)
+static int pl2303_open(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 {
         struct ktermios tmp_termios;
         struct usb_serial *serial = port->serial;
@@ -734,9 +737,8 @@ static int pl2303_open(struct usb_serial_port *port, struct file *filp)
         }
 
         /* Setup termios */
-        if (port->tty) {
-                pl2303_set_termios(port, &tmp_termios);
-        }
+        if (tty)
+                pl2303_set_termios(tty, port, &tmp_termios);
 
         //FIXME: need to assert RTS and DTR if CRTSCTS off
 
@@ -746,7 +748,7 @@ static int pl2303_open(struct usb_serial_port *port, struct file *filp)
         if (result) {
                 dev_err(&port->dev, "%s - failed submitting read urb,"
                         " error %d\n", __func__, result);
-                pl2303_close(port, NULL);
+                pl2303_close(tty, port, NULL);
                 return -EPROTO;
         }
 
@@ -756,15 +758,16 @@ static int pl2303_open(struct usb_serial_port *port, struct file *filp)
         if (result) {
                 dev_err(&port->dev, "%s - failed submitting interrupt urb,"
                         " error %d\n", __func__, result);
-                pl2303_close(port, NULL);
+                pl2303_close(tty, port, NULL);
                 return -EPROTO;
         }
         return 0;
 }
 
-static int pl2303_tiocmset(struct usb_serial_port *port, struct file *file,
+static int pl2303_tiocmset(struct tty_struct *tty, struct file *file,
                            unsigned int set, unsigned int clear)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct pl2303_private *priv = usb_get_serial_port_data(port);
         unsigned long flags;
         u8 control;
@@ -787,8 +790,9 @@ static int pl2303_tiocmset(struct usb_serial_port *port, struct file *file,
         return set_control_lines(port->serial->dev, control);
 }
 
-static int pl2303_tiocmget(struct usb_serial_port *port, struct file *file)
+static int pl2303_tiocmget(struct tty_struct *tty, struct file *file)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct pl2303_private *priv = usb_get_serial_port_data(port);
         unsigned long flags;
         unsigned int mcr;
@@ -853,9 +857,10 @@ static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
         return 0;
 }
 
-static int pl2303_ioctl(struct usb_serial_port *port, struct file *file,
+static int pl2303_ioctl(struct tty_struct *tty, struct file *file,
                         unsigned int cmd, unsigned long arg)
 {
+        struct usb_serial_port *port = tty->driver_data;
         dbg("%s (%d) cmd = 0x%04x", __func__, port->number, cmd);
 
         switch (cmd) {
@@ -871,8 +876,9 @@ static int pl2303_ioctl(struct usb_serial_port *port, struct file *file,
         return -ENOIOCTLCMD;
 }
 
-static void pl2303_break_ctl(struct usb_serial_port *port, int break_state)
+static void pl2303_break_ctl(struct tty_struct *tty, int break_state)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct usb_serial *serial = port->serial;
         u16 state;
         int result;
@@ -1001,7 +1007,7 @@ static void pl2303_read_bulk_callback(struct urb *urb)
 
         if (status) {
                 dbg("%s - urb status = %d", __func__, status);
-                if (!port->open_count) {
+                if (!port->port.count) {
                         dbg("%s - port is closed, exiting.", __func__);
                         return;
                 }
@@ -1044,7 +1050,7 @@ static void pl2303_read_bulk_callback(struct urb *urb)
                 tty_flag = TTY_FRAME;
         dbg("%s - tty_flag = %d", __func__, tty_flag);
 
-        tty = port->tty;
+        tty = port->port.tty;
         if (tty && urb->actual_length) {
                 tty_buffer_request_room(tty, urb->actual_length + 1);
                 /* overrun is special, not associated with a char */
@@ -1056,7 +1062,7 @@ static void pl2303_read_bulk_callback(struct urb *urb)
         }
 
         /* Schedule the next read _if_ we are still open */
-        if (port->open_count) {
+        if (port->port.count) {
                 urb->dev = port->serial->dev;
                 result = usb_submit_urb(urb, GFP_ATOMIC);
                 if (result)
diff --git a/drivers/usb/serial/safe_serial.c b/drivers/usb/serial/safe_serial.c
index 94bddf06ea4f..f823e4dcea1e 100644
--- a/drivers/usb/serial/safe_serial.c
+++ b/drivers/usb/serial/safe_serial.c
@@ -229,8 +229,8 @@ static void safe_read_bulk_callback (struct urb *urb)
                         int actual_length = data[length - 2] >> 2;
                         if (actual_length <= (length - 2)) {
                                 info ("%s - actual: %d", __func__, actual_length);
-                                tty_insert_flip_string(port->tty, data, actual_length);
-                                tty_flip_buffer_push (port->tty);
+                                tty_insert_flip_string(port->port.tty, data, actual_length);
+                                tty_flip_buffer_push (port->port.tty);
                         } else {
                                 err ("%s - inconsistent lengths %d:%d", __func__,
                                      actual_length, length);
@@ -239,8 +239,8 @@ static void safe_read_bulk_callback (struct urb *urb)
                         err ("%s - bad CRC %x", __func__, fcs);
                 }
         } else {
-                tty_insert_flip_string(port->tty, data, length);
-                tty_flip_buffer_push (port->tty);
+                tty_insert_flip_string(port->port.tty, data, length);
+                tty_flip_buffer_push (port->port.tty);
         }
 
         /* Continue trying to always read  */
@@ -255,7 +255,8 @@ static void safe_read_bulk_callback (struct urb *urb)
         }
 }
 
-static int safe_write (struct usb_serial_port *port, const unsigned char *buf, int count)
+static int safe_write(struct tty_struct *tty, struct usb_serial_port *port,
+                                        const unsigned char *buf, int count)
 {
         unsigned char *data;
         int result;
@@ -349,8 +350,9 @@ static int safe_write (struct usb_serial_port *port, const unsigned char *buf, i
         return (count);
 }
 
-static int safe_write_room (struct usb_serial_port *port)
+static int safe_write_room(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         int room = 0;           /* Default: no room */
         unsigned long flags;
 
diff --git a/drivers/usb/serial/sierra.c b/drivers/usb/serial/sierra.c
index 29074c1ba22b..892020d48555 100644
--- a/drivers/usb/serial/sierra.c
+++ b/drivers/usb/serial/sierra.c
@@ -250,7 +250,8 @@ struct sierra_port_private {
         int ri_state;
 };
 
-static int sierra_send_setup(struct usb_serial_port *port)
+static int sierra_send_setup(struct tty_struct *tty,
+                                                struct usb_serial_port *port)
 {
         struct usb_serial *serial = port->serial;
         struct sierra_port_private *portdata;
@@ -260,7 +261,7 @@ static int sierra_send_setup(struct usb_serial_port *port)
 
         portdata = usb_get_serial_port_data(port);
 
-        if (port->tty) {
+        if (tty) {
                 int val = 0;
                 if (portdata->dtr_state)
                         val |= 0x01;
@@ -284,32 +285,17 @@ static int sierra_send_setup(struct usb_serial_port *port)
         return 0;
 }
 
-static void sierra_rx_throttle(struct usb_serial_port *port)
+static void sierra_set_termios(struct tty_struct *tty,
+                struct usb_serial_port *port, struct ktermios *old_termios)
 {
         dbg("%s", __func__);
+        tty_termios_copy_hw(tty->termios, old_termios);
+        sierra_send_setup(tty, port);
 }
 
-static void sierra_rx_unthrottle(struct usb_serial_port *port)
-{
-        dbg("%s", __func__);
-}
-
-static void sierra_break_ctl(struct usb_serial_port *port, int break_state)
-{
-        /* Unfortunately, I don't know how to send a break */
-        dbg("%s", __func__);
-}
-
-static void sierra_set_termios(struct usb_serial_port *port,
-                        struct ktermios *old_termios)
-{
-        dbg("%s", __func__);
-        tty_termios_copy_hw(port->tty->termios, old_termios);
-        sierra_send_setup(port);
-}
-
-static int sierra_tiocmget(struct usb_serial_port *port, struct file *file)
+static int sierra_tiocmget(struct tty_struct *tty, struct file *file)
 {
+        struct usb_serial_port *port = tty->driver_data;
         unsigned int value;
         struct sierra_port_private *portdata;
 
@@ -325,9 +311,10 @@ static int sierra_tiocmget(struct usb_serial_port *port, struct file *file)
         return value;
 }
 
-static int sierra_tiocmset(struct usb_serial_port *port, struct file *file,
+static int sierra_tiocmset(struct tty_struct *tty, struct file *file,
                         unsigned int set, unsigned int clear)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct sierra_port_private *portdata;
 
         portdata = usb_get_serial_port_data(port);
@@ -341,13 +328,7 @@ static int sierra_tiocmset(struct usb_serial_port *port, struct file *file,
                 portdata->rts_state = 0;
         if (clear & TIOCM_DTR)
                 portdata->dtr_state = 0;
-        return sierra_send_setup(port);
-}
-
-static int sierra_ioctl(struct usb_serial_port *port, struct file *file,
-                        unsigned int cmd, unsigned long arg)
-{
-        return -ENOIOCTLCMD;
+        return sierra_send_setup(tty, port);
 }
 
 static void sierra_outdat_callback(struct urb *urb)
@@ -374,8 +355,8 @@ static void sierra_outdat_callback(struct urb *urb)
 }
 
 /* Write */
-static int sierra_write(struct usb_serial_port *port,
-                        const unsigned char *buf, int count)
+static int sierra_write(struct tty_struct *tty, struct usb_serial_port *port,
+                                        const unsigned char *buf, int count)
 {
         struct sierra_port_private *portdata = usb_get_serial_port_data(port);
         struct usb_serial *serial = port->serial;
@@ -463,7 +444,7 @@ static void sierra_indat_callback(struct urb *urb)
                 dbg("%s: nonzero status: %d on endpoint %02x.",
                     __func__, status, endpoint);
         } else {
-                tty = port->tty;
+                tty = port->port.tty;
                 if (urb->actual_length) {
                         tty_buffer_request_room(tty, urb->actual_length);
                         tty_insert_flip_string(tty, data, urb->actual_length);
@@ -473,7 +454,7 @@ static void sierra_indat_callback(struct urb *urb)
                 }
 
                 /* Resubmit urb so we continue receiving */
-                if (port->open_count && status != -ESHUTDOWN) {
+                if (port->port.count && status != -ESHUTDOWN) {
                         err = usb_submit_urb(urb, GFP_ATOMIC);
                         if (err)
                                 dev_err(&port->dev, "resubmit read urb failed."
@@ -517,9 +498,9 @@ static void sierra_instat_callback(struct urb *urb)
                         portdata->dsr_state = ((signals & 0x02) ? 1 : 0);
                         portdata->ri_state = ((signals & 0x08) ? 1 : 0);
 
-                        if (port->tty && !C_CLOCAL(port->tty) &&
+                        if (port->port.tty && !C_CLOCAL(port->port.tty) &&
                                         old_dcd_state && !portdata->dcd_state)
-                                tty_hangup(port->tty);
+                                tty_hangup(port->port.tty);
                 } else {
                         dbg("%s: type %x req %x", __func__,
                                 req_pkt->bRequestType, req_pkt->bRequest);
@@ -537,8 +518,9 @@ static void sierra_instat_callback(struct urb *urb)
         }
 }
 
-static int sierra_write_room(struct usb_serial_port *port)
+static int sierra_write_room(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct sierra_port_private *portdata = usb_get_serial_port_data(port);
         unsigned long flags;
 
@@ -557,22 +539,8 @@ static int sierra_write_room(struct usb_serial_port *port)
         return 2048;
 }
 
-static int sierra_chars_in_buffer(struct usb_serial_port *port)
-{
-        dbg("%s - port %d", __func__, port->number);
-
-        /*
-         * We can't really account for how much data we
-         * have sent out, but hasn't made it through to the
-         * device as we can't see the backend here, so just
-         * tell the tty layer that everything is flushed.
-         *
-         * FIXME: should walk the outstanding urbs info
-         */
-        return 0;
-}
-
-static int sierra_open(struct usb_serial_port *port, struct file *filp)
+static int sierra_open(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 {
         struct sierra_port_private *portdata;
         struct usb_serial *serial = port->serial;
@@ -612,9 +580,10 @@ static int sierra_open(struct usb_serial_port *port, struct file *filp)
                 }
         }
 
-        port->tty->low_latency = 1;
+        if (tty)
+                tty->low_latency = 1;
 
-        sierra_send_setup(port);
+        sierra_send_setup(tty, port);
 
         /* start up the interrupt endpoint if we have one */
         if (port->interrupt_in_urb) {
@@ -626,7 +595,8 @@ static int sierra_open(struct usb_serial_port *port, struct file *filp)
         return 0;
 }
 
-static void sierra_close(struct usb_serial_port *port, struct file *filp)
+static void sierra_close(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 {
         int i;
         struct usb_serial *serial = port->serial;
@@ -641,7 +611,7 @@ static void sierra_close(struct usb_serial_port *port, struct file *filp)
         if (serial->dev) {
                 mutex_lock(&serial->disc_mutex);
                 if (!serial->disconnected)
-                        sierra_send_setup(port);
+                        sierra_send_setup(tty, port);
                 mutex_unlock(&serial->disc_mutex);
 
                 /* Stop reading/writing urbs */
@@ -651,7 +621,7 @@ static void sierra_close(struct usb_serial_port *port, struct file *filp)
 
         usb_kill_urb(port->interrupt_in_urb);
 
-        port->tty = NULL;
+        port->port.tty = NULL;  /* FIXME */
 }
 
 static int sierra_startup(struct usb_serial *serial)
@@ -754,12 +724,7 @@ static struct usb_serial_driver sierra_device = {
         .close             = sierra_close,
         .write             = sierra_write,
         .write_room        = sierra_write_room,
-        .chars_in_buffer   = sierra_chars_in_buffer,
-        .throttle          = sierra_rx_throttle,
-        .unthrottle        = sierra_rx_unthrottle,
-        .ioctl             = sierra_ioctl,
         .set_termios       = sierra_set_termios,
-        .break_ctl         = sierra_break_ctl,
         .tiocmget          = sierra_tiocmget,
         .tiocmset          = sierra_tiocmset,
         .attach            = sierra_startup,
diff --git a/drivers/usb/serial/spcp8x5.c b/drivers/usb/serial/spcp8x5.c
index 55b2570b8b8b..58495f5cca1f 100644
--- a/drivers/usb/serial/spcp8x5.c
+++ b/drivers/usb/serial/spcp8x5.c
@@ -448,7 +448,8 @@ static void spcp8x5_set_workMode(struct usb_device *dev, u16 value,
 
 /* close the serial port. We should wait for data sending to device 1st and
  * then kill all urb. */
-static void spcp8x5_close(struct usb_serial_port *port, struct file *filp)
+static void spcp8x5_close(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 {
         struct spcp8x5_private *priv = usb_get_serial_port_data(port);
         unsigned long flags;
@@ -464,7 +465,7 @@ static void spcp8x5_close(struct usb_serial_port *port, struct file *filp)
         spin_lock_irqsave(&priv->lock, flags);
         timeout = SPCP8x5_CLOSING_WAIT;
         init_waitqueue_entry(&wait, current);
-        add_wait_queue(&port->tty->write_wait, &wait);
+        add_wait_queue(&tty->write_wait, &wait);
         for (;;) {
                 set_current_state(TASK_INTERRUPTIBLE);
                 if (ringbuf_avail_data(priv->buf) == 0 ||
@@ -475,7 +476,7 @@ static void spcp8x5_close(struct usb_serial_port *port, struct file *filp)
                 spin_lock_irqsave(&priv->lock, flags);
         }
         set_current_state(TASK_RUNNING);
-        remove_wait_queue(&port->tty->write_wait, &wait);
+        remove_wait_queue(&tty->write_wait, &wait);
 
         /* clear out any remaining data in the buffer */
         clear_ringbuf(priv->buf);
@@ -486,7 +487,7 @@ static void spcp8x5_close(struct usb_serial_port *port, struct file *filp)
          * flow control for data rates of 1200 bps or more, for lower rates we
          * should really know how much data is in the buffer to compute a delay
          * that is not unnecessarily long) */
-        bps = tty_get_baud_rate(port->tty);
+        bps = tty_get_baud_rate(tty);
         if (bps > 1200)
                 timeout = max((HZ*2560) / bps, HZ/10);
         else
@@ -495,8 +496,8 @@ static void spcp8x5_close(struct usb_serial_port *port, struct file *filp)
         schedule_timeout(timeout);
 
         /* clear control lines */
-        if (port->tty) {
-                c_cflag = port->tty->termios->c_cflag;
+        if (tty) {
+                c_cflag = tty->termios->c_cflag;
                 if (c_cflag & HUPCL) {
                         spin_lock_irqsave(&priv->lock, flags);
                         priv->line_control = 0;
@@ -518,14 +519,14 @@ static void spcp8x5_close(struct usb_serial_port *port, struct file *filp)
 }
 
 /* set the serial param for transfer. we should check if we really need to
- * transfer. then if be set flow contorl we should do this too. */
-static void spcp8x5_set_termios(struct usb_serial_port *port,
-                                struct ktermios *old_termios)
+ * transfer. if we set flow control we should do this too. */
+static void spcp8x5_set_termios(struct tty_struct *tty,
+                struct usb_serial_port *port, struct ktermios *old_termios)
 {
         struct usb_serial *serial = port->serial;
         struct spcp8x5_private *priv = usb_get_serial_port_data(port);
         unsigned long flags;
-        unsigned int cflag = port->tty->termios->c_cflag;
+        unsigned int cflag = tty->termios->c_cflag;
         unsigned int old_cflag = old_termios->c_cflag;
         unsigned short uartdata;
         unsigned char buf[2] = {0, 0};
@@ -533,21 +534,19 @@ static void spcp8x5_set_termios(struct usb_serial_port *port,
         int i;
         u8 control;
 
-        if ((!port->tty) || (!port->tty->termios))
-                return;
-
         /* for the 1st time call this function */
         spin_lock_irqsave(&priv->lock, flags);
         if (!priv->termios_initialized) {
-                *(port->tty->termios) = tty_std_termios;
-                port->tty->termios->c_cflag = B115200 | CS8 | CREAD |
-                                              HUPCL | CLOCAL;
+                *(tty->termios) = tty_std_termios;
+                tty->termios->c_cflag = B115200 | CS8 | CREAD | HUPCL | CLOCAL;
+                tty->termios->c_ispeed = 115200;
+                tty->termios->c_ospeed = 115200;
                 priv->termios_initialized = 1;
         }
         spin_unlock_irqrestore(&priv->lock, flags);
 
         /* check that they really want us to change something */
-        if (!tty_termios_hw_change(port->tty->termios, old_termios))
+        if (!tty_termios_hw_change(tty->termios, old_termios))
                 return;
 
         /* set DTR/RTS active */
@@ -567,7 +566,7 @@ static void spcp8x5_set_termios(struct usb_serial_port *port,
         }
 
         /* Set Baud Rate */
-        baud = tty_get_baud_rate(port->tty);;
+        baud = tty_get_baud_rate(tty);;
         switch (baud) {
         case 300:       buf[0] = 0x00;  break;
         case 600:       buf[0] = 0x01;  break;
@@ -643,7 +642,8 @@ static void spcp8x5_set_termios(struct usb_serial_port *port,
 
 /* open the serial port. do some usb system call. set termios and get the line
  * status of the device. then submit the read urb */
-static int spcp8x5_open(struct usb_serial_port *port, struct file *filp)
+static int spcp8x5_open(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 {
         struct ktermios tmp_termios;
         struct usb_serial *serial = port->serial;
@@ -665,7 +665,7 @@ static int spcp8x5_open(struct usb_serial_port *port, struct file *filp)
                 return ret;
 
         spin_lock_irqsave(&priv->lock, flags);
-        if (port->tty->termios->c_cflag & CBAUD)
+        if (tty && (tty->termios->c_cflag & CBAUD))
                 priv->line_control = MCR_DTR | MCR_RTS;
         else
                 priv->line_control = 0;
@@ -674,8 +674,8 @@ static int spcp8x5_open(struct usb_serial_port *port, struct file *filp)
         spcp8x5_set_ctrlLine(serial->dev, priv->line_control , priv->type);
 
         /* Setup termios */
-        if (port->tty)
-                spcp8x5_set_termios(port, &tmp_termios);
+        if (tty)
+                spcp8x5_set_termios(tty, port, &tmp_termios);
 
         spcp8x5_get_msr(serial->dev, &status, priv->type);
 
@@ -690,7 +690,7 @@ static int spcp8x5_open(struct usb_serial_port *port, struct file *filp)
         port->read_urb->dev = serial->dev;
         ret = usb_submit_urb(port->read_urb, GFP_KERNEL);
         if (ret) {
-                spcp8x5_close(port, NULL);
+                spcp8x5_close(tty, port, NULL);
                 return -EPROTO;
         }
         return 0;
@@ -717,7 +717,7 @@ static void spcp8x5_read_bulk_callback(struct urb *urb)
 
         /* check the urb status */
         if (urb->status) {
-                if (!port->open_count)
+                if (!port->port.count)
                         return;
                 if (urb->status == -EPROTO) {
                         /* spcp8x5 mysteriously fails with -EPROTO */
@@ -755,7 +755,7 @@ static void spcp8x5_read_bulk_callback(struct urb *urb)
                 tty_flag = TTY_FRAME;
         dev_dbg(&port->dev, "tty_flag = %d\n", tty_flag);
 
-        tty = port->tty;
+        tty = port->port.tty;
         if (tty && urb->actual_length) {
                 tty_buffer_request_room(tty, urb->actual_length + 1);
                 /* overrun is special, not associated with a char */
@@ -767,7 +767,7 @@ static void spcp8x5_read_bulk_callback(struct urb *urb)
         }
 
         /* Schedule the next read _if_ we are still open */
-        if (port->open_count) {
+        if (port->port.count) {
                 urb->dev = port->serial->dev;
                 result = usb_submit_urb(urb , GFP_ATOMIC);
                 if (result)
@@ -866,7 +866,7 @@ static void spcp8x5_write_bulk_callback(struct urb *urb)
 }
 
 /* write data to ring buffer. and then start the write transfer */
-static int spcp8x5_write(struct usb_serial_port *port,
+static int spcp8x5_write(struct tty_struct *tty, struct usb_serial_port *port,
                          const unsigned char *buf, int count)
 {
         struct spcp8x5_private *priv = usb_get_serial_port_data(port);
@@ -925,9 +925,10 @@ static int spcp8x5_wait_modem_info(struct usb_serial_port *port,
         return 0;
 }
 
-static int spcp8x5_ioctl(struct usb_serial_port *port, struct file *file,
+static int spcp8x5_ioctl(struct tty_struct *tty, struct file *file,
                          unsigned int cmd, unsigned long arg)
 {
+        struct usb_serial_port *port = tty->driver_data;
         dbg("%s (%d) cmd = 0x%04x", __func__, port->number, cmd);
 
         switch (cmd) {
@@ -943,9 +944,10 @@ static int spcp8x5_ioctl(struct usb_serial_port *port, struct file *file,
         return -ENOIOCTLCMD;
 }
 
-static int spcp8x5_tiocmset(struct usb_serial_port *port, struct file *file,
+static int spcp8x5_tiocmset(struct tty_struct *tty, struct file *file,
                             unsigned int set, unsigned int clear)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct spcp8x5_private *priv = usb_get_serial_port_data(port);
         unsigned long flags;
         u8 control;
@@ -965,8 +967,9 @@ static int spcp8x5_tiocmset(struct usb_serial_port *port, struct file *file,
         return spcp8x5_set_ctrlLine(port->serial->dev, control , priv->type);
 }
 
-static int spcp8x5_tiocmget(struct usb_serial_port *port, struct file *file)
+static int spcp8x5_tiocmget(struct tty_struct *tty, struct file *file)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct spcp8x5_private *priv = usb_get_serial_port_data(port);
         unsigned long flags;
         unsigned int mcr;
@@ -989,8 +992,9 @@ static int spcp8x5_tiocmget(struct usb_serial_port *port, struct file *file)
 }
 
 /* get the avail space room in ring buffer */
-static int spcp8x5_write_room(struct usb_serial_port *port)
+static int spcp8x5_write_room(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct spcp8x5_private *priv = usb_get_serial_port_data(port);
         int room = 0;
         unsigned long flags;
@@ -1003,8 +1007,9 @@ static int spcp8x5_write_room(struct usb_serial_port *port)
 }
 
 /* get the number of avail data in write ring buffer */
-static int spcp8x5_chars_in_buffer(struct usb_serial_port *port)
+static int spcp8x5_chars_in_buffer(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct spcp8x5_private *priv = usb_get_serial_port_data(port);
         int chars = 0;
         unsigned long flags;
diff --git a/drivers/usb/serial/ti_usb_3410_5052.c b/drivers/usb/serial/ti_usb_3410_5052.c
index a26a629dfc4f..48831a755fc1 100644
--- a/drivers/usb/serial/ti_usb_3410_5052.c
+++ b/drivers/usb/serial/ti_usb_3410_5052.c
@@ -70,6 +70,7 @@
 
 #include <linux/kernel.h>
 #include <linux/errno.h>
+#include <linux/firmware.h>
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/tty.h>
@@ -149,21 +150,23 @@ struct ti_device {
 
 static int ti_startup(struct usb_serial *serial);
 static void ti_shutdown(struct usb_serial *serial);
-static int ti_open(struct usb_serial_port *port, struct file *file);
-static void ti_close(struct usb_serial_port *port, struct file *file);
-static int ti_write(struct usb_serial_port *port, const unsigned char *data,
-        int count);
-static int ti_write_room(struct usb_serial_port *port);
-static int ti_chars_in_buffer(struct usb_serial_port *port);
-static void ti_throttle(struct usb_serial_port *port);
-static void ti_unthrottle(struct usb_serial_port *port);
-static int ti_ioctl(struct usb_serial_port *port, struct file *file, unsigned int cmd, unsigned long arg);
-static void ti_set_termios(struct usb_serial_port *port,
+static int ti_open(struct tty_struct *tty, struct usb_serial_port *port,
+                                struct file *file);
+static void ti_close(struct tty_struct *tty, struct usb_serial_port *port,
+                                struct file *file);
+static int ti_write(struct tty_struct *tty, struct usb_serial_port *port,
+                                const unsigned char *data, int count);
+static int ti_write_room(struct tty_struct *tty);
+static int ti_chars_in_buffer(struct tty_struct *tty);
+static void ti_throttle(struct tty_struct *tty);
+static void ti_unthrottle(struct tty_struct *tty);
+static int ti_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg);
+static void ti_set_termios(struct tty_struct *tty, struct usb_serial_port *port,
         struct ktermios *old_termios);
-static int ti_tiocmget(struct usb_serial_port *port, struct file *file);
-static int ti_tiocmset(struct usb_serial_port *port, struct file *file,
+static int ti_tiocmget(struct tty_struct *tty, struct file *file);
+static int ti_tiocmset(struct tty_struct *tty, struct file *file,
         unsigned int set, unsigned int clear);
-static void ti_break(struct usb_serial_port *port, int break_state);
+static void ti_break(struct tty_struct *tty, int break_state);
 static void ti_interrupt_callback(struct urb *urb);
 static void ti_bulk_in_callback(struct urb *urb);
 static void ti_bulk_out_callback(struct urb *urb);
@@ -192,8 +195,7 @@ static int ti_command_in_sync(struct ti_device *tdev, __u8 command,
 static int ti_write_byte(struct ti_device *tdev, unsigned long addr,
         __u8 mask, __u8 byte);
 
-static int ti_download_firmware(struct ti_device *tdev, char *fw_name);
-
+static int ti_download_firmware(struct ti_device *tdev, int type);
 
 /* circular buffer */
 static struct circ_buf *ti_buf_alloc(void);
@@ -430,11 +432,10 @@ static int ti_startup(struct usb_serial *serial)
 
         /* if we have only 1 configuration, download firmware */
         if (dev->descriptor.bNumConfigurations == 1) {
-
                 if (tdev->td_is_3410)
-                        status = ti_download_firmware(tdev, "ti_3410.fw");
+                        status = ti_download_firmware(tdev, 3410);
                 else
-                        status = ti_download_firmware(tdev, "ti_5052.fw");
+                        status = ti_download_firmware(tdev, 5052);
                 if (status)
                         goto free_tdev;
 
@@ -519,7 +520,8 @@ static void ti_shutdown(struct usb_serial *serial)
 }
 
 
-static int ti_open(struct usb_serial_port *port, struct file *file)
+static int ti_open(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *file)
 {
         struct ti_port *tport = usb_get_serial_port_data(port);
         struct ti_device *tdev;
@@ -543,9 +545,9 @@ static int ti_open(struct usb_serial_port *port, struct file *file)
         if (mutex_lock_interruptible(&tdev->td_open_close_lock))
                 return -ERESTARTSYS;
 
-        if (port->tty)
-                port->tty->low_latency = 
-                        (tport->tp_flags & ASYNC_LOW_LATENCY) ? 1 : 0;
+        if (tty)
+                tty->low_latency =
+                                (tport->tp_flags & ASYNC_LOW_LATENCY) ? 1 : 0;
 
         port_number = port->number - port->serial->minor;
 
@@ -573,7 +575,8 @@ static int ti_open(struct usb_serial_port *port, struct file *file)
                 }
         }
 
-        ti_set_termios(port, port->tty->termios);
+        if (tty)
+                ti_set_termios(tty, port, tty->termios);
 
         dbg("%s - sending TI_OPEN_PORT", __func__);
         status = ti_command_out_sync(tdev, TI_OPEN_PORT,
@@ -610,7 +613,8 @@ static int ti_open(struct usb_serial_port *port, struct file *file)
         usb_clear_halt(dev, port->write_urb->pipe);
         usb_clear_halt(dev, port->read_urb->pipe);
 
-        ti_set_termios(port, port->tty->termios);
+        if (tty)
+                ti_set_termios(tty, port, tty->termios);
 
         dbg("%s - sending TI_OPEN_PORT (2)", __func__);
         status = ti_command_out_sync(tdev, TI_OPEN_PORT,
@@ -661,7 +665,8 @@ release_lock:
 }
 
 
-static void ti_close(struct usb_serial_port *port, struct file *file)
+static void ti_close(struct tty_struct *tty, struct usb_serial_port *port,
+                                                        struct file *file)
 {
         struct ti_device *tdev;
         struct ti_port *tport;
@@ -707,8 +712,8 @@ static void ti_close(struct usb_serial_port *port, struct file *file)
 }
 
 
-static int ti_write(struct usb_serial_port *port, const unsigned char *data,
-        int count)
+static int ti_write(struct tty_struct *tty, struct usb_serial_port *port,
+                        const unsigned char *data, int count)
 {
         struct ti_port *tport = usb_get_serial_port_data(port);
         unsigned long flags;
@@ -733,8 +738,9 @@ static int ti_write(struct usb_serial_port *port, const unsigned char *data,
 }
 
 
-static int ti_write_room(struct usb_serial_port *port)
+static int ti_write_room(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct ti_port *tport = usb_get_serial_port_data(port);
         int room = 0;
         unsigned long flags;
@@ -753,8 +759,9 @@ static int ti_write_room(struct usb_serial_port *port)
 }
 
 
-static int ti_chars_in_buffer(struct usb_serial_port *port)
+static int ti_chars_in_buffer(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct ti_port *tport = usb_get_serial_port_data(port);
         int chars = 0;
         unsigned long flags;
@@ -773,32 +780,26 @@ static int ti_chars_in_buffer(struct usb_serial_port *port)
 }
 
 
-static void ti_throttle(struct usb_serial_port *port)
+static void ti_throttle(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct ti_port *tport = usb_get_serial_port_data(port);
-        struct tty_struct *tty;
 
         dbg("%s - port %d", __func__, port->number);
 
         if (tport == NULL)
                 return;
 
-        tty = port->tty;
-        if (!tty) {
-                dbg("%s - no tty", __func__);
-                return;
-        }
-
         if (I_IXOFF(tty) || C_CRTSCTS(tty))
                 ti_stop_read(tport, tty);
 
 }
 
 
-static void ti_unthrottle(struct usb_serial_port *port)
+static void ti_unthrottle(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct ti_port *tport = usb_get_serial_port_data(port);
-        struct tty_struct *tty;
         int status;
 
         dbg("%s - port %d", __func__, port->number);
@@ -806,12 +807,6 @@ static void ti_unthrottle(struct usb_serial_port *port)
         if (tport == NULL)
                 return;
 
-        tty = port->tty;
-        if (!tty) {
-                dbg("%s - no tty", __func__);
-                return;
-        }
-
         if (I_IXOFF(tty) || C_CRTSCTS(tty)) {
                 status = ti_restart_read(tport, tty);
                 if (status)
@@ -820,9 +815,10 @@ static void ti_unthrottle(struct usb_serial_port *port)
 }
 
 
-static int ti_ioctl(struct usb_serial_port *port, struct file *file,
+static int ti_ioctl(struct tty_struct *tty, struct file *file,
         unsigned int cmd, unsigned long arg)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct ti_port *tport = usb_get_serial_port_data(port);
         struct async_icount cnow;
         struct async_icount cprev;
@@ -875,11 +871,10 @@ static int ti_ioctl(struct usb_serial_port *port, struct file *file,
 }
 
 
-static void ti_set_termios(struct usb_serial_port *port,
-        struct ktermios *old_termios)
+static void ti_set_termios(struct tty_struct *tty,
+                struct usb_serial_port *port, struct ktermios *old_termios)
 {
         struct ti_port *tport = usb_get_serial_port_data(port);
-        struct tty_struct *tty = port->tty;
         struct ti_uart_config *config;
         tcflag_t cflag,iflag;
         int baud;
@@ -1008,8 +1003,9 @@ static void ti_set_termios(struct usb_serial_port *port,
 }
 
 
-static int ti_tiocmget(struct usb_serial_port *port, struct file *file)
+static int ti_tiocmget(struct tty_struct *tty, struct file *file)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct ti_port *tport = usb_get_serial_port_data(port);
         unsigned int result;
         unsigned int msr;
@@ -1040,9 +1036,10 @@ static int ti_tiocmget(struct usb_serial_port *port, struct file *file)
 }
 
 
-static int ti_tiocmset(struct usb_serial_port *port, struct file *file,
+static int ti_tiocmset(struct tty_struct *tty, struct file *file,
         unsigned int set, unsigned int clear)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct ti_port *tport = usb_get_serial_port_data(port);
         unsigned int mcr;
         unsigned long flags;
@@ -1074,8 +1071,9 @@ static int ti_tiocmset(struct usb_serial_port *port, struct file *file,
 }
 
 
-static void ti_break(struct usb_serial_port *port, int break_state)
+static void ti_break(struct tty_struct *tty, int break_state)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct ti_port *tport = usb_get_serial_port_data(port);
         int status;
 
@@ -1213,14 +1211,14 @@ static void ti_bulk_in_callback(struct urb *urb)
                 return;
         }
 
-        if (port->tty && urb->actual_length) {
+        if (port->port.tty && urb->actual_length) {
                 usb_serial_debug_data(debug, dev, __func__,
                         urb->actual_length, urb->transfer_buffer);
 
                 if (!tport->tp_is_open)
                         dbg("%s - port closed, dropping data", __func__);
                 else
-                        ti_recv(&urb->dev->dev, port->tty, urb->transfer_buffer,
+                        ti_recv(&urb->dev->dev, port->port.tty, urb->transfer_buffer,
                                 urb->actual_length);
 
                 spin_lock(&tport->tp_lock);
@@ -1302,7 +1300,7 @@ static void ti_send(struct ti_port *tport)
 {
         int count, result;
         struct usb_serial_port *port = tport->tp_port;
-        struct tty_struct *tty = port->tty;
+        struct tty_struct *tty = port->port.tty;        /* FIXME */
         unsigned long flags;
 
 
@@ -1442,8 +1440,9 @@ static int ti_set_serial_info(struct ti_port *tport,
                 return -EFAULT;
 
         tport->tp_flags = new_serial.flags & TI_SET_SERIAL_FLAGS;
-        if (port->tty)
-                port->tty->low_latency =
+        /* FIXME */
+        if (port->port.tty)
+                port->port.tty->low_latency =
                         (tport->tp_flags & ASYNC_LOW_LATENCY) ? 1 : 0;
         tport->tp_closing_wait = new_serial.closing_wait;
 
@@ -1477,7 +1476,7 @@ static void ti_handle_new_msr(struct ti_port *tport, __u8 msr)
         tport->tp_msr = msr & TI_MSR_MASK;
 
         /* handle CTS flow control */
-        tty = tport->tp_port->tty;
+        tty = tport->tp_port->port.tty;
         if (tty && C_CRTSCTS(tty)) {
                 if (msr & TI_MSR_CTS) {
                         tty->hw_stopped = 0;
@@ -1655,65 +1654,65 @@ static int ti_write_byte(struct ti_device *tdev, unsigned long addr,
         return status;
 }
 
-
-static int ti_download_firmware(struct ti_device *tdev,
-                                char *fw_name)
+static int ti_do_download(struct usb_device *dev, int pipe,
+                                                u8 *buffer, int size)
 {
-        const struct firmware *fw;
-        int status = 0;
-        int buffer_size;
         int pos;
-        int len;
+        u8 cs = 0;
         int done;
-        __u8 cs = 0;
-        __u8 *buffer;
-        struct usb_device *dev = tdev->td_serial->dev;
         struct ti_firmware_header *header;
-        unsigned int pipe = usb_sndbulkpipe(dev,
-                tdev->td_serial->port[0]->bulk_out_endpointAddress);
-
-        buffer_size = TI_FIRMWARE_BUF_SIZE + sizeof(struct ti_firmware_header);
-
-        if (request_firmware(&fw, fw_name, &dev->dev)) {
-                dev_err(&dev->dev, "%s - failed to load firmware \"%s\"\n",
-                        __func__, fw_name);
-                return -ENOENT;
-        }
-        if (fw->size > buffer_size) {
-                dev_err(&dev->dev, "%s - firmware \"%s\" is too large\n",
-                        __func__, fw_name);
-                release_firmware(fw);
-                return -EINVAL;
-        }
-
-        buffer = kmalloc(buffer_size, GFP_KERNEL);
-        if (!buffer) {
-                dev_err(&dev->dev, "%s - out of memory\n", __func__);
-                release_firmware(fw);
-                return -ENOMEM;
-        }
-
-        memcpy(buffer, fw->data, fw->size);
-        memset(buffer+fw->size, 0xff, buffer_size-fw->size);
-
-        for(pos = sizeof(struct ti_firmware_header); pos < buffer_size; pos++)
+        int status;
+        int len;
+        
+        for(pos = sizeof(struct ti_firmware_header); pos < size; pos++)
                 cs = (__u8)(cs + buffer[pos]);
 
         header = (struct ti_firmware_header *)buffer;
-        header->wLength = cpu_to_le16((__u16)(buffer_size - sizeof(struct ti_firmware_header)));
+        header->wLength = cpu_to_le16((__u16)(size 
+                                        - sizeof(struct ti_firmware_header)));
         header->bCheckSum = cs;
 
         dbg("%s - downloading firmware", __func__);
-        for (pos = 0; pos < buffer_size; pos += done) {
-                len = min(buffer_size - pos, TI_DOWNLOAD_MAX_PACKET_SIZE);
-                status = usb_bulk_msg(dev, pipe, buffer+pos, len, &done, 1000);
+        for (pos = 0; pos < size; pos += done) {
+                len = min(size - pos, TI_DOWNLOAD_MAX_PACKET_SIZE);
+                status = usb_bulk_msg(dev, pipe, buffer + pos, len,
+                                                                &done, 1000);
                 if (status)
                         break;
         }
+        return status;
+}
 
-        kfree(buffer);
-        release_firmware(fw);
+static int ti_download_firmware(struct ti_device *tdev, int type)
+{
+        int status = -ENOMEM;
+        int buffer_size;
+        __u8 *buffer;
+        struct usb_device *dev = tdev->td_serial->dev;
+        unsigned int pipe = usb_sndbulkpipe(dev,
+                tdev->td_serial->port[0]->bulk_out_endpointAddress);
+        const struct firmware *fw_p;
+        char buf[32];
+        sprintf(buf, "ti_usb-%d.bin", type);
 
+        if (request_firmware(&fw_p, buf, &dev->dev)) {
+                dev_err(&dev->dev, "%s - firmware not found\n", __func__);
+                return -ENOENT;
+        }
+        if (fw_p->size > TI_FIRMWARE_BUF_SIZE) {
+                dev_err(&dev->dev, "%s - firmware too large\n", __func__);
+                return -ENOENT;
+        }
+
+        buffer_size = TI_FIRMWARE_BUF_SIZE + sizeof(struct ti_firmware_header);
+        buffer = kmalloc(buffer_size, GFP_KERNEL);
+        if (buffer) {
+                memcpy(buffer, fw_p->data, fw_p->size);
+                memset(buffer + fw_p->size, 0xff, buffer_size - fw_p->size);
+                ti_do_download(dev, pipe, buffer, fw_p->size);
+                kfree(buffer);
+        }
+        release_firmware(fw_p);
         if (status) {
                 dev_err(&dev->dev, "%s - error downloading firmware, %d\n", __func__, status);
                 return status;
diff --git a/drivers/usb/serial/usb-serial.c b/drivers/usb/serial/usb-serial.c
index 353798631903..ffaed8ace066 100644
--- a/drivers/usb/serial/usb-serial.c
+++ b/drivers/usb/serial/usb-serial.c
@@ -143,7 +143,7 @@ static void destroy_serial(struct kref *kref)
         return_serial(serial);
 
         for (i = 0; i < serial->num_ports; ++i)
-                serial->port[i]->open_count = 0;
+                serial->port[i]->port.count = 0;
 
         /* the ports are cleaned up and released in port_release() */
         for (i = 0; i < serial->num_ports; ++i)
@@ -208,14 +208,14 @@ static int serial_open (struct tty_struct *tty, struct file * filp)
                 goto bailout_kref_put;
         }
          
-        ++port->open_count;
+        ++port->port.count;
 
         /* set up our port structure making the tty driver
          * remember our port object, and us it */
         tty->driver_data = port;
-        port->tty = tty;
+        port->port.tty = tty;
 
-        if (port->open_count == 1) {
+        if (port->port.count == 1) {
 
                 /* lock this module before we call it
                  * this may fail, which means we must bail out,
@@ -230,7 +230,7 @@ static int serial_open (struct tty_struct *tty, struct file * filp)
                         goto bailout_module_put;
                 /* only call the device specific open if this 
                  * is the first time the port is opened */
-                retval = serial->type->open(port, filp);
+                retval = serial->type->open(tty, port, filp);
                 if (retval)
                         goto bailout_interface_put;
         }
@@ -243,9 +243,9 @@ bailout_interface_put:
 bailout_module_put:
         module_put(serial->type->driver.owner);
 bailout_mutex_unlock:
-        port->open_count = 0;
+        port->port.count = 0;
         tty->driver_data = NULL;
-        port->tty = NULL;
+        port->port.tty = NULL;
         mutex_unlock(&port->mutex);
 bailout_kref_put:
         usb_serial_put(serial);
@@ -263,26 +263,26 @@ static void serial_close(struct tty_struct *tty, struct file * filp)
 
         mutex_lock(&port->mutex);
 
-        if (port->open_count == 0) {
+        if (port->port.count == 0) {
                 mutex_unlock(&port->mutex);
                 return;
         }
 
-        --port->open_count;
-        if (port->open_count == 0)
+        --port->port.count;
+        if (port->port.count == 0)
                 /* only call the device specific close if this 
                  * port is being closed by the last owner */
-                port->serial->type->close(port, filp);
+                port->serial->type->close(tty, port, filp);
 
-        if (port->open_count == (port->console? 1 : 0)) {
-                if (port->tty) {
-                        if (port->tty->driver_data)
-                                port->tty->driver_data = NULL;
-                        port->tty = NULL;
+        if (port->port.count == (port->console? 1 : 0)) {
+                if (port->port.tty) {
+                        if (port->port.tty->driver_data)
+                                port->port.tty->driver_data = NULL;
+                        port->port.tty = NULL;
                 }
         }
 
-        if (port->open_count == 0) {
+        if (port->port.count == 0) {
                 mutex_lock(&port->serial->disc_mutex);
                 if (!port->serial->disconnected)
                         usb_autopm_put_interface(port->serial->interface);
@@ -304,12 +304,12 @@ static int serial_write (struct tty_struct * tty, const unsigned char *buf, int
 
         dbg("%s - port %d, %d byte(s)", __func__, port->number, count);
 
-        /* open_count is managed under the mutex lock for the tty so cannot
+        /* count is managed under the mutex lock for the tty so cannot
            drop to zero until after the last close completes */
-        WARN_ON(!port->open_count);
+        WARN_ON(!port->port.count);
 
         /* pass on to the driver specific version of this function */
-        retval = port->serial->type->write(port, buf, count);
+        retval = port->serial->type->write(tty, port, buf, count);
 
 exit:
         return retval;
@@ -319,9 +319,9 @@ static int serial_write_room (struct tty_struct *tty)
 {
         struct usb_serial_port *port = tty->driver_data;
         dbg("%s - port %d", __func__, port->number);
-        WARN_ON(!port->open_count);
+        WARN_ON(!port->port.count);
         /* pass on to the driver specific version of this function */
-        return port->serial->type->write_room(port);
+        return port->serial->type->write_room(tty);
 }
 
 static int serial_chars_in_buffer (struct tty_struct *tty) 
@@ -329,9 +329,9 @@ static int serial_chars_in_buffer (struct tty_struct *tty)
         struct usb_serial_port *port = tty->driver_data;
         dbg("%s = port %d", __func__, port->number);
 
-        WARN_ON(!port->open_count);
+        WARN_ON(!port->port.count);
         /* pass on to the driver specific version of this function */
-        return port->serial->type->chars_in_buffer(port);
+        return port->serial->type->chars_in_buffer(tty);
 }
 
 static void serial_throttle (struct tty_struct * tty)
@@ -339,10 +339,10 @@ static void serial_throttle (struct tty_struct * tty)
         struct usb_serial_port *port = tty->driver_data;
         dbg("%s - port %d", __func__, port->number);
 
-        WARN_ON(!port->open_count);
+        WARN_ON(!port->port.count);
         /* pass on to the driver specific version of this function */
         if (port->serial->type->throttle)
-                port->serial->type->throttle(port);
+                port->serial->type->throttle(tty);
 }
 
 static void serial_unthrottle (struct tty_struct * tty)
@@ -350,10 +350,10 @@ static void serial_unthrottle (struct tty_struct * tty)
         struct usb_serial_port *port = tty->driver_data;
         dbg("%s - port %d", __func__, port->number);
 
-        WARN_ON(!port->open_count);
+        WARN_ON(!port->port.count);
         /* pass on to the driver specific version of this function */
         if (port->serial->type->unthrottle)
-                port->serial->type->unthrottle(port);
+                port->serial->type->unthrottle(tty);
 }
 
 static int serial_ioctl (struct tty_struct *tty, struct file * file, unsigned int cmd, unsigned long arg)
@@ -363,12 +363,12 @@ static int serial_ioctl (struct tty_struct *tty, struct file * file, unsigned in
 
         dbg("%s - port %d, cmd 0x%.4x", __func__, port->number, cmd);
 
-        WARN_ON(!port->open_count);
+        WARN_ON(!port->port.count);
 
         /* pass on to the driver specific version of this function if it is available */
         if (port->serial->type->ioctl) {
                 lock_kernel();
-                retval = port->serial->type->ioctl(port, file, cmd, arg);
+                retval = port->serial->type->ioctl(tty, file, cmd, arg);
                 unlock_kernel();
         }
         else
@@ -381,10 +381,10 @@ static void serial_set_termios (struct tty_struct *tty, struct ktermios * old)
         struct usb_serial_port *port = tty->driver_data;
         dbg("%s - port %d", __func__, port->number);
 
-        WARN_ON(!port->open_count);
+        WARN_ON(!port->port.count);
         /* pass on to the driver specific version of this function if it is available */
         if (port->serial->type->set_termios)
-                port->serial->type->set_termios(port, old);
+                port->serial->type->set_termios(tty, port, old);
         else
                 tty_termios_copy_hw(tty->termios, old);
 }
@@ -395,11 +395,11 @@ static void serial_break (struct tty_struct *tty, int break_state)
 
         dbg("%s - port %d", __func__, port->number);
 
-        WARN_ON(!port->open_count);
+        WARN_ON(!port->port.count);
         /* pass on to the driver specific version of this function if it is available */
         if (port->serial->type->break_ctl) {
                 lock_kernel();
-                port->serial->type->break_ctl(port, break_state);
+                port->serial->type->break_ctl(tty, break_state);
                 unlock_kernel();
         }
 }
@@ -457,9 +457,9 @@ static int serial_tiocmget (struct tty_struct *tty, struct file *file)
 
         dbg("%s - port %d", __func__, port->number);
 
-        WARN_ON(!port->open_count);
+        WARN_ON(!port->port.count);
         if (port->serial->type->tiocmget)
-                return port->serial->type->tiocmget(port, file);
+                return port->serial->type->tiocmget(tty, file);
         return -EINVAL;
 }
 
@@ -470,9 +470,9 @@ static int serial_tiocmset (struct tty_struct *tty, struct file *file,
 
         dbg("%s - port %d", __func__, port->number);
 
-        WARN_ON(!port->open_count);
+        WARN_ON(!port->port.count);
         if (port->serial->type->tiocmset)
-                return port->serial->type->tiocmset(port, file, set, clear);
+                return port->serial->type->tiocmset(tty, file, set, clear);
         return -EINVAL;
 }
 
@@ -497,7 +497,7 @@ static void usb_serial_port_work(struct work_struct *work)
         if (!port)
                 return;
 
-        tty = port->tty;
+        tty = port->port.tty;
         if (!tty)
                 return;
 
@@ -1010,8 +1010,8 @@ void usb_serial_disconnect(struct usb_interface *interface)
         for (i = 0; i < serial->num_ports; ++i) {
                 port = serial->port[i];
                 if (port) {
-                        if (port->tty)
-                                tty_hangup(port->tty);
+                        if (port->port.tty)
+                                tty_hangup(port->port.tty);
                         kill_traffic(port);
                 }
         }
diff --git a/drivers/usb/serial/usb_debug.c b/drivers/usb/serial/usb_debug.c
index 9ca4d4db1ddd..fc5d9952b03b 100644
--- a/drivers/usb/serial/usb_debug.c
+++ b/drivers/usb/serial/usb_debug.c
@@ -31,10 +31,11 @@ static struct usb_driver debug_driver = {
         .no_dynamic_id =        1,
 };
 
-int usb_debug_open(struct usb_serial_port *port, struct file *filp)
+int usb_debug_open(struct tty_struct *tty, struct usb_serial_port *port,
+                                                        struct file *filp)
 {
         port->bulk_out_size = USB_DEBUG_MAX_PACKET_SIZE;
-        return usb_serial_generic_open(port, filp);
+        return usb_serial_generic_open(tty, port, filp);
 }
 
 static struct usb_serial_driver debug_device = {
diff --git a/drivers/usb/serial/visor.c b/drivers/usb/serial/visor.c
index 5fc20122145f..373a3c7ea77b 100644
--- a/drivers/usb/serial/visor.c
+++ b/drivers/usb/serial/visor.c
@@ -35,17 +35,15 @@
 #define DRIVER_DESC "USB HandSpring Visor / Palm OS driver"
 
 /* function prototypes for a handspring visor */
-static int  visor_open          (struct usb_serial_port *port, struct file *filp);
-static void visor_close         (struct usb_serial_port *port, struct file *filp);
-static int  visor_write         (struct usb_serial_port *port, const unsigned char *buf, int count);
-static int  visor_write_room            (struct usb_serial_port *port);
-static int  visor_chars_in_buffer       (struct usb_serial_port *port);
-static void visor_throttle      (struct usb_serial_port *port);
-static void visor_unthrottle    (struct usb_serial_port *port);
+static int  visor_open          (struct tty_struct *tty, struct usb_serial_port *port, struct file *filp);
+static void visor_close         (struct tty_struct *tty, struct usb_serial_port *port, struct file *filp);
+static int  visor_write         (struct tty_struct *tty, struct usb_serial_port *port, const unsigned char *buf, int count);
+static int  visor_write_room    (struct tty_struct *tty);
+static void visor_throttle      (struct tty_struct *tty);
+static void visor_unthrottle    (struct tty_struct *tty);
 static int  visor_probe         (struct usb_serial *serial, const struct usb_device_id *id);
 static int  visor_calc_num_ports(struct usb_serial *serial);
 static void visor_shutdown      (struct usb_serial *serial);
-static int  visor_ioctl         (struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg);
 static void visor_write_bulk_callback   (struct urb *urb);
 static void visor_read_bulk_callback    (struct urb *urb);
 static void visor_read_int_callback     (struct urb *urb);
@@ -198,10 +196,8 @@ static struct usb_serial_driver handspring_device = {
         .probe =                visor_probe,
         .calc_num_ports =       visor_calc_num_ports,
         .shutdown =             visor_shutdown,
-        .ioctl =                visor_ioctl,
         .write =                visor_write,
         .write_room =           visor_write_room,
-        .chars_in_buffer =      visor_chars_in_buffer,
         .write_bulk_callback =  visor_write_bulk_callback,
         .read_bulk_callback =   visor_read_bulk_callback,
         .read_int_callback =    visor_read_int_callback,
@@ -225,10 +221,8 @@ static struct usb_serial_driver clie_5_device = {
         .probe =                visor_probe,
         .calc_num_ports =       visor_calc_num_ports,
         .shutdown =             visor_shutdown,
-        .ioctl =                visor_ioctl,
         .write =                visor_write,
         .write_room =           visor_write_room,
-        .chars_in_buffer =      visor_chars_in_buffer,
         .write_bulk_callback =  visor_write_bulk_callback,
         .read_bulk_callback =   visor_read_bulk_callback,
         .read_int_callback =    visor_read_int_callback,
@@ -249,10 +243,8 @@ static struct usb_serial_driver clie_3_5_device = {
         .throttle =             visor_throttle,
         .unthrottle =           visor_unthrottle,
         .attach =               clie_3_5_startup,
-        .ioctl =                visor_ioctl,
         .write =                visor_write,
         .write_room =           visor_write_room,
-        .chars_in_buffer =      visor_chars_in_buffer,
         .write_bulk_callback =  visor_write_bulk_callback,
         .read_bulk_callback =   visor_read_bulk_callback,
 };
@@ -274,7 +266,7 @@ static int stats;
 /******************************************************************************
  * Handspring Visor specific driver functions
  ******************************************************************************/
-static int visor_open (struct usb_serial_port *port, struct file *filp)
+static int visor_open (struct tty_struct *tty, struct usb_serial_port *port, struct file *filp)
 {
         struct usb_serial *serial = port->serial;
         struct visor_private *priv = usb_get_serial_port_data(port);
@@ -300,8 +292,8 @@ static int visor_open (struct usb_serial_port *port, struct file *filp)
          * through, otherwise it is scheduled, and with high data rates (like
          * with OHCI) data can get lost.
          */
-        if (port->tty)
-                port->tty->low_latency = 1;
+        if (tty)
+                tty->low_latency = 1;
 
         /* Start reading from the device */
         usb_fill_bulk_urb (port->read_urb, serial->dev,
@@ -329,7 +321,8 @@ exit:
 }
 
 
-static void visor_close (struct usb_serial_port *port, struct file * filp)
+static void visor_close(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file * filp)
 {
         struct visor_private *priv = usb_get_serial_port_data(port);
         unsigned char *transfer_buffer;
@@ -361,7 +354,8 @@ static void visor_close (struct usb_serial_port *port, struct file * filp)
 }
 
 
-static int visor_write (struct usb_serial_port *port, const unsigned char *buf, int count)
+static int visor_write(struct tty_struct *tty, struct usb_serial_port *port,
+                                        const unsigned char *buf, int count)
 {
         struct visor_private *priv = usb_get_serial_port_data(port);
         struct usb_serial *serial = port->serial;
@@ -435,8 +429,9 @@ error_no_buffer:
 }
 
 
-static int visor_write_room (struct usb_serial_port *port)
+static int visor_write_room (struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct visor_private *priv = usb_get_serial_port_data(port);
         unsigned long flags;
 
@@ -460,22 +455,6 @@ static int visor_write_room (struct usb_serial_port *port)
 }
 
 
-static int visor_chars_in_buffer (struct usb_serial_port *port)
-{
-        dbg("%s - port %d", __func__, port->number);
-
-        /* 
-         * We can't really account for how much data we
-         * have sent out, but hasn't made it through to the
-         * device, so just tell the tty layer that everything
-         * is flushed.
-         *
-         * FIXME: Should walk outstanding_urbs
-         */
-        return 0;
-}
-
-
 static void visor_write_bulk_callback (struct urb *urb)
 {
         struct usb_serial_port *port = urb->context;
@@ -520,7 +499,7 @@ static void visor_read_bulk_callback (struct urb *urb)
 
         usb_serial_debug_data(debug, &port->dev, __func__, urb->actual_length, data);
 
-        tty = port->tty;
+        tty = port->port.tty;
         if (tty && urb->actual_length) {
                 available_room = tty_buffer_request_room(tty, urb->actual_length);
                 if (available_room) {
@@ -591,8 +570,9 @@ exit:
                         __func__, result);
 }
 
-static void visor_throttle (struct usb_serial_port *port)
+static void visor_throttle (struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct visor_private *priv = usb_get_serial_port_data(port);
         unsigned long flags;
 
@@ -603,8 +583,9 @@ static void visor_throttle (struct usb_serial_port *port)
 }
 
 
-static void visor_unthrottle (struct usb_serial_port *port)
+static void visor_unthrottle (struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct visor_private *priv = usb_get_serial_port_data(port);
         unsigned long flags;
         int result;
@@ -922,13 +903,6 @@ static void visor_shutdown (struct usb_serial *serial)
         }
 }
 
-static int visor_ioctl (struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg)
-{
-        dbg("%s - port %d, cmd 0x%.4x", __func__, port->number, cmd);
-
-        return -ENOIOCTLCMD;
-}
-
 static int __init visor_init (void)
 {
         int i, retval;
diff --git a/drivers/usb/serial/whiteheat.c b/drivers/usb/serial/whiteheat.c
index 665aa77a917b..b07d6a5cac31 100644
--- a/drivers/usb/serial/whiteheat.c
+++ b/drivers/usb/serial/whiteheat.c
@@ -142,18 +142,18 @@ static int  whiteheat_firmware_attach	(struct usb_serial *serial);
 /* function prototypes for the Connect Tech WhiteHEAT serial converter */
 static int  whiteheat_attach            (struct usb_serial *serial);
 static void whiteheat_shutdown          (struct usb_serial *serial);
-static int  whiteheat_open              (struct usb_serial_port *port, struct file *filp);
-static void whiteheat_close             (struct usb_serial_port *port, struct file *filp);
-static int  whiteheat_write             (struct usb_serial_port *port, const unsigned char *buf, int count);
-static int  whiteheat_write_room        (struct usb_serial_port *port);
-static int  whiteheat_ioctl             (struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg);
-static void whiteheat_set_termios       (struct usb_serial_port *port, struct ktermios * old);
-static int  whiteheat_tiocmget          (struct usb_serial_port *port, struct file *file);
-static int  whiteheat_tiocmset          (struct usb_serial_port *port, struct file *file, unsigned int set, unsigned int clear);
-static void whiteheat_break_ctl         (struct usb_serial_port *port, int break_state);
-static int  whiteheat_chars_in_buffer   (struct usb_serial_port *port);
-static void whiteheat_throttle          (struct usb_serial_port *port);
-static void whiteheat_unthrottle        (struct usb_serial_port *port);
+static int  whiteheat_open              (struct tty_struct *tty, struct usb_serial_port *port, struct file *filp);
+static void whiteheat_close             (struct tty_struct *tty, struct usb_serial_port *port, struct file *filp);
+static int  whiteheat_write             (struct tty_struct *tty, struct usb_serial_port *port, const unsigned char *buf, int count);
+static int  whiteheat_write_room        (struct tty_struct *tty);
+static int  whiteheat_ioctl             (struct tty_struct *tty, struct file * file, unsigned int cmd, unsigned long arg);
+static void whiteheat_set_termios       (struct tty_struct *tty, struct usb_serial_port *port, struct ktermios * old);
+static int  whiteheat_tiocmget          (struct tty_struct *tty, struct file *file);
+static int  whiteheat_tiocmset          (struct tty_struct *tty, struct file *file, unsigned int set, unsigned int clear);
+static void whiteheat_break_ctl         (struct tty_struct *tty, int break_state);
+static int  whiteheat_chars_in_buffer   (struct tty_struct *tty);
+static void whiteheat_throttle          (struct tty_struct *tty);
+static void whiteheat_unthrottle        (struct tty_struct *tty);
 static void whiteheat_read_callback     (struct urb *urb);
 static void whiteheat_write_callback    (struct urb *urb);
 
@@ -246,7 +246,7 @@ static void rx_data_softint(struct work_struct *work);
 static int firm_send_command(struct usb_serial_port *port, __u8 command, __u8 *data, __u8 datasize);
 static int firm_open(struct usb_serial_port *port);
 static int firm_close(struct usb_serial_port *port);
-static int firm_setup_port(struct usb_serial_port *port);
+static int firm_setup_port(struct tty_struct *tty);
 static int firm_set_rts(struct usb_serial_port *port, __u8 onoff);
 static int firm_set_dtr(struct usb_serial_port *port, __u8 onoff);
 static int firm_set_break(struct usb_serial_port *port, __u8 onoff);
@@ -613,7 +613,8 @@ static void whiteheat_shutdown (struct usb_serial *serial)
 }
 
 
-static int whiteheat_open (struct usb_serial_port *port, struct file *filp)
+static int whiteheat_open (struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 {
         int             retval = 0;
         struct ktermios old_term;
@@ -624,7 +625,8 @@ static int whiteheat_open (struct usb_serial_port *port, struct file *filp)
         if (retval)
                 goto exit;
 
-        port->tty->low_latency = 1;
+        if (tty)
+                tty->low_latency = 1;
 
         /* send an open port command */
         retval = firm_open(port);
@@ -640,9 +642,11 @@ static int whiteheat_open (struct usb_serial_port *port, struct file *filp)
                 goto exit;
         }
 
-        old_term.c_cflag = ~port->tty->termios->c_cflag;
-        old_term.c_iflag = ~port->tty->termios->c_iflag;
-        whiteheat_set_termios(port, &old_term);
+        if (tty) {
+                old_term.c_cflag = ~tty->termios->c_cflag;
+                old_term.c_iflag = ~tty->termios->c_iflag;
+                whiteheat_set_termios(tty, port, &old_term);
+        }
 
         /* Work around HCD bugs */
         usb_clear_halt(port->serial->dev, port->read_urb->pipe);
@@ -663,7 +667,8 @@ exit:
 }
 
 
-static void whiteheat_close(struct usb_serial_port *port, struct file * filp)
+static void whiteheat_close(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file * filp)
 {
         struct whiteheat_private *info = usb_get_serial_port_data(port);
         struct whiteheat_urb_wrap *wrap;
@@ -681,7 +686,7 @@ static void whiteheat_close(struct usb_serial_port *port, struct file * filp)
         }
         mutex_unlock(&port->serial->disc_mutex);
 
-        port->tty->closing = 1;
+        tty->closing = 1;
 
 /*
  * Not currently in use; tty_wait_until_sent() calls
@@ -689,12 +694,12 @@ static void whiteheat_close(struct usb_serial_port *port, struct file * filp)
  * acquisition. This should be fixed at some point. Greg's been
  * notified.
         if ((filp->f_flags & (O_NDELAY | O_NONBLOCK)) == 0) {
-                tty_wait_until_sent(port->tty, CLOSING_DELAY);
+                tty_wait_until_sent(tty, CLOSING_DELAY);
         }
 */
 
-        tty_driver_flush_buffer(port->tty);
-        tty_ldisc_flush(port->tty);
+        tty_driver_flush_buffer(tty);
+        tty_ldisc_flush(tty);
 
         firm_report_tx_done(port);
 
@@ -728,11 +733,12 @@ static void whiteheat_close(struct usb_serial_port *port, struct file * filp)
 
         stop_command_port(port->serial);
 
-        port->tty->closing = 0;
+        tty->closing = 0;
 }
 
 
-static int whiteheat_write(struct usb_serial_port *port, const unsigned char *buf, int count)
+static int whiteheat_write(struct tty_struct *tty,
+        struct usb_serial_port *port, const unsigned char *buf, int count)
 {
         struct usb_serial *serial = port->serial;
         struct whiteheat_private *info = usb_get_serial_port_data(port);
@@ -791,8 +797,9 @@ static int whiteheat_write(struct usb_serial_port *port, const unsigned char *bu
 }
 
 
-static int whiteheat_write_room(struct usb_serial_port *port)
+static int whiteheat_write_room(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct whiteheat_private *info = usb_get_serial_port_data(port);
         struct list_head *tmp;
         int room = 0;
@@ -811,8 +818,9 @@ static int whiteheat_write_room(struct usb_serial_port *port)
 }
 
 
-static int whiteheat_tiocmget (struct usb_serial_port *port, struct file *file)
+static int whiteheat_tiocmget (struct tty_struct *tty, struct file *file)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct whiteheat_private *info = usb_get_serial_port_data(port);
         unsigned int modem_signals = 0;
 
@@ -828,9 +836,10 @@ static int whiteheat_tiocmget (struct usb_serial_port *port, struct file *file)
 }
 
 
-static int whiteheat_tiocmset (struct usb_serial_port *port, struct file *file,
+static int whiteheat_tiocmset (struct tty_struct *tty, struct file *file,
                                unsigned int set, unsigned int clear)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct whiteheat_private *info = usb_get_serial_port_data(port);
 
         dbg("%s - port %d", __func__, port->number);
@@ -851,8 +860,9 @@ static int whiteheat_tiocmset (struct usb_serial_port *port, struct file *file,
 }
 
 
-static int whiteheat_ioctl (struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg)
+static int whiteheat_ioctl (struct tty_struct *tty, struct file * file, unsigned int cmd, unsigned long arg)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct serial_struct serstruct;
         void __user *user_arg = (void __user *)arg;
 
@@ -896,20 +906,21 @@ static int whiteheat_ioctl (struct usb_serial_port *port, struct file * file, un
 }
 
 
-static void whiteheat_set_termios(struct usb_serial_port *port, struct ktermios *old_termios)
+static void whiteheat_set_termios(struct tty_struct *tty, struct usb_serial_port *port, struct ktermios *old_termios)
 {
-        dbg("%s -port %d", __func__, port->number);
-        firm_setup_port(port);
+        firm_setup_port(tty);
 }
 
 
-static void whiteheat_break_ctl(struct usb_serial_port *port, int break_state) {
+static void whiteheat_break_ctl(struct tty_struct *tty, int break_state) {
+        struct usb_serial_port *port = tty->driver_data;
         firm_set_break(port, break_state);
 }
 
 
-static int whiteheat_chars_in_buffer(struct usb_serial_port *port)
+static int whiteheat_chars_in_buffer(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct whiteheat_private *info = usb_get_serial_port_data(port);
         struct list_head *tmp;
         struct whiteheat_urb_wrap *wrap;
@@ -930,8 +941,9 @@ static int whiteheat_chars_in_buffer(struct usb_serial_port *port)
 }
 
 
-static void whiteheat_throttle (struct usb_serial_port *port)
+static void whiteheat_throttle (struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct whiteheat_private *info = usb_get_serial_port_data(port);
         unsigned long flags;
 
@@ -945,8 +957,9 @@ static void whiteheat_throttle (struct usb_serial_port *port)
 }
 
 
-static void whiteheat_unthrottle (struct usb_serial_port *port)
+static void whiteheat_unthrottle (struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct whiteheat_private *info = usb_get_serial_port_data(port);
         int actually_throttled;
         unsigned long flags;
@@ -1184,9 +1197,10 @@ static int firm_close(struct usb_serial_port *port) {
 }
 
 
-static int firm_setup_port(struct usb_serial_port *port) {
+static int firm_setup_port(struct tty_struct *tty) {
+        struct usb_serial_port *port = tty->driver_data;
         struct whiteheat_port_settings port_settings;
-        unsigned int cflag = port->tty->termios->c_cflag;
+        unsigned int cflag = tty->termios->c_cflag;
 
         port_settings.port = port->number + 1;
 
@@ -1235,22 +1249,22 @@ static int firm_setup_port(struct usb_serial_port *port) {
             (port_settings.hflow & WHITEHEAT_HFLOW_DTR) ? "DTR" : "");
         
         /* determine software flow control */
-        if (I_IXOFF(port->tty))
+        if (I_IXOFF(tty))
                 port_settings.sflow = WHITEHEAT_SFLOW_RXTX;
         else
                 port_settings.sflow = WHITEHEAT_SFLOW_NONE;
         dbg("%s - software flow control = %c", __func__, port_settings.sflow);
         
-        port_settings.xon = START_CHAR(port->tty);
-        port_settings.xoff = STOP_CHAR(port->tty);
+        port_settings.xon = START_CHAR(tty);
+        port_settings.xoff = STOP_CHAR(tty);
         dbg("%s - XON = %2x, XOFF = %2x", __func__, port_settings.xon, port_settings.xoff);
 
         /* get the baud rate wanted */
-        port_settings.baud = tty_get_baud_rate(port->tty);
+        port_settings.baud = tty_get_baud_rate(tty);
         dbg("%s - baud rate = %d", __func__, port_settings.baud);
 
         /* fixme: should set validated settings */
-        tty_encode_baud_rate(port->tty, port_settings.baud, port_settings.baud);
+        tty_encode_baud_rate(tty, port_settings.baud, port_settings.baud);
         /* handle any settings that aren't specified in the tty structure */
         port_settings.lloop = 0;
         
@@ -1426,7 +1440,7 @@ static void rx_data_softint(struct work_struct *work)
         struct whiteheat_private *info =
                 container_of(work, struct whiteheat_private, rx_work);
         struct usb_serial_port *port = info->port;
-        struct tty_struct *tty = port->tty;
+        struct tty_struct *tty = port->port.tty;
         struct whiteheat_urb_wrap *wrap;
         struct urb *urb;
         unsigned long flags;