Patched in Tegra support.

1 files changed, 261 insertions, 296 deletions

diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c
index 2d92cce260d..a06f2cdc610 100644
--- a/drivers/usb/class/cdc-acm.c
+++ b/drivers/usb/class/cdc-acm.c
@@ -58,62 +58,12 @@ static struct usb_driver acm_driver;
 static struct tty_driver *acm_tty_driver;
 static struct acm *acm_table[ACM_TTY_MINORS];
 
-static DEFINE_MUTEX(acm_table_lock);
+static DEFINE_MUTEX(open_mutex);
 
-/*
- * acm_table accessors
- */
-
-/*
- * Look up an ACM structure by index. If found and not disconnected, increment
- * its refcount and return it with its mutex held.
- */
-static struct acm *acm_get_by_index(unsigned index)
-{
-        struct acm *acm;
-
-        mutex_lock(&acm_table_lock);
-        acm = acm_table[index];
-        if (acm) {
-                mutex_lock(&acm->mutex);
-                if (acm->disconnected) {
-                        mutex_unlock(&acm->mutex);
-                        acm = NULL;
-                } else {
-                        tty_port_get(&acm->port);
-                        mutex_unlock(&acm->mutex);
-                }
-        }
-        mutex_unlock(&acm_table_lock);
-        return acm;
-}
-
-/*
- * Try to find an available minor number and if found, associate it with 'acm'.
- */
-static int acm_alloc_minor(struct acm *acm)
-{
-        int minor;
-
-        mutex_lock(&acm_table_lock);
-        for (minor = 0; minor < ACM_TTY_MINORS; minor++) {
-                if (!acm_table[minor]) {
-                        acm_table[minor] = acm;
-                        break;
-                }
-        }
-        mutex_unlock(&acm_table_lock);
-
-        return minor;
-}
+#define ACM_READY(acm)  (acm && acm->dev && acm->port.count)
 
-/* Release the minor number associated with 'acm'.  */
-static void acm_release_minor(struct acm *acm)
-{
-        mutex_lock(&acm_table_lock);
-        acm_table[acm->minor] = NULL;
-        mutex_unlock(&acm_table_lock);
-}
+static const struct tty_port_operations acm_port_ops = {
+};
 
 /*
  * Functions for ACM control messages.
@@ -205,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,
@@ -221,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) {
@@ -233,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);
 
@@ -317,6 +287,9 @@ static void acm_ctrl_irq(struct urb *urb)
                 goto exit;
         }
 
+        if (!ACM_READY(acm))
+                goto exit;
+
         usb_mark_last_busy(acm->dev);
 
         data = (unsigned char *)(dr + 1);
@@ -476,7 +449,8 @@ static void acm_write_bulk(struct urb *urb)
         spin_lock_irqsave(&acm->write_lock, flags);
         acm_write_done(acm, wb);
         spin_unlock_irqrestore(&acm->write_lock, flags);
-        schedule_work(&acm->work);
+        if (ACM_READY(acm))
+                schedule_work(&acm->work);
 }
 
 static void acm_softint(struct work_struct *work)
@@ -486,6 +460,8 @@ static void acm_softint(struct work_struct *work)
 
         dev_vdbg(&acm->data->dev, "%s\n", __func__);
 
+        if (!ACM_READY(acm))
+                return;
         tty = tty_port_tty_get(&acm->port);
         if (!tty)
                 return;
@@ -497,125 +473,93 @@ static void acm_softint(struct work_struct *work)
  * TTY handlers
  */
 
-static int acm_tty_install(struct tty_driver *driver, struct tty_struct *tty)
+static int acm_tty_open(struct tty_struct *tty, struct file *filp)
 {
         struct acm *acm;
-        int retval;
-
-        dev_dbg(tty->dev, "%s\n", __func__);
-
-        acm = acm_get_by_index(tty->index);
-        if (!acm)
-                return -ENODEV;
-
-        retval = tty_standard_install(driver, tty);
-        if (retval)
-                goto error_init_termios;
-
-        tty->driver_data = acm;
-
-        return 0;
+        int rv = -ENODEV;
 
-error_init_termios:
-        tty_port_put(&acm->port);
-        return retval;
-}
+        mutex_lock(&open_mutex);
 
