Merge branch 'wip-2.6.34' into old-private-masterarchived-private-master

1 files changed, 141 insertions, 115 deletions

diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
index ebcc6d0e2e91..1d7c4fac02e8 100644
--- a/drivers/usb/serial/ftdi_sio.c
+++ b/drivers/usb/serial/ftdi_sio.c
@@ -33,23 +33,24 @@
 #include <linux/errno.h>
 #include <linux/init.h>
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
 #include <linux/tty.h>
 #include <linux/tty_driver.h>
 #include <linux/tty_flip.h>
 #include <linux/module.h>
 #include <linux/spinlock.h>
+#include <linux/mutex.h>
 #include <linux/uaccess.h>
 #include <linux/usb.h>
 #include <linux/serial.h>
 #include <linux/usb/serial.h>
 #include "ftdi_sio.h"
+#include "ftdi_sio_ids.h"
 
 /*
  * Version Information
  */
 #define DRIVER_VERSION "v1.5.0"
-#define DRIVER_AUTHOR "Greg Kroah-Hartman <greg@kroah.com>, Bill Ryder <bryder@sgi.com>, Kuba Ober <kuba@mareimbrium.org>"
+#define DRIVER_AUTHOR "Greg Kroah-Hartman <greg@kroah.com>, Bill Ryder <bryder@sgi.com>, Kuba Ober <kuba@mareimbrium.org>, Andreas Mohr"
 #define DRIVER_DESC "USB FTDI Serial Converters Driver"
 
 static int debug;
@@ -87,10 +88,10 @@ struct ftdi_private {
 
         unsigned int latency;           /* latency setting in use */
         spinlock_t tx_lock;     /* spinlock for transmit state */
-        unsigned long tx_bytes;
         unsigned long tx_outstanding_bytes;
         unsigned long tx_outstanding_urbs;
         unsigned short max_packet_size;
+        struct mutex cfg_lock; /* Avoid mess by parallel calls of config ioctl() and change_speed() */
 };
 
 /* struct ftdi_sio_quirk is used by devices requiring special attention. */
@@ -144,10 +145,15 @@ static struct ftdi_sio_quirk ftdi_HE_TIRA1_quirk = {
 
 
 
+/*
+ * Device ID not listed? Test via module params product/vendor or
+ * /sys/bus/usb/ftdi_sio/new_id, then send patch/report!
+ */
 static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(FTDI_VID, FTDI_AMC232_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_CANUSB_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_CANDAPTER_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_NXTCAM_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_0_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_1_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_2_PID) },
@@ -551,9 +557,16 @@ static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(FTDI_VID, FTDI_IBS_PEDO_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_IBS_PROD_PID) },
         /*
-         * Due to many user requests for multiple ELV devices we enable
-         * them by default.
+         * ELV devices:
          */
+        { USB_DEVICE(FTDI_VID, FTDI_ELV_USR_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_ELV_MSM1_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_ELV_KL100_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_ELV_WS550_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_ELV_EC3000_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_ELV_WS888_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_ELV_TWS550_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_ELV_FEM_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_ELV_CLI7000_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_ELV_PPS7330_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_ELV_TFM100_PID) },
@@ -570,11 +583,17 @@ static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(FTDI_VID, FTDI_ELV_PCK100_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_ELV_RFP500_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_ELV_FS20SIG_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_ELV_UTP8_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_ELV_WS300PC_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_ELV_WS444PC_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_ELV_FHZ1300PC_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_ELV_EM1010PC_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_ELV_WS500_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_ELV_HS485_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_ELV_UMS100_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_ELV_TFD128_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_ELV_FM3RX_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_ELV_WS777_PID) },
         { USB_DEVICE(FTDI_VID, LINX_SDMUSBQSS_PID) },
         { USB_DEVICE(FTDI_VID, LINX_MASTERDEVEL2_PID) },
         { USB_DEVICE(FTDI_VID, LINX_FUTURE_0_PID) },
@@ -595,9 +614,24 @@ static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(FTDI_VID, FTDI_OCEANIC_PID) },
         { USB_DEVICE(TTI_VID, TTI_QL355P_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_RM_CANVIEW_PID) },
