13 files changed, 483 insertions, 247 deletions

diff --git a/drivers/usb/core/Kconfig b/drivers/usb/core/Kconfig
index 2fc0f88a3d86..f493fb1eaa27 100644
--- a/drivers/usb/core/Kconfig
+++ b/drivers/usb/core/Kconfig
@@ -31,7 +31,30 @@ config USB_DEVICEFS
           For the format of the various /proc/bus/usb/ files, please read
           <file:Documentation/usb/proc_usb_info.txt>.
 
-          Most users want to say Y here.
+          Usbfs files can't handle Access Control Lists (ACL), which are the
+          default way to grant access to USB devices for untrusted users of a
+          desktop system. The usbfs functionality is replaced by real
+          device-nodes managed by udev. These nodes live in /dev/bus/usb and
+          are used by libusb.
+
+config USB_DEVICE_CLASS
+        bool "USB device class-devices (DEPRECATED)"
+        depends on USB
+        default n
+        ---help---
+          Userspace access to USB devices is granted by device-nodes exported
+          directly from the usbdev in sysfs. Old versions of the driver
+          core and udev needed additional class devices to export device nodes.
+
+          These additional devices are difficult to handle in userspace, if
+          information about USB interfaces must be available. One device contains
+          the device node, the other device contains the interface data. Both
+          devices are at the same level in sysfs (siblings) and one can't access
+          the other. The device node created directly by the usbdev is the parent
+          device of the interface and therefore easily accessible from the interface
+          event.
+
+          This option provides backward compatibility if needed.
 
 config USB_DYNAMIC_MINORS
         bool "Dynamic USB minor allocation (EXPERIMENTAL)"
diff --git a/drivers/usb/core/devices.c b/drivers/usb/core/devices.c
index aefc7987120d..6753ca059ee4 100644
--- a/drivers/usb/core/devices.c
+++ b/drivers/usb/core/devices.c
@@ -246,7 +246,6 @@ static char *usb_dump_interface_descriptor(char *start, char *end,
 
         if (start > end)
                 return start;
-        down_read(&usb_bus_type.subsys.rwsem);
         if (iface) {
                 driver_name = (iface->dev.driver
                                 ? iface->dev.driver->name
@@ -263,7 +262,6 @@ static char *usb_dump_interface_descriptor(char *start, char *end,
                          desc->bInterfaceSubClass,
                          desc->bInterfaceProtocol,
                          driver_name);
-        up_read(&usb_bus_type.subsys.rwsem);
         return start;
 }
 
diff --git a/drivers/usb/core/devio.c b/drivers/usb/core/devio.c
index 36e7a843bf91..927a181120a9 100644
--- a/drivers/usb/core/devio.c
+++ b/drivers/usb/core/devio.c
@@ -57,7 +57,6 @@
 
 #define USB_MAXBUS                      64
 #define USB_DEVICE_MAX                  USB_MAXBUS * 128
-static struct class *usb_device_class;
 
 /* Mutual exclusion for removal, open, and release */
 DEFINE_MUTEX(usbfs_mutex);
@@ -421,14 +420,11 @@ static int claimintf(struct dev_state *ps, unsigned int ifnum)
         if (test_bit(ifnum, &ps->ifclaimed))
                 return 0;
 
-        /* lock against other changes to driver bindings */
-        down_write(&usb_bus_type.subsys.rwsem);
         intf = usb_ifnum_to_if(dev, ifnum);
         if (!intf)
                 err = -ENOENT;
         else
                 err = usb_driver_claim_interface(&usbfs_driver, intf, ps);
-        up_write(&usb_bus_type.subsys.rwsem);
         if (err == 0)
                 set_bit(ifnum, &ps->ifclaimed);
         return err;
@@ -444,8 +440,6 @@ static int releaseintf(struct dev_state *ps, unsigned int ifnum)
         if (ifnum >= 8*sizeof(ps->ifclaimed))
                 return err;
         dev = ps->dev;
-        /* lock against other changes to driver bindings */
-        down_write(&usb_bus_type.subsys.rwsem);
         intf = usb_ifnum_to_if(dev, ifnum);
         if (!intf)
                 err = -ENOENT;
@@ -453,7 +447,6 @@ static int releaseintf(struct dev_state *ps, unsigned int ifnum)
                 usb_driver_release_interface(&usbfs_driver, intf);
                 err = 0;
         }
-        up_write(&usb_bus_type.subsys.rwsem);
         return err;
 }
 
@@ -520,22 +513,25 @@ static int check_ctrlrecip(struct dev_state *ps, unsigned int requesttype, unsig
         return ret;
 }
 
-static struct usb_device *usbdev_lookup_minor(int minor)
+static int __match_minor(struct device *dev, void *data)
 {
-        struct device *device;
-        struct usb_device *udev = NULL;
+        int minor = *((int *)data);
 
-        down(&usb_device_class->sem);
-        list_for_each_entry(device, &usb_device_class->devices, node) {
-                if (device->devt == MKDEV(USB_DEVICE_MAJOR, minor)) {
-                        udev = device->platform_data;
-                        break;
-                }
-        }
-        up(&usb_device_class->sem);
+        if (dev->devt == MKDEV(USB_DEVICE_MAJOR, minor))
+                return 1;
+        return 0;
+}
 
-        return udev;
-};
+static struct usb_device *usbdev_lookup_by_minor(int minor)
+{
+        struct device *dev;
+
+        dev = bus_find_device(&usb_bus_type, NULL, &minor, __match_minor);
+        if (!dev)
+                return NULL;
+        put_device(dev);
+        return container_of(dev, struct usb_device, dev);
+}
 
 /*
  * file operations
@@ -554,11 +550,14 @@ static int usbdev_open(struct inode *inode, struct file *file)
                 goto out;
 
         ret = -ENOENT;
-        /* check if we are called from a real node or usbfs */
+        /* usbdev device-node */
         if (imajor(inode) == USB_DEVICE_MAJOR)
-                dev = usbdev_lookup_minor(iminor(inode));
+                dev = usbdev_lookup_by_minor(iminor(inode));
+#ifdef CONFIG_USB_DEVICEFS
+        /* procfs file */
         if (!dev)
                 dev = inode->i_private;
+#endif
         if (!dev)
                 goto out;
         ret = usb_autoresume_device(dev);
@@ -581,7 +580,7 @@ static int usbdev_open(struct inode *inode, struct file *file)
         ps->disccontext = NULL;
         ps->ifclaimed = 0;
         security_task_getsecid(current, &ps->secid);
-        wmb();
+        smp_wmb();
         list_add_tail(&ps->list, &dev->filelist);
         file->private_data = ps;
  out:
@@ -813,7 +812,6 @@ static int proc_getdriver(struct dev_state *ps, void __user *arg)
 
         if (copy_from_user(&gd, arg, sizeof(gd)))
                 return -EFAULT;
-        down_read(&usb_bus_type.subsys.rwsem);
         intf = usb_ifnum_to_if(ps->dev, gd.interface);
         if (!intf || !intf->dev.driver)
                 ret = -ENODATA;
@@ -822,7 +820,6 @@ static int proc_getdriver(struct dev_state *ps, void __user *arg)
                                 sizeof(gd.driver));
                 ret = (copy_to_user(arg, &gd, sizeof(gd)) ? -EFAULT : 0);
         }
