Merge git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb-2.6

* git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb-2.6: (142 commits)
  USB: Fix sysfs paths in documentation
  USB: skeleton: fix coding style issues.
  USB: O_NONBLOCK in read path of skeleton
  USB: make usb-skeleton honor O_NONBLOCK in write path
  USB: skel_read really sucks royally
  USB: Add hub descriptor update hook for xHCI
  USB: xhci: Support USB hubs.
  USB: xhci: Set multi-TT field for LS/FS devices under hubs.
  USB: xhci: Set route string for all devices.
  USB: xhci: Fix command wait list handling.
  USB: xhci: Change how xHCI commands are handled.
  USB: xhci: Refactor input device context setup.
  USB: xhci: Endpoint representation refactoring.
  USB: gadget: ether needs to select CRC32
  USB: fix USBTMC get_capabilities success handling
  USB: fix missing error check in probing
  USB: usbfs: add USBDEVFS_URB_BULK_CONTINUATION flag
  USB: support for autosuspend in sierra while online
  USB: ehci-dbgp,ehci: Allow dbpg to work with suspend/resume
  USB: ehci-dbgp,documentation: Documentation updates for ehci-dbgp
  ...

10 files changed, 430 insertions, 192 deletions

diff --git a/drivers/usb/core/config.c b/drivers/usb/core/config.c
index a16c538d0132..0d3af6a6ee49 100644
--- a/drivers/usb/core/config.c
+++ b/drivers/usb/core/config.c
@@ -105,7 +105,7 @@ static int usb_parse_ss_endpoint_companion(struct device *ddev, int cfgno,
         ep->ss_ep_comp->extralen = i;
         buffer += i;
         size -= i;
-        retval = buffer - buffer_start + i;
+        retval = buffer - buffer_start;
         if (num_skipped > 0)
                 dev_dbg(ddev, "skipped %d descriptor%s after %s\n",
                                 num_skipped, plural(num_skipped),
diff --git a/drivers/usb/core/devio.c b/drivers/usb/core/devio.c
index 4247eccf858c..181f78c84105 100644
--- a/drivers/usb/core/devio.c
+++ b/drivers/usb/core/devio.c
@@ -52,6 +52,7 @@
 
 #include "hcd.h"        /* for usbcore internals */
 #include "usb.h"
+#include "hub.h"
 
 #define USB_MAXBUS                      64
 #define USB_DEVICE_MAX                  USB_MAXBUS * 128
@@ -73,6 +74,7 @@ struct dev_state {
         void __user *disccontext;
         unsigned long ifclaimed;
         u32 secid;
+        u32 disabled_bulk_eps;
 };
 
 struct async {
@@ -87,6 +89,8 @@ struct async {
         struct urb *urb;
         int status;
         u32 secid;
+        u8 bulk_addr;
+        u8 bulk_status;
 };
 
 static int usbfs_snoop;
@@ -99,11 +103,15 @@ MODULE_PARM_DESC(usbfs_snoop, "true to log all usbfs traffic");
                         dev_info(dev , format , ## arg);        \
         } while (0)
 
-#define USB_DEVICE_DEV          MKDEV(USB_DEVICE_MAJOR, 0)
+enum snoop_when {
+        SUBMIT, COMPLETE
+};
 
+#define USB_DEVICE_DEV          MKDEV(USB_DEVICE_MAJOR, 0)
 
 #define MAX_USBFS_BUFFER_SIZE   16384
 
+
 static int connected(struct dev_state *ps)
 {
         return (!list_empty(&ps->list) &&
@@ -300,24 +308,79 @@ static struct async *async_getpending(struct dev_state *ps,
         return NULL;
 }
 
-static void snoop_urb(struct urb *urb, void __user *userurb)
+static void snoop_urb(struct usb_device *udev,
+                void __user *userurb, int pipe, unsigned length,
+                int timeout_or_status, enum snoop_when when)
 {
-        unsigned j;
-        unsigned char *data = urb->transfer_buffer;
+        static const char *types[] = {"isoc", "int", "ctrl", "bulk"};
+        static const char *dirs[] = {"out", "in"};
+        int ep;
+        const char *t, *d;
 
         if (!usbfs_snoop)
                 return;
 
-        dev_info(&urb->dev->dev, "direction=%s\n",
-                        usb_urb_dir_in(urb) ? "IN" : "OUT");
-        dev_info(&urb->dev->dev, "userurb=%p\n", userurb);
-        dev_info(&urb->dev->dev, "transfer_buffer_length=%u\n",
-                 urb->transfer_buffer_length);
-        dev_info(&urb->dev->dev, "actual_length=%u\n", urb->actual_length);
-        dev_info(&urb->dev->dev, "data: ");
-        for (j = 0; j < urb->transfer_buffer_length; ++j)
-                printk("%02x ", data[j]);
-        printk("\n");
+        ep = usb_pipeendpoint(pipe);
+        t = types[usb_pipetype(pipe)];
+        d = dirs[!!usb_pipein(pipe)];
+
+        if (userurb) {          /* Async */
+                if (when == SUBMIT)
+                        dev_info(&udev->dev, "userurb %p, ep%d %s-%s, "
+                                        "length %u\n",
+                                        userurb, ep, t, d, length);
+                else
+                        dev_info(&udev->dev, "userurb %p, ep%d %s-%s, "
+                                        "actual_length %u status %d\n",
+                                        userurb, ep, t, d, length,
+                                        timeout_or_status);
+        } else {
+                if (when == SUBMIT)
+                        dev_info(&udev->dev, "ep%d %s-%s, length %u, "
+                                        "timeout %d\n",
+                                        ep, t, d, length, timeout_or_status);
+                else
+                        dev_info(&udev->dev, "ep%d %s-%s, actual_length %u, "
+                                        "status %d\n",
+                                        ep, t, d, length, timeout_or_status);
+        }
+}
+
+#define AS_CONTINUATION 1
+#define AS_UNLINK       2
+
+static void cancel_bulk_urbs(struct dev_state *ps, unsigned bulk_addr)
+__releases(ps->lock)
+__acquires(ps->lock)
+{
+        struct async *as;
+
+        /* Mark all the pending URBs that match bulk_addr, up to but not
+         * including the first one without AS_CONTINUATION.  If such an
+         * URB is encountered then a new transfer has already started so
+         * the endpoint doesn't need to be disabled; otherwise it does.
+         */
+        list_for_each_entry(as, &ps->async_pending, asynclist) {
+                if (as->bulk_addr == bulk_addr) {
+                        if (as->bulk_status != AS_CONTINUATION)
+                                goto rescan;
+                        as->bulk_status = AS_UNLINK;
+                        as->bulk_addr = 0;
+                }
+        }
+        ps->disabled_bulk_eps |= (1 << bulk_addr);
+
+        /* Now carefully unlink all the marked pending URBs */
+ rescan:
+        list_for_each_entry(as, &ps->async_pending, asynclist) {
+                if (as->bulk_status == AS_UNLINK) {
+                        as->bulk_status = 0;            /* Only once */
+                        spin_unlock(&ps->lock);         /* Allow completions */
+                        usb_unlink_urb(as->urb);
+                        spin_lock(&ps->lock);
+                        goto rescan;
+                }
+        }
 }
 
 static void async_completed(struct urb *urb)
@@ -346,7 +409,11 @@ static void async_completed(struct urb *urb)
                 secid = as->secid;
         }
         snoop(&urb->dev->dev, "urb complete\n");
-        snoop_urb(urb, as->userurb);
+        snoop_urb(urb->dev, as->userurb, urb->pipe, urb->actual_length,
+                        as->status, COMPLETE);
+        if (as->status < 0 && as->bulk_addr && as->status != -ECONNRESET &&
+                        as->status != -ENOENT)
+                cancel_bulk_urbs(ps, as->bulk_addr);
         spin_unlock(&ps->lock);
 
         if (signr)
@@ -655,6 +722,7 @@ static int usbdev_release(struct inode *inode, struct file *file)
         struct async *as;
 
         usb_lock_device(dev);
+        usb_hub_release_all_ports(dev, ps);
 
         /* Protect against simultaneous open */
         mutex_lock(&usbfs_mutex);
@@ -688,7 +756,7 @@ static int proc_control(struct dev_state *ps, void __user *arg)
         unsigned int tmo;
         unsigned char *tbuf;
         unsigned wLength;
-        int i, j, ret;
+        int i, pipe, ret;
 
         if (copy_from_user(&ctrl, arg, sizeof(ctrl)))
                 return -EFAULT;
@@ -708,24 +776,17 @@ static int proc_control(struct dev_state *ps, void __user *arg)
                         free_page((unsigned long)tbuf);
                         return -EINVAL;
                 }
-                snoop(&dev->dev, "control read: bRequest=%02x "
-                                "bRrequestType=%02x wValue=%04x "
-                                "wIndex=%04x wLength=%04x\n",
-                        ctrl.bRequest, ctrl.bRequestType, ctrl.wValue,
-                                ctrl.wIndex, ctrl.wLength);
+                pipe = usb_rcvctrlpipe(dev, 0);
+                snoop_urb(dev, NULL, pipe, ctrl.wLength, tmo, SUBMIT);
 
                 usb_unlock_device(dev);
-                i = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), ctrl.bRequest,
+                i = usb_control_msg(dev, pipe, ctrl.bRequest,
                                     ctrl.bRequestType, ctrl.wValue, ctrl.wIndex,
                                     tbuf, ctrl.wLength, tmo);
                 usb_lock_device(dev);
+                snoop_urb(dev, NULL, pipe, max(i, 0), min(i, 0), COMPLETE);
+
                 if ((i > 0) && ctrl.wLength) {
-                        if (usbfs_snoop) {
-                                dev_info(&dev->dev, "control read: data ");
-                                for (j = 0; j < i; ++j)
-                                        printk("%02x ", (u8)(tbuf)[j]);
-                                printk("\n");
-                        }
                         if (copy_to_user(ctrl.data, tbuf, i)) {
                                 free_page((unsigned long)tbuf);
                                 return -EFAULT;
@@ -738,22 +799,15 @@ static int proc_control(struct dev_state *ps, void __user *arg)
                                 return -EFAULT;
                         }
                 }
-                snoop(&dev->dev, "control write: bRequest=%02x "
-                                "bRrequestType=%02x wValue=%04x "
-                                "wIndex=%04x wLength=%04x\n",
-                        ctrl.bRequest, ctrl.bRequestType, ctrl.wValue,
-                                ctrl.wIndex, ctrl.wLength);
-                if (usbfs_snoop) {
-                        dev_info(&dev->dev, "control write: data: ");
-                        for (j = 0; j < ctrl.wLength; ++j)
-                                printk("%02x ", (unsigned char)(tbuf)[j]);
-                        printk("\n");
-                }
+                pipe = usb_sndctrlpipe(dev, 0);
+                snoop_urb(dev, NULL, pipe, ctrl.wLength, tmo, SUBMIT);
+
                 usb_unlock_device(dev);
                 i = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), ctrl.bRequest,
                                     ctrl.bRequestType, ctrl.wValue, ctrl.wIndex,
                                     tbuf, ctrl.wLength, tmo);
                 usb_lock_device(dev);
