22 files changed, 333 insertions, 124 deletions

diff --git a/drivers/usb/host/Kconfig b/drivers/usb/host/Kconfig
index 2c63bfb1f8d9..845479f7c707 100644
--- a/drivers/usb/host/Kconfig
+++ b/drivers/usb/host/Kconfig
@@ -24,10 +24,7 @@ config USB_EHCI_HCD
           The Enhanced Host Controller Interface (EHCI) is standard for USB 2.0
           "high speed" (480 Mbit/sec, 60 Mbyte/sec) host controller hardware.
           If your USB host controller supports USB 2.0, you will likely want to
-          configure this Host Controller Driver.  At the time of this writing, 
-          the primary implementation of EHCI is a chip from NEC, widely available
-          in add-on PCI cards, but implementations are in the works from other 
-          vendors including Intel and Philips.  Motherboard support is appearing.
+          configure this Host Controller Driver.
 
           EHCI controllers are packaged with "companion" host controllers (OHCI
           or UHCI) to handle USB 1.1 devices connected to root hub ports.  Ports
@@ -123,7 +120,7 @@ config USB_ISP116X_HCD
 
 config USB_ISP1760_HCD
         tristate "ISP 1760 HCD support"
-        depends on USB && EXPERIMENTAL && (PCI || PPC_OF)
+        depends on USB && EXPERIMENTAL
         ---help---
           The ISP1760 chip is a USB 2.0 host controller.
 
diff --git a/drivers/usb/host/ehci-hcd.c b/drivers/usb/host/ehci-hcd.c
index e551bb38852b..f2618d17710d 100644
--- a/drivers/usb/host/ehci-hcd.c
+++ b/drivers/usb/host/ehci-hcd.c
@@ -110,6 +110,42 @@ MODULE_PARM_DESC (ignore_oc, "ignore bogus hardware overcurrent indications");
 
 /*-------------------------------------------------------------------------*/
 
+static void
+timer_action(struct ehci_hcd *ehci, enum ehci_timer_action action)
+{
+        /* Don't override timeouts which shrink or (later) disable
+         * the async ring; just the I/O watchdog.  Note that if a
+         * SHRINK were pending, OFF would never be requested.
+         */
+        if (timer_pending(&ehci->watchdog)
+                        && ((BIT(TIMER_ASYNC_SHRINK) | BIT(TIMER_ASYNC_OFF))
+                                & ehci->actions))
+                return;
+
+        if (!test_and_set_bit(action, &ehci->actions)) {
+                unsigned long t;
+
+                switch (action) {
+                case TIMER_IO_WATCHDOG:
+                        t = EHCI_IO_JIFFIES;
+                        break;
+                case TIMER_ASYNC_OFF:
+                        t = EHCI_ASYNC_JIFFIES;
+                        break;
+                /* case TIMER_ASYNC_SHRINK: */
+                default:
+                        /* add a jiffie since we synch against the
+                         * 8 KHz uframe counter.
+                         */
+                        t = DIV_ROUND_UP(EHCI_SHRINK_FRAMES * HZ, 1000) + 1;
+                        break;
+                }
+                mod_timer(&ehci->watchdog, t + jiffies);
+        }
+}
+
+/*-------------------------------------------------------------------------*/
+
 /*
  * handshake - spin reading hc until handshake completes or fails
  * @ptr: address of hc register to be read
diff --git a/drivers/usb/host/ehci-q.c b/drivers/usb/host/ehci-q.c
index ecc9b66c03cd..1976b1b3778c 100644
--- a/drivers/usb/host/ehci-q.c
+++ b/drivers/usb/host/ehci-q.c
@@ -333,12 +333,40 @@ qh_completions (struct ehci_hcd *ehci, struct ehci_qh *qh)
                 token = hc32_to_cpu(ehci, qtd->hw_token);
 
                 /* always clean up qtds the hc de-activated */
+ retry_xacterr:
                 if ((token & QTD_STS_ACTIVE) == 0) {
 
                         /* on STALL, error, and short reads this urb must
                          * complete and all its qtds must be recycled.
                          */
                         if ((token & QTD_STS_HALT) != 0) {
+
+                                /* retry transaction errors until we
+                                 * reach the software xacterr limit
+                                 */
+                                if ((token & QTD_STS_XACT) &&
+                                                QTD_CERR(token) == 0 &&
+                                                --qh->xacterrs > 0 &&
+                                                !urb->unlinked) {
+                                        ehci_dbg(ehci,
+        "detected XactErr len %zu/%zu retry %d\n",
+        qtd->length - QTD_LENGTH(token), qtd->length,
+        QH_XACTERR_MAX - qh->xacterrs);
+
+                                        /* reset the token in the qtd and the
+                                         * qh overlay (which still contains
+                                         * the qtd) so that we pick up from
+                                         * where we left off
+                                         */
+                                        token &= ~QTD_STS_HALT;
+                                        token |= QTD_STS_ACTIVE |
+                                                        (EHCI_TUNE_CERR << 10);
+                                        qtd->hw_token = cpu_to_hc32(ehci,
+                                                        token);
+                                        wmb();
+                                        qh->hw_token = cpu_to_hc32(ehci, token);
+                                        goto retry_xacterr;
+                                }
                                 stopped = 1;
 
                         /* magic dummy for some short reads; qh won't advance.
@@ -421,6 +449,9 @@ halt:
                 /* remove qtd; it's recycled after possible urb completion */
                 list_del (&qtd->qtd_list);
                 last = qtd;
+
+                /* reinit the xacterr counter for the next qtd */
+                qh->xacterrs = QH_XACTERR_MAX;
         }
 
         /* last urb's completion might still need calling */
@@ -862,6 +893,7 @@ static void qh_link_async (struct ehci_hcd *ehci, struct ehci_qh *qh)
         head->qh_next.qh = qh;
         head->hw_next = dma;
 
+        qh->xacterrs = QH_XACTERR_MAX;
         qh->qh_state = QH_STATE_LINKED;
         /* qtd completions reported later by interrupt */
 }
