Merge git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb-2.6

* git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb-2.6: (142 commits)
  USB: Fix sysfs paths in documentation
  USB: skeleton: fix coding style issues.
  USB: O_NONBLOCK in read path of skeleton
  USB: make usb-skeleton honor O_NONBLOCK in write path
  USB: skel_read really sucks royally
  USB: Add hub descriptor update hook for xHCI
  USB: xhci: Support USB hubs.
  USB: xhci: Set multi-TT field for LS/FS devices under hubs.
  USB: xhci: Set route string for all devices.
  USB: xhci: Fix command wait list handling.
  USB: xhci: Change how xHCI commands are handled.
  USB: xhci: Refactor input device context setup.
  USB: xhci: Endpoint representation refactoring.
  USB: gadget: ether needs to select CRC32
  USB: fix USBTMC get_capabilities success handling
  USB: fix missing error check in probing
  USB: usbfs: add USBDEVFS_URB_BULK_CONTINUATION flag
  USB: support for autosuspend in sierra while online
  USB: ehci-dbgp,ehci: Allow dbpg to work with suspend/resume
  USB: ehci-dbgp,documentation: Documentation updates for ehci-dbgp
  ...

12 files changed, 676 insertions, 133 deletions

diff --git a/drivers/usb/serial/ark3116.c b/drivers/usb/serial/ark3116.c
index 5d25d3e52bf6..131e61adaaf7 100644
--- a/drivers/usb/serial/ark3116.c
+++ b/drivers/usb/serial/ark3116.c
@@ -31,10 +31,20 @@ static int debug;
 
 static struct usb_device_id id_table [] = {
         { USB_DEVICE(0x6547, 0x0232) },
+        { USB_DEVICE(0x18ec, 0x3118) },         /* USB to IrDA adapter */
         { },
 };
 MODULE_DEVICE_TABLE(usb, id_table);
 
+static int is_irda(struct usb_serial *serial)
+{
+        struct usb_device *dev = serial->dev;
+        if (le16_to_cpu(dev->descriptor.idVendor) == 0x18ec &&
+                        le16_to_cpu(dev->descriptor.idProduct) == 0x3118)
+                return 1;
+        return 0;
+}
+
 static inline void ARK3116_SND(struct usb_serial *serial, int seq,
                                __u8 request, __u8 requesttype,
                                __u16 value, __u16 index)
@@ -84,11 +94,21 @@ static int ark3116_attach(struct usb_serial *serial)
                 return -ENOMEM;
         }
 
+        if (is_irda(serial))
+                dbg("IrDA mode");
+
         /* 3 */
         ARK3116_SND(serial, 3, 0xFE, 0x40, 0x0008, 0x0002);
         ARK3116_SND(serial, 4, 0xFE, 0x40, 0x0008, 0x0001);
         ARK3116_SND(serial, 5, 0xFE, 0x40, 0x0000, 0x0008);
-        ARK3116_SND(serial, 6, 0xFE, 0x40, 0x0000, 0x000B);
+        ARK3116_SND(serial, 6, 0xFE, 0x40, is_irda(serial) ? 0x0001 : 0x0000,
+                    0x000B);
+
+        if (is_irda(serial)) {
+                ARK3116_SND(serial, 1001, 0xFE, 0x40, 0x0000, 0x000C);
+                ARK3116_SND(serial, 1002, 0xFE, 0x40, 0x0041, 0x000D);
+                ARK3116_SND(serial, 1003, 0xFE, 0x40, 0x0001, 0x000A);
+        }
 
         /* <-- seq7 */
         ARK3116_RCV(serial,  7, 0xFE, 0xC0, 0x0000, 0x0003, 0x00, buf);
@@ -125,6 +145,8 @@ static int ark3116_attach(struct usb_serial *serial)
         ARK3116_SND(serial, 147, 0xFE, 0x40, 0x0083, 0x0003);
         ARK3116_SND(serial, 148, 0xFE, 0x40, 0x0038, 0x0000);
         ARK3116_SND(serial, 149, 0xFE, 0x40, 0x0001, 0x0001);
+        if (is_irda(serial))
+                ARK3116_SND(serial, 1004, 0xFE, 0x40, 0x0000, 0x0009);
         ARK3116_SND(serial, 150, 0xFE, 0x40, 0x0003, 0x0003);
         ARK3116_RCV(serial, 151, 0xFE, 0xC0, 0x0000, 0x0004, 0x03, buf);
         ARK3116_SND(serial, 152, 0xFE, 0x40, 0x0000, 0x0003);
diff --git a/drivers/usb/serial/ch341.c b/drivers/usb/serial/ch341.c
index 8c894a7d5dcf..59eff721fcc5 100644
--- a/drivers/usb/serial/ch341.c
+++ b/drivers/usb/serial/ch341.c
@@ -56,6 +56,18 @@
 #define CH341_BAUDBASE_FACTOR 1532620800
 #define CH341_BAUDBASE_DIVMAX 3
 
