[PATCH] USB: remove .owner field from struct usb_driver
[linux-2.6.git] / drivers / usb / core / hub.c
index 94f7d2d..40c6c50 100644 (file)
@@ -9,11 +9,6 @@
  */
 
 #include <linux/config.h>
-#ifdef CONFIG_USB_DEBUG
-       #define DEBUG
-#else
-       #undef DEBUG
-#endif
 #include <linux/kernel.h>
 #include <linux/errno.h>
 #include <linux/module.h>
@@ -26,6 +21,7 @@
 #include <linux/ioctl.h>
 #include <linux/usb.h>
 #include <linux/usbdevice_fs.h>
+#include <linux/kthread.h>
 
 #include <asm/semaphore.h>
 #include <asm/uaccess.h>
@@ -47,8 +43,7 @@ static LIST_HEAD(hub_event_list);     /* List of hubs needing servicing */
 /* Wakes up khubd */
 static DECLARE_WAIT_QUEUE_HEAD(khubd_wait);
 
-static pid_t khubd_pid = 0;                    /* PID of khubd */
-static DECLARE_COMPLETION(khubd_exited);
+static struct task_struct *khubd_task;
 
 /* cycle leds on hubs that aren't blinking for attention */
 static int blinkenlights = 0;
@@ -381,7 +376,7 @@ static void hub_tt_kevent (void *arg)
                        dev_err (&hdev->dev,
                                "clear tt %d (%04x) error %d\n",
                                clear->tt, clear->devinfo, status);
-               kfree (clear);
+               kfree(clear);
        }
        spin_unlock_irqrestore (&hub->tt.lock, flags);
 }
