7 files changed, 134 insertions, 81 deletions

diff --git a/drivers/usb/core/devio.c b/drivers/usb/core/devio.c
index 737e3c19967b..f4f2300f8e10 100644
--- a/drivers/usb/core/devio.c
+++ b/drivers/usb/core/devio.c
@@ -898,10 +898,8 @@ static int proc_control(struct dev_state *ps, void __user *arg)
         snoop(&dev->dev, "control urb: bRequestType=%02x "
                 "bRequest=%02x wValue=%04x "
                 "wIndex=%04x wLength=%04x\n",
-                ctrl.bRequestType, ctrl.bRequest,
-                __le16_to_cpup(&ctrl.wValue),
-                __le16_to_cpup(&ctrl.wIndex),
-                __le16_to_cpup(&ctrl.wLength));
+                ctrl.bRequestType, ctrl.bRequest, ctrl.wValue,
+                ctrl.wIndex, ctrl.wLength);
         if (ctrl.bRequestType & 0x80) {
                 if (ctrl.wLength && !access_ok(VERIFY_WRITE, ctrl.data,
                                                ctrl.wLength)) {
diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
index d6a8d23f047b..9795a21bc612 100644
--- a/drivers/usb/core/hcd.c
+++ b/drivers/usb/core/hcd.c
@@ -1033,6 +1033,7 @@ static int register_root_hub(struct usb_hcd *hcd)
                                         dev_name(&usb_dev->dev), retval);
                         return retval;
                 }
+                usb_dev->lpm_capable = usb_device_supports_lpm(usb_dev);
         }
 
         retval = usb_new_device (usb_dev);
@@ -1703,7 +1704,9 @@ static void usb_giveback_urb_bh(unsigned long param)
 
                 urb = list_entry(local_list.next, struct urb, urb_list);
                 list_del_init(&urb->urb_list);
+                bh->completing_ep = urb->ep;
                 __usb_hcd_giveback_urb(urb);
+                bh->completing_ep = NULL;
         }
 
         /* check if there are new URBs to giveback */
@@ -2073,8 +2076,11 @@ EXPORT_SYMBOL_GPL(usb_alloc_streams);
  *
  * Reverts a group of bulk endpoints back to not using stream IDs.
  * Can fail if we are given bad arguments, or HCD is broken.
+ *
+ * Return: On success, the number of allocated streams. On failure, a negative
+ * error code.
  */