-static int acm_tty_open(struct tty_struct *tty, struct file *filp)
-{
-        struct acm *acm = tty->driver_data;
+        acm = acm_table[tty->index];
+        if (!acm || !acm->dev)
+                goto out;
+        else
+                rv = 0;
 
-        dev_dbg(tty->dev, "%s\n", __func__);
+        dev_dbg(&acm->control->dev, "%s\n", __func__);
 
-        return tty_port_open(&acm->port, tty, filp);
-}
+        set_bit(TTY_NO_WRITE_SPLIT, &tty->flags);
 
-static int acm_port_activate(struct tty_port *port, struct tty_struct *tty)
-{
-        struct acm *acm = container_of(port, struct acm, port);
-        int retval = -ENODEV;
+        tty->driver_data = acm;
+        tty_port_tty_set(&acm->port, tty);
 
-        dev_dbg(&acm->control->dev, "%s\n", __func__);
+        if (usb_autopm_get_interface(acm->control) < 0)
+                goto early_bail;
+        else
+                acm->control->needs_remote_wakeup = 0;
 
         mutex_lock(&acm->mutex);
-        if (acm->disconnected)
-                goto disconnected;
-
-        retval = usb_autopm_get_interface(acm->control);
-        if (retval)
-                goto error_get_interface;
-
-        /*
-         * FIXME: Why do we need this? Allocating 64K of physically contiguous
-         * memory is really nasty...
-         */
-        set_bit(TTY_NO_WRITE_SPLIT, &tty->flags);
-        acm->control->needs_remote_wakeup = 1;
+        if (acm->port.count++) {
+                mutex_unlock(&acm->mutex);
+                usb_autopm_put_interface(acm->control);
+                goto out;
+        }
 
         acm->ctrlurb->dev = acm->dev;
         if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
                 dev_err(&acm->control->dev,
                         "%s - usb_submit_urb(ctrl irq) failed\n", __func__);
-                goto error_submit_urb;
+                goto bail_out;
         }
 
-        acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS;
-        if (acm_set_control(acm, acm->ctrlout) < 0 &&
+        if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS) &&
             (acm->ctrl_caps & USB_CDC_CAP_LINE))
-                goto error_set_control;
+                goto bail_out;
 
         usb_autopm_put_interface(acm->control);
 
-        /*
-         * Unthrottle device in case the TTY was closed while throttled.
-         */
-        spin_lock_irq(&acm->read_lock);
-        acm->throttled = 0;
-        acm->throttle_req = 0;
-        spin_unlock_irq(&acm->read_lock);
-
         if (acm_submit_read_urbs(acm, GFP_KERNEL))
-                goto error_submit_read_urbs;
+                goto bail_out;
 
-        mutex_unlock(&acm->mutex);
+        set_bit(ASYNCB_INITIALIZED, &acm->port.flags);
+        rv = tty_port_block_til_ready(&acm->port, tty, filp);
 
-        return 0;
+        mutex_unlock(&acm->mutex);
+out:
+        mutex_unlock(&open_mutex);
+        return rv;
 
-error_submit_read_urbs:
-        acm->ctrlout = 0;
-        acm_set_control(acm, acm->ctrlout);
-error_set_control:
-        usb_kill_urb(acm->ctrlurb);
-error_submit_urb:
-        usb_autopm_put_interface(acm->control);
-error_get_interface:
-disconnected:
+bail_out:
+        acm->port.count--;
         mutex_unlock(&acm->mutex);
-        return retval;
+        usb_autopm_put_interface(acm->control);
+early_bail:
+        mutex_unlock(&open_mutex);
+        tty_port_tty_set(&acm->port, NULL);
+        return -EIO;
 }
 