+/* Break support - the information used to implement this was gleaned from
+ * the Net/FreeBSD uchcom.c driver by Takanori Watanabe.  Domo arigato.
+ */
+
+#define CH341_REQ_WRITE_REG    0x9A
+#define CH341_REQ_READ_REG     0x95
+#define CH341_REG_BREAK1       0x05
+#define CH341_REG_BREAK2       0x18
+#define CH341_NBREAK_BITS_REG1 0x01
+#define CH341_NBREAK_BITS_REG2 0x40
+
+
 static int debug;
 
 static struct usb_device_id id_table [] = {
@@ -373,6 +385,45 @@ static void ch341_set_termios(struct tty_struct *tty,
          */
 }
 
+static void ch341_break_ctl(struct tty_struct *tty, int break_state)
+{
+        const uint16_t ch341_break_reg =
+                CH341_REG_BREAK1 | ((uint16_t) CH341_REG_BREAK2 << 8);
+        struct usb_serial_port *port = tty->driver_data;
+        int r;
+        uint16_t reg_contents;
+        uint8_t break_reg[2];
+
+        dbg("%s()", __func__);
+
+        r = ch341_control_in(port->serial->dev, CH341_REQ_READ_REG,
+                        ch341_break_reg, 0, break_reg, sizeof(break_reg));
+        if (r < 0) {
+                printk(KERN_WARNING "%s: USB control read error whilst getting"
+                                " break register contents.\n", __FILE__);
+                return;
+        }
+        dbg("%s - initial ch341 break register contents - reg1: %x, reg2: %x",
+                        __func__, break_reg[0], break_reg[1]);
+        if (break_state != 0) {
+                dbg("%s - Enter break state requested", __func__);
+                break_reg[0] &= ~CH341_NBREAK_BITS_REG1;
+                break_reg[1] &= ~CH341_NBREAK_BITS_REG2;
+        } else {
+                dbg("%s - Leave break state requested", __func__);
+                break_reg[0] |= CH341_NBREAK_BITS_REG1;
+                break_reg[1] |= CH341_NBREAK_BITS_REG2;
+        }
+        dbg("%s - New ch341 break register contents - reg1: %x, reg2: %x",
+                        __func__, break_reg[0], break_reg[1]);
+        reg_contents = (uint16_t)break_reg[0] | ((uint16_t)break_reg[1] << 8);
+        r = ch341_control_out(port->serial->dev, CH341_REQ_WRITE_REG,
+                        ch341_break_reg, reg_contents);
+        if (r < 0)
+                printk(KERN_WARNING "%s: USB control write error whilst setting"
+                                " break register contents.\n", __FILE__);
+}
+
 static int ch341_tiocmset(struct tty_struct *tty, struct file *file,
                           unsigned int set, unsigned int clear)
 {
@@ -576,6 +627,7 @@ static struct usb_serial_driver ch341_device = {
         .close             = ch341_close,
         .ioctl             = ch341_ioctl,
         .set_termios       = ch341_set_termios,
+        .break_ctl         = ch341_break_ctl,
         .tiocmget          = ch341_tiocmget,
         .tiocmset          = ch341_tiocmset,
         .read_int_callback = ch341_read_int_callback,
diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
index 76a17f915eef..4f883b1773d0 100644
--- a/drivers/usb/serial/ftdi_sio.c
+++ b/drivers/usb/serial/ftdi_sio.c
@@ -176,6 +176,9 @@ static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(FTDI_VID, FTDI_MICRO_CHAMELEON_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_RELAIS_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_OPENDCC_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_OPENDCC_SNIFFER_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_OPENDCC_THROTTLE_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_OPENDCC_GATEWAY_PID) },
         { USB_DEVICE(INTERBIOMETRICS_VID, INTERBIOMETRICS_IOBOARD_PID) },
         { USB_DEVICE(INTERBIOMETRICS_VID, INTERBIOMETRICS_MINI_IOBOARD_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_SPROG_II) },
@@ -694,6 +697,8 @@ static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(DE_VID, WHT_PID) },
         { USB_DEVICE(ADI_VID, ADI_GNICE_PID),
                 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
+        { USB_DEVICE(ADI_VID, ADI_GNICEPLUS_PID),
+                .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
         { USB_DEVICE(JETI_VID, JETI_SPC1201_PID) },
         { USB_DEVICE(MARVELL_VID, MARVELL_SHEEVAPLUG_PID),
                 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
@@ -702,6 +707,8 @@ static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(BAYER_VID, BAYER_CONTOUR_CABLE_PID) },
         { USB_DEVICE(FTDI_VID, MARVELL_OPENRD_PID),
                 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
+        { USB_DEVICE(FTDI_VID, HAMEG_HO820_PID) },
+        { USB_DEVICE(FTDI_VID, HAMEG_HO870_PID) },
         { },                                    /* Optional parameter entry */
         { }                                     /* Terminating entry */
 };
diff --git a/drivers/usb/serial/ftdi_sio.h b/drivers/usb/serial/ftdi_sio.h
index 8c92b88166ae..6f31e0d71898 100644
--- a/drivers/usb/serial/ftdi_sio.h
+++ b/drivers/usb/serial/ftdi_sio.h
@@ -81,6 +81,9 @@
 
 /* OpenDCC (www.opendcc.de) product id */
 #define FTDI_OPENDCC_PID        0xBFD8
+#define FTDI_OPENDCC_SNIFFER_PID        0xBFD9
+#define FTDI_OPENDCC_THROTTLE_PID       0xBFDA
+#define FTDI_OPENDCC_GATEWAY_PID        0xBFDB
 
 /* Sprog II (Andrew Crosland's SprogII DCC interface) */
 #define FTDI_SPROG_II           0xF0C8
@@ -930,6 +933,7 @@
  */
 #define ADI_VID                 0x0456
 #define ADI_GNICE_PID           0xF000
+#define ADI_GNICEPLUS_PID       0xF001
 
 /*
  * JETI SPECTROMETER SPECBOS 1201
@@ -968,6 +972,12 @@
 #define MARVELL_OPENRD_PID      0x9e90
 
 /*
+ * Hameg HO820 and HO870 interface (using VID 0x0403)
+ */
+#define        HAMEG_HO820_PID         0xed74
+#define        HAMEG_HO870_PID         0xed71
+
+/*
  *   BmRequestType:  1100 0000b
  *   bRequest:       FTDI_E2_READ
  *   wValue:         0
diff --git a/drivers/usb/serial/generic.c b/drivers/usb/serial/generic.c
index d9398e9f30ce..deba08c7a015 100644
--- a/drivers/usb/serial/generic.c
+++ b/drivers/usb/serial/generic.c
@@ -19,7 +19,7 @@
 #include <linux/usb.h>
 #include <linux/usb/serial.h>
 #include <linux/uaccess.h>
-
+#include <linux/kfifo.h>
 
 static int debug;
 
@@ -166,24 +166,6 @@ static void generic_cleanup(struct usb_serial_port *port)
         }
 }
 
-int usb_serial_generic_resume(struct usb_serial *serial)
-{
-        struct usb_serial_port *port;
-        int i, c = 0, r;
-
-        for (i = 0; i < serial->num_ports; i++) {
-                port = serial->port[i];
-                if (port->port.count && port->read_urb) {
-                        r = usb_submit_urb(port->read_urb, GFP_NOIO);
-                        if (r < 0)
-                                c++;
-                }
-        }
-
-        return c ? -EIO : 0;
-}
-EXPORT_SYMBOL_GPL(usb_serial_generic_resume);
-
 void usb_serial_generic_close(struct usb_serial_port *port)
 {
         dbg("%s - port %d", __func__, port->number);
@@ -272,12 +254,81 @@ error_no_buffer:
         return bwrite;
 }
 
+/**
+ * usb_serial_generic_write_start - kick off an URB write
+ * @port:       Pointer to the &struct usb_serial_port data
+ *
+ * Returns the number of bytes queued on success. This will be zero if there
+ * was nothing to send. Otherwise, it returns a negative errno value
+ */
+static int usb_serial_generic_write_start(struct usb_serial_port *port)
+{
+        struct usb_serial *serial = port->serial;
+        unsigned char *data;
+        int result;
+        int count;
+        unsigned long flags;
+        bool start_io;
+
+        /* Atomically determine whether we can and need to start a USB
+         * operation. */
+        spin_lock_irqsave(&port->lock, flags);
+        if (port->write_urb_busy)
+                start_io = false;
+        else {
+                start_io = (__kfifo_len(port->write_fifo) != 0);
+                port->write_urb_busy = start_io;
+        }
+        spin_unlock_irqrestore(&port->lock, flags);
+
+        if (!start_io)
+                return 0;
+
+        data = port->write_urb->transfer_buffer;
+        count = kfifo_get(port->write_fifo, data, port->bulk_out_size);
+        usb_serial_debug_data(debug, &port->dev, __func__, count, data);
+
+        /* set up our urb */
+        usb_fill_bulk_urb(port->write_urb, serial->dev,
+                           usb_sndbulkpipe(serial->dev,
+                                port->bulk_out_endpointAddress),
+                           port->write_urb->transfer_buffer, count,
+                           ((serial->type->write_bulk_callback) ?
+                             serial->type->write_bulk_callback :
+                             usb_serial_generic_write_bulk_callback),
+                           port);
+
+        /* send the data out the bulk port */
+        result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
+        if (result) {
+                dev_err(&port->dev,
+                        "%s - failed submitting write urb, error %d\n",
+                                                __func__, result);
+                /* don't have to grab the lock here, as we will
+                   retry if != 0 */
+                port->write_urb_busy = 0;
+        } else
+                result = count;
+
+        return result;
+}
+
+/**
+ * usb_serial_generic_write - generic write function for serial USB devices
+ * @tty:        Pointer to &struct tty_struct for the device
+ * @port:       Pointer to the &usb_serial_port structure for the device
+ * @buf:        Pointer to the data to write
+ * @count:      Number of bytes to write
+ *
+ * Returns the number of characters actually written, which may be anything
+ * from zero to @count. If an error occurs, it returns the negative errno
+ * value.
+ */
 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;
-        unsigned char *data;
 
         dbg("%s - port %d", __func__, port->number);
 
@@ -287,57 +338,20 @@ int usb_serial_generic_write(struct tty_struct *tty,
         }
 
         /* only do something if we have a bulk out endpoint */
-        if (serial->num_bulk_out) {
-                unsigned long flags;
-
-                if (serial->type->max_in_flight_urbs)
-                        return usb_serial_multi_urb_write(tty, port,
-                                                          buf, count);
-
-                spin_lock_irqsave(&port->lock, flags);
-                if (port->write_urb_busy) {
-                        spin_unlock_irqrestore(&port->lock, flags);
-                        dbg("%s - already writing", __func__);
-                        return 0;
-                }
-                port->write_urb_busy = 1;
-                spin_unlock_irqrestore(&port->lock, flags);
-
-                count = (count > port->bulk_out_size) ?
-                                        port->bulk_out_size : count;
-
-                memcpy(port->write_urb->transfer_buffer, buf, count);
-                data = port->write_urb->transfer_buffer;
-                usb_serial_debug_data(debug, &port->dev, __func__, count, data);
+        if (!serial->num_bulk_out)
+                return 0;
 
-                /* set up our urb */
-                usb_fill_bulk_urb(port->write_urb, serial->dev,
-                                   usb_sndbulkpipe(serial->dev,
-                                        port->bulk_out_endpointAddress),
-                                   port->write_urb->transfer_buffer, count,
-                                   ((serial->type->write_bulk_callback) ?
-                                     serial->type->write_bulk_callback :
-                                     usb_serial_generic_write_bulk_callback),
-                                   port);
+        if (serial->type->max_in_flight_urbs)
+                return usb_serial_multi_urb_write(tty, port,
+                                                  buf, count);
 
-                /* send the data out the bulk port */
-                port->write_urb_busy = 1;
-                result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
-                if (result) {
-                        dev_err(&port->dev,
-                                "%s - failed submitting write urb, error %d\n",
-                                                        __func__, result);
-                        /* don't have to grab the lock here, as we will
-                           retry if != 0 */
-                        port->write_urb_busy = 0;
-                } else
-                        result = count;
+        count = kfifo_put(port->write_fifo, buf, count);
+        result = usb_serial_generic_write_start(port);
 
-                return result;
-        }
+        if (result >= 0)
+                result = count;
 
-        /* no bulk out, so return 0 bytes written */
-        return 0;
+        return result;
 }
 EXPORT_SYMBOL_GPL(usb_serial_generic_write);
 
@@ -355,9 +369,8 @@ int usb_serial_generic_write_room(struct tty_struct *tty)
                         room = port->bulk_out_size *
                                 (serial->type->max_in_flight_urbs -
                                  port->urbs_in_flight);
-        } else if (serial->num_bulk_out && !(port->write_urb_busy)) {
-                room = port->bulk_out_size;
-        }
+        } else if (serial->num_bulk_out)
+                room = port->write_fifo->size - __kfifo_len(port->write_fifo);
         spin_unlock_irqrestore(&port->lock, flags);
 
         dbg("%s - returns %d", __func__, room);