diff --git a/drivers/usb/host/ehci-sched.c b/drivers/usb/host/ehci-sched.c
index 1d0b49e3f192..ada5d2ba297b 100644
--- a/drivers/usb/host/ehci-sched.c
+++ b/drivers/usb/host/ehci-sched.c
@@ -563,7 +563,7 @@ static int qh_unlink_periodic(struct ehci_hcd *ehci, struct ehci_qh *qh)
         //   and this qh is active in the current uframe
         //   (and overlay token SplitXstate is false?)
         // THEN
-        //   qh->hw_info1 |= __constant_cpu_to_hc32(1 << 7 /* "ignore" */);
+        //   qh->hw_info1 |= cpu_to_hc32(1 << 7 /* "ignore" */);
 
         /* high bandwidth, or otherwise part of every microframe */
         if ((period = qh->period) == 0)
diff --git a/drivers/usb/host/ehci.h b/drivers/usb/host/ehci.h
index 262b00c9b334..6cff195e1a36 100644
--- a/drivers/usb/host/ehci.h
+++ b/drivers/usb/host/ehci.h
@@ -190,40 +190,6 @@ timer_action_done (struct ehci_hcd *ehci, enum ehci_timer_action action)
         clear_bit (action, &ehci->actions);
 }
 
-static inline void
-timer_action (struct ehci_hcd *ehci, enum ehci_timer_action action)
-{
-        /* Don't override timeouts which shrink or (later) disable
-         * the async ring; just the I/O watchdog.  Note that if a
-         * SHRINK were pending, OFF would never be requested.
-         */
-        if (timer_pending(&ehci->watchdog)
-                        && ((BIT(TIMER_ASYNC_SHRINK) | BIT(TIMER_ASYNC_OFF))
-                                & ehci->actions))
-                return;
-
-        if (!test_and_set_bit (action, &ehci->actions)) {
-                unsigned long t;
-
-                switch (action) {
-                case TIMER_IO_WATCHDOG:
-                        t = EHCI_IO_JIFFIES;
-                        break;
-                case TIMER_ASYNC_OFF:
-                        t = EHCI_ASYNC_JIFFIES;
-                        break;
-                // case TIMER_ASYNC_SHRINK:
-                default:
-                        /* add a jiffie since we synch against the
-                         * 8 KHz uframe counter.
-                         */
-                        t = DIV_ROUND_UP(EHCI_SHRINK_FRAMES * HZ, 1000) + 1;
-                        break;
-                }
-                mod_timer(&ehci->watchdog, t + jiffies);
-        }
-}
-
 static void free_cached_itd_list(struct ehci_hcd *ehci);
 
 /*-------------------------------------------------------------------------*/
@@ -287,7 +253,7 @@ struct ehci_qtd {
 
 /*
  * Now the following defines are not converted using the
- * __constant_cpu_to_le32() macro anymore, since we have to support
+ * cpu_to_le32() macro anymore, since we have to support
  * "dynamic" switching between be and le support, so that the driver
  * can be used on one system with SoC EHCI controller using big-endian
  * descriptors as well as a normal little-endian PCI EHCI controller.
@@ -376,6 +342,9 @@ struct ehci_qh {
 #define QH_STATE_UNLINK_WAIT    4               /* LINKED and on reclaim q */
 #define QH_STATE_COMPLETING     5               /* don't touch token.HALT */
 
+        u8                      xacterrs;       /* XactErr retry counter */
+#define QH_XACTERR_MAX          32              /* XactErr retry limit */
+
         /* periodic schedule info */
         u8                      usecs;          /* intr bandwidth */
         u8                      gap_uf;         /* uframes split/csplit gap */
diff --git a/drivers/usb/host/hwa-hc.c b/drivers/usb/host/hwa-hc.c
index 8582236e4cad..cbf30e515f29 100644
--- a/drivers/usb/host/hwa-hc.c
+++ b/drivers/usb/host/hwa-hc.c
@@ -464,8 +464,7 @@ static int __hwahc_dev_set_key(struct wusbhc *wusbhc, u8 port_idx, u32 tkid,
                         port_idx << 8 | iface_no,
                         keyd, keyd_len, 1000 /* FIXME: arbitrary */);
 
-        memset(keyd, 0, sizeof(*keyd)); /* clear keys etc. */
-        kfree(keyd);
+        kzfree(keyd); /* clear keys etc. */
         return result;
 }
 
