1 files changed, 125 insertions, 13 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) },