+        { USB_DEVICE(CONTEC_VID, CONTEC_COM1USBH_PID) },
         { USB_DEVICE(BANDB_VID, BANDB_USOTL4_PID) },
         { USB_DEVICE(BANDB_VID, BANDB_USTL4_PID) },
         { USB_DEVICE(BANDB_VID, BANDB_USO9ML2_PID) },
+        { USB_DEVICE(BANDB_VID, BANDB_USOPTL4_PID) },
+        { USB_DEVICE(BANDB_VID, BANDB_USPTL4_PID) },
+        { USB_DEVICE(BANDB_VID, BANDB_USO9ML2DR_2_PID) },
+        { USB_DEVICE(BANDB_VID, BANDB_USO9ML2DR_PID) },
+        { USB_DEVICE(BANDB_VID, BANDB_USOPTL4DR2_PID) },
+        { USB_DEVICE(BANDB_VID, BANDB_USOPTL4DR_PID) },
+        { USB_DEVICE(BANDB_VID, BANDB_485USB9F_2W_PID) },
+        { USB_DEVICE(BANDB_VID, BANDB_485USB9F_4W_PID) },
+        { USB_DEVICE(BANDB_VID, BANDB_232USB9M_PID) },
+        { USB_DEVICE(BANDB_VID, BANDB_485USBTB_2W_PID) },
+        { USB_DEVICE(BANDB_VID, BANDB_485USBTB_4W_PID) },
+        { USB_DEVICE(BANDB_VID, BANDB_TTL5USB9M_PID) },
+        { USB_DEVICE(BANDB_VID, BANDB_TTL3USB9M_PID) },
+        { USB_DEVICE(BANDB_VID, BANDB_ZZ_PROG1_USB_PID) },
         { USB_DEVICE(FTDI_VID, EVER_ECO_PRO_CDS) },
         { USB_DEVICE(FTDI_VID, FTDI_4N_GALAXY_DE_1_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_4N_GALAXY_DE_2_PID) },
@@ -624,6 +658,7 @@ static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(EVOLUTION_VID, EVOLUTION_ER1_PID) },
         { USB_DEVICE(EVOLUTION_VID, EVO_HYBRID_PID) },
         { USB_DEVICE(EVOLUTION_VID, EVO_RCM4_PID) },
+        { USB_DEVICE(CONTEC_VID, CONTEC_COM1USBH_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_ARTEMIS_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16C_PID) },
@@ -682,6 +717,7 @@ static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID_USB60F) },
         { USB_DEVICE(FTDI_VID, FTDI_REU_TINY_PID) },
         { USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO4x4_PID) },
+        { USB_DEVICE(PAPOUCH_VID, PAPOUCH_AD4USB_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_DOMINTELL_DGQG_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_DOMINTELL_DUSB_PID) },
         { USB_DEVICE(ALTI2_VID, ALTI2_N3_PID) },
@@ -703,6 +739,10 @@ static struct usb_device_id id_table_combined [] = {
                 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
         { USB_DEVICE(FTDI_VID, HAMEG_HO820_PID) },
         { USB_DEVICE(FTDI_VID, HAMEG_HO870_PID) },
+        { USB_DEVICE(FTDI_VID, MJSG_GENERIC_PID) },
+        { USB_DEVICE(FTDI_VID, MJSG_SR_RADIO_PID) },
+        { USB_DEVICE(FTDI_VID, MJSG_HD_RADIO_PID) },
+        { USB_DEVICE(FTDI_VID, MJSG_XM_RADIO_PID) },
         { },                                    /* Optional parameter entry */
         { }                                     /* Terminating entry */
 };
@@ -778,7 +818,7 @@ static struct usb_serial_driver ftdi_sio_device = {
                 .name =         "ftdi_sio",
         },
         .description =          "FTDI USB Serial Device",
-        .usb_driver =           &ftdi_driver ,
+        .usb_driver =           &ftdi_driver,
         .id_table =             id_table_combined,
         .num_ports =            1,
         .probe =                ftdi_sio_probe,
