USB: Disable USB 3.0 LPM in critical sections.

There are several places where the USB core needs to disable USB 3.0
Link PM:
 - usb_bind_interface
 - usb_unbind_interface
 - usb_driver_claim_interface
 - usb_port_suspend/usb_port_resume
 - usb_reset_and_verify_device
 - usb_set_interface
 - usb_reset_configuration
 - usb_set_configuration

Use the new LPM disable/enable functions to temporarily disable LPM
around these critical sections.

We need to protect the critical section around binding and unbinding USB
interface drivers.  USB drivers may want to disable hub-initiated USB
3.0 LPM, which will change the value of the U1/U2 timeouts that the xHCI
driver will install.  We need to disable LPM completely until the driver
is bound to the interface, and the driver has a chance to enable
whatever alternate interface setting it needs in its probe routine.
Then re-enable USB3 LPM, and recalculate the U1/U2 timeout values.

We also need to disable LPM in usb_driver_claim_interface,
because drivers like usbfs can bind to an interface through that
function.  Note, there is no way currently for userspace drivers to
disable hub-initiated USB 3.0 LPM.  Revisit this later.

When a driver is unbound, the U1/U2 timeouts may change because we are
unbinding the last driver that needed hub-initiated USB 3.0 LPM to be
disabled.

USB LPM must be disabled when a USB device is going to be suspended.
The USB 3.0 spec does not define a state transition from U1 or U2 into
U3, so we need to bring the device into U0 by disabling LPM before we
can place it into U3.  Therefore, call usb_unlocked_disable_lpm() in
usb_port_suspend(), and call usb_unlocked_enable_lpm() in
usb_port_resume().  If the port suspend fails, make sure to re-enable
LPM by calling usb_unlocked_enable_lpm(), since usb_port_resume() will
not be called on a failed port suspend.

USB 3.0 devices lose their USB 3.0 LPM settings (including whether USB
device-initiated LPM is enabled) across device suspend.  Therefore,
disable LPM before the device will be reset in
usb_reset_and_verify_device(), and re-enable LPM after the reset is
complete and the configuration/alt settings are re-installed.

The calculated U1/U2 timeout values are heavily dependent on what USB
device endpoints are currently enabled.  When any of the enabled
endpoints on the device might change, due to a new configuration, or new
alternate interface setting, we need to first disable USB 3.0 LPM, add
or delete endpoints from the xHCI schedule, install the new interfaces
and alt settings, and then re-enable LPM.  Do this in usb_set_interface,
usb_reset_configuration, and usb_set_configuration.

Basically, there is a call to disable and then enable LPM in all
functions that lock the bandwidth_mutex.  One exception is
usb_disable_device, because the device is disconnecting or otherwise
going away, and we should not care about whether USB 3.0 LPM is enabled.

Signed-off-by: Sarah Sharp <sarah.a.sharp@linux.intel.com>

1 files changed, 38 insertions, 0 deletions

diff --git a/drivers/usb/core/message.c b/drivers/usb/core/message.c
index ca717da3be95..b548cf1dbc62 100644
--- a/drivers/usb/core/message.c
+++ b/drivers/usb/core/message.c
@@ -1308,10 +1308,19 @@ int usb_set_interface(struct usb_device *dev, int interface, int alternate)
          * Remove the current alt setting and add the new alt setting.
          */
         mutex_lock(hcd->bandwidth_mutex);
+        /* Disable LPM, and re-enable it once the new alt setting is installed,
+         * so that the xHCI driver can recalculate the U1/U2 timeouts.
+         */
+        if (usb_disable_lpm(dev)) {
+                dev_err(&iface->dev, "%s Failed to disable LPM\n.", __func__);
+                mutex_unlock(hcd->bandwidth_mutex);
+                return -ENOMEM;
+        }
         ret = usb_hcd_alloc_bandwidth(dev, NULL, iface->cur_altsetting, alt);
         if (ret < 0) {
                 dev_info(&dev->dev, "Not enough bandwidth for altsetting %d\n",
                                 alternate);
+                usb_enable_lpm(dev);
                 mutex_unlock(hcd->bandwidth_mutex);
                 return ret;
         }
@@ -1334,6 +1343,7 @@ int usb_set_interface(struct usb_device *dev, int interface, int alternate)
         } else if (ret < 0) {
                 /* Re-instate the old alt setting */
                 usb_hcd_alloc_bandwidth(dev, NULL, alt, iface->cur_altsetting);
+                usb_enable_lpm(dev);
                 mutex_unlock(hcd->bandwidth_mutex);
                 return ret;
         }
@@ -1354,6 +1364,9 @@ int usb_set_interface(struct usb_device *dev, int interface, int alternate)
 
         iface->cur_altsetting = alt;
 
+        /* Now that the interface is installed, re-enable LPM. */
+        usb_unlocked_enable_lpm(dev);
+
         /* If the interface only has one altsetting and the device didn't
          * accept the request, we attempt to carry out the equivalent action
          * by manually clearing the HALT feature for each endpoint in the
@@ -1437,6 +1450,14 @@ int usb_reset_configuration(struct usb_device *dev)
         config = dev->actconfig;
         retval = 0;
         mutex_lock(hcd->bandwidth_mutex);
+        /* Disable LPM, and re-enable it once the configuration is reset, so
+         * that the xHCI driver can recalculate the U1/U2 timeouts.
+         */
+        if (usb_disable_lpm(dev)) {
+                dev_err(&dev->dev, "%s Failed to disable LPM\n.", __func__);
+                mutex_unlock(hcd->bandwidth_mutex);
+                return -ENOMEM;
+        }
         /* Make sure we have enough bandwidth for each alternate setting 0 */
         for (i = 0; i < config->desc.bNumInterfaces; i++) {
                 struct usb_interface *intf = config->interface[i];
@@ -1465,6 +1486,7 @@ reset_old_alts:
                                 usb_hcd_alloc_bandwidth(dev, NULL,
                                                 alt, intf->cur_altsetting);
                 }
+                usb_enable_lpm(dev);
                 mutex_unlock(hcd->bandwidth_mutex);
                 return retval;
         }
@@ -1502,6 +1524,8 @@ reset_old_alts:
                         create_intf_ep_devs(intf);
                 }
         }
+        /* Now that the interfaces are installed, re-enable LPM. */
+        usb_unlocked_enable_lpm(dev);
         return 0;
 }
 EXPORT_SYMBOL_GPL(usb_reset_configuration);
@@ -1763,8 +1787,18 @@ free_interfaces:
          * this call fails, the device state is unchanged.
          */
         mutex_lock(hcd->bandwidth_mutex);
+        /* Disable LPM, and re-enable it once the new configuration is
+         * installed, so that the xHCI driver can recalculate the U1/U2
+         * timeouts.
+         */
+        if (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);
                 mutex_unlock(hcd->bandwidth_mutex);
                 usb_autosuspend_device(dev);
                 goto free_interfaces;
@@ -1784,6 +1818,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);
                 mutex_unlock(hcd->bandwidth_mutex);
                 usb_autosuspend_device(dev);
                 goto free_interfaces;
@@ -1838,6 +1873,9 @@ free_interfaces:
                         !(dev->quirks & USB_QUIRK_CONFIG_INTF_STRINGS))
                 cp->string = usb_cache_string(dev, cp->desc.iConfiguration);
 
+        /* Now that the interfaces are installed, re-enable LPM. */
+        usb_unlocked_enable_lpm(dev);
+
         /* Now that all the interfaces are set up, register them
          * to trigger binding of drivers to interfaces.  probe()
          * routines may install different altsettings and may