TTY: call tty_port_destroy in the rest of drivers
[linux-3.10.git] / drivers / usb / serial / usb-serial.c
index 742a5bc..64bda13 100644 (file)
@@ -1,7 +1,7 @@
 /*
  * USB Serial Converter driver
  *
- * Copyright (C) 1999 - 2005 Greg Kroah-Hartman (greg@kroah.com)
+ * Copyright (C) 1999 - 2012 Greg Kroah-Hartman (greg@kroah.com)
  * Copyright (C) 2000 Peter Berger (pberger@brimson.com)
  * Copyright (C) 2000 Al Borchers (borchers@steinerpoint.com)
  *
@@ -17,6 +17,8 @@
  *
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/errno.h>
 #include <linux/init.h>
 #include <linux/tty_flip.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
+#include <linux/seq_file.h>
 #include <linux/spinlock.h>
 #include <linux/mutex.h>
 #include <linux/list.h>
 #include <linux/uaccess.h>
+#include <linux/serial.h>
 #include <linux/usb.h>
 #include <linux/usb/serial.h>
+#include <linux/kfifo.h>
 #include "pl2303.h"
 
-/*
- * Version Information
- */
-#define DRIVER_AUTHOR "Greg Kroah-Hartman, greg@kroah.com, http://www.kroah.com/linux/"
+#define DRIVER_AUTHOR "Greg Kroah-Hartman <gregkh@linuxfoundation.org>"
 #define DRIVER_DESC "USB Serial Driver core"
 
-static void port_free(struct usb_serial_port *port);
-
-/* Driver structure we register with the USB core */
-static struct usb_driver usb_serial_driver = {
-       .name =         "usbserial",
-       .probe =        usb_serial_probe,
-       .disconnect =   usb_serial_disconnect,
-       .suspend =      usb_serial_suspend,
-       .resume =       usb_serial_resume,
-       .no_dynamic_id =        1,
-};
-
 /* There is no MODULE_DEVICE_TABLE for usbserial.c.  Instead
    the MODULE_DEVICE_TABLE declarations in each serial driver
    cause the "hotplug" program to pull in whatever module is necessary
@@ -59,12 +49,16 @@ static struct usb_driver usb_serial_driver = {
    drivers depend on it.
 */
 
-static int debug;
 /* initially all NULL */
 static struct usb_serial *serial_table[SERIAL_TTY_MINORS];
 static DEFINE_MUTEX(table_lock);
 static LIST_HEAD(usb_serial_driver_list);
 
+/*
+ * Look up the serial structure.  If it is found and it hasn't been
+ * disconnected, return with its disc_mutex held and its refcount
+ * incremented.  Otherwise return NULL.
+ */
 struct usb_serial *usb_serial_get_by_index(unsigned index)
 {
        struct usb_serial *serial;
@@ -72,8 +66,15 @@ struct usb_serial *usb_serial_get_by_index(unsigned index)
        mutex_lock(&table_lock);
        serial = serial_table[index];
 
-       if (serial)
-               kref_get(&serial->kref);
+       if (serial) {
+               mutex_lock(&serial->disc_mutex);
+               if (serial->disconnected) {
+                       mutex_unlock(&serial->disc_mutex);
+                       serial = NULL;
+               } else {
+                       kref_get(&serial->kref);
+               }
+       }
        mutex_unlock(&table_lock);
        return serial;
 }
