Merge tag 'usb-3.6-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb

Pull USB patches from Greg Kroah-Hartman:
 "Here's the big USB patch set for the 3.6-rc1 merge window.

  Lots of little changes in here, primarily for gadget controllers and
  drivers.  There's some scsi changes that I think also went in through
  the scsi tree, but they merge just fine.  All of these patches have
  been in the linux-next tree for a while now.

  Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>"

Fix up trivial conflicts in include/scsi/scsi_device.h (same libata
conflict that Jeff had already encountered)

* tag 'usb-3.6-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb: (207 commits)
  usb: Add USB_QUIRK_RESET_RESUME for all Logitech UVC webcams
  usb: Add quirk detection based on interface information
  usb: s3c-hsotg: Add header file protection macros in s3c-hsotg.h
  USB: ehci-s5p: Add vbus setup function to the s5p ehci glue layer
  USB: add USB_VENDOR_AND_INTERFACE_INFO() macro
  USB: notify phy when root hub port connect change
  USB: remove 8 bytes of padding from usb_host_interface on 64 bit builds
  USB: option: add ZTE MF821D
  USB: sierra: QMI mode MC7710 moved to qcserial
  USB: qcserial: adding Sierra Wireless devices
  USB: qcserial: support generic Qualcomm serial ports
  USB: qcserial: make probe more flexible
  USB: qcserial: centralize probe exit path
  USB: qcserial: consolidate usb_set_interface calls
  USB: ehci-s5p: Add support for device tree
  USB: ohci-exynos: Add support for device tree
  USB: ehci-omap: fix compile failure(v1)
  usb: host: tegra: pass correct pointer in ehci_setup()
  USB: ehci-fsl: Update ifdef check to work on 64-bit ppc
  USB: serial: keyspan: Removed unrequired parentheses.
  ...

10 files changed, 414 insertions, 150 deletions

diff --git a/drivers/usb/core/devio.c b/drivers/usb/core/devio.c
index e0f107948eba..ebb8a9de8b5f 100644
--- a/drivers/usb/core/devio.c
+++ b/drivers/usb/core/devio.c
@@ -47,6 +47,7 @@
 #include <linux/notifier.h>
 #include <linux/security.h>
 #include <linux/user_namespace.h>
+#include <linux/scatterlist.h>
 #include <asm/uaccess.h>
 #include <asm/byteorder.h>
 #include <linux/moduleparam.h>
@@ -55,6 +56,7 @@
 
 #define USB_MAXBUS                      64
 #define USB_DEVICE_MAX                  USB_MAXBUS * 128
+#define USB_SG_SIZE                     16384 /* split-size for large txs */
 
 /* Mutual exclusion for removal, open, and release */
 DEFINE_MUTEX(usbfs_mutex);
@@ -285,9 +287,16 @@ static struct async *alloc_async(unsigned int numisoframes)
 
 static void free_async(struct async *as)
 {
+        int i;
+
         put_pid(as->pid);
         if (as->cred)
                 put_cred(as->cred);
+        for (i = 0; i < as->urb->num_sgs; i++) {
+                if (sg_page(&as->urb->sg[i]))
+                        kfree(sg_virt(&as->urb->sg[i]));
+        }
+        kfree(as->urb->sg);
         kfree(as->urb->transfer_buffer);
         kfree(as->urb->setup_packet);
         usb_free_urb(as->urb);
@@ -388,6 +397,53 @@ static void snoop_urb(struct usb_device *udev,
         }
 }
 
+static void snoop_urb_data(struct urb *urb, unsigned len)
+{
+        int i, size;
+
+        if (!usbfs_snoop)
+                return;
+
+        if (urb->num_sgs == 0) {
+                print_hex_dump(KERN_DEBUG, "data: ", DUMP_PREFIX_NONE, 32, 1,
+                        urb->transfer_buffer, len, 1);
+                return;
+        }
+
+        for (i = 0; i < urb->num_sgs && len; i++) {
+                size = (len > USB_SG_SIZE) ? USB_SG_SIZE : len;
+                print_hex_dump(KERN_DEBUG, "data: ", DUMP_PREFIX_NONE, 32, 1,
+                        sg_virt(&urb->sg[i]), size, 1);
+                len -= size;
+        }
+}
+
+static int copy_urb_data_to_user(u8 __user *userbuffer, struct urb *urb)
+{
+        unsigned i, len, size;
+
+        if (urb->number_of_packets > 0)         /* Isochronous */
+                len = urb->transfer_buffer_length;
+        else                                    /* Non-Isoc */
+                len = urb->actual_length;
+
+        if (urb->num_sgs == 0) {
+                if (copy_to_user(userbuffer, urb->transfer_buffer, len))
+                        return -EFAULT;
+                return 0;
+        }
+
+        for (i = 0; i < urb->num_sgs && len; i++) {
+                size = (len > USB_SG_SIZE) ? USB_SG_SIZE : len;
+                if (copy_to_user(userbuffer, sg_virt(&urb->sg[i]), size))
+                        return -EFAULT;
+                userbuffer += size;
+                len -= size;
+        }
+
+        return 0;
+}
+
 #define AS_CONTINUATION 1
 #define AS_UNLINK       2
 
@@ -454,9 +510,10 @@ static void async_completed(struct urb *urb)
         }
         snoop(&urb->dev->dev, "urb complete\n");
         snoop_urb(urb->dev, as->userurb, urb->pipe, urb->actual_length,
-                        as->status, COMPLETE,
-                        ((urb->transfer_flags & URB_DIR_MASK) == USB_DIR_OUT) ?
-                                NULL : urb->transfer_buffer, urb->actual_length);
+                        as->status, COMPLETE, NULL, 0);
+        if ((urb->transfer_flags & URB_DIR_MASK) == USB_DIR_IN)
+                snoop_urb_data(urb, urb->actual_length);
+
         if (as->status < 0 && as->bulk_addr && as->status != -ECONNRESET &&
                         as->status != -ENOENT)
                 cancel_bulk_urbs(ps, as->bulk_addr);
