usbcore: add autosuspend/autoresume infrastructure

This patch (as739) adds the basic infrastructure for USB autosuspend
and autoresume.  The main features are:

	PM usage counters added to struct usb_device and struct
	usb_interface, indicating whether it's okay to autosuspend
	them or they are currently in use.

	Flag added to usb_device indicating whether the current
	suspend/resume operation originated from outside or as an
	autosuspend/autoresume.

	Flag added to usb_driver indicating whether the driver
	supports autosuspend.  If not, no device bound to the driver
	will be autosuspended.

	Mutex added to usb_device for protecting PM operations.
	Unlike the device semaphore, the locking rule for the pm_mutex
	is that you must acquire the locks going _up_ the device tree.

	New routines handling autosuspend/autoresume requests for
	interfaces and devices.

	Suspend and resume requests are propagated up the device tree
	(but not outside the USB subsystem).

	work_struct added to usb_device, for carrying out delayed
	autosuspend requests.

	Autoresume added (and autosuspend prevented) during probe and
	disconnect.

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

5 files changed, 493 insertions, 45 deletions

diff --git a/drivers/usb/core/driver.c b/drivers/usb/core/driver.c
index a5d11461f5a9..2b2000ac05ab 100644
--- a/drivers/usb/core/driver.c
+++ b/drivers/usb/core/driver.c
@@ -157,12 +157,13 @@ static int usb_probe_device(struct device *dev)
 
         udev = to_usb_device(dev);
 
-        /* FIXME: resume a suspended device */
-        if (udev->state == USB_STATE_SUSPENDED)
-                return -EHOSTUNREACH;
-
         /* TODO: Add real matching code */
 
+        /* The device should always appear to be in use
+         * unless the driver suports autosuspend.
+         */
+        udev->pm_usage_cnt = !(udriver->supports_autosuspend);
+
         error = udriver->probe(udev);
         return error;
 }
@@ -182,6 +183,7 @@ static int usb_probe_interface(struct device *dev)
 {
         struct usb_driver *driver = to_usb_driver(dev->driver);
         struct usb_interface *intf;
+        struct usb_device *udev;
         const struct usb_device_id *id;
         int error = -ENODEV;
 
@@ -191,10 +193,7 @@ static int usb_probe_interface(struct device *dev)
                 return error;
 
         intf = to_usb_interface(dev);
-
-        /* FIXME we'd much prefer to just resume it ... */
-        if (interface_to_usbdev(intf)->state == USB_STATE_SUSPENDED)
-                return -EHOSTUNREACH;
+        udev = interface_to_usbdev(intf);
 
         id = usb_match_id(intf, driver->id_table);
         if (!id)
@@ -202,18 +201,31 @@ static int usb_probe_interface(struct device *dev)
         if (id) {
                 dev_dbg(dev, "%s - got id\n", __FUNCTION__);
 
+                error = usb_autoresume_device(udev, 1);
+                if (error)
+                        return error;
+
                 /* Interface "power state" doesn't correspond to any hardware
                  * state whatsoever.  We use it to record when it's bound to
                  * a driver that may start I/0:  it's not frozen/quiesced.
                  */
                 mark_active(intf);
                 intf->condition = USB_INTERFACE_BINDING;
+
+                /* The interface should always appear to be in use
+                 * unless the driver suports autosuspend.
+                 */
+                intf->pm_usage_cnt = !(driver->supports_autosuspend);
+
                 error = driver->probe(intf, id);
                 if (error) {
                         mark_quiesced(intf);
+                        intf->needs_remote_wakeup = 0;
                         intf->condition = USB_INTERFACE_UNBOUND;
                 } else
                         intf->condition = USB_INTERFACE_BOUND;
+
+                usb_autosuspend_device(udev, 1);
         }
 
         return error;
@@ -224,9 +236,15 @@ static int usb_unbind_interface(struct device *dev)
 {
         struct usb_driver *driver = to_usb_driver(dev->driver);
         struct usb_interface *intf = to_usb_interface(dev);
+        struct usb_device *udev;
+        int error;
 
         intf->condition = USB_INTERFACE_UNBINDING;
 
+        /* Autoresume for set_interface call below */
+        udev = interface_to_usbdev(intf);
+        error = usb_autoresume_device(udev, 1);
+
         /* release all urbs for this interface */
         usb_disable_interface(interface_to_usbdev(intf), intf);
 
@@ -237,8 +255,13 @@ static int usb_unbind_interface(struct device *dev)
                         intf->altsetting[0].desc.bInterfaceNumber,
                         0);
         usb_set_intfdata(intf, NULL);
+
         intf->condition = USB_INTERFACE_UNBOUND;
         mark_quiesced(intf);
+        intf->needs_remote_wakeup = 0;
+
+        if (!error)
+                usb_autosuspend_device(udev, 1);
 
         return 0;
 }