@@ -794,8 +834,8 @@ static struct usb_serial_driver ftdi_sio_device = {
         .chars_in_buffer =      ftdi_chars_in_buffer,
         .read_bulk_callback =   ftdi_read_bulk_callback,
         .write_bulk_callback =  ftdi_write_bulk_callback,
-        .tiocmget =             ftdi_tiocmget,
-        .tiocmset =             ftdi_tiocmset,
+        .tiocmget =             ftdi_tiocmget,
+        .tiocmset =             ftdi_tiocmset,
         .ioctl =                ftdi_ioctl,
         .set_termios =          ftdi_set_termios,
         .break_ctl =            ftdi_break_ctl,
@@ -901,7 +941,6 @@ static int update_mctrl(struct usb_serial_port *port, unsigned int set,
                                                         unsigned int clear)
 {
         struct ftdi_private *priv = usb_get_serial_port_data(port);
-        char *buf;
         unsigned urb_value;
         int rv;
 
@@ -910,10 +949,6 @@ static int update_mctrl(struct usb_serial_port *port, unsigned int set,
                 return 0;       /* no change */
         }
 
-        buf = kmalloc(1, GFP_NOIO);
-        if (!buf)
-                return -ENOMEM;
-
         clear &= ~set;  /* 'set' takes precedence over 'clear' */
         urb_value = 0;
         if (clear & TIOCM_DTR)
@@ -929,9 +964,7 @@ static int update_mctrl(struct usb_serial_port *port, unsigned int set,
                                FTDI_SIO_SET_MODEM_CTRL_REQUEST,
                                FTDI_SIO_SET_MODEM_CTRL_REQUEST_TYPE,
                                urb_value, priv->interface,
-                               buf, 0, WDR_TIMEOUT);
-
-        kfree(buf);
+                               NULL, 0, WDR_TIMEOUT);
         if (rv < 0) {
                 dbg("%s Error from MODEM_CTRL urb: DTR %s, RTS %s",
                                 __func__,
@@ -1090,16 +1123,11 @@ static __u32 get_ftdi_divisor(struct tty_struct *tty,
 static int change_speed(struct tty_struct *tty, struct usb_serial_port *port)
 {
         struct ftdi_private *priv = usb_get_serial_port_data(port);
-        char *buf;
         __u16 urb_value;
         __u16 urb_index;
         __u32 urb_index_value;
         int rv;
 
-        buf = kmalloc(1, GFP_NOIO);
-        if (!buf)
-                return -ENOMEM;
-
         urb_index_value = get_ftdi_divisor(tty, port);
         urb_value = (__u16)urb_index_value;
         urb_index = (__u16)(urb_index_value >> 16);
@@ -1112,9 +1140,7 @@ static int change_speed(struct tty_struct *tty, struct usb_serial_port *port)
                             FTDI_SIO_SET_BAUDRATE_REQUEST,
                             FTDI_SIO_SET_BAUDRATE_REQUEST_TYPE,
                             urb_value, urb_index,
-                            buf, 0, WDR_SHORT_TIMEOUT);
-
-        kfree(buf);
+                            NULL, 0, WDR_SHORT_TIMEOUT);
         return rv;
 }
 
@@ -1122,8 +1148,7 @@ static int write_latency_timer(struct usb_serial_port *port)
 {
         struct ftdi_private *priv = usb_get_serial_port_data(port);
         struct usb_device *udev = port->serial->dev;
-        char buf[1];
-        int rv = 0;
+        int rv;
         int l = priv->latency;
 
         if (priv->flags & ASYNC_LOW_LATENCY)
@@ -1136,8 +1161,7 @@ static int write_latency_timer(struct usb_serial_port *port)
                              FTDI_SIO_SET_LATENCY_TIMER_REQUEST,
                              FTDI_SIO_SET_LATENCY_TIMER_REQUEST_TYPE,
                              l, priv->interface,
-                             buf, 0, WDR_TIMEOUT);
-
+                             NULL, 0, WDR_TIMEOUT);
         if (rv < 0)
                 dev_err(&port->dev, "Unable to write latency timer: %i\n", rv);
         return rv;
@@ -1147,24 +1171,29 @@ static int read_latency_timer(struct usb_serial_port *port)
 {
         struct ftdi_private *priv = usb_get_serial_port_data(port);
         struct usb_device *udev = port->serial->dev;
-        unsigned short latency = 0;
-        int rv = 0;
-
+        unsigned char *buf;
+        int rv;
 
         dbg("%s", __func__);
 
+        buf = kmalloc(1, GFP_KERNEL);
+        if (!buf)
+                return -ENOMEM;
+
         rv = usb_control_msg(udev,
                              usb_rcvctrlpipe(udev, 0),
                              FTDI_SIO_GET_LATENCY_TIMER_REQUEST,
                              FTDI_SIO_GET_LATENCY_TIMER_REQUEST_TYPE,
                              0, priv->interface,
-                             (char *) &latency, 1, WDR_TIMEOUT);
-
-        if (rv < 0) {
+                             buf, 1, WDR_TIMEOUT);
+        if (rv < 0)
                 dev_err(&port->dev, "Unable to read latency timer: %i\n", rv);
-                return -EIO;
-        }
-        return latency;
+        else
+                priv->latency = buf[0];
+
+        kfree(buf);
+
+        return rv;
 }
 
 static int get_serial_info(struct usb_serial_port *port,
@@ -1195,7 +1224,7 @@ static int set_serial_info(struct tty_struct *tty,
         if (copy_from_user(&new_serial, newinfo, sizeof(new_serial)))
                 return -EFAULT;
 
-        lock_kernel();
+        mutex_lock(&priv->cfg_lock);
         old_priv = *priv;
 
         /* Do error checking and permission checking */
@@ -1203,7 +1232,7 @@ static int set_serial_info(struct tty_struct *tty,
         if (!capable(CAP_SYS_ADMIN)) {
                 if (((new_serial.flags & ~ASYNC_USR_MASK) !=
                      (priv->flags & ~ASYNC_USR_MASK))) {
-                        unlock_kernel();
+                        mutex_unlock(&priv->cfg_lock);
                         return -EPERM;
                 }
                 priv->flags = ((priv->flags & ~ASYNC_USR_MASK) |
@@ -1214,7 +1243,7 @@ static int set_serial_info(struct tty_struct *tty,
 
         if ((new_serial.baud_base != priv->baud_base) &&
             (new_serial.baud_base < 9600)) {
-                unlock_kernel();
+                mutex_unlock(&priv->cfg_lock);
                 return -EINVAL;
         }
 
@@ -1244,11 +1273,11 @@ check_and_exit:
              (priv->flags & ASYNC_SPD_MASK)) ||
             (((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST) &&
              (old_priv.custom_divisor != priv->custom_divisor))) {
-                unlock_kernel();
                 change_speed(tty, port);
+                mutex_unlock(&priv->cfg_lock);
         }
         else
-                unlock_kernel();
+                mutex_unlock(&priv->cfg_lock);
         return 0;
 
 } /* set_serial_info */
@@ -1304,20 +1333,20 @@ static void ftdi_determine_type(struct usb_serial_port *port)
                                         __func__);
                 }
         } else if (version < 0x200) {
-                /* Old device.  Assume its the original SIO. */
+                /* Old device.  Assume it's the original SIO. */
                 priv->chip_type = SIO;
                 priv->baud_base = 12000000 / 16;
                 priv->write_offset = 1;
         } else if (version < 0x400) {
-                /* Assume its an FT8U232AM (or FT8U245AM) */
+                /* Assume it's an FT8U232AM (or FT8U245AM) */
                 /* (It might be a BM because of the iSerialNumber bug,
                  * but it will still work as an AM device.) */
                 priv->chip_type = FT8U232AM;
         } else if (version < 0x600) {
-                /* Assume its an FT232BM (or FT245BM) */
+                /* Assume it's an FT232BM (or FT245BM) */
                 priv->chip_type = FT232BM;
         } else {
-                /* Assume its an FT232R  */
+                /* Assume it's an FT232R */
                 priv->chip_type = FT232RL;
         }
         dev_info(&udev->dev, "Detected %s\n", ftdi_chip_name[priv->chip_type]);
@@ -1337,7 +1366,7 @@ static void ftdi_set_max_packet_size(struct usb_serial_port *port)
         struct usb_endpoint_descriptor *ep_desc = &interface->cur_altsetting->endpoint[1].desc;
 
         unsigned num_endpoints;
-        int i = 0;
+        int i;
 
         num_endpoints = interface->cur_altsetting->desc.bNumEndpoints;
         dev_info(&udev->dev, "Number of endpoints %d\n", num_endpoints);
@@ -1389,7 +1418,7 @@ static ssize_t store_latency_timer(struct device *dev,
         struct usb_serial_port *port = to_usb_serial_port(dev);
         struct ftdi_private *priv = usb_get_serial_port_data(port);
         int v = simple_strtoul(valbuf, NULL, 10);
-        int rv = 0;
+        int rv;
 
         priv->latency = v;
         rv = write_latency_timer(port);
@@ -1406,9 +1435,8 @@ static ssize_t store_event_char(struct device *dev,
         struct usb_serial_port *port = to_usb_serial_port(dev);
         struct ftdi_private *priv = usb_get_serial_port_data(port);
         struct usb_device *udev = port->serial->dev;
-        char buf[1];
         int v = simple_strtoul(valbuf, NULL, 10);
-        int rv = 0;
+        int rv;
 
         dbg("%s: setting event char = %i", __func__, v);
 
@@ -1417,8 +1445,7 @@ static ssize_t store_event_char(struct device *dev,
                              FTDI_SIO_SET_EVENT_CHAR_REQUEST,
                              FTDI_SIO_SET_EVENT_CHAR_REQUEST_TYPE,
                              v, priv->interface,
-                             buf, 0, WDR_TIMEOUT);
-
+                             NULL, 0, WDR_TIMEOUT);
         if (rv < 0) {
                 dbg("Unable to write event character: %i", rv);
                 return -EIO;
@@ -1517,9 +1544,9 @@ static int ftdi_sio_port_probe(struct usb_serial_port *port)
 
         kref_init(&priv->kref);
         spin_lock_init(&priv->tx_lock);
+        mutex_init(&priv->cfg_lock);
         init_waitqueue_head(&priv->delta_msr_wait);
-        /* This will push the characters through immediately rather
-           than queue a task to deliver them */
+
         priv->flags = ASYNC_LOW_LATENCY;
 
         if (quirk && quirk->port_probe)
@@ -1551,7 +1578,8 @@ static int ftdi_sio_port_probe(struct usb_serial_port *port)
 
         ftdi_determine_type(port);
         ftdi_set_max_packet_size(port);
-        read_latency_timer(port);
+        if (read_latency_timer(port) < 0)
+                priv->latency = 16;
         create_sysfs_attrs(port);
         return 0;
 }
@@ -1596,8 +1624,6 @@ static int ftdi_NDI_device_setup(struct usb_serial *serial)
 {
         struct usb_device *udev = serial->dev;
         int latency = ndi_latency_timer;
-        int rv = 0;
-        char buf[1];
 
         if (latency == 0)
                 latency = 1;
@@ -1607,10 +1633,11 @@ static int ftdi_NDI_device_setup(struct usb_serial *serial)
         dbg("%s setting NDI device latency to %d", __func__, latency);
         dev_info(&udev->dev, "NDI device with a latency value of %d", latency);
 
-        rv = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
+        /* FIXME: errors are not returned */
+        usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
                                 FTDI_SIO_SET_LATENCY_TIMER_REQUEST,
                                 FTDI_SIO_SET_LATENCY_TIMER_REQUEST_TYPE,
-                                latency, 0, buf, 0, WDR_TIMEOUT);
+                                latency, 0, NULL, 0, WDR_TIMEOUT);
         return 0;
 }
 
