17 files changed, 256 insertions, 375 deletions

diff --git a/drivers/usb/host/ehci-dbg.c b/drivers/usb/host/ehci-dbg.c
index b0f8ed5a7fb9..0cb53ca8d343 100644
--- a/drivers/usb/host/ehci-dbg.c
+++ b/drivers/usb/host/ehci-dbg.c
@@ -358,7 +358,8 @@ struct debug_buffer {
         struct usb_bus *bus;
         struct mutex mutex;     /* protect filling of buffer */
         size_t count;           /* number of characters filled into buffer */
-        char *page;
+        char *output_buf;
+        size_t alloc_size;
 };
 
 #define speed_char(info1) ({ char tmp; \
@@ -488,8 +489,8 @@ static ssize_t fill_async_buffer(struct debug_buffer *buf)
 
         hcd = bus_to_hcd(buf->bus);
         ehci = hcd_to_ehci (hcd);
-        next = buf->page;
-        size = PAGE_SIZE;
+        next = buf->output_buf;
+        size = buf->alloc_size;
 
         *next = 0;
 
@@ -510,7 +511,7 @@ static ssize_t fill_async_buffer(struct debug_buffer *buf)
         }
         spin_unlock_irqrestore (&ehci->lock, flags);
 
-        return strlen(buf->page);
+        return strlen(buf->output_buf);
 }
 
 #define DBG_SCHED_LIMIT 64
@@ -531,8 +532,8 @@ static ssize_t fill_periodic_buffer(struct debug_buffer *buf)
 
         hcd = bus_to_hcd(buf->bus);
         ehci = hcd_to_ehci (hcd);
-        next = buf->page;
-        size = PAGE_SIZE;
+        next = buf->output_buf;
+        size = buf->alloc_size;
 
         temp = scnprintf (next, size, "size = %d\n", ehci->periodic_size);
         size -= temp;
@@ -568,14 +569,16 @@ static ssize_t fill_periodic_buffer(struct debug_buffer *buf)
                                 for (temp = 0; temp < seen_count; temp++) {
                                         if (seen [temp].ptr != p.ptr)
                                                 continue;
-                                        if (p.qh->qh_next.ptr)
+                                        if (p.qh->qh_next.ptr) {
                                                 temp = scnprintf (next, size,
                                                         " ...");
-                                        p.ptr = NULL;
+                                                size -= temp;
+                                                next += temp;
+                                        }
                                         break;
                                 }
                                 /* show more info the first time around */