@@ -267,14 +290,19 @@ int usb_driver_claim_interface(struct usb_driver *driver,
                                 struct usb_interface *iface, void* priv)
 {
         struct device *dev = &iface->dev;
+        struct usb_device *udev = interface_to_usbdev(iface);
 
         if (dev->driver)
                 return -EBUSY;
 
         dev->driver = &driver->drvwrap.driver;
         usb_set_intfdata(iface, priv);
+
+        mutex_lock_nested(&udev->pm_mutex, udev->level);
         iface->condition = USB_INTERFACE_BOUND;
         mark_active(iface);
+        iface->pm_usage_cnt = !(driver->supports_autosuspend);
+        mutex_unlock(&udev->pm_mutex);
 
         /* if interface was already added, bind now; else let
          * the future device_add() bind it, bypassing probe()
@@ -304,6 +332,7 @@ void usb_driver_release_interface(struct usb_driver *driver,
                                         struct usb_interface *iface)
 {
         struct device *dev = &iface->dev;
+        struct usb_device *udev = interface_to_usbdev(iface);
 
         /* this should never happen, don't release something that's not ours */
         if (!dev->driver || dev->driver != &driver->drvwrap.driver)
@@ -321,8 +350,12 @@ void usb_driver_release_interface(struct usb_driver *driver,
 
         dev->driver = NULL;
         usb_set_intfdata(iface, NULL);
+
+        mutex_lock_nested(&udev->pm_mutex, udev->level);
         iface->condition = USB_INTERFACE_UNBOUND;
         mark_quiesced(iface);
+        iface->needs_remote_wakeup = 0;
+        mutex_unlock(&udev->pm_mutex);
 }
 EXPORT_SYMBOL(usb_driver_release_interface);
 
@@ -751,7 +784,7 @@ EXPORT_SYMBOL_GPL_FUTURE(usb_deregister);
 
 #ifdef CONFIG_PM
 
-/* Caller has locked udev */
+/* Caller has locked udev->pm_mutex */
 static int suspend_device(struct usb_device *udev, pm_message_t msg)
 {
         struct usb_device_driver        *udriver;
@@ -763,6 +796,7 @@ static int suspend_device(struct usb_device *udev, pm_message_t msg)
 
         /* For devices that don't have a driver, we do a standard suspend. */
         if (udev->dev.driver == NULL) {
+                udev->do_remote_wakeup = 0;
                 status = usb_port_suspend(udev);
                 goto done;
         }
@@ -771,12 +805,13 @@ static int suspend_device(struct usb_device *udev, pm_message_t msg)
         status = udriver->suspend(udev, msg);
 
 done:
+        // dev_dbg(&udev->dev, "%s: status %d\n", __FUNCTION__, status);
         if (status == 0)
                 udev->dev.power.power_state.event = msg.event;
         return status;
 }
 
-/* Caller has locked udev */
+/* Caller has locked udev->pm_mutex */
 static int resume_device(struct usb_device *udev)
 {
         struct usb_device_driver        *udriver;
@@ -796,12 +831,13 @@ static int resume_device(struct usb_device *udev)
         status = udriver->resume(udev);
 
 done:
+        // dev_dbg(&udev->dev, "%s: status %d\n", __FUNCTION__, status);
         if (status == 0)
                 udev->dev.power.power_state.event = PM_EVENT_ON;
         return status;
 }
 
-/* Caller has locked intf's usb_device */
+/* Caller has locked intf's usb_device's pm_mutex */
 static int suspend_interface(struct usb_interface *intf, pm_message_t msg)
 {
         struct usb_driver       *driver;
@@ -812,31 +848,33 @@ static int suspend_interface(struct usb_interface *intf, pm_message_t msg)
                         !is_active(intf))
                 goto done;
 
-        if (intf->dev.driver == NULL)           /* This can't happen */
+        if (intf->condition == USB_INTERFACE_UNBOUND)   /* This can't happen */
                 goto done;
         driver = to_usb_driver(intf->dev.driver);
 
         if (driver->suspend && driver->resume) {
                 status = driver->suspend(intf, msg);
-                if (status)
+                if (status == 0)
+                        mark_quiesced(intf);
+                else if (!interface_to_usbdev(intf)->auto_pm)
                         dev_err(&intf->dev, "%s error %d\n",
                                         "suspend", status);
-                else
-                        mark_quiesced(intf);
         } else {
                 // FIXME else if there's no suspend method, disconnect...
+                // Not possible if auto_pm is set...
                 dev_warn(&intf->dev, "no suspend for driver %s?\n",
                                 driver->name);
                 mark_quiesced(intf);
         }
 
 done:
+        // dev_dbg(&intf->dev, "%s: status %d\n", __FUNCTION__, status);
         if (status == 0)
                 intf->dev.power.power_state.event = msg.event;
         return status;
 }
 
-/* Caller has locked intf's usb_device */
+/* Caller has locked intf's usb_device's pm_mutex */
 static int resume_interface(struct usb_interface *intf)
 {
         struct usb_driver       *driver;
@@ -846,8 +884,12 @@ static int resume_interface(struct usb_interface *intf)
                         is_active(intf))
                 goto done;
 
+        /* Don't let autoresume interfere with unbinding */
+        if (intf->condition == USB_INTERFACE_UNBINDING)
+                goto done;
+
         /* Can't resume it if it doesn't have a driver. */