@@ -1686,7 +1713,7 @@ static int ftdi_submit_read_urb(struct usb_serial_port *port, gfp_t mem_flags)
                            urb->transfer_buffer_length,
                            ftdi_read_bulk_callback, port);
         result = usb_submit_urb(urb, mem_flags);
-        if (result)
+        if (result && result != -EPERM)
                 dev_err(&port->dev,
                         "%s - failed submitting read urb, error %d\n",
                                                         __func__, result);
@@ -1698,16 +1725,10 @@ static int ftdi_open(struct tty_struct *tty, struct usb_serial_port *port)
         struct usb_device *dev = port->serial->dev;
         struct ftdi_private *priv = usb_get_serial_port_data(port);
         unsigned long flags;
-
-        int result = 0;
-        char buf[1]; /* Needed for the usb_control_msg I think */
+        int result;
 
         dbg("%s", __func__);
 
-        spin_lock_irqsave(&priv->tx_lock, flags);
-        priv->tx_bytes = 0;
-        spin_unlock_irqrestore(&priv->tx_lock, flags);
-
         write_latency_timer(port);
 
         /* No error checking for this (will get errors later anyway) */
@@ -1715,7 +1736,7 @@ static int ftdi_open(struct tty_struct *tty, struct usb_serial_port *port)
         usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
                         FTDI_SIO_RESET_REQUEST, FTDI_SIO_RESET_REQUEST_TYPE,
                         FTDI_SIO_RESET_SIO,