-static void acm_port_destruct(struct tty_port *port)
+static void acm_tty_unregister(struct acm *acm)
 {
-        struct acm *acm = container_of(port, struct acm, port);
-
-        dev_dbg(&acm->control->dev, "%s\n", __func__);
+        int i;
 
         tty_unregister_device(acm_tty_driver, acm->minor);
-        acm_release_minor(acm);
         usb_put_intf(acm->control);
+        acm_table[acm->minor] = NULL;
+        usb_free_urb(acm->ctrlurb);
+        for (i = 0; i < ACM_NW; i++)
+                usb_free_urb(acm->wb[i].urb);
+        for (i = 0; i < acm->rx_buflimit; i++)
+                usb_free_urb(acm->read_urbs[i]);
         kfree(acm->country_codes);
         kfree(acm);
 }
 
-static void acm_port_shutdown(struct tty_port *port)
+static void acm_port_down(struct acm *acm)
 {
-        struct acm *acm = container_of(port, struct acm, port);
         int i;
 
-        dev_dbg(&acm->control->dev, "%s\n", __func__);
-
-        mutex_lock(&acm->mutex);
-        if (!acm->disconnected) {
+        if (acm->dev) {
                 usb_autopm_get_interface(acm->control);
                 acm_set_control(acm, acm->ctrlout = 0);
                 usb_kill_urb(acm->ctrlurb);
@@ -626,28 +570,48 @@ static void acm_port_shutdown(struct tty_port *port)
                 acm->control->needs_remote_wakeup = 0;
                 usb_autopm_put_interface(acm->control);
         }
-        mutex_unlock(&acm->mutex);
-}
-
-static void acm_tty_cleanup(struct tty_struct *tty)
-{
-        struct acm *acm = tty->driver_data;
-        dev_dbg(&acm->control->dev, "%s\n", __func__);
-        tty_port_put(&acm->port);
 }
 
 static void acm_tty_hangup(struct tty_struct *tty)
 {
-        struct acm *acm = tty->driver_data;
-        dev_dbg(&acm->control->dev, "%s\n", __func__);
+        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)
 {
         struct acm *acm = tty->driver_data;
-        dev_dbg(&acm->control->dev, "%s\n", __func__);
-        tty_port_close(&acm->port, tty, filp);
+
+        /* Perform the closing process and see if we need to do the hardware
+           shutdown */
+        if (!acm)
+                return;
+
+        mutex_lock(&open_mutex);
+        if (tty_port_close_start(&acm->port, tty, filp) == 0) {
+                if (!acm->dev) {
+                        tty_port_tty_set(&acm->port, NULL);
+                        acm_tty_unregister(acm);
+                        tty->driver_data = NULL;
+                }
+                mutex_unlock(&open_mutex);
+                return;
+        }
+        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,
@@ -659,6 +623,8 @@ static int acm_tty_write(struct tty_struct *tty,
         int wbn;
         struct acm_wb *wb;
 
+        if (!ACM_READY(acm))
+                return -EINVAL;
         if (!count)
                 return 0;
 
@@ -687,6 +653,8 @@ static int acm_tty_write(struct tty_struct *tty,
 static int acm_tty_write_room(struct tty_struct *tty)
 {
         struct acm *acm = tty->driver_data;
+        if (!ACM_READY(acm))
+                return -EINVAL;
         /*
          * Do not let the line discipline to know that we have a reserve,
          * or it might get too enthusiastic.
@@ -697,11 +665,7 @@ static int acm_tty_write_room(struct tty_struct *tty)
 static int acm_tty_chars_in_buffer(struct tty_struct *tty)
 {
         struct acm *acm = tty->driver_data;
-        /*
-         * if the device was unplugged then any remaining characters fell out
-         * of the connector ;)
-         */
-        if (acm->disconnected)
+        if (!ACM_READY(acm))
                 return 0;
         /*
          * This is inaccurate (overcounts), but it works.
@@ -713,6 +677,9 @@ static void acm_tty_throttle(struct tty_struct *tty)
 {
         struct acm *acm = tty->driver_data;
 
+        if (!ACM_READY(acm))
+                return;
+
         spin_lock_irq(&acm->read_lock);
         acm->throttle_req = 1;
         spin_unlock_irq(&acm->read_lock);
@@ -723,6 +690,9 @@ static void acm_tty_unthrottle(struct tty_struct *tty)
         struct acm *acm = tty->driver_data;
         unsigned int was_throttled;
 
+        if (!ACM_READY(acm))
+                return;
+
         spin_lock_irq(&acm->read_lock);
         was_throttled = acm->throttled;
         acm->throttled = 0;
@@ -737,7 +707,8 @@ static int acm_tty_break_ctl(struct tty_struct *tty, int state)
 {
         struct acm *acm = tty->driver_data;
         int retval;
-
+        if (!ACM_READY(acm))
+                return -EINVAL;
         retval = acm_send_break(acm, state ? 0xffff : 0);
         if (retval < 0)
                 dev_dbg(&acm->control->dev, "%s - send break failed\n",
@@ -749,6 +720,9 @@ static int acm_tty_tiocmget(struct tty_struct *tty)
 {
         struct acm *acm = tty->driver_data;
 
+        if (!ACM_READY(acm))
+                return -EINVAL;
+
         return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
                (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
                (acm->ctrlin  & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
@@ -763,6 +737,9 @@ static int acm_tty_tiocmset(struct tty_struct *tty,
         struct acm *acm = tty->driver_data;
         unsigned int newctrl;
 
+        if (!ACM_READY(acm))
+                return -EINVAL;
+
         newctrl = acm->ctrlout;
         set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
                                         (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
@@ -776,75 +753,15 @@ static int acm_tty_tiocmset(struct tty_struct *tty,
         return acm_set_control(acm, acm->ctrlout = newctrl);
 }
 
-static int get_serial_info(struct acm *acm, struct serial_struct __user *info)
-{
-        struct serial_struct tmp;
-
-        if (!info)
-                return -EINVAL;
-
-        memset(&tmp, 0, sizeof(tmp));
-        tmp.flags = ASYNC_LOW_LATENCY;
-        tmp.xmit_fifo_size = acm->writesize;
-        tmp.baud_base = le32_to_cpu(acm->line.dwDTERate);
-        tmp.close_delay = acm->port.close_delay / 10;
-        tmp.closing_wait = acm->port.closing_wait == ASYNC_CLOSING_WAIT_NONE ?
-                                ASYNC_CLOSING_WAIT_NONE :
-                                acm->port.closing_wait / 10;
-
-        if (copy_to_user(info, &tmp, sizeof(tmp)))
-                return -EFAULT;
-        else
-                return 0;
-}
-
-static int set_serial_info(struct acm *acm,
-                                struct serial_struct __user *newinfo)
-{
-        struct serial_struct new_serial;
-        unsigned int closing_wait, close_delay;
-        int retval = 0;
-
-        if (copy_from_user(&new_serial, newinfo, sizeof(new_serial)))
-                return -EFAULT;
-
-        close_delay = new_serial.close_delay * 10;
-        closing_wait = new_serial.closing_wait == ASYNC_CLOSING_WAIT_NONE ?
-                        ASYNC_CLOSING_WAIT_NONE : new_serial.closing_wait * 10;
-
-        mutex_lock(&acm->port.mutex);
-
-        if (!capable(CAP_SYS_ADMIN)) {
-                if ((close_delay != acm->port.close_delay) ||
-                    (closing_wait != acm->port.closing_wait))
-                        retval = -EPERM;
-                else
-                        retval = -EOPNOTSUPP;
-        } else {
-                acm->port.close_delay  = close_delay;
-                acm->port.closing_wait = closing_wait;
-        }
-
-        mutex_unlock(&acm->port.mutex);
-        return retval;
-}
-
 static int acm_tty_ioctl(struct tty_struct *tty,
                                         unsigned int cmd, unsigned long arg)
 {
         struct acm *acm = tty->driver_data;
-        int rv = -ENOIOCTLCMD;
 
-        switch (cmd) {
-        case TIOCGSERIAL: /* gets serial port data */
-                rv = get_serial_info(acm, (struct serial_struct __user *) arg);
-                break;
-        case TIOCSSERIAL:
-                rv = set_serial_info(acm, (struct serial_struct __user *) arg);
-                break;
-        }
+        if (!ACM_READY(acm))
+                return -EINVAL;
 
-        return rv;
+        return -ENOIOCTLCMD;
 }
 
 static const __u32 acm_tty_speed[] = {
@@ -855,34 +772,27 @@ static const __u32 acm_tty_speed[] = {
         2500000, 3000000, 3500000, 4000000
 };
 
+static const __u8 acm_tty_size[] = {
+        5, 6, 7, 8
+};
+
 static void acm_tty_set_termios(struct tty_struct *tty,
                                                 struct ktermios *termios_old)
 {
         struct acm *acm = tty->driver_data;
-        struct ktermios *termios = &tty->termios;
+        struct ktermios *termios = tty->termios;
         struct usb_cdc_line_coding newline;
         int newctrl = acm->ctrlout;
 
+        if (!ACM_READY(acm))
+                return;
+
         newline.dwDTERate = cpu_to_le32(tty_get_baud_rate(tty));
         newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
         newline.bParityType = termios->c_cflag & PARENB ?
                                 (termios->c_cflag & PARODD ? 1 : 2) +
                                 (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
-        switch (termios->c_cflag & CSIZE) {
-        case CS5:
-                newline.bDataBits = 5;
-                break;
-        case CS6:
-                newline.bDataBits = 6;
-                break;
-        case CS7:
-                newline.bDataBits = 7;
-                break;
-        case CS8:
-        default:
-                newline.bDataBits = 8;
-                break;
-        }
+        newline.bDataBits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4];
         /* FIXME: Needs to clear unsupported bits in the termios */
         acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
 
@@ -906,12 +816,6 @@ static void acm_tty_set_termios(struct tty_struct *tty,
         }
 }
 
-static const struct tty_port_operations acm_port_ops = {
-        .shutdown = acm_port_shutdown,
-        .activate = acm_port_activate,
-        .destruct = acm_port_destruct,
-};
-
 /*
  * USB probe and disconnect routines.
  */
@@ -989,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;
@@ -1043,7 +951,7 @@ static int acm_probe(struct usb_interface *intf,
                 case USB_CDC_CALL_MANAGEMENT_TYPE:
                         call_management_function = buffer[3];
                         call_interface_num = buffer[4];
-                        if ((quirks & NOT_A_MODEM) == 0 && (call_management_function & 3) != 3)
+                        if ( (quirks & NOT_A_MODEM) == 0 && (call_management_function & 3) != 3)
                                 dev_err(&intf->dev, "This device cannot do calls on its own. It is not a modem.\n");
                         break;
                 default:
@@ -1151,8 +1059,7 @@ skip_normal_probe:
         }
 
 
-        if (data_interface->cur_altsetting->desc.bNumEndpoints < 2 ||
-            control_interface->cur_altsetting->desc.bNumEndpoints == 0)
+        if (data_interface->cur_altsetting->desc.bNumEndpoints < 2)
                 return -EINVAL;
 
         epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
@@ -1172,6 +1079,12 @@ skip_normal_probe:
         }
 made_compressed_probe:
         dev_dbg(&intf->dev, "interfaces are valid\n");
+        for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);
+
+        if (minor == ACM_TTY_MINORS) {
+                dev_err(&intf->dev, "no more free acm devices\n");
+                return -ENODEV;
+        }
 
         acm = kzalloc(sizeof(struct acm), GFP_KERNEL);
         if (acm == NULL) {
@@ -1179,18 +1092,11 @@ made_compressed_probe:
                 goto alloc_fail;
         }
 
-        minor = acm_alloc_minor(acm);
-        if (minor == ACM_TTY_MINORS) {
-                dev_err(&intf->dev, "no more free acm devices\n");
-                kfree(acm);
-                return -ENODEV;
-        }
-
-        ctrlsize = usb_endpoint_maxp(epctrl);
-        readsize = usb_endpoint_maxp(epread) *
+        ctrlsize = le16_to_cpu(epctrl->wMaxPacketSize);
+        readsize = le16_to_cpu(epread->wMaxPacketSize) *
                                 (quirks == SINGLE_RX_URB ? 1 : 2);
         acm->combined_interfaces = combined_interfaces;
-        acm->writesize = usb_endpoint_maxp(epwrite) * 20;
+        acm->writesize = le16_to_cpu(epwrite->wMaxPacketSize) * 20;
         acm->control = control_interface;
         acm->data = data_interface;
         acm->minor = minor;
@@ -1202,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);
@@ -1209,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;
 
@@ -1281,7 +1190,7 @@ made_compressed_probe:
 
                 if (usb_endpoint_xfer_int(epwrite))
                         usb_fill_int_urb(snd->urb, usb_dev,
-                                usb_sndintpipe(usb_dev, epwrite->bEndpointAddress),
+                                usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
                                 NULL, acm->writesize, acm_write_bulk, snd, epwrite->bInterval);
                 else
                         usb_fill_bulk_urb(snd->urb, usb_dev,
@@ -1346,8 +1255,9 @@ skip_countries:
         usb_set_intfdata(data_interface, acm);
 
         usb_get_intf(control_interface);
-        tty_port_register_device(&acm->port, acm_tty_driver, minor,
-                        &control_interface->dev);
+        tty_register_device(acm_tty_driver, minor, &control_interface->dev);
+
+        acm_table[minor] = acm;
 
         return 0;
 alloc_fail7:
@@ -1363,7 +1273,6 @@ alloc_fail5:
 alloc_fail4:
         usb_free_coherent(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
 alloc_fail2:
-        acm_release_minor(acm);
         kfree(acm);
 alloc_fail:
         return -ENOMEM;
@@ -1373,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);
@@ -1389,16 +1303,12 @@ static void acm_disconnect(struct usb_interface *intf)
         struct acm *acm = usb_get_intfdata(intf);
         struct usb_device *usb_dev = interface_to_usbdev(intf);
         struct tty_struct *tty;
-        int i;
-
-        dev_dbg(&intf->dev, "%s\n", __func__);
 
         /* sibling interface is already cleaning up */
         if (!acm)
                 return;
 
-        mutex_lock(&acm->mutex);
-        acm->disconnected = true;
+        mutex_lock(&open_mutex);
         if (acm->country_codes) {
                 device_remove_file(&acm->control->dev,
                                 &dev_attr_wCountryCodes);
@@ -1406,32 +1316,34 @@ static void acm_disconnect(struct usb_interface *intf)
                                 &dev_attr_iCountryCodeRelDate);
         }
         device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
+        acm->dev = NULL;
         usb_set_intfdata(acm->control, NULL);
         usb_set_intfdata(acm->data, NULL);
-        mutex_unlock(&acm->mutex);
-
-        tty = tty_port_tty_get(&acm->port);
-        if (tty) {
-                tty_vhangup(tty);
-                tty_kref_put(tty);
-        }
 
         stop_data_traffic(acm);
 
-        usb_free_urb(acm->ctrlurb);
-        for (i = 0; i < ACM_NW; i++)
-                usb_free_urb(acm->wb[i].urb);
-        for (i = 0; i < acm->rx_buflimit; i++)
-                usb_free_urb(acm->read_urbs[i]);
+        usb_kill_anchored_urbs(&acm->deferred);
         acm_write_buffers_free(acm);
-        usb_free_coherent(usb_dev, acm->ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
+        usb_free_coherent(usb_dev, acm->ctrlsize, acm->ctrl_buffer,
+                          acm->ctrl_dma);
         acm_read_buffers_free(acm);
 
         if (!acm->combined_interfaces)
                 usb_driver_release_interface(&acm_driver, intf == acm->control ?
                                         acm->data : acm->control);
 
-        tty_port_put(&acm->port);
+        if (acm->port.count == 0) {
+                acm_tty_unregister(acm);
+                mutex_unlock(&open_mutex);
+                return;
+        }
+
+        mutex_unlock(&open_mutex);
+        tty = tty_port_tty_get(&acm->port);
+        if (tty) {
+                tty_hangup(tty);
+                tty_kref_put(tty);
+        }
 }
 
 #ifdef CONFIG_PM
@@ -1440,7 +1352,12 @@ static int acm_suspend(struct usb_interface *intf, pm_message_t message)
         struct acm *acm = usb_get_intfdata(intf);
         int cnt;
 
-        if (PMSG_IS_AUTO(message)) {
+        if (!acm) {
+                pr_err("%s: !acm\n", __func__);
+                return -ENODEV;
+        }
+
+        if (message.event & PM_EVENT_AUTO) {
                 int b;
 
                 spin_lock_irq(&acm->write_lock);
@@ -1458,32 +1375,66 @@ static int acm_suspend(struct usb_interface *intf, pm_message_t message)
 
         if (cnt)
                 return 0;
+        /*
+        we treat opened interfaces differently,
+        we must guard against open
+        */
+        mutex_lock(&acm->mutex);
 
-        if (test_bit(ASYNCB_INITIALIZED, &acm->port.flags))
+        if (acm->port.count)
                 stop_data_traffic(acm);
 
+        mutex_unlock(&acm->mutex);
         return 0;
 }
 
 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;
 
-        if (test_bit(ASYNCB_INITIALIZED, &acm->port.flags)) {
-                rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
 
+        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;
@@ -1492,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
@@ -1504,6 +1456,7 @@ static int acm_resume(struct usb_interface *intf)
         }
 
 err_out:
+        mutex_unlock(&acm->mutex);
         return rv;
 }
 
@@ -1512,14 +1465,21 @@ static int acm_reset_resume(struct usb_interface *intf)
         struct acm *acm = usb_get_intfdata(intf);
         struct tty_struct *tty;
 
-        if (test_bit(ASYNCB_INITIALIZED, &acm->port.flags)) {
+        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);
                 }
         }