+                snoop_urb(dev, NULL, pipe, max(i, 0), min(i, 0), COMPLETE);
         }
         free_page((unsigned long)tbuf);
         if (i < 0 && i != -EPIPE) {
@@ -772,7 +826,7 @@ static int proc_bulk(struct dev_state *ps, void __user *arg)
         unsigned int tmo, len1, pipe;
         int len2;
         unsigned char *tbuf;
-        int i, j, ret;
+        int i, ret;
 
         if (copy_from_user(&bulk, arg, sizeof(bulk)))
                 return -EFAULT;
@@ -799,18 +853,14 @@ static int proc_bulk(struct dev_state *ps, void __user *arg)
                         kfree(tbuf);
                         return -EINVAL;
                 }
-                snoop(&dev->dev, "bulk read: len=0x%02x timeout=%04d\n",
-                        bulk.len, bulk.timeout);
+                snoop_urb(dev, NULL, pipe, len1, tmo, SUBMIT);
+
                 usb_unlock_device(dev);
                 i = usb_bulk_msg(dev, pipe, tbuf, len1, &len2, tmo);
                 usb_lock_device(dev);
+                snoop_urb(dev, NULL, pipe, len2, i, COMPLETE);
+
                 if (!i && len2) {
-                        if (usbfs_snoop) {
-                                dev_info(&dev->dev, "bulk read: data ");
-                                for (j = 0; j < len2; ++j)
-                                        printk("%02x ", (u8)(tbuf)[j]);
-                                printk("\n");
-                        }
                         if (copy_to_user(bulk.data, tbuf, len2)) {
                                 kfree(tbuf);
                                 return -EFAULT;
@@ -823,17 +873,12 @@ static int proc_bulk(struct dev_state *ps, void __user *arg)
                                 return -EFAULT;
                         }
                 }