-                        priv->interface, buf, 0, WDR_TIMEOUT);
+                        priv->interface, NULL, 0, WDR_TIMEOUT);
 
         /* Termios defaults are set by usb_serial_init. We don't change
            port->tty->termios - this would lose speed settings, etc.
@@ -1743,7 +1764,6 @@ static int ftdi_open(struct tty_struct *tty, struct usb_serial_port *port)
 static void ftdi_dtr_rts(struct usb_serial_port *port, int on)
 {
         struct ftdi_private *priv = usb_get_serial_port_data(port);
-        char buf[1];
 
         mutex_lock(&port->serial->disc_mutex);
         if (!port->serial->disconnected) {
@@ -1752,7 +1772,7 @@ static void ftdi_dtr_rts(struct usb_serial_port *port, int on)
                             usb_sndctrlpipe(port->serial->dev, 0),
                             FTDI_SIO_SET_FLOW_CTRL_REQUEST,
                             FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
-                            0, priv->interface, buf, 0,
+                            0, priv->interface, NULL, 0,
                             WDR_TIMEOUT) < 0) {
                             dev_err(&port->dev, "error from flowcontrol urb\n");
                 }
@@ -1813,7 +1833,7 @@ static int ftdi_write(struct tty_struct *tty, struct usb_serial_port *port,
         spin_lock_irqsave(&priv->tx_lock, flags);
         if (priv->tx_outstanding_urbs > URB_UPPER_LIMIT) {
                 spin_unlock_irqrestore(&priv->tx_lock, flags);
-                dbg("%s - write limit hit\n", __func__);
+                dbg("%s - write limit hit", __func__);
                 return 0;
         }
         priv->tx_outstanding_urbs++;
@@ -1893,7 +1913,6 @@ static int ftdi_write(struct tty_struct *tty, struct usb_serial_port *port,
         } else {
                 spin_lock_irqsave(&priv->tx_lock, flags);
                 priv->tx_outstanding_bytes += count;
-                priv->tx_bytes += count;
                 spin_unlock_irqrestore(&priv->tx_lock, flags);
         }
 
@@ -2120,8 +2139,7 @@ static void ftdi_break_ctl(struct tty_struct *tty, int break_state)
 {
         struct usb_serial_port *port = tty->driver_data;
         struct ftdi_private *priv = usb_get_serial_port_data(port);
-        __u16 urb_value = 0;
-        char buf[1];
+        __u16 urb_value;
 
         /* break_state = -1 to turn on break, and 0 to turn off break */
         /* see drivers/char/tty_io.c to see it used */
