5 files changed, 171 insertions, 39 deletions

diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c
index dac7676ce21..a06f2cdc610 100644
--- a/drivers/usb/class/cdc-acm.c
+++ b/drivers/usb/class/cdc-acm.c
@@ -155,7 +155,6 @@ static int acm_start_wb(struct acm *acm, struct acm_wb *wb)
         wb->urb->transfer_dma = wb->dmah;
         wb->urb->transfer_buffer_length = wb->len;
         wb->urb->dev = acm->dev;
-
         rc = usb_submit_urb(wb->urb, GFP_ATOMIC);
         if (rc < 0) {
                 dev_err(&acm->data->dev,
@@ -171,6 +170,9 @@ static int acm_write_start(struct acm *acm, int wbn)
         unsigned long flags;
         struct acm_wb *wb = &acm->wb[wbn];
         int rc;
+#ifdef CONFIG_PM
+        struct urb *res;
+#endif
 
         spin_lock_irqsave(&acm->write_lock, flags);
         if (!acm->dev) {
@@ -183,15 +185,33 @@ static int acm_write_start(struct acm *acm, int wbn)
                                                         acm->susp_count);
         usb_autopm_get_interface_async(acm->control);
         if (acm->susp_count) {
+#ifdef CONFIG_PM
+                acm->transmitting++;
+                wb->urb->transfer_buffer = wb->buf;
+                wb->urb->transfer_dma = wb->dmah;
+                wb->urb->transfer_buffer_length = wb->len;
+                wb->urb->dev = acm->dev;
+                usb_anchor_urb(wb->urb, &acm->deferred);
+#else
                 if (!acm->delayed_wb)
                         acm->delayed_wb = wb;
                 else
                         usb_autopm_put_interface_async(acm->control);
+#endif
                 spin_unlock_irqrestore(&acm->write_lock, flags);
                 return 0;       /* A white lie */
         }
         usb_mark_last_busy(acm->dev);
-
+#ifdef CONFIG_PM
+        while ((res = usb_get_from_anchor(&acm->deferred))) {
+                rc = usb_submit_urb(res, GFP_ATOMIC);
+                if (rc < 0) {
+                        dbg("usb_submit_urb(pending request) failed: %d", rc);
+                        usb_unanchor_urb(res);
+                        acm_write_done(acm, res->context);
+                }
+        }
+#endif
         rc = acm_start_wb(acm, wb);
         spin_unlock_irqrestore(&acm->write_lock, flags);
 
@@ -476,7 +496,7 @@ static int acm_tty_open(struct tty_struct *tty, struct file *filp)
         if (usb_autopm_get_interface(acm->control) < 0)
                 goto early_bail;
         else
-                acm->control->needs_remote_wakeup = 1;
+                acm->control->needs_remote_wakeup = 0;
 
         mutex_lock(&acm->mutex);
         if (acm->port.count++) {
@@ -539,7 +559,6 @@ static void acm_port_down(struct acm *acm)
 {
         int i;
 
-        mutex_lock(&open_mutex);
         if (acm->dev) {
                 usb_autopm_get_interface(acm->control);
                 acm_set_control(acm, acm->ctrlout = 0);
@@ -551,14 +570,23 @@ static void acm_port_down(struct acm *acm)
                 acm->control->needs_remote_wakeup = 0;
                 usb_autopm_put_interface(acm->control);
         }
-        mutex_unlock(&open_mutex);
 }
 
 static void acm_tty_hangup(struct tty_struct *tty)
 {
-        struct acm *acm = tty->driver_data;
+        struct acm *acm;
+
+        mutex_lock(&open_mutex);
+        acm = tty->driver_data;
+
+        if (!acm)
+                goto out;
+
         tty_port_hangup(&acm->port);
         acm_port_down(acm);
+
+out:
+        mutex_unlock(&open_mutex);
 }
 
 static void acm_tty_close(struct tty_struct *tty, struct file *filp)
@@ -569,8 +597,9 @@ static void acm_tty_close(struct tty_struct *tty, struct file *filp)
            shutdown */
         if (!acm)
                 return;
+
+        mutex_lock(&open_mutex);
         if (tty_port_close_start(&acm->port, tty, filp) == 0) {
-                mutex_lock(&open_mutex);
                 if (!acm->dev) {
                         tty_port_tty_set(&acm->port, NULL);
                         acm_tty_unregister(acm);
@@ -582,6 +611,7 @@ static void acm_tty_close(struct tty_struct *tty, struct file *filp)
         acm_port_down(acm);
         tty_port_close_end(&acm->port, tty);
         tty_port_tty_set(&acm->port, NULL);
+        mutex_unlock(&open_mutex);
 }
 
 static int acm_tty_write(struct tty_struct *tty,
@@ -863,8 +893,12 @@ static int acm_probe(struct usb_interface *intf,
         quirks = (unsigned long)id->driver_info;
         num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
 
+        /* not a real CDC ACM device */
+        if (quirks & NOT_REAL_ACM)
+                return -ENODEV;
+
         /* handle quirks deadly to normal probing*/
-        if (quirks == NO_UNION_NORMAL) {
+        if (quirks & NO_UNION_NORMAL) {
                 data_interface = usb_ifnum_to_if(usb_dev, 1);
                 control_interface = usb_ifnum_to_if(usb_dev, 0);
                 goto skip_normal_probe;
@@ -1074,6 +1108,7 @@ made_compressed_probe:
         acm->readsize = readsize;
         acm->rx_buflimit = num_rx_buf;
         INIT_WORK(&acm->work, acm_softint);
+        init_usb_anchor(&acm->deferred);
         spin_lock_init(&acm->write_lock);
         spin_lock_init(&acm->read_lock);
         mutex_init(&acm->mutex);
@@ -1081,6 +1116,8 @@ made_compressed_probe:
         acm->is_int_ep = usb_endpoint_xfer_int(epread);
         if (acm->is_int_ep)
                 acm->bInterval = epread->bInterval;
+        if (quirks & NO_HANGUP_IN_RESET_RESUME)
+                acm->no_hangup_in_reset_resume = 1;
         tty_port_init(&acm->port);
         acm->port.ops = &acm_port_ops;
 
@@ -1181,6 +1218,8 @@ made_compressed_probe:
                 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
                 if (i < 0) {
                         kfree(acm->country_codes);
+                        acm->country_codes = NULL;
+                        acm->country_code_size = 0;
                         goto skip_countries;
                 }
 
@@ -1189,6 +1228,8 @@ made_compressed_probe:
                 if (i < 0) {
                         device_remove_file(&intf->dev, &dev_attr_wCountryCodes);
                         kfree(acm->country_codes);
+                        acm->country_codes = NULL;
+                        acm->country_code_size = 0;
                         goto skip_countries;
                 }
         }
@@ -1241,6 +1282,11 @@ static void stop_data_traffic(struct acm *acm)
 {
         int i;
 
+        if (!acm) {
+                pr_err("%s: !acm\n", __func__);
+                return;
+        }
+
         dev_dbg(&acm->control->dev, "%s\n", __func__);
 
         usb_kill_urb(acm->ctrlurb);
@@ -1276,6 +1322,7 @@ static void acm_disconnect(struct usb_interface *intf)
 
         stop_data_traffic(acm);
 
+        usb_kill_anchored_urbs(&acm->deferred);
         acm_write_buffers_free(acm);
         usb_free_coherent(usb_dev, acm->ctrlsize, acm->ctrl_buffer,
                           acm->ctrl_dma);
@@ -1305,6 +1352,11 @@ static int acm_suspend(struct usb_interface *intf, pm_message_t message)
         struct acm *acm = usb_get_intfdata(intf);
         int cnt;
 
+        if (!acm) {
+                pr_err("%s: !acm\n", __func__);
+                return -ENODEV;
+        }
+
         if (message.event & PM_EVENT_AUTO) {
                 int b;
 
@@ -1339,23 +1391,50 @@ static int acm_suspend(struct usb_interface *intf, pm_message_t message)
 static int acm_resume(struct usb_interface *intf)
 {
         struct acm *acm = usb_get_intfdata(intf);
-        struct acm_wb *wb;
         int rv = 0;
         int cnt;
+#ifdef CONFIG_PM
+        struct urb *res;
+#else
+        struct acm_wb *wb;
+#endif
+
+        if (!acm) {
+                pr_err("%s: !acm\n", __func__);
+                return -ENODEV;
+        }
 
         spin_lock_irq(&acm->read_lock);
-        acm->susp_count -= 1;
-        cnt = acm->susp_count;
+        if (acm->susp_count > 0) {
+                acm->susp_count -= 1;
+                cnt = acm->susp_count;
+        } else {
+                spin_unlock_irq(&acm->read_lock);
+                return 0;
+        }
         spin_unlock_irq(&acm->read_lock);
 
         if (cnt)
                 return 0;
 
+
         mutex_lock(&acm->mutex);
+
         if (acm->port.count) {
                 rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
-
                 spin_lock_irq(&acm->write_lock);
+#ifdef CONFIG_PM
+                while ((res = usb_get_from_anchor(&acm->deferred))) {
+                        rv = usb_submit_urb(res, GFP_ATOMIC);
+                        if (rv < 0) {
+                                dbg("usb_submit_urb(pending request)"
+                                        " failed: %d", rv);
+                                usb_unanchor_urb(res);
+                                acm_write_done(acm, res->context);
+                        }
+                }
+                spin_unlock_irq(&acm->write_lock);
+#else
                 if (acm->delayed_wb) {
                         wb = acm->delayed_wb;
                         acm->delayed_wb = NULL;
@@ -1364,6 +1443,7 @@ static int acm_resume(struct usb_interface *intf)
                 } else {
                         spin_unlock_irq(&acm->write_lock);
                 }
+#endif
 
                 /*
                  * delayed error checking because we must
@@ -1385,11 +1465,17 @@ static int acm_reset_resume(struct usb_interface *intf)
         struct acm *acm = usb_get_intfdata(intf);
         struct tty_struct *tty;
 
+        if (!acm) {
+                pr_err("%s: !acm\n", __func__);
+                return -ENODEV;
+        }
+
         mutex_lock(&acm->mutex);
         if (acm->port.count) {
                 tty = tty_port_tty_get(&acm->port);
                 if (tty) {
-                        tty_hangup(tty);
+                        if (!acm->no_hangup_in_reset_resume)
+                                tty_hangup(tty);
                         tty_kref_put(tty);
                 }
         }
@@ -1456,6 +1542,16 @@ static const struct usb_device_id acm_ids[] = {
         },
         { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
         },
+        /* Motorola H24 HSPA module: */
+        { USB_DEVICE(0x22b8, 0x2d91) }, /* modem                                */
+        { USB_DEVICE(0x22b8, 0x2d92) }, /* modem           + diagnostics        */
+        { USB_DEVICE(0x22b8, 0x2d93) }, /* modem + AT port                      */
+        { USB_DEVICE(0x22b8, 0x2d95) }, /* modem + AT port + diagnostics        */
+        { USB_DEVICE(0x22b8, 0x2d96) }, /* modem                         + NMEA */
+        { USB_DEVICE(0x22b8, 0x2d97) }, /* modem           + diagnostics + NMEA */
+        { USB_DEVICE(0x22b8, 0x2d99) }, /* modem + AT port               + NMEA */
+        { USB_DEVICE(0x22b8, 0x2d9a) }, /* modem + AT port + diagnostics + NMEA */
+
         { USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */
         .driver_info = NO_UNION_NORMAL, /* union descriptor misplaced on
                                            data interface instead of
@@ -1469,6 +1565,9 @@ static const struct usb_device_id acm_ids[] = {
         { USB_DEVICE(0x1576, 0x03b1), /* Maretron USB100 */
         .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
         },
+        { USB_DEVICE(0x1519, 0x0020),
+        .driver_info = NO_UNION_NORMAL | NO_HANGUP_IN_RESET_RESUME, /* has no union descriptor */
+        },
 
         /* Nokia S60 phones expose two ACM channels. The first is
          * a modem and is picked up by the standard AT-command
@@ -1534,6 +1633,9 @@ static const struct usb_device_id acm_ids[] = {
         { NOKIA_PCSUITE_ACM_INFO(0x03cd), }, /* Nokia C7 */
         { SAMSUNG_PCSUITE_ACM_INFO(0x6651), }, /* Samsung GTi8510 (INNOV8) */
 
+        /* Support for Owen devices */
+        { USB_DEVICE(0x03eb, 0x0030), }, /* Owen SI30 */
+
         /* NOTE: non-Nokia COMM/ACM/0xff is likely MSFT RNDIS... NOT a modem! */
 
         /* Support Lego NXT using pbLua firmware */
@@ -1546,6 +1648,16 @@ static const struct usb_device_id acm_ids[] = {
         .driver_info = NO_DATA_INTERFACE,
         },
 
+        /* Exclude XMM6260 boot rom (not running modem software yet) */
+        { USB_DEVICE(0x058b, 0x0041),
+        .driver_info = NOT_REAL_ACM,
+        },
+
+        /* Icera 450 */
+        { USB_DEVICE(0x1983, 0x0321),
+        .driver_info = NO_HANGUP_IN_RESET_RESUME,
+        },
+
         /* control interfaces without any protocol set */
         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
                 USB_CDC_PROTO_NONE) },
diff --git a/drivers/usb/class/cdc-acm.h b/drivers/usb/class/cdc-acm.h
index ca7937f26e2..ec59fda787f 100644
--- a/drivers/usb/class/cdc-acm.h
+++ b/drivers/usb/class/cdc-acm.h
@@ -115,8 +115,10 @@ struct acm {
         unsigned int is_int_ep:1;                       /* interrupt endpoints contrary to spec used */
         unsigned int throttled:1;                       /* actually throttled */
         unsigned int throttle_req:1;                    /* throttle requested */
+        unsigned int no_hangup_in_reset_resume:1;       /* do not call tty_hangup in acm_reset_resume */
         u8 bInterval;
         struct acm_wb *delayed_wb;                      /* write queued for a device about to be woken */
+        struct usb_anchor       deferred;
 };
 
 #define CDC_DATA_INTERFACE_TYPE 0x0a
@@ -127,3 +129,5 @@ struct acm {
 #define NO_CAP_LINE                     4
 #define NOT_A_MODEM                     8
 #define NO_DATA_INTERFACE               16
+#define NOT_REAL_ACM                    32
+#define NO_HANGUP_IN_RESET_RESUME       64
diff --git a/drivers/usb/class/cdc-wdm.c b/drivers/usb/class/cdc-wdm.c
index 2b9ff518b50..90581a85134 100644
--- a/drivers/usb/class/cdc-wdm.c
+++ b/drivers/usb/class/cdc-wdm.c
@@ -57,6 +57,8 @@ MODULE_DEVICE_TABLE (usb, wdm_ids);
 
 #define WDM_MAX                 16
 
+/* CDC-WMC r1.1 requires wMaxCommand to be "at least 256 decimal (0x100)" */
+#define WDM_DEFAULT_BUFSIZE     256
 
 static DEFINE_MUTEX(wdm_mutex);
 
@@ -88,7 +90,8 @@ struct wdm_device {
         int                     count;
         dma_addr_t              shandle;
         dma_addr_t              ihandle;
-        struct mutex            lock;
+        struct mutex            wlock;
+        struct mutex            rlock;
         wait_queue_head_t       wait;
         struct work_struct      rxwork;
         int                     werr;
@@ -323,7 +326,7 @@ static ssize_t wdm_write
         }
 
         /* concurrent writes and disconnect */
-        r = mutex_lock_interruptible(&desc->lock);
+        r = mutex_lock_interruptible(&desc->wlock);
         rv = -ERESTARTSYS;
         if (r) {
                 kfree(buf);
@@ -386,7 +389,7 @@ static ssize_t wdm_write
 out:
         usb_autopm_put_interface(desc->intf);
 outnp:
-        mutex_unlock(&desc->lock);
+        mutex_unlock(&desc->wlock);
 outnl:
         return rv < 0 ? rv : count;
 }
@@ -399,7 +402,7 @@ static ssize_t wdm_read
         struct wdm_device *desc = file->private_data;
 
 
-        rv = mutex_lock_interruptible(&desc->lock); /*concurrent reads */
+        rv = mutex_lock_interruptible(&desc->rlock); /*concurrent reads */
         if (rv < 0)
                 return -ERESTARTSYS;
 
@@ -467,14 +470,16 @@ retry:
         for (i = 0; i < desc->length - cntr; i++)
                 desc->ubuf[i] = desc->ubuf[i + cntr];
 
+        spin_lock_irq(&desc->iuspin);
         desc->length -= cntr;
+        spin_unlock_irq(&desc->iuspin);
         /* in case we had outstanding data */
         if (!desc->length)
                 clear_bit(WDM_READ, &desc->flags);
         rv = cntr;
 
 err:
-        mutex_unlock(&desc->lock);
+        mutex_unlock(&desc->rlock);
         return rv;
 }
 
@@ -540,7 +545,8 @@ static int wdm_open(struct inode *inode, struct file *file)
         }
         intf->needs_remote_wakeup = 1;
 
-        mutex_lock(&desc->lock);
+        /* using write lock to protect desc->count */
+        mutex_lock(&desc->wlock);
         if (!desc->count++) {
                 desc->werr = 0;
                 desc->rerr = 0;
@@ -553,7 +559,7 @@ static int wdm_open(struct inode *inode, struct file *file)
         } else {
                 rv = 0;
         }
-        mutex_unlock(&desc->lock);
+        mutex_unlock(&desc->wlock);
         usb_autopm_put_interface(desc->intf);
 out:
         mutex_unlock(&wdm_mutex);
@@ -565,9 +571,11 @@ static int wdm_release(struct inode *inode, struct file *file)
         struct wdm_device *desc = file->private_data;
 
         mutex_lock(&wdm_mutex);
-        mutex_lock(&desc->lock);
+
+        /* using write lock to protect desc->count */
+        mutex_lock(&desc->wlock);
         desc->count--;
-        mutex_unlock(&desc->lock);
+        mutex_unlock(&desc->wlock);
 
         if (!desc->count) {
                 dev_dbg(&desc->intf->dev, "wdm_release: cleanup");
@@ -630,7 +638,7 @@ static int wdm_probe(struct usb_interface *intf, const struct usb_device_id *id)
         struct usb_cdc_dmm_desc *dmhd;
         u8 *buffer = intf->altsetting->extra;
         int buflen = intf->altsetting->extralen;
-        u16 maxcom = 0;
+        u16 maxcom = WDM_DEFAULT_BUFSIZE;
 
         if (!buffer)
                 goto out;
@@ -665,7 +673,8 @@ next_desc:
         desc = kzalloc(sizeof(struct wdm_device), GFP_KERNEL);
         if (!desc)
                 goto out;
-        mutex_init(&desc->lock);
+        mutex_init(&desc->rlock);
+        mutex_init(&desc->wlock);
         spin_lock_init(&desc->iuspin);
         init_waitqueue_head(&desc->wait);
         desc->wMaxCommand = maxcom;
@@ -716,7 +725,7 @@ next_desc:
                 goto err;
 
         desc->inbuf = usb_alloc_coherent(interface_to_usbdev(intf),
-                                         desc->bMaxPacketSize0,
+                                         desc->wMaxCommand,
                                          GFP_KERNEL,
                                          &desc->response->transfer_dma);
         if (!desc->inbuf)
@@ -779,11 +788,13 @@ static void wdm_disconnect(struct usb_interface *intf)
         /* to terminate pending flushes */
         clear_bit(WDM_IN_USE, &desc->flags);
         spin_unlock_irqrestore(&desc->iuspin, flags);
-        mutex_lock(&desc->lock);
+        wake_up_all(&desc->wait);
+        mutex_lock(&desc->rlock);
+        mutex_lock(&desc->wlock);
         kill_urbs(desc);
         cancel_work_sync(&desc->rxwork);
-        mutex_unlock(&desc->lock);
-        wake_up_all(&desc->wait);
+        mutex_unlock(&desc->wlock);
+        mutex_unlock(&desc->rlock);
         if (!desc->count)
                 cleanup(desc);
         mutex_unlock(&wdm_mutex);
@@ -798,8 +809,10 @@ static int wdm_suspend(struct usb_interface *intf, pm_message_t message)
         dev_dbg(&desc->intf->dev, "wdm%d_suspend\n", intf->minor);
 
         /* if this is an autosuspend the caller does the locking */
-        if (!(message.event & PM_EVENT_AUTO))
-                mutex_lock(&desc->lock);
+        if (!(message.event & PM_EVENT_AUTO)) {
+                mutex_lock(&desc->rlock);
+                mutex_lock(&desc->wlock);
+        }
         spin_lock_irq(&desc->iuspin);
 
         if ((message.event & PM_EVENT_AUTO) &&
@@ -815,8 +828,10 @@ static int wdm_suspend(struct usb_interface *intf, pm_message_t message)
                 kill_urbs(desc);
                 cancel_work_sync(&desc->rxwork);
         }
-        if (!(message.event & PM_EVENT_AUTO))
-                mutex_unlock(&desc->lock);
+        if (!(message.event & PM_EVENT_AUTO)) {
+                mutex_unlock(&desc->wlock);
+                mutex_unlock(&desc->rlock);
+        }
 
         return rv;
 }
@@ -854,7 +869,8 @@ static int wdm_pre_reset(struct usb_interface *intf)
 {
         struct wdm_device *desc = usb_get_intfdata(intf);
 
-        mutex_lock(&desc->lock);
+        mutex_lock(&desc->rlock);
+        mutex_lock(&desc->wlock);
         kill_urbs(desc);
 
         /*
@@ -876,7 +892,8 @@ static int wdm_post_reset(struct usb_interface *intf)
         int rv;
 
         rv = recover_from_urb_loss(desc);
-        mutex_unlock(&desc->lock);
+        mutex_unlock(&desc->wlock);
+        mutex_unlock(&desc->rlock);
         return 0;
 }
 
diff --git a/drivers/usb/class/usblp.c b/drivers/usb/class/usblp.c
index 9eca4053312..cb3a93243a0 100644
--- a/drivers/usb/class/usblp.c
+++ b/drivers/usb/class/usblp.c
@@ -58,6 +58,7 @@
 #include <linux/mutex.h>
 #undef DEBUG
 #include <linux/usb.h>
+#include <linux/ratelimit.h>
 
 /*
  * Version Information
@@ -348,8 +349,7 @@ static int usblp_check_status(struct usblp *usblp, int err)
         mutex_lock(&usblp->mut);
         if ((error = usblp_read_status(usblp, usblp->statusbuf)) < 0) {
                 mutex_unlock(&usblp->mut);
-                if (printk_ratelimit())
-                        printk(KERN_ERR
+                printk_ratelimited(KERN_ERR
                                 "usblp%d: error %d reading printer status\n",
                                 usblp->minor, error);
                 return 0;
@@ -653,8 +653,7 @@ static long usblp_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 
                 case LPGETSTATUS:
                         if ((retval = usblp_read_status(usblp, usblp->statusbuf))) {
-                                if (printk_ratelimit())
-                                        printk(KERN_ERR "usblp%d:"
+                                printk_ratelimited(KERN_ERR "usblp%d:"
                                             "failed reading printer status (%d)\n",
                                             usblp->minor, retval);
                                 retval = -EIO;
diff --git a/drivers/usb/class/usbtmc.c b/drivers/usb/class/usbtmc.c
index 385acb895ab..3f94ac34dce 100644
--- a/drivers/usb/class/usbtmc.c
+++ b/drivers/usb/class/usbtmc.c
@@ -268,7 +268,7 @@ usbtmc_abort_bulk_in_status:
                                 dev_err(dev, "usb_bulk_msg returned %d\n", rv);
                                 goto exit;
                         }
-                } while ((actual = max_size) &&
+                } while ((actual == max_size) &&
                          (n < USBTMC_MAX_READS_TO_CLEAR_BULK_IN));
 
         if (actual == max_size) {