-        up_read(&usb_bus_type.subsys.rwsem);
         return ret;
 }
 
@@ -1351,15 +1348,12 @@ static int proc_ioctl(struct dev_state *ps, struct usbdevfs_ioctl *ctl)
 
         /* disconnect kernel driver from interface */
         case USBDEVFS_DISCONNECT:
-
-                down_write(&usb_bus_type.subsys.rwsem);
                 if (intf->dev.driver) {
                         driver = to_usb_driver(intf->dev.driver);
                         dev_dbg (&intf->dev, "disconnect by usbfs\n");
                         usb_driver_release_interface(driver, intf);
                 } else
                         retval = -ENODATA;
-                up_write(&usb_bus_type.subsys.rwsem);
                 break;
 
         /* let kernel drivers try to (re)bind to the interface */
@@ -1371,7 +1365,6 @@ static int proc_ioctl(struct dev_state *ps, struct usbdevfs_ioctl *ctl)
 
         /* talk directly to the interface's driver */
         default:
-                down_read(&usb_bus_type.subsys.rwsem);
                 if (intf->dev.driver)
                         driver = to_usb_driver(intf->dev.driver);
                 if (driver == NULL || driver->ioctl == NULL) {
@@ -1381,7 +1374,6 @@ static int proc_ioctl(struct dev_state *ps, struct usbdevfs_ioctl *ctl)
                         if (retval == -ENOIOCTLCMD)
                                 retval = -ENOTTY;
                 }
-                up_read(&usb_bus_type.subsys.rwsem);
         }
 
         /* cleanup and return */
@@ -1583,7 +1575,7 @@ static unsigned int usbdev_poll(struct file *file, struct poll_table_struct *wai
         return mask;
 }
 