-        if (intf->dev.driver == NULL) {
+        if (intf->condition == USB_INTERFACE_UNBOUND) {
                 status = -ENOTCONN;
                 goto done;
         }
@@ -867,18 +909,88 @@ static int resume_interface(struct usb_interface *intf)
         }
 
 done:
+        // dev_dbg(&intf->dev, "%s: status %d\n", __FUNCTION__, status);
         if (status == 0)
                 intf->dev.power.power_state.event = PM_EVENT_ON;
         return status;
 }
 
-/* Caller has locked udev */
+/**
+ * usb_suspend_both - suspend a USB device and its interfaces
+ * @udev: the usb_device to suspend
+ * @msg: Power Management message describing this state transition
+ *
+ * This is the central routine for suspending USB devices.  It calls the
+ * suspend methods for all the interface drivers in @udev and then calls
+ * the suspend method for @udev itself.  If an error occurs at any stage,
+ * all the interfaces which were suspended are resumed so that they remain
+ * in the same state as the device.
+ *
+ * If an autosuspend is in progress (@udev->auto_pm is set), the routine
+ * checks first to make sure that neither the device itself or any of its
+ * active interfaces is in use (pm_usage_cnt is greater than 0).  If they
+ * are, the autosuspend fails.
+ *
+ * If the suspend succeeds, the routine recursively queues an autosuspend
+ * request for @udev's parent device, thereby propagating the change up
+ * the device tree.  If all of the parent's children are now suspended,
+ * the parent will autosuspend in turn.
+ *
+ * The suspend method calls are subject to mutual exclusion under control
+ * of @udev's pm_mutex.  Many of these calls are also under the protection
+ * of @udev's device lock (including all requests originating outside the
+ * USB subsystem), but autosuspend requests generated by a child device or
+ * interface driver may not be.  Usbcore will insure that the method calls
+ * do not arrive during bind, unbind, or reset operations.  However, drivers
+ * must be prepared to handle suspend calls arriving at unpredictable times.
+ * The only way to block such calls is to do an autoresume (preventing
+ * autosuspends) while holding @udev's device lock (preventing outside
+ * suspends).
+ *
+ * The caller must hold @udev->pm_mutex.
+ *
+ * This routine can run only in process context.
+ */
 int usb_suspend_both(struct usb_device *udev, pm_message_t msg)
 {
         int                     status = 0;
         int                     i = 0;
         struct usb_interface    *intf;
+        struct usb_device       *parent = udev->parent;
+
+        cancel_delayed_work(&udev->autosuspend);
+        if (udev->state == USB_STATE_NOTATTACHED)
+                return 0;
+        if (udev->state == USB_STATE_SUSPENDED)
+                return 0;
 
+        udev->do_remote_wakeup = device_may_wakeup(&udev->dev);
+
+        /* For autosuspend, fail fast if anything is in use.
+         * Also fail if any interfaces require remote wakeup but it
+         * isn't available. */
+        if (udev->auto_pm) {
+                if (udev->pm_usage_cnt > 0)
+                        return -EBUSY;
+                if (udev->actconfig) {
+                        for (; i < udev->actconfig->desc.bNumInterfaces; i++) {
+                                intf = udev->actconfig->interface[i];
+                                if (!is_active(intf))
+                                        continue;
+                                if (intf->pm_usage_cnt > 0)
+                                        return -EBUSY;
+                                if (intf->needs_remote_wakeup &&
+                                                !udev->do_remote_wakeup) {
+                                        dev_dbg(&udev->dev,
+        "remote wakeup needed for autosuspend\n");
+                                        return -EOPNOTSUPP;
+                                }
+                        }
+                        i = 0;
+                }
+        }
+
+        /* Suspend all the interfaces and then udev itself */
         if (udev->actconfig) {
                 for (; i < udev->actconfig->desc.bNumInterfaces; i++) {
                         intf = udev->actconfig->interface[i];
@@ -896,40 +1008,282 @@ int usb_suspend_both(struct usb_device *udev, pm_message_t msg)
                         intf = udev->actconfig->interface[i];
                         resume_interface(intf);
                 }
-        }
+
+        /* If the suspend succeeded, propagate it up the tree */
+        } else if (parent)
+                usb_autosuspend_device(parent, 0);
+
+        // dev_dbg(&udev->dev, "%s: status %d\n", __FUNCTION__, status);
         return status;
 }
 