@@ -1114,8 +1171,8 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
         struct async *as = NULL;
         struct usb_ctrlrequest *dr = NULL;
         unsigned int u, totlen, isofrmlen;
-        int ret, ifnum = -1;
-        int is_in;
+        int i, ret, is_in, num_sgs = 0, ifnum = -1;
+        void *buf;
 
         if (uurb->flags & ~(USBDEVFS_URB_ISO_ASAP |
                                 USBDEVFS_URB_SHORT_NOT_OK |
@@ -1199,6 +1256,9 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
                         goto interrupt_urb;
                 }
                 uurb->number_of_packets = 0;
+                num_sgs = DIV_ROUND_UP(uurb->buffer_length, USB_SG_SIZE);
+                if (num_sgs == 1 || num_sgs > ps->dev->bus->sg_tablesize)
+                        num_sgs = 0;
                 break;
 
         case USBDEVFS_URB_TYPE_INTERRUPT:
@@ -1255,26 +1315,67 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
                 ret = -ENOMEM;
                 goto error;
         }
-        u += sizeof(struct async) + sizeof(struct urb) + uurb->buffer_length;
+
+        u += sizeof(struct async) + sizeof(struct urb) + uurb->buffer_length +
+             num_sgs * sizeof(struct scatterlist);
         ret = usbfs_increase_memory_usage(u);
         if (ret)
                 goto error;
         as->mem_usage = u;
 
-        if (uurb->buffer_length > 0) {
+        if (num_sgs) {
+                as->urb->sg = kmalloc(num_sgs * sizeof(struct scatterlist),
+                                      GFP_KERNEL);
+                if (!as->urb->sg) {
+                        ret = -ENOMEM;
+                        goto error;
+                }
+                as->urb->num_sgs = num_sgs;
+                sg_init_table(as->urb->sg, as->urb->num_sgs);
+
+                totlen = uurb->buffer_length;
+                for (i = 0; i < as->urb->num_sgs; i++) {
+                        u = (totlen > USB_SG_SIZE) ? USB_SG_SIZE : totlen;
+                        buf = kmalloc(u, GFP_KERNEL);
+                        if (!buf) {
+                                ret = -ENOMEM;
+                                goto error;
+                        }
+                        sg_set_buf(&as->urb->sg[i], buf, u);
+
+                        if (!is_in) {
+                                if (copy_from_user(buf, uurb->buffer, u)) {
+                                        ret = -EFAULT;
+                                        goto error;
+                                }
+                        }
+                        totlen -= u;
+                }
+        } else if (uurb->buffer_length > 0) {
                 as->urb->transfer_buffer = kmalloc(uurb->buffer_length,
                                 GFP_KERNEL);
                 if (!as->urb->transfer_buffer) {
                         ret = -ENOMEM;
                         goto error;
                 }
-                /* Isochronous input data may end up being discontiguous
-                 * if some of the packets are short.  Clear the buffer so
-                 * that the gaps don't leak kernel data to userspace.
-                 */
-                if (is_in && uurb->type == USBDEVFS_URB_TYPE_ISO)
+
+                if (!is_in) {
+                        if (copy_from_user(as->urb->transfer_buffer,
+                                           uurb->buffer,
+                                           uurb->buffer_length)) {
+                                ret = -EFAULT;
+                                goto error;
+                        }
+                } else if (uurb->type == USBDEVFS_URB_TYPE_ISO) {
+                        /*
+                         * Isochronous input data may end up being
+                         * discontiguous if some of the packets are short.
+                         * Clear the buffer so that the gaps don't leak
+                         * kernel data to userspace.
+                         */
                         memset(as->urb->transfer_buffer, 0,
                                         uurb->buffer_length);
+                }
         }
         as->urb->dev = ps->dev;
         as->urb->pipe = (uurb->type << 30) |
@@ -1328,17 +1429,12 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
         as->pid = get_pid(task_pid(current));
         as->cred = get_current_cred();
         security_task_getsecid(current, &as->secid);
-        if (!is_in && uurb->buffer_length > 0) {
-                if (copy_from_user(as->urb->transfer_buffer, uurb->buffer,
-                                uurb->buffer_length)) {
-                        ret = -EFAULT;
-                        goto error;
-                }
-        }
         snoop_urb(ps->dev, as->userurb, as->urb->pipe,
                         as->urb->transfer_buffer_length, 0, SUBMIT,
-                        is_in ? NULL : as->urb->transfer_buffer,
-                                uurb->buffer_length);
+                        NULL, 0);
+        if (!is_in)
+                snoop_urb_data(as->urb, as->urb->transfer_buffer_length);
+
         async_newpending(as);
 
         if (usb_endpoint_xfer_bulk(&ep->desc)) {
@@ -1433,11 +1529,7 @@ static int processcompl(struct async *as, void __user * __user *arg)
         unsigned int i;
 
         if (as->userbuffer && urb->actual_length) {
-                if (urb->number_of_packets > 0)         /* Isochronous */
-                        i = urb->transfer_buffer_length;
-                else                                    /* Non-Isoc */
-                        i = urb->actual_length;
-                if (copy_to_user(as->userbuffer, urb->transfer_buffer, i))
+                if (copy_urb_data_to_user(as->userbuffer, urb))
                         goto err_out;
         }
         if (put_user(as->status, &userurb->status))
@@ -1604,10 +1696,10 @@ static int processcompl_compat(struct async *as, void __user * __user *arg)
         void __user *addr = as->userurb;
         unsigned int i;
 
-        if (as->userbuffer && urb->actual_length)
-                if (copy_to_user(as->userbuffer, urb->transfer_buffer,
-                                 urb->actual_length))
+        if (as->userbuffer && urb->actual_length) {
+                if (copy_urb_data_to_user(as->userbuffer, urb))
                         return -EFAULT;
+        }
         if (put_user(as->status, &userurb->status))
                 return -EFAULT;
         if (put_user(urb->actual_length, &userurb->actual_length))
@@ -1820,6 +1912,22 @@ static int proc_release_port(struct dev_state *ps, void __user *arg)
         return usb_hub_release_port(ps->dev, portnum, ps);
 }
 