@@ -377,11 +390,8 @@ int usb_serial_generic_chars_in_buffer(struct tty_struct *tty)
                 spin_lock_irqsave(&port->lock, flags);
                 chars = port->tx_bytes_flight;
                 spin_unlock_irqrestore(&port->lock, flags);
-        } else if (serial->num_bulk_out) {
-                /* FIXME: Locking */
-                if (port->write_urb_busy)
-                        chars = port->write_urb->transfer_buffer_length;
-        }
+        } else if (serial->num_bulk_out)
+                chars = kfifo_len(port->write_fifo);
 
         dbg("%s - returns %d", __func__, chars);
         return chars;
@@ -485,16 +495,23 @@ void usb_serial_generic_write_bulk_callback(struct urb *urb)
                 if (port->urbs_in_flight < 0)
                         port->urbs_in_flight = 0;
                 spin_unlock_irqrestore(&port->lock, flags);
+
+                if (status) {
+                        dbg("%s - nonzero multi-urb write bulk status "
+                                "received: %d", __func__, status);
+                        return;
+                }
         } else {
-                /* Handle the case for single urb mode */
                 port->write_urb_busy = 0;
-        }
 
-        if (status) {
-                dbg("%s - nonzero write bulk status received: %d",
-                    __func__, status);
-                return;
+                if (status) {
+                        dbg("%s - nonzero multi-urb write bulk status "
+                                "received: %d", __func__, status);
+                        kfifo_reset(port->write_fifo);
+                } else
+                        usb_serial_generic_write_start(port);
         }
+
         usb_serial_port_softint(port);
 }
 EXPORT_SYMBOL_GPL(usb_serial_generic_write_bulk_callback);
@@ -559,6 +576,33 @@ int usb_serial_handle_break(struct usb_serial_port *port)
 }
 EXPORT_SYMBOL_GPL(usb_serial_handle_break);
 
+int usb_serial_generic_resume(struct usb_serial *serial)
+{
+        struct usb_serial_port *port;
+        int i, c = 0, r;
+
+        for (i = 0; i < serial->num_ports; i++) {
+                port = serial->port[i];
+                if (!port->port.count)
+                        continue;
+
+                if (port->read_urb) {
+                        r = usb_submit_urb(port->read_urb, GFP_NOIO);
+                        if (r < 0)
+                                c++;
+                }
+
+                if (port->write_urb) {
+                        r = usb_serial_generic_write_start(port);
+                        if (r < 0)
+                                c++;
+                }
+        }
+
+        return c ? -EIO : 0;
+}
+EXPORT_SYMBOL_GPL(usb_serial_generic_resume);
+
 void usb_serial_generic_disconnect(struct usb_serial *serial)
 {
         int i;
diff --git a/drivers/usb/serial/iuu_phoenix.c b/drivers/usb/serial/iuu_phoenix.c
index 6138c1cda35f..e6e02b178d2b 100644
--- a/drivers/usb/serial/iuu_phoenix.c
+++ b/drivers/usb/serial/iuu_phoenix.c
@@ -40,7 +40,7 @@ static int debug;
 /*
  * Version Information
  */
-#define DRIVER_VERSION "v0.10"
+#define DRIVER_VERSION "v0.11"
 #define DRIVER_DESC "Infinity USB Unlimited Phoenix driver"
 
 static struct usb_device_id id_table[] = {
@@ -64,6 +64,7 @@ static int cdmode = 1;
 static int iuu_cardin;
 static int iuu_cardout;
 static int xmas;
+static int vcc_default = 5;
 
 static void read_rxcmd_callback(struct urb *urb);
 
@@ -79,6 +80,7 @@ struct iuu_private {
         u8 *buf;                /* used for initialize speed */
         u8 *dbgbuf;             /* debug buffer */
         u8 len;
+        int vcc;                /* vcc (either 3 or 5 V) */
 };
 
 
@@ -114,6 +116,7 @@ static int iuu_startup(struct usb_serial *serial)
                 kfree(priv);
                 return -ENOMEM;
         }
+        priv->vcc = vcc_default;
         spin_lock_init(&priv->lock);
         init_waitqueue_head(&priv->delta_msr_wait);
         usb_set_serial_port_data(serial->port[0], priv);
@@ -1009,11 +1012,7 @@ static void iuu_close(struct usb_serial_port *port)
                 usb_kill_urb(port->write_urb);
                 usb_kill_urb(port->read_urb);
                 usb_kill_urb(port->interrupt_in_urb);
-                msleep(1000);
-                /* wait one second to free all buffers */
                 iuu_led(port, 0, 0, 0xF000, 0xFF);
-                msleep(1000);
-                usb_reset_device(port->serial->dev);
         }
 }
 
@@ -1182,6 +1181,95 @@ static int iuu_open(struct tty_struct *tty, struct usb_serial_port *port)
         return result;
 }
 