-/* Caller has locked udev */
+/**
+ * usb_resume_both - resume a USB device and its interfaces
+ * @udev: the usb_device to resume
+ *
+ * This is the central routine for resuming USB devices.  It calls the
+ * the resume method for @udev and then calls the resume methods for all
+ * the interface drivers in @udev.
+ *
+ * Before starting the resume, the routine calls itself recursively for
+ * the parent device of @udev, thereby propagating the change up the device
+ * tree and assuring that @udev will be able to resume.  If the parent is
+ * unable to resume successfully, the routine fails.
+ *
+ * The resume method calls are subject to mutual exclusion under control
+ * of @udev's pm_mutex.  Many of these calls are also under the protection
+ * of @udev's device lock (including all requests originating outside the
+ * USB subsystem), but autoresume requests generated by a child device or
+ * interface driver may not be.  Usbcore will insure that the method calls
+ * do not arrive during bind, unbind, or reset operations.  However, drivers
+ * must be prepared to handle resume calls arriving at unpredictable times.
+ * The only way to block such calls is to do an autoresume (preventing
+ * other autoresumes) while holding @udev's device lock (preventing outside
+ * resumes).
+ *
+ * The caller must hold @udev->pm_mutex.
+ *
+ * This routine can run only in process context.
+ */
 int usb_resume_both(struct usb_device *udev)
 {
-        int                     status;
+        int                     status = 0;
         int                     i;
         struct usb_interface    *intf;
+        struct usb_device       *parent = udev->parent;
+
+        cancel_delayed_work(&udev->autosuspend);
+        if (udev->state == USB_STATE_NOTATTACHED)
+                return -ENODEV;
 
-        /* Can't resume if the parent is suspended */
-        if (udev->parent && udev->parent->state == USB_STATE_SUSPENDED) {
-                dev_warn(&udev->dev, "can't resume; parent is suspended\n");
-                return -EHOSTUNREACH;
+        /* Propagate the resume up the tree, if necessary */
+        if (udev->state == USB_STATE_SUSPENDED) {
+                if (parent) {
+                        mutex_lock_nested(&parent->pm_mutex, parent->level);
+                        parent->auto_pm = 1;
+                        status = usb_resume_both(parent);
+                } else {
+
+                        /* We can't progagate beyond the USB subsystem,
+                         * so if a root hub's controller is suspended
+                         * then we're stuck. */
+                        if (udev->dev.parent->power.power_state.event !=
+                                        PM_EVENT_ON)
+                                status = -EHOSTUNREACH;
+                }
+                if (status == 0 && udev->state == USB_STATE_SUSPENDED)
+                        status = resume_device(udev);
+                if (parent)
+                        mutex_unlock(&parent->pm_mutex);
         }
 
-        status = resume_device(udev);
+        /* Now the parent won't suspend until we are finished */
+
         if (status == 0 && udev->actconfig) {
                 for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
                         intf = udev->actconfig->interface[i];
                         resume_interface(intf);
                 }
         }
+
+        // dev_dbg(&udev->dev, "%s: status %d\n", __FUNCTION__, status);
+        return status;
+}
+
+#ifdef CONFIG_USB_SUSPEND
+
+/**
+ * usb_autosuspend_device - delayed autosuspend of a USB device and its interfaces
+ * @udev - the usb_device to autosuspend
+ * @dec_usage_cnt - flag to decrement @udev's PM-usage counter
+ *
+ * This routine should be called when a core subsystem is finished using
+ * @udev and wants to allow it to autosuspend.  Examples would be when
+ * @udev's device file in usbfs is closed or after a configuration change.
+ *
+ * @dec_usage_cnt should be 1 if the subsystem previously incremented
+ * @udev's usage counter (such as by passing 1 to usb_autoresume_device);
+ * otherwise it should be 0.
+ *
+ * If the usage counter for @udev or any of its active interfaces is greater
+ * than 0, the autosuspend request will not be queued.  (If an interface
+ * driver does not support autosuspend then its usage counter is permanently
+ * positive.)  Likewise, if an interface driver requires remote-wakeup
+ * capability during autosuspend but remote wakeup is disabled, the
+ * autosuspend will fail.
+ *
+ * Often the caller will hold @udev's device lock, but this is not
+ * necessary.
+ *
+ * This routine can run only in process context.
+ */
+void usb_autosuspend_device(struct usb_device *udev, int dec_usage_cnt)
+{
+        mutex_lock_nested(&udev->pm_mutex, udev->level);
+        udev->pm_usage_cnt -= dec_usage_cnt;
+        if (udev->pm_usage_cnt <= 0)
+                schedule_delayed_work(&udev->autosuspend,
+                                USB_AUTOSUSPEND_DELAY);
+        mutex_unlock(&udev->pm_mutex);
+        // dev_dbg(&udev->dev, "%s: cnt %d\n",
+        //              __FUNCTION__, udev->pm_usage_cnt);
+}
+
+/**
+ * usb_autoresume_device - immediately autoresume a USB device and its interfaces
+ * @udev - the usb_device to autoresume
+ * @inc_usage_cnt - flag to increment @udev's PM-usage counter
+ *
+ * This routine should be called when a core subsystem wants to use @udev
+ * and needs to guarantee that it is not suspended.  In addition, the
+ * caller can prevent @udev from being autosuspended subsequently.  (Note
+ * that this will not prevent suspend events originating in the PM core.)
+ * Examples would be when @udev's device file in usbfs is opened (autosuspend
+ * should be prevented until the file is closed) or when a remote-wakeup
+ * request is received (later autosuspends should not be prevented).
+ *
+ * @inc_usage_cnt should be 1 to increment @udev's usage counter and prevent
+ * autosuspends.  This prevention will persist until the usage counter is
+ * decremented again (such as by passing 1 to usb_autosuspend_device).
+ * Otherwise @inc_usage_cnt should be 0 to leave the usage counter unchanged.
+ * Regardless, if the autoresume fails then the usage counter is not
+ * incremented.
+ *
+ * Often the caller will hold @udev's device lock, but this is not
+ * necessary (and attempting it might cause deadlock).
+ *
+ * This routine can run only in process context.
+ */
+int usb_autoresume_device(struct usb_device *udev, int inc_usage_cnt)
+{
+        int     status;
+
+        mutex_lock_nested(&udev->pm_mutex, udev->level);
+        udev->pm_usage_cnt += inc_usage_cnt;
+        udev->auto_pm = 1;
+        status = usb_resume_both(udev);
+        if (status != 0)
+                udev->pm_usage_cnt -= inc_usage_cnt;
+        mutex_unlock(&udev->pm_mutex);
+        // dev_dbg(&udev->dev, "%s: status %d cnt %d\n",
+        //              __FUNCTION__, status, udev->pm_usage_cnt);
+        return status;
+}
+
+/**
+ * usb_autopm_put_interface - decrement a USB interface's PM-usage counter
+ * @intf - the usb_interface whose counter should be decremented
+ *
+ * This routine should be called by an interface driver when it is
+ * finished using @intf and wants to allow it to autosuspend.  A typical
+ * example would be a character-device driver when its device file is
+ * closed.
+ *
+ * The routine decrements @intf's usage counter.  When the counter reaches
+ * 0, a delayed autosuspend request for @intf's device is queued.  When
+ * the delay expires, if @intf->pm_usage_cnt is still <= 0 along with all
+ * the other usage counters for the sibling interfaces and @intf's
+ * usb_device, the device and all its interfaces will be autosuspended.
+ *
+ * Note that @intf->pm_usage_cnt is owned by the interface driver.  The
+ * core will not change its value other than the increment and decrement
+ * in usb_autopm_get_interface and usb_autopm_put_interface.  The driver
+ * may use this simple counter-oriented discipline or may set the value
+ * any way it likes.
+ *
+ * If the driver has set @intf->needs_remote_wakeup then autosuspend will
+ * take place only if the device's remote-wakeup facility is enabled.
+ *
+ * Suspend method calls queued by this routine can arrive at any time
+ * while @intf is resumed and its usage counter is equal to 0.  They are
+ * not protected by the usb_device's lock but only by its pm_mutex.
+ * Drivers must provide their own synchronization.
+ *
+ * This routine can run only in process context.
+ */
+void usb_autopm_put_interface(struct usb_interface *intf)
+{
+        struct usb_device       *udev = interface_to_usbdev(intf);
+
+        mutex_lock_nested(&udev->pm_mutex, udev->level);
+        if (intf->condition != USB_INTERFACE_UNBOUND) {
+                if (--intf->pm_usage_cnt <= 0)
+                        schedule_delayed_work(&udev->autosuspend,
+                                        USB_AUTOSUSPEND_DELAY);
+        }
+        mutex_unlock(&udev->pm_mutex);
+        // dev_dbg(&intf->dev, "%s: cnt %d\n",
+        //              __FUNCTION__, intf->pm_usage_cnt);
+}
+EXPORT_SYMBOL_GPL(usb_autopm_put_interface);
+
+/**
+ * usb_autopm_get_interface - increment a USB interface's PM-usage counter
+ * @intf - the usb_interface whose counter should be incremented
+ *
+ * This routine should be called by an interface driver when it wants to
+ * use @intf and needs to guarantee that it is not suspended.  In addition,
+ * the routine prevents @intf from being autosuspended subsequently.  (Note
+ * that this will not prevent suspend events originating in the PM core.)
+ * This prevention will persist until usb_autopm_put_interface() is called
+ * or @intf is unbound.  A typical example would be a character-device
+ * driver when its device file is opened.
+ *
+ * The routine increments @intf's usage counter.  So long as the counter
+ * is greater than 0, autosuspend will not be allowed for @intf or its
+ * usb_device.  When the driver is finished using @intf it should call
+ * usb_autopm_put_interface() to decrement the usage counter and queue
+ * a delayed autosuspend request (if the counter is <= 0).
+ *
+ * Note that @intf->pm_usage_cnt is owned by the interface driver.  The
+ * core will not change its value other than the increment and decrement
+ * in usb_autopm_get_interface and usb_autopm_put_interface.  The driver
+ * may use this simple counter-oriented discipline or may set the value
+ * any way it likes.
+ *
+ * Resume method calls generated by this routine can arrive at any time
+ * while @intf is suspended.  They are not protected by the usb_device's
+ * lock but only by its pm_mutex.  Drivers must provide their own
+ * synchronization.
+ *
+ * This routine can run only in process context.
+ */
+int usb_autopm_get_interface(struct usb_interface *intf)
+{
+        struct usb_device       *udev = interface_to_usbdev(intf);
+        int                     status;
+
+        mutex_lock_nested(&udev->pm_mutex, udev->level);
+        if (intf->condition == USB_INTERFACE_UNBOUND)
+                status = -ENODEV;
+        else {
+                ++intf->pm_usage_cnt;
+                udev->auto_pm = 1;
+                status = usb_resume_both(udev);
+                if (status != 0)
+                        --intf->pm_usage_cnt;
+        }
+        mutex_unlock(&udev->pm_mutex);
+        // dev_dbg(&intf->dev, "%s: status %d cnt %d\n",
+        //              __FUNCTION__, status, intf->pm_usage_cnt);
         return status;
 }