-                snoop(&dev->dev, "bulk write: len=0x%02x timeout=%04d\n",
-                        bulk.len, bulk.timeout);
-                if (usbfs_snoop) {
-                        dev_info(&dev->dev, "bulk write: data: ");
-                        for (j = 0; j < len1; ++j)
-                                printk("%02x ", (unsigned char)(tbuf)[j]);
-                        printk("\n");
-                }
+                snoop_urb(dev, NULL, pipe, len1, tmo, SUBMIT);
+
                 usb_unlock_device(dev);
                 i = usb_bulk_msg(dev, pipe, tbuf, len1, &len2, tmo);
                 usb_lock_device(dev);
+                snoop_urb(dev, NULL, pipe, len2, i, COMPLETE);
         }
         kfree(tbuf);
         if (i < 0)
@@ -991,6 +1036,7 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
 
         if (uurb->flags & ~(USBDEVFS_URB_ISO_ASAP |
                                 USBDEVFS_URB_SHORT_NOT_OK |
+                                USBDEVFS_URB_BULK_CONTINUATION |
                                 USBDEVFS_URB_NO_FSBR |
                                 USBDEVFS_URB_ZERO_PACKET |
                                 USBDEVFS_URB_NO_INTERRUPT))
@@ -1051,13 +1097,6 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
                         is_in = 0;
                         uurb->endpoint &= ~USB_DIR_IN;
                 }
-                snoop(&ps->dev->dev, "control urb: bRequest=%02x "
-                        "bRrequestType=%02x wValue=%04x "
-                        "wIndex=%04x wLength=%04x\n",
-                        dr->bRequest, dr->bRequestType,
-                        __le16_to_cpup(&dr->wValue),
-                        __le16_to_cpup(&dr->wIndex),
-                        __le16_to_cpup(&dr->wLength));
                 break;
 
         case USBDEVFS_URB_TYPE_BULK:
@@ -1070,7 +1109,6 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
                 uurb->number_of_packets = 0;
                 if (uurb->buffer_length > MAX_USBFS_BUFFER_SIZE)
                         return -EINVAL;
-                snoop(&ps->dev->dev, "bulk urb\n");
                 break;
 
         case USBDEVFS_URB_TYPE_ISO:
@@ -1097,12 +1135,12 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
                         }
                         totlen += isopkt[u].length;
                 }
-                if (totlen > 32768) {
+                /* 3072 * 64 microframes */
+                if (totlen > 196608) {
                         kfree(isopkt);
                         return -EINVAL;
                 }
                 uurb->buffer_length = totlen;
-                snoop(&ps->dev->dev, "iso urb\n");
                 break;
 
         case USBDEVFS_URB_TYPE_INTERRUPT:
@@ -1111,7 +1149,6 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
                         return -EINVAL;
                 if (uurb->buffer_length > MAX_USBFS_BUFFER_SIZE)
                         return -EINVAL;
-                snoop(&ps->dev->dev, "interrupt urb\n");
                 break;
 
         default:
@@ -1198,11 +1235,46 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
                         return -EFAULT;
                 }
         }
-        snoop_urb(as->urb, as->userurb);
+        snoop_urb(ps->dev, as->userurb, as->urb->pipe,
+                        as->urb->transfer_buffer_length, 0, SUBMIT);
         async_newpending(as);
