USB: prepare for changover to Runtime PM framework

This patch (as1303) revises the USB Power Management infrastructure to
make it compatible with the new driver-model Runtime PM framework:

	Drivers are no longer allowed to access intf->pm_usage_cnt
	directly; the PM framework manages its own usage counters.

	usb_autopm_set_interface() is eliminated, because it directly
	sets intf->pm_usage_cnt.

	usb_autopm_enable() and usb_autopm_disable() are eliminated,
	because they call usb_autopm_set_interface().

	usb_autopm_get_interface_no_resume() and
	usb_autopm_put_interface_no_suspend() are added.  They
	correspond to pm_runtime_get_noresume() and
	pm_runtime_put_noidle() in the PM framework.

	The power/level attribute no longer accepts "suspend", only
	"on" and "auto".  The PM framework doesn't allow devices to be
	forced into a suspended mode.

The hub driver contains the only code that violates the new
guidelines.  It is updated to use the new interface routines instead.

Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

3 files changed, 36 insertions, 65 deletions

diff --git a/drivers/usb/core/driver.c b/drivers/usb/core/driver.c
index 8016a296010e..7a05bab73960 100644
--- a/drivers/usb/core/driver.c
+++ b/drivers/usb/core/driver.c
@@ -948,8 +948,6 @@ static int usb_resume_device(struct usb_device *udev, pm_message_t msg)
 
  done:
         dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
-        if (status == 0)
-                udev->autoresume_disabled = 0;
         return status;
 }
 
@@ -1280,11 +1278,6 @@ static int usb_resume_both(struct usb_device *udev, pm_message_t msg)
 
         /* Propagate the resume up the tree, if necessary */
         if (udev->state == USB_STATE_SUSPENDED) {
-                if ((msg.event & PM_EVENT_AUTO) &&
-                                udev->autoresume_disabled) {
-                        status = -EPERM;
-                        goto done;
-                }
                 if (parent) {
                         status = usb_autoresume_device(parent);
                         if (status == 0) {
@@ -1638,8 +1631,6 @@ int usb_autopm_get_interface_async(struct usb_interface *intf)
 
         if (intf->condition == USB_INTERFACE_UNBOUND)
                 status = -ENODEV;
-        else if (udev->autoresume_disabled)
-                status = -EPERM;
         else {
                 atomic_inc(&intf->pm_usage_cnt);
                 if (atomic_read(&intf->pm_usage_cnt) > 0 &&
@@ -1652,28 +1643,6 @@ int usb_autopm_get_interface_async(struct usb_interface *intf)
 }
 EXPORT_SYMBOL_GPL(usb_autopm_get_interface_async);
 
-/**
- * usb_autopm_set_interface - set a USB interface's autosuspend state
- * @intf: the usb_interface whose state should be set
- *
- * This routine sets the autosuspend state of @intf's device according
- * to @intf's usage counter, which the caller must have set previously.
- * If the counter is <= 0, the device is autosuspended (if it isn't
- * already suspended and if nothing else prevents the autosuspend).  If
- * the counter is > 0, the device is autoresumed (if it isn't already
- * awake).
- */
-int usb_autopm_set_interface(struct usb_interface *intf)
-{
-        int     status;
-
-        status = usb_autopm_do_interface(intf, 0);
-        dev_vdbg(&intf->dev, "%s: status %d cnt %d\n",
-                        __func__, status, atomic_read(&intf->pm_usage_cnt));
-        return status;
-}
-EXPORT_SYMBOL_GPL(usb_autopm_set_interface);
-
 #else
 
 void usb_autosuspend_work(struct work_struct *work)
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index 5413d712cae0..b38fd6730e2a 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -71,6 +71,7 @@ struct usb_hub {
 
         unsigned                mA_per_port;    /* current for each child */
 
+        unsigned                init_done:1;
         unsigned                limited_power:1;
         unsigned                quiescing:1;
         unsigned                disconnected:1;
@@ -375,12 +376,13 @@ static void kick_khubd(struct usb_hub *hub)
 {
         unsigned long   flags;
 
-        /* Suppress autosuspend until khubd runs */
-        atomic_set(&to_usb_interface(hub->intfdev)->pm_usage_cnt, 1);
-
         spin_lock_irqsave(&hub_event_lock, flags);
         if (!hub->disconnected && list_empty(&hub->event_list)) {
                 list_add_tail(&hub->event_list, &hub_event_list);
+
+                /* Suppress autosuspend until khubd runs */
+                usb_autopm_get_interface_no_resume(
+                                to_usb_interface(hub->intfdev));
                 wake_up(&khubd_wait);
         }
         spin_unlock_irqrestore(&hub_event_lock, flags);
@@ -665,7 +667,7 @@ int usb_remove_device(struct usb_device *udev)
 }
 
 enum hub_activation_type {
-        HUB_INIT, HUB_INIT2, HUB_INIT3,
+        HUB_INIT, HUB_INIT2, HUB_INIT3,         /* INITs must come first */
         HUB_POST_RESET, HUB_RESUME, HUB_RESET_RESUME,
 };
 
@@ -710,8 +712,8 @@ static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)
                                         msecs_to_jiffies(delay));
 
                         /* Suppress autosuspend until init is done */
-                        atomic_set(&to_usb_interface(hub->intfdev)->
-                                        pm_usage_cnt, 1);
+                        usb_autopm_get_interface_no_resume(
+                                        to_usb_interface(hub->intfdev));
                         return;         /* Continues at init2: below */
                 } else {
                         hub_power_on(hub, true);
@@ -818,6 +820,7 @@ static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)
         }
  init3:
         hub->quiescing = 0;
+        hub->init_done = 1;
 
         status = usb_submit_urb(hub->urb, GFP_NOIO);
         if (status < 0)
@@ -827,6 +830,10 @@ static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)
 
         /* Scan all ports that need attention */
         kick_khubd(hub);