@@ -84,7 +85,7 @@ static struct usb_serial *get_free_serial(struct usb_serial *serial,
        unsigned int i, j;
        int good_spot;
 
-       dbg("%s %d", __func__, num_ports);
+       dev_dbg(&serial->interface->dev, "%s %d\n", __func__, num_ports);
 
        *minor = 0;
        mutex_lock(&table_lock);
@@ -104,7 +105,7 @@ static struct usb_serial *get_free_serial(struct usb_serial *serial,
 
                *minor = i;
                j = 0;
-               dbg("%s - minor base = %d", __func__, *minor);
+               dev_dbg(&serial->interface->dev, "%s - minor base = %d\n", __func__, *minor);
                for (i = *minor; (i < (*minor + num_ports)) && (i < SERIAL_TTY_MINORS); ++i) {
                        serial_table[i] = serial;
                        serial->port[j++]->number = i;
@@ -120,10 +121,10 @@ static void return_serial(struct usb_serial *serial)
 {
        int i;
 
-       dbg("%s", __func__);
-
+       mutex_lock(&table_lock);
        for (i = 0; i < serial->num_ports; ++i)
                serial_table[serial->minor + i] = NULL;
+       mutex_unlock(&table_lock);
 }
 
 static void destroy_serial(struct kref *kref)
@@ -134,177 +135,198 @@ static void destroy_serial(struct kref *kref)
 
        serial = to_usb_serial(kref);
 
-       dbg("%s - %s", __func__, serial->type->description);
-
-       serial->type->shutdown(serial);
-
        /* return the minor range that this device had */
        if (serial->minor != SERIAL_TTY_NO_MINOR)
                return_serial(serial);
 
-       for (i = 0; i < serial->num_ports; ++i)
-               serial->port[i]->port.count = 0;
-
-       /* the ports are cleaned up and released in port_release() */
-       for (i = 0; i < serial->num_ports; ++i)
-               if (serial->port[i]->dev.parent != NULL) {
-                       device_unregister(&serial->port[i]->dev);
-                       serial->port[i] = NULL;
-               }
+       if (serial->attached)
+               serial->type->release(serial);
 
-       /* If this is a "fake" port, we have to clean it up here, as it will
-        * not get cleaned up in port_release() as it was never registered with
-        * the driver core */
-       if (serial->num_ports < serial->num_port_pointers) {
-               for (i = serial->num_ports;
-                                       i < serial->num_port_pointers; ++i) {
-                       port = serial->port[i];
-                       if (!port)
-                               continue;
-                       port_free(port);
+       /* Now that nothing is using the ports, they can be freed */
+       for (i = 0; i < serial->num_port_pointers; ++i) {
+               port = serial->port[i];
+               if (port) {
+                       port->serial = NULL;
+                       put_device(&port->dev);
                }
        }
 
        usb_put_dev(serial->dev);
-
-       /* free up any memory that we allocated */
        kfree(serial);
 }
 
 void usb_serial_put(struct usb_serial *serial)
 {
-       mutex_lock(&table_lock);
        kref_put(&serial->kref, destroy_serial);
-       mutex_unlock(&table_lock);
 }
 
 /*****************************************************************************
  * Driver tty interface functions
  *****************************************************************************/
-static int serial_open (struct tty_struct *tty, struct file *filp)
+
+/**
+ * serial_install - install tty
+ * @driver: the driver (USB in our case)
+ * @tty: the tty being created
+ *
+ * Create the termios objects for this tty.  We use the default
+ * USB serial settings but permit them to be overridden by
+ * serial->type->init_termios.
+ *
+ * This is the first place a new tty gets used.  Hence this is where we
+ * acquire references to the usb_serial structure and the driver module,
+ * where we store a pointer to the port, and where we do an autoresume.
+ * All these actions are reversed in serial_cleanup().
+ */
+static int serial_install(struct tty_driver *driver, struct tty_struct *tty)
 {
+       int idx = tty->index;
        struct usb_serial *serial;
        struct usb_serial_port *port;
-       unsigned int portNumber;
-       int retval;
+       int retval = -ENODEV;
 
-       dbg("%s", __func__);
+       serial = usb_serial_get_by_index(idx);
+       if (!serial)
+               return retval;
 
-       /* get the serial object associated with this tty pointer */
-       serial = usb_serial_get_by_index(tty->index);
-       if (!serial) {
-               tty->driver_data = NULL;
-               return -ENODEV;
-       }
+       port = serial->port[idx - serial->minor];
+       if (!port)
+               goto error_no_port;
+       if (!try_module_get(serial->type->driver.owner))
+               goto error_module_get;
 
-       portNumber = tty->index - serial->minor;
-       port = serial->port[portNumber];
-       if (!port) {
-               retval = -ENODEV;
-               goto bailout_kref_put;
-       }
+       retval = usb_autopm_get_interface(serial->interface);
+       if (retval)
+               goto error_get_interface;
 
-       if (port->serial->disconnected) {
-               retval = -ENODEV;
-               goto bailout_kref_put;
-       }
+       retval = tty_port_install(&port->port, driver, tty);
+       if (retval)
+               goto error_init_termios;
 
-       if (mutex_lock_interruptible(&port->mutex)) {
-               retval = -ERESTARTSYS;
-               goto bailout_kref_put;
-       }
+       mutex_unlock(&serial->disc_mutex);
 
-       ++port->port.count;
+       /* allow the driver to update the settings */
+       if (serial->type->init_termios)
+               serial->type->init_termios(tty);
 
-       /* set up our port structure making the tty driver
-        * remember our port object, and us it */
        tty->driver_data = port;
-       tty_port_tty_set(&port->port, tty);
-
-       if (port->port.count == 1) {
-
-               /* lock this module before we call it
-                * this may fail, which means we must bail out,
-                * safe because we are called with BKL held */
-               if (!try_module_get(serial->type->driver.owner)) {
-                       retval = -ENODEV;
-                       goto bailout_mutex_unlock;
-               }
-
-               retval = usb_autopm_get_interface(serial->interface);
-               if (retval)
-                       goto bailout_module_put;
-               /* only call the device specific open if this
-                * is the first time the port is opened */
-               retval = serial->type->open(tty, port, filp);
-               if (retval)
-                       goto bailout_interface_put;
-       }
 
-       mutex_unlock(&port->mutex);
-       return 0;
+       return retval;
 
-bailout_interface_put:
+ error_init_termios:
        usb_autopm_put_interface(serial->interface);
-bailout_module_put:
+ error_get_interface:
        module_put(serial->type->driver.owner);
-bailout_mutex_unlock:
-       port->port.count = 0;
-       tty->driver_data = NULL;
-       tty_port_tty_set(&port->port, NULL);
-       mutex_unlock(&port->mutex);
-bailout_kref_put:
+ error_module_get:
+ error_no_port:
        usb_serial_put(serial);
+       mutex_unlock(&serial->disc_mutex);
        return retval;
 }
 
-static void serial_close(struct tty_struct *tty, struct file *filp)
+static int serial_activate(struct tty_port *tport, struct tty_struct *tty)
+{
+       struct usb_serial_port *port =
+               container_of(tport, struct usb_serial_port, port);
+       struct usb_serial *serial = port->serial;
+       int retval;
+
+       mutex_lock(&serial->disc_mutex);
+       if (serial->disconnected)
+               retval = -ENODEV;
+       else
+               retval = port->serial->type->open(tty, port);
+       mutex_unlock(&serial->disc_mutex);
+
+       if (retval < 0)
+               retval = usb_translate_errors(retval);
+
+       return retval;
+}
+
+static int serial_open(struct tty_struct *tty, struct file *filp)
 {
        struct usb_serial_port *port = tty->driver_data;
 
-       if (!port)
+       dev_dbg(tty->dev, "%s - port %d\n", __func__, port->number);
+       return tty_port_open(&port->port, tty, filp);
+}
+
+/**
+ * serial_down - shut down hardware
+ * @tport: tty port to shut down
+ *
+ * Shut down a USB serial port unless it is the console.  We never
+ * shut down the console hardware as it will always be in use. Serialized
+ * against activate by the tport mutex and kept to matching open/close pairs
+ * of calls by the ASYNCB_INITIALIZED flag.
+ */
+static void serial_down(struct tty_port *tport)
+{
+       struct usb_serial_port *port =
+               container_of(tport, struct usb_serial_port, port);
+       struct usb_serial_driver *drv = port->serial->type;
+       /*
+        * The console is magical.  Do not hang up the console hardware
+        * or there will be tears.
+        */
+       if (port->port.console)
                return;
+       if (drv->close)
+               drv->close(port);
+}
+
+static void serial_hangup(struct tty_struct *tty)
+{
+       struct usb_serial_port *port = tty->driver_data;
+
+       dev_dbg(tty->dev, "%s - port %d\n", __func__, port->number);
+       tty_port_hangup(&port->port);
+}
+
+static void serial_close(struct tty_struct *tty, struct file *filp)
+{
+       struct usb_serial_port *port = tty->driver_data;
 
-       dbg("%s - port %d", __func__, port->number);
+       dev_dbg(tty->dev, "%s - port %d\n", __func__, port->number);
+       tty_port_close(&port->port, tty, filp);
+}
 
-       mutex_lock(&port->mutex);
+/**
+ * serial_cleanup - free resources post close/hangup
+ * @port: port to free up
+ *
+ * Do the resource freeing and refcount dropping for the port.
+ * Avoid freeing the console.
+ *
+ * Called asynchronously after the last tty kref is dropped.
+ */
+static void serial_cleanup(struct tty_struct *tty)
+{
+       struct usb_serial_port *port = tty->driver_data;
+       struct usb_serial *serial;
+       struct module *owner;
 
-       if (port->port.count == 0) {
-               mutex_unlock(&port->mutex);
+       /* The console is magical.  Do not hang up the console hardware
+        * or there will be tears.
+        */
+       if (port->port.console)
                return;
-       }
 
-       if (port->port.count == 1)
-               /* only call the device specific close if this
-                * port is being closed by the last owner. Ensure we do
-                * this before we drop the port count. The call is protected
-                * by the port mutex
-                */
-               port->serial->type->close(tty, port, filp);
-
-       if (port->port.count == (port->console ? 2 : 1)) {
-               struct tty_struct *tty = tty_port_tty_get(&port->port);
-               if (tty) {
-                       /* We must do this before we drop the port count to
-                          zero. */
-                       if (tty->driver_data)
-                               tty->driver_data = NULL;
-                       tty_port_tty_set(&port->port, NULL);
-                       tty_kref_put(tty);
-               }
-       }
+       dev_dbg(tty->dev, "%s - port %d\n", __func__, port->number);
 
-       if (port->port.count == 1) {
-               mutex_lock(&port->serial->disc_mutex);
-               if (!port->serial->disconnected)
-                       usb_autopm_put_interface(port->serial->interface);
-               mutex_unlock(&port->serial->disc_mutex);
-               module_put(port->serial->type->driver.owner);
-       }
-       --port->port.count;
+       tty->driver_data = NULL;
+
+       serial = port->serial;
+       owner = serial->type->driver.owner;
 
-       mutex_unlock(&port->mutex);
-       usb_serial_put(port->serial);
+       mutex_lock(&serial->disc_mutex);
+       if (!serial->disconnected)
+               usb_autopm_put_interface(serial->interface);
+       mutex_unlock(&serial->disc_mutex);
+
+       usb_serial_put(serial);
+       module_put(owner);
 }
 
 static int serial_write(struct tty_struct *tty, const unsigned char *buf,
@@ -316,15 +338,13 @@ static int serial_write(struct tty_struct *tty, const unsigned char *buf,
        if (port->serial->dev->state == USB_STATE_NOTATTACHED)
                goto exit;
 
-       dbg("%s - port %d, %d byte(s)", __func__, port->number, count);
-
-       /* count is managed under the mutex lock for the tty so cannot
-          drop to zero until after the last close completes */
-       WARN_ON(!port->port.count);
+       dev_dbg(tty->dev, "%s - port %d, %d byte(s)\n", __func__,
+               port->number, count);
 
        /* pass on to the driver specific version of this function */
        retval = port->serial->type->write(tty, port, buf, count);
-
+       if (retval < 0)
+               retval = usb_translate_errors(retval);
 exit:
        return retval;
 }
@@ -332,8 +352,8 @@ exit:
 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->port.count);
+
+       dev_dbg(tty->dev, "%s - port %d\n", __func__, port->number);
        /* pass on to the driver specific version of this function */
        return port->serial->type->write_room(tty);
 }
@@ -341,9 +361,9 @@ static int serial_write_room(struct tty_struct *tty)
 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->port.count);
+       dev_dbg(tty->dev, "%s - port %d\n", __func__, port->number);
+
        /* if the device was unplugged then any remaining characters
           fell out of the connector ;) */
        if (port->serial->disconnected)
@@ -355,9 +375,9 @@ static int serial_chars_in_buffer(struct tty_struct *tty)
 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->port.count);
+       dev_dbg(tty->dev, "%s - port %d\n", __func__, port->number);
+
        /* pass on to the driver specific version of this function */
        if (port->serial->type->throttle)
                port->serial->type->throttle(tty);
@@ -366,28 +386,27 @@ static void serial_throttle(struct tty_struct *tty)
 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->port.count);