-        if ((ret = usb_submit_urb(as->urb, GFP_KERNEL))) {
+
+        if (usb_endpoint_xfer_bulk(&ep->desc)) {
+                spin_lock_irq(&ps->lock);
+
+                /* Not exactly the endpoint address; the direction bit is
+                 * shifted to the 0x10 position so that the value will be
+                 * between 0 and 31.
+                 */
+                as->bulk_addr = usb_endpoint_num(&ep->desc) |
+                        ((ep->desc.bEndpointAddress & USB_ENDPOINT_DIR_MASK)
+                                >> 3);
+
+                /* If this bulk URB is the start of a new transfer, re-enable
+                 * the endpoint.  Otherwise mark it as a continuation URB.
+                 */
+                if (uurb->flags & USBDEVFS_URB_BULK_CONTINUATION)
+                        as->bulk_status = AS_CONTINUATION;
+                else
+                        ps->disabled_bulk_eps &= ~(1 << as->bulk_addr);
+
+                /* Don't accept continuation URBs if the endpoint is
+                 * disabled because of an earlier error.
+                 */
+                if (ps->disabled_bulk_eps & (1 << as->bulk_addr))
+                        ret = -EREMOTEIO;
+                else
+                        ret = usb_submit_urb(as->urb, GFP_ATOMIC);
+                spin_unlock_irq(&ps->lock);
+        } else {
+                ret = usb_submit_urb(as->urb, GFP_KERNEL);
+        }
+
+        if (ret) {
                 dev_printk(KERN_DEBUG, &ps->dev->dev,
                            "usbfs: usb_submit_urb returned %d\n", ret);
+                snoop_urb(ps->dev, as->userurb, as->urb->pipe,
+                                0, ret, COMPLETE);
                 async_removepending(as);
                 free_async(as);
                 return ret;
@@ -1548,6 +1620,29 @@ static int proc_ioctl_compat(struct dev_state *ps, compat_uptr_t arg)
 }
 #endif
 
+static int proc_claim_port(struct dev_state *ps, void __user *arg)
+{
+        unsigned portnum;
+        int rc;
+
+        if (get_user(portnum, (unsigned __user *) arg))
+                return -EFAULT;
+        rc = usb_hub_claim_port(ps->dev, portnum, ps);
+        if (rc == 0)
+                snoop(&ps->dev->dev, "port %d claimed by process %d: %s\n",
+                        portnum, task_pid_nr(current), current->comm);
+        return rc;
+}
+
+static int proc_release_port(struct dev_state *ps, void __user *arg)
+{
+        unsigned portnum;
+
+        if (get_user(portnum, (unsigned __user *) arg))
+                return -EFAULT;
+        return usb_hub_release_port(ps->dev, portnum, ps);
+}
+
 /*
  * NOTE:  All requests here that have interface numbers as parameters
  * are assuming that somehow the configuration has been prevented from
@@ -1645,7 +1740,7 @@ static int usbdev_ioctl(struct inode *inode, struct file *file,
                 break;
 
         case USBDEVFS_REAPURBNDELAY32:
-                snoop(&dev->dev, "%s: REAPURBDELAY32\n", __func__);
+                snoop(&dev->dev, "%s: REAPURBNDELAY32\n", __func__);
                 ret = proc_reapurbnonblock_compat(ps, p);
                 break;
 
@@ -1666,7 +1761,7 @@ static int usbdev_ioctl(struct inode *inode, struct file *file,
                 break;
 
         case USBDEVFS_REAPURBNDELAY:
-                snoop(&dev->dev, "%s: REAPURBDELAY\n", __func__);
+                snoop(&dev->dev, "%s: REAPURBNDELAY\n", __func__);
                 ret = proc_reapurbnonblock(ps, p);
                 break;
 
@@ -1689,6 +1784,16 @@ static int usbdev_ioctl(struct inode *inode, struct file *file,
                 snoop(&dev->dev, "%s: IOCTL\n", __func__);
                 ret = proc_ioctl_default(ps, p);
                 break;
+
+        case USBDEVFS_CLAIM_PORT:
+                snoop(&dev->dev, "%s: CLAIM_PORT\n", __func__);
+                ret = proc_claim_port(ps, p);
+                break;
+
+        case USBDEVFS_RELEASE_PORT:
+                snoop(&dev->dev, "%s: RELEASE_PORT\n", __func__);
+                ret = proc_release_port(ps, p);
+                break;
         }
         usb_unlock_device(dev);
         if (ret >= 0)
diff --git a/drivers/usb/core/driver.c b/drivers/usb/core/driver.c
index 69e5773abfce..4f864472c5c4 100644
--- a/drivers/usb/core/driver.c
+++ b/drivers/usb/core/driver.c
@@ -207,6 +207,9 @@ static int usb_probe_interface(struct device *dev)
 
         intf->needs_binding = 0;
 
+        if (usb_device_is_owned(udev))
+                return -ENODEV;
+
         if (udev->authorized == 0) {
                 dev_err(&intf->dev, "Device is not authorized for usage\n");
                 return -ENODEV;
@@ -232,28 +235,35 @@ static int usb_probe_interface(struct device *dev)
                 /* The interface should always appear to be in use
                  * unless the driver suports autosuspend.
                  */
-                intf->pm_usage_cnt = !(driver->supports_autosuspend);
+                atomic_set(&intf->pm_usage_cnt, !driver->supports_autosuspend);
 
                 /* Carry out a deferred switch to altsetting 0 */
                 if (intf->needs_altsetting0) {
-                        usb_set_interface(udev, intf->altsetting[0].
+                        error = usb_set_interface(udev, intf->altsetting[0].
                                         desc.bInterfaceNumber, 0);
+                        if (error < 0)
+                                goto err;
+
                         intf->needs_altsetting0 = 0;
                 }
 
                 error = driver->probe(intf, id);
-                if (error) {
-                        mark_quiesced(intf);
-                        intf->needs_remote_wakeup = 0;
-                        intf->condition = USB_INTERFACE_UNBOUND;
-                        usb_cancel_queued_reset(intf);
-                } else
-                        intf->condition = USB_INTERFACE_BOUND;
+                if (error)
+                        goto err;
 
+                intf->condition = USB_INTERFACE_BOUND;
                 usb_autosuspend_device(udev);
         }
 
         return error;
+
+err:
+        mark_quiesced(intf);
+        intf->needs_remote_wakeup = 0;
+        intf->condition = USB_INTERFACE_UNBOUND;
+        usb_cancel_queued_reset(intf);
+        usb_autosuspend_device(udev);
+        return error;
 }
 
 /* called from driver core with dev locked */
@@ -262,7 +272,7 @@ static int usb_unbind_interface(struct device *dev)
         struct usb_driver *driver = to_usb_driver(dev->driver);
         struct usb_interface *intf = to_usb_interface(dev);
         struct usb_device *udev;
-        int error;
+        int error, r;
 
         intf->condition = USB_INTERFACE_UNBINDING;
 
@@ -290,11 +300,14 @@ static int usb_unbind_interface(struct device *dev)
                  * Just re-enable it without affecting the endpoint toggles.
                  */
                 usb_enable_interface(udev, intf, false);
-        } else if (!error && intf->dev.power.status == DPM_ON)
-                usb_set_interface(udev, intf->altsetting[0].
+        } else if (!error && intf->dev.power.status == DPM_ON) {
+                r = usb_set_interface(udev, intf->altsetting[0].
                                 desc.bInterfaceNumber, 0);
-        else
+                if (r < 0)
+                        intf->needs_altsetting0 = 1;
+        } else {
                 intf->needs_altsetting0 = 1;
+        }
         usb_set_intfdata(intf, NULL);
 
         intf->condition = USB_INTERFACE_UNBOUND;