+
+        /* Allow autosuspend if it was suppressed */
+        if (type <= HUB_INIT3)
+                usb_autopm_put_interface_async(to_usb_interface(hub->intfdev));
 }
 
 /* Implement the continuations for the delays above */
@@ -854,6 +861,11 @@ static void hub_quiesce(struct usb_hub *hub, enum hub_quiescing_type type)
         int i;
 
         cancel_delayed_work_sync(&hub->init_work);
+        if (!hub->init_done) {
+                hub->init_done = 1;
+                usb_autopm_put_interface_no_suspend(
+                                to_usb_interface(hub->intfdev));
+        }
 
         /* khubd and related activity won't re-trigger */
         hub->quiescing = 1;
@@ -1176,7 +1188,10 @@ static void hub_disconnect(struct usb_interface *intf)
 
         /* Take the hub off the event list and don't let it be added again */
         spin_lock_irq(&hub_event_lock);
-        list_del_init(&hub->event_list);
+        if (!list_empty(&hub->event_list)) {
+                list_del_init(&hub->event_list);
+                usb_autopm_put_interface_no_suspend(intf);
+        }
         hub->disconnected = 1;
         spin_unlock_irq(&hub_event_lock);
 
@@ -3235,7 +3250,7 @@ static void hub_events(void)
                  * disconnected while waiting for the lock to succeed. */
                 usb_lock_device(hdev);
                 if (unlikely(hub->disconnected))
-                        goto loop;
+                        goto loop2;
 
                 /* If the hub has died, clean up after it */
                 if (hdev->state == USB_STATE_NOTATTACHED) {
@@ -3384,11 +3399,15 @@ static void hub_events(void)
                         }
                 }
 
-loop_autopm:
-                /* Allow autosuspend if we're not going to run again */
-                if (list_empty(&hub->event_list))
-                        usb_autopm_enable(intf);
-loop:
+ loop_autopm:
+                /* Balance the usb_autopm_get_interface() above */
+                usb_autopm_put_interface_no_suspend(intf);
+ loop:
+                /* Balance the usb_autopm_get_interface_no_resume() in
+                 * kick_khubd() and allow autosuspend.
+                 */
+                usb_autopm_put_interface(intf);
+ loop2:
                 usb_unlock_device(hdev);
                 kref_put(&hub->kref, hub_release);
 
diff --git a/drivers/usb/core/sysfs.c b/drivers/usb/core/sysfs.c
index ae763974be25..15477008b631 100644
--- a/drivers/usb/core/sysfs.c
+++ b/drivers/usb/core/sysfs.c
@@ -327,7 +327,6 @@ static DEVICE_ATTR(autosuspend, S_IRUGO | S_IWUSR,
 
 static const char on_string[] = "on";
 static const char auto_string[] = "auto";
-static const char suspend_string[] = "suspend";
 
 static ssize_t
 show_level(struct device *dev, struct device_attribute *attr, char *buf)
@@ -335,13 +334,8 @@ show_level(struct device *dev, struct device_attribute *attr, char *buf)
         struct usb_device *udev = to_usb_device(dev);
         const char *p = auto_string;
 
-        if (udev->state == USB_STATE_SUSPENDED) {
-                if (udev->autoresume_disabled)
-                        p = suspend_string;
-        } else {
-                if (udev->autosuspend_disabled)
-                        p = on_string;
-        }
+        if (udev->state != USB_STATE_SUSPENDED && udev->autosuspend_disabled)
+                p = on_string;
         return sprintf(buf, "%s\n", p);
 }
 
@@ -353,7 +347,7 @@ set_level(struct device *dev, struct device_attribute *attr,
         int len = count;
         char *cp;
         int rc = 0;
-        int old_autosuspend_disabled, old_autoresume_disabled;
+        int old_autosuspend_disabled;
 
         cp = memchr(buf, '\n', count);
         if (cp)
@@ -361,7 +355,6 @@ set_level(struct device *dev, struct device_attribute *attr,
 
         usb_lock_device(udev);
         old_autosuspend_disabled = udev->autosuspend_disabled;
-        old_autoresume_disabled = udev->autoresume_disabled;
 
         /* Setting the flags without calling usb_pm_lock is a subject to
          * races, but who cares...
@@ -369,28 +362,18 @@ set_level(struct device *dev, struct device_attribute *attr,
         if (len == sizeof on_string - 1 &&
                         strncmp(buf, on_string, len) == 0) {
                 udev->autosuspend_disabled = 1;
-                udev->autoresume_disabled = 0;
                 rc = usb_external_resume_device(udev, PMSG_USER_RESUME);
 
         } else if (len == sizeof auto_string - 1 &&
                         strncmp(buf, auto_string, len) == 0) {
                 udev->autosuspend_disabled = 0;
-                udev->autoresume_disabled = 0;
                 rc = usb_external_resume_device(udev, PMSG_USER_RESUME);
 
-        } else if (len == sizeof suspend_string - 1 &&
-                        strncmp(buf, suspend_string, len) == 0) {
-                udev->autosuspend_disabled = 0;
-                udev->autoresume_disabled = 1;
-                rc = usb_external_suspend_device(udev, PMSG_USER_SUSPEND);
-
         } else
                 rc = -EINVAL;
 
-        if (rc) {
+        if (rc)
                 udev->autosuspend_disabled = old_autosuspend_disabled;
-                udev->autoresume_disabled = old_autoresume_disabled;
-        }
         usb_unlock_device(udev);
         return (rc < 0 ? rc : count);
 }