+EXPORT_SYMBOL_GPL(usb_autopm_get_interface);
+
+#endif /* CONFIG_USB_SUSPEND */
 
 static int usb_suspend(struct device *dev, pm_message_t message)
 {
         int     status;
 
-        if (is_usb_device(dev))
-                status = usb_suspend_both(to_usb_device(dev), message);
-        else
+        if (is_usb_device(dev)) {
+                struct usb_device *udev = to_usb_device(dev);
+
+                mutex_lock_nested(&udev->pm_mutex, udev->level);
+                udev->auto_pm = 0;
+                status = usb_suspend_both(udev, message);
+                mutex_unlock(&udev->pm_mutex);
+        } else
                 status = 0;
         return status;
 }
@@ -939,7 +1293,12 @@ static int usb_resume(struct device *dev)
         int     status;
 
         if (is_usb_device(dev)) {
-                status = usb_resume_both(to_usb_device(dev));
+                struct usb_device *udev = to_usb_device(dev);
+
+                mutex_lock_nested(&udev->pm_mutex, udev->level);
+                udev->auto_pm = 0;
+                status = usb_resume_both(udev);
+                mutex_unlock(&udev->pm_mutex);
 
                 /* Rebind drivers that had no suspend method? */
         } else
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index 78e910b2046c..dee812bc6c43 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -1017,19 +1017,22 @@ void usb_set_device_state(struct usb_device *udev,
         if (udev->state == USB_STATE_NOTATTACHED)
                 ;       /* do nothing */
         else if (new_state != USB_STATE_NOTATTACHED) {
-                udev->state = new_state;
 
                 /* root hub wakeup capabilities are managed out-of-band
                  * and may involve silicon errata ... ignore them here.
                  */
                 if (udev->parent) {
-                        if (new_state == USB_STATE_CONFIGURED)
+                        if (udev->state == USB_STATE_SUSPENDED
+                                        || new_state == USB_STATE_SUSPENDED)
+                                ;       /* No change to wakeup settings */
+                        else if (new_state == USB_STATE_CONFIGURED)
                                 device_init_wakeup(&udev->dev,
                                         (udev->actconfig->desc.bmAttributes
                                          & USB_CONFIG_ATT_WAKEUP));
-                        else if (new_state != USB_STATE_SUSPENDED)
+                        else
                                 device_init_wakeup(&udev->dev, 0);
                 }
+                udev->state = new_state;
         } else
                 recursively_mark_NOTATTACHED(udev);
         spin_unlock_irqrestore(&device_state_lock, flags);
@@ -1507,7 +1510,7 @@ static int hub_port_suspend(struct usb_hub *hub, int port1,
          * NOTE:  OTG devices may issue remote wakeup (or SRP) even when
          * we don't explicitly enable it here.
          */
-        if (device_may_wakeup(&udev->dev)) {
+        if (udev->do_remote_wakeup) {
                 status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
                                 USB_REQ_SET_FEATURE, USB_RECIP_DEVICE,
                                 USB_DEVICE_REMOTE_WAKEUP, 0,
@@ -1533,7 +1536,8 @@ static int hub_port_suspend(struct usb_hub *hub, int port1,
                                 USB_CTRL_SET_TIMEOUT);
         } else {
                 /* device has up to 10 msec to fully suspend */
-                dev_dbg(&udev->dev, "usb suspend\n");
+                dev_dbg(&udev->dev, "usb %ssuspend\n",
+                                udev->auto_pm ? "auto-" : "");
                 usb_set_device_state(udev, USB_STATE_SUSPENDED);
                 msleep(10);
         }
@@ -1573,7 +1577,8 @@ static int __usb_port_suspend (struct usb_device *udev, int port1)
                 status = hub_port_suspend(hdev_to_hub(udev->parent), port1,
                                 udev);
         else {
-                dev_dbg(&udev->dev, "usb suspend\n");
+                dev_dbg(&udev->dev, "usb %ssuspend\n",
+                                udev->auto_pm ? "auto-" : "");
                 usb_set_device_state(udev, USB_STATE_SUSPENDED);
         }
         return status;
@@ -1687,7 +1692,8 @@ hub_port_resume(struct usb_hub *hub, int port1, struct usb_device *udev)
 
                 /* drive resume for at least 20 msec */
                 if (udev)
-                        dev_dbg(&udev->dev, "RESUME\n");
+                        dev_dbg(&udev->dev, "usb %sresume\n",
+                                        udev->auto_pm ? "auto-" : "");
                 msleep(25);
 
 #define LIVE_FLAGS      ( USB_PORT_STAT_POWER \
@@ -1754,8 +1760,11 @@ int usb_port_resume(struct usb_device *udev)
                 // NOTE this fails if parent is also suspended...
                 status = hub_port_resume(hdev_to_hub(udev->parent),
                                 udev->portnum, udev);
-        } else
+        } else {
+                dev_dbg(&udev->dev, "usb %sresume\n",
+                                udev->auto_pm ? "auto-" : "");
                 status = finish_port_resume(udev);
+        }
         if (status < 0)
                 dev_dbg(&udev->dev, "can't resume, status %d\n", status);
         return status;
@@ -1765,19 +1774,23 @@ static int remote_wakeup(struct usb_device *udev)
 {
         int     status = 0;
 
-        /* don't repeat RESUME sequence if this device
-         * was already woken up by some other task
-         */
+        /* All this just to avoid sending a port-resume message
+         * to the parent hub! */
+
         usb_lock_device(udev);
+        mutex_lock_nested(&udev->pm_mutex, udev->level);
         if (udev->state == USB_STATE_SUSPENDED) {
-                dev_dbg(&udev->dev, "RESUME (wakeup)\n");
+                dev_dbg(&udev->dev, "usb %sresume\n", "wakeup-");
                 /* TRSMRCY = 10 msec */
                 msleep(10);
                 status = finish_port_resume(udev);
+                if (status == 0)
+                        udev->dev.power.power_state.event = PM_EVENT_ON;
         }
+        mutex_unlock(&udev->pm_mutex);
 
         if (status == 0)
-                usb_resume_both(udev);
+                usb_autoresume_device(udev, 0);
         usb_unlock_device(udev);
         return status;
 }
@@ -1834,7 +1847,9 @@ static int hub_suspend(struct usb_interface *intf, pm_message_t msg)
                                         == PM_EVENT_ON
 #endif
                                 ) {
-                        dev_dbg(&intf->dev, "port %d nyet suspended\n", port1);
+                        if (!hdev->auto_pm)
+                                dev_dbg(&intf->dev, "port %d nyet suspended\n",
+                                                port1);
                         return -EBUSY;
                 }
         }