+       dev_dbg(tty->dev, "%s - port %d\n", __func__, port->number);
+
        /* pass on to the driver specific version of this function */
        if (port->serial->type->unthrottle)
                port->serial->type->unthrottle(tty);
 }
 
-static int serial_ioctl(struct tty_struct *tty, struct file *file,
+static int serial_ioctl(struct tty_struct *tty,
                                        unsigned int cmd, unsigned long arg)
 {
        struct usb_serial_port *port = tty->driver_data;
        int retval = -ENODEV;
 
-       dbg("%s - port %d, cmd 0x%.4x", __func__, port->number, cmd);
-
-       WARN_ON(!port->port.count);
+       dev_dbg(tty->dev, "%s - port %d, cmd 0x%.4x\n", __func__,
+               port->number, cmd);
 
        /* pass on to the driver specific version of this function
           if it is available */
        if (port->serial->type->ioctl) {
-               retval = port->serial->type->ioctl(tty, file, cmd, arg);
+               retval = port->serial->type->ioctl(tty, cmd, arg);
        } else
                retval = -ENOIOCTLCMD;
        return retval;
@@ -396,24 +415,23 @@ static int serial_ioctl(struct tty_struct *tty, struct file *file,
 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->port.count);
+       dev_dbg(tty->dev, "%s - port %d\n", __func__, port->number);
+
        /* 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(tty, port, old);
        else
-               tty_termios_copy_hw(tty->termios, old);
+               tty_termios_copy_hw(&tty->termios, old);
 }
 
 static int serial_break(struct tty_struct *tty, int break_state)
 {
        struct usb_serial_port *port = tty->driver_data;
 
-       dbg("%s - port %d", __func__, port->number);
+       dev_dbg(tty->dev, "%s - port %d\n", __func__, port->number);
 
-       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)
@@ -421,79 +439,84 @@ static int serial_break(struct tty_struct *tty, int break_state)
        return 0;
 }
 
-static int serial_read_proc(char *page, char **start, off_t off, int count,
-                                                       int *eof, void *data)
+static int serial_proc_show(struct seq_file *m, void *v)
 {
        struct usb_serial *serial;
-       int length = 0;
        int i;
-       off_t begin = 0;
        char tmp[40];
 
-       dbg("%s", __func__);
-       length += sprintf(page, "usbserinfo:1.0 driver:2.0\n");
-       for (i = 0; i < SERIAL_TTY_MINORS && length < PAGE_SIZE; ++i) {
+       seq_puts(m, "usbserinfo:1.0 driver:2.0\n");
+       for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
                serial = usb_serial_get_by_index(i);
                if (serial == NULL)
                        continue;
 
-               length += sprintf(page+length, "%d:", i);
+               seq_printf(m, "%d:", i);
                if (serial->type->driver.owner)
-                       length += sprintf(page+length, " module:%s",
+                       seq_printf(m, " module:%s",
                                module_name(serial->type->driver.owner));
-               length += sprintf(page+length, " name:\"%s\"",
+               seq_printf(m, " name:\"%s\"",
                                serial->type->description);
-               length += sprintf(page+length, " vendor:%04x product:%04x",
+               seq_printf(m, " vendor:%04x product:%04x",
                        le16_to_cpu(serial->dev->descriptor.idVendor),
                        le16_to_cpu(serial->dev->descriptor.idProduct));
-               length += sprintf(page+length, " num_ports:%d",
-                                                       serial->num_ports);
-               length += sprintf(page+length, " port:%d",
-                                                       i - serial->minor + 1);
+               seq_printf(m, " num_ports:%d", serial->num_ports);
+               seq_printf(m, " port:%d", i - serial->minor + 1);
                usb_make_path(serial->dev, tmp, sizeof(tmp));
-               length += sprintf(page+length, " path:%s", tmp);
+               seq_printf(m, " path:%s", tmp);
 
-               length += sprintf(page+length, "\n");
-               if ((length + begin) > (off + count)) {
-                       usb_serial_put(serial);
-                       goto done;
-               }
-               if ((length + begin) < off) {
-                       begin += length;
-                       length = 0;
-               }
+               seq_putc(m, '\n');
                usb_serial_put(serial);
+               mutex_unlock(&serial->disc_mutex);
        }
-       *eof = 1;
-done:
-       if (off >= (length + begin))
-               return 0;
-       *start = page + (off-begin);
-       return (count < begin+length-off) ? count : begin+length-off;
+       return 0;
+}
+
+static int serial_proc_open(struct inode *inode, struct file *file)
+{
+       return single_open(file, serial_proc_show, NULL);
 }
 
-static int serial_tiocmget(struct tty_struct *tty, struct file *file)
+static const struct file_operations serial_proc_fops = {
+       .owner          = THIS_MODULE,
+       .open           = serial_proc_open,
+       .read           = seq_read,
+       .llseek         = seq_lseek,
+       .release        = single_release,
+};
+
+static int serial_tiocmget(struct tty_struct *tty)
 {
        struct usb_serial_port *port = tty->driver_data;
 
-       dbg("%s - port %d", __func__, port->number);
+       dev_dbg(tty->dev, "%s - port %d\n", __func__, port->number);
 
-       WARN_ON(!port->port.count);
        if (port->serial->type->tiocmget)
-               return port->serial->type->tiocmget(tty, file);
+               return port->serial->type->tiocmget(tty);
        return -EINVAL;
 }
 
-static int serial_tiocmset(struct tty_struct *tty, struct file *file,
+static int serial_tiocmset(struct tty_struct *tty,
                            unsigned int set, unsigned int clear)
 {
        struct usb_serial_port *port = tty->driver_data;
 
-       dbg("%s - port %d", __func__, port->number);
+       dev_dbg(tty->dev, "%s - port %d\n", __func__, port->number);
 
-       WARN_ON(!port->port.count);
        if (port->serial->type->tiocmset)
-               return port->serial->type->tiocmset(tty, file, set, clear);
+               return port->serial->type->tiocmset(tty, set, clear);
+       return -EINVAL;
+}
+
+static int serial_get_icount(struct tty_struct *tty,
+                               struct serial_icounter_struct *icount)
+{
+       struct usb_serial_port *port = tty->driver_data;
+
+       dev_dbg(tty->dev, "%s - port %d\n", __func__, port->number);
+
+       if (port->serial->type->get_icount)
+               return port->serial->type->get_icount(tty, icount);
        return -EINVAL;
 }
 
@@ -514,28 +537,24 @@ static void usb_serial_port_work(struct work_struct *work)
                container_of(work, struct usb_serial_port, work);
        struct tty_struct *tty;
 
-       dbg("%s - port %d", __func__, port->number);
-
        tty = tty_port_tty_get(&port->port);
        if (!tty)
                return;
 
+       dev_dbg(tty->dev, "%s - port %d\n", __func__, port->number);
+
        tty_wakeup(tty);
        tty_kref_put(tty);
 }
 
-static void port_release(struct device *dev)
-{
-       struct usb_serial_port *port = to_usb_serial_port(dev);
-
-       dbg ("%s - %s", __func__, dev_name(dev));
-       port_free(port);
-}
-
 static void kill_traffic(struct usb_serial_port *port)
 {
-       usb_kill_urb(port->read_urb);
-       usb_kill_urb(port->write_urb);
+       int i;
+
+       for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i)
+               usb_kill_urb(port->read_urbs[i]);
+       for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i)
+               usb_kill_urb(port->write_urbs[i]);
        /*
         * This is tricky.
         * Some drivers submit the read_urb in the
@@ -551,18 +570,34 @@ static void kill_traffic(struct usb_serial_port *port)
        usb_kill_urb(port->interrupt_out_urb);
 }
 
-static void port_free(struct usb_serial_port *port)
+static void port_release(struct device *dev)
 {
+       struct usb_serial_port *port = to_usb_serial_port(dev);
+       int i;
+
+       dev_dbg(dev, "%s\n", __func__);
+
+       /*
+        * Stop all the traffic before cancelling the work, so that
+        * nobody will restart it by calling usb_serial_port_softint.
+        */
        kill_traffic(port);
-       usb_free_urb(port->read_urb);
-       usb_free_urb(port->write_urb);
+       cancel_work_sync(&port->work);
+
        usb_free_urb(port->interrupt_in_urb);
        usb_free_urb(port->interrupt_out_urb);
-       kfree(port->bulk_in_buffer);
-       kfree(port->bulk_out_buffer);
+       for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i) {
+               usb_free_urb(port->read_urbs[i]);
+               kfree(port->bulk_in_buffers[i]);
+       }
+       for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i) {
+               usb_free_urb(port->write_urbs[i]);
+               kfree(port->bulk_out_buffers[i]);
+       }
+       kfifo_free(&port->write_fifo);
        kfree(port->interrupt_in_buffer);
        kfree(port->interrupt_out_buffer);