+static int proc_get_capabilities(struct dev_state *ps, void __user *arg)
+{
+        __u32 caps;
+
+        caps = USBDEVFS_CAP_ZERO_PACKET | USBDEVFS_CAP_NO_PACKET_SIZE_LIM;
+        if (!ps->dev->bus->no_stop_on_short)
+                caps |= USBDEVFS_CAP_BULK_CONTINUATION;
+        if (ps->dev->bus->sg_tablesize)
+                caps |= USBDEVFS_CAP_BULK_SCATTER_GATHER;
+
+        if (put_user(caps, (__u32 __user *)arg))
+                return -EFAULT;
+
+        return 0;
+}
+
 /*
  * NOTE:  All requests here that have interface numbers as parameters
  * are assuming that somehow the configuration has been prevented from
@@ -1990,6 +2098,9 @@ static long usbdev_do_ioctl(struct file *file, unsigned int cmd,
                 snoop(&dev->dev, "%s: RELEASE_PORT\n", __func__);
                 ret = proc_release_port(ps, p);
                 break;
+        case USBDEVFS_GET_CAPABILITIES:
+                ret = proc_get_capabilities(ps, p);
+                break;
         }
         usb_unlock_device(dev);
         if (ret >= 0)
diff --git a/drivers/usb/core/driver.c b/drivers/usb/core/driver.c
index f536aebc958e..445455a4429b 100644
--- a/drivers/usb/core/driver.c
+++ b/drivers/usb/core/driver.c
@@ -367,6 +367,7 @@ static int usb_probe_interface(struct device *dev)
         return error;
 
  err:
+        usb_set_intfdata(intf, NULL);
         intf->needs_remote_wakeup = 0;
         intf->condition = USB_INTERFACE_UNBOUND;
         usb_cancel_queued_reset(intf);
@@ -606,30 +607,19 @@ int usb_match_device(struct usb_device *dev, const struct usb_device_id *id)
 }
 
 /* returns 0 if no match, 1 if match */
-int usb_match_one_id(struct usb_interface *interface,
-                     const struct usb_device_id *id)
+int usb_match_one_id_intf(struct usb_device *dev,
+                          struct usb_host_interface *intf,
+                          const struct usb_device_id *id)
 {
-        struct usb_host_interface *intf;
-        struct usb_device *dev;
-
-        /* proc_connectinfo in devio.c may call us with id == NULL. */
-        if (id == NULL)
-                return 0;
-
-        intf = interface->cur_altsetting;
-        dev = interface_to_usbdev(interface);
-
-        if (!usb_match_device(dev, id))
-                return 0;
-
-        /* The interface class, subclass, and protocol should never be
+        /* The interface class, subclass, protocol and number should never be
          * checked for a match if the device class is Vendor Specific,
          * unless the match record specifies the Vendor ID. */
         if (dev->descriptor.bDeviceClass == USB_CLASS_VENDOR_SPEC &&
                         !(id->match_flags & USB_DEVICE_ID_MATCH_VENDOR) &&
                         (id->match_flags & (USB_DEVICE_ID_MATCH_INT_CLASS |
                                 USB_DEVICE_ID_MATCH_INT_SUBCLASS |
-                                USB_DEVICE_ID_MATCH_INT_PROTOCOL)))
+                                USB_DEVICE_ID_MATCH_INT_PROTOCOL |
+                                USB_DEVICE_ID_MATCH_INT_NUMBER)))
                 return 0;
 
         if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_CLASS) &&
@@ -644,8 +634,32 @@ int usb_match_one_id(struct usb_interface *interface,
             (id->bInterfaceProtocol != intf->desc.bInterfaceProtocol))
                 return 0;
 
+        if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_NUMBER) &&
+            (id->bInterfaceNumber != intf->desc.bInterfaceNumber))
+                return 0;
+
         return 1;
 }