@@ -2587,7 +2602,7 @@ static void hub_events(void)
                  * stub "device" node was never suspended.
                  */
                 if (i)
-                        usb_resume_both(hdev);
+                        usb_autoresume_device(hdev, 0);
 
                 /* If this is an inactive or suspended hub, do nothing */
                 if (hub->quiescing)
@@ -2993,6 +3008,9 @@ int usb_reset_composite_device(struct usb_device *udev,
                 return -EINVAL;
         }
 
+        /* Prevent autosuspend during the reset */
+        usb_autoresume_device(udev, 1);
+
         if (iface && iface->condition != USB_INTERFACE_BINDING)
                 iface = NULL;
 
@@ -3034,6 +3052,7 @@ int usb_reset_composite_device(struct usb_device *udev,
                 }
         }
 
+        usb_autosuspend_device(udev, 1);
         return ret;
 }
 EXPORT_SYMBOL(usb_reset_composite_device);
diff --git a/drivers/usb/core/usb.c b/drivers/usb/core/usb.c
index b0c0a993338f..6b029cdb8671 100644
--- a/drivers/usb/core/usb.c
+++ b/drivers/usb/core/usb.c
@@ -168,6 +168,10 @@ static void usb_release_dev(struct device *dev)
 
         udev = to_usb_device(dev);
 
