18 files changed, 93 insertions, 93 deletions

diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c
index adfae9d1ce..bfc59a1047 100644
--- a/drivers/ata/libata-core.c
+++ b/drivers/ata/libata-core.c
@@ -600,8 +600,9 @@ static const char *sata_spd_string(unsigned int spd)
 
 void ata_dev_disable(struct ata_device *dev)
 {
-        if (ata_dev_enabled(dev) && ata_msg_drv(dev->ap)) {
-                ata_dev_printk(dev, KERN_WARNING, "disabled\n");
+        if (ata_dev_enabled(dev)) {
+                if (ata_msg_drv(dev->ap))
+                        ata_dev_printk(dev, KERN_WARNING, "disabled\n");
                 ata_down_xfermask_limit(dev, ATA_DNXFER_FORCE_PIO0 |
                                              ATA_DNXFER_QUIET);
                 dev->class++;
@@ -983,11 +984,6 @@ static u64 ata_hpa_resize(struct ata_device *dev)
         else
                 hpa_sectors = ata_read_native_max_address(dev);
 
-        /* if no hpa, both should be equal */
-        ata_dev_printk(dev, KERN_INFO, "%s 1: sectors = %lld, "
-                                "hpa_sectors = %lld\n",
-                __FUNCTION__, (long long)sectors, (long long)hpa_sectors);
-
         if (hpa_sectors > sectors) {
                 ata_dev_printk(dev, KERN_INFO,
                         "Host Protected Area detected:\n"
@@ -1009,7 +1005,11 @@ static u64 ata_hpa_resize(struct ata_device *dev)
                                 return hpa_sectors;
                         }
                 }
-        }
+        } else if (hpa_sectors < sectors)
+                ata_dev_printk(dev, KERN_WARNING, "%s 1: hpa sectors (%lld) "
+                               "is smaller than sectors (%lld)\n", __FUNCTION__,
+                               (long long)hpa_sectors, (long long)sectors);
+
         return sectors;
 }
 
@@ -2046,10 +2046,6 @@ int ata_dev_configure(struct ata_device *dev)
                 dev->max_sectors = min_t(unsigned int, ATA_MAX_SECTORS_128,
                                          dev->max_sectors);
 
-        /* limit ATAPI DMA to R/W commands only */
-        if (ata_device_blacklisted(dev) & ATA_HORKAGE_DMA_RW_ONLY)
-                dev->horkage |= ATA_HORKAGE_DMA_RW_ONLY;
-
         if (ap->ops->dev_config)
                 ap->ops->dev_config(dev);
 
@@ -3780,8 +3776,7 @@ static const struct ata_blacklist_entry ata_device_blacklist [] = {
         { "IOMEGA  ZIP 250       ATAPI", NULL,  ATA_HORKAGE_NODMA }, /* temporary fix */
 
         /* Weird ATAPI devices */
-        { "TORiSAN DVD-ROM DRD-N216", NULL,     ATA_HORKAGE_MAX_SEC_128 |
-                                                ATA_HORKAGE_DMA_RW_ONLY },
+        { "TORiSAN DVD-ROM DRD-N216", NULL,     ATA_HORKAGE_MAX_SEC_128 },
 
         /* Devices we expect to fail diagnostics */
 
@@ -4109,6 +4104,7 @@ static void ata_fill_sg(struct ata_queued_cmd *qc)
         if (idx)
                 ap->prd[idx - 1].flags_len |= cpu_to_le32(ATA_PRD_EOT);
 }
+
 /**
  *      ata_check_atapi_dma - Check whether ATAPI DMA can be supported
  *      @qc: Metadata associated with taskfile to check
@@ -4126,33 +4122,19 @@ static void ata_fill_sg(struct ata_queued_cmd *qc)
 int ata_check_atapi_dma(struct ata_queued_cmd *qc)
 {
         struct ata_port *ap = qc->ap;
-        int rc = 0; /* Assume ATAPI DMA is OK by default */
-
-        /* some drives can only do ATAPI DMA on read/write */
-        if (unlikely(qc->dev->horkage & ATA_HORKAGE_DMA_RW_ONLY)) {
-                struct scsi_cmnd *cmd = qc->scsicmd;
-                u8 *scsicmd = cmd->cmnd;
-
-                switch (scsicmd[0]) {
-                case READ_10:
-                case WRITE_10:
-                case READ_12:
-                case WRITE_12:
-                case READ_6:
-                case WRITE_6:
-                        /* atapi dma maybe ok */
-                        break;
-                default:
-                        /* turn off atapi dma */
-                        return 1;
-                }
-        }
+
+        /* Don't allow DMA if it isn't multiple of 16 bytes.  Quite a
+         * few ATAPI devices choke on such DMA requests.
+         */
+        if (unlikely(qc->nbytes & 15))
+                return 1;
 
         if (ap->ops->check_atapi_dma)