@@ -344,7 +357,7 @@ int usb_driver_claim_interface(struct usb_driver *driver,
         usb_pm_lock(udev);
         iface->condition = USB_INTERFACE_BOUND;
         mark_active(iface);
-        iface->pm_usage_cnt = !(driver->supports_autosuspend);
+        atomic_set(&iface->pm_usage_cnt, !driver->supports_autosuspend);
         usb_pm_unlock(udev);
 
         /* if interface was already added, bind now; else let
@@ -1065,7 +1078,7 @@ static int autosuspend_check(struct usb_device *udev, int reschedule)
                         intf = udev->actconfig->interface[i];
                         if (!is_active(intf))
                                 continue;
-                        if (intf->pm_usage_cnt > 0)
+                        if (atomic_read(&intf->pm_usage_cnt) > 0)
                                 return -EBUSY;
                         if (intf->needs_remote_wakeup &&
                                         !udev->do_remote_wakeup) {
@@ -1461,17 +1474,19 @@ static int usb_autopm_do_interface(struct usb_interface *intf,
                 status = -ENODEV;
         else {
                 udev->auto_pm = 1;
-                intf->pm_usage_cnt += inc_usage_cnt;
+                atomic_add(inc_usage_cnt, &intf->pm_usage_cnt);
                 udev->last_busy = jiffies;
-                if (inc_usage_cnt >= 0 && intf->pm_usage_cnt > 0) {
+                if (inc_usage_cnt >= 0 &&
+                                atomic_read(&intf->pm_usage_cnt) > 0) {
                         if (udev->state == USB_STATE_SUSPENDED)
                                 status = usb_resume_both(udev,
                                                 PMSG_AUTO_RESUME);
                         if (status != 0)
-                                intf->pm_usage_cnt -= inc_usage_cnt;
+                                atomic_sub(inc_usage_cnt, &intf->pm_usage_cnt);
                         else
                                 udev->last_busy = jiffies;
-                } else if (inc_usage_cnt <= 0 && intf->pm_usage_cnt <= 0) {
+                } else if (inc_usage_cnt <= 0 &&
+                                atomic_read(&intf->pm_usage_cnt) <= 0) {
                         status = usb_suspend_both(udev, PMSG_AUTO_SUSPEND);
                 }
         }
@@ -1516,7 +1531,7 @@ void usb_autopm_put_interface(struct usb_interface *intf)
 
         status = usb_autopm_do_interface(intf, -1);
         dev_vdbg(&intf->dev, "%s: status %d cnt %d\n",
-                        __func__, status, intf->pm_usage_cnt);
+                        __func__, status, atomic_read(&intf->pm_usage_cnt));
 }
 EXPORT_SYMBOL_GPL(usb_autopm_put_interface);
 
@@ -1544,10 +1559,10 @@ void usb_autopm_put_interface_async(struct usb_interface *intf)
                 status = -ENODEV;
         } else {
                 udev->last_busy = jiffies;
-                --intf->pm_usage_cnt;
+                atomic_dec(&intf->pm_usage_cnt);
                 if (udev->autosuspend_disabled || udev->autosuspend_delay < 0)
                         status = -EPERM;
-                else if (intf->pm_usage_cnt <= 0 &&
+                else if (atomic_read(&intf->pm_usage_cnt) <= 0 &&
                                 !timer_pending(&udev->autosuspend.timer)) {
                         queue_delayed_work(ksuspend_usb_wq, &udev->autosuspend,
                                         round_jiffies_up_relative(
@@ -1555,7 +1570,7 @@ void usb_autopm_put_interface_async(struct usb_interface *intf)
                 }
         }
         dev_vdbg(&intf->dev, "%s: status %d cnt %d\n",
-                        __func__, status, intf->pm_usage_cnt);
+                        __func__, status, atomic_read(&intf->pm_usage_cnt));
 }
 EXPORT_SYMBOL_GPL(usb_autopm_put_interface_async);
 
@@ -1599,7 +1614,7 @@ int usb_autopm_get_interface(struct usb_interface *intf)
 
         status = usb_autopm_do_interface(intf, 1);
         dev_vdbg(&intf->dev, "%s: status %d cnt %d\n",
-                        __func__, status, intf->pm_usage_cnt);
+                        __func__, status, atomic_read(&intf->pm_usage_cnt));
         return status;
 }
 EXPORT_SYMBOL_GPL(usb_autopm_get_interface);
@@ -1627,10 +1642,14 @@ int usb_autopm_get_interface_async(struct usb_interface *intf)
                 status = -ENODEV;
         else if (udev->autoresume_disabled)
                 status = -EPERM;
-        else if (++intf->pm_usage_cnt > 0 && udev->state == USB_STATE_SUSPENDED)
-                queue_work(ksuspend_usb_wq, &udev->autoresume);
+        else {
+                atomic_inc(&intf->pm_usage_cnt);
+                if (atomic_read(&intf->pm_usage_cnt) > 0 &&
+                                udev->state == USB_STATE_SUSPENDED)
+                        queue_work(ksuspend_usb_wq, &udev->autoresume);
+        }
         dev_vdbg(&intf->dev, "%s: status %d cnt %d\n",
-                        __func__, status, intf->pm_usage_cnt);
+                        __func__, status, atomic_read(&intf->pm_usage_cnt));
         return status;
 }
 EXPORT_SYMBOL_GPL(usb_autopm_get_interface_async);
@@ -1652,7 +1671,7 @@ int usb_autopm_set_interface(struct usb_interface *intf)
 
         status = usb_autopm_do_interface(intf, 0);
         dev_vdbg(&intf->dev, "%s: status %d cnt %d\n",
-                        __func__, status, intf->pm_usage_cnt);
+                        __func__, status, atomic_read(&intf->pm_usage_cnt));
         return status;
 }
 EXPORT_SYMBOL_GPL(usb_autopm_set_interface);
diff --git a/drivers/usb/core/generic.c b/drivers/usb/core/generic.c
index 30ecac3af15a..05e6d313961e 100644
--- a/drivers/usb/core/generic.c
+++ b/drivers/usb/core/generic.c
@@ -158,7 +158,9 @@ static int generic_probe(struct usb_device *udev)
         /* Choose and set the configuration.  This registers the interfaces
          * with the driver core and lets interface drivers bind to them.
          */
-        if (udev->authorized == 0)
+        if (usb_device_is_owned(udev))
+                ;               /* Don't configure if the device is owned */
+        else if (udev->authorized == 0)
                 dev_err(&udev->dev, "Device is not authorized for usage\n");
         else {
                 c = usb_choose_configuration(udev);
diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
index 95ccfa0b9fc5..34de475f016e 100644
--- a/drivers/usb/core/hcd.c
+++ b/drivers/usb/core/hcd.c
@@ -337,72 +337,89 @@ static const u8 ss_rh_config_descriptor[] = {
 
 /*-------------------------------------------------------------------------*/
 
-/*
- * helper routine for returning string descriptors in UTF-16LE
- * input can actually be ISO-8859-1; ASCII is its 7-bit subset
+/**
+ * ascii2desc() - Helper routine for producing UTF-16LE string descriptors
+ * @s: Null-terminated ASCII (actually ISO-8859-1) string
+ * @buf: Buffer for USB string descriptor (header + UTF-16LE)
+ * @len: Length (in bytes; may be odd) of descriptor buffer.
+ *
+ * The return value is the number of bytes filled in: 2 + 2*strlen(s) or
+ * buflen, whichever is less.
+ *
+ * USB String descriptors can contain at most 126 characters; input
+ * strings longer than that are truncated.
  */
-static unsigned ascii2utf(char *s, u8 *utf, int utfmax)
+static unsigned
+ascii2desc(char const *s, u8 *buf, unsigned len)
 {
-        unsigned retval;
+        unsigned n, t = 2 + 2*strlen(s);
 
-        for (retval = 0; *s && utfmax > 1; utfmax -= 2, retval += 2) {
-                *utf++ = *s++;
-                *utf++ = 0;
-        }
-        if (utfmax > 0) {
-                *utf = *s;
-                ++retval;
+        if (t > 254)
+                t = 254;        /* Longest possible UTF string descriptor */
+        if (len > t)
+                len = t;
+
+        t += USB_DT_STRING << 8;        /* Now t is first 16 bits to store */
+
+        n = len;
+        while (n--) {
+                *buf++ = t;
+                if (!n--)
+                        break;
+                *buf++ = t >> 8;
+                t = (unsigned char)*s++;
         }
-        return retval;
+        return len;
 }
 
-/*
- * rh_string - provides manufacturer, product and serial strings for root hub
- * @id: the string ID number (1: serial number, 2: product, 3: vendor)
+/**
+ * rh_string() - provides string descriptors for root hub
+ * @id: the string ID number (0: langids, 1: serial #, 2: product, 3: vendor)
  * @hcd: the host controller for this root hub
- * @data: return packet in UTF-16 LE
- * @len: length of the return packet
+ * @data: buffer for output packet
+ * @len: length of the provided buffer
  *
  * Produces either a manufacturer, product or serial number string for the
  * virtual root hub device.
+ * Returns the number of bytes filled in: the length of the descriptor or
+ * of the provided buffer, whichever is less.
  */
-static unsigned rh_string(int id, struct usb_hcd *hcd, u8 *data, unsigned len)
+static unsigned
+rh_string(int id, struct usb_hcd const *hcd, u8 *data, unsigned len)
 {
-        char buf [100];
+        char buf[100];
+        char const *s;
+        static char const langids[4] = {4, USB_DT_STRING, 0x09, 0x04};
 
         // language ids
-        if (id == 0) {
-                buf[0] = 4;    buf[1] = 3;      /* 4 bytes string data */
-                buf[2] = 0x09; buf[3] = 0x04;   /* MSFT-speak for "en-us" */
-                len = min_t(unsigned, len, 4);
-                memcpy (data, buf, len);
+        switch (id) {
+        case 0:
+                /* Array of LANGID codes (0x0409 is MSFT-speak for "en-us") */
+                /* See http://www.usb.org/developers/docs/USB_LANGIDs.pdf */
+                if (len > 4)
+                        len = 4;
+                memcpy(data, langids, len);
                 return len;
-
-        // serial number
-        } else if (id == 1) {
-                strlcpy (buf, hcd->self.bus_name, sizeof buf);
-
-        // product description
-        } else if (id == 2) {
-                strlcpy (buf, hcd->product_desc, sizeof buf);
-
-        // id 3 == vendor description
-        } else if (id == 3) {
+        case 1:
+                /* Serial number */
+                s = hcd->self.bus_name;
+                break;
+        case 2:
+                /* Product name */
+                s = hcd->product_desc;
+                break;
+        case 3:
+                /* Manufacturer */
                 snprintf (buf, sizeof buf, "%s %s %s", init_utsname()->sysname,
                         init_utsname()->release, hcd->driver->description);
-        }
-
-        switch (len) {          /* All cases fall through */
+                s = buf;
+                break;
         default:
-                len = 2 + ascii2utf (buf, data + 2, len - 2);
-        case 2:
-                data [1] = 3;   /* type == string */
-        case 1:
-                data [0] = 2 * (strlen (buf) + 1);
-        case 0:
-                ;               /* Compiler wants a statement here */
+                /* Can't happen; caller guarantees it */
+                return 0;
         }
-        return len;
+
+        return ascii2desc(s, data, len);
 }
 
 
diff --git a/drivers/usb/core/hcd.h b/drivers/usb/core/hcd.h
index ec5c67ea07b7..79782a1c43f6 100644
--- a/drivers/usb/core/hcd.h
+++ b/drivers/usb/core/hcd.h
@@ -267,6 +267,11 @@ struct hc_driver {
         void    (*reset_bandwidth)(struct usb_hcd *, struct usb_device *);
                 /* Returns the hardware-chosen device address */
         int     (*address_device)(struct usb_hcd *, struct usb_device *udev);
+                /* Notifies the HCD after a hub descriptor is fetched.
+                 * Will block.
+                 */
+        int     (*update_hub_device)(struct usb_hcd *, struct usb_device *hdev,
+                        struct usb_tt *tt, gfp_t mem_flags);
 };
 
 extern int usb_hcd_link_urb_to_ep(struct usb_hcd *hcd, struct urb *urb);
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index 71f86c60d83c..5ce839137ad6 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -78,6 +78,7 @@ struct usb_hub {
         u8                      indicator[USB_MAXCHILDREN];
         struct delayed_work     leds;
         struct delayed_work     init_work;
+        void                    **port_owners;
 };
 
 
@@ -162,8 +163,10 @@ static inline char *portspeed(int portstatus)
 }
 
 /* Note that hdev or one of its children must be locked! */
-static inline struct usb_hub *hdev_to_hub(struct usb_device *hdev)
+static struct usb_hub *hdev_to_hub(struct usb_device *hdev)
 {
+        if (!hdev || !hdev->actconfig)
+                return NULL;
         return usb_get_intfdata(hdev->actconfig->interface[0]);
 }
 
@@ -372,7 +375,7 @@ static void kick_khubd(struct usb_hub *hub)
         unsigned long   flags;
 
         /* Suppress autosuspend until khubd runs */
-        to_usb_interface(hub->intfdev)->pm_usage_cnt = 1;
+        atomic_set(&to_usb_interface(hub->intfdev)->pm_usage_cnt, 1);
 
         spin_lock_irqsave(&hub_event_lock, flags);
         if (!hub->disconnected && list_empty(&hub->event_list)) {
@@ -384,8 +387,10 @@ static void kick_khubd(struct usb_hub *hub)
 
 void usb_kick_khubd(struct usb_device *hdev)
 {
-        /* FIXME: What if hdev isn't bound to the hub driver? */
-        kick_khubd(hdev_to_hub(hdev));
+        struct usb_hub *hub = hdev_to_hub(hdev);
+
+        if (hub)
+                kick_khubd(hub);
 }
 
 
@@ -677,7 +682,8 @@ static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)
                                         msecs_to_jiffies(delay));
 
                         /* Suppress autosuspend until init is done */
-                        to_usb_interface(hub->intfdev)->pm_usage_cnt = 1;
+                        atomic_set(&to_usb_interface(hub->intfdev)->
+                                        pm_usage_cnt, 1);
                         return;         /* Continues at init2: below */
                 } else {
                         hub_power_on(hub, true);
@@ -854,25 +860,24 @@ static int hub_post_reset(struct usb_interface *intf)
 static int hub_configure(struct usb_hub *hub,
         struct usb_endpoint_descriptor *endpoint)
 {
+        struct usb_hcd *hcd;
         struct usb_device *hdev = hub->hdev;
         struct device *hub_dev = hub->intfdev;
         u16 hubstatus, hubchange;
         u16 wHubCharacteristics;
         unsigned int pipe;
         int maxp, ret;
-        char *message;
+        char *message = "out of memory";
 
         hub->buffer = usb_buffer_alloc(hdev, sizeof(*hub->buffer), GFP_KERNEL,
                         &hub->buffer_dma);
         if (!hub->buffer) {
-                message = "can't allocate hub irq buffer";
                 ret = -ENOMEM;
                 goto fail;
         }
 
         hub->status = kmalloc(sizeof(*hub->status), GFP_KERNEL);
         if (!hub->status) {
-                message = "can't kmalloc hub status buffer";
                 ret = -ENOMEM;
                 goto fail;
         }
@@ -880,7 +885,6 @@ static int hub_configure(struct usb_hub *hub,
 
         hub->descriptor = kmalloc(sizeof(*hub->descriptor), GFP_KERNEL);
         if (!hub->descriptor) {
-                message = "can't kmalloc hub descriptor";
                 ret = -ENOMEM;
                 goto fail;
         }
@@ -904,6 +908,12 @@ static int hub_configure(struct usb_hub *hub,
         dev_info (hub_dev, "%d port%s detected\n", hdev->maxchild,
                 (hdev->maxchild == 1) ? "" : "s");
 
+        hub->port_owners = kzalloc(hdev->maxchild * sizeof(void *), GFP_KERNEL);
+        if (!hub->port_owners) {
+                ret = -ENOMEM;
+                goto fail;
+        }
+
         wHubCharacteristics = le16_to_cpu(hub->descriptor->wHubCharacteristics);
 
         if (wHubCharacteristics & HUB_CHAR_COMPOUND) {
@@ -1052,6 +1062,19 @@ static int hub_configure(struct usb_hub *hub,
                 dev_dbg(hub_dev, "%umA bus power budget for each child\n",
                                 hub->mA_per_port);
 
+        /* Update the HCD's internal representation of this hub before khubd
+         * starts getting port status changes for devices under the hub.
+         */
+        hcd = bus_to_hcd(hdev->bus);
+        if (hcd->driver->update_hub_device) {
+                ret = hcd->driver->update_hub_device(hcd, hdev,
+                                &hub->tt, GFP_KERNEL);
+                if (ret < 0) {
+                        message = "can't update HCD hub info";
+                        goto fail;
+                }
+        }
+
         ret = hub_hub_status(hub, &hubstatus, &hubchange);
         if (ret < 0) {
                 message = "can't get hub status";
@@ -1082,7 +1105,6 @@ static int hub_configure(struct usb_hub *hub,
 
         hub->urb = usb_alloc_urb(0, GFP_KERNEL);
         if (!hub->urb) {
-                message = "couldn't allocate interrupt urb";
                 ret = -ENOMEM;
                 goto fail;
         }
@@ -1131,11 +1153,13 @@ static void hub_disconnect(struct usb_interface *intf)
         hub_quiesce(hub, HUB_DISCONNECT);
 
         usb_set_intfdata (intf, NULL);
+        hub->hdev->maxchild = 0;
 
         if (hub->hdev->speed == USB_SPEED_HIGH)
                 highspeed_hubs--;
 
         usb_free_urb(hub->urb);
+        kfree(hub->port_owners);
         kfree(hub->descriptor);
         kfree(hub->status);
         usb_buffer_free(hub->hdev, sizeof(*hub->buffer), hub->buffer,
@@ -1250,6 +1274,79 @@ hub_ioctl(struct usb_interface *intf, unsigned int code, void *user_data)
         }
 }
 
+/*
+ * Allow user programs to claim ports on a hub.  When a device is attached
+ * to one of these "claimed" ports, the program will "own" the device.
+ */
+static int find_port_owner(struct usb_device *hdev, unsigned port1,
+                void ***ppowner)
+{
+        if (hdev->state == USB_STATE_NOTATTACHED)
+                return -ENODEV;
+        if (port1 == 0 || port1 > hdev->maxchild)
+                return -EINVAL;
+
+        /* This assumes that devices not managed by the hub driver
+         * will always have maxchild equal to 0.
+         */
+        *ppowner = &(hdev_to_hub(hdev)->port_owners[port1 - 1]);
+        return 0;
+}
+
+/* In the following three functions, the caller must hold hdev's lock */
+int usb_hub_claim_port(struct usb_device *hdev, unsigned port1, void *owner)
+{
+        int rc;
+        void **powner;
+
+        rc = find_port_owner(hdev, port1, &powner);
+        if (rc)
+                return rc;
+        if (*powner)
+                return -EBUSY;
+        *powner = owner;
+        return rc;
+}
+
+int usb_hub_release_port(struct usb_device *hdev, unsigned port1, void *owner)
+{
+        int rc;
+        void **powner;
+
+        rc = find_port_owner(hdev, port1, &powner);
+        if (rc)
+                return rc;
+        if (*powner != owner)
+                return -ENOENT;
+        *powner = NULL;
+        return rc;
+}
+
+void usb_hub_release_all_ports(struct usb_device *hdev, void *owner)
+{
+        int n;
+        void **powner;
+
+        n = find_port_owner(hdev, 1, &powner);
+        if (n == 0) {
+                for (; n < hdev->maxchild; (++n, ++powner)) {
+                        if (*powner == owner)
+                                *powner = NULL;
+                }
+        }
+}
+
+/* The caller must hold udev's lock */
+bool usb_device_is_owned(struct usb_device *udev)
+{
+        struct usb_hub *hub;
+
+        if (udev->state == USB_STATE_NOTATTACHED || !udev->parent)
+                return false;
+        hub = hdev_to_hub(udev->parent);
+        return !!hub->port_owners[udev->portnum - 1];
+}
+
 
 static void recursively_mark_NOTATTACHED(struct usb_device *udev)
 {
@@ -2849,14 +2946,7 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1,
                         /* For a suspended device, treat this as a
                          * remote wakeup event.
                          */
-                        if (udev->do_remote_wakeup)
-                                status = remote_wakeup(udev);
-
-                        /* Otherwise leave it be; devices can't tell the
-                         * difference between suspended and disabled.
-                         */
-                        else
-                                status = 0;
+                        status = remote_wakeup(udev);
 #endif
 
                 } else {
diff --git a/drivers/usb/core/message.c b/drivers/usb/core/message.c
index 9720e699f472..da718e84d58d 100644
--- a/drivers/usb/core/message.c
+++ b/drivers/usb/core/message.c
@@ -459,35 +459,23 @@ int usb_sg_init(struct usb_sg_request *io, struct usb_device *dev,
                         io->urbs[i]->context = io;
 
                         /*
-                         * 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:
+                         * 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.
                          *
-                         *  - HIGHMEM, since DMA buffers located in high memory
-                         *    are not directly addressable by the CPU for PIO;
-                         *
-                         *  - IOMMU, since dma_map_sg() is allowed to use an
-                         *    IOMMU to make virtually discontiguous buffers be
-                         *    "dma-contiguous" so that PIO and DMA need diferent
-                         *    numbers of URBs.
-                         *
-                         * So when HIGHMEM or IOMMU are in use, transfer_buffer
-                         * is NULL to prevent stale pointers and to help spot
-                         * bugs.
+                         * Note that if IOMMU coalescing occurred, we cannot
+                         * trust sg_page anymore, so check if S/G list shrunk.
                          */
+                        if (io->nents == io->entries && !PageHighMem(sg_page(sg)))
+                                io->urbs[i]->transfer_buffer = sg_virt(sg);
+                        else
+                                io->urbs[i]->transfer_buffer = NULL;
+
                         if (dma) {
                                 io->urbs[i]->transfer_dma = sg_dma_address(sg);
                                 len = sg_dma_len(sg);
-#if defined(CONFIG_HIGHMEM) || defined(CONFIG_GART_IOMMU)
-                                io->urbs[i]->transfer_buffer = NULL;
-#else
-                                io->urbs[i]->transfer_buffer = sg_virt(sg);
-#endif
                         } else {
                                 /* hc may use _only_ transfer_buffer */
-                                io->urbs[i]->transfer_buffer = sg_virt(sg);
                                 len = sg->length;
                         }
 
diff --git a/drivers/usb/core/usb.c b/drivers/usb/core/usb.c
index 43ee943d757a..b1b85abb9a2d 100644
--- a/drivers/usb/core/usb.c
+++ b/drivers/usb/core/usb.c
@@ -413,8 +413,13 @@ struct usb_device *usb_alloc_dev(struct usb_device *parent,
                 } else {
                         snprintf(dev->devpath, sizeof dev->devpath,
                                 "%s.%d", parent->devpath, port1);
-                        dev->route = parent->route +
-                                (port1 << ((parent->level - 1)*4));
+                        /* Route string assumes hubs have less than 16 ports */
+                        if (port1 < 15)
+                                dev->route = parent->route +
+                                        (port1 << ((parent->level - 1)*4));
+                        else
+                                dev->route = parent->route +
+                                        (15 << ((parent->level - 1)*4));
                 }
 
                 dev->dev.parent = &parent->dev;
@@ -914,11 +919,11 @@ int usb_buffer_map_sg(const struct usb_device *dev, int is_in,
                         || !(bus = dev->bus)
                         || !(controller = bus->controller)
                         || !controller->dma_mask)
-                return -1;
+                return -EINVAL;
 
         /* FIXME generic api broken like pci, can't report errors */
         return dma_map_sg(controller, sg, nents,
-                        is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
+                        is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE) ? : -ENOMEM;
 }
 EXPORT_SYMBOL_GPL(usb_buffer_map_sg);
 
diff --git a/drivers/usb/core/usb.h b/drivers/usb/core/usb.h
index c0e0ae2bb8e7..9a8b15e6377a 100644
--- a/drivers/usb/core/usb.h
+++ b/drivers/usb/core/usb.h
@@ -37,6 +37,13 @@ extern int usb_match_device(struct usb_device *dev,
 extern void usb_forced_unbind_intf(struct usb_interface *intf);
 extern void usb_rebind_intf(struct usb_interface *intf);
 
+extern int usb_hub_claim_port(struct usb_device *hdev, unsigned port,
+                void *owner);
+extern int usb_hub_release_port(struct usb_device *hdev, unsigned port,
+                void *owner);
+extern void usb_hub_release_all_ports(struct usb_device *hdev, void *owner);
+extern bool usb_device_is_owned(struct usb_device *udev);
+
 extern int  usb_hub_init(void);
 extern void usb_hub_cleanup(void);
 extern int usb_major_init(void);