Merge rsync://rsync.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6

11 files changed, 591 insertions, 358 deletions

diff --git a/drivers/usb/core/Makefile b/drivers/usb/core/Makefile
index 28329ddf187c..ec510922af63 100644
--- a/drivers/usb/core/Makefile
+++ b/drivers/usb/core/Makefile
@@ -3,7 +3,8 @@
 #
 
 usbcore-objs    := usb.o hub.o hcd.o urb.o message.o driver.o \
-                        config.o file.o buffer.o sysfs.o devio.o notify.o
+                        config.o file.o buffer.o sysfs.o endpoint.o \
+                        devio.o notify.o
 
 ifeq ($(CONFIG_PCI),y)
         usbcore-objs    += hcd-pci.o
diff --git a/drivers/usb/core/devio.c b/drivers/usb/core/devio.c
index 545da37afca7..bcbeaf7101d1 100644
--- a/drivers/usb/core/devio.c
+++ b/drivers/usb/core/devio.c
@@ -515,19 +515,19 @@ static int check_ctrlrecip(struct dev_state *ps, unsigned int requesttype, unsig
 
 static struct usb_device *usbdev_lookup_minor(int minor)
 {
-        struct class_device *class_dev;
-        struct usb_device *dev = NULL;
+        struct device *device;
+        struct usb_device *udev = NULL;
 
         down(&usb_device_class->sem);
-        list_for_each_entry(class_dev, &usb_device_class->children, node) {
-                if (class_dev->devt == MKDEV(USB_DEVICE_MAJOR, minor)) {
-                        dev = class_dev->class_data;
+        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);
 
-        return dev;
+        return udev;
 };
 
 /*
@@ -823,8 +823,7 @@ static int proc_connectinfo(struct dev_state *ps, void __user *arg)
 
 static int proc_resetdevice(struct dev_state *ps)
 {
-        return usb_reset_device(ps->dev);
-
+        return usb_reset_composite_device(ps->dev, NULL);
 }
 
 static int proc_setintf(struct dev_state *ps, void __user *arg)
@@ -923,8 +922,8 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
                 if ((ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
                                 != USB_ENDPOINT_XFER_CONTROL)
                         return -EINVAL;
-                /* min 8 byte setup packet, max arbitrary */
-                if (uurb->buffer_length < 8 || uurb->buffer_length > PAGE_SIZE)
+                /* min 8 byte setup packet, max 8 byte setup plus an arbitrary data stage */
+                if (uurb->buffer_length < 8 || uurb->buffer_length > (8 + MAX_USBFS_BUFFER_SIZE))
                         return -EINVAL;
                 if (!(dr = kmalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL)))
                         return -ENOMEM;
@@ -982,7 +981,8 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
                         return -EFAULT;
                 }
                 for (totlen = u = 0; u < uurb->number_of_packets; u++) {
-                        if (isopkt[u].length > 1023) {
+                        /* arbitrary limit, sufficient for USB 2.0 high-bandwidth iso */
+                        if (isopkt[u].length > 8192) {
                                 kfree(isopkt);
                                 return -EINVAL;
                         }
@@ -1576,16 +1576,16 @@ static void usbdev_add(struct usb_device *dev)
 {
         int minor = ((dev->bus->busnum-1) * 128) + (dev->devnum-1);
 
-        dev->class_dev = class_device_create(usb_device_class, NULL,
-                                MKDEV(USB_DEVICE_MAJOR, minor), &dev->dev,
+        dev->usbfs_dev = device_create(usb_device_class, &dev->dev,
+                                MKDEV(USB_DEVICE_MAJOR, minor),
                                 "usbdev%d.%d", dev->bus->busnum, dev->devnum);
 
-        dev->class_dev->class_data = dev;
+        dev->usbfs_dev->platform_data = dev;
 }
 
 static void usbdev_remove(struct usb_device *dev)
 {
-        class_device_unregister(dev->class_dev);
+        device_unregister(dev->usbfs_dev);
 }
 
 static int usbdev_notify(struct notifier_block *self, unsigned long action,
diff --git a/drivers/usb/core/endpoint.c b/drivers/usb/core/endpoint.c
new file mode 100644
index 000000000000..247b5a4913a8
--- /dev/null
+++ b/drivers/usb/core/endpoint.c
@@ -0,0 +1,275 @@
+/*
+ * drivers/usb/core/endpoint.c
+ *
+ * (C) Copyright 2002,2004,2006 Greg Kroah-Hartman
+ * (C) Copyright 2002,2004 IBM Corp.
+ * (C) Copyright 2006 Novell Inc.
+ *
+ * Endpoint sysfs stuff
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/usb.h>
+#include "usb.h"
+
+/* endpoint stuff */
+
+struct ep_device {
+        struct usb_endpoint_descriptor *desc;
+        struct usb_device *udev;
+        struct device dev;
+};
+#define to_ep_device(_dev) \
+        container_of(_dev, struct ep_device, dev)
+
+struct ep_attribute {
+        struct attribute attr;
+        ssize_t (*show)(struct usb_device *,
+                        struct usb_endpoint_descriptor *, char *);
+};
+#define to_ep_attribute(_attr) \
+        container_of(_attr, struct ep_attribute, attr)
+
+#define usb_ep_attr(field, format_string)                       \
+static ssize_t show_ep_##field(struct device *dev,              \
+                               struct device_attribute *attr,   \
+                               char *buf)                       \
+{                                                               \
+        struct ep_device *ep = to_ep_device(dev);               \
+        return sprintf(buf, format_string, ep->desc->field);    \
+}                                                               \
+static DEVICE_ATTR(field, S_IRUGO, show_ep_##field, NULL);
+
+usb_ep_attr(bLength, "%02x\n")
+usb_ep_attr(bEndpointAddress, "%02x\n")
+usb_ep_attr(bmAttributes, "%02x\n")
+usb_ep_attr(bInterval, "%02x\n")
+
+static ssize_t show_ep_wMaxPacketSize(struct device *dev,
+                                      struct device_attribute *attr, char *buf)
+{
+        struct ep_device *ep = to_ep_device(dev);
+        return sprintf(buf, "%04x\n",
+                        le16_to_cpu(ep->desc->wMaxPacketSize) & 0x07ff);
+}
+static DEVICE_ATTR(wMaxPacketSize, S_IRUGO, show_ep_wMaxPacketSize, NULL);
+
+static ssize_t show_ep_type(struct device *dev, struct device_attribute *attr,
+                            char *buf)
+{
+        struct ep_device *ep = to_ep_device(dev);
+        char *type = "unknown";
+
+        switch (ep->desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
+        case USB_ENDPOINT_XFER_CONTROL:
+                type = "Control";
+                break;
+        case USB_ENDPOINT_XFER_ISOC:
+                type = "Isoc";
+                break;
+        case USB_ENDPOINT_XFER_BULK:
+                type = "Bulk";
+                break;
+        case USB_ENDPOINT_XFER_INT:
+                type = "Interrupt";
+                break;
+        }
+        return sprintf(buf, "%s\n", type);
+}
+static DEVICE_ATTR(type, S_IRUGO, show_ep_type, NULL);
+
+static ssize_t show_ep_interval(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        struct ep_device *ep = to_ep_device(dev);
+        char unit;
+        unsigned interval = 0;
+        unsigned in;
+
+        in = (ep->desc->bEndpointAddress & USB_DIR_IN);
+
+        switch (ep->desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
+        case USB_ENDPOINT_XFER_CONTROL:
+                if (ep->udev->speed == USB_SPEED_HIGH)  /* uframes per NAK */
+                        interval = ep->desc->bInterval;
+                break;
+        case USB_ENDPOINT_XFER_ISOC:
+                interval = 1 << (ep->desc->bInterval - 1);
+                break;
+        case USB_ENDPOINT_XFER_BULK:
+                if (ep->udev->speed == USB_SPEED_HIGH && !in) /* uframes per NAK */
+                        interval = ep->desc->bInterval;
+                break;
+        case USB_ENDPOINT_XFER_INT:
+                if (ep->udev->speed == USB_SPEED_HIGH)
+                        interval = 1 << (ep->desc->bInterval - 1);
+                else
+                        interval = ep->desc->bInterval;
+                break;
+        }
+        interval *= (ep->udev->speed == USB_SPEED_HIGH) ? 125 : 1000;
+        if (interval % 1000)
+                unit = 'u';
+        else {
+                unit = 'm';
+                interval /= 1000;
+        }
+
+        return sprintf(buf, "%d%cs\n", interval, unit);
+}
+static DEVICE_ATTR(interval, S_IRUGO, show_ep_interval, NULL);
+
+static ssize_t show_ep_direction(struct device *dev,
+                                 struct device_attribute *attr, char *buf)
+{
+        struct ep_device *ep = to_ep_device(dev);
+        char *direction;
+
+        if ((ep->desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
+                        USB_ENDPOINT_XFER_CONTROL)
+                direction = "both";
+        else if (ep->desc->bEndpointAddress & USB_DIR_IN)
+                direction = "in";
+        else
+                direction = "out";
+        return sprintf(buf, "%s\n", direction);
+}
+static DEVICE_ATTR(direction, S_IRUGO, show_ep_direction, NULL);
+
+static struct attribute *ep_dev_attrs[] = {
+        &dev_attr_bLength.attr,
+        &dev_attr_bEndpointAddress.attr,
+        &dev_attr_bmAttributes.attr,
+        &dev_attr_bInterval.attr,
+        &dev_attr_wMaxPacketSize.attr,
+        &dev_attr_interval.attr,
+        &dev_attr_type.attr,
+        &dev_attr_direction.attr,
+        NULL,
+};
+static struct attribute_group ep_dev_attr_grp = {
+        .attrs = ep_dev_attrs,
+};
+
+static struct endpoint_class {
+        struct kref kref;
+        struct class *class;
+} *ep_class;
+
+static int init_endpoint_class(void)
+{
+        int result = 0;
+
+        if (ep_class != NULL) {
+                kref_get(&ep_class->kref);
+                goto exit;
+        }
+
+        ep_class = kmalloc(sizeof(*ep_class), GFP_KERNEL);
+        if (!ep_class) {
+                result = -ENOMEM;
+                goto exit;
+        }
+
+        kref_init(&ep_class->kref);
+        ep_class->class = class_create(THIS_MODULE, "usb_endpoint");
+        if (IS_ERR(ep_class->class)) {
+                result = IS_ERR(ep_class->class);
+                kfree(ep_class);
+                ep_class = NULL;
+                goto exit;
+        }
+
+exit:
+        return result;
+}
+
+static void release_endpoint_class(struct kref *kref)
+{
+        /* Ok, we cheat as we know we only have one ep_class */
+        class_destroy(ep_class->class);
+        kfree(ep_class);
+        ep_class = NULL;
+}
+
+static void destroy_endpoint_class(void)
+{
+        if (ep_class)
+                kref_put(&ep_class->kref, release_endpoint_class);
+}
+
+static void ep_device_release(struct device *dev)
+{
+        struct ep_device *ep_dev = to_ep_device(dev);
+
+        dev_dbg(dev, "%s called for %s\n", __FUNCTION__, dev->bus_id);
+        kfree(ep_dev);
+}
+
+void usb_create_ep_files(struct device *parent,
+                         struct usb_host_endpoint *endpoint,
+                         struct usb_device *udev)
+{
+        char name[8];
+        struct ep_device *ep_dev;
+        int minor;
+        int retval;
+
+        retval = init_endpoint_class();
+        if (retval)
+                goto exit;
+
+        ep_dev = kzalloc(sizeof(*ep_dev), GFP_KERNEL);
+        if (!ep_dev) {
+                retval = -ENOMEM;
+                goto exit;
+        }
+
+        /* fun calculation to determine the minor of this endpoint */
+        minor = (((udev->bus->busnum - 1) * 128) * 16) + (udev->devnum - 1);
+
+        ep_dev->desc = &endpoint->desc;
+        ep_dev->udev = udev;
+        ep_dev->dev.devt = MKDEV(442, minor);   // FIXME fake number...
+        ep_dev->dev.class = ep_class->class;
+        ep_dev->dev.parent = parent;
+        ep_dev->dev.release = ep_device_release;
+        snprintf(ep_dev->dev.bus_id, BUS_ID_SIZE, "usbdev%d.%d_ep%02x",
+                 udev->bus->busnum, udev->devnum,
+                 endpoint->desc.bEndpointAddress);
+
+        retval = device_register(&ep_dev->dev);
+        if (retval)
+                goto error;
+        sysfs_create_group(&ep_dev->dev.kobj, &ep_dev_attr_grp);
+
+        endpoint->ep_dev = ep_dev;
+
+        /* create the symlink to the old-style "ep_XX" directory */
+        sprintf(name, "ep_%02x", endpoint->desc.bEndpointAddress);
+        sysfs_create_link(&parent->kobj, &endpoint->ep_dev->dev.kobj, name);
+
+exit:
+        return;
+error:
+        kfree(ep_dev);
+        return;
+}
+
+void usb_remove_ep_files(struct usb_host_endpoint *endpoint)
+{
+
+        if (endpoint->ep_dev) {
+                char name[8];
+
+                sprintf(name, "ep_%02x", endpoint->desc.bEndpointAddress);
+                sysfs_remove_link(&endpoint->ep_dev->dev.parent->kobj, name);
+                sysfs_remove_group(&endpoint->ep_dev->dev.kobj, &ep_dev_attr_grp);
+                device_unregister(&endpoint->ep_dev->dev);
+                endpoint->ep_dev = NULL;
+        }
+        destroy_endpoint_class();
+}
+
+
diff --git a/drivers/usb/core/file.c b/drivers/usb/core/file.c
index b263a54a13c0..f65b193cde3d 100644
--- a/drivers/usb/core/file.c
+++ b/drivers/usb/core/file.c
@@ -61,33 +61,66 @@ static struct file_operations usb_fops = {
         .open =         usb_open,
 };
 
-static struct class *usb_class;
+static struct usb_class {
+        struct kref kref;
+        struct class *class;
+} *usb_class;
 
-int usb_major_init(void)
+static int init_usb_class(void)
 {
-        int error;
+        int result = 0;
 
-        error = register_chrdev(USB_MAJOR, "usb", &usb_fops);
-        if (error) {
-                err("unable to get major %d for usb devices", USB_MAJOR);
-                goto out;
+        if (usb_class != NULL) {
+                kref_get(&usb_class->kref);
+                goto exit;
+        }
+
+        usb_class = kmalloc(sizeof(*usb_class), GFP_KERNEL);
+        if (!usb_class) {
+                result = -ENOMEM;
+                goto exit;
         }
 
-        usb_class = class_create(THIS_MODULE, "usb");
-        if (IS_ERR(usb_class)) {
-                error = PTR_ERR(usb_class);
+        kref_init(&usb_class->kref);
+        usb_class->class = class_create(THIS_MODULE, "usb");
+        if (IS_ERR(usb_class->class)) {
+                result = IS_ERR(usb_class->class);
                 err("class_create failed for usb devices");
-                unregister_chrdev(USB_MAJOR, "usb");
-                goto out;
+                kfree(usb_class);
+                usb_class = NULL;
         }
 
-out:
+exit:
+        return result;
+}
+
+static void release_usb_class(struct kref *kref)
+{
+        /* Ok, we cheat as we know we only have one usb_class */
+        class_destroy(usb_class->class);
+        kfree(usb_class);
+        usb_class = NULL;
+}
+
+static void destroy_usb_class(void)
+{
+        if (usb_class)
+                kref_put(&usb_class->kref, release_usb_class);
+}
+
+int usb_major_init(void)
+{
+        int error;
+
+        error = register_chrdev(USB_MAJOR, "usb", &usb_fops);
+        if (error)
+                err("unable to get major %d for usb devices", USB_MAJOR);
+
         return error;
 }
 
 void usb_major_cleanup(void)
 {
-        class_destroy(usb_class);
         unregister_chrdev(USB_MAJOR, "usb");
 }
 
@@ -149,6 +182,10 @@ int usb_register_dev(struct usb_interface *intf,
         if (retval)
                 goto exit;
 
+        retval = init_usb_class();
+        if (retval)
+                goto exit;
+
         intf->minor = minor;
 
         /* create a usb class device for this usb interface */
@@ -158,14 +195,13 @@ int usb_register_dev(struct usb_interface *intf,
                 ++temp;
         else
                 temp = name;
-        intf->class_dev = class_device_create(usb_class, NULL,
-                                              MKDEV(USB_MAJOR, minor),
-                                              &intf->dev, "%s", temp);
-        if (IS_ERR(intf->class_dev)) {
+        intf->usb_dev = device_create(usb_class->class, &intf->dev,
+                                      MKDEV(USB_MAJOR, minor), "%s", temp);
+        if (IS_ERR(intf->usb_dev)) {
                 spin_lock (&minor_lock);
                 usb_minors[intf->minor] = NULL;
                 spin_unlock (&minor_lock);
-                retval = PTR_ERR(intf->class_dev);
+                retval = PTR_ERR(intf->usb_dev);
         }
 exit:
         return retval;
@@ -206,9 +242,10 @@ void usb_deregister_dev(struct usb_interface *intf,
         spin_unlock (&minor_lock);
 
         snprintf(name, BUS_ID_SIZE, class_driver->name, intf->minor - minor_base);
-        class_device_destroy(usb_class, MKDEV(USB_MAJOR, intf->minor));
-        intf->class_dev = NULL;
+        device_destroy(usb_class->class, MKDEV(USB_MAJOR, intf->minor));
+        intf->usb_dev = NULL;
         intf->minor = -1;
+        destroy_usb_class();
 }
 EXPORT_SYMBOL(usb_deregister_dev);
 
diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
index e2e00ba4e1e6..4bf914d00a14 100644
--- a/drivers/usb/core/hcd.c
+++ b/drivers/usb/core/hcd.c
@@ -1826,24 +1826,16 @@ int usb_add_hcd(struct usb_hcd *hcd,
 
         /* enable irqs just before we start the controller */
         if (hcd->driver->irq) {
-                char    buf[8], *bufp = buf;
-
-#ifdef __sparc__
-                bufp = __irq_itoa(irqnum);
-#else
-                sprintf(buf, "%d", irqnum);
-#endif
-
                 snprintf(hcd->irq_descr, sizeof(hcd->irq_descr), "%s:usb%d",
                                 hcd->driver->description, hcd->self.busnum);
                 if ((retval = request_irq(irqnum, &usb_hcd_irq, irqflags,
                                 hcd->irq_descr, hcd)) != 0) {
                         dev_err(hcd->self.controller,
-                                        "request interrupt %s failed\n", bufp);
+                                        "request interrupt %d failed\n", irqnum);
                         goto err_request_irq;
                 }
                 hcd->irq = irqnum;
-                dev_info(hcd->self.controller, "irq %s, %s 0x%08llx\n", bufp,
+                dev_info(hcd->self.controller, "irq %d, %s 0x%08llx\n", irqnum,
                                 (hcd->driver->flags & HCD_MEMORY) ?
                                         "io mem" : "io base",
                                         (unsigned long long)hcd->rsrc_start);
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index 90b8d43c6b33..e1731ff8af4d 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -432,15 +432,22 @@ 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 ((wHubCharacteristics & HUB_CHAR_LPSM) < 2) {
+        u16 wHubCharacteristics =
+                        le16_to_cpu(hub->descriptor->wHubCharacteristics);
+
+        /* Enable power on each port.  Some hubs have reserved values
+         * of LPSM (> 2) in their descriptors, even though they are
+         * USB 2.0 hubs.  Some hubs do not implement port-power switching
+         * but only emulate it.  In all cases, the ports won't work
+         * unless we send these messages to the hub.
+         */
+        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);
-        }
+        else
+                dev_dbg(hub->intfdev, "trying to enable port power on "
+                                "non-switchable hub\n");
+        for (port1 = 1; port1 <= hub->descriptor->bNbrPorts; port1++)
+                set_port_feature(hub->hdev, port1, USB_PORT_FEAT_POWER);
 
         /* Wait at least 100 msec for power to become stable */
         msleep(max(pgood_delay, (unsigned) 100));
@@ -518,15 +525,16 @@ static int hub_port_disable(struct usb_hub *hub, int port1, int set_state)
 
 
 /* caller has locked the hub device */
-static void hub_pre_reset(struct usb_hub *hub, int disable_ports)
+static void hub_pre_reset(struct usb_interface *intf)
 {
+        struct usb_hub *hub = usb_get_intfdata(intf);
         struct usb_device *hdev = hub->hdev;
         int port1;
 
         for (port1 = 1; port1 <= hdev->maxchild; ++port1) {
                 if (hdev->children[port1 - 1]) {
                         usb_disconnect(&hdev->children[port1 - 1]);
-                        if (disable_ports)
+                        if (hub->error == 0)
                                 hub_port_disable(hub, port1, 0);
                 }
         }
@@ -534,8 +542,10 @@ static void hub_pre_reset(struct usb_hub *hub, int disable_ports)
 }
 
 /* caller has locked the hub device */
-static void hub_post_reset(struct usb_hub *hub)
+static void hub_post_reset(struct usb_interface *intf)
 {
+        struct usb_hub *hub = usb_get_intfdata(intf);
+
         hub_activate(hub);
         hub_power_on(hub);
 }
@@ -795,15 +805,16 @@ static void hub_disconnect(struct usb_interface *intf)
         struct usb_hub *hub = usb_get_intfdata (intf);
         struct usb_device *hdev;
 
+        /* Disconnect all children and quiesce the hub */
+        hub->error = 0;
+        hub_pre_reset(intf);
+
         usb_set_intfdata (intf, NULL);
         hdev = hub->hdev;
 
         if (hdev->speed == USB_SPEED_HIGH)
                 highspeed_hubs--;
 
-        /* Disconnect all children and quiesce the hub */
-        hub_pre_reset(hub, 1);
-
         usb_free_urb(hub->urb);
         hub->urb = NULL;
 
@@ -1169,6 +1180,7 @@ static int choose_configuration(struct usb_device *udev)
 {
         int i;
         int num_configs;
+        int insufficient_power = 0;
         struct usb_host_config *c, *best;
 
         best = NULL;
@@ -1221,8 +1233,10 @@ static int choose_configuration(struct usb_device *udev)
                  */
 
                 /* Rule out configs that draw too much bus current */
-                if (c->desc.bMaxPower * 2 > udev->bus_mA)
+                if (c->desc.bMaxPower * 2 > udev->bus_mA) {
+                        insufficient_power++;
                         continue;
+                }
 
                 /* If the first config's first interface is COMM/2/0xff
                  * (MSFT RNDIS), rule it out unless Linux has host-side
@@ -1231,7 +1245,7 @@ static int choose_configuration(struct usb_device *udev)
                                 && desc->bInterfaceClass == USB_CLASS_COMM
                                 && desc->bInterfaceSubClass == 2
                                 && desc->bInterfaceProtocol == 0xff) {
-#ifndef CONFIG_USB_NET_RNDIS
+#ifndef CONFIG_USB_NET_RNDIS_HOST
                         continue;
 #else
                         best = c;
@@ -1256,6 +1270,11 @@ static int choose_configuration(struct usb_device *udev)
                         best = c;
         }
 
+        if (insufficient_power > 0)
+                dev_info(&udev->dev, "rejected %d configuration%s "
+                        "due to insufficient available bus power\n",
+                        insufficient_power, plural(insufficient_power));
+
         if (best) {
                 i = best->desc.bConfigurationValue;
                 dev_info(&udev->dev,
@@ -2732,7 +2751,8 @@ static void hub_events(void)
 
                 /* If the hub has died, clean up after it */
                 if (hdev->state == USB_STATE_NOTATTACHED) {
-                        hub_pre_reset(hub, 0);
+                        hub->error = -ENODEV;
+                        hub_pre_reset(intf);
                         goto loop;
                 }
 
@@ -2744,7 +2764,7 @@ static void hub_events(void)
                         dev_dbg (hub_dev, "resetting for error %d\n",
                                 hub->error);
 
-                        ret = usb_reset_device(hdev);
+                        ret = usb_reset_composite_device(hdev, intf);
                         if (ret) {
                                 dev_dbg (hub_dev,
                                         "error resetting hub: %d\n", ret);
@@ -2913,6 +2933,8 @@ static struct usb_driver hub_driver = {
         .disconnect =   hub_disconnect,
         .suspend =      hub_suspend,
         .resume =       hub_resume,
+        .pre_reset =    hub_pre_reset,
+        .post_reset =   hub_post_reset,
         .ioctl =        hub_ioctl,
         .id_table =     hub_id_table,
 };
@@ -2992,9 +3014,9 @@ static int config_descriptors_changed(struct usb_device *udev)
  * usb_reset_device - perform a USB port reset to reinitialize a device
  * @udev: device to reset (not in SUSPENDED or NOTATTACHED state)
  *
- * WARNING - don't reset any device unless drivers for all of its
- * interfaces are expecting that reset!  Maybe some driver->reset()
- * method should eventually help ensure sufficient cooperation.
+ * WARNING - don't use this routine to reset a composite device
+ * (one with multiple interfaces owned by separate drivers)!
+ * Use usb_reset_composite_device() instead.
  *
  * Do a port reset, reassign the device's address, and establish its
  * former operating configuration.  If the reset fails, or the device's
@@ -3018,7 +3040,6 @@ int usb_reset_device(struct usb_device *udev)
         struct usb_device               *parent_hdev = udev->parent;
         struct usb_hub                  *parent_hub;
         struct usb_device_descriptor    descriptor = udev->descriptor;
-        struct usb_hub                  *hub = NULL;
         int                             i, ret = 0;
         int                             port1 = udev->portnum;
 
@@ -3036,14 +3057,6 @@ int usb_reset_device(struct usb_device *udev)
         }
         parent_hub = hdev_to_hub(parent_hdev);
 
-        /* If we're resetting an active hub, take some special actions */
-        if (udev->actconfig && udev->actconfig->desc.bNumInterfaces > 0 &&
-                        udev->actconfig->interface[0]->dev.driver ==
-                                &hub_driver.driver &&
-                        (hub = hdev_to_hub(udev)) != NULL) {
-                hub_pre_reset(hub, 0);
-        }
-
         set_bit(port1, parent_hub->busy_bits);
         for (i = 0; i < SET_CONFIG_TRIES; ++i) {
 
@@ -3102,11 +3115,87 @@ int usb_reset_device(struct usb_device *udev)
         }
 
 done:
-        if (hub)
-                hub_post_reset(hub);
         return 0;
  
 re_enumerate:
         hub_port_logical_disconnect(parent_hub, port1);
         return -ENODEV;
 }
+
+/**
+ * usb_reset_composite_device - warn interface drivers and perform a USB port reset
+ * @udev: device to reset (not in SUSPENDED or NOTATTACHED state)
+ * @iface: interface bound to the driver making the request (optional)
+ *
+ * Warns all drivers bound to registered interfaces (using their pre_reset
+ * method), performs the port reset, and then lets the drivers know that
+ * the reset is over (using their post_reset method).
+ *
+ * Return value is the same as for usb_reset_device().
+ *
+ * The caller must own the device lock.  For example, it's safe to use
+ * this from a driver probe() routine after downloading new firmware.
+ * For calls that might not occur during probe(), drivers should lock
+ * the device using usb_lock_device_for_reset().
+ *
+ * The interface locks are acquired during the pre_reset stage and released
+ * during the post_reset stage.  However if iface is not NULL and is
+ * currently being probed, we assume that the caller already owns its
+ * lock.
+ */
+int usb_reset_composite_device(struct usb_device *udev,
+                struct usb_interface *iface)
+{
+        int ret;
+        struct usb_host_config *config = udev->actconfig;
+
+        if (udev->state == USB_STATE_NOTATTACHED ||
+                        udev->state == USB_STATE_SUSPENDED) {
+                dev_dbg(&udev->dev, "device reset not allowed in state %d\n",
+                                udev->state);
+                return -EINVAL;
+        }
+
+        if (iface && iface->condition != USB_INTERFACE_BINDING)
+                iface = NULL;
+
+        if (config) {
+                int i;
+                struct usb_interface *cintf;
+                struct usb_driver *drv;
+
+                for (i = 0; i < config->desc.bNumInterfaces; ++i) {
+                        cintf = config->interface[i];
+                        if (cintf != iface)
+                                down(&cintf->dev.sem);
+                        if (device_is_registered(&cintf->dev) &&
+                                        cintf->dev.driver) {
+                                drv = to_usb_driver(cintf->dev.driver);
+                                if (drv->pre_reset)
+                                        (drv->pre_reset)(cintf);
+                        }
+                }
+        }
+
+        ret = usb_reset_device(udev);
+
+        if (config) {
+                int i;
+                struct usb_interface *cintf;
+                struct usb_driver *drv;
+
+                for (i = config->desc.bNumInterfaces - 1; i >= 0; --i) {
+                        cintf = config->interface[i];
+                        if (device_is_registered(&cintf->dev) &&
+                                        cintf->dev.driver) {
+                                drv = to_usb_driver(cintf->dev.driver);
+                                if (drv->post_reset)
+                                        (drv->post_reset)(cintf);
+                        }
+                        if (cintf != iface)
+                                up(&cintf->dev.sem);
+                }
+        }
+
+        return ret;
+}
diff --git a/drivers/usb/core/inode.c b/drivers/usb/core/inode.c
index 3cf945cc5b9a..bfc9b28a7242 100644
--- a/drivers/usb/core/inode.c
+++ b/drivers/usb/core/inode.c
@@ -543,10 +543,10 @@ static void fs_remove_file (struct dentry *dentry)
 
 /* --------------------------------------------------------------------- */
 
-static struct super_block *usb_get_sb(struct file_system_type *fs_type,
-        int flags, const char *dev_name, void *data)
+static int usb_get_sb(struct file_system_type *fs_type,
+        int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 {
-        return get_sb_single(fs_type, flags, data, usbfs_fill_super);
+        return get_sb_single(fs_type, flags, data, usbfs_fill_super, mnt);
 }
 
 static struct file_system_type usb_fs_type = {
@@ -569,7 +569,7 @@ static int create_special_files (void)
         ignore_mount = 1;
 
         /* create the devices special file */
-        retval = simple_pin_fs("usbfs", &usbfs_mount, &usbfs_mount_count);
+        retval = simple_pin_fs(&usb_fs_type, &usbfs_mount, &usbfs_mount_count);
         if (retval) {
                 err ("Unable to get usbfs mount");
                 goto exit;
diff --git a/drivers/usb/core/message.c b/drivers/usb/core/message.c
index 08fb20f06f3e..8569600f3130 100644
--- a/drivers/usb/core/message.c
+++ b/drivers/usb/core/message.c
@@ -158,6 +158,37 @@ int usb_control_msg(struct usb_device *dev, unsigned int pipe, __u8 request, __u
 
 
 /**
+ * usb_interrupt_msg - Builds an interrupt urb, sends it off and waits for completion
+ * @usb_dev: pointer to the usb device to send the message to
+ * @pipe: endpoint "pipe" to send the message to
+ * @data: pointer to the data to send
+ * @len: length in bytes of the data to send
+ * @actual_length: pointer to a location to put the actual length transferred in bytes
+ * @timeout: time in msecs to wait for the message to complete before
+ *      timing out (if 0 the wait is forever)
+ * Context: !in_interrupt ()
+ *
+ * This function sends a simple interrupt message to a specified endpoint and
+ * waits for the message to complete, or timeout.
+ *
+ * If successful, it returns 0, otherwise a negative error number.  The number
+ * of actual bytes transferred will be stored in the actual_length paramater.
+ *
+ * Don't use this function from within an interrupt context, like a bottom half
+ * handler.  If you need an asynchronous message, or need to send a message
+ * from within interrupt context, use usb_submit_urb() If a thread in your
+ * driver uses this call, make sure your disconnect() method can wait for it to
+ * complete.  Since you don't have a handle on the URB used, you can't cancel
+ * the request.
+ */
+int usb_interrupt_msg(struct usb_device *usb_dev, unsigned int pipe,
+                      void *data, int len, int *actual_length, int timeout)
+{
+        return usb_bulk_msg(usb_dev, pipe, data, len, actual_length, timeout);
+}
+EXPORT_SYMBOL_GPL(usb_interrupt_msg);
+
+/**
  *      usb_bulk_msg - Builds a bulk urb, sends it off and waits for completion
  *      @usb_dev: pointer to the usb device to send the message to
  *      @pipe: endpoint "pipe" to send the message to
@@ -1380,15 +1411,7 @@ free_interfaces:
                                 return ret;
                         }
                 }
-        }
-
-        /* if it's already configured, clear out old state first.
-         * getting rid of old interfaces means unbinding their drivers.
-         */
-        if (dev->state != USB_STATE_ADDRESS)
-                usb_disable_device (dev, 1);    // Skip ep0
 
-        if (cp) {
                 i = dev->bus_mA - cp->desc.bMaxPower * 2;
                 if (i < 0)
                         dev_warn(&dev->dev, "new config #%d exceeds power "
@@ -1396,84 +1419,91 @@ free_interfaces:
                                         configuration, -i);
         }
 
+        /* if it's already configured, clear out old state first.
+         * getting rid of old interfaces means unbinding their drivers.
+         */
+        if (dev->state != USB_STATE_ADDRESS)
+                usb_disable_device (dev, 1);    // Skip ep0
+
         if ((ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
                         USB_REQ_SET_CONFIGURATION, 0, configuration, 0,
-                        NULL, 0, USB_CTRL_SET_TIMEOUT)) < 0)
-                goto free_interfaces;
+                        NULL, 0, USB_CTRL_SET_TIMEOUT)) < 0) {
+
+                /* All the old state is gone, so what else can we do?
+                 * The device is probably useless now anyway.
+                 */
+                cp = NULL;
+        }
 
         dev->actconfig = cp;
-        if (!cp)
+        if (!cp) {
                 usb_set_device_state(dev, USB_STATE_ADDRESS);
-        else {
-                usb_set_device_state(dev, USB_STATE_CONFIGURED);
+                goto free_interfaces;
+        }
+        usb_set_device_state(dev, USB_STATE_CONFIGURED);
 
-                /* Initialize the new interface structures and the
-                 * hc/hcd/usbcore interface/endpoint state.
-                 */
-                for (i = 0; i < nintf; ++i) {
-                        struct usb_interface_cache *intfc;
-                        struct usb_interface *intf;
-                        struct usb_host_interface *alt;
-
-                        cp->interface[i] = intf = new_interfaces[i];
-                        intfc = cp->intf_cache[i];
-                        intf->altsetting = intfc->altsetting;
-                        intf->num_altsetting = intfc->num_altsetting;
-                        kref_get(&intfc->ref);
-
-                        alt = usb_altnum_to_altsetting(intf, 0);
-
-                        /* No altsetting 0?  We'll assume the first altsetting.
-                         * We could use a GetInterface call, but if a device is
-                         * so non-compliant that it doesn't have altsetting 0
-                         * then I wouldn't trust its reply anyway.
-                         */
-                        if (!alt)
-                                alt = &intf->altsetting[0];
-
-                        intf->cur_altsetting = alt;
-                        usb_enable_interface(dev, intf);
-                        intf->dev.parent = &dev->dev;
-                        intf->dev.driver = NULL;
-                        intf->dev.bus = &usb_bus_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",
-                                 dev->bus->busnum, dev->devpath,
-                                 configuration,
-                                 alt->desc.bInterfaceNumber);
-                }
-                kfree(new_interfaces);
+        /* Initialize the new interface structures and the
+         * hc/hcd/usbcore interface/endpoint state.
+         */
+        for (i = 0; i < nintf; ++i) {
+                struct usb_interface_cache *intfc;
+                struct usb_interface *intf;
+                struct usb_host_interface *alt;
+
+                cp->interface[i] = intf = new_interfaces[i];
+                intfc = cp->intf_cache[i];
+                intf->altsetting = intfc->altsetting;
+                intf->num_altsetting = intfc->num_altsetting;
+                kref_get(&intfc->ref);
 
-                if (cp->string == NULL)
-                        cp->string = usb_cache_string(dev,
-                                        cp->desc.iConfiguration);
+                alt = usb_altnum_to_altsetting(intf, 0);
 
-                /* Now that all the interfaces are set up, register them
-                 * to trigger binding of drivers to interfaces.  probe()
-                 * routines may install different altsettings and may
-                 * claim() any interfaces not yet bound.  Many class drivers
-                 * need that: CDC, audio, video, etc.
+                /* No altsetting 0?  We'll assume the first altsetting.
+                 * We could use a GetInterface call, but if a device is
+                 * so non-compliant that it doesn't have altsetting 0
+                 * then I wouldn't trust its reply anyway.
                  */
-                for (i = 0; i < nintf; ++i) {
-                        struct usb_interface *intf = cp->interface[i];
-
-                        dev_dbg (&dev->dev,
-                                "adding %s (config #%d, interface %d)\n",
-                                intf->dev.bus_id, configuration,
-                                intf->cur_altsetting->desc.bInterfaceNumber);
-                        ret = device_add (&intf->dev);
-                        if (ret != 0) {
-                                dev_err(&dev->dev,
-                                        "device_add(%s) --> %d\n",
-                                        intf->dev.bus_id,
-                                        ret);
-                                continue;
-                        }
-                        usb_create_sysfs_intf_files (intf);
+                if (!alt)
+                        alt = &intf->altsetting[0];
+
+                intf->cur_altsetting = alt;
+                usb_enable_interface(dev, intf);
+                intf->dev.parent = &dev->dev;
+                intf->dev.driver = NULL;
+                intf->dev.bus = &usb_bus_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",
+                         dev->bus->busnum, dev->devpath,
+                         configuration, alt->desc.bInterfaceNumber);
+        }
+        kfree(new_interfaces);
+
+        if (cp->string == NULL)
+                cp->string = usb_cache_string(dev, cp->desc.iConfiguration);
+
+        /* Now that all the interfaces are set up, register them
+         * to trigger binding of drivers to interfaces.  probe()
+         * routines may install different altsettings and may
+         * claim() any interfaces not yet bound.  Many class drivers
+         * need that: CDC, audio, video, etc.
+         */
+        for (i = 0; i < nintf; ++i) {
+                struct usb_interface *intf = cp->interface[i];
+
+                dev_dbg (&dev->dev,
+                        "adding %s (config #%d, interface %d)\n",
+                        intf->dev.bus_id, configuration,
+                        intf->cur_altsetting->desc.bInterfaceNumber);
+                ret = device_add (&intf->dev);
+                if (ret != 0) {
+                        dev_err(&dev->dev, "device_add(%s) --> %d\n",
+                                intf->dev.bus_id, ret);
+                        continue;
                 }
+                usb_create_sysfs_intf_files (intf);
         }
 
         return 0;
diff --git a/drivers/usb/core/sysfs.c b/drivers/usb/core/sysfs.c
index 71d881327e88..3f49bf51cff7 100644
--- a/drivers/usb/core/sysfs.c
+++ b/drivers/usb/core/sysfs.c
@@ -15,203 +15,6 @@
 #include <linux/usb.h>
 #include "usb.h"
 
-/* endpoint stuff */
-struct ep_object {
-        struct usb_endpoint_descriptor *desc;
-        struct usb_device *udev;
-        struct kobject kobj;
-};
-#define to_ep_object(_kobj) \
-        container_of(_kobj, struct ep_object, kobj)
-
-struct ep_attribute {
-        struct attribute attr;
-        ssize_t (*show)(struct usb_device *,
-                        struct usb_endpoint_descriptor *, char *);
-};
-#define to_ep_attribute(_attr) \
-        container_of(_attr, struct ep_attribute, attr)
-
-#define EP_ATTR(_name)                                          \
-struct ep_attribute ep_##_name = {                              \
-        .attr = {.name = #_name, .owner = THIS_MODULE,          \
-                        .mode = S_IRUGO},                       \
-        .show = show_ep_##_name}
-
-#define usb_ep_attr(field, format_string)                       \
-static ssize_t show_ep_##field(struct usb_device *udev,         \
-                struct usb_endpoint_descriptor *desc,           \
-                char *buf)                                      \
-{                                                               \
-        return sprintf(buf, format_string, desc->field);        \
-}                                                               \
-static EP_ATTR(field);
-
-usb_ep_attr(bLength, "%02x\n")
-usb_ep_attr(bEndpointAddress, "%02x\n")
-usb_ep_attr(bmAttributes, "%02x\n")
-usb_ep_attr(bInterval, "%02x\n")
-
-static ssize_t show_ep_wMaxPacketSize(struct usb_device *udev,
-                struct usb_endpoint_descriptor *desc, char *buf)
-{
-        return sprintf(buf, "%04x\n",
-                        le16_to_cpu(desc->wMaxPacketSize) & 0x07ff);
-}
-static EP_ATTR(wMaxPacketSize);
-
-static ssize_t show_ep_type(struct usb_device *udev,
-                struct usb_endpoint_descriptor *desc, char *buf)
-{
-        char *type = "unknown";
-
-        switch (desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
-        case USB_ENDPOINT_XFER_CONTROL:
-                type = "Control";
-                break;
-        case USB_ENDPOINT_XFER_ISOC:
-                type = "Isoc";
-                break;
-        case USB_ENDPOINT_XFER_BULK:
-                type = "Bulk";
-                break;
-        case USB_ENDPOINT_XFER_INT:
-                type = "Interrupt";
-                break;
-        }
-        return sprintf(buf, "%s\n", type);
-}
-static EP_ATTR(type);
-
-static ssize_t show_ep_interval(struct usb_device *udev,
-                struct usb_endpoint_descriptor *desc, char *buf)
-{
-        char unit;
-        unsigned interval = 0;
-        unsigned in;
-
-        in = (desc->bEndpointAddress & USB_DIR_IN);
-
-        switch (desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
-        case USB_ENDPOINT_XFER_CONTROL:
-                if (udev->speed == USB_SPEED_HIGH)      /* uframes per NAK */
-                        interval = desc->bInterval;
-                break;
-        case USB_ENDPOINT_XFER_ISOC:
-                interval = 1 << (desc->bInterval - 1);
-                break;
-        case USB_ENDPOINT_XFER_BULK:
-                if (udev->speed == USB_SPEED_HIGH && !in) /* uframes per NAK */
-                        interval = desc->bInterval;
-                break;
-        case USB_ENDPOINT_XFER_INT:
-                if (udev->speed == USB_SPEED_HIGH)
-                        interval = 1 << (desc->bInterval - 1);
-                else
-                        interval = desc->bInterval;
-                break;
-        }
-        interval *= (udev->speed == USB_SPEED_HIGH) ? 125 : 1000;
-        if (interval % 1000)
-                unit = 'u';
-        else {
-                unit = 'm';
-                interval /= 1000;
-        }
-
-        return sprintf(buf, "%d%cs\n", interval, unit);
-}
-static EP_ATTR(interval);
-
-static ssize_t show_ep_direction(struct usb_device *udev,
-                struct usb_endpoint_descriptor *desc, char *buf)
-{
-        char *direction;
-
-        if ((desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
-                        USB_ENDPOINT_XFER_CONTROL)
-                direction = "both";
-        else if (desc->bEndpointAddress & USB_DIR_IN)
-                direction = "in";
-        else
-                direction = "out";
-        return sprintf(buf, "%s\n", direction);
-}
-static EP_ATTR(direction);
-
-static struct attribute *ep_attrs[] = {
-        &ep_bLength.attr,
-        &ep_bEndpointAddress.attr,
-        &ep_bmAttributes.attr,
-        &ep_bInterval.attr,
-        &ep_wMaxPacketSize.attr,
-        &ep_type.attr,
-        &ep_interval.attr,
-        &ep_direction.attr,
-        NULL,
-};
-
-static void ep_object_release(struct kobject *kobj)
-{
-        kfree(to_ep_object(kobj));
-}
-
-static ssize_t ep_object_show(struct kobject *kobj, struct attribute *attr,
-                char *buf)
-{
-        struct ep_object *ep_obj = to_ep_object(kobj);
-        struct ep_attribute *ep_attr = to_ep_attribute(attr);
-
-        return (ep_attr->show)(ep_obj->udev, ep_obj->desc, buf);
-}
-
-static struct sysfs_ops ep_object_sysfs_ops = {
-        .show =                 ep_object_show,
-};
-
-static struct kobj_type ep_object_ktype = {
-        .release =              ep_object_release,
-        .sysfs_ops =            &ep_object_sysfs_ops,
-        .default_attrs =        ep_attrs,
-};
-
-static void usb_create_ep_files(struct kobject *parent,
-                struct usb_host_endpoint *endpoint,
-                struct usb_device *udev)
-{
-        struct ep_object *ep_obj;
-        struct kobject *kobj;
-
-        ep_obj = kzalloc(sizeof(struct ep_object), GFP_KERNEL);
-        if (!ep_obj)
-                return;
-
-        ep_obj->desc = &endpoint->desc;
-        ep_obj->udev = udev;
-
-        kobj = &ep_obj->kobj;
-        kobject_set_name(kobj, "ep_%02x", endpoint->desc.bEndpointAddress);
-        kobj->parent = parent;
-        kobj->ktype = &ep_object_ktype;
-
-        /* Don't use kobject_register, because it generates a hotplug event */
-        kobject_init(kobj);
-        if (kobject_add(kobj) == 0)
-                endpoint->kobj = kobj;
-        else
-                kobject_put(kobj);
-}
-
-static void usb_remove_ep_files(struct usb_host_endpoint *endpoint)
-{
-
-        if (endpoint->kobj) {
-                kobject_del(endpoint->kobj);
-                kobject_put(endpoint->kobj);
-                endpoint->kobj = NULL;
-        }
-}
-
 /* Active configuration fields */
 #define usb_actconfig_show(field, multiplier, format_string)            \
 static ssize_t  show_##field (struct device *dev,                       \
@@ -420,7 +223,7 @@ void usb_create_sysfs_dev_files (struct usb_device *udev)
         if (udev->serial)
                 device_create_file (dev, &dev_attr_serial);
         device_create_file (dev, &dev_attr_configuration);
-        usb_create_ep_files(&dev->kobj, &udev->ep0, udev);
+        usb_create_ep_files(dev, &udev->ep0, udev);
 }
 
 void usb_remove_sysfs_dev_files (struct usb_device *udev)
@@ -524,7 +327,7 @@ static inline void usb_create_intf_ep_files(struct usb_interface *intf,
 
         iface_desc = intf->cur_altsetting;
         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i)
-                usb_create_ep_files(&intf->dev.kobj, &iface_desc->endpoint[i],
+                usb_create_ep_files(&intf->dev, &iface_desc->endpoint[i],
                                 udev);
 }
 
diff --git a/drivers/usb/core/usb.c b/drivers/usb/core/usb.c
index b7fdc1cd134a..fb488c8a860c 100644
--- a/drivers/usb/core/usb.c
+++ b/drivers/usb/core/usb.c
@@ -991,6 +991,8 @@ void usb_buffer_unmap_sg (struct usb_device *dev, unsigned pipe,
 
 static int verify_suspended(struct device *dev, void *unused)
 {
+        if (dev->driver == NULL)
+                return 0;
         return (dev->power.power_state.event == PM_EVENT_ON) ? -EBUSY : 0;
 }
 
@@ -1207,6 +1209,7 @@ EXPORT_SYMBOL(usb_ifnum_to_if);
 EXPORT_SYMBOL(usb_altnum_to_altsetting);
 
 EXPORT_SYMBOL(usb_reset_device);
+EXPORT_SYMBOL(usb_reset_composite_device);
 
 EXPORT_SYMBOL(__usb_get_extra_descriptor);
 
diff --git a/drivers/usb/core/usb.h b/drivers/usb/core/usb.h
index 4647e1ebc68d..7a650c763a62 100644
--- a/drivers/usb/core/usb.h
+++ b/drivers/usb/core/usb.h
@@ -4,6 +4,9 @@ extern void usb_create_sysfs_dev_files (struct usb_device *dev);
 extern void usb_remove_sysfs_dev_files (struct usb_device *dev);
 extern void usb_create_sysfs_intf_files (struct usb_interface *intf);
 extern void usb_remove_sysfs_intf_files (struct usb_interface *intf);
+extern void usb_create_ep_files(struct device *parent, struct usb_host_endpoint *endpoint,
+                                struct usb_device *udev);
+extern void usb_remove_ep_files(struct usb_host_endpoint *endpoint);
 
 extern void usb_disable_endpoint (struct usb_device *dev, unsigned int epaddr);
 extern void usb_disable_interface (struct usb_device *dev,