+
+/* returns 0 if no match, 1 if match */
+int usb_match_one_id(struct usb_interface *interface,
+                     const struct usb_device_id *id)
+{
+        struct usb_host_interface *intf;
+        struct usb_device *dev;
+
+        /* proc_connectinfo in devio.c may call us with id == NULL. */
+        if (id == NULL)
+                return 0;
+
+        intf = interface->cur_altsetting;
+        dev = interface_to_usbdev(interface);
+
+        if (!usb_match_device(dev, id))
+                return 0;
+
+        return usb_match_one_id_intf(dev, intf, id);
+}
 EXPORT_SYMBOL_GPL(usb_match_one_id);
 
 /**
diff --git a/drivers/usb/core/file.c b/drivers/usb/core/file.c
index e673b26e598f..e5387a47ef6f 100644
--- a/drivers/usb/core/file.c
+++ b/drivers/usb/core/file.c
@@ -92,7 +92,7 @@ static int init_usb_class(void)
         }
 
         kref_init(&usb_class->kref);
-        usb_class->class = class_create(THIS_MODULE, "usb");
+        usb_class->class = class_create(THIS_MODULE, "usbmisc");
         if (IS_ERR(usb_class->class)) {
                 result = IS_ERR(usb_class->class);
                 printk(KERN_ERR "class_create failed for usb devices\n");
diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
index 190b1ec7bdcb..bc84106ac057 100644
--- a/drivers/usb/core/hcd.c
+++ b/drivers/usb/core/hcd.c
@@ -1398,7 +1398,15 @@ int usb_hcd_map_urb_for_dma(struct usb_hcd *hcd, struct urb *urb,
             && !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)) {
                 if (hcd->self.uses_dma) {
                         if (urb->num_sgs) {
-                                int n = dma_map_sg(
+                                int n;
+
+                                /* We don't support sg for isoc transfers ! */
+                                if (usb_endpoint_xfer_isoc(&urb->ep->desc)) {
+                                        WARN_ON(1);
+                                        return -EINVAL;
+                                }
+
+                                n = dma_map_sg(
                                                 hcd->self.controller,
                                                 urb->sg,
                                                 urb->num_sgs,
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index 8fb484984c86..821126eb8176 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -20,6 +20,7 @@
 #include <linux/usb.h>
 #include <linux/usbdevice_fs.h>
 #include <linux/usb/hcd.h>
+#include <linux/usb/otg.h>
 #include <linux/usb/quirks.h>
 #include <linux/kthread.h>
 #include <linux/mutex.h>
@@ -81,7 +82,7 @@ struct usb_hub {
         u8                      indicator[USB_MAXCHILDREN];
         struct delayed_work     leds;
         struct delayed_work     init_work;
-        void                    **port_owners;
+        struct dev_state        **port_owners;
 };
 
 static inline int hub_is_superspeed(struct usb_device *hdev)
@@ -1271,7 +1272,8 @@ static int hub_configure(struct usb_hub *hub,
 
         hdev->children = kzalloc(hdev->maxchild *
                                 sizeof(struct usb_device *), GFP_KERNEL);
-        hub->port_owners = kzalloc(hdev->maxchild * sizeof(void *), GFP_KERNEL);
+        hub->port_owners = kzalloc(hdev->maxchild * sizeof(struct dev_state *),
+                                GFP_KERNEL);
         if (!hdev->children || !hub->port_owners) {
                 ret = -ENOMEM;
                 goto fail;
@@ -1649,7 +1651,7 @@ hub_ioctl(struct usb_interface *intf, unsigned int code, void *user_data)
  * to one of these "claimed" ports, the program will "own" the device.
  */
 static int find_port_owner(struct usb_device *hdev, unsigned port1,
-                void ***ppowner)
+                struct dev_state ***ppowner)
 {
         if (hdev->state == USB_STATE_NOTATTACHED)
                 return -ENODEV;
@@ -1664,10 +1666,11 @@ static int find_port_owner(struct usb_device *hdev, unsigned port1,
 }
 
 /* In the following three functions, the caller must hold hdev's lock */
-int usb_hub_claim_port(struct usb_device *hdev, unsigned port1, void *owner)
+int usb_hub_claim_port(struct usb_device *hdev, unsigned port1,
+                       struct dev_state *owner)
 {
         int rc;
-        void **powner;
+        struct dev_state **powner;
 
         rc = find_port_owner(hdev, port1, &powner);
         if (rc)
@@ -1678,10 +1681,11 @@ int usb_hub_claim_port(struct usb_device *hdev, unsigned port1, void *owner)
         return rc;
 }
 
-int usb_hub_release_port(struct usb_device *hdev, unsigned port1, void *owner)
+int usb_hub_release_port(struct usb_device *hdev, unsigned port1,
+                         struct dev_state *owner)
 {
         int rc;
-        void **powner;
+        struct dev_state **powner;
 
         rc = find_port_owner(hdev, port1, &powner);
         if (rc)
@@ -1692,10 +1696,10 @@ int usb_hub_release_port(struct usb_device *hdev, unsigned port1, void *owner)
         return rc;
 }
 
-void usb_hub_release_all_ports(struct usb_device *hdev, void *owner)
+void usb_hub_release_all_ports(struct usb_device *hdev, struct dev_state *owner)
 {
         int n;
-        void **powner;
+        struct dev_state **powner;
 
         n = find_port_owner(hdev, 1, &powner);
         if (n == 0) {
@@ -2065,7 +2069,7 @@ static int usb_enumerate_device(struct usb_device *udev)
                 if (err < 0) {
                         dev_err(&udev->dev, "can't read configurations, error %d\n",
                                 err);
-                        goto fail;
+                        return err;
                 }
         }
         if (udev->wusb == 1 && udev->authorized == 0) {
@@ -2081,8 +2085,12 @@ static int usb_enumerate_device(struct usb_device *udev)
                 udev->serial = usb_cache_string(udev, udev->descriptor.iSerialNumber);
         }
         err = usb_enumerate_device_otg(udev);
-fail:
-        return err;
+        if (err < 0)
+                return err;
+
+        usb_detect_interface_quirks(udev);
+
+        return 0;
 }
 
 static void set_usb_port_removable(struct usb_device *udev)
@@ -2611,6 +2619,50 @@ static int check_port_resume_type(struct usb_device *udev,
         return status;
 }
 
+int usb_disable_ltm(struct usb_device *udev)
+{
+        struct usb_hcd *hcd = bus_to_hcd(udev->bus);
+
+        /* Check if the roothub and device supports LTM. */
+        if (!usb_device_supports_ltm(hcd->self.root_hub) ||
+                        !usb_device_supports_ltm(udev))
+                return 0;
+
+        /* Clear Feature LTM Enable can only be sent if the device is
+         * configured.
+         */
+        if (!udev->actconfig)
+                return 0;
+
+        return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
+                        USB_REQ_CLEAR_FEATURE, USB_RECIP_DEVICE,
+                        USB_DEVICE_LTM_ENABLE, 0, NULL, 0,
+                        USB_CTRL_SET_TIMEOUT);
+}
+EXPORT_SYMBOL_GPL(usb_disable_ltm);
+
+void usb_enable_ltm(struct usb_device *udev)
+{
+        struct usb_hcd *hcd = bus_to_hcd(udev->bus);
+
+        /* Check if the roothub and device supports LTM. */
+        if (!usb_device_supports_ltm(hcd->self.root_hub) ||
+                        !usb_device_supports_ltm(udev))
+                return;
+
+        /* Set Feature LTM Enable can only be sent if the device is
+         * configured.
+         */
+        if (!udev->actconfig)
+                return;
+
+        usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
+                        USB_REQ_SET_FEATURE, USB_RECIP_DEVICE,
+                        USB_DEVICE_LTM_ENABLE, 0, NULL, 0,
+                        USB_CTRL_SET_TIMEOUT);
+}
+EXPORT_SYMBOL_GPL(usb_enable_ltm);
+
 #ifdef  CONFIG_USB_SUSPEND
 
 /*
@@ -2706,6 +2758,11 @@ int usb_port_suspend(struct usb_device *udev, pm_message_t msg)
         if (udev->usb2_hw_lpm_enabled == 1)
                 usb_set_usb2_hardware_lpm(udev, 0);
 
+        if (usb_disable_ltm(udev)) {
+                dev_err(&udev->dev, "%s Failed to disable LTM before suspend\n.",
+                                __func__);
+                return -ENOMEM;
+        }
         if (usb_unlocked_disable_lpm(udev)) {
                 dev_err(&udev->dev, "%s Failed to disable LPM before suspend\n.",
                                 __func__);
@@ -2735,7 +2792,8 @@ int usb_port_suspend(struct usb_device *udev, pm_message_t msg)
                 if (udev->usb2_hw_lpm_capable == 1)
                         usb_set_usb2_hardware_lpm(udev, 1);
 
-                /* Try to enable USB3 LPM again */
+                /* Try to enable USB3 LTM and LPM again */
+                usb_enable_ltm(udev);
                 usb_unlocked_enable_lpm(udev);
 
                 /* System sleep transitions should never fail */
@@ -2936,7 +2994,8 @@ int usb_port_resume(struct usb_device *udev, pm_message_t msg)
                 if (udev->usb2_hw_lpm_capable == 1)
                         usb_set_usb2_hardware_lpm(udev, 1);
 
-                /* Try to enable USB3 LPM */
+                /* Try to enable USB3 LTM and LPM */
+                usb_enable_ltm(udev);
                 usb_unlocked_enable_lpm(udev);
         }
 