@@ -2137,7 +2155,7 @@ static void ftdi_break_ctl(struct tty_struct *tty, int break_state)
                         FTDI_SIO_SET_DATA_REQUEST,
                         FTDI_SIO_SET_DATA_REQUEST_TYPE,
                         urb_value , priv->interface,
-                        buf, 0, WDR_TIMEOUT) < 0) {
+                        NULL, 0, WDR_TIMEOUT) < 0) {
                 dev_err(&port->dev, "%s FAILED to enable/disable break state "
                         "(state was %d)\n", __func__, break_state);
         }
@@ -2161,7 +2179,6 @@ static void ftdi_set_termios(struct tty_struct *tty,
         struct ktermios *termios = tty->termios;
         unsigned int cflag = termios->c_cflag;
         __u16 urb_value; /* will hold the new flags */
-        char buf[1]; /* Perhaps I should dynamically alloc this? */
 
         /* Added for xon/xoff support */
         unsigned int iflag = termios->c_iflag;
@@ -2195,23 +2212,27 @@ static void ftdi_set_termios(struct tty_struct *tty,
 
         /* Set number of data bits, parity, stop bits */
 
-        termios->c_cflag &= ~CMSPAR;
-
         urb_value = 0;
         urb_value |= (cflag & CSTOPB ? FTDI_SIO_SET_DATA_STOP_BITS_2 :
                       FTDI_SIO_SET_DATA_STOP_BITS_1);
-        urb_value |= (cflag & PARENB ?
-                      (cflag & PARODD ? FTDI_SIO_SET_DATA_PARITY_ODD :
-                       FTDI_SIO_SET_DATA_PARITY_EVEN) :
-                      FTDI_SIO_SET_DATA_PARITY_NONE);
+        if (cflag & PARENB) {
+                if (cflag & CMSPAR)
+                        urb_value |= cflag & PARODD ?
+                                     FTDI_SIO_SET_DATA_PARITY_MARK :
+                                     FTDI_SIO_SET_DATA_PARITY_SPACE;
+                else
+                        urb_value |= cflag & PARODD ?
+                                     FTDI_SIO_SET_DATA_PARITY_ODD :
+                                     FTDI_SIO_SET_DATA_PARITY_EVEN;
+        } else {
+                urb_value |= FTDI_SIO_SET_DATA_PARITY_NONE;
+        }
         if (cflag & CSIZE) {
                 switch (cflag & CSIZE) {
-                case CS5: urb_value |= 5; dbg("Setting CS5"); break;
-                case CS6: urb_value |= 6; dbg("Setting CS6"); break;
                 case CS7: urb_value |= 7; dbg("Setting CS7"); break;
                 case CS8: urb_value |= 8; dbg("Setting CS8"); break;
                 default:
-                        dev_err(&port->dev, "CSIZE was set but not CS5-CS8\n");
+                        dev_err(&port->dev, "CSIZE was set but not CS7-CS8\n");
                 }
         }
 
@@ -2223,7 +2244,7 @@ static void ftdi_set_termios(struct tty_struct *tty,
                             FTDI_SIO_SET_DATA_REQUEST,
                             FTDI_SIO_SET_DATA_REQUEST_TYPE,
                             urb_value , priv->interface,
-                            buf, 0, WDR_SHORT_TIMEOUT) < 0) {
+                            NULL, 0, WDR_SHORT_TIMEOUT) < 0) {
                 dev_err(&port->dev, "%s FAILED to set "
                         "databits/stopbits/parity\n", __func__);
         }
