20 files changed, 473 insertions, 235 deletions

diff --git a/drivers/usb/Kconfig b/drivers/usb/Kconfig
index 8cd999a217b6..48f1781352f1 100644
--- a/drivers/usb/Kconfig
+++ b/drivers/usb/Kconfig
@@ -118,6 +118,8 @@ source "drivers/usb/host/Kconfig"
 
 source "drivers/usb/musb/Kconfig"
 
+source "drivers/usb/renesas_usbhs/Kconfig"
+
 source "drivers/usb/class/Kconfig"
 
 source "drivers/usb/storage/Kconfig"
diff --git a/drivers/usb/atm/ueagle-atm.c b/drivers/usb/atm/ueagle-atm.c
index e71521ce3010..428f36801e06 100644
--- a/drivers/usb/atm/ueagle-atm.c
+++ b/drivers/usb/atm/ueagle-atm.c
@@ -116,14 +116,14 @@ struct uea_cmvs_v1 {
         u32 address;
         u16 offset;
         u32 data;
-} __attribute__ ((packed));
+} __packed;
 
 struct uea_cmvs_v2 {
         u32 group;
         u32 address;
         u32 offset;
         u32 data;
-} __attribute__ ((packed));
+} __packed;
 
 /* information about currently processed cmv */
 struct cmv_dsc_e1 {
@@ -352,7 +352,7 @@ struct block_index {
         __le32 PageAddress;
         __le16 dummy1;
         __le16 PageNumber;
-} __attribute__ ((packed));
+} __packed;
 
 #define E4_IS_BOOT_PAGE(PageSize) ((le32_to_cpu(PageSize)) & 0x80000000)
 #define E4_PAGE_BYTES(PageSize) ((le32_to_cpu(PageSize) & 0x7fffffff) * 4)
@@ -367,7 +367,7 @@ struct l1_code {
         u8 page_number_to_block_index[E4_MAX_PAGE_NUMBER];
         struct block_index page_header[E4_NO_SWAPPAGE_HEADERS];
         u8 code[0];
-} __attribute__ ((packed));
+} __packed;
 
 /* structures describing a block within a DSP page */
 struct block_info_e1 {
@@ -377,7 +377,7 @@ struct block_info_e1 {
         __le16 wOvlOffset;
         __le16 wOvl;            /* overlay */
         __le16 wLast;
-} __attribute__ ((packed));
+} __packed;
 #define E1_BLOCK_INFO_SIZE 12
 
 struct block_info_e4 {
@@ -387,7 +387,7 @@ struct block_info_e4 {
         __be32 dwSize;
         __be32 dwAddress;
         __be16 wReserved;
-} __attribute__ ((packed));
+} __packed;
 #define E4_BLOCK_INFO_SIZE 14
 
 #define UEA_BIHDR 0xabcd
@@ -467,7 +467,7 @@ struct cmv_e1 {
         __le32 dwSymbolicAddress;
         __le16 wOffsetAddress;
         __le32 dwData;
-} __attribute__ ((packed));
+} __packed;
 
 struct cmv_e4 {
         __be16 wGroup;
@@ -475,17 +475,17 @@ struct cmv_e4 {
         __be16 wOffset;
         __be16 wAddress;
         __be32 dwData[6];
-} __attribute__ ((packed));
+} __packed;
 
 /* structures representing swap information */
 struct swap_info_e1 {
         __u8 bSwapPageNo;
         __u8 bOvl;              /* overlay */
-} __attribute__ ((packed));
+} __packed;
 
 struct swap_info_e4 {
         __u8 bSwapPageNo;
-} __attribute__ ((packed));
+} __packed;
 
 /* structures representing interrupt data */
 #define e1_bSwapPageNo  u.e1.s1.swapinfo.bSwapPageNo
@@ -499,23 +499,23 @@ union intr_data_e1 {
         struct {
                 struct swap_info_e1 swapinfo;
                 __le16 wDataSize;
-        } __attribute__ ((packed)) s1;
+        } __packed s1;
         struct {
                 struct cmv_e1 cmv;
                 __le16 wDataSize;
-        } __attribute__ ((packed)) s2;
-} __attribute__ ((packed));
+        } __packed s2;
+} __packed;
 
 union intr_data_e4 {
         struct {
                 struct swap_info_e4 swapinfo;
                 __le16 wDataSize;
-        } __attribute__ ((packed)) s1;
+        } __packed s1;
         struct {
                 struct cmv_e4 cmv;
                 __le16 wDataSize;
-        } __attribute__ ((packed)) s2;
-} __attribute__ ((packed));
+        } __packed s2;
+} __packed;
 
 struct intr_pkt {
         __u8 bType;
@@ -528,15 +528,15 @@ struct intr_pkt {
                 union intr_data_e1 e1;
                 union intr_data_e4 e4;
         } u;
-} __attribute__ ((packed));
+} __packed;
 
 #define E1_INTR_PKT_SIZE 28
 #define E4_INTR_PKT_SIZE 64
 
 static struct usb_driver uea_driver;
 static DEFINE_MUTEX(uea_mutex);
-static const char *chip_name[] = {"ADI930", "Eagle I", "Eagle II", "Eagle III",
-                                                                "Eagle IV"};
+static const char * const chip_name[] = {
+        "ADI930", "Eagle I", "Eagle II", "Eagle III", "Eagle IV"};
 
 static int modem_index;
 static unsigned int debug;
diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig
index b0594d907549..44b6b40aafb4 100644
--- a/drivers/usb/gadget/Kconfig
+++ b/drivers/usb/gadget/Kconfig
@@ -216,9 +216,11 @@ config USB_R8A66597
            dynamically linked module called "r8a66597_udc" and force all
            gadget drivers to also be dynamically linked.
 
-config USB_RENESAS_USBHS
+config USB_RENESAS_USBHS_UDC
         tristate 'Renesas USBHS controller'
         depends on SUPERH || ARCH_SHMOBILE
+        depends on USB_RENESAS_USBHS
+        select USB_GADGET_DUALSPEED
         help
            Renesas USBHS is a discrete USB host and peripheral controller chip
            that supports both full and high speed USB 2.0 data transfers.
diff --git a/drivers/usb/host/ehci-hcd.c b/drivers/usb/host/ehci-hcd.c
index e18862c5b059..2902199fa8ff 100644
--- a/drivers/usb/host/ehci-hcd.c
+++ b/drivers/usb/host/ehci-hcd.c
@@ -90,7 +90,8 @@ static const char	hcd_name [] = "ehci_hcd";
 #define EHCI_IAA_MSECS          10              /* arbitrary */
 #define EHCI_IO_JIFFIES         (HZ/10)         /* io watchdog > irq_thresh */
 #define EHCI_ASYNC_JIFFIES      (HZ/20)         /* async idle timeout */