@@ -3489,6 +3548,15 @@ EXPORT_SYMBOL_GPL(usb_unlocked_disable_lpm);
 
 void usb_unlocked_enable_lpm(struct usb_device *udev) { }
 EXPORT_SYMBOL_GPL(usb_unlocked_enable_lpm);
+
+int usb_disable_ltm(struct usb_device *udev)
+{
+        return 0;
+}
+EXPORT_SYMBOL_GPL(usb_disable_ltm);
+
+void usb_enable_ltm(struct usb_device *udev) { }
+EXPORT_SYMBOL_GPL(usb_enable_ltm);
 #endif
 
 
@@ -4038,6 +4106,13 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1,
                 }
         }
 
+        if (hcd->phy && !hdev->parent) {
+                if (portstatus & USB_PORT_STAT_CONNECTION)
+                        usb_phy_notify_connect(hcd->phy, port1);
+                else
+                        usb_phy_notify_disconnect(hcd->phy, port1);
+        }
+
         /* Return now if debouncing failed or nothing is connected or
          * the device was "removed".
          */
@@ -4672,6 +4747,23 @@ static int usb_reset_and_verify_device(struct usb_device *udev)
         }
         parent_hub = hdev_to_hub(parent_hdev);
 
+        /* Disable LPM and LTM while we reset the device and reinstall the alt
+         * settings.  Device-initiated LPM settings, and system exit latency
+         * settings are cleared when the device is reset, so we have to set
+         * them up again.
+         */
+        ret = usb_unlocked_disable_lpm(udev);
+        if (ret) {
+                dev_err(&udev->dev, "%s Failed to disable LPM\n.", __func__);
+                goto re_enumerate;
+        }
+        ret = usb_disable_ltm(udev);
+        if (ret) {
+                dev_err(&udev->dev, "%s Failed to disable LTM\n.",
+                                __func__);
+                goto re_enumerate;
+        }
+
         set_bit(port1, parent_hub->busy_bits);
         for (i = 0; i < SET_CONFIG_TRIES; ++i) {
 
@@ -4699,22 +4791,11 @@ static int usb_reset_and_verify_device(struct usb_device *udev)
                 goto done;
 
         mutex_lock(hcd->bandwidth_mutex);
-        /* Disable LPM while we reset the device and reinstall the alt settings.
-         * Device-initiated LPM settings, and system exit latency settings are
-         * cleared when the device is reset, so we have to set them up again.
-         */
-        ret = usb_disable_lpm(udev);
-        if (ret) {
-                dev_err(&udev->dev, "%s Failed to disable LPM\n.", __func__);
-                mutex_unlock(hcd->bandwidth_mutex);
-                goto done;
-        }
         ret = usb_hcd_alloc_bandwidth(udev, udev->actconfig, NULL, NULL);
         if (ret < 0) {
                 dev_warn(&udev->dev,
                                 "Busted HC?  Not enough HCD resources for "
                                 "old configuration.\n");
-                usb_enable_lpm(udev);
                 mutex_unlock(hcd->bandwidth_mutex);
                 goto re_enumerate;
         }
@@ -4726,7 +4807,6 @@ static int usb_reset_and_verify_device(struct usb_device *udev)
                 dev_err(&udev->dev,
                         "can't restore configuration #%d (error=%d)\n",
                         udev->actconfig->desc.bConfigurationValue, ret);
-                usb_enable_lpm(udev);
                 mutex_unlock(hcd->bandwidth_mutex);
                 goto re_enumerate;
         }
@@ -4765,17 +4845,18 @@ static int usb_reset_and_verify_device(struct usb_device *udev)
                                 desc->bInterfaceNumber,
                                 desc->bAlternateSetting,
                                 ret);
-                        usb_unlocked_enable_lpm(udev);
                         goto re_enumerate;
                 }
         }
 
-        /* Now that the alt settings are re-installed, enable LPM. */
-        usb_unlocked_enable_lpm(udev);
 done:
+        /* Now that the alt settings are re-installed, enable LTM and LPM. */
+        usb_unlocked_enable_lpm(udev);
+        usb_enable_ltm(udev);
         return 0;
  
 re_enumerate:
+        /* LPM state doesn't matter when we're about to destroy the device. */
         hub_port_logical_disconnect(parent_hub, port1);
         return -ENODEV;
 }
diff --git a/drivers/usb/core/message.c b/drivers/usb/core/message.c
index bdd1c6749d88..0ab7da2283e3 100644
--- a/drivers/usb/core/message.c
+++ b/drivers/usb/core/message.c
@@ -1174,6 +1174,8 @@ void usb_disable_device(struct usb_device *dev, int skip_ep0)
                         put_device(&dev->actconfig->interface[i]->dev);
                         dev->actconfig->interface[i] = NULL;
                 }
+                usb_unlocked_disable_lpm(dev);
+                usb_disable_ltm(dev);
                 dev->actconfig = NULL;
                 if (dev->state == USB_STATE_CONFIGURED)
                         usb_set_device_state(dev, USB_STATE_ADDRESS);
@@ -1559,7 +1561,7 @@ static int usb_if_uevent(struct device *dev, struct kobj_uevent_env *env)
 
         if (add_uevent_var(env,
                    "MODALIAS=usb:"
-                   "v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02Xic%02Xisc%02Xip%02X",
+                   "v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02Xic%02Xisc%02Xip%02Xin%02X",
                    le16_to_cpu(usb_dev->descriptor.idVendor),
                    le16_to_cpu(usb_dev->descriptor.idProduct),
                    le16_to_cpu(usb_dev->descriptor.bcdDevice),
@@ -1568,7 +1570,8 @@ static int usb_if_uevent(struct device *dev, struct kobj_uevent_env *env)
                    usb_dev->descriptor.bDeviceProtocol,
                    alt->desc.bInterfaceClass,
                    alt->desc.bInterfaceSubClass,
-                   alt->desc.bInterfaceProtocol))
+                   alt->desc.bInterfaceProtocol,
+                   alt->desc.bInterfaceNumber))
                 return -ENOMEM;
 
         return 0;
@@ -1791,14 +1794,15 @@ free_interfaces:
          * installed, so that the xHCI driver can recalculate the U1/U2
          * timeouts.
          */