-                rc = ap->ops->check_atapi_dma(qc);
+                return ap->ops->check_atapi_dma(qc);
 
-        return rc;
+        return 0;
 }
+
 /**
  *      ata_qc_prep - Prepare taskfile for submission
  *      @qc: Metadata associated with taskfile to be prepared
diff --git a/drivers/ata/libata-eh.c b/drivers/ata/libata-eh.c
index d8070989a3..f7582c9c32 100644
--- a/drivers/ata/libata-eh.c
+++ b/drivers/ata/libata-eh.c
@@ -336,6 +336,7 @@ void ata_scsi_error(struct Scsi_Host *host)
                         }
                         ata_port_printk(ap, KERN_ERR, "EH pending after %d "
                                         "tries, giving up\n", ATA_EH_MAX_REPEAT);
+                        ap->pflags &= ~ATA_PFLAG_EH_PENDING;
                 }
 
                 /* this run is complete, make sure EH info is clear */
@@ -1616,7 +1617,7 @@ static int ata_eh_reset(struct ata_port *ap, int classify,
         unsigned long deadline;
         unsigned int action;
         ata_reset_fn_t reset;
-        int i, did_followup_srst, rc;
+        int i, rc;
 
         /* about to reset */
         ata_eh_about_to_do(ap, NULL, ehc->i.action & ATA_EH_RESET_MASK);
@@ -1665,8 +1666,6 @@ static int ata_eh_reset(struct ata_port *ap, int classify,
 
         /* did prereset() screw up?  if so, fix up to avoid oopsing */
         if (!reset) {
-                ata_port_printk(ap, KERN_ERR, "BUG: prereset() requested "
-                                "invalid reset type\n");
                 if (softreset)
                         reset = softreset;
                 else
@@ -1689,11 +1688,9 @@ static int ata_eh_reset(struct ata_port *ap, int classify,
 
         rc = ata_do_reset(ap, reset, classes, deadline);
 
-        did_followup_srst = 0;
         if (reset == hardreset &&
             ata_eh_followup_srst_needed(rc, classify, classes)) {
                 /* okay, let's do follow-up softreset */
-                did_followup_srst = 1;
                 reset = softreset;
 
                 if (!reset) {
diff --git a/drivers/ata/libata-scsi.c b/drivers/ata/libata-scsi.c
index c228df298b..4ddf00c8c5 100644
--- a/drivers/ata/libata-scsi.c
+++ b/drivers/ata/libata-scsi.c
@@ -2384,11 +2384,6 @@ static unsigned int atapi_xlat(struct ata_queued_cmd *qc)
         int using_pio = (dev->flags & ATA_DFLAG_PIO);
         int nodata = (scmd->sc_data_direction == DMA_NONE);
 
-        if (!using_pio)
-                /* Check whether ATAPI DMA is safe */
-                if (ata_check_atapi_dma(qc))
-                        using_pio = 1;
-
         memset(qc->cdb, 0, dev->cdb_len);
         memcpy(qc->cdb, scmd->cmnd, scmd->cmd_len);
 
@@ -2401,19 +2396,22 @@ static unsigned int atapi_xlat(struct ata_queued_cmd *qc)
         }
 
         qc->tf.command = ATA_CMD_PACKET;
+        qc->nbytes = scmd->request_bufflen;
+
+        /* check whether ATAPI DMA is safe */
+        if (!using_pio && ata_check_atapi_dma(qc))
+                using_pio = 1;
 
-        /* no data, or PIO data xfer */
         if (using_pio || nodata) {
+                /* no data, or PIO data xfer */
                 if (nodata)
                         qc->tf.protocol = ATA_PROT_ATAPI_NODATA;
                 else
                         qc->tf.protocol = ATA_PROT_ATAPI;
                 qc->tf.lbam = (8 * 1024) & 0xff;
                 qc->tf.lbah = (8 * 1024) >> 8;
-        }
-
-        /* DMA data xfer */
-        else {
+        } else {
+                /* DMA data xfer */
                 qc->tf.protocol = ATA_PROT_ATAPI_DMA;
                 qc->tf.feature |= ATAPI_PKT_DMA;
 
@@ -2422,8 +2420,6 @@ static unsigned int atapi_xlat(struct ata_queued_cmd *qc)
                         qc->tf.feature |= ATAPI_DMADIR;
         }
 
-        qc->nbytes = scmd->request_bufflen;
-
         return 0;
 }
 
diff --git a/drivers/ata/pata_hpt37x.c b/drivers/ata/pata_hpt37x.c
index 6446735a46..a8c0cbeca3 100644
--- a/drivers/ata/pata_hpt37x.c
+++ b/drivers/ata/pata_hpt37x.c
@@ -931,13 +931,13 @@ static int hpt37x_init_one(struct pci_dev *dev, const struct pci_device_id *id)
                 .udma_mask = 0x7f,
                 .port_ops = &hpt372_port_ops
         };
-        /* HPT374 - UDMA133 */
+        /* HPT374 - UDMA100 */
         static const struct ata_port_info info_hpt374 = {
                 .sht = &hpt37x_sht,
                 .flags = ATA_FLAG_SLAVE_POSS|ATA_FLAG_SRST,
                 .pio_mask = 0x1f,
                 .mwdma_mask = 0x07,
-                .udma_mask = 0x7f,
+                .udma_mask = 0x3f,
                 .port_ops = &hpt374_port_ops
         };
 
diff --git a/drivers/ata/pata_it821x.c b/drivers/ata/pata_it821x.c
index dab4e7cf8c..12c6e08cc4 100644
--- a/drivers/ata/pata_it821x.c
+++ b/drivers/ata/pata_it821x.c
@@ -690,7 +690,7 @@ static struct ata_port_operations it821x_passthru_port_ops = {
         .port_start     = it821x_port_start,
 };
 
-static void __devinit it821x_disable_raid(struct pci_dev *pdev)
+static void it821x_disable_raid(struct pci_dev *pdev)
 {
         /* Reset local CPU, and set BIOS not ready */
         pci_write_config_byte(pdev, 0x5E, 0x01);
diff --git a/drivers/char/drm/drm_pciids.h b/drivers/char/drm/drm_pciids.h
index aa6335032d..30b200b013 100644
--- a/drivers/char/drm/drm_pciids.h
+++ b/drivers/char/drm/drm_pciids.h
@@ -219,6 +219,8 @@
         {0x1039, 0x6300, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
         {0x1039, 0x6330, PCI_ANY_ID, PCI_ANY_ID, 0, 0, SIS_CHIP_315}, \
         {0x1039, 0x7300, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
+        {0x18CA, 0x0040, PCI_ANY_ID, PCI_ANY_ID, 0, 0, SIS_CHIP_315}, \
+        {0x18CA, 0x0042, PCI_ANY_ID, PCI_ANY_ID, 0, 0, SIS_CHIP_315}, \
         {0, 0, 0}
 
 #define tdfx_PCI_IDS \
diff --git a/drivers/char/drm/sis_drv.h b/drivers/char/drm/sis_drv.h
index 2b8d6f6ed7..70d4ede75f 100644
--- a/drivers/char/drm/sis_drv.h
+++ b/drivers/char/drm/sis_drv.h
@@ -33,11 +33,11 @@
 
 #define DRIVER_AUTHOR           "SIS, Tungsten Graphics"
 #define DRIVER_NAME             "sis"
-#define DRIVER_DESC             "SIS 300/630/540"
-#define DRIVER_DATE             "20060704"
+#define DRIVER_DESC             "SIS 300/630/540 and XGI V3XE/V5/V8"
+#define DRIVER_DATE             "20070626"
 #define DRIVER_MAJOR            1
-#define DRIVER_MINOR            2
-#define DRIVER_PATCHLEVEL       1
+#define DRIVER_MINOR            3
+#define DRIVER_PATCHLEVEL       0
 
 enum sis_family {
         SIS_OTHER = 0,
diff --git a/drivers/net/au1000_eth.c b/drivers/net/au1000_eth.c
index c39ab803c5..c27cfcef45 100644
--- a/drivers/net/au1000_eth.c
+++ b/drivers/net/au1000_eth.c
@@ -34,7 +34,7 @@
  *
  *
  */
-
+#include <linux/dma-mapping.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/string.h>
diff --git a/drivers/net/cxgb3/xgmac.c b/drivers/net/cxgb3/xgmac.c
index b261be147e..c302b1a30c 100644
--- a/drivers/net/cxgb3/xgmac.c
+++ b/drivers/net/cxgb3/xgmac.c
@@ -335,11 +335,11 @@ int t3_mac_set_mtu(struct cmac *mac, unsigned int mtu)
         hwm = min(hwm, MAC_RXFIFO_SIZE - 8192);
         lwm = min(3 * (int)mtu, MAC_RXFIFO_SIZE / 4);
 
-        v = t3_read_reg(adap, A_XGM_RXFIFO_CFG + mac->offset);
         if (adap->params.rev == T3_REV_B2 &&
             (t3_read_reg(adap, A_XGM_RX_CTRL + mac->offset) & F_RXEN)) {
                 disable_exact_filters(mac);
-                t3_set_reg_field(adap, A_XGM_RXFIFO_CFG + mac->offset,
+                v = t3_read_reg(adap, A_XGM_RX_CFG + mac->offset);
+                t3_set_reg_field(adap, A_XGM_RX_CFG + mac->offset,
                                  F_ENHASHMCAST | F_COPYALLFRAMES, F_DISBCAST);
 
                 /* drain rx FIFO */
@@ -347,11 +347,12 @@ int t3_mac_set_mtu(struct cmac *mac, unsigned int mtu)
                                     A_XGM_RX_MAX_PKT_SIZE_ERR_CNT +
                                     mac->offset,
                                     1 << 31, 1, 20, 5)) {
-                        t3_write_reg(adap, A_XGM_RXFIFO_CFG + mac->offset, v);
+                        t3_write_reg(adap, A_XGM_RX_CFG + mac->offset, v);
                         enable_exact_filters(mac);
                         return -EIO;
                 }
                 t3_write_reg(adap, A_XGM_RX_MAX_PKT_SIZE + mac->offset, mtu);
+                t3_write_reg(adap, A_XGM_RX_CFG + mac->offset, v);
                 enable_exact_filters(mac);
         } else
                 t3_write_reg(adap, A_XGM_RX_MAX_PKT_SIZE + mac->offset, mtu);
@@ -362,6 +363,7 @@ int t3_mac_set_mtu(struct cmac *mac, unsigned int mtu)
          */
         hwm = rx_fifo_hwm(mtu);
         lwm = min(3 * (int)mtu, MAC_RXFIFO_SIZE / 4);
+        v = t3_read_reg(adap, A_XGM_RXFIFO_CFG + mac->offset);
         v &= ~V_RXFIFOPAUSELWM(M_RXFIFOPAUSELWM);
         v |= V_RXFIFOPAUSELWM(lwm / 8);
         if (G_RXFIFOPAUSEHWM(v))
diff --git a/drivers/net/s2io.c b/drivers/net/s2io.c
index c6ba3dee8a..09078ff84c 100644
--- a/drivers/net/s2io.c
+++ b/drivers/net/s2io.c
@@ -2868,6 +2868,7 @@ static void tx_intr_handler(struct fifo_info *fifo_data)
         struct tx_curr_get_info get_info, put_info;
         struct sk_buff *skb;
         struct TxD *txdlp;
+        u8 err_mask;
 
         get_info = fifo_data->tx_curr_get_info;
         memcpy(&put_info, &fifo_data->tx_curr_put_info, sizeof(put_info));
@@ -2886,8 +2887,8 @@ static void tx_intr_handler(struct fifo_info *fifo_data)
                         }
 
                         /* update t_code statistics */
-                        err >>= 48;
-                        switch(err) {
+                        err_mask = err >> 48;
+                        switch(err_mask) {
                                 case 2:
                                         nic->mac_control.stats_info->sw_stat.
                                                         tx_buf_abort_cnt++;
@@ -6805,6 +6806,7 @@ static int rx_osm_handler(struct ring_info *ring_data, struct RxD_t * rxdp)
         u16 l3_csum, l4_csum;
         unsigned long long err = rxdp->Control_1 & RXD_T_CODE;
         struct lro *lro;
+        u8 err_mask;
 
         skb->dev = dev;
 
@@ -6813,8 +6815,8 @@ static int rx_osm_handler(struct ring_info *ring_data, struct RxD_t * rxdp)
                 if (err & 0x1) {
                         sp->mac_control.stats_info->sw_stat.parity_err_cnt++;
                 }
-                err >>= 48;
-                switch(err) {
+                err_mask = err >> 48;
+                switch(err_mask) {
                         case 1:
                                 sp->mac_control.stats_info->sw_stat.
                                 rx_parity_err_cnt++;
@@ -6867,9 +6869,9 @@ static int rx_osm_handler(struct ring_info *ring_data, struct RxD_t * rxdp)
                 * Note that in this case, since checksum will be incorrect,
                 * stack will validate the same.
                 */
-                if (err != 0x5) {
-                        DBG_PRINT(ERR_DBG, "%s: Rx error Value: 0x%llx\n",
-                                dev->name, err);
+                if (err_mask != 0x5) {
+                        DBG_PRINT(ERR_DBG, "%s: Rx error Value: 0x%x\n",
+                                dev->name, err_mask);
                         sp->stats.rx_crc_errors++;
                         sp->mac_control.stats_info->sw_stat.mem_freed 
                                 += skb->truesize;
diff --git a/drivers/usb/gadget/file_storage.c b/drivers/usb/gadget/file_storage.c
index c6b6479fa4..4639b629e6 100644
--- a/drivers/usb/gadget/file_storage.c
+++ b/drivers/usb/gadget/file_storage.c
@@ -686,7 +686,6 @@ struct fsg_dev {
         int                     thread_wakeup_needed;
         struct completion       thread_notifier;
         struct task_struct      *thread_task;
-        sigset_t                thread_signal_mask;
 
         int                     cmnd_size;
         u8                      cmnd[MAX_COMMAND_SIZE];
@@ -3277,8 +3276,7 @@ static void handle_exception(struct fsg_dev *fsg)
         /* Clear the existing signals.  Anything but SIGUSR1 is converted
          * into a high-priority EXIT exception. */
         for (;;) {
-                sig = dequeue_signal_lock(current, &fsg->thread_signal_mask,
-                                &info);
+                sig = dequeue_signal_lock(current, &current->blocked, &info);
                 if (!sig)
                         break;
                 if (sig != SIGUSR1) {
@@ -3431,10 +3429,10 @@ static int fsg_main_thread(void *fsg_)
 
         /* Allow the thread to be killed by a signal, but set the signal mask
          * to block everything but INT, TERM, KILL, and USR1. */
-        siginitsetinv(&fsg->thread_signal_mask, sigmask(SIGINT) |
-                        sigmask(SIGTERM) | sigmask(SIGKILL) |
-                        sigmask(SIGUSR1));
-        sigprocmask(SIG_SETMASK, &fsg->thread_signal_mask, NULL);
+        allow_signal(SIGINT);
+        allow_signal(SIGTERM);
+        allow_signal(SIGKILL);
+        allow_signal(SIGUSR1);
 
         /* Arrange for userspace references to be interpreted as kernel
          * pointers.  That way we can pass a kernel pointer to a routine
diff --git a/drivers/usb/misc/iowarrior.c b/drivers/usb/misc/iowarrior.c
index fc51207b71..3bb33f7bfa 100644
--- a/drivers/usb/misc/iowarrior.c
+++ b/drivers/usb/misc/iowarrior.c
@@ -495,8 +495,8 @@ static int iowarrior_ioctl(struct inode *inode, struct file *file,
 
         /* verify that the device wasn't unplugged */
         if (!dev->present) {
-                mutex_unlock(&dev->mutex);
-                return -ENODEV;
+                retval = -ENODEV;
+                goto error_out;
         }
 
         dbg("%s - minor %d, cmd 0x%.4x, arg %ld", __func__, dev->minor, cmd,
@@ -579,9 +579,10 @@ static int iowarrior_ioctl(struct inode *inode, struct file *file,
                 retval = -ENOTTY;
                 break;
         }
-
+error_out:
         /* unlock the device */
         mutex_unlock(&dev->mutex);
+        kfree(buffer);
         return retval;
 }
 
diff --git a/drivers/usb/misc/usblcd.c b/drivers/usb/misc/usblcd.c
index 887ef953f3..12bad8a205 100644
--- a/drivers/usb/misc/usblcd.c
+++ b/drivers/usb/misc/usblcd.c
@@ -42,10 +42,14 @@ struct usb_lcd {
         size_t                  bulk_in_size;           /* the size of the receive buffer */
         __u8                    bulk_in_endpointAddr;   /* the address of the bulk in endpoint */
         __u8                    bulk_out_endpointAddr;  /* the address of the bulk out endpoint */
-        struct kref             kref;
+        struct kref             kref;
+        struct semaphore        limit_sem;              /* to stop writes at full throttle from
+                                                         * using up all RAM */
 };
 #define to_lcd_dev(d) container_of(d, struct usb_lcd, kref)
 
+#define USB_LCD_CONCURRENT_WRITES       5
+
 static struct usb_driver lcd_driver;
 static DEFINE_MUTEX(usb_lcd_open_mutex);
 
@@ -186,12 +190,13 @@ static void lcd_write_bulk_callback(struct urb *urb)
         /* free up our allocated buffer */
         usb_buffer_free(urb->dev, urb->transfer_buffer_length,
                         urb->transfer_buffer, urb->transfer_dma);
+        up(&dev->limit_sem);
 }
 
 static ssize_t lcd_write(struct file *file, const char __user * user_buffer, size_t count, loff_t *ppos)
 {
         struct usb_lcd *dev;
-        int retval = 0;
+        int retval = 0, r;
         struct urb *urb = NULL;
         char *buf = NULL;
         
@@ -201,10 +206,16 @@ static ssize_t lcd_write(struct file *file, const char __user * user_buffer, siz
         if (count == 0)
                 goto exit;
 
+        r = down_interruptible(&dev->limit_sem);
+        if (r < 0)
+                return -EINTR;
+
         /* create a urb, and a buffer for it, and copy the data to the urb */
         urb = usb_alloc_urb(0, GFP_KERNEL);
-        if (!urb)
-                return -ENOMEM;
+        if (!urb) {
+                retval = -ENOMEM;
+                goto err_no_buf;
+        }
         
         buf = usb_buffer_alloc(dev->udev, count, GFP_KERNEL, &urb->transfer_dma);
         if (!buf) {
@@ -239,6 +250,8 @@ exit:
 error:
         usb_buffer_free(dev->udev, count, buf, urb->transfer_dma);
         usb_free_urb(urb);
+err_no_buf:
+        up(&dev->limit_sem);
         return retval;
 }
 
@@ -277,6 +290,7 @@ static int lcd_probe(struct usb_interface *interface, const struct usb_device_id
                 goto error;
         }
         kref_init(&dev->kref);
+        sema_init(&dev->limit_sem, USB_LCD_CONCURRENT_WRITES);
 
         dev->udev = usb_get_dev(interface_to_usbdev(interface));
         dev->interface = interface;
diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
index 2353679f60..da1c6f7f82 100644
--- a/drivers/usb/serial/ftdi_sio.c
+++ b/drivers/usb/serial/ftdi_sio.c
@@ -317,6 +317,7 @@ static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(FTDI_VID, FTDI_ACTZWAVE_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_IRTRANS_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_IPLUS_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_IPLUS2_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_DMX4ALL) },
         { USB_DEVICE(FTDI_VID, FTDI_SIO_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_8U232AM_PID) },
diff --git a/drivers/usb/serial/ftdi_sio.h b/drivers/usb/serial/ftdi_sio.h
index 33aee90472..d9e49716db 100644
--- a/drivers/usb/serial/ftdi_sio.h
+++ b/drivers/usb/serial/ftdi_sio.h
@@ -56,6 +56,7 @@
 
 /* iPlus device */
 #define FTDI_IPLUS_PID 0xD070 /* Product Id */
+#define FTDI_IPLUS2_PID 0xD071 /* Product Id */
 
 /* DMX4ALL DMX Interfaces */
 #define FTDI_DMX4ALL 0xC850
diff --git a/drivers/usb/serial/io_edgeport.c b/drivers/usb/serial/io_edgeport.c
index 4807f96015..056e1923c4 100644
--- a/drivers/usb/serial/io_edgeport.c
+++ b/drivers/usb/serial/io_edgeport.c
@@ -3046,11 +3046,11 @@ static void edge_shutdown (struct usb_serial *serial)
         }
         /* free up our endpoint stuff */
         if (edge_serial->is_epic) {
-                usb_unlink_urb(edge_serial->interrupt_read_urb);
+                usb_kill_urb(edge_serial->interrupt_read_urb);
                 usb_free_urb(edge_serial->interrupt_read_urb);
                 kfree(edge_serial->interrupt_in_buffer);
 
-                usb_unlink_urb(edge_serial->read_urb);
+                usb_kill_urb(edge_serial->read_urb);
                 usb_free_urb(edge_serial->read_urb);
                 kfree(edge_serial->bulk_in_buffer);
         }
diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
index 89f067d950..5d3999e3ff 100644
--- a/drivers/usb/serial/option.c
+++ b/drivers/usb/serial/option.c
@@ -111,7 +111,8 @@ static int  option_send_setup(struct usb_serial_port *port);
 #define NOVATELWIRELESS_VENDOR_ID               0x1410
 
 #define ANYDATA_VENDOR_ID                       0x16d5
-#define ANYDATA_PRODUCT_ID                      0x6501
+#define ANYDATA_PRODUCT_ADU_E100A               0x6501
+#define ANYDATA_PRODUCT_ADU_500A                0x6502
 
 #define BANDRICH_VENDOR_ID                      0x1A8D
 #define BANDRICH_PRODUCT_C100_1                 0x1002
@@ -169,7 +170,8 @@ static struct usb_device_id option_ids[] = {
         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x2110) }, /* Novatel Merlin ES620 / Merlin ES720 / Ovation U720 */
         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x2130) }, /* Novatel Merlin ES620 SM Bus */
         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, 0x2410) }, /* Novatel EU740 */
-        { USB_DEVICE(ANYDATA_VENDOR_ID, ANYDATA_PRODUCT_ID) },
+        { USB_DEVICE(ANYDATA_VENDOR_ID, ANYDATA_PRODUCT_ADU_E100A) },
+        { USB_DEVICE(ANYDATA_VENDOR_ID, ANYDATA_PRODUCT_ADU_500A) },
         { USB_DEVICE(BANDRICH_VENDOR_ID, BANDRICH_PRODUCT_C100_1) },
         { USB_DEVICE(BANDRICH_VENDOR_ID, BANDRICH_PRODUCT_C100_2) },
         { USB_DEVICE(DELL_VENDOR_ID, 0x8118) },         /* Dell Wireless 5510 Mobile Broadband HSDPA ExpressCard */
diff --git a/drivers/usb/serial/ti_usb_3410_5052.c b/drivers/usb/serial/ti_usb_3410_5052.c
index 4203e2b1a7..3d505fd064 100644
--- a/drivers/usb/serial/ti_usb_3410_5052.c
+++ b/drivers/usb/serial/ti_usb_3410_5052.c
@@ -1555,15 +1555,17 @@ static int ti_restart_read(struct ti_port *tport, struct tty_struct *tty)
         spin_lock_irqsave(&tport->tp_lock, flags);
 
         if (tport->tp_read_urb_state == TI_READ_URB_STOPPED) {
+                tport->tp_read_urb_state = TI_READ_URB_RUNNING;
                 urb = tport->tp_port->read_urb;
+                spin_unlock_irqrestore(&tport->tp_lock, flags);
                 urb->complete = ti_bulk_in_callback;
                 urb->context = tport;
                 urb->dev = tport->tp_port->serial->dev;
                 status = usb_submit_urb(urb, GFP_KERNEL);
+        } else  {
+                tport->tp_read_urb_state = TI_READ_URB_RUNNING;
+                spin_unlock_irqrestore(&tport->tp_lock, flags);
         }
-        tport->tp_read_urb_state = TI_READ_URB_RUNNING;
-
-        spin_unlock_irqrestore(&tport->tp_lock, flags);
 
         return status;
 }