-#define EHCI_SHRINK_FRAMES      5               /* async qh unlink delay */
+#define EHCI_SHRINK_JIFFIES     (DIV_ROUND_UP(HZ, 200) + 1)
+                                                /* 200-ms async qh unlink delay */
 
 /* Initial IRQ latency:  faster than hw default */
 static int log2_irq_thresh = 0;         // 0 to 6
@@ -148,10 +149,7 @@ timer_action(struct ehci_hcd *ehci, enum ehci_timer_action action)
                         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;
+                        t = EHCI_SHRINK_JIFFIES;
                         break;
                 }
                 mod_timer(&ehci->watchdog, t + jiffies);
@@ -336,6 +334,7 @@ static void ehci_work(struct ehci_hcd *ehci);
 #include "ehci-mem.c"
 #include "ehci-q.c"
 #include "ehci-sched.c"
+#include "ehci-sysfs.c"
 
 /*-------------------------------------------------------------------------*/
 
@@ -520,7 +519,7 @@ static void ehci_stop (struct usb_hcd *hcd)
         ehci_reset (ehci);
         spin_unlock_irq(&ehci->lock);
 
-        remove_companion_file(ehci);
+        remove_sysfs_files(ehci);
         remove_debug_files (ehci);
 
         /* root hub is shut down separately (first, when possible) */
@@ -571,6 +570,12 @@ static int ehci_init(struct usb_hcd *hcd)
         hcc_params = ehci_readl(ehci, &ehci->caps->hcc_params);
 
         /*
+         * by default set standard 80% (== 100 usec/uframe) max periodic
+         * bandwidth as required by USB 2.0
+         */
+        ehci->uframe_periodic_max = 100;
+
+        /*
          * hw default: 1K periodic list heads, one per frame.
          * periodic_size can shrink by USBCMD update if hcc_params allows.
          */
@@ -754,7 +759,7 @@ static int ehci_run (struct usb_hcd *hcd)
          * since the class device isn't created that early.
          */
         create_debug_files(ehci);
-        create_companion_file(ehci);
+        create_sysfs_files(ehci);
 
         return 0;
 }
diff --git a/drivers/usb/host/ehci-hub.c b/drivers/usb/host/ehci-hub.c
index ea6184bf48d0..bf2c8f65e1ae 100644
--- a/drivers/usb/host/ehci-hub.c
+++ b/drivers/usb/host/ehci-hub.c
@@ -471,29 +471,6 @@ static int ehci_bus_resume (struct usb_hcd *hcd)
 
 /*-------------------------------------------------------------------------*/
 
-/* Display the ports dedicated to the companion controller */
-static ssize_t show_companion(struct device *dev,
-                              struct device_attribute *attr,
-                              char *buf)
-{
-        struct ehci_hcd         *ehci;
-        int                     nports, index, n;
-        int                     count = PAGE_SIZE;
-        char                    *ptr = buf;
-
-        ehci = hcd_to_ehci(bus_to_hcd(dev_get_drvdata(dev)));
-        nports = HCS_N_PORTS(ehci->hcs_params);
-
-        for (index = 0; index < nports; ++index) {
-                if (test_bit(index, &ehci->companion_ports)) {
-                        n = scnprintf(ptr, count, "%d\n", index + 1);
-                        ptr += n;
-                        count -= n;
-                }
-        }
-        return ptr - buf;
-}
-
 /*
  * Sets the owner of a port
  */
@@ -528,58 +505,6 @@ static void set_owner(struct ehci_hcd *ehci, int portnum, int new_owner)
         }
 }
 