-
+        mutex_unlock(&acm->mutex);
         return acm_resume(intf);
 }
 
@@ -1599,18 +1559,15 @@ static const struct usb_device_id acm_ids[] = {
                                            Maybe we should define a new
                                            quirk for this. */
         },
-        { USB_DEVICE(0x0572, 0x1340), /* Conexant CX93010-2x UCMxx */
-        .driver_info = NO_UNION_NORMAL,
-        },
-        { USB_DEVICE(0x05f9, 0x4002), /* PSC Scanning, Magellan 800i */
-        .driver_info = NO_UNION_NORMAL,
-        },
         { USB_DEVICE(0x1bbb, 0x0003), /* Alcatel OT-I650 */
         .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
         },
         { 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
@@ -1691,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) },
@@ -1727,7 +1694,6 @@ static struct usb_driver acm_driver = {
 #ifdef CONFIG_PM
         .supports_autosuspend = 1,
 #endif
-        .disable_hub_initiated_lpm = 1,
 };
 
 /*
@@ -1735,10 +1701,8 @@ static struct usb_driver acm_driver = {
  */
 
 static const struct tty_operations acm_ops = {
-        .install =              acm_tty_install,
         .open =                 acm_tty_open,
         .close =                acm_tty_close,
-        .cleanup =              acm_tty_cleanup,
         .hangup =               acm_tty_hangup,
         .write =                acm_tty_write,
         .write_room =           acm_tty_write_room,
@@ -1762,6 +1726,7 @@ static int __init acm_init(void)
         acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
         if (!acm_tty_driver)
                 return -ENOMEM;
+        acm_tty_driver->owner = THIS_MODULE,
         acm_tty_driver->driver_name = "acm",
         acm_tty_driver->name = "ttyACM",
         acm_tty_driver->major = ACM_TTY_MAJOR,