USB: add RESET_RESUME device quirk

[linux-2.6] / drivers / usb / core / driver.c

diff --git a/drivers/usb/core/driver.c b/drivers/usb/core/driver.c
index 2619986e53000f95667365157193dd1dec0d3453..02d6db61c940a03623f46add7b10ad4c1a406d93 100644 (file)
--- a/drivers/usb/core/driver.c
+++ b/drivers/usb/core/driver.c
@@ -24,6 +24,7 @@
 
 #include <linux/device.h>
 #include <linux/usb.h>
+#include <linux/usb/quirks.h>
 #include <linux/workqueue.h>
 #include "hcd.h"
 #include "usb.h"
@@ -802,14 +803,13 @@ static int usb_suspend_device(struct usb_device *udev, pm_message_t msg)
                        udev->state == USB_STATE_SUSPENDED)
                goto done;
 
-       /* For devices that don't have a driver, we do a standard suspend. */
-       if (udev->dev.driver == NULL) {
+       /* For devices that don't have a driver, we do a generic suspend. */
+       if (udev->dev.driver)
+               udriver = to_usb_device_driver(udev->dev.driver);
+       else {
                udev->do_remote_wakeup = 0;
-               status = usb_port_suspend(udev);
-               goto done;
+               udriver = &usb_generic_driver;
        }
-
-       udriver = to_usb_device_driver(udev->dev.driver);
        status = udriver->suspend(udev, msg);
 
 done:
@@ -825,8 +825,9 @@ static int usb_resume_device(struct usb_device *udev)
        struct usb_device_driver        *udriver;
        int                             status = 0;
 
-       if (udev->state == USB_STATE_NOTATTACHED ||
-                       udev->state != USB_STATE_SUSPENDED)
+       if (udev->state == USB_STATE_NOTATTACHED)
+               goto done;
+       if (udev->state != USB_STATE_SUSPENDED && !udev->reset_resume)
                goto done;
 
        /* Can't resume it if it doesn't have a driver. */
@@ -835,6 +836,9 @@ static int usb_resume_device(struct usb_device *udev)
                goto done;
        }
 
+       if (udev->quirks & USB_QUIRK_RESET_RESUME)
+               udev->reset_resume = 1;
+
        udriver = to_usb_device_driver(udev->dev.driver);
        status = udriver->resume(udev);
 
@@ -879,13 +883,11 @@ static int usb_suspend_interface(struct usb_interface *intf, pm_message_t msg)
 
 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's pm_mutex */
-static int usb_resume_interface(struct usb_interface *intf)
+static int usb_resume_interface(struct usb_interface *intf, int reset_resume)
 {
        struct usb_driver       *driver;
        int                     status = 0;
@@ -905,23 +907,21 @@ static int usb_resume_interface(struct usb_interface *intf)
        }
        driver = to_usb_driver(intf->dev.driver);
 
-       if (driver->resume) {
+       if (reset_resume && driver->post_reset)
+               driver->post_reset(intf, reset_resume);
+       else if (driver->resume) {
                status = driver->resume(intf);
                if (status)
                        dev_err(&intf->dev, "%s error %d\n",
                                        "resume", status);
-               else
-                       mark_active(intf);
-       } else {
+       } else
                dev_warn(&intf->dev, "no resume for driver %s?\n",
                                driver->name);
-               mark_active(intf);
-       }
 
 done:
        // dev_dbg(&intf->dev, "%s: status %d\n", __FUNCTION__, status);
        if (status == 0)
-               intf->dev.power.power_state.event = PM_EVENT_ON;
+               mark_active(intf);
        return status;
 }
 
@@ -1054,14 +1054,21 @@ static int usb_suspend_both(struct usb_device *udev, pm_message_t msg)
                                break;
                }
        }
-       if (status == 0)
+       if (status == 0) {
+
+               /* Non-root devices don't need to do anything for FREEZE
+                * or PRETHAW. */
+               if (udev->parent && (msg.event == PM_EVENT_FREEZE ||
+                               msg.event == PM_EVENT_PRETHAW))
+                       goto done;
                status = usb_suspend_device(udev, msg);
+       }
 
        /* If the suspend failed, resume interfaces that did get suspended */
        if (status != 0) {
                while (--i >= 0) {
                        intf = udev->actconfig->interface[i];
-                       usb_resume_interface(intf);
+                       usb_resume_interface(intf, 0);
                }
 
                /* Try another autosuspend when the interfaces aren't busy */
@@ -1160,20 +1167,21 @@ static int usb_resume_both(struct usb_device *udev)
                }
        } else {
 
-               /* Needed only for setting udev->dev.power.power_state.event
-                * and for possible debugging message. */
+               /* Needed for setting udev->dev.power.power_state.event,
+                * for possible debugging message, and for reset_resume. */
                status = usb_resume_device(udev);
        }
 
        if (status == 0 && udev->actconfig) {
                for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
                        intf = udev->actconfig->interface[i];
-                       usb_resume_interface(intf);
+                       usb_resume_interface(intf, udev->reset_resume);
                }
        }
 
  done:
        // dev_dbg(&udev->dev, "%s: status %d\n", __FUNCTION__, status);
+       udev->reset_resume = 0;
        return status;
 }
 
@@ -1508,8 +1516,15 @@ static int usb_resume(struct device *dev)
        if (!is_usb_device(dev))        /* Ignore PM for interfaces */
                return 0;
        udev = to_usb_device(dev);
-       if (udev->autoresume_disabled)
-               return -EPERM;
+
+       /* If autoresume is disabled then we also want to prevent resume
+        * during system wakeup.  However, a "persistent-device" reset-resume
+        * after power loss counts as a wakeup event.  So allow a
+        * reset-resume to occur if remote wakeup is enabled. */
+       if (udev->autoresume_disabled) {
+               if (!(udev->reset_resume && udev->do_remote_wakeup))
+                       return -EPERM;
+       }
        return usb_external_resume_device(udev);
 }