1 files changed, 62 insertions, 44 deletions

diff --git a/drivers/usb/host/ehci-q.c b/drivers/usb/host/ehci-q.c
index 5d6bc624c96..5c25783a764 100644
--- a/drivers/usb/host/ehci-q.c
+++ b/drivers/usb/host/ehci-q.c
@@ -103,7 +103,7 @@ qh_update (struct ehci_hcd *ehci, struct ehci_qh *qh, struct ehci_qtd *qtd)
         if (!(hw->hw_info1 & cpu_to_hc32(ehci, 1 << 14))) {
                 unsigned        is_out, epnum;
 
-                is_out = !(qtd->hw_token & cpu_to_hc32(ehci, 1 << 8));
+                is_out = qh->is_out;
                 epnum = (hc32_to_cpup(ehci, &hw->hw_info1) >> 8) & 0x0f;
                 if (unlikely (!usb_gettoggle (qh->dev, epnum, is_out))) {
                         hw->hw_token &= ~cpu_to_hc32(ehci, QTD_TOGGLE);
@@ -649,7 +649,7 @@ qh_urb_transaction (
         /*
          * data transfer stage:  buffer setup
          */
-        i = urb->num_sgs;
+        i = urb->num_mapped_sgs;
         if (len > 0 && i > 0) {
                 sg = urb->sg;
                 buf = sg_dma_address(sg);
@@ -946,6 +946,7 @@ done:
         hw = qh->hw;
         hw->hw_info1 = cpu_to_hc32(ehci, info1);
         hw->hw_info2 = cpu_to_hc32(ehci, info2);
+        qh->is_out = !is_input;
         usb_settoggle (urb->dev, usb_pipeendpoint (urb->pipe), !is_input, 1);
         qh_refresh (ehci, qh);
         return qh;
@@ -994,9 +995,16 @@ static void qh_link_async (struct ehci_hcd *ehci, struct ehci_qh *qh)
         head->qh_next.qh = qh;
         head->hw->hw_next = dma;
 
+        /*
+         * flush qh descriptor into memory immediately,
+         * see comments in qh_append_tds.
+         * */
+        ehci_sync_mem();
+
         qh_get(qh);
         qh->xacterrs = 0;
         qh->qh_state = QH_STATE_LINKED;
+        wmb();
         /* qtd completions reported later by interrupt */
 }
 
@@ -1081,6 +1089,18 @@ static struct ehci_qh *qh_append_tds (
                         wmb ();
                         dummy->hw_token = token;
 
+                        /*
+                         * Writing to dma coherent buffer on ARM may
+                         * be delayed to reach memory, so HC may not see
+                         * hw_token of dummy qtd in time, which can cause
+                         * the qtd transaction to be executed very late,
+                         * and degrade performance a lot. ehci_sync_mem
+                         * is added to flush 'token' immediatelly into
+                         * memory, so that ehci can execute the transaction
+                         * ASAP.
+                         * */
+                        ehci_sync_mem();
+
                         urb->hcpriv = qh_get (qh);
                 }
         }
@@ -1231,6 +1251,8 @@ static void start_unlink_async (struct ehci_hcd *ehci, struct ehci_qh *qh)
 
         prev->hw->hw_next = qh->hw->hw_next;
         prev->qh_next = qh->qh_next;
+        if (ehci->qh_scan_next == qh)
+                ehci->qh_scan_next = qh->qh_next.qh;
         wmb ();
 
         /* If the controller isn't running, we don't have to wait for it */
@@ -1256,53 +1278,49 @@ static void scan_async (struct ehci_hcd *ehci)
         struct ehci_qh          *qh;
         enum ehci_timer_action  action = TIMER_IO_WATCHDOG;
 
-        ehci->stamp = ehci_readl(ehci, &ehci->regs->frame_index);
         timer_action_done (ehci, TIMER_ASYNC_SHRINK);
-rescan:
         stopped = !HC_IS_RUNNING(ehci_to_hcd(ehci)->state);
-        qh = ehci->async->qh_next.qh;
-        if (likely (qh != NULL)) {
-                do {
-                        /* clean any finished work for this qh */
-                        if (!list_empty(&qh->qtd_list) && (stopped ||
-                                        qh->stamp != ehci->stamp)) {
-                                int temp;
-
-                                /* unlinks could happen here; completion
-                                 * reporting drops the lock.  rescan using
-                                 * the latest schedule, but don't rescan
-                                 * qhs we already finished (no looping)
-                                 * unless the controller is stopped.
-                                 */
-                                qh = qh_get (qh);
-                                qh->stamp = ehci->stamp;
-                                temp = qh_completions (ehci, qh);
-                                if (qh->needs_rescan)
-                                        unlink_async(ehci, qh);
-                                qh_put (qh);
-                                if (temp != 0) {
-                                        goto rescan;
-                                }
-                        }
 
-                        /* unlink idle entries, reducing DMA usage as well
-                         * as HCD schedule-scanning costs.  delay for any qh
-                         * we just scanned, there's a not-unusual case that it
-                         * doesn't stay idle for long.
-                         * (plus, avoids some kind of re-activation race.)
+        ehci->qh_scan_next = ehci->async->qh_next.qh;
+        while (ehci->qh_scan_next) {
+                qh = ehci->qh_scan_next;
+                ehci->qh_scan_next = qh->qh_next.qh;
+ rescan:
+                /* clean any finished work for this qh */
+                if (!list_empty(&qh->qtd_list)) {
+                        int temp;
+
+                        /*
+                         * Unlinks could happen here; completion reporting
+                         * drops the lock.  That's why ehci->qh_scan_next
+                         * always holds the next qh to scan; if the next qh
+                         * gets unlinked then ehci->qh_scan_next is adjusted
+                         * in start_unlink_async().
                          */
-                        if (list_empty(&qh->qtd_list)
-                                        && qh->qh_state == QH_STATE_LINKED) {
-                                if (!ehci->reclaim && (stopped ||
-                                        ((ehci->stamp - qh->stamp) & 0x1fff)
-                                                >= EHCI_SHRINK_FRAMES * 8))
-                                        start_unlink_async(ehci, qh);
-                                else
-                                        action = TIMER_ASYNC_SHRINK;
-                        }
+                        qh = qh_get(qh);
+                        temp = qh_completions(ehci, qh);
+                        if (qh->needs_rescan)
+                                unlink_async(ehci, qh);
+                        qh->unlink_time = jiffies + EHCI_SHRINK_JIFFIES;
+                        qh_put(qh);
+                        if (temp != 0)
+                                goto rescan;
+                }
 
-                        qh = qh->qh_next.qh;
-                } while (qh);
+                /* unlink idle entries, reducing DMA usage as well
+                 * as HCD schedule-scanning costs.  delay for any qh
+                 * we just scanned, there's a not-unusual case that it
+                 * doesn't stay idle for long.
+                 * (plus, avoids some kind of re-activation race.)
+                 */
+                if (list_empty(&qh->qtd_list)
+                                && qh->qh_state == QH_STATE_LINKED) {
+                        if (!ehci->reclaim && (stopped ||
+                                        time_after_eq(jiffies, qh->unlink_time)))
+                                start_unlink_async(ehci, qh);
+                        else
+                                action = TIMER_ASYNC_SHRINK;
+                }
         }
         if (action == TIMER_ASYNC_SHRINK)
                 timer_action (ehci, TIMER_ASYNC_SHRINK);