Merge branch 3.13-rc4 into usb-next

7 files changed, 86 insertions, 56 deletions

diff --git a/drivers/usb/core/config.c b/drivers/usb/core/config.c
index a6b2cabe7930..548d1996590f 100644
--- a/drivers/usb/core/config.c
+++ b/drivers/usb/core/config.c
@@ -651,10 +651,6 @@ void usb_destroy_configuration(struct usb_device *dev)
  *
  * hub-only!! ... and only in reset path, or usb_new_device()
  * (used by real hubs and virtual root hubs)
- *
- * NOTE: if this is a WUSB device and is not authorized, we skip the
- *       whole thing. A non-authorized USB device has no
- *       configurations.
  */
 int usb_get_configuration(struct usb_device *dev)
 {
@@ -666,8 +662,6 @@ int usb_get_configuration(struct usb_device *dev)
         struct usb_config_descriptor *desc;
 
         cfgno = 0;
-        if (dev->authorized == 0)       /* Not really an error */
-                goto out_not_authorized;
         result = -ENOMEM;
         if (ncfg > USB_MAXCONFIG) {
                 dev_warn(ddev, "too many configurations: %d, "
@@ -751,7 +745,6 @@ int usb_get_configuration(struct usb_device *dev)
 
 err:
         kfree(desc);
-out_not_authorized:
         dev->descriptor.bNumConfigurations = cfgno;
 err2:
         if (result == -ENOMEM)
diff --git a/drivers/usb/core/driver.c b/drivers/usb/core/driver.c
index 47aade2a5e74..8d989b1d3dc5 100644
--- a/drivers/usb/core/driver.c
+++ b/drivers/usb/core/driver.c
@@ -839,7 +839,7 @@ int usb_register_device_driver(struct usb_device_driver *new_udriver,
                 return -ENODEV;
 
         new_udriver->drvwrap.for_devices = 1;
-        new_udriver->drvwrap.driver.name = (char *) new_udriver->name;
+        new_udriver->drvwrap.driver.name = new_udriver->name;
         new_udriver->drvwrap.driver.bus = &usb_bus_type;
         new_udriver->drvwrap.driver.probe = usb_probe_device;
         new_udriver->drvwrap.driver.remove = usb_unbind_device;
@@ -900,7 +900,7 @@ int usb_register_driver(struct usb_driver *new_driver, struct module *owner,
                 return -ENODEV;
 
         new_driver->drvwrap.for_devices = 0;
-        new_driver->drvwrap.driver.name = (char *) new_driver->name;
+        new_driver->drvwrap.driver.name = new_driver->name;
         new_driver->drvwrap.driver.bus = &usb_bus_type;
         new_driver->drvwrap.driver.probe = usb_probe_interface;
         new_driver->drvwrap.driver.remove = usb_unbind_interface;
diff --git a/drivers/usb/core/hcd-pci.c b/drivers/usb/core/hcd-pci.c
index dfe9d0f22978..d59d99347d54 100644
--- a/drivers/usb/core/hcd-pci.c
+++ b/drivers/usb/core/hcd-pci.c
@@ -282,6 +282,7 @@ int usb_hcd_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
 
         if (retval != 0)
                 goto unmap_registers;
+        device_wakeup_enable(hcd->self.controller);
 
         if (pci_dev_run_wake(dev))
                 pm_runtime_put_noidle(&dev->dev);
diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
index 6bffb8c87bc9..6297c9e50de2 100644
--- a/drivers/usb/core/hcd.c
+++ b/drivers/usb/core/hcd.c
@@ -44,6 +44,7 @@
 
 #include <linux/usb.h>
 #include <linux/usb/hcd.h>
+#include <linux/usb/phy.h>
 
 #include "usb.h"
 
@@ -2588,6 +2589,24 @@ int usb_add_hcd(struct usb_hcd *hcd,
         int retval;
         struct usb_device *rhdev;
 
+        if (IS_ENABLED(CONFIG_USB_PHY) && !hcd->phy) {
+                struct usb_phy *phy = usb_get_phy_dev(hcd->self.controller, 0);
+
+                if (IS_ERR(phy)) {
+                        retval = PTR_ERR(phy);
+                        if (retval == -EPROBE_DEFER)
+                                return retval;
+                } else {
+                        retval = usb_phy_init(phy);
+                        if (retval) {
+                                usb_put_phy(phy);
+                                return retval;
+                        }
+                        hcd->phy = phy;
+                        hcd->remove_phy = 1;
+                }
+        }
+
         dev_info(hcd->self.controller, "%s\n", hcd->product_desc);
 
         /* Keep old behaviour if authorized_default is not in [0, 1]. */
@@ -2603,7 +2622,7 @@ int usb_add_hcd(struct usb_hcd *hcd,
          */
         if ((retval = hcd_buffer_create(hcd)) != 0) {
                 dev_dbg(hcd->self.controller, "pool alloc failed\n");
-                return retval;
+                goto err_remove_phy;
         }
 
         if ((retval = usb_register_bus(&hcd->self)) < 0)
@@ -2693,12 +2712,6 @@ int usb_add_hcd(struct usb_hcd *hcd,
         if (hcd->uses_new_polling && HCD_POLL_RH(hcd))
                 usb_hcd_poll_rh_status(hcd);
 
-        /*
-         * Host controllers don't generate their own wakeup requests;
-         * they only forward requests from the root hub.  Therefore
-         * controllers should always be enabled for remote wakeup.
-         */
-        device_wakeup_enable(hcd->self.controller);
         return retval;
 
 error_create_attr_group:
@@ -2734,6 +2747,12 @@ err_allocate_root_hub:
         usb_deregister_bus(&hcd->self);
 err_register_bus:
         hcd_buffer_destroy(hcd);
+err_remove_phy:
+        if (hcd->remove_phy && hcd->phy) {
+                usb_phy_shutdown(hcd->phy);
+                usb_put_phy(hcd->phy);
+                hcd->phy = NULL;
+        }
         return retval;
 }
 EXPORT_SYMBOL_GPL(usb_add_hcd);
@@ -2806,6 +2825,11 @@ void usb_remove_hcd(struct usb_hcd *hcd)
         usb_put_dev(hcd->self.root_hub);
         usb_deregister_bus(&hcd->self);
         hcd_buffer_destroy(hcd);
+        if (hcd->remove_phy && hcd->phy) {
+                usb_phy_shutdown(hcd->phy);
+                usb_put_phy(hcd->phy);
+                hcd->phy = NULL;
+        }
 }
 EXPORT_SYMBOL_GPL(usb_remove_hcd);
 
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index bd9dc3504b51..162e94dbed53 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -2235,17 +2235,13 @@ static int usb_enumerate_device(struct usb_device *udev)
                         return err;
                 }
         }
-        if (udev->wusb == 1 && udev->authorized == 0) {
-                udev->product = kstrdup("n/a (unauthorized)", GFP_KERNEL);
-                udev->manufacturer = kstrdup("n/a (unauthorized)", GFP_KERNEL);
-                udev->serial = kstrdup("n/a (unauthorized)", GFP_KERNEL);
-        } else {
-                /* read the standard strings and cache them if present */
-                udev->product = usb_cache_string(udev, udev->descriptor.iProduct);
-                udev->manufacturer = usb_cache_string(udev,
-                                                      udev->descriptor.iManufacturer);
-                udev->serial = usb_cache_string(udev, udev->descriptor.iSerialNumber);
-        }
+
+        /* read the standard strings and cache them if present */
+        udev->product = usb_cache_string(udev, udev->descriptor.iProduct);
+        udev->manufacturer = usb_cache_string(udev,
+                                              udev->descriptor.iManufacturer);
+        udev->serial = usb_cache_string(udev, udev->descriptor.iSerialNumber);
+
         err = usb_enumerate_device_otg(udev);
         if (err < 0)
                 return err;
@@ -2427,16 +2423,6 @@ int usb_deauthorize_device(struct usb_device *usb_dev)
         usb_dev->authorized = 0;
         usb_set_configuration(usb_dev, -1);
 
-        kfree(usb_dev->product);
-        usb_dev->product = kstrdup("n/a (unauthorized)", GFP_KERNEL);
-        kfree(usb_dev->manufacturer);
-        usb_dev->manufacturer = kstrdup("n/a (unauthorized)", GFP_KERNEL);
-        kfree(usb_dev->serial);
-        usb_dev->serial = kstrdup("n/a (unauthorized)", GFP_KERNEL);
-
-        usb_destroy_configuration(usb_dev);
-        usb_dev->descriptor.bNumConfigurations = 0;
-
 out_unauthorized:
         usb_unlock_device(usb_dev);
         return 0;
@@ -2464,17 +2450,7 @@ int usb_authorize_device(struct usb_device *usb_dev)
                 goto error_device_descriptor;
         }
 
-        kfree(usb_dev->product);
-        usb_dev->product = NULL;
-        kfree(usb_dev->manufacturer);
-        usb_dev->manufacturer = NULL;
-        kfree(usb_dev->serial);
-        usb_dev->serial = NULL;
-
         usb_dev->authorized = 1;
-        result = usb_enumerate_device(usb_dev);
-        if (result < 0)
-                goto error_enumerate;
         /* Choose and set the configuration.  This registers the interfaces
          * with the driver core and lets interface drivers bind to them.
          */
@@ -2490,7 +2466,6 @@ int usb_authorize_device(struct usb_device *usb_dev)
         }
         dev_info(&usb_dev->dev, "authorized to connect\n");
 
-error_enumerate:
 error_device_descriptor:
         usb_autosuspend_device(usb_dev);
 error_autoresume:
@@ -2523,6 +2498,21 @@ static unsigned hub_is_wusb(struct usb_hub *hub)
 #define HUB_LONG_RESET_TIME     200
 #define HUB_RESET_TIMEOUT       800
 
+/*
+ * "New scheme" enumeration causes an extra state transition to be
+ * exposed to an xhci host and causes USB3 devices to receive control
+ * commands in the default state.  This has been seen to cause
+ * enumeration failures, so disable this enumeration scheme for USB3
+ * devices.
+ */
+static bool use_new_scheme(struct usb_device *udev, int retry)
+{
+        if (udev->speed == USB_SPEED_SUPER)
+                return false;
+
+        return USE_NEW_SCHEME(retry);
+}
+
 static int hub_port_reset(struct usb_hub *hub, int port1,
                         struct usb_device *udev, unsigned int delay, bool warm);
 
@@ -3981,6 +3971,20 @@ static void hub_set_initial_usb2_lpm_policy(struct usb_device *udev)
         }
 }
 