-        if (usb_disable_lpm(dev)) {
+        if (dev->actconfig && usb_disable_lpm(dev)) {
                 dev_err(&dev->dev, "%s Failed to disable LPM\n.", __func__);
                 mutex_unlock(hcd->bandwidth_mutex);
                 return -ENOMEM;
         }
         ret = usb_hcd_alloc_bandwidth(dev, cp, NULL, NULL);
         if (ret < 0) {
-                usb_enable_lpm(dev);
+                if (dev->actconfig)
+                        usb_enable_lpm(dev);
                 mutex_unlock(hcd->bandwidth_mutex);
                 usb_autosuspend_device(dev);
                 goto free_interfaces;
@@ -1818,7 +1822,7 @@ free_interfaces:
         if (!cp) {
                 usb_set_device_state(dev, USB_STATE_ADDRESS);
                 usb_hcd_alloc_bandwidth(dev, NULL, NULL, NULL);
-                usb_enable_lpm(dev);
+                /* Leave LPM disabled while the device is unconfigured. */
                 mutex_unlock(hcd->bandwidth_mutex);
                 usb_autosuspend_device(dev);
                 goto free_interfaces;
@@ -1876,6 +1880,8 @@ free_interfaces:
 
         /* Now that the interfaces are installed, re-enable LPM. */
         usb_unlocked_enable_lpm(dev);
+        /* Enable LTM if it was turned off by usb_disable_device. */
+        usb_enable_ltm(dev);
 
         /* Now that all the interfaces are set up, register them
          * to trigger binding of drivers to interfaces.  probe()
diff --git a/drivers/usb/core/quirks.c b/drivers/usb/core/quirks.c
index 32d3adc315f5..f15501f4c585 100644
--- a/drivers/usb/core/quirks.c
+++ b/drivers/usb/core/quirks.c
@@ -15,17 +15,22 @@
 #include <linux/usb/quirks.h>
 #include "usb.h"
 
-/* List of quirky USB devices.  Please keep this list ordered by:
+/* Lists of quirky USB devices, split in device quirks and interface quirks.
+ * Device quirks are applied at the very beginning of the enumeration process,
+ * right after reading the device descriptor. They can thus only match on device
+ * information.
+ *
+ * Interface quirks are applied after reading all the configuration descriptors.
+ * They can match on both device and interface information.
+ *
+ * Note that the DELAY_INIT and HONOR_BNUMINTERFACES quirks do not make sense as
+ * interface quirks, as they only influence the enumeration process which is run
+ * before processing the interface quirks.
+ *
+ * Please keep the lists ordered by:
  *      1) Vendor ID
  *      2) Product ID
  *      3) Class ID
- *
- * as we want specific devices to be overridden first, and only after that, any
- * class specific quirks.
- *
- * Right now the logic aborts if it finds a valid device in the table, we might
- * want to change that in the future if it turns out that a whole class of
- * devices is broken...
  */
 static const struct usb_device_id usb_quirk_list[] = {
         /* CBM - Flash disk */
@@ -38,53 +43,23 @@ static const struct usb_device_id usb_quirk_list[] = {
         /* Creative SB Audigy 2 NX */
         { USB_DEVICE(0x041e, 0x3020), .driver_info = USB_QUIRK_RESET_RESUME },
 
-        /* Logitech Webcam C200 */
-        { USB_DEVICE(0x046d, 0x0802), .driver_info = USB_QUIRK_RESET_RESUME },
-
-        /* Logitech Webcam C250 */
-        { USB_DEVICE(0x046d, 0x0804), .driver_info = USB_QUIRK_RESET_RESUME },
-
-        /* Logitech Webcam C300 */
-        { USB_DEVICE(0x046d, 0x0805), .driver_info = USB_QUIRK_RESET_RESUME },
-
-        /* Logitech Webcam B/C500 */
-        { USB_DEVICE(0x046d, 0x0807), .driver_info = USB_QUIRK_RESET_RESUME },
-
-        /* Logitech Webcam C600 */
-        { USB_DEVICE(0x046d, 0x0808), .driver_info = USB_QUIRK_RESET_RESUME },
-
-        /* Logitech Webcam Pro 9000 */
-        { USB_DEVICE(0x046d, 0x0809), .driver_info = USB_QUIRK_RESET_RESUME },
+        /* Logitech Quickcam Fusion */
+        { USB_DEVICE(0x046d, 0x08c1), .driver_info = USB_QUIRK_RESET_RESUME },
 
-        /* Logitech Webcam C905 */
-        { USB_DEVICE(0x046d, 0x080a), .driver_info = USB_QUIRK_RESET_RESUME },
+        /* Logitech Quickcam Orbit MP */
+        { USB_DEVICE(0x046d, 0x08c2), .driver_info = USB_QUIRK_RESET_RESUME },
 
-        /* Logitech Webcam C210 */
-        { USB_DEVICE(0x046d, 0x0819), .driver_info = USB_QUIRK_RESET_RESUME },
+        /* Logitech Quickcam Pro for Notebook */
+        { USB_DEVICE(0x046d, 0x08c3), .driver_info = USB_QUIRK_RESET_RESUME },
 
-        /* Logitech Webcam C260 */
-        { USB_DEVICE(0x046d, 0x081a), .driver_info = USB_QUIRK_RESET_RESUME },
+        /* Logitech Quickcam Pro 5000 */
+        { USB_DEVICE(0x046d, 0x08c5), .driver_info = USB_QUIRK_RESET_RESUME },
 
-        /* Logitech Webcam C310 */
-        { USB_DEVICE(0x046d, 0x081b), .driver_info = USB_QUIRK_RESET_RESUME },
+        /* Logitech Quickcam OEM Dell Notebook */
+        { USB_DEVICE(0x046d, 0x08c6), .driver_info = USB_QUIRK_RESET_RESUME },
 
-        /* Logitech Webcam C910 */
-        { USB_DEVICE(0x046d, 0x0821), .driver_info = USB_QUIRK_RESET_RESUME },
-
-        /* Logitech Webcam C160 */
-        { USB_DEVICE(0x046d, 0x0824), .driver_info = USB_QUIRK_RESET_RESUME },
-
-        /* Logitech Webcam C270 */
-        { USB_DEVICE(0x046d, 0x0825), .driver_info = USB_QUIRK_RESET_RESUME },
-
-        /* Logitech Quickcam Pro 9000 */
-        { USB_DEVICE(0x046d, 0x0990), .driver_info = USB_QUIRK_RESET_RESUME },
-
-        /* Logitech Quickcam E3500 */
-        { USB_DEVICE(0x046d, 0x09a4), .driver_info = USB_QUIRK_RESET_RESUME },
-
-        /* Logitech Quickcam Vision Pro */
-        { USB_DEVICE(0x046d, 0x09a6), .driver_info = USB_QUIRK_RESET_RESUME },
+        /* Logitech Quickcam OEM Cisco VT Camera II */
+        { USB_DEVICE(0x046d, 0x08c7), .driver_info = USB_QUIRK_RESET_RESUME },
 
         /* Logitech Harmony 700-series */
         { USB_DEVICE(0x046d, 0xc122), .driver_info = USB_QUIRK_DELAY_INIT },
@@ -156,16 +131,57 @@ static const struct usb_device_id usb_quirk_list[] = {
         { }  /* terminating entry must be last */
 };
 
-static const struct usb_device_id *find_id(struct usb_device *udev)
+static const struct usb_device_id usb_interface_quirk_list[] = {
+        /* Logitech UVC Cameras */
+        { USB_VENDOR_AND_INTERFACE_INFO(0x046d, USB_CLASS_VIDEO, 1, 0),
+          .driver_info = USB_QUIRK_RESET_RESUME },
+
+        { }  /* terminating entry must be last */
+};
+
+static bool usb_match_any_interface(struct usb_device *udev,
+                                    const struct usb_device_id *id)
 {
-        const struct usb_device_id *id = usb_quirk_list;
+        unsigned int i;
 
-        for (; id->idVendor || id->bDeviceClass || id->bInterfaceClass ||
-                        id->driver_info; id++) {
-                if (usb_match_device(udev, id))
-                        return id;
+        for (i = 0; i < udev->descriptor.bNumConfigurations; ++i) {
+                struct usb_host_config *cfg = &udev->config[i];
+                unsigned int j;
+
+                for (j = 0; j < cfg->desc.bNumInterfaces; ++j) {
+                        struct usb_interface_cache *cache;
+                        struct usb_host_interface *intf;
+
+                        cache = cfg->intf_cache[j];
+                        if (cache->num_altsetting == 0)
+                                continue;
+
+                        intf = &cache->altsetting[0];
+                        if (usb_match_one_id_intf(udev, intf, id))
+                                return true;
+                }
+        }
+
+        return false;
+}
+
+static u32 __usb_detect_quirks(struct usb_device *udev,
+                               const struct usb_device_id *id)
+{
+        u32 quirks = 0;
+
+        for (; id->match_flags; id++) {
+                if (!usb_match_device(udev, id))
+                        continue;
+
+                if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_INFO) &&
+                    !usb_match_any_interface(udev, id))
+                        continue;
+
+                quirks |= (u32)(id->driver_info);
         }
-        return NULL;
+
+        return quirks;
 }
 
 /*
@@ -173,14 +189,10 @@ static const struct usb_device_id *find_id(struct usb_device *udev)
  */
 void usb_detect_quirks(struct usb_device *udev)
 {
-        const struct usb_device_id *id = usb_quirk_list;
-
-        id = find_id(udev);
-        if (id)
-                udev->quirks = (u32)(id->driver_info);
+        udev->quirks = __usb_detect_quirks(udev, usb_quirk_list);
         if (udev->quirks)
                 dev_dbg(&udev->dev, "USB quirks for this device: %x\n",
-                                udev->quirks);
+                        udev->quirks);
 
         /* For the present, all devices default to USB-PERSIST enabled */
 #if 0           /* was: #ifdef CONFIG_PM */
@@ -197,3 +209,16 @@ void usb_detect_quirks(struct usb_device *udev)
                 udev->persist_enabled = 1;
 #endif  /* CONFIG_PM */
 }
+
+void usb_detect_interface_quirks(struct usb_device *udev)
+{
+        u32 quirks;
+
+        quirks = __usb_detect_quirks(udev, usb_interface_quirk_list);
+        if (quirks == 0)
+                return;
+
+        dev_dbg(&udev->dev, "USB interface quirks for this device: %x\n",
+                quirks);
+        udev->quirks |= quirks;
+}
diff --git a/drivers/usb/core/sysfs.c b/drivers/usb/core/sysfs.c
index 9a56e3adf476..682e8256b95d 100644
--- a/drivers/usb/core/sysfs.c
+++ b/drivers/usb/core/sysfs.c
@@ -253,6 +253,15 @@ show_removable(struct device *dev, struct device_attribute *attr, char *buf)
 }
 static DEVICE_ATTR(removable, S_IRUGO, show_removable, NULL);
 
+static ssize_t
+show_ltm_capable(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        if (usb_device_supports_ltm(to_usb_device(dev)))
+                return sprintf(buf, "%s\n", "yes");
+        return sprintf(buf, "%s\n", "no");
+}
+static DEVICE_ATTR(ltm_capable, S_IRUGO, show_ltm_capable, NULL);
+
 #ifdef  CONFIG_PM
 
 static ssize_t
@@ -649,6 +658,7 @@ static struct attribute *dev_attrs[] = {
         &dev_attr_authorized.attr,
         &dev_attr_remove.attr,
         &dev_attr_removable.attr,
+        &dev_attr_ltm_capable.attr,
         NULL,
 };
 static struct attribute_group dev_attr_grp = {
@@ -840,7 +850,7 @@ static ssize_t show_modalias(struct device *dev,
         alt = intf->cur_altsetting;
 
         return sprintf(buf, "usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02X"
-                        "ic%02Xisc%02Xip%02X\n",
+                        "ic%02Xisc%02Xip%02Xin%02X\n",
                         le16_to_cpu(udev->descriptor.idVendor),
                         le16_to_cpu(udev->descriptor.idProduct),
                         le16_to_cpu(udev->descriptor.bcdDevice),
@@ -849,7 +859,8 @@ static ssize_t show_modalias(struct device *dev,
                         udev->descriptor.bDeviceProtocol,
                         alt->desc.bInterfaceClass,
                         alt->desc.bInterfaceSubClass,
-                        alt->desc.bInterfaceProtocol);
+                        alt->desc.bInterfaceProtocol,
+                        alt->desc.bInterfaceNumber);
 }
 static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
 
diff --git a/drivers/usb/core/usb.c b/drivers/usb/core/usb.c
index 25d0c61c3f8a..cd8fb44a3e16 100644
--- a/drivers/usb/core/usb.c
+++ b/drivers/usb/core/usb.c
@@ -396,6 +396,7 @@ struct usb_device *usb_alloc_dev(struct usb_device *parent,
         dev->dev.dma_mask = bus->controller->dma_mask;
         set_dev_node(&dev->dev, dev_to_node(bus->controller));
         dev->state = USB_STATE_ATTACHED;
+        dev->lpm_disable_count = 1;
         atomic_set(&dev->urbnum, 0);
 
         INIT_LIST_HEAD(&dev->ep0.urb_list);
diff --git a/drivers/usb/core/usb.h b/drivers/usb/core/usb.h
index 5c5c538ea73d..acb103c5c391 100644
--- a/drivers/usb/core/usb.h
+++ b/drivers/usb/core/usb.h
@@ -1,5 +1,7 @@
 #include <linux/pm.h>
 
+struct dev_state;
+
 /* Functions local to drivers/usb/core/ */
 
 extern int usb_create_sysfs_dev_files(struct usb_device *dev);
@@ -24,6 +26,7 @@ extern void usb_disable_device(struct usb_device *dev, int skip_ep0);
 extern int usb_deauthorize_device(struct usb_device *);
 extern int usb_authorize_device(struct usb_device *);
 extern void usb_detect_quirks(struct usb_device *udev);
+extern void usb_detect_interface_quirks(struct usb_device *udev);
 extern int usb_remove_device(struct usb_device *udev);
 
 extern int usb_get_device_descriptor(struct usb_device *dev,
@@ -35,16 +38,20 @@ extern int usb_set_configuration(struct usb_device *dev, int configuration);
 extern int usb_choose_configuration(struct usb_device *udev);
 
 extern void usb_kick_khubd(struct usb_device *dev);
+extern int usb_match_one_id_intf(struct usb_device *dev,
+                                 struct usb_host_interface *intf,
+                                 const struct usb_device_id *id);
 extern int usb_match_device(struct usb_device *dev,
                             const struct usb_device_id *id);
 extern void usb_forced_unbind_intf(struct usb_interface *intf);
 extern void usb_rebind_intf(struct usb_interface *intf);
 
 extern int usb_hub_claim_port(struct usb_device *hdev, unsigned port,
-                void *owner);
+                struct dev_state *owner);
 extern int usb_hub_release_port(struct usb_device *hdev, unsigned port,
-                void *owner);
-extern void usb_hub_release_all_ports(struct usb_device *hdev, void *owner);
+                struct dev_state *owner);
+extern void usb_hub_release_all_ports(struct usb_device *hdev,
+                struct dev_state *owner);
 extern bool usb_device_is_owned(struct usb_device *udev);
 
 extern int  usb_hub_init(void);