-       flush_scheduled_work();         /* port->work */
+       tty_port_destroy(&port->port);
        kfree(port);
 }
 
@@ -610,25 +645,28 @@ static const struct usb_device_id *get_iface_id(struct usb_serial_driver *drv,
 
        id = usb_match_id(intf, drv->id_table);
        if (id) {
-               dbg("static descriptor matches");
+               dev_dbg(&intf->dev, "static descriptor matches\n");
                goto exit;
        }
        id = match_dynamic_id(intf, drv);
        if (id)
-               dbg("dynamic descriptor matches");
+               dev_dbg(&intf->dev, "dynamic descriptor matches\n");
 exit:
        return id;
 }
 
+/* Caller must hold table_lock */
 static struct usb_serial_driver *search_serial_device(
                                        struct usb_interface *iface)
 {
-       const struct usb_device_id *id;
+       const struct usb_device_id *id = NULL;
        struct usb_serial_driver *drv;
+       struct usb_driver *driver = to_usb_driver(iface->dev.driver);
 
        /* Check if the usb id matches a known device */
        list_for_each_entry(drv, &usb_serial_driver_list, driver_list) {
-               id = get_iface_id(drv, iface);
+               if (drv->usb_driver == driver)
+                       id = get_iface_id(drv, iface);
                if (id)
                        return drv;
        }
@@ -636,9 +674,37 @@ static struct usb_serial_driver *search_serial_device(
        return NULL;
 }
 
-int usb_serial_probe(struct usb_interface *interface,
+static int serial_carrier_raised(struct tty_port *port)
+{
+       struct usb_serial_port *p = container_of(port, struct usb_serial_port, port);
+       struct usb_serial_driver *drv = p->serial->type;
+
+       if (drv->carrier_raised)
+               return drv->carrier_raised(p);
+       /* No carrier control - don't block */
+       return 1;
+}
+
+static void serial_dtr_rts(struct tty_port *port, int on)
+{
+       struct usb_serial_port *p = container_of(port, struct usb_serial_port, port);
+       struct usb_serial_driver *drv = p->serial->type;
+
+       if (drv->dtr_rts)
+               drv->dtr_rts(p, on);
+}
+
+static const struct tty_port_operations serial_port_ops = {
+       .carrier_raised = serial_carrier_raised,
+       .dtr_rts = serial_dtr_rts,
+       .activate = serial_activate,
+       .shutdown = serial_down,
+};
+
+static int usb_serial_probe(struct usb_interface *interface,
                               const struct usb_device_id *id)
 {
+       struct device *ddev = &interface->dev;
        struct usb_device *dev = interface_to_usbdev(interface);
        struct usb_serial *serial = NULL;
        struct usb_serial_port *port;
@@ -653,6 +719,7 @@ int usb_serial_probe(struct usb_interface *interface,
        unsigned int minor;
        int buffer_size;
        int i;
+       int j;
        int num_interrupt_in = 0;
        int num_interrupt_out = 0;
        int num_bulk_in = 0;
@@ -660,18 +727,25 @@ int usb_serial_probe(struct usb_interface *interface,
        int num_ports = 0;
        int max_endpoints;
 
-       lock_kernel(); /* guard against unloading a serial driver module */
+       mutex_lock(&table_lock);
        type = search_serial_device(interface);
        if (!type) {
-               unlock_kernel();
-               dbg("none matched");
+               mutex_unlock(&table_lock);
+               dev_dbg(ddev, "none matched\n");
                return -ENODEV;
        }
 
+       if (!try_module_get(type->driver.owner)) {
+               mutex_unlock(&table_lock);
+               dev_err(ddev, "module get failed, exiting\n");
+               return -EIO;
+       }
+       mutex_unlock(&table_lock);
+
        serial = create_serial(dev, interface, type);
        if (!serial) {
-               unlock_kernel();
-               dev_err(&interface->dev, "%s - out of memory\n", __func__);
+               module_put(type->driver.owner);
+               dev_err(ddev, "%s - out of memory\n", __func__);
                return -ENOMEM;
        }
 
@@ -679,22 +753,13 @@ int usb_serial_probe(struct usb_interface *interface,
        if (type->probe) {
                const struct usb_device_id *id;
 
-               if (!try_module_get(type->driver.owner)) {
-                       unlock_kernel();
-                       dev_err(&interface->dev,
-                               "module get failed, exiting\n");
-                       kfree(serial);
-                       return -EIO;
-               }
-
                id = get_iface_id(type, interface);
                retval = type->probe(serial, id);
-               module_put(type->driver.owner);
 
                if (retval) {
-                       unlock_kernel();
-                       dbg("sub driver rejected device");
-                       kfree(serial);
+                       dev_dbg(ddev, "sub driver rejected device\n");
+                       usb_serial_put(serial);
+                       module_put(type->driver.owner);
                        return retval;
                }
        }
@@ -707,28 +772,28 @@ int usb_serial_probe(struct usb_interface *interface,
 
                if (usb_endpoint_is_bulk_in(endpoint)) {
                        /* we found a bulk in endpoint */
-                       dbg("found bulk in on endpoint %d", i);
+                       dev_dbg(ddev, "found bulk in on endpoint %d\n", i);
                        bulk_in_endpoint[num_bulk_in] = endpoint;
                        ++num_bulk_in;
                }
 
                if (usb_endpoint_is_bulk_out(endpoint)) {
                        /* we found a bulk out endpoint */
-                       dbg("found bulk out on endpoint %d", i);
+                       dev_dbg(ddev, "found bulk out on endpoint %d\n", i);
                        bulk_out_endpoint[num_bulk_out] = endpoint;
                        ++num_bulk_out;
                }
 
                if (usb_endpoint_is_int_in(endpoint)) {
                        /* we found a interrupt in endpoint */
-                       dbg("found interrupt in on endpoint %d", i);
+                       dev_dbg(ddev, "found interrupt in on endpoint %d\n", i);
                        interrupt_in_endpoint[num_interrupt_in] = endpoint;
                        ++num_interrupt_in;
                }
 
                if (usb_endpoint_is_int_out(endpoint)) {
                        /* we found an interrupt out endpoint */
-                       dbg("found interrupt out on endpoint %d", i);
+                       dev_dbg(ddev, "found interrupt out on endpoint %d\n", i);
                        interrupt_out_endpoint[num_interrupt_out] = endpoint;
                        ++num_interrupt_out;
                }
@@ -752,7 +817,7 @@ int usb_serial_probe(struct usb_interface *interface,
                                endpoint = &iface_desc->endpoint[i].desc;
                                if (usb_endpoint_is_int_in(endpoint)) {
                                        /* we found a interrupt in endpoint */
-                                       dbg("found interrupt in for Prolific device on separate interface");
+                                       dev_dbg(ddev, "found interrupt in for Prolific device on separate interface\n");
                                        interrupt_in_endpoint[num_interrupt_in] = endpoint;
                                        ++num_interrupt_in;
                                }
@@ -764,9 +829,9 @@ int usb_serial_probe(struct usb_interface *interface,
                 * properly during a later invocation of usb_serial_probe
                 */
                if (num_bulk_in == 0 || num_bulk_out == 0) {
-                       unlock_kernel();
-                       dev_info(&interface->dev, "PL-2303 hack: descriptors matched but endpoints did not\n");
-                       kfree(serial);
+                       dev_info(ddev, "PL-2303 hack: descriptors matched but endpoints did not\n");
+                       usb_serial_put(serial);
+                       module_put(type->driver.owner);
                        return -ENODEV;
                }
        }
@@ -777,27 +842,19 @@ int usb_serial_probe(struct usb_interface *interface,
        if (type == &usb_serial_generic_device) {
                num_ports = num_bulk_out;
                if (num_ports == 0) {
-                       unlock_kernel();
-                       dev_err(&interface->dev,
-                           "Generic device with no bulk out, not allowed.\n");
-                       kfree(serial);
+                       dev_err(ddev, "Generic device with no bulk out, not allowed.\n");
+                       usb_serial_put(serial);
+                       module_put(type->driver.owner);
                        return -EIO;
                }
+               dev_info(ddev, "The \"generic\" usb-serial driver is only for testing and one-off prototypes.\n");
+               dev_info(ddev, "Tell linux-usb@vger.kernel.org to add your device to a proper driver.\n");
        }
 #endif
        if (!num_ports) {
                /* if this device type has a calc_num_ports function, call it */
-               if (type->calc_num_ports) {
-                       if (!try_module_get(type->driver.owner)) {
-                               unlock_kernel();
-                               dev_err(&interface->dev,
-                                       "module get failed, exiting\n");
-                               kfree(serial);
-                               return -EIO;
-                       }
+               if (type->calc_num_ports)
                        num_ports = type->calc_num_ports(serial);
-                       module_put(type->driver.owner);
-               }
                if (!num_ports)
                        num_ports = type->num_ports;
        }
@@ -809,8 +866,7 @@ int usb_serial_probe(struct usb_interface *interface,
        serial->num_interrupt_out = num_interrupt_out;
 
        /* found all that we need */
-       dev_info(&interface->dev, "%s converter detected\n",
-                       type->description);
+       dev_info(ddev, "%s converter detected\n", type->description);
 
        /* create our ports, we need as many as the max endpoints */
        /* we don't use num_ports here because some devices have more
@@ -820,69 +876,95 @@ int usb_serial_probe(struct usb_interface *interface,
        max_endpoints = max(max_endpoints, num_interrupt_out);
        max_endpoints = max(max_endpoints, (int)serial->num_ports);
        serial->num_port_pointers = max_endpoints;
-       unlock_kernel();
 
-       dbg("%s - setting up %d port structures for this device",
-                                               __func__, max_endpoints);
+       dev_dbg(ddev, "setting up %d port structures for this device", max_endpoints);
        for (i = 0; i < max_endpoints; ++i) {
                port = kzalloc(sizeof(struct usb_serial_port), GFP_KERNEL);
                if (!port)
                        goto probe_error;
                tty_port_init(&port->port);
+               port->port.ops = &serial_port_ops;
                port->serial = serial;
                spin_lock_init(&port->lock);
-               mutex_init(&port->mutex);
+               /* Keep this for private driver use for the moment but
+                  should probably go away */
                INIT_WORK(&port->work, usb_serial_port_work);
                serial->port[i] = port;
+               port->dev.parent = &interface->dev;
+               port->dev.driver = NULL;
+               port->dev.bus = &usb_serial_bus_type;
+               port->dev.release = &port_release;
+               device_initialize(&port->dev);
        }
 
        /* set up the endpoint information */
        for (i = 0; i < num_bulk_in; ++i) {
                endpoint = bulk_in_endpoint[i];
                port = serial->port[i];
-               port->read_urb = usb_alloc_urb(0, GFP_KERNEL);
-               if (!port->read_urb) {
-                       dev_err(&interface->dev, "No free urbs available\n");
-                       goto probe_error;
-               }
-               buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
+               buffer_size = max_t(int, serial->type->bulk_in_size,
+                               usb_endpoint_maxp(endpoint));
                port->bulk_in_size = buffer_size;
                port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
-               port->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
-               if (!port->bulk_in_buffer) {
-                       dev_err(&interface->dev,
-                                       "Couldn't allocate bulk_in_buffer\n");
-                       goto probe_error;
-               }
-               usb_fill_bulk_urb(port->read_urb, dev,
-                               usb_rcvbulkpipe(dev,
+
+               for (j = 0; j < ARRAY_SIZE(port->read_urbs); ++j) {
+                       set_bit(j, &port->read_urbs_free);
+                       port->read_urbs[j] = usb_alloc_urb(0, GFP_KERNEL);
+                       if (!port->read_urbs[j]) {
+                               dev_err(ddev, "No free urbs available\n");
+                               goto probe_error;
+                       }
+                       port->bulk_in_buffers[j] = kmalloc(buffer_size,
+                                                               GFP_KERNEL);
+                       if (!port->bulk_in_buffers[j]) {
+                               dev_err(ddev, "Couldn't allocate bulk_in_buffer\n");
+                               goto probe_error;
+                       }
+                       usb_fill_bulk_urb(port->read_urbs[j], dev,
+                                       usb_rcvbulkpipe(dev,
                                                endpoint->bEndpointAddress),
-                               port->bulk_in_buffer, buffer_size,
-                               serial->type->read_bulk_callback, port);
+                                       port->bulk_in_buffers[j], buffer_size,
+                                       serial->type->read_bulk_callback,
+                                       port);
+               }
+
+               port->read_urb = port->read_urbs[0];
+               port->bulk_in_buffer = port->bulk_in_buffers[0];
        }
 
        for (i = 0; i < num_bulk_out; ++i) {
                endpoint = bulk_out_endpoint[i];
                port = serial->port[i];
-               port->write_urb = usb_alloc_urb(0, GFP_KERNEL);
-               if (!port->write_urb) {
-                       dev_err(&interface->dev, "No free urbs available\n");
+               if (kfifo_alloc(&port->write_fifo, PAGE_SIZE, GFP_KERNEL))
                        goto probe_error;
-               }
-               buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
+               buffer_size = serial->type->bulk_out_size;
+               if (!buffer_size)
+                       buffer_size = usb_endpoint_maxp(endpoint);
                port->bulk_out_size = buffer_size;
                port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
-               port->bulk_out_buffer = kmalloc(buffer_size, GFP_KERNEL);
-               if (!port->bulk_out_buffer) {
-                       dev_err(&interface->dev,
-                                       "Couldn't allocate bulk_out_buffer\n");
-                       goto probe_error;
+
+               for (j = 0; j < ARRAY_SIZE(port->write_urbs); ++j) {
+                       set_bit(j, &port->write_urbs_free);
+                       port->write_urbs[j] = usb_alloc_urb(0, GFP_KERNEL);
+                       if (!port->write_urbs[j]) {
+                               dev_err(ddev, "No free urbs available\n");
+                               goto probe_error;
+                       }
+                       port->bulk_out_buffers[j] = kmalloc(buffer_size,
+                                                               GFP_KERNEL);
+                       if (!port->bulk_out_buffers[j]) {
+                               dev_err(ddev, "Couldn't allocate bulk_out_buffer\n");
+                               goto probe_error;
+                       }
+                       usb_fill_bulk_urb(port->write_urbs[j], dev,
+                                       usb_sndbulkpipe(dev,
+                                               endpoint->bEndpointAddress),
+                                       port->bulk_out_buffers[j], buffer_size,
+                                       serial->type->write_bulk_callback,
+                                       port);
                }
-               usb_fill_bulk_urb(port->write_urb, dev,
-                               usb_sndbulkpipe(dev,
-                                       endpoint->bEndpointAddress),
-                               port->bulk_out_buffer, buffer_size,
-                               serial->type->write_bulk_callback, port);
+
+               port->write_urb = port->write_urbs[0];
+               port->bulk_out_buffer = port->bulk_out_buffers[0];
        }
 
        if (serial->type->read_int_callback) {
@@ -891,18 +973,16 @@ int usb_serial_probe(struct usb_interface *interface,
                        port = serial->port[i];
                        port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
                        if (!port->interrupt_in_urb) {
-                               dev_err(&interface->dev,
-                                               "No free urbs available\n");
+                               dev_err(ddev, "No free urbs available\n");
                                goto probe_error;
                        }
-                       buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
+                       buffer_size = usb_endpoint_maxp(endpoint);
                        port->interrupt_in_endpointAddress =
                                                endpoint->bEndpointAddress;
                        port->interrupt_in_buffer = kmalloc(buffer_size,
                                                                GFP_KERNEL);
                        if (!port->interrupt_in_buffer) {
-                               dev_err(&interface->dev,
-                                   "Couldn't allocate interrupt_in_buffer\n");
+                               dev_err(ddev, "Couldn't allocate interrupt_in_buffer\n");
                                goto probe_error;
                        }
                        usb_fill_int_urb(port->interrupt_in_urb, dev,
@@ -913,7 +993,7 @@ int usb_serial_probe(struct usb_interface *interface,
                                endpoint->bInterval);
                }
        } else if (num_interrupt_in) {
-               dbg("the device claims to support interrupt in transfers, but read_int_callback is not defined");
+               dev_dbg(ddev, "The device claims to support interrupt in transfers, but read_int_callback is not defined\n");
        }
 
        if (serial->type->write_int_callback) {
@@ -922,19 +1002,17 @@ int usb_serial_probe(struct usb_interface *interface,
                        port = serial->port[i];
                        port->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
                        if (!port->interrupt_out_urb) {
-                               dev_err(&interface->dev,
-                                               "No free urbs available\n");
+                               dev_err(ddev, "No free urbs available\n");
                                goto probe_error;
                        }
-                       buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
+                       buffer_size = usb_endpoint_maxp(endpoint);
                        port->interrupt_out_size = buffer_size;
                        port->interrupt_out_endpointAddress =
                                                endpoint->bEndpointAddress;
                        port->interrupt_out_buffer = kmalloc(buffer_size,
                                                                GFP_KERNEL);
                        if (!port->interrupt_out_buffer) {
-                               dev_err(&interface->dev,
-                                 "Couldn't allocate interrupt_out_buffer\n");
+                               dev_err(ddev, "Couldn't allocate interrupt_out_buffer\n");
                                goto probe_error;
                        }
                        usb_fill_int_urb(port->interrupt_out_urb, dev,
@@ -945,29 +1023,35 @@ int usb_serial_probe(struct usb_interface *interface,
                                endpoint->bInterval);
                }
        } else if (num_interrupt_out) {
-               dbg("the device claims to support interrupt out transfers, but write_int_callback is not defined");
+               dev_dbg(ddev, "The device claims to support interrupt out transfers, but write_int_callback is not defined\n");
        }
 
+       usb_set_intfdata(interface, serial);
+
        /* if this device type has an attach function, call it */
        if (type->attach) {
-               if (!try_module_get(type->driver.owner)) {
-                       dev_err(&interface->dev,
-                                       "module get failed, exiting\n");
-                       goto probe_error;
-               }
                retval = type->attach(serial);
-               module_put(type->driver.owner);
                if (retval < 0)
                        goto probe_error;
+               serial->attached = 1;
                if (retval > 0) {
                        /* quietly accept this device, but don't bind to a
                           serial port as it's about to disappear */
+                       serial->num_ports = 0;
                        goto exit;
                }
+       } else {
+               serial->attached = 1;
        }
 
+       /* Avoid race with tty_open and serial_install by setting the
+        * disconnected flag and not clearing it until all ports have been
+        * registered.
+        */
+       serial->disconnected = 1;
+
        if (get_free_serial(serial, num_ports, &minor) == NULL) {
-               dev_err(&interface->dev, "No more free serial devices\n");
+               dev_err(ddev, "No more free serial devices\n");
                goto probe_error;
        }
        serial->minor = minor;
@@ -975,65 +1059,29 @@ int usb_serial_probe(struct usb_interface *interface,
        /* register all of the individual ports with the driver core */
        for (i = 0; i < num_ports; ++i) {
                port = serial->port[i];
-               port->dev.parent = &interface->dev;
-               port->dev.driver = NULL;
-               port->dev.bus = &usb_serial_bus_type;
-               port->dev.release = &port_release;
-
                dev_set_name(&port->dev, "ttyUSB%d", port->number);
-               dbg ("%s - registering %s", __func__, dev_name(&port->dev));
-               retval = device_register(&port->dev);
+               dev_dbg(ddev, "registering %s", dev_name(&port->dev));
+               device_enable_async_suspend(&port->dev);
+
+               retval = device_add(&port->dev);
                if (retval)
-                       dev_err(&port->dev, "Error registering port device, "
-                               "continuing\n");
+                       dev_err(ddev, "Error registering port device, continuing\n");
        }
 
-       usb_serial_console_init(debug, minor);
+       serial->disconnected = 0;
 
+       usb_serial_console_init(minor);
 exit:
-       /* success */
-       usb_set_intfdata(interface, serial);
+       module_put(type->driver.owner);
        return 0;
 
 probe_error:
-       for (i = 0; i < num_bulk_in; ++i) {
-               port = serial->port[i];
-               if (!port)
-                       continue;
-               usb_free_urb(port->read_urb);
-               kfree(port->bulk_in_buffer);
-       }
-       for (i = 0; i < num_bulk_out; ++i) {
-               port = serial->port[i];
-               if (!port)
-                       continue;
-               usb_free_urb(port->write_urb);
-               kfree(port->bulk_out_buffer);
-       }
-       for (i = 0; i < num_interrupt_in; ++i) {
-               port = serial->port[i];
-               if (!port)
-                       continue;
-               usb_free_urb(port->interrupt_in_urb);
-               kfree(port->interrupt_in_buffer);
-       }
-       for (i = 0; i < num_interrupt_out; ++i) {
-               port = serial->port[i];
-               if (!port)
-                       continue;
-               usb_free_urb(port->interrupt_out_urb);
-               kfree(port->interrupt_out_buffer);
-       }
-
-       /* free up any memory that we allocated */
-       for (i = 0; i < serial->num_port_pointers; ++i)
-               kfree(serial->port[i]);
-       kfree(serial);
+       usb_serial_put(serial);
+       module_put(type->driver.owner);
        return -EIO;
 }
-EXPORT_SYMBOL_GPL(usb_serial_probe);
 
-void usb_serial_disconnect(struct usb_interface *interface)
+static void usb_serial_disconnect(struct usb_interface *interface)
 {
        int i;
        struct usb_serial *serial = usb_get_intfdata(interface);
@@ -1041,30 +1089,32 @@ void usb_serial_disconnect(struct usb_interface *interface)
        struct usb_serial_port *port;
 
        usb_serial_console_disconnect(serial);
-       dbg("%s", __func__);
 
        mutex_lock(&serial->disc_mutex);
-       usb_set_intfdata(interface, NULL);
        /* must set a flag, to signal subdrivers */
        serial->disconnected = 1;
+       mutex_unlock(&serial->disc_mutex);
+
        for (i = 0; i < serial->num_ports; ++i) {
                port = serial->port[i];
                if (port) {
                        struct tty_struct *tty = tty_port_tty_get(&port->port);
                        if (tty) {
-                               tty_hangup(tty);
+                               tty_vhangup(tty);
                                tty_kref_put(tty);
                        }
                        kill_traffic(port);
+                       cancel_work_sync(&port->work);
+                       if (device_is_registered(&port->dev))
+                               device_del(&port->dev);
                }
        }
-       /* let the last holder of this object
-        * cause it to be cleaned up */
-       mutex_unlock(&serial->disc_mutex);
+       serial->type->disconnect(serial);
+
+       /* let the last holder of this object cause it to be cleaned up */
        usb_serial_put(serial);
        dev_info(dev, "device disconnected\n");
 }
-EXPORT_SYMBOL_GPL(usb_serial_disconnect);
 
 int usb_serial_suspend(struct usb_interface *intf, pm_message_t message)
 {
@@ -1074,15 +1124,21 @@ int usb_serial_suspend(struct usb_interface *intf, pm_message_t message)
 
        serial->suspending = 1;
 
+       if (serial->type->suspend) {
+               r = serial->type->suspend(serial, message);
+               if (r < 0) {
+                       serial->suspending = 0;
+                       goto err_out;
+               }
+       }
+
        for (i = 0; i < serial->num_ports; ++i) {
                port = serial->port[i];
                if (port)
                        kill_traffic(port);
        }
 
-       if (serial->type->suspend)
-               r = serial->type->suspend(serial, message);
-
+err_out:
        return r;
 }
 EXPORT_SYMBOL(usb_serial_suspend);
@@ -1102,10 +1158,27 @@ int usb_serial_resume(struct usb_interface *intf)
 }
 EXPORT_SYMBOL(usb_serial_resume);
 
+static int usb_serial_reset_resume(struct usb_interface *intf)
+{
+       struct usb_serial *serial = usb_get_intfdata(intf);
+       int rv;
+
+       serial->suspending = 0;
+       if (serial->type->reset_resume)
+               rv = serial->type->reset_resume(serial);
+       else {
+               rv = -EOPNOTSUPP;
+               intf->needs_binding = 1;
+       }
+
+       return rv;
+}
+
 static const struct tty_operations serial_ops = {
        .open =                 serial_open,
        .close =                serial_close,
        .write =                serial_write,
+       .hangup =               serial_hangup,
        .write_room =           serial_write_room,
        .ioctl =                serial_ioctl,
        .set_termios =          serial_set_termios,
@@ -1113,13 +1186,28 @@ static const struct tty_operations serial_ops = {
        .unthrottle =           serial_unthrottle,
        .break_ctl =            serial_break,
        .chars_in_buffer =      serial_chars_in_buffer,
-       .read_proc =            serial_read_proc,
        .tiocmget =             serial_tiocmget,
        .tiocmset =             serial_tiocmset,
+       .get_icount =           serial_get_icount,
+       .cleanup =              serial_cleanup,
+       .install =              serial_install,
+       .proc_fops =            &serial_proc_fops,
 };
 
+
 struct tty_driver *usb_serial_tty_driver;
 
+/* Driver structure we register with the USB core */
+static struct usb_driver usb_serial_driver = {
+       .name =         "usbserial",
+       .probe =        usb_serial_probe,
+       .disconnect =   usb_serial_disconnect,
+       .suspend =      usb_serial_suspend,
+       .resume =       usb_serial_resume,
+       .no_dynamic_id =        1,
+       .supports_autosuspend = 1,
+};
+
 static int __init usb_serial_init(void)
 {
        int i;
@@ -1135,14 +1223,12 @@ static int __init usb_serial_init(void)
 
        result = bus_register(&usb_serial_bus_type);
        if (result) {
-               printk(KERN_ERR "usb-serial: %s - registering bus driver "
-                      "failed\n", __func__);
+               pr_err("%s - registering bus driver failed\n", __func__);
                goto exit_bus;
        }
 
-       usb_serial_tty_driver->owner = THIS_MODULE;
        usb_serial_tty_driver->driver_name = "usbserial";
-       usb_serial_tty_driver->name =   "ttyUSB";
+       usb_serial_tty_driver->name = "ttyUSB";
        usb_serial_tty_driver->major = SERIAL_TTY_MAJOR;
        usb_serial_tty_driver->minor_start = 0;
        usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
@@ -1157,29 +1243,24 @@ static int __init usb_serial_init(void)
        tty_set_operations(usb_serial_tty_driver, &serial_ops);
        result = tty_register_driver(usb_serial_tty_driver);
        if (result) {
-               printk(KERN_ERR "usb-serial: %s - tty_register_driver failed\n",
-                      __func__);
+               pr_err("%s - tty_register_driver failed\n", __func__);
                goto exit_reg_driver;
        }
 
        /* register the USB driver */
        result = usb_register(&usb_serial_driver);
        if (result < 0) {
-               printk(KERN_ERR "usb-serial: %s - usb_register failed\n",
-                      __func__);
+               pr_err("%s - usb_register failed\n", __func__);
                goto exit_tty;
        }
 
        /* register the generic driver, if we should */
-       result = usb_serial_generic_register(debug);
+       result = usb_serial_generic_register();
        if (result < 0) {
-               printk(KERN_ERR "usb-serial: %s - registering generic "
-                      "driver failed\n", __func__);
+               pr_err("%s - registering generic driver failed\n", __func__);
                goto exit_generic;
        }
 
-       printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
-
        return result;
 
 exit_generic:
@@ -1192,8 +1273,7 @@ exit_reg_driver:
        bus_unregister(&usb_serial_bus_type);
 
 exit_bus:
-       printk(KERN_ERR "usb-serial: %s - returning with error %d\n",
-              __func__, result);
+       pr_err("%s - returning with error %d\n", __func__, result);
        put_tty_driver(usb_serial_tty_driver);
        return result;
 }
@@ -1219,7 +1299,7 @@ module_exit(usb_serial_exit);
        do {                                                            \
                if (!type->function) {                                  \
                        type->function = usb_serial_generic_##function; \
-                       dbg("Had to override the " #function            \
+                       pr_debug("Had to override the " #function       \
                                " usb serial operation with the generic one.");\
                        }                                               \
        } while (0)
@@ -1233,12 +1313,14 @@ static void fixup_generic(struct usb_serial_driver *device)
        set_to_generic_if_null(device, chars_in_buffer);
        set_to_generic_if_null(device, read_bulk_callback);
        set_to_generic_if_null(device, write_bulk_callback);
-       set_to_generic_if_null(device, shutdown);
+       set_to_generic_if_null(device, disconnect);
+       set_to_generic_if_null(device, release);
+       set_to_generic_if_null(device, process_read_urb);
+       set_to_generic_if_null(device, prepare_write_buffer);
 }
 
-int usb_serial_register(struct usb_serial_driver *driver)
+static int usb_serial_register(struct usb_serial_driver *driver)
 {
-       /* must be called with BKL held */
        int retval;
 
        if (usb_disabled())
@@ -1248,38 +1330,130 @@ int usb_serial_register(struct usb_serial_driver *driver)
 
        if (!driver->description)
                driver->description = driver->driver.name;
+       if (!driver->usb_driver) {
+               WARN(1, "Serial driver %s has no usb_driver\n",
+                               driver->description);
+               return -EINVAL;
+       }
 
        /* Add this device to our list of devices */
+       mutex_lock(&table_lock);
        list_add(&driver->driver_list, &usb_serial_driver_list);
 
        retval = usb_serial_bus_register(driver);
        if (retval) {
-               printk(KERN_ERR "usb-serial: problem %d when registering "
-                      "driver %s\n", retval, driver->description);
+               pr_err("problem %d when registering driver %s\n", retval, driver->description);
                list_del(&driver->driver_list);
        } else
-               printk(KERN_INFO "USB Serial support registered for %s\n",
-                                               driver->description);
+               pr_info("USB Serial support registered for %s\n", driver->description);
 
+       mutex_unlock(&table_lock);
        return retval;
 }
-EXPORT_SYMBOL_GPL(usb_serial_register);
-
 
-void usb_serial_deregister(struct usb_serial_driver *device)
+static void usb_serial_deregister(struct usb_serial_driver *device)
 {
-       /* must be called with BKL held */
-       printk(KERN_INFO "USB Serial deregistering driver %s\n",
-              device->description);
+       pr_info("USB Serial deregistering driver %s\n", device->description);
+       mutex_lock(&table_lock);
        list_del(&device->driver_list);
        usb_serial_bus_deregister(device);
+       mutex_unlock(&table_lock);
 }
-EXPORT_SYMBOL_GPL(usb_serial_deregister);
+
+/**
+ * usb_serial_register_drivers - register drivers for a usb-serial module
+ * @serial_drivers: NULL-terminated array of pointers to drivers to be registered
+ * @name: name of the usb_driver for this set of @serial_drivers
+ * @id_table: list of all devices this @serial_drivers set binds to
+ *
+ * Registers all the drivers in the @serial_drivers array, and dynamically
+ * creates a struct usb_driver with the name @name and id_table of @id_table.
+ */
+int usb_serial_register_drivers(struct usb_serial_driver *const serial_drivers[],
+                               const char *name,
+                               const struct usb_device_id *id_table)
+{
+       int rc;
+       struct usb_driver *udriver;
+       struct usb_serial_driver * const *sd;
+
+       /*
+        * udriver must be registered before any of the serial drivers,
+        * because the store_new_id() routine for the serial drivers (in
+        * bus.c) probes udriver.
+        *
+        * Performance hack: We don't want udriver to be probed until
+        * the serial drivers are registered, because the probe would
+        * simply fail for lack of a matching serial driver.
+        * So we leave udriver's id_table set to NULL until we are all set.
+        *
+        * Suspend/resume support is implemented in the usb-serial core,
+        * so fill in the PM-related fields in udriver.
+        */
+       udriver = kzalloc(sizeof(*udriver), GFP_KERNEL);
+       if (!udriver)
+               return -ENOMEM;
+
+       udriver->name = name;
+       udriver->no_dynamic_id = 1;
+       udriver->supports_autosuspend = 1;
+       udriver->suspend = usb_serial_suspend;
+       udriver->resume = usb_serial_resume;
+       udriver->probe = usb_serial_probe;
+       udriver->disconnect = usb_serial_disconnect;
+
+       /* we only set the reset_resume field if the serial_driver has one */
+       for (sd = serial_drivers; *sd; ++sd) {
+               if ((*sd)->reset_resume) {
+                       udriver->reset_resume = usb_serial_reset_resume;
+                       break;
+               }
+       }
+
+       rc = usb_register(udriver);
+       if (rc)
+               return rc;
+
+       for (sd = serial_drivers; *sd; ++sd) {
+               (*sd)->usb_driver = udriver;
+               rc = usb_serial_register(*sd);
+               if (rc)
+                       goto failed;
+       }
+
+       /* Now set udriver's id_table and look for matches */
+       udriver->id_table = id_table;
+       rc = driver_attach(&udriver->drvwrap.driver);
+       return 0;
+
+ failed:
+       while (sd-- > serial_drivers)
+               usb_serial_deregister(*sd);
+       usb_deregister(udriver);
+       return rc;
+}
+EXPORT_SYMBOL_GPL(usb_serial_register_drivers);
+
+/**
+ * usb_serial_deregister_drivers - deregister drivers for a usb-serial module
+ * @serial_drivers: NULL-terminated array of pointers to drivers to be deregistered
+ *
+ * Deregisters all the drivers in the @serial_drivers array and deregisters and
+ * frees the struct usb_driver that was created by the call to
+ * usb_serial_register_drivers().
+ */
+void usb_serial_deregister_drivers(struct usb_serial_driver *const serial_drivers[])
+{
+       struct usb_driver *udriver = (*serial_drivers)->usb_driver;
+
+       for (; *serial_drivers; ++serial_drivers)
+               usb_serial_deregister(*serial_drivers);
+       usb_deregister(udriver);
+       kfree(udriver);
+}
+EXPORT_SYMBOL_GPL(usb_serial_deregister_drivers);
 
 /* Module information */
 MODULE_AUTHOR(DRIVER_AUTHOR);
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE("GPL");
-
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Debug enabled or not");