@@ -2235,7 +2256,7 @@ static void ftdi_set_termios(struct tty_struct *tty,
                                     FTDI_SIO_SET_FLOW_CTRL_REQUEST,
                                     FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
                                     0, priv->interface,
-                                    buf, 0, WDR_TIMEOUT) < 0) {
+                                    NULL, 0, WDR_TIMEOUT) < 0) {
                         dev_err(&port->dev,
                                 "%s error from disable flowcontrol urb\n",
                                 __func__);
@@ -2244,9 +2265,11 @@ static void ftdi_set_termios(struct tty_struct *tty,
                 clear_mctrl(port, TIOCM_DTR | TIOCM_RTS);
         } else {
                 /* set the baudrate determined before */
+                mutex_lock(&priv->cfg_lock);
                 if (change_speed(tty, port))
                         dev_err(&port->dev, "%s urb failed to set baudrate\n",
                                 __func__);
+                mutex_unlock(&priv->cfg_lock);
                 /* Ensure RTS and DTR are raised when baudrate changed from 0 */
                 if (!old_termios || (old_termios->c_cflag & CBAUD) == B0)
                         set_mctrl(port, TIOCM_DTR | TIOCM_RTS);
@@ -2261,7 +2284,7 @@ static void ftdi_set_termios(struct tty_struct *tty,
                                     FTDI_SIO_SET_FLOW_CTRL_REQUEST,
                                     FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
                                     0 , (FTDI_SIO_RTS_CTS_HS | priv->interface),
-                                    buf, 0, WDR_TIMEOUT) < 0) {
+                                    NULL, 0, WDR_TIMEOUT) < 0) {
                         dev_err(&port->dev,
                                 "urb failed to set to rts/cts flow control\n");
                 }
@@ -2293,7 +2316,7 @@ static void ftdi_set_termios(struct tty_struct *tty,
                                             FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
                                             urb_value , (FTDI_SIO_XON_XOFF_HS
                                                          | priv->interface),
-                                            buf, 0, WDR_TIMEOUT) < 0) {
+                                            NULL, 0, WDR_TIMEOUT) < 0) {
                                 dev_err(&port->dev, "urb failed to set to "
                                         "xon/xoff flow control\n");
                         }