diff --git a/drivers/usb/host/isp116x-hcd.c b/drivers/usb/host/isp116x-hcd.c
index 4dda31b26892..a2b305477afe 100644
--- a/drivers/usb/host/isp116x-hcd.c
+++ b/drivers/usb/host/isp116x-hcd.c
@@ -772,7 +772,7 @@ static int isp116x_urb_enqueue(struct usb_hcd *hcd,
                 break;
         case PIPE_INTERRUPT:
                 urb->interval = ep->period;
-                ep->length = min((int)ep->maxpacket,
+                ep->length = min_t(u32, ep->maxpacket,
                                  urb->transfer_buffer_length);
 
                 /* urb submitted for already existing endpoint */
diff --git a/drivers/usb/host/isp116x.h b/drivers/usb/host/isp116x.h
index aa211bafcff9..12db961acdfb 100644
--- a/drivers/usb/host/isp116x.h
+++ b/drivers/usb/host/isp116x.h
@@ -563,7 +563,7 @@ static void urb_dbg(struct urb *urb, char *msg)
 */
 static inline void dump_ptd(struct ptd *ptd)
 {
-        printk("td: %x %d%c%d %d,%d,%d  %x %x%x%x\n",
+        printk(KERN_WARNING "td: %x %d%c%d %d,%d,%d  %x %x%x%x\n",
                PTD_GET_CC(ptd), PTD_GET_FA(ptd),
                PTD_DIR_STR(ptd), PTD_GET_EP(ptd),
                PTD_GET_COUNT(ptd), PTD_GET_LEN(ptd), PTD_GET_MPS(ptd),
@@ -576,7 +576,7 @@ static inline void dump_ptd_out_data(struct ptd *ptd, u8 * buf)
         int k;
 
         if (PTD_GET_DIR(ptd) != PTD_DIR_IN && PTD_GET_LEN(ptd)) {
-                printk("-> ");
+                printk(KERN_WARNING "-> ");
                 for (k = 0; k < PTD_GET_LEN(ptd); ++k)
                         printk("%02x ", ((u8 *) buf)[k]);
                 printk("\n");
@@ -588,13 +588,13 @@ static inline void dump_ptd_in_data(struct ptd *ptd, u8 * buf)
         int k;
 
         if (PTD_GET_DIR(ptd) == PTD_DIR_IN && PTD_GET_COUNT(ptd)) {
-                printk("<- ");
+                printk(KERN_WARNING "<- ");
                 for (k = 0; k < PTD_GET_COUNT(ptd); ++k)
                         printk("%02x ", ((u8 *) buf)[k]);
                 printk("\n");
         }
         if (PTD_GET_LAST(ptd))
-                printk("-\n");
+                printk(KERN_WARNING "-\n");
 }
 
 #else
diff --git a/drivers/usb/host/isp1760-hcd.c b/drivers/usb/host/isp1760-hcd.c
index b899f1a59c26..cd07ea3f0c63 100644
--- a/drivers/usb/host/isp1760-hcd.c
+++ b/drivers/usb/host/isp1760-hcd.c
@@ -644,7 +644,7 @@ static void transform_add_int(struct isp1760_hcd *priv, struct isp1760_qh *qh,
 
         if (urb->dev->speed != USB_SPEED_HIGH) {
                 /* split */
-                ptd->dw5 = __constant_cpu_to_le32(0x1c);
+                ptd->dw5 = cpu_to_le32(0x1c);
 
                 if (qh->period >= 32)
                         period = qh->period / 2;
@@ -819,6 +819,13 @@ static void enqueue_an_ATL_packet(struct usb_hcd *hcd, struct isp1760_qh *qh,
         u32 atl_regs, payload;
         u32 buffstatus;
 
+        /*
+         * When this function is called from the interrupt handler to enqueue
+         * a follow-up packet, the SKIP register gets written and read back
+         * almost immediately. With ISP1761, this register requires a delay of
+         * 195ns between a write and subsequent read (see section 15.1.1.3).
+         */
+        ndelay(195);
         skip_map = isp1760_readl(hcd->regs + HC_ATL_PTD_SKIPMAP_REG);
 
         BUG_ON(!skip_map);
@@ -853,6 +860,13 @@ static void enqueue_an_INT_packet(struct usb_hcd *hcd, struct isp1760_qh *qh,
         u32 int_regs, payload;
         u32 buffstatus;
 
+        /*
+         * When this function is called from the interrupt handler to enqueue
+         * a follow-up packet, the SKIP register gets written and read back
+         * almost immediately. With ISP1761, this register requires a delay of
+         * 195ns between a write and subsequent read (see section 15.1.1.3).
+         */
+        ndelay(195);
         skip_map = isp1760_readl(hcd->regs + HC_INT_PTD_SKIPMAP_REG);
 
         BUG_ON(!skip_map);
@@ -1054,7 +1068,7 @@ static void do_atl_int(struct usb_hcd *usb_hcd)
                         priv_write_copy(priv, (u32 *)&ptd, usb_hcd->regs +
                                         atl_regs, sizeof(ptd));
 
-                        ptd.dw0 |= __constant_cpu_to_le32(PTD_VALID);
+                        ptd.dw0 |= cpu_to_le32(PTD_VALID);
                         priv_write_copy(priv, (u32 *)&ptd, usb_hcd->regs +
                                         atl_regs, sizeof(ptd));
 
@@ -2235,9 +2249,10 @@ void deinit_kmem_cache(void)
         kmem_cache_destroy(qh_cachep);
 }
 
-struct usb_hcd *isp1760_register(u64 res_start, u64 res_len, int irq,
-                u64 irqflags, struct device *dev, const char *busname,
-                unsigned int devflags)
+struct usb_hcd *isp1760_register(phys_addr_t res_start, resource_size_t res_len,
+                                 int irq, unsigned long irqflags,
+                                 struct device *dev, const char *busname,
+                                 unsigned int devflags)
 {
         struct usb_hcd *hcd;
         struct isp1760_hcd *priv;
diff --git a/drivers/usb/host/isp1760-hcd.h b/drivers/usb/host/isp1760-hcd.h
index a9daea587962..462f4943cb1b 100644
--- a/drivers/usb/host/isp1760-hcd.h
+++ b/drivers/usb/host/isp1760-hcd.h
@@ -2,9 +2,10 @@
 #define _ISP1760_HCD_H_
 
 /* exports for if */
-struct usb_hcd *isp1760_register(u64 res_start, u64 res_len, int irq,
-                u64 irqflags, struct device *dev, const char *busname,
-                unsigned int devflags);
+struct usb_hcd *isp1760_register(phys_addr_t res_start, resource_size_t res_len,
+                                 int irq, unsigned long irqflags,
+                                 struct device *dev, const char *busname,
+                                 unsigned int devflags);
 int init_kmem_once(void);
 void deinit_kmem_cache(void);
 
diff --git a/drivers/usb/host/isp1760-if.c b/drivers/usb/host/isp1760-if.c
index 4cf7ca428b33..3fa3a1702796 100644
--- a/drivers/usb/host/isp1760-if.c
+++ b/drivers/usb/host/isp1760-if.c
@@ -10,6 +10,7 @@
 
 #include <linux/usb.h>
 #include <linux/io.h>
+#include <linux/platform_device.h>
 
 #include "../core/hcd.h"
 #include "isp1760-hcd.h"
@@ -300,39 +301,101 @@ static struct pci_driver isp1761_pci_driver = {
 };
 #endif
 
+static int __devinit isp1760_plat_probe(struct platform_device *pdev)
+{
+        int ret = 0;
+        struct usb_hcd *hcd;
+        struct resource *mem_res;
+        struct resource *irq_res;
+        resource_size_t mem_size;
+        unsigned long irqflags = IRQF_SHARED | IRQF_DISABLED;
+
+        mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!mem_res) {
+                pr_warning("isp1760: Memory resource not available\n");
+                ret = -ENODEV;
+                goto out;
+        }
+        mem_size = resource_size(mem_res);
+        if (!request_mem_region(mem_res->start, mem_size, "isp1760")) {
+                pr_warning("isp1760: Cannot reserve the memory resource\n");
+                ret = -EBUSY;
+                goto out;
+        }
+
+        irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+        if (!irq_res) {
+                pr_warning("isp1760: IRQ resource not available\n");
+                return -ENODEV;
+        }
+        irqflags |= irq_res->flags & IRQF_TRIGGER_MASK;
+
+        hcd = isp1760_register(mem_res->start, mem_size, irq_res->start,
+                               irqflags, &pdev->dev, dev_name(&pdev->dev), 0);
+        if (IS_ERR(hcd)) {
+                pr_warning("isp1760: Failed to register the HCD device\n");
+                ret = -ENODEV;
+                goto cleanup;
+        }
+
+        pr_info("ISP1760 USB device initialised\n");
+        return ret;
+
+cleanup:
+        release_mem_region(mem_res->start, mem_size);
+out:
+        return ret;
+}
+
+static int __devexit isp1760_plat_remove(struct platform_device *pdev)
+{
+        struct resource *mem_res;
+        resource_size_t mem_size;
+
+        mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        mem_size = resource_size(mem_res);
+        release_mem_region(mem_res->start, mem_size);
+
+        return 0;
+}
+
+static struct platform_driver isp1760_plat_driver = {
+        .probe  = isp1760_plat_probe,
+        .remove = isp1760_plat_remove,
+        .driver = {
+                .name   = "isp1760",
+        },
+};
+
 static int __init isp1760_init(void)
 {
-        int ret;
+        int ret, any_ret = -ENODEV;
 
         init_kmem_once();
 
+        ret = platform_driver_register(&isp1760_plat_driver);
+        if (!ret)
+                any_ret = 0;
 #ifdef CONFIG_PPC_OF
         ret = of_register_platform_driver(&isp1760_of_driver);
-        if (ret) {
-                deinit_kmem_cache();
-                return ret;
-        }
+        if (!ret)
+                any_ret = 0;
 #endif
 #ifdef CONFIG_PCI
         ret = pci_register_driver(&isp1761_pci_driver);
-        if (ret)
-                goto unreg_of;
+        if (!ret)
+                any_ret = 0;
 #endif
-        return ret;
 
-#ifdef CONFIG_PCI
-unreg_of:
-#endif
-#ifdef CONFIG_PPC_OF
-        of_unregister_platform_driver(&isp1760_of_driver);
-#endif
-        deinit_kmem_cache();
-        return ret;
+        if (any_ret)
+                deinit_kmem_cache();
+        return any_ret;
 }
 module_init(isp1760_init);
 
 static void __exit isp1760_exit(void)
 {
+        platform_driver_unregister(&isp1760_plat_driver);
 #ifdef CONFIG_PPC_OF
         of_unregister_platform_driver(&isp1760_of_driver);
 #endif
diff --git a/drivers/usb/host/ohci-hcd.c b/drivers/usb/host/ohci-hcd.c
index 7658589edb1c..25db704f3a2a 100644
--- a/drivers/usb/host/ohci-hcd.c
+++ b/drivers/usb/host/ohci-hcd.c
@@ -997,7 +997,7 @@ MODULE_LICENSE ("GPL");
 #define SA1111_DRIVER           ohci_hcd_sa1111_driver
 #endif
 
-#ifdef CONFIG_ARCH_S3C2410
+#if defined(CONFIG_ARCH_S3C2410) || defined(CONFIG_ARCH_S3C64XX)
 #include "ohci-s3c2410.c"
 #define PLATFORM_DRIVER         ohci_hcd_s3c2410_driver
 #endif
diff --git a/drivers/usb/host/ohci-s3c2410.c b/drivers/usb/host/ohci-s3c2410.c
index f46af7a718d4..a68af2dd55ca 100644
--- a/drivers/usb/host/ohci-s3c2410.c
+++ b/drivers/usb/host/ohci-s3c2410.c
@@ -21,9 +21,7 @@
 
 #include <linux/platform_device.h>
 #include <linux/clk.h>
-
-#include <mach/hardware.h>
-#include <mach/usb-control.h>
+#include <plat/usb-control.h>
 
 #define valid_port(idx) ((idx) == 1 || (idx) == 2)
 
@@ -372,7 +370,7 @@ static int usb_hcd_s3c2410_probe (const struct hc_driver *driver,
 
         usb_clk = clk_get(&dev->dev, "usb-bus-host");
         if (IS_ERR(usb_clk)) {
-                dev_err(&dev->dev, "cannot get usb-host clock\n");
+                dev_err(&dev->dev, "cannot get usb-bus-host clock\n");
                 retval = -ENOENT;
                 goto err_clk;
         }
diff --git a/drivers/usb/host/oxu210hp-hcd.c b/drivers/usb/host/oxu210hp-hcd.c
index 75548f7c716b..5ac489ee3dab 100644
--- a/drivers/usb/host/oxu210hp-hcd.c
+++ b/drivers/usb/host/oxu210hp-hcd.c
@@ -845,14 +845,14 @@ static inline void qh_update(struct oxu_hcd *oxu,
                 is_out = !(qtd->hw_token & cpu_to_le32(1 << 8));
                 epnum = (le32_to_cpup(&qh->hw_info1) >> 8) & 0x0f;
                 if (unlikely(!usb_gettoggle(qh->dev, epnum, is_out))) {
-                        qh->hw_token &= ~__constant_cpu_to_le32(QTD_TOGGLE);
+                        qh->hw_token &= ~cpu_to_le32(QTD_TOGGLE);
                         usb_settoggle(qh->dev, epnum, is_out, 1);
                 }
         }
 
         /* HC must see latest qtd and qh data before we clear ACTIVE+HALT */
         wmb();
-        qh->hw_token &= __constant_cpu_to_le32(QTD_TOGGLE | QTD_STS_PING);
+        qh->hw_token &= cpu_to_le32(QTD_TOGGLE | QTD_STS_PING);
 }
 
 /* If it weren't for a common silicon quirk (writing the dummy into the qh
@@ -937,7 +937,7 @@ __acquires(oxu->lock)
                 struct ehci_qh  *qh = (struct ehci_qh *) urb->hcpriv;
 
                 /* S-mask in a QH means it's an interrupt urb */
-                if ((qh->hw_info2 & __constant_cpu_to_le32(QH_SMASK)) != 0) {
+                if ((qh->hw_info2 & cpu_to_le32(QH_SMASK)) != 0) {
 
                         /* ... update hc-wide periodic stats (for usbfs) */
                         oxu_to_hcd(oxu)->self.bandwidth_int_reqs--;
@@ -981,7 +981,7 @@ static void unlink_async(struct oxu_hcd *oxu, struct ehci_qh *qh);
 static void intr_deschedule(struct oxu_hcd *oxu, struct ehci_qh *qh);
 static int qh_schedule(struct oxu_hcd *oxu, struct ehci_qh *qh);
 
-#define HALT_BIT __constant_cpu_to_le32(QTD_STS_HALT)
+#define HALT_BIT cpu_to_le32(QTD_STS_HALT)
 
 /* Process and free completed qtds for a qh, returning URBs to drivers.
  * Chases up to qh->hw_current.  Returns number of completions called,
@@ -1160,7 +1160,7 @@ halt:
                         /* should be rare for periodic transfers,
                          * except maybe high bandwidth ...
                          */
-                        if ((__constant_cpu_to_le32(QH_SMASK)
+                        if ((cpu_to_le32(QH_SMASK)
                                         & qh->hw_info2) != 0) {
                                 intr_deschedule(oxu, qh);
                                 (void) qh_schedule(oxu, qh);
@@ -1350,7 +1350,7 @@ static struct list_head *qh_urb_transaction(struct oxu_hcd *oxu,
         }
 
         /* by default, enable interrupt on urb completion */
-                qtd->hw_token |= __constant_cpu_to_le32(QTD_IOC);
+                qtd->hw_token |= cpu_to_le32(QTD_IOC);
         return head;
 
 cleanup:
@@ -1539,7 +1539,7 @@ static void qh_link_async(struct oxu_hcd *oxu, struct ehci_qh *qh)
         /* qtd completions reported later by interrupt */
 }
 
-#define QH_ADDR_MASK    __constant_cpu_to_le32(0x7f)
+#define QH_ADDR_MASK    cpu_to_le32(0x7f)
 
 /*
  * For control/bulk/interrupt, return QH with these TDs appended.
@@ -2012,7 +2012,7 @@ static void qh_unlink_periodic(struct oxu_hcd *oxu, struct ehci_qh *qh)
          *   and this qh is active in the current uframe
          *   (and overlay token SplitXstate is false?)
          * THEN
-         *   qh->hw_info1 |= __constant_cpu_to_le32(1 << 7 "ignore");
+         *   qh->hw_info1 |= cpu_to_le32(1 << 7 "ignore");
          */
 
         /* high bandwidth, or otherwise part of every microframe */
@@ -2057,7 +2057,7 @@ static void intr_deschedule(struct oxu_hcd *oxu, struct ehci_qh *qh)
          * active high speed queues may need bigger delays...
          */
         if (list_empty(&qh->qtd_list)
-                || (__constant_cpu_to_le32(QH_CMASK) & qh->hw_info2) != 0)
+                || (cpu_to_le32(QH_CMASK) & qh->hw_info2) != 0)
                 wait = 2;
         else
                 wait = 55;      /* worst case: 3 * 1024 */
@@ -2183,10 +2183,10 @@ static int qh_schedule(struct oxu_hcd *oxu, struct ehci_qh *qh)
                 qh->start = frame;
 
                 /* reset S-frame and (maybe) C-frame masks */
-                qh->hw_info2 &= __constant_cpu_to_le32(~(QH_CMASK | QH_SMASK));
+                qh->hw_info2 &= cpu_to_le32(~(QH_CMASK | QH_SMASK));
                 qh->hw_info2 |= qh->period
                         ? cpu_to_le32(1 << uframe)
-                        : __constant_cpu_to_le32(QH_SMASK);
+                        : cpu_to_le32(QH_SMASK);
                 qh->hw_info2 |= c_mask;
         } else
                 oxu_dbg(oxu, "reused qh %p schedule\n", qh);
@@ -2684,7 +2684,7 @@ static int oxu_reset(struct usb_hcd *hcd)
         oxu->urb_len = 0;
 
         /* FIMXE */
-        hcd->self.controller->dma_mask = 0UL;
+        hcd->self.controller->dma_mask = NULL;
 
         if (oxu->is_otg) {
                 oxu->caps = hcd->regs + OXU_OTG_CAP_OFFSET;
diff --git a/drivers/usb/host/oxu210hp.h b/drivers/usb/host/oxu210hp.h
index 8910e271cc7d..1c216ad9aad2 100644
--- a/drivers/usb/host/oxu210hp.h
+++ b/drivers/usb/host/oxu210hp.h
@@ -235,21 +235,21 @@ struct ehci_qtd {
 } __attribute__ ((aligned(32)));
 
 /* mask NakCnt+T in qh->hw_alt_next */
-#define QTD_MASK __constant_cpu_to_le32 (~0x1f)
+#define QTD_MASK cpu_to_le32 (~0x1f)
 
 #define IS_SHORT_READ(token) (QTD_LENGTH(token) != 0 && QTD_PID(token) == 1)
 
 /* Type tag from {qh, itd, sitd, fstn}->hw_next */
-#define Q_NEXT_TYPE(dma) ((dma) & __constant_cpu_to_le32 (3 << 1))
+#define Q_NEXT_TYPE(dma) ((dma) & cpu_to_le32 (3 << 1))
 
 /* values for that type tag */
-#define Q_TYPE_QH       __constant_cpu_to_le32 (1 << 1)
+#define Q_TYPE_QH       cpu_to_le32 (1 << 1)
 
 /* next async queue entry, or pointer to interrupt/periodic QH */
 #define QH_NEXT(dma)    (cpu_to_le32(((u32)dma)&~0x01f)|Q_TYPE_QH)
 
 /* for periodic/async schedules and qtd lists, mark end of list */
-#define EHCI_LIST_END   __constant_cpu_to_le32(1) /* "null pointer" to hw */
+#define EHCI_LIST_END   cpu_to_le32(1) /* "null pointer" to hw */
 
 /*
  * Entries in periodic shadow table are pointers to one of four kinds
diff --git a/drivers/usb/host/pci-quirks.c b/drivers/usb/host/pci-quirks.c
index 75b69847918e..033c2846ce59 100644
--- a/drivers/usb/host/pci-quirks.c
+++ b/drivers/usb/host/pci-quirks.c
@@ -234,7 +234,7 @@ static void __devinit quirk_usb_disable_ehci(struct pci_dev *pdev)
          */
         hcc_params = readl(base + EHCI_HCC_PARAMS);
         offset = (hcc_params >> 8) & 0xff;
-        while (offset && count--) {
+        while (offset && --count) {
                 u32             cap;
                 int             msec;
 
diff --git a/drivers/usb/host/r8a66597-hcd.c b/drivers/usb/host/r8a66597-hcd.c
index 319041205b57..f1626e58c141 100644
--- a/drivers/usb/host/r8a66597-hcd.c
+++ b/drivers/usb/host/r8a66597-hcd.c
@@ -660,9 +660,9 @@ static u16 get_empty_pipenum(struct r8a66597 *r8a66597,
         u16 array[R8A66597_MAX_NUM_PIPE], i = 0, min;
 
         memset(array, 0, sizeof(array));
-        switch (ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
+        switch (usb_endpoint_type(ep)) {
         case USB_ENDPOINT_XFER_BULK:
-                if (ep->bEndpointAddress & USB_ENDPOINT_DIR_MASK)
+                if (usb_endpoint_dir_in(ep))
                         array[i++] = 4;
                 else {
                         array[i++] = 3;
@@ -670,7 +670,7 @@ static u16 get_empty_pipenum(struct r8a66597 *r8a66597,
                 }
                 break;
         case USB_ENDPOINT_XFER_INT:
-                if (ep->bEndpointAddress & USB_ENDPOINT_DIR_MASK) {
+                if (usb_endpoint_dir_in(ep)) {
                         array[i++] = 6;
                         array[i++] = 7;
                         array[i++] = 8;
@@ -678,7 +678,7 @@ static u16 get_empty_pipenum(struct r8a66597 *r8a66597,
                         array[i++] = 9;
                 break;
         case USB_ENDPOINT_XFER_ISOC:
-                if (ep->bEndpointAddress & USB_ENDPOINT_DIR_MASK)
+                if (usb_endpoint_dir_in(ep))
                         array[i++] = 2;
                 else
                         array[i++] = 1;
@@ -928,10 +928,9 @@ static void init_pipe_info(struct r8a66597 *r8a66597, struct urb *urb,
 
         info.pipenum = get_empty_pipenum(r8a66597, ep);
         info.address = get_urb_to_r8a66597_addr(r8a66597, urb);
-        info.epnum = ep->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
+        info.epnum = usb_endpoint_num(ep);
         info.maxpacket = le16_to_cpu(ep->wMaxPacketSize);
-        info.type = get_r8a66597_type(ep->bmAttributes
-                                      & USB_ENDPOINT_XFERTYPE_MASK);
+        info.type = get_r8a66597_type(usb_endpoint_type(ep));
         info.bufnum = get_bufnum(info.pipenum);
         info.buf_bsize = get_buf_bsize(info.pipenum);
         if (info.type == R8A66597_BULK) {
@@ -941,7 +940,7 @@ static void init_pipe_info(struct r8a66597 *r8a66597, struct urb *urb,
                 info.interval = get_interval(urb, ep->bInterval);
                 info.timer_interval = get_timer_interval(urb, ep->bInterval);
         }
-        if (ep->bEndpointAddress & USB_ENDPOINT_DIR_MASK)
+        if (usb_endpoint_dir_in(ep))
                 info.dir_in = 1;
         else
                 info.dir_in = 0;
@@ -1014,6 +1013,9 @@ static void r8a66597_check_syssts(struct r8a66597 *r8a66597, int port,
 
         r8a66597_write(r8a66597, ~DTCH, get_intsts_reg(port));
         r8a66597_bset(r8a66597, DTCHE, get_intenb_reg(port));
+
+        if (r8a66597->bus_suspended)
+                usb_hcd_resume_root_hub(r8a66597_to_hcd(r8a66597));
 }
 
 /* this function must be called with interrupt disabled */
@@ -1395,7 +1397,7 @@ static void packet_write(struct r8a66597 *r8a66597, u16 pipenum)
                            (int)urb->iso_frame_desc[td->iso_cnt].length);
         } else {
                 buf = (u16 *)(urb->transfer_buffer + urb->actual_length);
-                size = min((int)bufsize,
+                size = min_t(u32, bufsize,
                            urb->transfer_buffer_length - urb->actual_length);
         }
 
@@ -1615,6 +1617,11 @@ static irqreturn_t r8a66597_irq(struct usb_hcd *hcd)
                         r8a66597_bclr(r8a66597, DTCHE, INTENB2);
                         r8a66597_usb_disconnect(r8a66597, 1);
                 }
+                if (mask2 & BCHG) {
+                        r8a66597_write(r8a66597, ~BCHG, INTSTS2);
+                        r8a66597_bclr(r8a66597, BCHGE, INTENB2);
+                        usb_hcd_resume_root_hub(r8a66597_to_hcd(r8a66597));
+                }
         }
 
         if (mask1) {
@@ -1630,6 +1637,12 @@ static irqreturn_t r8a66597_irq(struct usb_hcd *hcd)
                         r8a66597_bclr(r8a66597, DTCHE, INTENB1);
                         r8a66597_usb_disconnect(r8a66597, 0);
                 }
+                if (mask1 & BCHG) {
+                        r8a66597_write(r8a66597, ~BCHG, INTSTS1);
+                        r8a66597_bclr(r8a66597, BCHGE, INTENB1);
+                        usb_hcd_resume_root_hub(r8a66597_to_hcd(r8a66597));
+                }
+
                 if (mask1 & SIGN) {
                         r8a66597_write(r8a66597, ~SIGN, INTSTS1);
                         status = get_urb_error(r8a66597, 0);
@@ -2141,7 +2154,7 @@ static int r8a66597_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
 
                 switch (wValue) {
                 case USB_PORT_FEAT_ENABLE:
-                        rh->port &= (1 << USB_PORT_FEAT_POWER);
+                        rh->port &= ~(1 << USB_PORT_FEAT_POWER);
                         break;
                 case USB_PORT_FEAT_SUSPEND:
                         break;
@@ -2213,6 +2226,68 @@ error:
         return ret;
 }
 
+#if defined(CONFIG_PM)
+static int r8a66597_bus_suspend(struct usb_hcd *hcd)
+{
+        struct r8a66597 *r8a66597 = hcd_to_r8a66597(hcd);
+        int port;
+
+        dbg("%s", __func__);
+
+        for (port = 0; port < R8A66597_MAX_ROOT_HUB; port++) {
+                struct r8a66597_root_hub *rh = &r8a66597->root_hub[port];
+                unsigned long dvstctr_reg = get_dvstctr_reg(port);
+
+                if (!(rh->port & (1 << USB_PORT_FEAT_ENABLE)))
+                        continue;
+
+                dbg("suspend port = %d", port);
+                r8a66597_bclr(r8a66597, UACT, dvstctr_reg);     /* suspend */
+                rh->port |= 1 << USB_PORT_FEAT_SUSPEND;
+
+                if (rh->dev->udev->do_remote_wakeup) {
+                        msleep(3);      /* waiting last SOF */
+                        r8a66597_bset(r8a66597, RWUPE, dvstctr_reg);
+                        r8a66597_write(r8a66597, ~BCHG, get_intsts_reg(port));
+                        r8a66597_bset(r8a66597, BCHGE, get_intenb_reg(port));
+                }
+        }
+
+        r8a66597->bus_suspended = 1;
+
+        return 0;
+}
+
+static int r8a66597_bus_resume(struct usb_hcd *hcd)
+{
+        struct r8a66597 *r8a66597 = hcd_to_r8a66597(hcd);
+        int port;
+
+        dbg("%s", __func__);
+
+        for (port = 0; port < R8A66597_MAX_ROOT_HUB; port++) {
+                struct r8a66597_root_hub *rh = &r8a66597->root_hub[port];
+                unsigned long dvstctr_reg = get_dvstctr_reg(port);
+
+                if (!(rh->port & (1 << USB_PORT_FEAT_SUSPEND)))
+                        continue;
+
+                dbg("resume port = %d", port);
+                rh->port &= ~(1 << USB_PORT_FEAT_SUSPEND);
+                rh->port |= 1 << USB_PORT_FEAT_C_SUSPEND;
+                r8a66597_mdfy(r8a66597, RESUME, RESUME | UACT, dvstctr_reg);
+                msleep(50);
+                r8a66597_mdfy(r8a66597, UACT, RESUME | UACT, dvstctr_reg);
+        }
+
+        return 0;
+
+}
+#else
+#define r8a66597_bus_suspend    NULL
+#define r8a66597_bus_resume     NULL
+#endif
+
 static struct hc_driver r8a66597_hc_driver = {
         .description =          hcd_name,
         .hcd_priv_size =        sizeof(struct r8a66597),
@@ -2243,16 +2318,39 @@ static struct hc_driver r8a66597_hc_driver = {
          */
         .hub_status_data =      r8a66597_hub_status_data,
         .hub_control =          r8a66597_hub_control,
+        .bus_suspend =          r8a66597_bus_suspend,
+        .bus_resume =           r8a66597_bus_resume,
 };
 
 #if defined(CONFIG_PM)
 static int r8a66597_suspend(struct platform_device *pdev, pm_message_t state)
 {
+        struct r8a66597         *r8a66597 = dev_get_drvdata(&pdev->dev);
+        int port;
+
+        dbg("%s", __func__);
+
+        disable_controller(r8a66597);
+
+        for (port = 0; port < R8A66597_MAX_ROOT_HUB; port++) {
+                struct r8a66597_root_hub *rh = &r8a66597->root_hub[port];
+
+                rh->port = 0x00000000;
+        }
+
         return 0;
 }
 
 static int r8a66597_resume(struct platform_device *pdev)
 {
+        struct r8a66597         *r8a66597 = dev_get_drvdata(&pdev->dev);
+        struct usb_hcd          *hcd = r8a66597_to_hcd(r8a66597);
+
+        dbg("%s", __func__);
+
+        enable_controller(r8a66597);
+        usb_root_hub_lost_power(hcd->self.root_hub);
+
         return 0;
 }
 #else   /* if defined(CONFIG_PM) */
diff --git a/drivers/usb/host/r8a66597.h b/drivers/usb/host/r8a66597.h
index ecacde4d69b0..f49208f1bb74 100644
--- a/drivers/usb/host/r8a66597.h
+++ b/drivers/usb/host/r8a66597.h
@@ -504,6 +504,8 @@ struct r8a66597 {
 
         struct list_head child_device;
         unsigned long child_connect_map[4];
+
+        unsigned bus_suspended:1;
 };
 
 static inline struct r8a66597 *hcd_to_r8a66597(struct usb_hcd *hcd)
diff --git a/drivers/usb/host/sl811-hcd.c b/drivers/usb/host/sl811-hcd.c
index e106e9d48d4a..a949259f18b9 100644
--- a/drivers/usb/host/sl811-hcd.c
+++ b/drivers/usb/host/sl811-hcd.c
@@ -230,7 +230,7 @@ static void in_packet(
         writeb(usb_pipedevice(urb->pipe), data_reg);
 
         sl811_write(sl811, bank + SL11H_HOSTCTLREG, control);
-        ep->length = min((int)len,
+        ep->length = min_t(u32, len,
                         urb->transfer_buffer_length - urb->actual_length);
         PACKET("IN%s/%d qh%p len%d\n", ep->nak_count ? "/retry" : "",
                         !!usb_gettoggle(urb->dev, ep->epnum, 0), ep, len);
@@ -255,7 +255,7 @@ static void out_packet(
         buf = urb->transfer_buffer + urb->actual_length;
         prefetch(buf);
 
-        len = min((int)ep->maxpacket,
+        len = min_t(u32, ep->maxpacket,
                         urb->transfer_buffer_length - urb->actual_length);
 
         if (!(control & SL11H_HCTLMASK_ISOCH)
diff --git a/drivers/usb/host/uhci-debug.c b/drivers/usb/host/uhci-debug.c
index 20cc58b97807..e52b954dda47 100644
--- a/drivers/usb/host/uhci-debug.c
+++ b/drivers/usb/host/uhci-debug.c
@@ -118,7 +118,9 @@ static int uhci_show_urbp(struct urb_priv *urbp, char *buf, int len, int space)
         }
 
         out += sprintf(out, "%s%s", ptype, (urbp->fsbr ? " FSBR" : ""));
-        out += sprintf(out, " Actlen=%d", urbp->urb->actual_length);
+        out += sprintf(out, " Actlen=%d%s", urbp->urb->actual_length,
+                        (urbp->qh->type == USB_ENDPOINT_XFER_CONTROL ?
+                                "-8" : ""));
 
         if (urbp->urb->unlinked)
                 out += sprintf(out, " Unlinked=%d", urbp->urb->unlinked);
diff --git a/drivers/usb/host/uhci-hcd.h b/drivers/usb/host/uhci-hcd.h
index 7d01c5677f92..26bd1b2bcbfc 100644
--- a/drivers/usb/host/uhci-hcd.h
+++ b/drivers/usb/host/uhci-hcd.h
@@ -73,11 +73,11 @@
 #define   USBLEGSUP_RWC         0x8f00  /* the R/WC bits */
 #define   USBLEGSUP_RO          0x5040  /* R/O and reserved bits */
 
-#define UHCI_PTR_BITS           __constant_cpu_to_le32(0x000F)
-#define UHCI_PTR_TERM           __constant_cpu_to_le32(0x0001)
-#define UHCI_PTR_QH             __constant_cpu_to_le32(0x0002)
-#define UHCI_PTR_DEPTH          __constant_cpu_to_le32(0x0004)
-#define UHCI_PTR_BREADTH        __constant_cpu_to_le32(0x0000)
+#define UHCI_PTR_BITS           cpu_to_le32(0x000F)
+#define UHCI_PTR_TERM           cpu_to_le32(0x0001)
+#define UHCI_PTR_QH             cpu_to_le32(0x0002)
+#define UHCI_PTR_DEPTH          cpu_to_le32(0x0004)
+#define UHCI_PTR_BREADTH        cpu_to_le32(0x0000)
 
 #define UHCI_NUMFRAMES          1024    /* in the frame list [array] */
 #define UHCI_MAX_SOF_NUMBER     2047    /* in an SOF packet */
diff --git a/drivers/usb/host/uhci-q.c b/drivers/usb/host/uhci-q.c
index 5631d89c8730..3e5807d14ffb 100644
--- a/drivers/usb/host/uhci-q.c
+++ b/drivers/usb/host/uhci-q.c
@@ -402,7 +402,7 @@ static void uhci_fixup_toggles(struct uhci_qh *qh, int skip_first)
                 /* Otherwise all the toggles in the URB have to be switched */
                 } else {
                         list_for_each_entry(td, &urbp->td_list, list) {
-                                td->token ^= __constant_cpu_to_le32(
+                                td->token ^= cpu_to_le32(
                                                         TD_TOKEN_TOGGLE);
                                 toggle ^= 1;
                         }
@@ -883,7 +883,7 @@ static int uhci_submit_control(struct uhci_hcd *uhci, struct urb *urb,
 
         uhci_fill_td(td, 0, USB_PID_OUT | uhci_explen(0), 0);
         wmb();
-        qh->dummy_td->status |= __constant_cpu_to_le32(TD_CTRL_ACTIVE);
+        qh->dummy_td->status |= cpu_to_le32(TD_CTRL_ACTIVE);
         qh->dummy_td = td;
 
         /* Low-speed transfers get a different queue, and won't hog the bus.
@@ -899,8 +899,6 @@ static int uhci_submit_control(struct uhci_hcd *uhci, struct urb *urb,
         }
         if (qh->state != QH_STATE_ACTIVE)
                 qh->skel = skel;
-
-        urb->actual_length = -8;        /* Account for the SETUP packet */
         return 0;
 
 nomem:
@@ -1003,7 +1001,7 @@ static int uhci_submit_common(struct uhci_hcd *uhci, struct urb *urb,
          * fast side but not enough to justify delaying an interrupt
          * more than 2 or 3 URBs, so we will ignore the URB_NO_INTERRUPT
          * flag setting. */
-        td->status |= __constant_cpu_to_le32(TD_CTRL_IOC);
+        td->status |= cpu_to_le32(TD_CTRL_IOC);
 
         /*
          * Build the new dummy TD and activate the old one
@@ -1015,7 +1013,7 @@ static int uhci_submit_common(struct uhci_hcd *uhci, struct urb *urb,
 
         uhci_fill_td(td, 0, USB_PID_OUT | uhci_explen(0), 0);
         wmb();
-        qh->dummy_td->status |= __constant_cpu_to_le32(TD_CTRL_ACTIVE);
+        qh->dummy_td->status |= cpu_to_le32(TD_CTRL_ACTIVE);
         qh->dummy_td = td;
 
         usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe),
@@ -1317,7 +1315,7 @@ static int uhci_submit_isochronous(struct uhci_hcd *uhci, struct urb *urb,
         }
 
         /* Set the interrupt-on-completion flag on the last packet. */
-        td->status |= __constant_cpu_to_le32(TD_CTRL_IOC);
+        td->status |= cpu_to_le32(TD_CTRL_IOC);
 
         /* Add the TDs to the frame list */
         frame = urb->start_frame;
@@ -1494,11 +1492,10 @@ __acquires(uhci->lock)
 
         if (qh->type == USB_ENDPOINT_XFER_CONTROL) {
 
-                /* urb->actual_length < 0 means the setup transaction didn't
-                 * complete successfully.  Either it failed or the URB was
-                 * unlinked first.  Regardless, don't confuse people with a
-                 * negative length. */
-                urb->actual_length = max(urb->actual_length, 0);
+                /* Subtract off the length of the SETUP packet from
+                 * urb->actual_length.
+                 */
+                urb->actual_length -= min_t(u32, 8, urb->actual_length);
         }
 
         /* When giving back the first URB in an Isochronous queue,