-/*
- * Dedicate or undedicate a port to the companion controller.
- * Syntax is "[-]portnum", where a leading '-' sign means
- * return control of the port to the EHCI controller.
- */
-static ssize_t store_companion(struct device *dev,
-                               struct device_attribute *attr,
-                               const char *buf, size_t count)
-{
-        struct ehci_hcd         *ehci;
-        int                     portnum, new_owner;
-
-        ehci = hcd_to_ehci(bus_to_hcd(dev_get_drvdata(dev)));
-        new_owner = PORT_OWNER;         /* Owned by companion */
-        if (sscanf(buf, "%d", &portnum) != 1)
-                return -EINVAL;
-        if (portnum < 0) {
-                portnum = - portnum;
-                new_owner = 0;          /* Owned by EHCI */
-        }
-        if (portnum <= 0 || portnum > HCS_N_PORTS(ehci->hcs_params))
-                return -ENOENT;
-        portnum--;
-        if (new_owner)
-                set_bit(portnum, &ehci->companion_ports);
-        else
-                clear_bit(portnum, &ehci->companion_ports);
-        set_owner(ehci, portnum, new_owner);
-        return count;
-}
-static DEVICE_ATTR(companion, 0644, show_companion, store_companion);
-
-static inline int create_companion_file(struct ehci_hcd *ehci)
-{
-        int     i = 0;
-
-        /* with integrated TT there is no companion! */
-        if (!ehci_is_TDI(ehci))
-                i = device_create_file(ehci_to_hcd(ehci)->self.controller,
-                                       &dev_attr_companion);
-        return i;
-}
-
-static inline void remove_companion_file(struct ehci_hcd *ehci)
-{
-        /* with integrated TT there is no companion! */
-        if (!ehci_is_TDI(ehci))
-                device_remove_file(ehci_to_hcd(ehci)->self.controller,
-                                   &dev_attr_companion);
-}
-
-
 /*-------------------------------------------------------------------------*/
 
 static int check_reset_complete (
@@ -891,10 +816,11 @@ static int ehci_hub_control (
                          * power switching; they're allowed to just limit the
                          * current.  khubd will turn the power back on.
                          */
-                        if (HCS_PPC (ehci->hcs_params)){
+                        if ((temp & PORT_OC) && HCS_PPC(ehci->hcs_params)) {
                                 ehci_writel(ehci,
                                         temp & ~(PORT_RWC_BITS | PORT_POWER),
                                         status_reg);
+                                temp = ehci_readl(ehci, status_reg);
                         }
                 }
 
diff --git a/drivers/usb/host/ehci-msm.c b/drivers/usb/host/ehci-msm.c
index b5a0bf649c95..592d5f76803e 100644
--- a/drivers/usb/host/ehci-msm.c
+++ b/drivers/usb/host/ehci-msm.c
@@ -40,27 +40,9 @@ static int ehci_msm_reset(struct usb_hcd *hcd)
         int retval;
 
         ehci->caps = USB_CAPLENGTH;
-        ehci->regs = USB_CAPLENGTH +
-                HC_LENGTH(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
-        dbg_hcs_params(ehci, "reset");
-        dbg_hcc_params(ehci, "reset");
-
-        /* cache the data to minimize the chip reads*/
-        ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
-
         hcd->has_tt = 1;
-        ehci->sbrn = HCD_USB2;
-
-        retval = ehci_halt(ehci);
-        if (retval)
-                return retval;
-
-        /* data structure init */
-        retval = ehci_init(hcd);
-        if (retval)
-                return retval;
 
-        retval = ehci_reset(ehci);
+        retval = ehci_setup(hcd);
         if (retval)
                 return retval;
 
diff --git a/drivers/usb/host/ehci-q.c b/drivers/usb/host/ehci-q.c
index 5d6bc624c961..9bf3c0d983c4 100644
--- a/drivers/usb/host/ehci-q.c
+++ b/drivers/usb/host/ehci-q.c
@@ -1231,6 +1231,8 @@ static void start_unlink_async (struct ehci_hcd *ehci, struct ehci_qh *qh)
 
         prev->hw->hw_next = qh->hw->hw_next;
         prev->qh_next = qh->qh_next;
+        if (ehci->qh_scan_next == qh)
+                ehci->qh_scan_next = qh->qh_next.qh;
         wmb ();
 
         /* If the controller isn't running, we don't have to wait for it */
@@ -1256,53 +1258,49 @@ static void scan_async (struct ehci_hcd *ehci)
         struct ehci_qh          *qh;
         enum ehci_timer_action  action = TIMER_IO_WATCHDOG;
 
-        ehci->stamp = ehci_readl(ehci, &ehci->regs->frame_index);
         timer_action_done (ehci, TIMER_ASYNC_SHRINK);
-rescan:
         stopped = !HC_IS_RUNNING(ehci_to_hcd(ehci)->state);
-        qh = ehci->async->qh_next.qh;
-        if (likely (qh != NULL)) {
-                do {
-                        /* clean any finished work for this qh */
-                        if (!list_empty(&qh->qtd_list) && (stopped ||
-                                        qh->stamp != ehci->stamp)) {
-                                int temp;
-
-                                /* unlinks could happen here; completion
-                                 * reporting drops the lock.  rescan using
-                                 * the latest schedule, but don't rescan
-                                 * qhs we already finished (no looping)
-                                 * unless the controller is stopped.
-                                 */
-                                qh = qh_get (qh);
-                                qh->stamp = ehci->stamp;
-                                temp = qh_completions (ehci, qh);
-                                if (qh->needs_rescan)
-                                        unlink_async(ehci, qh);
-                                qh_put (qh);
-                                if (temp != 0) {
-                                        goto rescan;
-                                }
-                        }
 
-                        /* unlink idle entries, reducing DMA usage as well
-                         * as HCD schedule-scanning costs.  delay for any qh
-                         * we just scanned, there's a not-unusual case that it
-                         * doesn't stay idle for long.
-                         * (plus, avoids some kind of re-activation race.)
+        ehci->qh_scan_next = ehci->async->qh_next.qh;
+        while (ehci->qh_scan_next) {
+                qh = ehci->qh_scan_next;
+                ehci->qh_scan_next = qh->qh_next.qh;
+ rescan:
+                /* clean any finished work for this qh */
+                if (!list_empty(&qh->qtd_list)) {
+                        int temp;
+
+                        /*
+                         * Unlinks could happen here; completion reporting
+                         * drops the lock.  That's why ehci->qh_scan_next
+                         * always holds the next qh to scan; if the next qh
+                         * gets unlinked then ehci->qh_scan_next is adjusted
+                         * in start_unlink_async().
                          */
-                        if (list_empty(&qh->qtd_list)
-                                        && qh->qh_state == QH_STATE_LINKED) {
-                                if (!ehci->reclaim && (stopped ||
-                                        ((ehci->stamp - qh->stamp) & 0x1fff)
-                                                >= EHCI_SHRINK_FRAMES * 8))
-                                        start_unlink_async(ehci, qh);
-                                else
-                                        action = TIMER_ASYNC_SHRINK;
-                        }
+                        qh = qh_get(qh);
+                        temp = qh_completions(ehci, qh);
+                        if (qh->needs_rescan)
+                                unlink_async(ehci, qh);
+                        qh->unlink_time = jiffies + EHCI_SHRINK_JIFFIES;
+                        qh_put(qh);
+                        if (temp != 0)
+                                goto rescan;
+                }
 
-                        qh = qh->qh_next.qh;
-                } while (qh);
+                /* unlink idle entries, reducing DMA usage as well
+                 * as HCD schedule-scanning costs.  delay for any qh
+                 * we just scanned, there's a not-unusual case that it
+                 * doesn't stay idle for long.
+                 * (plus, avoids some kind of re-activation race.)
+                 */
+                if (list_empty(&qh->qtd_list)
+                                && qh->qh_state == QH_STATE_LINKED) {
+                        if (!ehci->reclaim && (stopped ||
+                                        time_after_eq(jiffies, qh->unlink_time)))
+                                start_unlink_async(ehci, qh);
+                        else
+                                action = TIMER_ASYNC_SHRINK;
+                }
         }
         if (action == TIMER_ASYNC_SHRINK)
                 timer_action (ehci, TIMER_ASYNC_SHRINK);
diff --git a/drivers/usb/host/ehci-sched.c b/drivers/usb/host/ehci-sched.c
index 6c9fbe352f73..2abf8543f083 100644
--- a/drivers/usb/host/ehci-sched.c
+++ b/drivers/usb/host/ehci-sched.c
@@ -172,7 +172,7 @@ periodic_usecs (struct ehci_hcd *ehci, unsigned frame, unsigned uframe)
                 }
         }
 #ifdef  DEBUG
-        if (usecs > 100)
+        if (usecs > ehci->uframe_periodic_max)
                 ehci_err (ehci, "uframe %d sched overrun: %d usecs\n",
                         frame * 8 + uframe, usecs);
 #endif
@@ -709,11 +709,8 @@ static int check_period (
         if (uframe >= 8)
                 return 0;
 
-        /*
-         * 80% periodic == 100 usec/uframe available
-         * convert "usecs we need" to "max already claimed"
-         */
-        usecs = 100 - usecs;
+        /* convert "usecs we need" to "max already claimed" */
+        usecs = ehci->uframe_periodic_max - usecs;
 
         /* we "know" 2 and 4 uframe intervals were rejected; so
          * for period 0, check _every_ microframe in the schedule.
@@ -1286,9 +1283,9 @@ itd_slot_ok (
 {
         uframe %= period;
         do {
-                /* can't commit more than 80% periodic == 100 usec */
+                /* can't commit more than uframe_periodic_max usec */
                 if (periodic_usecs (ehci, uframe >> 3, uframe & 0x7)
-                                > (100 - usecs))
+                                > (ehci->uframe_periodic_max - usecs))
                         return 0;
 
                 /* we know urb->interval is 2^N uframes */
@@ -1345,7 +1342,7 @@ sitd_slot_ok (
 #endif
 
                 /* check starts (OUT uses more than one) */
-                max_used = 100 - stream->usecs;
+                max_used = ehci->uframe_periodic_max - stream->usecs;
                 for (tmp = stream->raw_mask & 0xff; tmp; tmp >>= 1, uf++) {
                         if (periodic_usecs (ehci, frame, uf) > max_used)
                                 return 0;
@@ -1354,7 +1351,7 @@ sitd_slot_ok (
                 /* for IN, check CSPLIT */
                 if (stream->c_usecs) {
                         uf = uframe & 7;
-                        max_used = 100 - stream->c_usecs;
+                        max_used = ehci->uframe_periodic_max - stream->c_usecs;
                         do {
                                 tmp = 1 << uf;
                                 tmp <<= 8;
diff --git a/drivers/usb/host/ehci-sysfs.c b/drivers/usb/host/ehci-sysfs.c
new file mode 100644
index 000000000000..14ced00ba220
--- /dev/null
+++ b/drivers/usb/host/ehci-sysfs.c
@@ -0,0 +1,190 @@
+/*
+ * Copyright (C) 2007 by Alan Stern
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/* this file is part of ehci-hcd.c */
+
+
+/* Display the ports dedicated to the companion controller */
+static ssize_t show_companion(struct device *dev,
+                              struct device_attribute *attr,
+                              char *buf)
+{
+        struct ehci_hcd         *ehci;
+        int                     nports, index, n;
+        int                     count = PAGE_SIZE;
+        char                    *ptr = buf;
+
+        ehci = hcd_to_ehci(bus_to_hcd(dev_get_drvdata(dev)));
+        nports = HCS_N_PORTS(ehci->hcs_params);
+
+        for (index = 0; index < nports; ++index) {
+                if (test_bit(index, &ehci->companion_ports)) {
+                        n = scnprintf(ptr, count, "%d\n", index + 1);
+                        ptr += n;
+                        count -= n;
+                }
+        }
+        return ptr - buf;
+}
+
+/*
+ * Dedicate or undedicate a port to the companion controller.
+ * Syntax is "[-]portnum", where a leading '-' sign means
+ * return control of the port to the EHCI controller.
+ */
+static ssize_t store_companion(struct device *dev,
+                               struct device_attribute *attr,
+                               const char *buf, size_t count)
+{
+        struct ehci_hcd         *ehci;
+        int                     portnum, new_owner;
+
+        ehci = hcd_to_ehci(bus_to_hcd(dev_get_drvdata(dev)));
+        new_owner = PORT_OWNER;         /* Owned by companion */
+        if (sscanf(buf, "%d", &portnum) != 1)
+                return -EINVAL;
+        if (portnum < 0) {
+                portnum = - portnum;
+                new_owner = 0;          /* Owned by EHCI */
+        }
+        if (portnum <= 0 || portnum > HCS_N_PORTS(ehci->hcs_params))
+                return -ENOENT;
+        portnum--;
+        if (new_owner)
+                set_bit(portnum, &ehci->companion_ports);
+        else
+                clear_bit(portnum, &ehci->companion_ports);
+        set_owner(ehci, portnum, new_owner);
+        return count;
+}
+static DEVICE_ATTR(companion, 0644, show_companion, store_companion);
+
+
+/*
+ * Display / Set uframe_periodic_max
+ */
+static ssize_t show_uframe_periodic_max(struct device *dev,
+                                        struct device_attribute *attr,
+                                        char *buf)
+{
+        struct ehci_hcd         *ehci;
+        int                     n;
+
+        ehci = hcd_to_ehci(bus_to_hcd(dev_get_drvdata(dev)));
+        n = scnprintf(buf, PAGE_SIZE, "%d\n", ehci->uframe_periodic_max);
+        return n;
+}
+
+
+static ssize_t store_uframe_periodic_max(struct device *dev,
+                                        struct device_attribute *attr,
+                                        const char *buf, size_t count)
+{
+        struct ehci_hcd         *ehci;
+        unsigned                uframe_periodic_max;
+        unsigned                frame, uframe;
+        unsigned short          allocated_max;
+        unsigned long           flags;
+        ssize_t                 ret;
+
+        ehci = hcd_to_ehci(bus_to_hcd(dev_get_drvdata(dev)));
+        if (kstrtouint(buf, 0, &uframe_periodic_max) < 0)
+                return -EINVAL;
+
+        if (uframe_periodic_max < 100 || uframe_periodic_max >= 125) {
+                ehci_info(ehci, "rejecting invalid request for "
+                                "uframe_periodic_max=%u\n", uframe_periodic_max);
+                return -EINVAL;
+        }
+
+        ret = -EINVAL;
+
+        /*
+         * lock, so that our checking does not race with possible periodic
+         * bandwidth allocation through submitting new urbs.
+         */
+        spin_lock_irqsave (&ehci->lock, flags);
+
+        /*
+         * for request to decrease max periodic bandwidth, we have to check
+         * every microframe in the schedule to see whether the decrease is
+         * possible.
+         */
+        if (uframe_periodic_max < ehci->uframe_periodic_max) {
+                allocated_max = 0;
+
+                for (frame = 0; frame < ehci->periodic_size; ++frame)
+                        for (uframe = 0; uframe < 7; ++uframe)
+                                allocated_max = max(allocated_max,
+                                                    periodic_usecs (ehci, frame, uframe));
+
+                if (allocated_max > uframe_periodic_max) {
+                        ehci_info(ehci,
+                                "cannot decrease uframe_periodic_max becase "
+                                "periodic bandwidth is already allocated "
+                                "(%u > %u)\n",
+                                allocated_max, uframe_periodic_max);
+                        goto out_unlock;
+                }
+        }
+
+        /* increasing is always ok */
+
+        ehci_info(ehci, "setting max periodic bandwidth to %u%% "
+                        "(== %u usec/uframe)\n",
+                        100*uframe_periodic_max/125, uframe_periodic_max);
+
+        if (uframe_periodic_max != 100)
+                ehci_warn(ehci, "max periodic bandwidth set is non-standard\n");
+
+        ehci->uframe_periodic_max = uframe_periodic_max;
+        ret = count;
+
+out_unlock:
+        spin_unlock_irqrestore (&ehci->lock, flags);
+        return ret;
+}
+static DEVICE_ATTR(uframe_periodic_max, 0644, show_uframe_periodic_max, store_uframe_periodic_max);
+
+
+static inline int create_sysfs_files(struct ehci_hcd *ehci)
+{
+        struct device   *controller = ehci_to_hcd(ehci)->self.controller;
+        int     i = 0;
+
+        /* with integrated TT there is no companion! */
+        if (!ehci_is_TDI(ehci))
+                i = device_create_file(controller, &dev_attr_companion);
+        if (i)
+                goto out;
+
+        i = device_create_file(controller, &dev_attr_uframe_periodic_max);
+out:
+        return i;
+}
+
+static inline void remove_sysfs_files(struct ehci_hcd *ehci)
+{
+        struct device   *controller = ehci_to_hcd(ehci)->self.controller;
+
+        /* with integrated TT there is no companion! */
+        if (!ehci_is_TDI(ehci))
+                device_remove_file(controller, &dev_attr_companion);
+
+        device_remove_file(controller, &dev_attr_uframe_periodic_max);
+}
diff --git a/drivers/usb/host/ehci.h b/drivers/usb/host/ehci.h
index bd6ff489baf9..e4feec3457fb 100644
--- a/drivers/usb/host/ehci.h
+++ b/drivers/usb/host/ehci.h
@@ -75,6 +75,7 @@ struct ehci_hcd {			/* one per controller */
         struct ehci_qh          *async;
         struct ehci_qh          *dummy;         /* For AMD quirk use */
         struct ehci_qh          *reclaim;
+        struct ehci_qh          *qh_scan_next;
         unsigned                scanning : 1;
 
         /* periodic schedule support */
@@ -87,6 +88,8 @@ struct ehci_hcd {			/* one per controller */
         union ehci_shadow       *pshadow;       /* mirror hw periodic table */
         int                     next_uframe;    /* scan periodic, start here */
         unsigned                periodic_sched; /* periodic activity count */
+        unsigned                uframe_periodic_max; /* max periodic time per uframe */
+
 
         /* list of itds & sitds completed while clock_frame was still active */
         struct list_head        cached_itd_list;
@@ -117,7 +120,6 @@ struct ehci_hcd {			/* one per controller */
         struct timer_list       iaa_watchdog;
         struct timer_list       watchdog;
         unsigned long           actions;
-        unsigned                stamp;
         unsigned                periodic_stamp;
         unsigned                random_frame;
         unsigned long           next_statechange;
@@ -343,6 +345,7 @@ struct ehci_qh {
         struct ehci_qh          *reclaim;       /* next to reclaim */
 
         struct ehci_hcd         *ehci;
+        unsigned long           unlink_time;
 
         /*
          * Do NOT use atomic operations for QH refcounting. On some CPUs
diff --git a/drivers/usb/host/ohci-sh.c b/drivers/usb/host/ohci-sh.c
index f47867ff78c7..14cecb52a9fe 100644
--- a/drivers/usb/host/ohci-sh.c
+++ b/drivers/usb/host/ohci-sh.c
@@ -3,7 +3,7 @@
  *
  * Copyright (C) 2008 Renesas Solutions Corp.
  *
- * Author : Yoshihiro Shimoda <shimoda.yoshihiro@renesas.com>
+ * Author : Yoshihiro Shimoda <yoshihiro.shimoda.uh@renesas.com>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
diff --git a/drivers/usb/host/pci-quirks.c b/drivers/usb/host/pci-quirks.c
index fd930618c28f..b5a7304fcbef 100644
--- a/drivers/usb/host/pci-quirks.c
+++ b/drivers/usb/host/pci-quirks.c
@@ -507,20 +507,34 @@ static void __devinit quirk_usb_handoff_ohci(struct pci_dev *pdev)
         iounmap(base);
 }
 
+static const struct dmi_system_id __initconst ehci_dmi_nohandoff_table[] = {
+        {
+                /*  Pegatron Lucid (ExoPC) */
+                .matches = {
+                        DMI_MATCH(DMI_BOARD_NAME, "EXOPG06411"),
+                        DMI_MATCH(DMI_BIOS_VERSION, "Lucid-CE-133"),
+                },
+        },
+        {
+                /*  Pegatron Lucid (Ordissimo AIRIS) */
+                .matches = {
+                        DMI_MATCH(DMI_BOARD_NAME, "M11JB"),
+                        DMI_MATCH(DMI_BIOS_VERSION, "Lucid-GE-133"),
+                },
+        },
+        { }
+};
+
 static void __devinit ehci_bios_handoff(struct pci_dev *pdev,
                                         void __iomem *op_reg_base,
                                         u32 cap, u8 offset)
 {
         int try_handoff = 1, tried_handoff = 0;
 
-        /* The Pegatron Lucid (ExoPC) tablet sporadically waits for 90
-         * seconds trying the handoff on its unused controller.  Skip
-         * it. */
+        /* The Pegatron Lucid tablet sporadically waits for 98 seconds trying
+         * the handoff on its unused controller.  Skip it. */
         if (pdev->vendor == 0x8086 && pdev->device == 0x283a) {
-                const char *dmi_bn = dmi_get_system_info(DMI_BOARD_NAME);
-                const char *dmi_bv = dmi_get_system_info(DMI_BIOS_VERSION);
-                if (dmi_bn && !strcmp(dmi_bn, "EXOPG06411") &&
-                    dmi_bv && !strcmp(dmi_bv, "Lucid-CE-133"))
+                if (dmi_check_system(ehci_dmi_nohandoff_table))
                         try_handoff = 0;
         }
 
diff --git a/drivers/usb/host/r8a66597-hcd.c b/drivers/usb/host/r8a66597-hcd.c
index db6f8b9c19b6..fd35901861c3 100644
--- a/drivers/usb/host/r8a66597-hcd.c
+++ b/drivers/usb/host/r8a66597-hcd.c
@@ -6,7 +6,7 @@
  * Portions Copyright (C) 2004-2005 David Brownell
  * Portions Copyright (C) 1999 Roman Weissgaerber
  *
- * Author : Yoshihiro Shimoda <shimoda.yoshihiro@renesas.com>
+ * Author : Yoshihiro Shimoda <yoshihiro.shimoda.uh@renesas.com>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -1438,7 +1438,7 @@ static void packet_write(struct r8a66597 *r8a66597, u16 pipenum)
         if (pipenum > 0)
                 r8a66597_write(r8a66597, ~(1 << pipenum), BEMPSTS);
         if (urb->transfer_buffer) {
-                r8a66597_write_fifo(r8a66597, td->pipe->fifoaddr, buf, size);
+                r8a66597_write_fifo(r8a66597, td->pipe, buf, size);
                 if (!usb_pipebulk(urb->pipe) || td->maxpacket != size)
                         r8a66597_write(r8a66597, BVAL, td->pipe->fifoctr);
         }
@@ -2306,7 +2306,7 @@ static int r8a66597_bus_resume(struct usb_hcd *hcd)
 
                 dbg("resume port = %d", port);
                 rh->port &= ~USB_PORT_STAT_SUSPEND;
-                rh->port |= USB_PORT_STAT_C_SUSPEND < 16;
+                rh->port |= USB_PORT_STAT_C_SUSPEND << 16;
                 r8a66597_mdfy(r8a66597, RESUME, RESUME | UACT, dvstctr_reg);
                 msleep(50);
                 r8a66597_mdfy(r8a66597, UACT, RESUME | UACT, dvstctr_reg);
diff --git a/drivers/usb/host/r8a66597.h b/drivers/usb/host/r8a66597.h
index 25563e9a90bc..f28782d20eef 100644
--- a/drivers/usb/host/r8a66597.h
+++ b/drivers/usb/host/r8a66597.h
@@ -201,11 +201,26 @@ static inline void r8a66597_write(struct r8a66597 *r8a66597, u16 val,
         iowrite16(val, r8a66597->reg + offset);
 }
 
+static inline void r8a66597_mdfy(struct r8a66597 *r8a66597,
+                                 u16 val, u16 pat, unsigned long offset)
+{
+        u16 tmp;
+        tmp = r8a66597_read(r8a66597, offset);
+        tmp = tmp & (~pat);
+        tmp = tmp | val;
+        r8a66597_write(r8a66597, tmp, offset);
+}
+
+#define r8a66597_bclr(r8a66597, val, offset)    \
+                        r8a66597_mdfy(r8a66597, 0, val, offset)
+#define r8a66597_bset(r8a66597, val, offset)    \
+                        r8a66597_mdfy(r8a66597, val, 0, offset)
+
 static inline void r8a66597_write_fifo(struct r8a66597 *r8a66597,
-                                       unsigned long offset, u16 *buf,
+                                       struct r8a66597_pipe *pipe, u16 *buf,
                                        int len)
 {
-        void __iomem *fifoaddr = r8a66597->reg + offset;
+        void __iomem *fifoaddr = r8a66597->reg + pipe->fifoaddr;
         unsigned long count;
         unsigned char *pb;
         int i;
@@ -230,26 +245,15 @@ static inline void r8a66597_write_fifo(struct r8a66597 *r8a66597,
                 iowrite16_rep(fifoaddr, buf, len);
                 if (unlikely(odd)) {
                         buf = &buf[len];
+                        if (r8a66597->pdata->wr0_shorted_to_wr1)
+                                r8a66597_bclr(r8a66597, MBW_16, pipe->fifosel);
                         iowrite8((unsigned char)*buf, fifoaddr);
+                        if (r8a66597->pdata->wr0_shorted_to_wr1)
+                                r8a66597_bset(r8a66597, MBW_16, pipe->fifosel);
                 }
         }
 }
 
-static inline void r8a66597_mdfy(struct r8a66597 *r8a66597,
-                                 u16 val, u16 pat, unsigned long offset)
-{
-        u16 tmp;
-        tmp = r8a66597_read(r8a66597, offset);
-        tmp = tmp & (~pat);
-        tmp = tmp | val;
-        r8a66597_write(r8a66597, tmp, offset);
-}
-
-#define r8a66597_bclr(r8a66597, val, offset)    \
-                        r8a66597_mdfy(r8a66597, 0, val, offset)
-#define r8a66597_bset(r8a66597, val, offset)    \
-                        r8a66597_mdfy(r8a66597, val, 0, offset)
-
 static inline unsigned long get_syscfg_reg(int port)
 {
         return port == 0 ? SYSCFG0 : SYSCFG1;
diff --git a/drivers/usb/mon/mon_text.c b/drivers/usb/mon/mon_text.c
index c302e1983c70..1c3afcc11bd9 100644
--- a/drivers/usb/mon/mon_text.c
+++ b/drivers/usb/mon/mon_text.c
@@ -670,6 +670,9 @@ int mon_text_add(struct mon_bus *mbus, const struct usb_bus *ubus)
         int busnum = ubus? ubus->busnum: 0;
         int rc;
 
+        if (mon_dir == NULL)
+                return 0;
+
         if (ubus != NULL) {
                 rc = snprintf(name, NAMESZ, "%dt", busnum);
                 if (rc <= 0 || rc >= NAMESZ)
@@ -740,12 +743,12 @@ int __init mon_text_init(void)
 
         mondir = debugfs_create_dir("usbmon", usb_debug_root);
         if (IS_ERR(mondir)) {
-                printk(KERN_NOTICE TAG ": debugfs is not available\n");
-                return -ENODEV;
+                /* debugfs not available, but we can use usbmon without it */
+                return 0;
         }
         if (mondir == NULL) {
                 printk(KERN_NOTICE TAG ": unable to create usbmon directory\n");
-                return -ENODEV;
+                return -ENOMEM;
         }
         mon_dir = mondir;
         return 0;
diff --git a/drivers/usb/renesas_usbhs/Kconfig b/drivers/usb/renesas_usbhs/Kconfig
new file mode 100644
index 000000000000..286cbf1ca7de
--- /dev/null
+++ b/drivers/usb/renesas_usbhs/Kconfig
@@ -0,0 +1,15 @@
+#
+# Renesas USBHS Controller Drivers
+#
+
+config USB_RENESAS_USBHS
+        tristate 'Renesas USBHS controller'
+        depends on SUPERH || ARCH_SHMOBILE
+        default n
+        help
+          Renesas USBHS is a discrete USB host and peripheral controller chip
+          that supports both full and high speed USB 2.0 data transfers.
+          It has nine or more configurable endpoints, and endpoint zero.
+
+          Say "y" to link the driver statically, or "m" to build a
+          dynamically linked module called "renesas_usbhs"
diff --git a/drivers/usb/renesas_usbhs/common.c b/drivers/usb/renesas_usbhs/common.c
index 665259aec871..d8239e5efa66 100644
--- a/drivers/usb/renesas_usbhs/common.c
+++ b/drivers/usb/renesas_usbhs/common.c
@@ -21,6 +21,29 @@
 #include <linux/sysfs.h>
 #include "./common.h"
 
+/*
+ *              image of renesas_usbhs
+ *
+ * ex) gadget case
+
+ * mod.c
+ * mod_gadget.c
+ * mod_host.c           pipe.c          fifo.c
+ *
+ *                      +-------+       +-----------+
+ *                      | pipe0 |------>| fifo pio  |
+ * +------------+       +-------+       +-----------+
+ * | mod_gadget |=====> | pipe1 |--+
+ * +------------+       +-------+  |    +-----------+
+ *                      | pipe2 |  |  +-| fifo dma0 |
+ * +------------+       +-------+  |  | +-----------+
+ * | mod_host   |       | pipe3 |<-|--+
+ * +------------+       +-------+  |    +-----------+
+ *                      | ....  |  +--->| fifo dma1 |
+ *                      | ....  |       +-----------+
+ */
+
+
 #define USBHSF_RUNTIME_PWCTRL   (1 << 0)
 
 /* status */
diff --git a/drivers/usb/renesas_usbhs/fifo.c b/drivers/usb/renesas_usbhs/fifo.c
index 021695de1e9e..406893e4422b 100644
--- a/drivers/usb/renesas_usbhs/fifo.c
+++ b/drivers/usb/renesas_usbhs/fifo.c
@@ -26,7 +26,16 @@
 #define usbhsf_fifo_is_busy(f)  ((f)->pipe) /* see usbhs_pipe_select_fifo */
 
 /*
- *              packet info function
+ *              packet initialize
+ */
+void usbhs_pkt_init(struct usbhs_pkt *pkt)
+{
+        pkt->dma = DMA_ADDR_INVALID;
+        INIT_LIST_HEAD(&pkt->node);
+}
+
+/*
+ *              packet control function
  */
 static int usbhsf_null_handle(struct usbhs_pkt *pkt, int *is_done)
 {
@@ -43,12 +52,6 @@ static struct usbhs_pkt_handle usbhsf_null_handler = {
         .try_run = usbhsf_null_handle,
 };
 
-void usbhs_pkt_init(struct usbhs_pkt *pkt)
-{
-        pkt->dma = DMA_ADDR_INVALID;
-        INIT_LIST_HEAD(&pkt->node);
-}
-
 void usbhs_pkt_push(struct usbhs_pipe *pipe, struct usbhs_pkt *pkt,
                     struct usbhs_pkt_handle *handler,
                     void *buf, int len, int zero)
@@ -293,7 +296,7 @@ static int usbhsf_fifo_select(struct usbhs_pipe *pipe,
 }
 
 /*
- *              PIO fifo functions
+ *              PIO push handler
  */
 static int usbhsf_pio_try_push(struct usbhs_pkt *pkt, int *is_done)
 {
@@ -313,8 +316,11 @@ static int usbhsf_pio_try_push(struct usbhs_pkt *pkt, int *is_done)
                 return 0;
 
         ret = usbhs_pipe_is_accessible(pipe);
-        if (ret < 0)
+        if (ret < 0) {
+                /* inaccessible pipe is not an error */
+                ret = 0;
                 goto usbhs_fifo_write_busy;
+        }
 
         ret = usbhsf_fifo_barrier(priv, fifo);
         if (ret < 0)
@@ -395,6 +401,9 @@ struct usbhs_pkt_handle usbhs_fifo_pio_push_handler = {
         .try_run = usbhsf_pio_try_push,
 };
 
+/*
+ *              PIO pop handler
+ */
 static int usbhsf_prepare_pop(struct usbhs_pkt *pkt, int *is_done)
 {
         struct usbhs_pipe *pipe = pkt->pipe;
@@ -497,7 +506,7 @@ struct usbhs_pkt_handle usbhs_fifo_pio_pop_handler = {
 };
 
 /*
- *              handler function
+ *              DCP ctrol statge handler
  */
 static int usbhsf_ctrl_stage_end(struct usbhs_pkt *pkt, int *is_done)
 {
@@ -614,6 +623,9 @@ static void usbhsf_dma_prepare_tasklet(unsigned long data)
         dma_async_issue_pending(chan);
 }
 
+/*
+ *              DMA push handler
+ */
 static int usbhsf_dma_prepare_push(struct usbhs_pkt *pkt, int *is_done)
 {
         struct usbhs_pipe *pipe = pkt->pipe;
@@ -633,6 +645,9 @@ static int usbhsf_dma_prepare_push(struct usbhs_pkt *pkt, int *is_done)
         if (len % 4) /* 32bit alignment */
                 goto usbhsf_pio_prepare_push;
 
+        if (((u32)pkt->buf + pkt->actual) & 0x7) /* 8byte alignment */
+                goto usbhsf_pio_prepare_push;
+
         /* get enable DMA fifo */
         fifo = usbhsf_get_dma_fifo(priv, pkt);
         if (!fifo)
@@ -686,6 +701,9 @@ struct usbhs_pkt_handle usbhs_fifo_dma_push_handler = {
         .dma_done       = usbhsf_dma_push_done,
 };
 
+/*
+ *              DMA pop handler
+ */
 static int usbhsf_dma_try_pop(struct usbhs_pkt *pkt, int *is_done)
 {
         struct usbhs_pipe *pipe = pkt->pipe;
@@ -704,6 +722,9 @@ static int usbhsf_dma_try_pop(struct usbhs_pkt *pkt, int *is_done)
         if (!fifo)
                 goto usbhsf_pio_prepare_pop;
 
+        if (((u32)pkt->buf + pkt->actual) & 0x7) /* 8byte alignment */
+                goto usbhsf_pio_prepare_pop;
+
         ret = usbhsf_fifo_select(pipe, fifo, 0);
         if (ret < 0)
                 goto usbhsf_pio_prepare_pop;
diff --git a/drivers/usb/renesas_usbhs/mod_gadget.c b/drivers/usb/renesas_usbhs/mod_gadget.c
index 9a8e2e9141b2..ba79dbf5adbc 100644
--- a/drivers/usb/renesas_usbhs/mod_gadget.c
+++ b/drivers/usb/renesas_usbhs/mod_gadget.c
@@ -44,6 +44,7 @@ struct usbhsg_uep {
 struct usbhsg_gpriv {
         struct usb_gadget        gadget;
         struct usbhs_mod         mod;
+        struct list_head         link;
 
         struct usbhsg_uep       *uep;
         int                      uep_size;
@@ -113,8 +114,18 @@ struct usbhsg_recip_handle {
 #define usbhsg_status_clr(gp, b) (gp->status &= ~b)
 #define usbhsg_status_has(gp, b) (gp->status &   b)
 
+/* controller */
+LIST_HEAD(the_controller_link);
+
+#define usbhsg_for_each_controller(gpriv)\
+        list_for_each_entry(gpriv, &the_controller_link, link)
+#define usbhsg_controller_register(gpriv)\
+        list_add_tail(&(gpriv)->link, &the_controller_link)
+#define usbhsg_controller_unregister(gpriv)\
+        list_del_init(&(gpriv)->link)
+
 /*
- *              list push/pop
+ *              queue push/pop
  */
 static void usbhsg_queue_push(struct usbhsg_uep *uep,
                               struct usbhsg_request *ureq)
@@ -160,6 +171,9 @@ static void usbhsg_queue_done(struct usbhs_pkt *pkt)
         usbhsg_queue_pop(uep, ureq, 0);
 }
 
+/*
+ *              dma map/unmap
+ */
 static int usbhsg_dma_map(struct device *dev,
                           struct usbhs_pkt *pkt,
                           enum dma_data_direction dir)
@@ -473,6 +487,11 @@ static int usbhsg_ep_enable(struct usb_ep *ep,
                 uep->pipe               = pipe;
                 pipe->mod_private       = uep;
 
+                /*
+                 * usbhs_fifo_dma_push/pop_handler try to
+                 * use dmaengine if possible.
+                 * It will use pio handler if impossible.
+                 */
                 if (usb_endpoint_dir_in(desc))
                         uep->handler = &usbhs_fifo_dma_push_handler;
                 else
@@ -724,11 +743,10 @@ static int usbhsg_try_stop(struct usbhs_priv *priv, u32 status)
  *              linux usb function
  *
  */
-struct usbhsg_gpriv *the_controller;
 static int usbhsg_gadget_start(struct usb_gadget_driver *driver,
                             int (*bind)(struct usb_gadget *))
 {
-        struct usbhsg_gpriv *gpriv = the_controller;
+        struct usbhsg_gpriv *gpriv;
         struct usbhs_priv *priv;
         struct device *dev;
         int ret;
@@ -738,10 +756,17 @@ static int usbhsg_gadget_start(struct usb_gadget_driver *driver,
             !driver->setup      ||
             driver->speed != USB_SPEED_HIGH)
                 return -EINVAL;
-        if (!gpriv)
-                return -ENODEV;
-        if (gpriv->driver)
-                return -EBUSY;
+
+        /*
+         * find unused controller
+         */
+        usbhsg_for_each_controller(gpriv) {
+                if (!gpriv->driver)
+                        goto find_unused_controller;
+        }
+        return -ENODEV;
+
+find_unused_controller:
 
         dev  = usbhsg_gpriv_to_dev(gpriv);
         priv = usbhsg_gpriv_to_priv(gpriv);
@@ -778,18 +803,25 @@ add_fail:
 
 static int usbhsg_gadget_stop(struct usb_gadget_driver *driver)
 {
-        struct usbhsg_gpriv *gpriv = the_controller;
+        struct usbhsg_gpriv *gpriv;
         struct usbhs_priv *priv;
-        struct device *dev = usbhsg_gpriv_to_dev(gpriv);
-
-        if (!gpriv)
-                return -ENODEV;
+        struct device *dev;
 
         if (!driver             ||
-            !driver->unbind     ||
-            driver != gpriv->driver)
+            !driver->unbind)
                 return -EINVAL;
 
+        /*
+         * find controller
+         */
+        usbhsg_for_each_controller(gpriv) {
+                if (gpriv->driver == driver)
+                        goto find_matching_controller;
+        }
+        return -ENODEV;
+
+find_matching_controller:
+
         dev  = usbhsg_gpriv_to_dev(gpriv);
         priv = usbhsg_gpriv_to_priv(gpriv);
 
@@ -911,7 +943,7 @@ int __devinit usbhs_mod_gadget_probe(struct usbhs_priv *priv)
                 }
         }
 
-        the_controller = gpriv;
+        usbhsg_controller_register(gpriv);
 
         ret = usb_add_gadget_udc(dev, &gpriv->gadget);
         if (ret)
@@ -935,6 +967,9 @@ void __devexit usbhs_mod_gadget_remove(struct usbhs_priv *priv)
         struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
 
         usb_del_gadget_udc(&gpriv->gadget);
+
+        usbhsg_controller_unregister(gpriv);
+
         kfree(gpriv->uep);
         kfree(gpriv);
 }
diff --git a/drivers/usb/serial/pl2303.c b/drivers/usb/serial/pl2303.c
index 30461fcc2206..ee28115aa9b4 100644
--- a/drivers/usb/serial/pl2303.c
+++ b/drivers/usb/serial/pl2303.c
@@ -342,10 +342,28 @@ static void pl2303_set_termios(struct tty_struct *tty,
                                 baud = 6000000;
                 }
                 dbg("%s - baud set = %d", __func__, baud);
-                buf[0] = baud & 0xff;
-                buf[1] = (baud >> 8) & 0xff;
-                buf[2] = (baud >> 16) & 0xff;
-                buf[3] = (baud >> 24) & 0xff;
+                if (baud <= 115200) {
+                        buf[0] = baud & 0xff;
+                        buf[1] = (baud >> 8) & 0xff;
+                        buf[2] = (baud >> 16) & 0xff;
+                        buf[3] = (baud >> 24) & 0xff;
+                } else {
+                        /* apparently the formula for higher speeds is:
+                         * baudrate = 12M * 32 / (2^buf[1]) / buf[0]
+                         */
+                        unsigned tmp = 12*1000*1000*32 / baud;
+                        buf[3] = 0x80;
+                        buf[2] = 0;
+                        buf[1] = (tmp >= 256);
+                        while (tmp >= 256) {
+                                tmp >>= 2;
+                                buf[1] <<= 1;
+                        }
+                        if (tmp > 256) {
+                                tmp %= 256;
+                        }
+                        buf[0] = tmp;
+                }
         }
 
         /* For reference buf[4]=0 is 1 stop bits */