-const struct file_operations usbfs_device_file_operations = {
+const struct file_operations usbdev_file_operations = {
         .llseek =       usbdev_lseek,
         .read =         usbdev_read,
         .poll =         usbdev_poll,
@@ -1592,50 +1584,53 @@ const struct file_operations usbfs_device_file_operations = {
         .release =      usbdev_release,
 };
 
-static int usbdev_add(struct usb_device *dev)
+#ifdef CONFIG_USB_DEVICE_CLASS
+static struct class *usb_classdev_class;
+
+static int usb_classdev_add(struct usb_device *dev)
 {
         int minor = ((dev->bus->busnum-1) * 128) + (dev->devnum-1);
 
-        dev->usbfs_dev = device_create(usb_device_class, &dev->dev,
+        dev->usb_classdev = device_create(usb_classdev_class, &dev->dev,
                                 MKDEV(USB_DEVICE_MAJOR, minor),
                                 "usbdev%d.%d", dev->bus->busnum, dev->devnum);
-        if (IS_ERR(dev->usbfs_dev))
-                return PTR_ERR(dev->usbfs_dev);
+        if (IS_ERR(dev->usb_classdev))
+                return PTR_ERR(dev->usb_classdev);
 
-        dev->usbfs_dev->platform_data = dev;
         return 0;
 }
 
-static void usbdev_remove(struct usb_device *dev)
+static void usb_classdev_remove(struct usb_device *dev)
 {
-        device_unregister(dev->usbfs_dev);
+        device_unregister(dev->usb_classdev);
 }
 
-static int usbdev_notify(struct notifier_block *self, unsigned long action,
-                         void *dev)
+static int usb_classdev_notify(struct notifier_block *self,
+                               unsigned long action, void *dev)
 {
         switch (action) {
         case USB_DEVICE_ADD:
-                if (usbdev_add(dev))
+                if (usb_classdev_add(dev))
                         return NOTIFY_BAD;
                 break;
         case USB_DEVICE_REMOVE:
-                usbdev_remove(dev);
+                usb_classdev_remove(dev);
                 break;
         }
         return NOTIFY_OK;
 }
 
 static struct notifier_block usbdev_nb = {
-        .notifier_call =        usbdev_notify,
+        .notifier_call =        usb_classdev_notify,
 };
+#endif
 
 static struct cdev usb_device_cdev = {
         .kobj   = {.name = "usb_device", },
         .owner  = THIS_MODULE,
 };
 
-int __init usbdev_init(void)
+int __init usb_devio_init(void)
 {
         int retval;
 
@@ -1645,38 +1640,38 @@ int __init usbdev_init(void)
                 err("unable to register minors for usb_device");
                 goto out;
         }
-        cdev_init(&usb_device_cdev, &usbfs_device_file_operations);
+        cdev_init(&usb_device_cdev, &usbdev_file_operations);
         retval = cdev_add(&usb_device_cdev, USB_DEVICE_DEV, USB_DEVICE_MAX);
         if (retval) {
                 err("unable to get usb_device major %d", USB_DEVICE_MAJOR);
                 goto error_cdev;
         }
-        usb_device_class = class_create(THIS_MODULE, "usb_device");
-        if (IS_ERR(usb_device_class)) {
+#ifdef CONFIG_USB_DEVICE_CLASS
+        usb_classdev_class = class_create(THIS_MODULE, "usb_device");
+        if (IS_ERR(usb_classdev_class)) {
                 err("unable to register usb_device class");
-                retval = PTR_ERR(usb_device_class);
-                goto error_class;
+                retval = PTR_ERR(usb_classdev_class);
+                cdev_del(&usb_device_cdev);
+                usb_classdev_class = NULL;
+                goto out;
         }
 
         usb_register_notify(&usbdev_nb);
-
+#endif
 out:
         return retval;
 
-error_class:
-        usb_device_class = NULL;
-        cdev_del(&usb_device_cdev);
-
 error_cdev:
         unregister_chrdev_region(USB_DEVICE_DEV, USB_DEVICE_MAX);
         goto out;
 }
 
-void usbdev_cleanup(void)
+void usb_devio_cleanup(void)
 {
+#ifdef CONFIG_USB_DEVICE_CLASS
         usb_unregister_notify(&usbdev_nb);
-        class_destroy(usb_device_class);
+        class_destroy(usb_classdev_class);
+#endif
         cdev_del(&usb_device_cdev);
         unregister_chrdev_region(USB_DEVICE_DEV, USB_DEVICE_MAX);
 }
-
diff --git a/drivers/usb/core/driver.c b/drivers/usb/core/driver.c
index 9e3e943f313c..b9f7f90aef82 100644
--- a/drivers/usb/core/driver.c
+++ b/drivers/usb/core/driver.c
@@ -287,9 +287,9 @@ static int usb_unbind_interface(struct device *dev)
  * way to bind to an interface is to return the private data from
  * the driver's probe() method.
  *
- * Callers must own the device lock and the driver model's usb_bus_type.subsys
- * writelock.  So driver probe() entries don't need extra locking,
- * but other call contexts may need to explicitly claim those locks.
+ * Callers must own the device lock, so driver probe() entries don't need
+ * extra locking, but other call contexts may need to explicitly claim that
+ * lock.
  */
 int usb_driver_claim_interface(struct usb_driver *driver,
                                 struct usb_interface *iface, void* priv)
@@ -330,9 +330,9 @@ EXPORT_SYMBOL(usb_driver_claim_interface);
  * also causes the driver disconnect() method to be called.
  *
  * This call is synchronous, and may not be used in an interrupt context.
- * Callers must own the device lock and the driver model's usb_bus_type.subsys
- * writelock.  So driver disconnect() entries don't need extra locking,
- * but other call contexts may need to explicitly claim those locks.
+ * Callers must own the device lock, so driver disconnect() entries don't
+ * need extra locking, but other call contexts may need to explicitly claim
+ * that lock.
  */
 void usb_driver_release_interface(struct usb_driver *driver,
                                         struct usb_interface *iface)
@@ -574,23 +574,10 @@ static int usb_device_match(struct device *dev, struct device_driver *drv)
 }
 
 #ifdef  CONFIG_HOTPLUG
-
-/*
- * This sends an uevent to userspace, typically helping to load driver
- * or other modules, configure the device, and more.  Drivers can provide
- * a MODULE_DEVICE_TABLE to help with module loading subtasks.
- *
- * We're called either from khubd (the typical case) or from root hub
- * (init, kapmd, modprobe, rmmod, etc), but the agents need to handle
- * delays in event delivery.  Use sysfs (and DEVPATH) to make sure the
- * device (and this configuration!) are still present.
- */
 static int usb_uevent(struct device *dev, char **envp, int num_envp,
                       char *buffer, int buffer_size)
 {
-        struct usb_interface *intf;
         struct usb_device *usb_dev;
-        struct usb_host_interface *alt;
         int i = 0;
         int length = 0;
 
@@ -600,13 +587,11 @@ static int usb_uevent(struct device *dev, char **envp, int num_envp,
         /* driver is often null here; dev_dbg() would oops */
         pr_debug ("usb %s: uevent\n", dev->bus_id);
 
-        if (is_usb_device(dev)) {
+        if (is_usb_device(dev))
                 usb_dev = to_usb_device(dev);
-                alt = NULL;
-        } else {
-                intf = to_usb_interface(dev);
+        else {
+                struct usb_interface *intf = to_usb_interface(dev);
                 usb_dev = interface_to_usbdev(intf);
-                alt = intf->cur_altsetting;
         }
 
         if (usb_dev->devnum < 0) {
@@ -621,9 +606,7 @@ static int usb_uevent(struct device *dev, char **envp, int num_envp,
 #ifdef  CONFIG_USB_DEVICEFS
         /* If this is available, userspace programs can directly read
          * all the device descriptors we don't tell them about.  Or
-         * even act as usermode drivers.
-         *
-         * FIXME reduce hardwired intelligence here
+         * act as usermode drivers.
          */
         if (add_uevent_var(envp, num_envp, &i,
                            buffer, buffer_size, &length,
@@ -650,44 +633,29 @@ static int usb_uevent(struct device *dev, char **envp, int num_envp,
                            usb_dev->descriptor.bDeviceProtocol))
                 return -ENOMEM;
 
-        if (!is_usb_device(dev)) {
-
-                if (add_uevent_var(envp, num_envp, &i,
+        if (add_uevent_var(envp, num_envp, &i,
                            buffer, buffer_size, &length,
-                           "INTERFACE=%d/%d/%d",
-                           alt->desc.bInterfaceClass,
-                           alt->desc.bInterfaceSubClass,
-                           alt->desc.bInterfaceProtocol))
-                        return -ENOMEM;
+                           "BUSNUM=%03d",
+                           usb_dev->bus->busnum))
+                return -ENOMEM;
 
-                if (add_uevent_var(envp, num_envp, &i,
+        if (add_uevent_var(envp, num_envp, &i,
                            buffer, buffer_size, &length,
-                           "MODALIAS=usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02Xic%02Xisc%02Xip%02X",
-                           le16_to_cpu(usb_dev->descriptor.idVendor),
-                           le16_to_cpu(usb_dev->descriptor.idProduct),
-                           le16_to_cpu(usb_dev->descriptor.bcdDevice),
-                           usb_dev->descriptor.bDeviceClass,
-                           usb_dev->descriptor.bDeviceSubClass,
-                           usb_dev->descriptor.bDeviceProtocol,
-                           alt->desc.bInterfaceClass,
-                           alt->desc.bInterfaceSubClass,
-                           alt->desc.bInterfaceProtocol))
-                        return -ENOMEM;
-        }
+                           "DEVNUM=%03d",
+                           usb_dev->devnum))
+                return -ENOMEM;
 
         envp[i] = NULL;
-
         return 0;
 }
 
 #else
 
 static int usb_uevent(struct device *dev, char **envp,
-                        int num_envp, char *buffer, int buffer_size)
+                      int num_envp, char *buffer, int buffer_size)
 {
         return -ENODEV;
 }
-
 #endif  /* CONFIG_HOTPLUG */
 
 /**
@@ -872,8 +840,10 @@ static int usb_resume_device(struct usb_device *udev)
 
 done:
         // dev_dbg(&udev->dev, "%s: status %d\n", __FUNCTION__, status);
-        if (status == 0)
+        if (status == 0) {
+                udev->autoresume_disabled = 0;
                 udev->dev.power.power_state.event = PM_EVENT_ON;
+        }
         return status;
 }
 
@@ -962,6 +932,7 @@ static int autosuspend_check(struct usb_device *udev)
 {
         int                     i;
         struct usb_interface    *intf;
+        unsigned long           suspend_time;
 
         /* For autosuspend, fail fast if anything is in use or autosuspend
          * is disabled.  Also fail if any interfaces require remote wakeup
@@ -970,9 +941,10 @@ static int autosuspend_check(struct usb_device *udev)
         udev->do_remote_wakeup = device_may_wakeup(&udev->dev);
         if (udev->pm_usage_cnt > 0)
                 return -EBUSY;
-        if (!udev->autosuspend_delay)
+        if (udev->autosuspend_delay < 0 || udev->autosuspend_disabled)
                 return -EPERM;
 
+        suspend_time = udev->last_busy + udev->autosuspend_delay;
         if (udev->actconfig) {
                 for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
                         intf = udev->actconfig->interface[i];
@@ -988,6 +960,24 @@ static int autosuspend_check(struct usb_device *udev)
                         }
                 }
         }
+
+        /* If everything is okay but the device hasn't been idle for long
+         * enough, queue a delayed autosuspend request.
+         */
+        if (time_after(suspend_time, jiffies)) {
+                if (!timer_pending(&udev->autosuspend.timer)) {
+
+                        /* The value of jiffies may change between the
+                         * time_after() comparison above and the subtraction
+                         * below.  That's okay; the system behaves sanely
+                         * when a timer is registered for the present moment
+                         * or for the past.
+                         */
+                        queue_delayed_work(ksuspend_usb_wq, &udev->autosuspend,
+                                        suspend_time - jiffies);
+                        }
+                return -EAGAIN;
+        }
         return 0;
 }
 
@@ -1033,26 +1023,25 @@ static int autosuspend_check(struct usb_device *udev)
  *
  * This routine can run only in process context.
  */
-int usb_suspend_both(struct usb_device *udev, pm_message_t msg)
+static 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;
+        if (udev->state == USB_STATE_NOTATTACHED ||
+                        udev->state == USB_STATE_SUSPENDED)
+                goto done;
 
         udev->do_remote_wakeup = device_may_wakeup(&udev->dev);
 
         if (udev->auto_pm) {
                 status = autosuspend_check(udev);
                 if (status < 0)
-                        return status;
+                        goto done;
         }
+        cancel_delayed_work(&udev->autosuspend);
 
         /* Suspend all the interfaces and then udev itself */
         if (udev->actconfig) {
@@ -1077,6 +1066,7 @@ int usb_suspend_both(struct usb_device *udev, pm_message_t msg)
         } else if (parent)
                 usb_autosuspend_device(parent);
 
+ done:
         // dev_dbg(&udev->dev, "%s: status %d\n", __FUNCTION__, status);
         return status;
 }
@@ -1109,7 +1099,7 @@ int usb_suspend_both(struct usb_device *udev, pm_message_t msg)
  *
  * This routine can run only in process context.
  */
-int usb_resume_both(struct usb_device *udev)
+static int usb_resume_both(struct usb_device *udev)
 {
         int                     status = 0;
         int                     i;
@@ -1117,11 +1107,17 @@ int usb_resume_both(struct usb_device *udev)
         struct usb_device       *parent = udev->parent;
 
         cancel_delayed_work(&udev->autosuspend);
-        if (udev->state == USB_STATE_NOTATTACHED)
-                return -ENODEV;
+        if (udev->state == USB_STATE_NOTATTACHED) {
+                status = -ENODEV;
+                goto done;
+        }
 
         /* Propagate the resume up the tree, if necessary */
         if (udev->state == USB_STATE_SUSPENDED) {
+                if (udev->auto_pm && udev->autoresume_disabled) {
+                        status = -EPERM;
+                        goto done;
+                }
                 if (parent) {
                         status = usb_autoresume_device(parent);
                         if (status == 0) {
@@ -1167,6 +1163,7 @@ int usb_resume_both(struct usb_device *udev)
                 }
         }
 
+ done:
         // dev_dbg(&udev->dev, "%s: status %d\n", __FUNCTION__, status);
         return status;
 }
@@ -1181,20 +1178,34 @@ static int usb_autopm_do_device(struct usb_device *udev, int inc_usage_cnt)
         int     status = 0;
 
         usb_pm_lock(udev);
+        udev->auto_pm = 1;
         udev->pm_usage_cnt += inc_usage_cnt;
         WARN_ON(udev->pm_usage_cnt < 0);
         if (inc_usage_cnt >= 0 && udev->pm_usage_cnt > 0) {
-                udev->auto_pm = 1;
-                status = usb_resume_both(udev);
+                if (udev->state == USB_STATE_SUSPENDED)
+                        status = usb_resume_both(udev);
                 if (status != 0)
                         udev->pm_usage_cnt -= inc_usage_cnt;
-        } else if (inc_usage_cnt <= 0 && autosuspend_check(udev) == 0)
-                queue_delayed_work(ksuspend_usb_wq, &udev->autosuspend,
-                                udev->autosuspend_delay);
+                else if (inc_usage_cnt)
+                        udev->last_busy = jiffies;
+        } else if (inc_usage_cnt <= 0 && udev->pm_usage_cnt <= 0) {
+                if (inc_usage_cnt)
+                        udev->last_busy = jiffies;
+                status = usb_suspend_both(udev, PMSG_SUSPEND);
+        }
         usb_pm_unlock(udev);
         return status;
 }
 
+/* usb_autosuspend_work - callback routine to autosuspend a USB device */
+void usb_autosuspend_work(struct work_struct *work)
+{
+        struct usb_device *udev =
+                container_of(work, struct usb_device, autosuspend.work);
+
+        usb_autopm_do_device(udev, 0);
+}
+
 /**
  * usb_autosuspend_device - delayed autosuspend of a USB device and its interfaces
  * @udev: the usb_device to autosuspend
@@ -1286,15 +1297,20 @@ static int usb_autopm_do_interface(struct usb_interface *intf,
         if (intf->condition == USB_INTERFACE_UNBOUND)
                 status = -ENODEV;
         else {
+                udev->auto_pm = 1;
                 intf->pm_usage_cnt += inc_usage_cnt;
                 if (inc_usage_cnt >= 0 && intf->pm_usage_cnt > 0) {
-                        udev->auto_pm = 1;
-                        status = usb_resume_both(udev);
+                        if (udev->state == USB_STATE_SUSPENDED)
+                                status = usb_resume_both(udev);
                         if (status != 0)
                                 intf->pm_usage_cnt -= inc_usage_cnt;
-                } else if (inc_usage_cnt <= 0 && autosuspend_check(udev) == 0)
-                        queue_delayed_work(ksuspend_usb_wq, &udev->autosuspend,
-                                        udev->autosuspend_delay);
+                        else if (inc_usage_cnt)
+                                udev->last_busy = jiffies;
+                } else if (inc_usage_cnt <= 0 && intf->pm_usage_cnt <= 0) {
+                        if (inc_usage_cnt)
+                                udev->last_busy = jiffies;
+                        status = usb_suspend_both(udev, PMSG_SUSPEND);
+                }
         }
         usb_pm_unlock(udev);
         return status;
@@ -1353,11 +1369,14 @@ EXPORT_SYMBOL_GPL(usb_autopm_put_interface);
  * 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).
+ *
+ * The routine increments @intf's usage counter.  (However if the
+ * autoresume fails then the counter is re-decremented.)  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
@@ -1405,50 +1424,96 @@ int usb_autopm_set_interface(struct usb_interface *intf)
 }
 EXPORT_SYMBOL_GPL(usb_autopm_set_interface);
 
+#else
+
+void usb_autosuspend_work(struct work_struct *work)
+{}
+
 #endif /* CONFIG_USB_SUSPEND */
 
-static int usb_suspend(struct device *dev, pm_message_t message)
+/**
+ * usb_external_suspend_device - external suspend of a USB device and its interfaces
+ * @udev: the usb_device to suspend
+ * @msg: Power Management message describing this state transition
+ *
+ * This routine handles external suspend requests: ones not generated
+ * internally by a USB driver (autosuspend) but rather coming from the user
+ * (via sysfs) or the PM core (system sleep).  The suspend will be carried
+ * out regardless of @udev's usage counter or those of its interfaces,
+ * and regardless of whether or not remote wakeup is enabled.  Of course,
+ * interface drivers still have the option of failing the suspend (if
+ * there are unsuspended children, for example).
+ *
+ * The caller must hold @udev's device lock.
+ */
+int usb_external_suspend_device(struct usb_device *udev, pm_message_t msg)
 {
         int     status;
 
-        if (is_usb_device(dev)) {
-                struct usb_device *udev = to_usb_device(dev);
-
-                usb_pm_lock(udev);
-                udev->auto_pm = 0;
-                status = usb_suspend_both(udev, message);
-                usb_pm_unlock(udev);
-        } else
-                status = 0;
+        usb_pm_lock(udev);
+        udev->auto_pm = 0;
+        status = usb_suspend_both(udev, msg);
+        usb_pm_unlock(udev);
         return status;
 }
 
-static int usb_resume(struct device *dev)
+/**
+ * usb_external_resume_device - external resume of a USB device and its interfaces
+ * @udev: the usb_device to resume
+ *
+ * This routine handles external resume requests: ones not generated
+ * internally by a USB driver (autoresume) but rather coming from the user
+ * (via sysfs), the PM core (system resume), or the device itself (remote
+ * wakeup).  @udev's usage counter is unaffected.
+ *
+ * The caller must hold @udev's device lock.
+ */
+int usb_external_resume_device(struct usb_device *udev)
 {
         int     status;
 
-        if (is_usb_device(dev)) {
-                struct usb_device *udev = to_usb_device(dev);
-
-                usb_pm_lock(udev);
-                udev->auto_pm = 0;
-                status = usb_resume_both(udev);
-                usb_pm_unlock(udev);
+        usb_pm_lock(udev);
+        udev->auto_pm = 0;
+        status = usb_resume_both(udev);
+        usb_pm_unlock(udev);
 
-                /* Rebind drivers that had no suspend method? */
-        } else
-                status = 0;
+        /* Now that the device is awake, we can start trying to autosuspend
+         * it again. */
+        if (status == 0)
+                usb_try_autosuspend_device(udev);
         return status;
 }
 
+static int usb_suspend(struct device *dev, pm_message_t message)
+{
+        if (!is_usb_device(dev))        /* Ignore PM for interfaces */
+                return 0;
+        return usb_external_suspend_device(to_usb_device(dev), message);
+}
+
+static int usb_resume(struct device *dev)
+{
+        struct usb_device       *udev;
+
+        if (!is_usb_device(dev))        /* Ignore PM for interfaces */
+                return 0;
+        udev = to_usb_device(dev);
+        if (udev->autoresume_disabled)
+                return -EPERM;
+        return usb_external_resume_device(udev);
+}
+
+#else
+
+#define usb_suspend     NULL
+#define usb_resume      NULL
+
 #endif /* CONFIG_PM */
 
 struct bus_type usb_bus_type = {
         .name =         "usb",
         .match =        usb_device_match,
         .uevent =       usb_uevent,
-#ifdef CONFIG_PM
         .suspend =      usb_suspend,
         .resume =       usb_resume,
-#endif
 };
diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
index b26c19e8d19f..40cf882293e6 100644
--- a/drivers/usb/core/hcd.c
+++ b/drivers/usb/core/hcd.c
@@ -37,6 +37,7 @@
 #include <asm/irq.h>
 #include <asm/byteorder.h>
 #include <linux/platform_device.h>
+#include <linux/workqueue.h>
 
 #include <linux/usb.h>
 
@@ -544,6 +545,8 @@ void usb_hcd_poll_rh_status(struct usb_hcd *hcd)
         unsigned long   flags;
         char            buffer[4];      /* Any root hubs with > 31 ports? */
 
+        if (unlikely(!hcd->rh_registered))
+                return;
         if (!hcd->uses_new_polling && !hcd->status_urb)
                 return;
 
@@ -1296,14 +1299,26 @@ int hcd_bus_resume (struct usb_bus *bus)
         return status;
 }
 
+/* Workqueue routine for root-hub remote wakeup */
+static void hcd_resume_work(struct work_struct *work)
+{
+        struct usb_hcd *hcd = container_of(work, struct usb_hcd, wakeup_work);
+        struct usb_device *udev = hcd->self.root_hub;
+
+        usb_lock_device(udev);
+        usb_mark_last_busy(udev);
+        usb_external_resume_device(udev);
+        usb_unlock_device(udev);
+}
+
 /**
  * usb_hcd_resume_root_hub - called by HCD to resume its root hub 
  * @hcd: host controller for this root hub
  *
  * The USB host controller calls this function when its root hub is
  * suspended (with the remote wakeup feature enabled) and a remote
- * wakeup request is received.  It queues a request for khubd to
- * resume the root hub (that is, manage its downstream ports again).
+ * wakeup request is received.  The routine submits a workqueue request
+ * to resume the root hub (that is, manage its downstream ports again).
  */
 void usb_hcd_resume_root_hub (struct usb_hcd *hcd)
 {
@@ -1311,7 +1326,7 @@ void usb_hcd_resume_root_hub (struct usb_hcd *hcd)
 
         spin_lock_irqsave (&hcd_root_hub_lock, flags);
         if (hcd->rh_registered)
-                usb_resume_root_hub (hcd->self.root_hub);
+                queue_work(ksuspend_usb_wq, &hcd->wakeup_work);
         spin_unlock_irqrestore (&hcd_root_hub_lock, flags);
 }
 EXPORT_SYMBOL_GPL(usb_hcd_resume_root_hub);
@@ -1500,6 +1515,9 @@ struct usb_hcd *usb_create_hcd (const struct hc_driver *driver,
         init_timer(&hcd->rh_timer);
         hcd->rh_timer.function = rh_timer_func;
         hcd->rh_timer.data = (unsigned long) hcd;
+#ifdef CONFIG_PM
+        INIT_WORK(&hcd->wakeup_work, hcd_resume_work);
+#endif
 
         hcd->driver = driver;
         hcd->product_desc = (driver->product_desc) ? driver->product_desc :
@@ -1666,16 +1684,20 @@ void usb_remove_hcd(struct usb_hcd *hcd)
         hcd->rh_registered = 0;
         spin_unlock_irq (&hcd_root_hub_lock);
 
+#ifdef CONFIG_PM
+        flush_workqueue(ksuspend_usb_wq);
+#endif
+
         mutex_lock(&usb_bus_list_lock);
         usb_disconnect(&hcd->self.root_hub);
         mutex_unlock(&usb_bus_list_lock);
 
-        hcd->poll_rh = 0;
-        del_timer_sync(&hcd->rh_timer);
-
         hcd->driver->stop(hcd);
         hcd->state = HC_STATE_HALT;
 
+        hcd->poll_rh = 0;
+        del_timer_sync(&hcd->rh_timer);
+
         if (hcd->irq >= 0)
                 free_irq(hcd->irq, hcd);
         usb_deregister_bus(&hcd->self);
diff --git a/drivers/usb/core/hcd.h b/drivers/usb/core/hcd.h
index 2a269ca20517..ef50fa494e47 100644
--- a/drivers/usb/core/hcd.h
+++ b/drivers/usb/core/hcd.h
@@ -68,6 +68,9 @@ struct usb_hcd {
 
         struct timer_list       rh_timer;       /* drives root-hub polling */
         struct urb              *status_urb;    /* the current status urb */
+#ifdef CONFIG_PM
+        struct work_struct      wakeup_work;    /* for remote wakeup */
+#endif
 
         /*
          * hardware info/state
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index b89a98e61323..bde29ab2b504 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -119,8 +119,7 @@ MODULE_PARM_DESC(use_both_schemes,
                 "first one fails");
 
 
-#ifdef  DEBUG
-static inline char *portspeed (int portstatus)
+static inline char *portspeed(int portstatus)
 {
         if (portstatus & (1 << USB_PORT_FEAT_HIGHSPEED))
                 return "480 Mb/s";
@@ -129,7 +128,6 @@ static inline char *portspeed (int portstatus)
         else
                 return "12 Mb/s";
 }
-#endif
 
 /* Note that hdev or one of its children must be locked! */
 static inline struct usb_hub *hdev_to_hub(struct usb_device *hdev)
@@ -1369,11 +1367,15 @@ int usb_new_device(struct usb_device *udev)
         }
 #endif
 
+        /* export the usbdev device-node for libusb */
+        udev->dev.devt = MKDEV(USB_DEVICE_MAJOR,
+                        (((udev->bus->busnum-1) * 128) + (udev->devnum-1)));
+
         /* Register the device.  The device driver is responsible
-         * for adding the device files to usbfs and sysfs and for
-         * configuring the device.
+         * for adding the device files to sysfs and for configuring
+         * the device.
          */
-        err = device_add (&udev->dev);
+        err = device_add(&udev->dev);
         if (err) {
                 dev_err(&udev->dev, "can't device_add, error %d\n", err);
                 goto fail;
@@ -1857,12 +1859,8 @@ static int remote_wakeup(struct usb_device *udev)
         usb_lock_device(udev);
         if (udev->state == USB_STATE_SUSPENDED) {
                 dev_dbg(&udev->dev, "usb %sresume\n", "wakeup-");
-                status = usb_autoresume_device(udev);
-
-                /* Give the interface drivers a chance to do something,
-                 * then autosuspend the device again. */
-                if (status == 0)
-                        usb_autosuspend_device(udev);
+                usb_mark_last_busy(udev);
+                status = usb_external_resume_device(udev);
         }
         usb_unlock_device(udev);
         return status;
@@ -1986,13 +1984,6 @@ static inline int remote_wakeup(struct usb_device *udev)
 #define hub_resume NULL
 #endif
 
-void usb_resume_root_hub(struct usb_device *hdev)
-{
-        struct usb_hub *hub = hdev_to_hub(hdev);
-
-        kick_khubd(hub);
-}
-
 
 /* USB 2.0 spec, 7.1.7.3 / fig 7-29:
  *
diff --git a/drivers/usb/core/inode.c b/drivers/usb/core/inode.c
index 11dad22da41c..cddfc62c4611 100644
--- a/drivers/usb/core/inode.c
+++ b/drivers/usb/core/inode.c
@@ -662,7 +662,7 @@ static void usbfs_add_device(struct usb_device *dev)
         sprintf (name, "%03d", dev->devnum);
         dev->usbfs_dentry = fs_create_file (name, devmode | S_IFREG,
                                             dev->bus->usbfs_dentry, dev,
-                                            &usbfs_device_file_operations,
+                                            &usbdev_file_operations,
                                             devuid, devgid);
         if (dev->usbfs_dentry == NULL) {
                 err ("error creating usbfs device entry");
diff --git a/drivers/usb/core/message.c b/drivers/usb/core/message.c
index 217a3d6d0a06..b7434787db5f 100644
--- a/drivers/usb/core/message.c
+++ b/drivers/usb/core/message.c
@@ -412,10 +412,24 @@ int usb_sg_init (
                 io->urbs [i]->status = -EINPROGRESS;
                 io->urbs [i]->actual_length = 0;
 
+                /*
+                 * Some systems need to revert to PIO when DMA is temporarily
+                 * unavailable.  For their sakes, both transfer_buffer and
+                 * transfer_dma are set when possible.  However this can only
+                 * work on systems without HIGHMEM, since DMA buffers located
+                 * in high memory are not directly addressable by the CPU for
+                 * PIO ... so when HIGHMEM is in use, transfer_buffer is NULL
+                 * to prevent stale pointers and to help spot bugs.
+                 */
                 if (dma) {
-                        /* hc may use _only_ transfer_dma */
                         io->urbs [i]->transfer_dma = sg_dma_address (sg + i);
                         len = sg_dma_len (sg + i);
+#ifdef CONFIG_HIGHMEM
+                        io->urbs[i]->transfer_buffer = NULL;
+#else
+                        io->urbs[i]->transfer_buffer =
+                                page_address(sg[i].page) + sg[i].offset;
+#endif
                 } else {
                         /* hc may use _only_ transfer_buffer */
                         io->urbs [i]->transfer_buffer =
@@ -1305,7 +1319,7 @@ int usb_reset_configuration(struct usb_device *dev)
         return 0;
 }
 
-static void release_interface(struct device *dev)
+void usb_release_interface(struct device *dev)
 {
         struct usb_interface *intf = to_usb_interface(dev);
         struct usb_interface_cache *intfc =
@@ -1315,6 +1329,67 @@ static void release_interface(struct device *dev)
         kfree(intf);
 }
 
+#ifdef  CONFIG_HOTPLUG
+static int usb_if_uevent(struct device *dev, char **envp, int num_envp,
+                 char *buffer, int buffer_size)
+{
+        struct usb_device *usb_dev;
+        struct usb_interface *intf;
+        struct usb_host_interface *alt;
+        int i = 0;
+        int length = 0;
+
+        if (!dev)
+                return -ENODEV;
+
+        /* driver is often null here; dev_dbg() would oops */
+        pr_debug ("usb %s: uevent\n", dev->bus_id);
+
+        intf = to_usb_interface(dev);
+        usb_dev = interface_to_usbdev(intf);
+        alt = intf->cur_altsetting;
+
+        if (add_uevent_var(envp, num_envp, &i,
+                   buffer, buffer_size, &length,
+                   "INTERFACE=%d/%d/%d",
+                   alt->desc.bInterfaceClass,
+                   alt->desc.bInterfaceSubClass,
+                   alt->desc.bInterfaceProtocol))
+                return -ENOMEM;
+
+        if (add_uevent_var(envp, num_envp, &i,
+                   buffer, buffer_size, &length,
+                   "MODALIAS=usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02Xic%02Xisc%02Xip%02X",
+                   le16_to_cpu(usb_dev->descriptor.idVendor),
+                   le16_to_cpu(usb_dev->descriptor.idProduct),
+                   le16_to_cpu(usb_dev->descriptor.bcdDevice),
+                   usb_dev->descriptor.bDeviceClass,
+                   usb_dev->descriptor.bDeviceSubClass,
+                   usb_dev->descriptor.bDeviceProtocol,
+                   alt->desc.bInterfaceClass,
+                   alt->desc.bInterfaceSubClass,
+                   alt->desc.bInterfaceProtocol))
+                return -ENOMEM;
+
+        envp[i] = NULL;
+        return 0;
+}
+
+#else
+
+static int usb_if_uevent(struct device *dev, char **envp,
+                         int num_envp, char *buffer, int buffer_size)
+{
+        return -ENODEV;
+}
+#endif  /* CONFIG_HOTPLUG */
+
+struct device_type usb_if_device_type = {
+        .name =         "usb_interface",
+        .release =      usb_release_interface,
+        .uevent =       usb_if_uevent,
+};
+
 /*
  * usb_set_configuration - Makes a particular device setting be current
  * @dev: the device whose configuration is being updated
@@ -1349,7 +1424,7 @@ static void release_interface(struct device *dev)
  *
  * This call is synchronous. The calling context must be able to sleep,
  * must own the device lock, and must not hold the driver model's USB
- * bus rwsem; usb device driver probe() methods cannot use this routine.
+ * bus mutex; usb device driver probe() methods cannot use this routine.
  *
  * Returns zero on success, or else the status code returned by the
  * underlying call that failed.  On successful completion, each interface
@@ -1478,8 +1553,8 @@ free_interfaces:
                 intf->dev.parent = &dev->dev;
                 intf->dev.driver = NULL;
                 intf->dev.bus = &usb_bus_type;
+                intf->dev.type = &usb_if_device_type;
                 intf->dev.dma_mask = dev->dev.dma_mask;
-                intf->dev.release = release_interface;
                 device_initialize (&intf->dev);
                 mark_quiesced(intf);
                 sprintf (&intf->dev.bus_id[0], "%d-%s:%d.%d",
diff --git a/drivers/usb/core/quirks.c b/drivers/usb/core/quirks.c
index f08ec85a6d64..739f520908aa 100644
--- a/drivers/usb/core/quirks.c
+++ b/drivers/usb/core/quirks.c
@@ -42,7 +42,7 @@ static void usb_autosuspend_quirk(struct usb_device *udev)
 {
 #ifdef  CONFIG_USB_SUSPEND
         /* disable autosuspend, but allow the user to re-enable it via sysfs */
-        udev->autosuspend_delay = 0;
+        udev->autosuspend_disabled = 1;
 #endif
 }
 
diff --git a/drivers/usb/core/sysfs.c b/drivers/usb/core/sysfs.c
index 311d5df80386..e7c982377488 100644
--- a/drivers/usb/core/sysfs.c
+++ b/drivers/usb/core/sysfs.c
@@ -11,6 +11,7 @@
 
 
 #include <linux/kernel.h>
+#include <linux/string.h>
 #include <linux/usb.h>
 #include "usb.h"
 
@@ -117,6 +118,16 @@ show_speed(struct device *dev, struct device_attribute *attr, char *buf)
 static DEVICE_ATTR(speed, S_IRUGO, show_speed, NULL);
 
 static ssize_t
+show_busnum(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        struct usb_device *udev;
+
+        udev = to_usb_device(dev);
+        return sprintf(buf, "%d\n", udev->bus->busnum);
+}
+static DEVICE_ATTR(busnum, S_IRUGO, show_busnum, NULL);
+
+static ssize_t
 show_devnum(struct device *dev, struct device_attribute *attr, char *buf)
 {
         struct usb_device *udev;
@@ -165,7 +176,7 @@ show_autosuspend(struct device *dev, struct device_attribute *attr, char *buf)
 {
         struct usb_device *udev = to_usb_device(dev);
 
-        return sprintf(buf, "%u\n", udev->autosuspend_delay / HZ);
+        return sprintf(buf, "%d\n", udev->autosuspend_delay / HZ);
 }
 
 static ssize_t
@@ -173,39 +184,115 @@ set_autosuspend(struct device *dev, struct device_attribute *attr,
                 const char *buf, size_t count)
 {
         struct usb_device *udev = to_usb_device(dev);
-        unsigned value, old;
+        int value;
 
-        if (sscanf(buf, "%u", &value) != 1 || value >= INT_MAX/HZ)
+        if (sscanf(buf, "%d", &value) != 1 || value >= INT_MAX/HZ ||
+                        value <= - INT_MAX/HZ)
                 return -EINVAL;
         value *= HZ;
 
-        old = udev->autosuspend_delay;
         udev->autosuspend_delay = value;
-        if (value > 0 && old == 0)
+        if (value >= 0)
                 usb_try_autosuspend_device(udev);
-
+        else {
+                if (usb_autoresume_device(udev) == 0)
+                        usb_autosuspend_device(udev);
+        }
         return count;
 }
 
 static DEVICE_ATTR(autosuspend, S_IRUGO | S_IWUSR,
                 show_autosuspend, set_autosuspend);
 
+static const char on_string[] = "on";
+static const char auto_string[] = "auto";
+static const char suspend_string[] = "suspend";
+
+static ssize_t
+show_level(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        struct usb_device *udev = to_usb_device(dev);
+        const char *p = auto_string;
+
+        if (udev->state == USB_STATE_SUSPENDED) {
+                if (udev->autoresume_disabled)
+                        p = suspend_string;
+        } else {
+                if (udev->autosuspend_disabled)
+                        p = on_string;
+        }
+        return sprintf(buf, "%s\n", p);
+}
+
+static ssize_t
+set_level(struct device *dev, struct device_attribute *attr,
+                const char *buf, size_t count)
+{
+        struct usb_device *udev = to_usb_device(dev);
+        int len = count;
+        char *cp;
+        int rc = 0;
+
+        cp = memchr(buf, '\n', count);
+        if (cp)
+                len = cp - buf;
+
+        usb_lock_device(udev);
+
+        /* Setting the flags without calling usb_pm_lock is a subject to
+         * races, but who cares...
+         */
+        if (len == sizeof on_string - 1 &&
+                        strncmp(buf, on_string, len) == 0) {
+                udev->autosuspend_disabled = 1;
+                udev->autoresume_disabled = 0;
+                rc = usb_external_resume_device(udev);
+
+        } else if (len == sizeof auto_string - 1 &&
+                        strncmp(buf, auto_string, len) == 0) {
+                udev->autosuspend_disabled = 0;
+                udev->autoresume_disabled = 0;
+                rc = usb_external_resume_device(udev);
+
+        } else if (len == sizeof suspend_string - 1 &&
+                        strncmp(buf, suspend_string, len) == 0) {
+                udev->autosuspend_disabled = 0;
+                udev->autoresume_disabled = 1;
+                rc = usb_external_suspend_device(udev, PMSG_SUSPEND);
+
+        } else
+                rc = -EINVAL;
+
+        usb_unlock_device(udev);
+        return (rc < 0 ? rc : count);
+}
+
+static DEVICE_ATTR(level, S_IRUGO | S_IWUSR, show_level, set_level);
+
 static char power_group[] = "power";
 
 static int add_power_attributes(struct device *dev)
 {
         int rc = 0;
 
-        if (is_usb_device(dev))
+        if (is_usb_device(dev)) {
                 rc = sysfs_add_file_to_group(&dev->kobj,
                                 &dev_attr_autosuspend.attr,
                                 power_group);
+                if (rc == 0)
+                        rc = sysfs_add_file_to_group(&dev->kobj,
+                                        &dev_attr_level.attr,
+                                        power_group);
+        }
         return rc;
 }
 
 static void remove_power_attributes(struct device *dev)
 {
         sysfs_remove_file_from_group(&dev->kobj,
+                        &dev_attr_level.attr,
+                        power_group);
+        sysfs_remove_file_from_group(&dev->kobj,
                         &dev_attr_autosuspend.attr,
                         power_group);
 }
@@ -270,6 +357,7 @@ static struct attribute *dev_attrs[] = {
         &dev_attr_bNumConfigurations.attr,
         &dev_attr_bMaxPacketSize0.attr,
         &dev_attr_speed.attr,
+        &dev_attr_busnum.attr,
         &dev_attr_devnum.attr,
         &dev_attr_version.attr,
         &dev_attr_maxchild.attr,
diff --git a/drivers/usb/core/usb.c b/drivers/usb/core/usb.c
index 54b42ce311c1..dfd1b5c87ca3 100644
--- a/drivers/usb/core/usb.c
+++ b/drivers/usb/core/usb.c
@@ -49,12 +49,13 @@ const char *usbcore_name = "usbcore";
 
 static int nousb;       /* Disable USB when built into kernel image */
 
-struct workqueue_struct *ksuspend_usb_wq;       /* For autosuspend */
+/* Workqueue for autosuspend and for remote wakeup of root hubs */
+struct workqueue_struct *ksuspend_usb_wq;
 
 #ifdef  CONFIG_USB_SUSPEND
 static int usb_autosuspend_delay = 2;           /* Default delay value,
                                                  * in seconds */
-module_param_named(autosuspend, usb_autosuspend_delay, uint, 0644);
+module_param_named(autosuspend, usb_autosuspend_delay, int, 0644);
 MODULE_PARM_DESC(autosuspend, "default autosuspend delay");
 
 #else
@@ -196,6 +197,11 @@ static void usb_release_dev(struct device *dev)
         kfree(udev);
 }
 
+struct device_type usb_device_type = {
+        .name =         "usb_device",
+        .release =      usb_release_dev,
+};
+
 #ifdef  CONFIG_PM
 
 static int ksuspend_usb_init(void)
@@ -211,27 +217,6 @@ static void ksuspend_usb_cleanup(void)
         destroy_workqueue(ksuspend_usb_wq);
 }
 
-#ifdef  CONFIG_USB_SUSPEND
-
-/* usb_autosuspend_work - callback routine to autosuspend a USB device */
-static void usb_autosuspend_work(struct work_struct *work)
-{
-        struct usb_device *udev =
-                container_of(work, struct usb_device, autosuspend.work);
-
-        usb_pm_lock(udev);
-        udev->auto_pm = 1;
-        usb_suspend_both(udev, PMSG_SUSPEND);
-        usb_pm_unlock(udev);
-}
-
-#else
-
-static void usb_autosuspend_work(struct work_struct *work)
-{}
-
-#endif  /* CONFIG_USB_SUSPEND */
-
 #else
 
 #define ksuspend_usb_init()     0
@@ -267,13 +252,10 @@ usb_alloc_dev(struct usb_device *parent, struct usb_bus *bus, unsigned port1)
 
         device_initialize(&dev->dev);
         dev->dev.bus = &usb_bus_type;
+        dev->dev.type = &usb_device_type;
         dev->dev.dma_mask = bus->controller->dma_mask;
-        dev->dev.release = usb_release_dev;
         dev->state = USB_STATE_ATTACHED;
 
-        /* This magic assignment distinguishes devices from interfaces */
-        dev->dev.platform_data = &usb_generic_driver;
-
         INIT_LIST_HEAD(&dev->ep0.urb_list);
         dev->ep0.desc.bLength = USB_DT_ENDPOINT_SIZE;
         dev->ep0.desc.bDescriptorType = USB_DT_ENDPOINT;
@@ -902,9 +884,9 @@ static int __init usb_init(void)
         retval = usb_register(&usbfs_driver);
         if (retval)
                 goto driver_register_failed;
-        retval = usbdev_init();
+        retval = usb_devio_init();
         if (retval)
-                goto usbdevice_init_failed;
+                goto usb_devio_init_failed;
         retval = usbfs_init();
         if (retval)
                 goto fs_init_failed;
@@ -919,8 +901,8 @@ static int __init usb_init(void)
 hub_init_failed:
         usbfs_cleanup();
 fs_init_failed:
-        usbdev_cleanup();
-usbdevice_init_failed:
+        usb_devio_cleanup();
+usb_devio_init_failed:
         usb_deregister(&usbfs_driver);
 driver_register_failed:
         usb_major_cleanup();
@@ -947,7 +929,7 @@ static void __exit usb_exit(void)
         usb_major_cleanup();
         usbfs_cleanup();
         usb_deregister(&usbfs_driver);
-        usbdev_cleanup();
+        usb_devio_cleanup();
         usb_hub_cleanup();
         usb_host_cleanup();
         bus_unregister(&usb_bus_type);
diff --git a/drivers/usb/core/usb.h b/drivers/usb/core/usb.h
index 08b5a04e3755..bf2eb0dae2ec 100644
--- a/drivers/usb/core/usb.h
+++ b/drivers/usb/core/usb.h
@@ -21,7 +21,6 @@ extern char *usb_cache_string(struct usb_device *udev, int index);
 extern int usb_set_configuration(struct usb_device *dev, int configuration);
 
 extern void usb_kick_khubd(struct usb_device *dev);
-extern void usb_resume_root_hub(struct usb_device *dev);
 extern int usb_match_device(struct usb_device *dev,
                             const struct usb_device_id *id);
 
@@ -34,10 +33,12 @@ extern void usb_host_cleanup(void);
 
 #ifdef  CONFIG_PM
 
-extern int usb_suspend_both(struct usb_device *udev, pm_message_t msg);
-extern int usb_resume_both(struct usb_device *udev);
+extern void usb_autosuspend_work(struct work_struct *work);
 extern int usb_port_suspend(struct usb_device *dev);
 extern int usb_port_resume(struct usb_device *dev);
+extern int usb_external_suspend_device(struct usb_device *udev,
+                pm_message_t msg);
+extern int usb_external_resume_device(struct usb_device *udev);
 
 static inline void usb_pm_lock(struct usb_device *udev)
 {
@@ -51,11 +52,6 @@ static inline void usb_pm_unlock(struct usb_device *udev)
 
 #else
 
-#define usb_suspend_both(udev, msg)     0
-static inline int usb_resume_both(struct usb_device *udev)
-{
-        return 0;
-}
 #define usb_port_suspend(dev)           0
 #define usb_port_resume(dev)            0
 static inline void usb_pm_lock(struct usb_device *udev) {}
@@ -82,15 +78,13 @@ static inline int usb_autoresume_device(struct usb_device *udev)
 
 extern struct workqueue_struct *ksuspend_usb_wq;
 extern struct bus_type usb_bus_type;
+extern struct device_type usb_device_type;
+extern struct device_type usb_if_device_type;
 extern struct usb_device_driver usb_generic_driver;
 
-/* Here's how we tell apart devices and interfaces.  Luckily there's
- * no such thing as a platform USB device, so we can steal the use
- * of the platform_data field. */
-
 static inline int is_usb_device(const struct device *dev)
 {
-        return dev->platform_data == &usb_generic_driver;
+        return dev->type == &usb_device_type;
 }
 
 /* Do the same for device drivers and interface drivers. */
@@ -126,11 +120,11 @@ extern const char *usbcore_name;
 extern struct mutex usbfs_mutex;
 extern struct usb_driver usbfs_driver;
 extern const struct file_operations usbfs_devices_fops;
-extern const struct file_operations usbfs_device_file_operations;
+extern const struct file_operations usbdev_file_operations;
 extern void usbfs_conn_disc_event(void);
 
-extern int usbdev_init(void);
-extern void usbdev_cleanup(void);
+extern int usb_devio_init(void);
+extern void usb_devio_cleanup(void);
 
 struct dev_state {
         struct list_head list;      /* state list */