@@ -435,23 +430,33 @@ void usb_hub_tt_clear_buffer (struct usb_device *udev, int pipe)
 static void hub_power_on(struct usb_hub *hub)
 {
        int port1;
+       unsigned pgood_delay = hub->descriptor->bPwrOn2PwrGood * 2;
+       u16 wHubCharacteristics = le16_to_cpu(hub->descriptor->wHubCharacteristics);
 
        /* if hub supports power switching, enable power on each port */
-       if ((hub->descriptor->wHubCharacteristics & HUB_CHAR_LPSM) < 2) {
+       if ((wHubCharacteristics & HUB_CHAR_LPSM) < 2) {
                dev_dbg(hub->intfdev, "enabling power on all ports\n");
                for (port1 = 1; port1 <= hub->descriptor->bNbrPorts; port1++)
                        set_port_feature(hub->hdev, port1,
                                        USB_PORT_FEAT_POWER);
        }
 
-       /* Wait for power to be enabled */
-       msleep(hub->descriptor->bPwrOn2PwrGood * 2);
+       /* Wait at least 100 msec for power to become stable */
+       msleep(max(pgood_delay, (unsigned) 100));
 }
 
-static void hub_quiesce(struct usb_hub *hub)
+static inline void __hub_quiesce(struct usb_hub *hub)
 {
-       /* stop khubd and related activity */
+       /* (nonblocking) khubd and related activity won't re-trigger */
        hub->quiescing = 1;
+       hub->activating = 0;
+       hub->resume_root_hub = 0;
+}
+
+static void hub_quiesce(struct usb_hub *hub)
+{
+       /* (blocking) stop khubd and related activity */
+       __hub_quiesce(hub);
        usb_kill_urb(hub->urb);
        if (hub->has_indicators)
                cancel_delayed_work(&hub->leds);
@@ -465,6 +470,7 @@ static void hub_activate(struct usb_hub *hub)
 
        hub->quiescing = 0;
        hub->activating = 1;
+       hub->resume_root_hub = 0;
        status = usb_submit_urb(hub->urb, GFP_NOIO);
        if (status < 0)
                dev_err(hub->intfdev, "activate --> %d\n", status);
@@ -492,12 +498,30 @@ static int hub_hub_status(struct usb_hub *hub,
        return ret;
 }
 
+static int hub_port_disable(struct usb_hub *hub, int port1, int set_state)
+{
+       struct usb_device *hdev = hub->hdev;
+       int ret;
+
+       if (hdev->children[port1-1] && set_state) {
+               usb_set_device_state(hdev->children[port1-1],
+                               USB_STATE_NOTATTACHED);
+       }
+       ret = clear_port_feature(hdev, port1, USB_PORT_FEAT_ENABLE);
+       if (ret)
+               dev_err(hub->intfdev, "cannot disable port %d (err = %d)\n",
+                       port1, ret);
+
+       return ret;
+}
+
 static int hub_configure(struct usb_hub *hub,
        struct usb_endpoint_descriptor *endpoint)
 {
        struct usb_device *hdev = hub->hdev;
        struct device *hub_dev = hub->intfdev;
        u16 hubstatus, hubchange;
+       u16 wHubCharacteristics;
        unsigned int pipe;
        int maxp, ret;
        char *message;
@@ -543,9 +567,9 @@ static int hub_configure(struct usb_hub *hub,
        dev_info (hub_dev, "%d port%s detected\n", hdev->maxchild,
                (hdev->maxchild == 1) ? "" : "s");
 
-       le16_to_cpus(&hub->descriptor->wHubCharacteristics);
+       wHubCharacteristics = le16_to_cpu(hub->descriptor->wHubCharacteristics);
 
-       if (hub->descriptor->wHubCharacteristics & HUB_CHAR_COMPOUND) {
+       if (wHubCharacteristics & HUB_CHAR_COMPOUND) {
                int     i;
                char    portstr [USB_MAXCHILDREN + 1];
 
@@ -558,7 +582,7 @@ static int hub_configure(struct usb_hub *hub,
        } else
                dev_dbg(hub_dev, "standalone hub\n");
 
-       switch (hub->descriptor->wHubCharacteristics & HUB_CHAR_LPSM) {
+       switch (wHubCharacteristics & HUB_CHAR_LPSM) {
                case 0x00:
                        dev_dbg(hub_dev, "ganged power switching\n");
                        break;
@@ -571,7 +595,7 @@ static int hub_configure(struct usb_hub *hub,
                        break;
        }
 
-       switch (hub->descriptor->wHubCharacteristics & HUB_CHAR_OCPM) {
+       switch (wHubCharacteristics & HUB_CHAR_OCPM) {
                case 0x00:
                        dev_dbg(hub_dev, "global over-current protection\n");
                        break;
@@ -610,24 +634,38 @@ static int hub_configure(struct usb_hub *hub,
                        break;
        }
 
-       switch (hub->descriptor->wHubCharacteristics & HUB_CHAR_TTTT) {
-               case 0x00:
-                       if (hdev->descriptor.bDeviceProtocol != 0)
-                               dev_dbg(hub_dev, "TT requires at most 8 FS bit times\n");
+       /* Note 8 FS bit times == (8 bits / 12000000 bps) ~= 666ns */
+       switch (wHubCharacteristics & HUB_CHAR_TTTT) {
+               case HUB_TTTT_8_BITS:
+                       if (hdev->descriptor.bDeviceProtocol != 0) {
+                               hub->tt.think_time = 666;
+                               dev_dbg(hub_dev, "TT requires at most %d "
+                                               "FS bit times (%d ns)\n",
+                                       8, hub->tt.think_time);
+                       }
                        break;
-               case 0x20:
-                       dev_dbg(hub_dev, "TT requires at most 16 FS bit times\n");
+               case HUB_TTTT_16_BITS:
+                       hub->tt.think_time = 666 * 2;
+                       dev_dbg(hub_dev, "TT requires at most %d "
+                                       "FS bit times (%d ns)\n",
+                               16, hub->tt.think_time);
                        break;
-               case 0x40:
-                       dev_dbg(hub_dev, "TT requires at most 24 FS bit times\n");
+               case HUB_TTTT_24_BITS:
+                       hub->tt.think_time = 666 * 3;
+                       dev_dbg(hub_dev, "TT requires at most %d "
+                                       "FS bit times (%d ns)\n",
+                               24, hub->tt.think_time);
                        break;
-               case 0x60:
-                       dev_dbg(hub_dev, "TT requires at most 32 FS bit times\n");
+               case HUB_TTTT_32_BITS:
+                       hub->tt.think_time = 666 * 4;
+                       dev_dbg(hub_dev, "TT requires at most %d "
+                                       "FS bit times (%d ns)\n",
+                               32, hub->tt.think_time);
                        break;
        }
 
        /* probe() zeroes hub->indicator[] */
-       if (hub->descriptor->wHubCharacteristics & HUB_CHAR_PORTIND) {
+       if (wHubCharacteristics & HUB_CHAR_PORTIND) {
                hub->has_indicators = 1;
                dev_dbg(hub_dev, "Port indicators are supported\n");
        }
@@ -643,15 +681,21 @@ static int hub_configure(struct usb_hub *hub,
                message = "can't get hub status";
                goto fail;
        }
-       cpu_to_le16s(&hubstatus);
-       if ((hubstatus & (1 << USB_DEVICE_SELF_POWERED)) == 0) {
+       le16_to_cpus(&hubstatus);
+       if (hdev == hdev->bus->root_hub) {
+               struct usb_hcd *hcd =
+                               container_of(hdev->bus, struct usb_hcd, self);
+
+               hub->power_budget = min(500u, hcd->power_budget) / 2;
+       } else if ((hubstatus & (1 << USB_DEVICE_SELF_POWERED)) == 0) {
                dev_dbg(hub_dev, "hub controller current requirement: %dmA\n",
                        hub->descriptor->bHubContrCurrent);
                hub->power_budget = (501 - hub->descriptor->bHubContrCurrent)
                                        / 2;
+       }
+       if (hub->power_budget)
                dev_dbg(hub_dev, "%dmA bus power budget for children\n",
                        hub->power_budget * 2);
-       }
 
 
        ret = hub_hub_status(hub, &hubstatus, &hubchange);
@@ -666,7 +710,7 @@ static int hub_configure(struct usb_hub *hub,
                        (hubstatus & HUB_STATUS_LOCAL_POWER)
                        ? "lost (inactive)" : "good");
 
-       if ((hub->descriptor->wHubCharacteristics & HUB_CHAR_OCPM) == 0)
+       if ((wHubCharacteristics & HUB_CHAR_OCPM) == 0)
                dev_dbg(hub_dev, "%sover-current condition exists\n",
                        (hubstatus & HUB_STATUS_OVERCURRENT) ? "" : "no ");
 
@@ -706,20 +750,36 @@ fail:
 
 static unsigned highspeed_hubs;
 
+/* Called after the hub driver is unbound from a hub with children */
+static void hub_remove_children_work(void *__hub)
+{
+       struct usb_hub          *hub = __hub;
+       struct usb_device       *hdev = hub->hdev;
+       int                     i;
+
+       kfree(hub);
+
+       usb_lock_device(hdev);
+       for (i = 0; i < hdev->maxchild; ++i) {
+               if (hdev->children[i])
+                       usb_disconnect(&hdev->children[i]);
+       }
+       usb_unlock_device(hdev);
+       usb_put_dev(hdev);
+}
+
 static void hub_disconnect(struct usb_interface *intf)
 {
        struct usb_hub *hub = usb_get_intfdata (intf);
        struct usb_device *hdev;
+       int n, port1;
 
-       if (!hub)
-               return;
+       usb_set_intfdata (intf, NULL);
        hdev = hub->hdev;
 
        if (hdev->speed == USB_SPEED_HIGH)
                highspeed_hubs--;
 
-       usb_set_intfdata (intf, NULL);
-
        hub_quiesce(hub);
        usb_free_urb(hub->urb);
        hub->urb = NULL;
@@ -728,15 +788,11 @@ static void hub_disconnect(struct usb_interface *intf)
        list_del_init(&hub->event_list);
        spin_unlock_irq(&hub_event_lock);
 
-       if (hub->descriptor) {
-               kfree(hub->descriptor);
-               hub->descriptor = NULL;
-       }
+       kfree(hub->descriptor);
+       hub->descriptor = NULL;
 
-       if (hub->status) {
-               kfree(hub->status);
-               hub->status = NULL;
-       }
+       kfree(hub->status);
+       hub->status = NULL;
 
        if (hub->buffer) {
                usb_buffer_free(hdev, sizeof(*hub->buffer), hub->buffer,
@@ -744,8 +800,27 @@ static void hub_disconnect(struct usb_interface *intf)
                hub->buffer = NULL;
        }
 
-       /* Free the memory */
-       kfree(hub);
+       /* If there are any children then this is an unbind only, not a
+        * physical disconnection.  The active ports must be disabled
+        * and later on we must call usb_disconnect().  We can't call
+        * it now because we may not hold the hub's device lock.
+        */
+       n = 0;
+       for (port1 = 1; port1 <= hdev->maxchild; ++port1) {
+               if (hdev->children[port1 - 1]) {
+                       ++n;
+                       hub_port_disable(hub, port1, 1);
+               }
+       }
+
+       if (n == 0)
+               kfree(hub);
+       else {
+               /* Reuse the hub->leds work_struct for our own purposes */
+               INIT_WORK(&hub->leds, hub_remove_children_work, hub);
+               schedule_work(&hub->leds);
+               usb_get_dev(hdev);
+       }
 }
 
 static int hub_probe(struct usb_interface *intf, const struct usb_device_id *id)
@@ -785,14 +860,12 @@ descriptor_error:
        /* We found a hub */
        dev_info (&intf->dev, "USB hub found\n");
 
-       hub = kmalloc(sizeof(*hub), GFP_KERNEL);
+       hub = kzalloc(sizeof(*hub), GFP_KERNEL);
        if (!hub) {
                dev_dbg (&intf->dev, "couldn't kmalloc hub struct\n");
                return -ENOMEM;
        }
 
-       memset(hub, 0, sizeof(*hub));
-
        INIT_LIST_HEAD(&hub->event_list);
        hub->intfdev = &intf->dev;
        hub->hdev = hdev;
@@ -951,15 +1024,54 @@ void usb_set_device_state(struct usb_device *udev,
        spin_lock_irqsave(&device_state_lock, flags);
        if (udev->state == USB_STATE_NOTATTACHED)
                ;       /* do nothing */
-       else if (new_state != USB_STATE_NOTATTACHED)
+       else if (new_state != USB_STATE_NOTATTACHED) {
                udev->state = new_state;
-       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)
+                       device_init_wakeup(&udev->dev, 0);
+       } else
                recursively_mark_NOTATTACHED(udev);
        spin_unlock_irqrestore(&device_state_lock, flags);
 }
 EXPORT_SYMBOL(usb_set_device_state);
 
 
+#ifdef CONFIG_PM
+
+/**
+ * usb_root_hub_lost_power - called by HCD if the root hub lost Vbus power
+ * @rhdev: struct usb_device for the root hub
+ *
+ * The USB host controller driver calls this function when its root hub
+ * is resumed and Vbus power has been interrupted or the controller
+ * has been reset.  The routine marks all the children of the root hub
+ * as NOTATTACHED and marks logical connect-change events on their ports.
+ */
+void usb_root_hub_lost_power(struct usb_device *rhdev)
+{
+       struct usb_hub *hub;
+       int port1;
+       unsigned long flags;
+
+       dev_warn(&rhdev->dev, "root hub lost power or was reset\n");
+       spin_lock_irqsave(&device_state_lock, flags);
+       hub = hdev_to_hub(rhdev);
+       for (port1 = 1; port1 <= rhdev->maxchild; ++port1) {
+               if (rhdev->children[port1 - 1]) {
+                       recursively_mark_NOTATTACHED(
+                                       rhdev->children[port1 - 1]);
+                       set_bit(port1, hub->change_bits);
+               }
+       }
+       spin_unlock_irqrestore(&device_state_lock, flags);
+}
+EXPORT_SYMBOL_GPL(usb_root_hub_lost_power);
+
+#endif
+
 static void choose_address(struct usb_device *udev)
 {
        int             devnum;
@@ -1042,13 +1154,14 @@ void usb_disconnect(struct usb_device **pdev)
         */
        usb_disable_device(udev, 0);
 
+       usb_notify_remove_device(udev);
+
        /* Free the device number, remove the /proc/bus/usb entry and
         * the sysfs attributes, and delete the parent's children[]
         * (or root_hub) pointer.
         */
        dev_dbg (&udev->dev, "unregistering device\n");
        release_address(udev);
-       usbfs_remove_device(udev);
        usb_remove_sysfs_dev_files(udev);
 
        /* Avoid races with recursively_mark_NOTATTACHED() */
@@ -1119,21 +1232,6 @@ static inline void show_string(struct usb_device *udev, char *id, char *string)
 {}
 #endif
 
-static void get_string(struct usb_device *udev, char **string, int index)
-{
-       char *buf;
-
-       if (!index)
-               return;
-       buf = kmalloc(256, GFP_KERNEL);
-       if (!buf)
-               return;
-       if (usb_string(udev, index, buf, 256) > 0)
-               *string = buf;
-       else
-               kfree(buf);
-}
-
 
 #ifdef CONFIG_USB_OTG
 #include "otg_whitelist.h"
@@ -1172,9 +1270,10 @@ int usb_new_device(struct usb_device *udev)
        }
 
        /* read the standard strings and cache them if present */
-       get_string(udev, &udev->product, udev->descriptor.iProduct);
-       get_string(udev, &udev->manufacturer, udev->descriptor.iManufacturer);
-       get_string(udev, &udev->serial, udev->descriptor.iSerialNumber);
+       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);
 
        /* Tell the world! */
        dev_dbg(&udev->dev, "new device strings: Mfr=%d, Product=%d, "
@@ -1246,11 +1345,9 @@ int usb_new_device(struct usb_device *udev)
                 * (Includes HNP test device.)
                 */
                if (udev->bus->b_hnp_enable || udev->bus->is_b_host) {
-                       static int __usb_suspend_device (struct usb_device *,
-                                               int port1, pm_message_t state);
-                       err = __usb_suspend_device(udev,
-                                       udev->bus->otg_port,
-                                       PMSG_SUSPEND);
+                       static int __usb_suspend_device(struct usb_device *,
+                                               int port1);
+                       err = __usb_suspend_device(udev, udev->bus->otg_port);
                        if (err < 0)
                                dev_dbg(&udev->dev, "HNP fail, %d\n", err);
                }
@@ -1286,9 +1383,8 @@ int usb_new_device(struct usb_device *udev)
        }
 
        /* USB device state == configured ... usable */
+       usb_notify_add_device(udev);
 
-       /* add a /proc/bus/usb entry */
-       usbfs_add_device(udev);
        return 0;
 
 fail:
@@ -1390,7 +1486,7 @@ static int hub_port_reset(struct usb_hub *hub, int port1,
                                        port1, status);
                else {
                        status = hub_port_wait_reset(hub, port1, udev, delay);
-                       if (status)
+                       if (status && status != -ENOTCONN)
                                dev_dbg(hub->intfdev,
                                                "port_wait_reset: err = %d\n",
                                                status);
@@ -1399,8 +1495,8 @@ static int hub_port_reset(struct usb_hub *hub, int port1,
                /* return on disconnect or reset */
                switch (status) {
                case 0:
-                       /* TRSTRCY = 10 ms */
-                       msleep(10);
+                       /* TRSTRCY = 10 ms; plus some extra */
+                       msleep(10 + 40);
                        /* FALL THROUGH */
                case -ENOTCONN:
                case -ENODEV:
@@ -1426,23 +1522,6 @@ static int hub_port_reset(struct usb_hub *hub, int port1,
        return status;
 }
 
-static int hub_port_disable(struct usb_hub *hub, int port1, int set_state)
-{
-       struct usb_device *hdev = hub->hdev;
-       int ret;
-
-       if (hdev->children[port1-1] && set_state) {
-               usb_set_device_state(hdev->children[port1-1],
-                               USB_STATE_NOTATTACHED);
-       }
-       ret = clear_port_feature(hdev, port1, USB_PORT_FEAT_ENABLE);
-       if (ret)
-               dev_err(hub->intfdev, "cannot disable port %d (err = %d)\n",
-                       port1, ret);
-
-       return ret;
-}
-
 /*
  * Disable a port and mark a logical connnect-change event, so that some
  * time later khubd will disconnect() any existing usb_device on the port
@@ -1456,7 +1535,7 @@ static void hub_port_logical_disconnect(struct usb_hub *hub, int port1)
        /* FIXME let caller ask to power down the port:
         *  - some devices won't enumerate without a VBUS power cycle
         *  - SRP saves power that way
-        *  - usb_suspend_device(dev,PM_SUSPEND_DISK)
+        *  - ... new call, TBD ...
         * That's easy if this hub can switch power per-port, and
         * khubd reactivates the port later (timer, SRP, etc).
         * Powerdown must be optional, because of reset/DFU.
@@ -1492,11 +1571,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 (udev->actconfig
-                       // && FIXME (remote wakeup enabled on this bus)
-                       // ... currently assuming it's always appropriate
-                       && (udev->actconfig->desc.bmAttributes
-                               & USB_CONFIG_ATT_WAKEUP) != 0) {
+       if (device_may_wakeup(&udev->dev)) {
                status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
                                USB_REQ_SET_FEATURE, USB_RECIP_DEVICE,
                                USB_DEVICE_REMOTE_WAKEUP, 0,
@@ -1531,7 +1606,7 @@ static int hub_port_suspend(struct usb_hub *hub, int port1,
 
 /*
  * Devices on USB hub ports have only one "suspend" state, corresponding
- * to ACPI D2 (PM_SUSPEND_MEM), "may cause the device to lose some context".
+ * to ACPI D2, "may cause the device to lose some context".
  * State transitions include:
  *
  *   - suspend, resume ... when the VBUS power link stays live
@@ -1542,11 +1617,14 @@ static int hub_port_suspend(struct usb_hub *hub, int port1,
  * Other than re-initializing the hub (plug/unplug, except for root hubs),
  * Linux (2.6) currently has NO mechanisms to initiate that:  no khubd
  * timer, no SRP, no requests through sysfs.
+ *
+ * If CONFIG_USB_SUSPEND isn't enabled, devices only really suspend when
+ * the root hub for their bus goes into global suspend ... so we don't
+ * (falsely) update the device power state to say it suspended.
  */
-static int __usb_suspend_device (struct usb_device *udev, int port1,
-                                pm_message_t state)
+static int __usb_suspend_device (struct usb_device *udev, int port1)
 {
-       int     status;
+       int     status = 0;
 
        /* caller owns the udev device lock */
        if (port1 < 0)
@@ -1557,95 +1635,39 @@ static int __usb_suspend_device (struct usb_device *udev, int port1,
                return 0;
        }
 
-       /* suspend interface drivers; if this is a hub, it
-        * suspends the child devices
-        */
+       /* all interfaces must already be suspended */
        if (udev->actconfig) {
                int     i;
 
                for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
                        struct usb_interface    *intf;
-                       struct usb_driver       *driver;
 
                        intf = udev->actconfig->interface[i];
-                       if (state <= intf->dev.power.power_state)
-                               continue;
-                       if (!intf->dev.driver)
-                               continue;
-                       driver = to_usb_driver(intf->dev.driver);
-
-                       if (driver->suspend) {
-                               status = driver->suspend(intf, state);
-                               if (intf->dev.power.power_state != state
-                                               || status)
-                                       dev_err(&intf->dev,
-                                               "suspend %d fail, code %d\n",
-                                               state, status);
-                       }
-
-                       /* only drivers with suspend() can ever resume();
-                        * and after power loss, even they won't.
-                        * bus_rescan_devices() can rebind drivers later.
-                        *
-                        * FIXME the PM core self-deadlocks when unbinding
-                        * drivers during suspend/resume ... everything grabs
-                        * dpm_sem (not a spinlock, ugh).  we want to unbind,
-                        * since we know every driver's probe/disconnect works
-                        * even for drivers that can't suspend.
-                        */
-                       if (!driver->suspend || state > PM_SUSPEND_MEM) {
-#if 1
-                               dev_warn(&intf->dev, "resume is unsafe!\n");
-#else
-                               down_write(&usb_bus_type.rwsem);
-                               device_release_driver(&intf->dev);
-                               up_write(&usb_bus_type.rwsem);
-#endif
+                       if (is_active(intf)) {
+                               dev_dbg(&intf->dev, "nyet suspended\n");
+                               return -EBUSY;
                        }
                }
        }
 
-       /*
-        * FIXME this needs port power off call paths too, to help force
-        * USB into the "generic" PM model.  At least for devices on
-        * ports that aren't using ganged switching (usually root hubs).
-        *
-        * NOTE: SRP-capable links should adopt more aggressive poweroff
-        * policies (when HNP doesn't apply) once we have mechanisms to
-        * turn power back on!  (Likely not before 2.7...)
+       /* we only change a device's upstream USB link.
+        * root hubs have no upstream USB link.
         */
-       if (state > PM_SUSPEND_MEM) {
-               dev_warn(&udev->dev, "no poweroff yet, suspending instead\n");
-       }
-
-       /* "global suspend" of the HC-to-USB interface (root hub), or
-        * "selective suspend" of just one hub-device link.
-        */
-       if (!udev->parent) {
-               struct usb_bus  *bus = udev->bus;
-               if (bus && bus->op->hub_suspend) {
-                       status = bus->op->hub_suspend (bus);
-                       if (status == 0) {
-                               dev_dbg(&udev->dev, "usb suspend\n");
-                               usb_set_device_state(udev,
-                                               USB_STATE_SUSPENDED);
-                       }
-               } else
-                       status = -EOPNOTSUPP;
-       } else
+       if (udev->parent)
                status = hub_port_suspend(hdev_to_hub(udev->parent), port1,
                                udev);
 
        if (status == 0)
-               udev->dev.power.power_state = state;
+               udev->dev.power.power_state = PMSG_SUSPEND;
        return status;
 }
 
-/**
+#endif
+
+/*
  * usb_suspend_device - suspend a usb device
  * @udev: device that's no longer in active use
- * @state: PMSG_SUSPEND to suspend
- * Context: must be able to sleep; device not locked
+ * Context: must be able to sleep; device not locked; pm locks held
  *
  * Suspends a USB device that isn't in active use, conserving power.
  * Devices may wake out of a suspend, if anything important happens,
@@ -1653,37 +1675,49 @@ static int __usb_suspend_device (struct usb_device *udev, int port1,
  * suspend by the host, using usb_resume_device().  It's also routine
  * to disconnect devices while they are suspended.
  *
+ * This only affects the USB hardware for a device; its interfaces
+ * (and, for hubs, child devices) must already have been suspended.
+ *
  * Suspending OTG devices may trigger HNP, if that's been enabled
  * between a pair of dual-role devices.  That will change roles, such
  * as from A-Host to A-Peripheral or from B-Host back to B-Peripheral.
  *
  * Returns 0 on success, else negative errno.
  */
-int usb_suspend_device(struct usb_device *udev, pm_message_t state)
+int usb_suspend_device(struct usb_device *udev)
 {
+#ifdef CONFIG_USB_SUSPEND
        int     port1, status;
 
        port1 = locktree(udev);
        if (port1 < 0)
                return port1;
 
-       status = __usb_suspend_device(udev, port1, state);
+       status = __usb_suspend_device(udev, port1);
        usb_unlock_device(udev);
        return status;
+#else
+       /* NOTE:  udev->state unchanged, it's not lying ... */
+       udev->dev.power.power_state = PMSG_SUSPEND;
+       return 0;
+#endif
 }
 
 /*
+ * If the USB "suspend" state is in use (rather than "global suspend"),
+ * many devices will be individually taken out of suspend state using
+ * special" resume" signaling.  These routines kick in shortly after
  * hardware resume signaling is finished, either because of selective
  * resume (by host) or remote wakeup (by device) ... now see what changed
  * in the tree that's rooted at this device.
  */
-static int finish_port_resume(struct usb_device *udev)
+static int finish_device_resume(struct usb_device *udev)
 {
        int     status;
        u16     devstatus;
 
        /* caller owns the udev device lock */
-       dev_dbg(&udev->dev, "usb resume\n");
+       dev_dbg(&udev->dev, "finish resume\n");
 
        /* usb ch9 identifies four variants of SUSPENDED, based on what
         * state the device resumes to.  Linux currently won't see the
@@ -1693,7 +1727,6 @@ static int finish_port_resume(struct usb_device *udev)
        usb_set_device_state(udev, udev->actconfig
                        ? USB_STATE_CONFIGURED
                        : USB_STATE_ADDRESS);
-       udev->dev.power.power_state = PMSG_ON;
 
        /* 10.5.4.5 says be sure devices in the tree are still there.
         * For now let's assume the device didn't go crazy on resume,
@@ -1706,9 +1739,11 @@ static int finish_port_resume(struct usb_device *udev)
                        status);
        else if (udev->actconfig) {
                unsigned        i;
+               int             (*resume)(struct device *);
 
                le16_to_cpus(&devstatus);
-               if (devstatus & (1 << USB_DEVICE_REMOTE_WAKEUP)) {
+               if (devstatus & (1 << USB_DEVICE_REMOTE_WAKEUP)
+                               && udev->parent) {
                        status = usb_control_msg(udev,
                                        usb_sndctrlpipe(udev, 0),
                                        USB_REQ_CLEAR_FEATURE,
@@ -1724,33 +1759,11 @@ static int finish_port_resume(struct usb_device *udev)
                }
 
                /* resume interface drivers; if this is a hub, it
-                * resumes the child devices
+                * may have a child resume event to deal with soon
                 */
-               for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
-                       struct usb_interface    *intf;
-                       struct usb_driver       *driver;
-
-                       intf = udev->actconfig->interface[i];
-                       if (intf->dev.power.power_state == PMSG_SUSPEND)
-                               continue;
-                       if (!intf->dev.driver) {
-                               /* FIXME maybe force to alt 0 */
-                               continue;
-                       }
-                       driver = to_usb_driver(intf->dev.driver);
-
-                       /* bus_rescan_devices() may rebind drivers */
-                       if (!driver->resume)
-                               continue;
-
-                       /* can we do better than just logging errors? */
-                       status = driver->resume(intf);
-                       if (intf->dev.power.power_state != PMSG_ON
-                                       || status)
-                               dev_dbg(&intf->dev,
-                                       "resume fail, state %d code %d\n",
-                                       intf->dev.power.power_state, status);
-               }
+               resume = udev->dev.bus->resume;
+               for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++)
+                       (void) resume(&udev->actconfig->interface[i]->dev);
                status = 0;
 
        } else if (udev->devnum <= 0) {
@@ -1760,6 +1773,8 @@ static int finish_port_resume(struct usb_device *udev)
        return status;
 }
 
+#ifdef CONFIG_USB_SUSPEND
+
 static int
 hub_port_resume(struct usb_hub *hub, int port1, struct usb_device *udev)
 {
@@ -1805,7 +1820,7 @@ hub_port_resume(struct usb_hub *hub, int port1, struct usb_device *udev)
                        /* TRSMRCY = 10 msec */
                        msleep(10);
                        if (udev)
-                               status = finish_port_resume(udev);
+                               status = finish_device_resume(udev);
                }
        }
        if (status < 0)
@@ -1814,12 +1829,12 @@ hub_port_resume(struct usb_hub *hub, int port1, struct usb_device *udev)
        return status;
 }
 
-static int hub_resume (struct usb_interface *intf);
+#endif
 
-/**
+/*
  * usb_resume_device - re-activate a suspended usb device
  * @udev: device to re-activate
- * Context: must be able to sleep; device not locked
+ * Context: must be able to sleep; device not locked; pm locks held
  *
  * This will re-activate the suspended device, increasing power usage
  * while letting drivers communicate again with its endpoints.
@@ -1837,35 +1852,22 @@ int usb_resume_device(struct usb_device *udev)
        if (port1 < 0)
                return port1;
 
-       /* "global resume" of the HC-to-USB interface (root hub), or
-        * selective resume of one hub-to-device port
-        */
-       if (!udev->parent) {
-               struct usb_bus  *bus = udev->bus;
-               if (bus && bus->op->hub_resume) {
-                       status = bus->op->hub_resume (bus);
+#ifdef CONFIG_USB_SUSPEND
+       /* selective resume of one downstream hub-to-device port */
+       if (udev->parent) {
+               if (udev->state == USB_STATE_SUSPENDED) {
+                       // NOTE swsusp may bork us, device state being wrong...
+                       // NOTE this fails if parent is also suspended...
+                       status = hub_port_resume(hdev_to_hub(udev->parent),
+                                       port1, udev);
                } else
-                       status = -EOPNOTSUPP;
-               if (status == 0) {
-                       dev_dbg(&udev->dev, "usb resume\n");
-                       /* TRSMRCY = 10 msec */
-                       msleep(10);
-                       usb_set_device_state (udev, USB_STATE_CONFIGURED);
-                       udev->dev.power.power_state = PMSG_ON;
-                       status = hub_resume (udev
-                                       ->actconfig->interface[0]);
-               }
-       } else if (udev->state == USB_STATE_SUSPENDED) {
-               // NOTE this fails if parent is also suspended...
-               status = hub_port_resume(hdev_to_hub(udev->parent),
-                               port1, udev);
-       } else {
-               status = 0;
-       }
-       if (status < 0) {
+                       status = 0;
+       } else
+#endif
+               status = finish_device_resume(udev);
+       if (status < 0)
                dev_dbg(&udev->dev, "can't resume, status %d\n",
                        status);
-       }
 
        usb_unlock_device(udev);
 
@@ -1882,6 +1884,8 @@ static int remote_wakeup(struct usb_device *udev)
 {
        int     status = 0;
 
+#ifdef CONFIG_USB_SUSPEND
+
        /* don't repeat RESUME sequence if this device
         * was already woken up by some other task
         */
@@ -1890,38 +1894,52 @@ static int remote_wakeup(struct usb_device *udev)
                dev_dbg(&udev->dev, "RESUME (wakeup)\n");
                /* TRSMRCY = 10 msec */
                msleep(10);
-               status = finish_port_resume(udev);
+               status = finish_device_resume(udev);
        }
        up(&udev->serialize);
+#endif
        return status;
 }
 
-static int hub_suspend(struct usb_interface *intf, pm_message_t state)
+static int hub_suspend(struct usb_interface *intf, pm_message_t msg)
 {
        struct usb_hub          *hub = usb_get_intfdata (intf);
        struct usb_device       *hdev = hub->hdev;
        unsigned                port1;
-       int                     status;
-
-       /* stop khubd and related activity */
-       hub_quiesce(hub);
 
-       /* then suspend every port */
+       /* fail if children aren't already suspended */
        for (port1 = 1; port1 <= hdev->maxchild; port1++) {
                struct usb_device       *udev;
 
                udev = hdev->children [port1-1];
-               if (!udev)
-                       continue;
-               down(&udev->serialize);
-               status = __usb_suspend_device(udev, port1, state);
-               up(&udev->serialize);
-               if (status < 0)
-                       dev_dbg(&intf->dev, "suspend port %d --> %d\n",
-                               port1, status);
+               if (udev && (udev->dev.power.power_state.event
+                                       == PM_EVENT_ON
+#ifdef CONFIG_USB_SUSPEND
+                               || udev->state != USB_STATE_SUSPENDED
+#endif
+                               )) {
+                       dev_dbg(&intf->dev, "port %d nyet suspended\n", port1);
+                       return -EBUSY;
+               }
+       }
+
+       /* "global suspend" of the downstream HC-to-USB interface */
+       if (!hdev->parent) {
+               struct usb_bus  *bus = hdev->bus;
+               if (bus) {
+                       int     status = hcd_bus_suspend (bus);
+
+                       if (status != 0) {
+                               dev_dbg(&hdev->dev, "'global' suspend %d\n",
+                                       status);
+                               return status;
+                       }
+               } else
+                       return -EOPNOTSUPP;
        }
 
-       intf->dev.power.power_state = state;
+       /* stop khubd and related activity */
+       hub_quiesce(hub);
        return 0;
 }
 
@@ -1929,11 +1947,35 @@ static int hub_resume(struct usb_interface *intf)
 {
        struct usb_device       *hdev = interface_to_usbdev(intf);
        struct usb_hub          *hub = usb_get_intfdata (intf);
-       unsigned                port1;
        int                     status;
 
-       if (intf->dev.power.power_state == PM_SUSPEND_ON)
-               return 0;
+       /* "global resume" of the downstream HC-to-USB interface */
+       if (!hdev->parent) {
+               struct usb_bus  *bus = hdev->bus;
+               if (bus) {
+                       status = hcd_bus_resume (bus);
+                       if (status) {
+                               dev_dbg(&intf->dev, "'global' resume %d\n",
+                                       status);
+                               return status;
+                       }
+               } else
+                       return -EOPNOTSUPP;
+               if (status == 0) {
+                       /* TRSMRCY = 10 msec */
+                       msleep(10);
+               }
+       }
+
+       hub_activate(hub);
+
+       /* REVISIT:  this recursion probably shouldn't exist.  Remove
+        * this code sometime, after retesting with different root and
+        * external hubs.
+        */
+#ifdef CONFIG_USB_SUSPEND
+       {
+       unsigned                port1;
 
        for (port1 = 1; port1 <= hdev->maxchild; port1++) {
                struct usb_device       *udev;
@@ -1959,7 +2001,7 @@ static int hub_resume(struct usb_interface *intf)
                if (portstat & USB_PORT_STAT_SUSPEND)
                        status = hub_port_resume(hub, port1, udev);
                else {
-                       status = finish_port_resume(udev);
+                       status = finish_device_resume(udev);
                        if (status < 0) {
                                dev_dbg(&intf->dev, "resume port %d --> %d\n",
                                        port1, status);
@@ -1968,43 +2010,31 @@ static int hub_resume(struct usb_interface *intf)
                }
                up(&udev->serialize);
        }
-       intf->dev.power.power_state = PMSG_ON;
-
-       hub->resume_root_hub = 0;
-       hub_activate(hub);
+       }
+#endif
        return 0;
 }
 
-void usb_resume_root_hub(struct usb_device *hdev)
+void usb_suspend_root_hub(struct usb_device *hdev)
 {
        struct usb_hub *hub = hdev_to_hub(hdev);
 
-       hub->resume_root_hub = 1;
-       kick_khubd(hub);
+       /* This also makes any led blinker stop retriggering.  We're called
+        * from irq, so the blinker might still be scheduled.  Caller promises
+        * that the root hub status URB will be canceled.
+        */
+       __hub_quiesce(hub);
+       mark_quiesced(to_usb_interface(hub->intfdev));
 }
 
-#else  /* !CONFIG_USB_SUSPEND */
-
-int usb_suspend_device(struct usb_device *udev, pm_message_t state)
+void usb_resume_root_hub(struct usb_device *hdev)
 {
-       return 0;
-}
+       struct usb_hub *hub = hdev_to_hub(hdev);
 
-int usb_resume_device(struct usb_device *udev)
-{
-       return 0;
+       hub->resume_root_hub = 1;
+       kick_khubd(hub);
 }
 
-#define        hub_suspend             NULL
-#define        hub_resume              NULL
-#define        remote_wakeup(x)        0
-
-#endif /* CONFIG_USB_SUSPEND */
-
-EXPORT_SYMBOL(usb_suspend_device);
-EXPORT_SYMBOL(usb_resume_device);
-
-
 
 /* USB 2.0 spec, 7.1.7.3 / fig 7-29:
  *
@@ -2354,7 +2384,7 @@ check_highspeed (struct usb_hub *hub, struct usb_device *udev, int port1)
                        schedule_work (&hub->leds);
                }
        }
-       kfree (qual);
+       kfree(qual);
 }
 
 static unsigned
@@ -2413,6 +2443,7 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1,
 {
        struct usb_device *hdev = hub->hdev;
        struct device *hub_dev = hub->intfdev;
+       u16 wHubCharacteristics = le16_to_cpu(hub->descriptor->wHubCharacteristics);
        int status, i;
  
        dev_dbg (hub_dev,
@@ -2450,8 +2481,7 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1,
        if (!(portstatus & USB_PORT_STAT_CONNECTION)) {
 
                /* maybe switch power back on (e.g. root hub was reset) */
-               if ((hub->descriptor->wHubCharacteristics
-                                       & HUB_CHAR_LPSM) < 2
+               if ((wHubCharacteristics & HUB_CHAR_LPSM) < 2
                                && !(portstatus & (1 << USB_PORT_FEAT_POWER)))
                        set_port_feature(hdev, port1, USB_PORT_FEAT_POWER);
  
@@ -2630,21 +2660,28 @@ static void hub_events(void)
                intf = to_usb_interface(hub->intfdev);
                hub_dev = &intf->dev;
 
-               dev_dbg(hub_dev, "state %d ports %d chg %04x evt %04x\n",
+               i = hub->resume_root_hub;
+
+               dev_dbg(hub_dev, "state %d ports %d chg %04x evt %04x%s\n",
                                hdev->state, hub->descriptor
                                        ? hub->descriptor->bNbrPorts
                                        : 0,
                                /* NOTE: expects max 15 ports... */
                                (u16) hub->change_bits[0],
-                               (u16) hub->event_bits[0]);
+                               (u16) hub->event_bits[0],
+                               i ? ", resume root" : "");
 
                usb_get_intf(intf);
-               i = hub->resume_root_hub;
                spin_unlock_irq(&hub_event_lock);
 
-               /* Is this is a root hub wanting to be resumed? */
-               if (i)
-                       usb_resume_device(hdev);
+               /* Is this is a root hub wanting to reactivate the downstream
+                * ports?  If so, be sure the interface resumes even if its
+                * stub "device" node was never suspended.
+                */
+               if (i) {
+                       dpm_runtime_resume(&hdev->dev);
+                       dpm_runtime_resume(&intf->dev);
+               }
 
                /* Lock the device, then check to see if we were
                 * disconnected while waiting for the lock to succeed. */
@@ -2791,6 +2828,11 @@ static void hub_events(void)
 
                hub->activating = 0;
 
+               /* If this is a root hub, tell the HCD it's okay to
+                * re-enable port-change interrupts now. */
+               if (!hdev->parent)
+                       usb_enable_root_hub_irq(hdev->bus);
+
 loop:
                usb_unlock_device(hdev);
                usb_put_intf(intf);
@@ -2800,23 +2842,16 @@ loop:
 
 static int hub_thread(void *__unused)
 {
-       /*
-        * This thread doesn't need any user-level access,
-        * so get rid of all our resources
-        */
-
-       daemonize("khubd");
-       allow_signal(SIGKILL);
-
-       /* Send me a signal to get me die (for debugging) */
        do {
                hub_events();
-               wait_event_interruptible(khubd_wait, !list_empty(&hub_event_list)); 
-               try_to_freeze(PF_FREEZE);
-       } while (!signal_pending(current));
+               wait_event_interruptible(khubd_wait,
+                               !list_empty(&hub_event_list) ||
+                               kthread_should_stop());
+               try_to_freeze();
+       } while (!kthread_should_stop() || !list_empty(&hub_event_list));
 
-       pr_debug ("%s: khubd exiting\n", usbcore_name);
-       complete_and_exit(&khubd_exited, 0);
+       pr_debug("%s: khubd exiting\n", usbcore_name);
+       return 0;
 }
 
 static struct usb_device_id hub_id_table [] = {
@@ -2830,7 +2865,6 @@ static struct usb_device_id hub_id_table [] = {
 MODULE_DEVICE_TABLE (usb, hub_id_table);
 
 static struct usb_driver hub_driver = {
-       .owner =        THIS_MODULE,
        .name =         "hub",
        .probe =        hub_probe,
        .disconnect =   hub_disconnect,
@@ -2842,20 +2876,15 @@ static struct usb_driver hub_driver = {
 
 int usb_hub_init(void)
 {
-       pid_t pid;
-
        if (usb_register(&hub_driver) < 0) {
                printk(KERN_ERR "%s: can't register hub driver\n",
                        usbcore_name);
                return -1;
        }
 
-       pid = kernel_thread(hub_thread, NULL, CLONE_KERNEL);
-       if (pid >= 0) {
-               khubd_pid = pid;
-
+       khubd_task = kthread_run(hub_thread, NULL, "khubd");
+       if (!IS_ERR(khubd_task))
                return 0;
-       }
 
        /* Fall through if kernel_thread failed */
        usb_deregister(&hub_driver);
@@ -2866,12 +2895,7 @@ int usb_hub_init(void)
 
 void usb_hub_cleanup(void)
 {
-       int ret;
-
-       /* Kill the thread */
-       ret = kill_proc(khubd_pid, SIGKILL, 1);
-
-       wait_for_completion(&khubd_exited);
+       kthread_stop(khubd_task);
 
        /*
         * Hub resources are freed for us by usb_deregister. It calls
@@ -2883,7 +2907,6 @@ void usb_hub_cleanup(void)
        usb_deregister(&hub_driver);
 } /* usb_hub_cleanup() */
 
-
 static int config_descriptors_changed(struct usb_device *udev)
 {
        unsigned                        index;