-                                if (temp == seen_count && p.ptr) {
+                                if (temp == seen_count) {
                                         u32     scratch = hc32_to_cpup(ehci,
                                                         &p.qh->hw_info1);
                                         struct ehci_qtd *qtd;
@@ -649,7 +652,7 @@ static ssize_t fill_periodic_buffer(struct debug_buffer *buf)
         spin_unlock_irqrestore (&ehci->lock, flags);
         kfree (seen);
 
-        return PAGE_SIZE - size;
+        return buf->alloc_size - size;
 }
 #undef DBG_SCHED_LIMIT
 
@@ -665,14 +668,14 @@ static ssize_t fill_registers_buffer(struct debug_buffer *buf)
 
         hcd = bus_to_hcd(buf->bus);
         ehci = hcd_to_ehci (hcd);
-        next = buf->page;
-        size = PAGE_SIZE;
+        next = buf->output_buf;
+        size = buf->alloc_size;
 
         spin_lock_irqsave (&ehci->lock, flags);
 
         if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)) {
                 size = scnprintf (next, size,
-                        "bus %s, device %s (driver " DRIVER_VERSION ")\n"
+                        "bus %s, device %s\n"
                         "%s\n"
                         "SUSPENDED (no register access)\n",
                         hcd->self.controller->bus->name,
@@ -684,7 +687,7 @@ static ssize_t fill_registers_buffer(struct debug_buffer *buf)
         /* Capability Registers */
         i = HC_VERSION(ehci_readl(ehci, &ehci->caps->hc_capbase));
         temp = scnprintf (next, size,
-                "bus %s, device %s (driver " DRIVER_VERSION ")\n"
+                "bus %s, device %s\n"
                 "%s\n"
                 "EHCI %x.%02x, hcd state %d\n",
                 hcd->self.controller->bus->name,
@@ -808,7 +811,7 @@ static ssize_t fill_registers_buffer(struct debug_buffer *buf)
 done:
         spin_unlock_irqrestore (&ehci->lock, flags);
 
-        return PAGE_SIZE - size;
+        return buf->alloc_size - size;
 }
 
 static struct debug_buffer *alloc_buffer(struct usb_bus *bus,
@@ -822,6 +825,7 @@ static struct debug_buffer *alloc_buffer(struct usb_bus *bus,
                 buf->bus = bus;
                 buf->fill_func = fill_func;
                 mutex_init(&buf->mutex);
+                buf->alloc_size = PAGE_SIZE;
         }
 
         return buf;
@@ -831,10 +835,10 @@ static int fill_buffer(struct debug_buffer *buf)
 {
         int ret = 0;
 
-        if (!buf->page)
-                buf->page = (char *)get_zeroed_page(GFP_KERNEL);
+        if (!buf->output_buf)
+                buf->output_buf = (char *)vmalloc(buf->alloc_size);
 
-        if (!buf->page) {
+        if (!buf->output_buf) {
                 ret = -ENOMEM;
                 goto out;
         }
@@ -867,7 +871,7 @@ static ssize_t debug_output(struct file *file, char __user *user_buf,
         mutex_unlock(&buf->mutex);
 
         ret = simple_read_from_buffer(user_buf, len, offset,
-                                      buf->page, buf->count);
+                                      buf->output_buf, buf->count);
 
 out:
         return ret;
@@ -879,8 +883,8 @@ static int debug_close(struct inode *inode, struct file *file)
         struct debug_buffer *buf = file->private_data;
 
         if (buf) {
-                if (buf->page)
-                        free_page((unsigned long)buf->page);
+                if (buf->output_buf)
+                        vfree(buf->output_buf);
                 kfree(buf);
         }
 
@@ -895,10 +899,14 @@ static int debug_async_open(struct inode *inode, struct file *file)
 
 static int debug_periodic_open(struct inode *inode, struct file *file)
 {
-        file->private_data = alloc_buffer(inode->i_private,
-                                          fill_periodic_buffer);
+        struct debug_buffer *buf;
+        buf = alloc_buffer(inode->i_private, fill_periodic_buffer);
+        if (!buf)
+                return -ENOMEM;
 
-        return file->private_data ? 0 : -ENOMEM;
+        buf->alloc_size = (sizeof(void *) == 4 ? 6 : 8)*PAGE_SIZE;
+        file->private_data = buf;
+        return 0;
 }
 
 static int debug_registers_open(struct inode *inode, struct file *file)
diff --git a/drivers/usb/host/ehci-hcd.c b/drivers/usb/host/ehci-hcd.c
index 8409e0705d63..d343afacb0b0 100644
--- a/drivers/usb/host/ehci-hcd.c
+++ b/drivers/usb/host/ehci-hcd.c
@@ -24,6 +24,7 @@
 #include <linux/ioport.h>
 #include <linux/sched.h>
 #include <linux/slab.h>
+#include <linux/vmalloc.h>
 #include <linux/errno.h>
 #include <linux/init.h>
 #include <linux/timer.h>
@@ -59,7 +60,6 @@
  * providing early devices for those host controllers to talk to!
  */
 
-#define DRIVER_VERSION "10 Dec 2004"
 #define DRIVER_AUTHOR "David Brownell"
 #define DRIVER_DESC "USB 2.0 'Enhanced' Host Controller (EHCI) Driver"
 
@@ -620,9 +620,9 @@ static int ehci_run (struct usb_hcd *hcd)
 
         temp = HC_VERSION(ehci_readl(ehci, &ehci->caps->hc_capbase));
         ehci_info (ehci,
-                "USB %x.%x started, EHCI %x.%02x, driver %s%s\n",
+                "USB %x.%x started, EHCI %x.%02x%s\n",
                 ((ehci->sbrn & 0xf0)>>4), (ehci->sbrn & 0x0f),
-                temp >> 8, temp & 0xff, DRIVER_VERSION,
+                temp >> 8, temp & 0xff,
                 ignore_oc ? ", overcurrent ignored" : "");
 
         ehci_writel(ehci, INTR_MASK,
@@ -706,7 +706,7 @@ static irqreturn_t ehci_irq (struct usb_hcd *hcd)
                 pcd_status = status;
 
                 /* resume root hub? */
-                if (!(ehci_readl(ehci, &ehci->regs->command) & CMD_RUN))
+                if (!(cmd & CMD_RUN))
                         usb_hcd_resume_root_hub(hcd);
 
                 while (i--) {
@@ -715,8 +715,11 @@ static irqreturn_t ehci_irq (struct usb_hcd *hcd)
 
                         if (pstatus & PORT_OWNER)
                                 continue;
-                        if (!(pstatus & PORT_RESUME)
-                                        || ehci->reset_done [i] != 0)
+                        if (!(test_bit(i, &ehci->suspended_ports) &&
+                                        ((pstatus & PORT_RESUME) ||
+                                                !(pstatus & PORT_SUSPEND)) &&
+                                        (pstatus & PORT_PE) &&
+                                        ehci->reset_done[i] == 0))
                                 continue;
 
                         /* start 20 msec resume signaling from this port,
@@ -731,9 +734,8 @@ static irqreturn_t ehci_irq (struct usb_hcd *hcd)
 
         /* PCI errors [4.15.2.4] */
         if (unlikely ((status & STS_FATAL) != 0)) {
-                dbg_cmd (ehci, "fatal", ehci_readl(ehci,
-                                                   &ehci->regs->command));
-                dbg_status (ehci, "fatal", status);
+                dbg_cmd(ehci, "fatal", cmd);
+                dbg_status(ehci, "fatal", status);
                 if (status & STS_HALT) {
                         ehci_err (ehci, "fatal error\n");
 dead:
@@ -994,9 +996,7 @@ static int ehci_get_frame (struct usb_hcd *hcd)
 
 /*-------------------------------------------------------------------------*/
 
-#define DRIVER_INFO DRIVER_VERSION " " DRIVER_DESC
-
-MODULE_DESCRIPTION (DRIVER_INFO);
+MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_AUTHOR (DRIVER_AUTHOR);
 MODULE_LICENSE ("GPL");
 
@@ -1020,11 +1020,6 @@ MODULE_LICENSE ("GPL");
 #define PS3_SYSTEM_BUS_DRIVER   ps3_ehci_driver
 #endif
 
-#if defined(CONFIG_440EPX) && !defined(CONFIG_PPC_MERGE)
-#include "ehci-ppc-soc.c"
-#define PLATFORM_DRIVER         ehci_ppc_soc_driver
-#endif
-
 #ifdef CONFIG_USB_EHCI_HCD_PPC_OF
 #include "ehci-ppc-of.c"
 #define OF_PLATFORM_DRIVER      ehci_hcd_ppc_of_driver
@@ -1049,6 +1044,16 @@ static int __init ehci_hcd_init(void)
 {
         int retval = 0;
 
+        if (usb_disabled())
+                return -ENODEV;
+
+        printk(KERN_INFO "%s: " DRIVER_DESC "\n", hcd_name);
+        set_bit(USB_EHCI_LOADED, &usb_hcds_loaded);
+        if (test_bit(USB_UHCI_LOADED, &usb_hcds_loaded) ||
+                        test_bit(USB_OHCI_LOADED, &usb_hcds_loaded))
+                printk(KERN_WARNING "Warning! ehci_hcd should always be loaded"
+                                " before uhci_hcd and ohci_hcd, not after\n");
+
         pr_debug("%s: block sizes: qh %Zd qtd %Zd itd %Zd sitd %Zd\n",
                  hcd_name,
                  sizeof(struct ehci_qh), sizeof(struct ehci_qtd),
@@ -1056,8 +1061,10 @@ static int __init ehci_hcd_init(void)
 
 #ifdef DEBUG
         ehci_debug_root = debugfs_create_dir("ehci", NULL);
-        if (!ehci_debug_root)
-                return -ENOENT;
+        if (!ehci_debug_root) {
+                retval = -ENOENT;
+                goto err_debug;
+        }
 #endif
 
 #ifdef PLATFORM_DRIVER
@@ -1105,6 +1112,8 @@ clean0:
         debugfs_remove(ehci_debug_root);
         ehci_debug_root = NULL;
 #endif
+err_debug:
+        clear_bit(USB_EHCI_LOADED, &usb_hcds_loaded);
         return retval;
 }
 module_init(ehci_hcd_init);
@@ -1126,6 +1135,7 @@ static void __exit ehci_hcd_cleanup(void)
 #ifdef DEBUG
         debugfs_remove(ehci_debug_root);
 #endif
+        clear_bit(USB_EHCI_LOADED, &usb_hcds_loaded);
 }
 module_exit(ehci_hcd_cleanup);
 
diff --git a/drivers/usb/host/ehci-hub.c b/drivers/usb/host/ehci-hub.c
index 740835bb8575..218f9660d7ee 100644
--- a/drivers/usb/host/ehci-hub.c
+++ b/drivers/usb/host/ehci-hub.c
@@ -236,10 +236,8 @@ static int ehci_bus_resume (struct usb_hcd *hcd)
                 temp = ehci_readl(ehci, &ehci->regs->port_status [i]);
                 temp &= ~(PORT_RWC_BITS | PORT_WAKE_BITS);
                 if (test_bit(i, &ehci->bus_suspended) &&
-                                (temp & PORT_SUSPEND)) {
-                        ehci->reset_done [i] = jiffies + msecs_to_jiffies (20);
+                                (temp & PORT_SUSPEND))
                         temp |= PORT_RESUME;
-                }
                 ehci_writel(ehci, temp, &ehci->regs->port_status [i]);
         }
         i = HCS_N_PORTS (ehci->hcs_params);
@@ -482,10 +480,9 @@ ehci_hub_status_data (struct usb_hcd *hcd, char *buf)
                  * controller by the user.
                  */
 
-                if ((temp & mask) != 0
-                                || ((temp & PORT_RESUME) != 0
-                                        && time_after_eq(jiffies,
-                                                ehci->reset_done[i]))) {
+                if ((temp & mask) != 0 || test_bit(i, &ehci->port_c_suspend)
+                                || (ehci->reset_done[i] && time_after_eq(
+                                        jiffies, ehci->reset_done[i]))) {
                         if (i < 7)
                             buf [0] |= 1 << (i + 1);
                         else
@@ -688,6 +685,7 @@ static int ehci_hub_control (
                         /* resume completed? */
                         else if (time_after_eq(jiffies,
                                         ehci->reset_done[wIndex])) {
+                                clear_bit(wIndex, &ehci->suspended_ports);
                                 set_bit(wIndex, &ehci->port_c_suspend);
                                 ehci->reset_done[wIndex] = 0;
 
@@ -734,6 +732,9 @@ static int ehci_hub_control (
                                         ehci_readl(ehci, status_reg));
                 }
 
+                if (!(temp & (PORT_RESUME|PORT_RESET)))
+                        ehci->reset_done[wIndex] = 0;
+
                 /* transfer dedicated ports to the companion hc */
                 if ((temp & PORT_CONNECT) &&
                                 test_bit(wIndex, &ehci->companion_ports)) {
@@ -757,8 +758,17 @@ static int ehci_hub_control (
                 }
                 if (temp & PORT_PE)
                         status |= 1 << USB_PORT_FEAT_ENABLE;
-                if (temp & (PORT_SUSPEND|PORT_RESUME))
+
+                /* maybe the port was unsuspended without our knowledge */
+                if (temp & (PORT_SUSPEND|PORT_RESUME)) {
                         status |= 1 << USB_PORT_FEAT_SUSPEND;
+                } else if (test_bit(wIndex, &ehci->suspended_ports)) {
+                        clear_bit(wIndex, &ehci->suspended_ports);
+                        ehci->reset_done[wIndex] = 0;
+                        if (temp & PORT_PE)
+                                set_bit(wIndex, &ehci->port_c_suspend);
+                }
+
                 if (temp & PORT_OC)
                         status |= 1 << USB_PORT_FEAT_OVER_CURRENT;
                 if (temp & PORT_RESET)
@@ -803,6 +813,7 @@ static int ehci_hub_control (
                                         || (temp & PORT_RESET) != 0)
                                 goto error;
                         ehci_writel(ehci, temp | PORT_SUSPEND, status_reg);
+                        set_bit(wIndex, &ehci->suspended_ports);
                         break;
                 case USB_PORT_FEAT_POWER:
                         if (HCS_PPC (ehci->hcs_params))
diff --git a/drivers/usb/host/ehci-ppc-soc.c b/drivers/usb/host/ehci-ppc-soc.c
deleted file mode 100644
index 529590eb4037..000000000000
--- a/drivers/usb/host/ehci-ppc-soc.c
+++ /dev/null
@@ -1,201 +0,0 @@
-/*
- * EHCI HCD (Host Controller Driver) for USB.
- *
- * (C) Copyright 2006-2007 Stefan Roese <sr@denx.de>, DENX Software Engineering
- *
- * Bus Glue for PPC On-Chip EHCI driver
- * Tested on AMCC 440EPx
- *
- * Based on "ehci-au1xxx.c" by K.Boge <karsten.boge@amd.com>
- *
- * This file is licenced under the GPL.
- */
-
-#include <linux/platform_device.h>
-
-extern int usb_disabled(void);
-
-/* called during probe() after chip reset completes */
-static int ehci_ppc_soc_setup(struct usb_hcd *hcd)
-{
-        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
-        int             retval;
-
-        retval = ehci_halt(ehci);
-        if (retval)
-                return retval;
-
-        retval = ehci_init(hcd);
-        if (retval)
-                return retval;
-
-        ehci->sbrn = 0x20;
-        return ehci_reset(ehci);
-}
-
-/**
- * usb_ehci_ppc_soc_probe - initialize PPC-SoC-based HCDs
- * Context: !in_interrupt()
- *
- * Allocates basic resources for this USB host controller, and
- * then invokes the start() method for the HCD associated with it
- * through the hotplug entry's driver_data.
- *
- */
-int usb_ehci_ppc_soc_probe(const struct hc_driver *driver,
-                           struct usb_hcd **hcd_out,
-                           struct platform_device *dev)
-{
-        int retval;
-        struct usb_hcd *hcd;
-        struct ehci_hcd *ehci;
-
-        if (dev->resource[1].flags != IORESOURCE_IRQ) {
-                pr_debug("resource[1] is not IORESOURCE_IRQ");
-                retval = -ENOMEM;
-        }
-        hcd = usb_create_hcd(driver, &dev->dev, "PPC-SOC EHCI");
-        if (!hcd)
-                return -ENOMEM;
-        hcd->rsrc_start = dev->resource[0].start;
-        hcd->rsrc_len = dev->resource[0].end - dev->resource[0].start + 1;
-
-        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
-                pr_debug("request_mem_region failed");
-                retval = -EBUSY;
-                goto err1;
-        }
-
-        hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
-        if (!hcd->regs) {
-                pr_debug("ioremap failed");
-                retval = -ENOMEM;
-                goto err2;
-        }
-
-        ehci = hcd_to_ehci(hcd);
-        ehci->big_endian_mmio = 1;
-        ehci->big_endian_desc = 1;
-        ehci->caps = hcd->regs;
-        ehci->regs = hcd->regs + HC_LENGTH(ehci_readl(ehci, &ehci->caps->hc_capbase));
-
-        /* cache this readonly data; minimize chip reads */
-        ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
-
-#if defined(CONFIG_440EPX)
-        /*
-         * 440EPx Errata USBH_3
-         * Fix: Enable Break Memory Transfer (BMT) in INSNREG3
-         */
-        out_be32((void *)((ulong)(&ehci->regs->command) + 0x8c), (1 << 0));
-        ehci_dbg(ehci, "Break Memory Transfer (BMT) has beed enabled!\n");
-#endif
-
-        retval = usb_add_hcd(hcd, dev->resource[1].start, IRQF_DISABLED);
-        if (retval == 0)
-                return retval;
-
-        iounmap(hcd->regs);
-err2:
-        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
-err1:
-        usb_put_hcd(hcd);
-        return retval;
-}
-
-/* may be called without controller electrically present */
-/* may be called with controller, bus, and devices active */
-
-/**
- * usb_ehci_hcd_ppc_soc_remove - shutdown processing for PPC-SoC-based HCDs
- * @dev: USB Host Controller being removed
- * Context: !in_interrupt()
- *
- * Reverses the effect of usb_ehci_hcd_ppc_soc_probe(), first invoking
- * the HCD's stop() method.  It is always called from a thread
- * context, normally "rmmod", "apmd", or something similar.
- *
- */
-void usb_ehci_ppc_soc_remove(struct usb_hcd *hcd, struct platform_device *dev)
-{
-        usb_remove_hcd(hcd);
-        iounmap(hcd->regs);
-        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
-        usb_put_hcd(hcd);
-}
-
-static const struct hc_driver ehci_ppc_soc_hc_driver = {
-        .description = hcd_name,
-        .product_desc = "PPC-SOC EHCI",
-        .hcd_priv_size = sizeof(struct ehci_hcd),
-
-        /*
-         * generic hardware linkage
-         */
-        .irq = ehci_irq,
-        .flags = HCD_MEMORY | HCD_USB2,
-
-        /*
-         * basic lifecycle operations
-         */
-        .reset = ehci_ppc_soc_setup,
-        .start = ehci_run,
-        .stop = ehci_stop,
-        .shutdown = ehci_shutdown,
-
-        /*
-         * managing i/o requests and associated device resources
-         */
-        .urb_enqueue = ehci_urb_enqueue,
-        .urb_dequeue = ehci_urb_dequeue,
-        .endpoint_disable = ehci_endpoint_disable,
-
-        /*
-         * scheduling support
-         */
-        .get_frame_number = ehci_get_frame,
-
-        /*
-         * root hub support
-         */
-        .hub_status_data = ehci_hub_status_data,
-        .hub_control = ehci_hub_control,
-        .bus_suspend = ehci_bus_suspend,
-        .bus_resume = ehci_bus_resume,
-        .relinquish_port = ehci_relinquish_port,
-        .port_handed_over = ehci_port_handed_over,
-};
-
-static int ehci_hcd_ppc_soc_drv_probe(struct platform_device *pdev)
-{
-        struct usb_hcd *hcd = NULL;
-        int ret;
-
-        pr_debug("In ehci_hcd_ppc_soc_drv_probe\n");
-
-        if (usb_disabled())
-                return -ENODEV;
-
-        /* FIXME we only want one one probe() not two */
-        ret = usb_ehci_ppc_soc_probe(&ehci_ppc_soc_hc_driver, &hcd, pdev);
-        return ret;
-}
-
-static int ehci_hcd_ppc_soc_drv_remove(struct platform_device *pdev)
-{
-        struct usb_hcd *hcd = platform_get_drvdata(pdev);
-
-        /* FIXME we only want one one remove() not two */
-        usb_ehci_ppc_soc_remove(hcd, pdev);
-        return 0;
-}
-
-MODULE_ALIAS("platform:ppc-soc-ehci");
-static struct platform_driver ehci_ppc_soc_driver = {
-        .probe = ehci_hcd_ppc_soc_drv_probe,
-        .remove = ehci_hcd_ppc_soc_drv_remove,
-        .shutdown = usb_hcd_platform_shutdown,
-        .driver = {
-                .name = "ppc-soc-ehci",
-        }
-};
diff --git a/drivers/usb/host/ehci.h b/drivers/usb/host/ehci.h
index b697a13364ec..b11798d17ae5 100644
--- a/drivers/usb/host/ehci.h
+++ b/drivers/usb/host/ehci.h
@@ -99,6 +99,8 @@ struct ehci_hcd {			/* one per controller */
                         owned by the companion during a bus suspend */
         unsigned long           port_c_suspend;         /* which ports have
                         the change-suspend feature turned on */
+        unsigned long           suspended_ports;        /* which ports are
+                        suspended */
 
         /* per-HC memory pools (could be per-bus, but ...) */
         struct dma_pool         *qh_pool;       /* qh per active urb */
@@ -181,14 +183,16 @@ timer_action (struct ehci_hcd *ehci, enum ehci_timer_action action)
          * 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;
+        enum ehci_timer_action oldactions = ehci->actions;
 
         if (!test_and_set_bit (action, &ehci->actions)) {
                 unsigned long t;
 
+                if (timer_pending(&ehci->watchdog)
+                        && ((BIT(TIMER_ASYNC_SHRINK) | BIT(TIMER_ASYNC_OFF))
+                                & oldactions))
+                        return;
+
                 switch (action) {
                 case TIMER_IO_WATCHDOG:
                         t = EHCI_IO_JIFFIES;
@@ -204,7 +208,7 @@ timer_action (struct ehci_hcd *ehci, enum ehci_timer_action action)
                         t = DIV_ROUND_UP(EHCI_SHRINK_FRAMES * HZ, 1000) + 1;
                         break;
                 }
-                mod_timer(&ehci->watchdog, t + jiffies);
+                mod_timer(&ehci->watchdog, round_jiffies(t + jiffies));
         }
 }
 
@@ -604,16 +608,7 @@ ehci_port_speed(struct ehci_hcd *ehci, unsigned int portsc)
 /*
  * Big-endian read/write functions are arch-specific.
  * Other arches can be added if/when they're needed.
- *
- * REVISIT: arch/powerpc now has readl/writel_be, so the
- * definition below can die once the 4xx support is
- * finally ported over.
  */
-#if defined(CONFIG_PPC) && !defined(CONFIG_PPC_MERGE)
-#define readl_be(addr)          in_be32((__force unsigned *)addr)
-#define writel_be(val, addr)    out_be32((__force unsigned *)addr, val)
-#endif
-
 #if defined(CONFIG_ARM) && defined(CONFIG_ARCH_IXP4XX)
 #define readl_be(addr)          __raw_readl((__force unsigned *)addr)
 #define writel_be(val, addr)    __raw_writel(val, (__force unsigned *)addr)
diff --git a/drivers/usb/host/isp116x-hcd.c b/drivers/usb/host/isp116x-hcd.c
index ce1ca0ba0515..4dda31b26892 100644
--- a/drivers/usb/host/isp116x-hcd.c
+++ b/drivers/usb/host/isp116x-hcd.c
@@ -1562,11 +1562,12 @@ static int __devinit isp116x_probe(struct platform_device *pdev)
 {
         struct usb_hcd *hcd;
         struct isp116x *isp116x;
-        struct resource *addr, *data;
+        struct resource *addr, *data, *ires;
         void __iomem *addr_reg;
         void __iomem *data_reg;
         int irq;
         int ret = 0;
+        unsigned long irqflags;
 
         if (pdev->num_resources < 3) {
                 ret = -ENODEV;
@@ -1575,12 +1576,16 @@ static int __devinit isp116x_probe(struct platform_device *pdev)
 
         data = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         addr = platform_get_resource(pdev, IORESOURCE_MEM, 1);
-        irq = platform_get_irq(pdev, 0);
-        if (!addr || !data || irq < 0) {
+        ires = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+
+        if (!addr || !data || !ires) {
                 ret = -ENODEV;
                 goto err1;
         }
 
+        irq = ires->start;
+        irqflags = ires->flags & IRQF_TRIGGER_MASK;
+
         if (pdev->dev.dma_mask) {
                 DBG("DMA not supported\n");
                 ret = -EINVAL;
@@ -1634,7 +1639,7 @@ static int __devinit isp116x_probe(struct platform_device *pdev)
                 goto err6;
         }
 
-        ret = usb_add_hcd(hcd, irq, IRQF_DISABLED);
+        ret = usb_add_hcd(hcd, irq, irqflags | IRQF_DISABLED);
         if (ret)
                 goto err6;
 
diff --git a/drivers/usb/host/isp1760-if.c b/drivers/usb/host/isp1760-if.c
index 051ef7b6bdc6..af849f596135 100644
--- a/drivers/usb/host/isp1760-if.c
+++ b/drivers/usb/host/isp1760-if.c
@@ -218,7 +218,7 @@ static int __devinit isp1761_pci_probe(struct pci_dev *dev,
          * and reading back and checking the contents are same or not
          */
         if (reg_data != 0xFACE) {
-                err("scratch register mismatch %x", reg_data);
+                dev_err(&dev->dev, "scratch register mismatch %x\n", reg_data);
                 goto clean;
         }
 
@@ -232,9 +232,10 @@ static int __devinit isp1761_pci_probe(struct pci_dev *dev,
         hcd = isp1760_register(pci_mem_phy0, length, dev->irq,
                 IRQF_SHARED | IRQF_DISABLED, &dev->dev, dev_name(&dev->dev),
                 devflags);
-        pci_set_drvdata(dev, hcd);
-        if (!hcd)
+        if (!IS_ERR(hcd)) {
+                pci_set_drvdata(dev, hcd);
                 return 0;
+        }
 clean:
         status = -ENODEV;
         iounmap(iobase);
diff --git a/drivers/usb/host/ohci-dbg.c b/drivers/usb/host/ohci-dbg.c
index 7cef1d2f7ccc..d3269656aa4d 100644
--- a/drivers/usb/host/ohci-dbg.c
+++ b/drivers/usb/host/ohci-dbg.c
@@ -649,7 +649,7 @@ static ssize_t fill_registers_buffer(struct debug_buffer *buf)
         ohci_dbg_sw (ohci, &next, &size,
                 "bus %s, device %s\n"
                 "%s\n"
-                "%s version " DRIVER_VERSION "\n",
+                "%s\n",
                 hcd->self.controller->bus->name,
                 dev_name(hcd->self.controller),
                 hcd->product_desc,
diff --git a/drivers/usb/host/ohci-hcd.c b/drivers/usb/host/ohci-hcd.c
index 89901962cbfd..8647dab0d7f9 100644
--- a/drivers/usb/host/ohci-hcd.c
+++ b/drivers/usb/host/ohci-hcd.c
@@ -46,7 +46,6 @@
 
 #include "../core/hcd.h"
 
-#define DRIVER_VERSION "2006 August 04"
 #define DRIVER_AUTHOR "Roman Weissgaerber, David Brownell"
 #define DRIVER_DESC "USB 1.1 'Open' Host Controller (OHCI) Driver"
 
@@ -984,10 +983,8 @@ static int ohci_restart (struct ohci_hcd *ohci)
 
 /*-------------------------------------------------------------------------*/
 
-#define DRIVER_INFO DRIVER_VERSION " " DRIVER_DESC
-
 MODULE_AUTHOR (DRIVER_AUTHOR);
-MODULE_DESCRIPTION (DRIVER_INFO);
+MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE ("GPL");
 
 #ifdef CONFIG_PCI
@@ -1095,9 +1092,10 @@ static int __init ohci_hcd_mod_init(void)
         if (usb_disabled())
                 return -ENODEV;
 
-        printk (KERN_DEBUG "%s: " DRIVER_INFO "\n", hcd_name);
+        printk(KERN_INFO "%s: " DRIVER_DESC "\n", hcd_name);
         pr_debug ("%s: block sizes: ed %Zd td %Zd\n", hcd_name,
                 sizeof (struct ed), sizeof (struct td));
+        set_bit(USB_OHCI_LOADED, &usb_hcds_loaded);
 
 #ifdef DEBUG
         ohci_debug_root = debugfs_create_dir("ohci", NULL);
@@ -1184,6 +1182,7 @@ static int __init ohci_hcd_mod_init(void)
  error_debug:
 #endif
 
+        clear_bit(USB_OHCI_LOADED, &usb_hcds_loaded);
         return retval;
 }
 module_init(ohci_hcd_mod_init);
@@ -1214,6 +1213,7 @@ static void __exit ohci_hcd_mod_exit(void)
 #ifdef DEBUG
         debugfs_remove(ohci_debug_root);
 #endif
+        clear_bit(USB_OHCI_LOADED, &usb_hcds_loaded);
 }
 module_exit(ohci_hcd_mod_exit);
 
diff --git a/drivers/usb/host/ohci-hub.c b/drivers/usb/host/ohci-hub.c
index 7ea9a7b31155..32bbce9718f0 100644
--- a/drivers/usb/host/ohci-hub.c
+++ b/drivers/usb/host/ohci-hub.c
@@ -359,21 +359,24 @@ static void ohci_finish_controller_resume(struct usb_hcd *hcd)
 
 /* Carry out polling-, autostop-, and autoresume-related state changes */
 static int ohci_root_hub_state_changes(struct ohci_hcd *ohci, int changed,
-                int any_connected)
+                int any_connected, int rhsc_status)
 {
         int     poll_rh = 1;
-        int     rhsc;
+        int     rhsc_enable;
 
-        rhsc = ohci_readl(ohci, &ohci->regs->intrenable) & OHCI_INTR_RHSC;
-        switch (ohci->hc_control & OHCI_CTRL_HCFS) {
+        /* Some broken controllers never turn off RHCS in the interrupt
+         * status register.  For their sake we won't re-enable RHSC
+         * interrupts if the interrupt bit is already active.
+         */
+        rhsc_enable = ohci_readl(ohci, &ohci->regs->intrenable) &
+                        OHCI_INTR_RHSC;
 
+        switch (ohci->hc_control & OHCI_CTRL_HCFS) {
         case OHCI_USB_OPER:
-                /* If no status changes are pending, enable status-change
-                 * interrupts.
-                 */
-                if (!rhsc && !changed) {
-                        rhsc = OHCI_INTR_RHSC;
-                        ohci_writel(ohci, rhsc, &ohci->regs->intrenable);
+                /* If no status changes are pending, enable RHSC interrupts. */
+                if (!rhsc_enable && !rhsc_status && !changed) {
+                        rhsc_enable = OHCI_INTR_RHSC;
+                        ohci_writel(ohci, rhsc_enable, &ohci->regs->intrenable);
                 }
 
                 /* Keep on polling until we know a device is connected
@@ -383,7 +386,7 @@ static int ohci_root_hub_state_changes(struct ohci_hcd *ohci, int changed,
                         if (any_connected ||
                                         !device_may_wakeup(&ohci_to_hcd(ohci)
                                                 ->self.root_hub->dev)) {
-                                if (rhsc)
+                                if (rhsc_enable)
                                         poll_rh = 0;
                         } else {
                                 ohci->autostop = 1;
@@ -396,34 +399,45 @@ static int ohci_root_hub_state_changes(struct ohci_hcd *ohci, int changed,
                                 ohci->autostop = 0;
                                 ohci->next_statechange = jiffies +
                                                 STATECHANGE_DELAY;
-                        } else if (rhsc && time_after_eq(jiffies,
+                        } else if (time_after_eq(jiffies,
                                                 ohci->next_statechange)
                                         && !ohci->ed_rm_list
                                         && !(ohci->hc_control &
                                                 OHCI_SCHED_ENABLES)) {
                                 ohci_rh_suspend(ohci, 1);
-                                poll_rh = 0;
+                                if (rhsc_enable)
+                                        poll_rh = 0;
                         }
                 }
                 break;
 
-        /* if there is a port change, autostart or ask to be resumed */
         case OHCI_USB_SUSPEND:
         case OHCI_USB_RESUME:
+                /* if there is a port change, autostart or ask to be resumed */
                 if (changed) {
                         if (ohci->autostop)
                                 ohci_rh_resume(ohci);
                         else
                                 usb_hcd_resume_root_hub(ohci_to_hcd(ohci));
-                } else {
-                        if (!rhsc && (ohci->autostop ||
-                                        ohci_to_hcd(ohci)->self.root_hub->
-                                                do_remote_wakeup))
-                                ohci_writel(ohci, OHCI_INTR_RHSC,
-                                                &ohci->regs->intrenable);
 
-                        /* everything is idle, no need for polling */
+                /* If remote wakeup is disabled, stop polling */
+                } else if (!ohci->autostop &&
+                                !ohci_to_hcd(ohci)->self.root_hub->
+                                        do_remote_wakeup) {
                         poll_rh = 0;
+
+                } else {
+                        /* If no status changes are pending,
+                         * enable RHSC interrupts
+                         */
+                        if (!rhsc_enable && !rhsc_status) {
+                                rhsc_enable = OHCI_INTR_RHSC;
+                                ohci_writel(ohci, rhsc_enable,
+                                                &ohci->regs->intrenable);
+                        }
+                        /* Keep polling until RHSC is enabled */
+                        if (rhsc_enable)
+                                poll_rh = 0;
                 }
                 break;
         }
@@ -441,18 +455,22 @@ static inline int ohci_rh_resume(struct ohci_hcd *ohci)
  * autostop isn't used when CONFIG_PM is turned off.
  */
 static int ohci_root_hub_state_changes(struct ohci_hcd *ohci, int changed,
-                int any_connected)
+                int any_connected, int rhsc_status)
 {
         /* If RHSC is enabled, don't poll */
         if (ohci_readl(ohci, &ohci->regs->intrenable) & OHCI_INTR_RHSC)
                 return 0;
 
-        /* If no status changes are pending, enable status-change interrupts */
-        if (!changed) {
-                ohci_writel(ohci, OHCI_INTR_RHSC, &ohci->regs->intrenable);
-                return 0;
-        }
-        return 1;
+        /* If status changes are pending, continue polling.
+         * Conversely, if no status changes are pending but the RHSC
+         * status bit was set, then RHSC may be broken so continue polling.
+         */
+        if (changed || rhsc_status)
+                return 1;
+
+        /* It's safe to re-enable RHSC interrupts */
+        ohci_writel(ohci, OHCI_INTR_RHSC, &ohci->regs->intrenable);
+        return 0;
 }
 
 #endif  /* CONFIG_PM */
@@ -467,6 +485,7 @@ ohci_hub_status_data (struct usb_hcd *hcd, char *buf)
         struct ohci_hcd *ohci = hcd_to_ohci (hcd);
         int             i, changed = 0, length = 1;
         int             any_connected = 0;
+        int             rhsc_status;
         unsigned long   flags;
 
         spin_lock_irqsave (&ohci->lock, flags);
@@ -492,12 +511,10 @@ ohci_hub_status_data (struct usb_hcd *hcd, char *buf)
                 length++;
         }
 
-        /* Some broken controllers never turn off RHCS in the interrupt
-         * status register.  For their sake we won't re-enable RHSC
-         * interrupts if the flag is already set.
-         */
-        if (ohci_readl(ohci, &ohci->regs->intrstatus) & OHCI_INTR_RHSC)
-                changed = 1;
+        /* Clear the RHSC status flag before reading the port statuses */
+        ohci_writel(ohci, OHCI_INTR_RHSC, &ohci->regs->intrstatus);
+        rhsc_status = ohci_readl(ohci, &ohci->regs->intrstatus) &
+                        OHCI_INTR_RHSC;
 
         /* look at each port */
         for (i = 0; i < ohci->num_ports; i++) {
@@ -517,7 +534,7 @@ ohci_hub_status_data (struct usb_hcd *hcd, char *buf)
         }
 
         hcd->poll_rh = ohci_root_hub_state_changes(ohci, changed,
-                        any_connected);
+                        any_connected, rhsc_status);
 
 done:
         spin_unlock_irqrestore (&ohci->lock, flags);
diff --git a/drivers/usb/host/ohci-omap.c b/drivers/usb/host/ohci-omap.c
index 522185629624..91697bdb399f 100644
--- a/drivers/usb/host/ohci-omap.c
+++ b/drivers/usb/host/ohci-omap.c
@@ -231,7 +231,7 @@ static int ohci_omap_init(struct usb_hcd *hcd)
 
         omap_ohci_clock_power(1);
 
-        if (cpu_is_omap1510()) {
+        if (cpu_is_omap15xx()) {
                 omap_1510_local_bus_power(1);
                 omap_1510_local_bus_init();
         }
@@ -319,7 +319,7 @@ static int usb_hcd_omap_probe (const struct hc_driver *driver,
         if (IS_ERR(usb_host_ck))
                 return PTR_ERR(usb_host_ck);
 
-        if (!cpu_is_omap1510())
+        if (!cpu_is_omap15xx())
                 usb_dc_ck = clk_get(0, "usb_dc_ck");
         else
                 usb_dc_ck = clk_get(0, "lb_ck");
diff --git a/drivers/usb/host/ohci-pnx4008.c b/drivers/usb/host/ohci-pnx4008.c
index 658a2a978c32..e306ca6aef3d 100644
--- a/drivers/usb/host/ohci-pnx4008.c
+++ b/drivers/usb/host/ohci-pnx4008.c
@@ -331,7 +331,7 @@ static int __devinit usb_hcd_pnx4008_probe(struct platform_device *pdev)
 
         int ret = 0, irq;
 
-        dev_dbg(&pdev->dev, "%s: " DRIVER_INFO " (pnx4008)\n", hcd_name);
+        dev_dbg(&pdev->dev, "%s: " DRIVER_DESC " (pnx4008)\n", hcd_name);
         if (usb_disabled()) {
                 err("USB is disabled");
                 ret = -ENODEV;
diff --git a/drivers/usb/host/ohci.h b/drivers/usb/host/ohci.h
index faf622eafce7..222011f6172c 100644
--- a/drivers/usb/host/ohci.h
+++ b/drivers/usb/host/ohci.h
@@ -540,15 +540,7 @@ static inline struct usb_hcd *ohci_to_hcd (const struct ohci_hcd *ohci)
  * Big-endian read/write functions are arch-specific.
  * Other arches can be added if/when they're needed.
  *
- * REVISIT: arch/powerpc now has readl/writel_be, so the
- * definition below can die once the STB04xxx support is
- * finally ported over.
  */
-#if defined(CONFIG_PPC) && !defined(CONFIG_PPC_MERGE)
-#define readl_be(addr)          in_be32((__force unsigned *)addr)
-#define writel_be(val, addr)    out_be32((__force unsigned *)addr, val)
-#endif
-
 static inline unsigned int _ohci_readl (const struct ohci_hcd *ohci,
                                         __hc32 __iomem * regs)
 {
diff --git a/drivers/usb/host/r8a66597-hcd.c b/drivers/usb/host/r8a66597-hcd.c
index ea7126f99cab..c18d8790c410 100644
--- a/drivers/usb/host/r8a66597-hcd.c
+++ b/drivers/usb/host/r8a66597-hcd.c
@@ -66,7 +66,7 @@ static unsigned short endian;
 module_param(endian, ushort, 0644);
 MODULE_PARM_DESC(endian, "data endian: big=256, little=0 (default=0)");
 
-static unsigned short irq_sense = INTL;
+static unsigned short irq_sense = 0xff;
 module_param(irq_sense, ushort, 0644);
 MODULE_PARM_DESC(irq_sense, "IRQ sense: low level=32, falling edge=0 "
                 "(default=32)");
@@ -118,7 +118,7 @@ static int r8a66597_clock_enable(struct r8a66597 *r8a66597)
                 r8a66597_write(r8a66597, SCKE, SYSCFG0);
                 tmp = r8a66597_read(r8a66597, SYSCFG0);
                 if (i++ > 1000) {
-                        err("register access fail.");
+                        printk(KERN_ERR "r8a66597: register access fail.\n");
                         return -ENXIO;
                 }
         } while ((tmp & SCKE) != SCKE);
@@ -128,7 +128,7 @@ static int r8a66597_clock_enable(struct r8a66597 *r8a66597)
                 r8a66597_write(r8a66597, USBE, SYSCFG0);
                 tmp = r8a66597_read(r8a66597, SYSCFG0);
                 if (i++ > 1000) {
-                        err("register access fail.");
+                        printk(KERN_ERR "r8a66597: register access fail.\n");
                         return -ENXIO;
                 }
         } while ((tmp & USBE) != USBE);
@@ -141,7 +141,7 @@ static int r8a66597_clock_enable(struct r8a66597 *r8a66597)
                 msleep(1);
                 tmp = r8a66597_read(r8a66597, SYSCFG0);
                 if (i++ > 500) {
-                        err("register access fail.");
+                        printk(KERN_ERR "r8a66597: register access fail.\n");
                         return -ENXIO;
                 }
         } while ((tmp & SCKE) != SCKE);
@@ -265,7 +265,7 @@ static void get_port_number(char *devpath, u16 *root_port, u16 *hub_port)
         if (root_port) {
                 *root_port = (devpath[0] & 0x0F) - 1;
                 if (*root_port >= R8A66597_MAX_ROOT_HUB)
-                        err("illegal root port number");
+                        printk(KERN_ERR "r8a66597: Illegal root port number.\n");
         }
         if (hub_port)
                 *hub_port = devpath[2] & 0x0F;
@@ -286,7 +286,7 @@ static u16 get_r8a66597_usb_speed(enum usb_device_speed speed)
                 usbspd = HSMODE;
                 break;
         default:
-                err("unknown speed");
+                printk(KERN_ERR "r8a66597: unknown speed\n");
                 break;
         }
 
@@ -385,7 +385,7 @@ static u8 alloc_usb_address(struct r8a66597 *r8a66597, struct urb *urb)
         struct r8a66597_device *dev;
 
         if (is_hub_limit(urb->dev->devpath)) {
-                err("Externel hub limit reached.");
+                dev_err(&urb->dev->dev, "External hub limit reached.\n");
                 return 0;
         }
 
@@ -406,8 +406,9 @@ static u8 alloc_usb_address(struct r8a66597 *r8a66597, struct urb *urb)
                 return addr;
         }
 
-        err("cannot communicate with a USB device more than 10.(%x)",
-            r8a66597->address_map);
+        dev_err(&urb->dev->dev,
+                "cannot communicate with a USB device more than 10.(%x)\n",
+                r8a66597->address_map);
 
         return 0;
 }
@@ -447,7 +448,8 @@ static void r8a66597_reg_wait(struct r8a66597 *r8a66597, unsigned long reg,
         do {
                 tmp = r8a66597_read(r8a66597, reg);
                 if (i++ > 1000000) {
-                        err("register%lx, loop %x is timeout", reg, loop);
+                        printk(KERN_ERR "r8a66597: register%lx, loop %x "
+                               "is timeout\n", reg, loop);
                         break;
                 }
                 ndelay(1);
@@ -675,7 +677,7 @@ static u16 get_empty_pipenum(struct r8a66597 *r8a66597,
                         array[i++] = 1;
                 break;
         default:
-                err("Illegal type");
+                printk(KERN_ERR "r8a66597: Illegal type\n");
                 return 0;
         }
 
@@ -705,7 +707,7 @@ static u16 get_r8a66597_type(__u8 type)
                 r8a66597_type = R8A66597_ISO;
                 break;
         default:
-                err("Illegal type");
+                printk(KERN_ERR "r8a66597: Illegal type\n");
                 r8a66597_type = 0x0000;
                 break;
         }
@@ -724,7 +726,7 @@ static u16 get_bufnum(u16 pipenum)
         else if (check_interrupt(pipenum))
                 bufnum = 4 + (pipenum - 6);
         else
-                err("Illegal pipenum (%d)", pipenum);
+                printk(KERN_ERR "r8a66597: Illegal pipenum (%d)\n", pipenum);
 
         return bufnum;
 }
@@ -740,7 +742,7 @@ static u16 get_buf_bsize(u16 pipenum)
         else if (check_interrupt(pipenum))
                 buf_bsize = 0;
         else
-                err("Illegal pipenum (%d)", pipenum);
+                printk(KERN_ERR "r8a66597: Illegal pipenum (%d)\n", pipenum);
 
         return buf_bsize;
 }
@@ -760,10 +762,12 @@ static void enable_r8a66597_pipe_dma(struct r8a66597 *r8a66597,
                         if ((r8a66597->dma_map & (1 << i)) != 0)
                                 continue;
 
-                        info("address %d, EndpointAddress 0x%02x use DMA FIFO",
-                             usb_pipedevice(urb->pipe),
-                             info->dir_in ? USB_ENDPOINT_DIR_MASK + info->epnum
-                                            : info->epnum);
+                        dev_info(&dev->udev->dev,
+                                 "address %d, EndpointAddress 0x%02x use "
+                                 "DMA FIFO\n", usb_pipedevice(urb->pipe),
+                                 info->dir_in ?
+                                        USB_ENDPOINT_DIR_MASK + info->epnum
+                                        : info->epnum);
 
                         r8a66597->dma_map |= 1 << i;
                         dev->dma_map |= 1 << i;
@@ -1187,7 +1191,7 @@ static int start_transfer(struct r8a66597 *r8a66597, struct r8a66597_td *td)
                 prepare_status_packet(r8a66597, td);
                 break;
         default:
-                err("invalid type.");
+                printk(KERN_ERR "r8a66597: invalid type.\n");
                 break;
         }
 
@@ -1295,7 +1299,7 @@ static void packet_read(struct r8a66597 *r8a66597, u16 pipenum)
         if (unlikely((tmp & FRDY) == 0)) {
                 pipe_stop(r8a66597, td->pipe);
                 pipe_irq_disable(r8a66597, pipenum);
-                err("in fifo not ready (%d)", pipenum);
+                printk(KERN_ERR "r8a66597: in fifo not ready (%d)\n", pipenum);
                 finish_request(r8a66597, td, pipenum, td->urb, -EPIPE);
                 return;
         }
@@ -1370,7 +1374,7 @@ static void packet_write(struct r8a66597 *r8a66597, u16 pipenum)
         if (unlikely((tmp & FRDY) == 0)) {
                 pipe_stop(r8a66597, td->pipe);
                 pipe_irq_disable(r8a66597, pipenum);
-                err("out write fifo not ready. (%d)", pipenum);
+                printk(KERN_ERR "r8a66597: out fifo not ready (%d)\n", pipenum);
                 finish_request(r8a66597, td, pipenum, urb, -EPIPE);
                 return;
         }
@@ -2005,7 +2009,7 @@ static struct r8a66597_device *get_r8a66597_device(struct r8a66597 *r8a66597,
                 return dev;
         }
 
-        err("get_r8a66597_device fail.(%d)\n", addr);
+        printk(KERN_ERR "r8a66597: get_r8a66597_device fail.(%d)\n", addr);
         return NULL;
 }
 
@@ -2263,7 +2267,7 @@ static int __init_or_module r8a66597_remove(struct platform_device *pdev)
 #define resource_len(r) (((r)->end - (r)->start) + 1)
 static int __init r8a66597_probe(struct platform_device *pdev)
 {
-        struct resource *res = NULL;
+        struct resource *res = NULL, *ires;
         int irq = -1;
         void __iomem *reg = NULL;
         struct usb_hcd *hcd = NULL;
@@ -2274,7 +2278,7 @@ static int __init r8a66597_probe(struct platform_device *pdev)
 
         if (pdev->dev.dma_mask) {
                 ret = -EINVAL;
-                err("dma not support");
+                dev_err(&pdev->dev, "dma not supported\n");
                 goto clean_up;
         }
 
@@ -2282,21 +2286,25 @@ static int __init r8a66597_probe(struct platform_device *pdev)
                                            (char *)hcd_name);
         if (!res) {
                 ret = -ENODEV;
-                err("platform_get_resource_byname error.");
+                dev_err(&pdev->dev, "platform_get_resource_byname error.\n");
                 goto clean_up;
         }
 
-        irq = platform_get_irq(pdev, 0);
-        if (irq < 0) {
+        ires = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+        if (!ires) {
                 ret = -ENODEV;
-                err("platform_get_irq error.");
+                dev_err(&pdev->dev,
+                        "platform_get_resource IORESOURCE_IRQ error.\n");
                 goto clean_up;
         }
 
+        irq = ires->start;
+        irq_trigger = ires->flags & IRQF_TRIGGER_MASK;
+
         reg = ioremap(res->start, resource_len(res));
         if (reg == NULL) {
                 ret = -ENOMEM;
-                err("ioremap error.");
+                dev_err(&pdev->dev, "ioremap error.\n");
                 goto clean_up;
         }
 
@@ -2304,7 +2312,7 @@ static int __init r8a66597_probe(struct platform_device *pdev)
         hcd = usb_create_hcd(&r8a66597_hc_driver, &pdev->dev, (char *)hcd_name);
         if (!hcd) {
                 ret = -ENOMEM;
-                err("Failed to create hcd");
+                dev_err(&pdev->dev, "Failed to create hcd\n");
                 goto clean_up;
         }
         r8a66597 = hcd_to_r8a66597(hcd);
@@ -2329,13 +2337,33 @@ static int __init r8a66597_probe(struct platform_device *pdev)
         INIT_LIST_HEAD(&r8a66597->child_device);
 
         hcd->rsrc_start = res->start;
-        if (irq_sense == INTL)
-                irq_trigger = IRQF_TRIGGER_LOW;
-        else
-                irq_trigger = IRQF_TRIGGER_FALLING;
+
+        /* irq_sense setting on cmdline takes precedence over resource
+         * settings, so the introduction of irqflags in IRQ resourse
+         * won't disturb existing setups */
+        switch (irq_sense) {
+                case INTL:
+                        irq_trigger = IRQF_TRIGGER_LOW;
+                        break;
+                case 0:
+                        irq_trigger = IRQF_TRIGGER_FALLING;
+                        break;
+                case 0xff:
+                        if (irq_trigger)
+                                irq_sense = (irq_trigger & IRQF_TRIGGER_LOW) ?
+                                            INTL : 0;
+                        else {
+                                irq_sense = INTL;
+                                irq_trigger = IRQF_TRIGGER_LOW;
+                        }
+                        break;
+                default:
+                        dev_err(&pdev->dev, "Unknown irq_sense value.\n");
+        }
+
         ret = usb_add_hcd(hcd, irq, IRQF_DISABLED | irq_trigger);
         if (ret != 0) {
-                err("Failed to add hcd");
+                dev_err(&pdev->dev, "Failed to add hcd\n");
                 goto clean_up;
         }
 
@@ -2364,7 +2392,8 @@ static int __init r8a66597_init(void)
         if (usb_disabled())
                 return -ENODEV;
 
-        info("driver %s, %s", hcd_name, DRIVER_VERSION);
+        printk(KERN_INFO KBUILD_MODNAME ": driver %s, %s\n", hcd_name,
+               DRIVER_VERSION);
         return platform_driver_register(&r8a66597_driver);
 }
 module_init(r8a66597_init);
diff --git a/drivers/usb/host/sl811-hcd.c b/drivers/usb/host/sl811-hcd.c
index 8a74bbb57d08..e106e9d48d4a 100644
--- a/drivers/usb/host/sl811-hcd.c
+++ b/drivers/usb/host/sl811-hcd.c
@@ -1620,22 +1620,26 @@ sl811h_probe(struct platform_device *dev)
 {
         struct usb_hcd          *hcd;
         struct sl811            *sl811;
-        struct resource         *addr, *data;
+        struct resource         *addr, *data, *ires;
         int                     irq;
         void __iomem            *addr_reg;
         void __iomem            *data_reg;
         int                     retval;
         u8                      tmp, ioaddr = 0;
+        unsigned long           irqflags;
 
         /* basic sanity checks first.  board-specific init logic should
          * have initialized these three resources and probably board
          * specific platform_data.  we don't probe for IRQs, and do only
          * minimal sanity checking.
          */
-        irq = platform_get_irq(dev, 0);
-        if (dev->num_resources < 3 || irq < 0)
+        ires = platform_get_resource(dev, IORESOURCE_IRQ, 0);
+        if (dev->num_resources < 3 || !ires)
                 return -ENODEV;
 
+        irq = ires->start;
+        irqflags = ires->flags & IRQF_TRIGGER_MASK;
+
         /* refuse to confuse usbcore */
         if (dev->dev.dma_mask) {
                 DBG("no we won't dma\n");
@@ -1717,8 +1721,11 @@ sl811h_probe(struct platform_device *dev)
          * triggers (e.g. most ARM CPUs).  Initial driver stress testing
          * was on a system with single edge triggering, so most sorts of
          * triggering arrangement should work.
+         *
+         * Use resource IRQ flags if set by platform device setup.
          */
-        retval = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
+        irqflags |= IRQF_SHARED;
+        retval = usb_add_hcd(hcd, irq, IRQF_DISABLED | irqflags);
         if (retval != 0)
                 goto err6;
 
diff --git a/drivers/usb/host/uhci-hcd.c b/drivers/usb/host/uhci-hcd.c
index 3a7bfe7a8874..cf5e4cf7ea42 100644
--- a/drivers/usb/host/uhci-hcd.c
+++ b/drivers/usb/host/uhci-hcd.c
@@ -53,7 +53,6 @@
 /*
  * Version Information
  */
-#define DRIVER_VERSION "v3.0"
 #define DRIVER_AUTHOR "Linus 'Frodo Rabbit' Torvalds, Johannes Erdfelt, \
 Randy Dunlap, Georg Acher, Deti Fliegl, Thomas Sailer, Roman Weissgaerber, \
 Alan Stern"
@@ -951,12 +950,13 @@ static int __init uhci_hcd_init(void)
 {
         int retval = -ENOMEM;
 
-        printk(KERN_INFO DRIVER_DESC " " DRIVER_VERSION "%s\n",
-                        ignore_oc ? ", overcurrent ignored" : "");
-
         if (usb_disabled())
                 return -ENODEV;
 
+        printk(KERN_INFO "uhci_hcd: " DRIVER_DESC "%s\n",
+                        ignore_oc ? ", overcurrent ignored" : "");
+        set_bit(USB_UHCI_LOADED, &usb_hcds_loaded);
+
         if (DEBUG_CONFIGURED) {
                 errbuf = kmalloc(ERRBUF_LEN, GFP_KERNEL);
                 if (!errbuf)
@@ -988,6 +988,7 @@ debug_failed:
 
 errbuf_failed:
 
+        clear_bit(USB_UHCI_LOADED, &usb_hcds_loaded);
         return retval;
 }
 
@@ -997,6 +998,7 @@ static void __exit uhci_hcd_cleanup(void)
         kmem_cache_destroy(uhci_up_cachep);
         debugfs_remove(uhci_debugfs_root);
         kfree(errbuf);
+        clear_bit(USB_UHCI_LOADED, &usb_hcds_loaded);
 }
 
 module_init(uhci_hcd_init);
diff --git a/drivers/usb/host/uhci-q.c b/drivers/usb/host/uhci-q.c
index 1f0c2cf26e5d..5631d89c8730 100644
--- a/drivers/usb/host/uhci-q.c
+++ b/drivers/usb/host/uhci-q.c
@@ -1065,13 +1065,18 @@ static int uhci_submit_interrupt(struct uhci_hcd *uhci, struct urb *urb,
                 }
                 if (exponent < 0)
                         return -EINVAL;
-                qh->period = 1 << exponent;
-                qh->skel = SKEL_INDEX(exponent);
 
-                /* For now, interrupt phase is fixed by the layout
-                 * of the QH lists. */
-                qh->phase = (qh->period / 2) & (MAX_PHASE - 1);
-                ret = uhci_check_bandwidth(uhci, qh);
+                /* If the slot is full, try a lower period */
+                do {
+                        qh->period = 1 << exponent;
+                        qh->skel = SKEL_INDEX(exponent);
+
+                        /* For now, interrupt phase is fixed by the layout
+                         * of the QH lists.
+                         */
+                        qh->phase = (qh->period / 2) & (MAX_PHASE - 1);
+                        ret = uhci_check_bandwidth(uhci, qh);
+                } while (ret != 0 && --exponent >= 0);
                 if (ret)
                         return ret;
         } else if (qh->period > urb->interval)