+#ifdef  CONFIG_PM
+        cancel_delayed_work(&udev->autosuspend);
+        flush_scheduled_work();
+#endif
         usb_destroy_configuration(udev);
         usb_put_hcd(bus_to_hcd(udev->bus));
         kfree(udev->product);
@@ -176,6 +180,21 @@ static void usb_release_dev(struct device *dev)
         kfree(udev);
 }
 
+#ifdef  CONFIG_PM
+
+/* usb_autosuspend_work - callback routine to autosuspend a USB device */
+static void usb_autosuspend_work(void *_udev)
+{
+        struct usb_device       *udev = _udev;
+
+        mutex_lock_nested(&udev->pm_mutex, udev->level);
+        udev->auto_pm = 1;
+        usb_suspend_both(udev, PMSG_SUSPEND);
+        mutex_unlock(&udev->pm_mutex);
+}
+
+#endif
+
 /**
  * usb_alloc_dev - usb device constructor (usbcore-internal)
  * @parent: hub to which device is connected; null to allocate a root hub
@@ -251,6 +270,10 @@ usb_alloc_dev(struct usb_device *parent, struct usb_bus *bus, unsigned port1)
         dev->parent = parent;
         INIT_LIST_HEAD(&dev->filelist);
 
+#ifdef  CONFIG_PM
+        mutex_init(&dev->pm_mutex);
+        INIT_WORK(&dev->autosuspend, usb_autosuspend_work, dev);
+#endif
         return dev;
 }
 
diff --git a/drivers/usb/core/usb.h b/drivers/usb/core/usb.h
index 5162cb370215..10688ad73c6d 100644
--- a/drivers/usb/core/usb.h
+++ b/drivers/usb/core/usb.h
@@ -49,6 +49,20 @@ static inline int usb_resume_both(struct usb_device *udev)
 
 #endif
 
+#ifdef CONFIG_USB_SUSPEND
+
+#define USB_AUTOSUSPEND_DELAY   (HZ*2)
+
+extern void usb_autosuspend_device(struct usb_device *udev, int dec_busy_cnt);
+extern int usb_autoresume_device(struct usb_device *udev, int inc_busy_cnt);
+
+#else
+
+#define usb_autosuspend_device(udev, dec_busy_cnt)      do {} while (0)
+#define usb_autoresume_device(udev, inc_busy_cnt)       0
+
+#endif
+
 extern struct bus_type usb_bus_type;
 extern struct usb_device_driver usb_generic_driver;
 
diff --git a/include/linux/usb.h b/include/linux/usb.h
index df5c93eb3ce9..0da15b0b02be 100644
--- a/include/linux/usb.h
+++ b/include/linux/usb.h
@@ -19,6 +19,7 @@
 #include <linux/fs.h>           /* for struct file_operations */
 #include <linux/completion.h>   /* for struct completion */
 #include <linux/sched.h>        /* for current && schedule_timeout */