@@ -2307,7 +2330,7 @@ static void ftdi_set_termios(struct tty_struct *tty,
                                             FTDI_SIO_SET_FLOW_CTRL_REQUEST,
                                             FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
                                             0, priv->interface,
-                                            buf, 0, WDR_TIMEOUT) < 0) {
+                                            NULL, 0, WDR_TIMEOUT) < 0) {
                                 dev_err(&port->dev,
                                         "urb failed to clear flow control\n");
                         }
@@ -2321,21 +2344,22 @@ static int ftdi_tiocmget(struct tty_struct *tty, struct file *file)
 {
         struct usb_serial_port *port = tty->driver_data;
         struct ftdi_private *priv = usb_get_serial_port_data(port);
-        unsigned char buf[2];
+        unsigned char *buf;
+        int len;
         int ret;
 
         dbg("%s TIOCMGET", __func__);
+
+        buf = kmalloc(2, GFP_KERNEL);
+        if (!buf)
+                return -ENOMEM;
+        /*
+         * The 8U232AM returns a two byte value (the SIO a 1 byte value) in
+         * the same format as the data returned from the in point.
+         */
         switch (priv->chip_type) {
         case SIO:
-                /* Request the status from the device */
-                ret = usb_control_msg(port->serial->dev,
-                           usb_rcvctrlpipe(port->serial->dev, 0),
-                           FTDI_SIO_GET_MODEM_STATUS_REQUEST,
-                           FTDI_SIO_GET_MODEM_STATUS_REQUEST_TYPE,
-                           0, 0,
-                           buf, 1, WDR_TIMEOUT);
-                if (ret < 0)
-                        return ret;
+                len = 1;
                 break;
         case FT8U232AM:
         case FT232BM:
@@ -2343,27 +2367,30 @@ static int ftdi_tiocmget(struct tty_struct *tty, struct file *file)
         case FT232RL:
         case FT2232H:
         case FT4232H:
-                /* the 8U232AM returns a two byte value (the sio is a 1 byte
-                   value) - in the same format as the data returned from the in
-                   point */
-                ret = usb_control_msg(port->serial->dev,
-                                   usb_rcvctrlpipe(port->serial->dev, 0),
-                                   FTDI_SIO_GET_MODEM_STATUS_REQUEST,
-                                   FTDI_SIO_GET_MODEM_STATUS_REQUEST_TYPE,
-                                   0, priv->interface,
-                                   buf, 2, WDR_TIMEOUT);
-                if (ret < 0)
-                        return ret;
+                len = 2;
                 break;
         default:
-                return -EFAULT;
+                ret = -EFAULT;
+                goto out;
         }
 
-        return  (buf[0] & FTDI_SIO_DSR_MASK ? TIOCM_DSR : 0) |
+        ret = usb_control_msg(port->serial->dev,
+                        usb_rcvctrlpipe(port->serial->dev, 0),
+                        FTDI_SIO_GET_MODEM_STATUS_REQUEST,
+                        FTDI_SIO_GET_MODEM_STATUS_REQUEST_TYPE,
+                        0, priv->interface,
+                        buf, len, WDR_TIMEOUT);
+        if (ret < 0)
+                goto out;
+
+        ret = (buf[0] & FTDI_SIO_DSR_MASK ? TIOCM_DSR : 0) |
                 (buf[0] & FTDI_SIO_CTS_MASK ? TIOCM_CTS : 0) |
                 (buf[0]  & FTDI_SIO_RI_MASK  ? TIOCM_RI  : 0) |
                 (buf[0]  & FTDI_SIO_RLSD_MASK ? TIOCM_CD  : 0) |
                 priv->last_dtr_rts;
+out:
+        kfree(buf);
+        return ret;
 }
 
 static int ftdi_tiocmset(struct tty_struct *tty, struct file *file,
@@ -2468,8 +2495,7 @@ void ftdi_unthrottle(struct tty_struct *tty)
         port->throttled = port->throttle_req = 0;
         spin_unlock_irqrestore(&port->lock, flags);
 
-        /* Resubmit urb if throttled and open. */
-        if (was_throttled && test_bit(ASYNCB_INITIALIZED, &port->port.flags))
+        if (was_throttled)
                 ftdi_submit_read_urb(port, GFP_KERNEL);
 }