+/* how to change VCC */
+static int iuu_vcc_set(struct usb_serial_port *port, unsigned int vcc)
+{
+        int status;
+        u8 *buf;
+
+        buf = kmalloc(5, GFP_KERNEL);
+        if (!buf)
+                return -ENOMEM;
+
+        dbg("%s - enter", __func__);
+
+        buf[0] = IUU_SET_VCC;
+        buf[1] = vcc & 0xFF;
+        buf[2] = (vcc >> 8) & 0xFF;
+        buf[3] = (vcc >> 16) & 0xFF;
+        buf[4] = (vcc >> 24) & 0xFF;
+
+        status = bulk_immediate(port, buf, 5);
+        kfree(buf);
+
+        if (status != IUU_OPERATION_OK)
+                dbg("%s - vcc error status = %2x", __func__, status);
+        else
+                dbg("%s - vcc OK !", __func__);
+
+        return status;
+}
+
+/*
+ * Sysfs Attributes
+ */
+
+static ssize_t show_vcc_mode(struct device *dev,
+        struct device_attribute *attr, char *buf)
+{
+        struct usb_serial_port *port = to_usb_serial_port(dev);
+        struct iuu_private *priv = usb_get_serial_port_data(port);
+
+        return sprintf(buf, "%d\n", priv->vcc);
+}
+
+static ssize_t store_vcc_mode(struct device *dev,
+        struct device_attribute *attr, const char *buf, size_t count)
+{
+        struct usb_serial_port *port = to_usb_serial_port(dev);
+        struct iuu_private *priv = usb_get_serial_port_data(port);
+        unsigned long v;
+
+        if (strict_strtoul(buf, 10, &v)) {
+                dev_err(dev, "%s - vcc_mode: %s is not a unsigned long\n",
+                                __func__, buf);
+                goto fail_store_vcc_mode;
+        }
+
+        dbg("%s: setting vcc_mode = %ld", __func__, v);
+
+        if ((v != 3) && (v != 5)) {
+                dev_err(dev, "%s - vcc_mode %ld is invalid\n", __func__, v);
+        } else {
+                iuu_vcc_set(port, v);
+                priv->vcc = v;
+        }
+fail_store_vcc_mode:
+        return count;
+}
+
+static DEVICE_ATTR(vcc_mode, S_IRUSR | S_IWUSR, show_vcc_mode,
+        store_vcc_mode);
+
+static int iuu_create_sysfs_attrs(struct usb_serial_port *port)
+{
+        dbg("%s", __func__);
+
+        return device_create_file(&port->dev, &dev_attr_vcc_mode);
+}
+
+static int iuu_remove_sysfs_attrs(struct usb_serial_port *port)
+{
+        dbg("%s", __func__);
+
+        device_remove_file(&port->dev, &dev_attr_vcc_mode);
+        return 0;
+}
+
+/*
+ * End Sysfs Attributes
+ */
+
 static struct usb_serial_driver iuu_device = {
         .driver = {
                    .owner = THIS_MODULE,
@@ -1189,6 +1277,8 @@ static struct usb_serial_driver iuu_device = {
                    },
         .id_table = id_table,
         .num_ports = 1,
+        .port_probe = iuu_create_sysfs_attrs,
+        .port_remove = iuu_remove_sysfs_attrs,
         .open = iuu_open,
         .close = iuu_close,
         .write = iuu_uart_write,
@@ -1238,14 +1328,19 @@ module_param(debug, bool, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(debug, "Debug enabled or not");
 
 module_param(xmas, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(xmas, "xmas color enabled or not");
+MODULE_PARM_DESC(xmas, "Xmas colors enabled or not");
 
 module_param(boost, int, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(boost, "overclock boost percent 100 to 500");
+MODULE_PARM_DESC(boost, "Card overclock boost (in percent 100-500)");
 
 module_param(clockmode, int, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(clockmode, "1=3Mhz579,2=3Mhz680,3=6Mhz");
+MODULE_PARM_DESC(clockmode, "Card clock mode (1=3.579 MHz, 2=3.680 MHz, "
+                "3=6 Mhz)");
 
 module_param(cdmode, int, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(cdmode, "Card detect mode 0=none, 1=CD, 2=!CD, 3=DSR, "
-                 "4=!DSR, 5=CTS, 6=!CTS, 7=RING, 8=!RING");
+MODULE_PARM_DESC(cdmode, "Card detect mode (0=none, 1=CD, 2=!CD, 3=DSR, "
+                 "4=!DSR, 5=CTS, 6=!CTS, 7=RING, 8=!RING)");
+
+module_param(vcc_default, int, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(vcc_default, "Set default VCC (either 3 for 3.3V or 5 "
+                "for 5V). Default to 5.");
diff --git a/drivers/usb/serial/moto_modem.c b/drivers/usb/serial/moto_modem.c
index b66b71ccd12b..99bd00f5188a 100644
--- a/drivers/usb/serial/moto_modem.c
+++ b/drivers/usb/serial/moto_modem.c
@@ -8,7 +8,7 @@
  *  published by the Free Software Foundation.
  *
  * {sigh}
- * Mororola should be using the CDC ACM USB spec, but instead
+ * Motorola should be using the CDC ACM USB spec, but instead
  * they try to just "do their own thing"...  This driver should handle a
  * few phones in which a basic "dumb serial connection" is needed to be
  * able to get a connection through to them.
diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
index fe47051dbef2..f66e39883218 100644
--- a/drivers/usb/serial/option.c
+++ b/drivers/usb/serial/option.c
@@ -291,6 +291,7 @@ static int  option_resume(struct usb_serial *serial);
 
 #define TELIT_VENDOR_ID                         0x1bc7
 #define TELIT_PRODUCT_UC864E                    0x1003
+#define TELIT_PRODUCT_UC864G                    0x1004
 
 /* ZTE PRODUCTS */
 #define ZTE_VENDOR_ID                           0x19d2
@@ -299,6 +300,7 @@ static int  option_resume(struct usb_serial *serial);
 #define ZTE_PRODUCT_MF626                       0x0031
 #define ZTE_PRODUCT_CDMA_TECH                   0xfffe
 #define ZTE_PRODUCT_AC8710                      0xfff1
+#define ZTE_PRODUCT_AC2726                      0xfff5
 
 #define BENQ_VENDOR_ID                          0x04a5
 #define BENQ_PRODUCT_H10                        0x4068
@@ -502,6 +504,7 @@ static struct usb_device_id option_ids[] = {
         { USB_DEVICE(QUALCOMM_VENDOR_ID, 0x6613)}, /* Onda H600/ZTE MF330 */
         { USB_DEVICE(MAXON_VENDOR_ID, 0x6280) }, /* BP3-USB & BP3-EXT HSDPA */
         { USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_UC864E) },
+        { USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_UC864G) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_MF622, 0xff, 0xff, 0xff) }, /* ZTE WCDMA products */
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0002, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0003, 0xff, 0xff, 0xff) },
@@ -571,6 +574,7 @@ static struct usb_device_id option_ids[] = {
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0073, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_CDMA_TECH, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_AC8710, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_AC2726, 0xff, 0xff, 0xff) },
         { USB_DEVICE(BENQ_VENDOR_ID, BENQ_PRODUCT_H10) },
         { USB_DEVICE(DLINK_VENDOR_ID, DLINK_PRODUCT_DWM_652) },
         { USB_DEVICE(QISDA_VENDOR_ID, QISDA_PRODUCT_H21_4512) },
@@ -592,6 +596,7 @@ static struct usb_driver option_driver = {
 #ifdef CONFIG_PM
         .suspend    = usb_serial_suspend,
         .resume     = usb_serial_resume,
+        .supports_autosuspend = 1,
 #endif
         .id_table   = option_ids,
         .no_dynamic_id =        1,
@@ -639,6 +644,12 @@ static int debug;
 #define IN_BUFLEN 4096
 #define OUT_BUFLEN 4096
 
+struct option_intf_private {
+        spinlock_t susp_lock;
+        unsigned int suspended:1;
+        int in_flight;
+};
+
 struct option_port_private {
         /* Input endpoints and buffer for this port */
         struct urb *in_urbs[N_IN_URB];
@@ -647,6 +658,8 @@ struct option_port_private {
         struct urb *out_urbs[N_OUT_URB];
         u8 *out_buffer[N_OUT_URB];
         unsigned long out_busy;         /* Bit vector of URBs in use */
+        int opened;
+        struct usb_anchor delayed;
 
         /* Settings for the port */
         int rts_state;  /* Handshaking pins (outputs) */
@@ -693,12 +706,17 @@ module_exit(option_exit);
 static int option_probe(struct usb_serial *serial,
                         const struct usb_device_id *id)
 {
+        struct option_intf_private *data;
         /* D-Link DWM 652 still exposes CD-Rom emulation interface in modem mode */
         if (serial->dev->descriptor.idVendor == DLINK_VENDOR_ID &&
                 serial->dev->descriptor.idProduct == DLINK_PRODUCT_DWM_652 &&
                 serial->interface->cur_altsetting->desc.bInterfaceClass == 0x8)
                 return -ENODEV;
 
+        data = serial->private = kzalloc(sizeof(struct option_intf_private), GFP_KERNEL);
+        if (!data)
+                return -ENOMEM;
+        spin_lock_init(&data->susp_lock);
         return 0;
 }
 
@@ -755,12 +773,15 @@ static int option_write(struct tty_struct *tty, struct usb_serial_port *port,
                         const unsigned char *buf, int count)
 {
         struct option_port_private *portdata;
+        struct option_intf_private *intfdata;
         int i;
         int left, todo;
         struct urb *this_urb = NULL; /* spurious */
         int err;
+        unsigned long flags;
 
         portdata = usb_get_serial_port_data(port);
+        intfdata = port->serial->private;
 
         dbg("%s: write (%d chars)", __func__, count);
 
@@ -782,17 +803,33 @@ static int option_write(struct tty_struct *tty, struct usb_serial_port *port,
                 dbg("%s: endpoint %d buf %d", __func__,
                         usb_pipeendpoint(this_urb->pipe), i);
 
+                err = usb_autopm_get_interface_async(port->serial->interface);
+                if (err < 0)
+                        break;
+
                 /* send the data */
                 memcpy(this_urb->transfer_buffer, buf, todo);
                 this_urb->transfer_buffer_length = todo;
 
-                err = usb_submit_urb(this_urb, GFP_ATOMIC);
-                if (err) {
-                        dbg("usb_submit_urb %p (write bulk) failed "
-                                "(%d)", this_urb, err);
-                        clear_bit(i, &portdata->out_busy);
-                        continue;
+                spin_lock_irqsave(&intfdata->susp_lock, flags);
+                if (intfdata->suspended) {
+                        usb_anchor_urb(this_urb, &portdata->delayed);
+                        spin_unlock_irqrestore(&intfdata->susp_lock, flags);
+                } else {
+                        intfdata->in_flight++;
+                        spin_unlock_irqrestore(&intfdata->susp_lock, flags);
+                        err = usb_submit_urb(this_urb, GFP_ATOMIC);
+                        if (err) {
+                                dbg("usb_submit_urb %p (write bulk) failed "
+                                        "(%d)", this_urb, err);
+                                clear_bit(i, &portdata->out_busy);
+                                spin_lock_irqsave(&intfdata->susp_lock, flags);
+                                intfdata->in_flight--;
+                                spin_unlock_irqrestore(&intfdata->susp_lock, flags);
+                                continue;
+                        }
                 }
+
                 portdata->tx_start_time[i] = jiffies;
                 buf += todo;
                 left -= todo;
@@ -836,7 +873,10 @@ static void option_indat_callback(struct urb *urb)
                         if (err)
                                 printk(KERN_ERR "%s: resubmit read urb failed. "
                                         "(%d)", __func__, err);
+                        else
+                                usb_mark_last_busy(port->serial->dev);
                 }
+
         }
         return;
 }
@@ -845,15 +885,21 @@ static void option_outdat_callback(struct urb *urb)
 {
         struct usb_serial_port *port;
         struct option_port_private *portdata;
+        struct option_intf_private *intfdata;
         int i;
 
         dbg("%s", __func__);
 
         port =  urb->context;
+        intfdata = port->serial->private;
 
         usb_serial_port_softint(port);
-
+        usb_autopm_put_interface_async(port->serial->interface);
         portdata = usb_get_serial_port_data(port);
+        spin_lock(&intfdata->susp_lock);
+        intfdata->in_flight--;
+        spin_unlock(&intfdata->susp_lock);
+
         for (i = 0; i < N_OUT_URB; ++i) {
                 if (portdata->out_urbs[i] == urb) {
                         smp_mb__before_clear_bit();
@@ -963,10 +1009,13 @@ static int option_chars_in_buffer(struct tty_struct *tty)
 static int option_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
         struct option_port_private *portdata;
+        struct option_intf_private *intfdata;
+        struct usb_serial *serial = port->serial;
         int i, err;
         struct urb *urb;
 
         portdata = usb_get_serial_port_data(port);
+        intfdata = serial->private;
 
         dbg("%s", __func__);
 
@@ -985,6 +1034,12 @@ static int option_open(struct tty_struct *tty, struct usb_serial_port *port)
 
         option_send_setup(port);
 
+        serial->interface->needs_remote_wakeup = 1;
+        spin_lock_irq(&intfdata->susp_lock);
+        portdata->opened = 1;
+        spin_unlock_irq(&intfdata->susp_lock);
+        usb_autopm_put_interface(serial->interface);
+
         return 0;
 }
 
@@ -1009,16 +1064,23 @@ static void option_close(struct usb_serial_port *port)
         int i;
         struct usb_serial *serial = port->serial;
         struct option_port_private *portdata;
+        struct option_intf_private *intfdata = port->serial->private;
 
         dbg("%s", __func__);
         portdata = usb_get_serial_port_data(port);
 
         if (serial->dev) {
                 /* Stop reading/writing urbs */
+                spin_lock_irq(&intfdata->susp_lock);
+                portdata->opened = 0;
+                spin_unlock_irq(&intfdata->susp_lock);
+
                 for (i = 0; i < N_IN_URB; i++)
                         usb_kill_urb(portdata->in_urbs[i]);
                 for (i = 0; i < N_OUT_URB; i++)
                         usb_kill_urb(portdata->out_urbs[i]);
+                usb_autopm_get_interface(serial->interface);
+                serial->interface->needs_remote_wakeup = 0;
         }
 }
 
@@ -1123,6 +1185,7 @@ static int option_startup(struct usb_serial *serial)
                                         __func__, i);
                         return 1;
                 }
+                init_usb_anchor(&portdata->delayed);
 
                 for (j = 0; j < N_IN_URB; j++) {
                         buffer = (u8 *)__get_free_page(GFP_KERNEL);
@@ -1225,18 +1288,52 @@ static void option_release(struct usb_serial *serial)
 #ifdef CONFIG_PM
 static int option_suspend(struct usb_serial *serial, pm_message_t message)
 {
+        struct option_intf_private *intfdata = serial->private;
+        int b;
+
         dbg("%s entered", __func__);
+
+        if (serial->dev->auto_pm) {
+                spin_lock_irq(&intfdata->susp_lock);
+                b = intfdata->in_flight;
+                spin_unlock_irq(&intfdata->susp_lock);
+
+                if (b)
+                        return -EBUSY;
+        }
+
+        spin_lock_irq(&intfdata->susp_lock);
+        intfdata->suspended = 1;
+        spin_unlock_irq(&intfdata->susp_lock);
         stop_read_write_urbs(serial);
 
         return 0;
 }
 
+static void play_delayed(struct usb_serial_port *port)
+{
+        struct option_intf_private *data;
+        struct option_port_private *portdata;
+        struct urb *urb;
+        int err;
+
+        portdata = usb_get_serial_port_data(port);
+        data = port->serial->private;
+        while ((urb = usb_get_from_anchor(&portdata->delayed))) {
+                err = usb_submit_urb(urb, GFP_ATOMIC);
+                if (!err)
+                        data->in_flight++;
+        }
+}
+
 static int option_resume(struct usb_serial *serial)
 {
-        int err, i, j;
+        int i, j;
         struct usb_serial_port *port;
-        struct urb *urb;
+        struct option_intf_private *intfdata = serial->private;
         struct option_port_private *portdata;
+        struct urb *urb;
+        int err = 0;
 
         dbg("%s entered", __func__);
         /* get the interrupt URBs resubmitted unconditionally */
@@ -1251,7 +1348,7 @@ static int option_resume(struct usb_serial *serial)
                 if (err < 0) {
                         err("%s: Error %d for interrupt URB of port%d",
                                  __func__, err, i);
-                        return err;
+                        goto err_out;
                 }
         }
 
@@ -1259,27 +1356,32 @@ static int option_resume(struct usb_serial *serial)
                 /* walk all ports */
                 port = serial->port[i];
                 portdata = usb_get_serial_port_data(port);
-                mutex_lock(&port->mutex);
 
                 /* skip closed ports */
-                if (!port->port.count) {
-                        mutex_unlock(&port->mutex);
+                spin_lock_irq(&intfdata->susp_lock);
+                if (!portdata->opened) {
+                        spin_unlock_irq(&intfdata->susp_lock);
                         continue;
                 }
 
                 for (j = 0; j < N_IN_URB; j++) {
                         urb = portdata->in_urbs[j];
-                        err = usb_submit_urb(urb, GFP_NOIO);
+                        err = usb_submit_urb(urb, GFP_ATOMIC);
                         if (err < 0) {
-                                mutex_unlock(&port->mutex);
                                 err("%s: Error %d for bulk URB %d",
                                          __func__, err, i);
-                                return err;
+                                spin_unlock_irq(&intfdata->susp_lock);
+                                goto err_out;
                         }
                 }
-                mutex_unlock(&port->mutex);
+                play_delayed(port);
+                spin_unlock_irq(&intfdata->susp_lock);
         }
-        return 0;
+        spin_lock_irq(&intfdata->susp_lock);
+        intfdata->suspended = 0;
+        spin_unlock_irq(&intfdata->susp_lock);
+err_out:
+        return err;
 }
 #endif
 
diff --git a/drivers/usb/serial/pl2303.c b/drivers/usb/serial/pl2303.c
index a63ea99936f7..1128e01525b1 100644
--- a/drivers/usb/serial/pl2303.c
+++ b/drivers/usb/serial/pl2303.c
@@ -96,6 +96,7 @@ static struct usb_device_id id_table [] = {
         { USB_DEVICE(HP_VENDOR_ID, HP_LD220_PRODUCT_ID) },
         { USB_DEVICE(CRESSI_VENDOR_ID, CRESSI_EDY_PRODUCT_ID) },
         { USB_DEVICE(SONY_VENDOR_ID, SONY_QN3USB_PRODUCT_ID) },
+        { USB_DEVICE(SANWA_VENDOR_ID, SANWA_PRODUCT_ID) },
         { }                                     /* Terminating entry */
 };
 
@@ -527,6 +528,12 @@ static void pl2303_set_termios(struct tty_struct *tty,
         int baud;
         int i;
         u8 control;
+        const int baud_sup[] = { 75, 150, 300, 600, 1200, 1800, 2400, 3600,
+                                 4800, 7200, 9600, 14400, 19200, 28800, 38400,
+                                 57600, 115200, 230400, 460800, 614400,
+                                 921600, 1228800, 2457600, 3000000, 6000000 };
+        int baud_floor, baud_ceil;
+        int k;
 
         dbg("%s -  port %d", __func__, port->number);
 
@@ -572,9 +579,39 @@ static void pl2303_set_termios(struct tty_struct *tty,
                 dbg("%s - data bits = %d", __func__, buf[6]);
         }
 
+        /* For reference buf[0]:buf[3] baud rate value */
+        /* NOTE: Only the values defined in baud_sup are supported !
+         *       => if unsupported values are set, the PL2303 seems to use
+         *          9600 baud (at least my PL2303X always does)
+         */
         baud = tty_get_baud_rate(tty);
-        dbg("%s - baud = %d", __func__, baud);
+        dbg("%s - baud requested = %d", __func__, baud);
         if (baud) {
+                /* Set baudrate to nearest supported value */
+                for (k=0; k<ARRAY_SIZE(baud_sup); k++) {
+                        if (baud_sup[k] / baud) {
+                                baud_ceil = baud_sup[k];
+                                if (k==0) {
+                                        baud = baud_ceil;
+                                } else {
+                                        baud_floor = baud_sup[k-1];
+                                        if ((baud_ceil % baud)
+                                            > (baud % baud_floor))
+                                                baud = baud_floor;
+                                        else
+                                                baud = baud_ceil;
+                                }
+                                break;
+                        }
+                }
+                if (baud > 1228800) {
+                        /* type_0, type_1 only support up to 1228800 baud */
+                        if (priv->type != HX)
+                                baud = 1228800;
+                        else if (baud > 6000000)
+                                baud = 6000000;
+                }
+                dbg("%s - baud set = %d", __func__, baud);
                 buf[0] = baud & 0xff;
                 buf[1] = (baud >> 8) & 0xff;
                 buf[2] = (baud >> 16) & 0xff;
@@ -585,8 +622,16 @@ static void pl2303_set_termios(struct tty_struct *tty,
         /* For reference buf[4]=1 is 1.5 stop bits */
         /* For reference buf[4]=2 is 2 stop bits */
         if (cflag & CSTOPB) {
-                buf[4] = 2;
-                dbg("%s - stop bits = 2", __func__);
+                /* NOTE: Comply with "real" UARTs / RS232:
+                 *       use 1.5 instead of 2 stop bits with 5 data bits
+                 */
+                if ((cflag & CSIZE) == CS5) {
+                        buf[4] = 1;
+                        dbg("%s - stop bits = 1.5", __func__);
+                } else {
+                        buf[4] = 2;
+                        dbg("%s - stop bits = 2", __func__);
+                }
         } else {
                 buf[4] = 0;
                 dbg("%s - stop bits = 1", __func__);
@@ -599,11 +644,21 @@ static void pl2303_set_termios(struct tty_struct *tty,
                 /* For reference buf[5]=3 is mark parity */
                 /* For reference buf[5]=4 is space parity */
                 if (cflag & PARODD) {
-                        buf[5] = 1;
-                        dbg("%s - parity = odd", __func__);
+                        if (cflag & CMSPAR) {
+                                buf[5] = 3;
+                                dbg("%s - parity = mark", __func__);
+                        } else {
+                                buf[5] = 1;
+                                dbg("%s - parity = odd", __func__);
+                        }
                 } else {
-                        buf[5] = 2;
-                        dbg("%s - parity = even", __func__);
+                        if (cflag & CMSPAR) {
+                                buf[5] = 4;
+                                dbg("%s - parity = space", __func__);
+                        } else {
+                                buf[5] = 2;
+                                dbg("%s - parity = even", __func__);
+                        }
                 }
         } else {
                 buf[5] = 0;
@@ -647,7 +702,7 @@ static void pl2303_set_termios(struct tty_struct *tty,
                 pl2303_vendor_write(0x0, 0x0, serial);
         }
 
-        /* FIXME: Need to read back resulting baud rate */
+        /* Save resulting baud rate */
         if (baud)
                 tty_encode_baud_rate(tty, baud, baud);
 
diff --git a/drivers/usb/serial/pl2303.h b/drivers/usb/serial/pl2303.h
index ee9505e1dd92..d640dc951568 100644
--- a/drivers/usb/serial/pl2303.h
+++ b/drivers/usb/serial/pl2303.h
@@ -130,3 +130,7 @@
 /* Sony, USB data cable for CMD-Jxx mobile phones */
 #define SONY_VENDOR_ID          0x054c
 #define SONY_QN3USB_PRODUCT_ID  0x0437
+
+/* Sanwa KB-USB2 multimeter cable (ID: 11ad:0001) */
+#define SANWA_VENDOR_ID         0x11ad
+#define SANWA_PRODUCT_ID        0x0001
diff --git a/drivers/usb/serial/sierra.c b/drivers/usb/serial/sierra.c
index 55391bbe1230..68fa0e43b781 100644
--- a/drivers/usb/serial/sierra.c
+++ b/drivers/usb/serial/sierra.c
@@ -51,6 +51,12 @@ struct sierra_iface_info {
         const u8  *ifaceinfo;   /* pointer to the array holding the numbers */
 };
 
+struct sierra_intf_private {
+        spinlock_t susp_lock;
+        unsigned int suspended:1;
+        int in_flight;
+};
+
 static int sierra_set_power_state(struct usb_device *udev, __u16 swiState)
 {
         int result;
@@ -144,6 +150,7 @@ static int sierra_probe(struct usb_serial *serial,
 {
         int result = 0;
         struct usb_device *udev;
+        struct sierra_intf_private *data;
         u8 ifnum;
 
         udev = serial->dev;
@@ -171,6 +178,11 @@ static int sierra_probe(struct usb_serial *serial,
                 return -ENODEV;
         }
 
+        data = serial->private = kzalloc(sizeof(struct sierra_intf_private), GFP_KERNEL);
+        if (!data)
+                return -ENOMEM;
+        spin_lock_init(&data->susp_lock);
+
         return result;
 }
 
@@ -261,13 +273,18 @@ static struct usb_driver sierra_driver = {
         .name       = "sierra",
         .probe      = usb_serial_probe,
         .disconnect = usb_serial_disconnect,
+        .suspend    = usb_serial_suspend,
+        .resume     = usb_serial_resume,
         .id_table   = id_table,
         .no_dynamic_id =        1,
+        .supports_autosuspend = 1,
 };
 
 struct sierra_port_private {
         spinlock_t lock;        /* lock the structure */
         int outstanding_urbs;   /* number of out urbs in flight */
+        struct usb_anchor active;
+        struct usb_anchor delayed;
 
         /* Input endpoints and buffers for this port */
         struct urb *in_urbs[N_IN_URB];
@@ -279,6 +296,8 @@ struct sierra_port_private {
         int dsr_state;
         int dcd_state;
         int ri_state;
+
+        unsigned int opened:1;
 };
 
 static int sierra_send_setup(struct usb_serial_port *port)
@@ -390,21 +409,25 @@ static void sierra_outdat_callback(struct urb *urb)
 {
         struct usb_serial_port *port = urb->context;
         struct sierra_port_private *portdata = usb_get_serial_port_data(port);
+        struct sierra_intf_private *intfdata;
         int status = urb->status;
-        unsigned long flags;
 
         dev_dbg(&port->dev, "%s - port %d\n", __func__, port->number);
+        intfdata = port->serial->private;
 
         /* free up the transfer buffer, as usb_free_urb() does not do this */
         kfree(urb->transfer_buffer);
-
+        usb_autopm_put_interface_async(port->serial->interface);
         if (status)
                 dev_dbg(&port->dev, "%s - nonzero write bulk status "
                     "received: %d\n", __func__, status);
 
-        spin_lock_irqsave(&portdata->lock, flags);
+        spin_lock(&portdata->lock);
         --portdata->outstanding_urbs;
-        spin_unlock_irqrestore(&portdata->lock, flags);
+        spin_unlock(&portdata->lock);
+        spin_lock(&intfdata->susp_lock);
+        --intfdata->in_flight;
+        spin_unlock(&intfdata->susp_lock);
 
         usb_serial_port_softint(port);
 }
@@ -414,6 +437,7 @@ 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 sierra_intf_private *intfdata;
         struct usb_serial *serial = port->serial;
         unsigned long flags;
         unsigned char *buffer;
@@ -426,9 +450,9 @@ static int sierra_write(struct tty_struct *tty, struct usb_serial_port *port,
                 return 0;
 
         portdata = usb_get_serial_port_data(port);
+        intfdata = serial->private;
 
         dev_dbg(&port->dev, "%s: write (%zd bytes)\n", __func__, writesize);
-
         spin_lock_irqsave(&portdata->lock, flags);
         dev_dbg(&port->dev, "%s - outstanding_urbs: %d\n", __func__,
                 portdata->outstanding_urbs);
@@ -442,6 +466,14 @@ static int sierra_write(struct tty_struct *tty, struct usb_serial_port *port,
                 portdata->outstanding_urbs);
         spin_unlock_irqrestore(&portdata->lock, flags);
 
+        retval = usb_autopm_get_interface_async(serial->interface);
+        if (retval < 0) {
+                spin_lock_irqsave(&portdata->lock, flags);
+                portdata->outstanding_urbs--;
+                spin_unlock_irqrestore(&portdata->lock, flags);
+                goto error_simple;
+        }
+
         buffer = kmalloc(writesize, GFP_ATOMIC);
         if (!buffer) {
                 dev_err(&port->dev, "out of memory\n");
@@ -468,14 +500,29 @@ static int sierra_write(struct tty_struct *tty, struct usb_serial_port *port,
         /* Handle the need to send a zero length packet */
         urb->transfer_flags |= URB_ZERO_PACKET;
 
+        spin_lock_irqsave(&intfdata->susp_lock, flags);
+
+        if (intfdata->suspended) {
+                usb_anchor_urb(urb, &portdata->delayed);
+                spin_unlock_irqrestore(&intfdata->susp_lock, flags);
+                goto skip_power;
+        } else {
+                usb_anchor_urb(urb, &portdata->active);
+        }
         /* send it down the pipe */
         retval = usb_submit_urb(urb, GFP_ATOMIC);
         if (retval) {
+                usb_unanchor_urb(urb);
+                spin_unlock_irqrestore(&intfdata->susp_lock, flags);
                 dev_err(&port->dev, "%s - usb_submit_urb(write bulk) failed "
                         "with status = %d\n", __func__, retval);
                 goto error;
+        } else {
+                intfdata->in_flight++;
+                spin_unlock_irqrestore(&intfdata->susp_lock, flags);
         }
 
+skip_power:
         /* we are done with this urb, so let the host driver
          * really free it when it is finished with it */
         usb_free_urb(urb);
@@ -491,6 +538,8 @@ error_no_buffer:
         dev_dbg(&port->dev, "%s - 2. outstanding_urbs: %d\n", __func__,
                 portdata->outstanding_urbs);
         spin_unlock_irqrestore(&portdata->lock, flags);
+        usb_autopm_put_interface_async(serial->interface);
+error_simple:
         return retval;
 }
 
@@ -530,6 +579,7 @@ static void sierra_indat_callback(struct urb *urb)
 
         /* Resubmit urb so we continue receiving */
         if (port->port.count && status != -ESHUTDOWN && status != -EPERM) {
+                usb_mark_last_busy(port->serial->dev);
                 err = usb_submit_urb(urb, GFP_ATOMIC);
                 if (err)
                         dev_err(&port->dev, "resubmit read urb failed."
@@ -591,6 +641,7 @@ static void sierra_instat_callback(struct urb *urb)
 
         /* Resubmit urb so we continue receiving IRQ data */
         if (port->port.count && status != -ESHUTDOWN && status != -ENOENT) {
+                usb_mark_last_busy(serial->dev);
                 urb->dev = serial->dev;
                 err = usb_submit_urb(urb, GFP_ATOMIC);
                 if (err)
@@ -711,6 +762,8 @@ static void sierra_close(struct usb_serial_port *port)
         int i;
         struct usb_serial *serial = port->serial;
         struct sierra_port_private *portdata;
+        struct sierra_intf_private *intfdata = port->serial->private;
+
 
         dev_dbg(&port->dev, "%s\n", __func__);
         portdata = usb_get_serial_port_data(port);
@@ -723,6 +776,10 @@ static void sierra_close(struct usb_serial_port *port)
                 if (!serial->disconnected)
                         sierra_send_setup(port);
                 mutex_unlock(&serial->disc_mutex);
+                spin_lock_irq(&intfdata->susp_lock);
+                portdata->opened = 0;
+                spin_unlock_irq(&intfdata->susp_lock);
+
 
                 /* Stop reading urbs */
                 sierra_stop_rx_urbs(port);
@@ -731,6 +788,8 @@ static void sierra_close(struct usb_serial_port *port)
                         sierra_release_urb(portdata->in_urbs[i]);
                         portdata->in_urbs[i] = NULL;
                 }
+                usb_autopm_get_interface(serial->interface);
+                serial->interface->needs_remote_wakeup = 0;
         }
 }
 
@@ -738,6 +797,7 @@ static int sierra_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
         struct sierra_port_private *portdata;
         struct usb_serial *serial = port->serial;
+        struct sierra_intf_private *intfdata = serial->private;
         int i;
         int err;
         int endpoint;
@@ -771,6 +831,12 @@ static int sierra_open(struct tty_struct *tty, struct usb_serial_port *port)
         }
         sierra_send_setup(port);
 
+        serial->interface->needs_remote_wakeup = 1;
+        spin_lock_irq(&intfdata->susp_lock);
+        portdata->opened = 1;
+        spin_unlock_irq(&intfdata->susp_lock);
+        usb_autopm_put_interface(serial->interface);
+
         return 0;
 }
 
@@ -818,6 +884,8 @@ static int sierra_startup(struct usb_serial *serial)
                         return -ENOMEM;
                 }
                 spin_lock_init(&portdata->lock);
+                init_usb_anchor(&portdata->active);
+                init_usb_anchor(&portdata->delayed);
                 /* Set the port private data pointer */
                 usb_set_serial_port_data(port, portdata);
         }
@@ -844,6 +912,83 @@ static void sierra_release(struct usb_serial *serial)
         }
 }
 
+static void stop_read_write_urbs(struct usb_serial *serial)
+{
+        int i, j;
+        struct usb_serial_port *port;
+        struct sierra_port_private *portdata;
+
+        /* Stop reading/writing urbs */
+        for (i = 0; i < serial->num_ports; ++i) {
+                port = serial->port[i];
+                portdata = usb_get_serial_port_data(port);
+                for (j = 0; j < N_IN_URB; j++)
+                        usb_kill_urb(portdata->in_urbs[j]);
+                usb_kill_anchored_urbs(&portdata->active);
+        }
+}
+
+static int sierra_suspend(struct usb_serial *serial, pm_message_t message)
+{
+        struct sierra_intf_private *intfdata;
+        int b;
+
+        if (serial->dev->auto_pm) {
+                intfdata = serial->private;
+                spin_lock_irq(&intfdata->susp_lock);
+                b = intfdata->in_flight;
+
+                if (b) {
+                        spin_unlock_irq(&intfdata->susp_lock);
+                        return -EBUSY;
+                } else {
+                        intfdata->suspended = 1;
+                        spin_unlock_irq(&intfdata->susp_lock);
+                }
+        }
+        stop_read_write_urbs(serial);
+
+        return 0;
+}
+
+static int sierra_resume(struct usb_serial *serial)
+{
+        struct usb_serial_port *port;
+        struct sierra_intf_private *intfdata = serial->private;
+        struct sierra_port_private *portdata;
+        struct urb *urb;
+        int ec = 0;
+        int i, err;
+
+        spin_lock_irq(&intfdata->susp_lock);
+        for (i = 0; i < serial->num_ports; i++) {
+                port = serial->port[i];
+                portdata = usb_get_serial_port_data(port);
+
+                while ((urb = usb_get_from_anchor(&portdata->delayed))) {
+                        usb_anchor_urb(urb, &portdata->active);
+                        intfdata->in_flight++;
+                        err = usb_submit_urb(urb, GFP_ATOMIC);
+                        if (err < 0) {
+                                intfdata->in_flight--;
+                                usb_unanchor_urb(urb);
+                                usb_scuttle_anchored_urbs(&portdata->delayed);
+                                break;
+                        }
+                }
+
+                if (portdata->opened) {
+                        err = sierra_submit_rx_urbs(port, GFP_ATOMIC);
+                        if (err)
+                                ec++;
+                }
+        }
+        intfdata->suspended = 0;
+        spin_unlock_irq(&intfdata->susp_lock);
+
+        return ec ? -EIO : 0;
+}
+
 static struct usb_serial_driver sierra_device = {
         .driver = {
                 .owner =        THIS_MODULE,
@@ -864,6 +1009,8 @@ static struct usb_serial_driver sierra_device = {
         .tiocmset          = sierra_tiocmset,
         .attach            = sierra_startup,
         .release           = sierra_release,
+        .suspend           = sierra_suspend,
+        .resume            = sierra_resume,
         .read_int_callback = sierra_instat_callback,
 };
 
diff --git a/drivers/usb/serial/usb-serial.c b/drivers/usb/serial/usb-serial.c
index 9d7ca4868d37..ff75a3589e7e 100644
--- a/drivers/usb/serial/usb-serial.c
+++ b/drivers/usb/serial/usb-serial.c
@@ -35,6 +35,7 @@
 #include <linux/serial.h>
 #include <linux/usb.h>
 #include <linux/usb/serial.h>
+#include <linux/kfifo.h>
 #include "pl2303.h"
 
 /*
@@ -292,8 +293,6 @@ static int serial_open(struct tty_struct *tty, struct file *filp)
 static void serial_down(struct usb_serial_port *port)
 {
         struct usb_serial_driver *drv = port->serial->type;
-        struct usb_serial *serial;
-        struct module *owner;
 
         /*
          * The console is magical.  Do not hang up the console hardware
@@ -309,12 +308,8 @@ static void serial_down(struct usb_serial_port *port)
                 return;
 
         mutex_lock(&port->mutex);
-        serial = port->serial;
-        owner = serial->type->driver.owner;
-
         if (drv->close)
                 drv->close(port);
-
         mutex_unlock(&port->mutex);
 }
 
@@ -631,6 +626,8 @@ static void port_release(struct device *dev)
         usb_free_urb(port->write_urb);
         usb_free_urb(port->interrupt_in_urb);
         usb_free_urb(port->interrupt_out_urb);
+        if (!IS_ERR(port->write_fifo) && port->write_fifo)
+                kfifo_free(port->write_fifo);
         kfree(port->bulk_in_buffer);
         kfree(port->bulk_out_buffer);
         kfree(port->interrupt_in_buffer);
@@ -970,6 +967,10 @@ int usb_serial_probe(struct usb_interface *interface,
                         dev_err(&interface->dev, "No free urbs available\n");
                         goto probe_error;
                 }
+                port->write_fifo = kfifo_alloc(PAGE_SIZE, GFP_KERNEL,
+                        &port->lock);
+                if (IS_ERR(port->write_fifo))
+                        goto probe_error;
                 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
                 port->bulk_out_size = buffer_size;
                 port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
@@ -1163,15 +1164,19 @@ 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)
+                        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);