+#include <linux/mutex.h>        /* for struct mutex */
 
 struct usb_device;
 struct usb_driver;
@@ -103,8 +104,12 @@ enum usb_interface_condition {
  * @condition: binding state of the interface: not bound, binding
  *      (in probe()), bound to a driver, or unbinding (in disconnect())
  * @is_active: flag set when the interface is bound and not suspended.
+ * @needs_remote_wakeup: flag set when the driver requires remote-wakeup
+ *      capability during autosuspend.
  * @dev: driver model's view of this device
  * @class_dev: driver model's class view of this device.
+ * @pm_usage_cnt: PM usage counter for this interface; autosuspend is not
+ *      allowed unless the counter is 0.
  *
  * USB device drivers attach to interfaces on a physical device.  Each
  * interface encapsulates a single high level function, such as feeding
@@ -144,9 +149,11 @@ struct usb_interface {
                                          * bound to */
         enum usb_interface_condition condition;         /* state of binding */
         unsigned is_active:1;           /* the interface is not suspended */
+        unsigned needs_remote_wakeup:1; /* driver requires remote wakeup */
 
         struct device dev;              /* interface specific device info */
         struct class_device *class_dev;
+        int pm_usage_cnt;               /* usage counter for autosuspend */
 };
 #define to_usb_interface(d) container_of(d, struct usb_interface, dev)
 #define interface_to_usbdev(intf) \
@@ -372,6 +379,15 @@ struct usb_device {
 
         int maxchild;                   /* Number of ports if hub */
         struct usb_device *children[USB_MAXCHILDREN];
+
+#ifdef CONFIG_PM
+        struct work_struct autosuspend; /* for delayed autosuspends */
+        struct mutex pm_mutex;          /* protects PM operations */
+        int pm_usage_cnt;               /* usage counter for autosuspend */
+
+        unsigned auto_pm:1;             /* autosuspend/resume in progress */
+        unsigned do_remote_wakeup:1;    /* remote wakeup should be enabled */
+#endif
 };
 #define to_usb_device(d) container_of(d, struct usb_device, dev)
 
@@ -392,6 +408,17 @@ extern int usb_reset_composite_device(struct usb_device *dev,
 
 extern struct usb_device *usb_find_device(u16 vendor_id, u16 product_id);
 
+/* USB autosuspend and autoresume */
+#ifdef CONFIG_USB_SUSPEND
+extern int usb_autopm_get_interface(struct usb_interface *intf);
+extern void usb_autopm_put_interface(struct usb_interface *intf);
+
+#else
+#define usb_autopm_get_interface(intf)          0
+#define usb_autopm_put_interface(intf)          do {} while (0)
+#endif
+
+
 /*-------------------------------------------------------------------------*/
 
 /* for drivers using iso endpoints */
@@ -593,6 +620,8 @@ struct usbdrv_wrap {
  * @drvwrap: Driver-model core structure wrapper.
  * @no_dynamic_id: if set to 1, the USB core will not allow dynamic ids to be
  *      added to this driver by preventing the sysfs file from being created.
+ * @supports_autosuspend: if set to 0, the USB core will not allow autosuspend
+ *      for interfaces bound to this driver.
  *
  * USB interface drivers must provide a name, probe() and disconnect()
  * methods, and an id_table.  Other driver fields are optional.
@@ -631,6 +660,7 @@ struct usb_driver {
         struct usb_dynids dynids;
         struct usbdrv_wrap drvwrap;
         unsigned int no_dynamic_id:1;
+        unsigned int supports_autosuspend:1;
 };
 #define to_usb_driver(d) container_of(d, struct usb_driver, drvwrap.driver)
 
@@ -648,6 +678,8 @@ struct usb_driver {
  * @suspend: Called when the device is going to be suspended by the system.
  * @resume: Called when the device is being resumed by the system.
  * @drvwrap: Driver-model core structure wrapper.
+ * @supports_autosuspend: if set to 0, the USB core will not allow autosuspend
+ *      for devices bound to this driver.
  *
  * USB drivers must provide all the fields listed above except drvwrap.
  */
@@ -660,6 +692,7 @@ struct usb_device_driver {
         int (*suspend) (struct usb_device *udev, pm_message_t message);
         int (*resume) (struct usb_device *udev);
         struct usbdrv_wrap drvwrap;
+        unsigned int supports_autosuspend:1;
 };
 #define to_usb_device_driver(d) container_of(d, struct usb_device_driver, \
                 drvwrap.driver)