+static int hub_enable_device(struct usb_device *udev)
+{
+        struct usb_hcd *hcd = bus_to_hcd(udev->bus);
+
+        if (!hcd->driver->enable_device)
+                return 0;
+        if (udev->state == USB_STATE_ADDRESS)
+                return 0;
+        if (udev->state != USB_STATE_DEFAULT)
+                return -EINVAL;
+
+        return hcd->driver->enable_device(hcd, udev);
+}
+
 /* Reset device, (re)assign address, get device descriptor.
  * Device connection must be stable, no more debouncing needed.
  * Returns device in USB_STATE_ADDRESS, except on error.
@@ -4093,7 +4097,7 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
          * this area, and this is how Linux has done it for ages.
          * Change it cautiously.
          *
-         * NOTE:  If USE_NEW_SCHEME() is true we will start by issuing
+         * NOTE:  If use_new_scheme() is true we will start by issuing
          * a 64-byte GET_DESCRIPTOR request.  This is what Windows does,
          * so it may help with some non-standards-compliant devices.
          * Otherwise we start with SET_ADDRESS and then try to read the
@@ -4101,10 +4105,17 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
          * value.
          */
         for (i = 0; i < GET_DESCRIPTOR_TRIES; (++i, msleep(100))) {
-                if (USE_NEW_SCHEME(retry_counter) && !(hcd->driver->flags & HCD_USB3)) {
+                bool did_new_scheme = false;
+
+                if (use_new_scheme(udev, retry_counter)) {
                         struct usb_device_descriptor *buf;
                         int r = 0;
 
+                        did_new_scheme = true;
+                        retval = hub_enable_device(udev);
+                        if (retval < 0)
+                                goto fail;
+
 #define GET_DESCRIPTOR_BUFSIZE  64
                         buf = kmalloc(GET_DESCRIPTOR_BUFSIZE, GFP_NOIO);
                         if (!buf) {
@@ -4193,7 +4204,11 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
                          *  - read ep0 maxpacket even for high and low speed,
                          */
                         msleep(10);
-                        if (USE_NEW_SCHEME(retry_counter) && !(hcd->driver->flags & HCD_USB3))
+                        /* use_new_scheme() checks the speed which may have
+                         * changed since the initial look so we cache the result
+                         * in did_new_scheme
+                         */
+                        if (did_new_scheme)
                                 break;
                 }
 
diff --git a/drivers/usb/core/quirks.c b/drivers/usb/core/quirks.c
index 12924dbfdc2c..8f37063c0a49 100644
--- a/drivers/usb/core/quirks.c
+++ b/drivers/usb/core/quirks.c
@@ -98,9 +98,6 @@ static const struct usb_device_id usb_quirk_list[] = {
         /* Alcor Micro Corp. Hub */
         { USB_DEVICE(0x058f, 0x9254), .driver_info = USB_QUIRK_RESET_RESUME },
 
-        /* MicroTouch Systems touchscreen */
-        { USB_DEVICE(0x0596, 0x051e), .driver_info = USB_QUIRK_RESET_RESUME },
-
         /* appletouch */
         { USB_DEVICE(0x05ac, 0x021a), .driver_info = USB_QUIRK_RESET_RESUME },
 
diff --git a/drivers/usb/core/urb.c b/drivers/usb/core/urb.c
index e62208356c89..07c58af6b5c0 100644
--- a/drivers/usb/core/urb.c
+++ b/drivers/usb/core/urb.c
@@ -492,9 +492,9 @@ int usb_submit_urb(struct urb *urb, gfp_t mem_flags)
                 /* too small? */
                 switch (dev->speed) {
                 case USB_SPEED_WIRELESS:
-                        if (urb->interval < 6)
+                        if ((urb->interval < 6)
+                                && (xfertype == USB_ENDPOINT_XFER_INT))
                                 return -EINVAL;
-                        break;
                 default:
                         if (urb->interval <= 0)
                                 return -EINVAL;