-void usb_free_streams(struct usb_interface *interface,
+int usb_free_streams(struct usb_interface *interface,
                 struct usb_host_endpoint **eps, unsigned int num_eps,
                 gfp_t mem_flags)
 {
@@ -2085,14 +2091,14 @@ void usb_free_streams(struct usb_interface *interface,
         dev = interface_to_usbdev(interface);
         hcd = bus_to_hcd(dev->bus);
         if (dev->speed != USB_SPEED_SUPER)
-                return;
+                return -EINVAL;
 
         /* Streams only apply to bulk endpoints. */
         for (i = 0; i < num_eps; i++)
                 if (!eps[i] || !usb_endpoint_xfer_bulk(&eps[i]->desc))
-                        return;
+                        return -EINVAL;
 
-        hcd->driver->free_streams(hcd, dev, eps, num_eps, mem_flags);
+        return hcd->driver->free_streams(hcd, dev, eps, num_eps, mem_flags);
 }
 EXPORT_SYMBOL_GPL(usb_free_streams);
 
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index dde4c83516a1..6f783bfe2959 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -135,7 +135,7 @@ struct usb_hub *usb_hub_to_struct_hub(struct usb_device *hdev)
         return usb_get_intfdata(hdev->actconfig->interface[0]);
 }
 
-static int usb_device_supports_lpm(struct usb_device *udev)
+int usb_device_supports_lpm(struct usb_device *udev)
 {
         /* USB 2.1 (and greater) devices indicate LPM support through
          * their USB 2.0 Extended Capabilities BOS descriptor.
@@ -156,6 +156,11 @@ static int usb_device_supports_lpm(struct usb_device *udev)
                                 "Power management will be impacted.\n");
                 return 0;
         }
+
+        /* udev is root hub */
+        if (!udev->parent)
+                return 1;
+
         if (udev->parent->lpm_capable)
                 return 1;
 
@@ -310,9 +315,9 @@ static void usb_set_lpm_parameters(struct usb_device *udev)
                 return;
 
         udev_u1_del = udev->bos->ss_cap->bU1devExitLat;
-        udev_u2_del = udev->bos->ss_cap->bU2DevExitLat;
+        udev_u2_del = le16_to_cpu(udev->bos->ss_cap->bU2DevExitLat);
         hub_u1_del = udev->parent->bos->ss_cap->bU1devExitLat;
-        hub_u2_del = udev->parent->bos->ss_cap->bU2DevExitLat;
+        hub_u2_del = le16_to_cpu(udev->parent->bos->ss_cap->bU2DevExitLat);
 
         usb_set_lpm_mel(udev, &udev->u1_params, udev_u1_del,
                         hub, &udev->parent->u1_params, hub_u1_del);
diff --git a/drivers/usb/core/usb.h b/drivers/usb/core/usb.h
index 823857767a16..c49383669cd8 100644
--- a/drivers/usb/core/usb.h
+++ b/drivers/usb/core/usb.h
@@ -35,6 +35,7 @@ extern int usb_get_device_descriptor(struct usb_device *dev,
                 unsigned int size);
 extern int usb_get_bos_descriptor(struct usb_device *dev);
 extern void usb_release_bos_descriptor(struct usb_device *dev);
+extern int usb_device_supports_lpm(struct usb_device *udev);
 extern char *usb_cache_string(struct usb_device *udev, int index);
 extern int usb_set_configuration(struct usb_device *dev, int configuration);
 extern int usb_choose_configuration(struct usb_device *udev);
diff --git a/drivers/usb/host/ehci-fsl.c b/drivers/usb/host/ehci-fsl.c
index 4449f565d6c6..848fc46ad80c 100644
--- a/drivers/usb/host/ehci-fsl.c
+++ b/drivers/usb/host/ehci-fsl.c
@@ -57,7 +57,7 @@ static int usb_hcd_fsl_probe(const struct hc_driver *driver,
         pr_debug("initializing FSL-SOC USB Controller\n");
 
         /* Need platform data for setup */
-        pdata = (struct fsl_usb2_platform_data *)dev_get_platdata(&pdev->dev);
+        pdata = dev_get_platdata(&pdev->dev);
         if (!pdata) {
                 dev_err(&pdev->dev,
                         "No platform data for %s.\n", dev_name(&pdev->dev));
diff --git a/drivers/usb/host/ehci-sched.c b/drivers/usb/host/ehci-sched.c
index 85dd24ed97a6..dcbaad94d607 100644
--- a/drivers/usb/host/ehci-sched.c
+++ b/drivers/usb/host/ehci-sched.c
@@ -1370,10 +1370,12 @@ iso_stream_schedule (
         struct ehci_iso_stream  *stream
 )
 {
-        u32                     now, base, next, start, period, span;
-        int                     status;
+        u32                     now, base, next, start, period, span, now2;
+        u32                     wrap = 0, skip = 0;
+        int                     status = 0;
         unsigned                mod = ehci->periodic_size << 3;
         struct ehci_iso_sched   *sched = urb->hcpriv;
+        bool                    empty = list_empty(&stream->td_list);
 
         period = urb->interval;
         span = sched->span;
@@ -1384,69 +1386,31 @@ iso_stream_schedule (
 
         now = ehci_read_frame_index(ehci) & (mod - 1);
 
-        /* Typical case: reuse current schedule, stream is still active.
-         * Hopefully there are no gaps from the host falling behind
-         * (irq delays etc).  If there are, the behavior depends on
-         * whether URB_ISO_ASAP is set.
-         */
-        if (likely (!list_empty (&stream->td_list))) {
-
-                /* Take the isochronous scheduling threshold into account */
-                if (ehci->i_thresh)
-                        next = now + ehci->i_thresh;    /* uframe cache */
-                else
-                        next = (now + 2 + 7) & ~0x07;   /* full frame cache */
-
-                /*
-                 * Use ehci->last_iso_frame as the base.  There can't be any
-                 * TDs scheduled for earlier than that.
-                 */
-                base = ehci->last_iso_frame << 3;
-                next = (next - base) & (mod - 1);
-                start = (stream->next_uframe - base) & (mod - 1);
-
-                /* Is the schedule already full? */
-                if (unlikely(start < period)) {
-                        ehci_dbg(ehci, "iso sched full %p (%u-%u < %u mod %u)\n",
-                                        urb, stream->next_uframe, base,
-                                        period, mod);
-                        status = -ENOSPC;
-                        goto fail;
-                }
-
-                /* Behind the scheduling threshold? */
-                if (unlikely(start < next)) {
-                        unsigned now2 = (now - base) & (mod - 1);
-
-                        /* USB_ISO_ASAP: Round up to the first available slot */
-                        if (urb->transfer_flags & URB_ISO_ASAP)
-                                start += (next - start + period - 1) & -period;
-
-                        /*
-                         * Not ASAP: Use the next slot in the stream,
-                         * no matter what.
-                         */
-                        else if (start + span - period < now2) {
-                                ehci_dbg(ehci, "iso underrun %p (%u+%u < %u)\n",
-                                                urb, start + base,
-                                                span - period, now2 + base);
-                        }
-                }
+        /* Take the isochronous scheduling threshold into account */
+        if (ehci->i_thresh)
+                next = now + ehci->i_thresh;    /* uframe cache */
+        else
+                next = (now + 2 + 7) & ~0x07;   /* full frame cache */
 
-                start += base;
-        }
+        /*
+         * Use ehci->last_iso_frame as the base.  There can't be any
+         * TDs scheduled for earlier than that.
+         */
+        base = ehci->last_iso_frame << 3;
+        next = (next - base) & (mod - 1);
 
-        /* need to schedule; when's the next (u)frame we could start?
-         * this is bigger than ehci->i_thresh allows; scheduling itself
-         * isn't free, the delay should handle reasonably slow cpus.  it
+        /*
+         * Need to schedule; when's the next (u)frame we could start?
+         * This is bigger than ehci->i_thresh allows; scheduling itself
+         * isn't free, the delay should handle reasonably slow cpus.  It
          * can also help high bandwidth if the dma and irq loads don't
          * jump until after the queue is primed.
          */
-        else {
+        if (unlikely(empty && !hcd_periodic_completion_in_progress(
+                        ehci_to_hcd(ehci), urb->ep))) {
                 int done = 0;
 
-                base = now & ~0x07;
-                start = base + SCHEDULING_DELAY;
+                start = (now & ~0x07) + SCHEDULING_DELAY;
 
                 /* find a uframe slot with enough bandwidth.
                  * Early uframes are more precious because full-speed
@@ -1477,27 +1441,96 @@ iso_stream_schedule (
                         status = -ENOSPC;
                         goto fail;
                 }
+
+                start = (start - base) & (mod - 1);
+                goto use_start;
         }
 
+        /*
+         * Typical case: reuse current schedule, stream is still active.
+         * Hopefully there are no gaps from the host falling behind
+         * (irq delays etc).  If there are, the behavior depends on
+         * whether URB_ISO_ASAP is set.
+         */
+        start = (stream->next_uframe - base) & (mod - 1);
+        now2 = (now - base) & (mod - 1);
+
+        /* Is the schedule already full? */
+        if (unlikely(!empty && start < period)) {
+                ehci_dbg(ehci, "iso sched full %p (%u-%u < %u mod %u)\n",
+                                urb, stream->next_uframe, base, period, mod);
+                status = -ENOSPC;
+                goto fail;
+        }
+
+        /* Is the next packet scheduled after the base time? */
+        if (likely(!empty || start <= now2 + period)) {
+
+                /* URB_ISO_ASAP: make sure that start >= next */
+                if (unlikely(start < next &&
+                                (urb->transfer_flags & URB_ISO_ASAP)))
+                        goto do_ASAP;
+
+                /* Otherwise use start, if it's not in the past */
+                if (likely(start >= now2))
+                        goto use_start;
+
+        /* Otherwise we got an underrun while the queue was empty */
+        } else {
+                if (urb->transfer_flags & URB_ISO_ASAP)
+                        goto do_ASAP;
+                wrap = mod;
+                now2 += mod;
+        }
+
+        /* How many uframes and packets do we need to skip? */
+        skip = (now2 - start + period - 1) & -period;
+        if (skip >= span) {             /* Entirely in the past? */
+                ehci_dbg(ehci, "iso underrun %p (%u+%u < %u) [%u]\n",
+                                urb, start + base, span - period, now2 + base,
+                                base);
+
+                /* Try to keep the last TD intact for scanning later */
+                skip = span - period;
+
+                /* Will it come before the current scan position? */
+                if (empty) {
+                        skip = span;    /* Skip the entire URB */
+                        status = 1;     /* and give it back immediately */
+                        iso_sched_free(stream, sched);
+                        sched = NULL;
+                }
+        }
+        urb->error_count = skip / period;
+        if (sched)
+                sched->first_packet = urb->error_count;
+        goto use_start;
+
+ do_ASAP:
+        /* Use the first slot after "next" */
+        start = next + ((start - next) & (period - 1));
+
+ use_start:
         /* Tried to schedule too far into the future? */
-        if (unlikely(start - base + span - period >= mod)) {
+        if (unlikely(start + span - period >= mod + wrap)) {
                 ehci_dbg(ehci, "request %p would overflow (%u+%u >= %u)\n",
-                                urb, start - base, span - period, mod);
+                                urb, start, span - period, mod + wrap);
                 status = -EFBIG;
                 goto fail;
         }
 
-        stream->next_uframe = start & (mod - 1);
+        start += base;
+        stream->next_uframe = (start + skip) & (mod - 1);
 
         /* report high speed start in uframes; full speed, in frames */
-        urb->start_frame = stream->next_uframe;
+        urb->start_frame = start & (mod - 1);
         if (!stream->highspeed)
                 urb->start_frame >>= 3;
 
         /* Make sure scan_isoc() sees these */
         if (ehci->isoc_count == 0)
                 ehci->last_iso_frame = now >> 3;
-        return 0;
+        return status;
 
  fail:
         iso_sched_free(stream, sched);
@@ -1610,7 +1643,8 @@ static void itd_link_urb(
         ehci_to_hcd(ehci)->self.bandwidth_isoc_reqs++;
 
         /* fill iTDs uframe by uframe */
-        for (packet = 0, itd = NULL; packet < urb->number_of_packets; ) {
+        for (packet = iso_sched->first_packet, itd = NULL;
+                        packet < urb->number_of_packets;) {
                 if (itd == NULL) {
                         /* ASSERT:  we have all necessary itds */
                         // BUG_ON (list_empty (&iso_sched->td_list));
@@ -1804,10 +1838,14 @@ static int itd_submit (struct ehci_hcd *ehci, struct urb *urb,
         if (unlikely(status))
                 goto done_not_linked;
         status = iso_stream_schedule(ehci, urb, stream);
-        if (likely (status == 0))
+        if (likely(status == 0)) {
                 itd_link_urb (ehci, urb, ehci->periodic_size << 3, stream);
-        else
+        } else if (status > 0) {
+                status = 0;
+                ehci_urb_done(ehci, urb, 0);
+        } else {
                 usb_hcd_unlink_urb_from_ep(ehci_to_hcd(ehci), urb);
+        }
  done_not_linked:
         spin_unlock_irqrestore (&ehci->lock, flags);
  done:
@@ -2008,7 +2046,7 @@ static void sitd_link_urb(
         ehci_to_hcd(ehci)->self.bandwidth_isoc_reqs++;
 
         /* fill sITDs frame by frame */
-        for (packet = 0, sitd = NULL;
+        for (packet = sched->first_packet, sitd = NULL;
                         packet < urb->number_of_packets;
                         packet++) {
 
@@ -2178,10 +2216,14 @@ static int sitd_submit (struct ehci_hcd *ehci, struct urb *urb,
         if (unlikely(status))
                 goto done_not_linked;
         status = iso_stream_schedule(ehci, urb, stream);
-        if (status == 0)
+        if (likely(status == 0)) {
                 sitd_link_urb (ehci, urb, ehci->periodic_size << 3, stream);
-        else
+        } else if (status > 0) {
+                status = 0;
+                ehci_urb_done(ehci, urb, 0);
+        } else {
                 usb_hcd_unlink_urb_from_ep(ehci_to_hcd(ehci), urb);
+        }
  done_not_linked:
         spin_unlock_irqrestore (&ehci->lock, flags);
  done:
diff --git a/drivers/usb/host/ehci.h b/drivers/usb/host/ehci.h
index 291db7d09f22..2d401927e143 100644
--- a/drivers/usb/host/ehci.h
+++ b/drivers/usb/host/ehci.h
@@ -434,6 +434,7 @@ struct ehci_iso_packet {
 struct ehci_iso_sched {
         struct list_head        td_list;
         unsigned                span;
+        unsigned                first_packet;
         struct ehci_iso_packet  packet [0];
 };