371 files changed, 48833 insertions, 13624 deletions

diff --git a/drivers/usb/Kconfig b/drivers/usb/Kconfig
index 4aa00e6e57ad..48f1781352f1 100644
--- a/drivers/usb/Kconfig
+++ b/drivers/usb/Kconfig
@@ -31,7 +31,6 @@ config USB_ARCH_HAS_OHCI
         # ARM:
         default y if SA1111
         default y if ARCH_OMAP
-        default y if ARCH_LH7A404
         default y if ARCH_S3C2410
         default y if PXA27x
         default y if PXA3xx
@@ -41,17 +40,14 @@ config USB_ARCH_HAS_OHCI
         default y if MFD_TC6393XB
         default y if ARCH_W90X900
         default y if ARCH_DAVINCI_DA8XX
+        default y if ARCH_CNS3XXX
+        default y if PLAT_SPEAR
         # PPC:
         default y if STB03xxx
         default y if PPC_MPC52xx
         # MIPS:
         default y if MIPS_ALCHEMY
         default y if MACH_JZ4740
-        # SH:
-        default y if CPU_SUBTYPE_SH7720
-        default y if CPU_SUBTYPE_SH7721
-        default y if CPU_SUBTYPE_SH7763
-        default y if CPU_SUBTYPE_SH7786
         # more:
         default PCI
 
@@ -59,12 +55,20 @@ config USB_ARCH_HAS_OHCI
 config USB_ARCH_HAS_EHCI
         boolean
         default y if PPC_83xx
+        default y if PPC_MPC512x
         default y if SOC_AU1200
         default y if ARCH_IXP4XX
         default y if ARCH_W90X900
         default y if ARCH_AT91SAM9G45
         default y if ARCH_MXC
         default y if ARCH_OMAP3
+        default y if ARCH_CNS3XXX
+        default y if ARCH_VT8500
+        default y if PLAT_SPEAR
+        default y if PLAT_S5P
+        default y if ARCH_MSM
+        default y if MICROBLAZE
+        default y if SPARC_LEON
         default PCI
 
 # ARM SA1111 chips have a non-PCI based "OHCI-compatible" USB host interface.
@@ -114,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/Makefile b/drivers/usb/Makefile
index 239f050efa35..30ddf8dc4f72 100644
--- a/drivers/usb/Makefile
+++ b/drivers/usb/Makefile
@@ -22,6 +22,7 @@ obj-$(CONFIG_USB_R8A66597_HCD)	+= host/
 obj-$(CONFIG_USB_HWA_HCD)       += host/
 obj-$(CONFIG_USB_ISP1760_HCD)   += host/
 obj-$(CONFIG_USB_IMX21_HCD)     += host/
+obj-$(CONFIG_USB_FSL_MPH_DR_OF) += host/
 
 obj-$(CONFIG_USB_C67X00_HCD)    += c67x00/
 
@@ -45,3 +46,8 @@ obj-$(CONFIG_EARLY_PRINTK_DBGP)	+= early/
 
 obj-$(CONFIG_USB_ATM)           += atm/
 obj-$(CONFIG_USB_SPEEDTOUCH)    += atm/
+
+obj-$(CONFIG_USB_MUSB_HDRC)     += musb/
+obj-$(CONFIG_USB_RENESAS_USBHS) += renesas_usbhs/
+obj-$(CONFIG_USB_OTG_UTILS)     += otg/
+obj-$(CONFIG_USB_GADGET)        += gadget/
diff --git a/drivers/usb/atm/Makefile b/drivers/usb/atm/Makefile
index 4c4a776ab1cd..a5d792ec3ad5 100644
--- a/drivers/usb/atm/Makefile
+++ b/drivers/usb/atm/Makefile
@@ -2,12 +2,10 @@
 # Makefile for USB ATM/xDSL drivers
 #
 
+ccflags-$(CONFIG_USB_DEBUG) := -DDEBUG
+
 obj-$(CONFIG_USB_CXACRU)        += cxacru.o
 obj-$(CONFIG_USB_SPEEDTOUCH)    += speedtch.o
 obj-$(CONFIG_USB_UEAGLEATM)     += ueagle-atm.o
 obj-$(CONFIG_USB_ATM)           += usbatm.o
 obj-$(CONFIG_USB_XUSBATM)       += xusbatm.o
-
-ifeq ($(CONFIG_USB_DEBUG),y)
-EXTRA_CFLAGS += -DDEBUG
-endif
diff --git a/drivers/usb/atm/cxacru.c b/drivers/usb/atm/cxacru.c
index 5af23cc5ea9f..a845f8b8382f 100644
--- a/drivers/usb/atm/cxacru.c
+++ b/drivers/usb/atm/cxacru.c
@@ -1247,7 +1247,7 @@ static void cxacru_unbind(struct usbatm_data *usbatm_instance,
         mutex_unlock(&instance->poll_state_serialize);
 
         if (is_polling)
-                cancel_rearming_delayed_work(&instance->poll_work);
+                cancel_delayed_work_sync(&instance->poll_work);
 
         usb_kill_urb(instance->snd_urb);
         usb_kill_urb(instance->rcv_urb);
@@ -1344,8 +1344,24 @@ static struct usbatm_driver cxacru_driver = {
         .tx_padding     = 11,
 };
 
-static int cxacru_usb_probe(struct usb_interface *intf, const struct usb_device_id *id)
+static int cxacru_usb_probe(struct usb_interface *intf,
+                const struct usb_device_id *id)
 {
+        struct usb_device *usb_dev = interface_to_usbdev(intf);
+        char buf[15];
+
+        /* Avoid ADSL routers (cx82310_eth).
+         * Abort if bDeviceClass is 0xff and iProduct is "USB NET CARD".
+         */
+        if (usb_dev->descriptor.bDeviceClass == USB_CLASS_VENDOR_SPEC
+                        && usb_string(usb_dev, usb_dev->descriptor.iProduct,
+                                buf, sizeof(buf)) > 0) {
+                if (!strcmp(buf, "USB NET CARD")) {
+                        dev_info(&intf->dev, "ignoring cx82310_eth device\n");
+                        return -ENODEV;
+                }
+        }
+
         return usbatm_usb_probe(intf, id, &cxacru_driver);
 }
 
diff --git a/drivers/usb/atm/speedtch.c b/drivers/usb/atm/speedtch.c
index 4716e707de59..0842cfbf60cf 100644
--- a/drivers/usb/atm/speedtch.c
+++ b/drivers/usb/atm/speedtch.c
@@ -139,7 +139,8 @@ struct speedtch_instance_data {
 
         struct speedtch_params params; /* set in probe, constant afterwards */
 
-        struct delayed_work status_checker;
+        struct timer_list status_check_timer;
+        struct work_struct status_check_work;
 
         unsigned char last_status;
 
@@ -498,7 +499,7 @@ static void speedtch_check_status(struct work_struct *work)
 {
         struct speedtch_instance_data *instance =
                 container_of(work, struct speedtch_instance_data,
-                             status_checker.work);
+                             status_check_work);
         struct usbatm_data *usbatm = instance->usbatm;
         struct atm_dev *atm_dev = usbatm->atm_dev;
         unsigned char *buf = instance->scratch_buffer;
@@ -575,11 +576,11 @@ static void speedtch_status_poll(unsigned long data)
 {
         struct speedtch_instance_data *instance = (void *)data;
 
-        schedule_delayed_work(&instance->status_checker, 0);
+        schedule_work(&instance->status_check_work);
 
         /* The following check is racy, but the race is harmless */
         if (instance->poll_delay < MAX_POLL_DELAY)
-                mod_timer(&instance->status_checker.timer, jiffies + msecs_to_jiffies(instance->poll_delay));
+                mod_timer(&instance->status_check_timer, jiffies + msecs_to_jiffies(instance->poll_delay));
         else
                 atm_warn(instance->usbatm, "Too many failures - disabling line status polling\n");
 }
@@ -595,7 +596,7 @@ static void speedtch_resubmit_int(unsigned long data)
         if (int_urb) {
                 ret = usb_submit_urb(int_urb, GFP_ATOMIC);
                 if (!ret)
-                        schedule_delayed_work(&instance->status_checker, 0);
+                        schedule_work(&instance->status_check_work);
                 else {
                         atm_dbg(instance->usbatm, "%s: usb_submit_urb failed with result %d\n", __func__, ret);
                         mod_timer(&instance->resubmit_timer, jiffies + msecs_to_jiffies(RESUBMIT_DELAY));
@@ -624,7 +625,7 @@ static void speedtch_handle_int(struct urb *int_urb)
         }
 
         if ((count == 6) && !memcmp(up_int, instance->int_data, 6)) {
-                del_timer(&instance->status_checker.timer);
+                del_timer(&instance->status_check_timer);
                 atm_info(usbatm, "DSL line goes up\n");
         } else if ((count == 6) && !memcmp(down_int, instance->int_data, 6)) {
                 atm_info(usbatm, "DSL line goes down\n");
@@ -640,7 +641,7 @@ static void speedtch_handle_int(struct urb *int_urb)
 
         if ((int_urb = instance->int_urb)) {
                 ret = usb_submit_urb(int_urb, GFP_ATOMIC);
-                schedule_delayed_work(&instance->status_checker, 0);
+                schedule_work(&instance->status_check_work);
                 if (ret < 0) {
                         atm_dbg(usbatm, "%s: usb_submit_urb failed with result %d\n", __func__, ret);
                         goto fail;
@@ -686,7 +687,7 @@ static int speedtch_atm_start(struct usbatm_data *usbatm, struct atm_dev *atm_de
         }
 
         /* Start status polling */
-        mod_timer(&instance->status_checker.timer, jiffies + msecs_to_jiffies(1000));
+        mod_timer(&instance->status_check_timer, jiffies + msecs_to_jiffies(1000));
 
         return 0;
 }
@@ -698,7 +699,7 @@ static void speedtch_atm_stop(struct usbatm_data *usbatm, struct atm_dev *atm_de
 
         atm_dbg(usbatm, "%s entered\n", __func__);
 
-        del_timer_sync(&instance->status_checker.timer);
+        del_timer_sync(&instance->status_check_timer);
 
         /*
          * Since resubmit_timer and int_urb can schedule themselves and
@@ -717,7 +718,7 @@ static void speedtch_atm_stop(struct usbatm_data *usbatm, struct atm_dev *atm_de
         del_timer_sync(&instance->resubmit_timer);
         usb_free_urb(int_urb);
 
-        flush_scheduled_work();
+        flush_work_sync(&instance->status_check_work);
 }
 
 static int speedtch_pre_reset(struct usb_interface *intf)
@@ -869,10 +870,11 @@ static int speedtch_bind(struct usbatm_data *usbatm,
 
         usbatm->flags |= (use_isoc ? UDSL_USE_ISOC : 0);
 
-        INIT_DELAYED_WORK(&instance->status_checker, speedtch_check_status);
+        INIT_WORK(&instance->status_check_work, speedtch_check_status);
+        init_timer(&instance->status_check_timer);
 
-        instance->status_checker.timer.function = speedtch_status_poll;
-        instance->status_checker.timer.data = (unsigned long)instance;
+        instance->status_check_timer.function = speedtch_status_poll;
+        instance->status_check_timer.data = (unsigned long)instance;
         instance->last_status = 0xff;
         instance->poll_delay = MIN_POLL_DELAY;
 
diff --git a/drivers/usb/atm/ueagle-atm.c b/drivers/usb/atm/ueagle-atm.c
index ea071a5b6eee..e71521ce3010 100644
--- a/drivers/usb/atm/ueagle-atm.c
+++ b/drivers/usb/atm/ueagle-atm.c
@@ -168,7 +168,6 @@ struct uea_softc {
         union cmv_dsc cmv_dsc;
 
         struct work_struct task;
-        struct workqueue_struct *work_q;
         u16 pageno;
         u16 ovl;
 
@@ -1284,7 +1283,7 @@ static void uea_set_bulk_timeout(struct uea_softc *sc, u32 dsrate)
 
         /* in bulk mode the modem have problem with high rate
          * changing internal timing could improve things, but the
-         * value is misterious.
+         * value is mysterious.
          * ADI930 don't support it (-EPIPE error).
          */
 
@@ -1744,7 +1743,7 @@ static int uea_send_cmvs_e1(struct uea_softc *sc)
                                 goto out;
                 }
         } else {
-                /* This realy should not happen */
+                /* This really should not happen */
                 uea_err(INS_TO_USBDEV(sc), "bad cmvs version %d\n", ver);
                 goto out;
         }
@@ -1799,7 +1798,7 @@ static int uea_send_cmvs_e4(struct uea_softc *sc)
                                 goto out;
                 }
         } else {
-                /* This realy should not happen */
+                /* This really should not happen */
                 uea_err(INS_TO_USBDEV(sc), "bad cmvs version %d\n", ver);
                 goto out;
         }
@@ -1830,7 +1829,7 @@ static int uea_start_reset(struct uea_softc *sc)
 
         /* mask interrupt */
         sc->booting = 1;
-        /* We need to set this here because, a ack timeout could have occured,
+        /* We need to set this here because, a ack timeout could have occurred,
          * but before we start the reboot, the ack occurs and set this to 1.
          * So we will failed to wait Ready CMV.
          */
@@ -1879,7 +1878,7 @@ static int uea_start_reset(struct uea_softc *sc)
         /* start loading DSP */
         sc->pageno = 0;
         sc->ovl = 0;
-        queue_work(sc->work_q, &sc->task);
+        schedule_work(&sc->task);
 
         /* wait for modem ready CMV */
         ret = wait_cmv_ack(sc);
@@ -2091,14 +2090,14 @@ static void uea_schedule_load_page_e1(struct uea_softc *sc,
 {
         sc->pageno = intr->e1_bSwapPageNo;
         sc->ovl = intr->e1_bOvl >> 4 | intr->e1_bOvl << 4;
-        queue_work(sc->work_q, &sc->task);
+        schedule_work(&sc->task);
 }
 
 static void uea_schedule_load_page_e4(struct uea_softc *sc,
                                                 struct intr_pkt *intr)
 {
         sc->pageno = intr->e4_bSwapPageNo;
-        queue_work(sc->work_q, &sc->task);
+        schedule_work(&sc->task);
 }
 
 /*
@@ -2170,13 +2169,6 @@ static int uea_boot(struct uea_softc *sc)
 
         init_waitqueue_head(&sc->sync_q);
 
-        sc->work_q = create_workqueue("ueagle-dsp");
-        if (!sc->work_q) {
-                uea_err(INS_TO_USBDEV(sc), "cannot allocate workqueue\n");
-                uea_leaves(INS_TO_USBDEV(sc));
-                return -ENOMEM;
-        }
-
         if (UEA_CHIP_VERSION(sc) == ADI930)
                 load_XILINX_firmware(sc);
 
@@ -2206,8 +2198,11 @@ static int uea_boot(struct uea_softc *sc)
                 goto err1;
         }
 
-        sc->kthread = kthread_run(uea_kthread, sc, "ueagle-atm");
-        if (sc->kthread == ERR_PTR(-ENOMEM)) {
+        /* Create worker thread, but don't start it here.  Start it after
+         * all usbatm generic initialization is done.
+         */
+        sc->kthread = kthread_create(uea_kthread, sc, "ueagle-atm");
+        if (IS_ERR(sc->kthread)) {
                 uea_err(INS_TO_USBDEV(sc), "failed to create thread\n");
                 goto err2;
         }
@@ -2222,7 +2217,6 @@ err1:
         sc->urb_int = NULL;
         kfree(intr);
 err0:
-        destroy_workqueue(sc->work_q);
         uea_leaves(INS_TO_USBDEV(sc));
         return -ENOMEM;
 }
@@ -2243,8 +2237,8 @@ static void uea_stop(struct uea_softc *sc)
         kfree(sc->urb_int->transfer_buffer);
         usb_free_urb(sc->urb_int);
 
-        /* stop any pending boot process, when no one can schedule work */
-        destroy_workqueue(sc->work_q);
+        /* flush the work item, when no one can schedule it */
+        flush_work_sync(&sc->task);
 
         if (sc->dsp_firm)
                 release_firmware(sc->dsp_firm);
@@ -2301,7 +2295,7 @@ out:
         return ret;
 }
 
-static DEVICE_ATTR(stat_status, S_IWUGO | S_IRUGO, read_status, reboot);
+static DEVICE_ATTR(stat_status, S_IWUSR | S_IRUGO, read_status, reboot);
 
 static ssize_t read_human_status(struct device *dev,
                         struct device_attribute *attr, char *buf)
@@ -2364,8 +2358,7 @@ out:
         return ret;
 }
 
-static DEVICE_ATTR(stat_human_status, S_IWUGO | S_IRUGO,
-                                read_human_status, NULL);
+static DEVICE_ATTR(stat_human_status, S_IRUGO, read_human_status, NULL);
 
 static ssize_t read_delin(struct device *dev, struct device_attribute *attr,
                 char *buf)
@@ -2397,7 +2390,7 @@ out:
         return ret;
 }
 
-static DEVICE_ATTR(stat_delin, S_IWUGO | S_IRUGO, read_delin, NULL);
+static DEVICE_ATTR(stat_delin, S_IRUGO, read_delin, NULL);
 
 #define UEA_ATTR(name, reset)                                   \
                                                                 \
@@ -2625,6 +2618,7 @@ static struct usbatm_driver uea_usbatm_driver = {
 static int uea_probe(struct usb_interface *intf, const struct usb_device_id *id)
 {
         struct usb_device *usb = interface_to_usbdev(intf);
+        int ret;
 
         uea_enters(usb);
         uea_info(usb, "ADSL device founded vid (%#X) pid (%#X) Rev (%#X): %s\n",
@@ -2638,7 +2632,19 @@ static int uea_probe(struct usb_interface *intf, const struct usb_device_id *id)
         if (UEA_IS_PREFIRM(id))
                 return uea_load_firmware(usb, UEA_CHIP_VERSION(id));
 
-        return usbatm_usb_probe(intf, id, &uea_usbatm_driver);
+        ret = usbatm_usb_probe(intf, id, &uea_usbatm_driver);
+        if (ret == 0) {
+                struct usbatm_data *usbatm = usb_get_intfdata(intf);
+                struct uea_softc *sc = usbatm->driver_data;
+
+                /* Ensure carrier is initialized to off as early as possible */
+                UPDATE_ATM_SIGNAL(ATM_PHY_SIG_LOST);
+
+                /* Only start the worker thread when all init is done */
+                wake_up_process(sc->kthread);
+        }
+
+        return ret;
 }
 
 static void uea_disconnect(struct usb_interface *intf)
diff --git a/drivers/usb/atm/usbatm.c b/drivers/usb/atm/usbatm.c
index 05bf5a27b5b0..989e16e4ab5c 100644
--- a/drivers/usb/atm/usbatm.c
+++ b/drivers/usb/atm/usbatm.c
@@ -951,7 +951,9 @@ static int usbatm_atm_init(struct usbatm_data *instance)
          * condition: callbacks we register can be executed at once, before we have
          * initialized the struct atm_dev.  To protect against this, all callbacks
          * abort if atm_dev->dev_data is NULL. */
-        atm_dev = atm_dev_register(instance->driver_name, &usbatm_atm_devops, -1, NULL);
+        atm_dev = atm_dev_register(instance->driver_name,
+                                   &instance->usb_intf->dev, &usbatm_atm_devops,
+                                   -1, NULL);
         if (!atm_dev) {
                 usb_err(instance, "%s: failed to register ATM device!\n", __func__);
                 return -1;
@@ -966,14 +968,6 @@ static int usbatm_atm_init(struct usbatm_data *instance)
         /* temp init ATM device, set to 128kbit */
         atm_dev->link_rate = 128 * 1000 / 424;
 
-        ret = sysfs_create_link(&atm_dev->class_dev.kobj,
-                                &instance->usb_intf->dev.kobj, "device");
-        if (ret) {
-                atm_err(instance, "%s: sysfs_create_link failed: %d\n",
-                                        __func__, ret);
-                goto fail_sysfs;
-        }
-
         if (instance->driver->atm_start && ((ret = instance->driver->atm_start(instance, atm_dev)) < 0)) {
                 atm_err(instance, "%s: atm_start failed: %d!\n", __func__, ret);
                 goto fail;
@@ -992,8 +986,6 @@ static int usbatm_atm_init(struct usbatm_data *instance)
         return 0;
 
  fail:
-        sysfs_remove_link(&atm_dev->class_dev.kobj, "device");
- fail_sysfs:
         instance->atm_dev = NULL;
         atm_dev_deregister(atm_dev); /* usbatm_atm_dev_close will eventually be called */
         return ret;
@@ -1329,7 +1321,6 @@ void usbatm_usb_disconnect(struct usb_interface *intf)
 
         /* ATM finalize */
         if (instance->atm_dev) {
-                sysfs_remove_link(&instance->atm_dev->class_dev.kobj, "device");
                 atm_dev_deregister(instance->atm_dev);
                 instance->atm_dev = NULL;
         }
diff --git a/drivers/usb/c67x00/Makefile b/drivers/usb/c67x00/Makefile
index 868bc41b5980..b1218683c8ec 100644
--- a/drivers/usb/c67x00/Makefile
+++ b/drivers/usb/c67x00/Makefile
@@ -2,8 +2,8 @@
 # Makefile for Cypress C67X00 USB Controller
 #
 
-ccflags-$(CONFIG_USB_DEBUG)             += -DDEBUG
+ccflags-$(CONFIG_USB_DEBUG) := -DDEBUG
 
-obj-$(CONFIG_USB_C67X00_HCD)            += c67x00.o
+obj-$(CONFIG_USB_C67X00_HCD)    += c67x00.o
 
-c67x00-objs := c67x00-drv.o c67x00-ll-hpi.o c67x00-hcd.o c67x00-sched.o
+c67x00-y := c67x00-drv.o c67x00-ll-hpi.o c67x00-hcd.o c67x00-sched.o
diff --git a/drivers/usb/c67x00/c67x00-drv.c b/drivers/usb/c67x00/c67x00-drv.c
index b6d49234e521..62050f7a4f97 100644
--- a/drivers/usb/c67x00/c67x00-drv.c
+++ b/drivers/usb/c67x00/c67x00-drv.c
@@ -27,7 +27,7 @@
  * the link between the common hardware parts and the subdrivers (e.g.
  * interrupt handling).
  *
- * The c67x00 has 2 SIE's (serial interface engine) wich can be configured
+ * The c67x00 has 2 SIE's (serial interface engine) which can be configured
  * to be host, device or OTG (with some limitations, E.G. only SIE1 can be OTG).
  *
  * Depending on the platform configuration, the SIE's are created and
diff --git a/drivers/usb/c67x00/c67x00-hcd.h b/drivers/usb/c67x00/c67x00-hcd.h
index 74e44621e313..e3d493d4d61a 100644
--- a/drivers/usb/c67x00/c67x00-hcd.h
+++ b/drivers/usb/c67x00/c67x00-hcd.h
@@ -34,7 +34,7 @@
 /*
  * The following parameters depend on the CPU speed, bus speed, ...
  * These can be tuned for specific use cases, e.g. if isochronous transfers
- * are very important, bandwith can be sacrificed to guarantee that the
+ * are very important, bandwidth can be sacrificed to guarantee that the
  * 1ms deadline will be met.
  * If bulk transfers are important, the MAX_FRAME_BW can be increased,
  * but some (or many) isochronous deadlines might not be met.
diff --git a/drivers/usb/c67x00/c67x00-sched.c b/drivers/usb/c67x00/c67x00-sched.c
index f6b3c253f3fa..a03fbc15fa9c 100644
--- a/drivers/usb/c67x00/c67x00-sched.c
+++ b/drivers/usb/c67x00/c67x00-sched.c
@@ -907,7 +907,7 @@ static inline int c67x00_end_of_data(struct c67x00_td *td)
 
 /* Remove all td's from the list which come
  * after last_td and are meant for the same pipe.
- * This is used when a short packet has occured */
+ * This is used when a short packet has occurred */
 static inline void c67x00_clear_pipe(struct c67x00_hcd *c67x00,
                                      struct c67x00_td *last_td)
 {
diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c
index bc62fae0680f..dac7676ce21b 100644
--- a/drivers/usb/class/cdc-acm.c
+++ b/drivers/usb/class/cdc-acm.c
@@ -7,35 +7,12 @@
  * Copyright (c) 2000 Vojtech Pavlik    <vojtech@suse.cz>
  * Copyright (c) 2004 Oliver Neukum     <oliver@neukum.name>
  * Copyright (c) 2005 David Kubicek     <dave@awk.cz>
+ * Copyright (c) 2011 Johan Hovold      <jhovold@gmail.com>
  *
  * USB Abstract Control Model driver for USB modems and ISDN adapters
  *
  * Sponsored by SuSE
  *
- * ChangeLog:
- *      v0.9  - thorough cleaning, URBification, almost a rewrite
- *      v0.10 - some more cleanups
- *      v0.11 - fixed flow control, read error doesn't stop reads
- *      v0.12 - added TIOCM ioctls, added break handling, made struct acm
- *              kmalloced
- *      v0.13 - added termios, added hangup
- *      v0.14 - sized down struct acm
- *      v0.15 - fixed flow control again - characters could be lost
- *      v0.16 - added code for modems with swapped data and control interfaces
- *      v0.17 - added new style probing
- *      v0.18 - fixed new style probing for devices with more configurations
- *      v0.19 - fixed CLOCAL handling (thanks to Richard Shih-Ping Chan)
- *      v0.20 - switched to probing on interface (rather than device) class
- *      v0.21 - revert to probing on device for devices with multiple configs
- *      v0.22 - probe only the control interface. if usbcore doesn't choose the
- *              config we want, sysadmin changes bConfigurationValue in sysfs.
- *      v0.23 - use softirq for rx processing, as needed by tty layer
- *      v0.24 - change probe method to evaluate CDC union descriptor
- *      v0.25 - downstream tasks paralelized to maximize throughput
- *      v0.26 - multiple write urbs, writesize increased
- */
-
-/*
  * 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
@@ -74,13 +51,7 @@
 #include "cdc-acm.h"
 
 
-#define ACM_CLOSE_TIMEOUT       15      /* seconds to let writes drain */
-
-/*
- * Version Information
- */
-#define DRIVER_VERSION "v0.26"
-#define DRIVER_AUTHOR "Armin Fuerst, Pavel Machek, Johannes Erdfelt, Vojtech Pavlik, David Kubicek"
+#define DRIVER_AUTHOR "Armin Fuerst, Pavel Machek, Johannes Erdfelt, Vojtech Pavlik, David Kubicek, Johan Hovold"
 #define DRIVER_DESC "USB Abstract Control Model driver for USB modems and ISDN adapters"
 
 static struct usb_driver acm_driver;
@@ -94,12 +65,6 @@ static DEFINE_MUTEX(open_mutex);
 static const struct tty_port_operations acm_port_ops = {
 };
 
-#ifdef VERBOSE_DEBUG
-#define verbose 1
-#else
-#define verbose 0
-#endif
-
 /*
  * Functions for ACM control messages.
  */
@@ -111,8 +76,9 @@ static int acm_ctrl_msg(struct acm *acm, int request, int value,
                 request, USB_RT_ACM, value,
                 acm->control->altsetting[0].desc.bInterfaceNumber,
                 buf, len, 5000);
-        dbg("acm_control_msg: rq: 0x%02x val: %#x len: %#x result: %d",
-                                                request, value, len, retval);
+        dev_dbg(&acm->control->dev,
+                        "%s - rq 0x%02x, val %#x, len %#x, result %d\n",
+                        __func__, request, value, len, retval);
         return retval < 0 ? retval : 0;
 }
 
@@ -192,7 +158,9 @@ static int acm_start_wb(struct acm *acm, struct acm_wb *wb)
 
         rc = usb_submit_urb(wb->urb, GFP_ATOMIC);
         if (rc < 0) {
-                dbg("usb_submit_urb(write bulk) failed: %d", rc);
+                dev_err(&acm->data->dev,
+                        "%s - usb_submit_urb(write bulk) failed: %d\n",
+                        __func__, rc);
                 acm_write_done(acm, wb);
         }
         return rc;
@@ -211,7 +179,8 @@ static int acm_write_start(struct acm *acm, int wbn)
                 return -ENODEV;
         }
 
-        dbg("%s susp_count: %d", __func__, acm->susp_count);
+        dev_vdbg(&acm->data->dev, "%s - susp_count %d\n", __func__,
+                                                        acm->susp_count);
         usb_autopm_get_interface_async(acm->control);
         if (acm->susp_count) {
                 if (!acm->delayed_wb)
@@ -287,21 +256,27 @@ static void acm_ctrl_irq(struct urb *urb)
         case -ENOENT:
         case -ESHUTDOWN:
                 /* this urb is terminated, clean up */
-                dbg("%s - urb shutting down with status: %d", __func__, status);
+                dev_dbg(&acm->control->dev,
+                                "%s - urb shutting down with status: %d\n",
+                                __func__, status);
                 return;
         default:
-                dbg("%s - nonzero urb status received: %d", __func__, status);
+                dev_dbg(&acm->control->dev,
+                                "%s - nonzero urb status received: %d\n",
+                                __func__, status);
                 goto exit;
         }
 
         if (!ACM_READY(acm))
                 goto exit;
 
+        usb_mark_last_busy(acm->dev);
+
         data = (unsigned char *)(dr + 1);
         switch (dr->bNotificationType) {
         case USB_CDC_NOTIFY_NETWORK_CONNECTION:
-                dbg("%s network", dr->wValue ?
-                                        "connected to" : "disconnected from");
+                dev_dbg(&acm->control->dev, "%s - network connection: %d\n",
+                                                        __func__, dr->wValue);
                 break;
 
         case USB_CDC_NOTIFY_SERIAL_STATE:
@@ -311,7 +286,8 @@ static void acm_ctrl_irq(struct urb *urb)
                 if (tty) {
                         if (!acm->clocal &&
                                 (acm->ctrlin & ~newctrl & ACM_CTRL_DCD)) {
-                                dbg("calling hangup");
+                                dev_dbg(&acm->control->dev,
+                                        "%s - calling hangup\n", __func__);
                                 tty_hangup(tty);
                         }
                         tty_kref_put(tty);
@@ -319,7 +295,10 @@ static void acm_ctrl_irq(struct urb *urb)
 
                 acm->ctrlin = newctrl;
 
-                dbg("input control lines: dcd%c dsr%c break%c ring%c framing%c parity%c overrun%c",
+                dev_dbg(&acm->control->dev,
+                        "%s - input control lines: dcd%c dsr%c break%c "
+                        "ring%c framing%c parity%c overrun%c\n",
+                        __func__,
                         acm->ctrlin & ACM_CTRL_DCD ? '+' : '-',
                         acm->ctrlin & ACM_CTRL_DSR ? '+' : '-',
                         acm->ctrlin & ACM_CTRL_BRK ? '+' : '-',
@@ -330,175 +309,107 @@ static void acm_ctrl_irq(struct urb *urb)
                         break;
 
         default:
-                dbg("unknown notification %d received: index %d len %d data0 %d data1 %d",
+                dev_dbg(&acm->control->dev,
+                        "%s - unknown notification %d received: index %d "
+                        "len %d data0 %d data1 %d\n",
+                        __func__,
                         dr->bNotificationType, dr->wIndex,
                         dr->wLength, data[0], data[1]);
                 break;
         }
 exit:
-        usb_mark_last_busy(acm->dev);
         retval = usb_submit_urb(urb, GFP_ATOMIC);
         if (retval)
-                dev_err(&urb->dev->dev, "%s - usb_submit_urb failed with "
-                        "result %d", __func__, retval);
+                dev_err(&acm->control->dev, "%s - usb_submit_urb failed: %d\n",
+                                                        __func__, retval);
 }
 
-/* data interface returns incoming bytes, or we got unthrottled */
-static void acm_read_bulk(struct urb *urb)
+static int acm_submit_read_urb(struct acm *acm, int index, gfp_t mem_flags)
 {
-        struct acm_rb *buf;
-        struct acm_ru *rcv = urb->context;
-        struct acm *acm = rcv->instance;
-        int status = urb->status;
+        int res;
 
-        dbg("Entering acm_read_bulk with status %d", status);
+        if (!test_and_clear_bit(index, &acm->read_urbs_free))
+                return 0;
 
-        if (!ACM_READY(acm)) {
-                dev_dbg(&acm->data->dev, "Aborting, acm not ready");
-                return;
+        dev_vdbg(&acm->data->dev, "%s - urb %d\n", __func__, index);
+
+        res = usb_submit_urb(acm->read_urbs[index], mem_flags);
+        if (res) {
+                if (res != -EPERM) {
+                        dev_err(&acm->data->dev,
+                                        "%s - usb_submit_urb failed: %d\n",
+                                        __func__, res);
+                }
+                set_bit(index, &acm->read_urbs_free);
+                return res;
         }
-        usb_mark_last_busy(acm->dev);
 
-        if (status)
-                dev_dbg(&acm->data->dev, "bulk rx status %d\n", status);
+        return 0;
+}
 
-        buf = rcv->buffer;
-        buf->size = urb->actual_length;
+static int acm_submit_read_urbs(struct acm *acm, gfp_t mem_flags)
+{
+        int res;
+        int i;
 
-        if (likely(status == 0)) {
-                spin_lock(&acm->read_lock);
-                acm->processing++;
-                list_add_tail(&rcv->list, &acm->spare_read_urbs);
-                list_add_tail(&buf->list, &acm->filled_read_bufs);
-                spin_unlock(&acm->read_lock);
-        } else {
-                /* we drop the buffer due to an error */
-                spin_lock(&acm->read_lock);
-                list_add_tail(&rcv->list, &acm->spare_read_urbs);
-                list_add(&buf->list, &acm->spare_read_bufs);
-                spin_unlock(&acm->read_lock);
-                /* nevertheless the tasklet must be kicked unconditionally
-                so the queue cannot dry up */
+        for (i = 0; i < acm->rx_buflimit; ++i) {
+                res = acm_submit_read_urb(acm, i, mem_flags);
+                if (res)
+                        return res;
         }
-        if (likely(!acm->susp_count))
-                tasklet_schedule(&acm->urb_task);
+
+        return 0;
 }
 
-static void acm_rx_tasklet(unsigned long _acm)
+static void acm_process_read_urb(struct acm *acm, struct urb *urb)
 {
-        struct acm *acm = (void *)_acm;
-        struct acm_rb *buf;
         struct tty_struct *tty;
-        struct acm_ru *rcv;
-        unsigned long flags;
-        unsigned char throttled;
-
-        dbg("Entering acm_rx_tasklet");
-
-        if (!ACM_READY(acm)) {
-                dbg("acm_rx_tasklet: ACM not ready");
-                return;
-        }
 
-        spin_lock_irqsave(&acm->throttle_lock, flags);
-        throttled = acm->throttle;
-        spin_unlock_irqrestore(&acm->throttle_lock, flags);
-        if (throttled) {
-                dbg("acm_rx_tasklet: throttled");
+        if (!urb->actual_length)
                 return;
-        }
 
         tty = tty_port_tty_get(&acm->port);
+        if (!tty)
+                return;
 
-next_buffer:
-        spin_lock_irqsave(&acm->read_lock, flags);
-        if (list_empty(&acm->filled_read_bufs)) {
-                spin_unlock_irqrestore(&acm->read_lock, flags);
-                goto urbs;
-        }
-        buf = list_entry(acm->filled_read_bufs.next,
-                         struct acm_rb, list);
-        list_del(&buf->list);
-        spin_unlock_irqrestore(&acm->read_lock, flags);
-
-        dbg("acm_rx_tasklet: procesing buf 0x%p, size = %d", buf, buf->size);
-
-        if (tty) {
-                spin_lock_irqsave(&acm->throttle_lock, flags);
-                throttled = acm->throttle;
-                spin_unlock_irqrestore(&acm->throttle_lock, flags);
-                if (!throttled) {
-                        tty_insert_flip_string(tty, buf->base, buf->size);
-                        tty_flip_buffer_push(tty);
-                } else {
-                        tty_kref_put(tty);
-                        dbg("Throttling noticed");
-                        spin_lock_irqsave(&acm->read_lock, flags);
-                        list_add(&buf->list, &acm->filled_read_bufs);
-                        spin_unlock_irqrestore(&acm->read_lock, flags);
-                        return;
-                }
-        }
-
-        spin_lock_irqsave(&acm->read_lock, flags);
-        list_add(&buf->list, &acm->spare_read_bufs);
-        spin_unlock_irqrestore(&acm->read_lock, flags);
-        goto next_buffer;
+        tty_insert_flip_string(tty, urb->transfer_buffer, urb->actual_length);
+        tty_flip_buffer_push(tty);
 
-urbs:
         tty_kref_put(tty);
+}
 
-        while (!list_empty(&acm->spare_read_bufs)) {
-                spin_lock_irqsave(&acm->read_lock, flags);
-                if (list_empty(&acm->spare_read_urbs)) {
-                        acm->processing = 0;
-                        spin_unlock_irqrestore(&acm->read_lock, flags);
-                        return;
-                }
-                rcv = list_entry(acm->spare_read_urbs.next,
-                                 struct acm_ru, list);
-                list_del(&rcv->list);
-                spin_unlock_irqrestore(&acm->read_lock, flags);
+static void acm_read_bulk_callback(struct urb *urb)
+{
+        struct acm_rb *rb = urb->context;
+        struct acm *acm = rb->instance;
+        unsigned long flags;
 
-                buf = list_entry(acm->spare_read_bufs.next,
-                                 struct acm_rb, list);
-                list_del(&buf->list);
+        dev_vdbg(&acm->data->dev, "%s - urb %d, len %d\n", __func__,
+                                        rb->index, urb->actual_length);
+        set_bit(rb->index, &acm->read_urbs_free);
 
-                rcv->buffer = buf;
+        if (!acm->dev) {
+                dev_dbg(&acm->data->dev, "%s - disconnected\n", __func__);
+                return;
+        }
+        usb_mark_last_busy(acm->dev);
 
-                if (acm->is_int_ep)
-                        usb_fill_int_urb(rcv->urb, acm->dev,
-                                         acm->rx_endpoint,
-                                         buf->base,
-                                         acm->readsize,
-                                         acm_read_bulk, rcv, acm->bInterval);
-                else
-                        usb_fill_bulk_urb(rcv->urb, acm->dev,
-                                          acm->rx_endpoint,
-                                          buf->base,
-                                          acm->readsize,
-                                          acm_read_bulk, rcv);
-                rcv->urb->transfer_dma = buf->dma;
-                rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
-
-                /* This shouldn't kill the driver as unsuccessful URBs are
-                   returned to the free-urbs-pool and resubmited ASAP */
-                spin_lock_irqsave(&acm->read_lock, flags);
-                if (acm->susp_count ||
-                                usb_submit_urb(rcv->urb, GFP_ATOMIC) < 0) {
-                        list_add(&buf->list, &acm->spare_read_bufs);
-                        list_add(&rcv->list, &acm->spare_read_urbs);
-                        acm->processing = 0;
-                        spin_unlock_irqrestore(&acm->read_lock, flags);
-                        return;
-                } else {
-                        spin_unlock_irqrestore(&acm->read_lock, flags);
-                        dbg("acm_rx_tasklet: sending urb 0x%p, rcv 0x%p, buf 0x%p", rcv->urb, rcv, buf);
-                }
+        if (urb->status) {
+                dev_dbg(&acm->data->dev, "%s - non-zero urb status: %d\n",
+                                                        __func__, urb->status);
+                return;
         }
+        acm_process_read_urb(acm, urb);
+
+        /* throttle device if requested by tty */
         spin_lock_irqsave(&acm->read_lock, flags);
-        acm->processing = 0;
-        spin_unlock_irqrestore(&acm->read_lock, flags);
+        acm->throttled = acm->throttle_req;
+        if (!acm->throttled && !acm->susp_count) {
+                spin_unlock_irqrestore(&acm->read_lock, flags);
+                acm_submit_read_urb(acm, rb->index, GFP_ATOMIC);
+        } else {
+                spin_unlock_irqrestore(&acm->read_lock, flags);
+        }
 }
 
 /* data interface wrote those outgoing bytes */
@@ -508,9 +419,9 @@ static void acm_write_bulk(struct urb *urb)
         struct acm *acm = wb->instance;
         unsigned long flags;
 
-        if (verbose || urb->status
-                        || (urb->actual_length != urb->transfer_buffer_length))
-                dev_dbg(&acm->data->dev, "tx %d/%d bytes -- > %d\n",
+        if (urb->status || (urb->actual_length != urb->transfer_buffer_length))
+                dev_vdbg(&acm->data->dev, "%s - len %d/%d, status %d\n",
+                        __func__,
                         urb->actual_length,
                         urb->transfer_buffer_length,
                         urb->status);
@@ -520,8 +431,6 @@ static void acm_write_bulk(struct urb *urb)
         spin_unlock_irqrestore(&acm->write_lock, flags);
         if (ACM_READY(acm))
                 schedule_work(&acm->work);
-        else
-                wake_up_interruptible(&acm->drain_wait);
 }
 
 static void acm_softint(struct work_struct *work)
@@ -529,10 +438,13 @@ static void acm_softint(struct work_struct *work)
         struct acm *acm = container_of(work, struct acm, work);
         struct tty_struct *tty;
 
-        dev_vdbg(&acm->data->dev, "tx work\n");
+        dev_vdbg(&acm->data->dev, "%s\n", __func__);
+
         if (!ACM_READY(acm))
                 return;
         tty = tty_port_tty_get(&acm->port);
+        if (!tty)
+                return;
         tty_wakeup(tty);
         tty_kref_put(tty);
 }
@@ -545,8 +457,6 @@ static int acm_tty_open(struct tty_struct *tty, struct file *filp)
 {
         struct acm *acm;
         int rv = -ENODEV;
-        int i;
-        dbg("Entering acm_tty_open.");
 
         mutex_lock(&open_mutex);
 
@@ -556,6 +466,8 @@ static int acm_tty_open(struct tty_struct *tty, struct file *filp)
         else
                 rv = 0;
 
+        dev_dbg(&acm->control->dev, "%s\n", __func__);
+
         set_bit(TTY_NO_WRITE_SPLIT, &tty->flags);
 
         tty->driver_data = acm;
@@ -575,38 +487,28 @@ static int acm_tty_open(struct tty_struct *tty, struct file *filp)
 
         acm->ctrlurb->dev = acm->dev;
         if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
-                dbg("usb_submit_urb(ctrl irq) failed");
+                dev_err(&acm->control->dev,
+                        "%s - usb_submit_urb(ctrl irq) failed\n", __func__);
                 goto bail_out;
         }
 
         if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS) &&
             (acm->ctrl_caps & USB_CDC_CAP_LINE))
-                goto full_bailout;
+                goto bail_out;
 
         usb_autopm_put_interface(acm->control);
 
-        INIT_LIST_HEAD(&acm->spare_read_urbs);
-        INIT_LIST_HEAD(&acm->spare_read_bufs);
-        INIT_LIST_HEAD(&acm->filled_read_bufs);
-
-        for (i = 0; i < acm->rx_buflimit; i++)
-                list_add(&(acm->ru[i].list), &acm->spare_read_urbs);
-        for (i = 0; i < acm->rx_buflimit; i++)
-                list_add(&(acm->rb[i].list), &acm->spare_read_bufs);
-
-        acm->throttle = 0;
+        if (acm_submit_read_urbs(acm, GFP_KERNEL))
+                goto bail_out;
 
         set_bit(ASYNCB_INITIALIZED, &acm->port.flags);
         rv = tty_port_block_til_ready(&acm->port, tty, filp);
-        tasklet_schedule(&acm->urb_task);
 
         mutex_unlock(&acm->mutex);
 out:
         mutex_unlock(&open_mutex);
         return rv;
 
-full_bailout:
-        usb_kill_urb(acm->ctrlurb);
 bail_out:
         acm->port.count--;
         mutex_unlock(&acm->mutex);
@@ -619,26 +521,24 @@ early_bail:
 
 static void acm_tty_unregister(struct acm *acm)
 {
-        int i, nr;
+        int i;
 
-        nr = acm->rx_buflimit;
         tty_unregister_device(acm_tty_driver, acm->minor);
         usb_put_intf(acm->control);
         acm_table[acm->minor] = NULL;
         usb_free_urb(acm->ctrlurb);
         for (i = 0; i < ACM_NW; i++)
                 usb_free_urb(acm->wb[i].urb);
-        for (i = 0; i < nr; i++)
-                usb_free_urb(acm->ru[i].urb);
+        for (i = 0; i < acm->rx_buflimit; i++)
+                usb_free_urb(acm->read_urbs[i]);
         kfree(acm->country_codes);
         kfree(acm);
 }
 
-static int acm_tty_chars_in_buffer(struct tty_struct *tty);
-
 static void acm_port_down(struct acm *acm)
 {
-        int i, nr = acm->rx_buflimit;
+        int i;
+
         mutex_lock(&open_mutex);
         if (acm->dev) {
                 usb_autopm_get_interface(acm->control);
@@ -646,8 +546,8 @@ static void acm_port_down(struct acm *acm)
                 usb_kill_urb(acm->ctrlurb);
                 for (i = 0; i < ACM_NW; i++)
                         usb_kill_urb(acm->wb[i].urb);
-                for (i = 0; i < nr; i++)
-                        usb_kill_urb(acm->ru[i].urb);
+                for (i = 0; i < acm->rx_buflimit; i++)
+                        usb_kill_urb(acm->read_urbs[i]);
                 acm->control->needs_remote_wakeup = 0;
                 usb_autopm_put_interface(acm->control);
         }
@@ -693,13 +593,13 @@ static int acm_tty_write(struct tty_struct *tty,
         int wbn;
         struct acm_wb *wb;
 
-        dbg("Entering acm_tty_write to write %d bytes,", count);
-
         if (!ACM_READY(acm))
                 return -EINVAL;
         if (!count)
                 return 0;
 
+        dev_vdbg(&acm->data->dev, "%s - count %d\n", __func__, count);
+
         spin_lock_irqsave(&acm->write_lock, flags);
         wbn = acm_wb_alloc(acm);
         if (wbn < 0) {
@@ -709,7 +609,7 @@ static int acm_tty_write(struct tty_struct *tty,
         wb = &acm->wb[wbn];
 
         count = (count > acm->writesize) ? acm->writesize : count;
-        dbg("Get %d bytes...", count);
+        dev_vdbg(&acm->data->dev, "%s - write %d\n", __func__, count);
         memcpy(wb->buf, buf, count);
         wb->len = count;
         spin_unlock_irqrestore(&acm->write_lock, flags);
@@ -746,22 +646,31 @@ static int acm_tty_chars_in_buffer(struct tty_struct *tty)
 static void acm_tty_throttle(struct tty_struct *tty)
 {
         struct acm *acm = tty->driver_data;
+
         if (!ACM_READY(acm))
                 return;
-        spin_lock_bh(&acm->throttle_lock);
-        acm->throttle = 1;
-        spin_unlock_bh(&acm->throttle_lock);
+
+        spin_lock_irq(&acm->read_lock);
+        acm->throttle_req = 1;
+        spin_unlock_irq(&acm->read_lock);
 }
 
 static void acm_tty_unthrottle(struct tty_struct *tty)
 {
         struct acm *acm = tty->driver_data;
+        unsigned int was_throttled;
+
         if (!ACM_READY(acm))
                 return;
-        spin_lock_bh(&acm->throttle_lock);
-        acm->throttle = 0;
-        spin_unlock_bh(&acm->throttle_lock);
-        tasklet_schedule(&acm->urb_task);
+
+        spin_lock_irq(&acm->read_lock);
+        was_throttled = acm->throttled;
+        acm->throttled = 0;
+        acm->throttle_req = 0;
+        spin_unlock_irq(&acm->read_lock);
+
+        if (was_throttled)
+                acm_submit_read_urbs(acm, GFP_KERNEL);
 }
 
 static int acm_tty_break_ctl(struct tty_struct *tty, int state)
@@ -772,11 +681,12 @@ static int acm_tty_break_ctl(struct tty_struct *tty, int state)
                 return -EINVAL;
         retval = acm_send_break(acm, state ? 0xffff : 0);
         if (retval < 0)
-                dbg("send break failed");
+                dev_dbg(&acm->control->dev, "%s - send break failed\n",
+                                                                __func__);
         return retval;
 }
 
-static int acm_tty_tiocmget(struct tty_struct *tty, struct file *file)
+static int acm_tty_tiocmget(struct tty_struct *tty)
 {
         struct acm *acm = tty->driver_data;
 
@@ -791,7 +701,7 @@ static int acm_tty_tiocmget(struct tty_struct *tty, struct file *file)
                TIOCM_CTS;
 }
 
-static int acm_tty_tiocmset(struct tty_struct *tty, struct file *file,
+static int acm_tty_tiocmset(struct tty_struct *tty,
                             unsigned int set, unsigned int clear)
 {
         struct acm *acm = tty->driver_data;
@@ -813,7 +723,7 @@ static int acm_tty_tiocmset(struct tty_struct *tty, struct file *file,
         return acm_set_control(acm, acm->ctrlout = newctrl);
 }
 
-static int acm_tty_ioctl(struct tty_struct *tty, struct file *file,
+static int acm_tty_ioctl(struct tty_struct *tty,
                                         unsigned int cmd, unsigned long arg)
 {
         struct acm *acm = tty->driver_data;
@@ -867,7 +777,9 @@ static void acm_tty_set_termios(struct tty_struct *tty,
 
         if (memcmp(&acm->line, &newline, sizeof newline)) {
                 memcpy(&acm->line, &newline, sizeof newline);
-                dbg("set line: %d %d %d %d", le32_to_cpu(newline.dwDTERate),
+                dev_dbg(&acm->control->dev, "%s - set line: %d %d %d %d\n",
+                        __func__,
+                        le32_to_cpu(newline.dwDTERate),
                         newline.bCharFormat, newline.bParityType,
                         newline.bDataBits);
                 acm_set_line(acm, &acm->line);
@@ -892,11 +804,11 @@ static void acm_write_buffers_free(struct acm *acm)
 static void acm_read_buffers_free(struct acm *acm)
 {
         struct usb_device *usb_dev = interface_to_usbdev(acm->control);
-        int i, n = acm->rx_buflimit;
+        int i;
 
-        for (i = 0; i < n; i++)
+        for (i = 0; i < acm->rx_buflimit; i++)
                 usb_free_coherent(usb_dev, acm->readsize,
-                                  acm->rb[i].base, acm->rb[i].dma);
+                          acm->read_buffers[i].base, acm->read_buffers[i].dma);
 }
 
 /* Little helper: write buffers allocate */
@@ -941,7 +853,7 @@ static int acm_probe(struct usb_interface *intf,
         u8 ac_management_function = 0;
         u8 call_management_function = 0;
         int call_interface_num = -1;
-        int data_interface_num;
+        int data_interface_num = -1;
         unsigned long quirks;
         int num_rx_buf;
         int i;
@@ -1025,7 +937,11 @@ next_desc:
         if (!union_header) {
                 if (call_interface_num > 0) {
                         dev_dbg(&intf->dev, "No union descriptor, using call management descriptor\n");
-                        data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
+                        /* quirks for Droids MuIn LCD */
+                        if (quirks & NO_DATA_INTERFACE)
+                                data_interface = usb_ifnum_to_if(usb_dev, 0);
+                        else
+                                data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
                         control_interface = intf;
                 } else {
                         if (intf->cur_altsetting->desc.bNumEndpoints != 3) {
@@ -1128,7 +1044,7 @@ skip_normal_probe:
                 epwrite = t;
         }
 made_compressed_probe:
-        dbg("interfaces are valid");
+        dev_dbg(&intf->dev, "interfaces are valid\n");
         for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);
 
         if (minor == ACM_TTY_MINORS) {
@@ -1138,7 +1054,7 @@ made_compressed_probe:
 
         acm = kzalloc(sizeof(struct acm), GFP_KERNEL);
         if (acm == NULL) {
-                dev_dbg(&intf->dev, "out of memory (acm kzalloc)\n");
+                dev_err(&intf->dev, "out of memory (acm kzalloc)\n");
                 goto alloc_fail;
         }
 
@@ -1157,11 +1073,7 @@ made_compressed_probe:
         acm->ctrlsize = ctrlsize;
         acm->readsize = readsize;
         acm->rx_buflimit = num_rx_buf;
-        acm->urb_task.func = acm_rx_tasklet;
-        acm->urb_task.data = (unsigned long) acm;
         INIT_WORK(&acm->work, acm_softint);
-        init_waitqueue_head(&acm->drain_wait);
-        spin_lock_init(&acm->throttle_lock);
         spin_lock_init(&acm->write_lock);
         spin_lock_init(&acm->read_lock);
         mutex_init(&acm->mutex);
@@ -1174,53 +1086,69 @@ made_compressed_probe:
 
         buf = usb_alloc_coherent(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
         if (!buf) {
-                dev_dbg(&intf->dev, "out of memory (ctrl buffer alloc)\n");
+                dev_err(&intf->dev, "out of memory (ctrl buffer alloc)\n");
                 goto alloc_fail2;
         }
         acm->ctrl_buffer = buf;
 
         if (acm_write_buffers_alloc(acm) < 0) {
-                dev_dbg(&intf->dev, "out of memory (write buffer alloc)\n");
+                dev_err(&intf->dev, "out of memory (write buffer alloc)\n");
                 goto alloc_fail4;
         }
 
         acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
         if (!acm->ctrlurb) {
-                dev_dbg(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
+                dev_err(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
                 goto alloc_fail5;
         }
         for (i = 0; i < num_rx_buf; i++) {
-                struct acm_ru *rcv = &(acm->ru[i]);
+                struct acm_rb *rb = &(acm->read_buffers[i]);
+                struct urb *urb;
 
-                rcv->urb = usb_alloc_urb(0, GFP_KERNEL);
-                if (rcv->urb == NULL) {
-                        dev_dbg(&intf->dev,
-                                "out of memory (read urbs usb_alloc_urb)\n");
+                rb->base = usb_alloc_coherent(acm->dev, readsize, GFP_KERNEL,
+                                                                &rb->dma);
+                if (!rb->base) {
+                        dev_err(&intf->dev, "out of memory "
+                                        "(read bufs usb_alloc_coherent)\n");
                         goto alloc_fail6;
                 }
+                rb->index = i;
+                rb->instance = acm;
 
-                rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
-                rcv->instance = acm;
-        }
-        for (i = 0; i < num_rx_buf; i++) {
-                struct acm_rb *rb = &(acm->rb[i]);
-
-                rb->base = usb_alloc_coherent(acm->dev, readsize,
-                                GFP_KERNEL, &rb->dma);
-                if (!rb->base) {
-                        dev_dbg(&intf->dev,
-                                "out of memory (read bufs usb_alloc_coherent)\n");
-                        goto alloc_fail7;
+                urb = usb_alloc_urb(0, GFP_KERNEL);
+                if (!urb) {
+                        dev_err(&intf->dev,
+                                "out of memory (read urbs usb_alloc_urb)\n");
+                        goto alloc_fail6;
                 }
+                urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
+                urb->transfer_dma = rb->dma;
+                if (acm->is_int_ep) {
+                        usb_fill_int_urb(urb, acm->dev,
+                                         acm->rx_endpoint,
+                                         rb->base,
+                                         acm->readsize,
+                                         acm_read_bulk_callback, rb,
+                                         acm->bInterval);
+                } else {
+                        usb_fill_bulk_urb(urb, acm->dev,
+                                          acm->rx_endpoint,
+                                          rb->base,
+                                          acm->readsize,
+                                          acm_read_bulk_callback, rb);
+                }
+
+                acm->read_urbs[i] = urb;
+                __set_bit(i, &acm->read_urbs_free);
         }
         for (i = 0; i < ACM_NW; i++) {
                 struct acm_wb *snd = &(acm->wb[i]);
 
                 snd->urb = usb_alloc_urb(0, GFP_KERNEL);
                 if (snd->urb == NULL) {
-                        dev_dbg(&intf->dev,
-                                "out of memory (write urbs usb_alloc_urb)");
-                        goto alloc_fail8;
+                        dev_err(&intf->dev,
+                                "out of memory (write urbs usb_alloc_urb)\n");
+                        goto alloc_fail7;
                 }
 
                 if (usb_endpoint_xfer_int(epwrite))
@@ -1239,7 +1167,7 @@ made_compressed_probe:
 
         i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
         if (i < 0)
-                goto alloc_fail8;
+                goto alloc_fail7;
 
         if (cfd) { /* export the country data */
                 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
@@ -1291,14 +1219,13 @@ skip_countries:
         acm_table[minor] = acm;
 
         return 0;
-alloc_fail8:
+alloc_fail7:
         for (i = 0; i < ACM_NW; i++)
                 usb_free_urb(acm->wb[i].urb);
-alloc_fail7:
-        acm_read_buffers_free(acm);
 alloc_fail6:
         for (i = 0; i < num_rx_buf; i++)
-                usb_free_urb(acm->ru[i].urb);
+                usb_free_urb(acm->read_urbs[i]);
+        acm_read_buffers_free(acm);
         usb_free_urb(acm->ctrlurb);
 alloc_fail5:
         acm_write_buffers_free(acm);
@@ -1313,17 +1240,14 @@ alloc_fail:
 static void stop_data_traffic(struct acm *acm)
 {
         int i;
-        dbg("Entering stop_data_traffic");
 
-        tasklet_disable(&acm->urb_task);
+        dev_dbg(&acm->control->dev, "%s\n", __func__);
 
         usb_kill_urb(acm->ctrlurb);
         for (i = 0; i < ACM_NW; i++)
                 usb_kill_urb(acm->wb[i].urb);
         for (i = 0; i < acm->rx_buflimit; i++)
-                usb_kill_urb(acm->ru[i].urb);
-
-        tasklet_enable(&acm->urb_task);
+                usb_kill_urb(acm->read_urbs[i]);
 
         cancel_work_sync(&acm->work);
 }
@@ -1384,11 +1308,9 @@ static int acm_suspend(struct usb_interface *intf, pm_message_t message)
         if (message.event & PM_EVENT_AUTO) {
                 int b;
 
-                spin_lock_irq(&acm->read_lock);
-                spin_lock(&acm->write_lock);
-                b = acm->processing + acm->transmitting;
-                spin_unlock(&acm->write_lock);
-                spin_unlock_irq(&acm->read_lock);
+                spin_lock_irq(&acm->write_lock);
+                b = acm->transmitting;
+                spin_unlock_irq(&acm->write_lock);
                 if (b)
                         return -EBUSY;
         }
@@ -1450,7 +1372,7 @@ static int acm_resume(struct usb_interface *intf)
                 if (rv < 0)
                         goto err_out;
 
-                tasklet_schedule(&acm->urb_task);
+                rv = acm_submit_read_urbs(acm, GFP_NOIO);
         }
 
 err_out:
@@ -1607,6 +1529,9 @@ static const struct usb_device_id acm_ids[] = {
         { NOKIA_PCSUITE_ACM_INFO(0x0154), }, /* Nokia 5800 XpressMusic */
         { NOKIA_PCSUITE_ACM_INFO(0x04ce), }, /* Nokia E90 */
         { NOKIA_PCSUITE_ACM_INFO(0x01d4), }, /* Nokia E55 */
+        { NOKIA_PCSUITE_ACM_INFO(0x0302), }, /* Nokia N8 */
+        { NOKIA_PCSUITE_ACM_INFO(0x0335), }, /* Nokia E7 */
+        { NOKIA_PCSUITE_ACM_INFO(0x03cd), }, /* Nokia C7 */
         { SAMSUNG_PCSUITE_ACM_INFO(0x6651), }, /* Samsung GTi8510 (INNOV8) */
 
         /* NOTE: non-Nokia COMM/ACM/0xff is likely MSFT RNDIS... NOT a modem! */
@@ -1614,7 +1539,12 @@ static const struct usb_device_id acm_ids[] = {
         /* Support Lego NXT using pbLua firmware */
         { USB_DEVICE(0x0694, 0xff00),
         .driver_info = NOT_A_MODEM,
-        },
+        },
+
+        /* Support for Droids MuIn LCD */
+        { USB_DEVICE(0x04d8, 0x000b),
+        .driver_info = NO_DATA_INTERFACE,
+        },
 
         /* control interfaces without any protocol set */
         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
@@ -1710,8 +1640,7 @@ static int __init acm_init(void)
                 return retval;
         }
 
-        printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
-               DRIVER_DESC "\n");
+        printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
 
         return 0;
 }
diff --git a/drivers/usb/class/cdc-acm.h b/drivers/usb/class/cdc-acm.h
index 5eeb570b9a61..ca7937f26e27 100644
--- a/drivers/usb/class/cdc-acm.h
+++ b/drivers/usb/class/cdc-acm.h
@@ -52,7 +52,7 @@
  */
 
 /*
- * The only reason to have several buffers is to accomodate assumptions
+ * The only reason to have several buffers is to accommodate assumptions
  * in line disciplines. They ask for empty space amount, receive our URB size,
  * and proceed to issue several 1-character writes, assuming they will fit.
  * The very first write takes a complete URB. Fortunately, this only happens
@@ -72,16 +72,10 @@ struct acm_wb {
 };
 
 struct acm_rb {
-        struct list_head        list;
         int                     size;
         unsigned char           *base;
         dma_addr_t              dma;
-};
-
-struct acm_ru {
-        struct list_head        list;
-        struct acm_rb           *buffer;
-        struct urb              *urb;
+        int                     index;
         struct acm              *instance;
 };
 
@@ -97,35 +91,30 @@ struct acm {
         unsigned int country_code_size;                 /* size of this buffer */
         unsigned int country_rel_date;                  /* release date of version */
         struct acm_wb wb[ACM_NW];
-        struct acm_ru ru[ACM_NR];
-        struct acm_rb rb[ACM_NR];
+        unsigned long read_urbs_free;
+        struct urb *read_urbs[ACM_NR];
+        struct acm_rb read_buffers[ACM_NR];
         int rx_buflimit;
         int rx_endpoint;
         spinlock_t read_lock;
-        struct list_head spare_read_urbs;
-        struct list_head spare_read_bufs;
-        struct list_head filled_read_bufs;
         int write_used;                                 /* number of non-empty write buffers */
-        int processing;
         int transmitting;
         spinlock_t write_lock;
         struct mutex mutex;
         struct usb_cdc_line_coding line;                /* bits, stop, parity */
         struct work_struct work;                        /* work queue entry for line discipline waking up */
-        wait_queue_head_t drain_wait;                   /* close processing */
-        struct tasklet_struct urb_task;                 /* rx processing */
-        spinlock_t throttle_lock;                       /* synchronize throtteling and read callback */
         unsigned int ctrlin;                            /* input control lines (DCD, DSR, RI, break, overruns) */
         unsigned int ctrlout;                           /* output control lines (DTR, RTS) */
         unsigned int writesize;                         /* max packet size for the output bulk endpoint */
         unsigned int readsize,ctrlsize;                 /* buffer sizes for freeing */
         unsigned int minor;                             /* acm minor number */
-        unsigned char throttle;                         /* throttled by tty layer */
         unsigned char clocal;                           /* termios CLOCAL */
         unsigned int ctrl_caps;                         /* control capabilities from the class specific header */
         unsigned int susp_count;                        /* number of suspended interfaces */
         unsigned int combined_interfaces:1;             /* control and data collapsed */
         unsigned int is_int_ep:1;                       /* interrupt endpoints contrary to spec used */
+        unsigned int throttled:1;                       /* actually throttled */
+        unsigned int throttle_req:1;                    /* throttle requested */
         u8 bInterval;
         struct acm_wb *delayed_wb;                      /* write queued for a device about to be woken */
 };
@@ -137,3 +126,4 @@ struct acm {
 #define SINGLE_RX_URB                   2
 #define NO_CAP_LINE                     4
 #define NOT_A_MODEM                     8
+#define NO_DATA_INTERFACE               16
diff --git a/drivers/usb/class/cdc-wdm.c b/drivers/usb/class/cdc-wdm.c
index 094c76b5de17..2b9ff518b509 100644
--- a/drivers/usb/class/cdc-wdm.c
+++ b/drivers/usb/class/cdc-wdm.c
@@ -281,7 +281,7 @@ static void cleanup(struct wdm_device *desc)
                           desc->sbuf,
                           desc->validity->transfer_dma);
         usb_free_coherent(interface_to_usbdev(desc->intf),
-                          desc->wMaxCommand,
+                          desc->bMaxPacketSize0,
                           desc->inbuf,
                           desc->response->transfer_dma);
         kfree(desc->orq);
@@ -342,7 +342,7 @@ static ssize_t wdm_write
                 goto outnp;
         }
 
-        if (!file->f_flags && O_NONBLOCK)
+        if (!(file->f_flags & O_NONBLOCK))
                 r = wait_event_interruptible(desc->wait, !test_bit(WDM_IN_USE,
                                                                 &desc->flags));
         else
@@ -542,6 +542,8 @@ static int wdm_open(struct inode *inode, struct file *file)
 
         mutex_lock(&desc->lock);
         if (!desc->count++) {
+                desc->werr = 0;
+                desc->rerr = 0;
                 rv = usb_submit_urb(desc->validity, GFP_KERNEL);
                 if (rv < 0) {
                         desc->count--;
@@ -584,7 +586,8 @@ static const struct file_operations wdm_fops = {
         .open =         wdm_open,
         .flush =        wdm_flush,
         .release =      wdm_release,
-        .poll =         wdm_poll
+        .poll =         wdm_poll,
+        .llseek =       noop_llseek,
 };
 
 static struct usb_class_driver wdm_class = {
@@ -852,6 +855,18 @@ static int wdm_pre_reset(struct usb_interface *intf)
         struct wdm_device *desc = usb_get_intfdata(intf);
 
         mutex_lock(&desc->lock);
+        kill_urbs(desc);
+
+        /*
+         * we notify everybody using poll of
+         * an exceptional situation
+         * must be done before recovery lest a spontaneous
+         * message from the device is lost
+         */
+        spin_lock_irq(&desc->iuspin);
+        desc->rerr = -EINTR;
+        spin_unlock_irq(&desc->iuspin);
+        wake_up_all(&desc->wait);
         return 0;
 }
 
diff --git a/drivers/usb/class/usblp.c b/drivers/usb/class/usblp.c
index e325162859b0..9eca4053312e 100644
--- a/drivers/usb/class/usblp.c
+++ b/drivers/usb/class/usblp.c
@@ -1043,6 +1043,7 @@ static const struct file_operations usblp_fops = {
         .compat_ioctl =         usblp_ioctl,
         .open =         usblp_open,
         .release =      usblp_release,
+        .llseek =       noop_llseek,
 };
 
 static char *usblp_devnode(struct device *dev, mode_t *mode)
diff --git a/drivers/usb/class/usbtmc.c b/drivers/usb/class/usbtmc.c
index 3e7c1b800ebb..385acb895ab3 100644
--- a/drivers/usb/class/usbtmc.c
+++ b/drivers/usb/class/usbtmc.c
@@ -483,7 +483,7 @@ static ssize_t usbtmc_read(struct file *filp, char __user *buf,
                 }
 
                 done += n_characters;
-                /* Terminate if end-of-message bit recieved from device */
+                /* Terminate if end-of-message bit received from device */
                 if ((buffer[8] &  0x01) && (actual >= n_characters + 12))
                         remaining = 0;
                 else
@@ -987,6 +987,7 @@ static const struct file_operations fops = {
         .open           = usbtmc_open,
         .release        = usbtmc_release,
         .unlocked_ioctl = usbtmc_ioctl,
+        .llseek         = default_llseek,
 };
 
 static struct usb_class_driver usbtmc_class = {
diff --git a/drivers/usb/core/Kconfig b/drivers/usb/core/Kconfig
index 9eed5b52d9de..18d02e32a3d5 100644
--- a/drivers/usb/core/Kconfig
+++ b/drivers/usb/core/Kconfig
@@ -107,17 +107,25 @@ config USB_SUSPEND
           If you are unsure about this, say N here.
 
 config USB_OTG
-        bool
+        bool "OTG support"
         depends on USB && EXPERIMENTAL
         depends on USB_SUSPEND
         default n
+        help
+          The most notable feature of USB OTG is support for a
+          "Dual-Role" device, which can act as either a device
+          or a host. The initial role is decided by the type of
+          plug inserted and can be changed later when two dual
+          role devices talk to each other.
 
+          Select this only if your board has Mini-AB/Micro-AB
+          connector.
 
 config USB_OTG_WHITELIST
         bool "Rely on OTG Targeted Peripherals List"
-        depends on USB_OTG || EMBEDDED
+        depends on USB_OTG || EXPERT
         default y if USB_OTG
-        default n if EMBEDDED
+        default n if EXPERT
         help
           If you say Y here, the "otg_whitelist.h" file will be used as a
           product whitelist, so USB peripherals not listed there will be
@@ -133,7 +141,7 @@ config USB_OTG_WHITELIST
 
 config USB_OTG_BLACKLIST_HUB
         bool "Disable external hubs"
-        depends on USB_OTG || EMBEDDED
+        depends on USB_OTG || EXPERT
         help
           If you say Y here, then Linux will refuse to enumerate
           external hubs.  OTG hosts are allowed to reduce hardware
diff --git a/drivers/usb/core/Makefile b/drivers/usb/core/Makefile
index ec16e6029905..507a4e1b6360 100644
--- a/drivers/usb/core/Makefile
+++ b/drivers/usb/core/Makefile
@@ -2,20 +2,13 @@
 # Makefile for USB Core files and filesystem
 #
 
-usbcore-objs    := usb.o hub.o hcd.o urb.o message.o driver.o \
-                        config.o file.o buffer.o sysfs.o endpoint.o \
-                        devio.o notify.o generic.o quirks.o devices.o
+ccflags-$(CONFIG_USB_DEBUG) := -DDEBUG
 
-ifeq ($(CONFIG_PCI),y)
-        usbcore-objs    += hcd-pci.o
-endif
+usbcore-y := usb.o hub.o hcd.o urb.o message.o driver.o
+usbcore-y += config.o file.o buffer.o sysfs.o endpoint.o
+usbcore-y += devio.o notify.o generic.o quirks.o devices.o
 
-ifeq ($(CONFIG_USB_DEVICEFS),y)
-        usbcore-objs    += inode.o
-endif
+usbcore-$(CONFIG_PCI)           += hcd-pci.o
+usbcore-$(CONFIG_USB_DEVICEFS)  += inode.o
 
-obj-$(CONFIG_USB)       += usbcore.o
-
-ifeq ($(CONFIG_USB_DEBUG),y)
-EXTRA_CFLAGS += -DDEBUG
-endif
+obj-$(CONFIG_USB)               += usbcore.o
diff --git a/drivers/usb/core/buffer.c b/drivers/usb/core/buffer.c
index 2c6965484fe8..b0585e623ba9 100644
--- a/drivers/usb/core/buffer.c
+++ b/drivers/usb/core/buffer.c
@@ -10,7 +10,7 @@
 #include <linux/slab.h>
 #include <linux/device.h>
 #include <linux/mm.h>
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/dma-mapping.h>
 #include <linux/dmapool.h>
 #include <linux/usb.h>
@@ -22,7 +22,7 @@
  */
 
 /* FIXME tune these based on pool statistics ... */
-static const size_t     pool_max [HCD_BUFFER_POOLS] = {
+static const size_t     pool_max[HCD_BUFFER_POOLS] = {
         /* platforms without dma-friendly caches might need to
          * prevent cacheline sharing...
          */
@@ -51,7 +51,7 @@ static const size_t	pool_max [HCD_BUFFER_POOLS] = {
 int hcd_buffer_create(struct usb_hcd *hcd)
 {
         char            name[16];
-        int             i, size;
+        int             i, size;
 
         if (!hcd->self.controller->dma_mask &&
             !(hcd->driver->flags & HCD_LOCAL_MEM))
@@ -64,7 +64,7 @@ int hcd_buffer_create(struct usb_hcd *hcd)
                 snprintf(name, sizeof name, "buffer-%d", size);
                 hcd->pool[i] = dma_pool_create(name, hcd->self.controller,
                                 size, size, 0);
-                if (!hcd->pool [i]) {
+                if (!hcd->pool[i]) {
                         hcd_buffer_destroy(hcd);
                         return -ENOMEM;
                 }
@@ -99,14 +99,14 @@ void hcd_buffer_destroy(struct usb_hcd *hcd)
  */
 
 void *hcd_buffer_alloc(
-        struct usb_bus  *bus,
+        struct usb_bus          *bus,
         size_t                  size,
         gfp_t                   mem_flags,
         dma_addr_t              *dma
 )
 {
         struct usb_hcd          *hcd = bus_to_hcd(bus);
-        int                     i;
+        int                     i;
 
         /* some USB hosts just use PIO */
         if (!bus->controller->dma_mask &&
@@ -116,21 +116,21 @@ void *hcd_buffer_alloc(
         }
 
         for (i = 0; i < HCD_BUFFER_POOLS; i++) {
-                if (size <= pool_max [i])
-                        return dma_pool_alloc(hcd->pool [i], mem_flags, dma);
+                if (size <= pool_max[i])
+                        return dma_pool_alloc(hcd->pool[i], mem_flags, dma);
         }
         return dma_alloc_coherent(hcd->self.controller, size, dma, mem_flags);
 }
 
 void hcd_buffer_free(
-        struct usb_bus  *bus,
+        struct usb_bus          *bus,
         size_t                  size,
-        void                    *addr,
+        void                    *addr,
         dma_addr_t              dma
 )
 {
         struct usb_hcd          *hcd = bus_to_hcd(bus);
-        int                     i;
+        int                     i;
 
         if (!addr)
                 return;
@@ -142,8 +142,8 @@ void hcd_buffer_free(
         }
 
         for (i = 0; i < HCD_BUFFER_POOLS; i++) {
-                if (size <= pool_max [i]) {
-                        dma_pool_free(hcd->pool [i], addr, dma);
+                if (size <= pool_max[i]) {
+                        dma_pool_free(hcd->pool[i], addr, dma);
                         return;
                 }
         }
diff --git a/drivers/usb/core/config.c b/drivers/usb/core/config.c
index 83126b03e7cf..c962608b4b9a 100644
--- a/drivers/usb/core/config.c
+++ b/drivers/usb/core/config.c
@@ -129,7 +129,7 @@ static void usb_parse_ss_endpoint_companion(struct device *ddev, int cfgno,
                 max_tx = ep->desc.wMaxPacketSize * (desc->bMaxBurst + 1);
         else
                 max_tx = 999999;
-        if (desc->wBytesPerInterval > max_tx) {
+        if (le16_to_cpu(desc->wBytesPerInterval) > max_tx) {
                 dev_warn(ddev, "%s endpoint with wBytesPerInterval of %d in "
                                 "config %d interface %d altsetting %d ep %d: "
                                 "setting to %d\n",
diff --git a/drivers/usb/core/devices.c b/drivers/usb/core/devices.c
index 3449742c00e1..0149c0976e9c 100644
--- a/drivers/usb/core/devices.c
+++ b/drivers/usb/core/devices.c
@@ -54,7 +54,6 @@
 #include <linux/gfp.h>
 #include <linux/poll.h>
 #include <linux/usb.h>
-#include <linux/smp_lock.h>
 #include <linux/usbdevice_fs.h>
 #include <linux/usb/hcd.h>
 #include <linux/mutex.h>
@@ -65,49 +64,49 @@
 /* Define ALLOW_SERIAL_NUMBER if you want to see the serial number of devices */
 #define ALLOW_SERIAL_NUMBER
 
-static const char *format_topo =
-/* T:  Bus=dd Lev=dd Prnt=dd Port=dd Cnt=dd Dev#=ddd Spd=ddd MxCh=dd */
-"\nT:  Bus=%2.2d Lev=%2.2d Prnt=%2.2d Port=%2.2d Cnt=%2.2d Dev#=%3d Spd=%3s MxCh=%2d\n";
+static const char format_topo[] =
+/* T:  Bus=dd Lev=dd Prnt=dd Port=dd Cnt=dd Dev#=ddd Spd=dddd MxCh=dd */
+"\nT:  Bus=%2.2d Lev=%2.2d Prnt=%2.2d Port=%2.2d Cnt=%2.2d Dev#=%3d Spd=%-4s MxCh=%2d\n";
 
-static const char *format_string_manufacturer =
+static const char format_string_manufacturer[] =
 /* S:  Manufacturer=xxxx */
   "S:  Manufacturer=%.100s\n";
 
-static const char *format_string_product =
+static const char format_string_product[] =
 /* S:  Product=xxxx */
   "S:  Product=%.100s\n";
 
 #ifdef ALLOW_SERIAL_NUMBER
-static const char *format_string_serialnumber =
+static const char format_string_serialnumber[] =
 /* S:  SerialNumber=xxxx */
   "S:  SerialNumber=%.100s\n";
 #endif
 
-static const char *format_bandwidth =
+static const char format_bandwidth[] =
 /* B:  Alloc=ddd/ddd us (xx%), #Int=ddd, #Iso=ddd */
   "B:  Alloc=%3d/%3d us (%2d%%), #Int=%3d, #Iso=%3d\n";
 
-static const char *format_device1 =
+static const char format_device1[] =
 /* D:  Ver=xx.xx Cls=xx(sssss) Sub=xx Prot=xx MxPS=dd #Cfgs=dd */
   "D:  Ver=%2x.%02x Cls=%02x(%-5s) Sub=%02x Prot=%02x MxPS=%2d #Cfgs=%3d\n";
 
-static const char *format_device2 =
+static const char format_device2[] =
 /* P:  Vendor=xxxx ProdID=xxxx Rev=xx.xx */
   "P:  Vendor=%04x ProdID=%04x Rev=%2x.%02x\n";
 
-static const char *format_config =
+static const char format_config[] =
 /* C:  #Ifs=dd Cfg#=dd Atr=xx MPwr=dddmA */
   "C:%c #Ifs=%2d Cfg#=%2d Atr=%02x MxPwr=%3dmA\n";
 
-static const char *format_iad =
+static const char format_iad[] =
 /* A:  FirstIf#=dd IfCount=dd Cls=xx(sssss) Sub=xx Prot=xx */
   "A:  FirstIf#=%2d IfCount=%2d Cls=%02x(%-5s) Sub=%02x Prot=%02x\n";
 
-static const char *format_iface =
+static const char format_iface[] =
 /* I:  If#=dd Alt=dd #EPs=dd Cls=xx(sssss) Sub=xx Prot=xx Driver=xxxx*/
   "I:%c If#=%2d Alt=%2d #EPs=%2d Cls=%02x(%-5s) Sub=%02x Prot=%02x Driver=%s\n";
 
-static const char *format_endpt =
+static const char format_endpt[] =
 /* E:  Ad=xx(s) Atr=xx(ssss) MxPS=dddd Ivl=D?s */
   "E:  Ad=%02x(%c) Atr=%02x(%-4s) MxPS=%4d Ivl=%d%cs\n";
 
@@ -222,7 +221,7 @@ static char *usb_dump_endpoint_descriptor(int speed, char *start, char *end,
                 break;
         case USB_ENDPOINT_XFER_INT:
                 type = "Int.";
-                if (speed == USB_SPEED_HIGH)
+                if (speed == USB_SPEED_HIGH || speed == USB_SPEED_SUPER)
                         interval = 1 << (desc->bInterval - 1);
                 else
                         interval = desc->bInterval;
@@ -230,7 +229,8 @@ static char *usb_dump_endpoint_descriptor(int speed, char *start, char *end,
         default:        /* "can't happen" */
                 return start;
         }
-        interval *= (speed == USB_SPEED_HIGH) ? 125 : 1000;
+        interval *= (speed == USB_SPEED_HIGH ||
+                     speed == USB_SPEED_SUPER) ? 125 : 1000;
         if (interval % 1000)
                 unit = 'u';
         else {
@@ -520,11 +520,14 @@ static ssize_t usb_device_dump(char __user **buffer, size_t *nbytes,
                 speed = "1.5"; break;
         case USB_SPEED_UNKNOWN:         /* usb 1.1 root hub code */
         case USB_SPEED_FULL:
-                speed = "12 "; break;
+                speed = "12"; break;
+        case USB_SPEED_WIRELESS:        /* Wireless has no real fixed speed */
         case USB_SPEED_HIGH:
                 speed = "480"; break;
+        case USB_SPEED_SUPER:
+                speed = "5000"; break;
         default:
-                speed = "?? ";
+                speed = "??";
         }
         data_end = pages_start + sprintf(pages_start, format_topo,
                         bus->busnum, level, parent_devnum,
@@ -540,8 +543,9 @@ static ssize_t usb_device_dump(char __user **buffer, size_t *nbytes,
         if (level == 0) {
                 int     max;
 
-                /* high speed reserves 80%, full/low reserves 90% */
-                if (usbdev->speed == USB_SPEED_HIGH)
+                /* super/high speed reserves 80%, full/low reserves 90% */
+                if (usbdev->speed == USB_SPEED_HIGH ||
+                    usbdev->speed == USB_SPEED_SUPER)
                         max = 800;
                 else
                         max = FRAME_TIME_MAX_USECS_ALLOC;
diff --git a/drivers/usb/core/devio.c b/drivers/usb/core/devio.c
index f1aaff6202a5..37518dfdeb98 100644
--- a/drivers/usb/core/devio.c
+++ b/drivers/usb/core/devio.c
@@ -37,7 +37,6 @@
 #include <linux/fs.h>
 #include <linux/mm.h>
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
 #include <linux/signal.h>
 #include <linux/poll.h>
 #include <linux/module.h>
@@ -803,7 +802,7 @@ static int proc_control(struct dev_state *ps, void __user *arg)
                                     tbuf, ctrl.wLength, tmo);
                 usb_lock_device(dev);
                 snoop_urb(dev, NULL, pipe, max(i, 0), min(i, 0), COMPLETE,
-                        tbuf, i);
+                          tbuf, max(i, 0));
                 if ((i > 0) && ctrl.wLength) {
                         if (copy_to_user(ctrl.data, tbuf, i)) {
                                 free_page((unsigned long)tbuf);
@@ -965,10 +964,11 @@ static int proc_getdriver(struct dev_state *ps, void __user *arg)
 
 static int proc_connectinfo(struct dev_state *ps, void __user *arg)
 {
-        struct usbdevfs_connectinfo ci;
+        struct usbdevfs_connectinfo ci = {
+                .devnum = ps->dev->devnum,
+                .slow = ps->dev->speed == USB_SPEED_LOW
+        };
 
-        ci.devnum = ps->dev->devnum;
-        ci.slow = ps->dev->speed == USB_SPEED_LOW;
         if (copy_to_user(arg, &ci, sizeof(ci)))
                 return -EFAULT;
         return 0;
diff --git a/drivers/usb/core/driver.c b/drivers/usb/core/driver.c
index d7a4401ef019..34e3da5aa72a 100644
--- a/drivers/usb/core/driver.c
+++ b/drivers/usb/core/driver.c
@@ -27,7 +27,6 @@
 #include <linux/usb.h>
 #include <linux/usb/quirks.h>
 #include <linux/usb/hcd.h>
-#include <linux/pm_runtime.h>
 
 #include "usb.h"
 
@@ -376,7 +375,7 @@ static int usb_unbind_interface(struct device *dev)
                  * Just re-enable it without affecting the endpoint toggles.
                  */
                 usb_enable_interface(udev, intf, false);
-        } else if (!error && intf->dev.power.status == DPM_ON) {
+        } else if (!error && !intf->dev.power.is_prepared) {
                 r = usb_set_interface(udev, intf->altsetting[0].
                                 desc.bInterfaceNumber, 0);
                 if (r < 0)
@@ -961,7 +960,7 @@ void usb_rebind_intf(struct usb_interface *intf)
         }
 
         /* Try to rebind the interface */
-        if (intf->dev.power.status == DPM_ON) {
+        if (!intf->dev.power.is_prepared) {
                 intf->needs_binding = 0;
                 rc = device_attach(&intf->dev);
                 if (rc < 0)
@@ -1108,8 +1107,7 @@ static int usb_resume_interface(struct usb_device *udev,
         if (intf->condition == USB_INTERFACE_UNBOUND) {
 
                 /* Carry out a deferred switch to altsetting 0 */
-                if (intf->needs_altsetting0 &&
-                                intf->dev.power.status == DPM_ON) {
+                if (intf->needs_altsetting0 && !intf->dev.power.is_prepared) {
                         usb_set_interface(udev, intf->altsetting[0].
                                         desc.bInterfaceNumber, 0);
                         intf->needs_altsetting0 = 0;
@@ -1189,13 +1187,22 @@ static int usb_suspend_both(struct usb_device *udev, pm_message_t msg)
                 for (i = n - 1; i >= 0; --i) {
                         intf = udev->actconfig->interface[i];
                         status = usb_suspend_interface(udev, intf, msg);
+
+                        /* Ignore errors during system sleep transitions */
+                        if (!(msg.event & PM_EVENT_AUTO))
+                                status = 0;
                         if (status != 0)
                                 break;
                 }
         }
-        if (status == 0)
+        if (status == 0) {
                 status = usb_suspend_device(udev, msg);
 
+                /* Again, ignore errors during system sleep transitions */
+                if (!(msg.event & PM_EVENT_AUTO))
+                        status = 0;
+        }
+
         /* If the suspend failed, resume interfaces that did get suspended */
         if (status != 0) {
                 msg.event ^= (PM_EVENT_SUSPEND | PM_EVENT_RESUME);
@@ -1262,6 +1269,7 @@ static int usb_resume_both(struct usb_device *udev, pm_message_t msg)
                                         udev->reset_resume);
                 }
         }
+        usb_mark_last_busy(udev);
 
  done:
         dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
@@ -1329,7 +1337,6 @@ int usb_resume(struct device *dev, pm_message_t msg)
                         pm_runtime_disable(dev);
                         pm_runtime_set_active(dev);
                         pm_runtime_enable(dev);
-                        udev->last_busy = jiffies;
                         do_unbind_rebind(udev, DO_REBIND);
                 }
         }
@@ -1337,7 +1344,7 @@ int usb_resume(struct device *dev, pm_message_t msg)
         /* Avoid PM error messages for devices disconnected while suspended
          * as we'll display regular disconnect messages just a bit later.
          */
-        if (status == -ENODEV)
+        if (status == -ENODEV || status == -ESHUTDOWN)
                 status = 0;
         return status;
 }
@@ -1397,33 +1404,8 @@ void usb_autosuspend_device(struct usb_device *udev)
 {
         int     status;
 
-        udev->last_busy = jiffies;
-        status = pm_runtime_put_sync(&udev->dev);
-        dev_vdbg(&udev->dev, "%s: cnt %d -> %d\n",
-                        __func__, atomic_read(&udev->dev.power.usage_count),
-                        status);
-}
-
-/**
- * usb_try_autosuspend_device - attempt an autosuspend of a USB device and its interfaces
- * @udev: the usb_device to autosuspend
- *
- * This routine should be called when a core subsystem thinks @udev may
- * be ready to autosuspend.
- *
- * @udev's usage counter left unchanged.  If it is 0 and all the interfaces
- * are inactive then an autosuspend will be attempted.  The attempt may
- * fail or be delayed.
- *
- * The caller must hold @udev's device lock.
- *
- * This routine can run only in process context.
- */
-void usb_try_autosuspend_device(struct usb_device *udev)
-{
-        int     status;
-
-        status = pm_runtime_idle(&udev->dev);
+        usb_mark_last_busy(udev);
+        status = pm_runtime_put_sync_autosuspend(&udev->dev);
         dev_vdbg(&udev->dev, "%s: cnt %d -> %d\n",
                         __func__, atomic_read(&udev->dev.power.usage_count),
                         status);
@@ -1482,7 +1464,7 @@ void usb_autopm_put_interface(struct usb_interface *intf)
         struct usb_device       *udev = interface_to_usbdev(intf);
         int                     status;
 
-        udev->last_busy = jiffies;
+        usb_mark_last_busy(udev);
         atomic_dec(&intf->pm_usage_cnt);
         status = pm_runtime_put_sync(&intf->dev);
         dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n",
@@ -1509,32 +1491,11 @@ EXPORT_SYMBOL_GPL(usb_autopm_put_interface);
 void usb_autopm_put_interface_async(struct usb_interface *intf)
 {
         struct usb_device       *udev = interface_to_usbdev(intf);
-        unsigned long           last_busy;
-        int                     status = 0;
+        int                     status;
 
-        last_busy = udev->last_busy;
-        udev->last_busy = jiffies;
+        usb_mark_last_busy(udev);
         atomic_dec(&intf->pm_usage_cnt);
-        pm_runtime_put_noidle(&intf->dev);
-
-        if (udev->dev.power.runtime_auto) {
-                /* Optimization: Don't schedule a delayed autosuspend if
-                 * the timer is already running and the expiration time
-                 * wouldn't change.
-                 *
-                 * We have to use the interface's timer.  Attempts to
-                 * schedule a suspend for the device would fail because
-                 * the interface is still active.
-                 */
-                if (intf->dev.power.timer_expires == 0 ||
-                                round_jiffies_up(last_busy) !=
-                                round_jiffies_up(jiffies)) {
-                        status = pm_schedule_suspend(&intf->dev,
-                                        jiffies_to_msecs(
-                                        round_jiffies_up_relative(
-                                                udev->autosuspend_delay)));
-                }
-        }
+        status = pm_runtime_put(&intf->dev);
         dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n",
                         __func__, atomic_read(&intf->dev.power.usage_count),
                         status);
@@ -1554,7 +1515,7 @@ void usb_autopm_put_interface_no_suspend(struct usb_interface *intf)
 {
         struct usb_device       *udev = interface_to_usbdev(intf);
 
-        udev->last_busy = jiffies;
+        usb_mark_last_busy(udev);
         atomic_dec(&intf->pm_usage_cnt);
         pm_runtime_put_noidle(&intf->dev);
 }
@@ -1612,18 +1573,9 @@ EXPORT_SYMBOL_GPL(usb_autopm_get_interface);
  */
 int usb_autopm_get_interface_async(struct usb_interface *intf)
 {
-        int             status = 0;
-        enum rpm_status s;
-
-        /* Don't request a resume unless the interface is already suspending
-         * or suspended.  Doing so would force a running suspend timer to be
-         * cancelled.
-         */
-        pm_runtime_get_noresume(&intf->dev);
-        s = ACCESS_ONCE(intf->dev.power.runtime_status);
-        if (s == RPM_SUSPENDING || s == RPM_SUSPENDED)
-                status = pm_request_resume(&intf->dev);
+        int     status;
 
+        status = pm_runtime_get(&intf->dev);
         if (status < 0 && status != -EINPROGRESS)
                 pm_runtime_put_noidle(&intf->dev);
         else
@@ -1650,7 +1602,7 @@ void usb_autopm_get_interface_no_resume(struct usb_interface *intf)
 {
         struct usb_device       *udev = interface_to_usbdev(intf);
 
-        udev->last_busy = jiffies;
+        usb_mark_last_busy(udev);
         atomic_inc(&intf->pm_usage_cnt);
         pm_runtime_get_noresume(&intf->dev);
 }
@@ -1661,7 +1613,6 @@ static int autosuspend_check(struct usb_device *udev)
 {
         int                     w, i;
         struct usb_interface    *intf;
-        unsigned long           suspend_time, j;
 
         /* Fail if autosuspend is disabled, or any interfaces are in use, or
          * any interface drivers require remote wakeup but it isn't available.
@@ -1701,103 +1652,58 @@ static int autosuspend_check(struct usb_device *udev)
                 return -EOPNOTSUPP;
         }
         udev->do_remote_wakeup = w;
-
-        /* If everything is okay but the device hasn't been idle for long
-         * enough, queue a delayed autosuspend request.
-         */
-        j = ACCESS_ONCE(jiffies);
-        suspend_time = udev->last_busy + udev->autosuspend_delay;
-        if (time_before(j, suspend_time)) {
-                pm_schedule_suspend(&udev->dev, jiffies_to_msecs(
-                                round_jiffies_up_relative(suspend_time - j)));
-                return -EAGAIN;
-        }
         return 0;
 }
 
-static int usb_runtime_suspend(struct device *dev)
+int usb_runtime_suspend(struct device *dev)
 {
-        int     status = 0;
+        struct usb_device       *udev = to_usb_device(dev);
+        int                     status;
 
         /* A USB device can be suspended if it passes the various autosuspend
          * checks.  Runtime suspend for a USB device means suspending all the
          * interfaces and then the device itself.
          */
-        if (is_usb_device(dev)) {
-                struct usb_device       *udev = to_usb_device(dev);
-
-                if (autosuspend_check(udev) != 0)
-                        return -EAGAIN;
-
-                status = usb_suspend_both(udev, PMSG_AUTO_SUSPEND);
-
-                /* If an interface fails the suspend, adjust the last_busy
-                 * time so that we don't get another suspend attempt right
-                 * away.
-                 */
-                if (status) {
-                        udev->last_busy = jiffies +
-                                        (udev->autosuspend_delay == 0 ?
-                                                HZ/2 : 0);
-                }
-
-                /* Prevent the parent from suspending immediately after */
-                else if (udev->parent)
-                        udev->parent->last_busy = jiffies;
-        }
+        if (autosuspend_check(udev) != 0)
+                return -EAGAIN;
 
-        /* Runtime suspend for a USB interface doesn't mean anything. */
+        status = usb_suspend_both(udev, PMSG_AUTO_SUSPEND);
+        /* The PM core reacts badly unless the return code is 0,
+         * -EAGAIN, or -EBUSY, so always return -EBUSY on an error.
+         */
+        if (status != 0)
+                return -EBUSY;
         return status;
 }
 
-static int usb_runtime_resume(struct device *dev)
+int usb_runtime_resume(struct device *dev)
 {
+        struct usb_device       *udev = to_usb_device(dev);
+        int                     status;
+
         /* Runtime resume for a USB device means resuming both the device
          * and all its interfaces.
          */
-        if (is_usb_device(dev)) {
-                struct usb_device       *udev = to_usb_device(dev);
-                int                     status;
-
-                status = usb_resume_both(udev, PMSG_AUTO_RESUME);
-                udev->last_busy = jiffies;
-                return status;
-        }
-
-        /* Runtime resume for a USB interface doesn't mean anything. */
-        return 0;
+        status = usb_resume_both(udev, PMSG_AUTO_RESUME);
+        return status;
 }
 
-static int usb_runtime_idle(struct device *dev)
+int usb_runtime_idle(struct device *dev)
 {
+        struct usb_device       *udev = to_usb_device(dev);
+
         /* An idle USB device can be suspended if it passes the various
-         * autosuspend checks.  An idle interface can be suspended at
-         * any time.
+         * autosuspend checks.
          */
-        if (is_usb_device(dev)) {
-                struct usb_device       *udev = to_usb_device(dev);
-
-                if (autosuspend_check(udev) != 0)
-                        return 0;
-        }
-
-        pm_runtime_suspend(dev);
+        if (autosuspend_check(udev) == 0)
+                pm_runtime_autosuspend(dev);
         return 0;
 }
 
-static const struct dev_pm_ops usb_bus_pm_ops = {
-        .runtime_suspend =      usb_runtime_suspend,
-        .runtime_resume =       usb_runtime_resume,
-        .runtime_idle =         usb_runtime_idle,
-};
-
 #endif /* CONFIG_USB_SUSPEND */
 
 struct bus_type usb_bus_type = {
         .name =         "usb",
         .match =        usb_device_match,
         .uevent =       usb_uevent,
-#ifdef CONFIG_USB_SUSPEND
-        .pm =           &usb_bus_pm_ops,
-#endif
 };
diff --git a/drivers/usb/core/endpoint.c b/drivers/usb/core/endpoint.c
index 3788e738e265..df502a98d0df 100644
--- a/drivers/usb/core/endpoint.c
+++ b/drivers/usb/core/endpoint.c
@@ -192,17 +192,17 @@ int usb_create_ep_devs(struct device *parent,
         ep_dev->dev.parent = parent;
         ep_dev->dev.release = ep_device_release;
         dev_set_name(&ep_dev->dev, "ep_%02x", endpoint->desc.bEndpointAddress);
-        device_enable_async_suspend(&ep_dev->dev);
 
         retval = device_register(&ep_dev->dev);
         if (retval)
                 goto error_register;
 
+        device_enable_async_suspend(&ep_dev->dev);
         endpoint->ep_dev = ep_dev;
         return retval;
 
 error_register:
-        kfree(ep_dev);
+        put_device(&ep_dev->dev);
 exit:
         return retval;
 }
diff --git a/drivers/usb/core/file.c b/drivers/usb/core/file.c
index 1e6ccef2cf0c..99458c843d60 100644
--- a/drivers/usb/core/file.c
+++ b/drivers/usb/core/file.c
@@ -19,7 +19,6 @@
 #include <linux/errno.h>
 #include <linux/rwsem.h>
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
 #include <linux/usb.h>
 
 #include "usb.h"
@@ -59,6 +58,7 @@ static int usb_open(struct inode * inode, struct file * file)
 static const struct file_operations usb_fops = {
         .owner =        THIS_MODULE,
         .open =         usb_open,
+        .llseek =       noop_llseek,
 };
 
 static struct usb_class {
@@ -236,13 +236,6 @@ EXPORT_SYMBOL_GPL(usb_register_dev);
 void usb_deregister_dev(struct usb_interface *intf,
                         struct usb_class_driver *class_driver)
 {
-        int minor_base = class_driver->minor_base;
-        char name[20];
-
-#ifdef CONFIG_USB_DYNAMIC_MINORS
-        minor_base = 0;
-#endif
-
         if (intf->minor == -1)
                 return;
 
@@ -252,7 +245,6 @@ void usb_deregister_dev(struct usb_interface *intf,
         usb_minors[intf->minor] = NULL;
         up_write(&minor_rwsem);
 
-        snprintf(name, sizeof(name), class_driver->name, intf->minor - minor_base);
         device_destroy(usb_class->class, MKDEV(USB_MAJOR, intf->minor));
         intf->usb_dev = NULL;
         intf->minor = -1;
diff --git a/drivers/usb/core/hcd-pci.c b/drivers/usb/core/hcd-pci.c
index c3f98543caaf..ce22f4a84ed0 100644
--- a/drivers/usb/core/hcd-pci.c
+++ b/drivers/usb/core/hcd-pci.c
@@ -19,7 +19,6 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/pci.h>
-#include <linux/pm_runtime.h>
 #include <linux/usb.h>
 #include <linux/usb/hcd.h>
 
@@ -193,13 +192,13 @@ int usb_hcd_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
                         "Found HC with no IRQ.  Check BIOS/PCI %s setup!\n",
                         pci_name(dev));
                 retval = -ENODEV;
-                goto err1;
+                goto disable_pci;
         }
 
         hcd = usb_create_hcd(driver, &dev->dev, pci_name(dev));
         if (!hcd) {
                 retval = -ENOMEM;
-                goto err1;
+                goto disable_pci;
         }
 
         if (driver->flags & HCD_MEMORY) {
@@ -210,13 +209,13 @@ int usb_hcd_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
                                 driver->description)) {
                         dev_dbg(&dev->dev, "controller already in use\n");
                         retval = -EBUSY;
-                        goto err2;
+                        goto clear_companion;
                 }
                 hcd->regs = ioremap_nocache(hcd->rsrc_start, hcd->rsrc_len);
                 if (hcd->regs == NULL) {
                         dev_dbg(&dev->dev, "error mapping memory\n");
                         retval = -EFAULT;
-                        goto err3;
+                        goto release_mem_region;
                 }
 
         } else {
@@ -237,7 +236,7 @@ int usb_hcd_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
                 if (region == PCI_ROM_RESOURCE) {
                         dev_dbg(&dev->dev, "no i/o regions available\n");
                         retval = -EBUSY;
-                        goto err2;
+                        goto clear_companion;
                 }
         }
 
@@ -245,24 +244,24 @@ int usb_hcd_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
 
         retval = usb_add_hcd(hcd, dev->irq, IRQF_DISABLED | IRQF_SHARED);
         if (retval != 0)
-                goto err4;
+                goto unmap_registers;
         set_hs_companion(dev, hcd);
 
         if (pci_dev_run_wake(dev))
                 pm_runtime_put_noidle(&dev->dev);
         return retval;
 
- err4:
+unmap_registers:
         if (driver->flags & HCD_MEMORY) {
                 iounmap(hcd->regs);
- err3:
+release_mem_region:
                 release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
         } else
                 release_region(hcd->rsrc_start, hcd->rsrc_len);
- err2:
+clear_companion:
         clear_hs_companion(dev, hcd);
         usb_put_hcd(hcd);
- err1:
+disable_pci:
         pci_disable_device(dev);
         dev_err(&dev->dev, "init %s fail, %d\n", pci_name(dev), retval);
         return retval;
@@ -329,12 +328,14 @@ void usb_hcd_pci_shutdown(struct pci_dev *dev)
                 return;
 
         if (test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags) &&
-                        hcd->driver->shutdown)
+                        hcd->driver->shutdown) {
                 hcd->driver->shutdown(hcd);
+                pci_disable_device(dev);
+        }
 }
 EXPORT_SYMBOL_GPL(usb_hcd_pci_shutdown);
 
-#ifdef  CONFIG_PM_OPS
+#ifdef  CONFIG_PM
 
 #ifdef  CONFIG_PPC_PMAC
 static void powermac_set_asic(struct pci_dev *pci_dev, int enable)
@@ -362,11 +363,17 @@ static int check_root_hub_suspended(struct device *dev)
         struct pci_dev          *pci_dev = to_pci_dev(dev);
         struct usb_hcd          *hcd = pci_get_drvdata(pci_dev);
 
-        if (!(hcd->state == HC_STATE_SUSPENDED ||
-                        hcd->state == HC_STATE_HALT)) {
+        if (HCD_RH_RUNNING(hcd)) {
                 dev_warn(dev, "Root hub is not suspended\n");
                 return -EBUSY;
         }
+        if (hcd->shared_hcd) {
+                hcd = hcd->shared_hcd;
+                if (HCD_RH_RUNNING(hcd)) {
+                        dev_warn(dev, "Secondary root hub is not suspended\n");
+                        return -EBUSY;
+                }
+        }
         return 0;
 }
 
@@ -385,17 +392,22 @@ static int suspend_common(struct device *dev, bool do_wakeup)
         if (retval)
                 return retval;
 
-        if (hcd->driver->pci_suspend) {
+        if (hcd->driver->pci_suspend && !HCD_DEAD(hcd)) {
                 /* Optimization: Don't suspend if a root-hub wakeup is
                  * pending and it would cause the HCD to wake up anyway.
                  */
                 if (do_wakeup && HCD_WAKEUP_PENDING(hcd))
                         return -EBUSY;
+                if (do_wakeup && hcd->shared_hcd &&
+                                HCD_WAKEUP_PENDING(hcd->shared_hcd))
+                        return -EBUSY;
                 retval = hcd->driver->pci_suspend(hcd, do_wakeup);
                 suspend_report_result(hcd->driver->pci_suspend, retval);
 
                 /* Check again in case wakeup raced with pci_suspend */
-                if (retval == 0 && do_wakeup && HCD_WAKEUP_PENDING(hcd)) {
+                if ((retval == 0 && do_wakeup && HCD_WAKEUP_PENDING(hcd)) ||
+                                (retval == 0 && do_wakeup && hcd->shared_hcd &&
+                                 HCD_WAKEUP_PENDING(hcd->shared_hcd))) {
                         if (hcd->driver->pci_resume)
                                 hcd->driver->pci_resume(hcd, false);
                         retval = -EBUSY;
@@ -404,7 +416,12 @@ static int suspend_common(struct device *dev, bool do_wakeup)
                         return retval;
         }
 
-        synchronize_irq(pci_dev->irq);
+        /* If MSI-X is enabled, the driver will have synchronized all vectors
+         * in pci_suspend(). If MSI or legacy PCI is enabled, that will be
+         * synchronized here.
+         */
+        if (!hcd->msix_enabled)
+                synchronize_irq(pci_dev->irq);
 
         /* Downstream ports from this root hub should already be quiesced, so
          * there will be no DMA activity.  Now we can shut down the upstream
@@ -421,7 +438,9 @@ static int resume_common(struct device *dev, int event)
         struct usb_hcd          *hcd = pci_get_drvdata(pci_dev);
         int                     retval;
 
-        if (hcd->state != HC_STATE_SUSPENDED) {
+        if (HCD_RH_RUNNING(hcd) ||
+                        (hcd->shared_hcd &&
+                         HCD_RH_RUNNING(hcd->shared_hcd))) {
                 dev_dbg(dev, "can't resume, not suspended!\n");
                 return 0;
         }
@@ -435,8 +454,10 @@ static int resume_common(struct device *dev, int event)
         pci_set_master(pci_dev);
 
         clear_bit(HCD_FLAG_SAW_IRQ, &hcd->flags);
+        if (hcd->shared_hcd)
+                clear_bit(HCD_FLAG_SAW_IRQ, &hcd->shared_hcd->flags);
 
-        if (hcd->driver->pci_resume) {
+        if (hcd->driver->pci_resume && !HCD_DEAD(hcd)) {
                 if (event != PM_EVENT_AUTO_RESUME)
                         wait_for_companions(pci_dev, hcd);
 
@@ -444,6 +465,8 @@ static int resume_common(struct device *dev, int event)
                                 event == PM_EVENT_RESTORE);
                 if (retval) {
                         dev_err(dev, "PCI post-resume error %d!\n", retval);
+                        if (hcd->shared_hcd)
+                                usb_hc_died(hcd->shared_hcd);
                         usb_hc_died(hcd);
                 }
         }
@@ -469,10 +492,11 @@ static int hcd_pci_suspend_noirq(struct device *dev)
 
         pci_save_state(pci_dev);
 
-        /* If the root hub is HALTed rather than SUSPENDed,
-         * disallow remote wakeup.
+        /* If the root hub is dead rather than suspended, disallow remote
+         * wakeup.  usb_hc_died() should ensure that both hosts are marked as
+         * dying, so we only need to check the primary roothub.
          */
-        if (hcd->state == HC_STATE_HALT)
+        if (HCD_DEAD(hcd))
                 device_set_wakeup_enable(dev, 0);
         dev_dbg(dev, "wakeup: %d\n", device_may_wakeup(dev));
 
@@ -574,4 +598,4 @@ const struct dev_pm_ops usb_hcd_pci_pm_ops = {
 };
 EXPORT_SYMBOL_GPL(usb_hcd_pci_pm_ops);
 
-#endif  /* CONFIG_PM_OPS */
+#endif  /* CONFIG_PM */
diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
index 5cca00a6d09d..ace9f8442e5d 100644
--- a/drivers/usb/core/hcd.c
+++ b/drivers/usb/core/hcd.c
@@ -38,7 +38,6 @@
 #include <asm/unaligned.h>
 #include <linux/platform_device.h>
 #include <linux/workqueue.h>
-#include <linux/pm_runtime.h>
 
 #include <linux/usb.h>
 #include <linux/usb/hcd.h>
@@ -298,7 +297,7 @@ static const u8 ss_rh_config_descriptor[] = {
         /* one configuration */
         0x09,       /*  __u8  bLength; */
         0x02,       /*  __u8  bDescriptorType; Configuration */
-        0x19, 0x00, /*  __le16 wTotalLength; FIXME */
+        0x1f, 0x00, /*  __le16 wTotalLength; */
         0x01,       /*  __u8  bNumInterfaces; (1) */
         0x01,       /*  __u8  bConfigurationValue; */
         0x00,       /*  __u8  iConfiguration; */
@@ -328,11 +327,14 @@ static const u8 ss_rh_config_descriptor[] = {
                     /* __le16 ep_wMaxPacketSize; 1 + (MAX_ROOT_PORTS / 8)
                      * see hub.c:hub_configure() for details. */
         (USB_MAXCHILDREN + 1 + 7) / 8, 0x00,
-        0x0c        /*  __u8  ep_bInterval; (256ms -- usb 2.0 spec) */
-        /*
-         * All 3.0 hubs should have an endpoint companion descriptor,
-         * but we're ignoring that for now.  FIXME?
-         */
+        0x0c,       /*  __u8  ep_bInterval; (256ms -- usb 2.0 spec) */
+
+        /* one SuperSpeed endpoint companion descriptor */
+        0x06,        /* __u8 ss_bLength */
+        0x30,        /* __u8 ss_bDescriptorType; SuperSpeed EP Companion */
+        0x00,        /* __u8 ss_bMaxBurst; allows 1 TX between ACKs */
+        0x00,        /* __u8 ss_bmAttributes; 1 packet per service interval */
+        0x02, 0x00   /* __le16 ss_wBytesPerInterval; 15 bits for max 15 ports */
 };
 
 /*-------------------------------------------------------------------------*/
@@ -505,7 +507,7 @@ static int rh_call_control (struct usb_hcd *hcd, struct urb *urb)
         case DeviceRequest | USB_REQ_GET_DESCRIPTOR:
                 switch (wValue & 0xff00) {
                 case USB_DT_DEVICE << 8:
-                        switch (hcd->driver->flags & HCD_MASK) {
+                        switch (hcd->speed) {
                         case HCD_USB3:
                                 bufp = usb3_rh_dev_descriptor;
                                 break;
@@ -523,7 +525,7 @@ static int rh_call_control (struct usb_hcd *hcd, struct urb *urb)
                                 patch_protocol = 1;
                         break;
                 case USB_DT_CONFIG << 8:
-                        switch (hcd->driver->flags & HCD_MASK) {
+                        switch (hcd->speed) {
                         case HCD_USB3:
                                 bufp = ss_rh_config_descriptor;
                                 len = sizeof ss_rh_config_descriptor;
@@ -698,7 +700,7 @@ void usb_hcd_poll_rh_status(struct usb_hcd *hcd)
         /* The USB 2.0 spec says 256 ms.  This is close enough and won't
          * exceed that limit if HZ is 100. The math is more clunky than
          * maybe expected, this is to make sure that all timers for USB devices
-         * fire at the same time to give the CPU a break inbetween */
+         * fire at the same time to give the CPU a break in between */
         if (hcd->uses_new_polling ? HCD_POLL_RH(hcd) :
                         (length == 0 && hcd->status_urb != NULL))
                 mod_timer (&hcd->rh_timer, (jiffies/(HZ/4) + 1) * (HZ/4));
@@ -984,7 +986,7 @@ static int register_root_hub(struct usb_hcd *hcd)
                 spin_unlock_irq (&hcd_root_hub_lock);
 
                 /* Did the HC die before the root hub was registered? */
-                if (hcd->state == HC_STATE_HALT)
+                if (HCD_DEAD(hcd))
                         usb_hc_died (hcd);      /* This time clean up */
         }
 
@@ -1090,13 +1092,10 @@ int usb_hcd_link_urb_to_ep(struct usb_hcd *hcd, struct urb *urb)
          * Check the host controller's state and add the URB to the
          * endpoint's queue.
          */
-        switch (hcd->state) {
-        case HC_STATE_RUNNING:
-        case HC_STATE_RESUMING:
+        if (HCD_RH_RUNNING(hcd)) {
                 urb->unlinked = 0;
                 list_add_tail(&urb->urb_list, &urb->ep->urb_list);
-                break;
-        default:
+        } else {
                 rc = -ESHUTDOWN;
                 goto done;
         }
@@ -1154,6 +1153,8 @@ int usb_hcd_check_unlink_urb(struct usb_hcd *hcd, struct urb *urb,
                 dev_warn(hcd->self.controller, "Unlink after no-IRQ?  "
                         "Controller is probably using the wrong IRQ.\n");
                 set_bit(HCD_FLAG_SAW_IRQ, &hcd->flags);
+                if (hcd->shared_hcd)
+                        set_bit(HCD_FLAG_SAW_IRQ, &hcd->shared_hcd->flags);
         }
 
         return 0;
@@ -1263,10 +1264,8 @@ static void hcd_free_coherent(struct usb_bus *bus, dma_addr_t *dma_handle,
         *dma_handle = 0;
 }
 
-static void unmap_urb_for_dma(struct usb_hcd *hcd, struct urb *urb)
+void usb_hcd_unmap_urb_setup_for_dma(struct usb_hcd *hcd, struct urb *urb)
 {
-        enum dma_data_direction dir;
-
         if (urb->transfer_flags & URB_SETUP_MAP_SINGLE)
                 dma_unmap_single(hcd->self.controller,
                                 urb->setup_dma,
@@ -1279,6 +1278,25 @@ static void unmap_urb_for_dma(struct usb_hcd *hcd, struct urb *urb)
                                 sizeof(struct usb_ctrlrequest),
                                 DMA_TO_DEVICE);
 
+        /* Make it safe to call this routine more than once */
+        urb->transfer_flags &= ~(URB_SETUP_MAP_SINGLE | URB_SETUP_MAP_LOCAL);
+}
+EXPORT_SYMBOL_GPL(usb_hcd_unmap_urb_setup_for_dma);
+
+static void unmap_urb_for_dma(struct usb_hcd *hcd, struct urb *urb)
+{
+        if (hcd->driver->unmap_urb_for_dma)
+                hcd->driver->unmap_urb_for_dma(hcd, urb);
+        else
+                usb_hcd_unmap_urb_for_dma(hcd, urb);
+}
+
+void usb_hcd_unmap_urb_for_dma(struct usb_hcd *hcd, struct urb *urb)
+{
+        enum dma_data_direction dir;
+
+        usb_hcd_unmap_urb_setup_for_dma(hcd, urb);
+
         dir = usb_urb_dir_in(urb) ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
         if (urb->transfer_flags & URB_DMA_MAP_SG)
                 dma_unmap_sg(hcd->self.controller,
@@ -1303,14 +1321,23 @@ static void unmap_urb_for_dma(struct usb_hcd *hcd, struct urb *urb)
                                 dir);
 
         /* Make it safe to call this routine more than once */
-        urb->transfer_flags &= ~(URB_SETUP_MAP_SINGLE | URB_SETUP_MAP_LOCAL |
-                        URB_DMA_MAP_SG | URB_DMA_MAP_PAGE |
+        urb->transfer_flags &= ~(URB_DMA_MAP_SG | URB_DMA_MAP_PAGE |
                         URB_DMA_MAP_SINGLE | URB_MAP_LOCAL);
 }
+EXPORT_SYMBOL_GPL(usb_hcd_unmap_urb_for_dma);
 
 static int map_urb_for_dma(struct usb_hcd *hcd, struct urb *urb,
                            gfp_t mem_flags)
 {
+        if (hcd->driver->map_urb_for_dma)
+                return hcd->driver->map_urb_for_dma(hcd, urb, mem_flags);
+        else
+                return usb_hcd_map_urb_for_dma(hcd, urb, mem_flags);
+}
+
+int usb_hcd_map_urb_for_dma(struct usb_hcd *hcd, struct urb *urb,
+                            gfp_t mem_flags)
+{
         enum dma_data_direction dir;
         int ret = 0;
 
@@ -1321,6 +1348,8 @@ static int map_urb_for_dma(struct usb_hcd *hcd, struct urb *urb,
          */
 
         if (usb_endpoint_xfer_control(&urb->ep->desc)) {
+                if (hcd->self.uses_pio_for_control)
+                        return ret;
                 if (hcd->self.uses_dma) {
                         urb->setup_dma = dma_map_single(
                                         hcd->self.controller,
@@ -1400,10 +1429,11 @@ static int map_urb_for_dma(struct usb_hcd *hcd, struct urb *urb,
                 }
                 if (ret && (urb->transfer_flags & (URB_SETUP_MAP_SINGLE |
                                 URB_SETUP_MAP_LOCAL)))
-                        unmap_urb_for_dma(hcd, urb);
+                        usb_hcd_unmap_urb_for_dma(hcd, urb);
         }
         return ret;
 }
+EXPORT_SYMBOL_GPL(usb_hcd_map_urb_for_dma);
 
 /*-------------------------------------------------------------------------*/
 
@@ -1878,7 +1908,7 @@ void usb_free_streams(struct usb_interface *interface,
 
         /* Streams only apply to bulk endpoints. */
         for (i = 0; i < num_eps; i++)
-                if (!usb_endpoint_xfer_bulk(&eps[i]->desc))
+                if (!eps[i] || !usb_endpoint_xfer_bulk(&eps[i]->desc))
                         return;
 
         hcd->driver->free_streams(hcd, dev, eps, num_eps, mem_flags);
@@ -1903,7 +1933,7 @@ int usb_hcd_get_frame_number (struct usb_device *udev)
 {
         struct usb_hcd  *hcd = bus_to_hcd(udev->bus);
 
-        if (!HC_IS_RUNNING (hcd->state))
+        if (!HCD_RH_RUNNING(hcd))
                 return -ESHUTDOWN;
         return hcd->driver->get_frame_number (hcd);
 }
@@ -1920,9 +1950,15 @@ int hcd_bus_suspend(struct usb_device *rhdev, pm_message_t msg)
 
         dev_dbg(&rhdev->dev, "bus %s%s\n",
                         (msg.event & PM_EVENT_AUTO ? "auto-" : ""), "suspend");
+        if (HCD_DEAD(hcd)) {
+                dev_dbg(&rhdev->dev, "skipped %s of dead bus\n", "suspend");
+                return 0;
+        }
+
         if (!hcd->driver->bus_suspend) {
                 status = -ENOENT;
         } else {
+                clear_bit(HCD_FLAG_RH_RUNNING, &hcd->flags);
                 hcd->state = HC_STATE_QUIESCING;
                 status = hcd->driver->bus_suspend(hcd);
         }
@@ -1930,7 +1966,12 @@ int hcd_bus_suspend(struct usb_device *rhdev, pm_message_t msg)
                 usb_set_device_state(rhdev, USB_STATE_SUSPENDED);
                 hcd->state = HC_STATE_SUSPENDED;
         } else {
-                hcd->state = old_state;
+                spin_lock_irq(&hcd_root_hub_lock);
+                if (!HCD_DEAD(hcd)) {
+                        set_bit(HCD_FLAG_RH_RUNNING, &hcd->flags);
+                        hcd->state = old_state;
+                }
+                spin_unlock_irq(&hcd_root_hub_lock);
                 dev_dbg(&rhdev->dev, "bus %s fail, err %d\n",
                                 "suspend", status);
         }
@@ -1945,21 +1986,30 @@ int hcd_bus_resume(struct usb_device *rhdev, pm_message_t msg)
 
         dev_dbg(&rhdev->dev, "usb %s%s\n",
                         (msg.event & PM_EVENT_AUTO ? "auto-" : ""), "resume");
-        clear_bit(HCD_FLAG_WAKEUP_PENDING, &hcd->flags);
+        if (HCD_DEAD(hcd)) {
+                dev_dbg(&rhdev->dev, "skipped %s of dead bus\n", "resume");
+                return 0;
+        }
         if (!hcd->driver->bus_resume)
                 return -ENOENT;
-        if (hcd->state == HC_STATE_RUNNING)
+        if (HCD_RH_RUNNING(hcd))
                 return 0;
 
         hcd->state = HC_STATE_RESUMING;
         status = hcd->driver->bus_resume(hcd);
+        clear_bit(HCD_FLAG_WAKEUP_PENDING, &hcd->flags);
         if (status == 0) {
                 /* TRSMRCY = 10 msec */
                 msleep(10);
-                usb_set_device_state(rhdev, rhdev->actconfig
-                                ? USB_STATE_CONFIGURED
-                                : USB_STATE_ADDRESS);
-                hcd->state = HC_STATE_RUNNING;
+                spin_lock_irq(&hcd_root_hub_lock);
+                if (!HCD_DEAD(hcd)) {
+                        usb_set_device_state(rhdev, rhdev->actconfig
+                                        ? USB_STATE_CONFIGURED
+                                        : USB_STATE_ADDRESS);
+                        set_bit(HCD_FLAG_RH_RUNNING, &hcd->flags);
+                        hcd->state = HC_STATE_RUNNING;
+                }
+                spin_unlock_irq(&hcd_root_hub_lock);
         } else {
                 hcd->state = old_state;
                 dev_dbg(&rhdev->dev, "bus %s fail, err %d\n",
@@ -2070,15 +2120,14 @@ irqreturn_t usb_hcd_irq (int irq, void *__hcd)
          */
         local_irq_save(flags);
 
-        if (unlikely(hcd->state == HC_STATE_HALT || !HCD_HW_ACCESSIBLE(hcd))) {
+        if (unlikely(HCD_DEAD(hcd) || !HCD_HW_ACCESSIBLE(hcd))) {
                 rc = IRQ_NONE;
         } else if (hcd->driver->irq(hcd) == IRQ_NONE) {
                 rc = IRQ_NONE;
         } else {
                 set_bit(HCD_FLAG_SAW_IRQ, &hcd->flags);
-
-                if (unlikely(hcd->state == HC_STATE_HALT))
-                        usb_hc_died(hcd);
+                if (hcd->shared_hcd)
+                        set_bit(HCD_FLAG_SAW_IRQ, &hcd->shared_hcd->flags);
                 rc = IRQ_HANDLED;
         }
 
@@ -2095,7 +2144,9 @@ EXPORT_SYMBOL_GPL(usb_hcd_irq);
  *
  * This is called by bus glue to report a USB host controller that died
  * while operations may still have been pending.  It's called automatically
- * by the PCI glue, so only glue for non-PCI busses should need to call it. 
+ * by the PCI glue, so only glue for non-PCI busses should need to call it.
+ *
+ * Only call this function with the primary HCD.
  */
 void usb_hc_died (struct usb_hcd *hcd)
 {
@@ -2104,6 +2155,8 @@ void usb_hc_died (struct usb_hcd *hcd)
         dev_err (hcd->self.controller, "HC died; cleaning up\n");
 
         spin_lock_irqsave (&hcd_root_hub_lock, flags);
+        clear_bit(HCD_FLAG_RH_RUNNING, &hcd->flags);
+        set_bit(HCD_FLAG_DEAD, &hcd->flags);
         if (hcd->rh_registered) {
                 clear_bit(HCD_FLAG_POLL_RH, &hcd->flags);
 
@@ -2112,17 +2165,31 @@ void usb_hc_died (struct usb_hcd *hcd)
                                 USB_STATE_NOTATTACHED);
                 usb_kick_khubd (hcd->self.root_hub);
         }
+        if (usb_hcd_is_primary_hcd(hcd) && hcd->shared_hcd) {
+                hcd = hcd->shared_hcd;
+                if (hcd->rh_registered) {
+                        clear_bit(HCD_FLAG_POLL_RH, &hcd->flags);
+
+                        /* make khubd clean up old urbs and devices */
+                        usb_set_device_state(hcd->self.root_hub,
+                                        USB_STATE_NOTATTACHED);
+                        usb_kick_khubd(hcd->self.root_hub);
+                }
+        }
         spin_unlock_irqrestore (&hcd_root_hub_lock, flags);
+        /* Make sure that the other roothub is also deallocated. */
 }
 EXPORT_SYMBOL_GPL (usb_hc_died);
 
 /*-------------------------------------------------------------------------*/
 
 /**
- * usb_create_hcd - create and initialize an HCD structure
+ * usb_create_shared_hcd - create and initialize an HCD structure
  * @driver: HC driver that will use this hcd
  * @dev: device for this HC, stored in hcd->self.controller
  * @bus_name: value to store in hcd->self.bus_name
+ * @primary_hcd: a pointer to the usb_hcd structure that is sharing the
+ *              PCI device.  Only allocate certain resources for the primary HCD
  * Context: !in_interrupt()
  *
  * Allocate a struct usb_hcd, with extra space at the end for the
@@ -2131,8 +2198,9 @@ EXPORT_SYMBOL_GPL (usb_hc_died);
  *
  * If memory is unavailable, returns NULL.
  */
-struct usb_hcd *usb_create_hcd (const struct hc_driver *driver,
-                struct device *dev, const char *bus_name)
+struct usb_hcd *usb_create_shared_hcd(const struct hc_driver *driver,
+                struct device *dev, const char *bus_name,
+                struct usb_hcd *primary_hcd)
 {
         struct usb_hcd *hcd;
 
@@ -2141,7 +2209,24 @@ struct usb_hcd *usb_create_hcd (const struct hc_driver *driver,
                 dev_dbg (dev, "hcd alloc failed\n");
                 return NULL;
         }
-        dev_set_drvdata(dev, hcd);
+        if (primary_hcd == NULL) {
+                hcd->bandwidth_mutex = kmalloc(sizeof(*hcd->bandwidth_mutex),
+                                GFP_KERNEL);
+                if (!hcd->bandwidth_mutex) {
+                        kfree(hcd);
+                        dev_dbg(dev, "hcd bandwidth mutex alloc failed\n");
+                        return NULL;
+                }
+                mutex_init(hcd->bandwidth_mutex);
+                dev_set_drvdata(dev, hcd);
+        } else {
+                hcd->bandwidth_mutex = primary_hcd->bandwidth_mutex;
+                hcd->primary_hcd = primary_hcd;
+                primary_hcd->primary_hcd = primary_hcd;
+                hcd->shared_hcd = primary_hcd;
+                primary_hcd->shared_hcd = hcd;
+        }
+
         kref_init(&hcd->kref);
 
         usb_bus_init(&hcd->self);
@@ -2155,19 +2240,53 @@ struct usb_hcd *usb_create_hcd (const struct hc_driver *driver,
 #ifdef CONFIG_USB_SUSPEND
         INIT_WORK(&hcd->wakeup_work, hcd_resume_work);
 #endif
-        mutex_init(&hcd->bandwidth_mutex);
 
         hcd->driver = driver;
+        hcd->speed = driver->flags & HCD_MASK;
         hcd->product_desc = (driver->product_desc) ? driver->product_desc :
                         "USB Host Controller";
         return hcd;
 }
+EXPORT_SYMBOL_GPL(usb_create_shared_hcd);
+
+/**
+ * usb_create_hcd - create and initialize an HCD structure
+ * @driver: HC driver that will use this hcd
+ * @dev: device for this HC, stored in hcd->self.controller
+ * @bus_name: value to store in hcd->self.bus_name
+ * Context: !in_interrupt()
+ *
+ * Allocate a struct usb_hcd, with extra space at the end for the
+ * HC driver's private data.  Initialize the generic members of the
+ * hcd structure.
+ *
+ * If memory is unavailable, returns NULL.
+ */
+struct usb_hcd *usb_create_hcd(const struct hc_driver *driver,
+                struct device *dev, const char *bus_name)
+{
+        return usb_create_shared_hcd(driver, dev, bus_name, NULL);
+}
 EXPORT_SYMBOL_GPL(usb_create_hcd);
 
+/*
+ * Roothubs that share one PCI device must also share the bandwidth mutex.
+ * Don't deallocate the bandwidth_mutex until the last shared usb_hcd is
+ * deallocated.
+ *
+ * Make sure to only deallocate the bandwidth_mutex when the primary HCD is
+ * freed.  When hcd_release() is called for the non-primary HCD, set the
+ * primary_hcd's shared_hcd pointer to null (since the non-primary HCD will be
+ * freed shortly).
+ */
 static void hcd_release (struct kref *kref)
 {
         struct usb_hcd *hcd = container_of (kref, struct usb_hcd, kref);
 
+        if (usb_hcd_is_primary_hcd(hcd))
+                kfree(hcd->bandwidth_mutex);
+        else
+                hcd->shared_hcd->shared_hcd = NULL;
         kfree(hcd);
 }
 
@@ -2186,6 +2305,54 @@ void usb_put_hcd (struct usb_hcd *hcd)
 }
 EXPORT_SYMBOL_GPL(usb_put_hcd);
 
+int usb_hcd_is_primary_hcd(struct usb_hcd *hcd)
+{
+        if (!hcd->primary_hcd)
+                return 1;
+        return hcd == hcd->primary_hcd;
+}
+EXPORT_SYMBOL_GPL(usb_hcd_is_primary_hcd);
+
+static int usb_hcd_request_irqs(struct usb_hcd *hcd,
+                unsigned int irqnum, unsigned long irqflags)
+{
+        int retval;
+
+        if (hcd->driver->irq) {
+
+                /* IRQF_DISABLED doesn't work as advertised when used together
+                 * with IRQF_SHARED. As usb_hcd_irq() will always disable
+                 * interrupts we can remove it here.
+                 */
+                if (irqflags & IRQF_SHARED)
+                        irqflags &= ~IRQF_DISABLED;
+
+                snprintf(hcd->irq_descr, sizeof(hcd->irq_descr), "%s:usb%d",
+                                hcd->driver->description, hcd->self.busnum);
+                retval = request_irq(irqnum, &usb_hcd_irq, irqflags,
+                                hcd->irq_descr, hcd);
+                if (retval != 0) {
+                        dev_err(hcd->self.controller,
+                                        "request interrupt %d failed\n",
+                                        irqnum);
+                        return retval;
+                }
+                hcd->irq = irqnum;
+                dev_info(hcd->self.controller, "irq %d, %s 0x%08llx\n", irqnum,
+                                (hcd->driver->flags & HCD_MEMORY) ?
+                                        "io mem" : "io base",
+                                        (unsigned long long)hcd->rsrc_start);
+        } else {
+                hcd->irq = -1;
+                if (hcd->rsrc_start)
+                        dev_info(hcd->self.controller, "%s 0x%08llx\n",
+                                        (hcd->driver->flags & HCD_MEMORY) ?
+                                        "io mem" : "io base",
+                                        (unsigned long long)hcd->rsrc_start);
+        }
+        return 0;
+}
+
 /**
  * usb_add_hcd - finish generic HCD structure initialization and register
  * @hcd: the usb_hcd structure to initialize
@@ -2226,7 +2393,7 @@ int usb_add_hcd(struct usb_hcd *hcd,
         }
         hcd->self.root_hub = rhdev;
 
-        switch (hcd->driver->flags & HCD_MASK) {
+        switch (hcd->speed) {
         case HCD_USB11:
                 rhdev->speed = USB_SPEED_FULL;
                 break;
@@ -2237,6 +2404,7 @@ int usb_add_hcd(struct usb_hcd *hcd,
                 rhdev->speed = USB_SPEED_SUPER;
                 break;
         default:
+                retval = -EINVAL;
                 goto err_set_rh_speed;
         }
 
@@ -2246,6 +2414,12 @@ int usb_add_hcd(struct usb_hcd *hcd,
          */
         device_init_wakeup(&rhdev->dev, 1);
 
+        /* HCD_FLAG_RH_RUNNING doesn't matter until the root hub is
+         * registered.  But since the controller can die at any time,
+         * let's initialize the flag before touching the hardware.
+         */
+        set_bit(HCD_FLAG_RH_RUNNING, &hcd->flags);
+
         /* "reset" is misnamed; its role is now one-time init. the controller
          * should already have been reset (and boot firmware kicked off etc).
          */
@@ -2261,38 +2435,15 @@ int usb_add_hcd(struct usb_hcd *hcd,
                 dev_dbg(hcd->self.controller, "supports USB remote wakeup\n");
 
         /* enable irqs just before we start the controller */
-        if (hcd->driver->irq) {
-
-                /* IRQF_DISABLED doesn't work as advertised when used together
-                 * with IRQF_SHARED. As usb_hcd_irq() will always disable
-                 * interrupts we can remove it here.
-                 */
-                if (irqflags & IRQF_SHARED)
-                        irqflags &= ~IRQF_DISABLED;
-
-                snprintf(hcd->irq_descr, sizeof(hcd->irq_descr), "%s:usb%d",
-                                hcd->driver->description, hcd->self.busnum);
-                if ((retval = request_irq(irqnum, &usb_hcd_irq, irqflags,
-                                hcd->irq_descr, hcd)) != 0) {
-                        dev_err(hcd->self.controller,
-                                        "request interrupt %d failed\n", irqnum);
+        if (usb_hcd_is_primary_hcd(hcd)) {
+                retval = usb_hcd_request_irqs(hcd, irqnum, irqflags);
+                if (retval)
                         goto err_request_irq;
-                }
-                hcd->irq = irqnum;
-                dev_info(hcd->self.controller, "irq %d, %s 0x%08llx\n", irqnum,
-                                (hcd->driver->flags & HCD_MEMORY) ?
-                                        "io mem" : "io base",
-                                        (unsigned long long)hcd->rsrc_start);
-        } else {
-                hcd->irq = -1;
-                if (hcd->rsrc_start)
-                        dev_info(hcd->self.controller, "%s 0x%08llx\n",
-                                        (hcd->driver->flags & HCD_MEMORY) ?
-                                        "io mem" : "io base",
-                                        (unsigned long long)hcd->rsrc_start);
         }
 
-        if ((retval = hcd->driver->start(hcd)) < 0) {
+        hcd->state = HC_STATE_RUNNING;
+        retval = hcd->driver->start(hcd);
+        if (retval < 0) {
                 dev_err(hcd->self.controller, "startup error %d\n", retval);
                 goto err_hcd_driver_start;
         }
@@ -2313,6 +2464,7 @@ int usb_add_hcd(struct usb_hcd *hcd,
         return retval;
 
 error_create_attr_group:
+        clear_bit(HCD_FLAG_RH_RUNNING, &hcd->flags);
         if (HC_IS_RUNNING(hcd->state))
                 hcd->state = HC_STATE_QUIESCING;
         spin_lock_irq(&hcd_root_hub_lock);
@@ -2334,7 +2486,7 @@ err_register_root_hub:
         clear_bit(HCD_FLAG_POLL_RH, &hcd->flags);
         del_timer_sync(&hcd->rh_timer);
 err_hcd_driver_start:
-        if (hcd->irq >= 0)
+        if (usb_hcd_is_primary_hcd(hcd) && hcd->irq >= 0)
                 free_irq(irqnum, hcd);
 err_request_irq:
 err_hcd_driver_setup:
@@ -2365,6 +2517,7 @@ void usb_remove_hcd(struct usb_hcd *hcd)
         usb_get_dev(rhdev);
         sysfs_remove_group(&rhdev->dev.kobj, &usb_bus_attr_group);
 
+        clear_bit(HCD_FLAG_RH_RUNNING, &hcd->flags);
         if (HC_IS_RUNNING (hcd->state))
                 hcd->state = HC_STATE_QUIESCING;
 
@@ -2397,8 +2550,10 @@ void usb_remove_hcd(struct usb_hcd *hcd)
         clear_bit(HCD_FLAG_POLL_RH, &hcd->flags);
         del_timer_sync(&hcd->rh_timer);
 
-        if (hcd->irq >= 0)
-                free_irq(hcd->irq, hcd);
+        if (usb_hcd_is_primary_hcd(hcd)) {
+                if (hcd->irq >= 0)
+                        free_irq(hcd->irq, hcd);
+        }
 
         usb_put_dev(hcd->self.root_hub);
         usb_deregister_bus(&hcd->self);
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index 84c1897188d2..a428aa080a36 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -24,7 +24,6 @@
 #include <linux/kthread.h>
 #include <linux/mutex.h>
 #include <linux/freezer.h>
-#include <linux/pm_runtime.h>
 
 #include <asm/uaccess.h>
 #include <asm/byteorder.h>
@@ -83,6 +82,10 @@ struct usb_hub {
         void                    **port_owners;
 };
 
+static inline int hub_is_superspeed(struct usb_device *hdev)
+{
+        return (hdev->descriptor.bDeviceProtocol == 3);
+}
 
 /* Protect struct usb_device->state and ->children members
  * Note: Both are also protected by ->dev.sem, except that ->state can
@@ -152,14 +155,14 @@ EXPORT_SYMBOL_GPL(ehci_cf_port_reset_rwsem);
 
 static int usb_reset_and_verify_device(struct usb_device *udev);
 
-static inline char *portspeed(int portstatus)
+static inline char *portspeed(struct usb_hub *hub, int portstatus)
 {
+        if (hub_is_superspeed(hub->hdev))
+                return "5.0 Gb/s";
         if (portstatus & USB_PORT_STAT_HIGH_SPEED)
                 return "480 Mb/s";
         else if (portstatus & USB_PORT_STAT_LOW_SPEED)
                 return "1.5 Mb/s";
-        else if (portstatus & USB_PORT_STAT_SUPER_SPEED)
-                return "5.0 Gb/s";
         else
                 return "12 Mb/s";
 }
@@ -173,14 +176,23 @@ static struct usb_hub *hdev_to_hub(struct usb_device *hdev)
 }
 
 /* USB 2.0 spec Section 11.24.4.5 */
-static int get_hub_descriptor(struct usb_device *hdev, void *data, int size)
+static int get_hub_descriptor(struct usb_device *hdev, void *data)
 {
-        int i, ret;
+        int i, ret, size;
+        unsigned dtype;
+
+        if (hub_is_superspeed(hdev)) {
+                dtype = USB_DT_SS_HUB;
+                size = USB_DT_SS_HUB_SIZE;
+        } else {
+                dtype = USB_DT_HUB;
+                size = sizeof(struct usb_hub_descriptor);
+        }
 
         for (i = 0; i < 3; i++) {
                 ret = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
                         USB_REQ_GET_DESCRIPTOR, USB_DIR_IN | USB_RT_HUB,
-                        USB_DT_HUB << 8, 0, data, size,
+                        dtype << 8, 0, data, size,
                         USB_CTRL_GET_TIMEOUT);
                 if (ret >= (USB_DT_HUB_NONVAR_SIZE + 2))
                         return ret;
@@ -327,7 +339,8 @@ static int get_hub_status(struct usb_device *hdev,
 {
         int i, status = -ETIMEDOUT;
 
-        for (i = 0; i < USB_STS_RETRIES && status == -ETIMEDOUT; i++) {
+        for (i = 0; i < USB_STS_RETRIES &&
+                        (status == -ETIMEDOUT || status == -EPIPE); i++) {
                 status = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
                         USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_HUB, 0, 0,
                         data, sizeof(*data), USB_STS_TIMEOUT);
@@ -343,7 +356,8 @@ static int get_port_status(struct usb_device *hdev, int port1,
 {
         int i, status = -ETIMEDOUT;
 
-        for (i = 0; i < USB_STS_RETRIES && status == -ETIMEDOUT; i++) {
+        for (i = 0; i < USB_STS_RETRIES &&
+                        (status == -ETIMEDOUT || status == -EPIPE); i++) {
                 status = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
                         USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_PORT, 0, port1,
                         data, sizeof(*data), USB_STS_TIMEOUT);
@@ -366,6 +380,7 @@ static int hub_port_status(struct usb_hub *hub, int port1,
         } else {
                 *status = le16_to_cpu(hub->status->port.wPortStatus);
                 *change = le16_to_cpu(hub->status->port.wPortChange);
+
                 ret = 0;
         }
         mutex_unlock(&hub->status_mutex);
@@ -608,7 +623,7 @@ static int hub_port_disable(struct usb_hub *hub, int port1, int set_state)
         if (hdev->children[port1-1] && set_state)
                 usb_set_device_state(hdev->children[port1-1],
                                 USB_STATE_NOTATTACHED);
-        if (!hub->error)
+        if (!hub->error && !hub_is_superspeed(hub->hdev))
                 ret = clear_port_feature(hdev, port1, USB_PORT_FEAT_ENABLE);
         if (ret)
                 dev_err(hub->intfdev, "cannot disable port %d (err = %d)\n",
@@ -617,7 +632,7 @@ static int hub_port_disable(struct usb_hub *hub, int port1, int set_state)
 }
 
 /*
- * Disable a port and mark a logical connnect-change event, so that some
+ * Disable a port and mark a logical connect-change event, so that some
  * time later khubd will disconnect() any existing usb_device on the port
  * and will re-enumerate if there actually is a device attached.
  */
@@ -677,6 +692,8 @@ static void hub_init_func3(struct work_struct *ws);
 static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)
 {
         struct usb_device *hdev = hub->hdev;
+        struct usb_hcd *hcd;
+        int ret;
         int port1;
         int status;
         bool need_debounce_delay = false;
@@ -715,6 +732,25 @@ static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)
                         usb_autopm_get_interface_no_resume(
                                         to_usb_interface(hub->intfdev));
                         return;         /* Continues at init2: below */
+                } else if (type == HUB_RESET_RESUME) {
+                        /* The internal host controller state for the hub device
+                         * may be gone after a host power loss on system resume.
+                         * Update the device's info so the HW knows it's a hub.
+                         */
+                        hcd = bus_to_hcd(hdev->bus);
+                        if (hcd->driver->update_hub_device) {
+                                ret = hcd->driver->update_hub_device(hcd, hdev,
+                                                &hub->tt, GFP_NOIO);
+                                if (ret < 0) {
+                                        dev_err(hub->intfdev, "Host not "
+                                                        "accepting hub info "
+                                                        "update.\n");
+                                        dev_err(hub->intfdev, "LS/FS devices "
+                                                        "and hubs may not work "
+                                                        "under this hub\n.");
+                                }
+                        }
+                        hub_power_on(hub, true);
                 } else {
                         hub_power_on(hub, true);
                 }
@@ -749,15 +785,14 @@ static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)
                          * USB3 protocol ports will automatically transition
                          * to Enabled state when detect an USB3.0 device attach.
                          * Do not disable USB3 protocol ports.
-                         * FIXME: USB3 root hub and external hubs are treated
-                         * differently here.
                          */
-                        if (hdev->descriptor.bDeviceProtocol != 3 ||
-                            (!hdev->parent &&
-                             !(portstatus & USB_PORT_STAT_SUPER_SPEED))) {
+                        if (!hub_is_superspeed(hdev)) {
                                 clear_port_feature(hdev, port1,
                                                    USB_PORT_FEAT_ENABLE);
                                 portstatus &= ~USB_PORT_STAT_ENABLE;
+                        } else {
+                                /* Pretend that power was lost for USB3 devs */
+                                portstatus &= ~USB_PORT_STAT_ENABLE;
                         }
                 }
 
@@ -772,6 +807,11 @@ static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)
                         clear_port_feature(hub->hdev, port1,
                                         USB_PORT_FEAT_C_ENABLE);
                 }
+                if (portchange & USB_PORT_STAT_C_LINK_STATE) {
+                        need_debounce_delay = true;
+                        clear_port_feature(hub->hdev, port1,
+                                        USB_PORT_FEAT_C_PORT_LINK_STATE);
+                }
 
                 /* We can forget about a "removed" device when there's a
                  * physical disconnect or the connect status changes.
@@ -941,12 +981,23 @@ static int hub_configure(struct usb_hub *hub,
                 goto fail;
         }
 
+        if (hub_is_superspeed(hdev) && (hdev->parent != NULL)) {
+                ret = usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
+                                HUB_SET_DEPTH, USB_RT_HUB,
+                                hdev->level - 1, 0, NULL, 0,
+                                USB_CTRL_SET_TIMEOUT);
+
+                if (ret < 0) {
+                        message = "can't set hub depth";
+                        goto fail;
+                }
+        }
+
         /* Request the entire hub descriptor.
          * hub->descriptor can handle USB_MAXCHILDREN ports,
          * but the hub can/will return fewer bytes here.
          */
-        ret = get_hub_descriptor(hdev, hub->descriptor,
-                        sizeof(*hub->descriptor));
+        ret = get_hub_descriptor(hdev, hub->descriptor);
         if (ret < 0) {
                 message = "can't read hub descriptor";
                 goto fail;
@@ -968,12 +1019,14 @@ static int hub_configure(struct usb_hub *hub,
 
         wHubCharacteristics = le16_to_cpu(hub->descriptor->wHubCharacteristics);
 
-        if (wHubCharacteristics & HUB_CHAR_COMPOUND) {
+        /* FIXME for USB 3.0, skip for now */
+        if ((wHubCharacteristics & HUB_CHAR_COMPOUND) &&
+                        !(hub_is_superspeed(hdev))) {
                 int     i;
                 char    portstr [USB_MAXCHILDREN + 1];
 
                 for (i = 0; i < hdev->maxchild; i++)
-                        portstr[i] = hub->descriptor->DeviceRemovable
+                        portstr[i] = hub->descriptor->u.hs.DeviceRemovable
                                     [((i + 1) / 8)] & (1 << ((i + 1) % 8))
                                 ? 'F' : 'R';
                 portstr[hdev->maxchild] = 0;
@@ -1230,8 +1283,14 @@ static int hub_probe(struct usb_interface *intf, const struct usb_device_id *id)
         desc = intf->cur_altsetting;
         hdev = interface_to_usbdev(intf);
 
-        /* Hubs have proper suspend/resume support */
-        usb_enable_autosuspend(hdev);
+        /* Hubs have proper suspend/resume support.  USB 3.0 device suspend is
+         * different from USB 2.0/1.1 device suspend, and unfortunately we
+         * don't support it yet.  So leave autosuspend disabled for USB 3.0
+         * external hubs for now.  Enable autosuspend for USB 3.0 roothubs,
+         * since that isn't a "real" hub.
+         */
+        if (!hub_is_superspeed(hdev) || !hdev->parent)
+                usb_enable_autosuspend(hdev);
 
         if (hdev->level == MAX_TOPO_LEVEL) {
                 dev_err(&intf->dev,
@@ -1442,6 +1501,7 @@ void usb_set_device_state(struct usb_device *udev,
                 enum usb_device_state new_state)
 {
         unsigned long flags;
+        int wakeup = -1;
 
         spin_lock_irqsave(&device_state_lock, flags);
         if (udev->state == USB_STATE_NOTATTACHED)
@@ -1456,11 +1516,10 @@ void usb_set_device_state(struct usb_device *udev,
                                         || new_state == USB_STATE_SUSPENDED)
                                 ;       /* No change to wakeup settings */
                         else if (new_state == USB_STATE_CONFIGURED)
-                                device_set_wakeup_capable(&udev->dev,
-                                        (udev->actconfig->desc.bmAttributes
-                                         & USB_CONFIG_ATT_WAKEUP));
+                                wakeup = udev->actconfig->desc.bmAttributes
+                                         & USB_CONFIG_ATT_WAKEUP;
                         else
-                                device_set_wakeup_capable(&udev->dev, 0);
+                                wakeup = 0;
                 }
                 if (udev->state == USB_STATE_SUSPENDED &&
                         new_state != USB_STATE_SUSPENDED)
@@ -1472,10 +1531,19 @@ void usb_set_device_state(struct usb_device *udev,
         } else
                 recursively_mark_NOTATTACHED(udev);
         spin_unlock_irqrestore(&device_state_lock, flags);
+        if (wakeup >= 0)
+                device_set_wakeup_capable(&udev->dev, wakeup);
 }
 EXPORT_SYMBOL_GPL(usb_set_device_state);
 
 /*
+ * Choose a device number.
+ *
+ * Device numbers are used as filenames in usbfs.  On USB-1.1 and
+ * USB-2.0 buses they are also used as device addresses, however on
+ * USB-3.0 buses the address is assigned by the controller hardware
+ * and it usually is not the same as the device number.
+ *
  * WUSB devices are simple: they have no hubs behind, so the mapping
  * device <-> virtual port number becomes 1:1. Why? to simplify the
  * life of the device connection logic in
@@ -1497,7 +1565,7 @@ EXPORT_SYMBOL_GPL(usb_set_device_state);
  * the HCD must setup data structures before issuing a set address
  * command to the hardware.
  */
-static void choose_address(struct usb_device *udev)
+static void choose_devnum(struct usb_device *udev)
 {
         int             devnum;
         struct usb_bus  *bus = udev->bus;
@@ -1522,7 +1590,7 @@ static void choose_address(struct usb_device *udev)
         }
 }
 
-static void release_address(struct usb_device *udev)
+static void release_devnum(struct usb_device *udev)
 {
         if (udev->devnum > 0) {
                 clear_bit(udev->devnum, udev->bus->devmap.devicemap);
@@ -1530,7 +1598,7 @@ static void release_address(struct usb_device *udev)
         }
 }
 
-static void update_address(struct usb_device *udev, int devnum)
+static void update_devnum(struct usb_device *udev, int devnum)
 {
         /* The address for a WUSB device is managed by wusbcore. */
         if (!udev->wusb)
@@ -1566,6 +1634,7 @@ void usb_disconnect(struct usb_device **pdev)
 {
         struct usb_device       *udev = *pdev;
         int                     i;
+        struct usb_hcd          *hcd = bus_to_hcd(udev->bus);
 
         if (!udev) {
                 pr_debug ("%s nodev\n", __func__);
@@ -1574,10 +1643,11 @@ void usb_disconnect(struct usb_device **pdev)
 
         /* mark the device as inactive, so any further urb submissions for
          * this device (and any of its children) will fail immediately.
-         * this quiesces everyting except pending urbs.
+         * this quiesces everything except pending urbs.
          */
         usb_set_device_state(udev, USB_STATE_NOTATTACHED);
-        dev_info (&udev->dev, "USB disconnect, address %d\n", udev->devnum);
+        dev_info(&udev->dev, "USB disconnect, device number %d\n",
+                        udev->devnum);
 
         usb_lock_device(udev);
 
@@ -1592,7 +1662,9 @@ void usb_disconnect(struct usb_device **pdev)
          * so that the hardware is now fully quiesced.
          */
         dev_dbg (&udev->dev, "unregistering device\n");
+        mutex_lock(hcd->bandwidth_mutex);
         usb_disable_device(udev, 0);
+        mutex_unlock(hcd->bandwidth_mutex);
         usb_hcd_synchronize_unlinks(udev);
 
         usb_remove_ep_devs(&udev->ep0);
@@ -1607,7 +1679,7 @@ void usb_disconnect(struct usb_device **pdev)
         /* Free the device number and delete the parent's children[]
          * (or root_hub) pointer.
          */
-        release_address(udev);
+        release_devnum(udev);
 
         /* Avoid races with recursively_mark_NOTATTACHED() */
         spin_lock_irq(&device_state_lock);
@@ -1801,8 +1873,15 @@ int usb_new_device(struct usb_device *udev)
 
         /* Tell the runtime-PM framework the device is active */
         pm_runtime_set_active(&udev->dev);
+        pm_runtime_get_noresume(&udev->dev);
+        pm_runtime_use_autosuspend(&udev->dev);
         pm_runtime_enable(&udev->dev);
 
+        /* By default, forbid autosuspend for all devices.  It will be
+         * allowed for hubs during binding.
+         */
+        usb_disable_autosuspend(udev);
+
         err = usb_enumerate_device(udev);       /* Read descriptors */
         if (err < 0)
                 goto fail;
@@ -1828,6 +1907,8 @@ int usb_new_device(struct usb_device *udev)
         }
 
         (void) usb_create_ep_devs(&udev->dev, &udev->ep0, udev);
+        usb_mark_last_busy(udev);
+        pm_runtime_put_sync_autosuspend(&udev->dev);
         return err;
 
 fail:
@@ -1983,7 +2064,7 @@ static int hub_port_wait_reset(struct usb_hub *hub, int port1,
                     (portstatus & USB_PORT_STAT_ENABLE)) {
                         if (hub_is_wusb(hub))
                                 udev->speed = USB_SPEED_WIRELESS;
-                        else if (portstatus & USB_PORT_STAT_SUPER_SPEED)
+                        else if (hub_is_superspeed(hub->hdev))
                                 udev->speed = USB_SPEED_SUPER;
                         else if (portstatus & USB_PORT_STAT_HIGH_SPEED)
                                 udev->speed = USB_SPEED_HIGH;
@@ -2039,7 +2120,7 @@ static int hub_port_reset(struct usb_hub *hub, int port1,
                 case 0:
                         /* TRSTRCY = 10 ms; plus some extra */
                         msleep(10 + 40);
-                        update_address(udev, 0);
+                        update_devnum(udev, 0);
                         if (hcd->driver->reset_device) {
                                 status = hcd->driver->reset_device(hcd, udev);
                                 if (status < 0) {
@@ -2075,11 +2156,76 @@ static int hub_port_reset(struct usb_hub *hub, int port1,
         return status;
 }
 
+/* Warm reset a USB3 protocol port */
+static int hub_port_warm_reset(struct usb_hub *hub, int port)
+{
+        int ret;
+        u16 portstatus, portchange;
+
+        if (!hub_is_superspeed(hub->hdev)) {
+                dev_err(hub->intfdev, "only USB3 hub support warm reset\n");
+                return -EINVAL;
+        }
+
+        /* Warm reset the port */
+        ret = set_port_feature(hub->hdev,
+                                port, USB_PORT_FEAT_BH_PORT_RESET);
+        if (ret) {
+                dev_err(hub->intfdev, "cannot warm reset port %d\n", port);
+                return ret;
+        }
+
+        msleep(20);
+        ret = hub_port_status(hub, port, &portstatus, &portchange);
+
+        if (portchange & USB_PORT_STAT_C_RESET)
+                clear_port_feature(hub->hdev, port, USB_PORT_FEAT_C_RESET);
+
+        if (portchange & USB_PORT_STAT_C_BH_RESET)
+                clear_port_feature(hub->hdev, port,
+                                        USB_PORT_FEAT_C_BH_PORT_RESET);
+
+        if (portchange & USB_PORT_STAT_C_LINK_STATE)
+                clear_port_feature(hub->hdev, port,
+                                        USB_PORT_FEAT_C_PORT_LINK_STATE);
+
+        return ret;
+}
+
+/* Check if a port is power on */
+static int port_is_power_on(struct usb_hub *hub, unsigned portstatus)
+{
+        int ret = 0;
+
+        if (hub_is_superspeed(hub->hdev)) {
+                if (portstatus & USB_SS_PORT_STAT_POWER)
+                        ret = 1;
+        } else {
+                if (portstatus & USB_PORT_STAT_POWER)
+                        ret = 1;
+        }
+
+        return ret;
+}
+
 #ifdef  CONFIG_PM
 
-#define MASK_BITS       (USB_PORT_STAT_POWER | USB_PORT_STAT_CONNECTION | \
-                                USB_PORT_STAT_SUSPEND)
-#define WANT_BITS       (USB_PORT_STAT_POWER | USB_PORT_STAT_CONNECTION)
+/* Check if a port is suspended(USB2.0 port) or in U3 state(USB3.0 port) */
+static int port_is_suspended(struct usb_hub *hub, unsigned portstatus)
+{
+        int ret = 0;
+
+        if (hub_is_superspeed(hub->hdev)) {
+                if ((portstatus & USB_PORT_STAT_LINK_STATE)
+                                == USB_SS_PORT_LS_U3)
+                        ret = 1;
+        } else {
+                if (portstatus & USB_PORT_STAT_SUSPEND)
+                        ret = 1;
+        }
+
+        return ret;
+}
 
 /* Determine whether the device on a port is ready for a normal resume,
  * is ready for a reset-resume, or should be disconnected.
@@ -2089,7 +2235,9 @@ static int check_port_resume_type(struct usb_device *udev,
                 int status, unsigned portchange, unsigned portstatus)
 {
         /* Is the device still present? */
-        if (status || (portstatus & MASK_BITS) != WANT_BITS) {
+        if (status || port_is_suspended(hub, portstatus) ||
+                        !port_is_power_on(hub, portstatus) ||
+                        !(portstatus & USB_PORT_STAT_CONNECTION)) {
                 if (status >= 0)
                         status = -ENODEV;
         }
@@ -2200,7 +2348,13 @@ int usb_port_suspend(struct usb_device *udev, pm_message_t msg)
         }
 
         /* see 7.1.7.6 */
-        status = set_port_feature(hub->hdev, port1, USB_PORT_FEAT_SUSPEND);
+        if (hub_is_superspeed(hub->hdev))
+                status = set_port_feature(hub->hdev,
+                                port1 | (USB_SS_PORT_LS_U3 << 3),
+                                USB_PORT_FEAT_LINK_STATE);
+        else
+                status = set_port_feature(hub->hdev, port1,
+                                                USB_PORT_FEAT_SUSPEND);
         if (status) {
                 dev_dbg(hub->intfdev, "can't suspend port %d, status %d\n",
                                 port1, status);
@@ -2211,6 +2365,10 @@ int usb_port_suspend(struct usb_device *udev, pm_message_t msg)
                                 USB_DEVICE_REMOTE_WAKEUP, 0,
                                 NULL, 0,
                                 USB_CTRL_SET_TIMEOUT);
+
+                /* System sleep transitions should never fail */
+                if (!(msg.event & PM_EVENT_AUTO))
+                        status = 0;
         } else {
                 /* device has up to 10 msec to fully suspend */
                 dev_dbg(&udev->dev, "usb %ssuspend\n",
@@ -2218,6 +2376,7 @@ int usb_port_suspend(struct usb_device *udev, pm_message_t msg)
                 usb_set_device_state(udev, USB_STATE_SUSPENDED);
                 msleep(10);
         }
+        usb_mark_last_busy(hub->hdev);
         return status;
 }
 
@@ -2343,7 +2502,7 @@ int usb_port_resume(struct usb_device *udev, pm_message_t msg)
 
         /* Skip the initial Clear-Suspend step for a remote wakeup */
         status = hub_port_status(hub, port1, &portstatus, &portchange);
-        if (status == 0 && !(portstatus & USB_PORT_STAT_SUSPEND))
+        if (status == 0 && !port_is_suspended(hub, portstatus))
                 goto SuspendCleared;
 
         // dev_dbg(hub->intfdev, "resume port %d\n", port1);
@@ -2351,8 +2510,13 @@ int usb_port_resume(struct usb_device *udev, pm_message_t msg)
         set_bit(port1, hub->busy_bits);
 
         /* see 7.1.7.7; affects power usage, but not budgeting */
-        status = clear_port_feature(hub->hdev,
-                        port1, USB_PORT_FEAT_SUSPEND);
+        if (hub_is_superspeed(hub->hdev))
+                status = set_port_feature(hub->hdev,
+                                port1 | (USB_SS_PORT_LS_U0 << 3),
+                                USB_PORT_FEAT_LINK_STATE);
+        else
+                status = clear_port_feature(hub->hdev,
+                                port1, USB_PORT_FEAT_SUSPEND);
         if (status) {
                 dev_dbg(hub->intfdev, "can't resume port %d, status %d\n",
                                 port1, status);
@@ -2374,9 +2538,15 @@ int usb_port_resume(struct usb_device *udev, pm_message_t msg)
 
  SuspendCleared:
         if (status == 0) {
-                if (portchange & USB_PORT_STAT_C_SUSPEND)
-                        clear_port_feature(hub->hdev, port1,
-                                        USB_PORT_FEAT_C_SUSPEND);
+                if (hub_is_superspeed(hub->hdev)) {
+                        if (portchange & USB_PORT_STAT_C_LINK_STATE)
+                                clear_port_feature(hub->hdev, port1,
+                                        USB_PORT_FEAT_C_PORT_LINK_STATE);
+                } else {
+                        if (portchange & USB_PORT_STAT_C_SUSPEND)
+                                clear_port_feature(hub->hdev, port1,
+                                                USB_PORT_FEAT_C_SUSPEND);
+                }
         }
 
         clear_bit(port1, hub->busy_bits);
@@ -2448,16 +2618,15 @@ static int hub_suspend(struct usb_interface *intf, pm_message_t msg)
         struct usb_device       *hdev = hub->hdev;
         unsigned                port1;
 
-        /* fail if children aren't already suspended */
+        /* Warn if children aren't already suspended */
         for (port1 = 1; port1 <= hdev->maxchild; port1++) {
                 struct usb_device       *udev;
 
                 udev = hdev->children [port1-1];
                 if (udev && udev->can_submit) {
-                        if (!(msg.event & PM_EVENT_AUTO))
-                                dev_dbg(&intf->dev, "port %d nyet suspended\n",
-                                                port1);
-                        return -EBUSY;
+                        dev_warn(&intf->dev, "port %d nyet suspended\n", port1);
+                        if (msg.event & PM_EVENT_AUTO)
+                                return -EBUSY;
                 }
         }
 
@@ -2594,16 +2763,14 @@ static int hub_set_address(struct usb_device *udev, int devnum)
                 return 0;
         if (udev->state != USB_STATE_DEFAULT)
                 return -EINVAL;
-        if (hcd->driver->address_device) {
+        if (hcd->driver->address_device)
                 retval = hcd->driver->address_device(hcd, udev);
-        } else {
+        else
                 retval = usb_control_msg(udev, usb_sndaddr0pipe(),
                                 USB_REQ_SET_ADDRESS, 0, devnum, 0,
                                 NULL, 0, USB_CTRL_SET_TIMEOUT);
-                if (retval == 0)
-                        update_address(udev, devnum);
-        }
         if (retval == 0) {
+                update_devnum(udev, devnum);
                 /* Device now using proper address. */
                 usb_set_device_state(udev, USB_STATE_ADDRESS);
                 usb_ep0_reinit(udev);
@@ -2650,17 +2817,13 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
 
         mutex_lock(&usb_address0_mutex);
 
-        if (!udev->config && oldspeed == USB_SPEED_SUPER) {
-                /* Don't reset USB 3.0 devices during an initial setup */
-                usb_set_device_state(udev, USB_STATE_DEFAULT);
-        } else {
-                /* Reset the device; full speed may morph to high speed */
-                /* FIXME a USB 2.0 device may morph into SuperSpeed on reset. */
-                retval = hub_port_reset(hub, port1, udev, delay);
-                if (retval < 0)         /* error or disconnect */
-                        goto fail;
-                /* success, speed is known */
-        }
+        /* Reset the device; full speed may morph to high speed */
+        /* FIXME a USB 2.0 device may morph into SuperSpeed on reset. */
+        retval = hub_port_reset(hub, port1, udev, delay);
+        if (retval < 0)         /* error or disconnect */
+                goto fail;
+        /* success, speed is known */
+
         retval = -ENODEV;
 
         if (oldspeed != USB_SPEED_UNKNOWN && oldspeed != udev->speed) {
@@ -2712,9 +2875,9 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
         }
         if (udev->speed != USB_SPEED_SUPER)
                 dev_info(&udev->dev,
-                                "%s %s speed %sUSB device using %s and address %d\n",
+                                "%s %s speed %sUSB device number %d using %s\n",
                                 (udev->config) ? "reset" : "new", speed, type,
-                                udev->bus->controller->driver->name, devnum);
+                                devnum, udev->bus->controller->driver->name);
 
         /* Set up TT records, if needed  */
         if (hdev->tt) {
@@ -2722,6 +2885,11 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
                 udev->ttport = hdev->ttport;
         } else if (udev->speed != USB_SPEED_HIGH
                         && hdev->speed == USB_SPEED_HIGH) {
+                if (!hub->tt.hub) {
+                        dev_err(&udev->dev, "parent hub has no TT\n");
+                        retval = -EINVAL;
+                        goto fail;
+                }
                 udev->tt = &hub->tt;
                 udev->ttport = port1;
         }
@@ -2739,10 +2907,6 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
          * value.
          */
         for (i = 0; i < GET_DESCRIPTOR_TRIES; (++i, msleep(100))) {
-                /*
-                 * An xHCI controller cannot send any packets to a device until
-                 * a set address command successfully completes.
-                 */
                 if (USE_NEW_SCHEME(retry_counter) && !(hcd->driver->flags & HCD_USB3)) {
                         struct usb_device_descriptor *buf;
                         int r = 0;
@@ -2825,9 +2989,9 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
                         if (udev->speed == USB_SPEED_SUPER) {
                                 devnum = udev->devnum;
                                 dev_info(&udev->dev,
-                                                "%s SuperSpeed USB device using %s and address %d\n",
+                                                "%s SuperSpeed USB device number %d using %s\n",
                                                 (udev->config) ? "reset" : "new",
-                                                udev->bus->controller->driver->name, devnum);
+                                                devnum, udev->bus->controller->driver->name);
                         }
 
                         /* cope with hardware quirkiness:
@@ -2860,13 +3024,16 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
         else
                 i = udev->descriptor.bMaxPacketSize0;
         if (le16_to_cpu(udev->ep0.desc.wMaxPacketSize) != i) {
-                if (udev->speed != USB_SPEED_FULL ||
+                if (udev->speed == USB_SPEED_LOW ||
                                 !(i == 8 || i == 16 || i == 32 || i == 64)) {
-                        dev_err(&udev->dev, "ep0 maxpacket = %d\n", i);
+                        dev_err(&udev->dev, "Invalid ep0 maxpacket: %d\n", i);
                         retval = -EMSGSIZE;
                         goto fail;
                 }
-                dev_dbg(&udev->dev, "ep0 maxpacket = %d\n", i);
+                if (udev->speed == USB_SPEED_FULL)
+                        dev_dbg(&udev->dev, "ep0 maxpacket = %d\n", i);
+                else
+                        dev_warn(&udev->dev, "Using ep0 maxpacket: %d\n", i);
                 udev->ep0.desc.wMaxPacketSize = cpu_to_le16(i);
                 usb_ep0_reinit(udev);
         }
@@ -2887,7 +3054,7 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
 fail:
         if (retval) {
                 hub_port_disable(hub, port1, 0);
-                update_address(udev, devnum);   /* for disconnect processing */
+                update_devnum(udev, devnum);    /* for disconnect processing */
         }
         mutex_unlock(&usb_address0_mutex);
         return retval;
@@ -2978,7 +3145,7 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1,
 
         dev_dbg (hub_dev,
                 "port %d, status %04x, change %04x, %s\n",
-                port1, portstatus, portchange, portspeed (portstatus));
+                port1, portstatus, portchange, portspeed(hub, portstatus));
 
         if (hub->has_indicators) {
                 set_port_led(hub, port1, HUB_LED_AUTO);
@@ -3053,7 +3220,7 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1,
 
                 /* maybe switch power back on (e.g. root hub was reset) */
                 if ((wHubCharacteristics & HUB_CHAR_LPSM) < 2
-                                && !(portstatus & USB_PORT_STAT_POWER))
+                                && !port_is_power_on(hub, portstatus))
                         set_port_feature(hdev, port1, USB_PORT_FEAT_POWER);
 
                 if (portstatus & USB_PORT_STAT_ENABLE)
@@ -3079,34 +3246,16 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1,
                 udev->level = hdev->level + 1;
                 udev->wusb = hub_is_wusb(hub);
 
-                /*
-                 * USB 3.0 devices are reset automatically before the connect
-                 * port status change appears, and the root hub port status
-                 * shows the correct speed.  We also get port change
-                 * notifications for USB 3.0 devices from the USB 3.0 portion of
-                 * an external USB 3.0 hub, but this isn't handled correctly yet
-                 * FIXME.
-                 */
-
-                if (!(hcd->driver->flags & HCD_USB3))
-                        udev->speed = USB_SPEED_UNKNOWN;
-                else if ((hdev->parent == NULL) &&
-                                (portstatus & USB_PORT_STAT_SUPER_SPEED))
+                /* Only USB 3.0 devices are connected to SuperSpeed hubs. */
+                if (hub_is_superspeed(hub->hdev))
                         udev->speed = USB_SPEED_SUPER;
                 else
                         udev->speed = USB_SPEED_UNKNOWN;
 
-                /*
-                 * xHCI needs to issue an address device command later
-                 * in the hub_port_init sequence for SS/HS/FS/LS devices.
-                 */
-                if (!(hcd->driver->flags & HCD_USB3)) {
-                        /* set the address */
-                        choose_address(udev);
-                        if (udev->devnum <= 0) {
-                                status = -ENOTCONN;     /* Don't retry */
-                                goto loop;
-                        }
+                choose_devnum(udev);
+                if (udev->devnum <= 0) {
+                        status = -ENOTCONN;     /* Don't retry */
+                        goto loop;
                 }
 
                 /* reset (non-USB 3.0 devices) and get descriptor */
@@ -3195,7 +3344,7 @@ loop_disable:
                 hub_port_disable(hub, port1, 1);
 loop:
                 usb_ep0_reinit(udev);
-                release_address(udev);
+                release_devnum(udev);
                 hub_free_dev(udev);
                 usb_put_dev(udev);
                 if ((status == -ENOTCONN) || (status == -ENOTSUPP))
@@ -3372,12 +3521,19 @@ static void hub_events(void)
                         }
                         
                         if (portchange & USB_PORT_STAT_C_OVERCURRENT) {
-                                dev_err (hub_dev,
-                                        "over-current change on port %d\n",
-                                        i);
+                                u16 status = 0;
+                                u16 unused;
+
+                                dev_dbg(hub_dev, "over-current change on port "
+                                        "%d\n", i);
                                 clear_port_feature(hdev, i,
                                         USB_PORT_FEAT_C_OVER_CURRENT);
+                                msleep(100);    /* Cool down */
                                 hub_power_on(hub, true);
+                                hub_port_status(hub, i, &status, &unused);
+                                if (status & USB_PORT_STAT_OVERCURRENT)
+                                        dev_err(hub_dev, "over-current "
+                                                "condition on port %d\n", i);
                         }
 
                         if (portchange & USB_PORT_STAT_C_RESET) {
@@ -3387,6 +3543,35 @@ static void hub_events(void)
                                 clear_port_feature(hdev, i,
                                         USB_PORT_FEAT_C_RESET);
                         }
+                        if ((portchange & USB_PORT_STAT_C_BH_RESET) &&
+                                        hub_is_superspeed(hub->hdev)) {
+                                dev_dbg(hub_dev,
+                                        "warm reset change on port %d\n",
+                                        i);
+                                clear_port_feature(hdev, i,
+                                        USB_PORT_FEAT_C_BH_PORT_RESET);
+                        }
+                        if (portchange & USB_PORT_STAT_C_LINK_STATE) {
+                                clear_port_feature(hub->hdev, i,
+                                                USB_PORT_FEAT_C_PORT_LINK_STATE);
+                        }
+                        if (portchange & USB_PORT_STAT_C_CONFIG_ERROR) {
+                                dev_warn(hub_dev,
+                                        "config error on port %d\n",
+                                        i);
+                                clear_port_feature(hub->hdev, i,
+                                                USB_PORT_FEAT_C_PORT_CONFIG_ERROR);
+                        }
+
+                        /* Warm reset a USB3 protocol port if it's in
+                         * SS.Inactive state.
+                         */
+                        if (hub_is_superspeed(hub->hdev) &&
+                                (portstatus & USB_PORT_STAT_LINK_STATE)
+                                        == USB_SS_PORT_LS_SS_INACTIVE) {
+                                dev_dbg(hub_dev, "warm reset port %d\n", i);
+                                hub_port_warm_reset(hub, i);
+                        }
 
                         if (connect_change)
                                 hub_port_connect_change(hub, i,
@@ -3409,10 +3594,17 @@ static void hub_events(void)
                                         hub->limited_power = 0;
                         }
                         if (hubchange & HUB_CHANGE_OVERCURRENT) {
-                                dev_dbg (hub_dev, "overcurrent change\n");
-                                msleep(500);    /* Cool down */
+                                u16 status = 0;
+                                u16 unused;
+
+                                dev_dbg(hub_dev, "over-current change\n");
                                 clear_hub_feature(hdev, C_HUB_OVER_CURRENT);
+                                msleep(500);    /* Cool down */
                                 hub_power_on(hub, true);
+                                hub_hub_status(hub, &status, &unused);
+                                if (status & HUB_STATUS_OVERCURRENT)
+                                        dev_err(hub_dev, "over-current "
+                                                "condition\n");
                         }
                 }
 
@@ -3629,7 +3821,7 @@ static int usb_reset_and_verify_device(struct usb_device *udev)
         }
 
         if (!parent_hdev) {
-                /* this requires hcd-specific logic; see OHCI hc_restart() */
+                /* this requires hcd-specific logic; see ohci_restart() */
                 dev_dbg(&udev->dev, "%s for root hub!\n", __func__);
                 return -EISDIR;
         }
@@ -3661,13 +3853,13 @@ static int usb_reset_and_verify_device(struct usb_device *udev)
         if (!udev->actconfig)
                 goto done;
 
-        mutex_lock(&hcd->bandwidth_mutex);
+        mutex_lock(hcd->bandwidth_mutex);
         ret = usb_hcd_alloc_bandwidth(udev, udev->actconfig, NULL, NULL);
         if (ret < 0) {
                 dev_warn(&udev->dev,
                                 "Busted HC?  Not enough HCD resources for "
                                 "old configuration.\n");
-                mutex_unlock(&hcd->bandwidth_mutex);
+                mutex_unlock(hcd->bandwidth_mutex);
                 goto re_enumerate;
         }
         ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
@@ -3678,10 +3870,10 @@ static int usb_reset_and_verify_device(struct usb_device *udev)
                 dev_err(&udev->dev,
                         "can't restore configuration #%d (error=%d)\n",
                         udev->actconfig->desc.bConfigurationValue, ret);
-                mutex_unlock(&hcd->bandwidth_mutex);
+                mutex_unlock(hcd->bandwidth_mutex);
                 goto re_enumerate;
         }
-        mutex_unlock(&hcd->bandwidth_mutex);
+        mutex_unlock(hcd->bandwidth_mutex);
         usb_set_device_state(udev, USB_STATE_CONFIGURED);
 
         /* Put interfaces back into the same altsettings as before.
diff --git a/drivers/usb/core/inode.c b/drivers/usb/core/inode.c
index 095fa5366690..2278dad886e2 100644
--- a/drivers/usb/core/inode.c
+++ b/drivers/usb/core/inode.c
@@ -39,7 +39,6 @@
 #include <linux/parser.h>
 #include <linux/notifier.h>
 #include <linux/seq_file.h>
-#include <linux/smp_lock.h>
 #include <linux/usb/hcd.h>
 #include <asm/byteorder.h>
 #include "usb.h"
@@ -276,6 +275,7 @@ static struct inode *usbfs_get_inode (struct super_block *sb, int mode, dev_t de
         struct inode *inode = new_inode(sb);
 
         if (inode) {
+                inode->i_ino = get_next_ino();
                 inode->i_mode = mode;
                 inode->i_uid = current_fsuid();
                 inode->i_gid = current_fsgid();
@@ -343,17 +343,19 @@ static int usbfs_empty (struct dentry *dentry)
 {
         struct list_head *list;
 
-        spin_lock(&dcache_lock);
-
+        spin_lock(&dentry->d_lock);
         list_for_each(list, &dentry->d_subdirs) {
                 struct dentry *de = list_entry(list, struct dentry, d_u.d_child);
+
+                spin_lock_nested(&de->d_lock, DENTRY_D_LOCK_NESTED);
                 if (usbfs_positive(de)) {
-                        spin_unlock(&dcache_lock);
+                        spin_unlock(&de->d_lock);
+                        spin_unlock(&dentry->d_lock);
                         return 0;
                 }
+                spin_unlock(&de->d_lock);
         }
-
-        spin_unlock(&dcache_lock);
+        spin_unlock(&dentry->d_lock);
         return 1;
 }
 
@@ -387,7 +389,6 @@ static int usbfs_rmdir(struct inode *dir, struct dentry *dentry)
         mutex_unlock(&inode->i_mutex);
         if (!error)
                 d_delete(dentry);
-        dput(dentry);
         return error;
 }
 
@@ -573,16 +574,16 @@ static void fs_remove_file (struct dentry *dentry)
 
 /* --------------------------------------------------------------------- */
 
-static int usb_get_sb(struct file_system_type *fs_type,
-        int flags, const char *dev_name, void *data, struct vfsmount *mnt)
+static struct dentry *usb_mount(struct file_system_type *fs_type,
+        int flags, const char *dev_name, void *data)
 {
-        return get_sb_single(fs_type, flags, data, usbfs_fill_super, mnt);
+        return mount_single(fs_type, flags, data, usbfs_fill_super);
 }
 
 static struct file_system_type usb_fs_type = {
         .owner =        THIS_MODULE,
         .name =         "usbfs",
-        .get_sb =       usb_get_sb,
+        .mount =        usb_mount,
         .kill_sb =      kill_litter_super,
 };
 
diff --git a/drivers/usb/core/message.c b/drivers/usb/core/message.c
index 9f0ce7de0e36..0b5ec234c787 100644
--- a/drivers/usb/core/message.c
+++ b/drivers/usb/core/message.c
@@ -1135,22 +1135,26 @@ void usb_disable_interface(struct usb_device *dev, struct usb_interface *intf,
  * Deallocates hcd/hardware state for the endpoints (nuking all or most
  * pending urbs) and usbcore state for the interfaces, so that usbcore
  * must usb_set_configuration() before any interfaces could be used.
+ *
+ * Must be called with hcd->bandwidth_mutex held.
  */
 void usb_disable_device(struct usb_device *dev, int skip_ep0)
 {
         int i;
-
-        dev_dbg(&dev->dev, "%s nuking %s URBs\n", __func__,
-                skip_ep0 ? "non-ep0" : "all");
-        for (i = skip_ep0; i < 16; ++i) {
-                usb_disable_endpoint(dev, i, true);
-                usb_disable_endpoint(dev, i + USB_DIR_IN, true);
-        }
+        struct usb_hcd *hcd = bus_to_hcd(dev->bus);
 
         /* getting rid of interfaces will disconnect
          * any drivers bound to them (a key side effect)
          */
         if (dev->actconfig) {
+                /*
+                 * FIXME: In order to avoid self-deadlock involving the
+                 * bandwidth_mutex, we have to mark all the interfaces
+                 * before unregistering any of them.
+                 */
+                for (i = 0; i < dev->actconfig->desc.bNumInterfaces; i++)
+                        dev->actconfig->interface[i]->unregistering = 1;
+
                 for (i = 0; i < dev->actconfig->desc.bNumInterfaces; i++) {
                         struct usb_interface    *interface;
 
@@ -1160,7 +1164,6 @@ void usb_disable_device(struct usb_device *dev, int skip_ep0)
                                 continue;
                         dev_dbg(&dev->dev, "unregistering interface %s\n",
                                 dev_name(&interface->dev));
-                        interface->unregistering = 1;
                         remove_intf_ep_devs(interface);
                         device_del(&interface->dev);
                 }
@@ -1176,6 +1179,23 @@ void usb_disable_device(struct usb_device *dev, int skip_ep0)
                 if (dev->state == USB_STATE_CONFIGURED)
                         usb_set_device_state(dev, USB_STATE_ADDRESS);
         }
+
+        dev_dbg(&dev->dev, "%s nuking %s URBs\n", __func__,
+                skip_ep0 ? "non-ep0" : "all");
+        if (hcd->driver->check_bandwidth) {
+                /* First pass: Cancel URBs, leave endpoint pointers intact. */
+                for (i = skip_ep0; i < 16; ++i) {
+                        usb_disable_endpoint(dev, i, false);
+                        usb_disable_endpoint(dev, i + USB_DIR_IN, false);
+                }
+                /* Remove endpoints from the host controller internal state */
+                usb_hcd_alloc_bandwidth(dev, NULL, NULL, NULL);
+                /* Second pass: remove endpoint pointers */
+        }
+        for (i = skip_ep0; i < 16; ++i) {
+                usb_disable_endpoint(dev, i, true);
+                usb_disable_endpoint(dev, i + USB_DIR_IN, true);
+        }
 }
 
 /**
@@ -1273,6 +1293,8 @@ int usb_set_interface(struct usb_device *dev, int interface, int alternate)
                         interface);
                 return -EINVAL;
         }
+        if (iface->unregistering)
+                return -ENODEV;
 
         alt = usb_altnum_to_altsetting(iface, alternate);
         if (!alt) {
@@ -1284,12 +1306,12 @@ int usb_set_interface(struct usb_device *dev, int interface, int alternate)
         /* Make sure we have enough bandwidth for this alternate interface.
          * Remove the current alt setting and add the new alt setting.
          */
-        mutex_lock(&hcd->bandwidth_mutex);
+        mutex_lock(hcd->bandwidth_mutex);
         ret = usb_hcd_alloc_bandwidth(dev, NULL, iface->cur_altsetting, alt);
         if (ret < 0) {
                 dev_info(&dev->dev, "Not enough bandwidth for altsetting %d\n",
                                 alternate);
-                mutex_unlock(&hcd->bandwidth_mutex);
+                mutex_unlock(hcd->bandwidth_mutex);
                 return ret;
         }
 
@@ -1311,10 +1333,10 @@ int usb_set_interface(struct usb_device *dev, int interface, int alternate)
         } else if (ret < 0) {
                 /* Re-instate the old alt setting */
                 usb_hcd_alloc_bandwidth(dev, NULL, alt, iface->cur_altsetting);
-                mutex_unlock(&hcd->bandwidth_mutex);
+                mutex_unlock(hcd->bandwidth_mutex);
                 return ret;
         }
-        mutex_unlock(&hcd->bandwidth_mutex);
+        mutex_unlock(hcd->bandwidth_mutex);
 
         /* FIXME drivers shouldn't need to replicate/bugfix the logic here
          * when they implement async or easily-killable versions of this or
@@ -1413,7 +1435,7 @@ int usb_reset_configuration(struct usb_device *dev)
 
         config = dev->actconfig;
         retval = 0;
-        mutex_lock(&hcd->bandwidth_mutex);
+        mutex_lock(hcd->bandwidth_mutex);
         /* Make sure we have enough bandwidth for each alternate setting 0 */
         for (i = 0; i < config->desc.bNumInterfaces; i++) {
                 struct usb_interface *intf = config->interface[i];
@@ -1442,7 +1464,7 @@ reset_old_alts:
                                 usb_hcd_alloc_bandwidth(dev, NULL,
                                                 alt, intf->cur_altsetting);
                 }
-                mutex_unlock(&hcd->bandwidth_mutex);
+                mutex_unlock(hcd->bandwidth_mutex);
                 return retval;
         }
         retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
@@ -1451,7 +1473,7 @@ reset_old_alts:
                         NULL, 0, USB_CTRL_SET_TIMEOUT);
         if (retval < 0)
                 goto reset_old_alts;
-        mutex_unlock(&hcd->bandwidth_mutex);
+        mutex_unlock(hcd->bandwidth_mutex);
 
         /* re-init hc/hcd interface/endpoint state */
         for (i = 0; i < config->desc.bNumInterfaces; i++) {
@@ -1727,6 +1749,7 @@ free_interfaces:
         /* if it's already configured, clear out old state first.
          * getting rid of old interfaces means unbinding their drivers.
          */
+        mutex_lock(hcd->bandwidth_mutex);
         if (dev->state != USB_STATE_ADDRESS)
                 usb_disable_device(dev, 1);     /* Skip ep0 */
 
@@ -1739,10 +1762,9 @@ free_interfaces:
          * host controller will not allow submissions to dropped endpoints.  If
          * this call fails, the device state is unchanged.
          */
-        mutex_lock(&hcd->bandwidth_mutex);
         ret = usb_hcd_alloc_bandwidth(dev, cp, NULL, NULL);
         if (ret < 0) {
-                mutex_unlock(&hcd->bandwidth_mutex);
+                mutex_unlock(hcd->bandwidth_mutex);
                 usb_autosuspend_device(dev);
                 goto free_interfaces;
         }
@@ -1761,11 +1783,11 @@ free_interfaces:
         if (!cp) {
                 usb_set_device_state(dev, USB_STATE_ADDRESS);
                 usb_hcd_alloc_bandwidth(dev, NULL, NULL, NULL);
-                mutex_unlock(&hcd->bandwidth_mutex);
+                mutex_unlock(hcd->bandwidth_mutex);
                 usb_autosuspend_device(dev);
                 goto free_interfaces;
         }
-        mutex_unlock(&hcd->bandwidth_mutex);
+        mutex_unlock(hcd->bandwidth_mutex);
         usb_set_device_state(dev, USB_STATE_CONFIGURED);
 
         /* Initialize the new interface structures and the
@@ -1804,6 +1826,7 @@ free_interfaces:
                 INIT_WORK(&intf->reset_ws, __usb_queue_reset_device);
                 intf->minor = -1;
                 device_initialize(&intf->dev);
+                pm_runtime_no_callbacks(&intf->dev);
                 dev_set_name(&intf->dev, "%d-%s:%d.%d",
                         dev->bus->busnum, dev->devpath,
                         configuration, alt->desc.bInterfaceNumber);
diff --git a/drivers/usb/core/quirks.c b/drivers/usb/core/quirks.c
index 25719da45e33..81ce6a8e1d94 100644
--- a/drivers/usb/core/quirks.c
+++ b/drivers/usb/core/quirks.c
@@ -48,6 +48,10 @@ static const struct usb_device_id usb_quirk_list[] = {
         { USB_DEVICE(0x04b4, 0x0526), .driver_info =
                         USB_QUIRK_CONFIG_INTF_STRINGS },
 
+        /* Samsung Android phone modem - ID conflict with SPH-I500 */
+        { USB_DEVICE(0x04e8, 0x6601), .driver_info =
+                        USB_QUIRK_CONFIG_INTF_STRINGS },
+
         /* Roland SC-8820 */
         { USB_DEVICE(0x0582, 0x0007), .driver_info = USB_QUIRK_RESET_RESUME },
 
@@ -68,6 +72,10 @@ static const struct usb_device_id usb_quirk_list[] = {
         /* M-Systems Flash Disk Pioneers */
         { USB_DEVICE(0x08ec, 0x1000), .driver_info = USB_QUIRK_RESET_RESUME },
 
+        /* Keytouch QWERTY Panel keyboard */
+        { USB_DEVICE(0x0926, 0x3333), .driver_info =
+                        USB_QUIRK_CONFIG_INTF_STRINGS },
+
         /* X-Rite/Gretag-Macbeth Eye-One Pro display colorimeter */
         { USB_DEVICE(0x0971, 0x2000), .driver_info = USB_QUIRK_NO_SET_INTF },
 
@@ -117,21 +125,6 @@ void usb_detect_quirks(struct usb_device *udev)
                 dev_dbg(&udev->dev, "USB quirks for this device: %x\n",
                                 udev->quirks);
 
-#ifdef  CONFIG_USB_SUSPEND
-
-        /* By default, disable autosuspend for all devices.  The hub driver
-         * will enable it for hubs.
-         */
-        usb_disable_autosuspend(udev);
-
-        /* Autosuspend can also be disabled if the initial autosuspend_delay
-         * is negative.
-         */
-        if (udev->autosuspend_delay < 0)
-                usb_autoresume_device(udev);
-
-#endif
-
         /* For the present, all devices default to USB-PERSIST enabled */
 #if 0           /* was: #ifdef CONFIG_PM */
         /* Hubs are automatically enabled for USB-PERSIST */
diff --git a/drivers/usb/core/sysfs.c b/drivers/usb/core/sysfs.c
index 448f5b47fc48..cf05b97693ea 100644
--- a/drivers/usb/core/sysfs.c
+++ b/drivers/usb/core/sysfs.c
@@ -233,8 +233,6 @@ static DEVICE_ATTR(urbnum, S_IRUGO, show_urbnum, NULL);
 
 #ifdef  CONFIG_PM
 
-static const char power_group[] = "power";
-
 static ssize_t
 show_persist(struct device *dev, struct device_attribute *attr, char *buf)
 {
@@ -278,7 +276,7 @@ static int add_persist_attributes(struct device *dev)
                 if (udev->descriptor.bDeviceClass != USB_CLASS_HUB)
                         rc = sysfs_add_file_to_group(&dev->kobj,
                                         &dev_attr_persist.attr,
-                                        power_group);
+                                        power_group_name);
         }
         return rc;
 }
@@ -287,7 +285,7 @@ static void remove_persist_attributes(struct device *dev)
 {
         sysfs_remove_file_from_group(&dev->kobj,
                         &dev_attr_persist.attr,
-                        power_group);
+                        power_group_name);
 }
 #else
 
@@ -336,44 +334,20 @@ static DEVICE_ATTR(active_duration, S_IRUGO, show_active_duration, NULL);
 static ssize_t
 show_autosuspend(struct device *dev, struct device_attribute *attr, char *buf)
 {
-        struct usb_device *udev = to_usb_device(dev);
-
-        return sprintf(buf, "%d\n", udev->autosuspend_delay / HZ);
+        return sprintf(buf, "%d\n", dev->power.autosuspend_delay / 1000);
 }
 
 static ssize_t
 set_autosuspend(struct device *dev, struct device_attribute *attr,
                 const char *buf, size_t count)
 {
-        struct usb_device *udev = to_usb_device(dev);
-        int value, old_delay;
-        int rc;
+        int value;
 
-        if (sscanf(buf, "%d", &value) != 1 || value >= INT_MAX/HZ ||
-                        value <= - INT_MAX/HZ)
+        if (sscanf(buf, "%d", &value) != 1 || value >= INT_MAX/1000 ||
+                        value <= -INT_MAX/1000)
                 return -EINVAL;
-        value *= HZ;
-
-        usb_lock_device(udev);
-        old_delay = udev->autosuspend_delay;
-        udev->autosuspend_delay = value;
-
-        if (old_delay < 0) {    /* Autosuspend wasn't allowed */
-                if (value >= 0)
-                        usb_autosuspend_device(udev);
-        } else {                /* Autosuspend was allowed */
-                if (value < 0) {
-                        rc = usb_autoresume_device(udev);
-                        if (rc < 0) {
-                                count = rc;
-                                udev->autosuspend_delay = old_delay;
-                        }
-                } else {
-                        usb_try_autosuspend_device(udev);
-                }
-        }
 
-        usb_unlock_device(udev);
+        pm_runtime_set_autosuspend_delay(dev, value * 1000);
         return count;
 }
 
@@ -438,44 +412,30 @@ set_level(struct device *dev, struct device_attribute *attr,
 
 static DEVICE_ATTR(level, S_IRUGO | S_IWUSR, show_level, set_level);
 
+static struct attribute *power_attrs[] = {
+        &dev_attr_autosuspend.attr,
+        &dev_attr_level.attr,
+        &dev_attr_connected_duration.attr,
+        &dev_attr_active_duration.attr,
+        NULL,
+};
+static struct attribute_group power_attr_group = {
+        .name   = power_group_name,
+        .attrs  = power_attrs,
+};
+
 static int add_power_attributes(struct device *dev)
 {
         int rc = 0;
 
-        if (is_usb_device(dev)) {
-                rc = sysfs_add_file_to_group(&dev->kobj,
-                                &dev_attr_autosuspend.attr,
-                                power_group);
-                if (rc == 0)
-                        rc = sysfs_add_file_to_group(&dev->kobj,
-                                        &dev_attr_level.attr,
-                                        power_group);
-                if (rc == 0)
-                        rc = sysfs_add_file_to_group(&dev->kobj,
-                                        &dev_attr_connected_duration.attr,
-                                        power_group);
-                if (rc == 0)
-                        rc = sysfs_add_file_to_group(&dev->kobj,
-                                        &dev_attr_active_duration.attr,
-                                        power_group);
-        }
+        if (is_usb_device(dev))
+                rc = sysfs_merge_group(&dev->kobj, &power_attr_group);
         return rc;
 }
 
 static void remove_power_attributes(struct device *dev)
 {
-        sysfs_remove_file_from_group(&dev->kobj,
-                        &dev_attr_active_duration.attr,
-                        power_group);
-        sysfs_remove_file_from_group(&dev->kobj,
-                        &dev_attr_connected_duration.attr,
-                        power_group);
-        sysfs_remove_file_from_group(&dev->kobj,
-                        &dev_attr_level.attr,
-                        power_group);
-        sysfs_remove_file_from_group(&dev->kobj,
-                        &dev_attr_autosuspend.attr,
-                        power_group);
+        sysfs_unmerge_group(&dev->kobj, &power_attr_group);
 }
 
 #else
@@ -882,22 +842,19 @@ const struct attribute_group *usb_interface_groups[] = {
         NULL
 };
 
-int usb_create_sysfs_intf_files(struct usb_interface *intf)
+void usb_create_sysfs_intf_files(struct usb_interface *intf)
 {
         struct usb_device *udev = interface_to_usbdev(intf);
         struct usb_host_interface *alt = intf->cur_altsetting;
-        int retval;
 
         if (intf->sysfs_files_created || intf->unregistering)
-                return 0;
+                return;
 
-        if (alt->string == NULL &&
-                        !(udev->quirks & USB_QUIRK_CONFIG_INTF_STRINGS))
+        if (!alt->string && !(udev->quirks & USB_QUIRK_CONFIG_INTF_STRINGS))
                 alt->string = usb_cache_string(udev, alt->desc.iInterface);
-        if (alt->string)
-                retval = device_create_file(&intf->dev, &dev_attr_interface);
+        if (alt->string && device_create_file(&intf->dev, &dev_attr_interface))
+                ;       /* We don't actually care if the function fails. */
         intf->sysfs_files_created = 1;
-        return 0;
 }
 
 void usb_remove_sysfs_intf_files(struct usb_interface *intf)
diff --git a/drivers/usb/core/urb.c b/drivers/usb/core/urb.c
index 419e6b34e2fe..ae334b067c13 100644
--- a/drivers/usb/core/urb.c
+++ b/drivers/usb/core/urb.c
@@ -366,7 +366,16 @@ int usb_submit_urb(struct urb *urb, gfp_t mem_flags)
         if (xfertype == USB_ENDPOINT_XFER_ISOC) {
                 int     n, len;
 
-                /* FIXME SuperSpeed isoc endpoints have up to 16 bursts */
+                /* SuperSpeed isoc endpoints have up to 16 bursts of up to
+                 * 3 packets each
+                 */
+                if (dev->speed == USB_SPEED_SUPER) {
+                        int     burst = 1 + ep->ss_ep_comp.bMaxBurst;
+                        int     mult = USB_SS_MULT(ep->ss_ep_comp.bmAttributes);
+                        max *= burst;
+                        max *= mult;
+                }
+
                 /* "high bandwidth" mode, 1-3 packets/uframe? */
                 if (dev->speed == USB_SPEED_HIGH) {
                         int     mult = 1 + ((max >> 11) & 0x03);
@@ -401,8 +410,11 @@ int usb_submit_urb(struct urb *urb, gfp_t mem_flags)
         };
 
         /* Check that the pipe's type matches the endpoint's type */
-        if (usb_pipetype(urb->pipe) != pipetypes[xfertype])
+        if (usb_pipetype(urb->pipe) != pipetypes[xfertype]) {
+                dev_err(&dev->dev, "BOGUS urb xfer, pipe %x != type %x\n",
+                        usb_pipetype(urb->pipe), pipetypes[xfertype]);
                 return -EPIPE;          /* The most suitable error code :-) */
+        }
 
         /* enforce simple/standard policy */
         allowed = (URB_NO_TRANSFER_DMA_MAP | URB_NO_INTERRUPT | URB_DIR_MASK |
diff --git a/drivers/usb/core/usb.c b/drivers/usb/core/usb.c
index fdd4130fbb7d..8706fc97e60f 100644
--- a/drivers/usb/core/usb.c
+++ b/drivers/usb/core/usb.c
@@ -315,6 +315,11 @@ static const struct dev_pm_ops usb_device_pm_ops = {
         .thaw =         usb_dev_thaw,
         .poweroff =     usb_dev_poweroff,
         .restore =      usb_dev_restore,
+#ifdef CONFIG_USB_SUSPEND
+        .runtime_suspend =      usb_runtime_suspend,
+        .runtime_resume =       usb_runtime_resume,
+        .runtime_idle =         usb_runtime_idle,
+#endif
 };
 
 #endif  /* CONFIG_PM */
@@ -445,7 +450,8 @@ struct usb_device *usb_alloc_dev(struct usb_device *parent,
         INIT_LIST_HEAD(&dev->filelist);
 
 #ifdef  CONFIG_PM
-        dev->autosuspend_delay = usb_autosuspend_delay * HZ;
+        pm_runtime_set_autosuspend_delay(&dev->dev,
+                        usb_autosuspend_delay * 1000);
         dev->connect_time = jiffies;
         dev->active_duration = -jiffies;
 #endif
@@ -947,8 +953,7 @@ static int usb_bus_notify(struct notifier_block *nb, unsigned long action,
                 if (dev->type == &usb_device_type)
                         (void) usb_create_sysfs_dev_files(to_usb_device(dev));
                 else if (dev->type == &usb_if_device_type)
-                        (void) usb_create_sysfs_intf_files(
-                                        to_usb_interface(dev));
+                        usb_create_sysfs_intf_files(to_usb_interface(dev));
                 break;
 
         case BUS_NOTIFY_DEL_DEVICE:
diff --git a/drivers/usb/core/usb.h b/drivers/usb/core/usb.h
index cd882203ad34..d44d4b7bbf17 100644
--- a/drivers/usb/core/usb.h
+++ b/drivers/usb/core/usb.h
@@ -4,7 +4,7 @@
 
 extern int usb_create_sysfs_dev_files(struct usb_device *dev);
 extern void usb_remove_sysfs_dev_files(struct usb_device *dev);
-extern int usb_create_sysfs_intf_files(struct usb_interface *intf);
+extern void usb_create_sysfs_intf_files(struct usb_interface *intf);
 extern void usb_remove_sysfs_intf_files(struct usb_interface *intf);
 extern int usb_create_ep_devs(struct device *parent,
                                 struct usb_host_endpoint *endpoint,
@@ -75,14 +75,15 @@ static inline int usb_port_resume(struct usb_device *udev, pm_message_t msg)
 #ifdef CONFIG_USB_SUSPEND
 
 extern void usb_autosuspend_device(struct usb_device *udev);
-extern void usb_try_autosuspend_device(struct usb_device *udev);
 extern int usb_autoresume_device(struct usb_device *udev);
 extern int usb_remote_wakeup(struct usb_device *dev);
+extern int usb_runtime_suspend(struct device *dev);
+extern int usb_runtime_resume(struct device *dev);
+extern int usb_runtime_idle(struct device *dev);
 
 #else
 
 #define usb_autosuspend_device(udev)            do {} while (0)
-#define usb_try_autosuspend_device(udev)        do {} while (0)
 static inline int usb_autoresume_device(struct usb_device *udev)
 {
         return 0;
@@ -124,6 +125,19 @@ static inline int is_usb_device_driver(struct device_driver *drv)
                         for_devices;
 }
 
+/* translate USB error codes to codes user space understands */
+static inline int usb_translate_errors(int error_code)
+{
+        switch (error_code) {
+        case 0:
+        case -ENOMEM:
+        case -ENODEV:
+                return error_code;
+        default:
+                return -EIO;
+        }
+}
+
 
 /* for labeling diagnostics */
 extern const char *usbcore_name;
diff --git a/drivers/usb/early/Makefile b/drivers/usb/early/Makefile
index dfedee8c45b6..24bbe519c737 100644
--- a/drivers/usb/early/Makefile
+++ b/drivers/usb/early/Makefile
@@ -2,4 +2,4 @@
 # Makefile for early USB devices
 #
 
-obj-$(CONFIG_EARLY_PRINTK_DBGP)        += ehci-dbgp.o
+obj-$(CONFIG_EARLY_PRINTK_DBGP) += ehci-dbgp.o
diff --git a/drivers/usb/early/ehci-dbgp.c b/drivers/usb/early/ehci-dbgp.c
index 94ecdbc758ce..1fc8f1249806 100644
--- a/drivers/usb/early/ehci-dbgp.c
+++ b/drivers/usb/early/ehci-dbgp.c
@@ -102,6 +102,9 @@ static struct kgdb_io kgdbdbgp_io_ops;
 #define dbgp_kgdb_mode (0)
 #endif
 
+/* Local version of HC_LENGTH macro as ehci struct is not available here */
+#define EARLY_HC_LENGTH(p)      (0x00ff & (p)) /* bits 7 : 0 */
+
 /*
  * USB Packet IDs (PIDs)
  */
@@ -601,7 +604,7 @@ try_again:
                 dbgp_printk("dbgp_bulk_write failed: %d\n", ret);
                 goto err;
         }
-        dbgp_printk("small write doned\n");
+        dbgp_printk("small write done\n");
         dbgp_not_safe = 0;
 
         return 0;
@@ -648,7 +651,7 @@ static int ehci_reset_port(int port)
                 if (!(portsc & PORT_CONNECT))
                         return -ENOTCONN;
 
-                /* bomb out completely if something weird happend */
+                /* bomb out completely if something weird happened */
                 if ((portsc & PORT_CSC))
                         return -EINVAL;
 
@@ -892,7 +895,7 @@ int __init early_dbgp_init(char *s)
         dbgp_printk("ehci_bar: %p\n", ehci_bar);
 
         ehci_caps  = ehci_bar;
-        ehci_regs  = ehci_bar + HC_LENGTH(readl(&ehci_caps->hc_capbase));
+        ehci_regs  = ehci_bar + EARLY_HC_LENGTH(readl(&ehci_caps->hc_capbase));
         ehci_debug = ehci_bar + offset;
         ehci_dev.bus = bus;
         ehci_dev.slot = slot;
diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig
index cd27f9bde2c8..029e288805b6 100644
--- a/drivers/usb/gadget/Kconfig
+++ b/drivers/usb/gadget/Kconfig
@@ -158,6 +158,7 @@ config USB_GADGET_FSL_USB2
         boolean "Freescale Highspeed USB DR Peripheral Controller"
         depends on FSL_SOC || ARCH_MXC
         select USB_GADGET_DUALSPEED
+        select USB_FSL_MPH_DR_OF if OF
         help
            Some of Freescale PowerPC processors have a High Speed
            Dual-Role(DR) USB controller, which supports device mode.
@@ -175,15 +176,15 @@ config USB_FSL_USB2
         default USB_GADGET
         select USB_GADGET_SELECTED
 
-config USB_GADGET_LH7A40X
-        boolean "LH7A40X"
-        depends on ARCH_LH7A40X
+config USB_GADGET_FUSB300
+        boolean "Faraday FUSB300 USB Peripheral Controller"
+        select USB_GADGET_DUALSPEED
         help
-           This driver provides USB Device Controller driver for LH7A40x
+           Faraday usb device controller FUSB300 driver
 
-config USB_LH7A40X
+config USB_FUSB300
         tristate
-        depends on USB_GADGET_LH7A40X
+        depends on USB_GADGET_FUSB300
         default USB_GADGET
         select USB_GADGET_SELECTED
 
@@ -209,17 +210,6 @@ config USB_OMAP
         default USB_GADGET
         select USB_GADGET_SELECTED
 
-config USB_OTG
-        boolean "OTG Support"
-        depends on USB_GADGET_OMAP && ARCH_OMAP_OTG && USB_OHCI_HCD
-        help
-           The most notable feature of USB OTG is support for a
-           "Dual-Role" device, which can act as either a device
-           or a host.  The initial role choice can be changed
-           later, when two dual-role devices talk to each other.
-
-           Select this only if your OMAP board has a Mini-AB connector.
-
 config USB_GADGET_PXA25X
         boolean "PXA 25x or IXP 4xx"
         depends on (ARCH_PXA && PXA25x) || ARCH_IXP4XX
@@ -270,6 +260,24 @@ config USB_R8A66597
         default USB_GADGET
         select USB_GADGET_SELECTED
 
+config USB_GADGET_RENESAS_USBHS
+        boolean "Renesas USBHS"
+        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.
+           platform is able to configure endpoint (pipe) style
+
+           Say "y" to enable the gadget specific portion of the USBHS driver.
+
+
+config USB_RENESAS_USBHS_UDC
+        tristate
+        depends on USB_GADGET_RENESAS_USBHS
+        default USB_GADGET
+        select USB_GADGET_SELECTED
+
 config USB_GADGET_PXA27X
         boolean "PXA 27x"
         depends on ARCH_PXA && (PXA27x || PXA3xx)
@@ -348,6 +356,36 @@ config USB_S3C2410_DEBUG
         boolean "S3C2410 udc debug messages"
         depends on USB_GADGET_S3C2410
 
+config USB_GADGET_S3C_HSUDC
+        boolean "S3C2416, S3C2443 and S3C2450 USB Device Controller"
+        depends on ARCH_S3C2410
+        select USB_GADGET_DUALSPEED
+        help
+          Samsung's S3C2416, S3C2443 and S3C2450 is an ARM9 based SoC
+          integrated with dual speed USB 2.0 device controller. It has
+          8 endpoints, as well as endpoint zero.
+
+          This driver has been tested on S3C2416 and S3C2450 processors.
+
+config USB_S3C_HSUDC
+        tristate
+        depends on USB_GADGET_S3C_HSUDC
+        default USB_GADGET
+        select USB_GADGET_SELECTED
+
+config USB_GADGET_PXA_U2O
+        boolean "PXA9xx Processor USB2.0 controller"
+        select USB_GADGET_DUALSPEED
+        help
+          PXA9xx Processor series include a high speed USB2.0 device
+          controller, which support high speed and full speed USB peripheral.
+
+config USB_PXA_U2O
+        tristate
+        depends on USB_GADGET_PXA_U2O
+        default USB_GADGET
+        select USB_GADGET_SELECTED
+
 #
 # Controllers available in both integrated and discrete versions
 #
@@ -424,8 +462,8 @@ config USB_FSL_QE
         default USB_GADGET
         select USB_GADGET_SELECTED
 
-config USB_GADGET_CI13XXX
-        boolean "MIPS USB CI13xxx"
+config USB_GADGET_CI13XXX_PCI
+        boolean "MIPS USB CI13xxx PCI UDC"
         depends on PCI
         select USB_GADGET_DUALSPEED
         help
@@ -436,9 +474,9 @@ config USB_GADGET_CI13XXX
           dynamically linked module called "ci13xxx_udc" and force all
           gadget drivers to also be dynamically linked.
 
-config USB_CI13XXX
+config USB_CI13XXX_PCI
         tristate
-        depends on USB_GADGET_CI13XXX
+        depends on USB_GADGET_CI13XXX_PCI
         default USB_GADGET
         select USB_GADGET_SELECTED
 
@@ -505,6 +543,56 @@ config USB_LANGWELL
         default USB_GADGET
         select USB_GADGET_SELECTED
 
+config USB_GADGET_EG20T
+        boolean "Intel EG20T PCH/OKI SEMICONDUCTOR ML7213 IOH UDC"
+        depends on PCI
+        select USB_GADGET_DUALSPEED
+        help
+          This is a USB device driver for EG20T PCH.
+          EG20T PCH is the platform controller hub that is used in Intel's
+          general embedded platform. EG20T PCH has USB device interface.
+          Using this interface, it is able to access system devices connected
+          to USB device.
+          This driver enables USB device function.
+          USB device is a USB peripheral controller which
+          supports both full and high speed USB 2.0 data transfers.
+          This driver supports both control transfer and bulk transfer modes.
+          This driver dose not support interrupt transfer or isochronous
+          transfer modes.
+
+          This driver also can be used for OKI SEMICONDUCTOR's ML7213 which is
+          for IVI(In-Vehicle Infotainment) use.
+          ML7213 is companion chip for Intel Atom E6xx series.
+          ML7213 is completely compatible for Intel EG20T PCH.
+
+config USB_EG20T
+        tristate
+        depends on USB_GADGET_EG20T
+        default USB_GADGET
+        select USB_GADGET_SELECTED
+
+config USB_GADGET_CI13XXX_MSM
+        boolean "MIPS USB CI13xxx for MSM"
+        depends on ARCH_MSM
+        select USB_GADGET_DUALSPEED
+        select USB_MSM_OTG
+        help
+          MSM SoC has chipidea USB controller.  This driver uses
+          ci13xxx_udc core.
+          This driver depends on OTG driver for PHY initialization,
+          clock management, powering up VBUS, and power management.
+          This driver is not supported on boards like trout which
+          has an external PHY.
+
+          Say "y" to link the driver statically, or "m" to build a
+          dynamically linked module called "ci13xxx_msm" and force all
+          gadget drivers to also be dynamically linked.
+
+config USB_CI13XXX_MSM
+        tristate
+        depends on USB_GADGET_CI13XXX_MSM
+        default USB_GADGET
+        select USB_GADGET_SELECTED
 
 #
 # LAST -- dummy/emulated controller
@@ -544,13 +632,10 @@ config USB_DUMMY_HCD
 
 endchoice
 
+# Selected by UDC drivers that support high-speed operation.
 config USB_GADGET_DUALSPEED
         bool
         depends on USB_GADGET
-        default n
-        help
-          Means that gadget drivers should include extra descriptors
-          and code to handle dual-speed controllers.
 
 #
 # USB Gadget Drivers
@@ -695,6 +780,19 @@ config USB_ETH_EEM
          If you say "y" here, the Ethernet gadget driver will use the EEM
          protocol rather than ECM.  If unsure, say "n".
 
+config USB_G_NCM
+        tristate "Network Control Model (NCM) support"
+        depends on NET
+        select CRC32
+        help
+          This driver implements USB CDC NCM subclass standard. NCM is
+          an advanced protocol for Ethernet encapsulation, allows grouping
+          of several ethernet frames into one USB transfer and diffferent
+          alignment possibilities.
+
+          Say "y" to link the driver statically, or "m" to build a
+          dynamically linked module called "g_ncm".
+
 config USB_GADGETFS
         tristate "Gadget Filesystem (EXPERIMENTAL)"
         depends on EXPERIMENTAL
@@ -716,8 +814,8 @@ config USB_FUNCTIONFS
         depends on EXPERIMENTAL
         select USB_FUNCTIONFS_GENERIC if !(USB_FUNCTIONFS_ETH || USB_FUNCTIONFS_RNDIS)
         help
-          The Function Filesystem (FunctioFS) lets one create USB
-          composite functions in user space in the same way as GadgetFS
+          The Function Filesystem (FunctionFS) lets one create USB
+          composite functions in user space in the same way GadgetFS
           lets one create USB gadgets in user space.  This allows creation
           of composite gadgets such that some of the functions are
           implemented in kernel space (for instance Ethernet, serial or
@@ -733,14 +831,14 @@ config USB_FUNCTIONFS_ETH
         bool "Include configuration with CDC ECM (Ethernet)"
         depends on USB_FUNCTIONFS && NET
         help
-          Include a configuration with CDC ECM funcion (Ethernet) and the
-          Funcion Filesystem.
+          Include a configuration with CDC ECM function (Ethernet) and the
+          Function Filesystem.
 
 config USB_FUNCTIONFS_RNDIS
         bool "Include configuration with RNDIS (Ethernet)"
         depends on USB_FUNCTIONFS && NET
         help
-          Include a configuration with RNDIS funcion (Ethernet) and the Filesystem.
+          Include a configuration with RNDIS function (Ethernet) and the Filesystem.
 
 config USB_FUNCTIONFS_GENERIC
         bool "Include 'pure' configuration"
diff --git a/drivers/usb/gadget/Makefile b/drivers/usb/gadget/Makefile
index 27283df37d09..4fe92b18a055 100644
--- a/drivers/usb/gadget/Makefile
+++ b/drivers/usb/gadget/Makefile
@@ -1,9 +1,7 @@
 #
 # USB peripheral controller drivers
 #
-ifeq ($(CONFIG_USB_GADGET_DEBUG),y)
-        EXTRA_CFLAGS            += -DDEBUG
-endif
+ccflags-$(CONFIG_USB_GADGET_DEBUG) := -DDEBUG
 
 obj-$(CONFIG_USB_DUMMY_HCD)     += dummy_hcd.o
 obj-$(CONFIG_USB_NET2280)       += net2280.o
@@ -13,40 +11,44 @@ obj-$(CONFIG_USB_PXA27X)	+= pxa27x_udc.o
 obj-$(CONFIG_USB_IMX)           += imx_udc.o
 obj-$(CONFIG_USB_GOKU)          += goku_udc.o
 obj-$(CONFIG_USB_OMAP)          += omap_udc.o
-obj-$(CONFIG_USB_LH7A40X)       += lh7a40x_udc.o
 obj-$(CONFIG_USB_S3C2410)       += s3c2410_udc.o
 obj-$(CONFIG_USB_AT91)          += at91_udc.o
 obj-$(CONFIG_USB_ATMEL_USBA)    += atmel_usba_udc.o
 obj-$(CONFIG_USB_FSL_USB2)      += fsl_usb2_udc.o
-fsl_usb2_udc-objs               := fsl_udc_core.o
-ifeq ($(CONFIG_ARCH_MXC),y)
-fsl_usb2_udc-objs               += fsl_mxc_udc.o
-endif
+fsl_usb2_udc-y                  := fsl_udc_core.o
+fsl_usb2_udc-$(CONFIG_ARCH_MXC) += fsl_mxc_udc.o
 obj-$(CONFIG_USB_M66592)        += m66592-udc.o
 obj-$(CONFIG_USB_R8A66597)      += r8a66597-udc.o
 obj-$(CONFIG_USB_FSL_QE)        += fsl_qe_udc.o
-obj-$(CONFIG_USB_CI13XXX)       += ci13xxx_udc.o
+obj-$(CONFIG_USB_CI13XXX_PCI)   += ci13xxx_pci.o
 obj-$(CONFIG_USB_S3C_HSOTG)     += s3c-hsotg.o
+obj-$(CONFIG_USB_S3C_HSUDC)     += s3c-hsudc.o
 obj-$(CONFIG_USB_LANGWELL)      += langwell_udc.o
+obj-$(CONFIG_USB_EG20T)         += pch_udc.o
+obj-$(CONFIG_USB_PXA_U2O)       += mv_udc.o
+mv_udc-y                        := mv_udc_core.o mv_udc_phy.o
+obj-$(CONFIG_USB_CI13XXX_MSM)   += ci13xxx_msm.o
+obj-$(CONFIG_USB_FUSB300)       += fusb300_udc.o
 
 #
 # USB gadget drivers
 #
-g_zero-objs                     := zero.o
-g_audio-objs                    := audio.o
-g_ether-objs                    := ether.o
-g_serial-objs                   := serial.o
-g_midi-objs                     := gmidi.o
-gadgetfs-objs                   := inode.o
-g_file_storage-objs             := file_storage.o
-g_mass_storage-objs             := mass_storage.o
-g_printer-objs                  := printer.o
-g_cdc-objs                      := cdc2.o
-g_multi-objs                    := multi.o
-g_hid-objs                      := hid.o
-g_dbgp-objs                     := dbgp.o
-g_nokia-objs                    := nokia.o
-g_webcam-objs                   := webcam.o
+g_zero-y                        := zero.o
+g_audio-y                       := audio.o
+g_ether-y                       := ether.o
+g_serial-y                      := serial.o
+g_midi-y                        := gmidi.o
+gadgetfs-y                      := inode.o
+g_file_storage-y                := file_storage.o
+g_mass_storage-y                := mass_storage.o
+g_printer-y                     := printer.o
+g_cdc-y                         := cdc2.o
+g_multi-y                       := multi.o
+g_hid-y                         := hid.o
+g_dbgp-y                        := dbgp.o
+g_nokia-y                       := nokia.o
+g_webcam-y                      := webcam.o
+g_ncm-y                         := ncm.o
 
 obj-$(CONFIG_USB_ZERO)          += g_zero.o
 obj-$(CONFIG_USB_AUDIO)         += g_audio.o
@@ -64,4 +66,4 @@ obj-$(CONFIG_USB_G_DBGP)	+= g_dbgp.o
 obj-$(CONFIG_USB_G_MULTI)       += g_multi.o
 obj-$(CONFIG_USB_G_NOKIA)       += g_nokia.o
 obj-$(CONFIG_USB_G_WEBCAM)      += g_webcam.o
-
+obj-$(CONFIG_USB_G_NCM)         += g_ncm.o
diff --git a/drivers/usb/gadget/amd5536udc.c b/drivers/usb/gadget/amd5536udc.c
index 731150d4b1d9..95e8138cd48f 100644
--- a/drivers/usb/gadget/amd5536udc.c
+++ b/drivers/usb/gadget/amd5536udc.c
@@ -60,6 +60,7 @@
 #include <linux/device.h>
 #include <linux/io.h>
 #include <linux/irq.h>
+#include <linux/prefetch.h>
 
 #include <asm/byteorder.h>
 #include <asm/system.h>
@@ -203,7 +204,7 @@ static void print_regs(struct udc *dev)
                 DBG(dev, "DMA mode       = PPBNDU (packet per buffer "
                         "WITHOUT desc. update)\n");
                 dev_info(&dev->pdev->dev, "DMA mode (%s)\n", "PPBNDU");
-        } else if (use_dma && use_dma_ppb_du && use_dma_ppb_du) {
+        } else if (use_dma && use_dma_ppb && use_dma_ppb_du) {
                 DBG(dev, "DMA mode       = PPBDU (packet per buffer "
                         "WITH desc. update)\n");
                 dev_info(&dev->pdev->dev, "DMA mode (%s)\n", "PPBDU");
@@ -278,7 +279,7 @@ static int udc_enable_dev_setup_interrupts(struct udc *dev)
         return 0;
 }
 
-/* Calculates fifo start of endpoint based on preceeding endpoints */
+/* Calculates fifo start of endpoint based on preceding endpoints */
 static int udc_set_txfifo_addr(struct udc_ep *ep)
 {
         struct udc      *dev;
@@ -1954,13 +1955,14 @@ static int setup_ep0(struct udc *dev)
 }
 
 /* Called by gadget driver to register itself */
-int usb_gadget_register_driver(struct usb_gadget_driver *driver)
+int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
+                int (*bind)(struct usb_gadget *))
 {
         struct udc              *dev = udc;
         int                     retval;
         u32 tmp;
 
-        if (!driver || !driver->bind || !driver->setup
+        if (!driver || !bind || !driver->setup
                         || driver->speed != USB_SPEED_HIGH)
                 return -EINVAL;
         if (!dev)
@@ -1972,7 +1974,7 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver)
         dev->driver = driver;
         dev->gadget.dev.driver = &driver->driver;
 
-        retval = driver->bind(&dev->gadget);
+        retval = bind(&dev->gadget);
 
         /* Some gadget drivers use both ep0 directions.
          * NOTE: to gadget driver, ep0 is just one endpoint...
@@ -2000,7 +2002,7 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver)
 
         return 0;
 }
-EXPORT_SYMBOL(usb_gadget_register_driver);
+EXPORT_SYMBOL(usb_gadget_probe_driver);
 
 /* shutdown requests and disconnect from gadget */
 static void
@@ -2136,7 +2138,7 @@ static irqreturn_t udc_data_out_isr(struct udc *dev, int ep_ix)
         if (use_dma) {
                 /* BNA event ? */
                 if (tmp & AMD_BIT(UDC_EPSTS_BNA)) {
-                        DBG(dev, "BNA ep%dout occured - DESPTR = %x \n",
+                        DBG(dev, "BNA ep%dout occurred - DESPTR = %x \n",
                                         ep->num, readl(&ep->regs->desptr));
                         /* clear BNA */
                         writel(tmp | AMD_BIT(UDC_EPSTS_BNA), &ep->regs->sts);
@@ -2150,7 +2152,7 @@ static irqreturn_t udc_data_out_isr(struct udc *dev, int ep_ix)
         }
         /* HE event ? */
         if (tmp & AMD_BIT(UDC_EPSTS_HE)) {
-                dev_err(&dev->pdev->dev, "HE ep%dout occured\n", ep->num);
+                dev_err(&dev->pdev->dev, "HE ep%dout occurred\n", ep->num);
 
                 /* clear HE */
                 writel(tmp | AMD_BIT(UDC_EPSTS_HE), &ep->regs->sts);
@@ -2353,7 +2355,7 @@ static irqreturn_t udc_data_in_isr(struct udc *dev, int ep_ix)
                 /* BNA ? */
                 if (epsts & AMD_BIT(UDC_EPSTS_BNA)) {
                         dev_err(&dev->pdev->dev,
-                                "BNA ep%din occured - DESPTR = %08lx \n",
+                                "BNA ep%din occurred - DESPTR = %08lx \n",
                                 ep->num,
                                 (unsigned long) readl(&ep->regs->desptr));
 
@@ -2366,7 +2368,7 @@ static irqreturn_t udc_data_in_isr(struct udc *dev, int ep_ix)
         /* HE event ? */
         if (epsts & AMD_BIT(UDC_EPSTS_HE)) {
                 dev_err(&dev->pdev->dev,
-                        "HE ep%dn occured - DESPTR = %08lx \n",
+                        "HE ep%dn occurred - DESPTR = %08lx \n",
                         ep->num, (unsigned long) readl(&ep->regs->desptr));
 
                 /* clear HE */
@@ -2383,7 +2385,7 @@ static irqreturn_t udc_data_in_isr(struct udc *dev, int ep_ix)
                         req = list_entry(ep->queue.next,
                                         struct udc_request, queue);
                         /*
-                         * length bytes transfered
+                         * length bytes transferred
                          * check dma done of last desc. in PPBDU mode
                          */
                         if (use_dma_ppb_du) {
@@ -2783,7 +2785,7 @@ static irqreturn_t udc_control_in_isr(struct udc *dev)
                                         /* write fifo */
                                         udc_txfifo_write(ep, &req->req);
 
-                                        /* lengh bytes transfered */
+                                        /* lengh bytes transferred */
                                         len = req->req.length - req->req.actual;
                                         if (len > ep->ep.maxpacket)
                                                 len = ep->ep.maxpacket;
@@ -3358,7 +3360,6 @@ static int udc_probe(struct udc *dev)
         dev_set_name(&dev->gadget.dev, "gadget");
         dev->gadget.dev.release = gadget_release;
         dev->gadget.name = name;
-        dev->gadget.name = name;
         dev->gadget.is_dualspeed = 1;
 
         /* init registers, interrupts, ... */
@@ -3382,8 +3383,10 @@ static int udc_probe(struct udc *dev)
         udc = dev;
 
         retval = device_register(&dev->gadget.dev);
-        if (retval)
+        if (retval) {
+                put_device(&dev->gadget.dev);
                 goto finished;
+        }
 
         /* timer init */
         init_timer(&udc_timer);
diff --git a/drivers/usb/gadget/amd5536udc.h b/drivers/usb/gadget/amd5536udc.h
index 4bbabbbfc93f..1d1c7543468e 100644
--- a/drivers/usb/gadget/amd5536udc.h
+++ b/drivers/usb/gadget/amd5536udc.h
@@ -584,7 +584,7 @@ union udc_setup_data {
  * SET and GET bitfields in u32 values
  * via constants for mask/offset:
  * <bit_field_stub_name> is the text between
- * UDC_ and _MASK|_OFS of appropiate
+ * UDC_ and _MASK|_OFS of appropriate
  * constant
  *
  * set bitfield value in u32 u32Val
diff --git a/drivers/usb/gadget/at91_udc.c b/drivers/usb/gadget/at91_udc.c
index 93ead19507b6..f4690ffcb489 100644
--- a/drivers/usb/gadget/at91_udc.c
+++ b/drivers/usb/gadget/at91_udc.c
@@ -38,6 +38,7 @@
 #include <linux/clk.h>
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
+#include <linux/prefetch.h>
 
 #include <asm/byteorder.h>
 #include <mach/hardware.h>
@@ -826,7 +827,7 @@ done:
         return status;
 }
 
-/* reinit == restore inital software state */
+/* reinit == restore initial software state */
 static void udc_reinit(struct at91_udc *udc)
 {
         u32 i;
@@ -1266,7 +1267,6 @@ write_in:
         csr |= AT91_UDP_TXPKTRDY;
         __raw_writel(csr, creg);
         udc->req_pending = 0;
-        return;
 }
 
 static void handle_ep0(struct at91_udc *udc)
@@ -1628,7 +1628,8 @@ static void at91_vbus_timer(unsigned long data)
                 schedule_work(&udc->vbus_timer_work);
 }
 
-int usb_gadget_register_driver (struct usb_gadget_driver *driver)
+int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
+                int (*bind)(struct usb_gadget *))
 {
         struct at91_udc *udc = &controller;
         int             retval;
@@ -1636,7 +1637,7 @@ int usb_gadget_register_driver (struct usb_gadget_driver *driver)
 
         if (!driver
                         || driver->speed < USB_SPEED_FULL
-                        || !driver->bind
+                        || !bind
                         || !driver->setup) {
                 DBG("bad parameter.\n");
                 return -EINVAL;
@@ -1653,9 +1654,9 @@ int usb_gadget_register_driver (struct usb_gadget_driver *driver)
         udc->enabled = 1;
         udc->selfpowered = 1;
 
-        retval = driver->bind(&udc->gadget);
+        retval = bind(&udc->gadget);
         if (retval) {
-                DBG("driver->bind() returned %d\n", retval);
+                DBG("bind() returned %d\n", retval);
                 udc->driver = NULL;
                 udc->gadget.dev.driver = NULL;
                 dev_set_drvdata(&udc->gadget.dev, NULL);
@@ -1671,7 +1672,7 @@ int usb_gadget_register_driver (struct usb_gadget_driver *driver)
         DBG("bound to %s\n", driver->driver.name);
         return 0;
 }
-EXPORT_SYMBOL (usb_gadget_register_driver);
+EXPORT_SYMBOL(usb_gadget_probe_driver);
 
 int usb_gadget_unregister_driver (struct usb_gadget_driver *driver)
 {
@@ -1767,7 +1768,7 @@ static int __init at91udc_probe(struct platform_device *pdev)
         }
 
         /* newer chips have more FIFO memory than rm9200 */
-        if (cpu_is_at91sam9260()) {
+        if (cpu_is_at91sam9260() || cpu_is_at91sam9g20()) {
                 udc->ep[0].maxpacket = 64;
                 udc->ep[3].maxpacket = 64;
                 udc->ep[4].maxpacket = 512;
@@ -1798,8 +1799,10 @@ static int __init at91udc_probe(struct platform_device *pdev)
         }
 
         retval = device_register(&udc->gadget.dev);
-        if (retval < 0)
+        if (retval < 0) {
+                put_device(&udc->gadget.dev);
                 goto fail0b;
+        }
 
         /* don't do anything until we have both gadget driver and VBUS */
         clk_enable(udc->iclk);
diff --git a/drivers/usb/gadget/atmel_usba_udc.c b/drivers/usb/gadget/atmel_usba_udc.c
index d623c7bda1f6..db1a659702ba 100644
--- a/drivers/usb/gadget/atmel_usba_udc.c
+++ b/drivers/usb/gadget/atmel_usba_udc.c
@@ -1789,7 +1789,8 @@ out:
         return IRQ_HANDLED;
 }
 
-int usb_gadget_register_driver(struct usb_gadget_driver *driver)
+int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
+                int (*bind)(struct usb_gadget *))
 {
         struct usba_udc *udc = &the_udc;
         unsigned long flags;
@@ -1812,7 +1813,7 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver)
         clk_enable(udc->pclk);
         clk_enable(udc->hclk);
 
-        ret = driver->bind(&udc->gadget);
+        ret = bind(&udc->gadget);
         if (ret) {
                 DBG(DBG_ERR, "Could not bind to driver %s: error %d\n",
                         driver->driver.name, ret);
@@ -1841,7 +1842,7 @@ err_driver_bind:
         udc->gadget.dev.driver = NULL;
         return ret;
 }
-EXPORT_SYMBOL(usb_gadget_register_driver);
+EXPORT_SYMBOL(usb_gadget_probe_driver);
 
 int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
 {
@@ -2014,6 +2015,9 @@ static int __init usba_udc_probe(struct platform_device *pdev)
                         } else {
                                 disable_irq(gpio_to_irq(udc->vbus_pin));
                         }
+                } else {
+                        /* gpio_request fail so use -EINVAL for gpio_is_valid */
+                        udc->vbus_pin = -EINVAL;
                 }
         }
 
@@ -2053,8 +2057,10 @@ static int __exit usba_udc_remove(struct platform_device *pdev)
                 usba_ep_cleanup_debugfs(&usba_ep[i]);
         usba_cleanup_debugfs(udc);
 
-        if (gpio_is_valid(udc->vbus_pin))
+        if (gpio_is_valid(udc->vbus_pin)) {
+                free_irq(gpio_to_irq(udc->vbus_pin), udc);
                 gpio_free(udc->vbus_pin);
+        }
 
         free_irq(udc->irq, udc);
         kfree(usba_ep);
@@ -2089,6 +2095,6 @@ static void __exit udc_exit(void)
 module_exit(udc_exit);
 
 MODULE_DESCRIPTION("Atmel USBA UDC driver");
-MODULE_AUTHOR("Haavard Skinnemoen <hskinnemoen@atmel.com>");
+MODULE_AUTHOR("Haavard Skinnemoen (Atmel)");
 MODULE_LICENSE("GPL");
 MODULE_ALIAS("platform:atmel_usba_udc");
diff --git a/drivers/usb/gadget/audio.c b/drivers/usb/gadget/audio.c
index b744ccd0f34d..93b999e49ef3 100644
--- a/drivers/usb/gadget/audio.c
+++ b/drivers/usb/gadget/audio.c
@@ -89,7 +89,7 @@ static const struct usb_descriptor_header *otg_desc[] = {
 
 /*-------------------------------------------------------------------------*/
 
-static int __ref audio_do_config(struct usb_configuration *c)
+static int __init audio_do_config(struct usb_configuration *c)
 {
         /* FIXME alloc iConfiguration string, set it in c->strings */
 
@@ -105,7 +105,6 @@ static int __ref audio_do_config(struct usb_configuration *c)
 
 static struct usb_configuration audio_config_driver = {
         .label                  = DRIVER_DESC,
-        .bind                   = audio_do_config,
         .bConfigurationValue    = 1,
         /* .iConfiguration = DYNAMIC */
         .bmAttributes           = USB_CONFIG_ATT_SELFPOWER,
@@ -113,7 +112,7 @@ static struct usb_configuration audio_config_driver = {
 
 /*-------------------------------------------------------------------------*/
 
-static int __ref audio_bind(struct usb_composite_dev *cdev)
+static int __init audio_bind(struct usb_composite_dev *cdev)
 {
         int                     gcnum;
         int                     status;
@@ -145,7 +144,7 @@ static int __ref audio_bind(struct usb_composite_dev *cdev)
         strings_dev[STRING_PRODUCT_IDX].id = status;
         device_desc.iProduct = status;
 
-        status = usb_add_config(cdev, &audio_config_driver);
+        status = usb_add_config(cdev, &audio_config_driver, audio_do_config);
         if (status < 0)
                 goto fail;
 
@@ -166,13 +165,12 @@ static struct usb_composite_driver audio_driver = {
         .name           = "g_audio",
         .dev            = &device_desc,
         .strings        = audio_strings,
-        .bind           = audio_bind,
         .unbind         = __exit_p(audio_unbind),
 };
 
 static int __init init(void)
 {
-        return usb_composite_register(&audio_driver);
+        return usb_composite_probe(&audio_driver, audio_bind);
 }
 module_init(init);
 
diff --git a/drivers/usb/gadget/cdc2.c b/drivers/usb/gadget/cdc2.c
index 1f5ba2fd4c1f..2720ab07ef1a 100644
--- a/drivers/usb/gadget/cdc2.c
+++ b/drivers/usb/gadget/cdc2.c
@@ -129,7 +129,7 @@ static u8 hostaddr[ETH_ALEN];
 /*
  * We _always_ have both CDC ECM and CDC ACM functions.
  */
-static int __ref cdc_do_config(struct usb_configuration *c)
+static int __init cdc_do_config(struct usb_configuration *c)
 {
         int     status;
 
@@ -151,7 +151,6 @@ static int __ref cdc_do_config(struct usb_configuration *c)
 
 static struct usb_configuration cdc_config_driver = {
         .label                  = "CDC Composite (ECM + ACM)",
-        .bind                   = cdc_do_config,
         .bConfigurationValue    = 1,
         /* .iConfiguration = DYNAMIC */
         .bmAttributes           = USB_CONFIG_ATT_SELFPOWER,
@@ -159,7 +158,7 @@ static struct usb_configuration cdc_config_driver = {
 
 /*-------------------------------------------------------------------------*/
 
-static int __ref cdc_bind(struct usb_composite_dev *cdev)
+static int __init cdc_bind(struct usb_composite_dev *cdev)
 {
         int                     gcnum;
         struct usb_gadget       *gadget = cdev->gadget;
@@ -218,7 +217,7 @@ static int __ref cdc_bind(struct usb_composite_dev *cdev)
         device_desc.iProduct = status;
 
         /* register our configuration */
-        status = usb_add_config(cdev, &cdc_config_driver);
+        status = usb_add_config(cdev, &cdc_config_driver, cdc_do_config);
         if (status < 0)
                 goto fail1;
 
@@ -245,7 +244,6 @@ static struct usb_composite_driver cdc_driver = {
         .name           = "g_cdc",
         .dev            = &device_desc,
         .strings        = dev_strings,
-        .bind           = cdc_bind,
         .unbind         = __exit_p(cdc_unbind),
 };
 
@@ -255,7 +253,7 @@ MODULE_LICENSE("GPL");
 
 static int __init init(void)
 {
-        return usb_composite_register(&cdc_driver);
+        return usb_composite_probe(&cdc_driver, cdc_bind);
 }
 module_init(init);
 
diff --git a/drivers/usb/gadget/ci13xxx_msm.c b/drivers/usb/gadget/ci13xxx_msm.c
new file mode 100644
index 000000000000..139ac9419597
--- /dev/null
+++ b/drivers/usb/gadget/ci13xxx_msm.c
@@ -0,0 +1,134 @@
+/* Copyright (c) 2010, Code Aurora Forum. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/pm_runtime.h>
+#include <linux/usb/msm_hsusb_hw.h>
+#include <linux/usb/ulpi.h>
+
+#include "ci13xxx_udc.c"
+
+#define MSM_USB_BASE    (udc->regs)
+
+static irqreturn_t msm_udc_irq(int irq, void *data)
+{
+        return udc_irq();
+}
+
+static void ci13xxx_msm_notify_event(struct ci13xxx *udc, unsigned event)
+{
+        struct device *dev = udc->gadget.dev.parent;
+        int val;
+
+        switch (event) {
+        case CI13XXX_CONTROLLER_RESET_EVENT:
+                dev_dbg(dev, "CI13XXX_CONTROLLER_RESET_EVENT received\n");
+                writel(0, USB_AHBBURST);
+                writel(0, USB_AHBMODE);
+                break;
+        case CI13XXX_CONTROLLER_STOPPED_EVENT:
+                dev_dbg(dev, "CI13XXX_CONTROLLER_STOPPED_EVENT received\n");
+                /*
+                 * Put the transceiver in non-driving mode. Otherwise host
+                 * may not detect soft-disconnection.
+                 */
+                val = otg_io_read(udc->transceiver, ULPI_FUNC_CTRL);
+                val &= ~ULPI_FUNC_CTRL_OPMODE_MASK;
+                val |= ULPI_FUNC_CTRL_OPMODE_NONDRIVING;
+                otg_io_write(udc->transceiver, val, ULPI_FUNC_CTRL);
+                break;
+        default:
+                dev_dbg(dev, "unknown ci13xxx_udc event\n");
+                break;
+        }
+}
+
+static struct ci13xxx_udc_driver ci13xxx_msm_udc_driver = {
+        .name                   = "ci13xxx_msm",
+        .flags                  = CI13XXX_REGS_SHARED |
+                                  CI13XXX_REQUIRE_TRANSCEIVER |
+                                  CI13XXX_PULLUP_ON_VBUS |
+                                  CI13XXX_DISABLE_STREAMING,
+
+        .notify_event           = ci13xxx_msm_notify_event,
+};
+
+static int ci13xxx_msm_probe(struct platform_device *pdev)
+{
+        struct resource *res;
+        void __iomem *regs;
+        int irq;
+        int ret;
+
+        dev_dbg(&pdev->dev, "ci13xxx_msm_probe\n");
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(&pdev->dev, "failed to get platform resource mem\n");
+                return -ENXIO;
+        }
+
+        regs = ioremap(res->start, resource_size(res));
+        if (!regs) {
+                dev_err(&pdev->dev, "ioremap failed\n");
+                return -ENOMEM;
+        }
+
+        ret = udc_probe(&ci13xxx_msm_udc_driver, &pdev->dev, regs);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "udc_probe failed\n");
+                goto iounmap;
+        }
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0) {
+                dev_err(&pdev->dev, "IRQ not found\n");
+                ret = -ENXIO;
+                goto udc_remove;
+        }
+
+        ret = request_irq(irq, msm_udc_irq, IRQF_SHARED, pdev->name, pdev);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "request_irq failed\n");
+                goto udc_remove;
+        }
+
+        pm_runtime_no_callbacks(&pdev->dev);
+        pm_runtime_enable(&pdev->dev);
+
+        return 0;
+
+udc_remove:
+        udc_remove();
+iounmap:
+        iounmap(regs);
+
+        return ret;
+}
+
+static struct platform_driver ci13xxx_msm_driver = {
+        .probe = ci13xxx_msm_probe,
+        .driver = { .name = "msm_hsusb", },
+};
+
+static int __init ci13xxx_msm_init(void)
+{
+        return platform_driver_register(&ci13xxx_msm_driver);
+}
+module_init(ci13xxx_msm_init);
diff --git a/drivers/usb/gadget/ci13xxx_pci.c b/drivers/usb/gadget/ci13xxx_pci.c
new file mode 100644
index 000000000000..883ab5e832d1
--- /dev/null
+++ b/drivers/usb/gadget/ci13xxx_pci.c
@@ -0,0 +1,176 @@
+/*
+ * ci13xxx_pci.c - MIPS USB IP core family device controller
+ *
+ * Copyright (C) 2008 Chipidea - MIPS Technologies, Inc. All rights reserved.
+ *
+ * Author: David Lopo
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/module.h>
+#include <linux/pci.h>
+
+#include "ci13xxx_udc.c"
+
+/* driver name */
+#define UDC_DRIVER_NAME   "ci13xxx_pci"
+
+/******************************************************************************
+ * PCI block
+ *****************************************************************************/
+/**
+ * ci13xxx_pci_irq: interrut handler
+ * @irq:  irq number
+ * @pdev: USB Device Controller interrupt source
+ *
+ * This function returns IRQ_HANDLED if the IRQ has been handled
+ * This is an ISR don't trace, use attribute interface instead
+ */
+static irqreturn_t ci13xxx_pci_irq(int irq, void *pdev)
+{
+        if (irq == 0) {
+                dev_err(&((struct pci_dev *)pdev)->dev, "Invalid IRQ0 usage!");
+                return IRQ_HANDLED;
+        }
+        return udc_irq();
+}
+
+static struct ci13xxx_udc_driver ci13xxx_pci_udc_driver = {
+        .name           = UDC_DRIVER_NAME,
+};
+
+/**
+ * ci13xxx_pci_probe: PCI probe
+ * @pdev: USB device controller being probed
+ * @id:   PCI hotplug ID connecting controller to UDC framework
+ *
+ * This function returns an error code
+ * Allocates basic PCI resources for this USB device controller, and then
+ * invokes the udc_probe() method to start the UDC associated with it
+ */
+static int __devinit ci13xxx_pci_probe(struct pci_dev *pdev,
+                                       const struct pci_device_id *id)
+{
+        void __iomem *regs = NULL;
+        int retval = 0;
+
+        if (id == NULL)
+                return -EINVAL;
+
+        retval = pci_enable_device(pdev);
+        if (retval)
+                goto done;
+
+        if (!pdev->irq) {
+                dev_err(&pdev->dev, "No IRQ, check BIOS/PCI setup!");
+                retval = -ENODEV;
+                goto disable_device;
+        }
+
+        retval = pci_request_regions(pdev, UDC_DRIVER_NAME);
+        if (retval)
+                goto disable_device;
+
+        /* BAR 0 holds all the registers */
+        regs = pci_iomap(pdev, 0, 0);
+        if (!regs) {
+                dev_err(&pdev->dev, "Error mapping memory!");
+                retval = -EFAULT;
+                goto release_regions;
+        }
+        pci_set_drvdata(pdev, (__force void *)regs);
+
+        pci_set_master(pdev);
+        pci_try_set_mwi(pdev);
+
+        retval = udc_probe(&ci13xxx_pci_udc_driver, &pdev->dev, regs);
+        if (retval)
+                goto iounmap;
+
+        /* our device does not have MSI capability */
+
+        retval = request_irq(pdev->irq, ci13xxx_pci_irq, IRQF_SHARED,
+                             UDC_DRIVER_NAME, pdev);
+        if (retval)
+                goto gadget_remove;
+
+        return 0;
+
+ gadget_remove:
+        udc_remove();
+ iounmap:
+        pci_iounmap(pdev, regs);
+ release_regions:
+        pci_release_regions(pdev);
+ disable_device:
+        pci_disable_device(pdev);
+ done:
+        return retval;
+}
+
+/**
+ * ci13xxx_pci_remove: PCI remove
+ * @pdev: USB Device Controller being removed
+ *
+ * Reverses the effect of ci13xxx_pci_probe(),
+ * first invoking the udc_remove() and then releases
+ * all PCI resources allocated for this USB device controller
+ */
+static void __devexit ci13xxx_pci_remove(struct pci_dev *pdev)
+{
+        free_irq(pdev->irq, pdev);
+        udc_remove();
+        pci_iounmap(pdev, (__force void __iomem *)pci_get_drvdata(pdev));
+        pci_release_regions(pdev);
+        pci_disable_device(pdev);
+}
+
+/**
+ * PCI device table
+ * PCI device structure
+ *
+ * Check "pci.h" for details
+ */
+static DEFINE_PCI_DEVICE_TABLE(ci13xxx_pci_id_table) = {
+        { PCI_DEVICE(0x153F, 0x1004) },
+        { PCI_DEVICE(0x153F, 0x1006) },
+        { 0, 0, 0, 0, 0, 0, 0 /* end: all zeroes */ }
+};
+MODULE_DEVICE_TABLE(pci, ci13xxx_pci_id_table);
+
+static struct pci_driver ci13xxx_pci_driver = {
+        .name         = UDC_DRIVER_NAME,
+        .id_table     = ci13xxx_pci_id_table,
+        .probe        = ci13xxx_pci_probe,
+        .remove       = __devexit_p(ci13xxx_pci_remove),
+};
+
+/**
+ * ci13xxx_pci_init: module init
+ *
+ * Driver load
+ */
+static int __init ci13xxx_pci_init(void)
+{
+        return pci_register_driver(&ci13xxx_pci_driver);
+}
+module_init(ci13xxx_pci_init);
+
+/**
+ * ci13xxx_pci_exit: module exit
+ *
+ * Driver unload
+ */
+static void __exit ci13xxx_pci_exit(void)
+{
+        pci_unregister_driver(&ci13xxx_pci_driver);
+}
+module_exit(ci13xxx_pci_exit);
+
+MODULE_AUTHOR("MIPS - David Lopo <dlopo@chipidea.mips.com>");
+MODULE_DESCRIPTION("MIPS CI13XXX USB Peripheral Controller");
+MODULE_LICENSE("GPL");
+MODULE_VERSION("June 2008");
diff --git a/drivers/usb/gadget/ci13xxx_udc.c b/drivers/usb/gadget/ci13xxx_udc.c
index 699695128e33..baaf87ed7685 100644
--- a/drivers/usb/gadget/ci13xxx_udc.c
+++ b/drivers/usb/gadget/ci13xxx_udc.c
@@ -22,7 +22,6 @@
  * - ENDPT:  endpoint operations (Gadget API)
  * - GADGET: gadget operations (Gadget API)
  * - BUS:    bus glue code, bus abstraction layer
- * - PCI:    PCI core interface and PCI resources (interrupts, memory...)
  *
  * Compile Options
  * - CONFIG_USB_GADGET_DEBUG_FILES: enable debug facilities
@@ -60,11 +59,11 @@
 #include <linux/io.h>
 #include <linux/irq.h>
 #include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/pci.h>
 #include <linux/slab.h>
+#include <linux/pm_runtime.h>
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
+#include <linux/usb/otg.h>
 
 #include "ci13xxx_udc.h"
 
@@ -75,15 +74,23 @@
 /* ctrl register bank access */
 static DEFINE_SPINLOCK(udc_lock);
 
-/* driver name */
-#define UDC_DRIVER_NAME   "ci13xxx_udc"
-
 /* control endpoint description */
 static const struct usb_endpoint_descriptor
-ctrl_endpt_desc = {
+ctrl_endpt_out_desc = {
+        .bLength         = USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType = USB_DT_ENDPOINT,
+
+        .bEndpointAddress = USB_DIR_OUT,
+        .bmAttributes    = USB_ENDPOINT_XFER_CONTROL,
+        .wMaxPacketSize  = cpu_to_le16(CTRL_PAYLOAD_MAX),
+};
+
+static const struct usb_endpoint_descriptor
+ctrl_endpt_in_desc = {
         .bLength         = USB_DT_ENDPOINT_SIZE,
         .bDescriptorType = USB_DT_ENDPOINT,
 
+        .bEndpointAddress = USB_DIR_IN,
         .bmAttributes    = USB_ENDPOINT_XFER_CONTROL,
         .wMaxPacketSize  = cpu_to_le16(CTRL_PAYLOAD_MAX),
 };
@@ -132,6 +139,9 @@ static struct {
         size_t        size;   /* bank size */
 } hw_bank;
 
+/* MSM specific */
+#define ABS_AHBBURST        (0x0090UL)
+#define ABS_AHBMODE         (0x0098UL)
 /* UDC register map */
 #define ABS_CAPLENGTH       (0x100UL)
 #define ABS_HCCPARAMS       (0x108UL)
@@ -248,13 +258,7 @@ static u32 hw_ctest_and_write(u32 addr, u32 mask, u32 data)
         return (reg & mask) >> ffs_nr(mask);
 }
 
-/**
- * hw_device_reset: resets chip (execute without interruption)
- * @base: register base address
- *
- * This function returns an error code
- */
-static int hw_device_reset(void __iomem *base)
+static int hw_device_init(void __iomem *base)
 {
         u32 reg;
 
@@ -271,6 +275,28 @@ static int hw_device_reset(void __iomem *base)
         hw_bank.size += CAP_LAST;
         hw_bank.size /= sizeof(u32);
 
+        reg = hw_aread(ABS_DCCPARAMS, DCCPARAMS_DEN) >> ffs_nr(DCCPARAMS_DEN);
+        hw_ep_max = reg * 2;   /* cache hw ENDPT_MAX */
+
+        if (hw_ep_max == 0 || hw_ep_max > ENDPT_MAX)
+                return -ENODEV;
+
+        /* setup lock mode ? */
+
+        /* ENDPTSETUPSTAT is '0' by default */
+
+        /* HCSPARAMS.bf.ppc SHOULD BE zero for device */
+
+        return 0;
+}
+/**
+ * hw_device_reset: resets chip (execute without interruption)
+ * @base: register base address
+ *
+ * This function returns an error code
+ */
+static int hw_device_reset(struct ci13xxx *udc)
+{
         /* should flush & stop before reset */
         hw_cwrite(CAP_ENDPTFLUSH, ~0, ~0);
         hw_cwrite(CAP_USBCMD, USBCMD_RS, 0);
@@ -279,6 +305,14 @@ static int hw_device_reset(void __iomem *base)
         while (hw_cread(CAP_USBCMD, USBCMD_RST))
                 udelay(10);             /* not RTOS friendly */
 
+
+        if (udc->udc_driver->notify_event)
+                udc->udc_driver->notify_event(udc,
+                        CI13XXX_CONTROLLER_RESET_EVENT);
+
+        if (udc->udc_driver->flags & CI13XXX_DISABLE_STREAMING)
+                hw_cwrite(CAP_USBMODE, USBMODE_SDIS, USBMODE_SDIS);
+
         /* USBMODE should be configured step by step */
         hw_cwrite(CAP_USBMODE, USBMODE_CM, USBMODE_CM_IDLE);
         hw_cwrite(CAP_USBMODE, USBMODE_CM, USBMODE_CM_DEVICE);
@@ -290,18 +324,6 @@ static int hw_device_reset(void __iomem *base)
                 return -ENODEV;
         }
 
-        reg = hw_aread(ABS_DCCPARAMS, DCCPARAMS_DEN) >> ffs_nr(DCCPARAMS_DEN);
-        if (reg == 0 || reg > ENDPT_MAX)
-                return -ENODEV;
-
-        hw_ep_max = reg;   /* cache hw ENDPT_MAX */
-
-        /* setup lock mode ? */
-
-        /* ENDPTSETUPSTAT is '0' by default */
-
-        /* HCSPARAMS.bf.ppc SHOULD BE zero for device */
-
         return 0;
 }
 
@@ -413,20 +435,6 @@ static int hw_ep_get_halt(int num, int dir)
 }
 
 /**
- * hw_ep_is_primed: test if endpoint is primed (execute without interruption)
- * @num:   endpoint number
- * @dir:   endpoint direction
- *
- * This function returns true if endpoint primed
- */
-static int hw_ep_is_primed(int num, int dir)
-{
-        u32 reg = hw_cread(CAP_ENDPTPRIME, ~0) | hw_cread(CAP_ENDPTSTAT, ~0);
-
-        return test_bit(hw_ep_bit(num, dir), (void *)&reg);
-}
-
-/**
  * hw_test_and_clear_setup_status: test & clear setup status (execute without
  *                                 interruption)
  * @n: bit number (endpoint)
@@ -450,10 +458,6 @@ static int hw_ep_prime(int num, int dir, int is_ctrl)
 {
         int n = hw_ep_bit(num, dir);
 
-        /* the caller should flush first */
-        if (hw_ep_is_primed(num, dir))
-                return -EBUSY;
-
         if (is_ctrl && dir == RX && hw_cread(CAP_ENDPTSETUPSTAT, BIT(num)))
                 return -EAGAIN;
 
@@ -1186,16 +1190,17 @@ static ssize_t show_qheads(struct device *dev, struct device_attribute *attr,
         }
 
         spin_lock_irqsave(udc->lock, flags);
-        for (i = 0; i < hw_ep_max; i++) {
-                struct ci13xxx_ep *mEp = &udc->ci13xxx_ep[i];
+        for (i = 0; i < hw_ep_max/2; i++) {
+                struct ci13xxx_ep *mEpRx = &udc->ci13xxx_ep[i];
+                struct ci13xxx_ep *mEpTx = &udc->ci13xxx_ep[i + hw_ep_max/2];
                 n += scnprintf(buf + n, PAGE_SIZE - n,
                                "EP=%02i: RX=%08X TX=%08X\n",
-                               i, (u32)mEp->qh[RX].dma, (u32)mEp->qh[TX].dma);
+                               i, (u32)mEpRx->qh.dma, (u32)mEpTx->qh.dma);
                 for (j = 0; j < (sizeof(struct ci13xxx_qh)/sizeof(u32)); j++) {
                         n += scnprintf(buf + n, PAGE_SIZE - n,
                                        " %04X:    %08X    %08X\n", j,
-                                       *((u32 *)mEp->qh[RX].ptr + j),
-                                       *((u32 *)mEp->qh[TX].ptr + j));
+                                       *((u32 *)mEpRx->qh.ptr + j),
+                                       *((u32 *)mEpTx->qh.ptr + j));
                 }
         }
         spin_unlock_irqrestore(udc->lock, flags);
@@ -1282,7 +1287,7 @@ static ssize_t show_requests(struct device *dev, struct device_attribute *attr,
         unsigned long flags;
         struct list_head   *ptr = NULL;
         struct ci13xxx_req *req = NULL;
-        unsigned i, j, k, n = 0, qSize = sizeof(struct ci13xxx_td)/sizeof(u32);
+        unsigned i, j, n = 0, qSize = sizeof(struct ci13xxx_td)/sizeof(u32);
 
         dbg_trace("[%s] %p\n", __func__, buf);
         if (attr == NULL || buf == NULL) {
@@ -1292,22 +1297,20 @@ static ssize_t show_requests(struct device *dev, struct device_attribute *attr,
 
         spin_lock_irqsave(udc->lock, flags);
         for (i = 0; i < hw_ep_max; i++)
-                for (k = RX; k <= TX; k++)
-                        list_for_each(ptr, &udc->ci13xxx_ep[i].qh[k].queue)
-                        {
-                                req = list_entry(ptr,
-                                                 struct ci13xxx_req, queue);
+                list_for_each(ptr, &udc->ci13xxx_ep[i].qh.queue)
+                {
+                        req = list_entry(ptr, struct ci13xxx_req, queue);
 
+                        n += scnprintf(buf + n, PAGE_SIZE - n,
+                                        "EP=%02i: TD=%08X %s\n",
+                                        i % hw_ep_max/2, (u32)req->dma,
+                                        ((i < hw_ep_max/2) ? "RX" : "TX"));
+
+                        for (j = 0; j < qSize; j++)
                                 n += scnprintf(buf + n, PAGE_SIZE - n,
-                                               "EP=%02i: TD=%08X %s\n",
-                                               i, (u32)req->dma,
-                                               ((k == RX) ? "RX" : "TX"));
-
-                                for (j = 0; j < qSize; j++)
-                                        n += scnprintf(buf + n, PAGE_SIZE - n,
-                                                       " %04X:    %08X\n", j,
-                                                       *((u32 *)req->ptr + j));
-                        }
+                                                " %04X:    %08X\n", j,
+                                                *((u32 *)req->ptr + j));
+                }
         spin_unlock_irqrestore(udc->lock, flags);
 
         return n;
@@ -1413,6 +1416,8 @@ static inline u8 _usb_addr(struct ci13xxx_ep *ep)
 static int _hardware_enqueue(struct ci13xxx_ep *mEp, struct ci13xxx_req *mReq)
 {
         unsigned i;
+        int ret = 0;
+        unsigned length = mReq->req.length;
 
         trace("%p, %p", mEp, mReq);
 
@@ -1420,53 +1425,91 @@ static int _hardware_enqueue(struct ci13xxx_ep *mEp, struct ci13xxx_req *mReq)
         if (mReq->req.status == -EALREADY)
                 return -EALREADY;
 
-        if (hw_ep_is_primed(mEp->num, mEp->dir))
-                return -EBUSY;
-
         mReq->req.status = -EALREADY;
-
-        if (mReq->req.length && !mReq->req.dma) {
+        if (length && !mReq->req.dma) {
                 mReq->req.dma = \
                         dma_map_single(mEp->device, mReq->req.buf,
-                                       mReq->req.length, mEp->dir ?
-                                       DMA_TO_DEVICE : DMA_FROM_DEVICE);
+                                       length, mEp->dir ? DMA_TO_DEVICE :
+                                       DMA_FROM_DEVICE);
                 if (mReq->req.dma == 0)
                         return -ENOMEM;
 
                 mReq->map = 1;
         }
 
+        if (mReq->req.zero && length && (length % mEp->ep.maxpacket == 0)) {
+                mReq->zptr = dma_pool_alloc(mEp->td_pool, GFP_ATOMIC,
+                                           &mReq->zdma);
+                if (mReq->zptr == NULL) {
+                        if (mReq->map) {
+                                dma_unmap_single(mEp->device, mReq->req.dma,
+                                        length, mEp->dir ? DMA_TO_DEVICE :
+                                        DMA_FROM_DEVICE);
+                                mReq->req.dma = 0;
+                                mReq->map     = 0;
+                        }
+                        return -ENOMEM;
+                }
+                memset(mReq->zptr, 0, sizeof(*mReq->zptr));
+                mReq->zptr->next    = TD_TERMINATE;
+                mReq->zptr->token   = TD_STATUS_ACTIVE;
+                if (!mReq->req.no_interrupt)
+                        mReq->zptr->token   |= TD_IOC;
+        }
         /*
          * TD configuration
          * TODO - handle requests which spawns into several TDs
          */
         memset(mReq->ptr, 0, sizeof(*mReq->ptr));
-        mReq->ptr->next    |= TD_TERMINATE;
-        mReq->ptr->token    = mReq->req.length << ffs_nr(TD_TOTAL_BYTES);
+        mReq->ptr->token    = length << ffs_nr(TD_TOTAL_BYTES);
         mReq->ptr->token   &= TD_TOTAL_BYTES;
-        mReq->ptr->token   |= TD_IOC;
         mReq->ptr->token   |= TD_STATUS_ACTIVE;
+        if (mReq->zptr) {
+                mReq->ptr->next    = mReq->zdma;
+        } else {
+                mReq->ptr->next    = TD_TERMINATE;
+                if (!mReq->req.no_interrupt)
+                        mReq->ptr->token  |= TD_IOC;
+        }
         mReq->ptr->page[0]  = mReq->req.dma;
         for (i = 1; i < 5; i++)
                 mReq->ptr->page[i] =
-                        (mReq->req.dma + i * PAGE_SIZE) & ~TD_RESERVED_MASK;
+                        (mReq->req.dma + i * CI13XXX_PAGE_SIZE) & ~TD_RESERVED_MASK;
 
-        /*
-         *  QH configuration
-         *  At this point it's guaranteed exclusive access to qhead
-         *  (endpt is not primed) so it's no need to use tripwire
-         */
-        mEp->qh[mEp->dir].ptr->td.next   = mReq->dma;    /* TERMINATE = 0 */
-        mEp->qh[mEp->dir].ptr->td.token &= ~TD_STATUS;   /* clear status */
-        if (mReq->req.zero == 0)
-                mEp->qh[mEp->dir].ptr->cap |=  QH_ZLT;
-        else
-                mEp->qh[mEp->dir].ptr->cap &= ~QH_ZLT;
+        if (!list_empty(&mEp->qh.queue)) {
+                struct ci13xxx_req *mReqPrev;
+                int n = hw_ep_bit(mEp->num, mEp->dir);
+                int tmp_stat;
+
+                mReqPrev = list_entry(mEp->qh.queue.prev,
+                                struct ci13xxx_req, queue);
+                if (mReqPrev->zptr)
+                        mReqPrev->zptr->next = mReq->dma & TD_ADDR_MASK;
+                else
+                        mReqPrev->ptr->next = mReq->dma & TD_ADDR_MASK;
+                wmb();
+                if (hw_cread(CAP_ENDPTPRIME, BIT(n)))
+                        goto done;
+                do {
+                        hw_cwrite(CAP_USBCMD, USBCMD_ATDTW, USBCMD_ATDTW);
+                        tmp_stat = hw_cread(CAP_ENDPTSTAT, BIT(n));
+                } while (!hw_cread(CAP_USBCMD, USBCMD_ATDTW));
+                hw_cwrite(CAP_USBCMD, USBCMD_ATDTW, 0);
+                if (tmp_stat)
+                        goto done;
+        }
+
+        /*  QH configuration */
+        mEp->qh.ptr->td.next   = mReq->dma;    /* TERMINATE = 0 */
+        mEp->qh.ptr->td.token &= ~TD_STATUS;   /* clear status */
+        mEp->qh.ptr->cap |=  QH_ZLT;
 
         wmb();   /* synchronize before ep prime */
 
-        return hw_ep_prime(mEp->num, mEp->dir,
+        ret = hw_ep_prime(mEp->num, mEp->dir,
                            mEp->type == USB_ENDPOINT_XFER_CONTROL);
+done:
+        return ret;
 }
 
 /**
@@ -1483,8 +1526,15 @@ static int _hardware_dequeue(struct ci13xxx_ep *mEp, struct ci13xxx_req *mReq)
         if (mReq->req.status != -EALREADY)
                 return -EINVAL;
 
-        if (hw_ep_is_primed(mEp->num, mEp->dir))
-                hw_ep_flush(mEp->num, mEp->dir);
+        if ((TD_STATUS_ACTIVE & mReq->ptr->token) != 0)
+                return -EBUSY;
+
+        if (mReq->zptr) {
+                if ((TD_STATUS_ACTIVE & mReq->zptr->token) != 0)
+                        return -EBUSY;
+                dma_pool_free(mEp->td_pool, mReq->zptr, mReq->zdma);
+                mReq->zptr = NULL;
+        }
 
         mReq->req.status = 0;
 
@@ -1496,9 +1546,7 @@ static int _hardware_dequeue(struct ci13xxx_ep *mEp, struct ci13xxx_req *mReq)
         }
 
         mReq->req.status = mReq->ptr->token & TD_STATUS;
-        if      ((TD_STATUS_ACTIVE & mReq->req.status) != 0)
-                mReq->req.status = -ECONNRESET;
-        else if ((TD_STATUS_HALTED & mReq->req.status) != 0)
+        if ((TD_STATUS_HALTED & mReq->req.status) != 0)
                 mReq->req.status = -1;
         else if ((TD_STATUS_DT_ERR & mReq->req.status) != 0)
                 mReq->req.status = -1;
@@ -1531,16 +1579,16 @@ __acquires(mEp->lock)
 
         hw_ep_flush(mEp->num, mEp->dir);
 
-        while (!list_empty(&mEp->qh[mEp->dir].queue)) {
+        while (!list_empty(&mEp->qh.queue)) {
 
                 /* pop oldest request */
                 struct ci13xxx_req *mReq = \
-                        list_entry(mEp->qh[mEp->dir].queue.next,
+                        list_entry(mEp->qh.queue.next,
                                    struct ci13xxx_req, queue);
                 list_del_init(&mReq->queue);
                 mReq->req.status = -ESHUTDOWN;
 
-                if (!mReq->req.no_interrupt && mReq->req.complete != NULL) {
+                if (mReq->req.complete != NULL) {
                         spin_unlock(mEp->lock);
                         mReq->req.complete(&mEp->ep, &mReq->req);
                         spin_lock(mEp->lock);
@@ -1557,26 +1605,28 @@ __acquires(mEp->lock)
  * Caller must hold lock
  */
 static int _gadget_stop_activity(struct usb_gadget *gadget)
-__releases(udc->lock)
-__acquires(udc->lock)
 {
         struct usb_ep *ep;
         struct ci13xxx    *udc = container_of(gadget, struct ci13xxx, gadget);
-        struct ci13xxx_ep *mEp = container_of(gadget->ep0,
-                                              struct ci13xxx_ep, ep);
+        unsigned long flags;
 
         trace("%p", gadget);
 
         if (gadget == NULL)
                 return -EINVAL;
 
-        spin_unlock(udc->lock);
+        spin_lock_irqsave(udc->lock, flags);
+        udc->gadget.speed = USB_SPEED_UNKNOWN;
+        udc->remote_wakeup = 0;
+        udc->suspended = 0;
+        spin_unlock_irqrestore(udc->lock, flags);
 
         /* flush all endpoints */
         gadget_for_each_ep(ep, gadget) {
                 usb_ep_fifo_flush(ep);
         }
-        usb_ep_fifo_flush(gadget->ep0);
+        usb_ep_fifo_flush(&udc->ep0out.ep);
+        usb_ep_fifo_flush(&udc->ep0in.ep);
 
         udc->driver->disconnect(gadget);
 
@@ -1584,15 +1634,12 @@ __acquires(udc->lock)
         gadget_for_each_ep(ep, gadget) {
                 usb_ep_disable(ep);
         }
-        usb_ep_disable(gadget->ep0);
 
-        if (mEp->status != NULL) {
-                usb_ep_free_request(gadget->ep0, mEp->status);
-                mEp->status = NULL;
+        if (udc->status != NULL) {
+                usb_ep_free_request(&udc->ep0in.ep, udc->status);
+                udc->status = NULL;
         }
 
-        spin_lock(udc->lock);
-
         return 0;
 }
 
@@ -1609,7 +1656,6 @@ static void isr_reset_handler(struct ci13xxx *udc)
 __releases(udc->lock)
 __acquires(udc->lock)
 {
-        struct ci13xxx_ep *mEp = &udc->ci13xxx_ep[0];
         int retval;
 
         trace("%p", udc);
@@ -1621,6 +1667,7 @@ __acquires(udc->lock)
 
         dbg_event(0xFF, "BUS RST", 0);
 
+        spin_unlock(udc->lock);
         retval = _gadget_stop_activity(&udc->gadget);
         if (retval)
                 goto done;
@@ -1629,15 +1676,10 @@ __acquires(udc->lock)
         if (retval)
                 goto done;
 
-        spin_unlock(udc->lock);
-        retval = usb_ep_enable(&mEp->ep, &ctrl_endpt_desc);
-        if (!retval) {
-                mEp->status = usb_ep_alloc_request(&mEp->ep, GFP_KERNEL);
-                if (mEp->status == NULL) {
-                        usb_ep_disable(&mEp->ep);
-                        retval = -ENOMEM;
-                }
-        }
+        udc->status = usb_ep_alloc_request(&udc->ep0in.ep, GFP_ATOMIC);
+        if (udc->status == NULL)
+                retval = -ENOMEM;
+
         spin_lock(udc->lock);
 
  done:
@@ -1667,16 +1709,17 @@ static void isr_get_status_complete(struct usb_ep *ep, struct usb_request *req)
 
 /**
  * isr_get_status_response: get_status request response
- * @ep:    endpoint
+ * @udc: udc struct
  * @setup: setup request packet
  *
  * This function returns an error code
  */
-static int isr_get_status_response(struct ci13xxx_ep *mEp,
+static int isr_get_status_response(struct ci13xxx *udc,
                                    struct usb_ctrlrequest *setup)
 __releases(mEp->lock)
 __acquires(mEp->lock)
 {
+        struct ci13xxx_ep *mEp = &udc->ep0in;
         struct usb_request *req = NULL;
         gfp_t gfp_flags = GFP_ATOMIC;
         int dir, num, retval;
@@ -1701,7 +1744,8 @@ __acquires(mEp->lock)
         }
 
         if ((setup->bRequestType & USB_RECIP_MASK) == USB_RECIP_DEVICE) {
-                /* TODO: D1 - Remote Wakeup; D0 - Self Powered */
+                /* Assume that device is bus powered for now. */
+                *((u16 *)req->buf) = _udc->remote_wakeup << 1;
                 retval = 0;
         } else if ((setup->bRequestType & USB_RECIP_MASK) \
                    == USB_RECIP_ENDPOINT) {
@@ -1730,28 +1774,48 @@ __acquires(mEp->lock)
 }
 
 /**
+ * isr_setup_status_complete: setup_status request complete function
+ * @ep:  endpoint
+ * @req: request handled
+ *
+ * Caller must release lock. Put the port in test mode if test mode
+ * feature is selected.
+ */
+static void
+isr_setup_status_complete(struct usb_ep *ep, struct usb_request *req)
+{
+        struct ci13xxx *udc = req->context;
+        unsigned long flags;
+
+        trace("%p, %p", ep, req);
+
+        spin_lock_irqsave(udc->lock, flags);
+        if (udc->test_mode)
+                hw_port_test_set(udc->test_mode);
+        spin_unlock_irqrestore(udc->lock, flags);
+}
+
+/**
  * isr_setup_status_phase: queues the status phase of a setup transation
- * @mEp: endpoint
+ * @udc: udc struct
  *
  * This function returns an error code
  */
-static int isr_setup_status_phase(struct ci13xxx_ep *mEp)
+static int isr_setup_status_phase(struct ci13xxx *udc)
 __releases(mEp->lock)
 __acquires(mEp->lock)
 {
         int retval;
+        struct ci13xxx_ep *mEp;
 
-        trace("%p", mEp);
-
-        /* mEp is always valid & configured */
-
-        if (mEp->type == USB_ENDPOINT_XFER_CONTROL)
-                mEp->dir = (mEp->dir == TX) ? RX : TX;
+        trace("%p", udc);
 
-        mEp->status->no_interrupt = 1;
+        mEp = (udc->ep0_dir == TX) ? &udc->ep0out : &udc->ep0in;
+        udc->status->context = udc;
+        udc->status->complete = isr_setup_status_complete;
 
         spin_unlock(mEp->lock);
-        retval = usb_ep_queue(&mEp->ep, mEp->status, GFP_ATOMIC);
+        retval = usb_ep_queue(&mEp->ep, udc->status, GFP_ATOMIC);
         spin_lock(mEp->lock);
 
         return retval;
@@ -1768,40 +1832,37 @@ static int isr_tr_complete_low(struct ci13xxx_ep *mEp)
 __releases(mEp->lock)
 __acquires(mEp->lock)
 {
-        struct ci13xxx_req *mReq;
-        int retval;
+        struct ci13xxx_req *mReq, *mReqTemp;
+        struct ci13xxx_ep *mEpTemp = mEp;
+        int uninitialized_var(retval);
 
         trace("%p", mEp);
 
-        if (list_empty(&mEp->qh[mEp->dir].queue))
+        if (list_empty(&mEp->qh.queue))
                 return -EINVAL;
 
-        /* pop oldest request */
-        mReq = list_entry(mEp->qh[mEp->dir].queue.next,
-                          struct ci13xxx_req, queue);
-        list_del_init(&mReq->queue);
-
-        retval = _hardware_dequeue(mEp, mReq);
-        if (retval < 0) {
-                dbg_event(_usb_addr(mEp), "DONE", retval);
-                goto done;
-        }
-
-        dbg_done(_usb_addr(mEp), mReq->ptr->token, retval);
-
-        if (!mReq->req.no_interrupt && mReq->req.complete != NULL) {
-                spin_unlock(mEp->lock);
-                mReq->req.complete(&mEp->ep, &mReq->req);
-                spin_lock(mEp->lock);
+        list_for_each_entry_safe(mReq, mReqTemp, &mEp->qh.queue,
+                        queue) {
+                retval = _hardware_dequeue(mEp, mReq);
+                if (retval < 0)
+                        break;
+                list_del_init(&mReq->queue);
+                dbg_done(_usb_addr(mEp), mReq->ptr->token, retval);
+                if (mReq->req.complete != NULL) {
+                        spin_unlock(mEp->lock);
+                        if ((mEp->type == USB_ENDPOINT_XFER_CONTROL) &&
+                                        mReq->req.length)
+                                mEpTemp = &_udc->ep0in;
+                        mReq->req.complete(&mEpTemp->ep, &mReq->req);
+                        spin_lock(mEp->lock);
+                }
         }
 
-        if (!list_empty(&mEp->qh[mEp->dir].queue)) {
-                mReq = list_entry(mEp->qh[mEp->dir].queue.next,
-                                  struct ci13xxx_req, queue);
-                _hardware_enqueue(mEp, mReq);
-        }
+        if (retval == -EBUSY)
+                retval = 0;
+        if (retval < 0)
+                dbg_event(_usb_addr(mEp), "DONE", retval);
 
- done:
         return retval;
 }
 
@@ -1816,6 +1877,7 @@ __releases(udc->lock)
 __acquires(udc->lock)
 {
         unsigned i;
+        u8 tmode = 0;
 
         trace("%p", udc);
 
@@ -1826,19 +1888,17 @@ __acquires(udc->lock)
 
         for (i = 0; i < hw_ep_max; i++) {
                 struct ci13xxx_ep *mEp  = &udc->ci13xxx_ep[i];
-                int type, num, err = -EINVAL;
+                int type, num, dir, err = -EINVAL;
                 struct usb_ctrlrequest req;
 
-
                 if (mEp->desc == NULL)
                         continue;   /* not configured */
 
-                if ((mEp->dir == RX && hw_test_and_clear_complete(i)) ||
-                    (mEp->dir == TX && hw_test_and_clear_complete(i + 16))) {
+                if (hw_test_and_clear_complete(i)) {
                         err = isr_tr_complete_low(mEp);
                         if (mEp->type == USB_ENDPOINT_XFER_CONTROL) {
                                 if (err > 0)   /* needs status phase */
-                                        err = isr_setup_status_phase(mEp);
+                                        err = isr_setup_status_phase(udc);
                                 if (err < 0) {
                                         dbg_event(_usb_addr(mEp),
                                                   "ERROR", err);
@@ -1859,36 +1919,56 @@ __acquires(udc->lock)
                         continue;
                 }
 
+                /*
+                 * Flush data and handshake transactions of previous
+                 * setup packet.
+                 */
+                _ep_nuke(&udc->ep0out);
+                _ep_nuke(&udc->ep0in);
+
                 /* read_setup_packet */
                 do {
                         hw_test_and_set_setup_guard();
-                        memcpy(&req, &mEp->qh[RX].ptr->setup, sizeof(req));
+                        memcpy(&req, &mEp->qh.ptr->setup, sizeof(req));
                 } while (!hw_test_and_clear_setup_guard());
 
                 type = req.bRequestType;
 
-                mEp->dir = (type & USB_DIR_IN) ? TX : RX;
+                udc->ep0_dir = (type & USB_DIR_IN) ? TX : RX;
 
                 dbg_setup(_usb_addr(mEp), &req);
 
                 switch (req.bRequest) {
                 case USB_REQ_CLEAR_FEATURE:
-                        if (type != (USB_DIR_OUT|USB_RECIP_ENDPOINT) &&
-                            le16_to_cpu(req.wValue) != USB_ENDPOINT_HALT)
-                                goto delegate;
-                        if (req.wLength != 0)
-                                break;
-                        num  = le16_to_cpu(req.wIndex);
-                        num &= USB_ENDPOINT_NUMBER_MASK;
-                        if (!udc->ci13xxx_ep[num].wedge) {
-                                spin_unlock(udc->lock);
-                                err = usb_ep_clear_halt(
-                                        &udc->ci13xxx_ep[num].ep);
-                                spin_lock(udc->lock);
-                                if (err)
+                        if (type == (USB_DIR_OUT|USB_RECIP_ENDPOINT) &&
+                                        le16_to_cpu(req.wValue) ==
+                                        USB_ENDPOINT_HALT) {
+                                if (req.wLength != 0)
+                                        break;
+                                num  = le16_to_cpu(req.wIndex);
+                                dir = num & USB_ENDPOINT_DIR_MASK;
+                                num &= USB_ENDPOINT_NUMBER_MASK;
+                                if (dir) /* TX */
+                                        num += hw_ep_max/2;
+                                if (!udc->ci13xxx_ep[num].wedge) {
+                                        spin_unlock(udc->lock);
+                                        err = usb_ep_clear_halt(
+                                                &udc->ci13xxx_ep[num].ep);
+                                        spin_lock(udc->lock);
+                                        if (err)
+                                                break;
+                                }
+                                err = isr_setup_status_phase(udc);
+                        } else if (type == (USB_DIR_OUT|USB_RECIP_DEVICE) &&
+                                        le16_to_cpu(req.wValue) ==
+                                        USB_DEVICE_REMOTE_WAKEUP) {
+                                if (req.wLength != 0)
                                         break;
+                                udc->remote_wakeup = 0;
+                                err = isr_setup_status_phase(udc);
+                        } else {
+                                goto delegate;
                         }
-                        err = isr_setup_status_phase(mEp);
                         break;
                 case USB_REQ_GET_STATUS:
                         if (type != (USB_DIR_IN|USB_RECIP_DEVICE)   &&
@@ -1898,7 +1978,7 @@ __acquires(udc->lock)
                         if (le16_to_cpu(req.wLength) != 2 ||
                             le16_to_cpu(req.wValue)  != 0)
                                 break;
-                        err = isr_get_status_response(mEp, &req);
+                        err = isr_get_status_response(udc, &req);
                         break;
                 case USB_REQ_SET_ADDRESS:
                         if (type != (USB_DIR_OUT|USB_RECIP_DEVICE))
@@ -1909,28 +1989,59 @@ __acquires(udc->lock)
                         err = hw_usb_set_address((u8)le16_to_cpu(req.wValue));
                         if (err)
                                 break;
-                        err = isr_setup_status_phase(mEp);
+                        err = isr_setup_status_phase(udc);
                         break;
                 case USB_REQ_SET_FEATURE:
-                        if (type != (USB_DIR_OUT|USB_RECIP_ENDPOINT) &&
-                            le16_to_cpu(req.wValue) != USB_ENDPOINT_HALT)
-                                goto delegate;
-                        if (req.wLength != 0)
-                                break;
-                        num  = le16_to_cpu(req.wIndex);
-                        num &= USB_ENDPOINT_NUMBER_MASK;
+                        if (type == (USB_DIR_OUT|USB_RECIP_ENDPOINT) &&
+                                        le16_to_cpu(req.wValue) ==
+                                        USB_ENDPOINT_HALT) {
+                                if (req.wLength != 0)
+                                        break;
+                                num  = le16_to_cpu(req.wIndex);
+                                dir = num & USB_ENDPOINT_DIR_MASK;
+                                num &= USB_ENDPOINT_NUMBER_MASK;
+                                if (dir) /* TX */
+                                        num += hw_ep_max/2;
 
-                        spin_unlock(udc->lock);
-                        err = usb_ep_set_halt(&udc->ci13xxx_ep[num].ep);
-                        spin_lock(udc->lock);
-                        if (err)
-                                break;
-                        err = isr_setup_status_phase(mEp);
+                                spin_unlock(udc->lock);
+                                err = usb_ep_set_halt(&udc->ci13xxx_ep[num].ep);
+                                spin_lock(udc->lock);
+                                if (!err)
+                                        isr_setup_status_phase(udc);
+                        } else if (type == (USB_DIR_OUT|USB_RECIP_DEVICE)) {
+                                if (req.wLength != 0)
+                                        break;
+                                switch (le16_to_cpu(req.wValue)) {
+                                case USB_DEVICE_REMOTE_WAKEUP:
+                                        udc->remote_wakeup = 1;
+                                        err = isr_setup_status_phase(udc);
+                                        break;
+                                case USB_DEVICE_TEST_MODE:
+                                        tmode = le16_to_cpu(req.wIndex) >> 8;
+                                        switch (tmode) {
+                                        case TEST_J:
+                                        case TEST_K:
+                                        case TEST_SE0_NAK:
+                                        case TEST_PACKET:
+                                        case TEST_FORCE_EN:
+                                                udc->test_mode = tmode;
+                                                err = isr_setup_status_phase(
+                                                                udc);
+                                                break;
+                                        default:
+                                                break;
+                                        }
+                                default:
+                                        goto delegate;
+                                }
+                        } else {
+                                goto delegate;
+                        }
                         break;
                 default:
 delegate:
                         if (req.wLength == 0)   /* no data phase */
-                                mEp->dir = TX;
+                                udc->ep0_dir = TX;
 
                         spin_unlock(udc->lock);
                         err = udc->driver->setup(&udc->gadget, &req);
@@ -1961,7 +2072,7 @@ static int ep_enable(struct usb_ep *ep,
                      const struct usb_endpoint_descriptor *desc)
 {
         struct ci13xxx_ep *mEp = container_of(ep, struct ci13xxx_ep, ep);
-        int direction, retval = 0;
+        int retval = 0;
         unsigned long flags;
 
         trace("%p, %p", ep, desc);
@@ -1975,7 +2086,7 @@ static int ep_enable(struct usb_ep *ep,
 
         mEp->desc = desc;
 
-        if (!list_empty(&mEp->qh[mEp->dir].queue))
+        if (!list_empty(&mEp->qh.queue))
                 warn("enabling a non-empty endpoint!");
 
         mEp->dir  = usb_endpoint_dir_in(desc) ? TX : RX;
@@ -1984,30 +2095,28 @@ static int ep_enable(struct usb_ep *ep,
 
         mEp->ep.maxpacket = __constant_le16_to_cpu(desc->wMaxPacketSize);
 
-        direction = mEp->dir;
-        do {
-                dbg_event(_usb_addr(mEp), "ENABLE", 0);
+        dbg_event(_usb_addr(mEp), "ENABLE", 0);
 
-                mEp->qh[mEp->dir].ptr->cap = 0;
+        mEp->qh.ptr->cap = 0;
 
-                if (mEp->type == USB_ENDPOINT_XFER_CONTROL)
-                        mEp->qh[mEp->dir].ptr->cap |=  QH_IOS;
-                else if (mEp->type == USB_ENDPOINT_XFER_ISOC)
-                        mEp->qh[mEp->dir].ptr->cap &= ~QH_MULT;
-                else
-                        mEp->qh[mEp->dir].ptr->cap &= ~QH_ZLT;
+        if (mEp->type == USB_ENDPOINT_XFER_CONTROL)
+                mEp->qh.ptr->cap |=  QH_IOS;
+        else if (mEp->type == USB_ENDPOINT_XFER_ISOC)
+                mEp->qh.ptr->cap &= ~QH_MULT;
+        else
+                mEp->qh.ptr->cap &= ~QH_ZLT;
 
-                mEp->qh[mEp->dir].ptr->cap |=
-                        (mEp->ep.maxpacket << ffs_nr(QH_MAX_PKT)) & QH_MAX_PKT;
-                mEp->qh[mEp->dir].ptr->td.next |= TD_TERMINATE;   /* needed? */
+        mEp->qh.ptr->cap |=
+                (mEp->ep.maxpacket << ffs_nr(QH_MAX_PKT)) & QH_MAX_PKT;
+        mEp->qh.ptr->td.next |= TD_TERMINATE;   /* needed? */
 
+        /*
+         * Enable endpoints in the HW other than ep0 as ep0
+         * is always enabled
+         */
+        if (mEp->num)
                 retval |= hw_ep_enable(mEp->num, mEp->dir, mEp->type);
 
-                if (mEp->type == USB_ENDPOINT_XFER_CONTROL)
-                        mEp->dir = (mEp->dir == TX) ? RX : TX;
-
-        } while (mEp->dir != direction);
-
         spin_unlock_irqrestore(mEp->lock, flags);
         return retval;
 }
@@ -2061,7 +2170,6 @@ static struct usb_request *ep_alloc_request(struct usb_ep *ep, gfp_t gfp_flags)
 {
         struct ci13xxx_ep  *mEp  = container_of(ep, struct ci13xxx_ep, ep);
         struct ci13xxx_req *mReq = NULL;
-        unsigned long flags;
 
         trace("%p, %i", ep, gfp_flags);
 
@@ -2070,8 +2178,6 @@ static struct usb_request *ep_alloc_request(struct usb_ep *ep, gfp_t gfp_flags)
                 return NULL;
         }
 
-        spin_lock_irqsave(mEp->lock, flags);
-
         mReq = kzalloc(sizeof(struct ci13xxx_req), gfp_flags);
         if (mReq != NULL) {
                 INIT_LIST_HEAD(&mReq->queue);
@@ -2086,8 +2192,6 @@ static struct usb_request *ep_alloc_request(struct usb_ep *ep, gfp_t gfp_flags)
 
         dbg_event(_usb_addr(mEp), "ALLOC", mReq == NULL);
 
-        spin_unlock_irqrestore(mEp->lock, flags);
-
         return (mReq == NULL) ? NULL : &mReq->req;
 }
 
@@ -2143,11 +2247,15 @@ static int ep_queue(struct usb_ep *ep, struct usb_request *req,
 
         spin_lock_irqsave(mEp->lock, flags);
 
-        if (mEp->type == USB_ENDPOINT_XFER_CONTROL &&
-            !list_empty(&mEp->qh[mEp->dir].queue)) {
-                _ep_nuke(mEp);
-                retval = -EOVERFLOW;
-                warn("endpoint ctrl %X nuked", _usb_addr(mEp));
+        if (mEp->type == USB_ENDPOINT_XFER_CONTROL) {
+                if (req->length)
+                        mEp = (_udc->ep0_dir == RX) ?
+                                &_udc->ep0out : &_udc->ep0in;
+                if (!list_empty(&mEp->qh.queue)) {
+                        _ep_nuke(mEp);
+                        retval = -EOVERFLOW;
+                        warn("endpoint ctrl %X nuked", _usb_addr(mEp));
+                }
         }
 
         /* first nuke then test link, e.g. previous status has not sent */
@@ -2157,8 +2265,8 @@ static int ep_queue(struct usb_ep *ep, struct usb_request *req,
                 goto done;
         }
 
-        if (req->length > (4 * PAGE_SIZE)) {
-                req->length = (4 * PAGE_SIZE);
+        if (req->length > (4 * CI13XXX_PAGE_SIZE)) {
+                req->length = (4 * CI13XXX_PAGE_SIZE);
                 retval = -EMSGSIZE;
                 warn("request length truncated");
         }
@@ -2168,13 +2276,15 @@ static int ep_queue(struct usb_ep *ep, struct usb_request *req,
         /* push request */
         mReq->req.status = -EINPROGRESS;
         mReq->req.actual = 0;
-        list_add_tail(&mReq->queue, &mEp->qh[mEp->dir].queue);
 
         retval = _hardware_enqueue(mEp, mReq);
-        if (retval == -EALREADY || retval == -EBUSY) {
+
+        if (retval == -EALREADY) {
                 dbg_event(_usb_addr(mEp), "QUEUE", retval);
                 retval = 0;
         }
+        if (!retval)
+                list_add_tail(&mReq->queue, &mEp->qh.queue);
 
  done:
         spin_unlock_irqrestore(mEp->lock, flags);
@@ -2194,22 +2304,28 @@ static int ep_dequeue(struct usb_ep *ep, struct usb_request *req)
 
         trace("%p, %p", ep, req);
 
-        if (ep == NULL || req == NULL || mEp->desc == NULL ||
-            list_empty(&mReq->queue)  || list_empty(&mEp->qh[mEp->dir].queue))
+        if (ep == NULL || req == NULL || mReq->req.status != -EALREADY ||
+                mEp->desc == NULL || list_empty(&mReq->queue) ||
+                list_empty(&mEp->qh.queue))
                 return -EINVAL;
 
         spin_lock_irqsave(mEp->lock, flags);
 
         dbg_event(_usb_addr(mEp), "DEQUEUE", 0);
 
-        if (mReq->req.status == -EALREADY)
-                _hardware_dequeue(mEp, mReq);
+        hw_ep_flush(mEp->num, mEp->dir);
 
         /* pop request */
         list_del_init(&mReq->queue);
+        if (mReq->map) {
+                dma_unmap_single(mEp->device, mReq->req.dma, mReq->req.length,
+                                 mEp->dir ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
+                mReq->req.dma = 0;
+                mReq->map     = 0;
+        }
         req->status = -ECONNRESET;
 
-        if (!mReq->req.no_interrupt && mReq->req.complete != NULL) {
+        if (mReq->req.complete != NULL) {
                 spin_unlock(mEp->lock);
                 mReq->req.complete(&mEp->ep, &mReq->req);
                 spin_lock(mEp->lock);
@@ -2240,7 +2356,7 @@ static int ep_set_halt(struct usb_ep *ep, int value)
 #ifndef STALL_IN
         /* g_file_storage MS compliant but g_zero fails chapter 9 compliance */
         if (value && mEp->type == USB_ENDPOINT_XFER_BULK && mEp->dir == TX &&
-            !list_empty(&mEp->qh[mEp->dir].queue)) {
+            !list_empty(&mEp->qh.queue)) {
                 spin_unlock_irqrestore(mEp->lock, flags);
                 return -EAGAIN;
         }
@@ -2332,30 +2448,104 @@ static const struct usb_ep_ops usb_ep_ops = {
 /******************************************************************************
  * GADGET block
  *****************************************************************************/
+static int ci13xxx_vbus_session(struct usb_gadget *_gadget, int is_active)
+{
+        struct ci13xxx *udc = container_of(_gadget, struct ci13xxx, gadget);
+        unsigned long flags;
+        int gadget_ready = 0;
+
+        if (!(udc->udc_driver->flags & CI13XXX_PULLUP_ON_VBUS))
+                return -EOPNOTSUPP;
+
+        spin_lock_irqsave(udc->lock, flags);
+        udc->vbus_active = is_active;
+        if (udc->driver)
+                gadget_ready = 1;
+        spin_unlock_irqrestore(udc->lock, flags);
+
+        if (gadget_ready) {
+                if (is_active) {
+                        pm_runtime_get_sync(&_gadget->dev);
+                        hw_device_reset(udc);
+                        hw_device_state(udc->ep0out.qh.dma);
+                } else {
+                        hw_device_state(0);
+                        if (udc->udc_driver->notify_event)
+                                udc->udc_driver->notify_event(udc,
+                                CI13XXX_CONTROLLER_STOPPED_EVENT);
+                        _gadget_stop_activity(&udc->gadget);
+                        pm_runtime_put_sync(&_gadget->dev);
+                }
+        }
+
+        return 0;
+}
+
+static int ci13xxx_wakeup(struct usb_gadget *_gadget)
+{
+        struct ci13xxx *udc = container_of(_gadget, struct ci13xxx, gadget);
+        unsigned long flags;
+        int ret = 0;
+
+        trace();
+
+        spin_lock_irqsave(udc->lock, flags);
+        if (!udc->remote_wakeup) {
+                ret = -EOPNOTSUPP;
+                dbg_trace("remote wakeup feature is not enabled\n");
+                goto out;
+        }
+        if (!hw_cread(CAP_PORTSC, PORTSC_SUSP)) {
+                ret = -EINVAL;
+                dbg_trace("port is not suspended\n");
+                goto out;
+        }
+        hw_cwrite(CAP_PORTSC, PORTSC_FPR, PORTSC_FPR);
+out:
+        spin_unlock_irqrestore(udc->lock, flags);
+        return ret;
+}
+
+static int ci13xxx_vbus_draw(struct usb_gadget *_gadget, unsigned mA)
+{
+        struct ci13xxx *udc = container_of(_gadget, struct ci13xxx, gadget);
+
+        if (udc->transceiver)
+                return otg_set_power(udc->transceiver, mA);
+        return -ENOTSUPP;
+}
+
 /**
  * Device operations part of the API to the USB controller hardware,
  * which don't involve endpoints (or i/o)
  * Check  "usb_gadget.h" for details
  */
-static const struct usb_gadget_ops usb_gadget_ops;
+static const struct usb_gadget_ops usb_gadget_ops = {
+        .vbus_session   = ci13xxx_vbus_session,
+        .wakeup         = ci13xxx_wakeup,
+        .vbus_draw      = ci13xxx_vbus_draw,
+};
 
 /**
- * usb_gadget_register_driver: register a gadget driver
+ * usb_gadget_probe_driver: register a gadget driver
+ * @driver: the driver being registered
+ * @bind: the driver's bind callback
  *
- * Check usb_gadget_register_driver() at "usb_gadget.h" for details
- * Interrupts are enabled here
+ * Check usb_gadget_probe_driver() at <linux/usb/gadget.h> for details.
+ * Interrupts are enabled here.
  */
-int usb_gadget_register_driver(struct usb_gadget_driver *driver)
+int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
+                int (*bind)(struct usb_gadget *))
 {
         struct ci13xxx *udc = _udc;
-        unsigned long i, k, flags;
+        unsigned long flags;
+        int i, j;
         int retval = -ENOMEM;
 
         trace("%p", driver);
 
         if (driver             == NULL ||
-            driver->bind       == NULL ||
-            driver->unbind     == NULL ||
+            bind               == NULL ||
             driver->setup      == NULL ||
             driver->disconnect == NULL ||
             driver->suspend    == NULL ||
@@ -2369,13 +2559,13 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver)
         /* alloc resources */
         udc->qh_pool = dma_pool_create("ci13xxx_qh", &udc->gadget.dev,
                                        sizeof(struct ci13xxx_qh),
-                                       64, PAGE_SIZE);
+                                       64, CI13XXX_PAGE_SIZE);
         if (udc->qh_pool == NULL)
                 return -ENOMEM;
 
         udc->td_pool = dma_pool_create("ci13xxx_td", &udc->gadget.dev,
                                        sizeof(struct ci13xxx_td),
-                                       64, PAGE_SIZE);
+                                       64, CI13XXX_PAGE_SIZE);
         if (udc->td_pool == NULL) {
                 dma_pool_destroy(udc->qh_pool);
                 udc->qh_pool = NULL;
@@ -2386,68 +2576,88 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver)
 
         info("hw_ep_max = %d", hw_ep_max);
 
-        udc->driver = driver;
-        udc->gadget.ops        = NULL;
         udc->gadget.dev.driver = NULL;
 
         retval = 0;
-        for (i = 0; i < hw_ep_max; i++) {
-                struct ci13xxx_ep *mEp = &udc->ci13xxx_ep[i];
-
-                scnprintf(mEp->name, sizeof(mEp->name), "ep%i", (int)i);
-
-                mEp->lock         = udc->lock;
-                mEp->device       = &udc->gadget.dev;
-                mEp->td_pool      = udc->td_pool;
-
-                mEp->ep.name      = mEp->name;
-                mEp->ep.ops       = &usb_ep_ops;
-                mEp->ep.maxpacket = CTRL_PAYLOAD_MAX;
-
-                /* this allocation cannot be random */
-                for (k = RX; k <= TX; k++) {
-                        INIT_LIST_HEAD(&mEp->qh[k].queue);
-                        mEp->qh[k].ptr = dma_pool_alloc(udc->qh_pool,
-                                                        GFP_KERNEL,
-                                                        &mEp->qh[k].dma);
-                        if (mEp->qh[k].ptr == NULL)
+        for (i = 0; i < hw_ep_max/2; i++) {
+                for (j = RX; j <= TX; j++) {
+                        int k = i + j * hw_ep_max/2;
+                        struct ci13xxx_ep *mEp = &udc->ci13xxx_ep[k];
+
+                        scnprintf(mEp->name, sizeof(mEp->name), "ep%i%s", i,
+                                        (j == TX)  ? "in" : "out");
+
+                        mEp->lock         = udc->lock;
+                        mEp->device       = &udc->gadget.dev;
+                        mEp->td_pool      = udc->td_pool;
+
+                        mEp->ep.name      = mEp->name;
+                        mEp->ep.ops       = &usb_ep_ops;
+                        mEp->ep.maxpacket = CTRL_PAYLOAD_MAX;
+
+                        INIT_LIST_HEAD(&mEp->qh.queue);
+                        spin_unlock_irqrestore(udc->lock, flags);
+                        mEp->qh.ptr = dma_pool_alloc(udc->qh_pool, GFP_KERNEL,
+                                        &mEp->qh.dma);
+                        spin_lock_irqsave(udc->lock, flags);
+                        if (mEp->qh.ptr == NULL)
                                 retval = -ENOMEM;
                         else
-                                memset(mEp->qh[k].ptr, 0,
-                                       sizeof(*mEp->qh[k].ptr));
-                }
-                if (i == 0)
-                        udc->gadget.ep0 = &mEp->ep;
-                else
+                                memset(mEp->qh.ptr, 0, sizeof(*mEp->qh.ptr));
+
+                        /* skip ep0 out and in endpoints */
+                        if (i == 0)
+                                continue;
+
                         list_add_tail(&mEp->ep.ep_list, &udc->gadget.ep_list);
+                }
         }
         if (retval)
                 goto done;
+        spin_unlock_irqrestore(udc->lock, flags);
+        retval = usb_ep_enable(&udc->ep0out.ep, &ctrl_endpt_out_desc);
+        if (retval)
+                return retval;
+        retval = usb_ep_enable(&udc->ep0in.ep, &ctrl_endpt_in_desc);
+        if (retval)
+                return retval;
+        spin_lock_irqsave(udc->lock, flags);
 
+        udc->gadget.ep0 = &udc->ep0in.ep;
         /* bind gadget */
         driver->driver.bus     = NULL;
-        udc->gadget.ops        = &usb_gadget_ops;
         udc->gadget.dev.driver = &driver->driver;
 
         spin_unlock_irqrestore(udc->lock, flags);
-        retval = driver->bind(&udc->gadget);                /* MAY SLEEP */
+        retval = bind(&udc->gadget);                /* MAY SLEEP */
         spin_lock_irqsave(udc->lock, flags);
 
         if (retval) {
-                udc->gadget.ops        = NULL;
                 udc->gadget.dev.driver = NULL;
                 goto done;
         }
 
-        retval = hw_device_state(udc->ci13xxx_ep[0].qh[RX].dma);
+        udc->driver = driver;
+        pm_runtime_get_sync(&udc->gadget.dev);
+        if (udc->udc_driver->flags & CI13XXX_PULLUP_ON_VBUS) {
+                if (udc->vbus_active) {
+                        if (udc->udc_driver->flags & CI13XXX_REGS_SHARED)
+                                hw_device_reset(udc);
+                } else {
+                        pm_runtime_put_sync(&udc->gadget.dev);
+                        goto done;
+                }
+        }
+
+        retval = hw_device_state(udc->ep0out.qh.dma);
+        if (retval)
+                pm_runtime_put_sync(&udc->gadget.dev);
 
  done:
         spin_unlock_irqrestore(udc->lock, flags);
-        if (retval)
-                usb_gadget_unregister_driver(driver);
         return retval;
 }
-EXPORT_SYMBOL(usb_gadget_register_driver);
+EXPORT_SYMBOL(usb_gadget_probe_driver);
 
 /**
  * usb_gadget_unregister_driver: unregister a gadget driver
@@ -2457,12 +2667,11 @@ EXPORT_SYMBOL(usb_gadget_register_driver);
 int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
 {
         struct ci13xxx *udc = _udc;
-        unsigned long i, k, flags;
+        unsigned long i, flags;
 
         trace("%p", driver);
 
         if (driver             == NULL ||
-            driver->bind       == NULL ||
             driver->unbind     == NULL ||
             driver->setup      == NULL ||
             driver->disconnect == NULL ||
@@ -2473,35 +2682,35 @@ int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
 
         spin_lock_irqsave(udc->lock, flags);
 
-        hw_device_state(0);
-
-        /* unbind gadget */
-        if (udc->gadget.ops != NULL) {
+        if (!(udc->udc_driver->flags & CI13XXX_PULLUP_ON_VBUS) ||
+                        udc->vbus_active) {
+                hw_device_state(0);
+                if (udc->udc_driver->notify_event)
+                        udc->udc_driver->notify_event(udc,
+                        CI13XXX_CONTROLLER_STOPPED_EVENT);
                 _gadget_stop_activity(&udc->gadget);
+                pm_runtime_put(&udc->gadget.dev);
+        }
 
-                spin_unlock_irqrestore(udc->lock, flags);
-                driver->unbind(&udc->gadget);               /* MAY SLEEP */
-                spin_lock_irqsave(udc->lock, flags);
+        /* unbind gadget */
+        spin_unlock_irqrestore(udc->lock, flags);
+        driver->unbind(&udc->gadget);               /* MAY SLEEP */
+        spin_lock_irqsave(udc->lock, flags);
 
-                udc->gadget.ops        = NULL;
-                udc->gadget.dev.driver = NULL;
-        }
+        udc->gadget.dev.driver = NULL;
 
         /* free resources */
         for (i = 0; i < hw_ep_max; i++) {
                 struct ci13xxx_ep *mEp = &udc->ci13xxx_ep[i];
 
-                if (i == 0)
-                        udc->gadget.ep0 = NULL;
-                else if (!list_empty(&mEp->ep.ep_list))
+                if (!list_empty(&mEp->ep.ep_list))
                         list_del_init(&mEp->ep.ep_list);
 
-                for (k = RX; k <= TX; k++)
-                        if (mEp->qh[k].ptr != NULL)
-                                dma_pool_free(udc->qh_pool,
-                                              mEp->qh[k].ptr, mEp->qh[k].dma);
+                if (mEp->qh.ptr != NULL)
+                        dma_pool_free(udc->qh_pool, mEp->qh.ptr, mEp->qh.dma);
         }
 
+        udc->gadget.ep0 = NULL;
         udc->driver = NULL;
 
         spin_unlock_irqrestore(udc->lock, flags);
@@ -2542,6 +2751,14 @@ static irqreturn_t udc_irq(void)
         }
 
         spin_lock(udc->lock);
+
+        if (udc->udc_driver->flags & CI13XXX_REGS_SHARED) {
+                if (hw_cread(CAP_USBMODE, USBMODE_CM) !=
+                                USBMODE_CM_DEVICE) {
+                        spin_unlock(udc->lock);
+                        return IRQ_NONE;
+                }
+        }
         intr = hw_test_and_clear_intr_active();
         if (intr) {
                 isr_statistics.hndl.buf[isr_statistics.hndl.idx++] = intr;
@@ -2557,6 +2774,12 @@ static irqreturn_t udc_irq(void)
                         isr_statistics.pci++;
                         udc->gadget.speed = hw_port_is_high_speed() ?
                                 USB_SPEED_HIGH : USB_SPEED_FULL;
+                        if (udc->suspended) {
+                                spin_unlock(udc->lock);
+                                udc->driver->resume(&udc->gadget);
+                                spin_lock(udc->lock);
+                                udc->suspended = 0;
+                        }
                 }
                 if (USBi_UEI & intr)
                         isr_statistics.uei++;
@@ -2564,8 +2787,15 @@ static irqreturn_t udc_irq(void)
                         isr_statistics.ui++;
                         isr_tr_complete_handler(udc);
                 }
-                if (USBi_SLI & intr)
+                if (USBi_SLI & intr) {
+                        if (udc->gadget.speed != USB_SPEED_UNKNOWN) {
+                                udc->suspended = 1;
+                                spin_unlock(udc->lock);
+                                udc->driver->suspend(&udc->gadget);
+                                spin_lock(udc->lock);
+                        }
                         isr_statistics.sli++;
+                }
                 retval = IRQ_HANDLED;
         } else {
                 isr_statistics.none++;
@@ -2600,14 +2830,16 @@ static void udc_release(struct device *dev)
  * No interrupts active, the IRQ has not been requested yet
  * Kernel assumes 32-bit DMA operations by default, no need to dma_set_mask
  */
-static int udc_probe(struct device *dev, void __iomem *regs, const char *name)
+static int udc_probe(struct ci13xxx_udc_driver *driver, struct device *dev,
+                void __iomem *regs)
 {
         struct ci13xxx *udc;
         int retval = 0;
 
         trace("%p, %p, %p", dev, regs, name);
 
-        if (dev == NULL || regs == NULL || name == NULL)
+        if (dev == NULL || regs == NULL || driver == NULL ||
+                        driver->name == NULL)
                 return -EINVAL;
 
         udc = kzalloc(sizeof(struct ci13xxx), GFP_KERNEL);
@@ -2615,42 +2847,77 @@ static int udc_probe(struct device *dev, void __iomem *regs, const char *name)
                 return -ENOMEM;
 
         udc->lock = &udc_lock;
+        udc->regs = regs;
+        udc->udc_driver = driver;
 
-        retval = hw_device_reset(regs);
-        if (retval)
-                goto done;
-
-        udc->gadget.ops          = NULL;
+        udc->gadget.ops          = &usb_gadget_ops;
         udc->gadget.speed        = USB_SPEED_UNKNOWN;
         udc->gadget.is_dualspeed = 1;
         udc->gadget.is_otg       = 0;
-        udc->gadget.name         = name;
+        udc->gadget.name         = driver->name;
 
         INIT_LIST_HEAD(&udc->gadget.ep_list);
         udc->gadget.ep0 = NULL;
 
         dev_set_name(&udc->gadget.dev, "gadget");
         udc->gadget.dev.dma_mask = dev->dma_mask;
+        udc->gadget.dev.coherent_dma_mask = dev->coherent_dma_mask;
         udc->gadget.dev.parent   = dev;
         udc->gadget.dev.release  = udc_release;
 
+        retval = hw_device_init(regs);
+        if (retval < 0)
+                goto free_udc;
+
+        udc->transceiver = otg_get_transceiver();
+
+        if (udc->udc_driver->flags & CI13XXX_REQUIRE_TRANSCEIVER) {
+                if (udc->transceiver == NULL) {
+                        retval = -ENODEV;
+                        goto free_udc;
+                }
+        }
+
+        if (!(udc->udc_driver->flags & CI13XXX_REGS_SHARED)) {
+                retval = hw_device_reset(udc);
+                if (retval)
+                        goto put_transceiver;
+        }
+
         retval = device_register(&udc->gadget.dev);
-        if (retval)
-                goto done;
+        if (retval) {
+                put_device(&udc->gadget.dev);
+                goto put_transceiver;
+        }
 
 #ifdef CONFIG_USB_GADGET_DEBUG_FILES
         retval = dbg_create_files(&udc->gadget.dev);
 #endif
-        if (retval) {
-                device_unregister(&udc->gadget.dev);
-                goto done;
+        if (retval)
+                goto unreg_device;
+
+        if (udc->transceiver) {
+                retval = otg_set_peripheral(udc->transceiver, &udc->gadget);
+                if (retval)
+                        goto remove_dbg;
         }
+        pm_runtime_no_callbacks(&udc->gadget.dev);
+        pm_runtime_enable(&udc->gadget.dev);
 
         _udc = udc;
         return retval;
 
- done:
         err("error = %i", retval);
+remove_dbg:
+#ifdef CONFIG_USB_GADGET_DEBUG_FILES
+        dbg_remove_files(&udc->gadget.dev);
+#endif
+unreg_device:
+        device_unregister(&udc->gadget.dev);
+put_transceiver:
+        if (udc->transceiver)
+                otg_put_transceiver(udc->transceiver);
+free_udc:
         kfree(udc);
         _udc = NULL;
         return retval;
@@ -2670,6 +2937,10 @@ static void udc_remove(void)
                 return;
         }
 
+        if (udc->transceiver) {
+                otg_set_peripheral(udc->transceiver, &udc->gadget);
+                otg_put_transceiver(udc->transceiver);
+        }
 #ifdef CONFIG_USB_GADGET_DEBUG_FILES
         dbg_remove_files(&udc->gadget.dev);
 #endif
@@ -2678,156 +2949,3 @@ static void udc_remove(void)
         kfree(udc);
         _udc = NULL;
 }
-
-/******************************************************************************
- * PCI block
- *****************************************************************************/
-/**
- * ci13xxx_pci_irq: interrut handler
- * @irq:  irq number
- * @pdev: USB Device Controller interrupt source
- *
- * This function returns IRQ_HANDLED if the IRQ has been handled
- * This is an ISR don't trace, use attribute interface instead
- */
-static irqreturn_t ci13xxx_pci_irq(int irq, void *pdev)
-{
-        if (irq == 0) {
-                dev_err(&((struct pci_dev *)pdev)->dev, "Invalid IRQ0 usage!");
-                return IRQ_HANDLED;
-        }
-        return udc_irq();
-}
-
-/**
- * ci13xxx_pci_probe: PCI probe
- * @pdev: USB device controller being probed
- * @id:   PCI hotplug ID connecting controller to UDC framework
- *
- * This function returns an error code
- * Allocates basic PCI resources for this USB device controller, and then
- * invokes the udc_probe() method to start the UDC associated with it
- */
-static int __devinit ci13xxx_pci_probe(struct pci_dev *pdev,
-                                       const struct pci_device_id *id)
-{
-        void __iomem *regs = NULL;
-        int retval = 0;
-
-        if (id == NULL)
-                return -EINVAL;
-
-        retval = pci_enable_device(pdev);
-        if (retval)
-                goto done;
-
-        if (!pdev->irq) {
-                dev_err(&pdev->dev, "No IRQ, check BIOS/PCI setup!");
-                retval = -ENODEV;
-                goto disable_device;
-        }
-
-        retval = pci_request_regions(pdev, UDC_DRIVER_NAME);
-        if (retval)
-                goto disable_device;
-
-        /* BAR 0 holds all the registers */
-        regs = pci_iomap(pdev, 0, 0);
-        if (!regs) {
-                dev_err(&pdev->dev, "Error mapping memory!");
-                retval = -EFAULT;
-                goto release_regions;
-        }
-        pci_set_drvdata(pdev, (__force void *)regs);
-
-        pci_set_master(pdev);
-        pci_try_set_mwi(pdev);
-
-        retval = udc_probe(&pdev->dev, regs, UDC_DRIVER_NAME);
-        if (retval)
-                goto iounmap;
-
-        /* our device does not have MSI capability */
-
-        retval = request_irq(pdev->irq, ci13xxx_pci_irq, IRQF_SHARED,
-                             UDC_DRIVER_NAME, pdev);
-        if (retval)
-                goto gadget_remove;
-
-        return 0;
-
- gadget_remove:
-        udc_remove();
- iounmap:
-        pci_iounmap(pdev, regs);
- release_regions:
-        pci_release_regions(pdev);
- disable_device:
-        pci_disable_device(pdev);
- done:
-        return retval;
-}
-
-/**
- * ci13xxx_pci_remove: PCI remove
- * @pdev: USB Device Controller being removed
- *
- * Reverses the effect of ci13xxx_pci_probe(),
- * first invoking the udc_remove() and then releases
- * all PCI resources allocated for this USB device controller
- */
-static void __devexit ci13xxx_pci_remove(struct pci_dev *pdev)
-{
-        free_irq(pdev->irq, pdev);
-        udc_remove();
-        pci_iounmap(pdev, (__force void __iomem *)pci_get_drvdata(pdev));
-        pci_release_regions(pdev);
-        pci_disable_device(pdev);
-}
-
-/**
- * PCI device table
- * PCI device structure
- *
- * Check "pci.h" for details
- */
-static DEFINE_PCI_DEVICE_TABLE(ci13xxx_pci_id_table) = {
-        { PCI_DEVICE(0x153F, 0x1004) },
-        { PCI_DEVICE(0x153F, 0x1006) },
-        { 0, 0, 0, 0, 0, 0, 0 /* end: all zeroes */ }
-};
-MODULE_DEVICE_TABLE(pci, ci13xxx_pci_id_table);
-
-static struct pci_driver ci13xxx_pci_driver = {
-        .name         = UDC_DRIVER_NAME,
-        .id_table     = ci13xxx_pci_id_table,
-        .probe        = ci13xxx_pci_probe,
-        .remove       = __devexit_p(ci13xxx_pci_remove),
-};
-
-/**
- * ci13xxx_pci_init: module init
- *
- * Driver load
- */
-static int __init ci13xxx_pci_init(void)
-{
-        return pci_register_driver(&ci13xxx_pci_driver);
-}
-module_init(ci13xxx_pci_init);
-
-/**
- * ci13xxx_pci_exit: module exit
- *
- * Driver unload
- */
-static void __exit ci13xxx_pci_exit(void)
-{
-        pci_unregister_driver(&ci13xxx_pci_driver);
-}
-module_exit(ci13xxx_pci_exit);
-
-MODULE_AUTHOR("MIPS - David Lopo <dlopo@chipidea.mips.com>");
-MODULE_DESCRIPTION("MIPS CI13XXX USB Peripheral Controller");
-MODULE_LICENSE("GPL");
-MODULE_VERSION("June 2008");
diff --git a/drivers/usb/gadget/ci13xxx_udc.h b/drivers/usb/gadget/ci13xxx_udc.h
index 4026e9cede34..23707775cb43 100644
--- a/drivers/usb/gadget/ci13xxx_udc.h
+++ b/drivers/usb/gadget/ci13xxx_udc.h
@@ -19,7 +19,8 @@
 /******************************************************************************
  * DEFINE
  *****************************************************************************/
-#define ENDPT_MAX          (16)
+#define CI13XXX_PAGE_SIZE  4096ul /* page size for TD's */
+#define ENDPT_MAX          (32)
 #define CTRL_PAYLOAD_MAX   (64)
 #define RX        (0)  /* similar to USB_DIR_OUT but can be used as an index */
 #define TX        (1)  /* similar to USB_DIR_IN  but can be used as an index */
@@ -32,6 +33,7 @@ struct ci13xxx_td {
         /* 0 */
         u32 next;
 #define TD_TERMINATE          BIT(0)
+#define TD_ADDR_MASK          (0xFFFFFFEUL << 5)
         /* 1 */
         u32 token;
 #define TD_STATUS             (0x00FFUL <<  0)
@@ -73,6 +75,8 @@ struct ci13xxx_req {
         struct list_head     queue;
         struct ci13xxx_td   *ptr;
         dma_addr_t           dma;
+        struct ci13xxx_td   *zptr;
+        dma_addr_t           zdma;
 };
 
 /* Extension of usb_ep */
@@ -87,8 +91,7 @@ struct ci13xxx_ep {
                 struct list_head   queue;
                 struct ci13xxx_qh *ptr;
                 dma_addr_t         dma;
-        }                                      qh[2];
-        struct usb_request                    *status;
+        }                                      qh;
         int                                    wedge;
 
         /* global resources */
@@ -97,17 +100,43 @@ struct ci13xxx_ep {
         struct dma_pool                       *td_pool;
 };
 
+struct ci13xxx;
+struct ci13xxx_udc_driver {
+        const char      *name;
+        unsigned long    flags;
+#define CI13XXX_REGS_SHARED             BIT(0)
+#define CI13XXX_REQUIRE_TRANSCEIVER     BIT(1)
+#define CI13XXX_PULLUP_ON_VBUS          BIT(2)
+#define CI13XXX_DISABLE_STREAMING       BIT(3)
+
+#define CI13XXX_CONTROLLER_RESET_EVENT          0
+#define CI13XXX_CONTROLLER_STOPPED_EVENT        1
+        void    (*notify_event) (struct ci13xxx *udc, unsigned event);
+};
+
 /* CI13XXX UDC descriptor & global resources */
 struct ci13xxx {
         spinlock_t                *lock;      /* ctrl register bank access */
+        void __iomem              *regs;      /* registers address space */
 
         struct dma_pool           *qh_pool;   /* DMA pool for queue heads */
         struct dma_pool           *td_pool;   /* DMA pool for transfer descs */
+        struct usb_request        *status;    /* ep0 status request */
 
         struct usb_gadget          gadget;     /* USB slave device */
         struct ci13xxx_ep          ci13xxx_ep[ENDPT_MAX]; /* extended endpts */
+        u32                        ep0_dir;    /* ep0 direction */
+#define ep0out ci13xxx_ep[0]
+#define ep0in  ci13xxx_ep[16]
+        u8                         remote_wakeup; /* Is remote wakeup feature
+                                                        enabled by the host? */
+        u8                         suspended;  /* suspended by the host */
+        u8                         test_mode;  /* the selected test mode */
 
         struct usb_gadget_driver  *driver;     /* 3rd party gadget driver */
+        struct ci13xxx_udc_driver *udc_driver; /* device controller driver */
+        int                        vbus_active; /* is VBUS active */
+        struct otg_transceiver    *transceiver; /* Transceiver struct */
 };
 
 /******************************************************************************
@@ -130,6 +159,7 @@ struct ci13xxx {
 #define USBCMD_RS             BIT(0)
 #define USBCMD_RST            BIT(1)
 #define USBCMD_SUTW           BIT(13)
+#define USBCMD_ATDTW          BIT(14)
 
 /* USBSTS & USBINTR */
 #define USBi_UI               BIT(0)
@@ -143,6 +173,7 @@ struct ci13xxx {
 #define DEVICEADDR_USBADR     (0x7FUL << 25)
 
 /* PORTSC */
+#define PORTSC_FPR            BIT(6)
 #define PORTSC_SUSP           BIT(7)
 #define PORTSC_HSP            BIT(9)
 #define PORTSC_PTC            (0x0FUL << 16)
@@ -157,6 +188,7 @@ struct ci13xxx {
 #define    USBMODE_CM_DEVICE  (0x02UL <<  0)
 #define    USBMODE_CM_HOST    (0x03UL <<  0)
 #define USBMODE_SLOM          BIT(3)
+#define USBMODE_SDIS          BIT(4)
 
 /* ENDPTCTRL */
 #define ENDPTCTRL_RXS         BIT(0)
diff --git a/drivers/usb/gadget/composite.c b/drivers/usb/gadget/composite.c
index 1160c55de7f2..5cbb1a41c223 100644
--- a/drivers/usb/gadget/composite.c
+++ b/drivers/usb/gadget/composite.c
@@ -24,6 +24,7 @@
 #include <linux/kernel.h>
 #include <linux/slab.h>
 #include <linux/device.h>
+#include <linux/utsname.h>
 
 #include <linux/usb/composite.h>
 
@@ -39,8 +40,9 @@
 #define USB_BUFSIZ      1024
 
 static struct usb_composite_driver *composite;
+static int (*composite_gadget_bind)(struct usb_composite_dev *cdev);
 
-/* Some systems will need runtime overrides for the  product identifers
+/* Some systems will need runtime overrides for the  product identifiers
  * published in the device descriptor, either numbers or strings or both.
  * String parameters are in UTF-8 (superset of ASCII's 7 bit characters).
  */
@@ -69,6 +71,8 @@ static char *iSerialNumber;
 module_param(iSerialNumber, charp, 0);
 MODULE_PARM_DESC(iSerialNumber, "SerialNumber string");
 
+static char composite_manufacturer[50];
+
 /*-------------------------------------------------------------------------*/
 
 /**
@@ -201,14 +205,14 @@ int usb_function_activate(struct usb_function *function)
  * usb_interface_id() is called from usb_function.bind() callbacks to
  * allocate new interface IDs.  The function driver will then store that
  * ID in interface, association, CDC union, and other descriptors.  It
- * will also handle any control requests targetted at that interface,
+ * will also handle any control requests targeted at that interface,
  * particularly changing its altsetting via set_alt().  There may
  * also be class-specific or vendor-specific requests to handle.
  *
  * All interface identifier should be allocated using this routine, to
  * ensure that for example different functions don't wrongly assign
  * different meanings to the same identifier.  Note that since interface
- * identifers are configuration-specific, functions used in more than
+ * identifiers are configuration-specific, functions used in more than
  * one configuration (or more than once in a given configuration) need
  * multiple versions of the relevant descriptors.
  *
@@ -457,12 +461,23 @@ static int set_config(struct usb_composite_dev *cdev,
                         reset_config(cdev);
                         goto done;
                 }
+
+                if (result == USB_GADGET_DELAYED_STATUS) {
+                        DBG(cdev,
+                         "%s: interface %d (%s) requested delayed status\n",
+                                        __func__, tmp, f->name);
+                        cdev->delayed_status++;
+                        DBG(cdev, "delayed_status count %d\n",
+                                        cdev->delayed_status);
+                }
         }
 
         /* when we return, be sure our power usage is valid */
         power = c->bMaxPower ? (2 * c->bMaxPower) : CONFIG_USB_GADGET_VBUS_DRAW;
 done:
         usb_gadget_vbus_draw(gadget, power);
+        if (result >= 0 && cdev->delayed_status)
+                result = USB_GADGET_DELAYED_STATUS;
         return result;
 }
 
@@ -470,18 +485,20 @@ done:
  * usb_add_config() - add a configuration to a device.
  * @cdev: wraps the USB gadget
  * @config: the configuration, with bConfigurationValue assigned
+ * @bind: the configuration's bind function
  * Context: single threaded during gadget setup
  *
- * One of the main tasks of a composite driver's bind() routine is to
+ * One of the main tasks of a composite @bind() routine is to
  * add each of the configurations it supports, using this routine.
  *
- * This function returns the value of the configuration's bind(), which
+ * This function returns the value of the configuration's @bind(), which
  * is zero for success else a negative errno value.  Binding configurations
  * assigns global resources including string IDs, and per-configuration
  * resources such as interface IDs and endpoints.
  */
 int usb_add_config(struct usb_composite_dev *cdev,
-                struct usb_configuration *config)
+                struct usb_configuration *config,
+                int (*bind)(struct usb_configuration *))
 {
         int                             status = -EINVAL;
         struct usb_configuration        *c;
@@ -490,7 +507,7 @@ int usb_add_config(struct usb_composite_dev *cdev,
                         config->bConfigurationValue,
                         config->label, config);
 
-        if (!config->bConfigurationValue || !config->bind)
+        if (!config->bConfigurationValue || !bind)
                 goto done;
 
         /* Prevent duplicate configuration identifiers */
@@ -507,7 +524,7 @@ int usb_add_config(struct usb_composite_dev *cdev,
         INIT_LIST_HEAD(&config->functions);
         config->next_interface_id = 0;
 
-        status = config->bind(config);
+        status = bind(config);
         if (status < 0) {
                 list_del(&config->list);
                 config->cdev = NULL;
@@ -533,7 +550,7 @@ int usb_add_config(struct usb_composite_dev *cdev,
                 }
         }
 
-        /* set_alt(), or next config->bind(), sets up
+        /* set_alt(), or next bind(), sets up
          * ep->driver_data as needed.
          */
         usb_ep_autoconfig_reset(cdev->gadget);
@@ -599,6 +616,7 @@ static int get_string(struct usb_composite_dev *cdev,
         struct usb_configuration        *c;
         struct usb_function             *f;
         int                             len;
+        const char                      *str;
 
         /* Yes, not only is USB's I18N support probably more than most
          * folk will ever care about ... also, it's all supported here.
@@ -638,9 +656,29 @@ static int get_string(struct usb_composite_dev *cdev,
                 return s->bLength;
         }
 
-        /* Otherwise, look up and return a specified string.  String IDs
-         * are device-scoped, so we look up each string table we're told
-         * about.  These lookups are infrequent; simpler-is-better here.
+        /* Otherwise, look up and return a specified string.  First
+         * check if the string has not been overridden.
+         */
+        if (cdev->manufacturer_override == id)
+                str = iManufacturer ?: composite->iManufacturer ?:
+                        composite_manufacturer;
+        else if (cdev->product_override == id)
+                str = iProduct ?: composite->iProduct;
+        else if (cdev->serial_override == id)
+                str = iSerialNumber;
+        else
+                str = NULL;
+        if (str) {
+                struct usb_gadget_strings strings = {
+                        .language = language,
+                        .strings  = &(struct usb_string) { 0xff, str }
+                };
+                return usb_gadget_get_string(&strings, 0xff, buf);
+        }
+
+        /* String IDs are device-scoped, so we look up each string
+         * table we're told about.  These lookups are infrequent;
+         * simpler-is-better here.
          */
         if (composite->strings) {
                 len = lookup_string(composite->strings, buf, language, id);
@@ -786,7 +824,7 @@ composite_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
          */
         req->zero = 0;
         req->complete = composite_setup_complete;
-        req->length = USB_BUFSIZ;
+        req->length = 0;
         gadget->ep0->driver_data = cdev;
 
         switch (ctrl->bRequest) {
@@ -860,7 +898,7 @@ composite_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
         case USB_REQ_SET_INTERFACE:
                 if (ctrl->bRequestType != USB_RECIP_INTERFACE)
                         goto unknown;
-                if (!cdev->config || w_index >= MAX_CONFIG_INTERFACES)
+                if (!cdev->config || intf >= MAX_CONFIG_INTERFACES)
                         break;
                 f = cdev->config->interface[intf];
                 if (!f)
@@ -868,11 +906,19 @@ composite_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
                 if (w_value && !f->set_alt)
                         break;
                 value = f->set_alt(f, w_index, w_value);
+                if (value == USB_GADGET_DELAYED_STATUS) {
+                        DBG(cdev,
+                         "%s: interface %d (%s) requested delayed status\n",
+                                        __func__, intf, f->name);
+                        cdev->delayed_status++;
+                        DBG(cdev, "delayed_status count %d\n",
+                                        cdev->delayed_status);
+                }
                 break;
         case USB_REQ_GET_INTERFACE:
                 if (ctrl->bRequestType != (USB_DIR_IN|USB_RECIP_INTERFACE))
                         goto unknown;
-                if (!cdev->config || w_index >= MAX_CONFIG_INTERFACES)
+                if (!cdev->config || intf >= MAX_CONFIG_INTERFACES)
                         break;
                 f = cdev->config->interface[intf];
                 if (!f)
@@ -901,6 +947,8 @@ unknown:
                  */
                 switch (ctrl->bRequestType & USB_RECIP_MASK) {
                 case USB_RECIP_INTERFACE:
+                        if (!cdev->config || intf >= MAX_CONFIG_INTERFACES)
+                                break;
                         f = cdev->config->interface[intf];
                         break;
 
@@ -929,7 +977,7 @@ unknown:
         }
 
         /* respond with data transfer before status phase? */
-        if (value >= 0) {
+        if (value >= 0 && value != USB_GADGET_DELAYED_STATUS) {
                 req->length = value;
                 req->zero = value < w_length;
                 value = usb_ep_queue(gadget->ep0, req, GFP_ATOMIC);
@@ -938,6 +986,10 @@ unknown:
                         req->status = 0;
                         composite_setup_complete(gadget->ep0, req);
                 }
+        } else if (value == USB_GADGET_DELAYED_STATUS && w_length != 0) {
+                WARN(cdev,
+                        "%s: Delayed status not supported for w_length != 0",
+                        __func__);
         }
 
 done:
@@ -1019,32 +1071,23 @@ composite_unbind(struct usb_gadget *gadget)
                 kfree(cdev->req->buf);
                 usb_ep_free_request(gadget->ep0, cdev->req);
         }
+        device_remove_file(&gadget->dev, &dev_attr_suspended);
         kfree(cdev);
         set_gadget_data(gadget, NULL);
-        device_remove_file(&gadget->dev, &dev_attr_suspended);
         composite = NULL;
 }
 
-static void
-string_override_one(struct usb_gadget_strings *tab, u8 id, const char *s)
+static u8 override_id(struct usb_composite_dev *cdev, u8 *desc)
 {
-        struct usb_string               *str = tab->strings;
-
-        for (str = tab->strings; str->s; str++) {
-                if (str->id == id) {
-                        str->s = s;
-                        return;
-                }
+        if (!*desc) {
+                int ret = usb_string_id(cdev);
+                if (unlikely(ret < 0))
+                        WARNING(cdev, "failed to override string ID\n");
+                else
+                        *desc = ret;
         }
-}
 
-static void
-string_override(struct usb_gadget_strings **tab, u8 id, const char *s)
-{
-        while (*tab) {
-                string_override_one(*tab, id, s);
-                tab++;
-        }
+        return *desc;
 }
 
 static int composite_bind(struct usb_gadget *gadget)
@@ -1074,7 +1117,13 @@ static int composite_bind(struct usb_gadget *gadget)
         cdev->bufsiz = USB_BUFSIZ;
         cdev->driver = composite;
 
-        usb_gadget_set_selfpowered(gadget);
+        /*
+         * As per USB compliance update, a device that is actively drawing
+         * more than 100mA from USB must report itself as bus-powered in
+         * the GetStatus(DEVICE) call.
+         */
+        if (CONFIG_USB_GADGET_VBUS_DRAW <= USB_SELF_POWER_VBUS_MAX_DRAW)
+                usb_gadget_set_selfpowered(gadget);
 
         /* interface and string IDs start at zero via kzalloc.
          * we force endpoints to start unassigned; few controller
@@ -1082,38 +1131,53 @@ static int composite_bind(struct usb_gadget *gadget)
          */
         usb_ep_autoconfig_reset(cdev->gadget);
 
-        /* standardized runtime overrides for device ID data */
-        if (idVendor)
-                cdev->desc.idVendor = cpu_to_le16(idVendor);
-        if (idProduct)
-                cdev->desc.idProduct = cpu_to_le16(idProduct);
-        if (bcdDevice)
-                cdev->desc.bcdDevice = cpu_to_le16(bcdDevice);
-
         /* composite gadget needs to assign strings for whole device (like
          * serial number), register function drivers, potentially update
          * power state and consumption, etc
          */
-        status = composite->bind(cdev);
+        status = composite_gadget_bind(cdev);
         if (status < 0)
                 goto fail;
 
         cdev->desc = *composite->dev;
         cdev->desc.bMaxPacketSize0 = gadget->ep0->maxpacket;
 
-        /* strings can't be assigned before bind() allocates the
-         * releavnt identifiers
-         */
-        if (cdev->desc.iManufacturer && iManufacturer)
-                string_override(composite->strings,
-                        cdev->desc.iManufacturer, iManufacturer);
-        if (cdev->desc.iProduct && iProduct)
-                string_override(composite->strings,
-                        cdev->desc.iProduct, iProduct);
-        if (cdev->desc.iSerialNumber && iSerialNumber)
-                string_override(composite->strings,
-                        cdev->desc.iSerialNumber, iSerialNumber);
+        /* standardized runtime overrides for device ID data */
+        if (idVendor)
+                cdev->desc.idVendor = cpu_to_le16(idVendor);
+        if (idProduct)
+                cdev->desc.idProduct = cpu_to_le16(idProduct);
+        if (bcdDevice)
+                cdev->desc.bcdDevice = cpu_to_le16(bcdDevice);
+
+        /* string overrides */
+        if (iManufacturer || !cdev->desc.iManufacturer) {
+                if (!iManufacturer && !composite->iManufacturer &&
+                    !*composite_manufacturer)
+                        snprintf(composite_manufacturer,
+                                 sizeof composite_manufacturer,
+                                 "%s %s with %s",
+                                 init_utsname()->sysname,
+                                 init_utsname()->release,
+                                 gadget->name);
+
+                cdev->manufacturer_override =
+                        override_id(cdev, &cdev->desc.iManufacturer);
+        }
+
+        if (iProduct || (!cdev->desc.iProduct && composite->iProduct))
+                cdev->product_override =
+                        override_id(cdev, &cdev->desc.iProduct);
+
+        if (iSerialNumber)
+                cdev->serial_override =
+                        override_id(cdev, &cdev->desc.iSerialNumber);
 
+        /* has userspace failed to provide a serial number? */
+        if (composite->needs_serial && !cdev->desc.iSerialNumber)
+                WARNING(cdev, "userspace failed to provide iSerialNumber\n");
+
+        /* finish up */
         status = device_create_file(&gadget->dev, &dev_attr_suspended);
         if (status)
                 goto fail;
@@ -1148,6 +1212,8 @@ composite_suspend(struct usb_gadget *gadget)
                 composite->suspend(cdev);
 
         cdev->suspended = 1;
+
+        usb_gadget_vbus_draw(gadget, 2);
 }
 
 static void
@@ -1155,6 +1221,7 @@ composite_resume(struct usb_gadget *gadget)
 {
         struct usb_composite_dev        *cdev = get_gadget_data(gadget);
         struct usb_function             *f;
+        u8                              maxpower;
 
         /* REVISIT:  should we have config level
          * suspend/resume callbacks?
@@ -1167,6 +1234,11 @@ composite_resume(struct usb_gadget *gadget)
                         if (f->resume)
                                 f->resume(f);
                 }
+
+                maxpower = cdev->config->bMaxPower;
+
+                usb_gadget_vbus_draw(gadget, maxpower ?
+                        (2 * maxpower) : CONFIG_USB_GADGET_VBUS_DRAW);
         }
 
         cdev->suspended = 0;
@@ -1177,7 +1249,6 @@ composite_resume(struct usb_gadget *gadget)
 static struct usb_gadget_driver composite_driver = {
         .speed          = USB_SPEED_HIGH,
 
-        .bind           = composite_bind,
         .unbind         = composite_unbind,
 
         .setup          = composite_setup,
@@ -1192,8 +1263,12 @@ static struct usb_gadget_driver composite_driver = {
 };
 
 /**
- * usb_composite_register() - register a composite driver
+ * usb_composite_probe() - register a composite driver
  * @driver: the driver to register
+ * @bind: the callback used to allocate resources that are shared across the
+ *      whole device, such as string IDs, and add its configurations using
+ *      @usb_add_config().  This may fail by returning a negative errno
+ *      value; it should return zero on successful initialization.
  * Context: single threaded during gadget setup
  *
  * This function is used to register drivers using the composite driver
@@ -1206,18 +1281,22 @@ static struct usb_gadget_driver composite_driver = {
  * while it was binding.  That would usually be done in order to wait for
  * some userspace participation.
  */
-int usb_composite_register(struct usb_composite_driver *driver)
+int usb_composite_probe(struct usb_composite_driver *driver,
+                               int (*bind)(struct usb_composite_dev *cdev))
 {
-        if (!driver || !driver->dev || !driver->bind || composite)
+        if (!driver || !driver->dev || !bind || composite)
                 return -EINVAL;
 
         if (!driver->name)
                 driver->name = "composite";
+        if (!driver->iProduct)
+                driver->iProduct = driver->name;
         composite_driver.function =  (char *) driver->name;
         composite_driver.driver.name = driver->name;
         composite = driver;
+        composite_gadget_bind = bind;
 
-        return usb_gadget_register_driver(&composite_driver);
+        return usb_gadget_probe_driver(&composite_driver, composite_bind);
 }
 
 /**
@@ -1233,3 +1312,40 @@ void usb_composite_unregister(struct usb_composite_driver *driver)
                 return;
         usb_gadget_unregister_driver(&composite_driver);
 }
+
+/**
+ * usb_composite_setup_continue() - Continue with the control transfer
+ * @cdev: the composite device who's control transfer was kept waiting
+ *
+ * This function must be called by the USB function driver to continue
+ * with the control transfer's data/status stage in case it had requested to
+ * delay the data/status stages. A USB function's setup handler (e.g. set_alt())
+ * can request the composite framework to delay the setup request's data/status
+ * stages by returning USB_GADGET_DELAYED_STATUS.
+ */
+void usb_composite_setup_continue(struct usb_composite_dev *cdev)
+{
+        int                     value;
+        struct usb_request      *req = cdev->req;
+        unsigned long           flags;
+
+        DBG(cdev, "%s\n", __func__);
+        spin_lock_irqsave(&cdev->lock, flags);
+
+        if (cdev->delayed_status == 0) {
+                WARN(cdev, "%s: Unexpected call\n", __func__);
+
+        } else if (--cdev->delayed_status == 0) {
+                DBG(cdev, "%s: Completing delayed status\n", __func__);
+                req->length = 0;
+                value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
+                if (value < 0) {
+                        DBG(cdev, "ep_queue --> %d\n", value);
+                        req->status = 0;
+                        composite_setup_complete(cdev->gadget->ep0, req);
+                }
+        }
+
+        spin_unlock_irqrestore(&cdev->lock, flags);
+}
+
diff --git a/drivers/usb/gadget/dbgp.c b/drivers/usb/gadget/dbgp.c
index 0ed50a2c0a36..dbe92ee88477 100644
--- a/drivers/usb/gadget/dbgp.c
+++ b/drivers/usb/gadget/dbgp.c
@@ -261,8 +261,8 @@ static int __init dbgp_configure_endpoints(struct usb_gadget *gadget)
         o_desc.wMaxPacketSize =
                 __constant_cpu_to_le16(USB_DEBUG_MAX_PACKET_SIZE);
 
-        dbg_desc.bDebugInEndpoint = i_desc.bEndpointAddress & 0x7f;
-        dbg_desc.bDebugOutEndpoint = o_desc.bEndpointAddress & 0x7f;
+        dbg_desc.bDebugInEndpoint = i_desc.bEndpointAddress;
+        dbg_desc.bDebugOutEndpoint = o_desc.bEndpointAddress;
 
 #ifdef CONFIG_USB_G_DBGP_SERIAL
         dbgp.serial->in = dbgp.i_ep;
@@ -312,6 +312,7 @@ static int __init dbgp_bind(struct usb_gadget *gadget)
 
         dbgp.req->length = DBGP_REQ_EP0_LEN;
         gadget->ep0->driver_data = gadget;
+        device_desc.bMaxPacketSize0 = gadget->ep0->maxpacket;
 
 #ifdef CONFIG_USB_G_DBGP_SERIAL
         dbgp.serial = kzalloc(sizeof(struct gserial), GFP_KERNEL);
@@ -350,9 +351,9 @@ static int dbgp_setup(struct usb_gadget *gadget,
         u8 request = ctrl->bRequest;
         u16 value = le16_to_cpu(ctrl->wValue);
         u16 length = le16_to_cpu(ctrl->wLength);
-        int err = 0;
-        void *data;
-        u16 len;
+        int err = -EOPNOTSUPP;
+        void *data = NULL;
+        u16 len = 0;
 
         gadget->ep0->driver_data = gadget;
 
@@ -371,10 +372,9 @@ static int dbgp_setup(struct usb_gadget *gadget,
                 default:
                         goto fail;
                 }
+                err = 0;
         } else if (request == USB_REQ_SET_FEATURE &&
                    value == USB_DEVICE_DEBUG_MODE) {
-                len = 0;
-                data = NULL;
                 dev_dbg(&dbgp.gadget->dev, "setup: feat debug\n");
 #ifdef CONFIG_USB_G_DBGP_PRINTK
                 err = dbgp_enable_ep();
@@ -386,15 +386,13 @@ static int dbgp_setup(struct usb_gadget *gadget,
         } else
                 goto fail;
 
-        if (len >= 0) {
-                req->length = min(length, len);
-                req->zero = len < req->length;
-                if (data && req->length)
-                        memcpy(req->buf, data, req->length);
+        req->length = min(length, len);
+        req->zero = len < req->length;
+        if (data && req->length)
+                memcpy(req->buf, data, req->length);
 
-                req->complete = dbgp_setup_complete;
-                return usb_ep_queue(gadget->ep0, req, GFP_ATOMIC);
-        }
+        req->complete = dbgp_setup_complete;
+        return usb_ep_queue(gadget->ep0, req, GFP_ATOMIC);
 
 fail:
         dev_dbg(&dbgp.gadget->dev,
@@ -405,7 +403,6 @@ fail:
 static struct usb_gadget_driver dbgp_driver = {
         .function = "dbgp",
         .speed = USB_SPEED_HIGH,
-        .bind = dbgp_bind,
         .unbind = dbgp_unbind,
         .setup = dbgp_setup,
         .disconnect = dbgp_disconnect,
@@ -417,7 +414,7 @@ static struct usb_gadget_driver dbgp_driver = {
 
 static int __init dbgp_init(void)
 {
-        return usb_gadget_register_driver(&dbgp_driver);
+        return usb_gadget_probe_driver(&dbgp_driver, dbgp_bind);
 }
 
 static void __exit dbgp_exit(void)
diff --git a/drivers/usb/gadget/dummy_hcd.c b/drivers/usb/gadget/dummy_hcd.c
index dc6546248ed9..d3dcabc1a5fc 100644
--- a/drivers/usb/gadget/dummy_hcd.c
+++ b/drivers/usb/gadget/dummy_hcd.c
@@ -748,7 +748,8 @@ static DEVICE_ATTR (function, S_IRUGO, show_function, NULL);
  */
 
 int
-usb_gadget_register_driver (struct usb_gadget_driver *driver)
+usb_gadget_probe_driver(struct usb_gadget_driver *driver,
+                int (*bind)(struct usb_gadget *))
 {
         struct dummy    *dum = the_controller;
         int             retval, i;
@@ -757,8 +758,7 @@ usb_gadget_register_driver (struct usb_gadget_driver *driver)
                 return -EINVAL;
         if (dum->driver)
                 return -EBUSY;
-        if (!driver->bind || !driver->setup
-                        || driver->speed == USB_SPEED_UNKNOWN)
+        if (!bind || !driver->setup || driver->speed == USB_SPEED_UNKNOWN)
                 return -EINVAL;
 
         /*
@@ -796,7 +796,7 @@ usb_gadget_register_driver (struct usb_gadget_driver *driver)
         dum->gadget.dev.driver = &driver->driver;
         dev_dbg (udc_dev(dum), "binding gadget driver '%s'\n",
                         driver->driver.name);
-        retval = driver->bind(&dum->gadget);
+        retval = bind(&dum->gadget);
         if (retval) {
                 dum->driver = NULL;
                 dum->gadget.dev.driver = NULL;
@@ -812,7 +812,7 @@ usb_gadget_register_driver (struct usb_gadget_driver *driver)
         usb_hcd_poll_rh_status (dummy_to_hcd (dum));
         return 0;
 }
-EXPORT_SYMBOL (usb_gadget_register_driver);
+EXPORT_SYMBOL(usb_gadget_probe_driver);
 
 int
 usb_gadget_unregister_driver (struct usb_gadget_driver *driver)
@@ -874,6 +874,8 @@ static int dummy_udc_probe (struct platform_device *pdev)
         struct dummy    *dum = the_controller;
         int             rc;
 
+        usb_get_hcd(dummy_to_hcd(dum));
+
         dum->gadget.name = gadget_name;
         dum->gadget.ops = &dummy_ops;
         dum->gadget.is_dualspeed = 1;
@@ -885,15 +887,16 @@ static int dummy_udc_probe (struct platform_device *pdev)
         dum->gadget.dev.parent = &pdev->dev;
         dum->gadget.dev.release = dummy_gadget_release;
         rc = device_register (&dum->gadget.dev);
-        if (rc < 0)
+        if (rc < 0) {
+                put_device(&dum->gadget.dev);
                 return rc;
+        }
 
-        usb_get_hcd (dummy_to_hcd (dum));
-
-        platform_set_drvdata (pdev, dum);
         rc = device_create_file (&dum->gadget.dev, &dev_attr_function);
         if (rc < 0)
                 device_unregister (&dum->gadget.dev);
+        else
+                platform_set_drvdata(pdev, dum);
         return rc;
 }
 
@@ -1195,6 +1198,139 @@ static struct dummy_ep *find_endpoint (struct dummy *dum, u8 address)
 #define Ep_Request      (USB_TYPE_STANDARD | USB_RECIP_ENDPOINT)
 #define Ep_InRequest    (Ep_Request | USB_DIR_IN)
 
+
+/**
+ * handle_control_request() - handles all control transfers
+ * @dum: pointer to dummy (the_controller)
+ * @urb: the urb request to handle
+ * @setup: pointer to the setup data for a USB device control
+ *       request
+ * @status: pointer to request handling status
+ *
+ * Return 0 - if the request was handled
+ *        1 - if the request wasn't handles
+ *        error code on error
+ */
+static int handle_control_request(struct dummy *dum, struct urb *urb,
+                                  struct usb_ctrlrequest *setup,
+                                  int *status)
+{
+        struct dummy_ep         *ep2;
+        int                     ret_val = 1;
+        unsigned        w_index;
+        unsigned        w_value;
+
+        w_index = le16_to_cpu(setup->wIndex);
+        w_value = le16_to_cpu(setup->wValue);
+        switch (setup->bRequest) {
+        case USB_REQ_SET_ADDRESS:
+                if (setup->bRequestType != Dev_Request)
+                        break;
+                dum->address = w_value;
+                *status = 0;
+                dev_dbg(udc_dev(dum), "set_address = %d\n",
+                                w_value);
+                ret_val = 0;
+                break;
+        case USB_REQ_SET_FEATURE:
+                if (setup->bRequestType == Dev_Request) {
+                        ret_val = 0;
+                        switch (w_value) {
+                        case USB_DEVICE_REMOTE_WAKEUP:
+                                break;
+                        case USB_DEVICE_B_HNP_ENABLE:
+                                dum->gadget.b_hnp_enable = 1;
+                                break;
+                        case USB_DEVICE_A_HNP_SUPPORT:
+                                dum->gadget.a_hnp_support = 1;
+                                break;
+                        case USB_DEVICE_A_ALT_HNP_SUPPORT:
+                                dum->gadget.a_alt_hnp_support = 1;
+                                break;
+                        default:
+                                ret_val = -EOPNOTSUPP;
+                        }
+                        if (ret_val == 0) {
+                                dum->devstatus |= (1 << w_value);
+                                *status = 0;
+                        }
+                } else if (setup->bRequestType == Ep_Request) {
+                        /* endpoint halt */
+                        ep2 = find_endpoint(dum, w_index);
+                        if (!ep2 || ep2->ep.name == ep0name) {
+                                ret_val = -EOPNOTSUPP;
+                                break;
+                        }
+                        ep2->halted = 1;
+                        ret_val = 0;
+                        *status = 0;
+                }
+                break;
+        case USB_REQ_CLEAR_FEATURE:
+                if (setup->bRequestType == Dev_Request) {
+                        ret_val = 0;
+                        switch (w_value) {
+                        case USB_DEVICE_REMOTE_WAKEUP:
+                                w_value = USB_DEVICE_REMOTE_WAKEUP;
+                                break;
+                        default:
+                                ret_val = -EOPNOTSUPP;
+                                break;
+                        }
+                        if (ret_val == 0) {
+                                dum->devstatus &= ~(1 << w_value);
+                                *status = 0;
+                        }
+                } else if (setup->bRequestType == Ep_Request) {
+                        /* endpoint halt */
+                        ep2 = find_endpoint(dum, w_index);
+                        if (!ep2) {
+                                ret_val = -EOPNOTSUPP;
+                                break;
+                        }
+                        if (!ep2->wedged)
+                                ep2->halted = 0;
+                        ret_val = 0;
+                        *status = 0;
+                }
+                break;
+        case USB_REQ_GET_STATUS:
+                if (setup->bRequestType == Dev_InRequest
+                                || setup->bRequestType == Intf_InRequest
+                                || setup->bRequestType == Ep_InRequest) {
+                        char *buf;
+                        /*
+                         * device: remote wakeup, selfpowered
+                         * interface: nothing
+                         * endpoint: halt
+                         */
+                        buf = (char *)urb->transfer_buffer;
+                        if (urb->transfer_buffer_length > 0) {
+                                if (setup->bRequestType == Ep_InRequest) {
+                                        ep2 = find_endpoint(dum, w_index);
+                                        if (!ep2) {
+                                                ret_val = -EOPNOTSUPP;
+                                                break;
+                                        }
+                                        buf[0] = ep2->halted;
+                                } else if (setup->bRequestType ==
+                                           Dev_InRequest) {
+                                        buf[0] = (u8)dum->devstatus;
+                                } else
+                                        buf[0] = 0;
+                        }
+                        if (urb->transfer_buffer_length > 1)
+                                buf[1] = 0;
+                        urb->actual_length = min_t(u32, 2,
+                                urb->transfer_buffer_length);
+                        ret_val = 0;
+                        *status = 0;
+                }
+                break;
+        }
+        return ret_val;
+}
+
 /* drive both sides of the transfers; looks like irq handlers to
  * both drivers except the callbacks aren't in_irq().
  */
@@ -1297,14 +1433,8 @@ restart:
                 if (ep == &dum->ep [0] && ep->setup_stage) {
                         struct usb_ctrlrequest          setup;
                         int                             value = 1;
-                        struct dummy_ep                 *ep2;
-                        unsigned                        w_index;
-                        unsigned                        w_value;
 
                         setup = *(struct usb_ctrlrequest*) urb->setup_packet;
-                        w_index = le16_to_cpu(setup.wIndex);
-                        w_value = le16_to_cpu(setup.wValue);
-
                         /* paranoia, in case of stale queued data */
                         list_for_each_entry (req, &ep->queue, queue) {
                                 list_del_init (&req->queue);
@@ -1326,117 +1456,9 @@ restart:
                         ep->last_io = jiffies;
                         ep->setup_stage = 0;
                         ep->halted = 0;
-                        switch (setup.bRequest) {
-                        case USB_REQ_SET_ADDRESS:
-                                if (setup.bRequestType != Dev_Request)
-                                        break;
-                                dum->address = w_value;
-                                status = 0;
-                                dev_dbg (udc_dev(dum), "set_address = %d\n",
-                                                w_value);
-                                value = 0;
-                                break;
-                        case USB_REQ_SET_FEATURE:
-                                if (setup.bRequestType == Dev_Request) {
-                                        value = 0;
-                                        switch (w_value) {
-                                        case USB_DEVICE_REMOTE_WAKEUP:
-                                                break;
-                                        case USB_DEVICE_B_HNP_ENABLE:
-                                                dum->gadget.b_hnp_enable = 1;
-                                                break;
-                                        case USB_DEVICE_A_HNP_SUPPORT:
-                                                dum->gadget.a_hnp_support = 1;
-                                                break;
-                                        case USB_DEVICE_A_ALT_HNP_SUPPORT:
-                                                dum->gadget.a_alt_hnp_support
-                                                        = 1;
-                                                break;
-                                        default:
-                                                value = -EOPNOTSUPP;
-                                        }
-                                        if (value == 0) {
-                                                dum->devstatus |=
-                                                        (1 << w_value);
-                                                status = 0;
-                                        }
 
-                                } else if (setup.bRequestType == Ep_Request) {
-                                        // endpoint halt
-                                        ep2 = find_endpoint (dum, w_index);
-                                        if (!ep2 || ep2->ep.name == ep0name) {
-                                                value = -EOPNOTSUPP;
-                                                break;
-                                        }
-                                        ep2->halted = 1;
-                                        value = 0;
-                                        status = 0;
-                                }
-                                break;
-                        case USB_REQ_CLEAR_FEATURE:
-                                if (setup.bRequestType == Dev_Request) {
-                                        switch (w_value) {
-                                        case USB_DEVICE_REMOTE_WAKEUP:
-                                                dum->devstatus &= ~(1 <<
-                                                        USB_DEVICE_REMOTE_WAKEUP);
-                                                value = 0;
-                                                status = 0;
-                                                break;
-                                        default:
-                                                value = -EOPNOTSUPP;
-                                                break;
-                                        }
-                                } else if (setup.bRequestType == Ep_Request) {
-                                        // endpoint halt
-                                        ep2 = find_endpoint (dum, w_index);
-                                        if (!ep2) {
-                                                value = -EOPNOTSUPP;
-                                                break;
-                                        }
-                                        if (!ep2->wedged)
-                                                ep2->halted = 0;
-                                        value = 0;
-                                        status = 0;
-                                }
-                                break;
-                        case USB_REQ_GET_STATUS:
-                                if (setup.bRequestType == Dev_InRequest
-                                                || setup.bRequestType
-                                                        == Intf_InRequest
-                                                || setup.bRequestType
-                                                        == Ep_InRequest
-                                                ) {
-                                        char *buf;
-
-                                        // device: remote wakeup, selfpowered
-                                        // interface: nothing
-                                        // endpoint: halt
-                                        buf = (char *)urb->transfer_buffer;
-                                        if (urb->transfer_buffer_length > 0) {
-                                                if (setup.bRequestType ==
-                                                                Ep_InRequest) {
-        ep2 = find_endpoint (dum, w_index);
-        if (!ep2) {
-                value = -EOPNOTSUPP;
-                break;
-        }
-        buf [0] = ep2->halted;
-                                                } else if (setup.bRequestType ==
-                                                                Dev_InRequest) {
-                                                        buf [0] = (u8)
-                                                                dum->devstatus;
-                                                } else
-                                                        buf [0] = 0;
-                                        }
-                                        if (urb->transfer_buffer_length > 1)
-                                                buf [1] = 0;
-                                        urb->actual_length = min_t(u32, 2,
-                                                urb->transfer_buffer_length);
-                                        value = 0;
-                                        status = 0;
-                                }
-                                break;
-                        }
+                        value = handle_control_request(dum, urb, &setup,
+                                                       &status);
 
                         /* gadget driver handles all other requests.  block
                          * until setup() returns; no reentrancy issues etc.
@@ -1572,8 +1594,8 @@ hub_descriptor (struct usb_hub_descriptor *desc)
         desc->bDescLength = 9;
         desc->wHubCharacteristics = cpu_to_le16(0x0001);
         desc->bNbrPorts = 1;
-        desc->bitmap [0] = 0xff;
-        desc->bitmap [1] = 0xff;
+        desc->u.hs.DeviceRemovable[0] = 0xff;
+        desc->u.hs.DeviceRemovable[1] = 0xff;
 }
 
 static int dummy_hub_control (
@@ -1884,6 +1906,7 @@ static int dummy_hcd_probe(struct platform_device *pdev)
         if (!hcd)
                 return -ENOMEM;
         the_controller = hcd_to_dummy (hcd);
+        hcd->has_tt = 1;
 
         retval = usb_add_hcd(hcd, 0, 0);
         if (retval != 0) {
@@ -1974,11 +1997,29 @@ static int __init init (void)
         retval = platform_device_add(the_hcd_pdev);
         if (retval < 0)
                 goto err_add_hcd;
+        if (!the_controller) {
+                /*
+                 * The hcd was added successfully but its probe function failed
+                 * for some reason.
+                 */
+                retval = -EINVAL;
+                goto err_add_udc;
+        }
         retval = platform_device_add(the_udc_pdev);
         if (retval < 0)
                 goto err_add_udc;
+        if (!platform_get_drvdata(the_udc_pdev)) {
+                /*
+                 * The udc was added successfully but its probe function failed
+                 * for some reason.
+                 */
+                retval = -EINVAL;
+                goto err_probe_udc;
+        }
         return retval;
 
+err_probe_udc:
+        platform_device_del(the_udc_pdev);
 err_add_udc:
         platform_device_del(the_hcd_pdev);
 err_add_hcd:
diff --git a/drivers/usb/gadget/epautoconf.c b/drivers/usb/gadget/epautoconf.c
index 8a832488ccdd..9b7360ff5aa7 100644
--- a/drivers/usb/gadget/epautoconf.c
+++ b/drivers/usb/gadget/epautoconf.c
@@ -128,6 +128,13 @@ ep_matches (
                 }
         }
 
+        /*
+         * If the protocol driver hasn't yet decided on wMaxPacketSize
+         * and wants to know the maximum possible, provide the info.
+         */
+        if (desc->wMaxPacketSize == 0)
+                desc->wMaxPacketSize = cpu_to_le16(ep->maxpacket);
+
         /* endpoint maxpacket size is an input parameter, except for bulk
          * where it's an output parameter representing the full speed limit.
          * the usb spec fixes high speed bulk maxpacket at 512 bytes.
diff --git a/drivers/usb/gadget/ether.c b/drivers/usb/gadget/ether.c
index 114fa024c22c..1690c9d68256 100644
--- a/drivers/usb/gadget/ether.c
+++ b/drivers/usb/gadget/ether.c
@@ -237,7 +237,7 @@ static u8 hostaddr[ETH_ALEN];
  * the first one present.  That's to make Microsoft's drivers happy,
  * and to follow DOCSIS 1.0 (cable modem standard).
  */
-static int __ref rndis_do_config(struct usb_configuration *c)
+static int __init rndis_do_config(struct usb_configuration *c)
 {
         /* FIXME alloc iConfiguration string, set it in c->strings */
 
@@ -251,7 +251,6 @@ static int __ref rndis_do_config(struct usb_configuration *c)
 
 static struct usb_configuration rndis_config_driver = {
         .label                  = "RNDIS",
-        .bind                   = rndis_do_config,
         .bConfigurationValue    = 2,
         /* .iConfiguration = DYNAMIC */
         .bmAttributes           = USB_CONFIG_ATT_SELFPOWER,
@@ -270,7 +269,7 @@ MODULE_PARM_DESC(use_eem, "use CDC EEM mode");
 /*
  * We _always_ have an ECM, CDC Subset, or EEM configuration.
  */
-static int __ref eth_do_config(struct usb_configuration *c)
+static int __init eth_do_config(struct usb_configuration *c)
 {
         /* FIXME alloc iConfiguration string, set it in c->strings */
 
@@ -289,7 +288,6 @@ static int __ref eth_do_config(struct usb_configuration *c)
 
 static struct usb_configuration eth_config_driver = {
         /* .label = f(hardware) */
-        .bind                   = eth_do_config,
         .bConfigurationValue    = 1,
         /* .iConfiguration = DYNAMIC */
         .bmAttributes           = USB_CONFIG_ATT_SELFPOWER,
@@ -297,7 +295,7 @@ static struct usb_configuration eth_config_driver = {
 
 /*-------------------------------------------------------------------------*/
 
-static int __ref eth_bind(struct usb_composite_dev *cdev)
+static int __init eth_bind(struct usb_composite_dev *cdev)
 {
         int                     gcnum;
         struct usb_gadget       *gadget = cdev->gadget;
@@ -373,12 +371,13 @@ static int __ref eth_bind(struct usb_composite_dev *cdev)
 
         /* register our configuration(s); RNDIS first, if it's used */
         if (has_rndis()) {
-                status = usb_add_config(cdev, &rndis_config_driver);
+                status = usb_add_config(cdev, &rndis_config_driver,
+                                rndis_do_config);
                 if (status < 0)
                         goto fail;
         }
 
-        status = usb_add_config(cdev, &eth_config_driver);
+        status = usb_add_config(cdev, &eth_config_driver, eth_do_config);
         if (status < 0)
                 goto fail;
 
@@ -402,7 +401,6 @@ static struct usb_composite_driver eth_driver = {
         .name           = "g_ether",
         .dev            = &device_desc,
         .strings        = dev_strings,
-        .bind           = eth_bind,
         .unbind         = __exit_p(eth_unbind),
 };
 
@@ -412,7 +410,7 @@ MODULE_LICENSE("GPL");
 
 static int __init init(void)
 {
-        return usb_composite_register(&eth_driver);
+        return usb_composite_probe(&eth_driver, eth_bind);
 }
 module_init(init);
 
diff --git a/drivers/usb/gadget/f_acm.c b/drivers/usb/gadget/f_acm.c
index d47a123f15ab..bd6226cbae86 100644
--- a/drivers/usb/gadget/f_acm.c
+++ b/drivers/usb/gadget/f_acm.c
@@ -111,7 +111,7 @@ acm_iad_descriptor = {
         .bInterfaceCount =      2,      // control + data
         .bFunctionClass =       USB_CLASS_COMM,
         .bFunctionSubClass =    USB_CDC_SUBCLASS_ACM,
-        .bFunctionProtocol =    USB_CDC_PROTO_NONE,
+        .bFunctionProtocol =    USB_CDC_ACM_PROTO_AT_V25TER,
         /* .iFunction =         DYNAMIC */
 };
 
diff --git a/drivers/usb/gadget/f_audio.c b/drivers/usb/gadget/f_audio.c
index 1f48ceb55a77..8ee330a2ab58 100644
--- a/drivers/usb/gadget/f_audio.c
+++ b/drivers/usb/gadget/f_audio.c
@@ -177,7 +177,7 @@ static struct uac_format_type_i_discrete_descriptor_1 as_type_i_desc = {
 };
 
 /* Standard ISO OUT Endpoint Descriptor */
-static struct usb_endpoint_descriptor as_out_ep_desc __initdata = {
+static struct usb_endpoint_descriptor as_out_ep_desc  = {
         .bLength =              USB_DT_ENDPOINT_AUDIO_SIZE,
         .bDescriptorType =      USB_DT_ENDPOINT,
         .bEndpointAddress =     USB_DIR_OUT,
@@ -317,8 +317,6 @@ static void f_audio_playback_work(struct work_struct *data)
 
         u_audio_playback(&audio->card, play_buf->buf, play_buf->actual);
         f_audio_buffer_free(play_buf);
-
-        return;
 }
 
 static int f_audio_out_ep_complete(struct usb_ep *ep, struct usb_request *req)
@@ -708,6 +706,7 @@ f_audio_unbind(struct usb_configuration *c, struct usb_function *f)
         struct f_audio          *audio = func_to_audio(f);
 
         usb_free_descriptors(f->descriptors);
+        usb_free_descriptors(f->hs_descriptors);
         kfree(audio);
 }
 
@@ -744,7 +743,7 @@ int __init control_selector_init(struct f_audio *audio)
 }
 
 /**
- * audio_bind_config - add USB audio fucntion to a configuration
+ * audio_bind_config - add USB audio function to a configuration
  * @c: the configuration to supcard the USB audio function
  * Context: single threaded during gadget setup
  *
diff --git a/drivers/usb/gadget/f_eem.c b/drivers/usb/gadget/f_eem.c
index 95dd4662d6a8..b3c304290150 100644
--- a/drivers/usb/gadget/f_eem.c
+++ b/drivers/usb/gadget/f_eem.c
@@ -314,6 +314,9 @@ eem_unbind(struct usb_configuration *c, struct usb_function *f)
 
 static void eem_cmd_complete(struct usb_ep *ep, struct usb_request *req)
 {
+        struct sk_buff *skb = (struct sk_buff *)req->context;
+
+        dev_kfree_skb_any(skb);
 }
 
 /*
@@ -428,10 +431,11 @@ static int eem_unwrap(struct gether *port,
                                 skb_trim(skb2, len);
                                 put_unaligned_le16(BIT(15) | BIT(11) | len,
                                                         skb_push(skb2, 2));
-                                skb_copy_bits(skb, 0, req->buf, skb->len);
-                                req->length = skb->len;
+                                skb_copy_bits(skb2, 0, req->buf, skb2->len);
+                                req->length = skb2->len;
                                 req->complete = eem_cmd_complete;
                                 req->zero = 1;
+                                req->context = skb2;
                                 if (usb_ep_queue(port->in_ep, req, GFP_ATOMIC))
                                         DBG(cdev, "echo response queue fail\n");
                                 break;
diff --git a/drivers/usb/gadget/f_fs.c b/drivers/usb/gadget/f_fs.c
index e4f595055208..19fffccc370d 100644
--- a/drivers/usb/gadget/f_fs.c
+++ b/drivers/usb/gadget/f_fs.c
@@ -1,10 +1,10 @@
 /*
- * f_fs.c -- user mode filesystem api for usb composite funtcion controllers
+ * f_fs.c -- user mode file system API for USB composite function controllers
  *
  * Copyright (C) 2010 Samsung Electronics
  * Author: Michal Nazarewicz <m.nazarewicz@samsung.com>
  *
- * Based on inode.c (GadgetFS):
+ * Based on inode.c (GadgetFS) which was:
  * Copyright (C) 2003-2004 David Brownell
  * Copyright (C) 2003 Agilent Technologies
  *
@@ -30,7 +30,6 @@
 #include <linux/blkdev.h>
 #include <linux/pagemap.h>
 #include <asm/unaligned.h>
-#include <linux/smp_lock.h>
 
 #include <linux/usb/composite.h>
 #include <linux/usb/functionfs.h>
@@ -39,62 +38,56 @@
 #define FUNCTIONFS_MAGIC        0xa647361 /* Chosen by a honest dice roll ;) */
 
 
-/* Debuging *****************************************************************/
-
-#define ffs_printk(level, fmt, args...) printk(level "f_fs: " fmt "\n", ## args)
-
-#define FERR(...)  ffs_printk(KERN_ERR,  __VA_ARGS__)
-#define FINFO(...) ffs_printk(KERN_INFO, __VA_ARGS__)
-
-#ifdef DEBUG
-#  define FDBG(...) ffs_printk(KERN_DEBUG, __VA_ARGS__)
-#else
-#  define FDBG(...) do { } while (0)
-#endif /* DEBUG */
-
-#ifdef VERBOSE_DEBUG
-#  define FVDBG FDBG
-#else
-#  define FVDBG(...) do { } while (0)
-#endif /* VERBOSE_DEBUG */
-
-#define ENTER()    FVDBG("%s()", __func__)
+/* Debugging ****************************************************************/
 
 #ifdef VERBOSE_DEBUG
+#  define pr_vdebug pr_debug
 #  define ffs_dump_mem(prefix, ptr, len) \
-        print_hex_dump_bytes("f_fs" prefix ": ", DUMP_PREFIX_NONE, ptr, len)
+        print_hex_dump_bytes(pr_fmt(prefix ": "), DUMP_PREFIX_NONE, ptr, len)
 #else
+#  define pr_vdebug(...)                 do { } while (0)
 #  define ffs_dump_mem(prefix, ptr, len) do { } while (0)
-#endif
+#endif /* VERBOSE_DEBUG */
+
+#define ENTER()    pr_vdebug("%s()\n", __func__)
 
 
 /* The data structure and setup file ****************************************/
 
 enum ffs_state {
-        /* Waiting for descriptors and strings. */
-        /* In this state no open(2), read(2) or write(2) on epfiles
+        /*
+         * Waiting for descriptors and strings.
+         *
+         * In this state no open(2), read(2) or write(2) on epfiles
          * may succeed (which should not be the problem as there
-         * should be no such files opened in the firts place). */
+         * should be no such files opened in the first place).
+         */
         FFS_READ_DESCRIPTORS,
         FFS_READ_STRINGS,
 
-        /* We've got descriptors and strings.  We are or have called
+        /*
+         * We've got descriptors and strings.  We are or have called
          * functionfs_ready_callback().  functionfs_bind() may have
-         * been called but we don't know. */
-        /* This is the only state in which operations on epfiles may
-         * succeed. */
+         * been called but we don't know.
+         *
+         * This is the only state in which operations on epfiles may
+         * succeed.
+         */
         FFS_ACTIVE,
 
-        /* All endpoints have been closed.  This state is also set if
+        /*
+         * All endpoints have been closed.  This state is also set if
          * we encounter an unrecoverable error.  The only
          * unrecoverable error is situation when after reading strings
-         * from user space we fail to initialise EP files or
-         * functionfs_ready_callback() returns with error (<0). */
-        /* In this state no open(2), read(2) or write(2) (both on ep0
+         * from user space we fail to initialise epfiles or
+         * functionfs_ready_callback() returns with error (<0).
+         *
+         * In this state no open(2), read(2) or write(2) (both on ep0
          * as well as epfile) may succeed (at this point epfiles are
          * unlinked and all closed so this is not a problem; ep0 is
          * also closed but ep0 file exists and so open(2) on ep0 must
-         * fail). */
+         * fail).
+         */
         FFS_CLOSING
 };
 
@@ -102,14 +95,18 @@ enum ffs_state {
 enum ffs_setup_state {
         /* There is no setup request pending. */
         FFS_NO_SETUP,
-        /* User has read events and there was a setup request event
+        /*
+         * User has read events and there was a setup request event
          * there.  The next read/write on ep0 will handle the
-         * request. */
+         * request.
+         */
         FFS_SETUP_PENDING,
-        /* There was event pending but before user space handled it
+        /*
+         * There was event pending but before user space handled it
          * some other event was introduced which canceled existing
          * setup.  If this state is set read/write on ep0 return
-         * -EIDRM.  This state is only set when adding event. */
+         * -EIDRM.  This state is only set when adding event.
+         */
         FFS_SETUP_CANCELED
 };
 
@@ -121,23 +118,29 @@ struct ffs_function;
 struct ffs_data {
         struct usb_gadget               *gadget;
 
-        /* Protect access read/write operations, only one read/write
+        /*
+         * Protect access read/write operations, only one read/write
          * at a time.  As a consequence protects ep0req and company.
          * While setup request is being processed (queued) this is
-         * held. */
+         * held.
+         */
         struct mutex                    mutex;
 
-        /* Protect access to enpoint related structures (basically
+        /*
+         * Protect access to endpoint related structures (basically
          * usb_ep_queue(), usb_ep_dequeue(), etc. calls) except for
-         * endpint zero. */
+         * endpoint zero.
+         */
         spinlock_t                      eps_lock;
 
-        /* XXX REVISIT do we need our own request? Since we are not
-         * handling setup requests immidiatelly user space may be so
+        /*
+         * XXX REVISIT do we need our own request? Since we are not
+         * handling setup requests immediately user space may be so
          * slow that another setup will be sent to the gadget but this
          * time not to us but another function and then there could be
          * a race.  Is that the case? Or maybe we can use cdev->req
-         * after all, maybe we just need some spinlock for that? */
+         * after all, maybe we just need some spinlock for that?
+         */
         struct usb_request              *ep0req;                /* P: mutex */
         struct completion               ep0req_completion;      /* P: mutex */
         int                             ep0req_status;          /* P: mutex */
@@ -151,7 +154,7 @@ struct ffs_data {
         enum ffs_state                  state;
 
         /*
-         * Possible transations:
+         * Possible transitions:
          * + FFS_NO_SETUP       -> FFS_SETUP_PENDING  -- P: ev.waitq.lock
          *               happens only in ep0 read which is P: mutex
          * + FFS_SETUP_PENDING  -> FFS_NO_SETUP       -- P: ev.waitq.lock
@@ -184,18 +187,21 @@ struct ffs_data {
         /* Active function */
         struct ffs_function             *func;
 
-        /* Device name, write once when file system is mounted.
-         * Intendet for user to read if she wants. */
+        /*
+         * Device name, write once when file system is mounted.
+         * Intended for user to read if she wants.
+         */
         const char                      *dev_name;
-        /* Private data for our user (ie. gadget).  Managed by
-         * user. */
+        /* Private data for our user (ie. gadget).  Managed by user. */
         void                            *private_data;
 
         /* filled by __ffs_data_got_descs() */
-        /* real descriptors are 16 bytes after raw_descs (so you need
+        /*
+         * Real descriptors are 16 bytes after raw_descs (so you need
          * to skip 16 bytes (ie. ffs->raw_descs + 16) to get to the
          * first full speed descriptor).  raw_descs_length and
-         * raw_fs_descs_length do not have those 16 bytes added. */
+         * raw_fs_descs_length do not have those 16 bytes added.
+         */
         const void                      *raw_descs;
         unsigned                        raw_descs_length;
         unsigned                        raw_fs_descs_length;
@@ -212,18 +218,23 @@ struct ffs_data {
         const void                      *raw_strings;
         struct usb_gadget_strings       **stringtabs;
 
-        /* File system's super block, write once when file system is mounted. */
+        /*
+         * File system's super block, write once when file system is
+         * mounted.
+         */
         struct super_block              *sb;
 
-        /* File permissions, written once when fs is mounted*/
+        /* File permissions, written once when fs is mounted */
         struct ffs_file_perms {
                 umode_t                         mode;
                 uid_t                           uid;
                 gid_t                           gid;
         }                               file_perms;
 
-        /* The endpoint files, filled by ffs_epfiles_create(),
-         * destroyed by ffs_epfiles_destroy(). */
+        /*
+         * The endpoint files, filled by ffs_epfiles_create(),
+         * destroyed by ffs_epfiles_destroy().
+         */
         struct ffs_epfile               *epfiles;
 };
 
@@ -237,7 +248,7 @@ static struct ffs_data *__must_check ffs_data_new(void) __attribute__((malloc));
 static void ffs_data_opened(struct ffs_data *ffs);
 static void ffs_data_closed(struct ffs_data *ffs);
 
-/* Called with ffs->mutex held; take over ownerrship of data. */
+/* Called with ffs->mutex held; take over ownership of data. */
 static int __must_check
 __ffs_data_got_descs(struct ffs_data *ffs, char *data, size_t len);
 static int __must_check
@@ -268,11 +279,9 @@ static struct ffs_function *ffs_func_from_usb(struct usb_function *f)
 
 static void ffs_func_free(struct ffs_function *func);
 
-
 static void ffs_func_eps_disable(struct ffs_function *func);
 static int __must_check ffs_func_eps_enable(struct ffs_function *func);
 
-
 static int ffs_func_bind(struct usb_configuration *,
                          struct usb_function *);
 static void ffs_func_unbind(struct usb_configuration *,
@@ -289,7 +298,6 @@ static int ffs_func_revmap_ep(struct ffs_function *func, u8 num);
 static int ffs_func_revmap_intf(struct ffs_function *func, u8 intf);
 
 
-
 /* The endpoints structures *************************************************/
 
 struct ffs_ep {
@@ -322,7 +330,6 @@ struct ffs_epfile {
         unsigned char                   _pad;
 };
 
-
 static int  __must_check ffs_epfiles_create(struct ffs_data *ffs);
 static void ffs_epfiles_destroy(struct ffs_epfile *epfiles, unsigned count);
 
@@ -349,7 +356,6 @@ static void ffs_ep0_complete(struct usb_ep *ep, struct usb_request *req)
         complete_all(&ffs->ep0req_completion);
 }
 
-
 static int __ffs_ep0_queue_wait(struct ffs_data *ffs, char *data, size_t len)
 {
         struct usb_request *req = ffs->ep0req;
@@ -362,6 +368,14 @@ static int __ffs_ep0_queue_wait(struct ffs_data *ffs, char *data, size_t len)
         req->buf      = data;
         req->length   = len;
 
+        /*
+         * UDC layer requires to provide a buffer even for ZLP, but should
+         * not use it at all. Let's provide some poisoned pointer to catch
+         * possible bug in the driver.
+         */
+        if (req->buf == NULL)
+                req->buf = (void *)0xDEADBABE;
+
         INIT_COMPLETION(ffs->ep0req_completion);
 
         ret = usb_ep_queue(ffs->gadget->ep0, req, GFP_ATOMIC);
@@ -381,17 +395,16 @@ static int __ffs_ep0_queue_wait(struct ffs_data *ffs, char *data, size_t len)
 static int __ffs_ep0_stall(struct ffs_data *ffs)
 {
         if (ffs->ev.can_stall) {
-                FVDBG("ep0 stall\n");
+                pr_vdebug("ep0 stall\n");
                 usb_ep_set_halt(ffs->gadget->ep0);
                 ffs->setup_state = FFS_NO_SETUP;
                 return -EL2HLT;
         } else {
-                FDBG("bogus ep0 stall!\n");
+                pr_debug("bogus ep0 stall!\n");
                 return -ESRCH;
         }
 }
 
-
 static ssize_t ffs_ep0_write(struct file *file, const char __user *buf,
                              size_t len, loff_t *ptr)
 {
@@ -410,7 +423,6 @@ static ssize_t ffs_ep0_write(struct file *file, const char __user *buf,
         if (unlikely(ret < 0))
                 return ret;
 
-
         /* Check state */
         switch (ffs->state) {
         case FFS_READ_DESCRIPTORS:
@@ -422,14 +434,14 @@ static ssize_t ffs_ep0_write(struct file *file, const char __user *buf,
                 }
 
                 data = ffs_prepare_buffer(buf, len);
-                if (unlikely(IS_ERR(data))) {
+                if (IS_ERR(data)) {
                         ret = PTR_ERR(data);
                         break;
                 }
 
                 /* Handle data */
                 if (ffs->state == FFS_READ_DESCRIPTORS) {
-                        FINFO("read descriptors");
+                        pr_info("read descriptors\n");
                         ret = __ffs_data_got_descs(ffs, data, len);
                         if (unlikely(ret < 0))
                                 break;
@@ -437,7 +449,7 @@ static ssize_t ffs_ep0_write(struct file *file, const char __user *buf,
                         ffs->state = FFS_READ_STRINGS;
                         ret = len;
                 } else {
-                        FINFO("read strings");
+                        pr_info("read strings\n");
                         ret = __ffs_data_got_strings(ffs, data, len);
                         if (unlikely(ret < 0))
                                 break;
@@ -462,11 +474,12 @@ static ssize_t ffs_ep0_write(struct file *file, const char __user *buf,
                 }
                 break;
 
-
         case FFS_ACTIVE:
                 data = NULL;
-                /* We're called from user space, we can use _irq
-                 * rather then _irqsave */
+                /*
+                 * We're called from user space, we can use _irq
+                 * rather then _irqsave
+                 */
                 spin_lock_irq(&ffs->ev.waitq.lock);
                 switch (FFS_SETUP_STATE(ffs)) {
                 case FFS_SETUP_CANCELED:
@@ -494,23 +507,25 @@ static ssize_t ffs_ep0_write(struct file *file, const char __user *buf,
                 spin_unlock_irq(&ffs->ev.waitq.lock);
 
                 data = ffs_prepare_buffer(buf, len);
-                if (unlikely(IS_ERR(data))) {
+                if (IS_ERR(data)) {
                         ret = PTR_ERR(data);
                         break;
                 }
 
                 spin_lock_irq(&ffs->ev.waitq.lock);
 
-                /* We are guaranteed to be still in FFS_ACTIVE state
+                /*
+                 * We are guaranteed to be still in FFS_ACTIVE state
                  * but the state of setup could have changed from
                  * FFS_SETUP_PENDING to FFS_SETUP_CANCELED so we need
                  * to check for that.  If that happened we copied data
-                 * from user space in vain but it's unlikely. */
-                /* For sure we are not in FFS_NO_SETUP since this is
+                 * from user space in vain but it's unlikely.
+                 *
+                 * For sure we are not in FFS_NO_SETUP since this is
                  * the only place FFS_SETUP_PENDING -> FFS_NO_SETUP
                  * transition can be performed and it's protected by
-                 * mutex. */
-
+                 * mutex.
+                 */
                 if (FFS_SETUP_STATE(ffs) == FFS_SETUP_CANCELED) {
                         ret = -EIDRM;
 done_spin:
@@ -522,25 +537,22 @@ done_spin:
                 kfree(data);
                 break;
 
-
         default:
                 ret = -EBADFD;
                 break;
         }
 
-
         mutex_unlock(&ffs->mutex);
         return ret;
 }
 
-
-
 static ssize_t __ffs_ep0_read_events(struct ffs_data *ffs, char __user *buf,
                                      size_t n)
 {
-        /* We are holding ffs->ev.waitq.lock and ffs->mutex and we need
-         * to release them. */
-
+        /*
+         * We are holding ffs->ev.waitq.lock and ffs->mutex and we need
+         * to release them.
+         */
         struct usb_functionfs_event events[n];
         unsigned i = 0;
 
@@ -569,7 +581,6 @@ static ssize_t __ffs_ep0_read_events(struct ffs_data *ffs, char __user *buf,
                 ? -EFAULT : sizeof events;
 }
 
-
 static ssize_t ffs_ep0_read(struct file *file, char __user *buf,
                             size_t len, loff_t *ptr)
 {
@@ -589,16 +600,16 @@ static ssize_t ffs_ep0_read(struct file *file, char __user *buf,
         if (unlikely(ret < 0))
                 return ret;
 
-
         /* Check state */
         if (ffs->state != FFS_ACTIVE) {
                 ret = -EBADFD;
                 goto done_mutex;
         }
 
-
-        /* We're called from user space, we can use _irq rather then
-         * _irqsave */
+        /*
+         * We're called from user space, we can use _irq rather then
+         * _irqsave
+         */
         spin_lock_irq(&ffs->ev.waitq.lock);
 
         switch (FFS_SETUP_STATE(ffs)) {
@@ -618,7 +629,8 @@ static ssize_t ffs_ep0_read(struct file *file, char __user *buf,
                         break;
                 }
 
-                if (unlikely(wait_event_interruptible_exclusive_locked_irq(ffs->ev.waitq, ffs->ev.count))) {
+                if (wait_event_interruptible_exclusive_locked_irq(ffs->ev.waitq,
+                                                        ffs->ev.count)) {
                         ret = -EINTR;
                         break;
                 }
@@ -626,7 +638,6 @@ static ssize_t ffs_ep0_read(struct file *file, char __user *buf,
                 return __ffs_ep0_read_events(ffs, buf,
                                              min(n, (size_t)ffs->ev.count));
 
-
         case FFS_SETUP_PENDING:
                 if (ffs->ev.setup.bRequestType & USB_DIR_IN) {
                         spin_unlock_irq(&ffs->ev.waitq.lock);
@@ -672,8 +683,6 @@ done_mutex:
         return ret;
 }
 
-
-
 static int ffs_ep0_open(struct inode *inode, struct file *file)
 {
         struct ffs_data *ffs = inode->i_private;
@@ -689,7 +698,6 @@ static int ffs_ep0_open(struct inode *inode, struct file *file)
         return 0;
 }
 
-
 static int ffs_ep0_release(struct inode *inode, struct file *file)
 {
         struct ffs_data *ffs = file->private_data;
@@ -701,7 +709,6 @@ static int ffs_ep0_release(struct inode *inode, struct file *file)
         return 0;
 }
 
-
 static long ffs_ep0_ioctl(struct file *file, unsigned code, unsigned long value)
 {
         struct ffs_data *ffs = file->private_data;
@@ -722,7 +729,6 @@ static long ffs_ep0_ioctl(struct file *file, unsigned code, unsigned long value)
         return ret;
 }
 
-
 static const struct file_operations ffs_ep0_operations = {
         .owner =        THIS_MODULE,
         .llseek =       no_llseek,
@@ -737,7 +743,6 @@ static const struct file_operations ffs_ep0_operations = {
 
 /* "Normal" endpoints operations ********************************************/
 
-
 static void ffs_epfile_io_complete(struct usb_ep *_ep, struct usb_request *req)
 {
         ENTER();
@@ -748,7 +753,6 @@ static void ffs_epfile_io_complete(struct usb_ep *_ep, struct usb_request *req)
         }
 }
 
-
 static ssize_t ffs_epfile_io(struct file *file,
                              char __user *buf, size_t len, int read)
 {
@@ -778,8 +782,8 @@ first_try:
                                 goto error;
                         }
 
-                        if (unlikely(wait_event_interruptible
-                                     (epfile->wait, (ep = epfile->ep)))) {
+                        if (wait_event_interruptible(epfile->wait,
+                                                     (ep = epfile->ep))) {
                                 ret = -EINTR;
                                 goto error;
                         }
@@ -811,12 +815,16 @@ first_try:
                 if (unlikely(ret))
                         goto error;
 
-                /* We're called from user space, we can use _irq rather then
-                 * _irqsave */
+                /*
+                 * We're called from user space, we can use _irq rather then
+                 * _irqsave
+                 */
                 spin_lock_irq(&epfile->ffs->eps_lock);
 
-                /* While we were acquiring mutex endpoint got disabled
-                 * or changed? */
+                /*
+                 * While we were acquiring mutex endpoint got disabled
+                 * or changed?
+                 */
         } while (unlikely(epfile->ep != ep));
 
         /* Halt */
@@ -858,7 +866,6 @@ error:
         return ret;
 }
 
-
 static ssize_t
 ffs_epfile_write(struct file *file, const char __user *buf, size_t len,
                  loff_t *ptr)
@@ -904,7 +911,6 @@ ffs_epfile_release(struct inode *inode, struct file *file)
         return 0;
 }
 
-
 static long ffs_epfile_ioctl(struct file *file, unsigned code,
                              unsigned long value)
 {
@@ -943,7 +949,6 @@ static long ffs_epfile_ioctl(struct file *file, unsigned code,
         return ret;
 }
 
-
 static const struct file_operations ffs_epfile_operations = {
         .owner =        THIS_MODULE,
         .llseek =       no_llseek,
@@ -956,15 +961,13 @@ static const struct file_operations ffs_epfile_operations = {
 };
 
 
-
 /* File system and super block operations ***********************************/
 
 /*
- * Mounting the filesystem creates a controller file, used first for
+ * Mounting the file system creates a controller file, used first for
  * function configuration then later for event monitoring.
  */
 
-
 static struct inode *__must_check
 ffs_sb_make_inode(struct super_block *sb, void *data,
                   const struct file_operations *fops,
@@ -980,6 +983,7 @@ ffs_sb_make_inode(struct super_block *sb, void *data,
         if (likely(inode)) {
                 struct timespec current_time = CURRENT_TIME;
 
+                inode->i_ino     = get_next_ino();
                 inode->i_mode    = perms->mode;
                 inode->i_uid     = perms->uid;
                 inode->i_gid     = perms->gid;
@@ -996,9 +1000,7 @@ ffs_sb_make_inode(struct super_block *sb, void *data,
         return inode;
 }
 
-
 /* Create "regular" file */
-
 static struct inode *ffs_sb_create_file(struct super_block *sb,
                                         const char *name, void *data,
                                         const struct file_operations *fops,
@@ -1027,9 +1029,7 @@ static struct inode *ffs_sb_create_file(struct super_block *sb,
         return inode;
 }
 
-
 /* Super block */
-
 static const struct super_operations ffs_sb_operations = {
         .statfs =       simple_statfs,
         .drop_inode =   generic_delete_inode,
@@ -1050,7 +1050,7 @@ static int ffs_sb_fill(struct super_block *sb, void *_data, int silent)
 
         ENTER();
 
-        /* Initialize data */
+        /* Initialise data */
         ffs = ffs_data_new();
         if (unlikely(!ffs))
                 goto enomem0;
@@ -1096,7 +1096,6 @@ enomem0:
         return -ENOMEM;
 }
 
-
 static int ffs_fs_parse_opts(struct ffs_sb_fill_data *data, char *opts)
 {
         ENTER();
@@ -1116,7 +1115,7 @@ static int ffs_fs_parse_opts(struct ffs_sb_fill_data *data, char *opts)
                 /* Value limit */
                 eq = strchr(opts, '=');
                 if (unlikely(!eq)) {
-                        FERR("'=' missing in %s", opts);
+                        pr_err("'=' missing in %s\n", opts);
                         return -EINVAL;
                 }
                 *eq = 0;
@@ -1124,7 +1123,7 @@ static int ffs_fs_parse_opts(struct ffs_sb_fill_data *data, char *opts)
                 /* Parse value */
                 value = simple_strtoul(eq + 1, &end, 0);
                 if (unlikely(*end != ',' && *end != 0)) {
-                        FERR("%s: invalid value: %s", opts, eq + 1);
+                        pr_err("%s: invalid value: %s\n", opts, eq + 1);
                         return -EINVAL;
                 }
 
@@ -1159,7 +1158,7 @@ static int ffs_fs_parse_opts(struct ffs_sb_fill_data *data, char *opts)
 
                 default:
 invalid:
-                        FERR("%s: invalid option", opts);
+                        pr_err("%s: invalid option\n", opts);
                         return -EINVAL;
                 }
 
@@ -1172,12 +1171,11 @@ invalid:
         return 0;
 }
 
-
 /* "mount -t functionfs dev_name /dev/function" ends up here */
 
-static int
-ffs_fs_get_sb(struct file_system_type *t, int flags,
-              const char *dev_name, void *opts, struct vfsmount *mnt)
+static struct dentry *
+ffs_fs_mount(struct file_system_type *t, int flags,
+              const char *dev_name, void *opts)
 {
         struct ffs_sb_fill_data data = {
                 .perms = {
@@ -1193,14 +1191,14 @@ ffs_fs_get_sb(struct file_system_type *t, int flags,
 
         ret = functionfs_check_dev_callback(dev_name);
         if (unlikely(ret < 0))
-                return ret;
+                return ERR_PTR(ret);
 
         ret = ffs_fs_parse_opts(&data, opts);
         if (unlikely(ret < 0))
-                return ret;
+                return ERR_PTR(ret);
 
         data.dev_name = dev_name;
-        return get_sb_single(t, flags, &data, ffs_sb_fill, mnt);
+        return mount_single(t, flags, &data, ffs_sb_fill);
 }
 
 static void
@@ -1219,15 +1217,13 @@ ffs_fs_kill_sb(struct super_block *sb)
 static struct file_system_type ffs_fs_type = {
         .owner          = THIS_MODULE,
         .name           = "functionfs",
-        .get_sb         = ffs_fs_get_sb,
+        .mount          = ffs_fs_mount,
         .kill_sb        = ffs_fs_kill_sb,
 };
 
 
-
 /* Driver's main init/cleanup functions *************************************/
 
-
 static int functionfs_init(void)
 {
         int ret;
@@ -1236,9 +1232,9 @@ static int functionfs_init(void)
 
         ret = register_filesystem(&ffs_fs_type);
         if (likely(!ret))
-                FINFO("file system registered");
+                pr_info("file system registered\n");
         else
-                FERR("failed registering file system (%d)", ret);
+                pr_err("failed registering file system (%d)\n", ret);
 
         return ret;
 }
@@ -1247,18 +1243,16 @@ static void functionfs_cleanup(void)
 {
         ENTER();
 
-        FINFO("unloading");
+        pr_info("unloading\n");
         unregister_filesystem(&ffs_fs_type);
 }
 
 
-
 /* ffs_data and ffs_function construction and destruction code **************/
 
 static void ffs_data_clear(struct ffs_data *ffs);
 static void ffs_data_reset(struct ffs_data *ffs);
 
-
 static void ffs_data_get(struct ffs_data *ffs)
 {
         ENTER();
@@ -1279,7 +1273,7 @@ static void ffs_data_put(struct ffs_data *ffs)
         ENTER();
 
         if (unlikely(atomic_dec_and_test(&ffs->ref))) {
-                FINFO("%s(): freeing", __func__);
+                pr_info("%s(): freeing\n", __func__);
                 ffs_data_clear(ffs);
                 BUG_ON(mutex_is_locked(&ffs->mutex) ||
                        spin_is_locked(&ffs->ev.waitq.lock) ||
@@ -1289,8 +1283,6 @@ static void ffs_data_put(struct ffs_data *ffs)
         }
 }
 
-
-
 static void ffs_data_closed(struct ffs_data *ffs)
 {
         ENTER();
@@ -1303,7 +1295,6 @@ static void ffs_data_closed(struct ffs_data *ffs)
         ffs_data_put(ffs);
 }
 
-
 static struct ffs_data *ffs_data_new(void)
 {
         struct ffs_data *ffs = kzalloc(sizeof *ffs, GFP_KERNEL);
@@ -1326,7 +1317,6 @@ static struct ffs_data *ffs_data_new(void)
         return ffs;
 }
 
-
 static void ffs_data_clear(struct ffs_data *ffs)
 {
         ENTER();
@@ -1344,7 +1334,6 @@ static void ffs_data_clear(struct ffs_data *ffs)
         kfree(ffs->stringtabs);
 }
 
-
 static void ffs_data_reset(struct ffs_data *ffs)
 {
         ENTER();
@@ -1407,7 +1396,6 @@ static int functionfs_bind(struct ffs_data *ffs, struct usb_composite_dev *cdev)
         return 0;
 }
 
-
 static void functionfs_unbind(struct ffs_data *ffs)
 {
         ENTER();
@@ -1420,7 +1408,6 @@ static void functionfs_unbind(struct ffs_data *ffs)
         }
 }
 
-
 static int ffs_epfiles_create(struct ffs_data *ffs)
 {
         struct ffs_epfile *epfile, *epfiles;
@@ -1451,7 +1438,6 @@ static int ffs_epfiles_create(struct ffs_data *ffs)
         return 0;
 }
 
-
 static void ffs_epfiles_destroy(struct ffs_epfile *epfiles, unsigned count)
 {
         struct ffs_epfile *epfile = epfiles;
@@ -1471,7 +1457,6 @@ static void ffs_epfiles_destroy(struct ffs_epfile *epfiles, unsigned count)
         kfree(epfiles);
 }
 
-
 static int functionfs_bind_config(struct usb_composite_dev *cdev,
                                   struct usb_configuration *c,
                                   struct ffs_data *ffs)
@@ -1491,7 +1476,6 @@ static int functionfs_bind_config(struct usb_composite_dev *cdev,
         func->function.bind    = ffs_func_bind;
         func->function.unbind  = ffs_func_unbind;
         func->function.set_alt = ffs_func_set_alt;
-        /*func->function.get_alt = ffs_func_get_alt;*/
         func->function.disable = ffs_func_disable;
         func->function.setup   = ffs_func_setup;
         func->function.suspend = ffs_func_suspend;
@@ -1516,14 +1500,15 @@ static void ffs_func_free(struct ffs_function *func)
         ffs_data_put(func->ffs);
 
         kfree(func->eps);
-        /* eps and interfaces_nums are allocated in the same chunk so
+        /*
+         * eps and interfaces_nums are allocated in the same chunk so
          * only one free is required.  Descriptors are also allocated
-         * in the same chunk. */
+         * in the same chunk.
+         */
 
         kfree(func);
 }
 
-
 static void ffs_func_eps_disable(struct ffs_function *func)
 {
         struct ffs_ep *ep         = func->eps;
@@ -1581,11 +1566,12 @@ static int ffs_func_eps_enable(struct ffs_function *func)
 
 /* Parsing and building descriptors and strings *****************************/
 
-
-/* This validates if data pointed by data is a valid USB descriptor as
+/*
+ * This validates if data pointed by data is a valid USB descriptor as
  * well as record how many interfaces, endpoints and strings are
- * required by given configuration.  Returns address afther the
- * descriptor or NULL if data is invalid. */
+ * required by given configuration.  Returns address after the
+ * descriptor or NULL if data is invalid.
+ */
 
 enum ffs_entity_type {
         FFS_DESCRIPTOR, FFS_INTERFACE, FFS_STRING, FFS_ENDPOINT
@@ -1607,14 +1593,14 @@ static int __must_check ffs_do_desc(char *data, unsigned len,
 
         /* At least two bytes are required: length and type */
         if (len < 2) {
-                FVDBG("descriptor too short");
+                pr_vdebug("descriptor too short\n");
                 return -EINVAL;
         }
 
         /* If we have at least as many bytes as the descriptor takes? */
         length = _ds->bLength;
         if (len < length) {
-                FVDBG("descriptor longer then available data");
+                pr_vdebug("descriptor longer then available data\n");
                 return -EINVAL;
         }
 
@@ -1622,15 +1608,15 @@ static int __must_check ffs_do_desc(char *data, unsigned len,
 #define __entity_check_STRING(val)     (val)
 #define __entity_check_ENDPOINT(val)   ((val) & USB_ENDPOINT_NUMBER_MASK)
 #define __entity(type, val) do {                                        \
-                FVDBG("entity " #type "(%02x)", (val));                 \
+                pr_vdebug("entity " #type "(%02x)\n", (val));           \
                 if (unlikely(!__entity_check_ ##type(val))) {           \
-                        FVDBG("invalid entity's value");                \
+                        pr_vdebug("invalid entity's value\n");          \
                         return -EINVAL;                                 \
                 }                                                       \
                 ret = entity(FFS_ ##type, &val, _ds, priv);             \
                 if (unlikely(ret < 0)) {                                \
-                        FDBG("entity " #type "(%02x); ret = %d",        \
-                             (val), ret);                               \
+                        pr_debug("entity " #type "(%02x); ret = %d\n",  \
+                                 (val), ret);                           \
                         return ret;                                     \
                 }                                                       \
         } while (0)
@@ -1642,12 +1628,13 @@ static int __must_check ffs_do_desc(char *data, unsigned len,
         case USB_DT_STRING:
         case USB_DT_DEVICE_QUALIFIER:
                 /* function can't have any of those */
-                FVDBG("descriptor reserved for gadget: %d", _ds->bDescriptorType);
+                pr_vdebug("descriptor reserved for gadget: %d\n",
+                      _ds->bDescriptorType);
                 return -EINVAL;
 
         case USB_DT_INTERFACE: {
                 struct usb_interface_descriptor *ds = (void *)_ds;
-                FVDBG("interface descriptor");
+                pr_vdebug("interface descriptor\n");
                 if (length != sizeof *ds)
                         goto inv_length;
 
@@ -1659,7 +1646,7 @@ static int __must_check ffs_do_desc(char *data, unsigned len,
 
         case USB_DT_ENDPOINT: {
                 struct usb_endpoint_descriptor *ds = (void *)_ds;
-                FVDBG("endpoint descriptor");
+                pr_vdebug("endpoint descriptor\n");
                 if (length != USB_DT_ENDPOINT_SIZE &&
                     length != USB_DT_ENDPOINT_AUDIO_SIZE)
                         goto inv_length;
@@ -1674,7 +1661,7 @@ static int __must_check ffs_do_desc(char *data, unsigned len,
 
         case USB_DT_INTERFACE_ASSOCIATION: {
                 struct usb_interface_assoc_descriptor *ds = (void *)_ds;
-                FVDBG("interface association descriptor");
+                pr_vdebug("interface association descriptor\n");
                 if (length != sizeof *ds)
                         goto inv_length;
                 if (ds->iFunction)
@@ -1688,17 +1675,17 @@ static int __must_check ffs_do_desc(char *data, unsigned len,
         case USB_DT_SECURITY:
         case USB_DT_CS_RADIO_CONTROL:
                 /* TODO */
-                FVDBG("unimplemented descriptor: %d", _ds->bDescriptorType);
+                pr_vdebug("unimplemented descriptor: %d\n", _ds->bDescriptorType);
                 return -EINVAL;
 
         default:
                 /* We should never be here */
-                FVDBG("unknown descriptor: %d", _ds->bDescriptorType);
+                pr_vdebug("unknown descriptor: %d\n", _ds->bDescriptorType);
                 return -EINVAL;
 
-        inv_length:
-                FVDBG("invalid length: %d (descriptor %d)",
-                      _ds->bLength, _ds->bDescriptorType);
+inv_length:
+                pr_vdebug("invalid length: %d (descriptor %d)\n",
+                          _ds->bLength, _ds->bDescriptorType);
                 return -EINVAL;
         }
 
@@ -1711,7 +1698,6 @@ static int __must_check ffs_do_desc(char *data, unsigned len,
         return length;
 }
 
-
 static int __must_check ffs_do_descs(unsigned count, char *data, unsigned len,
                                      ffs_entity_callback entity, void *priv)
 {
@@ -1726,10 +1712,11 @@ static int __must_check ffs_do_descs(unsigned count, char *data, unsigned len,
                 if (num == count)
                         data = NULL;
 
-                /* Record "descriptor" entitny */
+                /* Record "descriptor" entity */
                 ret = entity(FFS_DESCRIPTOR, (u8 *)num, (void *)data, priv);
                 if (unlikely(ret < 0)) {
-                        FDBG("entity DESCRIPTOR(%02lx); ret = %d", num, ret);
+                        pr_debug("entity DESCRIPTOR(%02lx); ret = %d\n",
+                                 num, ret);
                         return ret;
                 }
 
@@ -1738,7 +1725,7 @@ static int __must_check ffs_do_descs(unsigned count, char *data, unsigned len,
 
                 ret = ffs_do_desc(data, len, entity, priv);
                 if (unlikely(ret < 0)) {
-                        FDBG("%s returns %d", __func__, ret);
+                        pr_debug("%s returns %d\n", __func__, ret);
                         return ret;
                 }
 
@@ -1748,7 +1735,6 @@ static int __must_check ffs_do_descs(unsigned count, char *data, unsigned len,
         }
 }
 
-
 static int __ffs_data_do_entity(enum ffs_entity_type type,
                                 u8 *valuep, struct usb_descriptor_header *desc,
                                 void *priv)
@@ -1762,16 +1748,20 @@ static int __ffs_data_do_entity(enum ffs_entity_type type,
                 break;
 
         case FFS_INTERFACE:
-                /* Interfaces are indexed from zero so if we
+                /*
+                 * Interfaces are indexed from zero so if we
                  * encountered interface "n" then there are at least
-                 * "n+1" interfaces. */
+                 * "n+1" interfaces.
+                 */
                 if (*valuep >= ffs->interfaces_count)
                         ffs->interfaces_count = *valuep + 1;
                 break;
 
         case FFS_STRING:
-                /* Strings are indexed from 1 (0 is magic ;) reserved
-                 * for languages list or some such) */
+                /*
+                 * Strings are indexed from 1 (0 is magic ;) reserved
+                 * for languages list or some such)
+                 */
                 if (*valuep > ffs->strings_count)
                         ffs->strings_count = *valuep;
                 break;
@@ -1786,7 +1776,6 @@ static int __ffs_data_do_entity(enum ffs_entity_type type,
         return 0;
 }
 
-
 static int __ffs_data_got_descs(struct ffs_data *ffs,
                                 char *const _data, size_t len)
 {
@@ -1849,8 +1838,6 @@ error:
         return ret;
 }
 
-
-
 static int __ffs_data_got_strings(struct ffs_data *ffs,
                                   char *const _data, size_t len)
 {
@@ -1876,17 +1863,17 @@ static int __ffs_data_got_strings(struct ffs_data *ffs,
         if (unlikely(str_count < needed_count))
                 goto error;
 
-        /* If we don't need any strings just return and free all
-         * memory */
+        /*
+         * If we don't need any strings just return and free all
+         * memory.
+         */
         if (!needed_count) {
                 kfree(_data);
                 return 0;
         }
 
-        /* Allocate */
+        /* Allocate everything in one chunk so there's less maintenance. */
         {
-                /* Allocate everything in one chunk so there's less
-                 * maintanance. */
                 struct {
                         struct usb_gadget_strings *stringtabs[lang_count + 1];
                         struct usb_gadget_strings stringtab[lang_count];
@@ -1937,13 +1924,17 @@ static int __ffs_data_got_strings(struct ffs_data *ffs,
                         if (unlikely(length == len))
                                 goto error_free;
 
-                        /* user may provide more strings then we need,
-                         * if that's the case we simply ingore the
-                         * rest */
+                        /*
+                         * User may provide more strings then we need,
+                         * if that's the case we simply ignore the
+                         * rest
+                         */
                         if (likely(needed)) {
-                                /* s->id will be set while adding
+                                /*
+                                 * s->id will be set while adding
                                  * function to configuration so for
-                                 * now just leave garbage here. */
+                                 * now just leave garbage here.
+                                 */
                                 s->s = data;
                                 --needed;
                                 ++s;
@@ -1977,8 +1968,6 @@ error:
 }
 
 
-
-
 /* Events handling and management *******************************************/
 
 static void __ffs_event_add(struct ffs_data *ffs,
@@ -1987,29 +1976,32 @@ static void __ffs_event_add(struct ffs_data *ffs,
         enum usb_functionfs_event_type rem_type1, rem_type2 = type;
         int neg = 0;
 
-        /* Abort any unhandled setup */
-        /* We do not need to worry about some cmpxchg() changing value
+        /*
+         * Abort any unhandled setup
+         *
+         * We do not need to worry about some cmpxchg() changing value
          * of ffs->setup_state without holding the lock because when
          * state is FFS_SETUP_PENDING cmpxchg() in several places in
-         * the source does nothing. */
+         * the source does nothing.
+         */
         if (ffs->setup_state == FFS_SETUP_PENDING)
                 ffs->setup_state = FFS_SETUP_CANCELED;
 
         switch (type) {
         case FUNCTIONFS_RESUME:
                 rem_type2 = FUNCTIONFS_SUSPEND;
-                /* FALL THGOUTH */
+                /* FALL THROUGH */
         case FUNCTIONFS_SUSPEND:
         case FUNCTIONFS_SETUP:
                 rem_type1 = type;
-                /* discard all similar events */
+                /* Discard all similar events */
                 break;
 
         case FUNCTIONFS_BIND:
         case FUNCTIONFS_UNBIND:
         case FUNCTIONFS_DISABLE:
         case FUNCTIONFS_ENABLE:
-                /* discard everything other then power management. */
+                /* Discard everything other then power management. */
                 rem_type1 = FUNCTIONFS_SUSPEND;
                 rem_type2 = FUNCTIONFS_RESUME;
                 neg = 1;
@@ -2026,11 +2018,11 @@ static void __ffs_event_add(struct ffs_data *ffs,
                         if ((*ev == rem_type1 || *ev == rem_type2) == neg)
                                 *out++ = *ev;
                         else
-                                FVDBG("purging event %d", *ev);
+                                pr_vdebug("purging event %d\n", *ev);
                 ffs->ev.count = out - ffs->ev.types;
         }
 
-        FVDBG("adding event %d", type);
+        pr_vdebug("adding event %d\n", type);
         ffs->ev.types[ffs->ev.count++] = type;
         wake_up_locked(&ffs->ev.waitq);
 }
@@ -2055,8 +2047,10 @@ static int __ffs_func_bind_do_descs(enum ffs_entity_type type, u8 *valuep,
         struct ffs_function *func = priv;
         struct ffs_ep *ffs_ep;
 
-        /* If hs_descriptors is not NULL then we are reading hs
-         * descriptors now */
+        /*
+         * If hs_descriptors is not NULL then we are reading hs
+         * descriptors now
+         */
         const int isHS = func->function.hs_descriptors != NULL;
         unsigned idx;
 
@@ -2075,9 +2069,9 @@ static int __ffs_func_bind_do_descs(enum ffs_entity_type type, u8 *valuep,
         ffs_ep = func->eps + idx;
 
         if (unlikely(ffs_ep->descs[isHS])) {
-                FVDBG("two %sspeed descriptors for EP %d",
-                      isHS ? "high" : "full",
-                      ds->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
+                pr_vdebug("two %sspeed descriptors for EP %d\n",
+                          isHS ? "high" : "full",
+                          ds->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
                 return -EINVAL;
         }
         ffs_ep->descs[isHS] = ds;
@@ -2091,11 +2085,11 @@ static int __ffs_func_bind_do_descs(enum ffs_entity_type type, u8 *valuep,
                 struct usb_request *req;
                 struct usb_ep *ep;
 
-                FVDBG("autoconfig");
+                pr_vdebug("autoconfig\n");
                 ep = usb_ep_autoconfig(func->gadget, ds);
                 if (unlikely(!ep))
                         return -ENOTSUPP;
-                ep->driver_data = func->eps + idx;;
+                ep->driver_data = func->eps + idx;
 
                 req = usb_ep_alloc_request(ep, GFP_KERNEL);
                 if (unlikely(!req))
@@ -2111,7 +2105,6 @@ static int __ffs_func_bind_do_descs(enum ffs_entity_type type, u8 *valuep,
         return 0;
 }
 
-
 static int __ffs_func_bind_do_nums(enum ffs_entity_type type, u8 *valuep,
                                    struct usb_descriptor_header *desc,
                                    void *priv)
@@ -2143,8 +2136,10 @@ static int __ffs_func_bind_do_nums(enum ffs_entity_type type, u8 *valuep,
                 break;
 
         case FFS_ENDPOINT:
-                /* USB_DT_ENDPOINT are handled in
-                 * __ffs_func_bind_do_descs(). */
+                /*
+                 * USB_DT_ENDPOINT are handled in
+                 * __ffs_func_bind_do_descs().
+                 */
                 if (desc->bDescriptorType == USB_DT_ENDPOINT)
                         return 0;
 
@@ -2160,7 +2155,7 @@ static int __ffs_func_bind_do_nums(enum ffs_entity_type type, u8 *valuep,
                 break;
         }
 
-        FVDBG("%02x -> %02x", *valuep, newValue);
+        pr_vdebug("%02x -> %02x\n", *valuep, newValue);
         *valuep = newValue;
         return 0;
 }
@@ -2211,9 +2206,11 @@ static int ffs_func_bind(struct usb_configuration *c,
         func->eps             = data->eps;
         func->interfaces_nums = data->inums;
 
-        /* Go throught all the endpoint descriptors and allocate
+        /*
+         * Go through all the endpoint descriptors and allocate
          * endpoints first, so that later we can rewrite the endpoint
-         * numbers without worying that it may be described later on. */
+         * numbers without worrying that it may be described later on.
+         */
         if (likely(full)) {
                 func->function.descriptors = data->fs_descs;
                 ret = ffs_do_descs(ffs->fs_descs_count,
@@ -2234,9 +2231,11 @@ static int ffs_func_bind(struct usb_configuration *c,
                                    __ffs_func_bind_do_descs, func);
         }
 
-        /* Now handle interface numbers allocation and interface and
-         * enpoint numbers rewritting.  We can do that in one go
-         * now. */
+        /*
+         * Now handle interface numbers allocation and interface and
+         * endpoint numbers rewriting.  We can do that in one go
+         * now.
+         */
         ret = ffs_do_descs(ffs->fs_descs_count +
                            (high ? ffs->hs_descs_count : 0),
                            data->raw_descs, sizeof data->raw_descs,
@@ -2274,7 +2273,6 @@ static void ffs_func_unbind(struct usb_configuration *c,
         ffs_func_free(func);
 }
 
-
 static int ffs_func_set_alt(struct usb_function *f,
                             unsigned interface, unsigned alt)
 {
@@ -2322,20 +2320,21 @@ static int ffs_func_setup(struct usb_function *f,
 
         ENTER();
 
-        FVDBG("creq->bRequestType = %02x", creq->bRequestType);
-        FVDBG("creq->bRequest     = %02x", creq->bRequest);
-        FVDBG("creq->wValue       = %04x", le16_to_cpu(creq->wValue));
-        FVDBG("creq->wIndex       = %04x", le16_to_cpu(creq->wIndex));
-        FVDBG("creq->wLength      = %04x", le16_to_cpu(creq->wLength));
+        pr_vdebug("creq->bRequestType = %02x\n", creq->bRequestType);
+        pr_vdebug("creq->bRequest     = %02x\n", creq->bRequest);
+        pr_vdebug("creq->wValue       = %04x\n", le16_to_cpu(creq->wValue));
+        pr_vdebug("creq->wIndex       = %04x\n", le16_to_cpu(creq->wIndex));
+        pr_vdebug("creq->wLength      = %04x\n", le16_to_cpu(creq->wLength));
 
-        /* Most requests directed to interface go throught here
+        /*
+         * Most requests directed to interface go through here
          * (notable exceptions are set/get interface) so we need to
          * handle them.  All other either handled by composite or
          * passed to usb_configuration->setup() (if one is set).  No
          * matter, we will handle requests directed to endpoint here
          * as well (as it's straightforward) but what to do with any
-         * other request? */
-
+         * other request?
+         */
         if (ffs->state != FFS_ACTIVE)
                 return -ENODEV;
 
@@ -2378,8 +2377,7 @@ static void ffs_func_resume(struct usb_function *f)
 }
 
 
-
-/* Enpoint and interface numbers reverse mapping ****************************/
+/* Endpoint and interface numbers reverse mapping ***************************/
 
 static int ffs_func_revmap_ep(struct ffs_function *func, u8 num)
 {
@@ -2410,7 +2408,6 @@ static int ffs_mutex_lock(struct mutex *mutex, unsigned nonblock)
                 : mutex_lock_interruptible(mutex);
 }
 
-
 static char *ffs_prepare_buffer(const char * __user buf, size_t len)
 {
         char *data;
@@ -2427,7 +2424,7 @@ static char *ffs_prepare_buffer(const char * __user buf, size_t len)
                 return ERR_PTR(-EFAULT);
         }
 
-        FVDBG("Buffer from user space:");
+        pr_vdebug("Buffer from user space:\n");
         ffs_dump_mem("", data, len);
 
         return data;
diff --git a/drivers/usb/gadget/f_hid.c b/drivers/usb/gadget/f_hid.c
index 53e120208e99..598e7e2ab80c 100644
--- a/drivers/usb/gadget/f_hid.c
+++ b/drivers/usb/gadget/f_hid.c
@@ -25,7 +25,6 @@
 #include <linux/cdev.h>
 #include <linux/mutex.h>
 #include <linux/poll.h>
-#include <linux/smp_lock.h>
 #include <linux/uaccess.h>
 #include <linux/wait.h>
 #include <linux/usb/g_hid.h>
@@ -318,8 +317,6 @@ static void hidg_set_report_complete(struct usb_ep *ep, struct usb_request *req)
         spin_unlock(&hidg->spinlock);
 
         wake_up(&hidg->read_queue);
-
-        return;
 }
 
 static int hidg_setup(struct usb_function *f,
@@ -413,8 +410,6 @@ static void hidg_disable(struct usb_function *f)
 
         usb_ep_disable(hidg->in_ep);
         hidg->in_ep->driver_data = NULL;
-
-        return;
 }
 
 static int hidg_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
@@ -451,6 +446,7 @@ const struct file_operations f_hidg_fops = {
         .write          = f_hidg_write,
         .read           = f_hidg_read,
         .poll           = f_hidg_poll,
+        .llseek         = noop_llseek,
 };
 
 static int __init hidg_bind(struct usb_configuration *c, struct usb_function *f)
diff --git a/drivers/usb/gadget/f_loopback.c b/drivers/usb/gadget/f_loopback.c
index 43225879c3cd..b37960f9e753 100644
--- a/drivers/usb/gadget/f_loopback.c
+++ b/drivers/usb/gadget/f_loopback.c
@@ -324,7 +324,7 @@ static void loopback_disable(struct usb_function *f)
 
 /*-------------------------------------------------------------------------*/
 
-static int __ref loopback_bind_config(struct usb_configuration *c)
+static int __init loopback_bind_config(struct usb_configuration *c)
 {
         struct f_loopback       *loop;
         int                     status;
@@ -346,10 +346,9 @@ static int __ref loopback_bind_config(struct usb_configuration *c)
         return status;
 }
 
-static  struct usb_configuration loopback_driver = {
+static struct usb_configuration loopback_driver = {
         .label          = "loopback",
         .strings        = loopback_strings,
-        .bind           = loopback_bind_config,
         .bConfigurationValue = 2,
         .bmAttributes   = USB_CONFIG_ATT_SELFPOWER,
         /* .iConfiguration = DYNAMIC */
@@ -382,5 +381,5 @@ int __init loopback_add(struct usb_composite_dev *cdev, bool autoresume)
                 loopback_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
         }
 
-        return usb_add_config(cdev, &loopback_driver);
+        return usb_add_config(cdev, &loopback_driver, loopback_bind_config);
 }
diff --git a/drivers/usb/gadget/f_mass_storage.c b/drivers/usb/gadget/f_mass_storage.c
index 32cce029f65c..efb58f9f5aa9 100644
--- a/drivers/usb/gadget/f_mass_storage.c
+++ b/drivers/usb/gadget/f_mass_storage.c
@@ -37,7 +37,6 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-
 /*
  * The Mass Storage Function acts as a USB Mass Storage device,
  * appearing to the host as a disk drive or as a CD-ROM drive.  In
@@ -73,6 +72,8 @@
  *                              being removable.
  *      ->cdrom         Flag specifying that LUN shall be reported as
  *                              being a CD-ROM.
+ *      ->nofua         Flag specifying that FUA flag in SCSI WRITE(10,12)
+ *                              commands for this LUN shall be ignored.
  *
  *      lun_name_format A printf-like format for names of the LUN
  *                              devices.  This determines how the
@@ -127,6 +128,8 @@
  *                      Default true, boolean for removable media.
  *      cdrom=b[,b...]  Default false, boolean for whether to emulate
  *                              a CD-ROM drive.
+ *      nofua=b[,b...]  Default false, booleans for ignore FUA flag
+ *                              in SCSI WRITE(10,12) commands
  *      luns=N          Default N = number of filenames, number of
  *                              LUNs to support.
  *      stall           Default determined according to the type of
@@ -181,7 +184,6 @@
  * <http://www.usb.org/developers/devclass_docs/usbmass-ufi10.pdf>.
  */
 
-
 /*
  *                              Driver Design
  *
@@ -271,7 +273,6 @@
 /* #define VERBOSE_DEBUG */
 /* #define DUMP_MSGS */
 
-
 #include <linux/blkdev.h>
 #include <linux/completion.h>
 #include <linux/dcache.h>
@@ -292,11 +293,11 @@
 
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
+#include <linux/usb/composite.h>
 
 #include "gadget_chips.h"
 
 
-
 /*------------------------------------------------------------------------*/
 
 #define FSG_DRIVER_DESC         "Mass Storage Function"
@@ -304,7 +305,6 @@
 
 static const char fsg_string_interface[] = "Mass Storage";
 
-
 #define FSG_NO_INTR_EP 1
 #define FSG_NO_DEVICE_STRINGS    1
 #define FSG_NO_OTG               1
@@ -320,28 +320,34 @@ struct fsg_common;
 
 /* FSF callback functions */
 struct fsg_operations {
-        /* Callback function to call when thread exits.  If no
+        /*
+         * Callback function to call when thread exits.  If no
          * callback is set or it returns value lower then zero MSF
          * will force eject all LUNs it operates on (including those
          * marked as non-removable or with prevent_medium_removal flag
-         * set). */
+         * set).
+         */
         int (*thread_exits)(struct fsg_common *common);
 
-        /* Called prior to ejection.  Negative return means error,
+        /*
+         * Called prior to ejection.  Negative return means error,
          * zero means to continue with ejection, positive means not to
-         * eject. */
+         * eject.
+         */
         int (*pre_eject)(struct fsg_common *common,
                          struct fsg_lun *lun, int num);
-        /* Called after ejection.  Negative return means error, zero
-         * or positive is just a success. */
+        /*
+         * Called after ejection.  Negative return means error, zero
+         * or positive is just a success.
+         */
         int (*post_eject)(struct fsg_common *common,
                           struct fsg_lun *lun, int num);
 };
 
-
 /* Data shared by all the FSG instances. */
 struct fsg_common {
         struct usb_gadget       *gadget;
+        struct usb_composite_dev *cdev;
         struct fsg_dev          *fsg, *new_fsg;
         wait_queue_head_t       fsg_wait;
 
@@ -394,14 +400,15 @@ struct fsg_common {
         /* Gadget's private data. */
         void                    *private_data;
 
-        /* Vendor (8 chars), product (16 chars), release (4
-         * hexadecimal digits) and NUL byte */
+        /*
+         * Vendor (8 chars), product (16 chars), release (4
+         * hexadecimal digits) and NUL byte
+         */
         char inquiry_string[8 + 16 + 4 + 1];
 
         struct kref             ref;
 };
 
-
 struct fsg_config {
         unsigned nluns;
         struct fsg_lun_config {
@@ -409,6 +416,7 @@ struct fsg_config {
                 char ro;
                 char removable;
                 char cdrom;
+                char nofua;
         } luns[FSG_MAX_LUNS];
 
         const char              *lun_name_format;
@@ -426,7 +434,6 @@ struct fsg_config {
         char                    can_stall;
 };
 
-
 struct fsg_dev {
         struct usb_function     function;
         struct usb_gadget       *gadget;        /* Copy of cdev->gadget */
@@ -444,7 +451,6 @@ struct fsg_dev {
         struct usb_ep           *bulk_out;
 };
 
-
 static inline int __fsg_is_set(struct fsg_common *common,
                                const char *func, unsigned line)
 {
@@ -457,13 +463,11 @@ static inline int __fsg_is_set(struct fsg_common *common,
 
 #define fsg_is_set(common) likely(__fsg_is_set(common, __func__, __LINE__))
 
-
 static inline struct fsg_dev *fsg_from_func(struct usb_function *f)
 {
         return container_of(f, struct fsg_dev, function);
 }
 
-
 typedef void (*fsg_routine_t)(struct fsg_dev *);
 
 static int exception_in_progress(struct fsg_common *common)
@@ -473,7 +477,7 @@ static int exception_in_progress(struct fsg_common *common)
 
 /* Make bulk-out requests be divisible by the maxpacket size */
 static void set_bulk_out_req_length(struct fsg_common *common,
-                struct fsg_buffhd *bh, unsigned int length)
+                                    struct fsg_buffhd *bh, unsigned int length)
 {
         unsigned int    rem;
 
@@ -484,6 +488,7 @@ static void set_bulk_out_req_length(struct fsg_common *common,
         bh->outreq->length = length;
 }
 
+
 /*-------------------------------------------------------------------------*/
 
 static int fsg_set_halt(struct fsg_dev *fsg, struct usb_ep *ep)
@@ -514,14 +519,15 @@ static void wakeup_thread(struct fsg_common *common)
                 wake_up_process(common->thread_task);
 }
 
-
 static void raise_exception(struct fsg_common *common, enum fsg_state new_state)
 {
         unsigned long           flags;
 
-        /* Do nothing if a higher-priority exception is already in progress.
+        /*
+         * Do nothing if a higher-priority exception is already in progress.
          * If a lower-or-equal priority exception is in progress, preempt it
-         * and notify the main thread by sending it a signal. */
+         * and notify the main thread by sending it a signal.
+         */
         spin_lock_irqsave(&common->lock, flags);
         if (common->state <= new_state) {
                 common->exception_req_tag = common->ep0_req_tag;
@@ -550,10 +556,10 @@ static int ep0_queue(struct fsg_common *common)
         return rc;
 }
 
+
 /*-------------------------------------------------------------------------*/
 
-/* Bulk and interrupt endpoint completion handlers.
- * These always run in_irq. */
+/* Completion handlers. These always run in_irq. */
 
 static void bulk_in_complete(struct usb_ep *ep, struct usb_request *req)
 {
@@ -562,7 +568,7 @@ static void bulk_in_complete(struct usb_ep *ep, struct usb_request *req)
 
         if (req->status || req->actual != req->length)
                 DBG(common, "%s --> %d, %u/%u\n", __func__,
-                                req->status, req->actual, req->length);
+                    req->status, req->actual, req->length);
         if (req->status == -ECONNRESET)         /* Request was cancelled */
                 usb_ep_fifo_flush(ep);
 
@@ -583,8 +589,7 @@ static void bulk_out_complete(struct usb_ep *ep, struct usb_request *req)
         dump_msg(common, "bulk-out", req->buf, req->actual);
         if (req->status || req->actual != bh->bulk_out_intended_length)
                 DBG(common, "%s --> %d, %u/%u\n", __func__,
-                                req->status, req->actual,
-                                bh->bulk_out_intended_length);
+                    req->status, req->actual, bh->bulk_out_intended_length);
         if (req->status == -ECONNRESET)         /* Request was cancelled */
                 usb_ep_fifo_flush(ep);
 
@@ -597,13 +602,8 @@ static void bulk_out_complete(struct usb_ep *ep, struct usb_request *req)
         spin_unlock(&common->lock);
 }
 
-
-/*-------------------------------------------------------------------------*/
-
-/* Ep0 class-specific handlers.  These always run in_irq. */
-
 static int fsg_setup(struct usb_function *f,
-                const struct usb_ctrlrequest *ctrl)
+                     const struct usb_ctrlrequest *ctrl)
 {
         struct fsg_dev          *fsg = fsg_from_func(f);
         struct usb_request      *req = fsg->common->ep0req;
@@ -614,6 +614,11 @@ static int fsg_setup(struct usb_function *f,
         if (!fsg_is_set(fsg->common))
                 return -EOPNOTSUPP;
 
+        ++fsg->common->ep0_req_tag;     /* Record arrival of a new request */
+        req->context = NULL;
+        req->length = 0;
+        dump_msg(fsg, "ep0-setup", (u8 *) ctrl, sizeof(*ctrl));
+
         switch (ctrl->bRequest) {
 
         case USB_BULK_RESET_REQUEST:
@@ -623,8 +628,10 @@ static int fsg_setup(struct usb_function *f,
                 if (w_index != fsg->interface_number || w_value != 0)
                         return -EDOM;
 
-                /* Raise an exception to stop the current operation
-                 * and reinitialize our state. */
+                /*
+                 * Raise an exception to stop the current operation
+                 * and reinitialize our state.
+                 */
                 DBG(fsg, "bulk reset request\n");
                 raise_exception(fsg->common, FSG_STATE_RESET);
                 return DELAYED_STATUS;
@@ -636,7 +643,7 @@ static int fsg_setup(struct usb_function *f,
                 if (w_index != fsg->interface_number || w_value != 0)
                         return -EDOM;
                 VDBG(fsg, "get max LUN\n");
-                *(u8 *) req->buf = fsg->common->nluns - 1;
+                *(u8 *)req->buf = fsg->common->nluns - 1;
 
                 /* Respond with data/status */
                 req->length = min((u16)1, w_length);
@@ -644,8 +651,7 @@ static int fsg_setup(struct usb_function *f,
         }
 
         VDBG(fsg,
-             "unknown class-specific control req "
-             "%02x.%02x v%04x i%04x l%u\n",
+             "unknown class-specific control req %02x.%02x v%04x i%04x l%u\n",
              ctrl->bRequestType, ctrl->bRequest,
              le16_to_cpu(ctrl->wValue), w_index, w_length);
         return -EOPNOTSUPP;
@@ -656,11 +662,10 @@ static int fsg_setup(struct usb_function *f,
 
 /* All the following routines run in process context */
 
-
 /* Use this for bulk or interrupt transfers, not ep0 */
 static void start_transfer(struct fsg_dev *fsg, struct usb_ep *ep,
-                struct usb_request *req, int *pbusy,
-                enum fsg_buffer_state *state)
+                           struct usb_request *req, int *pbusy,
+                           enum fsg_buffer_state *state)
 {
         int     rc;
 
@@ -678,25 +683,34 @@ static void start_transfer(struct fsg_dev *fsg, struct usb_ep *ep,
 
                 /* We can't do much more than wait for a reset */
 
-                /* Note: currently the net2280 driver fails zero-length
-                 * submissions if DMA is enabled. */
-                if (rc != -ESHUTDOWN && !(rc == -EOPNOTSUPP &&
-                                                req->length == 0))
+                /*
+                 * Note: currently the net2280 driver fails zero-length
+                 * submissions if DMA is enabled.
+                 */
+                if (rc != -ESHUTDOWN &&
+                    !(rc == -EOPNOTSUPP && req->length == 0))
                         WARNING(fsg, "error in submission: %s --> %d\n",
-                                        ep->name, rc);
+                                ep->name, rc);
         }
 }
 
-#define START_TRANSFER_OR(common, ep_name, req, pbusy, state)           \
-        if (fsg_is_set(common))                                         \
-                start_transfer((common)->fsg, (common)->fsg->ep_name,   \
-                               req, pbusy, state);                      \
-        else
-
-#define START_TRANSFER(common, ep_name, req, pbusy, state)              \
-        START_TRANSFER_OR(common, ep_name, req, pbusy, state) (void)0
-
+static bool start_in_transfer(struct fsg_common *common, struct fsg_buffhd *bh)
+{
+        if (!fsg_is_set(common))
+                return false;
+        start_transfer(common->fsg, common->fsg->bulk_in,
+                       bh->inreq, &bh->inreq_busy, &bh->state);
+        return true;
+}
 
+static bool start_out_transfer(struct fsg_common *common, struct fsg_buffhd *bh)
+{
+        if (!fsg_is_set(common))
+                return false;
+        start_transfer(common->fsg, common->fsg->bulk_out,
+                       bh->outreq, &bh->outreq_busy, &bh->state);
+        return true;
+}
 
 static int sleep_thread(struct fsg_common *common)
 {
@@ -734,16 +748,20 @@ static int do_read(struct fsg_common *common)
         unsigned int            partial_page;
         ssize_t                 nread;
 
-        /* Get the starting Logical Block Address and check that it's
-         * not too big */
-        if (common->cmnd[0] == SC_READ_6)
+        /*
+         * Get the starting Logical Block Address and check that it's
+         * not too big.
+         */
+        if (common->cmnd[0] == READ_6)
                 lba = get_unaligned_be24(&common->cmnd[1]);
         else {
                 lba = get_unaligned_be32(&common->cmnd[2]);
 
-                /* We allow DPO (Disable Page Out = don't save data in the
+                /*
+                 * We allow DPO (Disable Page Out = don't save data in the
                  * cache) and FUA (Force Unit Access = don't read from the
-                 * cache), but we don't implement them. */
+                 * cache), but we don't implement them.
+                 */
                 if ((common->cmnd[1] & ~0x18) != 0) {
                         curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
                         return -EINVAL;
@@ -761,22 +779,23 @@ static int do_read(struct fsg_common *common)
                 return -EIO;            /* No default reply */
 
         for (;;) {
-
-                /* Figure out how much we need to read:
+                /*
+                 * Figure out how much we need to read:
                  * Try to read the remaining amount.
                  * But don't read more than the buffer size.
                  * And don't try to read past the end of the file.
                  * Finally, if we're not at a page boundary, don't read past
                  *      the next page.
                  * If this means reading 0 then we were asked to read past
-                 *      the end of file. */
+                 *      the end of file.
+                 */
                 amount = min(amount_left, FSG_BUFLEN);
-                amount = min((loff_t) amount,
-                                curlun->file_length - file_offset);
+                amount = min((loff_t)amount,
+                             curlun->file_length - file_offset);
                 partial_page = file_offset & (PAGE_CACHE_SIZE - 1);
                 if (partial_page > 0)
-                        amount = min(amount, (unsigned int) PAGE_CACHE_SIZE -
-                                        partial_page);
+                        amount = min(amount, (unsigned int)PAGE_CACHE_SIZE -
+                                             partial_page);
 
                 /* Wait for the next buffer to become available */
                 bh = common->next_buffhd_to_fill;
@@ -786,8 +805,10 @@ static int do_read(struct fsg_common *common)
                                 return rc;
                 }
 
-                /* If we were asked to read past the end of file,
-                 * end with an empty buffer. */
+                /*
+                 * If we were asked to read past the end of file,
+                 * end with an empty buffer.
+                 */
                 if (amount == 0) {
                         curlun->sense_data =
                                         SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
@@ -801,21 +822,19 @@ static int do_read(struct fsg_common *common)
                 /* Perform the read */
                 file_offset_tmp = file_offset;
                 nread = vfs_read(curlun->filp,
-                                (char __user *) bh->buf,
-                                amount, &file_offset_tmp);
+                                 (char __user *)bh->buf,
+                                 amount, &file_offset_tmp);
                 VLDBG(curlun, "file read %u @ %llu -> %d\n", amount,
-                                (unsigned long long) file_offset,
-                                (int) nread);
+                      (unsigned long long)file_offset, (int)nread);
                 if (signal_pending(current))
                         return -EINTR;
 
                 if (nread < 0) {
-                        LDBG(curlun, "error in file read: %d\n",
-                                        (int) nread);
+                        LDBG(curlun, "error in file read: %d\n", (int)nread);
                         nread = 0;
                 } else if (nread < amount) {
                         LDBG(curlun, "partial file read: %d/%u\n",
-                                        (int) nread, amount);
+                             (int)nread, amount);
                         nread -= (nread & 511); /* Round down to a block */
                 }
                 file_offset  += nread;
@@ -837,10 +856,8 @@ static int do_read(struct fsg_common *common)
 
                 /* Send this buffer and go read some more */
                 bh->inreq->zero = 0;
-                START_TRANSFER_OR(common, bulk_in, bh->inreq,
-                               &bh->inreq_busy, &bh->state)
-                        /* Don't know what to do if
-                         * common->fsg is NULL */
+                if (!start_in_transfer(common, bh))
+                        /* Don't know what to do if common->fsg is NULL */
                         return -EIO;
                 common->next_buffhd_to_fill = bh->next;
         }
@@ -872,22 +889,26 @@ static int do_write(struct fsg_common *common)
         curlun->filp->f_flags &= ~O_SYNC;       /* Default is not to wait */
         spin_unlock(&curlun->filp->f_lock);
 
-        /* Get the starting Logical Block Address and check that it's
-         * not too big */
-        if (common->cmnd[0] == SC_WRITE_6)
+        /*
+         * Get the starting Logical Block Address and check that it's
+         * not too big
+         */
+        if (common->cmnd[0] == WRITE_6)
                 lba = get_unaligned_be24(&common->cmnd[1]);
         else {
                 lba = get_unaligned_be32(&common->cmnd[2]);
 
-                /* We allow DPO (Disable Page Out = don't save data in the
+                /*
+                 * We allow DPO (Disable Page Out = don't save data in the
                  * cache) and FUA (Force Unit Access = write directly to the
                  * medium).  We don't implement DPO; we implement FUA by
-                 * performing synchronous output. */
+                 * performing synchronous output.
+                 */
                 if (common->cmnd[1] & ~0x18) {
                         curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
                         return -EINVAL;
                 }
-                if (common->cmnd[1] & 0x08) {   /* FUA */
+                if (!curlun->nofua && (common->cmnd[1] & 0x08)) { /* FUA */
                         spin_lock(&curlun->filp->f_lock);
                         curlun->filp->f_flags |= O_SYNC;
                         spin_unlock(&curlun->filp->f_lock);
@@ -910,7 +931,8 @@ static int do_write(struct fsg_common *common)
                 bh = common->next_buffhd_to_fill;
                 if (bh->state == BUF_STATE_EMPTY && get_some_more) {
 
-                        /* Figure out how much we want to get:
+                        /*
+                         * Figure out how much we want to get:
                          * Try to get the remaining amount.
                          * But don't get more than the buffer size.
                          * And don't try to go past the end of the file.
@@ -918,14 +940,15 @@ static int do_write(struct fsg_common *common)
                          *      don't go past the next page.
                          * If this means getting 0, then we were asked
                          *      to write past the end of file.
-                         * Finally, round down to a block boundary. */
+                         * Finally, round down to a block boundary.
+                         */
                         amount = min(amount_left_to_req, FSG_BUFLEN);
-                        amount = min((loff_t) amount, curlun->file_length -
-                                        usb_offset);
+                        amount = min((loff_t)amount,
+                                     curlun->file_length - usb_offset);
                         partial_page = usb_offset & (PAGE_CACHE_SIZE - 1);
                         if (partial_page > 0)
                                 amount = min(amount,
-        (unsigned int) PAGE_CACHE_SIZE - partial_page);
+        (unsigned int)PAGE_CACHE_SIZE - partial_page);
 
                         if (amount == 0) {
                                 get_some_more = 0;
@@ -935,11 +958,13 @@ static int do_write(struct fsg_common *common)
                                 curlun->info_valid = 1;
                                 continue;
                         }
-                        amount -= (amount & 511);
+                        amount -= amount & 511;
                         if (amount == 0) {
 
-                                /* Why were we were asked to transfer a
-                                 * partial block? */
+                                /*
+                                 * Why were we were asked to transfer a
+                                 * partial block?
+                                 */
                                 get_some_more = 0;
                                 continue;
                         }
@@ -951,15 +976,15 @@ static int do_write(struct fsg_common *common)
                         if (amount_left_to_req == 0)
                                 get_some_more = 0;
 
-                        /* amount is always divisible by 512, hence by
-                         * the bulk-out maxpacket size */
+                        /*
+                         * amount is always divisible by 512, hence by
+                         * the bulk-out maxpacket size
+                         */
                         bh->outreq->length = amount;
                         bh->bulk_out_intended_length = amount;
                         bh->outreq->short_not_ok = 1;
-                        START_TRANSFER_OR(common, bulk_out, bh->outreq,
-                                          &bh->outreq_busy, &bh->state)
-                                /* Don't know what to do if
-                                 * common->fsg is NULL */
+                        if (!start_out_transfer(common, bh))
+                                /* Dunno what to do if common->fsg is NULL */
                                 return -EIO;
                         common->next_buffhd_to_fill = bh->next;
                         continue;
@@ -985,30 +1010,29 @@ static int do_write(struct fsg_common *common)
                         amount = bh->outreq->actual;
                         if (curlun->file_length - file_offset < amount) {
                                 LERROR(curlun,
-        "write %u @ %llu beyond end %llu\n",
-        amount, (unsigned long long) file_offset,
-        (unsigned long long) curlun->file_length);
+                                       "write %u @ %llu beyond end %llu\n",
+                                       amount, (unsigned long long)file_offset,
+                                       (unsigned long long)curlun->file_length);
                                 amount = curlun->file_length - file_offset;
                         }
 
                         /* Perform the write */
                         file_offset_tmp = file_offset;
                         nwritten = vfs_write(curlun->filp,
-                                        (char __user *) bh->buf,
-                                        amount, &file_offset_tmp);
+                                             (char __user *)bh->buf,
+                                             amount, &file_offset_tmp);
                         VLDBG(curlun, "file write %u @ %llu -> %d\n", amount,
-                                        (unsigned long long) file_offset,
-                                        (int) nwritten);
+                              (unsigned long long)file_offset, (int)nwritten);
                         if (signal_pending(current))
                                 return -EINTR;          /* Interrupted! */
 
                         if (nwritten < 0) {
                                 LDBG(curlun, "error in file write: %d\n",
-                                                (int) nwritten);
+                                     (int)nwritten);
                                 nwritten = 0;
                         } else if (nwritten < amount) {
                                 LDBG(curlun, "partial file write: %d/%u\n",
-                                                (int) nwritten, amount);
+                                     (int)nwritten, amount);
                                 nwritten -= (nwritten & 511);
                                 /* Round down to a block */
                         }
@@ -1081,16 +1105,20 @@ static int do_verify(struct fsg_common *common)
         unsigned int            amount;
         ssize_t                 nread;
 
-        /* Get the starting Logical Block Address and check that it's
-         * not too big */
+        /*
+         * Get the starting Logical Block Address and check that it's
+         * not too big.
+         */
         lba = get_unaligned_be32(&common->cmnd[2]);
         if (lba >= curlun->num_sectors) {
                 curlun->sense_data = SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
                 return -EINVAL;
         }
 
-        /* We allow DPO (Disable Page Out = don't save data in the
-         * cache) but we don't implement it. */
+        /*
+         * We allow DPO (Disable Page Out = don't save data in the
+         * cache) but we don't implement it.
+         */
         if (common->cmnd[1] & ~0x10) {
                 curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
                 return -EINVAL;
@@ -1115,16 +1143,17 @@ static int do_verify(struct fsg_common *common)
 
         /* Just try to read the requested blocks */
         while (amount_left > 0) {
-
-                /* Figure out how much we need to read:
+                /*
+                 * Figure out how much we need to read:
                  * Try to read the remaining amount, but not more than
                  * the buffer size.
                  * And don't try to read past the end of the file.
                  * If this means reading 0 then we were asked to read
-                 * past the end of file. */
+                 * past the end of file.
+                 */
                 amount = min(amount_left, FSG_BUFLEN);
-                amount = min((loff_t) amount,
-                                curlun->file_length - file_offset);
+                amount = min((loff_t)amount,
+                             curlun->file_length - file_offset);
                 if (amount == 0) {
                         curlun->sense_data =
                                         SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
@@ -1145,13 +1174,12 @@ static int do_verify(struct fsg_common *common)
                         return -EINTR;
 
                 if (nread < 0) {
-                        LDBG(curlun, "error in file verify: %d\n",
-                                        (int) nread);
+                        LDBG(curlun, "error in file verify: %d\n", (int)nread);
                         nread = 0;
                 } else if (nread < amount) {
                         LDBG(curlun, "partial file verify: %d/%u\n",
-                                        (int) nread, amount);
-                        nread -= (nread & 511); /* Round down to a sector */
+                             (int)nread, amount);
+                        nread -= nread & 511;   /* Round down to a sector */
                 }
                 if (nread == 0) {
                         curlun->sense_data = SS_UNRECOVERED_READ_ERROR;
@@ -1181,7 +1209,7 @@ static int do_inquiry(struct fsg_common *common, struct fsg_buffhd *bh)
                 return 36;
         }
 
-        buf[0] = curlun->cdrom ? TYPE_CDROM : TYPE_DISK;
+        buf[0] = curlun->cdrom ? TYPE_ROM : TYPE_DISK;
         buf[1] = curlun->removable ? 0x80 : 0;
         buf[2] = 2;             /* ANSI SCSI level 2 */
         buf[3] = 2;             /* SCSI-2 INQUIRY data format */
@@ -1193,7 +1221,6 @@ static int do_inquiry(struct fsg_common *common, struct fsg_buffhd *bh)
         return 36;
 }
 
-
 static int do_request_sense(struct fsg_common *common, struct fsg_buffhd *bh)
 {
         struct fsg_lun  *curlun = common->curlun;
@@ -1247,13 +1274,12 @@ static int do_request_sense(struct fsg_common *common, struct fsg_buffhd *bh)
         return 18;
 }
 
-
 static int do_read_capacity(struct fsg_common *common, struct fsg_buffhd *bh)
 {
         struct fsg_lun  *curlun = common->curlun;
         u32             lba = get_unaligned_be32(&common->cmnd[2]);
         int             pmi = common->cmnd[8];
-        u8              *buf = (u8 *) bh->buf;
+        u8              *buf = (u8 *)bh->buf;
 
         /* Check the PMI and LBA fields */
         if (pmi > 1 || (pmi == 0 && lba != 0)) {
@@ -1267,13 +1293,12 @@ static int do_read_capacity(struct fsg_common *common, struct fsg_buffhd *bh)
         return 8;
 }
 
-
 static int do_read_header(struct fsg_common *common, struct fsg_buffhd *bh)
 {
         struct fsg_lun  *curlun = common->curlun;
         int             msf = common->cmnd[1] & 0x02;
         u32             lba = get_unaligned_be32(&common->cmnd[2]);
-        u8              *buf = (u8 *) bh->buf;
+        u8              *buf = (u8 *)bh->buf;
 
         if (common->cmnd[1] & ~0x02) {          /* Mask away MSF */
                 curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
@@ -1290,13 +1315,12 @@ static int do_read_header(struct fsg_common *common, struct fsg_buffhd *bh)
         return 8;
 }
 
-
 static int do_read_toc(struct fsg_common *common, struct fsg_buffhd *bh)
 {
         struct fsg_lun  *curlun = common->curlun;
         int             msf = common->cmnd[1] & 0x02;
         int             start_track = common->cmnd[6];
-        u8              *buf = (u8 *) bh->buf;
+        u8              *buf = (u8 *)bh->buf;
 
         if ((common->cmnd[1] & ~0x02) != 0 ||   /* Mask away MSF */
                         start_track > 1) {
@@ -1318,7 +1342,6 @@ static int do_read_toc(struct fsg_common *common, struct fsg_buffhd *bh)
         return 20;
 }
 
-
 static int do_mode_sense(struct fsg_common *common, struct fsg_buffhd *bh)
 {
         struct fsg_lun  *curlun = common->curlun;
@@ -1343,16 +1366,18 @@ static int do_mode_sense(struct fsg_common *common, struct fsg_buffhd *bh)
         changeable_values = (pc == 1);
         all_pages = (page_code == 0x3f);
 
-        /* Write the mode parameter header.  Fixed values are: default
+        /*
+         * Write the mode parameter header.  Fixed values are: default
          * medium type, no cache control (DPOFUA), and no block descriptors.
          * The only variable value is the WriteProtect bit.  We will fill in
-         * the mode data length later. */
+         * the mode data length later.
+         */
         memset(buf, 0, 8);
-        if (mscmnd == SC_MODE_SENSE_6) {
+        if (mscmnd == MODE_SENSE) {
                 buf[2] = (curlun->ro ? 0x80 : 0x00);            /* WP, DPOFUA */
                 buf += 4;
                 limit = 255;
-        } else {                        /* SC_MODE_SENSE_10 */
+        } else {                        /* MODE_SENSE_10 */
                 buf[3] = (curlun->ro ? 0x80 : 0x00);            /* WP, DPOFUA */
                 buf += 8;
                 limit = 65535;          /* Should really be FSG_BUFLEN */
@@ -1360,8 +1385,10 @@ static int do_mode_sense(struct fsg_common *common, struct fsg_buffhd *bh)
 
         /* No block descriptors */
 
-        /* The mode pages, in numerical order.  The only page we support
-         * is the Caching page. */
+        /*
+         * The mode pages, in numerical order.  The only page we support
+         * is the Caching page.
+         */
         if (page_code == 0x08 || all_pages) {
                 valid_page = 1;
                 buf[0] = 0x08;          /* Page code */
@@ -1383,8 +1410,10 @@ static int do_mode_sense(struct fsg_common *common, struct fsg_buffhd *bh)
                 buf += 12;
         }
 
-        /* Check that a valid page was requested and the mode data length
-         * isn't too long. */
+        /*
+         * Check that a valid page was requested and the mode data length
+         * isn't too long.
+         */
         len = buf - buf0;
         if (!valid_page || len > limit) {
                 curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
@@ -1392,14 +1421,13 @@ static int do_mode_sense(struct fsg_common *common, struct fsg_buffhd *bh)
         }
 
         /*  Store the mode data length */
-        if (mscmnd == SC_MODE_SENSE_6)
+        if (mscmnd == MODE_SENSE)
                 buf0[0] = len - 1;
         else
                 put_unaligned_be16(len - 2, buf0);
         return len;
 }
 
-
 static int do_start_stop(struct fsg_common *common)
 {
         struct fsg_lun  *curlun = common->curlun;
@@ -1419,8 +1447,10 @@ static int do_start_stop(struct fsg_common *common)
         loej  = common->cmnd[4] & 0x02;
         start = common->cmnd[4] & 0x01;
 
-        /* Our emulation doesn't support mounting; the medium is
-         * available for use as soon as it is loaded. */
+        /*
+         * Our emulation doesn't support mounting; the medium is
+         * available for use as soon as it is loaded.
+         */
         if (start) {
                 if (!fsg_lun_is_open(curlun)) {
                         curlun->sense_data = SS_MEDIUM_NOT_PRESENT;
@@ -1461,7 +1491,6 @@ static int do_start_stop(struct fsg_common *common)
                 : 0;
 }
 
-
 static int do_prevent_allow(struct fsg_common *common)
 {
         struct fsg_lun  *curlun = common->curlun;
@@ -1486,7 +1515,6 @@ static int do_prevent_allow(struct fsg_common *common)
         return 0;
 }
 
-
 static int do_read_format_capacities(struct fsg_common *common,
                         struct fsg_buffhd *bh)
 {
@@ -1504,7 +1532,6 @@ static int do_read_format_capacities(struct fsg_common *common,
         return 12;
 }
 
-
 static int do_mode_select(struct fsg_common *common, struct fsg_buffhd *bh)
 {
         struct fsg_lun  *curlun = common->curlun;
@@ -1563,37 +1590,6 @@ static int wedge_bulk_in_endpoint(struct fsg_dev *fsg)
         return rc;
 }
 
-static int pad_with_zeros(struct fsg_dev *fsg)
-{
-        struct fsg_buffhd       *bh = fsg->common->next_buffhd_to_fill;
-        u32                     nkeep = bh->inreq->length;
-        u32                     nsend;
-        int                     rc;
-
-        bh->state = BUF_STATE_EMPTY;            /* For the first iteration */
-        fsg->common->usb_amount_left = nkeep + fsg->common->residue;
-        while (fsg->common->usb_amount_left > 0) {
-
-                /* Wait for the next buffer to be free */
-                while (bh->state != BUF_STATE_EMPTY) {
-                        rc = sleep_thread(fsg->common);
-                        if (rc)
-                                return rc;
-                }
-
-                nsend = min(fsg->common->usb_amount_left, FSG_BUFLEN);
-                memset(bh->buf + nkeep, 0, nsend - nkeep);
-                bh->inreq->length = nsend;
-                bh->inreq->zero = 0;
-                start_transfer(fsg, fsg->bulk_in, bh->inreq,
-                                &bh->inreq_busy, &bh->state);
-                bh = fsg->common->next_buffhd_to_fill = bh->next;
-                fsg->common->usb_amount_left -= nsend;
-                nkeep = 0;
-        }
-        return 0;
-}
-
 static int throw_away_data(struct fsg_common *common)
 {
         struct fsg_buffhd       *bh;
@@ -1612,7 +1608,7 @@ static int throw_away_data(struct fsg_common *common)
 
                         /* A short packet or an error ends everything */
                         if (bh->outreq->actual != bh->outreq->length ||
-                                        bh->outreq->status != 0) {
+                            bh->outreq->status != 0) {
                                 raise_exception(common,
                                                 FSG_STATE_ABORT_BULK_OUT);
                                 return -EINTR;
@@ -1626,15 +1622,15 @@ static int throw_away_data(struct fsg_common *common)
                  && common->usb_amount_left > 0) {
                         amount = min(common->usb_amount_left, FSG_BUFLEN);
 
-                        /* amount is always divisible by 512, hence by
-                         * the bulk-out maxpacket size */
+                        /*
+                         * amount is always divisible by 512, hence by
+                         * the bulk-out maxpacket size.
+                         */
                         bh->outreq->length = amount;
                         bh->bulk_out_intended_length = amount;
                         bh->outreq->short_not_ok = 1;
-                        START_TRANSFER_OR(common, bulk_out, bh->outreq,
-                                          &bh->outreq_busy, &bh->state)
-                                /* Don't know what to do if
-                                 * common->fsg is NULL */
+                        if (!start_out_transfer(common, bh))
+                                /* Dunno what to do if common->fsg is NULL */
                                 return -EIO;
                         common->next_buffhd_to_fill = bh->next;
                         common->usb_amount_left -= amount;
@@ -1649,7 +1645,6 @@ static int throw_away_data(struct fsg_common *common)
         return 0;
 }
 
-
 static int finish_reply(struct fsg_common *common)
 {
         struct fsg_buffhd       *bh = common->next_buffhd_to_fill;
@@ -1659,10 +1654,12 @@ static int finish_reply(struct fsg_common *common)
         case DATA_DIR_NONE:
                 break;                  /* Nothing to send */
 
-        /* If we don't know whether the host wants to read or write,
+        /*
+         * If we don't know whether the host wants to read or write,
          * this must be CB or CBI with an unknown command.  We mustn't
          * try to send or receive any data.  So stall both bulk pipes
-         * if we can and wait for a reset. */
+         * if we can and wait for a reset.
+         */
         case DATA_DIR_UNKNOWN:
                 if (!common->can_stall) {
                         /* Nothing */
@@ -1680,37 +1677,38 @@ static int finish_reply(struct fsg_common *common)
                 if (common->data_size == 0) {
                         /* Nothing to send */
 
+                /* Don't know what to do if common->fsg is NULL */
+                } else if (!fsg_is_set(common)) {
+                        rc = -EIO;
+
                 /* If there's no residue, simply send the last buffer */
                 } else if (common->residue == 0) {
                         bh->inreq->zero = 0;
-                        START_TRANSFER_OR(common, bulk_in, bh->inreq,
-                                          &bh->inreq_busy, &bh->state)
+                        if (!start_in_transfer(common, bh))
                                 return -EIO;
                         common->next_buffhd_to_fill = bh->next;
 
-                /* For Bulk-only, if we're allowed to stall then send the
-                 * short packet and halt the bulk-in endpoint.  If we can't
-                 * stall, pad out the remaining data with 0's. */
-                } else if (common->can_stall) {
+                /*
+                 * For Bulk-only, mark the end of the data with a short
+                 * packet.  If we are allowed to stall, halt the bulk-in
+                 * endpoint.  (Note: This violates the Bulk-Only Transport
+                 * specification, which requires us to pad the data if we
+                 * don't halt the endpoint.  Presumably nobody will mind.)
+                 */
+                } else {
                         bh->inreq->zero = 1;
-                        START_TRANSFER_OR(common, bulk_in, bh->inreq,
-                                          &bh->inreq_busy, &bh->state)
-                                /* Don't know what to do if
-                                 * common->fsg is NULL */
+                        if (!start_in_transfer(common, bh))
                                 rc = -EIO;
                         common->next_buffhd_to_fill = bh->next;
-                        if (common->fsg)
+                        if (common->can_stall)
                                 rc = halt_bulk_in_endpoint(common->fsg);
-                } else if (fsg_is_set(common)) {
-                        rc = pad_with_zeros(common->fsg);
-                } else {
-                        /* Don't know what to do if common->fsg is NULL */
-                        rc = -EIO;
                 }
                 break;
 
-        /* We have processed all we want from the data the host has sent.
-         * There may still be outstanding bulk-out requests. */
+        /*
+         * We have processed all we want from the data the host has sent.
+         * There may still be outstanding bulk-out requests.
+         */
         case DATA_DIR_FROM_HOST:
                 if (common->residue == 0) {
                         /* Nothing to receive */
@@ -1720,12 +1718,14 @@ static int finish_reply(struct fsg_common *common)
                         raise_exception(common, FSG_STATE_ABORT_BULK_OUT);
                         rc = -EINTR;
 
-                /* We haven't processed all the incoming data.  Even though
+                /*
+                 * We haven't processed all the incoming data.  Even though
                  * we may be allowed to stall, doing so would cause a race.
                  * The controller may already have ACK'ed all the remaining
                  * bulk-out packets, in which case the host wouldn't see a
                  * STALL.  Not realizing the endpoint was halted, it wouldn't
-                 * clear the halt -- leading to problems later on. */
+                 * clear the halt -- leading to problems later on.
+                 */
 #if 0
                 } else if (common->can_stall) {
                         if (fsg_is_set(common))
@@ -1735,8 +1735,10 @@ static int finish_reply(struct fsg_common *common)
                         rc = -EINTR;
 #endif
 
-                /* We can't stall.  Read in the excess data and throw it
-                 * all away. */
+                /*
+                 * We can't stall.  Read in the excess data and throw it
+                 * all away.
+                 */
                 } else {
                         rc = throw_away_data(common);
                 }
@@ -1745,7 +1747,6 @@ static int finish_reply(struct fsg_common *common)
         return rc;
 }
 
-
 static int send_status(struct fsg_common *common)
 {
         struct fsg_lun          *curlun = common->curlun;
@@ -1793,8 +1794,7 @@ static int send_status(struct fsg_common *common)
 
         bh->inreq->length = USB_BULK_CS_WRAP_LEN;
         bh->inreq->zero = 0;
-        START_TRANSFER_OR(common, bulk_in, bh->inreq,
-                          &bh->inreq_busy, &bh->state)
+        if (!start_in_transfer(common, bh))
                 /* Don't know what to do if common->fsg is NULL */
                 return -EIO;
 
@@ -1805,11 +1805,13 @@ static int send_status(struct fsg_common *common)
 
 /*-------------------------------------------------------------------------*/
 
-/* Check whether the command is properly formed and whether its data size
- * and direction agree with the values we already have. */
+/*
+ * Check whether the command is properly formed and whether its data size
+ * and direction agree with the values we already have.
+ */
 static int check_command(struct fsg_common *common, int cmnd_size,
-                enum data_direction data_dir, unsigned int mask,
-                int needs_medium, const char *name)
+                         enum data_direction data_dir, unsigned int mask,
+                         int needs_medium, const char *name)
 {
         int                     i;
         int                     lun = common->cmnd[1] >> 5;
@@ -1820,19 +1822,23 @@ static int check_command(struct fsg_common *common, int cmnd_size,
         hdlen[0] = 0;
         if (common->data_dir != DATA_DIR_UNKNOWN)
                 sprintf(hdlen, ", H%c=%u", dirletter[(int) common->data_dir],
-                                common->data_size);
+                        common->data_size);
         VDBG(common, "SCSI command: %s;  Dc=%d, D%c=%u;  Hc=%d%s\n",
              name, cmnd_size, dirletter[(int) data_dir],
              common->data_size_from_cmnd, common->cmnd_size, hdlen);
 
-        /* We can't reply at all until we know the correct data direction
-         * and size. */
+        /*
+         * We can't reply at all until we know the correct data direction
+         * and size.
+         */
         if (common->data_size_from_cmnd == 0)
                 data_dir = DATA_DIR_NONE;
         if (common->data_size < common->data_size_from_cmnd) {
-                /* Host data size < Device data size is a phase error.
+                /*
+                 * Host data size < Device data size is a phase error.
                  * Carry out the command, but only transfer as much as
-                 * we are allowed. */
+                 * we are allowed.
+                 */
                 common->data_size_from_cmnd = common->data_size;
                 common->phase_error = 1;
         }
@@ -1840,8 +1846,7 @@ static int check_command(struct fsg_common *common, int cmnd_size,
         common->usb_amount_left = common->data_size;
 
         /* Conflicting data directions is a phase error */
-        if (common->data_dir != data_dir
-         && common->data_size_from_cmnd > 0) {
+        if (common->data_dir != data_dir && common->data_size_from_cmnd > 0) {
                 common->phase_error = 1;
                 return -EINVAL;
         }
@@ -1849,7 +1854,8 @@ static int check_command(struct fsg_common *common, int cmnd_size,
         /* Verify the length of the command itself */
         if (cmnd_size != common->cmnd_size) {
 
-                /* Special case workaround: There are plenty of buggy SCSI
+                /*
+                 * Special case workaround: There are plenty of buggy SCSI
                  * implementations. Many have issues with cbw->Length
                  * field passing a wrong command size. For those cases we
                  * always try to work around the problem by using the length
@@ -1878,10 +1884,10 @@ static int check_command(struct fsg_common *common, int cmnd_size,
                     common->lun, lun);
 
         /* Check the LUN */
-        if (common->lun >= 0 && common->lun < common->nluns) {
+        if (common->lun < common->nluns) {
                 curlun = &common->luns[common->lun];
                 common->curlun = curlun;
-                if (common->cmnd[0] != SC_REQUEST_SENSE) {
+                if (common->cmnd[0] != REQUEST_SENSE) {
                         curlun->sense_data = SS_NO_SENSE;
                         curlun->sense_data_info = 0;
                         curlun->info_valid = 0;
@@ -1891,20 +1897,24 @@ static int check_command(struct fsg_common *common, int cmnd_size,
                 curlun = NULL;
                 common->bad_lun_okay = 0;
 
-                /* INQUIRY and REQUEST SENSE commands are explicitly allowed
-                 * to use unsupported LUNs; all others may not. */
-                if (common->cmnd[0] != SC_INQUIRY &&
-                    common->cmnd[0] != SC_REQUEST_SENSE) {
+                /*
+                 * INQUIRY and REQUEST SENSE commands are explicitly allowed
+                 * to use unsupported LUNs; all others may not.
+                 */
+                if (common->cmnd[0] != INQUIRY &&
+                    common->cmnd[0] != REQUEST_SENSE) {
                         DBG(common, "unsupported LUN %d\n", common->lun);
                         return -EINVAL;
                 }
         }
 
-        /* If a unit attention condition exists, only INQUIRY and
-         * REQUEST SENSE commands are allowed; anything else must fail. */
+        /*
+         * If a unit attention condition exists, only INQUIRY and
+         * REQUEST SENSE commands are allowed; anything else must fail.
+         */
         if (curlun && curlun->unit_attention_data != SS_NO_SENSE &&
-                        common->cmnd[0] != SC_INQUIRY &&
-                        common->cmnd[0] != SC_REQUEST_SENSE) {
+            common->cmnd[0] != INQUIRY &&
+            common->cmnd[0] != REQUEST_SENSE) {
                 curlun->sense_data = curlun->unit_attention_data;
                 curlun->unit_attention_data = SS_NO_SENSE;
                 return -EINVAL;
@@ -1930,7 +1940,6 @@ static int check_command(struct fsg_common *common, int cmnd_size,
         return 0;
 }
 
-
 static int do_scsi_command(struct fsg_common *common)
 {
         struct fsg_buffhd       *bh;
@@ -1955,7 +1964,7 @@ static int do_scsi_command(struct fsg_common *common)
         down_read(&common->filesem);    /* We're using the backing file */
         switch (common->cmnd[0]) {
 
-        case SC_INQUIRY:
+        case INQUIRY:
                 common->data_size_from_cmnd = common->cmnd[4];
                 reply = check_command(common, 6, DATA_DIR_TO_HOST,
                                       (1<<4), 0,
@@ -1964,7 +1973,7 @@ static int do_scsi_command(struct fsg_common *common)
                         reply = do_inquiry(common, bh);
                 break;
 
-        case SC_MODE_SELECT_6:
+        case MODE_SELECT:
                 common->data_size_from_cmnd = common->cmnd[4];
                 reply = check_command(common, 6, DATA_DIR_FROM_HOST,
                                       (1<<1) | (1<<4), 0,
@@ -1973,7 +1982,7 @@ static int do_scsi_command(struct fsg_common *common)
                         reply = do_mode_select(common, bh);
                 break;
 
-        case SC_MODE_SELECT_10:
+        case MODE_SELECT_10:
                 common->data_size_from_cmnd =
                         get_unaligned_be16(&common->cmnd[7]);
                 reply = check_command(common, 10, DATA_DIR_FROM_HOST,
@@ -1983,7 +1992,7 @@ static int do_scsi_command(struct fsg_common *common)
                         reply = do_mode_select(common, bh);
                 break;
 
-        case SC_MODE_SENSE_6:
+        case MODE_SENSE:
                 common->data_size_from_cmnd = common->cmnd[4];
                 reply = check_command(common, 6, DATA_DIR_TO_HOST,
                                       (1<<1) | (1<<2) | (1<<4), 0,
@@ -1992,7 +2001,7 @@ static int do_scsi_command(struct fsg_common *common)
                         reply = do_mode_sense(common, bh);
                 break;
 
-        case SC_MODE_SENSE_10:
+        case MODE_SENSE_10:
                 common->data_size_from_cmnd =
                         get_unaligned_be16(&common->cmnd[7]);
                 reply = check_command(common, 10, DATA_DIR_TO_HOST,
@@ -2002,7 +2011,7 @@ static int do_scsi_command(struct fsg_common *common)
                         reply = do_mode_sense(common, bh);
                 break;
 
-        case SC_PREVENT_ALLOW_MEDIUM_REMOVAL:
+        case ALLOW_MEDIUM_REMOVAL:
                 common->data_size_from_cmnd = 0;
                 reply = check_command(common, 6, DATA_DIR_NONE,
                                       (1<<4), 0,
@@ -2011,7 +2020,7 @@ static int do_scsi_command(struct fsg_common *common)
                         reply = do_prevent_allow(common);
                 break;
 
-        case SC_READ_6:
+        case READ_6:
                 i = common->cmnd[4];
                 common->data_size_from_cmnd = (i == 0 ? 256 : i) << 9;
                 reply = check_command(common, 6, DATA_DIR_TO_HOST,
@@ -2021,7 +2030,7 @@ static int do_scsi_command(struct fsg_common *common)
                         reply = do_read(common);
                 break;
 
-        case SC_READ_10:
+        case READ_10:
                 common->data_size_from_cmnd =
                                 get_unaligned_be16(&common->cmnd[7]) << 9;
                 reply = check_command(common, 10, DATA_DIR_TO_HOST,
@@ -2031,7 +2040,7 @@ static int do_scsi_command(struct fsg_common *common)
                         reply = do_read(common);
                 break;
 
-        case SC_READ_12:
+        case READ_12:
                 common->data_size_from_cmnd =
                                 get_unaligned_be32(&common->cmnd[6]) << 9;
                 reply = check_command(common, 12, DATA_DIR_TO_HOST,
@@ -2041,7 +2050,7 @@ static int do_scsi_command(struct fsg_common *common)
                         reply = do_read(common);
                 break;
 
-        case SC_READ_CAPACITY:
+        case READ_CAPACITY:
                 common->data_size_from_cmnd = 8;
                 reply = check_command(common, 10, DATA_DIR_TO_HOST,
                                       (0xf<<2) | (1<<8), 1,
@@ -2050,7 +2059,7 @@ static int do_scsi_command(struct fsg_common *common)
                         reply = do_read_capacity(common, bh);
                 break;
 
-        case SC_READ_HEADER:
+        case READ_HEADER:
                 if (!common->curlun || !common->curlun->cdrom)
                         goto unknown_cmnd;
                 common->data_size_from_cmnd =
@@ -2062,7 +2071,7 @@ static int do_scsi_command(struct fsg_common *common)
                         reply = do_read_header(common, bh);
                 break;
 
-        case SC_READ_TOC:
+        case READ_TOC:
                 if (!common->curlun || !common->curlun->cdrom)
                         goto unknown_cmnd;
                 common->data_size_from_cmnd =
@@ -2074,7 +2083,7 @@ static int do_scsi_command(struct fsg_common *common)
                         reply = do_read_toc(common, bh);
                 break;
 
-        case SC_READ_FORMAT_CAPACITIES:
+        case READ_FORMAT_CAPACITIES:
                 common->data_size_from_cmnd =
                         get_unaligned_be16(&common->cmnd[7]);
                 reply = check_command(common, 10, DATA_DIR_TO_HOST,
@@ -2084,7 +2093,7 @@ static int do_scsi_command(struct fsg_common *common)
                         reply = do_read_format_capacities(common, bh);
                 break;
 
-        case SC_REQUEST_SENSE:
+        case REQUEST_SENSE:
                 common->data_size_from_cmnd = common->cmnd[4];
                 reply = check_command(common, 6, DATA_DIR_TO_HOST,
                                       (1<<4), 0,
@@ -2093,7 +2102,7 @@ static int do_scsi_command(struct fsg_common *common)
                         reply = do_request_sense(common, bh);
                 break;
 
-        case SC_START_STOP_UNIT:
+        case START_STOP:
                 common->data_size_from_cmnd = 0;
                 reply = check_command(common, 6, DATA_DIR_NONE,
                                       (1<<1) | (1<<4), 0,
@@ -2102,7 +2111,7 @@ static int do_scsi_command(struct fsg_common *common)
                         reply = do_start_stop(common);
                 break;
 
-        case SC_SYNCHRONIZE_CACHE:
+        case SYNCHRONIZE_CACHE:
                 common->data_size_from_cmnd = 0;
                 reply = check_command(common, 10, DATA_DIR_NONE,
                                       (0xf<<2) | (3<<7), 1,
@@ -2111,16 +2120,18 @@ static int do_scsi_command(struct fsg_common *common)
                         reply = do_synchronize_cache(common);
                 break;
 
-        case SC_TEST_UNIT_READY:
+        case TEST_UNIT_READY:
                 common->data_size_from_cmnd = 0;
                 reply = check_command(common, 6, DATA_DIR_NONE,
                                 0, 1,
                                 "TEST UNIT READY");
                 break;
 
-        /* Although optional, this command is used by MS-Windows.  We
-         * support a minimal version: BytChk must be 0. */
-        case SC_VERIFY:
+        /*
+         * Although optional, this command is used by MS-Windows.  We
+         * support a minimal version: BytChk must be 0.
+         */
+        case VERIFY:
                 common->data_size_from_cmnd = 0;
                 reply = check_command(common, 10, DATA_DIR_NONE,
                                       (1<<1) | (0xf<<2) | (3<<7), 1,
@@ -2129,7 +2140,7 @@ static int do_scsi_command(struct fsg_common *common)
                         reply = do_verify(common);
                 break;
 
-        case SC_WRITE_6:
+        case WRITE_6:
                 i = common->cmnd[4];
                 common->data_size_from_cmnd = (i == 0 ? 256 : i) << 9;
                 reply = check_command(common, 6, DATA_DIR_FROM_HOST,
@@ -2139,7 +2150,7 @@ static int do_scsi_command(struct fsg_common *common)
                         reply = do_write(common);
                 break;
 
-        case SC_WRITE_10:
+        case WRITE_10:
                 common->data_size_from_cmnd =
                                 get_unaligned_be16(&common->cmnd[7]) << 9;
                 reply = check_command(common, 10, DATA_DIR_FROM_HOST,
@@ -2149,7 +2160,7 @@ static int do_scsi_command(struct fsg_common *common)
                         reply = do_write(common);
                 break;
 
-        case SC_WRITE_12:
+        case WRITE_12:
                 common->data_size_from_cmnd =
                                 get_unaligned_be32(&common->cmnd[6]) << 9;
                 reply = check_command(common, 12, DATA_DIR_FROM_HOST,
@@ -2159,14 +2170,16 @@ static int do_scsi_command(struct fsg_common *common)
                         reply = do_write(common);
                 break;
 
-        /* Some mandatory commands that we recognize but don't implement.
+        /*
+         * Some mandatory commands that we recognize but don't implement.
          * They don't mean much in this setting.  It's left as an exercise
          * for anyone interested to implement RESERVE and RELEASE in terms
-         * of Posix locks. */
-        case SC_FORMAT_UNIT:
-        case SC_RELEASE:
-        case SC_RESERVE:
-        case SC_SEND_DIAGNOSTIC:
+         * of Posix locks.
+         */
+        case FORMAT_UNIT:
+        case RELEASE:
+        case RESERVE:
+        case SEND_DIAGNOSTIC:
                 /* Fall through */
 
         default:
@@ -2190,7 +2203,7 @@ unknown_cmnd:
         if (reply == -EINVAL)
                 reply = 0;              /* Error reply length */
         if (reply >= 0 && common->data_dir == DATA_DIR_TO_HOST) {
-                reply = min((u32) reply, common->data_size_from_cmnd);
+                reply = min((u32)reply, common->data_size_from_cmnd);
                 bh->inreq->length = reply;
                 bh->state = BUF_STATE_FULL;
                 common->residue -= reply;
@@ -2220,7 +2233,8 @@ static int received_cbw(struct fsg_dev *fsg, struct fsg_buffhd *bh)
                                 req->actual,
                                 le32_to_cpu(cbw->Signature));
 
-                /* The Bulk-only spec says we MUST stall the IN endpoint
+                /*
+                 * The Bulk-only spec says we MUST stall the IN endpoint
                  * (6.6.1), so it's unavoidable.  It also says we must
                  * retain this state until the next reset, but there's
                  * no way to tell the controller driver it should ignore
@@ -2228,7 +2242,8 @@ static int received_cbw(struct fsg_dev *fsg, struct fsg_buffhd *bh)
                  *
                  * We aren't required to halt the OUT endpoint; instead
                  * we can simply accept and discard any data received
-                 * until the next reset. */
+                 * until the next reset.
+                 */
                 wedge_bulk_in_endpoint(fsg);
                 set_bit(IGNORE_BULK_OUT, &fsg->atomic_bitflags);
                 return -EINVAL;
@@ -2241,8 +2256,10 @@ static int received_cbw(struct fsg_dev *fsg, struct fsg_buffhd *bh)
                                 "cmdlen %u\n",
                                 cbw->Lun, cbw->Flags, cbw->Length);
 
-                /* We can do anything we want here, so let's stall the
-                 * bulk pipes if we are allowed to. */
+                /*
+                 * We can do anything we want here, so let's stall the
+                 * bulk pipes if we are allowed to.
+                 */
                 if (common->can_stall) {
                         fsg_set_halt(fsg, fsg->bulk_out);
                         halt_bulk_in_endpoint(fsg);
@@ -2265,7 +2282,6 @@ static int received_cbw(struct fsg_dev *fsg, struct fsg_buffhd *bh)
         return 0;
 }
 
-
 static int get_next_command(struct fsg_common *common)
 {
         struct fsg_buffhd       *bh;
@@ -2282,14 +2298,15 @@ static int get_next_command(struct fsg_common *common)
         /* Queue a request to read a Bulk-only CBW */
         set_bulk_out_req_length(common, bh, USB_BULK_CB_WRAP_LEN);
         bh->outreq->short_not_ok = 1;
-        START_TRANSFER_OR(common, bulk_out, bh->outreq,
-                          &bh->outreq_busy, &bh->state)
+        if (!start_out_transfer(common, bh))
                 /* Don't know what to do if common->fsg is NULL */
                 return -EIO;
 
-        /* We will drain the buffer in software, which means we
+        /*
+         * We will drain the buffer in software, which means we
          * can reuse it for the next filling.  No need to advance
-         * next_buffhd_to_fill. */
+         * next_buffhd_to_fill.
+         */
 
         /* Wait for the CBW to arrive */
         while (bh->state != BUF_STATE_FULL) {
@@ -2420,13 +2437,12 @@ reset:
 
 /****************************** ALT CONFIGS ******************************/
 
-
 static int fsg_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
 {
         struct fsg_dev *fsg = fsg_from_func(f);
         fsg->common->new_fsg = fsg;
         raise_exception(fsg->common, FSG_STATE_CONFIG_CHANGE);
-        return 0;
+        return USB_GADGET_DELAYED_STATUS;
 }
 
 static void fsg_disable(struct usb_function *f)
@@ -2448,8 +2464,10 @@ static void handle_exception(struct fsg_common *common)
         struct fsg_lun          *curlun;
         unsigned int            exception_req_tag;
 
-        /* Clear the existing signals.  Anything but SIGUSR1 is converted
-         * into a high-priority EXIT exception. */
+        /*
+         * Clear the existing signals.  Anything but SIGUSR1 is converted
+         * into a high-priority EXIT exception.
+         */
         for (;;) {
                 int sig =
                         dequeue_signal_lock(current, &current->blocked, &info);
@@ -2493,8 +2511,10 @@ static void handle_exception(struct fsg_common *common)
                         usb_ep_fifo_flush(common->fsg->bulk_out);
         }
 
-        /* Reset the I/O buffer states and pointers, the SCSI
-         * state, and the exception.  Then invoke the handler. */
+        /*
+         * Reset the I/O buffer states and pointers, the SCSI
+         * state, and the exception.  Then invoke the handler.
+         */
         spin_lock_irq(&common->lock);
 
         for (i = 0; i < FSG_NUM_BUFFERS; ++i) {
@@ -2532,9 +2552,11 @@ static void handle_exception(struct fsg_common *common)
                 break;
 
         case FSG_STATE_RESET:
-                /* In case we were forced against our will to halt a
+                /*
+                 * In case we were forced against our will to halt a
                  * bulk endpoint, clear the halt now.  (The SuperH UDC
-                 * requires this.) */
+                 * requires this.)
+                 */
                 if (!fsg_is_set(common))
                         break;
                 if (test_and_clear_bit(IGNORE_BULK_OUT,
@@ -2544,9 +2566,11 @@ static void handle_exception(struct fsg_common *common)
                 if (common->ep0_req_tag == exception_req_tag)
                         ep0_queue(common);      /* Complete the status stage */
 
-                /* Technically this should go here, but it would only be
+                /*
+                 * Technically this should go here, but it would only be
                  * a waste of time.  Ditto for the INTERFACE_CHANGE and
-                 * CONFIG_CHANGE cases. */
+                 * CONFIG_CHANGE cases.
+                 */
                 /* for (i = 0; i < common->nluns; ++i) */
                 /*      common->luns[i].unit_attention_data = */
                 /*              SS_RESET_OCCURRED;  */
@@ -2554,6 +2578,8 @@ static void handle_exception(struct fsg_common *common)
 
         case FSG_STATE_CONFIG_CHANGE:
                 do_set_interface(common, common->new_fsg);
+                if (common->new_fsg)
+                        usb_composite_setup_continue(common->cdev);
                 break;
 
         case FSG_STATE_EXIT:
@@ -2581,8 +2607,10 @@ static int fsg_main_thread(void *common_)
 {
         struct fsg_common       *common = common_;
 
-        /* Allow the thread to be killed by a signal, but set the signal mask
-         * to block everything but INT, TERM, KILL, and USR1. */
+        /*
+         * Allow the thread to be killed by a signal, but set the signal mask
+         * to block everything but INT, TERM, KILL, and USR1.
+         */
         allow_signal(SIGINT);
         allow_signal(SIGTERM);
         allow_signal(SIGKILL);
@@ -2591,9 +2619,11 @@ static int fsg_main_thread(void *common_)
         /* Allow the thread to be frozen */
         set_freezable();
 
-        /* Arrange for userspace references to be interpreted as kernel
+        /*
+         * Arrange for userspace references to be interpreted as kernel
          * pointers.  That way we can pass a kernel pointer to a routine
-         * that expects a __user pointer and it will work okay. */
+         * that expects a __user pointer and it will work okay.
+         */
         set_fs(get_ds());
 
         /* The main loop */
@@ -2653,7 +2683,7 @@ static int fsg_main_thread(void *common_)
                 up_write(&common->filesem);
         }
 
-        /* Let the unbind and cleanup routines know the thread has exited */
+        /* Let fsg_unbind() know the thread has exited */
         complete_and_exit(&common->thread_notifier, 0);
 }
 
@@ -2662,6 +2692,7 @@ static int fsg_main_thread(void *common_)
 
 /* Write permission is checked per LUN in store_*() functions. */
 static DEVICE_ATTR(ro, 0644, fsg_show_ro, fsg_store_ro);
+static DEVICE_ATTR(nofua, 0644, fsg_show_nofua, fsg_store_nofua);
 static DEVICE_ATTR(file, 0644, fsg_show_file, fsg_store_file);
 
 
@@ -2684,7 +2715,6 @@ static inline void fsg_common_put(struct fsg_common *common)
         kref_put(&common->ref, fsg_common_release);
 }
 
-
 static struct fsg_common *fsg_common_init(struct fsg_common *common,
                                           struct usb_composite_dev *cdev,
                                           struct fsg_config *cfg)
@@ -2710,7 +2740,7 @@ static struct fsg_common *fsg_common_init(struct fsg_common *common,
                         return ERR_PTR(-ENOMEM);
                 common->free_storage_on_release = 1;
         } else {
-                memset(common, 0, sizeof common);
+                memset(common, 0, sizeof *common);
                 common->free_storage_on_release = 0;
         }
 
@@ -2720,6 +2750,7 @@ static struct fsg_common *fsg_common_init(struct fsg_common *common,
         common->gadget = gadget;
         common->ep0 = gadget->ep0;
         common->ep0req = cdev->req;
+        common->cdev = cdev;
 
         /* Maybe allocate device-global string IDs, and patch descriptors */
         if (fsg_strings[FSG_STRING_INTERFACE].id == 0) {
@@ -2730,8 +2761,10 @@ static struct fsg_common *fsg_common_init(struct fsg_common *common,
                 fsg_intf_desc.iInterface = rc;
         }
 
-        /* Create the LUNs, open their backing files, and register the
-         * LUN devices in sysfs. */
+        /*
+         * Create the LUNs, open their backing files, and register the
+         * LUN devices in sysfs.
+         */
         curlun = kzalloc(nluns * sizeof *curlun, GFP_KERNEL);
         if (unlikely(!curlun)) {
                 rc = -ENOMEM;
@@ -2744,6 +2777,7 @@ static struct fsg_common *fsg_common_init(struct fsg_common *common,
         for (i = 0, lcfg = cfg->luns; i < nluns; ++i, ++curlun, ++lcfg) {
                 curlun->cdrom = !!lcfg->cdrom;
                 curlun->ro = lcfg->cdrom || lcfg->ro;
+                curlun->initially_ro = curlun->ro;
                 curlun->removable = lcfg->removable;
                 curlun->dev.release = fsg_lun_release;
                 curlun->dev.parent = &gadget->dev;
@@ -2759,6 +2793,7 @@ static struct fsg_common *fsg_common_init(struct fsg_common *common,
                 if (rc) {
                         INFO(common, "failed to register LUN%d: %d\n", i, rc);
                         common->nluns = i;
+                        put_device(&curlun->dev);
                         goto error_release;
                 }
 
@@ -2768,6 +2803,9 @@ static struct fsg_common *fsg_common_init(struct fsg_common *common,
                 rc = device_create_file(&curlun->dev, &dev_attr_file);
                 if (rc)
                         goto error_luns;
+                rc = device_create_file(&curlun->dev, &dev_attr_nofua);
+                if (rc)
+                        goto error_luns;
 
                 if (lcfg->filename) {
                         rc = fsg_lun_open(curlun, lcfg->filename);
@@ -2781,7 +2819,6 @@ static struct fsg_common *fsg_common_init(struct fsg_common *common,
         }
         common->nluns = nluns;
 
-
         /* Data buffers cyclic list */
         bh = common->buffhds;
         i = FSG_NUM_BUFFERS;
@@ -2798,7 +2835,6 @@ buffhds_first_it:
         } while (--i);
         bh->next = common->buffhds;
 
-
         /* Prepare inquiryString */
         if (cfg->release != 0xffff) {
                 i = cfg->release;
@@ -2812,41 +2848,35 @@ buffhds_first_it:
                         i = 0x0399;
                 }
         }
-#define OR(x, y) ((x) ? (x) : (y))
         snprintf(common->inquiry_string, sizeof common->inquiry_string,
-                 "%-8s%-16s%04x",
-                 OR(cfg->vendor_name, "Linux   "),
+                 "%-8s%-16s%04x", cfg->vendor_name ?: "Linux",
                  /* Assume product name dependent on the first LUN */
-                 OR(cfg->product_name, common->luns->cdrom
+                 cfg->product_name ?: (common->luns->cdrom
                                      ? "File-Stor Gadget"
-                                     : "File-CD Gadget  "),
+                                     : "File-CD Gadget"),
                  i);
 
-
-        /* Some peripheral controllers are known not to be able to
+        /*
+         * Some peripheral controllers are known not to be able to
          * halt bulk endpoints correctly.  If one of them is present,
          * disable stalls.
          */
         common->can_stall = cfg->can_stall &&
                 !(gadget_is_at91(common->gadget));
 
-
         spin_lock_init(&common->lock);
         kref_init(&common->ref);
 
-
         /* Tell the thread to start working */
         common->thread_task =
                 kthread_create(fsg_main_thread, common,
-                               OR(cfg->thread_name, "file-storage"));
+                               cfg->thread_name ?: "file-storage");
         if (IS_ERR(common->thread_task)) {
                 rc = PTR_ERR(common->thread_task);
                 goto error_release;
         }
         init_completion(&common->thread_notifier);
         init_waitqueue_head(&common->fsg_wait);
-#undef OR
-
 
         /* Information */
         INFO(common, FSG_DRIVER_DESC ", version: " FSG_DRIVER_VERSION "\n");
@@ -2880,18 +2910,15 @@ buffhds_first_it:
 
         return common;
 
-
 error_luns:
         common->nluns = i + 1;
 error_release:
         common->state = FSG_STATE_TERMINATED;   /* The thread is dead */
-        /* Call fsg_common_release() directly, ref might be not
-         * initialised */
+        /* Call fsg_common_release() directly, ref might be not initialised. */
         fsg_common_release(&common->ref);
         return ERR_PTR(rc);
 }
 
-
 static void fsg_common_release(struct kref *ref)
 {
         struct fsg_common *common = container_of(ref, struct fsg_common, ref);
@@ -2900,9 +2927,6 @@ static void fsg_common_release(struct kref *ref)
         if (common->state != FSG_STATE_TERMINATED) {
                 raise_exception(common, FSG_STATE_EXIT);
                 wait_for_completion(&common->thread_notifier);
-
-                /* The cleanup routine waits for this completion also */
-                complete(&common->thread_notifier);
         }
 
         if (likely(common->luns)) {
@@ -2911,6 +2935,7 @@ static void fsg_common_release(struct kref *ref)
 
                 /* In error recovery common->nluns may be zero. */
                 for (; i; --i, ++lun) {
+                        device_remove_file(&lun->dev, &dev_attr_nofua);
                         device_remove_file(&lun->dev, &dev_attr_ro);
                         device_remove_file(&lun->dev, &dev_attr_file);
                         fsg_lun_close(lun);
@@ -2935,7 +2960,6 @@ static void fsg_common_release(struct kref *ref)
 
 /*-------------------------------------------------------------------------*/
 
-
 static void fsg_unbind(struct usb_configuration *c, struct usb_function *f)
 {
         struct fsg_dev          *fsg = fsg_from_func(f);
@@ -2955,7 +2979,6 @@ static void fsg_unbind(struct usb_configuration *c, struct usb_function *f)
         kfree(fsg);
 }
 
-
 static int fsg_bind(struct usb_configuration *c, struct usb_function *f)
 {
         struct fsg_dev          *fsg = fsg_from_func(f);
@@ -3038,11 +3061,13 @@ static int fsg_bind_config(struct usb_composite_dev *cdev,
         fsg->function.disable     = fsg_disable;
 
         fsg->common               = common;
-        /* Our caller holds a reference to common structure so we
+        /*
+         * Our caller holds a reference to common structure so we
          * don't have to be worry about it being freed until we return
          * from this function.  So instead of incrementing counter now
          * and decrement in error recovery we increment it only when
-         * call to usb_add_function() was successful. */
+         * call to usb_add_function() was successful.
+         */
 
         rc = usb_add_function(c, &fsg->function);
         if (unlikely(rc))
@@ -3053,8 +3078,7 @@ static int fsg_bind_config(struct usb_composite_dev *cdev,
 }
 
 static inline int __deprecated __maybe_unused
-fsg_add(struct usb_composite_dev *cdev,
-        struct usb_configuration *c,
+fsg_add(struct usb_composite_dev *cdev, struct usb_configuration *c,
         struct fsg_common *common)
 {
         return fsg_bind_config(cdev, c, common);
@@ -3063,19 +3087,19 @@ fsg_add(struct usb_composite_dev *cdev,
 
 /************************* Module parameters *************************/
 
-
 struct fsg_module_parameters {
         char            *file[FSG_MAX_LUNS];
         int             ro[FSG_MAX_LUNS];
         int             removable[FSG_MAX_LUNS];
         int             cdrom[FSG_MAX_LUNS];
+        int             nofua[FSG_MAX_LUNS];
 
         unsigned int    file_count, ro_count, removable_count, cdrom_count;
+        unsigned int    nofua_count;
         unsigned int    luns;   /* nluns */
         int             stall;  /* can_stall */
 };
 
-
 #define _FSG_MODULE_PARAM_ARRAY(prefix, params, name, type, desc)       \
         module_param_array_named(prefix ## name, params.name, type,     \
                                  &prefix ## params.name ## _count,      \
@@ -3096,12 +3120,13 @@ struct fsg_module_parameters {
                                 "true to simulate removable media");    \
         _FSG_MODULE_PARAM_ARRAY(prefix, params, cdrom, bool,            \
                                 "true to simulate CD-ROM instead of disk"); \
+        _FSG_MODULE_PARAM_ARRAY(prefix, params, nofua, bool,            \
+                                "true to ignore SCSI WRITE(10,12) FUA bit"); \
         _FSG_MODULE_PARAM(prefix, params, luns, uint,                   \
                           "number of LUNs");                            \
         _FSG_MODULE_PARAM(prefix, params, stall, bool,                  \
                           "false to prevent bulk stalls")
 
-
 static void
 fsg_config_from_params(struct fsg_config *cfg,
                        const struct fsg_module_parameters *params)
diff --git a/drivers/usb/gadget/f_ncm.c b/drivers/usb/gadget/f_ncm.c
new file mode 100644
index 000000000000..86902a60bcdb
--- /dev/null
+++ b/drivers/usb/gadget/f_ncm.c
@@ -0,0 +1,1407 @@
+/*
+ * f_ncm.c -- USB CDC Network (NCM) link function driver
+ *
+ * Copyright (C) 2010 Nokia Corporation
+ * Contact: Yauheni Kaliuta <yauheni.kaliuta@nokia.com>
+ *
+ * The driver borrows from f_ecm.c which is:
+ *
+ * Copyright (C) 2003-2005,2008 David Brownell
+ * Copyright (C) 2008 Nokia Corporation
+ *
+ * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include <linux/kernel.h>
+#include <linux/device.h>
+#include <linux/etherdevice.h>
+#include <linux/crc32.h>
+
+#include <linux/usb/cdc.h>
+
+#include "u_ether.h"
+
+/*
+ * This function is a "CDC Network Control Model" (CDC NCM) Ethernet link.
+ * NCM is intended to be used with high-speed network attachments.
+ *
+ * Note that NCM requires the use of "alternate settings" for its data
+ * interface.  This means that the set_alt() method has real work to do,
+ * and also means that a get_alt() method is required.
+ */
+
+/* to trigger crc/non-crc ndp signature */
+
+#define NCM_NDP_HDR_CRC_MASK    0x01000000
+#define NCM_NDP_HDR_CRC         0x01000000
+#define NCM_NDP_HDR_NOCRC       0x00000000
+
+struct ncm_ep_descs {
+        struct usb_endpoint_descriptor  *in;
+        struct usb_endpoint_descriptor  *out;
+        struct usb_endpoint_descriptor  *notify;
+};
+
+enum ncm_notify_state {
+        NCM_NOTIFY_NONE,                /* don't notify */
+        NCM_NOTIFY_CONNECT,             /* issue CONNECT next */
+        NCM_NOTIFY_SPEED,               /* issue SPEED_CHANGE next */
+};
+
+struct f_ncm {
+        struct gether                   port;
+        u8                              ctrl_id, data_id;
+
+        char                            ethaddr[14];
+
+        struct ncm_ep_descs             fs;
+        struct ncm_ep_descs             hs;
+
+        struct usb_ep                   *notify;
+        struct usb_endpoint_descriptor  *notify_desc;
+        struct usb_request              *notify_req;
+        u8                              notify_state;
+        bool                            is_open;
+
+        struct ndp_parser_opts          *parser_opts;
+        bool                            is_crc;
+
+        /*
+         * for notification, it is accessed from both
+         * callback and ethernet open/close
+         */
+        spinlock_t                      lock;
+};
+
+static inline struct f_ncm *func_to_ncm(struct usb_function *f)
+{
+        return container_of(f, struct f_ncm, port.func);
+}
+
+/* peak (theoretical) bulk transfer rate in bits-per-second */
+static inline unsigned ncm_bitrate(struct usb_gadget *g)
+{
+        if (gadget_is_dualspeed(g) && g->speed == USB_SPEED_HIGH)
+                return 13 * 512 * 8 * 1000 * 8;
+        else
+                return 19 *  64 * 1 * 1000 * 8;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/*
+ * We cannot group frames so use just the minimal size which ok to put
+ * one max-size ethernet frame.
+ * If the host can group frames, allow it to do that, 16K is selected,
+ * because it's used by default by the current linux host driver
+ */
+#define NTB_DEFAULT_IN_SIZE     USB_CDC_NCM_NTB_MIN_IN_SIZE
+#define NTB_OUT_SIZE            16384
+
+/*
+ * skbs of size less than that will not be aligned
+ * to NCM's dwNtbInMaxSize to save bus bandwidth
+ */
+
+#define MAX_TX_NONFIXED         (512 * 3)
+
+#define FORMATS_SUPPORTED       (USB_CDC_NCM_NTB16_SUPPORTED |  \
+                                 USB_CDC_NCM_NTB32_SUPPORTED)
+
+static struct usb_cdc_ncm_ntb_parameters ntb_parameters = {
+        .wLength = sizeof ntb_parameters,
+        .bmNtbFormatsSupported = cpu_to_le16(FORMATS_SUPPORTED),
+        .dwNtbInMaxSize = cpu_to_le32(NTB_DEFAULT_IN_SIZE),
+        .wNdpInDivisor = cpu_to_le16(4),
+        .wNdpInPayloadRemainder = cpu_to_le16(0),
+        .wNdpInAlignment = cpu_to_le16(4),
+
+        .dwNtbOutMaxSize = cpu_to_le32(NTB_OUT_SIZE),
+        .wNdpOutDivisor = cpu_to_le16(4),
+        .wNdpOutPayloadRemainder = cpu_to_le16(0),
+        .wNdpOutAlignment = cpu_to_le16(4),
+};
+
+/*
+ * Use wMaxPacketSize big enough to fit CDC_NOTIFY_SPEED_CHANGE in one
+ * packet, to simplify cancellation; and a big transfer interval, to
+ * waste less bandwidth.
+ */
+
+#define LOG2_STATUS_INTERVAL_MSEC       5       /* 1 << 5 == 32 msec */
+#define NCM_STATUS_BYTECOUNT            16      /* 8 byte header + data */
+
+static struct usb_interface_assoc_descriptor ncm_iad_desc __initdata = {
+        .bLength =              sizeof ncm_iad_desc,
+        .bDescriptorType =      USB_DT_INTERFACE_ASSOCIATION,
+
+        /* .bFirstInterface =   DYNAMIC, */
+        .bInterfaceCount =      2,      /* control + data */
+        .bFunctionClass =       USB_CLASS_COMM,
+        .bFunctionSubClass =    USB_CDC_SUBCLASS_NCM,
+        .bFunctionProtocol =    USB_CDC_PROTO_NONE,
+        /* .iFunction =         DYNAMIC */
+};
+
+/* interface descriptor: */
+
+static struct usb_interface_descriptor ncm_control_intf __initdata = {
+        .bLength =              sizeof ncm_control_intf,
+        .bDescriptorType =      USB_DT_INTERFACE,
+
+        /* .bInterfaceNumber = DYNAMIC */
+        .bNumEndpoints =        1,
+        .bInterfaceClass =      USB_CLASS_COMM,
+        .bInterfaceSubClass =   USB_CDC_SUBCLASS_NCM,
+        .bInterfaceProtocol =   USB_CDC_PROTO_NONE,
+        /* .iInterface = DYNAMIC */
+};
+
+static struct usb_cdc_header_desc ncm_header_desc __initdata = {
+        .bLength =              sizeof ncm_header_desc,
+        .bDescriptorType =      USB_DT_CS_INTERFACE,
+        .bDescriptorSubType =   USB_CDC_HEADER_TYPE,
+
+        .bcdCDC =               cpu_to_le16(0x0110),
+};
+
+static struct usb_cdc_union_desc ncm_union_desc __initdata = {
+        .bLength =              sizeof(ncm_union_desc),
+        .bDescriptorType =      USB_DT_CS_INTERFACE,
+        .bDescriptorSubType =   USB_CDC_UNION_TYPE,
+        /* .bMasterInterface0 = DYNAMIC */
+        /* .bSlaveInterface0 =  DYNAMIC */
+};
+
+static struct usb_cdc_ether_desc ecm_desc __initdata = {
+        .bLength =              sizeof ecm_desc,
+        .bDescriptorType =      USB_DT_CS_INTERFACE,
+        .bDescriptorSubType =   USB_CDC_ETHERNET_TYPE,
+
+        /* this descriptor actually adds value, surprise! */
+        /* .iMACAddress = DYNAMIC */
+        .bmEthernetStatistics = cpu_to_le32(0), /* no statistics */
+        .wMaxSegmentSize =      cpu_to_le16(ETH_FRAME_LEN),
+        .wNumberMCFilters =     cpu_to_le16(0),
+        .bNumberPowerFilters =  0,
+};
+
+#define NCAPS   (USB_CDC_NCM_NCAP_ETH_FILTER | USB_CDC_NCM_NCAP_CRC_MODE)
+
+static struct usb_cdc_ncm_desc ncm_desc __initdata = {
+        .bLength =              sizeof ncm_desc,
+        .bDescriptorType =      USB_DT_CS_INTERFACE,
+        .bDescriptorSubType =   USB_CDC_NCM_TYPE,
+
+        .bcdNcmVersion =        cpu_to_le16(0x0100),
+        /* can process SetEthernetPacketFilter */
+        .bmNetworkCapabilities = NCAPS,
+};
+
+/* the default data interface has no endpoints ... */
+
+static struct usb_interface_descriptor ncm_data_nop_intf __initdata = {
+        .bLength =              sizeof ncm_data_nop_intf,
+        .bDescriptorType =      USB_DT_INTERFACE,
+
+        .bInterfaceNumber =     1,
+        .bAlternateSetting =    0,
+        .bNumEndpoints =        0,
+        .bInterfaceClass =      USB_CLASS_CDC_DATA,
+        .bInterfaceSubClass =   0,
+        .bInterfaceProtocol =   USB_CDC_NCM_PROTO_NTB,
+        /* .iInterface = DYNAMIC */
+};
+
+/* ... but the "real" data interface has two bulk endpoints */
+
+static struct usb_interface_descriptor ncm_data_intf __initdata = {
+        .bLength =              sizeof ncm_data_intf,
+        .bDescriptorType =      USB_DT_INTERFACE,
+
+        .bInterfaceNumber =     1,
+        .bAlternateSetting =    1,
+        .bNumEndpoints =        2,
+        .bInterfaceClass =      USB_CLASS_CDC_DATA,
+        .bInterfaceSubClass =   0,
+        .bInterfaceProtocol =   USB_CDC_NCM_PROTO_NTB,
+        /* .iInterface = DYNAMIC */
+};
+
+/* full speed support: */
+
+static struct usb_endpoint_descriptor fs_ncm_notify_desc __initdata = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bEndpointAddress =     USB_DIR_IN,
+        .bmAttributes =         USB_ENDPOINT_XFER_INT,
+        .wMaxPacketSize =       cpu_to_le16(NCM_STATUS_BYTECOUNT),
+        .bInterval =            1 << LOG2_STATUS_INTERVAL_MSEC,
+};
+
+static struct usb_endpoint_descriptor fs_ncm_in_desc __initdata = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bEndpointAddress =     USB_DIR_IN,
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+};
+
+static struct usb_endpoint_descriptor fs_ncm_out_desc __initdata = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bEndpointAddress =     USB_DIR_OUT,
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+};
+
+static struct usb_descriptor_header *ncm_fs_function[] __initdata = {
+        (struct usb_descriptor_header *) &ncm_iad_desc,
+        /* CDC NCM control descriptors */
+        (struct usb_descriptor_header *) &ncm_control_intf,
+        (struct usb_descriptor_header *) &ncm_header_desc,
+        (struct usb_descriptor_header *) &ncm_union_desc,
+        (struct usb_descriptor_header *) &ecm_desc,
+        (struct usb_descriptor_header *) &ncm_desc,
+        (struct usb_descriptor_header *) &fs_ncm_notify_desc,
+        /* data interface, altsettings 0 and 1 */
+        (struct usb_descriptor_header *) &ncm_data_nop_intf,
+        (struct usb_descriptor_header *) &ncm_data_intf,
+        (struct usb_descriptor_header *) &fs_ncm_in_desc,
+        (struct usb_descriptor_header *) &fs_ncm_out_desc,
+        NULL,
+};
+
+/* high speed support: */
+
+static struct usb_endpoint_descriptor hs_ncm_notify_desc __initdata = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bEndpointAddress =     USB_DIR_IN,
+        .bmAttributes =         USB_ENDPOINT_XFER_INT,
+        .wMaxPacketSize =       cpu_to_le16(NCM_STATUS_BYTECOUNT),
+        .bInterval =            LOG2_STATUS_INTERVAL_MSEC + 4,
+};
+static struct usb_endpoint_descriptor hs_ncm_in_desc __initdata = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bEndpointAddress =     USB_DIR_IN,
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+        .wMaxPacketSize =       cpu_to_le16(512),
+};
+
+static struct usb_endpoint_descriptor hs_ncm_out_desc __initdata = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bEndpointAddress =     USB_DIR_OUT,
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+        .wMaxPacketSize =       cpu_to_le16(512),
+};
+
+static struct usb_descriptor_header *ncm_hs_function[] __initdata = {
+        (struct usb_descriptor_header *) &ncm_iad_desc,
+        /* CDC NCM control descriptors */
+        (struct usb_descriptor_header *) &ncm_control_intf,
+        (struct usb_descriptor_header *) &ncm_header_desc,
+        (struct usb_descriptor_header *) &ncm_union_desc,
+        (struct usb_descriptor_header *) &ecm_desc,
+        (struct usb_descriptor_header *) &ncm_desc,
+        (struct usb_descriptor_header *) &hs_ncm_notify_desc,
+        /* data interface, altsettings 0 and 1 */
+        (struct usb_descriptor_header *) &ncm_data_nop_intf,
+        (struct usb_descriptor_header *) &ncm_data_intf,
+        (struct usb_descriptor_header *) &hs_ncm_in_desc,
+        (struct usb_descriptor_header *) &hs_ncm_out_desc,
+        NULL,
+};
+
+/* string descriptors: */
+
+#define STRING_CTRL_IDX 0
+#define STRING_MAC_IDX  1
+#define STRING_DATA_IDX 2
+#define STRING_IAD_IDX  3
+
+static struct usb_string ncm_string_defs[] = {
+        [STRING_CTRL_IDX].s = "CDC Network Control Model (NCM)",
+        [STRING_MAC_IDX].s = NULL /* DYNAMIC */,
+        [STRING_DATA_IDX].s = "CDC Network Data",
+        [STRING_IAD_IDX].s = "CDC NCM",
+        {  } /* end of list */
+};
+
+static struct usb_gadget_strings ncm_string_table = {
+        .language =             0x0409, /* en-us */
+        .strings =              ncm_string_defs,
+};
+
+static struct usb_gadget_strings *ncm_strings[] = {
+        &ncm_string_table,
+        NULL,
+};
+
+/*
+ * Here are options for NCM Datagram Pointer table (NDP) parser.
+ * There are 2 different formats: NDP16 and NDP32 in the spec (ch. 3),
+ * in NDP16 offsets and sizes fields are 1 16bit word wide,
+ * in NDP32 -- 2 16bit words wide. Also signatures are different.
+ * To make the parser code the same, put the differences in the structure,
+ * and switch pointers to the structures when the format is changed.
+ */
+
+struct ndp_parser_opts {
+        u32             nth_sign;
+        u32             ndp_sign;
+        unsigned        nth_size;
+        unsigned        ndp_size;
+        unsigned        ndplen_align;
+        /* sizes in u16 units */
+        unsigned        dgram_item_len; /* index or length */
+        unsigned        block_length;
+        unsigned        fp_index;
+        unsigned        reserved1;
+        unsigned        reserved2;
+        unsigned        next_fp_index;
+};
+
+#define INIT_NDP16_OPTS {                                       \
+                .nth_sign = USB_CDC_NCM_NTH16_SIGN,             \
+                .ndp_sign = USB_CDC_NCM_NDP16_NOCRC_SIGN,       \
+                .nth_size = sizeof(struct usb_cdc_ncm_nth16),   \
+                .ndp_size = sizeof(struct usb_cdc_ncm_ndp16),   \
+                .ndplen_align = 4,                              \
+                .dgram_item_len = 1,                            \
+                .block_length = 1,                              \
+                .fp_index = 1,                                  \
+                .reserved1 = 0,                                 \
+                .reserved2 = 0,                                 \
+                .next_fp_index = 1,                             \
+        }
+
+
+#define INIT_NDP32_OPTS {                                       \
+                .nth_sign = USB_CDC_NCM_NTH32_SIGN,             \
+                .ndp_sign = USB_CDC_NCM_NDP32_NOCRC_SIGN,       \
+                .nth_size = sizeof(struct usb_cdc_ncm_nth32),   \
+                .ndp_size = sizeof(struct usb_cdc_ncm_ndp32),   \
+                .ndplen_align = 8,                              \
+                .dgram_item_len = 2,                            \
+                .block_length = 2,                              \
+                .fp_index = 2,                                  \
+                .reserved1 = 1,                                 \
+                .reserved2 = 2,                                 \
+                .next_fp_index = 2,                             \
+        }
+
+static struct ndp_parser_opts ndp16_opts = INIT_NDP16_OPTS;
+static struct ndp_parser_opts ndp32_opts = INIT_NDP32_OPTS;
+
+static inline void put_ncm(__le16 **p, unsigned size, unsigned val)
+{
+        switch (size) {
+        case 1:
+                put_unaligned_le16((u16)val, *p);
+                break;
+        case 2:
+                put_unaligned_le32((u32)val, *p);
+
+                break;
+        default:
+                BUG();
+        }
+
+        *p += size;
+}
+
+static inline unsigned get_ncm(__le16 **p, unsigned size)
+{
+        unsigned tmp;
+
+        switch (size) {
+        case 1:
+                tmp = get_unaligned_le16(*p);
+                break;
+        case 2:
+                tmp = get_unaligned_le32(*p);
+                break;
+        default:
+                BUG();
+        }
+
+        *p += size;
+        return tmp;
+}
+
+/*-------------------------------------------------------------------------*/
+
+static inline void ncm_reset_values(struct f_ncm *ncm)
+{
+        ncm->parser_opts = &ndp16_opts;
+        ncm->is_crc = false;
+        ncm->port.cdc_filter = DEFAULT_FILTER;
+
+        /* doesn't make sense for ncm, fixed size used */
+        ncm->port.header_len = 0;
+
+        ncm->port.fixed_out_len = le32_to_cpu(ntb_parameters.dwNtbOutMaxSize);
+        ncm->port.fixed_in_len = NTB_DEFAULT_IN_SIZE;
+}
+
+/*
+ * Context: ncm->lock held
+ */
+static void ncm_do_notify(struct f_ncm *ncm)
+{
+        struct usb_request              *req = ncm->notify_req;
+        struct usb_cdc_notification     *event;
+        struct usb_composite_dev        *cdev = ncm->port.func.config->cdev;
+        __le32                          *data;
+        int                             status;
+
+        /* notification already in flight? */
+        if (!req)
+                return;
+
+        event = req->buf;
+        switch (ncm->notify_state) {
+        case NCM_NOTIFY_NONE:
+                return;
+
+        case NCM_NOTIFY_CONNECT:
+                event->bNotificationType = USB_CDC_NOTIFY_NETWORK_CONNECTION;
+                if (ncm->is_open)
+                        event->wValue = cpu_to_le16(1);
+                else
+                        event->wValue = cpu_to_le16(0);
+                event->wLength = 0;
+                req->length = sizeof *event;
+
+                DBG(cdev, "notify connect %s\n",
+                                ncm->is_open ? "true" : "false");
+                ncm->notify_state = NCM_NOTIFY_NONE;
+                break;
+
+        case NCM_NOTIFY_SPEED:
+                event->bNotificationType = USB_CDC_NOTIFY_SPEED_CHANGE;
+                event->wValue = cpu_to_le16(0);
+                event->wLength = cpu_to_le16(8);
+                req->length = NCM_STATUS_BYTECOUNT;
+
+                /* SPEED_CHANGE data is up/down speeds in bits/sec */
+                data = req->buf + sizeof *event;
+                data[0] = cpu_to_le32(ncm_bitrate(cdev->gadget));
+                data[1] = data[0];
+
+                DBG(cdev, "notify speed %d\n", ncm_bitrate(cdev->gadget));
+                ncm->notify_state = NCM_NOTIFY_CONNECT;
+                break;
+        }
+        event->bmRequestType = 0xA1;
+        event->wIndex = cpu_to_le16(ncm->ctrl_id);
+
+        ncm->notify_req = NULL;
+        /*
+         * In double buffering if there is a space in FIFO,
+         * completion callback can be called right after the call,
+         * so unlocking
+         */
+        spin_unlock(&ncm->lock);
+        status = usb_ep_queue(ncm->notify, req, GFP_ATOMIC);
+        spin_lock(&ncm->lock);
+        if (status < 0) {
+                ncm->notify_req = req;
+                DBG(cdev, "notify --> %d\n", status);
+        }
+}
+
+/*
+ * Context: ncm->lock held
+ */
+static void ncm_notify(struct f_ncm *ncm)
+{
+        /*
+         * NOTE on most versions of Linux, host side cdc-ethernet
+         * won't listen for notifications until its netdevice opens.
+         * The first notification then sits in the FIFO for a long
+         * time, and the second one is queued.
+         *
+         * If ncm_notify() is called before the second (CONNECT)
+         * notification is sent, then it will reset to send the SPEED
+         * notificaion again (and again, and again), but it's not a problem
+         */
+        ncm->notify_state = NCM_NOTIFY_SPEED;
+        ncm_do_notify(ncm);
+}
+
+static void ncm_notify_complete(struct usb_ep *ep, struct usb_request *req)
+{
+        struct f_ncm                    *ncm = req->context;
+        struct usb_composite_dev        *cdev = ncm->port.func.config->cdev;
+        struct usb_cdc_notification     *event = req->buf;
+
+        spin_lock(&ncm->lock);
+        switch (req->status) {
+        case 0:
+                VDBG(cdev, "Notification %02x sent\n",
+                     event->bNotificationType);
+                break;
+        case -ECONNRESET:
+        case -ESHUTDOWN:
+                ncm->notify_state = NCM_NOTIFY_NONE;
+                break;
+        default:
+                DBG(cdev, "event %02x --> %d\n",
+                        event->bNotificationType, req->status);
+                break;
+        }
+        ncm->notify_req = req;
+        ncm_do_notify(ncm);
+        spin_unlock(&ncm->lock);
+}
+
+static void ncm_ep0out_complete(struct usb_ep *ep, struct usb_request *req)
+{
+        /* now for SET_NTB_INPUT_SIZE only */
+        unsigned                in_size;
+        struct usb_function     *f = req->context;
+        struct f_ncm            *ncm = func_to_ncm(f);
+        struct usb_composite_dev *cdev = ep->driver_data;
+
+        req->context = NULL;
+        if (req->status || req->actual != req->length) {
+                DBG(cdev, "Bad control-OUT transfer\n");
+                goto invalid;
+        }
+
+        in_size = get_unaligned_le32(req->buf);
+        if (in_size < USB_CDC_NCM_NTB_MIN_IN_SIZE ||
+            in_size > le32_to_cpu(ntb_parameters.dwNtbInMaxSize)) {
+                DBG(cdev, "Got wrong INPUT SIZE (%d) from host\n", in_size);
+                goto invalid;
+        }
+
+        ncm->port.fixed_in_len = in_size;
+        VDBG(cdev, "Set NTB INPUT SIZE %d\n", in_size);
+        return;
+
+invalid:
+        usb_ep_set_halt(ep);
+        return;
+}
+
+static int ncm_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
+{
+        struct f_ncm            *ncm = func_to_ncm(f);
+        struct usb_composite_dev *cdev = f->config->cdev;
+        struct usb_request      *req = cdev->req;
+        int                     value = -EOPNOTSUPP;
+        u16                     w_index = le16_to_cpu(ctrl->wIndex);
+        u16                     w_value = le16_to_cpu(ctrl->wValue);
+        u16                     w_length = le16_to_cpu(ctrl->wLength);
+
+        /*
+         * composite driver infrastructure handles everything except
+         * CDC class messages; interface activation uses set_alt().
+         */
+        switch ((ctrl->bRequestType << 8) | ctrl->bRequest) {
+        case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
+                        | USB_CDC_SET_ETHERNET_PACKET_FILTER:
+                /*
+                 * see 6.2.30: no data, wIndex = interface,
+                 * wValue = packet filter bitmap
+                 */
+                if (w_length != 0 || w_index != ncm->ctrl_id)
+                        goto invalid;
+                DBG(cdev, "packet filter %02x\n", w_value);
+                /*
+                 * REVISIT locking of cdc_filter.  This assumes the UDC
+                 * driver won't have a concurrent packet TX irq running on
+                 * another CPU; or that if it does, this write is atomic...
+                 */
+                ncm->port.cdc_filter = w_value;
+                value = 0;
+                break;
+        /*
+         * and optionally:
+         * case USB_CDC_SEND_ENCAPSULATED_COMMAND:
+         * case USB_CDC_GET_ENCAPSULATED_RESPONSE:
+         * case USB_CDC_SET_ETHERNET_MULTICAST_FILTERS:
+         * case USB_CDC_SET_ETHERNET_PM_PATTERN_FILTER:
+         * case USB_CDC_GET_ETHERNET_PM_PATTERN_FILTER:
+         * case USB_CDC_GET_ETHERNET_STATISTIC:
+         */
+
+        case ((USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
+                | USB_CDC_GET_NTB_PARAMETERS:
+
+                if (w_length == 0 || w_value != 0 || w_index != ncm->ctrl_id)
+                        goto invalid;
+                value = w_length > sizeof ntb_parameters ?
+                        sizeof ntb_parameters : w_length;
+                memcpy(req->buf, &ntb_parameters, value);
+                VDBG(cdev, "Host asked NTB parameters\n");
+                break;
+
+        case ((USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
+                | USB_CDC_GET_NTB_INPUT_SIZE:
+
+                if (w_length < 4 || w_value != 0 || w_index != ncm->ctrl_id)
+                        goto invalid;
+                put_unaligned_le32(ncm->port.fixed_in_len, req->buf);
+                value = 4;
+                VDBG(cdev, "Host asked INPUT SIZE, sending %d\n",
+                     ncm->port.fixed_in_len);
+                break;
+
+        case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
+                | USB_CDC_SET_NTB_INPUT_SIZE:
+        {
+                if (w_length != 4 || w_value != 0 || w_index != ncm->ctrl_id)
+                        goto invalid;
+                req->complete = ncm_ep0out_complete;
+                req->length = w_length;
+                req->context = f;
+
+                value = req->length;
+                break;
+        }
+
+        case ((USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
+                | USB_CDC_GET_NTB_FORMAT:
+        {
+                uint16_t format;
+
+                if (w_length < 2 || w_value != 0 || w_index != ncm->ctrl_id)
+                        goto invalid;
+                format = (ncm->parser_opts == &ndp16_opts) ? 0x0000 : 0x0001;
+                put_unaligned_le16(format, req->buf);
+                value = 2;
+                VDBG(cdev, "Host asked NTB FORMAT, sending %d\n", format);
+                break;
+        }
+
+        case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
+                | USB_CDC_SET_NTB_FORMAT:
+        {
+                if (w_length != 0 || w_index != ncm->ctrl_id)
+                        goto invalid;
+                switch (w_value) {
+                case 0x0000:
+                        ncm->parser_opts = &ndp16_opts;
+                        DBG(cdev, "NCM16 selected\n");
+                        break;
+                case 0x0001:
+                        ncm->parser_opts = &ndp32_opts;
+                        DBG(cdev, "NCM32 selected\n");
+                        break;
+                default:
+                        goto invalid;
+                }
+                value = 0;
+                break;
+        }
+        case ((USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
+                | USB_CDC_GET_CRC_MODE:
+        {
+                uint16_t is_crc;
+
+                if (w_length < 2 || w_value != 0 || w_index != ncm->ctrl_id)
+                        goto invalid;
+                is_crc = ncm->is_crc ? 0x0001 : 0x0000;
+                put_unaligned_le16(is_crc, req->buf);
+                value = 2;
+                VDBG(cdev, "Host asked CRC MODE, sending %d\n", is_crc);
+                break;
+        }
+
+        case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
+                | USB_CDC_SET_CRC_MODE:
+        {
+                int ndp_hdr_crc = 0;
+
+                if (w_length != 0 || w_index != ncm->ctrl_id)
+                        goto invalid;
+                switch (w_value) {
+                case 0x0000:
+                        ncm->is_crc = false;
+                        ndp_hdr_crc = NCM_NDP_HDR_NOCRC;
+                        DBG(cdev, "non-CRC mode selected\n");
+                        break;
+                case 0x0001:
+                        ncm->is_crc = true;
+                        ndp_hdr_crc = NCM_NDP_HDR_CRC;
+                        DBG(cdev, "CRC mode selected\n");
+                        break;
+                default:
+                        goto invalid;
+                }
+                ncm->parser_opts->ndp_sign &= ~NCM_NDP_HDR_CRC_MASK;
+                ncm->parser_opts->ndp_sign |= ndp_hdr_crc;
+                value = 0;
+                break;
+        }
+
+        /* and disabled in ncm descriptor: */
+        /* case USB_CDC_GET_NET_ADDRESS: */
+        /* case USB_CDC_SET_NET_ADDRESS: */
+        /* case USB_CDC_GET_MAX_DATAGRAM_SIZE: */
+        /* case USB_CDC_SET_MAX_DATAGRAM_SIZE: */
+
+        default:
+invalid:
+                DBG(cdev, "invalid control req%02x.%02x v%04x i%04x l%d\n",
+                        ctrl->bRequestType, ctrl->bRequest,
+                        w_value, w_index, w_length);
+        }
+
+        /* respond with data transfer or status phase? */
+        if (value >= 0) {
+                DBG(cdev, "ncm req%02x.%02x v%04x i%04x l%d\n",
+                        ctrl->bRequestType, ctrl->bRequest,
+                        w_value, w_index, w_length);
+                req->zero = 0;
+                req->length = value;
+                value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
+                if (value < 0)
+                        ERROR(cdev, "ncm req %02x.%02x response err %d\n",
+                                        ctrl->bRequestType, ctrl->bRequest,
+                                        value);
+        }
+
+        /* device either stalls (value < 0) or reports success */
+        return value;
+}
+
+
+static int ncm_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
+{
+        struct f_ncm            *ncm = func_to_ncm(f);
+        struct usb_composite_dev *cdev = f->config->cdev;
+
+        /* Control interface has only altsetting 0 */
+        if (intf == ncm->ctrl_id) {
+                if (alt != 0)
+                        goto fail;
+
+                if (ncm->notify->driver_data) {
+                        DBG(cdev, "reset ncm control %d\n", intf);
+                        usb_ep_disable(ncm->notify);
+                } else {
+                        DBG(cdev, "init ncm ctrl %d\n", intf);
+                        ncm->notify_desc = ep_choose(cdev->gadget,
+                                        ncm->hs.notify,
+                                        ncm->fs.notify);
+                }
+                usb_ep_enable(ncm->notify, ncm->notify_desc);
+                ncm->notify->driver_data = ncm;
+
+        /* Data interface has two altsettings, 0 and 1 */
+        } else if (intf == ncm->data_id) {
+                if (alt > 1)
+                        goto fail;
+
+                if (ncm->port.in_ep->driver_data) {
+                        DBG(cdev, "reset ncm\n");
+                        gether_disconnect(&ncm->port);
+                        ncm_reset_values(ncm);
+                }
+
+                /*
+                 * CDC Network only sends data in non-default altsettings.
+                 * Changing altsettings resets filters, statistics, etc.
+                 */
+                if (alt == 1) {
+                        struct net_device       *net;
+
+                        if (!ncm->port.in) {
+                                DBG(cdev, "init ncm\n");
+                                ncm->port.in = ep_choose(cdev->gadget,
+                                                         ncm->hs.in,
+                                                         ncm->fs.in);
+                                ncm->port.out = ep_choose(cdev->gadget,
+                                                          ncm->hs.out,
+                                                          ncm->fs.out);
+                        }
+
+                        /* TODO */
+                        /* Enable zlps by default for NCM conformance;
+                         * override for musb_hdrc (avoids txdma ovhead)
+                         */
+                        ncm->port.is_zlp_ok = !(
+                                gadget_is_musbhdrc(cdev->gadget)
+                                );
+                        ncm->port.cdc_filter = DEFAULT_FILTER;
+                        DBG(cdev, "activate ncm\n");
+                        net = gether_connect(&ncm->port);
+                        if (IS_ERR(net))
+                                return PTR_ERR(net);
+                }
+
+                spin_lock(&ncm->lock);
+                ncm_notify(ncm);
+                spin_unlock(&ncm->lock);
+        } else
+                goto fail;
+
+        return 0;
+fail:
+        return -EINVAL;
+}
+
+/*
+ * Because the data interface supports multiple altsettings,
+ * this NCM function *MUST* implement a get_alt() method.
+ */
+static int ncm_get_alt(struct usb_function *f, unsigned intf)
+{
+        struct f_ncm            *ncm = func_to_ncm(f);
+
+        if (intf == ncm->ctrl_id)
+                return 0;
+        return ncm->port.in_ep->driver_data ? 1 : 0;
+}
+
+static struct sk_buff *ncm_wrap_ntb(struct gether *port,
+                                    struct sk_buff *skb)
+{
+        struct f_ncm    *ncm = func_to_ncm(&port->func);
+        struct sk_buff  *skb2;
+        int             ncb_len = 0;
+        __le16          *tmp;
+        int             div = ntb_parameters.wNdpInDivisor;
+        int             rem = ntb_parameters.wNdpInPayloadRemainder;
+        int             pad;
+        int             ndp_align = ntb_parameters.wNdpInAlignment;
+        int             ndp_pad;
+        unsigned        max_size = ncm->port.fixed_in_len;
+        struct ndp_parser_opts *opts = ncm->parser_opts;
+        unsigned        crc_len = ncm->is_crc ? sizeof(uint32_t) : 0;
+
+        ncb_len += opts->nth_size;
+        ndp_pad = ALIGN(ncb_len, ndp_align) - ncb_len;
+        ncb_len += ndp_pad;
+        ncb_len += opts->ndp_size;
+        ncb_len += 2 * 2 * opts->dgram_item_len; /* Datagram entry */
+        ncb_len += 2 * 2 * opts->dgram_item_len; /* Zero datagram entry */
+        pad = ALIGN(ncb_len, div) + rem - ncb_len;
+        ncb_len += pad;
+
+        if (ncb_len + skb->len + crc_len > max_size) {
+                dev_kfree_skb_any(skb);
+                return NULL;
+        }
+
+        skb2 = skb_copy_expand(skb, ncb_len,
+                               max_size - skb->len - ncb_len - crc_len,
+                               GFP_ATOMIC);
+        dev_kfree_skb_any(skb);
+        if (!skb2)
+                return NULL;
+
+        skb = skb2;
+
+        tmp = (void *) skb_push(skb, ncb_len);
+        memset(tmp, 0, ncb_len);
+
+        put_unaligned_le32(opts->nth_sign, tmp); /* dwSignature */
+        tmp += 2;
+        /* wHeaderLength */
+        put_unaligned_le16(opts->nth_size, tmp++);
+        tmp++; /* skip wSequence */
+        put_ncm(&tmp, opts->block_length, skb->len); /* (d)wBlockLength */
+        /* (d)wFpIndex */
+        /* the first pointer is right after the NTH + align */
+        put_ncm(&tmp, opts->fp_index, opts->nth_size + ndp_pad);
+
+        tmp = (void *)tmp + ndp_pad;
+
+        /* NDP */
+        put_unaligned_le32(opts->ndp_sign, tmp); /* dwSignature */
+        tmp += 2;
+        /* wLength */
+        put_unaligned_le16(ncb_len - opts->nth_size - pad, tmp++);
+
+        tmp += opts->reserved1;
+        tmp += opts->next_fp_index; /* skip reserved (d)wNextFpIndex */
+        tmp += opts->reserved2;
+
+        if (ncm->is_crc) {
+                uint32_t crc;
+
+                crc = ~crc32_le(~0,
+                                skb->data + ncb_len,
+                                skb->len - ncb_len);
+                put_unaligned_le32(crc, skb->data + skb->len);
+                skb_put(skb, crc_len);
+        }
+
+        /* (d)wDatagramIndex[0] */
+        put_ncm(&tmp, opts->dgram_item_len, ncb_len);
+        /* (d)wDatagramLength[0] */
+        put_ncm(&tmp, opts->dgram_item_len, skb->len - ncb_len);
+        /* (d)wDatagramIndex[1] and  (d)wDatagramLength[1] already zeroed */
+
+        if (skb->len > MAX_TX_NONFIXED)
+                memset(skb_put(skb, max_size - skb->len),
+                       0, max_size - skb->len);
+
+        return skb;
+}
+
+static int ncm_unwrap_ntb(struct gether *port,
+                          struct sk_buff *skb,
+                          struct sk_buff_head *list)
+{
+        struct f_ncm    *ncm = func_to_ncm(&port->func);
+        __le16          *tmp = (void *) skb->data;
+        unsigned        index, index2;
+        unsigned        dg_len, dg_len2;
+        unsigned        ndp_len;
+        struct sk_buff  *skb2;
+        int             ret = -EINVAL;
+        unsigned        max_size = le32_to_cpu(ntb_parameters.dwNtbOutMaxSize);
+        struct ndp_parser_opts *opts = ncm->parser_opts;
+        unsigned        crc_len = ncm->is_crc ? sizeof(uint32_t) : 0;
+        int             dgram_counter;
+
+        /* dwSignature */
+        if (get_unaligned_le32(tmp) != opts->nth_sign) {
+                INFO(port->func.config->cdev, "Wrong NTH SIGN, skblen %d\n",
+                        skb->len);
+                print_hex_dump(KERN_INFO, "HEAD:", DUMP_PREFIX_ADDRESS, 32, 1,
+                               skb->data, 32, false);
+
+                goto err;
+        }
+        tmp += 2;
+        /* wHeaderLength */
+        if (get_unaligned_le16(tmp++) != opts->nth_size) {
+                INFO(port->func.config->cdev, "Wrong NTB headersize\n");
+                goto err;
+        }
+        tmp++; /* skip wSequence */
+
+        /* (d)wBlockLength */
+        if (get_ncm(&tmp, opts->block_length) > max_size) {
+                INFO(port->func.config->cdev, "OUT size exceeded\n");
+                goto err;
+        }
+
+        index = get_ncm(&tmp, opts->fp_index);
+        /* NCM 3.2 */
+        if (((index % 4) != 0) && (index < opts->nth_size)) {
+                INFO(port->func.config->cdev, "Bad index: %x\n",
+                        index);
+                goto err;
+        }
+
+        /* walk through NDP */
+        tmp = ((void *)skb->data) + index;
+        if (get_unaligned_le32(tmp) != opts->ndp_sign) {
+                INFO(port->func.config->cdev, "Wrong NDP SIGN\n");
+                goto err;
+        }
+        tmp += 2;
+
+        ndp_len = get_unaligned_le16(tmp++);
+        /*
+         * NCM 3.3.1
+         * entry is 2 items
+         * item size is 16/32 bits, opts->dgram_item_len * 2 bytes
+         * minimal: struct usb_cdc_ncm_ndpX + normal entry + zero entry
+         */
+        if ((ndp_len < opts->ndp_size + 2 * 2 * (opts->dgram_item_len * 2))
+            || (ndp_len % opts->ndplen_align != 0)) {
+                INFO(port->func.config->cdev, "Bad NDP length: %x\n", ndp_len);
+                goto err;
+        }
+        tmp += opts->reserved1;
+        tmp += opts->next_fp_index; /* skip reserved (d)wNextFpIndex */
+        tmp += opts->reserved2;
+
+        ndp_len -= opts->ndp_size;
+        index2 = get_ncm(&tmp, opts->dgram_item_len);
+        dg_len2 = get_ncm(&tmp, opts->dgram_item_len);
+        dgram_counter = 0;
+
+        do {
+                index = index2;
+                dg_len = dg_len2;
+                if (dg_len < 14 + crc_len) { /* ethernet header + crc */
+                        INFO(port->func.config->cdev, "Bad dgram length: %x\n",
+                             dg_len);
+                        goto err;
+                }
+                if (ncm->is_crc) {
+                        uint32_t crc, crc2;
+
+                        crc = get_unaligned_le32(skb->data +
+                                                 index + dg_len - crc_len);
+                        crc2 = ~crc32_le(~0,
+                                         skb->data + index,
+                                         dg_len - crc_len);
+                        if (crc != crc2) {
+                                INFO(port->func.config->cdev, "Bad CRC\n");
+                                goto err;
+                        }
+                }
+
+                index2 = get_ncm(&tmp, opts->dgram_item_len);
+                dg_len2 = get_ncm(&tmp, opts->dgram_item_len);
+
+                if (index2 == 0 || dg_len2 == 0) {
+                        skb2 = skb;
+                } else {
+                        skb2 = skb_clone(skb, GFP_ATOMIC);
+                        if (skb2 == NULL)
+                                goto err;
+                }
+
+                if (!skb_pull(skb2, index)) {
+                        ret = -EOVERFLOW;
+                        goto err;
+                }
+
+                skb_trim(skb2, dg_len - crc_len);
+                skb_queue_tail(list, skb2);
+
+                ndp_len -= 2 * (opts->dgram_item_len * 2);
+
+                dgram_counter++;
+
+                if (index2 == 0 || dg_len2 == 0)
+                        break;
+        } while (ndp_len > 2 * (opts->dgram_item_len * 2)); /* zero entry */
+
+        VDBG(port->func.config->cdev,
+             "Parsed NTB with %d frames\n", dgram_counter);
+        return 0;
+err:
+        skb_queue_purge(list);
+        dev_kfree_skb_any(skb);
+        return ret;
+}
+
+static void ncm_disable(struct usb_function *f)
+{
+        struct f_ncm            *ncm = func_to_ncm(f);
+        struct usb_composite_dev *cdev = f->config->cdev;
+
+        DBG(cdev, "ncm deactivated\n");
+
+        if (ncm->port.in_ep->driver_data)
+                gether_disconnect(&ncm->port);
+
+        if (ncm->notify->driver_data) {
+                usb_ep_disable(ncm->notify);
+                ncm->notify->driver_data = NULL;
+                ncm->notify_desc = NULL;
+        }
+}
+
+/*-------------------------------------------------------------------------*/
+
+/*
+ * Callbacks let us notify the host about connect/disconnect when the
+ * net device is opened or closed.
+ *
+ * For testing, note that link states on this side include both opened
+ * and closed variants of:
+ *
+ *   - disconnected/unconfigured
+ *   - configured but inactive (data alt 0)
+ *   - configured and active (data alt 1)
+ *
+ * Each needs to be tested with unplug, rmmod, SET_CONFIGURATION, and
+ * SET_INTERFACE (altsetting).  Remember also that "configured" doesn't
+ * imply the host is actually polling the notification endpoint, and
+ * likewise that "active" doesn't imply it's actually using the data
+ * endpoints for traffic.
+ */
+
+static void ncm_open(struct gether *geth)
+{
+        struct f_ncm            *ncm = func_to_ncm(&geth->func);
+
+        DBG(ncm->port.func.config->cdev, "%s\n", __func__);
+
+        spin_lock(&ncm->lock);
+        ncm->is_open = true;
+        ncm_notify(ncm);
+        spin_unlock(&ncm->lock);
+}
+
+static void ncm_close(struct gether *geth)
+{
+        struct f_ncm            *ncm = func_to_ncm(&geth->func);
+
+        DBG(ncm->port.func.config->cdev, "%s\n", __func__);
+
+        spin_lock(&ncm->lock);
+        ncm->is_open = false;
+        ncm_notify(ncm);
+        spin_unlock(&ncm->lock);
+}
+
+/*-------------------------------------------------------------------------*/
+
+/* ethernet function driver setup/binding */
+
+static int __init
+ncm_bind(struct usb_configuration *c, struct usb_function *f)
+{
+        struct usb_composite_dev *cdev = c->cdev;
+        struct f_ncm            *ncm = func_to_ncm(f);
+        int                     status;
+        struct usb_ep           *ep;
+
+        /* allocate instance-specific interface IDs */
+        status = usb_interface_id(c, f);
+        if (status < 0)
+                goto fail;
+        ncm->ctrl_id = status;
+        ncm_iad_desc.bFirstInterface = status;
+
+        ncm_control_intf.bInterfaceNumber = status;
+        ncm_union_desc.bMasterInterface0 = status;
+
+        status = usb_interface_id(c, f);
+        if (status < 0)
+                goto fail;
+        ncm->data_id = status;
+
+        ncm_data_nop_intf.bInterfaceNumber = status;
+        ncm_data_intf.bInterfaceNumber = status;
+        ncm_union_desc.bSlaveInterface0 = status;
+
+        status = -ENODEV;
+
+        /* allocate instance-specific endpoints */
+        ep = usb_ep_autoconfig(cdev->gadget, &fs_ncm_in_desc);
+        if (!ep)
+                goto fail;
+        ncm->port.in_ep = ep;
+        ep->driver_data = cdev; /* claim */
+
+        ep = usb_ep_autoconfig(cdev->gadget, &fs_ncm_out_desc);
+        if (!ep)
+                goto fail;
+        ncm->port.out_ep = ep;
+        ep->driver_data = cdev; /* claim */
+
+        ep = usb_ep_autoconfig(cdev->gadget, &fs_ncm_notify_desc);
+        if (!ep)
+                goto fail;
+        ncm->notify = ep;
+        ep->driver_data = cdev; /* claim */
+
+        status = -ENOMEM;
+
+        /* allocate notification request and buffer */
+        ncm->notify_req = usb_ep_alloc_request(ep, GFP_KERNEL);
+        if (!ncm->notify_req)
+                goto fail;
+        ncm->notify_req->buf = kmalloc(NCM_STATUS_BYTECOUNT, GFP_KERNEL);
+        if (!ncm->notify_req->buf)
+                goto fail;
+        ncm->notify_req->context = ncm;
+        ncm->notify_req->complete = ncm_notify_complete;
+
+        /* copy descriptors, and track endpoint copies */
+        f->descriptors = usb_copy_descriptors(ncm_fs_function);
+        if (!f->descriptors)
+                goto fail;
+
+        ncm->fs.in = usb_find_endpoint(ncm_fs_function,
+                        f->descriptors, &fs_ncm_in_desc);
+        ncm->fs.out = usb_find_endpoint(ncm_fs_function,
+                        f->descriptors, &fs_ncm_out_desc);
+        ncm->fs.notify = usb_find_endpoint(ncm_fs_function,
+                        f->descriptors, &fs_ncm_notify_desc);
+
+        /*
+         * support all relevant hardware speeds... we expect that when
+         * hardware is dual speed, all bulk-capable endpoints work at
+         * both speeds
+         */
+        if (gadget_is_dualspeed(c->cdev->gadget)) {
+                hs_ncm_in_desc.bEndpointAddress =
+                                fs_ncm_in_desc.bEndpointAddress;
+                hs_ncm_out_desc.bEndpointAddress =
+                                fs_ncm_out_desc.bEndpointAddress;
+                hs_ncm_notify_desc.bEndpointAddress =
+                                fs_ncm_notify_desc.bEndpointAddress;
+
+                /* copy descriptors, and track endpoint copies */
+                f->hs_descriptors = usb_copy_descriptors(ncm_hs_function);
+                if (!f->hs_descriptors)
+                        goto fail;
+
+                ncm->hs.in = usb_find_endpoint(ncm_hs_function,
+                                f->hs_descriptors, &hs_ncm_in_desc);
+                ncm->hs.out = usb_find_endpoint(ncm_hs_function,
+                                f->hs_descriptors, &hs_ncm_out_desc);
+                ncm->hs.notify = usb_find_endpoint(ncm_hs_function,
+                                f->hs_descriptors, &hs_ncm_notify_desc);
+        }
+
+        /*
+         * NOTE:  all that is done without knowing or caring about
+         * the network link ... which is unavailable to this code
+         * until we're activated via set_alt().
+         */
+
+        ncm->port.open = ncm_open;
+        ncm->port.close = ncm_close;
+
+        DBG(cdev, "CDC Network: %s speed IN/%s OUT/%s NOTIFY/%s\n",
+                        gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full",
+                        ncm->port.in_ep->name, ncm->port.out_ep->name,
+                        ncm->notify->name);
+        return 0;
+
+fail:
+        if (f->descriptors)
+                usb_free_descriptors(f->descriptors);
+
+        if (ncm->notify_req) {
+                kfree(ncm->notify_req->buf);
+                usb_ep_free_request(ncm->notify, ncm->notify_req);
+        }
+
+        /* we might as well release our claims on endpoints */
+        if (ncm->notify)
+                ncm->notify->driver_data = NULL;
+        if (ncm->port.out)
+                ncm->port.out_ep->driver_data = NULL;
+        if (ncm->port.in)
+                ncm->port.in_ep->driver_data = NULL;
+
+        ERROR(cdev, "%s: can't bind, err %d\n", f->name, status);
+
+        return status;
+}
+
+static void
+ncm_unbind(struct usb_configuration *c, struct usb_function *f)
+{
+        struct f_ncm            *ncm = func_to_ncm(f);
+
+        DBG(c->cdev, "ncm unbind\n");
+
+        if (gadget_is_dualspeed(c->cdev->gadget))
+                usb_free_descriptors(f->hs_descriptors);
+        usb_free_descriptors(f->descriptors);
+
+        kfree(ncm->notify_req->buf);
+        usb_ep_free_request(ncm->notify, ncm->notify_req);
+
+        ncm_string_defs[1].s = NULL;
+        kfree(ncm);
+}
+
+/**
+ * ncm_bind_config - add CDC Network link to a configuration
+ * @c: the configuration to support the network link
+ * @ethaddr: a buffer in which the ethernet address of the host side
+ *      side of the link was recorded
+ * Context: single threaded during gadget setup
+ *
+ * Returns zero on success, else negative errno.
+ *
+ * Caller must have called @gether_setup().  Caller is also responsible
+ * for calling @gether_cleanup() before module unload.
+ */
+int __init ncm_bind_config(struct usb_configuration *c, u8 ethaddr[ETH_ALEN])
+{
+        struct f_ncm    *ncm;
+        int             status;
+
+        if (!can_support_ecm(c->cdev->gadget) || !ethaddr)
+                return -EINVAL;
+
+        /* maybe allocate device-global string IDs */
+        if (ncm_string_defs[0].id == 0) {
+
+                /* control interface label */
+                status = usb_string_id(c->cdev);
+                if (status < 0)
+                        return status;
+                ncm_string_defs[STRING_CTRL_IDX].id = status;
+                ncm_control_intf.iInterface = status;
+
+                /* data interface label */
+                status = usb_string_id(c->cdev);
+                if (status < 0)
+                        return status;
+                ncm_string_defs[STRING_DATA_IDX].id = status;
+                ncm_data_nop_intf.iInterface = status;
+                ncm_data_intf.iInterface = status;
+
+                /* MAC address */
+                status = usb_string_id(c->cdev);
+                if (status < 0)
+                        return status;
+                ncm_string_defs[STRING_MAC_IDX].id = status;
+                ecm_desc.iMACAddress = status;
+
+                /* IAD */
+                status = usb_string_id(c->cdev);
+                if (status < 0)
+                        return status;
+                ncm_string_defs[STRING_IAD_IDX].id = status;
+                ncm_iad_desc.iFunction = status;
+        }
+
+        /* allocate and initialize one new instance */
+        ncm = kzalloc(sizeof *ncm, GFP_KERNEL);
+        if (!ncm)
+                return -ENOMEM;
+
+        /* export host's Ethernet address in CDC format */
+        snprintf(ncm->ethaddr, sizeof ncm->ethaddr,
+                "%02X%02X%02X%02X%02X%02X",
+                ethaddr[0], ethaddr[1], ethaddr[2],
+                ethaddr[3], ethaddr[4], ethaddr[5]);
+        ncm_string_defs[1].s = ncm->ethaddr;
+
+        spin_lock_init(&ncm->lock);
+        ncm_reset_values(ncm);
+        ncm->port.is_fixed = true;
+
+        ncm->port.func.name = "cdc_network";
+        ncm->port.func.strings = ncm_strings;
+        /* descriptors are per-instance copies */
+        ncm->port.func.bind = ncm_bind;
+        ncm->port.func.unbind = ncm_unbind;
+        ncm->port.func.set_alt = ncm_set_alt;
+        ncm->port.func.get_alt = ncm_get_alt;
+        ncm->port.func.setup = ncm_setup;
+        ncm->port.func.disable = ncm_disable;
+
+        ncm->port.wrap = ncm_wrap_ntb;
+        ncm->port.unwrap = ncm_unwrap_ntb;
+
+        status = usb_add_function(c, &ncm->port.func);
+        if (status) {
+                ncm_string_defs[1].s = NULL;
+                kfree(ncm);
+        }
+        return status;
+}
diff --git a/drivers/usb/gadget/f_phonet.c b/drivers/usb/gadget/f_phonet.c
index 3c6e1a058745..5e1495097ec3 100644
--- a/drivers/usb/gadget/f_phonet.c
+++ b/drivers/usb/gadget/f_phonet.c
@@ -346,14 +346,19 @@ static void pn_rx_complete(struct usb_ep *ep, struct usb_request *req)
 
                 if (unlikely(!skb))
                         break;
-                skb_add_rx_frag(skb, skb_shinfo(skb)->nr_frags, page, 0,
-                                req->actual);
-                page = NULL;
 
-                if (req->actual < req->length) { /* Last fragment */
+                if (skb->len == 0) { /* First fragment */
                         skb->protocol = htons(ETH_P_PHONET);
                         skb_reset_mac_header(skb);
-                        pskb_pull(skb, 1);
+                        /* Can't use pskb_pull() on page in IRQ */
+                        memcpy(skb_put(skb, 1), page_address(page), 1);
+                }
+
+                skb_add_rx_frag(skb, skb_shinfo(skb)->nr_frags, page,
+                                skb->len == 0, req->actual);
+                page = NULL;
+
+                if (req->actual < req->length) { /* Last fragment */
                         skb->dev = dev;
                         dev->stats.rx_packets++;
                         dev->stats.rx_bytes += skb->len;
diff --git a/drivers/usb/gadget/f_rndis.c b/drivers/usb/gadget/f_rndis.c
index 882484a40398..fa12ec8364ef 100644
--- a/drivers/usb/gadget/f_rndis.c
+++ b/drivers/usb/gadget/f_rndis.c
@@ -420,8 +420,7 @@ rndis_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
          */
         case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
                         | USB_CDC_SEND_ENCAPSULATED_COMMAND:
-                if (w_length > req->length || w_value
-                                || w_index != rndis->ctrl_id)
+                if (w_value || w_index != rndis->ctrl_id)
                         goto invalid;
                 /* read the request; process it later */
                 value = w_length;
diff --git a/drivers/usb/gadget/f_sourcesink.c b/drivers/usb/gadget/f_sourcesink.c
index 685d768f336e..e403a534dd55 100644
--- a/drivers/usb/gadget/f_sourcesink.c
+++ b/drivers/usb/gadget/f_sourcesink.c
@@ -404,7 +404,7 @@ static void sourcesink_disable(struct usb_function *f)
 
 /*-------------------------------------------------------------------------*/
 
-static int __ref sourcesink_bind_config(struct usb_configuration *c)
+static int __init sourcesink_bind_config(struct usb_configuration *c)
 {
         struct f_sourcesink     *ss;
         int                     status;
@@ -498,7 +498,6 @@ unknown:
 static struct usb_configuration sourcesink_driver = {
         .label          = "source/sink",
         .strings        = sourcesink_strings,
-        .bind           = sourcesink_bind_config,
         .setup          = sourcesink_setup,
         .bConfigurationValue = 3,
         .bmAttributes   = USB_CONFIG_ATT_SELFPOWER,
@@ -532,5 +531,5 @@ int __init sourcesink_add(struct usb_composite_dev *cdev, bool autoresume)
                 sourcesink_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
         }
 
-        return usb_add_config(cdev, &sourcesink_driver);
+        return usb_add_config(cdev, &sourcesink_driver, sourcesink_bind_config);
 }
diff --git a/drivers/usb/gadget/file_storage.c b/drivers/usb/gadget/file_storage.c
index a857b7ac238c..0360f56221ea 100644
--- a/drivers/usb/gadget/file_storage.c
+++ b/drivers/usb/gadget/file_storage.c
@@ -89,6 +89,7 @@
  *                              Required if "removable" is not set, names of
  *                                      the files or block devices used for
  *                                      backing storage
+ *      serial=HHHH...          Required serial number (string of hex chars)
  *      ro=b[,b...]             Default false, booleans for read-only access
  *      removable               Default false, boolean for removable media
  *      luns=N                  Default N = number of filenames, number of
@@ -108,12 +109,11 @@
  *      vendor=0xVVVV           Default 0x0525 (NetChip), USB Vendor ID
  *      product=0xPPPP          Default 0xa4a5 (FSG), USB Product ID
  *      release=0xRRRR          Override the USB release number (bcdDevice)
- *      serial=HHHH...          Override serial number (string of hex chars)
  *      buflen=N                Default N=16384, buffer size used (will be
  *                                      rounded down to a multiple of
  *                                      PAGE_CACHE_SIZE)
  *
- * If CONFIG_USB_FILE_STORAGE_TEST is not set, only the "file", "ro",
+ * If CONFIG_USB_FILE_STORAGE_TEST is not set, only the "file", "serial", "ro",
  * "removable", "luns", "nofua", "stall", and "cdrom" options are available;
  * default values are used for everything else.
  *
@@ -273,13 +273,10 @@
 
 #define DRIVER_DESC             "File-backed Storage Gadget"
 #define DRIVER_NAME             "g_file_storage"
-/* DRIVER_VERSION must be at least 6 characters long, as it is used
- * to generate a fallback serial number. */
-#define DRIVER_VERSION          "20 November 2008"
+#define DRIVER_VERSION          "1 September 2010"
 
 static       char fsg_string_manufacturer[64];
 static const char fsg_string_product[] = DRIVER_DESC;
-static       char fsg_string_serial[13];
 static const char fsg_string_config[] = "Self-powered";
 static const char fsg_string_interface[] = "Mass Storage";
 
@@ -305,6 +302,7 @@ MODULE_LICENSE("Dual BSD/GPL");
 
 static struct {
         char            *file[FSG_MAX_LUNS];
+        char            *serial;
         int             ro[FSG_MAX_LUNS];
         int             nofua[FSG_MAX_LUNS];
         unsigned int    num_filenames;
@@ -321,7 +319,6 @@ static struct {
         unsigned short  vendor;
         unsigned short  product;
         unsigned short  release;
-        char            *serial;
         unsigned int    buflen;
 
         int             transport_type;
@@ -346,6 +343,9 @@ module_param_array_named(file, mod_data.file, charp, &mod_data.num_filenames,
                 S_IRUGO);
 MODULE_PARM_DESC(file, "names of backing files or devices");
 
+module_param_named(serial, mod_data.serial, charp, S_IRUGO);
+MODULE_PARM_DESC(serial, "USB serial number");
+
 module_param_array_named(ro, mod_data.ro, bool, &mod_data.num_ros, S_IRUGO);
 MODULE_PARM_DESC(ro, "true to force read-only");
 
@@ -365,9 +365,6 @@ MODULE_PARM_DESC(stall, "false to prevent bulk stalls");
 module_param_named(cdrom, mod_data.cdrom, bool, S_IRUGO);
 MODULE_PARM_DESC(cdrom, "true to emulate cdrom instead of disk");
 
-module_param_named(serial, mod_data.serial, charp, S_IRUGO);
-MODULE_PARM_DESC(serial, "USB serial number");
-
 /* In the non-TEST version, only the module parameters listed above
  * are available. */
 #ifdef CONFIG_USB_FILE_STORAGE_TEST
@@ -786,7 +783,7 @@ static void received_cbi_adsc(struct fsg_dev *fsg, struct fsg_buffhd *bh)
 {
         struct usb_request      *req = fsg->ep0req;
         static u8               cbi_reset_cmnd[6] = {
-                        SC_SEND_DIAGNOSTIC, 4, 0xff, 0xff, 0xff, 0xff};
+                        SEND_DIAGNOSTIC, 4, 0xff, 0xff, 0xff, 0xff};
 
         /* Error in command transfer? */
         if (req->status || req->length != req->actual ||
@@ -1138,7 +1135,7 @@ static int do_read(struct fsg_dev *fsg)
 
         /* Get the starting Logical Block Address and check that it's
          * not too big */
-        if (fsg->cmnd[0] == SC_READ_6)
+        if (fsg->cmnd[0] == READ_6)
                 lba = get_unaligned_be24(&fsg->cmnd[1]);
         else {
                 lba = get_unaligned_be32(&fsg->cmnd[2]);
@@ -1273,7 +1270,7 @@ static int do_write(struct fsg_dev *fsg)
 
         /* Get the starting Logical Block Address and check that it's
          * not too big */
-        if (fsg->cmnd[0] == SC_WRITE_6)
+        if (fsg->cmnd[0] == WRITE_6)
                 lba = get_unaligned_be24(&fsg->cmnd[1]);
         else {
                 lba = get_unaligned_be32(&fsg->cmnd[2]);
@@ -1581,7 +1578,7 @@ static int do_inquiry(struct fsg_dev *fsg, struct fsg_buffhd *bh)
         }
 
         memset(buf, 0, 8);
-        buf[0] = (mod_data.cdrom ? TYPE_CDROM : TYPE_DISK);
+        buf[0] = (mod_data.cdrom ? TYPE_ROM : TYPE_DISK);
         if (mod_data.removable)
                 buf[1] = 0x80;
         buf[2] = 2;             // ANSI SCSI level 2
@@ -1750,11 +1747,11 @@ static int do_mode_sense(struct fsg_dev *fsg, struct fsg_buffhd *bh)
          * The only variable value is the WriteProtect bit.  We will fill in
          * the mode data length later. */
         memset(buf, 0, 8);
-        if (mscmnd == SC_MODE_SENSE_6) {
+        if (mscmnd == MODE_SENSE) {
                 buf[2] = (curlun->ro ? 0x80 : 0x00);            // WP, DPOFUA
                 buf += 4;
                 limit = 255;
-        } else {                        // SC_MODE_SENSE_10
+        } else {                        // MODE_SENSE_10
                 buf[3] = (curlun->ro ? 0x80 : 0x00);            // WP, DPOFUA
                 buf += 8;
                 limit = 65535;          // Should really be mod_data.buflen
@@ -1794,7 +1791,7 @@ static int do_mode_sense(struct fsg_dev *fsg, struct fsg_buffhd *bh)
         }
 
         /*  Store the mode data length */
-        if (mscmnd == SC_MODE_SENSE_6)
+        if (mscmnd == MODE_SENSE)
                 buf0[0] = len - 1;
         else
                 put_unaligned_be16(len - 2, buf0);
@@ -1950,37 +1947,6 @@ static int wedge_bulk_in_endpoint(struct fsg_dev *fsg)
         return rc;
 }
 
-static int pad_with_zeros(struct fsg_dev *fsg)
-{
-        struct fsg_buffhd       *bh = fsg->next_buffhd_to_fill;
-        u32                     nkeep = bh->inreq->length;
-        u32                     nsend;
-        int                     rc;
-
-        bh->state = BUF_STATE_EMPTY;            // For the first iteration
-        fsg->usb_amount_left = nkeep + fsg->residue;
-        while (fsg->usb_amount_left > 0) {
-
-                /* Wait for the next buffer to be free */
-                while (bh->state != BUF_STATE_EMPTY) {
-                        rc = sleep_thread(fsg);
-                        if (rc)
-                                return rc;
-                }
-
-                nsend = min(fsg->usb_amount_left, (u32) mod_data.buflen);
-                memset(bh->buf + nkeep, 0, nsend - nkeep);
-                bh->inreq->length = nsend;
-                bh->inreq->zero = 0;
-                start_transfer(fsg, fsg->bulk_in, bh->inreq,
-                                &bh->inreq_busy, &bh->state);
-                bh = fsg->next_buffhd_to_fill = bh->next;
-                fsg->usb_amount_left -= nsend;
-                nkeep = 0;
-        }
-        return 0;
-}
-
 static int throw_away_data(struct fsg_dev *fsg)
 {
         struct fsg_buffhd       *bh;
@@ -2085,18 +2051,20 @@ static int finish_reply(struct fsg_dev *fsg)
                         }
                 }
 
-                /* For Bulk-only, if we're allowed to stall then send the
-                 * short packet and halt the bulk-in endpoint.  If we can't
-                 * stall, pad out the remaining data with 0's. */
+                /*
+                 * For Bulk-only, mark the end of the data with a short
+                 * packet.  If we are allowed to stall, halt the bulk-in
+                 * endpoint.  (Note: This violates the Bulk-Only Transport
+                 * specification, which requires us to pad the data if we
+                 * don't halt the endpoint.  Presumably nobody will mind.)
+                 */
                 else {
-                        if (mod_data.can_stall) {
-                                bh->inreq->zero = 1;
-                                start_transfer(fsg, fsg->bulk_in, bh->inreq,
-                                                &bh->inreq_busy, &bh->state);
-                                fsg->next_buffhd_to_fill = bh->next;
+                        bh->inreq->zero = 1;
+                        start_transfer(fsg, fsg->bulk_in, bh->inreq,
+                                        &bh->inreq_busy, &bh->state);
+                        fsg->next_buffhd_to_fill = bh->next;
+                        if (mod_data.can_stall)
                                 rc = halt_bulk_in_endpoint(fsg);
-                        } else
-                                rc = pad_with_zeros(fsg);
                 }
                 break;
 
@@ -2317,9 +2285,9 @@ static int check_command(struct fsg_dev *fsg, int cmnd_size,
                 fsg->lun = lun;         // Use LUN from the command
 
         /* Check the LUN */
-        if (fsg->lun >= 0 && fsg->lun < fsg->nluns) {
+        if (fsg->lun < fsg->nluns) {
                 fsg->curlun = curlun = &fsg->luns[fsg->lun];
-                if (fsg->cmnd[0] != SC_REQUEST_SENSE) {
+                if (fsg->cmnd[0] != REQUEST_SENSE) {
                         curlun->sense_data = SS_NO_SENSE;
                         curlun->sense_data_info = 0;
                         curlun->info_valid = 0;
@@ -2330,8 +2298,8 @@ static int check_command(struct fsg_dev *fsg, int cmnd_size,
 
                 /* INQUIRY and REQUEST SENSE commands are explicitly allowed
                  * to use unsupported LUNs; all others may not. */
-                if (fsg->cmnd[0] != SC_INQUIRY &&
-                                fsg->cmnd[0] != SC_REQUEST_SENSE) {
+                if (fsg->cmnd[0] != INQUIRY &&
+                                fsg->cmnd[0] != REQUEST_SENSE) {
                         DBG(fsg, "unsupported LUN %d\n", fsg->lun);
                         return -EINVAL;
                 }
@@ -2340,8 +2308,8 @@ static int check_command(struct fsg_dev *fsg, int cmnd_size,
         /* If a unit attention condition exists, only INQUIRY and
          * REQUEST SENSE commands are allowed; anything else must fail. */
         if (curlun && curlun->unit_attention_data != SS_NO_SENSE &&
-                        fsg->cmnd[0] != SC_INQUIRY &&
-                        fsg->cmnd[0] != SC_REQUEST_SENSE) {
+                        fsg->cmnd[0] != INQUIRY &&
+                        fsg->cmnd[0] != REQUEST_SENSE) {
                 curlun->sense_data = curlun->unit_attention_data;
                 curlun->unit_attention_data = SS_NO_SENSE;
                 return -EINVAL;
@@ -2391,7 +2359,7 @@ static int do_scsi_command(struct fsg_dev *fsg)
         down_read(&fsg->filesem);       // We're using the backing file
         switch (fsg->cmnd[0]) {
 
-        case SC_INQUIRY:
+        case INQUIRY:
                 fsg->data_size_from_cmnd = fsg->cmnd[4];
                 if ((reply = check_command(fsg, 6, DATA_DIR_TO_HOST,
                                 (1<<4), 0,
@@ -2399,7 +2367,7 @@ static int do_scsi_command(struct fsg_dev *fsg)
                         reply = do_inquiry(fsg, bh);
                 break;
 
-        case SC_MODE_SELECT_6:
+        case MODE_SELECT:
                 fsg->data_size_from_cmnd = fsg->cmnd[4];
                 if ((reply = check_command(fsg, 6, DATA_DIR_FROM_HOST,
                                 (1<<1) | (1<<4), 0,
@@ -2407,7 +2375,7 @@ static int do_scsi_command(struct fsg_dev *fsg)
                         reply = do_mode_select(fsg, bh);
                 break;
 
-        case SC_MODE_SELECT_10:
+        case MODE_SELECT_10:
                 fsg->data_size_from_cmnd = get_unaligned_be16(&fsg->cmnd[7]);
                 if ((reply = check_command(fsg, 10, DATA_DIR_FROM_HOST,
                                 (1<<1) | (3<<7), 0,
@@ -2415,7 +2383,7 @@ static int do_scsi_command(struct fsg_dev *fsg)
                         reply = do_mode_select(fsg, bh);
                 break;
 
-        case SC_MODE_SENSE_6:
+        case MODE_SENSE:
                 fsg->data_size_from_cmnd = fsg->cmnd[4];
                 if ((reply = check_command(fsg, 6, DATA_DIR_TO_HOST,
                                 (1<<1) | (1<<2) | (1<<4), 0,
@@ -2423,7 +2391,7 @@ static int do_scsi_command(struct fsg_dev *fsg)
                         reply = do_mode_sense(fsg, bh);
                 break;
 
-        case SC_MODE_SENSE_10:
+        case MODE_SENSE_10:
                 fsg->data_size_from_cmnd = get_unaligned_be16(&fsg->cmnd[7]);
                 if ((reply = check_command(fsg, 10, DATA_DIR_TO_HOST,
                                 (1<<1) | (1<<2) | (3<<7), 0,
@@ -2431,7 +2399,7 @@ static int do_scsi_command(struct fsg_dev *fsg)
                         reply = do_mode_sense(fsg, bh);
                 break;
 
-        case SC_PREVENT_ALLOW_MEDIUM_REMOVAL:
+        case ALLOW_MEDIUM_REMOVAL:
                 fsg->data_size_from_cmnd = 0;
                 if ((reply = check_command(fsg, 6, DATA_DIR_NONE,
                                 (1<<4), 0,
@@ -2439,7 +2407,7 @@ static int do_scsi_command(struct fsg_dev *fsg)
                         reply = do_prevent_allow(fsg);
                 break;
 
-        case SC_READ_6:
+        case READ_6:
                 i = fsg->cmnd[4];
                 fsg->data_size_from_cmnd = (i == 0 ? 256 : i) << 9;
                 if ((reply = check_command(fsg, 6, DATA_DIR_TO_HOST,
@@ -2448,7 +2416,7 @@ static int do_scsi_command(struct fsg_dev *fsg)
                         reply = do_read(fsg);
                 break;
 
-        case SC_READ_10:
+        case READ_10:
                 fsg->data_size_from_cmnd =
                                 get_unaligned_be16(&fsg->cmnd[7]) << 9;
                 if ((reply = check_command(fsg, 10, DATA_DIR_TO_HOST,
@@ -2457,7 +2425,7 @@ static int do_scsi_command(struct fsg_dev *fsg)
                         reply = do_read(fsg);
                 break;
 
-        case SC_READ_12:
+        case READ_12:
                 fsg->data_size_from_cmnd =
                                 get_unaligned_be32(&fsg->cmnd[6]) << 9;
                 if ((reply = check_command(fsg, 12, DATA_DIR_TO_HOST,
@@ -2466,7 +2434,7 @@ static int do_scsi_command(struct fsg_dev *fsg)
                         reply = do_read(fsg);
                 break;
 
-        case SC_READ_CAPACITY:
+        case READ_CAPACITY:
                 fsg->data_size_from_cmnd = 8;
                 if ((reply = check_command(fsg, 10, DATA_DIR_TO_HOST,
                                 (0xf<<2) | (1<<8), 1,
@@ -2474,7 +2442,7 @@ static int do_scsi_command(struct fsg_dev *fsg)
                         reply = do_read_capacity(fsg, bh);
                 break;
 
-        case SC_READ_HEADER:
+        case READ_HEADER:
                 if (!mod_data.cdrom)
                         goto unknown_cmnd;
                 fsg->data_size_from_cmnd = get_unaligned_be16(&fsg->cmnd[7]);
@@ -2484,7 +2452,7 @@ static int do_scsi_command(struct fsg_dev *fsg)
                         reply = do_read_header(fsg, bh);
                 break;
 
-        case SC_READ_TOC:
+        case READ_TOC:
                 if (!mod_data.cdrom)
                         goto unknown_cmnd;
                 fsg->data_size_from_cmnd = get_unaligned_be16(&fsg->cmnd[7]);
@@ -2494,7 +2462,7 @@ static int do_scsi_command(struct fsg_dev *fsg)
                         reply = do_read_toc(fsg, bh);
                 break;
 
-        case SC_READ_FORMAT_CAPACITIES:
+        case READ_FORMAT_CAPACITIES:
                 fsg->data_size_from_cmnd = get_unaligned_be16(&fsg->cmnd[7]);
                 if ((reply = check_command(fsg, 10, DATA_DIR_TO_HOST,
                                 (3<<7), 1,
@@ -2502,7 +2470,7 @@ static int do_scsi_command(struct fsg_dev *fsg)
                         reply = do_read_format_capacities(fsg, bh);
                 break;
 
-        case SC_REQUEST_SENSE:
+        case REQUEST_SENSE:
                 fsg->data_size_from_cmnd = fsg->cmnd[4];
                 if ((reply = check_command(fsg, 6, DATA_DIR_TO_HOST,
                                 (1<<4), 0,
@@ -2510,7 +2478,7 @@ static int do_scsi_command(struct fsg_dev *fsg)
                         reply = do_request_sense(fsg, bh);
                 break;
 
-        case SC_START_STOP_UNIT:
+        case START_STOP:
                 fsg->data_size_from_cmnd = 0;
                 if ((reply = check_command(fsg, 6, DATA_DIR_NONE,
                                 (1<<1) | (1<<4), 0,
@@ -2518,7 +2486,7 @@ static int do_scsi_command(struct fsg_dev *fsg)
                         reply = do_start_stop(fsg);
                 break;
 
-        case SC_SYNCHRONIZE_CACHE:
+        case SYNCHRONIZE_CACHE:
                 fsg->data_size_from_cmnd = 0;
                 if ((reply = check_command(fsg, 10, DATA_DIR_NONE,
                                 (0xf<<2) | (3<<7), 1,
@@ -2526,7 +2494,7 @@ static int do_scsi_command(struct fsg_dev *fsg)
                         reply = do_synchronize_cache(fsg);
                 break;
 
-        case SC_TEST_UNIT_READY:
+        case TEST_UNIT_READY:
                 fsg->data_size_from_cmnd = 0;
                 reply = check_command(fsg, 6, DATA_DIR_NONE,
                                 0, 1,
@@ -2535,7 +2503,7 @@ static int do_scsi_command(struct fsg_dev *fsg)
 
         /* Although optional, this command is used by MS-Windows.  We
          * support a minimal version: BytChk must be 0. */
-        case SC_VERIFY:
+        case VERIFY:
                 fsg->data_size_from_cmnd = 0;
                 if ((reply = check_command(fsg, 10, DATA_DIR_NONE,
                                 (1<<1) | (0xf<<2) | (3<<7), 1,
@@ -2543,7 +2511,7 @@ static int do_scsi_command(struct fsg_dev *fsg)
                         reply = do_verify(fsg);
                 break;
 
-        case SC_WRITE_6:
+        case WRITE_6:
                 i = fsg->cmnd[4];
                 fsg->data_size_from_cmnd = (i == 0 ? 256 : i) << 9;
                 if ((reply = check_command(fsg, 6, DATA_DIR_FROM_HOST,
@@ -2552,7 +2520,7 @@ static int do_scsi_command(struct fsg_dev *fsg)
                         reply = do_write(fsg);
                 break;
 
-        case SC_WRITE_10:
+        case WRITE_10:
                 fsg->data_size_from_cmnd =
                                 get_unaligned_be16(&fsg->cmnd[7]) << 9;
                 if ((reply = check_command(fsg, 10, DATA_DIR_FROM_HOST,
@@ -2561,7 +2529,7 @@ static int do_scsi_command(struct fsg_dev *fsg)
                         reply = do_write(fsg);
                 break;
 
-        case SC_WRITE_12:
+        case WRITE_12:
                 fsg->data_size_from_cmnd =
                                 get_unaligned_be32(&fsg->cmnd[6]) << 9;
                 if ((reply = check_command(fsg, 12, DATA_DIR_FROM_HOST,
@@ -2574,10 +2542,10 @@ static int do_scsi_command(struct fsg_dev *fsg)
          * They don't mean much in this setting.  It's left as an exercise
          * for anyone interested to implement RESERVE and RELEASE in terms
          * of Posix locks. */
-        case SC_FORMAT_UNIT:
-        case SC_RELEASE:
-        case SC_RESERVE:
-        case SC_SEND_DIAGNOSTIC:
+        case FORMAT_UNIT:
+        case RELEASE:
+        case RESERVE:
+        case SEND_DIAGNOSTIC:
                 // Fall through
 
         default:
@@ -3178,6 +3146,7 @@ static void /* __init_or_exit */ fsg_unbind(struct usb_gadget *gadget)
         for (i = 0; i < fsg->nluns; ++i) {
                 curlun = &fsg->luns[i];
                 if (curlun->registered) {
+                        device_remove_file(&curlun->dev, &dev_attr_nofua);
                         device_remove_file(&curlun->dev, &dev_attr_ro);
                         device_remove_file(&curlun->dev, &dev_attr_file);
                         fsg_lun_close(curlun);
@@ -3213,7 +3182,6 @@ static int __init check_parameters(struct fsg_dev *fsg)
 {
         int     prot;
         int     gcnum;
-        int     i;
 
         /* Store the default values */
         mod_data.transport_type = USB_PR_BULK;
@@ -3309,45 +3277,29 @@ static int __init check_parameters(struct fsg_dev *fsg)
                         if ((*ch < '0' || *ch > '9') &&
                             (*ch < 'A' || *ch > 'F')) { /* not uppercase hex */
                                 WARNING(fsg,
-                                        "Invalid serial string character: %c; "
-                                        "Failing back to default\n",
+                                        "Invalid serial string character: %c\n",
                                         *ch);
-                                goto fill_serial;
+                                goto no_serial;
                         }
                 }
                 if (len > 126 ||
                     (mod_data.transport_type == USB_PR_BULK && len < 12) ||
                     (mod_data.transport_type != USB_PR_BULK && len > 12)) {
-                        WARNING(fsg,
-                                "Invalid serial string length; "
-                                "Failing back to default\n");
-                        goto fill_serial;
+                        WARNING(fsg, "Invalid serial string length!\n");
+                        goto no_serial;
                 }
                 fsg_strings[FSG_STRING_SERIAL - 1].s = mod_data.serial;
         } else {
-                WARNING(fsg,
-                        "Userspace failed to provide serial number; "
-                        "Failing back to default\n");
-fill_serial:
-                /* Serial number not specified or invalid, make our own.
-                 * We just encode it from the driver version string,
-                 * 12 characters to comply with both CB[I] and BBB spec.
-                 * Warning : Two devices running the same kernel will have
-                 * the same fallback serial number. */
-                for (i = 0; i < 12; i += 2) {
-                        unsigned char   c = DRIVER_VERSION[i / 2];
-
-                        if (!c)
-                                break;
-                        sprintf(&fsg_string_serial[i], "%02X", c);
-                }
+                WARNING(fsg, "No serial-number string provided!\n");
+ no_serial:
+                device_desc.iSerialNumber = 0;
         }
 
         return 0;
 }
 
 
-static int __ref fsg_bind(struct usb_gadget *gadget)
+static int __init fsg_bind(struct usb_gadget *gadget)
 {
         struct fsg_dev          *fsg = the_fsg;
         int                     rc;
@@ -3411,25 +3363,28 @@ static int __ref fsg_bind(struct usb_gadget *gadget)
                 dev_set_name(&curlun->dev,"%s-lun%d",
                              dev_name(&gadget->dev), i);
 
-                if ((rc = device_register(&curlun->dev)) != 0) {
+                kref_get(&fsg->ref);
+                rc = device_register(&curlun->dev);
+                if (rc) {
                         INFO(fsg, "failed to register LUN%d: %d\n", i, rc);
-                        goto out;
-                }
-                if ((rc = device_create_file(&curlun->dev,
-                                        &dev_attr_ro)) != 0 ||
-                                (rc = device_create_file(&curlun->dev,
-                                        &dev_attr_nofua)) != 0 ||
-                                (rc = device_create_file(&curlun->dev,
-                                        &dev_attr_file)) != 0) {
-                        device_unregister(&curlun->dev);
+                        put_device(&curlun->dev);
                         goto out;
                 }
                 curlun->registered = 1;
-                kref_get(&fsg->ref);
+
+                rc = device_create_file(&curlun->dev, &dev_attr_ro);
+                if (rc)
+                        goto out;
+                rc = device_create_file(&curlun->dev, &dev_attr_nofua);
+                if (rc)
+                        goto out;
+                rc = device_create_file(&curlun->dev, &dev_attr_file);
+                if (rc)
+                        goto out;
 
                 if (mod_data.file[i] && *mod_data.file[i]) {
-                        if ((rc = fsg_lun_open(curlun,
-                                        mod_data.file[i])) != 0)
+                        rc = fsg_lun_open(curlun, mod_data.file[i]);
+                        if (rc)
                                 goto out;
                 } else if (!mod_data.removable) {
                         ERROR(fsg, "no file given for LUN%d\n", i);
@@ -3607,7 +3562,6 @@ static struct usb_gadget_driver		fsg_driver = {
         .speed          = USB_SPEED_FULL,
 #endif
         .function       = (char *) fsg_string_product,
-        .bind           = fsg_bind,
         .unbind         = fsg_unbind,
         .disconnect     = fsg_disconnect,
         .setup          = fsg_setup,
@@ -3649,7 +3603,7 @@ static int __init fsg_init(void)
         if ((rc = fsg_alloc()) != 0)
                 return rc;
         fsg = the_fsg;
-        if ((rc = usb_gadget_register_driver(&fsg_driver)) != 0)
+        if ((rc = usb_gadget_probe_driver(&fsg_driver, fsg_bind)) != 0)
                 kref_put(&fsg->ref, fsg_release);
         return rc;
 }
diff --git a/drivers/usb/gadget/fsl_mxc_udc.c b/drivers/usb/gadget/fsl_mxc_udc.c
index eafa6d2c5ed7..43a49ecc1f36 100644
--- a/drivers/usb/gadget/fsl_mxc_udc.c
+++ b/drivers/usb/gadget/fsl_mxc_udc.c
@@ -22,6 +22,10 @@
 static struct clk *mxc_ahb_clk;
 static struct clk *mxc_usb_clk;
 
+/* workaround ENGcm09152 for i.MX35 */
+#define USBPHYCTRL_OTGBASE_OFFSET       0x608
+#define USBPHYCTRL_EVDO                 (1 << 23)
+
 int fsl_udc_clk_init(struct platform_device *pdev)
 {
         struct fsl_usb2_platform_data *pdata;
@@ -84,6 +88,20 @@ eenahb:
 void fsl_udc_clk_finalize(struct platform_device *pdev)
 {
         struct fsl_usb2_platform_data *pdata = pdev->dev.platform_data;
+#if defined(CONFIG_SOC_IMX35)
+        if (cpu_is_mx35()) {
+                unsigned int v;
+
+                /* workaround ENGcm09152 for i.MX35 */
+                if (pdata->workaround & FLS_USB2_WORKAROUND_ENGCM09152) {
+                        v = readl(MX35_IO_ADDRESS(MX35_USB_BASE_ADDR +
+                                        USBPHYCTRL_OTGBASE_OFFSET));
+                        writel(v | USBPHYCTRL_EVDO,
+                                MX35_IO_ADDRESS(MX35_USB_BASE_ADDR +
+                                        USBPHYCTRL_OTGBASE_OFFSET));
+                }
+        }
+#endif
 
         /* ULPI transceivers don't need usbpll */
         if (pdata->phy_mode == FSL_USB2_PHY_ULPI) {
diff --git a/drivers/usb/gadget/fsl_qe_udc.c b/drivers/usb/gadget/fsl_qe_udc.c
index a5ea2c1d8c93..3a68e09309f7 100644
--- a/drivers/usb/gadget/fsl_qe_udc.c
+++ b/drivers/usb/gadget/fsl_qe_udc.c
@@ -1148,6 +1148,12 @@ static int qe_ep_tx(struct qe_ep *ep, struct qe_frame *frame)
 static int txcomplete(struct qe_ep *ep, unsigned char restart)
 {
         if (ep->tx_req != NULL) {
+                struct qe_req *req = ep->tx_req;
+                unsigned zlp = 0, last_len = 0;
+
+                last_len = min_t(unsigned, req->req.length - ep->sent,
+                                ep->ep.maxpacket);
+
                 if (!restart) {
                         int asent = ep->last;
                         ep->sent += asent;
@@ -1156,9 +1162,18 @@ static int txcomplete(struct qe_ep *ep, unsigned char restart)
                         ep->last = 0;
                 }
 
+                /* zlp needed when req->re.zero is set */
+                if (req->req.zero) {
+                        if (last_len == 0 ||
+                                (req->req.length % ep->ep.maxpacket) != 0)
+                                zlp = 0;
+                        else
+                                zlp = 1;
+                } else
+                        zlp = 0;
+
                 /* a request already were transmitted completely */
-                if ((ep->tx_req->req.length - ep->sent) <= 0) {
-                        ep->tx_req->req.actual = (unsigned int)ep->sent;
+                if (((ep->tx_req->req.length - ep->sent) <= 0) && !zlp) {
                         done(ep, ep->tx_req, 0);
                         ep->tx_req = NULL;
                         ep->last = 0;
@@ -1191,6 +1206,7 @@ static int qe_usb_senddata(struct qe_ep *ep, struct qe_frame *frame)
         buf = (u8 *)ep->tx_req->req.buf + ep->sent;
         if (buf && size) {
                 ep->last = size;
+                ep->tx_req->req.actual += size;
                 frame_set_data(frame, buf);
                 frame_set_length(frame, size);
                 frame_set_status(frame, FRAME_OK);
@@ -2302,9 +2318,10 @@ static irqreturn_t qe_udc_irq(int irq, void *_udc)
 }
 
 /*-------------------------------------------------------------------------
-        Gadget driver register and unregister.
+        Gadget driver probe and unregister.
  --------------------------------------------------------------------------*/
-int usb_gadget_register_driver(struct usb_gadget_driver *driver)
+int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
+                int (*bind)(struct usb_gadget *))
 {
         int retval;
         unsigned long flags = 0;
@@ -2315,8 +2332,7 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver)
 
         if (!driver || (driver->speed != USB_SPEED_FULL
                         && driver->speed != USB_SPEED_HIGH)
-                        || !driver->bind || !driver->disconnect
-                        || !driver->setup)
+                        || !bind || !driver->disconnect || !driver->setup)
                 return -EINVAL;
 
         if (udc_controller->driver)
@@ -2332,7 +2348,7 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver)
         udc_controller->gadget.speed = (enum usb_device_speed)(driver->speed);
         spin_unlock_irqrestore(&udc_controller->lock, flags);
 
-        retval = driver->bind(&udc_controller->gadget);
+        retval = bind(&udc_controller->gadget);
         if (retval) {
                 dev_err(udc_controller->dev, "bind to %s --> %d",
                                 driver->driver.name, retval);
@@ -2353,7 +2369,7 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver)
                 udc_controller->gadget.name, driver->driver.name);
         return 0;
 }
-EXPORT_SYMBOL(usb_gadget_register_driver);
+EXPORT_SYMBOL(usb_gadget_probe_driver);
 
 int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
 {
@@ -2523,15 +2539,20 @@ static void qe_udc_release(struct device *dev)
 }
 
 /* Driver probe functions */
-static int __devinit qe_udc_probe(struct platform_device *ofdev,
-                        const struct of_device_id *match)
+static const struct of_device_id qe_udc_match[];
+static int __devinit qe_udc_probe(struct platform_device *ofdev)
 {
+        const struct of_device_id *match;
         struct device_node *np = ofdev->dev.of_node;
         struct qe_ep *ep;
         unsigned int ret = 0;
         unsigned int i;
         const void *prop;
 
+        match = of_match_device(qe_udc_match, &ofdev->dev);
+        if (!match)
+                return -EINVAL;
+
         prop = of_get_property(np, "mode", NULL);
         if (!prop || strcmp(prop, "peripheral"))
                 return -ENODEV;
@@ -2768,7 +2789,7 @@ static const struct of_device_id qe_udc_match[] __devinitconst = {
 
 MODULE_DEVICE_TABLE(of, qe_udc_match);
 
-static struct of_platform_driver udc_driver = {
+static struct platform_driver udc_driver = {
         .driver = {
                 .name = (char *)driver_name,
                 .owner = THIS_MODULE,
@@ -2786,12 +2807,12 @@ static int __init qe_udc_init(void)
 {
         printk(KERN_INFO "%s: %s, %s\n", driver_name, driver_desc,
                         DRIVER_VERSION);
-        return of_register_platform_driver(&udc_driver);
+        return platform_driver_register(&udc_driver);
 }
 
 static void __exit qe_udc_exit(void)
 {
-        of_unregister_platform_driver(&udc_driver);
+        platform_driver_unregister(&udc_driver);
 }
 
 module_init(qe_udc_init);
diff --git a/drivers/usb/gadget/fsl_qe_udc.h b/drivers/usb/gadget/fsl_qe_udc.h
index bea5b827bebe..1da5fb03d218 100644
--- a/drivers/usb/gadget/fsl_qe_udc.h
+++ b/drivers/usb/gadget/fsl_qe_udc.h
@@ -207,15 +207,15 @@ struct qe_frame{
 
 /* Frame status field */
 /* Receive side */
-#define FRAME_OK               0x00000000 /* Frame tranmitted or received OK */
-#define FRAME_ERROR            0x80000000 /* Error occured on frame */
+#define FRAME_OK               0x00000000 /* Frame transmitted or received OK */
+#define FRAME_ERROR            0x80000000 /* Error occurred on frame */
 #define START_FRAME_LOST       0x40000000 /* START_FRAME_LOST */
 #define END_FRAME_LOST         0x20000000 /* END_FRAME_LOST */
 #define RX_ER_NONOCT           0x10000000 /* Rx Non Octet Aligned Packet */
 #define RX_ER_BITSTUFF         0x08000000 /* Frame Aborted --Received packet
                                              with bit stuff error */
 #define RX_ER_CRC              0x04000000 /* Received packet with CRC error */
-#define RX_ER_OVERUN           0x02000000 /* Over-run occured on reception */
+#define RX_ER_OVERUN           0x02000000 /* Over-run occurred on reception */
 #define RX_ER_PID              0x01000000 /* Wrong PID received */
 /* Tranmit side */
 #define TX_ER_NAK              0x00800000 /* Received NAK handshake */
@@ -379,7 +379,7 @@ struct qe_udc {
 #define T_LSP         0x01000000         /* Low-speed transaction */
 #define T_PID         0x00c00000         /* packet id */
 #define T_NAK         0x00100000         /* No ack. */
-#define T_STAL        0x00080000         /* Stall recieved */
+#define T_STAL        0x00080000         /* Stall received */
 #define T_TO          0x00040000         /* time out */
 #define T_UN          0x00020000         /* underrun */
 
diff --git a/drivers/usb/gadget/fsl_udc_core.c b/drivers/usb/gadget/fsl_udc_core.c
index 08a9a62a39e3..4e4833168087 100644
--- a/drivers/usb/gadget/fsl_udc_core.c
+++ b/drivers/usb/gadget/fsl_udc_core.c
@@ -1,12 +1,13 @@
 /*
- * Copyright (C) 2004-2007 Freescale Semicondutor, Inc. All rights reserved.
+ * Copyright (C) 2004-2007,2011 Freescale Semiconductor, Inc.
+ * All rights reserved.
  *
  * Author: Li Yang <leoli@freescale.com>
  *         Jiang Bo <tanya.jiang@freescale.com>
  *
  * Description:
  * Freescale high-speed USB SOC DR module device controller driver.
- * This can be found on MPC8349E/MPC8313E cpus.
+ * This can be found on MPC8349E/MPC8313E/MPC5121E cpus.
  * The driver is previously named as mpc_udc.  Based on bare board
  * code from Dave Liu and Shlomi Gridish.
  *
@@ -77,12 +78,77 @@ fsl_ep0_desc = {
 static void fsl_ep_fifo_flush(struct usb_ep *_ep);
 
 #ifdef CONFIG_PPC32
-#define fsl_readl(addr)         in_le32(addr)
-#define fsl_writel(val32, addr) out_le32(addr, val32)
-#else
+/*
+ * On some SoCs, the USB controller registers can be big or little endian,
+ * depending on the version of the chip. In order to be able to run the
+ * same kernel binary on 2 different versions of an SoC, the BE/LE decision
+ * must be made at run time. _fsl_readl and fsl_writel are pointers to the
+ * BE or LE readl() and writel() functions, and fsl_readl() and fsl_writel()
+ * call through those pointers. Platform code for SoCs that have BE USB
+ * registers should set pdata->big_endian_mmio flag.
+ *
+ * This also applies to controller-to-cpu accessors for the USB descriptors,
+ * since their endianness is also SoC dependant. Platform code for SoCs that
+ * have BE USB descriptors should set pdata->big_endian_desc flag.
+ */
+static u32 _fsl_readl_be(const unsigned __iomem *p)
+{
+        return in_be32(p);
+}
+
+static u32 _fsl_readl_le(const unsigned __iomem *p)
+{
+        return in_le32(p);
+}
+
+static void _fsl_writel_be(u32 v, unsigned __iomem *p)
+{
+        out_be32(p, v);
+}
+
+static void _fsl_writel_le(u32 v, unsigned __iomem *p)
+{
+        out_le32(p, v);
+}
+
+static u32 (*_fsl_readl)(const unsigned __iomem *p);
+static void (*_fsl_writel)(u32 v, unsigned __iomem *p);
+
+#define fsl_readl(p)            (*_fsl_readl)((p))
+#define fsl_writel(v, p)        (*_fsl_writel)((v), (p))
+
+static inline void fsl_set_accessors(struct fsl_usb2_platform_data *pdata)
+{
+        if (pdata->big_endian_mmio) {
+                _fsl_readl = _fsl_readl_be;
+                _fsl_writel = _fsl_writel_be;
+        } else {
+                _fsl_readl = _fsl_readl_le;
+                _fsl_writel = _fsl_writel_le;
+        }
+}
+
+static inline u32 cpu_to_hc32(const u32 x)
+{
+        return udc_controller->pdata->big_endian_desc
+                ? (__force u32)cpu_to_be32(x)
+                : (__force u32)cpu_to_le32(x);
+}
+
+static inline u32 hc32_to_cpu(const u32 x)
+{
+        return udc_controller->pdata->big_endian_desc
+                ? be32_to_cpu((__force __be32)x)
+                : le32_to_cpu((__force __le32)x);
+}
+#else /* !CONFIG_PPC32 */
+static inline void fsl_set_accessors(struct fsl_usb2_platform_data *pdata) {}
+
 #define fsl_readl(addr)         readl(addr)
 #define fsl_writel(val32, addr) writel(val32, addr)
-#endif
+#define cpu_to_hc32(x)          cpu_to_le32(x)
+#define hc32_to_cpu(x)          le32_to_cpu(x)
+#endif /* CONFIG_PPC32 */
 
 /********************************************************************
  *      Internal Used Function
@@ -177,7 +243,8 @@ static void nuke(struct fsl_ep *ep, int status)
 
 static int dr_controller_setup(struct fsl_udc *udc)
 {
-        unsigned int tmp, portctrl;
+        unsigned int tmp, portctrl, ep_num;
+        unsigned int max_no_of_ep;
 #ifndef CONFIG_ARCH_MXC
         unsigned int ctrl;
 #endif
@@ -226,9 +293,12 @@ static int dr_controller_setup(struct fsl_udc *udc)
 
         /* Set the controller as device mode */
         tmp = fsl_readl(&dr_regs->usbmode);
+        tmp &= ~USB_MODE_CTRL_MODE_MASK;        /* clear mode bits */
         tmp |= USB_MODE_CTRL_MODE_DEVICE;
         /* Disable Setup Lockout */
         tmp |= USB_MODE_SETUP_LOCK_OFF;
+        if (udc->pdata->es)
+                tmp |= USB_MODE_ES;
         fsl_writel(tmp, &dr_regs->usbmode);
 
         /* Clear the setup status */
@@ -242,22 +312,34 @@ static int dr_controller_setup(struct fsl_udc *udc)
                 udc->ep_qh, (int)tmp,
                 fsl_readl(&dr_regs->endpointlistaddr));
 
+        max_no_of_ep = (0x0000001F & fsl_readl(&dr_regs->dccparams));
+        for (ep_num = 1; ep_num < max_no_of_ep; ep_num++) {
+                tmp = fsl_readl(&dr_regs->endptctrl[ep_num]);
+                tmp &= ~(EPCTRL_TX_TYPE | EPCTRL_RX_TYPE);
+                tmp |= (EPCTRL_EP_TYPE_BULK << EPCTRL_TX_EP_TYPE_SHIFT)
+                | (EPCTRL_EP_TYPE_BULK << EPCTRL_RX_EP_TYPE_SHIFT);
+                fsl_writel(tmp, &dr_regs->endptctrl[ep_num]);
+        }
         /* Config control enable i/o output, cpu endian register */
 #ifndef CONFIG_ARCH_MXC
-        ctrl = __raw_readl(&usb_sys_regs->control);
-        ctrl |= USB_CTRL_IOENB;
-        __raw_writel(ctrl, &usb_sys_regs->control);
+        if (udc->pdata->have_sysif_regs) {
+                ctrl = __raw_readl(&usb_sys_regs->control);
+                ctrl |= USB_CTRL_IOENB;
+                __raw_writel(ctrl, &usb_sys_regs->control);
+        }
 #endif
 
 #if defined(CONFIG_PPC32) && !defined(CONFIG_NOT_COHERENT_CACHE)
         /* Turn on cache snooping hardware, since some PowerPC platforms
          * wholly rely on hardware to deal with cache coherent. */
 
-        /* Setup Snooping for all the 4GB space */
-        tmp = SNOOP_SIZE_2GB;   /* starts from 0x0, size 2G */
-        __raw_writel(tmp, &usb_sys_regs->snoop1);
-        tmp |= 0x80000000;      /* starts from 0x8000000, size 2G */
-        __raw_writel(tmp, &usb_sys_regs->snoop2);
+        if (udc->pdata->have_sysif_regs) {
+                /* Setup Snooping for all the 4GB space */
+                tmp = SNOOP_SIZE_2GB;   /* starts from 0x0, size 2G */
+                __raw_writel(tmp, &usb_sys_regs->snoop1);
+                tmp |= 0x80000000;      /* starts from 0x8000000, size 2G */
+                __raw_writel(tmp, &usb_sys_regs->snoop2);
+        }
 #endif
 
         return 0;
@@ -287,14 +369,25 @@ static void dr_controller_run(struct fsl_udc *udc)
         temp = fsl_readl(&dr_regs->usbcmd);
         temp |= USB_CMD_RUN_STOP;
         fsl_writel(temp, &dr_regs->usbcmd);
-
-        return;
 }
 
 static void dr_controller_stop(struct fsl_udc *udc)
 {
         unsigned int tmp;
 
+        pr_debug("%s\n", __func__);
+
+        /* if we're in OTG mode, and the Host is currently using the port,
+         * stop now and don't rip the controller out from under the
+         * ehci driver
+         */
+        if (udc->gadget.is_otg) {
+                if (!(fsl_readl(&dr_regs->otgsc) & OTGSC_STS_USB_ID)) {
+                        pr_debug("udc: Leaving early\n");
+                        return;
+                }
+        }
+
         /* disable all INTR */
         fsl_writel(0, &dr_regs->usbintr);
 
@@ -308,8 +401,6 @@ static void dr_controller_stop(struct fsl_udc *udc)
         tmp = fsl_readl(&dr_regs->usbcmd);
         tmp &= ~USB_CMD_RUN_STOP;
         fsl_writel(tmp, &dr_regs->usbcmd);
-
-        return;
 }
 
 static void dr_ep_setup(unsigned char ep_num, unsigned char dir,
@@ -322,12 +413,14 @@ static void dr_ep_setup(unsigned char ep_num, unsigned char dir,
                 if (ep_num)
                         tmp_epctrl |= EPCTRL_TX_DATA_TOGGLE_RST;
                 tmp_epctrl |= EPCTRL_TX_ENABLE;
+                tmp_epctrl &= ~EPCTRL_TX_TYPE;
                 tmp_epctrl |= ((unsigned int)(ep_type)
                                 << EPCTRL_TX_EP_TYPE_SHIFT);
         } else {
                 if (ep_num)
                         tmp_epctrl |= EPCTRL_RX_DATA_TOGGLE_RST;
                 tmp_epctrl |= EPCTRL_RX_ENABLE;
+                tmp_epctrl &= ~EPCTRL_RX_TYPE;
                 tmp_epctrl |= ((unsigned int)(ep_type)
                                 << EPCTRL_RX_EP_TYPE_SHIFT);
         }
@@ -413,11 +506,9 @@ static void struct_ep_qh_setup(struct fsl_udc *udc, unsigned char ep_num,
         if (zlt)
                 tmp |= EP_QUEUE_HEAD_ZLT_SEL;
 
-        p_QH->max_pkt_length = cpu_to_le32(tmp);
+        p_QH->max_pkt_length = cpu_to_hc32(tmp);
         p_QH->next_dtd_ptr = 1;
         p_QH->size_ioc_int_sts = 0;
-
-        return;
 }
 
 /* Setup qh structure and ep register for ep0. */
@@ -470,7 +561,7 @@ static int fsl_ep_enable(struct usb_ep *_ep,
 
         max = le16_to_cpu(desc->wMaxPacketSize);
 
-        /* Disable automatic zlp generation.  Driver is reponsible to indicate
+        /* Disable automatic zlp generation.  Driver is responsible to indicate
          * explicitly through req->req.zero.  This is needed to enable multi-td
          * request. */
         zlt = 1;
@@ -552,10 +643,13 @@ static int fsl_ep_disable(struct usb_ep *_ep)
         /* disable ep on controller */
         ep_num = ep_index(ep);
         epctrl = fsl_readl(&dr_regs->endptctrl[ep_num]);
-        if (ep_is_in(ep))
-                epctrl &= ~EPCTRL_TX_ENABLE;
-        else
-                epctrl &= ~EPCTRL_RX_ENABLE;
+        if (ep_is_in(ep)) {
+                epctrl &= ~(EPCTRL_TX_ENABLE | EPCTRL_TX_TYPE);
+                epctrl |= EPCTRL_EP_TYPE_BULK << EPCTRL_TX_EP_TYPE_SHIFT;
+        } else {
+                epctrl &= ~(EPCTRL_RX_ENABLE | EPCTRL_TX_TYPE);
+                epctrl |= EPCTRL_EP_TYPE_BULK << EPCTRL_RX_EP_TYPE_SHIFT;
+        }
         fsl_writel(epctrl, &dr_regs->endptctrl[ep_num]);
 
         udc = (struct fsl_udc *)ep->udc;
@@ -622,7 +716,7 @@ static void fsl_queue_td(struct fsl_ep *ep, struct fsl_req *req)
                 struct fsl_req *lastreq;
                 lastreq = list_entry(ep->queue.prev, struct fsl_req, queue);
                 lastreq->tail->next_td_ptr =
-                        cpu_to_le32(req->head->td_dma & DTD_ADDR_MASK);
+                        cpu_to_hc32(req->head->td_dma & DTD_ADDR_MASK);
                 /* Read prime bit, if 1 goto done */
                 if (fsl_readl(&dr_regs->endpointprime) & bitmask)
                         goto out;
@@ -647,14 +741,14 @@ static void fsl_queue_td(struct fsl_ep *ep, struct fsl_req *req)
 
         /* Write dQH next pointer and terminate bit to 0 */
         temp = req->head->td_dma & EP_QUEUE_HEAD_NEXT_POINTER_MASK;
-        dQH->next_dtd_ptr = cpu_to_le32(temp);
+        dQH->next_dtd_ptr = cpu_to_hc32(temp);
 
         /* Clear active and halt bit */
-        temp = cpu_to_le32(~(EP_QUEUE_HEAD_STATUS_ACTIVE
+        temp = cpu_to_hc32(~(EP_QUEUE_HEAD_STATUS_ACTIVE
                         | EP_QUEUE_HEAD_STATUS_HALT));
         dQH->size_ioc_int_sts &= temp;
 
-        /* Ensure that updates to the QH will occure before priming. */
+        /* Ensure that updates to the QH will occur before priming. */
         wmb();
 
         /* Prime endpoint by writing 1 to ENDPTPRIME */
@@ -688,17 +782,17 @@ static struct ep_td_struct *fsl_build_dtd(struct fsl_req *req, unsigned *length,
 
         dtd->td_dma = *dma;
         /* Clear reserved field */
-        swap_temp = cpu_to_le32(dtd->size_ioc_sts);
+        swap_temp = hc32_to_cpu(dtd->size_ioc_sts);
         swap_temp &= ~DTD_RESERVED_FIELDS;
-        dtd->size_ioc_sts = cpu_to_le32(swap_temp);
+        dtd->size_ioc_sts = cpu_to_hc32(swap_temp);
 
         /* Init all of buffer page pointers */
         swap_temp = (u32) (req->req.dma + req->req.actual);
-        dtd->buff_ptr0 = cpu_to_le32(swap_temp);
-        dtd->buff_ptr1 = cpu_to_le32(swap_temp + 0x1000);
-        dtd->buff_ptr2 = cpu_to_le32(swap_temp + 0x2000);
-        dtd->buff_ptr3 = cpu_to_le32(swap_temp + 0x3000);
-        dtd->buff_ptr4 = cpu_to_le32(swap_temp + 0x4000);
+        dtd->buff_ptr0 = cpu_to_hc32(swap_temp);
+        dtd->buff_ptr1 = cpu_to_hc32(swap_temp + 0x1000);
+        dtd->buff_ptr2 = cpu_to_hc32(swap_temp + 0x2000);
+        dtd->buff_ptr3 = cpu_to_hc32(swap_temp + 0x3000);
+        dtd->buff_ptr4 = cpu_to_hc32(swap_temp + 0x4000);
 
         req->req.actual += *length;
 
@@ -722,7 +816,7 @@ static struct ep_td_struct *fsl_build_dtd(struct fsl_req *req, unsigned *length,
         if (*is_last && !req->req.no_interrupt)
                 swap_temp |= DTD_IOC;
 
-        dtd->size_ioc_sts = cpu_to_le32(swap_temp);
+        dtd->size_ioc_sts = cpu_to_hc32(swap_temp);
 
         mb();
 
@@ -749,7 +843,7 @@ static int fsl_req_to_dtd(struct fsl_req *req)
                         is_first = 0;
                         req->head = dtd;
                 } else {
-                        last_dtd->next_td_ptr = cpu_to_le32(dma);
+                        last_dtd->next_td_ptr = cpu_to_hc32(dma);
                         last_dtd->next_td_virt = dtd;
                 }
                 last_dtd = dtd;
@@ -757,7 +851,7 @@ static int fsl_req_to_dtd(struct fsl_req *req)
                 req->dtd_count++;
         } while (!is_last);
 
-        dtd->next_td_ptr = cpu_to_le32(DTD_NEXT_TERMINATE);
+        dtd->next_td_ptr = cpu_to_hc32(DTD_NEXT_TERMINATE);
 
         req->tail = dtd;
 
@@ -772,7 +866,6 @@ fsl_ep_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
         struct fsl_req *req = container_of(_req, struct fsl_req, req);
         struct fsl_udc *udc;
         unsigned long flags;
-        int is_iso = 0;
 
         /* catch various bogus parameters */
         if (!_req || !req->req.complete || !req->req.buf
@@ -787,7 +880,6 @@ fsl_ep_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
         if (ep->desc->bmAttributes == USB_ENDPOINT_XFER_ISOC) {
                 if (req->req.length > ep->ep.maxpacket)
                         return -EMSGSIZE;
-                is_iso = 1;
         }
 
         udc = ep->udc;
@@ -970,6 +1062,36 @@ out:
         return status;
 }
 
+static int fsl_ep_fifo_status(struct usb_ep *_ep)
+{
+        struct fsl_ep *ep;
+        struct fsl_udc *udc;
+        int size = 0;
+        u32 bitmask;
+        struct ep_queue_head *d_qh;
+
+        ep = container_of(_ep, struct fsl_ep, ep);
+        if (!_ep || (!ep->desc && ep_index(ep) != 0))
+                return -ENODEV;
+
+        udc = (struct fsl_udc *)ep->udc;
+
+        if (!udc->driver || udc->gadget.speed == USB_SPEED_UNKNOWN)
+                return -ESHUTDOWN;
+
+        d_qh = &ep->udc->ep_qh[ep_index(ep) * 2 + ep_is_in(ep)];
+
+        bitmask = (ep_is_in(ep)) ? (1 << (ep_index(ep) + 16)) :
+            (1 << (ep_index(ep)));
+
+        if (fsl_readl(&dr_regs->endptstatus) & bitmask)
+                size = (d_qh->size_ioc_int_sts & DTD_PACKET_SIZE)
+                    >> DTD_LENGTH_BIT_POS;
+
+        pr_debug("%s %u\n", __func__, size);
+        return size;
+}
+
 static void fsl_ep_fifo_flush(struct usb_ep *_ep)
 {
         struct fsl_ep *ep;
@@ -1022,6 +1144,7 @@ static struct usb_ep_ops fsl_ep_ops = {
         .dequeue = fsl_ep_dequeue,
 
         .set_halt = fsl_ep_set_halt,
+        .fifo_status = fsl_ep_fifo_status,
         .fifo_flush = fsl_ep_fifo_flush,        /* flush fifo */
 };
 
@@ -1166,6 +1289,11 @@ static int ep0_prime_status(struct fsl_udc *udc, int direction)
         req->req.complete = NULL;
         req->dtd_count = 0;
 
+        req->req.dma = dma_map_single(ep->udc->gadget.dev.parent,
+                        req->req.buf, req->req.length,
+                        ep_is_in(ep) ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
+        req->mapped = 1;
+
         if (fsl_req_to_dtd(req) == 0)
                 fsl_queue_td(ep, req);
         else
@@ -1236,6 +1364,7 @@ static void ch9getstatus(struct fsl_udc *udc, u8 request_type, u16 value,
         req = udc->status_req;
         /* Fill in the reqest structure */
         *((u16 *) req->req.buf) = cpu_to_le16(tmp);
+
         req->ep = ep;
         req->req.length = 2;
         req->req.status = -EINPROGRESS;
@@ -1243,6 +1372,11 @@ static void ch9getstatus(struct fsl_udc *udc, u8 request_type, u16 value,
         req->req.complete = NULL;
         req->dtd_count = 0;
 
+        req->req.dma = dma_map_single(ep->udc->gadget.dev.parent,
+                                req->req.buf, req->req.length,
+                                ep_is_in(ep) ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
+        req->mapped = 1;
+
         /* prime the data phase */
         if ((fsl_req_to_dtd(req) == 0))
                 fsl_queue_td(ep, req);
@@ -1288,6 +1422,7 @@ static void setup_received_irq(struct fsl_udc *udc,
                 /* Status phase from udc */
         {
                 int rc = -EOPNOTSUPP;
+                u16 ptc = 0;
 
                 if ((setup->bRequestType & (USB_RECIP_MASK | USB_TYPE_MASK))
                                 == (USB_RECIP_ENDPOINT | USB_TYPE_STANDARD)) {
@@ -1309,17 +1444,19 @@ static void setup_received_irq(struct fsl_udc *udc,
                                 | USB_TYPE_STANDARD)) {
                         /* Note: The driver has not include OTG support yet.
                          * This will be set when OTG support is added */
-                        if (!gadget_is_otg(&udc->gadget))
-                                break;
-                        else if (setup->bRequest == USB_DEVICE_B_HNP_ENABLE)
-                                udc->gadget.b_hnp_enable = 1;
-                        else if (setup->bRequest == USB_DEVICE_A_HNP_SUPPORT)
-                                udc->gadget.a_hnp_support = 1;
-                        else if (setup->bRequest ==
-                                        USB_DEVICE_A_ALT_HNP_SUPPORT)
-                                udc->gadget.a_alt_hnp_support = 1;
-                        else
-                                break;
+                        if (wValue == USB_DEVICE_TEST_MODE)
+                                ptc = wIndex >> 8;
+                        else if (gadget_is_otg(&udc->gadget)) {
+                                if (setup->bRequest ==
+                                    USB_DEVICE_B_HNP_ENABLE)
+                                        udc->gadget.b_hnp_enable = 1;
+                                else if (setup->bRequest ==
+                                         USB_DEVICE_A_HNP_SUPPORT)
+                                        udc->gadget.a_hnp_support = 1;
+                                else if (setup->bRequest ==
+                                         USB_DEVICE_A_ALT_HNP_SUPPORT)
+                                        udc->gadget.a_alt_hnp_support = 1;
+                        }
                         rc = 0;
                 } else
                         break;
@@ -1328,6 +1465,15 @@ static void setup_received_irq(struct fsl_udc *udc,
                         if (ep0_prime_status(udc, EP_DIR_IN))
                                 ep0stall(udc);
                 }
+                if (ptc) {
+                        u32 tmp;
+
+                        mdelay(10);
+                        tmp = fsl_readl(&dr_regs->portsc1) | (ptc << 16);
+                        fsl_writel(tmp, &dr_regs->portsc1);
+                        printk(KERN_INFO "udc: switch to test mode %d.\n", ptc);
+                }
+
                 return;
         }
 
@@ -1402,6 +1548,7 @@ static void tripwire_handler(struct fsl_udc *udc, u8 ep_num, u8 *buffer_ptr)
 {
         u32 temp;
         struct ep_queue_head *qh;
+        struct fsl_usb2_platform_data *pdata = udc->pdata;
 
         qh = &udc->ep_qh[ep_num * 2 + EP_DIR_OUT];
 
@@ -1416,7 +1563,16 @@ static void tripwire_handler(struct fsl_udc *udc, u8 ep_num, u8 *buffer_ptr)
                 fsl_writel(temp | USB_CMD_SUTW, &dr_regs->usbcmd);
 
                 /* Copy the setup packet to local buffer */
-                memcpy(buffer_ptr, (u8 *) qh->setup_buffer, 8);
+                if (pdata->le_setup_buf) {
+                        u32 *p = (u32 *)buffer_ptr;
+                        u32 *s = (u32 *)qh->setup_buffer;
+
+                        /* Convert little endian setup buffer to CPU endian */
+                        *p++ = le32_to_cpu(*s++);
+                        *p = le32_to_cpu(*s);
+                } else {
+                        memcpy(buffer_ptr, (u8 *) qh->setup_buffer, 8);
+                }
         } while (!(fsl_readl(&dr_regs->usbcmd) & USB_CMD_SUTW));
 
         /* Clear Setup Tripwire */
@@ -1440,19 +1596,19 @@ static int process_ep_req(struct fsl_udc *udc, int pipe,
         actual = curr_req->req.length;
 
         for (j = 0; j < curr_req->dtd_count; j++) {
-                remaining_length = (le32_to_cpu(curr_td->size_ioc_sts)
+                remaining_length = (hc32_to_cpu(curr_td->size_ioc_sts)
                                         & DTD_PACKET_SIZE)
                                 >> DTD_LENGTH_BIT_POS;
                 actual -= remaining_length;
 
-                if ((errors = le32_to_cpu(curr_td->size_ioc_sts) &
-                                                DTD_ERROR_MASK)) {
+                errors = hc32_to_cpu(curr_td->size_ioc_sts);
+                if (errors & DTD_ERROR_MASK) {
                         if (errors & DTD_STATUS_HALTED) {
                                 ERR("dTD error %08x QH=%d\n", errors, pipe);
                                 /* Clear the errors and Halt condition */
-                                tmp = le32_to_cpu(curr_qh->size_ioc_int_sts);
+                                tmp = hc32_to_cpu(curr_qh->size_ioc_int_sts);
                                 tmp &= ~errors;
-                                curr_qh->size_ioc_int_sts = cpu_to_le32(tmp);
+                                curr_qh->size_ioc_int_sts = cpu_to_hc32(tmp);
                                 status = -EPIPE;
                                 /* FIXME: continue with next queued TD? */
 
@@ -1467,10 +1623,10 @@ static int process_ep_req(struct fsl_udc *udc, int pipe,
                                 status = -EILSEQ;
                                 break;
                         } else
-                                ERR("Unknown error has occured (0x%x)!\n",
+                                ERR("Unknown error has occurred (0x%x)!\n",
                                         errors);
 
-                } else if (le32_to_cpu(curr_td->size_ioc_sts)
+                } else if (hc32_to_cpu(curr_td->size_ioc_sts)
                                 & DTD_STATUS_ACTIVE) {
                         VDBG("Request not complete");
                         status = REQ_UNCOMPLETE;
@@ -1559,6 +1715,9 @@ static void port_change_irq(struct fsl_udc *udc)
 {
         u32 speed;
 
+        if (udc->bus_reset)
+                udc->bus_reset = 0;
+
         /* Bus resetting is finished */
         if (!(fsl_readl(&dr_regs->portsc1) & PORTSCX_PORT_RESET)) {
                 /* Get the speed */
@@ -1666,6 +1825,8 @@ static void reset_irq(struct fsl_udc *udc)
 
         if (fsl_readl(&dr_regs->portsc1) & PORTSCX_PORT_RESET) {
                 VDBG("Bus reset");
+                /* Bus is reseting */
+                udc->bus_reset = 1;
                 /* Reset all the queues, include XD, dTD, EP queue
                  * head and TR Queue */
                 reset_queues(udc);
@@ -1743,6 +1904,7 @@ static irqreturn_t fsl_udc_irq(int irq, void *_udc)
 
         /* Reset Received */
         if (irq_src & USB_STS_RESET) {
+                VDBG("reset int");
                 reset_irq(udc);
                 status = IRQ_HANDLED;
         }
@@ -1765,7 +1927,8 @@ static irqreturn_t fsl_udc_irq(int irq, void *_udc)
  * Hook to gadget drivers
  * Called by initialization code of gadget drivers
 *----------------------------------------------------------------*/
-int usb_gadget_register_driver(struct usb_gadget_driver *driver)
+int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
+                int (*bind)(struct usb_gadget *))
 {
         int retval = -ENODEV;
         unsigned long flags = 0;
@@ -1775,8 +1938,7 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver)
 
         if (!driver || (driver->speed != USB_SPEED_FULL
                                 && driver->speed != USB_SPEED_HIGH)
-                        || !driver->bind || !driver->disconnect
-                        || !driver->setup)
+                        || !bind || !driver->disconnect || !driver->setup)
                 return -EINVAL;
 
         if (udc_controller->driver)
@@ -1792,7 +1954,7 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver)
         spin_unlock_irqrestore(&udc_controller->lock, flags);
 
         /* bind udc driver to gadget driver */
-        retval = driver->bind(&udc_controller->gadget);
+        retval = bind(&udc_controller->gadget);
         if (retval) {
                 VDBG("bind to %s --> %d", driver->driver.name, retval);
                 udc_controller->gadget.dev.driver = NULL;
@@ -1800,11 +1962,30 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver)
                 goto out;
         }
 
-        /* Enable DR IRQ reg and Set usbcmd reg  Run bit */
-        dr_controller_run(udc_controller);
-        udc_controller->usb_state = USB_STATE_ATTACHED;
-        udc_controller->ep0_state = WAIT_FOR_SETUP;
-        udc_controller->ep0_dir = 0;
+        if (udc_controller->transceiver) {
+                /* Suspend the controller until OTG enable it */
+                udc_controller->stopped = 1;
+                printk(KERN_INFO "Suspend udc for OTG auto detect\n");
+
+                /* connect to bus through transceiver */
+                if (udc_controller->transceiver) {
+                        retval = otg_set_peripheral(udc_controller->transceiver,
+                                                    &udc_controller->gadget);
+                        if (retval < 0) {
+                                ERR("can't bind to transceiver\n");
+                                driver->unbind(&udc_controller->gadget);
+                                udc_controller->gadget.dev.driver = 0;
+                                udc_controller->driver = 0;
+                                return retval;
+                        }
+                }
+        } else {
+                /* Enable DR IRQ reg and set USBCMD reg Run bit */
+                dr_controller_run(udc_controller);
+                udc_controller->usb_state = USB_STATE_ATTACHED;
+                udc_controller->ep0_state = WAIT_FOR_SETUP;
+                udc_controller->ep0_dir = 0;
+        }
         printk(KERN_INFO "%s: bind to driver %s\n",
                         udc_controller->gadget.name, driver->driver.name);
 
@@ -1814,7 +1995,7 @@ out:
                        retval);
         return retval;
 }
-EXPORT_SYMBOL(usb_gadget_register_driver);
+EXPORT_SYMBOL(usb_gadget_probe_driver);
 
 /* Disconnect from gadget driver */
 int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
@@ -2052,16 +2233,18 @@ static int fsl_proc_read(char *page, char **start, off_t off, int count,
         next += t;
 
 #ifndef CONFIG_ARCH_MXC
-        tmp_reg = usb_sys_regs->snoop1;
-        t = scnprintf(next, size, "Snoop1 Reg : = [0x%x]\n\n", tmp_reg);
-        size -= t;
-        next += t;
+        if (udc->pdata->have_sysif_regs) {
+                tmp_reg = usb_sys_regs->snoop1;
+                t = scnprintf(next, size, "Snoop1 Reg : = [0x%x]\n\n", tmp_reg);
+                size -= t;
+                next += t;
 
-        tmp_reg = usb_sys_regs->control;
-        t = scnprintf(next, size, "General Control Reg : = [0x%x]\n\n",
-                        tmp_reg);
-        size -= t;
-        next += t;
+                tmp_reg = usb_sys_regs->control;
+                t = scnprintf(next, size, "General Control Reg : = [0x%x]\n\n",
+                                tmp_reg);
+                size -= t;
+                next += t;
+        }
 #endif
 
         /* ------fsl_udc, fsl_ep, fsl_request structure information ----- */
@@ -2190,7 +2373,6 @@ static int __init struct_udc_setup(struct fsl_udc *udc,
                         struct fsl_req, req);
         /* allocate a small amount of memory to get valid address */
         udc->status_req->req.buf = kmalloc(8, GFP_KERNEL);
-        udc->status_req->req.dma = virt_to_phys(udc->status_req->req.buf);
 
         udc->resume_state = USB_STATE_NOTATTACHED;
         udc->usb_state = USB_STATE_POWERED;
@@ -2241,6 +2423,7 @@ static int __init struct_ep_setup(struct fsl_udc *udc, unsigned char index,
  */
 static int __init fsl_udc_probe(struct platform_device *pdev)
 {
+        struct fsl_usb2_platform_data *pdata;
         struct resource *res;
         int ret = -ENODEV;
         unsigned int i;
@@ -2257,20 +2440,35 @@ static int __init fsl_udc_probe(struct platform_device *pdev)
                 return -ENOMEM;
         }
 
+        pdata = pdev->dev.platform_data;
+        udc_controller->pdata = pdata;
         spin_lock_init(&udc_controller->lock);
         udc_controller->stopped = 1;
 
+#ifdef CONFIG_USB_OTG
+        if (pdata->operating_mode == FSL_USB2_DR_OTG) {
+                udc_controller->transceiver = otg_get_transceiver();
+                if (!udc_controller->transceiver) {
+                        ERR("Can't find OTG driver!\n");
+                        ret = -ENODEV;
+                        goto err_kfree;
+                }
+        }
+#endif
+
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (!res) {
                 ret = -ENXIO;
                 goto err_kfree;
         }
 
-        if (!request_mem_region(res->start, res->end - res->start + 1,
-                                driver_name)) {
-                ERR("request mem region for %s failed\n", pdev->name);
-                ret = -EBUSY;
-                goto err_kfree;
+        if (pdata->operating_mode == FSL_USB2_DR_DEVICE) {
+                if (!request_mem_region(res->start, res->end - res->start + 1,
+                                        driver_name)) {
+                        ERR("request mem region for %s failed\n", pdev->name);
+                        ret = -EBUSY;
+                        goto err_kfree;
+                }
         }
 
         dr_regs = ioremap(res->start, resource_size(res));
@@ -2279,9 +2477,23 @@ static int __init fsl_udc_probe(struct platform_device *pdev)
                 goto err_release_mem_region;
         }
 
+        pdata->regs = (void *)dr_regs;
+
+        /*
+         * do platform specific init: check the clock, grab/config pins, etc.
+         */
+        if (pdata->init && pdata->init(pdev)) {
+                ret = -ENODEV;
+                goto err_iounmap_noclk;
+        }
+
+        /* Set accessors only after pdata->init() ! */
+        fsl_set_accessors(pdata);
+
 #ifndef CONFIG_ARCH_MXC
-        usb_sys_regs = (struct usb_sys_interface *)
-                        ((u32)dr_regs + USB_DR_SYS_OFFSET);
+        if (pdata->have_sysif_regs)
+                usb_sys_regs = (struct usb_sys_interface *)
+                                ((u32)dr_regs + USB_DR_SYS_OFFSET);
 #endif
 
         /* Initialize USB clocks */
@@ -2321,9 +2533,11 @@ static int __init fsl_udc_probe(struct platform_device *pdev)
                 goto err_free_irq;
         }
 
-        /* initialize usb hw reg except for regs for EP,
-         * leave usbintr reg untouched */
-        dr_controller_setup(udc_controller);
+        if (!udc_controller->transceiver) {
+                /* initialize usb hw reg except for regs for EP,
+                 * leave usbintr reg untouched */
+                dr_controller_setup(udc_controller);
+        }
 
         fsl_udc_clk_finalize(pdev);
 
@@ -2343,6 +2557,9 @@ static int __init fsl_udc_probe(struct platform_device *pdev)
         if (ret < 0)
                 goto err_free_irq;
 
+        if (udc_controller->transceiver)
+                udc_controller->gadget.is_otg = 1;
+
         /* setup QH and epctrl for ep0 */
         ep0_setup(udc_controller);
 
@@ -2381,11 +2598,14 @@ err_unregister:
 err_free_irq:
         free_irq(udc_controller->irq, udc_controller);
 err_iounmap:
+        if (pdata->exit)
+                pdata->exit(pdev);
         fsl_udc_clk_release();
 err_iounmap_noclk:
         iounmap(dr_regs);
 err_release_mem_region:
-        release_mem_region(res->start, res->end - res->start + 1);
+        if (pdata->operating_mode == FSL_USB2_DR_DEVICE)
+                release_mem_region(res->start, res->end - res->start + 1);
 err_kfree:
         kfree(udc_controller);
         udc_controller = NULL;
@@ -2398,6 +2618,7 @@ err_kfree:
 static int __exit fsl_udc_remove(struct platform_device *pdev)
 {
         struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        struct fsl_usb2_platform_data *pdata = pdev->dev.platform_data;
 
         DECLARE_COMPLETION(done);
 
@@ -2418,12 +2639,20 @@ static int __exit fsl_udc_remove(struct platform_device *pdev)
         dma_pool_destroy(udc_controller->td_pool);
         free_irq(udc_controller->irq, udc_controller);
         iounmap(dr_regs);
-        release_mem_region(res->start, res->end - res->start + 1);
+        if (pdata->operating_mode == FSL_USB2_DR_DEVICE)
+                release_mem_region(res->start, res->end - res->start + 1);
 
         device_unregister(&udc_controller->gadget.dev);
         /* free udc --wait for the release() finished */
         wait_for_completion(&done);
 
+        /*
+         * do platform specific un-initialization:
+         * release iomux pins, etc.
+         */
+        if (pdata->exit)
+                pdata->exit(pdev);
+
         return 0;
 }
 
@@ -2454,6 +2683,62 @@ static int fsl_udc_resume(struct platform_device *pdev)
         return 0;
 }
 
+static int fsl_udc_otg_suspend(struct device *dev, pm_message_t state)
+{
+        struct fsl_udc *udc = udc_controller;
+        u32 mode, usbcmd;
+
+        mode = fsl_readl(&dr_regs->usbmode) & USB_MODE_CTRL_MODE_MASK;
+
+        pr_debug("%s(): mode 0x%x stopped %d\n", __func__, mode, udc->stopped);
+
+        /*
+         * If the controller is already stopped, then this must be a
+         * PM suspend.  Remember this fact, so that we will leave the
+         * controller stopped at PM resume time.
+         */
+        if (udc->stopped) {
+                pr_debug("gadget already stopped, leaving early\n");
+                udc->already_stopped = 1;
+                return 0;
+        }
+
+        if (mode != USB_MODE_CTRL_MODE_DEVICE) {
+                pr_debug("gadget not in device mode, leaving early\n");
+                return 0;
+        }
+
+        /* stop the controller */
+        usbcmd = fsl_readl(&dr_regs->usbcmd) & ~USB_CMD_RUN_STOP;
+        fsl_writel(usbcmd, &dr_regs->usbcmd);
+
+        udc->stopped = 1;
+
+        pr_info("USB Gadget suspended\n");
+
+        return 0;
+}
+
+static int fsl_udc_otg_resume(struct device *dev)
+{
+        pr_debug("%s(): stopped %d  already_stopped %d\n", __func__,
+                 udc_controller->stopped, udc_controller->already_stopped);
+
+        /*
+         * If the controller was stopped at suspend time, then
+         * don't resume it now.
+         */
+        if (udc_controller->already_stopped) {
+                udc_controller->already_stopped = 0;
+                pr_debug("gadget was already stopped, leaving early\n");
+                return 0;
+        }
+
+        pr_info("USB Gadget resume\n");
+
+        return fsl_udc_resume(NULL);
+}
+
 /*-------------------------------------------------------------------------
         Register entry point for the peripheral controller driver
 --------------------------------------------------------------------------*/
@@ -2466,6 +2751,9 @@ static struct platform_driver udc_driver = {
         .driver  = {
                 .name = (char *)driver_name,
                 .owner = THIS_MODULE,
+                /* udc suspend/resume called from OTG driver */
+                .suspend = fsl_udc_otg_suspend,
+                .resume  = fsl_udc_otg_resume,
         },
 };
 
diff --git a/drivers/usb/gadget/fsl_usb2_udc.h b/drivers/usb/gadget/fsl_usb2_udc.h
index 20aeceed48c7..1d51be83fda8 100644
--- a/drivers/usb/gadget/fsl_usb2_udc.h
+++ b/drivers/usb/gadget/fsl_usb2_udc.h
@@ -15,7 +15,7 @@ struct usb_dr_device {
         u8 res1[256];
         u16 caplength;          /* Capability Register Length */
         u16 hciversion;         /* Host Controller Interface Version */
-        u32 hcsparams;          /* Host Controller Structual Parameters */
+        u32 hcsparams;          /* Host Controller Structural Parameters */
         u32 hccparams;          /* Host Controller Capability Parameters */
         u8 res2[20];
         u32 dciversion;         /* Device Controller Interface Version */
@@ -52,7 +52,7 @@ struct usb_dr_host {
         u8 res1[256];
         u16 caplength;          /* Capability Register Length */
         u16 hciversion;         /* Host Controller Interface Version */
-        u32 hcsparams;          /* Host Controller Structual Parameters */
+        u32 hcsparams;          /* Host Controller Structural Parameters */
         u32 hccparams;          /* Host Controller Capability Parameters */
         u8 res2[20];
         u32 dciversion;         /* Device Controller Interface Version */
@@ -275,7 +275,9 @@ struct usb_sys_interface {
 #define  USB_MODE_CTRL_MODE_IDLE              0x00000000
 #define  USB_MODE_CTRL_MODE_DEVICE            0x00000002
 #define  USB_MODE_CTRL_MODE_HOST              0x00000003
+#define  USB_MODE_CTRL_MODE_MASK              0x00000003
 #define  USB_MODE_CTRL_MODE_RSV               0x00000001
+#define  USB_MODE_ES                          0x00000004 /* Endian Select */
 #define  USB_MODE_SETUP_LOCK_OFF              0x00000008
 #define  USB_MODE_STREAM_DISABLE              0x00000010
 /* Endpoint Flush Register */
@@ -461,6 +463,7 @@ struct fsl_ep {
 struct fsl_udc {
         struct usb_gadget gadget;
         struct usb_gadget_driver *driver;
+        struct fsl_usb2_platform_data *pdata;
         struct completion *done;        /* to make sure release() is done */
         struct fsl_ep *eps;
         unsigned int max_ep;
@@ -473,6 +476,8 @@ struct fsl_udc {
         unsigned vbus_active:1;
         unsigned stopped:1;
         unsigned remote_wakeup:1;
+        unsigned already_stopped:1;
+        unsigned big_endian_desc:1;
 
         struct ep_queue_head *ep_qh;    /* Endpoints Queue-Head */
         struct fsl_req *status_req;     /* ep0 status request */
@@ -483,6 +488,7 @@ struct fsl_udc {
         dma_addr_t ep_qh_dma;           /* dma address of QH */
 
         u32 max_pipes;          /* Device max pipes */
+        u32 bus_reset;          /* Device is bus resetting */
         u32 resume_state;       /* USB state to resume */
         u32 usb_state;          /* USB current state */
         u32 ep0_state;          /* Endpoint zero state */
diff --git a/drivers/usb/gadget/fusb300_udc.c b/drivers/usb/gadget/fusb300_udc.c
new file mode 100644
index 000000000000..763d462454b9
--- /dev/null
+++ b/drivers/usb/gadget/fusb300_udc.c
@@ -0,0 +1,1744 @@
+/*
+ * Fusb300 UDC (USB gadget)
+ *
+ * Copyright (C) 2010 Faraday Technology Corp.
+ *
+ * Author : Yuan-hsin Chen <yhchen@faraday-tech.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
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * 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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+#include <linux/dma-mapping.h>
+#include <linux/err.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/platform_device.h>
+#include <linux/usb/ch9.h>
+#include <linux/usb/gadget.h>
+
+#include "fusb300_udc.h"
+
+MODULE_DESCRIPTION("FUSB300  USB gadget driver");
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Yuan Hsin Chen <yhchen@faraday-tech.com>");
+MODULE_ALIAS("platform:fusb300_udc");
+
+#define DRIVER_VERSION  "20 October 2010"
+
+static const char udc_name[] = "fusb300_udc";
+static const char * const fusb300_ep_name[] = {
+        "ep0", "ep1", "ep2", "ep3", "ep4", "ep5", "ep6", "ep7", "ep8", "ep9",
+        "ep10", "ep11", "ep12", "ep13", "ep14", "ep15"
+};
+
+static void done(struct fusb300_ep *ep, struct fusb300_request *req,
+                 int status);
+
+static void fusb300_enable_bit(struct fusb300 *fusb300, u32 offset,
+                               u32 value)
+{
+        u32 reg = ioread32(fusb300->reg + offset);
+
+        reg |= value;
+        iowrite32(reg, fusb300->reg + offset);
+}
+
+static void fusb300_disable_bit(struct fusb300 *fusb300, u32 offset,
+                                u32 value)
+{
+        u32 reg = ioread32(fusb300->reg + offset);
+
+        reg &= ~value;
+        iowrite32(reg, fusb300->reg + offset);
+}
+
+
+static void fusb300_ep_setting(struct fusb300_ep *ep,
+                               struct fusb300_ep_info info)
+{
+        ep->epnum = info.epnum;
+        ep->type = info.type;
+}
+
+static int fusb300_ep_release(struct fusb300_ep *ep)
+{
+        if (!ep->epnum)
+                return 0;
+        ep->epnum = 0;
+        ep->stall = 0;
+        ep->wedged = 0;
+        return 0;
+}
+
+static void fusb300_set_fifo_entry(struct fusb300 *fusb300,
+                                   u32 ep)
+{
+        u32 val = ioread32(fusb300->reg + FUSB300_OFFSET_EPSET1(ep));
+
+        val &= ~FUSB300_EPSET1_FIFOENTRY_MSK;
+        val |= FUSB300_EPSET1_FIFOENTRY(FUSB300_FIFO_ENTRY_NUM);
+        iowrite32(val, fusb300->reg + FUSB300_OFFSET_EPSET1(ep));
+}
+
+static void fusb300_set_start_entry(struct fusb300 *fusb300,
+                                    u8 ep)
+{
+        u32 reg = ioread32(fusb300->reg + FUSB300_OFFSET_EPSET1(ep));
+        u32 start_entry = fusb300->fifo_entry_num * FUSB300_FIFO_ENTRY_NUM;
+
+        reg &= ~FUSB300_EPSET1_START_ENTRY_MSK  ;
+        reg |= FUSB300_EPSET1_START_ENTRY(start_entry);
+        iowrite32(reg, fusb300->reg + FUSB300_OFFSET_EPSET1(ep));
+        if (fusb300->fifo_entry_num == FUSB300_MAX_FIFO_ENTRY) {
+                fusb300->fifo_entry_num = 0;
+                fusb300->addrofs = 0;
+                pr_err("fifo entry is over the maximum number!\n");
+        } else
+                fusb300->fifo_entry_num++;
+}
+
+/* set fusb300_set_start_entry first before fusb300_set_epaddrofs */
+static void fusb300_set_epaddrofs(struct fusb300 *fusb300,
+                                  struct fusb300_ep_info info)
+{
+        u32 reg = ioread32(fusb300->reg + FUSB300_OFFSET_EPSET2(info.epnum));
+
+        reg &= ~FUSB300_EPSET2_ADDROFS_MSK;
+        reg |= FUSB300_EPSET2_ADDROFS(fusb300->addrofs);
+        iowrite32(reg, fusb300->reg + FUSB300_OFFSET_EPSET2(info.epnum));
+        fusb300->addrofs += (info.maxpacket + 7) / 8 * FUSB300_FIFO_ENTRY_NUM;
+}
+
+static void ep_fifo_setting(struct fusb300 *fusb300,
+                            struct fusb300_ep_info info)
+{
+        fusb300_set_fifo_entry(fusb300, info.epnum);
+        fusb300_set_start_entry(fusb300, info.epnum);
+        fusb300_set_epaddrofs(fusb300, info);
+}
+
+static void fusb300_set_eptype(struct fusb300 *fusb300,
+                               struct fusb300_ep_info info)
+{
+        u32 reg = ioread32(fusb300->reg + FUSB300_OFFSET_EPSET1(info.epnum));
+
+        reg &= ~FUSB300_EPSET1_TYPE_MSK;
+        reg |= FUSB300_EPSET1_TYPE(info.type);
+        iowrite32(reg, fusb300->reg + FUSB300_OFFSET_EPSET1(info.epnum));
+}
+
+static void fusb300_set_epdir(struct fusb300 *fusb300,
+                              struct fusb300_ep_info info)
+{
+        u32 reg;
+
+        if (!info.dir_in)
+                return;
+        reg = ioread32(fusb300->reg + FUSB300_OFFSET_EPSET1(info.epnum));
+        reg &= ~FUSB300_EPSET1_DIR_MSK;
+        reg |= FUSB300_EPSET1_DIRIN;
+        iowrite32(reg, fusb300->reg + FUSB300_OFFSET_EPSET1(info.epnum));
+}
+
+static void fusb300_set_ep_active(struct fusb300 *fusb300,
+                          u8 ep)
+{
+        u32 reg = ioread32(fusb300->reg + FUSB300_OFFSET_EPSET1(ep));
+
+        reg |= FUSB300_EPSET1_ACTEN;
+        iowrite32(reg, fusb300->reg + FUSB300_OFFSET_EPSET1(ep));
+}
+
+static void fusb300_set_epmps(struct fusb300 *fusb300,
+                              struct fusb300_ep_info info)
+{
+        u32 reg = ioread32(fusb300->reg + FUSB300_OFFSET_EPSET2(info.epnum));
+
+        reg &= ~FUSB300_EPSET2_MPS_MSK;
+        reg |= FUSB300_EPSET2_MPS(info.maxpacket);
+        iowrite32(reg, fusb300->reg + FUSB300_OFFSET_EPSET2(info.epnum));
+}
+
+static void fusb300_set_interval(struct fusb300 *fusb300,
+                                 struct fusb300_ep_info info)
+{
+        u32 reg = ioread32(fusb300->reg + FUSB300_OFFSET_EPSET1(info.epnum));
+
+        reg &= ~FUSB300_EPSET1_INTERVAL(0x7);
+        reg |= FUSB300_EPSET1_INTERVAL(info.interval);
+        iowrite32(reg, fusb300->reg + FUSB300_OFFSET_EPSET1(info.epnum));
+}
+
+static void fusb300_set_bwnum(struct fusb300 *fusb300,
+                              struct fusb300_ep_info info)
+{
+        u32 reg = ioread32(fusb300->reg + FUSB300_OFFSET_EPSET1(info.epnum));
+
+        reg &= ~FUSB300_EPSET1_BWNUM(0x3);
+        reg |= FUSB300_EPSET1_BWNUM(info.bw_num);
+        iowrite32(reg, fusb300->reg + FUSB300_OFFSET_EPSET1(info.epnum));
+}
+
+static void set_ep_reg(struct fusb300 *fusb300,
+                      struct fusb300_ep_info info)
+{
+        fusb300_set_eptype(fusb300, info);
+        fusb300_set_epdir(fusb300, info);
+        fusb300_set_epmps(fusb300, info);
+
+        if (info.interval)
+                fusb300_set_interval(fusb300, info);
+
+        if (info.bw_num)
+                fusb300_set_bwnum(fusb300, info);
+
+        fusb300_set_ep_active(fusb300, info.epnum);
+}
+
+static int config_ep(struct fusb300_ep *ep,
+                     const struct usb_endpoint_descriptor *desc)
+{
+        struct fusb300 *fusb300 = ep->fusb300;
+        struct fusb300_ep_info info;
+
+        ep->desc = desc;
+
+        info.interval = 0;
+        info.addrofs = 0;
+        info.bw_num = 0;
+
+        info.type = desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK;
+        info.dir_in = (desc->bEndpointAddress & USB_ENDPOINT_DIR_MASK) ? 1 : 0;
+        info.maxpacket = le16_to_cpu(desc->wMaxPacketSize);
+        info.epnum = desc->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
+
+        if ((info.type == USB_ENDPOINT_XFER_INT) ||
+           (info.type == USB_ENDPOINT_XFER_ISOC)) {
+                info.interval = desc->bInterval;
+                if (info.type == USB_ENDPOINT_XFER_ISOC)
+                        info.bw_num = ((desc->wMaxPacketSize & 0x1800) >> 11);
+        }
+
+        ep_fifo_setting(fusb300, info);
+
+        set_ep_reg(fusb300, info);
+
+        fusb300_ep_setting(ep, info);
+
+        fusb300->ep[info.epnum] = ep;
+
+        return 0;
+}
+
+static int fusb300_enable(struct usb_ep *_ep,
+                          const struct usb_endpoint_descriptor *desc)
+{
+        struct fusb300_ep *ep;
+
+        ep = container_of(_ep, struct fusb300_ep, ep);
+
+        if (ep->fusb300->reenum) {
+                ep->fusb300->fifo_entry_num = 0;
+                ep->fusb300->addrofs = 0;
+                ep->fusb300->reenum = 0;
+        }
+
+        return config_ep(ep, desc);
+}
+
+static int fusb300_disable(struct usb_ep *_ep)
+{
+        struct fusb300_ep *ep;
+        struct fusb300_request *req;
+        unsigned long flags;
+
+        ep = container_of(_ep, struct fusb300_ep, ep);
+
+        BUG_ON(!ep);
+
+        while (!list_empty(&ep->queue)) {
+                req = list_entry(ep->queue.next, struct fusb300_request, queue);
+                spin_lock_irqsave(&ep->fusb300->lock, flags);
+                done(ep, req, -ECONNRESET);
+                spin_unlock_irqrestore(&ep->fusb300->lock, flags);
+        }
+
+        return fusb300_ep_release(ep);
+}
+
+static struct usb_request *fusb300_alloc_request(struct usb_ep *_ep,
+                                                gfp_t gfp_flags)
+{
+        struct fusb300_request *req;
+
+        req = kzalloc(sizeof(struct fusb300_request), gfp_flags);
+        if (!req)
+                return NULL;
+        INIT_LIST_HEAD(&req->queue);
+
+        return &req->req;
+}
+
+static void fusb300_free_request(struct usb_ep *_ep, struct usb_request *_req)
+{
+        struct fusb300_request *req;
+
+        req = container_of(_req, struct fusb300_request, req);
+        kfree(req);
+}
+
+static int enable_fifo_int(struct fusb300_ep *ep)
+{
+        struct fusb300 *fusb300 = ep->fusb300;
+
+        if (ep->epnum) {
+                fusb300_enable_bit(fusb300, FUSB300_OFFSET_IGER0,
+                        FUSB300_IGER0_EEPn_FIFO_INT(ep->epnum));
+        } else {
+                pr_err("can't enable_fifo_int ep0\n");
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int disable_fifo_int(struct fusb300_ep *ep)
+{
+        struct fusb300 *fusb300 = ep->fusb300;
+
+        if (ep->epnum) {
+                fusb300_disable_bit(fusb300, FUSB300_OFFSET_IGER0,
+                        FUSB300_IGER0_EEPn_FIFO_INT(ep->epnum));
+        } else {
+                pr_err("can't disable_fifo_int ep0\n");
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static void fusb300_set_cxlen(struct fusb300 *fusb300, u32 length)
+{
+        u32 reg;
+
+        reg = ioread32(fusb300->reg + FUSB300_OFFSET_CSR);
+        reg &= ~FUSB300_CSR_LEN_MSK;
+        reg |= FUSB300_CSR_LEN(length);
+        iowrite32(reg, fusb300->reg + FUSB300_OFFSET_CSR);
+}
+
+/* write data to cx fifo */
+static void fusb300_wrcxf(struct fusb300_ep *ep,
+                   struct fusb300_request *req)
+{
+        int i = 0;
+        u8 *tmp;
+        u32 data;
+        struct fusb300 *fusb300 = ep->fusb300;
+        u32 length = req->req.length - req->req.actual;
+
+        tmp = req->req.buf + req->req.actual;
+
+        if (length > SS_CTL_MAX_PACKET_SIZE) {
+                fusb300_set_cxlen(fusb300, SS_CTL_MAX_PACKET_SIZE);
+                for (i = (SS_CTL_MAX_PACKET_SIZE >> 2); i > 0; i--) {
+                        data = *tmp | *(tmp + 1) << 8 | *(tmp + 2) << 16 |
+                                *(tmp + 3) << 24;
+                        iowrite32(data, fusb300->reg + FUSB300_OFFSET_CXPORT);
+                        tmp += 4;
+                }
+                req->req.actual += SS_CTL_MAX_PACKET_SIZE;
+        } else { /* length is less than max packet size */
+                fusb300_set_cxlen(fusb300, length);
+                for (i = length >> 2; i > 0; i--) {
+                        data = *tmp | *(tmp + 1) << 8 | *(tmp + 2) << 16 |
+                                *(tmp + 3) << 24;
+                        printk(KERN_DEBUG "    0x%x\n", data);
+                        iowrite32(data, fusb300->reg + FUSB300_OFFSET_CXPORT);
+                        tmp = tmp + 4;
+                }
+                switch (length % 4) {
+                case 1:
+                        data = *tmp;
+                        printk(KERN_DEBUG "    0x%x\n", data);
+                        iowrite32(data, fusb300->reg + FUSB300_OFFSET_CXPORT);
+                        break;
+                case 2:
+                        data = *tmp | *(tmp + 1) << 8;
+                        printk(KERN_DEBUG "    0x%x\n", data);
+                        iowrite32(data, fusb300->reg + FUSB300_OFFSET_CXPORT);
+                        break;
+                case 3:
+                        data = *tmp | *(tmp + 1) << 8 | *(tmp + 2) << 16;
+                        printk(KERN_DEBUG "    0x%x\n", data);
+                        iowrite32(data, fusb300->reg + FUSB300_OFFSET_CXPORT);
+                        break;
+                default:
+                        break;
+                }
+                req->req.actual += length;
+        }
+}
+
+static void fusb300_set_epnstall(struct fusb300 *fusb300, u8 ep)
+{
+        fusb300_enable_bit(fusb300, FUSB300_OFFSET_EPSET0(ep),
+                FUSB300_EPSET0_STL);
+}
+
+static void fusb300_clear_epnstall(struct fusb300 *fusb300, u8 ep)
+{
+        u32 reg = ioread32(fusb300->reg + FUSB300_OFFSET_EPSET0(ep));
+
+        if (reg & FUSB300_EPSET0_STL) {
+                printk(KERN_DEBUG "EP%d stall... Clear!!\n", ep);
+                reg &= ~FUSB300_EPSET0_STL;
+                iowrite32(reg, fusb300->reg + FUSB300_OFFSET_EPSET0(ep));
+        }
+}
+
+static void ep0_queue(struct fusb300_ep *ep, struct fusb300_request *req)
+{
+        if (ep->fusb300->ep0_dir) { /* if IN */
+                if (req->req.length) {
+                        fusb300_wrcxf(ep, req);
+                } else
+                        printk(KERN_DEBUG "%s : req->req.length = 0x%x\n",
+                                __func__, req->req.length);
+                if ((req->req.length == req->req.actual) ||
+                    (req->req.actual < ep->ep.maxpacket))
+                        done(ep, req, 0);
+        } else { /* OUT */
+                if (!req->req.length)
+                        done(ep, req, 0);
+                else
+                        fusb300_enable_bit(ep->fusb300, FUSB300_OFFSET_IGER1,
+                                FUSB300_IGER1_CX_OUT_INT);
+        }
+}
+
+static int fusb300_queue(struct usb_ep *_ep, struct usb_request *_req,
+                         gfp_t gfp_flags)
+{
+        struct fusb300_ep *ep;
+        struct fusb300_request *req;
+        unsigned long flags;
+        int request  = 0;
+
+        ep = container_of(_ep, struct fusb300_ep, ep);
+        req = container_of(_req, struct fusb300_request, req);
+
+        if (ep->fusb300->gadget.speed == USB_SPEED_UNKNOWN)
+                return -ESHUTDOWN;
+
+        spin_lock_irqsave(&ep->fusb300->lock, flags);
+
+        if (list_empty(&ep->queue))
+                request = 1;
+
+        list_add_tail(&req->queue, &ep->queue);
+
+        req->req.actual = 0;
+        req->req.status = -EINPROGRESS;
+
+        if (ep->desc == NULL) /* ep0 */
+                ep0_queue(ep, req);
+        else if (request && !ep->stall)
+                enable_fifo_int(ep);
+
+        spin_unlock_irqrestore(&ep->fusb300->lock, flags);
+
+        return 0;
+}
+
+static int fusb300_dequeue(struct usb_ep *_ep, struct usb_request *_req)
+{
+        struct fusb300_ep *ep;
+        struct fusb300_request *req;
+        unsigned long flags;
+
+        ep = container_of(_ep, struct fusb300_ep, ep);
+        req = container_of(_req, struct fusb300_request, req);
+
+        spin_lock_irqsave(&ep->fusb300->lock, flags);
+        if (!list_empty(&ep->queue))
+                done(ep, req, -ECONNRESET);
+        spin_unlock_irqrestore(&ep->fusb300->lock, flags);
+
+        return 0;
+}
+
+static int fusb300_set_halt_and_wedge(struct usb_ep *_ep, int value, int wedge)
+{
+        struct fusb300_ep *ep;
+        struct fusb300 *fusb300;
+        unsigned long flags;
+        int ret = 0;
+
+        ep = container_of(_ep, struct fusb300_ep, ep);
+
+        fusb300 = ep->fusb300;
+
+        spin_lock_irqsave(&ep->fusb300->lock, flags);
+
+        if (!list_empty(&ep->queue)) {
+                ret = -EAGAIN;
+                goto out;
+        }
+
+        if (value) {
+                fusb300_set_epnstall(fusb300, ep->epnum);
+                ep->stall = 1;
+                if (wedge)
+                        ep->wedged = 1;
+        } else {
+                fusb300_clear_epnstall(fusb300, ep->epnum);
+                ep->stall = 0;
+                ep->wedged = 0;
+        }
+
+out:
+        spin_unlock_irqrestore(&ep->fusb300->lock, flags);
+        return ret;
+}
+
+static int fusb300_set_halt(struct usb_ep *_ep, int value)
+{
+        return fusb300_set_halt_and_wedge(_ep, value, 0);
+}
+
+static int fusb300_set_wedge(struct usb_ep *_ep)
+{
+        return fusb300_set_halt_and_wedge(_ep, 1, 1);
+}
+
+static void fusb300_fifo_flush(struct usb_ep *_ep)
+{
+}
+
+static struct usb_ep_ops fusb300_ep_ops = {
+        .enable         = fusb300_enable,
+        .disable        = fusb300_disable,
+
+        .alloc_request  = fusb300_alloc_request,
+        .free_request   = fusb300_free_request,
+
+        .queue          = fusb300_queue,
+        .dequeue        = fusb300_dequeue,
+
+        .set_halt       = fusb300_set_halt,
+        .fifo_flush     = fusb300_fifo_flush,
+        .set_wedge      = fusb300_set_wedge,
+};
+
+/*****************************************************************************/
+static void fusb300_clear_int(struct fusb300 *fusb300, u32 offset,
+                       u32 value)
+{
+        iowrite32(value, fusb300->reg + offset);
+}
+
+static void fusb300_reset(void)
+{
+}
+
+static void fusb300_set_cxstall(struct fusb300 *fusb300)
+{
+        fusb300_enable_bit(fusb300, FUSB300_OFFSET_CSR,
+                           FUSB300_CSR_STL);
+}
+
+static void fusb300_set_cxdone(struct fusb300 *fusb300)
+{
+        fusb300_enable_bit(fusb300, FUSB300_OFFSET_CSR,
+                           FUSB300_CSR_DONE);
+}
+
+/* read data from cx fifo */
+void fusb300_rdcxf(struct fusb300 *fusb300,
+                   u8 *buffer, u32 length)
+{
+        int i = 0;
+        u8 *tmp;
+        u32 data;
+
+        tmp = buffer;
+
+        for (i = (length >> 2); i > 0; i--) {
+                data = ioread32(fusb300->reg + FUSB300_OFFSET_CXPORT);
+                printk(KERN_DEBUG "    0x%x\n", data);
+                *tmp = data & 0xFF;
+                *(tmp + 1) = (data >> 8) & 0xFF;
+                *(tmp + 2) = (data >> 16) & 0xFF;
+                *(tmp + 3) = (data >> 24) & 0xFF;
+                tmp = tmp + 4;
+        }
+
+        switch (length % 4) {
+        case 1:
+                data = ioread32(fusb300->reg + FUSB300_OFFSET_CXPORT);
+                printk(KERN_DEBUG "    0x%x\n", data);
+                *tmp = data & 0xFF;
+                break;
+        case 2:
+                data = ioread32(fusb300->reg + FUSB300_OFFSET_CXPORT);
+                printk(KERN_DEBUG "    0x%x\n", data);
+                *tmp = data & 0xFF;
+                *(tmp + 1) = (data >> 8) & 0xFF;
+                break;
+        case 3:
+                data = ioread32(fusb300->reg + FUSB300_OFFSET_CXPORT);
+                printk(KERN_DEBUG "    0x%x\n", data);
+                *tmp = data & 0xFF;
+                *(tmp + 1) = (data >> 8) & 0xFF;
+                *(tmp + 2) = (data >> 16) & 0xFF;
+                break;
+        default:
+                break;
+        }
+}
+
+#if 0
+static void fusb300_dbg_fifo(struct fusb300_ep *ep,
+                                u8 entry, u16 length)
+{
+        u32 reg;
+        u32 i = 0;
+        u32 j = 0;
+
+        reg = ioread32(ep->fusb300->reg + FUSB300_OFFSET_GTM);
+        reg &= ~(FUSB300_GTM_TST_EP_ENTRY(0xF) |
+                FUSB300_GTM_TST_EP_NUM(0xF) | FUSB300_GTM_TST_FIFO_DEG);
+        reg |= (FUSB300_GTM_TST_EP_ENTRY(entry) |
+                FUSB300_GTM_TST_EP_NUM(ep->epnum) | FUSB300_GTM_TST_FIFO_DEG);
+        iowrite32(reg, ep->fusb300->reg + FUSB300_OFFSET_GTM);
+
+        for (i = 0; i < (length >> 2); i++) {
+                if (i * 4 == 1024)
+                        break;
+                reg = ioread32(ep->fusb300->reg +
+                        FUSB300_OFFSET_BUFDBG_START + i * 4);
+                printk(KERN_DEBUG"  0x%-8x", reg);
+                j++;
+                if ((j % 4)  == 0)
+                        printk(KERN_DEBUG "\n");
+        }
+
+        if (length % 4) {
+                reg = ioread32(ep->fusb300->reg +
+                        FUSB300_OFFSET_BUFDBG_START + i * 4);
+                printk(KERN_DEBUG "  0x%x\n", reg);
+        }
+
+        if ((j % 4)  != 0)
+                printk(KERN_DEBUG "\n");
+
+        fusb300_disable_bit(ep->fusb300, FUSB300_OFFSET_GTM,
+                FUSB300_GTM_TST_FIFO_DEG);
+}
+
+static void fusb300_cmp_dbg_fifo(struct fusb300_ep *ep,
+                                u8 entry, u16 length, u8 *golden)
+{
+        u32 reg;
+        u32 i = 0;
+        u32 golden_value;
+        u8 *tmp;
+
+        tmp = golden;
+
+        printk(KERN_DEBUG "fusb300_cmp_dbg_fifo (entry %d) : start\n", entry);
+
+        reg = ioread32(ep->fusb300->reg + FUSB300_OFFSET_GTM);
+        reg &= ~(FUSB300_GTM_TST_EP_ENTRY(0xF) |
+                FUSB300_GTM_TST_EP_NUM(0xF) | FUSB300_GTM_TST_FIFO_DEG);
+        reg |= (FUSB300_GTM_TST_EP_ENTRY(entry) |
+                FUSB300_GTM_TST_EP_NUM(ep->epnum) | FUSB300_GTM_TST_FIFO_DEG);
+        iowrite32(reg, ep->fusb300->reg + FUSB300_OFFSET_GTM);
+
+        for (i = 0; i < (length >> 2); i++) {
+                if (i * 4 == 1024)
+                        break;
+                golden_value = *tmp | *(tmp + 1) << 8 |
+                                *(tmp + 2) << 16 | *(tmp + 3) << 24;
+
+                reg = ioread32(ep->fusb300->reg +
+                        FUSB300_OFFSET_BUFDBG_START + i*4);
+
+                if (reg != golden_value) {
+                        printk(KERN_DEBUG "0x%x  :  ", (u32)(ep->fusb300->reg +
+                                FUSB300_OFFSET_BUFDBG_START + i*4));
+                        printk(KERN_DEBUG "    golden = 0x%x, reg = 0x%x\n",
+                                golden_value, reg);
+                }
+                tmp += 4;
+        }
+
+        switch (length % 4) {
+        case 1:
+                golden_value = *tmp;
+        case 2:
+                golden_value = *tmp | *(tmp + 1) << 8;
+        case 3:
+                golden_value = *tmp | *(tmp + 1) << 8 | *(tmp + 2) << 16;
+        default:
+                break;
+
+        reg = ioread32(ep->fusb300->reg + FUSB300_OFFSET_BUFDBG_START + i*4);
+        if (reg != golden_value) {
+                printk(KERN_DEBUG "0x%x:", (u32)(ep->fusb300->reg +
+                        FUSB300_OFFSET_BUFDBG_START + i*4));
+                printk(KERN_DEBUG "  golden = 0x%x, reg = 0x%x\n",
+                        golden_value, reg);
+        }
+        }
+
+        printk(KERN_DEBUG "fusb300_cmp_dbg_fifo : end\n");
+        fusb300_disable_bit(ep->fusb300, FUSB300_OFFSET_GTM,
+                FUSB300_GTM_TST_FIFO_DEG);
+}
+#endif
+
+static void fusb300_rdfifo(struct fusb300_ep *ep,
+                          struct fusb300_request *req,
+                          u32 length)
+{
+        int i = 0;
+        u8 *tmp;
+        u32 data, reg;
+        struct fusb300 *fusb300 = ep->fusb300;
+
+        tmp = req->req.buf + req->req.actual;
+        req->req.actual += length;
+
+        if (req->req.actual > req->req.length)
+                printk(KERN_DEBUG "req->req.actual > req->req.length\n");
+
+        for (i = (length >> 2); i > 0; i--) {
+                data = ioread32(fusb300->reg +
+                        FUSB300_OFFSET_EPPORT(ep->epnum));
+                *tmp = data & 0xFF;
+                *(tmp + 1) = (data >> 8) & 0xFF;
+                *(tmp + 2) = (data >> 16) & 0xFF;
+                *(tmp + 3) = (data >> 24) & 0xFF;
+                tmp = tmp + 4;
+        }
+
+        switch (length % 4) {
+        case 1:
+                data = ioread32(fusb300->reg +
+                        FUSB300_OFFSET_EPPORT(ep->epnum));
+                *tmp = data & 0xFF;
+                break;
+        case 2:
+                data = ioread32(fusb300->reg +
+                        FUSB300_OFFSET_EPPORT(ep->epnum));
+                *tmp = data & 0xFF;
+                *(tmp + 1) = (data >> 8) & 0xFF;
+                break;
+        case 3:
+                data = ioread32(fusb300->reg +
+                        FUSB300_OFFSET_EPPORT(ep->epnum));
+                *tmp = data & 0xFF;
+                *(tmp + 1) = (data >> 8) & 0xFF;
+                *(tmp + 2) = (data >> 16) & 0xFF;
+                break;
+        default:
+                break;
+        }
+
+        do {
+                reg = ioread32(fusb300->reg + FUSB300_OFFSET_IGR1);
+                reg &= FUSB300_IGR1_SYNF0_EMPTY_INT;
+                if (i)
+                        printk(KERN_INFO "sync fifo is not empty!\n");
+                i++;
+        } while (!reg);
+}
+
+/* write data to fifo */
+static void fusb300_wrfifo(struct fusb300_ep *ep,
+                           struct fusb300_request *req)
+{
+        int i = 0;
+        u8 *tmp;
+        u32 data, reg;
+        struct fusb300 *fusb300 = ep->fusb300;
+
+        tmp = req->req.buf;
+        req->req.actual = req->req.length;
+
+        for (i = (req->req.length >> 2); i > 0; i--) {
+                data = *tmp | *(tmp + 1) << 8 |
+                        *(tmp + 2) << 16 | *(tmp + 3) << 24;
+
+                iowrite32(data, fusb300->reg +
+                        FUSB300_OFFSET_EPPORT(ep->epnum));
+                tmp += 4;
+        }
+
+        switch (req->req.length % 4) {
+        case 1:
+                data = *tmp;
+                iowrite32(data, fusb300->reg +
+                        FUSB300_OFFSET_EPPORT(ep->epnum));
+                break;
+        case 2:
+                data = *tmp | *(tmp + 1) << 8;
+                iowrite32(data, fusb300->reg +
+                        FUSB300_OFFSET_EPPORT(ep->epnum));
+                break;
+        case 3:
+                data = *tmp | *(tmp + 1) << 8 | *(tmp + 2) << 16;
+                iowrite32(data, fusb300->reg +
+                        FUSB300_OFFSET_EPPORT(ep->epnum));
+                break;
+        default:
+                break;
+        }
+
+        do {
+                reg = ioread32(fusb300->reg + FUSB300_OFFSET_IGR1);
+                reg &= FUSB300_IGR1_SYNF0_EMPTY_INT;
+                if (i)
+                        printk(KERN_INFO"sync fifo is not empty!\n");
+                i++;
+        } while (!reg);
+}
+
+static u8 fusb300_get_epnstall(struct fusb300 *fusb300, u8 ep)
+{
+        u8 value;
+        u32 reg = ioread32(fusb300->reg + FUSB300_OFFSET_EPSET0(ep));
+
+        value = reg & FUSB300_EPSET0_STL;
+
+        return value;
+}
+
+static u8 fusb300_get_cxstall(struct fusb300 *fusb300)
+{
+        u8 value;
+        u32 reg = ioread32(fusb300->reg + FUSB300_OFFSET_CSR);
+
+        value = (reg & FUSB300_CSR_STL) >> 1;
+
+        return value;
+}
+
+static void request_error(struct fusb300 *fusb300)
+{
+        fusb300_set_cxstall(fusb300);
+        printk(KERN_DEBUG "request error!!\n");
+}
+
+static void get_status(struct fusb300 *fusb300, struct usb_ctrlrequest *ctrl)
+__releases(fusb300->lock)
+__acquires(fusb300->lock)
+{
+        u8 ep;
+        u16 status = 0;
+        u16 w_index = ctrl->wIndex;
+
+        switch (ctrl->bRequestType & USB_RECIP_MASK) {
+        case USB_RECIP_DEVICE:
+                status = 1 << USB_DEVICE_SELF_POWERED;
+                break;
+        case USB_RECIP_INTERFACE:
+                status = 0;
+                break;
+        case USB_RECIP_ENDPOINT:
+                ep = w_index & USB_ENDPOINT_NUMBER_MASK;
+                if (ep) {
+                        if (fusb300_get_epnstall(fusb300, ep))
+                                status = 1 << USB_ENDPOINT_HALT;
+                } else {
+                        if (fusb300_get_cxstall(fusb300))
+                                status = 0;
+                }
+                break;
+
+        default:
+                request_error(fusb300);
+                return;         /* exit */
+        }
+
+        fusb300->ep0_data = cpu_to_le16(status);
+        fusb300->ep0_req->buf = &fusb300->ep0_data;
+        fusb300->ep0_req->length = 2;
+
+        spin_unlock(&fusb300->lock);
+        fusb300_queue(fusb300->gadget.ep0, fusb300->ep0_req, GFP_KERNEL);
+        spin_lock(&fusb300->lock);
+}
+
+static void set_feature(struct fusb300 *fusb300, struct usb_ctrlrequest *ctrl)
+{
+        u8 ep;
+
+        switch (ctrl->bRequestType & USB_RECIP_MASK) {
+        case USB_RECIP_DEVICE:
+                fusb300_set_cxdone(fusb300);
+                break;
+        case USB_RECIP_INTERFACE:
+                fusb300_set_cxdone(fusb300);
+                break;
+        case USB_RECIP_ENDPOINT: {
+                u16 w_index = le16_to_cpu(ctrl->wIndex);
+
+                ep = w_index & USB_ENDPOINT_NUMBER_MASK;
+                if (ep)
+                        fusb300_set_epnstall(fusb300, ep);
+                else
+                        fusb300_set_cxstall(fusb300);
+                fusb300_set_cxdone(fusb300);
+                }
+                break;
+        default:
+                request_error(fusb300);
+                break;
+        }
+}
+
+static void fusb300_clear_seqnum(struct fusb300 *fusb300, u8 ep)
+{
+        fusb300_enable_bit(fusb300, FUSB300_OFFSET_EPSET0(ep),
+                            FUSB300_EPSET0_CLRSEQNUM);
+}
+
+static void clear_feature(struct fusb300 *fusb300, struct usb_ctrlrequest *ctrl)
+{
+        struct fusb300_ep *ep =
+                fusb300->ep[ctrl->wIndex & USB_ENDPOINT_NUMBER_MASK];
+
+        switch (ctrl->bRequestType & USB_RECIP_MASK) {
+        case USB_RECIP_DEVICE:
+                fusb300_set_cxdone(fusb300);
+                break;
+        case USB_RECIP_INTERFACE:
+                fusb300_set_cxdone(fusb300);
+                break;
+        case USB_RECIP_ENDPOINT:
+                if (ctrl->wIndex & USB_ENDPOINT_NUMBER_MASK) {
+                        if (ep->wedged) {
+                                fusb300_set_cxdone(fusb300);
+                                break;
+                        }
+                        if (ep->stall) {
+                                ep->stall = 0;
+                                fusb300_clear_seqnum(fusb300, ep->epnum);
+                                fusb300_clear_epnstall(fusb300, ep->epnum);
+                                if (!list_empty(&ep->queue))
+                                        enable_fifo_int(ep);
+                        }
+                }
+                fusb300_set_cxdone(fusb300);
+                break;
+        default:
+                request_error(fusb300);
+                break;
+        }
+}
+
+static void fusb300_set_dev_addr(struct fusb300 *fusb300, u16 addr)
+{
+        u32 reg = ioread32(fusb300->reg + FUSB300_OFFSET_DAR);
+
+        reg &= ~FUSB300_DAR_DRVADDR_MSK;
+        reg |= FUSB300_DAR_DRVADDR(addr);
+
+        iowrite32(reg, fusb300->reg + FUSB300_OFFSET_DAR);
+}
+
+static void set_address(struct fusb300 *fusb300, struct usb_ctrlrequest *ctrl)
+{
+        if (ctrl->wValue >= 0x0100)
+                request_error(fusb300);
+        else {
+                fusb300_set_dev_addr(fusb300, ctrl->wValue);
+                fusb300_set_cxdone(fusb300);
+        }
+}
+
+#define UVC_COPY_DESCRIPTORS(mem, src) \
+        do { \
+                const struct usb_descriptor_header * const *__src; \
+                for (__src = src; *__src; ++__src) { \
+                        memcpy(mem, *__src, (*__src)->bLength); \
+                        mem += (*__src)->bLength; \
+                } \
+        } while (0)
+
+static void fusb300_ep0_complete(struct usb_ep *ep,
+                                struct usb_request *req)
+{
+}
+
+static int setup_packet(struct fusb300 *fusb300, struct usb_ctrlrequest *ctrl)
+{
+        u8 *p = (u8 *)ctrl;
+        u8 ret = 0;
+        u8 i = 0;
+
+        fusb300_rdcxf(fusb300, p, 8);
+        fusb300->ep0_dir = ctrl->bRequestType & USB_DIR_IN;
+        fusb300->ep0_length = ctrl->wLength;
+
+        /* check request */
+        if ((ctrl->bRequestType & USB_TYPE_MASK) == USB_TYPE_STANDARD) {
+                switch (ctrl->bRequest) {
+                case USB_REQ_GET_STATUS:
+                        get_status(fusb300, ctrl);
+                        break;
+                case USB_REQ_CLEAR_FEATURE:
+                        clear_feature(fusb300, ctrl);
+                        break;
+                case USB_REQ_SET_FEATURE:
+                        set_feature(fusb300, ctrl);
+                        break;
+                case USB_REQ_SET_ADDRESS:
+                        set_address(fusb300, ctrl);
+                        break;
+                case USB_REQ_SET_CONFIGURATION:
+                        fusb300_enable_bit(fusb300, FUSB300_OFFSET_DAR,
+                                           FUSB300_DAR_SETCONFG);
+                        /* clear sequence number */
+                        for (i = 1; i <= FUSB300_MAX_NUM_EP; i++)
+                                fusb300_clear_seqnum(fusb300, i);
+                        fusb300->reenum = 1;
+                        ret = 1;
+                        break;
+                default:
+                        ret = 1;
+                        break;
+                }
+        } else
+                ret = 1;
+
+        return ret;
+}
+
+static void fusb300_set_ep_bycnt(struct fusb300_ep *ep, u32 bycnt)
+{
+        struct fusb300 *fusb300 = ep->fusb300;
+        u32 reg = ioread32(fusb300->reg + FUSB300_OFFSET_EPFFR(ep->epnum));
+
+        reg &= ~FUSB300_FFR_BYCNT;
+        reg |= bycnt & FUSB300_FFR_BYCNT;
+
+        iowrite32(reg, fusb300->reg + FUSB300_OFFSET_EPFFR(ep->epnum));
+}
+
+static void done(struct fusb300_ep *ep, struct fusb300_request *req,
+                 int status)
+{
+        list_del_init(&req->queue);
+
+        /* don't modify queue heads during completion callback */
+        if (ep->fusb300->gadget.speed == USB_SPEED_UNKNOWN)
+                req->req.status = -ESHUTDOWN;
+        else
+                req->req.status = status;
+
+        spin_unlock(&ep->fusb300->lock);
+        req->req.complete(&ep->ep, &req->req);
+        spin_lock(&ep->fusb300->lock);
+
+        if (ep->epnum) {
+                disable_fifo_int(ep);
+                if (!list_empty(&ep->queue))
+                        enable_fifo_int(ep);
+        } else
+                fusb300_set_cxdone(ep->fusb300);
+}
+
+void fusb300_fill_idma_prdtbl(struct fusb300_ep *ep,
+                        struct fusb300_request *req)
+{
+        u32 value;
+        u32 reg;
+
+        /* wait SW owner */
+        do {
+                reg = ioread32(ep->fusb300->reg +
+                        FUSB300_OFFSET_EPPRD_W0(ep->epnum));
+                reg &= FUSB300_EPPRD0_H;
+        } while (reg);
+
+        iowrite32((u32) req->req.buf, ep->fusb300->reg +
+                FUSB300_OFFSET_EPPRD_W1(ep->epnum));
+
+        value = FUSB300_EPPRD0_BTC(req->req.length) | FUSB300_EPPRD0_H |
+                FUSB300_EPPRD0_F | FUSB300_EPPRD0_L | FUSB300_EPPRD0_I;
+        iowrite32(value, ep->fusb300->reg + FUSB300_OFFSET_EPPRD_W0(ep->epnum));
+
+        iowrite32(0x0, ep->fusb300->reg + FUSB300_OFFSET_EPPRD_W2(ep->epnum));
+
+        fusb300_enable_bit(ep->fusb300, FUSB300_OFFSET_EPPRDRDY,
+                FUSB300_EPPRDR_EP_PRD_RDY(ep->epnum));
+}
+
+static void fusb300_wait_idma_finished(struct fusb300_ep *ep)
+{
+        u32 reg;
+
+        do {
+                reg = ioread32(ep->fusb300->reg + FUSB300_OFFSET_IGR1);
+                if ((reg & FUSB300_IGR1_VBUS_CHG_INT) ||
+                    (reg & FUSB300_IGR1_WARM_RST_INT) ||
+                    (reg & FUSB300_IGR1_HOT_RST_INT) ||
+                    (reg & FUSB300_IGR1_USBRST_INT)
+                )
+                        goto IDMA_RESET;
+                reg = ioread32(ep->fusb300->reg + FUSB300_OFFSET_IGR0);
+                reg &= FUSB300_IGR0_EPn_PRD_INT(ep->epnum);
+        } while (!reg);
+
+        fusb300_clear_int(ep->fusb300, FUSB300_OFFSET_IGR0,
+                FUSB300_IGR0_EPn_PRD_INT(ep->epnum));
+IDMA_RESET:
+        fusb300_clear_int(ep->fusb300, FUSB300_OFFSET_IGER0,
+                FUSB300_IGER0_EEPn_PRD_INT(ep->epnum));
+}
+
+static void  fusb300_set_idma(struct fusb300_ep *ep,
+                        struct fusb300_request *req)
+{
+        dma_addr_t d;
+        u8 *tmp = NULL;
+
+        d = dma_map_single(NULL, req->req.buf, req->req.length, DMA_TO_DEVICE);
+
+        if (dma_mapping_error(NULL, d)) {
+                kfree(req->req.buf);
+                printk(KERN_DEBUG "dma_mapping_error\n");
+        }
+
+        dma_sync_single_for_device(NULL, d, req->req.length, DMA_TO_DEVICE);
+
+        fusb300_enable_bit(ep->fusb300, FUSB300_OFFSET_IGER0,
+                FUSB300_IGER0_EEPn_PRD_INT(ep->epnum));
+
+        tmp = req->req.buf;
+        req->req.buf = (u8 *)d;
+
+        fusb300_fill_idma_prdtbl(ep, req);
+        /* check idma is done */
+        fusb300_wait_idma_finished(ep);
+
+        req->req.buf = tmp;
+
+        if (d)
+                dma_unmap_single(NULL, d, req->req.length, DMA_TO_DEVICE);
+}
+
+static void in_ep_fifo_handler(struct fusb300_ep *ep)
+{
+        struct fusb300_request *req = list_entry(ep->queue.next,
+                                        struct fusb300_request, queue);
+
+        if (req->req.length) {
+#if 0
+                fusb300_set_ep_bycnt(ep, req->req.length);
+                fusb300_wrfifo(ep, req);
+#else
+                fusb300_set_idma(ep, req);
+#endif
+        }
+        done(ep, req, 0);
+}
+
+static void out_ep_fifo_handler(struct fusb300_ep *ep)
+{
+        struct fusb300 *fusb300 = ep->fusb300;
+        struct fusb300_request *req = list_entry(ep->queue.next,
+                                                 struct fusb300_request, queue);
+        u32 reg = ioread32(fusb300->reg + FUSB300_OFFSET_EPFFR(ep->epnum));
+        u32 length = reg & FUSB300_FFR_BYCNT;
+
+        fusb300_rdfifo(ep, req, length);
+
+        /* finish out transfer */
+        if ((req->req.length == req->req.actual) || (length < ep->ep.maxpacket))
+                done(ep, req, 0);
+}
+
+static void check_device_mode(struct fusb300 *fusb300)
+{
+        u32 reg = ioread32(fusb300->reg + FUSB300_OFFSET_GCR);
+
+        switch (reg & FUSB300_GCR_DEVEN_MSK) {
+        case FUSB300_GCR_DEVEN_SS:
+                fusb300->gadget.speed = USB_SPEED_SUPER;
+                break;
+        case FUSB300_GCR_DEVEN_HS:
+                fusb300->gadget.speed = USB_SPEED_HIGH;
+                break;
+        case FUSB300_GCR_DEVEN_FS:
+                fusb300->gadget.speed = USB_SPEED_FULL;
+                break;
+        default:
+                fusb300->gadget.speed = USB_SPEED_UNKNOWN;
+                break;
+        }
+        printk(KERN_INFO "dev_mode = %d\n", (reg & FUSB300_GCR_DEVEN_MSK));
+}
+
+
+static void fusb300_ep0out(struct fusb300 *fusb300)
+{
+        struct fusb300_ep *ep = fusb300->ep[0];
+        u32 reg;
+
+        if (!list_empty(&ep->queue)) {
+                struct fusb300_request *req;
+
+                req = list_first_entry(&ep->queue,
+                        struct fusb300_request, queue);
+                if (req->req.length)
+                        fusb300_rdcxf(ep->fusb300, req->req.buf,
+                                req->req.length);
+                done(ep, req, 0);
+                reg = ioread32(fusb300->reg + FUSB300_OFFSET_IGER1);
+                reg &= ~FUSB300_IGER1_CX_OUT_INT;
+                iowrite32(reg, fusb300->reg + FUSB300_OFFSET_IGER1);
+        } else
+                pr_err("%s : empty queue\n", __func__);
+}
+
+static void fusb300_ep0in(struct fusb300 *fusb300)
+{
+        struct fusb300_request *req;
+        struct fusb300_ep *ep = fusb300->ep[0];
+
+        if ((!list_empty(&ep->queue)) && (fusb300->ep0_dir)) {
+                req = list_entry(ep->queue.next,
+                                struct fusb300_request, queue);
+                if (req->req.length)
+                        fusb300_wrcxf(ep, req);
+                if ((req->req.length - req->req.actual) < ep->ep.maxpacket)
+                        done(ep, req, 0);
+        } else
+                fusb300_set_cxdone(fusb300);
+}
+
+static void fusb300_grp2_handler(void)
+{
+}
+
+static void fusb300_grp3_handler(void)
+{
+}
+
+static void fusb300_grp4_handler(void)
+{
+}
+
+static void fusb300_grp5_handler(void)
+{
+}
+
+static irqreturn_t fusb300_irq(int irq, void *_fusb300)
+{
+        struct fusb300 *fusb300 = _fusb300;
+        u32 int_grp1 = ioread32(fusb300->reg + FUSB300_OFFSET_IGR1);
+        u32 int_grp1_en = ioread32(fusb300->reg + FUSB300_OFFSET_IGER1);
+        u32 int_grp0 = ioread32(fusb300->reg + FUSB300_OFFSET_IGR0);
+        u32 int_grp0_en = ioread32(fusb300->reg + FUSB300_OFFSET_IGER0);
+        struct usb_ctrlrequest ctrl;
+        u8 in;
+        u32 reg;
+        int i;
+
+        spin_lock(&fusb300->lock);
+
+        int_grp1 &= int_grp1_en;
+        int_grp0 &= int_grp0_en;
+
+        if (int_grp1 & FUSB300_IGR1_WARM_RST_INT) {
+                fusb300_clear_int(fusb300, FUSB300_OFFSET_IGR1,
+                                  FUSB300_IGR1_WARM_RST_INT);
+                printk(KERN_INFO"fusb300_warmreset\n");
+                fusb300_reset();
+        }
+
+        if (int_grp1 & FUSB300_IGR1_HOT_RST_INT) {
+                fusb300_clear_int(fusb300, FUSB300_OFFSET_IGR1,
+                                  FUSB300_IGR1_HOT_RST_INT);
+                printk(KERN_INFO"fusb300_hotreset\n");
+                fusb300_reset();
+        }
+
+        if (int_grp1 & FUSB300_IGR1_USBRST_INT) {
+                fusb300_clear_int(fusb300, FUSB300_OFFSET_IGR1,
+                                  FUSB300_IGR1_USBRST_INT);
+                fusb300_reset();
+        }
+        /* COMABT_INT has a highest priority */
+
+        if (int_grp1 & FUSB300_IGR1_CX_COMABT_INT) {
+                fusb300_clear_int(fusb300, FUSB300_OFFSET_IGR1,
+                                  FUSB300_IGR1_CX_COMABT_INT);
+                printk(KERN_INFO"fusb300_ep0abt\n");
+        }
+
+        if (int_grp1 & FUSB300_IGR1_VBUS_CHG_INT) {
+                fusb300_clear_int(fusb300, FUSB300_OFFSET_IGR1,
+                                  FUSB300_IGR1_VBUS_CHG_INT);
+                printk(KERN_INFO"fusb300_vbus_change\n");
+        }
+
+        if (int_grp1 & FUSB300_IGR1_U3_EXIT_FAIL_INT) {
+                fusb300_clear_int(fusb300, FUSB300_OFFSET_IGR1,
+                                  FUSB300_IGR1_U3_EXIT_FAIL_INT);
+        }
+
+        if (int_grp1 & FUSB300_IGR1_U2_EXIT_FAIL_INT) {
+                fusb300_clear_int(fusb300, FUSB300_OFFSET_IGR1,
+                                  FUSB300_IGR1_U2_EXIT_FAIL_INT);
+        }
+
+        if (int_grp1 & FUSB300_IGR1_U1_EXIT_FAIL_INT) {
+                fusb300_clear_int(fusb300, FUSB300_OFFSET_IGR1,
+                                  FUSB300_IGR1_U1_EXIT_FAIL_INT);
+        }
+
+        if (int_grp1 & FUSB300_IGR1_U2_ENTRY_FAIL_INT) {
+                fusb300_clear_int(fusb300, FUSB300_OFFSET_IGR1,
+                                  FUSB300_IGR1_U2_ENTRY_FAIL_INT);
+        }
+
+        if (int_grp1 & FUSB300_IGR1_U1_ENTRY_FAIL_INT) {
+                fusb300_clear_int(fusb300, FUSB300_OFFSET_IGR1,
+                                  FUSB300_IGR1_U1_ENTRY_FAIL_INT);
+        }
+
+        if (int_grp1 & FUSB300_IGR1_U3_EXIT_INT) {
+                fusb300_clear_int(fusb300, FUSB300_OFFSET_IGR1,
+                                  FUSB300_IGR1_U3_EXIT_INT);
+                printk(KERN_INFO "FUSB300_IGR1_U3_EXIT_INT\n");
+        }
+
+        if (int_grp1 & FUSB300_IGR1_U2_EXIT_INT) {
+                fusb300_clear_int(fusb300, FUSB300_OFFSET_IGR1,
+                                  FUSB300_IGR1_U2_EXIT_INT);
+                printk(KERN_INFO "FUSB300_IGR1_U2_EXIT_INT\n");
+        }
+
+        if (int_grp1 & FUSB300_IGR1_U1_EXIT_INT) {
+                fusb300_clear_int(fusb300, FUSB300_OFFSET_IGR1,
+                                  FUSB300_IGR1_U1_EXIT_INT);
+                printk(KERN_INFO "FUSB300_IGR1_U1_EXIT_INT\n");
+        }
+
+        if (int_grp1 & FUSB300_IGR1_U3_ENTRY_INT) {
+                fusb300_clear_int(fusb300, FUSB300_OFFSET_IGR1,
+                                  FUSB300_IGR1_U3_ENTRY_INT);
+                printk(KERN_INFO "FUSB300_IGR1_U3_ENTRY_INT\n");
+                fusb300_enable_bit(fusb300, FUSB300_OFFSET_SSCR1,
+                                   FUSB300_SSCR1_GO_U3_DONE);
+        }
+
+        if (int_grp1 & FUSB300_IGR1_U2_ENTRY_INT) {
+                fusb300_clear_int(fusb300, FUSB300_OFFSET_IGR1,
+                                  FUSB300_IGR1_U2_ENTRY_INT);
+                printk(KERN_INFO "FUSB300_IGR1_U2_ENTRY_INT\n");
+        }
+
+        if (int_grp1 & FUSB300_IGR1_U1_ENTRY_INT) {
+                fusb300_clear_int(fusb300, FUSB300_OFFSET_IGR1,
+                                  FUSB300_IGR1_U1_ENTRY_INT);
+                printk(KERN_INFO "FUSB300_IGR1_U1_ENTRY_INT\n");
+        }
+
+        if (int_grp1 & FUSB300_IGR1_RESM_INT) {
+                fusb300_clear_int(fusb300, FUSB300_OFFSET_IGR1,
+                                  FUSB300_IGR1_RESM_INT);
+                printk(KERN_INFO "fusb300_resume\n");
+        }
+
+        if (int_grp1 & FUSB300_IGR1_SUSP_INT) {
+                fusb300_clear_int(fusb300, FUSB300_OFFSET_IGR1,
+                                  FUSB300_IGR1_SUSP_INT);
+                printk(KERN_INFO "fusb300_suspend\n");
+        }
+
+        if (int_grp1 & FUSB300_IGR1_HS_LPM_INT) {
+                fusb300_clear_int(fusb300, FUSB300_OFFSET_IGR1,
+                                  FUSB300_IGR1_HS_LPM_INT);
+                printk(KERN_INFO "fusb300_HS_LPM_INT\n");
+        }
+
+        if (int_grp1 & FUSB300_IGR1_DEV_MODE_CHG_INT) {
+                fusb300_clear_int(fusb300, FUSB300_OFFSET_IGR1,
+                                  FUSB300_IGR1_DEV_MODE_CHG_INT);
+                check_device_mode(fusb300);
+        }
+
+        if (int_grp1 & FUSB300_IGR1_CX_COMFAIL_INT) {
+                fusb300_set_cxstall(fusb300);
+                printk(KERN_INFO "fusb300_ep0fail\n");
+        }
+
+        if (int_grp1 & FUSB300_IGR1_CX_SETUP_INT) {
+                printk(KERN_INFO "fusb300_ep0setup\n");
+                if (setup_packet(fusb300, &ctrl)) {
+                        spin_unlock(&fusb300->lock);
+                        if (fusb300->driver->setup(&fusb300->gadget, &ctrl) < 0)
+                                fusb300_set_cxstall(fusb300);
+                        spin_lock(&fusb300->lock);
+                }
+        }
+
+        if (int_grp1 & FUSB300_IGR1_CX_CMDEND_INT)
+                printk(KERN_INFO "fusb300_cmdend\n");
+
+
+        if (int_grp1 & FUSB300_IGR1_CX_OUT_INT) {
+                printk(KERN_INFO "fusb300_cxout\n");
+                fusb300_ep0out(fusb300);
+        }
+
+        if (int_grp1 & FUSB300_IGR1_CX_IN_INT) {
+                printk(KERN_INFO "fusb300_cxin\n");
+                fusb300_ep0in(fusb300);
+        }
+
+        if (int_grp1 & FUSB300_IGR1_INTGRP5)
+                fusb300_grp5_handler();
+
+        if (int_grp1 & FUSB300_IGR1_INTGRP4)
+                fusb300_grp4_handler();
+
+        if (int_grp1 & FUSB300_IGR1_INTGRP3)
+                fusb300_grp3_handler();
+
+        if (int_grp1 & FUSB300_IGR1_INTGRP2)
+                fusb300_grp2_handler();
+
+        if (int_grp0) {
+                for (i = 1; i < FUSB300_MAX_NUM_EP; i++) {
+                        if (int_grp0 & FUSB300_IGR0_EPn_FIFO_INT(i)) {
+                                reg = ioread32(fusb300->reg +
+                                        FUSB300_OFFSET_EPSET1(i));
+                                in = (reg & FUSB300_EPSET1_DIRIN) ? 1 : 0;
+                                if (in)
+                                        in_ep_fifo_handler(fusb300->ep[i]);
+                                else
+                                        out_ep_fifo_handler(fusb300->ep[i]);
+                        }
+                }
+        }
+
+        spin_unlock(&fusb300->lock);
+
+        return IRQ_HANDLED;
+}
+
+static void fusb300_set_u2_timeout(struct fusb300 *fusb300,
+                                   u32 time)
+{
+        u32 reg;
+
+        reg = ioread32(fusb300->reg + FUSB300_OFFSET_TT);
+        reg &= ~0xff;
+        reg |= FUSB300_SSCR2_U2TIMEOUT(time);
+
+        iowrite32(reg, fusb300->reg + FUSB300_OFFSET_TT);
+}
+
+static void fusb300_set_u1_timeout(struct fusb300 *fusb300,
+                                   u32 time)
+{
+        u32 reg;
+
+        reg = ioread32(fusb300->reg + FUSB300_OFFSET_TT);
+        reg &= ~(0xff << 8);
+        reg |= FUSB300_SSCR2_U1TIMEOUT(time);
+
+        iowrite32(reg, fusb300->reg + FUSB300_OFFSET_TT);
+}
+
+static void init_controller(struct fusb300 *fusb300)
+{
+        u32 reg;
+        u32 mask = 0;
+        u32 val = 0;
+
+        /* split on */
+        mask = val = FUSB300_AHBBCR_S0_SPLIT_ON | FUSB300_AHBBCR_S1_SPLIT_ON;
+        reg = ioread32(fusb300->reg + FUSB300_OFFSET_AHBCR);
+        reg &= ~mask;
+        reg |= val;
+        iowrite32(reg, fusb300->reg + FUSB300_OFFSET_AHBCR);
+
+        /* enable high-speed LPM */
+        mask = val = FUSB300_HSCR_HS_LPM_PERMIT;
+        reg = ioread32(fusb300->reg + FUSB300_OFFSET_HSCR);
+        reg &= ~mask;
+        reg |= val;
+        iowrite32(reg, fusb300->reg + FUSB300_OFFSET_HSCR);
+
+        /*set u1 u2 timmer*/
+        fusb300_set_u2_timeout(fusb300, 0xff);
+        fusb300_set_u1_timeout(fusb300, 0xff);
+
+        /* enable all grp1 interrupt */
+        iowrite32(0xcfffff9f, fusb300->reg + FUSB300_OFFSET_IGER1);
+}
+/*------------------------------------------------------------------------*/
+static struct fusb300 *the_controller;
+
+int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
+                int (*bind)(struct usb_gadget *))
+{
+        struct fusb300 *fusb300 = the_controller;
+        int retval;
+
+        if (!driver
+                        || driver->speed < USB_SPEED_FULL
+                        || !bind
+                        || !driver->setup)
+                return -EINVAL;
+
+        if (!fusb300)
+                return -ENODEV;
+
+        if (fusb300->driver)
+                return -EBUSY;
+
+        /* hook up the driver */
+        driver->driver.bus = NULL;
+        fusb300->driver = driver;
+        fusb300->gadget.dev.driver = &driver->driver;
+
+        retval = device_add(&fusb300->gadget.dev);
+        if (retval) {
+                pr_err("device_add error (%d)\n", retval);
+                goto error;
+        }
+
+        retval = bind(&fusb300->gadget);
+        if (retval) {
+                pr_err("bind to driver error (%d)\n", retval);
+                device_del(&fusb300->gadget.dev);
+                goto error;
+        }
+
+        return 0;
+
+error:
+        fusb300->driver = NULL;
+        fusb300->gadget.dev.driver = NULL;
+
+        return retval;
+}
+EXPORT_SYMBOL(usb_gadget_probe_driver);
+
+int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
+{
+        struct fusb300 *fusb300 = the_controller;
+
+        if (driver != fusb300->driver || !driver->unbind)
+                return -EINVAL;
+
+        driver->unbind(&fusb300->gadget);
+        fusb300->gadget.dev.driver = NULL;
+
+        init_controller(fusb300);
+        device_del(&fusb300->gadget.dev);
+        fusb300->driver = NULL;
+
+        return 0;
+}
+EXPORT_SYMBOL(usb_gadget_unregister_driver);
+/*--------------------------------------------------------------------------*/
+
+static int fusb300_udc_pullup(struct usb_gadget *_gadget, int is_active)
+{
+        return 0;
+}
+
+static struct usb_gadget_ops fusb300_gadget_ops = {
+        .pullup         = fusb300_udc_pullup,
+};
+
+static int __exit fusb300_remove(struct platform_device *pdev)
+{
+        struct fusb300 *fusb300 = dev_get_drvdata(&pdev->dev);
+
+        iounmap(fusb300->reg);
+        free_irq(platform_get_irq(pdev, 0), fusb300);
+
+        fusb300_free_request(&fusb300->ep[0]->ep, fusb300->ep0_req);
+        kfree(fusb300);
+
+        return 0;
+}
+
+static int __init fusb300_probe(struct platform_device *pdev)
+{
+        struct resource *res, *ires, *ires1;
+        void __iomem *reg = NULL;
+        struct fusb300 *fusb300 = NULL;
+        struct fusb300_ep *_ep[FUSB300_MAX_NUM_EP];
+        int ret = 0;
+        int i;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                ret = -ENODEV;
+                pr_err("platform_get_resource error.\n");
+                goto clean_up;
+        }
+
+        ires = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+        if (!ires) {
+                ret = -ENODEV;
+                dev_err(&pdev->dev,
+                        "platform_get_resource IORESOURCE_IRQ error.\n");
+                goto clean_up;
+        }
+
+        ires1 = platform_get_resource(pdev, IORESOURCE_IRQ, 1);
+        if (!ires1) {
+                ret = -ENODEV;
+                dev_err(&pdev->dev,
+                        "platform_get_resource IORESOURCE_IRQ 1 error.\n");
+                goto clean_up;
+        }
+
+        reg = ioremap(res->start, resource_size(res));
+        if (reg == NULL) {
+                ret = -ENOMEM;
+                pr_err("ioremap error.\n");
+                goto clean_up;
+        }
+
+        /* initialize udc */
+        fusb300 = kzalloc(sizeof(struct fusb300), GFP_KERNEL);
+        if (fusb300 == NULL) {
+                pr_err("kzalloc error\n");
+                goto clean_up;
+        }
+
+        for (i = 0; i < FUSB300_MAX_NUM_EP; i++) {
+                _ep[i] = kzalloc(sizeof(struct fusb300_ep), GFP_KERNEL);
+                if (_ep[i] == NULL) {
+                        pr_err("_ep kzalloc error\n");
+                        goto clean_up;
+                }
+                fusb300->ep[i] = _ep[i];
+        }
+
+        spin_lock_init(&fusb300->lock);
+
+        dev_set_drvdata(&pdev->dev, fusb300);
+
+        fusb300->gadget.ops = &fusb300_gadget_ops;
+
+        device_initialize(&fusb300->gadget.dev);
+
+        dev_set_name(&fusb300->gadget.dev, "gadget");
+
+        fusb300->gadget.is_dualspeed = 1;
+        fusb300->gadget.dev.parent = &pdev->dev;
+        fusb300->gadget.dev.dma_mask = pdev->dev.dma_mask;
+        fusb300->gadget.dev.release = pdev->dev.release;
+        fusb300->gadget.name = udc_name;
+        fusb300->reg = reg;
+
+        ret = request_irq(ires->start, fusb300_irq, IRQF_DISABLED | IRQF_SHARED,
+                          udc_name, fusb300);
+        if (ret < 0) {
+                pr_err("request_irq error (%d)\n", ret);
+                goto clean_up;
+        }
+
+        ret = request_irq(ires1->start, fusb300_irq,
+                        IRQF_DISABLED | IRQF_SHARED, udc_name, fusb300);
+        if (ret < 0) {
+                pr_err("request_irq1 error (%d)\n", ret);
+                goto clean_up;
+        }
+
+        INIT_LIST_HEAD(&fusb300->gadget.ep_list);
+
+        for (i = 0; i < FUSB300_MAX_NUM_EP ; i++) {
+                struct fusb300_ep *ep = fusb300->ep[i];
+
+                if (i != 0) {
+                        INIT_LIST_HEAD(&fusb300->ep[i]->ep.ep_list);
+                        list_add_tail(&fusb300->ep[i]->ep.ep_list,
+                                     &fusb300->gadget.ep_list);
+                }
+                ep->fusb300 = fusb300;
+                INIT_LIST_HEAD(&ep->queue);
+                ep->ep.name = fusb300_ep_name[i];
+                ep->ep.ops = &fusb300_ep_ops;
+                ep->ep.maxpacket = HS_BULK_MAX_PACKET_SIZE;
+        }
+        fusb300->ep[0]->ep.maxpacket = HS_CTL_MAX_PACKET_SIZE;
+        fusb300->ep[0]->epnum = 0;
+        fusb300->gadget.ep0 = &fusb300->ep[0]->ep;
+        INIT_LIST_HEAD(&fusb300->gadget.ep0->ep_list);
+
+        the_controller = fusb300;
+
+        fusb300->ep0_req = fusb300_alloc_request(&fusb300->ep[0]->ep,
+                                GFP_KERNEL);
+        if (fusb300->ep0_req == NULL)
+                goto clean_up3;
+
+        init_controller(fusb300);
+        dev_info(&pdev->dev, "version %s\n", DRIVER_VERSION);
+
+        return 0;
+
+clean_up3:
+        free_irq(ires->start, fusb300);
+
+clean_up:
+        if (fusb300) {
+                if (fusb300->ep0_req)
+                        fusb300_free_request(&fusb300->ep[0]->ep,
+                                fusb300->ep0_req);
+                kfree(fusb300);
+        }
+        if (reg)
+                iounmap(reg);
+
+        return ret;
+}
+
+static struct platform_driver fusb300_driver = {
+        .remove =       __exit_p(fusb300_remove),
+        .driver         = {
+                .name = (char *) udc_name,
+                .owner  = THIS_MODULE,
+        },
+};
+
+static int __init fusb300_udc_init(void)
+{
+        return platform_driver_probe(&fusb300_driver, fusb300_probe);
+}
+
+module_init(fusb300_udc_init);
+
+static void __exit fusb300_udc_cleanup(void)
+{
+        platform_driver_unregister(&fusb300_driver);
+}
+module_exit(fusb300_udc_cleanup);
diff --git a/drivers/usb/gadget/fusb300_udc.h b/drivers/usb/gadget/fusb300_udc.h
new file mode 100644
index 000000000000..f51aa2ef1f90
--- /dev/null
+++ b/drivers/usb/gadget/fusb300_udc.h
@@ -0,0 +1,687 @@
+/*
+ * Fusb300 UDC (USB gadget)
+ *
+ * Copyright (C) 2010 Faraday Technology Corp.
+ *
+ * Author : Yuan-hsin Chen <yhchen@faraday-tech.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
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * 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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+
+#ifndef __FUSB300_UDC_H__
+#define __FUSB300_UDC_H_
+
+#include <linux/kernel.h>
+
+#define FUSB300_OFFSET_GCR              0x00
+#define FUSB300_OFFSET_GTM              0x04
+#define FUSB300_OFFSET_DAR              0x08
+#define FUSB300_OFFSET_CSR              0x0C
+#define FUSB300_OFFSET_CXPORT           0x10
+#define FUSB300_OFFSET_EPSET0(n)        (0x20 + (n - 1) * 0x30)
+#define FUSB300_OFFSET_EPSET1(n)        (0x24 + (n - 1) * 0x30)
+#define FUSB300_OFFSET_EPSET2(n)        (0x28 + (n - 1) * 0x30)
+#define FUSB300_OFFSET_EPFFR(n)         (0x2c + (n - 1) * 0x30)
+#define FUSB300_OFFSET_EPSTRID(n)       (0x40 + (n - 1) * 0x30)
+#define FUSB300_OFFSET_HSPTM            0x300
+#define FUSB300_OFFSET_HSCR             0x304
+#define FUSB300_OFFSET_SSCR0            0x308
+#define FUSB300_OFFSET_SSCR1            0x30C
+#define FUSB300_OFFSET_TT               0x310
+#define FUSB300_OFFSET_DEVNOTF          0x314
+#define FUSB300_OFFSET_DNC1             0x318
+#define FUSB300_OFFSET_CS               0x31C
+#define FUSB300_OFFSET_SOF              0x324
+#define FUSB300_OFFSET_EFCS             0x328
+#define FUSB300_OFFSET_IGR0             0x400
+#define FUSB300_OFFSET_IGR1             0x404
+#define FUSB300_OFFSET_IGR2             0x408
+#define FUSB300_OFFSET_IGR3             0x40C
+#define FUSB300_OFFSET_IGR4             0x410
+#define FUSB300_OFFSET_IGR5             0x414
+#define FUSB300_OFFSET_IGER0            0x420
+#define FUSB300_OFFSET_IGER1            0x424
+#define FUSB300_OFFSET_IGER2            0x428
+#define FUSB300_OFFSET_IGER3            0x42C
+#define FUSB300_OFFSET_IGER4            0x430
+#define FUSB300_OFFSET_IGER5            0x434
+#define FUSB300_OFFSET_DMAHMER          0x500
+#define FUSB300_OFFSET_EPPRDRDY         0x504
+#define FUSB300_OFFSET_DMAEPMR          0x508
+#define FUSB300_OFFSET_DMAENR           0x50C
+#define FUSB300_OFFSET_DMAAPR           0x510
+#define FUSB300_OFFSET_AHBCR            0x514
+#define FUSB300_OFFSET_EPPRD_W0(n)      (0x520 + (n - 1) * 0x10)
+#define FUSB300_OFFSET_EPPRD_W1(n)      (0x524 + (n - 1) * 0x10)
+#define FUSB300_OFFSET_EPPRD_W2(n)      (0x528 + (n - 1) * 0x10)
+#define FUSB300_OFFSET_EPRD_PTR(n)      (0x52C + (n - 1) * 0x10)
+#define FUSB300_OFFSET_BUFDBG_START     0x800
+#define FUSB300_OFFSET_BUFDBG_END       0xBFC
+#define FUSB300_OFFSET_EPPORT(n)        (0x1010 + (n - 1) * 0x10)
+
+/*
+ * *    Global Control Register (offset = 000H)
+ * */
+#define FUSB300_GCR_SF_RST              (1 << 8)
+#define FUSB300_GCR_VBUS_STATUS         (1 << 7)
+#define FUSB300_GCR_FORCE_HS_SUSP       (1 << 6)
+#define FUSB300_GCR_SYNC_FIFO1_CLR      (1 << 5)
+#define FUSB300_GCR_SYNC_FIFO0_CLR      (1 << 4)
+#define FUSB300_GCR_FIFOCLR             (1 << 3)
+#define FUSB300_GCR_GLINTEN             (1 << 2)
+#define FUSB300_GCR_DEVEN_FS            0x3
+#define FUSB300_GCR_DEVEN_HS            0x2
+#define FUSB300_GCR_DEVEN_SS            0x1
+#define FUSB300_GCR_DEVDIS              0x0
+#define FUSB300_GCR_DEVEN_MSK           0x3
+
+
+/*
+ * *Global Test Mode (offset = 004H)
+ * */
+#define FUSB300_GTM_TST_DIS_SOFGEN      (1 << 16)
+#define FUSB300_GTM_TST_CUR_EP_ENTRY(n) ((n & 0xF) << 12)
+#define FUSB300_GTM_TST_EP_ENTRY(n)     ((n & 0xF) << 8)
+#define FUSB300_GTM_TST_EP_NUM(n)       ((n & 0xF) << 4)
+#define FUSB300_GTM_TST_FIFO_DEG        (1 << 1)
+#define FUSB300_GTM_TSTMODE             (1 << 0)
+
+/*
+ * * Device Address Register (offset = 008H)
+ * */
+#define FUSB300_DAR_SETCONFG    (1 << 7)
+#define FUSB300_DAR_DRVADDR(x)  (x & 0x7F)
+#define FUSB300_DAR_DRVADDR_MSK 0x7F
+
+/*
+ * *Control Transfer Configuration and Status Register
+ * (CX_Config_Status, offset = 00CH)
+ * */
+#define FUSB300_CSR_LEN(x)      ((x & 0xFFFF) << 8)
+#define FUSB300_CSR_LEN_MSK     (0xFFFF << 8)
+#define FUSB300_CSR_EMP         (1 << 4)
+#define FUSB300_CSR_FUL         (1 << 3)
+#define FUSB300_CSR_CLR         (1 << 2)
+#define FUSB300_CSR_STL         (1 << 1)
+#define FUSB300_CSR_DONE        (1 << 0)
+
+/*
+ * * EPn Setting 0 (EPn_SET0, offset = 020H+(n-1)*30H, n=1~15 )
+ * */
+#define FUSB300_EPSET0_CLRSEQNUM        (1 << 2)
+#define FUSB300_EPSET0_EPn_TX0BYTE      (1 << 1)
+#define FUSB300_EPSET0_STL              (1 << 0)
+
+/*
+ * * EPn Setting 1 (EPn_SET1, offset = 024H+(n-1)*30H, n=1~15)
+ * */
+#define FUSB300_EPSET1_START_ENTRY(x)   ((x & 0xFF) << 24)
+#define FUSB300_EPSET1_START_ENTRY_MSK  (0xFF << 24)
+#define FUSB300_EPSET1_FIFOENTRY(x)     ((x & 0x1F) << 12)
+#define FUSB300_EPSET1_FIFOENTRY_MSK    (0x1f << 12)
+#define FUSB300_EPSET1_INTERVAL(x)      ((x & 0x7) << 6)
+#define FUSB300_EPSET1_BWNUM(x)         ((x & 0x3) << 4)
+#define FUSB300_EPSET1_TYPEISO          (1 << 2)
+#define FUSB300_EPSET1_TYPEBLK          (2 << 2)
+#define FUSB300_EPSET1_TYPEINT          (3 << 2)
+#define FUSB300_EPSET1_TYPE(x)          ((x & 0x3) << 2)
+#define FUSB300_EPSET1_TYPE_MSK         (0x3 << 2)
+#define FUSB300_EPSET1_DIROUT           (0 << 1)
+#define FUSB300_EPSET1_DIRIN            (1 << 1)
+#define FUSB300_EPSET1_DIR(x)           ((x & 0x1) << 1)
+#define FUSB300_EPSET1_DIRIN            (1 << 1)
+#define FUSB300_EPSET1_DIR_MSK          ((0x1) << 1)
+#define FUSB300_EPSET1_ACTDIS           0
+#define FUSB300_EPSET1_ACTEN            1
+
+/*
+ * *EPn Setting 2 (EPn_SET2, offset = 028H+(n-1)*30H, n=1~15)
+ * */
+#define FUSB300_EPSET2_ADDROFS(x)       ((x & 0x7FFF) << 16)
+#define FUSB300_EPSET2_ADDROFS_MSK      (0x7fff << 16)
+#define FUSB300_EPSET2_MPS(x)           (x & 0x7FF)
+#define FUSB300_EPSET2_MPS_MSK          0x7FF
+
+/*
+ * * EPn FIFO Register (offset = 2cH+(n-1)*30H)
+ * */
+#define FUSB300_FFR_RST         (1 << 31)
+#define FUSB300_FF_FUL          (1 << 30)
+#define FUSB300_FF_EMPTY        (1 << 29)
+#define FUSB300_FFR_BYCNT       0x1FFFF
+
+/*
+ * *EPn Stream ID (EPn_STR_ID, offset = 040H+(n-1)*30H, n=1~15)
+ * */
+#define FUSB300_STRID_STREN     (1 << 16)
+#define FUSB300_STRID_STRID(x)  (x & 0xFFFF)
+
+/*
+ * *HS PHY Test Mode (offset = 300H)
+ * */
+#define FUSB300_HSPTM_TSTPKDONE         (1 << 4)
+#define FUSB300_HSPTM_TSTPKT            (1 << 3)
+#define FUSB300_HSPTM_TSTSET0NAK        (1 << 2)
+#define FUSB300_HSPTM_TSTKSTA           (1 << 1)
+#define FUSB300_HSPTM_TSTJSTA           (1 << 0)
+
+/*
+ * *HS Control Register (offset = 304H)
+ * */
+#define FUSB300_HSCR_HS_LPM_PERMIT      (1 << 8)
+#define FUSB300_HSCR_HS_LPM_RMWKUP      (1 << 7)
+#define FUSB300_HSCR_CAP_LPM_RMWKUP     (1 << 6)
+#define FUSB300_HSCR_HS_GOSUSP          (1 << 5)
+#define FUSB300_HSCR_HS_GORMWKU         (1 << 4)
+#define FUSB300_HSCR_CAP_RMWKUP         (1 << 3)
+#define FUSB300_HSCR_IDLECNT_0MS        0
+#define FUSB300_HSCR_IDLECNT_1MS        1
+#define FUSB300_HSCR_IDLECNT_2MS        2
+#define FUSB300_HSCR_IDLECNT_3MS        3
+#define FUSB300_HSCR_IDLECNT_4MS        4
+#define FUSB300_HSCR_IDLECNT_5MS        5
+#define FUSB300_HSCR_IDLECNT_6MS        6
+#define FUSB300_HSCR_IDLECNT_7MS        7
+
+/*
+ * * SS Controller Register 0 (offset = 308H)
+ * */
+#define FUSB300_SSCR0_MAX_INTERVAL(x)   ((x & 0x7) << 4)
+#define FUSB300_SSCR0_U2_FUN_EN         (1 << 1)
+#define FUSB300_SSCR0_U1_FUN_EN         (1 << 0)
+
+/*
+ * * SS Controller Register 1 (offset = 30CH)
+ * */
+#define FUSB300_SSCR1_GO_U3_DONE        (1 << 8)
+#define FUSB300_SSCR1_TXDEEMPH_LEVEL    (1 << 7)
+#define FUSB300_SSCR1_DIS_SCRMB         (1 << 6)
+#define FUSB300_SSCR1_FORCE_RECOVERY    (1 << 5)
+#define FUSB300_SSCR1_U3_WAKEUP_EN      (1 << 4)
+#define FUSB300_SSCR1_U2_EXIT_EN        (1 << 3)
+#define FUSB300_SSCR1_U1_EXIT_EN        (1 << 2)
+#define FUSB300_SSCR1_U2_ENTRY_EN       (1 << 1)
+#define FUSB300_SSCR1_U1_ENTRY_EN       (1 << 0)
+
+/*
+ * *SS Controller Register 2  (offset = 310H)
+ * */
+#define FUSB300_SSCR2_SS_TX_SWING               (1 << 25)
+#define FUSB300_SSCR2_FORCE_LINKPM_ACCEPT       (1 << 24)
+#define FUSB300_SSCR2_U2_INACT_TIMEOUT(x)       ((x & 0xFF) << 16)
+#define FUSB300_SSCR2_U1TIMEOUT(x)              ((x & 0xFF) << 8)
+#define FUSB300_SSCR2_U2TIMEOUT(x)              (x & 0xFF)
+
+/*
+ * *SS Device Notification Control (DEV_NOTF, offset = 314H)
+ * */
+#define FUSB300_DEVNOTF_CONTEXT0(x)             ((x & 0xFFFFFF) << 8)
+#define FUSB300_DEVNOTF_TYPE_DIS                0
+#define FUSB300_DEVNOTF_TYPE_FUNCWAKE           1
+#define FUSB300_DEVNOTF_TYPE_LTM                2
+#define FUSB300_DEVNOTF_TYPE_BUSINT_ADJMSG      3
+
+/*
+ * *BFM Arbiter Priority Register (BFM_ARB offset = 31CH)
+ * */
+#define FUSB300_BFMARB_ARB_M1   (1 << 3)
+#define FUSB300_BFMARB_ARB_M0   (1 << 2)
+#define FUSB300_BFMARB_ARB_S1   (1 << 1)
+#define FUSB300_BFMARB_ARB_S0   1
+
+/*
+ * *Vendor Specific IO Control Register (offset = 320H)
+ * */
+#define FUSB300_VSIC_VCTLOAD_N  (1 << 8)
+#define FUSB300_VSIC_VCTL(x)    (x & 0x3F)
+
+/*
+ * *SOF Mask Timer (offset = 324H)
+ * */
+#define FUSB300_SOF_MASK_TIMER_HS       0x044c
+#define FUSB300_SOF_MASK_TIMER_FS       0x2710
+
+/*
+ * *Error Flag and Control Status (offset = 328H)
+ * */
+#define FUSB300_EFCS_PM_STATE_U3        3
+#define FUSB300_EFCS_PM_STATE_U2        2
+#define FUSB300_EFCS_PM_STATE_U1        1
+#define FUSB300_EFCS_PM_STATE_U0        0
+
+/*
+ * *Interrupt Group 0 Register (offset = 400H)
+ * */
+#define FUSB300_IGR0_EP15_PRD_INT       (1 << 31)
+#define FUSB300_IGR0_EP14_PRD_INT       (1 << 30)
+#define FUSB300_IGR0_EP13_PRD_INT       (1 << 29)
+#define FUSB300_IGR0_EP12_PRD_INT       (1 << 28)
+#define FUSB300_IGR0_EP11_PRD_INT       (1 << 27)
+#define FUSB300_IGR0_EP10_PRD_INT       (1 << 26)
+#define FUSB300_IGR0_EP9_PRD_INT        (1 << 25)
+#define FUSB300_IGR0_EP8_PRD_INT        (1 << 24)
+#define FUSB300_IGR0_EP7_PRD_INT        (1 << 23)
+#define FUSB300_IGR0_EP6_PRD_INT        (1 << 22)
+#define FUSB300_IGR0_EP5_PRD_INT        (1 << 21)
+#define FUSB300_IGR0_EP4_PRD_INT        (1 << 20)
+#define FUSB300_IGR0_EP3_PRD_INT        (1 << 19)
+#define FUSB300_IGR0_EP2_PRD_INT        (1 << 18)
+#define FUSB300_IGR0_EP1_PRD_INT        (1 << 17)
+#define FUSB300_IGR0_EPn_PRD_INT(n)     (1 << (n + 16))
+
+#define FUSB300_IGR0_EP15_FIFO_INT      (1 << 15)
+#define FUSB300_IGR0_EP14_FIFO_INT      (1 << 14)
+#define FUSB300_IGR0_EP13_FIFO_INT      (1 << 13)
+#define FUSB300_IGR0_EP12_FIFO_INT      (1 << 12)
+#define FUSB300_IGR0_EP11_FIFO_INT      (1 << 11)
+#define FUSB300_IGR0_EP10_FIFO_INT      (1 << 10)
+#define FUSB300_IGR0_EP9_FIFO_INT       (1 << 9)
+#define FUSB300_IGR0_EP8_FIFO_INT       (1 << 8)
+#define FUSB300_IGR0_EP7_FIFO_INT       (1 << 7)
+#define FUSB300_IGR0_EP6_FIFO_INT       (1 << 6)
+#define FUSB300_IGR0_EP5_FIFO_INT       (1 << 5)
+#define FUSB300_IGR0_EP4_FIFO_INT       (1 << 4)
+#define FUSB300_IGR0_EP3_FIFO_INT       (1 << 3)
+#define FUSB300_IGR0_EP2_FIFO_INT       (1 << 2)
+#define FUSB300_IGR0_EP1_FIFO_INT       (1 << 1)
+#define FUSB300_IGR0_EPn_FIFO_INT(n)    (1 << n)
+
+/*
+ * *Interrupt Group 1 Register (offset = 404H)
+ * */
+#define FUSB300_IGR1_INTGRP5            (1 << 31)
+#define FUSB300_IGR1_VBUS_CHG_INT       (1 << 30)
+#define FUSB300_IGR1_SYNF1_EMPTY_INT    (1 << 29)
+#define FUSB300_IGR1_SYNF0_EMPTY_INT    (1 << 28)
+#define FUSB300_IGR1_U3_EXIT_FAIL_INT   (1 << 27)
+#define FUSB300_IGR1_U2_EXIT_FAIL_INT   (1 << 26)
+#define FUSB300_IGR1_U1_EXIT_FAIL_INT   (1 << 25)
+#define FUSB300_IGR1_U2_ENTRY_FAIL_INT  (1 << 24)
+#define FUSB300_IGR1_U1_ENTRY_FAIL_INT  (1 << 23)
+#define FUSB300_IGR1_U3_EXIT_INT        (1 << 22)
+#define FUSB300_IGR1_U2_EXIT_INT        (1 << 21)
+#define FUSB300_IGR1_U1_EXIT_INT        (1 << 20)
+#define FUSB300_IGR1_U3_ENTRY_INT       (1 << 19)
+#define FUSB300_IGR1_U2_ENTRY_INT       (1 << 18)
+#define FUSB300_IGR1_U1_ENTRY_INT       (1 << 17)
+#define FUSB300_IGR1_HOT_RST_INT        (1 << 16)
+#define FUSB300_IGR1_WARM_RST_INT       (1 << 15)
+#define FUSB300_IGR1_RESM_INT           (1 << 14)
+#define FUSB300_IGR1_SUSP_INT           (1 << 13)
+#define FUSB300_IGR1_HS_LPM_INT         (1 << 12)
+#define FUSB300_IGR1_USBRST_INT         (1 << 11)
+#define FUSB300_IGR1_DEV_MODE_CHG_INT   (1 << 9)
+#define FUSB300_IGR1_CX_COMABT_INT      (1 << 8)
+#define FUSB300_IGR1_CX_COMFAIL_INT     (1 << 7)
+#define FUSB300_IGR1_CX_CMDEND_INT      (1 << 6)
+#define FUSB300_IGR1_CX_OUT_INT         (1 << 5)
+#define FUSB300_IGR1_CX_IN_INT          (1 << 4)
+#define FUSB300_IGR1_CX_SETUP_INT       (1 << 3)
+#define FUSB300_IGR1_INTGRP4            (1 << 2)
+#define FUSB300_IGR1_INTGRP3            (1 << 1)
+#define FUSB300_IGR1_INTGRP2            (1 << 0)
+
+/*
+ * *Interrupt Group 2 Register (offset = 408H)
+ * */
+#define FUSB300_IGR2_EP6_STR_ACCEPT_INT         (1 << 29)
+#define FUSB300_IGR2_EP6_STR_RESUME_INT         (1 << 28)
+#define FUSB300_IGR2_EP6_STR_REQ_INT            (1 << 27)
+#define FUSB300_IGR2_EP6_STR_NOTRDY_INT         (1 << 26)
+#define FUSB300_IGR2_EP6_STR_PRIME_INT          (1 << 25)
+#define FUSB300_IGR2_EP5_STR_ACCEPT_INT         (1 << 24)
+#define FUSB300_IGR2_EP5_STR_RESUME_INT         (1 << 23)
+#define FUSB300_IGR2_EP5_STR_REQ_INT            (1 << 22)
+#define FUSB300_IGR2_EP5_STR_NOTRDY_INT         (1 << 21)
+#define FUSB300_IGR2_EP5_STR_PRIME_INT          (1 << 20)
+#define FUSB300_IGR2_EP4_STR_ACCEPT_INT         (1 << 19)
+#define FUSB300_IGR2_EP4_STR_RESUME_INT         (1 << 18)
+#define FUSB300_IGR2_EP4_STR_REQ_INT            (1 << 17)
+#define FUSB300_IGR2_EP4_STR_NOTRDY_INT         (1 << 16)
+#define FUSB300_IGR2_EP4_STR_PRIME_INT          (1 << 15)
+#define FUSB300_IGR2_EP3_STR_ACCEPT_INT         (1 << 14)
+#define FUSB300_IGR2_EP3_STR_RESUME_INT         (1 << 13)
+#define FUSB300_IGR2_EP3_STR_REQ_INT            (1 << 12)
+#define FUSB300_IGR2_EP3_STR_NOTRDY_INT         (1 << 11)
+#define FUSB300_IGR2_EP3_STR_PRIME_INT          (1 << 10)
+#define FUSB300_IGR2_EP2_STR_ACCEPT_INT         (1 << 9)
+#define FUSB300_IGR2_EP2_STR_RESUME_INT         (1 << 8)
+#define FUSB300_IGR2_EP2_STR_REQ_INT            (1 << 7)
+#define FUSB300_IGR2_EP2_STR_NOTRDY_INT         (1 << 6)
+#define FUSB300_IGR2_EP2_STR_PRIME_INT          (1 << 5)
+#define FUSB300_IGR2_EP1_STR_ACCEPT_INT         (1 << 4)
+#define FUSB300_IGR2_EP1_STR_RESUME_INT         (1 << 3)
+#define FUSB300_IGR2_EP1_STR_REQ_INT            (1 << 2)
+#define FUSB300_IGR2_EP1_STR_NOTRDY_INT         (1 << 1)
+#define FUSB300_IGR2_EP1_STR_PRIME_INT          (1 << 0)
+
+#define FUSB300_IGR2_EP_STR_ACCEPT_INT(n)       (1 << (5 * n - 1))
+#define FUSB300_IGR2_EP_STR_RESUME_INT(n)       (1 << (5 * n - 2))
+#define FUSB300_IGR2_EP_STR_REQ_INT(n)          (1 << (5 * n - 3))
+#define FUSB300_IGR2_EP_STR_NOTRDY_INT(n)       (1 << (5 * n - 4))
+#define FUSB300_IGR2_EP_STR_PRIME_INT(n)        (1 << (5 * n - 5))
+
+/*
+ * *Interrupt Group 3 Register (offset = 40CH)
+ * */
+#define FUSB300_IGR3_EP12_STR_ACCEPT_INT        (1 << 29)
+#define FUSB300_IGR3_EP12_STR_RESUME_INT        (1 << 28)
+#define FUSB300_IGR3_EP12_STR_REQ_INT           (1 << 27)
+#define FUSB300_IGR3_EP12_STR_NOTRDY_INT        (1 << 26)
+#define FUSB300_IGR3_EP12_STR_PRIME_INT         (1 << 25)
+#define FUSB300_IGR3_EP11_STR_ACCEPT_INT        (1 << 24)
+#define FUSB300_IGR3_EP11_STR_RESUME_INT        (1 << 23)
+#define FUSB300_IGR3_EP11_STR_REQ_INT           (1 << 22)
+#define FUSB300_IGR3_EP11_STR_NOTRDY_INT        (1 << 21)
+#define FUSB300_IGR3_EP11_STR_PRIME_INT         (1 << 20)
+#define FUSB300_IGR3_EP10_STR_ACCEPT_INT        (1 << 19)
+#define FUSB300_IGR3_EP10_STR_RESUME_INT        (1 << 18)
+#define FUSB300_IGR3_EP10_STR_REQ_INT           (1 << 17)
+#define FUSB300_IGR3_EP10_STR_NOTRDY_INT        (1 << 16)
+#define FUSB300_IGR3_EP10_STR_PRIME_INT         (1 << 15)
+#define FUSB300_IGR3_EP9_STR_ACCEPT_INT         (1 << 14)
+#define FUSB300_IGR3_EP9_STR_RESUME_INT         (1 << 13)
+#define FUSB300_IGR3_EP9_STR_REQ_INT            (1 << 12)
+#define FUSB300_IGR3_EP9_STR_NOTRDY_INT         (1 << 11)
+#define FUSB300_IGR3_EP9_STR_PRIME_INT          (1 << 10)
+#define FUSB300_IGR3_EP8_STR_ACCEPT_INT         (1 << 9)
+#define FUSB300_IGR3_EP8_STR_RESUME_INT         (1 << 8)
+#define FUSB300_IGR3_EP8_STR_REQ_INT            (1 << 7)
+#define FUSB300_IGR3_EP8_STR_NOTRDY_INT         (1 << 6)
+#define FUSB300_IGR3_EP8_STR_PRIME_INT          (1 << 5)
+#define FUSB300_IGR3_EP7_STR_ACCEPT_INT         (1 << 4)
+#define FUSB300_IGR3_EP7_STR_RESUME_INT         (1 << 3)
+#define FUSB300_IGR3_EP7_STR_REQ_INT            (1 << 2)
+#define FUSB300_IGR3_EP7_STR_NOTRDY_INT         (1 << 1)
+#define FUSB300_IGR3_EP7_STR_PRIME_INT          (1 << 0)
+
+#define FUSB300_IGR3_EP_STR_ACCEPT_INT(n)       (1 << (5 * (n - 6) - 1))
+#define FUSB300_IGR3_EP_STR_RESUME_INT(n)       (1 << (5 * (n - 6) - 2))
+#define FUSB300_IGR3_EP_STR_REQ_INT(n)          (1 << (5 * (n - 6) - 3))
+#define FUSB300_IGR3_EP_STR_NOTRDY_INT(n)       (1 << (5 * (n - 6) - 4))
+#define FUSB300_IGR3_EP_STR_PRIME_INT(n)        (1 << (5 * (n - 6) - 5))
+
+/*
+ * *Interrupt Group 4 Register (offset = 410H)
+ * */
+#define FUSB300_IGR4_EP15_RX0_INT               (1 << 31)
+#define FUSB300_IGR4_EP14_RX0_INT               (1 << 30)
+#define FUSB300_IGR4_EP13_RX0_INT               (1 << 29)
+#define FUSB300_IGR4_EP12_RX0_INT               (1 << 28)
+#define FUSB300_IGR4_EP11_RX0_INT               (1 << 27)
+#define FUSB300_IGR4_EP10_RX0_INT               (1 << 26)
+#define FUSB300_IGR4_EP9_RX0_INT                (1 << 25)
+#define FUSB300_IGR4_EP8_RX0_INT                (1 << 24)
+#define FUSB300_IGR4_EP7_RX0_INT                (1 << 23)
+#define FUSB300_IGR4_EP6_RX0_INT                (1 << 22)
+#define FUSB300_IGR4_EP5_RX0_INT                (1 << 21)
+#define FUSB300_IGR4_EP4_RX0_INT                (1 << 20)
+#define FUSB300_IGR4_EP3_RX0_INT                (1 << 19)
+#define FUSB300_IGR4_EP2_RX0_INT                (1 << 18)
+#define FUSB300_IGR4_EP1_RX0_INT                (1 << 17)
+#define FUSB300_IGR4_EP_RX0_INT(x)              (1 << (x + 16))
+#define FUSB300_IGR4_EP15_STR_ACCEPT_INT        (1 << 14)
+#define FUSB300_IGR4_EP15_STR_RESUME_INT        (1 << 13)
+#define FUSB300_IGR4_EP15_STR_REQ_INT           (1 << 12)
+#define FUSB300_IGR4_EP15_STR_NOTRDY_INT        (1 << 11)
+#define FUSB300_IGR4_EP15_STR_PRIME_INT         (1 << 10)
+#define FUSB300_IGR4_EP14_STR_ACCEPT_INT        (1 << 9)
+#define FUSB300_IGR4_EP14_STR_RESUME_INT        (1 << 8)
+#define FUSB300_IGR4_EP14_STR_REQ_INT           (1 << 7)
+#define FUSB300_IGR4_EP14_STR_NOTRDY_INT        (1 << 6)
+#define FUSB300_IGR4_EP14_STR_PRIME_INT         (1 << 5)
+#define FUSB300_IGR4_EP13_STR_ACCEPT_INT        (1 << 4)
+#define FUSB300_IGR4_EP13_STR_RESUME_INT        (1 << 3)
+#define FUSB300_IGR4_EP13_STR_REQ_INT           (1 << 2)
+#define FUSB300_IGR4_EP13_STR_NOTRDY_INT        (1 << 1)
+#define FUSB300_IGR4_EP13_STR_PRIME_INT         (1 << 0)
+
+#define FUSB300_IGR4_EP_STR_ACCEPT_INT(n)       (1 << (5 * (n - 12) - 1))
+#define FUSB300_IGR4_EP_STR_RESUME_INT(n)       (1 << (5 * (n - 12) - 2))
+#define FUSB300_IGR4_EP_STR_REQ_INT(n)          (1 << (5 * (n - 12) - 3))
+#define FUSB300_IGR4_EP_STR_NOTRDY_INT(n)       (1 << (5 * (n - 12) - 4))
+#define FUSB300_IGR4_EP_STR_PRIME_INT(n)        (1 << (5 * (n - 12) - 5))
+
+/*
+ * *Interrupt Group 5 Register (offset = 414H)
+ * */
+#define FUSB300_IGR5_EP_STL_INT(n)      (1 << n)
+
+/*
+ * *Interrupt Enable Group 0 Register (offset = 420H)
+ * */
+#define FUSB300_IGER0_EEP15_PRD_INT     (1 << 31)
+#define FUSB300_IGER0_EEP14_PRD_INT     (1 << 30)
+#define FUSB300_IGER0_EEP13_PRD_INT     (1 << 29)
+#define FUSB300_IGER0_EEP12_PRD_INT     (1 << 28)
+#define FUSB300_IGER0_EEP11_PRD_INT     (1 << 27)
+#define FUSB300_IGER0_EEP10_PRD_INT     (1 << 26)
+#define FUSB300_IGER0_EEP9_PRD_INT      (1 << 25)
+#define FUSB300_IGER0_EP8_PRD_INT       (1 << 24)
+#define FUSB300_IGER0_EEP7_PRD_INT      (1 << 23)
+#define FUSB300_IGER0_EEP6_PRD_INT      (1 << 22)
+#define FUSB300_IGER0_EEP5_PRD_INT      (1 << 21)
+#define FUSB300_IGER0_EEP4_PRD_INT      (1 << 20)
+#define FUSB300_IGER0_EEP3_PRD_INT      (1 << 19)
+#define FUSB300_IGER0_EEP2_PRD_INT      (1 << 18)
+#define FUSB300_IGER0_EEP1_PRD_INT      (1 << 17)
+#define FUSB300_IGER0_EEPn_PRD_INT(n)   (1 << (n + 16))
+
+#define FUSB300_IGER0_EEP15_FIFO_INT    (1 << 15)
+#define FUSB300_IGER0_EEP14_FIFO_INT    (1 << 14)
+#define FUSB300_IGER0_EEP13_FIFO_INT    (1 << 13)
+#define FUSB300_IGER0_EEP12_FIFO_INT    (1 << 12)
+#define FUSB300_IGER0_EEP11_FIFO_INT    (1 << 11)
+#define FUSB300_IGER0_EEP10_FIFO_INT    (1 << 10)
+#define FUSB300_IGER0_EEP9_FIFO_INT     (1 << 9)
+#define FUSB300_IGER0_EEP8_FIFO_INT     (1 << 8)
+#define FUSB300_IGER0_EEP7_FIFO_INT     (1 << 7)
+#define FUSB300_IGER0_EEP6_FIFO_INT     (1 << 6)
+#define FUSB300_IGER0_EEP5_FIFO_INT     (1 << 5)
+#define FUSB300_IGER0_EEP4_FIFO_INT     (1 << 4)
+#define FUSB300_IGER0_EEP3_FIFO_INT     (1 << 3)
+#define FUSB300_IGER0_EEP2_FIFO_INT     (1 << 2)
+#define FUSB300_IGER0_EEP1_FIFO_INT     (1 << 1)
+#define FUSB300_IGER0_EEPn_FIFO_INT(n)  (1 << n)
+
+/*
+ * *Interrupt Enable Group 1 Register (offset = 424H)
+ * */
+#define FUSB300_IGER1_EINT_GRP5         (1 << 31)
+#define FUSB300_IGER1_VBUS_CHG_INT      (1 << 30)
+#define FUSB300_IGER1_SYNF1_EMPTY_INT   (1 << 29)
+#define FUSB300_IGER1_SYNF0_EMPTY_INT   (1 << 28)
+#define FUSB300_IGER1_U3_EXIT_FAIL_INT  (1 << 27)
+#define FUSB300_IGER1_U2_EXIT_FAIL_INT  (1 << 26)
+#define FUSB300_IGER1_U1_EXIT_FAIL_INT  (1 << 25)
+#define FUSB300_IGER1_U2_ENTRY_FAIL_INT (1 << 24)
+#define FUSB300_IGER1_U1_ENTRY_FAIL_INT (1 << 23)
+#define FUSB300_IGER1_U3_EXIT_INT       (1 << 22)
+#define FUSB300_IGER1_U2_EXIT_INT       (1 << 21)
+#define FUSB300_IGER1_U1_EXIT_INT       (1 << 20)
+#define FUSB300_IGER1_U3_ENTRY_INT      (1 << 19)
+#define FUSB300_IGER1_U2_ENTRY_INT      (1 << 18)
+#define FUSB300_IGER1_U1_ENTRY_INT      (1 << 17)
+#define FUSB300_IGER1_HOT_RST_INT       (1 << 16)
+#define FUSB300_IGER1_WARM_RST_INT      (1 << 15)
+#define FUSB300_IGER1_RESM_INT          (1 << 14)
+#define FUSB300_IGER1_SUSP_INT          (1 << 13)
+#define FUSB300_IGER1_LPM_INT           (1 << 12)
+#define FUSB300_IGER1_HS_RST_INT        (1 << 11)
+#define FUSB300_IGER1_EDEV_MODE_CHG_INT (1 << 9)
+#define FUSB300_IGER1_CX_COMABT_INT     (1 << 8)
+#define FUSB300_IGER1_CX_COMFAIL_INT    (1 << 7)
+#define FUSB300_IGER1_CX_CMDEND_INT     (1 << 6)
+#define FUSB300_IGER1_CX_OUT_INT        (1 << 5)
+#define FUSB300_IGER1_CX_IN_INT         (1 << 4)
+#define FUSB300_IGER1_CX_SETUP_INT      (1 << 3)
+#define FUSB300_IGER1_INTGRP4           (1 << 2)
+#define FUSB300_IGER1_INTGRP3           (1 << 1)
+#define FUSB300_IGER1_INTGRP2           (1 << 0)
+
+/*
+ * *Interrupt Enable Group 2 Register (offset = 428H)
+ * */
+#define FUSB300_IGER2_EEP_STR_ACCEPT_INT(n)     (1 << (5 * n - 1))
+#define FUSB300_IGER2_EEP_STR_RESUME_INT(n)     (1 << (5 * n - 2))
+#define FUSB300_IGER2_EEP_STR_REQ_INT(n)        (1 << (5 * n - 3))
+#define FUSB300_IGER2_EEP_STR_NOTRDY_INT(n)     (1 << (5 * n - 4))
+#define FUSB300_IGER2_EEP_STR_PRIME_INT(n)      (1 << (5 * n - 5))
+
+/*
+ * *Interrupt Enable Group 3 Register (offset = 42CH)
+ * */
+
+#define FUSB300_IGER3_EEP_STR_ACCEPT_INT(n)     (1 << (5 * (n - 6) - 1))
+#define FUSB300_IGER3_EEP_STR_RESUME_INT(n)     (1 << (5 * (n - 6) - 2))
+#define FUSB300_IGER3_EEP_STR_REQ_INT(n)        (1 << (5 * (n - 6) - 3))
+#define FUSB300_IGER3_EEP_STR_NOTRDY_INT(n)     (1 << (5 * (n - 6) - 4))
+#define FUSB300_IGER3_EEP_STR_PRIME_INT(n)      (1 << (5 * (n - 6) - 5))
+
+/*
+ * *Interrupt Enable Group 4 Register (offset = 430H)
+ * */
+
+#define FUSB300_IGER4_EEP_RX0_INT(n)            (1 << (n + 16))
+#define FUSB300_IGER4_EEP_STR_ACCEPT_INT(n)     (1 << (5 * (n - 6) - 1))
+#define FUSB300_IGER4_EEP_STR_RESUME_INT(n)     (1 << (5 * (n - 6) - 2))
+#define FUSB300_IGER4_EEP_STR_REQ_INT(n)        (1 << (5 * (n - 6) - 3))
+#define FUSB300_IGER4_EEP_STR_NOTRDY_INT(n)     (1 << (5 * (n - 6) - 4))
+#define FUSB300_IGER4_EEP_STR_PRIME_INT(n)      (1 << (5 * (n - 6) - 5))
+
+/* EP PRD Ready (EP_PRD_RDY, offset = 504H) */
+
+#define FUSB300_EPPRDR_EP15_PRD_RDY             (1 << 15)
+#define FUSB300_EPPRDR_EP14_PRD_RDY             (1 << 14)
+#define FUSB300_EPPRDR_EP13_PRD_RDY             (1 << 13)
+#define FUSB300_EPPRDR_EP12_PRD_RDY             (1 << 12)
+#define FUSB300_EPPRDR_EP11_PRD_RDY             (1 << 11)
+#define FUSB300_EPPRDR_EP10_PRD_RDY             (1 << 10)
+#define FUSB300_EPPRDR_EP9_PRD_RDY              (1 << 9)
+#define FUSB300_EPPRDR_EP8_PRD_RDY              (1 << 8)
+#define FUSB300_EPPRDR_EP7_PRD_RDY              (1 << 7)
+#define FUSB300_EPPRDR_EP6_PRD_RDY              (1 << 6)
+#define FUSB300_EPPRDR_EP5_PRD_RDY              (1 << 5)
+#define FUSB300_EPPRDR_EP4_PRD_RDY              (1 << 4)
+#define FUSB300_EPPRDR_EP3_PRD_RDY              (1 << 3)
+#define FUSB300_EPPRDR_EP2_PRD_RDY              (1 << 2)
+#define FUSB300_EPPRDR_EP1_PRD_RDY              (1 << 1)
+#define FUSB300_EPPRDR_EP_PRD_RDY(n)            (1 << n)
+
+/* AHB Bus Control Register (offset = 514H) */
+#define FUSB300_AHBBCR_S1_SPLIT_ON              (1 << 17)
+#define FUSB300_AHBBCR_S0_SPLIT_ON              (1 << 16)
+#define FUSB300_AHBBCR_S1_1entry                (0 << 12)
+#define FUSB300_AHBBCR_S1_4entry                (3 << 12)
+#define FUSB300_AHBBCR_S1_8entry                (5 << 12)
+#define FUSB300_AHBBCR_S1_16entry               (7 << 12)
+#define FUSB300_AHBBCR_S0_1entry                (0 << 8)
+#define FUSB300_AHBBCR_S0_4entry                (3 << 8)
+#define FUSB300_AHBBCR_S0_8entry                (5 << 8)
+#define FUSB300_AHBBCR_S0_16entry               (7 << 8)
+#define FUSB300_AHBBCR_M1_BURST_SINGLE          (0 << 4)
+#define FUSB300_AHBBCR_M1_BURST_INCR            (1 << 4)
+#define FUSB300_AHBBCR_M1_BURST_INCR4           (3 << 4)
+#define FUSB300_AHBBCR_M1_BURST_INCR8           (5 << 4)
+#define FUSB300_AHBBCR_M1_BURST_INCR16          (7 << 4)
+#define FUSB300_AHBBCR_M0_BURST_SINGLE          0
+#define FUSB300_AHBBCR_M0_BURST_INCR            1
+#define FUSB300_AHBBCR_M0_BURST_INCR4           3
+#define FUSB300_AHBBCR_M0_BURST_INCR8           5
+#define FUSB300_AHBBCR_M0_BURST_INCR16          7
+#define FUSB300_IGER5_EEP_STL_INT(n)            (1 << n)
+
+/* WORD 0 Data Structure of PRD Table */
+#define FUSB300_EPPRD0_M                        (1 << 30)
+#define FUSB300_EPPRD0_O                        (1 << 29)
+/* The finished prd */
+#define FUSB300_EPPRD0_F                        (1 << 28)
+#define FUSB300_EPPRD0_I                        (1 << 27)
+#define FUSB300_EPPRD0_A                        (1 << 26)
+/* To decide HW point to first prd at next time */
+#define FUSB300_EPPRD0_L                        (1 << 25)
+#define FUSB300_EPPRD0_H                        (1 << 24)
+#define FUSB300_EPPRD0_BTC(n)                   (n & 0xFFFFFF)
+
+/*----------------------------------------------------------------------*/
+#define FUSB300_MAX_NUM_EP              16
+
+#define FUSB300_FIFO_ENTRY_NUM          8
+#define FUSB300_MAX_FIFO_ENTRY          8
+
+#define SS_CTL_MAX_PACKET_SIZE          0x200
+#define SS_BULK_MAX_PACKET_SIZE         0x400
+#define SS_INT_MAX_PACKET_SIZE          0x400
+#define SS_ISO_MAX_PACKET_SIZE          0x400
+
+#define HS_BULK_MAX_PACKET_SIZE         0x200
+#define HS_CTL_MAX_PACKET_SIZE          0x40
+#define HS_INT_MAX_PACKET_SIZE          0x400
+#define HS_ISO_MAX_PACKET_SIZE          0x400
+
+struct fusb300_ep_info {
+        u8      epnum;
+        u8      type;
+        u8      interval;
+        u8      dir_in;
+        u16     maxpacket;
+        u16     addrofs;
+        u16     bw_num;
+};
+
+struct fusb300_request {
+
+        struct usb_request      req;
+        struct list_head        queue;
+};
+
+
+struct fusb300_ep {
+        struct usb_ep           ep;
+        struct fusb300          *fusb300;
+
+        struct list_head        queue;
+        unsigned                stall:1;
+        unsigned                wedged:1;
+        unsigned                use_dma:1;
+
+        unsigned char           epnum;
+        unsigned char           type;
+        const struct usb_endpoint_descriptor    *desc;
+};
+
+struct fusb300 {
+        spinlock_t              lock;
+        void __iomem            *reg;
+
+        unsigned long           irq_trigger;
+
+        struct usb_gadget               gadget;
+        struct usb_gadget_driver        *driver;
+
+        struct fusb300_ep       *ep[FUSB300_MAX_NUM_EP];
+
+        struct usb_request      *ep0_req;       /* for internal request */
+        __le16                  ep0_data;
+        u32                     ep0_length;     /* for internal request */
+        u8                      ep0_dir;        /* 0/0x80  out/in */
+
+        u8                      fifo_entry_num; /* next start fifo entry */
+        u32                     addrofs;        /* next fifo address offset */
+        u8                      reenum;         /* if re-enumeration */
+};
+
+#endif
diff --git a/drivers/usb/gadget/g_ffs.c b/drivers/usb/gadget/g_ffs.c
index a9474f8d5325..ebf6970a10bf 100644
--- a/drivers/usb/gadget/g_ffs.c
+++ b/drivers/usb/gadget/g_ffs.c
@@ -1,7 +1,29 @@
+/*
+ * g_ffs.c -- user mode file system API for USB composite function controllers
+ *
+ * Copyright (C) 2010 Samsung Electronics
+ * Author: Michal Nazarewicz <m.nazarewicz@samsung.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
+ * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#define pr_fmt(fmt) "g_ffs: " fmt
+
 #include <linux/module.h>
 #include <linux/utsname.h>
 
-
 /*
  * kbuild is not very cooperative with respect to linking separately
  * compiled library objects into one module.  So for now we won't use
@@ -43,7 +65,6 @@ static int eth_bind_config(struct usb_configuration *c, u8 ethaddr[ETH_ALEN]);
 
 #include "f_fs.c"
 
-
 #define DRIVER_NAME     "g_ffs"
 #define DRIVER_DESC     "USB Function Filesystem"
 #define DRIVER_VERSION  "24 Aug 2004"
@@ -52,9 +73,8 @@ MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_AUTHOR("Michal Nazarewicz");
 MODULE_LICENSE("GPL");
 
-
-static unsigned short gfs_vendor_id    = 0x0525;        /* XXX NetChip */
-static unsigned short gfs_product_id   = 0xa4ac;        /* XXX */
+#define GFS_VENDOR_ID   0x1d6b  /* Linux Foundation */
+#define GFS_PRODUCT_ID  0x0105  /* FunctionFS Gadget */
 
 static struct usb_device_descriptor gfs_dev_desc = {
         .bLength                = sizeof gfs_dev_desc,
@@ -63,31 +83,16 @@ static struct usb_device_descriptor gfs_dev_desc = {
         .bcdUSB                 = cpu_to_le16(0x0200),
         .bDeviceClass           = USB_CLASS_PER_INTERFACE,
 
-        /* Vendor and product id can be overridden by module parameters.  */
-        /* .idVendor            = cpu_to_le16(gfs_vendor_id), */
-        /* .idProduct           = cpu_to_le16(gfs_product_id), */
-        /* .bcdDevice           = f(hardware) */
-        /* .iManufacturer       = DYNAMIC */
-        /* .iProduct            = DYNAMIC */
-        /* NO SERIAL NUMBER */
-        .bNumConfigurations     = 1,
+        .idVendor               = cpu_to_le16(GFS_VENDOR_ID),
+        .idProduct              = cpu_to_le16(GFS_PRODUCT_ID),
 };
 
-#define GFS_MODULE_PARAM_DESC(name, field) \
-        MODULE_PARM_DESC(name, "Value of the " #field " field of the device descriptor sent to the host.  Takes effect only prior to the user-space driver registering to the FunctionFS.")
-
-module_param_named(usb_class,    gfs_dev_desc.bDeviceClass,    byte,   0644);
-GFS_MODULE_PARAM_DESC(usb_class, bDeviceClass);
-module_param_named(usb_subclass, gfs_dev_desc.bDeviceSubClass, byte,   0644);
-GFS_MODULE_PARAM_DESC(usb_subclass, bDeviceSubClass);
-module_param_named(usb_protocol, gfs_dev_desc.bDeviceProtocol, byte,   0644);
-GFS_MODULE_PARAM_DESC(usb_protocol, bDeviceProtocol);
-module_param_named(usb_vendor,   gfs_vendor_id,                ushort, 0644);
-GFS_MODULE_PARAM_DESC(usb_vendor, idVendor);
-module_param_named(usb_product,  gfs_product_id,               ushort, 0644);
-GFS_MODULE_PARAM_DESC(usb_product, idProduct);
-
-
+module_param_named(bDeviceClass,    gfs_dev_desc.bDeviceClass,    byte,   0644);
+MODULE_PARM_DESC(bDeviceClass, "USB Device class");
+module_param_named(bDeviceSubClass, gfs_dev_desc.bDeviceSubClass, byte,   0644);
+MODULE_PARM_DESC(bDeviceSubClass, "USB Device subclass");
+module_param_named(bDeviceProtocol, gfs_dev_desc.bDeviceProtocol, byte,   0644);
+MODULE_PARM_DESC(bDeviceProtocol, "USB Device protocol");
 
 static const struct usb_descriptor_header *gfs_otg_desc[] = {
         (const struct usb_descriptor_header *)
@@ -95,29 +100,18 @@ static const struct usb_descriptor_header *gfs_otg_desc[] = {
                 .bLength                = sizeof(struct usb_otg_descriptor),
                 .bDescriptorType        = USB_DT_OTG,
 
-                /* REVISIT SRP-only hardware is possible, although
-                 * it would not be called "OTG" ... */
+                /*
+                 * REVISIT SRP-only hardware is possible, although
+                 * it would not be called "OTG" ...
+                 */
                 .bmAttributes           = USB_OTG_SRP | USB_OTG_HNP,
         },
 
         NULL
 };
 
-/* string IDs are assigned dynamically */
-
-enum {
-        GFS_STRING_MANUFACTURER_IDX,
-        GFS_STRING_PRODUCT_IDX,
-        GFS_STRING_FIRST_CONFIG_IDX,
-};
-
-static       char gfs_manufacturer[50];
-static const char gfs_driver_desc[] = DRIVER_DESC;
-static const char gfs_short_name[]  = DRIVER_NAME;
-
+/* String IDs are assigned dynamically */
 static struct usb_string gfs_strings[] = {
-        [GFS_STRING_MANUFACTURER_IDX].s = gfs_manufacturer,
-        [GFS_STRING_PRODUCT_IDX].s = gfs_driver_desc,
 #ifdef CONFIG_USB_FUNCTIONFS_RNDIS
         { .s = "FunctionFS + RNDIS" },
 #endif
@@ -138,8 +132,6 @@ static struct usb_gadget_strings *gfs_dev_strings[] = {
         NULL,
 };
 
-
-
 struct gfs_configuration {
         struct usb_configuration c;
         int (*eth)(struct usb_configuration *c, u8 *ethaddr);
@@ -162,24 +154,21 @@ struct gfs_configuration {
 #endif
 };
 
-
 static int gfs_bind(struct usb_composite_dev *cdev);
 static int gfs_unbind(struct usb_composite_dev *cdev);
 static int gfs_do_config(struct usb_configuration *c);
 
 static struct usb_composite_driver gfs_driver = {
-        .name           = gfs_short_name,
+        .name           = DRIVER_NAME,
         .dev            = &gfs_dev_desc,
         .strings        = gfs_dev_strings,
-        .bind           = gfs_bind,
         .unbind         = gfs_unbind,
+        .iProduct       = DRIVER_DESC,
 };
 
-
 static struct ffs_data *gfs_ffs_data;
 static unsigned long gfs_registered;
 
-
 static int  gfs_init(void)
 {
         ENTER();
@@ -199,7 +188,6 @@ static void  gfs_exit(void)
 }
 module_exit(gfs_exit);
 
-
 static int functionfs_ready_callback(struct ffs_data *ffs)
 {
         int ret;
@@ -210,7 +198,7 @@ static int functionfs_ready_callback(struct ffs_data *ffs)
                 return -EBUSY;
 
         gfs_ffs_data = ffs;
-        ret = usb_composite_register(&gfs_driver);
+        ret = usb_composite_probe(&gfs_driver, gfs_bind);
         if (unlikely(ret < 0))
                 clear_bit(0, &gfs_registered);
         return ret;
@@ -224,14 +212,11 @@ static void functionfs_closed_callback(struct ffs_data *ffs)
                 usb_composite_unregister(&gfs_driver);
 }
 
-
 static int functionfs_check_dev_callback(const char *dev_name)
 {
         return 0;
 }
 
-
-
 static int gfs_bind(struct usb_composite_dev *cdev)
 {
         int ret, i;
@@ -245,20 +230,10 @@ static int gfs_bind(struct usb_composite_dev *cdev)
         if (unlikely(ret < 0))
                 goto error_quick;
 
-        gfs_dev_desc.idVendor  = cpu_to_le16(gfs_vendor_id);
-        gfs_dev_desc.idProduct = cpu_to_le16(gfs_product_id);
-
-        snprintf(gfs_manufacturer, sizeof gfs_manufacturer, "%s %s with %s",
-                 init_utsname()->sysname, init_utsname()->release,
-                 cdev->gadget->name);
-
         ret = usb_string_ids_tab(cdev, gfs_strings);
         if (unlikely(ret < 0))
                 goto error;
 
-        gfs_dev_desc.iManufacturer = gfs_strings[GFS_STRING_MANUFACTURER_IDX].id;
-        gfs_dev_desc.iProduct      = gfs_strings[GFS_STRING_PRODUCT_IDX].id;
-
         ret = functionfs_bind(gfs_ffs_data, cdev);
         if (unlikely(ret < 0))
                 goto error;
@@ -266,14 +241,12 @@ static int gfs_bind(struct usb_composite_dev *cdev)
         for (i = 0; i < ARRAY_SIZE(gfs_configurations); ++i) {
                 struct gfs_configuration *c = gfs_configurations + i;
 
-                ret = GFS_STRING_FIRST_CONFIG_IDX + i;
-                c->c.label                      = gfs_strings[ret].s;
-                c->c.iConfiguration             = gfs_strings[ret].id;
-                c->c.bind                       = gfs_do_config;
+                c->c.label                      = gfs_strings[i].s;
+                c->c.iConfiguration             = gfs_strings[i].id;
                 c->c.bConfigurationValue        = 1 + i;
                 c->c.bmAttributes               = USB_CONFIG_ATT_SELFPOWER;
 
-                ret = usb_add_config(cdev, &c->c);
+                ret = usb_add_config(cdev, &c->c, gfs_do_config);
                 if (unlikely(ret < 0))
                         goto error_unbind;
         }
@@ -293,13 +266,14 @@ static int gfs_unbind(struct usb_composite_dev *cdev)
 {
         ENTER();
 
-        /* We may have been called in an error recovery frem
+        /*
+         * We may have been called in an error recovery from
          * composite_bind() after gfs_unbind() failure so we need to
          * check if gfs_ffs_data is not NULL since gfs_bind() handles
          * all error recovery itself.  I'd rather we werent called
          * from composite on orror recovery, but what you're gonna
-         * do...? */
-
+         * do...?
+         */
         if (gfs_ffs_data) {
                 gether_cleanup();
                 functionfs_unbind(gfs_ffs_data);
@@ -309,7 +283,6 @@ static int gfs_unbind(struct usb_composite_dev *cdev)
         return 0;
 }
 
-
 static int gfs_do_config(struct usb_configuration *c)
 {
         struct gfs_configuration *gc =
@@ -334,26 +307,29 @@ static int gfs_do_config(struct usb_configuration *c)
         if (unlikely(ret < 0))
                 return ret;
 
-        /* After previous do_configs there may be some invalid
+        /*
+         * After previous do_configs there may be some invalid
          * pointers in c->interface array.  This happens every time
          * a user space function with fewer interfaces than a user
          * space function that was run before the new one is run.  The
          * compasit's set_config() assumes that if there is no more
          * then MAX_CONFIG_INTERFACES interfaces in a configuration
          * then there is a NULL pointer after the last interface in
-         * c->interface array.  We need to make sure this is true. */
+         * c->interface array.  We need to make sure this is true.
+         */
         if (c->next_interface_id < ARRAY_SIZE(c->interface))
                 c->interface[c->next_interface_id] = NULL;
 
         return 0;
 }
 
-
 #ifdef CONFIG_USB_FUNCTIONFS_ETH
+
 static int eth_bind_config(struct usb_configuration *c, u8 ethaddr[ETH_ALEN])
 {
         return can_support_ecm(c->cdev->gadget)
                 ? ecm_bind_config(c, ethaddr)
                 : geth_bind_config(c, ethaddr);
 }
+
 #endif
diff --git a/drivers/usb/gadget/gadget_chips.h b/drivers/usb/gadget/gadget_chips.h
index e511fec9f26d..bcdac7c73e89 100644
--- a/drivers/usb/gadget/gadget_chips.h
+++ b/drivers/usb/gadget/gadget_chips.h
@@ -45,12 +45,6 @@
 #define gadget_is_goku(g)       0
 #endif
 
-#ifdef CONFIG_USB_GADGET_LH7A40X
-#define gadget_is_lh7a40x(g)    !strcmp("lh7a40x_udc", (g)->name)
-#else
-#define gadget_is_lh7a40x(g)    0
-#endif
-
 #ifdef CONFIG_USB_GADGET_OMAP
 #define gadget_is_omap(g)       !strcmp("omap_udc", (g)->name)
 #else
@@ -96,7 +90,7 @@
 
 /* Mentor high speed "dual role" controller, in peripheral role */
 #ifdef CONFIG_USB_GADGET_MUSB_HDRC
-#define gadget_is_musbhdrc(g)   !strcmp("musb_hdrc", (g)->name)
+#define gadget_is_musbhdrc(g)   !strcmp("musb-hdrc", (g)->name)
 #else
 #define gadget_is_musbhdrc(g)   0
 #endif
@@ -120,10 +114,10 @@
 #define gadget_is_fsl_qe(g)     0
 #endif
 
-#ifdef CONFIG_USB_GADGET_CI13XXX
-#define gadget_is_ci13xxx(g)    (!strcmp("ci13xxx_udc", (g)->name))
+#ifdef CONFIG_USB_GADGET_CI13XXX_PCI
+#define gadget_is_ci13xxx_pci(g)        (!strcmp("ci13xxx_pci", (g)->name))
 #else
-#define gadget_is_ci13xxx(g)    0
+#define gadget_is_ci13xxx_pci(g)        0
 #endif
 
 // CONFIG_USB_GADGET_SX2
@@ -142,6 +136,29 @@
 #define gadget_is_s3c_hsotg(g)    0
 #endif
 
+#ifdef CONFIG_USB_S3C_HSUDC
+#define gadget_is_s3c_hsudc(g) (!strcmp("s3c-hsudc", (g)->name))
+#else
+#define gadget_is_s3c_hsudc(g) 0
+#endif
+
+#ifdef CONFIG_USB_GADGET_EG20T
+#define gadget_is_pch(g)        (!strcmp("pch_udc", (g)->name))
+#else
+#define gadget_is_pch(g)        0
+#endif
+
+#ifdef CONFIG_USB_GADGET_CI13XXX_MSM
+#define gadget_is_ci13xxx_msm(g)        (!strcmp("ci13xxx_msm", (g)->name))
+#else
+#define gadget_is_ci13xxx_msm(g)        0
+#endif
+
+#ifdef CONFIG_USB_GADGET_RENESAS_USBHS
+#define gadget_is_renesas_usbhs(g) (!strcmp("renesas_usbhs_udc", (g)->name))
+#else
+#define gadget_is_renesas_usbhs(g) 0
+#endif
 
 /**
  * usb_gadget_controller_number - support bcdDevice id convention
@@ -170,8 +187,6 @@ static inline int usb_gadget_controller_number(struct usb_gadget *gadget)
                 return 0x06;
         else if (gadget_is_omap(gadget))
                 return 0x08;
-        else if (gadget_is_lh7a40x(gadget))
-                return 0x09;
         else if (gadget_is_pxa27x(gadget))
                 return 0x11;
         else if (gadget_is_s3c2410(gadget))
@@ -192,7 +207,7 @@ static inline int usb_gadget_controller_number(struct usb_gadget *gadget)
                 return 0x21;
         else if (gadget_is_fsl_qe(gadget))
                 return 0x22;
-        else if (gadget_is_ci13xxx(gadget))
+        else if (gadget_is_ci13xxx_pci(gadget))
                 return 0x23;
         else if (gadget_is_langwell(gadget))
                 return 0x24;
@@ -200,6 +215,15 @@ static inline int usb_gadget_controller_number(struct usb_gadget *gadget)
                 return 0x25;
         else if (gadget_is_s3c_hsotg(gadget))
                 return 0x26;
+        else if (gadget_is_pch(gadget))
+                return 0x27;
+        else if (gadget_is_ci13xxx_msm(gadget))
+                return 0x28;
+        else if (gadget_is_renesas_usbhs(gadget))
+                return 0x29;
+        else if (gadget_is_s3c_hsudc(gadget))
+                return 0x30;
+
         return -ENOENT;
 }
 
diff --git a/drivers/usb/gadget/gmidi.c b/drivers/usb/gadget/gmidi.c
index 1b413a5cc3f6..47b86b99d449 100644
--- a/drivers/usb/gadget/gmidi.c
+++ b/drivers/usb/gadget/gmidi.c
@@ -67,7 +67,7 @@ MODULE_PARM_DESC(index, "Index value for the USB MIDI Gadget adapter.");
 module_param(id, charp, 0444);
 MODULE_PARM_DESC(id, "ID string for the USB MIDI Gadget adapter.");
 
-/* Some systems will want different product identifers published in the
+/* Some systems will want different product identifiers published in the
  * device descriptor, either numbers or strings or both.  These string
  * parameters are in UTF-8 (superset of ASCII's 7 bit characters).
  */
@@ -1157,7 +1157,7 @@ fail:
 /*
  * Creates an output endpoint, and initializes output ports.
  */
-static int __ref gmidi_bind(struct usb_gadget *gadget)
+static int __init gmidi_bind(struct usb_gadget *gadget)
 {
         struct gmidi_device *dev;
         struct usb_ep *in_ep, *out_ep;
@@ -1292,7 +1292,6 @@ static void gmidi_resume(struct usb_gadget *gadget)
 static struct usb_gadget_driver gmidi_driver = {
         .speed          = USB_SPEED_FULL,
         .function       = (char *)longname,
-        .bind           = gmidi_bind,
         .unbind         = gmidi_unbind,
 
         .setup          = gmidi_setup,
@@ -1309,7 +1308,7 @@ static struct usb_gadget_driver gmidi_driver = {
 
 static int __init gmidi_init(void)
 {
-        return usb_gadget_register_driver(&gmidi_driver);
+        return usb_gadget_probe_driver(&gmidi_driver, gmidi_bind);
 }
 module_init(gmidi_init);
 
diff --git a/drivers/usb/gadget/goku_udc.c b/drivers/usb/gadget/goku_udc.c
index 1088d08c7ed8..bf6e11c758d5 100644
--- a/drivers/usb/gadget/goku_udc.c
+++ b/drivers/usb/gadget/goku_udc.c
@@ -38,6 +38,7 @@
 #include <linux/device.h>
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
+#include <linux/prefetch.h>
 
 #include <asm/byteorder.h>
 #include <asm/io.h>
@@ -1343,14 +1344,15 @@ static struct goku_udc	*the_controller;
  * disconnect is reported.  then a host may connect again, or
  * the driver might get unbound.
  */
-int usb_gadget_register_driver(struct usb_gadget_driver *driver)
+int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
+                int (*bind)(struct usb_gadget *))
 {
         struct goku_udc *dev = the_controller;
         int                     retval;
 
         if (!driver
                         || driver->speed < USB_SPEED_FULL
-                        || !driver->bind
+                        || !bind
                         || !driver->disconnect
                         || !driver->setup)
                 return -EINVAL;
@@ -1363,7 +1365,7 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver)
         driver->driver.bus = NULL;
         dev->driver = driver;
         dev->gadget.dev.driver = &driver->driver;
-        retval = driver->bind(&dev->gadget);
+        retval = bind(&dev->gadget);
         if (retval) {
                 DBG(dev, "bind to driver %s --> error %d\n",
                                 driver->driver.name, retval);
@@ -1380,7 +1382,7 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver)
         DBG(dev, "registered gadget driver '%s'\n", driver->driver.name);
         return 0;
 }
-EXPORT_SYMBOL(usb_gadget_register_driver);
+EXPORT_SYMBOL(usb_gadget_probe_driver);
 
 static void
 stop_activity(struct goku_udc *dev, struct usb_gadget_driver *driver)
@@ -1744,7 +1746,8 @@ static void goku_remove(struct pci_dev *pdev)
                                 pci_resource_len (pdev, 0));
         if (dev->enabled)
                 pci_disable_device(pdev);
-        device_unregister(&dev->gadget.dev);
+        if (dev->registered)
+                device_unregister(&dev->gadget.dev);
 
         pci_set_drvdata(pdev, NULL);
         dev->regs = NULL;
@@ -1774,7 +1777,7 @@ static int goku_probe(struct pci_dev *pdev, const struct pci_device_id *id)
         if (!pdev->irq) {
                 printk(KERN_ERR "Check PCI %s IRQ setup!\n", pci_name(pdev));
                 retval = -ENODEV;
-                goto done;
+                goto err;
         }
 
         /* alloc, and start init */
@@ -1782,7 +1785,7 @@ static int goku_probe(struct pci_dev *pdev, const struct pci_device_id *id)
         if (dev == NULL){
                 pr_debug("enomem %s\n", pci_name(pdev));
                 retval = -ENOMEM;
-                goto done;
+                goto err;
         }
 
         spin_lock_init(&dev->lock);
@@ -1800,7 +1803,7 @@ static int goku_probe(struct pci_dev *pdev, const struct pci_device_id *id)
         retval = pci_enable_device(pdev);
         if (retval < 0) {
                 DBG(dev, "can't enable, %d\n", retval);
-                goto done;
+                goto err;
         }
         dev->enabled = 1;
 
@@ -1809,7 +1812,7 @@ static int goku_probe(struct pci_dev *pdev, const struct pci_device_id *id)
         if (!request_mem_region(resource, len, driver_name)) {
                 DBG(dev, "controller already in use\n");
                 retval = -EBUSY;
-                goto done;
+                goto err;
         }
         dev->got_region = 1;
 
@@ -1817,7 +1820,7 @@ static int goku_probe(struct pci_dev *pdev, const struct pci_device_id *id)
         if (base == NULL) {
                 DBG(dev, "can't map memory\n");
                 retval = -EFAULT;
-                goto done;
+                goto err;
         }
         dev->regs = (struct goku_udc_regs __iomem *) base;
 
@@ -1833,7 +1836,7 @@ static int goku_probe(struct pci_dev *pdev, const struct pci_device_id *id)
                         driver_name, dev) != 0) {
                 DBG(dev, "request interrupt %d failed\n", pdev->irq);
                 retval = -EBUSY;
-                goto done;
+                goto err;
         }
         dev->got_irq = 1;
         if (use_dma)
@@ -1844,13 +1847,16 @@ static int goku_probe(struct pci_dev *pdev, const struct pci_device_id *id)
         create_proc_read_entry(proc_node_name, 0, NULL, udc_proc_read, dev);
 #endif
 
-        /* done */
         the_controller = dev;
         retval = device_register(&dev->gadget.dev);
-        if (retval == 0)
-                return 0;
+        if (retval) {
+                put_device(&dev->gadget.dev);
+                goto err;
+        }
+        dev->registered = 1;
+        return 0;
 
-done:
+err:
         if (dev)
                 goku_remove (pdev);
         return retval;
diff --git a/drivers/usb/gadget/goku_udc.h b/drivers/usb/gadget/goku_udc.h
index 566cb2319056..e7e0c69d3b1f 100644
--- a/drivers/usb/gadget/goku_udc.h
+++ b/drivers/usb/gadget/goku_udc.h
@@ -251,7 +251,8 @@ struct goku_udc {
                                         got_region:1,
                                         req_config:1,
                                         configured:1,
-                                        enabled:1;
+                                        enabled:1,
+                                        registered:1;
 
         /* pci state used to access those endpoints */
         struct pci_dev                  *pdev;
diff --git a/drivers/usb/gadget/hid.c b/drivers/usb/gadget/hid.c
index 735495bf8411..2523e54097bd 100644
--- a/drivers/usb/gadget/hid.c
+++ b/drivers/usb/gadget/hid.c
@@ -127,7 +127,7 @@ static struct usb_gadget_strings *dev_strings[] = {
 
 /****************************** Configurations ******************************/
 
-static int __ref do_config(struct usb_configuration *c)
+static int __init do_config(struct usb_configuration *c)
 {
         struct hidg_func_node *e;
         int func = 0, status = 0;
@@ -148,7 +148,6 @@ static int __ref do_config(struct usb_configuration *c)
 
 static struct usb_configuration config_driver = {
         .label                  = "HID Gadget",
-        .bind                   = do_config,
         .bConfigurationValue    = 1,
         /* .iConfiguration = DYNAMIC */
         .bmAttributes           = USB_CONFIG_ATT_SELFPOWER,
@@ -156,7 +155,7 @@ static struct usb_configuration config_driver = {
 
 /****************************** Gadget Bind ******************************/
 
-static int __ref hid_bind(struct usb_composite_dev *cdev)
+static int __init hid_bind(struct usb_composite_dev *cdev)
 {
         struct usb_gadget *gadget = cdev->gadget;
         struct list_head *tmp;
@@ -201,7 +200,7 @@ static int __ref hid_bind(struct usb_composite_dev *cdev)
         device_desc.iProduct = status;
 
         /* register our configuration */
-        status = usb_add_config(cdev, &config_driver);
+        status = usb_add_config(cdev, &config_driver, do_config);
         if (status < 0)
                 return status;
 
@@ -256,7 +255,6 @@ static struct usb_composite_driver hidg_driver = {
         .name           = "g_hid",
         .dev            = &device_desc,
         .strings        = dev_strings,
-        .bind           = hid_bind,
         .unbind         = __exit_p(hid_unbind),
 };
 
@@ -282,7 +280,7 @@ static int __init hidg_init(void)
         if (status < 0)
                 return status;
 
-        status = usb_composite_register(&hidg_driver);
+        status = usb_composite_probe(&hidg_driver, hid_bind);
         if (status < 0)
                 platform_driver_unregister(&hidg_plat_driver);
 
diff --git a/drivers/usb/gadget/imx_udc.c b/drivers/usb/gadget/imx_udc.c
index e743122fcd93..ade40066decf 100644
--- a/drivers/usb/gadget/imx_udc.c
+++ b/drivers/usb/gadget/imx_udc.c
@@ -30,6 +30,7 @@
 #include <linux/delay.h>
 #include <linux/timer.h>
 #include <linux/slab.h>
+#include <linux/prefetch.h>
 
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
@@ -1191,13 +1192,17 @@ static irqreturn_t imx_udc_ctrl_irq(int irq, void *dev)
         return IRQ_HANDLED;
 }
 
+#ifndef MX1_INT_USBD0
+#define MX1_INT_USBD0 MX1_USBD_INT0
+#endif
+
 static irqreturn_t imx_udc_bulk_irq(int irq, void *dev)
 {
         struct imx_udc_struct *imx_usb = dev;
-        struct imx_ep_struct *imx_ep = &imx_usb->imx_ep[irq - USBD_INT0];
+        struct imx_ep_struct *imx_ep = &imx_usb->imx_ep[irq - MX1_INT_USBD0];
         int intr = __raw_readl(imx_usb->base + USB_EP_INTR(EP_NO(imx_ep)));
 
-        dump_ep_intr(__func__, irq - USBD_INT0, intr, imx_usb->dev);
+        dump_ep_intr(__func__, irq - MX1_INT_USBD0, intr, imx_usb->dev);
 
         if (!imx_usb->driver) {
                 __raw_writel(intr, imx_usb->base + USB_EP_INTR(EP_NO(imx_ep)));
@@ -1316,17 +1321,18 @@ static struct imx_udc_struct controller = {
 };
 
 /*******************************************************************************
- * USB gadged driver functions
+ * USB gadget driver functions
  *******************************************************************************
  */
-int usb_gadget_register_driver(struct usb_gadget_driver *driver)
+int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
+                int (*bind)(struct usb_gadget *))
 {
         struct imx_udc_struct *imx_usb = &controller;
         int retval;
 
         if (!driver
                 || driver->speed < USB_SPEED_FULL
-                || !driver->bind
+                || !bind
                 || !driver->disconnect
                 || !driver->setup)
                         return -EINVAL;
@@ -1342,7 +1348,7 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver)
         retval = device_add(&imx_usb->gadget.dev);
         if (retval)
                 goto fail;
-        retval = driver->bind(&imx_usb->gadget);
+        retval = bind(&imx_usb->gadget);
         if (retval) {
                 D_ERR(imx_usb->dev, "<%s> bind to driver %s --> error %d\n",
                         __func__, driver->driver.name, retval);
@@ -1362,7 +1368,7 @@ fail:
         imx_usb->gadget.dev.driver = NULL;
         return retval;
 }
-EXPORT_SYMBOL(usb_gadget_register_driver);
+EXPORT_SYMBOL(usb_gadget_probe_driver);
 
 int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
 {
diff --git a/drivers/usb/gadget/imx_udc.h b/drivers/usb/gadget/imx_udc.h
index b48ad59603d1..7136c242b4ec 100644
--- a/drivers/usb/gadget/imx_udc.h
+++ b/drivers/usb/gadget/imx_udc.h
@@ -23,9 +23,6 @@
 /* Helper macros */
 #define EP_NO(ep)       ((ep->bEndpointAddress) & ~USB_DIR_IN) /* IN:1, OUT:0 */
 #define EP_DIR(ep)      ((ep->bEndpointAddress) & USB_DIR_IN ? 1 : 0)
-#define irq_to_ep(irq)  (((irq) >= USBD_INT0) || ((irq) <= USBD_INT6) \
-                ? ((irq) - USBD_INT0) : (USBD_INT6)) /*should not happen*/
-#define ep_to_irq(ep)   (EP_NO((ep)) + USBD_INT0)
 #define IMX_USB_NB_EP   6
 
 /* Driver structures */
diff --git a/drivers/usb/gadget/inode.c b/drivers/usb/gadget/inode.c
index fc35406fc80c..a56876aaf76c 100644
--- a/drivers/usb/gadget/inode.c
+++ b/drivers/usb/gadget/inode.c
@@ -33,7 +33,6 @@
 #include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/poll.h>
-#include <linux/smp_lock.h>
 
 #include <linux/device.h>
 #include <linux/moduleparam.h>
@@ -387,8 +386,10 @@ ep_read (struct file *fd, char __user *buf, size_t len, loff_t *ptr)
 
         /* halt any endpoint by doing a "wrong direction" i/o call */
         if (usb_endpoint_dir_in(&data->desc)) {
-                if (usb_endpoint_xfer_isoc(&data->desc))
+                if (usb_endpoint_xfer_isoc(&data->desc)) {
+                        mutex_unlock(&data->lock);
                         return -EINVAL;
+                }
                 DBG (data->dev, "%s halt\n", data->name);
                 spin_lock_irq (&data->dev->lock);
                 if (likely (data->ep != NULL))
@@ -430,8 +431,10 @@ ep_write (struct file *fd, const char __user *buf, size_t len, loff_t *ptr)
 
         /* halt any endpoint by doing a "wrong direction" i/o call */
         if (!usb_endpoint_dir_in(&data->desc)) {
-                if (usb_endpoint_xfer_isoc(&data->desc))
+                if (usb_endpoint_xfer_isoc(&data->desc)) {
+                        mutex_unlock(&data->lock);
                         return -EINVAL;
+                }
                 DBG (data->dev, "%s halt\n", data->name);
                 spin_lock_irq (&data->dev->lock);
                 if (likely (data->ep != NULL))
@@ -1775,7 +1778,6 @@ static struct usb_gadget_driver gadgetfs_driver = {
         .speed          = USB_SPEED_FULL,
 #endif
         .function       = (char *) driver_desc,
-        .bind           = gadgetfs_bind,
         .unbind         = gadgetfs_unbind,
         .setup          = gadgetfs_setup,
         .disconnect     = gadgetfs_disconnect,
@@ -1798,7 +1800,6 @@ static int gadgetfs_probe (struct usb_gadget *gadget)
 
 static struct usb_gadget_driver probe_driver = {
         .speed          = USB_SPEED_HIGH,
-        .bind           = gadgetfs_probe,
         .unbind         = gadgetfs_nop,
         .setup          = (void *)gadgetfs_nop,
         .disconnect     = gadgetfs_nop,
@@ -1908,7 +1909,7 @@ dev_config (struct file *fd, const char __user *buf, size_t len, loff_t *ptr)
 
         /* triggers gadgetfs_bind(); then we can enumerate. */
         spin_unlock_irq (&dev->lock);
-        value = usb_gadget_register_driver (&gadgetfs_driver);
+        value = usb_gadget_probe_driver(&gadgetfs_driver, gadgetfs_bind);
         if (value != 0) {
                 kfree (dev->buf);
                 dev->buf = NULL;
@@ -1994,6 +1995,7 @@ gadgetfs_make_inode (struct super_block *sb,
         struct inode *inode = new_inode (sb);
 
         if (inode) {
+                inode->i_ino = get_next_ino();
                 inode->i_mode = mode;
                 inode->i_uid = default_uid;
                 inode->i_gid = default_gid;
@@ -2047,7 +2049,7 @@ gadgetfs_fill_super (struct super_block *sb, void *opts, int silent)
                 return -ESRCH;
 
         /* fake probe to determine $CHIP */
-        (void) usb_gadget_register_driver (&probe_driver);
+        (void) usb_gadget_probe_driver(&probe_driver, gadgetfs_probe);
         if (!CHIP)
                 return -ENODEV;
 
@@ -2099,11 +2101,11 @@ enomem0:
 }
 
 /* "mount -t gadgetfs path /dev/gadget" ends up here */
-static int
-gadgetfs_get_sb (struct file_system_type *t, int flags,
-                const char *path, void *opts, struct vfsmount *mnt)
+static struct dentry *
+gadgetfs_mount (struct file_system_type *t, int flags,
+                const char *path, void *opts)
 {
-        return get_sb_single (t, flags, opts, gadgetfs_fill_super, mnt);
+        return mount_single (t, flags, opts, gadgetfs_fill_super);
 }
 
 static void
@@ -2121,7 +2123,7 @@ gadgetfs_kill_sb (struct super_block *sb)
 static struct file_system_type gadgetfs_type = {
         .owner          = THIS_MODULE,
         .name           = shortname,
-        .get_sb         = gadgetfs_get_sb,
+        .mount          = gadgetfs_mount,
         .kill_sb        = gadgetfs_kill_sb,
 };
 
diff --git a/drivers/usb/gadget/langwell_udc.c b/drivers/usb/gadget/langwell_udc.c
index c2d2a201f84b..9cee88a43a73 100644
--- a/drivers/usb/gadget/langwell_udc.c
+++ b/drivers/usb/gadget/langwell_udc.c
@@ -19,7 +19,7 @@
 
 
 /* #undef       DEBUG */
-/* #undef       VERBOSE */
+/* #undef       VERBOSE_DEBUG */
 
 #if defined(CONFIG_USB_LANGWELL_OTG)
 #define OTG_TRANSCEIVER
@@ -77,141 +77,110 @@ langwell_ep0_desc = {
 /*-------------------------------------------------------------------------*/
 /* debugging */
 
-#ifdef  DEBUG
-#define DBG(dev, fmt, args...) \
-        pr_debug("%s %s: " fmt , driver_name, \
-                        pci_name(dev->pdev), ## args)
-#else
-#define DBG(dev, fmt, args...) \
-        do { } while (0)
-#endif /* DEBUG */
-
-
-#ifdef  VERBOSE
-#define VDBG DBG
-#else
-#define VDBG(dev, fmt, args...) \
-        do { } while (0)
-#endif  /* VERBOSE */
-
-
-#define ERROR(dev, fmt, args...) \
-        pr_err("%s %s: " fmt , driver_name, \
-                        pci_name(dev->pdev), ## args)
-
-#define WARNING(dev, fmt, args...) \
-        pr_warning("%s %s: " fmt , driver_name, \
-                        pci_name(dev->pdev), ## args)
-
-#define INFO(dev, fmt, args...) \
-        pr_info("%s %s: " fmt , driver_name, \
-                        pci_name(dev->pdev), ## args)
-
-
-#ifdef  VERBOSE
+#ifdef  VERBOSE_DEBUG
 static inline void print_all_registers(struct langwell_udc *dev)
 {
         int     i;
 
         /* Capability Registers */
-        printk(KERN_DEBUG "Capability Registers (offset: "
-                        "0x%04x, length: 0x%08x)\n",
-                        CAP_REG_OFFSET,
-                        (u32)sizeof(struct langwell_cap_regs));
-        printk(KERN_DEBUG "caplength=0x%02x\n",
+        dev_dbg(&dev->pdev->dev,
+                "Capability Registers (offset: 0x%04x, length: 0x%08x)\n",
+                CAP_REG_OFFSET, (u32)sizeof(struct langwell_cap_regs));
+        dev_dbg(&dev->pdev->dev, "caplength=0x%02x\n",
                         readb(&dev->cap_regs->caplength));
-        printk(KERN_DEBUG "hciversion=0x%04x\n",
+        dev_dbg(&dev->pdev->dev, "hciversion=0x%04x\n",
                         readw(&dev->cap_regs->hciversion));
-        printk(KERN_DEBUG "hcsparams=0x%08x\n",
+        dev_dbg(&dev->pdev->dev, "hcsparams=0x%08x\n",
                         readl(&dev->cap_regs->hcsparams));
-        printk(KERN_DEBUG "hccparams=0x%08x\n",
+        dev_dbg(&dev->pdev->dev, "hccparams=0x%08x\n",
                         readl(&dev->cap_regs->hccparams));
-        printk(KERN_DEBUG "dciversion=0x%04x\n",
+        dev_dbg(&dev->pdev->dev, "dciversion=0x%04x\n",
                         readw(&dev->cap_regs->dciversion));
-        printk(KERN_DEBUG "dccparams=0x%08x\n",
+        dev_dbg(&dev->pdev->dev, "dccparams=0x%08x\n",
                         readl(&dev->cap_regs->dccparams));
 
         /* Operational Registers */
-        printk(KERN_DEBUG "Operational Registers (offset: "
-                        "0x%04x, length: 0x%08x)\n",
-                        OP_REG_OFFSET,
-                        (u32)sizeof(struct langwell_op_regs));
-        printk(KERN_DEBUG "extsts=0x%08x\n",
+        dev_dbg(&dev->pdev->dev,
+                "Operational Registers (offset: 0x%04x, length: 0x%08x)\n",
+                OP_REG_OFFSET, (u32)sizeof(struct langwell_op_regs));
+        dev_dbg(&dev->pdev->dev, "extsts=0x%08x\n",
                         readl(&dev->op_regs->extsts));
-        printk(KERN_DEBUG "extintr=0x%08x\n",
+        dev_dbg(&dev->pdev->dev, "extintr=0x%08x\n",
                         readl(&dev->op_regs->extintr));
-        printk(KERN_DEBUG "usbcmd=0x%08x\n",
+        dev_dbg(&dev->pdev->dev, "usbcmd=0x%08x\n",
                         readl(&dev->op_regs->usbcmd));
-        printk(KERN_DEBUG "usbsts=0x%08x\n",
+        dev_dbg(&dev->pdev->dev, "usbsts=0x%08x\n",
                         readl(&dev->op_regs->usbsts));
-        printk(KERN_DEBUG "usbintr=0x%08x\n",
+        dev_dbg(&dev->pdev->dev, "usbintr=0x%08x\n",
                         readl(&dev->op_regs->usbintr));
-        printk(KERN_DEBUG "frindex=0x%08x\n",
+        dev_dbg(&dev->pdev->dev, "frindex=0x%08x\n",
                         readl(&dev->op_regs->frindex));
-        printk(KERN_DEBUG "ctrldssegment=0x%08x\n",
+        dev_dbg(&dev->pdev->dev, "ctrldssegment=0x%08x\n",
                         readl(&dev->op_regs->ctrldssegment));
-        printk(KERN_DEBUG "deviceaddr=0x%08x\n",
+        dev_dbg(&dev->pdev->dev, "deviceaddr=0x%08x\n",
                         readl(&dev->op_regs->deviceaddr));
-        printk(KERN_DEBUG "endpointlistaddr=0x%08x\n",
+        dev_dbg(&dev->pdev->dev, "endpointlistaddr=0x%08x\n",
                         readl(&dev->op_regs->endpointlistaddr));
-        printk(KERN_DEBUG "ttctrl=0x%08x\n",
+        dev_dbg(&dev->pdev->dev, "ttctrl=0x%08x\n",
                         readl(&dev->op_regs->ttctrl));
-        printk(KERN_DEBUG "burstsize=0x%08x\n",
+        dev_dbg(&dev->pdev->dev, "burstsize=0x%08x\n",
                         readl(&dev->op_regs->burstsize));
-        printk(KERN_DEBUG "txfilltuning=0x%08x\n",
+        dev_dbg(&dev->pdev->dev, "txfilltuning=0x%08x\n",
                         readl(&dev->op_regs->txfilltuning));
-        printk(KERN_DEBUG "txttfilltuning=0x%08x\n",
+        dev_dbg(&dev->pdev->dev, "txttfilltuning=0x%08x\n",
                         readl(&dev->op_regs->txttfilltuning));
-        printk(KERN_DEBUG "ic_usb=0x%08x\n",
+        dev_dbg(&dev->pdev->dev, "ic_usb=0x%08x\n",
                         readl(&dev->op_regs->ic_usb));
-        printk(KERN_DEBUG "ulpi_viewport=0x%08x\n",
+        dev_dbg(&dev->pdev->dev, "ulpi_viewport=0x%08x\n",
                         readl(&dev->op_regs->ulpi_viewport));
-        printk(KERN_DEBUG "configflag=0x%08x\n",
+        dev_dbg(&dev->pdev->dev, "configflag=0x%08x\n",
                         readl(&dev->op_regs->configflag));
-        printk(KERN_DEBUG "portsc1=0x%08x\n",
+        dev_dbg(&dev->pdev->dev, "portsc1=0x%08x\n",
                         readl(&dev->op_regs->portsc1));
-        printk(KERN_DEBUG "devlc=0x%08x\n",
+        dev_dbg(&dev->pdev->dev, "devlc=0x%08x\n",
                         readl(&dev->op_regs->devlc));
-        printk(KERN_DEBUG "otgsc=0x%08x\n",
+        dev_dbg(&dev->pdev->dev, "otgsc=0x%08x\n",
                         readl(&dev->op_regs->otgsc));
-        printk(KERN_DEBUG "usbmode=0x%08x\n",
+        dev_dbg(&dev->pdev->dev, "usbmode=0x%08x\n",
                         readl(&dev->op_regs->usbmode));
-        printk(KERN_DEBUG "endptnak=0x%08x\n",
+        dev_dbg(&dev->pdev->dev, "endptnak=0x%08x\n",
                         readl(&dev->op_regs->endptnak));
-        printk(KERN_DEBUG "endptnaken=0x%08x\n",
+        dev_dbg(&dev->pdev->dev, "endptnaken=0x%08x\n",
                         readl(&dev->op_regs->endptnaken));
-        printk(KERN_DEBUG "endptsetupstat=0x%08x\n",
+        dev_dbg(&dev->pdev->dev, "endptsetupstat=0x%08x\n",
                         readl(&dev->op_regs->endptsetupstat));
-        printk(KERN_DEBUG "endptprime=0x%08x\n",
+        dev_dbg(&dev->pdev->dev, "endptprime=0x%08x\n",
                         readl(&dev->op_regs->endptprime));
-        printk(KERN_DEBUG "endptflush=0x%08x\n",
+        dev_dbg(&dev->pdev->dev, "endptflush=0x%08x\n",
                         readl(&dev->op_regs->endptflush));
-        printk(KERN_DEBUG "endptstat=0x%08x\n",
+        dev_dbg(&dev->pdev->dev, "endptstat=0x%08x\n",
                         readl(&dev->op_regs->endptstat));
-        printk(KERN_DEBUG "endptcomplete=0x%08x\n",
+        dev_dbg(&dev->pdev->dev, "endptcomplete=0x%08x\n",
                         readl(&dev->op_regs->endptcomplete));
 
         for (i = 0; i < dev->ep_max / 2; i++) {
-                printk(KERN_DEBUG "endptctrl[%d]=0x%08x\n",
+                dev_dbg(&dev->pdev->dev, "endptctrl[%d]=0x%08x\n",
                                 i, readl(&dev->op_regs->endptctrl[i]));
         }
 }
-#endif /* VERBOSE */
+#else
+
+#define print_all_registers(dev)        do { } while (0)
+
+#endif /* VERBOSE_DEBUG */
 
 
 /*-------------------------------------------------------------------------*/
 
-#define DIR_STRING(bAddress)    (((bAddress) & USB_DIR_IN) ? "in" : "out")
+#define is_in(ep)       (((ep)->ep_num == 0) ? ((ep)->dev->ep0_dir ==   \
+                        USB_DIR_IN) : (usb_endpoint_dir_in((ep)->desc)))
 
-#define is_in(ep)       (((ep)->ep_num == 0) ? ((ep)->dev->ep0_dir == \
-                        USB_DIR_IN) : ((ep)->desc->bEndpointAddress \
-                        & USB_DIR_IN) == USB_DIR_IN)
+#define DIR_STRING(ep)  (is_in(ep) ? "in" : "out")
 
 
-#ifdef  DEBUG
-static char *type_string(u8 bmAttributes)
+static char *type_string(const struct usb_endpoint_descriptor *desc)
 {
-        switch ((bmAttributes) & USB_ENDPOINT_XFERTYPE_MASK) {
+        switch (usb_endpoint_type(desc)) {
         case USB_ENDPOINT_XFER_BULK:
                 return "bulk";
         case USB_ENDPOINT_XFER_ISOC:
@@ -222,7 +191,6 @@ static char *type_string(u8 bmAttributes)
 
         return "control";
 }
-#endif
 
 
 /* configure endpoint control registers */
@@ -233,7 +201,7 @@ static void ep_reset(struct langwell_ep *ep, unsigned char ep_num,
         u32                     endptctrl;
 
         dev = ep->dev;
-        VDBG(dev, "---> %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
         endptctrl = readl(&dev->op_regs->endptctrl[ep_num]);
         if (is_in) {    /* TX */
@@ -250,7 +218,7 @@ static void ep_reset(struct langwell_ep *ep, unsigned char ep_num,
 
         writel(endptctrl, &dev->op_regs->endptctrl[ep_num]);
 
-        VDBG(dev, "<--- %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
 }
 
 
@@ -260,7 +228,7 @@ static void ep0_reset(struct langwell_udc *dev)
         struct langwell_ep      *ep;
         int                     i;
 
-        VDBG(dev, "---> %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
         /* ep0 in and out */
         for (i = 0; i < 2; i++) {
@@ -274,17 +242,18 @@ static void ep0_reset(struct langwell_udc *dev)
                 ep->dqh->dqh_ios = 1;
                 ep->dqh->dqh_mpl = EP0_MAX_PKT_SIZE;
 
-                /* FIXME: enable ep0-in HW zero length termination select */
+                /* enable ep0-in HW zero length termination select */
                 if (is_in(ep))
                         ep->dqh->dqh_zlt = 0;
                 ep->dqh->dqh_mult = 0;
 
+                ep->dqh->dtd_next = DTD_TERM;
+
                 /* configure ep0 control registers */
                 ep_reset(&dev->ep[0], 0, i, USB_ENDPOINT_XFER_CONTROL);
         }
 
-        VDBG(dev, "<--- %s()\n", __func__);
-        return;
+        dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
 }
 
 
@@ -300,12 +269,12 @@ static int langwell_ep_enable(struct usb_ep *_ep,
         struct langwell_ep      *ep;
         u16                     max = 0;
         unsigned long           flags;
-        int                     retval = 0;
+        int                     i, retval = 0;
         unsigned char           zlt, ios = 0, mult = 0;
 
         ep = container_of(_ep, struct langwell_ep, ep);
         dev = ep->dev;
-        VDBG(dev, "---> %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
         if (!_ep || !desc || ep->desc
                         || desc->bDescriptorType != USB_DT_ENDPOINT)
@@ -326,7 +295,7 @@ static int langwell_ep_enable(struct usb_ep *_ep,
          * sanity check type, direction, address, and then
          * initialize the endpoint capabilities fields in dQH
          */
-        switch (desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
+        switch (usb_endpoint_type(desc)) {
         case USB_ENDPOINT_XFER_CONTROL:
                 ios = 1;
                 break;
@@ -386,33 +355,36 @@ static int langwell_ep_enable(struct usb_ep *_ep,
 
         spin_lock_irqsave(&dev->lock, flags);
 
-        /* configure endpoint capabilities in dQH */
-        ep->dqh->dqh_ios = ios;
-        ep->dqh->dqh_mpl = cpu_to_le16(max);
-        ep->dqh->dqh_zlt = zlt;
-        ep->dqh->dqh_mult = mult;
-
         ep->ep.maxpacket = max;
         ep->desc = desc;
         ep->stopped = 0;
-        ep->ep_num = desc->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
+        ep->ep_num = usb_endpoint_num(desc);
 
         /* ep_type */
-        ep->ep_type = desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK;
+        ep->ep_type = usb_endpoint_type(desc);
 
         /* configure endpoint control registers */
         ep_reset(ep, ep->ep_num, is_in(ep), ep->ep_type);
 
-        DBG(dev, "enabled %s (ep%d%s-%s), max %04x\n",
+        /* configure endpoint capabilities in dQH */
+        i = ep->ep_num * 2 + is_in(ep);
+        ep->dqh = &dev->ep_dqh[i];
+        ep->dqh->dqh_ios = ios;
+        ep->dqh->dqh_mpl = cpu_to_le16(max);
+        ep->dqh->dqh_zlt = zlt;
+        ep->dqh->dqh_mult = mult;
+        ep->dqh->dtd_next = DTD_TERM;
+
+        dev_dbg(&dev->pdev->dev, "enabled %s (ep%d%s-%s), max %04x\n",
                         _ep->name,
                         ep->ep_num,
-                        DIR_STRING(desc->bEndpointAddress),
-                        type_string(desc->bmAttributes),
+                        DIR_STRING(ep),
+                        type_string(desc),
                         max);
 
         spin_unlock_irqrestore(&dev->lock, flags);
 done:
-        VDBG(dev, "<--- %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
         return retval;
 }
 
@@ -428,7 +400,7 @@ static void done(struct langwell_ep *ep, struct langwell_request *req,
         struct langwell_dtd     *curr_dtd, *next_dtd;
         int                     i;
 
-        VDBG(dev, "---> %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
         /* remove the req from ep->queue */
         list_del_init(&req->queue);
@@ -448,7 +420,8 @@ static void done(struct langwell_ep *ep, struct langwell_request *req,
         }
 
         if (req->mapped) {
-                dma_unmap_single(&dev->pdev->dev, req->req.dma, req->req.length,
+                dma_unmap_single(&dev->pdev->dev,
+                        req->req.dma, req->req.length,
                         is_in(ep) ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
                 req->req.dma = DMA_ADDR_INVALID;
                 req->mapped = 0;
@@ -458,9 +431,10 @@ static void done(struct langwell_ep *ep, struct langwell_request *req,
                                 is_in(ep) ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
 
         if (status != -ESHUTDOWN)
-                DBG(dev, "complete %s, req %p, stat %d, len %u/%u\n",
-                        ep->ep.name, &req->req, status,
-                        req->req.actual, req->req.length);
+                dev_dbg(&dev->pdev->dev,
+                                "complete %s, req %p, stat %d, len %u/%u\n",
+                                ep->ep.name, &req->req, status,
+                                req->req.actual, req->req.length);
 
         /* don't modify queue heads during completion callback */
         ep->stopped = 1;
@@ -473,7 +447,7 @@ static void done(struct langwell_ep *ep, struct langwell_request *req,
         spin_lock(&dev->lock);
         ep->stopped = stopped;
 
-        VDBG(dev, "<--- %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
 }
 
 
@@ -511,7 +485,7 @@ static int langwell_ep_disable(struct usb_ep *_ep)
 
         ep = container_of(_ep, struct langwell_ep, ep);
         dev = ep->dev;
-        VDBG(dev, "---> %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
         if (!_ep || !ep->desc)
                 return -EINVAL;
@@ -535,8 +509,8 @@ static int langwell_ep_disable(struct usb_ep *_ep)
 
         spin_unlock_irqrestore(&dev->lock, flags);
 
-        DBG(dev, "disabled %s\n", _ep->name);
-        VDBG(dev, "<--- %s()\n", __func__);
+        dev_dbg(&dev->pdev->dev, "disabled %s\n", _ep->name);
+        dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
 
         return 0;
 }
@@ -555,7 +529,7 @@ static struct usb_request *langwell_alloc_request(struct usb_ep *_ep,
 
         ep = container_of(_ep, struct langwell_ep, ep);
         dev = ep->dev;
-        VDBG(dev, "---> %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
         req = kzalloc(sizeof(*req), gfp_flags);
         if (!req)
@@ -564,8 +538,8 @@ static struct usb_request *langwell_alloc_request(struct usb_ep *_ep,
         req->req.dma = DMA_ADDR_INVALID;
         INIT_LIST_HEAD(&req->queue);
 
-        VDBG(dev, "alloc request for %s\n", _ep->name);
-        VDBG(dev, "<--- %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "alloc request for %s\n", _ep->name);
+        dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
         return &req->req;
 }
 
@@ -580,7 +554,7 @@ static void langwell_free_request(struct usb_ep *_ep,
 
         ep = container_of(_ep, struct langwell_ep, ep);
         dev = ep->dev;
-        VDBG(dev, "---> %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
         if (!_ep || !_req)
                 return;
@@ -591,8 +565,8 @@ static void langwell_free_request(struct usb_ep *_ep,
         if (_req)
                 kfree(req);
 
-        VDBG(dev, "free request for %s\n", _ep->name);
-        VDBG(dev, "<--- %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "free request for %s\n", _ep->name);
+        dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
 }
 
 
@@ -608,23 +582,24 @@ static int queue_dtd(struct langwell_ep *ep, struct langwell_request *req)
         struct langwell_udc     *dev;
 
         dev = ep->dev;
-        VDBG(dev, "---> %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
         i = ep->ep_num * 2 + is_in(ep);
         dqh = &dev->ep_dqh[i];
 
         if (ep->ep_num)
-                VDBG(dev, "%s\n", ep->name);
+                dev_vdbg(&dev->pdev->dev, "%s\n", ep->name);
         else
                 /* ep0 */
-                VDBG(dev, "%s-%s\n", ep->name, is_in(ep) ? "in" : "out");
+                dev_vdbg(&dev->pdev->dev, "%s-%s\n", ep->name, DIR_STRING(ep));
 
-        VDBG(dev, "ep_dqh[%d] addr: 0x%08x\n", i, (u32)&(dev->ep_dqh[i]));
+        dev_vdbg(&dev->pdev->dev, "ep_dqh[%d] addr: 0x%08x\n",
+                        i, (u32)&(dev->ep_dqh[i]));
 
         bit_mask = is_in(ep) ?
                 (1 << (ep->ep_num + 16)) : (1 << (ep->ep_num));
 
-        VDBG(dev, "bit_mask = 0x%08x\n", bit_mask);
+        dev_vdbg(&dev->pdev->dev, "bit_mask = 0x%08x\n", bit_mask);
 
         /* check if the pipe is empty */
         if (!(list_empty(&ep->queue))) {
@@ -665,14 +640,17 @@ static int queue_dtd(struct langwell_ep *ep, struct langwell_request *req)
         /* clear active and halt bit */
         dtd_status = (u8) ~(DTD_STS_ACTIVE | DTD_STS_HALTED);
         dqh->dtd_status &= dtd_status;
-        VDBG(dev, "dqh->dtd_status = 0x%x\n", dqh->dtd_status);
+        dev_vdbg(&dev->pdev->dev, "dqh->dtd_status = 0x%x\n", dqh->dtd_status);
+
+        /* ensure that updates to the dQH will occur before priming */
+        wmb();
 
         /* write 1 to endptprime register to PRIME endpoint */
         bit_mask = is_in(ep) ? (1 << (ep->ep_num + 16)) : (1 << ep->ep_num);
-        VDBG(dev, "endprime bit_mask = 0x%08x\n", bit_mask);
+        dev_vdbg(&dev->pdev->dev, "endprime bit_mask = 0x%08x\n", bit_mask);
         writel(bit_mask, &dev->op_regs->endptprime);
 out:
-        VDBG(dev, "<--- %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
         return 0;
 }
 
@@ -687,7 +665,7 @@ static struct langwell_dtd *build_dtd(struct langwell_request *req,
         int                     i;
 
         dev = req->ep->dev;
-        VDBG(dev, "---> %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
         /* the maximum transfer length, up to 16k bytes */
         *length = min(req->req.length - req->req.actual,
@@ -708,7 +686,7 @@ static struct langwell_dtd *build_dtd(struct langwell_request *req,
 
         /* fill in total bytes with transfer size */
         dtd->dtd_total = cpu_to_le16(*length);
-        VDBG(dev, "dtd->dtd_total = %d\n", dtd->dtd_total);
+        dev_vdbg(&dev->pdev->dev, "dtd->dtd_total = %d\n", dtd->dtd_total);
 
         /* set is_last flag if req->req.zero is set or not */
         if (req->req.zero) {
@@ -722,7 +700,7 @@ static struct langwell_dtd *build_dtd(struct langwell_request *req,
                 *is_last = 0;
 
         if (*is_last == 0)
-                VDBG(dev, "multi-dtd request!\n");
+                dev_vdbg(&dev->pdev->dev, "multi-dtd request!\n");
 
         /* set interrupt on complete bit for the last dTD */
         if (*is_last && !req->req.no_interrupt)
@@ -733,10 +711,12 @@ static struct langwell_dtd *build_dtd(struct langwell_request *req,
 
         /* set the active bit of status field to 1 */
         dtd->dtd_status = DTD_STS_ACTIVE;
-        VDBG(dev, "dtd->dtd_status = 0x%02x\n", dtd->dtd_status);
+        dev_vdbg(&dev->pdev->dev, "dtd->dtd_status = 0x%02x\n",
+                        dtd->dtd_status);
 
-        VDBG(dev, "length = %d, dma addr= 0x%08x\n", *length, (int)*dma);
-        VDBG(dev, "<--- %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "length = %d, dma addr= 0x%08x\n",
+                        *length, (int)*dma);
+        dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
         return dtd;
 }
 
@@ -751,7 +731,7 @@ static int req_to_dtd(struct langwell_request *req)
         dma_addr_t              dma;
 
         dev = req->ep->dev;
-        VDBG(dev, "---> %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
         do {
                 dtd = build_dtd(req, &count, &dma, &is_last);
                 if (dtd == NULL)
@@ -773,7 +753,7 @@ static int req_to_dtd(struct langwell_request *req)
 
         req->tail = dtd;
 
-        VDBG(dev, "<--- %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
         return 0;
 }
 
@@ -803,9 +783,9 @@ static int langwell_ep_queue(struct usb_ep *_ep, struct usb_request *_req,
 
         dev = ep->dev;
         req->ep = ep;
-        VDBG(dev, "---> %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
-        if (ep->desc->bmAttributes == USB_ENDPOINT_XFER_ISOC) {
+        if (usb_endpoint_xfer_isoc(ep->desc)) {
                 if (req->req.length > ep->ep.maxpacket)
                         return -EMSGSIZE;
                 is_iso = 1;
@@ -818,7 +798,7 @@ static int langwell_ep_queue(struct usb_ep *_ep, struct usb_request *_req,
         if (_req->dma == DMA_ADDR_INVALID) {
                 /* WORKAROUND: WARN_ON(size == 0) */
                 if (_req->length == 0) {
-                        VDBG(dev, "req->length: 0->1\n");
+                        dev_vdbg(&dev->pdev->dev, "req->length: 0->1\n");
                         zlflag = 1;
                         _req->length++;
                 }
@@ -827,24 +807,25 @@ static int langwell_ep_queue(struct usb_ep *_ep, struct usb_request *_req,
                                 _req->buf, _req->length,
                                 is_in(ep) ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
                 if (zlflag && (_req->length == 1)) {
-                        VDBG(dev, "req->length: 1->0\n");
+                        dev_vdbg(&dev->pdev->dev, "req->length: 1->0\n");
                         zlflag = 0;
                         _req->length = 0;
                 }
 
                 req->mapped = 1;
-                VDBG(dev, "req->mapped = 1\n");
+                dev_vdbg(&dev->pdev->dev, "req->mapped = 1\n");
         } else {
                 dma_sync_single_for_device(&dev->pdev->dev,
                                 _req->dma, _req->length,
                                 is_in(ep) ?  DMA_TO_DEVICE : DMA_FROM_DEVICE);
                 req->mapped = 0;
-                VDBG(dev, "req->mapped = 0\n");
+                dev_vdbg(&dev->pdev->dev, "req->mapped = 0\n");
         }
 
-        DBG(dev, "%s queue req %p, len %u, buf %p, dma 0x%08llx\n",
-            _ep->name,
-            _req, _req->length, _req->buf, (unsigned long long)_req->dma);
+        dev_dbg(&dev->pdev->dev,
+                        "%s queue req %p, len %u, buf %p, dma 0x%08x\n",
+                        _ep->name,
+                        _req, _req->length, _req->buf, (int)_req->dma);
 
         _req->status = -EINPROGRESS;
         _req->actual = 0;
@@ -866,12 +847,12 @@ static int langwell_ep_queue(struct usb_ep *_ep, struct usb_request *_req,
 
         if (likely(req != NULL)) {
                 list_add_tail(&req->queue, &ep->queue);
-                VDBG(dev, "list_add_tail() \n");
+                dev_vdbg(&dev->pdev->dev, "list_add_tail()\n");
         }
 
         spin_unlock_irqrestore(&dev->lock, flags);
 
-        VDBG(dev, "<--- %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
         return 0;
 }
 
@@ -888,7 +869,7 @@ static int langwell_ep_dequeue(struct usb_ep *_ep, struct usb_request *_req)
 
         ep = container_of(_ep, struct langwell_ep, ep);
         dev = ep->dev;
-        VDBG(dev, "---> %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
         if (!_ep || !ep->desc || !_req)
                 return -EINVAL;
@@ -924,7 +905,7 @@ static int langwell_ep_dequeue(struct usb_ep *_ep, struct usb_request *_req)
 
         /* queue head may be partially complete. */
         if (ep->queue.next == &req->queue) {
-                DBG(dev, "unlink (%s) dma\n", _ep->name);
+                dev_dbg(&dev->pdev->dev, "unlink (%s) dma\n", _ep->name);
                 _req->status = -ECONNRESET;
                 langwell_ep_fifo_flush(&ep->ep);
 
@@ -963,7 +944,7 @@ done:
         ep->stopped = stopped;
         spin_unlock_irqrestore(&dev->lock, flags);
 
-        VDBG(dev, "<--- %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
         return retval;
 }
 
@@ -976,7 +957,7 @@ static void ep_set_halt(struct langwell_ep *ep, int value)
         u32                     endptctrl = 0;
         int                     ep_num;
         struct langwell_udc     *dev = ep->dev;
-        VDBG(dev, "---> %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
         ep_num = ep->ep_num;
         endptctrl = readl(&dev->op_regs->endptctrl[ep_num]);
@@ -1001,7 +982,7 @@ static void ep_set_halt(struct langwell_ep *ep, int value)
 
         writel(endptctrl, &dev->op_regs->endptctrl[ep_num]);
 
-        VDBG(dev, "<--- %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
 }
 
 
@@ -1016,7 +997,7 @@ static int langwell_ep_set_halt(struct usb_ep *_ep, int value)
         ep = container_of(_ep, struct langwell_ep, ep);
         dev = ep->dev;
 
-        VDBG(dev, "---> %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
         if (!_ep || !ep->desc)
                 return -EINVAL;
@@ -1024,8 +1005,7 @@ static int langwell_ep_set_halt(struct usb_ep *_ep, int value)
         if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN)
                 return -ESHUTDOWN;
 
-        if (ep->desc && (ep->desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
-                        == USB_ENDPOINT_XFER_ISOC)
+        if (usb_endpoint_xfer_isoc(ep->desc))
                 return  -EOPNOTSUPP;
 
         spin_lock_irqsave(&dev->lock, flags);
@@ -1036,7 +1016,7 @@ static int langwell_ep_set_halt(struct usb_ep *_ep, int value)
          */
         if (!list_empty(&ep->queue) && is_in(ep) && value) {
                 /* IN endpoint FIFO holds bytes */
-                DBG(dev, "%s FIFO holds bytes\n", _ep->name);
+                dev_dbg(&dev->pdev->dev, "%s FIFO holds bytes\n", _ep->name);
                 retval = -EAGAIN;
                 goto done;
         }
@@ -1050,8 +1030,9 @@ static int langwell_ep_set_halt(struct usb_ep *_ep, int value)
         }
 done:
         spin_unlock_irqrestore(&dev->lock, flags);
-        DBG(dev, "%s %s halt\n", _ep->name, value ? "set" : "clear");
-        VDBG(dev, "<--- %s()\n", __func__);
+        dev_dbg(&dev->pdev->dev, "%s %s halt\n",
+                        _ep->name, value ? "set" : "clear");
+        dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
         return retval;
 }
 
@@ -1065,12 +1046,12 @@ static int langwell_ep_set_wedge(struct usb_ep *_ep)
         ep = container_of(_ep, struct langwell_ep, ep);
         dev = ep->dev;
 
-        VDBG(dev, "---> %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
         if (!_ep || !ep->desc)
                 return -EINVAL;
 
-        VDBG(dev, "<--- %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
         return usb_ep_set_halt(_ep);
 }
 
@@ -1086,15 +1067,16 @@ static void langwell_ep_fifo_flush(struct usb_ep *_ep)
         ep = container_of(_ep, struct langwell_ep, ep);
         dev = ep->dev;
 
-        VDBG(dev, "---> %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
         if (!_ep || !ep->desc) {
-                VDBG(dev, "ep or ep->desc is NULL\n");
-                VDBG(dev, "<--- %s()\n", __func__);
+                dev_vdbg(&dev->pdev->dev, "ep or ep->desc is NULL\n");
+                dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
                 return;
         }
 
-        VDBG(dev, "%s-%s fifo flush\n", _ep->name, is_in(ep) ? "in" : "out");
+        dev_vdbg(&dev->pdev->dev, "%s-%s fifo flush\n",
+                        _ep->name, DIR_STRING(ep));
 
         /* flush endpoint buffer */
         if (ep->ep_num == 0)
@@ -1110,14 +1092,14 @@ static void langwell_ep_fifo_flush(struct usb_ep *_ep)
                 writel(flush_bit, &dev->op_regs->endptflush);
                 while (readl(&dev->op_regs->endptflush)) {
                         if (time_after(jiffies, timeout)) {
-                                ERROR(dev, "ep flush timeout\n");
+                                dev_err(&dev->pdev->dev, "ep flush timeout\n");
                                 goto done;
                         }
                         cpu_relax();
                 }
         } while (readl(&dev->op_regs->endptstat) & flush_bit);
 done:
-        VDBG(dev, "<--- %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
 }
 
 
@@ -1167,31 +1149,59 @@ static int langwell_get_frame(struct usb_gadget *_gadget)
                 return -ENODEV;
 
         dev = container_of(_gadget, struct langwell_udc, gadget);
-        VDBG(dev, "---> %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
         retval = readl(&dev->op_regs->frindex) & FRINDEX_MASK;
 
-        VDBG(dev, "<--- %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
         return retval;
 }
 
 
+/* enter or exit PHY low power state */
+static void langwell_phy_low_power(struct langwell_udc *dev, bool flag)
+{
+        u32             devlc;
+        u8              devlc_byte2;
+        dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
+
+        devlc = readl(&dev->op_regs->devlc);
+        dev_vdbg(&dev->pdev->dev, "devlc = 0x%08x\n", devlc);
+
+        if (flag)
+                devlc |= LPM_PHCD;
+        else
+                devlc &= ~LPM_PHCD;
+
+        /* FIXME: workaround for Langwell A1/A2/A3 sighting */
+        devlc_byte2 = (devlc >> 16) & 0xff;
+        writeb(devlc_byte2, (u8 *)&dev->op_regs->devlc + 2);
+
+        devlc = readl(&dev->op_regs->devlc);
+        dev_vdbg(&dev->pdev->dev,
+                        "%s PHY low power suspend, devlc = 0x%08x\n",
+                        flag ? "enter" : "exit", devlc);
+}
+
+
 /* tries to wake up the host connected to this gadget */
 static int langwell_wakeup(struct usb_gadget *_gadget)
 {
         struct langwell_udc     *dev;
-        u32                     portsc1, devlc;
-        unsigned long           flags;
+        u32                     portsc1;
+        unsigned long           flags;
 
         if (!_gadget)
                 return 0;
 
         dev = container_of(_gadget, struct langwell_udc, gadget);
-        VDBG(dev, "---> %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
-        /* Remote Wakeup feature not enabled by host */
-        if (!dev->remote_wakeup)
+        /* remote wakeup feature not enabled by host */
+        if (!dev->remote_wakeup) {
+                dev_info(&dev->pdev->dev, "remote wakeup is disabled\n");
                 return -ENOTSUPP;
+        }
 
         spin_lock_irqsave(&dev->lock, flags);
 
@@ -1201,27 +1211,23 @@ static int langwell_wakeup(struct usb_gadget *_gadget)
                 return 0;
         }
 
-        /* LPM L1 to L0, remote wakeup */
-        if (dev->lpm && dev->lpm_state == LPM_L1) {
-                portsc1 |= PORTS_SLP;
-                writel(portsc1, &dev->op_regs->portsc1);
-        }
-
-        /* force port resume */
-        if (dev->usb_state == USB_STATE_SUSPENDED) {
-                portsc1 |= PORTS_FPR;
-                writel(portsc1, &dev->op_regs->portsc1);
-        }
+        /* LPM L1 to L0 or legacy remote wakeup */
+        if (dev->lpm && dev->lpm_state == LPM_L1)
+                dev_info(&dev->pdev->dev, "LPM L1 to L0 remote wakeup\n");
+        else
+                dev_info(&dev->pdev->dev, "device remote wakeup\n");
 
         /* exit PHY low power suspend */
-        devlc = readl(&dev->op_regs->devlc);
-        VDBG(dev, "devlc = 0x%08x\n", devlc);
-        devlc &= ~LPM_PHCD;
-        writel(devlc, &dev->op_regs->devlc);
+        if (dev->pdev->device != 0x0829)
+                langwell_phy_low_power(dev, 0);
+
+        /* force port resume */
+        portsc1 |= PORTS_FPR;
+        writel(portsc1, &dev->op_regs->portsc1);
 
         spin_unlock_irqrestore(&dev->lock, flags);
 
-        VDBG(dev, "<--- %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
         return 0;
 }
 
@@ -1231,16 +1237,17 @@ static int langwell_vbus_session(struct usb_gadget *_gadget, int is_active)
 {
         struct langwell_udc     *dev;
         unsigned long           flags;
-        u32                     usbcmd;
+        u32                     usbcmd;
 
         if (!_gadget)
                 return -ENODEV;
 
         dev = container_of(_gadget, struct langwell_udc, gadget);
-        VDBG(dev, "---> %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
         spin_lock_irqsave(&dev->lock, flags);
-        VDBG(dev, "VBUS status: %s\n", is_active ? "on" : "off");
+        dev_vdbg(&dev->pdev->dev, "VBUS status: %s\n",
+                        is_active ? "on" : "off");
 
         dev->vbus_active = (is_active != 0);
         if (dev->driver && dev->softconnected && dev->vbus_active) {
@@ -1255,7 +1262,7 @@ static int langwell_vbus_session(struct usb_gadget *_gadget, int is_active)
 
         spin_unlock_irqrestore(&dev->lock, flags);
 
-        VDBG(dev, "<--- %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
         return 0;
 }
 
@@ -1269,15 +1276,15 @@ static int langwell_vbus_draw(struct usb_gadget *_gadget, unsigned mA)
                 return -ENODEV;
 
         dev = container_of(_gadget, struct langwell_udc, gadget);
-        VDBG(dev, "---> %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
         if (dev->transceiver) {
-                VDBG(dev, "otg_set_power\n");
-                VDBG(dev, "<--- %s()\n", __func__);
+                dev_vdbg(&dev->pdev->dev, "otg_set_power\n");
+                dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
                 return otg_set_power(dev->transceiver, mA);
         }
 
-        VDBG(dev, "<--- %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
         return -ENOTSUPP;
 }
 
@@ -1286,15 +1293,15 @@ static int langwell_vbus_draw(struct usb_gadget *_gadget, unsigned mA)
 static int langwell_pullup(struct usb_gadget *_gadget, int is_on)
 {
         struct langwell_udc     *dev;
-        u32                     usbcmd;
-        unsigned long           flags;
+        u32                     usbcmd;
+        unsigned long           flags;
 
         if (!_gadget)
                 return -ENODEV;
 
         dev = container_of(_gadget, struct langwell_udc, gadget);
 
-        VDBG(dev, "---> %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
         spin_lock_irqsave(&dev->lock, flags);
         dev->softconnected = (is_on != 0);
@@ -1310,7 +1317,7 @@ static int langwell_pullup(struct usb_gadget *_gadget, int is_on)
         }
         spin_unlock_irqrestore(&dev->lock, flags);
 
-        VDBG(dev, "<--- %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
         return 0;
 }
 
@@ -1346,12 +1353,13 @@ static const struct usb_gadget_ops langwell_ops = {
 static int langwell_udc_reset(struct langwell_udc *dev)
 {
         u32             usbcmd, usbmode, devlc, endpointlistaddr;
+        u8              devlc_byte0, devlc_byte2;
         unsigned long   timeout;
 
         if (!dev)
                 return -EINVAL;
 
-        DBG(dev, "---> %s()\n", __func__);
+        dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
         /* set controller to stop state */
         usbcmd = readl(&dev->op_regs->usbcmd);
@@ -1367,7 +1375,7 @@ static int langwell_udc_reset(struct langwell_udc *dev)
         timeout = jiffies + RESET_TIMEOUT;
         while (readl(&dev->op_regs->usbcmd) & CMD_RST) {
                 if (time_after(jiffies, timeout)) {
-                        ERROR(dev, "device reset timeout\n");
+                        dev_err(&dev->pdev->dev, "device reset timeout\n");
                         return -ETIMEDOUT;
                 }
                 cpu_relax();
@@ -1382,7 +1390,7 @@ static int langwell_udc_reset(struct langwell_udc *dev)
 
         writel(usbmode, &dev->op_regs->usbmode);
         usbmode = readl(&dev->op_regs->usbmode);
-        VDBG(dev, "usbmode=0x%08x\n", usbmode);
+        dev_vdbg(&dev->pdev->dev, "usbmode=0x%08x\n", usbmode);
 
         /* Write-Clear setup status */
         writel(0, &dev->op_regs->usbsts);
@@ -1390,9 +1398,17 @@ static int langwell_udc_reset(struct langwell_udc *dev)
         /* if support USB LPM, ACK all LPM token */
         if (dev->lpm) {
                 devlc = readl(&dev->op_regs->devlc);
+                dev_vdbg(&dev->pdev->dev, "devlc = 0x%08x\n", devlc);
+                /* FIXME: workaround for Langwell A1/A2/A3 sighting */
                 devlc &= ~LPM_STL;      /* don't STALL LPM token */
                 devlc &= ~LPM_NYT_ACK;  /* ACK LPM token */
-                writel(devlc, &dev->op_regs->devlc);
+                devlc_byte0 = devlc & 0xff;
+                devlc_byte2 = (devlc >> 16) & 0xff;
+                writeb(devlc_byte0, (u8 *)&dev->op_regs->devlc);
+                writeb(devlc_byte2, (u8 *)&dev->op_regs->devlc + 2);
+                devlc = readl(&dev->op_regs->devlc);
+                dev_vdbg(&dev->pdev->dev,
+                                "ACK LPM token, devlc = 0x%08x\n", devlc);
         }
 
         /* fill endpointlistaddr register */
@@ -1400,10 +1416,11 @@ static int langwell_udc_reset(struct langwell_udc *dev)
         endpointlistaddr &= ENDPOINTLISTADDR_MASK;
         writel(endpointlistaddr, &dev->op_regs->endpointlistaddr);
 
-        VDBG(dev, "dQH base (vir: %p, phy: 0x%08x), endpointlistaddr=0x%08x\n",
-                        dev->ep_dqh, endpointlistaddr,
-                        readl(&dev->op_regs->endpointlistaddr));
-        DBG(dev, "<--- %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev,
+                "dQH base (vir: %p, phy: 0x%08x), endpointlistaddr=0x%08x\n",
+                dev->ep_dqh, endpointlistaddr,
+                readl(&dev->op_regs->endpointlistaddr));
+        dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
         return 0;
 }
 
@@ -1415,7 +1432,7 @@ static int eps_reinit(struct langwell_udc *dev)
         char                    name[14];
         int                     i;
 
-        VDBG(dev, "---> %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
         /* initialize ep0 */
         ep = &dev->ep[0];
@@ -1449,11 +1466,9 @@ static int eps_reinit(struct langwell_udc *dev)
 
                 INIT_LIST_HEAD(&ep->queue);
                 list_add_tail(&ep->ep.ep_list, &dev->gadget.ep_list);
-
-                ep->dqh = &dev->ep_dqh[i];
         }
 
-        VDBG(dev, "<--- %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
         return 0;
 }
 
@@ -1462,7 +1477,7 @@ static int eps_reinit(struct langwell_udc *dev)
 static void langwell_udc_start(struct langwell_udc *dev)
 {
         u32     usbintr, usbcmd;
-        DBG(dev, "---> %s()\n", __func__);
+        dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
         /* enable interrupts */
         usbintr = INTR_ULPIE    /* ULPI */
@@ -1485,8 +1500,7 @@ static void langwell_udc_start(struct langwell_udc *dev)
         usbcmd |= CMD_RUNSTOP;
         writel(usbcmd, &dev->op_regs->usbcmd);
 
-        DBG(dev, "<--- %s()\n", __func__);
-        return;
+        dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
 }
 
 
@@ -1495,7 +1509,7 @@ static void langwell_udc_stop(struct langwell_udc *dev)
 {
         u32     usbcmd;
 
-        DBG(dev, "---> %s()\n", __func__);
+        dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
         /* disable all interrupts */
         writel(0, &dev->op_regs->usbintr);
@@ -1508,8 +1522,7 @@ static void langwell_udc_stop(struct langwell_udc *dev)
         usbcmd &= ~CMD_RUNSTOP;
         writel(usbcmd, &dev->op_regs->usbcmd);
 
-        DBG(dev, "<--- %s()\n", __func__);
-        return;
+        dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
 }
 
 
@@ -1518,7 +1531,7 @@ static void stop_activity(struct langwell_udc *dev,
                 struct usb_gadget_driver *driver)
 {
         struct langwell_ep      *ep;
-        DBG(dev, "---> %s()\n", __func__);
+        dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
         nuke(&dev->ep[0], -ESHUTDOWN);
 
@@ -1533,7 +1546,7 @@ static void stop_activity(struct langwell_udc *dev,
                 spin_lock(&dev->lock);
         }
 
-        DBG(dev, "<--- %s()\n", __func__);
+        dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
 }
 
 
@@ -1659,13 +1672,15 @@ static ssize_t show_langwell_udc(struct device *_dev,
                 "Over-current Change: %s\n"
                 "Port Enable/Disable Change: %s\n"
                 "Port Enabled/Disabled: %s\n"
-                "Current Connect Status: %s\n\n",
+                "Current Connect Status: %s\n"
+                "LPM Suspend Status: %s\n\n",
                 (tmp_reg & PORTS_PR) ? "Reset" : "Not Reset",
                 (tmp_reg & PORTS_SUSP) ? "Suspend " : "Not Suspend",
                 (tmp_reg & PORTS_OCC) ? "Detected" : "No",
                 (tmp_reg & PORTS_PEC) ? "Changed" : "Not Changed",
                 (tmp_reg & PORTS_PE) ? "Enable" : "Not Correct",
-                (tmp_reg & PORTS_CCS) ?  "Attached" : "Not Attached");
+                (tmp_reg & PORTS_CCS) ?  "Attached" : "Not Attached",
+                (tmp_reg & PORTS_SLP) ? "LPM L1" : "LPM L0");
         size -= t;
         next += t;
 
@@ -1676,7 +1691,7 @@ static ssize_t show_langwell_udc(struct device *_dev,
                 "Serial Transceiver : %d\n"
                 "Port Speed: %s\n"
                 "Port Force Full Speed Connenct: %s\n"
-                "PHY Low Power Suspend Clock Disable: %s\n"
+                "PHY Low Power Suspend Clock: %s\n"
                 "BmAttributes: %d\n\n",
                 LPM_PTS(tmp_reg),
                 (tmp_reg & LPM_STS) ? 1 : 0,
@@ -1797,6 +1812,36 @@ static ssize_t show_langwell_udc(struct device *_dev,
 static DEVICE_ATTR(langwell_udc, S_IRUGO, show_langwell_udc, NULL);
 
 
+/* device "remote_wakeup" sysfs attribute file */
+static ssize_t store_remote_wakeup(struct device *_dev,
+                struct device_attribute *attr, const char *buf, size_t count)
+{
+        struct langwell_udc     *dev = the_controller;
+        unsigned long           flags;
+        ssize_t                 rc = count;
+
+        if (count > 2)
+                return -EINVAL;
+
+        if (count > 0 && buf[count-1] == '\n')
+                ((char *) buf)[count-1] = 0;
+
+        if (buf[0] != '1')
+                return -EINVAL;
+
+        /* force remote wakeup enabled in case gadget driver doesn't support */
+        spin_lock_irqsave(&dev->lock, flags);
+        dev->remote_wakeup = 1;
+        dev->dev_status |= (1 << USB_DEVICE_REMOTE_WAKEUP);
+        spin_unlock_irqrestore(&dev->lock, flags);
+
+        langwell_wakeup(&dev->gadget);
+
+        return rc;
+}
+static DEVICE_ATTR(remote_wakeup, S_IWUSR, NULL, store_remote_wakeup);
+
+
 /*-------------------------------------------------------------------------*/
 
 /*
@@ -1807,7 +1852,8 @@ static DEVICE_ATTR(langwell_udc, S_IRUGO, show_langwell_udc, NULL);
  * the driver might get unbound.
  */
 
-int usb_gadget_register_driver(struct usb_gadget_driver *driver)
+int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
+                int (*bind)(struct usb_gadget *))
 {
         struct langwell_udc     *dev = the_controller;
         unsigned long           flags;
@@ -1816,7 +1862,7 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver)
         if (!dev)
                 return -ENODEV;
 
-        DBG(dev, "---> %s()\n", __func__);
+        dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
         if (dev->driver)
                 return -EBUSY;
@@ -1830,9 +1876,9 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver)
 
         spin_unlock_irqrestore(&dev->lock, flags);
 
-        retval = driver->bind(&dev->gadget);
+        retval = bind(&dev->gadget);
         if (retval) {
-                DBG(dev, "bind to driver %s --> %d\n",
+                dev_dbg(&dev->pdev->dev, "bind to driver %s --> %d\n",
                                 driver->driver.name, retval);
                 dev->driver = NULL;
                 dev->gadget.dev.driver = NULL;
@@ -1851,13 +1897,13 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver)
         if (dev->got_irq)
                 langwell_udc_start(dev);
 
-        VDBG(dev, "After langwell_udc_start(), print all registers:\n");
-#ifdef  VERBOSE
+        dev_vdbg(&dev->pdev->dev,
+                        "After langwell_udc_start(), print all registers:\n");
         print_all_registers(dev);
-#endif
 
-        INFO(dev, "register driver: %s\n", driver->driver.name);
-        VDBG(dev, "<--- %s()\n", __func__);
+        dev_info(&dev->pdev->dev, "register driver: %s\n",
+                        driver->driver.name);
+        dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
         return 0;
 
 err_unbind:
@@ -1865,10 +1911,10 @@ err_unbind:
         dev->gadget.dev.driver = NULL;
         dev->driver = NULL;
 
-        DBG(dev, "<--- %s()\n", __func__);
+        dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
         return retval;
 }
-EXPORT_SYMBOL(usb_gadget_register_driver);
+EXPORT_SYMBOL(usb_gadget_probe_driver);
 
 
 /* unregister gadget driver */
@@ -1880,11 +1926,15 @@ int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
         if (!dev)
                 return -ENODEV;
 
-        DBG(dev, "---> %s()\n", __func__);
+        dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
-        if (unlikely(!driver || !driver->bind || !driver->unbind))
+        if (unlikely(!driver || !driver->unbind))
                 return -EINVAL;
 
+        /* exit PHY low power suspend */
+        if (dev->pdev->device != 0x0829)
+                langwell_phy_low_power(dev, 0);
+
         /* unbind OTG transceiver */
         if (dev->transceiver)
                 (void)otg_set_peripheral(dev->transceiver, 0);
@@ -1910,8 +1960,9 @@ int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
 
         device_remove_file(&dev->pdev->dev, &dev_attr_function);
 
-        INFO(dev, "unregistered driver '%s'\n", driver->driver.name);
-        DBG(dev, "<--- %s()\n", __func__);
+        dev_info(&dev->pdev->dev, "unregistered driver '%s'\n",
+                        driver->driver.name);
+        dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
         return 0;
 }
 EXPORT_SYMBOL(usb_gadget_unregister_driver);
@@ -1930,7 +1981,7 @@ static void setup_tripwire(struct langwell_udc *dev)
         unsigned long           timeout;
         struct langwell_dqh     *dqh;
 
-        VDBG(dev, "---> %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
         /* ep0 OUT dQH */
         dqh = &dev->ep_dqh[EP_DIR_OUT];
@@ -1943,7 +1994,7 @@ static void setup_tripwire(struct langwell_udc *dev)
         timeout = jiffies + SETUPSTAT_TIMEOUT;
         while (readl(&dev->op_regs->endptsetupstat)) {
                 if (time_after(jiffies, timeout)) {
-                        ERROR(dev, "setup_tripwire timeout\n");
+                        dev_err(&dev->pdev->dev, "setup_tripwire timeout\n");
                         break;
                 }
                 cpu_relax();
@@ -1963,7 +2014,7 @@ static void setup_tripwire(struct langwell_udc *dev)
         usbcmd = readl(&dev->op_regs->usbcmd);
         writel(usbcmd & ~CMD_SUTW, &dev->op_regs->usbcmd);
 
-        VDBG(dev, "<--- %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
 }
 
 
@@ -1972,7 +2023,7 @@ static void ep0_stall(struct langwell_udc *dev)
 {
         u32     endptctrl;
 
-        VDBG(dev, "---> %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
         /* set TX and RX to stall */
         endptctrl = readl(&dev->op_regs->endptctrl[0]);
@@ -1983,7 +2034,7 @@ static void ep0_stall(struct langwell_udc *dev)
         dev->ep0_state = WAIT_FOR_SETUP;
         dev->ep0_dir = USB_DIR_OUT;
 
-        VDBG(dev, "<--- %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
 }
 
 
@@ -1994,7 +2045,7 @@ static int prime_status_phase(struct langwell_udc *dev, int dir)
         struct langwell_ep      *ep;
         int                     status = 0;
 
-        VDBG(dev, "---> %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
         if (dir == EP_DIR_IN)
                 dev->ep0_dir = USB_DIR_IN;
@@ -2019,11 +2070,11 @@ static int prime_status_phase(struct langwell_udc *dev, int dir)
                 return -ENOMEM;
 
         if (status)
-                ERROR(dev, "can't queue ep0 status request\n");
+                dev_err(&dev->pdev->dev, "can't queue ep0 status request\n");
 
         list_add_tail(&req->queue, &ep->queue);
 
-        VDBG(dev, "<--- %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
         return status;
 }
 
@@ -2032,11 +2083,11 @@ static int prime_status_phase(struct langwell_udc *dev, int dir)
 static void set_address(struct langwell_udc *dev, u16 value,
                 u16 index, u16 length)
 {
-        VDBG(dev, "---> %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
         /* save the new address to device struct */
         dev->dev_addr = (u8) value;
-        VDBG(dev, "dev->dev_addr = %d\n", dev->dev_addr);
+        dev_vdbg(&dev->pdev->dev, "dev->dev_addr = %d\n", dev->dev_addr);
 
         /* update usb state */
         dev->usb_state = USB_STATE_ADDRESS;
@@ -2045,7 +2096,7 @@ static void set_address(struct langwell_udc *dev, u16 value,
         if (prime_status_phase(dev, EP_DIR_IN))
                 ep0_stall(dev);
 
-        VDBG(dev, "<--- %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
 }
 
 
@@ -2054,7 +2105,7 @@ static struct langwell_ep *get_ep_by_windex(struct langwell_udc *dev,
                 u16 wIndex)
 {
         struct langwell_ep              *ep;
-        VDBG(dev, "---> %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
         if ((wIndex & USB_ENDPOINT_NUMBER_MASK) == 0)
                 return &dev->ep[0];
@@ -2073,7 +2124,7 @@ static struct langwell_ep *get_ep_by_windex(struct langwell_udc *dev,
                         return ep;
         }
 
-        VDBG(dev, "<--- %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
         return NULL;
 }
 
@@ -2085,7 +2136,7 @@ static int ep_is_stall(struct langwell_ep *ep)
         u32                     endptctrl;
         int                     retval;
 
-        VDBG(dev, "---> %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
         endptctrl = readl(&dev->op_regs->endptctrl[ep->ep_num]);
         if (is_in(ep))
@@ -2093,7 +2144,7 @@ static int ep_is_stall(struct langwell_ep *ep)
         else
                 retval = endptctrl & EPCTRL_RXS ? 1 : 0;
 
-        VDBG(dev, "<--- %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
         return retval;
 }
 
@@ -2107,14 +2158,13 @@ static void get_status(struct langwell_udc *dev, u8 request_type, u16 value,
         u16     status_data = 0;        /* 16 bits cpu view status data */
         int     status = 0;
 
-        VDBG(dev, "---> %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
         ep = &dev->ep[0];
 
         if ((request_type & USB_RECIP_MASK) == USB_RECIP_DEVICE) {
                 /* get device status */
-                status_data = 1 << USB_DEVICE_SELF_POWERED;
-                status_data |= dev->remote_wakeup << USB_DEVICE_REMOTE_WAKEUP;
+                status_data = dev->dev_status;
         } else if ((request_type & USB_RECIP_MASK) == USB_RECIP_INTERFACE) {
                 /* get interface status */
                 status_data = 0;
@@ -2129,6 +2179,8 @@ static void get_status(struct langwell_udc *dev, u8 request_type, u16 value,
                 status_data = ep_is_stall(epn) << USB_ENDPOINT_HALT;
         }
 
+        dev_dbg(&dev->pdev->dev, "get status data: 0x%04x\n", status_data);
+
         dev->ep0_dir = USB_DIR_IN;
 
         /* borrow the per device status_req */
@@ -2150,18 +2202,19 @@ static void get_status(struct langwell_udc *dev, u8 request_type, u16 value,
                 goto stall;
 
         if (status) {
-                ERROR(dev, "response error on GET_STATUS request\n");
+                dev_err(&dev->pdev->dev,
+                                "response error on GET_STATUS request\n");
                 goto stall;
         }
 
         list_add_tail(&req->queue, &ep->queue);
         dev->ep0_state = DATA_STATE_XMIT;
 
-        VDBG(dev, "<--- %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
         return;
 stall:
         ep0_stall(dev);
-        VDBG(dev, "<--- %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
 }
 
 
@@ -2172,13 +2225,14 @@ static void handle_setup_packet(struct langwell_udc *dev,
         u16     wValue = le16_to_cpu(setup->wValue);
         u16     wIndex = le16_to_cpu(setup->wIndex);
         u16     wLength = le16_to_cpu(setup->wLength);
+        u32     portsc1;
 
-        VDBG(dev, "---> %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
         /* ep0 fifo flush */
         nuke(&dev->ep[0], -ESHUTDOWN);
 
-        DBG(dev, "SETUP %02x.%02x v%04x i%04x l%04x\n",
+        dev_dbg(&dev->pdev->dev, "SETUP %02x.%02x v%04x i%04x l%04x\n",
                         setup->bRequestType, setup->bRequest,
                         wValue, wIndex, wLength);
 
@@ -2197,7 +2251,7 @@ static void handle_setup_packet(struct langwell_udc *dev,
         /* We process some stardard setup requests here */
         switch (setup->bRequest) {
         case USB_REQ_GET_STATUS:
-                DBG(dev, "SETUP: USB_REQ_GET_STATUS\n");
+                dev_dbg(&dev->pdev->dev, "SETUP: USB_REQ_GET_STATUS\n");
                 /* get status, DATA and STATUS phase */
                 if ((setup->bRequestType & (USB_DIR_IN | USB_TYPE_MASK))
                                         != (USB_DIR_IN | USB_TYPE_STANDARD))
@@ -2206,7 +2260,7 @@ static void handle_setup_packet(struct langwell_udc *dev,
                 goto end;
 
         case USB_REQ_SET_ADDRESS:
-                DBG(dev, "SETUP: USB_REQ_SET_ADDRESS\n");
+                dev_dbg(&dev->pdev->dev, "SETUP: USB_REQ_SET_ADDRESS\n");
                 /* STATUS phase */
                 if (setup->bRequestType != (USB_DIR_OUT | USB_TYPE_STANDARD
                                                 | USB_RECIP_DEVICE))
@@ -2220,9 +2274,11 @@ static void handle_setup_packet(struct langwell_udc *dev,
         {
                 int rc = -EOPNOTSUPP;
                 if (setup->bRequest == USB_REQ_SET_FEATURE)
-                        DBG(dev, "SETUP: USB_REQ_SET_FEATURE\n");
+                        dev_dbg(&dev->pdev->dev,
+                                        "SETUP: USB_REQ_SET_FEATURE\n");
                 else if (setup->bRequest == USB_REQ_CLEAR_FEATURE)
-                        DBG(dev, "SETUP: USB_REQ_CLEAR_FEATURE\n");
+                        dev_dbg(&dev->pdev->dev,
+                                        "SETUP: USB_REQ_CLEAR_FEATURE\n");
 
                 if ((setup->bRequestType & (USB_RECIP_MASK | USB_TYPE_MASK))
                                 == (USB_RECIP_ENDPOINT | USB_TYPE_STANDARD)) {
@@ -2240,13 +2296,51 @@ static void handle_setup_packet(struct langwell_udc *dev,
 
                         spin_unlock(&dev->lock);
                         rc = langwell_ep_set_halt(&epn->ep,
-                                        (setup->bRequest == USB_REQ_SET_FEATURE)
-                                                ? 1 : 0);
+                                (setup->bRequest == USB_REQ_SET_FEATURE)
+                                ? 1 : 0);
                         spin_lock(&dev->lock);
 
                 } else if ((setup->bRequestType & (USB_RECIP_MASK
                                 | USB_TYPE_MASK)) == (USB_RECIP_DEVICE
                                 | USB_TYPE_STANDARD)) {
+                        rc = 0;
+                        switch (wValue) {
+                        case USB_DEVICE_REMOTE_WAKEUP:
+                                if (setup->bRequest == USB_REQ_SET_FEATURE) {
+                                        dev->remote_wakeup = 1;
+                                        dev->dev_status |= (1 << wValue);
+                                } else {
+                                        dev->remote_wakeup = 0;
+                                        dev->dev_status &= ~(1 << wValue);
+                                }
+                                break;
+                        case USB_DEVICE_TEST_MODE:
+                                dev_dbg(&dev->pdev->dev, "SETUP: TEST MODE\n");
+                                if ((wIndex & 0xff) ||
+                                        (dev->gadget.speed != USB_SPEED_HIGH))
+                                        ep0_stall(dev);
+
+                                switch (wIndex >> 8) {
+                                case TEST_J:
+                                case TEST_K:
+                                case TEST_SE0_NAK:
+                                case TEST_PACKET:
+                                case TEST_FORCE_EN:
+                                        if (prime_status_phase(dev, EP_DIR_IN))
+                                                ep0_stall(dev);
+                                        portsc1 = readl(&dev->op_regs->portsc1);
+                                        portsc1 |= (wIndex & 0xf00) << 8;
+                                        writel(portsc1, &dev->op_regs->portsc1);
+                                        goto end;
+                                default:
+                                        rc = -EOPNOTSUPP;
+                                }
+                                break;
+                        default:
+                                rc = -EOPNOTSUPP;
+                                break;
+                        }
+
                         if (!gadget_is_otg(&dev->gadget))
                                 break;
                         else if (setup->bRequest == USB_DEVICE_B_HNP_ENABLE) {
@@ -2262,7 +2356,6 @@ static void handle_setup_packet(struct langwell_udc *dev,
                                 dev->gadget.a_alt_hnp_support = 1;
                         else
                                 break;
-                        rc = 0;
                 } else
                         break;
 
@@ -2274,31 +2367,38 @@ static void handle_setup_packet(struct langwell_udc *dev,
         }
 
         case USB_REQ_GET_DESCRIPTOR:
-                DBG(dev, "SETUP: USB_REQ_GET_DESCRIPTOR\n");
+                dev_dbg(&dev->pdev->dev,
+                                "SETUP: USB_REQ_GET_DESCRIPTOR\n");
                 goto delegate;
 
         case USB_REQ_SET_DESCRIPTOR:
-                DBG(dev, "SETUP: USB_REQ_SET_DESCRIPTOR unsupported\n");
+                dev_dbg(&dev->pdev->dev,
+                                "SETUP: USB_REQ_SET_DESCRIPTOR unsupported\n");
                 goto delegate;
 
         case USB_REQ_GET_CONFIGURATION:
-                DBG(dev, "SETUP: USB_REQ_GET_CONFIGURATION\n");
+                dev_dbg(&dev->pdev->dev,
+                                "SETUP: USB_REQ_GET_CONFIGURATION\n");
                 goto delegate;
 
         case USB_REQ_SET_CONFIGURATION:
-                DBG(dev, "SETUP: USB_REQ_SET_CONFIGURATION\n");
+                dev_dbg(&dev->pdev->dev,
+                                "SETUP: USB_REQ_SET_CONFIGURATION\n");
                 goto delegate;
 
         case USB_REQ_GET_INTERFACE:
-                DBG(dev, "SETUP: USB_REQ_GET_INTERFACE\n");
+                dev_dbg(&dev->pdev->dev,
+                                "SETUP: USB_REQ_GET_INTERFACE\n");
                 goto delegate;
 
         case USB_REQ_SET_INTERFACE:
-                DBG(dev, "SETUP: USB_REQ_SET_INTERFACE\n");
+                dev_dbg(&dev->pdev->dev,
+                                "SETUP: USB_REQ_SET_INTERFACE\n");
                 goto delegate;
 
         case USB_REQ_SYNCH_FRAME:
-                DBG(dev, "SETUP: USB_REQ_SYNCH_FRAME unsupported\n");
+                dev_dbg(&dev->pdev->dev,
+                                "SETUP: USB_REQ_SYNCH_FRAME unsupported\n");
                 goto delegate;
 
         default:
@@ -2310,7 +2410,8 @@ delegate:
                         /* DATA phase from gadget, STATUS phase from udc */
                         dev->ep0_dir = (setup->bRequestType & USB_DIR_IN)
                                         ?  USB_DIR_IN : USB_DIR_OUT;
-                        VDBG(dev, "dev->ep0_dir = 0x%x, wLength = %d\n",
+                        dev_vdbg(&dev->pdev->dev,
+                                        "dev->ep0_dir = 0x%x, wLength = %d\n",
                                         dev->ep0_dir, wLength);
                         spin_unlock(&dev->lock);
                         if (dev->driver->setup(&dev->gadget,
@@ -2322,7 +2423,8 @@ delegate:
                 } else {
                         /* no DATA phase, IN STATUS phase from gadget */
                         dev->ep0_dir = USB_DIR_IN;
-                        VDBG(dev, "dev->ep0_dir = 0x%x, wLength = %d\n",
+                        dev_vdbg(&dev->pdev->dev,
+                                        "dev->ep0_dir = 0x%x, wLength = %d\n",
                                         dev->ep0_dir, wLength);
                         spin_unlock(&dev->lock);
                         if (dev->driver->setup(&dev->gadget,
@@ -2334,8 +2436,7 @@ delegate:
                 break;
         }
 end:
-        VDBG(dev, "<--- %s()\n", __func__);
-        return;
+        dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
 }
 
 
@@ -2359,23 +2460,27 @@ static int process_ep_req(struct langwell_udc *dev, int index,
         td_complete = 0;
         actual = curr_req->req.length;
 
-        VDBG(dev, "---> %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
         for (i = 0; i < curr_req->dtd_count; i++) {
-                remaining_length = le16_to_cpu(curr_dtd->dtd_total);
-                actual -= remaining_length;
 
                 /* command execution states by dTD */
                 dtd_status = curr_dtd->dtd_status;
 
+                barrier();
+                remaining_length = le16_to_cpu(curr_dtd->dtd_total);
+                actual -= remaining_length;
+
                 if (!dtd_status) {
                         /* transfers completed successfully */
                         if (!remaining_length) {
                                 td_complete++;
-                                VDBG(dev, "dTD transmitted successfully\n");
+                                dev_vdbg(&dev->pdev->dev,
+                                        "dTD transmitted successfully\n");
                         } else {
                                 if (dir) {
-                                        VDBG(dev, "TX dTD remains data\n");
+                                        dev_vdbg(&dev->pdev->dev,
+                                                "TX dTD remains data\n");
                                         retval = -EPROTO;
                                         break;
 
@@ -2387,27 +2492,32 @@ static int process_ep_req(struct langwell_udc *dev, int index,
                 } else {
                         /* transfers completed with errors */
                         if (dtd_status & DTD_STS_ACTIVE) {
-                                DBG(dev, "request not completed\n");
+                                dev_dbg(&dev->pdev->dev,
+                                        "dTD status ACTIVE dQH[%d]\n", index);
                                 retval = 1;
                                 return retval;
                         } else if (dtd_status & DTD_STS_HALTED) {
-                                ERROR(dev, "dTD error %08x dQH[%d]\n",
-                                                dtd_status, index);
+                                dev_err(&dev->pdev->dev,
+                                        "dTD error %08x dQH[%d]\n",
+                                        dtd_status, index);
                                 /* clear the errors and halt condition */
                                 curr_dqh->dtd_status = 0;
                                 retval = -EPIPE;
                                 break;
                         } else if (dtd_status & DTD_STS_DBE) {
-                                DBG(dev, "data buffer (overflow) error\n");
+                                dev_dbg(&dev->pdev->dev,
+                                        "data buffer (overflow) error\n");
                                 retval = -EPROTO;
                                 break;
                         } else if (dtd_status & DTD_STS_TRE) {
-                                DBG(dev, "transaction(ISO) error\n");
+                                dev_dbg(&dev->pdev->dev,
+                                        "transaction(ISO) error\n");
                                 retval = -EILSEQ;
                                 break;
                         } else
-                                ERROR(dev, "unknown error (0x%x)!\n",
-                                                dtd_status);
+                                dev_err(&dev->pdev->dev,
+                                        "unknown error (0x%x)!\n",
+                                        dtd_status);
                 }
 
                 if (i != curr_req->dtd_count - 1)
@@ -2420,7 +2530,7 @@ static int process_ep_req(struct langwell_udc *dev, int index,
 
         curr_req->req.actual = actual;
 
-        VDBG(dev, "<--- %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
         return 0;
 }
 
@@ -2430,7 +2540,7 @@ static void ep0_req_complete(struct langwell_udc *dev,
                 struct langwell_ep *ep0, struct langwell_request *req)
 {
         u32     new_addr;
-        VDBG(dev, "---> %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
         if (dev->usb_state == USB_STATE_ADDRESS) {
                 /* set the new address */
@@ -2438,7 +2548,7 @@ static void ep0_req_complete(struct langwell_udc *dev,
                 writel(new_addr << USBADR_SHIFT, &dev->op_regs->deviceaddr);
 
                 new_addr = USBADR(readl(&dev->op_regs->deviceaddr));
-                VDBG(dev, "new_addr = %d\n", new_addr);
+                dev_vdbg(&dev->pdev->dev, "new_addr = %d\n", new_addr);
         }
 
         done(ep0, req, 0);
@@ -2458,14 +2568,14 @@ static void ep0_req_complete(struct langwell_udc *dev,
                 dev->ep0_state = WAIT_FOR_SETUP;
                 break;
         case WAIT_FOR_SETUP:
-                ERROR(dev, "unexpect ep0 packets\n");
+                dev_err(&dev->pdev->dev, "unexpect ep0 packets\n");
                 break;
         default:
                 ep0_stall(dev);
                 break;
         }
 
-        VDBG(dev, "<--- %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
 }
 
 
@@ -2477,16 +2587,17 @@ static void handle_trans_complete(struct langwell_udc *dev)
         struct langwell_ep      *epn;
         struct langwell_request *curr_req, *temp_req;
 
-        VDBG(dev, "---> %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
         complete_bits = readl(&dev->op_regs->endptcomplete);
-        VDBG(dev, "endptcomplete register: 0x%08x\n", complete_bits);
+        dev_vdbg(&dev->pdev->dev, "endptcomplete register: 0x%08x\n",
+                        complete_bits);
 
         /* Write-Clear the bits in endptcomplete register */
         writel(complete_bits, &dev->op_regs->endptcomplete);
 
         if (!complete_bits) {
-                DBG(dev, "complete_bits = 0\n");
+                dev_dbg(&dev->pdev->dev, "complete_bits = 0\n");
                 goto done;
         }
 
@@ -2506,23 +2617,25 @@ static void handle_trans_complete(struct langwell_udc *dev)
                         epn = &dev->ep[i];
 
                 if (epn->name == NULL) {
-                        WARNING(dev, "invalid endpoint\n");
+                        dev_warn(&dev->pdev->dev, "invalid endpoint\n");
                         continue;
                 }
 
                 if (i < 2)
                         /* ep0 in and out */
-                        DBG(dev, "%s-%s transfer completed\n",
+                        dev_dbg(&dev->pdev->dev, "%s-%s transfer completed\n",
                                         epn->name,
                                         is_in(epn) ? "in" : "out");
                 else
-                        DBG(dev, "%s transfer completed\n", epn->name);
+                        dev_dbg(&dev->pdev->dev, "%s transfer completed\n",
+                                        epn->name);
 
                 /* process the req queue until an uncomplete request */
                 list_for_each_entry_safe(curr_req, temp_req,
                                 &epn->queue, queue) {
                         status = process_ep_req(dev, i, curr_req);
-                        VDBG(dev, "%s req status: %d\n", epn->name, status);
+                        dev_vdbg(&dev->pdev->dev, "%s req status: %d\n",
+                                        epn->name, status);
 
                         if (status)
                                 break;
@@ -2540,8 +2653,7 @@ static void handle_trans_complete(struct langwell_udc *dev)
                 }
         }
 done:
-        VDBG(dev, "<--- %s()\n", __func__);
-        return;
+        dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
 }
 
 
@@ -2551,14 +2663,14 @@ static void handle_port_change(struct langwell_udc *dev)
         u32     portsc1, devlc;
         u32     speed;
 
-        VDBG(dev, "---> %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
         if (dev->bus_reset)
                 dev->bus_reset = 0;
 
         portsc1 = readl(&dev->op_regs->portsc1);
         devlc = readl(&dev->op_regs->devlc);
-        VDBG(dev, "portsc1 = 0x%08x, devlc = 0x%08x\n",
+        dev_vdbg(&dev->pdev->dev, "portsc1 = 0x%08x, devlc = 0x%08x\n",
                         portsc1, devlc);
 
         /* bus reset is finished */
@@ -2579,25 +2691,22 @@ static void handle_port_change(struct langwell_udc *dev)
                         dev->gadget.speed = USB_SPEED_UNKNOWN;
                         break;
                 }
-                VDBG(dev, "speed = %d, dev->gadget.speed = %d\n",
+                dev_vdbg(&dev->pdev->dev,
+                                "speed = %d, dev->gadget.speed = %d\n",
                                 speed, dev->gadget.speed);
         }
 
         /* LPM L0 to L1 */
         if (dev->lpm && dev->lpm_state == LPM_L0)
                 if (portsc1 & PORTS_SUSP && portsc1 & PORTS_SLP) {
-                                INFO(dev, "LPM L0 to L1\n");
-                                dev->lpm_state = LPM_L1;
+                        dev_info(&dev->pdev->dev, "LPM L0 to L1\n");
+                        dev->lpm_state = LPM_L1;
                 }
 
         /* LPM L1 to L0, force resume or remote wakeup finished */
         if (dev->lpm && dev->lpm_state == LPM_L1)
                 if (!(portsc1 & PORTS_SUSP)) {
-                        if (portsc1 & PORTS_SLP)
-                                INFO(dev, "LPM L1 to L0, force resume\n");
-                        else
-                                INFO(dev, "LPM L1 to L0, remote wakeup\n");
-
+                        dev_info(&dev->pdev->dev, "LPM L1 to L0\n");
                         dev->lpm_state = LPM_L0;
                 }
 
@@ -2605,7 +2714,7 @@ static void handle_port_change(struct langwell_udc *dev)
         if (!dev->resume_state)
                 dev->usb_state = USB_STATE_DEFAULT;
 
-        VDBG(dev, "<--- %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
 }
 
 
@@ -2617,7 +2726,7 @@ static void handle_usb_reset(struct langwell_udc *dev)
                         endptcomplete;
         unsigned long   timeout;
 
-        VDBG(dev, "---> %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
         /* Write-Clear the device address */
         deviceaddr = readl(&dev->op_regs->deviceaddr);
@@ -2634,7 +2743,10 @@ static void handle_usb_reset(struct langwell_udc *dev)
 
         dev->ep0_dir = USB_DIR_OUT;
         dev->ep0_state = WAIT_FOR_SETUP;
-        dev->remote_wakeup = 0;         /* default to 0 on reset */
+
+        /* remote wakeup reset to 0 when the device is reset */
+        dev->remote_wakeup = 0;
+        dev->dev_status = 1 << USB_DEVICE_SELF_POWERED;
         dev->gadget.b_hnp_enable = 0;
         dev->gadget.a_hnp_support = 0;
         dev->gadget.a_alt_hnp_support = 0;
@@ -2651,7 +2763,7 @@ static void handle_usb_reset(struct langwell_udc *dev)
         timeout = jiffies + PRIME_TIMEOUT;
         while (readl(&dev->op_regs->endptprime)) {
                 if (time_after(jiffies, timeout)) {
-                        ERROR(dev, "USB reset timeout\n");
+                        dev_err(&dev->pdev->dev, "USB reset timeout\n");
                         break;
                 }
                 cpu_relax();
@@ -2661,7 +2773,7 @@ static void handle_usb_reset(struct langwell_udc *dev)
         writel((u32) ~0, &dev->op_regs->endptflush);
 
         if (readl(&dev->op_regs->portsc1) & PORTS_PR) {
-                VDBG(dev, "USB bus reset\n");
+                dev_vdbg(&dev->pdev->dev, "USB bus reset\n");
                 /* bus is reseting */
                 dev->bus_reset = 1;
 
@@ -2669,7 +2781,7 @@ static void handle_usb_reset(struct langwell_udc *dev)
                 stop_activity(dev, dev->driver);
                 dev->usb_state = USB_STATE_DEFAULT;
         } else {
-                VDBG(dev, "device controller reset\n");
+                dev_vdbg(&dev->pdev->dev, "device controller reset\n");
                 /* controller reset */
                 langwell_udc_reset(dev);
 
@@ -2691,15 +2803,14 @@ static void handle_usb_reset(struct langwell_udc *dev)
                 dev->lotg->hsm.b_hnp_enable = 0;
 #endif
 
-        VDBG(dev, "<--- %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
 }
 
 
 /* USB bus suspend/resume interrupt */
 static void handle_bus_suspend(struct langwell_udc *dev)
 {
-        u32             devlc;
-        DBG(dev, "---> %s()\n", __func__);
+        dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
         dev->resume_state = dev->usb_state;
         dev->usb_state = USB_STATE_SUSPENDED;
@@ -2733,33 +2844,29 @@ static void handle_bus_suspend(struct langwell_udc *dev)
                         spin_unlock(&dev->lock);
                         dev->driver->suspend(&dev->gadget);
                         spin_lock(&dev->lock);
-                        DBG(dev, "suspend %s\n", dev->driver->driver.name);
+                        dev_dbg(&dev->pdev->dev, "suspend %s\n",
+                                        dev->driver->driver.name);
                 }
         }
 
         /* enter PHY low power suspend */
-        devlc = readl(&dev->op_regs->devlc);
-        VDBG(dev, "devlc = 0x%08x\n", devlc);
-        devlc |= LPM_PHCD;
-        writel(devlc, &dev->op_regs->devlc);
+        if (dev->pdev->device != 0x0829)
+                langwell_phy_low_power(dev, 0);
 
-        DBG(dev, "<--- %s()\n", __func__);
+        dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
 }
 
 
 static void handle_bus_resume(struct langwell_udc *dev)
 {
-        u32             devlc;
-        DBG(dev, "---> %s()\n", __func__);
+        dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
         dev->usb_state = dev->resume_state;
         dev->resume_state = 0;
 
         /* exit PHY low power suspend */
-        devlc = readl(&dev->op_regs->devlc);
-        VDBG(dev, "devlc = 0x%08x\n", devlc);
-        devlc &= ~LPM_PHCD;
-        writel(devlc, &dev->op_regs->devlc);
+        if (dev->pdev->device != 0x0829)
+                langwell_phy_low_power(dev, 0);
 
 #ifdef  OTG_TRANSCEIVER
         if (dev->lotg->otg.default_a == 0)
@@ -2772,11 +2879,12 @@ static void handle_bus_resume(struct langwell_udc *dev)
                         spin_unlock(&dev->lock);
                         dev->driver->resume(&dev->gadget);
                         spin_lock(&dev->lock);
-                        DBG(dev, "resume %s\n", dev->driver->driver.name);
+                        dev_dbg(&dev->pdev->dev, "resume %s\n",
+                                        dev->driver->driver.name);
                 }
         }
 
-        DBG(dev, "<--- %s()\n", __func__);
+        dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
 }
 
 
@@ -2789,11 +2897,11 @@ static irqreturn_t langwell_irq(int irq, void *_dev)
                                 irq_sts,
                                 portsc1;
 
-        VDBG(dev, "---> %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
         if (dev->stopped) {
-                VDBG(dev, "handle IRQ_NONE\n");
-                VDBG(dev, "<--- %s()\n", __func__);
+                dev_vdbg(&dev->pdev->dev, "handle IRQ_NONE\n");
+                dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
                 return IRQ_NONE;
         }
 
@@ -2806,12 +2914,13 @@ static irqreturn_t langwell_irq(int irq, void *_dev)
         usbintr = readl(&dev->op_regs->usbintr);
 
         irq_sts = usbsts & usbintr;
-        VDBG(dev, "usbsts = 0x%08x, usbintr = 0x%08x, irq_sts = 0x%08x\n",
+        dev_vdbg(&dev->pdev->dev,
+                        "usbsts = 0x%08x, usbintr = 0x%08x, irq_sts = 0x%08x\n",
                         usbsts, usbintr, irq_sts);
 
         if (!irq_sts) {
-                VDBG(dev, "handle IRQ_NONE\n");
-                VDBG(dev, "<--- %s()\n", __func__);
+                dev_vdbg(&dev->pdev->dev, "handle IRQ_NONE\n");
+                dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
                 spin_unlock(&dev->lock);
                 return IRQ_NONE;
         }
@@ -2827,12 +2936,13 @@ static irqreturn_t langwell_irq(int irq, void *_dev)
 
         /* USB interrupt */
         if (irq_sts & STS_UI) {
-                VDBG(dev, "USB interrupt\n");
+                dev_vdbg(&dev->pdev->dev, "USB interrupt\n");
 
                 /* setup packet received from ep0 */
                 if (readl(&dev->op_regs->endptsetupstat)
                                 & EP0SETUPSTAT_MASK) {
-                        VDBG(dev, "USB SETUP packet received interrupt\n");
+                        dev_vdbg(&dev->pdev->dev,
+                                "USB SETUP packet received interrupt\n");
                         /* setup tripwire semaphone */
                         setup_tripwire(dev);
                         handle_setup_packet(dev, &dev->local_setup_buff);
@@ -2840,7 +2950,8 @@ static irqreturn_t langwell_irq(int irq, void *_dev)
 
                 /* USB transfer completion */
                 if (readl(&dev->op_regs->endptcomplete)) {
-                        VDBG(dev, "USB transfer completion interrupt\n");
+                        dev_vdbg(&dev->pdev->dev,
+                                "USB transfer completion interrupt\n");
                         handle_trans_complete(dev);
                 }
         }
@@ -2848,36 +2959,36 @@ static irqreturn_t langwell_irq(int irq, void *_dev)
         /* SOF received interrupt (for ISO transfer) */
         if (irq_sts & STS_SRI) {
                 /* FIXME */
-                /* VDBG(dev, "SOF received interrupt\n"); */
+                /* dev_vdbg(&dev->pdev->dev, "SOF received interrupt\n"); */
         }
 
         /* port change detect interrupt */
         if (irq_sts & STS_PCI) {
-                VDBG(dev, "port change detect interrupt\n");
+                dev_vdbg(&dev->pdev->dev, "port change detect interrupt\n");
                 handle_port_change(dev);
         }
 
         /* suspend interrrupt */
         if (irq_sts & STS_SLI) {
-                VDBG(dev, "suspend interrupt\n");
+                dev_vdbg(&dev->pdev->dev, "suspend interrupt\n");
                 handle_bus_suspend(dev);
         }
 
         /* USB reset interrupt */
         if (irq_sts & STS_URI) {
-                VDBG(dev, "USB reset interrupt\n");
+                dev_vdbg(&dev->pdev->dev, "USB reset interrupt\n");
                 handle_usb_reset(dev);
         }
 
         /* USB error or system error interrupt */
         if (irq_sts & (STS_UEI | STS_SEI)) {
                 /* FIXME */
-                WARNING(dev, "error IRQ, irq_sts: %x\n", irq_sts);
+                dev_warn(&dev->pdev->dev, "error IRQ, irq_sts: %x\n", irq_sts);
         }
 
         spin_unlock(&dev->lock);
 
-        VDBG(dev, "<--- %s()\n", __func__);
+        dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
         return IRQ_HANDLED;
 }
 
@@ -2889,15 +3000,59 @@ static void gadget_release(struct device *_dev)
 {
         struct langwell_udc     *dev = the_controller;
 
-        DBG(dev, "---> %s()\n", __func__);
+        dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
         complete(dev->done);
 
-        DBG(dev, "<--- %s()\n", __func__);
+        dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
         kfree(dev);
 }
 
 
+/* enable SRAM caching if SRAM detected */
+static void sram_init(struct langwell_udc *dev)
+{
+        struct pci_dev          *pdev = dev->pdev;
+
+        dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
+
+        dev->sram_addr = pci_resource_start(pdev, 1);
+        dev->sram_size = pci_resource_len(pdev, 1);
+        dev_info(&dev->pdev->dev, "Found private SRAM at %x size:%x\n",
+                        dev->sram_addr, dev->sram_size);
+        dev->got_sram = 1;
+
+        if (pci_request_region(pdev, 1, kobject_name(&pdev->dev.kobj))) {
+                dev_warn(&dev->pdev->dev, "SRAM request failed\n");
+                dev->got_sram = 0;
+        } else if (!dma_declare_coherent_memory(&pdev->dev, dev->sram_addr,
+                        dev->sram_addr, dev->sram_size, DMA_MEMORY_MAP)) {
+                dev_warn(&dev->pdev->dev, "SRAM DMA declare failed\n");
+                pci_release_region(pdev, 1);
+                dev->got_sram = 0;
+        }
+
+        dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
+}
+
+
+/* release SRAM caching */
+static void sram_deinit(struct langwell_udc *dev)
+{
+        struct pci_dev *pdev = dev->pdev;
+
+        dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
+
+        dma_release_declared_memory(&pdev->dev);
+        pci_release_region(pdev, 1);
+
+        dev->got_sram = 0;
+
+        dev_info(&dev->pdev->dev, "release SRAM caching\n");
+        dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
+}
+
+
 /* tear down the binding between this driver and the pci device */
 static void langwell_udc_remove(struct pci_dev *pdev)
 {
@@ -2906,26 +3061,32 @@ static void langwell_udc_remove(struct pci_dev *pdev)
         DECLARE_COMPLETION(done);
 
         BUG_ON(dev->driver);
-        DBG(dev, "---> %s()\n", __func__);
+        dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
         dev->done = &done;
 
-        /* free memory allocated in probe */
+#ifndef OTG_TRANSCEIVER
+        /* free dTD dma_pool and dQH */
         if (dev->dtd_pool)
                 dma_pool_destroy(dev->dtd_pool);
 
+        if (dev->ep_dqh)
+                dma_free_coherent(&pdev->dev, dev->ep_dqh_size,
+                        dev->ep_dqh, dev->ep_dqh_dma);
+
+        /* release SRAM caching */
+        if (dev->has_sram && dev->got_sram)
+                sram_deinit(dev);
+#endif
+
         if (dev->status_req) {
                 kfree(dev->status_req->req.buf);
                 kfree(dev->status_req);
         }
 
-        if (dev->ep_dqh)
-                dma_free_coherent(&pdev->dev, dev->ep_dqh_size,
-                        dev->ep_dqh, dev->ep_dqh_dma);
-
         kfree(dev->ep);
 
-        /* diable IRQ handler */
+        /* disable IRQ handler */
         if (dev->got_irq)
                 free_irq(pdev->irq, dev);
 
@@ -2949,11 +3110,12 @@ static void langwell_udc_remove(struct pci_dev *pdev)
 
         dev->cap_regs = NULL;
 
-        INFO(dev, "unbind\n");
-        DBG(dev, "<--- %s()\n", __func__);
+        dev_info(&dev->pdev->dev, "unbind\n");
+        dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
 
         device_unregister(&dev->gadget.dev);
         device_remove_file(&pdev->dev, &dev_attr_langwell_udc);
+        device_remove_file(&pdev->dev, &dev_attr_remote_wakeup);
 
 #ifndef OTG_TRANSCEIVER
         pci_set_drvdata(pdev, NULL);
@@ -2997,7 +3159,7 @@ static int langwell_udc_probe(struct pci_dev *pdev,
         spin_lock_init(&dev->lock);
 
         dev->pdev = pdev;
-        DBG(dev, "---> %s()\n", __func__);
+        dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
 #ifdef  OTG_TRANSCEIVER
         /* PCI device is already enabled by otg_transceiver driver */
@@ -3022,7 +3184,7 @@ static int langwell_udc_probe(struct pci_dev *pdev,
         resource = pci_resource_start(pdev, 0);
         len = pci_resource_len(pdev, 0);
         if (!request_mem_region(resource, len, driver_name)) {
-                ERROR(dev, "controller already in use\n");
+                dev_err(&dev->pdev->dev, "controller already in use\n");
                 retval = -EBUSY;
                 goto error;
         }
@@ -3031,33 +3193,43 @@ static int langwell_udc_probe(struct pci_dev *pdev,
         base = ioremap_nocache(resource, len);
 #endif
         if (base == NULL) {
-                ERROR(dev, "can't map memory\n");
+                dev_err(&dev->pdev->dev, "can't map memory\n");
                 retval = -EFAULT;
                 goto error;
         }
 
         dev->cap_regs = (struct langwell_cap_regs __iomem *) base;
-        VDBG(dev, "dev->cap_regs: %p\n", dev->cap_regs);
+        dev_vdbg(&dev->pdev->dev, "dev->cap_regs: %p\n", dev->cap_regs);
         dev->op_regs = (struct langwell_op_regs __iomem *)
                 (base + OP_REG_OFFSET);
-        VDBG(dev, "dev->op_regs: %p\n", dev->op_regs);
+        dev_vdbg(&dev->pdev->dev, "dev->op_regs: %p\n", dev->op_regs);
 
         /* irq setup after old hardware is cleaned up */
         if (!pdev->irq) {
-                ERROR(dev, "No IRQ. Check PCI setup!\n");
+                dev_err(&dev->pdev->dev, "No IRQ. Check PCI setup!\n");
                 retval = -ENODEV;
                 goto error;
         }
 
+        dev->has_sram = 1;
+        dev->got_sram = 0;
+        dev_vdbg(&dev->pdev->dev, "dev->has_sram: %d\n", dev->has_sram);
+
 #ifndef OTG_TRANSCEIVER
-        INFO(dev, "irq %d, io mem: 0x%08lx, len: 0x%08lx, pci mem 0x%p\n",
+        /* enable SRAM caching if detected */
+        if (dev->has_sram && !dev->got_sram)
+                sram_init(dev);
+
+        dev_info(&dev->pdev->dev,
+                        "irq %d, io mem: 0x%08lx, len: 0x%08lx, pci mem 0x%p\n",
                         pdev->irq, resource, len, base);
         /* enables bus-mastering for device dev */
         pci_set_master(pdev);
 
         if (request_irq(pdev->irq, langwell_irq, IRQF_SHARED,
                                 driver_name, dev) != 0) {
-                ERROR(dev, "request interrupt %d failed\n", pdev->irq);
+                dev_err(&dev->pdev->dev,
+                                "request interrupt %d failed\n", pdev->irq);
                 retval = -EBUSY;
                 goto error;
         }
@@ -3071,32 +3243,34 @@ static int langwell_udc_probe(struct pci_dev *pdev,
         dev->lpm = (readl(&dev->cap_regs->hccparams) & HCC_LEN) ? 1 : 0;
         dev->dciversion = readw(&dev->cap_regs->dciversion);
         dev->devcap = (readl(&dev->cap_regs->dccparams) & DEVCAP) ? 1 : 0;
-        VDBG(dev, "dev->lpm: %d\n", dev->lpm);
-        VDBG(dev, "dev->dciversion: 0x%04x\n", dev->dciversion);
-        VDBG(dev, "dccparams: 0x%08x\n", readl(&dev->cap_regs->dccparams));
-        VDBG(dev, "dev->devcap: %d\n", dev->devcap);
+        dev_vdbg(&dev->pdev->dev, "dev->lpm: %d\n", dev->lpm);
+        dev_vdbg(&dev->pdev->dev, "dev->dciversion: 0x%04x\n",
+                        dev->dciversion);
+        dev_vdbg(&dev->pdev->dev, "dccparams: 0x%08x\n",
+                        readl(&dev->cap_regs->dccparams));
+        dev_vdbg(&dev->pdev->dev, "dev->devcap: %d\n", dev->devcap);
         if (!dev->devcap) {
-                ERROR(dev, "can't support device mode\n");
+                dev_err(&dev->pdev->dev, "can't support device mode\n");
                 retval = -ENODEV;
                 goto error;
         }
 
         /* a pair of endpoints (out/in) for each address */
         dev->ep_max = DEN(readl(&dev->cap_regs->dccparams)) * 2;
-        VDBG(dev, "dev->ep_max: %d\n", dev->ep_max);
+        dev_vdbg(&dev->pdev->dev, "dev->ep_max: %d\n", dev->ep_max);
 
         /* allocate endpoints memory */
         dev->ep = kzalloc(sizeof(struct langwell_ep) * dev->ep_max,
                         GFP_KERNEL);
         if (!dev->ep) {
-                ERROR(dev, "allocate endpoints memory failed\n");
+                dev_err(&dev->pdev->dev, "allocate endpoints memory failed\n");
                 retval = -ENOMEM;
                 goto error;
         }
 
         /* allocate device dQH memory */
         size = dev->ep_max * sizeof(struct langwell_dqh);
-        VDBG(dev, "orig size = %d\n", size);
+        dev_vdbg(&dev->pdev->dev, "orig size = %d\n", size);
         if (size < DQH_ALIGNMENT)
                 size = DQH_ALIGNMENT;
         else if ((size % DQH_ALIGNMENT) != 0) {
@@ -3106,17 +3280,18 @@ static int langwell_udc_probe(struct pci_dev *pdev,
         dev->ep_dqh = dma_alloc_coherent(&pdev->dev, size,
                                         &dev->ep_dqh_dma, GFP_KERNEL);
         if (!dev->ep_dqh) {
-                ERROR(dev, "allocate dQH memory failed\n");
+                dev_err(&dev->pdev->dev, "allocate dQH memory failed\n");
                 retval = -ENOMEM;
                 goto error;
         }
         dev->ep_dqh_size = size;
-        VDBG(dev, "ep_dqh_size = %d\n", dev->ep_dqh_size);
+        dev_vdbg(&dev->pdev->dev, "ep_dqh_size = %d\n", dev->ep_dqh_size);
 
         /* initialize ep0 status request structure */
         dev->status_req = kzalloc(sizeof(struct langwell_request), GFP_KERNEL);
         if (!dev->status_req) {
-                ERROR(dev, "allocate status_req memory failed\n");
+                dev_err(&dev->pdev->dev,
+                                "allocate status_req memory failed\n");
                 retval = -ENOMEM;
                 goto error;
         }
@@ -3129,7 +3304,10 @@ static int langwell_udc_probe(struct pci_dev *pdev,
         dev->resume_state = USB_STATE_NOTATTACHED;
         dev->usb_state = USB_STATE_POWERED;
         dev->ep0_dir = USB_DIR_OUT;
-        dev->remote_wakeup = 0; /* default to 0 on reset */
+
+        /* remote wakeup reset to 0 when the device is reset */
+        dev->remote_wakeup = 0;
+        dev->dev_status = 1 << USB_DEVICE_SELF_POWERED;
 
 #ifndef OTG_TRANSCEIVER
         /* reset device controller */
@@ -3174,18 +3352,20 @@ static int langwell_udc_probe(struct pci_dev *pdev,
         }
 
         /* done */
-        INFO(dev, "%s\n", driver_desc);
-        INFO(dev, "irq %d, pci mem %p\n", pdev->irq, base);
-        INFO(dev, "Driver version: " DRIVER_VERSION "\n");
-        INFO(dev, "Support (max) %d endpoints\n", dev->ep_max);
-        INFO(dev, "Device interface version: 0x%04x\n", dev->dciversion);
-        INFO(dev, "Controller mode: %s\n", dev->devcap ? "Device" : "Host");
-        INFO(dev, "Support USB LPM: %s\n", dev->lpm ? "Yes" : "No");
-
-        VDBG(dev, "After langwell_udc_probe(), print all registers:\n");
-#ifdef  VERBOSE
+        dev_info(&dev->pdev->dev, "%s\n", driver_desc);
+        dev_info(&dev->pdev->dev, "irq %d, pci mem %p\n", pdev->irq, base);
+        dev_info(&dev->pdev->dev, "Driver version: " DRIVER_VERSION "\n");
+        dev_info(&dev->pdev->dev, "Support (max) %d endpoints\n", dev->ep_max);
+        dev_info(&dev->pdev->dev, "Device interface version: 0x%04x\n",
+                        dev->dciversion);
+        dev_info(&dev->pdev->dev, "Controller mode: %s\n",
+                        dev->devcap ? "Device" : "Host");
+        dev_info(&dev->pdev->dev, "Support USB LPM: %s\n",
+                        dev->lpm ? "Yes" : "No");
+
+        dev_vdbg(&dev->pdev->dev,
+                        "After langwell_udc_probe(), print all registers:\n");
         print_all_registers(dev);
-#endif
 
         the_controller = dev;
 
@@ -3197,12 +3377,18 @@ static int langwell_udc_probe(struct pci_dev *pdev,
         if (retval)
                 goto error;
 
-        VDBG(dev, "<--- %s()\n", __func__);
+        retval = device_create_file(&pdev->dev, &dev_attr_remote_wakeup);
+        if (retval)
+                goto error_attr1;
+
+        dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
         return 0;
 
+error_attr1:
+        device_remove_file(&pdev->dev, &dev_attr_langwell_udc);
 error:
         if (dev) {
-                DBG(dev, "<--- %s()\n", __func__);
+                dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
                 langwell_udc_remove(pdev);
         }
 
@@ -3214,32 +3400,45 @@ error:
 static int langwell_udc_suspend(struct pci_dev *pdev, pm_message_t state)
 {
         struct langwell_udc     *dev = the_controller;
-        u32                     devlc;
 
-        DBG(dev, "---> %s()\n", __func__);
+        dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
         /* disable interrupt and set controller to stop state */
         langwell_udc_stop(dev);
 
-        /* diable IRQ handler */
+        /* disable IRQ handler */
         if (dev->got_irq)
                 free_irq(pdev->irq, dev);
         dev->got_irq = 0;
 
-
         /* save PCI state */
         pci_save_state(pdev);
 
+        spin_lock_irq(&dev->lock);
+        /* stop all usb activities */
+        stop_activity(dev, dev->driver);
+        spin_unlock_irq(&dev->lock);
+
+        /* free dTD dma_pool and dQH */
+        if (dev->dtd_pool)
+                dma_pool_destroy(dev->dtd_pool);
+
+        if (dev->ep_dqh)
+                dma_free_coherent(&pdev->dev, dev->ep_dqh_size,
+                        dev->ep_dqh, dev->ep_dqh_dma);
+
+        /* release SRAM caching */
+        if (dev->has_sram && dev->got_sram)
+                sram_deinit(dev);
+
         /* set device power state */
         pci_set_power_state(pdev, PCI_D3hot);
 
         /* enter PHY low power suspend */
-        devlc = readl(&dev->op_regs->devlc);
-        VDBG(dev, "devlc = 0x%08x\n", devlc);
-        devlc |= LPM_PHCD;
-        writel(devlc, &dev->op_regs->devlc);
+        if (dev->pdev->device != 0x0829)
+                langwell_phy_low_power(dev, 1);
 
-        DBG(dev, "<--- %s()\n", __func__);
+        dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
         return 0;
 }
 
@@ -3248,27 +3447,58 @@ static int langwell_udc_suspend(struct pci_dev *pdev, pm_message_t state)
 static int langwell_udc_resume(struct pci_dev *pdev)
 {
         struct langwell_udc     *dev = the_controller;
-        u32                     devlc;
+        size_t                  size;
 
-        DBG(dev, "---> %s()\n", __func__);
+        dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
         /* exit PHY low power suspend */
-        devlc = readl(&dev->op_regs->devlc);
-        VDBG(dev, "devlc = 0x%08x\n", devlc);
-        devlc &= ~LPM_PHCD;
-        writel(devlc, &dev->op_regs->devlc);
+        if (dev->pdev->device != 0x0829)
+                langwell_phy_low_power(dev, 0);
 
         /* set device D0 power state */
         pci_set_power_state(pdev, PCI_D0);
 
+        /* enable SRAM caching if detected */
+        if (dev->has_sram && !dev->got_sram)
+                sram_init(dev);
+
+        /* allocate device dQH memory */
+        size = dev->ep_max * sizeof(struct langwell_dqh);
+        dev_vdbg(&dev->pdev->dev, "orig size = %d\n", size);
+        if (size < DQH_ALIGNMENT)
+                size = DQH_ALIGNMENT;
+        else if ((size % DQH_ALIGNMENT) != 0) {
+                size += DQH_ALIGNMENT + 1;
+                size &= ~(DQH_ALIGNMENT - 1);
+        }
+        dev->ep_dqh = dma_alloc_coherent(&pdev->dev, size,
+                                        &dev->ep_dqh_dma, GFP_KERNEL);
+        if (!dev->ep_dqh) {
+                dev_err(&dev->pdev->dev, "allocate dQH memory failed\n");
+                return -ENOMEM;
+        }
+        dev->ep_dqh_size = size;
+        dev_vdbg(&dev->pdev->dev, "ep_dqh_size = %d\n", dev->ep_dqh_size);
+
+        /* create dTD dma_pool resource */
+        dev->dtd_pool = dma_pool_create("langwell_dtd",
+                        &dev->pdev->dev,
+                        sizeof(struct langwell_dtd),
+                        DTD_ALIGNMENT,
+                        DMA_BOUNDARY);
+
+        if (!dev->dtd_pool)
+                return -ENOMEM;
+
         /* restore PCI state */
         pci_restore_state(pdev);
 
         /* enable IRQ handler */
-        if (request_irq(pdev->irq, langwell_irq, IRQF_SHARED, driver_name, dev)
-                        != 0) {
-                ERROR(dev, "request interrupt %d failed\n", pdev->irq);
-                return -1;
+        if (request_irq(pdev->irq, langwell_irq, IRQF_SHARED,
+                                driver_name, dev) != 0) {
+                dev_err(&dev->pdev->dev, "request interrupt %d failed\n",
+                                pdev->irq);
+                return -EBUSY;
         }
         dev->got_irq = 1;
 
@@ -3290,7 +3520,7 @@ static int langwell_udc_resume(struct pci_dev *pdev)
         dev->ep0_state = WAIT_FOR_SETUP;
         dev->ep0_dir = USB_DIR_OUT;
 
-        DBG(dev, "<--- %s()\n", __func__);
+        dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
         return 0;
 }
 
@@ -3301,15 +3531,15 @@ static void langwell_udc_shutdown(struct pci_dev *pdev)
         struct langwell_udc     *dev = the_controller;
         u32                     usbmode;
 
-        DBG(dev, "---> %s()\n", __func__);
+        dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
         /* reset controller mode to IDLE */
         usbmode = readl(&dev->op_regs->usbmode);
-        DBG(dev, "usbmode = 0x%08x\n", usbmode);
+        dev_dbg(&dev->pdev->dev, "usbmode = 0x%08x\n", usbmode);
         usbmode &= (~3 | MODE_IDLE);
         writel(usbmode, &dev->op_regs->usbmode);
 
-        DBG(dev, "<--- %s()\n", __func__);
+        dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
 }
 
 /*-------------------------------------------------------------------------*/
@@ -3324,7 +3554,6 @@ static const struct pci_device_id pci_ids[] = { {
 }, { /* end: all zeroes */ }
 };
 
-
 MODULE_DEVICE_TABLE(pci, pci_ids);
 
 
@@ -3343,12 +3572,6 @@ static struct pci_driver langwell_pci_driver = {
 };
 
 
-MODULE_DESCRIPTION(DRIVER_DESC);
-MODULE_AUTHOR("Xiaochen Shen <xiaochen.shen@intel.com>");
-MODULE_VERSION(DRIVER_VERSION);
-MODULE_LICENSE("GPL");
-
-
 static int __init init(void)
 {
 #ifdef  OTG_TRANSCEIVER
@@ -3370,3 +3593,9 @@ static void __exit cleanup(void)
 }
 module_exit(cleanup);
 
+
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_AUTHOR("Xiaochen Shen <xiaochen.shen@intel.com>");
+MODULE_VERSION(DRIVER_VERSION);
+MODULE_LICENSE("GPL");
+
diff --git a/drivers/usb/gadget/langwell_udc.h b/drivers/usb/gadget/langwell_udc.h
index 9719934e1c08..f1d9c1bb04f3 100644
--- a/drivers/usb/gadget/langwell_udc.h
+++ b/drivers/usb/gadget/langwell_udc.h
@@ -18,11 +18,7 @@
  */
 
 #include <linux/usb/langwell_udc.h>
-
-#if defined(CONFIG_USB_LANGWELL_OTG)
 #include <linux/usb/langwell_otg.h>
-#endif
-
 
 /*-------------------------------------------------------------------------*/
 
@@ -199,7 +195,9 @@ struct langwell_udc {
                                 vbus_active:1,
                                 suspended:1,
                                 stopped:1,
-                                lpm:1;  /* LPM capability */
+                                lpm:1,          /* LPM capability */
+                                has_sram:1,     /* SRAM caching */
+                                got_sram:1;
 
         /* pci state used to access those endpoints */
         struct pci_dev          *pdev;
@@ -224,5 +222,12 @@ struct langwell_udc {
 
         /* make sure release() is done */
         struct completion       *done;
+
+        /* for private SRAM caching */
+        unsigned int            sram_addr;
+        unsigned int            sram_size;
+
+        /* device status data for get_status request */
+        u16                     dev_status;
 };
 
diff --git a/drivers/usb/gadget/lh7a40x_udc.c b/drivers/usb/gadget/lh7a40x_udc.c
deleted file mode 100644
index fded3fca793b..000000000000
--- a/drivers/usb/gadget/lh7a40x_udc.c
+++ /dev/null
@@ -1,2152 +0,0 @@
-/*
- * linux/drivers/usb/gadget/lh7a40x_udc.c
- * Sharp LH7A40x on-chip full speed USB device controllers
- *
- * Copyright (C) 2004 Mikko Lahteenmaki, Nordic ID
- * Copyright (C) 2004 Bo Henriksen, Nordic ID
- *
- * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- *
- */
-
-#include <linux/platform_device.h>
-#include <linux/slab.h>
-
-#include "lh7a40x_udc.h"
-
-//#define DEBUG printk
-//#define DEBUG_EP0 printk
-//#define DEBUG_SETUP printk
-
-#ifndef DEBUG_EP0
-# define DEBUG_EP0(fmt,args...)
-#endif
-#ifndef DEBUG_SETUP
-# define DEBUG_SETUP(fmt,args...)
-#endif
-#ifndef DEBUG
-# define NO_STATES
-# define DEBUG(fmt,args...)
-#endif
-
-#define DRIVER_DESC                     "LH7A40x USB Device Controller"
-#define DRIVER_VERSION          __DATE__
-
-#ifndef _BIT                    /* FIXME - what happended to _BIT in 2.6.7bk18? */
-#define _BIT(x) (1<<(x))
-#endif
-
-struct lh7a40x_udc *the_controller;
-
-static const char driver_name[] = "lh7a40x_udc";
-static const char driver_desc[] = DRIVER_DESC;
-static const char ep0name[] = "ep0-control";
-
-/*
-  Local definintions.
-*/
-
-#ifndef NO_STATES
-static char *state_names[] = {
-        "WAIT_FOR_SETUP",
-        "DATA_STATE_XMIT",
-        "DATA_STATE_NEED_ZLP",
-        "WAIT_FOR_OUT_STATUS",
-        "DATA_STATE_RECV"
-};
-#endif
-
-/*
-  Local declarations.
-*/
-static int lh7a40x_ep_enable(struct usb_ep *ep,
-                             const struct usb_endpoint_descriptor *);
-static int lh7a40x_ep_disable(struct usb_ep *ep);
-static struct usb_request *lh7a40x_alloc_request(struct usb_ep *ep, gfp_t);
-static void lh7a40x_free_request(struct usb_ep *ep, struct usb_request *);
-static int lh7a40x_queue(struct usb_ep *ep, struct usb_request *, gfp_t);
-static int lh7a40x_dequeue(struct usb_ep *ep, struct usb_request *);
-static int lh7a40x_set_halt(struct usb_ep *ep, int);
-static int lh7a40x_fifo_status(struct usb_ep *ep);
-static void lh7a40x_fifo_flush(struct usb_ep *ep);
-static void lh7a40x_ep0_kick(struct lh7a40x_udc *dev, struct lh7a40x_ep *ep);
-static void lh7a40x_handle_ep0(struct lh7a40x_udc *dev, u32 intr);
-
-static void done(struct lh7a40x_ep *ep, struct lh7a40x_request *req,
-                 int status);
-static void pio_irq_enable(int bEndpointAddress);
-static void pio_irq_disable(int bEndpointAddress);
-static void stop_activity(struct lh7a40x_udc *dev,
-                          struct usb_gadget_driver *driver);
-static void flush(struct lh7a40x_ep *ep);
-static void udc_enable(struct lh7a40x_udc *dev);
-static void udc_set_address(struct lh7a40x_udc *dev, unsigned char address);
-
-static struct usb_ep_ops lh7a40x_ep_ops = {
-        .enable = lh7a40x_ep_enable,
-        .disable = lh7a40x_ep_disable,
-
-        .alloc_request = lh7a40x_alloc_request,
-        .free_request = lh7a40x_free_request,
-
-        .queue = lh7a40x_queue,
-        .dequeue = lh7a40x_dequeue,
-
-        .set_halt = lh7a40x_set_halt,
-        .fifo_status = lh7a40x_fifo_status,
-        .fifo_flush = lh7a40x_fifo_flush,
-};
-
-/* Inline code */
-
-static __inline__ int write_packet(struct lh7a40x_ep *ep,
-                                   struct lh7a40x_request *req, int max)
-{
-        u8 *buf;
-        int length, count;
-        volatile u32 *fifo = (volatile u32 *)ep->fifo;
-
-        buf = req->req.buf + req->req.actual;
-        prefetch(buf);
-
-        length = req->req.length - req->req.actual;
-        length = min(length, max);
-        req->req.actual += length;
-
-        DEBUG("Write %d (max %d), fifo %p\n", length, max, fifo);
-
-        count = length;
-        while (count--) {
-                *fifo = *buf++;
-        }
-
-        return length;
-}
-
-static __inline__ void usb_set_index(u32 ep)
-{
-        *(volatile u32 *)io_p2v(USB_INDEX) = ep;
-}
-
-static __inline__ u32 usb_read(u32 port)
-{
-        return *(volatile u32 *)io_p2v(port);
-}
-
-static __inline__ void usb_write(u32 val, u32 port)
-{
-        *(volatile u32 *)io_p2v(port) = val;
-}
-
-static __inline__ void usb_set(u32 val, u32 port)
-{
-        volatile u32 *ioport = (volatile u32 *)io_p2v(port);
-        u32 after = (*ioport) | val;
-        *ioport = after;
-}
-
-static __inline__ void usb_clear(u32 val, u32 port)
-{
-        volatile u32 *ioport = (volatile u32 *)io_p2v(port);
-        u32 after = (*ioport) & ~val;
-        *ioport = after;
-}
-
-/*-------------------------------------------------------------------------*/
-
-#define GPIO_PORTC_DR   (0x80000E08)
-#define GPIO_PORTC_DDR  (0x80000E18)
-#define GPIO_PORTC_PDR  (0x80000E70)
-
-/* get port C pin data register */
-#define get_portc_pdr(bit)              ((usb_read(GPIO_PORTC_PDR) & _BIT(bit)) != 0)
-/* get port C data direction register */
-#define get_portc_ddr(bit)              ((usb_read(GPIO_PORTC_DDR) & _BIT(bit)) != 0)
-/* set port C data register */
-#define set_portc_dr(bit, val)  (val ? usb_set(_BIT(bit), GPIO_PORTC_DR) : usb_clear(_BIT(bit), GPIO_PORTC_DR))
-/* set port C data direction register */
-#define set_portc_ddr(bit, val) (val ? usb_set(_BIT(bit), GPIO_PORTC_DDR) : usb_clear(_BIT(bit), GPIO_PORTC_DDR))
-
-/*
- * LPD7A404 GPIO's:
- * Port C bit 1 = USB Port 1 Power Enable
- * Port C bit 2 = USB Port 1 Data Carrier Detect
- */
-#define is_usb_connected()              get_portc_pdr(2)
-
-#ifdef CONFIG_USB_GADGET_DEBUG_FILES
-
-static const char proc_node_name[] = "driver/udc";
-
-static int
-udc_proc_read(char *page, char **start, off_t off, int count,
-              int *eof, void *_dev)
-{
-        char *buf = page;
-        struct lh7a40x_udc *dev = _dev;
-        char *next = buf;
-        unsigned size = count;
-        unsigned long flags;
-        int t;
-
-        if (off != 0)
-                return 0;
-
-        local_irq_save(flags);
-
-        /* basic device status */
-        t = scnprintf(next, size,
-                      DRIVER_DESC "\n"
-                      "%s version: %s\n"
-                      "Gadget driver: %s\n"
-                      "Host: %s\n\n",
-                      driver_name, DRIVER_VERSION,
-                      dev->driver ? dev->driver->driver.name : "(none)",
-                      is_usb_connected()? "full speed" : "disconnected");
-        size -= t;
-        next += t;
-
-        t = scnprintf(next, size,
-                      "GPIO:\n"
-                      " Port C bit 1: %d, dir %d\n"
-                      " Port C bit 2: %d, dir %d\n\n",
-                      get_portc_pdr(1), get_portc_ddr(1),
-                      get_portc_pdr(2), get_portc_ddr(2)
-            );
-        size -= t;
-        next += t;
-
-        t = scnprintf(next, size,
-                      "DCP pullup: %d\n\n",
-                      (usb_read(USB_PM) & PM_USB_DCP) != 0);
-        size -= t;
-        next += t;
-
-        local_irq_restore(flags);
-        *eof = 1;
-        return count - size;
-}
-
-#define create_proc_files()     create_proc_read_entry(proc_node_name, 0, NULL, udc_proc_read, dev)
-#define remove_proc_files()     remove_proc_entry(proc_node_name, NULL)
-
-#else   /* !CONFIG_USB_GADGET_DEBUG_FILES */
-
-#define create_proc_files() do {} while (0)
-#define remove_proc_files() do {} while (0)
-
-#endif  /* CONFIG_USB_GADGET_DEBUG_FILES */
-
-/*
- *      udc_disable - disable USB device controller
- */
-static void udc_disable(struct lh7a40x_udc *dev)
-{
-        DEBUG("%s, %p\n", __func__, dev);
-
-        udc_set_address(dev, 0);
-
-        /* Disable interrupts */
-        usb_write(0, USB_IN_INT_EN);
-        usb_write(0, USB_OUT_INT_EN);
-        usb_write(0, USB_INT_EN);
-
-        /* Disable the USB */
-        usb_write(0, USB_PM);
-
-#ifdef CONFIG_ARCH_LH7A404
-        /* Disable USB power */
-        set_portc_dr(1, 0);
-#endif
-
-        /* if hardware supports it, disconnect from usb */
-        /* make_usb_disappear(); */
-
-        dev->ep0state = WAIT_FOR_SETUP;
-        dev->gadget.speed = USB_SPEED_UNKNOWN;
-        dev->usb_address = 0;
-}
-
-/*
- *      udc_reinit - initialize software state
- */
-static void udc_reinit(struct lh7a40x_udc *dev)
-{
-        u32 i;
-
-        DEBUG("%s, %p\n", __func__, dev);
-
-        /* device/ep0 records init */
-        INIT_LIST_HEAD(&dev->gadget.ep_list);
-        INIT_LIST_HEAD(&dev->gadget.ep0->ep_list);
-        dev->ep0state = WAIT_FOR_SETUP;
-
-        /* basic endpoint records init */
-        for (i = 0; i < UDC_MAX_ENDPOINTS; i++) {
-                struct lh7a40x_ep *ep = &dev->ep[i];
-
-                if (i != 0)
-                        list_add_tail(&ep->ep.ep_list, &dev->gadget.ep_list);
-
-                ep->desc = 0;
-                ep->stopped = 0;
-                INIT_LIST_HEAD(&ep->queue);
-                ep->pio_irqs = 0;
-        }
-
-        /* the rest was statically initialized, and is read-only */
-}
-
-#define BYTES2MAXP(x)   (x / 8)
-#define MAXP2BYTES(x)   (x * 8)
-
-/* until it's enabled, this UDC should be completely invisible
- * to any USB host.
- */
-static void udc_enable(struct lh7a40x_udc *dev)
-{
-        int ep;
-
-        DEBUG("%s, %p\n", __func__, dev);
-
-        dev->gadget.speed = USB_SPEED_UNKNOWN;
-
-#ifdef CONFIG_ARCH_LH7A404
-        /* Set Port C bit 1 & 2 as output */
-        set_portc_ddr(1, 1);
-        set_portc_ddr(2, 1);
-
-        /* Enable USB power */
-        set_portc_dr(1, 0);
-#endif
-
-        /*
-         * C.f Chapter 18.1.3.1 Initializing the USB
-         */
-
-        /* Disable the USB */
-        usb_clear(PM_USB_ENABLE, USB_PM);
-
-        /* Reset APB & I/O sides of the USB */
-        usb_set(USB_RESET_APB | USB_RESET_IO, USB_RESET);
-        mdelay(5);
-        usb_clear(USB_RESET_APB | USB_RESET_IO, USB_RESET);
-
-        /* Set MAXP values for each */
-        for (ep = 0; ep < UDC_MAX_ENDPOINTS; ep++) {
-                struct lh7a40x_ep *ep_reg = &dev->ep[ep];
-                u32 csr;
-
-                usb_set_index(ep);
-
-                switch (ep_reg->ep_type) {
-                case ep_bulk_in:
-                case ep_interrupt:
-                        usb_clear(USB_IN_CSR2_USB_DMA_EN | USB_IN_CSR2_AUTO_SET,
-                                  ep_reg->csr2);
-                        /* Fall through */
-                case ep_control:
-                        usb_write(BYTES2MAXP(ep_maxpacket(ep_reg)),
-                                  USB_IN_MAXP);
-                        break;
-                case ep_bulk_out:
-                        usb_clear(USB_OUT_CSR2_USB_DMA_EN |
-                                  USB_OUT_CSR2_AUTO_CLR, ep_reg->csr2);
-                        usb_write(BYTES2MAXP(ep_maxpacket(ep_reg)),
-                                  USB_OUT_MAXP);
-                        break;
-                }
-
-                /* Read & Write CSR1, just in case */
-                csr = usb_read(ep_reg->csr1);
-                usb_write(csr, ep_reg->csr1);
-
-                flush(ep_reg);
-        }
-
-        /* Disable interrupts */
-        usb_write(0, USB_IN_INT_EN);
-        usb_write(0, USB_OUT_INT_EN);
-        usb_write(0, USB_INT_EN);
-
-        /* Enable interrupts */
-        usb_set(USB_IN_INT_EP0, USB_IN_INT_EN);
-        usb_set(USB_INT_RESET_INT | USB_INT_RESUME_INT, USB_INT_EN);
-        /* Dont enable rest of the interrupts */
-        /* usb_set(USB_IN_INT_EP3 | USB_IN_INT_EP1 | USB_IN_INT_EP0, USB_IN_INT_EN);
-           usb_set(USB_OUT_INT_EP2, USB_OUT_INT_EN); */
-
-        /* Enable SUSPEND */
-        usb_set(PM_ENABLE_SUSPEND, USB_PM);
-
-        /* Enable the USB */
-        usb_set(PM_USB_ENABLE, USB_PM);
-
-#ifdef CONFIG_ARCH_LH7A404
-        /* NOTE: DOES NOT WORK! */
-        /* Let host detect UDC:
-         * Software must write a 0 to the PMR:DCP_CTRL bit to turn this
-         * transistor on and pull the USBDP pin HIGH.
-         */
-        /* usb_clear(PM_USB_DCP, USB_PM);
-           usb_set(PM_USB_DCP, USB_PM); */
-#endif
-}
-
-/*
-  Register entry point for the peripheral controller driver.
-*/
-int usb_gadget_register_driver(struct usb_gadget_driver *driver)
-{
-        struct lh7a40x_udc *dev = the_controller;
-        int retval;
-
-        DEBUG("%s: %s\n", __func__, driver->driver.name);
-
-        if (!driver
-                        || driver->speed != USB_SPEED_FULL
-                        || !driver->bind
-                        || !driver->disconnect
-                        || !driver->setup)
-                return -EINVAL;
-        if (!dev)
-                return -ENODEV;
-        if (dev->driver)
-                return -EBUSY;
-
-        /* first hook up the driver ... */
-        dev->driver = driver;
-        dev->gadget.dev.driver = &driver->driver;
-
-        device_add(&dev->gadget.dev);
-        retval = driver->bind(&dev->gadget);
-        if (retval) {
-                printk(KERN_WARNING "%s: bind to driver %s --> error %d\n",
-                       dev->gadget.name, driver->driver.name, retval);
-                device_del(&dev->gadget.dev);
-
-                dev->driver = 0;
-                dev->gadget.dev.driver = 0;
-                return retval;
-        }
-
-        /* ... then enable host detection and ep0; and we're ready
-         * for set_configuration as well as eventual disconnect.
-         * NOTE:  this shouldn't power up until later.
-         */
-        printk(KERN_WARNING "%s: registered gadget driver '%s'\n",
-               dev->gadget.name, driver->driver.name);
-
-        udc_enable(dev);
-
-        return 0;
-}
-
-EXPORT_SYMBOL(usb_gadget_register_driver);
-
-/*
-  Unregister entry point for the peripheral controller driver.
-*/
-int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
-{
-        struct lh7a40x_udc *dev = the_controller;
-        unsigned long flags;
-
-        if (!dev)
-                return -ENODEV;
-        if (!driver || driver != dev->driver || !driver->unbind)
-                return -EINVAL;
-
-        spin_lock_irqsave(&dev->lock, flags);
-        dev->driver = 0;
-        stop_activity(dev, driver);
-        spin_unlock_irqrestore(&dev->lock, flags);
-
-        driver->unbind(&dev->gadget);
-        dev->gadget.dev.driver = NULL;
-        device_del(&dev->gadget.dev);
-
-        udc_disable(dev);
-
-        DEBUG("unregistered gadget driver '%s'\n", driver->driver.name);
-        return 0;
-}
-
-EXPORT_SYMBOL(usb_gadget_unregister_driver);
-
-/*-------------------------------------------------------------------------*/
-
-/** Write request to FIFO (max write == maxp size)
- *  Return:  0 = still running, 1 = completed, negative = errno
- *  NOTE: INDEX register must be set for EP
- */
-static int write_fifo(struct lh7a40x_ep *ep, struct lh7a40x_request *req)
-{
-        u32 max;
-        u32 csr;
-
-        max = le16_to_cpu(ep->desc->wMaxPacketSize);
-
-        csr = usb_read(ep->csr1);
-        DEBUG("CSR: %x %d\n", csr, csr & USB_IN_CSR1_FIFO_NOT_EMPTY);
-
-        if (!(csr & USB_IN_CSR1_FIFO_NOT_EMPTY)) {
-                unsigned count;
-                int is_last, is_short;
-
-                count = write_packet(ep, req, max);
-                usb_set(USB_IN_CSR1_IN_PKT_RDY, ep->csr1);
-
-                /* last packet is usually short (or a zlp) */
-                if (unlikely(count != max))
-                        is_last = is_short = 1;
-                else {
-                        if (likely(req->req.length != req->req.actual)
-                            || req->req.zero)
-                                is_last = 0;
-                        else
-                                is_last = 1;
-                        /* interrupt/iso maxpacket may not fill the fifo */
-                        is_short = unlikely(max < ep_maxpacket(ep));
-                }
-
-                DEBUG("%s: wrote %s %d bytes%s%s %d left %p\n", __func__,
-                      ep->ep.name, count,
-                      is_last ? "/L" : "", is_short ? "/S" : "",
-                      req->req.length - req->req.actual, req);
-
-                /* requests complete when all IN data is in the FIFO */
-                if (is_last) {
-                        done(ep, req, 0);
-                        if (list_empty(&ep->queue)) {
-                                pio_irq_disable(ep_index(ep));
-                        }
-                        return 1;
-                }
-        } else {
-                DEBUG("Hmm.. %d ep FIFO is not empty!\n", ep_index(ep));
-        }
-
-        return 0;
-}
-
-/** Read to request from FIFO (max read == bytes in fifo)
- *  Return:  0 = still running, 1 = completed, negative = errno
- *  NOTE: INDEX register must be set for EP
- */
-static int read_fifo(struct lh7a40x_ep *ep, struct lh7a40x_request *req)
-{
-        u32 csr;
-        u8 *buf;
-        unsigned bufferspace, count, is_short;
-        volatile u32 *fifo = (volatile u32 *)ep->fifo;
-
-        /* make sure there's a packet in the FIFO. */
-        csr = usb_read(ep->csr1);
-        if (!(csr & USB_OUT_CSR1_OUT_PKT_RDY)) {
-                DEBUG("%s: Packet NOT ready!\n", __func__);
-                return -EINVAL;
-        }
-
-        buf = req->req.buf + req->req.actual;
-        prefetchw(buf);
-        bufferspace = req->req.length - req->req.actual;
-
-        /* read all bytes from this packet */
-        count = usb_read(USB_OUT_FIFO_WC1);
-        req->req.actual += min(count, bufferspace);
-
-        is_short = (count < ep->ep.maxpacket);
-        DEBUG("read %s %02x, %d bytes%s req %p %d/%d\n",
-              ep->ep.name, csr, count,
-              is_short ? "/S" : "", req, req->req.actual, req->req.length);
-
-        while (likely(count-- != 0)) {
-                u8 byte = (u8) (*fifo & 0xff);
-
-                if (unlikely(bufferspace == 0)) {
-                        /* this happens when the driver's buffer
-                         * is smaller than what the host sent.
-                         * discard the extra data.
-                         */
-                        if (req->req.status != -EOVERFLOW)
-                                printk(KERN_WARNING "%s overflow %d\n",
-                                       ep->ep.name, count);
-                        req->req.status = -EOVERFLOW;
-                } else {
-                        *buf++ = byte;
-                        bufferspace--;
-                }
-        }
-
-        usb_clear(USB_OUT_CSR1_OUT_PKT_RDY, ep->csr1);
-
-        /* completion */
-        if (is_short || req->req.actual == req->req.length) {
-                done(ep, req, 0);
-                usb_set(USB_OUT_CSR1_FIFO_FLUSH, ep->csr1);
-
-                if (list_empty(&ep->queue))
-                        pio_irq_disable(ep_index(ep));
-                return 1;
-        }
-
-        /* finished that packet.  the next one may be waiting... */
-        return 0;
-}
-
-/*
- *      done - retire a request; caller blocked irqs
- *  INDEX register is preserved to keep same
- */
-static void done(struct lh7a40x_ep *ep, struct lh7a40x_request *req, int status)
-{
-        unsigned int stopped = ep->stopped;
-        u32 index;
-
-        DEBUG("%s, %p\n", __func__, ep);
-        list_del_init(&req->queue);
-
-        if (likely(req->req.status == -EINPROGRESS))
-                req->req.status = status;
-        else
-                status = req->req.status;
-
-        if (status && status != -ESHUTDOWN)
-                DEBUG("complete %s req %p stat %d len %u/%u\n",
-                      ep->ep.name, &req->req, status,
-                      req->req.actual, req->req.length);
-
-        /* don't modify queue heads during completion callback */
-        ep->stopped = 1;
-        /* Read current index (completion may modify it) */
-        index = usb_read(USB_INDEX);
-
-        spin_unlock(&ep->dev->lock);
-        req->req.complete(&ep->ep, &req->req);
-        spin_lock(&ep->dev->lock);
-
-        /* Restore index */
-        usb_set_index(index);
-        ep->stopped = stopped;
-}
-
-/** Enable EP interrupt */
-static void pio_irq_enable(int ep)
-{
-        DEBUG("%s: %d\n", __func__, ep);
-
-        switch (ep) {
-        case 1:
-                usb_set(USB_IN_INT_EP1, USB_IN_INT_EN);
-                break;
-        case 2:
-                usb_set(USB_OUT_INT_EP2, USB_OUT_INT_EN);
-                break;
-        case 3:
-                usb_set(USB_IN_INT_EP3, USB_IN_INT_EN);
-                break;
-        default:
-                DEBUG("Unknown endpoint: %d\n", ep);
-                break;
-        }
-}
-
-/** Disable EP interrupt */
-static void pio_irq_disable(int ep)
-{
-        DEBUG("%s: %d\n", __func__, ep);
-
-        switch (ep) {
-        case 1:
-                usb_clear(USB_IN_INT_EP1, USB_IN_INT_EN);
-                break;
-        case 2:
-                usb_clear(USB_OUT_INT_EP2, USB_OUT_INT_EN);
-                break;
-        case 3:
-                usb_clear(USB_IN_INT_EP3, USB_IN_INT_EN);
-                break;
-        default:
-                DEBUG("Unknown endpoint: %d\n", ep);
-                break;
-        }
-}
-
-/*
- *      nuke - dequeue ALL requests
- */
-void nuke(struct lh7a40x_ep *ep, int status)
-{
-        struct lh7a40x_request *req;
-
-        DEBUG("%s, %p\n", __func__, ep);
-
-        /* Flush FIFO */
-        flush(ep);
-
-        /* called with irqs blocked */
-        while (!list_empty(&ep->queue)) {
-                req = list_entry(ep->queue.next, struct lh7a40x_request, queue);
-                done(ep, req, status);
-        }
-
-        /* Disable IRQ if EP is enabled (has descriptor) */
-        if (ep->desc)
-                pio_irq_disable(ep_index(ep));
-}
-
-/*
-void nuke_all(struct lh7a40x_udc *dev)
-{
-        int n;
-        for(n=0; n<UDC_MAX_ENDPOINTS; n++) {
-                struct lh7a40x_ep *ep = &dev->ep[n];
-                usb_set_index(n);
-                nuke(ep, 0);
-        }
-}*/
-
-/*
-static void flush_all(struct lh7a40x_udc *dev)
-{
-        int n;
-    for (n = 0; n < UDC_MAX_ENDPOINTS; n++)
-    {
-                struct lh7a40x_ep *ep = &dev->ep[n];
-                flush(ep);
-    }
-}
-*/
-
-/** Flush EP
- * NOTE: INDEX register must be set before this call
- */
-static void flush(struct lh7a40x_ep *ep)
-{
-        DEBUG("%s, %p\n", __func__, ep);
-
-        switch (ep->ep_type) {
-        case ep_control:
-                /* check, by implication c.f. 15.1.2.11 */
-                break;
-
-        case ep_bulk_in:
-        case ep_interrupt:
-                /* if(csr & USB_IN_CSR1_IN_PKT_RDY) */
-                usb_set(USB_IN_CSR1_FIFO_FLUSH, ep->csr1);
-                break;
-
-        case ep_bulk_out:
-                /* if(csr & USB_OUT_CSR1_OUT_PKT_RDY) */
-                usb_set(USB_OUT_CSR1_FIFO_FLUSH, ep->csr1);
-                break;
-        }
-}
-
-/**
- * lh7a40x_in_epn - handle IN interrupt
- */
-static void lh7a40x_in_epn(struct lh7a40x_udc *dev, u32 ep_idx, u32 intr)
-{
-        u32 csr;
-        struct lh7a40x_ep *ep = &dev->ep[ep_idx];
-        struct lh7a40x_request *req;
-
-        usb_set_index(ep_idx);
-
-        csr = usb_read(ep->csr1);
-        DEBUG("%s: %d, csr %x\n", __func__, ep_idx, csr);
-
-        if (csr & USB_IN_CSR1_SENT_STALL) {
-                DEBUG("USB_IN_CSR1_SENT_STALL\n");
-                usb_set(USB_IN_CSR1_SENT_STALL /*|USB_IN_CSR1_SEND_STALL */ ,
-                        ep->csr1);
-                return;
-        }
-
-        if (!ep->desc) {
-                DEBUG("%s: NO EP DESC\n", __func__);
-                return;
-        }
-
-        if (list_empty(&ep->queue))
-                req = 0;
-        else
-                req = list_entry(ep->queue.next, struct lh7a40x_request, queue);
-
-        DEBUG("req: %p\n", req);
-
-        if (!req)
-                return;
-
-        write_fifo(ep, req);
-}
-
-/* ********************************************************************************************* */
-/* Bulk OUT (recv)
- */
-
-static void lh7a40x_out_epn(struct lh7a40x_udc *dev, u32 ep_idx, u32 intr)
-{
-        struct lh7a40x_ep *ep = &dev->ep[ep_idx];
-        struct lh7a40x_request *req;
-
-        DEBUG("%s: %d\n", __func__, ep_idx);
-
-        usb_set_index(ep_idx);
-
-        if (ep->desc) {
-                u32 csr;
-                csr = usb_read(ep->csr1);
-
-                while ((csr =
-                        usb_read(ep->
-                                 csr1)) & (USB_OUT_CSR1_OUT_PKT_RDY |
-                                           USB_OUT_CSR1_SENT_STALL)) {
-                        DEBUG("%s: %x\n", __func__, csr);
-
-                        if (csr & USB_OUT_CSR1_SENT_STALL) {
-                                DEBUG("%s: stall sent, flush fifo\n",
-                                      __func__);
-                                /* usb_set(USB_OUT_CSR1_FIFO_FLUSH, ep->csr1); */
-                                flush(ep);
-                        } else if (csr & USB_OUT_CSR1_OUT_PKT_RDY) {
-                                if (list_empty(&ep->queue))
-                                        req = 0;
-                                else
-                                        req =
-                                            list_entry(ep->queue.next,
-                                                       struct lh7a40x_request,
-                                                       queue);
-
-                                if (!req) {
-                                        printk(KERN_WARNING
-                                               "%s: NULL REQ %d\n",
-                                               __func__, ep_idx);
-                                        flush(ep);
-                                        break;
-                                } else {
-                                        read_fifo(ep, req);
-                                }
-                        }
-
-                }
-
-        } else {
-                /* Throw packet away.. */
-                printk(KERN_WARNING "%s: No descriptor?!?\n", __func__);
-                flush(ep);
-        }
-}
-
-static void stop_activity(struct lh7a40x_udc *dev,
-                          struct usb_gadget_driver *driver)
-{
-        int i;
-
-        /* don't disconnect drivers more than once */
-        if (dev->gadget.speed == USB_SPEED_UNKNOWN)
-                driver = 0;
-        dev->gadget.speed = USB_SPEED_UNKNOWN;
-
-        /* prevent new request submissions, kill any outstanding requests  */
-        for (i = 0; i < UDC_MAX_ENDPOINTS; i++) {
-                struct lh7a40x_ep *ep = &dev->ep[i];
-                ep->stopped = 1;
-
-                usb_set_index(i);
-                nuke(ep, -ESHUTDOWN);
-        }
-
-        /* report disconnect; the driver is already quiesced */
-        if (driver) {
-                spin_unlock(&dev->lock);
-                driver->disconnect(&dev->gadget);
-                spin_lock(&dev->lock);
-        }
-
-        /* re-init driver-visible data structures */
-        udc_reinit(dev);
-}
-
-/** Handle USB RESET interrupt
- */
-static void lh7a40x_reset_intr(struct lh7a40x_udc *dev)
-{
-#if 0                           /* def CONFIG_ARCH_LH7A404 */
-        /* Does not work always... */
-
-        DEBUG("%s: %d\n", __func__, dev->usb_address);
-
-        if (!dev->usb_address) {
-                /*usb_set(USB_RESET_IO, USB_RESET);
-                   mdelay(5);
-                   usb_clear(USB_RESET_IO, USB_RESET); */
-                return;
-        }
-        /* Put the USB controller into reset. */
-        usb_set(USB_RESET_IO, USB_RESET);
-
-        /* Set Device ID to 0 */
-        udc_set_address(dev, 0);
-
-        /* Let PLL2 settle down */
-        mdelay(5);
-
-        /* Release the USB controller from reset */
-        usb_clear(USB_RESET_IO, USB_RESET);
-
-        /* Re-enable UDC */
-        udc_enable(dev);
-
-#endif
-        dev->gadget.speed = USB_SPEED_FULL;
-}
-
-/*
- *      lh7a40x usb client interrupt handler.
- */
-static irqreturn_t lh7a40x_udc_irq(int irq, void *_dev)
-{
-        struct lh7a40x_udc *dev = _dev;
-
-        DEBUG("\n\n");
-
-        spin_lock(&dev->lock);
-
-        for (;;) {
-                u32 intr_in = usb_read(USB_IN_INT);
-                u32 intr_out = usb_read(USB_OUT_INT);
-                u32 intr_int = usb_read(USB_INT);
-
-                /* Test also against enable bits.. (lh7a40x errata).. Sigh.. */
-                u32 in_en = usb_read(USB_IN_INT_EN);
-                u32 out_en = usb_read(USB_OUT_INT_EN);
-
-                if (!intr_out && !intr_in && !intr_int)
-                        break;
-
-                DEBUG("%s (on state %s)\n", __func__,
-                      state_names[dev->ep0state]);
-                DEBUG("intr_out = %x\n", intr_out);
-                DEBUG("intr_in  = %x\n", intr_in);
-                DEBUG("intr_int = %x\n", intr_int);
-
-                if (intr_in) {
-                        usb_write(intr_in, USB_IN_INT);
-
-                        if ((intr_in & USB_IN_INT_EP1)
-                            && (in_en & USB_IN_INT_EP1)) {
-                                DEBUG("USB_IN_INT_EP1\n");
-                                lh7a40x_in_epn(dev, 1, intr_in);
-                        }
-                        if ((intr_in & USB_IN_INT_EP3)
-                            && (in_en & USB_IN_INT_EP3)) {
-                                DEBUG("USB_IN_INT_EP3\n");
-                                lh7a40x_in_epn(dev, 3, intr_in);
-                        }
-                        if (intr_in & USB_IN_INT_EP0) {
-                                DEBUG("USB_IN_INT_EP0 (control)\n");
-                                lh7a40x_handle_ep0(dev, intr_in);
-                        }
-                }
-
-                if (intr_out) {
-                        usb_write(intr_out, USB_OUT_INT);
-
-                        if ((intr_out & USB_OUT_INT_EP2)
-                            && (out_en & USB_OUT_INT_EP2)) {
-                                DEBUG("USB_OUT_INT_EP2\n");
-                                lh7a40x_out_epn(dev, 2, intr_out);
-                        }
-                }
-
-                if (intr_int) {
-                        usb_write(intr_int, USB_INT);
-
-                        if (intr_int & USB_INT_RESET_INT) {
-                                lh7a40x_reset_intr(dev);
-                        }
-
-                        if (intr_int & USB_INT_RESUME_INT) {
-                                DEBUG("USB resume\n");
-
-                                if (dev->gadget.speed != USB_SPEED_UNKNOWN
-                                    && dev->driver
-                                    && dev->driver->resume
-                                    && is_usb_connected()) {
-                                        dev->driver->resume(&dev->gadget);
-                                }
-                        }
-
-                        if (intr_int & USB_INT_SUSPEND_INT) {
-                                DEBUG("USB suspend%s\n",
-                                      is_usb_connected()? "" : "+disconnect");
-                                if (!is_usb_connected()) {
-                                        stop_activity(dev, dev->driver);
-                                } else if (dev->gadget.speed !=
-                                           USB_SPEED_UNKNOWN && dev->driver
-                                           && dev->driver->suspend) {
-                                        dev->driver->suspend(&dev->gadget);
-                                }
-                        }
-
-                }
-        }
-
-        spin_unlock(&dev->lock);
-
-        return IRQ_HANDLED;
-}
-
-static int lh7a40x_ep_enable(struct usb_ep *_ep,
-                             const struct usb_endpoint_descriptor *desc)
-{
-        struct lh7a40x_ep *ep;
-        struct lh7a40x_udc *dev;
-        unsigned long flags;
-
-        DEBUG("%s, %p\n", __func__, _ep);
-
-        ep = container_of(_ep, struct lh7a40x_ep, ep);
-        if (!_ep || !desc || ep->desc || _ep->name == ep0name
-            || desc->bDescriptorType != USB_DT_ENDPOINT
-            || ep->bEndpointAddress != desc->bEndpointAddress
-            || ep_maxpacket(ep) < le16_to_cpu(desc->wMaxPacketSize)) {
-                DEBUG("%s, bad ep or descriptor\n", __func__);
-                return -EINVAL;
-        }
-
-        /* xfer types must match, except that interrupt ~= bulk */
-        if (ep->bmAttributes != desc->bmAttributes
-            && ep->bmAttributes != USB_ENDPOINT_XFER_BULK
-            && desc->bmAttributes != USB_ENDPOINT_XFER_INT) {
-                DEBUG("%s, %s type mismatch\n", __func__, _ep->name);
-                return -EINVAL;
-        }
-
-        /* hardware _could_ do smaller, but driver doesn't */
-        if ((desc->bmAttributes == USB_ENDPOINT_XFER_BULK
-             && le16_to_cpu(desc->wMaxPacketSize) != ep_maxpacket(ep))
-            || !desc->wMaxPacketSize) {
-                DEBUG("%s, bad %s maxpacket\n", __func__, _ep->name);
-                return -ERANGE;
-        }
-
-        dev = ep->dev;
-        if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN) {
-                DEBUG("%s, bogus device state\n", __func__);
-                return -ESHUTDOWN;
-        }
-
-        spin_lock_irqsave(&ep->dev->lock, flags);
-
-        ep->stopped = 0;
-        ep->desc = desc;
-        ep->pio_irqs = 0;
-        ep->ep.maxpacket = le16_to_cpu(desc->wMaxPacketSize);
-
-        spin_unlock_irqrestore(&ep->dev->lock, flags);
-
-        /* Reset halt state (does flush) */
-        lh7a40x_set_halt(_ep, 0);
-
-        DEBUG("%s: enabled %s\n", __func__, _ep->name);
-        return 0;
-}
-
-/** Disable EP
- *  NOTE: Sets INDEX register
- */
-static int lh7a40x_ep_disable(struct usb_ep *_ep)
-{
-        struct lh7a40x_ep *ep;
-        unsigned long flags;
-
-        DEBUG("%s, %p\n", __func__, _ep);
-
-        ep = container_of(_ep, struct lh7a40x_ep, ep);
-        if (!_ep || !ep->desc) {
-                DEBUG("%s, %s not enabled\n", __func__,
-                      _ep ? ep->ep.name : NULL);
-                return -EINVAL;
-        }
-
-        spin_lock_irqsave(&ep->dev->lock, flags);
-
-        usb_set_index(ep_index(ep));
-
-        /* Nuke all pending requests (does flush) */
-        nuke(ep, -ESHUTDOWN);
-
-        /* Disable ep IRQ */
-        pio_irq_disable(ep_index(ep));
-
-        ep->desc = 0;
-        ep->stopped = 1;
-
-        spin_unlock_irqrestore(&ep->dev->lock, flags);
-
-        DEBUG("%s: disabled %s\n", __func__, _ep->name);
-        return 0;
-}
-
-static struct usb_request *lh7a40x_alloc_request(struct usb_ep *ep,
-                                                 gfp_t gfp_flags)
-{
-        struct lh7a40x_request *req;
-
-        DEBUG("%s, %p\n", __func__, ep);
-
-        req = kzalloc(sizeof(*req), gfp_flags);
-        if (!req)
-                return 0;
-
-        INIT_LIST_HEAD(&req->queue);
-
-        return &req->req;
-}
-
-static void lh7a40x_free_request(struct usb_ep *ep, struct usb_request *_req)
-{
-        struct lh7a40x_request *req;
-
-        DEBUG("%s, %p\n", __func__, ep);
-
-        req = container_of(_req, struct lh7a40x_request, req);
-        WARN_ON(!list_empty(&req->queue));
-        kfree(req);
-}
-
-/** Queue one request
- *  Kickstart transfer if needed
- *  NOTE: Sets INDEX register
- */
-static int lh7a40x_queue(struct usb_ep *_ep, struct usb_request *_req,
-                         gfp_t gfp_flags)
-{
-        struct lh7a40x_request *req;
-        struct lh7a40x_ep *ep;
-        struct lh7a40x_udc *dev;
-        unsigned long flags;
-
-        DEBUG("\n\n\n%s, %p\n", __func__, _ep);
-
-        req = container_of(_req, struct lh7a40x_request, req);
-        if (unlikely
-            (!_req || !_req->complete || !_req->buf
-             || !list_empty(&req->queue))) {
-                DEBUG("%s, bad params\n", __func__);
-                return -EINVAL;
-        }
-
-        ep = container_of(_ep, struct lh7a40x_ep, ep);
-        if (unlikely(!_ep || (!ep->desc && ep->ep.name != ep0name))) {
-                DEBUG("%s, bad ep\n", __func__);
-                return -EINVAL;
-        }
-
-        dev = ep->dev;
-        if (unlikely(!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN)) {
-                DEBUG("%s, bogus device state %p\n", __func__, dev->driver);
-                return -ESHUTDOWN;
-        }
-
-        DEBUG("%s queue req %p, len %d buf %p\n", _ep->name, _req, _req->length,
-              _req->buf);
-
-        spin_lock_irqsave(&dev->lock, flags);
-
-        _req->status = -EINPROGRESS;
-        _req->actual = 0;
-
-        /* kickstart this i/o queue? */
-        DEBUG("Add to %d Q %d %d\n", ep_index(ep), list_empty(&ep->queue),
-              ep->stopped);
-        if (list_empty(&ep->queue) && likely(!ep->stopped)) {
-                u32 csr;
-
-                if (unlikely(ep_index(ep) == 0)) {
-                        /* EP0 */
-                        list_add_tail(&req->queue, &ep->queue);
-                        lh7a40x_ep0_kick(dev, ep);
-                        req = 0;
-                } else if (ep_is_in(ep)) {
-                        /* EP1 & EP3 */
-                        usb_set_index(ep_index(ep));
-                        csr = usb_read(ep->csr1);
-                        pio_irq_enable(ep_index(ep));
-                        if ((csr & USB_IN_CSR1_FIFO_NOT_EMPTY) == 0) {
-                                if (write_fifo(ep, req) == 1)
-                                        req = 0;
-                        }
-                } else {
-                        /* EP2 */
-                        usb_set_index(ep_index(ep));
-                        csr = usb_read(ep->csr1);
-                        pio_irq_enable(ep_index(ep));
-                        if (!(csr & USB_OUT_CSR1_FIFO_FULL)) {
-                                if (read_fifo(ep, req) == 1)
-                                        req = 0;
-                        }
-                }
-        }
-
-        /* pio or dma irq handler advances the queue. */
-        if (likely(req != 0))
-                list_add_tail(&req->queue, &ep->queue);
-
-        spin_unlock_irqrestore(&dev->lock, flags);
-
-        return 0;
-}
-
-/* dequeue JUST ONE request */
-static int lh7a40x_dequeue(struct usb_ep *_ep, struct usb_request *_req)
-{
-        struct lh7a40x_ep *ep;
-        struct lh7a40x_request *req;
-        unsigned long flags;
-
-        DEBUG("%s, %p\n", __func__, _ep);
-
-        ep = container_of(_ep, struct lh7a40x_ep, ep);
-        if (!_ep || ep->ep.name == ep0name)
-                return -EINVAL;
-
-        spin_lock_irqsave(&ep->dev->lock, flags);
-
-        /* make sure it's actually queued on this endpoint */
-        list_for_each_entry(req, &ep->queue, queue) {
-                if (&req->req == _req)
-                        break;
-        }
-        if (&req->req != _req) {
-                spin_unlock_irqrestore(&ep->dev->lock, flags);
-                return -EINVAL;
-        }
-
-        done(ep, req, -ECONNRESET);
-
-        spin_unlock_irqrestore(&ep->dev->lock, flags);
-        return 0;
-}
-
-/** Halt specific EP
- *  Return 0 if success
- *  NOTE: Sets INDEX register to EP !
- */
-static int lh7a40x_set_halt(struct usb_ep *_ep, int value)
-{
-        struct lh7a40x_ep *ep;
-        unsigned long flags;
-
-        ep = container_of(_ep, struct lh7a40x_ep, ep);
-        if (unlikely(!_ep || (!ep->desc && ep->ep.name != ep0name))) {
-                DEBUG("%s, bad ep\n", __func__);
-                return -EINVAL;
-        }
-
-        usb_set_index(ep_index(ep));
-
-        DEBUG("%s, ep %d, val %d\n", __func__, ep_index(ep), value);
-
-        spin_lock_irqsave(&ep->dev->lock, flags);
-
-        if (ep_index(ep) == 0) {
-                /* EP0 */
-                usb_set(EP0_SEND_STALL, ep->csr1);
-        } else if (ep_is_in(ep)) {
-                u32 csr = usb_read(ep->csr1);
-                if (value && ((csr & USB_IN_CSR1_FIFO_NOT_EMPTY)
-                              || !list_empty(&ep->queue))) {
-                        /*
-                         * Attempts to halt IN endpoints will fail (returning -EAGAIN)
-                         * if any transfer requests are still queued, or if the controller
-                         * FIFO still holds bytes that the host hasn't collected.
-                         */
-                        spin_unlock_irqrestore(&ep->dev->lock, flags);
-                        DEBUG
-                            ("Attempt to halt IN endpoint failed (returning -EAGAIN) %d %d\n",
-                             (csr & USB_IN_CSR1_FIFO_NOT_EMPTY),
-                             !list_empty(&ep->queue));
-                        return -EAGAIN;
-                }
-                flush(ep);
-                if (value)
-                        usb_set(USB_IN_CSR1_SEND_STALL, ep->csr1);
-                else {
-                        usb_clear(USB_IN_CSR1_SEND_STALL, ep->csr1);
-                        usb_set(USB_IN_CSR1_CLR_DATA_TOGGLE, ep->csr1);
-                }
-
-        } else {
-
-                flush(ep);
-                if (value)
-                        usb_set(USB_OUT_CSR1_SEND_STALL, ep->csr1);
-                else {
-                        usb_clear(USB_OUT_CSR1_SEND_STALL, ep->csr1);
-                        usb_set(USB_OUT_CSR1_CLR_DATA_REG, ep->csr1);
-                }
-        }
-
-        if (value) {
-                ep->stopped = 1;
-        } else {
-                ep->stopped = 0;
-        }
-
-        spin_unlock_irqrestore(&ep->dev->lock, flags);
-
-        DEBUG("%s %s halted\n", _ep->name, value == 0 ? "NOT" : "IS");
-
-        return 0;
-}
-
-/** Return bytes in EP FIFO
- *  NOTE: Sets INDEX register to EP
- */
-static int lh7a40x_fifo_status(struct usb_ep *_ep)
-{
-        u32 csr;
-        int count = 0;
-        struct lh7a40x_ep *ep;
-
-        ep = container_of(_ep, struct lh7a40x_ep, ep);
-        if (!_ep) {
-                DEBUG("%s, bad ep\n", __func__);
-                return -ENODEV;
-        }
-
-        DEBUG("%s, %d\n", __func__, ep_index(ep));
-
-        /* LPD can't report unclaimed bytes from IN fifos */
-        if (ep_is_in(ep))
-                return -EOPNOTSUPP;
-
-        usb_set_index(ep_index(ep));
-
-        csr = usb_read(ep->csr1);
-        if (ep->dev->gadget.speed != USB_SPEED_UNKNOWN ||
-            csr & USB_OUT_CSR1_OUT_PKT_RDY) {
-                count = usb_read(USB_OUT_FIFO_WC1);
-        }
-
-        return count;
-}
-
-/** Flush EP FIFO
- *  NOTE: Sets INDEX register to EP
- */
-static void lh7a40x_fifo_flush(struct usb_ep *_ep)
-{
-        struct lh7a40x_ep *ep;
-
-        ep = container_of(_ep, struct lh7a40x_ep, ep);
-        if (unlikely(!_ep || (!ep->desc && ep->ep.name != ep0name))) {
-                DEBUG("%s, bad ep\n", __func__);
-                return;
-        }
-
-        usb_set_index(ep_index(ep));
-        flush(ep);
-}
-
-/****************************************************************/
-/* End Point 0 related functions                                */
-/****************************************************************/
-
-/* return:  0 = still running, 1 = completed, negative = errno */
-static int write_fifo_ep0(struct lh7a40x_ep *ep, struct lh7a40x_request *req)
-{
-        u32 max;
-        unsigned count;
-        int is_last;
-
-        max = ep_maxpacket(ep);
-
-        DEBUG_EP0("%s\n", __func__);
-
-        count = write_packet(ep, req, max);
-
-        /* last packet is usually short (or a zlp) */
-        if (unlikely(count != max))
-                is_last = 1;
-        else {
-                if (likely(req->req.length != req->req.actual) || req->req.zero)
-                        is_last = 0;
-                else
-                        is_last = 1;
-        }
-
-        DEBUG_EP0("%s: wrote %s %d bytes%s %d left %p\n", __func__,
-                  ep->ep.name, count,
-                  is_last ? "/L" : "", req->req.length - req->req.actual, req);
-
-        /* requests complete when all IN data is in the FIFO */
-        if (is_last) {
-                done(ep, req, 0);
-                return 1;
-        }
-
-        return 0;
-}
-
-static __inline__ int lh7a40x_fifo_read(struct lh7a40x_ep *ep,
-                                        unsigned char *cp, int max)
-{
-        int bytes;
-        int count = usb_read(USB_OUT_FIFO_WC1);
-        volatile u32 *fifo = (volatile u32 *)ep->fifo;
-
-        if (count > max)
-                count = max;
-        bytes = count;
-        while (count--)
-                *cp++ = *fifo & 0xFF;
-        return bytes;
-}
-
-static __inline__ void lh7a40x_fifo_write(struct lh7a40x_ep *ep,
-                                          unsigned char *cp, int count)
-{
-        volatile u32 *fifo = (volatile u32 *)ep->fifo;
-        DEBUG_EP0("fifo_write: %d %d\n", ep_index(ep), count);
-        while (count--)
-                *fifo = *cp++;
-}
-
-static int read_fifo_ep0(struct lh7a40x_ep *ep, struct lh7a40x_request *req)
-{
-        u32 csr;
-        u8 *buf;
-        unsigned bufferspace, count, is_short;
-        volatile u32 *fifo = (volatile u32 *)ep->fifo;
-
-        DEBUG_EP0("%s\n", __func__);
-
-        csr = usb_read(USB_EP0_CSR);
-        if (!(csr & USB_OUT_CSR1_OUT_PKT_RDY))
-                return 0;
-
-        buf = req->req.buf + req->req.actual;
-        prefetchw(buf);
-        bufferspace = req->req.length - req->req.actual;
-
-        /* read all bytes from this packet */
-        if (likely(csr & EP0_OUT_PKT_RDY)) {
-                count = usb_read(USB_OUT_FIFO_WC1);
-                req->req.actual += min(count, bufferspace);
-        } else                  /* zlp */
-                count = 0;
-
-        is_short = (count < ep->ep.maxpacket);
-        DEBUG_EP0("read %s %02x, %d bytes%s req %p %d/%d\n",
-                  ep->ep.name, csr, count,
-                  is_short ? "/S" : "", req, req->req.actual, req->req.length);
-
-        while (likely(count-- != 0)) {
-                u8 byte = (u8) (*fifo & 0xff);
-
-                if (unlikely(bufferspace == 0)) {
-                        /* this happens when the driver's buffer
-                         * is smaller than what the host sent.
-                         * discard the extra data.
-                         */
-                        if (req->req.status != -EOVERFLOW)
-                                DEBUG_EP0("%s overflow %d\n", ep->ep.name,
-                                          count);
-                        req->req.status = -EOVERFLOW;
-                } else {
-                        *buf++ = byte;
-                        bufferspace--;
-                }
-        }
-
-        /* completion */
-        if (is_short || req->req.actual == req->req.length) {
-                done(ep, req, 0);
-                return 1;
-        }
-
-        /* finished that packet.  the next one may be waiting... */
-        return 0;
-}
-
-/**
- * udc_set_address - set the USB address for this device
- * @address:
- *
- * Called from control endpoint function after it decodes a set address setup packet.
- */
-static void udc_set_address(struct lh7a40x_udc *dev, unsigned char address)
-{
-        DEBUG_EP0("%s: %d\n", __func__, address);
-        /* c.f. 15.1.2.2 Table 15-4 address will be used after DATA_END is set */
-        dev->usb_address = address;
-        usb_set((address & USB_FA_FUNCTION_ADDR), USB_FA);
-        usb_set(USB_FA_ADDR_UPDATE | (address & USB_FA_FUNCTION_ADDR), USB_FA);
-        /* usb_read(USB_FA); */
-}
-
-/*
- * DATA_STATE_RECV (OUT_PKT_RDY)
- *      - if error
- *              set EP0_CLR_OUT | EP0_DATA_END | EP0_SEND_STALL bits
- *      - else
- *              set EP0_CLR_OUT bit
-                                if last set EP0_DATA_END bit
- */
-static void lh7a40x_ep0_out(struct lh7a40x_udc *dev, u32 csr)
-{
-        struct lh7a40x_request *req;
-        struct lh7a40x_ep *ep = &dev->ep[0];
-        int ret;
-
-        DEBUG_EP0("%s: %x\n", __func__, csr);
-
-        if (list_empty(&ep->queue))
-                req = 0;
-        else
-                req = list_entry(ep->queue.next, struct lh7a40x_request, queue);
-
-        if (req) {
-
-                if (req->req.length == 0) {
-                        DEBUG_EP0("ZERO LENGTH OUT!\n");
-                        usb_set((EP0_CLR_OUT | EP0_DATA_END), USB_EP0_CSR);
-                        dev->ep0state = WAIT_FOR_SETUP;
-                        return;
-                }
-                ret = read_fifo_ep0(ep, req);
-                if (ret) {
-                        /* Done! */
-                        DEBUG_EP0("%s: finished, waiting for status\n",
-                                  __func__);
-
-                        usb_set((EP0_CLR_OUT | EP0_DATA_END), USB_EP0_CSR);
-                        dev->ep0state = WAIT_FOR_SETUP;
-                } else {
-                        /* Not done yet.. */
-                        DEBUG_EP0("%s: not finished\n", __func__);
-                        usb_set(EP0_CLR_OUT, USB_EP0_CSR);
-                }
-        } else {
-                DEBUG_EP0("NO REQ??!\n");
-        }
-}
-
-/*
- * DATA_STATE_XMIT
- */
-static int lh7a40x_ep0_in(struct lh7a40x_udc *dev, u32 csr)
-{
-        struct lh7a40x_request *req;
-        struct lh7a40x_ep *ep = &dev->ep[0];
-        int ret, need_zlp = 0;
-
-        DEBUG_EP0("%s: %x\n", __func__, csr);
-
-        if (list_empty(&ep->queue))
-                req = 0;
-        else
-                req = list_entry(ep->queue.next, struct lh7a40x_request, queue);
-
-        if (!req) {
-                DEBUG_EP0("%s: NULL REQ\n", __func__);
-                return 0;
-        }
-
-        if (req->req.length == 0) {
-
-                usb_set((EP0_IN_PKT_RDY | EP0_DATA_END), USB_EP0_CSR);
-                dev->ep0state = WAIT_FOR_SETUP;
-                return 1;
-        }
-
-        if (req->req.length - req->req.actual == EP0_PACKETSIZE) {
-                /* Next write will end with the packet size, */
-                /* so we need Zero-length-packet */
-                need_zlp = 1;
-        }
-
-        ret = write_fifo_ep0(ep, req);
-
-        if (ret == 1 && !need_zlp) {
-                /* Last packet */
-                DEBUG_EP0("%s: finished, waiting for status\n", __func__);
-
-                usb_set((EP0_IN_PKT_RDY | EP0_DATA_END), USB_EP0_CSR);
-                dev->ep0state = WAIT_FOR_SETUP;
-        } else {
-                DEBUG_EP0("%s: not finished\n", __func__);
-                usb_set(EP0_IN_PKT_RDY, USB_EP0_CSR);
-        }
-
-        if (need_zlp) {
-                DEBUG_EP0("%s: Need ZLP!\n", __func__);
-                usb_set(EP0_IN_PKT_RDY, USB_EP0_CSR);
-                dev->ep0state = DATA_STATE_NEED_ZLP;
-        }
-
-        return 1;
-}
-
-static int lh7a40x_handle_get_status(struct lh7a40x_udc *dev,
-                                     struct usb_ctrlrequest *ctrl)
-{
-        struct lh7a40x_ep *ep0 = &dev->ep[0];
-        struct lh7a40x_ep *qep;
-        int reqtype = (ctrl->bRequestType & USB_RECIP_MASK);
-        u16 val = 0;
-
-        if (reqtype == USB_RECIP_INTERFACE) {
-                /* This is not supported.
-                 * And according to the USB spec, this one does nothing..
-                 * Just return 0
-                 */
-                DEBUG_SETUP("GET_STATUS: USB_RECIP_INTERFACE\n");
-        } else if (reqtype == USB_RECIP_DEVICE) {
-                DEBUG_SETUP("GET_STATUS: USB_RECIP_DEVICE\n");
-                val |= (1 << 0);        /* Self powered */
-                /*val |= (1<<1); *//* Remote wakeup */
-        } else if (reqtype == USB_RECIP_ENDPOINT) {
-                int ep_num = (ctrl->wIndex & ~USB_DIR_IN);
-
-                DEBUG_SETUP
-                    ("GET_STATUS: USB_RECIP_ENDPOINT (%d), ctrl->wLength = %d\n",
-                     ep_num, ctrl->wLength);
-
-                if (ctrl->wLength > 2 || ep_num > 3)
-                        return -EOPNOTSUPP;
-
-                qep = &dev->ep[ep_num];
-                if (ep_is_in(qep) != ((ctrl->wIndex & USB_DIR_IN) ? 1 : 0)
-                    && ep_index(qep) != 0) {
-                        return -EOPNOTSUPP;
-                }
-
-                usb_set_index(ep_index(qep));
-
-                /* Return status on next IN token */
-                switch (qep->ep_type) {
-                case ep_control:
-                        val =
-                            (usb_read(qep->csr1) & EP0_SEND_STALL) ==
-                            EP0_SEND_STALL;
-                        break;
-                case ep_bulk_in:
-                case ep_interrupt:
-                        val =
-                            (usb_read(qep->csr1) & USB_IN_CSR1_SEND_STALL) ==
-                            USB_IN_CSR1_SEND_STALL;
-                        break;
-                case ep_bulk_out:
-                        val =
-                            (usb_read(qep->csr1) & USB_OUT_CSR1_SEND_STALL) ==
-                            USB_OUT_CSR1_SEND_STALL;
-                        break;
-                }
-
-                /* Back to EP0 index */
-                usb_set_index(0);
-
-                DEBUG_SETUP("GET_STATUS, ep: %d (%x), val = %d\n", ep_num,
-                            ctrl->wIndex, val);
-        } else {
-                DEBUG_SETUP("Unknown REQ TYPE: %d\n", reqtype);
-                return -EOPNOTSUPP;
-        }
-
-        /* Clear "out packet ready" */
-        usb_set((EP0_CLR_OUT), USB_EP0_CSR);
-        /* Put status to FIFO */
-        lh7a40x_fifo_write(ep0, (u8 *) & val, sizeof(val));
-        /* Issue "In packet ready" */
-        usb_set((EP0_IN_PKT_RDY | EP0_DATA_END), USB_EP0_CSR);
-
-        return 0;
-}
-
-/*
- * WAIT_FOR_SETUP (OUT_PKT_RDY)
- *      - read data packet from EP0 FIFO
- *      - decode command
- *      - if error
- *              set EP0_CLR_OUT | EP0_DATA_END | EP0_SEND_STALL bits
- *      - else
- *              set EP0_CLR_OUT | EP0_DATA_END bits
- */
-static void lh7a40x_ep0_setup(struct lh7a40x_udc *dev, u32 csr)
-{
-        struct lh7a40x_ep *ep = &dev->ep[0];
-        struct usb_ctrlrequest ctrl;
-        int i, bytes, is_in;
-
-        DEBUG_SETUP("%s: %x\n", __func__, csr);
-
-        /* Nuke all previous transfers */
-        nuke(ep, -EPROTO);
-
-        /* read control req from fifo (8 bytes) */
-        bytes = lh7a40x_fifo_read(ep, (unsigned char *)&ctrl, 8);
-
-        DEBUG_SETUP("Read CTRL REQ %d bytes\n", bytes);
-        DEBUG_SETUP("CTRL.bRequestType = %d (is_in %d)\n", ctrl.bRequestType,
-                    ctrl.bRequestType == USB_DIR_IN);
-        DEBUG_SETUP("CTRL.bRequest = %d\n", ctrl.bRequest);
-        DEBUG_SETUP("CTRL.wLength = %d\n", ctrl.wLength);
-        DEBUG_SETUP("CTRL.wValue = %d (%d)\n", ctrl.wValue, ctrl.wValue >> 8);
-        DEBUG_SETUP("CTRL.wIndex = %d\n", ctrl.wIndex);
-
-        /* Set direction of EP0 */
-        if (likely(ctrl.bRequestType & USB_DIR_IN)) {
-                ep->bEndpointAddress |= USB_DIR_IN;
-                is_in = 1;
-        } else {
-                ep->bEndpointAddress &= ~USB_DIR_IN;
-                is_in = 0;
-        }
-
-        dev->req_pending = 1;
-
-        /* Handle some SETUP packets ourselves */
-        switch (ctrl.bRequest) {
-        case USB_REQ_SET_ADDRESS:
-                if (ctrl.bRequestType != (USB_TYPE_STANDARD | USB_RECIP_DEVICE))
-                        break;
-
-                DEBUG_SETUP("USB_REQ_SET_ADDRESS (%d)\n", ctrl.wValue);
-                udc_set_address(dev, ctrl.wValue);
-                usb_set((EP0_CLR_OUT | EP0_DATA_END), USB_EP0_CSR);
-                return;
-
-        case USB_REQ_GET_STATUS:{
-                        if (lh7a40x_handle_get_status(dev, &ctrl) == 0)
-                                return;
-
-        case USB_REQ_CLEAR_FEATURE:
-        case USB_REQ_SET_FEATURE:
-                        if (ctrl.bRequestType == USB_RECIP_ENDPOINT) {
-                                struct lh7a40x_ep *qep;
-                                int ep_num = (ctrl.wIndex & 0x0f);
-
-                                /* Support only HALT feature */
-                                if (ctrl.wValue != 0 || ctrl.wLength != 0
-                                    || ep_num > 3 || ep_num < 1)
-                                        break;
-
-                                qep = &dev->ep[ep_num];
-                                spin_unlock(&dev->lock);
-                                if (ctrl.bRequest == USB_REQ_SET_FEATURE) {
-                                        DEBUG_SETUP("SET_FEATURE (%d)\n",
-                                                    ep_num);
-                                        lh7a40x_set_halt(&qep->ep, 1);
-                                } else {
-                                        DEBUG_SETUP("CLR_FEATURE (%d)\n",
-                                                    ep_num);
-                                        lh7a40x_set_halt(&qep->ep, 0);
-                                }
-                                spin_lock(&dev->lock);
-                                usb_set_index(0);
-
-                                /* Reply with a ZLP on next IN token */
-                                usb_set((EP0_CLR_OUT | EP0_DATA_END),
-                                        USB_EP0_CSR);
-                                return;
-                        }
-                        break;
-                }
-
-        default:
-                break;
-        }
-
-        if (likely(dev->driver)) {
-                /* device-2-host (IN) or no data setup command, process immediately */
-                spin_unlock(&dev->lock);
-                i = dev->driver->setup(&dev->gadget, &ctrl);
-                spin_lock(&dev->lock);
-
-                if (i < 0) {
-                        /* setup processing failed, force stall */
-                        DEBUG_SETUP
-                            ("  --> ERROR: gadget setup FAILED (stalling), setup returned %d\n",
-                             i);
-                        usb_set_index(0);
-                        usb_set((EP0_CLR_OUT | EP0_DATA_END | EP0_SEND_STALL),
-                                USB_EP0_CSR);
-
-                        /* ep->stopped = 1; */
-                        dev->ep0state = WAIT_FOR_SETUP;
-                }
-        }
-}
-
-/*
- * DATA_STATE_NEED_ZLP
- */
-static void lh7a40x_ep0_in_zlp(struct lh7a40x_udc *dev, u32 csr)
-{
-        DEBUG_EP0("%s: %x\n", __func__, csr);
-
-        /* c.f. Table 15-14 */
-        usb_set((EP0_IN_PKT_RDY | EP0_DATA_END), USB_EP0_CSR);
-        dev->ep0state = WAIT_FOR_SETUP;
-}
-
-/*
- * handle ep0 interrupt
- */
-static void lh7a40x_handle_ep0(struct lh7a40x_udc *dev, u32 intr)
-{
-        struct lh7a40x_ep *ep = &dev->ep[0];
-        u32 csr;
-
-        /* Set index 0 */
-        usb_set_index(0);
-        csr = usb_read(USB_EP0_CSR);
-
-        DEBUG_EP0("%s: csr = %x\n", __func__, csr);
-
-        /*
-         * For overview of what we should be doing see c.f. Chapter 18.1.2.4
-         * We will follow that outline here modified by our own global state
-         * indication which provides hints as to what we think should be
-         * happening..
-         */
-
-        /*
-         * if SENT_STALL is set
-         *      - clear the SENT_STALL bit
-         */
-        if (csr & EP0_SENT_STALL) {
-                DEBUG_EP0("%s: EP0_SENT_STALL is set: %x\n", __func__, csr);
-                usb_clear((EP0_SENT_STALL | EP0_SEND_STALL), USB_EP0_CSR);
-                nuke(ep, -ECONNABORTED);
-                dev->ep0state = WAIT_FOR_SETUP;
-                return;
-        }
-
-        /*
-         * if a transfer is in progress && IN_PKT_RDY and OUT_PKT_RDY are clear
-         *      - fill EP0 FIFO
-         *      - if last packet
-         *      -       set IN_PKT_RDY | DATA_END
-         *      - else
-         *              set IN_PKT_RDY
-         */
-        if (!(csr & (EP0_IN_PKT_RDY | EP0_OUT_PKT_RDY))) {
-                DEBUG_EP0("%s: IN_PKT_RDY and OUT_PKT_RDY are clear\n",
-                          __func__);
-
-                switch (dev->ep0state) {
-                case DATA_STATE_XMIT:
-                        DEBUG_EP0("continue with DATA_STATE_XMIT\n");
-                        lh7a40x_ep0_in(dev, csr);
-                        return;
-                case DATA_STATE_NEED_ZLP:
-                        DEBUG_EP0("continue with DATA_STATE_NEED_ZLP\n");
-                        lh7a40x_ep0_in_zlp(dev, csr);
-                        return;
-                default:
-                        /* Stall? */
-                        DEBUG_EP0("Odd state!! state = %s\n",
-                                  state_names[dev->ep0state]);
-                        dev->ep0state = WAIT_FOR_SETUP;
-                        /* nuke(ep, 0); */
-                        /* usb_set(EP0_SEND_STALL, ep->csr1); */
-                        break;
-                }
-        }
-
-        /*
-         * if SETUP_END is set
-         *      - abort the last transfer
-         *      - set SERVICED_SETUP_END_BIT
-         */
-        if (csr & EP0_SETUP_END) {
-                DEBUG_EP0("%s: EP0_SETUP_END is set: %x\n", __func__, csr);
-
-                usb_set(EP0_CLR_SETUP_END, USB_EP0_CSR);
-
-                nuke(ep, 0);
-                dev->ep0state = WAIT_FOR_SETUP;
-        }
-
-        /*
-         * if EP0_OUT_PKT_RDY is set
-         *      - read data packet from EP0 FIFO
-         *      - decode command
-         *      - if error
-         *              set SERVICED_OUT_PKT_RDY | DATA_END bits | SEND_STALL
-         *      - else
-         *              set SERVICED_OUT_PKT_RDY | DATA_END bits
-         */
-        if (csr & EP0_OUT_PKT_RDY) {
-
-                DEBUG_EP0("%s: EP0_OUT_PKT_RDY is set: %x\n", __func__,
-                          csr);
-
-                switch (dev->ep0state) {
-                case WAIT_FOR_SETUP:
-                        DEBUG_EP0("WAIT_FOR_SETUP\n");
-                        lh7a40x_ep0_setup(dev, csr);
-                        break;
-
-                case DATA_STATE_RECV:
-                        DEBUG_EP0("DATA_STATE_RECV\n");
-                        lh7a40x_ep0_out(dev, csr);
-                        break;
-
-                default:
-                        /* send stall? */
-                        DEBUG_EP0("strange state!! 2. send stall? state = %d\n",
-                                  dev->ep0state);
-                        break;
-                }
-        }
-}
-
-static void lh7a40x_ep0_kick(struct lh7a40x_udc *dev, struct lh7a40x_ep *ep)
-{
-        u32 csr;
-
-        usb_set_index(0);
-        csr = usb_read(USB_EP0_CSR);
-
-        DEBUG_EP0("%s: %x\n", __func__, csr);
-
-        /* Clear "out packet ready" */
-        usb_set(EP0_CLR_OUT, USB_EP0_CSR);
-
-        if (ep_is_in(ep)) {
-                dev->ep0state = DATA_STATE_XMIT;
-                lh7a40x_ep0_in(dev, csr);
-        } else {
-                dev->ep0state = DATA_STATE_RECV;
-                lh7a40x_ep0_out(dev, csr);
-        }
-}
-
-/* ---------------------------------------------------------------------------
- *      device-scoped parts of the api to the usb controller hardware
- * ---------------------------------------------------------------------------
- */
-
-static int lh7a40x_udc_get_frame(struct usb_gadget *_gadget)
-{
-        u32 frame1 = usb_read(USB_FRM_NUM1);    /* Least significant 8 bits */
-        u32 frame2 = usb_read(USB_FRM_NUM2);    /* Most significant 3 bits */
-        DEBUG("%s, %p\n", __func__, _gadget);
-        return ((frame2 & 0x07) << 8) | (frame1 & 0xff);
-}
-
-static int lh7a40x_udc_wakeup(struct usb_gadget *_gadget)
-{
-        /* host may not have enabled remote wakeup */
-        /*if ((UDCCS0 & UDCCS0_DRWF) == 0)
-           return -EHOSTUNREACH;
-           udc_set_mask_UDCCR(UDCCR_RSM); */
-        return -ENOTSUPP;
-}
-
-static const struct usb_gadget_ops lh7a40x_udc_ops = {
-        .get_frame = lh7a40x_udc_get_frame,
-        .wakeup = lh7a40x_udc_wakeup,
-        /* current versions must always be self-powered */
-};
-
-static void nop_release(struct device *dev)
-{
-        DEBUG("%s %s\n", __func__, dev_name(dev));
-}
-
-static struct lh7a40x_udc memory = {
-        .usb_address = 0,
-
-        .gadget = {
-                   .ops = &lh7a40x_udc_ops,
-                   .ep0 = &memory.ep[0].ep,
-                   .name = driver_name,
-                   .dev = {
-                           .init_name = "gadget",
-                           .release = nop_release,
-                           },
-                   },
-
-        /* control endpoint */
-        .ep[0] = {
-                  .ep = {
-                         .name = ep0name,
-                         .ops = &lh7a40x_ep_ops,
-                         .maxpacket = EP0_PACKETSIZE,
-                         },
-                  .dev = &memory,
-
-                  .bEndpointAddress = 0,
-                  .bmAttributes = 0,
-
-                  .ep_type = ep_control,
-                  .fifo = io_p2v(USB_EP0_FIFO),
-                  .csr1 = USB_EP0_CSR,
-                  .csr2 = USB_EP0_CSR,
-                  },
-
-        /* first group of endpoints */
-        .ep[1] = {
-                  .ep = {
-                         .name = "ep1in-bulk",
-                         .ops = &lh7a40x_ep_ops,
-                         .maxpacket = 64,
-                         },
-                  .dev = &memory,
-
-                  .bEndpointAddress = USB_DIR_IN | 1,
-                  .bmAttributes = USB_ENDPOINT_XFER_BULK,
-
-                  .ep_type = ep_bulk_in,
-                  .fifo = io_p2v(USB_EP1_FIFO),
-                  .csr1 = USB_IN_CSR1,
-                  .csr2 = USB_IN_CSR2,
-                  },
-
-        .ep[2] = {
-                  .ep = {
-                         .name = "ep2out-bulk",
-                         .ops = &lh7a40x_ep_ops,
-                         .maxpacket = 64,
-                         },
-                  .dev = &memory,
-
-                  .bEndpointAddress = 2,
-                  .bmAttributes = USB_ENDPOINT_XFER_BULK,
-
-                  .ep_type = ep_bulk_out,
-                  .fifo = io_p2v(USB_EP2_FIFO),
-                  .csr1 = USB_OUT_CSR1,
-                  .csr2 = USB_OUT_CSR2,
-                  },
-
-        .ep[3] = {
-                  .ep = {
-                         .name = "ep3in-int",
-                         .ops = &lh7a40x_ep_ops,
-                         .maxpacket = 64,
-                         },
-                  .dev = &memory,
-
-                  .bEndpointAddress = USB_DIR_IN | 3,
-                  .bmAttributes = USB_ENDPOINT_XFER_INT,
-
-                  .ep_type = ep_interrupt,
-                  .fifo = io_p2v(USB_EP3_FIFO),
-                  .csr1 = USB_IN_CSR1,
-                  .csr2 = USB_IN_CSR2,
-                  },
-};
-
-/*
- *      probe - binds to the platform device
- */
-static int lh7a40x_udc_probe(struct platform_device *pdev)
-{
-        struct lh7a40x_udc *dev = &memory;
-        int retval;
-
-        DEBUG("%s: %p\n", __func__, pdev);
-
-        spin_lock_init(&dev->lock);
-        dev->dev = &pdev->dev;
-
-        device_initialize(&dev->gadget.dev);
-        dev->gadget.dev.parent = &pdev->dev;
-
-        the_controller = dev;
-        platform_set_drvdata(pdev, dev);
-
-        udc_disable(dev);
-        udc_reinit(dev);
-
-        /* irq setup after old hardware state is cleaned up */
-        retval =
-            request_irq(IRQ_USBINTR, lh7a40x_udc_irq, IRQF_DISABLED, driver_name,
-                        dev);
-        if (retval != 0) {
-                DEBUG(KERN_ERR "%s: can't get irq %i, err %d\n", driver_name,
-                      IRQ_USBINTR, retval);
-                return -EBUSY;
-        }
-
-        create_proc_files();
-
-        return retval;
-}
-
-static int lh7a40x_udc_remove(struct platform_device *pdev)
-{
-        struct lh7a40x_udc *dev = platform_get_drvdata(pdev);
-
-        DEBUG("%s: %p\n", __func__, pdev);
-
-        if (dev->driver)
-                return -EBUSY;
-
-        udc_disable(dev);
-        remove_proc_files();
-
-        free_irq(IRQ_USBINTR, dev);
-
-        platform_set_drvdata(pdev, 0);
-
-        the_controller = 0;
-
-        return 0;
-}
-
-/*-------------------------------------------------------------------------*/
-
-static struct platform_driver udc_driver = {
-        .probe = lh7a40x_udc_probe,
-        .remove = lh7a40x_udc_remove,
-            /* FIXME power management support */
-            /* .suspend = ... disable UDC */
-            /* .resume = ... re-enable UDC */
-        .driver = {
-                .name = (char *)driver_name,
-                .owner = THIS_MODULE,
-        },
-};
-
-static int __init udc_init(void)
-{
-        DEBUG("%s: %s version %s\n", __func__, driver_name, DRIVER_VERSION);
-        return platform_driver_register(&udc_driver);
-}
-
-static void __exit udc_exit(void)
-{
-        platform_driver_unregister(&udc_driver);
-}
-
-module_init(udc_init);
-module_exit(udc_exit);
-
-MODULE_DESCRIPTION(DRIVER_DESC);
-MODULE_AUTHOR("Mikko Lahteenmaki, Bo Henriksen");
-MODULE_LICENSE("GPL");
-MODULE_ALIAS("platform:lh7a40x_udc");
diff --git a/drivers/usb/gadget/lh7a40x_udc.h b/drivers/usb/gadget/lh7a40x_udc.h
deleted file mode 100644
index ca861203a301..000000000000
--- a/drivers/usb/gadget/lh7a40x_udc.h
+++ /dev/null
@@ -1,259 +0,0 @@
-/*
- * linux/drivers/usb/gadget/lh7a40x_udc.h
- * Sharp LH7A40x on-chip full speed USB device controllers
- *
- * Copyright (C) 2004 Mikko Lahteenmaki, Nordic ID
- * Copyright (C) 2004 Bo Henriksen, Nordic ID
- *
- * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- *
- */
-
-#ifndef __LH7A40X_H_
-#define __LH7A40X_H_
-
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/ioport.h>
-#include <linux/types.h>
-#include <linux/errno.h>
-#include <linux/delay.h>
-#include <linux/sched.h>
-#include <linux/slab.h>
-#include <linux/init.h>
-#include <linux/timer.h>
-#include <linux/list.h>
-#include <linux/interrupt.h>
-#include <linux/proc_fs.h>
-#include <linux/mm.h>
-#include <linux/device.h>
-#include <linux/dma-mapping.h>
-
-#include <asm/byteorder.h>
-#include <asm/dma.h>
-#include <asm/io.h>
-#include <asm/irq.h>
-#include <asm/system.h>
-#include <asm/unaligned.h>
-#include <mach/hardware.h>
-
-#include <linux/usb/ch9.h>
-#include <linux/usb/gadget.h>
-
-/*
- * Memory map
- */
-
-#define USB_FA                                  0x80000200      // function address register
-#define USB_PM                                  0x80000204      // power management register
-
-#define USB_IN_INT                              0x80000208      // IN interrupt register bank (EP0-EP3)
-#define USB_OUT_INT                             0x80000210      // OUT interrupt register bank (EP2)
-#define USB_INT                                 0x80000218      // interrupt register bank
-
-#define USB_IN_INT_EN                   0x8000021C      // IN interrupt enable register bank
-#define USB_OUT_INT_EN                  0x80000224      // OUT interrupt enable register bank
-#define USB_INT_EN                              0x8000022C      // USB interrupt enable register bank
-
-#define USB_FRM_NUM1                    0x80000230      // Frame number1 register
-#define USB_FRM_NUM2                    0x80000234      // Frame number2 register
-#define USB_INDEX                               0x80000238      // index register
-
-#define USB_IN_MAXP                             0x80000240      // IN MAXP register
-#define USB_IN_CSR1                             0x80000244      // IN CSR1 register/EP0 CSR register
-#define USB_EP0_CSR                             0x80000244      // IN CSR1 register/EP0 CSR register
-#define USB_IN_CSR2                             0x80000248      // IN CSR2 register
-#define USB_OUT_MAXP                    0x8000024C      // OUT MAXP register
-
-#define USB_OUT_CSR1                    0x80000250      // OUT CSR1 register
-#define USB_OUT_CSR2                    0x80000254      // OUT CSR2 register
-#define USB_OUT_FIFO_WC1                0x80000258      // OUT FIFO write count1 register
-#define USB_OUT_FIFO_WC2                0x8000025C      // OUT FIFO write count2 register
-
-#define USB_RESET                               0x8000044C      // USB reset register
-
-#define USB_EP0_FIFO                    0x80000280
-#define USB_EP1_FIFO                    0x80000284
-#define USB_EP2_FIFO                    0x80000288
-#define USB_EP3_FIFO                    0x8000028c
-
-/*
- * USB reset register
- */
-#define USB_RESET_APB                   (1<<1)  //resets USB APB control side WRITE
-#define USB_RESET_IO                    (1<<0)  //resets USB IO side WRITE
-
-/*
- * USB function address register
- */
-#define USB_FA_ADDR_UPDATE              (1<<7)
-#define USB_FA_FUNCTION_ADDR    (0x7F)
-
-/*
- * Power Management register
- */
-#define PM_USB_DCP                              (1<<5)
-#define PM_USB_ENABLE                   (1<<4)
-#define PM_USB_RESET                    (1<<3)
-#define PM_UC_RESUME                    (1<<2)
-#define PM_SUSPEND_MODE                 (1<<1)
-#define PM_ENABLE_SUSPEND               (1<<0)
-
-/*
- * IN interrupt register
- */
-#define USB_IN_INT_EP3                          (1<<3)
-#define USB_IN_INT_EP1                          (1<<1)
-#define USB_IN_INT_EP0                          (1<<0)
-
-/*
- * OUT interrupt register
- */
-#define USB_OUT_INT_EP2                         (1<<2)
-
-/*
- * USB interrupt register
- */
-#define USB_INT_RESET_INT                       (1<<2)
-#define USB_INT_RESUME_INT                      (1<<1)
-#define USB_INT_SUSPEND_INT                     (1<<0)
-
-/*
- * USB interrupt enable register
- */
-#define USB_INT_EN_USB_RESET_INTER              (1<<2)
-#define USB_INT_EN_RESUME_INTER                 (1<<1)
-#define USB_INT_EN_SUSPEND_INTER                (1<<0)
-
-/*
- * INCSR1 register
- */
-#define USB_IN_CSR1_CLR_DATA_TOGGLE             (1<<6)
-#define USB_IN_CSR1_SENT_STALL                  (1<<5)
-#define USB_IN_CSR1_SEND_STALL                  (1<<4)
-#define USB_IN_CSR1_FIFO_FLUSH                  (1<<3)
-#define USB_IN_CSR1_FIFO_NOT_EMPTY              (1<<1)
-#define USB_IN_CSR1_IN_PKT_RDY                  (1<<0)
-
-/*
- * INCSR2 register
- */
-#define USB_IN_CSR2_AUTO_SET                    (1<<7)
-#define USB_IN_CSR2_USB_DMA_EN                  (1<<4)
-
-/*
- * OUT CSR1 register
- */
-#define USB_OUT_CSR1_CLR_DATA_REG               (1<<7)
-#define USB_OUT_CSR1_SENT_STALL                 (1<<6)
-#define USB_OUT_CSR1_SEND_STALL                 (1<<5)
-#define USB_OUT_CSR1_FIFO_FLUSH                 (1<<4)
-#define USB_OUT_CSR1_FIFO_FULL                  (1<<1)
-#define USB_OUT_CSR1_OUT_PKT_RDY                (1<<0)
-
-/*
- * OUT CSR2 register
- */
-#define USB_OUT_CSR2_AUTO_CLR                   (1<<7)
-#define USB_OUT_CSR2_USB_DMA_EN                 (1<<4)
-
-/*
- * EP0 CSR
- */
-#define EP0_CLR_SETUP_END               (1<<7)  /* Clear "Setup Ends" Bit (w) */
-#define EP0_CLR_OUT                             (1<<6)  /* Clear "Out packet ready" Bit (w) */
-#define EP0_SEND_STALL                  (1<<5)  /* Send STALL Handshake (rw) */
-#define EP0_SETUP_END                   (1<<4)  /* Setup Ends (r) */
-
-#define EP0_DATA_END                    (1<<3)  /* Data end (rw) */
-#define EP0_SENT_STALL                  (1<<2)  /* Sent Stall Handshake (r) */
-#define EP0_IN_PKT_RDY                  (1<<1)  /* In packet ready (rw) */
-#define EP0_OUT_PKT_RDY                 (1<<0)  /* Out packet ready (r) */
-
-/* general CSR */
-#define OUT_PKT_RDY             (1<<0)
-#define IN_PKT_RDY              (1<<0)
-
-/*
- * IN/OUT MAXP register
- */
-#define USB_OUT_MAXP_MAXP                       (0xF)
-#define USB_IN_MAXP_MAXP                        (0xF)
-
-// Max packet size
-//#define EP0_PACKETSIZE        0x10
-#define EP0_PACKETSIZE          0x8
-#define EP0_MAXPACKETSIZE       0x10
-
-#define UDC_MAX_ENDPOINTS       4
-
-#define WAIT_FOR_SETUP          0
-#define DATA_STATE_XMIT         1
-#define DATA_STATE_NEED_ZLP     2
-#define WAIT_FOR_OUT_STATUS     3
-#define DATA_STATE_RECV         4
-
-/* ********************************************************************************************* */
-/* IO
- */
-
-typedef enum ep_type {
-        ep_control, ep_bulk_in, ep_bulk_out, ep_interrupt
-} ep_type_t;
-
-struct lh7a40x_ep {
-        struct usb_ep ep;
-        struct lh7a40x_udc *dev;
-
-        const struct usb_endpoint_descriptor *desc;
-        struct list_head queue;
-        unsigned long pio_irqs;
-
-        u8 stopped;
-        u8 bEndpointAddress;
-        u8 bmAttributes;
-
-        ep_type_t ep_type;
-        u32 fifo;
-        u32 csr1;
-        u32 csr2;
-};
-
-struct lh7a40x_request {
-        struct usb_request req;
-        struct list_head queue;
-};
-
-struct lh7a40x_udc {
-        struct usb_gadget gadget;
-        struct usb_gadget_driver *driver;
-        struct device *dev;
-        spinlock_t lock;
-
-        int ep0state;
-        struct lh7a40x_ep ep[UDC_MAX_ENDPOINTS];
-
-        unsigned char usb_address;
-
-        unsigned req_pending:1, req_std:1, req_config:1;
-};
-
-extern struct lh7a40x_udc *the_controller;
-
-#define ep_is_in(EP)            (((EP)->bEndpointAddress&USB_DIR_IN)==USB_DIR_IN)
-#define ep_index(EP)            ((EP)->bEndpointAddress&0xF)
-#define ep_maxpacket(EP)        ((EP)->ep.maxpacket)
-
-#endif
diff --git a/drivers/usb/gadget/m66592-udc.c b/drivers/usb/gadget/m66592-udc.c
index e03058fe23cb..084aa080a2d5 100644
--- a/drivers/usb/gadget/m66592-udc.c
+++ b/drivers/usb/gadget/m66592-udc.c
@@ -258,7 +258,7 @@ static int pipe_buffer_setting(struct m66592 *m66592,
                 break;
         case M66592_BULK:
                 /* isochronous pipes may be used as bulk pipes */
-                if (info->pipe > M66592_BASE_PIPENUM_BULK)
+                if (info->pipe >= M66592_BASE_PIPENUM_BULK)
                         bufnum = info->pipe - M66592_BASE_PIPENUM_BULK;
                 else
                         bufnum = info->pipe - M66592_BASE_PIPENUM_ISOC;
@@ -1454,14 +1454,15 @@ static struct usb_ep_ops m66592_ep_ops = {
 /*-------------------------------------------------------------------------*/
 static struct m66592 *the_controller;
 
-int usb_gadget_register_driver(struct usb_gadget_driver *driver)
+int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
+                int (*bind)(struct usb_gadget *))
 {
         struct m66592 *m66592 = the_controller;
         int retval;
 
         if (!driver
                         || driver->speed != USB_SPEED_HIGH
-                        || !driver->bind
+                        || !bind
                         || !driver->setup)
                 return -EINVAL;
         if (!m66592)
@@ -1480,7 +1481,7 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver)
                 goto error;
         }
 
-        retval = driver->bind (&m66592->gadget);
+        retval = bind(&m66592->gadget);
         if (retval) {
                 pr_err("bind to driver error (%d)\n", retval);
                 device_del(&m66592->gadget.dev);
@@ -1505,7 +1506,7 @@ error:
 
         return retval;
 }
-EXPORT_SYMBOL(usb_gadget_register_driver);
+EXPORT_SYMBOL(usb_gadget_probe_driver);
 
 int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
 {
diff --git a/drivers/usb/gadget/mass_storage.c b/drivers/usb/gadget/mass_storage.c
index 585f2559484d..01822422c3e8 100644
--- a/drivers/usb/gadget/mass_storage.c
+++ b/drivers/usb/gadget/mass_storage.c
@@ -75,10 +75,6 @@ static struct usb_device_descriptor msg_device_desc = {
         /* Vendor and product id can be overridden by module parameters.  */
         .idVendor =             cpu_to_le16(FSG_VENDOR_ID),
         .idProduct =            cpu_to_le16(FSG_PRODUCT_ID),
-        /* .bcdDevice = f(hardware) */
-        /* .iManufacturer = DYNAMIC */
-        /* .iProduct = DYNAMIC */
-        /* NO SERIAL NUMBER */
         .bNumConfigurations =   1,
 };
 
@@ -86,7 +82,8 @@ static struct usb_otg_descriptor otg_descriptor = {
         .bLength =              sizeof otg_descriptor,
         .bDescriptorType =      USB_DT_OTG,
 
-        /* REVISIT SRP-only hardware is possible, although
+        /*
+         * REVISIT SRP-only hardware is possible, although
          * it would not be called "OTG" ...
          */
         .bmAttributes =         USB_OTG_SRP | USB_OTG_HNP,
@@ -98,33 +95,6 @@ static const struct usb_descriptor_header *otg_desc[] = {
 };
 
 
-/* string IDs are assigned dynamically */
-
-#define STRING_MANUFACTURER_IDX         0
-#define STRING_PRODUCT_IDX              1
-#define STRING_CONFIGURATION_IDX        2
-
-static char manufacturer[50];
-
-static struct usb_string strings_dev[] = {
-        [STRING_MANUFACTURER_IDX].s = manufacturer,
-        [STRING_PRODUCT_IDX].s = DRIVER_DESC,
-        [STRING_CONFIGURATION_IDX].s = "Self Powered",
-        {  } /* end of list */
-};
-
-static struct usb_gadget_strings stringtab_dev = {
-        .language       = 0x0409,       /* en-us */
-        .strings        = strings_dev,
-};
-
-static struct usb_gadget_strings *dev_strings[] = {
-        &stringtab_dev,
-        NULL,
-};
-
-
-
 /****************************** Configurations ******************************/
 
 static struct fsg_module_parameters mod_data = {
@@ -132,7 +102,7 @@ static struct fsg_module_parameters mod_data = {
 };
 FSG_MODULE_PARAMETERS(/* no prefix */, mod_data);
 
-static unsigned long msg_registered = 0;
+static unsigned long msg_registered;
 static void msg_cleanup(void);
 
 static int msg_thread_exits(struct fsg_common *common)
@@ -141,7 +111,7 @@ static int msg_thread_exits(struct fsg_common *common)
         return 0;
 }
 
-static int __ref msg_do_config(struct usb_configuration *c)
+static int __init msg_do_config(struct usb_configuration *c)
 {
         static const struct fsg_operations ops = {
                 .thread_exits = msg_thread_exits,
@@ -171,54 +141,23 @@ static int __ref msg_do_config(struct usb_configuration *c)
 
 static struct usb_configuration msg_config_driver = {
         .label                  = "Linux File-Backed Storage",
-        .bind                   = msg_do_config,
         .bConfigurationValue    = 1,
-        /* .iConfiguration = DYNAMIC */
         .bmAttributes           = USB_CONFIG_ATT_SELFPOWER,
 };
 
 
-
 /****************************** Gadget Bind ******************************/
 
-
-static int __ref msg_bind(struct usb_composite_dev *cdev)
+static int __init msg_bind(struct usb_composite_dev *cdev)
 {
-        struct usb_gadget *gadget = cdev->gadget;
         int status;
 
-        /* Allocate string descriptor numbers ... note that string
-         * contents can be overridden by the composite_dev glue.
-         */
-
-        /* device descriptor strings: manufacturer, product */
-        snprintf(manufacturer, sizeof manufacturer, "%s %s with %s",
-                 init_utsname()->sysname, init_utsname()->release,
-                 gadget->name);
-        status = usb_string_id(cdev);
+        status = usb_add_config(cdev, &msg_config_driver, msg_do_config);
         if (status < 0)
                 return status;
-        strings_dev[STRING_MANUFACTURER_IDX].id = status;
-        msg_device_desc.iManufacturer = status;
 
-        status = usb_string_id(cdev);
-        if (status < 0)
-                return status;
-        strings_dev[STRING_PRODUCT_IDX].id = status;
-        msg_device_desc.iProduct = status;
-
-        status = usb_string_id(cdev);
-        if (status < 0)
-                return status;
-        strings_dev[STRING_CONFIGURATION_IDX].id = status;
-        msg_config_driver.iConfiguration = status;
-
-        /* register our second configuration */
-        status = usb_add_config(cdev, &msg_config_driver);
-        if (status < 0)
-                return status;
-
-        dev_info(&gadget->dev, DRIVER_DESC ", version: " DRIVER_VERSION "\n");
+        dev_info(&cdev->gadget->dev,
+                 DRIVER_DESC ", version: " DRIVER_VERSION "\n");
         set_bit(0, &msg_registered);
         return 0;
 }
@@ -226,12 +165,11 @@ static int __ref msg_bind(struct usb_composite_dev *cdev)
 
 /****************************** Some noise ******************************/
 
-
 static struct usb_composite_driver msg_driver = {
         .name           = "g_mass_storage",
         .dev            = &msg_device_desc,
-        .strings        = dev_strings,
-        .bind           = msg_bind,
+        .iProduct       = DRIVER_DESC,
+        .needs_serial   = 1,
 };
 
 MODULE_DESCRIPTION(DRIVER_DESC);
@@ -240,7 +178,7 @@ MODULE_LICENSE("GPL");
 
 static int __init msg_init(void)
 {
-        return usb_composite_register(&msg_driver);
+        return usb_composite_probe(&msg_driver, msg_bind);
 }
 module_init(msg_init);
 
diff --git a/drivers/usb/gadget/multi.c b/drivers/usb/gadget/multi.c
index 795d76232167..d9feced348e3 100644
--- a/drivers/usb/gadget/multi.c
+++ b/drivers/usb/gadget/multi.c
@@ -74,8 +74,8 @@ MODULE_LICENSE("GPL");
 
 /***************************** Device Descriptor ****************************/
 
-#define MULTI_VENDOR_NUM        0x0525  /* XXX NetChip */
-#define MULTI_PRODUCT_NUM       0xa4ab  /* XXX */
+#define MULTI_VENDOR_NUM        0x1d6b  /* Linux Foundation */
+#define MULTI_PRODUCT_NUM       0x0104  /* Multifunction Composite Gadget */
 
 
 enum {
@@ -121,8 +121,6 @@ static const struct usb_descriptor_header *otg_desc[] = {
 
 
 enum {
-        MULTI_STRING_MANUFACTURER_IDX,
-        MULTI_STRING_PRODUCT_IDX,
 #ifdef CONFIG_USB_G_MULTI_RNDIS
         MULTI_STRING_RNDIS_CONFIG_IDX,
 #endif
@@ -131,11 +129,7 @@ enum {
 #endif
 };
 
-static char manufacturer[50];
-
 static struct usb_string strings_dev[] = {
-        [MULTI_STRING_MANUFACTURER_IDX].s = manufacturer,
-        [MULTI_STRING_PRODUCT_IDX].s      = DRIVER_DESC,
 #ifdef CONFIG_USB_G_MULTI_RNDIS
         [MULTI_STRING_RNDIS_CONFIG_IDX].s = "Multifunction with RNDIS",
 #endif
@@ -170,7 +164,7 @@ static u8 hostaddr[ETH_ALEN];
 
 #ifdef USB_ETH_RNDIS
 
-static __ref int rndis_do_config(struct usb_configuration *c)
+static __init int rndis_do_config(struct usb_configuration *c)
 {
         int ret;
 
@@ -197,7 +191,6 @@ static __ref int rndis_do_config(struct usb_configuration *c)
 static int rndis_config_register(struct usb_composite_dev *cdev)
 {
         static struct usb_configuration config = {
-                .bind                   = rndis_do_config,
                 .bConfigurationValue    = MULTI_RNDIS_CONFIG_NUM,
                 .bmAttributes           = USB_CONFIG_ATT_SELFPOWER,
         };
@@ -205,7 +198,7 @@ static int rndis_config_register(struct usb_composite_dev *cdev)
         config.label          = strings_dev[MULTI_STRING_RNDIS_CONFIG_IDX].s;
         config.iConfiguration = strings_dev[MULTI_STRING_RNDIS_CONFIG_IDX].id;
 
-        return usb_add_config(cdev, &config);
+        return usb_add_config(cdev, &config, rndis_do_config);
 }
 
 #else
@@ -222,7 +215,7 @@ static int rndis_config_register(struct usb_composite_dev *cdev)
 
 #ifdef CONFIG_USB_G_MULTI_CDC
 
-static __ref int cdc_do_config(struct usb_configuration *c)
+static __init int cdc_do_config(struct usb_configuration *c)
 {
         int ret;
 
@@ -249,7 +242,6 @@ static __ref int cdc_do_config(struct usb_configuration *c)
 static int cdc_config_register(struct usb_composite_dev *cdev)
 {
         static struct usb_configuration config = {
-                .bind                   = cdc_do_config,
                 .bConfigurationValue    = MULTI_CDC_CONFIG_NUM,
                 .bmAttributes           = USB_CONFIG_ATT_SELFPOWER,
         };
@@ -257,7 +249,7 @@ static int cdc_config_register(struct usb_composite_dev *cdev)
         config.label          = strings_dev[MULTI_STRING_CDC_CONFIG_IDX].s;
         config.iConfiguration = strings_dev[MULTI_STRING_CDC_CONFIG_IDX].id;
 
-        return usb_add_config(cdev, &config);
+        return usb_add_config(cdev, &config, cdc_do_config);
 }
 
 #else
@@ -314,20 +306,11 @@ static int __ref multi_bind(struct usb_composite_dev *cdev)
                 device_desc.bcdDevice = cpu_to_le16(0x0300 | 0x0099);
         }
 
-        /* allocate string descriptor numbers */
-        snprintf(manufacturer, sizeof manufacturer, "%s %s with %s",
-                 init_utsname()->sysname, init_utsname()->release,
-                 gadget->name);
-
+        /* allocate string IDs */
         status = usb_string_ids_tab(cdev, strings_dev);
         if (unlikely(status < 0))
                 goto fail2;
 
-        device_desc.iManufacturer =
-                strings_dev[MULTI_STRING_MANUFACTURER_IDX].id;
-        device_desc.iProduct      =
-                strings_dev[MULTI_STRING_PRODUCT_IDX].id;
-
         /* register configurations */
         status = rndis_config_register(cdev);
         if (unlikely(status < 0))
@@ -368,14 +351,15 @@ static struct usb_composite_driver multi_driver = {
         .name           = "g_multi",
         .dev            = &device_desc,
         .strings        = dev_strings,
-        .bind           = multi_bind,
         .unbind         = __exit_p(multi_unbind),
+        .iProduct       = DRIVER_DESC,
+        .needs_serial   = 1,
 };
 
 
 static int __init multi_init(void)
 {
-        return usb_composite_register(&multi_driver);
+        return usb_composite_probe(&multi_driver, multi_bind);
 }
 module_init(multi_init);
 
diff --git a/drivers/usb/gadget/mv_udc.h b/drivers/usb/gadget/mv_udc.h
new file mode 100644
index 000000000000..65f1f7c3bd4e
--- /dev/null
+++ b/drivers/usb/gadget/mv_udc.h
@@ -0,0 +1,294 @@
+
+#ifndef __MV_UDC_H
+#define __MV_UDC_H
+
+#define VUSBHS_MAX_PORTS        8
+
+#define DQH_ALIGNMENT           2048
+#define DTD_ALIGNMENT           64
+#define DMA_BOUNDARY            4096
+
+#define EP_DIR_IN       1
+#define EP_DIR_OUT      0
+
+#define DMA_ADDR_INVALID        (~(dma_addr_t)0)
+
+#define EP0_MAX_PKT_SIZE        64
+/* ep0 transfer state */
+#define WAIT_FOR_SETUP          0
+#define DATA_STATE_XMIT         1
+#define DATA_STATE_NEED_ZLP     2
+#define WAIT_FOR_OUT_STATUS     3
+#define DATA_STATE_RECV         4
+
+#define CAPLENGTH_MASK          (0xff)
+#define DCCPARAMS_DEN_MASK      (0x1f)
+
+#define HCSPARAMS_PPC           (0x10)
+
+/* Frame Index Register Bit Masks */
+#define USB_FRINDEX_MASKS       0x3fff
+
+/* Command Register Bit Masks */
+#define USBCMD_RUN_STOP                         (0x00000001)
+#define USBCMD_CTRL_RESET                       (0x00000002)
+#define USBCMD_SETUP_TRIPWIRE_SET               (0x00002000)
+#define USBCMD_SETUP_TRIPWIRE_CLEAR             (~USBCMD_SETUP_TRIPWIRE_SET)
+
+#define USBCMD_ATDTW_TRIPWIRE_SET               (0x00004000)
+#define USBCMD_ATDTW_TRIPWIRE_CLEAR             (~USBCMD_ATDTW_TRIPWIRE_SET)
+
+/* bit 15,3,2 are for frame list size */
+#define USBCMD_FRAME_SIZE_1024                  (0x00000000) /* 000 */
+#define USBCMD_FRAME_SIZE_512                   (0x00000004) /* 001 */
+#define USBCMD_FRAME_SIZE_256                   (0x00000008) /* 010 */
+#define USBCMD_FRAME_SIZE_128                   (0x0000000C) /* 011 */
+#define USBCMD_FRAME_SIZE_64                    (0x00008000) /* 100 */
+#define USBCMD_FRAME_SIZE_32                    (0x00008004) /* 101 */
+#define USBCMD_FRAME_SIZE_16                    (0x00008008) /* 110 */
+#define USBCMD_FRAME_SIZE_8                     (0x0000800C) /* 111 */
+
+#define EPCTRL_TX_ALL_MASK                      (0xFFFF0000)
+#define EPCTRL_RX_ALL_MASK                      (0x0000FFFF)
+
+#define EPCTRL_TX_DATA_TOGGLE_RST               (0x00400000)
+#define EPCTRL_TX_EP_STALL                      (0x00010000)
+#define EPCTRL_RX_EP_STALL                      (0x00000001)
+#define EPCTRL_RX_DATA_TOGGLE_RST               (0x00000040)
+#define EPCTRL_RX_ENABLE                        (0x00000080)
+#define EPCTRL_TX_ENABLE                        (0x00800000)
+#define EPCTRL_CONTROL                          (0x00000000)
+#define EPCTRL_ISOCHRONOUS                      (0x00040000)
+#define EPCTRL_BULK                             (0x00080000)
+#define EPCTRL_INT                              (0x000C0000)
+#define EPCTRL_TX_TYPE                          (0x000C0000)
+#define EPCTRL_RX_TYPE                          (0x0000000C)
+#define EPCTRL_DATA_TOGGLE_INHIBIT              (0x00000020)
+#define EPCTRL_TX_EP_TYPE_SHIFT                 (18)
+#define EPCTRL_RX_EP_TYPE_SHIFT                 (2)
+
+#define EPCOMPLETE_MAX_ENDPOINTS                (16)
+
+/* endpoint list address bit masks */
+#define USB_EP_LIST_ADDRESS_MASK              0xfffff800
+
+#define PORTSCX_W1C_BITS                        0x2a
+#define PORTSCX_PORT_RESET                      0x00000100
+#define PORTSCX_PORT_POWER                      0x00001000
+#define PORTSCX_FORCE_FULL_SPEED_CONNECT        0x01000000
+#define PORTSCX_PAR_XCVR_SELECT                 0xC0000000
+#define PORTSCX_PORT_FORCE_RESUME               0x00000040
+#define PORTSCX_PORT_SUSPEND                    0x00000080
+#define PORTSCX_PORT_SPEED_FULL                 0x00000000
+#define PORTSCX_PORT_SPEED_LOW                  0x04000000
+#define PORTSCX_PORT_SPEED_HIGH                 0x08000000
+#define PORTSCX_PORT_SPEED_MASK                 0x0C000000
+
+/* USB MODE Register Bit Masks */
+#define USBMODE_CTRL_MODE_IDLE                  0x00000000
+#define USBMODE_CTRL_MODE_DEVICE                0x00000002
+#define USBMODE_CTRL_MODE_HOST                  0x00000003
+#define USBMODE_CTRL_MODE_RSV                   0x00000001
+#define USBMODE_SETUP_LOCK_OFF                  0x00000008
+#define USBMODE_STREAM_DISABLE                  0x00000010
+
+/* USB STS Register Bit Masks */
+#define USBSTS_INT                      0x00000001
+#define USBSTS_ERR                      0x00000002
+#define USBSTS_PORT_CHANGE              0x00000004
+#define USBSTS_FRM_LST_ROLL             0x00000008
+#define USBSTS_SYS_ERR                  0x00000010
+#define USBSTS_IAA                      0x00000020
+#define USBSTS_RESET                    0x00000040
+#define USBSTS_SOF                      0x00000080
+#define USBSTS_SUSPEND                  0x00000100
+#define USBSTS_HC_HALTED                0x00001000
+#define USBSTS_RCL                      0x00002000
+#define USBSTS_PERIODIC_SCHEDULE        0x00004000
+#define USBSTS_ASYNC_SCHEDULE           0x00008000
+
+
+/* Interrupt Enable Register Bit Masks */
+#define USBINTR_INT_EN                          (0x00000001)
+#define USBINTR_ERR_INT_EN                      (0x00000002)
+#define USBINTR_PORT_CHANGE_DETECT_EN           (0x00000004)
+
+#define USBINTR_ASYNC_ADV_AAE                   (0x00000020)
+#define USBINTR_ASYNC_ADV_AAE_ENABLE            (0x00000020)
+#define USBINTR_ASYNC_ADV_AAE_DISABLE           (0xFFFFFFDF)
+
+#define USBINTR_RESET_EN                        (0x00000040)
+#define USBINTR_SOF_UFRAME_EN                   (0x00000080)
+#define USBINTR_DEVICE_SUSPEND                  (0x00000100)
+
+#define USB_DEVICE_ADDRESS_MASK                 (0xfe000000)
+#define USB_DEVICE_ADDRESS_BIT_SHIFT            (25)
+
+struct mv_cap_regs {
+        u32     caplength_hciversion;
+        u32     hcsparams;      /* HC structural parameters */
+        u32     hccparams;      /* HC Capability Parameters*/
+        u32     reserved[5];
+        u32     dciversion;     /* DC version number and reserved 16 bits */
+        u32     dccparams;      /* DC Capability Parameters */
+};
+
+struct mv_op_regs {
+        u32     usbcmd;         /* Command register */
+        u32     usbsts;         /* Status register */
+        u32     usbintr;        /* Interrupt enable */
+        u32     frindex;        /* Frame index */
+        u32     reserved1[1];
+        u32     deviceaddr;     /* Device Address */
+        u32     eplistaddr;     /* Endpoint List Address */
+        u32     ttctrl;         /* HOST TT status and control */
+        u32     burstsize;      /* Programmable Burst Size */
+        u32     txfilltuning;   /* Host Transmit Pre-Buffer Packet Tuning */
+        u32     reserved[4];
+        u32     epnak;          /* Endpoint NAK */
+        u32     epnaken;        /* Endpoint NAK Enable */
+        u32     configflag;     /* Configured Flag register */
+        u32     portsc[VUSBHS_MAX_PORTS]; /* Port Status/Control x, x = 1..8 */
+        u32     otgsc;
+        u32     usbmode;        /* USB Host/Device mode */
+        u32     epsetupstat;    /* Endpoint Setup Status */
+        u32     epprime;        /* Endpoint Initialize */
+        u32     epflush;        /* Endpoint De-initialize */
+        u32     epstatus;       /* Endpoint Status */
+        u32     epcomplete;     /* Endpoint Interrupt On Complete */
+        u32     epctrlx[16];    /* Endpoint Control, where x = 0.. 15 */
+        u32     mcr;            /* Mux Control */
+        u32     isr;            /* Interrupt Status */
+        u32     ier;            /* Interrupt Enable */
+};
+
+struct mv_udc {
+        struct usb_gadget               gadget;
+        struct usb_gadget_driver        *driver;
+        spinlock_t                      lock;
+        struct completion               *done;
+        struct platform_device          *dev;
+        int                             irq;
+
+        struct mv_cap_regs __iomem      *cap_regs;
+        struct mv_op_regs __iomem       *op_regs;
+        unsigned int                    phy_regs;
+        unsigned int                    max_eps;
+        struct mv_dqh                   *ep_dqh;
+        size_t                          ep_dqh_size;
+        dma_addr_t                      ep_dqh_dma;
+
+        struct dma_pool                 *dtd_pool;
+        struct mv_ep                    *eps;
+
+        struct mv_dtd                   *dtd_head;
+        struct mv_dtd                   *dtd_tail;
+        unsigned int                    dtd_entries;
+
+        struct mv_req                   *status_req;
+        struct usb_ctrlrequest          local_setup_buff;
+
+        unsigned int            resume_state;   /* USB state to resume */
+        unsigned int            usb_state;      /* USB current state */
+        unsigned int            ep0_state;      /* Endpoint zero state */
+        unsigned int            ep0_dir;
+
+        unsigned int            dev_addr;
+
+        int                     errors;
+        unsigned                softconnect:1,
+                                vbus_active:1,
+                                remote_wakeup:1,
+                                softconnected:1,
+                                force_fs:1;
+        struct clk              *clk;
+};
+
+/* endpoint data structure */
+struct mv_ep {
+        struct usb_ep           ep;
+        struct mv_udc           *udc;
+        struct list_head        queue;
+        struct mv_dqh           *dqh;
+        const struct usb_endpoint_descriptor    *desc;
+        u32                     direction;
+        char                    name[14];
+        unsigned                stopped:1,
+                                wedge:1,
+                                ep_type:2,
+                                ep_num:8;
+};
+
+/* request data structure */
+struct mv_req {
+        struct usb_request      req;
+        struct mv_dtd           *dtd, *head, *tail;
+        struct mv_ep            *ep;
+        struct list_head        queue;
+        unsigned                dtd_count;
+        unsigned                mapped:1;
+};
+
+#define EP_QUEUE_HEAD_MULT_POS                  30
+#define EP_QUEUE_HEAD_ZLT_SEL                   0x20000000
+#define EP_QUEUE_HEAD_MAX_PKT_LEN_POS           16
+#define EP_QUEUE_HEAD_MAX_PKT_LEN(ep_info)      (((ep_info)>>16)&0x07ff)
+#define EP_QUEUE_HEAD_IOS                       0x00008000
+#define EP_QUEUE_HEAD_NEXT_TERMINATE            0x00000001
+#define EP_QUEUE_HEAD_IOC                       0x00008000
+#define EP_QUEUE_HEAD_MULTO                     0x00000C00
+#define EP_QUEUE_HEAD_STATUS_HALT               0x00000040
+#define EP_QUEUE_HEAD_STATUS_ACTIVE             0x00000080
+#define EP_QUEUE_CURRENT_OFFSET_MASK            0x00000FFF
+#define EP_QUEUE_HEAD_NEXT_POINTER_MASK         0xFFFFFFE0
+#define EP_QUEUE_FRINDEX_MASK                   0x000007FF
+#define EP_MAX_LENGTH_TRANSFER                  0x4000
+
+struct mv_dqh {
+        /* Bits 16..26 Bit 15 is Interrupt On Setup */
+        u32     max_packet_length;
+        u32     curr_dtd_ptr;           /* Current dTD Pointer */
+        u32     next_dtd_ptr;           /* Next dTD Pointer */
+        /* Total bytes (16..30), IOC (15), INT (8), STS (0-7) */
+        u32     size_ioc_int_sts;
+        u32     buff_ptr0;              /* Buffer pointer Page 0 (12-31) */
+        u32     buff_ptr1;              /* Buffer pointer Page 1 (12-31) */
+        u32     buff_ptr2;              /* Buffer pointer Page 2 (12-31) */
+        u32     buff_ptr3;              /* Buffer pointer Page 3 (12-31) */
+        u32     buff_ptr4;              /* Buffer pointer Page 4 (12-31) */
+        u32     reserved1;
+        /* 8 bytes of setup data that follows the Setup PID */
+        u8      setup_buffer[8];
+        u32     reserved2[4];
+};
+
+
+#define DTD_NEXT_TERMINATE              (0x00000001)
+#define DTD_IOC                         (0x00008000)
+#define DTD_STATUS_ACTIVE               (0x00000080)
+#define DTD_STATUS_HALTED               (0x00000040)
+#define DTD_STATUS_DATA_BUFF_ERR        (0x00000020)
+#define DTD_STATUS_TRANSACTION_ERR      (0x00000008)
+#define DTD_RESERVED_FIELDS             (0x00007F00)
+#define DTD_ERROR_MASK                  (0x68)
+#define DTD_ADDR_MASK                   (0xFFFFFFE0)
+#define DTD_PACKET_SIZE                 0x7FFF0000
+#define DTD_LENGTH_BIT_POS              (16)
+
+struct mv_dtd {
+        u32     dtd_next;
+        u32     size_ioc_sts;
+        u32     buff_ptr0;              /* Buffer pointer Page 0 */
+        u32     buff_ptr1;              /* Buffer pointer Page 1 */
+        u32     buff_ptr2;              /* Buffer pointer Page 2 */
+        u32     buff_ptr3;              /* Buffer pointer Page 3 */
+        u32     buff_ptr4;              /* Buffer pointer Page 4 */
+        u32     scratch_ptr;
+        /* 32 bytes */
+        dma_addr_t td_dma;              /* dma address for this td */
+        struct mv_dtd *next_dtd_virt;
+};
+
+extern int mv_udc_phy_init(unsigned int base);
+
+#endif
diff --git a/drivers/usb/gadget/mv_udc_core.c b/drivers/usb/gadget/mv_udc_core.c
new file mode 100644
index 000000000000..b1a8146b9d50
--- /dev/null
+++ b/drivers/usb/gadget/mv_udc_core.c
@@ -0,0 +1,2149 @@
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/dma-mapping.h>
+#include <linux/dmapool.h>
+#include <linux/kernel.h>
+#include <linux/delay.h>
+#include <linux/ioport.h>
+#include <linux/sched.h>
+#include <linux/slab.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/timer.h>
+#include <linux/list.h>
+#include <linux/interrupt.h>
+#include <linux/moduleparam.h>
+#include <linux/device.h>
+#include <linux/usb/ch9.h>
+#include <linux/usb/gadget.h>
+#include <linux/usb/otg.h>
+#include <linux/pm.h>
+#include <linux/io.h>
+#include <linux/irq.h>
+#include <linux/platform_device.h>
+#include <linux/clk.h>
+#include <asm/system.h>
+#include <asm/unaligned.h>
+
+#include "mv_udc.h"
+
+#define DRIVER_DESC             "Marvell PXA USB Device Controller driver"
+#define DRIVER_VERSION          "8 Nov 2010"
+
+#define ep_dir(ep)      (((ep)->ep_num == 0) ? \
+                                ((ep)->udc->ep0_dir) : ((ep)->direction))
+
+/* timeout value -- usec */
+#define RESET_TIMEOUT           10000
+#define FLUSH_TIMEOUT           10000
+#define EPSTATUS_TIMEOUT        10000
+#define PRIME_TIMEOUT           10000
+#define READSAFE_TIMEOUT        1000
+#define DTD_TIMEOUT             1000
+
+#define LOOPS_USEC_SHIFT        4
+#define LOOPS_USEC              (1 << LOOPS_USEC_SHIFT)
+#define LOOPS(timeout)          ((timeout) >> LOOPS_USEC_SHIFT)
+
+static const char driver_name[] = "mv_udc";
+static const char driver_desc[] = DRIVER_DESC;
+
+/* controller device global variable */
+static struct mv_udc    *the_controller;
+int mv_usb_otgsc;
+
+static void nuke(struct mv_ep *ep, int status);
+
+/* for endpoint 0 operations */
+static const struct usb_endpoint_descriptor mv_ep0_desc = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+        .bEndpointAddress =     0,
+        .bmAttributes =         USB_ENDPOINT_XFER_CONTROL,
+        .wMaxPacketSize =       EP0_MAX_PKT_SIZE,
+};
+
+static void ep0_reset(struct mv_udc *udc)
+{
+        struct mv_ep *ep;
+        u32 epctrlx;
+        int i = 0;
+
+        /* ep0 in and out */
+        for (i = 0; i < 2; i++) {
+                ep = &udc->eps[i];
+                ep->udc = udc;
+
+                /* ep0 dQH */
+                ep->dqh = &udc->ep_dqh[i];
+
+                /* configure ep0 endpoint capabilities in dQH */
+                ep->dqh->max_packet_length =
+                        (EP0_MAX_PKT_SIZE << EP_QUEUE_HEAD_MAX_PKT_LEN_POS)
+                        | EP_QUEUE_HEAD_IOS;
+
+                epctrlx = readl(&udc->op_regs->epctrlx[0]);
+                if (i) {        /* TX */
+                        epctrlx |= EPCTRL_TX_ENABLE | EPCTRL_TX_DATA_TOGGLE_RST
+                                | (USB_ENDPOINT_XFER_CONTROL
+                                        << EPCTRL_TX_EP_TYPE_SHIFT);
+
+                } else {        /* RX */
+                        epctrlx |= EPCTRL_RX_ENABLE | EPCTRL_RX_DATA_TOGGLE_RST
+                                | (USB_ENDPOINT_XFER_CONTROL
+                                        << EPCTRL_RX_EP_TYPE_SHIFT);
+                }
+
+                writel(epctrlx, &udc->op_regs->epctrlx[0]);
+        }
+}
+
+/* protocol ep0 stall, will automatically be cleared on new transaction */
+static void ep0_stall(struct mv_udc *udc)
+{
+        u32     epctrlx;
+
+        /* set TX and RX to stall */
+        epctrlx = readl(&udc->op_regs->epctrlx[0]);
+        epctrlx |= EPCTRL_RX_EP_STALL | EPCTRL_TX_EP_STALL;
+        writel(epctrlx, &udc->op_regs->epctrlx[0]);
+
+        /* update ep0 state */
+        udc->ep0_state = WAIT_FOR_SETUP;
+        udc->ep0_dir = EP_DIR_OUT;
+}
+
+static int process_ep_req(struct mv_udc *udc, int index,
+        struct mv_req *curr_req)
+{
+        struct mv_dtd   *curr_dtd;
+        struct mv_dqh   *curr_dqh;
+        int td_complete, actual, remaining_length;
+        int i, direction;
+        int retval = 0;
+        u32 errors;
+
+        curr_dqh = &udc->ep_dqh[index];
+        direction = index % 2;
+
+        curr_dtd = curr_req->head;
+        td_complete = 0;
+        actual = curr_req->req.length;
+
+        for (i = 0; i < curr_req->dtd_count; i++) {
+                if (curr_dtd->size_ioc_sts & DTD_STATUS_ACTIVE) {
+                        dev_dbg(&udc->dev->dev, "%s, dTD not completed\n",
+                                udc->eps[index].name);
+                        return 1;
+                }
+
+                errors = curr_dtd->size_ioc_sts & DTD_ERROR_MASK;
+                if (!errors) {
+                        remaining_length +=
+                                (curr_dtd->size_ioc_sts & DTD_PACKET_SIZE)
+                                        >> DTD_LENGTH_BIT_POS;
+                        actual -= remaining_length;
+                } else {
+                        dev_info(&udc->dev->dev,
+                                "complete_tr error: ep=%d %s: error = 0x%x\n",
+                                index >> 1, direction ? "SEND" : "RECV",
+                                errors);
+                        if (errors & DTD_STATUS_HALTED) {
+                                /* Clear the errors and Halt condition */
+                                curr_dqh->size_ioc_int_sts &= ~errors;
+                                retval = -EPIPE;
+                        } else if (errors & DTD_STATUS_DATA_BUFF_ERR) {
+                                retval = -EPROTO;
+                        } else if (errors & DTD_STATUS_TRANSACTION_ERR) {
+                                retval = -EILSEQ;
+                        }
+                }
+                if (i != curr_req->dtd_count - 1)
+                        curr_dtd = (struct mv_dtd *)curr_dtd->next_dtd_virt;
+        }
+        if (retval)
+                return retval;
+
+        curr_req->req.actual = actual;
+
+        return 0;
+}
+
+/*
+ * done() - retire a request; caller blocked irqs
+ * @status : request status to be set, only works when
+ * request is still in progress.
+ */
+static void done(struct mv_ep *ep, struct mv_req *req, int status)
+{
+        struct mv_udc *udc = NULL;
+        unsigned char stopped = ep->stopped;
+        struct mv_dtd *curr_td, *next_td;
+        int j;
+
+        udc = (struct mv_udc *)ep->udc;
+        /* Removed the req from fsl_ep->queue */
+        list_del_init(&req->queue);
+
+        /* req.status should be set as -EINPROGRESS in ep_queue() */
+        if (req->req.status == -EINPROGRESS)
+                req->req.status = status;
+        else
+                status = req->req.status;
+
+        /* Free dtd for the request */
+        next_td = req->head;
+        for (j = 0; j < req->dtd_count; j++) {
+                curr_td = next_td;
+                if (j != req->dtd_count - 1)
+                        next_td = curr_td->next_dtd_virt;
+                dma_pool_free(udc->dtd_pool, curr_td, curr_td->td_dma);
+        }
+
+        if (req->mapped) {
+                dma_unmap_single(ep->udc->gadget.dev.parent,
+                        req->req.dma, req->req.length,
+                        ((ep_dir(ep) == EP_DIR_IN) ?
+                                DMA_TO_DEVICE : DMA_FROM_DEVICE));
+                req->req.dma = DMA_ADDR_INVALID;
+                req->mapped = 0;
+        } else
+                dma_sync_single_for_cpu(ep->udc->gadget.dev.parent,
+                        req->req.dma, req->req.length,
+                        ((ep_dir(ep) == EP_DIR_IN) ?
+                                DMA_TO_DEVICE : DMA_FROM_DEVICE));
+
+        if (status && (status != -ESHUTDOWN))
+                dev_info(&udc->dev->dev, "complete %s req %p stat %d len %u/%u",
+                        ep->ep.name, &req->req, status,
+                        req->req.actual, req->req.length);
+
+        ep->stopped = 1;
+
+        spin_unlock(&ep->udc->lock);
+        /*
+         * complete() is from gadget layer,
+         * eg fsg->bulk_in_complete()
+         */
+        if (req->req.complete)
+                req->req.complete(&ep->ep, &req->req);
+
+        spin_lock(&ep->udc->lock);
+        ep->stopped = stopped;
+}
+
+static int queue_dtd(struct mv_ep *ep, struct mv_req *req)
+{
+        u32 tmp, epstatus, bit_pos, direction;
+        struct mv_udc *udc;
+        struct mv_dqh *dqh;
+        unsigned int loops;
+        int readsafe, retval = 0;
+
+        udc = ep->udc;
+        direction = ep_dir(ep);
+        dqh = &(udc->ep_dqh[ep->ep_num * 2 + direction]);
+        bit_pos = 1 << (((direction == EP_DIR_OUT) ? 0 : 16) + ep->ep_num);
+
+        /* check if the pipe is empty */
+        if (!(list_empty(&ep->queue))) {
+                struct mv_req *lastreq;
+                lastreq = list_entry(ep->queue.prev, struct mv_req, queue);
+                lastreq->tail->dtd_next =
+                        req->head->td_dma & EP_QUEUE_HEAD_NEXT_POINTER_MASK;
+                if (readl(&udc->op_regs->epprime) & bit_pos) {
+                        loops = LOOPS(PRIME_TIMEOUT);
+                        while (readl(&udc->op_regs->epprime) & bit_pos) {
+                                if (loops == 0) {
+                                        retval = -ETIME;
+                                        goto done;
+                                }
+                                udelay(LOOPS_USEC);
+                                loops--;
+                        }
+                        if (readl(&udc->op_regs->epstatus) & bit_pos)
+                                goto done;
+                }
+                readsafe = 0;
+                loops = LOOPS(READSAFE_TIMEOUT);
+                while (readsafe == 0) {
+                        if (loops == 0) {
+                                retval = -ETIME;
+                                goto done;
+                        }
+                        /* start with setting the semaphores */
+                        tmp = readl(&udc->op_regs->usbcmd);
+                        tmp |= USBCMD_ATDTW_TRIPWIRE_SET;
+                        writel(tmp, &udc->op_regs->usbcmd);
+
+                        /* read the endpoint status */
+                        epstatus = readl(&udc->op_regs->epstatus) & bit_pos;
+
+                        /*
+                         * Reread the ATDTW semaphore bit to check if it is
+                         * cleared. When hardware see a hazard, it will clear
+                         * the bit or else we remain set to 1 and we can
+                         * proceed with priming of endpoint if not already
+                         * primed.
+                         */
+                        if (readl(&udc->op_regs->usbcmd)
+                                & USBCMD_ATDTW_TRIPWIRE_SET) {
+                                readsafe = 1;
+                        }
+                        loops--;
+                        udelay(LOOPS_USEC);
+                }
+
+                /* Clear the semaphore */
+                tmp = readl(&udc->op_regs->usbcmd);
+                tmp &= USBCMD_ATDTW_TRIPWIRE_CLEAR;
+                writel(tmp, &udc->op_regs->usbcmd);
+
+                /* If endpoint is not active, we activate it now. */
+                if (!epstatus) {
+                        if (direction == EP_DIR_IN) {
+                                struct mv_dtd *curr_dtd = dma_to_virt(
+                                        &udc->dev->dev, dqh->curr_dtd_ptr);
+
+                                loops = LOOPS(DTD_TIMEOUT);
+                                while (curr_dtd->size_ioc_sts
+                                        & DTD_STATUS_ACTIVE) {
+                                        if (loops == 0) {
+                                                retval = -ETIME;
+                                                goto done;
+                                        }
+                                        loops--;
+                                        udelay(LOOPS_USEC);
+                                }
+                        }
+                        /* No other transfers on the queue */
+
+                        /* Write dQH next pointer and terminate bit to 0 */
+                        dqh->next_dtd_ptr = req->head->td_dma
+                                & EP_QUEUE_HEAD_NEXT_POINTER_MASK;
+                        dqh->size_ioc_int_sts = 0;
+
+                        /*
+                         * Ensure that updates to the QH will
+                         * occur before priming.
+                         */
+                        wmb();
+
+                        /* Prime the Endpoint */
+                        writel(bit_pos, &udc->op_regs->epprime);
+                }
+        } else {
+                /* Write dQH next pointer and terminate bit to 0 */
+                dqh->next_dtd_ptr = req->head->td_dma
+                        & EP_QUEUE_HEAD_NEXT_POINTER_MASK;;
+                dqh->size_ioc_int_sts = 0;
+
+                /* Ensure that updates to the QH will occur before priming. */
+                wmb();
+
+                /* Prime the Endpoint */
+                writel(bit_pos, &udc->op_regs->epprime);
+
+                if (direction == EP_DIR_IN) {
+                        /* FIXME add status check after prime the IN ep */
+                        int prime_again;
+                        u32 curr_dtd_ptr = dqh->curr_dtd_ptr;
+
+                        loops = LOOPS(DTD_TIMEOUT);
+                        prime_again = 0;
+                        while ((curr_dtd_ptr != req->head->td_dma)) {
+                                curr_dtd_ptr = dqh->curr_dtd_ptr;
+                                if (loops == 0) {
+                                        dev_err(&udc->dev->dev,
+                                                "failed to prime %s\n",
+                                                ep->name);
+                                        retval = -ETIME;
+                                        goto done;
+                                }
+                                loops--;
+                                udelay(LOOPS_USEC);
+
+                                if (loops == (LOOPS(DTD_TIMEOUT) >> 2)) {
+                                        if (prime_again)
+                                                goto done;
+                                        dev_info(&udc->dev->dev,
+                                                "prime again\n");
+                                        writel(bit_pos,
+                                                &udc->op_regs->epprime);
+                                        prime_again = 1;
+                                }
+                        }
+                }
+        }
+done:
+        return retval;;
+}
+
+static struct mv_dtd *build_dtd(struct mv_req *req, unsigned *length,
+                dma_addr_t *dma, int *is_last)
+{
+        u32 temp;
+        struct mv_dtd *dtd;
+        struct mv_udc *udc;
+
+        /* how big will this transfer be? */
+        *length = min(req->req.length - req->req.actual,
+                        (unsigned)EP_MAX_LENGTH_TRANSFER);
+
+        udc = req->ep->udc;
+
+        /*
+         * Be careful that no _GFP_HIGHMEM is set,
+         * or we can not use dma_to_virt
+         */
+        dtd = dma_pool_alloc(udc->dtd_pool, GFP_KERNEL, dma);
+        if (dtd == NULL)
+                return dtd;
+
+        dtd->td_dma = *dma;
+        /* initialize buffer page pointers */
+        temp = (u32)(req->req.dma + req->req.actual);
+        dtd->buff_ptr0 = cpu_to_le32(temp);
+        temp &= ~0xFFF;
+        dtd->buff_ptr1 = cpu_to_le32(temp + 0x1000);
+        dtd->buff_ptr2 = cpu_to_le32(temp + 0x2000);
+        dtd->buff_ptr3 = cpu_to_le32(temp + 0x3000);
+        dtd->buff_ptr4 = cpu_to_le32(temp + 0x4000);
+
+        req->req.actual += *length;
+
+        /* zlp is needed if req->req.zero is set */
+        if (req->req.zero) {
+                if (*length == 0 || (*length % req->ep->ep.maxpacket) != 0)
+                        *is_last = 1;
+                else
+                        *is_last = 0;
+        } else if (req->req.length == req->req.actual)
+                *is_last = 1;
+        else
+                *is_last = 0;
+
+        /* Fill in the transfer size; set active bit */
+        temp = ((*length << DTD_LENGTH_BIT_POS) | DTD_STATUS_ACTIVE);
+
+        /* Enable interrupt for the last dtd of a request */
+        if (*is_last && !req->req.no_interrupt)
+                temp |= DTD_IOC;
+
+        dtd->size_ioc_sts = temp;
+
+        mb();
+
+        return dtd;
+}
+
+/* generate dTD linked list for a request */
+static int req_to_dtd(struct mv_req *req)
+{
+        unsigned count;
+        int is_last, is_first = 1;
+        struct mv_dtd *dtd, *last_dtd = NULL;
+        struct mv_udc *udc;
+        dma_addr_t dma;
+
+        udc = req->ep->udc;
+
+        do {
+                dtd = build_dtd(req, &count, &dma, &is_last);
+                if (dtd == NULL)
+                        return -ENOMEM;
+
+                if (is_first) {
+                        is_first = 0;
+                        req->head = dtd;
+                } else {
+                        last_dtd->dtd_next = dma;
+                        last_dtd->next_dtd_virt = dtd;
+                }
+                last_dtd = dtd;
+                req->dtd_count++;
+        } while (!is_last);
+
+        /* set terminate bit to 1 for the last dTD */
+        dtd->dtd_next = DTD_NEXT_TERMINATE;
+
+        req->tail = dtd;
+
+        return 0;
+}
+
+static int mv_ep_enable(struct usb_ep *_ep,
+                const struct usb_endpoint_descriptor *desc)
+{
+        struct mv_udc *udc;
+        struct mv_ep *ep;
+        struct mv_dqh *dqh;
+        u16 max = 0;
+        u32 bit_pos, epctrlx, direction;
+        unsigned char zlt = 0, ios = 0, mult = 0;
+
+        ep = container_of(_ep, struct mv_ep, ep);
+        udc = ep->udc;
+
+        if (!_ep || !desc || ep->desc
+                        || desc->bDescriptorType != USB_DT_ENDPOINT)
+                return -EINVAL;
+
+        if (!udc->driver || udc->gadget.speed == USB_SPEED_UNKNOWN)
+                return -ESHUTDOWN;
+
+        direction = ep_dir(ep);
+        max = le16_to_cpu(desc->wMaxPacketSize);
+
+        /*
+         * disable HW zero length termination select
+         * driver handles zero length packet through req->req.zero
+         */
+        zlt = 1;
+
+        /* Get the endpoint queue head address */
+        dqh = (struct mv_dqh *)ep->dqh;
+
+        bit_pos = 1 << ((direction == EP_DIR_OUT ? 0 : 16) + ep->ep_num);
+
+        /* Check if the Endpoint is Primed */
+        if ((readl(&udc->op_regs->epprime) & bit_pos)
+                || (readl(&udc->op_regs->epstatus) & bit_pos)) {
+                dev_info(&udc->dev->dev,
+                        "ep=%d %s: Init ERROR: ENDPTPRIME=0x%x,"
+                        " ENDPTSTATUS=0x%x, bit_pos=0x%x\n",
+                        (unsigned)ep->ep_num, direction ? "SEND" : "RECV",
+                        (unsigned)readl(&udc->op_regs->epprime),
+                        (unsigned)readl(&udc->op_regs->epstatus),
+                        (unsigned)bit_pos);
+                goto en_done;
+        }
+        /* Set the max packet length, interrupt on Setup and Mult fields */
+        switch (desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
+        case USB_ENDPOINT_XFER_BULK:
+                zlt = 1;
+                mult = 0;
+                break;
+        case USB_ENDPOINT_XFER_CONTROL:
+                ios = 1;
+        case USB_ENDPOINT_XFER_INT:
+                mult = 0;
+                break;
+        case USB_ENDPOINT_XFER_ISOC:
+                /* Calculate transactions needed for high bandwidth iso */
+                mult = (unsigned char)(1 + ((max >> 11) & 0x03));
+                max = max & 0x8ff;      /* bit 0~10 */
+                /* 3 transactions at most */
+                if (mult > 3)
+                        goto en_done;
+                break;
+        default:
+                goto en_done;
+        }
+        dqh->max_packet_length = (max << EP_QUEUE_HEAD_MAX_PKT_LEN_POS)
+                | (mult << EP_QUEUE_HEAD_MULT_POS)
+                | (zlt ? EP_QUEUE_HEAD_ZLT_SEL : 0)
+                | (ios ? EP_QUEUE_HEAD_IOS : 0);
+        dqh->next_dtd_ptr = 1;
+        dqh->size_ioc_int_sts = 0;
+
+        ep->ep.maxpacket = max;
+        ep->desc = desc;
+        ep->stopped = 0;
+
+        /* Enable the endpoint for Rx or Tx and set the endpoint type */
+        epctrlx = readl(&udc->op_regs->epctrlx[ep->ep_num]);
+        if (direction == EP_DIR_IN) {
+                epctrlx &= ~EPCTRL_TX_ALL_MASK;
+                epctrlx |= EPCTRL_TX_ENABLE | EPCTRL_TX_DATA_TOGGLE_RST
+                        | ((desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
+                                << EPCTRL_TX_EP_TYPE_SHIFT);
+        } else {
+                epctrlx &= ~EPCTRL_RX_ALL_MASK;
+                epctrlx |= EPCTRL_RX_ENABLE | EPCTRL_RX_DATA_TOGGLE_RST
+                        | ((desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
+                                << EPCTRL_RX_EP_TYPE_SHIFT);
+        }
+        writel(epctrlx, &udc->op_regs->epctrlx[ep->ep_num]);
+
+        /*
+         * Implement Guideline (GL# USB-7) The unused endpoint type must
+         * be programmed to bulk.
+         */
+        epctrlx = readl(&udc->op_regs->epctrlx[ep->ep_num]);
+        if ((epctrlx & EPCTRL_RX_ENABLE) == 0) {
+                epctrlx |= ((desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
+                                << EPCTRL_RX_EP_TYPE_SHIFT);
+                writel(epctrlx, &udc->op_regs->epctrlx[ep->ep_num]);
+        }
+
+        epctrlx = readl(&udc->op_regs->epctrlx[ep->ep_num]);
+        if ((epctrlx & EPCTRL_TX_ENABLE) == 0) {
+                epctrlx |= ((desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
+                                << EPCTRL_TX_EP_TYPE_SHIFT);
+                writel(epctrlx, &udc->op_regs->epctrlx[ep->ep_num]);
+        }
+
+        return 0;
+en_done:
+        return -EINVAL;
+}
+
+static int  mv_ep_disable(struct usb_ep *_ep)
+{
+        struct mv_udc *udc;
+        struct mv_ep *ep;
+        struct mv_dqh *dqh;
+        u32 bit_pos, epctrlx, direction;
+
+        ep = container_of(_ep, struct mv_ep, ep);
+        if ((_ep == NULL) || !ep->desc)
+                return -EINVAL;
+
+        udc = ep->udc;
+
+        /* Get the endpoint queue head address */
+        dqh = ep->dqh;
+
+        direction = ep_dir(ep);
+        bit_pos = 1 << ((direction == EP_DIR_OUT ? 0 : 16) + ep->ep_num);
+
+        /* Reset the max packet length and the interrupt on Setup */
+        dqh->max_packet_length = 0;
+
+        /* Disable the endpoint for Rx or Tx and reset the endpoint type */
+        epctrlx = readl(&udc->op_regs->epctrlx[ep->ep_num]);
+        epctrlx &= ~((direction == EP_DIR_IN)
+                        ? (EPCTRL_TX_ENABLE | EPCTRL_TX_TYPE)
+                        : (EPCTRL_RX_ENABLE | EPCTRL_RX_TYPE));
+        writel(epctrlx, &udc->op_regs->epctrlx[ep->ep_num]);
+
+        /* nuke all pending requests (does flush) */
+        nuke(ep, -ESHUTDOWN);
+
+        ep->desc = NULL;
+        ep->stopped = 1;
+        return 0;
+}
+
+static struct usb_request *
+mv_alloc_request(struct usb_ep *_ep, gfp_t gfp_flags)
+{
+        struct mv_req *req = NULL;
+
+        req = kzalloc(sizeof *req, gfp_flags);
+        if (!req)
+                return NULL;
+
+        req->req.dma = DMA_ADDR_INVALID;
+        INIT_LIST_HEAD(&req->queue);
+
+        return &req->req;
+}
+
+static void mv_free_request(struct usb_ep *_ep, struct usb_request *_req)
+{
+        struct mv_req *req = NULL;
+
+        req = container_of(_req, struct mv_req, req);
+
+        if (_req)
+                kfree(req);
+}
+
+static void mv_ep_fifo_flush(struct usb_ep *_ep)
+{
+        struct mv_udc *udc;
+        u32 bit_pos, direction;
+        struct mv_ep *ep = container_of(_ep, struct mv_ep, ep);
+        unsigned int loops;
+
+        udc = ep->udc;
+        direction = ep_dir(ep);
+        bit_pos = 1 << ((direction == EP_DIR_OUT ? 0 : 16) + ep->ep_num);
+        /*
+         * Flushing will halt the pipe
+         * Write 1 to the Flush register
+         */
+        writel(bit_pos, &udc->op_regs->epflush);
+
+        /* Wait until flushing completed */
+        loops = LOOPS(FLUSH_TIMEOUT);
+        while (readl(&udc->op_regs->epflush) & bit_pos) {
+                /*
+                 * ENDPTFLUSH bit should be cleared to indicate this
+                 * operation is complete
+                 */
+                if (loops == 0) {
+                        dev_err(&udc->dev->dev,
+                                "TIMEOUT for ENDPTFLUSH=0x%x, bit_pos=0x%x\n",
+                                (unsigned)readl(&udc->op_regs->epflush),
+                                (unsigned)bit_pos);
+                        return;
+                }
+                loops--;
+                udelay(LOOPS_USEC);
+        }
+        loops = LOOPS(EPSTATUS_TIMEOUT);
+        while (readl(&udc->op_regs->epstatus) & bit_pos) {
+                unsigned int inter_loops;
+
+                if (loops == 0) {
+                        dev_err(&udc->dev->dev,
+                                "TIMEOUT for ENDPTSTATUS=0x%x, bit_pos=0x%x\n",
+                                (unsigned)readl(&udc->op_regs->epstatus),
+                                (unsigned)bit_pos);
+                        return;
+                }
+                /* Write 1 to the Flush register */
+                writel(bit_pos, &udc->op_regs->epflush);
+
+                /* Wait until flushing completed */
+                inter_loops = LOOPS(FLUSH_TIMEOUT);
+                while (readl(&udc->op_regs->epflush) & bit_pos) {
+                        /*
+                         * ENDPTFLUSH bit should be cleared to indicate this
+                         * operation is complete
+                         */
+                        if (inter_loops == 0) {
+                                dev_err(&udc->dev->dev,
+                                        "TIMEOUT for ENDPTFLUSH=0x%x,"
+                                        "bit_pos=0x%x\n",
+                                        (unsigned)readl(&udc->op_regs->epflush),
+                                        (unsigned)bit_pos);
+                                return;
+                        }
+                        inter_loops--;
+                        udelay(LOOPS_USEC);
+                }
+                loops--;
+        }
+}
+
+/* queues (submits) an I/O request to an endpoint */
+static int
+mv_ep_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
+{
+        struct mv_ep *ep = container_of(_ep, struct mv_ep, ep);
+        struct mv_req *req = container_of(_req, struct mv_req, req);
+        struct mv_udc *udc = ep->udc;
+        unsigned long flags;
+
+        /* catch various bogus parameters */
+        if (!_req || !req->req.complete || !req->req.buf
+                        || !list_empty(&req->queue)) {
+                dev_err(&udc->dev->dev, "%s, bad params", __func__);
+                return -EINVAL;
+        }
+        if (unlikely(!_ep || !ep->desc)) {
+                dev_err(&udc->dev->dev, "%s, bad ep", __func__);
+                return -EINVAL;
+        }
+        if (ep->desc->bmAttributes == USB_ENDPOINT_XFER_ISOC) {
+                if (req->req.length > ep->ep.maxpacket)
+                        return -EMSGSIZE;
+        }
+
+        udc = ep->udc;
+        if (!udc->driver || udc->gadget.speed == USB_SPEED_UNKNOWN)
+                return -ESHUTDOWN;
+
+        req->ep = ep;
+
+        /* map virtual address to hardware */
+        if (req->req.dma == DMA_ADDR_INVALID) {
+                req->req.dma = dma_map_single(ep->udc->gadget.dev.parent,
+                                        req->req.buf,
+                                        req->req.length, ep_dir(ep)
+                                                ? DMA_TO_DEVICE
+                                                : DMA_FROM_DEVICE);
+                req->mapped = 1;
+        } else {
+                dma_sync_single_for_device(ep->udc->gadget.dev.parent,
+                                        req->req.dma, req->req.length,
+                                        ep_dir(ep)
+                                                ? DMA_TO_DEVICE
+                                                : DMA_FROM_DEVICE);
+                req->mapped = 0;
+        }
+
+        req->req.status = -EINPROGRESS;
+        req->req.actual = 0;
+        req->dtd_count = 0;
+
+        spin_lock_irqsave(&udc->lock, flags);
+
+        /* build dtds and push them to device queue */
+        if (!req_to_dtd(req)) {
+                int retval;
+                retval = queue_dtd(ep, req);
+                if (retval) {
+                        spin_unlock_irqrestore(&udc->lock, flags);
+                        return retval;
+                }
+        } else {
+                spin_unlock_irqrestore(&udc->lock, flags);
+                return -ENOMEM;
+        }
+
+        /* Update ep0 state */
+        if (ep->ep_num == 0)
+                udc->ep0_state = DATA_STATE_XMIT;
+
+        /* irq handler advances the queue */
+        if (req != NULL)
+                list_add_tail(&req->queue, &ep->queue);
+        spin_unlock_irqrestore(&udc->lock, flags);
+
+        return 0;
+}
+
+/* dequeues (cancels, unlinks) an I/O request from an endpoint */
+static int mv_ep_dequeue(struct usb_ep *_ep, struct usb_request *_req)
+{
+        struct mv_ep *ep = container_of(_ep, struct mv_ep, ep);
+        struct mv_req *req;
+        struct mv_udc *udc = ep->udc;
+        unsigned long flags;
+        int stopped, ret = 0;
+        u32 epctrlx;
+
+        if (!_ep || !_req)
+                return -EINVAL;
+
+        spin_lock_irqsave(&ep->udc->lock, flags);
+        stopped = ep->stopped;
+
+        /* Stop the ep before we deal with the queue */
+        ep->stopped = 1;
+        epctrlx = readl(&udc->op_regs->epctrlx[ep->ep_num]);
+        if (ep_dir(ep) == EP_DIR_IN)
+                epctrlx &= ~EPCTRL_TX_ENABLE;
+        else
+                epctrlx &= ~EPCTRL_RX_ENABLE;
+        writel(epctrlx, &udc->op_regs->epctrlx[ep->ep_num]);
+
+        /* make sure it's actually queued on this endpoint */
+        list_for_each_entry(req, &ep->queue, queue) {
+                if (&req->req == _req)
+                        break;
+        }
+        if (&req->req != _req) {
+                ret = -EINVAL;
+                goto out;
+        }
+
+        /* The request is in progress, or completed but not dequeued */
+        if (ep->queue.next == &req->queue) {
+                _req->status = -ECONNRESET;
+                mv_ep_fifo_flush(_ep);  /* flush current transfer */
+
+                /* The request isn't the last request in this ep queue */
+                if (req->queue.next != &ep->queue) {
+                        struct mv_dqh *qh;
+                        struct mv_req *next_req;
+
+                        qh = ep->dqh;
+                        next_req = list_entry(req->queue.next, struct mv_req,
+                                        queue);
+
+                        /* Point the QH to the first TD of next request */
+                        writel((u32) next_req->head, &qh->curr_dtd_ptr);
+                } else {
+                        struct mv_dqh *qh;
+
+                        qh = ep->dqh;
+                        qh->next_dtd_ptr = 1;
+                        qh->size_ioc_int_sts = 0;
+                }
+
+                /* The request hasn't been processed, patch up the TD chain */
+        } else {
+                struct mv_req *prev_req;
+
+                prev_req = list_entry(req->queue.prev, struct mv_req, queue);
+                writel(readl(&req->tail->dtd_next),
+                                &prev_req->tail->dtd_next);
+
+        }
+
+        done(ep, req, -ECONNRESET);
+
+        /* Enable EP */
+out:
+        epctrlx = readl(&udc->op_regs->epctrlx[ep->ep_num]);
+        if (ep_dir(ep) == EP_DIR_IN)
+                epctrlx |= EPCTRL_TX_ENABLE;
+        else
+                epctrlx |= EPCTRL_RX_ENABLE;
+        writel(epctrlx, &udc->op_regs->epctrlx[ep->ep_num]);
+        ep->stopped = stopped;
+
+        spin_unlock_irqrestore(&ep->udc->lock, flags);
+        return ret;
+}
+
+static void ep_set_stall(struct mv_udc *udc, u8 ep_num, u8 direction, int stall)
+{
+        u32 epctrlx;
+
+        epctrlx = readl(&udc->op_regs->epctrlx[ep_num]);
+
+        if (stall) {
+                if (direction == EP_DIR_IN)
+                        epctrlx |= EPCTRL_TX_EP_STALL;
+                else
+                        epctrlx |= EPCTRL_RX_EP_STALL;
+        } else {
+                if (direction == EP_DIR_IN) {
+                        epctrlx &= ~EPCTRL_TX_EP_STALL;
+                        epctrlx |= EPCTRL_TX_DATA_TOGGLE_RST;
+                } else {
+                        epctrlx &= ~EPCTRL_RX_EP_STALL;
+                        epctrlx |= EPCTRL_RX_DATA_TOGGLE_RST;
+                }
+        }
+        writel(epctrlx, &udc->op_regs->epctrlx[ep_num]);
+}
+
+static int ep_is_stall(struct mv_udc *udc, u8 ep_num, u8 direction)
+{
+        u32 epctrlx;
+
+        epctrlx = readl(&udc->op_regs->epctrlx[ep_num]);
+
+        if (direction == EP_DIR_OUT)
+                return (epctrlx & EPCTRL_RX_EP_STALL) ? 1 : 0;
+        else
+                return (epctrlx & EPCTRL_TX_EP_STALL) ? 1 : 0;
+}
+
+static int mv_ep_set_halt_wedge(struct usb_ep *_ep, int halt, int wedge)
+{
+        struct mv_ep *ep;
+        unsigned long flags = 0;
+        int status = 0;
+        struct mv_udc *udc;
+
+        ep = container_of(_ep, struct mv_ep, ep);
+        udc = ep->udc;
+        if (!_ep || !ep->desc) {
+                status = -EINVAL;
+                goto out;
+        }
+
+        if (ep->desc->bmAttributes == USB_ENDPOINT_XFER_ISOC) {
+                status = -EOPNOTSUPP;
+                goto out;
+        }
+
+        /*
+         * Attempt to halt IN ep will fail if any transfer requests
+         * are still queue
+         */
+        if (halt && (ep_dir(ep) == EP_DIR_IN) && !list_empty(&ep->queue)) {
+                status = -EAGAIN;
+                goto out;
+        }
+
+        spin_lock_irqsave(&ep->udc->lock, flags);
+        ep_set_stall(udc, ep->ep_num, ep_dir(ep), halt);
+        if (halt && wedge)
+                ep->wedge = 1;
+        else if (!halt)
+                ep->wedge = 0;
+        spin_unlock_irqrestore(&ep->udc->lock, flags);
+
+        if (ep->ep_num == 0) {
+                udc->ep0_state = WAIT_FOR_SETUP;
+                udc->ep0_dir = EP_DIR_OUT;
+        }
+out:
+        return status;
+}
+
+static int mv_ep_set_halt(struct usb_ep *_ep, int halt)
+{
+        return mv_ep_set_halt_wedge(_ep, halt, 0);
+}
+
+static int mv_ep_set_wedge(struct usb_ep *_ep)
+{
+        return mv_ep_set_halt_wedge(_ep, 1, 1);
+}
+
+static struct usb_ep_ops mv_ep_ops = {
+        .enable         = mv_ep_enable,
+        .disable        = mv_ep_disable,
+
+        .alloc_request  = mv_alloc_request,
+        .free_request   = mv_free_request,
+
+        .queue          = mv_ep_queue,
+        .dequeue        = mv_ep_dequeue,
+
+        .set_wedge      = mv_ep_set_wedge,
+        .set_halt       = mv_ep_set_halt,
+        .fifo_flush     = mv_ep_fifo_flush,     /* flush fifo */
+};
+
+static void udc_stop(struct mv_udc *udc)
+{
+        u32 tmp;
+
+        /* Disable interrupts */
+        tmp = readl(&udc->op_regs->usbintr);
+        tmp &= ~(USBINTR_INT_EN | USBINTR_ERR_INT_EN |
+                USBINTR_PORT_CHANGE_DETECT_EN | USBINTR_RESET_EN);
+        writel(tmp, &udc->op_regs->usbintr);
+
+        /* Reset the Run the bit in the command register to stop VUSB */
+        tmp = readl(&udc->op_regs->usbcmd);
+        tmp &= ~USBCMD_RUN_STOP;
+        writel(tmp, &udc->op_regs->usbcmd);
+}
+
+static void udc_start(struct mv_udc *udc)
+{
+        u32 usbintr;
+
+        usbintr = USBINTR_INT_EN | USBINTR_ERR_INT_EN
+                | USBINTR_PORT_CHANGE_DETECT_EN
+                | USBINTR_RESET_EN | USBINTR_DEVICE_SUSPEND;
+        /* Enable interrupts */
+        writel(usbintr, &udc->op_regs->usbintr);
+
+        /* Set the Run bit in the command register */
+        writel(USBCMD_RUN_STOP, &udc->op_regs->usbcmd);
+}
+
+static int udc_reset(struct mv_udc *udc)
+{
+        unsigned int loops;
+        u32 tmp, portsc;
+
+        /* Stop the controller */
+        tmp = readl(&udc->op_regs->usbcmd);
+        tmp &= ~USBCMD_RUN_STOP;
+        writel(tmp, &udc->op_regs->usbcmd);
+
+        /* Reset the controller to get default values */
+        writel(USBCMD_CTRL_RESET, &udc->op_regs->usbcmd);
+
+        /* wait for reset to complete */
+        loops = LOOPS(RESET_TIMEOUT);
+        while (readl(&udc->op_regs->usbcmd) & USBCMD_CTRL_RESET) {
+                if (loops == 0) {
+                        dev_err(&udc->dev->dev,
+                                "Wait for RESET completed TIMEOUT\n");
+                        return -ETIMEDOUT;
+                }
+                loops--;
+                udelay(LOOPS_USEC);
+        }
+
+        /* set controller to device mode */
+        tmp = readl(&udc->op_regs->usbmode);
+        tmp |= USBMODE_CTRL_MODE_DEVICE;
+
+        /* turn setup lockout off, require setup tripwire in usbcmd */
+        tmp |= USBMODE_SETUP_LOCK_OFF | USBMODE_STREAM_DISABLE;
+
+        writel(tmp, &udc->op_regs->usbmode);
+
+        writel(0x0, &udc->op_regs->epsetupstat);
+
+        /* Configure the Endpoint List Address */
+        writel(udc->ep_dqh_dma & USB_EP_LIST_ADDRESS_MASK,
+                &udc->op_regs->eplistaddr);
+
+        portsc = readl(&udc->op_regs->portsc[0]);
+        if (readl(&udc->cap_regs->hcsparams) & HCSPARAMS_PPC)
+                portsc &= (~PORTSCX_W1C_BITS | ~PORTSCX_PORT_POWER);
+
+        if (udc->force_fs)
+                portsc |= PORTSCX_FORCE_FULL_SPEED_CONNECT;
+        else
+                portsc &= (~PORTSCX_FORCE_FULL_SPEED_CONNECT);
+
+        writel(portsc, &udc->op_regs->portsc[0]);
+
+        tmp = readl(&udc->op_regs->epctrlx[0]);
+        tmp &= ~(EPCTRL_TX_EP_STALL | EPCTRL_RX_EP_STALL);
+        writel(tmp, &udc->op_regs->epctrlx[0]);
+
+        return 0;
+}
+
+static int mv_udc_get_frame(struct usb_gadget *gadget)
+{
+        struct mv_udc *udc;
+        u16     retval;
+
+        if (!gadget)
+                return -ENODEV;
+
+        udc = container_of(gadget, struct mv_udc, gadget);
+
+        retval = readl(udc->op_regs->frindex) & USB_FRINDEX_MASKS;
+
+        return retval;
+}
+
+/* Tries to wake up the host connected to this gadget */
+static int mv_udc_wakeup(struct usb_gadget *gadget)
+{
+        struct mv_udc *udc = container_of(gadget, struct mv_udc, gadget);
+        u32 portsc;
+
+        /* Remote wakeup feature not enabled by host */
+        if (!udc->remote_wakeup)
+                return -ENOTSUPP;
+
+        portsc = readl(&udc->op_regs->portsc);
+        /* not suspended? */
+        if (!(portsc & PORTSCX_PORT_SUSPEND))
+                return 0;
+        /* trigger force resume */
+        portsc |= PORTSCX_PORT_FORCE_RESUME;
+        writel(portsc, &udc->op_regs->portsc[0]);
+        return 0;
+}
+
+static int mv_udc_pullup(struct usb_gadget *gadget, int is_on)
+{
+        struct mv_udc *udc;
+        unsigned long flags;
+
+        udc = container_of(gadget, struct mv_udc, gadget);
+        spin_lock_irqsave(&udc->lock, flags);
+
+        udc->softconnect = (is_on != 0);
+        if (udc->driver && udc->softconnect)
+                udc_start(udc);
+        else
+                udc_stop(udc);
+
+        spin_unlock_irqrestore(&udc->lock, flags);
+        return 0;
+}
+
+/* device controller usb_gadget_ops structure */
+static const struct usb_gadget_ops mv_ops = {
+
+        /* returns the current frame number */
+        .get_frame      = mv_udc_get_frame,
+
+        /* tries to wake up the host connected to this gadget */
+        .wakeup         = mv_udc_wakeup,
+
+        /* D+ pullup, software-controlled connect/disconnect to USB host */
+        .pullup         = mv_udc_pullup,
+};
+
+static void mv_udc_testmode(struct mv_udc *udc, u16 index, bool enter)
+{
+        dev_info(&udc->dev->dev, "Test Mode is not support yet\n");
+}
+
+static int eps_init(struct mv_udc *udc)
+{
+        struct mv_ep    *ep;
+        char name[14];
+        int i;
+
+        /* initialize ep0 */
+        ep = &udc->eps[0];
+        ep->udc = udc;
+        strncpy(ep->name, "ep0", sizeof(ep->name));
+        ep->ep.name = ep->name;
+        ep->ep.ops = &mv_ep_ops;
+        ep->wedge = 0;
+        ep->stopped = 0;
+        ep->ep.maxpacket = EP0_MAX_PKT_SIZE;
+        ep->ep_num = 0;
+        ep->desc = &mv_ep0_desc;
+        INIT_LIST_HEAD(&ep->queue);
+
+        ep->ep_type = USB_ENDPOINT_XFER_CONTROL;
+
+        /* initialize other endpoints */
+        for (i = 2; i < udc->max_eps * 2; i++) {
+                ep = &udc->eps[i];
+                if (i % 2) {
+                        snprintf(name, sizeof(name), "ep%din", i / 2);
+                        ep->direction = EP_DIR_IN;
+                } else {
+                        snprintf(name, sizeof(name), "ep%dout", i / 2);
+                        ep->direction = EP_DIR_OUT;
+                }
+                ep->udc = udc;
+                strncpy(ep->name, name, sizeof(ep->name));
+                ep->ep.name = ep->name;
+
+                ep->ep.ops = &mv_ep_ops;
+                ep->stopped = 0;
+                ep->ep.maxpacket = (unsigned short) ~0;
+                ep->ep_num = i / 2;
+
+                INIT_LIST_HEAD(&ep->queue);
+                list_add_tail(&ep->ep.ep_list, &udc->gadget.ep_list);
+
+                ep->dqh = &udc->ep_dqh[i];
+        }
+
+        return 0;
+}
+
+/* delete all endpoint requests, called with spinlock held */
+static void nuke(struct mv_ep *ep, int status)
+{
+        /* called with spinlock held */
+        ep->stopped = 1;
+
+        /* endpoint fifo flush */
+        mv_ep_fifo_flush(&ep->ep);
+
+        while (!list_empty(&ep->queue)) {
+                struct mv_req *req = NULL;
+                req = list_entry(ep->queue.next, struct mv_req, queue);
+                done(ep, req, status);
+        }
+}
+
+/* stop all USB activities */
+static void stop_activity(struct mv_udc *udc, struct usb_gadget_driver *driver)
+{
+        struct mv_ep    *ep;
+
+        nuke(&udc->eps[0], -ESHUTDOWN);
+
+        list_for_each_entry(ep, &udc->gadget.ep_list, ep.ep_list) {
+                nuke(ep, -ESHUTDOWN);
+        }
+
+        /* report disconnect; the driver is already quiesced */
+        if (driver) {
+                spin_unlock(&udc->lock);
+                driver->disconnect(&udc->gadget);
+                spin_lock(&udc->lock);
+        }
+}
+
+int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
+                int (*bind)(struct usb_gadget *))
+{
+        struct mv_udc *udc = the_controller;
+        int retval = 0;
+        unsigned long flags;
+
+        if (!udc)
+                return -ENODEV;
+
+        if (udc->driver)
+                return -EBUSY;
+
+        spin_lock_irqsave(&udc->lock, flags);
+
+        /* hook up the driver ... */
+        driver->driver.bus = NULL;
+        udc->driver = driver;
+        udc->gadget.dev.driver = &driver->driver;
+
+        udc->usb_state = USB_STATE_ATTACHED;
+        udc->ep0_state = WAIT_FOR_SETUP;
+        udc->ep0_dir = USB_DIR_OUT;
+
+        spin_unlock_irqrestore(&udc->lock, flags);
+
+        retval = bind(&udc->gadget);
+        if (retval) {
+                dev_err(&udc->dev->dev, "bind to driver %s --> %d\n",
+                                driver->driver.name, retval);
+                udc->driver = NULL;
+                udc->gadget.dev.driver = NULL;
+                return retval;
+        }
+        udc_reset(udc);
+        ep0_reset(udc);
+        udc_start(udc);
+
+        return 0;
+}
+EXPORT_SYMBOL(usb_gadget_probe_driver);
+
+int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
+{
+        struct mv_udc *udc = the_controller;
+        unsigned long flags;
+
+        if (!udc)
+                return -ENODEV;
+
+        udc_stop(udc);
+
+        spin_lock_irqsave(&udc->lock, flags);
+
+        /* stop all usb activities */
+        udc->gadget.speed = USB_SPEED_UNKNOWN;
+        stop_activity(udc, driver);
+        spin_unlock_irqrestore(&udc->lock, flags);
+
+        /* unbind gadget driver */
+        driver->unbind(&udc->gadget);
+        udc->gadget.dev.driver = NULL;
+        udc->driver = NULL;
+
+        return 0;
+}
+EXPORT_SYMBOL(usb_gadget_unregister_driver);
+
+static int
+udc_prime_status(struct mv_udc *udc, u8 direction, u16 status, bool empty)
+{
+        int retval = 0;
+        struct mv_req *req;
+        struct mv_ep *ep;
+
+        ep = &udc->eps[0];
+        udc->ep0_dir = direction;
+
+        req = udc->status_req;
+
+        /* fill in the reqest structure */
+        if (empty == false) {
+                *((u16 *) req->req.buf) = cpu_to_le16(status);
+                req->req.length = 2;
+        } else
+                req->req.length = 0;
+
+        req->ep = ep;
+        req->req.status = -EINPROGRESS;
+        req->req.actual = 0;
+        req->req.complete = NULL;
+        req->dtd_count = 0;
+
+        /* prime the data phase */
+        if (!req_to_dtd(req))
+                retval = queue_dtd(ep, req);
+        else{   /* no mem */
+                retval = -ENOMEM;
+                goto out;
+        }
+
+        if (retval) {
+                dev_err(&udc->dev->dev, "response error on GET_STATUS request\n");
+                goto out;
+        }
+
+        list_add_tail(&req->queue, &ep->queue);
+
+        return 0;
+out:
+        return retval;
+}
+
+static void ch9setaddress(struct mv_udc *udc, struct usb_ctrlrequest *setup)
+{
+        udc->dev_addr = (u8)setup->wValue;
+
+        /* update usb state */
+        udc->usb_state = USB_STATE_ADDRESS;
+
+        if (udc_prime_status(udc, EP_DIR_IN, 0, true))
+                ep0_stall(udc);
+}
+
+static void ch9getstatus(struct mv_udc *udc, u8 ep_num,
+        struct usb_ctrlrequest *setup)
+{
+        u16 status;
+        int retval;
+
+        if ((setup->bRequestType & (USB_DIR_IN | USB_TYPE_MASK))
+                != (USB_DIR_IN | USB_TYPE_STANDARD))
+                return;
+
+        if ((setup->bRequestType & USB_RECIP_MASK) == USB_RECIP_DEVICE) {
+                status = 1 << USB_DEVICE_SELF_POWERED;
+                status |= udc->remote_wakeup << USB_DEVICE_REMOTE_WAKEUP;
+        } else if ((setup->bRequestType & USB_RECIP_MASK)
+                        == USB_RECIP_INTERFACE) {
+                /* get interface status */
+                status = 0;
+        } else if ((setup->bRequestType & USB_RECIP_MASK)
+                        == USB_RECIP_ENDPOINT) {
+                u8 ep_num, direction;
+
+                ep_num = setup->wIndex & USB_ENDPOINT_NUMBER_MASK;
+                direction = (setup->wIndex & USB_ENDPOINT_DIR_MASK)
+                                ? EP_DIR_IN : EP_DIR_OUT;
+                status = ep_is_stall(udc, ep_num, direction)
+                                << USB_ENDPOINT_HALT;
+        }
+
+        retval = udc_prime_status(udc, EP_DIR_IN, status, false);
+        if (retval)
+                ep0_stall(udc);
+}
+
+static void ch9clearfeature(struct mv_udc *udc, struct usb_ctrlrequest *setup)
+{
+        u8 ep_num;
+        u8 direction;
+        struct mv_ep *ep;
+
+        if ((setup->bRequestType & (USB_TYPE_MASK | USB_RECIP_MASK))
+                == ((USB_TYPE_STANDARD | USB_RECIP_DEVICE))) {
+                switch (setup->wValue) {
+                case USB_DEVICE_REMOTE_WAKEUP:
+                        udc->remote_wakeup = 0;
+                        break;
+                case USB_DEVICE_TEST_MODE:
+                        mv_udc_testmode(udc, 0, false);
+                        break;
+                default:
+                        goto out;
+                }
+        } else if ((setup->bRequestType & (USB_TYPE_MASK | USB_RECIP_MASK))
+                == ((USB_TYPE_STANDARD | USB_RECIP_ENDPOINT))) {
+                switch (setup->wValue) {
+                case USB_ENDPOINT_HALT:
+                        ep_num = setup->wIndex & USB_ENDPOINT_NUMBER_MASK;
+                        direction = (setup->wIndex & USB_ENDPOINT_DIR_MASK)
+                                ? EP_DIR_IN : EP_DIR_OUT;
+                        if (setup->wValue != 0 || setup->wLength != 0
+                                || ep_num > udc->max_eps)
+                                goto out;
+                        ep = &udc->eps[ep_num * 2 + direction];
+                        if (ep->wedge == 1)
+                                break;
+                        spin_unlock(&udc->lock);
+                        ep_set_stall(udc, ep_num, direction, 0);
+                        spin_lock(&udc->lock);
+                        break;
+                default:
+                        goto out;
+                }
+        } else
+                goto out;
+
+        if (udc_prime_status(udc, EP_DIR_IN, 0, true))
+                ep0_stall(udc);
+        else
+                udc->ep0_state = DATA_STATE_XMIT;
+out:
+        return;
+}
+
+static void ch9setfeature(struct mv_udc *udc, struct usb_ctrlrequest *setup)
+{
+        u8 ep_num;
+        u8 direction;
+
+        if ((setup->bRequestType & (USB_TYPE_MASK | USB_RECIP_MASK))
+                == ((USB_TYPE_STANDARD | USB_RECIP_DEVICE))) {
+                switch (setup->wValue) {
+                case USB_DEVICE_REMOTE_WAKEUP:
+                        udc->remote_wakeup = 1;
+                        break;
+                case USB_DEVICE_TEST_MODE:
+                        if (setup->wIndex & 0xFF
+                                && udc->gadget.speed != USB_SPEED_HIGH)
+                                goto out;
+                        if (udc->usb_state == USB_STATE_CONFIGURED
+                                || udc->usb_state == USB_STATE_ADDRESS
+                                || udc->usb_state == USB_STATE_DEFAULT)
+                                mv_udc_testmode(udc,
+                                        setup->wIndex & 0xFF00, true);
+                        else
+                                goto out;
+                        break;
+                default:
+                        goto out;
+                }
+        } else if ((setup->bRequestType & (USB_TYPE_MASK | USB_RECIP_MASK))
+                == ((USB_TYPE_STANDARD | USB_RECIP_ENDPOINT))) {
+                switch (setup->wValue) {
+                case USB_ENDPOINT_HALT:
+                        ep_num = setup->wIndex & USB_ENDPOINT_NUMBER_MASK;
+                        direction = (setup->wIndex & USB_ENDPOINT_DIR_MASK)
+                                ? EP_DIR_IN : EP_DIR_OUT;
+                        if (setup->wValue != 0 || setup->wLength != 0
+                                || ep_num > udc->max_eps)
+                                goto out;
+                        spin_unlock(&udc->lock);
+                        ep_set_stall(udc, ep_num, direction, 1);
+                        spin_lock(&udc->lock);
+                        break;
+                default:
+                        goto out;
+                }
+        } else
+                goto out;
+
+        if (udc_prime_status(udc, EP_DIR_IN, 0, true))
+                ep0_stall(udc);
+out:
+        return;
+}
+
+static void handle_setup_packet(struct mv_udc *udc, u8 ep_num,
+        struct usb_ctrlrequest *setup)
+{
+        bool delegate = false;
+
+        nuke(&udc->eps[ep_num * 2 + EP_DIR_OUT], -ESHUTDOWN);
+
+        dev_dbg(&udc->dev->dev, "SETUP %02x.%02x v%04x i%04x l%04x\n",
+                        setup->bRequestType, setup->bRequest,
+                        setup->wValue, setup->wIndex, setup->wLength);
+        /* We process some stardard setup requests here */
+        if ((setup->bRequestType & USB_TYPE_MASK) == USB_TYPE_STANDARD) {
+                switch (setup->bRequest) {
+                case USB_REQ_GET_STATUS:
+                        ch9getstatus(udc, ep_num, setup);
+                        break;
+
+                case USB_REQ_SET_ADDRESS:
+                        ch9setaddress(udc, setup);
+                        break;
+
+                case USB_REQ_CLEAR_FEATURE:
+                        ch9clearfeature(udc, setup);
+                        break;
+
+                case USB_REQ_SET_FEATURE:
+                        ch9setfeature(udc, setup);
+                        break;
+
+                default:
+                        delegate = true;
+                }
+        } else
+                delegate = true;
+
+        /* delegate USB standard requests to the gadget driver */
+        if (delegate == true) {
+                /* USB requests handled by gadget */
+                if (setup->wLength) {
+                        /* DATA phase from gadget, STATUS phase from udc */
+                        udc->ep0_dir = (setup->bRequestType & USB_DIR_IN)
+                                        ?  EP_DIR_IN : EP_DIR_OUT;
+                        spin_unlock(&udc->lock);
+                        if (udc->driver->setup(&udc->gadget,
+                                &udc->local_setup_buff) < 0)
+                                ep0_stall(udc);
+                        spin_lock(&udc->lock);
+                        udc->ep0_state = (setup->bRequestType & USB_DIR_IN)
+                                        ?  DATA_STATE_XMIT : DATA_STATE_RECV;
+                } else {
+                        /* no DATA phase, IN STATUS phase from gadget */
+                        udc->ep0_dir = EP_DIR_IN;
+                        spin_unlock(&udc->lock);
+                        if (udc->driver->setup(&udc->gadget,
+                                &udc->local_setup_buff) < 0)
+                                ep0_stall(udc);
+                        spin_lock(&udc->lock);
+                        udc->ep0_state = WAIT_FOR_OUT_STATUS;
+                }
+        }
+}
+
+/* complete DATA or STATUS phase of ep0 prime status phase if needed */
+static void ep0_req_complete(struct mv_udc *udc,
+        struct mv_ep *ep0, struct mv_req *req)
+{
+        u32 new_addr;
+
+        if (udc->usb_state == USB_STATE_ADDRESS) {
+                /* set the new address */
+                new_addr = (u32)udc->dev_addr;
+                writel(new_addr << USB_DEVICE_ADDRESS_BIT_SHIFT,
+                        &udc->op_regs->deviceaddr);
+        }
+
+        done(ep0, req, 0);
+
+        switch (udc->ep0_state) {
+        case DATA_STATE_XMIT:
+                /* receive status phase */
+                if (udc_prime_status(udc, EP_DIR_OUT, 0, true))
+                        ep0_stall(udc);
+                break;
+        case DATA_STATE_RECV:
+                /* send status phase */
+                if (udc_prime_status(udc, EP_DIR_IN, 0 , true))
+                        ep0_stall(udc);
+                break;
+        case WAIT_FOR_OUT_STATUS:
+                udc->ep0_state = WAIT_FOR_SETUP;
+                break;
+        case WAIT_FOR_SETUP:
+                dev_err(&udc->dev->dev, "unexpect ep0 packets\n");
+                break;
+        default:
+                ep0_stall(udc);
+                break;
+        }
+}
+
+static void get_setup_data(struct mv_udc *udc, u8 ep_num, u8 *buffer_ptr)
+{
+        u32 temp;
+        struct mv_dqh *dqh;
+
+        dqh = &udc->ep_dqh[ep_num * 2 + EP_DIR_OUT];
+
+        /* Clear bit in ENDPTSETUPSTAT */
+        temp = readl(&udc->op_regs->epsetupstat);
+        writel(temp | (1 << ep_num), &udc->op_regs->epsetupstat);
+
+        /* while a hazard exists when setup package arrives */
+        do {
+                /* Set Setup Tripwire */
+                temp = readl(&udc->op_regs->usbcmd);
+                writel(temp | USBCMD_SETUP_TRIPWIRE_SET, &udc->op_regs->usbcmd);
+
+                /* Copy the setup packet to local buffer */
+                memcpy(buffer_ptr, (u8 *) dqh->setup_buffer, 8);
+        } while (!(readl(&udc->op_regs->usbcmd) & USBCMD_SETUP_TRIPWIRE_SET));
+
+        /* Clear Setup Tripwire */
+        temp = readl(&udc->op_regs->usbcmd);
+        writel(temp & ~USBCMD_SETUP_TRIPWIRE_SET, &udc->op_regs->usbcmd);
+}
+
+static void irq_process_tr_complete(struct mv_udc *udc)
+{
+        u32 tmp, bit_pos;
+        int i, ep_num = 0, direction = 0;
+        struct mv_ep    *curr_ep;
+        struct mv_req *curr_req, *temp_req;
+        int status;
+
+        /*
+         * We use separate loops for ENDPTSETUPSTAT and ENDPTCOMPLETE
+         * because the setup packets are to be read ASAP
+         */
+
+        /* Process all Setup packet received interrupts */
+        tmp = readl(&udc->op_regs->epsetupstat);
+
+        if (tmp) {
+                for (i = 0; i < udc->max_eps; i++) {
+                        if (tmp & (1 << i)) {
+                                get_setup_data(udc, i,
+                                        (u8 *)(&udc->local_setup_buff));
+                                handle_setup_packet(udc, i,
+                                        &udc->local_setup_buff);
+                        }
+                }
+        }
+
+        /* Don't clear the endpoint setup status register here.
+         * It is cleared as a setup packet is read out of the buffer
+         */
+
+        /* Process non-setup transaction complete interrupts */
+        tmp = readl(&udc->op_regs->epcomplete);
+
+        if (!tmp)
+                return;
+
+        writel(tmp, &udc->op_regs->epcomplete);
+
+        for (i = 0; i < udc->max_eps * 2; i++) {
+                ep_num = i >> 1;
+                direction = i % 2;
+
+                bit_pos = 1 << (ep_num + 16 * direction);
+
+                if (!(bit_pos & tmp))
+                        continue;
+
+                if (i == 1)
+                        curr_ep = &udc->eps[0];
+                else
+                        curr_ep = &udc->eps[i];
+                /* process the req queue until an uncomplete request */
+                list_for_each_entry_safe(curr_req, temp_req,
+                        &curr_ep->queue, queue) {
+                        status = process_ep_req(udc, i, curr_req);
+                        if (status)
+                                break;
+
+                        /* write back status to req */
+                        curr_req->req.status = status;
+
+                        /* ep0 request completion */
+                        if (ep_num == 0) {
+                                ep0_req_complete(udc, curr_ep, curr_req);
+                                break;
+                        } else {
+                                done(curr_ep, curr_req, status);
+                        }
+                }
+        }
+}
+
+void irq_process_reset(struct mv_udc *udc)
+{
+        u32 tmp;
+        unsigned int loops;
+
+        udc->ep0_dir = EP_DIR_OUT;
+        udc->ep0_state = WAIT_FOR_SETUP;
+        udc->remote_wakeup = 0;         /* default to 0 on reset */
+
+        /* The address bits are past bit 25-31. Set the address */
+        tmp = readl(&udc->op_regs->deviceaddr);
+        tmp &= ~(USB_DEVICE_ADDRESS_MASK);
+        writel(tmp, &udc->op_regs->deviceaddr);
+
+        /* Clear all the setup token semaphores */
+        tmp = readl(&udc->op_regs->epsetupstat);
+        writel(tmp, &udc->op_regs->epsetupstat);
+
+        /* Clear all the endpoint complete status bits */
+        tmp = readl(&udc->op_regs->epcomplete);
+        writel(tmp, &udc->op_regs->epcomplete);
+
+        /* wait until all endptprime bits cleared */
+        loops = LOOPS(PRIME_TIMEOUT);
+        while (readl(&udc->op_regs->epprime) & 0xFFFFFFFF) {
+                if (loops == 0) {
+                        dev_err(&udc->dev->dev,
+                                "Timeout for ENDPTPRIME = 0x%x\n",
+                                readl(&udc->op_regs->epprime));
+                        break;
+                }
+                loops--;
+                udelay(LOOPS_USEC);
+        }
+
+        /* Write 1s to the Flush register */
+        writel((u32)~0, &udc->op_regs->epflush);
+
+        if (readl(&udc->op_regs->portsc[0]) & PORTSCX_PORT_RESET) {
+                dev_info(&udc->dev->dev, "usb bus reset\n");
+                udc->usb_state = USB_STATE_DEFAULT;
+                /* reset all the queues, stop all USB activities */
+                stop_activity(udc, udc->driver);
+        } else {
+                dev_info(&udc->dev->dev, "USB reset portsc 0x%x\n",
+                        readl(&udc->op_regs->portsc));
+
+                /*
+                 * re-initialize
+                 * controller reset
+                 */
+                udc_reset(udc);
+
+                /* reset all the queues, stop all USB activities */
+                stop_activity(udc, udc->driver);
+
+                /* reset ep0 dQH and endptctrl */
+                ep0_reset(udc);
+
+                /* enable interrupt and set controller to run state */
+                udc_start(udc);
+
+                udc->usb_state = USB_STATE_ATTACHED;
+        }
+}
+
+static void handle_bus_resume(struct mv_udc *udc)
+{
+        udc->usb_state = udc->resume_state;
+        udc->resume_state = 0;
+
+        /* report resume to the driver */
+        if (udc->driver) {
+                if (udc->driver->resume) {
+                        spin_unlock(&udc->lock);
+                        udc->driver->resume(&udc->gadget);
+                        spin_lock(&udc->lock);
+                }
+        }
+}
+
+static void irq_process_suspend(struct mv_udc *udc)
+{
+        udc->resume_state = udc->usb_state;
+        udc->usb_state = USB_STATE_SUSPENDED;
+
+        if (udc->driver->suspend) {
+                spin_unlock(&udc->lock);
+                udc->driver->suspend(&udc->gadget);
+                spin_lock(&udc->lock);
+        }
+}
+
+static void irq_process_port_change(struct mv_udc *udc)
+{
+        u32 portsc;
+
+        portsc = readl(&udc->op_regs->portsc[0]);
+        if (!(portsc & PORTSCX_PORT_RESET)) {
+                /* Get the speed */
+                u32 speed = portsc & PORTSCX_PORT_SPEED_MASK;
+                switch (speed) {
+                case PORTSCX_PORT_SPEED_HIGH:
+                        udc->gadget.speed = USB_SPEED_HIGH;
+                        break;
+                case PORTSCX_PORT_SPEED_FULL:
+                        udc->gadget.speed = USB_SPEED_FULL;
+                        break;
+                case PORTSCX_PORT_SPEED_LOW:
+                        udc->gadget.speed = USB_SPEED_LOW;
+                        break;
+                default:
+                        udc->gadget.speed = USB_SPEED_UNKNOWN;
+                        break;
+                }
+        }
+
+        if (portsc & PORTSCX_PORT_SUSPEND) {
+                udc->resume_state = udc->usb_state;
+                udc->usb_state = USB_STATE_SUSPENDED;
+                if (udc->driver->suspend) {
+                        spin_unlock(&udc->lock);
+                        udc->driver->suspend(&udc->gadget);
+                        spin_lock(&udc->lock);
+                }
+        }
+
+        if (!(portsc & PORTSCX_PORT_SUSPEND)
+                && udc->usb_state == USB_STATE_SUSPENDED) {
+                handle_bus_resume(udc);
+        }
+
+        if (!udc->resume_state)
+                udc->usb_state = USB_STATE_DEFAULT;
+}
+
+static void irq_process_error(struct mv_udc *udc)
+{
+        /* Increment the error count */
+        udc->errors++;
+}
+
+static irqreturn_t mv_udc_irq(int irq, void *dev)
+{
+        struct mv_udc *udc = (struct mv_udc *)dev;
+        u32 status, intr;
+
+        spin_lock(&udc->lock);
+
+        status = readl(&udc->op_regs->usbsts);
+        intr = readl(&udc->op_regs->usbintr);
+        status &= intr;
+
+        if (status == 0) {
+                spin_unlock(&udc->lock);
+                return IRQ_NONE;
+        }
+
+        /* Clear all the interrupts occurred */
+        writel(status, &udc->op_regs->usbsts);
+
+        if (status & USBSTS_ERR)
+                irq_process_error(udc);
+
+        if (status & USBSTS_RESET)
+                irq_process_reset(udc);
+
+        if (status & USBSTS_PORT_CHANGE)
+                irq_process_port_change(udc);
+
+        if (status & USBSTS_INT)
+                irq_process_tr_complete(udc);
+
+        if (status & USBSTS_SUSPEND)
+                irq_process_suspend(udc);
+
+        spin_unlock(&udc->lock);
+
+        return IRQ_HANDLED;
+}
+
+/* release device structure */
+static void gadget_release(struct device *_dev)
+{
+        struct mv_udc *udc = the_controller;
+
+        complete(udc->done);
+        kfree(udc);
+}
+
+static int mv_udc_remove(struct platform_device *dev)
+{
+        struct mv_udc *udc = the_controller;
+
+        DECLARE_COMPLETION(done);
+
+        udc->done = &done;
+
+        /* free memory allocated in probe */
+        if (udc->dtd_pool)
+                dma_pool_destroy(udc->dtd_pool);
+
+        if (udc->ep_dqh)
+                dma_free_coherent(&dev->dev, udc->ep_dqh_size,
+                        udc->ep_dqh, udc->ep_dqh_dma);
+
+        kfree(udc->eps);
+
+        if (udc->irq)
+                free_irq(udc->irq, &dev->dev);
+
+        if (udc->cap_regs)
+                iounmap(udc->cap_regs);
+        udc->cap_regs = NULL;
+
+        if (udc->phy_regs)
+                iounmap((void *)udc->phy_regs);
+        udc->phy_regs = 0;
+
+        if (udc->status_req) {
+                kfree(udc->status_req->req.buf);
+                kfree(udc->status_req);
+        }
+
+        device_unregister(&udc->gadget.dev);
+
+        /* free dev, wait for the release() finished */
+        wait_for_completion(&done);
+
+        the_controller = NULL;
+
+        return 0;
+}
+
+int mv_udc_probe(struct platform_device *dev)
+{
+        struct mv_udc *udc;
+        int retval = 0;
+        struct resource *r;
+        size_t size;
+
+        udc = kzalloc(sizeof *udc, GFP_KERNEL);
+        if (udc == NULL) {
+                dev_err(&dev->dev, "failed to allocate memory for udc\n");
+                retval = -ENOMEM;
+                goto error;
+        }
+
+        spin_lock_init(&udc->lock);
+
+        udc->dev = dev;
+
+        udc->clk = clk_get(&dev->dev, "U2OCLK");
+        if (IS_ERR(udc->clk)) {
+                retval = PTR_ERR(udc->clk);
+                goto error;
+        }
+
+        r = platform_get_resource_byname(udc->dev, IORESOURCE_MEM, "u2o");
+        if (r == NULL) {
+                dev_err(&dev->dev, "no I/O memory resource defined\n");
+                retval = -ENODEV;
+                goto error;
+        }
+
+        udc->cap_regs = (struct mv_cap_regs __iomem *)
+                ioremap(r->start, resource_size(r));
+        if (udc->cap_regs == NULL) {
+                dev_err(&dev->dev, "failed to map I/O memory\n");
+                retval = -EBUSY;
+                goto error;
+        }
+
+        r = platform_get_resource_byname(udc->dev, IORESOURCE_MEM, "u2ophy");
+        if (r == NULL) {
+                dev_err(&dev->dev, "no phy I/O memory resource defined\n");
+                retval = -ENODEV;
+                goto error;
+        }
+
+        udc->phy_regs = (unsigned int)ioremap(r->start, resource_size(r));
+        if (udc->phy_regs == 0) {
+                dev_err(&dev->dev, "failed to map phy I/O memory\n");
+                retval = -EBUSY;
+                goto error;
+        }
+
+        /* we will acces controller register, so enable the clk */
+        clk_enable(udc->clk);
+        retval = mv_udc_phy_init(udc->phy_regs);
+        if (retval) {
+                dev_err(&dev->dev, "phy initialization error %d\n", retval);
+                goto error;
+        }
+
+        udc->op_regs = (struct mv_op_regs __iomem *)((u32)udc->cap_regs
+                + (readl(&udc->cap_regs->caplength_hciversion)
+                        & CAPLENGTH_MASK));
+        udc->max_eps = readl(&udc->cap_regs->dccparams) & DCCPARAMS_DEN_MASK;
+
+        size = udc->max_eps * sizeof(struct mv_dqh) *2;
+        size = (size + DQH_ALIGNMENT - 1) & ~(DQH_ALIGNMENT - 1);
+        udc->ep_dqh = dma_alloc_coherent(&dev->dev, size,
+                                        &udc->ep_dqh_dma, GFP_KERNEL);
+
+        if (udc->ep_dqh == NULL) {
+                dev_err(&dev->dev, "allocate dQH memory failed\n");
+                retval = -ENOMEM;
+                goto error;
+        }
+        udc->ep_dqh_size = size;
+
+        /* create dTD dma_pool resource */
+        udc->dtd_pool = dma_pool_create("mv_dtd",
+                        &dev->dev,
+                        sizeof(struct mv_dtd),
+                        DTD_ALIGNMENT,
+                        DMA_BOUNDARY);
+
+        if (!udc->dtd_pool) {
+                retval = -ENOMEM;
+                goto error;
+        }
+
+        size = udc->max_eps * sizeof(struct mv_ep) *2;
+        udc->eps = kzalloc(size, GFP_KERNEL);
+        if (udc->eps == NULL) {
+                dev_err(&dev->dev, "allocate ep memory failed\n");
+                retval = -ENOMEM;
+                goto error;
+        }
+
+        /* initialize ep0 status request structure */
+        udc->status_req = kzalloc(sizeof(struct mv_req), GFP_KERNEL);
+        if (!udc->status_req) {
+                dev_err(&dev->dev, "allocate status_req memory failed\n");
+                retval = -ENOMEM;
+                goto error;
+        }
+        INIT_LIST_HEAD(&udc->status_req->queue);
+
+        /* allocate a small amount of memory to get valid address */
+        udc->status_req->req.buf = kzalloc(8, GFP_KERNEL);
+        udc->status_req->req.dma = virt_to_phys(udc->status_req->req.buf);
+
+        udc->resume_state = USB_STATE_NOTATTACHED;
+        udc->usb_state = USB_STATE_POWERED;
+        udc->ep0_dir = EP_DIR_OUT;
+        udc->remote_wakeup = 0;
+
+        r = platform_get_resource(udc->dev, IORESOURCE_IRQ, 0);
+        if (r == NULL) {
+                dev_err(&dev->dev, "no IRQ resource defined\n");
+                retval = -ENODEV;
+                goto error;
+        }
+        udc->irq = r->start;
+        if (request_irq(udc->irq, mv_udc_irq,
+                IRQF_DISABLED | IRQF_SHARED, driver_name, udc)) {
+                dev_err(&dev->dev, "Request irq %d for UDC failed\n",
+                        udc->irq);
+                retval = -ENODEV;
+                goto error;
+        }
+
+        /* initialize gadget structure */
+        udc->gadget.ops = &mv_ops;      /* usb_gadget_ops */
+        udc->gadget.ep0 = &udc->eps[0].ep;      /* gadget ep0 */
+        INIT_LIST_HEAD(&udc->gadget.ep_list);   /* ep_list */
+        udc->gadget.speed = USB_SPEED_UNKNOWN;  /* speed */
+        udc->gadget.is_dualspeed = 1;           /* support dual speed */
+
+        /* the "gadget" abstracts/virtualizes the controller */
+        dev_set_name(&udc->gadget.dev, "gadget");
+        udc->gadget.dev.parent = &dev->dev;
+        udc->gadget.dev.dma_mask = dev->dev.dma_mask;
+        udc->gadget.dev.release = gadget_release;
+        udc->gadget.name = driver_name;         /* gadget name */
+
+        retval = device_register(&udc->gadget.dev);
+        if (retval)
+                goto error;
+
+        eps_init(udc);
+
+        the_controller = udc;
+
+        goto out;
+error:
+        if (udc)
+                mv_udc_remove(udc->dev);
+out:
+        return retval;
+}
+
+#ifdef CONFIG_PM
+static int mv_udc_suspend(struct device *_dev)
+{
+        struct mv_udc *udc = the_controller;
+
+        udc_stop(udc);
+
+        return 0;
+}
+
+static int mv_udc_resume(struct device *_dev)
+{
+        struct mv_udc *udc = the_controller;
+        int retval;
+
+        retval = mv_udc_phy_init(udc->phy_regs);
+        if (retval) {
+                dev_err(_dev, "phy initialization error %d\n", retval);
+                return retval;
+        }
+        udc_reset(udc);
+        ep0_reset(udc);
+        udc_start(udc);
+
+        return 0;
+}
+
+static const struct dev_pm_ops mv_udc_pm_ops = {
+        .suspend        = mv_udc_suspend,
+        .resume         = mv_udc_resume,
+};
+#endif
+
+static struct platform_driver udc_driver = {
+        .probe          = mv_udc_probe,
+        .remove         = __exit_p(mv_udc_remove),
+        .driver         = {
+                .owner  = THIS_MODULE,
+                .name   = "pxa-u2o",
+#ifdef CONFIG_PM
+                .pm     = &mv_udc_pm_ops,
+#endif
+        },
+};
+
+
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_AUTHOR("Chao Xie <chao.xie@marvell.com>");
+MODULE_VERSION(DRIVER_VERSION);
+MODULE_LICENSE("GPL");
+
+
+static int __init init(void)
+{
+        return platform_driver_register(&udc_driver);
+}
+module_init(init);
+
+
+static void __exit cleanup(void)
+{
+        platform_driver_unregister(&udc_driver);
+}
+module_exit(cleanup);
+
diff --git a/drivers/usb/gadget/mv_udc_phy.c b/drivers/usb/gadget/mv_udc_phy.c
new file mode 100644
index 000000000000..d4dea97e38a5
--- /dev/null
+++ b/drivers/usb/gadget/mv_udc_phy.c
@@ -0,0 +1,214 @@
+#include <linux/delay.h>
+#include <linux/timer.h>
+#include <linux/io.h>
+#include <linux/errno.h>
+
+#include <mach/cputype.h>
+
+#ifdef CONFIG_ARCH_MMP
+
+#define UTMI_REVISION           0x0
+#define UTMI_CTRL               0x4
+#define UTMI_PLL                0x8
+#define UTMI_TX                 0xc
+#define UTMI_RX                 0x10
+#define UTMI_IVREF              0x14
+#define UTMI_T0                 0x18
+#define UTMI_T1                 0x1c
+#define UTMI_T2                 0x20
+#define UTMI_T3                 0x24
+#define UTMI_T4                 0x28
+#define UTMI_T5                 0x2c
+#define UTMI_RESERVE            0x30
+#define UTMI_USB_INT            0x34
+#define UTMI_DBG_CTL            0x38
+#define UTMI_OTG_ADDON          0x3c
+
+/* For UTMICTRL Register */
+#define UTMI_CTRL_USB_CLK_EN                    (1 << 31)
+/* pxa168 */
+#define UTMI_CTRL_SUSPEND_SET1                  (1 << 30)
+#define UTMI_CTRL_SUSPEND_SET2                  (1 << 29)
+#define UTMI_CTRL_RXBUF_PDWN                    (1 << 24)
+#define UTMI_CTRL_TXBUF_PDWN                    (1 << 11)
+
+#define UTMI_CTRL_INPKT_DELAY_SHIFT             30
+#define UTMI_CTRL_INPKT_DELAY_SOF_SHIFT         28
+#define UTMI_CTRL_PU_REF_SHIFT                  20
+#define UTMI_CTRL_ARC_PULLDN_SHIFT              12
+#define UTMI_CTRL_PLL_PWR_UP_SHIFT              1
+#define UTMI_CTRL_PWR_UP_SHIFT                  0
+/* For UTMI_PLL Register */
+#define UTMI_PLL_CLK_BLK_EN_SHIFT               24
+#define UTMI_PLL_FBDIV_SHIFT                    4
+#define UTMI_PLL_REFDIV_SHIFT                   0
+#define UTMI_PLL_FBDIV_MASK                     0x00000FF0
+#define UTMI_PLL_REFDIV_MASK                    0x0000000F
+#define UTMI_PLL_ICP_MASK                       0x00007000
+#define UTMI_PLL_KVCO_MASK                      0x00031000
+#define UTMI_PLL_PLLCALI12_SHIFT                29
+#define UTMI_PLL_PLLCALI12_MASK                 (0x3 << 29)
+#define UTMI_PLL_PLLVDD18_SHIFT                 27
+#define UTMI_PLL_PLLVDD18_MASK                  (0x3 << 27)
+#define UTMI_PLL_PLLVDD12_SHIFT                 25
+#define UTMI_PLL_PLLVDD12_MASK                  (0x3 << 25)
+#define UTMI_PLL_KVCO_SHIFT                     15
+#define UTMI_PLL_ICP_SHIFT                      12
+/* For UTMI_TX Register */
+#define UTMI_TX_REG_EXT_FS_RCAL_SHIFT           27
+#define UTMI_TX_REG_EXT_FS_RCAL_MASK            (0xf << 27)
+#define UTMI_TX_REG_EXT_FS_RCAL_EN_MASK         26
+#define UTMI_TX_REG_EXT_FS_RCAL_EN              (0x1 << 26)
+#define UTMI_TX_LOW_VDD_EN_SHIFT                11
+#define UTMI_TX_IMPCAL_VTH_SHIFT                14
+#define UTMI_TX_IMPCAL_VTH_MASK                 (0x7 << 14)
+#define UTMI_TX_CK60_PHSEL_SHIFT                17
+#define UTMI_TX_CK60_PHSEL_MASK                 (0xf << 17)
+#define UTMI_TX_TXVDD12_SHIFT                   22
+#define UTMI_TX_TXVDD12_MASK                    (0x3 << 22)
+#define UTMI_TX_AMP_SHIFT                       0
+#define UTMI_TX_AMP_MASK                        (0x7 << 0)
+/* For UTMI_RX Register */
+#define UTMI_RX_SQ_THRESH_SHIFT                 4
+#define UTMI_RX_SQ_THRESH_MASK                  (0xf << 4)
+#define UTMI_REG_SQ_LENGTH_SHIFT                15
+#define UTMI_REG_SQ_LENGTH_MASK                 (0x3 << 15)
+
+#define REG_RCAL_START                          0x00001000
+#define VCOCAL_START                            0x00200000
+#define KVCO_EXT                                0x00400000
+#define PLL_READY                               0x00800000
+#define CLK_BLK_EN                              0x01000000
+#endif
+
+static unsigned int u2o_read(unsigned int base, unsigned int offset)
+{
+        return readl(base + offset);
+}
+
+static void u2o_set(unsigned int base, unsigned int offset, unsigned int value)
+{
+        unsigned int reg;
+
+        reg = readl(base + offset);
+        reg |= value;
+        writel(reg, base + offset);
+        readl(base + offset);
+}
+
+static void u2o_clear(unsigned int base, unsigned int offset,
+        unsigned int value)
+{
+        unsigned int reg;
+
+        reg = readl(base + offset);
+        reg &= ~value;
+        writel(reg, base + offset);
+        readl(base + offset);
+}
+
+static void u2o_write(unsigned int base, unsigned int offset,
+        unsigned int value)
+{
+        writel(value, base + offset);
+        readl(base + offset);
+}
+
+#ifdef CONFIG_ARCH_MMP
+int mv_udc_phy_init(unsigned int base)
+{
+        unsigned long timeout;
+
+        /* Initialize the USB PHY power */
+        if (cpu_is_pxa910()) {
+                u2o_set(base, UTMI_CTRL, (1 << UTMI_CTRL_INPKT_DELAY_SOF_SHIFT)
+                        | (1 << UTMI_CTRL_PU_REF_SHIFT));
+        }
+
+        u2o_set(base, UTMI_CTRL, 1 << UTMI_CTRL_PLL_PWR_UP_SHIFT);
+        u2o_set(base, UTMI_CTRL, 1 << UTMI_CTRL_PWR_UP_SHIFT);
+
+        /* UTMI_PLL settings */
+        u2o_clear(base, UTMI_PLL, UTMI_PLL_PLLVDD18_MASK
+                | UTMI_PLL_PLLVDD12_MASK | UTMI_PLL_PLLCALI12_MASK
+                | UTMI_PLL_FBDIV_MASK | UTMI_PLL_REFDIV_MASK
+                | UTMI_PLL_ICP_MASK | UTMI_PLL_KVCO_MASK);
+
+        u2o_set(base, UTMI_PLL, (0xee << UTMI_PLL_FBDIV_SHIFT)
+                | (0xb << UTMI_PLL_REFDIV_SHIFT)
+                | (3 << UTMI_PLL_PLLVDD18_SHIFT)
+                | (3 << UTMI_PLL_PLLVDD12_SHIFT)
+                | (3 << UTMI_PLL_PLLCALI12_SHIFT)
+                | (1 << UTMI_PLL_ICP_SHIFT) | (3 << UTMI_PLL_KVCO_SHIFT));
+
+        /* UTMI_TX */
+        u2o_clear(base, UTMI_TX, UTMI_TX_REG_EXT_FS_RCAL_EN_MASK
+                | UTMI_TX_TXVDD12_MASK
+                | UTMI_TX_CK60_PHSEL_MASK | UTMI_TX_IMPCAL_VTH_MASK
+                | UTMI_TX_REG_EXT_FS_RCAL_MASK | UTMI_TX_AMP_MASK);
+        u2o_set(base, UTMI_TX, (3 << UTMI_TX_TXVDD12_SHIFT)
+                | (4 << UTMI_TX_CK60_PHSEL_SHIFT)
+                | (4 << UTMI_TX_IMPCAL_VTH_SHIFT)
+                | (8 << UTMI_TX_REG_EXT_FS_RCAL_SHIFT)
+                | (3 << UTMI_TX_AMP_SHIFT));
+
+        /* UTMI_RX */
+        u2o_clear(base, UTMI_RX, UTMI_RX_SQ_THRESH_MASK
+                | UTMI_REG_SQ_LENGTH_MASK);
+        if (cpu_is_pxa168())
+                u2o_set(base, UTMI_RX, (7 << UTMI_RX_SQ_THRESH_SHIFT)
+                        | (2 << UTMI_REG_SQ_LENGTH_SHIFT));
+        else
+                u2o_set(base, UTMI_RX, (0x7 << UTMI_RX_SQ_THRESH_SHIFT)
+                        | (2 << UTMI_REG_SQ_LENGTH_SHIFT));
+
+        /* UTMI_IVREF */
+        if (cpu_is_pxa168())
+                /*
+                 * fixing Microsoft Altair board interface with NEC hub issue -
+                 * Set UTMI_IVREF from 0x4a3 to 0x4bf
+                 */
+                u2o_write(base, UTMI_IVREF, 0x4bf);
+
+        /* calibrate */
+        timeout = jiffies + 100;
+        while ((u2o_read(base, UTMI_PLL) & PLL_READY) == 0) {
+                if (time_after(jiffies, timeout))
+                        return -ETIME;
+                cpu_relax();
+        }
+
+        /* toggle VCOCAL_START bit of UTMI_PLL */
+        udelay(200);
+        u2o_set(base, UTMI_PLL, VCOCAL_START);
+        udelay(40);
+        u2o_clear(base, UTMI_PLL, VCOCAL_START);
+
+        /* toggle REG_RCAL_START bit of UTMI_TX */
+        udelay(200);
+        u2o_set(base, UTMI_TX, REG_RCAL_START);
+        udelay(40);
+        u2o_clear(base, UTMI_TX, REG_RCAL_START);
+        udelay(200);
+
+        /* make sure phy is ready */
+        timeout = jiffies + 100;
+        while ((u2o_read(base, UTMI_PLL) & PLL_READY) == 0) {
+                if (time_after(jiffies, timeout))
+                        return -ETIME;
+                cpu_relax();
+        }
+
+        if (cpu_is_pxa168()) {
+                u2o_set(base, UTMI_RESERVE, 1 << 5);
+                /* Turn on UTMI PHY OTG extension */
+                u2o_write(base, UTMI_OTG_ADDON, 1);
+        }
+        return 0;
+}
+#else
+int mv_udc_phy_init(unsigned int base)
+{
+        return 0;
+}
+#endif
diff --git a/drivers/usb/gadget/ncm.c b/drivers/usb/gadget/ncm.c
new file mode 100644
index 000000000000..99c179ad729d
--- /dev/null
+++ b/drivers/usb/gadget/ncm.c
@@ -0,0 +1,248 @@
+/*
+ * ncm.c -- NCM gadget driver
+ *
+ * Copyright (C) 2010 Nokia Corporation
+ * Contact: Yauheni Kaliuta <yauheni.kaliuta@nokia.com>
+ *
+ * The driver borrows from ether.c which is:
+ *
+ * Copyright (C) 2003-2005,2008 David Brownell
+ * Copyright (C) 2003-2004 Robert Schwebel, Benedikt Spranger
+ * Copyright (C) 2008 Nokia Corporation
+ *
+ * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+/* #define DEBUG */
+/* #define VERBOSE_DEBUG */
+
+#include <linux/kernel.h>
+#include <linux/utsname.h>
+
+
+#include "u_ether.h"
+
+#define DRIVER_DESC             "NCM Gadget"
+
+/*-------------------------------------------------------------------------*/
+
+/*
+ * Kbuild is not very cooperative with respect to linking separately
+ * compiled library objects into one module.  So for now we won't use
+ * separate compilation ... ensuring init/exit sections work to shrink
+ * the runtime footprint, and giving us at least some parts of what
+ * a "gcc --combine ... part1.c part2.c part3.c ... " build would.
+ */
+#include "composite.c"
+#include "usbstring.c"
+#include "config.c"
+#include "epautoconf.c"
+
+#include "f_ncm.c"
+#include "u_ether.c"
+
+/*-------------------------------------------------------------------------*/
+
+/* DO NOT REUSE THESE IDs with a protocol-incompatible driver!!  Ever!!
+ * Instead:  allocate your own, using normal USB-IF procedures.
+ */
+
+/* Thanks to NetChip Technologies for donating this product ID.
+ * It's for devices with only CDC Ethernet configurations.
+ */
+#define CDC_VENDOR_NUM          0x0525  /* NetChip */
+#define CDC_PRODUCT_NUM         0xa4a1  /* Linux-USB Ethernet Gadget */
+
+/*-------------------------------------------------------------------------*/
+
+static struct usb_device_descriptor device_desc = {
+        .bLength =              sizeof device_desc,
+        .bDescriptorType =      USB_DT_DEVICE,
+
+        .bcdUSB =               cpu_to_le16 (0x0200),
+
+        .bDeviceClass =         USB_CLASS_COMM,
+        .bDeviceSubClass =      0,
+        .bDeviceProtocol =      0,
+        /* .bMaxPacketSize0 = f(hardware) */
+
+        /* Vendor and product id defaults change according to what configs
+         * we support.  (As does bNumConfigurations.)  These values can
+         * also be overridden by module parameters.
+         */
+        .idVendor =             cpu_to_le16 (CDC_VENDOR_NUM),
+        .idProduct =            cpu_to_le16 (CDC_PRODUCT_NUM),
+        /* .bcdDevice = f(hardware) */
+        /* .iManufacturer = DYNAMIC */
+        /* .iProduct = DYNAMIC */
+        /* NO SERIAL NUMBER */
+        .bNumConfigurations =   1,
+};
+
+static struct usb_otg_descriptor otg_descriptor = {
+        .bLength =              sizeof otg_descriptor,
+        .bDescriptorType =      USB_DT_OTG,
+
+        /* REVISIT SRP-only hardware is possible, although
+         * it would not be called "OTG" ...
+         */
+        .bmAttributes =         USB_OTG_SRP | USB_OTG_HNP,
+};
+
+static const struct usb_descriptor_header *otg_desc[] = {
+        (struct usb_descriptor_header *) &otg_descriptor,
+        NULL,
+};
+
+
+/* string IDs are assigned dynamically */
+
+#define STRING_MANUFACTURER_IDX         0
+#define STRING_PRODUCT_IDX              1
+
+static char manufacturer[50];
+
+static struct usb_string strings_dev[] = {
+        [STRING_MANUFACTURER_IDX].s = manufacturer,
+        [STRING_PRODUCT_IDX].s = DRIVER_DESC,
+        {  } /* end of list */
+};
+
+static struct usb_gadget_strings stringtab_dev = {
+        .language       = 0x0409,       /* en-us */
+        .strings        = strings_dev,
+};
+
+static struct usb_gadget_strings *dev_strings[] = {
+        &stringtab_dev,
+        NULL,
+};
+
+static u8 hostaddr[ETH_ALEN];
+
+/*-------------------------------------------------------------------------*/
+
+static int __init ncm_do_config(struct usb_configuration *c)
+{
+        /* FIXME alloc iConfiguration string, set it in c->strings */
+
+        if (gadget_is_otg(c->cdev->gadget)) {
+                c->descriptors = otg_desc;
+                c->bmAttributes |= USB_CONFIG_ATT_WAKEUP;
+        }
+
+        return ncm_bind_config(c, hostaddr);
+}
+
+static struct usb_configuration ncm_config_driver = {
+        /* .label = f(hardware) */
+        .label                  = "CDC Ethernet (NCM)",
+        .bConfigurationValue    = 1,
+        /* .iConfiguration = DYNAMIC */
+        .bmAttributes           = USB_CONFIG_ATT_SELFPOWER,
+};
+
+/*-------------------------------------------------------------------------*/
+
+static int __init gncm_bind(struct usb_composite_dev *cdev)
+{
+        int                     gcnum;
+        struct usb_gadget       *gadget = cdev->gadget;
+        int                     status;
+
+        /* set up network link layer */
+        status = gether_setup(cdev->gadget, hostaddr);
+        if (status < 0)
+                return status;
+
+        gcnum = usb_gadget_controller_number(gadget);
+        if (gcnum >= 0)
+                device_desc.bcdDevice = cpu_to_le16(0x0300 | gcnum);
+        else {
+                /* We assume that can_support_ecm() tells the truth;
+                 * but if the controller isn't recognized at all then
+                 * that assumption is a bit more likely to be wrong.
+                 */
+                dev_warn(&gadget->dev,
+                         "controller '%s' not recognized; trying %s\n",
+                         gadget->name,
+                         ncm_config_driver.label);
+                device_desc.bcdDevice =
+                        cpu_to_le16(0x0300 | 0x0099);
+        }
+
+
+        /* Allocate string descriptor numbers ... note that string
+         * contents can be overridden by the composite_dev glue.
+         */
+
+        /* device descriptor strings: manufacturer, product */
+        snprintf(manufacturer, sizeof manufacturer, "%s %s with %s",
+                init_utsname()->sysname, init_utsname()->release,
+                gadget->name);
+        status = usb_string_id(cdev);
+        if (status < 0)
+                goto fail;
+        strings_dev[STRING_MANUFACTURER_IDX].id = status;
+        device_desc.iManufacturer = status;
+
+        status = usb_string_id(cdev);
+        if (status < 0)
+                goto fail;
+        strings_dev[STRING_PRODUCT_IDX].id = status;
+        device_desc.iProduct = status;
+
+        status = usb_add_config(cdev, &ncm_config_driver,
+                                ncm_do_config);
+        if (status < 0)
+                goto fail;
+
+        dev_info(&gadget->dev, "%s\n", DRIVER_DESC);
+
+        return 0;
+
+fail:
+        gether_cleanup();
+        return status;
+}
+
+static int __exit gncm_unbind(struct usb_composite_dev *cdev)
+{
+        gether_cleanup();
+        return 0;
+}
+
+static struct usb_composite_driver ncm_driver = {
+        .name           = "g_ncm",
+        .dev            = &device_desc,
+        .strings        = dev_strings,
+        .unbind         = __exit_p(gncm_unbind),
+};
+
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_AUTHOR("Yauheni Kaliuta");
+MODULE_LICENSE("GPL");
+
+static int __init init(void)
+{
+        return usb_composite_probe(&ncm_driver, gncm_bind);
+}
+module_init(init);
+
+static void __exit cleanup(void)
+{
+        usb_composite_unregister(&ncm_driver);
+}
+module_exit(cleanup);
diff --git a/drivers/usb/gadget/net2280.c b/drivers/usb/gadget/net2280.c
index 9498be87a724..476d88e1ae97 100644
--- a/drivers/usb/gadget/net2280.c
+++ b/drivers/usb/gadget/net2280.c
@@ -63,6 +63,7 @@
 #include <linux/device.h>
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
+#include <linux/prefetch.h>
 
 #include <asm/byteorder.h>
 #include <asm/io.h>
@@ -117,7 +118,7 @@ module_param (fifo_mode, ushort, 0644);
 
 /* enable_suspend -- When enabled, the driver will respond to
  * USB suspend requests by powering down the NET2280.  Otherwise,
- * USB suspend requests will be ignored.  This is acceptible for
+ * USB suspend requests will be ignored.  This is acceptable for
  * self-powered devices
  */
 static int enable_suspend = 0;
@@ -1929,7 +1930,8 @@ static void ep0_start (struct net2280 *dev)
  * disconnect is reported.  then a host may connect again, or
  * the driver might get unbound.
  */
-int usb_gadget_register_driver (struct usb_gadget_driver *driver)
+int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
+                int (*bind)(struct usb_gadget *))
 {
         struct net2280          *dev = the_controller;
         int                     retval;
@@ -1941,8 +1943,7 @@ int usb_gadget_register_driver (struct usb_gadget_driver *driver)
          */
         if (!driver
                         || driver->speed != USB_SPEED_HIGH
-                        || !driver->bind
-                        || !driver->setup)
+                        || !bind || !driver->setup)
                 return -EINVAL;
         if (!dev)
                 return -ENODEV;
@@ -1957,7 +1958,7 @@ int usb_gadget_register_driver (struct usb_gadget_driver *driver)
         driver->driver.bus = NULL;
         dev->driver = driver;
         dev->gadget.dev.driver = &driver->driver;
-        retval = driver->bind (&dev->gadget);
+        retval = bind(&dev->gadget);
         if (retval) {
                 DEBUG (dev, "bind to driver %s --> %d\n",
                                 driver->driver.name, retval);
@@ -1993,7 +1994,7 @@ err_unbind:
         dev->driver = NULL;
         return retval;
 }
-EXPORT_SYMBOL (usb_gadget_register_driver);
+EXPORT_SYMBOL(usb_gadget_probe_driver);
 
 static void
 stop_activity (struct net2280 *dev, struct usb_gadget_driver *driver)
diff --git a/drivers/usb/gadget/nokia.c b/drivers/usb/gadget/nokia.c
index 7d6b66a85724..55ca63ad3506 100644
--- a/drivers/usb/gadget/nokia.c
+++ b/drivers/usb/gadget/nokia.c
@@ -135,7 +135,6 @@ static int __init nokia_bind_config(struct usb_configuration *c)
 
 static struct usb_configuration nokia_config_500ma_driver = {
         .label          = "Bus Powered",
-        .bind           = nokia_bind_config,
         .bConfigurationValue = 1,
         /* .iConfiguration = DYNAMIC */
         .bmAttributes   = USB_CONFIG_ATT_ONE,
@@ -144,7 +143,6 @@ static struct usb_configuration nokia_config_500ma_driver = {
 
 static struct usb_configuration nokia_config_100ma_driver = {
         .label          = "Self Powered",
-        .bind           = nokia_bind_config,
         .bConfigurationValue = 2,
         /* .iConfiguration = DYNAMIC */
         .bmAttributes   = USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER,
@@ -205,12 +203,14 @@ static int __init nokia_bind(struct usb_composite_dev *cdev)
                 goto err_usb;
         }
 
-        /* finaly register the configuration */
-        status = usb_add_config(cdev, &nokia_config_500ma_driver);
+        /* finally register the configuration */
+        status = usb_add_config(cdev, &nokia_config_500ma_driver,
+                        nokia_bind_config);
         if (status < 0)
                 goto err_usb;
 
-        status = usb_add_config(cdev, &nokia_config_100ma_driver);
+        status = usb_add_config(cdev, &nokia_config_100ma_driver,
+                        nokia_bind_config);
         if (status < 0)
                 goto err_usb;
 
@@ -241,13 +241,12 @@ static struct usb_composite_driver nokia_driver = {
         .name           = "g_nokia",
         .dev            = &device_desc,
         .strings        = dev_strings,
-        .bind           = nokia_bind,
         .unbind         = __exit_p(nokia_unbind),
 };
 
 static int __init nokia_init(void)
 {
-        return usb_composite_register(&nokia_driver);
+        return usb_composite_probe(&nokia_driver, nokia_bind);
 }
 module_init(nokia_init);
 
diff --git a/drivers/usb/gadget/omap_udc.c b/drivers/usb/gadget/omap_udc.c
index f81e4f025f23..82fd24935332 100644
--- a/drivers/usb/gadget/omap_udc.c
+++ b/drivers/usb/gadget/omap_udc.c
@@ -44,6 +44,7 @@
 #include <linux/usb/otg.h>
 #include <linux/dma-mapping.h>
 #include <linux/clk.h>
+#include <linux/prefetch.h>
 
 #include <asm/byteorder.h>
 #include <asm/io.h>
@@ -54,7 +55,6 @@
 
 #include <plat/dma.h>
 #include <plat/usb.h>
-#include <plat/control.h>
 
 #include "omap_udc.h"
 
@@ -2102,7 +2102,8 @@ static inline int machine_without_vbus_sense(void)
                 );
 }
 
-int usb_gadget_register_driver (struct usb_gadget_driver *driver)
+int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
+                int (*bind)(struct usb_gadget *))
 {
         int             status = -ENODEV;
         struct omap_ep  *ep;
@@ -2114,8 +2115,7 @@ int usb_gadget_register_driver (struct usb_gadget_driver *driver)
         if (!driver
                         // FIXME if otg, check:  driver->is_otg
                         || driver->speed < USB_SPEED_FULL
-                        || !driver->bind
-                        || !driver->setup)
+                        || !bind || !driver->setup)
                 return -EINVAL;
 
         spin_lock_irqsave(&udc->lock, flags);
@@ -2145,7 +2145,7 @@ int usb_gadget_register_driver (struct usb_gadget_driver *driver)
         if (udc->dc_clk != NULL)
                 omap_udc_enable_clock(1);
 
-        status = driver->bind (&udc->gadget);
+        status = bind(&udc->gadget);
         if (status) {
                 DBG("bind to %s --> %d\n", driver->driver.name, status);
                 udc->gadget.dev.driver = NULL;
@@ -2186,7 +2186,7 @@ done:
                 omap_udc_enable_clock(0);
         return status;
 }
-EXPORT_SYMBOL(usb_gadget_register_driver);
+EXPORT_SYMBOL(usb_gadget_probe_driver);
 
 int usb_gadget_unregister_driver (struct usb_gadget_driver *driver)
 {
@@ -2309,21 +2309,12 @@ static char *trx_mode(unsigned m, int enabled)
 static int proc_otg_show(struct seq_file *s)
 {
         u32             tmp;
-        u32             trans;
-        char            *ctrl_name;
+        u32             trans = 0;
+        char            *ctrl_name = "(UNKNOWN)";
 
+        /* XXX This needs major revision for OMAP2+ */
         tmp = omap_readl(OTG_REV);
-        if (cpu_is_omap24xx()) {
-                /*
-                 * REVISIT: Not clear how this works on OMAP2.  trans
-                 * is ANDed to produce bits 7 and 8, which might make
-                 * sense for USB_TRANSCEIVER_CTRL on OMAP1,
-                 * but with CONTROL_DEVCONF, these bits have something to
-                 * do with the frame adjustment counter and McBSP2.
-                 */
-                ctrl_name = "control_devconf";
-                trans = omap_ctrl_readl(OMAP2_CONTROL_DEVCONF0);
-        } else {
+        if (cpu_class_is_omap1()) {
                 ctrl_name = "tranceiver_ctrl";
                 trans = omap_readw(USB_TRANSCEIVER_CTRL);
         }
diff --git a/drivers/usb/gadget/pch_udc.c b/drivers/usb/gadget/pch_udc.c
new file mode 100644
index 000000000000..68dbcc3e4cc2
--- /dev/null
+++ b/drivers/usb/gadget/pch_udc.c
@@ -0,0 +1,3004 @@
+/*
+ * Copyright (C) 2010 OKI SEMICONDUCTOR CO., LTD.
+ *
+ * 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; version 2 of the License.
+ *
+ * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+ */
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/delay.h>
+#include <linux/errno.h>
+#include <linux/list.h>
+#include <linux/interrupt.h>
+#include <linux/usb/ch9.h>
+#include <linux/usb/gadget.h>
+
+/* Address offset of Registers */
+#define UDC_EP_REG_SHIFT        0x20    /* Offset to next EP */
+
+#define UDC_EPCTL_ADDR          0x00    /* Endpoint control */
+#define UDC_EPSTS_ADDR          0x04    /* Endpoint status */
+#define UDC_BUFIN_FRAMENUM_ADDR 0x08    /* buffer size in / frame number out */
+#define UDC_BUFOUT_MAXPKT_ADDR  0x0C    /* buffer size out / maxpkt in */
+#define UDC_SUBPTR_ADDR         0x10    /* setup buffer pointer */
+#define UDC_DESPTR_ADDR         0x14    /* Data descriptor pointer */
+#define UDC_CONFIRM_ADDR        0x18    /* Write/Read confirmation */
+
+#define UDC_DEVCFG_ADDR         0x400   /* Device configuration */
+#define UDC_DEVCTL_ADDR         0x404   /* Device control */
+#define UDC_DEVSTS_ADDR         0x408   /* Device status */
+#define UDC_DEVIRQSTS_ADDR      0x40C   /* Device irq status */
+#define UDC_DEVIRQMSK_ADDR      0x410   /* Device irq mask */
+#define UDC_EPIRQSTS_ADDR       0x414   /* Endpoint irq status */
+#define UDC_EPIRQMSK_ADDR       0x418   /* Endpoint irq mask */
+#define UDC_DEVLPM_ADDR         0x41C   /* LPM control / status */
+#define UDC_CSR_BUSY_ADDR       0x4f0   /* UDC_CSR_BUSY Status register */
+#define UDC_SRST_ADDR           0x4fc   /* SOFT RESET register */
+#define UDC_CSR_ADDR            0x500   /* USB_DEVICE endpoint register */
+
+/* Endpoint control register */
+/* Bit position */
+#define UDC_EPCTL_MRXFLUSH              (1 << 12)
+#define UDC_EPCTL_RRDY                  (1 << 9)
+#define UDC_EPCTL_CNAK                  (1 << 8)
+#define UDC_EPCTL_SNAK                  (1 << 7)
+#define UDC_EPCTL_NAK                   (1 << 6)
+#define UDC_EPCTL_P                     (1 << 3)
+#define UDC_EPCTL_F                     (1 << 1)
+#define UDC_EPCTL_S                     (1 << 0)
+#define UDC_EPCTL_ET_SHIFT              4
+/* Mask patern */
+#define UDC_EPCTL_ET_MASK               0x00000030
+/* Value for ET field */
+#define UDC_EPCTL_ET_CONTROL            0
+#define UDC_EPCTL_ET_ISO                1
+#define UDC_EPCTL_ET_BULK               2
+#define UDC_EPCTL_ET_INTERRUPT          3
+
+/* Endpoint status register */
+/* Bit position */
+#define UDC_EPSTS_XFERDONE              (1 << 27)
+#define UDC_EPSTS_RSS                   (1 << 26)
+#define UDC_EPSTS_RCS                   (1 << 25)
+#define UDC_EPSTS_TXEMPTY               (1 << 24)
+#define UDC_EPSTS_TDC                   (1 << 10)
+#define UDC_EPSTS_HE                    (1 << 9)
+#define UDC_EPSTS_MRXFIFO_EMP           (1 << 8)
+#define UDC_EPSTS_BNA                   (1 << 7)
+#define UDC_EPSTS_IN                    (1 << 6)
+#define UDC_EPSTS_OUT_SHIFT             4
+/* Mask patern */
+#define UDC_EPSTS_OUT_MASK              0x00000030
+#define UDC_EPSTS_ALL_CLR_MASK          0x1F0006F0
+/* Value for OUT field */
+#define UDC_EPSTS_OUT_SETUP             2
+#define UDC_EPSTS_OUT_DATA              1
+
+/* Device configuration register */
+/* Bit position */
+#define UDC_DEVCFG_CSR_PRG              (1 << 17)
+#define UDC_DEVCFG_SP                   (1 << 3)
+/* SPD Valee */
+#define UDC_DEVCFG_SPD_HS               0x0
+#define UDC_DEVCFG_SPD_FS               0x1
+#define UDC_DEVCFG_SPD_LS               0x2
+
+/* Device control register */
+/* Bit position */
+#define UDC_DEVCTL_THLEN_SHIFT          24
+#define UDC_DEVCTL_BRLEN_SHIFT          16
+#define UDC_DEVCTL_CSR_DONE             (1 << 13)
+#define UDC_DEVCTL_SD                   (1 << 10)
+#define UDC_DEVCTL_MODE                 (1 << 9)
+#define UDC_DEVCTL_BREN                 (1 << 8)
+#define UDC_DEVCTL_THE                  (1 << 7)
+#define UDC_DEVCTL_DU                   (1 << 4)
+#define UDC_DEVCTL_TDE                  (1 << 3)
+#define UDC_DEVCTL_RDE                  (1 << 2)
+#define UDC_DEVCTL_RES                  (1 << 0)
+
+/* Device status register */
+/* Bit position */
+#define UDC_DEVSTS_TS_SHIFT             18
+#define UDC_DEVSTS_ENUM_SPEED_SHIFT     13
+#define UDC_DEVSTS_ALT_SHIFT            8
+#define UDC_DEVSTS_INTF_SHIFT           4
+#define UDC_DEVSTS_CFG_SHIFT            0
+/* Mask patern */
+#define UDC_DEVSTS_TS_MASK              0xfffc0000
+#define UDC_DEVSTS_ENUM_SPEED_MASK      0x00006000
+#define UDC_DEVSTS_ALT_MASK             0x00000f00
+#define UDC_DEVSTS_INTF_MASK            0x000000f0
+#define UDC_DEVSTS_CFG_MASK             0x0000000f
+/* value for maximum speed for SPEED field */
+#define UDC_DEVSTS_ENUM_SPEED_FULL      1
+#define UDC_DEVSTS_ENUM_SPEED_HIGH      0
+#define UDC_DEVSTS_ENUM_SPEED_LOW       2
+#define UDC_DEVSTS_ENUM_SPEED_FULLX     3
+
+/* Device irq register */
+/* Bit position */
+#define UDC_DEVINT_RWKP                 (1 << 7)
+#define UDC_DEVINT_ENUM                 (1 << 6)
+#define UDC_DEVINT_SOF                  (1 << 5)
+#define UDC_DEVINT_US                   (1 << 4)
+#define UDC_DEVINT_UR                   (1 << 3)
+#define UDC_DEVINT_ES                   (1 << 2)
+#define UDC_DEVINT_SI                   (1 << 1)
+#define UDC_DEVINT_SC                   (1 << 0)
+/* Mask patern */
+#define UDC_DEVINT_MSK                  0x7f
+
+/* Endpoint irq register */
+/* Bit position */
+#define UDC_EPINT_IN_SHIFT              0
+#define UDC_EPINT_OUT_SHIFT             16
+#define UDC_EPINT_IN_EP0                (1 << 0)
+#define UDC_EPINT_OUT_EP0               (1 << 16)
+/* Mask patern */
+#define UDC_EPINT_MSK_DISABLE_ALL       0xffffffff
+
+/* UDC_CSR_BUSY Status register */
+/* Bit position */
+#define UDC_CSR_BUSY                    (1 << 0)
+
+/* SOFT RESET register */
+/* Bit position */
+#define UDC_PSRST                       (1 << 1)
+#define UDC_SRST                        (1 << 0)
+
+/* USB_DEVICE endpoint register */
+/* Bit position */
+#define UDC_CSR_NE_NUM_SHIFT            0
+#define UDC_CSR_NE_DIR_SHIFT            4
+#define UDC_CSR_NE_TYPE_SHIFT           5
+#define UDC_CSR_NE_CFG_SHIFT            7
+#define UDC_CSR_NE_INTF_SHIFT           11
+#define UDC_CSR_NE_ALT_SHIFT            15
+#define UDC_CSR_NE_MAX_PKT_SHIFT        19
+/* Mask patern */
+#define UDC_CSR_NE_NUM_MASK             0x0000000f
+#define UDC_CSR_NE_DIR_MASK             0x00000010
+#define UDC_CSR_NE_TYPE_MASK            0x00000060
+#define UDC_CSR_NE_CFG_MASK             0x00000780
+#define UDC_CSR_NE_INTF_MASK            0x00007800
+#define UDC_CSR_NE_ALT_MASK             0x00078000
+#define UDC_CSR_NE_MAX_PKT_MASK         0x3ff80000
+
+#define PCH_UDC_CSR(ep) (UDC_CSR_ADDR + ep*4)
+#define PCH_UDC_EPINT(in, num)\
+                (1 << (num + (in ? UDC_EPINT_IN_SHIFT : UDC_EPINT_OUT_SHIFT)))
+
+/* Index of endpoint */
+#define UDC_EP0IN_IDX           0
+#define UDC_EP0OUT_IDX          1
+#define UDC_EPIN_IDX(ep)        (ep * 2)
+#define UDC_EPOUT_IDX(ep)       (ep * 2 + 1)
+#define PCH_UDC_EP0             0
+#define PCH_UDC_EP1             1
+#define PCH_UDC_EP2             2
+#define PCH_UDC_EP3             3
+
+/* Number of endpoint */
+#define PCH_UDC_EP_NUM          32      /* Total number of EPs (16 IN,16 OUT) */
+#define PCH_UDC_USED_EP_NUM     4       /* EP number of EP's really used */
+/* Length Value */
+#define PCH_UDC_BRLEN           0x0F    /* Burst length */
+#define PCH_UDC_THLEN           0x1F    /* Threshold length */
+/* Value of EP Buffer Size */
+#define UDC_EP0IN_BUFF_SIZE     16
+#define UDC_EPIN_BUFF_SIZE      256
+#define UDC_EP0OUT_BUFF_SIZE    16
+#define UDC_EPOUT_BUFF_SIZE     256
+/* Value of EP maximum packet size */
+#define UDC_EP0IN_MAX_PKT_SIZE  64
+#define UDC_EP0OUT_MAX_PKT_SIZE 64
+#define UDC_BULK_MAX_PKT_SIZE   512
+
+/* DMA */
+#define DMA_DIR_RX              1       /* DMA for data receive */
+#define DMA_DIR_TX              2       /* DMA for data transmit */
+#define DMA_ADDR_INVALID        (~(dma_addr_t)0)
+#define UDC_DMA_MAXPACKET       65536   /* maximum packet size for DMA */
+
+/**
+ * struct pch_udc_data_dma_desc - Structure to hold DMA descriptor information
+ *                                for data
+ * @status:             Status quadlet
+ * @reserved:           Reserved
+ * @dataptr:            Buffer descriptor
+ * @next:               Next descriptor
+ */
+struct pch_udc_data_dma_desc {
+        u32 status;
+        u32 reserved;
+        u32 dataptr;
+        u32 next;
+};
+
+/**
+ * struct pch_udc_stp_dma_desc - Structure to hold DMA descriptor information
+ *                               for control data
+ * @status:     Status
+ * @reserved:   Reserved
+ * @data12:     First setup word
+ * @data34:     Second setup word
+ */
+struct pch_udc_stp_dma_desc {
+        u32 status;
+        u32 reserved;
+        struct usb_ctrlrequest request;
+} __attribute((packed));
+
+/* DMA status definitions */
+/* Buffer status */
+#define PCH_UDC_BUFF_STS        0xC0000000
+#define PCH_UDC_BS_HST_RDY      0x00000000
+#define PCH_UDC_BS_DMA_BSY      0x40000000
+#define PCH_UDC_BS_DMA_DONE     0x80000000
+#define PCH_UDC_BS_HST_BSY      0xC0000000
+/*  Rx/Tx Status */
+#define PCH_UDC_RXTX_STS        0x30000000
+#define PCH_UDC_RTS_SUCC        0x00000000
+#define PCH_UDC_RTS_DESERR      0x10000000
+#define PCH_UDC_RTS_BUFERR      0x30000000
+/* Last Descriptor Indication */
+#define PCH_UDC_DMA_LAST        0x08000000
+/* Number of Rx/Tx Bytes Mask */
+#define PCH_UDC_RXTX_BYTES      0x0000ffff
+
+/**
+ * struct pch_udc_cfg_data - Structure to hold current configuration
+ *                           and interface information
+ * @cur_cfg:    current configuration in use
+ * @cur_intf:   current interface in use
+ * @cur_alt:    current alt interface in use
+ */
+struct pch_udc_cfg_data {
+        u16 cur_cfg;
+        u16 cur_intf;
+        u16 cur_alt;
+};
+
+/**
+ * struct pch_udc_ep - Structure holding a PCH USB device Endpoint information
+ * @ep:                 embedded ep request
+ * @td_stp_phys:        for setup request
+ * @td_data_phys:       for data request
+ * @td_stp:             for setup request
+ * @td_data:            for data request
+ * @dev:                reference to device struct
+ * @offset_addr:        offset address of ep register
+ * @desc:               for this ep
+ * @queue:              queue for requests
+ * @num:                endpoint number
+ * @in:                 endpoint is IN
+ * @halted:             endpoint halted?
+ * @epsts:              Endpoint status
+ */
+struct pch_udc_ep {
+        struct usb_ep                   ep;
+        dma_addr_t                      td_stp_phys;
+        dma_addr_t                      td_data_phys;
+        struct pch_udc_stp_dma_desc     *td_stp;
+        struct pch_udc_data_dma_desc    *td_data;
+        struct pch_udc_dev              *dev;
+        unsigned long                   offset_addr;
+        const struct usb_endpoint_descriptor    *desc;
+        struct list_head                queue;
+        unsigned                        num:5,
+                                        in:1,
+                                        halted:1;
+        unsigned long                   epsts;
+};
+
+/**
+ * struct pch_udc_dev - Structure holding complete information
+ *                      of the PCH USB device
+ * @gadget:             gadget driver data
+ * @driver:             reference to gadget driver bound
+ * @pdev:               reference to the PCI device
+ * @ep:                 array of endpoints
+ * @lock:               protects all state
+ * @active:             enabled the PCI device
+ * @stall:              stall requested
+ * @prot_stall:         protcol stall requested
+ * @irq_registered:     irq registered with system
+ * @mem_region:         device memory mapped
+ * @registered:         driver regsitered with system
+ * @suspended:          driver in suspended state
+ * @connected:          gadget driver associated
+ * @set_cfg_not_acked:  pending acknowledgement 4 setup
+ * @waiting_zlp_ack:    pending acknowledgement 4 ZLP
+ * @data_requests:      DMA pool for data requests
+ * @stp_requests:       DMA pool for setup requests
+ * @dma_addr:           DMA pool for received
+ * @ep0out_buf:         Buffer for DMA
+ * @setup_data:         Received setup data
+ * @phys_addr:          of device memory
+ * @base_addr:          for mapped device memory
+ * @irq:                IRQ line for the device
+ * @cfg_data:           current cfg, intf, and alt in use
+ */
+struct pch_udc_dev {
+        struct usb_gadget               gadget;
+        struct usb_gadget_driver        *driver;
+        struct pci_dev                  *pdev;
+        struct pch_udc_ep               ep[PCH_UDC_EP_NUM];
+        spinlock_t                      lock; /* protects all state */
+        unsigned        active:1,
+                        stall:1,
+                        prot_stall:1,
+                        irq_registered:1,
+                        mem_region:1,
+                        registered:1,
+                        suspended:1,
+                        connected:1,
+                        set_cfg_not_acked:1,
+                        waiting_zlp_ack:1;
+        struct pci_pool         *data_requests;
+        struct pci_pool         *stp_requests;
+        dma_addr_t                      dma_addr;
+        void                            *ep0out_buf;
+        struct usb_ctrlrequest          setup_data;
+        unsigned long                   phys_addr;
+        void __iomem                    *base_addr;
+        unsigned                        irq;
+        struct pch_udc_cfg_data cfg_data;
+};
+
+#define PCH_UDC_PCI_BAR                 1
+#define PCI_DEVICE_ID_INTEL_EG20T_UDC   0x8808
+#define PCI_VENDOR_ID_ROHM              0x10DB
+#define PCI_DEVICE_ID_ML7213_IOH_UDC    0x801D
+
+static const char       ep0_string[] = "ep0in";
+static DEFINE_SPINLOCK(udc_stall_spinlock);     /* stall spin lock */
+struct pch_udc_dev *pch_udc;            /* pointer to device object */
+static int speed_fs;
+module_param_named(speed_fs, speed_fs, bool, S_IRUGO);
+MODULE_PARM_DESC(speed_fs, "true for Full speed operation");
+
+/**
+ * struct pch_udc_request - Structure holding a PCH USB device request packet
+ * @req:                embedded ep request
+ * @td_data_phys:       phys. address
+ * @td_data:            first dma desc. of chain
+ * @td_data_last:       last dma desc. of chain
+ * @queue:              associated queue
+ * @dma_going:          DMA in progress for request
+ * @dma_mapped:         DMA memory mapped for request
+ * @dma_done:           DMA completed for request
+ * @chain_len:          chain length
+ * @buf:                Buffer memory for align adjustment
+ * @dma:                DMA memory for align adjustment
+ */
+struct pch_udc_request {
+        struct usb_request              req;
+        dma_addr_t                      td_data_phys;
+        struct pch_udc_data_dma_desc    *td_data;
+        struct pch_udc_data_dma_desc    *td_data_last;
+        struct list_head                queue;
+        unsigned                        dma_going:1,
+                                        dma_mapped:1,
+                                        dma_done:1;
+        unsigned                        chain_len;
+        void                            *buf;
+        dma_addr_t                      dma;
+};
+
+static inline u32 pch_udc_readl(struct pch_udc_dev *dev, unsigned long reg)
+{
+        return ioread32(dev->base_addr + reg);
+}
+
+static inline void pch_udc_writel(struct pch_udc_dev *dev,
+                                    unsigned long val, unsigned long reg)
+{
+        iowrite32(val, dev->base_addr + reg);
+}
+
+static inline void pch_udc_bit_set(struct pch_udc_dev *dev,
+                                     unsigned long reg,
+                                     unsigned long bitmask)
+{
+        pch_udc_writel(dev, pch_udc_readl(dev, reg) | bitmask, reg);
+}
+
+static inline void pch_udc_bit_clr(struct pch_udc_dev *dev,
+                                     unsigned long reg,
+                                     unsigned long bitmask)
+{
+        pch_udc_writel(dev, pch_udc_readl(dev, reg) & ~(bitmask), reg);
+}
+
+static inline u32 pch_udc_ep_readl(struct pch_udc_ep *ep, unsigned long reg)
+{
+        return ioread32(ep->dev->base_addr + ep->offset_addr + reg);
+}
+
+static inline void pch_udc_ep_writel(struct pch_udc_ep *ep,
+                                    unsigned long val, unsigned long reg)
+{
+        iowrite32(val, ep->dev->base_addr + ep->offset_addr + reg);
+}
+
+static inline void pch_udc_ep_bit_set(struct pch_udc_ep *ep,
+                                     unsigned long reg,
+                                     unsigned long bitmask)
+{
+        pch_udc_ep_writel(ep, pch_udc_ep_readl(ep, reg) | bitmask, reg);
+}
+
+static inline void pch_udc_ep_bit_clr(struct pch_udc_ep *ep,
+                                     unsigned long reg,
+                                     unsigned long bitmask)
+{
+        pch_udc_ep_writel(ep, pch_udc_ep_readl(ep, reg) & ~(bitmask), reg);
+}
+
+/**
+ * pch_udc_csr_busy() - Wait till idle.
+ * @dev:        Reference to pch_udc_dev structure
+ */
+static void pch_udc_csr_busy(struct pch_udc_dev *dev)
+{
+        unsigned int count = 200;
+
+        /* Wait till idle */
+        while ((pch_udc_readl(dev, UDC_CSR_BUSY_ADDR) & UDC_CSR_BUSY)
+                && --count)
+                cpu_relax();
+        if (!count)
+                dev_err(&dev->pdev->dev, "%s: wait error\n", __func__);
+}
+
+/**
+ * pch_udc_write_csr() - Write the command and status registers.
+ * @dev:        Reference to pch_udc_dev structure
+ * @val:        value to be written to CSR register
+ * @addr:       address of CSR register
+ */
+static void pch_udc_write_csr(struct pch_udc_dev *dev, unsigned long val,
+                               unsigned int ep)
+{
+        unsigned long reg = PCH_UDC_CSR(ep);
+
+        pch_udc_csr_busy(dev);          /* Wait till idle */
+        pch_udc_writel(dev, val, reg);
+        pch_udc_csr_busy(dev);          /* Wait till idle */
+}
+
+/**
+ * pch_udc_read_csr() - Read the command and status registers.
+ * @dev:        Reference to pch_udc_dev structure
+ * @addr:       address of CSR register
+ *
+ * Return codes:        content of CSR register
+ */
+static u32 pch_udc_read_csr(struct pch_udc_dev *dev, unsigned int ep)
+{
+        unsigned long reg = PCH_UDC_CSR(ep);
+
+        pch_udc_csr_busy(dev);          /* Wait till idle */
+        pch_udc_readl(dev, reg);        /* Dummy read */
+        pch_udc_csr_busy(dev);          /* Wait till idle */
+        return pch_udc_readl(dev, reg);
+}
+
+/**
+ * pch_udc_rmt_wakeup() - Initiate for remote wakeup
+ * @dev:        Reference to pch_udc_dev structure
+ */
+static inline void pch_udc_rmt_wakeup(struct pch_udc_dev *dev)
+{
+        pch_udc_bit_set(dev, UDC_DEVCTL_ADDR, UDC_DEVCTL_RES);
+        mdelay(1);
+        pch_udc_bit_clr(dev, UDC_DEVCTL_ADDR, UDC_DEVCTL_RES);
+}
+
+/**
+ * pch_udc_get_frame() - Get the current frame from device status register
+ * @dev:        Reference to pch_udc_dev structure
+ * Retern       current frame
+ */
+static inline int pch_udc_get_frame(struct pch_udc_dev *dev)
+{
+        u32 frame = pch_udc_readl(dev, UDC_DEVSTS_ADDR);
+        return (frame & UDC_DEVSTS_TS_MASK) >> UDC_DEVSTS_TS_SHIFT;
+}
+
+/**
+ * pch_udc_clear_selfpowered() - Clear the self power control
+ * @dev:        Reference to pch_udc_regs structure
+ */
+static inline void pch_udc_clear_selfpowered(struct pch_udc_dev *dev)
+{
+        pch_udc_bit_clr(dev, UDC_DEVCFG_ADDR, UDC_DEVCFG_SP);
+}
+
+/**
+ * pch_udc_set_selfpowered() - Set the self power control
+ * @dev:        Reference to pch_udc_regs structure
+ */
+static inline void pch_udc_set_selfpowered(struct pch_udc_dev *dev)
+{
+        pch_udc_bit_set(dev, UDC_DEVCFG_ADDR, UDC_DEVCFG_SP);
+}
+
+/**
+ * pch_udc_set_disconnect() - Set the disconnect status.
+ * @dev:        Reference to pch_udc_regs structure
+ */
+static inline void pch_udc_set_disconnect(struct pch_udc_dev *dev)
+{
+        pch_udc_bit_set(dev, UDC_DEVCTL_ADDR, UDC_DEVCTL_SD);
+}
+
+/**
+ * pch_udc_clear_disconnect() - Clear the disconnect status.
+ * @dev:        Reference to pch_udc_regs structure
+ */
+static void pch_udc_clear_disconnect(struct pch_udc_dev *dev)
+{
+        /* Clear the disconnect */
+        pch_udc_bit_set(dev, UDC_DEVCTL_ADDR, UDC_DEVCTL_RES);
+        pch_udc_bit_clr(dev, UDC_DEVCTL_ADDR, UDC_DEVCTL_SD);
+        mdelay(1);
+        /* Resume USB signalling */
+        pch_udc_bit_clr(dev, UDC_DEVCTL_ADDR, UDC_DEVCTL_RES);
+}
+
+/**
+ * pch_udc_vbus_session() - set or clearr the disconnect status.
+ * @dev:        Reference to pch_udc_regs structure
+ * @is_active:  Parameter specifying the action
+ *                0:   indicating VBUS power is ending
+ *                !0:  indicating VBUS power is starting
+ */
+static inline void pch_udc_vbus_session(struct pch_udc_dev *dev,
+                                          int is_active)
+{
+        if (is_active)
+                pch_udc_clear_disconnect(dev);
+        else
+                pch_udc_set_disconnect(dev);
+}
+
+/**
+ * pch_udc_ep_set_stall() - Set the stall of endpoint
+ * @ep:         Reference to structure of type pch_udc_ep_regs
+ */
+static void pch_udc_ep_set_stall(struct pch_udc_ep *ep)
+{
+        if (ep->in) {
+                pch_udc_ep_bit_set(ep, UDC_EPCTL_ADDR, UDC_EPCTL_F);
+                pch_udc_ep_bit_set(ep, UDC_EPCTL_ADDR, UDC_EPCTL_S);
+        } else {
+                pch_udc_ep_bit_set(ep, UDC_EPCTL_ADDR, UDC_EPCTL_S);
+        }
+}
+
+/**
+ * pch_udc_ep_clear_stall() - Clear the stall of endpoint
+ * @ep:         Reference to structure of type pch_udc_ep_regs
+ */
+static inline void pch_udc_ep_clear_stall(struct pch_udc_ep *ep)
+{
+        /* Clear the stall */
+        pch_udc_ep_bit_clr(ep, UDC_EPCTL_ADDR, UDC_EPCTL_S);
+        /* Clear NAK by writing CNAK */
+        pch_udc_ep_bit_set(ep, UDC_EPCTL_ADDR, UDC_EPCTL_CNAK);
+}
+
+/**
+ * pch_udc_ep_set_trfr_type() - Set the transfer type of endpoint
+ * @ep:         Reference to structure of type pch_udc_ep_regs
+ * @type:       Type of endpoint
+ */
+static inline void pch_udc_ep_set_trfr_type(struct pch_udc_ep *ep,
+                                        u8 type)
+{
+        pch_udc_ep_writel(ep, ((type << UDC_EPCTL_ET_SHIFT) &
+                                UDC_EPCTL_ET_MASK), UDC_EPCTL_ADDR);
+}
+
+/**
+ * pch_udc_ep_set_bufsz() - Set the maximum packet size for the endpoint
+ * @ep:         Reference to structure of type pch_udc_ep_regs
+ * @buf_size:   The buffer word size
+ */
+static void pch_udc_ep_set_bufsz(struct pch_udc_ep *ep,
+                                                 u32 buf_size, u32 ep_in)
+{
+        u32 data;
+        if (ep_in) {
+                data = pch_udc_ep_readl(ep, UDC_BUFIN_FRAMENUM_ADDR);
+                data = (data & 0xffff0000) | (buf_size & 0xffff);
+                pch_udc_ep_writel(ep, data, UDC_BUFIN_FRAMENUM_ADDR);
+        } else {
+                data = pch_udc_ep_readl(ep, UDC_BUFOUT_MAXPKT_ADDR);
+                data = (buf_size << 16) | (data & 0xffff);
+                pch_udc_ep_writel(ep, data, UDC_BUFOUT_MAXPKT_ADDR);
+        }
+}
+
+/**
+ * pch_udc_ep_set_maxpkt() - Set the Max packet size for the endpoint
+ * @ep:         Reference to structure of type pch_udc_ep_regs
+ * @pkt_size:   The packet byte size
+ */
+static void pch_udc_ep_set_maxpkt(struct pch_udc_ep *ep, u32 pkt_size)
+{
+        u32 data = pch_udc_ep_readl(ep, UDC_BUFOUT_MAXPKT_ADDR);
+        data = (data & 0xffff0000) | (pkt_size & 0xffff);
+        pch_udc_ep_writel(ep, data, UDC_BUFOUT_MAXPKT_ADDR);
+}
+
+/**
+ * pch_udc_ep_set_subptr() - Set the Setup buffer pointer for the endpoint
+ * @ep:         Reference to structure of type pch_udc_ep_regs
+ * @addr:       Address of the register
+ */
+static inline void pch_udc_ep_set_subptr(struct pch_udc_ep *ep, u32 addr)
+{
+        pch_udc_ep_writel(ep, addr, UDC_SUBPTR_ADDR);
+}
+
+/**
+ * pch_udc_ep_set_ddptr() - Set the Data descriptor pointer for the endpoint
+ * @ep:         Reference to structure of type pch_udc_ep_regs
+ * @addr:       Address of the register
+ */
+static inline void pch_udc_ep_set_ddptr(struct pch_udc_ep *ep, u32 addr)
+{
+        pch_udc_ep_writel(ep, addr, UDC_DESPTR_ADDR);
+}
+
+/**
+ * pch_udc_ep_set_pd() - Set the poll demand bit for the endpoint
+ * @ep:         Reference to structure of type pch_udc_ep_regs
+ */
+static inline void pch_udc_ep_set_pd(struct pch_udc_ep *ep)
+{
+        pch_udc_ep_bit_set(ep, UDC_EPCTL_ADDR, UDC_EPCTL_P);
+}
+
+/**
+ * pch_udc_ep_set_rrdy() - Set the receive ready bit for the endpoint
+ * @ep:         Reference to structure of type pch_udc_ep_regs
+ */
+static inline void pch_udc_ep_set_rrdy(struct pch_udc_ep *ep)
+{
+        pch_udc_ep_bit_set(ep, UDC_EPCTL_ADDR, UDC_EPCTL_RRDY);
+}
+
+/**
+ * pch_udc_ep_clear_rrdy() - Clear the receive ready bit for the endpoint
+ * @ep:         Reference to structure of type pch_udc_ep_regs
+ */
+static inline void pch_udc_ep_clear_rrdy(struct pch_udc_ep *ep)
+{
+        pch_udc_ep_bit_clr(ep, UDC_EPCTL_ADDR, UDC_EPCTL_RRDY);
+}
+
+/**
+ * pch_udc_set_dma() - Set the 'TDE' or RDE bit of device control
+ *                      register depending on the direction specified
+ * @dev:        Reference to structure of type pch_udc_regs
+ * @dir:        whether Tx or Rx
+ *                DMA_DIR_RX: Receive
+ *                DMA_DIR_TX: Transmit
+ */
+static inline void pch_udc_set_dma(struct pch_udc_dev *dev, int dir)
+{
+        if (dir == DMA_DIR_RX)
+                pch_udc_bit_set(dev, UDC_DEVCTL_ADDR, UDC_DEVCTL_RDE);
+        else if (dir == DMA_DIR_TX)
+                pch_udc_bit_set(dev, UDC_DEVCTL_ADDR, UDC_DEVCTL_TDE);
+}
+
+/**
+ * pch_udc_clear_dma() - Clear the 'TDE' or RDE bit of device control
+ *                               register depending on the direction specified
+ * @dev:        Reference to structure of type pch_udc_regs
+ * @dir:        Whether Tx or Rx
+ *                DMA_DIR_RX: Receive
+ *                DMA_DIR_TX: Transmit
+ */
+static inline void pch_udc_clear_dma(struct pch_udc_dev *dev, int dir)
+{
+        if (dir == DMA_DIR_RX)
+                pch_udc_bit_clr(dev, UDC_DEVCTL_ADDR, UDC_DEVCTL_RDE);
+        else if (dir == DMA_DIR_TX)
+                pch_udc_bit_clr(dev, UDC_DEVCTL_ADDR, UDC_DEVCTL_TDE);
+}
+
+/**
+ * pch_udc_set_csr_done() - Set the device control register
+ *                              CSR done field (bit 13)
+ * @dev:        reference to structure of type pch_udc_regs
+ */
+static inline void pch_udc_set_csr_done(struct pch_udc_dev *dev)
+{
+        pch_udc_bit_set(dev, UDC_DEVCTL_ADDR, UDC_DEVCTL_CSR_DONE);
+}
+
+/**
+ * pch_udc_disable_interrupts() - Disables the specified interrupts
+ * @dev:        Reference to structure of type pch_udc_regs
+ * @mask:       Mask to disable interrupts
+ */
+static inline void pch_udc_disable_interrupts(struct pch_udc_dev *dev,
+                                            u32 mask)
+{
+        pch_udc_bit_set(dev, UDC_DEVIRQMSK_ADDR, mask);
+}
+
+/**
+ * pch_udc_enable_interrupts() - Enable the specified interrupts
+ * @dev:        Reference to structure of type pch_udc_regs
+ * @mask:       Mask to enable interrupts
+ */
+static inline void pch_udc_enable_interrupts(struct pch_udc_dev *dev,
+                                           u32 mask)
+{
+        pch_udc_bit_clr(dev, UDC_DEVIRQMSK_ADDR, mask);
+}
+
+/**
+ * pch_udc_disable_ep_interrupts() - Disable endpoint interrupts
+ * @dev:        Reference to structure of type pch_udc_regs
+ * @mask:       Mask to disable interrupts
+ */
+static inline void pch_udc_disable_ep_interrupts(struct pch_udc_dev *dev,
+                                                u32 mask)
+{
+        pch_udc_bit_set(dev, UDC_EPIRQMSK_ADDR, mask);
+}
+
+/**
+ * pch_udc_enable_ep_interrupts() - Enable endpoint interrupts
+ * @dev:        Reference to structure of type pch_udc_regs
+ * @mask:       Mask to enable interrupts
+ */
+static inline void pch_udc_enable_ep_interrupts(struct pch_udc_dev *dev,
+                                              u32 mask)
+{
+        pch_udc_bit_clr(dev, UDC_EPIRQMSK_ADDR, mask);
+}
+
+/**
+ * pch_udc_read_device_interrupts() - Read the device interrupts
+ * @dev:        Reference to structure of type pch_udc_regs
+ * Retern       The device interrupts
+ */
+static inline u32 pch_udc_read_device_interrupts(struct pch_udc_dev *dev)
+{
+        return pch_udc_readl(dev, UDC_DEVIRQSTS_ADDR);
+}
+
+/**
+ * pch_udc_write_device_interrupts() - Write device interrupts
+ * @dev:        Reference to structure of type pch_udc_regs
+ * @val:        The value to be written to interrupt register
+ */
+static inline void pch_udc_write_device_interrupts(struct pch_udc_dev *dev,
+                                                     u32 val)
+{
+        pch_udc_writel(dev, val, UDC_DEVIRQSTS_ADDR);
+}
+
+/**
+ * pch_udc_read_ep_interrupts() - Read the endpoint interrupts
+ * @dev:        Reference to structure of type pch_udc_regs
+ * Retern       The endpoint interrupt
+ */
+static inline u32 pch_udc_read_ep_interrupts(struct pch_udc_dev *dev)
+{
+        return pch_udc_readl(dev, UDC_EPIRQSTS_ADDR);
+}
+
+/**
+ * pch_udc_write_ep_interrupts() - Clear endpoint interupts
+ * @dev:        Reference to structure of type pch_udc_regs
+ * @val:        The value to be written to interrupt register
+ */
+static inline void pch_udc_write_ep_interrupts(struct pch_udc_dev *dev,
+                                             u32 val)
+{
+        pch_udc_writel(dev, val, UDC_EPIRQSTS_ADDR);
+}
+
+/**
+ * pch_udc_read_device_status() - Read the device status
+ * @dev:        Reference to structure of type pch_udc_regs
+ * Retern       The device status
+ */
+static inline u32 pch_udc_read_device_status(struct pch_udc_dev *dev)
+{
+        return pch_udc_readl(dev, UDC_DEVSTS_ADDR);
+}
+
+/**
+ * pch_udc_read_ep_control() - Read the endpoint control
+ * @ep:         Reference to structure of type pch_udc_ep_regs
+ * Retern       The endpoint control register value
+ */
+static inline u32 pch_udc_read_ep_control(struct pch_udc_ep *ep)
+{
+        return pch_udc_ep_readl(ep, UDC_EPCTL_ADDR);
+}
+
+/**
+ * pch_udc_clear_ep_control() - Clear the endpoint control register
+ * @ep:         Reference to structure of type pch_udc_ep_regs
+ * Retern       The endpoint control register value
+ */
+static inline void pch_udc_clear_ep_control(struct pch_udc_ep *ep)
+{
+        return pch_udc_ep_writel(ep, 0, UDC_EPCTL_ADDR);
+}
+
+/**
+ * pch_udc_read_ep_status() - Read the endpoint status
+ * @ep:         Reference to structure of type pch_udc_ep_regs
+ * Retern       The endpoint status
+ */
+static inline u32 pch_udc_read_ep_status(struct pch_udc_ep *ep)
+{
+        return pch_udc_ep_readl(ep, UDC_EPSTS_ADDR);
+}
+
+/**
+ * pch_udc_clear_ep_status() - Clear the endpoint status
+ * @ep:         Reference to structure of type pch_udc_ep_regs
+ * @stat:       Endpoint status
+ */
+static inline void pch_udc_clear_ep_status(struct pch_udc_ep *ep,
+                                         u32 stat)
+{
+        return pch_udc_ep_writel(ep, stat, UDC_EPSTS_ADDR);
+}
+
+/**
+ * pch_udc_ep_set_nak() - Set the bit 7 (SNAK field)
+ *                              of the endpoint control register
+ * @ep:         Reference to structure of type pch_udc_ep_regs
+ */
+static inline void pch_udc_ep_set_nak(struct pch_udc_ep *ep)
+{
+        pch_udc_ep_bit_set(ep, UDC_EPCTL_ADDR, UDC_EPCTL_SNAK);
+}
+
+/**
+ * pch_udc_ep_clear_nak() - Set the bit 8 (CNAK field)
+ *                              of the endpoint control register
+ * @ep:         reference to structure of type pch_udc_ep_regs
+ */
+static void pch_udc_ep_clear_nak(struct pch_udc_ep *ep)
+{
+        unsigned int loopcnt = 0;
+        struct pch_udc_dev *dev = ep->dev;
+
+        if (!(pch_udc_ep_readl(ep, UDC_EPCTL_ADDR) & UDC_EPCTL_NAK))
+                return;
+        if (!ep->in) {
+                loopcnt = 10000;
+                while (!(pch_udc_read_ep_status(ep) & UDC_EPSTS_MRXFIFO_EMP) &&
+                        --loopcnt)
+                        udelay(5);
+                if (!loopcnt)
+                        dev_err(&dev->pdev->dev, "%s: RxFIFO not Empty\n",
+                                __func__);
+        }
+        loopcnt = 10000;
+        while ((pch_udc_read_ep_control(ep) & UDC_EPCTL_NAK) && --loopcnt) {
+                pch_udc_ep_bit_set(ep, UDC_EPCTL_ADDR, UDC_EPCTL_CNAK);
+                udelay(5);
+        }
+        if (!loopcnt)
+                dev_err(&dev->pdev->dev, "%s: Clear NAK not set for ep%d%s\n",
+                        __func__, ep->num, (ep->in ? "in" : "out"));
+}
+
+/**
+ * pch_udc_ep_fifo_flush() - Flush the endpoint fifo
+ * @ep: reference to structure of type pch_udc_ep_regs
+ * @dir:        direction of endpoint
+ *                0:  endpoint is OUT
+ *                !0: endpoint is IN
+ */
+static void pch_udc_ep_fifo_flush(struct pch_udc_ep *ep, int dir)
+{
+        if (dir) {      /* IN ep */
+                pch_udc_ep_bit_set(ep, UDC_EPCTL_ADDR, UDC_EPCTL_F);
+                return;
+        }
+}
+
+/**
+ * pch_udc_ep_enable() - This api enables endpoint
+ * @regs:       Reference to structure pch_udc_ep_regs
+ * @desc:       endpoint descriptor
+ */
+static void pch_udc_ep_enable(struct pch_udc_ep *ep,
+                               struct pch_udc_cfg_data *cfg,
+                               const struct usb_endpoint_descriptor *desc)
+{
+        u32 val = 0;
+        u32 buff_size = 0;
+
+        pch_udc_ep_set_trfr_type(ep, desc->bmAttributes);
+        if (ep->in)
+                buff_size = UDC_EPIN_BUFF_SIZE;
+        else
+                buff_size = UDC_EPOUT_BUFF_SIZE;
+        pch_udc_ep_set_bufsz(ep, buff_size, ep->in);
+        pch_udc_ep_set_maxpkt(ep, le16_to_cpu(desc->wMaxPacketSize));
+        pch_udc_ep_set_nak(ep);
+        pch_udc_ep_fifo_flush(ep, ep->in);
+        /* Configure the endpoint */
+        val = ep->num << UDC_CSR_NE_NUM_SHIFT | ep->in << UDC_CSR_NE_DIR_SHIFT |
+              ((desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) <<
+                UDC_CSR_NE_TYPE_SHIFT) |
+              (cfg->cur_cfg << UDC_CSR_NE_CFG_SHIFT) |
+              (cfg->cur_intf << UDC_CSR_NE_INTF_SHIFT) |
+              (cfg->cur_alt << UDC_CSR_NE_ALT_SHIFT) |
+              le16_to_cpu(desc->wMaxPacketSize) << UDC_CSR_NE_MAX_PKT_SHIFT;
+
+        if (ep->in)
+                pch_udc_write_csr(ep->dev, val, UDC_EPIN_IDX(ep->num));
+        else
+                pch_udc_write_csr(ep->dev, val, UDC_EPOUT_IDX(ep->num));
+}
+
+/**
+ * pch_udc_ep_disable() - This api disables endpoint
+ * @regs:       Reference to structure pch_udc_ep_regs
+ */
+static void pch_udc_ep_disable(struct pch_udc_ep *ep)
+{
+        if (ep->in) {
+                /* flush the fifo */
+                pch_udc_ep_writel(ep, UDC_EPCTL_F, UDC_EPCTL_ADDR);
+                /* set NAK */
+                pch_udc_ep_writel(ep, UDC_EPCTL_SNAK, UDC_EPCTL_ADDR);
+                pch_udc_ep_bit_set(ep, UDC_EPSTS_ADDR, UDC_EPSTS_IN);
+        } else {
+                /* set NAK */
+                pch_udc_ep_writel(ep, UDC_EPCTL_SNAK, UDC_EPCTL_ADDR);
+        }
+        /* reset desc pointer */
+        pch_udc_ep_writel(ep, 0, UDC_DESPTR_ADDR);
+}
+
+/**
+ * pch_udc_wait_ep_stall() - Wait EP stall.
+ * @dev:        Reference to pch_udc_dev structure
+ */
+static void pch_udc_wait_ep_stall(struct pch_udc_ep *ep)
+{
+        unsigned int count = 10000;
+
+        /* Wait till idle */
+        while ((pch_udc_read_ep_control(ep) & UDC_EPCTL_S) && --count)
+                udelay(5);
+        if (!count)
+                dev_err(&ep->dev->pdev->dev, "%s: wait error\n", __func__);
+}
+
+/**
+ * pch_udc_init() - This API initializes usb device controller
+ * @dev:        Rreference to pch_udc_regs structure
+ */
+static void pch_udc_init(struct pch_udc_dev *dev)
+{
+        if (NULL == dev) {
+                pr_err("%s: Invalid address\n", __func__);
+                return;
+        }
+        /* Soft Reset and Reset PHY */
+        pch_udc_writel(dev, UDC_SRST, UDC_SRST_ADDR);
+        pch_udc_writel(dev, UDC_SRST | UDC_PSRST, UDC_SRST_ADDR);
+        mdelay(1);
+        pch_udc_writel(dev, UDC_SRST, UDC_SRST_ADDR);
+        pch_udc_writel(dev, 0x00, UDC_SRST_ADDR);
+        mdelay(1);
+        /* mask and clear all device interrupts */
+        pch_udc_bit_set(dev, UDC_DEVIRQMSK_ADDR, UDC_DEVINT_MSK);
+        pch_udc_bit_set(dev, UDC_DEVIRQSTS_ADDR, UDC_DEVINT_MSK);
+
+        /* mask and clear all ep interrupts */
+        pch_udc_bit_set(dev, UDC_EPIRQMSK_ADDR, UDC_EPINT_MSK_DISABLE_ALL);
+        pch_udc_bit_set(dev, UDC_EPIRQSTS_ADDR, UDC_EPINT_MSK_DISABLE_ALL);
+
+        /* enable dynamic CSR programmingi, self powered and device speed */
+        if (speed_fs)
+                pch_udc_bit_set(dev, UDC_DEVCFG_ADDR, UDC_DEVCFG_CSR_PRG |
+                                UDC_DEVCFG_SP | UDC_DEVCFG_SPD_FS);
+        else /* defaul high speed */
+                pch_udc_bit_set(dev, UDC_DEVCFG_ADDR, UDC_DEVCFG_CSR_PRG |
+                                UDC_DEVCFG_SP | UDC_DEVCFG_SPD_HS);
+        pch_udc_bit_set(dev, UDC_DEVCTL_ADDR,
+                        (PCH_UDC_THLEN << UDC_DEVCTL_THLEN_SHIFT) |
+                        (PCH_UDC_BRLEN << UDC_DEVCTL_BRLEN_SHIFT) |
+                        UDC_DEVCTL_MODE | UDC_DEVCTL_BREN |
+                        UDC_DEVCTL_THE);
+}
+
+/**
+ * pch_udc_exit() - This API exit usb device controller
+ * @dev:        Reference to pch_udc_regs structure
+ */
+static void pch_udc_exit(struct pch_udc_dev *dev)
+{
+        /* mask all device interrupts */
+        pch_udc_bit_set(dev, UDC_DEVIRQMSK_ADDR, UDC_DEVINT_MSK);
+        /* mask all ep interrupts */
+        pch_udc_bit_set(dev, UDC_EPIRQMSK_ADDR, UDC_EPINT_MSK_DISABLE_ALL);
+        /* put device in disconnected state */
+        pch_udc_set_disconnect(dev);
+}
+
+/**
+ * pch_udc_pcd_get_frame() - This API is invoked to get the current frame number
+ * @gadget:     Reference to the gadget driver
+ *
+ * Return codes:
+ *      0:              Success
+ *      -EINVAL:        If the gadget passed is NULL
+ */
+static int pch_udc_pcd_get_frame(struct usb_gadget *gadget)
+{
+        struct pch_udc_dev      *dev;
+
+        if (!gadget)
+                return -EINVAL;
+        dev = container_of(gadget, struct pch_udc_dev, gadget);
+        return pch_udc_get_frame(dev);
+}
+
+/**
+ * pch_udc_pcd_wakeup() - This API is invoked to initiate a remote wakeup
+ * @gadget:     Reference to the gadget driver
+ *
+ * Return codes:
+ *      0:              Success
+ *      -EINVAL:        If the gadget passed is NULL
+ */
+static int pch_udc_pcd_wakeup(struct usb_gadget *gadget)
+{
+        struct pch_udc_dev      *dev;
+        unsigned long           flags;
+
+        if (!gadget)
+                return -EINVAL;
+        dev = container_of(gadget, struct pch_udc_dev, gadget);
+        spin_lock_irqsave(&dev->lock, flags);
+        pch_udc_rmt_wakeup(dev);
+        spin_unlock_irqrestore(&dev->lock, flags);
+        return 0;
+}
+
+/**
+ * pch_udc_pcd_selfpowered() - This API is invoked to specify whether the device
+ *                              is self powered or not
+ * @gadget:     Reference to the gadget driver
+ * @value:      Specifies self powered or not
+ *
+ * Return codes:
+ *      0:              Success
+ *      -EINVAL:        If the gadget passed is NULL
+ */
+static int pch_udc_pcd_selfpowered(struct usb_gadget *gadget, int value)
+{
+        struct pch_udc_dev      *dev;
+
+        if (!gadget)
+                return -EINVAL;
+        dev = container_of(gadget, struct pch_udc_dev, gadget);
+        if (value)
+                pch_udc_set_selfpowered(dev);
+        else
+                pch_udc_clear_selfpowered(dev);
+        return 0;
+}
+
+/**
+ * pch_udc_pcd_pullup() - This API is invoked to make the device
+ *                              visible/invisible to the host
+ * @gadget:     Reference to the gadget driver
+ * @is_on:      Specifies whether the pull up is made active or inactive
+ *
+ * Return codes:
+ *      0:              Success
+ *      -EINVAL:        If the gadget passed is NULL
+ */
+static int pch_udc_pcd_pullup(struct usb_gadget *gadget, int is_on)
+{
+        struct pch_udc_dev      *dev;
+
+        if (!gadget)
+                return -EINVAL;
+        dev = container_of(gadget, struct pch_udc_dev, gadget);
+        pch_udc_vbus_session(dev, is_on);
+        return 0;
+}
+
+/**
+ * pch_udc_pcd_vbus_session() - This API is used by a driver for an external
+ *                              transceiver (or GPIO) that
+ *                              detects a VBUS power session starting/ending
+ * @gadget:     Reference to the gadget driver
+ * @is_active:  specifies whether the session is starting or ending
+ *
+ * Return codes:
+ *      0:              Success
+ *      -EINVAL:        If the gadget passed is NULL
+ */
+static int pch_udc_pcd_vbus_session(struct usb_gadget *gadget, int is_active)
+{
+        struct pch_udc_dev      *dev;
+
+        if (!gadget)
+                return -EINVAL;
+        dev = container_of(gadget, struct pch_udc_dev, gadget);
+        pch_udc_vbus_session(dev, is_active);
+        return 0;
+}
+
+/**
+ * pch_udc_pcd_vbus_draw() - This API is used by gadget drivers during
+ *                              SET_CONFIGURATION calls to
+ *                              specify how much power the device can consume
+ * @gadget:     Reference to the gadget driver
+ * @mA:         specifies the current limit in 2mA unit
+ *
+ * Return codes:
+ *      -EINVAL:        If the gadget passed is NULL
+ *      -EOPNOTSUPP:
+ */
+static int pch_udc_pcd_vbus_draw(struct usb_gadget *gadget, unsigned int mA)
+{
+        return -EOPNOTSUPP;
+}
+
+static const struct usb_gadget_ops pch_udc_ops = {
+        .get_frame = pch_udc_pcd_get_frame,
+        .wakeup = pch_udc_pcd_wakeup,
+        .set_selfpowered = pch_udc_pcd_selfpowered,
+        .pullup = pch_udc_pcd_pullup,
+        .vbus_session = pch_udc_pcd_vbus_session,
+        .vbus_draw = pch_udc_pcd_vbus_draw,
+};
+
+/**
+ * complete_req() - This API is invoked from the driver when processing
+ *                      of a request is complete
+ * @ep:         Reference to the endpoint structure
+ * @req:        Reference to the request structure
+ * @status:     Indicates the success/failure of completion
+ */
+static void complete_req(struct pch_udc_ep *ep, struct pch_udc_request *req,
+                                                                 int status)
+{
+        struct pch_udc_dev      *dev;
+        unsigned halted = ep->halted;
+
+        list_del_init(&req->queue);
+
+        /* set new status if pending */
+        if (req->req.status == -EINPROGRESS)
+                req->req.status = status;
+        else
+                status = req->req.status;
+
+        dev = ep->dev;
+        if (req->dma_mapped) {
+                if (req->dma == DMA_ADDR_INVALID) {
+                        if (ep->in)
+                                dma_unmap_single(&dev->pdev->dev, req->req.dma,
+                                                 req->req.length,
+                                                 DMA_TO_DEVICE);
+                        else
+                                dma_unmap_single(&dev->pdev->dev, req->req.dma,
+                                                 req->req.length,
+                                                 DMA_FROM_DEVICE);
+                        req->req.dma = DMA_ADDR_INVALID;
+                } else {
+                        if (ep->in)
+                                dma_unmap_single(&dev->pdev->dev, req->dma,
+                                                 req->req.length,
+                                                 DMA_TO_DEVICE);
+                        else {
+                                dma_unmap_single(&dev->pdev->dev, req->dma,
+                                                 req->req.length,
+                                                 DMA_FROM_DEVICE);
+                                memcpy(req->req.buf, req->buf, req->req.length);
+                        }
+                        kfree(req->buf);
+                        req->dma = DMA_ADDR_INVALID;
+                }
+                req->dma_mapped = 0;
+        }
+        ep->halted = 1;
+        spin_unlock(&dev->lock);
+        if (!ep->in)
+                pch_udc_ep_clear_rrdy(ep);
+        req->req.complete(&ep->ep, &req->req);
+        spin_lock(&dev->lock);
+        ep->halted = halted;
+}
+
+/**
+ * empty_req_queue() - This API empties the request queue of an endpoint
+ * @ep:         Reference to the endpoint structure
+ */
+static void empty_req_queue(struct pch_udc_ep *ep)
+{
+        struct pch_udc_request  *req;
+
+        ep->halted = 1;
+        while (!list_empty(&ep->queue)) {
+                req = list_entry(ep->queue.next, struct pch_udc_request, queue);
+                complete_req(ep, req, -ESHUTDOWN);      /* Remove from list */
+        }
+}
+
+/**
+ * pch_udc_free_dma_chain() - This function frees the DMA chain created
+ *                              for the request
+ * @dev         Reference to the driver structure
+ * @req         Reference to the request to be freed
+ *
+ * Return codes:
+ *      0: Success
+ */
+static void pch_udc_free_dma_chain(struct pch_udc_dev *dev,
+                                   struct pch_udc_request *req)
+{
+        struct pch_udc_data_dma_desc *td = req->td_data;
+        unsigned i = req->chain_len;
+
+        dma_addr_t addr2;
+        dma_addr_t addr = (dma_addr_t)td->next;
+        td->next = 0x00;
+        for (; i > 1; --i) {
+                /* do not free first desc., will be done by free for request */
+                td = phys_to_virt(addr);
+                addr2 = (dma_addr_t)td->next;
+                pci_pool_free(dev->data_requests, td, addr);
+                td->next = 0x00;
+                addr = addr2;
+        }
+        req->chain_len = 1;
+}
+
+/**
+ * pch_udc_create_dma_chain() - This function creates or reinitializes
+ *                              a DMA chain
+ * @ep:         Reference to the endpoint structure
+ * @req:        Reference to the request
+ * @buf_len:    The buffer length
+ * @gfp_flags:  Flags to be used while mapping the data buffer
+ *
+ * Return codes:
+ *      0:              success,
+ *      -ENOMEM:        pci_pool_alloc invocation fails
+ */
+static int pch_udc_create_dma_chain(struct pch_udc_ep *ep,
+                                    struct pch_udc_request *req,
+                                    unsigned long buf_len,
+                                    gfp_t gfp_flags)
+{
+        struct pch_udc_data_dma_desc *td = req->td_data, *last;
+        unsigned long bytes = req->req.length, i = 0;
+        dma_addr_t dma_addr;
+        unsigned len = 1;
+
+        if (req->chain_len > 1)
+                pch_udc_free_dma_chain(ep->dev, req);
+
+        if (req->dma == DMA_ADDR_INVALID)
+                td->dataptr = req->req.dma;
+        else
+                td->dataptr = req->dma;
+
+        td->status = PCH_UDC_BS_HST_BSY;
+        for (; ; bytes -= buf_len, ++len) {
+                td->status = PCH_UDC_BS_HST_BSY | min(buf_len, bytes);
+                if (bytes <= buf_len)
+                        break;
+                last = td;
+                td = pci_pool_alloc(ep->dev->data_requests, gfp_flags,
+                                    &dma_addr);
+                if (!td)
+                        goto nomem;
+                i += buf_len;
+                td->dataptr = req->td_data->dataptr + i;
+                last->next = dma_addr;
+        }
+
+        req->td_data_last = td;
+        td->status |= PCH_UDC_DMA_LAST;
+        td->next = req->td_data_phys;
+        req->chain_len = len;
+        return 0;
+
+nomem:
+        if (len > 1) {
+                req->chain_len = len;
+                pch_udc_free_dma_chain(ep->dev, req);
+        }
+        req->chain_len = 1;
+        return -ENOMEM;
+}
+
+/**
+ * prepare_dma() - This function creates and initializes the DMA chain
+ *                      for the request
+ * @ep:         Reference to the endpoint structure
+ * @req:        Reference to the request
+ * @gfp:        Flag to be used while mapping the data buffer
+ *
+ * Return codes:
+ *      0:              Success
+ *      Other 0:        linux error number on failure
+ */
+static int prepare_dma(struct pch_udc_ep *ep, struct pch_udc_request *req,
+                          gfp_t gfp)
+{
+        int     retval;
+
+        /* Allocate and create a DMA chain */
+        retval = pch_udc_create_dma_chain(ep, req, ep->ep.maxpacket, gfp);
+        if (retval) {
+                pr_err("%s: could not create DMA chain:%d\n", __func__, retval);
+                return retval;
+        }
+        if (ep->in)
+                req->td_data->status = (req->td_data->status &
+                                ~PCH_UDC_BUFF_STS) | PCH_UDC_BS_HST_RDY;
+        return 0;
+}
+
+/**
+ * process_zlp() - This function process zero length packets
+ *                      from the gadget driver
+ * @ep:         Reference to the endpoint structure
+ * @req:        Reference to the request
+ */
+static void process_zlp(struct pch_udc_ep *ep, struct pch_udc_request *req)
+{
+        struct pch_udc_dev      *dev = ep->dev;
+
+        /* IN zlp's are handled by hardware */
+        complete_req(ep, req, 0);
+
+        /* if set_config or set_intf is waiting for ack by zlp
+         * then set CSR_DONE
+         */
+        if (dev->set_cfg_not_acked) {
+                pch_udc_set_csr_done(dev);
+                dev->set_cfg_not_acked = 0;
+        }
+        /* setup command is ACK'ed now by zlp */
+        if (!dev->stall && dev->waiting_zlp_ack) {
+                pch_udc_ep_clear_nak(&(dev->ep[UDC_EP0IN_IDX]));
+                dev->waiting_zlp_ack = 0;
+        }
+}
+
+/**
+ * pch_udc_start_rxrequest() - This function starts the receive requirement.
+ * @ep:         Reference to the endpoint structure
+ * @req:        Reference to the request structure
+ */
+static void pch_udc_start_rxrequest(struct pch_udc_ep *ep,
+                                         struct pch_udc_request *req)
+{
+        struct pch_udc_data_dma_desc *td_data;
+
+        pch_udc_clear_dma(ep->dev, DMA_DIR_RX);
+        td_data = req->td_data;
+        /* Set the status bits for all descriptors */
+        while (1) {
+                td_data->status = (td_data->status & ~PCH_UDC_BUFF_STS) |
+                                    PCH_UDC_BS_HST_RDY;
+                if ((td_data->status & PCH_UDC_DMA_LAST) ==  PCH_UDC_DMA_LAST)
+                        break;
+                td_data = phys_to_virt(td_data->next);
+        }
+        /* Write the descriptor pointer */
+        pch_udc_ep_set_ddptr(ep, req->td_data_phys);
+        req->dma_going = 1;
+        pch_udc_enable_ep_interrupts(ep->dev, UDC_EPINT_OUT_EP0 << ep->num);
+        pch_udc_set_dma(ep->dev, DMA_DIR_RX);
+        pch_udc_ep_clear_nak(ep);
+        pch_udc_ep_set_rrdy(ep);
+}
+
+/**
+ * pch_udc_pcd_ep_enable() - This API enables the endpoint. It is called
+ *                              from gadget driver
+ * @usbep:      Reference to the USB endpoint structure
+ * @desc:       Reference to the USB endpoint descriptor structure
+ *
+ * Return codes:
+ *      0:              Success
+ *      -EINVAL:
+ *      -ESHUTDOWN:
+ */
+static int pch_udc_pcd_ep_enable(struct usb_ep *usbep,
+                                    const struct usb_endpoint_descriptor *desc)
+{
+        struct pch_udc_ep       *ep;
+        struct pch_udc_dev      *dev;
+        unsigned long           iflags;
+
+        if (!usbep || (usbep->name == ep0_string) || !desc ||
+            (desc->bDescriptorType != USB_DT_ENDPOINT) || !desc->wMaxPacketSize)
+                return -EINVAL;
+
+        ep = container_of(usbep, struct pch_udc_ep, ep);
+        dev = ep->dev;
+        if (!dev->driver || (dev->gadget.speed == USB_SPEED_UNKNOWN))
+                return -ESHUTDOWN;
+        spin_lock_irqsave(&dev->lock, iflags);
+        ep->desc = desc;
+        ep->halted = 0;
+        pch_udc_ep_enable(ep, &ep->dev->cfg_data, desc);
+        ep->ep.maxpacket = le16_to_cpu(desc->wMaxPacketSize);
+        pch_udc_enable_ep_interrupts(ep->dev, PCH_UDC_EPINT(ep->in, ep->num));
+        spin_unlock_irqrestore(&dev->lock, iflags);
+        return 0;
+}
+
+/**
+ * pch_udc_pcd_ep_disable() - This API disables endpoint and is called
+ *                              from gadget driver
+ * @usbep       Reference to the USB endpoint structure
+ *
+ * Return codes:
+ *      0:              Success
+ *      -EINVAL:
+ */
+static int pch_udc_pcd_ep_disable(struct usb_ep *usbep)
+{
+        struct pch_udc_ep       *ep;
+        struct pch_udc_dev      *dev;
+        unsigned long   iflags;
+
+        if (!usbep)
+                return -EINVAL;
+
+        ep = container_of(usbep, struct pch_udc_ep, ep);
+        dev = ep->dev;
+        if ((usbep->name == ep0_string) || !ep->desc)
+                return -EINVAL;
+
+        spin_lock_irqsave(&ep->dev->lock, iflags);
+        empty_req_queue(ep);
+        ep->halted = 1;
+        pch_udc_ep_disable(ep);
+        pch_udc_disable_ep_interrupts(ep->dev, PCH_UDC_EPINT(ep->in, ep->num));
+        ep->desc = NULL;
+        INIT_LIST_HEAD(&ep->queue);
+        spin_unlock_irqrestore(&ep->dev->lock, iflags);
+        return 0;
+}
+
+/**
+ * pch_udc_alloc_request() - This function allocates request structure.
+ *                              It is called by gadget driver
+ * @usbep:      Reference to the USB endpoint structure
+ * @gfp:        Flag to be used while allocating memory
+ *
+ * Return codes:
+ *      NULL:                   Failure
+ *      Allocated address:      Success
+ */
+static struct usb_request *pch_udc_alloc_request(struct usb_ep *usbep,
+                                                  gfp_t gfp)
+{
+        struct pch_udc_request          *req;
+        struct pch_udc_ep               *ep;
+        struct pch_udc_data_dma_desc    *dma_desc;
+        struct pch_udc_dev              *dev;
+
+        if (!usbep)
+                return NULL;
+        ep = container_of(usbep, struct pch_udc_ep, ep);
+        dev = ep->dev;
+        req = kzalloc(sizeof *req, gfp);
+        if (!req)
+                return NULL;
+        req->req.dma = DMA_ADDR_INVALID;
+        req->dma = DMA_ADDR_INVALID;
+        INIT_LIST_HEAD(&req->queue);
+        if (!ep->dev->dma_addr)
+                return &req->req;
+        /* ep0 in requests are allocated from data pool here */
+        dma_desc = pci_pool_alloc(ep->dev->data_requests, gfp,
+                                  &req->td_data_phys);
+        if (NULL == dma_desc) {
+                kfree(req);
+                return NULL;
+        }
+        /* prevent from using desc. - set HOST BUSY */
+        dma_desc->status |= PCH_UDC_BS_HST_BSY;
+        dma_desc->dataptr = __constant_cpu_to_le32(DMA_ADDR_INVALID);
+        req->td_data = dma_desc;
+        req->td_data_last = dma_desc;
+        req->chain_len = 1;
+        return &req->req;
+}
+
+/**
+ * pch_udc_free_request() - This function frees request structure.
+ *                              It is called by gadget driver
+ * @usbep:      Reference to the USB endpoint structure
+ * @usbreq:     Reference to the USB request
+ */
+static void pch_udc_free_request(struct usb_ep *usbep,
+                                  struct usb_request *usbreq)
+{
+        struct pch_udc_ep       *ep;
+        struct pch_udc_request  *req;
+        struct pch_udc_dev      *dev;
+
+        if (!usbep || !usbreq)
+                return;
+        ep = container_of(usbep, struct pch_udc_ep, ep);
+        req = container_of(usbreq, struct pch_udc_request, req);
+        dev = ep->dev;
+        if (!list_empty(&req->queue))
+                dev_err(&dev->pdev->dev, "%s: %s req=0x%p queue not empty\n",
+                        __func__, usbep->name, req);
+        if (req->td_data != NULL) {
+                if (req->chain_len > 1)
+                        pch_udc_free_dma_chain(ep->dev, req);
+                pci_pool_free(ep->dev->data_requests, req->td_data,
+                              req->td_data_phys);
+        }
+        kfree(req);
+}
+
+/**
+ * pch_udc_pcd_queue() - This function queues a request packet. It is called
+ *                      by gadget driver
+ * @usbep:      Reference to the USB endpoint structure
+ * @usbreq:     Reference to the USB request
+ * @gfp:        Flag to be used while mapping the data buffer
+ *
+ * Return codes:
+ *      0:                      Success
+ *      linux error number:     Failure
+ */
+static int pch_udc_pcd_queue(struct usb_ep *usbep, struct usb_request *usbreq,
+                                                                 gfp_t gfp)
+{
+        int retval = 0;
+        struct pch_udc_ep       *ep;
+        struct pch_udc_dev      *dev;
+        struct pch_udc_request  *req;
+        unsigned long   iflags;
+
+        if (!usbep || !usbreq || !usbreq->complete || !usbreq->buf)
+                return -EINVAL;
+        ep = container_of(usbep, struct pch_udc_ep, ep);
+        dev = ep->dev;
+        if (!ep->desc && ep->num)
+                return -EINVAL;
+        req = container_of(usbreq, struct pch_udc_request, req);
+        if (!list_empty(&req->queue))
+                return -EINVAL;
+        if (!dev->driver || (dev->gadget.speed == USB_SPEED_UNKNOWN))
+                return -ESHUTDOWN;
+        spin_lock_irqsave(&dev->lock, iflags);
+        /* map the buffer for dma */
+        if (usbreq->length &&
+            ((usbreq->dma == DMA_ADDR_INVALID) || !usbreq->dma)) {
+                if (!((unsigned long)(usbreq->buf) & 0x03)) {
+                        if (ep->in)
+                                usbreq->dma = dma_map_single(&dev->pdev->dev,
+                                                             usbreq->buf,
+                                                             usbreq->length,
+                                                             DMA_TO_DEVICE);
+                        else
+                                usbreq->dma = dma_map_single(&dev->pdev->dev,
+                                                             usbreq->buf,
+                                                             usbreq->length,
+                                                             DMA_FROM_DEVICE);
+                } else {
+                        req->buf = kzalloc(usbreq->length, GFP_ATOMIC);
+                        if (!req->buf) {
+                                retval = -ENOMEM;
+                                goto probe_end;
+                        }
+                        if (ep->in) {
+                                memcpy(req->buf, usbreq->buf, usbreq->length);
+                                req->dma = dma_map_single(&dev->pdev->dev,
+                                                          req->buf,
+                                                          usbreq->length,
+                                                          DMA_TO_DEVICE);
+                        } else
+                                req->dma = dma_map_single(&dev->pdev->dev,
+                                                          req->buf,
+                                                          usbreq->length,
+                                                          DMA_FROM_DEVICE);
+                }
+                req->dma_mapped = 1;
+        }
+        if (usbreq->length > 0) {
+                retval = prepare_dma(ep, req, GFP_ATOMIC);
+                if (retval)
+                        goto probe_end;
+        }
+        usbreq->actual = 0;
+        usbreq->status = -EINPROGRESS;
+        req->dma_done = 0;
+        if (list_empty(&ep->queue) && !ep->halted) {
+                /* no pending transfer, so start this req */
+                if (!usbreq->length) {
+                        process_zlp(ep, req);
+                        retval = 0;
+                        goto probe_end;
+                }
+                if (!ep->in) {
+                        pch_udc_start_rxrequest(ep, req);
+                } else {
+                        /*
+                        * For IN trfr the descriptors will be programmed and
+                        * P bit will be set when
+                        * we get an IN token
+                        */
+                        pch_udc_wait_ep_stall(ep);
+                        pch_udc_ep_clear_nak(ep);
+                        pch_udc_enable_ep_interrupts(ep->dev, (1 << ep->num));
+                }
+        }
+        /* Now add this request to the ep's pending requests */
+        if (req != NULL)
+                list_add_tail(&req->queue, &ep->queue);
+
+probe_end:
+        spin_unlock_irqrestore(&dev->lock, iflags);
+        return retval;
+}
+
+/**
+ * pch_udc_pcd_dequeue() - This function de-queues a request packet.
+ *                              It is called by gadget driver
+ * @usbep:      Reference to the USB endpoint structure
+ * @usbreq:     Reference to the USB request
+ *
+ * Return codes:
+ *      0:                      Success
+ *      linux error number:     Failure
+ */
+static int pch_udc_pcd_dequeue(struct usb_ep *usbep,
+                                struct usb_request *usbreq)
+{
+        struct pch_udc_ep       *ep;
+        struct pch_udc_request  *req;
+        struct pch_udc_dev      *dev;
+        unsigned long           flags;
+        int ret = -EINVAL;
+
+        ep = container_of(usbep, struct pch_udc_ep, ep);
+        dev = ep->dev;
+        if (!usbep || !usbreq || (!ep->desc && ep->num))
+                return ret;
+        req = container_of(usbreq, struct pch_udc_request, req);
+        spin_lock_irqsave(&ep->dev->lock, flags);
+        /* make sure it's still queued on this endpoint */
+        list_for_each_entry(req, &ep->queue, queue) {
+                if (&req->req == usbreq) {
+                        pch_udc_ep_set_nak(ep);
+                        if (!list_empty(&req->queue))
+                                complete_req(ep, req, -ECONNRESET);
+                        ret = 0;
+                        break;
+                }
+        }
+        spin_unlock_irqrestore(&ep->dev->lock, flags);
+        return ret;
+}
+
+/**
+ * pch_udc_pcd_set_halt() - This function Sets or clear the endpoint halt
+ *                          feature
+ * @usbep:      Reference to the USB endpoint structure
+ * @halt:       Specifies whether to set or clear the feature
+ *
+ * Return codes:
+ *      0:                      Success
+ *      linux error number:     Failure
+ */
+static int pch_udc_pcd_set_halt(struct usb_ep *usbep, int halt)
+{
+        struct pch_udc_ep       *ep;
+        struct pch_udc_dev      *dev;
+        unsigned long iflags;
+        int ret;
+
+        if (!usbep)
+                return -EINVAL;
+        ep = container_of(usbep, struct pch_udc_ep, ep);
+        dev = ep->dev;
+        if (!ep->desc && !ep->num)
+                return -EINVAL;
+        if (!ep->dev->driver || (ep->dev->gadget.speed == USB_SPEED_UNKNOWN))
+                return -ESHUTDOWN;
+        spin_lock_irqsave(&udc_stall_spinlock, iflags);
+        if (list_empty(&ep->queue)) {
+                if (halt) {
+                        if (ep->num == PCH_UDC_EP0)
+                                ep->dev->stall = 1;
+                        pch_udc_ep_set_stall(ep);
+                        pch_udc_enable_ep_interrupts(ep->dev,
+                                                     PCH_UDC_EPINT(ep->in,
+                                                                   ep->num));
+                } else {
+                        pch_udc_ep_clear_stall(ep);
+                }
+                ret = 0;
+        } else {
+                ret = -EAGAIN;
+        }
+        spin_unlock_irqrestore(&udc_stall_spinlock, iflags);
+        return ret;
+}
+
+/**
+ * pch_udc_pcd_set_wedge() - This function Sets or clear the endpoint
+ *                              halt feature
+ * @usbep:      Reference to the USB endpoint structure
+ * @halt:       Specifies whether to set or clear the feature
+ *
+ * Return codes:
+ *      0:                      Success
+ *      linux error number:     Failure
+ */
+static int pch_udc_pcd_set_wedge(struct usb_ep *usbep)
+{
+        struct pch_udc_ep       *ep;
+        struct pch_udc_dev      *dev;
+        unsigned long iflags;
+        int ret;
+
+        if (!usbep)
+                return -EINVAL;
+        ep = container_of(usbep, struct pch_udc_ep, ep);
+        dev = ep->dev;
+        if (!ep->desc && !ep->num)
+                return -EINVAL;
+        if (!ep->dev->driver || (ep->dev->gadget.speed == USB_SPEED_UNKNOWN))
+                return -ESHUTDOWN;
+        spin_lock_irqsave(&udc_stall_spinlock, iflags);
+        if (!list_empty(&ep->queue)) {
+                ret = -EAGAIN;
+        } else {
+                if (ep->num == PCH_UDC_EP0)
+                        ep->dev->stall = 1;
+                pch_udc_ep_set_stall(ep);
+                pch_udc_enable_ep_interrupts(ep->dev,
+                                             PCH_UDC_EPINT(ep->in, ep->num));
+                ep->dev->prot_stall = 1;
+                ret = 0;
+        }
+        spin_unlock_irqrestore(&udc_stall_spinlock, iflags);
+        return ret;
+}
+
+/**
+ * pch_udc_pcd_fifo_flush() - This function Flush the FIFO of specified endpoint
+ * @usbep:      Reference to the USB endpoint structure
+ */
+static void pch_udc_pcd_fifo_flush(struct usb_ep *usbep)
+{
+        struct pch_udc_ep  *ep;
+
+        if (!usbep)
+                return;
+
+        ep = container_of(usbep, struct pch_udc_ep, ep);
+        if (ep->desc || !ep->num)
+                pch_udc_ep_fifo_flush(ep, ep->in);
+}
+
+static const struct usb_ep_ops pch_udc_ep_ops = {
+        .enable         = pch_udc_pcd_ep_enable,
+        .disable        = pch_udc_pcd_ep_disable,
+        .alloc_request  = pch_udc_alloc_request,
+        .free_request   = pch_udc_free_request,
+        .queue          = pch_udc_pcd_queue,
+        .dequeue        = pch_udc_pcd_dequeue,
+        .set_halt       = pch_udc_pcd_set_halt,
+        .set_wedge      = pch_udc_pcd_set_wedge,
+        .fifo_status    = NULL,
+        .fifo_flush     = pch_udc_pcd_fifo_flush,
+};
+
+/**
+ * pch_udc_init_setup_buff() - This function initializes the SETUP buffer
+ * @td_stp:     Reference to the SETP buffer structure
+ */
+static void pch_udc_init_setup_buff(struct pch_udc_stp_dma_desc *td_stp)
+{
+        static u32      pky_marker;
+
+        if (!td_stp)
+                return;
+        td_stp->reserved = ++pky_marker;
+        memset(&td_stp->request, 0xFF, sizeof td_stp->request);
+        td_stp->status = PCH_UDC_BS_HST_RDY;
+}
+
+/**
+ * pch_udc_start_next_txrequest() - This function starts
+ *                                      the next transmission requirement
+ * @ep: Reference to the endpoint structure
+ */
+static void pch_udc_start_next_txrequest(struct pch_udc_ep *ep)
+{
+        struct pch_udc_request *req;
+        struct pch_udc_data_dma_desc *td_data;
+
+        if (pch_udc_read_ep_control(ep) & UDC_EPCTL_P)
+                return;
+
+        if (list_empty(&ep->queue))
+                return;
+
+        /* next request */
+        req = list_entry(ep->queue.next, struct pch_udc_request, queue);
+        if (req->dma_going)
+                return;
+        if (!req->td_data)
+                return;
+        pch_udc_wait_ep_stall(ep);
+        req->dma_going = 1;
+        pch_udc_ep_set_ddptr(ep, 0);
+        td_data = req->td_data;
+        while (1) {
+                td_data->status = (td_data->status & ~PCH_UDC_BUFF_STS) |
+                                   PCH_UDC_BS_HST_RDY;
+                if ((td_data->status & PCH_UDC_DMA_LAST) == PCH_UDC_DMA_LAST)
+                        break;
+                td_data = phys_to_virt(td_data->next);
+        }
+        pch_udc_ep_set_ddptr(ep, req->td_data_phys);
+        pch_udc_set_dma(ep->dev, DMA_DIR_TX);
+        pch_udc_ep_set_pd(ep);
+        pch_udc_enable_ep_interrupts(ep->dev, PCH_UDC_EPINT(ep->in, ep->num));
+        pch_udc_ep_clear_nak(ep);
+}
+
+/**
+ * pch_udc_complete_transfer() - This function completes a transfer
+ * @ep:         Reference to the endpoint structure
+ */
+static void pch_udc_complete_transfer(struct pch_udc_ep *ep)
+{
+        struct pch_udc_request *req;
+        struct pch_udc_dev *dev = ep->dev;
+
+        if (list_empty(&ep->queue))
+                return;
+        req = list_entry(ep->queue.next, struct pch_udc_request, queue);
+        if ((req->td_data_last->status & PCH_UDC_BUFF_STS) !=
+            PCH_UDC_BS_DMA_DONE)
+                return;
+        if ((req->td_data_last->status & PCH_UDC_RXTX_STS) !=
+             PCH_UDC_RTS_SUCC) {
+                dev_err(&dev->pdev->dev, "Invalid RXTX status (0x%08x) "
+                        "epstatus=0x%08x\n",
+                       (req->td_data_last->status & PCH_UDC_RXTX_STS),
+                       (int)(ep->epsts));
+                return;
+        }
+
+        req->req.actual = req->req.length;
+        req->td_data_last->status = PCH_UDC_BS_HST_BSY | PCH_UDC_DMA_LAST;
+        req->td_data->status = PCH_UDC_BS_HST_BSY | PCH_UDC_DMA_LAST;
+        complete_req(ep, req, 0);
+        req->dma_going = 0;
+        if (!list_empty(&ep->queue)) {
+                pch_udc_wait_ep_stall(ep);
+                pch_udc_ep_clear_nak(ep);
+                pch_udc_enable_ep_interrupts(ep->dev,
+                                             PCH_UDC_EPINT(ep->in, ep->num));
+        } else {
+                pch_udc_disable_ep_interrupts(ep->dev,
+                                              PCH_UDC_EPINT(ep->in, ep->num));
+        }
+}
+
+/**
+ * pch_udc_complete_receiver() - This function completes a receiver
+ * @ep:         Reference to the endpoint structure
+ */
+static void pch_udc_complete_receiver(struct pch_udc_ep *ep)
+{
+        struct pch_udc_request *req;
+        struct pch_udc_dev *dev = ep->dev;
+        unsigned int count;
+        struct pch_udc_data_dma_desc *td;
+        dma_addr_t addr;
+
+        if (list_empty(&ep->queue))
+                return;
+        /* next request */
+        req = list_entry(ep->queue.next, struct pch_udc_request, queue);
+        pch_udc_clear_dma(ep->dev, DMA_DIR_RX);
+        pch_udc_ep_set_ddptr(ep, 0);
+        if ((req->td_data_last->status & PCH_UDC_BUFF_STS) ==
+            PCH_UDC_BS_DMA_DONE)
+                td = req->td_data_last;
+        else
+                td = req->td_data;
+
+        while (1) {
+                if ((td->status & PCH_UDC_RXTX_STS) != PCH_UDC_RTS_SUCC) {
+                        dev_err(&dev->pdev->dev, "Invalid RXTX status=0x%08x "
+                                "epstatus=0x%08x\n",
+                                (req->td_data->status & PCH_UDC_RXTX_STS),
+                                (int)(ep->epsts));
+                        return;
+                }
+                if ((td->status & PCH_UDC_BUFF_STS) == PCH_UDC_BS_DMA_DONE)
+                        if (td->status | PCH_UDC_DMA_LAST) {
+                                count = td->status & PCH_UDC_RXTX_BYTES;
+                                break;
+                        }
+                if (td == req->td_data_last) {
+                        dev_err(&dev->pdev->dev, "Not complete RX descriptor");
+                        return;
+                }
+                addr = (dma_addr_t)td->next;
+                td = phys_to_virt(addr);
+        }
+        /* on 64k packets the RXBYTES field is zero */
+        if (!count && (req->req.length == UDC_DMA_MAXPACKET))
+                count = UDC_DMA_MAXPACKET;
+        req->td_data->status |= PCH_UDC_DMA_LAST;
+        td->status |= PCH_UDC_BS_HST_BSY;
+
+        req->dma_going = 0;
+        req->req.actual = count;
+        complete_req(ep, req, 0);
+        /* If there is a new/failed requests try that now */
+        if (!list_empty(&ep->queue)) {
+                req = list_entry(ep->queue.next, struct pch_udc_request, queue);
+                pch_udc_start_rxrequest(ep, req);
+        }
+}
+
+/**
+ * pch_udc_svc_data_in() - This function process endpoint interrupts
+ *                              for IN endpoints
+ * @dev:        Reference to the device structure
+ * @ep_num:     Endpoint that generated the interrupt
+ */
+static void pch_udc_svc_data_in(struct pch_udc_dev *dev, int ep_num)
+{
+        u32     epsts;
+        struct pch_udc_ep       *ep;
+
+        ep = &dev->ep[UDC_EPIN_IDX(ep_num)];
+        epsts = ep->epsts;
+        ep->epsts = 0;
+
+        if (!(epsts & (UDC_EPSTS_IN | UDC_EPSTS_BNA  | UDC_EPSTS_HE |
+                       UDC_EPSTS_TDC | UDC_EPSTS_RCS | UDC_EPSTS_TXEMPTY |
+                       UDC_EPSTS_RSS | UDC_EPSTS_XFERDONE)))
+                return;
+        if ((epsts & UDC_EPSTS_BNA))
+                return;
+        if (epsts & UDC_EPSTS_HE)
+                return;
+        if (epsts & UDC_EPSTS_RSS) {
+                pch_udc_ep_set_stall(ep);
+                pch_udc_enable_ep_interrupts(ep->dev,
+                                             PCH_UDC_EPINT(ep->in, ep->num));
+        }
+        if (epsts & UDC_EPSTS_RCS) {
+                if (!dev->prot_stall) {
+                        pch_udc_ep_clear_stall(ep);
+                } else {
+                        pch_udc_ep_set_stall(ep);
+                        pch_udc_enable_ep_interrupts(ep->dev,
+                                                PCH_UDC_EPINT(ep->in, ep->num));
+                }
+        }
+        if (epsts & UDC_EPSTS_TDC)
+                pch_udc_complete_transfer(ep);
+        /* On IN interrupt, provide data if we have any */
+        if ((epsts & UDC_EPSTS_IN) && !(epsts & UDC_EPSTS_RSS) &&
+            !(epsts & UDC_EPSTS_TDC) && !(epsts & UDC_EPSTS_TXEMPTY))
+                pch_udc_start_next_txrequest(ep);
+}
+
+/**
+ * pch_udc_svc_data_out() - Handles interrupts from OUT endpoint
+ * @dev:        Reference to the device structure
+ * @ep_num:     Endpoint that generated the interrupt
+ */
+static void pch_udc_svc_data_out(struct pch_udc_dev *dev, int ep_num)
+{
+        u32                     epsts;
+        struct pch_udc_ep               *ep;
+        struct pch_udc_request          *req = NULL;
+
+        ep = &dev->ep[UDC_EPOUT_IDX(ep_num)];
+        epsts = ep->epsts;
+        ep->epsts = 0;
+
+        if ((epsts & UDC_EPSTS_BNA) && (!list_empty(&ep->queue))) {
+                /* next request */
+                req = list_entry(ep->queue.next, struct pch_udc_request,
+                                 queue);
+                if ((req->td_data_last->status & PCH_UDC_BUFF_STS) !=
+                     PCH_UDC_BS_DMA_DONE) {
+                        if (!req->dma_going)
+                                pch_udc_start_rxrequest(ep, req);
+                        return;
+                }
+        }
+        if (epsts & UDC_EPSTS_HE)
+                return;
+        if (epsts & UDC_EPSTS_RSS) {
+                pch_udc_ep_set_stall(ep);
+                pch_udc_enable_ep_interrupts(ep->dev,
+                                             PCH_UDC_EPINT(ep->in, ep->num));
+        }
+        if (epsts & UDC_EPSTS_RCS) {
+                if (!dev->prot_stall) {
+                        pch_udc_ep_clear_stall(ep);
+                } else {
+                        pch_udc_ep_set_stall(ep);
+                        pch_udc_enable_ep_interrupts(ep->dev,
+                                                PCH_UDC_EPINT(ep->in, ep->num));
+                }
+        }
+        if (((epsts & UDC_EPSTS_OUT_MASK) >> UDC_EPSTS_OUT_SHIFT) ==
+            UDC_EPSTS_OUT_DATA) {
+                if (ep->dev->prot_stall == 1) {
+                        pch_udc_ep_set_stall(ep);
+                        pch_udc_enable_ep_interrupts(ep->dev,
+                                                PCH_UDC_EPINT(ep->in, ep->num));
+                } else {
+                        pch_udc_complete_receiver(ep);
+                }
+        }
+        if (list_empty(&ep->queue))
+                pch_udc_set_dma(dev, DMA_DIR_RX);
+}
+
+/**
+ * pch_udc_svc_control_in() - Handle Control IN endpoint interrupts
+ * @dev:        Reference to the device structure
+ */
+static void pch_udc_svc_control_in(struct pch_udc_dev *dev)
+{
+        u32     epsts;
+        struct pch_udc_ep       *ep;
+        struct pch_udc_ep       *ep_out;
+
+        ep = &dev->ep[UDC_EP0IN_IDX];
+        ep_out = &dev->ep[UDC_EP0OUT_IDX];
+        epsts = ep->epsts;
+        ep->epsts = 0;
+
+        if (!(epsts & (UDC_EPSTS_IN | UDC_EPSTS_BNA | UDC_EPSTS_HE |
+                       UDC_EPSTS_TDC | UDC_EPSTS_RCS | UDC_EPSTS_TXEMPTY |
+                       UDC_EPSTS_XFERDONE)))
+                return;
+        if ((epsts & UDC_EPSTS_BNA))
+                return;
+        if (epsts & UDC_EPSTS_HE)
+                return;
+        if ((epsts & UDC_EPSTS_TDC) && (!dev->stall)) {
+                pch_udc_complete_transfer(ep);
+                pch_udc_clear_dma(dev, DMA_DIR_RX);
+                ep_out->td_data->status = (ep_out->td_data->status &
+                                        ~PCH_UDC_BUFF_STS) |
+                                        PCH_UDC_BS_HST_RDY;
+                pch_udc_ep_clear_nak(ep_out);
+                pch_udc_set_dma(dev, DMA_DIR_RX);
+                pch_udc_ep_set_rrdy(ep_out);
+        }
+        /* On IN interrupt, provide data if we have any */
+        if ((epsts & UDC_EPSTS_IN) && !(epsts & UDC_EPSTS_TDC) &&
+             !(epsts & UDC_EPSTS_TXEMPTY))
+                pch_udc_start_next_txrequest(ep);
+}
+
+/**
+ * pch_udc_svc_control_out() - Routine that handle Control
+ *                                      OUT endpoint interrupts
+ * @dev:        Reference to the device structure
+ */
+static void pch_udc_svc_control_out(struct pch_udc_dev *dev)
+{
+        u32     stat;
+        int setup_supported;
+        struct pch_udc_ep       *ep;
+
+        ep = &dev->ep[UDC_EP0OUT_IDX];
+        stat = ep->epsts;
+        ep->epsts = 0;
+
+        /* If setup data */
+        if (((stat & UDC_EPSTS_OUT_MASK) >> UDC_EPSTS_OUT_SHIFT) ==
+            UDC_EPSTS_OUT_SETUP) {
+                dev->stall = 0;
+                dev->ep[UDC_EP0IN_IDX].halted = 0;
+                dev->ep[UDC_EP0OUT_IDX].halted = 0;
+                dev->setup_data = ep->td_stp->request;
+                pch_udc_init_setup_buff(ep->td_stp);
+                pch_udc_clear_dma(dev, DMA_DIR_RX);
+                pch_udc_ep_fifo_flush(&(dev->ep[UDC_EP0IN_IDX]),
+                                      dev->ep[UDC_EP0IN_IDX].in);
+                if ((dev->setup_data.bRequestType & USB_DIR_IN))
+                        dev->gadget.ep0 = &dev->ep[UDC_EP0IN_IDX].ep;
+                else /* OUT */
+                        dev->gadget.ep0 = &ep->ep;
+                spin_unlock(&dev->lock);
+                /* If Mass storage Reset */
+                if ((dev->setup_data.bRequestType == 0x21) &&
+                    (dev->setup_data.bRequest == 0xFF))
+                        dev->prot_stall = 0;
+                /* call gadget with setup data received */
+                setup_supported = dev->driver->setup(&dev->gadget,
+                                                     &dev->setup_data);
+                spin_lock(&dev->lock);
+
+                if (dev->setup_data.bRequestType & USB_DIR_IN) {
+                        ep->td_data->status = (ep->td_data->status &
+                                                ~PCH_UDC_BUFF_STS) |
+                                                PCH_UDC_BS_HST_RDY;
+                        pch_udc_ep_set_ddptr(ep, ep->td_data_phys);
+                }
+                /* ep0 in returns data on IN phase */
+                if (setup_supported >= 0 && setup_supported <
+                                            UDC_EP0IN_MAX_PKT_SIZE) {
+                        pch_udc_ep_clear_nak(&(dev->ep[UDC_EP0IN_IDX]));
+                        /* Gadget would have queued a request when
+                         * we called the setup */
+                        if (!(dev->setup_data.bRequestType & USB_DIR_IN)) {
+                                pch_udc_set_dma(dev, DMA_DIR_RX);
+                                pch_udc_ep_clear_nak(ep);
+                        }
+                } else if (setup_supported < 0) {
+                        /* if unsupported request, then stall */
+                        pch_udc_ep_set_stall(&(dev->ep[UDC_EP0IN_IDX]));
+                        pch_udc_enable_ep_interrupts(ep->dev,
+                                                PCH_UDC_EPINT(ep->in, ep->num));
+                        dev->stall = 0;
+                        pch_udc_set_dma(dev, DMA_DIR_RX);
+                } else {
+                        dev->waiting_zlp_ack = 1;
+                }
+        } else if ((((stat & UDC_EPSTS_OUT_MASK) >> UDC_EPSTS_OUT_SHIFT) ==
+                     UDC_EPSTS_OUT_DATA) && !dev->stall) {
+                pch_udc_clear_dma(dev, DMA_DIR_RX);
+                pch_udc_ep_set_ddptr(ep, 0);
+                if (!list_empty(&ep->queue)) {
+                        ep->epsts = stat;
+                        pch_udc_svc_data_out(dev, PCH_UDC_EP0);
+                }
+                pch_udc_set_dma(dev, DMA_DIR_RX);
+        }
+        pch_udc_ep_set_rrdy(ep);
+}
+
+
+/**
+ * pch_udc_postsvc_epinters() - This function enables end point interrupts
+ *                              and clears NAK status
+ * @dev:        Reference to the device structure
+ * @ep_num:     End point number
+ */
+static void pch_udc_postsvc_epinters(struct pch_udc_dev *dev, int ep_num)
+{
+        struct pch_udc_ep       *ep;
+        struct pch_udc_request *req;
+
+        ep = &dev->ep[UDC_EPIN_IDX(ep_num)];
+        if (!list_empty(&ep->queue)) {
+                req = list_entry(ep->queue.next, struct pch_udc_request, queue);
+                pch_udc_enable_ep_interrupts(ep->dev,
+                                             PCH_UDC_EPINT(ep->in, ep->num));
+                pch_udc_ep_clear_nak(ep);
+        }
+}
+
+/**
+ * pch_udc_read_all_epstatus() - This function read all endpoint status
+ * @dev:        Reference to the device structure
+ * @ep_intr:    Status of endpoint interrupt
+ */
+static void pch_udc_read_all_epstatus(struct pch_udc_dev *dev, u32 ep_intr)
+{
+        int i;
+        struct pch_udc_ep       *ep;
+
+        for (i = 0; i < PCH_UDC_USED_EP_NUM; i++) {
+                /* IN */
+                if (ep_intr & (0x1 << i)) {
+                        ep = &dev->ep[UDC_EPIN_IDX(i)];
+                        ep->epsts = pch_udc_read_ep_status(ep);
+                        pch_udc_clear_ep_status(ep, ep->epsts);
+                }
+                /* OUT */
+                if (ep_intr & (0x10000 << i)) {
+                        ep = &dev->ep[UDC_EPOUT_IDX(i)];
+                        ep->epsts = pch_udc_read_ep_status(ep);
+                        pch_udc_clear_ep_status(ep, ep->epsts);
+                }
+        }
+}
+
+/**
+ * pch_udc_activate_control_ep() - This function enables the control endpoints
+ *                                      for traffic after a reset
+ * @dev:        Reference to the device structure
+ */
+static void pch_udc_activate_control_ep(struct pch_udc_dev *dev)
+{
+        struct pch_udc_ep       *ep;
+        u32 val;
+
+        /* Setup the IN endpoint */
+        ep = &dev->ep[UDC_EP0IN_IDX];
+        pch_udc_clear_ep_control(ep);
+        pch_udc_ep_fifo_flush(ep, ep->in);
+        pch_udc_ep_set_bufsz(ep, UDC_EP0IN_BUFF_SIZE, ep->in);
+        pch_udc_ep_set_maxpkt(ep, UDC_EP0IN_MAX_PKT_SIZE);
+        /* Initialize the IN EP Descriptor */
+        ep->td_data      = NULL;
+        ep->td_stp       = NULL;
+        ep->td_data_phys = 0;
+        ep->td_stp_phys  = 0;
+
+        /* Setup the OUT endpoint */
+        ep = &dev->ep[UDC_EP0OUT_IDX];
+        pch_udc_clear_ep_control(ep);
+        pch_udc_ep_fifo_flush(ep, ep->in);
+        pch_udc_ep_set_bufsz(ep, UDC_EP0OUT_BUFF_SIZE, ep->in);
+        pch_udc_ep_set_maxpkt(ep, UDC_EP0OUT_MAX_PKT_SIZE);
+        val = UDC_EP0OUT_MAX_PKT_SIZE << UDC_CSR_NE_MAX_PKT_SHIFT;
+        pch_udc_write_csr(ep->dev, val, UDC_EP0OUT_IDX);
+
+        /* Initialize the SETUP buffer */
+        pch_udc_init_setup_buff(ep->td_stp);
+        /* Write the pointer address of dma descriptor */
+        pch_udc_ep_set_subptr(ep, ep->td_stp_phys);
+        /* Write the pointer address of Setup descriptor */
+        pch_udc_ep_set_ddptr(ep, ep->td_data_phys);
+
+        /* Initialize the dma descriptor */
+        ep->td_data->status  = PCH_UDC_DMA_LAST;
+        ep->td_data->dataptr = dev->dma_addr;
+        ep->td_data->next    = ep->td_data_phys;
+
+        pch_udc_ep_clear_nak(ep);
+}
+
+
+/**
+ * pch_udc_svc_ur_interrupt() - This function handles a USB reset interrupt
+ * @dev:        Reference to driver structure
+ */
+static void pch_udc_svc_ur_interrupt(struct pch_udc_dev *dev)
+{
+        struct pch_udc_ep       *ep;
+        int i;
+
+        pch_udc_clear_dma(dev, DMA_DIR_TX);
+        pch_udc_clear_dma(dev, DMA_DIR_RX);
+        /* Mask all endpoint interrupts */
+        pch_udc_disable_ep_interrupts(dev, UDC_EPINT_MSK_DISABLE_ALL);
+        /* clear all endpoint interrupts */
+        pch_udc_write_ep_interrupts(dev, UDC_EPINT_MSK_DISABLE_ALL);
+
+        for (i = 0; i < PCH_UDC_EP_NUM; i++) {
+                ep = &dev->ep[i];
+                pch_udc_clear_ep_status(ep, UDC_EPSTS_ALL_CLR_MASK);
+                pch_udc_clear_ep_control(ep);
+                pch_udc_ep_set_ddptr(ep, 0);
+                pch_udc_write_csr(ep->dev, 0x00, i);
+        }
+        dev->stall = 0;
+        dev->prot_stall = 0;
+        dev->waiting_zlp_ack = 0;
+        dev->set_cfg_not_acked = 0;
+
+        /* disable ep to empty req queue. Skip the control EP's */
+        for (i = 0; i < (PCH_UDC_USED_EP_NUM*2); i++) {
+                ep = &dev->ep[i];
+                pch_udc_ep_set_nak(ep);
+                pch_udc_ep_fifo_flush(ep, ep->in);
+                /* Complete request queue */
+                empty_req_queue(ep);
+        }
+        if (dev->driver && dev->driver->disconnect)
+                dev->driver->disconnect(&dev->gadget);
+}
+
+/**
+ * pch_udc_svc_enum_interrupt() - This function handles a USB speed enumeration
+ *                              done interrupt
+ * @dev:        Reference to driver structure
+ */
+static void pch_udc_svc_enum_interrupt(struct pch_udc_dev *dev)
+{
+        u32 dev_stat, dev_speed;
+        u32 speed = USB_SPEED_FULL;
+
+        dev_stat = pch_udc_read_device_status(dev);
+        dev_speed = (dev_stat & UDC_DEVSTS_ENUM_SPEED_MASK) >>
+                                                 UDC_DEVSTS_ENUM_SPEED_SHIFT;
+        switch (dev_speed) {
+        case UDC_DEVSTS_ENUM_SPEED_HIGH:
+                speed = USB_SPEED_HIGH;
+                break;
+        case  UDC_DEVSTS_ENUM_SPEED_FULL:
+                speed = USB_SPEED_FULL;
+                break;
+        case  UDC_DEVSTS_ENUM_SPEED_LOW:
+                speed = USB_SPEED_LOW;
+                break;
+        default:
+                BUG();
+        }
+        dev->gadget.speed = speed;
+        pch_udc_activate_control_ep(dev);
+        pch_udc_enable_ep_interrupts(dev, UDC_EPINT_IN_EP0 | UDC_EPINT_OUT_EP0);
+        pch_udc_set_dma(dev, DMA_DIR_TX);
+        pch_udc_set_dma(dev, DMA_DIR_RX);
+        pch_udc_ep_set_rrdy(&(dev->ep[UDC_EP0OUT_IDX]));
+}
+
+/**
+ * pch_udc_svc_intf_interrupt() - This function handles a set interface
+ *                                interrupt
+ * @dev:        Reference to driver structure
+ */
+static void pch_udc_svc_intf_interrupt(struct pch_udc_dev *dev)
+{
+        u32 reg, dev_stat = 0;
+        int i, ret;
+
+        dev_stat = pch_udc_read_device_status(dev);
+        dev->cfg_data.cur_intf = (dev_stat & UDC_DEVSTS_INTF_MASK) >>
+                                                         UDC_DEVSTS_INTF_SHIFT;
+        dev->cfg_data.cur_alt = (dev_stat & UDC_DEVSTS_ALT_MASK) >>
+                                                         UDC_DEVSTS_ALT_SHIFT;
+        dev->set_cfg_not_acked = 1;
+        /* Construct the usb request for gadget driver and inform it */
+        memset(&dev->setup_data, 0 , sizeof dev->setup_data);
+        dev->setup_data.bRequest = USB_REQ_SET_INTERFACE;
+        dev->setup_data.bRequestType = USB_RECIP_INTERFACE;
+        dev->setup_data.wValue = cpu_to_le16(dev->cfg_data.cur_alt);
+        dev->setup_data.wIndex = cpu_to_le16(dev->cfg_data.cur_intf);
+        /* programm the Endpoint Cfg registers */
+        /* Only one end point cfg register */
+        reg = pch_udc_read_csr(dev, UDC_EP0OUT_IDX);
+        reg = (reg & ~UDC_CSR_NE_INTF_MASK) |
+              (dev->cfg_data.cur_intf << UDC_CSR_NE_INTF_SHIFT);
+        reg = (reg & ~UDC_CSR_NE_ALT_MASK) |
+              (dev->cfg_data.cur_alt << UDC_CSR_NE_ALT_SHIFT);
+        pch_udc_write_csr(dev, reg, UDC_EP0OUT_IDX);
+        for (i = 0; i < PCH_UDC_USED_EP_NUM * 2; i++) {
+                /* clear stall bits */
+                pch_udc_ep_clear_stall(&(dev->ep[i]));
+                dev->ep[i].halted = 0;
+        }
+        dev->stall = 0;
+        spin_unlock(&dev->lock);
+        ret = dev->driver->setup(&dev->gadget, &dev->setup_data);
+        spin_lock(&dev->lock);
+}
+
+/**
+ * pch_udc_svc_cfg_interrupt() - This function handles a set configuration
+ *                              interrupt
+ * @dev:        Reference to driver structure
+ */
+static void pch_udc_svc_cfg_interrupt(struct pch_udc_dev *dev)
+{
+        int i, ret;
+        u32 reg, dev_stat = 0;
+
+        dev_stat = pch_udc_read_device_status(dev);
+        dev->set_cfg_not_acked = 1;
+        dev->cfg_data.cur_cfg = (dev_stat & UDC_DEVSTS_CFG_MASK) >>
+                                UDC_DEVSTS_CFG_SHIFT;
+        /* make usb request for gadget driver */
+        memset(&dev->setup_data, 0 , sizeof dev->setup_data);
+        dev->setup_data.bRequest = USB_REQ_SET_CONFIGURATION;
+        dev->setup_data.wValue = cpu_to_le16(dev->cfg_data.cur_cfg);
+        /* program the NE registers */
+        /* Only one end point cfg register */
+        reg = pch_udc_read_csr(dev, UDC_EP0OUT_IDX);
+        reg = (reg & ~UDC_CSR_NE_CFG_MASK) |
+              (dev->cfg_data.cur_cfg << UDC_CSR_NE_CFG_SHIFT);
+        pch_udc_write_csr(dev, reg, UDC_EP0OUT_IDX);
+        for (i = 0; i < PCH_UDC_USED_EP_NUM * 2; i++) {
+                /* clear stall bits */
+                pch_udc_ep_clear_stall(&(dev->ep[i]));
+                dev->ep[i].halted = 0;
+        }
+        dev->stall = 0;
+
+        /* call gadget zero with setup data received */
+        spin_unlock(&dev->lock);
+        ret = dev->driver->setup(&dev->gadget, &dev->setup_data);
+        spin_lock(&dev->lock);
+}
+
+/**
+ * pch_udc_dev_isr() - This function services device interrupts
+ *                      by invoking appropriate routines.
+ * @dev:        Reference to the device structure
+ * @dev_intr:   The Device interrupt status.
+ */
+static void pch_udc_dev_isr(struct pch_udc_dev *dev, u32 dev_intr)
+{
+        /* USB Reset Interrupt */
+        if (dev_intr & UDC_DEVINT_UR)
+                pch_udc_svc_ur_interrupt(dev);
+        /* Enumeration Done Interrupt */
+        if (dev_intr & UDC_DEVINT_ENUM)
+                pch_udc_svc_enum_interrupt(dev);
+        /* Set Interface Interrupt */
+        if (dev_intr & UDC_DEVINT_SI)
+                pch_udc_svc_intf_interrupt(dev);
+        /* Set Config Interrupt */
+        if (dev_intr & UDC_DEVINT_SC)
+                pch_udc_svc_cfg_interrupt(dev);
+        /* USB Suspend interrupt */
+        if (dev_intr & UDC_DEVINT_US)
+                dev_dbg(&dev->pdev->dev, "USB_SUSPEND\n");
+        /* Clear the SOF interrupt, if enabled */
+        if (dev_intr & UDC_DEVINT_SOF)
+                dev_dbg(&dev->pdev->dev, "SOF\n");
+        /* ES interrupt, IDLE > 3ms on the USB */
+        if (dev_intr & UDC_DEVINT_ES)
+                dev_dbg(&dev->pdev->dev, "ES\n");
+        /* RWKP interrupt */
+        if (dev_intr & UDC_DEVINT_RWKP)
+                dev_dbg(&dev->pdev->dev, "RWKP\n");
+}
+
+/**
+ * pch_udc_isr() - This function handles interrupts from the PCH USB Device
+ * @irq:        Interrupt request number
+ * @dev:        Reference to the device structure
+ */
+static irqreturn_t pch_udc_isr(int irq, void *pdev)
+{
+        struct pch_udc_dev *dev = (struct pch_udc_dev *) pdev;
+        u32 dev_intr, ep_intr;
+        int i;
+
+        dev_intr = pch_udc_read_device_interrupts(dev);
+        ep_intr = pch_udc_read_ep_interrupts(dev);
+
+        if (dev_intr)
+                /* Clear device interrupts */
+                pch_udc_write_device_interrupts(dev, dev_intr);
+        if (ep_intr)
+                /* Clear ep interrupts */
+                pch_udc_write_ep_interrupts(dev, ep_intr);
+        if (!dev_intr && !ep_intr)
+                return IRQ_NONE;
+        spin_lock(&dev->lock);
+        if (dev_intr)
+                pch_udc_dev_isr(dev, dev_intr);
+        if (ep_intr) {
+                pch_udc_read_all_epstatus(dev, ep_intr);
+                /* Process Control In interrupts, if present */
+                if (ep_intr & UDC_EPINT_IN_EP0) {
+                        pch_udc_svc_control_in(dev);
+                        pch_udc_postsvc_epinters(dev, 0);
+                }
+                /* Process Control Out interrupts, if present */
+                if (ep_intr & UDC_EPINT_OUT_EP0)
+                        pch_udc_svc_control_out(dev);
+                /* Process data in end point interrupts */
+                for (i = 1; i < PCH_UDC_USED_EP_NUM; i++) {
+                        if (ep_intr & (1 <<  i)) {
+                                pch_udc_svc_data_in(dev, i);
+                                pch_udc_postsvc_epinters(dev, i);
+                        }
+                }
+                /* Process data out end point interrupts */
+                for (i = UDC_EPINT_OUT_SHIFT + 1; i < (UDC_EPINT_OUT_SHIFT +
+                                                 PCH_UDC_USED_EP_NUM); i++)
+                        if (ep_intr & (1 <<  i))
+                                pch_udc_svc_data_out(dev, i -
+                                                         UDC_EPINT_OUT_SHIFT);
+        }
+        spin_unlock(&dev->lock);
+        return IRQ_HANDLED;
+}
+
+/**
+ * pch_udc_setup_ep0() - This function enables control endpoint for traffic
+ * @dev:        Reference to the device structure
+ */
+static void pch_udc_setup_ep0(struct pch_udc_dev *dev)
+{
+        /* enable ep0 interrupts */
+        pch_udc_enable_ep_interrupts(dev, UDC_EPINT_IN_EP0 |
+                                                UDC_EPINT_OUT_EP0);
+        /* enable device interrupts */
+        pch_udc_enable_interrupts(dev, UDC_DEVINT_UR | UDC_DEVINT_US |
+                                       UDC_DEVINT_ES | UDC_DEVINT_ENUM |
+                                       UDC_DEVINT_SI | UDC_DEVINT_SC);
+}
+
+/**
+ * gadget_release() - Free the gadget driver private data
+ * @pdev        reference to struct pci_dev
+ */
+static void gadget_release(struct device *pdev)
+{
+        struct pch_udc_dev *dev = dev_get_drvdata(pdev);
+
+        kfree(dev);
+}
+
+/**
+ * pch_udc_pcd_reinit() - This API initializes the endpoint structures
+ * @dev:        Reference to the driver structure
+ */
+static void pch_udc_pcd_reinit(struct pch_udc_dev *dev)
+{
+        const char *const ep_string[] = {
+                ep0_string, "ep0out", "ep1in", "ep1out", "ep2in", "ep2out",
+                "ep3in", "ep3out", "ep4in", "ep4out", "ep5in", "ep5out",
+                "ep6in", "ep6out", "ep7in", "ep7out", "ep8in", "ep8out",
+                "ep9in", "ep9out", "ep10in", "ep10out", "ep11in", "ep11out",
+                "ep12in", "ep12out", "ep13in", "ep13out", "ep14in", "ep14out",
+                "ep15in", "ep15out",
+        };
+        int i;
+
+        dev->gadget.speed = USB_SPEED_UNKNOWN;
+        INIT_LIST_HEAD(&dev->gadget.ep_list);
+
+        /* Initialize the endpoints structures */
+        memset(dev->ep, 0, sizeof dev->ep);
+        for (i = 0; i < PCH_UDC_EP_NUM; i++) {
+                struct pch_udc_ep *ep = &dev->ep[i];
+                ep->dev = dev;
+                ep->halted = 1;
+                ep->num = i / 2;
+                ep->in = ~i & 1;
+                ep->ep.name = ep_string[i];
+                ep->ep.ops = &pch_udc_ep_ops;
+                if (ep->in)
+                        ep->offset_addr = ep->num * UDC_EP_REG_SHIFT;
+                else
+                        ep->offset_addr = (UDC_EPINT_OUT_SHIFT + ep->num) *
+                                          UDC_EP_REG_SHIFT;
+                /* need to set ep->ep.maxpacket and set Default Configuration?*/
+                ep->ep.maxpacket = UDC_BULK_MAX_PKT_SIZE;
+                list_add_tail(&ep->ep.ep_list, &dev->gadget.ep_list);
+                INIT_LIST_HEAD(&ep->queue);
+        }
+        dev->ep[UDC_EP0IN_IDX].ep.maxpacket = UDC_EP0IN_MAX_PKT_SIZE;
+        dev->ep[UDC_EP0OUT_IDX].ep.maxpacket = UDC_EP0OUT_MAX_PKT_SIZE;
+
+        /* remove ep0 in and out from the list.  They have own pointer */
+        list_del_init(&dev->ep[UDC_EP0IN_IDX].ep.ep_list);
+        list_del_init(&dev->ep[UDC_EP0OUT_IDX].ep.ep_list);
+
+        dev->gadget.ep0 = &dev->ep[UDC_EP0IN_IDX].ep;
+        INIT_LIST_HEAD(&dev->gadget.ep0->ep_list);
+}
+
+/**
+ * pch_udc_pcd_init() - This API initializes the driver structure
+ * @dev:        Reference to the driver structure
+ *
+ * Return codes:
+ *      0: Success
+ */
+static int pch_udc_pcd_init(struct pch_udc_dev *dev)
+{
+        pch_udc_init(dev);
+        pch_udc_pcd_reinit(dev);
+        return 0;
+}
+
+/**
+ * init_dma_pools() - create dma pools during initialization
+ * @pdev:       reference to struct pci_dev
+ */
+static int init_dma_pools(struct pch_udc_dev *dev)
+{
+        struct pch_udc_stp_dma_desc     *td_stp;
+        struct pch_udc_data_dma_desc    *td_data;
+
+        /* DMA setup */
+        dev->data_requests = pci_pool_create("data_requests", dev->pdev,
+                sizeof(struct pch_udc_data_dma_desc), 0, 0);
+        if (!dev->data_requests) {
+                dev_err(&dev->pdev->dev, "%s: can't get request data pool\n",
+                        __func__);
+                return -ENOMEM;
+        }
+
+        /* dma desc for setup data */
+        dev->stp_requests = pci_pool_create("setup requests", dev->pdev,
+                sizeof(struct pch_udc_stp_dma_desc), 0, 0);
+        if (!dev->stp_requests) {
+                dev_err(&dev->pdev->dev, "%s: can't get setup request pool\n",
+                        __func__);
+                return -ENOMEM;
+        }
+        /* setup */
+        td_stp = pci_pool_alloc(dev->stp_requests, GFP_KERNEL,
+                                &dev->ep[UDC_EP0OUT_IDX].td_stp_phys);
+        if (!td_stp) {
+                dev_err(&dev->pdev->dev,
+                        "%s: can't allocate setup dma descriptor\n", __func__);
+                return -ENOMEM;
+        }
+        dev->ep[UDC_EP0OUT_IDX].td_stp = td_stp;
+
+        /* data: 0 packets !? */
+        td_data = pci_pool_alloc(dev->data_requests, GFP_KERNEL,
+                                &dev->ep[UDC_EP0OUT_IDX].td_data_phys);
+        if (!td_data) {
+                dev_err(&dev->pdev->dev,
+                        "%s: can't allocate data dma descriptor\n", __func__);
+                return -ENOMEM;
+        }
+        dev->ep[UDC_EP0OUT_IDX].td_data = td_data;
+        dev->ep[UDC_EP0IN_IDX].td_stp = NULL;
+        dev->ep[UDC_EP0IN_IDX].td_stp_phys = 0;
+        dev->ep[UDC_EP0IN_IDX].td_data = NULL;
+        dev->ep[UDC_EP0IN_IDX].td_data_phys = 0;
+
+        dev->ep0out_buf = kzalloc(UDC_EP0OUT_BUFF_SIZE * 4, GFP_KERNEL);
+        if (!dev->ep0out_buf)
+                return -ENOMEM;
+        dev->dma_addr = dma_map_single(&dev->pdev->dev, dev->ep0out_buf,
+                                       UDC_EP0OUT_BUFF_SIZE * 4,
+                                       DMA_FROM_DEVICE);
+        return 0;
+}
+
+int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
+        int (*bind)(struct usb_gadget *))
+{
+        struct pch_udc_dev      *dev = pch_udc;
+        int                     retval;
+
+        if (!driver || (driver->speed == USB_SPEED_UNKNOWN) || !bind ||
+            !driver->setup || !driver->unbind || !driver->disconnect) {
+                dev_err(&dev->pdev->dev,
+                        "%s: invalid driver parameter\n", __func__);
+                return -EINVAL;
+        }
+
+        if (!dev)
+                return -ENODEV;
+
+        if (dev->driver) {
+                dev_err(&dev->pdev->dev, "%s: already bound\n", __func__);
+                return -EBUSY;
+        }
+        driver->driver.bus = NULL;
+        dev->driver = driver;
+        dev->gadget.dev.driver = &driver->driver;
+
+        /* Invoke the bind routine of the gadget driver */
+        retval = bind(&dev->gadget);
+
+        if (retval) {
+                dev_err(&dev->pdev->dev, "%s: binding to %s returning %d\n",
+                       __func__, driver->driver.name, retval);
+                dev->driver = NULL;
+                dev->gadget.dev.driver = NULL;
+                return retval;
+        }
+        /* get ready for ep0 traffic */
+        pch_udc_setup_ep0(dev);
+
+        /* clear SD */
+        pch_udc_clear_disconnect(dev);
+
+        dev->connected = 1;
+        return 0;
+}
+EXPORT_SYMBOL(usb_gadget_probe_driver);
+
+int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
+{
+        struct pch_udc_dev      *dev = pch_udc;
+
+        if (!dev)
+                return -ENODEV;
+
+        if (!driver || (driver != dev->driver)) {
+                dev_err(&dev->pdev->dev,
+                        "%s: invalid driver parameter\n", __func__);
+                return -EINVAL;
+        }
+
+        pch_udc_disable_interrupts(dev, UDC_DEVINT_MSK);
+
+        /* Assures that there are no pending requests with this driver */
+        driver->disconnect(&dev->gadget);
+        driver->unbind(&dev->gadget);
+        dev->gadget.dev.driver = NULL;
+        dev->driver = NULL;
+        dev->connected = 0;
+
+        /* set SD */
+        pch_udc_set_disconnect(dev);
+        return 0;
+}
+EXPORT_SYMBOL(usb_gadget_unregister_driver);
+
+static void pch_udc_shutdown(struct pci_dev *pdev)
+{
+        struct pch_udc_dev *dev = pci_get_drvdata(pdev);
+
+        pch_udc_disable_interrupts(dev, UDC_DEVINT_MSK);
+        pch_udc_disable_ep_interrupts(dev, UDC_EPINT_MSK_DISABLE_ALL);
+
+        /* disable the pullup so the host will think we're gone */
+        pch_udc_set_disconnect(dev);
+}
+
+static void pch_udc_remove(struct pci_dev *pdev)
+{
+        struct pch_udc_dev      *dev = pci_get_drvdata(pdev);
+
+        /* gadget driver must not be registered */
+        if (dev->driver)
+                dev_err(&pdev->dev,
+                        "%s: gadget driver still bound!!!\n", __func__);
+        /* dma pool cleanup */
+        if (dev->data_requests)
+                pci_pool_destroy(dev->data_requests);
+
+        if (dev->stp_requests) {
+                /* cleanup DMA desc's for ep0in */
+                if (dev->ep[UDC_EP0OUT_IDX].td_stp) {
+                        pci_pool_free(dev->stp_requests,
+                                dev->ep[UDC_EP0OUT_IDX].td_stp,
+                                dev->ep[UDC_EP0OUT_IDX].td_stp_phys);
+                }
+                if (dev->ep[UDC_EP0OUT_IDX].td_data) {
+                        pci_pool_free(dev->stp_requests,
+                                dev->ep[UDC_EP0OUT_IDX].td_data,
+                                dev->ep[UDC_EP0OUT_IDX].td_data_phys);
+                }
+                pci_pool_destroy(dev->stp_requests);
+        }
+
+        if (dev->dma_addr)
+                dma_unmap_single(&dev->pdev->dev, dev->dma_addr,
+                                 UDC_EP0OUT_BUFF_SIZE * 4, DMA_FROM_DEVICE);
+        kfree(dev->ep0out_buf);
+
+        pch_udc_exit(dev);
+
+        if (dev->irq_registered)
+                free_irq(pdev->irq, dev);
+        if (dev->base_addr)
+                iounmap(dev->base_addr);
+        if (dev->mem_region)
+                release_mem_region(dev->phys_addr,
+                                   pci_resource_len(pdev, PCH_UDC_PCI_BAR));
+        if (dev->active)
+                pci_disable_device(pdev);
+        if (dev->registered)
+                device_unregister(&dev->gadget.dev);
+        kfree(dev);
+        pci_set_drvdata(pdev, NULL);
+}
+
+#ifdef CONFIG_PM
+static int pch_udc_suspend(struct pci_dev *pdev, pm_message_t state)
+{
+        struct pch_udc_dev *dev = pci_get_drvdata(pdev);
+
+        pch_udc_disable_interrupts(dev, UDC_DEVINT_MSK);
+        pch_udc_disable_ep_interrupts(dev, UDC_EPINT_MSK_DISABLE_ALL);
+
+        pci_disable_device(pdev);
+        pci_enable_wake(pdev, PCI_D3hot, 0);
+
+        if (pci_save_state(pdev)) {
+                dev_err(&pdev->dev,
+                        "%s: could not save PCI config state\n", __func__);
+                return -ENOMEM;
+        }
+        pci_set_power_state(pdev, pci_choose_state(pdev, state));
+        return 0;
+}
+
+static int pch_udc_resume(struct pci_dev *pdev)
+{
+        int ret;
+
+        pci_set_power_state(pdev, PCI_D0);
+        pci_restore_state(pdev);
+        ret = pci_enable_device(pdev);
+        if (ret) {
+                dev_err(&pdev->dev, "%s: pci_enable_device failed\n", __func__);
+                return ret;
+        }
+        pci_enable_wake(pdev, PCI_D3hot, 0);
+        return 0;
+}
+#else
+#define pch_udc_suspend NULL
+#define pch_udc_resume  NULL
+#endif /* CONFIG_PM */
+
+static int pch_udc_probe(struct pci_dev *pdev,
+                          const struct pci_device_id *id)
+{
+        unsigned long           resource;
+        unsigned long           len;
+        int                     retval;
+        struct pch_udc_dev      *dev;
+
+        /* one udc only */
+        if (pch_udc) {
+                pr_err("%s: already probed\n", __func__);
+                return -EBUSY;
+        }
+        /* init */
+        dev = kzalloc(sizeof *dev, GFP_KERNEL);
+        if (!dev) {
+                pr_err("%s: no memory for device structure\n", __func__);
+                return -ENOMEM;
+        }
+        /* pci setup */
+        if (pci_enable_device(pdev) < 0) {
+                kfree(dev);
+                pr_err("%s: pci_enable_device failed\n", __func__);
+                return -ENODEV;
+        }
+        dev->active = 1;
+        pci_set_drvdata(pdev, dev);
+
+        /* PCI resource allocation */
+        resource = pci_resource_start(pdev, 1);
+        len = pci_resource_len(pdev, 1);
+
+        if (!request_mem_region(resource, len, KBUILD_MODNAME)) {
+                dev_err(&pdev->dev, "%s: pci device used already\n", __func__);
+                retval = -EBUSY;
+                goto finished;
+        }
+        dev->phys_addr = resource;
+        dev->mem_region = 1;
+
+        dev->base_addr = ioremap_nocache(resource, len);
+        if (!dev->base_addr) {
+                pr_err("%s: device memory cannot be mapped\n", __func__);
+                retval = -ENOMEM;
+                goto finished;
+        }
+        if (!pdev->irq) {
+                dev_err(&pdev->dev, "%s: irq not set\n", __func__);
+                retval = -ENODEV;
+                goto finished;
+        }
+        pch_udc = dev;
+        /* initialize the hardware */
+        if (pch_udc_pcd_init(dev))
+                goto finished;
+        if (request_irq(pdev->irq, pch_udc_isr, IRQF_SHARED, KBUILD_MODNAME,
+                        dev)) {
+                dev_err(&pdev->dev, "%s: request_irq(%d) fail\n", __func__,
+                        pdev->irq);
+                retval = -ENODEV;
+                goto finished;
+        }
+        dev->irq = pdev->irq;
+        dev->irq_registered = 1;
+
+        pci_set_master(pdev);
+        pci_try_set_mwi(pdev);
+
+        /* device struct setup */
+        spin_lock_init(&dev->lock);
+        dev->pdev = pdev;
+        dev->gadget.ops = &pch_udc_ops;
+
+        retval = init_dma_pools(dev);
+        if (retval)
+                goto finished;
+
+        dev_set_name(&dev->gadget.dev, "gadget");
+        dev->gadget.dev.parent = &pdev->dev;
+        dev->gadget.dev.dma_mask = pdev->dev.dma_mask;
+        dev->gadget.dev.release = gadget_release;
+        dev->gadget.name = KBUILD_MODNAME;
+        dev->gadget.is_dualspeed = 1;
+
+        retval = device_register(&dev->gadget.dev);
+        if (retval)
+                goto finished;
+        dev->registered = 1;
+
+        /* Put the device in disconnected state till a driver is bound */
+        pch_udc_set_disconnect(dev);
+        return 0;
+
+finished:
+        pch_udc_remove(pdev);
+        return retval;
+}
+
+static DEFINE_PCI_DEVICE_TABLE(pch_udc_pcidev_id) = {
+        {
+                PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_EG20T_UDC),
+                .class = (PCI_CLASS_SERIAL_USB << 8) | 0xfe,
+                .class_mask = 0xffffffff,
+        },
+        {
+                PCI_DEVICE(PCI_VENDOR_ID_ROHM, PCI_DEVICE_ID_ML7213_IOH_UDC),
+                .class = (PCI_CLASS_SERIAL_USB << 8) | 0xfe,
+                .class_mask = 0xffffffff,
+        },
+        { 0 },
+};
+
+MODULE_DEVICE_TABLE(pci, pch_udc_pcidev_id);
+
+
+static struct pci_driver pch_udc_driver = {
+        .name = KBUILD_MODNAME,
+        .id_table =     pch_udc_pcidev_id,
+        .probe =        pch_udc_probe,
+        .remove =       pch_udc_remove,
+        .suspend =      pch_udc_suspend,
+        .resume =       pch_udc_resume,
+        .shutdown =     pch_udc_shutdown,
+};
+
+static int __init pch_udc_pci_init(void)
+{
+        return pci_register_driver(&pch_udc_driver);
+}
+module_init(pch_udc_pci_init);
+
+static void __exit pch_udc_pci_exit(void)
+{
+        pci_unregister_driver(&pch_udc_driver);
+}
+module_exit(pch_udc_pci_exit);
+
+MODULE_DESCRIPTION("Intel EG20T USB Device Controller");
+MODULE_AUTHOR("OKI SEMICONDUCTOR, <toshiharu-linux@dsn.okisemi.com>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/usb/gadget/printer.c b/drivers/usb/gadget/printer.c
index cf241c371a71..271ef94668e7 100644
--- a/drivers/usb/gadget/printer.c
+++ b/drivers/usb/gadget/printer.c
@@ -126,36 +126,36 @@ static struct printer_dev usb_printer_gadget;
 #define PRINTER_VENDOR_NUM      0x0525          /* NetChip */
 #define PRINTER_PRODUCT_NUM     0xa4a8          /* Linux-USB Printer Gadget */
 
-/* Some systems will want different product identifers published in the
+/* Some systems will want different product identifiers published in the
  * device descriptor, either numbers or strings or both.  These string
  * parameters are in UTF-8 (superset of ASCII's 7 bit characters).
  */
 
-static ushort __initdata idVendor;
+static ushort idVendor;
 module_param(idVendor, ushort, S_IRUGO);
 MODULE_PARM_DESC(idVendor, "USB Vendor ID");
 
-static ushort __initdata idProduct;
+static ushort idProduct;
 module_param(idProduct, ushort, S_IRUGO);
 MODULE_PARM_DESC(idProduct, "USB Product ID");
 
-static ushort __initdata bcdDevice;
+static ushort bcdDevice;
 module_param(bcdDevice, ushort, S_IRUGO);
 MODULE_PARM_DESC(bcdDevice, "USB Device version (BCD)");
 
-static char *__initdata iManufacturer;
+static char *iManufacturer;
 module_param(iManufacturer, charp, S_IRUGO);
 MODULE_PARM_DESC(iManufacturer, "USB Manufacturer string");
 
-static char *__initdata iProduct;
+static char *iProduct;
 module_param(iProduct, charp, S_IRUGO);
 MODULE_PARM_DESC(iProduct, "USB Product string");
 
-static char *__initdata iSerialNum;
+static char *iSerialNum;
 module_param(iSerialNum, charp, S_IRUGO);
 MODULE_PARM_DESC(iSerialNum, "1");
 
-static char *__initdata iPNPstring;
+static char *iPNPstring;
 module_param(iPNPstring, charp, S_IRUGO);
 MODULE_PARM_DESC(iPNPstring, "MFG:linux;MDL:g_printer;CLS:PRINTER;SN:1;");
 
@@ -884,7 +884,8 @@ static const struct file_operations printer_io_operations = {
         .fsync =        printer_fsync,
         .poll =         printer_poll,
         .unlocked_ioctl = printer_ioctl,
-        .release =      printer_close
+        .release =      printer_close,
+        .llseek =       noop_llseek,
 };
 
 /*-------------------------------------------------------------------------*/
@@ -1188,6 +1189,8 @@ printer_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
                         else if (gadget->a_alt_hnp_support)
                                 DBG(dev, "HNP needs a different root port\n");
                         value = printer_set_config(dev, wValue);
+                        if (!value)
+                                value = set_interface(dev, PRINTER_INTERFACE);
                         break;
                 case USB_REQ_GET_CONFIGURATION:
                         if (ctrl->bRequestType != USB_DIR_IN)
@@ -1347,7 +1350,7 @@ printer_unbind(struct usb_gadget *gadget)
         set_gadget_data(gadget, NULL);
 }
 
-static int __ref
+static int __init
 printer_bind(struct usb_gadget *gadget)
 {
         struct printer_dev      *dev;
@@ -1543,7 +1546,6 @@ static struct usb_gadget_driver printer_driver = {
         .speed          = DEVSPEED,
 
         .function       = (char *) driver_desc,
-        .bind           = printer_bind,
         .unbind         = printer_unbind,
 
         .setup          = printer_setup,
@@ -1579,11 +1581,11 @@ init(void)
                 return status;
         }
 
-        status = usb_gadget_register_driver(&printer_driver);
+        status = usb_gadget_probe_driver(&printer_driver, printer_bind);
         if (status) {
                 class_destroy(usb_gadget_class);
                 unregister_chrdev_region(g_printer_devno, 1);
-                DBG(dev, "usb_gadget_register_driver %x\n", status);
+                DBG(dev, "usb_gadget_probe_driver %x\n", status);
         }
 
         return status;
@@ -1596,13 +1598,12 @@ cleanup(void)
         int status;
 
         mutex_lock(&usb_printer_gadget.lock_printer_io);
-        class_destroy(usb_gadget_class);
-        unregister_chrdev_region(g_printer_devno, 2);
-
         status = usb_gadget_unregister_driver(&printer_driver);
         if (status)
                 ERROR(dev, "usb_gadget_unregister_driver %x\n", status);
 
+        unregister_chrdev_region(g_printer_devno, 2);
+        class_destroy(usb_gadget_class);
         mutex_unlock(&usb_printer_gadget.lock_printer_io);
 }
 module_exit(cleanup);
diff --git a/drivers/usb/gadget/pxa25x_udc.c b/drivers/usb/gadget/pxa25x_udc.c
index be5fb34d9602..774545494cf2 100644
--- a/drivers/usb/gadget/pxa25x_udc.c
+++ b/drivers/usb/gadget/pxa25x_udc.c
@@ -46,6 +46,7 @@
 #include <linux/seq_file.h>
 #include <linux/debugfs.h>
 #include <linux/io.h>
+#include <linux/prefetch.h>
 
 #include <asm/byteorder.h>
 #include <asm/dma.h>
@@ -139,24 +140,6 @@ static const char ep0name [] = "ep0";
 static void pxa25x_ep_fifo_flush (struct usb_ep *ep);
 static void nuke (struct pxa25x_ep *, int status);
 
-/* one GPIO should be used to detect VBUS from the host */
-static int is_vbus_present(void)
-{
-        struct pxa2xx_udc_mach_info             *mach = the_controller->mach;
-
-        if (gpio_is_valid(mach->gpio_vbus)) {
-                int value = gpio_get_value(mach->gpio_vbus);
-
-                if (mach->gpio_vbus_inverted)
-                        return !value;
-                else
-                        return !!value;
-        }
-        if (mach->udc_is_connected)
-                return mach->udc_is_connected();
-        return 1;
-}
-
 /* one GPIO should control a D+ pullup, so host sees this device (or not) */
 static void pullup_off(void)
 {
@@ -1055,7 +1038,7 @@ udc_seq_show(struct seq_file *m, void *_d)
                 "%s version: %s\nGadget driver: %s\nHost %s\n\n",
                 driver_name, DRIVER_VERSION SIZE_STR "(pio)",
                 dev->driver ? dev->driver->driver.name : "(none)",
-                is_vbus_present() ? "full speed" : "disconnected");
+                dev->gadget.speed == USB_SPEED_FULL ? "full speed" : "disconnected");
 
         /* registers for device and ep0 */
         seq_printf(m,
@@ -1094,7 +1077,7 @@ udc_seq_show(struct seq_file *m, void *_d)
                         (tmp & UDCCFR_ACM) ? " acm" : "");
         }
 
-        if (!is_vbus_present() || !dev->driver)
+        if (dev->gadget.speed != USB_SPEED_FULL || !dev->driver)
                 goto done;
 
         seq_printf(m, "ep0 IN %lu/%lu, OUT %lu/%lu\nirqs %lu\n\n",
@@ -1280,14 +1263,15 @@ static void udc_enable (struct pxa25x_udc *dev)
  * disconnect is reported.  then a host may connect again, or
  * the driver might get unbound.
  */
-int usb_gadget_register_driver(struct usb_gadget_driver *driver)
+int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
+                int (*bind)(struct usb_gadget *))
 {
         struct pxa25x_udc       *dev = the_controller;
         int                     retval;
 
         if (!driver
                         || driver->speed < USB_SPEED_FULL
-                        || !driver->bind
+                        || !bind
                         || !driver->disconnect
                         || !driver->setup)
                 return -EINVAL;
@@ -1308,7 +1292,7 @@ fail:
                 dev->gadget.dev.driver = NULL;
                 return retval;
         }
-        retval = driver->bind(&dev->gadget);
+        retval = bind(&dev->gadget);
         if (retval) {
                 DMSG("bind to driver %s --> error %d\n",
                                 driver->driver.name, retval);
@@ -1338,7 +1322,7 @@ fail:
 bind_fail:
         return retval;
 }
-EXPORT_SYMBOL(usb_gadget_register_driver);
+EXPORT_SYMBOL(usb_gadget_probe_driver);
 
 static void
 stop_activity(struct pxa25x_udc *dev, struct usb_gadget_driver *driver)
@@ -1434,14 +1418,6 @@ lubbock_vbus_irq(int irq, void *_dev)
 
 #endif
 
-static irqreturn_t udc_vbus_irq(int irq, void *_dev)
-{
-        struct pxa25x_udc       *dev = _dev;
-
-        pxa25x_udc_vbus_session(&dev->gadget, is_vbus_present());
-        return IRQ_HANDLED;
-}
-
 
 /*-------------------------------------------------------------------------*/
 
@@ -1765,12 +1741,9 @@ pxa25x_udc_irq(int irq, void *_dev)
                 if (unlikely(udccr & UDCCR_SUSIR)) {
                         udc_ack_int_UDCCR(UDCCR_SUSIR);
                         handled = 1;
-                        DBG(DBG_VERBOSE, "USB suspend%s\n", is_vbus_present()
-                                ? "" : "+disconnect");
+                        DBG(DBG_VERBOSE, "USB suspend\n");
 
-                        if (!is_vbus_present())
-                                stop_activity(dev, dev->driver);
-                        else if (dev->gadget.speed != USB_SPEED_UNKNOWN
+                        if (dev->gadget.speed != USB_SPEED_UNKNOWN
                                         && dev->driver
                                         && dev->driver->suspend)
                                 dev->driver->suspend(&dev->gadget);
@@ -1785,8 +1758,7 @@ pxa25x_udc_irq(int irq, void *_dev)
 
                         if (dev->gadget.speed != USB_SPEED_UNKNOWN
                                         && dev->driver
-                                        && dev->driver->resume
-                                        && is_vbus_present())
+                                        && dev->driver->resume)
                                 dev->driver->resume(&dev->gadget);
                 }
 
@@ -2136,7 +2108,7 @@ static struct pxa25x_udc memory = {
 static int __init pxa25x_udc_probe(struct platform_device *pdev)
 {
         struct pxa25x_udc *dev = &memory;
-        int retval, vbus_irq, irq;
+        int retval, irq;
         u32 chiprev;
 
         /* insist on Intel/ARM/XScale */
@@ -2198,19 +2170,6 @@ static int __init pxa25x_udc_probe(struct platform_device *pdev)
 
         dev->transceiver = otg_get_transceiver();
 
-        if (gpio_is_valid(dev->mach->gpio_vbus)) {
-                if ((retval = gpio_request(dev->mach->gpio_vbus,
-                                "pxa25x_udc GPIO VBUS"))) {
-                        dev_dbg(&pdev->dev,
-                                "can't get vbus gpio %d, err: %d\n",
-                                dev->mach->gpio_vbus, retval);
-                        goto err_gpio_vbus;
-                }
-                gpio_direction_input(dev->mach->gpio_vbus);
-                vbus_irq = gpio_to_irq(dev->mach->gpio_vbus);
-        } else
-                vbus_irq = 0;
-
         if (gpio_is_valid(dev->mach->gpio_pullup)) {
                 if ((retval = gpio_request(dev->mach->gpio_pullup,
                                 "pca25x_udc GPIO PULLUP"))) {
@@ -2236,7 +2195,7 @@ static int __init pxa25x_udc_probe(struct platform_device *pdev)
         udc_disable(dev);
         udc_reinit(dev);
 
-        dev->vbus = !!is_vbus_present();
+        dev->vbus = 0;
 
         /* irq setup after old hardware state is cleaned up */
         retval = request_irq(irq, pxa25x_udc_irq,
@@ -2257,7 +2216,6 @@ static int __init pxa25x_udc_probe(struct platform_device *pdev)
                 if (retval != 0) {
                         pr_err("%s: can't get irq %i, err %d\n",
                                 driver_name, LUBBOCK_USB_DISC_IRQ, retval);
-lubbock_fail0:
                         goto err_irq_lub;
                 }
                 retval = request_irq(LUBBOCK_USB_IRQ,
@@ -2267,39 +2225,24 @@ lubbock_fail0:
                 if (retval != 0) {
                         pr_err("%s: can't get irq %i, err %d\n",
                                 driver_name, LUBBOCK_USB_IRQ, retval);
-                        free_irq(LUBBOCK_USB_DISC_IRQ, dev);
                         goto lubbock_fail0;
                 }
         } else
 #endif
-        if (vbus_irq) {
-                retval = request_irq(vbus_irq, udc_vbus_irq,
-                                IRQF_DISABLED | IRQF_SAMPLE_RANDOM |
-                                IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
-                                driver_name, dev);
-                if (retval != 0) {
-                        pr_err("%s: can't get irq %i, err %d\n",
-                                driver_name, vbus_irq, retval);
-                        goto err_vbus_irq;
-                }
-        }
         create_debug_files(dev);
 
         return 0;
 
- err_vbus_irq:
 #ifdef  CONFIG_ARCH_LUBBOCK
+lubbock_fail0:
         free_irq(LUBBOCK_USB_DISC_IRQ, dev);
  err_irq_lub:
-#endif
         free_irq(irq, dev);
+#endif
  err_irq1:
         if (gpio_is_valid(dev->mach->gpio_pullup))
                 gpio_free(dev->mach->gpio_pullup);
  err_gpio_pullup:
-        if (gpio_is_valid(dev->mach->gpio_vbus))
-                gpio_free(dev->mach->gpio_vbus);
- err_gpio_vbus:
         if (dev->transceiver) {
                 otg_put_transceiver(dev->transceiver);
                 dev->transceiver = NULL;
@@ -2336,10 +2279,6 @@ static int __exit pxa25x_udc_remove(struct platform_device *pdev)
                 free_irq(LUBBOCK_USB_IRQ, dev);
         }
 #endif
-        if (gpio_is_valid(dev->mach->gpio_vbus)) {
-                free_irq(gpio_to_irq(dev->mach->gpio_vbus), dev);
-                gpio_free(dev->mach->gpio_vbus);
-        }
         if (gpio_is_valid(dev->mach->gpio_pullup))
                 gpio_free(dev->mach->gpio_pullup);
 
diff --git a/drivers/usb/gadget/pxa27x_udc.c b/drivers/usb/gadget/pxa27x_udc.c
index 980762453a9c..57607696735c 100644
--- a/drivers/usb/gadget/pxa27x_udc.c
+++ b/drivers/usb/gadget/pxa27x_udc.c
@@ -32,6 +32,7 @@
 #include <linux/irq.h>
 #include <linux/gpio.h>
 #include <linux/slab.h>
+#include <linux/prefetch.h>
 
 #include <asm/byteorder.h>
 #include <mach/hardware.h>
@@ -602,7 +603,7 @@ static void inc_ep_stats_reqs(struct pxa_ep *ep, int is_in)
 /**
  * inc_ep_stats_bytes - Update ep stats counts
  * @ep: physical endpoint
- * @count: bytes transfered on endpoint
+ * @count: bytes transferred on endpoint
  * @is_in: ep direction (USB_DIR_IN or 0)
  */
 static void inc_ep_stats_bytes(struct pxa_ep *ep, int count, int is_in)
@@ -877,7 +878,7 @@ static void nuke(struct pxa_ep *ep, int status)
  * If there is less space in request than bytes received in OUT endpoint,
  * bytes are left in the OUT endpoint.
  *
- * Returns how many bytes were actually transfered
+ * Returns how many bytes were actually transferred
  */
 static int read_packet(struct pxa_ep *ep, struct pxa27x_request *req)
 {
@@ -914,7 +915,7 @@ static int read_packet(struct pxa_ep *ep, struct pxa27x_request *req)
  * endpoint. If there are no bytes to transfer, doesn't write anything
  * to physical endpoint.
  *
- * Returns how many bytes were actually transfered.
+ * Returns how many bytes were actually transferred.
  */
 static int write_packet(struct pxa_ep *ep, struct pxa27x_request *req,
                         unsigned int max)
@@ -991,7 +992,7 @@ static int read_fifo(struct pxa_ep *ep, struct pxa27x_request *req)
  * caller guarantees at least one packet buffer is ready (or a zlp).
  * Doesn't complete the request, that's the caller's job
  *
- * Returns 1 if request fully transfered, 0 if partial transfer
+ * Returns 1 if request fully transferred, 0 if partial transfer
  */
 static int write_fifo(struct pxa_ep *ep, struct pxa27x_request *req)
 {
@@ -1094,7 +1095,7 @@ static int read_ep0_fifo(struct pxa_ep *ep, struct pxa27x_request *req)
  * Sends a request (or a part of the request) to the control endpoint (ep0 in).
  * If the request doesn't fit, the remaining part will be sent from irq.
  * The request is considered fully written only if either :
- *   - last write transfered all remaining bytes, but fifo was not fully filled
+ *   - last write transferred all remaining bytes, but fifo was not fully filled
  *   - last write was a 0 length write
  *
  * Returns 1 if request fully written, 0 if request only partially sent
@@ -1394,8 +1395,6 @@ static void pxa_ep_fifo_flush(struct usb_ep *_ep)
         }
 
         spin_unlock_irqrestore(&ep->lock, flags);
-
-        return;
 }
 
 /**
@@ -1550,7 +1549,7 @@ static int pxa_udc_get_frame(struct usb_gadget *_gadget)
  * pxa_udc_wakeup - Force udc device out of suspend
  * @_gadget: usb gadget
  *
- * Returns 0 if successfull, error code otherwise
+ * Returns 0 if successful, error code otherwise
  */
 static int pxa_udc_wakeup(struct usb_gadget *_gadget)
 {
@@ -1792,8 +1791,9 @@ static void udc_enable(struct pxa_udc *udc)
 }
 
 /**
- * usb_gadget_register_driver - Register gadget driver
+ * usb_gadget_probe_driver - Register gadget driver
  * @driver: gadget driver
+ * @bind: bind function
  *
  * When a driver is successfully registered, it will receive control requests
  * including set_configuration(), which enables non-control requests.  Then
@@ -1805,12 +1805,13 @@ static void udc_enable(struct pxa_udc *udc)
  *
  * Returns 0 if no error, -EINVAL, -ENODEV, -EBUSY otherwise
  */
-int usb_gadget_register_driver(struct usb_gadget_driver *driver)
+int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
+                int (*bind)(struct usb_gadget *))
 {
         struct pxa_udc *udc = the_controller;
         int retval;
 
-        if (!driver || driver->speed < USB_SPEED_FULL || !driver->bind
+        if (!driver || driver->speed < USB_SPEED_FULL || !bind
                         || !driver->disconnect || !driver->setup)
                 return -EINVAL;
         if (!udc)
@@ -1828,7 +1829,7 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver)
                 dev_err(udc->dev, "device_add error %d\n", retval);
                 goto add_fail;
         }
-        retval = driver->bind(&udc->gadget);
+        retval = bind(&udc->gadget);
         if (retval) {
                 dev_err(udc->dev, "bind to driver %s --> error %d\n",
                         driver->driver.name, retval);
@@ -1859,7 +1860,7 @@ add_fail:
         udc->gadget.dev.driver = NULL;
         return retval;
 }
-EXPORT_SYMBOL(usb_gadget_register_driver);
+EXPORT_SYMBOL(usb_gadget_probe_driver);
 
 
 /**
diff --git a/drivers/usb/gadget/r8a66597-udc.c b/drivers/usb/gadget/r8a66597-udc.c
index 2456ccd9965e..6dcc1f68fa60 100644
--- a/drivers/usb/gadget/r8a66597-udc.c
+++ b/drivers/usb/gadget/r8a66597-udc.c
@@ -42,6 +42,7 @@ static const char *r8a66597_ep_name[] = {
         "ep8", "ep9",
 };
 
+static void init_controller(struct r8a66597 *r8a66597);
 static void disable_controller(struct r8a66597 *r8a66597);
 static void irq_ep0_write(struct r8a66597_ep *ep, struct r8a66597_request *req);
 static void irq_packet_write(struct r8a66597_ep *ep,
@@ -104,6 +105,8 @@ __acquires(r8a66597->lock)
         spin_lock(&r8a66597->lock);
 
         disable_controller(r8a66597);
+        init_controller(r8a66597);
+        r8a66597_bset(r8a66597, VBSE, INTENB0);
         INIT_LIST_HEAD(&r8a66597->ep[0].queue);
 }
 
@@ -255,7 +258,7 @@ static int pipe_buffer_setting(struct r8a66597 *r8a66597,
                 break;
         case R8A66597_BULK:
                 /* isochronous pipes may be used as bulk pipes */
-                if (info->pipe > R8A66597_BASE_PIPENUM_BULK)
+                if (info->pipe >= R8A66597_BASE_PIPENUM_BULK)
                         bufnum = info->pipe - R8A66597_BASE_PIPENUM_BULK;
                 else
                         bufnum = info->pipe - R8A66597_BASE_PIPENUM_ISOC;
@@ -274,7 +277,7 @@ static int pipe_buffer_setting(struct r8a66597 *r8a66597,
         }
 
         if (buf_bsize && ((bufnum + 16) >= R8A66597_MAX_BUFNUM)) {
-                pr_err(KERN_ERR "r8a66597 pipe memory is insufficient\n");
+                pr_err("r8a66597 pipe memory is insufficient\n");
                 return -ENOMEM;
         }
 
@@ -1080,7 +1083,9 @@ static void irq_device_state(struct r8a66597 *r8a66597)
 
         if (dvsq == DS_DFLT) {
                 /* bus reset */
+                spin_unlock(&r8a66597->lock);
                 r8a66597->driver->disconnect(&r8a66597->gadget);
+                spin_lock(&r8a66597->lock);
                 r8a66597_update_usb_speed(r8a66597);
         }
         if (r8a66597->old_dvsq == DS_CNFG && dvsq != DS_CNFG)
@@ -1405,14 +1410,15 @@ static struct usb_ep_ops r8a66597_ep_ops = {
 /*-------------------------------------------------------------------------*/
 static struct r8a66597 *the_controller;
 
-int usb_gadget_register_driver(struct usb_gadget_driver *driver)
+int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
+                int (*bind)(struct usb_gadget *))
 {
         struct r8a66597 *r8a66597 = the_controller;
         int retval;
 
         if (!driver
                         || driver->speed != USB_SPEED_HIGH
-                        || !driver->bind
+                        || !bind
                         || !driver->setup)
                 return -EINVAL;
         if (!r8a66597)
@@ -1431,7 +1437,7 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver)
                 goto error;
         }
 
-        retval = driver->bind(&r8a66597->gadget);
+        retval = bind(&r8a66597->gadget);
         if (retval) {
                 printk(KERN_ERR "bind to driver error (%d)\n", retval);
                 device_del(&r8a66597->gadget.dev);
@@ -1456,7 +1462,7 @@ error:
 
         return retval;
 }
-EXPORT_SYMBOL(usb_gadget_register_driver);
+EXPORT_SYMBOL(usb_gadget_probe_driver);
 
 int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
 {
diff --git a/drivers/usb/gadget/r8a66597-udc.h b/drivers/usb/gadget/r8a66597-udc.h
index f763b5190afa..5fc22e09a0f1 100644
--- a/drivers/usb/gadget/r8a66597-udc.h
+++ b/drivers/usb/gadget/r8a66597-udc.h
@@ -136,7 +136,7 @@ static inline void r8a66597_read_fifo(struct r8a66597 *r8a66597,
                                       int len)
 {
         void __iomem *fifoaddr = r8a66597->reg + offset;
-        unsigned int data;
+        unsigned int data = 0;
         int i;
 
         if (r8a66597->pdata->on_chip) {
diff --git a/drivers/usb/gadget/rndis.c b/drivers/usb/gadget/rndis.c
index 972d5ddd1e18..d3cdffea9c8a 100644
--- a/drivers/usb/gadget/rndis.c
+++ b/drivers/usb/gadget/rndis.c
@@ -61,17 +61,17 @@ MODULE_PARM_DESC (rndis_debug, "enable debugging");
 #define RNDIS_MAX_CONFIGS       1
 
 
-static rndis_params rndis_per_dev_params [RNDIS_MAX_CONFIGS];
+static rndis_params rndis_per_dev_params[RNDIS_MAX_CONFIGS];
 
 /* Driver Version */
-static const __le32 rndis_driver_version = cpu_to_le32 (1);
+static const __le32 rndis_driver_version = cpu_to_le32(1);
 
 /* Function Prototypes */
-static rndis_resp_t *rndis_add_response (int configNr, u32 length);
+static rndis_resp_t *rndis_add_response(int configNr, u32 length);
 
 
 /* supported OIDs */
-static const u32 oid_supported_list [] =
+static const u32 oid_supported_list[] =
 {
         /* the general stuff */
         OID_GEN_SUPPORTED_LIST,
@@ -161,21 +161,20 @@ static const u32 oid_supported_list [] =
 
 
 /* NDIS Functions */
-static int
-gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
-                rndis_resp_t *r)
+static int gen_ndis_query_resp(int configNr, u32 OID, u8 *buf,
+                               unsigned buf_len, rndis_resp_t *r)
 {
-        int                     retval = -ENOTSUPP;
-        u32                     length = 4;     /* usually */
-        __le32                  *outbuf;
-        int                     i, count;
-        rndis_query_cmplt_type  *resp;
-        struct net_device       *net;
+        int retval = -ENOTSUPP;
+        u32 length = 4; /* usually */
+        __le32 *outbuf;
+        int i, count;
+        rndis_query_cmplt_type *resp;
+        struct net_device *net;
         struct rtnl_link_stats64 temp;
         const struct rtnl_link_stats64 *stats;
 
         if (!r) return -ENOMEM;
-        resp = (rndis_query_cmplt_type *) r->buf;
+        resp = (rndis_query_cmplt_type *)r->buf;
 
         if (!resp) return -ENOMEM;
 
@@ -191,8 +190,8 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
         }
 
         /* response goes here, right after the header */
-        outbuf = (__le32 *) &resp[1];
-        resp->InformationBufferOffset = cpu_to_le32 (16);
+        outbuf = (__le32 *)&resp[1];
+        resp->InformationBufferOffset = cpu_to_le32(16);
 
         net = rndis_per_dev_params[configNr].dev;
         stats = dev_get_stats(net, &temp);
@@ -204,10 +203,10 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
         /* mandatory */
         case OID_GEN_SUPPORTED_LIST:
                 pr_debug("%s: OID_GEN_SUPPORTED_LIST\n", __func__);
-                length = sizeof (oid_supported_list);
-                count  = length / sizeof (u32);
+                length = sizeof(oid_supported_list);
+                count  = length / sizeof(u32);
                 for (i = 0; i < count; i++)
-                        outbuf[i] = cpu_to_le32 (oid_supported_list[i]);
+                        outbuf[i] = cpu_to_le32(oid_supported_list[i]);
                 retval = 0;
                 break;
 
@@ -220,14 +219,14 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
                  * reddite ergo quae sunt Caesaris Caesari
                  * et quae sunt Dei Deo!
                  */
-                *outbuf = cpu_to_le32 (0);
+                *outbuf = cpu_to_le32(0);
                 retval = 0;
                 break;
 
         /* mandatory */
         case OID_GEN_MEDIA_SUPPORTED:
                 pr_debug("%s: OID_GEN_MEDIA_SUPPORTED\n", __func__);
-                *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr].medium);
+                *outbuf = cpu_to_le32(rndis_per_dev_params[configNr].medium);
                 retval = 0;
                 break;
 
@@ -235,16 +234,16 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
         case OID_GEN_MEDIA_IN_USE:
                 pr_debug("%s: OID_GEN_MEDIA_IN_USE\n", __func__);
                 /* one medium, one transport... (maybe you do it better) */
-                *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr].medium);
+                *outbuf = cpu_to_le32(rndis_per_dev_params[configNr].medium);
                 retval = 0;
                 break;
 
         /* mandatory */
         case OID_GEN_MAXIMUM_FRAME_SIZE:
                 pr_debug("%s: OID_GEN_MAXIMUM_FRAME_SIZE\n", __func__);
-                if (rndis_per_dev_params [configNr].dev) {
-                        *outbuf = cpu_to_le32 (
-                                rndis_per_dev_params [configNr].dev->mtu);
+                if (rndis_per_dev_params[configNr].dev) {
+                        *outbuf = cpu_to_le32(
+                                rndis_per_dev_params[configNr].dev->mtu);
                         retval = 0;
                 }
                 break;
@@ -253,21 +252,21 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
         case OID_GEN_LINK_SPEED:
                 if (rndis_debug > 1)
                         pr_debug("%s: OID_GEN_LINK_SPEED\n", __func__);
-                if (rndis_per_dev_params [configNr].media_state
+                if (rndis_per_dev_params[configNr].media_state
                                 == NDIS_MEDIA_STATE_DISCONNECTED)
-                        *outbuf = cpu_to_le32 (0);
+                        *outbuf = cpu_to_le32(0);
                 else
-                        *outbuf = cpu_to_le32 (
-                                rndis_per_dev_params [configNr].speed);
+                        *outbuf = cpu_to_le32(
+                                rndis_per_dev_params[configNr].speed);
                 retval = 0;
                 break;
 
         /* mandatory */
         case OID_GEN_TRANSMIT_BLOCK_SIZE:
                 pr_debug("%s: OID_GEN_TRANSMIT_BLOCK_SIZE\n", __func__);
-                if (rndis_per_dev_params [configNr].dev) {
-                        *outbuf = cpu_to_le32 (
-                                rndis_per_dev_params [configNr].dev->mtu);
+                if (rndis_per_dev_params[configNr].dev) {
+                        *outbuf = cpu_to_le32(
+                                rndis_per_dev_params[configNr].dev->mtu);
                         retval = 0;
                 }
                 break;
@@ -275,9 +274,9 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
         /* mandatory */
         case OID_GEN_RECEIVE_BLOCK_SIZE:
                 pr_debug("%s: OID_GEN_RECEIVE_BLOCK_SIZE\n", __func__);
-                if (rndis_per_dev_params [configNr].dev) {
-                        *outbuf = cpu_to_le32 (
-                                rndis_per_dev_params [configNr].dev->mtu);
+                if (rndis_per_dev_params[configNr].dev) {
+                        *outbuf = cpu_to_le32(
+                                rndis_per_dev_params[configNr].dev->mtu);
                         retval = 0;
                 }
                 break;
@@ -285,18 +284,20 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
         /* mandatory */
         case OID_GEN_VENDOR_ID:
                 pr_debug("%s: OID_GEN_VENDOR_ID\n", __func__);
-                *outbuf = cpu_to_le32 (
-                        rndis_per_dev_params [configNr].vendorID);
+                *outbuf = cpu_to_le32(
+                        rndis_per_dev_params[configNr].vendorID);
                 retval = 0;
                 break;
 
         /* mandatory */
         case OID_GEN_VENDOR_DESCRIPTION:
                 pr_debug("%s: OID_GEN_VENDOR_DESCRIPTION\n", __func__);
-                if ( rndis_per_dev_params [configNr].vendorDescr ) {
-                        length = strlen (rndis_per_dev_params [configNr].vendorDescr);
-                        memcpy (outbuf,
-                                rndis_per_dev_params [configNr].vendorDescr, length);
+                if (rndis_per_dev_params[configNr].vendorDescr) {
+                        length = strlen(rndis_per_dev_params[configNr].
+                                        vendorDescr);
+                        memcpy(outbuf,
+                                rndis_per_dev_params[configNr].vendorDescr,
+                                length);
                 } else {
                         outbuf[0] = 0;
                 }
@@ -313,7 +314,7 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
         /* mandatory */
         case OID_GEN_CURRENT_PACKET_FILTER:
                 pr_debug("%s: OID_GEN_CURRENT_PACKET_FILTER\n", __func__);
-                *outbuf = cpu_to_le32 (*rndis_per_dev_params[configNr].filter);
+                *outbuf = cpu_to_le32(*rndis_per_dev_params[configNr].filter);
                 retval = 0;
                 break;
 
@@ -328,14 +329,14 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
         case OID_GEN_MEDIA_CONNECT_STATUS:
                 if (rndis_debug > 1)
                         pr_debug("%s: OID_GEN_MEDIA_CONNECT_STATUS\n", __func__);
-                *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr]
+                *outbuf = cpu_to_le32(rndis_per_dev_params[configNr]
                                                 .media_state);
                 retval = 0;
                 break;
 
         case OID_GEN_PHYSICAL_MEDIUM:
                 pr_debug("%s: OID_GEN_PHYSICAL_MEDIUM\n", __func__);
-                *outbuf = cpu_to_le32 (0);
+                *outbuf = cpu_to_le32(0);
                 retval = 0;
                 break;
 
@@ -409,10 +410,10 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
         /* mandatory */
         case OID_802_3_PERMANENT_ADDRESS:
                 pr_debug("%s: OID_802_3_PERMANENT_ADDRESS\n", __func__);
-                if (rndis_per_dev_params [configNr].dev) {
+                if (rndis_per_dev_params[configNr].dev) {
                         length = ETH_ALEN;
-                        memcpy (outbuf,
-                                rndis_per_dev_params [configNr].host_mac,
+                        memcpy(outbuf,
+                                rndis_per_dev_params[configNr].host_mac,
                                 length);
                         retval = 0;
                 }
@@ -421,9 +422,9 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
         /* mandatory */
         case OID_802_3_CURRENT_ADDRESS:
                 pr_debug("%s: OID_802_3_CURRENT_ADDRESS\n", __func__);
-                if (rndis_per_dev_params [configNr].dev) {
+                if (rndis_per_dev_params[configNr].dev) {
                         length = ETH_ALEN;
-                        memcpy (outbuf,
+                        memcpy(outbuf,
                                 rndis_per_dev_params [configNr].host_mac,
                                 length);
                         retval = 0;
@@ -434,7 +435,7 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
         case OID_802_3_MULTICAST_LIST:
                 pr_debug("%s: OID_802_3_MULTICAST_LIST\n", __func__);
                 /* Multicast base address only */
-                *outbuf = cpu_to_le32 (0xE0000000);
+                *outbuf = cpu_to_le32(0xE0000000);
                 retval = 0;
                 break;
 
@@ -442,7 +443,7 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
         case OID_802_3_MAXIMUM_LIST_SIZE:
                 pr_debug("%s: OID_802_3_MAXIMUM_LIST_SIZE\n", __func__);
                 /* Multicast base address only */
-                *outbuf = cpu_to_le32 (1);
+                *outbuf = cpu_to_le32(1);
                 retval = 0;
                 break;
 
@@ -466,14 +467,14 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
         /* mandatory */
         case OID_802_3_XMIT_ONE_COLLISION:
                 pr_debug("%s: OID_802_3_XMIT_ONE_COLLISION\n", __func__);
-                *outbuf = cpu_to_le32 (0);
+                *outbuf = cpu_to_le32(0);
                 retval = 0;
                 break;
 
         /* mandatory */
         case OID_802_3_XMIT_MORE_COLLISIONS:
                 pr_debug("%s: OID_802_3_XMIT_MORE_COLLISIONS\n", __func__);
-                *outbuf = cpu_to_le32 (0);
+                *outbuf = cpu_to_le32(0);
                 retval = 0;
                 break;
 
@@ -484,22 +485,22 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
         if (retval < 0)
                 length = 0;
 
-        resp->InformationBufferLength = cpu_to_le32 (length);
-        r->length = length + sizeof *resp;
-        resp->MessageLength = cpu_to_le32 (r->length);
+        resp->InformationBufferLength = cpu_to_le32(length);
+        r->length = length + sizeof(*resp);
+        resp->MessageLength = cpu_to_le32(r->length);
         return retval;
 }
 
-static int gen_ndis_set_resp (u8 configNr, u32 OID, u8 *buf, u32 buf_len,
-                        rndis_resp_t *r)
+static int gen_ndis_set_resp(u8 configNr, u32 OID, u8 *buf, u32 buf_len,
+                             rndis_resp_t *r)
 {
-        rndis_set_cmplt_type            *resp;
-        int                             i, retval = -ENOTSUPP;
-        struct rndis_params             *params;
+        rndis_set_cmplt_type *resp;
+        int i, retval = -ENOTSUPP;
+        struct rndis_params *params;
 
         if (!r)
                 return -ENOMEM;
-        resp = (rndis_set_cmplt_type *) r->buf;
+        resp = (rndis_set_cmplt_type *)r->buf;
         if (!resp)
                 return -ENOMEM;
 
@@ -514,7 +515,7 @@ static int gen_ndis_set_resp (u8 configNr, u32 OID, u8 *buf, u32 buf_len,
                 }
         }
 
-        params = &rndis_per_dev_params [configNr];
+        params = &rndis_per_dev_params[configNr];
         switch (OID) {
         case OID_GEN_CURRENT_PACKET_FILTER:
 
@@ -537,11 +538,11 @@ static int gen_ndis_set_resp (u8 configNr, u32 OID, u8 *buf, u32 buf_len,
                         params->state = RNDIS_DATA_INITIALIZED;
                         netif_carrier_on(params->dev);
                         if (netif_running(params->dev))
-                                netif_wake_queue (params->dev);
+                                netif_wake_queue(params->dev);
                 } else {
                         params->state = RNDIS_INITIALIZED;
-                        netif_carrier_off (params->dev);
-                        netif_stop_queue (params->dev);
+                        netif_carrier_off(params->dev);
+                        netif_stop_queue(params->dev);
                 }
                 break;
 
@@ -563,48 +564,47 @@ static int gen_ndis_set_resp (u8 configNr, u32 OID, u8 *buf, u32 buf_len,
  * Response Functions
  */
 
-static int rndis_init_response (int configNr, rndis_init_msg_type *buf)
+static int rndis_init_response(int configNr, rndis_init_msg_type *buf)
 {
-        rndis_init_cmplt_type   *resp;
-        rndis_resp_t            *r;
-        struct rndis_params     *params = rndis_per_dev_params + configNr;
+        rndis_init_cmplt_type *resp;
+        rndis_resp_t *r;
+        struct rndis_params *params = rndis_per_dev_params + configNr;
 
         if (!params->dev)
                 return -ENOTSUPP;
 
-        r = rndis_add_response (configNr, sizeof (rndis_init_cmplt_type));
+        r = rndis_add_response(configNr, sizeof(rndis_init_cmplt_type));
         if (!r)
                 return -ENOMEM;
-        resp = (rndis_init_cmplt_type *) r->buf;
+        resp = (rndis_init_cmplt_type *)r->buf;
 
-        resp->MessageType = cpu_to_le32 (
-                        REMOTE_NDIS_INITIALIZE_CMPLT);
-        resp->MessageLength = cpu_to_le32 (52);
+        resp->MessageType = cpu_to_le32(REMOTE_NDIS_INITIALIZE_CMPLT);
+        resp->MessageLength = cpu_to_le32(52);
         resp->RequestID = buf->RequestID; /* Still LE in msg buffer */
-        resp->Status = cpu_to_le32 (RNDIS_STATUS_SUCCESS);
-        resp->MajorVersion = cpu_to_le32 (RNDIS_MAJOR_VERSION);
-        resp->MinorVersion = cpu_to_le32 (RNDIS_MINOR_VERSION);
-        resp->DeviceFlags = cpu_to_le32 (RNDIS_DF_CONNECTIONLESS);
-        resp->Medium = cpu_to_le32 (RNDIS_MEDIUM_802_3);
-        resp->MaxPacketsPerTransfer = cpu_to_le32 (1);
-        resp->MaxTransferSize = cpu_to_le32 (
+        resp->Status = cpu_to_le32(RNDIS_STATUS_SUCCESS);
+        resp->MajorVersion = cpu_to_le32(RNDIS_MAJOR_VERSION);
+        resp->MinorVersion = cpu_to_le32(RNDIS_MINOR_VERSION);
+        resp->DeviceFlags = cpu_to_le32(RNDIS_DF_CONNECTIONLESS);
+        resp->Medium = cpu_to_le32(RNDIS_MEDIUM_802_3);
+        resp->MaxPacketsPerTransfer = cpu_to_le32(1);
+        resp->MaxTransferSize = cpu_to_le32(
                   params->dev->mtu
-                + sizeof (struct ethhdr)
-                + sizeof (struct rndis_packet_msg_type)
+                + sizeof(struct ethhdr)
+                + sizeof(struct rndis_packet_msg_type)
                 + 22);
-        resp->PacketAlignmentFactor = cpu_to_le32 (0);
-        resp->AFListOffset = cpu_to_le32 (0);
-        resp->AFListSize = cpu_to_le32 (0);
+        resp->PacketAlignmentFactor = cpu_to_le32(0);
+        resp->AFListOffset = cpu_to_le32(0);
+        resp->AFListSize = cpu_to_le32(0);
 
         params->resp_avail(params->v);
         return 0;
 }
 
-static int rndis_query_response (int configNr, rndis_query_msg_type *buf)
+static int rndis_query_response(int configNr, rndis_query_msg_type *buf)
 {
         rndis_query_cmplt_type *resp;
-        rndis_resp_t            *r;
-        struct rndis_params     *params = rndis_per_dev_params + configNr;
+        rndis_resp_t *r;
+        struct rndis_params *params = rndis_per_dev_params + configNr;
 
         /* pr_debug("%s: OID = %08X\n", __func__, cpu_to_le32(buf->OID)); */
         if (!params->dev)
@@ -616,47 +616,46 @@ static int rndis_query_response (int configNr, rndis_query_msg_type *buf)
          * rndis_query_cmplt_type followed by data.
          * oid_supported_list is the largest data reply
          */
-        r = rndis_add_response (configNr,
-                sizeof (oid_supported_list) + sizeof(rndis_query_cmplt_type));
+        r = rndis_add_response(configNr,
+                sizeof(oid_supported_list) + sizeof(rndis_query_cmplt_type));
         if (!r)
                 return -ENOMEM;
-        resp = (rndis_query_cmplt_type *) r->buf;
+        resp = (rndis_query_cmplt_type *)r->buf;
 
-        resp->MessageType = cpu_to_le32 (REMOTE_NDIS_QUERY_CMPLT);
+        resp->MessageType = cpu_to_le32(REMOTE_NDIS_QUERY_CMPLT);
         resp->RequestID = buf->RequestID; /* Still LE in msg buffer */
 
-        if (gen_ndis_query_resp (configNr, le32_to_cpu (buf->OID),
+        if (gen_ndis_query_resp(configNr, le32_to_cpu(buf->OID),
                         le32_to_cpu(buf->InformationBufferOffset)
-                                        + 8 + (u8 *) buf,
+                                        + 8 + (u8 *)buf,
                         le32_to_cpu(buf->InformationBufferLength),
                         r)) {
                 /* OID not supported */
-                resp->Status = cpu_to_le32 (
-                                RNDIS_STATUS_NOT_SUPPORTED);
-                resp->MessageLength = cpu_to_le32 (sizeof *resp);
-                resp->InformationBufferLength = cpu_to_le32 (0);
-                resp->InformationBufferOffset = cpu_to_le32 (0);
+                resp->Status = cpu_to_le32(RNDIS_STATUS_NOT_SUPPORTED);
+                resp->MessageLength = cpu_to_le32(sizeof *resp);
+                resp->InformationBufferLength = cpu_to_le32(0);
+                resp->InformationBufferOffset = cpu_to_le32(0);
         } else
-                resp->Status = cpu_to_le32 (RNDIS_STATUS_SUCCESS);
+                resp->Status = cpu_to_le32(RNDIS_STATUS_SUCCESS);
 
         params->resp_avail(params->v);
         return 0;
 }
 
-static int rndis_set_response (int configNr, rndis_set_msg_type *buf)
+static int rndis_set_response(int configNr, rndis_set_msg_type *buf)
 {
-        u32                     BufLength, BufOffset;
-        rndis_set_cmplt_type    *resp;
-        rndis_resp_t            *r;
-        struct rndis_params     *params = rndis_per_dev_params + configNr;
+        u32 BufLength, BufOffset;
+        rndis_set_cmplt_type *resp;
+        rndis_resp_t *r;
+        struct rndis_params *params = rndis_per_dev_params + configNr;
 
-        r = rndis_add_response (configNr, sizeof (rndis_set_cmplt_type));
+        r = rndis_add_response(configNr, sizeof(rndis_set_cmplt_type));
         if (!r)
                 return -ENOMEM;
-        resp = (rndis_set_cmplt_type *) r->buf;
+        resp = (rndis_set_cmplt_type *)r->buf;
 
-        BufLength = le32_to_cpu (buf->InformationBufferLength);
-        BufOffset = le32_to_cpu (buf->InformationBufferOffset);
+        BufLength = le32_to_cpu(buf->InformationBufferLength);
+        BufOffset = le32_to_cpu(buf->InformationBufferOffset);
 
 #ifdef  VERBOSE_DEBUG
         pr_debug("%s: Length: %d\n", __func__, BufLength);
@@ -670,59 +669,59 @@ static int rndis_set_response (int configNr, rndis_set_msg_type *buf)
         pr_debug("\n");
 #endif
 
-        resp->MessageType = cpu_to_le32 (REMOTE_NDIS_SET_CMPLT);
-        resp->MessageLength = cpu_to_le32 (16);
+        resp->MessageType = cpu_to_le32(REMOTE_NDIS_SET_CMPLT);
+        resp->MessageLength = cpu_to_le32(16);
         resp->RequestID = buf->RequestID; /* Still LE in msg buffer */
-        if (gen_ndis_set_resp (configNr, le32_to_cpu (buf->OID),
-                        ((u8 *) buf) + 8 + BufOffset, BufLength, r))
-                resp->Status = cpu_to_le32 (RNDIS_STATUS_NOT_SUPPORTED);
+        if (gen_ndis_set_resp(configNr, le32_to_cpu(buf->OID),
+                        ((u8 *)buf) + 8 + BufOffset, BufLength, r))
+                resp->Status = cpu_to_le32(RNDIS_STATUS_NOT_SUPPORTED);
         else
-                resp->Status = cpu_to_le32 (RNDIS_STATUS_SUCCESS);
+                resp->Status = cpu_to_le32(RNDIS_STATUS_SUCCESS);
 
         params->resp_avail(params->v);
         return 0;
 }
 
-static int rndis_reset_response (int configNr, rndis_reset_msg_type *buf)
+static int rndis_reset_response(int configNr, rndis_reset_msg_type *buf)
 {
-        rndis_reset_cmplt_type  *resp;
-        rndis_resp_t            *r;
-        struct rndis_params     *params = rndis_per_dev_params + configNr;
+        rndis_reset_cmplt_type *resp;
+        rndis_resp_t *r;
+        struct rndis_params *params = rndis_per_dev_params + configNr;
 
-        r = rndis_add_response (configNr, sizeof (rndis_reset_cmplt_type));
+        r = rndis_add_response(configNr, sizeof(rndis_reset_cmplt_type));
         if (!r)
                 return -ENOMEM;
-        resp = (rndis_reset_cmplt_type *) r->buf;
+        resp = (rndis_reset_cmplt_type *)r->buf;
 
-        resp->MessageType = cpu_to_le32 (REMOTE_NDIS_RESET_CMPLT);
-        resp->MessageLength = cpu_to_le32 (16);
-        resp->Status = cpu_to_le32 (RNDIS_STATUS_SUCCESS);
+        resp->MessageType = cpu_to_le32(REMOTE_NDIS_RESET_CMPLT);
+        resp->MessageLength = cpu_to_le32(16);
+        resp->Status = cpu_to_le32(RNDIS_STATUS_SUCCESS);
         /* resent information */
-        resp->AddressingReset = cpu_to_le32 (1);
+        resp->AddressingReset = cpu_to_le32(1);
 
         params->resp_avail(params->v);
         return 0;
 }
 
-static int rndis_keepalive_response (int configNr,
-                                rndis_keepalive_msg_type *buf)
+static int rndis_keepalive_response(int configNr,
+                                    rndis_keepalive_msg_type *buf)
 {
-        rndis_keepalive_cmplt_type      *resp;
-        rndis_resp_t                    *r;
-        struct rndis_params     *params = rndis_per_dev_params + configNr;
+        rndis_keepalive_cmplt_type *resp;
+        rndis_resp_t *r;
+        struct rndis_params *params = rndis_per_dev_params + configNr;
 
         /* host "should" check only in RNDIS_DATA_INITIALIZED state */
 
-        r = rndis_add_response (configNr, sizeof (rndis_keepalive_cmplt_type));
+        r = rndis_add_response(configNr, sizeof(rndis_keepalive_cmplt_type));
         if (!r)
                 return -ENOMEM;
-        resp = (rndis_keepalive_cmplt_type *) r->buf;
+        resp = (rndis_keepalive_cmplt_type *)r->buf;
 
-        resp->MessageType = cpu_to_le32 (
+        resp->MessageType = cpu_to_le32(
                         REMOTE_NDIS_KEEPALIVE_CMPLT);
-        resp->MessageLength = cpu_to_le32 (16);
+        resp->MessageLength = cpu_to_le32(16);
         resp->RequestID = buf->RequestID; /* Still LE in msg buffer */
-        resp->Status = cpu_to_le32 (RNDIS_STATUS_SUCCESS);
+        resp->Status = cpu_to_le32(RNDIS_STATUS_SUCCESS);
 
         params->resp_avail(params->v);
         return 0;
@@ -732,86 +731,85 @@ static int rndis_keepalive_response (int configNr,
 /*
  * Device to Host Comunication
  */
-static int rndis_indicate_status_msg (int configNr, u32 status)
+static int rndis_indicate_status_msg(int configNr, u32 status)
 {
-        rndis_indicate_status_msg_type  *resp;
-        rndis_resp_t                    *r;
-        struct rndis_params     *params = rndis_per_dev_params + configNr;
+        rndis_indicate_status_msg_type *resp;
+        rndis_resp_t *r;
+        struct rndis_params *params = rndis_per_dev_params + configNr;
 
         if (params->state == RNDIS_UNINITIALIZED)
                 return -ENOTSUPP;
 
-        r = rndis_add_response (configNr,
-                                sizeof (rndis_indicate_status_msg_type));
+        r = rndis_add_response(configNr,
+                                sizeof(rndis_indicate_status_msg_type));
         if (!r)
                 return -ENOMEM;
-        resp = (rndis_indicate_status_msg_type *) r->buf;
+        resp = (rndis_indicate_status_msg_type *)r->buf;
 
-        resp->MessageType = cpu_to_le32 (
-                        REMOTE_NDIS_INDICATE_STATUS_MSG);
-        resp->MessageLength = cpu_to_le32 (20);
-        resp->Status = cpu_to_le32 (status);
-        resp->StatusBufferLength = cpu_to_le32 (0);
-        resp->StatusBufferOffset = cpu_to_le32 (0);
+        resp->MessageType = cpu_to_le32(REMOTE_NDIS_INDICATE_STATUS_MSG);
+        resp->MessageLength = cpu_to_le32(20);
+        resp->Status = cpu_to_le32(status);
+        resp->StatusBufferLength = cpu_to_le32(0);
+        resp->StatusBufferOffset = cpu_to_le32(0);
 
         params->resp_avail(params->v);
         return 0;
 }
 
-int rndis_signal_connect (int configNr)
+int rndis_signal_connect(int configNr)
 {
-        rndis_per_dev_params [configNr].media_state
+        rndis_per_dev_params[configNr].media_state
                         = NDIS_MEDIA_STATE_CONNECTED;
-        return rndis_indicate_status_msg (configNr,
+        return rndis_indicate_status_msg(configNr,
                                           RNDIS_STATUS_MEDIA_CONNECT);
 }
 
-int rndis_signal_disconnect (int configNr)
+int rndis_signal_disconnect(int configNr)
 {
-        rndis_per_dev_params [configNr].media_state
+        rndis_per_dev_params[configNr].media_state
                         = NDIS_MEDIA_STATE_DISCONNECTED;
-        return rndis_indicate_status_msg (configNr,
+        return rndis_indicate_status_msg(configNr,
                                           RNDIS_STATUS_MEDIA_DISCONNECT);
 }
 
-void rndis_uninit (int configNr)
+void rndis_uninit(int configNr)
 {
         u8 *buf;
         u32 length;
 
         if (configNr >= RNDIS_MAX_CONFIGS)
                 return;
-        rndis_per_dev_params [configNr].state = RNDIS_UNINITIALIZED;
+        rndis_per_dev_params[configNr].state = RNDIS_UNINITIALIZED;
 
         /* drain the response queue */
         while ((buf = rndis_get_next_response(configNr, &length)))
                 rndis_free_response(configNr, buf);
 }
 
-void rndis_set_host_mac (int configNr, const u8 *addr)
+void rndis_set_host_mac(int configNr, const u8 *addr)
 {
-        rndis_per_dev_params [configNr].host_mac = addr;
+        rndis_per_dev_params[configNr].host_mac = addr;
 }
 
 /*
  * Message Parser
  */
-int rndis_msg_parser (u8 configNr, u8 *buf)
+int rndis_msg_parser(u8 configNr, u8 *buf)
 {
         u32 MsgType, MsgLength;
         __le32 *tmp;
-        struct rndis_params             *params;
+        struct rndis_params *params;
 
         if (!buf)
                 return -ENOMEM;
 
-        tmp = (__le32 *) buf;
+        tmp = (__le32 *)buf;
         MsgType   = get_unaligned_le32(tmp++);
         MsgLength = get_unaligned_le32(tmp++);
 
         if (configNr >= RNDIS_MAX_CONFIGS)
                 return -ENOTSUPP;
-        params = &rndis_per_dev_params [configNr];
+        params = &rndis_per_dev_params[configNr];
 
         /* NOTE: RNDIS is *EXTREMELY* chatty ... Windows constantly polls for
          * rx/tx statistics and link status, in addition to KEEPALIVE traffic
@@ -822,41 +820,41 @@ int rndis_msg_parser (u8 configNr, u8 *buf)
         switch (MsgType) {
         case REMOTE_NDIS_INITIALIZE_MSG:
                 pr_debug("%s: REMOTE_NDIS_INITIALIZE_MSG\n",
-                        __func__ );
+                        __func__);
                 params->state = RNDIS_INITIALIZED;
-                return  rndis_init_response (configNr,
-                                        (rndis_init_msg_type *) buf);
+                return rndis_init_response(configNr,
+                                        (rndis_init_msg_type *)buf);
 
         case REMOTE_NDIS_HALT_MSG:
                 pr_debug("%s: REMOTE_NDIS_HALT_MSG\n",
-                        __func__ );
+                        __func__);
                 params->state = RNDIS_UNINITIALIZED;
                 if (params->dev) {
-                        netif_carrier_off (params->dev);
-                        netif_stop_queue (params->dev);
+                        netif_carrier_off(params->dev);
+                        netif_stop_queue(params->dev);
                 }
                 return 0;
 
         case REMOTE_NDIS_QUERY_MSG:
-                return rndis_query_response (configNr,
-                                        (rndis_query_msg_type *) buf);
+                return rndis_query_response(configNr,
+                                        (rndis_query_msg_type *)buf);
 
         case REMOTE_NDIS_SET_MSG:
-                return rndis_set_response (configNr,
-                                        (rndis_set_msg_type *) buf);
+                return rndis_set_response(configNr,
+                                        (rndis_set_msg_type *)buf);
 
         case REMOTE_NDIS_RESET_MSG:
                 pr_debug("%s: REMOTE_NDIS_RESET_MSG\n",
-                        __func__ );
-                return rndis_reset_response (configNr,
-                                        (rndis_reset_msg_type *) buf);
+                        __func__);
+                return rndis_reset_response(configNr,
+                                        (rndis_reset_msg_type *)buf);
 
         case REMOTE_NDIS_KEEPALIVE_MSG:
                 /* For USB: host does this every 5 seconds */
                 if (rndis_debug > 1)
                         pr_debug("%s: REMOTE_NDIS_KEEPALIVE_MSG\n",
-                                __func__ );
-                return rndis_keepalive_response (configNr,
+                                __func__);
+                return rndis_keepalive_response(configNr,
                                                  (rndis_keepalive_msg_type *)
                                                  buf);
 
@@ -866,7 +864,7 @@ int rndis_msg_parser (u8 configNr, u8 *buf)
                  * suspending itself.
                  */
                 pr_warning("%s: unknown RNDIS message 0x%08X len %d\n",
-                        __func__ , MsgType, MsgLength);
+                        __func__, MsgType, MsgLength);
                 {
                         unsigned i;
                         for (i = 0; i < MsgLength; i += 16) {
@@ -901,10 +899,10 @@ int rndis_register(void (*resp_avail)(void *v), void *v)
                 return -EINVAL;
 
         for (i = 0; i < RNDIS_MAX_CONFIGS; i++) {
-                if (!rndis_per_dev_params [i].used) {
-                        rndis_per_dev_params [i].used = 1;
-                        rndis_per_dev_params [i].resp_avail = resp_avail;
-                        rndis_per_dev_params [i].v = v;
+                if (!rndis_per_dev_params[i].used) {
+                        rndis_per_dev_params[i].used = 1;
+                        rndis_per_dev_params[i].resp_avail = resp_avail;
+                        rndis_per_dev_params[i].v = v;
                         pr_debug("%s: configNr = %d\n", __func__, i);
                         return i;
                 }
@@ -914,14 +912,12 @@ int rndis_register(void (*resp_avail)(void *v), void *v)
         return -ENODEV;
 }
 
-void rndis_deregister (int configNr)
+void rndis_deregister(int configNr)
 {
-        pr_debug("%s: \n", __func__);
+        pr_debug("%s:\n", __func__);
 
         if (configNr >= RNDIS_MAX_CONFIGS) return;
-        rndis_per_dev_params [configNr].used = 0;
-
-        return;
+        rndis_per_dev_params[configNr].used = 0;
 }
 
 int rndis_set_param_dev(u8 configNr, struct net_device *dev, u16 *cdc_filter)
@@ -931,76 +927,76 @@ int rndis_set_param_dev(u8 configNr, struct net_device *dev, u16 *cdc_filter)
                 return -EINVAL;
         if (configNr >= RNDIS_MAX_CONFIGS) return -1;
 
-        rndis_per_dev_params [configNr].dev = dev;
-        rndis_per_dev_params [configNr].filter = cdc_filter;
+        rndis_per_dev_params[configNr].dev = dev;
+        rndis_per_dev_params[configNr].filter = cdc_filter;
 
         return 0;
 }
 
-int rndis_set_param_vendor (u8 configNr, u32 vendorID, const char *vendorDescr)
+int rndis_set_param_vendor(u8 configNr, u32 vendorID, const char *vendorDescr)
 {
         pr_debug("%s:\n", __func__);
         if (!vendorDescr) return -1;
         if (configNr >= RNDIS_MAX_CONFIGS) return -1;
 
-        rndis_per_dev_params [configNr].vendorID = vendorID;
-        rndis_per_dev_params [configNr].vendorDescr = vendorDescr;
+        rndis_per_dev_params[configNr].vendorID = vendorID;
+        rndis_per_dev_params[configNr].vendorDescr = vendorDescr;
 
         return 0;
 }
 
-int rndis_set_param_medium (u8 configNr, u32 medium, u32 speed)
+int rndis_set_param_medium(u8 configNr, u32 medium, u32 speed)
 {
         pr_debug("%s: %u %u\n", __func__, medium, speed);
         if (configNr >= RNDIS_MAX_CONFIGS) return -1;
 
-        rndis_per_dev_params [configNr].medium = medium;
-        rndis_per_dev_params [configNr].speed = speed;
+        rndis_per_dev_params[configNr].medium = medium;
+        rndis_per_dev_params[configNr].speed = speed;
 
         return 0;
 }
 
-void rndis_add_hdr (struct sk_buff *skb)
+void rndis_add_hdr(struct sk_buff *skb)
 {
-        struct rndis_packet_msg_type    *header;
+        struct rndis_packet_msg_type *header;
 
         if (!skb)
                 return;
-        header = (void *) skb_push (skb, sizeof *header);
-        memset (header, 0, sizeof *header);
+        header = (void *)skb_push(skb, sizeof(*header));
+        memset(header, 0, sizeof *header);
         header->MessageType = cpu_to_le32(REMOTE_NDIS_PACKET_MSG);
         header->MessageLength = cpu_to_le32(skb->len);
-        header->DataOffset = cpu_to_le32 (36);
-        header->DataLength = cpu_to_le32(skb->len - sizeof *header);
+        header->DataOffset = cpu_to_le32(36);
+        header->DataLength = cpu_to_le32(skb->len - sizeof(*header));
 }
 
-void rndis_free_response (int configNr, u8 *buf)
+void rndis_free_response(int configNr, u8 *buf)
 {
-        rndis_resp_t            *r;
-        struct list_head        *act, *tmp;
+        rndis_resp_t *r;
+        struct list_head *act, *tmp;
 
-        list_for_each_safe (act, tmp,
-                        &(rndis_per_dev_params [configNr].resp_queue))
+        list_for_each_safe(act, tmp,
+                        &(rndis_per_dev_params[configNr].resp_queue))
         {
-                r = list_entry (act, rndis_resp_t, list);
+                r = list_entry(act, rndis_resp_t, list);
                 if (r && r->buf == buf) {
-                        list_del (&r->list);
-                        kfree (r);
+                        list_del(&r->list);
+                        kfree(r);
                 }
         }
 }
 
-u8 *rndis_get_next_response (int configNr, u32 *length)
+u8 *rndis_get_next_response(int configNr, u32 *length)
 {
-        rndis_resp_t            *r;
-        struct list_head        *act, *tmp;
+        rndis_resp_t *r;
+        struct list_head *act, *tmp;
 
         if (!length) return NULL;
 
-        list_for_each_safe (act, tmp,
-                        &(rndis_per_dev_params [configNr].resp_queue))
+        list_for_each_safe(act, tmp,
+                        &(rndis_per_dev_params[configNr].resp_queue))
         {
-                r = list_entry (act, rndis_resp_t, list);
+                r = list_entry(act, rndis_resp_t, list);
                 if (!r->send) {
                         r->send = 1;
                         *length = r->length;
@@ -1011,20 +1007,20 @@ u8 *rndis_get_next_response (int configNr, u32 *length)
         return NULL;
 }
 
-static rndis_resp_t *rndis_add_response (int configNr, u32 length)
+static rndis_resp_t *rndis_add_response(int configNr, u32 length)
 {
-        rndis_resp_t    *r;
+        rndis_resp_t *r;
 
-        /* NOTE:  this gets copied into ether.c USB_BUFSIZ bytes ... */
-        r = kmalloc (sizeof (rndis_resp_t) + length, GFP_ATOMIC);
+        /* NOTE: this gets copied into ether.c USB_BUFSIZ bytes ... */
+        r = kmalloc(sizeof(rndis_resp_t) + length, GFP_ATOMIC);
         if (!r) return NULL;
 
-        r->buf = (u8 *) (r + 1);
+        r->buf = (u8 *)(r + 1);
         r->length = length;
         r->send = 0;
 
-        list_add_tail (&r->list,
-                &(rndis_per_dev_params [configNr].resp_queue));
+        list_add_tail(&r->list,
+                &(rndis_per_dev_params[configNr].resp_queue));
         return r;
 }
 
@@ -1033,7 +1029,7 @@ int rndis_rm_hdr(struct gether *port,
                         struct sk_buff_head *list)
 {
         /* tmp points to a struct rndis_packet_msg_type */
-        __le32          *tmp = (void *) skb->data;
+        __le32 *tmp = (void *)skb->data;
 
         /* MessageType, MessageLength */
         if (cpu_to_le32(REMOTE_NDIS_PACKET_MSG)
@@ -1054,7 +1050,7 @@ int rndis_rm_hdr(struct gether *port,
         return 0;
 }
 
-#ifdef  CONFIG_USB_GADGET_DEBUG_FILES
+#ifdef CONFIG_USB_GADGET_DEBUG_FILES
 
 static int rndis_proc_show(struct seq_file *m, void *v)
 {
@@ -1087,7 +1083,7 @@ static int rndis_proc_show(struct seq_file *m, void *v)
 }
 
 static ssize_t rndis_proc_write(struct file *file, const char __user *buffer,
-                size_t count, loff_t *ppos)
+                                size_t count, loff_t *ppos)
 {
         rndis_params *p = PDE(file->f_path.dentry->d_inode)->data;
         u32 speed = 0;
@@ -1109,11 +1105,11 @@ static ssize_t rndis_proc_write(struct file *file, const char __user *buffer,
                 case '8':
                 case '9':
                         fl_speed = 1;
-                        speed = speed*10 + c - '0';
+                        speed = speed * 10 + c - '0';
                         break;
                 case 'C':
                 case 'c':
-                        rndis_signal_connect (p->confignr);
+                        rndis_signal_connect(p->confignr);
                         break;
                 case 'D':
                 case 'd':
@@ -1145,11 +1141,11 @@ static const struct file_operations rndis_proc_fops = {
         .write          = rndis_proc_write,
 };
 
-#define NAME_TEMPLATE   "driver/rndis-%03d"
+#define NAME_TEMPLATE "driver/rndis-%03d"
 
 static struct proc_dir_entry *rndis_connect_state [RNDIS_MAX_CONFIGS];
 
-#endif  /* CONFIG_USB_GADGET_DEBUG_FILES */
+#endif /* CONFIG_USB_GADGET_DEBUG_FILES */
 
 
 int rndis_init(void)
@@ -1160,42 +1156,40 @@ int rndis_init(void)
 #ifdef  CONFIG_USB_GADGET_DEBUG_FILES
                 char name [20];
 
-                sprintf (name, NAME_TEMPLATE, i);
-                if (!(rndis_connect_state [i]
-                                = proc_create_data(name, 0660, NULL,
+                sprintf(name, NAME_TEMPLATE, i);
+                rndis_connect_state[i] = proc_create_data(name, 0660, NULL,
                                         &rndis_proc_fops,
-                                        (void *)(rndis_per_dev_params + i))))
-                {
-                        pr_debug("%s :remove entries", __func__);
+                                        (void *)(rndis_per_dev_params + i));
+                if (!rndis_connect_state[i]) {
+                        pr_debug("%s: remove entries", __func__);
                         while (i) {
-                                sprintf (name, NAME_TEMPLATE, --i);
-                                remove_proc_entry (name, NULL);
+                                sprintf(name, NAME_TEMPLATE, --i);
+                                remove_proc_entry(name, NULL);
                         }
                         pr_debug("\n");
                         return -EIO;
                 }
 #endif
-                rndis_per_dev_params [i].confignr = i;
-                rndis_per_dev_params [i].used = 0;
-                rndis_per_dev_params [i].state = RNDIS_UNINITIALIZED;
-                rndis_per_dev_params [i].media_state
+                rndis_per_dev_params[i].confignr = i;
+                rndis_per_dev_params[i].used = 0;
+                rndis_per_dev_params[i].state = RNDIS_UNINITIALIZED;
+                rndis_per_dev_params[i].media_state
                                 = NDIS_MEDIA_STATE_DISCONNECTED;
-                INIT_LIST_HEAD (&(rndis_per_dev_params [i].resp_queue));
+                INIT_LIST_HEAD(&(rndis_per_dev_params[i].resp_queue));
         }
 
         return 0;
 }
 
-void rndis_exit (void)
+void rndis_exit(void)
 {
-#ifdef  CONFIG_USB_GADGET_DEBUG_FILES
+#ifdef CONFIG_USB_GADGET_DEBUG_FILES
         u8 i;
-        char name [20];
+        char name[20];
 
         for (i = 0; i < RNDIS_MAX_CONFIGS; i++) {
-                sprintf (name, NAME_TEMPLATE, i);
-                remove_proc_entry (name, NULL);
+                sprintf(name, NAME_TEMPLATE, i);
+                remove_proc_entry(name, NULL);
         }
 #endif
 }
-
diff --git a/drivers/usb/gadget/s3c-hsotg.c b/drivers/usb/gadget/s3c-hsotg.c
index a229744a8c7d..0dfee282878a 100644
--- a/drivers/usb/gadget/s3c-hsotg.c
+++ b/drivers/usb/gadget/s3c-hsotg.c
@@ -1,5 +1,8 @@
 /* linux/drivers/usb/gadget/s3c-hsotg.c
  *
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd.
+ *              http://www.samsung.com
+ *
  * Copyright 2008 Openmoko, Inc.
  * Copyright 2008 Simtec Electronics
  *      Ben Dooks <ben@simtec.co.uk>
@@ -41,8 +44,8 @@
 /* EP0_MPS_LIMIT
  *
  * Unfortunately there seems to be a limit of the amount of data that can
- * be transfered by IN transactions on EP0. This is either 127 bytes or 3
- * packets (which practially means 1 packet and 63 bytes of data) when the
+ * be transferred by IN transactions on EP0. This is either 127 bytes or 3
+ * packets (which practically means 1 packet and 63 bytes of data) when the
  * MPS is set to 64.
  *
  * This means if we are wanting to move >127 bytes of data, we need to
@@ -613,11 +616,10 @@ static unsigned get_ep_limit(struct s3c_hsotg_ep *hs_ep)
                 maxpkt = S3C_DxEPTSIZ_PktCnt_LIMIT + 1;
         } else {
                 maxsize = 64+64;
-                if (hs_ep->dir_in) {
+                if (hs_ep->dir_in)
                         maxpkt = S3C_DIEPTSIZ0_PktCnt_LIMIT + 1;
-                } else {
+                else
                         maxpkt = 2;
-                }
         }
 
         /* we made the constant loading easier above by using +1 */
@@ -679,6 +681,14 @@ static void s3c_hsotg_start_req(struct s3c_hsotg *hsotg,
                 __func__, readl(hsotg->regs + epctrl_reg), index,
                 hs_ep->dir_in ? "in" : "out");
 
+        /* If endpoint is stalled, we will restart request later */
+        ctrl = readl(hsotg->regs + epctrl_reg);
+
+        if (ctrl & S3C_DxEPCTL_Stall) {
+                dev_warn(hsotg->dev, "%s: ep%d is stalled\n", __func__, index);
+                return;
+        }
+
         length = ureq->length - ureq->actual;
 
         if (0)
@@ -731,18 +741,6 @@ static void s3c_hsotg_start_req(struct s3c_hsotg *hsotg,
         /* write size / packets */
         writel(epsize, hsotg->regs + epsize_reg);
 
-        ctrl = readl(hsotg->regs + epctrl_reg);
-
-        if (ctrl & S3C_DxEPCTL_Stall) {
-                dev_warn(hsotg->dev, "%s: ep%d is stalled\n", __func__, index);
-
-                /* not sure what we can do here, if it is EP0 then we should
-                 * get this cleared once the endpoint has transmitted the
-                 * STALL packet, otherwise it needs to be cleared by the
-                 * host.
-                 */
-        }
-
         if (using_dma(hsotg)) {
                 unsigned int dma_reg;
 
@@ -783,7 +781,7 @@ static void s3c_hsotg_start_req(struct s3c_hsotg *hsotg,
                        hsotg->regs + S3C_DIEPINT(index));
 
         /* Note, trying to clear the NAK here causes problems with transmit
-         * on the S3C6400 ending up with the TXFIFO becomming full. */
+         * on the S3C6400 ending up with the TXFIFO becoming full. */
 
         /* check ep is enabled */
         if (!(readl(hsotg->regs + epctrl_reg) & S3C_DxEPCTL_EPEna))
@@ -1048,6 +1046,20 @@ static int s3c_hsotg_process_req_status(struct s3c_hsotg *hsotg,
 static int s3c_hsotg_ep_sethalt(struct usb_ep *ep, int value);
 
 /**
+ * get_ep_head - return the first request on the endpoint
+ * @hs_ep: The controller endpoint to get
+ *
+ * Get the first request on the endpoint.
+ */
+static struct s3c_hsotg_req *get_ep_head(struct s3c_hsotg_ep *hs_ep)
+{
+        if (list_empty(&hs_ep->queue))
+                return NULL;
+
+        return list_first_entry(&hs_ep->queue, struct s3c_hsotg_req, queue);
+}
+
+/**
  * s3c_hsotg_process_req_featire - process request {SET,CLEAR}_FEATURE
  * @hsotg: The device state
  * @ctrl: USB control request
@@ -1055,8 +1067,12 @@ static int s3c_hsotg_ep_sethalt(struct usb_ep *ep, int value);
 static int s3c_hsotg_process_req_feature(struct s3c_hsotg *hsotg,
                                          struct usb_ctrlrequest *ctrl)
 {
+        struct s3c_hsotg_ep *ep0 = &hsotg->eps[0];
+        struct s3c_hsotg_req *hs_req;
+        bool restart;
         bool set = (ctrl->bRequest == USB_REQ_SET_FEATURE);
         struct s3c_hsotg_ep *ep;
+        int ret;
 
         dev_dbg(hsotg->dev, "%s: %s_FEATURE\n",
                 __func__, set ? "SET" : "CLEAR");
@@ -1072,6 +1088,36 @@ static int s3c_hsotg_process_req_feature(struct s3c_hsotg *hsotg,
                 switch (le16_to_cpu(ctrl->wValue)) {
                 case USB_ENDPOINT_HALT:
                         s3c_hsotg_ep_sethalt(&ep->ep, set);
+
+                        ret = s3c_hsotg_send_reply(hsotg, ep0, NULL, 0);
+                        if (ret) {
+                                dev_err(hsotg->dev,
+                                        "%s: failed to send reply\n", __func__);
+                                return ret;
+                        }
+
+                        if (!set) {
+                                /*
+                                 * If we have request in progress,
+                                 * then complete it
+                                 */
+                                if (ep->req) {
+                                        hs_req = ep->req;
+                                        ep->req = NULL;
+                                        list_del_init(&hs_req->queue);
+                                        hs_req->req.complete(&ep->ep,
+                                                             &hs_req->req);
+                                }
+
+                                /* If we have pending request, then start it */
+                                restart = !list_empty(&ep->queue);
+                                if (restart) {
+                                        hs_req = get_ep_head(ep);
+                                        s3c_hsotg_start_req(hsotg, ep,
+                                                            hs_req, false);
+                                }
+                        }
+
                         break;
 
                 default:
@@ -1148,14 +1194,6 @@ static void s3c_hsotg_process_control(struct s3c_hsotg *hsotg,
                         dev_dbg(hsotg->dev, "driver->setup() ret %d\n", ret);
         }
 
-        if (ret > 0) {
-                if (!ep0->dir_in) {
-                        /* need to generate zlp in reply or take data */
-                        /* todo - deal with any data we might be sent? */
-                        ret = s3c_hsotg_send_reply(hsotg, ep0, NULL, 0);
-                }
-        }
-
         /* the request is either unhandlable, or is not formatted correctly
          * so respond with a STALL for the status stage to indicate failure.
          */
@@ -1176,10 +1214,10 @@ static void s3c_hsotg_process_control(struct s3c_hsotg *hsotg,
                 writel(ctrl, hsotg->regs + reg);
 
                 dev_dbg(hsotg->dev,
-                        "writen DxEPCTL=0x%08x to %08x (DxEPCTL=0x%08x)\n",
+                        "written DxEPCTL=0x%08x to %08x (DxEPCTL=0x%08x)\n",
                         ctrl, reg, readl(hsotg->regs + reg));
 
-                /* don't belive we need to anything more to get the EP
+                /* don't believe we need to anything more to get the EP
                  * to reply with a STALL packet */
         }
 }
@@ -1247,20 +1285,6 @@ static void s3c_hsotg_enqueue_setup(struct s3c_hsotg *hsotg)
 }
 
 /**
- * get_ep_head - return the first request on the endpoint
- * @hs_ep: The controller endpoint to get
- *
- * Get the first request on the endpoint.
-*/
-static struct s3c_hsotg_req *get_ep_head(struct s3c_hsotg_ep *hs_ep)
-{
-        if (list_empty(&hs_ep->queue))
-                return NULL;
-
-        return list_first_entry(&hs_ep->queue, struct s3c_hsotg_req, queue);
-}
-
-/**
  * s3c_hsotg_complete_request - complete a request given to us
  * @hsotg: The device state.
  * @hs_ep: The endpoint the request was on.
@@ -1416,7 +1440,7 @@ static void s3c_hsotg_rx_data(struct s3c_hsotg *hsotg, int ep_idx, int size)
  * transaction.
  *
  * Note, since we don't write any data to the TxFIFO, then it is
- * currently belived that we do not need to wait for any space in
+ * currently believed that we do not need to wait for any space in
  * the TxFIFO.
  */
 static void s3c_hsotg_send_zlp(struct s3c_hsotg *hsotg,
@@ -1540,7 +1564,7 @@ static u32 s3c_hsotg_read_frameno(struct s3c_hsotg *hsotg)
  * that requires processing, so find out what is in there and do the
  * appropriate read.
  *
- * The RXFIFO is a true FIFO, the packets comming out are still in packet
+ * The RXFIFO is a true FIFO, the packets coming out are still in packet
  * chunks, so if you have x packets received on an endpoint you'll get x
  * FIFO events delivered, each with a packet's worth of data in it.
  *
@@ -1683,6 +1707,37 @@ bad_mps:
         dev_err(hsotg->dev, "ep%d: bad mps of %d\n", ep, mps);
 }
 
+/**
+ * s3c_hsotg_txfifo_flush - flush Tx FIFO
+ * @hsotg: The driver state
+ * @idx: The index for the endpoint (0..15)
+ */
+static void s3c_hsotg_txfifo_flush(struct s3c_hsotg *hsotg, unsigned int idx)
+{
+        int timeout;
+        int val;
+
+        writel(S3C_GRSTCTL_TxFNum(idx) | S3C_GRSTCTL_TxFFlsh,
+                hsotg->regs + S3C_GRSTCTL);
+
+        /* wait until the fifo is flushed */
+        timeout = 100;
+
+        while (1) {
+                val = readl(hsotg->regs + S3C_GRSTCTL);
+
+                if ((val & (S3C_GRSTCTL_TxFFlsh)) == 0)
+                        break;
+
+                if (--timeout == 0) {
+                        dev_err(hsotg->dev,
+                                "%s: timeout flushing fifo (GRSTCTL=%08x)\n",
+                                __func__, val);
+                }
+
+                udelay(1);
+        }
+}
 
 /**
  * s3c_hsotg_trytx - check to see if anything needs transmitting
@@ -1775,10 +1830,12 @@ static void s3c_hsotg_epint(struct s3c_hsotg *hsotg, unsigned int idx,
         u32 epctl_reg = dir_in ? S3C_DIEPCTL(idx) : S3C_DOEPCTL(idx);
         u32 epsiz_reg = dir_in ? S3C_DIEPTSIZ(idx) : S3C_DOEPTSIZ(idx);
         u32 ints;
-        u32 clear = 0;
 
         ints = readl(hsotg->regs + epint_reg);
 
+        /* Clear endpoint interrupts */
+        writel(ints, hsotg->regs + epint_reg);
+
         dev_dbg(hsotg->dev, "%s: ep%d(%s) DxEPINT=0x%08x\n",
                 __func__, idx, dir_in ? "in" : "out", ints);
 
@@ -1801,19 +1858,28 @@ static void s3c_hsotg_epint(struct s3c_hsotg *hsotg, unsigned int idx,
 
                         s3c_hsotg_handle_outdone(hsotg, idx, false);
                 }
-
-                clear |= S3C_DxEPINT_XferCompl;
         }
 
         if (ints & S3C_DxEPINT_EPDisbld) {
                 dev_dbg(hsotg->dev, "%s: EPDisbld\n", __func__);
-                clear |= S3C_DxEPINT_EPDisbld;
+
+                if (dir_in) {
+                        int epctl = readl(hsotg->regs + epctl_reg);
+
+                        s3c_hsotg_txfifo_flush(hsotg, idx);
+
+                        if ((epctl & S3C_DxEPCTL_Stall) &&
+                                (epctl & S3C_DxEPCTL_EPType_Bulk)) {
+                                int dctl = readl(hsotg->regs + S3C_DCTL);
+
+                                dctl |= S3C_DCTL_CGNPInNAK;
+                                writel(dctl, hsotg->regs + S3C_DCTL);
+                        }
+                }
         }
 
-        if (ints & S3C_DxEPINT_AHBErr) {
+        if (ints & S3C_DxEPINT_AHBErr)
                 dev_dbg(hsotg->dev, "%s: AHBErr\n", __func__);
-                clear |= S3C_DxEPINT_AHBErr;
-        }
 
         if (ints & S3C_DxEPINT_Setup) {  /* Setup or Timeout */
                 dev_dbg(hsotg->dev, "%s: Setup/Timeout\n",  __func__);
@@ -1829,14 +1895,10 @@ static void s3c_hsotg_epint(struct s3c_hsotg *hsotg, unsigned int idx,
                         else
                                 s3c_hsotg_handle_outdone(hsotg, 0, true);
                 }
-
-                clear |= S3C_DxEPINT_Setup;
         }
 
-        if (ints & S3C_DxEPINT_Back2BackSetup) {
+        if (ints & S3C_DxEPINT_Back2BackSetup)
                 dev_dbg(hsotg->dev, "%s: B2BSetup/INEPNakEff\n", __func__);
-                clear |= S3C_DxEPINT_Back2BackSetup;
-        }
 
         if (dir_in) {
                 /* not sure if this is important, but we'll clear it anyway
@@ -1844,14 +1906,12 @@ static void s3c_hsotg_epint(struct s3c_hsotg *hsotg, unsigned int idx,
                 if (ints & S3C_DIEPMSK_INTknTXFEmpMsk) {
                         dev_dbg(hsotg->dev, "%s: ep%d: INTknTXFEmpMsk\n",
                                 __func__, idx);
-                        clear |= S3C_DIEPMSK_INTknTXFEmpMsk;
                 }
 
                 /* this probably means something bad is happening */
                 if (ints & S3C_DIEPMSK_INTknEPMisMsk) {
                         dev_warn(hsotg->dev, "%s: ep%d: INTknEP\n",
                                  __func__, idx);
-                        clear |= S3C_DIEPMSK_INTknEPMisMsk;
                 }
 
                 /* FIFO has space or is empty (see GAHBCFG) */
@@ -1860,11 +1920,8 @@ static void s3c_hsotg_epint(struct s3c_hsotg *hsotg, unsigned int idx,
                         dev_dbg(hsotg->dev, "%s: ep%d: TxFIFOEmpty\n",
                                 __func__, idx);
                         s3c_hsotg_trytx(hsotg, hs_ep);
-                        clear |= S3C_DIEPMSK_TxFIFOEmpty;
                 }
         }
-
-        writel(clear, hsotg->regs + epint_reg);
 }
 
 /**
@@ -2056,7 +2113,6 @@ irq_retry:
                 dev_info(hsotg->dev, "OTGInt: %08x\n", otgint);
 
                 writel(otgint, hsotg->regs + S3C_GOTGINT);
-                writel(S3C_GINTSTS_OTGInt, hsotg->regs + S3C_GINTSTS);
         }
 
         if (gintsts & S3C_GINTSTS_DisconnInt) {
@@ -2072,8 +2128,9 @@ irq_retry:
         }
 
         if (gintsts & S3C_GINTSTS_EnumDone) {
-                s3c_hsotg_irq_enumdone(hsotg);
                 writel(S3C_GINTSTS_EnumDone, hsotg->regs + S3C_GINTSTS);
+
+                s3c_hsotg_irq_enumdone(hsotg);
         }
 
         if (gintsts & S3C_GINTSTS_ConIDStsChng) {
@@ -2101,10 +2158,6 @@ irq_retry:
                         if (daint_in & 1)
                                 s3c_hsotg_epint(hsotg, ep, 1);
                 }
-
-                writel(daint, hsotg->regs + S3C_DAINT);
-                writel(gintsts & (S3C_GINTSTS_OEPInt | S3C_GINTSTS_IEPInt),
-                       hsotg->regs + S3C_GINTSTS);
         }
 
         if (gintsts & S3C_GINTSTS_USBRst) {
@@ -2112,6 +2165,8 @@ irq_retry:
                 dev_dbg(hsotg->dev, "GNPTXSTS=%08x\n",
                         readl(hsotg->regs + S3C_GNPTXSTS));
 
+                writel(S3C_GINTSTS_USBRst, hsotg->regs + S3C_GINTSTS);
+
                 kill_all_requests(hsotg, &hsotg->eps[0], -ECONNRESET, true);
 
                 /* it seems after a reset we can end up with a situation
@@ -2123,8 +2178,6 @@ irq_retry:
                 s3c_hsotg_init_fifo(hsotg);
 
                 s3c_hsotg_enqueue_setup(hsotg);
-
-                writel(S3C_GINTSTS_USBRst, hsotg->regs + S3C_GINTSTS);
         }
 
         /* check both FIFOs */
@@ -2138,8 +2191,6 @@ irq_retry:
 
                 s3c_hsotg_disable_gsint(hsotg, S3C_GINTSTS_NPTxFEmp);
                 s3c_hsotg_irq_fifoempty(hsotg, false);
-
-                writel(S3C_GINTSTS_NPTxFEmp, hsotg->regs + S3C_GINTSTS);
         }
 
         if (gintsts & S3C_GINTSTS_PTxFEmp) {
@@ -2149,8 +2200,6 @@ irq_retry:
 
                 s3c_hsotg_disable_gsint(hsotg, S3C_GINTSTS_PTxFEmp);
                 s3c_hsotg_irq_fifoempty(hsotg, true);
-
-                writel(S3C_GINTSTS_PTxFEmp, hsotg->regs + S3C_GINTSTS);
         }
 
         if (gintsts & S3C_GINTSTS_RxFLvl) {
@@ -2159,7 +2208,6 @@ irq_retry:
                  * set. */
 
                 s3c_hsotg_handle_rx(hsotg);
-                writel(S3C_GINTSTS_RxFLvl, hsotg->regs + S3C_GINTSTS);
         }
 
         if (gintsts & S3C_GINTSTS_ModeMis) {
@@ -2188,24 +2236,22 @@ irq_retry:
 
         /* these next two seem to crop-up occasionally causing the core
          * to shutdown the USB transfer, so try clearing them and logging
-         * the occurence. */
+         * the occurrence. */
 
         if (gintsts & S3C_GINTSTS_GOUTNakEff) {
                 dev_info(hsotg->dev, "GOUTNakEff triggered\n");
 
-                s3c_hsotg_dump(hsotg);
-
                 writel(S3C_DCTL_CGOUTNak, hsotg->regs + S3C_DCTL);
-                writel(S3C_GINTSTS_GOUTNakEff, hsotg->regs + S3C_GINTSTS);
+
+                s3c_hsotg_dump(hsotg);
         }
 
         if (gintsts & S3C_GINTSTS_GINNakEff) {
                 dev_info(hsotg->dev, "GINNakEff triggered\n");
 
-                s3c_hsotg_dump(hsotg);
-
                 writel(S3C_DCTL_CGNPInNAK, hsotg->regs + S3C_DCTL);
-                writel(S3C_GINTSTS_GINNakEff, hsotg->regs + S3C_GINTSTS);
+
+                s3c_hsotg_dump(hsotg);
         }
 
         /* if we've had fifo events, we should try and go around the
@@ -2403,11 +2449,6 @@ static int s3c_hsotg_ep_dequeue(struct usb_ep *ep, struct usb_request *req)
 
         dev_info(hs->dev, "ep_dequeue(%p,%p)\n", ep, req);
 
-        if (hs_req == hs_ep->req) {
-                dev_dbg(hs->dev, "%s: already in progress\n", __func__);
-                return -EINPROGRESS;
-        }
-
         spin_lock_irqsave(&hs_ep->lock, flags);
 
         if (!on_list(hs_ep, hs_req)) {
@@ -2429,6 +2470,7 @@ static int s3c_hsotg_ep_sethalt(struct usb_ep *ep, int value)
         unsigned long irqflags;
         u32 epreg;
         u32 epctl;
+        u32 xfertype;
 
         dev_info(hs->dev, "%s(ep %p %s, %d)\n", __func__, ep, ep->name, value);
 
@@ -2439,10 +2481,17 @@ static int s3c_hsotg_ep_sethalt(struct usb_ep *ep, int value)
         epreg = S3C_DIEPCTL(index);
         epctl = readl(hs->regs + epreg);
 
-        if (value)
-                epctl |= S3C_DxEPCTL_Stall;
-        else
+        if (value) {
+                epctl |= S3C_DxEPCTL_Stall + S3C_DxEPCTL_SNAK;
+                if (epctl & S3C_DxEPCTL_EPEna)
+                        epctl |= S3C_DxEPCTL_EPDis;
+        } else {
                 epctl &= ~S3C_DxEPCTL_Stall;
+                xfertype = epctl & S3C_DxEPCTL_EPType_MASK;
+                if (xfertype == S3C_DxEPCTL_EPType_Bulk ||
+                        xfertype == S3C_DxEPCTL_EPType_Intterupt)
+                                epctl |= S3C_DxEPCTL_SetD0PID;
+        }
 
         writel(epctl, hs->regs + epreg);
 
@@ -2451,8 +2500,13 @@ static int s3c_hsotg_ep_sethalt(struct usb_ep *ep, int value)
 
         if (value)
                 epctl |= S3C_DxEPCTL_Stall;
-        else
+        else {
                 epctl &= ~S3C_DxEPCTL_Stall;
+                xfertype = epctl & S3C_DxEPCTL_EPType_MASK;
+                if (xfertype == S3C_DxEPCTL_EPType_Bulk ||
+                        xfertype == S3C_DxEPCTL_EPType_Intterupt)
+                                epctl |= S3C_DxEPCTL_SetD0PID;
+        }
 
         writel(epctl, hs->regs + epreg);
 
@@ -2469,7 +2523,7 @@ static struct usb_ep_ops s3c_hsotg_ep_ops = {
         .queue          = s3c_hsotg_ep_queue,
         .dequeue        = s3c_hsotg_ep_dequeue,
         .set_halt       = s3c_hsotg_ep_sethalt,
-        /* note, don't belive we have any call for the fifo routines */
+        /* note, don't believe we have any call for the fifo routines */
 };
 
 /**
@@ -2491,9 +2545,9 @@ static int s3c_hsotg_corereset(struct s3c_hsotg *hsotg)
         timeout = 1000;
         do {
                 grstctl = readl(hsotg->regs + S3C_GRSTCTL);
-        } while (!(grstctl & S3C_GRSTCTL_CSftRst) && timeout-- > 0);
+        } while ((grstctl & S3C_GRSTCTL_CSftRst) && timeout-- > 0);
 
-        if (!(grstctl & S3C_GRSTCTL_CSftRst)) {
+        if (grstctl & S3C_GRSTCTL_CSftRst) {
                 dev_err(hsotg->dev, "Failed to get CSftRst asserted\n");
                 return -EINVAL;
         }
@@ -2510,20 +2564,18 @@ static int s3c_hsotg_corereset(struct s3c_hsotg *hsotg)
                         return -ETIMEDOUT;
                 }
 
-                if (grstctl & S3C_GRSTCTL_CSftRst)
-                        continue;
-
                 if (!(grstctl & S3C_GRSTCTL_AHBIdle))
                         continue;
 
-                break;          /* reset done */
+                break;          /* reset done */
         }
 
         dev_dbg(hsotg->dev, "reset successful\n");
         return 0;
 }
 
-int usb_gadget_register_driver(struct usb_gadget_driver *driver)
+int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
+                int (*bind)(struct usb_gadget *))
 {
         struct s3c_hsotg *hsotg = our_hsotg;
         int ret;
@@ -2543,7 +2595,7 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver)
                 dev_err(hsotg->dev, "%s: bad speed\n", __func__);
         }
 
-        if (!driver->bind || !driver->setup) {
+        if (!bind || !driver->setup) {
                 dev_err(hsotg->dev, "%s: missing entry points\n", __func__);
                 return -EINVAL;
         }
@@ -2562,7 +2614,7 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver)
                 goto err;
         }
 
-        ret = driver->bind(&hsotg->gadget);
+        ret = bind(&hsotg->gadget);
         if (ret) {
                 dev_err(hsotg->dev, "failed bind %s\n", driver->driver.name);
 
@@ -2587,6 +2639,12 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver)
 
         writel(1 << 18 | S3C_DCFG_DevSpd_HS,  hsotg->regs + S3C_DCFG);
 
+        /* Clear any pending OTG interrupts */
+        writel(0xffffffff, hsotg->regs + S3C_GOTGINT);
+
+        /* Clear any pending interrupts */
+        writel(0xffffffff, hsotg->regs + S3C_GINTSTS);
+
         writel(S3C_GINTSTS_DisconnInt | S3C_GINTSTS_SessReqInt |
                S3C_GINTSTS_ConIDStsChng | S3C_GINTSTS_USBRst |
                S3C_GINTSTS_EnumDone | S3C_GINTSTS_OTGInt |
@@ -2622,9 +2680,9 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver)
 
         writel(0, hsotg->regs + S3C_DAINTMSK);
 
-        dev_info(hsotg->dev, "EP0: DIEPCTL0=0x%08x, DOEPCTL0=0x%08x\n",
-                 readl(hsotg->regs + S3C_DIEPCTL0),
-                 readl(hsotg->regs + S3C_DOEPCTL0));
+        dev_dbg(hsotg->dev, "EP0: DIEPCTL0=0x%08x, DOEPCTL0=0x%08x\n",
+                readl(hsotg->regs + S3C_DIEPCTL0),
+                readl(hsotg->regs + S3C_DOEPCTL0));
 
         /* enable in and out endpoint interrupts */
         s3c_hsotg_en_gsint(hsotg, S3C_GINTSTS_OEPInt | S3C_GINTSTS_IEPInt);
@@ -2643,7 +2701,7 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver)
         udelay(10);  /* see openiboot */
         __bic32(hsotg->regs + S3C_DCTL, S3C_DCTL_PWROnPrgDone);
 
-        dev_info(hsotg->dev, "DCTL=0x%08x\n", readl(hsotg->regs + S3C_DCTL));
+        dev_dbg(hsotg->dev, "DCTL=0x%08x\n", readl(hsotg->regs + S3C_DCTL));
 
         /* S3C_DxEPCTL_USBActEp says RO in manual, but seems to be set by
            writing to the EPCTL register.. */
@@ -2663,9 +2721,9 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver)
 
         s3c_hsotg_enqueue_setup(hsotg);
 
-        dev_info(hsotg->dev, "EP0: DIEPCTL0=0x%08x, DOEPCTL0=0x%08x\n",
-                 readl(hsotg->regs + S3C_DIEPCTL0),
-                 readl(hsotg->regs + S3C_DOEPCTL0));
+        dev_dbg(hsotg->dev, "EP0: DIEPCTL0=0x%08x, DOEPCTL0=0x%08x\n",
+                readl(hsotg->regs + S3C_DIEPCTL0),
+                readl(hsotg->regs + S3C_DOEPCTL0));
 
         /* clear global NAKs */
         writel(S3C_DCTL_CGOUTNak | S3C_DCTL_CGNPInNAK,
@@ -2687,7 +2745,7 @@ err:
         hsotg->gadget.dev.driver = NULL;
         return ret;
 }
-EXPORT_SYMBOL(usb_gadget_register_driver);
+EXPORT_SYMBOL(usb_gadget_probe_driver);
 
 int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
 {
@@ -2863,9 +2921,9 @@ static void s3c_hsotg_init(struct s3c_hsotg *hsotg)
 
         /* setup fifos */
 
-        dev_info(hsotg->dev, "GRXFSIZ=0x%08x, GNPTXFSIZ=0x%08x\n",
-                 readl(hsotg->regs + S3C_GRXFSIZ),
-                 readl(hsotg->regs + S3C_GNPTXFSIZ));
+        dev_dbg(hsotg->dev, "GRXFSIZ=0x%08x, GNPTXFSIZ=0x%08x\n",
+                readl(hsotg->regs + S3C_GRXFSIZ),
+                readl(hsotg->regs + S3C_GNPTXFSIZ));
 
         s3c_hsotg_init_fifo(hsotg);
 
@@ -2887,6 +2945,7 @@ static void s3c_hsotg_init(struct s3c_hsotg *hsotg)
 
 static void s3c_hsotg_dump(struct s3c_hsotg *hsotg)
 {
+#ifdef DEBUG
         struct device *dev = hsotg->dev;
         void __iomem *regs = hsotg->regs;
         u32 val;
@@ -2929,6 +2988,7 @@ static void s3c_hsotg_dump(struct s3c_hsotg *hsotg)
 
         dev_info(dev, "DVBUSDIS=0x%08x, DVBUSPULSE=%08x\n",
                  readl(regs + S3C_DVBUSDIS), readl(regs + S3C_DVBUSPULSE));
+#endif
 }
 
 
@@ -3260,7 +3320,7 @@ static int __devinit s3c_hsotg_probe(struct platform_device *pdev)
         hsotg->clk = clk_get(&pdev->dev, "otg");
         if (IS_ERR(hsotg->clk)) {
                 dev_err(dev, "cannot get otg clock\n");
-                ret = -EINVAL;
+                ret = PTR_ERR(hsotg->clk);
                 goto err_mem;
         }
 
diff --git a/drivers/usb/gadget/s3c-hsudc.c b/drivers/usb/gadget/s3c-hsudc.c
new file mode 100644
index 000000000000..d5e3e1e58626
--- /dev/null
+++ b/drivers/usb/gadget/s3c-hsudc.c
@@ -0,0 +1,1352 @@
+/* linux/drivers/usb/gadget/s3c-hsudc.c
+ *
+ * Copyright (c) 2010 Samsung Electronics Co., Ltd.
+ *              http://www.samsung.com/
+ *
+ * S3C24XX USB 2.0 High-speed USB controller gadget driver
+ *
+ * The S3C24XX USB 2.0 high-speed USB controller supports upto 9 endpoints.
+ * Each endpoint can be configured as either in or out endpoint. Endpoints
+ * can be configured for Bulk or Interrupt transfer mode.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+*/
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/spinlock.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+#include <linux/dma-mapping.h>
+#include <linux/delay.h>
+#include <linux/io.h>
+#include <linux/slab.h>
+#include <linux/clk.h>
+#include <linux/usb/ch9.h>
+#include <linux/usb/gadget.h>
+#include <linux/prefetch.h>
+
+#include <mach/regs-s3c2443-clock.h>
+#include <plat/udc.h>
+
+#define S3C_HSUDC_REG(x)        (x)
+
+/* Non-Indexed Registers */
+#define S3C_IR                          S3C_HSUDC_REG(0x00) /* Index Register */
+#define S3C_EIR                         S3C_HSUDC_REG(0x04) /* EP Intr Status */
+#define S3C_EIR_EP0                     (1<<0)
+#define S3C_EIER                        S3C_HSUDC_REG(0x08) /* EP Intr Enable */
+#define S3C_FAR                         S3C_HSUDC_REG(0x0c) /* Gadget Address */
+#define S3C_FNR                         S3C_HSUDC_REG(0x10) /* Frame Number */
+#define S3C_EDR                         S3C_HSUDC_REG(0x14) /* EP Direction */
+#define S3C_TR                          S3C_HSUDC_REG(0x18) /* Test Register */
+#define S3C_SSR                         S3C_HSUDC_REG(0x1c) /* System Status */
+#define S3C_SSR_DTZIEN_EN               (0xff8f)
+#define S3C_SSR_ERR                     (0xff80)
+#define S3C_SSR_VBUSON                  (1 << 8)
+#define S3C_SSR_HSP                     (1 << 4)
+#define S3C_SSR_SDE                     (1 << 3)
+#define S3C_SSR_RESUME                  (1 << 2)
+#define S3C_SSR_SUSPEND                 (1 << 1)
+#define S3C_SSR_RESET                   (1 << 0)
+#define S3C_SCR                         S3C_HSUDC_REG(0x20) /* System Control */
+#define S3C_SCR_DTZIEN_EN               (1 << 14)
+#define S3C_SCR_RRD_EN                  (1 << 5)
+#define S3C_SCR_SUS_EN                  (1 << 1)
+#define S3C_SCR_RST_EN                  (1 << 0)
+#define S3C_EP0SR                       S3C_HSUDC_REG(0x24) /* EP0 Status */
+#define S3C_EP0SR_EP0_LWO               (1 << 6)
+#define S3C_EP0SR_STALL                 (1 << 4)
+#define S3C_EP0SR_TX_SUCCESS            (1 << 1)
+#define S3C_EP0SR_RX_SUCCESS            (1 << 0)
+#define S3C_EP0CR                       S3C_HSUDC_REG(0x28) /* EP0 Control */
+#define S3C_BR(_x)                      S3C_HSUDC_REG(0x60 + (_x * 4))
+
+/* Indexed Registers */
+#define S3C_ESR                         S3C_HSUDC_REG(0x2c) /* EPn Status */
+#define S3C_ESR_FLUSH                   (1 << 6)
+#define S3C_ESR_STALL                   (1 << 5)
+#define S3C_ESR_LWO                     (1 << 4)
+#define S3C_ESR_PSIF_ONE                (1 << 2)
+#define S3C_ESR_PSIF_TWO                (2 << 2)
+#define S3C_ESR_TX_SUCCESS              (1 << 1)
+#define S3C_ESR_RX_SUCCESS              (1 << 0)
+#define S3C_ECR                         S3C_HSUDC_REG(0x30) /* EPn Control */
+#define S3C_ECR_DUEN                    (1 << 7)
+#define S3C_ECR_FLUSH                   (1 << 6)
+#define S3C_ECR_STALL                   (1 << 1)
+#define S3C_ECR_IEMS                    (1 << 0)
+#define S3C_BRCR                        S3C_HSUDC_REG(0x34) /* Read Count */
+#define S3C_BWCR                        S3C_HSUDC_REG(0x38) /* Write Count */
+#define S3C_MPR                         S3C_HSUDC_REG(0x3c) /* Max Pkt Size */
+
+#define WAIT_FOR_SETUP                  (0)
+#define DATA_STATE_XMIT                 (1)
+#define DATA_STATE_RECV                 (2)
+
+/**
+ * struct s3c_hsudc_ep - Endpoint representation used by driver.
+ * @ep: USB gadget layer representation of device endpoint.
+ * @name: Endpoint name (as required by ep autoconfiguration).
+ * @dev: Reference to the device controller to which this EP belongs.
+ * @desc: Endpoint descriptor obtained from the gadget driver.
+ * @queue: Transfer request queue for the endpoint.
+ * @stopped: Maintains state of endpoint, set if EP is halted.
+ * @bEndpointAddress: EP address (including direction bit).
+ * @fifo: Base address of EP FIFO.
+ */
+struct s3c_hsudc_ep {
+        struct usb_ep ep;
+        char name[20];
+        struct s3c_hsudc *dev;
+        const struct usb_endpoint_descriptor *desc;
+        struct list_head queue;
+        u8 stopped;
+        u8 wedge;
+        u8 bEndpointAddress;
+        void __iomem *fifo;
+};
+
+/**
+ * struct s3c_hsudc_req - Driver encapsulation of USB gadget transfer request.
+ * @req: Reference to USB gadget transfer request.
+ * @queue: Used for inserting this request to the endpoint request queue.
+ */
+struct s3c_hsudc_req {
+        struct usb_request req;
+        struct list_head queue;
+};
+
+/**
+ * struct s3c_hsudc - Driver's abstraction of the device controller.
+ * @gadget: Instance of usb_gadget which is referenced by gadget driver.
+ * @driver: Reference to currenty active gadget driver.
+ * @dev: The device reference used by probe function.
+ * @lock: Lock to synchronize the usage of Endpoints (EP's are indexed).
+ * @regs: Remapped base address of controller's register space.
+ * @mem_rsrc: Device memory resource used for remapping device register space.
+ * irq: IRQ number used by the controller.
+ * uclk: Reference to the controller clock.
+ * ep0state: Current state of EP0.
+ * ep: List of endpoints supported by the controller.
+ */
+struct s3c_hsudc {
+        struct usb_gadget gadget;
+        struct usb_gadget_driver *driver;
+        struct device *dev;
+        struct s3c24xx_hsudc_platdata *pd;
+        spinlock_t lock;
+        void __iomem *regs;
+        struct resource *mem_rsrc;
+        int irq;
+        struct clk *uclk;
+        int ep0state;
+        struct s3c_hsudc_ep ep[];
+};
+
+#define ep_maxpacket(_ep)       ((_ep)->ep.maxpacket)
+#define ep_is_in(_ep)           ((_ep)->bEndpointAddress & USB_DIR_IN)
+#define ep_index(_ep)           ((_ep)->bEndpointAddress & \
+                                        USB_ENDPOINT_NUMBER_MASK)
+
+static struct s3c_hsudc *the_controller;
+static const char driver_name[] = "s3c-udc";
+static const char ep0name[] = "ep0-control";
+
+static inline struct s3c_hsudc_req *our_req(struct usb_request *req)
+{
+        return container_of(req, struct s3c_hsudc_req, req);
+}
+
+static inline struct s3c_hsudc_ep *our_ep(struct usb_ep *ep)
+{
+        return container_of(ep, struct s3c_hsudc_ep, ep);
+}
+
+static inline struct s3c_hsudc *to_hsudc(struct usb_gadget *gadget)
+{
+        return container_of(gadget, struct s3c_hsudc, gadget);
+}
+
+static inline void set_index(struct s3c_hsudc *hsudc, int ep_addr)
+{
+        ep_addr &= USB_ENDPOINT_NUMBER_MASK;
+        writel(ep_addr, hsudc->regs + S3C_IR);
+}
+
+static inline void __orr32(void __iomem *ptr, u32 val)
+{
+        writel(readl(ptr) | val, ptr);
+}
+
+static void s3c_hsudc_init_phy(void)
+{
+        u32 cfg;
+
+        cfg = readl(S3C2443_PWRCFG) | S3C2443_PWRCFG_USBPHY;
+        writel(cfg, S3C2443_PWRCFG);
+
+        cfg = readl(S3C2443_URSTCON);
+        cfg |= (S3C2443_URSTCON_FUNCRST | S3C2443_URSTCON_PHYRST);
+        writel(cfg, S3C2443_URSTCON);
+        mdelay(1);
+
+        cfg = readl(S3C2443_URSTCON);
+        cfg &= ~(S3C2443_URSTCON_FUNCRST | S3C2443_URSTCON_PHYRST);
+        writel(cfg, S3C2443_URSTCON);
+
+        cfg = readl(S3C2443_PHYCTRL);
+        cfg &= ~(S3C2443_PHYCTRL_CLKSEL | S3C2443_PHYCTRL_DSPORT);
+        cfg |= (S3C2443_PHYCTRL_EXTCLK | S3C2443_PHYCTRL_PLLSEL);
+        writel(cfg, S3C2443_PHYCTRL);
+
+        cfg = readl(S3C2443_PHYPWR);
+        cfg &= ~(S3C2443_PHYPWR_FSUSPEND | S3C2443_PHYPWR_PLL_PWRDN |
+                S3C2443_PHYPWR_XO_ON | S3C2443_PHYPWR_PLL_REFCLK |
+                S3C2443_PHYPWR_ANALOG_PD);
+        cfg |= S3C2443_PHYPWR_COMMON_ON;
+        writel(cfg, S3C2443_PHYPWR);
+
+        cfg = readl(S3C2443_UCLKCON);
+        cfg |= (S3C2443_UCLKCON_DETECT_VBUS | S3C2443_UCLKCON_FUNC_CLKEN |
+                S3C2443_UCLKCON_TCLKEN);
+        writel(cfg, S3C2443_UCLKCON);
+}
+
+static void s3c_hsudc_uninit_phy(void)
+{
+        u32 cfg;
+
+        cfg = readl(S3C2443_PWRCFG) & ~S3C2443_PWRCFG_USBPHY;
+        writel(cfg, S3C2443_PWRCFG);
+
+        writel(S3C2443_PHYPWR_FSUSPEND, S3C2443_PHYPWR);
+
+        cfg = readl(S3C2443_UCLKCON) & ~S3C2443_UCLKCON_FUNC_CLKEN;
+        writel(cfg, S3C2443_UCLKCON);
+}
+
+/**
+ * s3c_hsudc_complete_request - Complete a transfer request.
+ * @hsep: Endpoint to which the request belongs.
+ * @hsreq: Transfer request to be completed.
+ * @status: Transfer completion status for the transfer request.
+ */
+static void s3c_hsudc_complete_request(struct s3c_hsudc_ep *hsep,
+                                struct s3c_hsudc_req *hsreq, int status)
+{
+        unsigned int stopped = hsep->stopped;
+        struct s3c_hsudc *hsudc = hsep->dev;
+
+        list_del_init(&hsreq->queue);
+        hsreq->req.status = status;
+
+        if (!ep_index(hsep)) {
+                hsudc->ep0state = WAIT_FOR_SETUP;
+                hsep->bEndpointAddress &= ~USB_DIR_IN;
+        }
+
+        hsep->stopped = 1;
+        spin_unlock(&hsudc->lock);
+        if (hsreq->req.complete != NULL)
+                hsreq->req.complete(&hsep->ep, &hsreq->req);
+        spin_lock(&hsudc->lock);
+        hsep->stopped = stopped;
+}
+
+/**
+ * s3c_hsudc_nuke_ep - Terminate all requests queued for a endpoint.
+ * @hsep: Endpoint for which queued requests have to be terminated.
+ * @status: Transfer completion status for the transfer request.
+ */
+static void s3c_hsudc_nuke_ep(struct s3c_hsudc_ep *hsep, int status)
+{
+        struct s3c_hsudc_req *hsreq;
+
+        while (!list_empty(&hsep->queue)) {
+                hsreq = list_entry(hsep->queue.next,
+                                struct s3c_hsudc_req, queue);
+                s3c_hsudc_complete_request(hsep, hsreq, status);
+        }
+}
+
+/**
+ * s3c_hsudc_stop_activity - Stop activity on all endpoints.
+ * @hsudc: Device controller for which EP activity is to be stopped.
+ * @driver: Reference to the gadget driver which is currently active.
+ *
+ * All the endpoints are stopped and any pending transfer requests if any on
+ * the endpoint are terminated.
+ */
+static void s3c_hsudc_stop_activity(struct s3c_hsudc *hsudc,
+                          struct usb_gadget_driver *driver)
+{
+        struct s3c_hsudc_ep *hsep;
+        int epnum;
+
+        hsudc->gadget.speed = USB_SPEED_UNKNOWN;
+
+        for (epnum = 0; epnum < hsudc->pd->epnum; epnum++) {
+                hsep = &hsudc->ep[epnum];
+                hsep->stopped = 1;
+                s3c_hsudc_nuke_ep(hsep, -ESHUTDOWN);
+        }
+
+        spin_unlock(&hsudc->lock);
+        driver->disconnect(&hsudc->gadget);
+        spin_lock(&hsudc->lock);
+}
+
+/**
+ * s3c_hsudc_read_setup_pkt - Read the received setup packet from EP0 fifo.
+ * @hsudc: Device controller from which setup packet is to be read.
+ * @buf: The buffer into which the setup packet is read.
+ *
+ * The setup packet received in the EP0 fifo is read and stored into a
+ * given buffer address.
+ */
+
+static void s3c_hsudc_read_setup_pkt(struct s3c_hsudc *hsudc, u16 *buf)
+{
+        int count;
+
+        count = readl(hsudc->regs + S3C_BRCR);
+        while (count--)
+                *buf++ = (u16)readl(hsudc->regs + S3C_BR(0));
+
+        writel(S3C_EP0SR_RX_SUCCESS, hsudc->regs + S3C_EP0SR);
+}
+
+/**
+ * s3c_hsudc_write_fifo - Write next chunk of transfer data to EP fifo.
+ * @hsep: Endpoint to which the data is to be written.
+ * @hsreq: Transfer request from which the next chunk of data is written.
+ *
+ * Write the next chunk of data from a transfer request to the endpoint FIFO.
+ * If the transfer request completes, 1 is returned, otherwise 0 is returned.
+ */
+static int s3c_hsudc_write_fifo(struct s3c_hsudc_ep *hsep,
+                                struct s3c_hsudc_req *hsreq)
+{
+        u16 *buf;
+        u32 max = ep_maxpacket(hsep);
+        u32 count, length;
+        bool is_last;
+        void __iomem *fifo = hsep->fifo;
+
+        buf = hsreq->req.buf + hsreq->req.actual;
+        prefetch(buf);
+
+        length = hsreq->req.length - hsreq->req.actual;
+        length = min(length, max);
+        hsreq->req.actual += length;
+
+        writel(length, hsep->dev->regs + S3C_BWCR);
+        for (count = 0; count < length; count += 2)
+                writel(*buf++, fifo);
+
+        if (count != max) {
+                is_last = true;
+        } else {
+                if (hsreq->req.length != hsreq->req.actual || hsreq->req.zero)
+                        is_last = false;
+                else
+                        is_last = true;
+        }
+
+        if (is_last) {
+                s3c_hsudc_complete_request(hsep, hsreq, 0);
+                return 1;
+        }
+
+        return 0;
+}
+
+/**
+ * s3c_hsudc_read_fifo - Read the next chunk of data from EP fifo.
+ * @hsep: Endpoint from which the data is to be read.
+ * @hsreq: Transfer request to which the next chunk of data read is written.
+ *
+ * Read the next chunk of data from the endpoint FIFO and a write it to the
+ * transfer request buffer. If the transfer request completes, 1 is returned,
+ * otherwise 0 is returned.
+ */
+static int s3c_hsudc_read_fifo(struct s3c_hsudc_ep *hsep,
+                                struct s3c_hsudc_req *hsreq)
+{
+        struct s3c_hsudc *hsudc = hsep->dev;
+        u32 csr, offset;
+        u16 *buf, word;
+        u32 buflen, rcnt, rlen;
+        void __iomem *fifo = hsep->fifo;
+        u32 is_short = 0;
+
+        offset = (ep_index(hsep)) ? S3C_ESR : S3C_EP0SR;
+        csr = readl(hsudc->regs + offset);
+        if (!(csr & S3C_ESR_RX_SUCCESS))
+                return -EINVAL;
+
+        buf = hsreq->req.buf + hsreq->req.actual;
+        prefetchw(buf);
+        buflen = hsreq->req.length - hsreq->req.actual;
+
+        rcnt = readl(hsudc->regs + S3C_BRCR);
+        rlen = (csr & S3C_ESR_LWO) ? (rcnt * 2 - 1) : (rcnt * 2);
+
+        hsreq->req.actual += min(rlen, buflen);
+        is_short = (rlen < hsep->ep.maxpacket);
+
+        while (rcnt-- != 0) {
+                word = (u16)readl(fifo);
+                if (buflen) {
+                        *buf++ = word;
+                        buflen--;
+                } else {
+                        hsreq->req.status = -EOVERFLOW;
+                }
+        }
+
+        writel(S3C_ESR_RX_SUCCESS, hsudc->regs + offset);
+
+        if (is_short || hsreq->req.actual == hsreq->req.length) {
+                s3c_hsudc_complete_request(hsep, hsreq, 0);
+                return 1;
+        }
+
+        return 0;
+}
+
+/**
+ * s3c_hsudc_epin_intr - Handle in-endpoint interrupt.
+ * @hsudc - Device controller for which the interrupt is to be handled.
+ * @ep_idx - Endpoint number on which an interrupt is pending.
+ *
+ * Handles interrupt for a in-endpoint. The interrupts that are handled are
+ * stall and data transmit complete interrupt.
+ */
+static void s3c_hsudc_epin_intr(struct s3c_hsudc *hsudc, u32 ep_idx)
+{
+        struct s3c_hsudc_ep *hsep = &hsudc->ep[ep_idx];
+        struct s3c_hsudc_req *hsreq;
+        u32 csr;
+
+        csr = readl((u32)hsudc->regs + S3C_ESR);
+        if (csr & S3C_ESR_STALL) {
+                writel(S3C_ESR_STALL, hsudc->regs + S3C_ESR);
+                return;
+        }
+
+        if (csr & S3C_ESR_TX_SUCCESS) {
+                writel(S3C_ESR_TX_SUCCESS, hsudc->regs + S3C_ESR);
+                if (list_empty(&hsep->queue))
+                        return;
+
+                hsreq = list_entry(hsep->queue.next,
+                                struct s3c_hsudc_req, queue);
+                if ((s3c_hsudc_write_fifo(hsep, hsreq) == 0) &&
+                                (csr & S3C_ESR_PSIF_TWO))
+                        s3c_hsudc_write_fifo(hsep, hsreq);
+        }
+}
+
+/**
+ * s3c_hsudc_epout_intr - Handle out-endpoint interrupt.
+ * @hsudc - Device controller for which the interrupt is to be handled.
+ * @ep_idx - Endpoint number on which an interrupt is pending.
+ *
+ * Handles interrupt for a out-endpoint. The interrupts that are handled are
+ * stall, flush and data ready interrupt.
+ */
+static void s3c_hsudc_epout_intr(struct s3c_hsudc *hsudc, u32 ep_idx)
+{
+        struct s3c_hsudc_ep *hsep = &hsudc->ep[ep_idx];
+        struct s3c_hsudc_req *hsreq;
+        u32 csr;
+
+        csr = readl((u32)hsudc->regs + S3C_ESR);
+        if (csr & S3C_ESR_STALL) {
+                writel(S3C_ESR_STALL, hsudc->regs + S3C_ESR);
+                return;
+        }
+
+        if (csr & S3C_ESR_FLUSH) {
+                __orr32(hsudc->regs + S3C_ECR, S3C_ECR_FLUSH);
+                return;
+        }
+
+        if (csr & S3C_ESR_RX_SUCCESS) {
+                if (list_empty(&hsep->queue))
+                        return;
+
+                hsreq = list_entry(hsep->queue.next,
+                                struct s3c_hsudc_req, queue);
+                if (((s3c_hsudc_read_fifo(hsep, hsreq)) == 0) &&
+                                (csr & S3C_ESR_PSIF_TWO))
+                        s3c_hsudc_read_fifo(hsep, hsreq);
+        }
+}
+
+/** s3c_hsudc_set_halt - Set or clear a endpoint halt.
+ * @_ep: Endpoint on which halt has to be set or cleared.
+ * @value: 1 for setting halt on endpoint, 0 to clear halt.
+ *
+ * Set or clear endpoint halt. If halt is set, the endpoint is stopped.
+ * If halt is cleared, for in-endpoints, if there are any pending
+ * transfer requests, transfers are started.
+ */
+static int s3c_hsudc_set_halt(struct usb_ep *_ep, int value)
+{
+        struct s3c_hsudc_ep *hsep = our_ep(_ep);
+        struct s3c_hsudc *hsudc = hsep->dev;
+        struct s3c_hsudc_req *hsreq;
+        unsigned long irqflags;
+        u32 ecr;
+        u32 offset;
+
+        if (value && ep_is_in(hsep) && !list_empty(&hsep->queue))
+                return -EAGAIN;
+
+        spin_lock_irqsave(&hsudc->lock, irqflags);
+        set_index(hsudc, ep_index(hsep));
+        offset = (ep_index(hsep)) ? S3C_ECR : S3C_EP0CR;
+        ecr = readl(hsudc->regs + offset);
+
+        if (value) {
+                ecr |= S3C_ECR_STALL;
+                if (ep_index(hsep))
+                        ecr |= S3C_ECR_FLUSH;
+                hsep->stopped = 1;
+        } else {
+                ecr &= ~S3C_ECR_STALL;
+                hsep->stopped = hsep->wedge = 0;
+        }
+        writel(ecr, hsudc->regs + offset);
+
+        if (ep_is_in(hsep) && !list_empty(&hsep->queue) && !value) {
+                hsreq = list_entry(hsep->queue.next,
+                        struct s3c_hsudc_req, queue);
+                if (hsreq)
+                        s3c_hsudc_write_fifo(hsep, hsreq);
+        }
+
+        spin_unlock_irqrestore(&hsudc->lock, irqflags);
+        return 0;
+}
+
+/** s3c_hsudc_set_wedge - Sets the halt feature with the clear requests ignored
+ * @_ep: Endpoint on which wedge has to be set.
+ *
+ * Sets the halt feature with the clear requests ignored.
+ */
+static int s3c_hsudc_set_wedge(struct usb_ep *_ep)
+{
+        struct s3c_hsudc_ep *hsep = our_ep(_ep);
+
+        if (!hsep)
+                return -EINVAL;
+
+        hsep->wedge = 1;
+        return usb_ep_set_halt(_ep);
+}
+
+/** s3c_hsudc_handle_reqfeat - Handle set feature or clear feature requests.
+ * @_ep: Device controller on which the set/clear feature needs to be handled.
+ * @ctrl: Control request as received on the endpoint 0.
+ *
+ * Handle set feature or clear feature control requests on the control endpoint.
+ */
+static int s3c_hsudc_handle_reqfeat(struct s3c_hsudc *hsudc,
+                                        struct usb_ctrlrequest *ctrl)
+{
+        struct s3c_hsudc_ep *hsep;
+        bool set = (ctrl->bRequest == USB_REQ_SET_FEATURE);
+        u8 ep_num = ctrl->wIndex & USB_ENDPOINT_NUMBER_MASK;
+
+        if (ctrl->bRequestType == USB_RECIP_ENDPOINT) {
+                hsep = &hsudc->ep[ep_num];
+                switch (le16_to_cpu(ctrl->wValue)) {
+                case USB_ENDPOINT_HALT:
+                        if (set || (!set && !hsep->wedge))
+                                s3c_hsudc_set_halt(&hsep->ep, set);
+                        return 0;
+                }
+        }
+
+        return -ENOENT;
+}
+
+/**
+ * s3c_hsudc_process_req_status - Handle get status control request.
+ * @hsudc: Device controller on which get status request has be handled.
+ * @ctrl: Control request as received on the endpoint 0.
+ *
+ * Handle get status control request received on control endpoint.
+ */
+static void s3c_hsudc_process_req_status(struct s3c_hsudc *hsudc,
+                                        struct usb_ctrlrequest *ctrl)
+{
+        struct s3c_hsudc_ep *hsep0 = &hsudc->ep[0];
+        struct s3c_hsudc_req hsreq;
+        struct s3c_hsudc_ep *hsep;
+        __le16 reply;
+        u8 epnum;
+
+        switch (ctrl->bRequestType & USB_RECIP_MASK) {
+        case USB_RECIP_DEVICE:
+                reply = cpu_to_le16(0);
+                break;
+
+        case USB_RECIP_INTERFACE:
+                reply = cpu_to_le16(0);
+                break;
+
+        case USB_RECIP_ENDPOINT:
+                epnum = le16_to_cpu(ctrl->wIndex) & USB_ENDPOINT_NUMBER_MASK;
+                hsep = &hsudc->ep[epnum];
+                reply = cpu_to_le16(hsep->stopped ? 1 : 0);
+                break;
+        }
+
+        INIT_LIST_HEAD(&hsreq.queue);
+        hsreq.req.length = 2;
+        hsreq.req.buf = &reply;
+        hsreq.req.actual = 0;
+        hsreq.req.complete = NULL;
+        s3c_hsudc_write_fifo(hsep0, &hsreq);
+}
+
+/**
+ * s3c_hsudc_process_setup - Process control request received on endpoint 0.
+ * @hsudc: Device controller on which control request has been received.
+ *
+ * Read the control request received on endpoint 0, decode it and handle
+ * the request.
+ */
+static void s3c_hsudc_process_setup(struct s3c_hsudc *hsudc)
+{
+        struct s3c_hsudc_ep *hsep = &hsudc->ep[0];
+        struct usb_ctrlrequest ctrl = {0};
+        int ret;
+
+        s3c_hsudc_nuke_ep(hsep, -EPROTO);
+        s3c_hsudc_read_setup_pkt(hsudc, (u16 *)&ctrl);
+
+        if (ctrl.bRequestType & USB_DIR_IN) {
+                hsep->bEndpointAddress |= USB_DIR_IN;
+                hsudc->ep0state = DATA_STATE_XMIT;
+        } else {
+                hsep->bEndpointAddress &= ~USB_DIR_IN;
+                hsudc->ep0state = DATA_STATE_RECV;
+        }
+
+        switch (ctrl.bRequest) {
+        case USB_REQ_SET_ADDRESS:
+                if (ctrl.bRequestType != (USB_TYPE_STANDARD | USB_RECIP_DEVICE))
+                        break;
+                hsudc->ep0state = WAIT_FOR_SETUP;
+                return;
+
+        case USB_REQ_GET_STATUS:
+                if ((ctrl.bRequestType & USB_TYPE_MASK) != USB_TYPE_STANDARD)
+                        break;
+                s3c_hsudc_process_req_status(hsudc, &ctrl);
+                return;
+
+        case USB_REQ_SET_FEATURE:
+        case USB_REQ_CLEAR_FEATURE:
+                if ((ctrl.bRequestType & USB_TYPE_MASK) != USB_TYPE_STANDARD)
+                        break;
+                s3c_hsudc_handle_reqfeat(hsudc, &ctrl);
+                hsudc->ep0state = WAIT_FOR_SETUP;
+                return;
+        }
+
+        if (hsudc->driver) {
+                spin_unlock(&hsudc->lock);
+                ret = hsudc->driver->setup(&hsudc->gadget, &ctrl);
+                spin_lock(&hsudc->lock);
+
+                if (ctrl.bRequest == USB_REQ_SET_CONFIGURATION) {
+                        hsep->bEndpointAddress &= ~USB_DIR_IN;
+                        hsudc->ep0state = WAIT_FOR_SETUP;
+                }
+
+                if (ret < 0) {
+                        dev_err(hsudc->dev, "setup failed, returned %d\n",
+                                                ret);
+                        s3c_hsudc_set_halt(&hsep->ep, 1);
+                        hsudc->ep0state = WAIT_FOR_SETUP;
+                        hsep->bEndpointAddress &= ~USB_DIR_IN;
+                }
+        }
+}
+
+/** s3c_hsudc_handle_ep0_intr - Handle endpoint 0 interrupt.
+ * @hsudc: Device controller on which endpoint 0 interrupt has occured.
+ *
+ * Handle endpoint 0 interrupt when it occurs. EP0 interrupt could occur
+ * when a stall handshake is sent to host or data is sent/received on
+ * endpoint 0.
+ */
+static void s3c_hsudc_handle_ep0_intr(struct s3c_hsudc *hsudc)
+{
+        struct s3c_hsudc_ep *hsep = &hsudc->ep[0];
+        struct s3c_hsudc_req *hsreq;
+        u32 csr = readl(hsudc->regs + S3C_EP0SR);
+        u32 ecr;
+
+        if (csr & S3C_EP0SR_STALL) {
+                ecr = readl(hsudc->regs + S3C_EP0CR);
+                ecr &= ~(S3C_ECR_STALL | S3C_ECR_FLUSH);
+                writel(ecr, hsudc->regs + S3C_EP0CR);
+
+                writel(S3C_EP0SR_STALL, hsudc->regs + S3C_EP0SR);
+                hsep->stopped = 0;
+
+                s3c_hsudc_nuke_ep(hsep, -ECONNABORTED);
+                hsudc->ep0state = WAIT_FOR_SETUP;
+                hsep->bEndpointAddress &= ~USB_DIR_IN;
+                return;
+        }
+
+        if (csr & S3C_EP0SR_TX_SUCCESS) {
+                writel(S3C_EP0SR_TX_SUCCESS, hsudc->regs + S3C_EP0SR);
+                if (ep_is_in(hsep)) {
+                        if (list_empty(&hsep->queue))
+                                return;
+
+                        hsreq = list_entry(hsep->queue.next,
+                                        struct s3c_hsudc_req, queue);
+                        s3c_hsudc_write_fifo(hsep, hsreq);
+                }
+        }
+
+        if (csr & S3C_EP0SR_RX_SUCCESS) {
+                if (hsudc->ep0state == WAIT_FOR_SETUP)
+                        s3c_hsudc_process_setup(hsudc);
+                else {
+                        if (!ep_is_in(hsep)) {
+                                if (list_empty(&hsep->queue))
+                                        return;
+                                hsreq = list_entry(hsep->queue.next,
+                                        struct s3c_hsudc_req, queue);
+                                s3c_hsudc_read_fifo(hsep, hsreq);
+                        }
+                }
+        }
+}
+
+/**
+ * s3c_hsudc_ep_enable - Enable a endpoint.
+ * @_ep: The endpoint to be enabled.
+ * @desc: Endpoint descriptor.
+ *
+ * Enables a endpoint when called from the gadget driver. Endpoint stall if
+ * any is cleared, transfer type is configured and endpoint interrupt is
+ * enabled.
+ */
+static int s3c_hsudc_ep_enable(struct usb_ep *_ep,
+                                const struct usb_endpoint_descriptor *desc)
+{
+        struct s3c_hsudc_ep *hsep;
+        struct s3c_hsudc *hsudc;
+        unsigned long flags;
+        u32 ecr = 0;
+
+        hsep = container_of(_ep, struct s3c_hsudc_ep, ep);
+        if (!_ep || !desc || hsep->desc || _ep->name == ep0name
+                || desc->bDescriptorType != USB_DT_ENDPOINT
+                || hsep->bEndpointAddress != desc->bEndpointAddress
+                || ep_maxpacket(hsep) < le16_to_cpu(desc->wMaxPacketSize))
+                return -EINVAL;
+
+        if ((desc->bmAttributes == USB_ENDPOINT_XFER_BULK
+                && le16_to_cpu(desc->wMaxPacketSize) != ep_maxpacket(hsep))
+                || !desc->wMaxPacketSize)
+                return -ERANGE;
+
+        hsudc = hsep->dev;
+        if (!hsudc->driver || hsudc->gadget.speed == USB_SPEED_UNKNOWN)
+                return -ESHUTDOWN;
+
+        spin_lock_irqsave(&hsudc->lock, flags);
+
+        set_index(hsudc, hsep->bEndpointAddress);
+        ecr |= ((usb_endpoint_xfer_int(desc)) ? S3C_ECR_IEMS : S3C_ECR_DUEN);
+        writel(ecr, hsudc->regs + S3C_ECR);
+
+        hsep->stopped = hsep->wedge = 0;
+        hsep->desc = desc;
+        hsep->ep.maxpacket = le16_to_cpu(desc->wMaxPacketSize);
+
+        s3c_hsudc_set_halt(_ep, 0);
+        __set_bit(ep_index(hsep), hsudc->regs + S3C_EIER);
+
+        spin_unlock_irqrestore(&hsudc->lock, flags);
+        return 0;
+}
+
+/**
+ * s3c_hsudc_ep_disable - Disable a endpoint.
+ * @_ep: The endpoint to be disabled.
+ * @desc: Endpoint descriptor.
+ *
+ * Disables a endpoint when called from the gadget driver.
+ */
+static int s3c_hsudc_ep_disable(struct usb_ep *_ep)
+{
+        struct s3c_hsudc_ep *hsep = our_ep(_ep);
+        struct s3c_hsudc *hsudc = hsep->dev;
+        unsigned long flags;
+
+        if (!_ep || !hsep->desc)
+                return -EINVAL;
+
+        spin_lock_irqsave(&hsudc->lock, flags);
+
+        set_index(hsudc, hsep->bEndpointAddress);
+        __clear_bit(ep_index(hsep), hsudc->regs + S3C_EIER);
+
+        s3c_hsudc_nuke_ep(hsep, -ESHUTDOWN);
+
+        hsep->desc = 0;
+        hsep->stopped = 1;
+
+        spin_unlock_irqrestore(&hsudc->lock, flags);
+        return 0;
+}
+
+/**
+ * s3c_hsudc_alloc_request - Allocate a new request.
+ * @_ep: Endpoint for which request is allocated (not used).
+ * @gfp_flags: Flags used for the allocation.
+ *
+ * Allocates a single transfer request structure when called from gadget driver.
+ */
+static struct usb_request *s3c_hsudc_alloc_request(struct usb_ep *_ep,
+                                                gfp_t gfp_flags)
+{
+        struct s3c_hsudc_req *hsreq;
+
+        hsreq = kzalloc(sizeof *hsreq, gfp_flags);
+        if (!hsreq)
+                return 0;
+
+        INIT_LIST_HEAD(&hsreq->queue);
+        return &hsreq->req;
+}
+
+/**
+ * s3c_hsudc_free_request - Deallocate a request.
+ * @ep: Endpoint for which request is deallocated (not used).
+ * @_req: Request to be deallocated.
+ *
+ * Allocates a single transfer request structure when called from gadget driver.
+ */
+static void s3c_hsudc_free_request(struct usb_ep *ep, struct usb_request *_req)
+{
+        struct s3c_hsudc_req *hsreq;
+
+        hsreq = container_of(_req, struct s3c_hsudc_req, req);
+        WARN_ON(!list_empty(&hsreq->queue));
+        kfree(hsreq);
+}
+
+/**
+ * s3c_hsudc_queue - Queue a transfer request for the endpoint.
+ * @_ep: Endpoint for which the request is queued.
+ * @_req: Request to be queued.
+ * @gfp_flags: Not used.
+ *
+ * Start or enqueue a request for a endpoint when called from gadget driver.
+ */
+static int s3c_hsudc_queue(struct usb_ep *_ep, struct usb_request *_req,
+                        gfp_t gfp_flags)
+{
+        struct s3c_hsudc_req *hsreq;
+        struct s3c_hsudc_ep *hsep;
+        struct s3c_hsudc *hsudc;
+        unsigned long flags;
+        u32 offset;
+        u32 csr;
+
+        hsreq = container_of(_req, struct s3c_hsudc_req, req);
+        if ((!_req || !_req->complete || !_req->buf ||
+                !list_empty(&hsreq->queue)))
+                return -EINVAL;
+
+        hsep = container_of(_ep, struct s3c_hsudc_ep, ep);
+        hsudc = hsep->dev;
+        if (!hsudc->driver || hsudc->gadget.speed == USB_SPEED_UNKNOWN)
+                return -ESHUTDOWN;
+
+        spin_lock_irqsave(&hsudc->lock, flags);
+        set_index(hsudc, hsep->bEndpointAddress);
+
+        _req->status = -EINPROGRESS;
+        _req->actual = 0;
+
+        if (!ep_index(hsep) && _req->length == 0) {
+                hsudc->ep0state = WAIT_FOR_SETUP;
+                s3c_hsudc_complete_request(hsep, hsreq, 0);
+                spin_unlock_irqrestore(&hsudc->lock, flags);
+                return 0;
+        }
+
+        if (list_empty(&hsep->queue) && !hsep->stopped) {
+                offset = (ep_index(hsep)) ? S3C_ESR : S3C_EP0SR;
+                if (ep_is_in(hsep)) {
+                        csr = readl((u32)hsudc->regs + offset);
+                        if (!(csr & S3C_ESR_TX_SUCCESS) &&
+                                (s3c_hsudc_write_fifo(hsep, hsreq) == 1))
+                                hsreq = 0;
+                } else {
+                        csr = readl((u32)hsudc->regs + offset);
+                        if ((csr & S3C_ESR_RX_SUCCESS)
+                                   && (s3c_hsudc_read_fifo(hsep, hsreq) == 1))
+                                hsreq = 0;
+                }
+        }
+
+        if (hsreq != 0)
+                list_add_tail(&hsreq->queue, &hsep->queue);
+
+        spin_unlock_irqrestore(&hsudc->lock, flags);
+        return 0;
+}
+
+/**
+ * s3c_hsudc_dequeue - Dequeue a transfer request from an endpoint.
+ * @_ep: Endpoint from which the request is dequeued.
+ * @_req: Request to be dequeued.
+ *
+ * Dequeue a request from a endpoint when called from gadget driver.
+ */
+static int s3c_hsudc_dequeue(struct usb_ep *_ep, struct usb_request *_req)
+{
+        struct s3c_hsudc_ep *hsep = our_ep(_ep);
+        struct s3c_hsudc *hsudc = hsep->dev;
+        struct s3c_hsudc_req *hsreq;
+        unsigned long flags;
+
+        hsep = container_of(_ep, struct s3c_hsudc_ep, ep);
+        if (!_ep || hsep->ep.name == ep0name)
+                return -EINVAL;
+
+        spin_lock_irqsave(&hsudc->lock, flags);
+
+        list_for_each_entry(hsreq, &hsep->queue, queue) {
+                if (&hsreq->req == _req)
+                        break;
+        }
+        if (&hsreq->req != _req) {
+                spin_unlock_irqrestore(&hsudc->lock, flags);
+                return -EINVAL;
+        }
+
+        set_index(hsudc, hsep->bEndpointAddress);
+        s3c_hsudc_complete_request(hsep, hsreq, -ECONNRESET);
+
+        spin_unlock_irqrestore(&hsudc->lock, flags);
+        return 0;
+}
+
+static struct usb_ep_ops s3c_hsudc_ep_ops = {
+        .enable = s3c_hsudc_ep_enable,
+        .disable = s3c_hsudc_ep_disable,
+        .alloc_request = s3c_hsudc_alloc_request,
+        .free_request = s3c_hsudc_free_request,
+        .queue = s3c_hsudc_queue,
+        .dequeue = s3c_hsudc_dequeue,
+        .set_halt = s3c_hsudc_set_halt,
+        .set_wedge = s3c_hsudc_set_wedge,
+};
+
+/**
+ * s3c_hsudc_initep - Initialize a endpoint to default state.
+ * @hsudc - Reference to the device controller.
+ * @hsep - Endpoint to be initialized.
+ * @epnum - Address to be assigned to the endpoint.
+ *
+ * Initialize a endpoint with default configuration.
+ */
+static void s3c_hsudc_initep(struct s3c_hsudc *hsudc,
+                                struct s3c_hsudc_ep *hsep, int epnum)
+{
+        char *dir;
+
+        if ((epnum % 2) == 0) {
+                dir = "out";
+        } else {
+                dir = "in";
+                hsep->bEndpointAddress = USB_DIR_IN;
+        }
+
+        hsep->bEndpointAddress |= epnum;
+        if (epnum)
+                snprintf(hsep->name, sizeof(hsep->name), "ep%d%s", epnum, dir);
+        else
+                snprintf(hsep->name, sizeof(hsep->name), "%s", ep0name);
+
+        INIT_LIST_HEAD(&hsep->queue);
+        INIT_LIST_HEAD(&hsep->ep.ep_list);
+        if (epnum)
+                list_add_tail(&hsep->ep.ep_list, &hsudc->gadget.ep_list);
+
+        hsep->dev = hsudc;
+        hsep->ep.name = hsep->name;
+        hsep->ep.maxpacket = epnum ? 512 : 64;
+        hsep->ep.ops = &s3c_hsudc_ep_ops;
+        hsep->fifo = hsudc->regs + S3C_BR(epnum);
+        hsep->desc = 0;
+        hsep->stopped = 0;
+        hsep->wedge = 0;
+
+        set_index(hsudc, epnum);
+        writel(hsep->ep.maxpacket, hsudc->regs + S3C_MPR);
+}
+
+/**
+ * s3c_hsudc_setup_ep - Configure all endpoints to default state.
+ * @hsudc: Reference to device controller.
+ *
+ * Configures all endpoints to default state.
+ */
+static void s3c_hsudc_setup_ep(struct s3c_hsudc *hsudc)
+{
+        int epnum;
+
+        hsudc->ep0state = WAIT_FOR_SETUP;
+        INIT_LIST_HEAD(&hsudc->gadget.ep_list);
+        for (epnum = 0; epnum < hsudc->pd->epnum; epnum++)
+                s3c_hsudc_initep(hsudc, &hsudc->ep[epnum], epnum);
+}
+
+/**
+ * s3c_hsudc_reconfig - Reconfigure the device controller to default state.
+ * @hsudc: Reference to device controller.
+ *
+ * Reconfigures the device controller registers to a default state.
+ */
+static void s3c_hsudc_reconfig(struct s3c_hsudc *hsudc)
+{
+        writel(0xAA, hsudc->regs + S3C_EDR);
+        writel(1, hsudc->regs + S3C_EIER);
+        writel(0, hsudc->regs + S3C_TR);
+        writel(S3C_SCR_DTZIEN_EN | S3C_SCR_RRD_EN | S3C_SCR_SUS_EN |
+                        S3C_SCR_RST_EN, hsudc->regs + S3C_SCR);
+        writel(0, hsudc->regs + S3C_EP0CR);
+
+        s3c_hsudc_setup_ep(hsudc);
+}
+
+/**
+ * s3c_hsudc_irq - Interrupt handler for device controller.
+ * @irq: Not used.
+ * @_dev: Reference to the device controller.
+ *
+ * Interrupt handler for the device controller. This handler handles controller
+ * interrupts and endpoint interrupts.
+ */
+static irqreturn_t s3c_hsudc_irq(int irq, void *_dev)
+{
+        struct s3c_hsudc *hsudc = _dev;
+        struct s3c_hsudc_ep *hsep;
+        u32 ep_intr;
+        u32 sys_status;
+        u32 ep_idx;
+
+        spin_lock(&hsudc->lock);
+
+        sys_status = readl(hsudc->regs + S3C_SSR);
+        ep_intr = readl(hsudc->regs + S3C_EIR) & 0x3FF;
+
+        if (!ep_intr && !(sys_status & S3C_SSR_DTZIEN_EN)) {
+                spin_unlock(&hsudc->lock);
+                return IRQ_HANDLED;
+        }
+
+        if (sys_status) {
+                if (sys_status & S3C_SSR_VBUSON)
+                        writel(S3C_SSR_VBUSON, hsudc->regs + S3C_SSR);
+
+                if (sys_status & S3C_SSR_ERR)
+                        writel(S3C_SSR_ERR, hsudc->regs + S3C_SSR);
+
+                if (sys_status & S3C_SSR_SDE) {
+                        writel(S3C_SSR_SDE, hsudc->regs + S3C_SSR);
+                        hsudc->gadget.speed = (sys_status & S3C_SSR_HSP) ?
+                                USB_SPEED_HIGH : USB_SPEED_FULL;
+                }
+
+                if (sys_status & S3C_SSR_SUSPEND) {
+                        writel(S3C_SSR_SUSPEND, hsudc->regs + S3C_SSR);
+                        if (hsudc->gadget.speed != USB_SPEED_UNKNOWN
+                                && hsudc->driver && hsudc->driver->suspend)
+                                hsudc->driver->suspend(&hsudc->gadget);
+                }
+
+                if (sys_status & S3C_SSR_RESUME) {
+                        writel(S3C_SSR_RESUME, hsudc->regs + S3C_SSR);
+                        if (hsudc->gadget.speed != USB_SPEED_UNKNOWN
+                                && hsudc->driver && hsudc->driver->resume)
+                                hsudc->driver->resume(&hsudc->gadget);
+                }
+
+                if (sys_status & S3C_SSR_RESET) {
+                        writel(S3C_SSR_RESET, hsudc->regs + S3C_SSR);
+                        for (ep_idx = 0; ep_idx < hsudc->pd->epnum; ep_idx++) {
+                                hsep = &hsudc->ep[ep_idx];
+                                hsep->stopped = 1;
+                                s3c_hsudc_nuke_ep(hsep, -ECONNRESET);
+                        }
+                        s3c_hsudc_reconfig(hsudc);
+                        hsudc->ep0state = WAIT_FOR_SETUP;
+                }
+        }
+
+        if (ep_intr & S3C_EIR_EP0) {
+                writel(S3C_EIR_EP0, hsudc->regs + S3C_EIR);
+                set_index(hsudc, 0);
+                s3c_hsudc_handle_ep0_intr(hsudc);
+        }
+
+        ep_intr >>= 1;
+        ep_idx = 1;
+        while (ep_intr) {
+                if (ep_intr & 1)  {
+                        hsep = &hsudc->ep[ep_idx];
+                        set_index(hsudc, ep_idx);
+                        writel(1 << ep_idx, hsudc->regs + S3C_EIR);
+                        if (ep_is_in(hsep))
+                                s3c_hsudc_epin_intr(hsudc, ep_idx);
+                        else
+                                s3c_hsudc_epout_intr(hsudc, ep_idx);
+                }
+                ep_intr >>= 1;
+                ep_idx++;
+        }
+
+        spin_unlock(&hsudc->lock);
+        return IRQ_HANDLED;
+}
+
+int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
+                int (*bind)(struct usb_gadget *))
+{
+        struct s3c_hsudc *hsudc = the_controller;
+        int ret;
+
+        if (!driver
+                || (driver->speed != USB_SPEED_FULL &&
+                        driver->speed != USB_SPEED_HIGH)
+                || !bind
+                || !driver->unbind || !driver->disconnect || !driver->setup)
+                return -EINVAL;
+
+        if (!hsudc)
+                return -ENODEV;
+
+        if (hsudc->driver)
+                return -EBUSY;
+
+        hsudc->driver = driver;
+        hsudc->gadget.dev.driver = &driver->driver;
+        hsudc->gadget.speed = USB_SPEED_UNKNOWN;
+        ret = device_add(&hsudc->gadget.dev);
+        if (ret) {
+                dev_err(hsudc->dev, "failed to probe gadget device");
+                return ret;
+        }
+
+        ret = bind(&hsudc->gadget);
+        if (ret) {
+                dev_err(hsudc->dev, "%s: bind failed\n", hsudc->gadget.name);
+                device_del(&hsudc->gadget.dev);
+
+                hsudc->driver = NULL;
+                hsudc->gadget.dev.driver = NULL;
+                return ret;
+        }
+
+        enable_irq(hsudc->irq);
+        dev_info(hsudc->dev, "bound driver %s\n", driver->driver.name);
+
+        s3c_hsudc_reconfig(hsudc);
+        s3c_hsudc_init_phy();
+        if (hsudc->pd->gpio_init)
+                hsudc->pd->gpio_init();
+
+        return 0;
+}
+EXPORT_SYMBOL(usb_gadget_probe_driver);
+
+int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
+{
+        struct s3c_hsudc *hsudc = the_controller;
+        unsigned long flags;
+
+        if (!hsudc)
+                return -ENODEV;
+
+        if (!driver || driver != hsudc->driver || !driver->unbind)
+                return -EINVAL;
+
+        spin_lock_irqsave(&hsudc->lock, flags);
+        hsudc->driver = 0;
+        s3c_hsudc_uninit_phy();
+        if (hsudc->pd->gpio_uninit)
+                hsudc->pd->gpio_uninit();
+        s3c_hsudc_stop_activity(hsudc, driver);
+        spin_unlock_irqrestore(&hsudc->lock, flags);
+
+        driver->unbind(&hsudc->gadget);
+        device_del(&hsudc->gadget.dev);
+        disable_irq(hsudc->irq);
+
+        dev_info(hsudc->dev, "unregistered gadget driver '%s'\n",
+                        driver->driver.name);
+        return 0;
+}
+EXPORT_SYMBOL(usb_gadget_unregister_driver);
+
+static inline u32 s3c_hsudc_read_frameno(struct s3c_hsudc *hsudc)
+{
+        return readl(hsudc->regs + S3C_FNR) & 0x3FF;
+}
+
+static int s3c_hsudc_gadget_getframe(struct usb_gadget *gadget)
+{
+        return s3c_hsudc_read_frameno(to_hsudc(gadget));
+}
+
+static struct usb_gadget_ops s3c_hsudc_gadget_ops = {
+        .get_frame      = s3c_hsudc_gadget_getframe,
+};
+
+static int s3c_hsudc_probe(struct platform_device *pdev)
+{
+        struct device *dev = &pdev->dev;
+        struct resource *res;
+        struct s3c_hsudc *hsudc;
+        struct s3c24xx_hsudc_platdata *pd = pdev->dev.platform_data;
+        int ret;
+
+        hsudc = kzalloc(sizeof(struct s3c_hsudc) +
+                        sizeof(struct s3c_hsudc_ep) * pd->epnum,
+                        GFP_KERNEL);
+        if (!hsudc) {
+                dev_err(dev, "cannot allocate memory\n");
+                return -ENOMEM;
+        }
+
+        the_controller = hsudc;
+        platform_set_drvdata(pdev, dev);
+        hsudc->dev = dev;
+        hsudc->pd = pdev->dev.platform_data;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(dev, "unable to obtain driver resource data\n");
+                ret = -ENODEV;
+                goto err_res;
+        }
+
+        hsudc->mem_rsrc = request_mem_region(res->start, resource_size(res),
+                                dev_name(&pdev->dev));
+        if (!hsudc->mem_rsrc) {
+                dev_err(dev, "failed to reserve register area\n");
+                ret = -ENODEV;
+                goto err_res;
+        }
+
+        hsudc->regs = ioremap(res->start, resource_size(res));
+        if (!hsudc->regs) {
+                dev_err(dev, "error mapping device register area\n");
+                ret = -EBUSY;
+                goto err_remap;
+        }
+
+        ret = platform_get_irq(pdev, 0);
+        if (ret < 0) {
+                dev_err(dev, "unable to obtain IRQ number\n");
+                goto err_irq;
+        }
+        hsudc->irq = ret;
+
+        ret = request_irq(hsudc->irq, s3c_hsudc_irq, 0, driver_name, hsudc);
+        if (ret < 0) {
+                dev_err(dev, "irq request failed\n");
+                goto err_irq;
+        }
+
+        spin_lock_init(&hsudc->lock);
+
+        device_initialize(&hsudc->gadget.dev);
+        dev_set_name(&hsudc->gadget.dev, "gadget");
+
+        hsudc->gadget.is_dualspeed = 1;
+        hsudc->gadget.ops = &s3c_hsudc_gadget_ops;
+        hsudc->gadget.name = dev_name(dev);
+        hsudc->gadget.dev.parent = dev;
+        hsudc->gadget.dev.dma_mask = dev->dma_mask;
+        hsudc->gadget.ep0 = &hsudc->ep[0].ep;
+
+        hsudc->gadget.is_otg = 0;
+        hsudc->gadget.is_a_peripheral = 0;
+
+        s3c_hsudc_setup_ep(hsudc);
+
+        hsudc->uclk = clk_get(&pdev->dev, "usb-device");
+        if (IS_ERR(hsudc->uclk)) {
+                dev_err(dev, "failed to find usb-device clock source\n");
+                ret = PTR_ERR(hsudc->uclk);
+                goto err_clk;
+        }
+        clk_enable(hsudc->uclk);
+
+        local_irq_disable();
+
+        disable_irq(hsudc->irq);
+        local_irq_enable();
+        return 0;
+err_clk:
+        free_irq(hsudc->irq, hsudc);
+err_irq:
+        iounmap(hsudc->regs);
+
+err_remap:
+        release_resource(hsudc->mem_rsrc);
+        kfree(hsudc->mem_rsrc);
+
+err_res:
+        kfree(hsudc);
+        return ret;
+}
+
+static struct platform_driver s3c_hsudc_driver = {
+        .driver         = {
+                .owner  = THIS_MODULE,
+                .name   = "s3c-hsudc",
+        },
+        .probe          = s3c_hsudc_probe,
+};
+
+static int __init s3c_hsudc_modinit(void)
+{
+        return platform_driver_register(&s3c_hsudc_driver);
+}
+
+static void __exit s3c_hsudc_modexit(void)
+{
+        platform_driver_unregister(&s3c_hsudc_driver);
+}
+
+module_init(s3c_hsudc_modinit);
+module_exit(s3c_hsudc_modexit);
+
+MODULE_DESCRIPTION("Samsung S3C24XX USB high-speed controller driver");
+MODULE_AUTHOR("Thomas Abraham <thomas.ab@samsung.com>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/usb/gadget/s3c2410_udc.c b/drivers/usb/gadget/s3c2410_udc.c
index ea2b3c7ebee5..100f2635cf0a 100644
--- a/drivers/usb/gadget/s3c2410_udc.c
+++ b/drivers/usb/gadget/s3c2410_udc.c
@@ -36,6 +36,7 @@
 #include <linux/platform_device.h>
 #include <linux/clk.h>
 #include <linux/gpio.h>
+#include <linux/prefetch.h>
 
 #include <linux/debugfs.h>
 #include <linux/seq_file.h>
@@ -902,7 +903,7 @@ static irqreturn_t s3c2410_udc_irq(int dummy, void *_dev)
         int pwr_reg;
         int ep0csr;
         int i;
-        u32 idx;
+        u32 idx, idx2;
         unsigned long flags;
 
         spin_lock_irqsave(&dev->lock, flags);
@@ -1017,6 +1018,20 @@ static irqreturn_t s3c2410_udc_irq(int dummy, void *_dev)
                 }
         }
 
+        /* what else causes this interrupt? a receive! who is it? */
+        if (!usb_status && !usbd_status && !pwr_reg && !ep0csr) {
+                for (i = 1; i < S3C2410_ENDPOINTS; i++) {
+                        idx2 = udc_read(S3C2410_UDC_INDEX_REG);
+                        udc_write(i, S3C2410_UDC_INDEX_REG);
+
+                        if (udc_read(S3C2410_UDC_OUT_CSR1_REG) & 0x1)
+                                s3c2410_udc_handle_ep(&dev->ep[i]);
+
+                        /* restore index */
+                        udc_write(idx2, S3C2410_UDC_INDEX_REG);
+                }
+        }
+
         dprintk(DEBUG_VERBOSE, "irq: %d s3c2410_udc_done.\n", IRQ_USBD);
 
         /* Restore old index */
@@ -1467,7 +1482,9 @@ static int s3c2410_udc_set_pullup(struct s3c2410_udc *udc, int is_on)
 {
         dprintk(DEBUG_NORMAL, "%s()\n", __func__);
 
-        if (udc_info && udc_info->udc_command) {
+        if (udc_info && (udc_info->udc_command ||
+                gpio_is_valid(udc_info->pullup_pin))) {
+
                 if (is_on)
                         s3c2410_udc_enable(udc);
                 else {
@@ -1544,6 +1561,32 @@ static const struct usb_gadget_ops s3c2410_ops = {
         .vbus_draw              = s3c2410_vbus_draw,
 };
 
+static void s3c2410_udc_command(enum s3c2410_udc_cmd_e cmd)
+{
+        if (!udc_info)
+                return;
+
+        if (udc_info->udc_command) {
+                udc_info->udc_command(S3C2410_UDC_P_DISABLE);
+        } else if (gpio_is_valid(udc_info->pullup_pin)) {
+                int value;
+
+                switch (cmd) {
+                case S3C2410_UDC_P_ENABLE:
+                        value = 1;
+                        break;
+                case S3C2410_UDC_P_DISABLE:
+                        value = 0;
+                        break;
+                default:
+                        return;
+                }
+                value ^= udc_info->pullup_pin_inverted;
+
+                gpio_set_value(udc_info->pullup_pin, value);
+        }
+}
+
 /*------------------------- gadget driver handling---------------------------*/
 /*
  * s3c2410_udc_disable
@@ -1565,8 +1608,7 @@ static void s3c2410_udc_disable(struct s3c2410_udc *dev)
         udc_write(0x1F, S3C2410_UDC_EP_INT_REG);
 
         /* Good bye, cruel world */
-        if (udc_info && udc_info->udc_command)
-                udc_info->udc_command(S3C2410_UDC_P_DISABLE);
+        s3c2410_udc_command(S3C2410_UDC_P_DISABLE);
 
         /* Set speed to unknown */
         dev->gadget.speed = USB_SPEED_UNKNOWN;
@@ -1627,20 +1669,19 @@ static void s3c2410_udc_enable(struct s3c2410_udc *dev)
         udc_write(S3C2410_UDC_INT_EP0, S3C2410_UDC_EP_INT_EN_REG);
 
         /* time to say "hello, world" */
-        if (udc_info && udc_info->udc_command)
-                udc_info->udc_command(S3C2410_UDC_P_ENABLE);
+        s3c2410_udc_command(S3C2410_UDC_P_ENABLE);
 }
 
 /*
- *      usb_gadget_register_driver
+ *      usb_gadget_probe_driver
  */
-int usb_gadget_register_driver(struct usb_gadget_driver *driver)
+int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
+                int (*bind)(struct usb_gadget *))
 {
         struct s3c2410_udc *udc = the_controller;
         int             retval;
 
-        dprintk(DEBUG_NORMAL, "usb_gadget_register_driver() '%s'\n",
-                driver->driver.name);
+        dprintk(DEBUG_NORMAL, "%s() '%s'\n", __func__, driver->driver.name);
 
         /* Sanity checks */
         if (!udc)
@@ -1649,10 +1690,9 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver)
         if (udc->driver)
                 return -EBUSY;
 
-        if (!driver->bind || !driver->setup
-                        || driver->speed < USB_SPEED_FULL) {
+        if (!bind || !driver->setup || driver->speed < USB_SPEED_FULL) {
                 printk(KERN_ERR "Invalid driver: bind %p setup %p speed %d\n",
-                        driver->bind, driver->setup, driver->speed);
+                        bind, driver->setup, driver->speed);
                 return -EINVAL;
         }
 #if defined(MODULE)
@@ -1675,7 +1715,7 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver)
         dprintk(DEBUG_NORMAL, "binding gadget driver '%s'\n",
                 driver->driver.name);
 
-        if ((retval = driver->bind (&udc->gadget)) != 0) {
+        if ((retval = bind(&udc->gadget)) != 0) {
                 device_del(&udc->gadget.dev);
                 goto register_error;
         }
@@ -1690,6 +1730,7 @@ register_error:
         udc->gadget.dev.driver = NULL;
         return retval;
 }
+EXPORT_SYMBOL(usb_gadget_probe_driver);
 
 /*
  *      usb_gadget_unregister_driver
@@ -1903,6 +1944,17 @@ static int s3c2410_udc_probe(struct platform_device *pdev)
                 udc->vbus = 1;
         }
 
+        if (udc_info && !udc_info->udc_command &&
+                gpio_is_valid(udc_info->pullup_pin)) {
+
+                retval = gpio_request_one(udc_info->pullup_pin,
+                                udc_info->vbus_pin_inverted ?
+                                GPIOF_OUT_INIT_HIGH : GPIOF_OUT_INIT_LOW,
+                                "udc pullup");
+                if (retval)
+                        goto err_vbus_irq;
+        }
+
         if (s3c2410_udc_debugfs_root) {
                 udc->regs_info = debugfs_create_file("registers", S_IRUGO,
                                 s3c2410_udc_debugfs_root,
@@ -1915,6 +1967,9 @@ static int s3c2410_udc_probe(struct platform_device *pdev)
 
         return 0;
 
+err_vbus_irq:
+        if (udc_info && udc_info->vbus_pin > 0)
+                free_irq(gpio_to_irq(udc_info->vbus_pin), udc);
 err_gpio_claim:
         if (udc_info && udc_info->vbus_pin > 0)
                 gpio_free(udc_info->vbus_pin);
@@ -1942,6 +1997,10 @@ static int s3c2410_udc_remove(struct platform_device *pdev)
 
         debugfs_remove(udc->regs_info);
 
+        if (udc_info && !udc_info->udc_command &&
+                gpio_is_valid(udc_info->pullup_pin))
+                gpio_free(udc_info->pullup_pin);
+
         if (udc_info && udc_info->vbus_pin > 0) {
                 irq = gpio_to_irq(udc_info->vbus_pin);
                 free_irq(irq, udc);
@@ -1973,16 +2032,14 @@ static int s3c2410_udc_remove(struct platform_device *pdev)
 #ifdef CONFIG_PM
 static int s3c2410_udc_suspend(struct platform_device *pdev, pm_message_t message)
 {
-        if (udc_info && udc_info->udc_command)
-                udc_info->udc_command(S3C2410_UDC_P_DISABLE);
+        s3c2410_udc_command(S3C2410_UDC_P_DISABLE);
 
         return 0;
 }
 
 static int s3c2410_udc_resume(struct platform_device *pdev)
 {
-        if (udc_info && udc_info->udc_command)
-                udc_info->udc_command(S3C2410_UDC_P_ENABLE);
+        s3c2410_udc_command(S3C2410_UDC_P_ENABLE);
 
         return 0;
 }
@@ -2049,7 +2106,6 @@ static void __exit udc_exit(void)
 }
 
 EXPORT_SYMBOL(usb_gadget_unregister_driver);
-EXPORT_SYMBOL(usb_gadget_register_driver);
 
 module_init(udc_init);
 module_exit(udc_exit);
diff --git a/drivers/usb/gadget/serial.c b/drivers/usb/gadget/serial.c
index b22eedbc7dc5..1ac57a973aa9 100644
--- a/drivers/usb/gadget/serial.c
+++ b/drivers/usb/gadget/serial.c
@@ -137,7 +137,7 @@ MODULE_PARM_DESC(n_ports, "number of ports to create, default=1");
 
 /*-------------------------------------------------------------------------*/
 
-static int __ref serial_bind_config(struct usb_configuration *c)
+static int __init serial_bind_config(struct usb_configuration *c)
 {
         unsigned i;
         int status = 0;
@@ -155,13 +155,12 @@ static int __ref serial_bind_config(struct usb_configuration *c)
 
 static struct usb_configuration serial_config_driver = {
         /* .label = f(use_acm) */
-        .bind           = serial_bind_config,
         /* .bConfigurationValue = f(use_acm) */
         /* .iConfiguration = DYNAMIC */
         .bmAttributes   = USB_CONFIG_ATT_SELFPOWER,
 };
 
-static int __ref gs_bind(struct usb_composite_dev *cdev)
+static int __init gs_bind(struct usb_composite_dev *cdev)
 {
         int                     gcnum;
         struct usb_gadget       *gadget = cdev->gadget;
@@ -225,7 +224,8 @@ static int __ref gs_bind(struct usb_composite_dev *cdev)
         }
 
         /* register our configuration */
-        status = usb_add_config(cdev, &serial_config_driver);
+        status = usb_add_config(cdev, &serial_config_driver,
+                        serial_bind_config);
         if (status < 0)
                 goto fail;
 
@@ -242,7 +242,6 @@ static struct usb_composite_driver gserial_driver = {
         .name           = "g_serial",
         .dev            = &device_desc,
         .strings        = dev_strings,
-        .bind           = gs_bind,
 };
 
 static int __init init(void)
@@ -271,7 +270,7 @@ static int __init init(void)
         }
         strings_dev[STRING_DESCRIPTION_IDX].s = serial_config_driver.label;
 
-        return usb_composite_register(&gserial_driver);
+        return usb_composite_probe(&gserial_driver, gs_bind);
 }
 module_init(init);
 
diff --git a/drivers/usb/gadget/storage_common.c b/drivers/usb/gadget/storage_common.c
index 484acfb1a7c5..1fa4f705b0b4 100644
--- a/drivers/usb/gadget/storage_common.c
+++ b/drivers/usb/gadget/storage_common.c
@@ -26,7 +26,6 @@
  * be defined (each of type pointer to char):
  *  - fsg_string_manufacturer -- name of the manufacturer
  *  - fsg_string_product      -- name of the product
- *  - fsg_string_serial       -- product's serial
  *  - fsg_string_config       -- name of the configuration
  *  - fsg_string_interface    -- name of the interface
  * The first four are only needed when FSG_DESCRIPTORS_DEVICE_STRINGS
@@ -54,6 +53,8 @@
  */
 
 
+#include <linux/usb/storage.h>
+#include <scsi/scsi.h>
 #include <asm/unaligned.h>
 
 
@@ -153,23 +154,6 @@
 
 /*-------------------------------------------------------------------------*/
 
-/* SCSI device types */
-#define TYPE_DISK       0x00
-#define TYPE_CDROM      0x05
-
-/* USB protocol value = the transport method */
-#define USB_PR_CBI      0x00            /* Control/Bulk/Interrupt */
-#define USB_PR_CB       0x01            /* Control/Bulk w/o interrupt */
-#define USB_PR_BULK     0x50            /* Bulk-only */
-
-/* USB subclass value = the protocol encapsulation */
-#define USB_SC_RBC      0x01            /* Reduced Block Commands (flash) */
-#define USB_SC_8020     0x02            /* SFF-8020i, MMC-2, ATAPI (CD-ROM) */
-#define USB_SC_QIC      0x03            /* QIC-157 (tape) */
-#define USB_SC_UFI      0x04            /* UFI (floppy) */
-#define USB_SC_8070     0x05            /* SFF-8070i (removable) */
-#define USB_SC_SCSI     0x06            /* Transparent SCSI */
-
 /* Bulk-only data structures */
 
 /* Command Block Wrapper */
@@ -221,33 +205,6 @@ struct interrupt_data {
 /* Length of a SCSI Command Data Block */
 #define MAX_COMMAND_SIZE        16
 
-/* SCSI commands that we recognize */
-#define SC_FORMAT_UNIT                  0x04
-#define SC_INQUIRY                      0x12
-#define SC_MODE_SELECT_6                0x15
-#define SC_MODE_SELECT_10               0x55
-#define SC_MODE_SENSE_6                 0x1a
-#define SC_MODE_SENSE_10                0x5a
-#define SC_PREVENT_ALLOW_MEDIUM_REMOVAL 0x1e
-#define SC_READ_6                       0x08
-#define SC_READ_10                      0x28
-#define SC_READ_12                      0xa8
-#define SC_READ_CAPACITY                0x25
-#define SC_READ_FORMAT_CAPACITIES       0x23
-#define SC_READ_HEADER                  0x44
-#define SC_READ_TOC                     0x43
-#define SC_RELEASE                      0x17
-#define SC_REQUEST_SENSE                0x03
-#define SC_RESERVE                      0x16
-#define SC_SEND_DIAGNOSTIC              0x1d
-#define SC_START_STOP_UNIT              0x1b
-#define SC_SYNCHRONIZE_CACHE            0x35
-#define SC_TEST_UNIT_READY              0x00
-#define SC_VERIFY                       0x2f
-#define SC_WRITE_6                      0x0a
-#define SC_WRITE_10                     0x2a
-#define SC_WRITE_12                     0xaa
-
 /* SCSI Sense Key/Additional Sense Code/ASC Qualifier values */
 #define SS_NO_SENSE                             0
 #define SS_COMMUNICATION_FAILURE                0x040800
@@ -552,7 +509,7 @@ static struct usb_string		fsg_strings[] = {
 #ifndef FSG_NO_DEVICE_STRINGS
         {FSG_STRING_MANUFACTURER,       fsg_string_manufacturer},
         {FSG_STRING_PRODUCT,            fsg_string_product},
-        {FSG_STRING_SERIAL,             fsg_string_serial},
+        {FSG_STRING_SERIAL,             ""},
         {FSG_STRING_CONFIG,             fsg_string_config},
 #endif
         {FSG_STRING_INTERFACE,          fsg_string_interface},
@@ -586,7 +543,7 @@ static int fsg_lun_open(struct fsg_lun *curlun, const char *filename)
         ro = curlun->initially_ro;
         if (!ro) {
                 filp = filp_open(filename, O_RDWR | O_LARGEFILE, 0);
-                if (-EROFS == PTR_ERR(filp))
+                if (PTR_ERR(filp) == -EROFS || PTR_ERR(filp) == -EACCES)
                         ro = 1;
         }
         if (ro)
@@ -601,10 +558,7 @@ static int fsg_lun_open(struct fsg_lun *curlun, const char *filename)
 
         if (filp->f_path.dentry)
                 inode = filp->f_path.dentry->d_inode;
-        if (inode && S_ISBLK(inode->i_mode)) {
-                if (bdev_read_only(inode->i_bdev))
-                        ro = 1;
-        } else if (!inode || !S_ISREG(inode->i_mode)) {
+        if (!inode || (!S_ISREG(inode->i_mode) && !S_ISBLK(inode->i_mode))) {
                 LINFO(curlun, "invalid file type: %s\n", filename);
                 goto out;
         }
@@ -754,13 +708,14 @@ static ssize_t fsg_show_file(struct device *dev, struct device_attribute *attr,
 static ssize_t fsg_store_ro(struct device *dev, struct device_attribute *attr,
                             const char *buf, size_t count)
 {
-        ssize_t         rc = count;
+        ssize_t         rc;
         struct fsg_lun  *curlun = fsg_lun_from_dev(dev);
         struct rw_semaphore     *filesem = dev_get_drvdata(dev);
-        unsigned long   ro;
+        unsigned        ro;
 
-        if (strict_strtoul(buf, 2, &ro))
-                return -EINVAL;
+        rc = kstrtouint(buf, 2, &ro);
+        if (rc)
+                return rc;
 
         /*
          * Allow the write-enable status to change only while the
@@ -774,6 +729,7 @@ static ssize_t fsg_store_ro(struct device *dev, struct device_attribute *attr,
                 curlun->ro = ro;
                 curlun->initially_ro = ro;
                 LDBG(curlun, "read-only status set to %d\n", curlun->ro);
+                rc = count;
         }
         up_read(filesem);
         return rc;
@@ -784,10 +740,12 @@ static ssize_t fsg_store_nofua(struct device *dev,
                                const char *buf, size_t count)
 {
         struct fsg_lun  *curlun = fsg_lun_from_dev(dev);
-        unsigned long   nofua;
+        unsigned        nofua;
+        int             ret;
 
-        if (strict_strtoul(buf, 2, &nofua))
-                return -EINVAL;
+        ret = kstrtouint(buf, 2, &nofua);
+        if (ret)
+                return ret;
 
         /* Sync data when switching from async mode to sync */
         if (!nofua && curlun->nofua)
diff --git a/drivers/usb/gadget/u_audio.c b/drivers/usb/gadget/u_audio.c
index 7a86d2c9109c..59ffe1ecf1c9 100644
--- a/drivers/usb/gadget/u_audio.c
+++ b/drivers/usb/gadget/u_audio.c
@@ -255,6 +255,7 @@ static int gaudio_open_snd_dev(struct gaudio *card)
                 ERROR(card, "No such PCM capture device: %s\n", fn_cap);
                 snd->substream = NULL;
                 snd->card = NULL;
+                snd->filp = NULL;
         } else {
                 pcm_file = snd->filp->private_data;
                 snd->substream = pcm_file->substream;
@@ -273,17 +274,17 @@ static int gaudio_close_snd_dev(struct gaudio *gau)
 
         /* Close control device */
         snd = &gau->control;
-        if (!IS_ERR(snd->filp))
+        if (snd->filp)
                 filp_close(snd->filp, current->files);
 
         /* Close PCM playback device and setup substream */
         snd = &gau->playback;
-        if (!IS_ERR(snd->filp))
+        if (snd->filp)
                 filp_close(snd->filp, current->files);
 
         /* Close PCM capture device and setup substream */
         snd = &gau->capture;
-        if (!IS_ERR(snd->filp))
+        if (snd->filp)
                 filp_close(snd->filp, current->files);
 
         return 0;
@@ -304,8 +305,7 @@ int __init gaudio_setup(struct gaudio *card)
         ret = gaudio_open_snd_dev(card);
         if (ret)
                 ERROR(card, "we need at least one control device\n");
-
-        if (!the_card)
+        else if (!the_card)
                 the_card = card;
 
         return ret;
diff --git a/drivers/usb/gadget/u_ether.c b/drivers/usb/gadget/u_ether.c
index 6bb876d65252..2ac1d2147325 100644
--- a/drivers/usb/gadget/u_ether.c
+++ b/drivers/usb/gadget/u_ether.c
@@ -240,6 +240,9 @@ rx_submit(struct eth_dev *dev, struct usb_request *req, gfp_t gfp_flags)
         size += out->maxpacket - 1;
         size -= size % out->maxpacket;
 
+        if (dev->port_usb->is_fixed)
+                size = max_t(size_t, size, dev->port_usb->fixed_out_len);
+
         skb = alloc_skb(size + NET_IP_ALIGN, gfp_flags);
         if (skb == NULL) {
                 DBG(dev, "no rx skb\n");
@@ -578,12 +581,19 @@ static netdev_tx_t eth_start_xmit(struct sk_buff *skb,
         req->context = skb;
         req->complete = tx_complete;
 
+        /* NCM requires no zlp if transfer is dwNtbInMaxSize */
+        if (dev->port_usb->is_fixed &&
+            length == dev->port_usb->fixed_in_len &&
+            (length % in->maxpacket) == 0)
+                req->zero = 0;
+        else
+                req->zero = 1;
+
         /* use zlp framing on tx for strict CDC-Ether conformance,
          * though any robust network rx path ignores extra padding.
          * and some hardware doesn't like to write zlps.
          */
-        req->zero = 1;
-        if (!dev->zlp && (length % in->maxpacket) == 0)
+        if (req->zero && !dev->zlp && (length % in->maxpacket) == 0)
                 length++;
 
         req->length = length;
@@ -797,7 +807,6 @@ int gether_setup(struct usb_gadget *g, u8 ethaddr[ETH_ALEN])
          *  - iff DATA transfer is active, carrier is "on"
          *  - tx queueing enabled if open *and* carrier is "on"
          */
-        netif_stop_queue(net);
         netif_carrier_off(net);
 
         dev->gadget = g;
@@ -830,11 +839,9 @@ void gether_cleanup(void)
                 return;
 
         unregister_netdev(the_dev->net);
+        flush_work_sync(&the_dev->work);
         free_netdev(the_dev->net);
 
-        /* assuming we used keventd, it must quiesce too */
-        flush_scheduled_work();
-
         the_dev = NULL;
 }
 
diff --git a/drivers/usb/gadget/u_ether.h b/drivers/usb/gadget/u_ether.h
index 3c8c0c9f9d72..b56e1e7d423c 100644
--- a/drivers/usb/gadget/u_ether.h
+++ b/drivers/usb/gadget/u_ether.h
@@ -62,6 +62,10 @@ struct gether {
 
         /* hooks for added framing, as needed for RNDIS and EEM. */
         u32                             header_len;
+        /* NCM requires fixed size bundles */
+        bool                            is_fixed;
+        u32                             fixed_out_len;
+        u32                             fixed_in_len;
         struct sk_buff                  *(*wrap)(struct gether *port,
                                                 struct sk_buff *skb);
         int                             (*unwrap)(struct gether *port,
@@ -103,6 +107,7 @@ static inline bool can_support_ecm(struct usb_gadget *gadget)
 /* each configuration may bind one instance of an ethernet link */
 int geth_bind_config(struct usb_configuration *c, u8 ethaddr[ETH_ALEN]);
 int ecm_bind_config(struct usb_configuration *c, u8 ethaddr[ETH_ALEN]);
+int ncm_bind_config(struct usb_configuration *c, u8 ethaddr[ETH_ALEN]);
 int eem_bind_config(struct usb_configuration *c);
 
 #ifdef USB_ETH_RNDIS
diff --git a/drivers/usb/gadget/u_serial.c b/drivers/usb/gadget/u_serial.c
index 01e5354a4c20..40f7716b31fc 100644
--- a/drivers/usb/gadget/u_serial.c
+++ b/drivers/usb/gadget/u_serial.c
@@ -105,11 +105,15 @@ struct gs_port {
         wait_queue_head_t       close_wait;     /* wait for last close */
 
         struct list_head        read_pool;
+        int read_started;
+        int read_allocated;
         struct list_head        read_queue;
         unsigned                n_read;
         struct tasklet_struct   push;
 
         struct list_head        write_pool;
+        int write_started;
+        int write_allocated;
         struct gs_buf           port_write_buf;
         wait_queue_head_t       drain_wait;     /* wait while writes drain */
 
@@ -363,6 +367,9 @@ __acquires(&port->port_lock)
                 struct usb_request      *req;
                 int                     len;
 
+                if (port->write_started >= QUEUE_SIZE)
+                        break;
+
                 req = list_entry(pool->next, struct usb_request, list);
                 len = gs_send_packet(port, req->buf, in->maxpacket);
                 if (len == 0) {
@@ -397,6 +404,8 @@ __acquires(&port->port_lock)
                         break;
                 }
 
+                port->write_started++;
+
                 /* abort immediately after disconnect */
                 if (!port->port_usb)
                         break;
@@ -418,7 +427,6 @@ __acquires(&port->port_lock)
 {
         struct list_head        *pool = &port->read_pool;
         struct usb_ep           *out = port->port_usb->out;
-        unsigned                started = 0;
 
         while (!list_empty(pool)) {
                 struct usb_request      *req;
@@ -430,6 +438,9 @@ __acquires(&port->port_lock)
                 if (!tty)
                         break;
 
+                if (port->read_started >= QUEUE_SIZE)
+                        break;
+
                 req = list_entry(pool->next, struct usb_request, list);
                 list_del(&req->list);
                 req->length = out->maxpacket;
@@ -447,13 +458,13 @@ __acquires(&port->port_lock)
                         list_add(&req->list, pool);
                         break;
                 }
-                started++;
+                port->read_started++;
 
                 /* abort immediately after disconnect */
                 if (!port->port_usb)
                         break;
         }
-        return started;
+        return port->read_started;
 }
 
 /*
@@ -535,6 +546,7 @@ static void gs_rx_push(unsigned long _port)
                 }
 recycle:
                 list_move(&req->list, &port->read_pool);
+                port->read_started--;
         }
 
         /* Push from tty to ldisc; without low_latency set this is handled by
@@ -587,6 +599,7 @@ static void gs_write_complete(struct usb_ep *ep, struct usb_request *req)
 
         spin_lock(&port->port_lock);
         list_add(&req->list, &port->write_pool);
+        port->write_started--;
 
         switch (req->status) {
         default:
@@ -608,7 +621,8 @@ static void gs_write_complete(struct usb_ep *ep, struct usb_request *req)
         spin_unlock(&port->port_lock);
 }
 
-static void gs_free_requests(struct usb_ep *ep, struct list_head *head)
+static void gs_free_requests(struct usb_ep *ep, struct list_head *head,
+                                                         int *allocated)
 {
         struct usb_request      *req;
 
@@ -616,25 +630,31 @@ static void gs_free_requests(struct usb_ep *ep, struct list_head *head)
                 req = list_entry(head->next, struct usb_request, list);
                 list_del(&req->list);
                 gs_free_req(ep, req);
+                if (allocated)
+                        (*allocated)--;
         }
 }
 
 static int gs_alloc_requests(struct usb_ep *ep, struct list_head *head,
-                void (*fn)(struct usb_ep *, struct usb_request *))
+                void (*fn)(struct usb_ep *, struct usb_request *),
+                int *allocated)
 {
         int                     i;
         struct usb_request      *req;
+        int n = allocated ? QUEUE_SIZE - *allocated : QUEUE_SIZE;
 
         /* Pre-allocate up to QUEUE_SIZE transfers, but if we can't
          * do quite that many this time, don't fail ... we just won't
          * be as speedy as we might otherwise be.
          */
-        for (i = 0; i < QUEUE_SIZE; i++) {
+        for (i = 0; i < n; i++) {
                 req = gs_alloc_req(ep, ep->maxpacket, GFP_ATOMIC);
                 if (!req)
                         return list_empty(head) ? -ENOMEM : 0;
                 req->complete = fn;
                 list_add_tail(&req->list, head);
+                if (allocated)
+                        (*allocated)++;
         }
         return 0;
 }
@@ -661,14 +681,15 @@ static int gs_start_io(struct gs_port *port)
          * configurations may use different endpoints with a given port;
          * and high speed vs full speed changes packet sizes too.
          */
-        status = gs_alloc_requests(ep, head, gs_read_complete);
+        status = gs_alloc_requests(ep, head, gs_read_complete,
+                &port->read_allocated);
         if (status)
                 return status;
 
         status = gs_alloc_requests(port->port_usb->in, &port->write_pool,
-                        gs_write_complete);
+                        gs_write_complete, &port->write_allocated);
         if (status) {
-                gs_free_requests(ep, head);
+                gs_free_requests(ep, head, &port->read_allocated);
                 return status;
         }
 
@@ -680,8 +701,9 @@ static int gs_start_io(struct gs_port *port)
         if (started) {
                 tty_wakeup(port->port_tty);
         } else {
-                gs_free_requests(ep, head);
-                gs_free_requests(port->port_usb->in, &port->write_pool);
+                gs_free_requests(ep, head, &port->read_allocated);
+                gs_free_requests(port->port_usb->in, &port->write_pool,
+                        &port->write_allocated);
                 status = -EIO;
         }
 
@@ -1315,8 +1337,12 @@ void gserial_disconnect(struct gserial *gser)
         spin_lock_irqsave(&port->port_lock, flags);
         if (port->open_count == 0 && !port->openclose)
                 gs_buf_free(&port->port_write_buf);
-        gs_free_requests(gser->out, &port->read_pool);
-        gs_free_requests(gser->out, &port->read_queue);
-        gs_free_requests(gser->in, &port->write_pool);
+        gs_free_requests(gser->out, &port->read_pool, NULL);
+        gs_free_requests(gser->out, &port->read_queue, NULL);
+        gs_free_requests(gser->in, &port->write_pool, NULL);
+
+        port->read_allocated = port->read_started =
+                port->write_allocated = port->write_started = 0;
+
         spin_unlock_irqrestore(&port->port_lock, flags);
 }
diff --git a/drivers/usb/gadget/webcam.c b/drivers/usb/gadget/webcam.c
index de1deb7a3c63..a5a0fdb808c7 100644
--- a/drivers/usb/gadget/webcam.c
+++ b/drivers/usb/gadget/webcam.c
@@ -308,7 +308,7 @@ static const struct uvc_descriptor_header * const uvc_hs_streaming_cls[] = {
  * USB configuration
  */
 
-static int __ref
+static int __init
 webcam_config_bind(struct usb_configuration *c)
 {
         return uvc_bind_config(c, uvc_control_cls, uvc_fs_streaming_cls,
@@ -317,7 +317,6 @@ webcam_config_bind(struct usb_configuration *c)
 
 static struct usb_configuration webcam_config_driver = {
         .label                  = webcam_config_label,
-        .bind                   = webcam_config_bind,
         .bConfigurationValue    = 1,
         .iConfiguration         = 0, /* dynamic */
         .bmAttributes           = USB_CONFIG_ATT_SELFPOWER,
@@ -330,7 +329,7 @@ webcam_unbind(struct usb_composite_dev *cdev)
         return 0;
 }
 
-static int __ref
+static int __init
 webcam_bind(struct usb_composite_dev *cdev)
 {
         int ret;
@@ -354,7 +353,8 @@ webcam_bind(struct usb_composite_dev *cdev)
         webcam_config_driver.iConfiguration = ret;
 
         /* Register our configuration. */
-        if ((ret = usb_add_config(cdev, &webcam_config_driver)) < 0)
+        if ((ret = usb_add_config(cdev, &webcam_config_driver,
+                                        webcam_config_bind)) < 0)
                 goto error;
 
         INFO(cdev, "Webcam Video Gadget\n");
@@ -373,14 +373,13 @@ static struct usb_composite_driver webcam_driver = {
         .name           = "g_webcam",
         .dev            = &webcam_device_descriptor,
         .strings        = webcam_device_strings,
-        .bind           = webcam_bind,
         .unbind         = webcam_unbind,
 };
 
 static int __init
 webcam_init(void)
 {
-        return usb_composite_register(&webcam_driver);
+        return usb_composite_probe(&webcam_driver, webcam_bind);
 }
 
 static void __exit
diff --git a/drivers/usb/gadget/zero.c b/drivers/usb/gadget/zero.c
index cf353920bb1c..6d16db9d9d2d 100644
--- a/drivers/usb/gadget/zero.c
+++ b/drivers/usb/gadget/zero.c
@@ -264,7 +264,7 @@ static void zero_resume(struct usb_composite_dev *cdev)
 
 /*-------------------------------------------------------------------------*/
 
-static int __ref zero_bind(struct usb_composite_dev *cdev)
+static int __init zero_bind(struct usb_composite_dev *cdev)
 {
         int                     gcnum;
         struct usb_gadget       *gadget = cdev->gadget;
@@ -340,7 +340,6 @@ static struct usb_composite_driver zero_driver = {
         .name           = "zero",
         .dev            = &device_desc,
         .strings        = dev_strings,
-        .bind           = zero_bind,
         .unbind         = zero_unbind,
         .suspend        = zero_suspend,
         .resume         = zero_resume,
@@ -351,7 +350,7 @@ MODULE_LICENSE("GPL");
 
 static int __init init(void)
 {
-        return usb_composite_register(&zero_driver);
+        return usb_composite_probe(&zero_driver, zero_bind);
 }
 module_init(init);
 
diff --git a/drivers/usb/host/Kconfig b/drivers/usb/host/Kconfig
index 2d926cec0725..ab085f12d570 100644
--- a/drivers/usb/host/Kconfig
+++ b/drivers/usb/host/Kconfig
@@ -91,14 +91,28 @@ config USB_EHCI_TT_NEWSCHED
 
           If unsure, say Y.
 
+config USB_EHCI_HCD_PMC_MSP
+        tristate "EHCI support for on-chip PMC MSP71xx USB controller"
+        depends on USB_EHCI_HCD && MSP_HAS_USB
+        default n
+        select USB_EHCI_BIG_ENDIAN_DESC
+        select USB_EHCI_BIG_ENDIAN_MMIO
+        ---help---
+                Enables support for the onchip USB controller on the PMC_MSP7100 Family SoC's.
+                If unsure, say N.
+
 config USB_EHCI_BIG_ENDIAN_MMIO
         bool
-        depends on USB_EHCI_HCD && (PPC_CELLEB || PPC_PS3 || 440EPX || ARCH_IXP4XX || XPS_USB_HCD_XILINX)
+        depends on USB_EHCI_HCD && (PPC_CELLEB || PPC_PS3 || 440EPX || \
+                                    ARCH_IXP4XX || XPS_USB_HCD_XILINX || \
+                                    PPC_MPC512x || CPU_CAVIUM_OCTEON || \
+                                    PMC_MSP || SPARC_LEON)
         default y
 
 config USB_EHCI_BIG_ENDIAN_DESC
         bool
-        depends on USB_EHCI_HCD && (440EPX || ARCH_IXP4XX || XPS_USB_HCD_XILINX)
+        depends on USB_EHCI_HCD && (440EPX || ARCH_IXP4XX || XPS_USB_HCD_XILINX || \
+                                    PPC_MPC512x || PMC_MSP || SPARC_LEON)
         default y
 
 config XPS_USB_HCD_XILINX
@@ -112,10 +126,14 @@ config XPS_USB_HCD_XILINX
                 support both high speed and full speed devices, or high speed
                 devices only.
 
+config USB_FSL_MPH_DR_OF
+        tristate
+
 config USB_EHCI_FSL
         bool "Support for Freescale on-chip EHCI USB controller"
         depends on USB_EHCI_HCD && FSL_SOC
         select USB_EHCI_ROOT_HUB_TT
+        select USB_FSL_MPH_DR_OF if OF
         ---help---
           Variation of ARC USB block used in some Freescale chips.
 
@@ -126,6 +144,35 @@ config USB_EHCI_MXC
         ---help---
           Variation of ARC USB block used in some Freescale chips.
 
+config USB_EHCI_HCD_OMAP
+        bool "EHCI support for OMAP3 and later chips"
+        depends on USB_EHCI_HCD && ARCH_OMAP
+        default y
+        --- help ---
+          Enables support for the on-chip EHCI controller on
+          OMAP3 and later chips.
+
+config USB_EHCI_MSM
+        bool "Support for MSM on-chip EHCI USB controller"
+        depends on USB_EHCI_HCD && ARCH_MSM
+        select USB_EHCI_ROOT_HUB_TT
+        select USB_MSM_OTG
+        ---help---
+          Enables support for the USB Host controller present on the
+          Qualcomm chipsets. Root Hub has inbuilt TT.
+          This driver depends on OTG driver for PHY initialization,
+          clock management, powering up VBUS, and power management.
+          This driver is not supported on boards like trout which
+          has an external PHY.
+
+config USB_EHCI_TEGRA
+       boolean "NVIDIA Tegra HCD support"
+       depends on USB_EHCI_HCD && ARCH_TEGRA
+       select USB_EHCI_ROOT_HUB_TT
+       help
+         This driver enables support for the internal USB Host Controllers
+         found in NVIDIA Tegra SoCs. The controllers are EHCI compliant.
+
 config USB_EHCI_HCD_PPC_OF
         bool "EHCI support for PPC USB controller on OF platform bus"
         depends on USB_EHCI_HCD && PPC_OF
@@ -134,12 +181,42 @@ config USB_EHCI_HCD_PPC_OF
           Enables support for the USB controller present on the PowerPC
           OpenFirmware platform bus.
 
+config USB_EHCI_SH
+        bool "EHCI support for SuperH USB controller"
+        depends on USB_EHCI_HCD && SUPERH
+        ---help---
+          Enables support for the on-chip EHCI controller on the SuperH.
+          If you use the PCI EHCI controller, this option is not necessary.
+
+config USB_EHCI_S5P
+       boolean "S5P EHCI support"
+       depends on USB_EHCI_HCD && PLAT_S5P
+       help
+         Enable support for the S5P SOC's on-chip EHCI controller.
+
 config USB_W90X900_EHCI
         bool "W90X900(W90P910) EHCI support"
         depends on USB_EHCI_HCD && ARCH_W90X900
         ---help---
                 Enables support for the W90X900 USB controller
 
+config USB_CNS3XXX_EHCI
+        bool "Cavium CNS3XXX EHCI Module"
+        depends on USB_EHCI_HCD && ARCH_CNS3XXX
+        ---help---
+          Enable support for the CNS3XXX SOC's on-chip EHCI controller.
+          It is needed for high-speed (480Mbit/sec) USB 2.0 device
+          support.
+
+config USB_EHCI_ATH79
+        bool "EHCI support for AR7XXX/AR9XXX SoCs"
+        depends on USB_EHCI_HCD && (SOC_AR71XX || SOC_AR724X || SOC_AR913X)
+        select USB_EHCI_ROOT_HUB_TT
+        default y
+        ---help---
+          Enables support for the built-in EHCI controller present
+          on the Atheros AR7XXX/AR9XXX SoCs.
+
 config USB_OXU210HP_HCD
         tristate "OXU210HP HCD support"
         depends on USB
@@ -225,6 +302,14 @@ config USB_OHCI_HCD_OMAP3
           Enables support for the on-chip OHCI controller on
           OMAP3 and later chips.
 
+config USB_OHCI_ATH79
+        bool "USB OHCI support for the Atheros AR71XX/AR7240 SoCs"
+        depends on USB_OHCI_HCD && (SOC_AR71XX || SOC_AR724X)
+        default y
+        help
+          Enables support for the built-in OHCI controller present on the
+          Atheros AR71XX/AR7240 SoCs.
+
 config USB_OHCI_HCD_PPC_SOC
         bool "OHCI support for on-chip PPC USB controller"
         depends on USB_OHCI_HCD && (STB03xxx || PPC_MPC52xx)
@@ -279,6 +364,20 @@ config USB_OHCI_HCD_SSB
 
           If unsure, say N.
 
+config USB_OHCI_SH
+        bool "OHCI support for SuperH USB controller"
+        depends on USB_OHCI_HCD && SUPERH
+        ---help---
+          Enables support for the on-chip OHCI controller on the SuperH.
+          If you use the PCI OHCI controller, this option is not necessary.
+
+config USB_CNS3XXX_OHCI
+        bool "Cavium CNS3XXX OHCI Module"
+        depends on USB_OHCI_HCD && ARCH_CNS3XXX
+        ---help---
+          Enable support for the CNS3XXX SOC's on-chip OHCI controller.
+          It is needed for low-speed USB 1.0 device support.
+
 config USB_OHCI_BIG_ENDIAN_DESC
         bool
         depends on USB_OHCI_HCD
@@ -297,7 +396,7 @@ config USB_OHCI_LITTLE_ENDIAN
 
 config USB_UHCI_HCD
         tristate "UHCI HCD (most Intel and VIA) support"
-        depends on USB && PCI
+        depends on USB && (PCI || SPARC_LEON)
         ---help---
           The Universal Host Controller Interface is a standard by Intel for
           accessing the USB hardware in the PC (which is also called the USB
@@ -306,11 +405,27 @@ config USB_UHCI_HCD
           with Intel PCI chipsets (like intel 430TX, 440FX, 440LX, 440BX,
           i810, i820) conform to this standard. Also all VIA PCI chipsets
           (like VIA VP2, VP3, MVP3, Apollo Pro, Apollo Pro II or Apollo Pro
-          133). If unsure, say Y.
+          133) and LEON/GRLIB SoCs with the GRUSBHC controller.
+          If unsure, say Y.
 
           To compile this driver as a module, choose M here: the
           module will be called uhci-hcd.
 
+config USB_UHCI_SUPPORT_NON_PCI_HC
+        bool
+        depends on USB_UHCI_HCD
+        default y if SPARC_LEON
+
+config USB_UHCI_BIG_ENDIAN_MMIO
+        bool
+        depends on USB_UHCI_SUPPORT_NON_PCI_HC && SPARC_LEON
+        default y
+
+config USB_UHCI_BIG_ENDIAN_DESC
+        bool
+        depends on USB_UHCI_SUPPORT_NON_PCI_HC && SPARC_LEON
+        default y
+
 config USB_FHCI_HCD
         tristate "Freescale QE USB Host Controller support"
         depends on USB && OF_GPIO && QE_GPIO && QUICC_ENGINE
@@ -326,7 +441,7 @@ config FHCI_DEBUG
         depends on USB_FHCI_HCD && DEBUG_FS
         help
           Say "y" to see some FHCI debug information and statistics
-          throught debugfs.
+          through debugfs.
 
 config USB_U132_HCD
         tristate "Elan U132 Adapter Host Controller"
@@ -368,6 +483,16 @@ config USB_SL811_HCD
           To compile this driver as a module, choose M here: the
           module will be called sl811-hcd.
 
+config USB_SL811_HCD_ISO
+        bool "partial ISO support"
+        depends on USB_SL811_HCD
+        help
+          The driver doesn't support iso_frame_desc (yet), but for some simple
+          devices that just queue one ISO frame per URB, then ISO transfers
+          "should" work using the normal urb status fields.
+
+          If unsure, say N.
+
 config USB_SL811_CS
         tristate "CF/PCMCIA support for SL811HS HCD"
         depends on USB_SL811_HCD && PCMCIA
@@ -428,3 +553,28 @@ config USB_IMX21_HCD
          To compile this driver as a module, choose M here: the
          module will be called "imx21-hcd".
 
+config USB_OCTEON_EHCI
+        bool "Octeon on-chip EHCI support"
+        depends on USB && USB_EHCI_HCD && CPU_CAVIUM_OCTEON
+        default n
+        select USB_EHCI_BIG_ENDIAN_MMIO
+        help
+          Enable support for the Octeon II SOC's on-chip EHCI
+          controller.  It is needed for high-speed (480Mbit/sec)
+          USB 2.0 device support.  All CN6XXX based chips with USB are
+          supported.
+
+config USB_OCTEON_OHCI
+        bool "Octeon on-chip OHCI support"
+        depends on USB && USB_OHCI_HCD && CPU_CAVIUM_OCTEON
+        default USB_OCTEON_EHCI
+        select USB_OHCI_BIG_ENDIAN_MMIO
+        select USB_OHCI_LITTLE_ENDIAN
+        help
+          Enable support for the Octeon II SOC's on-chip OHCI
+          controller.  It is needed for low-speed USB 1.0 device
+          support.  All CN6XXX based chips with USB are supported.
+
+config USB_OCTEON2_COMMON
+        bool
+        default y if USB_OCTEON_EHCI || USB_OCTEON_OHCI
diff --git a/drivers/usb/host/Makefile b/drivers/usb/host/Makefile
index b6315aa47f7a..624a362f2fee 100644
--- a/drivers/usb/host/Makefile
+++ b/drivers/usb/host/Makefile
@@ -2,17 +2,17 @@
 # Makefile for USB Host Controller Drivers
 #
 
-ifeq ($(CONFIG_USB_DEBUG),y)
-        EXTRA_CFLAGS            += -DDEBUG
-endif
-
-isp1760-objs := isp1760-hcd.o isp1760-if.o
-fhci-objs := fhci-hcd.o fhci-hub.o fhci-q.o fhci-mem.o \
-             fhci-tds.o fhci-sched.o
-ifeq ($(CONFIG_FHCI_DEBUG),y)
-fhci-objs += fhci-dbg.o
-endif
-xhci-hcd-objs := xhci.o xhci-mem.o xhci-pci.o xhci-ring.o xhci-hub.o xhci-dbg.o
+ccflags-$(CONFIG_USB_DEBUG) := -DDEBUG
+
+isp1760-y := isp1760-hcd.o isp1760-if.o
+
+fhci-y := fhci-hcd.o fhci-hub.o fhci-q.o
+fhci-y += fhci-mem.o fhci-tds.o fhci-sched.o
+
+fhci-$(CONFIG_FHCI_DEBUG) += fhci-dbg.o
+
+xhci-hcd-y := xhci.o xhci-mem.o xhci-pci.o
+xhci-hcd-y += xhci-ring.o xhci-hub.o xhci-dbg.o
 
 obj-$(CONFIG_USB_WHCI_HCD)      += whci/
 
@@ -33,4 +33,5 @@ obj-$(CONFIG_USB_R8A66597_HCD)	+= r8a66597-hcd.o
 obj-$(CONFIG_USB_ISP1760_HCD)   += isp1760.o
 obj-$(CONFIG_USB_HWA_HCD)       += hwa-hc.o
 obj-$(CONFIG_USB_IMX21_HCD)     += imx21-hcd.o
-
+obj-$(CONFIG_USB_FSL_MPH_DR_OF) += fsl-mph-dr-of.o
+obj-$(CONFIG_USB_OCTEON2_COMMON) += octeon2-common.o
diff --git a/drivers/usb/host/ehci-ath79.c b/drivers/usb/host/ehci-ath79.c
new file mode 100644
index 000000000000..aa248c2f2c60
--- /dev/null
+++ b/drivers/usb/host/ehci-ath79.c
@@ -0,0 +1,204 @@
+/*
+ *  Bus Glue for Atheros AR7XXX/AR9XXX built-in EHCI controller.
+ *
+ *  Copyright (C) 2008-2011 Gabor Juhos <juhosg@openwrt.org>
+ *  Copyright (C) 2008 Imre Kaloz <kaloz@openwrt.org>
+ *
+ *  Parts of this file are based on Atheros' 2.6.15 BSP
+ *      Copyright (C) 2007 Atheros Communications, Inc.
+ *
+ *  This program is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 as published
+ *  by the Free Software Foundation.
+ */
+
+#include <linux/platform_device.h>
+
+enum {
+        EHCI_ATH79_IP_V1 = 0,
+        EHCI_ATH79_IP_V2,
+};
+
+static const struct platform_device_id ehci_ath79_id_table[] = {
+        {
+                .name           = "ar71xx-ehci",
+                .driver_data    = EHCI_ATH79_IP_V1,
+        },
+        {
+                .name           = "ar724x-ehci",
+                .driver_data    = EHCI_ATH79_IP_V2,
+        },
+        {
+                .name           = "ar913x-ehci",
+                .driver_data    = EHCI_ATH79_IP_V2,
+        },
+        {
+                /* terminating entry */
+        },
+};
+
+MODULE_DEVICE_TABLE(platform, ehci_ath79_id_table);
+
+static int ehci_ath79_init(struct usb_hcd *hcd)
+{
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        struct platform_device *pdev = to_platform_device(hcd->self.controller);
+        const struct platform_device_id *id;
+        int ret;
+
+        id = platform_get_device_id(pdev);
+        if (!id) {
+                dev_err(hcd->self.controller, "missing device id\n");
+                return -EINVAL;
+        }
+
+        switch (id->driver_data) {
+        case EHCI_ATH79_IP_V1:
+                ehci->has_synopsys_hc_bug = 1;
+
+                ehci->caps = hcd->regs;
+                ehci->regs = hcd->regs +
+                        HC_LENGTH(ehci,
+                                  ehci_readl(ehci, &ehci->caps->hc_capbase));
+                break;
+
+        case EHCI_ATH79_IP_V2:
+                hcd->has_tt = 1;
+
+                ehci->caps = hcd->regs + 0x100;
+                ehci->regs = hcd->regs + 0x100 +
+                        HC_LENGTH(ehci,
+                                  ehci_readl(ehci, &ehci->caps->hc_capbase));
+                break;
+
+        default:
+                BUG();
+        }
+
+        dbg_hcs_params(ehci, "reset");
+        dbg_hcc_params(ehci, "reset");
+        ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
+        ehci->sbrn = 0x20;
+
+        ehci_reset(ehci);
+
+        ret = ehci_init(hcd);
+        if (ret)
+                return ret;
+
+        ehci_port_power(ehci, 0);
+
+        return 0;
+}
+
+static const struct hc_driver ehci_ath79_hc_driver = {
+        .description            = hcd_name,
+        .product_desc           = "Atheros built-in EHCI controller",
+        .hcd_priv_size          = sizeof(struct ehci_hcd),
+        .irq                    = ehci_irq,
+        .flags                  = HCD_MEMORY | HCD_USB2,
+
+        .reset                  = ehci_ath79_init,
+        .start                  = ehci_run,
+        .stop                   = ehci_stop,
+        .shutdown               = ehci_shutdown,
+
+        .urb_enqueue            = ehci_urb_enqueue,
+        .urb_dequeue            = ehci_urb_dequeue,
+        .endpoint_disable       = ehci_endpoint_disable,
+        .endpoint_reset         = ehci_endpoint_reset,
+
+        .get_frame_number       = ehci_get_frame,
+
+        .hub_status_data        = ehci_hub_status_data,
+        .hub_control            = ehci_hub_control,
+
+        .relinquish_port        = ehci_relinquish_port,
+        .port_handed_over       = ehci_port_handed_over,
+
+        .clear_tt_buffer_complete = ehci_clear_tt_buffer_complete,
+};
+
+static int ehci_ath79_probe(struct platform_device *pdev)
+{
+        struct usb_hcd *hcd;
+        struct resource *res;
+        int irq;
+        int ret;
+
+        if (usb_disabled())
+                return -ENODEV;
+
+        res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+        if (!res) {
+                dev_dbg(&pdev->dev, "no IRQ specified\n");
+                return -ENODEV;
+        }
+        irq = res->start;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_dbg(&pdev->dev, "no base address specified\n");
+                return -ENODEV;
+        }
+
+        hcd = usb_create_hcd(&ehci_ath79_hc_driver, &pdev->dev,
+                             dev_name(&pdev->dev));
+        if (!hcd)
+                return -ENOMEM;
+
+        hcd->rsrc_start = res->start;
+        hcd->rsrc_len   = res->end - res->start + 1;
+
+        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
+                dev_dbg(&pdev->dev, "controller already in use\n");
+                ret = -EBUSY;
+                goto err_put_hcd;
+        }
+
+        hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
+        if (!hcd->regs) {
+                dev_dbg(&pdev->dev, "error mapping memory\n");
+                ret = -EFAULT;
+                goto err_release_region;
+        }
+
+        ret = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
+        if (ret)
+                goto err_iounmap;
+
+        return 0;
+
+err_iounmap:
+        iounmap(hcd->regs);
+
+err_release_region:
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+err_put_hcd:
+        usb_put_hcd(hcd);
+        return ret;
+}
+
+static int ehci_ath79_remove(struct platform_device *pdev)
+{
+        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+
+        usb_remove_hcd(hcd);
+        iounmap(hcd->regs);
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+        usb_put_hcd(hcd);
+
+        return 0;
+}
+
+static struct platform_driver ehci_ath79_driver = {
+        .probe          = ehci_ath79_probe,
+        .remove         = ehci_ath79_remove,
+        .id_table       = ehci_ath79_id_table,
+        .driver = {
+                .owner  = THIS_MODULE,
+                .name   = "ath79-ehci",
+        }
+};
+
+MODULE_ALIAS(PLATFORM_MODULE_PREFIX "ath79-ehci");
diff --git a/drivers/usb/host/ehci-atmel.c b/drivers/usb/host/ehci-atmel.c
index 51bd0edf544f..a5a3ef1f0096 100644
--- a/drivers/usb/host/ehci-atmel.c
+++ b/drivers/usb/host/ehci-atmel.c
@@ -56,7 +56,7 @@ static int ehci_atmel_setup(struct usb_hcd *hcd)
         /* registers start at offset 0x0 */
         ehci->caps = hcd->regs;
         ehci->regs = hcd->regs +
-                HC_LENGTH(ehci_readl(ehci, &ehci->caps->hc_capbase));
+                HC_LENGTH(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
         dbg_hcs_params(ehci, "reset");
         dbg_hcc_params(ehci, "reset");
 
@@ -99,6 +99,7 @@ static const struct hc_driver ehci_atmel_hc_driver = {
         .urb_enqueue            = ehci_urb_enqueue,
         .urb_dequeue            = ehci_urb_dequeue,
         .endpoint_disable       = ehci_endpoint_disable,
+        .endpoint_reset         = ehci_endpoint_reset,
 
         /* scheduling support */
         .get_frame_number       = ehci_get_frame,
@@ -110,9 +111,11 @@ static const struct hc_driver ehci_atmel_hc_driver = {
         .bus_resume             = ehci_bus_resume,
         .relinquish_port        = ehci_relinquish_port,
         .port_handed_over       = ehci_port_handed_over,
+
+        .clear_tt_buffer_complete       = ehci_clear_tt_buffer_complete,
 };
 
-static int __init ehci_atmel_drv_probe(struct platform_device *pdev)
+static int __devinit ehci_atmel_drv_probe(struct platform_device *pdev)
 {
         struct usb_hcd *hcd;
         const struct hc_driver *driver = &ehci_atmel_hc_driver;
@@ -204,7 +207,7 @@ fail_create_hcd:
         return retval;
 }
 
-static int __exit ehci_atmel_drv_remove(struct platform_device *pdev)
+static int __devexit ehci_atmel_drv_remove(struct platform_device *pdev)
 {
         struct usb_hcd *hcd = platform_get_drvdata(pdev);
 
@@ -224,7 +227,7 @@ static int __exit ehci_atmel_drv_remove(struct platform_device *pdev)
 
 static struct platform_driver ehci_atmel_driver = {
         .probe          = ehci_atmel_drv_probe,
-        .remove         = __exit_p(ehci_atmel_drv_remove),
+        .remove         = __devexit_p(ehci_atmel_drv_remove),
         .shutdown       = usb_hcd_platform_shutdown,
         .driver.name    = "atmel-ehci",
 };
diff --git a/drivers/usb/host/ehci-au1xxx.c b/drivers/usb/host/ehci-au1xxx.c
index 2baf8a849086..42ae57409908 100644
--- a/drivers/usb/host/ehci-au1xxx.c
+++ b/drivers/usb/host/ehci-au1xxx.c
@@ -175,7 +175,8 @@ static int ehci_hcd_au1xxx_drv_probe(struct platform_device *pdev)
 
         ehci = hcd_to_ehci(hcd);
         ehci->caps = hcd->regs;
-        ehci->regs = hcd->regs + HC_LENGTH(readl(&ehci->caps->hc_capbase));
+        ehci->regs = hcd->regs +
+                HC_LENGTH(ehci, readl(&ehci->caps->hc_capbase));
         /* cache this readonly data; minimize chip reads */
         ehci->hcs_params = readl(&ehci->caps->hcs_params);
 
@@ -215,10 +216,7 @@ static int ehci_hcd_au1xxx_drv_suspend(struct device *dev)
         struct usb_hcd *hcd = dev_get_drvdata(dev);
         struct ehci_hcd *ehci = hcd_to_ehci(hcd);
         unsigned long flags;
-        int rc;
-
-        return 0;
-        rc = 0;
+        int rc = 0;
 
         if (time_before(jiffies, ehci->next_statechange))
                 msleep(10);
@@ -227,19 +225,19 @@ static int ehci_hcd_au1xxx_drv_suspend(struct device *dev)
          * mark HW unaccessible.  The PM and USB cores make sure that
          * the root hub is either suspended or stopped.
          */
-        spin_lock_irqsave(&ehci->lock, flags);
         ehci_prepare_ports_for_controller_suspend(ehci, device_may_wakeup(dev));
+        spin_lock_irqsave(&ehci->lock, flags);
         ehci_writel(ehci, 0, &ehci->regs->intr_enable);
         (void)ehci_readl(ehci, &ehci->regs->intr_enable);
 
         clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
-
-        au1xxx_stop_ehc();
         spin_unlock_irqrestore(&ehci->lock, flags);
 
         // could save FLADJ in case of Vaux power loss
         // ... we'd only use it to handle clock skew
 
+        au1xxx_stop_ehc();
+
         return rc;
 }
 
diff --git a/drivers/usb/host/ehci-cns3xxx.c b/drivers/usb/host/ehci-cns3xxx.c
new file mode 100644
index 000000000000..d41745c6f0c4
--- /dev/null
+++ b/drivers/usb/host/ehci-cns3xxx.c
@@ -0,0 +1,171 @@
+/*
+ * Copyright 2008 Cavium Networks
+ *
+ * This file is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License, Version 2, as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/platform_device.h>
+#include <linux/atomic.h>
+#include <mach/cns3xxx.h>
+#include <mach/pm.h>
+
+static int cns3xxx_ehci_init(struct usb_hcd *hcd)
+{
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        int retval;
+
+        /*
+         * EHCI and OHCI share the same clock and power,
+         * resetting twice would cause the 1st controller been reset.
+         * Therefore only do power up  at the first up device, and
+         * power down at the last down device.
+         *
+         * Set USB AHB INCR length to 16
+         */
+        if (atomic_inc_return(&usb_pwr_ref) == 1) {
+                cns3xxx_pwr_power_up(1 << PM_PLL_HM_PD_CTRL_REG_OFFSET_PLL_USB);
+                cns3xxx_pwr_clk_en(1 << PM_CLK_GATE_REG_OFFSET_USB_HOST);
+                cns3xxx_pwr_soft_rst(1 << PM_SOFT_RST_REG_OFFST_USB_HOST);
+                __raw_writel((__raw_readl(MISC_CHIP_CONFIG_REG) | (0X2 << 24)),
+                        MISC_CHIP_CONFIG_REG);
+        }
+
+        ehci->caps = hcd->regs;
+        ehci->regs = hcd->regs
+                + HC_LENGTH(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
+        ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
+
+        hcd->has_tt = 0;
+        ehci_reset(ehci);
+
+        retval = ehci_init(hcd);
+        if (retval)
+                return retval;
+
+        ehci_port_power(ehci, 0);
+
+        return retval;
+}
+
+static const struct hc_driver cns3xxx_ehci_hc_driver = {
+        .description            = hcd_name,
+        .product_desc           = "CNS3XXX EHCI Host Controller",
+        .hcd_priv_size          = sizeof(struct ehci_hcd),
+        .irq                    = ehci_irq,
+        .flags                  = HCD_MEMORY | HCD_USB2,
+        .reset                  = cns3xxx_ehci_init,
+        .start                  = ehci_run,
+        .stop                   = ehci_stop,
+        .shutdown               = ehci_shutdown,
+        .urb_enqueue            = ehci_urb_enqueue,
+        .urb_dequeue            = ehci_urb_dequeue,
+        .endpoint_disable       = ehci_endpoint_disable,
+        .endpoint_reset         = ehci_endpoint_reset,
+        .get_frame_number       = ehci_get_frame,
+        .hub_status_data        = ehci_hub_status_data,
+        .hub_control            = ehci_hub_control,
+#ifdef CONFIG_PM
+        .bus_suspend            = ehci_bus_suspend,
+        .bus_resume             = ehci_bus_resume,
+#endif
+        .relinquish_port        = ehci_relinquish_port,
+        .port_handed_over       = ehci_port_handed_over,
+
+        .clear_tt_buffer_complete       = ehci_clear_tt_buffer_complete,
+};
+
+static int cns3xxx_ehci_probe(struct platform_device *pdev)
+{
+        struct device *dev = &pdev->dev;
+        struct usb_hcd *hcd;
+        const struct hc_driver *driver = &cns3xxx_ehci_hc_driver;
+        struct resource *res;
+        int irq;
+        int retval;
+
+        if (usb_disabled())
+                return -ENODEV;
+
+        res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+        if (!res) {
+                dev_err(dev, "Found HC with no IRQ.\n");
+                return -ENODEV;
+        }
+        irq = res->start;
+
+        hcd = usb_create_hcd(driver, &pdev->dev, dev_name(&pdev->dev));
+        if (!hcd)
+                return -ENOMEM;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(dev, "Found HC with no register addr.\n");
+                retval = -ENODEV;
+                goto err1;
+        }
+
+        hcd->rsrc_start = res->start;
+        hcd->rsrc_len = res->end - res->start + 1;
+
+        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len,
+                                driver->description)) {
+                dev_dbg(dev, "controller already in use\n");
+                retval = -EBUSY;
+                goto err1;
+        }
+
+        hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
+        if (hcd->regs == NULL) {
+                dev_dbg(dev, "error mapping memory\n");
+                retval = -EFAULT;
+                goto err2;
+        }
+
+        retval = usb_add_hcd(hcd, irq, IRQF_SHARED);
+        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;
+}
+
+static int cns3xxx_ehci_remove(struct platform_device *pdev)
+{
+        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+
+        usb_remove_hcd(hcd);
+        iounmap(hcd->regs);
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+
+        /*
+         * EHCI and OHCI share the same clock and power,
+         * resetting twice would cause the 1st controller been reset.
+         * Therefore only do power up  at the first up device, and
+         * power down at the last down device.
+         */
+        if (atomic_dec_return(&usb_pwr_ref) == 0)
+                cns3xxx_pwr_clk_dis(1 << PM_CLK_GATE_REG_OFFSET_USB_HOST);
+
+        usb_put_hcd(hcd);
+
+        platform_set_drvdata(pdev, NULL);
+
+        return 0;
+}
+
+MODULE_ALIAS("platform:cns3xxx-ehci");
+
+static struct platform_driver cns3xxx_ehci_driver = {
+        .probe = cns3xxx_ehci_probe,
+        .remove = cns3xxx_ehci_remove,
+        .driver = {
+                .name = "cns3xxx-ehci",
+        },
+};
diff --git a/drivers/usb/host/ehci-dbg.c b/drivers/usb/host/ehci-dbg.c
index 76b7fd2d838a..40a844c1dbb4 100644
--- a/drivers/usb/host/ehci-dbg.c
+++ b/drivers/usb/host/ehci-dbg.c
@@ -28,11 +28,9 @@
         dev_warn (ehci_to_hcd(ehci)->self.controller , fmt , ## args )
 
 #ifdef VERBOSE_DEBUG
-#       define vdbg dbg
 #       define ehci_vdbg ehci_dbg
 #else
-#       define vdbg(fmt,args...) do { } while (0)
-#       define ehci_vdbg(ehci, fmt, args...) do { } while (0)
+        static inline void ehci_vdbg(struct ehci_hcd *ehci, ...) {}
 #endif
 
 #ifdef  DEBUG
@@ -369,18 +367,21 @@ static const struct file_operations debug_async_fops = {
         .open           = debug_async_open,
         .read           = debug_output,
         .release        = debug_close,
+        .llseek         = default_llseek,
 };
 static const struct file_operations debug_periodic_fops = {
         .owner          = THIS_MODULE,
         .open           = debug_periodic_open,
         .read           = debug_output,
         .release        = debug_close,
+        .llseek         = default_llseek,
 };
 static const struct file_operations debug_registers_fops = {
         .owner          = THIS_MODULE,
         .open           = debug_registers_open,
         .read           = debug_output,
         .release        = debug_close,
+        .llseek         = default_llseek,
 };
 static const struct file_operations debug_lpm_fops = {
         .owner          = THIS_MODULE,
@@ -388,6 +389,7 @@ static const struct file_operations debug_lpm_fops = {
         .read           = debug_lpm_read,
         .write          = debug_lpm_write,
         .release        = debug_lpm_close,
+        .llseek         = noop_llseek,
 };
 
 static struct dentry *ehci_debug_root;
@@ -724,7 +726,7 @@ static ssize_t fill_registers_buffer(struct debug_buffer *buf)
         }
 
         /* Capability Registers */
-        i = HC_VERSION(ehci_readl(ehci, &ehci->caps->hc_capbase));
+        i = HC_VERSION(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
         temp = scnprintf (next, size,
                 "bus %s, device %s\n"
                 "%s\n"
@@ -875,7 +877,7 @@ static int fill_buffer(struct debug_buffer *buf)
         int ret = 0;
 
         if (!buf->output_buf)
-                buf->output_buf = (char *)vmalloc(buf->alloc_size);
+                buf->output_buf = vmalloc(buf->alloc_size);
 
         if (!buf->output_buf) {
                 ret = -ENOMEM;
@@ -1063,7 +1065,7 @@ static inline void create_debug_files (struct ehci_hcd *ehci)
                                                     &debug_registers_fops))
                 goto file_error;
 
-        if (!debugfs_create_file("lpm", S_IRUGO|S_IWUGO, ehci->debug_dir, bus,
+        if (!debugfs_create_file("lpm", S_IRUGO|S_IWUSR, ehci->debug_dir, bus,
                                                     &debug_lpm_fops))
                 goto file_error;
 
diff --git a/drivers/usb/host/ehci-fsl.c b/drivers/usb/host/ehci-fsl.c
index a416421abfa2..f380bf97e5af 100644
--- a/drivers/usb/host/ehci-fsl.c
+++ b/drivers/usb/host/ehci-fsl.c
@@ -52,7 +52,6 @@ static int usb_hcd_fsl_probe(const struct hc_driver *driver,
         struct resource *res;
         int irq;
         int retval;
-        unsigned int temp;
 
         pr_debug("initializing FSL-SOC USB Controller\n");
 
@@ -116,17 +115,52 @@ static int usb_hcd_fsl_probe(const struct hc_driver *driver,
                 goto err3;
         }
 
-        /* Enable USB controller */
-        temp = in_be32(hcd->regs + 0x500);
-        out_be32(hcd->regs + 0x500, temp | 0x4);
+        pdata->regs = hcd->regs;
 
-        /* Set to Host mode */
-        temp = in_le32(hcd->regs + 0x1a8);
-        out_le32(hcd->regs + 0x1a8, temp | 0x3);
+        if (pdata->power_budget)
+                hcd->power_budget = pdata->power_budget;
+
+        /*
+         * do platform specific init: check the clock, grab/config pins, etc.
+         */
+        if (pdata->init && pdata->init(pdev)) {
+                retval = -ENODEV;
+                goto err3;
+        }
+
+        /* Enable USB controller, 83xx or 8536 */
+        if (pdata->have_sysif_regs)
+                setbits32(hcd->regs + FSL_SOC_USB_CTRL, 0x4);
+
+        /* Don't need to set host mode here. It will be done by tdi_reset() */
 
         retval = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
         if (retval != 0)
                 goto err4;
+
+#ifdef CONFIG_USB_OTG
+        if (pdata->operating_mode == FSL_USB2_DR_OTG) {
+                struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+
+                ehci->transceiver = otg_get_transceiver();
+                dev_dbg(&pdev->dev, "hcd=0x%p  ehci=0x%p, transceiver=0x%p\n",
+                        hcd, ehci, ehci->transceiver);
+
+                if (ehci->transceiver) {
+                        retval = otg_set_host(ehci->transceiver,
+                                              &ehci_to_hcd(ehci)->self);
+                        if (retval) {
+                                if (ehci->transceiver)
+                                        put_device(ehci->transceiver->dev);
+                                goto err4;
+                        }
+                } else {
+                        dev_err(&pdev->dev, "can't find transceiver\n");
+                        retval = -ENODEV;
+                        goto err4;
+                }
+        }
+#endif
         return retval;
 
       err4:
@@ -137,6 +171,8 @@ static int usb_hcd_fsl_probe(const struct hc_driver *driver,
         usb_put_hcd(hcd);
       err1:
         dev_err(&pdev->dev, "init %s fail, %d\n", dev_name(&pdev->dev), retval);
+        if (pdata->exit)
+                pdata->exit(pdev);
         return retval;
 }
 
@@ -154,17 +190,36 @@ static int usb_hcd_fsl_probe(const struct hc_driver *driver,
 static void usb_hcd_fsl_remove(struct usb_hcd *hcd,
                                struct platform_device *pdev)
 {
+        struct fsl_usb2_platform_data *pdata = pdev->dev.platform_data;
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+
+        if (ehci->transceiver) {
+                otg_set_host(ehci->transceiver, NULL);
+                put_device(ehci->transceiver->dev);
+        }
+
         usb_remove_hcd(hcd);
+
+        /*
+         * do platform specific un-initialization:
+         * release iomux pins, disable clock, etc.
+         */
+        if (pdata->exit)
+                pdata->exit(pdev);
         iounmap(hcd->regs);
         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
         usb_put_hcd(hcd);
 }
 
-static void mpc83xx_setup_phy(struct ehci_hcd *ehci,
-                              enum fsl_usb2_phy_modes phy_mode,
-                              unsigned int port_offset)
+static void ehci_fsl_setup_phy(struct ehci_hcd *ehci,
+                               enum fsl_usb2_phy_modes phy_mode,
+                               unsigned int port_offset)
 {
-        u32 portsc = 0;
+        u32 portsc;
+
+        portsc = ehci_readl(ehci, &ehci->regs->port_status[port_offset]);
+        portsc &= ~(PORT_PTS_MSK | PORT_PTS_PTW);
+
         switch (phy_mode) {
         case FSL_USB2_PHY_ULPI:
                 portsc |= PORT_PTS_ULPI;
@@ -184,20 +239,21 @@ static void mpc83xx_setup_phy(struct ehci_hcd *ehci,
         ehci_writel(ehci, portsc, &ehci->regs->port_status[port_offset]);
 }
 
-static void mpc83xx_usb_setup(struct usb_hcd *hcd)
+static void ehci_fsl_usb_setup(struct ehci_hcd *ehci)
 {
-        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        struct usb_hcd *hcd = ehci_to_hcd(ehci);
         struct fsl_usb2_platform_data *pdata;
         void __iomem *non_ehci = hcd->regs;
         u32 temp;
 
-        pdata =
-            (struct fsl_usb2_platform_data *)hcd->self.controller->
-            platform_data;
+        pdata = hcd->self.controller->platform_data;
+
         /* Enable PHY interface in the control reg. */
-        temp = in_be32(non_ehci + FSL_SOC_USB_CTRL);
-        out_be32(non_ehci + FSL_SOC_USB_CTRL, temp | 0x00000004);
-        out_be32(non_ehci + FSL_SOC_USB_SNOOP1, 0x0000001b);
+        if (pdata->have_sysif_regs) {
+                temp = in_be32(non_ehci + FSL_SOC_USB_CTRL);
+                out_be32(non_ehci + FSL_SOC_USB_CTRL, temp | 0x00000004);
+                out_be32(non_ehci + FSL_SOC_USB_SNOOP1, 0x0000001b);
+        }
 
 #if defined(CONFIG_PPC32) && !defined(CONFIG_NOT_COHERENT_CACHE)
         /*
@@ -214,7 +270,7 @@ static void mpc83xx_usb_setup(struct usb_hcd *hcd)
 
         if ((pdata->operating_mode == FSL_USB2_DR_HOST) ||
                         (pdata->operating_mode == FSL_USB2_DR_OTG))
-                mpc83xx_setup_phy(ehci, pdata->phy_mode, 0);
+                ehci_fsl_setup_phy(ehci, pdata->phy_mode, 0);
 
         if (pdata->operating_mode == FSL_USB2_MPH_HOST) {
                 unsigned int chip, rev, svr;
@@ -228,27 +284,27 @@ static void mpc83xx_usb_setup(struct usb_hcd *hcd)
                         ehci->has_fsl_port_bug = 1;
 
                 if (pdata->port_enables & FSL_USB2_PORT0_ENABLED)
-                        mpc83xx_setup_phy(ehci, pdata->phy_mode, 0);
+                        ehci_fsl_setup_phy(ehci, pdata->phy_mode, 0);
                 if (pdata->port_enables & FSL_USB2_PORT1_ENABLED)
-                        mpc83xx_setup_phy(ehci, pdata->phy_mode, 1);
+                        ehci_fsl_setup_phy(ehci, pdata->phy_mode, 1);
         }
 
-        /* put controller in host mode. */
-        ehci_writel(ehci, 0x00000003, non_ehci + FSL_SOC_USB_USBMODE);
+        if (pdata->have_sysif_regs) {
 #ifdef CONFIG_PPC_85xx
-        out_be32(non_ehci + FSL_SOC_USB_PRICTRL, 0x00000008);
-        out_be32(non_ehci + FSL_SOC_USB_AGECNTTHRSH, 0x00000080);
+                out_be32(non_ehci + FSL_SOC_USB_PRICTRL, 0x00000008);
+                out_be32(non_ehci + FSL_SOC_USB_AGECNTTHRSH, 0x00000080);
 #else
-        out_be32(non_ehci + FSL_SOC_USB_PRICTRL, 0x0000000c);
-        out_be32(non_ehci + FSL_SOC_USB_AGECNTTHRSH, 0x00000040);
+                out_be32(non_ehci + FSL_SOC_USB_PRICTRL, 0x0000000c);
+                out_be32(non_ehci + FSL_SOC_USB_AGECNTTHRSH, 0x00000040);
 #endif
-        out_be32(non_ehci + FSL_SOC_USB_SICTRL, 0x00000001);
+                out_be32(non_ehci + FSL_SOC_USB_SICTRL, 0x00000001);
+        }
 }
 
 /* called after powerup, by probe or system-pm "wakeup" */
 static int ehci_fsl_reinit(struct ehci_hcd *ehci)
 {
-        mpc83xx_usb_setup(ehci_to_hcd(ehci));
+        ehci_fsl_usb_setup(ehci);
         ehci_port_power(ehci, 0);
 
         return 0;
@@ -259,17 +315,24 @@ static int ehci_fsl_setup(struct usb_hcd *hcd)
 {
         struct ehci_hcd *ehci = hcd_to_ehci(hcd);
         int retval;
+        struct fsl_usb2_platform_data *pdata;
+
+        pdata = hcd->self.controller->platform_data;
+        ehci->big_endian_desc = pdata->big_endian_desc;
+        ehci->big_endian_mmio = pdata->big_endian_mmio;
 
         /* EHCI registers start at offset 0x100 */
         ehci->caps = hcd->regs + 0x100;
         ehci->regs = hcd->regs + 0x100 +
-            HC_LENGTH(ehci_readl(ehci, &ehci->caps->hc_capbase));
+                HC_LENGTH(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
         dbg_hcs_params(ehci, "reset");
         dbg_hcc_params(ehci, "reset");
 
         /* cache this readonly data; minimize chip reads */
         ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
 
+        hcd->has_tt = 1;
+
         retval = ehci_halt(ehci);
         if (retval)
                 return retval;
@@ -279,8 +342,6 @@ static int ehci_fsl_setup(struct usb_hcd *hcd)
         if (retval)
                 return retval;
 
-        hcd->has_tt = 1;
-
         ehci->sbrn = 0x20;
 
         ehci_reset(ehci);
@@ -300,6 +361,149 @@ struct ehci_fsl {
 
 #ifdef CONFIG_PM
 
+#ifdef CONFIG_PPC_MPC512x
+static int ehci_fsl_mpc512x_drv_suspend(struct device *dev)
+{
+        struct usb_hcd *hcd = dev_get_drvdata(dev);
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        struct fsl_usb2_platform_data *pdata = dev->platform_data;
+        u32 tmp;
+
+#ifdef DEBUG
+        u32 mode = ehci_readl(ehci, hcd->regs + FSL_SOC_USB_USBMODE);
+        mode &= USBMODE_CM_MASK;
+        tmp = ehci_readl(ehci, hcd->regs + 0x140);      /* usbcmd */
+
+        dev_dbg(dev, "suspend=%d already_suspended=%d "
+                "mode=%d  usbcmd %08x\n", pdata->suspended,
+                pdata->already_suspended, mode, tmp);
+#endif
+
+        /*
+         * If the controller is already suspended, then this must be a
+         * PM suspend.  Remember this fact, so that we will leave the
+         * controller suspended at PM resume time.
+         */
+        if (pdata->suspended) {
+                dev_dbg(dev, "already suspended, leaving early\n");
+                pdata->already_suspended = 1;
+                return 0;
+        }
+
+        dev_dbg(dev, "suspending...\n");
+
+        hcd->state = HC_STATE_SUSPENDED;
+        dev->power.power_state = PMSG_SUSPEND;
+
+        /* ignore non-host interrupts */
+        clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
+
+        /* stop the controller */
+        tmp = ehci_readl(ehci, &ehci->regs->command);
+        tmp &= ~CMD_RUN;
+        ehci_writel(ehci, tmp, &ehci->regs->command);
+
+        /* save EHCI registers */
+        pdata->pm_command = ehci_readl(ehci, &ehci->regs->command);
+        pdata->pm_command &= ~CMD_RUN;
+        pdata->pm_status  = ehci_readl(ehci, &ehci->regs->status);
+        pdata->pm_intr_enable  = ehci_readl(ehci, &ehci->regs->intr_enable);
+        pdata->pm_frame_index  = ehci_readl(ehci, &ehci->regs->frame_index);
+        pdata->pm_segment  = ehci_readl(ehci, &ehci->regs->segment);
+        pdata->pm_frame_list  = ehci_readl(ehci, &ehci->regs->frame_list);
+        pdata->pm_async_next  = ehci_readl(ehci, &ehci->regs->async_next);
+        pdata->pm_configured_flag  =
+                ehci_readl(ehci, &ehci->regs->configured_flag);
+        pdata->pm_portsc = ehci_readl(ehci, &ehci->regs->port_status[0]);
+        pdata->pm_usbgenctrl = ehci_readl(ehci,
+                                          hcd->regs + FSL_SOC_USB_USBGENCTRL);
+
+        /* clear the W1C bits */
+        pdata->pm_portsc &= cpu_to_hc32(ehci, ~PORT_RWC_BITS);
+
+        pdata->suspended = 1;
+
+        /* clear PP to cut power to the port */
+        tmp = ehci_readl(ehci, &ehci->regs->port_status[0]);
+        tmp &= ~PORT_POWER;
+        ehci_writel(ehci, tmp, &ehci->regs->port_status[0]);
+
+        return 0;
+}
+
+static int ehci_fsl_mpc512x_drv_resume(struct device *dev)
+{
+        struct usb_hcd *hcd = dev_get_drvdata(dev);
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        struct fsl_usb2_platform_data *pdata = dev->platform_data;
+        u32 tmp;
+
+        dev_dbg(dev, "suspend=%d already_suspended=%d\n",
+                pdata->suspended, pdata->already_suspended);
+
+        /*
+         * If the controller was already suspended at suspend time,
+         * then don't resume it now.
+         */
+        if (pdata->already_suspended) {
+                dev_dbg(dev, "already suspended, leaving early\n");
+                pdata->already_suspended = 0;
+                return 0;
+        }
+
+        if (!pdata->suspended) {
+                dev_dbg(dev, "not suspended, leaving early\n");
+                return 0;
+        }
+
+        pdata->suspended = 0;
+
+        dev_dbg(dev, "resuming...\n");
+
+        /* set host mode */
+        tmp = USBMODE_CM_HOST | (pdata->es ? USBMODE_ES : 0);
+        ehci_writel(ehci, tmp, hcd->regs + FSL_SOC_USB_USBMODE);
+
+        ehci_writel(ehci, pdata->pm_usbgenctrl,
+                    hcd->regs + FSL_SOC_USB_USBGENCTRL);
+        ehci_writel(ehci, ISIPHYCTRL_PXE | ISIPHYCTRL_PHYE,
+                    hcd->regs + FSL_SOC_USB_ISIPHYCTRL);
+
+        /* restore EHCI registers */
+        ehci_writel(ehci, pdata->pm_command, &ehci->regs->command);
+        ehci_writel(ehci, pdata->pm_intr_enable, &ehci->regs->intr_enable);
+        ehci_writel(ehci, pdata->pm_frame_index, &ehci->regs->frame_index);
+        ehci_writel(ehci, pdata->pm_segment, &ehci->regs->segment);
+        ehci_writel(ehci, pdata->pm_frame_list, &ehci->regs->frame_list);
+        ehci_writel(ehci, pdata->pm_async_next, &ehci->regs->async_next);
+        ehci_writel(ehci, pdata->pm_configured_flag,
+                    &ehci->regs->configured_flag);
+        ehci_writel(ehci, pdata->pm_portsc, &ehci->regs->port_status[0]);
+
+        set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
+        hcd->state = HC_STATE_RUNNING;
+        dev->power.power_state = PMSG_ON;
+
+        tmp = ehci_readl(ehci, &ehci->regs->command);
+        tmp |= CMD_RUN;
+        ehci_writel(ehci, tmp, &ehci->regs->command);
+
+        usb_hcd_resume_root_hub(hcd);
+
+        return 0;
+}
+#else
+static inline int ehci_fsl_mpc512x_drv_suspend(struct device *dev)
+{
+        return 0;
+}
+
+static inline int ehci_fsl_mpc512x_drv_resume(struct device *dev)
+{
+        return 0;
+}
+#endif /* CONFIG_PPC_MPC512x */
+
 static struct ehci_fsl *hcd_to_ehci_fsl(struct usb_hcd *hcd)
 {
         struct ehci_hcd *ehci = hcd_to_ehci(hcd);
@@ -313,6 +517,11 @@ static int ehci_fsl_drv_suspend(struct device *dev)
         struct ehci_fsl *ehci_fsl = hcd_to_ehci_fsl(hcd);
         void __iomem *non_ehci = hcd->regs;
 
+        if (of_device_is_compatible(dev->parent->of_node,
+                                    "fsl,mpc5121-usb2-dr")) {
+                return ehci_fsl_mpc512x_drv_suspend(dev);
+        }
+
         ehci_prepare_ports_for_controller_suspend(hcd_to_ehci(hcd),
                         device_may_wakeup(dev));
         if (!fsl_deep_sleep())
@@ -329,6 +538,11 @@ static int ehci_fsl_drv_resume(struct device *dev)
         struct ehci_hcd *ehci = hcd_to_ehci(hcd);
         void __iomem *non_ehci = hcd->regs;
 
+        if (of_device_is_compatible(dev->parent->of_node,
+                                    "fsl,mpc5121-usb2-dr")) {
+                return ehci_fsl_mpc512x_drv_resume(dev);
+        }
+
         ehci_prepare_ports_for_controller_resume(ehci);
         if (!fsl_deep_sleep())
                 return 0;
@@ -363,6 +577,38 @@ static struct dev_pm_ops ehci_fsl_pm_ops = {
 #define EHCI_FSL_PM_OPS         NULL
 #endif /* CONFIG_PM */
 
+#ifdef CONFIG_USB_OTG
+static int ehci_start_port_reset(struct usb_hcd *hcd, unsigned port)
+{
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        u32 status;
+
+        if (!port)
+                return -EINVAL;
+
+        port--;
+
+        /* start port reset before HNP protocol time out */
+        status = readl(&ehci->regs->port_status[port]);
+        if (!(status & PORT_CONNECT))
+                return -ENODEV;
+
+        /* khubd will finish the reset later */
+        if (ehci_is_TDI(ehci)) {
+                writel(PORT_RESET |
+                       (status & ~(PORT_CSC | PORT_PEC | PORT_OCC)),
+                       &ehci->regs->port_status[port]);
+        } else {
+                writel(PORT_RESET, &ehci->regs->port_status[port]);
+        }
+
+        return 0;
+}
+#else
+#define ehci_start_port_reset   NULL
+#endif /* CONFIG_USB_OTG */
+
+
 static const struct hc_driver ehci_fsl_hc_driver = {
         .description = hcd_name,
         .product_desc = "Freescale On-Chip EHCI Host Controller",
@@ -372,7 +618,7 @@ static const struct hc_driver ehci_fsl_hc_driver = {
          * generic hardware linkage
          */
         .irq = ehci_irq,
-        .flags = HCD_USB2,
+        .flags = HCD_USB2 | HCD_MEMORY,
 
         /*
          * basic lifecycle operations
@@ -402,6 +648,7 @@ static const struct hc_driver ehci_fsl_hc_driver = {
         .hub_control = ehci_hub_control,
         .bus_suspend = ehci_bus_suspend,
         .bus_resume = ehci_bus_resume,
+        .start_port_reset = ehci_start_port_reset,
         .relinquish_port = ehci_relinquish_port,
         .port_handed_over = ehci_port_handed_over,
 
diff --git a/drivers/usb/host/ehci-fsl.h b/drivers/usb/host/ehci-fsl.h
index b5e59db53347..491806221165 100644
--- a/drivers/usb/host/ehci-fsl.h
+++ b/drivers/usb/host/ehci-fsl.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2005 freescale semiconductor
+/* Copyright (C) 2005-2010 Freescale Semiconductor, Inc.
  * Copyright (c) 2005 MontaVista Software
  *
  * This program is free software; you can redistribute  it and/or modify it
@@ -28,6 +28,17 @@
 #define PORT_PTS_PTW            (1<<28)
 #define FSL_SOC_USB_PORTSC2     0x188
 #define FSL_SOC_USB_USBMODE     0x1a8
+#define USBMODE_CM_MASK         (3 << 0)        /* controller mode mask */
+#define USBMODE_CM_HOST         (3 << 0)        /* controller mode: host */
+#define USBMODE_ES              (1 << 2)        /* (Big) Endian Select */
+
+#define FSL_SOC_USB_USBGENCTRL  0x200
+#define USBGENCTRL_PPP          (1 << 3)
+#define USBGENCTRL_PFP          (1 << 2)
+#define FSL_SOC_USB_ISIPHYCTRL  0x204
+#define ISIPHYCTRL_PXE          (1)
+#define ISIPHYCTRL_PHYE         (1 << 4)
+
 #define FSL_SOC_USB_SNOOP1      0x400   /* NOTE: big-endian */
 #define FSL_SOC_USB_SNOOP2      0x404   /* NOTE: big-endian */
 #define FSL_SOC_USB_AGECNTTHRSH 0x408   /* NOTE: big-endian */
diff --git a/drivers/usb/host/ehci-grlib.c b/drivers/usb/host/ehci-grlib.c
new file mode 100644
index 000000000000..93b230dc51a2
--- /dev/null
+++ b/drivers/usb/host/ehci-grlib.c
@@ -0,0 +1,242 @@
+/*
+ * Driver for Aeroflex Gaisler GRLIB GRUSBHC EHCI host controller
+ *
+ * GRUSBHC is typically found on LEON/GRLIB SoCs
+ *
+ * (c) Jan Andersson <jan@gaisler.com>
+ *
+ * Based on ehci-ppc-of.c which is:
+ * (c) Valentine Barshak <vbarshak@ru.mvista.com>
+ * and in turn based on "ehci-ppc-soc.c" by Stefan Roese <sr@denx.de>
+ * and "ohci-ppc-of.c" by Sylvain Munaut <tnt@246tNt.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 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.
+ */
+
+
+#include <linux/signal.h>
+
+#include <linux/of_irq.h>
+#include <linux/of_address.h>
+#include <linux/of_platform.h>
+
+#define GRUSBHC_HCIVERSION 0x0100 /* Known value of cap. reg. HCIVERSION */
+
+/* called during probe() after chip reset completes */
+static int ehci_grlib_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;
+        ehci_port_power(ehci, 1);
+
+        return ehci_reset(ehci);
+}
+
+
+static const struct hc_driver ehci_grlib_hc_driver = {
+        .description            = hcd_name,
+        .product_desc           = "GRLIB GRUSBHC EHCI",
+        .hcd_priv_size          = sizeof(struct ehci_hcd),
+
+        /*
+         * generic hardware linkage
+         */
+        .irq                    = ehci_irq,
+        .flags                  = HCD_MEMORY | HCD_USB2,
+
+        /*
+         * basic lifecycle operations
+         */
+        .reset                  = ehci_grlib_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,
+        .endpoint_reset         = ehci_endpoint_reset,
+
+        /*
+         * scheduling support
+         */
+        .get_frame_number       = ehci_get_frame,
+
+        /*
+         * root hub support
+         */
+        .hub_status_data        = ehci_hub_status_data,
+        .hub_control            = ehci_hub_control,
+#ifdef  CONFIG_PM
+        .bus_suspend            = ehci_bus_suspend,
+        .bus_resume             = ehci_bus_resume,
+#endif
+        .relinquish_port        = ehci_relinquish_port,
+        .port_handed_over       = ehci_port_handed_over,
+
+        .clear_tt_buffer_complete       = ehci_clear_tt_buffer_complete,
+};
+
+
+static int __devinit ehci_hcd_grlib_probe(struct platform_device *op)
+{
+        struct device_node *dn = op->dev.of_node;
+        struct usb_hcd *hcd;
+        struct ehci_hcd *ehci = NULL;
+        struct resource res;
+        u32 hc_capbase;
+        int irq;
+        int rv;
+
+        if (usb_disabled())
+                return -ENODEV;
+
+        dev_dbg(&op->dev, "initializing GRUSBHC EHCI USB Controller\n");
+
+        rv = of_address_to_resource(dn, 0, &res);
+        if (rv)
+                return rv;
+
+        /* usb_create_hcd requires dma_mask != NULL */
+        op->dev.dma_mask = &op->dev.coherent_dma_mask;
+        hcd = usb_create_hcd(&ehci_grlib_hc_driver, &op->dev,
+                        "GRUSBHC EHCI USB");
+        if (!hcd)
+                return -ENOMEM;
+
+        hcd->rsrc_start = res.start;
+        hcd->rsrc_len = res.end - res.start + 1;
+
+        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
+                printk(KERN_ERR "%s: request_mem_region failed\n", __FILE__);
+                rv = -EBUSY;
+                goto err_rmr;
+        }
+
+        irq = irq_of_parse_and_map(dn, 0);
+        if (irq == NO_IRQ) {
+                printk(KERN_ERR "%s: irq_of_parse_and_map failed\n", __FILE__);
+                rv = -EBUSY;
+                goto err_irq;
+        }
+
+        hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
+        if (!hcd->regs) {
+                printk(KERN_ERR "%s: ioremap failed\n", __FILE__);
+                rv = -ENOMEM;
+                goto err_ioremap;
+        }
+
+        ehci = hcd_to_ehci(hcd);
+
+        ehci->caps = hcd->regs;
+
+        /* determine endianness of this implementation */
+        hc_capbase = ehci_readl(ehci, &ehci->caps->hc_capbase);
+        if (HC_VERSION(ehci, hc_capbase) != GRUSBHC_HCIVERSION) {
+                ehci->big_endian_mmio = 1;
+                ehci->big_endian_desc = 1;
+                ehci->big_endian_capbase = 1;
+        }
+
+        ehci->regs = hcd->regs +
+                HC_LENGTH(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
+
+        /* cache this readonly data; minimize chip reads */
+        ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
+
+        rv = usb_add_hcd(hcd, irq, 0);
+        if (rv)
+                goto err_ehci;
+
+        return 0;
+
+err_ehci:
+        iounmap(hcd->regs);
+err_ioremap:
+        irq_dispose_mapping(irq);
+err_irq:
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+err_rmr:
+        usb_put_hcd(hcd);
+
+        return rv;
+}
+
+
+static int ehci_hcd_grlib_remove(struct platform_device *op)
+{
+        struct usb_hcd *hcd = dev_get_drvdata(&op->dev);
+
+        dev_set_drvdata(&op->dev, NULL);
+
+        dev_dbg(&op->dev, "stopping GRLIB GRUSBHC EHCI USB Controller\n");
+
+        usb_remove_hcd(hcd);
+
+        iounmap(hcd->regs);
+        irq_dispose_mapping(hcd->irq);
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+
+        usb_put_hcd(hcd);
+
+        return 0;
+}
+
+
+static void ehci_hcd_grlib_shutdown(struct platform_device *op)
+{
+        struct usb_hcd *hcd = dev_get_drvdata(&op->dev);
+
+        if (hcd->driver->shutdown)
+                hcd->driver->shutdown(hcd);
+}
+
+
+static const struct of_device_id ehci_hcd_grlib_of_match[] = {
+        {
+                .name = "GAISLER_EHCI",
+         },
+        {
+                .name = "01_026",
+         },
+        {},
+};
+MODULE_DEVICE_TABLE(of, ehci_hcd_grlib_of_match);
+
+
+static struct platform_driver ehci_grlib_driver = {
+        .probe          = ehci_hcd_grlib_probe,
+        .remove         = ehci_hcd_grlib_remove,
+        .shutdown       = ehci_hcd_grlib_shutdown,
+        .driver = {
+                .name = "grlib-ehci",
+                .owner = THIS_MODULE,
+                .of_match_table = ehci_hcd_grlib_of_match,
+        },
+};
diff --git a/drivers/usb/host/ehci-hcd.c b/drivers/usb/host/ehci-hcd.c
index 34a928d3b7d2..f8030ee928e8 100644
--- a/drivers/usb/host/ehci-hcd.c
+++ b/drivers/usb/host/ehci-hcd.c
@@ -1,4 +1,8 @@
 /*
+ * Enhanced Host Controller Interface (EHCI) driver for USB.
+ *
+ * Maintainer: Alan Stern <stern@rowland.harvard.edu>
+ *
  * Copyright (c) 2000-2004 by David Brownell
  *
  * This program is free software; you can redistribute it and/or modify it
@@ -118,6 +122,7 @@ MODULE_PARM_DESC(hird, "host initiated resume duration, +1 for each 75us\n");
 
 #include "ehci.h"
 #include "ehci-dbg.c"
+#include "pci-quirks.h"
 
 /*-------------------------------------------------------------------------*/
 
@@ -194,6 +199,17 @@ static int handshake (struct ehci_hcd *ehci, void __iomem *ptr,
         return -ETIMEDOUT;
 }
 
+/* check TDI/ARC silicon is in host mode */
+static int tdi_in_host_mode (struct ehci_hcd *ehci)
+{
+        u32 __iomem     *reg_ptr;
+        u32             tmp;
+
+        reg_ptr = (u32 __iomem *)(((u8 __iomem *)ehci->regs) + USBMODE);
+        tmp = ehci_readl(ehci, reg_ptr);
+        return (tmp & 3) == USBMODE_CM_HC;
+}
+
 /* force HC to halt state from unknown (EHCI spec section 2.3) */
 static int ehci_halt (struct ehci_hcd *ehci)
 {
@@ -202,6 +218,10 @@ static int ehci_halt (struct ehci_hcd *ehci)
         /* disable any irqs left enabled by previous code */
         ehci_writel(ehci, 0, &ehci->regs->intr_enable);
 
+        if (ehci_is_TDI(ehci) && tdi_in_host_mode(ehci) == 0) {
+                return 0;
+        }
+
         if ((temp & STS_HALT) != 0)
                 return 0;
 
@@ -514,6 +534,9 @@ static void ehci_stop (struct usb_hcd *hcd)
         spin_unlock_irq (&ehci->lock);
         ehci_mem_cleanup (ehci);
 
+        if (ehci->amd_pll_fix == 1)
+                usb_amd_dev_put();
+
 #ifdef  EHCI_STATS
         ehci_dbg (ehci, "irq normal %ld err %ld reclaim %ld (lost %ld)\n",
                 ehci->stats.normal, ehci->stats.error, ehci->stats.reclaim,
@@ -549,6 +572,8 @@ static int ehci_init(struct usb_hcd *hcd)
         ehci->iaa_watchdog.function = ehci_iaa_watchdog;
         ehci->iaa_watchdog.data = (unsigned long) ehci;
 
+        hcc_params = ehci_readl(ehci, &ehci->caps->hcc_params);
+
         /*
          * hw default: 1K periodic list heads, one per frame.
          * periodic_size can shrink by USBCMD update if hcc_params allows.
@@ -556,11 +581,20 @@ static int ehci_init(struct usb_hcd *hcd)
         ehci->periodic_size = DEFAULT_I_TDPS;
         INIT_LIST_HEAD(&ehci->cached_itd_list);
         INIT_LIST_HEAD(&ehci->cached_sitd_list);
+
+        if (HCC_PGM_FRAMELISTLEN(hcc_params)) {
+                /* periodic schedule size can be smaller than default */
+                switch (EHCI_TUNE_FLS) {
+                case 0: ehci->periodic_size = 1024; break;
+                case 1: ehci->periodic_size = 512; break;
+                case 2: ehci->periodic_size = 256; break;
+                default:        BUG();
+                }
+        }
         if ((retval = ehci_mem_init(ehci, GFP_KERNEL)) < 0)
                 return retval;
 
         /* controllers may cache some of the periodic schedule ... */
-        hcc_params = ehci_readl(ehci, &ehci->caps->hcc_params);
         if (HCC_ISOC_CACHE(hcc_params))         // full frame cache
                 ehci->i_thresh = 2 + 8;
         else                                    // N microframes cached
@@ -614,12 +648,6 @@ static int ehci_init(struct usb_hcd *hcd)
                 /* periodic schedule size can be smaller than default */
                 temp &= ~(3 << 2);
                 temp |= (EHCI_TUNE_FLS << 2);
-                switch (EHCI_TUNE_FLS) {
-                case 0: ehci->periodic_size = 1024; break;
-                case 1: ehci->periodic_size = 512; break;
-                case 2: ehci->periodic_size = 256; break;
-                default:        BUG();
-                }
         }
         if (HCC_LPM(hcc_params)) {
                 /* support link power management EHCI 1.1 addendum */
@@ -651,7 +679,12 @@ static int ehci_run (struct usb_hcd *hcd)
         hcd->uses_new_polling = 1;
 
         /* EHCI spec section 4.1 */
-        if ((retval = ehci_reset(ehci)) != 0) {
+        /*
+         * TDI driver does the ehci_reset in their reset callback.
+         * Don't reset here, because configuration settings will
+         * vanish.
+         */
+        if (!ehci_is_TDI(ehci) && (retval = ehci_reset(ehci)) != 0) {
                 ehci_mem_cleanup(ehci);
                 return retval;
         }
@@ -710,7 +743,7 @@ static int ehci_run (struct usb_hcd *hcd)
         up_write(&ehci_cf_port_reset_rwsem);
         ehci->last_periodic_enable = ktime_get_real();
 
-        temp = HC_VERSION(ehci_readl(ehci, &ehci->caps->hc_capbase));
+        temp = HC_VERSION(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
         ehci_info (ehci,
                 "USB %x.%x started, EHCI %x.%02x%s\n",
                 ((ehci->sbrn & 0xf0)>>4), (ehci->sbrn & 0x0f),
@@ -748,8 +781,9 @@ static irqreturn_t ehci_irq (struct usb_hcd *hcd)
                 goto dead;
         }
 
+        /* Shared IRQ? */
         masked_status = status & INTR_MASK;
-        if (!masked_status) {           /* irq sharing? */
+        if (!masked_status || unlikely(hcd->state == HC_STATE_HALT)) {
                 spin_unlock(&ehci->lock);
                 return IRQ_NONE;
         }
@@ -844,6 +878,7 @@ static irqreturn_t ehci_irq (struct usb_hcd *hcd)
 dead:
                 ehci_reset(ehci);
                 ehci_writel(ehci, 0, &ehci->regs->configured_flag);
+                usb_hc_died(hcd);
                 /* generic layer kills/unlinks all urbs, then
                  * uses ehci_stop to clean up the rest
                  */
@@ -1048,10 +1083,11 @@ rescan:
                                 tmp && tmp != qh;
                                 tmp = tmp->qh_next.qh)
                         continue;
-                /* periodic qh self-unlinks on empty */
-                if (!tmp)
-                        goto nogood;
-                unlink_async (ehci, qh);
+                /* periodic qh self-unlinks on empty, and a COMPLETING qh
+                 * may already be unlinked.
+                 */
+                if (tmp)
+                        unlink_async(ehci, qh);
                 /* FALL THROUGH */
         case QH_STATE_UNLINK:           /* wait for hw to finish? */
         case QH_STATE_UNLINK_WAIT:
@@ -1068,7 +1104,6 @@ idle_timeout:
                 }
                 /* else FALL THROUGH */
         default:
-nogood:
                 /* caller was supposed to have unlinked any requests;
                  * that's not our job.  just leak this memory.
                  */
@@ -1080,7 +1115,6 @@ nogood:
         ep->hcpriv = NULL;
 done:
         spin_unlock_irqrestore (&ehci->lock, flags);
-        return;
 }
 
 static void
@@ -1152,12 +1186,17 @@ MODULE_LICENSE ("GPL");
 #define PLATFORM_DRIVER         ehci_mxc_driver
 #endif
 
+#ifdef CONFIG_USB_EHCI_SH
+#include "ehci-sh.c"
+#define PLATFORM_DRIVER         ehci_hcd_sh_driver
+#endif
+
 #ifdef CONFIG_SOC_AU1200
 #include "ehci-au1xxx.c"
 #define PLATFORM_DRIVER         ehci_hcd_au1xxx_driver
 #endif
 
-#ifdef CONFIG_ARCH_OMAP3
+#ifdef CONFIG_USB_EHCI_HCD_OMAP
 #include "ehci-omap.c"
 #define        PLATFORM_DRIVER         ehci_hcd_omap_driver
 #endif
@@ -1197,6 +1236,56 @@ MODULE_LICENSE ("GPL");
 #define PLATFORM_DRIVER         ehci_atmel_driver
 #endif
 
+#ifdef CONFIG_USB_OCTEON_EHCI
+#include "ehci-octeon.c"
+#define PLATFORM_DRIVER         ehci_octeon_driver
+#endif
+
+#ifdef CONFIG_USB_CNS3XXX_EHCI
+#include "ehci-cns3xxx.c"
+#define PLATFORM_DRIVER         cns3xxx_ehci_driver
+#endif
+
+#ifdef CONFIG_ARCH_VT8500
+#include "ehci-vt8500.c"
+#define PLATFORM_DRIVER         vt8500_ehci_driver
+#endif
+
+#ifdef CONFIG_PLAT_SPEAR
+#include "ehci-spear.c"
+#define PLATFORM_DRIVER         spear_ehci_hcd_driver
+#endif
+
+#ifdef CONFIG_USB_EHCI_MSM
+#include "ehci-msm.c"
+#define PLATFORM_DRIVER         ehci_msm_driver
+#endif
+
+#ifdef CONFIG_USB_EHCI_HCD_PMC_MSP
+#include "ehci-pmcmsp.c"
+#define PLATFORM_DRIVER         ehci_hcd_msp_driver
+#endif
+
+#ifdef CONFIG_USB_EHCI_TEGRA
+#include "ehci-tegra.c"
+#define PLATFORM_DRIVER         tegra_ehci_driver
+#endif
+
+#ifdef CONFIG_USB_EHCI_S5P
+#include "ehci-s5p.c"
+#define PLATFORM_DRIVER         s5p_ehci_driver
+#endif
+
+#ifdef CONFIG_USB_EHCI_ATH79
+#include "ehci-ath79.c"
+#define PLATFORM_DRIVER         ehci_ath79_driver
+#endif
+
+#ifdef CONFIG_SPARC_LEON
+#include "ehci-grlib.c"
+#define PLATFORM_DRIVER         ehci_grlib_driver
+#endif
+
 #if !defined(PCI_DRIVER) && !defined(PLATFORM_DRIVER) && \
     !defined(PS3_SYSTEM_BUS_DRIVER) && !defined(OF_PLATFORM_DRIVER) && \
     !defined(XILINX_OF_PLATFORM_DRIVER)
@@ -1249,24 +1338,24 @@ static int __init ehci_hcd_init(void)
 #endif
 
 #ifdef OF_PLATFORM_DRIVER
-        retval = of_register_platform_driver(&OF_PLATFORM_DRIVER);
+        retval = platform_driver_register(&OF_PLATFORM_DRIVER);
         if (retval < 0)
                 goto clean3;
 #endif
 
 #ifdef XILINX_OF_PLATFORM_DRIVER
-        retval = of_register_platform_driver(&XILINX_OF_PLATFORM_DRIVER);
+        retval = platform_driver_register(&XILINX_OF_PLATFORM_DRIVER);
         if (retval < 0)
                 goto clean4;
 #endif
         return retval;
 
 #ifdef XILINX_OF_PLATFORM_DRIVER
-        /* of_unregister_platform_driver(&XILINX_OF_PLATFORM_DRIVER); */
+        /* platform_driver_unregister(&XILINX_OF_PLATFORM_DRIVER); */
 clean4:
 #endif
 #ifdef OF_PLATFORM_DRIVER
-        of_unregister_platform_driver(&OF_PLATFORM_DRIVER);
+        platform_driver_unregister(&OF_PLATFORM_DRIVER);
 clean3:
 #endif
 #ifdef PS3_SYSTEM_BUS_DRIVER
@@ -1294,10 +1383,10 @@ module_init(ehci_hcd_init);
 static void __exit ehci_hcd_cleanup(void)
 {
 #ifdef XILINX_OF_PLATFORM_DRIVER
-        of_unregister_platform_driver(&XILINX_OF_PLATFORM_DRIVER);
+        platform_driver_unregister(&XILINX_OF_PLATFORM_DRIVER);
 #endif
 #ifdef OF_PLATFORM_DRIVER
-        of_unregister_platform_driver(&OF_PLATFORM_DRIVER);
+        platform_driver_unregister(&OF_PLATFORM_DRIVER);
 #endif
 #ifdef PLATFORM_DRIVER
         platform_driver_unregister(&PLATFORM_DRIVER);
diff --git a/drivers/usb/host/ehci-hub.c b/drivers/usb/host/ehci-hub.c
index 796ea0c8900f..ea6184bf48d0 100644
--- a/drivers/usb/host/ehci-hub.c
+++ b/drivers/usb/host/ehci-hub.c
@@ -27,6 +27,7 @@
  */
 
 /*-------------------------------------------------------------------------*/
+#include <linux/usb/otg.h>
 
 #define PORT_WAKE_BITS  (PORT_WKOC_E|PORT_WKDISC_E|PORT_WKCONN_E)
 
@@ -106,11 +107,33 @@ static void ehci_handover_companion_ports(struct ehci_hcd *ehci)
         ehci->owned_ports = 0;
 }
 
-static void ehci_adjust_port_wakeup_flags(struct ehci_hcd *ehci,
+static int ehci_port_change(struct ehci_hcd *ehci)
+{
+        int i = HCS_N_PORTS(ehci->hcs_params);
+
+        /* First check if the controller indicates a change event */
+
+        if (ehci_readl(ehci, &ehci->regs->status) & STS_PCD)
+                return 1;
+
+        /*
+         * Not all controllers appear to update this while going from D3 to D0,
+         * so check the individual port status registers as well
+         */
+
+        while (i--)
+                if (ehci_readl(ehci, &ehci->regs->port_status[i]) & PORT_CSC)
+                        return 1;
+
+        return 0;
+}
+
+static __maybe_unused void ehci_adjust_port_wakeup_flags(struct ehci_hcd *ehci,
                 bool suspending, bool do_wakeup)
 {
         int             port;
         u32             temp;
+        unsigned long   flags;
 
         /* If remote wakeup is enabled for the root hub but disabled
          * for the controller, we must adjust all the port wakeup flags
@@ -120,6 +143,8 @@ static void ehci_adjust_port_wakeup_flags(struct ehci_hcd *ehci,
         if (!ehci_to_hcd(ehci)->self.root_hub->do_remote_wakeup || do_wakeup)
                 return;
 
+        spin_lock_irqsave(&ehci->lock, flags);
+
         /* clear phy low-power mode before changing wakeup flags */
         if (ehci->has_hostpc) {
                 port = HCS_N_PORTS(ehci->hcs_params);
@@ -131,7 +156,9 @@ static void ehci_adjust_port_wakeup_flags(struct ehci_hcd *ehci,
                         temp = ehci_readl(ehci, hostpc_reg);
                         ehci_writel(ehci, temp & ~HOSTPC_PHCD, hostpc_reg);
                 }
+                spin_unlock_irqrestore(&ehci->lock, flags);
                 msleep(5);
+                spin_lock_irqsave(&ehci->lock, flags);
         }
 
         port = HCS_N_PORTS(ehci->hcs_params);
@@ -168,8 +195,10 @@ static void ehci_adjust_port_wakeup_flags(struct ehci_hcd *ehci,
         }
 
         /* Does the root hub have a port wakeup pending? */
-        if (!suspending && (ehci_readl(ehci, &ehci->regs->status) & STS_PCD))
+        if (!suspending && ehci_port_change(ehci))
                 usb_hcd_resume_root_hub(ehci_to_hcd(ehci));
+
+        spin_unlock_irqrestore(&ehci->lock, flags);
 }
 
 static int ehci_bus_suspend (struct usb_hcd *hcd)
@@ -531,14 +560,15 @@ static ssize_t store_companion(struct device *dev,
 }
 static DEVICE_ATTR(companion, 0644, show_companion, store_companion);
 
-static inline void create_companion_file(struct ehci_hcd *ehci)
+static inline int create_companion_file(struct ehci_hcd *ehci)
 {
-        int     i;
+        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)
@@ -688,8 +718,8 @@ ehci_hub_descriptor (
         desc->bDescLength = 7 + 2 * temp;
 
         /* two bitmaps:  ports removable, and usb 1.0 legacy PortPwrCtrlMask */
-        memset (&desc->bitmap [0], 0, temp);
-        memset (&desc->bitmap [temp], 0xff, temp);
+        memset(&desc->u.hs.DeviceRemovable[0], 0, temp);
+        memset(&desc->u.hs.DeviceRemovable[temp], 0xff, temp);
 
         temp = 0x0008;                  /* per-port overcurrent reporting */
         if (HCS_PPC (ehci->hcs_params))
@@ -772,6 +802,13 @@ static int ehci_hub_control (
                                 goto error;
                         if (ehci->no_selective_suspend)
                                 break;
+#ifdef CONFIG_USB_OTG
+                        if ((hcd->self.otg_port == (wIndex + 1))
+                            && hcd->self.b_hnp_enable) {
+                                otg_start_hnp(ehci->transceiver);
+                                break;
+                        }
+#endif
                         if (!(temp & PORT_SUSPEND))
                                 break;
                         if ((temp & PORT_PE) == 0)
diff --git a/drivers/usb/host/ehci-ixp4xx.c b/drivers/usb/host/ehci-ixp4xx.c
index 89b7c70c6ed6..50e600d26e28 100644
--- a/drivers/usb/host/ehci-ixp4xx.c
+++ b/drivers/usb/host/ehci-ixp4xx.c
@@ -23,7 +23,7 @@ static int ixp4xx_ehci_init(struct usb_hcd *hcd)
 
         ehci->caps = hcd->regs + 0x100;
         ehci->regs = hcd->regs + 0x100
-                + HC_LENGTH(ehci_readl(ehci, &ehci->caps->hc_capbase));
+                + HC_LENGTH(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
         ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
 
         hcd->has_tt = 1;
diff --git a/drivers/usb/host/ehci-lpm.c b/drivers/usb/host/ehci-lpm.c
index b4d4d63c13ed..2111627a19de 100644
--- a/drivers/usb/host/ehci-lpm.c
+++ b/drivers/usb/host/ehci-lpm.c
@@ -17,7 +17,8 @@
 */
 
 /* this file is part of ehci-hcd.c */
-static int ehci_lpm_set_da(struct ehci_hcd *ehci, int dev_addr, int port_num)
+static int __maybe_unused ehci_lpm_set_da(struct ehci_hcd *ehci,
+        int dev_addr, int port_num)
 {
         u32 __iomem portsc;
 
@@ -37,7 +38,7 @@ static int ehci_lpm_set_da(struct ehci_hcd *ehci, int dev_addr, int port_num)
  * this function is used to check if the device support LPM
  * if yes, mark the PORTSC register with PORT_LPM bit
  */
-static int ehci_lpm_check(struct ehci_hcd *ehci, int port)
+static int __maybe_unused ehci_lpm_check(struct ehci_hcd *ehci, int port)
 {
         u32 __iomem     *portsc ;
         u32 val32;
diff --git a/drivers/usb/host/ehci-mem.c b/drivers/usb/host/ehci-mem.c
index 1f3f01eacaf0..12f70c302b0b 100644
--- a/drivers/usb/host/ehci-mem.c
+++ b/drivers/usb/host/ehci-mem.c
@@ -40,7 +40,7 @@ static inline void ehci_qtd_init(struct ehci_hcd *ehci, struct ehci_qtd *qtd,
 {
         memset (qtd, 0, sizeof *qtd);
         qtd->qtd_dma = dma;
-        qtd->hw_token = cpu_to_le32 (QTD_STS_HALT);
+        qtd->hw_token = cpu_to_hc32(ehci, QTD_STS_HALT);
         qtd->hw_next = EHCI_LIST_END(ehci);
         qtd->hw_alt_next = EHCI_LIST_END(ehci);
         INIT_LIST_HEAD (&qtd->qtd_list);
@@ -141,6 +141,10 @@ static void ehci_mem_cleanup (struct ehci_hcd *ehci)
                 qh_put (ehci->async);
         ehci->async = NULL;
 
+        if (ehci->dummy)
+                qh_put(ehci->dummy);
+        ehci->dummy = NULL;
+
         /* DMA consistent memory and pools */
         if (ehci->qtd_pool)
                 dma_pool_destroy (ehci->qtd_pool);
@@ -227,8 +231,26 @@ static int ehci_mem_init (struct ehci_hcd *ehci, gfp_t flags)
         if (ehci->periodic == NULL) {
                 goto fail;
         }
-        for (i = 0; i < ehci->periodic_size; i++)
-                ehci->periodic [i] = EHCI_LIST_END(ehci);
+
+        if (ehci->use_dummy_qh) {
+                struct ehci_qh_hw       *hw;
+                ehci->dummy = ehci_qh_alloc(ehci, flags);
+                if (!ehci->dummy)
+                        goto fail;
+
+                hw = ehci->dummy->hw;
+                hw->hw_next = EHCI_LIST_END(ehci);
+                hw->hw_qtd_next = EHCI_LIST_END(ehci);
+                hw->hw_alt_next = EHCI_LIST_END(ehci);
+                hw->hw_token &= ~QTD_STS_ACTIVE;
+                ehci->dummy->hw = hw;
+
+                for (i = 0; i < ehci->periodic_size; i++)
+                        ehci->periodic[i] = ehci->dummy->qh_dma;
+        } else {
+                for (i = 0; i < ehci->periodic_size; i++)
+                        ehci->periodic[i] = EHCI_LIST_END(ehci);
+        }
 
         /* software shadow of hardware table */
         ehci->pshadow = kcalloc(ehci->periodic_size, sizeof(void *), flags);
diff --git a/drivers/usb/host/ehci-msm.c b/drivers/usb/host/ehci-msm.c
new file mode 100644
index 000000000000..b5a0bf649c95
--- /dev/null
+++ b/drivers/usb/host/ehci-msm.c
@@ -0,0 +1,265 @@
+/* ehci-msm.c - HSUSB Host Controller Driver Implementation
+ *
+ * Copyright (c) 2008-2011, Code Aurora Forum. All rights reserved.
+ *
+ * Partly derived from ehci-fsl.c and ehci-hcd.c
+ * Copyright (c) 2000-2004 by David Brownell
+ * Copyright (c) 2005 MontaVista Software
+ *
+ * All source code in this file is licensed under the following license except
+ * where indicated.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published
+ * by the Free Software Foundation.
+ *
+ * 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, you can find it at http://www.fsf.org
+ */
+
+#include <linux/platform_device.h>
+#include <linux/clk.h>
+#include <linux/err.h>
+#include <linux/pm_runtime.h>
+
+#include <linux/usb/otg.h>
+#include <linux/usb/msm_hsusb_hw.h>
+
+#define MSM_USB_BASE (hcd->regs)
+
+static struct otg_transceiver *otg;
+
+static int ehci_msm_reset(struct usb_hcd *hcd)
+{
+        struct ehci_hcd *ehci = hcd_to_ehci(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);
+        if (retval)
+                return retval;
+
+        /* bursts of unspecified length. */
+        writel(0, USB_AHBBURST);
+        /* Use the AHB transactor */
+        writel(0, USB_AHBMODE);
+        /* Disable streaming mode and select host mode */
+        writel(0x13, USB_USBMODE);
+
+        ehci_port_power(ehci, 1);
+        return 0;
+}
+
+static struct hc_driver msm_hc_driver = {
+        .description            = hcd_name,
+        .product_desc           = "Qualcomm On-Chip EHCI Host Controller",
+        .hcd_priv_size          = sizeof(struct ehci_hcd),
+
+        /*
+         * generic hardware linkage
+         */
+        .irq                    = ehci_irq,
+        .flags                  = HCD_USB2 | HCD_MEMORY,
+
+        .reset                  = ehci_msm_reset,
+        .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,
+        .endpoint_reset         = ehci_endpoint_reset,
+        .clear_tt_buffer_complete = ehci_clear_tt_buffer_complete,
+
+        /*
+         * scheduling support
+         */
+        .get_frame_number       = ehci_get_frame,
+
+        /*
+         * root hub support
+         */
+        .hub_status_data        = ehci_hub_status_data,
+        .hub_control            = ehci_hub_control,
+        .relinquish_port        = ehci_relinquish_port,
+        .port_handed_over       = ehci_port_handed_over,
+
+        /*
+         * PM support
+         */
+        .bus_suspend            = ehci_bus_suspend,
+        .bus_resume             = ehci_bus_resume,
+};
+
+static int ehci_msm_probe(struct platform_device *pdev)
+{
+        struct usb_hcd *hcd;
+        struct resource *res;
+        int ret;
+
+        dev_dbg(&pdev->dev, "ehci_msm proble\n");
+
+        hcd = usb_create_hcd(&msm_hc_driver, &pdev->dev, dev_name(&pdev->dev));
+        if (!hcd) {
+                dev_err(&pdev->dev, "Unable to create HCD\n");
+                return  -ENOMEM;
+        }
+
+        hcd->irq = platform_get_irq(pdev, 0);
+        if (hcd->irq < 0) {
+                dev_err(&pdev->dev, "Unable to get IRQ resource\n");
+                ret = hcd->irq;
+                goto put_hcd;
+        }
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(&pdev->dev, "Unable to get memory resource\n");
+                ret = -ENODEV;
+                goto put_hcd;
+        }
+
+        hcd->rsrc_start = res->start;
+        hcd->rsrc_len = resource_size(res);
+        hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
+        if (!hcd->regs) {
+                dev_err(&pdev->dev, "ioremap failed\n");
+                ret = -ENOMEM;
+                goto put_hcd;
+        }
+
+        /*
+         * OTG driver takes care of PHY initialization, clock management,
+         * powering up VBUS, mapping of registers address space and power
+         * management.
+         */
+        otg = otg_get_transceiver();
+        if (!otg) {
+                dev_err(&pdev->dev, "unable to find transceiver\n");
+                ret = -ENODEV;
+                goto unmap;
+        }
+
+        ret = otg_set_host(otg, &hcd->self);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "unable to register with transceiver\n");
+                goto put_transceiver;
+        }
+
+        device_init_wakeup(&pdev->dev, 1);
+        /*
+         * OTG device parent of HCD takes care of putting
+         * hardware into low power mode.
+         */
+        pm_runtime_no_callbacks(&pdev->dev);
+        pm_runtime_enable(&pdev->dev);
+
+        return 0;
+
+put_transceiver:
+        otg_put_transceiver(otg);
+unmap:
+        iounmap(hcd->regs);
+put_hcd:
+        usb_put_hcd(hcd);
+
+        return ret;
+}
+
+static int __devexit ehci_msm_remove(struct platform_device *pdev)
+{
+        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+
+        device_init_wakeup(&pdev->dev, 0);
+        pm_runtime_disable(&pdev->dev);
+        pm_runtime_set_suspended(&pdev->dev);
+
+        otg_set_host(otg, NULL);
+        otg_put_transceiver(otg);
+
+        usb_put_hcd(hcd);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int ehci_msm_pm_suspend(struct device *dev)
+{
+        struct usb_hcd *hcd = dev_get_drvdata(dev);
+        bool wakeup = device_may_wakeup(dev);
+
+        dev_dbg(dev, "ehci-msm PM suspend\n");
+
+        /*
+         * EHCI helper function has also the same check before manipulating
+         * port wakeup flags.  We do check here the same condition before
+         * calling the same helper function to avoid bringing hardware
+         * from Low power mode when there is no need for adjusting port
+         * wakeup flags.
+         */
+        if (hcd->self.root_hub->do_remote_wakeup && !wakeup) {
+                pm_runtime_resume(dev);
+                ehci_prepare_ports_for_controller_suspend(hcd_to_ehci(hcd),
+                                wakeup);
+        }
+
+        return 0;
+}
+
+static int ehci_msm_pm_resume(struct device *dev)
+{
+        struct usb_hcd *hcd = dev_get_drvdata(dev);
+
+        dev_dbg(dev, "ehci-msm PM resume\n");
+        ehci_prepare_ports_for_controller_resume(hcd_to_ehci(hcd));
+
+        return 0;
+}
+#else
+#define ehci_msm_pm_suspend     NULL
+#define ehci_msm_pm_resume      NULL
+#endif
+
+static const struct dev_pm_ops ehci_msm_dev_pm_ops = {
+        .suspend         = ehci_msm_pm_suspend,
+        .resume          = ehci_msm_pm_resume,
+};
+
+static struct platform_driver ehci_msm_driver = {
+        .probe  = ehci_msm_probe,
+        .remove = __devexit_p(ehci_msm_remove),
+        .driver = {
+                   .name = "msm_hsusb_host",
+                   .pm = &ehci_msm_dev_pm_ops,
+        },
+};
diff --git a/drivers/usb/host/ehci-mxc.c b/drivers/usb/host/ehci-mxc.c
index a8ad8ac120a2..0c058be35a38 100644
--- a/drivers/usb/host/ehci-mxc.c
+++ b/drivers/usb/host/ehci-mxc.c
@@ -21,17 +21,17 @@
 #include <linux/clk.h>
 #include <linux/delay.h>
 #include <linux/usb/otg.h>
+#include <linux/usb/ulpi.h>
 #include <linux/slab.h>
 
 #include <mach/mxc_ehci.h>
 
+#include <asm/mach-types.h>
+
 #define ULPI_VIEWPORT_OFFSET    0x170
-#define PORTSC_OFFSET           0x184
-#define USBMODE_OFFSET          0x1a8
-#define USBMODE_CM_HOST         3
 
 struct ehci_mxc_priv {
-        struct clk *usbclk, *ahbclk;
+        struct clk *usbclk, *ahbclk, *phy1clk;
         struct usb_hcd *hcd;
 };
 
@@ -41,16 +41,14 @@ static int ehci_mxc_setup(struct usb_hcd *hcd)
         struct ehci_hcd *ehci = hcd_to_ehci(hcd);
         int retval;
 
-        /* EHCI registers start at offset 0x100 */
-        ehci->caps = hcd->regs + 0x100;
-        ehci->regs = hcd->regs + 0x100 +
-            HC_LENGTH(ehci_readl(ehci, &ehci->caps->hc_capbase));
         dbg_hcs_params(ehci, "reset");
         dbg_hcc_params(ehci, "reset");
 
         /* cache this readonly data; minimize chip reads */
         ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
 
+        hcd->has_tt = 1;
+
         retval = ehci_halt(ehci);
         if (retval)
                 return retval;
@@ -60,8 +58,6 @@ static int ehci_mxc_setup(struct usb_hcd *hcd)
         if (retval)
                 return retval;
 
-        hcd->has_tt = 1;
-
         ehci->sbrn = 0x20;
 
         ehci_reset(ehci);
@@ -95,6 +91,7 @@ static const struct hc_driver ehci_mxc_hc_driver = {
         .urb_enqueue = ehci_urb_enqueue,
         .urb_dequeue = ehci_urb_dequeue,
         .endpoint_disable = ehci_endpoint_disable,
+        .endpoint_reset = ehci_endpoint_reset,
 
         /*
          * scheduling support
@@ -110,6 +107,8 @@ static const struct hc_driver ehci_mxc_hc_driver = {
         .bus_resume = ehci_bus_resume,
         .relinquish_port = ehci_relinquish_port,
         .port_handed_over = ehci_port_handed_over,
+
+        .clear_tt_buffer_complete = ehci_clear_tt_buffer_complete,
 };
 
 static int ehci_mxc_drv_probe(struct platform_device *pdev)
@@ -117,9 +116,11 @@ static int ehci_mxc_drv_probe(struct platform_device *pdev)
         struct mxc_usbh_platform_data *pdata = pdev->dev.platform_data;
         struct usb_hcd *hcd;
         struct resource *res;
-        int irq, ret, temp;
+        int irq, ret;
+        unsigned int flags;
         struct ehci_mxc_priv *priv;
         struct device *dev = &pdev->dev;
+        struct ehci_hcd *ehci;
 
         dev_info(&pdev->dev, "initializing i.MX USB Controller\n");
 
@@ -163,17 +164,6 @@ static int ehci_mxc_drv_probe(struct platform_device *pdev)
                 goto err_ioremap;
         }
 
-        /* call platform specific init function */
-        if (pdata->init) {
-                ret = pdata->init(pdev);
-                if (ret) {
-                        dev_err(dev, "platform init failed\n");
-                        goto err_init;
-                }
-                /* platforms need some time to settle changed IO settings */
-                mdelay(10);
-        }
-
         /* enable clocks */
         priv->usbclk = clk_get(dev, "usb");
         if (IS_ERR(priv->usbclk)) {
@@ -191,18 +181,40 @@ static int ehci_mxc_drv_probe(struct platform_device *pdev)
                 clk_enable(priv->ahbclk);
         }
 
-        /* set USBMODE to host mode */
-        temp = readl(hcd->regs + USBMODE_OFFSET);
-        writel(temp | USBMODE_CM_HOST, hcd->regs + USBMODE_OFFSET);
+        /* "dr" device has its own clock on i.MX51 */
+        if (cpu_is_mx51() && (pdev->id == 0)) {
+                priv->phy1clk = clk_get(dev, "usb_phy1");
+                if (IS_ERR(priv->phy1clk)) {
+                        ret = PTR_ERR(priv->phy1clk);
+                        goto err_clk_phy;
+                }
+                clk_enable(priv->phy1clk);
+        }
+
+
+        /* call platform specific init function */
+        if (pdata->init) {
+                ret = pdata->init(pdev);
+                if (ret) {
+                        dev_err(dev, "platform init failed\n");
+                        goto err_init;
+                }
+                /* platforms need some time to settle changed IO settings */
+                mdelay(10);
+        }
+
+        ehci = hcd_to_ehci(hcd);
+
+        /* EHCI registers start at offset 0x100 */
+        ehci->caps = hcd->regs + 0x100;
+        ehci->regs = hcd->regs + 0x100 +
+                HC_LENGTH(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
 
         /* set up the PORTSCx register */
-        writel(pdata->portsc, hcd->regs + PORTSC_OFFSET);
-        mdelay(10);
+        ehci_writel(ehci, pdata->portsc, &ehci->regs->port_status[0]);
 
-        /* setup specific usb hw */
-        ret = mxc_initialize_usb_hw(pdev->id, pdata->flags);
-        if (ret < 0)
-                goto err_init;
+        /* is this really needed? */
+        msleep(10);
 
         /* Initialize the transceiver */
         if (pdata->otg) {
@@ -227,12 +239,34 @@ static int ehci_mxc_drv_probe(struct platform_device *pdev)
         if (ret)
                 goto err_add;
 
+        if (pdata->otg) {
+                /*
+                 * efikamx and efikasb have some hardware bug which is
+                 * preventing usb to work unless CHRGVBUS is set.
+                 * It's in violation of USB specs
+                 */
+                if (machine_is_mx51_efikamx() || machine_is_mx51_efikasb()) {
+                        flags = otg_io_read(pdata->otg, ULPI_OTG_CTRL);
+                        flags |= ULPI_OTG_CTRL_CHRGVBUS;
+                        ret = otg_io_write(pdata->otg, flags, ULPI_OTG_CTRL);
+                        if (ret) {
+                                dev_err(dev, "unable to set CHRVBUS\n");
+                                goto err_add;
+                        }
+                }
+        }
+
         return 0;
 
 err_add:
         if (pdata && pdata->exit)
                 pdata->exit(pdev);
 err_init:
+        if (priv->phy1clk) {
+                clk_disable(priv->phy1clk);
+                clk_put(priv->phy1clk);
+        }
+err_clk_phy:
         if (priv->ahbclk) {
                 clk_disable(priv->ahbclk);
                 clk_put(priv->ahbclk);
@@ -276,6 +310,10 @@ static int __exit ehci_mxc_drv_remove(struct platform_device *pdev)
                 clk_disable(priv->ahbclk);
                 clk_put(priv->ahbclk);
         }
+        if (priv->phy1clk) {
+                clk_disable(priv->phy1clk);
+                clk_put(priv->phy1clk);
+        }
 
         kfree(priv);
 
diff --git a/drivers/usb/host/ehci-octeon.c b/drivers/usb/host/ehci-octeon.c
new file mode 100644
index 000000000000..ff55757ba7d8
--- /dev/null
+++ b/drivers/usb/host/ehci-octeon.c
@@ -0,0 +1,207 @@
+/*
+ * EHCI HCD glue for Cavium Octeon II SOCs.
+ *
+ * Loosely based on ehci-au1xxx.c
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ * Copyright (C) 2010 Cavium Networks
+ *
+ */
+
+#include <linux/platform_device.h>
+
+#include <asm/octeon/octeon.h>
+#include <asm/octeon/cvmx-uctlx-defs.h>
+
+#define OCTEON_EHCI_HCD_NAME "octeon-ehci"
+
+/* Common clock init code.  */
+void octeon2_usb_clocks_start(void);
+void octeon2_usb_clocks_stop(void);
+
+static void ehci_octeon_start(void)
+{
+        union cvmx_uctlx_ehci_ctl ehci_ctl;
+
+        octeon2_usb_clocks_start();
+
+        ehci_ctl.u64 = cvmx_read_csr(CVMX_UCTLX_EHCI_CTL(0));
+        /* Use 64-bit addressing. */
+        ehci_ctl.s.ehci_64b_addr_en = 1;
+        ehci_ctl.s.l2c_addr_msb = 0;
+        ehci_ctl.s.l2c_buff_emod = 1; /* Byte swapped. */
+        ehci_ctl.s.l2c_desc_emod = 1; /* Byte swapped. */
+        cvmx_write_csr(CVMX_UCTLX_EHCI_CTL(0), ehci_ctl.u64);
+}
+
+static void ehci_octeon_stop(void)
+{
+        octeon2_usb_clocks_stop();
+}
+
+static const struct hc_driver ehci_octeon_hc_driver = {
+        .description            = hcd_name,
+        .product_desc           = "Octeon EHCI",
+        .hcd_priv_size          = sizeof(struct ehci_hcd),
+
+        /*
+         * generic hardware linkage
+         */
+        .irq                    = ehci_irq,
+        .flags                  = HCD_MEMORY | HCD_USB2,
+
+        /*
+         * basic lifecycle operations
+         */
+        .reset                  = ehci_init,
+        .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,
+        .endpoint_reset         = ehci_endpoint_reset,
+
+        /*
+         * 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,
+
+        .clear_tt_buffer_complete       = ehci_clear_tt_buffer_complete,
+};
+
+static u64 ehci_octeon_dma_mask = DMA_BIT_MASK(64);
+
+static int ehci_octeon_drv_probe(struct platform_device *pdev)
+{
+        struct usb_hcd *hcd;
+        struct ehci_hcd *ehci;
+        struct resource *res_mem;
+        int irq;
+        int ret;
+
+        if (usb_disabled())
+                return -ENODEV;
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0) {
+                dev_err(&pdev->dev, "No irq assigned\n");
+                return -ENODEV;
+        }
+
+        res_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (res_mem == NULL) {
+                dev_err(&pdev->dev, "No register space assigned\n");
+                return -ENODEV;
+        }
+
+        /*
+         * We can DMA from anywhere. But the descriptors must be in
+         * the lower 4GB.
+         */
+        pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
+        pdev->dev.dma_mask = &ehci_octeon_dma_mask;
+
+        hcd = usb_create_hcd(&ehci_octeon_hc_driver, &pdev->dev, "octeon");
+        if (!hcd)
+                return -ENOMEM;
+
+        hcd->rsrc_start = res_mem->start;
+        hcd->rsrc_len = res_mem->end - res_mem->start + 1;
+
+        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len,
+                                OCTEON_EHCI_HCD_NAME)) {
+                dev_err(&pdev->dev, "request_mem_region failed\n");
+                ret = -EBUSY;
+                goto err1;
+        }
+
+        hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
+        if (!hcd->regs) {
+                dev_err(&pdev->dev, "ioremap failed\n");
+                ret = -ENOMEM;
+                goto err2;
+        }
+
+        ehci_octeon_start();
+
+        ehci = hcd_to_ehci(hcd);
+
+        /* Octeon EHCI matches CPU endianness. */
+#ifdef __BIG_ENDIAN
+        ehci->big_endian_mmio = 1;
+#endif
+
+        ehci->caps = hcd->regs;
+        ehci->regs = hcd->regs +
+                HC_LENGTH(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
+        /* cache this readonly data; minimize chip reads */
+        ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
+
+        ret = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
+        if (ret) {
+                dev_dbg(&pdev->dev, "failed to add hcd with err %d\n", ret);
+                goto err3;
+        }
+
+        platform_set_drvdata(pdev, hcd);
+
+        /* root ports should always stay powered */
+        ehci_port_power(ehci, 1);
+
+        return 0;
+err3:
+        ehci_octeon_stop();
+
+        iounmap(hcd->regs);
+err2:
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+err1:
+        usb_put_hcd(hcd);
+        return ret;
+}
+
+static int ehci_octeon_drv_remove(struct platform_device *pdev)
+{
+        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+
+        usb_remove_hcd(hcd);
+
+        ehci_octeon_stop();
+        iounmap(hcd->regs);
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+        usb_put_hcd(hcd);
+
+        platform_set_drvdata(pdev, NULL);
+
+        return 0;
+}
+
+static struct platform_driver ehci_octeon_driver = {
+        .probe          = ehci_octeon_drv_probe,
+        .remove         = ehci_octeon_drv_remove,
+        .shutdown       = usb_hcd_platform_shutdown,
+        .driver = {
+                .name   = OCTEON_EHCI_HCD_NAME,
+                .owner  = THIS_MODULE,
+        }
+};
+
+MODULE_ALIAS("platform:" OCTEON_EHCI_HCD_NAME);
diff --git a/drivers/usb/host/ehci-omap.c b/drivers/usb/host/ehci-omap.c
index 116ae280053a..55a57c23dd0f 100644
--- a/drivers/usb/host/ehci-omap.c
+++ b/drivers/usb/host/ehci-omap.c
@@ -1,11 +1,13 @@
 /*
- * ehci-omap.c - driver for USBHOST on OMAP 34xx processor
+ * ehci-omap.c - driver for USBHOST on OMAP3/4 processors
  *
- * Bus Glue for OMAP34xx USBHOST 3 port EHCI controller
- * Tested on OMAP3430 ES2.0 SDP
+ * Bus Glue for the EHCI controllers in OMAP3/4
+ * Tested on several OMAP3 boards, and OMAP4 Pandaboard
  *
- * Copyright (C) 2007-2008 Texas Instruments, Inc.
+ * Copyright (C) 2007-2011 Texas Instruments, Inc.
  *      Author: Vikram Pandita <vikram.pandita@ti.com>
+ *      Author: Anand Gadiyar <gadiyar@ti.com>
+ *      Author: Keshava Munegowda <keshava_mgowda@ti.com>
  *
  * Copyright (C) 2009 Nokia Corporation
  *      Contact: Felipe Balbi <felipe.balbi@nokia.com>
@@ -26,95 +28,19 @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  *
- * TODO (last updated Feb 12, 2010):
+ * TODO (last updated Feb 27, 2010):
  *      - add kernel-doc
  *      - enable AUTOIDLE
  *      - add suspend/resume
- *      - move workarounds to board-files
+ *      - add HSIC and TLL support
+ *      - convert to use hwmod and runtime PM
  */
 
 #include <linux/platform_device.h>
-#include <linux/clk.h>
-#include <linux/gpio.h>
-#include <linux/regulator/consumer.h>
 #include <linux/slab.h>
 #include <linux/usb/ulpi.h>
 #include <plat/usb.h>
-
-/*
- * OMAP USBHOST Register addresses: VIRTUAL ADDRESSES
- *      Use ehci_omap_readl()/ehci_omap_writel() functions
- */
-
-/* TLL Register Set */
-#define OMAP_USBTLL_REVISION                            (0x00)
-#define OMAP_USBTLL_SYSCONFIG                           (0x10)
-#define OMAP_USBTLL_SYSCONFIG_CACTIVITY                 (1 << 8)
-#define OMAP_USBTLL_SYSCONFIG_SIDLEMODE                 (1 << 3)
-#define OMAP_USBTLL_SYSCONFIG_ENAWAKEUP                 (1 << 2)
-#define OMAP_USBTLL_SYSCONFIG_SOFTRESET                 (1 << 1)
-#define OMAP_USBTLL_SYSCONFIG_AUTOIDLE                  (1 << 0)
-
-#define OMAP_USBTLL_SYSSTATUS                           (0x14)
-#define OMAP_USBTLL_SYSSTATUS_RESETDONE                 (1 << 0)
-
-#define OMAP_USBTLL_IRQSTATUS                           (0x18)
-#define OMAP_USBTLL_IRQENABLE                           (0x1C)
-
-#define OMAP_TLL_SHARED_CONF                            (0x30)
-#define OMAP_TLL_SHARED_CONF_USB_90D_DDR_EN             (1 << 6)
-#define OMAP_TLL_SHARED_CONF_USB_180D_SDR_EN            (1 << 5)
-#define OMAP_TLL_SHARED_CONF_USB_DIVRATION              (1 << 2)
-#define OMAP_TLL_SHARED_CONF_FCLK_REQ                   (1 << 1)
-#define OMAP_TLL_SHARED_CONF_FCLK_IS_ON                 (1 << 0)
-
-#define OMAP_TLL_CHANNEL_CONF(num)                      (0x040 + 0x004 * num)
-#define OMAP_TLL_CHANNEL_CONF_ULPINOBITSTUFF            (1 << 11)
-#define OMAP_TLL_CHANNEL_CONF_ULPI_ULPIAUTOIDLE         (1 << 10)
-#define OMAP_TLL_CHANNEL_CONF_UTMIAUTOIDLE              (1 << 9)
-#define OMAP_TLL_CHANNEL_CONF_ULPIDDRMODE               (1 << 8)
-#define OMAP_TLL_CHANNEL_CONF_CHANEN                    (1 << 0)
-
-#define OMAP_TLL_ULPI_FUNCTION_CTRL(num)                (0x804 + 0x100 * num)
-#define OMAP_TLL_ULPI_INTERFACE_CTRL(num)               (0x807 + 0x100 * num)
-#define OMAP_TLL_ULPI_OTG_CTRL(num)                     (0x80A + 0x100 * num)
-#define OMAP_TLL_ULPI_INT_EN_RISE(num)                  (0x80D + 0x100 * num)
-#define OMAP_TLL_ULPI_INT_EN_FALL(num)                  (0x810 + 0x100 * num)
-#define OMAP_TLL_ULPI_INT_STATUS(num)                   (0x813 + 0x100 * num)
-#define OMAP_TLL_ULPI_INT_LATCH(num)                    (0x814 + 0x100 * num)
-#define OMAP_TLL_ULPI_DEBUG(num)                        (0x815 + 0x100 * num)
-#define OMAP_TLL_ULPI_SCRATCH_REGISTER(num)             (0x816 + 0x100 * num)
-
-#define OMAP_TLL_CHANNEL_COUNT                          3
-#define OMAP_TLL_CHANNEL_1_EN_MASK                      (1 << 1)
-#define OMAP_TLL_CHANNEL_2_EN_MASK                      (1 << 2)
-#define OMAP_TLL_CHANNEL_3_EN_MASK                      (1 << 4)
-
-/* UHH Register Set */
-#define OMAP_UHH_REVISION                               (0x00)
-#define OMAP_UHH_SYSCONFIG                              (0x10)
-#define OMAP_UHH_SYSCONFIG_MIDLEMODE                    (1 << 12)
-#define OMAP_UHH_SYSCONFIG_CACTIVITY                    (1 << 8)
-#define OMAP_UHH_SYSCONFIG_SIDLEMODE                    (1 << 3)
-#define OMAP_UHH_SYSCONFIG_ENAWAKEUP                    (1 << 2)
-#define OMAP_UHH_SYSCONFIG_SOFTRESET                    (1 << 1)
-#define OMAP_UHH_SYSCONFIG_AUTOIDLE                     (1 << 0)
-
-#define OMAP_UHH_SYSSTATUS                              (0x14)
-#define OMAP_UHH_HOSTCONFIG                             (0x40)
-#define OMAP_UHH_HOSTCONFIG_ULPI_BYPASS                 (1 << 0)
-#define OMAP_UHH_HOSTCONFIG_ULPI_P1_BYPASS              (1 << 0)
-#define OMAP_UHH_HOSTCONFIG_ULPI_P2_BYPASS              (1 << 11)
-#define OMAP_UHH_HOSTCONFIG_ULPI_P3_BYPASS              (1 << 12)
-#define OMAP_UHH_HOSTCONFIG_INCR4_BURST_EN              (1 << 2)
-#define OMAP_UHH_HOSTCONFIG_INCR8_BURST_EN              (1 << 3)
-#define OMAP_UHH_HOSTCONFIG_INCR16_BURST_EN             (1 << 4)
-#define OMAP_UHH_HOSTCONFIG_INCRX_ALIGN_EN              (1 << 5)
-#define OMAP_UHH_HOSTCONFIG_P1_CONNECT_STATUS           (1 << 8)
-#define OMAP_UHH_HOSTCONFIG_P2_CONNECT_STATUS           (1 << 9)
-#define OMAP_UHH_HOSTCONFIG_P3_CONNECT_STATUS           (1 << 10)
-
-#define OMAP_UHH_DEBUG_CSR                              (0x44)
+#include <linux/regulator/consumer.h>
 
 /* EHCI Register Set */
 #define EHCI_INSNREG04                                  (0xA0)
@@ -129,116 +55,22 @@
 
 /*-------------------------------------------------------------------------*/
 
-static inline void ehci_omap_writel(void __iomem *base, u32 reg, u32 val)
-{
-        __raw_writel(val, base + reg);
-}
+static const struct hc_driver ehci_omap_hc_driver;
 
-static inline u32 ehci_omap_readl(void __iomem *base, u32 reg)
-{
-        return __raw_readl(base + reg);
-}
 
-static inline void ehci_omap_writeb(void __iomem *base, u8 reg, u8 val)
+static inline void ehci_write(void __iomem *base, u32 reg, u32 val)
 {
-        __raw_writeb(val, base + reg);
+        __raw_writel(val, base + reg);
 }
 
-static inline u8 ehci_omap_readb(void __iomem *base, u8 reg)
+static inline u32 ehci_read(void __iomem *base, u32 reg)
 {
-        return __raw_readb(base + reg);
-}
-
-/*-------------------------------------------------------------------------*/
-
-struct ehci_hcd_omap {
-        struct ehci_hcd         *ehci;
-        struct device           *dev;
-
-        struct clk              *usbhost_ick;
-        struct clk              *usbhost2_120m_fck;
-        struct clk              *usbhost1_48m_fck;
-        struct clk              *usbtll_fck;
-        struct clk              *usbtll_ick;
-
-        /* FIXME the following two workarounds are
-         * board specific not silicon-specific so these
-         * should be moved to board-file instead.
-         *
-         * Maybe someone from TI will know better which
-         * board is affected and needs the workarounds
-         * to be applied
-         */
-
-        /* gpio for resetting phy */
-        int                     reset_gpio_port[OMAP3_HS_USB_PORTS];
-
-        /* phy reset workaround */
-        int                     phy_reset;
-
-        /* desired phy_mode: TLL, PHY */
-        enum ehci_hcd_omap_mode port_mode[OMAP3_HS_USB_PORTS];
-
-        void __iomem            *uhh_base;
-        void __iomem            *tll_base;
-        void __iomem            *ehci_base;
-
-        /* Regulators for USB PHYs.
-         * Each PHY can have a separate regulator.
-         */
-        struct regulator        *regulator[OMAP3_HS_USB_PORTS];
-};
-
-/*-------------------------------------------------------------------------*/
-
-static void omap_usb_utmi_init(struct ehci_hcd_omap *omap, u8 tll_channel_mask)
-{
-        unsigned reg;
-        int i;
-
-        /* Program the 3 TLL channels upfront */
-        for (i = 0; i < OMAP_TLL_CHANNEL_COUNT; i++) {
-                reg = ehci_omap_readl(omap->tll_base, OMAP_TLL_CHANNEL_CONF(i));
-
-                /* Disable AutoIdle, BitStuffing and use SDR Mode */
-                reg &= ~(OMAP_TLL_CHANNEL_CONF_UTMIAUTOIDLE
-                                | OMAP_TLL_CHANNEL_CONF_ULPINOBITSTUFF
-                                | OMAP_TLL_CHANNEL_CONF_ULPIDDRMODE);
-                ehci_omap_writel(omap->tll_base, OMAP_TLL_CHANNEL_CONF(i), reg);
-        }
-
-        /* Program Common TLL register */
-        reg = ehci_omap_readl(omap->tll_base, OMAP_TLL_SHARED_CONF);
-        reg |= (OMAP_TLL_SHARED_CONF_FCLK_IS_ON
-                        | OMAP_TLL_SHARED_CONF_USB_DIVRATION
-                        | OMAP_TLL_SHARED_CONF_USB_180D_SDR_EN);
-        reg &= ~OMAP_TLL_SHARED_CONF_USB_90D_DDR_EN;
-
-        ehci_omap_writel(omap->tll_base, OMAP_TLL_SHARED_CONF, reg);
-
-        /* Enable channels now */
-        for (i = 0; i < OMAP_TLL_CHANNEL_COUNT; i++) {
-                reg = ehci_omap_readl(omap->tll_base, OMAP_TLL_CHANNEL_CONF(i));
-
-                /* Enable only the reg that is needed */
-                if (!(tll_channel_mask & 1<<i))
-                        continue;
-
-                reg |= OMAP_TLL_CHANNEL_CONF_CHANEN;
-                ehci_omap_writel(omap->tll_base, OMAP_TLL_CHANNEL_CONF(i), reg);
-
-                ehci_omap_writeb(omap->tll_base,
-                                OMAP_TLL_ULPI_SCRATCH_REGISTER(i), 0xbe);
-                dev_dbg(omap->dev, "ULPI_SCRATCH_REG[ch=%d]= 0x%02x\n",
-                                i+1, ehci_omap_readb(omap->tll_base,
-                                OMAP_TLL_ULPI_SCRATCH_REGISTER(i)));
-        }
+        return __raw_readl(base + reg);
 }
 
-/*-------------------------------------------------------------------------*/
-
-static void omap_ehci_soft_phy_reset(struct ehci_hcd_omap *omap, u8 port)
+static void omap_ehci_soft_phy_reset(struct platform_device *pdev, u8 port)
 {
+        struct usb_hcd  *hcd = dev_get_drvdata(&pdev->dev);
         unsigned long timeout = jiffies + msecs_to_jiffies(1000);
         unsigned reg = 0;
 
@@ -252,336 +84,20 @@ static void omap_ehci_soft_phy_reset(struct ehci_hcd_omap *omap, u8 port)
                 /* start ULPI access*/
                 | (1 << EHCI_INSNREG05_ULPI_CONTROL_SHIFT);
 
-        ehci_omap_writel(omap->ehci_base, EHCI_INSNREG05_ULPI, reg);
+        ehci_write(hcd->regs, EHCI_INSNREG05_ULPI, reg);
 
         /* Wait for ULPI access completion */
-        while ((ehci_omap_readl(omap->ehci_base, EHCI_INSNREG05_ULPI)
+        while ((ehci_read(hcd->regs, EHCI_INSNREG05_ULPI)
                         & (1 << EHCI_INSNREG05_ULPI_CONTROL_SHIFT))) {
                 cpu_relax();
 
                 if (time_after(jiffies, timeout)) {
-                        dev_dbg(omap->dev, "phy reset operation timed out\n");
+                        dev_dbg(&pdev->dev, "phy reset operation timed out\n");
                         break;
                 }
         }
 }
 
-/* omap_start_ehc
- *      - Start the TI USBHOST controller
- */
-static int omap_start_ehc(struct ehci_hcd_omap *omap, struct usb_hcd *hcd)
-{
-        unsigned long timeout = jiffies + msecs_to_jiffies(1000);
-        u8 tll_ch_mask = 0;
-        unsigned reg = 0;
-        int ret = 0;
-
-        dev_dbg(omap->dev, "starting TI EHCI USB Controller\n");
-
-        /* Enable Clocks for USBHOST */
-        omap->usbhost_ick = clk_get(omap->dev, "usbhost_ick");
-        if (IS_ERR(omap->usbhost_ick)) {
-                ret =  PTR_ERR(omap->usbhost_ick);
-                goto err_host_ick;
-        }
-        clk_enable(omap->usbhost_ick);
-
-        omap->usbhost2_120m_fck = clk_get(omap->dev, "usbhost_120m_fck");
-        if (IS_ERR(omap->usbhost2_120m_fck)) {
-                ret = PTR_ERR(omap->usbhost2_120m_fck);
-                goto err_host_120m_fck;
-        }
-        clk_enable(omap->usbhost2_120m_fck);
-
-        omap->usbhost1_48m_fck = clk_get(omap->dev, "usbhost_48m_fck");
-        if (IS_ERR(omap->usbhost1_48m_fck)) {
-                ret = PTR_ERR(omap->usbhost1_48m_fck);
-                goto err_host_48m_fck;
-        }
-        clk_enable(omap->usbhost1_48m_fck);
-
-        if (omap->phy_reset) {
-                /* Refer: ISSUE1 */
-                if (gpio_is_valid(omap->reset_gpio_port[0])) {
-                        gpio_request(omap->reset_gpio_port[0],
-                                                "USB1 PHY reset");
-                        gpio_direction_output(omap->reset_gpio_port[0], 0);
-                }
-
-                if (gpio_is_valid(omap->reset_gpio_port[1])) {
-                        gpio_request(omap->reset_gpio_port[1],
-                                                "USB2 PHY reset");
-                        gpio_direction_output(omap->reset_gpio_port[1], 0);
-                }
-
-                /* Hold the PHY in RESET for enough time till DIR is high */
-                udelay(10);
-        }
-
-        /* Configure TLL for 60Mhz clk for ULPI */
-        omap->usbtll_fck = clk_get(omap->dev, "usbtll_fck");
-        if (IS_ERR(omap->usbtll_fck)) {
-                ret = PTR_ERR(omap->usbtll_fck);
-                goto err_tll_fck;
-        }
-        clk_enable(omap->usbtll_fck);
-
-        omap->usbtll_ick = clk_get(omap->dev, "usbtll_ick");
-        if (IS_ERR(omap->usbtll_ick)) {
-                ret = PTR_ERR(omap->usbtll_ick);
-                goto err_tll_ick;
-        }
-        clk_enable(omap->usbtll_ick);
-
-        /* perform TLL soft reset, and wait until reset is complete */
-        ehci_omap_writel(omap->tll_base, OMAP_USBTLL_SYSCONFIG,
-                        OMAP_USBTLL_SYSCONFIG_SOFTRESET);
-
-        /* Wait for TLL reset to complete */
-        while (!(ehci_omap_readl(omap->tll_base, OMAP_USBTLL_SYSSTATUS)
-                        & OMAP_USBTLL_SYSSTATUS_RESETDONE)) {
-                cpu_relax();
-
-                if (time_after(jiffies, timeout)) {
-                        dev_dbg(omap->dev, "operation timed out\n");
-                        ret = -EINVAL;
-                        goto err_sys_status;
-                }
-        }
-
-        dev_dbg(omap->dev, "TLL RESET DONE\n");
-
-        /* (1<<3) = no idle mode only for initial debugging */
-        ehci_omap_writel(omap->tll_base, OMAP_USBTLL_SYSCONFIG,
-                        OMAP_USBTLL_SYSCONFIG_ENAWAKEUP |
-                        OMAP_USBTLL_SYSCONFIG_SIDLEMODE |
-                        OMAP_USBTLL_SYSCONFIG_CACTIVITY);
-
-
-        /* Put UHH in NoIdle/NoStandby mode */
-        reg = ehci_omap_readl(omap->uhh_base, OMAP_UHH_SYSCONFIG);
-        reg |= (OMAP_UHH_SYSCONFIG_ENAWAKEUP
-                        | OMAP_UHH_SYSCONFIG_SIDLEMODE
-                        | OMAP_UHH_SYSCONFIG_CACTIVITY
-                        | OMAP_UHH_SYSCONFIG_MIDLEMODE);
-        reg &= ~OMAP_UHH_SYSCONFIG_AUTOIDLE;
-
-        ehci_omap_writel(omap->uhh_base, OMAP_UHH_SYSCONFIG, reg);
-
-        reg = ehci_omap_readl(omap->uhh_base, OMAP_UHH_HOSTCONFIG);
-
-        /* setup ULPI bypass and burst configurations */
-        reg |= (OMAP_UHH_HOSTCONFIG_INCR4_BURST_EN
-                        | OMAP_UHH_HOSTCONFIG_INCR8_BURST_EN
-                        | OMAP_UHH_HOSTCONFIG_INCR16_BURST_EN);
-        reg &= ~OMAP_UHH_HOSTCONFIG_INCRX_ALIGN_EN;
-
-        if (omap->port_mode[0] == EHCI_HCD_OMAP_MODE_UNKNOWN)
-                reg &= ~OMAP_UHH_HOSTCONFIG_P1_CONNECT_STATUS;
-        if (omap->port_mode[1] == EHCI_HCD_OMAP_MODE_UNKNOWN)
-                reg &= ~OMAP_UHH_HOSTCONFIG_P2_CONNECT_STATUS;
-        if (omap->port_mode[2] == EHCI_HCD_OMAP_MODE_UNKNOWN)
-                reg &= ~OMAP_UHH_HOSTCONFIG_P3_CONNECT_STATUS;
-
-        /* Bypass the TLL module for PHY mode operation */
-        if (cpu_is_omap3430() && (omap_rev() <= OMAP3430_REV_ES2_1)) {
-                dev_dbg(omap->dev, "OMAP3 ES version <= ES2.1\n");
-                if ((omap->port_mode[0] == EHCI_HCD_OMAP_MODE_PHY) ||
-                        (omap->port_mode[1] == EHCI_HCD_OMAP_MODE_PHY) ||
-                                (omap->port_mode[2] == EHCI_HCD_OMAP_MODE_PHY))
-                        reg &= ~OMAP_UHH_HOSTCONFIG_ULPI_BYPASS;
-                else
-                        reg |= OMAP_UHH_HOSTCONFIG_ULPI_BYPASS;
-        } else {
-                dev_dbg(omap->dev, "OMAP3 ES version > ES2.1\n");
-                if (omap->port_mode[0] == EHCI_HCD_OMAP_MODE_PHY)
-                        reg &= ~OMAP_UHH_HOSTCONFIG_ULPI_P1_BYPASS;
-                else if (omap->port_mode[0] == EHCI_HCD_OMAP_MODE_TLL)
-                        reg |= OMAP_UHH_HOSTCONFIG_ULPI_P1_BYPASS;
-
-                if (omap->port_mode[1] == EHCI_HCD_OMAP_MODE_PHY)
-                        reg &= ~OMAP_UHH_HOSTCONFIG_ULPI_P2_BYPASS;
-                else if (omap->port_mode[1] == EHCI_HCD_OMAP_MODE_TLL)
-                        reg |= OMAP_UHH_HOSTCONFIG_ULPI_P2_BYPASS;
-
-                if (omap->port_mode[2] == EHCI_HCD_OMAP_MODE_PHY)
-                        reg &= ~OMAP_UHH_HOSTCONFIG_ULPI_P3_BYPASS;
-                else if (omap->port_mode[2] == EHCI_HCD_OMAP_MODE_TLL)
-                        reg |= OMAP_UHH_HOSTCONFIG_ULPI_P3_BYPASS;
-
-        }
-        ehci_omap_writel(omap->uhh_base, OMAP_UHH_HOSTCONFIG, reg);
-        dev_dbg(omap->dev, "UHH setup done, uhh_hostconfig=%x\n", reg);
-
-
-        /*
-         * An undocumented "feature" in the OMAP3 EHCI controller,
-         * causes suspended ports to be taken out of suspend when
-         * the USBCMD.Run/Stop bit is cleared (for example when
-         * we do ehci_bus_suspend).
-         * This breaks suspend-resume if the root-hub is allowed
-         * to suspend. Writing 1 to this undocumented register bit
-         * disables this feature and restores normal behavior.
-         */
-        ehci_omap_writel(omap->ehci_base, EHCI_INSNREG04,
-                                EHCI_INSNREG04_DISABLE_UNSUSPEND);
-
-        if ((omap->port_mode[0] == EHCI_HCD_OMAP_MODE_TLL) ||
-                (omap->port_mode[1] == EHCI_HCD_OMAP_MODE_TLL) ||
-                        (omap->port_mode[2] == EHCI_HCD_OMAP_MODE_TLL)) {
-
-                if (omap->port_mode[0] == EHCI_HCD_OMAP_MODE_TLL)
-                        tll_ch_mask |= OMAP_TLL_CHANNEL_1_EN_MASK;
-                if (omap->port_mode[1] == EHCI_HCD_OMAP_MODE_TLL)
-                        tll_ch_mask |= OMAP_TLL_CHANNEL_2_EN_MASK;
-                if (omap->port_mode[2] == EHCI_HCD_OMAP_MODE_TLL)
-                        tll_ch_mask |= OMAP_TLL_CHANNEL_3_EN_MASK;
-
-                /* Enable UTMI mode for required TLL channels */
-                omap_usb_utmi_init(omap, tll_ch_mask);
-        }
-
-        if (omap->phy_reset) {
-                /* Refer ISSUE1:
-                 * Hold the PHY in RESET for enough time till
-                 * PHY is settled and ready
-                 */
-                udelay(10);
-
-                if (gpio_is_valid(omap->reset_gpio_port[0]))
-                        gpio_set_value(omap->reset_gpio_port[0], 1);
-
-                if (gpio_is_valid(omap->reset_gpio_port[1]))
-                        gpio_set_value(omap->reset_gpio_port[1], 1);
-        }
-
-        /* Soft reset the PHY using PHY reset command over ULPI */
-        if (omap->port_mode[0] == EHCI_HCD_OMAP_MODE_PHY)
-                omap_ehci_soft_phy_reset(omap, 0);
-        if (omap->port_mode[1] == EHCI_HCD_OMAP_MODE_PHY)
-                omap_ehci_soft_phy_reset(omap, 1);
-
-        return 0;
-
-err_sys_status:
-        clk_disable(omap->usbtll_ick);
-        clk_put(omap->usbtll_ick);
-
-err_tll_ick:
-        clk_disable(omap->usbtll_fck);
-        clk_put(omap->usbtll_fck);
-
-err_tll_fck:
-        clk_disable(omap->usbhost1_48m_fck);
-        clk_put(omap->usbhost1_48m_fck);
-
-        if (omap->phy_reset) {
-                if (gpio_is_valid(omap->reset_gpio_port[0]))
-                        gpio_free(omap->reset_gpio_port[0]);
-
-                if (gpio_is_valid(omap->reset_gpio_port[1]))
-                        gpio_free(omap->reset_gpio_port[1]);
-        }
-
-err_host_48m_fck:
-        clk_disable(omap->usbhost2_120m_fck);
-        clk_put(omap->usbhost2_120m_fck);
-
-err_host_120m_fck:
-        clk_disable(omap->usbhost_ick);
-        clk_put(omap->usbhost_ick);
-
-err_host_ick:
-        return ret;
-}
-
-static void omap_stop_ehc(struct ehci_hcd_omap *omap, struct usb_hcd *hcd)
-{
-        unsigned long timeout = jiffies + msecs_to_jiffies(100);
-
-        dev_dbg(omap->dev, "stopping TI EHCI USB Controller\n");
-
-        /* Reset OMAP modules for insmod/rmmod to work */
-        ehci_omap_writel(omap->uhh_base, OMAP_UHH_SYSCONFIG,
-                        OMAP_UHH_SYSCONFIG_SOFTRESET);
-        while (!(ehci_omap_readl(omap->uhh_base, OMAP_UHH_SYSSTATUS)
-                                & (1 << 0))) {
-                cpu_relax();
-
-                if (time_after(jiffies, timeout))
-                        dev_dbg(omap->dev, "operation timed out\n");
-        }
-
-        while (!(ehci_omap_readl(omap->uhh_base, OMAP_UHH_SYSSTATUS)
-                                & (1 << 1))) {
-                cpu_relax();
-
-                if (time_after(jiffies, timeout))
-                        dev_dbg(omap->dev, "operation timed out\n");
-        }
-
-        while (!(ehci_omap_readl(omap->uhh_base, OMAP_UHH_SYSSTATUS)
-                                & (1 << 2))) {
-                cpu_relax();
-
-                if (time_after(jiffies, timeout))
-                        dev_dbg(omap->dev, "operation timed out\n");
-        }
-
-        ehci_omap_writel(omap->tll_base, OMAP_USBTLL_SYSCONFIG, (1 << 1));
-
-        while (!(ehci_omap_readl(omap->tll_base, OMAP_USBTLL_SYSSTATUS)
-                                & (1 << 0))) {
-                cpu_relax();
-
-                if (time_after(jiffies, timeout))
-                        dev_dbg(omap->dev, "operation timed out\n");
-        }
-
-        if (omap->usbtll_fck != NULL) {
-                clk_disable(omap->usbtll_fck);
-                clk_put(omap->usbtll_fck);
-                omap->usbtll_fck = NULL;
-        }
-
-        if (omap->usbhost_ick != NULL) {
-                clk_disable(omap->usbhost_ick);
-                clk_put(omap->usbhost_ick);
-                omap->usbhost_ick = NULL;
-        }
-
-        if (omap->usbhost1_48m_fck != NULL) {
-                clk_disable(omap->usbhost1_48m_fck);
-                clk_put(omap->usbhost1_48m_fck);
-                omap->usbhost1_48m_fck = NULL;
-        }
-
-        if (omap->usbhost2_120m_fck != NULL) {
-                clk_disable(omap->usbhost2_120m_fck);
-                clk_put(omap->usbhost2_120m_fck);
-                omap->usbhost2_120m_fck = NULL;
-        }
-
-        if (omap->usbtll_ick != NULL) {
-                clk_disable(omap->usbtll_ick);
-                clk_put(omap->usbtll_ick);
-                omap->usbtll_ick = NULL;
-        }
-
-        if (omap->phy_reset) {
-                if (gpio_is_valid(omap->reset_gpio_port[0]))
-                        gpio_free(omap->reset_gpio_port[0]);
-
-                if (gpio_is_valid(omap->reset_gpio_port[1]))
-                        gpio_free(omap->reset_gpio_port[1]);
-        }
-
-        dev_dbg(omap->dev, "Clock to USB host has been disabled\n");
-}
-
-/*-------------------------------------------------------------------------*/
-
-static const struct hc_driver ehci_omap_hc_driver;
 
 /* configure so an HC device and id are always provided */
 /* always called with process context; sleeping is OK */
@@ -595,155 +111,132 @@ static const struct hc_driver ehci_omap_hc_driver;
  */
 static int ehci_hcd_omap_probe(struct platform_device *pdev)
 {
-        struct ehci_hcd_omap_platform_data *pdata = pdev->dev.platform_data;
-        struct ehci_hcd_omap *omap;
-        struct resource *res;
-        struct usb_hcd *hcd;
-
-        int irq = platform_get_irq(pdev, 0);
-        int ret = -ENODEV;
-        int i;
-        char supply[7];
-
-        if (!pdata) {
-                dev_dbg(&pdev->dev, "missing platform_data\n");
-                goto err_pdata;
-        }
+        struct device                           *dev = &pdev->dev;
+        struct ehci_hcd_omap_platform_data      *pdata = dev->platform_data;
+        struct resource                         *res;
+        struct usb_hcd                          *hcd;
+        void __iomem                            *regs;
+        struct ehci_hcd                         *omap_ehci;
+        int                                     ret = -ENODEV;
+        int                                     irq;
+        int                                     i;
+        char                                    supply[7];
 
         if (usb_disabled())
-                goto err_disabled;
+                return -ENODEV;
 
-        omap = kzalloc(sizeof(*omap), GFP_KERNEL);
-        if (!omap) {
-                ret = -ENOMEM;
-                goto err_disabled;
+        if (!dev->parent) {
+                dev_err(dev, "Missing parent device\n");
+                return -ENODEV;
         }
 
-        hcd = usb_create_hcd(&ehci_omap_hc_driver, &pdev->dev,
-                        dev_name(&pdev->dev));
-        if (!hcd) {
-                dev_dbg(&pdev->dev, "failed to create hcd with err %d\n", ret);
-                ret = -ENOMEM;
-                goto err_create_hcd;
+        irq = platform_get_irq_byname(pdev, "ehci-irq");
+        if (irq < 0) {
+                dev_err(dev, "EHCI irq failed\n");
+                return -ENODEV;
         }
 
-        platform_set_drvdata(pdev, omap);
-        omap->dev               = &pdev->dev;
-        omap->phy_reset         = pdata->phy_reset;
-        omap->reset_gpio_port[0]        = pdata->reset_gpio_port[0];
-        omap->reset_gpio_port[1]        = pdata->reset_gpio_port[1];
-        omap->reset_gpio_port[2]        = pdata->reset_gpio_port[2];
-        omap->port_mode[0]              = pdata->port_mode[0];
-        omap->port_mode[1]              = pdata->port_mode[1];
-        omap->port_mode[2]              = pdata->port_mode[2];
-        omap->ehci              = hcd_to_ehci(hcd);
-        omap->ehci->sbrn        = 0x20;
-
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-
-        hcd->rsrc_start = res->start;
-        hcd->rsrc_len = resource_size(res);
-
-        hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
-        if (!hcd->regs) {
-                dev_err(&pdev->dev, "EHCI ioremap failed\n");
-                ret = -ENOMEM;
-                goto err_ioremap;
+        res =  platform_get_resource_byname(pdev,
+                                IORESOURCE_MEM, "ehci");
+        if (!res) {
+                dev_err(dev, "UHH EHCI get resource failed\n");
+                return -ENODEV;
         }
 
-        /* we know this is the memory we want, no need to ioremap again */
-        omap->ehci->caps = hcd->regs;
-        omap->ehci_base = hcd->regs;
-
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
-        omap->uhh_base = ioremap(res->start, resource_size(res));
-        if (!omap->uhh_base) {
-                dev_err(&pdev->dev, "UHH ioremap failed\n");
-                ret = -ENOMEM;
-                goto err_uhh_ioremap;
+        regs = ioremap(res->start, resource_size(res));
+        if (!regs) {
+                dev_err(dev, "UHH EHCI ioremap failed\n");
+                return -ENOMEM;
         }
 
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 2);
-        omap->tll_base = ioremap(res->start, resource_size(res));
-        if (!omap->tll_base) {
-                dev_err(&pdev->dev, "TLL ioremap failed\n");
+        hcd = usb_create_hcd(&ehci_omap_hc_driver, dev,
+                        dev_name(dev));
+        if (!hcd) {
+                dev_err(dev, "failed to create hcd with err %d\n", ret);
                 ret = -ENOMEM;
-                goto err_tll_ioremap;
+                goto err_io;
         }
 
+        hcd->rsrc_start = res->start;
+        hcd->rsrc_len = resource_size(res);
+        hcd->regs = regs;
+
         /* get ehci regulator and enable */
         for (i = 0 ; i < OMAP3_HS_USB_PORTS ; i++) {
-                if (omap->port_mode[i] != EHCI_HCD_OMAP_MODE_PHY) {
-                        omap->regulator[i] = NULL;
+                if (pdata->port_mode[i] != OMAP_EHCI_PORT_MODE_PHY) {
+                        pdata->regulator[i] = NULL;
                         continue;
                 }
                 snprintf(supply, sizeof(supply), "hsusb%d", i);
-                omap->regulator[i] = regulator_get(omap->dev, supply);
-                if (IS_ERR(omap->regulator[i])) {
-                        omap->regulator[i] = NULL;
-                        dev_dbg(&pdev->dev,
+                pdata->regulator[i] = regulator_get(dev, supply);
+                if (IS_ERR(pdata->regulator[i])) {
+                        pdata->regulator[i] = NULL;
+                        dev_dbg(dev,
                         "failed to get ehci port%d regulator\n", i);
                 } else {
-                        regulator_enable(omap->regulator[i]);
+                        regulator_enable(pdata->regulator[i]);
                 }
         }
 
-        ret = omap_start_ehc(omap, hcd);
+        ret = omap_usbhs_enable(dev);
         if (ret) {
-                dev_dbg(&pdev->dev, "failed to start ehci\n");
-                goto err_start;
+                dev_err(dev, "failed to start usbhs with err %d\n", ret);
+                goto err_enable;
         }
 
-        omap->ehci->regs = hcd->regs
-                + HC_LENGTH(readl(&omap->ehci->caps->hc_capbase));
+        /*
+         * An undocumented "feature" in the OMAP3 EHCI controller,
+         * causes suspended ports to be taken out of suspend when
+         * the USBCMD.Run/Stop bit is cleared (for example when
+         * we do ehci_bus_suspend).
+         * This breaks suspend-resume if the root-hub is allowed
+         * to suspend. Writing 1 to this undocumented register bit
+         * disables this feature and restores normal behavior.
+         */
+        ehci_write(regs, EHCI_INSNREG04,
+                                EHCI_INSNREG04_DISABLE_UNSUSPEND);
+
+        /* Soft reset the PHY using PHY reset command over ULPI */
+        if (pdata->port_mode[0] == OMAP_EHCI_PORT_MODE_PHY)
+                omap_ehci_soft_phy_reset(pdev, 0);
+        if (pdata->port_mode[1] == OMAP_EHCI_PORT_MODE_PHY)
+                omap_ehci_soft_phy_reset(pdev, 1);
+
+        omap_ehci = hcd_to_ehci(hcd);
+        omap_ehci->sbrn = 0x20;
 
-        dbg_hcs_params(omap->ehci, "reset");
-        dbg_hcc_params(omap->ehci, "reset");
+        /* we know this is the memory we want, no need to ioremap again */
+        omap_ehci->caps = hcd->regs;
+        omap_ehci->regs = hcd->regs
+                + HC_LENGTH(ehci, readl(&omap_ehci->caps->hc_capbase));
+
+        dbg_hcs_params(omap_ehci, "reset");
+        dbg_hcc_params(omap_ehci, "reset");
 
         /* cache this readonly data; minimize chip reads */
-        omap->ehci->hcs_params = readl(&omap->ehci->caps->hcs_params);
+        omap_ehci->hcs_params = readl(&omap_ehci->caps->hcs_params);
 
         ret = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
         if (ret) {
-                dev_dbg(&pdev->dev, "failed to add hcd with err %d\n", ret);
+                dev_err(dev, "failed to add hcd with err %d\n", ret);
                 goto err_add_hcd;
         }
 
         /* root ports should always stay powered */
-        ehci_port_power(omap->ehci, 1);
+        ehci_port_power(omap_ehci, 1);
 
         return 0;
 
 err_add_hcd:
-        omap_stop_ehc(omap, hcd);
-
-err_start:
-        for (i = 0 ; i < OMAP3_HS_USB_PORTS ; i++) {
-                if (omap->regulator[i]) {
-                        regulator_disable(omap->regulator[i]);
-                        regulator_put(omap->regulator[i]);
-                }
-        }
-        iounmap(omap->tll_base);
-
-err_tll_ioremap:
-        iounmap(omap->uhh_base);
+        omap_usbhs_disable(dev);
 
-err_uhh_ioremap:
-        iounmap(hcd->regs);
-
-err_ioremap:
+err_enable:
         usb_put_hcd(hcd);
 
-err_create_hcd:
-        kfree(omap);
-err_disabled:
-err_pdata:
+err_io:
         return ret;
 }
 
-/* may be called without controller electrically present */
-/* may be called with controller, bus, and devices active */
 
 /**
  * ehci_hcd_omap_remove - shutdown processing for EHCI HCDs
@@ -755,31 +248,18 @@ err_pdata:
  */
 static int ehci_hcd_omap_remove(struct platform_device *pdev)
 {
-        struct ehci_hcd_omap *omap = platform_get_drvdata(pdev);
-        struct usb_hcd *hcd = ehci_to_hcd(omap->ehci);
-        int i;
+        struct device *dev      = &pdev->dev;
+        struct usb_hcd *hcd     = dev_get_drvdata(dev);
 
         usb_remove_hcd(hcd);
-        omap_stop_ehc(omap, hcd);
-        iounmap(hcd->regs);
-        for (i = 0 ; i < OMAP3_HS_USB_PORTS ; i++) {
-                if (omap->regulator[i]) {
-                        regulator_disable(omap->regulator[i]);
-                        regulator_put(omap->regulator[i]);
-                }
-        }
-        iounmap(omap->tll_base);
-        iounmap(omap->uhh_base);
+        omap_usbhs_disable(dev);
         usb_put_hcd(hcd);
-        kfree(omap);
-
         return 0;
 }
 
 static void ehci_hcd_omap_shutdown(struct platform_device *pdev)
 {
-        struct ehci_hcd_omap *omap = platform_get_drvdata(pdev);
-        struct usb_hcd *hcd = ehci_to_hcd(omap->ehci);
+        struct usb_hcd *hcd = dev_get_drvdata(&pdev->dev);
 
         if (hcd->driver->shutdown)
                 hcd->driver->shutdown(hcd);
diff --git a/drivers/usb/host/ehci-orion.c b/drivers/usb/host/ehci-orion.c
index 0f87dc72820a..395bdb0248d5 100644
--- a/drivers/usb/host/ehci-orion.c
+++ b/drivers/usb/host/ehci-orion.c
@@ -105,7 +105,8 @@ static int ehci_orion_setup(struct usb_hcd *hcd)
         struct ehci_hcd *ehci = hcd_to_ehci(hcd);
         int retval;
 
-        ehci_reset(ehci);
+        hcd->has_tt = 1;
+
         retval = ehci_halt(ehci);
         if (retval)
                 return retval;
@@ -117,7 +118,7 @@ static int ehci_orion_setup(struct usb_hcd *hcd)
         if (retval)
                 return retval;
 
-        hcd->has_tt = 1;
+        ehci_reset(ehci);
 
         ehci_port_power(ehci, 0);
 
@@ -250,7 +251,7 @@ static int __devinit ehci_orion_drv_probe(struct platform_device *pdev)
         ehci = hcd_to_ehci(hcd);
         ehci->caps = hcd->regs + 0x100;
         ehci->regs = hcd->regs + 0x100 +
-                HC_LENGTH(ehci_readl(ehci, &ehci->caps->hc_capbase));
+                HC_LENGTH(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
         ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
         hcd->has_tt = 1;
         ehci->sbrn = 0x20;
diff --git a/drivers/usb/host/ehci-pci.c b/drivers/usb/host/ehci-pci.c
index a1e8d273103f..1102ce65a3a9 100644
--- a/drivers/usb/host/ehci-pci.c
+++ b/drivers/usb/host/ehci-pci.c
@@ -22,6 +22,9 @@
 #error "This file is PCI bus glue.  CONFIG_PCI must be defined."
 #endif
 
+/* defined here to avoid adding to pci_ids.h for single instance use */
+#define PCI_DEVICE_ID_INTEL_CE4100_USB  0x2e70
+
 /*-------------------------------------------------------------------------*/
 
 /* called after powerup, by probe or system-pm "wakeup" */
@@ -67,7 +70,7 @@ static int ehci_pci_setup(struct usb_hcd *hcd)
 
         ehci->caps = hcd->regs;
         ehci->regs = hcd->regs +
-                HC_LENGTH(ehci_readl(ehci, &ehci->caps->hc_capbase));
+                HC_LENGTH(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
 
         dbg_hcs_params(ehci, "reset");
         dbg_hcc_params(ehci, "reset");
@@ -103,6 +106,19 @@ static int ehci_pci_setup(struct usb_hcd *hcd)
         if (retval)
                 return retval;
 
+        if ((pdev->vendor == PCI_VENDOR_ID_AMD && pdev->device == 0x7808) ||
+            (pdev->vendor == PCI_VENDOR_ID_ATI && pdev->device == 0x4396)) {
+                /* EHCI controller on AMD SB700/SB800/Hudson-2/3 platforms may
+                 * read/write memory space which does not belong to it when
+                 * there is NULL pointer with T-bit set to 1 in the frame list
+                 * table. To avoid the issue, the frame list link pointer
+                 * should always contain a valid pointer to a inactive qh.
+                 */
+                ehci->use_dummy_qh = 1;
+                ehci_info(ehci, "applying AMD SB700/SB800/Hudson-2/3 EHCI "
+                                "dummy qh workaround\n");
+        }
+
         /* data structure init */
         retval = ehci_init(hcd);
         if (retval)
@@ -124,6 +140,10 @@ static int ehci_pci_setup(struct usb_hcd *hcd)
                         ehci_info(ehci, "disable lpm for langwell/penwell\n");
                         ehci->has_lpm = 0;
                 }
+                if (pdev->device == PCI_DEVICE_ID_INTEL_CE4100_USB) {
+                        hcd->has_tt = 1;
+                        tdi_reset(ehci);
+                }
                 break;
         case PCI_VENDOR_ID_TDI:
                 if (pdev->device == PCI_DEVICE_ID_TDI_EHCI) {
@@ -132,6 +152,9 @@ static int ehci_pci_setup(struct usb_hcd *hcd)
                 }
                 break;
         case PCI_VENDOR_ID_AMD:
+                /* AMD PLL quirk */
+                if (usb_amd_find_chipset_info())
+                        ehci->amd_pll_fix = 1;
                 /* AMD8111 EHCI doesn't work, according to AMD errata */
                 if (pdev->device == 0x7463) {
                         ehci_info(ehci, "ignoring AMD8111 (errata)\n");
@@ -148,6 +171,18 @@ static int ehci_pci_setup(struct usb_hcd *hcd)
                         if (pdev->revision < 0xa4)
                                 ehci->no_selective_suspend = 1;
                         break;
+
+                /* MCP89 chips on the MacBookAir3,1 give EPROTO when
+                 * fetching device descriptors unless LPM is disabled.
+                 * There are also intermittent problems enumerating
+                 * devices with PPCD enabled.
+                 */
+                case 0x0d9d:
+                        ehci_info(ehci, "disable lpm/ppcd for nvidia mcp89");
+                        ehci->has_lpm = 0;
+                        ehci->has_ppcd = 0;
+                        ehci->command &= ~CMD_PPCEE;
+                        break;
                 }
                 break;
         case PCI_VENDOR_ID_VIA:
@@ -165,6 +200,9 @@ static int ehci_pci_setup(struct usb_hcd *hcd)
                 }
                 break;
         case PCI_VENDOR_ID_ATI:
+                /* AMD PLL quirk */
+                if (usb_amd_find_chipset_info())
+                        ehci->amd_pll_fix = 1;
                 /* SB600 and old version of SB700 have a bug in EHCI controller,
                  * which causes usb devices lose response in some cases.
                  */
@@ -296,8 +334,8 @@ static int ehci_pci_suspend(struct usb_hcd *hcd, bool do_wakeup)
          * mark HW unaccessible.  The PM and USB cores make sure that
          * the root hub is either suspended or stopped.
          */
-        spin_lock_irqsave (&ehci->lock, flags);
         ehci_prepare_ports_for_controller_suspend(ehci, do_wakeup);
+        spin_lock_irqsave (&ehci->lock, flags);
         ehci_writel(ehci, 0, &ehci->regs->intr_enable);
         (void)ehci_readl(ehci, &ehci->regs->intr_enable);
 
@@ -310,11 +348,50 @@ static int ehci_pci_suspend(struct usb_hcd *hcd, bool do_wakeup)
         return rc;
 }
 
+static bool usb_is_intel_switchable_ehci(struct pci_dev *pdev)
+{
+        return pdev->class == PCI_CLASS_SERIAL_USB_EHCI &&
+                pdev->vendor == PCI_VENDOR_ID_INTEL &&
+                pdev->device == 0x1E26;
+}
+
+static void ehci_enable_xhci_companion(void)
+{
+        struct pci_dev          *companion = NULL;
+
+        /* The xHCI and EHCI controllers are not on the same PCI slot */
+        for_each_pci_dev(companion) {
+                if (!usb_is_intel_switchable_xhci(companion))
+                        continue;
+                usb_enable_xhci_ports(companion);
+                return;
+        }
+}
+
 static int ehci_pci_resume(struct usb_hcd *hcd, bool hibernated)
 {
         struct ehci_hcd         *ehci = hcd_to_ehci(hcd);
         struct pci_dev          *pdev = to_pci_dev(hcd->self.controller);
 
+        /* The BIOS on systems with the Intel Panther Point chipset may or may
+         * not support xHCI natively.  That means that during system resume, it
+         * may switch the ports back to EHCI so that users can use their
+         * keyboard to select a kernel from GRUB after resume from hibernate.
+         *
+         * The BIOS is supposed to remember whether the OS had xHCI ports
+         * enabled before resume, and switch the ports back to xHCI when the
+         * BIOS/OS semaphore is written, but we all know we can't trust BIOS
+         * writers.
+         *
+         * Unconditionally switch the ports back to xHCI after a system resume.
+         * We can't tell whether the EHCI or xHCI controller will be resumed
+         * first, so we have to do the port switchover in both drivers.  Writing
+         * a '1' to the port switchover registers should have no effect if the
+         * port was already switched over.
+         */
+        if (usb_is_intel_switchable_ehci(pdev))
+                ehci_enable_xhci_companion();
+
         // maybe restore FLADJ
 
         if (time_before(jiffies, ehci->next_statechange))
diff --git a/drivers/usb/host/ehci-pmcmsp.c b/drivers/usb/host/ehci-pmcmsp.c
new file mode 100644
index 000000000000..cd69099cda19
--- /dev/null
+++ b/drivers/usb/host/ehci-pmcmsp.c
@@ -0,0 +1,383 @@
+/*
+ * PMC MSP EHCI (Host Controller Driver) for USB.
+ *
+ * (C) Copyright 2006-2010 PMC-Sierra Inc
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ */
+
+/* includes */
+#include <linux/platform_device.h>
+#include <linux/gpio.h>
+#include <linux/usb.h>
+#include <msp_usb.h>
+
+/* stream disable*/
+#define USB_CTRL_MODE_STREAM_DISABLE    0x10
+
+/* threshold */
+#define USB_CTRL_FIFO_THRESH            0x00300000
+
+/* register offset for usb_mode */
+#define USB_EHCI_REG_USB_MODE           0x68
+
+/* register offset for usb fifo */
+#define USB_EHCI_REG_USB_FIFO           0x24
+
+/* register offset for usb status */
+#define USB_EHCI_REG_USB_STATUS         0x44
+
+/* serial/parallel transceiver */
+#define USB_EHCI_REG_BIT_STAT_STS       (1<<29)
+
+/* TWI USB0 host device pin */
+#define MSP_PIN_USB0_HOST_DEV           49
+
+/* TWI USB1 host device pin */
+#define MSP_PIN_USB1_HOST_DEV           50
+
+
+static void usb_hcd_tdi_set_mode(struct ehci_hcd *ehci)
+{
+        u8 *base;
+        u8 *statreg;
+        u8 *fiforeg;
+        u32 val;
+        struct ehci_regs *reg_base = ehci->regs;
+
+        /* get register base */
+        base = (u8 *)reg_base + USB_EHCI_REG_USB_MODE;
+        statreg = (u8 *)reg_base + USB_EHCI_REG_USB_STATUS;
+        fiforeg = (u8 *)reg_base + USB_EHCI_REG_USB_FIFO;
+
+        /* Disable controller mode stream */
+        val = ehci_readl(ehci, (u32 *)base);
+        ehci_writel(ehci, (val | USB_CTRL_MODE_STREAM_DISABLE),
+                        (u32 *)base);
+
+        /* clear STS to select parallel transceiver interface */
+        val = ehci_readl(ehci, (u32 *)statreg);
+        val = val & ~USB_EHCI_REG_BIT_STAT_STS;
+        ehci_writel(ehci, val, (u32 *)statreg);
+
+        /* write to set the proper fifo threshold */
+        ehci_writel(ehci, USB_CTRL_FIFO_THRESH, (u32 *)fiforeg);
+
+        /* set TWI GPIO USB_HOST_DEV pin high */
+        gpio_direction_output(MSP_PIN_USB0_HOST_DEV, 1);
+#ifdef CONFIG_MSP_HAS_DUAL_USB
+        gpio_direction_output(MSP_PIN_USB1_HOST_DEV, 1);
+#endif
+}
+
+/* called during probe() after chip reset completes */
+static int ehci_msp_setup(struct usb_hcd *hcd)
+{
+        struct ehci_hcd         *ehci = hcd_to_ehci(hcd);
+        int                     retval;
+        ehci->big_endian_mmio = 1;
+        ehci->big_endian_desc = 1;
+
+        ehci->caps = hcd->regs;
+        ehci->regs = hcd->regs +
+                HC_LENGTH(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
+        dbg_hcs_params(ehci, "reset");
+        dbg_hcc_params(ehci, "reset");
+
+        /* cache this readonly data; minimize chip reads */
+        ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
+        hcd->has_tt = 1;
+
+        retval = ehci_halt(ehci);
+        if (retval)
+                return retval;
+
+        ehci_reset(ehci);
+
+        /* data structure init */
+        retval = ehci_init(hcd);
+        if (retval)
+                return retval;
+
+        usb_hcd_tdi_set_mode(ehci);
+        ehci_port_power(ehci, 0);
+
+        return retval;
+}
+
+
+/* configure so an HC device and id are always provided
+ * always called with process context; sleeping is OK
+ */
+
+static int usb_hcd_msp_map_regs(struct mspusb_device *dev)
+{
+        struct resource *res;
+        struct platform_device *pdev = &dev->dev;
+        u32 res_len;
+        int retval;
+
+        /* MAB register space */
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+        if (res == NULL)
+                return -ENOMEM;
+        res_len = res->end - res->start + 1;
+        if (!request_mem_region(res->start, res_len, "mab regs"))
+                return -EBUSY;
+
+        dev->mab_regs = ioremap_nocache(res->start, res_len);
+        if (dev->mab_regs == NULL) {
+                retval = -ENOMEM;
+                goto err1;
+        }
+
+        /* MSP USB register space */
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 2);
+        if (res == NULL) {
+                retval = -ENOMEM;
+                goto err2;
+        }
+        res_len = res->end - res->start + 1;
+        if (!request_mem_region(res->start, res_len, "usbid regs")) {
+                retval = -EBUSY;
+                goto err2;
+        }
+        dev->usbid_regs = ioremap_nocache(res->start, res_len);
+        if (dev->usbid_regs == NULL) {
+                retval = -ENOMEM;
+                goto err3;
+        }
+
+        return 0;
+err3:
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 2);
+        res_len = res->end - res->start + 1;
+        release_mem_region(res->start, res_len);
+err2:
+        iounmap(dev->mab_regs);
+err1:
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+        res_len = res->end - res->start + 1;
+        release_mem_region(res->start, res_len);
+        dev_err(&pdev->dev, "Failed to map non-EHCI regs.\n");
+        return retval;
+}
+
+/**
+ * usb_hcd_msp_probe - initialize PMC MSP-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_hcd_msp_probe(const struct hc_driver *driver,
+                          struct platform_device *dev)
+{
+        int retval;
+        struct usb_hcd *hcd;
+        struct resource *res;
+        struct ehci_hcd         *ehci ;
+
+        hcd = usb_create_hcd(driver, &dev->dev, "pmcmsp");
+        if (!hcd)
+                return -ENOMEM;
+
+        res = platform_get_resource(dev, IORESOURCE_MEM, 0);
+        if (res == NULL) {
+                pr_debug("No IOMEM resource info for %s.\n", dev->name);
+                retval = -ENOMEM;
+                goto err1;
+        }
+        hcd->rsrc_start = res->start;
+        hcd->rsrc_len = res->end - res->start + 1;
+        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, dev->name)) {
+                retval = -EBUSY;
+                goto err1;
+        }
+        hcd->regs = ioremap_nocache(hcd->rsrc_start, hcd->rsrc_len);
+        if (!hcd->regs) {
+                pr_debug("ioremap failed");
+                retval = -ENOMEM;
+                goto err2;
+        }
+
+        res = platform_get_resource(dev, IORESOURCE_IRQ, 0);
+        if (res == NULL) {
+                dev_err(&dev->dev, "No IRQ resource info for %s.\n", dev->name);
+                retval = -ENOMEM;
+                goto err3;
+        }
+
+        /* Map non-EHCI register spaces */
+        retval = usb_hcd_msp_map_regs(to_mspusb_device(dev));
+        if (retval != 0)
+                goto err3;
+
+        ehci = hcd_to_ehci(hcd);
+        ehci->big_endian_mmio = 1;
+        ehci->big_endian_desc = 1;
+
+
+        retval = usb_add_hcd(hcd, res->start, IRQF_SHARED);
+        if (retval == 0)
+                return 0;
+
+        usb_remove_hcd(hcd);
+err3:
+        iounmap(hcd->regs);
+err2:
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+err1:
+        usb_put_hcd(hcd);
+
+        return retval;
+}
+
+
+
+/**
+ * usb_hcd_msp_remove - shutdown processing for PMC MSP-based HCDs
+ * @dev: USB Host Controller being removed
+ * Context: !in_interrupt()
+ *
+ * Reverses the effect of usb_hcd_msp_probe(), first invoking
+ * the HCD's stop() method.  It is always called from a thread
+ * context, normally "rmmod", "apmd", or something similar.
+ *
+ * may be called without controller electrically present
+ * may be called with controller, bus, and devices active
+ */
+void usb_hcd_msp_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);
+}
+
+#ifdef CONFIG_MSP_HAS_DUAL_USB
+/*
+ * Wrapper around the main ehci_irq.  Since both USB host controllers are
+ * sharing the same IRQ, need to first determine whether we're the intended
+ * recipient of this interrupt.
+ */
+static irqreturn_t ehci_msp_irq(struct usb_hcd *hcd)
+{
+        u32 int_src;
+        struct device *dev = hcd->self.controller;
+        struct platform_device *pdev;
+        struct mspusb_device *mdev;
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        /* need to reverse-map a couple of containers to get our device */
+        pdev = to_platform_device(dev);
+        mdev = to_mspusb_device(pdev);
+
+        /* Check to see if this interrupt is for this host controller */
+        int_src = ehci_readl(ehci, &mdev->mab_regs->int_stat);
+        if (int_src & (1 << pdev->id))
+                return ehci_irq(hcd);
+
+        /* Not for this device */
+        return IRQ_NONE;
+}
+#endif /* DUAL_USB */
+
+static const struct hc_driver ehci_msp_hc_driver = {
+        .description =          hcd_name,
+        .product_desc =         "PMC MSP EHCI",
+        .hcd_priv_size =        sizeof(struct ehci_hcd),
+
+        /*
+         * generic hardware linkage
+         */
+#ifdef CONFIG_MSP_HAS_DUAL_USB
+        .irq =                  ehci_msp_irq,
+#else
+        .irq =                  ehci_irq,
+#endif
+        .flags =                HCD_MEMORY | HCD_USB2,
+
+        /*
+         * basic lifecycle operations
+         */
+        .reset =                ehci_msp_setup,
+        .start =                ehci_run,
+        .shutdown               = ehci_shutdown,
+        .start                  = ehci_run,
+        .stop                   = ehci_stop,
+
+        /*
+         * managing i/o requests and associated device resources
+         */
+        .urb_enqueue            = ehci_urb_enqueue,
+        .urb_dequeue            = ehci_urb_dequeue,
+        .endpoint_disable       = ehci_endpoint_disable,
+        .endpoint_reset         = ehci_endpoint_reset,
+
+        /*
+         * 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,
+
+        .clear_tt_buffer_complete       = ehci_clear_tt_buffer_complete,
+};
+
+static int ehci_hcd_msp_drv_probe(struct platform_device *pdev)
+{
+        int ret;
+
+        pr_debug("In ehci_hcd_msp_drv_probe");
+
+        if (usb_disabled())
+                return -ENODEV;
+
+        gpio_request(MSP_PIN_USB0_HOST_DEV, "USB0_HOST_DEV_GPIO");
+#ifdef CONFIG_MSP_HAS_DUAL_USB
+        gpio_request(MSP_PIN_USB1_HOST_DEV, "USB1_HOST_DEV_GPIO");
+#endif
+
+        ret = usb_hcd_msp_probe(&ehci_msp_hc_driver, pdev);
+
+        return ret;
+}
+
+static int ehci_hcd_msp_drv_remove(struct platform_device *pdev)
+{
+        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+
+        usb_hcd_msp_remove(hcd, pdev);
+
+        /* free TWI GPIO USB_HOST_DEV pin */
+        gpio_free(MSP_PIN_USB0_HOST_DEV);
+#ifdef CONFIG_MSP_HAS_DUAL_USB
+        gpio_free(MSP_PIN_USB1_HOST_DEV);
+#endif
+
+        return 0;
+}
+
+MODULE_ALIAS("pmcmsp-ehci");
+
+static struct platform_driver ehci_hcd_msp_driver = {
+        .probe          = ehci_hcd_msp_drv_probe,
+        .remove         = ehci_hcd_msp_drv_remove,
+        .driver         = {
+                .name   = "pmcmsp-ehci",
+                .owner  = THIS_MODULE,
+        },
+};
diff --git a/drivers/usb/host/ehci-ppc-of.c b/drivers/usb/host/ehci-ppc-of.c
index ba52be473027..8552db6c29c9 100644
--- a/drivers/usb/host/ehci-ppc-of.c
+++ b/drivers/usb/host/ehci-ppc-of.c
@@ -105,8 +105,7 @@ ppc44x_enable_bmt(struct device_node *dn)
 }
 
 
-static int __devinit
-ehci_hcd_ppc_of_probe(struct platform_device *op, const struct of_device_id *match)
+static int __devinit ehci_hcd_ppc_of_probe(struct platform_device *op)
 {
         struct device_node *dn = op->dev.of_node;
         struct usb_hcd *hcd;
@@ -180,7 +179,7 @@ ehci_hcd_ppc_of_probe(struct platform_device *op, const struct of_device_id *mat
 
         ehci->caps = hcd->regs;
         ehci->regs = hcd->regs +
-                        HC_LENGTH(ehci_readl(ehci, &ehci->caps->hc_capbase));
+                HC_LENGTH(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
 
         /* cache this readonly data; minimize chip reads */
         ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
@@ -255,14 +254,12 @@ static int ehci_hcd_ppc_of_remove(struct platform_device *op)
 }
 
 
-static int ehci_hcd_ppc_of_shutdown(struct platform_device *op)
+static void ehci_hcd_ppc_of_shutdown(struct platform_device *op)
 {
         struct usb_hcd *hcd = dev_get_drvdata(&op->dev);
 
         if (hcd->driver->shutdown)
                 hcd->driver->shutdown(hcd);
-
-        return 0;
 }
 
 
@@ -275,7 +272,7 @@ static const struct of_device_id ehci_hcd_ppc_of_match[] = {
 MODULE_DEVICE_TABLE(of, ehci_hcd_ppc_of_match);
 
 
-static struct of_platform_driver ehci_hcd_ppc_of_driver = {
+static struct platform_driver ehci_hcd_ppc_of_driver = {
         .probe          = ehci_hcd_ppc_of_probe,
         .remove         = ehci_hcd_ppc_of_remove,
         .shutdown       = ehci_hcd_ppc_of_shutdown,
diff --git a/drivers/usb/host/ehci-ps3.c b/drivers/usb/host/ehci-ps3.c
index 1dee33b9139e..64626a777d61 100644
--- a/drivers/usb/host/ehci-ps3.c
+++ b/drivers/usb/host/ehci-ps3.c
@@ -29,7 +29,7 @@ static int ps3_ehci_hc_reset(struct usb_hcd *hcd)
         ehci->big_endian_mmio = 1;
 
         ehci->caps = hcd->regs;
-        ehci->regs = hcd->regs + HC_LENGTH(ehci_readl(ehci,
+        ehci->regs = hcd->regs + HC_LENGTH(ehci, ehci_readl(ehci,
                 &ehci->caps->hc_capbase));
 
         dbg_hcs_params(ehci, "reset");
diff --git a/drivers/usb/host/ehci-q.c b/drivers/usb/host/ehci-q.c
index 233c288e3f93..5d6bc624c961 100644
--- a/drivers/usb/host/ehci-q.c
+++ b/drivers/usb/host/ehci-q.c
@@ -315,7 +315,6 @@ qh_completions (struct ehci_hcd *ehci, struct ehci_qh *qh)
         int                     stopped;
         unsigned                count = 0;
         u8                      state;
-        const __le32            halt = HALT_BIT(ehci);
         struct ehci_qh_hw       *hw = qh->hw;
 
         if (unlikely (list_empty (&qh->qtd_list)))
@@ -422,7 +421,6 @@ qh_completions (struct ehci_hcd *ehci, struct ehci_qh *qh)
                                         && !(qtd->hw_alt_next
                                                 & EHCI_LIST_END(ehci))) {
                                 stopped = 1;
-                                goto halt;
                         }
 
                 /* stop scanning when we reach qtds the hc is using */
@@ -456,16 +454,6 @@ qh_completions (struct ehci_hcd *ehci, struct ehci_qh *qh)
                                  */
                                 ehci_clear_tt_buffer(ehci, qh, urb, token);
                         }
-
-                        /* force halt for unlinked or blocked qh, so we'll
-                         * patch the qh later and so that completions can't
-                         * activate it while we "know" it's stopped.
-                         */
-                        if ((halt & hw->hw_token) == 0) {
-halt:
-                                hw->hw_token |= halt;
-                                wmb ();
-                        }
                 }
 
                 /* unless we already know the urb's status, collect qtd status
@@ -838,6 +826,7 @@ qh_make (
                                 is_input, 0,
                                 hb_mult(maxp) * max_packet(maxp)));
                 qh->start = NO_FRAME;
+                qh->stamp = ehci->periodic_stamp;
 
                 if (urb->dev->speed == USB_SPEED_HIGH) {
                         qh->c_usecs = 0;
@@ -1107,22 +1096,24 @@ submit_async (
         struct list_head        *qtd_list,
         gfp_t                   mem_flags
 ) {
-        struct ehci_qtd         *qtd;
         int                     epnum;
         unsigned long           flags;
         struct ehci_qh          *qh = NULL;
         int                     rc;
 
-        qtd = list_entry (qtd_list->next, struct ehci_qtd, qtd_list);
         epnum = urb->ep->desc.bEndpointAddress;
 
 #ifdef EHCI_URB_TRACE
-        ehci_dbg (ehci,
-                "%s %s urb %p ep%d%s len %d, qtd %p [qh %p]\n",
-                __func__, urb->dev->devpath, urb,
-                epnum & 0x0f, (epnum & USB_DIR_IN) ? "in" : "out",
-                urb->transfer_buffer_length,
-                qtd, urb->ep->hcpriv);
+        {
+                struct ehci_qtd *qtd;
+                qtd = list_entry(qtd_list->next, struct ehci_qtd, qtd_list);
+                ehci_dbg(ehci,
+                         "%s %s urb %p ep%d%s len %d, qtd %p [qh %p]\n",
+                         __func__, urb->dev->devpath, urb,
+                         epnum & 0x0f, (epnum & USB_DIR_IN) ? "in" : "out",
+                         urb->transfer_buffer_length,
+                         qtd, urb->ep->hcpriv);
+        }
 #endif
 
         spin_lock_irqsave (&ehci->lock, flags);
@@ -1193,6 +1184,10 @@ static void end_unlink_async (struct ehci_hcd *ehci)
                 ehci->reclaim = NULL;
                 start_unlink_async (ehci, next);
         }
+
+        if (ehci->has_synopsys_hc_bug)
+                ehci_writel(ehci, (u32) ehci->async->qh_dma,
+                            &ehci->regs->async_next);
 }
 
 /* makes sure the async qh will become idle */
@@ -1257,24 +1252,27 @@ static void start_unlink_async (struct ehci_hcd *ehci, struct ehci_qh *qh)
 
 static void scan_async (struct ehci_hcd *ehci)
 {
+        bool                    stopped;
         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)
-                                        && qh->stamp != ehci->stamp) {
+                        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).
+                                 * qhs we already finished (no looping)
+                                 * unless the controller is stopped.
                                  */
                                 qh = qh_get (qh);
                                 qh->stamp = ehci->stamp;
@@ -1295,9 +1293,9 @@ rescan:
                          */
                         if (list_empty(&qh->qtd_list)
                                         && qh->qh_state == QH_STATE_LINKED) {
-                                if (!ehci->reclaim
-                                        && ((ehci->stamp - qh->stamp) & 0x1fff)
-                                                >= (EHCI_SHRINK_FRAMES * 8))
+                                if (!ehci->reclaim && (stopped ||
+                                        ((ehci->stamp - qh->stamp) & 0x1fff)
+                                                >= EHCI_SHRINK_FRAMES * 8))
                                         start_unlink_async(ehci, qh);
                                 else
                                         action = TIMER_ASYNC_SHRINK;
diff --git a/drivers/usb/host/ehci-s5p.c b/drivers/usb/host/ehci-s5p.c
new file mode 100644
index 000000000000..e3374c8f7b3f
--- /dev/null
+++ b/drivers/usb/host/ehci-s5p.c
@@ -0,0 +1,202 @@
+/*
+ * SAMSUNG S5P USB HOST EHCI Controller
+ *
+ * Copyright (C) 2011 Samsung Electronics Co.Ltd
+ * Author: Jingoo Han <jg1.han@samsung.com>
+ * Author: Joonyoung Shim <jy0922.shim@samsung.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 the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ *
+ */
+
+#include <linux/clk.h>
+#include <linux/platform_device.h>
+#include <mach/regs-pmu.h>
+#include <plat/cpu.h>
+#include <plat/ehci.h>
+#include <plat/usb-phy.h>
+
+struct s5p_ehci_hcd {
+        struct device *dev;
+        struct usb_hcd *hcd;
+        struct clk *clk;
+};
+
+static const struct hc_driver s5p_ehci_hc_driver = {
+        .description            = hcd_name,
+        .product_desc           = "S5P EHCI Host Controller",
+        .hcd_priv_size          = sizeof(struct ehci_hcd),
+
+        .irq                    = ehci_irq,
+        .flags                  = HCD_MEMORY | HCD_USB2,
+
+        .reset                  = ehci_init,
+        .start                  = ehci_run,
+        .stop                   = ehci_stop,
+        .shutdown               = ehci_shutdown,
+
+        .get_frame_number       = ehci_get_frame,
+
+        .urb_enqueue            = ehci_urb_enqueue,
+        .urb_dequeue            = ehci_urb_dequeue,
+        .endpoint_disable       = ehci_endpoint_disable,
+        .endpoint_reset         = ehci_endpoint_reset,
+
+        .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,
+
+        .clear_tt_buffer_complete       = ehci_clear_tt_buffer_complete,
+};
+
+static int __devinit s5p_ehci_probe(struct platform_device *pdev)
+{
+        struct s5p_ehci_platdata *pdata;
+        struct s5p_ehci_hcd *s5p_ehci;
+        struct usb_hcd *hcd;
+        struct ehci_hcd *ehci;
+        struct resource *res;
+        int irq;
+        int err;
+
+        pdata = pdev->dev.platform_data;
+        if (!pdata) {
+                dev_err(&pdev->dev, "No platform data defined\n");
+                return -EINVAL;
+        }
+
+        s5p_ehci = kzalloc(sizeof(struct s5p_ehci_hcd), GFP_KERNEL);
+        if (!s5p_ehci)
+                return -ENOMEM;
+
+        s5p_ehci->dev = &pdev->dev;
+
+        hcd = usb_create_hcd(&s5p_ehci_hc_driver, &pdev->dev,
+                                        dev_name(&pdev->dev));
+        if (!hcd) {
+                dev_err(&pdev->dev, "Unable to create HCD\n");
+                err = -ENOMEM;
+                goto fail_hcd;
+        }
+
+        s5p_ehci->clk = clk_get(&pdev->dev, "usbhost");
+
+        if (IS_ERR(s5p_ehci->clk)) {
+                dev_err(&pdev->dev, "Failed to get usbhost clock\n");
+                err = PTR_ERR(s5p_ehci->clk);
+                goto fail_clk;
+        }
+
+        err = clk_enable(s5p_ehci->clk);
+        if (err)
+                goto fail_clken;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(&pdev->dev, "Failed to get I/O memory\n");
+                err = -ENXIO;
+                goto fail_io;
+        }
+
+        hcd->rsrc_start = res->start;
+        hcd->rsrc_len = resource_size(res);
+        hcd->regs = ioremap(res->start, resource_size(res));
+        if (!hcd->regs) {
+                dev_err(&pdev->dev, "Failed to remap I/O memory\n");
+                err = -ENOMEM;
+                goto fail_io;
+        }
+
+        irq = platform_get_irq(pdev, 0);
+        if (!irq) {
+                dev_err(&pdev->dev, "Failed to get IRQ\n");
+                err = -ENODEV;
+                goto fail;
+        }
+
+        if (pdata->phy_init)
+                pdata->phy_init(pdev, S5P_USB_PHY_HOST);
+
+        ehci = hcd_to_ehci(hcd);
+        ehci->caps = hcd->regs;
+        ehci->regs = hcd->regs +
+                HC_LENGTH(ehci, readl(&ehci->caps->hc_capbase));
+
+        dbg_hcs_params(ehci, "reset");
+        dbg_hcc_params(ehci, "reset");
+
+        /* cache this readonly data; minimize chip reads */
+        ehci->hcs_params = readl(&ehci->caps->hcs_params);
+
+        err = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
+        if (err) {
+                dev_err(&pdev->dev, "Failed to add USB HCD\n");
+                goto fail;
+        }
+
+        platform_set_drvdata(pdev, s5p_ehci);
+
+        return 0;
+
+fail:
+        iounmap(hcd->regs);
+fail_io:
+        clk_disable(s5p_ehci->clk);
+fail_clken:
+        clk_put(s5p_ehci->clk);
+fail_clk:
+        usb_put_hcd(hcd);
+fail_hcd:
+        kfree(s5p_ehci);
+        return err;
+}
+
+static int __devexit s5p_ehci_remove(struct platform_device *pdev)
+{
+        struct s5p_ehci_platdata *pdata = pdev->dev.platform_data;
+        struct s5p_ehci_hcd *s5p_ehci = platform_get_drvdata(pdev);
+        struct usb_hcd *hcd = s5p_ehci->hcd;
+
+        usb_remove_hcd(hcd);
+
+        if (pdata && pdata->phy_exit)
+                pdata->phy_exit(pdev, S5P_USB_PHY_HOST);
+
+        iounmap(hcd->regs);
+
+        clk_disable(s5p_ehci->clk);
+        clk_put(s5p_ehci->clk);
+
+        usb_put_hcd(hcd);
+        kfree(s5p_ehci);
+
+        return 0;
+}
+
+static void s5p_ehci_shutdown(struct platform_device *pdev)
+{
+        struct s5p_ehci_hcd *s5p_ehci = platform_get_drvdata(pdev);
+        struct usb_hcd *hcd = s5p_ehci->hcd;
+
+        if (hcd->driver->shutdown)
+                hcd->driver->shutdown(hcd);
+}
+
+static struct platform_driver s5p_ehci_driver = {
+        .probe          = s5p_ehci_probe,
+        .remove         = __devexit_p(s5p_ehci_remove),
+        .shutdown       = s5p_ehci_shutdown,
+        .driver = {
+                .name   = "s5p-ehci",
+                .owner  = THIS_MODULE,
+        }
+};
+
+MODULE_ALIAS("platform:s5p-ehci");
diff --git a/drivers/usb/host/ehci-sched.c b/drivers/usb/host/ehci-sched.c
index a92526d6e5ae..6c9fbe352f73 100644
--- a/drivers/usb/host/ehci-sched.c
+++ b/drivers/usb/host/ehci-sched.c
@@ -98,7 +98,14 @@ static void periodic_unlink (struct ehci_hcd *ehci, unsigned frame, void *ptr)
          */
         *prev_p = *periodic_next_shadow(ehci, &here,
                         Q_NEXT_TYPE(ehci, *hw_p));
-        *hw_p = *shadow_next_periodic(ehci, &here, Q_NEXT_TYPE(ehci, *hw_p));
+
+        if (!ehci->use_dummy_qh ||
+            *shadow_next_periodic(ehci, &here, Q_NEXT_TYPE(ehci, *hw_p))
+                        != EHCI_LIST_END(ehci))
+                *hw_p = *shadow_next_periodic(ehci, &here,
+                                Q_NEXT_TYPE(ehci, *hw_p));
+        else
+                *hw_p = ehci->dummy->qh_dma;
 }
 
 /* how many of the uframe's 125 usecs are allocated? */
@@ -464,8 +471,10 @@ static int enable_periodic (struct ehci_hcd *ehci)
          */
         status = handshake_on_error_set_halt(ehci, &ehci->regs->status,
                                              STS_PSS, 0, 9 * 125);
-        if (status)
+        if (status) {
+                usb_hc_died(ehci_to_hcd(ehci));
                 return status;
+        }
 
         cmd = ehci_readl(ehci, &ehci->regs->command) | CMD_PSE;
         ehci_writel(ehci, cmd, &ehci->regs->command);
@@ -503,8 +512,10 @@ static int disable_periodic (struct ehci_hcd *ehci)
          */
         status = handshake_on_error_set_halt(ehci, &ehci->regs->status,
                                              STS_PSS, STS_PSS, 9 * 125);
-        if (status)
+        if (status) {
+                usb_hc_died(ehci_to_hcd(ehci));
                 return status;
+        }
 
         cmd = ehci_readl(ehci, &ehci->regs->command) & ~CMD_PSE;
         ehci_writel(ehci, cmd, &ehci->regs->command);
@@ -1041,8 +1052,6 @@ iso_stream_put(struct ehci_hcd *ehci, struct ehci_iso_stream *stream)
          * not like a QH -- no persistent state (toggle, halt)
          */
         if (stream->refcount == 1) {
-                int             is_in;
-
                 // BUG_ON (!list_empty(&stream->td_list));
 
                 while (!list_empty (&stream->free_list)) {
@@ -1069,7 +1078,6 @@ iso_stream_put(struct ehci_hcd *ehci, struct ehci_iso_stream *stream)
                         }
                 }
 
-                is_in = (stream->bEndpointAddress & USB_DIR_IN) ? 0x10 : 0;
                 stream->bEndpointAddress &= 0x0f;
                 if (stream->ep)
                         stream->ep->hcpriv = NULL;
@@ -1609,6 +1617,12 @@ itd_link_urb (
                         urb->interval,
                         next_uframe >> 3, next_uframe & 0x7);
         }
+
+        if (ehci_to_hcd(ehci)->self.bandwidth_isoc_reqs == 0) {
+                if (ehci->amd_pll_fix == 1)
+                        usb_amd_quirk_pll_disable();
+        }
+
         ehci_to_hcd(ehci)->self.bandwidth_isoc_reqs++;
 
         /* fill iTDs uframe by uframe */
@@ -1733,6 +1747,11 @@ itd_complete (
         (void) disable_periodic(ehci);
         ehci_to_hcd(ehci)->self.bandwidth_isoc_reqs--;
 
+        if (ehci_to_hcd(ehci)->self.bandwidth_isoc_reqs == 0) {
+                if (ehci->amd_pll_fix == 1)
+                        usb_amd_quirk_pll_enable();
+        }
+
         if (unlikely(list_is_singular(&stream->td_list))) {
                 ehci_to_hcd(ehci)->self.bandwidth_allocated
                                 -= stream->bandwidth;
@@ -2018,6 +2037,12 @@ sitd_link_urb (
                         (next_uframe >> 3) & (ehci->periodic_size - 1),
                         stream->interval, hc32_to_cpu(ehci, stream->splits));
         }
+
+        if (ehci_to_hcd(ehci)->self.bandwidth_isoc_reqs == 0) {
+                if (ehci->amd_pll_fix == 1)
+                        usb_amd_quirk_pll_disable();
+        }
+
         ehci_to_hcd(ehci)->self.bandwidth_isoc_reqs++;
 
         /* fill sITDs frame by frame */
@@ -2118,6 +2143,11 @@ sitd_complete (
         (void) disable_periodic(ehci);
         ehci_to_hcd(ehci)->self.bandwidth_isoc_reqs--;
 
+        if (ehci_to_hcd(ehci)->self.bandwidth_isoc_reqs == 0) {
+                if (ehci->amd_pll_fix == 1)
+                        usb_amd_quirk_pll_enable();
+        }
+
         if (list_is_singular(&stream->td_list)) {
                 ehci_to_hcd(ehci)->self.bandwidth_allocated
                                 -= stream->bandwidth;
@@ -2261,6 +2291,7 @@ scan_periodic (struct ehci_hcd *ehci)
         }
         clock &= mod - 1;
         clock_frame = clock >> 3;
+        ++ehci->periodic_stamp;
 
         for (;;) {
                 union ehci_shadow       q, *q_p;
@@ -2289,10 +2320,14 @@ restart:
                                 temp.qh = qh_get (q.qh);
                                 type = Q_NEXT_TYPE(ehci, q.qh->hw->hw_next);
                                 q = q.qh->qh_next;
-                                modified = qh_completions (ehci, temp.qh);
-                                if (unlikely(list_empty(&temp.qh->qtd_list) ||
-                                                temp.qh->needs_rescan))
-                                        intr_deschedule (ehci, temp.qh);
+                                if (temp.qh->stamp != ehci->periodic_stamp) {
+                                        modified = qh_completions(ehci, temp.qh);
+                                        if (!modified)
+                                                temp.qh->stamp = ehci->periodic_stamp;
+                                        if (unlikely(list_empty(&temp.qh->qtd_list) ||
+                                                        temp.qh->needs_rescan))
+                                                intr_deschedule(ehci, temp.qh);
+                                }
                                 qh_put (temp.qh);
                                 break;
                         case Q_TYPE_FSTN:
@@ -2335,7 +2370,11 @@ restart:
                                  * pointer for much longer, if at all.
                                  */
                                 *q_p = q.itd->itd_next;
-                                *hw_p = q.itd->hw_next;
+                                if (!ehci->use_dummy_qh ||
+                                    q.itd->hw_next != EHCI_LIST_END(ehci))
+                                        *hw_p = q.itd->hw_next;
+                                else
+                                        *hw_p = ehci->dummy->qh_dma;
                                 type = Q_NEXT_TYPE(ehci, q.itd->hw_next);
                                 wmb();
                                 modified = itd_complete (ehci, q.itd);
@@ -2368,7 +2407,11 @@ restart:
                                  * URB completion.
                                  */
                                 *q_p = q.sitd->sitd_next;
-                                *hw_p = q.sitd->hw_next;
+                                if (!ehci->use_dummy_qh ||
+                                    q.sitd->hw_next != EHCI_LIST_END(ehci))
+                                        *hw_p = q.sitd->hw_next;
+                                else
+                                        *hw_p = ehci->dummy->qh_dma;
                                 type = Q_NEXT_TYPE(ehci, q.sitd->hw_next);
                                 wmb();
                                 modified = sitd_complete (ehci, q.sitd);
@@ -2426,6 +2469,7 @@ restart:
                         if (ehci->clock_frame != clock_frame) {
                                 free_cached_lists(ehci);
                                 ehci->clock_frame = clock_frame;
+                                ++ehci->periodic_stamp;
                         }
                 } else {
                         now_uframe++;
diff --git a/drivers/usb/host/ehci-sh.c b/drivers/usb/host/ehci-sh.c
new file mode 100644
index 000000000000..86a95bb80a61
--- /dev/null
+++ b/drivers/usb/host/ehci-sh.c
@@ -0,0 +1,243 @@
+/*
+ * SuperH EHCI host controller driver
+ *
+ * Copyright (C) 2010  Paul Mundt
+ *
+ * Based on ohci-sh.c and ehci-atmel.c.
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ */
+#include <linux/platform_device.h>
+#include <linux/clk.h>
+
+struct ehci_sh_priv {
+        struct clk *iclk, *fclk;
+        struct usb_hcd *hcd;
+};
+
+static int ehci_sh_reset(struct usb_hcd *hcd)
+{
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        int ret;
+
+        ehci->caps = hcd->regs;
+        ehci->regs = hcd->regs + HC_LENGTH(ehci, ehci_readl(ehci,
+                &ehci->caps->hc_capbase));
+
+        dbg_hcs_params(ehci, "reset");
+        dbg_hcc_params(ehci, "reset");
+
+        ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
+
+        ret = ehci_halt(ehci);
+        if (unlikely(ret))
+                return ret;
+
+        ret = ehci_init(hcd);
+        if (unlikely(ret))
+                return ret;
+
+        ehci->sbrn = 0x20;
+
+        ehci_reset(ehci);
+        ehci_port_power(ehci, 0);
+
+        return ret;
+}
+
+static const struct hc_driver ehci_sh_hc_driver = {
+        .description                    = hcd_name,
+        .product_desc                   = "SuperH EHCI",
+        .hcd_priv_size                  = sizeof(struct ehci_hcd),
+
+        /*
+         * generic hardware linkage
+         */
+        .irq                            = ehci_irq,
+        .flags                          = HCD_USB2 | HCD_MEMORY,
+
+        /*
+         * basic lifecycle operations
+         */
+        .reset                          = ehci_sh_reset,
+        .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,
+        .endpoint_reset                 = ehci_endpoint_reset,
+
+        /*
+         * scheduling support
+         */
+        .get_frame_number               = ehci_get_frame,
+
+        /*
+         * root hub support
+         */
+        .hub_status_data                = ehci_hub_status_data,
+        .hub_control                    = ehci_hub_control,
+
+#ifdef CONFIG_PM
+        .bus_suspend                    = ehci_bus_suspend,
+        .bus_resume                     = ehci_bus_resume,
+#endif
+
+        .relinquish_port                = ehci_relinquish_port,
+        .port_handed_over               = ehci_port_handed_over,
+        .clear_tt_buffer_complete       = ehci_clear_tt_buffer_complete,
+};
+
+static int ehci_hcd_sh_probe(struct platform_device *pdev)
+{
+        const struct hc_driver *driver = &ehci_sh_hc_driver;
+        struct resource *res;
+        struct ehci_sh_priv *priv;
+        struct usb_hcd *hcd;
+        int irq, ret;
+
+        if (usb_disabled())
+                return -ENODEV;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(&pdev->dev,
+                        "Found HC with no register addr. Check %s setup!\n",
+                        dev_name(&pdev->dev));
+                ret = -ENODEV;
+                goto fail_create_hcd;
+        }
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq <= 0) {
+                dev_err(&pdev->dev,
+                        "Found HC with no IRQ. Check %s setup!\n",
+                        dev_name(&pdev->dev));
+                ret = -ENODEV;
+                goto fail_create_hcd;
+        }
+
+        /* initialize hcd */
+        hcd = usb_create_hcd(&ehci_sh_hc_driver, &pdev->dev,
+                             dev_name(&pdev->dev));
+        if (!hcd) {
+                ret = -ENOMEM;
+                goto fail_create_hcd;
+        }
+
+        hcd->rsrc_start = res->start;
+        hcd->rsrc_len = resource_size(res);
+
+        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len,
+                                driver->description)) {
+                dev_dbg(&pdev->dev, "controller already in use\n");
+                ret = -EBUSY;
+                goto fail_request_resource;
+        }
+
+        hcd->regs = ioremap_nocache(hcd->rsrc_start, hcd->rsrc_len);
+        if (hcd->regs == NULL) {
+                dev_dbg(&pdev->dev, "error mapping memory\n");
+                ret = -ENXIO;
+                goto fail_ioremap;
+        }
+
+        priv = kmalloc(sizeof(struct ehci_sh_priv), GFP_KERNEL);
+        if (!priv) {
+                dev_dbg(&pdev->dev, "error allocating priv data\n");
+                ret = -ENOMEM;
+                goto fail_alloc;
+        }
+
+        /* These are optional, we don't care if they fail */
+        priv->fclk = clk_get(&pdev->dev, "usb_fck");
+        if (IS_ERR(priv->fclk))
+                priv->fclk = NULL;
+
+        priv->iclk = clk_get(&pdev->dev, "usb_ick");
+        if (IS_ERR(priv->iclk))
+                priv->iclk = NULL;
+
+        clk_enable(priv->fclk);
+        clk_enable(priv->iclk);
+
+        ret = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
+        if (ret != 0) {
+                dev_err(&pdev->dev, "Failed to add hcd");
+                goto fail_add_hcd;
+        }
+
+        priv->hcd = hcd;
+        platform_set_drvdata(pdev, priv);
+
+        return ret;
+
+fail_add_hcd:
+        clk_disable(priv->iclk);
+        clk_disable(priv->fclk);
+
+        clk_put(priv->iclk);
+        clk_put(priv->fclk);
+
+        kfree(priv);
+fail_alloc:
+        iounmap(hcd->regs);
+fail_ioremap:
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+fail_request_resource:
+        usb_put_hcd(hcd);
+fail_create_hcd:
+        dev_err(&pdev->dev, "init %s fail, %d\n", dev_name(&pdev->dev), ret);
+
+        return ret;
+}
+
+static int __exit ehci_hcd_sh_remove(struct platform_device *pdev)
+{
+        struct ehci_sh_priv *priv = platform_get_drvdata(pdev);
+        struct usb_hcd *hcd = priv->hcd;
+
+        usb_remove_hcd(hcd);
+        iounmap(hcd->regs);
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+        usb_put_hcd(hcd);
+        platform_set_drvdata(pdev, NULL);
+
+        clk_disable(priv->fclk);
+        clk_disable(priv->iclk);
+
+        clk_put(priv->fclk);
+        clk_put(priv->iclk);
+
+        kfree(priv);
+
+        return 0;
+}
+
+static void ehci_hcd_sh_shutdown(struct platform_device *pdev)
+{
+        struct ehci_sh_priv *priv = platform_get_drvdata(pdev);
+        struct usb_hcd *hcd = priv->hcd;
+
+        if (hcd->driver->shutdown)
+                hcd->driver->shutdown(hcd);
+}
+
+static struct platform_driver ehci_hcd_sh_driver = {
+        .probe          = ehci_hcd_sh_probe,
+        .remove         = __exit_p(ehci_hcd_sh_remove),
+        .shutdown       = ehci_hcd_sh_shutdown,
+        .driver         = {
+                .name   = "sh_ehci",
+                .owner  = THIS_MODULE,
+        },
+};
+
+MODULE_ALIAS("platform:sh_ehci");
diff --git a/drivers/usb/host/ehci-spear.c b/drivers/usb/host/ehci-spear.c
new file mode 100644
index 000000000000..dbf1e4ef3c17
--- /dev/null
+++ b/drivers/usb/host/ehci-spear.c
@@ -0,0 +1,212 @@
+/*
+* Driver for EHCI HCD on SPEAR SOC
+*
+* Copyright (C) 2010 ST Micro Electronics,
+* Deepak Sikri <deepak.sikri@st.com>
+*
+* Based on various ehci-*.c drivers
+*
+* This file is subject to the terms and conditions of the GNU General Public
+* License. See the file COPYING in the main directory of this archive for
+* more details.
+*/
+
+#include <linux/platform_device.h>
+#include <linux/clk.h>
+
+struct spear_ehci {
+        struct ehci_hcd ehci;
+        struct clk *clk;
+};
+
+#define to_spear_ehci(hcd)      (struct spear_ehci *)hcd_to_ehci(hcd)
+
+static void spear_start_ehci(struct spear_ehci *ehci)
+{
+        clk_enable(ehci->clk);
+}
+
+static void spear_stop_ehci(struct spear_ehci *ehci)
+{
+        clk_disable(ehci->clk);
+}
+
+static int ehci_spear_setup(struct usb_hcd *hcd)
+{
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        int retval = 0;
+
+        /* registers start at offset 0x0 */
+        ehci->caps = hcd->regs;
+        ehci->regs = hcd->regs + HC_LENGTH(ehci, ehci_readl(ehci,
+                                &ehci->caps->hc_capbase));
+        /* cache this readonly data; minimize chip reads */
+        ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
+        retval = ehci_halt(ehci);
+        if (retval)
+                return retval;
+
+        retval = ehci_init(hcd);
+        if (retval)
+                return retval;
+
+        ehci_reset(ehci);
+        ehci_port_power(ehci, 0);
+
+        return retval;
+}
+
+static const struct hc_driver ehci_spear_hc_driver = {
+        .description                    = hcd_name,
+        .product_desc                   = "SPEAr EHCI",
+        .hcd_priv_size                  = sizeof(struct spear_ehci),
+
+        /* generic hardware linkage */
+        .irq                            = ehci_irq,
+        .flags                          = HCD_MEMORY | HCD_USB2,
+
+        /* basic lifecycle operations */
+        .reset                          = ehci_spear_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,
+        .endpoint_reset                 = ehci_endpoint_reset,
+
+        /* 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,
+        .clear_tt_buffer_complete       = ehci_clear_tt_buffer_complete,
+};
+
+static int spear_ehci_hcd_drv_probe(struct platform_device *pdev)
+{
+        struct usb_hcd *hcd ;
+        struct spear_ehci *ehci;
+        struct resource *res;
+        struct clk *usbh_clk;
+        const struct hc_driver *driver = &ehci_spear_hc_driver;
+        int *pdata = pdev->dev.platform_data;
+        int irq, retval;
+        char clk_name[20] = "usbh_clk";
+
+        if (pdata == NULL)
+                return -EFAULT;
+
+        if (usb_disabled())
+                return -ENODEV;
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0) {
+                retval = irq;
+                goto fail_irq_get;
+        }
+
+        if (*pdata >= 0)
+                sprintf(clk_name, "usbh.%01d_clk", *pdata);
+
+        usbh_clk = clk_get(NULL, clk_name);
+        if (IS_ERR(usbh_clk)) {
+                dev_err(&pdev->dev, "Error getting interface clock\n");
+                retval = PTR_ERR(usbh_clk);
+                goto fail_get_usbh_clk;
+        }
+
+        hcd = usb_create_hcd(driver, &pdev->dev, dev_name(&pdev->dev));
+        if (!hcd) {
+                retval = -ENOMEM;
+                goto fail_create_hcd;
+        }
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                retval = -ENODEV;
+                goto fail_request_resource;
+        }
+
+        hcd->rsrc_start = res->start;
+        hcd->rsrc_len = resource_size(res);
+        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len,
+                                driver->description)) {
+                retval = -EBUSY;
+                goto fail_request_resource;
+        }
+
+        hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
+        if (hcd->regs == NULL) {
+                dev_dbg(&pdev->dev, "error mapping memory\n");
+                retval = -ENOMEM;
+                goto fail_ioremap;
+        }
+
+        ehci = (struct spear_ehci *)hcd_to_ehci(hcd);
+        ehci->clk = usbh_clk;
+
+        spear_start_ehci(ehci);
+        retval = usb_add_hcd(hcd, irq, IRQF_SHARED | IRQF_DISABLED);
+        if (retval)
+                goto fail_add_hcd;
+
+        return retval;
+
+fail_add_hcd:
+        spear_stop_ehci(ehci);
+        iounmap(hcd->regs);
+fail_ioremap:
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+fail_request_resource:
+        usb_put_hcd(hcd);
+fail_create_hcd:
+        clk_put(usbh_clk);
+fail_get_usbh_clk:
+fail_irq_get:
+        dev_err(&pdev->dev, "init fail, %d\n", retval);
+
+        return retval ;
+}
+
+static int spear_ehci_hcd_drv_remove(struct platform_device *pdev)
+{
+        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+        struct spear_ehci *ehci_p = to_spear_ehci(hcd);
+
+        if (!hcd)
+                return 0;
+        if (in_interrupt())
+                BUG();
+        usb_remove_hcd(hcd);
+
+        if (ehci_p->clk)
+                spear_stop_ehci(ehci_p);
+        iounmap(hcd->regs);
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+        usb_put_hcd(hcd);
+
+        if (ehci_p->clk)
+                clk_put(ehci_p->clk);
+
+        return 0;
+}
+
+static struct platform_driver spear_ehci_hcd_driver = {
+        .probe          = spear_ehci_hcd_drv_probe,
+        .remove         = spear_ehci_hcd_drv_remove,
+        .shutdown       = usb_hcd_platform_shutdown,
+        .driver         = {
+                .name = "spear-ehci",
+                .bus = &platform_bus_type
+        }
+};
+
+MODULE_ALIAS("platform:spear-ehci");
diff --git a/drivers/usb/host/ehci-tegra.c b/drivers/usb/host/ehci-tegra.c
new file mode 100644
index 000000000000..02b2bfd49a10
--- /dev/null
+++ b/drivers/usb/host/ehci-tegra.c
@@ -0,0 +1,787 @@
+/*
+ * EHCI-compliant USB host controller driver for NVIDIA Tegra SoCs
+ *
+ * Copyright (C) 2010 Google, Inc.
+ * Copyright (C) 2009 NVIDIA Corporation
+ *
+ * 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.
+ *
+ */
+
+#include <linux/clk.h>
+#include <linux/platform_device.h>
+#include <linux/platform_data/tegra_usb.h>
+#include <linux/irq.h>
+#include <linux/usb/otg.h>
+#include <mach/usb_phy.h>
+
+#define TEGRA_USB_DMA_ALIGN 32
+
+struct tegra_ehci_hcd {
+        struct ehci_hcd *ehci;
+        struct tegra_usb_phy *phy;
+        struct clk *clk;
+        struct clk *emc_clk;
+        struct otg_transceiver *transceiver;
+        int host_resumed;
+        int bus_suspended;
+        int port_resuming;
+        int power_down_on_bus_suspend;
+        enum tegra_usb_phy_port_speed port_speed;
+};
+
+static void tegra_ehci_power_up(struct usb_hcd *hcd)
+{
+        struct tegra_ehci_hcd *tegra = dev_get_drvdata(hcd->self.controller);
+
+        clk_enable(tegra->emc_clk);
+        clk_enable(tegra->clk);
+        tegra_usb_phy_power_on(tegra->phy);
+        tegra->host_resumed = 1;
+}
+
+static void tegra_ehci_power_down(struct usb_hcd *hcd)
+{
+        struct tegra_ehci_hcd *tegra = dev_get_drvdata(hcd->self.controller);
+
+        tegra->host_resumed = 0;
+        tegra_usb_phy_power_off(tegra->phy);
+        clk_disable(tegra->clk);
+        clk_disable(tegra->emc_clk);
+}
+
+static int tegra_ehci_internal_port_reset(
+        struct ehci_hcd *ehci,
+        u32 __iomem     *portsc_reg
+)
+{
+        u32             temp;
+        unsigned long   flags;
+        int             retval = 0;
+        int             i, tries;
+        u32             saved_usbintr;
+
+        spin_lock_irqsave(&ehci->lock, flags);
+        saved_usbintr = ehci_readl(ehci, &ehci->regs->intr_enable);
+        /* disable USB interrupt */
+        ehci_writel(ehci, 0, &ehci->regs->intr_enable);
+        spin_unlock_irqrestore(&ehci->lock, flags);
+
+        /*
+         * Here we have to do Port Reset at most twice for
+         * Port Enable bit to be set.
+         */
+        for (i = 0; i < 2; i++) {
+                temp = ehci_readl(ehci, portsc_reg);
+                temp |= PORT_RESET;
+                ehci_writel(ehci, temp, portsc_reg);
+                mdelay(10);
+                temp &= ~PORT_RESET;
+                ehci_writel(ehci, temp, portsc_reg);
+                mdelay(1);
+                tries = 100;
+                do {
+                        mdelay(1);
+                        /*
+                         * Up to this point, Port Enable bit is
+                         * expected to be set after 2 ms waiting.
+                         * USB1 usually takes extra 45 ms, for safety,
+                         * we take 100 ms as timeout.
+                         */
+                        temp = ehci_readl(ehci, portsc_reg);
+                } while (!(temp & PORT_PE) && tries--);
+                if (temp & PORT_PE)
+                        break;
+        }
+        if (i == 2)
+                retval = -ETIMEDOUT;
+
+        /*
+         * Clear Connect Status Change bit if it's set.
+         * We can't clear PORT_PEC. It will also cause PORT_PE to be cleared.
+         */
+        if (temp & PORT_CSC)
+                ehci_writel(ehci, PORT_CSC, portsc_reg);
+
+        /*
+         * Write to clear any interrupt status bits that might be set
+         * during port reset.
+         */
+        temp = ehci_readl(ehci, &ehci->regs->status);
+        ehci_writel(ehci, temp, &ehci->regs->status);
+
+        /* restore original interrupt enable bits */
+        ehci_writel(ehci, saved_usbintr, &ehci->regs->intr_enable);
+        return retval;
+}
+
+static int tegra_ehci_hub_control(
+        struct usb_hcd  *hcd,
+        u16             typeReq,
+        u16             wValue,
+        u16             wIndex,
+        char            *buf,
+        u16             wLength
+)
+{
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        struct tegra_ehci_hcd *tegra = dev_get_drvdata(hcd->self.controller);
+        u32 __iomem     *status_reg;
+        u32             temp;
+        unsigned long   flags;
+        int             retval = 0;
+
+        status_reg = &ehci->regs->port_status[(wIndex & 0xff) - 1];
+
+        spin_lock_irqsave(&ehci->lock, flags);
+
+        /*
+         * In ehci_hub_control() for USB_PORT_FEAT_ENABLE clears the other bits
+         * that are write on clear, by writing back the register read value, so
+         * USB_PORT_FEAT_ENABLE is handled by masking the set on clear bits
+         */
+        if (typeReq == ClearPortFeature && wValue == USB_PORT_FEAT_ENABLE) {
+                temp = ehci_readl(ehci, status_reg) & ~PORT_RWC_BITS;
+                ehci_writel(ehci, temp & ~PORT_PE, status_reg);
+                goto done;
+        }
+
+        else if (typeReq == GetPortStatus) {
+                temp = ehci_readl(ehci, status_reg);
+                if (tegra->port_resuming && !(temp & PORT_SUSPEND)) {
+                        /* Resume completed, re-enable disconnect detection */
+                        tegra->port_resuming = 0;
+                        tegra_usb_phy_postresume(tegra->phy);
+                }
+        }
+
+        else if (typeReq == SetPortFeature && wValue == USB_PORT_FEAT_SUSPEND) {
+                temp = ehci_readl(ehci, status_reg);
+                if ((temp & PORT_PE) == 0 || (temp & PORT_RESET) != 0) {
+                        retval = -EPIPE;
+                        goto done;
+                }
+
+                temp &= ~PORT_WKCONN_E;
+                temp |= PORT_WKDISC_E | PORT_WKOC_E;
+                ehci_writel(ehci, temp | PORT_SUSPEND, status_reg);
+
+                /*
+                 * If a transaction is in progress, there may be a delay in
+                 * suspending the port. Poll until the port is suspended.
+                 */
+                if (handshake(ehci, status_reg, PORT_SUSPEND,
+                                                PORT_SUSPEND, 5000))
+                        pr_err("%s: timeout waiting for SUSPEND\n", __func__);
+
+                set_bit((wIndex & 0xff) - 1, &ehci->suspended_ports);
+                goto done;
+        }
+
+        /* For USB1 port we need to issue Port Reset twice internally */
+        if (tegra->phy->instance == 0 &&
+           (typeReq == SetPortFeature && wValue == USB_PORT_FEAT_RESET)) {
+                spin_unlock_irqrestore(&ehci->lock, flags);
+                return tegra_ehci_internal_port_reset(ehci, status_reg);
+        }
+
+        /*
+         * Tegra host controller will time the resume operation to clear the bit
+         * when the port control state switches to HS or FS Idle. This behavior
+         * is different from EHCI where the host controller driver is required
+         * to set this bit to a zero after the resume duration is timed in the
+         * driver.
+         */
+        else if (typeReq == ClearPortFeature &&
+                                        wValue == USB_PORT_FEAT_SUSPEND) {
+                temp = ehci_readl(ehci, status_reg);
+                if ((temp & PORT_RESET) || !(temp & PORT_PE)) {
+                        retval = -EPIPE;
+                        goto done;
+                }
+
+                if (!(temp & PORT_SUSPEND))
+                        goto done;
+
+                /* Disable disconnect detection during port resume */
+                tegra_usb_phy_preresume(tegra->phy);
+
+                ehci->reset_done[wIndex-1] = jiffies + msecs_to_jiffies(25);
+
+                temp &= ~(PORT_RWC_BITS | PORT_WAKE_BITS);
+                /* start resume signalling */
+                ehci_writel(ehci, temp | PORT_RESUME, status_reg);
+
+                spin_unlock_irqrestore(&ehci->lock, flags);
+                msleep(20);
+                spin_lock_irqsave(&ehci->lock, flags);
+
+                /* Poll until the controller clears RESUME and SUSPEND */
+                if (handshake(ehci, status_reg, PORT_RESUME, 0, 2000))
+                        pr_err("%s: timeout waiting for RESUME\n", __func__);
+                if (handshake(ehci, status_reg, PORT_SUSPEND, 0, 2000))
+                        pr_err("%s: timeout waiting for SUSPEND\n", __func__);
+
+                ehci->reset_done[wIndex-1] = 0;
+
+                tegra->port_resuming = 1;
+                goto done;
+        }
+
+        spin_unlock_irqrestore(&ehci->lock, flags);
+
+        /* Handle the hub control events here */
+        return ehci_hub_control(hcd, typeReq, wValue, wIndex, buf, wLength);
+done:
+        spin_unlock_irqrestore(&ehci->lock, flags);
+        return retval;
+}
+
+static void tegra_ehci_restart(struct usb_hcd *hcd)
+{
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+
+        ehci_reset(ehci);
+
+        /* setup the frame list and Async q heads */
+        ehci_writel(ehci, ehci->periodic_dma, &ehci->regs->frame_list);
+        ehci_writel(ehci, (u32)ehci->async->qh_dma, &ehci->regs->async_next);
+        /* setup the command register and set the controller in RUN mode */
+        ehci->command &= ~(CMD_LRESET|CMD_IAAD|CMD_PSE|CMD_ASE|CMD_RESET);
+        ehci->command |= CMD_RUN;
+        ehci_writel(ehci, ehci->command, &ehci->regs->command);
+
+        down_write(&ehci_cf_port_reset_rwsem);
+        ehci_writel(ehci, FLAG_CF, &ehci->regs->configured_flag);
+        /* flush posted writes */
+        ehci_readl(ehci, &ehci->regs->command);
+        up_write(&ehci_cf_port_reset_rwsem);
+}
+
+static int tegra_usb_suspend(struct usb_hcd *hcd)
+{
+        struct tegra_ehci_hcd *tegra = dev_get_drvdata(hcd->self.controller);
+        struct ehci_regs __iomem *hw = tegra->ehci->regs;
+        unsigned long flags;
+
+        spin_lock_irqsave(&tegra->ehci->lock, flags);
+
+        tegra->port_speed = (readl(&hw->port_status[0]) >> 26) & 0x3;
+        ehci_halt(tegra->ehci);
+        clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
+
+        spin_unlock_irqrestore(&tegra->ehci->lock, flags);
+
+        tegra_ehci_power_down(hcd);
+        return 0;
+}
+
+static int tegra_usb_resume(struct usb_hcd *hcd)
+{
+        struct tegra_ehci_hcd *tegra = dev_get_drvdata(hcd->self.controller);
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        struct ehci_regs __iomem *hw = ehci->regs;
+        unsigned long val;
+
+        set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
+        tegra_ehci_power_up(hcd);
+
+        if (tegra->port_speed > TEGRA_USB_PHY_PORT_SPEED_HIGH) {
+                /* Wait for the phy to detect new devices
+                 * before we restart the controller */
+                msleep(10);
+                goto restart;
+        }
+
+        /* Force the phy to keep data lines in suspend state */
+        tegra_ehci_phy_restore_start(tegra->phy, tegra->port_speed);
+
+        /* Enable host mode */
+        tdi_reset(ehci);
+
+        /* Enable Port Power */
+        val = readl(&hw->port_status[0]);
+        val |= PORT_POWER;
+        writel(val, &hw->port_status[0]);
+        udelay(10);
+
+        /* Check if the phy resume from LP0. When the phy resume from LP0
+         * USB register will be reset. */
+        if (!readl(&hw->async_next)) {
+                /* Program the field PTC based on the saved speed mode */
+                val = readl(&hw->port_status[0]);
+                val &= ~PORT_TEST(~0);
+                if (tegra->port_speed == TEGRA_USB_PHY_PORT_SPEED_HIGH)
+                        val |= PORT_TEST_FORCE;
+                else if (tegra->port_speed == TEGRA_USB_PHY_PORT_SPEED_FULL)
+                        val |= PORT_TEST(6);
+                else if (tegra->port_speed == TEGRA_USB_PHY_PORT_SPEED_LOW)
+                        val |= PORT_TEST(7);
+                writel(val, &hw->port_status[0]);
+                udelay(10);
+
+                /* Disable test mode by setting PTC field to NORMAL_OP */
+                val = readl(&hw->port_status[0]);
+                val &= ~PORT_TEST(~0);
+                writel(val, &hw->port_status[0]);
+                udelay(10);
+        }
+
+        /* Poll until CCS is enabled */
+        if (handshake(ehci, &hw->port_status[0], PORT_CONNECT,
+                                                 PORT_CONNECT, 2000)) {
+                pr_err("%s: timeout waiting for PORT_CONNECT\n", __func__);
+                goto restart;
+        }
+
+        /* Poll until PE is enabled */
+        if (handshake(ehci, &hw->port_status[0], PORT_PE,
+                                                 PORT_PE, 2000)) {
+                pr_err("%s: timeout waiting for USB_PORTSC1_PE\n", __func__);
+                goto restart;
+        }
+
+        /* Clear the PCI status, to avoid an interrupt taken upon resume */
+        val = readl(&hw->status);
+        val |= STS_PCD;
+        writel(val, &hw->status);
+
+        /* Put controller in suspend mode by writing 1 to SUSP bit of PORTSC */
+        val = readl(&hw->port_status[0]);
+        if ((val & PORT_POWER) && (val & PORT_PE)) {
+                val |= PORT_SUSPEND;
+                writel(val, &hw->port_status[0]);
+
+                /* Wait until port suspend completes */
+                if (handshake(ehci, &hw->port_status[0], PORT_SUSPEND,
+                                                         PORT_SUSPEND, 1000)) {
+                        pr_err("%s: timeout waiting for PORT_SUSPEND\n",
+                                                                __func__);
+                        goto restart;
+                }
+        }
+
+        tegra_ehci_phy_restore_end(tegra->phy);
+        return 0;
+
+restart:
+        if (tegra->port_speed <= TEGRA_USB_PHY_PORT_SPEED_HIGH)
+                tegra_ehci_phy_restore_end(tegra->phy);
+
+        tegra_ehci_restart(hcd);
+        return 0;
+}
+
+static void tegra_ehci_shutdown(struct usb_hcd *hcd)
+{
+        struct tegra_ehci_hcd *tegra = dev_get_drvdata(hcd->self.controller);
+
+        /* ehci_shutdown touches the USB controller registers, make sure
+         * controller has clocks to it */
+        if (!tegra->host_resumed)
+                tegra_ehci_power_up(hcd);
+
+        ehci_shutdown(hcd);
+}
+
+static int tegra_ehci_setup(struct usb_hcd *hcd)
+{
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        int retval;
+
+        /* EHCI registers start at offset 0x100 */
+        ehci->caps = hcd->regs + 0x100;
+        ehci->regs = hcd->regs + 0x100 +
+                HC_LENGTH(ehci, readl(&ehci->caps->hc_capbase));
+
+        dbg_hcs_params(ehci, "reset");
+        dbg_hcc_params(ehci, "reset");
+
+        /* cache this readonly data; minimize chip reads */
+        ehci->hcs_params = readl(&ehci->caps->hcs_params);
+
+        /* switch to host mode */
+        hcd->has_tt = 1;
+        ehci_reset(ehci);
+
+        retval = ehci_halt(ehci);
+        if (retval)
+                return retval;
+
+        /* data structure init */
+        retval = ehci_init(hcd);
+        if (retval)
+                return retval;
+
+        ehci->sbrn = 0x20;
+
+        ehci_port_power(ehci, 1);
+        return retval;
+}
+
+#ifdef CONFIG_PM
+static int tegra_ehci_bus_suspend(struct usb_hcd *hcd)
+{
+        struct tegra_ehci_hcd *tegra = dev_get_drvdata(hcd->self.controller);
+        int error_status = 0;
+
+        error_status = ehci_bus_suspend(hcd);
+        if (!error_status && tegra->power_down_on_bus_suspend) {
+                tegra_usb_suspend(hcd);
+                tegra->bus_suspended = 1;
+        }
+
+        return error_status;
+}
+
+static int tegra_ehci_bus_resume(struct usb_hcd *hcd)
+{
+        struct tegra_ehci_hcd *tegra = dev_get_drvdata(hcd->self.controller);
+
+        if (tegra->bus_suspended && tegra->power_down_on_bus_suspend) {
+                tegra_usb_resume(hcd);
+                tegra->bus_suspended = 0;
+        }
+
+        tegra_usb_phy_preresume(tegra->phy);
+        tegra->port_resuming = 1;
+        return ehci_bus_resume(hcd);
+}
+#endif
+
+struct temp_buffer {
+        void *kmalloc_ptr;
+        void *old_xfer_buffer;
+        u8 data[0];
+};
+
+static void free_temp_buffer(struct urb *urb)
+{
+        enum dma_data_direction dir;
+        struct temp_buffer *temp;
+
+        if (!(urb->transfer_flags & URB_ALIGNED_TEMP_BUFFER))
+                return;
+
+        dir = usb_urb_dir_in(urb) ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
+
+        temp = container_of(urb->transfer_buffer, struct temp_buffer,
+                            data);
+
+        if (dir == DMA_FROM_DEVICE)
+                memcpy(temp->old_xfer_buffer, temp->data,
+                       urb->transfer_buffer_length);
+        urb->transfer_buffer = temp->old_xfer_buffer;
+        kfree(temp->kmalloc_ptr);
+
+        urb->transfer_flags &= ~URB_ALIGNED_TEMP_BUFFER;
+}
+
+static int alloc_temp_buffer(struct urb *urb, gfp_t mem_flags)
+{
+        enum dma_data_direction dir;
+        struct temp_buffer *temp, *kmalloc_ptr;
+        size_t kmalloc_size;
+
+        if (urb->num_sgs || urb->sg ||
+            urb->transfer_buffer_length == 0 ||
+            !((uintptr_t)urb->transfer_buffer & (TEGRA_USB_DMA_ALIGN - 1)))
+                return 0;
+
+        dir = usb_urb_dir_in(urb) ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
+
+        /* Allocate a buffer with enough padding for alignment */
+        kmalloc_size = urb->transfer_buffer_length +
+                sizeof(struct temp_buffer) + TEGRA_USB_DMA_ALIGN - 1;
+
+        kmalloc_ptr = kmalloc(kmalloc_size, mem_flags);
+        if (!kmalloc_ptr)
+                return -ENOMEM;
+
+        /* Position our struct temp_buffer such that data is aligned */
+        temp = PTR_ALIGN(kmalloc_ptr + 1, TEGRA_USB_DMA_ALIGN) - 1;
+
+        temp->kmalloc_ptr = kmalloc_ptr;
+        temp->old_xfer_buffer = urb->transfer_buffer;
+        if (dir == DMA_TO_DEVICE)
+                memcpy(temp->data, urb->transfer_buffer,
+                       urb->transfer_buffer_length);
+        urb->transfer_buffer = temp->data;
+
+        urb->transfer_flags |= URB_ALIGNED_TEMP_BUFFER;
+
+        return 0;
+}
+
+static int tegra_ehci_map_urb_for_dma(struct usb_hcd *hcd, struct urb *urb,
+                                      gfp_t mem_flags)
+{
+        int ret;
+
+        ret = alloc_temp_buffer(urb, mem_flags);
+        if (ret)
+                return ret;
+
+        ret = usb_hcd_map_urb_for_dma(hcd, urb, mem_flags);
+        if (ret)
+                free_temp_buffer(urb);
+
+        return ret;
+}
+
+static void tegra_ehci_unmap_urb_for_dma(struct usb_hcd *hcd, struct urb *urb)
+{
+        usb_hcd_unmap_urb_for_dma(hcd, urb);
+        free_temp_buffer(urb);
+}
+
+static const struct hc_driver tegra_ehci_hc_driver = {
+        .description            = hcd_name,
+        .product_desc           = "Tegra EHCI Host Controller",
+        .hcd_priv_size          = sizeof(struct ehci_hcd),
+
+        .flags                  = HCD_USB2 | HCD_MEMORY,
+
+        .reset                  = tegra_ehci_setup,
+        .irq                    = ehci_irq,
+
+        .start                  = ehci_run,
+        .stop                   = ehci_stop,
+        .shutdown               = tegra_ehci_shutdown,
+        .urb_enqueue            = ehci_urb_enqueue,
+        .urb_dequeue            = ehci_urb_dequeue,
+        .map_urb_for_dma        = tegra_ehci_map_urb_for_dma,
+        .unmap_urb_for_dma      = tegra_ehci_unmap_urb_for_dma,
+        .endpoint_disable       = ehci_endpoint_disable,
+        .endpoint_reset         = ehci_endpoint_reset,
+        .get_frame_number       = ehci_get_frame,
+        .hub_status_data        = ehci_hub_status_data,
+        .hub_control            = tegra_ehci_hub_control,
+        .clear_tt_buffer_complete = ehci_clear_tt_buffer_complete,
+#ifdef CONFIG_PM
+        .bus_suspend            = tegra_ehci_bus_suspend,
+        .bus_resume             = tegra_ehci_bus_resume,
+#endif
+        .relinquish_port        = ehci_relinquish_port,
+        .port_handed_over       = ehci_port_handed_over,
+};
+
+static int tegra_ehci_probe(struct platform_device *pdev)
+{
+        struct resource *res;
+        struct usb_hcd *hcd;
+        struct tegra_ehci_hcd *tegra;
+        struct tegra_ehci_platform_data *pdata;
+        int err = 0;
+        int irq;
+        int instance = pdev->id;
+
+        pdata = pdev->dev.platform_data;
+        if (!pdata) {
+                dev_err(&pdev->dev, "Platform data missing\n");
+                return -EINVAL;
+        }
+
+        tegra = kzalloc(sizeof(struct tegra_ehci_hcd), GFP_KERNEL);
+        if (!tegra)
+                return -ENOMEM;
+
+        hcd = usb_create_hcd(&tegra_ehci_hc_driver, &pdev->dev,
+                                        dev_name(&pdev->dev));
+        if (!hcd) {
+                dev_err(&pdev->dev, "Unable to create HCD\n");
+                err = -ENOMEM;
+                goto fail_hcd;
+        }
+
+        platform_set_drvdata(pdev, tegra);
+
+        tegra->clk = clk_get(&pdev->dev, NULL);
+        if (IS_ERR(tegra->clk)) {
+                dev_err(&pdev->dev, "Can't get ehci clock\n");
+                err = PTR_ERR(tegra->clk);
+                goto fail_clk;
+        }
+
+        err = clk_enable(tegra->clk);
+        if (err)
+                goto fail_clken;
+
+        tegra->emc_clk = clk_get(&pdev->dev, "emc");
+        if (IS_ERR(tegra->emc_clk)) {
+                dev_err(&pdev->dev, "Can't get emc clock\n");
+                err = PTR_ERR(tegra->emc_clk);
+                goto fail_emc_clk;
+        }
+
+        clk_enable(tegra->emc_clk);
+        clk_set_rate(tegra->emc_clk, 400000000);
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(&pdev->dev, "Failed to get I/O memory\n");
+                err = -ENXIO;
+                goto fail_io;
+        }
+        hcd->rsrc_start = res->start;
+        hcd->rsrc_len = resource_size(res);
+        hcd->regs = ioremap(res->start, resource_size(res));
+        if (!hcd->regs) {
+                dev_err(&pdev->dev, "Failed to remap I/O memory\n");
+                err = -ENOMEM;
+                goto fail_io;
+        }
+
+        tegra->phy = tegra_usb_phy_open(instance, hcd->regs, pdata->phy_config,
+                                                TEGRA_USB_PHY_MODE_HOST);
+        if (IS_ERR(tegra->phy)) {
+                dev_err(&pdev->dev, "Failed to open USB phy\n");
+                err = -ENXIO;
+                goto fail_phy;
+        }
+
+        err = tegra_usb_phy_power_on(tegra->phy);
+        if (err) {
+                dev_err(&pdev->dev, "Failed to power on the phy\n");
+                goto fail;
+        }
+
+        tegra->host_resumed = 1;
+        tegra->power_down_on_bus_suspend = pdata->power_down_on_bus_suspend;
+        tegra->ehci = hcd_to_ehci(hcd);
+
+        irq = platform_get_irq(pdev, 0);
+        if (!irq) {
+                dev_err(&pdev->dev, "Failed to get IRQ\n");
+                err = -ENODEV;
+                goto fail;
+        }
+        set_irq_flags(irq, IRQF_VALID);
+
+#ifdef CONFIG_USB_OTG_UTILS
+        if (pdata->operating_mode == TEGRA_USB_OTG) {
+                tegra->transceiver = otg_get_transceiver();
+                if (tegra->transceiver)
+                        otg_set_host(tegra->transceiver, &hcd->self);
+        }
+#endif
+
+        err = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
+        if (err) {
+                dev_err(&pdev->dev, "Failed to add USB HCD\n");
+                goto fail;
+        }
+
+        return err;
+
+fail:
+#ifdef CONFIG_USB_OTG_UTILS
+        if (tegra->transceiver) {
+                otg_set_host(tegra->transceiver, NULL);
+                otg_put_transceiver(tegra->transceiver);
+        }
+#endif
+        tegra_usb_phy_close(tegra->phy);
+fail_phy:
+        iounmap(hcd->regs);
+fail_io:
+        clk_disable(tegra->emc_clk);
+        clk_put(tegra->emc_clk);
+fail_emc_clk:
+        clk_disable(tegra->clk);
+fail_clken:
+        clk_put(tegra->clk);
+fail_clk:
+        usb_put_hcd(hcd);
+fail_hcd:
+        kfree(tegra);
+        return err;
+}
+
+#ifdef CONFIG_PM
+static int tegra_ehci_resume(struct platform_device *pdev)
+{
+        struct tegra_ehci_hcd *tegra = platform_get_drvdata(pdev);
+        struct usb_hcd *hcd = ehci_to_hcd(tegra->ehci);
+
+        if (tegra->bus_suspended)
+                return 0;
+
+        return tegra_usb_resume(hcd);
+}
+
+static int tegra_ehci_suspend(struct platform_device *pdev, pm_message_t state)
+{
+        struct tegra_ehci_hcd *tegra = platform_get_drvdata(pdev);
+        struct usb_hcd *hcd = ehci_to_hcd(tegra->ehci);
+
+        if (tegra->bus_suspended)
+                return 0;
+
+        if (time_before(jiffies, tegra->ehci->next_statechange))
+                msleep(10);
+
+        return tegra_usb_suspend(hcd);
+}
+#endif
+
+static int tegra_ehci_remove(struct platform_device *pdev)
+{
+        struct tegra_ehci_hcd *tegra = platform_get_drvdata(pdev);
+        struct usb_hcd *hcd = ehci_to_hcd(tegra->ehci);
+
+        if (tegra == NULL || hcd == NULL)
+                return -EINVAL;
+
+#ifdef CONFIG_USB_OTG_UTILS
+        if (tegra->transceiver) {
+                otg_set_host(tegra->transceiver, NULL);
+                otg_put_transceiver(tegra->transceiver);
+        }
+#endif
+
+        usb_remove_hcd(hcd);
+        usb_put_hcd(hcd);
+
+        tegra_usb_phy_close(tegra->phy);
+        iounmap(hcd->regs);
+
+        clk_disable(tegra->clk);
+        clk_put(tegra->clk);
+
+        clk_disable(tegra->emc_clk);
+        clk_put(tegra->emc_clk);
+
+        kfree(tegra);
+        return 0;
+}
+
+static void tegra_ehci_hcd_shutdown(struct platform_device *pdev)
+{
+        struct tegra_ehci_hcd *tegra = platform_get_drvdata(pdev);
+        struct usb_hcd *hcd = ehci_to_hcd(tegra->ehci);
+
+        if (hcd->driver->shutdown)
+                hcd->driver->shutdown(hcd);
+}
+
+static struct platform_driver tegra_ehci_driver = {
+        .probe          = tegra_ehci_probe,
+        .remove         = tegra_ehci_remove,
+#ifdef CONFIG_PM
+        .suspend        = tegra_ehci_suspend,
+        .resume         = tegra_ehci_resume,
+#endif
+        .shutdown       = tegra_ehci_hcd_shutdown,
+        .driver         = {
+                .name   = "tegra-ehci",
+        }
+};
diff --git a/drivers/usb/host/ehci-vt8500.c b/drivers/usb/host/ehci-vt8500.c
new file mode 100644
index 000000000000..47d749631bc7
--- /dev/null
+++ b/drivers/usb/host/ehci-vt8500.c
@@ -0,0 +1,173 @@
+/*
+ * drivers/usb/host/ehci-vt8500.c
+ *
+ * Copyright (C) 2010 Alexey Charkov <alchark@gmail.com>
+ *
+ * Based on ehci-au1xxx.c
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * 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.
+ *
+ */
+
+#include <linux/platform_device.h>
+
+static int ehci_update_device(struct usb_hcd *hcd, struct usb_device *udev)
+{
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        int rc = 0;
+
+        if (!udev->parent) /* udev is root hub itself, impossible */
+                rc = -1;
+        /* we only support lpm device connected to root hub yet */
+        if (ehci->has_lpm && !udev->parent->parent) {
+                rc = ehci_lpm_set_da(ehci, udev->devnum, udev->portnum);
+                if (!rc)
+                        rc = ehci_lpm_check(ehci, udev->portnum);
+        }
+        return rc;
+}
+
+static const struct hc_driver vt8500_ehci_hc_driver = {
+        .description            = hcd_name,
+        .product_desc           = "VT8500 EHCI",
+        .hcd_priv_size          = sizeof(struct ehci_hcd),
+
+        /*
+         * generic hardware linkage
+         */
+        .irq                    = ehci_irq,
+        .flags                  = HCD_MEMORY | HCD_USB2,
+
+        /*
+         * basic lifecycle operations
+         */
+        .reset                  = ehci_init,
+        .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,
+        .endpoint_reset         = ehci_endpoint_reset,
+
+        /*
+         * 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,
+
+        /*
+         * call back when device connected and addressed
+         */
+        .update_device =        ehci_update_device,
+
+        .clear_tt_buffer_complete       = ehci_clear_tt_buffer_complete,
+};
+
+static int vt8500_ehci_drv_probe(struct platform_device *pdev)
+{
+        struct usb_hcd *hcd;
+        struct ehci_hcd *ehci;
+        struct resource *res;
+        int ret;
+
+        if (usb_disabled())
+                return -ENODEV;
+
+        if (pdev->resource[1].flags != IORESOURCE_IRQ) {
+                pr_debug("resource[1] is not IORESOURCE_IRQ");
+                return -ENOMEM;
+        }
+        hcd = usb_create_hcd(&vt8500_ehci_hc_driver, &pdev->dev, "VT8500");
+        if (!hcd)
+                return -ENOMEM;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        hcd->rsrc_start = res->start;
+        hcd->rsrc_len = resource_size(res);
+
+        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
+                pr_debug("request_mem_region failed");
+                ret = -EBUSY;
+                goto err1;
+        }
+
+        hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
+        if (!hcd->regs) {
+                pr_debug("ioremap failed");
+                ret = -ENOMEM;
+                goto err2;
+        }
+
+        ehci = hcd_to_ehci(hcd);
+        ehci->caps = hcd->regs;
+        ehci->regs = hcd->regs +
+                HC_LENGTH(ehci, readl(&ehci->caps->hc_capbase));
+
+        dbg_hcs_params(ehci, "reset");
+        dbg_hcc_params(ehci, "reset");
+
+        /* cache this readonly data; minimize chip reads */
+        ehci->hcs_params = readl(&ehci->caps->hcs_params);
+
+        ehci_port_power(ehci, 1);
+
+        ret = usb_add_hcd(hcd, pdev->resource[1].start,
+                          IRQF_DISABLED | IRQF_SHARED);
+        if (ret == 0) {
+                platform_set_drvdata(pdev, hcd);
+                return ret;
+        }
+
+        iounmap(hcd->regs);
+err2:
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+err1:
+        usb_put_hcd(hcd);
+        return ret;
+}
+
+static int vt8500_ehci_drv_remove(struct platform_device *pdev)
+{
+        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+
+        usb_remove_hcd(hcd);
+        iounmap(hcd->regs);
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+        usb_put_hcd(hcd);
+        platform_set_drvdata(pdev, NULL);
+
+        return 0;
+}
+
+static struct platform_driver vt8500_ehci_driver = {
+        .probe          = vt8500_ehci_drv_probe,
+        .remove         = vt8500_ehci_drv_remove,
+        .shutdown       = usb_hcd_platform_shutdown,
+        .driver = {
+                .name   = "vt8500-ehci",
+                .owner  = THIS_MODULE,
+        }
+};
+
+MODULE_ALIAS("platform:vt8500-ehci");
diff --git a/drivers/usb/host/ehci-w90x900.c b/drivers/usb/host/ehci-w90x900.c
index cfa21ea20f82..52a027aaa370 100644
--- a/drivers/usb/host/ehci-w90x900.c
+++ b/drivers/usb/host/ehci-w90x900.c
@@ -57,7 +57,7 @@ static int __devinit usb_w90x900_probe(const struct hc_driver *driver,
         ehci = hcd_to_ehci(hcd);
         ehci->caps = hcd->regs;
         ehci->regs = hcd->regs +
-                 HC_LENGTH(ehci_readl(ehci, &ehci->caps->hc_capbase));
+                HC_LENGTH(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
 
         /* enable PHY 0,1,the regs only apply to w90p910
         *  0xA4,0xA8 were offsets of PHY0 and PHY1 controller of
@@ -130,6 +130,7 @@ static const struct hc_driver ehci_w90x900_hc_driver = {
         .urb_enqueue = ehci_urb_enqueue,
         .urb_dequeue = ehci_urb_dequeue,
         .endpoint_disable = ehci_endpoint_disable,
+        .endpoint_reset = ehci_endpoint_reset,
 
         /*
          * scheduling support
@@ -147,6 +148,8 @@ static const struct hc_driver ehci_w90x900_hc_driver = {
 #endif
         .relinquish_port        = ehci_relinquish_port,
         .port_handed_over       = ehci_port_handed_over,
+
+        .clear_tt_buffer_complete = ehci_clear_tt_buffer_complete,
 };
 
 static int __devinit ehci_w90x900_probe(struct platform_device *pdev)
diff --git a/drivers/usb/host/ehci-xilinx-of.c b/drivers/usb/host/ehci-xilinx-of.c
index 6c8076ad821d..a64d6d66d760 100644
--- a/drivers/usb/host/ehci-xilinx-of.c
+++ b/drivers/usb/host/ehci-xilinx-of.c
@@ -29,6 +29,7 @@
 
 #include <linux/of.h>
 #include <linux/of_platform.h>
+#include <linux/of_address.h>
 
 /**
  * ehci_xilinx_of_setup - Initialize the device for ehci_reset()
@@ -117,6 +118,7 @@ static const struct hc_driver ehci_xilinx_of_hc_driver = {
         .urb_enqueue            = ehci_urb_enqueue,
         .urb_dequeue            = ehci_urb_dequeue,
         .endpoint_disable       = ehci_endpoint_disable,
+        .endpoint_reset         = ehci_endpoint_reset,
 
         /*
          * scheduling support
@@ -141,15 +143,13 @@ static const struct hc_driver ehci_xilinx_of_hc_driver = {
 /**
  * ehci_hcd_xilinx_of_probe - Probe method for the USB host controller
  * @op:         pointer to the platform_device bound to the host controller
- * @match:      pointer to of_device_id structure, not used
  *
  * This function requests resources and sets up appropriate properties for the
  * host controller. Because the Xilinx USB host controller can be configured
  * as HS only or HS/FS only, it checks the configuration in the device tree
  * entry, and sets an appropriate value for hcd->has_tt.
  */
-static int __devinit
-ehci_hcd_xilinx_of_probe(struct platform_device *op, const struct of_device_id *match)
+static int __devinit ehci_hcd_xilinx_of_probe(struct platform_device *op)
 {
         struct device_node *dn = op->dev.of_node;
         struct usb_hcd *hcd;
@@ -220,7 +220,7 @@ ehci_hcd_xilinx_of_probe(struct platform_device *op, const struct of_device_id *
          */
         ehci->caps = hcd->regs + 0x100;
         ehci->regs = hcd->regs + 0x100 +
-                        HC_LENGTH(ehci_readl(ehci, &ehci->caps->hc_capbase));
+                HC_LENGTH(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
 
         /* cache this readonly data; minimize chip reads */
         ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
@@ -287,7 +287,7 @@ static const struct of_device_id ehci_hcd_xilinx_of_match[] = {
 };
 MODULE_DEVICE_TABLE(of, ehci_hcd_xilinx_of_match);
 
-static struct of_platform_driver ehci_hcd_xilinx_of_driver = {
+static struct platform_driver ehci_hcd_xilinx_of_driver = {
         .probe          = ehci_hcd_xilinx_of_probe,
         .remove         = ehci_hcd_xilinx_of_remove,
         .shutdown       = ehci_hcd_xilinx_of_shutdown,
diff --git a/drivers/usb/host/ehci.h b/drivers/usb/host/ehci.h
index bde823f704e9..bd6ff489baf9 100644
--- a/drivers/usb/host/ehci.h
+++ b/drivers/usb/host/ehci.h
@@ -73,6 +73,7 @@ struct ehci_hcd {			/* one per controller */
 
         /* async schedule support */
         struct ehci_qh          *async;
+        struct ehci_qh          *dummy;         /* For AMD quirk use */
         struct ehci_qh          *reclaim;
         unsigned                scanning : 1;
 
@@ -117,6 +118,7 @@ struct ehci_hcd {			/* one per controller */
         struct timer_list       watchdog;
         unsigned long           actions;
         unsigned                stamp;
+        unsigned                periodic_stamp;
         unsigned                random_frame;
         unsigned long           next_statechange;
         ktime_t                 last_periodic_enable;
@@ -127,10 +129,14 @@ struct ehci_hcd {			/* one per controller */
         unsigned                has_fsl_port_bug:1; /* FreeScale */
         unsigned                big_endian_mmio:1;
         unsigned                big_endian_desc:1;
+        unsigned                big_endian_capbase:1;
         unsigned                has_amcc_usb23:1;
         unsigned                need_io_watchdog:1;
         unsigned                broken_periodic:1;
+        unsigned                amd_pll_fix:1;
         unsigned                fs_i_thresh:1;  /* Intel iso scheduling */
+        unsigned                use_dummy_qh:1; /* AMD Frame List table quirk*/
+        unsigned                has_synopsys_hc_bug:1; /* Synopsys HC */
 
         /* required for usb32 quirk */
         #define OHCI_CTRL_HCFS          (3 << 6)
@@ -157,6 +163,10 @@ struct ehci_hcd {			/* one per controller */
 #ifdef DEBUG
         struct dentry           *debug_dir;
 #endif
+        /*
+         * OTG controllers and transceivers need software interaction
+         */
+        struct otg_transceiver  *transceiver;
 };
 
 /* convert between an HCD pointer and the corresponding EHCI_HCD */
@@ -597,12 +607,18 @@ ehci_port_speed(struct ehci_hcd *ehci, unsigned int portsc)
  * This attempts to support either format at compile time without a
  * runtime penalty, or both formats with the additional overhead
  * of checking a flag bit.
+ *
+ * ehci_big_endian_capbase is a special quirk for controllers that
+ * implement the HC capability registers as separate registers and not
+ * as fields of a 32-bit register.
  */
 
 #ifdef CONFIG_USB_EHCI_BIG_ENDIAN_MMIO
 #define ehci_big_endian_mmio(e)         ((e)->big_endian_mmio)
+#define ehci_big_endian_capbase(e)      ((e)->big_endian_capbase)
 #else
 #define ehci_big_endian_mmio(e)         0
+#define ehci_big_endian_capbase(e)      0
 #endif
 
 /*
@@ -641,7 +657,7 @@ static inline void ehci_writel(const struct ehci_hcd *ehci,
 /*
  * On certain ppc-44x SoC there is a HW issue, that could only worked around with
  * explicit suspend/operate of OHCI. This function hereby makes sense only on that arch.
- * Other common bits are dependant on has_amcc_usb23 quirk flag.
+ * Other common bits are dependent on has_amcc_usb23 quirk flag.
  */
 #ifdef CONFIG_44x
 static inline void set_ohci_hcfs(struct ehci_hcd *ehci, int operational)
diff --git a/drivers/usb/host/fhci-hcd.c b/drivers/usb/host/fhci-hcd.c
index 20092a27a1e8..19223c7449e1 100644
--- a/drivers/usb/host/fhci-hcd.c
+++ b/drivers/usb/host/fhci-hcd.c
@@ -98,13 +98,13 @@ void fhci_usb_enable_interrupt(struct fhci_usb *usb)
         usb->intr_nesting_cnt--;
 }
 
-/* diable the usb interrupt */
+/* disable the usb interrupt */
 void fhci_usb_disable_interrupt(struct fhci_usb *usb)
 {
         struct fhci_hcd *fhci = usb->fhci;
 
         if (usb->intr_nesting_cnt == 0) {
-                /* diable the timer interrupt */
+                /* disable the timer interrupt */
                 disable_irq_nosync(fhci->timer->irq);
 
                 /* disable the usb interrupt */
@@ -401,7 +401,7 @@ static int fhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb,
                 /* 1 td fro setup,1 for ack */
                 size = 2;
         case PIPE_BULK:
-                /* one td for every 4096 bytes(can be upto 8k) */
+                /* one td for every 4096 bytes(can be up to 8k) */
                 size += urb->transfer_buffer_length / 4096;
                 /* ...add for any remaining bytes... */
                 if ((urb->transfer_buffer_length % 4096) != 0)
@@ -561,8 +561,7 @@ static const struct hc_driver fhci_driver = {
         .hub_control = fhci_hub_control,
 };
 
-static int __devinit of_fhci_probe(struct platform_device *ofdev,
-                                   const struct of_device_id *ofid)
+static int __devinit of_fhci_probe(struct platform_device *ofdev)
 {
         struct device *dev = &ofdev->dev;
         struct device_node *node = dev->of_node;
@@ -812,7 +811,7 @@ static const struct of_device_id of_fhci_match[] = {
 };
 MODULE_DEVICE_TABLE(of, of_fhci_match);
 
-static struct of_platform_driver of_fhci_driver = {
+static struct platform_driver of_fhci_driver = {
         .driver = {
                 .name = "fsl,usb-fhci",
                 .owner = THIS_MODULE,
@@ -824,13 +823,13 @@ static struct of_platform_driver of_fhci_driver = {
 
 static int __init fhci_module_init(void)
 {
-        return of_register_platform_driver(&of_fhci_driver);
+        return platform_driver_register(&of_fhci_driver);
 }
 module_init(fhci_module_init);
 
 static void __exit fhci_module_exit(void)
 {
-        of_unregister_platform_driver(&of_fhci_driver);
+        platform_driver_unregister(&of_fhci_driver);
 }
 module_exit(fhci_module_exit);
 
diff --git a/drivers/usb/host/fhci-tds.c b/drivers/usb/host/fhci-tds.c
index 7be548ca2183..0ea577bfca2a 100644
--- a/drivers/usb/host/fhci-tds.c
+++ b/drivers/usb/host/fhci-tds.c
@@ -40,7 +40,7 @@
 #define TD_RXER         0x0020 /* Rx error or not */
 
 #define TD_NAK          0x0010 /* No ack. */
-#define TD_STAL         0x0008 /* Stall recieved */
+#define TD_STAL         0x0008 /* Stall received */
 #define TD_TO           0x0004 /* time out */
 #define TD_UN           0x0002 /* underrun */
 #define TD_NO           0x0010 /* Rx Non Octet Aligned Packet */
@@ -271,10 +271,10 @@ void fhci_init_ep_registers(struct fhci_usb *usb, struct endpoint *ep,
 
 /*
  * Collect the submitted frames and inform the application about them
- * It is also prepearing the TDs for new frames. If the Tx interrupts
- * are diabled, the application should call that routine to get
+ * It is also preparing the TDs for new frames. If the Tx interrupts
+ * are disabled, the application should call that routine to get
  * confirmation about the submitted frames. Otherwise, the routine is
- * called frome the interrupt service routine during the Tx interrupt.
+ * called from the interrupt service routine during the Tx interrupt.
  * In that case the application is informed by calling the application
  * specific 'fhci_transaction_confirm' routine
  */
@@ -337,7 +337,7 @@ static void fhci_td_transaction_confirm(struct fhci_usb *usb)
                                         pkt->status = USB_TD_RX_ER_NONOCT;
                                 else
                                         fhci_err(usb->fhci, "illegal error "
-                                                 "occured\n");
+                                                 "occurred\n");
                         } else if (td_status & TD_NAK)
                                 pkt->status = USB_TD_TX_ER_NAK;
                         else if (td_status & TD_TO)
@@ -347,7 +347,7 @@ static void fhci_td_transaction_confirm(struct fhci_usb *usb)
                         else if (td_status & TD_STAL)
                                 pkt->status = USB_TD_TX_ER_STALL;
                         else
-                                fhci_err(usb->fhci, "illegal error occured\n");
+                                fhci_err(usb->fhci, "illegal error occurred\n");
                 } else if ((extra_data & TD_TOK_IN) &&
                                 pkt->len > td_length - CRC_SIZE) {
                         pkt->status = USB_TD_RX_DATA_UNDERUN;
diff --git a/drivers/usb/host/fhci.h b/drivers/usb/host/fhci.h
index 71c3caaea4c1..dc6939a44a1a 100644
--- a/drivers/usb/host/fhci.h
+++ b/drivers/usb/host/fhci.h
@@ -82,7 +82,7 @@
 #define USB_TD_RX_ER_NONOCT     0x40000000 /* Tx Non Octet Aligned Packet */
 #define USB_TD_RX_ER_BITSTUFF   0x20000000 /* Frame Aborted-Received pkt */
 #define USB_TD_RX_ER_CRC        0x10000000 /* CRC error */
-#define USB_TD_RX_ER_OVERUN     0x08000000 /* Over - run occured */
+#define USB_TD_RX_ER_OVERUN     0x08000000 /* Over - run occurred */
 #define USB_TD_RX_ER_PID        0x04000000 /* wrong PID received */
 #define USB_TD_RX_DATA_UNDERUN  0x02000000 /* shorter than expected */
 #define USB_TD_RX_DATA_OVERUN   0x01000000 /* longer than expected */
@@ -363,7 +363,7 @@ struct ed {
 struct td {
         void *data;              /* a pointer to the data buffer */
         unsigned int len;        /* length of the data to be submitted */
-        unsigned int actual_len; /* actual bytes transfered on this td */
+        unsigned int actual_len; /* actual bytes transferred on this td */
         enum fhci_ta_type type;  /* transaction type */
         u8 toggle;               /* toggle for next trans. within this TD */
         u16 iso_index;           /* ISO transaction index */
diff --git a/drivers/usb/host/fsl-mph-dr-of.c b/drivers/usb/host/fsl-mph-dr-of.c
new file mode 100644
index 000000000000..79a66d622f9c
--- /dev/null
+++ b/drivers/usb/host/fsl-mph-dr-of.c
@@ -0,0 +1,313 @@
+/*
+ * Setup platform devices needed by the Freescale multi-port host
+ * and/or dual-role USB controller modules based on the description
+ * in flat device tree.
+ *
+ * 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.
+ */
+
+#include <linux/kernel.h>
+#include <linux/platform_device.h>
+#include <linux/fsl_devices.h>
+#include <linux/err.h>
+#include <linux/io.h>
+#include <linux/of_platform.h>
+#include <linux/clk.h>
+
+struct fsl_usb2_dev_data {
+        char *dr_mode;          /* controller mode */
+        char *drivers[3];       /* drivers to instantiate for this mode */
+        enum fsl_usb2_operating_modes op_mode;  /* operating mode */
+};
+
+struct fsl_usb2_dev_data dr_mode_data[] __devinitdata = {
+        {
+                .dr_mode = "host",
+                .drivers = { "fsl-ehci", NULL, NULL, },
+                .op_mode = FSL_USB2_DR_HOST,
+        },
+        {
+                .dr_mode = "otg",
+                .drivers = { "fsl-usb2-otg", "fsl-ehci", "fsl-usb2-udc", },
+                .op_mode = FSL_USB2_DR_OTG,
+        },
+        {
+                .dr_mode = "peripheral",
+                .drivers = { "fsl-usb2-udc", NULL, NULL, },
+                .op_mode = FSL_USB2_DR_DEVICE,
+        },
+};
+
+struct fsl_usb2_dev_data * __devinit get_dr_mode_data(struct device_node *np)
+{
+        const unsigned char *prop;
+        int i;
+
+        prop = of_get_property(np, "dr_mode", NULL);
+        if (prop) {
+                for (i = 0; i < ARRAY_SIZE(dr_mode_data); i++) {
+                        if (!strcmp(prop, dr_mode_data[i].dr_mode))
+                                return &dr_mode_data[i];
+                }
+        }
+        pr_warn("%s: Invalid 'dr_mode' property, fallback to host mode\n",
+                np->full_name);
+        return &dr_mode_data[0]; /* mode not specified, use host */
+}
+
+static enum fsl_usb2_phy_modes __devinit determine_usb_phy(const char *phy_type)
+{
+        if (!phy_type)
+                return FSL_USB2_PHY_NONE;
+        if (!strcasecmp(phy_type, "ulpi"))
+                return FSL_USB2_PHY_ULPI;
+        if (!strcasecmp(phy_type, "utmi"))
+                return FSL_USB2_PHY_UTMI;
+        if (!strcasecmp(phy_type, "utmi_wide"))
+                return FSL_USB2_PHY_UTMI_WIDE;
+        if (!strcasecmp(phy_type, "serial"))
+                return FSL_USB2_PHY_SERIAL;
+
+        return FSL_USB2_PHY_NONE;
+}
+
+struct platform_device * __devinit fsl_usb2_device_register(
+                                        struct platform_device *ofdev,
+                                        struct fsl_usb2_platform_data *pdata,
+                                        const char *name, int id)
+{
+        struct platform_device *pdev;
+        const struct resource *res = ofdev->resource;
+        unsigned int num = ofdev->num_resources;
+        int retval;
+
+        pdev = platform_device_alloc(name, id);
+        if (!pdev) {
+                retval = -ENOMEM;
+                goto error;
+        }
+
+        pdev->dev.parent = &ofdev->dev;
+
+        pdev->dev.coherent_dma_mask = ofdev->dev.coherent_dma_mask;
+        pdev->dev.dma_mask = &pdev->archdata.dma_mask;
+        *pdev->dev.dma_mask = *ofdev->dev.dma_mask;
+
+        retval = platform_device_add_data(pdev, pdata, sizeof(*pdata));
+        if (retval)
+                goto error;
+
+        if (num) {
+                retval = platform_device_add_resources(pdev, res, num);
+                if (retval)
+                        goto error;
+        }
+
+        retval = platform_device_add(pdev);
+        if (retval)
+                goto error;
+
+        return pdev;
+
+error:
+        platform_device_put(pdev);
+        return ERR_PTR(retval);
+}
+
+static const struct of_device_id fsl_usb2_mph_dr_of_match[];
+
+static int __devinit fsl_usb2_mph_dr_of_probe(struct platform_device *ofdev)
+{
+        struct device_node *np = ofdev->dev.of_node;
+        struct platform_device *usb_dev;
+        struct fsl_usb2_platform_data data, *pdata;
+        struct fsl_usb2_dev_data *dev_data;
+        const struct of_device_id *match;
+        const unsigned char *prop;
+        static unsigned int idx;
+        int i;
+
+        if (!of_device_is_available(np))
+                return -ENODEV;
+
+        match = of_match_device(fsl_usb2_mph_dr_of_match, &ofdev->dev);
+        if (!match)
+                return -ENODEV;
+
+        pdata = &data;
+        if (match->data)
+                memcpy(pdata, match->data, sizeof(data));
+        else
+                memset(pdata, 0, sizeof(data));
+
+        dev_data = get_dr_mode_data(np);
+
+        if (of_device_is_compatible(np, "fsl-usb2-mph")) {
+                if (of_get_property(np, "port0", NULL))
+                        pdata->port_enables |= FSL_USB2_PORT0_ENABLED;
+
+                if (of_get_property(np, "port1", NULL))
+                        pdata->port_enables |= FSL_USB2_PORT1_ENABLED;
+
+                pdata->operating_mode = FSL_USB2_MPH_HOST;
+        } else {
+                if (of_get_property(np, "fsl,invert-drvvbus", NULL))
+                        pdata->invert_drvvbus = 1;
+
+                if (of_get_property(np, "fsl,invert-pwr-fault", NULL))
+                        pdata->invert_pwr_fault = 1;
+
+                /* setup mode selected in the device tree */
+                pdata->operating_mode = dev_data->op_mode;
+        }
+
+        prop = of_get_property(np, "phy_type", NULL);
+        pdata->phy_mode = determine_usb_phy(prop);
+
+        for (i = 0; i < ARRAY_SIZE(dev_data->drivers); i++) {
+                if (!dev_data->drivers[i])
+                        continue;
+                usb_dev = fsl_usb2_device_register(ofdev, pdata,
+                                        dev_data->drivers[i], idx);
+                if (IS_ERR(usb_dev)) {
+                        dev_err(&ofdev->dev, "Can't register usb device\n");
+                        return PTR_ERR(usb_dev);
+                }
+        }
+        idx++;
+        return 0;
+}
+
+static int __devexit __unregister_subdev(struct device *dev, void *d)
+{
+        platform_device_unregister(to_platform_device(dev));
+        return 0;
+}
+
+static int __devexit fsl_usb2_mph_dr_of_remove(struct platform_device *ofdev)
+{
+        device_for_each_child(&ofdev->dev, NULL, __unregister_subdev);
+        return 0;
+}
+
+#ifdef CONFIG_PPC_MPC512x
+
+#define USBGENCTRL              0x200           /* NOTE: big endian */
+#define GC_WU_INT_CLR           (1 << 5)        /* Wakeup int clear */
+#define GC_ULPI_SEL             (1 << 4)        /* ULPI i/f select (usb0 only)*/
+#define GC_PPP                  (1 << 3)        /* Inv. Port Power Polarity */
+#define GC_PFP                  (1 << 2)        /* Inv. Power Fault Polarity */
+#define GC_WU_ULPI_EN           (1 << 1)        /* Wakeup on ULPI event */
+#define GC_WU_IE                (1 << 1)        /* Wakeup interrupt enable */
+
+#define ISIPHYCTRL              0x204           /* NOTE: big endian */
+#define PHYCTRL_PHYE            (1 << 4)        /* On-chip UTMI PHY enable */
+#define PHYCTRL_BSENH           (1 << 3)        /* Bit Stuff Enable High */
+#define PHYCTRL_BSEN            (1 << 2)        /* Bit Stuff Enable */
+#define PHYCTRL_LSFE            (1 << 1)        /* Line State Filter Enable */
+#define PHYCTRL_PXE             (1 << 0)        /* PHY oscillator enable */
+
+int fsl_usb2_mpc5121_init(struct platform_device *pdev)
+{
+        struct fsl_usb2_platform_data *pdata = pdev->dev.platform_data;
+        struct clk *clk;
+        char clk_name[10];
+        int base, clk_num;
+
+        base = pdev->resource->start & 0xf000;
+        if (base == 0x3000)
+                clk_num = 1;
+        else if (base == 0x4000)
+                clk_num = 2;
+        else
+                return -ENODEV;
+
+        snprintf(clk_name, sizeof(clk_name), "usb%d_clk", clk_num);
+        clk = clk_get(&pdev->dev, clk_name);
+        if (IS_ERR(clk)) {
+                dev_err(&pdev->dev, "failed to get clk\n");
+                return PTR_ERR(clk);
+        }
+
+        clk_enable(clk);
+        pdata->clk = clk;
+
+        if (pdata->phy_mode == FSL_USB2_PHY_UTMI_WIDE) {
+                u32 reg = 0;
+
+                if (pdata->invert_drvvbus)
+                        reg |= GC_PPP;
+
+                if (pdata->invert_pwr_fault)
+                        reg |= GC_PFP;
+
+                out_be32(pdata->regs + ISIPHYCTRL, PHYCTRL_PHYE | PHYCTRL_PXE);
+                out_be32(pdata->regs + USBGENCTRL, reg);
+        }
+        return 0;
+}
+
+static void fsl_usb2_mpc5121_exit(struct platform_device *pdev)
+{
+        struct fsl_usb2_platform_data *pdata = pdev->dev.platform_data;
+
+        pdata->regs = NULL;
+
+        if (pdata->clk) {
+                clk_disable(pdata->clk);
+                clk_put(pdata->clk);
+        }
+}
+
+static struct fsl_usb2_platform_data fsl_usb2_mpc5121_pd = {
+        .big_endian_desc = 1,
+        .big_endian_mmio = 1,
+        .es = 1,
+        .have_sysif_regs = 0,
+        .le_setup_buf = 1,
+        .init = fsl_usb2_mpc5121_init,
+        .exit = fsl_usb2_mpc5121_exit,
+};
+#endif /* CONFIG_PPC_MPC512x */
+
+static struct fsl_usb2_platform_data fsl_usb2_mpc8xxx_pd = {
+        .have_sysif_regs = 1,
+};
+
+static const struct of_device_id fsl_usb2_mph_dr_of_match[] = {
+        { .compatible = "fsl-usb2-mph", .data = &fsl_usb2_mpc8xxx_pd, },
+        { .compatible = "fsl-usb2-dr", .data = &fsl_usb2_mpc8xxx_pd, },
+#ifdef CONFIG_PPC_MPC512x
+        { .compatible = "fsl,mpc5121-usb2-dr", .data = &fsl_usb2_mpc5121_pd, },
+#endif
+        {},
+};
+
+static struct platform_driver fsl_usb2_mph_dr_driver = {
+        .driver = {
+                .name = "fsl-usb2-mph-dr",
+                .owner = THIS_MODULE,
+                .of_match_table = fsl_usb2_mph_dr_of_match,
+        },
+        .probe  = fsl_usb2_mph_dr_of_probe,
+        .remove = __devexit_p(fsl_usb2_mph_dr_of_remove),
+};
+
+static int __init fsl_usb2_mph_dr_init(void)
+{
+        return platform_driver_register(&fsl_usb2_mph_dr_driver);
+}
+module_init(fsl_usb2_mph_dr_init);
+
+static void __exit fsl_usb2_mph_dr_exit(void)
+{
+        platform_driver_unregister(&fsl_usb2_mph_dr_driver);
+}
+module_exit(fsl_usb2_mph_dr_exit);
+
+MODULE_DESCRIPTION("FSL MPH DR OF devices driver");
+MODULE_AUTHOR("Anatolij Gustschin <agust@denx.de>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/usb/host/imx21-dbg.c b/drivers/usb/host/imx21-dbg.c
index 512f647448ca..6d7533427163 100644
--- a/drivers/usb/host/imx21-dbg.c
+++ b/drivers/usb/host/imx21-dbg.c
@@ -384,7 +384,7 @@ static void debug_isoc_show_one(struct seq_file *s,
         seq_printf(s, "%s %d:\n"
                 "cc=0X%02X\n"
                 "scheduled frame %d (%d)\n"
-                "submittted frame %d (%d)\n"
+                "submitted frame %d (%d)\n"
                 "completed frame %d (%d)\n"
                 "requested length=%d\n"
                 "completed length=%d\n\n",
diff --git a/drivers/usb/host/imx21-hcd.c b/drivers/usb/host/imx21-hcd.c
index 3e5630369c31..af05718bdc73 100644
--- a/drivers/usb/host/imx21-hcd.c
+++ b/drivers/usb/host/imx21-hcd.c
@@ -27,8 +27,8 @@
   *    * 32 transfer descriptors (called ETDs)
   *    * 4Kb of Data memory
   *
-  * The data memory is shared between the host and fuction controlers
-  * (but this driver only supports the host controler)
+  * The data memory is shared between the host and function controllers
+  * (but this driver only supports the host controller)
   *
   * So setting up a transfer involves:
   *    * Allocating a ETD
@@ -57,6 +57,7 @@
 #include <linux/slab.h>
 #include <linux/usb.h>
 #include <linux/usb/hcd.h>
+#include <linux/dma-mapping.h>
 
 #include "imx21-hcd.h"
 
@@ -136,9 +137,18 @@ static int imx21_hc_get_frame(struct usb_hcd *hcd)
         return wrap_frame(readl(imx21->regs + USBH_FRMNUB));
 }
 
+static inline bool unsuitable_for_dma(dma_addr_t addr)
+{
+        return (addr & 3) != 0;
+}
 
 #include "imx21-dbg.c"
 
+static void nonisoc_urb_completed_for_etd(
+        struct imx21 *imx21, struct etd_priv *etd, int status);
+static void schedule_nonisoc_etd(struct imx21 *imx21, struct urb *urb);
+static void free_dmem(struct imx21 *imx21, struct etd_priv *etd);
+
 /* =========================================== */
 /* ETD management                               */
 /* ===========================================  */
@@ -185,7 +195,8 @@ static void reset_etd(struct imx21 *imx21, int num)
                 etd_writel(imx21, num, i, 0);
         etd->urb = NULL;
         etd->ep = NULL;
-        etd->td = NULL;;
+        etd->td = NULL;
+        etd->bounce_buffer = NULL;
 }
 
 static void free_etd(struct imx21 *imx21, int num)
@@ -221,26 +232,94 @@ static void setup_etd_dword0(struct imx21 *imx21,
                 ((u32) maxpacket << DW0_MAXPKTSIZ));
 }
 
-static void activate_etd(struct imx21 *imx21,
-        int etd_num, dma_addr_t dma, u8 dir)
+/**
+ * Copy buffer to data controller data memory.
+ * We cannot use memcpy_toio() because the hardware requires 32bit writes
+ */
+static void copy_to_dmem(
+        struct imx21 *imx21, int dmem_offset, void *src, int count)
+{
+        void __iomem *dmem = imx21->regs + USBOTG_DMEM + dmem_offset;
+        u32 word = 0;
+        u8 *p = src;
+        int byte = 0;
+        int i;
+
+        for (i = 0; i < count; i++) {
+                byte = i % 4;
+                word += (*p++ << (byte * 8));
+                if (byte == 3) {
+                        writel(word, dmem);
+                        dmem += 4;
+                        word = 0;
+                }
+        }
+
+        if (count && byte != 3)
+                writel(word, dmem);
+}
+
+static void activate_etd(struct imx21 *imx21, int etd_num, u8 dir)
 {
         u32 etd_mask = 1 << etd_num;
         struct etd_priv *etd = &imx21->etd[etd_num];
 
+        if (etd->dma_handle && unsuitable_for_dma(etd->dma_handle)) {
+                /* For non aligned isoc the condition below is always true */
+                if (etd->len <= etd->dmem_size) {
+                        /* Fits into data memory, use PIO */
+                        if (dir != TD_DIR_IN) {
+                                copy_to_dmem(imx21,
+                                                etd->dmem_offset,
+                                                etd->cpu_buffer, etd->len);
+                        }
+                        etd->dma_handle = 0;
+
+                } else {
+                        /* Too big for data memory, use bounce buffer */
+                        enum dma_data_direction dmadir;
+
+                        if (dir == TD_DIR_IN) {
+                                dmadir = DMA_FROM_DEVICE;
+                                etd->bounce_buffer = kmalloc(etd->len,
+                                                                GFP_ATOMIC);
+                        } else {
+                                dmadir = DMA_TO_DEVICE;
+                                etd->bounce_buffer = kmemdup(etd->cpu_buffer,
+                                                                etd->len,
+                                                                GFP_ATOMIC);
+                        }
+                        if (!etd->bounce_buffer) {
+                                dev_err(imx21->dev, "failed bounce alloc\n");
+                                goto err_bounce_alloc;
+                        }
+
+                        etd->dma_handle =
+                                dma_map_single(imx21->dev,
+                                                etd->bounce_buffer,
+                                                etd->len,
+                                                dmadir);
+                        if (dma_mapping_error(imx21->dev, etd->dma_handle)) {
+                                dev_err(imx21->dev, "failed bounce map\n");
+                                goto err_bounce_map;
+                        }
+                }
+        }
+
         clear_toggle_bit(imx21, USBH_ETDDONESTAT, etd_mask);
         set_register_bits(imx21, USBH_ETDDONEEN, etd_mask);
         clear_toggle_bit(imx21, USBH_XFILLSTAT, etd_mask);
         clear_toggle_bit(imx21, USBH_YFILLSTAT, etd_mask);
 
-        if (dma) {
+        if (etd->dma_handle) {
                 set_register_bits(imx21, USB_ETDDMACHANLCLR, etd_mask);
                 clear_toggle_bit(imx21, USBH_XBUFSTAT, etd_mask);
                 clear_toggle_bit(imx21, USBH_YBUFSTAT, etd_mask);
-                writel(dma, imx21->regs + USB_ETDSMSA(etd_num));
+                writel(etd->dma_handle, imx21->regs + USB_ETDSMSA(etd_num));
                 set_register_bits(imx21, USB_ETDDMAEN, etd_mask);
         } else {
                 if (dir != TD_DIR_IN) {
-                        /* need to set for ZLP */
+                        /* need to set for ZLP and PIO */
                         set_toggle_bit(imx21, USBH_XFILLSTAT, etd_mask);
                         set_toggle_bit(imx21, USBH_YFILLSTAT, etd_mask);
                 }
@@ -263,6 +342,14 @@ static void activate_etd(struct imx21 *imx21,
 
         etd->active_count = 1;
         writel(etd_mask, imx21->regs + USBH_ETDENSET);
+        return;
+
+err_bounce_map:
+        kfree(etd->bounce_buffer);
+
+err_bounce_alloc:
+        free_dmem(imx21, etd);
+        nonisoc_urb_completed_for_etd(imx21, etd, -ENOMEM);
 }
 
 /* ===========================================  */
@@ -323,16 +410,23 @@ static void activate_queued_etd(struct imx21 *imx21,
         etd_writel(imx21, etd_num, 1,
             ((dmem_offset + maxpacket) << DW1_YBUFSRTAD) | dmem_offset);
 
+        etd->dmem_offset = dmem_offset;
         urb_priv->active = 1;
-        activate_etd(imx21, etd_num, etd->dma_handle, dir);
+        activate_etd(imx21, etd_num, dir);
 }
 
-static void free_dmem(struct imx21 *imx21, int offset)
+static void free_dmem(struct imx21 *imx21, struct etd_priv *etd)
 {
         struct imx21_dmem_area *area;
-        struct etd_priv *etd, *tmp;
+        struct etd_priv *tmp;
         int found = 0;
+        int offset;
 
+        if (!etd->dmem_size)
+                return;
+        etd->dmem_size = 0;
+
+        offset = etd->dmem_offset;
         list_for_each_entry(area, &imx21->dmem_list, list) {
                 if (area->offset == offset) {
                         debug_dmem_freed(imx21, area->size);
@@ -378,20 +472,23 @@ static void free_epdmem(struct imx21 *imx21, struct usb_host_endpoint *ep)
 /* ===========================================  */
 /* End handling                                 */
 /* ===========================================  */
-static void schedule_nonisoc_etd(struct imx21 *imx21, struct urb *urb);
 
 /* Endpoint now idle - release it's ETD(s) or asssign to queued request */
 static void ep_idle(struct imx21 *imx21, struct ep_priv *ep_priv)
 {
-        int etd_num;
         int i;
 
         for (i = 0; i < NUM_ISO_ETDS; i++) {
-                etd_num = ep_priv->etd[i];
+                int etd_num = ep_priv->etd[i];
+                struct etd_priv *etd;
                 if (etd_num < 0)
                         continue;
 
+                etd = &imx21->etd[etd_num];
                 ep_priv->etd[i] = -1;
+
+                free_dmem(imx21, etd); /* for isoc */
+
                 if (list_empty(&imx21->queue_for_etd)) {
                         free_etd(imx21, etd_num);
                         continue;
@@ -437,6 +534,24 @@ __acquires(imx21->lock)
                 ep_idle(imx21, ep_priv);
 }
 
+static void nonisoc_urb_completed_for_etd(
+        struct imx21 *imx21, struct etd_priv *etd, int status)
+{
+        struct usb_host_endpoint *ep = etd->ep;
+
+        urb_done(imx21->hcd, etd->urb, status);
+        etd->urb = NULL;
+
+        if (!list_empty(&ep->urb_list)) {
+                struct urb *urb = list_first_entry(
+                                        &ep->urb_list, struct urb, urb_list);
+
+                dev_vdbg(imx21->dev, "next URB %p\n", urb);
+                schedule_nonisoc_etd(imx21, urb);
+        }
+}
+
+
 /* ===========================================  */
 /* ISOC Handling ...                            */
 /* ===========================================  */
@@ -489,6 +604,8 @@ too_late:
                 etd->ep = td->ep;
                 etd->urb = td->urb;
                 etd->len = td->len;
+                etd->dma_handle = td->dma_handle;
+                etd->cpu_buffer = td->cpu_buffer;
 
                 debug_isoc_submitted(imx21, cur_frame, td);
 
@@ -502,16 +619,17 @@ too_late:
                         (TD_NOTACCESSED << DW3_COMPCODE0) |
                         (td->len << DW3_PKTLEN0));
 
-                activate_etd(imx21, etd_num, td->data, dir);
+                activate_etd(imx21, etd_num, dir);
         }
 }
 
-static void isoc_etd_done(struct usb_hcd *hcd, struct urb *urb, int etd_num)
+static void isoc_etd_done(struct usb_hcd *hcd, int etd_num)
 {
         struct imx21 *imx21 = hcd_to_imx21(hcd);
         int etd_mask = 1 << etd_num;
-        struct urb_priv *urb_priv = urb->hcpriv;
         struct etd_priv *etd = imx21->etd + etd_num;
+        struct urb *urb = etd->urb;
+        struct urb_priv *urb_priv = urb->hcpriv;
         struct td *td = etd->td;
         struct usb_host_endpoint *ep = etd->ep;
         int isoc_index = td->isoc_index;
@@ -545,8 +663,13 @@ static void isoc_etd_done(struct usb_hcd *hcd, struct urb *urb, int etd_num)
                         bytes_xfrd, td->len, urb, etd_num, isoc_index);
         }
 
-        if (dir_in)
+        if (dir_in) {
                 clear_toggle_bit(imx21, USBH_XFILLSTAT, etd_mask);
+                if (!etd->dma_handle)
+                        memcpy_fromio(etd->cpu_buffer,
+                                imx21->regs + USBOTG_DMEM + etd->dmem_offset,
+                                bytes_xfrd);
+        }
 
         urb->actual_length += bytes_xfrd;
         urb->iso_frame_desc[isoc_index].actual_length = bytes_xfrd;
@@ -569,30 +692,43 @@ static struct ep_priv *alloc_isoc_ep(
         int i;
 
         ep_priv = kzalloc(sizeof(struct ep_priv), GFP_ATOMIC);
-        if (ep_priv == NULL)
+        if (!ep_priv)
                 return NULL;
 
-        /* Allocate the ETDs */
-        for (i = 0; i < NUM_ISO_ETDS; i++) {
-                ep_priv->etd[i] = alloc_etd(imx21);
-                if (ep_priv->etd[i] < 0) {
-                        int j;
-                        dev_err(imx21->dev, "isoc: Couldn't allocate etd\n");
-                        for (j = 0; j < i; j++)
-                                free_etd(imx21, ep_priv->etd[j]);
-                        goto alloc_etd_failed;
-                }
-                imx21->etd[ep_priv->etd[i]].ep = ep;
-        }
+        for (i = 0; i < NUM_ISO_ETDS; i++)
+                ep_priv->etd[i] = -1;
 
         INIT_LIST_HEAD(&ep_priv->td_list);
         ep_priv->ep = ep;
         ep->hcpriv = ep_priv;
         return ep_priv;
+}
+
+static int alloc_isoc_etds(struct imx21 *imx21, struct ep_priv *ep_priv)
+{
+        int i, j;
+        int etd_num;
+
+        /* Allocate the ETDs if required */
+        for (i = 0; i < NUM_ISO_ETDS; i++) {
+                if (ep_priv->etd[i] < 0) {
+                        etd_num = alloc_etd(imx21);
+                        if (etd_num < 0)
+                                goto alloc_etd_failed;
+
+                        ep_priv->etd[i] = etd_num;
+                        imx21->etd[etd_num].ep = ep_priv->ep;
+                }
+        }
+        return 0;
 
 alloc_etd_failed:
-        kfree(ep_priv);
-        return NULL;
+        dev_err(imx21->dev, "isoc: Couldn't allocate etd\n");
+        for (j = 0; j < i; j++) {
+                free_etd(imx21, ep_priv->etd[j]);
+                ep_priv->etd[j] = -1;
+        }
+        return -ENOMEM;
 }
 
 static int imx21_hc_urb_enqueue_isoc(struct usb_hcd *hcd,
@@ -632,6 +768,10 @@ static int imx21_hc_urb_enqueue_isoc(struct usb_hcd *hcd,
                 ep_priv = ep->hcpriv;
         }
 
+        ret = alloc_isoc_etds(imx21, ep_priv);
+        if (ret)
+                goto alloc_etd_failed;
+
         ret = usb_hcd_link_urb_to_ep(hcd, urb);
         if (ret)
                 goto link_failed;
@@ -688,12 +828,14 @@ static int imx21_hc_urb_enqueue_isoc(struct usb_hcd *hcd,
         /* set up transfers */
         td = urb_priv->isoc_td;
         for (i = 0; i < urb->number_of_packets; i++, td++) {
+                unsigned int offset = urb->iso_frame_desc[i].offset;
                 td->ep = ep;
                 td->urb = urb;
                 td->len = urb->iso_frame_desc[i].length;
                 td->isoc_index = i;
                 td->frame = wrap_frame(urb->start_frame + urb->interval * i);
-                td->data = urb->transfer_dma + urb->iso_frame_desc[i].offset;
+                td->dma_handle = urb->transfer_dma + offset;
+                td->cpu_buffer = urb->transfer_buffer + offset;
                 list_add_tail(&td->list, &ep_priv->td_list);
         }
 
@@ -711,6 +853,7 @@ alloc_dmem_failed:
         usb_hcd_unlink_urb_from_ep(hcd, urb);
 
 link_failed:
+alloc_etd_failed:
 alloc_ep_failed:
         spin_unlock_irqrestore(&imx21->lock, flags);
         kfree(urb_priv->isoc_td);
@@ -734,9 +877,7 @@ static void dequeue_isoc_urb(struct imx21 *imx21,
                                 struct etd_priv *etd = imx21->etd + etd_num;
 
                                 reset_etd(imx21, etd_num);
-                                if (etd->dmem_size)
-                                        free_dmem(imx21, etd->dmem_offset);
-                                etd->dmem_size = 0;
+                                free_dmem(imx21, etd);
                         }
                 }
         }
@@ -761,7 +902,6 @@ static void schedule_nonisoc_etd(struct imx21 *imx21, struct urb *urb)
         int state = urb_priv->state;
         int etd_num = ep_priv->etd[0];
         struct etd_priv *etd;
-        int dmem_offset;
         u32 count;
         u16 etd_buf_size;
         u16 maxpacket;
@@ -786,13 +926,16 @@ static void schedule_nonisoc_etd(struct imx21 *imx21, struct urb *urb)
         if (usb_pipecontrol(pipe) && (state != US_CTRL_DATA)) {
                 if (state == US_CTRL_SETUP) {
                         dir = TD_DIR_SETUP;
+                        if (unsuitable_for_dma(urb->setup_dma))
+                                usb_hcd_unmap_urb_setup_for_dma(imx21->hcd,
+                                        urb);
                         etd->dma_handle = urb->setup_dma;
+                        etd->cpu_buffer = urb->setup_packet;
                         bufround = 0;
                         count = 8;
                         datatoggle = TD_TOGGLE_DATA0;
                 } else {        /* US_CTRL_ACK */
                         dir = usb_pipeout(pipe) ? TD_DIR_IN : TD_DIR_OUT;
-                        etd->dma_handle = urb->transfer_dma;
                         bufround = 0;
                         count = 0;
                         datatoggle = TD_TOGGLE_DATA1;
@@ -800,7 +943,11 @@ static void schedule_nonisoc_etd(struct imx21 *imx21, struct urb *urb)
         } else {
                 dir = usb_pipeout(pipe) ? TD_DIR_OUT : TD_DIR_IN;
                 bufround = (dir == TD_DIR_IN) ? 1 : 0;
+                if (unsuitable_for_dma(urb->transfer_dma))
+                        usb_hcd_unmap_urb_for_dma(imx21->hcd, urb);
+
                 etd->dma_handle = urb->transfer_dma;
+                etd->cpu_buffer = urb->transfer_buffer;
                 if (usb_pipebulk(pipe) && (state == US_BULK0))
                         count = 0;
                 else
@@ -855,8 +1002,8 @@ static void schedule_nonisoc_etd(struct imx21 *imx21, struct urb *urb)
 
         /* allocate x and y buffer space at once */
         etd->dmem_size = (count > maxpacket) ? maxpacket * 2 : maxpacket;
-        dmem_offset = alloc_dmem(imx21, etd->dmem_size, urb_priv->ep);
-        if (dmem_offset < 0) {
+        etd->dmem_offset = alloc_dmem(imx21, etd->dmem_size, urb_priv->ep);
+        if (etd->dmem_offset < 0) {
                 /* Setup everything we can in HW and update when we get DMEM */
                 etd_writel(imx21, etd_num, 1, (u32)maxpacket << 16);
 
@@ -867,26 +1014,26 @@ static void schedule_nonisoc_etd(struct imx21 *imx21, struct urb *urb)
         }
 
         etd_writel(imx21, etd_num, 1,
-                (((u32) dmem_offset + (u32) maxpacket) << DW1_YBUFSRTAD) |
-                (u32) dmem_offset);
+                (((u32) etd->dmem_offset + (u32) maxpacket) << DW1_YBUFSRTAD) |
+                (u32) etd->dmem_offset);
 
         urb_priv->active = 1;
 
         /* enable the ETD to kick off transfer */
         dev_vdbg(imx21->dev, "Activating etd %d for %d bytes %s\n",
                 etd_num, count, dir != TD_DIR_IN ? "out" : "in");
-        activate_etd(imx21, etd_num, etd->dma_handle, dir);
+        activate_etd(imx21, etd_num, dir);
 
 }
 
-static void nonisoc_etd_done(struct usb_hcd *hcd, struct urb *urb, int etd_num)
+static void nonisoc_etd_done(struct usb_hcd *hcd, int etd_num)
 {
         struct imx21 *imx21 = hcd_to_imx21(hcd);
         struct etd_priv *etd = &imx21->etd[etd_num];
+        struct urb *urb = etd->urb;
         u32 etd_mask = 1 << etd_num;
         struct urb_priv *urb_priv = urb->hcpriv;
         int dir;
-        u16 xbufaddr;
         int cc;
         u32 bytes_xfrd;
         int etd_done;
@@ -894,7 +1041,6 @@ static void nonisoc_etd_done(struct usb_hcd *hcd, struct urb *urb, int etd_num)
         disactivate_etd(imx21, etd_num);
 
         dir = (etd_readl(imx21, etd_num, 0) >> DW0_DIRECT) & 0x3;
-        xbufaddr = etd_readl(imx21, etd_num, 1) & 0xffff;
         cc = (etd_readl(imx21, etd_num, 2) >> DW2_COMPCODE) & 0xf;
         bytes_xfrd = etd->len - (etd_readl(imx21, etd_num, 3) & 0x1fffff);
 
@@ -906,8 +1052,21 @@ static void nonisoc_etd_done(struct usb_hcd *hcd, struct urb *urb, int etd_num)
         if (dir == TD_DIR_IN) {
                 clear_toggle_bit(imx21, USBH_XFILLSTAT, etd_mask);
                 clear_toggle_bit(imx21, USBH_YFILLSTAT, etd_mask);
+
+                if (etd->bounce_buffer) {
+                        memcpy(etd->cpu_buffer, etd->bounce_buffer, bytes_xfrd);
+                        dma_unmap_single(imx21->dev,
+                                etd->dma_handle, etd->len, DMA_FROM_DEVICE);
+                } else if (!etd->dma_handle && bytes_xfrd) {/* PIO */
+                        memcpy_fromio(etd->cpu_buffer,
+                                imx21->regs + USBOTG_DMEM + etd->dmem_offset,
+                                bytes_xfrd);
+                }
         }
-        free_dmem(imx21, xbufaddr);
+
+        kfree(etd->bounce_buffer);
+        etd->bounce_buffer = NULL;
+        free_dmem(imx21, etd);
 
         urb->error_count = 0;
         if (!(urb->transfer_flags & URB_SHORT_NOT_OK)
@@ -964,24 +1123,15 @@ static void nonisoc_etd_done(struct usb_hcd *hcd, struct urb *urb, int etd_num)
                 break;
         }
 
-        if (!etd_done) {
+        if (etd_done)
+                nonisoc_urb_completed_for_etd(imx21, etd, cc_to_error[cc]);
+        else {
                 dev_vdbg(imx21->dev, "next state=%d\n", urb_priv->state);
                 schedule_nonisoc_etd(imx21, urb);
-        } else {
-                struct usb_host_endpoint *ep = urb->ep;
-
-                urb_done(hcd, urb, cc_to_error[cc]);
-                etd->urb = NULL;
-
-                if (!list_empty(&ep->urb_list)) {
-                        urb = list_first_entry(&ep->urb_list,
-                                struct urb, urb_list);
-                        dev_vdbg(imx21->dev, "next URB %p\n", urb);
-                        schedule_nonisoc_etd(imx21, urb);
-                }
         }
 }
 
+
 static struct ep_priv *alloc_ep(void)
 {
         int i;
@@ -1007,7 +1157,6 @@ static int imx21_hc_urb_enqueue(struct usb_hcd *hcd,
         struct etd_priv *etd;
         int ret;
         unsigned long flags;
-        int new_ep = 0;
 
         dev_vdbg(imx21->dev,
                 "enqueue urb=%p ep=%p len=%d "
@@ -1035,7 +1184,6 @@ static int imx21_hc_urb_enqueue(struct usb_hcd *hcd,
                 }
                 ep->hcpriv = ep_priv;
                 ep_priv->ep = ep;
-                new_ep = 1;
         }
 
         ret = usb_hcd_link_urb_to_ep(hcd, urb);
@@ -1124,9 +1272,13 @@ static int imx21_hc_urb_dequeue(struct usb_hcd *hcd, struct urb *urb,
         } else if (urb_priv->active) {
                 int etd_num = ep_priv->etd[0];
                 if (etd_num != -1) {
+                        struct etd_priv *etd = &imx21->etd[etd_num];
+
                         disactivate_etd(imx21, etd_num);
-                        free_dmem(imx21, etd_readl(imx21, etd_num, 1) & 0xffff);
-                        imx21->etd[etd_num].urb = NULL;
+                        free_dmem(imx21, etd);
+                        etd->urb = NULL;
+                        kfree(etd->bounce_buffer);
+                        etd->bounce_buffer = NULL;
                 }
         }
 
@@ -1171,7 +1323,7 @@ static void process_etds(struct usb_hcd *hcd, struct imx21 *imx21, int sof)
  * (and hence no interrupt occurs).
  * This causes the transfer in question to hang.
  * The kludge below checks for this condition at each SOF and processes any
- * blocked ETDs (after an arbitary 10 frame wait)
+ * blocked ETDs (after an arbitrary 10 frame wait)
  *
  * With a single active transfer the usbtest test suite will run for days
  * without the kludge.
@@ -1226,9 +1378,9 @@ static void process_etds(struct usb_hcd *hcd, struct imx21 *imx21, int sof)
                 }
 
                 if (usb_pipeisoc(etd->urb->pipe))
-                        isoc_etd_done(hcd, etd->urb, etd_num);
+                        isoc_etd_done(hcd, etd_num);
                 else
-                        nonisoc_etd_done(hcd, etd->urb, etd_num);
+                        nonisoc_etd_done(hcd, etd_num);
         }
 
         /* only enable SOF interrupt if it may be needed for the kludge */
@@ -1320,8 +1472,8 @@ static int get_hub_descriptor(struct usb_hcd *hcd,
                 0x0010 |        /* No over current protection */
                 0);
 
-        desc->bitmap[0] = 1 << 1;
-        desc->bitmap[1] = ~0;
+        desc->u.hs.DeviceRemovable[0] = 1 << 1;
+        desc->u.hs.DeviceRemovable[1] = ~0;
         return 0;
 }
 
@@ -1507,7 +1659,7 @@ static int imx21_hc_reset(struct usb_hcd *hcd)
 
         spin_lock_irqsave(&imx21->lock, flags);
 
-        /* Reset the Host controler modules */
+        /* Reset the Host controller modules */
         writel(USBOTG_RST_RSTCTRL | USBOTG_RST_RSTRH |
                 USBOTG_RST_RSTHSIE | USBOTG_RST_RSTHC,
                 imx21->regs + USBOTG_RST_CTRL);
@@ -1696,6 +1848,7 @@ static int imx21_probe(struct platform_device *pdev)
         }
 
         imx21 = hcd_to_imx21(hcd);
+        imx21->hcd = hcd;
         imx21->dev = &pdev->dev;
         imx21->pdata = pdev->dev.platform_data;
         if (!imx21->pdata)
@@ -1754,7 +1907,7 @@ failed_clock_set:
 failed_clock_get:
         iounmap(imx21->regs);
 failed_ioremap:
-        release_mem_region(res->start, res->end - res->start);
+        release_mem_region(res->start, resource_size(res));
 failed_request_mem:
         remove_debug_files(imx21);
         usb_put_hcd(hcd);
diff --git a/drivers/usb/host/imx21-hcd.h b/drivers/usb/host/imx21-hcd.h
index 1b0d913780a5..87b29fd971b4 100644
--- a/drivers/usb/host/imx21-hcd.h
+++ b/drivers/usb/host/imx21-hcd.h
@@ -250,6 +250,7 @@
 #define USBCTRL_USB_BYP                 (1 << 2)
 #define USBCTRL_HOST1_TXEN_OE           (1 << 1)
 
+#define USBOTG_DMEM             0x1000
 
 /* Values in TD blocks */
 #define TD_DIR_SETUP        0
@@ -346,8 +347,8 @@ struct td {
         struct list_head list;
         struct urb *urb;
         struct usb_host_endpoint *ep;
-        dma_addr_t data;
-        unsigned long buf_addr;
+        dma_addr_t dma_handle;
+        void *cpu_buffer;
         int len;
         int frame;
         int isoc_index;
@@ -360,6 +361,8 @@ struct etd_priv {
         struct td *td;
         struct list_head queue;
         dma_addr_t dma_handle;
+        void *cpu_buffer;
+        void *bounce_buffer;
         int alloc;
         int len;
         int dmem_size;
@@ -412,6 +415,7 @@ struct debug_isoc_trace {
 struct imx21 {
         spinlock_t lock;
         struct device *dev;
+        struct usb_hcd *hcd;
         struct mx21_usbh_platform_data *pdata;
         struct list_head dmem_list;
         struct list_head queue_for_etd; /* eps queued due to etd shortage */
diff --git a/drivers/usb/host/isp116x-hcd.c b/drivers/usb/host/isp116x-hcd.c
index d9e82123de2a..baae4ccd16ac 100644
--- a/drivers/usb/host/isp116x-hcd.c
+++ b/drivers/usb/host/isp116x-hcd.c
@@ -612,6 +612,7 @@ static irqreturn_t isp116x_irq(struct usb_hcd *hcd)
                         /* IRQ's are off, we do no DMA,
                            perfectly ready to die ... */
                         hcd->state = HC_STATE_HALT;
+                        usb_hc_died(hcd);
                         ret = IRQ_HANDLED;
                         goto done;
                 }
@@ -951,9 +952,9 @@ static void isp116x_hub_descriptor(struct isp116x *isp116x,
         /* Power switching, device type, overcurrent. */
         desc->wHubCharacteristics = cpu_to_le16((u16) ((reg >> 8) & 0x1f));
         desc->bPwrOn2PwrGood = (u8) ((reg >> 24) & 0xff);
-        /* two bitmaps:  ports removable, and legacy PortPwrCtrlMask */
-        desc->bitmap[0] = 0;
-        desc->bitmap[1] = ~0;
+        /* ports removable, and legacy PortPwrCtrlMask */
+        desc->u.hs.DeviceRemovable[0] = 0;
+        desc->u.hs.DeviceRemovable[1] = ~0;
 }
 
 /* Perform reset of a given port.
@@ -1557,8 +1558,6 @@ static int isp116x_remove(struct platform_device *pdev)
         return 0;
 }
 
-#define resource_len(r) (((r)->end - (r)->start) + 1)
-
 static int __devinit isp116x_probe(struct platform_device *pdev)
 {
         struct usb_hcd *hcd;
@@ -1597,7 +1596,7 @@ static int __devinit isp116x_probe(struct platform_device *pdev)
                 ret = -EBUSY;
                 goto err1;
         }
-        addr_reg = ioremap(addr->start, resource_len(addr));
+        addr_reg = ioremap(addr->start, resource_size(addr));
         if (addr_reg == NULL) {
                 ret = -ENOMEM;
                 goto err2;
@@ -1606,7 +1605,7 @@ static int __devinit isp116x_probe(struct platform_device *pdev)
                 ret = -EBUSY;
                 goto err3;
         }
-        data_reg = ioremap(data->start, resource_len(data));
+        data_reg = ioremap(data->start, resource_size(data));
         if (data_reg == NULL) {
                 ret = -ENOMEM;
                 goto err4;
diff --git a/drivers/usb/host/isp116x.h b/drivers/usb/host/isp116x.h
index 12db961acdfb..9a2c400e6090 100644
--- a/drivers/usb/host/isp116x.h
+++ b/drivers/usb/host/isp116x.h
@@ -13,7 +13,7 @@
 
 /* Full speed: max # of bytes to transfer for a single urb
    at a time must be < 1024 && must be multiple of 64.
-   832 allows transfering 4kiB within 5 frames. */
+   832 allows transferring 4kiB within 5 frames. */
 #define MAX_TRANSFER_SIZE_FULLSPEED     832
 
 /* Low speed: there is no reason to schedule in very big
diff --git a/drivers/usb/host/isp1362-hcd.c b/drivers/usb/host/isp1362-hcd.c
index 0587ad4ce5c2..9c37dad3e816 100644
--- a/drivers/usb/host/isp1362-hcd.c
+++ b/drivers/usb/host/isp1362-hcd.c
@@ -70,7 +70,6 @@
 #include <linux/ioport.h>
 #include <linux/sched.h>
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
 #include <linux/errno.h>
 #include <linux/init.h>
 #include <linux/list.h>
@@ -82,6 +81,7 @@
 #include <linux/pm.h>
 #include <linux/io.h>
 #include <linux/bitmap.h>
+#include <linux/prefetch.h>
 
 #include <asm/irq.h>
 #include <asm/system.h>
@@ -227,7 +227,6 @@ static int claim_ptd_buffers(struct isp1362_ep_queue *epq,
 
 static inline void release_ptd_buffers(struct isp1362_ep_queue *epq, struct isp1362_ep *ep)
 {
-        int index = ep->ptd_index;
         int last = ep->ptd_index + ep->num_ptds;
 
         if (last > epq->buf_count)
@@ -237,10 +236,8 @@ static inline void release_ptd_buffers(struct isp1362_ep_queue *epq, struct isp1
                     epq->buf_map, epq->skip_map);
         BUG_ON(last > epq->buf_count);
 
-        for (; index < last; index++) {
-                __clear_bit(index, &epq->buf_map);
-                __set_bit(index, &epq->skip_map);
-        }
+        bitmap_clear(&epq->buf_map, ep->ptd_index, ep->num_ptds);
+        bitmap_set(&epq->skip_map, ep->ptd_index, ep->num_ptds);
         epq->buf_avail += ep->num_ptds;
         epq->ptd_count--;
 
@@ -550,7 +547,7 @@ static void postproc_ep(struct isp1362_hcd *isp1362_hcd, struct isp1362_ep *ep)
                         if (usb_pipecontrol(urb->pipe)) {
                                 ep->nextpid = USB_PID_ACK;
                                 /* save the data underrun error code for later and
-                                 * procede with the status stage
+                                 * proceed with the status stage
                                  */
                                 urb->actual_length += PTD_GET_COUNT(ptd);
                                 BUG_ON(urb->actual_length > urb->transfer_buffer_length);
@@ -1556,9 +1553,9 @@ static void isp1362_hub_descriptor(struct isp1362_hcd *isp1362_hcd,
         desc->wHubCharacteristics = cpu_to_le16((reg >> 8) & 0x1f);
         DBG(0, "%s: hubcharacteristics = %02x\n", __func__, cpu_to_le16((reg >> 8) & 0x1f));
         desc->bPwrOn2PwrGood = (reg >> 24) & 0xff;
-        /* two bitmaps:  ports removable, and legacy PortPwrCtrlMask */
-        desc->bitmap[0] = desc->bNbrPorts == 1 ? 1 << 1 : 3 << 1;
-        desc->bitmap[1] = ~0;
+        /* ports removable, and legacy PortPwrCtrlMask */
+        desc->u.hs.DeviceRemovable[0] = desc->bNbrPorts == 1 ? 1 << 1 : 3 << 1;
+        desc->u.hs.DeviceRemovable[1] = ~0;
 
         DBG(3, "%s: exit\n", __func__);
 }
@@ -1676,13 +1673,6 @@ static int isp1362_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                 switch (wValue) {
                 case USB_PORT_FEAT_SUSPEND:
                         _DBG(0, "USB_PORT_FEAT_SUSPEND\n");
-#ifdef  CONFIG_USB_OTG
-                        if (ohci->hcd.self.otg_port == (wIndex + 1) &&
-                            ohci->hcd.self.b_hnp_enable) {
-                                start_hnp(ohci);
-                                break;
-                        }
-#endif
                         spin_lock_irqsave(&isp1362_hcd->lock, flags);
                         isp1362_write_reg32(isp1362_hcd, HCRHPORT1 + wIndex, RH_PS_PSS);
                         isp1362_hcd->rhport[wIndex] =
@@ -2656,8 +2646,6 @@ static struct hc_driver isp1362_hc_driver = {
 
 /*-------------------------------------------------------------------------*/
 
-#define resource_len(r) (((r)->end - (r)->start) + 1)
-
 static int __devexit isp1362_remove(struct platform_device *pdev)
 {
         struct usb_hcd *hcd = platform_get_drvdata(pdev);
@@ -2679,12 +2667,12 @@ static int __devexit isp1362_remove(struct platform_device *pdev)
         res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
         DBG(0, "%s: release mem_region: %08lx\n", __func__, (long unsigned int)res->start);
         if (res)
-                release_mem_region(res->start, resource_len(res));
+                release_mem_region(res->start, resource_size(res));
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         DBG(0, "%s: release mem_region: %08lx\n", __func__, (long unsigned int)res->start);
         if (res)
-                release_mem_region(res->start, resource_len(res));
+                release_mem_region(res->start, resource_size(res));
 
         DBG(0, "%s: put_hcd\n", __func__);
         usb_put_hcd(hcd);
@@ -2693,7 +2681,7 @@ static int __devexit isp1362_remove(struct platform_device *pdev)
         return 0;
 }
 
-static int __init isp1362_probe(struct platform_device *pdev)
+static int __devinit isp1362_probe(struct platform_device *pdev)
 {
         struct usb_hcd *hcd;
         struct isp1362_hcd *isp1362_hcd;
@@ -2730,21 +2718,21 @@ static int __init isp1362_probe(struct platform_device *pdev)
                 goto err1;
         }
 
-        if (!request_mem_region(addr->start, resource_len(addr), hcd_name)) {
+        if (!request_mem_region(addr->start, resource_size(addr), hcd_name)) {
                 retval = -EBUSY;
                 goto err1;
         }
-        addr_reg = ioremap(addr->start, resource_len(addr));
+        addr_reg = ioremap(addr->start, resource_size(addr));
         if (addr_reg == NULL) {
                 retval = -ENOMEM;
                 goto err2;
         }
 
-        if (!request_mem_region(data->start, resource_len(data), hcd_name)) {
+        if (!request_mem_region(data->start, resource_size(data), hcd_name)) {
                 retval = -EBUSY;
                 goto err3;
         }
-        data_reg = ioremap(data->start, resource_len(data));
+        data_reg = ioremap(data->start, resource_size(data));
         if (data_reg == NULL) {
                 retval = -ENOMEM;
                 goto err4;
@@ -2802,13 +2790,13 @@ static int __init isp1362_probe(struct platform_device *pdev)
         iounmap(data_reg);
  err4:
         DBG(0, "%s: Releasing mem region %08lx\n", __func__, (long unsigned int)data->start);
-        release_mem_region(data->start, resource_len(data));
+        release_mem_region(data->start, resource_size(data));
  err3:
         DBG(0, "%s: Unmapping addr_reg @ %p\n", __func__, addr_reg);
         iounmap(addr_reg);
  err2:
         DBG(0, "%s: Releasing mem region %08lx\n", __func__, (long unsigned int)addr->start);
-        release_mem_region(addr->start, resource_len(addr));
+        release_mem_region(addr->start, resource_size(addr));
  err1:
         pr_err("%s: init error, %d\n", __func__, retval);
 
diff --git a/drivers/usb/host/isp1760-hcd.c b/drivers/usb/host/isp1760-hcd.c
index bdba8c5d844a..55d3d5859ac5 100644
--- a/drivers/usb/host/isp1760-hcd.c
+++ b/drivers/usb/host/isp1760-hcd.c
@@ -8,6 +8,8 @@
  *
  * (c) 2007 Sebastian Siewior <bigeasy@linutronix.de>
  *
+ * (c) 2011 Arvid Brodin <arvid.brodin@enea.com>
+ *
  */
 #include <linux/module.h>
 #include <linux/kernel.h>
@@ -26,13 +28,18 @@
 
 static struct kmem_cache *qtd_cachep;
 static struct kmem_cache *qh_cachep;
+static struct kmem_cache *urb_listitem_cachep;
 
 struct isp1760_hcd {
         u32 hcs_params;
         spinlock_t              lock;
-        struct inter_packet_info atl_ints[32];
-        struct inter_packet_info int_ints[32];
+        struct slotinfo         atl_slots[32];
+        int                     atl_done_map;
+        struct slotinfo         int_slots[32];
+        int                     int_done_map;
         struct memory_chunk memory_pool[BLOCKS];
+        struct list_head        controlqhs, bulkqhs, interruptqhs;
+        int active_ptds;
 
         /* periodic schedule support */
 #define DEFAULT_I_TDPS          1024
@@ -47,10 +54,6 @@ static inline struct isp1760_hcd *hcd_to_priv(struct usb_hcd *hcd)
 {
         return (struct isp1760_hcd *) (hcd->hcd_priv);
 }
-static inline struct usb_hcd *priv_to_hcd(struct isp1760_hcd *priv)
-{
-        return container_of((void *) priv, struct usb_hcd, hcd_priv);
-}
 
 /* Section 2.2 Host Controller Capability Registers */
 #define HC_LENGTH(p)            (((p)>>00)&0x00ff)      /* bits 7:0 */
@@ -80,217 +83,270 @@ static inline struct usb_hcd *priv_to_hcd(struct isp1760_hcd *priv)
 #define PORT_RWC_BITS   (PORT_CSC)
 
 struct isp1760_qtd {
-        struct isp1760_qtd *hw_next;
         u8 packet_type;
-        u8 toggle;
-
         void *data_buffer;
+        u32 payload_addr;
+
         /* the rest is HCD-private */
         struct list_head qtd_list;
         struct urb *urb;
         size_t length;
-
-        /* isp special*/
+        size_t actual_length;
+
+        /* QTD_ENQUEUED:        waiting for transfer (inactive) */
+        /* QTD_PAYLOAD_ALLOC:   chip mem has been allocated for payload */
+        /* QTD_XFER_STARTED:    valid ptd has been written to isp176x - only
+                                interrupt handler may touch this qtd! */
+        /* QTD_XFER_COMPLETE:   payload has been transferred successfully */
+        /* QTD_RETIRE:          transfer error/abort qtd */
+#define QTD_ENQUEUED            0
+#define QTD_PAYLOAD_ALLOC       1
+#define QTD_XFER_STARTED        2
+#define QTD_XFER_COMPLETE       3
+#define QTD_RETIRE              4
         u32 status;
-#define URB_COMPLETE_NOTIFY     (1 << 0)
-#define URB_ENQUEUED            (1 << 1)
-#define URB_TYPE_ATL            (1 << 2)
-#define URB_TYPE_INT            (1 << 3)
 };
 
+/* Queue head, one for each active endpoint */
 struct isp1760_qh {
-        /* first part defined by EHCI spec */
+        struct list_head qh_list;
         struct list_head qtd_list;
-        struct isp1760_hcd *priv;
-
-        /* periodic schedule info */
-        unsigned short period;          /* polling interval */
-        struct usb_device *dev;
-
         u32 toggle;
         u32 ping;
+        int slot;
 };
 
-#define ehci_port_speed(priv, portsc) USB_PORT_STAT_HIGH_SPEED
+struct urb_listitem {
+        struct list_head urb_list;
+        struct urb *urb;
+};
 
-static unsigned int isp1760_readl(__u32 __iomem *regs)
+/*
+ * Access functions for isp176x registers (addresses 0..0x03FF).
+ */
+static u32 reg_read32(void __iomem *base, u32 reg)
 {
-        return readl(regs);
+        return readl(base + reg);
 }
 
-static void isp1760_writel(const unsigned int val, __u32 __iomem *regs)
+static void reg_write32(void __iomem *base, u32 reg, u32 val)
 {
-        writel(val, regs);
+        writel(val, base + reg);
 }
 
 /*
- * The next two copy via MMIO data to/from the device. memcpy_{to|from}io()
+ * Access functions for isp176x memory (offset >= 0x0400).
+ *
+ * bank_reads8() reads memory locations prefetched by an earlier write to
+ * HC_MEMORY_REG (see isp176x datasheet). Unless you want to do fancy multi-
+ * bank optimizations, you should use the more generic mem_reads8() below.
+ *
+ * For access to ptd memory, use the specialized ptd_read() and ptd_write()
+ * below.
+ *
+ * These functions copy via MMIO data to/from the device. memcpy_{to|from}io()
  * doesn't quite work because some people have to enforce 32-bit access
  */
-static void priv_read_copy(struct isp1760_hcd *priv, u32 *src,
-                __u32 __iomem *dst, u32 len)
+static void bank_reads8(void __iomem *src_base, u32 src_offset, u32 bank_addr,
+                                                        __u32 *dst, u32 bytes)
 {
+        __u32 __iomem *src;
         u32 val;
-        u8 *buff8;
+        __u8 *src_byteptr;
+        __u8 *dst_byteptr;
 
-        if (!src) {
-                printk(KERN_ERR "ERROR: buffer: %p len: %d\n", src, len);
-                return;
-        }
+        src = src_base + (bank_addr | src_offset);
 
-        while (len >= 4) {
-                *src = __raw_readl(dst);
-                len -= 4;
-                src++;
-                dst++;
+        if (src_offset < PAYLOAD_OFFSET) {
+                while (bytes >= 4) {
+                        *dst = le32_to_cpu(__raw_readl(src));
+                        bytes -= 4;
+                        src++;
+                        dst++;
+                }
+        } else {
+                while (bytes >= 4) {
+                        *dst = __raw_readl(src);
+                        bytes -= 4;
+                        src++;
+                        dst++;
+                }
         }
 
-        if (!len)
+        if (!bytes)
                 return;
 
         /* in case we have 3, 2 or 1 by left. The dst buffer may not be fully
          * allocated.
          */
-        val = isp1760_readl(dst);
-
-        buff8 = (u8 *)src;
-        while (len) {
-
-                *buff8 = val;
-                val >>= 8;
-                len--;
-                buff8++;
+        if (src_offset < PAYLOAD_OFFSET)
+                val = le32_to_cpu(__raw_readl(src));
+        else
+                val = __raw_readl(src);
+
+        dst_byteptr = (void *) dst;
+        src_byteptr = (void *) &val;
+        while (bytes > 0) {
+                *dst_byteptr = *src_byteptr;
+                dst_byteptr++;
+                src_byteptr++;
+                bytes--;
         }
 }
 
-static void priv_write_copy(const struct isp1760_hcd *priv, const u32 *src,
-                __u32 __iomem *dst, u32 len)
+static void mem_reads8(void __iomem *src_base, u32 src_offset, void *dst,
+                                                                u32 bytes)
 {
-        while (len >= 4) {
-                __raw_writel(*src, dst);
-                len -= 4;
-                src++;
-                dst++;
+        reg_write32(src_base, HC_MEMORY_REG, src_offset + ISP_BANK(0));
+        ndelay(90);
+        bank_reads8(src_base, src_offset, ISP_BANK(0), dst, bytes);
+}
+
+static void mem_writes8(void __iomem *dst_base, u32 dst_offset,
+                                                __u32 const *src, u32 bytes)
+{
+        __u32 __iomem *dst;
+
+        dst = dst_base + dst_offset;
+
+        if (dst_offset < PAYLOAD_OFFSET) {
+                while (bytes >= 4) {
+                        __raw_writel(cpu_to_le32(*src), dst);
+                        bytes -= 4;
+                        src++;
+                        dst++;
+                }
+        } else {
+                while (bytes >= 4) {
+                        __raw_writel(*src, dst);
+                        bytes -= 4;
+                        src++;
+                        dst++;
+                }
         }
 
-        if (!len)
+        if (!bytes)
                 return;
-        /* in case we have 3, 2 or 1 by left. The buffer is allocated and the
-         * extra bytes should not be read by the HW
+        /* in case we have 3, 2 or 1 bytes left. The buffer is allocated and the
+         * extra bytes should not be read by the HW.
          */
 
-        __raw_writel(*src, dst);
+        if (dst_offset < PAYLOAD_OFFSET)
+                __raw_writel(cpu_to_le32(*src), dst);
+        else
+                __raw_writel(*src, dst);
 }
 
+/*
+ * Read and write ptds. 'ptd_offset' should be one of ISO_PTD_OFFSET,
+ * INT_PTD_OFFSET, and ATL_PTD_OFFSET. 'slot' should be less than 32.
+ */
+static void ptd_read(void __iomem *base, u32 ptd_offset, u32 slot,
+                                                                struct ptd *ptd)
+{
+        reg_write32(base, HC_MEMORY_REG,
+                                ISP_BANK(0) + ptd_offset + slot*sizeof(*ptd));
+        ndelay(90);
+        bank_reads8(base, ptd_offset + slot*sizeof(*ptd), ISP_BANK(0),
+                                                (void *) ptd, sizeof(*ptd));
+}
+
+static void ptd_write(void __iomem *base, u32 ptd_offset, u32 slot,
+                                                                struct ptd *ptd)
+{
+        mem_writes8(base, ptd_offset + slot*sizeof(*ptd) + sizeof(ptd->dw0),
+                                                &ptd->dw1, 7*sizeof(ptd->dw1));
+        /* Make sure dw0 gets written last (after other dw's and after payload)
+           since it contains the enable bit */
+        wmb();
+        mem_writes8(base, ptd_offset + slot*sizeof(*ptd), &ptd->dw0,
+                                                        sizeof(ptd->dw0));
+}
+
+
 /* memory management of the 60kb on the chip from 0x1000 to 0xffff */
 static void init_memory(struct isp1760_hcd *priv)
 {
-        int i;
-        u32 payload;
+        int i, curr;
+        u32 payload_addr;
 
-        payload = 0x1000;
+        payload_addr = PAYLOAD_OFFSET;
         for (i = 0; i < BLOCK_1_NUM; i++) {
-                priv->memory_pool[i].start = payload;
+                priv->memory_pool[i].start = payload_addr;
                 priv->memory_pool[i].size = BLOCK_1_SIZE;
                 priv->memory_pool[i].free = 1;
-                payload += priv->memory_pool[i].size;
+                payload_addr += priv->memory_pool[i].size;
         }
 
-
-        for (i = BLOCK_1_NUM; i < BLOCK_1_NUM + BLOCK_2_NUM; i++) {
-                priv->memory_pool[i].start = payload;
-                priv->memory_pool[i].size = BLOCK_2_SIZE;
-                priv->memory_pool[i].free = 1;
-                payload += priv->memory_pool[i].size;
+        curr = i;
+        for (i = 0; i < BLOCK_2_NUM; i++) {
+                priv->memory_pool[curr + i].start = payload_addr;
+                priv->memory_pool[curr + i].size = BLOCK_2_SIZE;
+                priv->memory_pool[curr + i].free = 1;
+                payload_addr += priv->memory_pool[curr + i].size;
         }
 
-
-        for (i = BLOCK_1_NUM + BLOCK_2_NUM; i < BLOCKS; i++) {
-                priv->memory_pool[i].start = payload;
-                priv->memory_pool[i].size = BLOCK_3_SIZE;
-                priv->memory_pool[i].free = 1;
-                payload += priv->memory_pool[i].size;
+        curr = i;
+        for (i = 0; i < BLOCK_3_NUM; i++) {
+                priv->memory_pool[curr + i].start = payload_addr;
+                priv->memory_pool[curr + i].size = BLOCK_3_SIZE;
+                priv->memory_pool[curr + i].free = 1;
+                payload_addr += priv->memory_pool[curr + i].size;
         }
 
-        BUG_ON(payload - priv->memory_pool[i - 1].size > PAYLOAD_SIZE);
+        WARN_ON(payload_addr - priv->memory_pool[0].start > PAYLOAD_AREA_SIZE);
 }
 
-static u32 alloc_mem(struct isp1760_hcd *priv, u32 size)
+static void alloc_mem(struct usb_hcd *hcd, struct isp1760_qtd *qtd)
 {
+        struct isp1760_hcd *priv = hcd_to_priv(hcd);
         int i;
 
-        if (!size)
-                return ISP1760_NULL_POINTER;
+        WARN_ON(qtd->payload_addr);
+
+        if (!qtd->length)
+                return;
 
         for (i = 0; i < BLOCKS; i++) {
-                if (priv->memory_pool[i].size >= size &&
+                if (priv->memory_pool[i].size >= qtd->length &&
                                 priv->memory_pool[i].free) {
-
                         priv->memory_pool[i].free = 0;
-                        return priv->memory_pool[i].start;
+                        qtd->payload_addr = priv->memory_pool[i].start;
+                        return;
                 }
         }
-
-        printk(KERN_ERR "ISP1760 MEM: can not allocate %d bytes of memory\n",
-                        size);
-        printk(KERN_ERR "Current memory map:\n");
-        for (i = 0; i < BLOCKS; i++) {
-                printk(KERN_ERR "Pool %2d size %4d status: %d\n",
-                                i, priv->memory_pool[i].size,
-                                priv->memory_pool[i].free);
-        }
-        /* XXX maybe -ENOMEM could be possible */
-        BUG();
-        return 0;
 }
 
-static void free_mem(struct isp1760_hcd *priv, u32 mem)
+static void free_mem(struct usb_hcd *hcd, struct isp1760_qtd *qtd)
 {
+        struct isp1760_hcd *priv = hcd_to_priv(hcd);
         int i;
 
-        if (mem == ISP1760_NULL_POINTER)
+        if (!qtd->payload_addr)
                 return;
 
         for (i = 0; i < BLOCKS; i++) {
-                if (priv->memory_pool[i].start == mem) {
-
-                        BUG_ON(priv->memory_pool[i].free);
-
+                if (priv->memory_pool[i].start == qtd->payload_addr) {
+                        WARN_ON(priv->memory_pool[i].free);
                         priv->memory_pool[i].free = 1;
-                        return ;
+                        qtd->payload_addr = 0;
+                        return;
                 }
         }
 
-        printk(KERN_ERR "Trying to free not-here-allocated memory :%08x\n",
-                        mem);
-        BUG();
-}
-
-static void isp1760_init_regs(struct usb_hcd *hcd)
-{
-        isp1760_writel(0, hcd->regs + HC_BUFFER_STATUS_REG);
-        isp1760_writel(NO_TRANSFER_ACTIVE, hcd->regs +
-                        HC_ATL_PTD_SKIPMAP_REG);
-        isp1760_writel(NO_TRANSFER_ACTIVE, hcd->regs +
-                        HC_INT_PTD_SKIPMAP_REG);
-        isp1760_writel(NO_TRANSFER_ACTIVE, hcd->regs +
-                        HC_ISO_PTD_SKIPMAP_REG);
-
-        isp1760_writel(~NO_TRANSFER_ACTIVE, hcd->regs +
-                        HC_ATL_PTD_DONEMAP_REG);
-        isp1760_writel(~NO_TRANSFER_ACTIVE, hcd->regs +
-                        HC_INT_PTD_DONEMAP_REG);
-        isp1760_writel(~NO_TRANSFER_ACTIVE, hcd->regs +
-                        HC_ISO_PTD_DONEMAP_REG);
+        dev_err(hcd->self.controller, "%s: Invalid pointer: %08x\n",
+                                                __func__, qtd->payload_addr);
+        WARN_ON(1);
+        qtd->payload_addr = 0;
 }
 
-static int handshake(struct isp1760_hcd *priv, void __iomem *ptr,
+static int handshake(struct usb_hcd *hcd, u32 reg,
                       u32 mask, u32 done, int usec)
 {
         u32 result;
 
         do {
-                result = isp1760_readl(ptr);
+                result = reg_read32(hcd->regs, reg);
                 if (result == ~0)
                         return -ENODEV;
                 result &= mask;
@@ -303,48 +359,43 @@ static int handshake(struct isp1760_hcd *priv, void __iomem *ptr,
 }
 
 /* reset a non-running (STS_HALT == 1) controller */
-static int ehci_reset(struct isp1760_hcd *priv)
+static int ehci_reset(struct usb_hcd *hcd)
 {
         int retval;
-        struct usb_hcd *hcd = priv_to_hcd(priv);
-        u32 command = isp1760_readl(hcd->regs + HC_USBCMD);
+        struct isp1760_hcd *priv = hcd_to_priv(hcd);
+
+        u32 command = reg_read32(hcd->regs, HC_USBCMD);
 
         command |= CMD_RESET;
-        isp1760_writel(command, hcd->regs + HC_USBCMD);
+        reg_write32(hcd->regs, HC_USBCMD, command);
         hcd->state = HC_STATE_HALT;
         priv->next_statechange = jiffies;
-        retval = handshake(priv, hcd->regs + HC_USBCMD,
+        retval = handshake(hcd, HC_USBCMD,
                             CMD_RESET, 0, 250 * 1000);
         return retval;
 }
 
-static void qh_destroy(struct isp1760_qh *qh)
-{
-        BUG_ON(!list_empty(&qh->qtd_list));
-        kmem_cache_free(qh_cachep, qh);
-}
-
-static struct isp1760_qh *isp1760_qh_alloc(struct isp1760_hcd *priv,
-                gfp_t flags)
+static struct isp1760_qh *qh_alloc(gfp_t flags)
 {
         struct isp1760_qh *qh;
 
         qh = kmem_cache_zalloc(qh_cachep, flags);
         if (!qh)
-                return qh;
+                return NULL;
 
+        INIT_LIST_HEAD(&qh->qh_list);
         INIT_LIST_HEAD(&qh->qtd_list);
-        qh->priv = priv;
+        qh->slot = -1;
+
         return qh;
 }
 
-/* magic numbers that can affect system performance */
-#define EHCI_TUNE_CERR          3       /* 0-3 qtd retries; 0 == don't stop */
-#define EHCI_TUNE_RL_HS         4       /* nak throttle; see 4.9 */
-#define EHCI_TUNE_RL_TT         0
-#define EHCI_TUNE_MULT_HS       1       /* 1-3 transactions/uframe; 4.10.3 */
-#define EHCI_TUNE_MULT_TT       1
-#define EHCI_TUNE_FLS           2       /* (small) 256 frame schedule */
+static void qh_free(struct isp1760_qh *qh)
+{
+        WARN_ON(!list_empty(&qh->qtd_list));
+        WARN_ON(qh->slot > -1);
+        kmem_cache_free(qh_cachep, qh);
+}
 
 /* one-time init, only for memory state */
 static int priv_init(struct usb_hcd *hcd)
@@ -354,6 +405,10 @@ static int priv_init(struct usb_hcd *hcd)
 
         spin_lock_init(&priv->lock);
 
+        INIT_LIST_HEAD(&priv->interruptqhs);
+        INIT_LIST_HEAD(&priv->controlqhs);
+        INIT_LIST_HEAD(&priv->bulkqhs);
+
         /*
          * hw default: 1K periodic list heads, one per frame.
          * periodic_size can shrink by USBCMD update if hcc_params allows.
@@ -361,7 +416,7 @@ static int priv_init(struct usb_hcd *hcd)
         priv->periodic_size = DEFAULT_I_TDPS;
 
         /* controllers may cache some of the periodic schedule ... */
-        hcc_params = isp1760_readl(hcd->regs + HC_HCCPARAMS);
+        hcc_params = reg_read32(hcd->regs, HC_HCCPARAMS);
         /* full frame cache */
         if (HCC_ISOC_CACHE(hcc_params))
                 priv->i_thresh = 8;
@@ -398,46 +453,52 @@ static int isp1760_hc_setup(struct usb_hcd *hcd)
          * Write it twice to ensure correct upper bits if switching
          * to 16-bit mode.
          */
-        isp1760_writel(hwmode, hcd->regs + HC_HW_MODE_CTRL);
-        isp1760_writel(hwmode, hcd->regs + HC_HW_MODE_CTRL);
+        reg_write32(hcd->regs, HC_HW_MODE_CTRL, hwmode);
+        reg_write32(hcd->regs, HC_HW_MODE_CTRL, hwmode);
 
-        isp1760_writel(0xdeadbabe, hcd->regs + HC_SCRATCH_REG);
+        reg_write32(hcd->regs, HC_SCRATCH_REG, 0xdeadbabe);
         /* Change bus pattern */
-        scratch = isp1760_readl(hcd->regs + HC_CHIP_ID_REG);
-        scratch = isp1760_readl(hcd->regs + HC_SCRATCH_REG);
+        scratch = reg_read32(hcd->regs, HC_CHIP_ID_REG);
+        scratch = reg_read32(hcd->regs, HC_SCRATCH_REG);
         if (scratch != 0xdeadbabe) {
-                printk(KERN_ERR "ISP1760: Scratch test failed.\n");
+                dev_err(hcd->self.controller, "Scratch test failed.\n");
                 return -ENODEV;
         }
 
         /* pre reset */
-        isp1760_init_regs(hcd);
+        reg_write32(hcd->regs, HC_BUFFER_STATUS_REG, 0);
+        reg_write32(hcd->regs, HC_ATL_PTD_SKIPMAP_REG, NO_TRANSFER_ACTIVE);
+        reg_write32(hcd->regs, HC_INT_PTD_SKIPMAP_REG, NO_TRANSFER_ACTIVE);
+        reg_write32(hcd->regs, HC_ISO_PTD_SKIPMAP_REG, NO_TRANSFER_ACTIVE);
 
         /* reset */
-        isp1760_writel(SW_RESET_RESET_ALL, hcd->regs + HC_RESET_REG);
+        reg_write32(hcd->regs, HC_RESET_REG, SW_RESET_RESET_ALL);
         mdelay(100);
 
-        isp1760_writel(SW_RESET_RESET_HC, hcd->regs + HC_RESET_REG);
+        reg_write32(hcd->regs, HC_RESET_REG, SW_RESET_RESET_HC);
         mdelay(100);
 
-        result = ehci_reset(priv);
+        result = ehci_reset(hcd);
         if (result)
                 return result;
 
         /* Step 11 passed */
 
-        isp1760_info(priv, "bus width: %d, oc: %s\n",
+        dev_info(hcd->self.controller, "bus width: %d, oc: %s\n",
                            (priv->devflags & ISP1760_FLAG_BUS_WIDTH_16) ?
                            16 : 32, (priv->devflags & ISP1760_FLAG_ANALOG_OC) ?
                            "analog" : "digital");
 
+        /* This is weird: at the first plug-in of a device there seems to be
+           one packet queued that never gets returned? */
+        priv->active_ptds = -1;
+
         /* ATL reset */
-        isp1760_writel(hwmode | ALL_ATX_RESET, hcd->regs + HC_HW_MODE_CTRL);
+        reg_write32(hcd->regs, HC_HW_MODE_CTRL, hwmode | ALL_ATX_RESET);
         mdelay(10);
-        isp1760_writel(hwmode, hcd->regs + HC_HW_MODE_CTRL);
+        reg_write32(hcd->regs, HC_HW_MODE_CTRL, hwmode);
 
-        isp1760_writel(INTERRUPT_ENABLE_MASK, hcd->regs + HC_INTERRUPT_REG);
-        isp1760_writel(INTERRUPT_ENABLE_MASK, hcd->regs + HC_INTERRUPT_ENABLE);
+        reg_write32(hcd->regs, HC_INTERRUPT_ENABLE, INTERRUPT_ENABLE_MASK);
 
         /*
          * PORT 1 Control register of the ISP1760 is the OTG control
@@ -445,11 +506,10 @@ static int isp1760_hc_setup(struct usb_hcd *hcd)
          * support in this driver, we use port 1 as a "normal" USB host port on
          * both chips.
          */
-        isp1760_writel(PORT1_POWER | PORT1_INIT2,
-                       hcd->regs + HC_PORT1_CTRL);
+        reg_write32(hcd->regs, HC_PORT1_CTRL, PORT1_POWER | PORT1_INIT2);
         mdelay(10);
 
-        priv->hcs_params = isp1760_readl(hcd->regs + HC_HCSPARAMS);
+        priv->hcs_params = reg_read32(hcd->regs, HC_HCSPARAMS);
 
         return priv_init(hcd);
 }
@@ -457,25 +517,31 @@ static int isp1760_hc_setup(struct usb_hcd *hcd)
 static void isp1760_init_maps(struct usb_hcd *hcd)
 {
         /*set last maps, for iso its only 1, else 32 tds bitmap*/
-        isp1760_writel(0x80000000, hcd->regs + HC_ATL_PTD_LASTPTD_REG);
-        isp1760_writel(0x80000000, hcd->regs + HC_INT_PTD_LASTPTD_REG);
-        isp1760_writel(0x00000001, hcd->regs + HC_ISO_PTD_LASTPTD_REG);
+        reg_write32(hcd->regs, HC_ATL_PTD_LASTPTD_REG, 0x80000000);
+        reg_write32(hcd->regs, HC_INT_PTD_LASTPTD_REG, 0x80000000);
+        reg_write32(hcd->regs, HC_ISO_PTD_LASTPTD_REG, 0x00000001);
+
+        reg_write32(hcd->regs, HC_ATL_PTD_SKIPMAP_REG, 0xffffffff);
+        reg_write32(hcd->regs, HC_INT_PTD_SKIPMAP_REG, 0xffffffff);
+        reg_write32(hcd->regs, HC_ISO_PTD_SKIPMAP_REG, 0xffffffff);
+
+        reg_write32(hcd->regs, HC_BUFFER_STATUS_REG,
+                                                ATL_BUF_FILL | INT_BUF_FILL);
 }
 
 static void isp1760_enable_interrupts(struct usb_hcd *hcd)
 {
-        isp1760_writel(0, hcd->regs + HC_ATL_IRQ_MASK_AND_REG);
-        isp1760_writel(0, hcd->regs + HC_ATL_IRQ_MASK_OR_REG);
-        isp1760_writel(0, hcd->regs + HC_INT_IRQ_MASK_AND_REG);
-        isp1760_writel(0, hcd->regs + HC_INT_IRQ_MASK_OR_REG);
-        isp1760_writel(0, hcd->regs + HC_ISO_IRQ_MASK_AND_REG);
-        isp1760_writel(0xffffffff, hcd->regs + HC_ISO_IRQ_MASK_OR_REG);
+        reg_write32(hcd->regs, HC_ATL_IRQ_MASK_AND_REG, 0);
+        reg_write32(hcd->regs, HC_ATL_IRQ_MASK_OR_REG, 0xffffffff);
+        reg_write32(hcd->regs, HC_INT_IRQ_MASK_AND_REG, 0);
+        reg_write32(hcd->regs, HC_INT_IRQ_MASK_OR_REG, 0xffffffff);
+        reg_write32(hcd->regs, HC_ISO_IRQ_MASK_AND_REG, 0);
+        reg_write32(hcd->regs, HC_ISO_IRQ_MASK_OR_REG, 0xffffffff);
         /* step 23 passed */
 }
 
 static int isp1760_run(struct usb_hcd *hcd)
 {
-        struct isp1760_hcd *priv = hcd_to_priv(hcd);
         int retval;
         u32 temp;
         u32 command;
@@ -485,16 +551,15 @@ static int isp1760_run(struct usb_hcd *hcd)
 
         hcd->state = HC_STATE_RUNNING;
         isp1760_enable_interrupts(hcd);
-        temp = isp1760_readl(hcd->regs + HC_HW_MODE_CTRL);
-        isp1760_writel(temp | HW_GLOBAL_INTR_EN, hcd->regs + HC_HW_MODE_CTRL);
+        temp = reg_read32(hcd->regs, HC_HW_MODE_CTRL);
+        reg_write32(hcd->regs, HC_HW_MODE_CTRL, temp | HW_GLOBAL_INTR_EN);
 
-        command = isp1760_readl(hcd->regs + HC_USBCMD);
+        command = reg_read32(hcd->regs, HC_USBCMD);
         command &= ~(CMD_LRESET|CMD_RESET);
         command |= CMD_RUN;
-        isp1760_writel(command, hcd->regs + HC_USBCMD);
+        reg_write32(hcd->regs, HC_USBCMD, command);
 
-        retval = handshake(priv, hcd->regs + HC_USBCMD, CMD_RUN, CMD_RUN,
-                        250 * 1000);
+        retval = handshake(hcd, HC_USBCMD, CMD_RUN, CMD_RUN, 250 * 1000);
         if (retval)
                 return retval;
 
@@ -504,17 +569,16 @@ static int isp1760_run(struct usb_hcd *hcd)
          * the semaphore while doing so.
          */
         down_write(&ehci_cf_port_reset_rwsem);
-        isp1760_writel(FLAG_CF, hcd->regs + HC_CONFIGFLAG);
+        reg_write32(hcd->regs, HC_CONFIGFLAG, FLAG_CF);
 
-        retval = handshake(priv, hcd->regs + HC_CONFIGFLAG, FLAG_CF, FLAG_CF,
-                        250 * 1000);
+        retval = handshake(hcd, HC_CONFIGFLAG, FLAG_CF, FLAG_CF, 250 * 1000);
         up_write(&ehci_cf_port_reset_rwsem);
         if (retval)
                 return retval;
 
-        chipid = isp1760_readl(hcd->regs + HC_CHIP_ID_REG);
-        isp1760_info(priv, "USB ISP %04x HW rev. %d started\n", chipid & 0xffff,
-                        chipid >> 16);
+        chipid = reg_read32(hcd->regs, HC_CHIP_ID_REG);
+        dev_info(hcd->self.controller, "USB ISP %04x HW rev. %d started\n",
+                                        chipid & 0xffff, chipid >> 16);
 
         /* PTD Register Init Part 2, Step 28 */
         /* enable INTs */
@@ -532,378 +596,169 @@ static u32 base_to_chip(u32 base)
         return ((base - 0x400) >> 3);
 }
 
-static void transform_into_atl(struct isp1760_hcd *priv, struct isp1760_qh *qh,
-                        struct isp1760_qtd *qtd, struct urb *urb,
-                        u32 payload, struct ptd *ptd)
+static int last_qtd_of_urb(struct isp1760_qtd *qtd, struct isp1760_qh *qh)
+{
+        struct urb *urb;
+
+        if (list_is_last(&qtd->qtd_list, &qh->qtd_list))
+                return 1;
+
+        urb = qtd->urb;
+        qtd = list_entry(qtd->qtd_list.next, typeof(*qtd), qtd_list);
+        return (qtd->urb != urb);
+}
+
+/* magic numbers that can affect system performance */
+#define EHCI_TUNE_CERR          3       /* 0-3 qtd retries; 0 == don't stop */
+#define EHCI_TUNE_RL_HS         4       /* nak throttle; see 4.9 */
+#define EHCI_TUNE_RL_TT         0
+#define EHCI_TUNE_MULT_HS       1       /* 1-3 transactions/uframe; 4.10.3 */
+#define EHCI_TUNE_MULT_TT       1
+#define EHCI_TUNE_FLS           2       /* (small) 256 frame schedule */
+
+static void create_ptd_atl(struct isp1760_qh *qh,
+                        struct isp1760_qtd *qtd, struct ptd *ptd)
 {
-        u32 dw0;
-        u32 dw1;
-        u32 dw2;
-        u32 dw3;
         u32 maxpacket;
         u32 multi;
-        u32 pid_code;
         u32 rl = RL_COUNTER;
         u32 nak = NAK_COUNTER;
 
+        memset(ptd, 0, sizeof(*ptd));
+
         /* according to 3.6.2, max packet len can not be > 0x400 */
-        maxpacket = usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe));
+        maxpacket = usb_maxpacket(qtd->urb->dev, qtd->urb->pipe,
+                                                usb_pipeout(qtd->urb->pipe));
         multi =  1 + ((maxpacket >> 11) & 0x3);
         maxpacket &= 0x7ff;
 
         /* DW0 */
-        dw0 = PTD_VALID;
-        dw0 |= PTD_LENGTH(qtd->length);
-        dw0 |= PTD_MAXPACKET(maxpacket);
-        dw0 |= PTD_ENDPOINT(usb_pipeendpoint(urb->pipe));
-        dw1 = usb_pipeendpoint(urb->pipe) >> 1;
+        ptd->dw0 = DW0_VALID_BIT;
+        ptd->dw0 |= TO_DW0_LENGTH(qtd->length);
+        ptd->dw0 |= TO_DW0_MAXPACKET(maxpacket);
+        ptd->dw0 |= TO_DW0_ENDPOINT(usb_pipeendpoint(qtd->urb->pipe));
 
         /* DW1 */
-        dw1 |= PTD_DEVICE_ADDR(usb_pipedevice(urb->pipe));
+        ptd->dw1 = usb_pipeendpoint(qtd->urb->pipe) >> 1;
+        ptd->dw1 |= TO_DW1_DEVICE_ADDR(usb_pipedevice(qtd->urb->pipe));
+        ptd->dw1 |= TO_DW1_PID_TOKEN(qtd->packet_type);
 
-        pid_code = qtd->packet_type;
-        dw1 |= PTD_PID_TOKEN(pid_code);
+        if (usb_pipebulk(qtd->urb->pipe))
+                ptd->dw1 |= DW1_TRANS_BULK;
+        else if  (usb_pipeint(qtd->urb->pipe))
+                ptd->dw1 |= DW1_TRANS_INT;
 
-        if (usb_pipebulk(urb->pipe))
-                dw1 |= PTD_TRANS_BULK;
-        else if  (usb_pipeint(urb->pipe))
-                dw1 |= PTD_TRANS_INT;
-
-        if (urb->dev->speed != USB_SPEED_HIGH) {
+        if (qtd->urb->dev->speed != USB_SPEED_HIGH) {
                 /* split transaction */
 
-                dw1 |= PTD_TRANS_SPLIT;
-                if (urb->dev->speed == USB_SPEED_LOW)
-                        dw1 |= PTD_SE_USB_LOSPEED;
+                ptd->dw1 |= DW1_TRANS_SPLIT;
+                if (qtd->urb->dev->speed == USB_SPEED_LOW)
+                        ptd->dw1 |= DW1_SE_USB_LOSPEED;
 
-                dw1 |= PTD_PORT_NUM(urb->dev->ttport);
-                dw1 |= PTD_HUB_NUM(urb->dev->tt->hub->devnum);
+                ptd->dw1 |= TO_DW1_PORT_NUM(qtd->urb->dev->ttport);
+                ptd->dw1 |= TO_DW1_HUB_NUM(qtd->urb->dev->tt->hub->devnum);
 
                 /* SE bit for Split INT transfers */
-                if (usb_pipeint(urb->pipe) &&
-                                (urb->dev->speed == USB_SPEED_LOW))
-                        dw1 |= 2 << 16;
+                if (usb_pipeint(qtd->urb->pipe) &&
+                                (qtd->urb->dev->speed == USB_SPEED_LOW))
+                        ptd->dw1 |= 2 << 16;
 
-                dw3 = 0;
                 rl = 0;
                 nak = 0;
         } else {
-                dw0 |= PTD_MULTI(multi);
-                if (usb_pipecontrol(urb->pipe) || usb_pipebulk(urb->pipe))
-                        dw3 = qh->ping;
-                else
-                        dw3 = 0;
+                ptd->dw0 |= TO_DW0_MULTI(multi);
+                if (usb_pipecontrol(qtd->urb->pipe) ||
+                                                usb_pipebulk(qtd->urb->pipe))
+                        ptd->dw3 |= TO_DW3_PING(qh->ping);
         }
         /* DW2 */
-        dw2 = 0;
-        dw2 |= PTD_DATA_START_ADDR(base_to_chip(payload));
-        dw2 |= PTD_RL_CNT(rl);
-        dw3 |= PTD_NAC_CNT(nak);
+        ptd->dw2 = 0;
+        ptd->dw2 |= TO_DW2_DATA_START_ADDR(base_to_chip(qtd->payload_addr));
+        ptd->dw2 |= TO_DW2_RL(rl);
 
         /* DW3 */
-        if (usb_pipecontrol(urb->pipe))
-                dw3 |= PTD_DATA_TOGGLE(qtd->toggle);
-        else
-                dw3 |= qh->toggle;
-
+        ptd->dw3 |= TO_DW3_NAKCOUNT(nak);
+        ptd->dw3 |= TO_DW3_DATA_TOGGLE(qh->toggle);
+        if (usb_pipecontrol(qtd->urb->pipe)) {
+                if (qtd->data_buffer == qtd->urb->setup_packet)
+                        ptd->dw3 &= ~TO_DW3_DATA_TOGGLE(1);
+                else if (last_qtd_of_urb(qtd, qh))
+                        ptd->dw3 |= TO_DW3_DATA_TOGGLE(1);
+        }
 
-        dw3 |= PTD_ACTIVE;
+        ptd->dw3 |= DW3_ACTIVE_BIT;
         /* Cerr */
-        dw3 |= PTD_CERR(ERR_COUNTER);
-
-        memset(ptd, 0, sizeof(*ptd));
-
-        ptd->dw0 = cpu_to_le32(dw0);
-        ptd->dw1 = cpu_to_le32(dw1);
-        ptd->dw2 = cpu_to_le32(dw2);
-        ptd->dw3 = cpu_to_le32(dw3);
+        ptd->dw3 |= TO_DW3_CERR(ERR_COUNTER);
 }
 
-static void transform_add_int(struct isp1760_hcd *priv, struct isp1760_qh *qh,
-                        struct isp1760_qtd *qtd, struct urb *urb,
-                        u32 payload, struct ptd *ptd)
+static void transform_add_int(struct isp1760_qh *qh,
+                        struct isp1760_qtd *qtd, struct ptd *ptd)
 {
-        u32 maxpacket;
-        u32 multi;
-        u32 numberofusofs;
-        u32 i;
-        u32 usofmask, usof;
+        u32 usof;
         u32 period;
 
-        maxpacket = usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe));
-        multi =  1 + ((maxpacket >> 11) & 0x3);
-        maxpacket &= 0x7ff;
-        /* length of the data per uframe */
-        maxpacket = multi * maxpacket;
-
-        numberofusofs = urb->transfer_buffer_length / maxpacket;
-        if (urb->transfer_buffer_length % maxpacket)
-                numberofusofs += 1;
-
-        usofmask = 1;
-        usof = 0;
-        for (i = 0; i < numberofusofs; i++) {
-                usof |= usofmask;
-                usofmask <<= 1;
-        }
-
-        if (urb->dev->speed != USB_SPEED_HIGH) {
-                /* split */
-                ptd->dw5 = cpu_to_le32(0x1c);
+        /*
+         * Most of this is guessing. ISP1761 datasheet is quite unclear, and
+         * the algorithm from the original Philips driver code, which was
+         * pretty much used in this driver before as well, is quite horrendous
+         * and, i believe, incorrect. The code below follows the datasheet and
+         * USB2.0 spec as far as I can tell, and plug/unplug seems to be much
+         * more reliable this way (fingers crossed...).
+         */
 
-                if (qh->period >= 32)
-                        period = qh->period / 2;
+        if (qtd->urb->dev->speed == USB_SPEED_HIGH) {
+                /* urb->interval is in units of microframes (1/8 ms) */
+                period = qtd->urb->interval >> 3;
+
+                if (qtd->urb->interval > 4)
+                        usof = 0x01; /* One bit set =>
+                                                interval 1 ms * uFrame-match */
+                else if (qtd->urb->interval > 2)
+                        usof = 0x22; /* Two bits set => interval 1/2 ms */
+                else if (qtd->urb->interval > 1)
+                        usof = 0x55; /* Four bits set => interval 1/4 ms */
                 else
-                        period = qh->period;
-
+                        usof = 0xff; /* All bits set => interval 1/8 ms */
         } else {
+                /* urb->interval is in units of frames (1 ms) */
+                period = qtd->urb->interval;
+                usof = 0x0f;            /* Execute Start Split on any of the
+                                           four first uFrames */
 
-                if (qh->period >= 8)
-                        period = qh->period/8;
-                else
-                        period = qh->period;
-
-                if (period >= 32)
-                        period  = 16;
-
-                if (qh->period >= 8) {
-                        /* millisecond period */
-                        period = (period << 3);
-                } else {
-                        /* usof based tranmsfers */
-                        /* minimum 4 usofs */
-                        usof = 0x11;
-                }
-        }
-
-        ptd->dw2 |= cpu_to_le32(period);
-        ptd->dw4 = cpu_to_le32(usof);
-}
-
-static void transform_into_int(struct isp1760_hcd *priv, struct isp1760_qh *qh,
-                        struct isp1760_qtd *qtd, struct urb *urb,
-                        u32 payload, struct ptd *ptd)
-{
-        transform_into_atl(priv, qh, qtd, urb, payload, ptd);
-        transform_add_int(priv, qh, qtd, urb,  payload, ptd);
-}
-
-static int qtd_fill(struct isp1760_qtd *qtd, void *databuffer, size_t len,
-                u32 token)
-{
-        int count;
-
-        qtd->data_buffer = databuffer;
-        qtd->packet_type = GET_QTD_TOKEN_TYPE(token);
-        qtd->toggle = GET_DATA_TOGGLE(token);
-
-        if (len > HC_ATL_PL_SIZE)
-                count = HC_ATL_PL_SIZE;
-        else
-                count = len;
-
-        qtd->length = count;
-        return count;
-}
-
-static int check_error(struct ptd *ptd)
-{
-        int error = 0;
-        u32 dw3;
-
-        dw3 = le32_to_cpu(ptd->dw3);
-        if (dw3 & DW3_HALT_BIT) {
-                error = -EPIPE;
-
-                if (dw3 & DW3_ERROR_BIT)
-                        pr_err("error bit is set in DW3\n");
-        }
-
-        if (dw3 & DW3_QTD_ACTIVE) {
-                printk(KERN_ERR "transfer active bit is set DW3\n");
-                printk(KERN_ERR "nak counter: %d, rl: %d\n", (dw3 >> 19) & 0xf,
-                                (le32_to_cpu(ptd->dw2) >> 25) & 0xf);
-        }
-
-        return error;
-}
-
-static void check_int_err_status(u32 dw4)
-{
-        u32 i;
-
-        dw4 >>= 8;
-
-        for (i = 0; i < 8; i++) {
-                switch (dw4 & 0x7) {
-                case INT_UNDERRUN:
-                        printk(KERN_ERR "ERROR: under run , %d\n", i);
-                        break;
-
-                case INT_EXACT:
-                        printk(KERN_ERR "ERROR: transaction error, %d\n", i);
-                        break;
-
-                case INT_BABBLE:
-                        printk(KERN_ERR "ERROR: babble error, %d\n", i);
-                        break;
-                }
-                dw4 >>= 3;
-        }
-}
-
-static void enqueue_one_qtd(struct isp1760_qtd *qtd, struct isp1760_hcd *priv,
-                u32 payload)
-{
-        u32 token;
-        struct usb_hcd *hcd = priv_to_hcd(priv);
-
-        token = qtd->packet_type;
-
-        if (qtd->length && (qtd->length <= HC_ATL_PL_SIZE)) {
-                switch (token) {
-                case IN_PID:
-                        break;
-                case OUT_PID:
-                case SETUP_PID:
-                        priv_write_copy(priv, qtd->data_buffer,
-                                        hcd->regs + payload,
-                                        qtd->length);
-                }
+                /*
+                 * First 8 bits in dw5 is uSCS and "specifies which uSOF the
+                 * complete split needs to be sent. Valid only for IN." Also,
+                 * "All bits can be set to one for every transfer." (p 82,
+                 * ISP1761 data sheet.) 0x1c is from Philips driver. Where did
+                 * that number come from? 0xff seems to work fine...
+                 */
+                /* ptd->dw5 = 0x1c; */
+                ptd->dw5 = 0xff; /* Execute Complete Split on any uFrame */
         }
-}
-
-static void enqueue_one_atl_qtd(u32 atl_regs, u32 payload,
-                struct isp1760_hcd *priv, struct isp1760_qh *qh,
-                struct urb *urb, u32 slot, struct isp1760_qtd *qtd)
-{
-        struct ptd ptd;
-        struct usb_hcd *hcd = priv_to_hcd(priv);
-
-        transform_into_atl(priv, qh, qtd, urb, payload, &ptd);
-        priv_write_copy(priv, (u32 *)&ptd, hcd->regs + atl_regs, sizeof(ptd));
-        enqueue_one_qtd(qtd, priv, payload);
-
-        priv->atl_ints[slot].urb = urb;
-        priv->atl_ints[slot].qh = qh;
-        priv->atl_ints[slot].qtd = qtd;
-        priv->atl_ints[slot].data_buffer = qtd->data_buffer;
-        priv->atl_ints[slot].payload = payload;
-        qtd->status |= URB_ENQUEUED | URB_TYPE_ATL;
-        qtd->status |= slot << 16;
-}
-
-static void enqueue_one_int_qtd(u32 int_regs, u32 payload,
-                struct isp1760_hcd *priv, struct isp1760_qh *qh,
-                struct urb *urb, u32 slot,  struct isp1760_qtd *qtd)
-{
-        struct ptd ptd;
-        struct usb_hcd *hcd = priv_to_hcd(priv);
-
-        transform_into_int(priv, qh, qtd, urb, payload, &ptd);
-        priv_write_copy(priv, (u32 *)&ptd, hcd->regs + int_regs, sizeof(ptd));
-        enqueue_one_qtd(qtd, priv, payload);
-
-        priv->int_ints[slot].urb = urb;
-        priv->int_ints[slot].qh = qh;
-        priv->int_ints[slot].qtd = qtd;
-        priv->int_ints[slot].data_buffer = qtd->data_buffer;
-        priv->int_ints[slot].payload = payload;
-        qtd->status |= URB_ENQUEUED | URB_TYPE_INT;
-        qtd->status |= slot << 16;
-}
-
-static void enqueue_an_ATL_packet(struct usb_hcd *hcd, struct isp1760_qh *qh,
-                                  struct isp1760_qtd *qtd)
-{
-        struct isp1760_hcd *priv = hcd_to_priv(hcd);
-        u32 skip_map, or_map;
-        u32 queue_entry;
-        u32 slot;
-        u32 atl_regs, payload;
-        u32 buffstatus;
-
-        /*
-         * When this function is called from the interrupt handler to enqueue
-         * a follow-up packet, the SKIP register gets written and read back
-         * almost immediately. With ISP1761, this register requires a delay of
-         * 195ns between a write and subsequent read (see section 15.1.1.3).
-         */
-        mmiowb();
-        ndelay(195);
-        skip_map = isp1760_readl(hcd->regs + HC_ATL_PTD_SKIPMAP_REG);
-
-        BUG_ON(!skip_map);
-        slot = __ffs(skip_map);
-        queue_entry = 1 << slot;
-
-        atl_regs = ATL_REGS_OFFSET + slot * sizeof(struct ptd);
 
-        payload = alloc_mem(priv, qtd->length);
+        period = period >> 1;/* Ensure equal or shorter period than requested */
+        period &= 0xf8; /* Mask off too large values and lowest unused 3 bits */
 
-        enqueue_one_atl_qtd(atl_regs, payload, priv, qh, qtd->urb, slot, qtd);
-
-        or_map = isp1760_readl(hcd->regs + HC_ATL_IRQ_MASK_OR_REG);
-        or_map |= queue_entry;
-        isp1760_writel(or_map, hcd->regs + HC_ATL_IRQ_MASK_OR_REG);
-
-        skip_map &= ~queue_entry;
-        isp1760_writel(skip_map, hcd->regs + HC_ATL_PTD_SKIPMAP_REG);
-
-        buffstatus = isp1760_readl(hcd->regs + HC_BUFFER_STATUS_REG);
-        buffstatus |= ATL_BUFFER;
-        isp1760_writel(buffstatus, hcd->regs + HC_BUFFER_STATUS_REG);
+        ptd->dw2 |= period;
+        ptd->dw4 = usof;
 }
 
-static void enqueue_an_INT_packet(struct usb_hcd *hcd, struct isp1760_qh *qh,
-                                  struct isp1760_qtd *qtd)
+static void create_ptd_int(struct isp1760_qh *qh,
+                        struct isp1760_qtd *qtd, struct ptd *ptd)
 {
-        struct isp1760_hcd *priv = hcd_to_priv(hcd);
-        u32 skip_map, or_map;
-        u32 queue_entry;
-        u32 slot;
-        u32 int_regs, payload;
-        u32 buffstatus;
-
-        /*
-         * When this function is called from the interrupt handler to enqueue
-         * a follow-up packet, the SKIP register gets written and read back
-         * almost immediately. With ISP1761, this register requires a delay of
-         * 195ns between a write and subsequent read (see section 15.1.1.3).
-         */
-        mmiowb();
-        ndelay(195);
-        skip_map = isp1760_readl(hcd->regs + HC_INT_PTD_SKIPMAP_REG);
-
-        BUG_ON(!skip_map);
-        slot = __ffs(skip_map);
-        queue_entry = 1 << slot;
-
-        int_regs = INT_REGS_OFFSET + slot * sizeof(struct ptd);
-
-        payload = alloc_mem(priv, qtd->length);
-
-        enqueue_one_int_qtd(int_regs, payload, priv, qh, qtd->urb, slot, qtd);
-
-        or_map = isp1760_readl(hcd->regs + HC_INT_IRQ_MASK_OR_REG);
-        or_map |= queue_entry;
-        isp1760_writel(or_map, hcd->regs + HC_INT_IRQ_MASK_OR_REG);
-
-        skip_map &= ~queue_entry;
-        isp1760_writel(skip_map, hcd->regs + HC_INT_PTD_SKIPMAP_REG);
-
-        buffstatus = isp1760_readl(hcd->regs + HC_BUFFER_STATUS_REG);
-        buffstatus |= INT_BUFFER;
-        isp1760_writel(buffstatus, hcd->regs + HC_BUFFER_STATUS_REG);
+        create_ptd_atl(qh, qtd, ptd);
+        transform_add_int(qh, qtd, ptd);
 }
 
-static void isp1760_urb_done(struct isp1760_hcd *priv, struct urb *urb, int status)
+static void isp1760_urb_done(struct usb_hcd *hcd, struct urb *urb)
 __releases(priv->lock)
 __acquires(priv->lock)
 {
+        struct isp1760_hcd *priv = hcd_to_priv(hcd);
+
         if (!urb->unlinked) {
-                if (status == -EINPROGRESS)
-                        status = 0;
+                if (urb->status == -EINPROGRESS)
+                        urb->status = 0;
         }
 
         if (usb_pipein(urb->pipe) && usb_pipetype(urb->pipe) != PIPE_CONTROL) {
@@ -915,679 +770,660 @@ __acquires(priv->lock)
         }
 
         /* complete() can reenter this HCD */
-        usb_hcd_unlink_urb_from_ep(priv_to_hcd(priv), urb);
+        usb_hcd_unlink_urb_from_ep(hcd, urb);
         spin_unlock(&priv->lock);
-        usb_hcd_giveback_urb(priv_to_hcd(priv), urb, status);
+        usb_hcd_giveback_urb(hcd, urb, urb->status);
         spin_lock(&priv->lock);
 }
 
-static void isp1760_qtd_free(struct isp1760_qtd *qtd)
+static struct isp1760_qtd *qtd_alloc(gfp_t flags, struct urb *urb,
+                                                                u8 packet_type)
 {
-        kmem_cache_free(qtd_cachep, qtd);
-}
-
-static struct isp1760_qtd *clean_this_qtd(struct isp1760_qtd *qtd)
-{
-        struct isp1760_qtd *tmp_qtd;
-
-        tmp_qtd = qtd->hw_next;
-        list_del(&qtd->qtd_list);
-        isp1760_qtd_free(qtd);
-        return tmp_qtd;
-}
+        struct isp1760_qtd *qtd;
 
-/*
- * Remove this QTD from the QH list and free its memory. If this QTD
- * isn't the last one than remove also his successor(s).
- * Returns the QTD which is part of an new URB and should be enqueued.
- */
-static struct isp1760_qtd *clean_up_qtdlist(struct isp1760_qtd *qtd)
-{
-        struct isp1760_qtd *tmp_qtd;
-        int last_one;
+        qtd = kmem_cache_zalloc(qtd_cachep, flags);
+        if (!qtd)
+                return NULL;
 
-        do {
-                tmp_qtd = qtd->hw_next;
-                last_one = qtd->status & URB_COMPLETE_NOTIFY;
-                list_del(&qtd->qtd_list);
-                isp1760_qtd_free(qtd);
-                qtd = tmp_qtd;
-        } while (!last_one && qtd);
+        INIT_LIST_HEAD(&qtd->qtd_list);
+        qtd->urb = urb;
+        qtd->packet_type = packet_type;
+        qtd->status = QTD_ENQUEUED;
+        qtd->actual_length = 0;
 
         return qtd;
 }
 
-static void do_atl_int(struct usb_hcd *usb_hcd)
+static void qtd_free(struct isp1760_qtd *qtd)
 {
-        struct isp1760_hcd *priv = hcd_to_priv(usb_hcd);
-        u32 done_map, skip_map;
-        struct ptd ptd;
-        struct urb *urb = NULL;
-        u32 atl_regs_base;
-        u32 atl_regs;
-        u32 queue_entry;
-        u32 payload;
-        u32 length;
-        u32 or_map;
-        u32 status = -EINVAL;
-        int error;
-        struct isp1760_qtd *qtd;
-        struct isp1760_qh *qh;
-        u32 rl;
-        u32 nakcount;
-
-        done_map = isp1760_readl(usb_hcd->regs +
-                        HC_ATL_PTD_DONEMAP_REG);
-        skip_map = isp1760_readl(usb_hcd->regs +
-                        HC_ATL_PTD_SKIPMAP_REG);
-
-        or_map = isp1760_readl(usb_hcd->regs + HC_ATL_IRQ_MASK_OR_REG);
-        or_map &= ~done_map;
-        isp1760_writel(or_map, usb_hcd->regs + HC_ATL_IRQ_MASK_OR_REG);
-
-        atl_regs_base = ATL_REGS_OFFSET;
-        while (done_map) {
-                u32 dw1;
-                u32 dw2;
-                u32 dw3;
-
-                status = 0;
-
-                queue_entry = __ffs(done_map);
-                done_map &= ~(1 << queue_entry);
-                skip_map |= 1 << queue_entry;
-
-                atl_regs = atl_regs_base + queue_entry * sizeof(struct ptd);
-
-                urb = priv->atl_ints[queue_entry].urb;
-                qtd = priv->atl_ints[queue_entry].qtd;
-                qh = priv->atl_ints[queue_entry].qh;
-                payload = priv->atl_ints[queue_entry].payload;
-
-                if (!qh) {
-                        printk(KERN_ERR "qh is 0\n");
-                        continue;
-                }
-                isp1760_writel(atl_regs + ISP_BANK(0), usb_hcd->regs +
-                                HC_MEMORY_REG);
-                isp1760_writel(payload  + ISP_BANK(1), usb_hcd->regs +
-                                HC_MEMORY_REG);
-                /*
-                 * write bank1 address twice to ensure the 90ns delay (time
-                 * between BANK0 write and the priv_read_copy() call is at
-                 * least 3*t_WHWL + 2*t_w11 = 3*25ns + 2*17ns = 109ns)
-                 */
-                isp1760_writel(payload  + ISP_BANK(1), usb_hcd->regs +
-                                HC_MEMORY_REG);
-
-                priv_read_copy(priv, (u32 *)&ptd, usb_hcd->regs + atl_regs +
-                                ISP_BANK(0), sizeof(ptd));
+        WARN_ON(qtd->payload_addr);
+        kmem_cache_free(qtd_cachep, qtd);
+}
 
-                dw1 = le32_to_cpu(ptd.dw1);
-                dw2 = le32_to_cpu(ptd.dw2);
-                dw3 = le32_to_cpu(ptd.dw3);
-                rl = (dw2 >> 25) & 0x0f;
-                nakcount = (dw3 >> 19) & 0xf;
+static void start_bus_transfer(struct usb_hcd *hcd, u32 ptd_offset, int slot,
+                                struct slotinfo *slots, struct isp1760_qtd *qtd,
+                                struct isp1760_qh *qh, struct ptd *ptd)
+{
+        struct isp1760_hcd *priv = hcd_to_priv(hcd);
+        int skip_map;
+
+        WARN_ON((slot < 0) || (slot > 31));
+        WARN_ON(qtd->length && !qtd->payload_addr);
+        WARN_ON(slots[slot].qtd);
+        WARN_ON(slots[slot].qh);
+        WARN_ON(qtd->status != QTD_PAYLOAD_ALLOC);
+
+        slots[slot].qtd = qtd;
+        slots[slot].qh = qh;
+        qh->slot = slot;
+        qtd->status = QTD_XFER_STARTED; /* Set this before writing ptd, since
+                interrupt routine may preempt and expects this value. */
+        ptd_write(hcd->regs, ptd_offset, slot, ptd);
+        priv->active_ptds++;
+
+        /* Make sure done map has not triggered from some unlinked transfer */
+        if (ptd_offset == ATL_PTD_OFFSET) {
+                priv->atl_done_map |= reg_read32(hcd->regs,
+                                                HC_ATL_PTD_DONEMAP_REG);
+                priv->atl_done_map &= ~(1 << qh->slot);
+
+                skip_map = reg_read32(hcd->regs, HC_ATL_PTD_SKIPMAP_REG);
+                skip_map &= ~(1 << qh->slot);
+                reg_write32(hcd->regs, HC_ATL_PTD_SKIPMAP_REG, skip_map);
+        } else {
+                priv->int_done_map |= reg_read32(hcd->regs,
+                                                HC_INT_PTD_DONEMAP_REG);
+                priv->int_done_map &= ~(1 << qh->slot);
 
-                /* Transfer Error, *but* active and no HALT -> reload */
-                if ((dw3 & DW3_ERROR_BIT) && (dw3 & DW3_QTD_ACTIVE) &&
-                                !(dw3 & DW3_HALT_BIT)) {
-
-                        /* according to ppriv code, we have to
-                         * reload this one if trasfered bytes != requested bytes
-                         * else act like everything went smooth..
-                         * XXX This just doesn't feel right and hasn't
-                         * triggered so far.
-                         */
+                skip_map = reg_read32(hcd->regs, HC_INT_PTD_SKIPMAP_REG);
+                skip_map &= ~(1 << qh->slot);
+                reg_write32(hcd->regs, HC_INT_PTD_SKIPMAP_REG, skip_map);
+        }
+}
 
-                        length = PTD_XFERRED_LENGTH(dw3);
-                        printk(KERN_ERR "Should reload now.... transfered %d "
-                                        "of %zu\n", length, qtd->length);
-                        BUG();
-                }
+static int is_short_bulk(struct isp1760_qtd *qtd)
+{
+        return (usb_pipebulk(qtd->urb->pipe) &&
+                                        (qtd->actual_length < qtd->length));
+}
 
-                if (!nakcount && (dw3 & DW3_QTD_ACTIVE)) {
-                        u32 buffstatus;
+static void collect_qtds(struct usb_hcd *hcd, struct isp1760_qh *qh,
+                                                struct list_head *urb_list)
+{
+        int last_qtd;
+        struct isp1760_qtd *qtd, *qtd_next;
+        struct urb_listitem *urb_listitem;
 
-                        /*
-                         * NAKs are handled in HW by the chip. Usually if the
-                         * device is not able to send data fast enough.
-                         * This happens mostly on slower hardware.
-                         */
-                        printk(KERN_NOTICE "Reloading ptd %p/%p... qh %p read: "
-                                        "%d of %zu done: %08x cur: %08x\n", qtd,
-                                        urb, qh, PTD_XFERRED_LENGTH(dw3),
-                                        qtd->length, done_map,
-                                        (1 << queue_entry));
+        list_for_each_entry_safe(qtd, qtd_next, &qh->qtd_list, qtd_list) {
+                if (qtd->status < QTD_XFER_COMPLETE)
+                        break;
 
-                        /* RL counter = ERR counter */
-                        dw3 &= ~(0xf << 19);
-                        dw3 |= rl << 19;
-                        dw3 &= ~(3 << (55 - 32));
-                        dw3 |= ERR_COUNTER << (55 - 32);
-
-                        /*
-                         * It is not needed to write skip map back because it
-                         * is unchanged. Just make sure that this entry is
-                         * unskipped once it gets written to the HW.
-                         */
-                        skip_map &= ~(1 << queue_entry);
-                        or_map = isp1760_readl(usb_hcd->regs +
-                                        HC_ATL_IRQ_MASK_OR_REG);
-                        or_map |= 1 << queue_entry;
-                        isp1760_writel(or_map, usb_hcd->regs +
-                                        HC_ATL_IRQ_MASK_OR_REG);
-
-                        ptd.dw3 = cpu_to_le32(dw3);
-                        priv_write_copy(priv, (u32 *)&ptd, usb_hcd->regs +
-                                        atl_regs, sizeof(ptd));
-
-                        ptd.dw0 |= cpu_to_le32(PTD_VALID);
-                        priv_write_copy(priv, (u32 *)&ptd, usb_hcd->regs +
-                                        atl_regs, sizeof(ptd));
-
-                        buffstatus = isp1760_readl(usb_hcd->regs +
-                                        HC_BUFFER_STATUS_REG);
-                        buffstatus |= ATL_BUFFER;
-                        isp1760_writel(buffstatus, usb_hcd->regs +
-                                        HC_BUFFER_STATUS_REG);
-                        continue;
-                }
+                if (list_is_last(&qtd->qtd_list, &qh->qtd_list))
+                        last_qtd = 1;
+                else
+                        last_qtd = qtd->urb != qtd_next->urb;
+
+                if ((!last_qtd) && (qtd->status == QTD_RETIRE))
+                        qtd_next->status = QTD_RETIRE;
+
+                if (qtd->status == QTD_XFER_COMPLETE) {
+                        if (qtd->actual_length) {
+                                switch (qtd->packet_type) {
+                                case IN_PID:
+                                        mem_reads8(hcd->regs, qtd->payload_addr,
+                                                        qtd->data_buffer,
+                                                        qtd->actual_length);
+                                        /* Fall through (?) */
+                                case OUT_PID:
+                                        qtd->urb->actual_length +=
+                                                        qtd->actual_length;
+                                        /* Fall through ... */
+                                case SETUP_PID:
+                                        break;
+                                }
+                        }
 
-                error = check_error(&ptd);
-                if (error) {
-                        status = error;
-                        priv->atl_ints[queue_entry].qh->toggle = 0;
-                        priv->atl_ints[queue_entry].qh->ping = 0;
-                        urb->status = -EPIPE;
-
-#if 0
-                        printk(KERN_ERR "Error in %s().\n", __func__);
-                        printk(KERN_ERR "IN dw0: %08x dw1: %08x dw2: %08x "
-                                        "dw3: %08x dw4: %08x dw5: %08x dw6: "
-                                        "%08x dw7: %08x\n",
-                                        ptd.dw0, ptd.dw1, ptd.dw2, ptd.dw3,
-                                        ptd.dw4, ptd.dw5, ptd.dw6, ptd.dw7);
-#endif
-                } else {
-                        if (usb_pipetype(urb->pipe) == PIPE_BULK) {
-                                priv->atl_ints[queue_entry].qh->toggle = dw3 &
-                                        (1 << 25);
-                                priv->atl_ints[queue_entry].qh->ping = dw3 &
-                                        (1 << 26);
+                        if (is_short_bulk(qtd)) {
+                                if (qtd->urb->transfer_flags & URB_SHORT_NOT_OK)
+                                        qtd->urb->status = -EREMOTEIO;
+                                if (!last_qtd)
+                                        qtd_next->status = QTD_RETIRE;
                         }
                 }
 
-                length = PTD_XFERRED_LENGTH(dw3);
-                if (length) {
-                        switch (DW1_GET_PID(dw1)) {
-                        case IN_PID:
-                                priv_read_copy(priv,
-                                        priv->atl_ints[queue_entry].data_buffer,
-                                        usb_hcd->regs + payload + ISP_BANK(1),
-                                        length);
-
-                        case OUT_PID:
-
-                                urb->actual_length += length;
-
-                        case SETUP_PID:
+                if (qtd->payload_addr)
+                        free_mem(hcd, qtd);
+
+                if (last_qtd) {
+                        if ((qtd->status == QTD_RETIRE) &&
+                                        (qtd->urb->status == -EINPROGRESS))
+                                qtd->urb->status = -EPIPE;
+                        /* Defer calling of urb_done() since it releases lock */
+                        urb_listitem = kmem_cache_zalloc(urb_listitem_cachep,
+                                                                GFP_ATOMIC);
+                        if (unlikely(!urb_listitem))
                                 break;
-                        }
+                        urb_listitem->urb = qtd->urb;
+                        list_add_tail(&urb_listitem->urb_list, urb_list);
                 }
 
-                priv->atl_ints[queue_entry].data_buffer = NULL;
-                priv->atl_ints[queue_entry].urb = NULL;
-                priv->atl_ints[queue_entry].qtd = NULL;
-                priv->atl_ints[queue_entry].qh = NULL;
+                list_del(&qtd->qtd_list);
+                qtd_free(qtd);
+        }
+}
 
-                free_mem(priv, payload);
+#define ENQUEUE_DEPTH   2
+static void enqueue_qtds(struct usb_hcd *hcd, struct isp1760_qh *qh)
+{
+        struct isp1760_hcd *priv = hcd_to_priv(hcd);
+        int ptd_offset;
+        struct slotinfo *slots;
+        int curr_slot, free_slot;
+        int n;
+        struct ptd ptd;
+        struct isp1760_qtd *qtd;
 
-                isp1760_writel(skip_map, usb_hcd->regs +
-                                HC_ATL_PTD_SKIPMAP_REG);
+        if (unlikely(list_empty(&qh->qtd_list))) {
+                WARN_ON(1);
+                return;
+        }
 
-                if (urb->status == -EPIPE) {
-                        /* HALT was received */
+        if (usb_pipeint(list_entry(qh->qtd_list.next, struct isp1760_qtd,
+                                                        qtd_list)->urb->pipe)) {
+                ptd_offset = INT_PTD_OFFSET;
+                slots = priv->int_slots;
+        } else {
+                ptd_offset = ATL_PTD_OFFSET;
+                slots = priv->atl_slots;
+        }
 
-                        qtd = clean_up_qtdlist(qtd);
-                        isp1760_urb_done(priv, urb, urb->status);
+        free_slot = -1;
+        for (curr_slot = 0; curr_slot < 32; curr_slot++) {
+                if ((free_slot == -1) && (slots[curr_slot].qtd == NULL))
+                        free_slot = curr_slot;
+                if (slots[curr_slot].qh == qh)
+                        break;
+        }
 
-                } else if (usb_pipebulk(urb->pipe) && (length < qtd->length)) {
-                        /* short BULK received */
+        n = 0;
+        list_for_each_entry(qtd, &qh->qtd_list, qtd_list) {
+                if (qtd->status == QTD_ENQUEUED) {
+                        WARN_ON(qtd->payload_addr);
+                        alloc_mem(hcd, qtd);
+                        if ((qtd->length) && (!qtd->payload_addr))
+                                break;
 
-                        if (urb->transfer_flags & URB_SHORT_NOT_OK) {
-                                urb->status = -EREMOTEIO;
-                                isp1760_dbg(priv, "short bulk, %d instead %zu "
-                                        "with URB_SHORT_NOT_OK flag.\n",
-                                        length, qtd->length);
+                        if ((qtd->length) &&
+                            ((qtd->packet_type == SETUP_PID) ||
+                             (qtd->packet_type == OUT_PID))) {
+                                mem_writes8(hcd->regs, qtd->payload_addr,
+                                                qtd->data_buffer, qtd->length);
                         }
 
-                        if (urb->status == -EINPROGRESS)
-                                urb->status = 0;
-
-                        qtd = clean_up_qtdlist(qtd);
-
-                        isp1760_urb_done(priv, urb, urb->status);
-
-                } else if (qtd->status & URB_COMPLETE_NOTIFY) {
-                        /* that was the last qtd of that URB */
-
-                        if (urb->status == -EINPROGRESS)
-                                urb->status = 0;
-
-                        qtd = clean_this_qtd(qtd);
-                        isp1760_urb_done(priv, urb, urb->status);
-
-                } else {
-                        /* next QTD of this URB */
-
-                        qtd = clean_this_qtd(qtd);
-                        BUG_ON(!qtd);
+                        qtd->status = QTD_PAYLOAD_ALLOC;
                 }
 
-                if (qtd)
-                        enqueue_an_ATL_packet(usb_hcd, qh, qtd);
+                if (qtd->status == QTD_PAYLOAD_ALLOC) {
+/*
+                        if ((curr_slot > 31) && (free_slot == -1))
+                                dev_dbg(hcd->self.controller, "%s: No slot "
+                                        "available for transfer\n", __func__);
+*/
+                        /* Start xfer for this endpoint if not already done */
+                        if ((curr_slot > 31) && (free_slot > -1)) {
+                                if (usb_pipeint(qtd->urb->pipe))
+                                        create_ptd_int(qh, qtd, &ptd);
+                                else
+                                        create_ptd_atl(qh, qtd, &ptd);
+
+                                start_bus_transfer(hcd, ptd_offset, free_slot,
+                                                        slots, qtd, qh, &ptd);
+                                curr_slot = free_slot;
+                        }
 
-                skip_map = isp1760_readl(usb_hcd->regs +
-                                HC_ATL_PTD_SKIPMAP_REG);
+                        n++;
+                        if (n >= ENQUEUE_DEPTH)
+                                break;
+                }
         }
 }
 
-static void do_intl_int(struct usb_hcd *usb_hcd)
+void schedule_ptds(struct usb_hcd *hcd)
 {
-        struct isp1760_hcd *priv = hcd_to_priv(usb_hcd);
-        u32 done_map, skip_map;
-        struct ptd ptd;
-        struct urb *urb = NULL;
-        u32 int_regs;
-        u32 int_regs_base;
-        u32 payload;
-        u32 length;
-        u32 or_map;
-        int error;
-        u32 queue_entry;
-        struct isp1760_qtd *qtd;
-        struct isp1760_qh *qh;
-
-        done_map = isp1760_readl(usb_hcd->regs +
-                        HC_INT_PTD_DONEMAP_REG);
-        skip_map = isp1760_readl(usb_hcd->regs +
-                        HC_INT_PTD_SKIPMAP_REG);
+        struct isp1760_hcd *priv;
+        struct isp1760_qh *qh, *qh_next;
+        struct list_head *ep_queue;
+        struct usb_host_endpoint *ep;
+        LIST_HEAD(urb_list);
+        struct urb_listitem *urb_listitem, *urb_listitem_next;
+
+        if (!hcd) {
+                WARN_ON(1);
+                return;
+        }
 
-        or_map = isp1760_readl(usb_hcd->regs + HC_INT_IRQ_MASK_OR_REG);
-        or_map &= ~done_map;
-        isp1760_writel(or_map, usb_hcd->regs + HC_INT_IRQ_MASK_OR_REG);
+        priv = hcd_to_priv(hcd);
 
-        int_regs_base = INT_REGS_OFFSET;
+        /*
+         * check finished/retired xfers, transfer payloads, call urb_done()
+         */
+        ep_queue = &priv->interruptqhs;
+        while (ep_queue) {
+                list_for_each_entry_safe(qh, qh_next, ep_queue, qh_list) {
+                        ep = list_entry(qh->qtd_list.next, struct isp1760_qtd,
+                                                        qtd_list)->urb->ep;
+                        collect_qtds(hcd, qh, &urb_list);
+                        if (list_empty(&qh->qtd_list)) {
+                                list_del(&qh->qh_list);
+                                if (ep->hcpriv == NULL) {
+                                        /* Endpoint has been disabled, so we
+                                        can free the associated queue head. */
+                                        qh_free(qh);
+                                }
+                        }
+                }
 
-        while (done_map) {
-                u32 dw1;
-                u32 dw3;
+                if (ep_queue == &priv->interruptqhs)
+                        ep_queue = &priv->controlqhs;
+                else if (ep_queue == &priv->controlqhs)
+                        ep_queue = &priv->bulkqhs;
+                else
+                        ep_queue = NULL;
+        }
 
-                queue_entry = __ffs(done_map);
-                done_map &= ~(1 << queue_entry);
-                skip_map |= 1 << queue_entry;
+        list_for_each_entry_safe(urb_listitem, urb_listitem_next, &urb_list,
+                                                                urb_list) {
+                isp1760_urb_done(hcd, urb_listitem->urb);
+                kmem_cache_free(urb_listitem_cachep, urb_listitem);
+        }
 
-                int_regs = int_regs_base + queue_entry * sizeof(struct ptd);
-                urb = priv->int_ints[queue_entry].urb;
-                qtd = priv->int_ints[queue_entry].qtd;
-                qh = priv->int_ints[queue_entry].qh;
-                payload = priv->int_ints[queue_entry].payload;
+        /*
+         * Schedule packets for transfer.
+         *
+         * According to USB2.0 specification:
+         *
+         * 1st prio: interrupt xfers, up to 80 % of bandwidth
+         * 2nd prio: control xfers
+         * 3rd prio: bulk xfers
+         *
+         * ... but let's use a simpler scheme here (mostly because ISP1761 doc
+         * is very unclear on how to prioritize traffic):
+         *
+         * 1) Enqueue any queued control transfers, as long as payload chip mem
+         *    and PTD ATL slots are available.
+         * 2) Enqueue any queued INT transfers, as long as payload chip mem
+         *    and PTD INT slots are available.
+         * 3) Enqueue any queued bulk transfers, as long as payload chip mem
+         *    and PTD ATL slots are available.
+         *
+         * Use double buffering (ENQUEUE_DEPTH==2) as a compromise between
+         * conservation of chip mem and performance.
+         *
+         * I'm sure this scheme could be improved upon!
+         */
+        ep_queue = &priv->controlqhs;
+        while (ep_queue) {
+                list_for_each_entry_safe(qh, qh_next, ep_queue, qh_list)
+                        enqueue_qtds(hcd, qh);
+
+                if (ep_queue == &priv->controlqhs)
+                        ep_queue = &priv->interruptqhs;
+                else if (ep_queue == &priv->interruptqhs)
+                        ep_queue = &priv->bulkqhs;
+                else
+                        ep_queue = NULL;
+        }
+}
 
-                if (!qh) {
-                        printk(KERN_ERR "(INT) qh is 0\n");
-                        continue;
-                }
+#define PTD_STATE_QTD_DONE      1
+#define PTD_STATE_QTD_RELOAD    2
+#define PTD_STATE_URB_RETIRE    3
 
-                isp1760_writel(int_regs + ISP_BANK(0), usb_hcd->regs +
-                                HC_MEMORY_REG);
-                isp1760_writel(payload  + ISP_BANK(1), usb_hcd->regs +
-                                HC_MEMORY_REG);
-                /*
-                 * write bank1 address twice to ensure the 90ns delay (time
-                 * between BANK0 write and the priv_read_copy() call is at
-                 * least 3*t_WHWL + 2*t_w11 = 3*25ns + 2*17ns = 92ns)
-                 */
-                isp1760_writel(payload  + ISP_BANK(1), usb_hcd->regs +
-                                HC_MEMORY_REG);
-
-                priv_read_copy(priv, (u32 *)&ptd, usb_hcd->regs + int_regs +
-                                ISP_BANK(0), sizeof(ptd));
-                dw1 = le32_to_cpu(ptd.dw1);
-                dw3 = le32_to_cpu(ptd.dw3);
-                check_int_err_status(le32_to_cpu(ptd.dw4));
-
-                error = check_error(&ptd);
-                if (error) {
-#if 0
-                        printk(KERN_ERR "Error in %s().\n", __func__);
-                        printk(KERN_ERR "IN dw0: %08x dw1: %08x dw2: %08x "
-                                        "dw3: %08x dw4: %08x dw5: %08x dw6: "
-                                        "%08x dw7: %08x\n",
-                                        ptd.dw0, ptd.dw1, ptd.dw2, ptd.dw3,
-                                        ptd.dw4, ptd.dw5, ptd.dw6, ptd.dw7);
-#endif
-                        urb->status = -EPIPE;
-                        priv->int_ints[queue_entry].qh->toggle = 0;
-                        priv->int_ints[queue_entry].qh->ping = 0;
+static int check_int_transfer(struct usb_hcd *hcd, struct ptd *ptd,
+                                                                struct urb *urb)
+{
+        __dw dw4;
+        int i;
 
-                } else {
-                        priv->int_ints[queue_entry].qh->toggle =
-                                dw3 & (1 << 25);
-                        priv->int_ints[queue_entry].qh->ping = dw3 & (1 << 26);
-                }
+        dw4 = ptd->dw4;
+        dw4 >>= 8;
 
-                if (urb->dev->speed != USB_SPEED_HIGH)
-                        length = PTD_XFERRED_LENGTH_LO(dw3);
-                else
-                        length = PTD_XFERRED_LENGTH(dw3);
+        /* FIXME: ISP1761 datasheet does not say what to do with these. Do we
+           need to handle these errors? Is it done in hardware? */
 
-                if (length) {
-                        switch (DW1_GET_PID(dw1)) {
-                        case IN_PID:
-                                priv_read_copy(priv,
-                                        priv->int_ints[queue_entry].data_buffer,
-                                        usb_hcd->regs + payload + ISP_BANK(1),
-                                        length);
-                        case OUT_PID:
+        if (ptd->dw3 & DW3_HALT_BIT) {
 
-                                urb->actual_length += length;
+                urb->status = -EPROTO; /* Default unknown error */
 
-                        case SETUP_PID:
+                for (i = 0; i < 8; i++) {
+                        switch (dw4 & 0x7) {
+                        case INT_UNDERRUN:
+                                dev_dbg(hcd->self.controller, "%s: underrun "
+                                                "during uFrame %d\n",
+                                                __func__, i);
+                                urb->status = -ECOMM; /* Could not write data */
+                                break;
+                        case INT_EXACT:
+                                dev_dbg(hcd->self.controller, "%s: transaction "
+                                                "error during uFrame %d\n",
+                                                __func__, i);
+                                urb->status = -EPROTO; /* timeout, bad CRC, PID
+                                                          error etc. */
+                                break;
+                        case INT_BABBLE:
+                                dev_dbg(hcd->self.controller, "%s: babble "
+                                                "error during uFrame %d\n",
+                                                __func__, i);
+                                urb->status = -EOVERFLOW;
                                 break;
                         }
+                        dw4 >>= 3;
                 }
 
-                priv->int_ints[queue_entry].data_buffer = NULL;
-                priv->int_ints[queue_entry].urb = NULL;
-                priv->int_ints[queue_entry].qtd = NULL;
-                priv->int_ints[queue_entry].qh = NULL;
-
-                isp1760_writel(skip_map, usb_hcd->regs +
-                                HC_INT_PTD_SKIPMAP_REG);
-                free_mem(priv, payload);
-
-                if (urb->status == -EPIPE) {
-                        /* HALT received */
-
-                         qtd = clean_up_qtdlist(qtd);
-                         isp1760_urb_done(priv, urb, urb->status);
-
-                } else if (qtd->status & URB_COMPLETE_NOTIFY) {
-
-                        if (urb->status == -EINPROGRESS)
-                                urb->status = 0;
-
-                        qtd = clean_this_qtd(qtd);
-                        isp1760_urb_done(priv, urb, urb->status);
+                return PTD_STATE_URB_RETIRE;
+        }
 
-                } else {
-                        /* next QTD of this URB */
+        return PTD_STATE_QTD_DONE;
+}
 
-                        qtd = clean_this_qtd(qtd);
-                        BUG_ON(!qtd);
-                }
+static int check_atl_transfer(struct usb_hcd *hcd, struct ptd *ptd,
+                                                                struct urb *urb)
+{
+        WARN_ON(!ptd);
+        if (ptd->dw3 & DW3_HALT_BIT) {
+                if (ptd->dw3 & DW3_BABBLE_BIT)
+                        urb->status = -EOVERFLOW;
+                else if (FROM_DW3_CERR(ptd->dw3))
+                        urb->status = -EPIPE;  /* Stall */
+                else if (ptd->dw3 & DW3_ERROR_BIT)
+                        urb->status = -EPROTO; /* XactErr */
+                else
+                        urb->status = -EPROTO; /* Unknown */
+/*
+                dev_dbg(hcd->self.controller, "%s: ptd error:\n"
+                        "        dw0: %08x dw1: %08x dw2: %08x dw3: %08x\n"
+                        "        dw4: %08x dw5: %08x dw6: %08x dw7: %08x\n",
+                        __func__,
+                        ptd->dw0, ptd->dw1, ptd->dw2, ptd->dw3,
+                        ptd->dw4, ptd->dw5, ptd->dw6, ptd->dw7);
+*/
+                return PTD_STATE_URB_RETIRE;
+        }
 
-                if (qtd)
-                        enqueue_an_INT_packet(usb_hcd, qh, qtd);
+        if ((ptd->dw3 & DW3_ERROR_BIT) && (ptd->dw3 & DW3_ACTIVE_BIT)) {
+                /* Transfer Error, *but* active and no HALT -> reload */
+                dev_dbg(hcd->self.controller, "PID error; reloading ptd\n");
+                return PTD_STATE_QTD_RELOAD;
+        }
 
-                skip_map = isp1760_readl(usb_hcd->regs +
-                                HC_INT_PTD_SKIPMAP_REG);
+        if (!FROM_DW3_NAKCOUNT(ptd->dw3) && (ptd->dw3 & DW3_ACTIVE_BIT)) {
+                /*
+                 * NAKs are handled in HW by the chip. Usually if the
+                 * device is not able to send data fast enough.
+                 * This happens mostly on slower hardware.
+                 */
+                return PTD_STATE_QTD_RELOAD;
         }
+
+        return PTD_STATE_QTD_DONE;
 }
 
-#define max_packet(wMaxPacketSize) ((wMaxPacketSize) & 0x07ff)
-static struct isp1760_qh *qh_make(struct isp1760_hcd *priv, struct urb *urb,
-                gfp_t flags)
+static irqreturn_t isp1760_irq(struct usb_hcd *hcd)
 {
+        struct isp1760_hcd *priv = hcd_to_priv(hcd);
+        u32 imask;
+        irqreturn_t irqret = IRQ_NONE;
+        struct ptd ptd;
         struct isp1760_qh *qh;
-        int is_input, type;
-
-        qh = isp1760_qh_alloc(priv, flags);
-        if (!qh)
-                return qh;
-
-        /*
-         * init endpoint/device data for this QH
-         */
-        is_input = usb_pipein(urb->pipe);
-        type = usb_pipetype(urb->pipe);
+        int slot;
+        int state;
+        struct slotinfo *slots;
+        u32 ptd_offset;
+        struct isp1760_qtd *qtd;
+        int modified;
+        static int last_active_ptds;
+        int int_skip_map, atl_skip_map;
 
-        if (type == PIPE_INTERRUPT) {
+        spin_lock(&priv->lock);
 
-                if (urb->dev->speed == USB_SPEED_HIGH) {
+        if (!(hcd->state & HC_STATE_RUNNING))
+                goto leave;
 
-                        qh->period = urb->interval >> 3;
-                        if (qh->period == 0 && urb->interval != 1) {
-                                /* NOTE interval 2 or 4 uframes could work.
-                                 * But interval 1 scheduling is simpler, and
-                                 * includes high bandwidth.
-                                 */
-                                printk(KERN_ERR "intr period %d uframes, NYET!",
-                                                urb->interval);
-                                qh_destroy(qh);
-                                return NULL;
+        imask = reg_read32(hcd->regs, HC_INTERRUPT_REG);
+        if (unlikely(!imask))
+                goto leave;
+        reg_write32(hcd->regs, HC_INTERRUPT_REG, imask); /* Clear */
+
+        int_skip_map = reg_read32(hcd->regs, HC_INT_PTD_SKIPMAP_REG);
+        atl_skip_map = reg_read32(hcd->regs, HC_ATL_PTD_SKIPMAP_REG);
+        priv->int_done_map |= reg_read32(hcd->regs, HC_INT_PTD_DONEMAP_REG);
+        priv->atl_done_map |= reg_read32(hcd->regs, HC_ATL_PTD_DONEMAP_REG);
+        priv->int_done_map &= ~int_skip_map;
+        priv->atl_done_map &= ~atl_skip_map;
+
+        modified = priv->int_done_map | priv->atl_done_map;
+
+        while (priv->int_done_map || priv->atl_done_map) {
+                if (priv->int_done_map) {
+                        /* INT ptd */
+                        slot = __ffs(priv->int_done_map);
+                        priv->int_done_map &= ~(1 << slot);
+                        slots = priv->int_slots;
+                        /* This should not trigger, and could be removed if
+                           noone have any problems with it triggering: */
+                        if (!slots[slot].qh) {
+                                WARN_ON(1);
+                                continue;
                         }
+                        ptd_offset = INT_PTD_OFFSET;
+                        ptd_read(hcd->regs, INT_PTD_OFFSET, slot, &ptd);
+                        state = check_int_transfer(hcd, &ptd,
+                                                        slots[slot].qtd->urb);
                 } else {
-                        qh->period = urb->interval;
+                        /* ATL ptd */
+                        slot = __ffs(priv->atl_done_map);
+                        priv->atl_done_map &= ~(1 << slot);
+                        slots = priv->atl_slots;
+                        /* This should not trigger, and could be removed if
+                           noone have any problems with it triggering: */
+                        if (!slots[slot].qh) {
+                                WARN_ON(1);
+                                continue;
+                        }
+                        ptd_offset = ATL_PTD_OFFSET;
+                        ptd_read(hcd->regs, ATL_PTD_OFFSET, slot, &ptd);
+                        state = check_atl_transfer(hcd, &ptd,
+                                                        slots[slot].qtd->urb);
                 }
-        }
 
-        /* support for tt scheduling, and access to toggles */
-        qh->dev = urb->dev;
+                qtd = slots[slot].qtd;
+                slots[slot].qtd = NULL;
+                qh = slots[slot].qh;
+                slots[slot].qh = NULL;
+                priv->active_ptds--;
+                qh->slot = -1;
+
+                WARN_ON(qtd->status != QTD_XFER_STARTED);
+
+                switch (state) {
+                case PTD_STATE_QTD_DONE:
+                        if ((usb_pipeint(qtd->urb->pipe)) &&
+                                       (qtd->urb->dev->speed != USB_SPEED_HIGH))
+                                qtd->actual_length =
+                                       FROM_DW3_SCS_NRBYTESTRANSFERRED(ptd.dw3);
+                        else
+                                qtd->actual_length =
+                                        FROM_DW3_NRBYTESTRANSFERRED(ptd.dw3);
+
+                        qtd->status = QTD_XFER_COMPLETE;
+                        if (list_is_last(&qtd->qtd_list, &qh->qtd_list) ||
+                                                        is_short_bulk(qtd))
+                                qtd = NULL;
+                        else
+                                qtd = list_entry(qtd->qtd_list.next,
+                                                        typeof(*qtd), qtd_list);
+
+                        qh->toggle = FROM_DW3_DATA_TOGGLE(ptd.dw3);
+                        qh->ping = FROM_DW3_PING(ptd.dw3);
+                        break;
 
-        if (!usb_pipecontrol(urb->pipe))
-                usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe), !is_input,
-                                1);
-        return qh;
-}
+                case PTD_STATE_QTD_RELOAD: /* QTD_RETRY, for atls only */
+                        qtd->status = QTD_PAYLOAD_ALLOC;
+                        ptd.dw0 |= DW0_VALID_BIT;
+                        /* RL counter = ERR counter */
+                        ptd.dw3 &= ~TO_DW3_NAKCOUNT(0xf);
+                        ptd.dw3 |= TO_DW3_NAKCOUNT(FROM_DW2_RL(ptd.dw2));
+                        ptd.dw3 &= ~TO_DW3_CERR(3);
+                        ptd.dw3 |= TO_DW3_CERR(ERR_COUNTER);
+                        qh->toggle = FROM_DW3_DATA_TOGGLE(ptd.dw3);
+                        qh->ping = FROM_DW3_PING(ptd.dw3);
+                        break;
 
-/*
- * For control/bulk/interrupt, return QH with these TDs appended.
- * Allocates and initializes the QH if necessary.
- * Returns null if it can't allocate a QH it needs to.
- * If the QH has TDs (urbs) already, that's great.
- */
-static struct isp1760_qh *qh_append_tds(struct isp1760_hcd *priv,
-                struct urb *urb, struct list_head *qtd_list, int epnum,
-                void **ptr)
-{
-        struct isp1760_qh *qh;
-        struct isp1760_qtd *qtd;
-        struct isp1760_qtd *prev_qtd;
+                case PTD_STATE_URB_RETIRE:
+                        qtd->status = QTD_RETIRE;
+                        qtd = NULL;
+                        qh->toggle = 0;
+                        qh->ping = 0;
+                        break;
 
-        qh = (struct isp1760_qh *)*ptr;
-        if (!qh) {
-                /* can't sleep here, we have priv->lock... */
-                qh = qh_make(priv, urb, GFP_ATOMIC);
-                if (!qh)
-                        return qh;
-                *ptr = qh;
-        }
+                default:
+                        WARN_ON(1);
+                        continue;
+                }
 
-        qtd = list_entry(qtd_list->next, struct isp1760_qtd,
-                        qtd_list);
-        if (!list_empty(&qh->qtd_list))
-                prev_qtd = list_entry(qh->qtd_list.prev,
-                                struct isp1760_qtd, qtd_list);
-        else
-                prev_qtd = NULL;
+                if (qtd && (qtd->status == QTD_PAYLOAD_ALLOC)) {
+                        if (slots == priv->int_slots) {
+                                if (state == PTD_STATE_QTD_RELOAD)
+                                        dev_err(hcd->self.controller,
+                                                "%s: PTD_STATE_QTD_RELOAD on "
+                                                "interrupt packet\n", __func__);
+                                if (state != PTD_STATE_QTD_RELOAD)
+                                        create_ptd_int(qh, qtd, &ptd);
+                        } else {
+                                if (state != PTD_STATE_QTD_RELOAD)
+                                        create_ptd_atl(qh, qtd, &ptd);
+                        }
 
-        list_splice(qtd_list, qh->qtd_list.prev);
-        if (prev_qtd) {
-                BUG_ON(prev_qtd->hw_next);
-                prev_qtd->hw_next = qtd;
+                        start_bus_transfer(hcd, ptd_offset, slot, slots, qtd,
+                                qh, &ptd);
+                }
         }
 
-        urb->hcpriv = qh;
-        return qh;
-}
-
-static void qtd_list_free(struct isp1760_hcd *priv, struct urb *urb,
-                struct list_head *qtd_list)
-{
-        struct list_head *entry, *temp;
+        if (modified)
+                schedule_ptds(hcd);
 
-        list_for_each_safe(entry, temp, qtd_list) {
-                struct isp1760_qtd      *qtd;
+        /* ISP1760 Errata 2 explains that interrupts may be missed (or not
+           happen?) if two USB devices are running simultaneously. Perhaps
+           this happens when a PTD is finished during interrupt handling;
+           enable SOF interrupts if PTDs are still scheduled when exiting this
+           interrupt handler, just to be safe. */
 
-                qtd = list_entry(entry, struct isp1760_qtd, qtd_list);
-                list_del(&qtd->qtd_list);
-                isp1760_qtd_free(qtd);
+        if (priv->active_ptds != last_active_ptds) {
+                if (priv->active_ptds > 0)
+                        reg_write32(hcd->regs, HC_INTERRUPT_ENABLE,
+                                                INTERRUPT_ENABLE_SOT_MASK);
+                else
+                        reg_write32(hcd->regs, HC_INTERRUPT_ENABLE,
+                                                INTERRUPT_ENABLE_MASK);
+                last_active_ptds = priv->active_ptds;
         }
-}
-
-static int isp1760_prepare_enqueue(struct isp1760_hcd *priv, struct urb *urb,
-                struct list_head *qtd_list, gfp_t mem_flags, packet_enqueue *p)
-{
-        struct isp1760_qtd         *qtd;
-        int                     epnum;
-        unsigned long           flags;
-        struct isp1760_qh          *qh = NULL;
-        int                     rc;
-        int qh_busy;
-
-        qtd = list_entry(qtd_list->next, struct isp1760_qtd, qtd_list);
-        epnum = urb->ep->desc.bEndpointAddress;
 
-        spin_lock_irqsave(&priv->lock, flags);
-        if (!HCD_HW_ACCESSIBLE(priv_to_hcd(priv))) {
-                rc = -ESHUTDOWN;
-                goto done;
-        }
-        rc = usb_hcd_link_urb_to_ep(priv_to_hcd(priv), urb);
-        if (rc)
-                goto done;
+        irqret = IRQ_HANDLED;
+leave:
+        spin_unlock(&priv->lock);
 
-        qh = urb->ep->hcpriv;
-        if (qh)
-                qh_busy = !list_empty(&qh->qtd_list);
-        else
-                qh_busy = 0;
+        return irqret;
+}
 
-        qh = qh_append_tds(priv, urb, qtd_list, epnum, &urb->ep->hcpriv);
-        if (!qh) {
-                usb_hcd_unlink_urb_from_ep(priv_to_hcd(priv), urb);
-                rc = -ENOMEM;
-                goto done;
-        }
+static int qtd_fill(struct isp1760_qtd *qtd, void *databuffer, size_t len)
+{
+        qtd->data_buffer = databuffer;
 
-        if (!qh_busy)
-                p(priv_to_hcd(priv), qh, qtd);
+        if (len > MAX_PAYLOAD_SIZE)
+                len = MAX_PAYLOAD_SIZE;
+        qtd->length = len;
 
-done:
-        spin_unlock_irqrestore(&priv->lock, flags);
-        if (!qh)
-                qtd_list_free(priv, urb, qtd_list);
-        return rc;
+        return qtd->length;
 }
 
-static struct isp1760_qtd *isp1760_qtd_alloc(struct isp1760_hcd *priv,
-                gfp_t flags)
+static void qtd_list_free(struct list_head *qtd_list)
 {
-        struct isp1760_qtd *qtd;
+        struct isp1760_qtd *qtd, *qtd_next;
 
-        qtd = kmem_cache_zalloc(qtd_cachep, flags);
-        if (qtd)
-                INIT_LIST_HEAD(&qtd->qtd_list);
-
-        return qtd;
+        list_for_each_entry_safe(qtd, qtd_next, qtd_list, qtd_list) {
+                list_del(&qtd->qtd_list);
+                qtd_free(qtd);
+        }
 }
 
 /*
- * create a list of filled qtds for this URB; won't link into qh.
+ * Packetize urb->transfer_buffer into list of packets of size wMaxPacketSize.
+ * Also calculate the PID type (SETUP/IN/OUT) for each packet.
  */
-static struct list_head *qh_urb_transaction(struct isp1760_hcd *priv,
+#define max_packet(wMaxPacketSize) ((wMaxPacketSize) & 0x07ff)
+static void packetize_urb(struct usb_hcd *hcd,
                 struct urb *urb, struct list_head *head, gfp_t flags)
 {
-        struct isp1760_qtd *qtd, *qtd_prev;
+        struct isp1760_qtd *qtd;
         void *buf;
-        int len, maxpacket;
-        int is_input;
-        u32 token;
+        int len, maxpacketsize;
+        u8 packet_type;
 
         /*
          * URBs map to sequences of QTDs:  one logical transaction
          */
-        qtd = isp1760_qtd_alloc(priv, flags);
-        if (!qtd)
-                return NULL;
 
-        list_add_tail(&qtd->qtd_list, head);
-        qtd->urb = urb;
-        urb->status = -EINPROGRESS;
+        if (!urb->transfer_buffer && urb->transfer_buffer_length) {
+                /* XXX This looks like usb storage / SCSI bug */
+                dev_err(hcd->self.controller,
+                                "buf is null, dma is %08lx len is %d\n",
+                                (long unsigned)urb->transfer_dma,
+                                urb->transfer_buffer_length);
+                WARN_ON(1);
+        }
 
-        token = 0;
-        /* for split transactions, SplitXState initialized to zero */
+        if (usb_pipein(urb->pipe))
+                packet_type = IN_PID;
+        else
+                packet_type = OUT_PID;
 
-        len = urb->transfer_buffer_length;
-        is_input = usb_pipein(urb->pipe);
         if (usb_pipecontrol(urb->pipe)) {
-                /* SETUP pid */
-                qtd_fill(qtd, urb->setup_packet,
-                                sizeof(struct usb_ctrlrequest),
-                                token | SETUP_PID);
-
-                /* ... and always at least one more pid */
-                token ^= DATA_TOGGLE;
-                qtd_prev = qtd;
-                qtd = isp1760_qtd_alloc(priv, flags);
+                qtd = qtd_alloc(flags, urb, SETUP_PID);
                 if (!qtd)
                         goto cleanup;
-                qtd->urb = urb;
-                qtd_prev->hw_next = qtd;
+                qtd_fill(qtd, urb->setup_packet, sizeof(struct usb_ctrlrequest));
                 list_add_tail(&qtd->qtd_list, head);
 
                 /* for zero length DATA stages, STATUS is always IN */
-                if (len == 0)
-                        token |= IN_PID;
+                if (urb->transfer_buffer_length == 0)
+                        packet_type = IN_PID;
         }
 
-        /*
-         * data transfer stage:  buffer setup
-         */
-        buf = urb->transfer_buffer;
-
-        if (is_input)
-                token |= IN_PID;
-        else
-                token |= OUT_PID;
-
-        maxpacket = max_packet(usb_maxpacket(urb->dev, urb->pipe, !is_input));
+        maxpacketsize = max_packet(usb_maxpacket(urb->dev, urb->pipe,
+                                                usb_pipeout(urb->pipe)));
 
         /*
          * buffer gets wrapped in one or more qtds;
          * last one may be "short" (including zero len)
          * and may serve as a control status ack
          */
+        buf = urb->transfer_buffer;
+        len = urb->transfer_buffer_length;
+
         for (;;) {
                 int this_qtd_len;
 
-                if (!buf && len) {
-                        /* XXX This looks like usb storage / SCSI bug */
-                        printk(KERN_ERR "buf is null, dma is %08lx len is %d\n",
-                                        (long unsigned)urb->transfer_dma, len);
-                        WARN_ON(1);
-                }
+                qtd = qtd_alloc(flags, urb, packet_type);
+                if (!qtd)
+                        goto cleanup;
+                this_qtd_len = qtd_fill(qtd, buf, len);
+                list_add_tail(&qtd->qtd_list, head);
 
-                this_qtd_len = qtd_fill(qtd, buf, len, token);
                 len -= this_qtd_len;
                 buf += this_qtd_len;
 
-                /* qh makes control packets use qtd toggle; maybe switch it */
-                if ((maxpacket & (this_qtd_len + (maxpacket - 1))) == 0)
-                        token ^= DATA_TOGGLE;
-
                 if (len <= 0)
                         break;
-
-                qtd_prev = qtd;
-                qtd = isp1760_qtd_alloc(priv, flags);
-                if (!qtd)
-                        goto cleanup;
-                qtd->urb = urb;
-                qtd_prev->hw_next = qtd;
-                list_add_tail(&qtd->qtd_list, head);
         }
 
         /*
@@ -1599,187 +1435,204 @@ static struct list_head *qh_urb_transaction(struct isp1760_hcd *priv,
 
                 if (usb_pipecontrol(urb->pipe)) {
                         one_more = 1;
-                        /* "in" <--> "out"  */
-                        token ^= IN_PID;
-                        /* force DATA1 */
-                        token |= DATA_TOGGLE;
+                        if (packet_type == IN_PID)
+                                packet_type = OUT_PID;
+                        else
+                                packet_type = IN_PID;
                 } else if (usb_pipebulk(urb->pipe)
                                 && (urb->transfer_flags & URB_ZERO_PACKET)
-                                && !(urb->transfer_buffer_length % maxpacket)) {
+                                && !(urb->transfer_buffer_length %
+                                                        maxpacketsize)) {
                         one_more = 1;
                 }
                 if (one_more) {
-                        qtd_prev = qtd;
-                        qtd = isp1760_qtd_alloc(priv, flags);
+                        qtd = qtd_alloc(flags, urb, packet_type);
                         if (!qtd)
                                 goto cleanup;
-                        qtd->urb = urb;
-                        qtd_prev->hw_next = qtd;
-                        list_add_tail(&qtd->qtd_list, head);
 
                         /* never any data in such packets */
-                        qtd_fill(qtd, NULL, 0, token);
+                        qtd_fill(qtd, NULL, 0);
+                        list_add_tail(&qtd->qtd_list, head);
                 }
         }
 
-        qtd->status = URB_COMPLETE_NOTIFY;
-        return head;
+        return;
 
 cleanup:
-        qtd_list_free(priv, urb, head);
-        return NULL;
+        qtd_list_free(head);
 }
 
 static int isp1760_urb_enqueue(struct usb_hcd *hcd, struct urb *urb,
                 gfp_t mem_flags)
 {
         struct isp1760_hcd *priv = hcd_to_priv(hcd);
-        struct list_head qtd_list;
-        packet_enqueue *pe;
-
-        INIT_LIST_HEAD(&qtd_list);
+        struct list_head *ep_queue;
+        struct isp1760_qh *qh, *qhit;
+        unsigned long spinflags;
+        LIST_HEAD(new_qtds);
+        int retval;
+        int qh_in_queue;
 
         switch (usb_pipetype(urb->pipe)) {
         case PIPE_CONTROL:
+                ep_queue = &priv->controlqhs;
+                break;
         case PIPE_BULK:
-
-                if (!qh_urb_transaction(priv, urb, &qtd_list, mem_flags))
-                        return -ENOMEM;
-                pe =  enqueue_an_ATL_packet;
+                ep_queue = &priv->bulkqhs;
                 break;
-
         case PIPE_INTERRUPT:
-                if (!qh_urb_transaction(priv, urb, &qtd_list, mem_flags))
-                        return -ENOMEM;
-                pe = enqueue_an_INT_packet;
+                if (urb->interval < 0)
+                        return -EINVAL;
+                /* FIXME: Check bandwidth  */
+                ep_queue = &priv->interruptqhs;
                 break;
-
         case PIPE_ISOCHRONOUS:
-                printk(KERN_ERR "PIPE_ISOCHRONOUS ain't supported\n");
+                dev_err(hcd->self.controller, "%s: isochronous USB packets "
+                                                        "not yet supported\n",
+                                                        __func__);
+                return -EPIPE;
         default:
+                dev_err(hcd->self.controller, "%s: unknown pipe type\n",
+                                                        __func__);
                 return -EPIPE;
         }
 
-        return isp1760_prepare_enqueue(priv, urb, &qtd_list, mem_flags, pe);
+        if (usb_pipein(urb->pipe))
+                urb->actual_length = 0;
+
+        packetize_urb(hcd, urb, &new_qtds, mem_flags);
+        if (list_empty(&new_qtds))
+                return -ENOMEM;
+        urb->hcpriv = NULL; /* Used to signal unlink to interrupt handler */
+
+        retval = 0;
+        spin_lock_irqsave(&priv->lock, spinflags);
+
+        if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)) {
+                retval = -ESHUTDOWN;
+                goto out;
+        }
+        retval = usb_hcd_link_urb_to_ep(hcd, urb);
+        if (retval)
+                goto out;
+
+        qh = urb->ep->hcpriv;
+        if (qh) {
+                qh_in_queue = 0;
+                list_for_each_entry(qhit, ep_queue, qh_list) {
+                        if (qhit == qh) {
+                                qh_in_queue = 1;
+                                break;
+                        }
+                }
+                if (!qh_in_queue)
+                        list_add_tail(&qh->qh_list, ep_queue);
+        } else {
+                qh = qh_alloc(GFP_ATOMIC);
+                if (!qh) {
+                        retval = -ENOMEM;
+                        goto out;
+                }
+                list_add_tail(&qh->qh_list, ep_queue);
+                urb->ep->hcpriv = qh;
+        }
+
+        list_splice_tail(&new_qtds, &qh->qtd_list);
+        schedule_ptds(hcd);
+
+out:
+        spin_unlock_irqrestore(&priv->lock, spinflags);
+        return retval;
+}
+
+static void kill_transfer(struct usb_hcd *hcd, struct urb *urb,
+                struct isp1760_qh *qh)
+{
+        struct isp1760_hcd *priv = hcd_to_priv(hcd);
+        int skip_map;
+
+        WARN_ON(qh->slot == -1);
+
+        /* We need to forcefully reclaim the slot since some transfers never
+           return, e.g. interrupt transfers and NAKed bulk transfers. */
+        if (usb_pipecontrol(urb->pipe) || usb_pipebulk(urb->pipe)) {
+                skip_map = reg_read32(hcd->regs, HC_ATL_PTD_SKIPMAP_REG);
+                skip_map |= (1 << qh->slot);
+                reg_write32(hcd->regs, HC_ATL_PTD_SKIPMAP_REG, skip_map);
+                priv->atl_slots[qh->slot].qh = NULL;
+                priv->atl_slots[qh->slot].qtd = NULL;
+        } else {
+                skip_map = reg_read32(hcd->regs, HC_INT_PTD_SKIPMAP_REG);
+                skip_map |= (1 << qh->slot);
+                reg_write32(hcd->regs, HC_INT_PTD_SKIPMAP_REG, skip_map);
+                priv->int_slots[qh->slot].qh = NULL;
+                priv->int_slots[qh->slot].qtd = NULL;
+        }
+
+        qh->slot = -1;
+        priv->active_ptds--;
 }
 
 static int isp1760_urb_dequeue(struct usb_hcd *hcd, struct urb *urb,
                 int status)
 {
         struct isp1760_hcd *priv = hcd_to_priv(hcd);
-        struct inter_packet_info *ints;
-        u32 i;
-        u32 reg_base, or_reg, skip_reg;
-        unsigned long flags;
-        struct ptd ptd;
-        packet_enqueue *pe;
-
-        switch (usb_pipetype(urb->pipe)) {
-        case PIPE_ISOCHRONOUS:
-                return -EPIPE;
-                break;
+        unsigned long spinflags;
+        struct isp1760_qh *qh;
+        struct isp1760_qtd *qtd;
+        int retval = 0;
 
-        case PIPE_INTERRUPT:
-                ints = priv->int_ints;
-                reg_base = INT_REGS_OFFSET;
-                or_reg = HC_INT_IRQ_MASK_OR_REG;
-                skip_reg = HC_INT_PTD_SKIPMAP_REG;
-                pe = enqueue_an_INT_packet;
-                break;
+        spin_lock_irqsave(&priv->lock, spinflags);
 
-        default:
-                ints = priv->atl_ints;
-                reg_base = ATL_REGS_OFFSET;
-                or_reg = HC_ATL_IRQ_MASK_OR_REG;
-                skip_reg = HC_ATL_PTD_SKIPMAP_REG;
-                pe =  enqueue_an_ATL_packet;
-                break;
+        qh = urb->ep->hcpriv;
+        if (!qh) {
+                retval = -EINVAL;
+                goto out;
         }
 
-        memset(&ptd, 0, sizeof(ptd));
-        spin_lock_irqsave(&priv->lock, flags);
-
-        for (i = 0; i < 32; i++) {
-                if (ints->urb == urb) {
-                        u32 skip_map;
-                        u32 or_map;
-                        struct isp1760_qtd *qtd;
-                        struct isp1760_qh *qh = ints->qh;
-
-                        skip_map = isp1760_readl(hcd->regs + skip_reg);
-                        skip_map |= 1 << i;
-                        isp1760_writel(skip_map, hcd->regs + skip_reg);
-
-                        or_map = isp1760_readl(hcd->regs + or_reg);
-                        or_map &= ~(1 << i);
-                        isp1760_writel(or_map, hcd->regs + or_reg);
-
-                        priv_write_copy(priv, (u32 *)&ptd, hcd->regs + reg_base
-                                        + i * sizeof(ptd), sizeof(ptd));
-                        qtd = ints->qtd;
-                        qtd = clean_up_qtdlist(qtd);
-
-                        free_mem(priv, ints->payload);
-
-                        ints->urb = NULL;
-                        ints->qh = NULL;
-                        ints->qtd = NULL;
-                        ints->data_buffer = NULL;
-                        ints->payload = 0;
-
-                        isp1760_urb_done(priv, urb, status);
-                        if (qtd)
-                                pe(hcd, qh, qtd);
-                        break;
-
-                } else if (ints->qtd) {
-                        struct isp1760_qtd *qtd, *prev_qtd = ints->qtd;
-
-                        for (qtd = ints->qtd->hw_next; qtd; qtd = qtd->hw_next) {
-                                if (qtd->urb == urb) {
-                                        prev_qtd->hw_next = clean_up_qtdlist(qtd);
-                                        isp1760_urb_done(priv, urb, status);
-                                        break;
-                                }
-                                prev_qtd = qtd;
-                        }
-                        /* we found the urb before the end of the list */
-                        if (qtd)
-                                break;
+        list_for_each_entry(qtd, &qh->qtd_list, qtd_list)
+                if (qtd->urb == urb) {
+                        if (qtd->status == QTD_XFER_STARTED)
+                                kill_transfer(hcd, urb, qh);
+                        qtd->status = QTD_RETIRE;
                 }
-                ints++;
-        }
 
-        spin_unlock_irqrestore(&priv->lock, flags);
-        return 0;
+        urb->status = status;
+        schedule_ptds(hcd);
+
+out:
+        spin_unlock_irqrestore(&priv->lock, spinflags);
+        return retval;
 }
 
-static irqreturn_t isp1760_irq(struct usb_hcd *usb_hcd)
+static void isp1760_endpoint_disable(struct usb_hcd *hcd,
+                struct usb_host_endpoint *ep)
 {
-        struct isp1760_hcd *priv = hcd_to_priv(usb_hcd);
-        u32 imask;
-        irqreturn_t irqret = IRQ_NONE;
+        struct isp1760_hcd *priv = hcd_to_priv(hcd);
+        unsigned long spinflags;
+        struct isp1760_qh *qh;
+        struct isp1760_qtd *qtd;
 
-        spin_lock(&priv->lock);
+        spin_lock_irqsave(&priv->lock, spinflags);
 
-        if (!(usb_hcd->state & HC_STATE_RUNNING))
-                goto leave;
+        qh = ep->hcpriv;
+        if (!qh)
+                goto out;
 
-        imask = isp1760_readl(usb_hcd->regs + HC_INTERRUPT_REG);
-        if (unlikely(!imask))
-                goto leave;
+        list_for_each_entry(qtd, &qh->qtd_list, qtd_list) {
+                if (qtd->status == QTD_XFER_STARTED)
+                        kill_transfer(hcd, qtd->urb, qh);
+                qtd->status = QTD_RETIRE;
+                qtd->urb->status = -ECONNRESET;
+        }
 
-        isp1760_writel(imask, usb_hcd->regs + HC_INTERRUPT_REG);
-        if (imask & HC_ATL_INT)
-                do_atl_int(usb_hcd);
+        ep->hcpriv = NULL;
+        /* Cannot free qh here since it will be parsed by schedule_ptds() */
 
-        if (imask & HC_INTL_INT)
-                do_intl_int(usb_hcd);
+        schedule_ptds(hcd);
 
-        irqret = IRQ_HANDLED;
-leave:
-        spin_unlock(&priv->lock);
-        return irqret;
+out:
+        spin_unlock_irqrestore(&priv->lock, spinflags);
 }
 
 static int isp1760_hub_status_data(struct usb_hcd *hcd, char *buf)
@@ -1799,12 +1652,12 @@ static int isp1760_hub_status_data(struct usb_hcd *hcd, char *buf)
         mask = PORT_CSC;
 
         spin_lock_irqsave(&priv->lock, flags);
-        temp = isp1760_readl(hcd->regs + HC_PORTSC1);
+        temp = reg_read32(hcd->regs, HC_PORTSC1);
 
         if (temp & PORT_OWNER) {
                 if (temp & PORT_CSC) {
                         temp &= ~PORT_CSC;
-                        isp1760_writel(temp, hcd->regs + HC_PORTSC1);
+                        reg_write32(hcd->regs, HC_PORTSC1, temp);
                         goto done;
                 }
         }
@@ -1844,9 +1697,9 @@ static void isp1760_hub_descriptor(struct isp1760_hcd *priv,
         temp = 1 + (ports / 8);
         desc->bDescLength = 7 + 2 * temp;
 
-        /* two bitmaps:  ports removable, and usb 1.0 legacy PortPwrCtrlMask */
-        memset(&desc->bitmap[0], 0, temp);
-        memset(&desc->bitmap[temp], 0xff, temp);
+        /* ports removable, and usb 1.0 legacy PortPwrCtrlMask */
+        memset(&desc->u.hs.DeviceRemovable[0], 0, temp);
+        memset(&desc->u.hs.DeviceRemovable[temp], 0xff, temp);
 
         /* per-port overcurrent reporting */
         temp = 0x0008;
@@ -1861,8 +1714,8 @@ static void isp1760_hub_descriptor(struct isp1760_hcd *priv,
 
 #define PORT_WAKE_BITS  (PORT_WKOC_E|PORT_WKDISC_E|PORT_WKCONN_E)
 
-static int check_reset_complete(struct isp1760_hcd *priv, int index,
-                u32 __iomem *status_reg, int port_status)
+static int check_reset_complete(struct usb_hcd *hcd, int index,
+                int port_status)
 {
         if (!(port_status & PORT_CONNECT))
                 return port_status;
@@ -1870,15 +1723,17 @@ static int check_reset_complete(struct isp1760_hcd *priv, int index,
         /* if reset finished and it's still not enabled -- handoff */
         if (!(port_status & PORT_PE)) {
 
-                printk(KERN_ERR "port %d full speed --> companion\n",
-                        index + 1);
+                dev_info(hcd->self.controller,
+                                        "port %d full speed --> companion\n",
+                                        index + 1);
 
                 port_status |= PORT_OWNER;
                 port_status &= ~PORT_RWC_BITS;
-                isp1760_writel(port_status, status_reg);
+                reg_write32(hcd->regs, HC_PORTSC1, port_status);
 
         } else
-                printk(KERN_ERR "port %d high speed\n", index + 1);
+                dev_info(hcd->self.controller, "port %d high speed\n",
+                                                                index + 1);
 
         return port_status;
 }
@@ -1888,7 +1743,6 @@ static int isp1760_hub_control(struct usb_hcd *hcd, u16 typeReq,
 {
         struct isp1760_hcd *priv = hcd_to_priv(hcd);
         int ports = HCS_N_PORTS(priv->hcs_params);
-        u32 __iomem *status_reg = hcd->regs + HC_PORTSC1;
         u32 temp, status;
         unsigned long flags;
         int retval = 0;
@@ -1917,7 +1771,7 @@ static int isp1760_hub_control(struct usb_hcd *hcd, u16 typeReq,
                 if (!wIndex || wIndex > ports)
                         goto error;
                 wIndex--;
-                temp = isp1760_readl(status_reg);
+                temp = reg_read32(hcd->regs, HC_PORTSC1);
 
                 /*
                  * Even if OWNER is set, so the port is owned by the
@@ -1928,7 +1782,7 @@ static int isp1760_hub_control(struct usb_hcd *hcd, u16 typeReq,
 
                 switch (wValue) {
                 case USB_PORT_FEAT_ENABLE:
-                        isp1760_writel(temp & ~PORT_PE, status_reg);
+                        reg_write32(hcd->regs, HC_PORTSC1, temp & ~PORT_PE);
                         break;
                 case USB_PORT_FEAT_C_ENABLE:
                         /* XXX error? */
@@ -1942,8 +1796,8 @@ static int isp1760_hub_control(struct usb_hcd *hcd, u16 typeReq,
                                         goto error;
                                 /* resume signaling for 20 msec */
                                 temp &= ~(PORT_RWC_BITS);
-                                isp1760_writel(temp | PORT_RESUME,
-                                                status_reg);
+                                reg_write32(hcd->regs, HC_PORTSC1,
+                                                        temp | PORT_RESUME);
                                 priv->reset_done = jiffies +
                                         msecs_to_jiffies(20);
                         }
@@ -1953,11 +1807,11 @@ static int isp1760_hub_control(struct usb_hcd *hcd, u16 typeReq,
                         break;
                 case USB_PORT_FEAT_POWER:
                         if (HCS_PPC(priv->hcs_params))
-                                isp1760_writel(temp & ~PORT_POWER, status_reg);
+                                reg_write32(hcd->regs, HC_PORTSC1,
+                                                        temp & ~PORT_POWER);
                         break;
                 case USB_PORT_FEAT_C_CONNECTION:
-                        isp1760_writel(temp | PORT_CSC,
-                                        status_reg);
+                        reg_write32(hcd->regs, HC_PORTSC1, temp | PORT_CSC);
                         break;
                 case USB_PORT_FEAT_C_OVER_CURRENT:
                         /* XXX error ?*/
@@ -1968,7 +1822,7 @@ static int isp1760_hub_control(struct usb_hcd *hcd, u16 typeReq,
                 default:
                         goto error;
                 }
-                isp1760_readl(hcd->regs + HC_USBCMD);
+                reg_read32(hcd->regs, HC_USBCMD);
                 break;
         case GetHubDescriptor:
                 isp1760_hub_descriptor(priv, (struct usb_hub_descriptor *)
@@ -1983,7 +1837,7 @@ static int isp1760_hub_control(struct usb_hcd *hcd, u16 typeReq,
                         goto error;
                 wIndex--;
                 status = 0;
-                temp = isp1760_readl(status_reg);
+                temp = reg_read32(hcd->regs, HC_PORTSC1);
 
                 /* wPortChange bits */
                 if (temp & PORT_CSC)
@@ -1992,7 +1846,7 @@ static int isp1760_hub_control(struct usb_hcd *hcd, u16 typeReq,
 
                 /* whoever resumes must GetPortStatus to complete it!! */
                 if (temp & PORT_RESUME) {
-                        printk(KERN_ERR "Port resume should be skipped.\n");
+                        dev_err(hcd->self.controller, "Port resume should be skipped.\n");
 
                         /* Remote Wakeup received? */
                         if (!priv->reset_done) {
@@ -2000,8 +1854,7 @@ static int isp1760_hub_control(struct usb_hcd *hcd, u16 typeReq,
                                 priv->reset_done = jiffies
                                                 + msecs_to_jiffies(20);
                                 /* check the port again */
-                                mod_timer(&priv_to_hcd(priv)->rh_timer,
-                                                priv->reset_done);
+                                mod_timer(&hcd->rh_timer, priv->reset_done);
                         }
 
                         /* resume completed? */
@@ -2011,14 +1864,13 @@ static int isp1760_hub_control(struct usb_hcd *hcd, u16 typeReq,
                                 priv->reset_done = 0;
 
                                 /* stop resume signaling */
-                                temp = isp1760_readl(status_reg);
-                                isp1760_writel(
-                                        temp & ~(PORT_RWC_BITS | PORT_RESUME),
-                                        status_reg);
-                                retval = handshake(priv, status_reg,
+                                temp = reg_read32(hcd->regs, HC_PORTSC1);
+                                reg_write32(hcd->regs, HC_PORTSC1,
+                                        temp & ~(PORT_RWC_BITS | PORT_RESUME));
+                                retval = handshake(hcd, HC_PORTSC1,
                                            PORT_RESUME, 0, 2000 /* 2msec */);
                                 if (retval != 0) {
-                                        isp1760_err(priv,
+                                        dev_err(hcd->self.controller,
                                                 "port %d resume error %d\n",
                                                 wIndex + 1, retval);
                                         goto error;
@@ -2035,22 +1887,21 @@ static int isp1760_hub_control(struct usb_hcd *hcd, u16 typeReq,
                         priv->reset_done = 0;
 
                         /* force reset to complete */
-                        isp1760_writel(temp & ~PORT_RESET,
-                                        status_reg);
+                        reg_write32(hcd->regs, HC_PORTSC1, temp & ~PORT_RESET);
                         /* REVISIT:  some hardware needs 550+ usec to clear
                          * this bit; seems too long to spin routinely...
                          */
-                        retval = handshake(priv, status_reg,
+                        retval = handshake(hcd, HC_PORTSC1,
                                         PORT_RESET, 0, 750);
                         if (retval != 0) {
-                                isp1760_err(priv, "port %d reset error %d\n",
+                                dev_err(hcd->self.controller, "port %d reset error %d\n",
                                                 wIndex + 1, retval);
                                 goto error;
                         }
 
                         /* see what we found out */
-                        temp = check_reset_complete(priv, wIndex, status_reg,
-                                        isp1760_readl(status_reg));
+                        temp = check_reset_complete(hcd, wIndex,
+                                        reg_read32(hcd->regs, HC_PORTSC1));
                 }
                 /*
                  * Even if OWNER is set, there's no harm letting khubd
@@ -2059,12 +1910,12 @@ static int isp1760_hub_control(struct usb_hcd *hcd, u16 typeReq,
                  */
 
                 if (temp & PORT_OWNER)
-                        printk(KERN_ERR "Warning: PORT_OWNER is set\n");
+                        dev_err(hcd->self.controller, "PORT_OWNER is set\n");
 
                 if (temp & PORT_CONNECT) {
                         status |= USB_PORT_STAT_CONNECTION;
                         /* status may be from integrated TT */
-                        status |= ehci_port_speed(priv, temp);
+                        status |= USB_PORT_STAT_HIGH_SPEED;
                 }
                 if (temp & PORT_PE)
                         status |= USB_PORT_STAT_ENABLE;
@@ -2093,14 +1944,14 @@ static int isp1760_hub_control(struct usb_hcd *hcd, u16 typeReq,
                 if (!wIndex || wIndex > ports)
                         goto error;
                 wIndex--;
-                temp = isp1760_readl(status_reg);
+                temp = reg_read32(hcd->regs, HC_PORTSC1);
                 if (temp & PORT_OWNER)
                         break;
 
 /*              temp &= ~PORT_RWC_BITS; */
                 switch (wValue) {
                 case USB_PORT_FEAT_ENABLE:
-                        isp1760_writel(temp | PORT_PE, status_reg);
+                        reg_write32(hcd->regs, HC_PORTSC1, temp | PORT_PE);
                         break;
 
                 case USB_PORT_FEAT_SUSPEND:
@@ -2108,12 +1959,12 @@ static int isp1760_hub_control(struct usb_hcd *hcd, u16 typeReq,
                                         || (temp & PORT_RESET) != 0)
                                 goto error;
 
-                        isp1760_writel(temp | PORT_SUSPEND, status_reg);
+                        reg_write32(hcd->regs, HC_PORTSC1, temp | PORT_SUSPEND);
                         break;
                 case USB_PORT_FEAT_POWER:
                         if (HCS_PPC(priv->hcs_params))
-                                isp1760_writel(temp | PORT_POWER,
-                                                status_reg);
+                                reg_write32(hcd->regs, HC_PORTSC1,
+                                                        temp | PORT_POWER);
                         break;
                 case USB_PORT_FEAT_RESET:
                         if (temp & PORT_RESUME)
@@ -2136,12 +1987,12 @@ static int isp1760_hub_control(struct usb_hcd *hcd, u16 typeReq,
                                 priv->reset_done = jiffies +
                                         msecs_to_jiffies(50);
                         }
-                        isp1760_writel(temp, status_reg);
+                        reg_write32(hcd->regs, HC_PORTSC1, temp);
                         break;
                 default:
                         goto error;
                 }
-                isp1760_readl(hcd->regs + HC_USBCMD);
+                reg_read32(hcd->regs, HC_USBCMD);
                 break;
 
         default:
@@ -2153,57 +2004,12 @@ error:
         return retval;
 }
 
-static void isp1760_endpoint_disable(struct usb_hcd *usb_hcd,
-                struct usb_host_endpoint *ep)
-{
-        struct isp1760_hcd *priv = hcd_to_priv(usb_hcd);
-        struct isp1760_qh *qh;
-        struct isp1760_qtd *qtd;
-        unsigned long flags;
-
-        spin_lock_irqsave(&priv->lock, flags);
-        qh = ep->hcpriv;
-        if (!qh)
-                goto out;
-
-        ep->hcpriv = NULL;
-        do {
-                /* more than entry might get removed */
-                if (list_empty(&qh->qtd_list))
-                        break;
-
-                qtd = list_first_entry(&qh->qtd_list, struct isp1760_qtd,
-                                qtd_list);
-
-                if (qtd->status & URB_ENQUEUED) {
-
-                        spin_unlock_irqrestore(&priv->lock, flags);
-                        isp1760_urb_dequeue(usb_hcd, qtd->urb, -ECONNRESET);
-                        spin_lock_irqsave(&priv->lock, flags);
-                } else {
-                        struct urb *urb;
-
-                        urb = qtd->urb;
-                        clean_up_qtdlist(qtd);
-                        isp1760_urb_done(priv, urb, -ECONNRESET);
-                }
-        } while (1);
-
-        qh_destroy(qh);
-        /* remove requests and leak them.
-         * ATL are pretty fast done, INT could take a while...
-         * The latter shoule be removed
-         */
-out:
-        spin_unlock_irqrestore(&priv->lock, flags);
-}
-
 static int isp1760_get_frame(struct usb_hcd *hcd)
 {
         struct isp1760_hcd *priv = hcd_to_priv(hcd);
         u32 fr;
 
-        fr = isp1760_readl(hcd->regs + HC_FRINDEX);
+        fr = reg_read32(hcd->regs, HC_FRINDEX);
         return (fr >> 3) % priv->periodic_size;
 }
 
@@ -2217,13 +2023,13 @@ static void isp1760_stop(struct usb_hcd *hcd)
         mdelay(20);
 
         spin_lock_irq(&priv->lock);
-        ehci_reset(priv);
+        ehci_reset(hcd);
         /* Disable IRQ */
-        temp = isp1760_readl(hcd->regs + HC_HW_MODE_CTRL);
-        isp1760_writel(temp &= ~HW_GLOBAL_INTR_EN, hcd->regs + HC_HW_MODE_CTRL);
+        temp = reg_read32(hcd->regs, HC_HW_MODE_CTRL);
+        reg_write32(hcd->regs, HC_HW_MODE_CTRL, temp &= ~HW_GLOBAL_INTR_EN);
         spin_unlock_irq(&priv->lock);
 
-        isp1760_writel(0, hcd->regs + HC_CONFIGFLAG);
+        reg_write32(hcd->regs, HC_CONFIGFLAG, 0);
 }
 
 static void isp1760_shutdown(struct usb_hcd *hcd)
@@ -2231,12 +2037,12 @@ static void isp1760_shutdown(struct usb_hcd *hcd)
         u32 command, temp;
 
         isp1760_stop(hcd);
-        temp = isp1760_readl(hcd->regs + HC_HW_MODE_CTRL);
-        isp1760_writel(temp &= ~HW_GLOBAL_INTR_EN, hcd->regs + HC_HW_MODE_CTRL);
+        temp = reg_read32(hcd->regs, HC_HW_MODE_CTRL);
+        reg_write32(hcd->regs, HC_HW_MODE_CTRL, temp &= ~HW_GLOBAL_INTR_EN);
 
-        command = isp1760_readl(hcd->regs + HC_USBCMD);
+        command = reg_read32(hcd->regs, HC_USBCMD);
         command &= ~CMD_RUN;
-        isp1760_writel(command, hcd->regs + HC_USBCMD);
+        reg_write32(hcd->regs, HC_USBCMD, command);
 }
 
 static const struct hc_driver isp1760_hc_driver = {
@@ -2259,6 +2065,13 @@ static const struct hc_driver isp1760_hc_driver = {
 
 int __init init_kmem_once(void)
 {
+        urb_listitem_cachep = kmem_cache_create("isp1760 urb_listitem",
+                        sizeof(struct urb_listitem), 0, SLAB_TEMPORARY |
+                        SLAB_MEM_SPREAD, NULL);
+
+        if (!urb_listitem_cachep)
+                return -ENOMEM;
+
         qtd_cachep = kmem_cache_create("isp1760_qtd",
                         sizeof(struct isp1760_qtd), 0, SLAB_TEMPORARY |
                         SLAB_MEM_SPREAD, NULL);
@@ -2281,6 +2094,7 @@ void deinit_kmem_cache(void)
 {
         kmem_cache_destroy(qtd_cachep);
         kmem_cache_destroy(qh_cachep);
+        kmem_cache_destroy(urb_listitem_cachep);
 }
 
 struct usb_hcd *isp1760_register(phys_addr_t res_start, resource_size_t res_len,
diff --git a/drivers/usb/host/isp1760-hcd.h b/drivers/usb/host/isp1760-hcd.h
index 6931ef5c9650..014a7dfadf91 100644
--- a/drivers/usb/host/isp1760-hcd.h
+++ b/drivers/usb/host/isp1760-hcd.h
@@ -49,10 +49,9 @@ void deinit_kmem_cache(void);
 #define SW_RESET_RESET_ALL      (1 << 0)
 
 #define HC_BUFFER_STATUS_REG    0x334
-#define ATL_BUFFER              0x1
-#define INT_BUFFER              0x2
-#define ISO_BUFFER              0x4
-#define BUFFER_MAP              0x7
+#define ISO_BUF_FILL            (1 << 2)
+#define INT_BUF_FILL            (1 << 1)
+#define ATL_BUF_FILL            (1 << 0)
 
 #define HC_MEMORY_REG           0x33c
 #define ISP_BANK(x)             ((x) << 16)
@@ -68,13 +67,13 @@ void deinit_kmem_cache(void);
 #define HC_INTERRUPT_REG        0x310
 
 #define HC_INTERRUPT_ENABLE     0x314
-#define INTERRUPT_ENABLE_MASK   (HC_INTL_INT | HC_ATL_INT | HC_EOT_INT)
-
 #define HC_ISO_INT              (1 << 9)
 #define HC_ATL_INT              (1 << 8)
 #define HC_INTL_INT             (1 << 7)
 #define HC_EOT_INT              (1 << 3)
 #define HC_SOT_INT              (1 << 1)
+#define INTERRUPT_ENABLE_MASK   (HC_INTL_INT | HC_ATL_INT)
+#define INTERRUPT_ENABLE_SOT_MASK       (HC_SOT_INT)
 
 #define HC_ISO_IRQ_MASK_OR_REG  0x318
 #define HC_INT_IRQ_MASK_OR_REG  0x31C
@@ -83,37 +82,29 @@ void deinit_kmem_cache(void);
 #define HC_INT_IRQ_MASK_AND_REG 0x328
 #define HC_ATL_IRQ_MASK_AND_REG 0x32C
 
-/* Register sets */
-#define HC_BEGIN_OF_ATL         0x0c00
-#define HC_BEGIN_OF_INT         0x0800
-#define HC_BEGIN_OF_ISO         0x0400
-#define HC_BEGIN_OF_PAYLOAD     0x1000
-
 /* urb state*/
 #define DELETE_URB              (0x0008)
 #define NO_TRANSFER_ACTIVE      (0xffffffff)
 
-#define ATL_REGS_OFFSET         (0xc00)
-#define INT_REGS_OFFSET         (0x800)
-
-/* Philips Transfer Descriptor (PTD) */
+/* Philips Proprietary Transfer Descriptor (PTD) */
+typedef __u32 __bitwise __dw;
 struct ptd {
-        __le32 dw0;
-        __le32 dw1;
-        __le32 dw2;
-        __le32 dw3;
-        __le32 dw4;
-        __le32 dw5;
-        __le32 dw6;
-        __le32 dw7;
+        __dw dw0;
+        __dw dw1;
+        __dw dw2;
+        __dw dw3;
+        __dw dw4;
+        __dw dw5;
+        __dw dw6;
+        __dw dw7;
 };
+#define PTD_OFFSET              0x0400
+#define ISO_PTD_OFFSET          0x0400
+#define INT_PTD_OFFSET          0x0800
+#define ATL_PTD_OFFSET          0x0c00
+#define PAYLOAD_OFFSET          0x1000
 
-struct inter_packet_info {
-        void *data_buffer;
-        u32 payload;
-#define PTD_FIRE_NEXT           (1 << 0)
-#define PTD_URB_FINISHED        (1 << 1)
-        struct urb *urb;
+struct slotinfo {
         struct isp1760_qh *qh;
         struct isp1760_qtd *qtd;
 };
@@ -122,15 +113,6 @@ struct inter_packet_info {
 typedef void (packet_enqueue)(struct usb_hcd *hcd, struct isp1760_qh *qh,
                 struct isp1760_qtd *qtd);
 
-#define isp1760_dbg(priv, fmt, args...) \
-        dev_dbg(priv_to_hcd(priv)->self.controller, fmt, ##args)
-
-#define isp1760_info(priv, fmt, args...) \
-        dev_info(priv_to_hcd(priv)->self.controller, fmt, ##args)
-
-#define isp1760_err(priv, fmt, args...) \
-        dev_err(priv_to_hcd(priv)->self.controller, fmt, ##args)
-
 /*
  * Device flags that can vary from board to board.  All of these
  * indicate the most "atypical" case, so that a devflags of 0 is
@@ -167,63 +149,57 @@ struct memory_chunk {
 #define BLOCK_2_SIZE 1024
 #define BLOCK_3_SIZE 8192
 #define BLOCKS (BLOCK_1_NUM + BLOCK_2_NUM + BLOCK_3_NUM)
-#define PAYLOAD_SIZE 0xf000
-
-/* I saw if some reloads if the pointer was negative */
-#define ISP1760_NULL_POINTER    (0x400)
+#define MAX_PAYLOAD_SIZE BLOCK_3_SIZE
+#define PAYLOAD_AREA_SIZE 0xf000
 
 /* ATL */
 /* DW0 */
-#define PTD_VALID                       1
-#define PTD_LENGTH(x)                   (((u32) x) << 3)
-#define PTD_MAXPACKET(x)                (((u32) x) << 18)
-#define PTD_MULTI(x)                    (((u32) x) << 29)
-#define PTD_ENDPOINT(x)                 (((u32) x) << 31)
+#define DW0_VALID_BIT                   1
+#define FROM_DW0_VALID(x)               ((x) & 0x01)
+#define TO_DW0_LENGTH(x)                (((u32) x) << 3)
+#define TO_DW0_MAXPACKET(x)             (((u32) x) << 18)
+#define TO_DW0_MULTI(x)                 (((u32) x) << 29)
+#define TO_DW0_ENDPOINT(x)              (((u32) x) << 31)
 /* DW1 */
-#define PTD_DEVICE_ADDR(x)              (((u32) x) << 3)
-#define PTD_PID_TOKEN(x)                (((u32) x) << 10)
-#define PTD_TRANS_BULK                  ((u32) 2 << 12)
-#define PTD_TRANS_INT                   ((u32) 3 << 12)
-#define PTD_TRANS_SPLIT                 ((u32) 1 << 14)
-#define PTD_SE_USB_LOSPEED              ((u32) 2 << 16)
-#define PTD_PORT_NUM(x)                 (((u32) x) << 18)
-#define PTD_HUB_NUM(x)                  (((u32) x) << 25)
-#define PTD_PING(x)                     (((u32) x) << 26)
+#define TO_DW1_DEVICE_ADDR(x)           (((u32) x) << 3)
+#define TO_DW1_PID_TOKEN(x)             (((u32) x) << 10)
+#define DW1_TRANS_BULK                  ((u32) 2 << 12)
+#define DW1_TRANS_INT                   ((u32) 3 << 12)
+#define DW1_TRANS_SPLIT                 ((u32) 1 << 14)
+#define DW1_SE_USB_LOSPEED              ((u32) 2 << 16)
+#define TO_DW1_PORT_NUM(x)              (((u32) x) << 18)
+#define TO_DW1_HUB_NUM(x)               (((u32) x) << 25)
 /* DW2 */
-#define PTD_RL_CNT(x)                   (((u32) x) << 25)
-#define PTD_DATA_START_ADDR(x)          (((u32) x) << 8)
-#define BASE_ADDR                       0x1000
+#define TO_DW2_DATA_START_ADDR(x)       (((u32) x) << 8)
+#define TO_DW2_RL(x)                    ((x) << 25)
+#define FROM_DW2_RL(x)                  (((x) >> 25) & 0xf)
 /* DW3 */
-#define PTD_CERR(x)                     (((u32) x) << 23)
-#define PTD_NAC_CNT(x)                  (((u32) x) << 19)
-#define PTD_ACTIVE                      ((u32) 1 << 31)
-#define PTD_DATA_TOGGLE(x)              (((u32) x) << 25)
-
-#define DW3_HALT_BIT                    (1 << 30)
+#define FROM_DW3_NRBYTESTRANSFERRED(x)          ((x) & 0x7fff)
+#define FROM_DW3_SCS_NRBYTESTRANSFERRED(x)      ((x) & 0x07ff)
+#define TO_DW3_NAKCOUNT(x)              ((x) << 19)
+#define FROM_DW3_NAKCOUNT(x)            (((x) >> 19) & 0xf)
+#define TO_DW3_CERR(x)                  ((x) << 23)
+#define FROM_DW3_CERR(x)                (((x) >> 23) & 0x3)
+#define TO_DW3_DATA_TOGGLE(x)           ((x) << 25)
+#define FROM_DW3_DATA_TOGGLE(x)         (((x) >> 25) & 0x1)
+#define TO_DW3_PING(x)                  ((x) << 26)
+#define FROM_DW3_PING(x)                (((x) >> 26) & 0x1)
 #define DW3_ERROR_BIT                   (1 << 28)
-#define DW3_QTD_ACTIVE                  (1 << 31)
+#define DW3_BABBLE_BIT                  (1 << 29)
+#define DW3_HALT_BIT                    (1 << 30)
+#define DW3_ACTIVE_BIT                  (1 << 31)
 
 #define INT_UNDERRUN                    (1 << 2)
 #define INT_BABBLE                      (1 << 1)
 #define INT_EXACT                       (1 << 0)
 
-#define DW1_GET_PID(x)                  (((x) >> 10) & 0x3)
-#define PTD_XFERRED_LENGTH(x)           ((x) & 0x7fff)
-#define PTD_XFERRED_LENGTH_LO(x)        ((x) & 0x7ff)
-
 #define SETUP_PID       (2)
 #define IN_PID          (1)
 #define OUT_PID         (0)
-#define GET_QTD_TOKEN_TYPE(x)   ((x) & 0x3)
-
-#define DATA_TOGGLE             (1 << 31)
-#define GET_DATA_TOGGLE(x)      ((x) >> 31)
 
 /* Errata 1 */
 #define RL_COUNTER      (0)
 #define NAK_COUNTER     (0)
 #define ERR_COUNTER     (2)
 
-#define HC_ATL_PL_SIZE  (8192)
-
-#endif
+#endif /* _ISP1760_HCD_H_ */
diff --git a/drivers/usb/host/isp1760-if.c b/drivers/usb/host/isp1760-if.c
index 3b28dbfca058..7ee30056f373 100644
--- a/drivers/usb/host/isp1760-if.c
+++ b/drivers/usb/host/isp1760-if.c
@@ -27,8 +27,7 @@
 #endif
 
 #ifdef CONFIG_PPC_OF
-static int of_isp1760_probe(struct platform_device *dev,
-                const struct of_device_id *match)
+static int of_isp1760_probe(struct platform_device *dev)
 {
         struct usb_hcd *hcd;
         struct device_node *dp = dev->dev.of_node;
@@ -119,7 +118,7 @@ static const struct of_device_id of_isp1760_match[] = {
 };
 MODULE_DEVICE_TABLE(of, of_isp1760_match);
 
-static struct of_platform_driver isp1760_of_driver = {
+static struct platform_driver isp1760_of_driver = {
         .driver = {
                 .name = "nxp-isp1760",
                 .owner = THIS_MODULE,
@@ -398,7 +397,7 @@ static int __init isp1760_init(void)
         if (!ret)
                 any_ret = 0;
 #ifdef CONFIG_PPC_OF
-        ret = of_register_platform_driver(&isp1760_of_driver);
+        ret = platform_driver_register(&isp1760_of_driver);
         if (!ret)
                 any_ret = 0;
 #endif
@@ -418,7 +417,7 @@ static void __exit isp1760_exit(void)
 {
         platform_driver_unregister(&isp1760_plat_driver);
 #ifdef CONFIG_PPC_OF
-        of_unregister_platform_driver(&isp1760_of_driver);
+        platform_driver_unregister(&isp1760_of_driver);
 #endif
 #ifdef CONFIG_PCI
         pci_unregister_driver(&isp1761_pci_driver);
diff --git a/drivers/usb/host/octeon2-common.c b/drivers/usb/host/octeon2-common.c
new file mode 100644
index 000000000000..d9df423f3d12
--- /dev/null
+++ b/drivers/usb/host/octeon2-common.c
@@ -0,0 +1,200 @@
+/*
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ * Copyright (C) 2010, 2011 Cavium Networks
+ */
+
+#include <linux/module.h>
+#include <linux/mutex.h>
+#include <linux/delay.h>
+
+#include <asm/octeon/octeon.h>
+#include <asm/octeon/cvmx-uctlx-defs.h>
+
+static DEFINE_MUTEX(octeon2_usb_clocks_mutex);
+
+static int octeon2_usb_clock_start_cnt;
+
+void octeon2_usb_clocks_start(void)
+{
+        u64 div;
+        union cvmx_uctlx_if_ena if_ena;
+        union cvmx_uctlx_clk_rst_ctl clk_rst_ctl;
+        union cvmx_uctlx_uphy_ctl_status uphy_ctl_status;
+        union cvmx_uctlx_uphy_portx_ctl_status port_ctl_status;
+        int i;
+        unsigned long io_clk_64_to_ns;
+
+
+        mutex_lock(&octeon2_usb_clocks_mutex);
+
+        octeon2_usb_clock_start_cnt++;
+        if (octeon2_usb_clock_start_cnt != 1)
+                goto exit;
+
+        io_clk_64_to_ns = 64000000000ull / octeon_get_io_clock_rate();
+
+        /*
+         * Step 1: Wait for voltages stable.  That surely happened
+         * before starting the kernel.
+         *
+         * Step 2: Enable  SCLK of UCTL by writing UCTL0_IF_ENA[EN] = 1
+         */
+        if_ena.u64 = 0;
+        if_ena.s.en = 1;
+        cvmx_write_csr(CVMX_UCTLX_IF_ENA(0), if_ena.u64);
+
+        /* Step 3: Configure the reference clock, PHY, and HCLK */
+        clk_rst_ctl.u64 = cvmx_read_csr(CVMX_UCTLX_CLK_RST_CTL(0));
+
+        /*
+         * If the UCTL looks like it has already been started, skip
+         * the initialization, otherwise bus errors are obtained.
+         */
+        if (clk_rst_ctl.s.hrst)
+                goto end_clock;
+        /* 3a */
+        clk_rst_ctl.s.p_por = 1;
+        clk_rst_ctl.s.hrst = 0;
+        clk_rst_ctl.s.p_prst = 0;
+        clk_rst_ctl.s.h_clkdiv_rst = 0;
+        clk_rst_ctl.s.o_clkdiv_rst = 0;
+        clk_rst_ctl.s.h_clkdiv_en = 0;
+        clk_rst_ctl.s.o_clkdiv_en = 0;
+        cvmx_write_csr(CVMX_UCTLX_CLK_RST_CTL(0), clk_rst_ctl.u64);
+
+        /* 3b */
+        /* 12MHz crystal. */
+        clk_rst_ctl.s.p_refclk_sel = 0;
+        clk_rst_ctl.s.p_refclk_div = 0;
+        cvmx_write_csr(CVMX_UCTLX_CLK_RST_CTL(0), clk_rst_ctl.u64);
+
+        /* 3c */
+        div = octeon_get_io_clock_rate() / 130000000ull;
+
+        switch (div) {
+        case 0:
+                div = 1;
+                break;
+        case 1:
+        case 2:
+        case 3:
+        case 4:
+                break;
+        case 5:
+                div = 4;
+                break;
+        case 6:
+        case 7:
+                div = 6;
+                break;
+        case 8:
+        case 9:
+        case 10:
+        case 11:
+                div = 8;
+                break;
+        default:
+                div = 12;
+                break;
+        }
+        clk_rst_ctl.s.h_div = div;
+        cvmx_write_csr(CVMX_UCTLX_CLK_RST_CTL(0), clk_rst_ctl.u64);
+        /* Read it back, */
+        clk_rst_ctl.u64 = cvmx_read_csr(CVMX_UCTLX_CLK_RST_CTL(0));
+        clk_rst_ctl.s.h_clkdiv_en = 1;
+        cvmx_write_csr(CVMX_UCTLX_CLK_RST_CTL(0), clk_rst_ctl.u64);
+        /* 3d */
+        clk_rst_ctl.s.h_clkdiv_rst = 1;
+        cvmx_write_csr(CVMX_UCTLX_CLK_RST_CTL(0), clk_rst_ctl.u64);
+
+        /* 3e: delay 64 io clocks */
+        ndelay(io_clk_64_to_ns);
+
+        /*
+         * Step 4: Program the power-on reset field in the UCTL
+         * clock-reset-control register.
+         */
+        clk_rst_ctl.s.p_por = 0;
+        cvmx_write_csr(CVMX_UCTLX_CLK_RST_CTL(0), clk_rst_ctl.u64);
+
+        /* Step 5:    Wait 1 ms for the PHY clock to start. */
+        mdelay(1);
+
+        /*
+         * Step 6: Program the reset input from automatic test
+         * equipment field in the UPHY CSR
+         */
+        uphy_ctl_status.u64 = cvmx_read_csr(CVMX_UCTLX_UPHY_CTL_STATUS(0));
+        uphy_ctl_status.s.ate_reset = 1;
+        cvmx_write_csr(CVMX_UCTLX_UPHY_CTL_STATUS(0), uphy_ctl_status.u64);
+
+        /* Step 7: Wait for at least 10ns. */
+        ndelay(10);
+
+        /* Step 8: Clear the ATE_RESET field in the UPHY CSR. */
+        uphy_ctl_status.s.ate_reset = 0;
+        cvmx_write_csr(CVMX_UCTLX_UPHY_CTL_STATUS(0), uphy_ctl_status.u64);
+
+        /*
+         * Step 9: Wait for at least 20ns for UPHY to output PHY clock
+         * signals and OHCI_CLK48
+         */
+        ndelay(20);
+
+        /* Step 10: Configure the OHCI_CLK48 and OHCI_CLK12 clocks. */
+        /* 10a */
+        clk_rst_ctl.s.o_clkdiv_rst = 1;
+        cvmx_write_csr(CVMX_UCTLX_CLK_RST_CTL(0), clk_rst_ctl.u64);
+
+        /* 10b */
+        clk_rst_ctl.s.o_clkdiv_en = 1;
+        cvmx_write_csr(CVMX_UCTLX_CLK_RST_CTL(0), clk_rst_ctl.u64);
+
+        /* 10c */
+        ndelay(io_clk_64_to_ns);
+
+        /*
+         * Step 11: Program the PHY reset field:
+         * UCTL0_CLK_RST_CTL[P_PRST] = 1
+         */
+        clk_rst_ctl.s.p_prst = 1;
+        cvmx_write_csr(CVMX_UCTLX_CLK_RST_CTL(0), clk_rst_ctl.u64);
+
+        /* Step 12: Wait 1 uS. */
+        udelay(1);
+
+        /* Step 13: Program the HRESET_N field: UCTL0_CLK_RST_CTL[HRST] = 1 */
+        clk_rst_ctl.s.hrst = 1;
+        cvmx_write_csr(CVMX_UCTLX_CLK_RST_CTL(0), clk_rst_ctl.u64);
+
+end_clock:
+        /* Now we can set some other registers.  */
+
+        for (i = 0; i <= 1; i++) {
+                port_ctl_status.u64 =
+                        cvmx_read_csr(CVMX_UCTLX_UPHY_PORTX_CTL_STATUS(i, 0));
+                /* Set txvreftune to 15 to obtain compliant 'eye' diagram. */
+                port_ctl_status.s.txvreftune = 15;
+                port_ctl_status.s.txrisetune = 1;
+                port_ctl_status.s.txpreemphasistune = 1;
+                cvmx_write_csr(CVMX_UCTLX_UPHY_PORTX_CTL_STATUS(i, 0),
+                               port_ctl_status.u64);
+        }
+
+        /* Set uSOF cycle period to 60,000 bits. */
+        cvmx_write_csr(CVMX_UCTLX_EHCI_FLA(0), 0x20ull);
+exit:
+        mutex_unlock(&octeon2_usb_clocks_mutex);
+}
+EXPORT_SYMBOL(octeon2_usb_clocks_start);
+
+void octeon2_usb_clocks_stop(void)
+{
+        mutex_lock(&octeon2_usb_clocks_mutex);
+        octeon2_usb_clock_start_cnt--;
+        mutex_unlock(&octeon2_usb_clocks_mutex);
+}
+EXPORT_SYMBOL(octeon2_usb_clocks_stop);
diff --git a/drivers/usb/host/ohci-ath79.c b/drivers/usb/host/ohci-ath79.c
new file mode 100644
index 000000000000..ffea3e7cb0a8
--- /dev/null
+++ b/drivers/usb/host/ohci-ath79.c
@@ -0,0 +1,151 @@
+/*
+ *  OHCI HCD (Host Controller Driver) for USB.
+ *
+ *  Bus Glue for Atheros AR71XX/AR724X built-in OHCI controller.
+ *
+ *  Copyright (C) 2008-2011 Gabor Juhos <juhosg@openwrt.org>
+ *  Copyright (C) 2008 Imre Kaloz <kaloz@openwrt.org>
+ *
+ *  Parts of this file are based on Atheros' 2.6.15 BSP
+ *      Copyright (C) 2007 Atheros Communications, Inc.
+ *
+ *  This program is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 as published
+ *  by the Free Software Foundation.
+ */
+
+#include <linux/platform_device.h>
+
+static int __devinit ohci_ath79_start(struct usb_hcd *hcd)
+{
+        struct ohci_hcd *ohci = hcd_to_ohci(hcd);
+        int ret;
+
+        ret = ohci_init(ohci);
+        if (ret < 0)
+                return ret;
+
+        ret = ohci_run(ohci);
+        if (ret < 0)
+                goto err;
+
+        return 0;
+
+err:
+        ohci_stop(hcd);
+        return ret;
+}
+
+static const struct hc_driver ohci_ath79_hc_driver = {
+        .description            = hcd_name,
+        .product_desc           = "Atheros built-in OHCI controller",
+        .hcd_priv_size          = sizeof(struct ohci_hcd),
+
+        .irq                    = ohci_irq,
+        .flags                  = HCD_USB11 | HCD_MEMORY,
+
+        .start                  = ohci_ath79_start,
+        .stop                   = ohci_stop,
+        .shutdown               = ohci_shutdown,
+
+        .urb_enqueue            = ohci_urb_enqueue,
+        .urb_dequeue            = ohci_urb_dequeue,
+        .endpoint_disable       = ohci_endpoint_disable,
+
+        /*
+         * scheduling support
+         */
+        .get_frame_number       = ohci_get_frame,
+
+        /*
+         * root hub support
+         */
+        .hub_status_data        = ohci_hub_status_data,
+        .hub_control            = ohci_hub_control,
+        .start_port_reset       = ohci_start_port_reset,
+};
+
+static int ohci_ath79_probe(struct platform_device *pdev)
+{
+        struct usb_hcd *hcd;
+        struct resource *res;
+        int irq;
+        int ret;
+
+        if (usb_disabled())
+                return -ENODEV;
+
+        res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+        if (!res) {
+                dev_dbg(&pdev->dev, "no IRQ specified\n");
+                return -ENODEV;
+        }
+        irq = res->start;
+
+        hcd = usb_create_hcd(&ohci_ath79_hc_driver, &pdev->dev,
+                             dev_name(&pdev->dev));
+        if (!hcd)
+                return -ENOMEM;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_dbg(&pdev->dev, "no base address specified\n");
+                ret = -ENODEV;
+                goto err_put_hcd;
+        }
+        hcd->rsrc_start = res->start;
+        hcd->rsrc_len   = res->end - res->start + 1;
+
+        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
+                dev_dbg(&pdev->dev, "controller already in use\n");
+                ret = -EBUSY;
+                goto err_put_hcd;
+        }
+
+        hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
+        if (!hcd->regs) {
+                dev_dbg(&pdev->dev, "error mapping memory\n");
+                ret = -EFAULT;
+                goto err_release_region;
+        }
+
+        ohci_hcd_init(hcd_to_ohci(hcd));
+
+        ret = usb_add_hcd(hcd, irq, IRQF_DISABLED);
+        if (ret)
+                goto err_stop_hcd;
+
+        return 0;
+
+err_stop_hcd:
+        iounmap(hcd->regs);
+err_release_region:
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+err_put_hcd:
+        usb_put_hcd(hcd);
+        return ret;
+}
+
+static int ohci_ath79_remove(struct platform_device *pdev)
+{
+        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+
+        usb_remove_hcd(hcd);
+        iounmap(hcd->regs);
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+        usb_put_hcd(hcd);
+
+        return 0;
+}
+
+static struct platform_driver ohci_hcd_ath79_driver = {
+        .probe          = ohci_ath79_probe,
+        .remove         = ohci_ath79_remove,
+        .shutdown       = usb_hcd_platform_shutdown,
+        .driver         = {
+                .name   = "ath79-ohci",
+                .owner  = THIS_MODULE,
+        },
+};
+
+MODULE_ALIAS(PLATFORM_MODULE_PREFIX "ath79-ohci");
diff --git a/drivers/usb/host/ohci-au1xxx.c b/drivers/usb/host/ohci-au1xxx.c
index 17a6043c1fa0..958d985f2951 100644
--- a/drivers/usb/host/ohci-au1xxx.c
+++ b/drivers/usb/host/ohci-au1xxx.c
@@ -33,7 +33,7 @@
 
 #ifdef __LITTLE_ENDIAN
 #define USBH_ENABLE_INIT (USBH_ENABLE_CE | USBH_ENABLE_E | USBH_ENABLE_C)
-#elif __BIG_ENDIAN
+#elif defined(__BIG_ENDIAN)
 #define USBH_ENABLE_INIT (USBH_ENABLE_CE | USBH_ENABLE_E | USBH_ENABLE_C | \
                           USBH_ENABLE_BE)
 #else
diff --git a/drivers/usb/host/ohci-cns3xxx.c b/drivers/usb/host/ohci-cns3xxx.c
new file mode 100644
index 000000000000..f05ef87e934c
--- /dev/null
+++ b/drivers/usb/host/ohci-cns3xxx.c
@@ -0,0 +1,165 @@
+/*
+ * Copyright 2008 Cavium Networks
+ *
+ * This file is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License, Version 2, as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/platform_device.h>
+#include <linux/atomic.h>
+#include <mach/cns3xxx.h>
+#include <mach/pm.h>
+
+static int __devinit
+cns3xxx_ohci_start(struct usb_hcd *hcd)
+{
+        struct ohci_hcd *ohci = hcd_to_ohci(hcd);
+        int ret;
+
+        /*
+         * EHCI and OHCI share the same clock and power,
+         * resetting twice would cause the 1st controller been reset.
+         * Therefore only do power up  at the first up device, and
+         * power down at the last down device.
+         *
+         * Set USB AHB INCR length to 16
+         */
+        if (atomic_inc_return(&usb_pwr_ref) == 1) {
+                cns3xxx_pwr_power_up(1 << PM_PLL_HM_PD_CTRL_REG_OFFSET_PLL_USB);
+                cns3xxx_pwr_clk_en(1 << PM_CLK_GATE_REG_OFFSET_USB_HOST);
+                cns3xxx_pwr_soft_rst(1 << PM_SOFT_RST_REG_OFFST_USB_HOST);
+                __raw_writel((__raw_readl(MISC_CHIP_CONFIG_REG) | (0X2 << 24)),
+                        MISC_CHIP_CONFIG_REG);
+        }
+
+        ret = ohci_init(ohci);
+        if (ret < 0)
+                return ret;
+
+        ohci->num_ports = 1;
+
+        ret = ohci_run(ohci);
+        if (ret < 0) {
+                err("can't start %s", hcd->self.bus_name);
+                ohci_stop(hcd);
+                return ret;
+        }
+        return 0;
+}
+
+static const struct hc_driver cns3xxx_ohci_hc_driver = {
+        .description            = hcd_name,
+        .product_desc           = "CNS3XXX OHCI Host controller",
+        .hcd_priv_size          = sizeof(struct ohci_hcd),
+        .irq                    = ohci_irq,
+        .flags                  = HCD_USB11 | HCD_MEMORY,
+        .start                  = cns3xxx_ohci_start,
+        .stop                   = ohci_stop,
+        .shutdown               = ohci_shutdown,
+        .urb_enqueue            = ohci_urb_enqueue,
+        .urb_dequeue            = ohci_urb_dequeue,
+        .endpoint_disable       = ohci_endpoint_disable,
+        .get_frame_number       = ohci_get_frame,
+        .hub_status_data        = ohci_hub_status_data,
+        .hub_control            = ohci_hub_control,
+#ifdef CONFIG_PM
+        .bus_suspend            = ohci_bus_suspend,
+        .bus_resume             = ohci_bus_resume,
+#endif
+        .start_port_reset       = ohci_start_port_reset,
+};
+
+static int cns3xxx_ohci_probe(struct platform_device *pdev)
+{
+        struct device *dev = &pdev->dev;
+        struct usb_hcd *hcd;
+        const struct hc_driver *driver = &cns3xxx_ohci_hc_driver;
+        struct resource *res;
+        int irq;
+        int retval;
+
+        if (usb_disabled())
+                return -ENODEV;
+
+        res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+        if (!res) {
+                dev_err(dev, "Found HC with no IRQ.\n");
+                return -ENODEV;
+        }
+        irq = res->start;
+
+        hcd = usb_create_hcd(driver, dev, dev_name(dev));
+        if (!hcd)
+                return -ENOMEM;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(dev, "Found HC with no register addr.\n");
+                retval = -ENODEV;
+                goto err1;
+        }
+        hcd->rsrc_start = res->start;
+        hcd->rsrc_len = res->end - res->start + 1;
+
+        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len,
+                        driver->description)) {
+                dev_dbg(dev, "controller already in use\n");
+                retval = -EBUSY;
+                goto err1;
+        }
+
+        hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
+        if (!hcd->regs) {
+                dev_dbg(dev, "error mapping memory\n");
+                retval = -EFAULT;
+                goto err2;
+        }
+
+        ohci_hcd_init(hcd_to_ohci(hcd));
+
+        retval = usb_add_hcd(hcd, irq, IRQF_SHARED);
+        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;
+}
+
+static int cns3xxx_ohci_remove(struct platform_device *pdev)
+{
+        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+
+        usb_remove_hcd(hcd);
+        iounmap(hcd->regs);
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+
+        /*
+         * EHCI and OHCI share the same clock and power,
+         * resetting twice would cause the 1st controller been reset.
+         * Therefore only do power up  at the first up device, and
+         * power down at the last down device.
+         */
+        if (atomic_dec_return(&usb_pwr_ref) == 0)
+                cns3xxx_pwr_clk_dis(1 << PM_CLK_GATE_REG_OFFSET_USB_HOST);
+
+        usb_put_hcd(hcd);
+
+        platform_set_drvdata(pdev, NULL);
+
+        return 0;
+}
+
+MODULE_ALIAS("platform:cns3xxx-ohci");
+
+static struct platform_driver ohci_hcd_cns3xxx_driver = {
+        .probe = cns3xxx_ohci_probe,
+        .remove = cns3xxx_ohci_remove,
+        .driver = {
+                .name = "cns3xxx-ohci",
+        },
+};
diff --git a/drivers/usb/host/ohci-dbg.c b/drivers/usb/host/ohci-dbg.c
index 36abd2baa3ea..d7d34492934a 100644
--- a/drivers/usb/host/ohci-dbg.c
+++ b/drivers/usb/host/ohci-dbg.c
@@ -413,18 +413,21 @@ static const struct file_operations debug_async_fops = {
         .open           = debug_async_open,
         .read           = debug_output,
         .release        = debug_close,
+        .llseek         = default_llseek,
 };
 static const struct file_operations debug_periodic_fops = {
         .owner          = THIS_MODULE,
         .open           = debug_periodic_open,
         .read           = debug_output,
         .release        = debug_close,
+        .llseek         = default_llseek,
 };
 static const struct file_operations debug_registers_fops = {
         .owner          = THIS_MODULE,
         .open           = debug_registers_open,
         .read           = debug_output,
         .release        = debug_close,
+        .llseek         = default_llseek,
 };
 
 static struct dentry *ohci_debug_root;
diff --git a/drivers/usb/host/ohci-hcd.c b/drivers/usb/host/ohci-hcd.c
index c3b4ccc7337b..f9cf3f04b742 100644
--- a/drivers/usb/host/ohci-hcd.c
+++ b/drivers/usb/host/ohci-hcd.c
@@ -1,5 +1,7 @@
 /*
- * OHCI HCD (Host Controller Driver) for USB.
+ * Open Host Controller Interface (OHCI) driver for USB.
+ *
+ * Maintainer: Alan Stern <stern@rowland.harvard.edu>
  *
  * (C) Copyright 1999 Roman Weissgaerber <weissg@vienna.at>
  * (C) Copyright 2000-2004 David Brownell <dbrownell@users.sourceforge.net>
@@ -75,6 +77,7 @@ static const char	hcd_name [] = "ohci_hcd";
 #define STATECHANGE_DELAY       msecs_to_jiffies(300)
 
 #include "ohci.h"
+#include "pci-quirks.h"
 
 static void ohci_dump (struct ohci_hcd *ohci, int verbose);
 static int ohci_init (struct ohci_hcd *ohci);
@@ -85,18 +88,8 @@ static int ohci_restart (struct ohci_hcd *ohci);
 #endif
 
 #ifdef CONFIG_PCI
-static void quirk_amd_pll(int state);
-static void amd_iso_dev_put(void);
 static void sb800_prefetch(struct ohci_hcd *ohci, int on);
 #else
-static inline void quirk_amd_pll(int state)
-{
-        return;
-}
-static inline void amd_iso_dev_put(void)
-{
-        return;
-}
 static inline void sb800_prefetch(struct ohci_hcd *ohci, int on)
 {
         return;
@@ -171,7 +164,7 @@ static int ohci_urb_enqueue (
                 // case PIPE_INTERRUPT:
                 // case PIPE_BULK:
                 default:
-                        /* one TD for every 4096 Bytes (can be upto 8K) */
+                        /* one TD for every 4096 Bytes (can be up to 8K) */
                         size += urb->transfer_buffer_length / 4096;
                         /* ... and for any remaining bytes ... */
                         if ((urb->transfer_buffer_length % 4096) != 0)
@@ -370,7 +363,6 @@ sanitize:
         }
         ep->hcpriv = NULL;
         spin_unlock_irqrestore (&ohci->lock, flags);
-        return;
 }
 
 static int ohci_get_frame (struct usb_hcd *hcd)
@@ -398,7 +390,14 @@ ohci_shutdown (struct usb_hcd *hcd)
 
         ohci = hcd_to_ohci (hcd);
         ohci_writel (ohci, OHCI_INTR_MIE, &ohci->regs->intrdisable);
-        ohci_usb_reset (ohci);
+        ohci->hc_control = ohci_readl(ohci, &ohci->regs->control);
+
+        /* If the SHUTDOWN quirk is set, don't put the controller in RESET */
+        ohci->hc_control &= (ohci->flags & OHCI_QUIRK_SHUTDOWN ?
+                        OHCI_CTRL_RWC | OHCI_CTRL_HCFS :
+                        OHCI_CTRL_RWC);
+        ohci_writel(ohci, ohci->hc_control, &ohci->regs->control);
+
         /* flush the writes */
         (void) ohci_readl (ohci, &ohci->regs->control);
 }
@@ -767,6 +766,7 @@ static irqreturn_t ohci_irq (struct usb_hcd *hcd)
         if (ints == ~(u32)0) {
                 disable (ohci);
                 ohci_dbg (ohci, "device removed!\n");
+                usb_hc_died(hcd);
                 return IRQ_HANDLED;
         }
 
@@ -774,7 +774,7 @@ static irqreturn_t ohci_irq (struct usb_hcd *hcd)
         ints &= ohci_readl(ohci, &regs->intrenable);
 
         /* interrupt for some other device? */
-        if (ints == 0)
+        if (ints == 0 || unlikely(hcd->state == HC_STATE_HALT))
                 return IRQ_NOTMINE;
 
         if (ints & OHCI_INTR_UE) {
@@ -791,6 +791,7 @@ static irqreturn_t ohci_irq (struct usb_hcd *hcd)
                 } else {
                         disable (ohci);
                         ohci_err (ohci, "OHCI Unrecoverable Error, disabled\n");
+                        usb_hc_died(hcd);
                 }
 
                 ohci_dump (ohci, 1);
@@ -895,7 +896,8 @@ static void ohci_stop (struct usb_hcd *hcd)
 
         ohci_dump (ohci, 1);
 
-        flush_scheduled_work();
+        if (quirk_nec(ohci))
+                flush_work_sync(&ohci->nec_work);
 
         ohci_usb_reset (ohci);
         ohci_writel (ohci, OHCI_INTR_MIE, &ohci->regs->intrdisable);
@@ -905,7 +907,7 @@ static void ohci_stop (struct usb_hcd *hcd)
         if (quirk_zfmicro(ohci))
                 del_timer(&ohci->unlink_watchdog);
         if (quirk_amdiso(ohci))
-                amd_iso_dev_put();
+                usb_amd_dev_put();
 
         remove_debug_files (ohci);
         ohci_mem_cleanup (ohci);
@@ -1016,11 +1018,6 @@ MODULE_LICENSE ("GPL");
 #define OMAP3_PLATFORM_DRIVER   ohci_hcd_omap3_driver
 #endif
 
-#ifdef CONFIG_ARCH_LH7A404
-#include "ohci-lh7a404.c"
-#define PLATFORM_DRIVER         ohci_hcd_lh7a404_driver
-#endif
-
 #if defined(CONFIG_PXA27x) || defined(CONFIG_PXA3xx)
 #include "ohci-pxa27x.c"
 #define PLATFORM_DRIVER         ohci_hcd_pxa27x_driver
@@ -1061,10 +1058,7 @@ MODULE_LICENSE ("GPL");
 #define PLATFORM_DRIVER         ohci_hcd_da8xx_driver
 #endif
 
-#if defined(CONFIG_CPU_SUBTYPE_SH7720) || \
-    defined(CONFIG_CPU_SUBTYPE_SH7721) || \
-    defined(CONFIG_CPU_SUBTYPE_SH7763) || \
-    defined(CONFIG_CPU_SUBTYPE_SH7786)
+#ifdef CONFIG_USB_OHCI_SH
 #include "ohci-sh.c"
 #define PLATFORM_DRIVER         ohci_hcd_sh_driver
 #endif
@@ -1075,6 +1069,11 @@ MODULE_LICENSE ("GPL");
 #define OF_PLATFORM_DRIVER      ohci_hcd_ppc_of_driver
 #endif
 
+#ifdef CONFIG_PLAT_SPEAR
+#include "ohci-spear.c"
+#define PLATFORM_DRIVER         spear_ohci_hcd_driver
+#endif
+
 #ifdef CONFIG_PPC_PS3
 #include "ohci-ps3.c"
 #define PS3_SYSTEM_BUS_DRIVER   ps3_ohci_driver
@@ -1100,6 +1099,21 @@ MODULE_LICENSE ("GPL");
 #define PLATFORM_DRIVER ohci_hcd_jz4740_driver
 #endif
 
+#ifdef CONFIG_USB_OCTEON_OHCI
+#include "ohci-octeon.c"
+#define PLATFORM_DRIVER         ohci_octeon_driver
+#endif
+
+#ifdef CONFIG_USB_CNS3XXX_OHCI
+#include "ohci-cns3xxx.c"
+#define PLATFORM_DRIVER         ohci_hcd_cns3xxx_driver
+#endif
+
+#ifdef CONFIG_USB_OHCI_ATH79
+#include "ohci-ath79.c"
+#define PLATFORM_DRIVER         ohci_hcd_ath79_driver
+#endif
+
 #if     !defined(PCI_DRIVER) &&         \
         !defined(PLATFORM_DRIVER) &&    \
         !defined(OMAP1_PLATFORM_DRIVER) &&      \
@@ -1158,7 +1172,7 @@ static int __init ohci_hcd_mod_init(void)
 #endif
 
 #ifdef OF_PLATFORM_DRIVER
-        retval = of_register_platform_driver(&OF_PLATFORM_DRIVER);
+        retval = platform_driver_register(&OF_PLATFORM_DRIVER);
         if (retval < 0)
                 goto error_of_platform;
 #endif
@@ -1217,7 +1231,7 @@ static int __init ohci_hcd_mod_init(void)
  error_sa1111:
 #endif
 #ifdef OF_PLATFORM_DRIVER
-        of_unregister_platform_driver(&OF_PLATFORM_DRIVER);
+        platform_driver_unregister(&OF_PLATFORM_DRIVER);
  error_of_platform:
 #endif
 #ifdef PLATFORM_DRIVER
@@ -1265,11 +1279,14 @@ static void __exit ohci_hcd_mod_exit(void)
         sa1111_driver_unregister(&SA1111_DRIVER);
 #endif
 #ifdef OF_PLATFORM_DRIVER
-        of_unregister_platform_driver(&OF_PLATFORM_DRIVER);
+        platform_driver_unregister(&OF_PLATFORM_DRIVER);
 #endif
 #ifdef PLATFORM_DRIVER
         platform_driver_unregister(&PLATFORM_DRIVER);
 #endif
+#ifdef OMAP3_PLATFORM_DRIVER
+        platform_driver_unregister(&OMAP3_PLATFORM_DRIVER);
+#endif
 #ifdef PS3_SYSTEM_BUS_DRIVER
         ps3_ohci_driver_unregister(&PS3_SYSTEM_BUS_DRIVER);
 #endif
diff --git a/drivers/usb/host/ohci-hub.c b/drivers/usb/host/ohci-hub.c
index cddcda95b579..9154615292db 100644
--- a/drivers/usb/host/ohci-hub.c
+++ b/drivers/usb/host/ohci-hub.c
@@ -580,15 +580,16 @@ ohci_hub_descriptor (
             temp |= 0x0008;
         desc->wHubCharacteristics = (__force __u16)cpu_to_hc16(ohci, temp);
 
-        /* two bitmaps:  ports removable, and usb 1.0 legacy PortPwrCtrlMask */
+        /* ports removable, and usb 1.0 legacy PortPwrCtrlMask */
         rh = roothub_b (ohci);
-        memset(desc->bitmap, 0xff, sizeof(desc->bitmap));
-        desc->bitmap [0] = rh & RH_B_DR;
+        memset(desc->u.hs.DeviceRemovable, 0xff,
+                        sizeof(desc->u.hs.DeviceRemovable));
+        desc->u.hs.DeviceRemovable[0] = rh & RH_B_DR;
         if (ohci->num_ports > 7) {
-                desc->bitmap [1] = (rh & RH_B_DR) >> 8;
-                desc->bitmap [2] = 0xff;
+                desc->u.hs.DeviceRemovable[1] = (rh & RH_B_DR) >> 8;
+                desc->u.hs.DeviceRemovable[2] = 0xff;
         } else
-                desc->bitmap [1] = 0xff;
+                desc->u.hs.DeviceRemovable[1] = 0xff;
 }
 
 /*-------------------------------------------------------------------------*/
diff --git a/drivers/usb/host/ohci-jz4740.c b/drivers/usb/host/ohci-jz4740.c
index 10e1872f3ab9..931d588c3fb5 100644
--- a/drivers/usb/host/ohci-jz4740.c
+++ b/drivers/usb/host/ohci-jz4740.c
@@ -273,4 +273,4 @@ static struct platform_driver ohci_hcd_jz4740_driver = {
         },
 };
 
-MODULE_ALIAS("platfrom:jz4740-ohci");
+MODULE_ALIAS("platform:jz4740-ohci");
diff --git a/drivers/usb/host/ohci-lh7a404.c b/drivers/usb/host/ohci-lh7a404.c
deleted file mode 100644
index 18d39f0463ee..000000000000
--- a/drivers/usb/host/ohci-lh7a404.c
+++ /dev/null
@@ -1,252 +0,0 @@
-/*
- * OHCI HCD (Host Controller Driver) for USB.
- *
- * (C) Copyright 1999 Roman Weissgaerber <weissg@vienna.at>
- * (C) Copyright 2000-2002 David Brownell <dbrownell@users.sourceforge.net>
- * (C) Copyright 2002 Hewlett-Packard Company
- *
- * Bus Glue for Sharp LH7A404
- *
- * Written by Christopher Hoover <ch@hpl.hp.com>
- * Based on fragments of previous driver by Russell King et al.
- *
- * Modified for LH7A404 from ohci-sa1111.c
- *  by Durgesh Pattamatta <pattamattad@sharpsec.com>
- *
- * This file is licenced under the GPL.
- */
-
-#include <linux/platform_device.h>
-#include <linux/signal.h>
-
-#include <mach/hardware.h>
-
-
-extern int usb_disabled(void);
-
-/*-------------------------------------------------------------------------*/
-
-static void lh7a404_start_hc(struct platform_device *dev)
-{
-        printk(KERN_DEBUG "%s: starting LH7A404 OHCI USB Controller\n",
-               __FILE__);
-
-        /*
-         * Now, carefully enable the USB clock, and take
-         * the USB host controller out of reset.
-         */
-        CSC_PWRCNT |= CSC_PWRCNT_USBH_EN; /* Enable clock */
-        udelay(1000);
-        USBH_CMDSTATUS = OHCI_HCR;
-
-        printk(KERN_DEBUG "%s: Clock to USB host has been enabled \n", __FILE__);
-}
-
-static void lh7a404_stop_hc(struct platform_device *dev)
-{
-        printk(KERN_DEBUG "%s: stopping LH7A404 OHCI USB Controller\n",
-               __FILE__);
-
-        CSC_PWRCNT &= ~CSC_PWRCNT_USBH_EN; /* Disable clock */
-}
-
-
-/*-------------------------------------------------------------------------*/
-
-/* configure so an HC device and id are always provided */
-/* always called with process context; sleeping is OK */
-
-
-/**
- * usb_hcd_lh7a404_probe - initialize LH7A404-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_hcd_lh7a404_probe (const struct hc_driver *driver,
-                          struct platform_device *dev)
-{
-        int retval;
-        struct usb_hcd *hcd;
-
-        if (dev->resource[1].flags != IORESOURCE_IRQ) {
-                pr_debug("resource[1] is not IORESOURCE_IRQ");
-                return -ENOMEM;
-        }
-
-        hcd = usb_create_hcd(driver, &dev->dev, "lh7a404");
-        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;
-        }
-
-        lh7a404_start_hc(dev);
-        ohci_hcd_init(hcd_to_ohci(hcd));
-
-        retval = usb_add_hcd(hcd, dev->resource[1].start, IRQF_DISABLED);
-        if (retval == 0)
-                return retval;
-
-        lh7a404_stop_hc(dev);
-        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_hcd_lh7a404_remove - shutdown processing for LH7A404-based HCDs
- * @dev: USB Host Controller being removed
- * Context: !in_interrupt()
- *
- * Reverses the effect of usb_hcd_lh7a404_probe(), first invoking
- * the HCD's stop() method.  It is always called from a thread
- * context, normally "rmmod", "apmd", or something similar.
- *
- */
-void usb_hcd_lh7a404_remove (struct usb_hcd *hcd, struct platform_device *dev)
-{
-        usb_remove_hcd(hcd);
-        lh7a404_stop_hc(dev);
-        iounmap(hcd->regs);
-        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
-        usb_put_hcd(hcd);
-}
-
-/*-------------------------------------------------------------------------*/
-
-static int __devinit
-ohci_lh7a404_start (struct usb_hcd *hcd)
-{
-        struct ohci_hcd *ohci = hcd_to_ohci (hcd);
-        int             ret;
-
-        ohci_dbg (ohci, "ohci_lh7a404_start, ohci:%p", ohci);
-        if ((ret = ohci_init(ohci)) < 0)
-                return ret;
-
-        if ((ret = ohci_run (ohci)) < 0) {
-                err ("can't start %s", hcd->self.bus_name);
-                ohci_stop (hcd);
-                return ret;
-        }
-        return 0;
-}
-
-/*-------------------------------------------------------------------------*/
-
-static const struct hc_driver ohci_lh7a404_hc_driver = {
-        .description =          hcd_name,
-        .product_desc =         "LH7A404 OHCI",
-        .hcd_priv_size =        sizeof(struct ohci_hcd),
-
-        /*
-         * generic hardware linkage
-         */
-        .irq =                  ohci_irq,
-        .flags =                HCD_USB11 | HCD_MEMORY,
-
-        /*
-         * basic lifecycle operations
-         */
-        .start =                ohci_lh7a404_start,
-        .stop =                 ohci_stop,
-        .shutdown =             ohci_shutdown,
-
-        /*
-         * managing i/o requests and associated device resources
-         */
-        .urb_enqueue =          ohci_urb_enqueue,
-        .urb_dequeue =          ohci_urb_dequeue,
-        .endpoint_disable =     ohci_endpoint_disable,
-
-        /*
-         * scheduling support
-         */
-        .get_frame_number =     ohci_get_frame,
-
-        /*
-         * root hub support
-         */
-        .hub_status_data =      ohci_hub_status_data,
-        .hub_control =          ohci_hub_control,
-#ifdef  CONFIG_PM
-        .bus_suspend =          ohci_bus_suspend,
-        .bus_resume =           ohci_bus_resume,
-#endif
-        .start_port_reset =     ohci_start_port_reset,
-};
-
-/*-------------------------------------------------------------------------*/
-
-static int ohci_hcd_lh7a404_drv_probe(struct platform_device *pdev)
-{
-        int ret;
-
-        pr_debug ("In ohci_hcd_lh7a404_drv_probe");
-
-        if (usb_disabled())
-                return -ENODEV;
-
-        ret = usb_hcd_lh7a404_probe(&ohci_lh7a404_hc_driver, pdev);
-        return ret;
-}
-
-static int ohci_hcd_lh7a404_drv_remove(struct platform_device *pdev)
-{
-        struct usb_hcd *hcd = platform_get_drvdata(pdev);
-
-        usb_hcd_lh7a404_remove(hcd, pdev);
-        return 0;
-}
-        /*TBD*/
-/*static int ohci_hcd_lh7a404_drv_suspend(struct platform_device *dev)
-{
-        struct usb_hcd *hcd = platform_get_drvdata(dev);
-
-        return 0;
-}
-static int ohci_hcd_lh7a404_drv_resume(struct platform_device *dev)
-{
-        struct usb_hcd *hcd = platform_get_drvdata(dev);
-
-
-        return 0;
-}
-*/
-
-static struct platform_driver ohci_hcd_lh7a404_driver = {
-        .probe          = ohci_hcd_lh7a404_drv_probe,
-        .remove         = ohci_hcd_lh7a404_drv_remove,
-        .shutdown       = usb_hcd_platform_shutdown,
-        /*.suspend      = ohci_hcd_lh7a404_drv_suspend, */
-        /*.resume       = ohci_hcd_lh7a404_drv_resume, */
-        .driver         = {
-                .name   = "lh7a404-ohci",
-                .owner  = THIS_MODULE,
-        },
-};
-
-MODULE_ALIAS("platform:lh7a404-ohci");
diff --git a/drivers/usb/host/ohci-octeon.c b/drivers/usb/host/ohci-octeon.c
new file mode 100644
index 000000000000..e4ddfaf8870f
--- /dev/null
+++ b/drivers/usb/host/ohci-octeon.c
@@ -0,0 +1,214 @@
+/*
+ * EHCI HCD glue for Cavium Octeon II SOCs.
+ *
+ * Loosely based on ehci-au1xxx.c
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ * Copyright (C) 2010 Cavium Networks
+ *
+ */
+
+#include <linux/platform_device.h>
+
+#include <asm/octeon/octeon.h>
+#include <asm/octeon/cvmx-uctlx-defs.h>
+
+#define OCTEON_OHCI_HCD_NAME "octeon-ohci"
+
+/* Common clock init code.  */
+void octeon2_usb_clocks_start(void);
+void octeon2_usb_clocks_stop(void);
+
+static void ohci_octeon_hw_start(void)
+{
+        union cvmx_uctlx_ohci_ctl ohci_ctl;
+
+        octeon2_usb_clocks_start();
+
+        ohci_ctl.u64 = cvmx_read_csr(CVMX_UCTLX_OHCI_CTL(0));
+        ohci_ctl.s.l2c_addr_msb = 0;
+        ohci_ctl.s.l2c_buff_emod = 1; /* Byte swapped. */
+        ohci_ctl.s.l2c_desc_emod = 1; /* Byte swapped. */
+        cvmx_write_csr(CVMX_UCTLX_OHCI_CTL(0), ohci_ctl.u64);
+
+}
+
+static void ohci_octeon_hw_stop(void)
+{
+        /* Undo ohci_octeon_start() */
+        octeon2_usb_clocks_stop();
+}
+
+static int __devinit ohci_octeon_start(struct usb_hcd *hcd)
+{
+        struct ohci_hcd *ohci = hcd_to_ohci(hcd);
+        int ret;
+
+        ret = ohci_init(ohci);
+
+        if (ret < 0)
+                return ret;
+
+        ret = ohci_run(ohci);
+
+        if (ret < 0) {
+                ohci_err(ohci, "can't start %s", hcd->self.bus_name);
+                ohci_stop(hcd);
+                return ret;
+        }
+
+        return 0;
+}
+
+static const struct hc_driver ohci_octeon_hc_driver = {
+        .description            = hcd_name,
+        .product_desc           = "Octeon OHCI",
+        .hcd_priv_size          = sizeof(struct ohci_hcd),
+
+        /*
+         * generic hardware linkage
+         */
+        .irq =                  ohci_irq,
+        .flags =                HCD_USB11 | HCD_MEMORY,
+
+        /*
+         * basic lifecycle operations
+         */
+        .start =                ohci_octeon_start,
+        .stop =                 ohci_stop,
+        .shutdown =             ohci_shutdown,
+
+        /*
+         * managing i/o requests and associated device resources
+         */
+        .urb_enqueue =          ohci_urb_enqueue,
+        .urb_dequeue =          ohci_urb_dequeue,
+        .endpoint_disable =     ohci_endpoint_disable,
+
+        /*
+         * scheduling support
+         */
+        .get_frame_number =     ohci_get_frame,
+
+        /*
+         * root hub support
+         */
+        .hub_status_data =      ohci_hub_status_data,
+        .hub_control =          ohci_hub_control,
+
+        .start_port_reset =     ohci_start_port_reset,
+};
+
+static int ohci_octeon_drv_probe(struct platform_device *pdev)
+{
+        struct usb_hcd *hcd;
+        struct ohci_hcd *ohci;
+        void *reg_base;
+        struct resource *res_mem;
+        int irq;
+        int ret;
+
+        if (usb_disabled())
+                return -ENODEV;
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0) {
+                dev_err(&pdev->dev, "No irq assigned\n");
+                return -ENODEV;
+        }
+
+        res_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (res_mem == NULL) {
+                dev_err(&pdev->dev, "No register space assigned\n");
+                return -ENODEV;
+        }
+
+        /* Ohci is a 32-bit device. */
+        pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
+        pdev->dev.dma_mask = &pdev->dev.coherent_dma_mask;
+
+        hcd = usb_create_hcd(&ohci_octeon_hc_driver, &pdev->dev, "octeon");
+        if (!hcd)
+                return -ENOMEM;
+
+        hcd->rsrc_start = res_mem->start;
+        hcd->rsrc_len = res_mem->end - res_mem->start + 1;
+
+        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len,
+                                OCTEON_OHCI_HCD_NAME)) {
+                dev_err(&pdev->dev, "request_mem_region failed\n");
+                ret = -EBUSY;
+                goto err1;
+        }
+
+        reg_base = ioremap(hcd->rsrc_start, hcd->rsrc_len);
+        if (!reg_base) {
+                dev_err(&pdev->dev, "ioremap failed\n");
+                ret = -ENOMEM;
+                goto err2;
+        }
+
+        ohci_octeon_hw_start();
+
+        hcd->regs = reg_base;
+
+        ohci = hcd_to_ohci(hcd);
+
+        /* Octeon OHCI matches CPU endianness. */
+#ifdef __BIG_ENDIAN
+        ohci->flags |= OHCI_QUIRK_BE_MMIO;
+#endif
+
+        ohci_hcd_init(ohci);
+
+        ret = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
+        if (ret) {
+                dev_dbg(&pdev->dev, "failed to add hcd with err %d\n", ret);
+                goto err3;
+        }
+
+        platform_set_drvdata(pdev, hcd);
+
+        return 0;
+
+err3:
+        ohci_octeon_hw_stop();
+
+        iounmap(hcd->regs);
+err2:
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+err1:
+        usb_put_hcd(hcd);
+        return ret;
+}
+
+static int ohci_octeon_drv_remove(struct platform_device *pdev)
+{
+        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+
+        usb_remove_hcd(hcd);
+
+        ohci_octeon_hw_stop();
+        iounmap(hcd->regs);
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+        usb_put_hcd(hcd);
+
+        platform_set_drvdata(pdev, NULL);
+
+        return 0;
+}
+
+static struct platform_driver ohci_octeon_driver = {
+        .probe          = ohci_octeon_drv_probe,
+        .remove         = ohci_octeon_drv_remove,
+        .shutdown       = usb_hcd_platform_shutdown,
+        .driver = {
+                .name   = OCTEON_OHCI_HCD_NAME,
+                .owner  = THIS_MODULE,
+        }
+};
+
+MODULE_ALIAS("platform:" OCTEON_OHCI_HCD_NAME);
diff --git a/drivers/usb/host/ohci-omap3.c b/drivers/usb/host/ohci-omap3.c
index 2cc8a504b18c..6048f2f64f73 100644
--- a/drivers/usb/host/ohci-omap3.c
+++ b/drivers/usb/host/ohci-omap3.c
@@ -7,6 +7,7 @@
  * Copyright (C) 2007-2010 Texas Instruments, Inc.
  * Author: Vikram Pandita <vikram.pandita@ti.com>
  * Author: Anand Gadiyar <gadiyar@ti.com>
+ * Author: Keshava Munegowda <keshava_mgowda@ti.com>
  *
  * Based on ehci-omap.c and some other ohci glue layers
  *
@@ -24,150 +25,15 @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  *
- * TODO (last updated Mar 10th, 2010):
+ * TODO (last updated Feb 27, 2011):
  *      - add kernel-doc
- *      - Factor out code common to EHCI to a separate file
- *      - Make EHCI and OHCI coexist together
- *        - needs newer silicon versions to actually work
- *        - the last one to be loaded currently steps on the other's toes
- *      - Add hooks for configuring transceivers, etc. at init/exit
- *      - Add aggressive clock-management code
  */
 
 #include <linux/platform_device.h>
-#include <linux/clk.h>
-
 #include <plat/usb.h>
 
-/*
- * OMAP USBHOST Register addresses: VIRTUAL ADDRESSES
- *      Use ohci_omap_readl()/ohci_omap_writel() functions
- */
-
-/* TLL Register Set */
-#define OMAP_USBTLL_REVISION                            (0x00)
-#define OMAP_USBTLL_SYSCONFIG                           (0x10)
-#define OMAP_USBTLL_SYSCONFIG_CACTIVITY                 (1 << 8)
-#define OMAP_USBTLL_SYSCONFIG_SIDLEMODE                 (1 << 3)
-#define OMAP_USBTLL_SYSCONFIG_ENAWAKEUP                 (1 << 2)
-#define OMAP_USBTLL_SYSCONFIG_SOFTRESET                 (1 << 1)
-#define OMAP_USBTLL_SYSCONFIG_AUTOIDLE                  (1 << 0)
-
-#define OMAP_USBTLL_SYSSTATUS                           (0x14)
-#define OMAP_USBTLL_SYSSTATUS_RESETDONE                 (1 << 0)
-
-#define OMAP_USBTLL_IRQSTATUS                           (0x18)
-#define OMAP_USBTLL_IRQENABLE                           (0x1C)
-
-#define OMAP_TLL_SHARED_CONF                            (0x30)
-#define OMAP_TLL_SHARED_CONF_USB_90D_DDR_EN             (1 << 6)
-#define OMAP_TLL_SHARED_CONF_USB_180D_SDR_EN            (1 << 5)
-#define OMAP_TLL_SHARED_CONF_USB_DIVRATION              (1 << 2)
-#define OMAP_TLL_SHARED_CONF_FCLK_REQ                   (1 << 1)
-#define OMAP_TLL_SHARED_CONF_FCLK_IS_ON                 (1 << 0)
-
-#define OMAP_TLL_CHANNEL_CONF(num)                      (0x040 + 0x004 * num)
-#define OMAP_TLL_CHANNEL_CONF_FSLSMODE_SHIFT            24
-#define OMAP_TLL_CHANNEL_CONF_ULPINOBITSTUFF            (1 << 11)
-#define OMAP_TLL_CHANNEL_CONF_ULPI_ULPIAUTOIDLE         (1 << 10)
-#define OMAP_TLL_CHANNEL_CONF_UTMIAUTOIDLE              (1 << 9)
-#define OMAP_TLL_CHANNEL_CONF_ULPIDDRMODE               (1 << 8)
-#define OMAP_TLL_CHANNEL_CONF_CHANMODE_FSLS             (1 << 1)
-#define OMAP_TLL_CHANNEL_CONF_CHANEN                    (1 << 0)
-
-#define OMAP_TLL_CHANNEL_COUNT                          3
-
-/* UHH Register Set */
-#define OMAP_UHH_REVISION                               (0x00)
-#define OMAP_UHH_SYSCONFIG                              (0x10)
-#define OMAP_UHH_SYSCONFIG_MIDLEMODE                    (1 << 12)
-#define OMAP_UHH_SYSCONFIG_CACTIVITY                    (1 << 8)
-#define OMAP_UHH_SYSCONFIG_SIDLEMODE                    (1 << 3)
-#define OMAP_UHH_SYSCONFIG_ENAWAKEUP                    (1 << 2)
-#define OMAP_UHH_SYSCONFIG_SOFTRESET                    (1 << 1)
-#define OMAP_UHH_SYSCONFIG_AUTOIDLE                     (1 << 0)
-
-#define OMAP_UHH_SYSSTATUS                              (0x14)
-#define OMAP_UHH_SYSSTATUS_UHHRESETDONE                 (1 << 0)
-#define OMAP_UHH_SYSSTATUS_OHCIRESETDONE                (1 << 1)
-#define OMAP_UHH_SYSSTATUS_EHCIRESETDONE                (1 << 2)
-#define OMAP_UHH_HOSTCONFIG                             (0x40)
-#define OMAP_UHH_HOSTCONFIG_ULPI_BYPASS                 (1 << 0)
-#define OMAP_UHH_HOSTCONFIG_ULPI_P1_BYPASS              (1 << 0)
-#define OMAP_UHH_HOSTCONFIG_ULPI_P2_BYPASS              (1 << 11)
-#define OMAP_UHH_HOSTCONFIG_ULPI_P3_BYPASS              (1 << 12)
-#define OMAP_UHH_HOSTCONFIG_INCR4_BURST_EN              (1 << 2)
-#define OMAP_UHH_HOSTCONFIG_INCR8_BURST_EN              (1 << 3)
-#define OMAP_UHH_HOSTCONFIG_INCR16_BURST_EN             (1 << 4)
-#define OMAP_UHH_HOSTCONFIG_INCRX_ALIGN_EN              (1 << 5)
-#define OMAP_UHH_HOSTCONFIG_P1_CONNECT_STATUS           (1 << 8)
-#define OMAP_UHH_HOSTCONFIG_P2_CONNECT_STATUS           (1 << 9)
-#define OMAP_UHH_HOSTCONFIG_P3_CONNECT_STATUS           (1 << 10)
-
-#define OMAP_UHH_DEBUG_CSR                              (0x44)
-
 /*-------------------------------------------------------------------------*/
 
-static inline void ohci_omap_writel(void __iomem *base, u32 reg, u32 val)
-{
-        __raw_writel(val, base + reg);
-}
-
-static inline u32 ohci_omap_readl(void __iomem *base, u32 reg)
-{
-        return __raw_readl(base + reg);
-}
-
-static inline void ohci_omap_writeb(void __iomem *base, u8 reg, u8 val)
-{
-        __raw_writeb(val, base + reg);
-}
-
-static inline u8 ohci_omap_readb(void __iomem *base, u8 reg)
-{
-        return __raw_readb(base + reg);
-}
-
-/*-------------------------------------------------------------------------*/
-
-struct ohci_hcd_omap3 {
-        struct ohci_hcd         *ohci;
-        struct device           *dev;
-
-        struct clk              *usbhost_ick;
-        struct clk              *usbhost2_120m_fck;
-        struct clk              *usbhost1_48m_fck;
-        struct clk              *usbtll_fck;
-        struct clk              *usbtll_ick;
-
-        /* port_mode: TLL/PHY, 2/3/4/6-PIN, DP-DM/DAT-SE0 */
-        enum ohci_omap3_port_mode       port_mode[OMAP3_HS_USB_PORTS];
-        void __iomem            *uhh_base;
-        void __iomem            *tll_base;
-        void __iomem            *ohci_base;
-
-        unsigned                es2_compatibility:1;
-};
-
-/*-------------------------------------------------------------------------*/
-
-static void ohci_omap3_clock_power(struct ohci_hcd_omap3 *omap, int on)
-{
-        if (on) {
-                clk_enable(omap->usbtll_ick);
-                clk_enable(omap->usbtll_fck);
-                clk_enable(omap->usbhost_ick);
-                clk_enable(omap->usbhost1_48m_fck);
-                clk_enable(omap->usbhost2_120m_fck);
-        } else {
-                clk_disable(omap->usbhost2_120m_fck);
-                clk_disable(omap->usbhost1_48m_fck);
-                clk_disable(omap->usbhost_ick);
-                clk_disable(omap->usbtll_fck);
-                clk_disable(omap->usbtll_ick);
-        }
-}
-
 static int ohci_omap3_init(struct usb_hcd *hcd)
 {
         dev_dbg(hcd->self.controller, "starting OHCI controller\n");
@@ -175,7 +41,6 @@ static int ohci_omap3_init(struct usb_hcd *hcd)
         return ohci_init(hcd_to_ohci(hcd));
 }
 
-
 /*-------------------------------------------------------------------------*/
 
 static int ohci_omap3_start(struct usb_hcd *hcd)
@@ -202,325 +67,6 @@ static int ohci_omap3_start(struct usb_hcd *hcd)
 
 /*-------------------------------------------------------------------------*/
 
-/*
- * convert the port-mode enum to a value we can use in the FSLSMODE
- * field of USBTLL_CHANNEL_CONF
- */
-static unsigned ohci_omap3_fslsmode(enum ohci_omap3_port_mode mode)
-{
-        switch (mode) {
-        case OMAP_OHCI_PORT_MODE_UNUSED:
-        case OMAP_OHCI_PORT_MODE_PHY_6PIN_DATSE0:
-                return 0x0;
-
-        case OMAP_OHCI_PORT_MODE_PHY_6PIN_DPDM:
-                return 0x1;
-
-        case OMAP_OHCI_PORT_MODE_PHY_3PIN_DATSE0:
-                return 0x2;
-
-        case OMAP_OHCI_PORT_MODE_PHY_4PIN_DPDM:
-                return 0x3;
-
-        case OMAP_OHCI_PORT_MODE_TLL_6PIN_DATSE0:
-                return 0x4;
-
-        case OMAP_OHCI_PORT_MODE_TLL_6PIN_DPDM:
-                return 0x5;
-
-        case OMAP_OHCI_PORT_MODE_TLL_3PIN_DATSE0:
-                return 0x6;
-
-        case OMAP_OHCI_PORT_MODE_TLL_4PIN_DPDM:
-                return 0x7;
-
-        case OMAP_OHCI_PORT_MODE_TLL_2PIN_DATSE0:
-                return 0xA;
-
-        case OMAP_OHCI_PORT_MODE_TLL_2PIN_DPDM:
-                return 0xB;
-        default:
-                pr_warning("Invalid port mode, using default\n");
-                return 0x0;
-        }
-}
-
-static void ohci_omap3_tll_config(struct ohci_hcd_omap3 *omap)
-{
-        u32 reg;
-        int i;
-
-        /* Program TLL SHARED CONF */
-        reg = ohci_omap_readl(omap->tll_base, OMAP_TLL_SHARED_CONF);
-        reg &= ~OMAP_TLL_SHARED_CONF_USB_90D_DDR_EN;
-        reg &= ~OMAP_TLL_SHARED_CONF_USB_180D_SDR_EN;
-        reg |= OMAP_TLL_SHARED_CONF_USB_DIVRATION;
-        reg |= OMAP_TLL_SHARED_CONF_FCLK_IS_ON;
-        ohci_omap_writel(omap->tll_base, OMAP_TLL_SHARED_CONF, reg);
-
-        /* Program each TLL channel */
-        /*
-         * REVISIT: Only the 3-pin and 4-pin PHY modes have
-         * actually been tested.
-         */
-        for (i = 0; i < OMAP_TLL_CHANNEL_COUNT; i++) {
-
-                /* Enable only those channels that are actually used */
-                if (omap->port_mode[i] == OMAP_OHCI_PORT_MODE_UNUSED)
-                        continue;
-
-                reg = ohci_omap_readl(omap->tll_base, OMAP_TLL_CHANNEL_CONF(i));
-                reg |= ohci_omap3_fslsmode(omap->port_mode[i])
-                                << OMAP_TLL_CHANNEL_CONF_FSLSMODE_SHIFT;
-                reg |= OMAP_TLL_CHANNEL_CONF_CHANMODE_FSLS;
-                reg |= OMAP_TLL_CHANNEL_CONF_CHANEN;
-                ohci_omap_writel(omap->tll_base, OMAP_TLL_CHANNEL_CONF(i), reg);
-        }
-}
-
-/* omap3_start_ohci
- *      - Start the TI USBHOST controller
- */
-static int omap3_start_ohci(struct ohci_hcd_omap3 *omap, struct usb_hcd *hcd)
-{
-        unsigned long timeout = jiffies + msecs_to_jiffies(1000);
-        u32 reg = 0;
-        int ret = 0;
-
-        dev_dbg(omap->dev, "starting TI OHCI USB Controller\n");
-
-        /* Get all the clock handles we need */
-        omap->usbhost_ick = clk_get(omap->dev, "usbhost_ick");
-        if (IS_ERR(omap->usbhost_ick)) {
-                dev_err(omap->dev, "could not get usbhost_ick\n");
-                ret =  PTR_ERR(omap->usbhost_ick);
-                goto err_host_ick;
-        }
-
-        omap->usbhost2_120m_fck = clk_get(omap->dev, "usbhost_120m_fck");
-        if (IS_ERR(omap->usbhost2_120m_fck)) {
-                dev_err(omap->dev, "could not get usbhost_120m_fck\n");
-                ret = PTR_ERR(omap->usbhost2_120m_fck);
-                goto err_host_120m_fck;
-        }
-
-        omap->usbhost1_48m_fck = clk_get(omap->dev, "usbhost_48m_fck");
-        if (IS_ERR(omap->usbhost1_48m_fck)) {
-                dev_err(omap->dev, "could not get usbhost_48m_fck\n");
-                ret = PTR_ERR(omap->usbhost1_48m_fck);
-                goto err_host_48m_fck;
-        }
-
-        omap->usbtll_fck = clk_get(omap->dev, "usbtll_fck");
-        if (IS_ERR(omap->usbtll_fck)) {
-                dev_err(omap->dev, "could not get usbtll_fck\n");
-                ret = PTR_ERR(omap->usbtll_fck);
-                goto err_tll_fck;
-        }
-
-        omap->usbtll_ick = clk_get(omap->dev, "usbtll_ick");
-        if (IS_ERR(omap->usbtll_ick)) {
-                dev_err(omap->dev, "could not get usbtll_ick\n");
-                ret = PTR_ERR(omap->usbtll_ick);
-                goto err_tll_ick;
-        }
-
-        /* Now enable all the clocks in the correct order */
-        ohci_omap3_clock_power(omap, 1);
-
-        /* perform TLL soft reset, and wait until reset is complete */
-        ohci_omap_writel(omap->tll_base, OMAP_USBTLL_SYSCONFIG,
-                        OMAP_USBTLL_SYSCONFIG_SOFTRESET);
-
-        /* Wait for TLL reset to complete */
-        while (!(ohci_omap_readl(omap->tll_base, OMAP_USBTLL_SYSSTATUS)
-                        & OMAP_USBTLL_SYSSTATUS_RESETDONE)) {
-                cpu_relax();
-
-                if (time_after(jiffies, timeout)) {
-                        dev_dbg(omap->dev, "operation timed out\n");
-                        ret = -EINVAL;
-                        goto err_sys_status;
-                }
-        }
-
-        dev_dbg(omap->dev, "TLL reset done\n");
-
-        /* (1<<3) = no idle mode only for initial debugging */
-        ohci_omap_writel(omap->tll_base, OMAP_USBTLL_SYSCONFIG,
-                        OMAP_USBTLL_SYSCONFIG_ENAWAKEUP |
-                        OMAP_USBTLL_SYSCONFIG_SIDLEMODE |
-                        OMAP_USBTLL_SYSCONFIG_CACTIVITY);
-
-
-        /* Put UHH in NoIdle/NoStandby mode */
-        reg = ohci_omap_readl(omap->uhh_base, OMAP_UHH_SYSCONFIG);
-        reg |= (OMAP_UHH_SYSCONFIG_ENAWAKEUP
-                        | OMAP_UHH_SYSCONFIG_SIDLEMODE
-                        | OMAP_UHH_SYSCONFIG_CACTIVITY
-                        | OMAP_UHH_SYSCONFIG_MIDLEMODE);
-        reg &= ~OMAP_UHH_SYSCONFIG_AUTOIDLE;
-        reg &= ~OMAP_UHH_SYSCONFIG_SOFTRESET;
-
-        ohci_omap_writel(omap->uhh_base, OMAP_UHH_SYSCONFIG, reg);
-
-        reg = ohci_omap_readl(omap->uhh_base, OMAP_UHH_HOSTCONFIG);
-
-        /* setup ULPI bypass and burst configurations */
-        reg |= (OMAP_UHH_HOSTCONFIG_INCR4_BURST_EN
-                        | OMAP_UHH_HOSTCONFIG_INCR8_BURST_EN
-                        | OMAP_UHH_HOSTCONFIG_INCR16_BURST_EN);
-        reg &= ~OMAP_UHH_HOSTCONFIG_INCRX_ALIGN_EN;
-
-        /*
-         * REVISIT: Pi_CONNECT_STATUS controls MStandby
-         * assertion and Swakeup generation - let us not
-         * worry about this for now. OMAP HWMOD framework
-         * might take care of this later. If not, we can
-         * update these registers when adding aggressive
-         * clock management code.
-         *
-         * For now, turn off all the Pi_CONNECT_STATUS bits
-         *
-        if (omap->port_mode[0] == OMAP_OHCI_PORT_MODE_UNUSED)
-                reg &= ~OMAP_UHH_HOSTCONFIG_P1_CONNECT_STATUS;
-        if (omap->port_mode[1] == OMAP_OHCI_PORT_MODE_UNUSED)
-                reg &= ~OMAP_UHH_HOSTCONFIG_P2_CONNECT_STATUS;
-        if (omap->port_mode[2] == OMAP_OHCI_PORT_MODE_UNUSED)
-                reg &= ~OMAP_UHH_HOSTCONFIG_P3_CONNECT_STATUS;
-         */
-        reg &= ~OMAP_UHH_HOSTCONFIG_P1_CONNECT_STATUS;
-        reg &= ~OMAP_UHH_HOSTCONFIG_P2_CONNECT_STATUS;
-        reg &= ~OMAP_UHH_HOSTCONFIG_P3_CONNECT_STATUS;
-
-         if (omap->es2_compatibility) {
-                /*
-                 * All OHCI modes need to go through the TLL,
-                 * unlike in the EHCI case. So use UTMI mode
-                 * for all ports for OHCI, on ES2.x silicon
-                 */
-                dev_dbg(omap->dev, "OMAP3 ES version <= ES2.1\n");
-                reg |= OMAP_UHH_HOSTCONFIG_ULPI_BYPASS;
-        } else {
-                dev_dbg(omap->dev, "OMAP3 ES version > ES2.1\n");
-                if (omap->port_mode[0] == OMAP_OHCI_PORT_MODE_UNUSED)
-                        reg &= ~OMAP_UHH_HOSTCONFIG_ULPI_P1_BYPASS;
-                else
-                        reg |= OMAP_UHH_HOSTCONFIG_ULPI_P1_BYPASS;
-
-                if (omap->port_mode[1] == OMAP_OHCI_PORT_MODE_UNUSED)
-                        reg &= ~OMAP_UHH_HOSTCONFIG_ULPI_P2_BYPASS;
-                else
-                        reg |= OMAP_UHH_HOSTCONFIG_ULPI_P2_BYPASS;
-
-                if (omap->port_mode[2] == OMAP_OHCI_PORT_MODE_UNUSED)
-                        reg &= ~OMAP_UHH_HOSTCONFIG_ULPI_P3_BYPASS;
-                else
-                        reg |= OMAP_UHH_HOSTCONFIG_ULPI_P3_BYPASS;
-
-        }
-        ohci_omap_writel(omap->uhh_base, OMAP_UHH_HOSTCONFIG, reg);
-        dev_dbg(omap->dev, "UHH setup done, uhh_hostconfig=%x\n", reg);
-
-        ohci_omap3_tll_config(omap);
-
-        return 0;
-
-err_sys_status:
-        ohci_omap3_clock_power(omap, 0);
-        clk_put(omap->usbtll_ick);
-
-err_tll_ick:
-        clk_put(omap->usbtll_fck);
-
-err_tll_fck:
-        clk_put(omap->usbhost1_48m_fck);
-
-err_host_48m_fck:
-        clk_put(omap->usbhost2_120m_fck);
-
-err_host_120m_fck:
-        clk_put(omap->usbhost_ick);
-
-err_host_ick:
-        return ret;
-}
-
-static void omap3_stop_ohci(struct ohci_hcd_omap3 *omap, struct usb_hcd *hcd)
-{
-        unsigned long timeout = jiffies + msecs_to_jiffies(100);
-
-        dev_dbg(omap->dev, "stopping TI EHCI USB Controller\n");
-
-        /* Reset USBHOST for insmod/rmmod to work */
-        ohci_omap_writel(omap->uhh_base, OMAP_UHH_SYSCONFIG,
-                        OMAP_UHH_SYSCONFIG_SOFTRESET);
-        while (!(ohci_omap_readl(omap->uhh_base, OMAP_UHH_SYSSTATUS)
-                                & OMAP_UHH_SYSSTATUS_UHHRESETDONE)) {
-                cpu_relax();
-
-                if (time_after(jiffies, timeout))
-                        dev_dbg(omap->dev, "operation timed out\n");
-        }
-
-        while (!(ohci_omap_readl(omap->uhh_base, OMAP_UHH_SYSSTATUS)
-                                & OMAP_UHH_SYSSTATUS_OHCIRESETDONE)) {
-                cpu_relax();
-
-                if (time_after(jiffies, timeout))
-                        dev_dbg(omap->dev, "operation timed out\n");
-        }
-
-        while (!(ohci_omap_readl(omap->uhh_base, OMAP_UHH_SYSSTATUS)
-                                & OMAP_UHH_SYSSTATUS_EHCIRESETDONE)) {
-                cpu_relax();
-
-                if (time_after(jiffies, timeout))
-                        dev_dbg(omap->dev, "operation timed out\n");
-        }
-
-        ohci_omap_writel(omap->tll_base, OMAP_USBTLL_SYSCONFIG, (1 << 1));
-
-        while (!(ohci_omap_readl(omap->tll_base, OMAP_USBTLL_SYSSTATUS)
-                                & (1 << 0))) {
-                cpu_relax();
-
-                if (time_after(jiffies, timeout))
-                        dev_dbg(omap->dev, "operation timed out\n");
-        }
-
-        ohci_omap3_clock_power(omap, 0);
-
-        if (omap->usbtll_fck != NULL) {
-                clk_put(omap->usbtll_fck);
-                omap->usbtll_fck = NULL;
-        }
-
-        if (omap->usbhost_ick != NULL) {
-                clk_put(omap->usbhost_ick);
-                omap->usbhost_ick = NULL;
-        }
-
-        if (omap->usbhost1_48m_fck != NULL) {
-                clk_put(omap->usbhost1_48m_fck);
-                omap->usbhost1_48m_fck = NULL;
-        }
-
-        if (omap->usbhost2_120m_fck != NULL) {
-                clk_put(omap->usbhost2_120m_fck);
-                omap->usbhost2_120m_fck = NULL;
-        }
-
-        if (omap->usbtll_ick != NULL) {
-                clk_put(omap->usbtll_ick);
-                omap->usbtll_ick = NULL;
-        }
-
-        dev_dbg(omap->dev, "Clock to USB host has been disabled\n");
-}
-
-/*-------------------------------------------------------------------------*/
-
 static const struct hc_driver ohci_omap3_hc_driver = {
         .description =          hcd_name,
         .product_desc =         "OMAP3 OHCI Host Controller",
@@ -580,107 +126,77 @@ static const struct hc_driver ohci_omap3_hc_driver = {
  */
 static int __devinit ohci_hcd_omap3_probe(struct platform_device *pdev)
 {
-        struct ohci_hcd_omap_platform_data *pdata = pdev->dev.platform_data;
-        struct ohci_hcd_omap3 *omap;
-        struct resource *res;
-        struct usb_hcd *hcd;
-        int ret = -ENODEV;
-        int irq;
+        struct device           *dev = &pdev->dev;
+        struct usb_hcd          *hcd = NULL;
+        void __iomem            *regs = NULL;
+        struct resource         *res;
+        int                     ret = -ENODEV;
+        int                     irq;
 
         if (usb_disabled())
-                goto err_disabled;
+                goto err_end;
 
-        if (!pdata) {
-                dev_dbg(&pdev->dev, "missing platform_data\n");
-                goto err_pdata;
+        if (!dev->parent) {
+                dev_err(dev, "Missing parent device\n");
+                return -ENODEV;
         }
 
-        irq = platform_get_irq(pdev, 0);
+        irq = platform_get_irq_byname(pdev, "ohci-irq");
+        if (irq < 0) {
+                dev_err(dev, "OHCI irq failed\n");
+                return -ENODEV;
+        }
 
-        omap = kzalloc(sizeof(*omap), GFP_KERNEL);
-        if (!omap) {
-                ret = -ENOMEM;
-                goto err_disabled;
+        res = platform_get_resource_byname(pdev,
+                                IORESOURCE_MEM, "ohci");
+        if (!ret) {
+                dev_err(dev, "UHH OHCI get resource failed\n");
+                return -ENOMEM;
         }
 
-        hcd = usb_create_hcd(&ohci_omap3_hc_driver, &pdev->dev,
-                        dev_name(&pdev->dev));
-        if (!hcd) {
-                ret = -ENOMEM;
-                goto err_create_hcd;
+        regs = ioremap(res->start, resource_size(res));
+        if (!regs) {
+                dev_err(dev, "UHH OHCI ioremap failed\n");
+                return -ENOMEM;
         }
 
-        platform_set_drvdata(pdev, omap);
-        omap->dev               = &pdev->dev;
-        omap->port_mode[0]      = pdata->port_mode[0];
-        omap->port_mode[1]      = pdata->port_mode[1];
-        omap->port_mode[2]      = pdata->port_mode[2];
-        omap->es2_compatibility = pdata->es2_compatibility;
-        omap->ohci              = hcd_to_ohci(hcd);
 
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        hcd = usb_create_hcd(&ohci_omap3_hc_driver, dev,
+                        dev_name(dev));
+        if (!hcd) {
+                dev_err(dev, "usb_create_hcd failed\n");
+                goto err_io;
+        }
 
         hcd->rsrc_start = res->start;
         hcd->rsrc_len = resource_size(res);
+        hcd->regs =  regs;
 
-        hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
-        if (!hcd->regs) {
-                dev_err(&pdev->dev, "OHCI ioremap failed\n");
-                ret = -ENOMEM;
-                goto err_ioremap;
-        }
-
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
-        omap->uhh_base = ioremap(res->start, resource_size(res));
-        if (!omap->uhh_base) {
-                dev_err(&pdev->dev, "UHH ioremap failed\n");
-                ret = -ENOMEM;
-                goto err_uhh_ioremap;
-        }
-
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 2);
-        omap->tll_base = ioremap(res->start, resource_size(res));
-        if (!omap->tll_base) {
-                dev_err(&pdev->dev, "TLL ioremap failed\n");
-                ret = -ENOMEM;
-                goto err_tll_ioremap;
-        }
-
-        ret = omap3_start_ohci(omap, hcd);
+        ret = omap_usbhs_enable(dev);
         if (ret) {
-                dev_dbg(&pdev->dev, "failed to start ehci\n");
-                goto err_start;
+                dev_dbg(dev, "failed to start ohci\n");
+                goto err_end;
         }
 
-        ohci_hcd_init(omap->ohci);
+        ohci_hcd_init(hcd_to_ohci(hcd));
 
         ret = usb_add_hcd(hcd, irq, IRQF_DISABLED);
         if (ret) {
-                dev_dbg(&pdev->dev, "failed to add hcd with err %d\n", ret);
+                dev_dbg(dev, "failed to add hcd with err %d\n", ret);
                 goto err_add_hcd;
         }
 
         return 0;
 
 err_add_hcd:
-        omap3_stop_ohci(omap, hcd);
-
-err_start:
-        iounmap(omap->tll_base);
-
-err_tll_ioremap:
-        iounmap(omap->uhh_base);
-
-err_uhh_ioremap:
-        iounmap(hcd->regs);
+        omap_usbhs_disable(dev);
 
-err_ioremap:
+err_end:
         usb_put_hcd(hcd);
 
-err_create_hcd:
-        kfree(omap);
-err_pdata:
-err_disabled:
+err_io:
+        iounmap(regs);
+
         return ret;
 }
 
@@ -699,24 +215,20 @@ err_disabled:
  */
 static int __devexit ohci_hcd_omap3_remove(struct platform_device *pdev)
 {
-        struct ohci_hcd_omap3 *omap = platform_get_drvdata(pdev);
-        struct usb_hcd *hcd = ohci_to_hcd(omap->ohci);
+        struct device *dev      = &pdev->dev;
+        struct usb_hcd *hcd     = dev_get_drvdata(dev);
 
-        usb_remove_hcd(hcd);
-        omap3_stop_ohci(omap, hcd);
         iounmap(hcd->regs);
-        iounmap(omap->tll_base);
-        iounmap(omap->uhh_base);
+        usb_remove_hcd(hcd);
+        omap_usbhs_disable(dev);
         usb_put_hcd(hcd);
-        kfree(omap);
 
         return 0;
 }
 
 static void ohci_hcd_omap3_shutdown(struct platform_device *pdev)
 {
-        struct ohci_hcd_omap3 *omap = platform_get_drvdata(pdev);
-        struct usb_hcd *hcd = ohci_to_hcd(omap->ohci);
+        struct usb_hcd *hcd = dev_get_drvdata(&pdev->dev);
 
         if (hcd->driver->shutdown)
                 hcd->driver->shutdown(hcd);
diff --git a/drivers/usb/host/ohci-pci.c b/drivers/usb/host/ohci-pci.c
index 6bdc8b25a6a1..ad8166c681e2 100644
--- a/drivers/usb/host/ohci-pci.c
+++ b/drivers/usb/host/ohci-pci.c
@@ -22,24 +22,6 @@
 #include <linux/io.h>
 
 
-/* constants used to work around PM-related transfer
- * glitches in some AMD 700 series southbridges
- */
-#define AB_REG_BAR      0xf0
-#define AB_INDX(addr)   ((addr) + 0x00)
-#define AB_DATA(addr)   ((addr) + 0x04)
-#define AX_INDXC        0X30
-#define AX_DATAC        0x34
-
-#define NB_PCIE_INDX_ADDR       0xe0
-#define NB_PCIE_INDX_DATA       0xe4
-#define PCIE_P_CNTL             0x10040
-#define BIF_NB                  0x10002
-
-static struct pci_dev *amd_smbus_dev;
-static struct pci_dev *amd_hb_dev;
-static int amd_ohci_iso_count;
-
 /*-------------------------------------------------------------------------*/
 
 static int broken_suspend(struct usb_hcd *hcd)
@@ -168,15 +150,18 @@ static int ohci_quirk_nec(struct usb_hcd *hcd)
 static int ohci_quirk_amd700(struct usb_hcd *hcd)
 {
         struct ohci_hcd *ohci = hcd_to_ohci(hcd);
-        u8 rev = 0;
+        struct pci_dev *amd_smbus_dev;
+        u8 rev;
 
-        if (!amd_smbus_dev)
-                amd_smbus_dev = pci_get_device(PCI_VENDOR_ID_ATI,
-                                PCI_DEVICE_ID_ATI_SBX00_SMBUS, NULL);
+        if (usb_amd_find_chipset_info())
+                ohci->flags |= OHCI_QUIRK_AMD_PLL;
+
+        amd_smbus_dev = pci_get_device(PCI_VENDOR_ID_ATI,
+                        PCI_DEVICE_ID_ATI_SBX00_SMBUS, NULL);
         if (!amd_smbus_dev)
                 return 0;
 
-        pci_read_config_byte(amd_smbus_dev, PCI_REVISION_ID, &rev);
+        rev = amd_smbus_dev->revision;
 
         /* SB800 needs pre-fetch fix */
         if ((rev >= 0x40) && (rev <= 0x4f)) {
@@ -184,89 +169,32 @@ static int ohci_quirk_amd700(struct usb_hcd *hcd)
                 ohci_dbg(ohci, "enabled AMD prefetch quirk\n");
         }
 
-        if ((rev > 0x3b) || (rev < 0x30)) {
-                pci_dev_put(amd_smbus_dev);
-                amd_smbus_dev = NULL;
-                return 0;
-        }
-
-        amd_ohci_iso_count++;
-
-        if (!amd_hb_dev)
-                amd_hb_dev = pci_get_device(PCI_VENDOR_ID_AMD, 0x9600, NULL);
-
-        ohci->flags |= OHCI_QUIRK_AMD_ISO;
-        ohci_dbg(ohci, "enabled AMD ISO transfers quirk\n");
+        pci_dev_put(amd_smbus_dev);
+        amd_smbus_dev = NULL;
 
         return 0;
 }
 
-/*
- * The hardware normally enables the A-link power management feature, which
- * lets the system lower the power consumption in idle states.
- *
- * Assume the system is configured to have USB 1.1 ISO transfers going
- * to or from a USB device.  Without this quirk, that stream may stutter
- * or have breaks occasionally.  For transfers going to speakers, this
- * makes a very audible mess...
- *
- * That audio playback corruption is due to the audio stream getting
- * interrupted occasionally when the link goes in lower power state
- * This USB quirk prevents the link going into that lower power state
- * during audio playback or other ISO operations.
+/* nVidia controllers continue to drive Reset signalling on the bus
+ * even after system shutdown, wasting power.  This flag tells the
+ * shutdown routine to leave the controller OPERATIONAL instead of RESET.
  */
-static void quirk_amd_pll(int on)
+static int ohci_quirk_nvidia_shutdown(struct usb_hcd *hcd)
 {
-        u32 addr;
-        u32 val;
-        u32 bit = (on > 0) ? 1 : 0;
-
-        pci_read_config_dword(amd_smbus_dev, AB_REG_BAR, &addr);
-
-        /* BIT names/meanings are NDA-protected, sorry ... */
-
-        outl(AX_INDXC, AB_INDX(addr));
-        outl(0x40, AB_DATA(addr));
-        outl(AX_DATAC, AB_INDX(addr));
-        val = inl(AB_DATA(addr));
-        val &= ~((1 << 3) | (1 << 4) | (1 << 9));
-        val |= (bit << 3) | ((!bit) << 4) | ((!bit) << 9);
-        outl(val, AB_DATA(addr));
-
-        if (amd_hb_dev) {
-                addr = PCIE_P_CNTL;
-                pci_write_config_dword(amd_hb_dev, NB_PCIE_INDX_ADDR, addr);
-
-                pci_read_config_dword(amd_hb_dev, NB_PCIE_INDX_DATA, &val);
-                val &= ~(1 | (1 << 3) | (1 << 4) | (1 << 9) | (1 << 12));
-                val |= bit | (bit << 3) | (bit << 12);
-                val |= ((!bit) << 4) | ((!bit) << 9);
-                pci_write_config_dword(amd_hb_dev, NB_PCIE_INDX_DATA, val);
-
-                addr = BIF_NB;
-                pci_write_config_dword(amd_hb_dev, NB_PCIE_INDX_ADDR, addr);
-
-                pci_read_config_dword(amd_hb_dev, NB_PCIE_INDX_DATA, &val);
-                val &= ~(1 << 8);
-                val |= bit << 8;
-                pci_write_config_dword(amd_hb_dev, NB_PCIE_INDX_DATA, val);
-        }
-}
+        struct pci_dev *pdev = to_pci_dev(hcd->self.controller);
+        struct ohci_hcd *ohci = hcd_to_ohci(hcd);
 
-static void amd_iso_dev_put(void)
-{
-        amd_ohci_iso_count--;
-        if (amd_ohci_iso_count == 0) {
-                if (amd_smbus_dev) {
-                        pci_dev_put(amd_smbus_dev);
-                        amd_smbus_dev = NULL;
-                }
-                if (amd_hb_dev) {
-                        pci_dev_put(amd_hb_dev);
-                        amd_hb_dev = NULL;
-                }
+        /* Evidently nVidia fixed their later hardware; this is a guess at
+         * the changeover point.
+         */
+#define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_USB           0x026d
+
+        if (pdev->device < PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_USB) {
+                ohci->flags |= OHCI_QUIRK_SHUTDOWN;
+                ohci_dbg(ohci, "enabled nVidia shutdown quirk\n");
         }
 
+        return 0;
 }
 
 static void sb800_prefetch(struct ohci_hcd *ohci, int on)
@@ -332,6 +260,10 @@ static const struct pci_device_id ohci_pci_quirks[] = {
                 PCI_DEVICE(PCI_VENDOR_ID_ATI, 0x4399),
                 .driver_data = (unsigned long)ohci_quirk_amd700,
         },
+        {
+                PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_ANY_ID),
+                .driver_data = (unsigned long) ohci_quirk_nvidia_shutdown,
+        },
 
         /* FIXME for some of the early AMD 760 southbridges, OHCI
          * won't work at all.  blacklist them.
diff --git a/drivers/usb/host/ohci-ppc-of.c b/drivers/usb/host/ohci-ppc-of.c
index b2c2dbf08766..1ca1821320f4 100644
--- a/drivers/usb/host/ohci-ppc-of.c
+++ b/drivers/usb/host/ohci-ppc-of.c
@@ -80,8 +80,7 @@ static const struct hc_driver ohci_ppc_of_hc_driver = {
 };
 
 
-static int __devinit
-ohci_hcd_ppc_of_probe(struct platform_device *op, const struct of_device_id *match)
+static int __devinit ohci_hcd_ppc_of_probe(struct platform_device *op)
 {
         struct device_node *dn = op->dev.of_node;
         struct usb_hcd *hcd;
@@ -201,14 +200,12 @@ static int ohci_hcd_ppc_of_remove(struct platform_device *op)
         return 0;
 }
 
-static int ohci_hcd_ppc_of_shutdown(struct platform_device *op)
+static void ohci_hcd_ppc_of_shutdown(struct platform_device *op)
 {
         struct usb_hcd *hcd = dev_get_drvdata(&op->dev);
 
         if (hcd->driver->shutdown)
                 hcd->driver->shutdown(hcd);
-
-        return 0;
 }
 
 
@@ -243,7 +240,7 @@ MODULE_DEVICE_TABLE(of, ohci_hcd_ppc_of_match);
 #endif
 
 
-static struct of_platform_driver ohci_hcd_ppc_of_driver = {
+static struct platform_driver ohci_hcd_ppc_of_driver = {
         .probe          = ohci_hcd_ppc_of_probe,
         .remove         = ohci_hcd_ppc_of_remove,
         .shutdown       = ohci_hcd_ppc_of_shutdown,
diff --git a/drivers/usb/host/ohci-pxa27x.c b/drivers/usb/host/ohci-pxa27x.c
index 418163894775..80be5472783a 100644
--- a/drivers/usb/host/ohci-pxa27x.c
+++ b/drivers/usb/host/ohci-pxa27x.c
@@ -24,6 +24,7 @@
 #include <linux/platform_device.h>
 #include <linux/clk.h>
 #include <mach/ohci.h>
+#include <mach/pxa3xx-u2d.h>
 
 /*
  * UHC: USB Host Controller (OHCI-like) register definitions
@@ -235,6 +236,9 @@ static int pxa27x_start_hc(struct pxa27x_ohci *ohci, struct device *dev)
         if (retval < 0)
                 return retval;
 
+        if (cpu_is_pxa3xx())
+                pxa3xx_u2d_start_hc(&ohci_to_hcd(&ohci->ohci)->self);
+
         uhchr = __raw_readl(ohci->mmio_base + UHCHR) & ~UHCHR_SSE;
         __raw_writel(uhchr, ohci->mmio_base + UHCHR);
         __raw_writel(UHCHIE_UPRIE | UHCHIE_RWIE, ohci->mmio_base + UHCHIE);
@@ -251,6 +255,9 @@ static void pxa27x_stop_hc(struct pxa27x_ohci *ohci, struct device *dev)
 
         inf = dev->platform_data;
 
+        if (cpu_is_pxa3xx())
+                pxa3xx_u2d_stop_hc(&ohci_to_hcd(&ohci->ohci)->self);
+
         if (inf->exit)
                 inf->exit(dev);
 
@@ -305,8 +312,10 @@ int usb_hcd_pxa27x_probe (const struct hc_driver *driver, struct platform_device
                 return PTR_ERR(usb_clk);
 
         hcd = usb_create_hcd (driver, &pdev->dev, "pxa27x");
-        if (!hcd)
-                return -ENOMEM;
+        if (!hcd) {
+                retval = -ENOMEM;
+                goto err0;
+        }
 
         r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (!r) {
@@ -361,6 +370,7 @@ int usb_hcd_pxa27x_probe (const struct hc_driver *driver, struct platform_device
         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
  err1:
         usb_put_hcd(hcd);
+ err0:
         clk_put(usb_clk);
         return retval;
 }
diff --git a/drivers/usb/host/ohci-q.c b/drivers/usb/host/ohci-q.c
index 83094d067e0f..dd24fc115e48 100644
--- a/drivers/usb/host/ohci-q.c
+++ b/drivers/usb/host/ohci-q.c
@@ -52,7 +52,7 @@ __acquires(ohci->lock)
                 ohci_to_hcd(ohci)->self.bandwidth_isoc_reqs--;
                 if (ohci_to_hcd(ohci)->self.bandwidth_isoc_reqs == 0) {
                         if (quirk_amdiso(ohci))
-                                quirk_amd_pll(1);
+                                usb_amd_quirk_pll_enable();
                         if (quirk_amdprefetch(ohci))
                                 sb800_prefetch(ohci, 0);
                 }
@@ -686,7 +686,7 @@ static void td_submit_urb (
                 }
                 if (ohci_to_hcd(ohci)->self.bandwidth_isoc_reqs == 0) {
                         if (quirk_amdiso(ohci))
-                                quirk_amd_pll(0);
+                                usb_amd_quirk_pll_disable();
                         if (quirk_amdprefetch(ohci))
                                 sb800_prefetch(ohci, 1);
                 }
diff --git a/drivers/usb/host/ohci-s3c2410.c b/drivers/usb/host/ohci-s3c2410.c
index a68af2dd55ca..7c9a4d55526b 100644
--- a/drivers/usb/host/ohci-s3c2410.c
+++ b/drivers/usb/host/ohci-s3c2410.c
@@ -56,9 +56,8 @@ static void s3c2410_start_hc(struct platform_device *dev, struct usb_hcd *hcd)
                 info->hcd       = hcd;
                 info->report_oc = s3c2410_hcd_oc;
 
-                if (info->enable_oc != NULL) {
+                if (info->enable_oc != NULL)
                         (info->enable_oc)(info, 1);
-                }
         }
 }
 
@@ -72,9 +71,8 @@ static void s3c2410_stop_hc(struct platform_device *dev)
                 info->report_oc = NULL;
                 info->hcd       = NULL;
 
-                if (info->enable_oc != NULL) {
+                if (info->enable_oc != NULL)
                         (info->enable_oc)(info, 0);
-                }
         }
 
         clk_disable(clk);
@@ -88,14 +86,14 @@ static void s3c2410_stop_hc(struct platform_device *dev)
 */
 
 static int
-ohci_s3c2410_hub_status_data (struct usb_hcd *hcd, char *buf)
+ohci_s3c2410_hub_status_data(struct usb_hcd *hcd, char *buf)
 {
         struct s3c2410_hcd_info *info = to_s3c2410_info(hcd);
         struct s3c2410_hcd_port *port;
         int orig;
         int portno;
 
-        orig  = ohci_hub_status_data (hcd, buf);
+        orig  = ohci_hub_status_data(hcd, buf);
 
         if (info == NULL)
                 return orig;
@@ -145,7 +143,7 @@ static void s3c2410_usb_set_power(struct s3c2410_hcd_info *info,
  * request.
 */
 
-static int ohci_s3c2410_hub_control (
+static int ohci_s3c2410_hub_control(
         struct usb_hcd  *hcd,
         u16             typeReq,
         u16             wValue,
@@ -199,9 +197,8 @@ static int ohci_s3c2410_hub_control (
                         dev_dbg(hcd->self.controller,
                                 "ClearPortFeature: OVER_CURRENT\n");
 
-                        if (valid_port(wIndex)) {
+                        if (valid_port(wIndex))
                                 info->port[wIndex-1].oc_status = 0;
-                        }
 
                         goto out;
 
@@ -242,8 +239,11 @@ static int ohci_s3c2410_hub_control (
                 desc->wHubCharacteristics |= cpu_to_le16(0x0001);
 
                 if (info->enable_oc) {
-                        desc->wHubCharacteristics &= ~cpu_to_le16(HUB_CHAR_OCPM);
-                        desc->wHubCharacteristics |=  cpu_to_le16(0x0008|0x0001);
+                        desc->wHubCharacteristics &= ~cpu_to_le16(
+                                HUB_CHAR_OCPM);
+                        desc->wHubCharacteristics |=  cpu_to_le16(
+                                0x0008 |
+                                0x0001);
                 }
 
                 dev_dbg(hcd->self.controller, "wHubCharacteristics after 0x%04x\n",
@@ -257,13 +257,11 @@ static int ohci_s3c2410_hub_control (
                 dev_dbg(hcd->self.controller, "GetPortStatus(%d)\n", wIndex);
 
                 if (valid_port(wIndex)) {
-                        if (info->port[wIndex-1].oc_changed) {
+                        if (info->port[wIndex-1].oc_changed)
                                 *data |= cpu_to_le32(RH_PS_OCIC);
-                        }
 
-                        if (info->port[wIndex-1].oc_status) {
+                        if (info->port[wIndex-1].oc_status)
                                 *data |= cpu_to_le32(RH_PS_POCI);
-                        }
                 }
         }
 
@@ -321,7 +319,7 @@ static void s3c2410_hcd_oc(struct s3c2410_hcd_info *info, int port_oc)
 */
 
 static void
-usb_hcd_s3c2410_remove (struct usb_hcd *hcd, struct platform_device *dev)
+usb_hcd_s3c2410_remove(struct usb_hcd *hcd, struct platform_device *dev)
 {
         usb_remove_hcd(hcd);
         s3c2410_stop_hc(dev);
@@ -339,7 +337,7 @@ usb_hcd_s3c2410_remove (struct usb_hcd *hcd, struct platform_device *dev)
  * through the hotplug entry's driver_data.
  *
  */
-static int usb_hcd_s3c2410_probe (const struct hc_driver *driver,
+static int usb_hcd_s3c2410_probe(const struct hc_driver *driver,
                                   struct platform_device *dev)
 {
         struct usb_hcd *hcd = NULL;
@@ -353,7 +351,7 @@ static int usb_hcd_s3c2410_probe (const struct hc_driver *driver,
                 return -ENOMEM;
 
         hcd->rsrc_start = dev->resource[0].start;
-        hcd->rsrc_len   = dev->resource[0].end - dev->resource[0].start + 1;
+        hcd->rsrc_len   = resource_size(&dev->resource[0]);
 
         if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
                 dev_err(&dev->dev, "request_mem_region failed\n");
@@ -364,14 +362,14 @@ static int usb_hcd_s3c2410_probe (const struct hc_driver *driver,
         clk = clk_get(&dev->dev, "usb-host");
         if (IS_ERR(clk)) {
                 dev_err(&dev->dev, "cannot get usb-host clock\n");
-                retval = -ENOENT;
+                retval = PTR_ERR(clk);
                 goto err_mem;
         }
 
         usb_clk = clk_get(&dev->dev, "usb-bus-host");
         if (IS_ERR(usb_clk)) {
                 dev_err(&dev->dev, "cannot get usb-bus-host clock\n");
-                retval = -ENOENT;
+                retval = PTR_ERR(usb_clk);
                 goto err_clk;
         }
 
@@ -411,17 +409,19 @@ static int usb_hcd_s3c2410_probe (const struct hc_driver *driver,
 /*-------------------------------------------------------------------------*/
 
 static int
-ohci_s3c2410_start (struct usb_hcd *hcd)
+ohci_s3c2410_start(struct usb_hcd *hcd)
 {
-        struct ohci_hcd *ohci = hcd_to_ohci (hcd);
+        struct ohci_hcd *ohci = hcd_to_ohci(hcd);
         int ret;
 
-        if ((ret = ohci_init(ohci)) < 0)
+        ret = ohci_init(ohci);
+        if (ret < 0)
                 return ret;
 
-        if ((ret = ohci_run (ohci)) < 0) {
-                err ("can't start %s", hcd->self.bus_name);
-                ohci_stop (hcd);
+        ret = ohci_run(ohci);
+        if (ret < 0) {
+                err("can't start %s", hcd->self.bus_name);
+                ohci_stop(hcd);
                 return ret;
         }
 
@@ -473,12 +473,12 @@ static const struct hc_driver ohci_s3c2410_hc_driver = {
 
 /* device driver */
 
-static int ohci_hcd_s3c2410_drv_probe(struct platform_device *pdev)
+static int __devinit ohci_hcd_s3c2410_drv_probe(struct platform_device *pdev)
 {
         return usb_hcd_s3c2410_probe(&ohci_s3c2410_hc_driver, pdev);
 }
 
-static int ohci_hcd_s3c2410_drv_remove(struct platform_device *pdev)
+static int __devexit ohci_hcd_s3c2410_drv_remove(struct platform_device *pdev)
 {
         struct usb_hcd *hcd = platform_get_drvdata(pdev);
 
@@ -488,7 +488,7 @@ static int ohci_hcd_s3c2410_drv_remove(struct platform_device *pdev)
 
 static struct platform_driver ohci_hcd_s3c2410_driver = {
         .probe          = ohci_hcd_s3c2410_drv_probe,
-        .remove         = ohci_hcd_s3c2410_drv_remove,
+        .remove         = __devexit_p(ohci_hcd_s3c2410_drv_remove),
         .shutdown       = usb_hcd_platform_shutdown,
         /*.suspend      = ohci_hcd_s3c2410_drv_suspend, */
         /*.resume       = ohci_hcd_s3c2410_drv_resume, */
diff --git a/drivers/usb/host/ohci-sh.c b/drivers/usb/host/ohci-sh.c
index 60f03cc7ec4f..f47867ff78c7 100644
--- a/drivers/usb/host/ohci-sh.c
+++ b/drivers/usb/host/ohci-sh.c
@@ -77,7 +77,6 @@ static const struct hc_driver ohci_sh_hc_driver = {
 
 /*-------------------------------------------------------------------------*/
 
-#define resource_len(r) (((r)->end - (r)->start) + 1)
 static int ohci_hcd_sh_probe(struct platform_device *pdev)
 {
         struct resource *res = NULL;
@@ -109,8 +108,8 @@ static int ohci_hcd_sh_probe(struct platform_device *pdev)
 
         hcd->regs = (void __iomem *)res->start;
         hcd->rsrc_start = res->start;
-        hcd->rsrc_len = resource_len(res);
-        ret = usb_add_hcd(hcd, irq, IRQF_DISABLED);
+        hcd->rsrc_len = resource_size(res);
+        ret = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
         if (ret != 0) {
                 err("Failed to add hcd");
                 usb_put_hcd(hcd);
diff --git a/drivers/usb/host/ohci-sm501.c b/drivers/usb/host/ohci-sm501.c
index cff23637cfcc..041d30f30c10 100644
--- a/drivers/usb/host/ohci-sm501.c
+++ b/drivers/usb/host/ohci-sm501.c
@@ -168,7 +168,7 @@ static int ohci_hcd_sm501_drv_probe(struct platform_device *pdev)
 
         retval = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
         if (retval)
-                goto err4;
+                goto err5;
 
         /* enable power and unmask interrupts */
 
@@ -176,6 +176,8 @@ static int ohci_hcd_sm501_drv_probe(struct platform_device *pdev)
         sm501_modify_reg(dev->parent, SM501_IRQ_MASK, 1 << 6, 0);
 
         return 0;
+err5:
+        iounmap(hcd->regs);
 err4:
         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
 err3:
diff --git a/drivers/usb/host/ohci-spear.c b/drivers/usb/host/ohci-spear.c
new file mode 100644
index 000000000000..4fd4bea9ac7a
--- /dev/null
+++ b/drivers/usb/host/ohci-spear.c
@@ -0,0 +1,240 @@
+/*
+* OHCI HCD (Host Controller Driver) for USB.
+*
+* Copyright (C) 2010 ST Microelectronics.
+* Deepak Sikri<deepak.sikri@st.com>
+*
+* Based on various ohci-*.c drivers
+*
+* This file is licensed under the terms of the GNU General Public
+* License version 2. This program is licensed "as is" without any
+* warranty of any kind, whether express or implied.
+*/
+
+#include <linux/signal.h>
+#include <linux/platform_device.h>
+#include <linux/clk.h>
+
+struct spear_ohci {
+        struct ohci_hcd ohci;
+        struct clk *clk;
+};
+
+#define to_spear_ohci(hcd)      (struct spear_ohci *)hcd_to_ohci(hcd)
+
+static void spear_start_ohci(struct spear_ohci *ohci)
+{
+        clk_enable(ohci->clk);
+}
+
+static void spear_stop_ohci(struct spear_ohci *ohci)
+{
+        clk_disable(ohci->clk);
+}
+
+static int __devinit ohci_spear_start(struct usb_hcd *hcd)
+{
+        struct ohci_hcd *ohci = hcd_to_ohci(hcd);
+        int ret;
+
+        ret = ohci_init(ohci);
+        if (ret < 0)
+                return ret;
+        ohci->regs = hcd->regs;
+
+        ret = ohci_run(ohci);
+        if (ret < 0) {
+                dev_err(hcd->self.controller, "can't start\n");
+                ohci_stop(hcd);
+                return ret;
+        }
+
+        create_debug_files(ohci);
+
+#ifdef DEBUG
+        ohci_dump(ohci, 1);
+#endif
+        return 0;
+}
+
+static const struct hc_driver ohci_spear_hc_driver = {
+        .description            = hcd_name,
+        .product_desc           = "SPEAr OHCI",
+        .hcd_priv_size          = sizeof(struct spear_ohci),
+
+        /* generic hardware linkage */
+        .irq                    = ohci_irq,
+        .flags                  = HCD_USB11 | HCD_MEMORY,
+
+        /* basic lifecycle operations */
+        .start                  = ohci_spear_start,
+        .stop                   = ohci_stop,
+        .shutdown               = ohci_shutdown,
+#ifdef  CONFIG_PM
+        .bus_suspend            = ohci_bus_suspend,
+        .bus_resume             = ohci_bus_resume,
+#endif
+
+        /* managing i/o requests and associated device resources */
+        .urb_enqueue            = ohci_urb_enqueue,
+        .urb_dequeue            = ohci_urb_dequeue,
+        .endpoint_disable       = ohci_endpoint_disable,
+
+        /* scheduling support */
+        .get_frame_number       = ohci_get_frame,
+
+        /* root hub support */
+        .hub_status_data        = ohci_hub_status_data,
+        .hub_control            = ohci_hub_control,
+
+        .start_port_reset       = ohci_start_port_reset,
+};
+
+static int spear_ohci_hcd_drv_probe(struct platform_device *pdev)
+{
+        const struct hc_driver *driver = &ohci_spear_hc_driver;
+        struct usb_hcd *hcd = NULL;
+        struct clk *usbh_clk;
+        struct spear_ohci *ohci_p;
+        struct resource *res;
+        int retval, irq;
+        int *pdata = pdev->dev.platform_data;
+        char clk_name[20] = "usbh_clk";
+
+        if (pdata == NULL)
+                return -EFAULT;
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0) {
+                retval = irq;
+                goto fail_irq_get;
+        }
+
+        if (*pdata >= 0)
+                sprintf(clk_name, "usbh.%01d_clk", *pdata);
+
+        usbh_clk = clk_get(NULL, clk_name);
+        if (IS_ERR(usbh_clk)) {
+                dev_err(&pdev->dev, "Error getting interface clock\n");
+                retval = PTR_ERR(usbh_clk);
+                goto fail_get_usbh_clk;
+        }
+
+        hcd = usb_create_hcd(driver, &pdev->dev, dev_name(&pdev->dev));
+        if (!hcd) {
+                retval = -ENOMEM;
+                goto fail_create_hcd;
+        }
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                retval = -ENODEV;
+                goto fail_request_resource;
+        }
+
+        hcd->rsrc_start = pdev->resource[0].start;
+        hcd->rsrc_len = resource_size(res);
+        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
+                dev_dbg(&pdev->dev, "request_mem_region failed\n");
+                retval = -EBUSY;
+                goto fail_request_resource;
+        }
+
+        hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
+        if (!hcd->regs) {
+                dev_dbg(&pdev->dev, "ioremap failed\n");
+                retval = -ENOMEM;
+                goto fail_ioremap;
+        }
+
+        ohci_p = (struct spear_ohci *)hcd_to_ohci(hcd);
+        ohci_p->clk = usbh_clk;
+        spear_start_ohci(ohci_p);
+        ohci_hcd_init(hcd_to_ohci(hcd));
+
+        retval = usb_add_hcd(hcd, platform_get_irq(pdev, 0), IRQF_DISABLED);
+        if (retval == 0)
+                return retval;
+
+        spear_stop_ohci(ohci_p);
+        iounmap(hcd->regs);
+fail_ioremap:
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+fail_request_resource:
+        usb_put_hcd(hcd);
+fail_create_hcd:
+        clk_put(usbh_clk);
+fail_get_usbh_clk:
+fail_irq_get:
+        dev_err(&pdev->dev, "init fail, %d\n", retval);
+
+        return retval;
+}
+
+static int spear_ohci_hcd_drv_remove(struct platform_device *pdev)
+{
+        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+        struct spear_ohci *ohci_p = to_spear_ohci(hcd);
+
+        usb_remove_hcd(hcd);
+        if (ohci_p->clk)
+                spear_stop_ohci(ohci_p);
+
+        iounmap(hcd->regs);
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+        usb_put_hcd(hcd);
+
+        if (ohci_p->clk)
+                clk_put(ohci_p->clk);
+        platform_set_drvdata(pdev, NULL);
+        return 0;
+}
+
+#if defined(CONFIG_PM)
+static int spear_ohci_hcd_drv_suspend(struct platform_device *dev,
+                pm_message_t message)
+{
+        struct usb_hcd *hcd = platform_get_drvdata(dev);
+        struct ohci_hcd *ohci = hcd_to_ohci(hcd);
+        struct spear_ohci *ohci_p = to_spear_ohci(hcd);
+
+        if (time_before(jiffies, ohci->next_statechange))
+                msleep(5);
+        ohci->next_statechange = jiffies;
+
+        spear_stop_ohci(ohci_p);
+        ohci_to_hcd(ohci)->state = HC_STATE_SUSPENDED;
+        return 0;
+}
+
+static int spear_ohci_hcd_drv_resume(struct platform_device *dev)
+{
+        struct usb_hcd *hcd = platform_get_drvdata(dev);
+        struct ohci_hcd *ohci = hcd_to_ohci(hcd);
+        struct spear_ohci *ohci_p = to_spear_ohci(hcd);
+
+        if (time_before(jiffies, ohci->next_statechange))
+                msleep(5);
+        ohci->next_statechange = jiffies;
+
+        spear_start_ohci(ohci_p);
+        ohci_finish_controller_resume(hcd);
+        return 0;
+}
+#endif
+
+/* Driver definition to register with the platform bus */
+static struct platform_driver spear_ohci_hcd_driver = {
+        .probe =        spear_ohci_hcd_drv_probe,
+        .remove =       spear_ohci_hcd_drv_remove,
+#ifdef CONFIG_PM
+        .suspend =      spear_ohci_hcd_drv_suspend,
+        .resume =       spear_ohci_hcd_drv_resume,
+#endif
+        .driver = {
+                .owner = THIS_MODULE,
+                .name = "spear-ohci",
+        },
+};
+
+MODULE_ALIAS("platform:spear-ohci");
diff --git a/drivers/usb/host/ohci-tmio.c b/drivers/usb/host/ohci-tmio.c
index 8dabe8e31d8c..3558491dd87d 100644
--- a/drivers/usb/host/ohci-tmio.c
+++ b/drivers/usb/host/ohci-tmio.c
@@ -185,7 +185,7 @@ static struct platform_driver ohci_hcd_tmio_driver;
 
 static int __devinit ohci_hcd_tmio_drv_probe(struct platform_device *dev)
 {
-        struct mfd_cell *cell = dev->dev.platform_data;
+        const struct mfd_cell *cell = mfd_get_cell(dev);
         struct resource *regs = platform_get_resource(dev, IORESOURCE_MEM, 0);
         struct resource *config = platform_get_resource(dev, IORESOURCE_MEM, 1);
         struct resource *sram = platform_get_resource(dev, IORESOURCE_MEM, 2);
@@ -274,7 +274,7 @@ static int __devexit ohci_hcd_tmio_drv_remove(struct platform_device *dev)
 {
         struct usb_hcd *hcd = platform_get_drvdata(dev);
         struct tmio_hcd *tmio = hcd_to_tmio(hcd);
-        struct mfd_cell *cell = dev->dev.platform_data;
+        const struct mfd_cell *cell = mfd_get_cell(dev);
 
         usb_remove_hcd(hcd);
         tmio_stop_hc(dev);
@@ -293,7 +293,7 @@ static int __devexit ohci_hcd_tmio_drv_remove(struct platform_device *dev)
 #ifdef CONFIG_PM
 static int ohci_hcd_tmio_drv_suspend(struct platform_device *dev, pm_message_t state)
 {
-        struct mfd_cell *cell = dev->dev.platform_data;
+        const struct mfd_cell *cell = mfd_get_cell(dev);
         struct usb_hcd *hcd = platform_get_drvdata(dev);
         struct ohci_hcd *ohci = hcd_to_ohci(hcd);
         struct tmio_hcd *tmio = hcd_to_tmio(hcd);
@@ -326,7 +326,7 @@ static int ohci_hcd_tmio_drv_suspend(struct platform_device *dev, pm_message_t s
 
 static int ohci_hcd_tmio_drv_resume(struct platform_device *dev)
 {
-        struct mfd_cell *cell = dev->dev.platform_data;
+        const struct mfd_cell *cell = mfd_get_cell(dev);
         struct usb_hcd *hcd = platform_get_drvdata(dev);
         struct ohci_hcd *ohci = hcd_to_ohci(hcd);
         struct tmio_hcd *tmio = hcd_to_tmio(hcd);
diff --git a/drivers/usb/host/ohci.h b/drivers/usb/host/ohci.h
index 5bf15fed0d9f..35e5fd640ce7 100644
--- a/drivers/usb/host/ohci.h
+++ b/drivers/usb/host/ohci.h
@@ -401,8 +401,9 @@ struct ohci_hcd {
 #define OHCI_QUIRK_NEC          0x40                    /* lost interrupts */
 #define OHCI_QUIRK_FRAME_NO     0x80                    /* no big endian frame_no shift */
 #define OHCI_QUIRK_HUB_POWER    0x100                   /* distrust firmware power/oc setup */
-#define OHCI_QUIRK_AMD_ISO      0x200                   /* ISO transfers*/
+#define OHCI_QUIRK_AMD_PLL      0x200                   /* AMD PLL quirk*/
 #define OHCI_QUIRK_AMD_PREFETCH 0x400                   /* pre-fetch for ISO transfer */
+#define OHCI_QUIRK_SHUTDOWN     0x800                   /* nVidia power bug */
         // there are also chip quirks/bugs in init logic
 
         struct work_struct      nec_work;       /* Worker for NEC quirk */
@@ -432,7 +433,7 @@ static inline int quirk_zfmicro(struct ohci_hcd *ohci)
 }
 static inline int quirk_amdiso(struct ohci_hcd *ohci)
 {
-        return ohci->flags & OHCI_QUIRK_AMD_ISO;
+        return ohci->flags & OHCI_QUIRK_AMD_PLL;
 }
 static inline int quirk_amdprefetch(struct ohci_hcd *ohci)
 {
@@ -574,18 +575,8 @@ static inline void _ohci_writel (const struct ohci_hcd *ohci,
 #endif
 }
 
-#ifdef CONFIG_ARCH_LH7A404
-/* Marc Singer: at the time this code was written, the LH7A404
- * had a problem reading the USB host registers.  This
- * implementation of the ohci_readl function performs the read
- * twice as a work-around.
- */
-#define ohci_readl(o,r)         (_ohci_readl(o,r),_ohci_readl(o,r))
-#define ohci_writel(o,v,r)      _ohci_writel(o,v,r)
-#else
 #define ohci_readl(o,r)         _ohci_readl(o,r)
 #define ohci_writel(o,v,r)      _ohci_writel(o,v,r)
-#endif
 
 
 /*-------------------------------------------------------------------------*/
diff --git a/drivers/usb/host/oxu210hp-hcd.c b/drivers/usb/host/oxu210hp-hcd.c
index d9c85a292737..5fbe997dc6df 100644
--- a/drivers/usb/host/oxu210hp-hcd.c
+++ b/drivers/usb/host/oxu210hp-hcd.c
@@ -451,9 +451,9 @@ static void ehci_hub_descriptor(struct oxu_hcd *oxu,
         temp = 1 + (ports / 8);
         desc->bDescLength = 7 + 2 * temp;
 
-        /* two bitmaps:  ports removable, and usb 1.0 legacy PortPwrCtrlMask */
-        memset(&desc->bitmap[0], 0, temp);
-        memset(&desc->bitmap[temp], 0xff, temp);
+        /* ports removable, and usb 1.0 legacy PortPwrCtrlMask */
+        memset(&desc->u.hs.DeviceRemovable[0], 0, temp);
+        memset(&desc->u.hs.DeviceRemovable[temp], 0xff, temp);
 
         temp = 0x0008;                  /* per-port overcurrent reporting */
         if (HCS_PPC(oxu->hcs_params))
@@ -544,8 +544,6 @@ static void oxu_buf_free(struct oxu_hcd *oxu, struct ehci_qtd *qtd)
         qtd->buffer = NULL;
 
         spin_unlock(&oxu->mem_lock);
-
-        return;
 }
 
 static inline void ehci_qtd_init(struct ehci_qtd *qtd, dma_addr_t dma)
@@ -571,8 +569,6 @@ static inline void oxu_qtd_free(struct oxu_hcd *oxu, struct ehci_qtd *qtd)
         oxu->qtd_used[index] = 0;
 
         spin_unlock(&oxu->mem_lock);
-
-        return;
 }
 
 static struct ehci_qtd *ehci_qtd_alloc(struct oxu_hcd *oxu)
@@ -615,8 +611,6 @@ static void oxu_qh_free(struct oxu_hcd *oxu, struct ehci_qh *qh)
         oxu->qh_used[index] = 0;
 
         spin_unlock(&oxu->mem_lock);
-
-        return;
 }
 
 static void qh_destroy(struct kref *kref)
@@ -693,8 +687,6 @@ static void oxu_murb_free(struct oxu_hcd *oxu, struct oxu_murb *murb)
         oxu->murb_used[index] = 0;
 
         spin_unlock(&oxu->mem_lock);
-
-        return;
 }
 
 static struct oxu_murb *oxu_murb_alloc(struct oxu_hcd *oxu)
@@ -1892,6 +1884,7 @@ static int enable_periodic(struct oxu_hcd *oxu)
         status = handshake(oxu, &oxu->regs->status, STS_PSS, 0, 9 * 125);
         if (status != 0) {
                 oxu_to_hcd(oxu)->state = HC_STATE_HALT;
+                usb_hc_died(oxu_to_hcd(oxu));
                 return status;
         }
 
@@ -1917,6 +1910,7 @@ static int disable_periodic(struct oxu_hcd *oxu)
         status = handshake(oxu, &oxu->regs->status, STS_PSS, STS_PSS, 9 * 125);
         if (status != 0) {
                 oxu_to_hcd(oxu)->state = HC_STATE_HALT;
+                usb_hc_died(oxu_to_hcd(oxu));
                 return status;
         }
 
@@ -2457,8 +2451,9 @@ static irqreturn_t oxu210_hcd_irq(struct usb_hcd *hcd)
                 goto dead;
         }
 
+        /* Shared IRQ? */
         status &= INTR_MASK;
-        if (!status) {                  /* irq sharing? */
+        if (!status || unlikely(hcd->state == HC_STATE_HALT)) {
                 spin_unlock(&oxu->lock);
                 return IRQ_NONE;
         }
@@ -2524,6 +2519,7 @@ static irqreturn_t oxu210_hcd_irq(struct usb_hcd *hcd)
 dead:
                         ehci_reset(oxu);
                         writel(0, &oxu->regs->configured_flag);
+                        usb_hc_died(hcd);
                         /* generic layer kills/unlinks all urbs, then
                          * uses oxu_stop to clean up the rest
                          */
@@ -2887,7 +2883,7 @@ static int oxu_urb_enqueue(struct usb_hcd *hcd, struct urb *urb,
         /* Ok, we have more job to do! :) */
 
         for (i = 0; i < num - 1; i++) {
-                /* Get free micro URB poll till a free urb is recieved */
+                /* Get free micro URB poll till a free urb is received */
 
                 do {
                         murb = (struct urb *) oxu_murb_alloc(oxu);
@@ -2919,7 +2915,7 @@ static int oxu_urb_enqueue(struct usb_hcd *hcd, struct urb *urb,
 
         /* Last urb requires special handling  */
 
-        /* Get free micro URB poll till a free urb is recieved */
+        /* Get free micro URB poll till a free urb is received */
         do {
                 murb = (struct urb *) oxu_murb_alloc(oxu);
                 if (!murb)
@@ -3070,7 +3066,6 @@ nogood:
         ep->hcpriv = NULL;
 done:
         spin_unlock_irqrestore(&oxu->lock, flags);
-        return;
 }
 
 static int oxu_get_frame(struct usb_hcd *hcd)
@@ -3103,7 +3098,7 @@ static int oxu_hub_status_data(struct usb_hcd *hcd, char *buf)
 
         /* Some boards (mostly VIA?) report bogus overcurrent indications,
          * causing massive log spam unless we completely ignore them.  It
-         * may be relevant that VIA VT8235 controlers, where PORT_POWER is
+         * may be relevant that VIA VT8235 controllers, where PORT_POWER is
          * always set, seem to clear PORT_OCC and PORT_CSC when writing to
          * PORT_POWER; that's surprising, but maybe within-spec.
          */
@@ -3696,7 +3691,7 @@ static void oxu_configuration(struct platform_device *pdev, void *base)
 static int oxu_verify_id(struct platform_device *pdev, void *base)
 {
         u32 id;
-        char *bo[] = {
+        static const char * const bo[] = {
                 "reserved",
                 "128-pin LQFP",
                 "84-pin TFBGA",
@@ -3841,7 +3836,7 @@ static int oxu_drv_probe(struct platform_device *pdev)
                 return -EBUSY;
         }
 
-        ret = set_irq_type(irq, IRQF_TRIGGER_FALLING);
+        ret = irq_set_irq_type(irq, IRQF_TRIGGER_FALLING);
         if (ret) {
                 dev_err(&pdev->dev, "error setting irq type\n");
                 ret = -EFAULT;
diff --git a/drivers/usb/host/pci-quirks.c b/drivers/usb/host/pci-quirks.c
index 83b5f9cea85a..fd930618c28f 100644
--- a/drivers/usb/host/pci-quirks.c
+++ b/drivers/usb/host/pci-quirks.c
@@ -14,6 +14,7 @@
 #include <linux/init.h>
 #include <linux/delay.h>
 #include <linux/acpi.h>
+#include <linux/dmi.h>
 #include "pci-quirks.h"
 #include "xhci-ext-caps.h"
 
@@ -52,6 +53,298 @@
 #define EHCI_USBLEGCTLSTS       4               /* legacy control/status */
 #define EHCI_USBLEGCTLSTS_SOOE  (1 << 13)       /* SMI on ownership change */
 
+/* AMD quirk use */
+#define AB_REG_BAR_LOW          0xe0
+#define AB_REG_BAR_HIGH         0xe1
+#define AB_REG_BAR_SB700        0xf0
+#define AB_INDX(addr)           ((addr) + 0x00)
+#define AB_DATA(addr)           ((addr) + 0x04)
+#define AX_INDXC                0x30
+#define AX_DATAC                0x34
+
+#define NB_PCIE_INDX_ADDR       0xe0
+#define NB_PCIE_INDX_DATA       0xe4
+#define PCIE_P_CNTL             0x10040
+#define BIF_NB                  0x10002
+#define NB_PIF0_PWRDOWN_0       0x01100012
+#define NB_PIF0_PWRDOWN_1       0x01100013
+
+#define USB_INTEL_XUSB2PR      0xD0
+#define USB_INTEL_USB3_PSSEN   0xD8
+
+static struct amd_chipset_info {
+        struct pci_dev  *nb_dev;
+        struct pci_dev  *smbus_dev;
+        int nb_type;
+        int sb_type;
+        int isoc_reqs;
+        int probe_count;
+        int probe_result;
+} amd_chipset;
+
+static DEFINE_SPINLOCK(amd_lock);
+
+int usb_amd_find_chipset_info(void)
+{
+        u8 rev = 0;
+        unsigned long flags;
+        struct amd_chipset_info info;
+        int ret;
+
+        spin_lock_irqsave(&amd_lock, flags);
+
+        /* probe only once */
+        if (amd_chipset.probe_count > 0) {
+                amd_chipset.probe_count++;
+                spin_unlock_irqrestore(&amd_lock, flags);
+                return amd_chipset.probe_result;
+        }
+        memset(&info, 0, sizeof(info));
+        spin_unlock_irqrestore(&amd_lock, flags);
+
+        info.smbus_dev = pci_get_device(PCI_VENDOR_ID_ATI, 0x4385, NULL);
+        if (info.smbus_dev) {
+                rev = info.smbus_dev->revision;
+                if (rev >= 0x40)
+                        info.sb_type = 1;
+                else if (rev >= 0x30 && rev <= 0x3b)
+                        info.sb_type = 3;
+        } else {
+                info.smbus_dev = pci_get_device(PCI_VENDOR_ID_AMD,
+                                                0x780b, NULL);
+                if (!info.smbus_dev) {
+                        ret = 0;
+                        goto commit;
+                }
+
+                rev = info.smbus_dev->revision;
+                if (rev >= 0x11 && rev <= 0x18)
+                        info.sb_type = 2;
+        }
+
+        if (info.sb_type == 0) {
+                if (info.smbus_dev) {
+                        pci_dev_put(info.smbus_dev);
+                        info.smbus_dev = NULL;
+                }
+                ret = 0;
+                goto commit;
+        }
+
+        info.nb_dev = pci_get_device(PCI_VENDOR_ID_AMD, 0x9601, NULL);
+        if (info.nb_dev) {
+                info.nb_type = 1;
+        } else {
+                info.nb_dev = pci_get_device(PCI_VENDOR_ID_AMD, 0x1510, NULL);
+                if (info.nb_dev) {
+                        info.nb_type = 2;
+                } else {
+                        info.nb_dev = pci_get_device(PCI_VENDOR_ID_AMD,
+                                                     0x9600, NULL);
+                        if (info.nb_dev)
+                                info.nb_type = 3;
+                }
+        }
+
+        ret = info.probe_result = 1;
+        printk(KERN_DEBUG "QUIRK: Enable AMD PLL fix\n");
+
+commit:
+
+        spin_lock_irqsave(&amd_lock, flags);
+        if (amd_chipset.probe_count > 0) {
+                /* race - someone else was faster - drop devices */
+
+                /* Mark that we where here */
+                amd_chipset.probe_count++;
+                ret = amd_chipset.probe_result;
+
+                spin_unlock_irqrestore(&amd_lock, flags);
+
+                if (info.nb_dev)
+                        pci_dev_put(info.nb_dev);
+                if (info.smbus_dev)
+                        pci_dev_put(info.smbus_dev);
+
+        } else {
+                /* no race - commit the result */
+                info.probe_count++;
+                amd_chipset = info;
+                spin_unlock_irqrestore(&amd_lock, flags);
+        }
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(usb_amd_find_chipset_info);
+
+/*
+ * The hardware normally enables the A-link power management feature, which
+ * lets the system lower the power consumption in idle states.
+ *
+ * This USB quirk prevents the link going into that lower power state
+ * during isochronous transfers.
+ *
+ * Without this quirk, isochronous stream on OHCI/EHCI/xHCI controllers of
+ * some AMD platforms may stutter or have breaks occasionally.
+ */
+static void usb_amd_quirk_pll(int disable)
+{
+        u32 addr, addr_low, addr_high, val;
+        u32 bit = disable ? 0 : 1;
+        unsigned long flags;
+
+        spin_lock_irqsave(&amd_lock, flags);
+
+        if (disable) {
+                amd_chipset.isoc_reqs++;
+                if (amd_chipset.isoc_reqs > 1) {
+                        spin_unlock_irqrestore(&amd_lock, flags);
+                        return;
+                }
+        } else {
+                amd_chipset.isoc_reqs--;
+                if (amd_chipset.isoc_reqs > 0) {
+                        spin_unlock_irqrestore(&amd_lock, flags);
+                        return;
+                }
+        }
+
+        if (amd_chipset.sb_type == 1 || amd_chipset.sb_type == 2) {
+                outb_p(AB_REG_BAR_LOW, 0xcd6);
+                addr_low = inb_p(0xcd7);
+                outb_p(AB_REG_BAR_HIGH, 0xcd6);
+                addr_high = inb_p(0xcd7);
+                addr = addr_high << 8 | addr_low;
+
+                outl_p(0x30, AB_INDX(addr));
+                outl_p(0x40, AB_DATA(addr));
+                outl_p(0x34, AB_INDX(addr));
+                val = inl_p(AB_DATA(addr));
+        } else if (amd_chipset.sb_type == 3) {
+                pci_read_config_dword(amd_chipset.smbus_dev,
+                                        AB_REG_BAR_SB700, &addr);
+                outl(AX_INDXC, AB_INDX(addr));
+                outl(0x40, AB_DATA(addr));
+                outl(AX_DATAC, AB_INDX(addr));
+                val = inl(AB_DATA(addr));
+        } else {
+                spin_unlock_irqrestore(&amd_lock, flags);
+                return;
+        }
+
+        if (disable) {
+                val &= ~0x08;
+                val |= (1 << 4) | (1 << 9);
+        } else {
+                val |= 0x08;
+                val &= ~((1 << 4) | (1 << 9));
+        }
+        outl_p(val, AB_DATA(addr));
+
+        if (!amd_chipset.nb_dev) {
+                spin_unlock_irqrestore(&amd_lock, flags);
+                return;
+        }
+
+        if (amd_chipset.nb_type == 1 || amd_chipset.nb_type == 3) {
+                addr = PCIE_P_CNTL;
+                pci_write_config_dword(amd_chipset.nb_dev,
+                                        NB_PCIE_INDX_ADDR, addr);
+                pci_read_config_dword(amd_chipset.nb_dev,
+                                        NB_PCIE_INDX_DATA, &val);
+
+                val &= ~(1 | (1 << 3) | (1 << 4) | (1 << 9) | (1 << 12));
+                val |= bit | (bit << 3) | (bit << 12);
+                val |= ((!bit) << 4) | ((!bit) << 9);
+                pci_write_config_dword(amd_chipset.nb_dev,
+                                        NB_PCIE_INDX_DATA, val);
+
+                addr = BIF_NB;
+                pci_write_config_dword(amd_chipset.nb_dev,
+                                        NB_PCIE_INDX_ADDR, addr);
+                pci_read_config_dword(amd_chipset.nb_dev,
+                                        NB_PCIE_INDX_DATA, &val);
+                val &= ~(1 << 8);
+                val |= bit << 8;
+
+                pci_write_config_dword(amd_chipset.nb_dev,
+                                        NB_PCIE_INDX_DATA, val);
+        } else if (amd_chipset.nb_type == 2) {
+                addr = NB_PIF0_PWRDOWN_0;
+                pci_write_config_dword(amd_chipset.nb_dev,
+                                        NB_PCIE_INDX_ADDR, addr);
+                pci_read_config_dword(amd_chipset.nb_dev,
+                                        NB_PCIE_INDX_DATA, &val);
+                if (disable)
+                        val &= ~(0x3f << 7);
+                else
+                        val |= 0x3f << 7;
+
+                pci_write_config_dword(amd_chipset.nb_dev,
+                                        NB_PCIE_INDX_DATA, val);
+
+                addr = NB_PIF0_PWRDOWN_1;
+                pci_write_config_dword(amd_chipset.nb_dev,
+                                        NB_PCIE_INDX_ADDR, addr);
+                pci_read_config_dword(amd_chipset.nb_dev,
+                                        NB_PCIE_INDX_DATA, &val);
+                if (disable)
+                        val &= ~(0x3f << 7);
+                else
+                        val |= 0x3f << 7;
+
+                pci_write_config_dword(amd_chipset.nb_dev,
+                                        NB_PCIE_INDX_DATA, val);
+        }
+
+        spin_unlock_irqrestore(&amd_lock, flags);
+        return;
+}
+
+void usb_amd_quirk_pll_disable(void)
+{
+        usb_amd_quirk_pll(1);
+}
+EXPORT_SYMBOL_GPL(usb_amd_quirk_pll_disable);
+
+void usb_amd_quirk_pll_enable(void)
+{
+        usb_amd_quirk_pll(0);
+}
+EXPORT_SYMBOL_GPL(usb_amd_quirk_pll_enable);
+
+void usb_amd_dev_put(void)
+{
+        struct pci_dev *nb, *smbus;
+        unsigned long flags;
+
+        spin_lock_irqsave(&amd_lock, flags);
+
+        amd_chipset.probe_count--;
+        if (amd_chipset.probe_count > 0) {
+                spin_unlock_irqrestore(&amd_lock, flags);
+                return;
+        }
+
+        /* save them to pci_dev_put outside of spinlock */
+        nb    = amd_chipset.nb_dev;
+        smbus = amd_chipset.smbus_dev;
+
+        amd_chipset.nb_dev = NULL;
+        amd_chipset.smbus_dev = NULL;
+        amd_chipset.nb_type = 0;
+        amd_chipset.sb_type = 0;
+        amd_chipset.isoc_reqs = 0;
+        amd_chipset.probe_result = 0;
+
+        spin_unlock_irqrestore(&amd_lock, flags);
+
+        if (nb)
+                pci_dev_put(nb);
+        if (smbus)
+                pci_dev_put(smbus);
+}
+EXPORT_SYMBOL_GPL(usb_amd_dev_put);
 
 /*
  * Make sure the controller is completely inactive, unable to
@@ -169,6 +462,7 @@ static int __devinit mmio_resource_enabled(struct pci_dev *pdev, int idx)
 static void __devinit quirk_usb_handoff_ohci(struct pci_dev *pdev)
 {
         void __iomem *base;
+        u32 control;
 
         if (!mmio_resource_enabled(pdev, 0))
                 return;
@@ -177,10 +471,14 @@ static void __devinit quirk_usb_handoff_ohci(struct pci_dev *pdev)
         if (base == NULL)
                 return;
 
+        control = readl(base + OHCI_CONTROL);
+
 /* On PA-RISC, PDC can leave IR set incorrectly; ignore it there. */
-#ifndef __hppa__
-{
-        u32 control = readl(base + OHCI_CONTROL);
+#ifdef __hppa__
+#define OHCI_CTRL_MASK          (OHCI_CTRL_RWC | OHCI_CTRL_IR)
+#else
+#define OHCI_CTRL_MASK          OHCI_CTRL_RWC
+
         if (control & OHCI_CTRL_IR) {
                 int wait_time = 500; /* arbitrary; 5 seconds */
                 writel(OHCI_INTR_OC, base + OHCI_INTRENABLE);
@@ -194,13 +492,12 @@ static void __devinit quirk_usb_handoff_ohci(struct pci_dev *pdev)
                         dev_warn(&pdev->dev, "OHCI: BIOS handoff failed"
                                         " (BIOS bug?) %08x\n",
                                         readl(base + OHCI_CONTROL));
-
-                /* reset controller, preserving RWC */
-                writel(control & OHCI_CTRL_RWC, base + OHCI_CONTROL);
         }
-}
 #endif
 
+        /* reset controller, preserving RWC (and possibly IR) */
+        writel(control & OHCI_CTRL_MASK, base + OHCI_CONTROL);
+
         /*
          * disable interrupts
          */
@@ -210,14 +507,84 @@ static void __devinit quirk_usb_handoff_ohci(struct pci_dev *pdev)
         iounmap(base);
 }
 
+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. */
+        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"))
+                        try_handoff = 0;
+        }
+
+        if (try_handoff && (cap & EHCI_USBLEGSUP_BIOS)) {
+                dev_dbg(&pdev->dev, "EHCI: BIOS handoff\n");
+
+#if 0
+/* aleksey_gorelov@phoenix.com reports that some systems need SMI forced on,
+ * but that seems dubious in general (the BIOS left it off intentionally)
+ * and is known to prevent some systems from booting.  so we won't do this
+ * unless maybe we can determine when we're on a system that needs SMI forced.
+ */
+                /* BIOS workaround (?): be sure the pre-Linux code
+                 * receives the SMI
+                 */
+                pci_read_config_dword(pdev, offset + EHCI_USBLEGCTLSTS, &val);
+                pci_write_config_dword(pdev, offset + EHCI_USBLEGCTLSTS,
+                                       val | EHCI_USBLEGCTLSTS_SOOE);
+#endif
+
+                /* some systems get upset if this semaphore is
+                 * set for any other reason than forcing a BIOS
+                 * handoff..
+                 */
+                pci_write_config_byte(pdev, offset + 3, 1);
+        }
+
+        /* if boot firmware now owns EHCI, spin till it hands it over. */
+        if (try_handoff) {
+                int msec = 1000;
+                while ((cap & EHCI_USBLEGSUP_BIOS) && (msec > 0)) {
+                        tried_handoff = 1;
+                        msleep(10);
+                        msec -= 10;
+                        pci_read_config_dword(pdev, offset, &cap);
+                }
+        }
+
+        if (cap & EHCI_USBLEGSUP_BIOS) {
+                /* well, possibly buggy BIOS... try to shut it down,
+                 * and hope nothing goes too wrong
+                 */
+                if (try_handoff)
+                        dev_warn(&pdev->dev, "EHCI: BIOS handoff failed"
+                                 " (BIOS bug?) %08x\n", cap);
+                pci_write_config_byte(pdev, offset + 2, 0);
+        }
+
+        /* just in case, always disable EHCI SMIs */
+        pci_write_config_dword(pdev, offset + EHCI_USBLEGCTLSTS, 0);
+
+        /* If the BIOS ever owned the controller then we can't expect
+         * any power sessions to remain intact.
+         */
+        if (tried_handoff)
+                writel(0, op_reg_base + EHCI_CONFIGFLAG);
+}
+
 static void __devinit quirk_usb_disable_ehci(struct pci_dev *pdev)
 {
-        int wait_time, delta;
         void __iomem *base, *op_reg_base;
-        u32     hcc_params, val;
+        u32     hcc_params, cap, val;
         u8      offset, cap_length;
-        int     count = 256/4;
-        int     tried_handoff = 0;
+        int     wait_time, delta, count = 256/4;
 
         if (!mmio_resource_enabled(pdev, 0))
                 return;
@@ -236,77 +603,17 @@ static void __devinit quirk_usb_disable_ehci(struct pci_dev *pdev)
         hcc_params = readl(base + EHCI_HCC_PARAMS);
         offset = (hcc_params >> 8) & 0xff;
         while (offset && --count) {
-                u32             cap;
-                int             msec;
-
                 pci_read_config_dword(pdev, offset, &cap);
-                switch (cap & 0xff) {
-                case 1:                 /* BIOS/SMM/... handoff support */
-                        if ((cap & EHCI_USBLEGSUP_BIOS)) {
-                                dev_dbg(&pdev->dev, "EHCI: BIOS handoff\n");
 
-#if 0
-/* aleksey_gorelov@phoenix.com reports that some systems need SMI forced on,
- * but that seems dubious in general (the BIOS left it off intentionally)
- * and is known to prevent some systems from booting.  so we won't do this
- * unless maybe we can determine when we're on a system that needs SMI forced.
- */
-                                /* BIOS workaround (?): be sure the
-                                 * pre-Linux code receives the SMI
-                                 */
-                                pci_read_config_dword(pdev,
-                                                offset + EHCI_USBLEGCTLSTS,
-                                                &val);
-                                pci_write_config_dword(pdev,
-                                                offset + EHCI_USBLEGCTLSTS,
-                                                val | EHCI_USBLEGCTLSTS_SOOE);
-#endif
-
-                                /* some systems get upset if this semaphore is
-                                 * set for any other reason than forcing a BIOS
-                                 * handoff..
-                                 */
-                                pci_write_config_byte(pdev, offset + 3, 1);
-                        }
-
-                        /* if boot firmware now owns EHCI, spin till
-                         * it hands it over.
-                         */
-                        msec = 1000;
-                        while ((cap & EHCI_USBLEGSUP_BIOS) && (msec > 0)) {
-                                tried_handoff = 1;
-                                msleep(10);
-                                msec -= 10;
-                                pci_read_config_dword(pdev, offset, &cap);
-                        }
-
-                        if (cap & EHCI_USBLEGSUP_BIOS) {
-                                /* well, possibly buggy BIOS... try to shut
-                                 * it down, and hope nothing goes too wrong
-                                 */
-                                dev_warn(&pdev->dev, "EHCI: BIOS handoff failed"
-                                                " (BIOS bug?) %08x\n", cap);
-                                pci_write_config_byte(pdev, offset + 2, 0);
-                        }
-
-                        /* just in case, always disable EHCI SMIs */
-                        pci_write_config_dword(pdev,
-                                        offset + EHCI_USBLEGCTLSTS,
-                                        0);
-
-                        /* If the BIOS ever owned the controller then we
-                         * can't expect any power sessions to remain intact.
-                         */
-                        if (tried_handoff)
-                                writel(0, op_reg_base + EHCI_CONFIGFLAG);
+                switch (cap & 0xff) {
+                case 1:
+                        ehci_bios_handoff(pdev, op_reg_base, cap, offset);
                         break;
-                case 0:                 /* illegal reserved capability */
-                        cap = 0;
-                        /* FALLTHROUGH */
+                case 0: /* Illegal reserved cap, set cap=0 so we exit */
+                        cap = 0; /* then fallthrough... */
                 default:
                         dev_warn(&pdev->dev, "EHCI: unrecognized capability "
-                                        "%02x\n", cap & 0xff);
-                        break;
+                                 "%02x\n", cap & 0xff);
                 }
                 offset = (cap >> 8) & 0xff;
         }
@@ -338,8 +645,6 @@ static void __devinit quirk_usb_disable_ehci(struct pci_dev *pdev)
         writel(0x3f, op_reg_base + EHCI_USBSTS);
 
         iounmap(base);
-
-        return;
 }
 
 /*
@@ -371,6 +676,64 @@ static int handshake(void __iomem *ptr, u32 mask, u32 done,
         return -ETIMEDOUT;
 }
 
+bool usb_is_intel_switchable_xhci(struct pci_dev *pdev)
+{
+        return pdev->class == PCI_CLASS_SERIAL_USB_XHCI &&
+                pdev->vendor == PCI_VENDOR_ID_INTEL &&
+                pdev->device == PCI_DEVICE_ID_INTEL_PANTHERPOINT_XHCI;
+}
+EXPORT_SYMBOL_GPL(usb_is_intel_switchable_xhci);
+
+/*
+ * Intel's Panther Point chipset has two host controllers (EHCI and xHCI) that
+ * share some number of ports.  These ports can be switched between either
+ * controller.  Not all of the ports under the EHCI host controller may be
+ * switchable.
+ *
+ * The ports should be switched over to xHCI before PCI probes for any device
+ * start.  This avoids active devices under EHCI being disconnected during the
+ * port switchover, which could cause loss of data on USB storage devices, or
+ * failed boot when the root file system is on a USB mass storage device and is
+ * enumerated under EHCI first.
+ *
+ * We write into the xHC's PCI configuration space in some Intel-specific
+ * registers to switch the ports over.  The USB 3.0 terminations and the USB
+ * 2.0 data wires are switched separately.  We want to enable the SuperSpeed
+ * terminations before switching the USB 2.0 wires over, so that USB 3.0
+ * devices connect at SuperSpeed, rather than at USB 2.0 speeds.
+ */
+void usb_enable_xhci_ports(struct pci_dev *xhci_pdev)
+{
+        u32             ports_available;
+
+        ports_available = 0xffffffff;
+        /* Write USB3_PSSEN, the USB 3.0 Port SuperSpeed Enable
+         * Register, to turn on SuperSpeed terminations for all
+         * available ports.
+         */
+        pci_write_config_dword(xhci_pdev, USB_INTEL_USB3_PSSEN,
+                        cpu_to_le32(ports_available));
+
+        pci_read_config_dword(xhci_pdev, USB_INTEL_USB3_PSSEN,
+                        &ports_available);
+        dev_dbg(&xhci_pdev->dev, "USB 3.0 ports that are now enabled "
+                        "under xHCI: 0x%x\n", ports_available);
+
+        ports_available = 0xffffffff;
+        /* Write XUSB2PR, the xHC USB 2.0 Port Routing Register, to
+         * switch the USB 2.0 power and data lines over to the xHCI
+         * host.
+         */
+        pci_write_config_dword(xhci_pdev, USB_INTEL_XUSB2PR,
+                        cpu_to_le32(ports_available));
+
+        pci_read_config_dword(xhci_pdev, USB_INTEL_XUSB2PR,
+                        &ports_available);
+        dev_dbg(&xhci_pdev->dev, "USB 2.0 ports that are now switched over "
+                        "to xHCI: 0x%x\n", ports_available);
+}
+EXPORT_SYMBOL_GPL(usb_enable_xhci_ports);
+
 /**
  * PCI Quirks for xHCI.
  *
@@ -430,6 +793,8 @@ static void __devinit quirk_usb_handoff_xhci(struct pci_dev *pdev)
         writel(XHCI_LEGACY_DISABLE_SMI,
                         base + ext_cap_offset + XHCI_LEGACY_CONTROL_OFFSET);
 
+        if (usb_is_intel_switchable_xhci(pdev))
+                usb_enable_xhci_ports(pdev);
 hc_init:
         op_reg_base = base + XHCI_HC_LENGTH(readl(base));
 
diff --git a/drivers/usb/host/pci-quirks.h b/drivers/usb/host/pci-quirks.h
index 1564edfff6fe..b1002a8ef96f 100644
--- a/drivers/usb/host/pci-quirks.h
+++ b/drivers/usb/host/pci-quirks.h
@@ -1,7 +1,19 @@
 #ifndef __LINUX_USB_PCI_QUIRKS_H
 #define __LINUX_USB_PCI_QUIRKS_H
 
+#ifdef CONFIG_PCI
 void uhci_reset_hc(struct pci_dev *pdev, unsigned long base);
 int uhci_check_and_reset_hc(struct pci_dev *pdev, unsigned long base);
+int usb_amd_find_chipset_info(void);
+void usb_amd_dev_put(void);
+void usb_amd_quirk_pll_disable(void);
+void usb_amd_quirk_pll_enable(void);
+bool usb_is_intel_switchable_xhci(struct pci_dev *pdev);
+void usb_enable_xhci_ports(struct pci_dev *xhci_pdev);
+#else
+static inline void usb_amd_quirk_pll_disable(void) {}
+static inline void usb_amd_quirk_pll_enable(void) {}
+static inline void usb_amd_dev_put(void) {}
+#endif  /* CONFIG_PCI */
 
 #endif  /*  __LINUX_USB_PCI_QUIRKS_H  */
diff --git a/drivers/usb/host/r8a66597-hcd.c b/drivers/usb/host/r8a66597-hcd.c
index 77be3c24a427..4586369dda00 100644
--- a/drivers/usb/host/r8a66597-hcd.c
+++ b/drivers/usb/host/r8a66597-hcd.c
@@ -2150,8 +2150,9 @@ static void r8a66597_hub_descriptor(struct r8a66597 *r8a66597,
         desc->bDescLength = 9;
         desc->bPwrOn2PwrGood = 0;
         desc->wHubCharacteristics = cpu_to_le16(0x0011);
-        desc->bitmap[0] = ((1 << r8a66597->max_root_hub) - 1) << 1;
-        desc->bitmap[1] = ~0;
+        desc->u.hs.DeviceRemovable[0] =
+                ((1 << r8a66597->max_root_hub) - 1) << 1;
+        desc->u.hs.DeviceRemovable[1] = ~0;
 }
 
 static int r8a66597_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
@@ -2397,7 +2398,7 @@ static const struct dev_pm_ops r8a66597_dev_pm_ops = {
 #define R8A66597_DEV_PM_OPS     NULL
 #endif
 
-static int __init_or_module r8a66597_remove(struct platform_device *pdev)
+static int __devexit r8a66597_remove(struct platform_device *pdev)
 {
         struct r8a66597         *r8a66597 = dev_get_drvdata(&pdev->dev);
         struct usb_hcd          *hcd = r8a66597_to_hcd(r8a66597);
@@ -2516,6 +2517,7 @@ static int __devinit r8a66597_probe(struct platform_device *pdev)
         INIT_LIST_HEAD(&r8a66597->child_device);
 
         hcd->rsrc_start = res->start;
+        hcd->has_tt = 1;
 
         ret = usb_add_hcd(hcd, irq, IRQF_DISABLED | irq_trigger);
         if (ret != 0) {
@@ -2542,7 +2544,7 @@ clean_up:
 
 static struct platform_driver r8a66597_driver = {
         .probe =        r8a66597_probe,
-        .remove =       r8a66597_remove,
+        .remove =       __devexit_p(r8a66597_remove),
         .driver         = {
                 .name = (char *) hcd_name,
                 .owner  = THIS_MODULE,
diff --git a/drivers/usb/host/r8a66597.h b/drivers/usb/host/r8a66597.h
index 95d0f5adfdcf..25563e9a90bc 100644
--- a/drivers/usb/host/r8a66597.h
+++ b/drivers/usb/host/r8a66597.h
@@ -227,7 +227,7 @@ static inline void r8a66597_write_fifo(struct r8a66597 *r8a66597,
                 int odd = len & 0x0001;
 
                 len = len / 2;
-                ioread16_rep(fifoaddr, buf, len);
+                iowrite16_rep(fifoaddr, buf, len);
                 if (unlikely(odd)) {
                         buf = &buf[len];
                         iowrite8((unsigned char)*buf, fifoaddr);
diff --git a/drivers/usb/host/sl811-hcd.c b/drivers/usb/host/sl811-hcd.c
index 990f06b89eaa..1a996245ab98 100644
--- a/drivers/usb/host/sl811-hcd.c
+++ b/drivers/usb/host/sl811-hcd.c
@@ -47,6 +47,7 @@
 #include <linux/usb/sl811.h>
 #include <linux/usb/hcd.h>
 #include <linux/platform_device.h>
+#include <linux/prefetch.h>
 
 #include <asm/io.h>
 #include <asm/irq.h>
@@ -71,12 +72,6 @@ MODULE_ALIAS("platform:sl811-hcd");
 /* for now, use only one transfer register bank */
 #undef  USE_B
 
-/* this doesn't understand urb->iso_frame_desc[], but if you had a driver
- * that just queued one ISO frame per URB then iso transfers "should" work
- * using the normal urb status fields.
- */
-#define DISABLE_ISO
-
 // #define      QUIRK2
 #define QUIRK3
 
@@ -807,7 +802,7 @@ static int sl811h_urb_enqueue(
         int                     retval;
         struct usb_host_endpoint        *hep = urb->ep;
 
-#ifdef  DISABLE_ISO
+#ifndef CONFIG_USB_SL811_HCD_ISO
         if (type == PIPE_ISOCHRONOUS)
                 return -ENOSPC;
 #endif
@@ -861,6 +856,7 @@ static int sl811h_urb_enqueue(
                         DBG("dev %d ep%d maxpacket %d\n",
                                 udev->devnum, epnum, ep->maxpacket);
                         retval = -EINVAL;
+                        kfree(ep);
                         goto fail;
                 }
 
@@ -1110,9 +1106,9 @@ sl811h_hub_descriptor (
 
         desc->wHubCharacteristics = cpu_to_le16(temp);
 
-        /* two bitmaps:  ports removable, and legacy PortPwrCtrlMask */
-        desc->bitmap[0] = 0 << 1;
-        desc->bitmap[1] = ~0;
+        /* ports removable, and legacy PortPwrCtrlMask */
+        desc->u.hs.DeviceRemovable[0] = 0 << 1;
+        desc->u.hs.DeviceRemovable[1] = ~0;
 }
 
 static void
diff --git a/drivers/usb/host/sl811_cs.c b/drivers/usb/host/sl811_cs.c
index 0e13a00eb2ed..3b6f50eaec91 100644
--- a/drivers/usb/host/sl811_cs.c
+++ b/drivers/usb/host/sl811_cs.c
@@ -20,7 +20,6 @@
 #include <linux/ioport.h>
 #include <linux/platform_device.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/cisreg.h>
 #include <pcmcia/ds.h>
@@ -132,49 +131,12 @@ static void sl811_cs_release(struct pcmcia_device * link)
         platform_device_unregister(&platform_dev);
 }
 
-static int sl811_cs_config_check(struct pcmcia_device *p_dev,
-                                 cistpl_cftable_entry_t *cfg,
-                                 cistpl_cftable_entry_t *dflt,
-                                 unsigned int vcc,
-                                 void *priv_data)
+static int sl811_cs_config_check(struct pcmcia_device *p_dev, void *priv_data)
 {
-        if (cfg->index == 0)
-                return -ENODEV;
-
-        /* Use power settings for Vcc and Vpp if present */
-        /*  Note that the CIS values need to be rescaled */
-        if (cfg->vcc.present & (1<<CISTPL_POWER_VNOM)) {
-                if (cfg->vcc.param[CISTPL_POWER_VNOM]/10000 != vcc)
-                        return -ENODEV;
-        } else if (dflt->vcc.present & (1<<CISTPL_POWER_VNOM)) {
-                if (dflt->vcc.param[CISTPL_POWER_VNOM]/10000 != vcc)
-                        return -ENODEV;
-                }
-
-        if (cfg->vpp1.present & (1<<CISTPL_POWER_VNOM))
-                p_dev->conf.Vpp =
-                        cfg->vpp1.param[CISTPL_POWER_VNOM]/10000;
-        else if (dflt->vpp1.present & (1<<CISTPL_POWER_VNOM))
-                p_dev->conf.Vpp =
-                        dflt->vpp1.param[CISTPL_POWER_VNOM]/10000;
-
-        /* we need an interrupt */
-        p_dev->conf.Attributes |= CONF_ENABLE_IRQ;
-
-        /* IO window settings */
-        p_dev->resource[0]->end = p_dev->resource[1]->end = 0;
-        if ((cfg->io.nwin > 0) || (dflt->io.nwin > 0)) {
-                cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io;
-                p_dev->io_lines = io->flags & CISTPL_IO_LINES_MASK;
-
-                p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
-                p_dev->resource[0]->start = io->win[0].base;
-                p_dev->resource[0]->end = io->win[0].len;
-
-                return pcmcia_request_io(p_dev);
-        }
-        pcmcia_disable_device(p_dev);
-        return -ENODEV;
+        if (p_dev->config_index == 0)
+                return -EINVAL;
+
+        return pcmcia_request_io(p_dev);
 }
 
 
@@ -185,6 +147,9 @@ static int sl811_cs_config(struct pcmcia_device *link)
 
         dev_dbg(&link->dev, "sl811_cs_config\n");
 
+        link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_VPP |
+                CONF_AUTO_CHECK_VCC | CONF_AUTO_SET_IO;
+
         if (pcmcia_loop_config(link, sl811_cs_config_check, NULL))
                 goto failed;
 
@@ -195,18 +160,10 @@ static int sl811_cs_config(struct pcmcia_device *link)
         if (!link->irq)
                 goto failed;
 
-        ret = pcmcia_request_configuration(link, &link->conf);
+        ret = pcmcia_enable_device(link);
         if (ret)
                 goto failed;
 
-        dev_info(&link->dev, "index 0x%02x: ",
-                link->conf.ConfigIndex);
-        if (link->conf.Vpp)
-                printk(", Vpp %d.%d", link->conf.Vpp/10, link->conf.Vpp%10);
-        printk(", irq %d", link->irq);
-        printk(", io %pR", link->resource[0]);
-        printk("\n");
-
         if (sl811_hc_init(parent, link->resource[0]->start, link->irq)
                         < 0) {
 failed:
@@ -227,13 +184,10 @@ static int sl811_cs_probe(struct pcmcia_device *link)
         local->p_dev = link;
         link->priv = local;
 
-        link->conf.Attributes = 0;
-        link->conf.IntType = INT_MEMORY_AND_IO;
-
         return sl811_cs_config(link);
 }
 
-static struct pcmcia_device_id sl811_ids[] = {
+static const struct pcmcia_device_id sl811_ids[] = {
         PCMCIA_DEVICE_MANF_CARD(0xc015, 0x0001), /* RATOC USB HOST CF+ Card */
         PCMCIA_DEVICE_NULL,
 };
@@ -241,9 +195,7 @@ MODULE_DEVICE_TABLE(pcmcia, sl811_ids);
 
 static struct pcmcia_driver sl811_cs_driver = {
         .owner          = THIS_MODULE,
-        .drv            = {
-                .name   = "sl811_cs",
-        },
+        .name           = "sl811_cs",
         .probe          = sl811_cs_probe,
         .remove         = sl811_cs_detach,
         .id_table       = sl811_ids,
diff --git a/drivers/usb/host/u132-hcd.c b/drivers/usb/host/u132-hcd.c
index 5b31bae92dbc..533d12cca371 100644
--- a/drivers/usb/host/u132-hcd.c
+++ b/drivers/usb/host/u132-hcd.c
@@ -316,7 +316,6 @@ static void u132_ring_requeue_work(struct u132 *u132, struct u132_ring *ring,
         } else if (queue_delayed_work(workqueue, &ring->scheduler, 0))
                 return;
         kref_put(&u132->kref, u132_hcd_delete);
-        return;
 }
 
 static void u132_ring_queue_work(struct u132 *u132, struct u132_ring *ring,
@@ -324,7 +323,6 @@ static void u132_ring_queue_work(struct u132 *u132, struct u132_ring *ring,
 {
         kref_get(&u132->kref);
         u132_ring_requeue_work(u132, ring, delta);
-        return;
 }
 
 static void u132_ring_cancel_work(struct u132 *u132, struct u132_ring *ring)
@@ -543,7 +541,6 @@ static void u132_hcd_giveback_urb(struct u132 *u132, struct u132_endp *endp,
         mutex_unlock(&u132->scheduler_lock);
         u132_endp_put_kref(u132, endp);
         usb_hcd_giveback_urb(hcd, urb, status);
-        return;
 }
 
 static void u132_hcd_forget_urb(struct u132 *u132, struct u132_endp *endp,
@@ -574,8 +571,8 @@ static void u132_hcd_abandon_urb(struct u132 *u132, struct u132_endp *endp,
                 endp->active = 0;
                 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
                 kfree(urbq);
-        } usb_hcd_giveback_urb(hcd, urb, status);
-        return;
+        }
+        usb_hcd_giveback_urb(hcd, urb, status);
 }
 
 static inline int edset_input(struct u132 *u132, struct u132_ring *ring,
@@ -2607,13 +2604,14 @@ static int u132_roothub_descriptor(struct u132 *u132,
         retval = u132_read_pcimem(u132, roothub.b, &rh_b);
         if (retval)
                 return retval;
-        memset(desc->bitmap, 0xff, sizeof(desc->bitmap));
-        desc->bitmap[0] = rh_b & RH_B_DR;
+        memset(desc->u.hs.DeviceRemovable, 0xff,
+                        sizeof(desc->u.hs.DeviceRemovable));
+        desc->u.hs.DeviceRemovable[0] = rh_b & RH_B_DR;
         if (u132->num_ports > 7) {
-                desc->bitmap[1] = (rh_b & RH_B_DR) >> 8;
-                desc->bitmap[2] = 0xff;
+                desc->u.hs.DeviceRemovable[1] = (rh_b & RH_B_DR) >> 8;
+                desc->u.hs.DeviceRemovable[2] = 0xff;
         } else
-                desc->bitmap[1] = 0xff;
+                desc->u.hs.DeviceRemovable[1] = 0xff;
         return 0;
 }
 
@@ -3085,7 +3083,6 @@ static void u132_initialise(struct u132 *u132, struct platform_device *pdev)
                 u132->endp[endps] = NULL;
 
         mutex_unlock(&u132->sw_lock);
-        return;
 }
 
 static int __devinit u132_probe(struct platform_device *pdev)
@@ -3233,8 +3230,7 @@ static int __init u132_hcd_init(void)
         mutex_init(&u132_module_lock);
         if (usb_disabled())
                 return -ENODEV;
-        printk(KERN_INFO "driver %s built at %s on %s\n", hcd_name, __TIME__,
-                __DATE__);
+        printk(KERN_INFO "driver %s\n", hcd_name);
         workqueue = create_singlethread_workqueue("u132");
         retval = platform_driver_register(&u132_platform_driver);
         return retval;
diff --git a/drivers/usb/host/uhci-debug.c b/drivers/usb/host/uhci-debug.c
index 6e7fb5f38db6..fc0b0daac93d 100644
--- a/drivers/usb/host/uhci-debug.c
+++ b/drivers/usb/host/uhci-debug.c
@@ -12,7 +12,6 @@
 #include <linux/slab.h>
 #include <linux/kernel.h>
 #include <linux/debugfs.h>
-#include <linux/smp_lock.h>
 #include <asm/io.h>
 
 #include "uhci-hcd.h"
@@ -38,7 +37,8 @@ static void lprintk(char *buf)
         }
 }
 
-static int uhci_show_td(struct uhci_td *td, char *buf, int len, int space)
+static int uhci_show_td(struct uhci_hcd *uhci, struct uhci_td *td, char *buf,
+                        int len, int space)
 {
         char *out = buf;
         char *spid;
@@ -48,8 +48,9 @@ static int uhci_show_td(struct uhci_td *td, char *buf, int len, int space)
         if (len < 160)
                 return 0;
 
-        status = td_status(td);
-        out += sprintf(out, "%*s[%p] link (%08x) ", space, "", td, le32_to_cpu(td->link));
+        status = td_status(uhci, td);
+        out += sprintf(out, "%*s[%p] link (%08x) ", space, "", td,
+                hc32_to_cpu(uhci, td->link));
         out += sprintf(out, "e%d %s%s%s%s%s%s%s%s%s%sLength=%x ",
                 ((status >> 27) & 3),
                 (status & TD_CTRL_SPD) ?      "SPD " : "",
@@ -64,7 +65,7 @@ static int uhci_show_td(struct uhci_td *td, char *buf, int len, int space)
                 (status & TD_CTRL_BITSTUFF) ? "BitStuff " : "",
                 status & 0x7ff);
 
-        token = td_token(td);
+        token = td_token(uhci, td);
         switch (uhci_packetid(token)) {
                 case USB_PID_SETUP:
                         spid = "SETUP";
@@ -87,12 +88,13 @@ static int uhci_show_td(struct uhci_td *td, char *buf, int len, int space)
                 (token >> 8) & 127,
                 (token & 0xff),
                 spid);
-        out += sprintf(out, "(buf=%08x)\n", le32_to_cpu(td->buffer));
+        out += sprintf(out, "(buf=%08x)\n", hc32_to_cpu(uhci, td->buffer));
 
         return out - buf;
 }
 
-static int uhci_show_urbp(struct urb_priv *urbp, char *buf, int len, int space)
+static int uhci_show_urbp(struct uhci_hcd *uhci, struct urb_priv *urbp,
+                        char *buf, int len, int space)
 {
         char *out = buf;
         struct uhci_td *td;
@@ -131,9 +133,10 @@ static int uhci_show_urbp(struct urb_priv *urbp, char *buf, int len, int space)
                 if (urbp->qh->type != USB_ENDPOINT_XFER_ISOC &&
                                 (++i <= 10 || debug > 2)) {
                         out += sprintf(out, "%*s%d: ", space + 2, "", i);
-                        out += uhci_show_td(td, out, len - (out - buf), 0);
+                        out += uhci_show_td(uhci, td, out,
+                                        len - (out - buf), 0);
                 } else {
-                        if (td_status(td) & TD_CTRL_ACTIVE)
+                        if (td_status(uhci, td) & TD_CTRL_ACTIVE)
                                 ++nactive;
                         else
                                 ++ninactive;
@@ -152,7 +155,7 @@ static int uhci_show_qh(struct uhci_hcd *uhci,
 {
         char *out = buf;
         int i, nurbs;
-        __le32 element = qh_element(qh);
+        __hc32 element = qh_element(qh);
         char *qtype;
 
         /* Try to make sure there's enough memory */
@@ -169,7 +172,8 @@ static int uhci_show_qh(struct uhci_hcd *uhci,
 
         out += sprintf(out, "%*s[%p] %s QH link (%08x) element (%08x)\n",
                         space, "", qh, qtype,
-                        le32_to_cpu(qh->link), le32_to_cpu(element));
+                        hc32_to_cpu(uhci, qh->link),
+                        hc32_to_cpu(uhci, element));
         if (qh->type == USB_ENDPOINT_XFER_ISOC)
                 out += sprintf(out, "%*s    period %d phase %d load %d us, "
                                 "frame %x desc [%p]\n",
@@ -179,22 +183,22 @@ static int uhci_show_qh(struct uhci_hcd *uhci,
                 out += sprintf(out, "%*s    period %d phase %d load %d us\n",
                                 space, "", qh->period, qh->phase, qh->load);
 
-        if (element & UHCI_PTR_QH)
+        if (element & UHCI_PTR_QH(uhci))
                 out += sprintf(out, "%*s  Element points to QH (bug?)\n", space, "");
 
-        if (element & UHCI_PTR_DEPTH)
+        if (element & UHCI_PTR_DEPTH(uhci))
                 out += sprintf(out, "%*s  Depth traverse\n", space, "");
 
-        if (element & cpu_to_le32(8))
+        if (element & cpu_to_hc32(uhci, 8))
                 out += sprintf(out, "%*s  Bit 3 set (bug?)\n", space, "");
 
-        if (!(element & ~(UHCI_PTR_QH | UHCI_PTR_DEPTH)))
+        if (!(element & ~(UHCI_PTR_QH(uhci) | UHCI_PTR_DEPTH(uhci))))
                 out += sprintf(out, "%*s  Element is NULL (bug?)\n", space, "");
 
         if (list_empty(&qh->queue)) {
                 out += sprintf(out, "%*s  queue is empty\n", space, "");
                 if (qh == uhci->skel_async_qh)
-                        out += uhci_show_td(uhci->term_td, out,
+                        out += uhci_show_td(uhci, uhci->term_td, out,
                                         len - (out - buf), 0);
         } else {
                 struct urb_priv *urbp = list_entry(qh->queue.next,
@@ -202,13 +206,13 @@ static int uhci_show_qh(struct uhci_hcd *uhci,
                 struct uhci_td *td = list_entry(urbp->td_list.next,
                                 struct uhci_td, list);
 
-                if (element != LINK_TO_TD(td))
+                if (element != LINK_TO_TD(uhci, td))
                         out += sprintf(out, "%*s Element != First TD\n",
                                         space, "");
                 i = nurbs = 0;
                 list_for_each_entry(urbp, &qh->queue, node) {
                         if (++i <= 10)
-                                out += uhci_show_urbp(urbp, out,
+                                out += uhci_show_urbp(uhci, urbp, out,
                                                 len - (out - buf), space + 2);
                         else
                                 ++nurbs;
@@ -220,7 +224,8 @@ static int uhci_show_qh(struct uhci_hcd *uhci,
 
         if (qh->dummy_td) {
                 out += sprintf(out, "%*s  Dummy TD\n", space, "");
-                out += uhci_show_td(qh->dummy_td, out, len - (out - buf), 0);
+                out += uhci_show_td(uhci, qh->dummy_td, out,
+                                len - (out - buf), 0);
         }
 
         return out - buf;
@@ -286,7 +291,6 @@ static int uhci_show_root_hub_state(struct uhci_hcd *uhci, char *buf, int len)
 static int uhci_show_status(struct uhci_hcd *uhci, char *buf, int len)
 {
         char *out = buf;
-        unsigned long io_addr = uhci->io_addr;
         unsigned short usbcmd, usbstat, usbint, usbfrnum;
         unsigned int flbaseadd;
         unsigned char sof;
@@ -296,14 +300,14 @@ static int uhci_show_status(struct uhci_hcd *uhci, char *buf, int len)
         if (len < 80 * 9)
                 return 0;
 
-        usbcmd    = inw(io_addr + 0);
-        usbstat   = inw(io_addr + 2);
-        usbint    = inw(io_addr + 4);
-        usbfrnum  = inw(io_addr + 6);
-        flbaseadd = inl(io_addr + 8);
-        sof       = inb(io_addr + 12);
-        portsc1   = inw(io_addr + 16);
-        portsc2   = inw(io_addr + 18);
+        usbcmd    = uhci_readw(uhci, 0);
+        usbstat   = uhci_readw(uhci, 2);
+        usbint    = uhci_readw(uhci, 4);
+        usbfrnum  = uhci_readw(uhci, 6);
+        flbaseadd = uhci_readl(uhci, 8);
+        sof       = uhci_readb(uhci, 12);
+        portsc1   = uhci_readw(uhci, 16);
+        portsc2   = uhci_readw(uhci, 18);
 
         out += sprintf(out, "  usbcmd    =     %04x   %s%s%s%s%s%s%s%s\n",
                 usbcmd,
@@ -348,8 +352,8 @@ static int uhci_sprint_schedule(struct uhci_hcd *uhci, char *buf, int len)
         struct uhci_td *td;
         struct list_head *tmp, *head;
         int nframes, nerrs;
-        __le32 link;
-        __le32 fsbr_link;
+        __hc32 link;
+        __hc32 fsbr_link;
 
         static const char * const qh_names[] = {
                 "unlink", "iso", "int128", "int64", "int32", "int16",
@@ -377,7 +381,7 @@ static int uhci_sprint_schedule(struct uhci_hcd *uhci, char *buf, int len)
         nframes = 10;
         nerrs = 0;
         for (i = 0; i < UHCI_NUMFRAMES; ++i) {
-                __le32 qh_dma;
+                __hc32 qh_dma;
 
                 j = 0;
                 td = uhci->frame_cpu[i];
@@ -387,7 +391,7 @@ static int uhci_sprint_schedule(struct uhci_hcd *uhci, char *buf, int len)
 
                 if (nframes > 0) {
                         out += sprintf(out, "- Frame %d -> (%08x)\n",
-                                        i, le32_to_cpu(link));
+                                        i, hc32_to_cpu(uhci, link));
                         j = 1;
                 }
 
@@ -396,7 +400,7 @@ static int uhci_sprint_schedule(struct uhci_hcd *uhci, char *buf, int len)
                 do {
                         td = list_entry(tmp, struct uhci_td, fl_list);
                         tmp = tmp->next;
-                        if (link != LINK_TO_TD(td)) {
+                        if (link != LINK_TO_TD(uhci, td)) {
                                 if (nframes > 0)
                                         out += sprintf(out, "    link does "
                                                 "not match list entry!\n");
@@ -404,7 +408,7 @@ static int uhci_sprint_schedule(struct uhci_hcd *uhci, char *buf, int len)
                                         ++nerrs;
                         }
                         if (nframes > 0)
-                                out += uhci_show_td(td, out,
+                                out += uhci_show_td(uhci, td, out,
                                                 len - (out - buf), 4);
                         link = td->link;
                 } while (tmp != head);
@@ -416,11 +420,12 @@ check_link:
                                 if (!j) {
                                         out += sprintf(out,
                                                 "- Frame %d -> (%08x)\n",
-                                                i, le32_to_cpu(link));
+                                                i, hc32_to_cpu(uhci, link));
                                         j = 1;
                                 }
                                 out += sprintf(out, "   link does not match "
-                                        "QH (%08x)!\n", le32_to_cpu(qh_dma));
+                                        "QH (%08x)!\n",
+                                        hc32_to_cpu(uhci, qh_dma));
                         } else
                                 ++nerrs;
                 }
@@ -441,11 +446,11 @@ check_link:
 
                 /* Last QH is the Terminating QH, it's different */
                 if (i == SKEL_TERM) {
-                        if (qh_element(qh) != LINK_TO_TD(uhci->term_td))
+                        if (qh_element(qh) != LINK_TO_TD(uhci, uhci->term_td))
                                 out += sprintf(out, "    skel_term_qh element is not set to term_td!\n");
                         link = fsbr_link;
                         if (!link)
-                                link = LINK_TO_QH(uhci->skel_term_qh);
+                                link = LINK_TO_QH(uhci, uhci->skel_term_qh);
                         goto check_qh_link;
                 }
 
@@ -459,20 +464,20 @@ check_link:
                                 out += uhci_show_qh(uhci, qh, out,
                                                 len - (out - buf), 4);
                         if (!fsbr_link && qh->skel >= SKEL_FSBR)
-                                fsbr_link = LINK_TO_QH(qh);
+                                fsbr_link = LINK_TO_QH(uhci, qh);
                 }
                 if ((cnt -= 10) > 0)
                         out += sprintf(out, "    Skipped %d QHs\n", cnt);
 
-                link = UHCI_PTR_TERM;
+                link = UHCI_PTR_TERM(uhci);
                 if (i <= SKEL_ISO)
                         ;
                 else if (i < SKEL_ASYNC)
-                        link = LINK_TO_QH(uhci->skel_async_qh);
+                        link = LINK_TO_QH(uhci, uhci->skel_async_qh);
                 else if (!uhci->fsbr_is_on)
                         ;
                 else
-                        link = LINK_TO_QH(uhci->skel_term_qh);
+                        link = LINK_TO_QH(uhci, uhci->skel_term_qh);
 check_qh_link:
                 if (qh->link != link)
                         out += sprintf(out, "    last QH not linked to next skeleton!\n");
diff --git a/drivers/usb/host/uhci-grlib.c b/drivers/usb/host/uhci-grlib.c
new file mode 100644
index 000000000000..d01c1e227681
--- /dev/null
+++ b/drivers/usb/host/uhci-grlib.c
@@ -0,0 +1,208 @@
+/*
+ * UHCI HCD (Host Controller Driver) for GRLIB GRUSBHC
+ *
+ * Copyright (c) 2011 Jan Andersson <jan@gaisler.com>
+ *
+ * This file is based on UHCI PCI HCD:
+ * (C) Copyright 1999 Linus Torvalds
+ * (C) Copyright 1999-2002 Johannes Erdfelt, johannes@erdfelt.com
+ * (C) Copyright 1999 Randy Dunlap
+ * (C) Copyright 1999 Georg Acher, acher@in.tum.de
+ * (C) Copyright 1999 Deti Fliegl, deti@fliegl.de
+ * (C) Copyright 1999 Thomas Sailer, sailer@ife.ee.ethz.ch
+ * (C) Copyright 1999 Roman Weissgaerber, weissg@vienna.at
+ * (C) Copyright 2000 Yggdrasil Computing, Inc. (port of new PCI interface
+ *               support from usb-ohci.c by Adam Richter, adam@yggdrasil.com).
+ * (C) Copyright 1999 Gregory P. Smith (from usb-ohci.c)
+ * (C) Copyright 2004-2007 Alan Stern, stern@rowland.harvard.edu
+ */
+
+#include <linux/of_irq.h>
+#include <linux/of_address.h>
+#include <linux/of_platform.h>
+
+static int uhci_grlib_init(struct usb_hcd *hcd)
+{
+        struct uhci_hcd *uhci = hcd_to_uhci(hcd);
+
+        /*
+         * Probe to determine the endianness of the controller.
+         * We know that bit 7 of the PORTSC1 register is always set
+         * and bit 15 is always clear.  If uhci_readw() yields a value
+         * with bit 7 (0x80) turned on then the current little-endian
+         * setting is correct.  Otherwise we assume the value was
+         * byte-swapped; hence the register interface and presumably
+         * also the descriptors are big-endian.
+         */
+        if (!(uhci_readw(uhci, USBPORTSC1) & 0x80)) {
+                uhci->big_endian_mmio = 1;
+                uhci->big_endian_desc = 1;
+        }
+
+        uhci->rh_numports = uhci_count_ports(hcd);
+
+        /* Set up pointers to to generic functions */
+        uhci->reset_hc = uhci_generic_reset_hc;
+        uhci->check_and_reset_hc = uhci_generic_check_and_reset_hc;
+        /* No special actions need to be taken for the functions below */
+        uhci->configure_hc = NULL;
+        uhci->resume_detect_interrupts_are_broken = NULL;
+        uhci->global_suspend_mode_is_broken = NULL;
+
+        /* Reset if the controller isn't already safely quiescent. */
+        check_and_reset_hc(uhci);
+        return 0;
+}
+
+static const struct hc_driver uhci_grlib_hc_driver = {
+        .description =          hcd_name,
+        .product_desc =         "GRLIB GRUSBHC UHCI Host Controller",
+        .hcd_priv_size =        sizeof(struct uhci_hcd),
+
+        /* Generic hardware linkage */
+        .irq =                  uhci_irq,
+        .flags =                HCD_MEMORY | HCD_USB11,
+
+        /* Basic lifecycle operations */
+        .reset =                uhci_grlib_init,
+        .start =                uhci_start,
+#ifdef CONFIG_PM
+        .pci_suspend =          NULL,
+        .pci_resume =           NULL,
+        .bus_suspend =          uhci_rh_suspend,
+        .bus_resume =           uhci_rh_resume,
+#endif
+        .stop =                 uhci_stop,
+
+        .urb_enqueue =          uhci_urb_enqueue,
+        .urb_dequeue =          uhci_urb_dequeue,
+
+        .endpoint_disable =     uhci_hcd_endpoint_disable,
+        .get_frame_number =     uhci_hcd_get_frame_number,
+
+        .hub_status_data =      uhci_hub_status_data,
+        .hub_control =          uhci_hub_control,
+};
+
+
+static int __devinit uhci_hcd_grlib_probe(struct platform_device *op)
+{
+        struct device_node *dn = op->dev.of_node;
+        struct usb_hcd *hcd;
+        struct uhci_hcd *uhci = NULL;
+        struct resource res;
+        int irq;
+        int rv;
+
+        if (usb_disabled())
+                return -ENODEV;
+
+        dev_dbg(&op->dev, "initializing GRUSBHC UHCI USB Controller\n");
+
+        rv = of_address_to_resource(dn, 0, &res);
+        if (rv)
+                return rv;
+
+        /* usb_create_hcd requires dma_mask != NULL */
+        op->dev.dma_mask = &op->dev.coherent_dma_mask;
+        hcd = usb_create_hcd(&uhci_grlib_hc_driver, &op->dev,
+                        "GRUSBHC UHCI USB");
+        if (!hcd)
+                return -ENOMEM;
+
+        hcd->rsrc_start = res.start;
+        hcd->rsrc_len = res.end - res.start + 1;
+
+        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
+                printk(KERN_ERR "%s: request_mem_region failed\n", __FILE__);
+                rv = -EBUSY;
+                goto err_rmr;
+        }
+
+        irq = irq_of_parse_and_map(dn, 0);
+        if (irq == NO_IRQ) {
+                printk(KERN_ERR "%s: irq_of_parse_and_map failed\n", __FILE__);
+                rv = -EBUSY;
+                goto err_irq;
+        }
+
+        hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
+        if (!hcd->regs) {
+                printk(KERN_ERR "%s: ioremap failed\n", __FILE__);
+                rv = -ENOMEM;
+                goto err_ioremap;
+        }
+
+        uhci = hcd_to_uhci(hcd);
+
+        uhci->regs = hcd->regs;
+
+        rv = usb_add_hcd(hcd, irq, 0);
+        if (rv)
+                goto err_uhci;
+
+        return 0;
+
+err_uhci:
+        iounmap(hcd->regs);
+err_ioremap:
+        irq_dispose_mapping(irq);
+err_irq:
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+err_rmr:
+        usb_put_hcd(hcd);
+
+        return rv;
+}
+
+static int uhci_hcd_grlib_remove(struct platform_device *op)
+{
+        struct usb_hcd *hcd = dev_get_drvdata(&op->dev);
+
+        dev_set_drvdata(&op->dev, NULL);
+
+        dev_dbg(&op->dev, "stopping GRLIB GRUSBHC UHCI USB Controller\n");
+
+        usb_remove_hcd(hcd);
+
+        iounmap(hcd->regs);
+        irq_dispose_mapping(hcd->irq);
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+
+        usb_put_hcd(hcd);
+
+        return 0;
+}
+
+/* Make sure the controller is quiescent and that we're not using it
+ * any more.  This is mainly for the benefit of programs which, like kexec,
+ * expect the hardware to be idle: not doing DMA or generating IRQs.
+ *
+ * This routine may be called in a damaged or failing kernel.  Hence we
+ * do not acquire the spinlock before shutting down the controller.
+ */
+static void uhci_hcd_grlib_shutdown(struct platform_device *op)
+{
+        struct usb_hcd *hcd = dev_get_drvdata(&op->dev);
+
+        uhci_hc_died(hcd_to_uhci(hcd));
+}
+
+static const struct of_device_id uhci_hcd_grlib_of_match[] = {
+        { .name = "GAISLER_UHCI", },
+        { .name = "01_027", },
+        {},
+};
+MODULE_DEVICE_TABLE(of, uhci_hcd_grlib_of_match);
+
+
+static struct platform_driver uhci_grlib_driver = {
+        .probe          = uhci_hcd_grlib_probe,
+        .remove         = uhci_hcd_grlib_remove,
+        .shutdown       = uhci_hcd_grlib_shutdown,
+        .driver = {
+                .name = "grlib-uhci",
+                .owner = THIS_MODULE,
+                .of_match_table = uhci_hcd_grlib_of_match,
+        },
+};
diff --git a/drivers/usb/host/uhci-hcd.c b/drivers/usb/host/uhci-hcd.c
index f52d04db28f4..fba99b120588 100644
--- a/drivers/usb/host/uhci-hcd.c
+++ b/drivers/usb/host/uhci-hcd.c
@@ -48,14 +48,14 @@
 #include <asm/system.h>
 
 #include "uhci-hcd.h"
-#include "pci-quirks.h"
 
 /*
  * Version Information
  */
-#define DRIVER_AUTHOR "Linus 'Frodo Rabbit' Torvalds, Johannes Erdfelt, \
-Randy Dunlap, Georg Acher, Deti Fliegl, Thomas Sailer, Roman Weissgaerber, \
-Alan Stern"
+#define DRIVER_AUTHOR                                                   \
+        "Linus 'Frodo Rabbit' Torvalds, Johannes Erdfelt, "             \
+        "Randy Dunlap, Georg Acher, Deti Fliegl, Thomas Sailer, "       \
+        "Roman Weissgaerber, Alan Stern"
 #define DRIVER_DESC "USB Universal Host Controller Interface driver"
 
 /* for flakey hardware, ignore overcurrent indicators */
@@ -93,7 +93,7 @@ static void uhci_get_current_frame_number(struct uhci_hcd *uhci);
 /*
  * Calculate the link pointer DMA value for the first Skeleton QH in a frame.
  */
-static __le32 uhci_frame_skel_link(struct uhci_hcd *uhci, int frame)
+static __hc32 uhci_frame_skel_link(struct uhci_hcd *uhci, int frame)
 {
         int skelnum;
 
@@ -115,7 +115,7 @@ static __le32 uhci_frame_skel_link(struct uhci_hcd *uhci, int frame)
         skelnum = 8 - (int) __ffs(frame | UHCI_NUMFRAMES);
         if (skelnum <= 1)
                 skelnum = 9;
-        return LINK_TO_QH(uhci->skelqh[skelnum]);
+        return LINK_TO_QH(uhci, uhci->skelqh[skelnum]);
 }
 
 #include "uhci-debug.c"
@@ -134,15 +134,12 @@ static void finish_reset(struct uhci_hcd *uhci)
          * We have to clear them by hand.
          */
         for (port = 0; port < uhci->rh_numports; ++port)
-                outw(0, uhci->io_addr + USBPORTSC1 + (port * 2));
+                uhci_writew(uhci, 0, USBPORTSC1 + (port * 2));
 
         uhci->port_c_suspend = uhci->resuming_ports = 0;
         uhci->rh_state = UHCI_RH_RESET;
         uhci->is_stopped = UHCI_IS_STOPPED;
-        uhci_to_hcd(uhci)->state = HC_STATE_HALT;
         clear_bit(HCD_FLAG_POLL_RH, &uhci_to_hcd(uhci)->flags);
-
-        uhci->dead = 0;         /* Full reset resurrects the controller */
 }
 
 /*
@@ -152,7 +149,7 @@ static void finish_reset(struct uhci_hcd *uhci)
 static void uhci_hc_died(struct uhci_hcd *uhci)
 {
         uhci_get_current_frame_number(uhci);
-        uhci_reset_hc(to_pci_dev(uhci_dev(uhci)), uhci->io_addr);
+        uhci->reset_hc(uhci);
         finish_reset(uhci);
         uhci->dead = 1;
 
@@ -167,97 +164,118 @@ static void uhci_hc_died(struct uhci_hcd *uhci)
  */
 static void check_and_reset_hc(struct uhci_hcd *uhci)
 {
-        if (uhci_check_and_reset_hc(to_pci_dev(uhci_dev(uhci)), uhci->io_addr))
+        if (uhci->check_and_reset_hc(uhci))
                 finish_reset(uhci);
 }
 
+#if defined(CONFIG_USB_UHCI_SUPPORT_NON_PCI_HC)
+/*
+ * The two functions below are generic reset functions that are used on systems
+ * that do not have keyboard and mouse legacy support. We assume that we are
+ * running on such a system if CONFIG_USB_UHCI_SUPPORT_NON_PCI_HC is defined.
+ */
+
+/*
+ * Make sure the controller is completely inactive, unable to
+ * generate interrupts or do DMA.
+ */
+static void uhci_generic_reset_hc(struct uhci_hcd *uhci)
+{
+        /* Reset the HC - this will force us to get a
+         * new notification of any already connected
+         * ports due to the virtual disconnect that it
+         * implies.
+         */
+        uhci_writew(uhci, USBCMD_HCRESET, USBCMD);
+        mb();
+        udelay(5);
+        if (uhci_readw(uhci, USBCMD) & USBCMD_HCRESET)
+                dev_warn(uhci_dev(uhci), "HCRESET not completed yet!\n");
+
+        /* Just to be safe, disable interrupt requests and
+         * make sure the controller is stopped.
+         */
+        uhci_writew(uhci, 0, USBINTR);
+        uhci_writew(uhci, 0, USBCMD);
+}
+
+/*
+ * Initialize a controller that was newly discovered or has just been
+ * resumed.  In either case we can't be sure of its previous state.
+ *
+ * Returns: 1 if the controller was reset, 0 otherwise.
+ */
+static int uhci_generic_check_and_reset_hc(struct uhci_hcd *uhci)
+{
+        unsigned int cmd, intr;
+
+        /*
+         * When restarting a suspended controller, we expect all the
+         * settings to be the same as we left them:
+         *
+         *      Controller is stopped and configured with EGSM set;
+         *      No interrupts enabled except possibly Resume Detect.
+         *
+         * If any of these conditions are violated we do a complete reset.
+         */
+
+        cmd = uhci_readw(uhci, USBCMD);
+        if ((cmd & USBCMD_RS) || !(cmd & USBCMD_CF) || !(cmd & USBCMD_EGSM)) {
+                dev_dbg(uhci_dev(uhci), "%s: cmd = 0x%04x\n",
+                                __func__, cmd);
+                goto reset_needed;
+        }
+
+        intr = uhci_readw(uhci, USBINTR);
+        if (intr & (~USBINTR_RESUME)) {
+                dev_dbg(uhci_dev(uhci), "%s: intr = 0x%04x\n",
+                                __func__, intr);
+                goto reset_needed;
+        }
+        return 0;
+
+reset_needed:
+        dev_dbg(uhci_dev(uhci), "Performing full reset\n");
+        uhci_generic_reset_hc(uhci);
+        return 1;
+}
+#endif /* CONFIG_USB_UHCI_SUPPORT_NON_PCI_HC */
+
 /*
  * Store the basic register settings needed by the controller.
  */
 static void configure_hc(struct uhci_hcd *uhci)
 {
-        struct pci_dev *pdev = to_pci_dev(uhci_dev(uhci));
-
         /* Set the frame length to the default: 1 ms exactly */
-        outb(USBSOF_DEFAULT, uhci->io_addr + USBSOF);
+        uhci_writeb(uhci, USBSOF_DEFAULT, USBSOF);
 
         /* Store the frame list base address */
-        outl(uhci->frame_dma_handle, uhci->io_addr + USBFLBASEADD);
+        uhci_writel(uhci, uhci->frame_dma_handle, USBFLBASEADD);
 
         /* Set the current frame number */
-        outw(uhci->frame_number & UHCI_MAX_SOF_NUMBER,
-                        uhci->io_addr + USBFRNUM);
-
-        /* Mark controller as not halted before we enable interrupts */
-        uhci_to_hcd(uhci)->state = HC_STATE_SUSPENDED;
-        mb();
-
-        /* Enable PIRQ */
-        pci_write_config_word(pdev, USBLEGSUP, USBLEGSUP_DEFAULT);
+        uhci_writew(uhci, uhci->frame_number & UHCI_MAX_SOF_NUMBER,
+                        USBFRNUM);
 
-        /* Disable platform-specific non-PME# wakeup */
-        if (pdev->vendor == PCI_VENDOR_ID_INTEL)
-                pci_write_config_byte(pdev, USBRES_INTEL, 0);
+        /* perform any arch/bus specific configuration */
+        if (uhci->configure_hc)
+                uhci->configure_hc(uhci);
 }
 
-
 static int resume_detect_interrupts_are_broken(struct uhci_hcd *uhci)
 {
-        int port;
-
         /* If we have to ignore overcurrent events then almost by definition
          * we can't depend on resume-detect interrupts. */
         if (ignore_oc)
                 return 1;
 
-        switch (to_pci_dev(uhci_dev(uhci))->vendor) {
-            default:
-                break;
-
-            case PCI_VENDOR_ID_GENESYS:
-                /* Genesys Logic's GL880S controllers don't generate
-                 * resume-detect interrupts.
-                 */
-                return 1;
-
-            case PCI_VENDOR_ID_INTEL:
-                /* Some of Intel's USB controllers have a bug that causes
-                 * resume-detect interrupts if any port has an over-current
-                 * condition.  To make matters worse, some motherboards
-                 * hardwire unused USB ports' over-current inputs active!
-                 * To prevent problems, we will not enable resume-detect
-                 * interrupts if any ports are OC.
-                 */
-                for (port = 0; port < uhci->rh_numports; ++port) {
-                        if (inw(uhci->io_addr + USBPORTSC1 + port * 2) &
-                                        USBPORTSC_OC)
-                                return 1;
-                }
-                break;
-        }
-        return 0;
+        return uhci->resume_detect_interrupts_are_broken ?
+                uhci->resume_detect_interrupts_are_broken(uhci) : 0;
 }
 
 static int global_suspend_mode_is_broken(struct uhci_hcd *uhci)
 {
-        int port;
-        const char *sys_info;
-        static char bad_Asus_board[] = "A7V8X";
-
-        /* One of Asus's motherboards has a bug which causes it to
-         * wake up immediately from suspend-to-RAM if any of the ports
-         * are connected.  In such cases we will not set EGSM.
-         */
-        sys_info = dmi_get_system_info(DMI_BOARD_NAME);
-        if (sys_info && !strcmp(sys_info, bad_Asus_board)) {
-                for (port = 0; port < uhci->rh_numports; ++port) {
-                        if (inw(uhci->io_addr + USBPORTSC1 + port * 2) &
-                                        USBPORTSC_CCS)
-                                return 1;
-                }
-        }
-
-        return 0;
+        return uhci->global_suspend_mode_is_broken ?
+                uhci->global_suspend_mode_is_broken(uhci) : 0;
 }
 
 static void suspend_rh(struct uhci_hcd *uhci, enum uhci_rh_state new_state)
@@ -320,8 +338,8 @@ __acquires(uhci->lock)
                         !int_enable)
                 uhci->RD_enable = int_enable = 0;
 
-        outw(int_enable, uhci->io_addr + USBINTR);
-        outw(egsm_enable | USBCMD_CF, uhci->io_addr + USBCMD);
+        uhci_writew(uhci, int_enable, USBINTR);
+        uhci_writew(uhci, egsm_enable | USBCMD_CF, USBCMD);
         mb();
         udelay(5);
 
@@ -330,7 +348,7 @@ __acquires(uhci->lock)
          * controller should stop after a few microseconds.  Otherwise
          * we will give the controller one frame to stop.
          */
-        if (!auto_stop && !(inw(uhci->io_addr + USBSTS) & USBSTS_HCH)) {
+        if (!auto_stop && !(uhci_readw(uhci, USBSTS) & USBSTS_HCH)) {
                 uhci->rh_state = UHCI_RH_SUSPENDING;
                 spin_unlock_irq(&uhci->lock);
                 msleep(1);
@@ -338,7 +356,7 @@ __acquires(uhci->lock)
                 if (uhci->dead)
                         return;
         }
-        if (!(inw(uhci->io_addr + USBSTS) & USBSTS_HCH))
+        if (!(uhci_readw(uhci, USBSTS) & USBSTS_HCH))
                 dev_warn(uhci_dev(uhci), "Controller not stopped yet!\n");
 
         uhci_get_current_frame_number(uhci);
@@ -360,15 +378,14 @@ __acquires(uhci->lock)
 
 static void start_rh(struct uhci_hcd *uhci)
 {
-        uhci_to_hcd(uhci)->state = HC_STATE_RUNNING;
         uhci->is_stopped = 0;
 
         /* Mark it configured and running with a 64-byte max packet.
          * All interrupts are enabled, even though RESUME won't do anything.
          */
-        outw(USBCMD_RS | USBCMD_CF | USBCMD_MAXP, uhci->io_addr + USBCMD);
-        outw(USBINTR_TIMEOUT | USBINTR_RESUME | USBINTR_IOC | USBINTR_SP,
-                        uhci->io_addr + USBINTR);
+        uhci_writew(uhci, USBCMD_RS | USBCMD_CF | USBCMD_MAXP, USBCMD);
+        uhci_writew(uhci, USBINTR_TIMEOUT | USBINTR_RESUME |
+                USBINTR_IOC | USBINTR_SP, USBINTR);
         mb();
         uhci->rh_state = UHCI_RH_RUNNING;
         set_bit(HCD_FLAG_POLL_RH, &uhci_to_hcd(uhci)->flags);
@@ -391,9 +408,9 @@ __acquires(uhci->lock)
                 unsigned egsm;
 
                 /* Keep EGSM on if it was set before */
-                egsm = inw(uhci->io_addr + USBCMD) & USBCMD_EGSM;
+                egsm = uhci_readw(uhci, USBCMD) & USBCMD_EGSM;
                 uhci->rh_state = UHCI_RH_RESUMING;
-                outw(USBCMD_FGR | USBCMD_CF | egsm, uhci->io_addr + USBCMD);
+                uhci_writew(uhci, USBCMD_FGR | USBCMD_CF | egsm, USBCMD);
                 spin_unlock_irq(&uhci->lock);
                 msleep(20);
                 spin_lock_irq(&uhci->lock);
@@ -401,10 +418,10 @@ __acquires(uhci->lock)
                         return;
 
                 /* End Global Resume and wait for EOP to be sent */
-                outw(USBCMD_CF, uhci->io_addr + USBCMD);
+                uhci_writew(uhci, USBCMD_CF, USBCMD);
                 mb();
                 udelay(4);
-                if (inw(uhci->io_addr + USBCMD) & USBCMD_FGR)
+                if (uhci_readw(uhci, USBCMD) & USBCMD_FGR)
                         dev_warn(uhci_dev(uhci), "FGR not stopped yet!\n");
         }
 
@@ -424,10 +441,10 @@ static irqreturn_t uhci_irq(struct usb_hcd *hcd)
          * interrupt cause.  Contrary to the UHCI specification, the
          * "HC Halted" status bit is persistent: it is RO, not R/WC.
          */
-        status = inw(uhci->io_addr + USBSTS);
+        status = uhci_readw(uhci, USBSTS);
         if (!(status & ~USBSTS_HCH))    /* shared interrupt, not mine */
                 return IRQ_NONE;
-        outw(status, uhci->io_addr + USBSTS);           /* Clear it */
+        uhci_writew(uhci, status, USBSTS);              /* Clear it */
 
         if (status & ~(USBSTS_USBINT | USBSTS_ERROR | USBSTS_RD)) {
                 if (status & USBSTS_HSE)
@@ -449,6 +466,7 @@ static irqreturn_t uhci_irq(struct usb_hcd *hcd)
                                         lprintk(errbuf);
                                 }
                                 uhci_hc_died(uhci);
+                                usb_hc_died(hcd);
 
                                 /* Force a callback in case there are
                                  * pending unlinks */
@@ -471,7 +489,7 @@ static irqreturn_t uhci_irq(struct usb_hcd *hcd)
 
 /*
  * Store the current frame number in uhci->frame_number if the controller
- * is runnning.  Expand from 11 bits (of which we use only 10) to a
+ * is running.  Expand from 11 bits (of which we use only 10) to a
  * full-sized integer.
  *
  * Like many other parts of the driver, this code relies on being polled
@@ -482,7 +500,7 @@ static void uhci_get_current_frame_number(struct uhci_hcd *uhci)
         if (!uhci->is_stopped) {
                 unsigned delta;
 
-                delta = (inw(uhci->io_addr + USBFRNUM) - uhci->frame_number) &
+                delta = (uhci_readw(uhci, USBFRNUM) - uhci->frame_number) &
                                 (UHCI_NUMFRAMES - 1);
                 uhci->frame_number += delta;
         }
@@ -519,61 +537,6 @@ static void release_uhci(struct uhci_hcd *uhci)
                         uhci->frame, uhci->frame_dma_handle);
 }
 
-static int uhci_init(struct usb_hcd *hcd)
-{
-        struct uhci_hcd *uhci = hcd_to_uhci(hcd);
-        unsigned io_size = (unsigned) hcd->rsrc_len;
-        int port;
-
-        uhci->io_addr = (unsigned long) hcd->rsrc_start;
-
-        /* The UHCI spec says devices must have 2 ports, and goes on to say
-         * they may have more but gives no way to determine how many there
-         * are.  However according to the UHCI spec, Bit 7 of the port
-         * status and control register is always set to 1.  So we try to
-         * use this to our advantage.  Another common failure mode when
-         * a nonexistent register is addressed is to return all ones, so
-         * we test for that also.
-         */
-        for (port = 0; port < (io_size - USBPORTSC1) / 2; port++) {
-                unsigned int portstatus;
-
-                portstatus = inw(uhci->io_addr + USBPORTSC1 + (port * 2));
-                if (!(portstatus & 0x0080) || portstatus == 0xffff)
-                        break;
-        }
-        if (debug)
-                dev_info(uhci_dev(uhci), "detected %d ports\n", port);
-
-        /* Anything greater than 7 is weird so we'll ignore it. */
-        if (port > UHCI_RH_MAXCHILD) {
-                dev_info(uhci_dev(uhci), "port count misdetected? "
-                                "forcing to 2 ports\n");
-                port = 2;
-        }
-        uhci->rh_numports = port;
-
-        /* Kick BIOS off this hardware and reset if the controller
-         * isn't already safely quiescent.
-         */
-        check_and_reset_hc(uhci);
-        return 0;
-}
-
-/* Make sure the controller is quiescent and that we're not using it
- * any more.  This is mainly for the benefit of programs which, like kexec,
- * expect the hardware to be idle: not doing DMA or generating IRQs.
- *
- * This routine may be called in a damaged or failing kernel.  Hence we
- * do not acquire the spinlock before shutting down the controller.
- */
-static void uhci_shutdown(struct pci_dev *pdev)
-{
-        struct usb_hcd *hcd = (struct usb_hcd *) pci_get_drvdata(pdev);
-
-        uhci_hc_died(hcd_to_uhci(hcd));
-}
-
 /*
  * Allocate a frame list, and then setup the skeleton
  *
@@ -668,16 +631,16 @@ static int uhci_start(struct usb_hcd *hcd)
          * 8 Interrupt queues; link all higher int queues to int1 = async
          */
         for (i = SKEL_ISO + 1; i < SKEL_ASYNC; ++i)
-                uhci->skelqh[i]->link = LINK_TO_QH(uhci->skel_async_qh);
-        uhci->skel_async_qh->link = UHCI_PTR_TERM;
-        uhci->skel_term_qh->link = LINK_TO_QH(uhci->skel_term_qh);
+                uhci->skelqh[i]->link = LINK_TO_QH(uhci, uhci->skel_async_qh);
+        uhci->skel_async_qh->link = UHCI_PTR_TERM(uhci);
+        uhci->skel_term_qh->link = LINK_TO_QH(uhci, uhci->skel_term_qh);
 
         /* This dummy TD is to work around a bug in Intel PIIX controllers */
-        uhci_fill_td(uhci->term_td, 0, uhci_explen(0) |
+        uhci_fill_td(uhci, uhci->term_td, 0, uhci_explen(0) |
                         (0x7f << TD_TOKEN_DEVADDR_SHIFT) | USB_PID_IN, 0);
-        uhci->term_td->link = UHCI_PTR_TERM;
+        uhci->term_td->link = UHCI_PTR_TERM(uhci);
         uhci->skel_async_qh->element = uhci->skel_term_qh->element =
-                        LINK_TO_TD(uhci->term_td);
+                LINK_TO_TD(uhci, uhci->term_td);
 
         /*
          * Fill the frame list: make all entries point to the proper
@@ -790,86 +753,6 @@ static int uhci_rh_resume(struct usb_hcd *hcd)
         return rc;
 }
 
-static int uhci_pci_suspend(struct usb_hcd *hcd, bool do_wakeup)
-{
-        struct uhci_hcd *uhci = hcd_to_uhci(hcd);
-        struct pci_dev *pdev = to_pci_dev(uhci_dev(uhci));
-        int rc = 0;
-
-        dev_dbg(uhci_dev(uhci), "%s\n", __func__);
-
-        spin_lock_irq(&uhci->lock);
-        if (!HCD_HW_ACCESSIBLE(hcd) || uhci->dead)
-                goto done_okay;         /* Already suspended or dead */
-
-        if (uhci->rh_state > UHCI_RH_SUSPENDED) {
-                dev_warn(uhci_dev(uhci), "Root hub isn't suspended!\n");
-                rc = -EBUSY;
-                goto done;
-        };
-
-        /* All PCI host controllers are required to disable IRQ generation
-         * at the source, so we must turn off PIRQ.
-         */
-        pci_write_config_word(pdev, USBLEGSUP, 0);
-        clear_bit(HCD_FLAG_POLL_RH, &hcd->flags);
-
-        /* Enable platform-specific non-PME# wakeup */
-        if (do_wakeup) {
-                if (pdev->vendor == PCI_VENDOR_ID_INTEL)
-                        pci_write_config_byte(pdev, USBRES_INTEL,
-                                        USBPORT1EN | USBPORT2EN);
-        }
-
-done_okay:
-        clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
-done:
-        spin_unlock_irq(&uhci->lock);
-        return rc;
-}
-
-static int uhci_pci_resume(struct usb_hcd *hcd, bool hibernated)
-{
-        struct uhci_hcd *uhci = hcd_to_uhci(hcd);
-
-        dev_dbg(uhci_dev(uhci), "%s\n", __func__);
-
-        /* Since we aren't in D3 any more, it's safe to set this flag
-         * even if the controller was dead.
-         */
-        set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
-
-        spin_lock_irq(&uhci->lock);
-
-        /* Make sure resume from hibernation re-enumerates everything */
-        if (hibernated)
-                uhci_hc_died(uhci);
-
-        /* The firmware or a boot kernel may have changed the controller
-         * settings during a system wakeup.  Check it and reconfigure
-         * to avoid problems.
-         */
-        check_and_reset_hc(uhci);
-
-        /* If the controller was dead before, it's back alive now */
-        configure_hc(uhci);
-
-        /* Tell the core if the controller had to be reset */
-        if (uhci->rh_state == UHCI_RH_RESET)
-                usb_root_hub_lost_power(hcd->self.root_hub);
-
-        spin_unlock_irq(&uhci->lock);
-
-        /* If interrupts don't work and remote wakeup is enabled then
-         * the suspended root hub needs to be polled.
-         */
-        if (!uhci->RD_enable && hcd->self.root_hub->do_remote_wakeup)
-                set_bit(HCD_FLAG_POLL_RH, &hcd->flags);
-
-        /* Does the root hub have a port wakeup pending? */
-        usb_hcd_poll_rh_status(hcd);
-        return 0;
-}
 #endif
 
 /* Wait until a particular device/endpoint's QH is idle, and free it */
@@ -907,67 +790,62 @@ static int uhci_hcd_get_frame_number(struct usb_hcd *hcd)
         /* Minimize latency by avoiding the spinlock */
         frame_number = uhci->frame_number;
         barrier();
-        delta = (inw(uhci->io_addr + USBFRNUM) - frame_number) &
+        delta = (uhci_readw(uhci, USBFRNUM) - frame_number) &
                         (UHCI_NUMFRAMES - 1);
         return frame_number + delta;
 }
 
-static const char hcd_name[] = "uhci_hcd";
-
-static const struct hc_driver uhci_driver = {
-        .description =          hcd_name,
-        .product_desc =         "UHCI Host Controller",
-        .hcd_priv_size =        sizeof(struct uhci_hcd),
-
-        /* Generic hardware linkage */
-        .irq =                  uhci_irq,
-        .flags =                HCD_USB11,
-
-        /* Basic lifecycle operations */
-        .reset =                uhci_init,
-        .start =                uhci_start,
-#ifdef CONFIG_PM
-        .pci_suspend =          uhci_pci_suspend,
-        .pci_resume =           uhci_pci_resume,
-        .bus_suspend =          uhci_rh_suspend,
-        .bus_resume =           uhci_rh_resume,
-#endif
-        .stop =                 uhci_stop,
+/* Determines number of ports on controller */
+static int uhci_count_ports(struct usb_hcd *hcd)
+{
+        struct uhci_hcd *uhci = hcd_to_uhci(hcd);
+        unsigned io_size = (unsigned) hcd->rsrc_len;
+        int port;
 
-        .urb_enqueue =          uhci_urb_enqueue,
-        .urb_dequeue =          uhci_urb_dequeue,
+        /* The UHCI spec says devices must have 2 ports, and goes on to say
+         * they may have more but gives no way to determine how many there
+         * are.  However according to the UHCI spec, Bit 7 of the port
+         * status and control register is always set to 1.  So we try to
+         * use this to our advantage.  Another common failure mode when
+         * a nonexistent register is addressed is to return all ones, so
+         * we test for that also.
+         */
+        for (port = 0; port < (io_size - USBPORTSC1) / 2; port++) {
+                unsigned int portstatus;
 
-        .endpoint_disable =     uhci_hcd_endpoint_disable,
-        .get_frame_number =     uhci_hcd_get_frame_number,
+                portstatus = uhci_readw(uhci, USBPORTSC1 + (port * 2));
+                if (!(portstatus & 0x0080) || portstatus == 0xffff)
+                        break;
+        }
+        if (debug)
+                dev_info(uhci_dev(uhci), "detected %d ports\n", port);
 
-        .hub_status_data =      uhci_hub_status_data,
-        .hub_control =          uhci_hub_control,
-};
+        /* Anything greater than 7 is weird so we'll ignore it. */
+        if (port > UHCI_RH_MAXCHILD) {
+                dev_info(uhci_dev(uhci), "port count misdetected? "
+                                "forcing to 2 ports\n");
+                port = 2;
+        }
 
-static const struct pci_device_id uhci_pci_ids[] = { {
-        /* handle any USB UHCI controller */
-        PCI_DEVICE_CLASS(PCI_CLASS_SERIAL_USB_UHCI, ~0),
-        .driver_data =  (unsigned long) &uhci_driver,
-        }, { /* end: all zeroes */ }
-};
+        return port;
+}
 
-MODULE_DEVICE_TABLE(pci, uhci_pci_ids);
+static const char hcd_name[] = "uhci_hcd";
 
-static struct pci_driver uhci_pci_driver = {
-        .name =         (char *)hcd_name,
-        .id_table =     uhci_pci_ids,
+#ifdef CONFIG_PCI
+#include "uhci-pci.c"
+#define PCI_DRIVER              uhci_pci_driver
+#endif
 
-        .probe =        usb_hcd_pci_probe,
-        .remove =       usb_hcd_pci_remove,
-        .shutdown =     uhci_shutdown,
+#ifdef CONFIG_SPARC_LEON
+#include "uhci-grlib.c"
+#define PLATFORM_DRIVER         uhci_grlib_driver
+#endif
 
-#ifdef CONFIG_PM_SLEEP
-        .driver =       {
-                .pm =   &usb_hcd_pci_pm_ops
-        },
+#if !defined(PCI_DRIVER) && !defined(PLATFORM_DRIVER)
+#error "missing bus glue for uhci-hcd"
 #endif
-};
- 
+
 static int __init uhci_hcd_init(void)
 {
         int retval = -ENOMEM;
@@ -993,13 +871,27 @@ static int __init uhci_hcd_init(void)
         if (!uhci_up_cachep)
                 goto up_failed;
 
-        retval = pci_register_driver(&uhci_pci_driver);
-        if (retval)
-                goto init_failed;
+#ifdef PLATFORM_DRIVER
+        retval = platform_driver_register(&PLATFORM_DRIVER);
+        if (retval < 0)
+                goto clean0;
+#endif
+
+#ifdef PCI_DRIVER
+        retval = pci_register_driver(&PCI_DRIVER);
+        if (retval < 0)
+                goto clean1;
+#endif
 
         return 0;
 
-init_failed:
+#ifdef PCI_DRIVER
+clean1:
+#endif
+#ifdef PLATFORM_DRIVER
+        platform_driver_unregister(&PLATFORM_DRIVER);
+clean0:
+#endif
         kmem_cache_destroy(uhci_up_cachep);
 
 up_failed:
@@ -1016,7 +908,12 @@ errbuf_failed:
 
 static void __exit uhci_hcd_cleanup(void) 
 {
-        pci_unregister_driver(&uhci_pci_driver);
+#ifdef PLATFORM_DRIVER
+        platform_driver_unregister(&PLATFORM_DRIVER);
+#endif
+#ifdef PCI_DRIVER
+        pci_unregister_driver(&PCI_DRIVER);
+#endif
         kmem_cache_destroy(uhci_up_cachep);
         debugfs_remove(uhci_debugfs_root);
         kfree(errbuf);
diff --git a/drivers/usb/host/uhci-hcd.h b/drivers/usb/host/uhci-hcd.h
index 49bf2790f9c2..7af2b7052047 100644
--- a/drivers/usb/host/uhci-hcd.h
+++ b/drivers/usb/host/uhci-hcd.h
@@ -78,11 +78,11 @@
 #define   USBPORT1EN            0x01
 #define   USBPORT2EN            0x02
 
-#define UHCI_PTR_BITS           cpu_to_le32(0x000F)
-#define UHCI_PTR_TERM           cpu_to_le32(0x0001)
-#define UHCI_PTR_QH             cpu_to_le32(0x0002)
-#define UHCI_PTR_DEPTH          cpu_to_le32(0x0004)
-#define UHCI_PTR_BREADTH        cpu_to_le32(0x0000)
+#define UHCI_PTR_BITS(uhci)     cpu_to_hc32((uhci), 0x000F)
+#define UHCI_PTR_TERM(uhci)     cpu_to_hc32((uhci), 0x0001)
+#define UHCI_PTR_QH(uhci)       cpu_to_hc32((uhci), 0x0002)
+#define UHCI_PTR_DEPTH(uhci)    cpu_to_hc32((uhci), 0x0004)
+#define UHCI_PTR_BREADTH(uhci)  cpu_to_hc32((uhci), 0x0000)
 
 #define UHCI_NUMFRAMES          1024    /* in the frame list [array] */
 #define UHCI_MAX_SOF_NUMBER     2047    /* in an SOF packet */
@@ -99,6 +99,22 @@
 
 
 /*
+ * __hc32 and __hc16 are "Host Controller" types, they may be equivalent to
+ * __leXX (normally) or __beXX (given UHCI_BIG_ENDIAN_DESC), depending on
+ * the host controller implementation.
+ *
+ * To facilitate the strongest possible byte-order checking from "sparse"
+ * and so on, we use __leXX unless that's not practical.
+ */
+#ifdef CONFIG_USB_UHCI_BIG_ENDIAN_DESC
+typedef __u32 __bitwise __hc32;
+typedef __u16 __bitwise __hc16;
+#else
+#define __hc32  __le32
+#define __hc16  __le16
+#endif
+
+/*
  *      Queue Headers
  */
 
@@ -130,8 +146,8 @@
 
 struct uhci_qh {
         /* Hardware fields */
-        __le32 link;                    /* Next QH in the schedule */
-        __le32 element;                 /* Queue element (TD) pointer */
+        __hc32 link;                    /* Next QH in the schedule */
+        __hc32 element;                 /* Queue element (TD) pointer */
 
         /* Software fields */
         dma_addr_t dma_handle;
@@ -168,14 +184,10 @@ struct uhci_qh {
  * We need a special accessor for the element pointer because it is
  * subject to asynchronous updates by the controller.
  */
-static inline __le32 qh_element(struct uhci_qh *qh) {
-        __le32 element = qh->element;
+#define qh_element(qh)          ACCESS_ONCE((qh)->element)
 
-        barrier();
-        return element;
-}
-
-#define LINK_TO_QH(qh)          (UHCI_PTR_QH | cpu_to_le32((qh)->dma_handle))
+#define LINK_TO_QH(uhci, qh)    (UHCI_PTR_QH((uhci)) | \
+                                cpu_to_hc32((uhci), (qh)->dma_handle))
 
 
 /*
@@ -212,7 +224,7 @@ static inline __le32 qh_element(struct uhci_qh *qh) {
 /*
  * for TD <info>: (a.k.a. Token)
  */
-#define td_token(td)            le32_to_cpu((td)->token)
+#define td_token(uhci, td)      hc32_to_cpu((uhci), (td)->token)
 #define TD_TOKEN_DEVADDR_SHIFT  8
 #define TD_TOKEN_TOGGLE_SHIFT   19
 #define TD_TOKEN_TOGGLE         (1 << 19)
@@ -245,10 +257,10 @@ static inline __le32 qh_element(struct uhci_qh *qh) {
  */
 struct uhci_td {
         /* Hardware fields */
-        __le32 link;
-        __le32 status;
-        __le32 token;
-        __le32 buffer;
+        __hc32 link;
+        __hc32 status;
+        __hc32 token;
+        __hc32 buffer;
 
         /* Software fields */
         dma_addr_t dma_handle;
@@ -263,14 +275,10 @@ struct uhci_td {
  * We need a special accessor for the control/status word because it is
  * subject to asynchronous updates by the controller.
  */
-static inline u32 td_status(struct uhci_td *td) {
-        __le32 status = td->status;
+#define td_status(uhci, td)             hc32_to_cpu((uhci), \
+                                                ACCESS_ONCE((td)->status))
 
-        barrier();
-        return le32_to_cpu(status);
-}
-
-#define LINK_TO_TD(td)          (cpu_to_le32((td)->dma_handle))
+#define LINK_TO_TD(uhci, td)            (cpu_to_hc32((uhci), (td)->dma_handle))
 
 
 /*
@@ -380,6 +388,9 @@ struct uhci_hcd {
         /* Grabbed from PCI */
         unsigned long io_addr;
 
+        /* Used when registers are memory mapped */
+        void __iomem *regs;
+
         struct dma_pool *qh_pool;
         struct dma_pool *td_pool;
 
@@ -390,7 +401,7 @@ struct uhci_hcd {
         spinlock_t lock;
 
         dma_addr_t frame_dma_handle;    /* Hardware frame list */
-        __le32 *frame;
+        __hc32 *frame;
         void **frame_cpu;               /* CPU's frame list */
 
         enum uhci_rh_state rh_state;
@@ -415,6 +426,12 @@ struct uhci_hcd {
 
         struct timer_list fsbr_timer;           /* For turning off FBSR */
 
+        /* Silicon quirks */
+        unsigned int oc_low:1;                  /* OverCurrent bit active low */
+        unsigned int wait_for_hp:1;             /* Wait for HP port reset */
+        unsigned int big_endian_mmio:1;         /* Big endian registers */
+        unsigned int big_endian_desc:1;         /* Big endian descriptors */
+
         /* Support for port suspend/resume/reset */
         unsigned long port_c_suspend;           /* Bit-arrays of ports */
         unsigned long resuming_ports;
@@ -429,6 +446,16 @@ struct uhci_hcd {
 
         int total_load;                         /* Sum of array values */
         short load[MAX_PHASE];                  /* Periodic allocations */
+
+        /* Reset host controller */
+        void    (*reset_hc) (struct uhci_hcd *uhci);
+        int     (*check_and_reset_hc) (struct uhci_hcd *uhci);
+        /* configure_hc should perform arch specific settings, if needed */
+        void    (*configure_hc) (struct uhci_hcd *uhci);
+        /* Check for broken resume detect interrupts */
+        int     (*resume_detect_interrupts_are_broken) (struct uhci_hcd *uhci);
+        /* Check for broken global suspend */
+        int     (*global_suspend_mode_is_broken) (struct uhci_hcd *uhci);
 };
 
 /* Convert between a usb_hcd pointer and the corresponding uhci_hcd */
@@ -467,4 +494,171 @@ struct urb_priv {
 #define PCI_VENDOR_ID_GENESYS           0x17a0
 #define PCI_DEVICE_ID_GL880S_UHCI       0x8083
 
+/*
+ * Functions used to access controller registers. The UCHI spec says that host
+ * controller I/O registers are mapped into PCI I/O space. For non-PCI hosts
+ * we use memory mapped registers.
+ */
+
+#ifndef CONFIG_USB_UHCI_SUPPORT_NON_PCI_HC
+/* Support PCI only */
+static inline u32 uhci_readl(const struct uhci_hcd *uhci, int reg)
+{
+        return inl(uhci->io_addr + reg);
+}
+
+static inline void uhci_writel(const struct uhci_hcd *uhci, u32 val, int reg)
+{
+        outl(val, uhci->io_addr + reg);
+}
+
+static inline u16 uhci_readw(const struct uhci_hcd *uhci, int reg)
+{
+        return inw(uhci->io_addr + reg);
+}
+
+static inline void uhci_writew(const struct uhci_hcd *uhci, u16 val, int reg)
+{
+        outw(val, uhci->io_addr + reg);
+}
+
+static inline u8 uhci_readb(const struct uhci_hcd *uhci, int reg)
+{
+        return inb(uhci->io_addr + reg);
+}
+
+static inline void uhci_writeb(const struct uhci_hcd *uhci, u8 val, int reg)
+{
+        outb(val, uhci->io_addr + reg);
+}
+
+#else
+/* Support non-PCI host controllers */
+#ifdef CONFIG_PCI
+/* Support PCI and non-PCI host controllers */
+#define uhci_has_pci_registers(u)       ((u)->io_addr != 0)
+#else
+/* Support non-PCI host controllers only */
+#define uhci_has_pci_registers(u)       0
+#endif
+
+#ifdef CONFIG_USB_UHCI_BIG_ENDIAN_MMIO
+/* Support (non-PCI) big endian host controllers */
+#define uhci_big_endian_mmio(u)         ((u)->big_endian_mmio)
+#else
+#define uhci_big_endian_mmio(u)         0
+#endif
+
+static inline u32 uhci_readl(const struct uhci_hcd *uhci, int reg)
+{
+        if (uhci_has_pci_registers(uhci))
+                return inl(uhci->io_addr + reg);
+#ifdef CONFIG_USB_UHCI_BIG_ENDIAN_MMIO
+        else if (uhci_big_endian_mmio(uhci))
+                return readl_be(uhci->regs + reg);
+#endif
+        else
+                return readl(uhci->regs + reg);
+}
+
+static inline void uhci_writel(const struct uhci_hcd *uhci, u32 val, int reg)
+{
+        if (uhci_has_pci_registers(uhci))
+                outl(val, uhci->io_addr + reg);
+#ifdef CONFIG_USB_UHCI_BIG_ENDIAN_MMIO
+        else if (uhci_big_endian_mmio(uhci))
+                writel_be(val, uhci->regs + reg);
+#endif
+        else
+                writel(val, uhci->regs + reg);
+}
+
+static inline u16 uhci_readw(const struct uhci_hcd *uhci, int reg)
+{
+        if (uhci_has_pci_registers(uhci))
+                return inw(uhci->io_addr + reg);
+#ifdef CONFIG_USB_UHCI_BIG_ENDIAN_MMIO
+        else if (uhci_big_endian_mmio(uhci))
+                return readw_be(uhci->regs + reg);
+#endif
+        else
+                return readw(uhci->regs + reg);
+}
+
+static inline void uhci_writew(const struct uhci_hcd *uhci, u16 val, int reg)
+{
+        if (uhci_has_pci_registers(uhci))
+                outw(val, uhci->io_addr + reg);
+#ifdef CONFIG_USB_UHCI_BIG_ENDIAN_MMIO
+        else if (uhci_big_endian_mmio(uhci))
+                writew_be(val, uhci->regs + reg);
+#endif
+        else
+                writew(val, uhci->regs + reg);
+}
+
+static inline u8 uhci_readb(const struct uhci_hcd *uhci, int reg)
+{
+        if (uhci_has_pci_registers(uhci))
+                return inb(uhci->io_addr + reg);
+#ifdef CONFIG_USB_UHCI_BIG_ENDIAN_MMIO
+        else if (uhci_big_endian_mmio(uhci))
+                return readb_be(uhci->regs + reg);
+#endif
+        else
+                return readb(uhci->regs + reg);
+}
+
+static inline void uhci_writeb(const struct uhci_hcd *uhci, u8 val, int reg)
+{
+        if (uhci_has_pci_registers(uhci))
+                outb(val, uhci->io_addr + reg);
+#ifdef CONFIG_USB_UHCI_BIG_ENDIAN_MMIO
+        else if (uhci_big_endian_mmio(uhci))
+                writeb_be(val, uhci->regs + reg);
+#endif
+        else
+                writeb(val, uhci->regs + reg);
+}
+#endif /* CONFIG_USB_UHCI_SUPPORT_NON_PCI_HC */
+
+/*
+ * The GRLIB GRUSBHC controller can use big endian format for its descriptors.
+ *
+ * UHCI controllers accessed through PCI work normally (little-endian
+ * everywhere), so we don't bother supporting a BE-only mode.
+ */
+#ifdef CONFIG_USB_UHCI_BIG_ENDIAN_DESC
+#define uhci_big_endian_desc(u)         ((u)->big_endian_desc)
+
+/* cpu to uhci */
+static inline __hc32 cpu_to_hc32(const struct uhci_hcd *uhci, const u32 x)
+{
+        return uhci_big_endian_desc(uhci)
+                ? (__force __hc32)cpu_to_be32(x)
+                : (__force __hc32)cpu_to_le32(x);
+}
+
+/* uhci to cpu */
+static inline u32 hc32_to_cpu(const struct uhci_hcd *uhci, const __hc32 x)
+{
+        return uhci_big_endian_desc(uhci)
+                ? be32_to_cpu((__force __be32)x)
+                : le32_to_cpu((__force __le32)x);
+}
+
+#else
+/* cpu to uhci */
+static inline __hc32 cpu_to_hc32(const struct uhci_hcd *uhci, const u32 x)
+{
+        return cpu_to_le32(x);
+}
+
+/* uhci to cpu */
+static inline u32 hc32_to_cpu(const struct uhci_hcd *uhci, const __hc32 x)
+{
+        return le32_to_cpu(x);
+}
+#endif
+
 #endif
diff --git a/drivers/usb/host/uhci-hub.c b/drivers/usb/host/uhci-hub.c
index 6d59c0f77f25..045cde4cbc3d 100644
--- a/drivers/usb/host/uhci-hub.c
+++ b/drivers/usb/host/uhci-hub.c
@@ -44,7 +44,7 @@ static int any_ports_active(struct uhci_hcd *uhci)
         int port;
 
         for (port = 0; port < uhci->rh_numports; ++port) {
-                if ((inw(uhci->io_addr + USBPORTSC1 + port * 2) &
+                if ((uhci_readw(uhci, USBPORTSC1 + port * 2) &
                                 (USBPORTSC_CCS | RWC_BITS)) ||
                                 test_bit(port, &uhci->port_c_suspend))
                         return 1;
@@ -68,7 +68,7 @@ static inline int get_hub_status_data(struct uhci_hcd *uhci, char *buf)
 
         *buf = 0;
         for (port = 0; port < uhci->rh_numports; ++port) {
-                if ((inw(uhci->io_addr + USBPORTSC1 + port * 2) & mask) ||
+                if ((uhci_readw(uhci, USBPORTSC1 + port * 2) & mask) ||
                                 test_bit(port, &uhci->port_c_suspend))
                         *buf |= (1 << (port + 1));
         }
@@ -78,17 +78,17 @@ static inline int get_hub_status_data(struct uhci_hcd *uhci, char *buf)
 #define OK(x)                   len = (x); break
 
 #define CLR_RH_PORTSTAT(x) \
-        status = inw(port_addr); \
+        status = uhci_readw(uhci, port_addr);   \
         status &= ~(RWC_BITS|WZ_BITS); \
         status &= ~(x); \
         status |= RWC_BITS & (x); \
-        outw(status, port_addr)
+        uhci_writew(uhci, status, port_addr)
 
 #define SET_RH_PORTSTAT(x) \
-        status = inw(port_addr); \
+        status = uhci_readw(uhci, port_addr);   \
         status |= (x); \
         status &= ~(RWC_BITS|WZ_BITS); \
-        outw(status, port_addr)
+        uhci_writew(uhci, status, port_addr)
 
 /* UHCI controllers don't automatically stop resume signalling after 20 msec,
  * so we have to poll and check timeouts in order to take care of it.
@@ -99,7 +99,7 @@ static void uhci_finish_suspend(struct uhci_hcd *uhci, int port,
         int status;
         int i;
 
-        if (inw(port_addr) & SUSPEND_BITS) {
+        if (uhci_readw(uhci, port_addr) & SUSPEND_BITS) {
                 CLR_RH_PORTSTAT(SUSPEND_BITS);
                 if (test_bit(port, &uhci->resuming_ports))
                         set_bit(port, &uhci->port_c_suspend);
@@ -110,7 +110,7 @@ static void uhci_finish_suspend(struct uhci_hcd *uhci, int port,
                  * Experiments show that some controllers take longer, so
                  * we'll poll for completion. */
                 for (i = 0; i < 10; ++i) {
-                        if (!(inw(port_addr) & SUSPEND_BITS))
+                        if (!(uhci_readw(uhci, port_addr) & SUSPEND_BITS))
                                 break;
                         udelay(1);
                 }
@@ -121,12 +121,12 @@ static void uhci_finish_suspend(struct uhci_hcd *uhci, int port,
 /* Wait for the UHCI controller in HP's iLO2 server management chip.
  * It can take up to 250 us to finish a reset and set the CSC bit.
  */
-static void wait_for_HP(unsigned long port_addr)
+static void wait_for_HP(struct uhci_hcd *uhci, unsigned long port_addr)
 {
         int i;
 
         for (i = 10; i < 250; i += 10) {
-                if (inw(port_addr) & USBPORTSC_CSC)
+                if (uhci_readw(uhci, port_addr) & USBPORTSC_CSC)
                         return;
                 udelay(10);
         }
@@ -140,8 +140,8 @@ static void uhci_check_ports(struct uhci_hcd *uhci)
         int status;
 
         for (port = 0; port < uhci->rh_numports; ++port) {
-                port_addr = uhci->io_addr + USBPORTSC1 + 2 * port;
-                status = inw(port_addr);
+                port_addr = USBPORTSC1 + 2 * port;
+                status = uhci_readw(uhci, port_addr);
                 if (unlikely(status & USBPORTSC_PR)) {
                         if (time_after_eq(jiffies, uhci->ports_timeout)) {
                                 CLR_RH_PORTSTAT(USBPORTSC_PR);
@@ -149,9 +149,8 @@ static void uhci_check_ports(struct uhci_hcd *uhci)
 
                                 /* HP's server management chip requires
                                  * a longer delay. */
-                                if (to_pci_dev(uhci_dev(uhci))->vendor ==
-                                                PCI_VENDOR_ID_HP)
-                                        wait_for_HP(port_addr);
+                                if (uhci->wait_for_hp)
+                                        wait_for_HP(uhci, port_addr);
 
                                 /* If the port was enabled before, turning
                                  * reset on caused a port enable change.
@@ -242,7 +241,7 @@ static int uhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
         struct uhci_hcd *uhci = hcd_to_uhci(hcd);
         int status, lstatus, retval = 0, len = 0;
         unsigned int port = wIndex - 1;
-        unsigned long port_addr = uhci->io_addr + USBPORTSC1 + 2 * port;
+        unsigned long port_addr = USBPORTSC1 + 2 * port;
         u16 wPortChange, wPortStatus;
         unsigned long flags;
 
@@ -260,14 +259,13 @@ static int uhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                         goto err;
 
                 uhci_check_ports(uhci);
-                status = inw(port_addr);
+                status = uhci_readw(uhci, port_addr);
 
                 /* Intel controllers report the OverCurrent bit active on.
                  * VIA controllers report it active off, so we'll adjust the
                  * bit value.  (It's not standardized in the UHCI spec.)
                  */
-                if (to_pci_dev(hcd->self.controller)->vendor ==
-                                PCI_VENDOR_ID_VIA)
+                if (uhci->oc_low)
                         status ^= USBPORTSC_OC;
 
                 /* UHCI doesn't support C_RESET (always false) */
@@ -358,7 +356,7 @@ static int uhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                         CLR_RH_PORTSTAT(USBPORTSC_PEC);
                         OK(0);
                 case USB_PORT_FEAT_SUSPEND:
-                        if (!(inw(port_addr) & USBPORTSC_SUSP)) {
+                        if (!(uhci_readw(uhci, port_addr) & USBPORTSC_SUSP)) {
 
                                 /* Make certain the port isn't suspended */
                                 uhci_finish_suspend(uhci, port, port_addr);
@@ -370,7 +368,8 @@ static int uhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                                  * if the port is disabled.  When this happens
                                  * just skip the Resume signalling.
                                  */
-                                if (!(inw(port_addr) & USBPORTSC_RD))
+                                if (!(uhci_readw(uhci, port_addr) &
+                                                USBPORTSC_RD))
                                         uhci_finish_suspend(uhci, port,
                                                         port_addr);
                                 else
diff --git a/drivers/usb/host/uhci-pci.c b/drivers/usb/host/uhci-pci.c
new file mode 100644
index 000000000000..c300bd2f7d1c
--- /dev/null
+++ b/drivers/usb/host/uhci-pci.c
@@ -0,0 +1,301 @@
+/*
+ * UHCI HCD (Host Controller Driver) PCI Bus Glue.
+ *
+ * Extracted from uhci-hcd.c:
+ * Maintainer: Alan Stern <stern@rowland.harvard.edu>
+ *
+ * (C) Copyright 1999 Linus Torvalds
+ * (C) Copyright 1999-2002 Johannes Erdfelt, johannes@erdfelt.com
+ * (C) Copyright 1999 Randy Dunlap
+ * (C) Copyright 1999 Georg Acher, acher@in.tum.de
+ * (C) Copyright 1999 Deti Fliegl, deti@fliegl.de
+ * (C) Copyright 1999 Thomas Sailer, sailer@ife.ee.ethz.ch
+ * (C) Copyright 1999 Roman Weissgaerber, weissg@vienna.at
+ * (C) Copyright 2000 Yggdrasil Computing, Inc. (port of new PCI interface
+ *               support from usb-ohci.c by Adam Richter, adam@yggdrasil.com).
+ * (C) Copyright 1999 Gregory P. Smith (from usb-ohci.c)
+ * (C) Copyright 2004-2007 Alan Stern, stern@rowland.harvard.edu
+ */
+
+#include "pci-quirks.h"
+
+/*
+ * Make sure the controller is completely inactive, unable to
+ * generate interrupts or do DMA.
+ */
+static void uhci_pci_reset_hc(struct uhci_hcd *uhci)
+{
+        uhci_reset_hc(to_pci_dev(uhci_dev(uhci)), uhci->io_addr);
+}
+
+/*
+ * Initialize a controller that was newly discovered or has just been
+ * resumed.  In either case we can't be sure of its previous state.
+ *
+ * Returns: 1 if the controller was reset, 0 otherwise.
+ */
+static int uhci_pci_check_and_reset_hc(struct uhci_hcd *uhci)
+{
+        return uhci_check_and_reset_hc(to_pci_dev(uhci_dev(uhci)),
+                                uhci->io_addr);
+}
+
+/*
+ * Store the basic register settings needed by the controller.
+ * This function is called at the end of configure_hc in uhci-hcd.c.
+ */
+static void uhci_pci_configure_hc(struct uhci_hcd *uhci)
+{
+        struct pci_dev *pdev = to_pci_dev(uhci_dev(uhci));
+
+        /* Enable PIRQ */
+        pci_write_config_word(pdev, USBLEGSUP, USBLEGSUP_DEFAULT);
+
+        /* Disable platform-specific non-PME# wakeup */
+        if (pdev->vendor == PCI_VENDOR_ID_INTEL)
+                pci_write_config_byte(pdev, USBRES_INTEL, 0);
+}
+
+static int uhci_pci_resume_detect_interrupts_are_broken(struct uhci_hcd *uhci)
+{
+        int port;
+
+        switch (to_pci_dev(uhci_dev(uhci))->vendor) {
+        default:
+                break;
+
+        case PCI_VENDOR_ID_GENESYS:
+                /* Genesys Logic's GL880S controllers don't generate
+                 * resume-detect interrupts.
+                 */
+                return 1;
+
+        case PCI_VENDOR_ID_INTEL:
+                /* Some of Intel's USB controllers have a bug that causes
+                 * resume-detect interrupts if any port has an over-current
+                 * condition.  To make matters worse, some motherboards
+                 * hardwire unused USB ports' over-current inputs active!
+                 * To prevent problems, we will not enable resume-detect
+                 * interrupts if any ports are OC.
+                 */
+                for (port = 0; port < uhci->rh_numports; ++port) {
+                        if (inw(uhci->io_addr + USBPORTSC1 + port * 2) &
+                                        USBPORTSC_OC)
+                                return 1;
+                }
+                break;
+        }
+        return 0;
+}
+
+static int uhci_pci_global_suspend_mode_is_broken(struct uhci_hcd *uhci)
+{
+        int port;
+        const char *sys_info;
+        static const char bad_Asus_board[] = "A7V8X";
+
+        /* One of Asus's motherboards has a bug which causes it to
+         * wake up immediately from suspend-to-RAM if any of the ports
+         * are connected.  In such cases we will not set EGSM.
+         */
+        sys_info = dmi_get_system_info(DMI_BOARD_NAME);
+        if (sys_info && !strcmp(sys_info, bad_Asus_board)) {
+                for (port = 0; port < uhci->rh_numports; ++port) {
+                        if (inw(uhci->io_addr + USBPORTSC1 + port * 2) &
+                                        USBPORTSC_CCS)
+                                return 1;
+                }
+        }
+
+        return 0;
+}
+
+static int uhci_pci_init(struct usb_hcd *hcd)
+{
+        struct uhci_hcd *uhci = hcd_to_uhci(hcd);
+
+        uhci->io_addr = (unsigned long) hcd->rsrc_start;
+
+        uhci->rh_numports = uhci_count_ports(hcd);
+
+        /* Intel controllers report the OverCurrent bit active on.
+         * VIA controllers report it active off, so we'll adjust the
+         * bit value.  (It's not standardized in the UHCI spec.)
+         */
+        if (to_pci_dev(uhci_dev(uhci))->vendor == PCI_VENDOR_ID_VIA)
+                uhci->oc_low = 1;
+
+        /* HP's server management chip requires a longer port reset delay. */
+        if (to_pci_dev(uhci_dev(uhci))->vendor == PCI_VENDOR_ID_HP)
+                uhci->wait_for_hp = 1;
+
+        /* Set up pointers to PCI-specific functions */
+        uhci->reset_hc = uhci_pci_reset_hc;
+        uhci->check_and_reset_hc = uhci_pci_check_and_reset_hc;
+        uhci->configure_hc = uhci_pci_configure_hc;
+        uhci->resume_detect_interrupts_are_broken =
+                uhci_pci_resume_detect_interrupts_are_broken;
+        uhci->global_suspend_mode_is_broken =
+                uhci_pci_global_suspend_mode_is_broken;
+
+
+        /* Kick BIOS off this hardware and reset if the controller
+         * isn't already safely quiescent.
+         */
+        check_and_reset_hc(uhci);
+        return 0;
+}
+
+/* Make sure the controller is quiescent and that we're not using it
+ * any more.  This is mainly for the benefit of programs which, like kexec,
+ * expect the hardware to be idle: not doing DMA or generating IRQs.
+ *
+ * This routine may be called in a damaged or failing kernel.  Hence we
+ * do not acquire the spinlock before shutting down the controller.
+ */
+static void uhci_shutdown(struct pci_dev *pdev)
+{
+        struct usb_hcd *hcd = pci_get_drvdata(pdev);
+
+        uhci_hc_died(hcd_to_uhci(hcd));
+}
+
+#ifdef CONFIG_PM
+
+static int uhci_pci_suspend(struct usb_hcd *hcd, bool do_wakeup)
+{
+        struct uhci_hcd *uhci = hcd_to_uhci(hcd);
+        struct pci_dev *pdev = to_pci_dev(uhci_dev(uhci));
+        int rc = 0;
+
+        dev_dbg(uhci_dev(uhci), "%s\n", __func__);
+
+        spin_lock_irq(&uhci->lock);
+        if (!HCD_HW_ACCESSIBLE(hcd) || uhci->dead)
+                goto done_okay;         /* Already suspended or dead */
+
+        if (uhci->rh_state > UHCI_RH_SUSPENDED) {
+                dev_warn(uhci_dev(uhci), "Root hub isn't suspended!\n");
+                rc = -EBUSY;
+                goto done;
+        };
+
+        /* All PCI host controllers are required to disable IRQ generation
+         * at the source, so we must turn off PIRQ.
+         */
+        pci_write_config_word(pdev, USBLEGSUP, 0);
+        clear_bit(HCD_FLAG_POLL_RH, &hcd->flags);
+
+        /* Enable platform-specific non-PME# wakeup */
+        if (do_wakeup) {
+                if (pdev->vendor == PCI_VENDOR_ID_INTEL)
+                        pci_write_config_byte(pdev, USBRES_INTEL,
+                                        USBPORT1EN | USBPORT2EN);
+        }
+
+done_okay:
+        clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
+done:
+        spin_unlock_irq(&uhci->lock);
+        return rc;
+}
+
+static int uhci_pci_resume(struct usb_hcd *hcd, bool hibernated)
+{
+        struct uhci_hcd *uhci = hcd_to_uhci(hcd);
+
+        dev_dbg(uhci_dev(uhci), "%s\n", __func__);
+
+        /* Since we aren't in D3 any more, it's safe to set this flag
+         * even if the controller was dead.
+         */
+        set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
+
+        spin_lock_irq(&uhci->lock);
+
+        /* Make sure resume from hibernation re-enumerates everything */
+        if (hibernated) {
+                uhci->reset_hc(uhci);
+                finish_reset(uhci);
+        }
+
+        /* The firmware may have changed the controller settings during
+         * a system wakeup.  Check it and reconfigure to avoid problems.
+         */
+        else {
+                check_and_reset_hc(uhci);
+        }
+        configure_hc(uhci);
+
+        /* Tell the core if the controller had to be reset */
+        if (uhci->rh_state == UHCI_RH_RESET)
+                usb_root_hub_lost_power(hcd->self.root_hub);
+
+        spin_unlock_irq(&uhci->lock);
+
+        /* If interrupts don't work and remote wakeup is enabled then
+         * the suspended root hub needs to be polled.
+         */
+        if (!uhci->RD_enable && hcd->self.root_hub->do_remote_wakeup)
+                set_bit(HCD_FLAG_POLL_RH, &hcd->flags);
+
+        /* Does the root hub have a port wakeup pending? */
+        usb_hcd_poll_rh_status(hcd);
+        return 0;
+}
+
+#endif
+
+static const struct hc_driver uhci_driver = {
+        .description =          hcd_name,
+        .product_desc =         "UHCI Host Controller",
+        .hcd_priv_size =        sizeof(struct uhci_hcd),
+
+        /* Generic hardware linkage */
+        .irq =                  uhci_irq,
+        .flags =                HCD_USB11,
+
+        /* Basic lifecycle operations */
+        .reset =                uhci_pci_init,
+        .start =                uhci_start,
+#ifdef CONFIG_PM
+        .pci_suspend =          uhci_pci_suspend,
+        .pci_resume =           uhci_pci_resume,
+        .bus_suspend =          uhci_rh_suspend,
+        .bus_resume =           uhci_rh_resume,
+#endif
+        .stop =                 uhci_stop,
+
+        .urb_enqueue =          uhci_urb_enqueue,
+        .urb_dequeue =          uhci_urb_dequeue,
+
+        .endpoint_disable =     uhci_hcd_endpoint_disable,
+        .get_frame_number =     uhci_hcd_get_frame_number,
+
+        .hub_status_data =      uhci_hub_status_data,
+        .hub_control =          uhci_hub_control,
+};
+
+static DEFINE_PCI_DEVICE_TABLE(uhci_pci_ids) = { {
+        /* handle any USB UHCI controller */
+        PCI_DEVICE_CLASS(PCI_CLASS_SERIAL_USB_UHCI, ~0),
+        .driver_data =  (unsigned long) &uhci_driver,
+        }, { /* end: all zeroes */ }
+};
+
+MODULE_DEVICE_TABLE(pci, uhci_pci_ids);
+
+static struct pci_driver uhci_pci_driver = {
+        .name =         (char *)hcd_name,
+        .id_table =     uhci_pci_ids,
+
+        .probe =        usb_hcd_pci_probe,
+        .remove =       usb_hcd_pci_remove,
+        .shutdown =     uhci_shutdown,
+
+#ifdef CONFIG_PM_SLEEP
+        .driver =       {
+                .pm =   &usb_hcd_pci_pm_ops
+        },
+#endif
+};
diff --git a/drivers/usb/host/uhci-q.c b/drivers/usb/host/uhci-q.c
index d3ade4018487..84ed28b34f93 100644
--- a/drivers/usb/host/uhci-q.c
+++ b/drivers/usb/host/uhci-q.c
@@ -29,12 +29,12 @@ static void uhci_set_next_interrupt(struct uhci_hcd *uhci)
 {
         if (uhci->is_stopped)
                 mod_timer(&uhci_to_hcd(uhci)->rh_timer, jiffies);
-        uhci->term_td->status |= cpu_to_le32(TD_CTRL_IOC); 
+        uhci->term_td->status |= cpu_to_hc32(uhci, TD_CTRL_IOC);
 }
 
 static inline void uhci_clear_next_interrupt(struct uhci_hcd *uhci)
 {
-        uhci->term_td->status &= ~cpu_to_le32(TD_CTRL_IOC);
+        uhci->term_td->status &= ~cpu_to_hc32(uhci, TD_CTRL_IOC);
 }
 
 
@@ -53,7 +53,7 @@ static void uhci_fsbr_on(struct uhci_hcd *uhci)
         uhci->fsbr_is_on = 1;
         lqh = list_entry(uhci->skel_async_qh->node.prev,
                         struct uhci_qh, node);
-        lqh->link = LINK_TO_QH(uhci->skel_term_qh);
+        lqh->link = LINK_TO_QH(uhci, uhci->skel_term_qh);
 }
 
 static void uhci_fsbr_off(struct uhci_hcd *uhci)
@@ -65,7 +65,7 @@ static void uhci_fsbr_off(struct uhci_hcd *uhci)
         uhci->fsbr_is_on = 0;
         lqh = list_entry(uhci->skel_async_qh->node.prev,
                         struct uhci_qh, node);
-        lqh->link = UHCI_PTR_TERM;
+        lqh->link = UHCI_PTR_TERM(uhci);
 }
 
 static void uhci_add_fsbr(struct uhci_hcd *uhci, struct urb *urb)
@@ -131,12 +131,12 @@ static void uhci_free_td(struct uhci_hcd *uhci, struct uhci_td *td)
         dma_pool_free(uhci->td_pool, td, td->dma_handle);
 }
 
-static inline void uhci_fill_td(struct uhci_td *td, u32 status,
-                u32 token, u32 buffer)
+static inline void uhci_fill_td(struct uhci_hcd *uhci, struct uhci_td *td,
+                u32 status, u32 token, u32 buffer)
 {
-        td->status = cpu_to_le32(status);
-        td->token = cpu_to_le32(token);
-        td->buffer = cpu_to_le32(buffer);
+        td->status = cpu_to_hc32(uhci, status);
+        td->token = cpu_to_hc32(uhci, token);
+        td->buffer = cpu_to_hc32(uhci, buffer);
 }
 
 static void uhci_add_td_to_urbp(struct uhci_td *td, struct urb_priv *urbp)
@@ -170,11 +170,11 @@ static inline void uhci_insert_td_in_frame_list(struct uhci_hcd *uhci,
 
                 td->link = ltd->link;
                 wmb();
-                ltd->link = LINK_TO_TD(td);
+                ltd->link = LINK_TO_TD(uhci, td);
         } else {
                 td->link = uhci->frame[framenum];
                 wmb();
-                uhci->frame[framenum] = LINK_TO_TD(td);
+                uhci->frame[framenum] = LINK_TO_TD(uhci, td);
                 uhci->frame_cpu[framenum] = td;
         }
 }
@@ -195,8 +195,10 @@ static inline void uhci_remove_td_from_frame_list(struct uhci_hcd *uhci,
                 } else {
                         struct uhci_td *ntd;
 
-                        ntd = list_entry(td->fl_list.next, struct uhci_td, fl_list);
-                        uhci->frame[td->frame] = LINK_TO_TD(ntd);
+                        ntd = list_entry(td->fl_list.next,
+                                         struct uhci_td,
+                                         fl_list);
+                        uhci->frame[td->frame] = LINK_TO_TD(uhci, ntd);
                         uhci->frame_cpu[td->frame] = ntd;
                 }
         } else {
@@ -253,8 +255,8 @@ static struct uhci_qh *uhci_alloc_qh(struct uhci_hcd *uhci,
         memset(qh, 0, sizeof(*qh));
         qh->dma_handle = dma_handle;
 
-        qh->element = UHCI_PTR_TERM;
-        qh->link = UHCI_PTR_TERM;
+        qh->element = UHCI_PTR_TERM(uhci);
+        qh->link = UHCI_PTR_TERM(uhci);
 
         INIT_LIST_HEAD(&qh->queue);
         INIT_LIST_HEAD(&qh->node);
@@ -346,9 +348,9 @@ static int uhci_cleanup_queue(struct uhci_hcd *uhci, struct uhci_qh *qh,
 
         /* If the QH element pointer is UHCI_PTR_TERM then then currently
          * executing URB has already been unlinked, so this one isn't it. */
-        if (qh_element(qh) == UHCI_PTR_TERM)
+        if (qh_element(qh) == UHCI_PTR_TERM(uhci))
                 goto done;
-        qh->element = UHCI_PTR_TERM;
+        qh->element = UHCI_PTR_TERM(uhci);
 
         /* Control pipes don't have to worry about toggles */
         if (qh->type == USB_ENDPOINT_XFER_CONTROL)
@@ -358,7 +360,7 @@ static int uhci_cleanup_queue(struct uhci_hcd *uhci, struct uhci_qh *qh,
         WARN_ON(list_empty(&urbp->td_list));
         td = list_entry(urbp->td_list.next, struct uhci_td, list);
         qh->needs_fixup = 1;
-        qh->initial_toggle = uhci_toggle(td_token(td));
+        qh->initial_toggle = uhci_toggle(td_token(uhci, td));
 
 done:
         return ret;
@@ -368,7 +370,8 @@ done:
  * Fix up the data toggles for URBs in a queue, when one of them
  * terminates early (short transfer, error, or dequeued).
  */
-static void uhci_fixup_toggles(struct uhci_qh *qh, int skip_first)
+static void uhci_fixup_toggles(struct uhci_hcd *uhci, struct uhci_qh *qh,
+                        int skip_first)
 {
         struct urb_priv *urbp = NULL;
         struct uhci_td *td;
@@ -382,7 +385,7 @@ static void uhci_fixup_toggles(struct uhci_qh *qh, int skip_first)
 
         /* When starting with the first URB, if the QH element pointer is
          * still valid then we know the URB's toggles are okay. */
-        else if (qh_element(qh) != UHCI_PTR_TERM)
+        else if (qh_element(qh) != UHCI_PTR_TERM(uhci))
                 toggle = 2;
 
         /* Fix up the toggle for the URBs in the queue.  Normally this
@@ -394,15 +397,15 @@ static void uhci_fixup_toggles(struct uhci_qh *qh, int skip_first)
                 /* If the first TD has the right toggle value, we don't
                  * need to change any toggles in this URB */
                 td = list_entry(urbp->td_list.next, struct uhci_td, list);
-                if (toggle > 1 || uhci_toggle(td_token(td)) == toggle) {
+                if (toggle > 1 || uhci_toggle(td_token(uhci, td)) == toggle) {
                         td = list_entry(urbp->td_list.prev, struct uhci_td,
                                         list);
-                        toggle = uhci_toggle(td_token(td)) ^ 1;
+                        toggle = uhci_toggle(td_token(uhci, td)) ^ 1;
 
                 /* Otherwise all the toggles in the URB have to be switched */
                 } else {
                         list_for_each_entry(td, &urbp->td_list, list) {
-                                td->token ^= cpu_to_le32(
+                                td->token ^= cpu_to_hc32(uhci,
                                                         TD_TOKEN_TOGGLE);
                                 toggle ^= 1;
                         }
@@ -439,7 +442,7 @@ static void link_interrupt(struct uhci_hcd *uhci, struct uhci_qh *qh)
         pqh = list_entry(qh->node.prev, struct uhci_qh, node);
         qh->link = pqh->link;
         wmb();
-        pqh->link = LINK_TO_QH(qh);
+        pqh->link = LINK_TO_QH(uhci, qh);
 }
 
 /*
@@ -449,7 +452,7 @@ static void link_interrupt(struct uhci_hcd *uhci, struct uhci_qh *qh)
 static void link_async(struct uhci_hcd *uhci, struct uhci_qh *qh)
 {
         struct uhci_qh *pqh;
-        __le32 link_to_new_qh;
+        __hc32 link_to_new_qh;
 
         /* Find the predecessor QH for our new one and insert it in the list.
          * The list of QHs is expected to be short, so linear search won't
@@ -463,7 +466,7 @@ static void link_async(struct uhci_hcd *uhci, struct uhci_qh *qh)
         /* Link it into the schedule */
         qh->link = pqh->link;
         wmb();
-        link_to_new_qh = LINK_TO_QH(qh);
+        link_to_new_qh = LINK_TO_QH(uhci, qh);
         pqh->link = link_to_new_qh;
 
         /* If this is now the first FSBR QH, link the terminating skeleton
@@ -481,13 +484,13 @@ static void uhci_activate_qh(struct uhci_hcd *uhci, struct uhci_qh *qh)
 
         /* Set the element pointer if it isn't set already.
          * This isn't needed for Isochronous queues, but it doesn't hurt. */
-        if (qh_element(qh) == UHCI_PTR_TERM) {
+        if (qh_element(qh) == UHCI_PTR_TERM(uhci)) {
                 struct urb_priv *urbp = list_entry(qh->queue.next,
                                 struct urb_priv, node);
                 struct uhci_td *td = list_entry(urbp->td_list.next,
                                 struct uhci_td, list);
 
-                qh->element = LINK_TO_TD(td);
+                qh->element = LINK_TO_TD(uhci, td);
         }
 
         /* Treat the queue as if it has just advanced */
@@ -531,7 +534,7 @@ static void unlink_interrupt(struct uhci_hcd *uhci, struct uhci_qh *qh)
 static void unlink_async(struct uhci_hcd *uhci, struct uhci_qh *qh)
 {
         struct uhci_qh *pqh;
-        __le32 link_to_next_qh = qh->link;
+        __hc32 link_to_next_qh = qh->link;
 
         pqh = list_entry(qh->node.prev, struct uhci_qh, node);
         pqh->link = link_to_next_qh;
@@ -728,7 +731,7 @@ static inline struct urb_priv *uhci_alloc_urb_priv(struct uhci_hcd *uhci,
 
         urbp->urb = urb;
         urb->hcpriv = urbp;
-        
+
         INIT_LIST_HEAD(&urbp->node);
         INIT_LIST_HEAD(&urbp->td_list);
 
@@ -755,8 +758,8 @@ static void uhci_free_urb_priv(struct uhci_hcd *uhci,
 /*
  * Map status to standard result codes
  *
- * <status> is (td_status(td) & 0xF60000), a.k.a.
- * uhci_status_bits(td_status(td)).
+ * <status> is (td_status(uhci, td) & 0xF60000), a.k.a.
+ * uhci_status_bits(td_status(uhci, td)).
  * Note: <status> does not include the TD_CTRL_NAK bit.
  * <dir_out> is True for output TDs and False for input TDs.
  */
@@ -792,7 +795,7 @@ static int uhci_submit_control(struct uhci_hcd *uhci, struct urb *urb,
         int maxsze = le16_to_cpu(qh->hep->desc.wMaxPacketSize);
         int len = urb->transfer_buffer_length;
         dma_addr_t data = urb->transfer_dma;
-        __le32 *plink;
+        __hc32 *plink;
         struct urb_priv *urbp = urb->hcpriv;
         int skel;
 
@@ -809,7 +812,7 @@ static int uhci_submit_control(struct uhci_hcd *uhci, struct urb *urb,
          */
         td = qh->dummy_td;
         uhci_add_td_to_urbp(td, urbp);
-        uhci_fill_td(td, status, destination | uhci_explen(8),
+        uhci_fill_td(uhci, td, status, destination | uhci_explen(8),
                         urb->setup_dma);
         plink = &td->link;
         status |= TD_CTRL_ACTIVE;
@@ -842,14 +845,14 @@ static int uhci_submit_control(struct uhci_hcd *uhci, struct urb *urb,
                 td = uhci_alloc_td(uhci);
                 if (!td)
                         goto nomem;
-                *plink = LINK_TO_TD(td);
+                *plink = LINK_TO_TD(uhci, td);
 
                 /* Alternate Data0/1 (start with Data1) */
                 destination ^= TD_TOKEN_TOGGLE;
-        
+
                 uhci_add_td_to_urbp(td, urbp);
-                uhci_fill_td(td, status, destination | uhci_explen(pktsze),
-                                data);
+                uhci_fill_td(uhci, td, status,
+                        destination | uhci_explen(pktsze), data);
                 plink = &td->link;
 
                 data += pktsze;
@@ -857,19 +860,19 @@ static int uhci_submit_control(struct uhci_hcd *uhci, struct urb *urb,
         }
 
         /*
-         * Build the final TD for control status 
+         * Build the final TD for control status
          */
         td = uhci_alloc_td(uhci);
         if (!td)
                 goto nomem;
-        *plink = LINK_TO_TD(td);
+        *plink = LINK_TO_TD(uhci, td);
 
         /* Change direction for the status transaction */
         destination ^= (USB_PID_IN ^ USB_PID_OUT);
         destination |= TD_TOKEN_TOGGLE;         /* End in Data1 */
 
         uhci_add_td_to_urbp(td, urbp);
-        uhci_fill_td(td, status | TD_CTRL_IOC,
+        uhci_fill_td(uhci, td, status | TD_CTRL_IOC,
                         destination | uhci_explen(0), 0);
         plink = &td->link;
 
@@ -879,11 +882,11 @@ static int uhci_submit_control(struct uhci_hcd *uhci, struct urb *urb,
         td = uhci_alloc_td(uhci);
         if (!td)
                 goto nomem;
-        *plink = LINK_TO_TD(td);
+        *plink = LINK_TO_TD(uhci, td);
 
-        uhci_fill_td(td, 0, USB_PID_OUT | uhci_explen(0), 0);
+        uhci_fill_td(uhci, td, 0, USB_PID_OUT | uhci_explen(0), 0);
         wmb();
-        qh->dummy_td->status |= cpu_to_le32(TD_CTRL_ACTIVE);
+        qh->dummy_td->status |= cpu_to_hc32(uhci, TD_CTRL_ACTIVE);
         qh->dummy_td = td;
 
         /* Low-speed transfers get a different queue, and won't hog the bus.
@@ -917,10 +920,13 @@ static int uhci_submit_common(struct uhci_hcd *uhci, struct urb *urb,
         unsigned long destination, status;
         int maxsze = le16_to_cpu(qh->hep->desc.wMaxPacketSize);
         int len = urb->transfer_buffer_length;
-        dma_addr_t data = urb->transfer_dma;
-        __le32 *plink;
+        int this_sg_len;
+        dma_addr_t data;
+        __hc32 *plink;
         struct urb_priv *urbp = urb->hcpriv;
         unsigned int toggle;
+        struct scatterlist  *sg;
+        int i;
 
         if (len < 0)
                 return -EINVAL;
@@ -937,12 +943,26 @@ static int uhci_submit_common(struct uhci_hcd *uhci, struct urb *urb,
         if (usb_pipein(urb->pipe))
                 status |= TD_CTRL_SPD;
 
+        i = urb->num_sgs;
+        if (len > 0 && i > 0) {
+                sg = urb->sg;
+                data = sg_dma_address(sg);
+
+                /* urb->transfer_buffer_length may be smaller than the
+                 * size of the scatterlist (or vice versa)
+                 */
+                this_sg_len = min_t(int, sg_dma_len(sg), len);
+        } else {
+                sg = NULL;
+                data = urb->transfer_dma;
+                this_sg_len = len;
+        }
         /*
          * Build the DATA TDs
          */
         plink = NULL;
         td = qh->dummy_td;
-        do {    /* Allow zero length packets */
+        for (;;) {      /* Allow zero length packets */
                 int pktsze = maxsze;
 
                 if (len <= pktsze) {            /* The last packet */
@@ -955,20 +975,28 @@ static int uhci_submit_common(struct uhci_hcd *uhci, struct urb *urb,
                         td = uhci_alloc_td(uhci);
                         if (!td)
                                 goto nomem;
-                        *plink = LINK_TO_TD(td);
+                        *plink = LINK_TO_TD(uhci, td);
                 }
                 uhci_add_td_to_urbp(td, urbp);
-                uhci_fill_td(td, status,
+                uhci_fill_td(uhci, td, status,
                                 destination | uhci_explen(pktsze) |
                                         (toggle << TD_TOKEN_TOGGLE_SHIFT),
                                 data);
                 plink = &td->link;
                 status |= TD_CTRL_ACTIVE;
 
+                toggle ^= 1;
                 data += pktsze;
+                this_sg_len -= pktsze;
                 len -= maxsze;
-                toggle ^= 1;
-        } while (len > 0);
+                if (this_sg_len <= 0) {
+                        if (--i <= 0 || len <= 0)
+                                break;
+                        sg = sg_next(sg);
+                        data = sg_dma_address(sg);
+                        this_sg_len = min_t(int, sg_dma_len(sg), len);
+                }
+        }
 
         /*
          * URB_ZERO_PACKET means adding a 0-length packet, if direction
@@ -983,10 +1011,10 @@ static int uhci_submit_common(struct uhci_hcd *uhci, struct urb *urb,
                 td = uhci_alloc_td(uhci);
                 if (!td)
                         goto nomem;
-                *plink = LINK_TO_TD(td);
+                *plink = LINK_TO_TD(uhci, td);
 
                 uhci_add_td_to_urbp(td, urbp);
-                uhci_fill_td(td, status,
+                uhci_fill_td(uhci, td, status,
                                 destination | uhci_explen(0) |
                                         (toggle << TD_TOKEN_TOGGLE_SHIFT),
                                 data);
@@ -1001,7 +1029,7 @@ static int uhci_submit_common(struct uhci_hcd *uhci, struct urb *urb,
          * fast side but not enough to justify delaying an interrupt
          * more than 2 or 3 URBs, so we will ignore the URB_NO_INTERRUPT
          * flag setting. */
-        td->status |= cpu_to_le32(TD_CTRL_IOC);
+        td->status |= cpu_to_hc32(uhci, TD_CTRL_IOC);
 
         /*
          * Build the new dummy TD and activate the old one
@@ -1009,11 +1037,11 @@ static int uhci_submit_common(struct uhci_hcd *uhci, struct urb *urb,
         td = uhci_alloc_td(uhci);
         if (!td)
                 goto nomem;
-        *plink = LINK_TO_TD(td);
+        *plink = LINK_TO_TD(uhci, td);
 
-        uhci_fill_td(td, 0, USB_PID_OUT | uhci_explen(0), 0);
+        uhci_fill_td(uhci, td, 0, USB_PID_OUT | uhci_explen(0), 0);
         wmb();
-        qh->dummy_td->status |= cpu_to_le32(TD_CTRL_ACTIVE);
+        qh->dummy_td->status |= cpu_to_hc32(uhci, TD_CTRL_ACTIVE);
         qh->dummy_td = td;
 
         usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe),
@@ -1106,7 +1134,7 @@ static int uhci_fixup_short_transfer(struct uhci_hcd *uhci,
                  * the queue at the status stage transaction, which is
                  * the last TD. */
                 WARN_ON(list_empty(&urbp->td_list));
-                qh->element = LINK_TO_TD(td);
+                qh->element = LINK_TO_TD(uhci, td);
                 tmp = td->list.prev;
                 ret = -EINPROGRESS;
 
@@ -1115,8 +1143,9 @@ static int uhci_fixup_short_transfer(struct uhci_hcd *uhci,
                 /* When a bulk/interrupt transfer is short, we have to
                  * fix up the toggles of the following URBs on the queue
                  * before restarting the queue at the next URB. */
-                qh->initial_toggle = uhci_toggle(td_token(qh->post_td)) ^ 1;
-                uhci_fixup_toggles(qh, 1);
+                qh->initial_toggle =
+                        uhci_toggle(td_token(uhci, qh->post_td)) ^ 1;
+                uhci_fixup_toggles(uhci, qh, 1);
 
                 if (list_empty(&urbp->td_list))
                         td = qh->post_td;
@@ -1151,7 +1180,7 @@ static int uhci_result_common(struct uhci_hcd *uhci, struct urb *urb)
                 unsigned int ctrlstat;
                 int len;
 
-                ctrlstat = td_status(td);
+                ctrlstat = td_status(uhci, td);
                 status = uhci_status_bits(ctrlstat);
                 if (status & TD_CTRL_ACTIVE)
                         return -EINPROGRESS;
@@ -1161,7 +1190,7 @@ static int uhci_result_common(struct uhci_hcd *uhci, struct urb *urb)
 
                 if (status) {
                         ret = uhci_map_status(status,
-                                        uhci_packetout(td_token(td)));
+                                        uhci_packetout(td_token(uhci, td)));
                         if ((debug == 1 && ret != -EPIPE) || debug > 1) {
                                 /* Some debugging code */
                                 dev_dbg(&urb->dev->dev,
@@ -1177,7 +1206,7 @@ static int uhci_result_common(struct uhci_hcd *uhci, struct urb *urb)
                         }
 
                 /* Did we receive a short packet? */
-                } else if (len < uhci_expected_length(td_token(td))) {
+                } else if (len < uhci_expected_length(td_token(uhci, td))) {
 
                         /* For control transfers, go to the status TD if
                          * this isn't already the last data TD */
@@ -1209,10 +1238,10 @@ err:
         if (ret < 0) {
                 /* Note that the queue has stopped and save
                  * the next toggle value */
-                qh->element = UHCI_PTR_TERM;
+                qh->element = UHCI_PTR_TERM(uhci);
                 qh->is_stopped = 1;
                 qh->needs_fixup = (qh->type != USB_ENDPOINT_XFER_CONTROL);
-                qh->initial_toggle = uhci_toggle(td_token(td)) ^
+                qh->initial_toggle = uhci_toggle(td_token(uhci, td)) ^
                                 (ret == -EREMOTEIO);
 
         } else          /* Short packet received */
@@ -1308,14 +1337,14 @@ static int uhci_submit_isochronous(struct uhci_hcd *uhci, struct urb *urb,
                         return -ENOMEM;
 
                 uhci_add_td_to_urbp(td, urbp);
-                uhci_fill_td(td, status, destination |
+                uhci_fill_td(uhci, td, status, destination |
                                 uhci_explen(urb->iso_frame_desc[i].length),
                                 urb->transfer_dma +
                                         urb->iso_frame_desc[i].offset);
         }
 
         /* Set the interrupt-on-completion flag on the last packet. */
-        td->status |= cpu_to_le32(TD_CTRL_IOC);
+        td->status |= cpu_to_hc32(uhci, TD_CTRL_IOC);
 
         /* Add the TDs to the frame list */
         frame = urb->start_frame;
@@ -1351,7 +1380,7 @@ static int uhci_result_isochronous(struct uhci_hcd *uhci, struct urb *urb)
 
                 uhci_remove_tds_from_frame(uhci, qh->iso_frame);
 
-                ctrlstat = td_status(td);
+                ctrlstat = td_status(uhci, td);
                 if (ctrlstat & TD_CTRL_ACTIVE) {
                         status = -EXDEV;        /* TD was added too late? */
                 } else {
@@ -1602,7 +1631,7 @@ restart:
          * queue, the QH can now be re-activated. */
         if (!list_empty(&qh->queue)) {
                 if (qh->needs_fixup)
-                        uhci_fixup_toggles(qh, 0);
+                        uhci_fixup_toggles(uhci, qh, 0);
 
                 /* If the first URB on the queue wants FSBR but its time
                  * limit has expired, set the next TD to interrupt on
@@ -1612,7 +1641,7 @@ restart:
                         struct uhci_td *td = list_entry(urbp->td_list.next,
                                         struct uhci_td, list);
 
-                        td->status |= __cpu_to_le32(TD_CTRL_IOC);
+                        td->status |= cpu_to_hc32(uhci, TD_CTRL_IOC);
                 }
 
                 uhci_activate_qh(uhci, qh);
@@ -1659,7 +1688,7 @@ static int uhci_advance_check(struct uhci_hcd *uhci, struct uhci_qh *qh)
         } else {
                 urbp = list_entry(qh->queue.next, struct urb_priv, node);
                 td = list_entry(urbp->td_list.next, struct uhci_td, list);
-                status = td_status(td);
+                status = td_status(uhci, td);
                 if (!(status & TD_CTRL_ACTIVE)) {
 
                         /* We're okay, the queue has advanced */
@@ -1677,7 +1706,8 @@ static int uhci_advance_check(struct uhci_hcd *uhci, struct uhci_qh *qh)
         if (time_after(jiffies, qh->advance_jiffies + QH_WAIT_TIMEOUT)) {
 
                 /* Detect the Intel bug and work around it */
-                if (qh->post_td && qh_element(qh) == LINK_TO_TD(qh->post_td)) {
+                if (qh->post_td && qh_element(qh) ==
+                        LINK_TO_TD(uhci, qh->post_td)) {
                         qh->element = qh->post_td->link;
                         qh->advance_jiffies = jiffies;
                         ret = 1;
diff --git a/drivers/usb/host/whci/Kbuild b/drivers/usb/host/whci/Kbuild
index 11e5040b8337..26df0138079e 100644
--- a/drivers/usb/host/whci/Kbuild
+++ b/drivers/usb/host/whci/Kbuild
@@ -3,7 +3,7 @@ obj-$(CONFIG_USB_WHCI_HCD) += whci-hcd.o
 whci-hcd-y := \
         asl.o   \
         debug.o \
-        hcd.o   \
+        hcd.o   \
         hw.o    \
         init.o  \
         int.o   \
diff --git a/drivers/usb/host/whci/hcd.c b/drivers/usb/host/whci/hcd.c
index 72b6892fda67..9546f6cd01f0 100644
--- a/drivers/usb/host/whci/hcd.c
+++ b/drivers/usb/host/whci/hcd.c
@@ -356,7 +356,7 @@ static void __exit whci_hc_driver_exit(void)
 module_exit(whci_hc_driver_exit);
 
 /* PCI device ID's that we handle (so it gets loaded) */
-static struct pci_device_id whci_hcd_id_table[] = {
+static struct pci_device_id __used whci_hcd_id_table[] = {
         { PCI_DEVICE_CLASS(PCI_CLASS_WIRELESS_WHCI, ~0) },
         { /* empty last entry */ }
 };
diff --git a/drivers/usb/host/whci/qset.c b/drivers/usb/host/whci/qset.c
index dc0ab8382f5d..d6e175428618 100644
--- a/drivers/usb/host/whci/qset.c
+++ b/drivers/usb/host/whci/qset.c
@@ -739,7 +739,7 @@ static int get_urb_status_from_qtd(struct urb *urb, u32 status)
  * process_inactive_qtd - process an inactive (but not halted) qTD.
  *
  * Update the urb with the transfer bytes from the qTD, if the urb is
- * completely transfered or (in the case of an IN only) the LPF is
+ * completely transferred or (in the case of an IN only) the LPF is
  * set, then the transfer is complete and the urb should be returned
  * to the system.
  */
diff --git a/drivers/usb/host/xhci-dbg.c b/drivers/usb/host/xhci-dbg.c
index fcbf4abbf381..1f50b4468e87 100644
--- a/drivers/usb/host/xhci-dbg.c
+++ b/drivers/usb/host/xhci-dbg.c
@@ -147,7 +147,7 @@ static void xhci_print_op_regs(struct xhci_hcd *xhci)
 
 static void xhci_print_ports(struct xhci_hcd *xhci)
 {
-        u32 __iomem *addr;
+        __le32 __iomem *addr;
         int i, j;
         int ports;
         char *names[NUM_PORT_REGS] = {
@@ -169,9 +169,10 @@ static void xhci_print_ports(struct xhci_hcd *xhci)
         }
 }
 
-void xhci_print_ir_set(struct xhci_hcd *xhci, struct xhci_intr_reg *ir_set, int set_num)
+void xhci_print_ir_set(struct xhci_hcd *xhci, int set_num)
 {
-        void *addr;
+        struct xhci_intr_reg __iomem *ir_set = &xhci->run_regs->ir_set[set_num];
+        void __iomem *addr;
         u32 temp;
         u64 temp_64;
 
@@ -252,27 +253,27 @@ void xhci_print_trb_offsets(struct xhci_hcd *xhci, union xhci_trb *trb)
 void xhci_debug_trb(struct xhci_hcd *xhci, union xhci_trb *trb)
 {
         u64     address;
-        u32     type = xhci_readl(xhci, &trb->link.control) & TRB_TYPE_BITMASK;
+        u32     type = le32_to_cpu(trb->link.control) & TRB_TYPE_BITMASK;
 
         switch (type) {
         case TRB_TYPE(TRB_LINK):
                 xhci_dbg(xhci, "Link TRB:\n");
                 xhci_print_trb_offsets(xhci, trb);
 
-                address = trb->link.segment_ptr;
+                address = le64_to_cpu(trb->link.segment_ptr);
                 xhci_dbg(xhci, "Next ring segment DMA address = 0x%llx\n", address);
 
                 xhci_dbg(xhci, "Interrupter target = 0x%x\n",
-                                GET_INTR_TARGET(trb->link.intr_target));
+                         GET_INTR_TARGET(le32_to_cpu(trb->link.intr_target)));
                 xhci_dbg(xhci, "Cycle bit = %u\n",
-                                (unsigned int) (trb->link.control & TRB_CYCLE));
+                         (unsigned int) (le32_to_cpu(trb->link.control) & TRB_CYCLE));
                 xhci_dbg(xhci, "Toggle cycle bit = %u\n",
-                                (unsigned int) (trb->link.control & LINK_TOGGLE));
+                         (unsigned int) (le32_to_cpu(trb->link.control) & LINK_TOGGLE));
                 xhci_dbg(xhci, "No Snoop bit = %u\n",
-                                (unsigned int) (trb->link.control & TRB_NO_SNOOP));
+                         (unsigned int) (le32_to_cpu(trb->link.control) & TRB_NO_SNOOP));
                 break;
         case TRB_TYPE(TRB_TRANSFER):
-                address = trb->trans_event.buffer;
+                address = le64_to_cpu(trb->trans_event.buffer);
                 /*
                  * FIXME: look at flags to figure out if it's an address or if
                  * the data is directly in the buffer field.
@@ -280,11 +281,12 @@ void xhci_debug_trb(struct xhci_hcd *xhci, union xhci_trb *trb)
                 xhci_dbg(xhci, "DMA address or buffer contents= %llu\n", address);
                 break;
         case TRB_TYPE(TRB_COMPLETION):
-                address = trb->event_cmd.cmd_trb;
+                address = le64_to_cpu(trb->event_cmd.cmd_trb);
                 xhci_dbg(xhci, "Command TRB pointer = %llu\n", address);
                 xhci_dbg(xhci, "Completion status = %u\n",
-                                (unsigned int) GET_COMP_CODE(trb->event_cmd.status));
-                xhci_dbg(xhci, "Flags = 0x%x\n", (unsigned int) trb->event_cmd.flags);
+                         (unsigned int) GET_COMP_CODE(le32_to_cpu(trb->event_cmd.status)));
+                xhci_dbg(xhci, "Flags = 0x%x\n",
+                         (unsigned int) le32_to_cpu(trb->event_cmd.flags));
                 break;
         default:
                 xhci_dbg(xhci, "Unknown TRB with TRB type ID %u\n",
@@ -310,16 +312,16 @@ void xhci_debug_trb(struct xhci_hcd *xhci, union xhci_trb *trb)
 void xhci_debug_segment(struct xhci_hcd *xhci, struct xhci_segment *seg)
 {
         int i;
-        u32 addr = (u32) seg->dma;
+        u64 addr = seg->dma;
         union xhci_trb *trb = seg->trbs;
 
         for (i = 0; i < TRBS_PER_SEGMENT; ++i) {
                 trb = &seg->trbs[i];
-                xhci_dbg(xhci, "@%08x %08x %08x %08x %08x\n", addr,
-                                lower_32_bits(trb->link.segment_ptr),
-                                upper_32_bits(trb->link.segment_ptr),
-                                (unsigned int) trb->link.intr_target,
-                                (unsigned int) trb->link.control);
+                xhci_dbg(xhci, "@%016llx %08x %08x %08x %08x\n", addr,
+                         (u32)lower_32_bits(le64_to_cpu(trb->link.segment_ptr)),
+                         (u32)upper_32_bits(le64_to_cpu(trb->link.segment_ptr)),
+                         (unsigned int) le32_to_cpu(trb->link.intr_target),
+                         (unsigned int) le32_to_cpu(trb->link.control));
                 addr += sizeof(*trb);
         }
 }
@@ -390,18 +392,18 @@ void xhci_dbg_ep_rings(struct xhci_hcd *xhci,
 
 void xhci_dbg_erst(struct xhci_hcd *xhci, struct xhci_erst *erst)
 {
-        u32 addr = (u32) erst->erst_dma_addr;
+        u64 addr = erst->erst_dma_addr;
         int i;
         struct xhci_erst_entry *entry;
 
         for (i = 0; i < erst->num_entries; ++i) {
                 entry = &erst->entries[i];
-                xhci_dbg(xhci, "@%08x %08x %08x %08x %08x\n",
-                                (unsigned int) addr,
-                                lower_32_bits(entry->seg_addr),
-                                upper_32_bits(entry->seg_addr),
-                                (unsigned int) entry->seg_size,
-                                (unsigned int) entry->rsvd);
+                xhci_dbg(xhci, "@%016llx %08x %08x %08x %08x\n",
+                         addr,
+                         lower_32_bits(le64_to_cpu(entry->seg_addr)),
+                         upper_32_bits(le64_to_cpu(entry->seg_addr)),
+                         (unsigned int) le32_to_cpu(entry->seg_size),
+                         (unsigned int) le32_to_cpu(entry->rsvd));
                 addr += sizeof(*entry);
         }
 }
@@ -435,21 +437,21 @@ char *xhci_get_slot_state(struct xhci_hcd *xhci,
 {
         struct xhci_slot_ctx *slot_ctx = xhci_get_slot_ctx(xhci, ctx);
 
-        switch (GET_SLOT_STATE(slot_ctx->dev_state)) {
-        case 0:
+        switch (GET_SLOT_STATE(le32_to_cpu(slot_ctx->dev_state))) {
+        case SLOT_STATE_ENABLED:
                 return "enabled/disabled";
-        case 1:
+        case SLOT_STATE_DEFAULT:
                 return "default";
-        case 2:
+        case SLOT_STATE_ADDRESSED:
                 return "addressed";
-        case 3:
+        case SLOT_STATE_CONFIGURED:
                 return "configured";
         default:
                 return "reserved";
         }
 }
 
-void xhci_dbg_slot_ctx(struct xhci_hcd *xhci, struct xhci_container_ctx *ctx)
+static void xhci_dbg_slot_ctx(struct xhci_hcd *xhci, struct xhci_container_ctx *ctx)
 {
         /* Fields are 32 bits wide, DMA addresses are in bytes */
         int field_size = 32 / 8;
@@ -488,7 +490,7 @@ void xhci_dbg_slot_ctx(struct xhci_hcd *xhci, struct xhci_container_ctx *ctx)
                 dbg_rsvd64(xhci, (u64 *)slot_ctx, dma);
 }
 
-void xhci_dbg_ep_ctx(struct xhci_hcd *xhci,
+static void xhci_dbg_ep_ctx(struct xhci_hcd *xhci,
                      struct xhci_container_ctx *ctx,
                      unsigned int last_ep)
 {
diff --git a/drivers/usb/host/xhci-ext-caps.h b/drivers/usb/host/xhci-ext-caps.h
index 78c4edac1db1..ce5c9e51748e 100644
--- a/drivers/usb/host/xhci-ext-caps.h
+++ b/drivers/usb/host/xhci-ext-caps.h
@@ -19,8 +19,8 @@
  * along with this program; if not, write to the Free Software Foundation,
  * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
-/* Up to 16 microframes to halt an HC - one microframe is 125 microsectonds */
-#define XHCI_MAX_HALT_USEC      (16*125)
+/* Up to 16 ms to halt an HC */
+#define XHCI_MAX_HALT_USEC      (16*1000)
 /* HC not running - set to 1 when run/stop bit is cleared. */
 #define XHCI_STS_HALT           (1<<0)
 
diff --git a/drivers/usb/host/xhci-hub.c b/drivers/usb/host/xhci-hub.c
index a1a7a9795536..0be788cc2fdb 100644
--- a/drivers/usb/host/xhci-hub.c
+++ b/drivers/usb/host/xhci-hub.c
@@ -24,27 +24,19 @@
 
 #include "xhci.h"
 
-static void xhci_hub_descriptor(struct xhci_hcd *xhci,
-                struct usb_hub_descriptor *desc)
+#define PORT_WAKE_BITS  (PORT_WKOC_E | PORT_WKDISC_E | PORT_WKCONN_E)
+#define PORT_RWC_BITS   (PORT_CSC | PORT_PEC | PORT_WRC | PORT_OCC | \
+                         PORT_RC | PORT_PLC | PORT_PE)
+
+static void xhci_common_hub_descriptor(struct xhci_hcd *xhci,
+                struct usb_hub_descriptor *desc, int ports)
 {
-        int ports;
         u16 temp;
 
-        ports = HCS_MAX_PORTS(xhci->hcs_params1);
-
-        /* USB 3.0 hubs have a different descriptor, but we fake this for now */
-        desc->bDescriptorType = 0x29;
         desc->bPwrOn2PwrGood = 10;      /* xhci section 5.4.9 says 20ms max */
         desc->bHubContrCurrent = 0;
 
         desc->bNbrPorts = ports;
-        temp = 1 + (ports / 8);
-        desc->bDescLength = 7 + 2 * temp;
-
-        /* Why does core/hcd.h define bitmap?  It's just confusing. */
-        memset(&desc->DeviceRemovable[0], 0, temp);
-        memset(&desc->DeviceRemovable[temp], 0xff, temp);
-
         /* Ugh, these should be #defines, FIXME */
         /* Using table 11-13 in USB 2.0 spec. */
         temp = 0;
@@ -58,7 +50,103 @@ static void xhci_hub_descriptor(struct xhci_hcd *xhci,
         temp |= 0x0008;
         /* Bits 6:5 - no TTs in root ports */
         /* Bit  7 - no port indicators */
-        desc->wHubCharacteristics = (__force __u16) cpu_to_le16(temp);
+        desc->wHubCharacteristics = cpu_to_le16(temp);
+}
+
+/* Fill in the USB 2.0 roothub descriptor */
+static void xhci_usb2_hub_descriptor(struct usb_hcd *hcd, struct xhci_hcd *xhci,
+                struct usb_hub_descriptor *desc)
+{
+        int ports;
+        u16 temp;
+        __u8 port_removable[(USB_MAXCHILDREN + 1 + 7) / 8];
+        u32 portsc;
+        unsigned int i;
+
+        ports = xhci->num_usb2_ports;
+
+        xhci_common_hub_descriptor(xhci, desc, ports);
+        desc->bDescriptorType = 0x29;
+        temp = 1 + (ports / 8);
+        desc->bDescLength = 7 + 2 * temp;
+
+        /* The Device Removable bits are reported on a byte granularity.
+         * If the port doesn't exist within that byte, the bit is set to 0.
+         */
+        memset(port_removable, 0, sizeof(port_removable));
+        for (i = 0; i < ports; i++) {
+                portsc = xhci_readl(xhci, xhci->usb3_ports[i]);
+                /* If a device is removable, PORTSC reports a 0, same as in the
+                 * hub descriptor DeviceRemovable bits.
+                 */
+                if (portsc & PORT_DEV_REMOVE)
+                        /* This math is hairy because bit 0 of DeviceRemovable
+                         * is reserved, and bit 1 is for port 1, etc.
+                         */
+                        port_removable[(i + 1) / 8] |= 1 << ((i + 1) % 8);
+        }
+
+        /* ch11.h defines a hub descriptor that has room for USB_MAXCHILDREN
+         * ports on it.  The USB 2.0 specification says that there are two
+         * variable length fields at the end of the hub descriptor:
+         * DeviceRemovable and PortPwrCtrlMask.  But since we can have less than
+         * USB_MAXCHILDREN ports, we may need to use the DeviceRemovable array
+         * to set PortPwrCtrlMask bits.  PortPwrCtrlMask must always be set to
+         * 0xFF, so we initialize the both arrays (DeviceRemovable and
+         * PortPwrCtrlMask) to 0xFF.  Then we set the DeviceRemovable for each
+         * set of ports that actually exist.
+         */
+        memset(desc->u.hs.DeviceRemovable, 0xff,
+                        sizeof(desc->u.hs.DeviceRemovable));
+        memset(desc->u.hs.PortPwrCtrlMask, 0xff,
+                        sizeof(desc->u.hs.PortPwrCtrlMask));
+
+        for (i = 0; i < (ports + 1 + 7) / 8; i++)
+                memset(&desc->u.hs.DeviceRemovable[i], port_removable[i],
+                                sizeof(__u8));
+}
+
+/* Fill in the USB 3.0 roothub descriptor */
+static void xhci_usb3_hub_descriptor(struct usb_hcd *hcd, struct xhci_hcd *xhci,
+                struct usb_hub_descriptor *desc)
+{
+        int ports;
+        u16 port_removable;
+        u32 portsc;
+        unsigned int i;
+
+        ports = xhci->num_usb3_ports;
+        xhci_common_hub_descriptor(xhci, desc, ports);
+        desc->bDescriptorType = 0x2a;
+        desc->bDescLength = 12;
+
+        /* header decode latency should be zero for roothubs,
+         * see section 4.23.5.2.
+         */
+        desc->u.ss.bHubHdrDecLat = 0;
+        desc->u.ss.wHubDelay = 0;
+
+        port_removable = 0;
+        /* bit 0 is reserved, bit 1 is for port 1, etc. */
+        for (i = 0; i < ports; i++) {
+                portsc = xhci_readl(xhci, xhci->usb3_ports[i]);
+                if (portsc & PORT_DEV_REMOVE)
+                        port_removable |= 1 << (i + 1);
+        }
+        memset(&desc->u.ss.DeviceRemovable,
+                        (__force __u16) cpu_to_le16(port_removable),
+                        sizeof(__u16));
+}
+
+static void xhci_hub_descriptor(struct usb_hcd *hcd, struct xhci_hcd *xhci,
+                struct usb_hub_descriptor *desc)
+{
+
+        if (hcd->speed == HCD_USB3)
+                xhci_usb3_hub_descriptor(hcd, xhci, desc);
+        else
+                xhci_usb2_hub_descriptor(hcd, xhci, desc);
+
 }
 
 static unsigned int xhci_port_speed(unsigned int port_status)
@@ -67,8 +155,6 @@ static unsigned int xhci_port_speed(unsigned int port_status)
                 return USB_PORT_STAT_LOW_SPEED;
         if (DEV_HIGHSPEED(port_status))
                 return USB_PORT_STAT_HIGH_SPEED;
-        if (DEV_SUPERSPEED(port_status))
-                return USB_PORT_STAT_SUPER_SPEED;
         /*
          * FIXME: Yes, we should check for full speed, but the core uses that as
          * a default in portspeed() in usb/core/hub.c (which is the only place
@@ -123,15 +209,120 @@ static unsigned int xhci_port_speed(unsigned int port_status)
  * writing a 0 clears the bit and writing a 1 sets the bit (RWS).
  * For all other types (RW1S, RW1CS, RW, and RZ), writing a '0' has no effect.
  */
-static u32 xhci_port_state_to_neutral(u32 state)
+u32 xhci_port_state_to_neutral(u32 state)
 {
         /* Save read-only status and port state */
         return (state & XHCI_PORT_RO) | (state & XHCI_PORT_RWS);
 }
 
-static void xhci_disable_port(struct xhci_hcd *xhci, u16 wIndex,
-                u32 __iomem *addr, u32 port_status)
+/*
+ * find slot id based on port number.
+ * @port: The one-based port number from one of the two split roothubs.
+ */
+int xhci_find_slot_id_by_port(struct usb_hcd *hcd, struct xhci_hcd *xhci,
+                u16 port)
+{
+        int slot_id;
+        int i;
+        enum usb_device_speed speed;
+
+        slot_id = 0;
+        for (i = 0; i < MAX_HC_SLOTS; i++) {
+                if (!xhci->devs[i])
+                        continue;
+                speed = xhci->devs[i]->udev->speed;
+                if (((speed == USB_SPEED_SUPER) == (hcd->speed == HCD_USB3))
+                                && xhci->devs[i]->port == port) {
+                        slot_id = i;
+                        break;
+                }
+        }
+
+        return slot_id;
+}
+
+/*
+ * Stop device
+ * It issues stop endpoint command for EP 0 to 30. And wait the last command
+ * to complete.
+ * suspend will set to 1, if suspend bit need to set in command.
+ */
+static int xhci_stop_device(struct xhci_hcd *xhci, int slot_id, int suspend)
+{
+        struct xhci_virt_device *virt_dev;
+        struct xhci_command *cmd;
+        unsigned long flags;
+        int timeleft;
+        int ret;
+        int i;
+
+        ret = 0;
+        virt_dev = xhci->devs[slot_id];
+        cmd = xhci_alloc_command(xhci, false, true, GFP_NOIO);
+        if (!cmd) {
+                xhci_dbg(xhci, "Couldn't allocate command structure.\n");
+                return -ENOMEM;
+        }
+
+        spin_lock_irqsave(&xhci->lock, flags);
+        for (i = LAST_EP_INDEX; i > 0; i--) {
+                if (virt_dev->eps[i].ring && virt_dev->eps[i].ring->dequeue)
+                        xhci_queue_stop_endpoint(xhci, slot_id, i, suspend);
+        }
+        cmd->command_trb = xhci->cmd_ring->enqueue;
+        list_add_tail(&cmd->cmd_list, &virt_dev->cmd_list);
+        xhci_queue_stop_endpoint(xhci, slot_id, 0, suspend);
+        xhci_ring_cmd_db(xhci);
+        spin_unlock_irqrestore(&xhci->lock, flags);
+
+        /* Wait for last stop endpoint command to finish */
+        timeleft = wait_for_completion_interruptible_timeout(
+                        cmd->completion,
+                        USB_CTRL_SET_TIMEOUT);
+        if (timeleft <= 0) {
+                xhci_warn(xhci, "%s while waiting for stop endpoint command\n",
+                                timeleft == 0 ? "Timeout" : "Signal");
+                spin_lock_irqsave(&xhci->lock, flags);
+                /* The timeout might have raced with the event ring handler, so
+                 * only delete from the list if the item isn't poisoned.
+                 */
+                if (cmd->cmd_list.next != LIST_POISON1)
+                        list_del(&cmd->cmd_list);
+                spin_unlock_irqrestore(&xhci->lock, flags);
+                ret = -ETIME;
+                goto command_cleanup;
+        }
+
+command_cleanup:
+        xhci_free_command(xhci, cmd);
+        return ret;
+}
+
+/*
+ * Ring device, it rings the all doorbells unconditionally.
+ */
+void xhci_ring_device(struct xhci_hcd *xhci, int slot_id)
+{
+        int i;
+
+        for (i = 0; i < LAST_EP_INDEX + 1; i++)
+                if (xhci->devs[slot_id]->eps[i].ring &&
+                    xhci->devs[slot_id]->eps[i].ring->dequeue)
+                        xhci_ring_ep_doorbell(xhci, slot_id, i, 0);
+
+        return;
+}
+
+static void xhci_disable_port(struct usb_hcd *hcd, struct xhci_hcd *xhci,
+                u16 wIndex, __le32 __iomem *addr, u32 port_status)
 {
+        /* Don't allow the USB core to disable SuperSpeed ports. */
+        if (hcd->speed == HCD_USB3) {
+                xhci_dbg(xhci, "Ignoring request to disable "
+                                "SuperSpeed port.\n");
+                return;
+        }
+
         /* Write 1 to disable the port */
         xhci_writel(xhci, port_status | PORT_PE, addr);
         port_status = xhci_readl(xhci, addr);
@@ -140,7 +331,7 @@ static void xhci_disable_port(struct xhci_hcd *xhci, u16 wIndex,
 }
 
 static void xhci_clear_port_change_bit(struct xhci_hcd *xhci, u16 wValue,
-                u16 wIndex, u32 __iomem *addr, u32 port_status)
+                u16 wIndex, __le32 __iomem *addr, u32 port_status)
 {
         char *port_change_bit;
         u32 status;
@@ -150,6 +341,10 @@ static void xhci_clear_port_change_bit(struct xhci_hcd *xhci, u16 wValue,
                 status = PORT_RC;
                 port_change_bit = "reset";
                 break;
+        case USB_PORT_FEAT_C_BH_PORT_RESET:
+                status = PORT_WRC;
+                port_change_bit = "warm(BH) reset";
+                break;
         case USB_PORT_FEAT_C_CONNECTION:
                 status = PORT_CSC;
                 port_change_bit = "connect";
@@ -162,6 +357,14 @@ static void xhci_clear_port_change_bit(struct xhci_hcd *xhci, u16 wValue,
                 status = PORT_PEC;
                 port_change_bit = "enable/disable";
                 break;
+        case USB_PORT_FEAT_C_SUSPEND:
+                status = PORT_PLC;
+                port_change_bit = "suspend/resume";
+                break;
+        case USB_PORT_FEAT_C_PORT_LINK_STATE:
+                status = PORT_PLC;
+                port_change_bit = "link state";
+                break;
         default:
                 /* Should never happen */
                 return;
@@ -173,17 +376,37 @@ static void xhci_clear_port_change_bit(struct xhci_hcd *xhci, u16 wValue,
                         port_change_bit, wIndex, port_status);
 }
 
+static int xhci_get_ports(struct usb_hcd *hcd, __le32 __iomem ***port_array)
+{
+        int max_ports;
+        struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+
+        if (hcd->speed == HCD_USB3) {
+                max_ports = xhci->num_usb3_ports;
+                *port_array = xhci->usb3_ports;
+        } else {
+                max_ports = xhci->num_usb2_ports;
+                *port_array = xhci->usb2_ports;
+        }
+
+        return max_ports;
+}
+
 int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                 u16 wIndex, char *buf, u16 wLength)
 {
         struct xhci_hcd *xhci = hcd_to_xhci(hcd);
-        int ports;
+        int max_ports;
         unsigned long flags;
-        u32 temp, status;
+        u32 temp, temp1, status;
         int retval = 0;
-        u32 __iomem *addr;
+        __le32 __iomem **port_array;
+        int slot_id;
+        struct xhci_bus_state *bus_state;
+        u16 link_state = 0;
 
-        ports = HCS_MAX_PORTS(xhci->hcs_params1);
+        max_ports = xhci_get_ports(hcd, &port_array);
+        bus_state = &xhci->bus_state[hcd_index(hcd)];
 
         spin_lock_irqsave(&xhci->lock, flags);
         switch (typeReq) {
@@ -192,15 +415,30 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                 memset(buf, 0, 4);
                 break;
         case GetHubDescriptor:
-                xhci_hub_descriptor(xhci, (struct usb_hub_descriptor *) buf);
+                /* Check to make sure userspace is asking for the USB 3.0 hub
+                 * descriptor for the USB 3.0 roothub.  If not, we stall the
+                 * endpoint, like external hubs do.
+                 */
+                if (hcd->speed == HCD_USB3 &&
+                                (wLength < USB_DT_SS_HUB_SIZE ||
+                                 wValue != (USB_DT_SS_HUB << 8))) {
+                        xhci_dbg(xhci, "Wrong hub descriptor type for "
+                                        "USB 3.0 roothub.\n");
+                        goto error;
+                }
+                xhci_hub_descriptor(hcd, xhci,
+                                (struct usb_hub_descriptor *) buf);
                 break;
         case GetPortStatus:
-                if (!wIndex || wIndex > ports)
+                if (!wIndex || wIndex > max_ports)
                         goto error;
                 wIndex--;
                 status = 0;
-                addr = &xhci->op_regs->port_status_base + NUM_PORT_REGS*(wIndex & 0xff);
-                temp = xhci_readl(xhci, addr);
+                temp = xhci_readl(xhci, port_array[wIndex]);
+                if (temp == 0xffffffff) {
+                        retval = -ENODEV;
+                        break;
+                }
                 xhci_dbg(xhci, "get port status, actual port %d status  = 0x%x\n", wIndex, temp);
 
                 /* wPortChange bits */
@@ -210,10 +448,54 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                         status |= USB_PORT_STAT_C_ENABLE << 16;
                 if ((temp & PORT_OCC))
                         status |= USB_PORT_STAT_C_OVERCURRENT << 16;
-                /*
-                 * FIXME ignoring suspend, reset, and USB 2.1/3.0 specific
-                 * changes
-                 */
+                if ((temp & PORT_RC))
+                        status |= USB_PORT_STAT_C_RESET << 16;
+                /* USB3.0 only */
+                if (hcd->speed == HCD_USB3) {
+                        if ((temp & PORT_PLC))
+                                status |= USB_PORT_STAT_C_LINK_STATE << 16;
+                        if ((temp & PORT_WRC))
+                                status |= USB_PORT_STAT_C_BH_RESET << 16;
+                }
+
+                if (hcd->speed != HCD_USB3) {
+                        if ((temp & PORT_PLS_MASK) == XDEV_U3
+                                        && (temp & PORT_POWER))
+                                status |= USB_PORT_STAT_SUSPEND;
+                }
+                if ((temp & PORT_PLS_MASK) == XDEV_RESUME) {
+                        if ((temp & PORT_RESET) || !(temp & PORT_PE))
+                                goto error;
+                        if (!DEV_SUPERSPEED(temp) && time_after_eq(jiffies,
+                                                bus_state->resume_done[wIndex])) {
+                                xhci_dbg(xhci, "Resume USB2 port %d\n",
+                                        wIndex + 1);
+                                bus_state->resume_done[wIndex] = 0;
+                                temp1 = xhci_port_state_to_neutral(temp);
+                                temp1 &= ~PORT_PLS_MASK;
+                                temp1 |= PORT_LINK_STROBE | XDEV_U0;
+                                xhci_writel(xhci, temp1, port_array[wIndex]);
+
+                                xhci_dbg(xhci, "set port %d resume\n",
+                                        wIndex + 1);
+                                slot_id = xhci_find_slot_id_by_port(hcd, xhci,
+                                                                 wIndex + 1);
+                                if (!slot_id) {
+                                        xhci_dbg(xhci, "slot_id is zero\n");
+                                        goto error;
+                                }
+                                xhci_ring_device(xhci, slot_id);
+                                bus_state->port_c_suspend |= 1 << wIndex;
+                                bus_state->suspended_ports &= ~(1 << wIndex);
+                        }
+                }
+                if ((temp & PORT_PLS_MASK) == XDEV_U0
+                        && (temp & PORT_POWER)
+                        && (bus_state->suspended_ports & (1 << wIndex))) {
+                        bus_state->suspended_ports &= ~(1 << wIndex);
+                        if (hcd->speed != HCD_USB3)
+                                bus_state->port_c_suspend |= 1 << wIndex;
+                }
                 if (temp & PORT_CONNECT) {
                         status |= USB_PORT_STAT_CONNECTION;
                         status |= xhci_port_speed(temp);
@@ -224,20 +506,114 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                         status |= USB_PORT_STAT_OVERCURRENT;
                 if (temp & PORT_RESET)
                         status |= USB_PORT_STAT_RESET;
-                if (temp & PORT_POWER)
-                        status |= USB_PORT_STAT_POWER;
+                if (temp & PORT_POWER) {
+                        if (hcd->speed == HCD_USB3)
+                                status |= USB_SS_PORT_STAT_POWER;
+                        else
+                                status |= USB_PORT_STAT_POWER;
+                }
+                /* Port Link State */
+                if (hcd->speed == HCD_USB3) {
+                        /* resume state is a xHCI internal state.
+                         * Do not report it to usb core.
+                         */
+                        if ((temp & PORT_PLS_MASK) != XDEV_RESUME)
+                                status |= (temp & PORT_PLS_MASK);
+                }
+                if (bus_state->port_c_suspend & (1 << wIndex))
+                        status |= 1 << USB_PORT_FEAT_C_SUSPEND;
                 xhci_dbg(xhci, "Get port status returned 0x%x\n", status);
                 put_unaligned(cpu_to_le32(status), (__le32 *) buf);
                 break;
         case SetPortFeature:
+                if (wValue == USB_PORT_FEAT_LINK_STATE)
+                        link_state = (wIndex & 0xff00) >> 3;
                 wIndex &= 0xff;
-                if (!wIndex || wIndex > ports)
+                if (!wIndex || wIndex > max_ports)
                         goto error;
                 wIndex--;
-                addr = &xhci->op_regs->port_status_base + NUM_PORT_REGS*(wIndex & 0xff);
-                temp = xhci_readl(xhci, addr);
+                temp = xhci_readl(xhci, port_array[wIndex]);
+                if (temp == 0xffffffff) {
+                        retval = -ENODEV;
+                        break;
+                }
                 temp = xhci_port_state_to_neutral(temp);
+                /* FIXME: What new port features do we need to support? */
                 switch (wValue) {
+                case USB_PORT_FEAT_SUSPEND:
+                        temp = xhci_readl(xhci, port_array[wIndex]);
+                        /* In spec software should not attempt to suspend
+                         * a port unless the port reports that it is in the
+                         * enabled (PED = ‘1’,PLS < ‘3’) state.
+                         */
+                        if ((temp & PORT_PE) == 0 || (temp & PORT_RESET)
+                                || (temp & PORT_PLS_MASK) >= XDEV_U3) {
+                                xhci_warn(xhci, "USB core suspending device "
+                                          "not in U0/U1/U2.\n");
+                                goto error;
+                        }
+
+                        slot_id = xhci_find_slot_id_by_port(hcd, xhci,
+                                        wIndex + 1);
+                        if (!slot_id) {
+                                xhci_warn(xhci, "slot_id is zero\n");
+                                goto error;
+                        }
+                        /* unlock to execute stop endpoint commands */
+                        spin_unlock_irqrestore(&xhci->lock, flags);
+                        xhci_stop_device(xhci, slot_id, 1);
+                        spin_lock_irqsave(&xhci->lock, flags);
+
+                        temp = xhci_port_state_to_neutral(temp);
+                        temp &= ~PORT_PLS_MASK;
+                        temp |= PORT_LINK_STROBE | XDEV_U3;
+                        xhci_writel(xhci, temp, port_array[wIndex]);
+
+                        spin_unlock_irqrestore(&xhci->lock, flags);
+                        msleep(10); /* wait device to enter */
+                        spin_lock_irqsave(&xhci->lock, flags);
+
+                        temp = xhci_readl(xhci, port_array[wIndex]);
+                        bus_state->suspended_ports |= 1 << wIndex;
+                        break;
+                case USB_PORT_FEAT_LINK_STATE:
+                        temp = xhci_readl(xhci, port_array[wIndex]);
+                        /* Software should not attempt to set
+                         * port link state above '5' (Rx.Detect) and the port
+                         * must be enabled.
+                         */
+                        if ((temp & PORT_PE) == 0 ||
+                                (link_state > USB_SS_PORT_LS_RX_DETECT)) {
+                                xhci_warn(xhci, "Cannot set link state.\n");
+                                goto error;
+                        }
+
+                        if (link_state == USB_SS_PORT_LS_U3) {
+                                slot_id = xhci_find_slot_id_by_port(hcd, xhci,
+                                                wIndex + 1);
+                                if (slot_id) {
+                                        /* unlock to execute stop endpoint
+                                         * commands */
+                                        spin_unlock_irqrestore(&xhci->lock,
+                                                                flags);
+                                        xhci_stop_device(xhci, slot_id, 1);
+                                        spin_lock_irqsave(&xhci->lock, flags);
+                                }
+                        }
+
+                        temp = xhci_port_state_to_neutral(temp);
+                        temp &= ~PORT_PLS_MASK;
+                        temp |= PORT_LINK_STROBE | link_state;
+                        xhci_writel(xhci, temp, port_array[wIndex]);
+
+                        spin_unlock_irqrestore(&xhci->lock, flags);
+                        msleep(20); /* wait device to enter */
+                        spin_lock_irqsave(&xhci->lock, flags);
+
+                        temp = xhci_readl(xhci, port_array[wIndex]);
+                        if (link_state == USB_SS_PORT_LS_U3)
+                                bus_state->suspended_ports |= 1 << wIndex;
+                        break;
                 case USB_PORT_FEAT_POWER:
                         /*
                          * Turn on ports, even if there isn't per-port switching.
@@ -245,41 +621,96 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                          * However, khubd will ignore the roothub events until
                          * the roothub is registered.
                          */
-                        xhci_writel(xhci, temp | PORT_POWER, addr);
+                        xhci_writel(xhci, temp | PORT_POWER,
+                                        port_array[wIndex]);
 
-                        temp = xhci_readl(xhci, addr);
+                        temp = xhci_readl(xhci, port_array[wIndex]);
                         xhci_dbg(xhci, "set port power, actual port %d status  = 0x%x\n", wIndex, temp);
                         break;
                 case USB_PORT_FEAT_RESET:
                         temp = (temp | PORT_RESET);
-                        xhci_writel(xhci, temp, addr);
+                        xhci_writel(xhci, temp, port_array[wIndex]);
 
-                        temp = xhci_readl(xhci, addr);
+                        temp = xhci_readl(xhci, port_array[wIndex]);
                         xhci_dbg(xhci, "set port reset, actual port %d status  = 0x%x\n", wIndex, temp);
                         break;
+                case USB_PORT_FEAT_BH_PORT_RESET:
+                        temp |= PORT_WR;
+                        xhci_writel(xhci, temp, port_array[wIndex]);
+
+                        temp = xhci_readl(xhci, port_array[wIndex]);
+                        break;
                 default:
                         goto error;
                 }
-                temp = xhci_readl(xhci, addr); /* unblock any posted writes */
+                /* unblock any posted writes */
+                temp = xhci_readl(xhci, port_array[wIndex]);
                 break;
         case ClearPortFeature:
-                if (!wIndex || wIndex > ports)
+                if (!wIndex || wIndex > max_ports)
                         goto error;
                 wIndex--;
-                addr = &xhci->op_regs->port_status_base +
-                        NUM_PORT_REGS*(wIndex & 0xff);
-                temp = xhci_readl(xhci, addr);
+                temp = xhci_readl(xhci, port_array[wIndex]);
+                if (temp == 0xffffffff) {
+                        retval = -ENODEV;
+                        break;
+                }
+                /* FIXME: What new port features do we need to support? */
                 temp = xhci_port_state_to_neutral(temp);
                 switch (wValue) {
+                case USB_PORT_FEAT_SUSPEND:
+                        temp = xhci_readl(xhci, port_array[wIndex]);
+                        xhci_dbg(xhci, "clear USB_PORT_FEAT_SUSPEND\n");
+                        xhci_dbg(xhci, "PORTSC %04x\n", temp);
+                        if (temp & PORT_RESET)
+                                goto error;
+                        if (temp & XDEV_U3) {
+                                if ((temp & PORT_PE) == 0)
+                                        goto error;
+
+                                temp = xhci_port_state_to_neutral(temp);
+                                temp &= ~PORT_PLS_MASK;
+                                temp |= PORT_LINK_STROBE | XDEV_RESUME;
+                                xhci_writel(xhci, temp,
+                                                port_array[wIndex]);
+
+                                spin_unlock_irqrestore(&xhci->lock,
+                                                       flags);
+                                msleep(20);
+                                spin_lock_irqsave(&xhci->lock, flags);
+
+                                temp = xhci_readl(xhci,
+                                                port_array[wIndex]);
+                                temp = xhci_port_state_to_neutral(temp);
+                                temp &= ~PORT_PLS_MASK;
+                                temp |= PORT_LINK_STROBE | XDEV_U0;
+                                xhci_writel(xhci, temp,
+                                                port_array[wIndex]);
+                        }
+                        bus_state->port_c_suspend |= 1 << wIndex;
+
+                        slot_id = xhci_find_slot_id_by_port(hcd, xhci,
+                                        wIndex + 1);
+                        if (!slot_id) {
+                                xhci_dbg(xhci, "slot_id is zero\n");
+                                goto error;
+                        }
+                        xhci_ring_device(xhci, slot_id);
+                        break;
+                case USB_PORT_FEAT_C_SUSPEND:
+                        bus_state->port_c_suspend &= ~(1 << wIndex);
                 case USB_PORT_FEAT_C_RESET:
+                case USB_PORT_FEAT_C_BH_PORT_RESET:
                 case USB_PORT_FEAT_C_CONNECTION:
                 case USB_PORT_FEAT_C_OVER_CURRENT:
                 case USB_PORT_FEAT_C_ENABLE:
+                case USB_PORT_FEAT_C_PORT_LINK_STATE:
                         xhci_clear_port_change_bit(xhci, wValue, wIndex,
-                                        addr, temp);
+                                        port_array[wIndex], temp);
                         break;
                 case USB_PORT_FEAT_ENABLE:
-                        xhci_disable_port(xhci, wIndex, addr, temp);
+                        xhci_disable_port(hcd, xhci, wIndex,
+                                        port_array[wIndex], temp);
                         break;
                 default:
                         goto error;
@@ -306,25 +737,35 @@ int xhci_hub_status_data(struct usb_hcd *hcd, char *buf)
 {
         unsigned long flags;
         u32 temp, status;
+        u32 mask;
         int i, retval;
         struct xhci_hcd *xhci = hcd_to_xhci(hcd);
-        int ports;
-        u32 __iomem *addr;
+        int max_ports;
+        __le32 __iomem **port_array;
+        struct xhci_bus_state *bus_state;
 
-        ports = HCS_MAX_PORTS(xhci->hcs_params1);
+        max_ports = xhci_get_ports(hcd, &port_array);
+        bus_state = &xhci->bus_state[hcd_index(hcd)];
 
         /* Initial status is no changes */
-        retval = (ports + 8) / 8;
+        retval = (max_ports + 8) / 8;
         memset(buf, 0, retval);
         status = 0;
 
+        mask = PORT_CSC | PORT_PEC | PORT_OCC | PORT_PLC;
+
         spin_lock_irqsave(&xhci->lock, flags);
         /* For each port, did anything change?  If so, set that bit in buf. */
-        for (i = 0; i < ports; i++) {
-                addr = &xhci->op_regs->port_status_base +
-                        NUM_PORT_REGS*i;
-                temp = xhci_readl(xhci, addr);
-                if (temp & (PORT_CSC | PORT_PEC | PORT_OCC)) {
+        for (i = 0; i < max_ports; i++) {
+                temp = xhci_readl(xhci, port_array[i]);
+                if (temp == 0xffffffff) {
+                        retval = -ENODEV;
+                        break;
+                }
+                if ((temp & mask) != 0 ||
+                        (bus_state->port_c_suspend & 1 << i) ||
+                        (bus_state->resume_done[i] && time_after_eq(
+                            jiffies, bus_state->resume_done[i]))) {
                         buf[(i + 1) / 8] |= 1 << (i + 1) % 8;
                         status = 1;
                 }
@@ -332,3 +773,202 @@ int xhci_hub_status_data(struct usb_hcd *hcd, char *buf)
         spin_unlock_irqrestore(&xhci->lock, flags);
         return status ? retval : 0;
 }
+
+#ifdef CONFIG_PM
+
+int xhci_bus_suspend(struct usb_hcd *hcd)
+{
+        struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+        int max_ports, port_index;
+        __le32 __iomem **port_array;
+        struct xhci_bus_state *bus_state;
+        unsigned long flags;
+
+        max_ports = xhci_get_ports(hcd, &port_array);
+        bus_state = &xhci->bus_state[hcd_index(hcd)];
+
+        spin_lock_irqsave(&xhci->lock, flags);
+
+        if (hcd->self.root_hub->do_remote_wakeup) {
+                port_index = max_ports;
+                while (port_index--) {
+                        if (bus_state->resume_done[port_index] != 0) {
+                                spin_unlock_irqrestore(&xhci->lock, flags);
+                                xhci_dbg(xhci, "suspend failed because "
+                                                "port %d is resuming\n",
+                                                port_index + 1);
+                                return -EBUSY;
+                        }
+                }
+        }
+
+        port_index = max_ports;
+        bus_state->bus_suspended = 0;
+        while (port_index--) {
+                /* suspend the port if the port is not suspended */
+                u32 t1, t2;
+                int slot_id;
+
+                t1 = xhci_readl(xhci, port_array[port_index]);
+                t2 = xhci_port_state_to_neutral(t1);
+
+                if ((t1 & PORT_PE) && !(t1 & PORT_PLS_MASK)) {
+                        xhci_dbg(xhci, "port %d not suspended\n", port_index);
+                        slot_id = xhci_find_slot_id_by_port(hcd, xhci,
+                                        port_index + 1);
+                        if (slot_id) {
+                                spin_unlock_irqrestore(&xhci->lock, flags);
+                                xhci_stop_device(xhci, slot_id, 1);
+                                spin_lock_irqsave(&xhci->lock, flags);
+                        }
+                        t2 &= ~PORT_PLS_MASK;
+                        t2 |= PORT_LINK_STROBE | XDEV_U3;
+                        set_bit(port_index, &bus_state->bus_suspended);
+                }
+                if (hcd->self.root_hub->do_remote_wakeup) {
+                        if (t1 & PORT_CONNECT) {
+                                t2 |= PORT_WKOC_E | PORT_WKDISC_E;
+                                t2 &= ~PORT_WKCONN_E;
+                        } else {
+                                t2 |= PORT_WKOC_E | PORT_WKCONN_E;
+                                t2 &= ~PORT_WKDISC_E;
+                        }
+                } else
+                        t2 &= ~PORT_WAKE_BITS;
+
+                t1 = xhci_port_state_to_neutral(t1);
+                if (t1 != t2)
+                        xhci_writel(xhci, t2, port_array[port_index]);
+
+                if (hcd->speed != HCD_USB3) {
+                        /* enable remote wake up for USB 2.0 */
+                        __le32 __iomem *addr;
+                        u32 tmp;
+
+                        /* Add one to the port status register address to get
+                         * the port power control register address.
+                         */
+                        addr = port_array[port_index] + 1;
+                        tmp = xhci_readl(xhci, addr);
+                        tmp |= PORT_RWE;
+                        xhci_writel(xhci, tmp, addr);
+                }
+        }
+        hcd->state = HC_STATE_SUSPENDED;
+        bus_state->next_statechange = jiffies + msecs_to_jiffies(10);
+        spin_unlock_irqrestore(&xhci->lock, flags);
+        return 0;
+}
+
+int xhci_bus_resume(struct usb_hcd *hcd)
+{
+        struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+        int max_ports, port_index;
+        __le32 __iomem **port_array;
+        struct xhci_bus_state *bus_state;
+        u32 temp;
+        unsigned long flags;
+
+        max_ports = xhci_get_ports(hcd, &port_array);
+        bus_state = &xhci->bus_state[hcd_index(hcd)];
+
+        if (time_before(jiffies, bus_state->next_statechange))
+                msleep(5);
+
+        spin_lock_irqsave(&xhci->lock, flags);
+        if (!HCD_HW_ACCESSIBLE(hcd)) {
+                spin_unlock_irqrestore(&xhci->lock, flags);
+                return -ESHUTDOWN;
+        }
+
+        /* delay the irqs */
+        temp = xhci_readl(xhci, &xhci->op_regs->command);
+        temp &= ~CMD_EIE;
+        xhci_writel(xhci, temp, &xhci->op_regs->command);
+
+        port_index = max_ports;
+        while (port_index--) {
+                /* Check whether need resume ports. If needed
+                   resume port and disable remote wakeup */
+                u32 temp;
+                int slot_id;
+
+                temp = xhci_readl(xhci, port_array[port_index]);
+                if (DEV_SUPERSPEED(temp))
+                        temp &= ~(PORT_RWC_BITS | PORT_CEC | PORT_WAKE_BITS);
+                else
+                        temp &= ~(PORT_RWC_BITS | PORT_WAKE_BITS);
+                if (test_bit(port_index, &bus_state->bus_suspended) &&
+                    (temp & PORT_PLS_MASK)) {
+                        if (DEV_SUPERSPEED(temp)) {
+                                temp = xhci_port_state_to_neutral(temp);
+                                temp &= ~PORT_PLS_MASK;
+                                temp |= PORT_LINK_STROBE | XDEV_U0;
+                                xhci_writel(xhci, temp, port_array[port_index]);
+                        } else {
+                                temp = xhci_port_state_to_neutral(temp);
+                                temp &= ~PORT_PLS_MASK;
+                                temp |= PORT_LINK_STROBE | XDEV_RESUME;
+                                xhci_writel(xhci, temp, port_array[port_index]);
+
+                                spin_unlock_irqrestore(&xhci->lock, flags);
+                                msleep(20);
+                                spin_lock_irqsave(&xhci->lock, flags);
+
+                                temp = xhci_readl(xhci, port_array[port_index]);
+                                temp = xhci_port_state_to_neutral(temp);
+                                temp &= ~PORT_PLS_MASK;
+                                temp |= PORT_LINK_STROBE | XDEV_U0;
+                                xhci_writel(xhci, temp, port_array[port_index]);
+                        }
+                        /* wait for the port to enter U0 and report port link
+                         * state change.
+                         */
+                        spin_unlock_irqrestore(&xhci->lock, flags);
+                        msleep(20);
+                        spin_lock_irqsave(&xhci->lock, flags);
+
+                        /* Clear PLC */
+                        temp = xhci_readl(xhci, port_array[port_index]);
+                        if (temp & PORT_PLC) {
+                                temp = xhci_port_state_to_neutral(temp);
+                                temp |= PORT_PLC;
+                                xhci_writel(xhci, temp, port_array[port_index]);
+                        }
+
+                        slot_id = xhci_find_slot_id_by_port(hcd,
+                                        xhci, port_index + 1);
+                        if (slot_id)
+                                xhci_ring_device(xhci, slot_id);
+                } else
+                        xhci_writel(xhci, temp, port_array[port_index]);
+
+                if (hcd->speed != HCD_USB3) {
+                        /* disable remote wake up for USB 2.0 */
+                        __le32 __iomem *addr;
+                        u32 tmp;
+
+                        /* Add one to the port status register address to get
+                         * the port power control register address.
+                         */
+                        addr = port_array[port_index] + 1;
+                        tmp = xhci_readl(xhci, addr);
+                        tmp &= ~PORT_RWE;
+                        xhci_writel(xhci, tmp, addr);
+                }
+        }
+
+        (void) xhci_readl(xhci, &xhci->op_regs->command);
+
+        bus_state->next_statechange = jiffies + msecs_to_jiffies(5);
+        /* re-enable irqs */
+        temp = xhci_readl(xhci, &xhci->op_regs->command);
+        temp |= CMD_EIE;
+        xhci_writel(xhci, temp, &xhci->op_regs->command);
+        temp = xhci_readl(xhci, &xhci->op_regs->command);
+
+        spin_unlock_irqrestore(&xhci->lock, flags);
+        return 0;
+}
+
+#endif  /* CONFIG_PM */
diff --git a/drivers/usb/host/xhci-mem.c b/drivers/usb/host/xhci-mem.c
index 4e51343ddffc..fcb7f7efc86d 100644
--- a/drivers/usb/host/xhci-mem.c
+++ b/drivers/usb/host/xhci-mem.c
@@ -89,16 +89,17 @@ static void xhci_link_segments(struct xhci_hcd *xhci, struct xhci_segment *prev,
                 return;
         prev->next = next;
         if (link_trbs) {
-                prev->trbs[TRBS_PER_SEGMENT-1].link.segment_ptr = next->dma;
+                prev->trbs[TRBS_PER_SEGMENT-1].link.
+                        segment_ptr = cpu_to_le64(next->dma);
 
                 /* Set the last TRB in the segment to have a TRB type ID of Link TRB */
-                val = prev->trbs[TRBS_PER_SEGMENT-1].link.control;
+                val = le32_to_cpu(prev->trbs[TRBS_PER_SEGMENT-1].link.control);
                 val &= ~TRB_TYPE_BITMASK;
                 val |= TRB_TYPE(TRB_LINK);
                 /* Always set the chain bit with 0.95 hardware */
                 if (xhci_link_trb_quirk(xhci))
                         val |= TRB_CHAIN;
-                prev->trbs[TRBS_PER_SEGMENT-1].link.control = val;
+                prev->trbs[TRBS_PER_SEGMENT-1].link.control = cpu_to_le32(val);
         }
         xhci_dbg(xhci, "Linking segment 0x%llx to segment 0x%llx (DMA)\n",
                         (unsigned long long)prev->dma,
@@ -186,7 +187,8 @@ static struct xhci_ring *xhci_ring_alloc(struct xhci_hcd *xhci,
 
         if (link_trbs) {
                 /* See section 4.9.2.1 and 6.4.4.1 */
-                prev->trbs[TRBS_PER_SEGMENT-1].link.control |= (LINK_TOGGLE);
+                prev->trbs[TRBS_PER_SEGMENT-1].link.
+                        control |= cpu_to_le32(LINK_TOGGLE);
                 xhci_dbg(xhci, "Wrote link toggle flag to"
                                 " segment %p (virtual), 0x%llx (DMA)\n",
                                 prev, (unsigned long long)prev->dma);
@@ -207,14 +209,13 @@ void xhci_free_or_cache_endpoint_ring(struct xhci_hcd *xhci,
 
         rings_cached = virt_dev->num_rings_cached;
         if (rings_cached < XHCI_MAX_RINGS_CACHED) {
-                virt_dev->num_rings_cached++;
-                rings_cached = virt_dev->num_rings_cached;
                 virt_dev->ring_cache[rings_cached] =
                         virt_dev->eps[ep_index].ring;
+                virt_dev->num_rings_cached++;
                 xhci_dbg(xhci, "Cached old ring, "
                                 "%d ring%s cached\n",
-                                rings_cached,
-                                (rings_cached > 1) ? "s" : "");
+                                virt_dev->num_rings_cached,
+                                (virt_dev->num_rings_cached > 1) ? "s" : "");
         } else {
                 xhci_ring_free(xhci, virt_dev->eps[ep_index].ring);
                 xhci_dbg(xhci, "Ring cache full (%d rings), "
@@ -307,7 +308,7 @@ struct xhci_ep_ctx *xhci_get_ep_ctx(struct xhci_hcd *xhci,
 
 /***************** Streams structures manipulation *************************/
 
-void xhci_free_stream_ctx(struct xhci_hcd *xhci,
+static void xhci_free_stream_ctx(struct xhci_hcd *xhci,
                 unsigned int num_stream_ctxs,
                 struct xhci_stream_ctx *stream_ctx, dma_addr_t dma)
 {
@@ -335,7 +336,7 @@ void xhci_free_stream_ctx(struct xhci_hcd *xhci,
  * The stream context array must be a power of 2, and can be as small as
  * 64 bytes or as large as 1MB.
  */
-struct xhci_stream_ctx *xhci_alloc_stream_ctx(struct xhci_hcd *xhci,
+static struct xhci_stream_ctx *xhci_alloc_stream_ctx(struct xhci_hcd *xhci,
                 unsigned int num_stream_ctxs, dma_addr_t *dma,
                 gfp_t mem_flags)
 {
@@ -548,7 +549,8 @@ struct xhci_stream_info *xhci_alloc_stream_info(struct xhci_hcd *xhci,
                 addr = cur_ring->first_seg->dma |
                         SCT_FOR_CTX(SCT_PRI_TR) |
                         cur_ring->cycle_state;
-                stream_info->stream_ctx_array[cur_stream].stream_ring = addr;
+                stream_info->stream_ctx_array[cur_stream].
+                        stream_ring = cpu_to_le64(addr);
                 xhci_dbg(xhci, "Setting stream %d ring ptr to 0x%08llx\n",
                                 cur_stream, (unsigned long long) addr);
 
@@ -614,10 +616,10 @@ void xhci_setup_streams_ep_input_ctx(struct xhci_hcd *xhci,
         max_primary_streams = fls(stream_info->num_stream_ctxs) - 2;
         xhci_dbg(xhci, "Setting number of stream ctx array entries to %u\n",
                         1 << (max_primary_streams + 1));
-        ep_ctx->ep_info &= ~EP_MAXPSTREAMS_MASK;
-        ep_ctx->ep_info |= EP_MAXPSTREAMS(max_primary_streams);
-        ep_ctx->ep_info |= EP_HAS_LSA;
-        ep_ctx->deq  = stream_info->ctx_array_dma;
+        ep_ctx->ep_info &= cpu_to_le32(~EP_MAXPSTREAMS_MASK);
+        ep_ctx->ep_info |= cpu_to_le32(EP_MAXPSTREAMS(max_primary_streams)
+                                       | EP_HAS_LSA);
+        ep_ctx->deq  = cpu_to_le64(stream_info->ctx_array_dma);
 }
 
 /*
@@ -630,10 +632,9 @@ void xhci_setup_no_streams_ep_input_ctx(struct xhci_hcd *xhci,
                 struct xhci_virt_ep *ep)
 {
         dma_addr_t addr;
-        ep_ctx->ep_info &= ~EP_MAXPSTREAMS_MASK;
-        ep_ctx->ep_info &= ~EP_HAS_LSA;
+        ep_ctx->ep_info &= cpu_to_le32(~(EP_MAXPSTREAMS_MASK | EP_HAS_LSA));
         addr = xhci_trb_virt_to_dma(ep->ring->deq_seg, ep->ring->dequeue);
-        ep_ctx->deq  = addr | ep->ring->cycle_state;
+        ep_ctx->deq  = cpu_to_le64(addr | ep->ring->cycle_state);
 }
 
 /* Frees all stream contexts associated with the endpoint,
@@ -778,13 +779,14 @@ int xhci_alloc_virt_device(struct xhci_hcd *xhci, int slot_id,
 
         init_completion(&dev->cmd_completion);
         INIT_LIST_HEAD(&dev->cmd_list);
+        dev->udev = udev;
 
         /* Point to output device context in dcbaa. */
-        xhci->dcbaa->dev_context_ptrs[slot_id] = dev->out_ctx->dma;
+        xhci->dcbaa->dev_context_ptrs[slot_id] = cpu_to_le64(dev->out_ctx->dma);
         xhci_dbg(xhci, "Set slot id %d dcbaa entry %p to 0x%llx\n",
-                        slot_id,
-                        &xhci->dcbaa->dev_context_ptrs[slot_id],
-                        (unsigned long long) xhci->dcbaa->dev_context_ptrs[slot_id]);
+                 slot_id,
+                 &xhci->dcbaa->dev_context_ptrs[slot_id],
+                 (unsigned long long) le64_to_cpu(xhci->dcbaa->dev_context_ptrs[slot_id]));
 
         return 1;
 fail:
@@ -809,8 +811,58 @@ void xhci_copy_ep0_dequeue_into_input_ctx(struct xhci_hcd *xhci,
          * configured device has reset, so all control transfers should have
          * been completed or cancelled before the reset.
          */
-        ep0_ctx->deq = xhci_trb_virt_to_dma(ep_ring->enq_seg, ep_ring->enqueue);
-        ep0_ctx->deq |= ep_ring->cycle_state;
+        ep0_ctx->deq = cpu_to_le64(xhci_trb_virt_to_dma(ep_ring->enq_seg,
+                                                        ep_ring->enqueue)
+                                   | ep_ring->cycle_state);
+}
+
+/*
+ * The xHCI roothub may have ports of differing speeds in any order in the port
+ * status registers.  xhci->port_array provides an array of the port speed for
+ * each offset into the port status registers.
+ *
+ * The xHCI hardware wants to know the roothub port number that the USB device
+ * is attached to (or the roothub port its ancestor hub is attached to).  All we
+ * know is the index of that port under either the USB 2.0 or the USB 3.0
+ * roothub, but that doesn't give us the real index into the HW port status
+ * registers.  Scan through the xHCI roothub port array, looking for the Nth
+ * entry of the correct port speed.  Return the port number of that entry.
+ */
+static u32 xhci_find_real_port_number(struct xhci_hcd *xhci,
+                struct usb_device *udev)
+{
+        struct usb_device *top_dev;
+        unsigned int num_similar_speed_ports;
+        unsigned int faked_port_num;
+        int i;
+
+        for (top_dev = udev; top_dev->parent && top_dev->parent->parent;
+                        top_dev = top_dev->parent)
+                /* Found device below root hub */;
+        faked_port_num = top_dev->portnum;
+        for (i = 0, num_similar_speed_ports = 0;
+                        i < HCS_MAX_PORTS(xhci->hcs_params1); i++) {
+                u8 port_speed = xhci->port_array[i];
+
+                /*
+                 * Skip ports that don't have known speeds, or have duplicate
+                 * Extended Capabilities port speed entries.
+                 */
+                if (port_speed == 0 || port_speed == DUPLICATE_ENTRY)
+                        continue;
+
+                /*
+                 * USB 3.0 ports are always under a USB 3.0 hub.  USB 2.0 and
+                 * 1.1 ports are under the USB 2.0 hub.  If the port speed
+                 * matches the device speed, it's a similar speed port.
+                 */
+                if ((port_speed == 0x03) == (udev->speed == USB_SPEED_SUPER))
+                        num_similar_speed_ports++;
+                if (num_similar_speed_ports == faked_port_num)
+                        /* Roothub ports are numbered from 1 to N */
+                        return i+1;
+        }
+        return 0;
 }
 
 /* Setup an xHCI virtual device for a Set Address command */
@@ -818,9 +870,10 @@ int xhci_setup_addressable_virt_dev(struct xhci_hcd *xhci, struct usb_device *ud
 {
         struct xhci_virt_device *dev;
         struct xhci_ep_ctx      *ep0_ctx;
-        struct usb_device       *top_dev;
         struct xhci_slot_ctx    *slot_ctx;
         struct xhci_input_control_ctx *ctrl_ctx;
+        u32                     port_num;
+        struct usb_device *top_dev;
 
         dev = xhci->devs[udev->slot_id];
         /* Slot ID 0 is reserved */
@@ -834,24 +887,22 @@ int xhci_setup_addressable_virt_dev(struct xhci_hcd *xhci, struct usb_device *ud
         slot_ctx = xhci_get_slot_ctx(xhci, dev->in_ctx);
 
         /* 2) New slot context and endpoint 0 context are valid*/
-        ctrl_ctx->add_flags = SLOT_FLAG | EP0_FLAG;
+        ctrl_ctx->add_flags = cpu_to_le32(SLOT_FLAG | EP0_FLAG);
 
         /* 3) Only the control endpoint is valid - one endpoint context */
-        slot_ctx->dev_info |= LAST_CTX(1);
-
-        slot_ctx->dev_info |= (u32) udev->route;
+        slot_ctx->dev_info |= cpu_to_le32(LAST_CTX(1) | (u32) udev->route);
         switch (udev->speed) {
         case USB_SPEED_SUPER:
-                slot_ctx->dev_info |= (u32) SLOT_SPEED_SS;
+                slot_ctx->dev_info |= cpu_to_le32((u32) SLOT_SPEED_SS);
                 break;
         case USB_SPEED_HIGH:
-                slot_ctx->dev_info |= (u32) SLOT_SPEED_HS;
+                slot_ctx->dev_info |= cpu_to_le32((u32) SLOT_SPEED_HS);
                 break;
         case USB_SPEED_FULL:
-                slot_ctx->dev_info |= (u32) SLOT_SPEED_FS;
+                slot_ctx->dev_info |= cpu_to_le32((u32) SLOT_SPEED_FS);
                 break;
         case USB_SPEED_LOW:
-                slot_ctx->dev_info |= (u32) SLOT_SPEED_LS;
+                slot_ctx->dev_info |= cpu_to_le32((u32) SLOT_SPEED_LS);
                 break;
         case USB_SPEED_WIRELESS:
                 xhci_dbg(xhci, "FIXME xHCI doesn't support wireless speeds\n");
@@ -862,40 +913,45 @@ int xhci_setup_addressable_virt_dev(struct xhci_hcd *xhci, struct usb_device *ud
                 BUG();
         }
         /* Find the root hub port this device is under */
+        port_num = xhci_find_real_port_number(xhci, udev);
+        if (!port_num)
+                return -EINVAL;
+        slot_ctx->dev_info2 |= cpu_to_le32((u32) ROOT_HUB_PORT(port_num));
+        /* Set the port number in the virtual_device to the faked port number */
         for (top_dev = udev; top_dev->parent && top_dev->parent->parent;
                         top_dev = top_dev->parent)
                 /* Found device below root hub */;
-        slot_ctx->dev_info2 |= (u32) ROOT_HUB_PORT(top_dev->portnum);
-        xhci_dbg(xhci, "Set root hub portnum to %d\n", top_dev->portnum);
-
-        /* Is this a LS/FS device under a HS hub? */
-        if ((udev->speed == USB_SPEED_LOW || udev->speed == USB_SPEED_FULL) &&
-                        udev->tt) {
-                slot_ctx->tt_info = udev->tt->hub->slot_id;
-                slot_ctx->tt_info |= udev->ttport << 8;
+        dev->port = top_dev->portnum;
+        xhci_dbg(xhci, "Set root hub portnum to %d\n", port_num);
+        xhci_dbg(xhci, "Set fake root hub portnum to %d\n", dev->port);
+
+        /* Is this a LS/FS device under an external HS hub? */
+        if (udev->tt && udev->tt->hub->parent) {
+                slot_ctx->tt_info = cpu_to_le32(udev->tt->hub->slot_id |
+                                                (udev->ttport << 8));
                 if (udev->tt->multi)
-                        slot_ctx->dev_info |= DEV_MTT;
+                        slot_ctx->dev_info |= cpu_to_le32(DEV_MTT);
         }
         xhci_dbg(xhci, "udev->tt = %p\n", udev->tt);
         xhci_dbg(xhci, "udev->ttport = 0x%x\n", udev->ttport);
 
         /* Step 4 - ring already allocated */
         /* Step 5 */
-        ep0_ctx->ep_info2 = EP_TYPE(CTRL_EP);
+        ep0_ctx->ep_info2 = cpu_to_le32(EP_TYPE(CTRL_EP));
         /*
          * XXX: Not sure about wireless USB devices.
          */
         switch (udev->speed) {
         case USB_SPEED_SUPER:
-                ep0_ctx->ep_info2 |= MAX_PACKET(512);
+                ep0_ctx->ep_info2 |= cpu_to_le32(MAX_PACKET(512));
                 break;
         case USB_SPEED_HIGH:
         /* USB core guesses at a 64-byte max packet first for FS devices */
         case USB_SPEED_FULL:
-                ep0_ctx->ep_info2 |= MAX_PACKET(64);
+                ep0_ctx->ep_info2 |= cpu_to_le32(MAX_PACKET(64));
                 break;
         case USB_SPEED_LOW:
-                ep0_ctx->ep_info2 |= MAX_PACKET(8);
+                ep0_ctx->ep_info2 |= cpu_to_le32(MAX_PACKET(8));
                 break;
         case USB_SPEED_WIRELESS:
                 xhci_dbg(xhci, "FIXME xHCI doesn't support wireless speeds\n");
@@ -906,18 +962,67 @@ int xhci_setup_addressable_virt_dev(struct xhci_hcd *xhci, struct usb_device *ud
                 BUG();
         }
         /* EP 0 can handle "burst" sizes of 1, so Max Burst Size field is 0 */
-        ep0_ctx->ep_info2 |= MAX_BURST(0);
-        ep0_ctx->ep_info2 |= ERROR_COUNT(3);
+        ep0_ctx->ep_info2 |= cpu_to_le32(MAX_BURST(0) | ERROR_COUNT(3));
 
-        ep0_ctx->deq =
-                dev->eps[0].ring->first_seg->dma;
-        ep0_ctx->deq |= dev->eps[0].ring->cycle_state;
+        ep0_ctx->deq = cpu_to_le64(dev->eps[0].ring->first_seg->dma |
+                                   dev->eps[0].ring->cycle_state);
 
         /* Steps 7 and 8 were done in xhci_alloc_virt_device() */
 
         return 0;
 }
 
+/*
+ * Convert interval expressed as 2^(bInterval - 1) == interval into
+ * straight exponent value 2^n == interval.
+ *
+ */
+static unsigned int xhci_parse_exponent_interval(struct usb_device *udev,
+                struct usb_host_endpoint *ep)
+{
+        unsigned int interval;
+
+        interval = clamp_val(ep->desc.bInterval, 1, 16) - 1;
+        if (interval != ep->desc.bInterval - 1)
+                dev_warn(&udev->dev,
+                         "ep %#x - rounding interval to %d %sframes\n",
+                         ep->desc.bEndpointAddress,
+                         1 << interval,
+                         udev->speed == USB_SPEED_FULL ? "" : "micro");
+
+        if (udev->speed == USB_SPEED_FULL) {
+                /*
+                 * Full speed isoc endpoints specify interval in frames,
+                 * not microframes. We are using microframes everywhere,
+                 * so adjust accordingly.
+                 */
+                interval += 3;  /* 1 frame = 2^3 uframes */
+        }
+
+        return interval;
+}
+
+/*
+ * Convert bInterval expressed in frames (in 1-255 range) to exponent of
+ * microframes, rounded down to nearest power of 2.
+ */
+static unsigned int xhci_parse_frame_interval(struct usb_device *udev,
+                struct usb_host_endpoint *ep)
+{
+        unsigned int interval;
+
+        interval = fls(8 * ep->desc.bInterval) - 1;
+        interval = clamp_val(interval, 3, 10);
+        if ((1 << interval) != 8 * ep->desc.bInterval)
+                dev_warn(&udev->dev,
+                         "ep %#x - rounding interval to %d microframes, ep desc says %d microframes\n",
+                         ep->desc.bEndpointAddress,
+                         1 << interval,
+                         8 * ep->desc.bInterval);
+
+        return interval;
+}
+
 /* Return the polling or NAK interval.
  *
  * The polling interval is expressed in "microframes".  If xHCI's Interval field
@@ -926,7 +1031,7 @@ int xhci_setup_addressable_virt_dev(struct xhci_hcd *xhci, struct usb_device *ud
  * The NAK interval is one NAK per 1 to 255 microframes, or no NAKs if interval
  * is set to 0.
  */
-static inline unsigned int xhci_get_endpoint_interval(struct usb_device *udev,
+static unsigned int xhci_get_endpoint_interval(struct usb_device *udev,
                 struct usb_host_endpoint *ep)
 {
         unsigned int interval = 0;
@@ -935,45 +1040,38 @@ static inline unsigned int xhci_get_endpoint_interval(struct usb_device *udev,
         case USB_SPEED_HIGH:
                 /* Max NAK rate */
                 if (usb_endpoint_xfer_control(&ep->desc) ||
-                                usb_endpoint_xfer_bulk(&ep->desc))
+                    usb_endpoint_xfer_bulk(&ep->desc)) {
                         interval = ep->desc.bInterval;
+                        break;
+                }
                 /* Fall through - SS and HS isoc/int have same decoding */
+
         case USB_SPEED_SUPER:
                 if (usb_endpoint_xfer_int(&ep->desc) ||
-                                usb_endpoint_xfer_isoc(&ep->desc)) {
-                        if (ep->desc.bInterval == 0)
-                                interval = 0;
-                        else
-                                interval = ep->desc.bInterval - 1;
-                        if (interval > 15)
-                                interval = 15;
-                        if (interval != ep->desc.bInterval + 1)
-                                dev_warn(&udev->dev, "ep %#x - rounding interval to %d microframes\n",
-                                                ep->desc.bEndpointAddress, 1 << interval);
+                    usb_endpoint_xfer_isoc(&ep->desc)) {
+                        interval = xhci_parse_exponent_interval(udev, ep);
                 }
                 break;
-        /* Convert bInterval (in 1-255 frames) to microframes and round down to
-         * nearest power of 2.
-         */
+
         case USB_SPEED_FULL:
+                if (usb_endpoint_xfer_isoc(&ep->desc)) {
+                        interval = xhci_parse_exponent_interval(udev, ep);
+                        break;
+                }
+                /*
+                 * Fall through for interrupt endpoint interval decoding
+                 * since it uses the same rules as low speed interrupt
+                 * endpoints.
+                 */
+
         case USB_SPEED_LOW:
                 if (usb_endpoint_xfer_int(&ep->desc) ||
-                                usb_endpoint_xfer_isoc(&ep->desc)) {
-                        interval = fls(8*ep->desc.bInterval) - 1;
-                        if (interval > 10)
-                                interval = 10;
-                        if (interval < 3)
-                                interval = 3;
-                        if ((1 << interval) != 8*ep->desc.bInterval)
-                                dev_warn(&udev->dev,
-                                                "ep %#x - rounding interval"
-                                                " to %d microframes, "
-                                                "ep desc says %d microframes\n",
-                                                ep->desc.bEndpointAddress,
-                                                1 << interval,
-                                                8*ep->desc.bInterval);
+                    usb_endpoint_xfer_isoc(&ep->desc)) {
+
+                        interval = xhci_parse_frame_interval(udev, ep);
                 }
                 break;
+
         default:
                 BUG();
         }
@@ -985,7 +1083,7 @@ static inline unsigned int xhci_get_endpoint_interval(struct usb_device *udev,
  * transaction opportunities per microframe", but that goes in the Max Burst
  * endpoint context field.
  */
-static inline u32 xhci_get_endpoint_mult(struct usb_device *udev,
+static u32 xhci_get_endpoint_mult(struct usb_device *udev,
                 struct usb_host_endpoint *ep)
 {
         if (udev->speed != USB_SPEED_SUPER ||
@@ -994,7 +1092,7 @@ static inline u32 xhci_get_endpoint_mult(struct usb_device *udev,
         return ep->ss_ep_comp.bmAttributes;
 }
 
-static inline u32 xhci_get_endpoint_type(struct usb_device *udev,
+static u32 xhci_get_endpoint_type(struct usb_device *udev,
                 struct usb_host_endpoint *ep)
 {
         int in;
@@ -1028,7 +1126,7 @@ static inline u32 xhci_get_endpoint_type(struct usb_device *udev,
  * Basically, this is the maxpacket size, multiplied by the burst size
  * and mult size.
  */
-static inline u32 xhci_get_max_esit_payload(struct xhci_hcd *xhci,
+static u32 xhci_get_max_esit_payload(struct xhci_hcd *xhci,
                 struct usb_device *udev,
                 struct usb_host_endpoint *ep)
 {
@@ -1041,10 +1139,10 @@ static inline u32 xhci_get_max_esit_payload(struct xhci_hcd *xhci,
                 return 0;
 
         if (udev->speed == USB_SPEED_SUPER)
-                return ep->ss_ep_comp.wBytesPerInterval;
+                return le16_to_cpu(ep->ss_ep_comp.wBytesPerInterval);
 
-        max_packet = ep->desc.wMaxPacketSize & 0x3ff;
-        max_burst = (ep->desc.wMaxPacketSize & 0x1800) >> 11;
+        max_packet = GET_MAX_PACKET(le16_to_cpu(ep->desc.wMaxPacketSize));
+        max_burst = (le16_to_cpu(ep->desc.wMaxPacketSize) & 0x1800) >> 11;
         /* A 0 in max burst means 1 transfer per ESIT */
         return max_packet * (max_burst + 1);
 }
@@ -1093,33 +1191,31 @@ int xhci_endpoint_init(struct xhci_hcd *xhci,
         }
         virt_dev->eps[ep_index].skip = false;
         ep_ring = virt_dev->eps[ep_index].new_ring;
-        ep_ctx->deq = ep_ring->first_seg->dma | ep_ring->cycle_state;
+        ep_ctx->deq = cpu_to_le64(ep_ring->first_seg->dma | ep_ring->cycle_state);
 
-        ep_ctx->ep_info = xhci_get_endpoint_interval(udev, ep);
-        ep_ctx->ep_info |= EP_MULT(xhci_get_endpoint_mult(udev, ep));
+        ep_ctx->ep_info = cpu_to_le32(xhci_get_endpoint_interval(udev, ep)
+                                      | EP_MULT(xhci_get_endpoint_mult(udev, ep)));
 
         /* FIXME dig Mult and streams info out of ep companion desc */
 
         /* Allow 3 retries for everything but isoc;
-         * error count = 0 means infinite retries.
+         * CErr shall be set to 0 for Isoch endpoints.
          */
         if (!usb_endpoint_xfer_isoc(&ep->desc))
-                ep_ctx->ep_info2 = ERROR_COUNT(3);
+                ep_ctx->ep_info2 = cpu_to_le32(ERROR_COUNT(3));
         else
-                ep_ctx->ep_info2 = ERROR_COUNT(1);
+                ep_ctx->ep_info2 = cpu_to_le32(ERROR_COUNT(0));
 
-        ep_ctx->ep_info2 |= xhci_get_endpoint_type(udev, ep);
+        ep_ctx->ep_info2 |= cpu_to_le32(xhci_get_endpoint_type(udev, ep));
 
         /* Set the max packet size and max burst */
         switch (udev->speed) {
         case USB_SPEED_SUPER:
-                max_packet = ep->desc.wMaxPacketSize;
-                ep_ctx->ep_info2 |= MAX_PACKET(max_packet);
+                max_packet = le16_to_cpu(ep->desc.wMaxPacketSize);
+                ep_ctx->ep_info2 |= cpu_to_le32(MAX_PACKET(max_packet));
                 /* dig out max burst from ep companion desc */
                 max_packet = ep->ss_ep_comp.bMaxBurst;
-                if (!max_packet)
-                        xhci_warn(xhci, "WARN no SS endpoint bMaxBurst\n");
-                ep_ctx->ep_info2 |= MAX_BURST(max_packet);
+                ep_ctx->ep_info2 |= cpu_to_le32(MAX_BURST(max_packet));
                 break;
         case USB_SPEED_HIGH:
                 /* bits 11:12 specify the number of additional transaction
@@ -1127,20 +1223,21 @@ int xhci_endpoint_init(struct xhci_hcd *xhci,
                  */
                 if (usb_endpoint_xfer_isoc(&ep->desc) ||
                                 usb_endpoint_xfer_int(&ep->desc)) {
-                        max_burst = (ep->desc.wMaxPacketSize & 0x1800) >> 11;
-                        ep_ctx->ep_info2 |= MAX_BURST(max_burst);
+                        max_burst = (le16_to_cpu(ep->desc.wMaxPacketSize)
+                                     & 0x1800) >> 11;
+                        ep_ctx->ep_info2 |= cpu_to_le32(MAX_BURST(max_burst));
                 }
                 /* Fall through */
         case USB_SPEED_FULL:
         case USB_SPEED_LOW:
-                max_packet = ep->desc.wMaxPacketSize & 0x3ff;
-                ep_ctx->ep_info2 |= MAX_PACKET(max_packet);
+                max_packet = GET_MAX_PACKET(le16_to_cpu(ep->desc.wMaxPacketSize));
+                ep_ctx->ep_info2 |= cpu_to_le32(MAX_PACKET(max_packet));
                 break;
         default:
                 BUG();
         }
         max_esit_payload = xhci_get_max_esit_payload(xhci, udev, ep);
-        ep_ctx->tx_info = MAX_ESIT_PAYLOAD_FOR_EP(max_esit_payload);
+        ep_ctx->tx_info = cpu_to_le32(MAX_ESIT_PAYLOAD_FOR_EP(max_esit_payload));
 
         /*
          * XXX no idea how to calculate the average TRB buffer length for bulk
@@ -1156,8 +1253,15 @@ int xhci_endpoint_init(struct xhci_hcd *xhci,
          * including link TRBs, No-op TRBs, and Event data TRBs.  Since we don't
          * use Event Data TRBs, and we don't chain in a link TRB on short
          * transfers, we're basically dividing by 1.
+         *
+         * xHCI 1.0 specification indicates that the Average TRB Length should
+         * be set to 8 for control endpoints.
          */
-        ep_ctx->tx_info |= AVG_TRB_LENGTH_FOR_EP(max_esit_payload);
+        if (usb_endpoint_xfer_control(&ep->desc) && xhci->hci_version == 0x100)
+                ep_ctx->tx_info |= cpu_to_le32(AVG_TRB_LENGTH_FOR_EP(8));
+        else
+                ep_ctx->tx_info |=
+                         cpu_to_le32(AVG_TRB_LENGTH_FOR_EP(max_esit_payload));
 
         /* FIXME Debug endpoint context */
         return 0;
@@ -1257,7 +1361,7 @@ static int scratchpad_alloc(struct xhci_hcd *xhci, gfp_t flags)
         if (!xhci->scratchpad->sp_dma_buffers)
                 goto fail_sp4;
 
-        xhci->dcbaa->dev_context_ptrs[0] = xhci->scratchpad->sp_dma;
+        xhci->dcbaa->dev_context_ptrs[0] = cpu_to_le64(xhci->scratchpad->sp_dma);
         for (i = 0; i < num_sp; i++) {
                 dma_addr_t dma;
                 void *buf = pci_alloc_consistent(to_pci_dev(dev),
@@ -1441,8 +1545,17 @@ void xhci_mem_cleanup(struct xhci_hcd *xhci)
         xhci->dcbaa = NULL;
 
         scratchpad_free(xhci);
+
+        xhci->num_usb2_ports = 0;
+        xhci->num_usb3_ports = 0;
+        kfree(xhci->usb2_ports);
+        kfree(xhci->usb3_ports);
+        kfree(xhci->port_array);
+
         xhci->page_size = 0;
         xhci->page_shift = 0;
+        xhci->bus_state[0].bus_suspended = 0;
+        xhci->bus_state[1].bus_suspended = 0;
 }
 
 static int xhci_test_trb_in_td(struct xhci_hcd *xhci,
@@ -1624,6 +1737,184 @@ static void xhci_set_hc_event_deq(struct xhci_hcd *xhci)
                         &xhci->ir_set->erst_dequeue);
 }
 
+static void xhci_add_in_port(struct xhci_hcd *xhci, unsigned int num_ports,
+                __le32 __iomem *addr, u8 major_revision)
+{
+        u32 temp, port_offset, port_count;
+        int i;
+
+        if (major_revision > 0x03) {
+                xhci_warn(xhci, "Ignoring unknown port speed, "
+                                "Ext Cap %p, revision = 0x%x\n",
+                                addr, major_revision);
+                /* Ignoring port protocol we can't understand. FIXME */
+                return;
+        }
+
+        /* Port offset and count in the third dword, see section 7.2 */
+        temp = xhci_readl(xhci, addr + 2);
+        port_offset = XHCI_EXT_PORT_OFF(temp);
+        port_count = XHCI_EXT_PORT_COUNT(temp);
+        xhci_dbg(xhci, "Ext Cap %p, port offset = %u, "
+                        "count = %u, revision = 0x%x\n",
+                        addr, port_offset, port_count, major_revision);
+        /* Port count includes the current port offset */
+        if (port_offset == 0 || (port_offset + port_count - 1) > num_ports)
+                /* WTF? "Valid values are ‘1’ to MaxPorts" */
+                return;
+        port_offset--;
+        for (i = port_offset; i < (port_offset + port_count); i++) {
+                /* Duplicate entry.  Ignore the port if the revisions differ. */
+                if (xhci->port_array[i] != 0) {
+                        xhci_warn(xhci, "Duplicate port entry, Ext Cap %p,"
+                                        " port %u\n", addr, i);
+                        xhci_warn(xhci, "Port was marked as USB %u, "
+                                        "duplicated as USB %u\n",
+                                        xhci->port_array[i], major_revision);
+                        /* Only adjust the roothub port counts if we haven't
+                         * found a similar duplicate.
+                         */
+                        if (xhci->port_array[i] != major_revision &&
+                                xhci->port_array[i] != DUPLICATE_ENTRY) {
+                                if (xhci->port_array[i] == 0x03)
+                                        xhci->num_usb3_ports--;
+                                else
+                                        xhci->num_usb2_ports--;
+                                xhci->port_array[i] = DUPLICATE_ENTRY;
+                        }
+                        /* FIXME: Should we disable the port? */
+                        continue;
+                }
+                xhci->port_array[i] = major_revision;
+                if (major_revision == 0x03)
+                        xhci->num_usb3_ports++;
+                else
+                        xhci->num_usb2_ports++;
+        }
+        /* FIXME: Should we disable ports not in the Extended Capabilities? */
+}
+
+/*
+ * Scan the Extended Capabilities for the "Supported Protocol Capabilities" that
+ * specify what speeds each port is supposed to be.  We can't count on the port
+ * speed bits in the PORTSC register being correct until a device is connected,
+ * but we need to set up the two fake roothubs with the correct number of USB
+ * 3.0 and USB 2.0 ports at host controller initialization time.
+ */
+static int xhci_setup_port_arrays(struct xhci_hcd *xhci, gfp_t flags)
+{
+        __le32 __iomem *addr;
+        u32 offset;
+        unsigned int num_ports;
+        int i, port_index;
+
+        addr = &xhci->cap_regs->hcc_params;
+        offset = XHCI_HCC_EXT_CAPS(xhci_readl(xhci, addr));
+        if (offset == 0) {
+                xhci_err(xhci, "No Extended Capability registers, "
+                                "unable to set up roothub.\n");
+                return -ENODEV;
+        }
+
+        num_ports = HCS_MAX_PORTS(xhci->hcs_params1);
+        xhci->port_array = kzalloc(sizeof(*xhci->port_array)*num_ports, flags);
+        if (!xhci->port_array)
+                return -ENOMEM;
+
+        /*
+         * For whatever reason, the first capability offset is from the
+         * capability register base, not from the HCCPARAMS register.
+         * See section 5.3.6 for offset calculation.
+         */
+        addr = &xhci->cap_regs->hc_capbase + offset;
+        while (1) {
+                u32 cap_id;
+
+                cap_id = xhci_readl(xhci, addr);
+                if (XHCI_EXT_CAPS_ID(cap_id) == XHCI_EXT_CAPS_PROTOCOL)
+                        xhci_add_in_port(xhci, num_ports, addr,
+                                        (u8) XHCI_EXT_PORT_MAJOR(cap_id));
+                offset = XHCI_EXT_CAPS_NEXT(cap_id);
+                if (!offset || (xhci->num_usb2_ports + xhci->num_usb3_ports)
+                                == num_ports)
+                        break;
+                /*
+                 * Once you're into the Extended Capabilities, the offset is
+                 * always relative to the register holding the offset.
+                 */
+                addr += offset;
+        }
+
+        if (xhci->num_usb2_ports == 0 && xhci->num_usb3_ports == 0) {
+                xhci_warn(xhci, "No ports on the roothubs?\n");
+                return -ENODEV;
+        }
+        xhci_dbg(xhci, "Found %u USB 2.0 ports and %u USB 3.0 ports.\n",
+                        xhci->num_usb2_ports, xhci->num_usb3_ports);
+
+        /* Place limits on the number of roothub ports so that the hub
+         * descriptors aren't longer than the USB core will allocate.
+         */
+        if (xhci->num_usb3_ports > 15) {
+                xhci_dbg(xhci, "Limiting USB 3.0 roothub ports to 15.\n");
+                xhci->num_usb3_ports = 15;
+        }
+        if (xhci->num_usb2_ports > USB_MAXCHILDREN) {
+                xhci_dbg(xhci, "Limiting USB 2.0 roothub ports to %u.\n",
+                                USB_MAXCHILDREN);
+                xhci->num_usb2_ports = USB_MAXCHILDREN;
+        }
+
+        /*
+         * Note we could have all USB 3.0 ports, or all USB 2.0 ports.
+         * Not sure how the USB core will handle a hub with no ports...
+         */
+        if (xhci->num_usb2_ports) {
+                xhci->usb2_ports = kmalloc(sizeof(*xhci->usb2_ports)*
+                                xhci->num_usb2_ports, flags);
+                if (!xhci->usb2_ports)
+                        return -ENOMEM;
+
+                port_index = 0;
+                for (i = 0; i < num_ports; i++) {
+                        if (xhci->port_array[i] == 0x03 ||
+                                        xhci->port_array[i] == 0 ||
+                                        xhci->port_array[i] == DUPLICATE_ENTRY)
+                                continue;
+
+                        xhci->usb2_ports[port_index] =
+                                &xhci->op_regs->port_status_base +
+                                NUM_PORT_REGS*i;
+                        xhci_dbg(xhci, "USB 2.0 port at index %u, "
+                                        "addr = %p\n", i,
+                                        xhci->usb2_ports[port_index]);
+                        port_index++;
+                        if (port_index == xhci->num_usb2_ports)
+                                break;
+                }
+        }
+        if (xhci->num_usb3_ports) {
+                xhci->usb3_ports = kmalloc(sizeof(*xhci->usb3_ports)*
+                                xhci->num_usb3_ports, flags);
+                if (!xhci->usb3_ports)
+                        return -ENOMEM;
+
+                port_index = 0;
+                for (i = 0; i < num_ports; i++)
+                        if (xhci->port_array[i] == 0x03) {
+                                xhci->usb3_ports[port_index] =
+                                        &xhci->op_regs->port_status_base +
+                                        NUM_PORT_REGS*i;
+                                xhci_dbg(xhci, "USB 3.0 port at index %u, "
+                                                "addr = %p\n", i,
+                                                xhci->usb3_ports[port_index]);
+                                port_index++;
+                                if (port_index == xhci->num_usb3_ports)
+                                        break;
+                        }
+        }
+        return 0;
+}
 
 int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
 {
@@ -1730,11 +2021,11 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
         val &= DBOFF_MASK;
         xhci_dbg(xhci, "// Doorbell array is located at offset 0x%x"
                         " from cap regs base addr\n", val);
-        xhci->dba = (void *) xhci->cap_regs + val;
+        xhci->dba = (void __iomem *) xhci->cap_regs + val;
         xhci_dbg_regs(xhci);
         xhci_print_run_regs(xhci);
         /* Set ir_set to interrupt register set 0 */
-        xhci->ir_set = (void *) xhci->run_regs->ir_set;
+        xhci->ir_set = &xhci->run_regs->ir_set[0];
 
         /*
          * Event ring setup: Allocate a normal ring, but also setup
@@ -1765,8 +2056,8 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
         /* set ring base address and size for each segment table entry */
         for (val = 0, seg = xhci->event_ring->first_seg; val < ERST_NUM_SEGS; val++) {
                 struct xhci_erst_entry *entry = &xhci->erst.entries[val];
-                entry->seg_addr = seg->dma;
-                entry->seg_size = TRBS_PER_SEGMENT;
+                entry->seg_addr = cpu_to_le64(seg->dma);
+                entry->seg_size = cpu_to_le32(TRBS_PER_SEGMENT);
                 entry->rsvd = 0;
                 seg = seg->next;
         }
@@ -1791,7 +2082,7 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
         /* Set the event ring dequeue address */
         xhci_set_hc_event_deq(xhci);
         xhci_dbg(xhci, "Wrote ERST address to ir_set 0.\n");
-        xhci_print_ir_set(xhci, xhci->ir_set, 0);
+        xhci_print_ir_set(xhci, 0);
 
         /*
          * XXX: Might need to set the Interrupter Moderation Register to
@@ -1801,9 +2092,15 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
         init_completion(&xhci->addr_dev);
         for (i = 0; i < MAX_HC_SLOTS; ++i)
                 xhci->devs[i] = NULL;
+        for (i = 0; i < USB_MAXCHILDREN; ++i) {
+                xhci->bus_state[0].resume_done[i] = 0;
+                xhci->bus_state[1].resume_done[i] = 0;
+        }
 
         if (scratchpad_alloc(xhci, flags))
                 goto fail;
+        if (xhci_setup_port_arrays(xhci, flags))
+                goto fail;
 
         return 0;
 
diff --git a/drivers/usb/host/xhci-pci.c b/drivers/usb/host/xhci-pci.c
index f7efe025beda..cb16de213f64 100644
--- a/drivers/usb/host/xhci-pci.c
+++ b/drivers/usb/host/xhci-pci.c
@@ -21,6 +21,7 @@
  */
 
 #include <linux/pci.h>
+#include <linux/slab.h>
 
 #include "xhci.h"
 
@@ -28,6 +29,9 @@
 #define PCI_VENDOR_ID_FRESCO_LOGIC      0x1b73
 #define PCI_DEVICE_ID_FRESCO_LOGIC_PDK  0x1000
 
+#define PCI_VENDOR_ID_ETRON             0x1b6f
+#define PCI_DEVICE_ID_ASROCK_P67        0x7023
+
 static const char hcd_name[] = "xhci_hcd";
 
 /* called after powerup, by probe or system-pm "wakeup" */
@@ -50,13 +54,45 @@ static int xhci_pci_reinit(struct xhci_hcd *xhci, struct pci_dev *pdev)
 /* called during probe() after chip reset completes */
 static int xhci_pci_setup(struct usb_hcd *hcd)
 {
-        struct xhci_hcd         *xhci = hcd_to_xhci(hcd);
+        struct xhci_hcd         *xhci;
         struct pci_dev          *pdev = to_pci_dev(hcd->self.controller);
         int                     retval;
         u32                     temp;
 
         hcd->self.sg_tablesize = TRBS_PER_SEGMENT - 2;
 
+        if (usb_hcd_is_primary_hcd(hcd)) {
+                xhci = kzalloc(sizeof(struct xhci_hcd), GFP_KERNEL);
+                if (!xhci)
+                        return -ENOMEM;
+                *((struct xhci_hcd **) hcd->hcd_priv) = xhci;
+                xhci->main_hcd = hcd;
+                /* Mark the first roothub as being USB 2.0.
+                 * The xHCI driver will register the USB 3.0 roothub.
+                 */
+                hcd->speed = HCD_USB2;
+                hcd->self.root_hub->speed = USB_SPEED_HIGH;
+                /*
+                 * USB 2.0 roothub under xHCI has an integrated TT,
+                 * (rate matching hub) as opposed to having an OHCI/UHCI
+                 * companion controller.
+                 */
+                hcd->has_tt = 1;
+        } else {
+                /* xHCI private pointer was set in xhci_pci_probe for the second
+                 * registered roothub.
+                 */
+                xhci = hcd_to_xhci(hcd);
+                temp = xhci_readl(xhci, &xhci->cap_regs->hcc_params);
+                if (HCC_64BIT_ADDR(temp)) {
+                        xhci_dbg(xhci, "Enabling 64-bit DMA addresses.\n");
+                        dma_set_mask(hcd->self.controller, DMA_BIT_MASK(64));
+                } else {
+                        dma_set_mask(hcd->self.controller, DMA_BIT_MASK(32));
+                }
+                return 0;
+        }
+
         xhci->cap_regs = hcd->regs;
         xhci->op_regs = hcd->regs +
                 HC_LENGTH(xhci_readl(xhci, &xhci->cap_regs->hc_capbase));
@@ -73,25 +109,50 @@ static int xhci_pci_setup(struct usb_hcd *hcd)
 
         /* Look for vendor-specific quirks */
         if (pdev->vendor == PCI_VENDOR_ID_FRESCO_LOGIC &&
-                        pdev->device == PCI_DEVICE_ID_FRESCO_LOGIC_PDK &&
-                        pdev->revision == 0x0) {
+                        pdev->device == PCI_DEVICE_ID_FRESCO_LOGIC_PDK) {
+                if (pdev->revision == 0x0) {
                         xhci->quirks |= XHCI_RESET_EP_QUIRK;
                         xhci_dbg(xhci, "QUIRK: Fresco Logic xHC needs configure"
                                         " endpoint cmd after reset endpoint\n");
+                }
+                /* Fresco Logic confirms: all revisions of this chip do not
+                 * support MSI, even though some of them claim to in their PCI
+                 * capabilities.
+                 */
+                xhci->quirks |= XHCI_BROKEN_MSI;
+                xhci_dbg(xhci, "QUIRK: Fresco Logic revision %u "
+                                "has broken MSI implementation\n",
+                                pdev->revision);
         }
+
         if (pdev->vendor == PCI_VENDOR_ID_NEC)
                 xhci->quirks |= XHCI_NEC_HOST;
 
+        /* AMD PLL quirk */
+        if (pdev->vendor == PCI_VENDOR_ID_AMD && usb_amd_find_chipset_info())
+                xhci->quirks |= XHCI_AMD_PLL_FIX;
+        if (pdev->vendor == PCI_VENDOR_ID_INTEL &&
+                        pdev->device == PCI_DEVICE_ID_INTEL_PANTHERPOINT_XHCI) {
+                xhci->quirks |= XHCI_SPURIOUS_SUCCESS;
+                xhci->quirks |= XHCI_EP_LIMIT_QUIRK;
+                xhci->limit_active_eps = 64;
+        }
+        if (pdev->vendor == PCI_VENDOR_ID_ETRON &&
+                        pdev->device == PCI_DEVICE_ID_ASROCK_P67) {
+                xhci->quirks |= XHCI_RESET_ON_RESUME;
+                xhci_dbg(xhci, "QUIRK: Resetting on resume\n");
+        }
+
         /* Make sure the HC is halted. */
         retval = xhci_halt(xhci);
         if (retval)
-                return retval;
+                goto error;
 
         xhci_dbg(xhci, "Resetting HCD\n");
         /* Reset the internal HC memory state and registers. */
         retval = xhci_reset(xhci);
         if (retval)
-                return retval;
+                goto error;
         xhci_dbg(xhci, "Reset complete\n");
 
         temp = xhci_readl(xhci, &xhci->cap_regs->hcc_params);
@@ -106,33 +167,152 @@ static int xhci_pci_setup(struct usb_hcd *hcd)
         /* Initialize HCD and host controller data structures. */
         retval = xhci_init(hcd);
         if (retval)
-                return retval;
+                goto error;
         xhci_dbg(xhci, "Called HCD init\n");
 
         pci_read_config_byte(pdev, XHCI_SBRN_OFFSET, &xhci->sbrn);
         xhci_dbg(xhci, "Got SBRN %u\n", (unsigned int) xhci->sbrn);
 
         /* Find any debug ports */
-        return xhci_pci_reinit(xhci, pdev);
+        retval = xhci_pci_reinit(xhci, pdev);
+        if (!retval)
+                return retval;
+
+error:
+        kfree(xhci);
+        return retval;
 }
 
+/*
+ * We need to register our own PCI probe function (instead of the USB core's
+ * function) in order to create a second roothub under xHCI.
+ */
+static int xhci_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
+{
+        int retval;
+        struct xhci_hcd *xhci;
+        struct hc_driver *driver;
+        struct usb_hcd *hcd;
+
+        driver = (struct hc_driver *)id->driver_data;
+        /* Register the USB 2.0 roothub.
+         * FIXME: USB core must know to register the USB 2.0 roothub first.
+         * This is sort of silly, because we could just set the HCD driver flags
+         * to say USB 2.0, but I'm not sure what the implications would be in
+         * the other parts of the HCD code.
+         */
+        retval = usb_hcd_pci_probe(dev, id);
+
+        if (retval)
+                return retval;
+
+        /* USB 2.0 roothub is stored in the PCI device now. */
+        hcd = dev_get_drvdata(&dev->dev);
+        xhci = hcd_to_xhci(hcd);
+        xhci->shared_hcd = usb_create_shared_hcd(driver, &dev->dev,
+                                pci_name(dev), hcd);
+        if (!xhci->shared_hcd) {
+                retval = -ENOMEM;
+                goto dealloc_usb2_hcd;
+        }
+
+        /* Set the xHCI pointer before xhci_pci_setup() (aka hcd_driver.reset)
+         * is called by usb_add_hcd().
+         */
+        *((struct xhci_hcd **) xhci->shared_hcd->hcd_priv) = xhci;
+
+        retval = usb_add_hcd(xhci->shared_hcd, dev->irq,
+                        IRQF_DISABLED | IRQF_SHARED);
+        if (retval)
+                goto put_usb3_hcd;
+        /* Roothub already marked as USB 3.0 speed */
+        return 0;
+
+put_usb3_hcd:
+        usb_put_hcd(xhci->shared_hcd);
+dealloc_usb2_hcd:
+        usb_hcd_pci_remove(dev);
+        return retval;
+}
+
+static void xhci_pci_remove(struct pci_dev *dev)
+{
+        struct xhci_hcd *xhci;
+
+        xhci = hcd_to_xhci(pci_get_drvdata(dev));
+        if (xhci->shared_hcd) {
+                usb_remove_hcd(xhci->shared_hcd);
+                usb_put_hcd(xhci->shared_hcd);
+        }
+        usb_hcd_pci_remove(dev);
+        kfree(xhci);
+}
+
+#ifdef CONFIG_PM
+static int xhci_pci_suspend(struct usb_hcd *hcd, bool do_wakeup)
+{
+        struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+        int     retval = 0;
+
+        if (hcd->state != HC_STATE_SUSPENDED ||
+                        xhci->shared_hcd->state != HC_STATE_SUSPENDED)
+                return -EINVAL;
+
+        retval = xhci_suspend(xhci);
+
+        return retval;
+}
+
+static int xhci_pci_resume(struct usb_hcd *hcd, bool hibernated)
+{
+        struct xhci_hcd         *xhci = hcd_to_xhci(hcd);
+        struct pci_dev          *pdev = to_pci_dev(hcd->self.controller);
+        int                     retval = 0;
+
+        /* The BIOS on systems with the Intel Panther Point chipset may or may
+         * not support xHCI natively.  That means that during system resume, it
+         * may switch the ports back to EHCI so that users can use their
+         * keyboard to select a kernel from GRUB after resume from hibernate.
+         *
+         * The BIOS is supposed to remember whether the OS had xHCI ports
+         * enabled before resume, and switch the ports back to xHCI when the
+         * BIOS/OS semaphore is written, but we all know we can't trust BIOS
+         * writers.
+         *
+         * Unconditionally switch the ports back to xHCI after a system resume.
+         * We can't tell whether the EHCI or xHCI controller will be resumed
+         * first, so we have to do the port switchover in both drivers.  Writing
+         * a '1' to the port switchover registers should have no effect if the
+         * port was already switched over.
+         */
+        if (usb_is_intel_switchable_xhci(pdev))
+                usb_enable_xhci_ports(pdev);
+
+        retval = xhci_resume(xhci, hibernated);
+        return retval;
+}
+#endif /* CONFIG_PM */
+
 static const struct hc_driver xhci_pci_hc_driver = {
         .description =          hcd_name,
         .product_desc =         "xHCI Host Controller",
-        .hcd_priv_size =        sizeof(struct xhci_hcd),
+        .hcd_priv_size =        sizeof(struct xhci_hcd *),
 
         /*
          * generic hardware linkage
          */
         .irq =                  xhci_irq,
-        .flags =                HCD_MEMORY | HCD_USB3,
+        .flags =                HCD_MEMORY | HCD_USB3 | HCD_SHARED,
 
         /*
          * basic lifecycle operations
          */
         .reset =                xhci_pci_setup,
         .start =                xhci_run,
-        /* suspend and resume implemented later */
+#ifdef CONFIG_PM
+        .pci_suspend =          xhci_pci_suspend,
+        .pci_resume =           xhci_pci_resume,
+#endif
         .stop =                 xhci_stop,
         .shutdown =             xhci_shutdown,
 
@@ -152,7 +332,7 @@ static const struct hc_driver xhci_pci_hc_driver = {
         .reset_bandwidth =      xhci_reset_bandwidth,
         .address_device =       xhci_address_device,
         .update_hub_device =    xhci_update_hub_device,
-        .reset_device =         xhci_reset_device,
+        .reset_device =         xhci_discover_or_reset_device,
 
         /*
          * scheduling support
@@ -162,6 +342,8 @@ static const struct hc_driver xhci_pci_hc_driver = {
         /* Root hub support */
         .hub_control =          xhci_hub_control,
         .hub_status_data =      xhci_hub_status_data,
+        .bus_suspend =          xhci_bus_suspend,
+        .bus_resume =           xhci_bus_resume,
 };
 
 /*-------------------------------------------------------------------------*/
@@ -181,11 +363,16 @@ static struct pci_driver xhci_pci_driver = {
         .name =         (char *) hcd_name,
         .id_table =     pci_ids,
 
-        .probe =        usb_hcd_pci_probe,
-        .remove =       usb_hcd_pci_remove,
+        .probe =        xhci_pci_probe,
+        .remove =       xhci_pci_remove,
         /* suspend and resume implemented later */
 
         .shutdown =     usb_hcd_pci_shutdown,
+#ifdef CONFIG_PM_SLEEP
+        .driver = {
+                .pm = &usb_hcd_pci_pm_ops
+        },
+#endif
 };
 
 int xhci_register_pci(void)
diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c
index 48e60d166ff0..70cacbbe7fb9 100644
--- a/drivers/usb/host/xhci-ring.c
+++ b/drivers/usb/host/xhci-ring.c
@@ -68,6 +68,10 @@
 #include <linux/slab.h>
 #include "xhci.h"
 
+static int handle_cmd_in_cmd_wait_list(struct xhci_hcd *xhci,
+                struct xhci_virt_device *virt_dev,
+                struct xhci_event_cmd *event);
+
 /*
  * Returns zero if the TRB isn't in this segment, otherwise it returns the DMA
  * address of the TRB.
@@ -89,33 +93,35 @@ dma_addr_t xhci_trb_virt_to_dma(struct xhci_segment *seg,
 /* Does this link TRB point to the first segment in a ring,
  * or was the previous TRB the last TRB on the last segment in the ERST?
  */
-static inline bool last_trb_on_last_seg(struct xhci_hcd *xhci, struct xhci_ring *ring,
+static bool last_trb_on_last_seg(struct xhci_hcd *xhci, struct xhci_ring *ring,
                 struct xhci_segment *seg, union xhci_trb *trb)
 {
         if (ring == xhci->event_ring)
                 return (trb == &seg->trbs[TRBS_PER_SEGMENT]) &&
                         (seg->next == xhci->event_ring->first_seg);
         else
-                return trb->link.control & LINK_TOGGLE;
+                return le32_to_cpu(trb->link.control) & LINK_TOGGLE;
 }
 
 /* Is this TRB a link TRB or was the last TRB the last TRB in this event ring
  * segment?  I.e. would the updated event TRB pointer step off the end of the
  * event seg?
  */
-static inline int last_trb(struct xhci_hcd *xhci, struct xhci_ring *ring,
+static int last_trb(struct xhci_hcd *xhci, struct xhci_ring *ring,
                 struct xhci_segment *seg, union xhci_trb *trb)
 {
         if (ring == xhci->event_ring)
                 return trb == &seg->trbs[TRBS_PER_SEGMENT];
         else
-                return (trb->link.control & TRB_TYPE_BITMASK) == TRB_TYPE(TRB_LINK);
+                return (le32_to_cpu(trb->link.control) & TRB_TYPE_BITMASK)
+                        == TRB_TYPE(TRB_LINK);
 }
 
-static inline int enqueue_is_link_trb(struct xhci_ring *ring)
+static int enqueue_is_link_trb(struct xhci_ring *ring)
 {
         struct xhci_link_trb *link = &ring->enqueue->link;
-        return ((link->control & TRB_TYPE_BITMASK) == TRB_TYPE(TRB_LINK));
+        return ((le32_to_cpu(link->control) & TRB_TYPE_BITMASK) ==
+                TRB_TYPE(TRB_LINK));
 }
 
 /* Updates trb to point to the next TRB in the ring, and updates seg if the next
@@ -161,12 +167,6 @@ static void inc_deq(struct xhci_hcd *xhci, struct xhci_ring *ring, bool consumer
                 next = ring->dequeue;
         }
         addr = (unsigned long long) xhci_trb_virt_to_dma(ring->deq_seg, ring->dequeue);
-        if (ring == xhci->event_ring)
-                xhci_dbg(xhci, "Event ring deq = 0x%llx (DMA)\n", addr);
-        else if (ring == xhci->cmd_ring)
-                xhci_dbg(xhci, "Command ring deq = 0x%llx (DMA)\n", addr);
-        else
-                xhci_dbg(xhci, "Ring deq = 0x%llx (DMA)\n", addr);
 }
 
 /*
@@ -193,7 +193,7 @@ static void inc_enq(struct xhci_hcd *xhci, struct xhci_ring *ring,
         union xhci_trb *next;
         unsigned long long addr;
 
-        chain = ring->enqueue->generic.field[3] & TRB_CHAIN;
+        chain = le32_to_cpu(ring->enqueue->generic.field[3]) & TRB_CHAIN;
         next = ++(ring->enqueue);
 
         ring->enq_updates++;
@@ -219,12 +219,14 @@ static void inc_enq(struct xhci_hcd *xhci, struct xhci_ring *ring,
                                  * (which may mean the chain bit is cleared).
                                  */
                                 if (!xhci_link_trb_quirk(xhci)) {
-                                        next->link.control &= ~TRB_CHAIN;
-                                        next->link.control |= chain;
+                                        next->link.control &=
+                                                cpu_to_le32(~TRB_CHAIN);
+                                        next->link.control |=
+                                                cpu_to_le32(chain);
                                 }
                                 /* Give this link TRB to the hardware */
                                 wmb();
-                                next->link.control ^= TRB_CYCLE;
+                                next->link.control ^= cpu_to_le32(TRB_CYCLE);
                         }
                         /* Toggle the cycle bit after the last ring segment. */
                         if (last_trb_on_last_seg(xhci, ring, ring->enq_seg, next)) {
@@ -240,12 +242,6 @@ static void inc_enq(struct xhci_hcd *xhci, struct xhci_ring *ring,
                 next = ring->enqueue;
         }
         addr = (unsigned long long) xhci_trb_virt_to_dma(ring->enq_seg, ring->enqueue);
-        if (ring == xhci->event_ring)
-                xhci_dbg(xhci, "Event ring enq = 0x%llx (DMA)\n", addr);
-        else if (ring == xhci->cmd_ring)
-                xhci_dbg(xhci, "Command ring enq = 0x%llx (DMA)\n", addr);
-        else
-                xhci_dbg(xhci, "Ring enq = 0x%llx (DMA)\n", addr);
 }
 
 /*
@@ -304,40 +300,35 @@ static int room_on_ring(struct xhci_hcd *xhci, struct xhci_ring *ring,
 /* Ring the host controller doorbell after placing a command on the ring */
 void xhci_ring_cmd_db(struct xhci_hcd *xhci)
 {
-        u32 temp;
-
         xhci_dbg(xhci, "// Ding dong!\n");
-        temp = xhci_readl(xhci, &xhci->dba->doorbell[0]) & DB_MASK;
-        xhci_writel(xhci, temp | DB_TARGET_HOST, &xhci->dba->doorbell[0]);
+        xhci_writel(xhci, DB_VALUE_HOST, &xhci->dba->doorbell[0]);
         /* Flush PCI posted writes */
         xhci_readl(xhci, &xhci->dba->doorbell[0]);
 }
 
-static void ring_ep_doorbell(struct xhci_hcd *xhci,
+void xhci_ring_ep_doorbell(struct xhci_hcd *xhci,
                 unsigned int slot_id,
                 unsigned int ep_index,
                 unsigned int stream_id)
 {
-        struct xhci_virt_ep *ep;
-        unsigned int ep_state;
-        u32 field;
-        __u32 __iomem *db_addr = &xhci->dba->doorbell[slot_id];
+        __le32 __iomem *db_addr = &xhci->dba->doorbell[slot_id];
+        struct xhci_virt_ep *ep = &xhci->devs[slot_id]->eps[ep_index];
+        unsigned int ep_state = ep->ep_state;
 
-        ep = &xhci->devs[slot_id]->eps[ep_index];
-        ep_state = ep->ep_state;
         /* Don't ring the doorbell for this endpoint if there are pending
-         * cancellations because the we don't want to interrupt processing.
+         * cancellations because we don't want to interrupt processing.
          * We don't want to restart any stream rings if there's a set dequeue
          * pointer command pending because the device can choose to start any
          * stream once the endpoint is on the HW schedule.
          * FIXME - check all the stream rings for pending cancellations.
          */
-        if (!(ep_state & EP_HALT_PENDING) && !(ep_state & SET_DEQ_PENDING)
-                        && !(ep_state & EP_HALTED)) {
-                field = xhci_readl(xhci, db_addr) & DB_MASK;
-                field |= EPI_TO_DB(ep_index) | STREAM_ID_TO_DB(stream_id);
-                xhci_writel(xhci, field, db_addr);
-        }
+        if ((ep_state & EP_HALT_PENDING) || (ep_state & SET_DEQ_PENDING) ||
+            (ep_state & EP_HALTED))
+                return;
+        xhci_writel(xhci, DB_VALUE(ep_index, stream_id), db_addr);
+        /* The CPU has better things to do at this point than wait for a
+         * write-posting flush.  It'll get there soon enough.
+         */
 }
 
 /* Ring the doorbell for any rings with pending URBs */
@@ -353,7 +344,7 @@ static void ring_doorbell_for_active_rings(struct xhci_hcd *xhci,
         /* A ring has pending URBs if its TD list is not empty */
         if (!(ep->ep_state & EP_HAS_STREAMS)) {
                 if (!(list_empty(&ep->ring->td_list)))
-                        ring_ep_doorbell(xhci, slot_id, ep_index, 0);
+                        xhci_ring_ep_doorbell(xhci, slot_id, ep_index, 0);
                 return;
         }
 
@@ -361,7 +352,8 @@ static void ring_doorbell_for_active_rings(struct xhci_hcd *xhci,
                         stream_id++) {
                 struct xhci_stream_info *stream_info = ep->stream_info;
                 if (!list_empty(&stream_info->stream_rings[stream_id]->td_list))
-                        ring_ep_doorbell(xhci, slot_id, ep_index, stream_id);
+                        xhci_ring_ep_doorbell(xhci, slot_id, ep_index,
+                                                stream_id);
         }
 }
 
@@ -380,10 +372,8 @@ static struct xhci_segment *find_trb_seg(
         while (cur_seg->trbs > trb ||
                         &cur_seg->trbs[TRBS_PER_SEGMENT - 1] < trb) {
                 generic_trb = &cur_seg->trbs[TRBS_PER_SEGMENT - 1].generic;
-                if ((generic_trb->field[3] & TRB_TYPE_BITMASK) ==
-                                TRB_TYPE(TRB_LINK) &&
-                                (generic_trb->field[3] & LINK_TOGGLE))
-                        *cycle_state = ~(*cycle_state) & 0x1;
+                if (le32_to_cpu(generic_trb->field[3]) & LINK_TOGGLE)
+                        *cycle_state ^= 0x1;
                 cur_seg = cur_seg->next;
                 if (cur_seg == start_seg)
                         /* Looped over the entire list.  Oops! */
@@ -449,6 +439,10 @@ static struct xhci_ring *xhci_urb_to_transfer_ring(struct xhci_hcd *xhci,
  *    any link TRBs with the toggle cycle bit set.
  *  - Finally we move the dequeue state one TRB further, toggling the cycle bit
  *    if we've moved it past a link TRB with the toggle cycle bit set.
+ *
+ * Some of the uses of xhci_generic_trb are grotty, but if they're done
+ * with correct __le32 accesses they should work fine.  Only users of this are
+ * in here.
  */
 void xhci_find_new_dequeue_state(struct xhci_hcd *xhci,
                 unsigned int slot_id, unsigned int ep_index,
@@ -474,36 +468,52 @@ void xhci_find_new_dequeue_state(struct xhci_hcd *xhci,
         state->new_deq_seg = find_trb_seg(cur_td->start_seg,
                         dev->eps[ep_index].stopped_trb,
                         &state->new_cycle_state);
-        if (!state->new_deq_seg)
-                BUG();
+        if (!state->new_deq_seg) {
+                WARN_ON(1);
+                return;
+        }
+
         /* Dig out the cycle state saved by the xHC during the stop ep cmd */
         xhci_dbg(xhci, "Finding endpoint context\n");
         ep_ctx = xhci_get_ep_ctx(xhci, dev->out_ctx, ep_index);
-        state->new_cycle_state = 0x1 & ep_ctx->deq;
+        state->new_cycle_state = 0x1 & le64_to_cpu(ep_ctx->deq);
 
         state->new_deq_ptr = cur_td->last_trb;
         xhci_dbg(xhci, "Finding segment containing last TRB in TD.\n");
         state->new_deq_seg = find_trb_seg(state->new_deq_seg,
                         state->new_deq_ptr,
                         &state->new_cycle_state);
-        if (!state->new_deq_seg)
-                BUG();
+        if (!state->new_deq_seg) {
+                WARN_ON(1);
+                return;
+        }
 
         trb = &state->new_deq_ptr->generic;
-        if ((trb->field[3] & TRB_TYPE_BITMASK) == TRB_TYPE(TRB_LINK) &&
-                                (trb->field[3] & LINK_TOGGLE))
-                state->new_cycle_state = ~(state->new_cycle_state) & 0x1;
+        if ((le32_to_cpu(trb->field[3]) & TRB_TYPE_BITMASK) ==
+            TRB_TYPE(TRB_LINK) && (le32_to_cpu(trb->field[3]) & LINK_TOGGLE))
+                state->new_cycle_state ^= 0x1;
         next_trb(xhci, ep_ring, &state->new_deq_seg, &state->new_deq_ptr);
 
+        /*
+         * If there is only one segment in a ring, find_trb_seg()'s while loop
+         * will not run, and it will return before it has a chance to see if it
+         * needs to toggle the cycle bit.  It can't tell if the stalled transfer
+         * ended just before the link TRB on a one-segment ring, or if the TD
+         * wrapped around the top of the ring, because it doesn't have the TD in
+         * question.  Look for the one-segment case where stalled TRB's address
+         * is greater than the new dequeue pointer address.
+         */
+        if (ep_ring->first_seg == ep_ring->first_seg->next &&
+                        state->new_deq_ptr < dev->eps[ep_index].stopped_trb)
+                state->new_cycle_state ^= 0x1;
+        xhci_dbg(xhci, "Cycle state = 0x%x\n", state->new_cycle_state);
+
         /* Don't update the ring cycle state for the producer (us). */
         xhci_dbg(xhci, "New dequeue segment = %p (virtual)\n",
                         state->new_deq_seg);
         addr = xhci_trb_virt_to_dma(state->new_deq_seg, state->new_deq_ptr);
         xhci_dbg(xhci, "New dequeue pointer = 0x%llx (DMA)\n",
                         (unsigned long long) addr);
-        xhci_dbg(xhci, "Setting dequeue pointer in internal ring state.\n");
-        ep_ring->dequeue = state->new_deq_ptr;
-        ep_ring->deq_seg = state->new_deq_seg;
 }
 
 static void td_to_noop(struct xhci_hcd *xhci, struct xhci_ring *ep_ring,
@@ -515,12 +525,12 @@ static void td_to_noop(struct xhci_hcd *xhci, struct xhci_ring *ep_ring,
         for (cur_seg = cur_td->start_seg, cur_trb = cur_td->first_trb;
                         true;
                         next_trb(xhci, ep_ring, &cur_seg, &cur_trb)) {
-                if ((cur_trb->generic.field[3] & TRB_TYPE_BITMASK) ==
-                                TRB_TYPE(TRB_LINK)) {
+                if ((le32_to_cpu(cur_trb->generic.field[3]) & TRB_TYPE_BITMASK)
+                    == TRB_TYPE(TRB_LINK)) {
                         /* Unchain any chained Link TRBs, but
                          * leave the pointers intact.
                          */
-                        cur_trb->generic.field[3] &= ~TRB_CHAIN;
+                        cur_trb->generic.field[3] &= cpu_to_le32(~TRB_CHAIN);
                         xhci_dbg(xhci, "Cancel (unchain) link TRB\n");
                         xhci_dbg(xhci, "Address = %p (0x%llx dma); "
                                         "in seg %p (0x%llx dma)\n",
@@ -533,8 +543,9 @@ static void td_to_noop(struct xhci_hcd *xhci, struct xhci_ring *ep_ring,
                         cur_trb->generic.field[1] = 0;
                         cur_trb->generic.field[2] = 0;
                         /* Preserve only the cycle bit of this TRB */
-                        cur_trb->generic.field[3] &= TRB_CYCLE;
-                        cur_trb->generic.field[3] |= TRB_TYPE(TRB_TR_NOOP);
+                        cur_trb->generic.field[3] &= cpu_to_le32(TRB_CYCLE);
+                        cur_trb->generic.field[3] |= cpu_to_le32(
+                                TRB_TYPE(TRB_TR_NOOP));
                         xhci_dbg(xhci, "Cancel TRB %p (0x%llx dma) "
                                         "in seg %p (0x%llx dma)\n",
                                         cur_trb,
@@ -578,7 +589,7 @@ void xhci_queue_new_dequeue_state(struct xhci_hcd *xhci,
         ep->ep_state |= SET_DEQ_PENDING;
 }
 
-static inline void xhci_stop_watchdog_timer_in_irq(struct xhci_hcd *xhci,
+static void xhci_stop_watchdog_timer_in_irq(struct xhci_hcd *xhci,
                 struct xhci_virt_ep *ep)
 {
         ep->ep_state &= ~EP_HALT_PENDING;
@@ -594,24 +605,30 @@ static inline void xhci_stop_watchdog_timer_in_irq(struct xhci_hcd *xhci,
 static void xhci_giveback_urb_in_irq(struct xhci_hcd *xhci,
                 struct xhci_td *cur_td, int status, char *adjective)
 {
-        struct usb_hcd *hcd = xhci_to_hcd(xhci);
+        struct usb_hcd *hcd;
         struct urb      *urb;
         struct urb_priv *urb_priv;
 
         urb = cur_td->urb;
         urb_priv = urb->hcpriv;
         urb_priv->td_cnt++;
+        hcd = bus_to_hcd(urb->dev->bus);
 
         /* Only giveback urb when this is the last td in urb */
         if (urb_priv->td_cnt == urb_priv->length) {
+                if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) {
+                        xhci_to_hcd(xhci)->self.bandwidth_isoc_reqs--;
+                        if (xhci_to_hcd(xhci)->self.bandwidth_isoc_reqs == 0) {
+                                if (xhci->quirks & XHCI_AMD_PLL_FIX)
+                                        usb_amd_quirk_pll_enable();
+                        }
+                }
                 usb_hcd_unlink_urb_from_ep(hcd, urb);
-                xhci_dbg(xhci, "Giveback %s URB %p\n", adjective, urb);
 
                 spin_unlock(&xhci->lock);
                 usb_hcd_giveback_urb(hcd, urb, status);
                 xhci_urb_free_priv(xhci, urb_priv);
                 spin_lock(&xhci->lock);
-                xhci_dbg(xhci, "%s URB given back\n", adjective);
         }
 }
 
@@ -626,10 +643,11 @@ static void xhci_giveback_urb_in_irq(struct xhci_hcd *xhci,
  *     bit cleared) so that the HW will skip over them.
  */
 static void handle_stopped_endpoint(struct xhci_hcd *xhci,
-                union xhci_trb *trb)
+                union xhci_trb *trb, struct xhci_event_cmd *event)
 {
         unsigned int slot_id;
         unsigned int ep_index;
+        struct xhci_virt_device *virt_dev;
         struct xhci_ring *ep_ring;
         struct xhci_virt_ep *ep;
         struct list_head *entry;
@@ -638,13 +656,30 @@ static void handle_stopped_endpoint(struct xhci_hcd *xhci,
 
         struct xhci_dequeue_state deq_state;
 
+        if (unlikely(TRB_TO_SUSPEND_PORT(
+                             le32_to_cpu(xhci->cmd_ring->dequeue->generic.field[3])))) {
+                slot_id = TRB_TO_SLOT_ID(
+                        le32_to_cpu(xhci->cmd_ring->dequeue->generic.field[3]));
+                virt_dev = xhci->devs[slot_id];
+                if (virt_dev)
+                        handle_cmd_in_cmd_wait_list(xhci, virt_dev,
+                                event);
+                else
+                        xhci_warn(xhci, "Stop endpoint command "
+                                "completion for disabled slot %u\n",
+                                slot_id);
+                return;
+        }
+
         memset(&deq_state, 0, sizeof(deq_state));
-        slot_id = TRB_TO_SLOT_ID(trb->generic.field[3]);
-        ep_index = TRB_TO_EP_INDEX(trb->generic.field[3]);
+        slot_id = TRB_TO_SLOT_ID(le32_to_cpu(trb->generic.field[3]));
+        ep_index = TRB_TO_EP_INDEX(le32_to_cpu(trb->generic.field[3]));
         ep = &xhci->devs[slot_id]->eps[ep_index];
 
         if (list_empty(&ep->cancelled_td_list)) {
                 xhci_stop_watchdog_timer_in_irq(xhci, ep);
+                ep->stopped_td = NULL;
+                ep->stopped_trb = NULL;
                 ring_doorbell_for_active_rings(xhci, slot_id, ep_index);
                 return;
         }
@@ -803,8 +838,7 @@ void xhci_stop_endpoint_command_watchdog(unsigned long arg)
         if (ret < 0) {
                 /* This is bad; the host is not responding to commands and it's
                  * not allowing itself to be halted.  At least interrupts are
-                 * disabled, so we can set HC_STATE_HALT and notify the
-                 * USB core.  But if we call usb_hc_died(), it will attempt to
+                 * disabled. If we call usb_hc_died(), it will attempt to
                  * disconnect all device drivers under this host.  Those
                  * disconnect() methods will wait for all URBs to be unlinked,
                  * so we must complete them.
@@ -849,9 +883,8 @@ void xhci_stop_endpoint_command_watchdog(unsigned long arg)
                 }
         }
         spin_unlock(&xhci->lock);
-        xhci_to_hcd(xhci)->state = HC_STATE_HALT;
         xhci_dbg(xhci, "Calling usb_hc_died()\n");
-        usb_hc_died(xhci_to_hcd(xhci));
+        usb_hc_died(xhci_to_hcd(xhci)->primary_hcd);
         xhci_dbg(xhci, "xHCI host controller is dead.\n");
 }
 
@@ -874,9 +907,9 @@ static void handle_set_deq_completion(struct xhci_hcd *xhci,
         struct xhci_ep_ctx *ep_ctx;
         struct xhci_slot_ctx *slot_ctx;
 
-        slot_id = TRB_TO_SLOT_ID(trb->generic.field[3]);
-        ep_index = TRB_TO_EP_INDEX(trb->generic.field[3]);
-        stream_id = TRB_TO_STREAM_ID(trb->generic.field[2]);
+        slot_id = TRB_TO_SLOT_ID(le32_to_cpu(trb->generic.field[3]));
+        ep_index = TRB_TO_EP_INDEX(le32_to_cpu(trb->generic.field[3]));
+        stream_id = TRB_TO_STREAM_ID(le32_to_cpu(trb->generic.field[2]));
         dev = xhci->devs[slot_id];
 
         ep_ring = xhci_stream_id_to_ring(dev, ep_index, stream_id);
@@ -892,11 +925,11 @@ static void handle_set_deq_completion(struct xhci_hcd *xhci,
         ep_ctx = xhci_get_ep_ctx(xhci, dev->out_ctx, ep_index);
         slot_ctx = xhci_get_slot_ctx(xhci, dev->out_ctx);
 
-        if (GET_COMP_CODE(event->status) != COMP_SUCCESS) {
+        if (GET_COMP_CODE(le32_to_cpu(event->status)) != COMP_SUCCESS) {
                 unsigned int ep_state;
                 unsigned int slot_state;
 
-                switch (GET_COMP_CODE(event->status)) {
+                switch (GET_COMP_CODE(le32_to_cpu(event->status))) {
                 case COMP_TRB_ERR:
                         xhci_warn(xhci, "WARN Set TR Deq Ptr cmd invalid because "
                                         "of stream ID configuration\n");
@@ -904,9 +937,9 @@ static void handle_set_deq_completion(struct xhci_hcd *xhci,
                 case COMP_CTX_STATE:
                         xhci_warn(xhci, "WARN Set TR Deq Ptr cmd failed due "
                                         "to incorrect slot or ep state.\n");
-                        ep_state = ep_ctx->ep_info;
+                        ep_state = le32_to_cpu(ep_ctx->ep_info);
                         ep_state &= EP_STATE_MASK;
-                        slot_state = slot_ctx->dev_state;
+                        slot_state = le32_to_cpu(slot_ctx->dev_state);
                         slot_state = GET_SLOT_STATE(slot_state);
                         xhci_dbg(xhci, "Slot state = %u, EP state = %u\n",
                                         slot_state, ep_state);
@@ -918,7 +951,7 @@ static void handle_set_deq_completion(struct xhci_hcd *xhci,
                 default:
                         xhci_warn(xhci, "WARN Set TR Deq Ptr cmd with unknown "
                                         "completion code of %u.\n",
-                                        GET_COMP_CODE(event->status));
+                                  GET_COMP_CODE(le32_to_cpu(event->status)));
                         break;
                 }
                 /* OK what do we do now?  The endpoint state is hosed, and we
@@ -929,10 +962,27 @@ static void handle_set_deq_completion(struct xhci_hcd *xhci,
                  */
         } else {
                 xhci_dbg(xhci, "Successful Set TR Deq Ptr cmd, deq = @%08llx\n",
-                                ep_ctx->deq);
+                         le64_to_cpu(ep_ctx->deq));
+                if (xhci_trb_virt_to_dma(dev->eps[ep_index].queued_deq_seg,
+                                         dev->eps[ep_index].queued_deq_ptr) ==
+                    (le64_to_cpu(ep_ctx->deq) & ~(EP_CTX_CYCLE_MASK))) {
+                        /* Update the ring's dequeue segment and dequeue pointer
+                         * to reflect the new position.
+                         */
+                        ep_ring->deq_seg = dev->eps[ep_index].queued_deq_seg;
+                        ep_ring->dequeue = dev->eps[ep_index].queued_deq_ptr;
+                } else {
+                        xhci_warn(xhci, "Mismatch between completed Set TR Deq "
+                                        "Ptr command & xHCI internal state.\n");
+                        xhci_warn(xhci, "ep deq seg = %p, deq ptr = %p\n",
+                                        dev->eps[ep_index].queued_deq_seg,
+                                        dev->eps[ep_index].queued_deq_ptr);
+                }
         }
 
         dev->eps[ep_index].ep_state &= ~SET_DEQ_PENDING;
+        dev->eps[ep_index].queued_deq_seg = NULL;
+        dev->eps[ep_index].queued_deq_ptr = NULL;
         /* Restart any rings with pending URBs */
         ring_doorbell_for_active_rings(xhci, slot_id, ep_index);
 }
@@ -944,13 +994,13 @@ static void handle_reset_ep_completion(struct xhci_hcd *xhci,
         int slot_id;
         unsigned int ep_index;
 
-        slot_id = TRB_TO_SLOT_ID(trb->generic.field[3]);
-        ep_index = TRB_TO_EP_INDEX(trb->generic.field[3]);
+        slot_id = TRB_TO_SLOT_ID(le32_to_cpu(trb->generic.field[3]));
+        ep_index = TRB_TO_EP_INDEX(le32_to_cpu(trb->generic.field[3]));
         /* This command will only fail if the endpoint wasn't halted,
          * but we don't care.
          */
         xhci_dbg(xhci, "Ignoring reset ep completion code of %u\n",
-                        (unsigned int) GET_COMP_CODE(event->status));
+                 (unsigned int) GET_COMP_CODE(le32_to_cpu(event->status)));
 
         /* HW with the reset endpoint quirk needs to have a configure endpoint
          * command complete before the endpoint can be used.  Queue that here
@@ -987,8 +1037,7 @@ static int handle_cmd_in_cmd_wait_list(struct xhci_hcd *xhci,
         if (xhci->cmd_ring->dequeue != command->command_trb)
                 return 0;
 
-        command->status =
-                GET_COMP_CODE(event->status);
+        command->status = GET_COMP_CODE(le32_to_cpu(event->status));
         list_del(&command->cmd_list);
         if (command->completion)
                 complete(command->completion);
@@ -1000,7 +1049,7 @@ static int handle_cmd_in_cmd_wait_list(struct xhci_hcd *xhci,
 static void handle_cmd_completion(struct xhci_hcd *xhci,
                 struct xhci_event_cmd *event)
 {
-        int slot_id = TRB_TO_SLOT_ID(event->flags);
+        int slot_id = TRB_TO_SLOT_ID(le32_to_cpu(event->flags));
         u64 cmd_dma;
         dma_addr_t cmd_dequeue_dma;
         struct xhci_input_control_ctx *ctrl_ctx;
@@ -1009,7 +1058,7 @@ static void handle_cmd_completion(struct xhci_hcd *xhci,
         struct xhci_ring *ep_ring;
         unsigned int ep_state;
 
-        cmd_dma = event->cmd_trb;
+        cmd_dma = le64_to_cpu(event->cmd_trb);
         cmd_dequeue_dma = xhci_trb_virt_to_dma(xhci->cmd_ring->deq_seg,
                         xhci->cmd_ring->dequeue);
         /* Is the command ring deq ptr out of sync with the deq seg ptr? */
@@ -1022,17 +1071,23 @@ static void handle_cmd_completion(struct xhci_hcd *xhci,
                 xhci->error_bitmask |= 1 << 5;
                 return;
         }
-        switch (xhci->cmd_ring->dequeue->generic.field[3] & TRB_TYPE_BITMASK) {
+        switch (le32_to_cpu(xhci->cmd_ring->dequeue->generic.field[3])
+                & TRB_TYPE_BITMASK) {
         case TRB_TYPE(TRB_ENABLE_SLOT):
-                if (GET_COMP_CODE(event->status) == COMP_SUCCESS)
+                if (GET_COMP_CODE(le32_to_cpu(event->status)) == COMP_SUCCESS)
                         xhci->slot_id = slot_id;
                 else
                         xhci->slot_id = 0;
                 complete(&xhci->addr_dev);
                 break;
         case TRB_TYPE(TRB_DISABLE_SLOT):
-                if (xhci->devs[slot_id])
+                if (xhci->devs[slot_id]) {
+                        if (xhci->quirks & XHCI_EP_LIMIT_QUIRK)
+                                /* Delete default control endpoint resources */
+                                xhci_free_device_endpoint_resources(xhci,
+                                                xhci->devs[slot_id], true);
                         xhci_free_virt_device(xhci, slot_id);
+                }
                 break;
         case TRB_TYPE(TRB_CONFIG_EP):
                 virt_dev = xhci->devs[slot_id];
@@ -1049,7 +1104,7 @@ static void handle_cmd_completion(struct xhci_hcd *xhci,
                 ctrl_ctx = xhci_get_input_control_ctx(xhci,
                                 virt_dev->in_ctx);
                 /* Input ctx add_flags are the endpoint index plus one */
-                ep_index = xhci_last_valid_endpoint(ctrl_ctx->add_flags) - 1;
+                ep_index = xhci_last_valid_endpoint(le32_to_cpu(ctrl_ctx->add_flags)) - 1;
                 /* A usb_set_interface() call directly after clearing a halted
                  * condition may race on this quirky hardware.  Not worth
                  * worrying about, since this is prototype hardware.  Not sure
@@ -1058,8 +1113,8 @@ static void handle_cmd_completion(struct xhci_hcd *xhci,
                  */
                 if (xhci->quirks & XHCI_RESET_EP_QUIRK &&
                                 ep_index != (unsigned int) -1 &&
-                                ctrl_ctx->add_flags - SLOT_FLAG ==
-                                        ctrl_ctx->drop_flags) {
+                    le32_to_cpu(ctrl_ctx->add_flags) - SLOT_FLAG ==
+                    le32_to_cpu(ctrl_ctx->drop_flags)) {
                         ep_ring = xhci->devs[slot_id]->eps[ep_index].ring;
                         ep_state = xhci->devs[slot_id]->eps[ep_index].ep_state;
                         if (!(ep_state & EP_HALTED))
@@ -1076,28 +1131,27 @@ static void handle_cmd_completion(struct xhci_hcd *xhci,
 bandwidth_change:
                 xhci_dbg(xhci, "Completed config ep cmd\n");
                 xhci->devs[slot_id]->cmd_status =
-                        GET_COMP_CODE(event->status);
+                        GET_COMP_CODE(le32_to_cpu(event->status));
                 complete(&xhci->devs[slot_id]->cmd_completion);
                 break;
         case TRB_TYPE(TRB_EVAL_CONTEXT):
                 virt_dev = xhci->devs[slot_id];
                 if (handle_cmd_in_cmd_wait_list(xhci, virt_dev, event))
                         break;
-                xhci->devs[slot_id]->cmd_status = GET_COMP_CODE(event->status);
+                xhci->devs[slot_id]->cmd_status = GET_COMP_CODE(le32_to_cpu(event->status));
                 complete(&xhci->devs[slot_id]->cmd_completion);
                 break;
         case TRB_TYPE(TRB_ADDR_DEV):
-                xhci->devs[slot_id]->cmd_status = GET_COMP_CODE(event->status);
+                xhci->devs[slot_id]->cmd_status = GET_COMP_CODE(le32_to_cpu(event->status));
                 complete(&xhci->addr_dev);
                 break;
         case TRB_TYPE(TRB_STOP_RING):
-                handle_stopped_endpoint(xhci, xhci->cmd_ring->dequeue);
+                handle_stopped_endpoint(xhci, xhci->cmd_ring->dequeue, event);
                 break;
         case TRB_TYPE(TRB_SET_DEQ):
                 handle_set_deq_completion(xhci, event, xhci->cmd_ring->dequeue);
                 break;
         case TRB_TYPE(TRB_CMD_NOOP):
-                ++xhci->noops_handled;
                 break;
         case TRB_TYPE(TRB_RESET_EP):
                 handle_reset_ep_completion(xhci, event, xhci->cmd_ring->dequeue);
@@ -1105,7 +1159,7 @@ bandwidth_change:
         case TRB_TYPE(TRB_RESET_DEV):
                 xhci_dbg(xhci, "Completed reset device command.\n");
                 slot_id = TRB_TO_SLOT_ID(
-                                xhci->cmd_ring->dequeue->generic.field[3]);
+                        le32_to_cpu(xhci->cmd_ring->dequeue->generic.field[3]));
                 virt_dev = xhci->devs[slot_id];
                 if (virt_dev)
                         handle_cmd_in_cmd_wait_list(xhci, virt_dev, event);
@@ -1119,8 +1173,8 @@ bandwidth_change:
                         break;
                 }
                 xhci_dbg(xhci, "NEC firmware version %2x.%02x\n",
-                                NEC_FW_MAJOR(event->status),
-                                NEC_FW_MINOR(event->status));
+                         NEC_FW_MAJOR(le32_to_cpu(event->status)),
+                         NEC_FW_MINOR(le32_to_cpu(event->status)));
                 break;
         default:
                 /* Skip over unknown commands on the event ring */
@@ -1135,32 +1189,175 @@ static void handle_vendor_event(struct xhci_hcd *xhci,
 {
         u32 trb_type;
 
-        trb_type = TRB_FIELD_TO_TYPE(event->generic.field[3]);
+        trb_type = TRB_FIELD_TO_TYPE(le32_to_cpu(event->generic.field[3]));
         xhci_dbg(xhci, "Vendor specific event TRB type = %u\n", trb_type);
         if (trb_type == TRB_NEC_CMD_COMP && (xhci->quirks & XHCI_NEC_HOST))
                 handle_cmd_completion(xhci, &event->event_cmd);
 }
 
+/* @port_id: the one-based port ID from the hardware (indexed from array of all
+ * port registers -- USB 3.0 and USB 2.0).
+ *
+ * Returns a zero-based port number, which is suitable for indexing into each of
+ * the split roothubs' port arrays and bus state arrays.
+ */
+static unsigned int find_faked_portnum_from_hw_portnum(struct usb_hcd *hcd,
+                struct xhci_hcd *xhci, u32 port_id)
+{
+        unsigned int i;
+        unsigned int num_similar_speed_ports = 0;
+
+        /* port_id from the hardware is 1-based, but port_array[], usb3_ports[],
+         * and usb2_ports are 0-based indexes.  Count the number of similar
+         * speed ports, up to 1 port before this port.
+         */
+        for (i = 0; i < (port_id - 1); i++) {
+                u8 port_speed = xhci->port_array[i];
+
+                /*
+                 * Skip ports that don't have known speeds, or have duplicate
+                 * Extended Capabilities port speed entries.
+                 */
+                if (port_speed == 0 || port_speed == DUPLICATE_ENTRY)
+                        continue;
+
+                /*
+                 * USB 3.0 ports are always under a USB 3.0 hub.  USB 2.0 and
+                 * 1.1 ports are under the USB 2.0 hub.  If the port speed
+                 * matches the device speed, it's a similar speed port.
+                 */
+                if ((port_speed == 0x03) == (hcd->speed == HCD_USB3))
+                        num_similar_speed_ports++;
+        }
+        return num_similar_speed_ports;
+}
+
 static void handle_port_status(struct xhci_hcd *xhci,
                 union xhci_trb *event)
 {
+        struct usb_hcd *hcd;
         u32 port_id;
+        u32 temp, temp1;
+        int max_ports;
+        int slot_id;
+        unsigned int faked_port_index;
+        u8 major_revision;
+        struct xhci_bus_state *bus_state;
+        __le32 __iomem **port_array;
+        bool bogus_port_status = false;
 
         /* Port status change events always have a successful completion code */
-        if (GET_COMP_CODE(event->generic.field[2]) != COMP_SUCCESS) {
+        if (GET_COMP_CODE(le32_to_cpu(event->generic.field[2])) != COMP_SUCCESS) {
                 xhci_warn(xhci, "WARN: xHC returned failed port status event\n");
                 xhci->error_bitmask |= 1 << 8;
         }
-        /* FIXME: core doesn't care about all port link state changes yet */
-        port_id = GET_PORT_ID(event->generic.field[0]);
+        port_id = GET_PORT_ID(le32_to_cpu(event->generic.field[0]));
         xhci_dbg(xhci, "Port Status Change Event for port %d\n", port_id);
 
+        max_ports = HCS_MAX_PORTS(xhci->hcs_params1);
+        if ((port_id <= 0) || (port_id > max_ports)) {
+                xhci_warn(xhci, "Invalid port id %d\n", port_id);
+                bogus_port_status = true;
+                goto cleanup;
+        }
+
+        /* Figure out which usb_hcd this port is attached to:
+         * is it a USB 3.0 port or a USB 2.0/1.1 port?
+         */
+        major_revision = xhci->port_array[port_id - 1];
+        if (major_revision == 0) {
+                xhci_warn(xhci, "Event for port %u not in "
+                                "Extended Capabilities, ignoring.\n",
+                                port_id);
+                bogus_port_status = true;
+                goto cleanup;
+        }
+        if (major_revision == DUPLICATE_ENTRY) {
+                xhci_warn(xhci, "Event for port %u duplicated in"
+                                "Extended Capabilities, ignoring.\n",
+                                port_id);
+                bogus_port_status = true;
+                goto cleanup;
+        }
+
+        /*
+         * Hardware port IDs reported by a Port Status Change Event include USB
+         * 3.0 and USB 2.0 ports.  We want to check if the port has reported a
+         * resume event, but we first need to translate the hardware port ID
+         * into the index into the ports on the correct split roothub, and the
+         * correct bus_state structure.
+         */
+        /* Find the right roothub. */
+        hcd = xhci_to_hcd(xhci);
+        if ((major_revision == 0x03) != (hcd->speed == HCD_USB3))
+                hcd = xhci->shared_hcd;
+        bus_state = &xhci->bus_state[hcd_index(hcd)];
+        if (hcd->speed == HCD_USB3)
+                port_array = xhci->usb3_ports;
+        else
+                port_array = xhci->usb2_ports;
+        /* Find the faked port hub number */
+        faked_port_index = find_faked_portnum_from_hw_portnum(hcd, xhci,
+                        port_id);
+
+        temp = xhci_readl(xhci, port_array[faked_port_index]);
+        if (hcd->state == HC_STATE_SUSPENDED) {
+                xhci_dbg(xhci, "resume root hub\n");
+                usb_hcd_resume_root_hub(hcd);
+        }
+
+        if ((temp & PORT_PLC) && (temp & PORT_PLS_MASK) == XDEV_RESUME) {
+                xhci_dbg(xhci, "port resume event for port %d\n", port_id);
+
+                temp1 = xhci_readl(xhci, &xhci->op_regs->command);
+                if (!(temp1 & CMD_RUN)) {
+                        xhci_warn(xhci, "xHC is not running.\n");
+                        goto cleanup;
+                }
+
+                if (DEV_SUPERSPEED(temp)) {
+                        xhci_dbg(xhci, "resume SS port %d\n", port_id);
+                        temp = xhci_port_state_to_neutral(temp);
+                        temp &= ~PORT_PLS_MASK;
+                        temp |= PORT_LINK_STROBE | XDEV_U0;
+                        xhci_writel(xhci, temp, port_array[faked_port_index]);
+                        slot_id = xhci_find_slot_id_by_port(hcd, xhci,
+                                        faked_port_index);
+                        if (!slot_id) {
+                                xhci_dbg(xhci, "slot_id is zero\n");
+                                goto cleanup;
+                        }
+                        xhci_ring_device(xhci, slot_id);
+                        xhci_dbg(xhci, "resume SS port %d finished\n", port_id);
+                        /* Clear PORT_PLC */
+                        temp = xhci_readl(xhci, port_array[faked_port_index]);
+                        temp = xhci_port_state_to_neutral(temp);
+                        temp |= PORT_PLC;
+                        xhci_writel(xhci, temp, port_array[faked_port_index]);
+                } else {
+                        xhci_dbg(xhci, "resume HS port %d\n", port_id);
+                        bus_state->resume_done[faked_port_index] = jiffies +
+                                msecs_to_jiffies(20);
+                        mod_timer(&hcd->rh_timer,
+                                  bus_state->resume_done[faked_port_index]);
+                        /* Do the rest in GetPortStatus */
+                }
+        }
+
+cleanup:
         /* Update event ring dequeue pointer before dropping the lock */
         inc_deq(xhci, xhci->event_ring, true);
 
+        /* Don't make the USB core poll the roothub if we got a bad port status
+         * change event.  Besides, at that point we can't tell which roothub
+         * (USB 2.0 or USB 3.0) to kick.
+         */
+        if (bogus_port_status)
+                return;
+
         spin_unlock(&xhci->lock);
         /* Pass this up to the core */
-        usb_hcd_poll_rh_status(xhci_to_hcd(xhci));
+        usb_hcd_poll_rh_status(hcd);
         spin_lock(&xhci->lock);
 }
 
@@ -1261,7 +1458,7 @@ static int xhci_requires_manual_halt_cleanup(struct xhci_hcd *xhci,
                  * endpoint anyway.  Check if a babble halted the
                  * endpoint.
                  */
-                if ((ep_ctx->ep_info & EP_STATE_MASK) == EP_STATE_HALTED)
+                if ((le32_to_cpu(ep_ctx->ep_info) & EP_STATE_MASK) == EP_STATE_HALTED)
                         return 1;
 
         return 0;
@@ -1299,12 +1496,12 @@ static int finish_td(struct xhci_hcd *xhci, struct xhci_td *td,
         struct urb_priv *urb_priv;
         u32 trb_comp_code;
 
-        slot_id = TRB_TO_SLOT_ID(event->flags);
+        slot_id = TRB_TO_SLOT_ID(le32_to_cpu(event->flags));
         xdev = xhci->devs[slot_id];
-        ep_index = TRB_TO_EP_ID(event->flags) - 1;
-        ep_ring = xhci_dma_to_transfer_ring(ep, event->buffer);
+        ep_index = TRB_TO_EP_ID(le32_to_cpu(event->flags)) - 1;
+        ep_ring = xhci_dma_to_transfer_ring(ep, le64_to_cpu(event->buffer));
         ep_ctx = xhci_get_ep_ctx(xhci, xdev->out_ctx, ep_index);
-        trb_comp_code = GET_COMP_CODE(event->transfer_len);
+        trb_comp_code = GET_COMP_CODE(le32_to_cpu(event->transfer_len));
 
         if (skip)
                 goto td_cleanup;
@@ -1377,8 +1574,17 @@ td_cleanup:
 
                 urb_priv->td_cnt++;
                 /* Giveback the urb when all the tds are completed */
-                if (urb_priv->td_cnt == urb_priv->length)
+                if (urb_priv->td_cnt == urb_priv->length) {
                         ret = 1;
+                        if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) {
+                                xhci_to_hcd(xhci)->self.bandwidth_isoc_reqs--;
+                                if (xhci_to_hcd(xhci)->self.bandwidth_isoc_reqs
+                                        == 0) {
+                                        if (xhci->quirks & XHCI_AMD_PLL_FIX)
+                                                usb_amd_quirk_pll_enable();
+                                }
+                        }
+                }
         }
 
         return ret;
@@ -1398,12 +1604,12 @@ static int process_ctrl_td(struct xhci_hcd *xhci, struct xhci_td *td,
         struct xhci_ep_ctx *ep_ctx;
         u32 trb_comp_code;
 
-        slot_id = TRB_TO_SLOT_ID(event->flags);
+        slot_id = TRB_TO_SLOT_ID(le32_to_cpu(event->flags));
         xdev = xhci->devs[slot_id];
-        ep_index = TRB_TO_EP_ID(event->flags) - 1;
-        ep_ring = xhci_dma_to_transfer_ring(ep, event->buffer);
+        ep_index = TRB_TO_EP_ID(le32_to_cpu(event->flags)) - 1;
+        ep_ring = xhci_dma_to_transfer_ring(ep, le64_to_cpu(event->buffer));
         ep_ctx = xhci_get_ep_ctx(xhci, xdev->out_ctx, ep_index);
-        trb_comp_code = GET_COMP_CODE(event->transfer_len);
+        trb_comp_code = GET_COMP_CODE(le32_to_cpu(event->transfer_len));
 
         xhci_debug_trb(xhci, xhci->event_ring->dequeue);
         switch (trb_comp_code) {
@@ -1417,7 +1623,6 @@ static int process_ctrl_td(struct xhci_hcd *xhci, struct xhci_td *td,
                                         "without IOC set??\n");
                         *status = -ESHUTDOWN;
                 } else {
-                        xhci_dbg(xhci, "Successful control transfer!\n");
                         *status = 0;
                 }
                 break;
@@ -1428,6 +1633,9 @@ static int process_ctrl_td(struct xhci_hcd *xhci, struct xhci_td *td,
                 else
                         *status = 0;
                 break;
+        case COMP_STOP_INVAL:
+        case COMP_STOP:
+                return finish_td(xhci, td, event_trb, event, ep, status, false);
         default:
                 if (!xhci_requires_manual_halt_cleanup(xhci,
                                         ep_ctx, trb_comp_code))
@@ -1442,7 +1650,7 @@ static int process_ctrl_td(struct xhci_hcd *xhci, struct xhci_td *td,
                                 event_trb != td->last_trb)
                         td->urb->actual_length =
                                 td->urb->transfer_buffer_length
-                                - TRB_LEN(event->transfer_len);
+                                - TRB_LEN(le32_to_cpu(event->transfer_len));
                 else
                         td->urb->actual_length = 0;
 
@@ -1472,15 +1680,12 @@ static int process_ctrl_td(struct xhci_hcd *xhci, struct xhci_td *td,
                         }
                 } else {
                 /* Maybe the event was for the data stage? */
-                        if (trb_comp_code != COMP_STOP_INVAL) {
-                                /* We didn't stop on a link TRB in the middle */
-                                td->urb->actual_length =
-                                        td->urb->transfer_buffer_length -
-                                        TRB_LEN(event->transfer_len);
-                                xhci_dbg(xhci, "Waiting for status "
-                                                "stage event\n");
-                                return 0;
-                        }
+                        td->urb->actual_length =
+                                td->urb->transfer_buffer_length -
+                                TRB_LEN(le32_to_cpu(event->transfer_len));
+                        xhci_dbg(xhci, "Waiting for status "
+                                        "stage event\n");
+                        return 0;
                 }
         }
 
@@ -1498,97 +1703,102 @@ static int process_isoc_td(struct xhci_hcd *xhci, struct xhci_td *td,
         struct urb_priv *urb_priv;
         int idx;
         int len = 0;
-        int skip_td = 0;
         union xhci_trb *cur_trb;
         struct xhci_segment *cur_seg;
+        struct usb_iso_packet_descriptor *frame;
         u32 trb_comp_code;
+        bool skip_td = false;
 
-        ep_ring = xhci_dma_to_transfer_ring(ep, event->buffer);
-        trb_comp_code = GET_COMP_CODE(event->transfer_len);
+        ep_ring = xhci_dma_to_transfer_ring(ep, le64_to_cpu(event->buffer));
+        trb_comp_code = GET_COMP_CODE(le32_to_cpu(event->transfer_len));
         urb_priv = td->urb->hcpriv;
         idx = urb_priv->td_cnt;
+        frame = &td->urb->iso_frame_desc[idx];
 
-        if (ep->skip) {
-                /* The transfer is partly done */
-                *status = -EXDEV;
-                td->urb->iso_frame_desc[idx].status = -EXDEV;
-        } else {
-                /* handle completion code */
-                switch (trb_comp_code) {
-                case COMP_SUCCESS:
-                        td->urb->iso_frame_desc[idx].status = 0;
-                        xhci_dbg(xhci, "Successful isoc transfer!\n");
-                        break;
-                case COMP_SHORT_TX:
-                        if (td->urb->transfer_flags & URB_SHORT_NOT_OK)
-                                td->urb->iso_frame_desc[idx].status =
-                                         -EREMOTEIO;
-                        else
-                                td->urb->iso_frame_desc[idx].status = 0;
-                        break;
-                case COMP_BW_OVER:
-                        td->urb->iso_frame_desc[idx].status = -ECOMM;
-                        skip_td = 1;
-                        break;
-                case COMP_BUFF_OVER:
-                case COMP_BABBLE:
-                        td->urb->iso_frame_desc[idx].status = -EOVERFLOW;
-                        skip_td = 1;
-                        break;
-                case COMP_STALL:
-                        td->urb->iso_frame_desc[idx].status = -EPROTO;
-                        skip_td = 1;
-                        break;
-                case COMP_STOP:
-                case COMP_STOP_INVAL:
-                        break;
-                default:
-                        td->urb->iso_frame_desc[idx].status = -1;
-                        break;
-                }
-        }
-
-        /* calc actual length */
-        if (ep->skip) {
-                td->urb->iso_frame_desc[idx].actual_length = 0;
-                /* Update ring dequeue pointer */
-                while (ep_ring->dequeue != td->last_trb)
-                        inc_deq(xhci, ep_ring, false);
-                inc_deq(xhci, ep_ring, false);
-                return finish_td(xhci, td, event_trb, event, ep, status, true);
+        /* handle completion code */
+        switch (trb_comp_code) {
+        case COMP_SUCCESS:
+                frame->status = 0;
+                break;
+        case COMP_SHORT_TX:
+                frame->status = td->urb->transfer_flags & URB_SHORT_NOT_OK ?
+                                -EREMOTEIO : 0;
+                break;
+        case COMP_BW_OVER:
+                frame->status = -ECOMM;
+                skip_td = true;
+                break;
+        case COMP_BUFF_OVER:
+        case COMP_BABBLE:
+                frame->status = -EOVERFLOW;
+                skip_td = true;
+                break;
+        case COMP_DEV_ERR:
+        case COMP_STALL:
+                frame->status = -EPROTO;
+                skip_td = true;
+                break;
+        case COMP_STOP:
+        case COMP_STOP_INVAL:
+                break;
+        default:
+                frame->status = -1;
+                break;
         }
 
-        if (trb_comp_code == COMP_SUCCESS || skip_td == 1) {
-                td->urb->iso_frame_desc[idx].actual_length =
-                        td->urb->iso_frame_desc[idx].length;
-                td->urb->actual_length +=
-                        td->urb->iso_frame_desc[idx].length;
+        if (trb_comp_code == COMP_SUCCESS || skip_td) {
+                frame->actual_length = frame->length;
+                td->urb->actual_length += frame->length;
         } else {
                 for (cur_trb = ep_ring->dequeue,
                      cur_seg = ep_ring->deq_seg; cur_trb != event_trb;
                      next_trb(xhci, ep_ring, &cur_seg, &cur_trb)) {
-                        if ((cur_trb->generic.field[3] &
+                        if ((le32_to_cpu(cur_trb->generic.field[3]) &
                          TRB_TYPE_BITMASK) != TRB_TYPE(TRB_TR_NOOP) &&
-                            (cur_trb->generic.field[3] &
+                            (le32_to_cpu(cur_trb->generic.field[3]) &
                          TRB_TYPE_BITMASK) != TRB_TYPE(TRB_LINK))
-                                len +=
-                                    TRB_LEN(cur_trb->generic.field[2]);
+                                len += TRB_LEN(le32_to_cpu(cur_trb->generic.field[2]));
                 }
-                len += TRB_LEN(cur_trb->generic.field[2]) -
-                        TRB_LEN(event->transfer_len);
+                len += TRB_LEN(le32_to_cpu(cur_trb->generic.field[2])) -
+                        TRB_LEN(le32_to_cpu(event->transfer_len));
 
                 if (trb_comp_code != COMP_STOP_INVAL) {
-                        td->urb->iso_frame_desc[idx].actual_length = len;
+                        frame->actual_length = len;
                         td->urb->actual_length += len;
                 }
         }
 
-        if ((idx == urb_priv->length - 1) && *status == -EINPROGRESS)
-                *status = 0;
-
         return finish_td(xhci, td, event_trb, event, ep, status, false);
 }
 
+static int skip_isoc_td(struct xhci_hcd *xhci, struct xhci_td *td,
+                        struct xhci_transfer_event *event,
+                        struct xhci_virt_ep *ep, int *status)
+{
+        struct xhci_ring *ep_ring;
+        struct urb_priv *urb_priv;
+        struct usb_iso_packet_descriptor *frame;
+        int idx;
+
+        ep_ring = xhci_dma_to_transfer_ring(ep, le64_to_cpu(event->buffer));
+        urb_priv = td->urb->hcpriv;
+        idx = urb_priv->td_cnt;
+        frame = &td->urb->iso_frame_desc[idx];
+
+        /* The transfer is partly done. */
+        frame->status = -EXDEV;
+
+        /* calc actual length */
+        frame->actual_length = 0;
+
+        /* Update ring dequeue pointer */
+        while (ep_ring->dequeue != td->last_trb)
+                inc_deq(xhci, ep_ring, false);
+        inc_deq(xhci, ep_ring, false);
+
+        return finish_td(xhci, td, NULL, event, ep, status, true);
+}
+
 /*
  * Process bulk and interrupt tds, update urb status and actual_length.
  */
@@ -1601,8 +1811,8 @@ static int process_bulk_intr_td(struct xhci_hcd *xhci, struct xhci_td *td,
         struct xhci_segment *cur_seg;
         u32 trb_comp_code;
 
-        ep_ring = xhci_dma_to_transfer_ring(ep, event->buffer);
-        trb_comp_code = GET_COMP_CODE(event->transfer_len);
+        ep_ring = xhci_dma_to_transfer_ring(ep, le64_to_cpu(event->buffer));
+        trb_comp_code = GET_COMP_CODE(le32_to_cpu(event->transfer_len));
 
         switch (trb_comp_code) {
         case COMP_SUCCESS:
@@ -1615,12 +1825,6 @@ static int process_bulk_intr_td(struct xhci_hcd *xhci, struct xhci_td *td,
                         else
                                 *status = 0;
                 } else {
-                        if (usb_endpoint_xfer_bulk(&td->urb->ep->desc))
-                                xhci_dbg(xhci, "Successful bulk "
-                                                "transfer!\n");
-                        else
-                                xhci_dbg(xhci, "Successful interrupt "
-                                                "transfer!\n");
                         *status = 0;
                 }
                 break;
@@ -1634,23 +1838,23 @@ static int process_bulk_intr_td(struct xhci_hcd *xhci, struct xhci_td *td,
                 /* Others already handled above */
                 break;
         }
-        dev_dbg(&td->urb->dev->dev,
-                        "ep %#x - asked for %d bytes, "
-                        "%d bytes untransferred\n",
-                        td->urb->ep->desc.bEndpointAddress,
-                        td->urb->transfer_buffer_length,
-                        TRB_LEN(event->transfer_len));
+        if (trb_comp_code == COMP_SHORT_TX)
+                xhci_dbg(xhci, "ep %#x - asked for %d bytes, "
+                                "%d bytes untransferred\n",
+                                td->urb->ep->desc.bEndpointAddress,
+                                td->urb->transfer_buffer_length,
+                                TRB_LEN(le32_to_cpu(event->transfer_len)));
         /* Fast path - was this the last TRB in the TD for this URB? */
         if (event_trb == td->last_trb) {
-                if (TRB_LEN(event->transfer_len) != 0) {
+                if (TRB_LEN(le32_to_cpu(event->transfer_len)) != 0) {
                         td->urb->actual_length =
                                 td->urb->transfer_buffer_length -
-                                TRB_LEN(event->transfer_len);
+                                TRB_LEN(le32_to_cpu(event->transfer_len));
                         if (td->urb->transfer_buffer_length <
                                         td->urb->actual_length) {
                                 xhci_warn(xhci, "HC gave bad length "
                                                 "of %d bytes left\n",
-                                                TRB_LEN(event->transfer_len));
+                                          TRB_LEN(le32_to_cpu(event->transfer_len)));
                                 td->urb->actual_length = 0;
                                 if (td->urb->transfer_flags & URB_SHORT_NOT_OK)
                                         *status = -EREMOTEIO;
@@ -1681,20 +1885,20 @@ static int process_bulk_intr_td(struct xhci_hcd *xhci, struct xhci_td *td,
                 for (cur_trb = ep_ring->dequeue, cur_seg = ep_ring->deq_seg;
                                 cur_trb != event_trb;
                                 next_trb(xhci, ep_ring, &cur_seg, &cur_trb)) {
-                        if ((cur_trb->generic.field[3] &
+                        if ((le32_to_cpu(cur_trb->generic.field[3]) &
                          TRB_TYPE_BITMASK) != TRB_TYPE(TRB_TR_NOOP) &&
-                            (cur_trb->generic.field[3] &
+                            (le32_to_cpu(cur_trb->generic.field[3]) &
                          TRB_TYPE_BITMASK) != TRB_TYPE(TRB_LINK))
                                 td->urb->actual_length +=
-                                        TRB_LEN(cur_trb->generic.field[2]);
+                                        TRB_LEN(le32_to_cpu(cur_trb->generic.field[2]));
                 }
                 /* If the ring didn't stop on a Link or No-op TRB, add
                  * in the actual bytes transferred from the Normal TRB
                  */
                 if (trb_comp_code != COMP_STOP_INVAL)
                         td->urb->actual_length +=
-                                TRB_LEN(cur_trb->generic.field[2]) -
-                                TRB_LEN(event->transfer_len);
+                                TRB_LEN(le32_to_cpu(cur_trb->generic.field[2])) -
+                                TRB_LEN(le32_to_cpu(event->transfer_len));
         }
 
         return finish_td(xhci, td, event_trb, event, ep, status, false);
@@ -1724,7 +1928,7 @@ static int handle_tx_event(struct xhci_hcd *xhci,
         u32 trb_comp_code;
         int ret = 0;
 
-        slot_id = TRB_TO_SLOT_ID(event->flags);
+        slot_id = TRB_TO_SLOT_ID(le32_to_cpu(event->flags));
         xdev = xhci->devs[slot_id];
         if (!xdev) {
                 xhci_err(xhci, "ERROR Transfer event pointed to bad slot\n");
@@ -1732,20 +1936,20 @@ static int handle_tx_event(struct xhci_hcd *xhci,
         }
 
         /* Endpoint ID is 1 based, our index is zero based */
-        ep_index = TRB_TO_EP_ID(event->flags) - 1;
-        xhci_dbg(xhci, "%s - ep index = %d\n", __func__, ep_index);
+        ep_index = TRB_TO_EP_ID(le32_to_cpu(event->flags)) - 1;
         ep = &xdev->eps[ep_index];
-        ep_ring = xhci_dma_to_transfer_ring(ep, event->buffer);
+        ep_ring = xhci_dma_to_transfer_ring(ep, le64_to_cpu(event->buffer));
         ep_ctx = xhci_get_ep_ctx(xhci, xdev->out_ctx, ep_index);
         if (!ep_ring ||
-                (ep_ctx->ep_info & EP_STATE_MASK) == EP_STATE_DISABLED) {
+            (le32_to_cpu(ep_ctx->ep_info) & EP_STATE_MASK) ==
+            EP_STATE_DISABLED) {
                 xhci_err(xhci, "ERROR Transfer event for disabled endpoint "
                                 "or incorrect stream ring\n");
                 return -ENODEV;
         }
 
-        event_dma = event->buffer;
-        trb_comp_code = GET_COMP_CODE(event->transfer_len);
+        event_dma = le64_to_cpu(event->buffer);
+        trb_comp_code = GET_COMP_CODE(le32_to_cpu(event->transfer_len));
         /* Look for common error cases */
         switch (trb_comp_code) {
         /* Skip codes that require special handling depending on
@@ -1798,15 +2002,21 @@ static int handle_tx_event(struct xhci_hcd *xhci,
                 if (!list_empty(&ep_ring->td_list))
                         xhci_dbg(xhci, "Underrun Event for slot %d ep %d "
                                         "still with TDs queued?\n",
-                                TRB_TO_SLOT_ID(event->flags), ep_index);
+                                 TRB_TO_SLOT_ID(le32_to_cpu(event->flags)),
+                                 ep_index);
                 goto cleanup;
         case COMP_OVERRUN:
                 xhci_dbg(xhci, "overrun event on endpoint\n");
                 if (!list_empty(&ep_ring->td_list))
                         xhci_dbg(xhci, "Overrun Event for slot %d ep %d "
                                         "still with TDs queued?\n",
-                                TRB_TO_SLOT_ID(event->flags), ep_index);
+                                 TRB_TO_SLOT_ID(le32_to_cpu(event->flags)),
+                                 ep_index);
                 goto cleanup;
+        case COMP_DEV_ERR:
+                xhci_warn(xhci, "WARN: detect an incompatible device");
+                status = -EPROTO;
+                break;
         case COMP_MISSED_INT:
                 /*
                  * When encounter missed service error, one or more isoc tds
@@ -1834,9 +2044,11 @@ static int handle_tx_event(struct xhci_hcd *xhci,
                 if (list_empty(&ep_ring->td_list)) {
                         xhci_warn(xhci, "WARN Event TRB for slot %d ep %d "
                                         "with no TDs queued?\n",
-                                  TRB_TO_SLOT_ID(event->flags), ep_index);
+                                  TRB_TO_SLOT_ID(le32_to_cpu(event->flags)),
+                                  ep_index);
                         xhci_dbg(xhci, "Event TRB with TRB type ID %u\n",
-                          (unsigned int) (event->flags & TRB_TYPE_BITMASK)>>10);
+                                 (unsigned int) (le32_to_cpu(event->flags)
+                                                 & TRB_TYPE_BITMASK)>>10);
                         xhci_print_trb_offsets(xhci, (union xhci_trb *) event);
                         if (ep->skip) {
                                 ep->skip = false;
@@ -1848,36 +2060,71 @@ static int handle_tx_event(struct xhci_hcd *xhci,
                 }
 
                 td = list_entry(ep_ring->td_list.next, struct xhci_td, td_list);
+
                 /* Is this a TRB in the currently executing TD? */
                 event_seg = trb_in_td(ep_ring->deq_seg, ep_ring->dequeue,
                                 td->last_trb, event_dma);
-                if (event_seg && ep->skip) {
-                        xhci_dbg(xhci, "Found td. Clear skip flag.\n");
-                        ep->skip = false;
+
+                /*
+                 * Skip the Force Stopped Event. The event_trb(event_dma) of FSE
+                 * is not in the current TD pointed by ep_ring->dequeue because
+                 * that the hardware dequeue pointer still at the previous TRB
+                 * of the current TD. The previous TRB maybe a Link TD or the
+                 * last TRB of the previous TD. The command completion handle
+                 * will take care the rest.
+                 */
+                if (!event_seg && trb_comp_code == COMP_STOP_INVAL) {
+                        ret = 0;
+                        goto cleanup;
                 }
-                if (!event_seg &&
-                   (!ep->skip || !usb_endpoint_xfer_isoc(&td->urb->ep->desc))) {
-                        /* HC is busted, give up! */
-                        xhci_err(xhci, "ERROR Transfer event TRB DMA ptr not "
+
+                if (!event_seg) {
+                        if (!ep->skip ||
+                            !usb_endpoint_xfer_isoc(&td->urb->ep->desc)) {
+                                /* Some host controllers give a spurious
+                                 * successful event after a short transfer.
+                                 * Ignore it.
+                                 */
+                                if ((xhci->quirks & XHCI_SPURIOUS_SUCCESS) && 
+                                                ep_ring->last_td_was_short) {
+                                        ep_ring->last_td_was_short = false;
+                                        ret = 0;
+                                        goto cleanup;
+                                }
+                                /* HC is busted, give up! */
+                                xhci_err(xhci,
+                                        "ERROR Transfer event TRB DMA ptr not "
                                         "part of current TD\n");
-                        return -ESHUTDOWN;
+                                return -ESHUTDOWN;
+                        }
+
+                        ret = skip_isoc_td(xhci, td, event, ep, &status);
+                        goto cleanup;
                 }
+                if (trb_comp_code == COMP_SHORT_TX)
+                        ep_ring->last_td_was_short = true;
+                else
+                        ep_ring->last_td_was_short = false;
 
-                if (event_seg) {
-                        event_trb = &event_seg->trbs[(event_dma -
-                                         event_seg->dma) / sizeof(*event_trb)];
-                        /*
-                         * No-op TRB should not trigger interrupts.
-                         * If event_trb is a no-op TRB, it means the
-                         * corresponding TD has been cancelled. Just ignore
-                         * the TD.
-                         */
-                        if ((event_trb->generic.field[3] & TRB_TYPE_BITMASK)
-                                         == TRB_TYPE(TRB_TR_NOOP)) {
-                                xhci_dbg(xhci, "event_trb is a no-op TRB. "
-                                                "Skip it\n");
-                                goto cleanup;
-                        }
+                if (ep->skip) {
+                        xhci_dbg(xhci, "Found td. Clear skip flag.\n");
+                        ep->skip = false;
+                }
+
+                event_trb = &event_seg->trbs[(event_dma - event_seg->dma) /
+                                                sizeof(*event_trb)];
+                /*
+                 * No-op TRB should not trigger interrupts.
+                 * If event_trb is a no-op TRB, it means the
+                 * corresponding TD has been cancelled. Just ignore
+                 * the TD.
+                 */
+                if ((le32_to_cpu(event_trb->generic.field[3])
+                             & TRB_TYPE_BITMASK)
+                                 == TRB_TYPE(TRB_TR_NOOP)) {
+                        xhci_dbg(xhci,
+                                 "event_trb is a no-op TRB. Skip it\n");
+                        goto cleanup;
                 }
 
                 /* Now update the urb's actual_length and give back to
@@ -1915,12 +2162,23 @@ cleanup:
                                         trb_comp_code != COMP_BABBLE))
                                 xhci_urb_free_priv(xhci, urb_priv);
 
-                        usb_hcd_unlink_urb_from_ep(xhci_to_hcd(xhci), urb);
-                        xhci_dbg(xhci, "Giveback URB %p, len = %d, "
-                                        "status = %d\n",
-                                        urb, urb->actual_length, status);
+                        usb_hcd_unlink_urb_from_ep(bus_to_hcd(urb->dev->bus), urb);
+                        if ((urb->actual_length != urb->transfer_buffer_length &&
+                                                (urb->transfer_flags &
+                                                 URB_SHORT_NOT_OK)) ||
+                                        status != 0)
+                                xhci_dbg(xhci, "Giveback URB %p, len = %d, "
+                                                "expected = %x, status = %d\n",
+                                                urb, urb->actual_length,
+                                                urb->transfer_buffer_length,
+                                                status);
                         spin_unlock(&xhci->lock);
-                        usb_hcd_giveback_urb(xhci_to_hcd(xhci), urb, status);
+                        /* EHCI, UHCI, and OHCI always unconditionally set the
+                         * urb->status of an isochronous endpoint to 0.
+                         */
+                        if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS)
+                                status = 0;
+                        usb_hcd_giveback_urb(bus_to_hcd(urb->dev->bus), urb, status);
                         spin_lock(&xhci->lock);
                 }
 
@@ -1938,52 +2196,52 @@ cleanup:
 /*
  * This function handles all OS-owned events on the event ring.  It may drop
  * xhci->lock between event processing (e.g. to pass up port status changes).
+ * Returns >0 for "possibly more events to process" (caller should call again),
+ * otherwise 0 if done.  In future, <0 returns should indicate error code.
  */
-static void xhci_handle_event(struct xhci_hcd *xhci)
+static int xhci_handle_event(struct xhci_hcd *xhci)
 {
         union xhci_trb *event;
         int update_ptrs = 1;
         int ret;
 
-        xhci_dbg(xhci, "In %s\n", __func__);
         if (!xhci->event_ring || !xhci->event_ring->dequeue) {
                 xhci->error_bitmask |= 1 << 1;
-                return;
+                return 0;
         }
 
         event = xhci->event_ring->dequeue;
         /* Does the HC or OS own the TRB? */
-        if ((event->event_cmd.flags & TRB_CYCLE) !=
-                        xhci->event_ring->cycle_state) {
+        if ((le32_to_cpu(event->event_cmd.flags) & TRB_CYCLE) !=
+            xhci->event_ring->cycle_state) {
                 xhci->error_bitmask |= 1 << 2;
-                return;
+                return 0;
         }
-        xhci_dbg(xhci, "%s - OS owns TRB\n", __func__);
 
+        /*
+         * Barrier between reading the TRB_CYCLE (valid) flag above and any
+         * speculative reads of the event's flags/data below.
+         */
+        rmb();
         /* FIXME: Handle more event types. */
-        switch ((event->event_cmd.flags & TRB_TYPE_BITMASK)) {
+        switch ((le32_to_cpu(event->event_cmd.flags) & TRB_TYPE_BITMASK)) {
         case TRB_TYPE(TRB_COMPLETION):
-                xhci_dbg(xhci, "%s - calling handle_cmd_completion\n", __func__);
                 handle_cmd_completion(xhci, &event->event_cmd);
-                xhci_dbg(xhci, "%s - returned from handle_cmd_completion\n", __func__);
                 break;
         case TRB_TYPE(TRB_PORT_STATUS):
-                xhci_dbg(xhci, "%s - calling handle_port_status\n", __func__);
                 handle_port_status(xhci, event);
-                xhci_dbg(xhci, "%s - returned from handle_port_status\n", __func__);
                 update_ptrs = 0;
                 break;
         case TRB_TYPE(TRB_TRANSFER):
-                xhci_dbg(xhci, "%s - calling handle_tx_event\n", __func__);
                 ret = handle_tx_event(xhci, &event->trans_event);
-                xhci_dbg(xhci, "%s - returned from handle_tx_event\n", __func__);
                 if (ret < 0)
                         xhci->error_bitmask |= 1 << 9;
                 else
                         update_ptrs = 0;
                 break;
         default:
-                if ((event->event_cmd.flags & TRB_TYPE_BITMASK) >= TRB_TYPE(48))
+                if ((le32_to_cpu(event->event_cmd.flags) & TRB_TYPE_BITMASK) >=
+                    TRB_TYPE(48))
                         handle_vendor_event(xhci, event);
                 else
                         xhci->error_bitmask |= 1 << 3;
@@ -1994,15 +2252,17 @@ static void xhci_handle_event(struct xhci_hcd *xhci)
         if (xhci->xhc_state & XHCI_STATE_DYING) {
                 xhci_dbg(xhci, "xHCI host dying, returning from "
                                 "event handler.\n");
-                return;
+                return 0;
         }
 
         if (update_ptrs)
                 /* Update SW event ring dequeue pointer */
                 inc_deq(xhci, xhci->event_ring, true);
 
-        /* Are there more items on the event ring? */
-        xhci_handle_event(xhci);
+        /* Are there more items on the event ring?  Caller will call us again to
+         * check.
+         */
+        return 1;
 }
 
 /*
@@ -2028,24 +2288,12 @@ irqreturn_t xhci_irq(struct usb_hcd *hcd)
 
         if (!(status & STS_EINT)) {
                 spin_unlock(&xhci->lock);
-                xhci_warn(xhci, "Spurious interrupt.\n");
                 return IRQ_NONE;
         }
-        xhci_dbg(xhci, "op reg status = %08x\n", status);
-        xhci_dbg(xhci, "Event ring dequeue ptr:\n");
-        xhci_dbg(xhci, "@%llx %08x %08x %08x %08x\n",
-                        (unsigned long long)
-                        xhci_trb_virt_to_dma(xhci->event_ring->deq_seg, trb),
-                        lower_32_bits(trb->link.segment_ptr),
-                        upper_32_bits(trb->link.segment_ptr),
-                        (unsigned int) trb->link.intr_target,
-                        (unsigned int) trb->link.control);
-
         if (status & STS_FATAL) {
                 xhci_warn(xhci, "WARNING: Host System Error\n");
                 xhci_halt(xhci);
 hw_died:
-                xhci_to_hcd(xhci)->state = HC_STATE_HALT;
                 spin_unlock(&xhci->lock);
                 return -ESHUTDOWN;
         }
@@ -2086,7 +2334,7 @@ hw_died:
         /* FIXME this should be a delayed service routine
          * that clears the EHB.
          */
-        xhci_handle_event(xhci);
+        while (xhci_handle_event(xhci) > 0) {}
 
         temp_64 = xhci_read_64(xhci, &xhci->ir_set->erst_dequeue);
         /* If necessary, update the HW's version of the event ring deq ptr. */
@@ -2113,8 +2361,12 @@ hw_died:
 irqreturn_t xhci_msi_irq(int irq, struct usb_hcd *hcd)
 {
         irqreturn_t ret;
+        struct xhci_hcd *xhci;
 
+        xhci = hcd_to_xhci(hcd);
         set_bit(HCD_FLAG_SAW_IRQ, &hcd->flags);
+        if (xhci->shared_hcd)
+                set_bit(HCD_FLAG_SAW_IRQ, &xhci->shared_hcd->flags);
 
         ret = xhci_irq(hcd);
 
@@ -2137,10 +2389,10 @@ static void queue_trb(struct xhci_hcd *xhci, struct xhci_ring *ring,
         struct xhci_generic_trb *trb;
 
         trb = &ring->enqueue->generic;
-        trb->field[0] = field1;
-        trb->field[1] = field2;
-        trb->field[2] = field3;
-        trb->field[3] = field4;
+        trb->field[0] = cpu_to_le32(field1);
+        trb->field[1] = cpu_to_le32(field2);
+        trb->field[2] = cpu_to_le32(field3);
+        trb->field[3] = cpu_to_le32(field4);
         inc_enq(xhci, ring, consumer, more_trbs_coming);
 }
 
@@ -2152,7 +2404,6 @@ static int prepare_ring(struct xhci_hcd *xhci, struct xhci_ring *ep_ring,
                 u32 ep_state, unsigned int num_trbs, gfp_t mem_flags)
 {
         /* Make sure the endpoint has been added to xHC schedule */
-        xhci_dbg(xhci, "Endpoint state = 0x%x\n", ep_state);
         switch (ep_state) {
         case EP_STATE_DISABLED:
                 /*
@@ -2189,21 +2440,19 @@ static int prepare_ring(struct xhci_hcd *xhci, struct xhci_ring *ep_ring,
                 struct xhci_ring *ring = ep_ring;
                 union xhci_trb *next;
 
-                xhci_dbg(xhci, "prepare_ring: pointing to link trb\n");
                 next = ring->enqueue;
 
                 while (last_trb(xhci, ring, ring->enq_seg, next)) {
-
                         /* If we're not dealing with 0.95 hardware,
                          * clear the chain bit.
                          */
                         if (!xhci_link_trb_quirk(xhci))
-                                next->link.control &= ~TRB_CHAIN;
+                                next->link.control &= cpu_to_le32(~TRB_CHAIN);
                         else
-                                next->link.control |= TRB_CHAIN;
+                                next->link.control |= cpu_to_le32(TRB_CHAIN);
 
                         wmb();
-                        next->link.control ^= (u32) TRB_CYCLE;
+                        next->link.control ^= cpu_to_le32((u32) TRB_CYCLE);
 
                         /* Toggle the cycle bit after the last ring segment. */
                         if (last_trb_on_last_seg(xhci, ring, ring->enq_seg, next)) {
@@ -2246,8 +2495,8 @@ static int prepare_transfer(struct xhci_hcd *xhci,
         }
 
         ret = prepare_ring(xhci, ep_ring,
-                        ep_ctx->ep_info & EP_STATE_MASK,
-                        num_trbs, mem_flags);
+                           le32_to_cpu(ep_ctx->ep_info) & EP_STATE_MASK,
+                           num_trbs, mem_flags);
         if (ret)
                 return ret;
 
@@ -2258,7 +2507,7 @@ static int prepare_transfer(struct xhci_hcd *xhci,
         INIT_LIST_HEAD(&td->cancelled_td_list);
 
         if (td_index == 0) {
-                ret = usb_hcd_link_urb_to_ep(xhci_to_hcd(xhci), urb);
+                ret = usb_hcd_link_urb_to_ep(bus_to_hcd(urb->dev->bus), urb);
                 if (unlikely(ret)) {
                         xhci_urb_free_priv(xhci, urb_priv);
                         urb->hcpriv = NULL;
@@ -2294,12 +2543,13 @@ static unsigned int count_sg_trbs_needed(struct xhci_hcd *xhci, struct urb *urb)
 
                 /* Scatter gather list entries may cross 64KB boundaries */
                 running_total = TRB_MAX_BUFF_SIZE -
-                        (sg_dma_address(sg) & ((1 << TRB_MAX_BUFF_SHIFT) - 1));
+                        (sg_dma_address(sg) & (TRB_MAX_BUFF_SIZE - 1));
+                running_total &= TRB_MAX_BUFF_SIZE - 1;
                 if (running_total != 0)
                         num_trbs++;
 
                 /* How many more 64KB chunks to transfer, how many more TRBs? */
-                while (running_total < sg_dma_len(sg)) {
+                while (running_total < sg_dma_len(sg) && running_total < temp) {
                         num_trbs++;
                         running_total += TRB_MAX_BUFF_SIZE;
                 }
@@ -2314,7 +2564,8 @@ static unsigned int count_sg_trbs_needed(struct xhci_hcd *xhci, struct urb *urb)
         }
         xhci_dbg(xhci, "\n");
         if (!in_interrupt())
-                dev_dbg(&urb->dev->dev, "ep %#x - urb len = %d, sglist used, num_trbs = %d\n",
+                xhci_dbg(xhci, "ep %#x - urb len = %d, sglist used, "
+                                "num_trbs = %d\n",
                                 urb->ep->desc.bEndpointAddress,
                                 urb->transfer_buffer_length,
                                 num_trbs);
@@ -2324,11 +2575,11 @@ static unsigned int count_sg_trbs_needed(struct xhci_hcd *xhci, struct urb *urb)
 static void check_trb_math(struct urb *urb, int num_trbs, int running_total)
 {
         if (num_trbs != 0)
-                dev_dbg(&urb->dev->dev, "%s - ep %#x - Miscalculated number of "
+                dev_err(&urb->dev->dev, "%s - ep %#x - Miscalculated number of "
                                 "TRBs, %d left\n", __func__,
                                 urb->ep->desc.bEndpointAddress, num_trbs);
         if (running_total != urb->transfer_buffer_length)
-                dev_dbg(&urb->dev->dev, "%s - ep %#x - Miscalculated tx length, "
+                dev_err(&urb->dev->dev, "%s - ep %#x - Miscalculated tx length, "
                                 "queued %#x (%d), asked for %#x (%d)\n",
                                 __func__,
                                 urb->ep->desc.bEndpointAddress,
@@ -2339,15 +2590,18 @@ static void check_trb_math(struct urb *urb, int num_trbs, int running_total)
 
 static void giveback_first_trb(struct xhci_hcd *xhci, int slot_id,
                 unsigned int ep_index, unsigned int stream_id, int start_cycle,
-                struct xhci_generic_trb *start_trb, struct xhci_td *td)
+                struct xhci_generic_trb *start_trb)
 {
         /*
          * Pass all the TRBs to the hardware at once and make sure this write
          * isn't reordered.
          */
         wmb();
-        start_trb->field[3] |= start_cycle;
-        ring_ep_doorbell(xhci, slot_id, ep_index, stream_id);
+        if (start_cycle)
+                start_trb->field[3] |= cpu_to_le32(start_cycle);
+        else
+                start_trb->field[3] &= cpu_to_le32(~TRB_CYCLE);
+        xhci_ring_ep_doorbell(xhci, slot_id, ep_index, stream_id);
 }
 
 /*
@@ -2364,7 +2618,7 @@ int xhci_queue_intr_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
         int xhci_interval;
         int ep_interval;
 
-        xhci_interval = EP_INTERVAL_TO_UFRAMES(ep_ctx->ep_info);
+        xhci_interval = EP_INTERVAL_TO_UFRAMES(le32_to_cpu(ep_ctx->ep_info));
         ep_interval = urb->interval;
         /* Convert to microframes */
         if (urb->dev->speed == USB_SPEED_LOW ||
@@ -2374,7 +2628,7 @@ int xhci_queue_intr_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
          * to set the polling interval (once the API is added).
          */
         if (xhci_interval != ep_interval) {
-                if (!printk_ratelimit())
+                if (printk_ratelimit())
                         dev_dbg(&urb->dev->dev, "Driver uses different interval"
                                         " (%d microframe%s) than xHCI "
                                         "(%d microframe%s)\n",
@@ -2406,6 +2660,35 @@ static u32 xhci_td_remainder(unsigned int remainder)
                 return (remainder >> 10) << 17;
 }
 
+/*
+ * For xHCI 1.0 host controllers, TD size is the number of packets remaining in
+ * the TD (*not* including this TRB).
+ *
+ * Total TD packet count = total_packet_count =
+ *     roundup(TD size in bytes / wMaxPacketSize)
+ *
+ * Packets transferred up to and including this TRB = packets_transferred =
+ *     rounddown(total bytes transferred including this TRB / wMaxPacketSize)
+ *
+ * TD size = total_packet_count - packets_transferred
+ *
+ * It must fit in bits 21:17, so it can't be bigger than 31.
+ */
+
+static u32 xhci_v1_0_td_remainder(int running_total, int trb_buff_len,
+                unsigned int total_packet_count, struct urb *urb)
+{
+        int packets_transferred;
+
+        /* All the TRB queueing functions don't count the current TRB in
+         * running_total.
+         */
+        packets_transferred = (running_total + trb_buff_len) /
+                le16_to_cpu(urb->ep->desc.wMaxPacketSize);
+
+        return xhci_td_remainder(total_packet_count - packets_transferred);
+}
+
 static int queue_bulk_sg_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                 struct urb *urb, int slot_id, unsigned int ep_index)
 {
@@ -2416,6 +2699,7 @@ static int queue_bulk_sg_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
         struct scatterlist *sg;
         int num_sgs;
         int trb_buff_len, this_sg_len, running_total;
+        unsigned int total_packet_count;
         bool first_trb;
         u64 addr;
         bool more_trbs_coming;
@@ -2429,6 +2713,8 @@ static int queue_bulk_sg_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
 
         num_trbs = count_sg_trbs_needed(xhci, urb);
         num_sgs = urb->num_sgs;
+        total_packet_count = roundup(urb->transfer_buffer_length,
+                        le16_to_cpu(urb->ep->desc.wMaxPacketSize));
 
         trb_buff_len = prepare_transfer(xhci, xhci->devs[slot_id],
                         ep_index, urb->stream_id,
@@ -2460,8 +2746,7 @@ static int queue_bulk_sg_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
         sg = urb->sg;
         addr = (u64) sg_dma_address(sg);
         this_sg_len = sg_dma_len(sg);
-        trb_buff_len = TRB_MAX_BUFF_SIZE -
-                (addr & ((1 << TRB_MAX_BUFF_SHIFT) - 1));
+        trb_buff_len = TRB_MAX_BUFF_SIZE - (addr & (TRB_MAX_BUFF_SIZE - 1));
         trb_buff_len = min_t(int, trb_buff_len, this_sg_len);
         if (trb_buff_len > urb->transfer_buffer_length)
                 trb_buff_len = urb->transfer_buffer_length;
@@ -2476,9 +2761,11 @@ static int queue_bulk_sg_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                 u32 remainder = 0;
 
                 /* Don't change the cycle bit of the first TRB until later */
-                if (first_trb)
+                if (first_trb) {
                         first_trb = false;
-                else
+                        if (start_cycle == 0)
+                                field |= 0x1;
+                } else
                         field |= ep_ring->cycle_state;
 
                 /* Chain all the TRBs together; clear the chain bit in the last
@@ -2491,23 +2778,37 @@ static int queue_bulk_sg_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                         td->last_trb = ep_ring->enqueue;
                         field |= TRB_IOC;
                 }
+
+                /* Only set interrupt on short packet for IN endpoints */
+                if (usb_urb_dir_in(urb))
+                        field |= TRB_ISP;
+
                 xhci_dbg(xhci, " sg entry: dma = %#x, len = %#x (%d), "
                                 "64KB boundary at %#x, end dma = %#x\n",
                                 (unsigned int) addr, trb_buff_len, trb_buff_len,
                                 (unsigned int) (addr + TRB_MAX_BUFF_SIZE) & ~(TRB_MAX_BUFF_SIZE - 1),
                                 (unsigned int) addr + trb_buff_len);
                 if (TRB_MAX_BUFF_SIZE -
-                                (addr & ((1 << TRB_MAX_BUFF_SHIFT) - 1)) < trb_buff_len) {
+                                (addr & (TRB_MAX_BUFF_SIZE - 1)) < trb_buff_len) {
                         xhci_warn(xhci, "WARN: sg dma xfer crosses 64KB boundaries!\n");
                         xhci_dbg(xhci, "Next boundary at %#x, end dma = %#x\n",
                                         (unsigned int) (addr + TRB_MAX_BUFF_SIZE) & ~(TRB_MAX_BUFF_SIZE - 1),
                                         (unsigned int) addr + trb_buff_len);
                 }
-                remainder = xhci_td_remainder(urb->transfer_buffer_length -
-                                running_total) ;
+
+                /* Set the TRB length, TD size, and interrupter fields. */
+                if (xhci->hci_version < 0x100) {
+                        remainder = xhci_td_remainder(
+                                        urb->transfer_buffer_length -
+                                        running_total);
+                } else {
+                        remainder = xhci_v1_0_td_remainder(running_total,
+                                        trb_buff_len, total_packet_count, urb);
+                }
                 length_field = TRB_LEN(trb_buff_len) |
                         remainder |
                         TRB_INTR_TARGET(0);
+
                 if (num_trbs > 1)
                         more_trbs_coming = true;
                 else
@@ -2516,12 +2817,7 @@ static int queue_bulk_sg_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                                 lower_32_bits(addr),
                                 upper_32_bits(addr),
                                 length_field,
-                                /* We always want to know if the TRB was short,
-                                 * or we won't get an event when it completes.
-                                 * (Unless we use event data TRBs, which are a
-                                 * waste of space and HC resources.)
-                                 */
-                                field | TRB_ISP | TRB_TYPE(TRB_NORMAL));
+                                field | TRB_TYPE(TRB_NORMAL));
                 --num_trbs;
                 running_total += trb_buff_len;
 
@@ -2541,7 +2837,7 @@ static int queue_bulk_sg_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                 }
 
                 trb_buff_len = TRB_MAX_BUFF_SIZE -
-                        (addr & ((1 << TRB_MAX_BUFF_SHIFT) - 1));
+                        (addr & (TRB_MAX_BUFF_SIZE - 1));
                 trb_buff_len = min_t(int, trb_buff_len, this_sg_len);
                 if (running_total + trb_buff_len > urb->transfer_buffer_length)
                         trb_buff_len =
@@ -2550,7 +2846,7 @@ static int queue_bulk_sg_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
 
         check_trb_math(urb, num_trbs, running_total);
         giveback_first_trb(xhci, slot_id, ep_index, urb->stream_id,
-                        start_cycle, start_trb, td);
+                        start_cycle, start_trb);
         return 0;
 }
 
@@ -2569,6 +2865,7 @@ int xhci_queue_bulk_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
         u32 field, length_field;
 
         int running_total, trb_buff_len, ret;
+        unsigned int total_packet_count;
         u64 addr;
 
         if (urb->num_sgs)
@@ -2581,7 +2878,8 @@ int xhci_queue_bulk_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
         num_trbs = 0;
         /* How much data is (potentially) left before the 64KB boundary? */
         running_total = TRB_MAX_BUFF_SIZE -
-                (urb->transfer_dma & ((1 << TRB_MAX_BUFF_SHIFT) - 1));
+                (urb->transfer_dma & (TRB_MAX_BUFF_SIZE - 1));
+        running_total &= TRB_MAX_BUFF_SIZE - 1;
 
         /* If there's some data on this 64KB chunk, or we have to send a
          * zero-length transfer, we need at least one TRB
@@ -2596,7 +2894,8 @@ int xhci_queue_bulk_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
         /* FIXME: this doesn't deal with URB_ZERO_PACKET - need one more */
 
         if (!in_interrupt())
-                dev_dbg(&urb->dev->dev, "ep %#x - urb len = %#x (%d), addr = %#llx, num_trbs = %d\n",
+                xhci_dbg(xhci, "ep %#x - urb len = %#x (%d), "
+                                "addr = %#llx, num_trbs = %d\n",
                                 urb->ep->desc.bEndpointAddress,
                                 urb->transfer_buffer_length,
                                 urb->transfer_buffer_length,
@@ -2621,11 +2920,13 @@ int xhci_queue_bulk_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
         start_cycle = ep_ring->cycle_state;
 
         running_total = 0;
+        total_packet_count = roundup(urb->transfer_buffer_length,
+                        le16_to_cpu(urb->ep->desc.wMaxPacketSize));
         /* How much data is in the first TRB? */
         addr = (u64) urb->transfer_dma;
         trb_buff_len = TRB_MAX_BUFF_SIZE -
-                (urb->transfer_dma & ((1 << TRB_MAX_BUFF_SHIFT) - 1));
-        if (urb->transfer_buffer_length < trb_buff_len)
+                (urb->transfer_dma & (TRB_MAX_BUFF_SIZE - 1));
+        if (trb_buff_len > urb->transfer_buffer_length)
                 trb_buff_len = urb->transfer_buffer_length;
 
         first_trb = true;
@@ -2636,9 +2937,11 @@ int xhci_queue_bulk_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                 field = 0;
 
                 /* Don't change the cycle bit of the first TRB until later */
-                if (first_trb)
+                if (first_trb) {
                         first_trb = false;
-                else
+                        if (start_cycle == 0)
+                                field |= 0x1;
+                } else
                         field |= ep_ring->cycle_state;
 
                 /* Chain all the TRBs together; clear the chain bit in the last
@@ -2651,11 +2954,24 @@ int xhci_queue_bulk_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                         td->last_trb = ep_ring->enqueue;
                         field |= TRB_IOC;
                 }
-                remainder = xhci_td_remainder(urb->transfer_buffer_length -
-                                running_total);
+
+                /* Only set interrupt on short packet for IN endpoints */
+                if (usb_urb_dir_in(urb))
+                        field |= TRB_ISP;
+
+                /* Set the TRB length, TD size, and interrupter fields. */
+                if (xhci->hci_version < 0x100) {
+                        remainder = xhci_td_remainder(
+                                        urb->transfer_buffer_length -
+                                        running_total);
+                } else {
+                        remainder = xhci_v1_0_td_remainder(running_total,
+                                        trb_buff_len, total_packet_count, urb);
+                }
                 length_field = TRB_LEN(trb_buff_len) |
                         remainder |
                         TRB_INTR_TARGET(0);
+
                 if (num_trbs > 1)
                         more_trbs_coming = true;
                 else
@@ -2664,12 +2980,7 @@ int xhci_queue_bulk_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                                 lower_32_bits(addr),
                                 upper_32_bits(addr),
                                 length_field,
-                                /* We always want to know if the TRB was short,
-                                 * or we won't get an event when it completes.
-                                 * (Unless we use event data TRBs, which are a
-                                 * waste of space and HC resources.)
-                                 */
-                                field | TRB_ISP | TRB_TYPE(TRB_NORMAL));
+                                field | TRB_TYPE(TRB_NORMAL));
                 --num_trbs;
                 running_total += trb_buff_len;
 
@@ -2682,7 +2993,7 @@ int xhci_queue_bulk_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
 
         check_trb_math(urb, num_trbs, running_total);
         giveback_first_trb(xhci, slot_id, ep_index, urb->stream_id,
-                        start_cycle, start_trb, td);
+                        start_cycle, start_trb);
         return 0;
 }
 
@@ -2743,16 +3054,35 @@ int xhci_queue_ctrl_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
         /* Queue setup TRB - see section 6.4.1.2.1 */
         /* FIXME better way to translate setup_packet into two u32 fields? */
         setup = (struct usb_ctrlrequest *) urb->setup_packet;
+        field = 0;
+        field |= TRB_IDT | TRB_TYPE(TRB_SETUP);
+        if (start_cycle == 0)
+                field |= 0x1;
+
+        /* xHCI 1.0 6.4.1.2.1: Transfer Type field */
+        if (xhci->hci_version == 0x100) {
+                if (urb->transfer_buffer_length > 0) {
+                        if (setup->bRequestType & USB_DIR_IN)
+                                field |= TRB_TX_TYPE(TRB_DATA_IN);
+                        else
+                                field |= TRB_TX_TYPE(TRB_DATA_OUT);
+                }
+        }
+
         queue_trb(xhci, ep_ring, false, true,
-                        /* FIXME endianness is probably going to bite my ass here. */
-                        setup->bRequestType | setup->bRequest << 8 | setup->wValue << 16,
-                        setup->wIndex | setup->wLength << 16,
-                        TRB_LEN(8) | TRB_INTR_TARGET(0),
-                        /* Immediate data in pointer */
-                        TRB_IDT | TRB_TYPE(TRB_SETUP));
+                  setup->bRequestType | setup->bRequest << 8 | le16_to_cpu(setup->wValue) << 16,
+                  le16_to_cpu(setup->wIndex) | le16_to_cpu(setup->wLength) << 16,
+                  TRB_LEN(8) | TRB_INTR_TARGET(0),
+                  /* Immediate data in pointer */
+                  field);
 
         /* If there's data, queue data TRBs */
-        field = 0;
+        /* Only set interrupt on short packet for IN endpoints */
+        if (usb_urb_dir_in(urb))
+                field = TRB_ISP | TRB_TYPE(TRB_DATA);
+        else
+                field = TRB_TYPE(TRB_DATA);
+
         length_field = TRB_LEN(urb->transfer_buffer_length) |
                 xhci_td_remainder(urb->transfer_buffer_length) |
                 TRB_INTR_TARGET(0);
@@ -2763,8 +3093,7 @@ int xhci_queue_ctrl_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                                 lower_32_bits(urb->transfer_dma),
                                 upper_32_bits(urb->transfer_dma),
                                 length_field,
-                                /* Event on short tx */
-                                field | TRB_ISP | TRB_TYPE(TRB_DATA) | ep_ring->cycle_state);
+                                field | ep_ring->cycle_state);
         }
 
         /* Save the DMA address of the last TRB in the TD */
@@ -2784,7 +3113,7 @@ int xhci_queue_ctrl_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                         field | TRB_IOC | TRB_TYPE(TRB_STATUS) | ep_ring->cycle_state);
 
         giveback_first_trb(xhci, slot_id, ep_index, 0,
-                        start_cycle, start_trb, td);
+                        start_cycle, start_trb);
         return 0;
 }
 
@@ -2797,8 +3126,8 @@ static int count_isoc_trbs_needed(struct xhci_hcd *xhci,
         addr = (u64) (urb->transfer_dma + urb->iso_frame_desc[i].offset);
         td_len = urb->iso_frame_desc[i].length;
 
-        running_total = TRB_MAX_BUFF_SIZE -
-                        (addr & ((1 << TRB_MAX_BUFF_SHIFT) - 1));
+        running_total = TRB_MAX_BUFF_SIZE - (addr & (TRB_MAX_BUFF_SIZE - 1));
+        running_total &= TRB_MAX_BUFF_SIZE - 1;
         if (running_total != 0)
                 num_trbs++;
 
@@ -2810,6 +3139,63 @@ static int count_isoc_trbs_needed(struct xhci_hcd *xhci,
         return num_trbs;
 }
 
+/*
+ * The transfer burst count field of the isochronous TRB defines the number of
+ * bursts that are required to move all packets in this TD.  Only SuperSpeed
+ * devices can burst up to bMaxBurst number of packets per service interval.
+ * This field is zero based, meaning a value of zero in the field means one
+ * burst.  Basically, for everything but SuperSpeed devices, this field will be
+ * zero.  Only xHCI 1.0 host controllers support this field.
+ */
+static unsigned int xhci_get_burst_count(struct xhci_hcd *xhci,
+                struct usb_device *udev,
+                struct urb *urb, unsigned int total_packet_count)
+{
+        unsigned int max_burst;
+
+        if (xhci->hci_version < 0x100 || udev->speed != USB_SPEED_SUPER)
+                return 0;
+
+        max_burst = urb->ep->ss_ep_comp.bMaxBurst;
+        return roundup(total_packet_count, max_burst + 1) - 1;
+}
+
+/*
+ * Returns the number of packets in the last "burst" of packets.  This field is
+ * valid for all speeds of devices.  USB 2.0 devices can only do one "burst", so
+ * the last burst packet count is equal to the total number of packets in the
+ * TD.  SuperSpeed endpoints can have up to 3 bursts.  All but the last burst
+ * must contain (bMaxBurst + 1) number of packets, but the last burst can
+ * contain 1 to (bMaxBurst + 1) packets.
+ */
+static unsigned int xhci_get_last_burst_packet_count(struct xhci_hcd *xhci,
+                struct usb_device *udev,
+                struct urb *urb, unsigned int total_packet_count)
+{
+        unsigned int max_burst;
+        unsigned int residue;
+
+        if (xhci->hci_version < 0x100)
+                return 0;
+
+        switch (udev->speed) {
+        case USB_SPEED_SUPER:
+                /* bMaxBurst is zero based: 0 means 1 packet per burst */
+                max_burst = urb->ep->ss_ep_comp.bMaxBurst;
+                residue = total_packet_count % (max_burst + 1);
+                /* If residue is zero, the last burst contains (max_burst + 1)
+                 * number of packets, but the TLBPC field is zero-based.
+                 */
+                if (residue == 0)
+                        return max_burst;
+                return residue - 1;
+        default:
+                if (total_packet_count == 0)
+                        return 0;
+                return total_packet_count - 1;
+        }
+}
+
 /* This is for isoc transfer */
 static int xhci_queue_isoc_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                 struct urb *urb, int slot_id, unsigned int ep_index)
@@ -2825,6 +3211,7 @@ static int xhci_queue_isoc_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
         int running_total, trb_buff_len, td_len, td_remain_len, ret;
         u64 start_addr, addr;
         int i, j;
+        bool more_trbs_coming;
 
         ep_ring = xhci->devs[slot_id]->eps[ep_index].ring;
 
@@ -2835,7 +3222,7 @@ static int xhci_queue_isoc_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
         }
 
         if (!in_interrupt())
-                dev_dbg(&urb->dev->dev, "ep %#x - urb len = %#x (%d),"
+                xhci_dbg(xhci, "ep %#x - urb len = %#x (%d),"
                                 " addr = %#llx, num_tds = %d\n",
                                 urb->ep->desc.bEndpointAddress,
                                 urb->transfer_buffer_length,
@@ -2849,12 +3236,22 @@ static int xhci_queue_isoc_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
 
         /* Queue the first TRB, even if it's zero-length */
         for (i = 0; i < num_tds; i++) {
-                first_trb = true;
+                unsigned int total_packet_count;
+                unsigned int burst_count;
+                unsigned int residue;
 
+                first_trb = true;
                 running_total = 0;
                 addr = start_addr + urb->iso_frame_desc[i].offset;
                 td_len = urb->iso_frame_desc[i].length;
                 td_remain_len = td_len;
+                /* FIXME: Ignoring zero-length packets, can those happen? */
+                total_packet_count = roundup(td_len,
+                                le16_to_cpu(urb->ep->desc.wMaxPacketSize));
+                burst_count = xhci_get_burst_count(xhci, urb->dev, urb,
+                                total_packet_count);
+                residue = xhci_get_last_burst_packet_count(xhci,
+                                urb->dev, urb, total_packet_count);
 
                 trbs_per_td = count_isoc_trbs_needed(xhci, urb, i);
 
@@ -2868,14 +3265,17 @@ static int xhci_queue_isoc_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
 
                 for (j = 0; j < trbs_per_td; j++) {
                         u32 remainder = 0;
-                        field = 0;
+                        field = TRB_TBC(burst_count) | TRB_TLBPC(residue);
 
                         if (first_trb) {
                                 /* Queue the isoc TRB */
                                 field |= TRB_TYPE(TRB_ISOC);
                                 /* Assume URB_ISO_ASAP is set */
                                 field |= TRB_SIA;
-                                if (i > 0)
+                                if (i == 0) {
+                                        if (start_cycle == 0)
+                                                field |= 0x1;
+                                } else
                                         field |= ep_ring->cycle_state;
                                 first_trb = false;
                         } else {
@@ -2884,15 +3284,26 @@ static int xhci_queue_isoc_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                                 field |= ep_ring->cycle_state;
                         }
 
+                        /* Only set interrupt on short packet for IN EPs */
+                        if (usb_urb_dir_in(urb))
+                                field |= TRB_ISP;
+
                         /* Chain all the TRBs together; clear the chain bit in
                          * the last TRB to indicate it's the last TRB in the
                          * chain.
                          */
                         if (j < trbs_per_td - 1) {
                                 field |= TRB_CHAIN;
+                                more_trbs_coming = true;
                         } else {
                                 td->last_trb = ep_ring->enqueue;
                                 field |= TRB_IOC;
+                                if (xhci->hci_version == 0x100) {
+                                        /* Set BEI bit except for the last td */
+                                        if (i < num_tds - 1)
+                                                field |= TRB_BEI;
+                                }
+                                more_trbs_coming = false;
                         }
 
                         /* Calculate TRB length */
@@ -2901,20 +3312,24 @@ static int xhci_queue_isoc_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                         if (trb_buff_len > td_remain_len)
                                 trb_buff_len = td_remain_len;
 
-                        remainder = xhci_td_remainder(td_len - running_total);
+                        /* Set the TRB length, TD size, & interrupter fields. */
+                        if (xhci->hci_version < 0x100) {
+                                remainder = xhci_td_remainder(
+                                                td_len - running_total);
+                        } else {
+                                remainder = xhci_v1_0_td_remainder(
+                                                running_total, trb_buff_len,
+                                                total_packet_count, urb);
+                        }
                         length_field = TRB_LEN(trb_buff_len) |
                                 remainder |
                                 TRB_INTR_TARGET(0);
-                        queue_trb(xhci, ep_ring, false, false,
+
+                        queue_trb(xhci, ep_ring, false, more_trbs_coming,
                                 lower_32_bits(addr),
                                 upper_32_bits(addr),
                                 length_field,
-                                /* We always want to know if the TRB was short,
-                                 * or we won't get an event when it completes.
-                                 * (Unless we use event data TRBs, which are a
-                                 * waste of space and HC resources.)
-                                 */
-                                field | TRB_ISP);
+                                field);
                         running_total += trb_buff_len;
 
                         addr += trb_buff_len;
@@ -2928,10 +3343,14 @@ static int xhci_queue_isoc_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                 }
         }
 
-        wmb();
-        start_trb->field[3] |= start_cycle;
+        if (xhci_to_hcd(xhci)->self.bandwidth_isoc_reqs == 0) {
+                if (xhci->quirks & XHCI_AMD_PLL_FIX)
+                        usb_amd_quirk_pll_disable();
+        }
+        xhci_to_hcd(xhci)->self.bandwidth_isoc_reqs++;
 
-        ring_ep_doorbell(xhci, slot_id, ep_index, urb->stream_id);
+        giveback_first_trb(xhci, slot_id, ep_index, urb->stream_id,
+                        start_cycle, start_trb);
         return 0;
 }
 
@@ -2966,8 +3385,8 @@ int xhci_queue_isoc_tx_prepare(struct xhci_hcd *xhci, gfp_t mem_flags,
         /* Check the ring to guarantee there is enough room for the whole urb.
          * Do not insert any td of the urb to the ring if the check failed.
          */
-        ret = prepare_ring(xhci, ep_ring, ep_ctx->ep_info & EP_STATE_MASK,
-                                num_trbs, mem_flags);
+        ret = prepare_ring(xhci, ep_ring, le32_to_cpu(ep_ctx->ep_info) & EP_STATE_MASK,
+                           num_trbs, mem_flags);
         if (ret)
                 return ret;
 
@@ -2979,7 +3398,7 @@ int xhci_queue_isoc_tx_prepare(struct xhci_hcd *xhci, gfp_t mem_flags,
                         urb->dev->speed == USB_SPEED_FULL)
                 urb->start_frame >>= 3;
 
-        xhci_interval = EP_INTERVAL_TO_UFRAMES(ep_ctx->ep_info);
+        xhci_interval = EP_INTERVAL_TO_UFRAMES(le32_to_cpu(ep_ctx->ep_info));
         ep_interval = urb->interval;
         /* Convert to microframes */
         if (urb->dev->speed == USB_SPEED_LOW ||
@@ -2989,7 +3408,7 @@ int xhci_queue_isoc_tx_prepare(struct xhci_hcd *xhci, gfp_t mem_flags,
          * to set the polling interval (once the API is added).
          */
         if (xhci_interval != ep_interval) {
-                if (!printk_ratelimit())
+                if (printk_ratelimit())
                         dev_dbg(&urb->dev->dev, "Driver uses different interval"
                                         " (%d microframe%s) than xHCI "
                                         "(%d microframe%s)\n",
@@ -3039,24 +3458,6 @@ static int queue_command(struct xhci_hcd *xhci, u32 field1, u32 field2,
         return 0;
 }
 
-/* Queue a no-op command on the command ring */
-static int queue_cmd_noop(struct xhci_hcd *xhci)
-{
-        return queue_command(xhci, 0, 0, 0, TRB_TYPE(TRB_CMD_NOOP), false);
-}
-
-/*
- * Place a no-op command on the command ring to test the command and
- * event ring.
- */
-void *xhci_setup_one_noop(struct xhci_hcd *xhci)
-{
-        if (queue_cmd_noop(xhci) < 0)
-                return NULL;
-        xhci->noops_submitted++;
-        return xhci_ring_cmd_db;
-}
-
 /* Queue a slot enable or disable request on the command ring */
 int xhci_queue_slot_control(struct xhci_hcd *xhci, u32 trb_type, u32 slot_id)
 {
@@ -3108,15 +3509,20 @@ int xhci_queue_evaluate_context(struct xhci_hcd *xhci, dma_addr_t in_ctx_ptr,
                         false);
 }
 
+/*
+ * Suspend is set to indicate "Stop Endpoint Command" is being issued to stop
+ * activity on an endpoint that is about to be suspended.
+ */
 int xhci_queue_stop_endpoint(struct xhci_hcd *xhci, int slot_id,
-                unsigned int ep_index)
+                unsigned int ep_index, int suspend)
 {
         u32 trb_slot_id = SLOT_ID_FOR_TRB(slot_id);
         u32 trb_ep_index = EP_ID_FOR_TRB(ep_index);
         u32 type = TRB_TYPE(TRB_STOP_RING);
+        u32 trb_suspend = SUSPEND_PORT_FOR_TRB(suspend);
 
         return queue_command(xhci, 0, 0, 0,
-                        trb_slot_id | trb_ep_index | type, false);
+                        trb_slot_id | trb_ep_index | type | trb_suspend, false);
 }
 
 /* Set Transfer Ring Dequeue Pointer command.
@@ -3132,6 +3538,7 @@ static int queue_set_tr_deq(struct xhci_hcd *xhci, int slot_id,
         u32 trb_ep_index = EP_ID_FOR_TRB(ep_index);
         u32 trb_stream_id = STREAM_ID_FOR_TRB(stream_id);
         u32 type = TRB_TYPE(TRB_SET_DEQ);
+        struct xhci_virt_ep *ep;
 
         addr = xhci_trb_virt_to_dma(deq_seg, deq_ptr);
         if (addr == 0) {
@@ -3140,6 +3547,14 @@ static int queue_set_tr_deq(struct xhci_hcd *xhci, int slot_id,
                                 deq_seg, deq_ptr);
                 return 0;
         }
+        ep = &xhci->devs[slot_id]->eps[ep_index];
+        if ((ep->ep_state & SET_DEQ_PENDING)) {
+                xhci_warn(xhci, "WARN Cannot submit Set TR Deq Ptr\n");
+                xhci_warn(xhci, "A Set TR Deq Ptr command is pending.\n");
+                return 0;
+        }
+        ep->queued_deq_seg = deq_seg;
+        ep->queued_deq_ptr = deq_ptr;
         return queue_command(xhci, lower_32_bits(addr) | cycle_state,
                         upper_32_bits(addr), trb_stream_id,
                         trb_slot_id | trb_ep_index | type, false);
diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c
index d5c550ea3e68..f5fe1ac301ab 100644
--- a/drivers/usb/host/xhci.c
+++ b/drivers/usb/host/xhci.c
@@ -93,23 +93,26 @@ void xhci_quiesce(struct xhci_hcd *xhci)
  *
  * Disable any IRQs and clear the run/stop bit.
  * HC will complete any current and actively pipelined transactions, and
- * should halt within 16 microframes of the run/stop bit being cleared.
+ * should halt within 16 ms of the run/stop bit being cleared.
  * Read HC Halted bit in the status register to see when the HC is finished.
- * XXX: shouldn't we set HC_STATE_HALT here somewhere?
  */
 int xhci_halt(struct xhci_hcd *xhci)
 {
+        int ret;
         xhci_dbg(xhci, "// Halt the HC\n");
         xhci_quiesce(xhci);
 
-        return handshake(xhci, &xhci->op_regs->status,
+        ret = handshake(xhci, &xhci->op_regs->status,
                         STS_HALT, STS_HALT, XHCI_MAX_HALT_USEC);
+        if (!ret)
+                xhci->xhc_state |= XHCI_STATE_HALTED;
+        return ret;
 }
 
 /*
  * Set the run bit and wait for the host to be running.
  */
-int xhci_start(struct xhci_hcd *xhci)
+static int xhci_start(struct xhci_hcd *xhci)
 {
         u32 temp;
         int ret;
@@ -130,11 +133,13 @@ int xhci_start(struct xhci_hcd *xhci)
                 xhci_err(xhci, "Host took too long to start, "
                                 "waited %u microseconds.\n",
                                 XHCI_MAX_HALT_USEC);
+        if (!ret)
+                xhci->xhc_state &= ~XHCI_STATE_HALTED;
         return ret;
 }
 
 /*
- * Reset a halted HC, and set the internal HC state to HC_STATE_HALT.
+ * Reset a halted HC.
  *
  * This resets pipelines, timers, counters, state machines, etc.
  * Transactions will be terminated immediately, and operational registers
@@ -156,8 +161,6 @@ int xhci_reset(struct xhci_hcd *xhci)
         command = xhci_readl(xhci, &xhci->op_regs->command);
         command |= CMD_RESET;
         xhci_writel(xhci, command, &xhci->op_regs->command);
-        /* XXX: Why does EHCI set this here?  Shouldn't other code do this? */
-        xhci_to_hcd(xhci)->state = HC_STATE_HALT;
 
         ret = handshake(xhci, &xhci->op_regs->command,
                         CMD_RESET, 0, 250 * 1000);
@@ -226,7 +229,8 @@ static int xhci_setup_msi(struct xhci_hcd *xhci)
 static int xhci_setup_msix(struct xhci_hcd *xhci)
 {
         int i, ret = 0;
-        struct pci_dev *pdev = to_pci_dev(xhci_to_hcd(xhci)->self.controller);
+        struct usb_hcd *hcd = xhci_to_hcd(xhci);
+        struct pci_dev *pdev = to_pci_dev(hcd->self.controller);
 
         /*
          * calculate number of msi-x vectors supported.
@@ -265,6 +269,7 @@ static int xhci_setup_msix(struct xhci_hcd *xhci)
                         goto disable_msix;
         }
 
+        hcd->msix_enabled = 1;
         return ret;
 
 disable_msix:
@@ -280,7 +285,8 @@ free_entries:
 /* Free any IRQs and disable MSI-X */
 static void xhci_cleanup_msix(struct xhci_hcd *xhci)
 {
-        struct pci_dev *pdev = to_pci_dev(xhci_to_hcd(xhci)->self.controller);
+        struct usb_hcd *hcd = xhci_to_hcd(xhci);
+        struct pci_dev *pdev = to_pci_dev(hcd->self.controller);
 
         xhci_free_irq(xhci);
 
@@ -292,6 +298,7 @@ static void xhci_cleanup_msix(struct xhci_hcd *xhci)
                 pci_disable_msi(pdev);
         }
 
+        hcd->msix_enabled = 0;
         return;
 }
 
@@ -325,7 +332,7 @@ int xhci_init(struct usb_hcd *hcd)
 
 
 #ifdef CONFIG_USB_XHCI_HCD_DEBUGGING
-void xhci_event_ring_work(unsigned long arg)
+static void xhci_event_ring_work(unsigned long arg)
 {
         unsigned long flags;
         int temp;
@@ -346,7 +353,6 @@ void xhci_event_ring_work(unsigned long arg)
 
         temp = xhci_readl(xhci, &xhci->ir_set->irq_pending);
         xhci_dbg(xhci, "ir_set 0 pending = 0x%x\n", temp);
-        xhci_dbg(xhci, "No-op commands handled = %d\n", xhci->noops_handled);
         xhci_dbg(xhci, "HC error bitmask = 0x%x\n", xhci->error_bitmask);
         xhci->error_bitmask = 0;
         xhci_dbg(xhci, "Event ring:\n");
@@ -366,10 +372,6 @@ void xhci_event_ring_work(unsigned long arg)
                         xhci_dbg_ep_rings(xhci, i, j, &xhci->devs[i]->eps[j]);
                 }
         }
-
-        if (xhci->noops_submitted != NUM_TEST_NOOPS)
-                if (xhci_setup_one_noop(xhci))
-                        xhci_ring_cmd_db(xhci);
         spin_unlock_irqrestore(&xhci->lock, flags);
 
         if (!xhci->zombie)
@@ -379,6 +381,21 @@ void xhci_event_ring_work(unsigned long arg)
 }
 #endif
 
+static int xhci_run_finished(struct xhci_hcd *xhci)
+{
+        if (xhci_start(xhci)) {
+                xhci_halt(xhci);
+                return -ENODEV;
+        }
+        xhci->shared_hcd->state = HC_STATE_RUNNING;
+
+        if (xhci->quirks & XHCI_NEC_HOST)
+                xhci_ring_cmd_db(xhci);
+
+        xhci_dbg(xhci, "Finished xhci_run for USB3 roothub\n");
+        return 0;
+}
+
 /*
  * Start the HC after it was halted.
  *
@@ -398,9 +415,14 @@ int xhci_run(struct usb_hcd *hcd)
         u32 ret;
         struct xhci_hcd *xhci = hcd_to_xhci(hcd);
         struct pci_dev  *pdev = to_pci_dev(xhci_to_hcd(xhci)->self.controller);
-        void (*doorbell)(struct xhci_hcd *) = NULL;
+
+        /* Start the xHCI host controller running only after the USB 2.0 roothub
+         * is setup.
+         */
 
         hcd->uses_new_polling = 1;
+        if (!usb_hcd_is_primary_hcd(hcd))
+                return xhci_run_finished(xhci);
 
         xhci_dbg(xhci, "xhci_run\n");
         /* unregister the legacy interrupt */
@@ -408,12 +430,19 @@ int xhci_run(struct usb_hcd *hcd)
                 free_irq(hcd->irq, hcd);
         hcd->irq = -1;
 
+        /* Some Fresco Logic host controllers advertise MSI, but fail to
+         * generate interrupts.  Don't even try to enable MSI.
+         */
+        if (xhci->quirks & XHCI_BROKEN_MSI)
+                goto legacy_irq;
+
         ret = xhci_setup_msix(xhci);
         if (ret)
                 /* fall back to msi*/
                 ret = xhci_setup_msi(xhci);
 
         if (ret) {
+legacy_irq:
                 /* fall back to legacy interrupt*/
                 ret = request_irq(pdev->irq, &usb_hcd_irq, IRQF_SHARED,
                                         hcd->irq_descr, hcd);
@@ -457,7 +486,6 @@ int xhci_run(struct usb_hcd *hcd)
         xhci_writel(xhci, temp, &xhci->ir_set->irq_control);
 
         /* Set the HCD state before we enable the irqs */
-        hcd->state = HC_STATE_RUNNING;
         temp = xhci_readl(xhci, &xhci->op_regs->command);
         temp |= (CMD_EIE);
         xhci_dbg(xhci, "// Enable interrupts, cmd = 0x%x.\n",
@@ -469,26 +497,29 @@ int xhci_run(struct usb_hcd *hcd)
                         xhci->ir_set, (unsigned int) ER_IRQ_ENABLE(temp));
         xhci_writel(xhci, ER_IRQ_ENABLE(temp),
                         &xhci->ir_set->irq_pending);
-        xhci_print_ir_set(xhci, xhci->ir_set, 0);
+        xhci_print_ir_set(xhci, 0);
 
-        if (NUM_TEST_NOOPS > 0)
-                doorbell = xhci_setup_one_noop(xhci);
         if (xhci->quirks & XHCI_NEC_HOST)
                 xhci_queue_vendor_command(xhci, 0, 0, 0,
                                 TRB_TYPE(TRB_NEC_GET_FW));
 
-        if (xhci_start(xhci)) {
-                xhci_halt(xhci);
-                return -ENODEV;
-        }
+        xhci_dbg(xhci, "Finished xhci_run for USB2 roothub\n");
+        return 0;
+}
 
-        if (doorbell)
-                (*doorbell)(xhci);
-        if (xhci->quirks & XHCI_NEC_HOST)
-                xhci_ring_cmd_db(xhci);
+static void xhci_only_stop_hcd(struct usb_hcd *hcd)
+{
+        struct xhci_hcd *xhci = hcd_to_xhci(hcd);
 
-        xhci_dbg(xhci, "Finished xhci_run\n");
-        return 0;
+        spin_lock_irq(&xhci->lock);
+        xhci_halt(xhci);
+
+        /* The shared_hcd is going to be deallocated shortly (the USB core only
+         * calls this function when allocation fails in usb_add_hcd(), or
+         * usb_remove_hcd() is called).  So we need to unset xHCI's pointer.
+         */
+        xhci->shared_hcd = NULL;
+        spin_unlock_irq(&xhci->lock);
 }
 
 /*
@@ -505,25 +536,37 @@ void xhci_stop(struct usb_hcd *hcd)
         u32 temp;
         struct xhci_hcd *xhci = hcd_to_xhci(hcd);
 
+        if (!usb_hcd_is_primary_hcd(hcd)) {
+                xhci_only_stop_hcd(xhci->shared_hcd);
+                return;
+        }
+
         spin_lock_irq(&xhci->lock);
+        /* Make sure the xHC is halted for a USB3 roothub
+         * (xhci_stop() could be called as part of failed init).
+         */
         xhci_halt(xhci);
         xhci_reset(xhci);
-        xhci_cleanup_msix(xhci);
         spin_unlock_irq(&xhci->lock);
 
+        xhci_cleanup_msix(xhci);
+
 #ifdef CONFIG_USB_XHCI_HCD_DEBUGGING
         /* Tell the event ring poll function not to reschedule */
         xhci->zombie = 1;
         del_timer_sync(&xhci->event_ring_timer);
 #endif
 
+        if (xhci->quirks & XHCI_AMD_PLL_FIX)
+                usb_amd_dev_put();
+
         xhci_dbg(xhci, "// Disabling event ring interrupts\n");
         temp = xhci_readl(xhci, &xhci->op_regs->status);
         xhci_writel(xhci, temp & ~STS_EINT, &xhci->op_regs->status);
         temp = xhci_readl(xhci, &xhci->ir_set->irq_pending);
         xhci_writel(xhci, ER_IRQ_DISABLE(temp),
                         &xhci->ir_set->irq_pending);
-        xhci_print_ir_set(xhci, xhci->ir_set, 0);
+        xhci_print_ir_set(xhci, 0);
 
         xhci_dbg(xhci, "cleaning up memory\n");
         xhci_mem_cleanup(xhci);
@@ -537,6 +580,8 @@ void xhci_stop(struct usb_hcd *hcd)
  * This is called when the machine is rebooting or halting.  We assume that the
  * machine will be powered off, and the HC's internal state will be reset.
  * Don't bother to free memory.
+ *
+ * This will only ever be called with the main usb_hcd (the USB3 roothub).
  */
 void xhci_shutdown(struct usb_hcd *hcd)
 {
@@ -544,13 +589,284 @@ void xhci_shutdown(struct usb_hcd *hcd)
 
         spin_lock_irq(&xhci->lock);
         xhci_halt(xhci);
-        xhci_cleanup_msix(xhci);
         spin_unlock_irq(&xhci->lock);
 
+        xhci_cleanup_msix(xhci);
+
         xhci_dbg(xhci, "xhci_shutdown completed - status = %x\n",
                     xhci_readl(xhci, &xhci->op_regs->status));
 }
 
+#ifdef CONFIG_PM
+static void xhci_save_registers(struct xhci_hcd *xhci)
+{
+        xhci->s3.command = xhci_readl(xhci, &xhci->op_regs->command);
+        xhci->s3.dev_nt = xhci_readl(xhci, &xhci->op_regs->dev_notification);
+        xhci->s3.dcbaa_ptr = xhci_read_64(xhci, &xhci->op_regs->dcbaa_ptr);
+        xhci->s3.config_reg = xhci_readl(xhci, &xhci->op_regs->config_reg);
+        xhci->s3.irq_pending = xhci_readl(xhci, &xhci->ir_set->irq_pending);
+        xhci->s3.irq_control = xhci_readl(xhci, &xhci->ir_set->irq_control);
+        xhci->s3.erst_size = xhci_readl(xhci, &xhci->ir_set->erst_size);
+        xhci->s3.erst_base = xhci_read_64(xhci, &xhci->ir_set->erst_base);
+        xhci->s3.erst_dequeue = xhci_read_64(xhci, &xhci->ir_set->erst_dequeue);
+}
+
+static void xhci_restore_registers(struct xhci_hcd *xhci)
+{
+        xhci_writel(xhci, xhci->s3.command, &xhci->op_regs->command);
+        xhci_writel(xhci, xhci->s3.dev_nt, &xhci->op_regs->dev_notification);
+        xhci_write_64(xhci, xhci->s3.dcbaa_ptr, &xhci->op_regs->dcbaa_ptr);
+        xhci_writel(xhci, xhci->s3.config_reg, &xhci->op_regs->config_reg);
+        xhci_writel(xhci, xhci->s3.irq_pending, &xhci->ir_set->irq_pending);
+        xhci_writel(xhci, xhci->s3.irq_control, &xhci->ir_set->irq_control);
+        xhci_writel(xhci, xhci->s3.erst_size, &xhci->ir_set->erst_size);
+        xhci_write_64(xhci, xhci->s3.erst_base, &xhci->ir_set->erst_base);
+}
+
+static void xhci_set_cmd_ring_deq(struct xhci_hcd *xhci)
+{
+        u64     val_64;
+
+        /* step 2: initialize command ring buffer */
+        val_64 = xhci_read_64(xhci, &xhci->op_regs->cmd_ring);
+        val_64 = (val_64 & (u64) CMD_RING_RSVD_BITS) |
+                (xhci_trb_virt_to_dma(xhci->cmd_ring->deq_seg,
+                                      xhci->cmd_ring->dequeue) &
+                 (u64) ~CMD_RING_RSVD_BITS) |
+                xhci->cmd_ring->cycle_state;
+        xhci_dbg(xhci, "// Setting command ring address to 0x%llx\n",
+                        (long unsigned long) val_64);
+        xhci_write_64(xhci, val_64, &xhci->op_regs->cmd_ring);
+}
+
+/*
+ * The whole command ring must be cleared to zero when we suspend the host.
+ *
+ * The host doesn't save the command ring pointer in the suspend well, so we
+ * need to re-program it on resume.  Unfortunately, the pointer must be 64-byte
+ * aligned, because of the reserved bits in the command ring dequeue pointer
+ * register.  Therefore, we can't just set the dequeue pointer back in the
+ * middle of the ring (TRBs are 16-byte aligned).
+ */
+static void xhci_clear_command_ring(struct xhci_hcd *xhci)
+{
+        struct xhci_ring *ring;
+        struct xhci_segment *seg;
+
+        ring = xhci->cmd_ring;
+        seg = ring->deq_seg;
+        do {
+                memset(seg->trbs, 0, SEGMENT_SIZE);
+                seg = seg->next;
+        } while (seg != ring->deq_seg);
+
+        /* Reset the software enqueue and dequeue pointers */
+        ring->deq_seg = ring->first_seg;
+        ring->dequeue = ring->first_seg->trbs;
+        ring->enq_seg = ring->deq_seg;
+        ring->enqueue = ring->dequeue;
+
+        /*
+         * Ring is now zeroed, so the HW should look for change of ownership
+         * when the cycle bit is set to 1.
+         */
+        ring->cycle_state = 1;
+
+        /*
+         * Reset the hardware dequeue pointer.
+         * Yes, this will need to be re-written after resume, but we're paranoid
+         * and want to make sure the hardware doesn't access bogus memory
+         * because, say, the BIOS or an SMI started the host without changing
+         * the command ring pointers.
+         */
+        xhci_set_cmd_ring_deq(xhci);
+}
+
+/*
+ * Stop HC (not bus-specific)
+ *
+ * This is called when the machine transition into S3/S4 mode.
+ *
+ */
+int xhci_suspend(struct xhci_hcd *xhci)
+{
+        int                     rc = 0;
+        struct usb_hcd          *hcd = xhci_to_hcd(xhci);
+        u32                     command;
+        int                     i;
+
+        spin_lock_irq(&xhci->lock);
+        clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
+        clear_bit(HCD_FLAG_HW_ACCESSIBLE, &xhci->shared_hcd->flags);
+        /* step 1: stop endpoint */
+        /* skipped assuming that port suspend has done */
+
+        /* step 2: clear Run/Stop bit */
+        command = xhci_readl(xhci, &xhci->op_regs->command);
+        command &= ~CMD_RUN;
+        xhci_writel(xhci, command, &xhci->op_regs->command);
+        if (handshake(xhci, &xhci->op_regs->status,
+                      STS_HALT, STS_HALT, 100*100)) {
+                xhci_warn(xhci, "WARN: xHC CMD_RUN timeout\n");
+                spin_unlock_irq(&xhci->lock);
+                return -ETIMEDOUT;
+        }
+        xhci_clear_command_ring(xhci);
+
+        /* step 3: save registers */
+        xhci_save_registers(xhci);
+
+        /* step 4: set CSS flag */
+        command = xhci_readl(xhci, &xhci->op_regs->command);
+        command |= CMD_CSS;
+        xhci_writel(xhci, command, &xhci->op_regs->command);
+        if (handshake(xhci, &xhci->op_regs->status, STS_SAVE, 0, 10*100)) {
+                xhci_warn(xhci, "WARN: xHC CMD_CSS timeout\n");
+                spin_unlock_irq(&xhci->lock);
+                return -ETIMEDOUT;
+        }
+        spin_unlock_irq(&xhci->lock);
+
+        /* step 5: remove core well power */
+        /* synchronize irq when using MSI-X */
+        if (xhci->msix_entries) {
+                for (i = 0; i < xhci->msix_count; i++)
+                        synchronize_irq(xhci->msix_entries[i].vector);
+        }
+
+        return rc;
+}
+
+/*
+ * start xHC (not bus-specific)
+ *
+ * This is called when the machine transition from S3/S4 mode.
+ *
+ */
+int xhci_resume(struct xhci_hcd *xhci, bool hibernated)
+{
+        u32                     command, temp = 0;
+        struct usb_hcd          *hcd = xhci_to_hcd(xhci);
+        struct usb_hcd          *secondary_hcd;
+        int                     retval;
+
+        /* Wait a bit if either of the roothubs need to settle from the
+         * transition into bus suspend.
+         */
+        if (time_before(jiffies, xhci->bus_state[0].next_statechange) ||
+                        time_before(jiffies,
+                                xhci->bus_state[1].next_statechange))
+                msleep(100);
+
+        spin_lock_irq(&xhci->lock);
+        if (xhci->quirks & XHCI_RESET_ON_RESUME)
+                hibernated = true;
+
+        if (!hibernated) {
+                /* step 1: restore register */
+                xhci_restore_registers(xhci);
+                /* step 2: initialize command ring buffer */
+                xhci_set_cmd_ring_deq(xhci);
+                /* step 3: restore state and start state*/
+                /* step 3: set CRS flag */
+                command = xhci_readl(xhci, &xhci->op_regs->command);
+                command |= CMD_CRS;
+                xhci_writel(xhci, command, &xhci->op_regs->command);
+                if (handshake(xhci, &xhci->op_regs->status,
+                              STS_RESTORE, 0, 10*100)) {
+                        xhci_dbg(xhci, "WARN: xHC CMD_CSS timeout\n");
+                        spin_unlock_irq(&xhci->lock);
+                        return -ETIMEDOUT;
+                }
+                temp = xhci_readl(xhci, &xhci->op_regs->status);
+        }
+
+        /* If restore operation fails, re-initialize the HC during resume */
+        if ((temp & STS_SRE) || hibernated) {
+                /* Let the USB core know _both_ roothubs lost power. */
+                usb_root_hub_lost_power(xhci->main_hcd->self.root_hub);
+                usb_root_hub_lost_power(xhci->shared_hcd->self.root_hub);
+
+                xhci_dbg(xhci, "Stop HCD\n");
+                xhci_halt(xhci);
+                xhci_reset(xhci);
+                spin_unlock_irq(&xhci->lock);
+                xhci_cleanup_msix(xhci);
+
+#ifdef CONFIG_USB_XHCI_HCD_DEBUGGING
+                /* Tell the event ring poll function not to reschedule */
+                xhci->zombie = 1;
+                del_timer_sync(&xhci->event_ring_timer);
+#endif
+
+                xhci_dbg(xhci, "// Disabling event ring interrupts\n");
+                temp = xhci_readl(xhci, &xhci->op_regs->status);
+                xhci_writel(xhci, temp & ~STS_EINT, &xhci->op_regs->status);
+                temp = xhci_readl(xhci, &xhci->ir_set->irq_pending);
+                xhci_writel(xhci, ER_IRQ_DISABLE(temp),
+                                &xhci->ir_set->irq_pending);
+                xhci_print_ir_set(xhci, 0);
+
+                xhci_dbg(xhci, "cleaning up memory\n");
+                xhci_mem_cleanup(xhci);
+                xhci_dbg(xhci, "xhci_stop completed - status = %x\n",
+                            xhci_readl(xhci, &xhci->op_regs->status));
+
+                /* USB core calls the PCI reinit and start functions twice:
+                 * first with the primary HCD, and then with the secondary HCD.
+                 * If we don't do the same, the host will never be started.
+                 */
+                if (!usb_hcd_is_primary_hcd(hcd))
+                        secondary_hcd = hcd;
+                else
+                        secondary_hcd = xhci->shared_hcd;
+
+                xhci_dbg(xhci, "Initialize the xhci_hcd\n");
+                retval = xhci_init(hcd->primary_hcd);
+                if (retval)
+                        return retval;
+                xhci_dbg(xhci, "Start the primary HCD\n");
+                retval = xhci_run(hcd->primary_hcd);
+                if (retval)
+                        goto failed_restart;
+
+                xhci_dbg(xhci, "Start the secondary HCD\n");
+                retval = xhci_run(secondary_hcd);
+                if (!retval) {
+                        set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
+                        set_bit(HCD_FLAG_HW_ACCESSIBLE,
+                                        &xhci->shared_hcd->flags);
+                }
+failed_restart:
+                hcd->state = HC_STATE_SUSPENDED;
+                xhci->shared_hcd->state = HC_STATE_SUSPENDED;
+                return retval;
+        }
+
+        /* step 4: set Run/Stop bit */
+        command = xhci_readl(xhci, &xhci->op_regs->command);
+        command |= CMD_RUN;
+        xhci_writel(xhci, command, &xhci->op_regs->command);
+        handshake(xhci, &xhci->op_regs->status, STS_HALT,
+                  0, 250 * 1000);
+
+        /* step 5: walk topology and initialize portsc,
+         * portpmsc and portli
+         */
+        /* this is done in bus_resume */
+
+        /* step 6: restart each of the previously
+         * Running endpoints by ringing their doorbells
+         */
+
+        set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
+        set_bit(HCD_FLAG_HW_ACCESSIBLE, &xhci->shared_hcd->flags);
+
+        spin_unlock_irq(&xhci->lock);
+        return 0;
+}
+#endif  /* CONFIG_PM */
+
 /*-------------------------------------------------------------------------*/
 
 /**
@@ -606,8 +922,12 @@ unsigned int xhci_last_valid_endpoint(u32 added_ctxs)
 /* Returns 1 if the arguments are OK;
  * returns 0 this is a root hub; returns -EINVAL for NULL pointers.
  */
-int xhci_check_args(struct usb_hcd *hcd, struct usb_device *udev,
-                struct usb_host_endpoint *ep, int check_ep, const char *func) {
+static int xhci_check_args(struct usb_hcd *hcd, struct usb_device *udev,
+                struct usb_host_endpoint *ep, int check_ep, bool check_virt_dev,
+                const char *func) {
+        struct xhci_hcd *xhci;
+        struct xhci_virt_device *virt_dev;
+
         if (!hcd || (check_ep && !ep) || !udev) {
                 printk(KERN_DEBUG "xHCI %s called with invalid args\n",
                                 func);
@@ -618,11 +938,24 @@ int xhci_check_args(struct usb_hcd *hcd, struct usb_device *udev,
                                 func);
                 return 0;
         }
-        if (!udev->slot_id) {
-                printk(KERN_DEBUG "xHCI %s called with unaddressed device\n",
-                                func);
-                return -EINVAL;
+
+        if (check_virt_dev) {
+                xhci = hcd_to_xhci(hcd);
+                if (!udev->slot_id || !xhci->devs
+                        || !xhci->devs[udev->slot_id]) {
+                        printk(KERN_DEBUG "xHCI %s called with unaddressed "
+                                                "device\n", func);
+                        return -EINVAL;
+                }
+
+                virt_dev = xhci->devs[udev->slot_id];
+                if (virt_dev->udev != udev) {
+                        printk(KERN_DEBUG "xHCI %s called with udev and "
+                                          "virt_dev does not match\n", func);
+                        return -EINVAL;
+                }
         }
+
         return 1;
 }
 
@@ -649,8 +982,8 @@ static int xhci_check_maxpacket(struct xhci_hcd *xhci, unsigned int slot_id,
 
         out_ctx = xhci->devs[slot_id]->out_ctx;
         ep_ctx = xhci_get_ep_ctx(xhci, out_ctx, ep_index);
-        hw_max_packet_size = MAX_PACKET_DECODED(ep_ctx->ep_info2);
-        max_packet_size = urb->dev->ep0.desc.wMaxPacketSize;
+        hw_max_packet_size = MAX_PACKET_DECODED(le32_to_cpu(ep_ctx->ep_info2));
+        max_packet_size = le16_to_cpu(urb->dev->ep0.desc.wMaxPacketSize);
         if (hw_max_packet_size != max_packet_size) {
                 xhci_dbg(xhci, "Max Packet Size for ep 0 changed.\n");
                 xhci_dbg(xhci, "Max packet size in usb_device = %d\n",
@@ -664,15 +997,15 @@ static int xhci_check_maxpacket(struct xhci_hcd *xhci, unsigned int slot_id,
                                 xhci->devs[slot_id]->out_ctx, ep_index);
                 in_ctx = xhci->devs[slot_id]->in_ctx;
                 ep_ctx = xhci_get_ep_ctx(xhci, in_ctx, ep_index);
-                ep_ctx->ep_info2 &= ~MAX_PACKET_MASK;
-                ep_ctx->ep_info2 |= MAX_PACKET(max_packet_size);
+                ep_ctx->ep_info2 &= cpu_to_le32(~MAX_PACKET_MASK);
+                ep_ctx->ep_info2 |= cpu_to_le32(MAX_PACKET(max_packet_size));
 
                 /* Set up the input context flags for the command */
                 /* FIXME: This won't work if a non-default control endpoint
                  * changes max packet sizes.
                  */
                 ctrl_ctx = xhci_get_input_control_ctx(xhci, in_ctx);
-                ctrl_ctx->add_flags = EP0_FLAG;
+                ctrl_ctx->add_flags = cpu_to_le32(EP0_FLAG);
                 ctrl_ctx->drop_flags = 0;
 
                 xhci_dbg(xhci, "Slot %d input context\n", slot_id);
@@ -686,7 +1019,7 @@ static int xhci_check_maxpacket(struct xhci_hcd *xhci, unsigned int slot_id,
                 /* Clean up the input context for later use by bandwidth
                  * functions.
                  */
-                ctrl_ctx->add_flags = SLOT_FLAG;
+                ctrl_ctx->add_flags = cpu_to_le32(SLOT_FLAG);
         }
         return ret;
 }
@@ -704,18 +1037,13 @@ int xhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags)
         struct urb_priv *urb_priv;
         int size, i;
 
-        if (!urb || xhci_check_args(hcd, urb->dev, urb->ep, true, __func__) <= 0)
+        if (!urb || xhci_check_args(hcd, urb->dev, urb->ep,
+                                        true, true, __func__) <= 0)
                 return -EINVAL;
 
         slot_id = urb->dev->slot_id;
         ep_index = xhci_get_endpoint_index(&urb->ep->desc);
 
-        if (!xhci->devs || !xhci->devs[slot_id]) {
-                if (!in_interrupt())
-                        dev_warn(&urb->dev->dev, "WARN: urb submitted for dev with no Slot ID\n");
-                ret = -EINVAL;
-                goto exit;
-        }
         if (!HCD_HW_ACCESSIBLE(hcd)) {
                 if (!in_interrupt())
                         xhci_dbg(xhci, "urb submitted during PCI suspend\n");
@@ -904,13 +1232,13 @@ int xhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
         if (ret || !urb->hcpriv)
                 goto done;
         temp = xhci_readl(xhci, &xhci->op_regs->status);
-        if (temp == 0xffffffff) {
+        if (temp == 0xffffffff || (xhci->xhc_state & XHCI_STATE_HALTED)) {
                 xhci_dbg(xhci, "HW died, freeing TD.\n");
                 urb_priv = urb->hcpriv;
 
                 usb_hcd_unlink_urb_from_ep(hcd, urb);
                 spin_unlock_irqrestore(&xhci->lock, flags);
-                usb_hcd_giveback_urb(xhci_to_hcd(xhci), urb, -ESHUTDOWN);
+                usb_hcd_giveback_urb(hcd, urb, -ESHUTDOWN);
                 xhci_urb_free_priv(xhci, urb_priv);
                 return ret;
         }
@@ -956,7 +1284,7 @@ int xhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
                 ep->stop_cmd_timer.expires = jiffies +
                         XHCI_STOP_EP_CMD_TIMEOUT * HZ;
                 add_timer(&ep->stop_cmd_timer);
-                xhci_queue_stop_endpoint(xhci, urb->dev->slot_id, ep_index);
+                xhci_queue_stop_endpoint(xhci, urb->dev->slot_id, ep_index, 0);
                 xhci_ring_cmd_db(xhci);
         }
 done:
@@ -991,12 +1319,14 @@ int xhci_drop_endpoint(struct usb_hcd *hcd, struct usb_device *udev,
         u32 new_add_flags, new_drop_flags, new_slot_info;
         int ret;
 
-        ret = xhci_check_args(hcd, udev, ep, 1, __func__);
+        ret = xhci_check_args(hcd, udev, ep, 1, true, __func__);
         if (ret <= 0)
                 return ret;
         xhci = hcd_to_xhci(hcd);
-        xhci_dbg(xhci, "%s called for udev %p\n", __func__, udev);
+        if (xhci->xhc_state & XHCI_STATE_DYING)
+                return -ENODEV;
 
+        xhci_dbg(xhci, "%s called for udev %p\n", __func__, udev);
         drop_flag = xhci_get_endpoint_flag(&ep->desc);
         if (drop_flag == SLOT_FLAG || drop_flag == EP0_FLAG) {
                 xhci_dbg(xhci, "xHCI %s - can't drop slot or ep 0 %#x\n",
@@ -1004,12 +1334,6 @@ int xhci_drop_endpoint(struct usb_hcd *hcd, struct usb_device *udev,
                 return 0;
         }
 
-        if (!xhci->devs || !xhci->devs[udev->slot_id]) {
-                xhci_warn(xhci, "xHCI %s called with unaddressed device\n",
-                                __func__);
-                return -EINVAL;
-        }
-
         in_ctx = xhci->devs[udev->slot_id]->in_ctx;
         out_ctx = xhci->devs[udev->slot_id]->out_ctx;
         ctrl_ctx = xhci_get_input_control_ctx(xhci, in_ctx);
@@ -1018,27 +1342,30 @@ int xhci_drop_endpoint(struct usb_hcd *hcd, struct usb_device *udev,
         /* If the HC already knows the endpoint is disabled,
          * or the HCD has noted it is disabled, ignore this request
          */
-        if ((ep_ctx->ep_info & EP_STATE_MASK) == EP_STATE_DISABLED ||
-                        ctrl_ctx->drop_flags & xhci_get_endpoint_flag(&ep->desc)) {
+        if ((le32_to_cpu(ep_ctx->ep_info) & EP_STATE_MASK) ==
+            EP_STATE_DISABLED ||
+            le32_to_cpu(ctrl_ctx->drop_flags) &
+            xhci_get_endpoint_flag(&ep->desc)) {
                 xhci_warn(xhci, "xHCI %s called with disabled ep %p\n",
                                 __func__, ep);
                 return 0;
         }
 
-        ctrl_ctx->drop_flags |= drop_flag;
-        new_drop_flags = ctrl_ctx->drop_flags;
+        ctrl_ctx->drop_flags |= cpu_to_le32(drop_flag);
+        new_drop_flags = le32_to_cpu(ctrl_ctx->drop_flags);
 
-        ctrl_ctx->add_flags &= ~drop_flag;
-        new_add_flags = ctrl_ctx->add_flags;
+        ctrl_ctx->add_flags &= cpu_to_le32(~drop_flag);
+        new_add_flags = le32_to_cpu(ctrl_ctx->add_flags);
 
-        last_ctx = xhci_last_valid_endpoint(ctrl_ctx->add_flags);
+        last_ctx = xhci_last_valid_endpoint(le32_to_cpu(ctrl_ctx->add_flags));
         slot_ctx = xhci_get_slot_ctx(xhci, in_ctx);
         /* Update the last valid endpoint context, if we deleted the last one */
-        if ((slot_ctx->dev_info & LAST_CTX_MASK) > LAST_CTX(last_ctx)) {
-                slot_ctx->dev_info &= ~LAST_CTX_MASK;
-                slot_ctx->dev_info |= LAST_CTX(last_ctx);
+        if ((le32_to_cpu(slot_ctx->dev_info) & LAST_CTX_MASK) >
+            LAST_CTX(last_ctx)) {
+                slot_ctx->dev_info &= cpu_to_le32(~LAST_CTX_MASK);
+                slot_ctx->dev_info |= cpu_to_le32(LAST_CTX(last_ctx));
         }
-        new_slot_info = slot_ctx->dev_info;
+        new_slot_info = le32_to_cpu(slot_ctx->dev_info);
 
         xhci_endpoint_zero(xhci, xhci->devs[udev->slot_id], ep);
 
@@ -1076,15 +1403,18 @@ int xhci_add_endpoint(struct usb_hcd *hcd, struct usb_device *udev,
         u32 added_ctxs;
         unsigned int last_ctx;
         u32 new_add_flags, new_drop_flags, new_slot_info;
+        struct xhci_virt_device *virt_dev;
         int ret = 0;
 
-        ret = xhci_check_args(hcd, udev, ep, 1, __func__);
+        ret = xhci_check_args(hcd, udev, ep, 1, true, __func__);
         if (ret <= 0) {
                 /* So we won't queue a reset ep command for a root hub */
                 ep->hcpriv = NULL;
                 return ret;
         }
         xhci = hcd_to_xhci(hcd);
+        if (xhci->xhc_state & XHCI_STATE_DYING)
+                return -ENODEV;
 
         added_ctxs = xhci_get_endpoint_flag(&ep->desc);
         last_ctx = xhci_last_valid_endpoint(added_ctxs);
@@ -1098,21 +1428,30 @@ int xhci_add_endpoint(struct usb_hcd *hcd, struct usb_device *udev,
                 return 0;
         }
 
-        if (!xhci->devs || !xhci->devs[udev->slot_id]) {
-                xhci_warn(xhci, "xHCI %s called with unaddressed device\n",
-                                __func__);
-                return -EINVAL;
-        }
-
-        in_ctx = xhci->devs[udev->slot_id]->in_ctx;
-        out_ctx = xhci->devs[udev->slot_id]->out_ctx;
+        virt_dev = xhci->devs[udev->slot_id];
+        in_ctx = virt_dev->in_ctx;
+        out_ctx = virt_dev->out_ctx;
         ctrl_ctx = xhci_get_input_control_ctx(xhci, in_ctx);
         ep_index = xhci_get_endpoint_index(&ep->desc);
         ep_ctx = xhci_get_ep_ctx(xhci, out_ctx, ep_index);
+
+        /* If this endpoint is already in use, and the upper layers are trying
+         * to add it again without dropping it, reject the addition.
+         */
+        if (virt_dev->eps[ep_index].ring &&
+                        !(le32_to_cpu(ctrl_ctx->drop_flags) &
+                                xhci_get_endpoint_flag(&ep->desc))) {
+                xhci_warn(xhci, "Trying to add endpoint 0x%x "
+                                "without dropping it.\n",
+                                (unsigned int) ep->desc.bEndpointAddress);
+                return -EINVAL;
+        }
+
         /* If the HCD has already noted the endpoint is enabled,
          * ignore this request.
          */
-        if (ctrl_ctx->add_flags & xhci_get_endpoint_flag(&ep->desc)) {
+        if (le32_to_cpu(ctrl_ctx->add_flags) &
+            xhci_get_endpoint_flag(&ep->desc)) {
                 xhci_warn(xhci, "xHCI %s called with enabled ep %p\n",
                                 __func__, ep);
                 return 0;
@@ -1123,15 +1462,14 @@ int xhci_add_endpoint(struct usb_hcd *hcd, struct usb_device *udev,
          * process context, not interrupt context (or so documenation
          * for usb_set_interface() and usb_set_configuration() claim).
          */
-        if (xhci_endpoint_init(xhci, xhci->devs[udev->slot_id],
-                                udev, ep, GFP_NOIO) < 0) {
+        if (xhci_endpoint_init(xhci, virt_dev, udev, ep, GFP_NOIO) < 0) {
                 dev_dbg(&udev->dev, "%s - could not initialize ep %#x\n",
                                 __func__, ep->desc.bEndpointAddress);
                 return -ENOMEM;
         }
 
-        ctrl_ctx->add_flags |= added_ctxs;
-        new_add_flags = ctrl_ctx->add_flags;
+        ctrl_ctx->add_flags |= cpu_to_le32(added_ctxs);
+        new_add_flags = le32_to_cpu(ctrl_ctx->add_flags);
 
         /* If xhci_endpoint_disable() was called for this endpoint, but the
          * xHC hasn't been notified yet through the check_bandwidth() call,
@@ -1139,15 +1477,16 @@ int xhci_add_endpoint(struct usb_hcd *hcd, struct usb_device *udev,
          * descriptors.  We must drop and re-add this endpoint, so we leave the
          * drop flags alone.
          */
-        new_drop_flags = ctrl_ctx->drop_flags;
+        new_drop_flags = le32_to_cpu(ctrl_ctx->drop_flags);
 
         slot_ctx = xhci_get_slot_ctx(xhci, in_ctx);
         /* Update the last valid endpoint context, if we just added one past */
-        if ((slot_ctx->dev_info & LAST_CTX_MASK) < LAST_CTX(last_ctx)) {
-                slot_ctx->dev_info &= ~LAST_CTX_MASK;
-                slot_ctx->dev_info |= LAST_CTX(last_ctx);
+        if ((le32_to_cpu(slot_ctx->dev_info) & LAST_CTX_MASK) <
+            LAST_CTX(last_ctx)) {
+                slot_ctx->dev_info &= cpu_to_le32(~LAST_CTX_MASK);
+                slot_ctx->dev_info |= cpu_to_le32(LAST_CTX(last_ctx));
         }
-        new_slot_info = slot_ctx->dev_info;
+        new_slot_info = le32_to_cpu(slot_ctx->dev_info);
 
         /* Store the usb_device pointer for later use */
         ep->hcpriv = udev;
@@ -1177,9 +1516,9 @@ static void xhci_zero_in_ctx(struct xhci_hcd *xhci, struct xhci_virt_device *vir
         ctrl_ctx->drop_flags = 0;
         ctrl_ctx->add_flags = 0;
         slot_ctx = xhci_get_slot_ctx(xhci, virt_dev->in_ctx);
-        slot_ctx->dev_info &= ~LAST_CTX_MASK;
+        slot_ctx->dev_info &= cpu_to_le32(~LAST_CTX_MASK);
         /* Endpoint 0 is always valid */
-        slot_ctx->dev_info |= LAST_CTX(1);
+        slot_ctx->dev_info |= cpu_to_le32(LAST_CTX(1));
         for (i = 1; i < 31; ++i) {
                 ep_ctx = xhci_get_ep_ctx(xhci, virt_dev->in_ctx, i);
                 ep_ctx->ep_info = 0;
@@ -1190,7 +1529,7 @@ static void xhci_zero_in_ctx(struct xhci_hcd *xhci, struct xhci_virt_device *vir
 }
 
 static int xhci_configure_endpoint_result(struct xhci_hcd *xhci,
-                struct usb_device *udev, int *cmd_status)
+                struct usb_device *udev, u32 *cmd_status)
 {
         int ret;
 
@@ -1214,6 +1553,11 @@ static int xhci_configure_endpoint_result(struct xhci_hcd *xhci,
                                 "and endpoint is not disabled.\n");
                 ret = -EINVAL;
                 break;
+        case COMP_DEV_ERR:
+                dev_warn(&udev->dev, "ERROR: Incompatible device for endpoint "
+                                "configure command.\n");
+                ret = -ENODEV;
+                break;
         case COMP_SUCCESS:
                 dev_dbg(&udev->dev, "Successful Endpoint Configure command\n");
                 ret = 0;
@@ -1228,7 +1572,7 @@ static int xhci_configure_endpoint_result(struct xhci_hcd *xhci,
 }
 
 static int xhci_evaluate_context_result(struct xhci_hcd *xhci,
-                struct usb_device *udev, int *cmd_status)
+                struct usb_device *udev, u32 *cmd_status)
 {
         int ret;
         struct xhci_virt_device *virt_dev = xhci->devs[udev->slot_id];
@@ -1248,6 +1592,16 @@ static int xhci_evaluate_context_result(struct xhci_hcd *xhci,
                 xhci_dbg_ctx(xhci, virt_dev->out_ctx, 1);
                 ret = -EINVAL;
                 break;
+        case COMP_DEV_ERR:
+                dev_warn(&udev->dev, "ERROR: Incompatible device for evaluate "
+                                "context command.\n");
+                ret = -ENODEV;
+                break;
+        case COMP_MEL_ERR:
+                /* Max Exit Latency too large error */
+                dev_warn(&udev->dev, "WARN: Max Exit Latency too large\n");
+                ret = -EINVAL;
+                break;
         case COMP_SUCCESS:
                 dev_dbg(&udev->dev, "Successful evaluate context command\n");
                 ret = 0;
@@ -1261,6 +1615,113 @@ static int xhci_evaluate_context_result(struct xhci_hcd *xhci,
         return ret;
 }
 
+static u32 xhci_count_num_new_endpoints(struct xhci_hcd *xhci,
+                struct xhci_container_ctx *in_ctx)
+{
+        struct xhci_input_control_ctx *ctrl_ctx;
+        u32 valid_add_flags;
+        u32 valid_drop_flags;
+
+        ctrl_ctx = xhci_get_input_control_ctx(xhci, in_ctx);
+        /* Ignore the slot flag (bit 0), and the default control endpoint flag
+         * (bit 1).  The default control endpoint is added during the Address
+         * Device command and is never removed until the slot is disabled.
+         */
+        valid_add_flags = ctrl_ctx->add_flags >> 2;
+        valid_drop_flags = ctrl_ctx->drop_flags >> 2;
+
+        /* Use hweight32 to count the number of ones in the add flags, or
+         * number of endpoints added.  Don't count endpoints that are changed
+         * (both added and dropped).
+         */
+        return hweight32(valid_add_flags) -
+                hweight32(valid_add_flags & valid_drop_flags);
+}
+
+static unsigned int xhci_count_num_dropped_endpoints(struct xhci_hcd *xhci,
+                struct xhci_container_ctx *in_ctx)
+{
+        struct xhci_input_control_ctx *ctrl_ctx;
+        u32 valid_add_flags;
+        u32 valid_drop_flags;
+
+        ctrl_ctx = xhci_get_input_control_ctx(xhci, in_ctx);
+        valid_add_flags = ctrl_ctx->add_flags >> 2;
+        valid_drop_flags = ctrl_ctx->drop_flags >> 2;
+
+        return hweight32(valid_drop_flags) -
+                hweight32(valid_add_flags & valid_drop_flags);
+}
+
+/*
+ * We need to reserve the new number of endpoints before the configure endpoint
+ * command completes.  We can't subtract the dropped endpoints from the number
+ * of active endpoints until the command completes because we can oversubscribe
+ * the host in this case:
+ *
+ *  - the first configure endpoint command drops more endpoints than it adds
+ *  - a second configure endpoint command that adds more endpoints is queued
+ *  - the first configure endpoint command fails, so the config is unchanged
+ *  - the second command may succeed, even though there isn't enough resources
+ *
+ * Must be called with xhci->lock held.
+ */
+static int xhci_reserve_host_resources(struct xhci_hcd *xhci,
+                struct xhci_container_ctx *in_ctx)
+{
+        u32 added_eps;
+
+        added_eps = xhci_count_num_new_endpoints(xhci, in_ctx);
+        if (xhci->num_active_eps + added_eps > xhci->limit_active_eps) {
+                xhci_dbg(xhci, "Not enough ep ctxs: "
+                                "%u active, need to add %u, limit is %u.\n",
+                                xhci->num_active_eps, added_eps,
+                                xhci->limit_active_eps);
+                return -ENOMEM;
+        }
+        xhci->num_active_eps += added_eps;
+        xhci_dbg(xhci, "Adding %u ep ctxs, %u now active.\n", added_eps,
+                        xhci->num_active_eps);
+        return 0;
+}
+
+/*
+ * The configure endpoint was failed by the xHC for some other reason, so we
+ * need to revert the resources that failed configuration would have used.
+ *
+ * Must be called with xhci->lock held.
+ */
+static void xhci_free_host_resources(struct xhci_hcd *xhci,
+                struct xhci_container_ctx *in_ctx)
+{
+        u32 num_failed_eps;
+
+        num_failed_eps = xhci_count_num_new_endpoints(xhci, in_ctx);
+        xhci->num_active_eps -= num_failed_eps;
+        xhci_dbg(xhci, "Removing %u failed ep ctxs, %u now active.\n",
+                        num_failed_eps,
+                        xhci->num_active_eps);
+}
+
+/*
+ * Now that the command has completed, clean up the active endpoint count by
+ * subtracting out the endpoints that were dropped (but not changed).
+ *
+ * Must be called with xhci->lock held.
+ */
+static void xhci_finish_resource_reservation(struct xhci_hcd *xhci,
+                struct xhci_container_ctx *in_ctx)
+{
+        u32 num_dropped_eps;
+
+        num_dropped_eps = xhci_count_num_dropped_endpoints(xhci, in_ctx);
+        xhci->num_active_eps -= num_dropped_eps;
+        if (num_dropped_eps)
+                xhci_dbg(xhci, "Removing %u dropped ep ctxs, %u now active.\n",
+                                num_dropped_eps,
+                                xhci->num_active_eps);
+}
+
 /* Issue a configure endpoint command or evaluate context command
  * and wait for it to finish.
  */
@@ -1274,19 +1735,45 @@ static int xhci_configure_endpoint(struct xhci_hcd *xhci,
         unsigned long flags;
         struct xhci_container_ctx *in_ctx;
         struct completion *cmd_completion;
-        int *cmd_status;
+        u32 *cmd_status;
         struct xhci_virt_device *virt_dev;
 
         spin_lock_irqsave(&xhci->lock, flags);
         virt_dev = xhci->devs[udev->slot_id];
         if (command) {
                 in_ctx = command->in_ctx;
+                if ((xhci->quirks & XHCI_EP_LIMIT_QUIRK) &&
+                                xhci_reserve_host_resources(xhci, in_ctx)) {
+                        spin_unlock_irqrestore(&xhci->lock, flags);
+                        xhci_warn(xhci, "Not enough host resources, "
+                                        "active endpoint contexts = %u\n",
+                                        xhci->num_active_eps);
+                        return -ENOMEM;
+                }
+
                 cmd_completion = command->completion;
                 cmd_status = &command->status;
                 command->command_trb = xhci->cmd_ring->enqueue;
+
+                /* Enqueue pointer can be left pointing to the link TRB,
+                 * we must handle that
+                 */
+                if ((le32_to_cpu(command->command_trb->link.control)
+                     & TRB_TYPE_BITMASK) == TRB_TYPE(TRB_LINK))
+                        command->command_trb =
+                                xhci->cmd_ring->enq_seg->next->trbs;
+
                 list_add_tail(&command->cmd_list, &virt_dev->cmd_list);
         } else {
                 in_ctx = virt_dev->in_ctx;
+                if ((xhci->quirks & XHCI_EP_LIMIT_QUIRK) &&
+                                xhci_reserve_host_resources(xhci, in_ctx)) {
+                        spin_unlock_irqrestore(&xhci->lock, flags);
+                        xhci_warn(xhci, "Not enough host resources, "
+                                        "active endpoint contexts = %u\n",
+                                        xhci->num_active_eps);
+                        return -ENOMEM;
+                }
                 cmd_completion = &virt_dev->cmd_completion;
                 cmd_status = &virt_dev->cmd_status;
         }
@@ -1301,6 +1788,8 @@ static int xhci_configure_endpoint(struct xhci_hcd *xhci,
         if (ret < 0) {
                 if (command)
                         list_del(&command->cmd_list);
+                if ((xhci->quirks & XHCI_EP_LIMIT_QUIRK))
+                        xhci_free_host_resources(xhci, in_ctx);
                 spin_unlock_irqrestore(&xhci->lock, flags);
                 xhci_dbg(xhci, "FIXME allocate a new ring segment\n");
                 return -ENOMEM;
@@ -1323,8 +1812,22 @@ static int xhci_configure_endpoint(struct xhci_hcd *xhci,
         }
 
         if (!ctx_change)
-                return xhci_configure_endpoint_result(xhci, udev, cmd_status);
-        return xhci_evaluate_context_result(xhci, udev, cmd_status);
+                ret = xhci_configure_endpoint_result(xhci, udev, cmd_status);
+        else
+                ret = xhci_evaluate_context_result(xhci, udev, cmd_status);
+
+        if ((xhci->quirks & XHCI_EP_LIMIT_QUIRK)) {
+                spin_lock_irqsave(&xhci->lock, flags);
+                /* If the command failed, remove the reserved resources.
+                 * Otherwise, clean up the estimate to include dropped eps.
+                 */
+                if (ret)
+                        xhci_free_host_resources(xhci, in_ctx);
+                else
+                        xhci_finish_resource_reservation(xhci, in_ctx);
+                spin_unlock_irqrestore(&xhci->lock, flags);
+        }
+        return ret;
 }
 
 /* Called after one or more calls to xhci_add_endpoint() or
@@ -1346,29 +1849,25 @@ int xhci_check_bandwidth(struct usb_hcd *hcd, struct usb_device *udev)
         struct xhci_input_control_ctx *ctrl_ctx;
         struct xhci_slot_ctx *slot_ctx;
 
-        ret = xhci_check_args(hcd, udev, NULL, 0, __func__);
+        ret = xhci_check_args(hcd, udev, NULL, 0, true, __func__);
         if (ret <= 0)
                 return ret;
         xhci = hcd_to_xhci(hcd);
+        if (xhci->xhc_state & XHCI_STATE_DYING)
+                return -ENODEV;
 
-        if (!udev->slot_id || !xhci->devs || !xhci->devs[udev->slot_id]) {
-                xhci_warn(xhci, "xHCI %s called with unaddressed device\n",
-                                __func__);
-                return -EINVAL;
-        }
         xhci_dbg(xhci, "%s called for udev %p\n", __func__, udev);
         virt_dev = xhci->devs[udev->slot_id];
 
         /* See section 4.6.6 - A0 = 1; A1 = D0 = D1 = 0 */
         ctrl_ctx = xhci_get_input_control_ctx(xhci, virt_dev->in_ctx);
-        ctrl_ctx->add_flags |= SLOT_FLAG;
-        ctrl_ctx->add_flags &= ~EP0_FLAG;
-        ctrl_ctx->drop_flags &= ~SLOT_FLAG;
-        ctrl_ctx->drop_flags &= ~EP0_FLAG;
+        ctrl_ctx->add_flags |= cpu_to_le32(SLOT_FLAG);
+        ctrl_ctx->add_flags &= cpu_to_le32(~EP0_FLAG);
+        ctrl_ctx->drop_flags &= cpu_to_le32(~(SLOT_FLAG | EP0_FLAG));
         xhci_dbg(xhci, "New Input Control Context:\n");
         slot_ctx = xhci_get_slot_ctx(xhci, virt_dev->in_ctx);
         xhci_dbg_ctx(xhci, virt_dev->in_ctx,
-                        LAST_CTX_TO_EP_NUM(slot_ctx->dev_info));
+                     LAST_CTX_TO_EP_NUM(le32_to_cpu(slot_ctx->dev_info)));
 
         ret = xhci_configure_endpoint(xhci, udev, NULL,
                         false, false);
@@ -1379,10 +1878,19 @@ int xhci_check_bandwidth(struct usb_hcd *hcd, struct usb_device *udev)
 
         xhci_dbg(xhci, "Output context after successful config ep cmd:\n");
         xhci_dbg_ctx(xhci, virt_dev->out_ctx,
-                        LAST_CTX_TO_EP_NUM(slot_ctx->dev_info));
+                     LAST_CTX_TO_EP_NUM(le32_to_cpu(slot_ctx->dev_info)));
 
+        /* Free any rings that were dropped, but not changed. */
+        for (i = 1; i < 31; ++i) {
+                if ((le32_to_cpu(ctrl_ctx->drop_flags) & (1 << (i + 1))) &&
+                    !(le32_to_cpu(ctrl_ctx->add_flags) & (1 << (i + 1))))
+                        xhci_free_or_cache_endpoint_ring(xhci, virt_dev, i);
+        }
         xhci_zero_in_ctx(xhci, virt_dev);
-        /* Install new rings and free or cache any old rings */
+        /*
+         * Install any rings for completely new endpoints or changed endpoints,
+         * and free or cache any old rings from changed endpoints.
+         */
         for (i = 1; i < 31; ++i) {
                 if (!virt_dev->eps[i].new_ring)
                         continue;
@@ -1405,16 +1913,11 @@ void xhci_reset_bandwidth(struct usb_hcd *hcd, struct usb_device *udev)
         struct xhci_virt_device *virt_dev;
         int i, ret;
 
-        ret = xhci_check_args(hcd, udev, NULL, 0, __func__);
+        ret = xhci_check_args(hcd, udev, NULL, 0, true, __func__);
         if (ret <= 0)
                 return;
         xhci = hcd_to_xhci(hcd);
 
-        if (!xhci->devs || !xhci->devs[udev->slot_id]) {
-                xhci_warn(xhci, "xHCI %s called with unaddressed device\n",
-                                __func__);
-                return;
-        }
         xhci_dbg(xhci, "%s called for udev %p\n", __func__, udev);
         virt_dev = xhci->devs[udev->slot_id];
         /* Free any rings allocated for added endpoints */
@@ -1434,16 +1937,16 @@ static void xhci_setup_input_ctx_for_config_ep(struct xhci_hcd *xhci,
 {
         struct xhci_input_control_ctx *ctrl_ctx;
         ctrl_ctx = xhci_get_input_control_ctx(xhci, in_ctx);
-        ctrl_ctx->add_flags = add_flags;
-        ctrl_ctx->drop_flags = drop_flags;
+        ctrl_ctx->add_flags = cpu_to_le32(add_flags);
+        ctrl_ctx->drop_flags = cpu_to_le32(drop_flags);
         xhci_slot_copy(xhci, in_ctx, out_ctx);
-        ctrl_ctx->add_flags |= SLOT_FLAG;
+        ctrl_ctx->add_flags |= cpu_to_le32(SLOT_FLAG);
 
         xhci_dbg(xhci, "Input Context:\n");
         xhci_dbg_ctx(xhci, in_ctx, xhci_last_valid_endpoint(add_flags));
 }
 
-void xhci_setup_input_ctx_for_quirk(struct xhci_hcd *xhci,
+static void xhci_setup_input_ctx_for_quirk(struct xhci_hcd *xhci,
                 unsigned int slot_id, unsigned int ep_index,
                 struct xhci_dequeue_state *deq_state)
 {
@@ -1466,7 +1969,7 @@ void xhci_setup_input_ctx_for_quirk(struct xhci_hcd *xhci,
                                 deq_state->new_deq_ptr);
                 return;
         }
-        ep_ctx->deq = addr | deq_state->new_cycle_state;
+        ep_ctx->deq = cpu_to_le64(addr | deq_state->new_cycle_state);
 
         added_ctxs = xhci_get_endpoint_flag_from_index(ep_index);
         xhci_setup_input_ctx_for_config_ep(xhci, xhci->devs[slot_id]->in_ctx,
@@ -1575,7 +2078,7 @@ static int xhci_check_streams_endpoint(struct xhci_hcd *xhci,
 
         if (!ep)
                 return -EINVAL;
-        ret = xhci_check_args(xhci_to_hcd(xhci), udev, ep, 1, __func__);
+        ret = xhci_check_args(xhci_to_hcd(xhci), udev, ep, 1, true, __func__);
         if (ret <= 0)
                 return -EINVAL;
         if (ep->ss_ep_comp.bmAttributes == 0) {
@@ -1771,7 +2274,7 @@ int xhci_alloc_streams(struct usb_hcd *hcd, struct usb_device *udev,
                 return -EINVAL;
         }
         vdev = xhci->devs[udev->slot_id];
-        /* Mark each endpoint as being in transistion, so
+        /* Mark each endpoint as being in transition, so
          * xhci_urb_enqueue() will reject all URBs.
          */
         for (i = 0; i < num_eps; i++) {
@@ -1942,6 +2445,34 @@ int xhci_free_streams(struct usb_hcd *hcd, struct usb_device *udev,
 }
 
 /*
+ * Deletes endpoint resources for endpoints that were active before a Reset
+ * Device command, or a Disable Slot command.  The Reset Device command leaves
+ * the control endpoint intact, whereas the Disable Slot command deletes it.
+ *
+ * Must be called with xhci->lock held.
+ */
+void xhci_free_device_endpoint_resources(struct xhci_hcd *xhci,
+        struct xhci_virt_device *virt_dev, bool drop_control_ep)
+{
+        int i;
+        unsigned int num_dropped_eps = 0;
+        unsigned int drop_flags = 0;
+
+        for (i = (drop_control_ep ? 0 : 1); i < 31; i++) {
+                if (virt_dev->eps[i].ring) {
+                        drop_flags |= 1 << i;
+                        num_dropped_eps++;
+                }
+        }
+        xhci->num_active_eps -= num_dropped_eps;
+        if (num_dropped_eps)
+                xhci_dbg(xhci, "Dropped %u ep ctxs, flags = 0x%x, "
+                                "%u now active.\n",
+                                num_dropped_eps, drop_flags,
+                                xhci->num_active_eps);
+}
+
+/*
  * This submits a Reset Device Command, which will set the device state to 0,
  * set the device address to 0, and disable all the endpoints except the default
  * control endpoint.  The USB core should come back and call
@@ -1953,8 +2484,13 @@ int xhci_free_streams(struct usb_hcd *hcd, struct usb_device *udev,
  * Wait for the Reset Device command to finish.  Remove all structures
  * associated with the endpoints that were disabled.  Clear the input device
  * structure?  Cache the rings?  Reset the control endpoint 0 max packet size?
+ *
+ * If the virt_dev to be reset does not exist or does not match the udev,
+ * it means the device is lost, possibly due to the xHC restore error and
+ * re-initialization during S3/S4. In this case, call xhci_alloc_dev() to
+ * re-allocate the device.
  */
-int xhci_reset_device(struct usb_hcd *hcd, struct usb_device *udev)
+int xhci_discover_or_reset_device(struct usb_hcd *hcd, struct usb_device *udev)
 {
         int ret, i;
         unsigned long flags;
@@ -1964,19 +2500,45 @@ int xhci_reset_device(struct usb_hcd *hcd, struct usb_device *udev)
         struct xhci_command *reset_device_cmd;
         int timeleft;
         int last_freed_endpoint;
+        struct xhci_slot_ctx *slot_ctx;
 
-        ret = xhci_check_args(hcd, udev, NULL, 0, __func__);
+        ret = xhci_check_args(hcd, udev, NULL, 0, false, __func__);
         if (ret <= 0)
                 return ret;
         xhci = hcd_to_xhci(hcd);
         slot_id = udev->slot_id;
         virt_dev = xhci->devs[slot_id];
         if (!virt_dev) {
-                xhci_dbg(xhci, "%s called with invalid slot ID %u\n",
-                                __func__, slot_id);
-                return -EINVAL;
+                xhci_dbg(xhci, "The device to be reset with slot ID %u does "
+                                "not exist. Re-allocate the device\n", slot_id);
+                ret = xhci_alloc_dev(hcd, udev);
+                if (ret == 1)
+                        return 0;
+                else
+                        return -EINVAL;
         }
 
+        if (virt_dev->udev != udev) {
+                /* If the virt_dev and the udev does not match, this virt_dev
+                 * may belong to another udev.
+                 * Re-allocate the device.
+                 */
+                xhci_dbg(xhci, "The device to be reset with slot ID %u does "
+                                "not match the udev. Re-allocate the device\n",
+                                slot_id);
+                ret = xhci_alloc_dev(hcd, udev);
+                if (ret == 1)
+                        return 0;
+                else
+                        return -EINVAL;
+        }
+
+        /* If device is not setup, there is no point in resetting it */
+        slot_ctx = xhci_get_slot_ctx(xhci, virt_dev->out_ctx);
+        if (GET_SLOT_STATE(le32_to_cpu(slot_ctx->dev_state)) ==
+                                                SLOT_STATE_DISABLED)
+                return 0;
+
         xhci_dbg(xhci, "Resetting device with slot ID %u\n", slot_id);
         /* Allocate the command structure that holds the struct completion.
          * Assume we're in process context, since the normal device reset
@@ -1993,6 +2555,15 @@ int xhci_reset_device(struct usb_hcd *hcd, struct usb_device *udev)
         /* Attempt to submit the Reset Device command to the command ring */
         spin_lock_irqsave(&xhci->lock, flags);
         reset_device_cmd->command_trb = xhci->cmd_ring->enqueue;
+
+        /* Enqueue pointer can be left pointing to the link TRB,
+         * we must handle that
+         */
+        if ((le32_to_cpu(reset_device_cmd->command_trb->link.control)
+             & TRB_TYPE_BITMASK) == TRB_TYPE(TRB_LINK))
+                reset_device_cmd->command_trb =
+                        xhci->cmd_ring->enq_seg->next->trbs;
+
         list_add_tail(&reset_device_cmd->cmd_list, &virt_dev->cmd_list);
         ret = xhci_queue_reset_device(xhci, slot_id);
         if (ret) {
@@ -2049,13 +2620,29 @@ int xhci_reset_device(struct usb_hcd *hcd, struct usb_device *udev)
                 goto command_cleanup;
         }
 
+        /* Free up host controller endpoint resources */
+        if ((xhci->quirks & XHCI_EP_LIMIT_QUIRK)) {
+                spin_lock_irqsave(&xhci->lock, flags);
+                /* Don't delete the default control endpoint resources */
+                xhci_free_device_endpoint_resources(xhci, virt_dev, false);
+                spin_unlock_irqrestore(&xhci->lock, flags);
+        }
+
         /* Everything but endpoint 0 is disabled, so free or cache the rings. */
         last_freed_endpoint = 1;
         for (i = 1; i < 31; ++i) {
-                if (!virt_dev->eps[i].ring)
-                        continue;
-                xhci_free_or_cache_endpoint_ring(xhci, virt_dev, i);
-                last_freed_endpoint = i;
+                struct xhci_virt_ep *ep = &virt_dev->eps[i];
+
+                if (ep->ep_state & EP_HAS_STREAMS) {
+                        xhci_free_stream_info(xhci, ep->stream_info);
+                        ep->stream_info = NULL;
+                        ep->ep_state &= ~EP_HAS_STREAMS;
+                }
+
+                if (ep->ring) {
+                        xhci_free_or_cache_endpoint_ring(xhci, virt_dev, i);
+                        last_freed_endpoint = i;
+                }
         }
         xhci_dbg(xhci, "Output context after successful reset device cmd:\n");
         xhci_dbg_ctx(xhci, virt_dev->out_ctx, last_freed_endpoint);
@@ -2077,13 +2664,13 @@ void xhci_free_dev(struct usb_hcd *hcd, struct usb_device *udev)
         struct xhci_virt_device *virt_dev;
         unsigned long flags;
         u32 state;
-        int i;
+        int i, ret;
 
-        if (udev->slot_id == 0)
+        ret = xhci_check_args(hcd, udev, NULL, 0, true, __func__);
+        if (ret <= 0)
                 return;
+
         virt_dev = xhci->devs[udev->slot_id];
-        if (!virt_dev)
-                return;
 
         /* Stop any wayward timer functions (which may grab the lock) */
         for (i = 0; i < 31; ++i) {
@@ -2114,6 +2701,27 @@ void xhci_free_dev(struct usb_hcd *hcd, struct usb_device *udev)
 }
 
 /*
+ * Checks if we have enough host controller resources for the default control
+ * endpoint.
+ *
+ * Must be called with xhci->lock held.
+ */
+static int xhci_reserve_host_control_ep_resources(struct xhci_hcd *xhci)
+{
+        if (xhci->num_active_eps + 1 > xhci->limit_active_eps) {
+                xhci_dbg(xhci, "Not enough ep ctxs: "
+                                "%u active, need to add 1, limit is %u.\n",
+                                xhci->num_active_eps, xhci->limit_active_eps);
+                return -ENOMEM;
+        }
+        xhci->num_active_eps += 1;
+        xhci_dbg(xhci, "Adding 1 ep ctx, %u now active.\n",
+                        xhci->num_active_eps);
+        return 0;
+}
+
+
+/*
  * Returns 0 if the xHC ran out of device slots, the Enable Slot command
  * timed out, or allocating memory failed.  Returns 1 on success.
  */
@@ -2148,20 +2756,39 @@ int xhci_alloc_dev(struct usb_hcd *hcd, struct usb_device *udev)
                 xhci_err(xhci, "Error while assigning device slot ID\n");
                 return 0;
         }
-        /* xhci_alloc_virt_device() does not touch rings; no need to lock */
-        if (!xhci_alloc_virt_device(xhci, xhci->slot_id, udev, GFP_KERNEL)) {
-                /* Disable slot, if we can do it without mem alloc */
-                xhci_warn(xhci, "Could not allocate xHCI USB device data structures\n");
+
+        if ((xhci->quirks & XHCI_EP_LIMIT_QUIRK)) {
                 spin_lock_irqsave(&xhci->lock, flags);
-                if (!xhci_queue_slot_control(xhci, TRB_DISABLE_SLOT, udev->slot_id))
-                        xhci_ring_cmd_db(xhci);
+                ret = xhci_reserve_host_control_ep_resources(xhci);
+                if (ret) {
+                        spin_unlock_irqrestore(&xhci->lock, flags);
+                        xhci_warn(xhci, "Not enough host resources, "
+                                        "active endpoint contexts = %u\n",
+                                        xhci->num_active_eps);
+                        goto disable_slot;
+                }
                 spin_unlock_irqrestore(&xhci->lock, flags);
-                return 0;
+        }
+        /* Use GFP_NOIO, since this function can be called from
+         * xhci_discover_or_reset_device(), which may be called as part of
+         * mass storage driver error handling.
+         */
+        if (!xhci_alloc_virt_device(xhci, xhci->slot_id, udev, GFP_NOIO)) {
+                xhci_warn(xhci, "Could not allocate xHCI USB device data structures\n");
+                goto disable_slot;
         }
         udev->slot_id = xhci->slot_id;
         /* Is this a LS or FS device under a HS hub? */
         /* Hub or peripherial? */
         return 1;
+
+disable_slot:
+        /* Disable slot, if we can do it without mem alloc */
+        spin_lock_irqsave(&xhci->lock, flags);
+        if (!xhci_queue_slot_control(xhci, TRB_DISABLE_SLOT, udev->slot_id))
+                xhci_ring_cmd_db(xhci);
+        spin_unlock_irqrestore(&xhci->lock, flags);
+        return 0;
 }
 
 /*
@@ -2191,12 +2818,28 @@ int xhci_address_device(struct usb_hcd *hcd, struct usb_device *udev)
 
         virt_dev = xhci->devs[udev->slot_id];
 
-        /* If this is a Set Address to an unconfigured device, setup ep 0 */
-        if (!udev->config)
+        if (WARN_ON(!virt_dev)) {
+                /*
+                 * In plug/unplug torture test with an NEC controller,
+                 * a zero-dereference was observed once due to virt_dev = 0.
+                 * Print useful debug rather than crash if it is observed again!
+                 */
+                xhci_warn(xhci, "Virt dev invalid for slot_id 0x%x!\n",
+                        udev->slot_id);
+                return -EINVAL;
+        }
+
+        slot_ctx = xhci_get_slot_ctx(xhci, virt_dev->in_ctx);
+        /*
+         * If this is the first Set Address since device plug-in or
+         * virt_device realloaction after a resume with an xHCI power loss,
+         * then set up the slot context.
+         */
+        if (!slot_ctx->dev_info)
                 xhci_setup_addressable_virt_dev(xhci, udev);
+        /* Otherwise, update the control endpoint ring enqueue pointer. */
         else
                 xhci_copy_ep0_dequeue_into_input_ctx(xhci, udev);
-        /* Otherwise, assume the core has the device configured how it wants */
         xhci_dbg(xhci, "Slot ID %d Input Context:\n", udev->slot_id);
         xhci_dbg_ctx(xhci, virt_dev->in_ctx, 2);
 
@@ -2236,6 +2879,11 @@ int xhci_address_device(struct usb_hcd *hcd, struct usb_device *udev)
                 dev_warn(&udev->dev, "Device not responding to set address.\n");
                 ret = -EPROTO;
                 break;
+        case COMP_DEV_ERR:
+                dev_warn(&udev->dev, "ERROR: Incompatible device for address "
+                                "device command.\n");
+                ret = -ENODEV;
+                break;
         case COMP_SUCCESS:
                 xhci_dbg(xhci, "Successful Address Device command\n");
                 break;
@@ -2253,10 +2901,10 @@ int xhci_address_device(struct usb_hcd *hcd, struct usb_device *udev)
         temp_64 = xhci_read_64(xhci, &xhci->op_regs->dcbaa_ptr);
         xhci_dbg(xhci, "Op regs DCBAA ptr = %#016llx\n", temp_64);
         xhci_dbg(xhci, "Slot ID %d dcbaa entry @%p = %#016llx\n",
-                        udev->slot_id,
-                        &xhci->dcbaa->dev_context_ptrs[udev->slot_id],
-                        (unsigned long long)
-                                xhci->dcbaa->dev_context_ptrs[udev->slot_id]);
+                 udev->slot_id,
+                 &xhci->dcbaa->dev_context_ptrs[udev->slot_id],
+                 (unsigned long long)
+                 le64_to_cpu(xhci->dcbaa->dev_context_ptrs[udev->slot_id]));
         xhci_dbg(xhci, "Output Context DMA address = %#08llx\n",
                         (unsigned long long)virt_dev->out_ctx->dma);
         xhci_dbg(xhci, "Slot ID %d Input Context:\n", udev->slot_id);
@@ -2268,15 +2916,16 @@ int xhci_address_device(struct usb_hcd *hcd, struct usb_device *udev)
          * address given back to us by the HC.
          */
         slot_ctx = xhci_get_slot_ctx(xhci, virt_dev->out_ctx);
-        udev->devnum = (slot_ctx->dev_state & DEV_ADDR_MASK) + 1;
+        /* Use kernel assigned address for devices; store xHC assigned
+         * address locally. */
+        virt_dev->address = (le32_to_cpu(slot_ctx->dev_state) & DEV_ADDR_MASK)
+                + 1;
         /* Zero the input context control for later use */
         ctrl_ctx = xhci_get_input_control_ctx(xhci, virt_dev->in_ctx);
         ctrl_ctx->add_flags = 0;
         ctrl_ctx->drop_flags = 0;
 
-        xhci_dbg(xhci, "Device address = %d\n", udev->devnum);
-        /* XXX Meh, not sure if anyone else but choose_address uses this. */
-        set_bit(udev->devnum, udev->bus->devmap.devicemap);
+        xhci_dbg(xhci, "Internal device address = %d\n", virt_dev->address);
 
         return 0;
 }
@@ -2314,24 +2963,29 @@ int xhci_update_hub_device(struct usb_hcd *hcd, struct usb_device *hdev,
         spin_lock_irqsave(&xhci->lock, flags);
         xhci_slot_copy(xhci, config_cmd->in_ctx, vdev->out_ctx);
         ctrl_ctx = xhci_get_input_control_ctx(xhci, config_cmd->in_ctx);
-        ctrl_ctx->add_flags |= SLOT_FLAG;
+        ctrl_ctx->add_flags |= cpu_to_le32(SLOT_FLAG);
         slot_ctx = xhci_get_slot_ctx(xhci, config_cmd->in_ctx);
-        slot_ctx->dev_info |= DEV_HUB;
+        slot_ctx->dev_info |= cpu_to_le32(DEV_HUB);
         if (tt->multi)
-                slot_ctx->dev_info |= DEV_MTT;
+                slot_ctx->dev_info |= cpu_to_le32(DEV_MTT);
         if (xhci->hci_version > 0x95) {
                 xhci_dbg(xhci, "xHCI version %x needs hub "
                                 "TT think time and number of ports\n",
                                 (unsigned int) xhci->hci_version);
-                slot_ctx->dev_info2 |= XHCI_MAX_PORTS(hdev->maxchild);
+                slot_ctx->dev_info2 |= cpu_to_le32(XHCI_MAX_PORTS(hdev->maxchild));
                 /* Set TT think time - convert from ns to FS bit times.
                  * 0 = 8 FS bit times, 1 = 16 FS bit times,
                  * 2 = 24 FS bit times, 3 = 32 FS bit times.
+                 *
+                 * xHCI 1.0: this field shall be 0 if the device is not a
+                 * High-spped hub.
                  */
                 think_time = tt->think_time;
                 if (think_time != 0)
                         think_time = (think_time / 666) - 1;
-                slot_ctx->tt_info |= TT_THINK_TIME(think_time);
+                if (xhci->hci_version < 0x100 || hdev->speed == USB_SPEED_HIGH)
+                        slot_ctx->tt_info |=
+                                cpu_to_le32(TT_THINK_TIME(think_time));
         } else {
                 xhci_dbg(xhci, "xHCI version %x doesn't need hub "
                                 "TT think time or number of ports\n",
diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h
index 34a60d9f056a..d8bbf5ccb10d 100644
--- a/drivers/usb/host/xhci.h
+++ b/drivers/usb/host/xhci.h
@@ -30,6 +30,7 @@
 
 /* Code sharing between pci-quirks and xhci hcd */
 #include        "xhci-ext-caps.h"
+#include "pci-quirks.h"
 
 /* xHCI PCI Configuration Registers */
 #define XHCI_SBRN_OFFSET        (0x60)
@@ -56,13 +57,13 @@
  * @run_regs_off:       RTSOFF - Runtime register space offset
  */
 struct xhci_cap_regs {
-        u32     hc_capbase;
-        u32     hcs_params1;
-        u32     hcs_params2;
-        u32     hcs_params3;
-        u32     hcc_params;
-        u32     db_off;
-        u32     run_regs_off;
+        __le32  hc_capbase;
+        __le32  hcs_params1;
+        __le32  hcs_params2;
+        __le32  hcs_params3;
+        __le32  hcc_params;
+        __le32  db_off;
+        __le32  run_regs_off;
         /* Reserved up to (CAPLENGTH - 0x1C) */
 };
 
@@ -154,26 +155,26 @@ struct xhci_cap_regs {
  *                      devices.
  */
 struct xhci_op_regs {
-        u32     command;
-        u32     status;
-        u32     page_size;
-        u32     reserved1;
-        u32     reserved2;
-        u32     dev_notification;
-        u64     cmd_ring;
+        __le32  command;
+        __le32  status;
+        __le32  page_size;
+        __le32  reserved1;
+        __le32  reserved2;
+        __le32  dev_notification;
+        __le64  cmd_ring;
         /* rsvd: offset 0x20-2F */
-        u32     reserved3[4];
-        u64     dcbaa_ptr;
-        u32     config_reg;
+        __le32  reserved3[4];
+        __le64  dcbaa_ptr;
+        __le32  config_reg;
         /* rsvd: offset 0x3C-3FF */
-        u32     reserved4[241];
+        __le32  reserved4[241];
         /* port 1 registers, which serve as a base address for other ports */
-        u32     port_status_base;
-        u32     port_power_base;
-        u32     port_link_base;
-        u32     reserved5;
+        __le32  port_status_base;
+        __le32  port_power_base;
+        __le32  port_link_base;
+        __le32  reserved5;
         /* registers for ports 2-255 */
-        u32     reserved6[NUM_PORT_REGS*254];
+        __le32  reserved6[NUM_PORT_REGS*254];
 };
 
 /* USBCMD - USB command - command bitmasks */
@@ -191,7 +192,7 @@ struct xhci_op_regs {
 /* bits 4:6 are reserved (and should be preserved on writes). */
 /* light reset (port status stays unchanged) - reset completed when this is 0 */
 #define CMD_LRESET      (1 << 7)
-/* FIXME: ignoring host controller save/restore state for now. */
+/* host controller save/restore state. */
 #define CMD_CSS         (1 << 8)
 #define CMD_CRS         (1 << 9)
 /* Enable Wrap Event - '1' means xHC generates an event when MFINDEX wraps. */
@@ -232,7 +233,7 @@ struct xhci_op_regs {
  * notification type that matches a bit set in this bit field.
  */
 #define DEV_NOTE_MASK           (0xffff)
-#define ENABLE_DEV_NOTE(x)      (1 << x)
+#define ENABLE_DEV_NOTE(x)      (1 << (x))
 /* Most of the device notification types should only be used for debug.
  * SW does need to pay attention to function wake notifications.
  */
@@ -269,6 +270,10 @@ struct xhci_op_regs {
  * A read gives the current link PM state of the port,
  * a write with Link State Write Strobe set sets the link state.
  */
+#define PORT_PLS_MASK   (0xf << 5)
+#define XDEV_U0         (0x0 << 5)
+#define XDEV_U3         (0x3 << 5)
+#define XDEV_RESUME     (0xf << 5)
 /* true: port has power (see HCC_PPC) */
 #define PORT_POWER      (1 << 9)
 /* bits 10:13 indicate device speed:
@@ -344,6 +349,9 @@ struct xhci_op_regs {
 /* Initiate a warm port reset - complete when PORT_WRC is '1' */
 #define PORT_WR         (1 << 31)
 
+/* We mark duplicate entries with -1 */
+#define DUPLICATE_ENTRY ((u8)(-1))
+
 /* Port Power Management Status and Control - port_power_base bitmasks */
 /* Inactivity timer value for transitions into U1, in microseconds.
  * Timeout can be up to 127us.  0xFF means an infinite timeout.
@@ -353,6 +361,8 @@ struct xhci_op_regs {
 #define PORT_U2_TIMEOUT(p)      (((p) & 0xff) << 8)
 /* Bits 24:31 for port testing */
 
+/* USB2 Protocol PORTSPMSC */
+#define PORT_RWE        (1 << 0x3)
 
 /**
  * struct xhci_intr_reg - Interrupt Register Set
@@ -372,12 +382,12 @@ struct xhci_op_regs {
  * updates the dequeue pointer.
  */
 struct xhci_intr_reg {
-        u32     irq_pending;
-        u32     irq_control;
-        u32     erst_size;
-        u32     rsvd;
-        u64     erst_base;
-        u64     erst_dequeue;
+        __le32  irq_pending;
+        __le32  irq_control;
+        __le32  erst_size;
+        __le32  rsvd;
+        __le64  erst_base;
+        __le64  erst_dequeue;
 };
 
 /* irq_pending bitmasks */
@@ -422,30 +432,44 @@ struct xhci_intr_reg {
  * or larger accesses"
  */
 struct xhci_run_regs {
-        u32                     microframe_index;
-        u32                     rsvd[7];
+        __le32                  microframe_index;
+        __le32                  rsvd[7];
         struct xhci_intr_reg    ir_set[128];
 };
 
 /**
  * struct doorbell_array
  *
+ * Bits  0 -  7: Endpoint target
+ * Bits  8 - 15: RsvdZ
+ * Bits 16 - 31: Stream ID
+ *
  * Section 5.6
  */
 struct xhci_doorbell_array {
-        u32     doorbell[256];
+        __le32  doorbell[256];
 };
 
-#define DB_TARGET_MASK          0xFFFFFF00
-#define DB_STREAM_ID_MASK       0x0000FFFF
-#define DB_TARGET_HOST          0x0
-#define DB_STREAM_ID_HOST       0x0
-#define DB_MASK                 (0xff << 8)
+#define DB_VALUE(ep, stream)    ((((ep) + 1) & 0xff) | ((stream) << 16))
+#define DB_VALUE_HOST           0x00000000
 
-/* Endpoint Target - bits 0:7 */
-#define EPI_TO_DB(p)            (((p) + 1) & 0xff)
-#define STREAM_ID_TO_DB(p)      (((p) & 0xffff) << 16)
+/**
+ * struct xhci_protocol_caps
+ * @revision:           major revision, minor revision, capability ID,
+ *                      and next capability pointer.
+ * @name_string:        Four ASCII characters to say which spec this xHC
+ *                      follows, typically "USB ".
+ * @port_info:          Port offset, count, and protocol-defined information.
+ */
+struct xhci_protocol_caps {
+        u32     revision;
+        u32     name_string;
+        u32     port_info;
+};
 
+#define XHCI_EXT_PORT_MAJOR(x)  (((x) >> 24) & 0xff)
+#define XHCI_EXT_PORT_OFF(x)    ((x) & 0xff)
+#define XHCI_EXT_PORT_COUNT(x)  (((x) >> 8) & 0xff)
 
 /**
  * struct xhci_container_ctx
@@ -480,12 +504,12 @@ struct xhci_container_ctx {
  * reserved at the end of the slot context for HC internal use.
  */
 struct xhci_slot_ctx {
-        u32     dev_info;
-        u32     dev_info2;
-        u32     tt_info;
-        u32     dev_state;
+        __le32  dev_info;
+        __le32  dev_info2;
+        __le32  tt_info;
+        __le32  dev_state;
         /* offset 0x10 to 0x1f reserved for HC internal use */
-        u32     reserved[4];
+        __le32  reserved[4];
 };
 
 /* dev_info bitmasks */
@@ -510,6 +534,7 @@ struct xhci_slot_ctx {
 #define MAX_EXIT        (0xffff)
 /* Root hub port number that is needed to access the USB device */
 #define ROOT_HUB_PORT(p)        (((p) & 0xff) << 16)
+#define DEVINFO_TO_ROOT_HUB_PORT(p)     (((p) >> 16) & 0xff)
 /* Maximum number of ports under a hub device */
 #define XHCI_MAX_PORTS(p)       (((p) & 0xff) << 24)
 
@@ -535,6 +560,11 @@ struct xhci_slot_ctx {
 #define SLOT_STATE      (0x1f << 27)
 #define GET_SLOT_STATE(p)       (((p) & (0x1f << 27)) >> 27)
 
+#define SLOT_STATE_DISABLED     0
+#define SLOT_STATE_ENABLED      SLOT_STATE_DISABLED
+#define SLOT_STATE_DEFAULT      1
+#define SLOT_STATE_ADDRESSED    2
+#define SLOT_STATE_CONFIGURED   3
 
 /**
  * struct xhci_ep_ctx
@@ -555,12 +585,12 @@ struct xhci_slot_ctx {
  * reserved at the end of the endpoint context for HC internal use.
  */
 struct xhci_ep_ctx {
-        u32     ep_info;
-        u32     ep_info2;
-        u64     deq;
-        u32     tx_info;
+        __le32  ep_info;
+        __le32  ep_info2;
+        __le64  deq;
+        __le32  tx_info;
         /* offset 0x14 - 0x1f reserved for HC internal use */
-        u32     reserved[3];
+        __le32  reserved[3];
 };
 
 /* ep_info bitmasks */
@@ -580,11 +610,11 @@ struct xhci_ep_ctx {
 #define EP_STATE_STOPPED        3
 #define EP_STATE_ERROR          4
 /* Mult - Max number of burtst within an interval, in EP companion desc. */
-#define EP_MULT(p)              ((p & 0x3) << 8)
+#define EP_MULT(p)              (((p) & 0x3) << 8)
 /* bits 10:14 are Max Primary Streams */
 /* bit 15 is Linear Stream Array */
 /* Interval - period between requests to an endpoint - 125u increments. */
-#define EP_INTERVAL(p)          ((p & 0xff) << 16)
+#define EP_INTERVAL(p)          (((p) & 0xff) << 16)
 #define EP_INTERVAL_TO_UFRAMES(p)               (1 << (((p) >> 16) & 0xff))
 #define EP_MAXPSTREAMS_MASK     (0x1f << 10)
 #define EP_MAXPSTREAMS(p)       (((p) << 10) & EP_MAXPSTREAMS_MASK)
@@ -614,10 +644,18 @@ struct xhci_ep_ctx {
 #define MAX_PACKET_MASK         (0xffff << 16)
 #define MAX_PACKET_DECODED(p)   (((p) >> 16) & 0xffff)
 
+/* Get max packet size from ep desc. Bit 10..0 specify the max packet size.
+ * USB2.0 spec 9.6.6.
+ */
+#define GET_MAX_PACKET(p)       ((p) & 0x7ff)
+
 /* tx_info bitmasks */
 #define AVG_TRB_LENGTH_FOR_EP(p)        ((p) & 0xffff)
 #define MAX_ESIT_PAYLOAD_FOR_EP(p)      (((p) & 0xffff) << 16)
 
+/* deq bitmasks */
+#define EP_CTX_CYCLE_MASK               (1 << 0)
+
 
 /**
  * struct xhci_input_control_context
@@ -627,9 +665,9 @@ struct xhci_ep_ctx {
  * @add_context:        set the bit of the endpoint context you want to enable
  */
 struct xhci_input_control_ctx {
-        u32     drop_flags;
-        u32     add_flags;
-        u32     rsvd2[6];
+        __le32  drop_flags;
+        __le32  add_flags;
+        __le32  rsvd2[6];
 };
 
 /* Represents everything that is needed to issue a command on the command ring.
@@ -655,9 +693,9 @@ struct xhci_command {
 
 struct xhci_stream_ctx {
         /* 64-bit stream ring address, cycle state, and stream type */
-        u64     stream_ring;
+        __le64  stream_ring;
         /* offset 0x14 - 0x1f reserved for HC internal use */
-        u32     reserved[2];
+        __le32  reserved[2];
 };
 
 /* Stream Context Types (section 6.4.1) - bits 3:1 of stream ctx deq ptr */
@@ -720,6 +758,12 @@ struct xhci_virt_ep {
         struct timer_list       stop_cmd_timer;
         int                     stop_cmds_pending;
         struct xhci_hcd         *xhci;
+        /* Dequeue pointer and dequeue segment for a submitted Set TR Dequeue
+         * command.  We'll need to update the ring's dequeue segment and dequeue
+         * pointer after the command completes.
+         */
+        struct xhci_segment     *queued_deq_seg;
+        union xhci_trb          *queued_deq_ptr;
         /*
          * Sometimes the xHC can not process isochronous endpoint ring quickly
          * enough, and it will miss some isoc tds on the ring and generate
@@ -731,6 +775,7 @@ struct xhci_virt_ep {
 };
 
 struct xhci_virt_device {
+        struct usb_device               *udev;
         /*
          * Commands to the hardware are passed an "input context" that
          * tells the hardware what to change in its data structures.
@@ -745,12 +790,15 @@ struct xhci_virt_device {
         /* Rings saved to ensure old alt settings can be re-instated */
         struct xhci_ring                **ring_cache;
         int                             num_rings_cached;
+        /* Store xHC assigned device address */
+        int                             address;
 #define XHCI_MAX_RINGS_CACHED   31
         struct xhci_virt_ep             eps[31];
         struct completion               cmd_completion;
         /* Status of the last command issued for this device */
         u32                             cmd_status;
         struct list_head                cmd_list;
+        u8                              port;
 };
 
 
@@ -760,7 +808,7 @@ struct xhci_virt_device {
  */
 struct xhci_device_context_array {
         /* 64-bit device addresses; we only write 32-bit addresses */
-        u64                     dev_context_ptrs[MAX_HC_SLOTS];
+        __le64                  dev_context_ptrs[MAX_HC_SLOTS];
         /* private xHCD pointers */
         dma_addr_t      dma;
 };
@@ -773,10 +821,10 @@ struct xhci_device_context_array {
 
 struct xhci_transfer_event {
         /* 64-bit buffer address, or immediate data */
-        u64     buffer;
-        u32     transfer_len;
+        __le64  buffer;
+        __le32  transfer_len;
         /* This field is interpreted differently based on the type of TRB */
-        u32     flags;
+        __le32  flags;
 };
 
 /** Transfer Event bit fields **/
@@ -826,6 +874,8 @@ struct xhci_transfer_event {
 #define COMP_PING_ERR   20
 /* Event Ring is full */
 #define COMP_ER_FULL    21
+/* Incompatible Device Error */
+#define COMP_DEV_ERR    22
 /* Missed Service Error - HC couldn't service an isoc ep within interval */
 #define COMP_MISSED_INT 23
 /* Successfully stopped command ring */
@@ -834,11 +884,13 @@ struct xhci_transfer_event {
 #define COMP_CMD_ABORT  25
 /* Stopped - transfer was terminated by a stop endpoint command */
 #define COMP_STOP       26
-/* Same as COMP_EP_STOPPED, but the transfered length in the event is invalid */
+/* Same as COMP_EP_STOPPED, but the transferred length in the event is invalid */
 #define COMP_STOP_INVAL 27
 /* Control Abort Error - Debug Capability - control pipe aborted */
 #define COMP_DBG_ABORT  28
-/* TRB type 29 and 30 reserved */
+/* Max Exit Latency Too Large Error */
+#define COMP_MEL_ERR    29
+/* TRB type 30 reserved */
 /* Isoc Buffer Overrun - an isoc IN ep sent more data than could fit in TD */
 #define COMP_BUFF_OVER  31
 /* Event Lost Error - xHC has an "internal event overrun condition" */
@@ -855,9 +907,9 @@ struct xhci_transfer_event {
 
 struct xhci_link_trb {
         /* 64-bit segment pointer*/
-        u64 segment_ptr;
-        u32 intr_target;
-        u32 control;
+        __le64 segment_ptr;
+        __le32 intr_target;
+        __le32 control;
 };
 
 /* control bitfields */
@@ -866,9 +918,9 @@ struct xhci_link_trb {
 /* Command completion event TRB */
 struct xhci_event_cmd {
         /* Pointer to command TRB, or the value passed by the event data trb */
-        u64 cmd_trb;
-        u32 status;
-        u32 flags;
+        __le64 cmd_trb;
+        __le32 status;
+        __le32 flags;
 };
 
 /* flags bitmasks */
@@ -881,6 +933,10 @@ struct xhci_event_cmd {
 #define TRB_TO_EP_INDEX(p)              ((((p) & (0x1f << 16)) >> 16) - 1)
 #define EP_ID_FOR_TRB(p)                ((((p) + 1) & 0x1f) << 16)
 
+#define SUSPEND_PORT_FOR_TRB(p)         (((p) & 1) << 23)
+#define TRB_TO_SUSPEND_PORT(p)          (((p) & (1 << 23)) >> 23)
+#define LAST_EP_INDEX                   30
+
 /* Set TR Dequeue Pointer command TRB fields */
 #define TRB_TO_STREAM_ID(p)             ((((p) & (0xffff << 16)) >> 16))
 #define STREAM_ID_FOR_TRB(p)            ((((p)) & 0xffff) << 16)
@@ -896,6 +952,8 @@ struct xhci_event_cmd {
 /* Interrupter Target - which MSI-X vector to target the completion event at */
 #define TRB_INTR_TARGET(p)      (((p) & 0x3ff) << 22)
 #define GET_INTR_TARGET(p)      (((p) >> 22) & 0x3ff)
+#define TRB_TBC(p)              (((p) & 0x3) << 7)
+#define TRB_TLBPC(p)            (((p) & 0xf) << 16)
 
 /* Cycle bit - indicates TRB ownership by HC or HCD */
 #define TRB_CYCLE               (1<<0)
@@ -915,15 +973,20 @@ struct xhci_event_cmd {
 /* The buffer pointer contains immediate data */
 #define TRB_IDT                 (1<<6)
 
+/* Block Event Interrupt */
+#define TRB_BEI                 (1<<9)
 
 /* Control transfer TRB specific fields */
 #define TRB_DIR_IN              (1<<16)
+#define TRB_TX_TYPE(p)          ((p) << 16)
+#define TRB_DATA_OUT            2
+#define TRB_DATA_IN             3
 
 /* Isochronous TRB specific fields */
 #define TRB_SIA                 (1<<31)
 
 struct xhci_generic_trb {
-        u32 field[4];
+        __le32 field[4];
 };
 
 union xhci_trb {
@@ -1067,14 +1130,15 @@ struct xhci_ring {
          */
         u32                     cycle_state;
         unsigned int            stream_id;
+        bool                    last_td_was_short;
 };
 
 struct xhci_erst_entry {
         /* 64-bit event ring segment address */
-        u64     seg_addr;
-        u32     seg_size;
+        __le64  seg_addr;
+        __le32  seg_size;
         /* Set to zero */
-        u32     rsvd;
+        __le32  rsvd;
 };
 
 struct xhci_erst {
@@ -1115,9 +1179,41 @@ struct urb_priv {
 #define XHCI_STOP_EP_CMD_TIMEOUT        5
 /* XXX: Make these module parameters */
 
+struct s3_save {
+        u32     command;
+        u32     dev_nt;
+        u64     dcbaa_ptr;
+        u32     config_reg;
+        u32     irq_pending;
+        u32     irq_control;
+        u32     erst_size;
+        u64     erst_base;
+        u64     erst_dequeue;
+};
+
+struct xhci_bus_state {
+        unsigned long           bus_suspended;
+        unsigned long           next_statechange;
+
+        /* Port suspend arrays are indexed by the portnum of the fake roothub */
+        /* ports suspend status arrays - max 31 ports for USB2, 15 for USB3 */
+        u32                     port_c_suspend;
+        u32                     suspended_ports;
+        unsigned long           resume_done[USB_MAXCHILDREN];
+};
+
+static inline unsigned int hcd_index(struct usb_hcd *hcd)
+{
+        if (hcd->speed == HCD_USB3)
+                return 0;
+        else
+                return 1;
+}
 
 /* There is one ehci_hci structure per controller */
 struct xhci_hcd {
+        struct usb_hcd *main_hcd;
+        struct usb_hcd *shared_hcd;
         /* glue to PCI and HCD framework */
         struct xhci_cap_regs __iomem *cap_regs;
         struct xhci_op_regs __iomem *op_regs;
@@ -1178,6 +1274,9 @@ struct xhci_hcd {
 #endif
         /* Host controller watchdog timer structures */
         unsigned int            xhc_state;
+
+        u32                     command;
+        struct s3_save          s3;
 /* Host controller is dying - not responding to commands. "I'm not dead yet!"
  *
  * xHC interrupts have been disabled and a watchdog timer will (or has already)
@@ -1191,28 +1290,50 @@ struct xhci_hcd {
  * There are no reports of xHCI host controllers that display this issue.
  */
 #define XHCI_STATE_DYING        (1 << 0)
+#define XHCI_STATE_HALTED       (1 << 1)
         /* Statistics */
-        int                     noops_submitted;
-        int                     noops_handled;
         int                     error_bitmask;
         unsigned int            quirks;
 #define XHCI_LINK_TRB_QUIRK     (1 << 0)
 #define XHCI_RESET_EP_QUIRK     (1 << 1)
 #define XHCI_NEC_HOST           (1 << 2)
+#define XHCI_AMD_PLL_FIX        (1 << 3)
+#define XHCI_SPURIOUS_SUCCESS   (1 << 4)
+/*
+ * Certain Intel host controllers have a limit to the number of endpoint
+ * contexts they can handle.  Ideally, they would signal that they can't handle
+ * anymore endpoint contexts by returning a Resource Error for the Configure
+ * Endpoint command, but they don't.  Instead they expect software to keep track
+ * of the number of active endpoints for them, across configure endpoint
+ * commands, reset device commands, disable slot commands, and address device
+ * commands.
+ */
+#define XHCI_EP_LIMIT_QUIRK     (1 << 5)
+#define XHCI_BROKEN_MSI         (1 << 6)
+#define XHCI_RESET_ON_RESUME    (1 << 7)
+        unsigned int            num_active_eps;
+        unsigned int            limit_active_eps;
+        /* There are two roothubs to keep track of bus suspend info for */
+        struct xhci_bus_state   bus_state[2];
+        /* Is each xHCI roothub port a USB 3.0, USB 2.0, or USB 1.1 port? */
+        u8                      *port_array;
+        /* Array of pointers to USB 3.0 PORTSC registers */
+        __le32 __iomem          **usb3_ports;
+        unsigned int            num_usb3_ports;
+        /* Array of pointers to USB 2.0 PORTSC registers */
+        __le32 __iomem          **usb2_ports;
+        unsigned int            num_usb2_ports;
 };
 
-/* For testing purposes */
-#define NUM_TEST_NOOPS  0
-
 /* convert between an HCD pointer and the corresponding EHCI_HCD */
 static inline struct xhci_hcd *hcd_to_xhci(struct usb_hcd *hcd)
 {
-        return (struct xhci_hcd *) (hcd->hcd_priv);
+        return *((struct xhci_hcd **) (hcd->hcd_priv));
 }
 
 static inline struct usb_hcd *xhci_to_hcd(struct xhci_hcd *xhci)
 {
-        return container_of((void *) xhci, struct usb_hcd, hcd_priv);
+        return xhci->main_hcd;
 }
 
 #ifdef CONFIG_USB_XHCI_HCD_DEBUGGING
@@ -1233,16 +1354,13 @@ static inline struct usb_hcd *xhci_to_hcd(struct xhci_hcd *xhci)
 /* TODO: copied from ehci.h - can be refactored? */
 /* xHCI spec says all registers are little endian */
 static inline unsigned int xhci_readl(const struct xhci_hcd *xhci,
-                __u32 __iomem *regs)
+                __le32 __iomem *regs)
 {
         return readl(regs);
 }
 static inline void xhci_writel(struct xhci_hcd *xhci,
-                const unsigned int val, __u32 __iomem *regs)
+                const unsigned int val, __le32 __iomem *regs)
 {
-        xhci_dbg(xhci,
-                        "`MEM_WRITE_DWORD(3'b000, 32'h%p, 32'h%0x, 4'hf);\n",
-                        regs, val);
         writel(val, regs);
 }
 
@@ -1256,7 +1374,7 @@ static inline void xhci_writel(struct xhci_hcd *xhci,
  * the high dword, and write order is irrelevant.
  */
 static inline u64 xhci_read_64(const struct xhci_hcd *xhci,
-                __u64 __iomem *regs)
+                __le64 __iomem *regs)
 {
         __u32 __iomem *ptr = (__u32 __iomem *) regs;
         u64 val_lo = readl(ptr);
@@ -1264,15 +1382,12 @@ static inline u64 xhci_read_64(const struct xhci_hcd *xhci,
         return val_lo + (val_hi << 32);
 }
 static inline void xhci_write_64(struct xhci_hcd *xhci,
-                const u64 val, __u64 __iomem *regs)
+                                 const u64 val, __le64 __iomem *regs)
 {
         __u32 __iomem *ptr = (__u32 __iomem *) regs;
         u32 val_lo = lower_32_bits(val);
         u32 val_hi = upper_32_bits(val);
 
-        xhci_dbg(xhci,
-                        "`MEM_WRITE_DWORD(3'b000, 64'h%p, 64'h%0lx, 4'hf);\n",
-                        regs, (long unsigned int) val);
         writel(val_lo, ptr);
         writel(val_hi, ptr + 1);
 }
@@ -1285,7 +1400,7 @@ static inline int xhci_link_trb_quirk(struct xhci_hcd *xhci)
 }
 
 /* xHCI debugging */
-void xhci_print_ir_set(struct xhci_hcd *xhci, struct xhci_intr_reg *ir_set, int set_num);
+void xhci_print_ir_set(struct xhci_hcd *xhci, int set_num);
 void xhci_print_registers(struct xhci_hcd *xhci);
 void xhci_dbg_regs(struct xhci_hcd *xhci);
 void xhci_print_run_regs(struct xhci_hcd *xhci);
@@ -1341,6 +1456,8 @@ void xhci_setup_streams_ep_input_ctx(struct xhci_hcd *xhci,
 void xhci_setup_no_streams_ep_input_ctx(struct xhci_hcd *xhci,
                 struct xhci_ep_ctx *ep_ctx,
                 struct xhci_virt_ep *ep);
+void xhci_free_device_endpoint_resources(struct xhci_hcd *xhci,
+        struct xhci_virt_device *virt_dev, bool drop_control_ep);
 struct xhci_ring *xhci_dma_to_transfer_ring(
                 struct xhci_virt_ep *ep,
                 u64 address);
@@ -1369,6 +1486,15 @@ int xhci_init(struct usb_hcd *hcd);
 int xhci_run(struct usb_hcd *hcd);
 void xhci_stop(struct usb_hcd *hcd);
 void xhci_shutdown(struct usb_hcd *hcd);
+
+#ifdef  CONFIG_PM
+int xhci_suspend(struct xhci_hcd *xhci);
+int xhci_resume(struct xhci_hcd *xhci, bool hibernated);
+#else
+#define xhci_suspend    NULL
+#define xhci_resume     NULL
+#endif
+
 int xhci_get_frame(struct usb_hcd *hcd);
 irqreturn_t xhci_irq(struct usb_hcd *hcd);
 irqreturn_t xhci_msi_irq(int irq, struct usb_hcd *hcd);
@@ -1388,7 +1514,7 @@ int xhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status);
 int xhci_add_endpoint(struct usb_hcd *hcd, struct usb_device *udev, struct usb_host_endpoint *ep);
 int xhci_drop_endpoint(struct usb_hcd *hcd, struct usb_device *udev, struct usb_host_endpoint *ep);
 void xhci_endpoint_reset(struct usb_hcd *hcd, struct usb_host_endpoint *ep);
-int xhci_reset_device(struct usb_hcd *hcd, struct usb_device *udev);
+int xhci_discover_or_reset_device(struct usb_hcd *hcd, struct usb_device *udev);
 int xhci_check_bandwidth(struct usb_hcd *hcd, struct usb_device *udev);
 void xhci_reset_bandwidth(struct usb_hcd *hcd, struct usb_device *udev);
 
@@ -1399,14 +1525,13 @@ struct xhci_segment *trb_in_td(struct xhci_segment *start_seg,
                 dma_addr_t suspect_dma);
 int xhci_is_vendor_info_code(struct xhci_hcd *xhci, unsigned int trb_comp_code);
 void xhci_ring_cmd_db(struct xhci_hcd *xhci);
-void *xhci_setup_one_noop(struct xhci_hcd *xhci);
 int xhci_queue_slot_control(struct xhci_hcd *xhci, u32 trb_type, u32 slot_id);
 int xhci_queue_address_device(struct xhci_hcd *xhci, dma_addr_t in_ctx_ptr,
                 u32 slot_id);
 int xhci_queue_vendor_command(struct xhci_hcd *xhci,
                 u32 field1, u32 field2, u32 field3, u32 field4);
 int xhci_queue_stop_endpoint(struct xhci_hcd *xhci, int slot_id,
-                unsigned int ep_index);
+                unsigned int ep_index, int suspend);
 int xhci_queue_ctrl_tx(struct xhci_hcd *xhci, gfp_t mem_flags, struct urb *urb,
                 int slot_id, unsigned int ep_index);
 int xhci_queue_bulk_tx(struct xhci_hcd *xhci, gfp_t mem_flags, struct urb *urb,
@@ -1436,12 +1561,27 @@ void xhci_queue_config_ep_quirk(struct xhci_hcd *xhci,
                 unsigned int slot_id, unsigned int ep_index,
                 struct xhci_dequeue_state *deq_state);
 void xhci_stop_endpoint_command_watchdog(unsigned long arg);
+void xhci_ring_ep_doorbell(struct xhci_hcd *xhci, unsigned int slot_id,
+                unsigned int ep_index, unsigned int stream_id);
 
 /* xHCI roothub code */
 int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue, u16 wIndex,
                 char *buf, u16 wLength);
 int xhci_hub_status_data(struct usb_hcd *hcd, char *buf);
 
+#ifdef CONFIG_PM
+int xhci_bus_suspend(struct usb_hcd *hcd);
+int xhci_bus_resume(struct usb_hcd *hcd);
+#else
+#define xhci_bus_suspend        NULL
+#define xhci_bus_resume         NULL
+#endif  /* CONFIG_PM */
+
+u32 xhci_port_state_to_neutral(u32 state);
+int xhci_find_slot_id_by_port(struct usb_hcd *hcd, struct xhci_hcd *xhci,
+                u16 port);
+void xhci_ring_device(struct xhci_hcd *xhci, int slot_id);
+
 /* xHCI contexts */
 struct xhci_input_control_ctx *xhci_get_input_control_ctx(struct xhci_hcd *xhci, struct xhci_container_ctx *ctx);
 struct xhci_slot_ctx *xhci_get_slot_ctx(struct xhci_hcd *xhci, struct xhci_container_ctx *ctx);
diff --git a/drivers/usb/image/mdc800.c b/drivers/usb/image/mdc800.c
index e192e8f7c560..575b56c79e97 100644
--- a/drivers/usb/image/mdc800.c
+++ b/drivers/usb/image/mdc800.c
@@ -963,6 +963,7 @@ static const struct file_operations mdc800_device_ops =
         .write =        mdc800_device_write,
         .open =         mdc800_device_open,
         .release =      mdc800_device_release,
+        .llseek =       noop_llseek,
 };
 
 
diff --git a/drivers/usb/image/microtek.c b/drivers/usb/image/microtek.c
index 3a6bcd5fee09..a0037961e5bd 100644
--- a/drivers/usb/image/microtek.c
+++ b/drivers/usb/image/microtek.c
@@ -69,7 +69,7 @@
  *      20000513 added IDs for all products supported by Windows driver (john)
  *      20000514 Rewrote mts_scsi_queuecommand to use URBs (john)
  *      20000514 Version 0.0.8j
- *      20000514 Fix reporting of non-existant devices to SCSI layer (john)
+ *      20000514 Fix reporting of non-existent devices to SCSI layer (john)
  *      20000514 Added MTS_DEBUG_INT (john)
  *      20000514 Changed "usb-microtek" to "microtek" for consistency (john)
  *      20000514 Stupid bug fixes (john)
@@ -364,7 +364,7 @@ static int mts_scsi_host_reset(struct scsi_cmnd *srb)
 }
 
 static int
-mts_scsi_queuecommand(struct scsi_cmnd *srb, mts_scsi_cmnd_callback callback);
+mts_scsi_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *srb);
 
 static void mts_transfer_cleanup( struct urb *transfer );
 static void mts_do_sg(struct urb * transfer);
@@ -398,7 +398,6 @@ void mts_int_submit_urb (struct urb* transfer,
                 context->srb->result = DID_ERROR << 16;
                 mts_transfer_cleanup(transfer);
         }
-        return;
 }
 
 
@@ -409,7 +408,6 @@ static void mts_transfer_cleanup( struct urb *transfer )
 
         if ( likely(context->final_callback != NULL) )
                 context->final_callback(context->srb);
-
 }
 
 static void mts_transfer_done( struct urb *transfer )
@@ -420,8 +418,6 @@ static void mts_transfer_done( struct urb *transfer )
         context->srb->result |= (unsigned)(*context->scsi_status)<<1;
 
         mts_transfer_cleanup(transfer);
-
-        return;
 }
 
 
@@ -452,8 +448,6 @@ static void mts_data_done( struct urb* transfer )
         }
 
         mts_get_status(transfer);
-
-        return;
 }
 
 
@@ -496,8 +490,6 @@ static void mts_command_done( struct urb *transfer )
                         mts_get_status(transfer);
                 }
         }
-
-        return;
 }
 
 static void mts_do_sg (struct urb* transfer)
@@ -522,7 +514,6 @@ static void mts_do_sg (struct urb* transfer)
                            sg[context->fragment].length,
                            context->fragment + 1 == scsi_sg_count(context->srb) ?
                            mts_data_done : mts_do_sg);
-        return;
 }
 
 static const u8 mts_read_image_sig[] = { 0x28, 00, 00, 00 };
@@ -566,14 +557,14 @@ mts_build_transfer_context(struct scsi_cmnd *srb, struct mts_desc* desc)
 
         if ( !memcmp( srb->cmnd, mts_read_image_sig, mts_read_image_sig_len )
 ) {             pipe = usb_rcvbulkpipe(desc->usb_dev,desc->ep_image);
-                MTS_DEBUG( "transfering from desc->ep_image == %d\n",
+                MTS_DEBUG( "transferring from desc->ep_image == %d\n",
                            (int)desc->ep_image );
         } else if ( MTS_DIRECTION_IS_IN(srb->cmnd[0]) ) {
                         pipe = usb_rcvbulkpipe(desc->usb_dev,desc->ep_response);
-                        MTS_DEBUG( "transfering from desc->ep_response == %d\n",
+                        MTS_DEBUG( "transferring from desc->ep_response == %d\n",
                                    (int)desc->ep_response);
         } else {
-                MTS_DEBUG("transfering to desc->ep_out == %d\n",
+                MTS_DEBUG("transferring to desc->ep_out == %d\n",
                           (int)desc->ep_out);
                 pipe = usb_sndbulkpipe(desc->usb_dev,desc->ep_out);
         }
@@ -582,7 +573,7 @@ mts_build_transfer_context(struct scsi_cmnd *srb, struct mts_desc* desc)
 
 
 static int
-mts_scsi_queuecommand(struct scsi_cmnd *srb, mts_scsi_cmnd_callback callback)
+mts_scsi_queuecommand_lck(struct scsi_cmnd *srb, mts_scsi_cmnd_callback callback)
 {
         struct mts_desc* desc = (struct mts_desc*)(srb->device->host->hostdata[0]);
         int err = 0;
@@ -635,6 +626,8 @@ out:
         return err;
 }
 
+static DEF_SCSI_QCMD(mts_scsi_queuecommand)
+
 static struct scsi_host_template mts_scsi_host_template = {
         .module                 = THIS_MODULE,
         .name                   = "microtekX6",
diff --git a/drivers/usb/misc/Kconfig b/drivers/usb/misc/Kconfig
index 55660eaf947c..1bfcd02ebeb5 100644
--- a/drivers/usb/misc/Kconfig
+++ b/drivers/usb/misc/Kconfig
@@ -231,3 +231,16 @@ config USB_ISIGHTFW
           driver beforehand. Tools for doing so are available at
           http://bersace03.free.fr
 
+config USB_YUREX
+        tristate "USB YUREX driver support"
+        depends on USB
+        help
+          Say Y here if you want to connect a YUREX to your computer's
+          USB port. The YUREX is a leg-shakes sensor. See
+          <http://bbu.kayac.com/en/> for further information.
+          This driver supports read/write of leg-shakes counter and
+          fasync for the counter update via a device file /dev/yurex*.
+
+          To compile this driver as a module, choose M here: the
+          module will be called yurex.
+
diff --git a/drivers/usb/misc/Makefile b/drivers/usb/misc/Makefile
index 717703e81425..796ce7ebccc8 100644
--- a/drivers/usb/misc/Makefile
+++ b/drivers/usb/misc/Makefile
@@ -3,28 +3,27 @@
 # (the ones that don't fit into any other categories)
 #
 
-obj-$(CONFIG_USB_ADUTUX)        += adutux.o
-obj-$(CONFIG_USB_APPLEDISPLAY)  += appledisplay.o
-obj-$(CONFIG_USB_CYPRESS_CY7C63)+= cypress_cy7c63.o
-obj-$(CONFIG_USB_CYTHERM)       += cytherm.o
-obj-$(CONFIG_USB_EMI26)         += emi26.o
-obj-$(CONFIG_USB_EMI62)         += emi62.o
-obj-$(CONFIG_USB_FTDI_ELAN)     += ftdi-elan.o
-obj-$(CONFIG_USB_IDMOUSE)       += idmouse.o
-obj-$(CONFIG_USB_IOWARRIOR)     += iowarrior.o
-obj-$(CONFIG_USB_ISIGHTFW)      += isight_firmware.o
-obj-$(CONFIG_USB_LCD)           += usblcd.o
-obj-$(CONFIG_USB_LD)            += ldusb.o
-obj-$(CONFIG_USB_LED)           += usbled.o
-obj-$(CONFIG_USB_LEGOTOWER)     += legousbtower.o
-obj-$(CONFIG_USB_RIO500)        += rio500.o
-obj-$(CONFIG_USB_TEST)          += usbtest.o
-obj-$(CONFIG_USB_TRANCEVIBRATOR)        += trancevibrator.o
-obj-$(CONFIG_USB_USS720)        += uss720.o
-obj-$(CONFIG_USB_SEVSEG)        += usbsevseg.o
+ccflags-$(CONFIG_USB_DEBUG) := -DDEBUG
 
-obj-$(CONFIG_USB_SISUSBVGA)     += sisusbvga/
+obj-$(CONFIG_USB_ADUTUX)                += adutux.o
+obj-$(CONFIG_USB_APPLEDISPLAY)          += appledisplay.o
+obj-$(CONFIG_USB_CYPRESS_CY7C63)        += cypress_cy7c63.o
+obj-$(CONFIG_USB_CYTHERM)               += cytherm.o
+obj-$(CONFIG_USB_EMI26)                 += emi26.o
+obj-$(CONFIG_USB_EMI62)                 += emi62.o
+obj-$(CONFIG_USB_FTDI_ELAN)             += ftdi-elan.o
+obj-$(CONFIG_USB_IDMOUSE)               += idmouse.o
+obj-$(CONFIG_USB_IOWARRIOR)             += iowarrior.o
+obj-$(CONFIG_USB_ISIGHTFW)              += isight_firmware.o
+obj-$(CONFIG_USB_LCD)                   += usblcd.o
+obj-$(CONFIG_USB_LD)                    += ldusb.o
+obj-$(CONFIG_USB_LED)                   += usbled.o
+obj-$(CONFIG_USB_LEGOTOWER)             += legousbtower.o
+obj-$(CONFIG_USB_RIO500)                += rio500.o
+obj-$(CONFIG_USB_TEST)                  += usbtest.o
+obj-$(CONFIG_USB_TRANCEVIBRATOR)        += trancevibrator.o
+obj-$(CONFIG_USB_USS720)                += uss720.o
+obj-$(CONFIG_USB_SEVSEG)                += usbsevseg.o
+obj-$(CONFIG_USB_YUREX)                 += yurex.o
 
-ifeq ($(CONFIG_USB_DEBUG),y)
-EXTRA_CFLAGS += -DDEBUG
-endif
+obj-$(CONFIG_USB_SISUSBVGA)             += sisusbvga/
diff --git a/drivers/usb/misc/adutux.c b/drivers/usb/misc/adutux.c
index 801324af9470..a6afd15f6a46 100644
--- a/drivers/usb/misc/adutux.c
+++ b/drivers/usb/misc/adutux.c
@@ -679,6 +679,7 @@ static const struct file_operations adu_fops = {
         .write = adu_write,
         .open = adu_open,
         .release = adu_release,
+        .llseek = noop_llseek,
 };
 
 /*
@@ -716,7 +717,7 @@ static int adu_probe(struct usb_interface *interface,
                 goto exit;
         }
 
-        /* allocate memory for our device state and intialize it */
+        /* allocate memory for our device state and initialize it */
         dev = kzalloc(sizeof(struct adu_device), GFP_KERNEL);
         if (dev == NULL) {
                 dev_err(&interface->dev, "Out of memory\n");
diff --git a/drivers/usb/misc/appledisplay.c b/drivers/usb/misc/appledisplay.c
index 1fa6ce3e4a23..68ab460a735c 100644
--- a/drivers/usb/misc/appledisplay.c
+++ b/drivers/usb/misc/appledisplay.c
@@ -282,6 +282,7 @@ static int appledisplay_probe(struct usb_interface *iface,
         snprintf(bl_name, sizeof(bl_name), "appledisplay%d",
                 atomic_inc_return(&count_displays) - 1);
         memset(&props, 0, sizeof(struct backlight_properties));
+        props.type = BACKLIGHT_RAW;
         props.max_brightness = 0xff;
         pdata->bd = backlight_device_register(bl_name, NULL, pdata,
                                               &appledisplay_bl_data, &props);
diff --git a/drivers/usb/misc/cypress_cy7c63.c b/drivers/usb/misc/cypress_cy7c63.c
index 2f43c57743c9..9251773ecef4 100644
--- a/drivers/usb/misc/cypress_cy7c63.c
+++ b/drivers/usb/misc/cypress_cy7c63.c
@@ -196,11 +196,9 @@ static ssize_t get_port1_handler(struct device *dev,
         return read_port(dev, attr, buf, 1, CYPRESS_READ_PORT_ID1);
 }
 
-static DEVICE_ATTR(port0, S_IWUGO | S_IRUGO,
-                   get_port0_handler, set_port0_handler);
+static DEVICE_ATTR(port0, S_IRUGO | S_IWUSR, get_port0_handler, set_port0_handler);
 
-static DEVICE_ATTR(port1, S_IWUGO | S_IRUGO,
-                   get_port1_handler, set_port1_handler);
+static DEVICE_ATTR(port1, S_IRUGO | S_IWUSR, get_port1_handler, set_port1_handler);
 
 
 static int cypress_probe(struct usb_interface *interface,
diff --git a/drivers/usb/misc/ftdi-elan.c b/drivers/usb/misc/ftdi-elan.c
index aecf380f6ecc..b16bd3ce3915 100644
--- a/drivers/usb/misc/ftdi-elan.c
+++ b/drivers/usb/misc/ftdi-elan.c
@@ -456,7 +456,6 @@ static void ftdi_elan_cancel_targets(struct usb_ftdi *ftdi)
 static void ftdi_elan_kick_command_queue(struct usb_ftdi *ftdi)
 {
         ftdi_command_queue_work(ftdi, 0);
-        return;
 }
 
 static void ftdi_elan_command_work(struct work_struct *work)
@@ -483,7 +482,6 @@ static void ftdi_elan_command_work(struct work_struct *work)
 static void ftdi_elan_kick_respond_queue(struct usb_ftdi *ftdi)
 {
         ftdi_respond_queue_work(ftdi, 0);
-        return;
 }
 
 static void ftdi_elan_respond_work(struct work_struct *work)
@@ -2769,7 +2767,7 @@ static int ftdi_elan_probe(struct usb_interface *interface,
         ftdi->sequence_num = ++ftdi_instances;
         mutex_unlock(&ftdi_module_lock);
         ftdi_elan_init_kref(ftdi);
-        init_MUTEX(&ftdi->sw_lock);
+        sema_init(&ftdi->sw_lock, 1);
         ftdi->udev = usb_get_dev(interface_to_usbdev(interface));
         ftdi->interface = interface;
         mutex_init(&ftdi->u132_lock);
@@ -2891,8 +2889,7 @@ static struct usb_driver ftdi_elan_driver = {
 static int __init ftdi_elan_init(void)
 {
         int result;
-        printk(KERN_INFO "driver %s built at %s on %s\n", ftdi_elan_driver.name,
-               __TIME__, __DATE__);
+        printk(KERN_INFO "driver %s\n", ftdi_elan_driver.name);
         mutex_init(&ftdi_module_lock);
         INIT_LIST_HEAD(&ftdi_static_list);
         status_queue = create_singlethread_workqueue("ftdi-status-control");
diff --git a/drivers/usb/misc/idmouse.c b/drivers/usb/misc/idmouse.c
index a54c3cb804ce..c6184b4d1695 100644
--- a/drivers/usb/misc/idmouse.c
+++ b/drivers/usb/misc/idmouse.c
@@ -105,6 +105,7 @@ static const struct file_operations idmouse_fops = {
         .read = idmouse_read,
         .open = idmouse_open,
         .release = idmouse_release,
+        .llseek = default_llseek,
 };
 
 /* class driver information */
diff --git a/drivers/usb/misc/iowarrior.c b/drivers/usb/misc/iowarrior.c
index bc88c79875a1..a2190b983f52 100644
--- a/drivers/usb/misc/iowarrior.c
+++ b/drivers/usb/misc/iowarrior.c
@@ -40,7 +40,7 @@
 #ifdef CONFIG_USB_DYNAMIC_MINORS
 #define IOWARRIOR_MINOR_BASE    0
 #else
-#define IOWARRIOR_MINOR_BASE    208     // SKELETON_MINOR_BASE 192 + 16, not offical yet
+#define IOWARRIOR_MINOR_BASE    208     // SKELETON_MINOR_BASE 192 + 16, not official yet
 #endif
 
 /* interrupt input queue size */
@@ -374,7 +374,7 @@ static ssize_t iowarrior_write(struct file *file,
         case USB_DEVICE_ID_CODEMERCS_IOWPV2:
         case USB_DEVICE_ID_CODEMERCS_IOW40:
                 /* IOW24 and IOW40 use a synchronous call */
-                buf = kmalloc(8, GFP_KERNEL);   /* 8 bytes are enough for both products */
+                buf = kmalloc(count, GFP_KERNEL);
                 if (!buf) {
                         retval = -ENOMEM;
                         goto exit;
@@ -553,6 +553,7 @@ static long iowarrior_ioctl(struct file *file, unsigned int cmd,
                         /* needed for power consumption */
                         struct usb_config_descriptor *cfg_descriptor = &dev->udev->actconfig->desc;
 
+                        memset(&info, 0, sizeof(info));
                         /* directly from the descriptor */
                         info.vendor = le16_to_cpu(dev->udev->descriptor.idVendor);
                         info.product = dev->product_id;
@@ -730,6 +731,7 @@ static const struct file_operations iowarrior_fops = {
         .open = iowarrior_open,
         .release = iowarrior_release,
         .poll = iowarrior_poll,
+        .llseek = noop_llseek,
 };
 
 static char *iowarrior_devnode(struct device *dev, mode_t *mode)
@@ -767,7 +769,7 @@ static int iowarrior_probe(struct usb_interface *interface,
         int i;
         int retval = -ENOMEM;
 
-        /* allocate memory for our device state and intialize it */
+        /* allocate memory for our device state and initialize it */
         dev = kzalloc(sizeof(struct iowarrior), GFP_KERNEL);
         if (dev == NULL) {
                 dev_err(&interface->dev, "Out of memory\n");
diff --git a/drivers/usb/misc/ldusb.c b/drivers/usb/misc/ldusb.c
index dd41d8710043..cb4096201e29 100644
--- a/drivers/usb/misc/ldusb.c
+++ b/drivers/usb/misc/ldusb.c
@@ -20,11 +20,6 @@
  * Derived from Lego USB Tower driver
  * Copyright (C) 2003 David Glance <advidgsf@sourceforge.net>
  *               2001-2004 Juergen Stuber <starblue@users.sourceforge.net>
- *
- * V0.1  (mh) Initial version
- * V0.11 (mh) Added raw support for HID 1.0 devices (no interrupt out endpoint)
- * V0.12 (mh) Added kmalloc check for string buffer
- * V0.13 (mh) Added support for LD X-Ray and Machine Test System
  */
 
 #include <linux/kernel.h>
@@ -41,20 +36,39 @@
 
 /* Define these values to match your devices */
 #define USB_VENDOR_ID_LD                0x0f11  /* USB Vendor ID of LD Didactic GmbH */
-#define USB_DEVICE_ID_LD_CASSY          0x1000  /* USB Product ID of CASSY-S */
+#define USB_DEVICE_ID_LD_CASSY          0x1000  /* USB Product ID of CASSY-S modules with 8 bytes endpoint size */
+#define USB_DEVICE_ID_LD_CASSY2         0x1001  /* USB Product ID of CASSY-S modules with 64 bytes endpoint size */
 #define USB_DEVICE_ID_LD_POCKETCASSY    0x1010  /* USB Product ID of Pocket-CASSY */
+#define USB_DEVICE_ID_LD_POCKETCASSY2   0x1011  /* USB Product ID of Pocket-CASSY 2 (reserved) */
 #define USB_DEVICE_ID_LD_MOBILECASSY    0x1020  /* USB Product ID of Mobile-CASSY */
+#define USB_DEVICE_ID_LD_MOBILECASSY2   0x1021  /* USB Product ID of Mobile-CASSY 2 (reserved) */
+#define USB_DEVICE_ID_LD_MICROCASSYVOLTAGE      0x1031  /* USB Product ID of Micro-CASSY Voltage */
+#define USB_DEVICE_ID_LD_MICROCASSYCURRENT      0x1032  /* USB Product ID of Micro-CASSY Current */
+#define USB_DEVICE_ID_LD_MICROCASSYTIME         0x1033  /* USB Product ID of Micro-CASSY Time (reserved) */
+#define USB_DEVICE_ID_LD_MICROCASSYTEMPERATURE  0x1035  /* USB Product ID of Micro-CASSY Temperature */
+#define USB_DEVICE_ID_LD_MICROCASSYPH           0x1038  /* USB Product ID of Micro-CASSY pH */
 #define USB_DEVICE_ID_LD_JWM            0x1080  /* USB Product ID of Joule and Wattmeter */
 #define USB_DEVICE_ID_LD_DMMP           0x1081  /* USB Product ID of Digital Multimeter P (reserved) */
 #define USB_DEVICE_ID_LD_UMIP           0x1090  /* USB Product ID of UMI P */
-#define USB_DEVICE_ID_LD_XRAY1          0x1100  /* USB Product ID of X-Ray Apparatus */
-#define USB_DEVICE_ID_LD_XRAY2          0x1101  /* USB Product ID of X-Ray Apparatus */
+#define USB_DEVICE_ID_LD_UMIC           0x10A0  /* USB Product ID of UMI C */
+#define USB_DEVICE_ID_LD_UMIB           0x10B0  /* USB Product ID of UMI B */
+#define USB_DEVICE_ID_LD_XRAY           0x1100  /* USB Product ID of X-Ray Apparatus 55481 */
+#define USB_DEVICE_ID_LD_XRAY2          0x1101  /* USB Product ID of X-Ray Apparatus 554800 */
+#define USB_DEVICE_ID_LD_XRAYCT         0x1110  /* USB Product ID of X-Ray Apparatus CT 554821*/
 #define USB_DEVICE_ID_LD_VIDEOCOM       0x1200  /* USB Product ID of VideoCom */
+#define USB_DEVICE_ID_LD_MOTOR          0x1210  /* USB Product ID of Motor (reserved) */
 #define USB_DEVICE_ID_LD_COM3LAB        0x2000  /* USB Product ID of COM3LAB */
 #define USB_DEVICE_ID_LD_TELEPORT       0x2010  /* USB Product ID of Terminal Adapter */
 #define USB_DEVICE_ID_LD_NETWORKANALYSER 0x2020 /* USB Product ID of Network Analyser */
 #define USB_DEVICE_ID_LD_POWERCONTROL   0x2030  /* USB Product ID of Converter Control Unit */
 #define USB_DEVICE_ID_LD_MACHINETEST    0x2040  /* USB Product ID of Machine Test System */
+#define USB_DEVICE_ID_LD_MOSTANALYSER   0x2050  /* USB Product ID of MOST Protocol Analyser */
+#define USB_DEVICE_ID_LD_MOSTANALYSER2  0x2051  /* USB Product ID of MOST Protocol Analyser 2 */
+#define USB_DEVICE_ID_LD_ABSESP         0x2060  /* USB Product ID of ABS ESP */
+#define USB_DEVICE_ID_LD_AUTODATABUS    0x2070  /* USB Product ID of Automotive Data Buses */
+#define USB_DEVICE_ID_LD_MCT            0x2080  /* USB Product ID of Microcontroller technique */
+#define USB_DEVICE_ID_LD_HYBRID         0x2090  /* USB Product ID of Automotive Hybrid */
+#define USB_DEVICE_ID_LD_HEATCONTROL    0x20A0  /* USB Product ID of Heat control */
 
 #define USB_VENDOR_ID_VERNIER           0x08f7
 #define USB_DEVICE_ID_VERNIER_GOTEMP    0x0002
@@ -71,19 +85,37 @@
 /* table of devices that work with this driver */
 static const struct usb_device_id ld_usb_table[] = {
         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_CASSY) },
+        { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_CASSY2) },
         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_POCKETCASSY) },
+        { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_POCKETCASSY2) },
         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOBILECASSY) },
+        { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOBILECASSY2) },
+        { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYVOLTAGE) },
+        { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYCURRENT) },
+        { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYTIME) },
+        { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYTEMPERATURE) },
+        { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYPH) },
         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_JWM) },
         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_DMMP) },
         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_UMIP) },
-        { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_XRAY1) },
+        { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_UMIC) },
+        { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_UMIB) },
+        { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_XRAY) },
         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_XRAY2) },
         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_VIDEOCOM) },
+        { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOTOR) },
         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_COM3LAB) },
         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_TELEPORT) },
         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_NETWORKANALYSER) },
         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_POWERCONTROL) },
         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MACHINETEST) },
+        { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOSTANALYSER) },
+        { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOSTANALYSER2) },
+        { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_ABSESP) },
+        { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_AUTODATABUS) },
+        { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MCT) },
+        { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_HYBRID) },
+        { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_HEATCONTROL) },
         { USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_GOTEMP) },
         { USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_SKIP) },
         { USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_CYCLOPS) },
@@ -91,7 +123,7 @@ static const struct usb_device_id ld_usb_table[] = {
         { }                                     /* Terminating entry */
 };
 MODULE_DEVICE_TABLE(usb, ld_usb_table);
-MODULE_VERSION("V0.13");
+MODULE_VERSION("V0.14");
 MODULE_AUTHOR("Michael Hund <mhund@ld-didactic.de>");
 MODULE_DESCRIPTION("LD USB Driver");
 MODULE_LICENSE("GPL");
@@ -613,6 +645,7 @@ static const struct file_operations ld_usb_fops = {
         .open =         ld_usb_open,
         .release =      ld_usb_release,
         .poll =         ld_usb_poll,
+        .llseek =       no_llseek,
 };
 
 /*
@@ -641,7 +674,7 @@ static int ld_usb_probe(struct usb_interface *intf, const struct usb_device_id *
         int i;
         int retval = -ENOMEM;
 
-        /* allocate memory for our device state and intialize it */
+        /* allocate memory for our device state and initialize it */
 
         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
         if (dev == NULL) {
diff --git a/drivers/usb/misc/rio500.c b/drivers/usb/misc/rio500.c
index cc13ae61712a..4e23d3841b43 100644
--- a/drivers/usb/misc/rio500.c
+++ b/drivers/usb/misc/rio500.c
@@ -439,6 +439,7 @@ static const struct file_operations usb_rio_fops = {
         .unlocked_ioctl = ioctl_rio,
         .open =         open_rio,
         .release =      close_rio,
+        .llseek =       noop_llseek,
 };
 
 static struct usb_class_driver usb_rio_class = {
diff --git a/drivers/usb/misc/sisusbvga/Makefile b/drivers/usb/misc/sisusbvga/Makefile
index 7f934cfc906c..3142476ccc8e 100644
--- a/drivers/usb/misc/sisusbvga/Makefile
+++ b/drivers/usb/misc/sisusbvga/Makefile
@@ -4,5 +4,4 @@
 
 obj-$(CONFIG_USB_SISUSBVGA) += sisusbvga.o
 
-sisusbvga-objs := sisusb.o sisusb_init.o sisusb_con.o
-
+sisusbvga-y := sisusb.o sisusb_init.o sisusb_con.o
diff --git a/drivers/usb/misc/sisusbvga/sisusb.c b/drivers/usb/misc/sisusbvga/sisusb.c
index 70d00e99a4b4..dd573abd2d1e 100644
--- a/drivers/usb/misc/sisusbvga/sisusb.c
+++ b/drivers/usb/misc/sisusbvga/sisusb.c
@@ -3008,6 +3008,7 @@ sisusb_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 #else
                         x.sisusb_conactive  = 0;
 #endif
+                        memset(x.sisusb_reserved, 0, sizeof(x.sisusb_reserved));
 
                         if (copy_to_user((void __user *)arg, &x, sizeof(x)))
                                 retval = -EFAULT;
diff --git a/drivers/usb/misc/trancevibrator.c b/drivers/usb/misc/trancevibrator.c
index d77aba46ae85..f63776a48e2a 100644
--- a/drivers/usb/misc/trancevibrator.c
+++ b/drivers/usb/misc/trancevibrator.c
@@ -86,7 +86,7 @@ static ssize_t set_speed(struct device *dev, struct device_attribute *attr,
         return count;
 }
 
-static DEVICE_ATTR(speed, S_IWUGO | S_IRUGO, show_speed, set_speed);
+static DEVICE_ATTR(speed, S_IRUGO | S_IWUSR, show_speed, set_speed);
 
 static int tv_probe(struct usb_interface *interface,
                     const struct usb_device_id *id)
diff --git a/drivers/usb/misc/usblcd.c b/drivers/usb/misc/usblcd.c
index d00dde19194c..51648154bb44 100644
--- a/drivers/usb/misc/usblcd.c
+++ b/drivers/usb/misc/usblcd.c
@@ -282,6 +282,7 @@ static const struct file_operations lcd_fops = {
         .open =         lcd_open,
         .unlocked_ioctl = lcd_ioctl,
         .release =      lcd_release,
+        .llseek =        noop_llseek,
 };
 
 /*
diff --git a/drivers/usb/misc/usbled.c b/drivers/usb/misc/usbled.c
index 63da2c3c838f..1616ad1793a4 100644
--- a/drivers/usb/misc/usbled.c
+++ b/drivers/usb/misc/usbled.c
@@ -1,5 +1,5 @@
 /*
- * USB LED driver - 1.1
+ * USB LED driver
  *
  * Copyright (C) 2004 Greg Kroah-Hartman (greg@kroah.com)
  *
@@ -20,12 +20,17 @@
 #define DRIVER_AUTHOR "Greg Kroah-Hartman, greg@kroah.com"
 #define DRIVER_DESC "USB LED Driver"
 
-#define VENDOR_ID       0x0fc5
-#define PRODUCT_ID      0x1223
+enum led_type {
+        DELCOM_VISUAL_SIGNAL_INDICATOR,
+        DREAM_CHEEKY_WEBMAIL_NOTIFIER,
+};
 
 /* table of devices that work with this driver */
 static const struct usb_device_id id_table[] = {
-        { USB_DEVICE(VENDOR_ID, PRODUCT_ID) },
+        { USB_DEVICE(0x0fc5, 0x1223),
+                        .driver_info = DELCOM_VISUAL_SIGNAL_INDICATOR },
+        { USB_DEVICE(0x1d34, 0x0004),
+                        .driver_info = DREAM_CHEEKY_WEBMAIL_NOTIFIER },
         { },
 };
 MODULE_DEVICE_TABLE (usb, id_table);
@@ -35,15 +40,12 @@ struct usb_led {
         unsigned char           blue;
         unsigned char           red;
         unsigned char           green;
+        enum led_type           type;
 };
 
-#define BLUE    0x04
-#define RED     0x02
-#define GREEN   0x01
 static void change_color(struct usb_led *led)
 {
-        int retval;
-        unsigned char color = 0x07;
+        int retval = 0;
         unsigned char *buffer;
 
         buffer = kmalloc(8, GFP_KERNEL);
@@ -52,25 +54,59 @@ static void change_color(struct usb_led *led)
                 return;
         }
 
-        if (led->blue)
-                color &= ~(BLUE);
-        if (led->red)
-                color &= ~(RED);
-        if (led->green)
-                color &= ~(GREEN);
-        dev_dbg(&led->udev->dev,
-                "blue = %d, red = %d, green = %d, color = %.2x\n",
-                led->blue, led->red, led->green, color);
-
-        retval = usb_control_msg(led->udev,
-                                usb_sndctrlpipe(led->udev, 0),
-                                0x12,
-                                0xc8,
-                                (0x02 * 0x100) + 0x0a,
-                                (0x00 * 0x100) + color,
-                                buffer, 
-                                8,
-                                2000);
+        switch (led->type) {
+        case DELCOM_VISUAL_SIGNAL_INDICATOR: {
+                unsigned char color = 0x07;
+
+                if (led->blue)
+                        color &= ~0x04;
+                if (led->red)
+                        color &= ~0x02;
+                if (led->green)
+                        color &= ~0x01;
+                dev_dbg(&led->udev->dev,
+                        "blue = %d, red = %d, green = %d, color = %.2x\n",
+                        led->blue, led->red, led->green, color);
+
+                retval = usb_control_msg(led->udev,
+                                        usb_sndctrlpipe(led->udev, 0),
+                                        0x12,
+                                        0xc8,
+                                        (0x02 * 0x100) + 0x0a,
+                                        (0x00 * 0x100) + color,
+                                        buffer,
+                                        8,
+                                        2000);
+                break;
+        }
+
+        case DREAM_CHEEKY_WEBMAIL_NOTIFIER:
+                dev_dbg(&led->udev->dev,
+                        "red = %d, green = %d, blue = %d\n",
+                        led->red, led->green, led->blue);
+
+                buffer[0] = led->red;
+                buffer[1] = led->green;
+                buffer[2] = led->blue;
+                buffer[3] = buffer[4] = buffer[5] = 0;
+                buffer[6] = 0x1a;
+                buffer[7] = 0x05;
+
+                retval = usb_control_msg(led->udev,
+                                        usb_sndctrlpipe(led->udev, 0),
+                                        0x09,
+                                        0x21,
+                                        0x200,
+                                        0,
+                                        buffer,
+                                        8,
+                                        2000);
+                break;
+
+        default:
+                dev_err(&led->udev->dev, "unknown device type %d\n", led->type);
+        }
+
         if (retval)
                 dev_dbg(&led->udev->dev, "retval = %d\n", retval);
         kfree(buffer);
@@ -94,7 +130,7 @@ static ssize_t set_##value(struct device *dev, struct device_attribute *attr, co
         change_color(led);                                              \
         return count;                                                   \
 }                                                                       \
-static DEVICE_ATTR(value, S_IWUGO | S_IRUGO, show_##value, set_##value);
+static DEVICE_ATTR(value, S_IRUGO | S_IWUSR, show_##value, set_##value);
 show_set(blue);
 show_set(red);
 show_set(green);
@@ -107,11 +143,12 @@ static int led_probe(struct usb_interface *interface, const struct usb_device_id
 
         dev = kzalloc(sizeof(struct usb_led), GFP_KERNEL);
         if (dev == NULL) {
-                dev_err(&interface->dev, "Out of memory\n");
+                dev_err(&interface->dev, "out of memory\n");
                 goto error_mem;
         }
 
         dev->udev = usb_get_dev(udev);
+        dev->type = id->driver_info;
 
         usb_set_intfdata (interface, dev);
 
@@ -125,6 +162,31 @@ static int led_probe(struct usb_interface *interface, const struct usb_device_id
         if (retval)
                 goto error;
 
+        if (dev->type == DREAM_CHEEKY_WEBMAIL_NOTIFIER) {
+                unsigned char *enable;
+
+                enable = kmemdup("\x1f\x02\0\x5f\0\0\x1a\x03", 8, GFP_KERNEL);
+                if (!enable) {
+                        dev_err(&interface->dev, "out of memory\n");
+                        retval = -ENOMEM;
+                        goto error;
+                }
+
+                retval = usb_control_msg(udev,
+                                        usb_sndctrlpipe(udev, 0),
+                                        0x09,
+                                        0x21,
+                                        0x200,
+                                        0,
+                                        enable,
+                                        8,
+                                        2000);
+
+                kfree(enable);
+                if (retval != 8)
+                        goto error;
+        }
+
         dev_info(&interface->dev, "USB LED device now attached\n");
         return 0;
 
diff --git a/drivers/usb/misc/usbsevseg.c b/drivers/usb/misc/usbsevseg.c
index de8ef945b536..417b8f207e8b 100644
--- a/drivers/usb/misc/usbsevseg.c
+++ b/drivers/usb/misc/usbsevseg.c
@@ -192,7 +192,7 @@ static ssize_t set_attr_##name(struct device *dev, 		\
                                                                 \
         return count;                                           \
 }                                                               \
-static DEVICE_ATTR(name, S_IWUGO | S_IRUGO, show_attr_##name, set_attr_##name);
+static DEVICE_ATTR(name, S_IRUGO | S_IWUSR, show_attr_##name, set_attr_##name);
 
 static ssize_t show_attr_text(struct device *dev,
         struct device_attribute *attr, char *buf)
@@ -223,7 +223,7 @@ static ssize_t set_attr_text(struct device *dev,
         return count;
 }
 
-static DEVICE_ATTR(text, S_IWUGO | S_IRUGO, show_attr_text, set_attr_text);
+static DEVICE_ATTR(text, S_IRUGO | S_IWUSR, show_attr_text, set_attr_text);
 
 static ssize_t show_attr_decimals(struct device *dev,
         struct device_attribute *attr, char *buf)
@@ -272,8 +272,7 @@ static ssize_t set_attr_decimals(struct device *dev,
         return count;
 }
 
-static DEVICE_ATTR(decimals, S_IWUGO | S_IRUGO,
-        show_attr_decimals, set_attr_decimals);
+static DEVICE_ATTR(decimals, S_IRUGO | S_IWUSR, show_attr_decimals, set_attr_decimals);
 
 static ssize_t show_attr_textmode(struct device *dev,
         struct device_attribute *attr, char *buf)
@@ -319,8 +318,7 @@ static ssize_t set_attr_textmode(struct device *dev,
         return -EINVAL;
 }
 
-static DEVICE_ATTR(textmode, S_IWUGO | S_IRUGO,
-        show_attr_textmode, set_attr_textmode);
+static DEVICE_ATTR(textmode, S_IRUGO | S_IWUSR, show_attr_textmode, set_attr_textmode);
 
 
 MYDEV_ATTR_SIMPLE_UNSIGNED(powered, update_display_powered);
diff --git a/drivers/usb/misc/usbtest.c b/drivers/usb/misc/usbtest.c
index eef370eb7a54..bb10846affc3 100644
--- a/drivers/usb/misc/usbtest.c
+++ b/drivers/usb/misc/usbtest.c
@@ -13,17 +13,16 @@
 
 /*-------------------------------------------------------------------------*/
 
-// FIXME make these public somewhere; usbdevfs.h?
-//
+/* FIXME make these public somewhere; usbdevfs.h? */
 struct usbtest_param {
-        // inputs
+        /* inputs */
         unsigned                test_num;       /* 0..(TEST_CASES-1) */
         unsigned                iterations;
         unsigned                length;
         unsigned                vary;
         unsigned                sglen;
 
-        // outputs
+        /* outputs */
         struct timeval          duration;
 };
 #define USBTEST_REQUEST _IOWR('U', 100, struct usbtest_param)
@@ -45,9 +44,9 @@ struct usbtest_info {
         const char              *name;
         u8                      ep_in;          /* bulk/intr source */
         u8                      ep_out;         /* bulk/intr sink */
-        unsigned                autoconf : 1;
-        unsigned                ctrl_out : 1;
-        unsigned                iso : 1;        /* try iso in/out */
+        unsigned                autoconf:1;
+        unsigned                ctrl_out:1;
+        unsigned                iso:1;          /* try iso in/out */
         int                     alt;
 };
 
@@ -71,9 +70,9 @@ struct usbtest_dev {
         u8                      *buf;
 };
 
-static struct usb_device *testdev_to_usbdev (struct usbtest_dev *test)
+static struct usb_device *testdev_to_usbdev(struct usbtest_dev *test)
 {
-        return interface_to_usbdev (test->intf);
+        return interface_to_usbdev(test->intf);
 }
 
 /* set up all urbs so they can be used with either bulk or interrupt */
@@ -84,10 +83,12 @@ static struct usb_device *testdev_to_usbdev (struct usbtest_dev *test)
 #define WARNING(tdev, fmt, args...) \
         dev_warn(&(tdev)->intf->dev , fmt , ## args)
 
+#define GUARD_BYTE      0xA5
+
 /*-------------------------------------------------------------------------*/
 
 static int
-get_endpoints (struct usbtest_dev *dev, struct usb_interface *intf)
+get_endpoints(struct usbtest_dev *dev, struct usb_interface *intf)
 {
         int                             tmp;
         struct usb_host_interface       *alt;
@@ -103,7 +104,7 @@ get_endpoints (struct usbtest_dev *dev, struct usb_interface *intf)
                 alt = intf->altsetting + tmp;
 
                 /* take the first altsetting with in-bulk + out-bulk;
-                 * ignore other endpoints and altsetttings.
+                 * ignore other endpoints and altsettings.
                  */
                 for (ep = 0; ep < alt->desc.bNumEndpoints; ep++) {
                         struct usb_host_endpoint        *e;
@@ -115,7 +116,7 @@ get_endpoints (struct usbtest_dev *dev, struct usb_interface *intf)
                         case USB_ENDPOINT_XFER_ISOC:
                                 if (dev->info->iso)
                                         goto try_iso;
-                                // FALLTHROUGH
+                                /* FALLTHROUGH */
                         default:
                                 continue;
                         }
@@ -142,9 +143,9 @@ try_iso:
         return -EINVAL;
 
 found:
-        udev = testdev_to_usbdev (dev);
+        udev = testdev_to_usbdev(dev);
         if (alt->desc.bAlternateSetting != 0) {
-                tmp = usb_set_interface (udev,
+                tmp = usb_set_interface(udev,
                                 alt->desc.bInterfaceNumber,
                                 alt->desc.bAlternateSetting);
                 if (tmp < 0)
@@ -152,21 +153,21 @@ found:
         }
 
         if (in) {
-                dev->in_pipe = usb_rcvbulkpipe (udev,
+                dev->in_pipe = usb_rcvbulkpipe(udev,
                         in->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
-                dev->out_pipe = usb_sndbulkpipe (udev,
+                dev->out_pipe = usb_sndbulkpipe(udev,
                         out->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
         }
         if (iso_in) {
                 dev->iso_in = &iso_in->desc;
-                dev->in_iso_pipe = usb_rcvisocpipe (udev,
+                dev->in_iso_pipe = usb_rcvisocpipe(udev,
                                 iso_in->desc.bEndpointAddress
                                         & USB_ENDPOINT_NUMBER_MASK);
         }
 
         if (iso_out) {
                 dev->iso_out = &iso_out->desc;
-                dev->out_iso_pipe = usb_sndisocpipe (udev,
+                dev->out_iso_pipe = usb_sndisocpipe(udev,
                                 iso_out->desc.bEndpointAddress
                                         & USB_ENDPOINT_NUMBER_MASK);
         }
@@ -182,45 +183,73 @@ found:
  * them with non-zero test data (or test for it) when appropriate.
  */
 
-static void simple_callback (struct urb *urb)
+static void simple_callback(struct urb *urb)
 {
         complete(urb->context);
 }
 
-static struct urb *simple_alloc_urb (
+static struct urb *usbtest_alloc_urb(
         struct usb_device       *udev,
         int                     pipe,
-        unsigned long           bytes
-)
+        unsigned long           bytes,
+        unsigned                transfer_flags,
+        unsigned                offset)
 {
         struct urb              *urb;
 
-        urb = usb_alloc_urb (0, GFP_KERNEL);
+        urb = usb_alloc_urb(0, GFP_KERNEL);
         if (!urb)
                 return urb;
-        usb_fill_bulk_urb (urb, udev, pipe, NULL, bytes, simple_callback, NULL);
+        usb_fill_bulk_urb(urb, udev, pipe, NULL, bytes, simple_callback, NULL);
         urb->interval = (udev->speed == USB_SPEED_HIGH)
                         ? (INTERRUPT_RATE << 3)
                         : INTERRUPT_RATE;
-        urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
-        if (usb_pipein (pipe))
+        urb->transfer_flags = transfer_flags;
+        if (usb_pipein(pipe))
                 urb->transfer_flags |= URB_SHORT_NOT_OK;
-        urb->transfer_buffer = usb_alloc_coherent (udev, bytes, GFP_KERNEL,
-                        &urb->transfer_dma);
+
+        if (urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)
+                urb->transfer_buffer = usb_alloc_coherent(udev, bytes + offset,
+                        GFP_KERNEL, &urb->transfer_dma);
+        else
+                urb->transfer_buffer = kmalloc(bytes + offset, GFP_KERNEL);
+
         if (!urb->transfer_buffer) {
-                usb_free_urb (urb);
-                urb = NULL;
-        } else
-                memset (urb->transfer_buffer, 0, bytes);
+                usb_free_urb(urb);
+                return NULL;
+        }
+
+        /* To test unaligned transfers add an offset and fill the
+                unused memory with a guard value */
+        if (offset) {
+                memset(urb->transfer_buffer, GUARD_BYTE, offset);
+                urb->transfer_buffer += offset;
+                if (urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)
+                        urb->transfer_dma += offset;
+        }
+
+        /* For inbound transfers use guard byte so that test fails if
+                data not correctly copied */
+        memset(urb->transfer_buffer,
+                        usb_pipein(urb->pipe) ? GUARD_BYTE : 0,
+                        bytes);
         return urb;
 }
 
-static unsigned pattern = 0;
+static struct urb *simple_alloc_urb(
+        struct usb_device       *udev,
+        int                     pipe,
+        unsigned long           bytes)
+{
+        return usbtest_alloc_urb(udev, pipe, bytes, URB_NO_TRANSFER_DMA_MAP, 0);
+}
+
+static unsigned pattern;
 static unsigned mod_pattern;
 module_param_named(pattern, mod_pattern, uint, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(mod_pattern, "i/o pattern (0 == zeroes)");
 
-static inline void simple_fill_buf (struct urb *urb)
+static inline void simple_fill_buf(struct urb *urb)
 {
         unsigned        i;
         u8              *buf = urb->transfer_buffer;
@@ -228,9 +257,9 @@ static inline void simple_fill_buf (struct urb *urb)
 
         switch (pattern) {
         default:
-                // FALLTHROUGH
+                /* FALLTHROUGH */
         case 0:
-                memset (buf, 0, len);
+                memset(buf, 0, len);
                 break;
         case 1:                 /* mod63 */
                 for (i = 0; i < len; i++)
@@ -239,13 +268,38 @@ static inline void simple_fill_buf (struct urb *urb)
         }
 }
 
-static inline int simple_check_buf(struct usbtest_dev *tdev, struct urb *urb)
+static inline unsigned long buffer_offset(void *buf)
+{
+        return (unsigned long)buf & (ARCH_KMALLOC_MINALIGN - 1);
+}
+
+static int check_guard_bytes(struct usbtest_dev *tdev, struct urb *urb)
+{
+        u8 *buf = urb->transfer_buffer;
+        u8 *guard = buf - buffer_offset(buf);
+        unsigned i;
+
+        for (i = 0; guard < buf; i++, guard++) {
+                if (*guard != GUARD_BYTE) {
+                        ERROR(tdev, "guard byte[%d] %d (not %d)\n",
+                                i, *guard, GUARD_BYTE);
+                        return -EINVAL;
+                }
+        }
+        return 0;
+}
+
+static int simple_check_buf(struct usbtest_dev *tdev, struct urb *urb)
 {
         unsigned        i;
         u8              expected;
         u8              *buf = urb->transfer_buffer;
         unsigned        len = urb->actual_length;
 
+        int ret = check_guard_bytes(tdev, urb);
+        if (ret)
+                return ret;
+
         for (i = 0; i < len; i++, buf++) {
                 switch (pattern) {
                 /* all-zeroes has no synchronization issues */
@@ -273,14 +327,22 @@ static inline int simple_check_buf(struct usbtest_dev *tdev, struct urb *urb)
         return 0;
 }
 
-static void simple_free_urb (struct urb *urb)
+static void simple_free_urb(struct urb *urb)
 {
-        usb_free_coherent(urb->dev, urb->transfer_buffer_length,
-                          urb->transfer_buffer, urb->transfer_dma);
-        usb_free_urb (urb);
+        unsigned long offset = buffer_offset(urb->transfer_buffer);
+
+        if (urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)
+                usb_free_coherent(
+                        urb->dev,
+                        urb->transfer_buffer_length + offset,
+                        urb->transfer_buffer - offset,
+                        urb->transfer_dma - offset);
+        else
+                kfree(urb->transfer_buffer - offset);
+        usb_free_urb(urb);
 }
 
-static int simple_io (
+static int simple_io(
         struct usbtest_dev      *tdev,
         struct urb              *urb,
         int                     iterations,
@@ -296,17 +358,18 @@ static int simple_io (
 
         urb->context = &completion;
         while (retval == 0 && iterations-- > 0) {
-                init_completion (&completion);
-                if (usb_pipeout (urb->pipe))
-                        simple_fill_buf (urb);
-                if ((retval = usb_submit_urb (urb, GFP_KERNEL)) != 0)
+                init_completion(&completion);
+                if (usb_pipeout(urb->pipe))
+                        simple_fill_buf(urb);
+                retval = usb_submit_urb(urb, GFP_KERNEL);
+                if (retval != 0)
                         break;
 
                 /* NOTE:  no timeouts; can't be broken out of by interrupt */
-                wait_for_completion (&completion);
+                wait_for_completion(&completion);
                 retval = urb->status;
                 urb->dev = udev;
-                if (retval == 0 && usb_pipein (urb->pipe))
+                if (retval == 0 && usb_pipein(urb->pipe))
                         retval = simple_check_buf(tdev, urb);
 
                 if (vary) {
@@ -337,7 +400,7 @@ static int simple_io (
  * Yes, this also tests the scatterlist primitives.
  */
 
-static void free_sglist (struct scatterlist *sg, int nents)
+static void free_sglist(struct scatterlist *sg, int nents)
 {
         unsigned                i;
 
@@ -346,19 +409,19 @@ static void free_sglist (struct scatterlist *sg, int nents)
         for (i = 0; i < nents; i++) {
                 if (!sg_page(&sg[i]))
                         continue;
-                kfree (sg_virt(&sg[i]));
+                kfree(sg_virt(&sg[i]));
         }
-        kfree (sg);
+        kfree(sg);
 }
 
 static struct scatterlist *
-alloc_sglist (int nents, int max, int vary)
+alloc_sglist(int nents, int max, int vary)
 {
         struct scatterlist      *sg;
         unsigned                i;
         unsigned                size = max;
 
-        sg = kmalloc (nents * sizeof *sg, GFP_KERNEL);
+        sg = kmalloc(nents * sizeof *sg, GFP_KERNEL);
         if (!sg)
                 return NULL;
         sg_init_table(sg, nents);
@@ -367,9 +430,9 @@ alloc_sglist (int nents, int max, int vary)
                 char            *buf;
                 unsigned        j;
 
-                buf = kzalloc (size, GFP_KERNEL);
+                buf = kzalloc(size, GFP_KERNEL);
                 if (!buf) {
-                        free_sglist (sg, i);
+                        free_sglist(sg, i);
                         return NULL;
                 }
 
@@ -397,7 +460,7 @@ alloc_sglist (int nents, int max, int vary)
         return sg;
 }
 
-static int perform_sglist (
+static int perform_sglist(
         struct usbtest_dev      *tdev,
         unsigned                iterations,
         int                     pipe,
@@ -410,7 +473,7 @@ static int perform_sglist (
         int                     retval = 0;
 
         while (retval == 0 && iterations-- > 0) {
-                retval = usb_sg_init (req, udev, pipe,
+                retval = usb_sg_init(req, udev, pipe,
                                 (udev->speed == USB_SPEED_HIGH)
                                         ? (INTERRUPT_RATE << 3)
                                         : INTERRUPT_RATE,
@@ -418,7 +481,7 @@ static int perform_sglist (
 
                 if (retval)
                         break;
-                usb_sg_wait (req);
+                usb_sg_wait(req);
                 retval = req->status;
 
                 /* FIXME check resulting data pattern */
@@ -426,9 +489,9 @@ static int perform_sglist (
                 /* FIXME if endpoint halted, clear halt (and log) */
         }
 
-        // FIXME for unlink or fault handling tests, don't report
-        // failure if retval is as we expected ...
-
+        /* FIXME for unlink or fault handling tests, don't report
+         * failure if retval is as we expected ...
+         */
         if (retval)
                 ERROR(tdev, "perform_sglist failed, "
                                 "iterations left %d, status %d\n",
@@ -452,31 +515,31 @@ static int perform_sglist (
  */
 
 static unsigned realworld = 1;
-module_param (realworld, uint, 0);
-MODULE_PARM_DESC (realworld, "clear to demand stricter spec compliance");
+module_param(realworld, uint, 0);
+MODULE_PARM_DESC(realworld, "clear to demand stricter spec compliance");
 
-static int get_altsetting (struct usbtest_dev *dev)
+static int get_altsetting(struct usbtest_dev *dev)
 {
         struct usb_interface    *iface = dev->intf;
-        struct usb_device       *udev = interface_to_usbdev (iface);
+        struct usb_device       *udev = interface_to_usbdev(iface);
         int                     retval;
 
-        retval = usb_control_msg (udev, usb_rcvctrlpipe (udev, 0),
+        retval = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
                         USB_REQ_GET_INTERFACE, USB_DIR_IN|USB_RECIP_INTERFACE,
-                        0, iface->altsetting [0].desc.bInterfaceNumber,
+                        0, iface->altsetting[0].desc.bInterfaceNumber,
                         dev->buf, 1, USB_CTRL_GET_TIMEOUT);
         switch (retval) {
         case 1:
-                return dev->buf [0];
+                return dev->buf[0];
         case 0:
                 retval = -ERANGE;
-                // FALLTHROUGH
+                /* FALLTHROUGH */
         default:
                 return retval;
         }
 }
 
-static int set_altsetting (struct usbtest_dev *dev, int alternate)
+static int set_altsetting(struct usbtest_dev *dev, int alternate)
 {
         struct usb_interface            *iface = dev->intf;
         struct usb_device               *udev;
@@ -484,9 +547,9 @@ static int set_altsetting (struct usbtest_dev *dev, int alternate)
         if (alternate < 0 || alternate >= 256)
                 return -EINVAL;
 
-        udev = interface_to_usbdev (iface);
-        return usb_set_interface (udev,
-                        iface->altsetting [0].desc.bInterfaceNumber,
+        udev = interface_to_usbdev(iface);
+        return usb_set_interface(udev,
+                        iface->altsetting[0].desc.bInterfaceNumber,
                         alternate);
 }
 
@@ -519,9 +582,9 @@ static int is_good_config(struct usbtest_dev *tdev, int len)
                 return 0;
         }
 
-        if (le16_to_cpu(config->wTotalLength) == len)           /* read it all */
+        if (le16_to_cpu(config->wTotalLength) == len)   /* read it all */
                 return 1;
-        if (le16_to_cpu(config->wTotalLength) >= TBUF_SIZE)             /* max partial read */
+        if (le16_to_cpu(config->wTotalLength) >= TBUF_SIZE)     /* max partial read */
                 return 1;
         ERROR(tdev, "bogus config descriptor read size\n");
         return 0;
@@ -542,10 +605,10 @@ static int is_good_config(struct usbtest_dev *tdev, int len)
  * to see if usbcore, hcd, and device all behave right.  such testing would
  * involve varied read sizes and other operation sequences.
  */
-static int ch9_postconfig (struct usbtest_dev *dev)
+static int ch9_postconfig(struct usbtest_dev *dev)
 {
         struct usb_interface    *iface = dev->intf;
-        struct usb_device       *udev = interface_to_usbdev (iface);
+        struct usb_device       *udev = interface_to_usbdev(iface);
         int                     i, alt, retval;
 
         /* [9.2.3] if there's more than one altsetting, we need to be able to
@@ -554,7 +617,7 @@ static int ch9_postconfig (struct usbtest_dev *dev)
         for (i = 0; i < iface->num_altsetting; i++) {
 
                 /* 9.2.3 constrains the range here */
-                alt = iface->altsetting [i].desc.bAlternateSetting;
+                alt = iface->altsetting[i].desc.bAlternateSetting;
                 if (alt < 0 || alt >= iface->num_altsetting) {
                         dev_err(&iface->dev,
                                         "invalid alt [%d].bAltSetting = %d\n",
@@ -566,7 +629,7 @@ static int ch9_postconfig (struct usbtest_dev *dev)
                         continue;
 
                 /* [9.4.10] set_interface */
-                retval = set_altsetting (dev, alt);
+                retval = set_altsetting(dev, alt);
                 if (retval) {
                         dev_err(&iface->dev, "can't set_interface = %d, %d\n",
                                         alt, retval);
@@ -574,7 +637,7 @@ static int ch9_postconfig (struct usbtest_dev *dev)
                 }
 
                 /* [9.4.4] get_interface always works */
-                retval = get_altsetting (dev);
+                retval = get_altsetting(dev);
                 if (retval != alt) {
                         dev_err(&iface->dev, "get alt should be %d, was %d\n",
                                         alt, retval);
@@ -591,11 +654,11 @@ static int ch9_postconfig (struct usbtest_dev *dev)
                  * ... although some cheap devices (like one TI Hub I've got)
                  * won't return config descriptors except before set_config.
                  */
-                retval = usb_control_msg (udev, usb_rcvctrlpipe (udev, 0),
+                retval = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
                                 USB_REQ_GET_CONFIGURATION,
                                 USB_DIR_IN | USB_RECIP_DEVICE,
                                 0, 0, dev->buf, 1, USB_CTRL_GET_TIMEOUT);
-                if (retval != 1 || dev->buf [0] != expected) {
+                if (retval != 1 || dev->buf[0] != expected) {
                         dev_err(&iface->dev, "get config --> %d %d (1 %d)\n",
                                 retval, dev->buf[0], expected);
                         return (retval < 0) ? retval : -EDOM;
@@ -603,7 +666,7 @@ static int ch9_postconfig (struct usbtest_dev *dev)
         }
 
         /* there's always [9.4.3] a device descriptor [9.6.1] */
-        retval = usb_get_descriptor (udev, USB_DT_DEVICE, 0,
+        retval = usb_get_descriptor(udev, USB_DT_DEVICE, 0,
                         dev->buf, sizeof udev->descriptor);
         if (retval != sizeof udev->descriptor) {
                 dev_err(&iface->dev, "dev descriptor --> %d\n", retval);
@@ -612,7 +675,7 @@ static int ch9_postconfig (struct usbtest_dev *dev)
 
         /* there's always [9.4.3] at least one config descriptor [9.6.3] */
         for (i = 0; i < udev->descriptor.bNumConfigurations; i++) {
-                retval = usb_get_descriptor (udev, USB_DT_CONFIG, i,
+                retval = usb_get_descriptor(udev, USB_DT_CONFIG, i,
                                 dev->buf, TBUF_SIZE);
                 if (!is_good_config(dev, retval)) {
                         dev_err(&iface->dev,
@@ -621,18 +684,19 @@ static int ch9_postconfig (struct usbtest_dev *dev)
                         return (retval < 0) ? retval : -EDOM;
                 }
 
-                // FIXME cross-checking udev->config[i] to make sure usbcore
-                // parsed it right (etc) would be good testing paranoia
+                /* FIXME cross-checking udev->config[i] to make sure usbcore
+                 * parsed it right (etc) would be good testing paranoia
+                 */
         }
 
         /* and sometimes [9.2.6.6] speed dependent descriptors */
         if (le16_to_cpu(udev->descriptor.bcdUSB) == 0x0200) {
-                struct usb_qualifier_descriptor         *d = NULL;
+                struct usb_qualifier_descriptor *d = NULL;
 
                 /* device qualifier [9.6.2] */
-                retval = usb_get_descriptor (udev,
+                retval = usb_get_descriptor(udev,
                                 USB_DT_DEVICE_QUALIFIER, 0, dev->buf,
-                                sizeof (struct usb_qualifier_descriptor));
+                                sizeof(struct usb_qualifier_descriptor));
                 if (retval == -EPIPE) {
                         if (udev->speed == USB_SPEED_HIGH) {
                                 dev_err(&iface->dev,
@@ -641,7 +705,7 @@ static int ch9_postconfig (struct usbtest_dev *dev)
                                 return (retval < 0) ? retval : -EDOM;
                         }
                         /* usb2.0 but not high-speed capable; fine */
-                } else if (retval != sizeof (struct usb_qualifier_descriptor)) {
+                } else if (retval != sizeof(struct usb_qualifier_descriptor)) {
                         dev_err(&iface->dev, "dev qualifier --> %d\n", retval);
                         return (retval < 0) ? retval : -EDOM;
                 } else
@@ -651,7 +715,7 @@ static int ch9_postconfig (struct usbtest_dev *dev)
                 if (d) {
                         unsigned max = d->bNumConfigurations;
                         for (i = 0; i < max; i++) {
-                                retval = usb_get_descriptor (udev,
+                                retval = usb_get_descriptor(udev,
                                         USB_DT_OTHER_SPEED_CONFIG, i,
                                         dev->buf, TBUF_SIZE);
                                 if (!is_good_config(dev, retval)) {
@@ -663,25 +727,26 @@ static int ch9_postconfig (struct usbtest_dev *dev)
                         }
                 }
         }
-        // FIXME fetch strings from at least the device descriptor
+        /* FIXME fetch strings from at least the device descriptor */
 
         /* [9.4.5] get_status always works */
-        retval = usb_get_status (udev, USB_RECIP_DEVICE, 0, dev->buf);
+        retval = usb_get_status(udev, USB_RECIP_DEVICE, 0, dev->buf);
         if (retval != 2) {
                 dev_err(&iface->dev, "get dev status --> %d\n", retval);
                 return (retval < 0) ? retval : -EDOM;
         }
 
-        // FIXME configuration.bmAttributes says if we could try to set/clear
-        // the device's remote wakeup feature ... if we can, test that here
+        /* FIXME configuration.bmAttributes says if we could try to set/clear
+         * the device's remote wakeup feature ... if we can, test that here
+         */
 
-        retval = usb_get_status (udev, USB_RECIP_INTERFACE,
-                        iface->altsetting [0].desc.bInterfaceNumber, dev->buf);
+        retval = usb_get_status(udev, USB_RECIP_INTERFACE,
+                        iface->altsetting[0].desc.bInterfaceNumber, dev->buf);
         if (retval != 2) {
                 dev_err(&iface->dev, "get interface status --> %d\n", retval);
                 return (retval < 0) ? retval : -EDOM;
         }
-        // FIXME get status for each endpoint in the interface
+        /* FIXME get status for each endpoint in the interface */
 
         return 0;
 }
@@ -717,7 +782,7 @@ struct subcase {
         int                     expected;
 };
 
-static void ctrl_complete (struct urb *urb)
+static void ctrl_complete(struct urb *urb)
 {
         struct ctrl_ctx         *ctx = urb->context;
         struct usb_ctrlrequest  *reqp;
@@ -725,9 +790,9 @@ static void ctrl_complete (struct urb *urb)
         int                     status = urb->status;
 
         reqp = (struct usb_ctrlrequest *)urb->setup_packet;
-        subcase = container_of (reqp, struct subcase, setup);
+        subcase = container_of(reqp, struct subcase, setup);
 
-        spin_lock (&ctx->lock);
+        spin_lock(&ctx->lock);
         ctx->count--;
         ctx->pending--;
 
@@ -787,14 +852,14 @@ error:
 
                         /* unlink whatever's still pending */
                         for (i = 1; i < ctx->param->sglen; i++) {
-                                struct urb      *u = ctx->urb [
-                                                (i + subcase->number)
-                                                % ctx->param->sglen];
+                                struct urb *u = ctx->urb[
+                                                        (i + subcase->number)
+                                                        % ctx->param->sglen];
 
                                 if (u == urb || !u->dev)
                                         continue;
                                 spin_unlock(&ctx->lock);
-                                status = usb_unlink_urb (u);
+                                status = usb_unlink_urb(u);
                                 spin_lock(&ctx->lock);
                                 switch (status) {
                                 case -EINPROGRESS:
@@ -812,7 +877,8 @@ error:
 
         /* resubmit if we need to, else mark this as done */
         if ((status == 0) && (ctx->pending < ctx->count)) {
-                if ((status = usb_submit_urb (urb, GFP_ATOMIC)) != 0) {
+                status = usb_submit_urb(urb, GFP_ATOMIC);
+                if (status != 0) {
                         ERROR(ctx->dev,
                                 "can't resubmit ctrl %02x.%02x, err %d\n",
                                 reqp->bRequestType, reqp->bRequest, status);
@@ -824,21 +890,21 @@ error:
 
         /* signal completion when nothing's queued */
         if (ctx->pending == 0)
-                complete (&ctx->complete);
-        spin_unlock (&ctx->lock);
+                complete(&ctx->complete);
+        spin_unlock(&ctx->lock);
 }
 
 static int
-test_ctrl_queue (struct usbtest_dev *dev, struct usbtest_param *param)
+test_ctrl_queue(struct usbtest_dev *dev, struct usbtest_param *param)
 {
-        struct usb_device       *udev = testdev_to_usbdev (dev);
+        struct usb_device       *udev = testdev_to_usbdev(dev);
         struct urb              **urb;
         struct ctrl_ctx         context;
         int                     i;
 
-        spin_lock_init (&context.lock);
+        spin_lock_init(&context.lock);
         context.dev = dev;
-        init_completion (&context.complete);
+        init_completion(&context.complete);
         context.count = param->sglen * param->iterations;
         context.pending = 0;
         context.status = -ENOMEM;
@@ -853,7 +919,7 @@ test_ctrl_queue (struct usbtest_dev *dev, struct usbtest_param *param)
         if (!urb)
                 return -ENOMEM;
         for (i = 0; i < param->sglen; i++) {
-                int                     pipe = usb_rcvctrlpipe (udev, 0);
+                int                     pipe = usb_rcvctrlpipe(udev, 0);
                 unsigned                len;
                 struct urb              *u;
                 struct usb_ctrlrequest  req;
@@ -869,104 +935,110 @@ test_ctrl_queue (struct usbtest_dev *dev, struct usbtest_param *param)
                  * device, but some are chosen to trigger protocol stalls
                  * or short reads.
                  */
-                memset (&req, 0, sizeof req);
+                memset(&req, 0, sizeof req);
                 req.bRequest = USB_REQ_GET_DESCRIPTOR;
                 req.bRequestType = USB_DIR_IN|USB_RECIP_DEVICE;
 
                 switch (i % NUM_SUBCASES) {
-                case 0:         // get device descriptor
-                        req.wValue = cpu_to_le16 (USB_DT_DEVICE << 8);
-                        len = sizeof (struct usb_device_descriptor);
+                case 0:         /* get device descriptor */
+                        req.wValue = cpu_to_le16(USB_DT_DEVICE << 8);
+                        len = sizeof(struct usb_device_descriptor);
                         break;
-                case 1:         // get first config descriptor (only)
-                        req.wValue = cpu_to_le16 ((USB_DT_CONFIG << 8) | 0);
-                        len = sizeof (struct usb_config_descriptor);
+                case 1:         /* get first config descriptor (only) */
+                        req.wValue = cpu_to_le16((USB_DT_CONFIG << 8) | 0);
+                        len = sizeof(struct usb_config_descriptor);
                         break;
-                case 2:         // get altsetting (OFTEN STALLS)
+                case 2:         /* get altsetting (OFTEN STALLS) */
                         req.bRequest = USB_REQ_GET_INTERFACE;
                         req.bRequestType = USB_DIR_IN|USB_RECIP_INTERFACE;
-                        // index = 0 means first interface
+                        /* index = 0 means first interface */
                         len = 1;
                         expected = EPIPE;
                         break;
-                case 3:         // get interface status
+                case 3:         /* get interface status */
                         req.bRequest = USB_REQ_GET_STATUS;
                         req.bRequestType = USB_DIR_IN|USB_RECIP_INTERFACE;
-                        // interface 0
+                        /* interface 0 */
                         len = 2;
                         break;
-                case 4:         // get device status
+                case 4:         /* get device status */
                         req.bRequest = USB_REQ_GET_STATUS;
                         req.bRequestType = USB_DIR_IN|USB_RECIP_DEVICE;
                         len = 2;
                         break;
-                case 5:         // get device qualifier (MAY STALL)
+                case 5:         /* get device qualifier (MAY STALL) */
                         req.wValue = cpu_to_le16 (USB_DT_DEVICE_QUALIFIER << 8);
-                        len = sizeof (struct usb_qualifier_descriptor);
+                        len = sizeof(struct usb_qualifier_descriptor);
                         if (udev->speed != USB_SPEED_HIGH)
                                 expected = EPIPE;
                         break;
-                case 6:         // get first config descriptor, plus interface
-                        req.wValue = cpu_to_le16 ((USB_DT_CONFIG << 8) | 0);
-                        len = sizeof (struct usb_config_descriptor);
-                        len += sizeof (struct usb_interface_descriptor);
+                case 6:         /* get first config descriptor, plus interface */
+                        req.wValue = cpu_to_le16((USB_DT_CONFIG << 8) | 0);
+                        len = sizeof(struct usb_config_descriptor);
+                        len += sizeof(struct usb_interface_descriptor);
                         break;
-                case 7:         // get interface descriptor (ALWAYS STALLS)
+                case 7:         /* get interface descriptor (ALWAYS STALLS) */
                         req.wValue = cpu_to_le16 (USB_DT_INTERFACE << 8);
-                        // interface == 0
-                        len = sizeof (struct usb_interface_descriptor);
+                        /* interface == 0 */
+                        len = sizeof(struct usb_interface_descriptor);
                         expected = -EPIPE;
                         break;
-                // NOTE: two consecutive stalls in the queue here.
-                // that tests fault recovery a bit more aggressively.
-                case 8:         // clear endpoint halt (MAY STALL)
+                /* NOTE: two consecutive stalls in the queue here.
+                 *  that tests fault recovery a bit more aggressively. */
+                case 8:         /* clear endpoint halt (MAY STALL) */
                         req.bRequest = USB_REQ_CLEAR_FEATURE;
                         req.bRequestType = USB_RECIP_ENDPOINT;
-                        // wValue 0 == ep halt
-                        // wIndex 0 == ep0 (shouldn't halt!)
+                        /* wValue 0 == ep halt */
+                        /* wIndex 0 == ep0 (shouldn't halt!) */
                         len = 0;
-                        pipe = usb_sndctrlpipe (udev, 0);
+                        pipe = usb_sndctrlpipe(udev, 0);
                         expected = EPIPE;
                         break;
-                case 9:         // get endpoint status
+                case 9:         /* get endpoint status */
                         req.bRequest = USB_REQ_GET_STATUS;
                         req.bRequestType = USB_DIR_IN|USB_RECIP_ENDPOINT;
-                        // endpoint 0
+                        /* endpoint 0 */
                         len = 2;
                         break;
-                case 10:        // trigger short read (EREMOTEIO)
-                        req.wValue = cpu_to_le16 ((USB_DT_CONFIG << 8) | 0);
+                case 10:        /* trigger short read (EREMOTEIO) */
+                        req.wValue = cpu_to_le16((USB_DT_CONFIG << 8) | 0);
                         len = 1024;
                         expected = -EREMOTEIO;
                         break;
-                // NOTE: two consecutive _different_ faults in the queue.
-                case 11:        // get endpoint descriptor (ALWAYS STALLS)
-                        req.wValue = cpu_to_le16 (USB_DT_ENDPOINT << 8);
-                        // endpoint == 0
-                        len = sizeof (struct usb_interface_descriptor);
+                /* NOTE: two consecutive _different_ faults in the queue. */
+                case 11:        /* get endpoint descriptor (ALWAYS STALLS) */
+                        req.wValue = cpu_to_le16(USB_DT_ENDPOINT << 8);
+                        /* endpoint == 0 */
+                        len = sizeof(struct usb_interface_descriptor);
                         expected = EPIPE;
                         break;
-                // NOTE: sometimes even a third fault in the queue!
-                case 12:        // get string 0 descriptor (MAY STALL)
-                        req.wValue = cpu_to_le16 (USB_DT_STRING << 8);
-                        // string == 0, for language IDs
-                        len = sizeof (struct usb_interface_descriptor);
-                        // may succeed when > 4 languages
-                        expected = EREMOTEIO;   // or EPIPE, if no strings
+                /* NOTE: sometimes even a third fault in the queue! */
+                case 12:        /* get string 0 descriptor (MAY STALL) */
+                        req.wValue = cpu_to_le16(USB_DT_STRING << 8);
+                        /* string == 0, for language IDs */
+                        len = sizeof(struct usb_interface_descriptor);
+                        /* may succeed when > 4 languages */
+                        expected = EREMOTEIO;   /* or EPIPE, if no strings */
                         break;
-                case 13:        // short read, resembling case 10
-                        req.wValue = cpu_to_le16 ((USB_DT_CONFIG << 8) | 0);
-                        // last data packet "should" be DATA1, not DATA0
+                case 13:        /* short read, resembling case 10 */
+                        req.wValue = cpu_to_le16((USB_DT_CONFIG << 8) | 0);
+                        /* last data packet "should" be DATA1, not DATA0 */
                         len = 1024 - udev->descriptor.bMaxPacketSize0;
                         expected = -EREMOTEIO;
                         break;
-                case 14:        // short read; try to fill the last packet
-                        req.wValue = cpu_to_le16 ((USB_DT_DEVICE << 8) | 0);
+                case 14:        /* short read; try to fill the last packet */
+                        req.wValue = cpu_to_le16((USB_DT_DEVICE << 8) | 0);
                         /* device descriptor size == 18 bytes */
                         len = udev->descriptor.bMaxPacketSize0;
+                        if (udev->speed == USB_SPEED_SUPER)
+                                len = 512;
                         switch (len) {
-                        case 8:         len = 24; break;
-                        case 16:        len = 32; break;
+                        case 8:
+                                len = 24;
+                                break;
+                        case 16:
+                                len = 32;
+                                break;
                         }
                         expected = -EREMOTEIO;
                         break;
@@ -975,8 +1047,8 @@ test_ctrl_queue (struct usbtest_dev *dev, struct usbtest_param *param)
                         context.status = -EINVAL;
                         goto cleanup;
                 }
-                req.wLength = cpu_to_le16 (len);
-                urb [i] = u = simple_alloc_urb (udev, pipe, len);
+                req.wLength = cpu_to_le16(len);
+                urb[i] = u = simple_alloc_urb(udev, pipe, len);
                 if (!u)
                         goto cleanup;
 
@@ -994,9 +1066,9 @@ test_ctrl_queue (struct usbtest_dev *dev, struct usbtest_param *param)
 
         /* queue the urbs */
         context.urb = urb;
-        spin_lock_irq (&context.lock);
+        spin_lock_irq(&context.lock);
         for (i = 0; i < param->sglen; i++) {
-                context.status = usb_submit_urb (urb [i], GFP_ATOMIC);
+                context.status = usb_submit_urb(urb[i], GFP_ATOMIC);
                 if (context.status != 0) {
                         ERROR(dev, "can't submit urb[%d], status %d\n",
                                         i, context.status);
@@ -1005,23 +1077,23 @@ test_ctrl_queue (struct usbtest_dev *dev, struct usbtest_param *param)
                 }
                 context.pending++;
         }
-        spin_unlock_irq (&context.lock);
+        spin_unlock_irq(&context.lock);
 
         /* FIXME  set timer and time out; provide a disconnect hook */
 
         /* wait for the last one to complete */
         if (context.pending > 0)
-                wait_for_completion (&context.complete);
+                wait_for_completion(&context.complete);
 
 cleanup:
         for (i = 0; i < param->sglen; i++) {
-                if (!urb [i])
+                if (!urb[i])
                         continue;
-                urb [i]->dev = udev;
+                urb[i]->dev = udev;
                 kfree(urb[i]->setup_packet);
-                simple_free_urb (urb [i]);
+                simple_free_urb(urb[i]);
         }
-        kfree (urb);
+        kfree(urb);
         return context.status;
 }
 #undef NUM_SUBCASES
@@ -1029,27 +1101,27 @@ cleanup:
 
 /*-------------------------------------------------------------------------*/
 
-static void unlink1_callback (struct urb *urb)
+static void unlink1_callback(struct urb *urb)
 {
         int     status = urb->status;
 
-        // we "know" -EPIPE (stall) never happens
+        /* we "know" -EPIPE (stall) never happens */
         if (!status)
-                status = usb_submit_urb (urb, GFP_ATOMIC);
+                status = usb_submit_urb(urb, GFP_ATOMIC);
         if (status) {
                 urb->status = status;
                 complete(urb->context);
         }
 }
 
-static int unlink1 (struct usbtest_dev *dev, int pipe, int size, int async)
+static int unlink1(struct usbtest_dev *dev, int pipe, int size, int async)
 {
         struct urb              *urb;
         struct completion       completion;
         int                     retval = 0;
 
-        init_completion (&completion);
-        urb = simple_alloc_urb (testdev_to_usbdev (dev), pipe, size);
+        init_completion(&completion);
+        urb = simple_alloc_urb(testdev_to_usbdev(dev), pipe, size);
         if (!urb)
                 return -ENOMEM;
         urb->context = &completion;
@@ -1061,7 +1133,8 @@ static int unlink1 (struct usbtest_dev *dev, int pipe, int size, int async)
          * FIXME want additional tests for when endpoint is STALLing
          * due to errors, or is just NAKing requests.
          */
-        if ((retval = usb_submit_urb (urb, GFP_KERNEL)) != 0) {
+        retval = usb_submit_urb(urb, GFP_KERNEL);
+        if (retval != 0) {
                 dev_err(&dev->intf->dev, "submit fail %d\n", retval);
                 return retval;
         }
@@ -1069,7 +1142,7 @@ static int unlink1 (struct usbtest_dev *dev, int pipe, int size, int async)
         /* unlinking that should always work.  variable delay tests more
          * hcd states and code paths, even with little other system load.
          */
-        msleep (jiffies % (2 * INTERRUPT_RATE));
+        msleep(jiffies % (2 * INTERRUPT_RATE));
         if (async) {
                 while (!completion_done(&completion)) {
                         retval = usb_unlink_urb(urb);
@@ -1098,11 +1171,11 @@ static int unlink1 (struct usbtest_dev *dev, int pipe, int size, int async)
                         break;
                 }
         } else
-                usb_kill_urb (urb);
+                usb_kill_urb(urb);
 
-        wait_for_completion (&completion);
+        wait_for_completion(&completion);
         retval = urb->status;
-        simple_free_urb (urb);
+        simple_free_urb(urb);
 
         if (async)
                 return (retval == -ECONNRESET) ? 0 : retval - 1000;
@@ -1111,14 +1184,112 @@ static int unlink1 (struct usbtest_dev *dev, int pipe, int size, int async)
                                 0 : retval - 2000;
 }
 
-static int unlink_simple (struct usbtest_dev *dev, int pipe, int len)
+static int unlink_simple(struct usbtest_dev *dev, int pipe, int len)
 {
         int                     retval = 0;
 
         /* test sync and async paths */
-        retval = unlink1 (dev, pipe, len, 1);
+        retval = unlink1(dev, pipe, len, 1);
         if (!retval)
-                retval = unlink1 (dev, pipe, len, 0);
+                retval = unlink1(dev, pipe, len, 0);
+        return retval;
+}
+
+/*-------------------------------------------------------------------------*/
+
+struct queued_ctx {
+        struct completion       complete;
+        atomic_t                pending;
+        unsigned                num;
+        int                     status;
+        struct urb              **urbs;
+};
+
+static void unlink_queued_callback(struct urb *urb)
+{
+        int                     status = urb->status;
+        struct queued_ctx       *ctx = urb->context;
+
+        if (ctx->status)
+                goto done;
+        if (urb == ctx->urbs[ctx->num - 4] || urb == ctx->urbs[ctx->num - 2]) {
+                if (status == -ECONNRESET)
+                        goto done;
+                /* What error should we report if the URB completed normally? */
+        }
+        if (status != 0)
+                ctx->status = status;
+
+ done:
+        if (atomic_dec_and_test(&ctx->pending))
+                complete(&ctx->complete);
+}
+
+static int unlink_queued(struct usbtest_dev *dev, int pipe, unsigned num,
+                unsigned size)
+{
+        struct queued_ctx       ctx;
+        struct usb_device       *udev = testdev_to_usbdev(dev);
+        void                    *buf;
+        dma_addr_t              buf_dma;
+        int                     i;
+        int                     retval = -ENOMEM;
+
+        init_completion(&ctx.complete);
+        atomic_set(&ctx.pending, 1);    /* One more than the actual value */
+        ctx.num = num;
+        ctx.status = 0;
+
+        buf = usb_alloc_coherent(udev, size, GFP_KERNEL, &buf_dma);
+        if (!buf)
+                return retval;
+        memset(buf, 0, size);
+
+        /* Allocate and init the urbs we'll queue */
+        ctx.urbs = kcalloc(num, sizeof(struct urb *), GFP_KERNEL);
+        if (!ctx.urbs)
+                goto free_buf;
+        for (i = 0; i < num; i++) {
+                ctx.urbs[i] = usb_alloc_urb(0, GFP_KERNEL);
+                if (!ctx.urbs[i])
+                        goto free_urbs;
+                usb_fill_bulk_urb(ctx.urbs[i], udev, pipe, buf, size,
+                                unlink_queued_callback, &ctx);
+                ctx.urbs[i]->transfer_dma = buf_dma;
+                ctx.urbs[i]->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
+        }
+
+        /* Submit all the URBs and then unlink URBs num - 4 and num - 2. */
+        for (i = 0; i < num; i++) {
+                atomic_inc(&ctx.pending);
+                retval = usb_submit_urb(ctx.urbs[i], GFP_KERNEL);
+                if (retval != 0) {
+                        dev_err(&dev->intf->dev, "submit urbs[%d] fail %d\n",
+                                        i, retval);
+                        atomic_dec(&ctx.pending);
+                        ctx.status = retval;
+                        break;
+                }
+        }
+        if (i == num) {
+                usb_unlink_urb(ctx.urbs[num - 4]);
+                usb_unlink_urb(ctx.urbs[num - 2]);
+        } else {
+                while (--i >= 0)
+                        usb_unlink_urb(ctx.urbs[i]);
+        }
+
+        if (atomic_dec_and_test(&ctx.pending))          /* The extra count */
+                complete(&ctx.complete);
+        wait_for_completion(&ctx.complete);
+        retval = ctx.status;
+
+ free_urbs:
+        for (i = 0; i < num; i++)
+                usb_free_urb(ctx.urbs[i]);
+        kfree(ctx.urbs);
+ free_buf:
+        usb_free_coherent(udev, size, buf, buf_dma);
         return retval;
 }
 
@@ -1130,7 +1301,7 @@ static int verify_not_halted(struct usbtest_dev *tdev, int ep, struct urb *urb)
         u16     status;
 
         /* shouldn't look or act halted */
-        retval = usb_get_status (urb->dev, USB_RECIP_ENDPOINT, ep, &status);
+        retval = usb_get_status(urb->dev, USB_RECIP_ENDPOINT, ep, &status);
         if (retval < 0) {
                 ERROR(tdev, "ep %02x couldn't get no-halt status, %d\n",
                                 ep, retval);
@@ -1152,7 +1323,7 @@ static int verify_halted(struct usbtest_dev *tdev, int ep, struct urb *urb)
         u16     status;
 
         /* should look and act halted */
-        retval = usb_get_status (urb->dev, USB_RECIP_ENDPOINT, ep, &status);
+        retval = usb_get_status(urb->dev, USB_RECIP_ENDPOINT, ep, &status);
         if (retval < 0) {
                 ERROR(tdev, "ep %02x couldn't get halt status, %d\n",
                                 ep, retval);
@@ -1182,7 +1353,7 @@ static int test_halt(struct usbtest_dev *tdev, int ep, struct urb *urb)
                 return retval;
 
         /* set halt (protocol test only), verify it worked */
-        retval = usb_control_msg (urb->dev, usb_sndctrlpipe (urb->dev, 0),
+        retval = usb_control_msg(urb->dev, usb_sndctrlpipe(urb->dev, 0),
                         USB_REQ_SET_FEATURE, USB_RECIP_ENDPOINT,
                         USB_ENDPOINT_HALT, ep,
                         NULL, 0, USB_CTRL_SET_TIMEOUT);
@@ -1195,7 +1366,7 @@ static int test_halt(struct usbtest_dev *tdev, int ep, struct urb *urb)
                 return retval;
 
         /* clear halt (tests API + protocol), verify it worked */
-        retval = usb_clear_halt (urb->dev, urb->pipe);
+        retval = usb_clear_halt(urb->dev, urb->pipe);
         if (retval < 0) {
                 ERROR(tdev, "ep %02x couldn't clear halt, %d\n", ep, retval);
                 return retval;
@@ -1209,18 +1380,18 @@ static int test_halt(struct usbtest_dev *tdev, int ep, struct urb *urb)
         return 0;
 }
 
-static int halt_simple (struct usbtest_dev *dev)
+static int halt_simple(struct usbtest_dev *dev)
 {
         int             ep;
         int             retval = 0;
         struct urb      *urb;
 
-        urb = simple_alloc_urb (testdev_to_usbdev (dev), 0, 512);
+        urb = simple_alloc_urb(testdev_to_usbdev(dev), 0, 512);
         if (urb == NULL)
                 return -ENOMEM;
 
         if (dev->in_pipe) {
-                ep = usb_pipeendpoint (dev->in_pipe) | USB_DIR_IN;
+                ep = usb_pipeendpoint(dev->in_pipe) | USB_DIR_IN;
                 urb->pipe = dev->in_pipe;
                 retval = test_halt(dev, ep, urb);
                 if (retval < 0)
@@ -1228,12 +1399,12 @@ static int halt_simple (struct usbtest_dev *dev)
         }
 
         if (dev->out_pipe) {
-                ep = usb_pipeendpoint (dev->out_pipe);
+                ep = usb_pipeendpoint(dev->out_pipe);
                 urb->pipe = dev->out_pipe;
                 retval = test_halt(dev, ep, urb);
         }
 done:
-        simple_free_urb (urb);
+        simple_free_urb(urb);
         return retval;
 }
 
@@ -1247,8 +1418,8 @@ done:
  * need to be able to handle more than one OUT data packet.  We'll
  * try whatever we're told to try.
  */
-static int ctrl_out (struct usbtest_dev *dev,
-                unsigned count, unsigned length, unsigned vary)
+static int ctrl_out(struct usbtest_dev *dev,
+                unsigned count, unsigned length, unsigned vary, unsigned offset)
 {
         unsigned                i, j, len;
         int                     retval;
@@ -1259,11 +1430,12 @@ static int ctrl_out (struct usbtest_dev *dev,
         if (length < 1 || length > 0xffff || vary >= length)
                 return -EINVAL;
 
-        buf = kmalloc(length, GFP_KERNEL);
+        buf = kmalloc(length + offset, GFP_KERNEL);
         if (!buf)
                 return -ENOMEM;
 
-        udev = testdev_to_usbdev (dev);
+        buf += offset;
+        udev = testdev_to_usbdev(dev);
         len = length;
         retval = 0;
 
@@ -1273,8 +1445,8 @@ static int ctrl_out (struct usbtest_dev *dev,
         for (i = 0; i < count; i++) {
                 /* write patterned data */
                 for (j = 0; j < len; j++)
-                        buf [j] = i + j;
-                retval = usb_control_msg (udev, usb_sndctrlpipe (udev,0),
+                        buf[j] = i + j;
+                retval = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
                                 0x5b, USB_DIR_OUT|USB_TYPE_VENDOR,
                                 0, 0, buf, len, USB_CTRL_SET_TIMEOUT);
                 if (retval != len) {
@@ -1288,7 +1460,7 @@ static int ctrl_out (struct usbtest_dev *dev,
                 }
 
                 /* read it back -- assuming nothing intervened!!  */
-                retval = usb_control_msg (udev, usb_rcvctrlpipe (udev,0),
+                retval = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
                                 0x5c, USB_DIR_IN|USB_TYPE_VENDOR,
                                 0, 0, buf, len, USB_CTRL_GET_TIMEOUT);
                 if (retval != len) {
@@ -1303,9 +1475,9 @@ static int ctrl_out (struct usbtest_dev *dev,
 
                 /* fail if we can't verify */
                 for (j = 0; j < len; j++) {
-                        if (buf [j] != (u8) (i + j)) {
+                        if (buf[j] != (u8) (i + j)) {
                                 ERROR(dev, "ctrl_out, byte %d is %d not %d\n",
-                                        j, buf [j], (u8) i + j);
+                                        j, buf[j], (u8) i + j);
                                 retval = -EBADMSG;
                                 break;
                         }
@@ -1326,10 +1498,10 @@ static int ctrl_out (struct usbtest_dev *dev,
         }
 
         if (retval < 0)
-                ERROR (dev, "ctrl_out %s failed, code %d, count %d\n",
+                ERROR(dev, "ctrl_out %s failed, code %d, count %d\n",
                         what, retval, i);
 
-        kfree (buf);
+        kfree(buf - offset);
         return retval;
 }
 
@@ -1351,7 +1523,7 @@ struct iso_context {
         struct usbtest_dev      *dev;
 };
 
-static void iso_callback (struct urb *urb)
+static void iso_callback(struct urb *urb)
 {
         struct iso_context      *ctx = urb->context;
 
@@ -1363,10 +1535,14 @@ static void iso_callback (struct urb *urb)
                 ctx->errors += urb->error_count;
         else if (urb->status != 0)
                 ctx->errors += urb->number_of_packets;
+        else if (urb->actual_length != urb->transfer_buffer_length)
+                ctx->errors++;
+        else if (check_guard_bytes(ctx->dev, urb) != 0)
+                ctx->errors++;
 
         if (urb->status == 0 && ctx->count > (ctx->pending - 1)
                         && !ctx->submit_error) {
-                int status = usb_submit_urb (urb, GFP_ATOMIC);
+                int status = usb_submit_urb(urb, GFP_ATOMIC);
                 switch (status) {
                 case 0:
                         goto done;
@@ -1388,17 +1564,18 @@ static void iso_callback (struct urb *urb)
                         dev_err(&ctx->dev->intf->dev,
                                 "iso test, %lu errors out of %lu\n",
                                 ctx->errors, ctx->packet_count);
-                complete (&ctx->done);
+                complete(&ctx->done);
         }
 done:
         spin_unlock(&ctx->lock);
 }
 
-static struct urb *iso_alloc_urb (
+static struct urb *iso_alloc_urb(
         struct usb_device       *udev,
         int                     pipe,
         struct usb_endpoint_descriptor  *desc,
-        long                    bytes
+        long                    bytes,
+        unsigned offset
 )
 {
         struct urb              *urb;
@@ -1410,7 +1587,7 @@ static struct urb *iso_alloc_urb (
         maxp *= 1 + (0x3 & (le16_to_cpu(desc->wMaxPacketSize) >> 11));
         packets = DIV_ROUND_UP(bytes, maxp);
 
-        urb = usb_alloc_urb (packets, GFP_KERNEL);
+        urb = usb_alloc_urb(packets, GFP_KERNEL);
         if (!urb)
                 return urb;
         urb->dev = udev;
@@ -1418,31 +1595,42 @@ static struct urb *iso_alloc_urb (
 
         urb->number_of_packets = packets;
         urb->transfer_buffer_length = bytes;
-        urb->transfer_buffer = usb_alloc_coherent (udev, bytes, GFP_KERNEL,
-                        &urb->transfer_dma);
+        urb->transfer_buffer = usb_alloc_coherent(udev, bytes + offset,
+                                                        GFP_KERNEL,
+                                                        &urb->transfer_dma);
         if (!urb->transfer_buffer) {
-                usb_free_urb (urb);
+                usb_free_urb(urb);
                 return NULL;
         }
-        memset (urb->transfer_buffer, 0, bytes);
+        if (offset) {
+                memset(urb->transfer_buffer, GUARD_BYTE, offset);
+                urb->transfer_buffer += offset;
+                urb->transfer_dma += offset;
+        }
+        /* For inbound transfers use guard byte so that test fails if
+                data not correctly copied */
+        memset(urb->transfer_buffer,
+                        usb_pipein(urb->pipe) ? GUARD_BYTE : 0,
+                        bytes);
+
         for (i = 0; i < packets; i++) {
                 /* here, only the last packet will be short */
-                urb->iso_frame_desc[i].length = min ((unsigned) bytes, maxp);
+                urb->iso_frame_desc[i].length = min((unsigned) bytes, maxp);
                 bytes -= urb->iso_frame_desc[i].length;
 
                 urb->iso_frame_desc[i].offset = maxp * i;
         }
 
         urb->complete = iso_callback;
-        // urb->context = SET BY CALLER
+        /* urb->context = SET BY CALLER */
         urb->interval = 1 << (desc->bInterval - 1);
         urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
         return urb;
 }
 
 static int
-test_iso_queue (struct usbtest_dev *dev, struct usbtest_param *param,
-                int pipe, struct usb_endpoint_descriptor *desc)
+test_iso_queue(struct usbtest_dev *dev, struct usbtest_param *param,
+                int pipe, struct usb_endpoint_descriptor *desc, unsigned offset)
 {
         struct iso_context      context;
         struct usb_device       *udev;
@@ -1457,11 +1645,11 @@ test_iso_queue (struct usbtest_dev *dev, struct usbtest_param *param,
         memset(&context, 0, sizeof context);
         context.count = param->iterations * param->sglen;
         context.dev = dev;
-        init_completion (&context.done);
-        spin_lock_init (&context.lock);
+        init_completion(&context.done);
+        spin_lock_init(&context.lock);
 
-        memset (urbs, 0, sizeof urbs);
-        udev = testdev_to_usbdev (dev);
+        memset(urbs, 0, sizeof urbs);
+        udev = testdev_to_usbdev(dev);
         dev_info(&dev->intf->dev,
                 "... iso period %d %sframes, wMaxPacket %04x\n",
                 1 << (desc->bInterval - 1),
@@ -1469,14 +1657,14 @@ test_iso_queue (struct usbtest_dev *dev, struct usbtest_param *param,
                 le16_to_cpu(desc->wMaxPacketSize));
 
         for (i = 0; i < param->sglen; i++) {
-                urbs [i] = iso_alloc_urb (udev, pipe, desc,
-                                param->length);
-                if (!urbs [i]) {
+                urbs[i] = iso_alloc_urb(udev, pipe, desc,
+                                        param->length, offset);
+                if (!urbs[i]) {
                         status = -ENOMEM;
                         goto fail;
                 }
                 packets += urbs[i]->number_of_packets;
-                urbs [i]->context = &context;
+                urbs[i]->context = &context;
         }
         packets *= param->iterations;
         dev_info(&dev->intf->dev,
@@ -1485,27 +1673,27 @@ test_iso_queue (struct usbtest_dev *dev, struct usbtest_param *param,
                         / ((udev->speed == USB_SPEED_HIGH) ? 8 : 1),
                 packets);
 
-        spin_lock_irq (&context.lock);
+        spin_lock_irq(&context.lock);
         for (i = 0; i < param->sglen; i++) {
                 ++context.pending;
-                status = usb_submit_urb (urbs [i], GFP_ATOMIC);
+                status = usb_submit_urb(urbs[i], GFP_ATOMIC);
                 if (status < 0) {
-                        ERROR (dev, "submit iso[%d], error %d\n", i, status);
+                        ERROR(dev, "submit iso[%d], error %d\n", i, status);
                         if (i == 0) {
-                                spin_unlock_irq (&context.lock);
+                                spin_unlock_irq(&context.lock);
                                 goto fail;
                         }
 
-                        simple_free_urb (urbs [i]);
+                        simple_free_urb(urbs[i]);
                         urbs[i] = NULL;
                         context.pending--;
                         context.submit_error = 1;
                         break;
                 }
         }
-        spin_unlock_irq (&context.lock);
+        spin_unlock_irq(&context.lock);
 
-        wait_for_completion (&context.done);
+        wait_for_completion(&context.done);
 
         for (i = 0; i < param->sglen; i++) {
                 if (urbs[i])
@@ -1526,12 +1714,32 @@ test_iso_queue (struct usbtest_dev *dev, struct usbtest_param *param,
 
 fail:
         for (i = 0; i < param->sglen; i++) {
-                if (urbs [i])
-                        simple_free_urb (urbs [i]);
+                if (urbs[i])
+                        simple_free_urb(urbs[i]);
         }
         return status;
 }
 
+static int test_unaligned_bulk(
+        struct usbtest_dev *tdev,
+        int pipe,
+        unsigned length,
+        int iterations,
+        unsigned transfer_flags,
+        const char *label)
+{
+        int retval;
+        struct urb *urb = usbtest_alloc_urb(
+                testdev_to_usbdev(tdev), pipe, length, transfer_flags, 1);
+
+        if (!urb)
+                return -ENOMEM;
+
+        retval = simple_io(tdev, urb, iterations, 0, 0, label);
+        simple_free_urb(urb);
+        return retval;
+}
+
 /*-------------------------------------------------------------------------*/
 
 /* We only have this one interface to user space, through usbfs.
@@ -1557,10 +1765,10 @@ fail:
 
 /* No BKL needed */
 static int
-usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *buf)
+usbtest_ioctl(struct usb_interface *intf, unsigned int code, void *buf)
 {
-        struct usbtest_dev      *dev = usb_get_intfdata (intf);
-        struct usb_device       *udev = testdev_to_usbdev (dev);
+        struct usbtest_dev      *dev = usb_get_intfdata(intf);
+        struct usb_device       *udev = testdev_to_usbdev(dev);
         struct usbtest_param    *param = buf;
         int                     retval = -EOPNOTSUPP;
         struct urb              *urb;
@@ -1569,7 +1777,7 @@ usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *buf)
         struct timeval          start;
         unsigned                i;
 
-        // FIXME USBDEVFS_CONNECTINFO doesn't say how fast the device is.
+        /* FIXME USBDEVFS_CONNECTINFO doesn't say how fast the device is. */
 
         pattern = mod_pattern;
 
@@ -1595,9 +1803,9 @@ usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *buf)
                         mutex_unlock(&dev->lock);
                         return -ENODEV;
                 }
-                res = set_altsetting (dev, dev->info->alt);
+                res = set_altsetting(dev, dev->info->alt);
                 if (res) {
-                        dev_err (&intf->dev,
+                        dev_err(&intf->dev,
                                         "set altsetting to %d failed, %d\n",
                                         dev->info->alt, res);
                         mutex_unlock(&dev->lock);
@@ -1614,7 +1822,7 @@ usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *buf)
          * FIXME add more tests!  cancel requests, verify the data, control
          * queueing, concurrent read+write threads, and so on.
          */
-        do_gettimeofday (&start);
+        do_gettimeofday(&start);
         switch (param->test_num) {
 
         case 0:
@@ -1629,14 +1837,14 @@ usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *buf)
                 dev_info(&intf->dev,
                                 "TEST 1:  write %d bytes %u times\n",
                                 param->length, param->iterations);
-                urb = simple_alloc_urb (udev, dev->out_pipe, param->length);
+                urb = simple_alloc_urb(udev, dev->out_pipe, param->length);
                 if (!urb) {
                         retval = -ENOMEM;
                         break;
                 }
-                // FIRMWARE:  bulk sink (maybe accepts short writes)
+                /* FIRMWARE:  bulk sink (maybe accepts short writes) */
                 retval = simple_io(dev, urb, param->iterations, 0, 0, "test1");
-                simple_free_urb (urb);
+                simple_free_urb(urb);
                 break;
         case 2:
                 if (dev->in_pipe == 0)
@@ -1644,14 +1852,14 @@ usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *buf)
                 dev_info(&intf->dev,
                                 "TEST 2:  read %d bytes %u times\n",
                                 param->length, param->iterations);
-                urb = simple_alloc_urb (udev, dev->in_pipe, param->length);
+                urb = simple_alloc_urb(udev, dev->in_pipe, param->length);
                 if (!urb) {
                         retval = -ENOMEM;
                         break;
                 }
-                // FIRMWARE:  bulk source (maybe generates short writes)
+                /* FIRMWARE:  bulk source (maybe generates short writes) */
                 retval = simple_io(dev, urb, param->iterations, 0, 0, "test2");
-                simple_free_urb (urb);
+                simple_free_urb(urb);
                 break;
         case 3:
                 if (dev->out_pipe == 0 || param->vary == 0)
@@ -1659,15 +1867,15 @@ usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *buf)
                 dev_info(&intf->dev,
                                 "TEST 3:  write/%d 0..%d bytes %u times\n",
                                 param->vary, param->length, param->iterations);
-                urb = simple_alloc_urb (udev, dev->out_pipe, param->length);
+                urb = simple_alloc_urb(udev, dev->out_pipe, param->length);
                 if (!urb) {
                         retval = -ENOMEM;
                         break;
                 }
-                // FIRMWARE:  bulk sink (maybe accepts short writes)
+                /* FIRMWARE:  bulk sink (maybe accepts short writes) */
                 retval = simple_io(dev, urb, param->iterations, param->vary,
                                         0, "test3");
-                simple_free_urb (urb);
+                simple_free_urb(urb);
                 break;
         case 4:
                 if (dev->in_pipe == 0 || param->vary == 0)
@@ -1675,15 +1883,15 @@ usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *buf)
                 dev_info(&intf->dev,
                                 "TEST 4:  read/%d 0..%d bytes %u times\n",
                                 param->vary, param->length, param->iterations);
-                urb = simple_alloc_urb (udev, dev->in_pipe, param->length);
+                urb = simple_alloc_urb(udev, dev->in_pipe, param->length);
                 if (!urb) {
                         retval = -ENOMEM;
                         break;
                 }
-                // FIRMWARE:  bulk source (maybe generates short writes)
+                /* FIRMWARE:  bulk source (maybe generates short writes) */
                 retval = simple_io(dev, urb, param->iterations, param->vary,
                                         0, "test4");
-                simple_free_urb (urb);
+                simple_free_urb(urb);
                 break;
 
         /* Queued bulk I/O tests */
@@ -1694,15 +1902,15 @@ usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *buf)
                         "TEST 5:  write %d sglists %d entries of %d bytes\n",
                                 param->iterations,
                                 param->sglen, param->length);
-                sg = alloc_sglist (param->sglen, param->length, 0);
+                sg = alloc_sglist(param->sglen, param->length, 0);
                 if (!sg) {
                         retval = -ENOMEM;
                         break;
                 }
-                // FIRMWARE:  bulk sink (maybe accepts short writes)
+                /* FIRMWARE:  bulk sink (maybe accepts short writes) */
                 retval = perform_sglist(dev, param->iterations, dev->out_pipe,
                                 &req, sg, param->sglen);
-                free_sglist (sg, param->sglen);
+                free_sglist(sg, param->sglen);
                 break;
 
         case 6:
@@ -1712,15 +1920,15 @@ usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *buf)
                         "TEST 6:  read %d sglists %d entries of %d bytes\n",
                                 param->iterations,
                                 param->sglen, param->length);
-                sg = alloc_sglist (param->sglen, param->length, 0);
+                sg = alloc_sglist(param->sglen, param->length, 0);
                 if (!sg) {
                         retval = -ENOMEM;
                         break;
                 }
-                // FIRMWARE:  bulk source (maybe generates short writes)
+                /* FIRMWARE:  bulk source (maybe generates short writes) */
                 retval = perform_sglist(dev, param->iterations, dev->in_pipe,
                                 &req, sg, param->sglen);
-                free_sglist (sg, param->sglen);
+                free_sglist(sg, param->sglen);
                 break;
         case 7:
                 if (dev->out_pipe == 0 || param->sglen == 0 || param->vary == 0)
@@ -1729,15 +1937,15 @@ usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *buf)
                         "TEST 7:  write/%d %d sglists %d entries 0..%d bytes\n",
                                 param->vary, param->iterations,
                                 param->sglen, param->length);
-                sg = alloc_sglist (param->sglen, param->length, param->vary);
+                sg = alloc_sglist(param->sglen, param->length, param->vary);
                 if (!sg) {
                         retval = -ENOMEM;
                         break;
                 }
-                // FIRMWARE:  bulk sink (maybe accepts short writes)
+                /* FIRMWARE:  bulk sink (maybe accepts short writes) */
                 retval = perform_sglist(dev, param->iterations, dev->out_pipe,
                                 &req, sg, param->sglen);
-                free_sglist (sg, param->sglen);
+                free_sglist(sg, param->sglen);
                 break;
         case 8:
                 if (dev->in_pipe == 0 || param->sglen == 0 || param->vary == 0)
@@ -1746,15 +1954,15 @@ usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *buf)
                         "TEST 8:  read/%d %d sglists %d entries 0..%d bytes\n",
                                 param->vary, param->iterations,
                                 param->sglen, param->length);
-                sg = alloc_sglist (param->sglen, param->length, param->vary);
+                sg = alloc_sglist(param->sglen, param->length, param->vary);
                 if (!sg) {
                         retval = -ENOMEM;
                         break;
                 }
-                // FIRMWARE:  bulk source (maybe generates short writes)
+                /* FIRMWARE:  bulk source (maybe generates short writes) */
                 retval = perform_sglist(dev, param->iterations, dev->in_pipe,
                                 &req, sg, param->sglen);
-                free_sglist (sg, param->sglen);
+                free_sglist(sg, param->sglen);
                 break;
 
         /* non-queued sanity tests for control (chapter 9 subset) */
@@ -1764,7 +1972,7 @@ usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *buf)
                         "TEST 9:  ch9 (subset) control tests, %d times\n",
                                 param->iterations);
                 for (i = param->iterations; retval == 0 && i--; /* NOP */)
-                        retval = ch9_postconfig (dev);
+                        retval = ch9_postconfig(dev);
                 if (retval)
                         dev_err(&intf->dev, "ch9 subset failed, "
                                         "iterations left %d\n", i);
@@ -1779,7 +1987,7 @@ usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *buf)
                                 "TEST 10:  queue %d control calls, %d times\n",
                                 param->sglen,
                                 param->iterations);
-                retval = test_ctrl_queue (dev, param);
+                retval = test_ctrl_queue(dev, param);
                 break;
 
         /* simple non-queued unlinks (ring with one urb) */
@@ -1790,7 +1998,7 @@ usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *buf)
                 dev_info(&intf->dev, "TEST 11:  unlink %d reads of %d\n",
                                 param->iterations, param->length);
                 for (i = param->iterations; retval == 0 && i--; /* NOP */)
-                        retval = unlink_simple (dev, dev->in_pipe,
+                        retval = unlink_simple(dev, dev->in_pipe,
                                                 param->length);
                 if (retval)
                         dev_err(&intf->dev, "unlink reads failed %d, "
@@ -1803,7 +2011,7 @@ usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *buf)
                 dev_info(&intf->dev, "TEST 12:  unlink %d writes of %d\n",
                                 param->iterations, param->length);
                 for (i = param->iterations; retval == 0 && i--; /* NOP */)
-                        retval = unlink_simple (dev, dev->out_pipe,
+                        retval = unlink_simple(dev, dev->out_pipe,
                                                 param->length);
                 if (retval)
                         dev_err(&intf->dev, "unlink writes failed %d, "
@@ -1818,7 +2026,7 @@ usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *buf)
                 dev_info(&intf->dev, "TEST 13:  set/clear %d halts\n",
                                 param->iterations);
                 for (i = param->iterations; retval == 0 && i--; /* NOP */)
-                        retval = halt_simple (dev);
+                        retval = halt_simple(dev);
 
                 if (retval)
                         ERROR(dev, "halts failed, iterations left %d\n", i);
@@ -1833,7 +2041,7 @@ usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *buf)
                                 realworld ? 1 : 0, param->length,
                                 param->vary);
                 retval = ctrl_out(dev, param->iterations,
-                                param->length, param->vary);
+                                param->length, param->vary, 0);
                 break;
 
         /* iso write tests */
@@ -1844,9 +2052,9 @@ usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *buf)
                         "TEST 15:  write %d iso, %d entries of %d bytes\n",
                                 param->iterations,
                                 param->sglen, param->length);
-                // FIRMWARE:  iso sink
-                retval = test_iso_queue (dev, param,
-                                dev->out_iso_pipe, dev->iso_out);
+                /* FIRMWARE:  iso sink */
+                retval = test_iso_queue(dev, param,
+                                dev->out_iso_pipe, dev->iso_out, 0);
                 break;
 
         /* iso read tests */
@@ -1857,17 +2065,125 @@ usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *buf)
                         "TEST 16:  read %d iso, %d entries of %d bytes\n",
                                 param->iterations,
                                 param->sglen, param->length);
-                // FIRMWARE:  iso source
-                retval = test_iso_queue (dev, param,
-                                dev->in_iso_pipe, dev->iso_in);
+                /* FIRMWARE:  iso source */
+                retval = test_iso_queue(dev, param,
+                                dev->in_iso_pipe, dev->iso_in, 0);
+                break;
+
+        /* FIXME scatterlist cancel (needs helper thread) */
+
+        /* Tests for bulk I/O using DMA mapping by core and odd address */
+        case 17:
+                if (dev->out_pipe == 0)
+                        break;
+                dev_info(&intf->dev,
+                        "TEST 17:  write odd addr %d bytes %u times core map\n",
+                        param->length, param->iterations);
+
+                retval = test_unaligned_bulk(
+                                dev, dev->out_pipe,
+                                param->length, param->iterations,
+                                0, "test17");
+                break;
+
+        case 18:
+                if (dev->in_pipe == 0)
+                        break;
+                dev_info(&intf->dev,
+                        "TEST 18:  read odd addr %d bytes %u times core map\n",
+                        param->length, param->iterations);
+
+                retval = test_unaligned_bulk(
+                                dev, dev->in_pipe,
+                                param->length, param->iterations,
+                                0, "test18");
+                break;
+
+        /* Tests for bulk I/O using premapped coherent buffer and odd address */
+        case 19:
+                if (dev->out_pipe == 0)
+                        break;
+                dev_info(&intf->dev,
+                        "TEST 19:  write odd addr %d bytes %u times premapped\n",
+                        param->length, param->iterations);
+
+                retval = test_unaligned_bulk(
+                                dev, dev->out_pipe,
+                                param->length, param->iterations,
+                                URB_NO_TRANSFER_DMA_MAP, "test19");
+                break;
+
+        case 20:
+                if (dev->in_pipe == 0)
+                        break;
+                dev_info(&intf->dev,
+                        "TEST 20:  read odd addr %d bytes %u times premapped\n",
+                        param->length, param->iterations);
+
+                retval = test_unaligned_bulk(
+                                dev, dev->in_pipe,
+                                param->length, param->iterations,
+                                URB_NO_TRANSFER_DMA_MAP, "test20");
+                break;
+
+        /* control write tests with unaligned buffer */
+        case 21:
+                if (!dev->info->ctrl_out)
+                        break;
+                dev_info(&intf->dev,
+                                "TEST 21:  %d ep0out odd addr, %d..%d vary %d\n",
+                                param->iterations,
+                                realworld ? 1 : 0, param->length,
+                                param->vary);
+                retval = ctrl_out(dev, param->iterations,
+                                param->length, param->vary, 1);
+                break;
+
+        /* unaligned iso tests */
+        case 22:
+                if (dev->out_iso_pipe == 0 || param->sglen == 0)
+                        break;
+                dev_info(&intf->dev,
+                        "TEST 22:  write %d iso odd, %d entries of %d bytes\n",
+                                param->iterations,
+                                param->sglen, param->length);
+                retval = test_iso_queue(dev, param,
+                                dev->out_iso_pipe, dev->iso_out, 1);
                 break;
 
-        // FIXME unlink from queue (ring with N urbs)
+        case 23:
+                if (dev->in_iso_pipe == 0 || param->sglen == 0)
+                        break;
+                dev_info(&intf->dev,
+                        "TEST 23:  read %d iso odd, %d entries of %d bytes\n",
+                                param->iterations,
+                                param->sglen, param->length);
+                retval = test_iso_queue(dev, param,
+                                dev->in_iso_pipe, dev->iso_in, 1);
+                break;
 
-        // FIXME scatterlist cancel (needs helper thread)
+        /* unlink URBs from a bulk-OUT queue */
+        case 24:
+                if (dev->out_pipe == 0 || !param->length || param->sglen < 4)
+                        break;
+                retval = 0;
+                dev_info(&intf->dev, "TEST 17:  unlink from %d queues of "
+                                "%d %d-byte writes\n",
+                                param->iterations, param->sglen, param->length);
+                for (i = param->iterations; retval == 0 && i > 0; --i) {
+                        retval = unlink_queued(dev, dev->out_pipe,
+                                                param->sglen, param->length);
+                        if (retval) {
+                                dev_err(&intf->dev,
+                                        "unlink queued writes failed %d, "
+                                        "iterations left %d\n", retval, i);
+                                break;
+                        }
+                }
+                break;
 
         }
-        do_gettimeofday (&param->duration);
+        do_gettimeofday(&param->duration);
         param->duration.tv_sec -= start.tv_sec;
         param->duration.tv_usec -= start.tv_usec;
         if (param->duration.tv_usec < 0) {
@@ -1880,22 +2196,22 @@ usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *buf)
 
 /*-------------------------------------------------------------------------*/
 
-static unsigned force_interrupt = 0;
-module_param (force_interrupt, uint, 0);
-MODULE_PARM_DESC (force_interrupt, "0 = test default; else interrupt");
+static unsigned force_interrupt;
+module_param(force_interrupt, uint, 0);
+MODULE_PARM_DESC(force_interrupt, "0 = test default; else interrupt");
 
 #ifdef  GENERIC
 static unsigned short vendor;
 module_param(vendor, ushort, 0);
-MODULE_PARM_DESC (vendor, "vendor code (from usb-if)");
+MODULE_PARM_DESC(vendor, "vendor code (from usb-if)");
 
 static unsigned short product;
 module_param(product, ushort, 0);
-MODULE_PARM_DESC (product, "product code (from vendor)");
+MODULE_PARM_DESC(product, "product code (from vendor)");
 #endif
 
 static int
-usbtest_probe (struct usb_interface *intf, const struct usb_device_id *id)
+usbtest_probe(struct usb_interface *intf, const struct usb_device_id *id)
 {
         struct usb_device       *udev;
         struct usbtest_dev      *dev;
@@ -1903,7 +2219,7 @@ usbtest_probe (struct usb_interface *intf, const struct usb_device_id *id)
         char                    *rtest, *wtest;
         char                    *irtest, *iwtest;
 
-        udev = interface_to_usbdev (intf);
+        udev = interface_to_usbdev(intf);
 
 #ifdef  GENERIC
         /* specify devices by module parameters? */
@@ -1930,8 +2246,9 @@ usbtest_probe (struct usb_interface *intf, const struct usb_device_id *id)
         dev->intf = intf;
 
         /* cacheline-aligned scratch for i/o */
-        if ((dev->buf = kmalloc (TBUF_SIZE, GFP_KERNEL)) == NULL) {
-                kfree (dev);
+        dev->buf = kmalloc(TBUF_SIZE, GFP_KERNEL);
+        if (dev->buf == NULL) {
+                kfree(dev);
                 return -ENOMEM;
         }
 
@@ -1943,18 +2260,18 @@ usbtest_probe (struct usb_interface *intf, const struct usb_device_id *id)
         irtest = iwtest = "";
         if (force_interrupt || udev->speed == USB_SPEED_LOW) {
                 if (info->ep_in) {
-                        dev->in_pipe = usb_rcvintpipe (udev, info->ep_in);
+                        dev->in_pipe = usb_rcvintpipe(udev, info->ep_in);
                         rtest = " intr-in";
                 }
                 if (info->ep_out) {
-                        dev->out_pipe = usb_sndintpipe (udev, info->ep_out);
+                        dev->out_pipe = usb_sndintpipe(udev, info->ep_out);
                         wtest = " intr-out";
                 }
         } else {
                 if (info->autoconf) {
                         int status;
 
-                        status = get_endpoints (dev, intf);
+                        status = get_endpoints(dev, intf);
                         if (status < 0) {
                                 WARNING(dev, "couldn't get endpoints, %d\n",
                                                 status);
@@ -1963,10 +2280,10 @@ usbtest_probe (struct usb_interface *intf, const struct usb_device_id *id)
                         /* may find bulk or ISO pipes */
                 } else {
                         if (info->ep_in)
-                                dev->in_pipe = usb_rcvbulkpipe (udev,
+                                dev->in_pipe = usb_rcvbulkpipe(udev,
                                                         info->ep_in);
                         if (info->ep_out)
-                                dev->out_pipe = usb_sndbulkpipe (udev,
+                                dev->out_pipe = usb_sndbulkpipe(udev,
                                                         info->ep_out);
                 }
                 if (dev->in_pipe)
@@ -1979,15 +2296,26 @@ usbtest_probe (struct usb_interface *intf, const struct usb_device_id *id)
                         iwtest = " iso-out";
         }
 
-        usb_set_intfdata (intf, dev);
-        dev_info (&intf->dev, "%s\n", info->name);
-        dev_info (&intf->dev, "%s speed {control%s%s%s%s%s} tests%s\n",
+        usb_set_intfdata(intf, dev);
+        dev_info(&intf->dev, "%s\n", info->name);
+        dev_info(&intf->dev, "%s speed {control%s%s%s%s%s} tests%s\n",
                         ({ char *tmp;
                         switch (udev->speed) {
-                        case USB_SPEED_LOW: tmp = "low"; break;
-                        case USB_SPEED_FULL: tmp = "full"; break;
-                        case USB_SPEED_HIGH: tmp = "high"; break;
-                        default: tmp = "unknown"; break;
+                        case USB_SPEED_LOW:
+                                tmp = "low";
+                                break;
+                        case USB_SPEED_FULL:
+                                tmp = "full";
+                                break;
+                        case USB_SPEED_HIGH:
+                                tmp = "high";
+                                break;
+                        case USB_SPEED_SUPER:
+                                tmp = "super";
+                                break;
+                        default:
+                                tmp = "unknown";
+                                break;
                         }; tmp; }),
                         info->ctrl_out ? " in/out" : "",
                         rtest, wtest,
@@ -1996,24 +2324,24 @@ usbtest_probe (struct usb_interface *intf, const struct usb_device_id *id)
         return 0;
 }
 
-static int usbtest_suspend (struct usb_interface *intf, pm_message_t message)
+static int usbtest_suspend(struct usb_interface *intf, pm_message_t message)
 {
         return 0;
 }
 
-static int usbtest_resume (struct usb_interface *intf)
+static int usbtest_resume(struct usb_interface *intf)
 {
         return 0;
 }
 
 
-static void usbtest_disconnect (struct usb_interface *intf)
+static void usbtest_disconnect(struct usb_interface *intf)
 {
-        struct usbtest_dev      *dev = usb_get_intfdata (intf);
+        struct usbtest_dev      *dev = usb_get_intfdata(intf);
 
-        usb_set_intfdata (intf, NULL);
-        dev_dbg (&intf->dev, "disconnect\n");
-        kfree (dev);
+        usb_set_intfdata(intf, NULL);
+        dev_dbg(&intf->dev, "disconnect\n");
+        kfree(dev);
 }
 
 /* Basic testing only needs a device that can source or sink bulk traffic.
@@ -2050,9 +2378,9 @@ static struct usbtest_info fw_info = {
         .ep_in          = 2,
         .ep_out         = 2,
         .alt            = 1,
-        .autoconf       = 1,            // iso and ctrl_out need autoconf
+        .autoconf       = 1,            /* iso and ctrl_out need autoconf */
         .ctrl_out       = 1,
-        .iso            = 1,            // iso_ep's are #8 in/out
+        .iso            = 1,            /* iso_ep's are #8 in/out */
 };
 
 /* peripheral running Linux and 'zero.c' test firmware, or
@@ -2109,56 +2437,56 @@ static const struct usb_device_id id_table[] = {
          */
 
         /* generic EZ-USB FX controller */
-        { USB_DEVICE (0x0547, 0x2235),
+        { USB_DEVICE(0x0547, 0x2235),
                 .driver_info = (unsigned long) &ez1_info,
-                },
+        },
 
         /* CY3671 development board with EZ-USB FX */
-        { USB_DEVICE (0x0547, 0x0080),
+        { USB_DEVICE(0x0547, 0x0080),
                 .driver_info = (unsigned long) &ez1_info,
-                },
+        },
 
         /* generic EZ-USB FX2 controller (or development board) */
-        { USB_DEVICE (0x04b4, 0x8613),
+        { USB_DEVICE(0x04b4, 0x8613),
                 .driver_info = (unsigned long) &ez2_info,
-                },
+        },
 
         /* re-enumerated usb test device firmware */
-        { USB_DEVICE (0xfff0, 0xfff0),
+        { USB_DEVICE(0xfff0, 0xfff0),
                 .driver_info = (unsigned long) &fw_info,
-                },
+        },
 
         /* "Gadget Zero" firmware runs under Linux */
-        { USB_DEVICE (0x0525, 0xa4a0),
+        { USB_DEVICE(0x0525, 0xa4a0),
                 .driver_info = (unsigned long) &gz_info,
-                },
+        },
 
         /* so does a user-mode variant */
-        { USB_DEVICE (0x0525, 0xa4a4),
+        { USB_DEVICE(0x0525, 0xa4a4),
                 .driver_info = (unsigned long) &um_info,
-                },
+        },
 
         /* ... and a user-mode variant that talks iso */
-        { USB_DEVICE (0x0525, 0xa4a3),
+        { USB_DEVICE(0x0525, 0xa4a3),
                 .driver_info = (unsigned long) &um2_info,
-                },
+        },
 
 #ifdef KEYSPAN_19Qi
         /* Keyspan 19qi uses an21xx (original EZ-USB) */
-        // this does not coexist with the real Keyspan 19qi driver!
-        { USB_DEVICE (0x06cd, 0x010b),
+        /* this does not coexist with the real Keyspan 19qi driver! */
+        { USB_DEVICE(0x06cd, 0x010b),
                 .driver_info = (unsigned long) &ez1_info,
-                },
+        },
 #endif
 
         /*-------------------------------------------------------------*/
 
 #ifdef IBOT2
         /* iBOT2 makes a nice source of high speed bulk-in data */
-        // this does not coexist with a real iBOT2 driver!
-        { USB_DEVICE (0x0b62, 0x0059),
+        /* this does not coexist with a real iBOT2 driver! */
+        { USB_DEVICE(0x0b62, 0x0059),
                 .driver_info = (unsigned long) &ibot2_info,
-                },
+        },
 #endif
 
         /*-------------------------------------------------------------*/
@@ -2172,7 +2500,7 @@ static const struct usb_device_id id_table[] = {
 
         { }
 };
-MODULE_DEVICE_TABLE (usb, id_table);
+MODULE_DEVICE_TABLE(usb, id_table);
 
 static struct usb_driver usbtest_driver = {
         .name =         "usbtest",
@@ -2186,22 +2514,22 @@ static struct usb_driver usbtest_driver = {
 
 /*-------------------------------------------------------------------------*/
 
-static int __init usbtest_init (void)
+static int __init usbtest_init(void)
 {
 #ifdef GENERIC
         if (vendor)
                 pr_debug("params: vend=0x%04x prod=0x%04x\n", vendor, product);
 #endif
-        return usb_register (&usbtest_driver);
+        return usb_register(&usbtest_driver);
 }
-module_init (usbtest_init);
+module_init(usbtest_init);
 
-static void __exit usbtest_exit (void)
+static void __exit usbtest_exit(void)
 {
-        usb_deregister (&usbtest_driver);
+        usb_deregister(&usbtest_driver);
 }
-module_exit (usbtest_exit);
+module_exit(usbtest_exit);
 
-MODULE_DESCRIPTION ("USB Core/HCD Testing Driver");
-MODULE_LICENSE ("GPL");
+MODULE_DESCRIPTION("USB Core/HCD Testing Driver");
+MODULE_LICENSE("GPL");
 
diff --git a/drivers/usb/misc/uss720.c b/drivers/usb/misc/uss720.c
index 796e2f68f749..8b1d94a76914 100644
--- a/drivers/usb/misc/uss720.c
+++ b/drivers/usb/misc/uss720.c
@@ -3,7 +3,7 @@
 /*
  *      uss720.c  --  USS720 USB Parport Cable.
  *
- *      Copyright (C) 1999, 2005
+ *      Copyright (C) 1999, 2005, 2010
  *          Thomas Sailer (t.sailer@alumni.ethz.ch)
  *
  *      This program is free software; you can redistribute it and/or modify
@@ -177,12 +177,11 @@ static struct uss720_async_request *submit_async_request(struct parport_uss720_p
         spin_lock_irqsave(&priv->asynclock, flags);
         list_add_tail(&rq->asynclist, &priv->asynclist);
         spin_unlock_irqrestore(&priv->asynclock, flags);
+        kref_get(&rq->ref_count);
         ret = usb_submit_urb(rq->urb, mem_flags);
-        if (!ret) {
-                kref_get(&rq->ref_count);
+        if (!ret)
                 return rq;
-        }
-        kref_put(&rq->ref_count, destroy_async);
+        destroy_async(&rq->ref_count);
         err("submit_async_request submit_urb failed with %d", ret);
         return NULL;
 }
@@ -776,6 +775,7 @@ static const struct usb_device_id uss720_table[] = {
         { USB_DEVICE(0x0557, 0x2001) },
         { USB_DEVICE(0x0729, 0x1284) },
         { USB_DEVICE(0x1293, 0x0002) },
+        { USB_DEVICE(0x050d, 0x0002) },
         { }                                             /* Terminating entry */
 };
 
diff --git a/drivers/usb/misc/yurex.c b/drivers/usb/misc/yurex.c
new file mode 100644
index 000000000000..ac5bfd619e62
--- /dev/null
+++ b/drivers/usb/misc/yurex.c
@@ -0,0 +1,564 @@
+/*
+ * Driver for Meywa-Denki & KAYAC YUREX
+ *
+ * Copyright (C) 2010 Tomoki Sekiyama (tomoki.sekiyama@gmail.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 the Free Software Foundation, version 2.
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/kref.h>
+#include <linux/mutex.h>
+#include <linux/uaccess.h>
+#include <linux/usb.h>
+#include <linux/hid.h>
+
+#define DRIVER_AUTHOR "Tomoki Sekiyama"
+#define DRIVER_DESC "Driver for Meywa-Denki & KAYAC YUREX"
+
+#define YUREX_VENDOR_ID         0x0c45
+#define YUREX_PRODUCT_ID        0x1010
+
+#define CMD_ACK         '!'
+#define CMD_ANIMATE     'A'
+#define CMD_COUNT       'C'
+#define CMD_LED         'L'
+#define CMD_READ        'R'
+#define CMD_SET         'S'
+#define CMD_VERSION     'V'
+#define CMD_EOF         0x0d
+#define CMD_PADDING     0xff
+
+#define YUREX_BUF_SIZE          8
+#define YUREX_WRITE_TIMEOUT     (HZ*2)
+
+/* table of devices that work with this driver */
+static struct usb_device_id yurex_table[] = {
+        { USB_DEVICE(YUREX_VENDOR_ID, YUREX_PRODUCT_ID) },
+        { }                                     /* Terminating entry */
+};
+MODULE_DEVICE_TABLE(usb, yurex_table);
+
+#ifdef CONFIG_USB_DYNAMIC_MINORS
+#define YUREX_MINOR_BASE        0
+#else
+#define YUREX_MINOR_BASE        192
+#endif
+
+/* Structure to hold all of our device specific stuff */
+struct usb_yurex {
+        struct usb_device       *udev;
+        struct usb_interface    *interface;
+        __u8                    int_in_endpointAddr;
+        struct urb              *urb;           /* URB for interrupt in */
+        unsigned char           *int_buffer;    /* buffer for intterupt in */
+        struct urb              *cntl_urb;      /* URB for control msg */
+        struct usb_ctrlrequest  *cntl_req;      /* req for control msg */
+        unsigned char           *cntl_buffer;   /* buffer for control msg */
+
+        struct kref             kref;
+        struct mutex            io_mutex;
+        struct fasync_struct    *async_queue;
+        wait_queue_head_t       waitq;
+
+        spinlock_t              lock;
+        __s64                   bbu;            /* BBU from device */
+};
+#define to_yurex_dev(d) container_of(d, struct usb_yurex, kref)
+
+static struct usb_driver yurex_driver;
+static const struct file_operations yurex_fops;
+
+
+static void yurex_control_callback(struct urb *urb)
+{
+        struct usb_yurex *dev = urb->context;
+        int status = urb->status;
+
+        if (status) {
+                err("%s - control failed: %d\n", __func__, status);
+                wake_up_interruptible(&dev->waitq);
+                return;
+        }
+        /* on success, sender woken up by CMD_ACK int in, or timeout */
+}
+
+static void yurex_delete(struct kref *kref)
+{
+        struct usb_yurex *dev = to_yurex_dev(kref);
+
+        dbg("yurex_delete");
+
+        usb_put_dev(dev->udev);
+        if (dev->cntl_urb) {
+                usb_kill_urb(dev->cntl_urb);
+                if (dev->cntl_req)
+                        usb_free_coherent(dev->udev, YUREX_BUF_SIZE,
+                                dev->cntl_req, dev->cntl_urb->setup_dma);
+                if (dev->cntl_buffer)
+                        usb_free_coherent(dev->udev, YUREX_BUF_SIZE,
+                                dev->cntl_buffer, dev->cntl_urb->transfer_dma);
+                usb_free_urb(dev->cntl_urb);
+        }
+        if (dev->urb) {
+                usb_kill_urb(dev->urb);
+                if (dev->int_buffer)
+                        usb_free_coherent(dev->udev, YUREX_BUF_SIZE,
+                                dev->int_buffer, dev->urb->transfer_dma);
+                usb_free_urb(dev->urb);
+        }
+        kfree(dev);
+}
+
+/*
+ * usb class driver info in order to get a minor number from the usb core,
+ * and to have the device registered with the driver core
+ */
+static struct usb_class_driver yurex_class = {
+        .name =         "yurex%d",
+        .fops =         &yurex_fops,
+        .minor_base =   YUREX_MINOR_BASE,
+};
+
+static void yurex_interrupt(struct urb *urb)
+{
+        struct usb_yurex *dev = urb->context;
+        unsigned char *buf = dev->int_buffer;
+        int status = urb->status;
+        unsigned long flags;
+        int retval, i;
+
+        switch (status) {
+        case 0: /*success*/
+                break;
+        case -EOVERFLOW:
+                err("%s - overflow with length %d, actual length is %d",
+                    __func__, YUREX_BUF_SIZE, dev->urb->actual_length);
+        case -ECONNRESET:
+        case -ENOENT:
+        case -ESHUTDOWN:
+        case -EILSEQ:
+                /* The device is terminated, clean up */
+                return;
+        default:
+                err("%s - unknown status received: %d", __func__, status);
+                goto exit;
+        }
+
+        /* handle received message */
+        switch (buf[0]) {
+        case CMD_COUNT:
+        case CMD_READ:
+                if (buf[6] == CMD_EOF) {
+                        spin_lock_irqsave(&dev->lock, flags);
+                        dev->bbu = 0;
+                        for (i = 1; i < 6; i++) {
+                                dev->bbu += buf[i];
+                                if (i != 5)
+                                        dev->bbu <<= 8;
+                        }
+                        dbg("%s count: %lld", __func__, dev->bbu);
+                        spin_unlock_irqrestore(&dev->lock, flags);
+
+                        kill_fasync(&dev->async_queue, SIGIO, POLL_IN);
+                }
+                else
+                        dbg("data format error - no EOF");
+                break;
+        case CMD_ACK:
+                dbg("%s ack: %c", __func__, buf[1]);
+                wake_up_interruptible(&dev->waitq);
+                break;
+        }
+
+exit:
+        retval = usb_submit_urb(dev->urb, GFP_ATOMIC);
+        if (retval) {
+                err("%s - usb_submit_urb failed: %d",
+                        __func__, retval);
+        }
+}
+
+static int yurex_probe(struct usb_interface *interface, const struct usb_device_id *id)
+{
+        struct usb_yurex *dev;
+        struct usb_host_interface *iface_desc;
+        struct usb_endpoint_descriptor *endpoint;
+        int retval = -ENOMEM;
+        int i;
+        DEFINE_WAIT(wait);
+
+        /* allocate memory for our device state and initialize it */
+        dev = kzalloc(sizeof(*dev), GFP_KERNEL);
+        if (!dev) {
+                err("Out of memory");
+                goto error;
+        }
+        kref_init(&dev->kref);
+        mutex_init(&dev->io_mutex);
+        spin_lock_init(&dev->lock);
+        init_waitqueue_head(&dev->waitq);
+
+        dev->udev = usb_get_dev(interface_to_usbdev(interface));
+        dev->interface = interface;
+
+        /* set up the endpoint information */
+        iface_desc = interface->cur_altsetting;
+        for (i = 0; i < iface_desc->desc.bNumEndpoints; i++) {
+                endpoint = &iface_desc->endpoint[i].desc;
+
+                if (usb_endpoint_is_int_in(endpoint)) {
+                        dev->int_in_endpointAddr = endpoint->bEndpointAddress;
+                        break;
+                }
+        }
+        if (!dev->int_in_endpointAddr) {
+                retval = -ENODEV;
+                err("Could not find endpoints");
+                goto error;
+        }
+
+
+        /* allocate control URB */
+        dev->cntl_urb = usb_alloc_urb(0, GFP_KERNEL);
+        if (!dev->cntl_urb) {
+                err("Could not allocate control URB");
+                goto error;
+        }
+
+        /* allocate buffer for control req */
+        dev->cntl_req = usb_alloc_coherent(dev->udev, YUREX_BUF_SIZE,
+                                           GFP_KERNEL,
+                                           &dev->cntl_urb->setup_dma);
+        if (!dev->cntl_req) {
+                err("Could not allocate cntl_req");
+                goto error;
+        }
+
+        /* allocate buffer for control msg */
+        dev->cntl_buffer = usb_alloc_coherent(dev->udev, YUREX_BUF_SIZE,
+                                              GFP_KERNEL,
+                                              &dev->cntl_urb->transfer_dma);
+        if (!dev->cntl_buffer) {
+                err("Could not allocate cntl_buffer");
+                goto error;
+        }
+
+        /* configure control URB */
+        dev->cntl_req->bRequestType = USB_DIR_OUT | USB_TYPE_CLASS |
+                                      USB_RECIP_INTERFACE;
+        dev->cntl_req->bRequest = HID_REQ_SET_REPORT;
+        dev->cntl_req->wValue   = cpu_to_le16((HID_OUTPUT_REPORT + 1) << 8);
+        dev->cntl_req->wIndex   = cpu_to_le16(iface_desc->desc.bInterfaceNumber);
+        dev->cntl_req->wLength  = cpu_to_le16(YUREX_BUF_SIZE);
+
+        usb_fill_control_urb(dev->cntl_urb, dev->udev,
+                             usb_sndctrlpipe(dev->udev, 0),
+                             (void *)dev->cntl_req, dev->cntl_buffer,
+                             YUREX_BUF_SIZE, yurex_control_callback, dev);
+        dev->cntl_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
+
+
+        /* allocate interrupt URB */
+        dev->urb = usb_alloc_urb(0, GFP_KERNEL);
+        if (!dev->urb) {
+                err("Could not allocate URB");
+                goto error;
+        }
+
+        /* allocate buffer for interrupt in */
+        dev->int_buffer = usb_alloc_coherent(dev->udev, YUREX_BUF_SIZE,
+                                        GFP_KERNEL, &dev->urb->transfer_dma);
+        if (!dev->int_buffer) {
+                err("Could not allocate int_buffer");
+                goto error;
+        }
+
+        /* configure interrupt URB */
+        usb_fill_int_urb(dev->urb, dev->udev,
+                         usb_rcvintpipe(dev->udev, dev->int_in_endpointAddr),
+                         dev->int_buffer, YUREX_BUF_SIZE, yurex_interrupt,
+                         dev, 1);
+        dev->cntl_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
+        if (usb_submit_urb(dev->urb, GFP_KERNEL)) {
+                retval = -EIO;
+                err("Could not submitting URB");
+                goto error;
+        }
+
+        /* save our data pointer in this interface device */
+        usb_set_intfdata(interface, dev);
+
+        /* we can register the device now, as it is ready */
+        retval = usb_register_dev(interface, &yurex_class);
+        if (retval) {
+                err("Not able to get a minor for this device.");
+                usb_set_intfdata(interface, NULL);
+                goto error;
+        }
+
+        dev->bbu = -1;
+
+        dev_info(&interface->dev,
+                 "USB YUREX device now attached to Yurex #%d\n",
+                 interface->minor);
+
+        return 0;
+
+error:
+        if (dev)
+                /* this frees allocated memory */
+                kref_put(&dev->kref, yurex_delete);
+        return retval;
+}
+
+static void yurex_disconnect(struct usb_interface *interface)
+{
+        struct usb_yurex *dev;
+        int minor = interface->minor;
+
+        dev = usb_get_intfdata(interface);
+        usb_set_intfdata(interface, NULL);
+
+        /* give back our minor */
+        usb_deregister_dev(interface, &yurex_class);
+
+        /* prevent more I/O from starting */
+        mutex_lock(&dev->io_mutex);
+        dev->interface = NULL;
+        mutex_unlock(&dev->io_mutex);
+
+        /* wakeup waiters */
+        kill_fasync(&dev->async_queue, SIGIO, POLL_IN);
+        wake_up_interruptible(&dev->waitq);
+
+        /* decrement our usage count */
+        kref_put(&dev->kref, yurex_delete);
+
+        dev_info(&interface->dev, "USB YUREX #%d now disconnected\n", minor);
+}
+
+static struct usb_driver yurex_driver = {
+        .name =         "yurex",
+        .probe =        yurex_probe,
+        .disconnect =   yurex_disconnect,
+        .id_table =     yurex_table,
+};
+
+
+static int yurex_fasync(int fd, struct file *file, int on)
+{
+        struct usb_yurex *dev;
+
+        dev = (struct usb_yurex *)file->private_data;
+        return fasync_helper(fd, file, on, &dev->async_queue);
+}
+
+static int yurex_open(struct inode *inode, struct file *file)
+{
+        struct usb_yurex *dev;
+        struct usb_interface *interface;
+        int subminor;
+        int retval = 0;
+
+        subminor = iminor(inode);
+
+        interface = usb_find_interface(&yurex_driver, subminor);
+        if (!interface) {
+                err("%s - error, can't find device for minor %d",
+                    __func__, subminor);
+                retval = -ENODEV;
+                goto exit;
+        }
+
+        dev = usb_get_intfdata(interface);
+        if (!dev) {
+                retval = -ENODEV;
+                goto exit;
+        }
+
+        /* increment our usage count for the device */
+        kref_get(&dev->kref);
+
+        /* save our object in the file's private structure */
+        mutex_lock(&dev->io_mutex);
+        file->private_data = dev;
+        mutex_unlock(&dev->io_mutex);
+
+exit:
+        return retval;
+}
+
+static int yurex_release(struct inode *inode, struct file *file)
+{
+        struct usb_yurex *dev;
+
+        dev = (struct usb_yurex *)file->private_data;
+        if (dev == NULL)
+                return -ENODEV;
+
+        yurex_fasync(-1, file, 0);
+
+        /* decrement the count on our device */
+        kref_put(&dev->kref, yurex_delete);
+        return 0;
+}
+
+static ssize_t yurex_read(struct file *file, char *buffer, size_t count, loff_t *ppos)
+{
+        struct usb_yurex *dev;
+        int retval = 0;
+        int bytes_read = 0;
+        char in_buffer[20];
+        unsigned long flags;
+
+        dev = (struct usb_yurex *)file->private_data;
+
+        mutex_lock(&dev->io_mutex);
+        if (!dev->interface) {          /* already disconnected */
+                retval = -ENODEV;
+                goto exit;
+        }
+
+        spin_lock_irqsave(&dev->lock, flags);
+        bytes_read = snprintf(in_buffer, 20, "%lld\n", dev->bbu);
+        spin_unlock_irqrestore(&dev->lock, flags);
+
+        if (*ppos < bytes_read) {
+                if (copy_to_user(buffer, in_buffer + *ppos, bytes_read - *ppos))
+                        retval = -EFAULT;
+                else {
+                        retval = bytes_read - *ppos;
+                        *ppos += bytes_read;
+                }
+        }
+
+exit:
+        mutex_unlock(&dev->io_mutex);
+        return retval;
+}
+
+static ssize_t yurex_write(struct file *file, const char *user_buffer, size_t count, loff_t *ppos)
+{
+        struct usb_yurex *dev;
+        int i, set = 0, retval = 0;
+        char buffer[16];
+        char *data = buffer;
+        unsigned long long c, c2 = 0;
+        signed long timeout = 0;
+        DEFINE_WAIT(wait);
+
+        count = min(sizeof(buffer), count);
+        dev = (struct usb_yurex *)file->private_data;
+
+        /* verify that we actually have some data to write */
+        if (count == 0)
+                goto error;
+
+        mutex_lock(&dev->io_mutex);
+        if (!dev->interface) {          /* alreaday disconnected */
+                mutex_unlock(&dev->io_mutex);
+                retval = -ENODEV;
+                goto error;
+        }
+
+        if (copy_from_user(buffer, user_buffer, count)) {
+                mutex_unlock(&dev->io_mutex);
+                retval = -EFAULT;
+                goto error;
+        }
+        memset(dev->cntl_buffer, CMD_PADDING, YUREX_BUF_SIZE);
+
+        switch (buffer[0]) {
+        case CMD_ANIMATE:
+        case CMD_LED:
+                dev->cntl_buffer[0] = buffer[0];
+                dev->cntl_buffer[1] = buffer[1];
+                dev->cntl_buffer[2] = CMD_EOF;
+                break;
+        case CMD_READ:
+        case CMD_VERSION:
+                dev->cntl_buffer[0] = buffer[0];
+                dev->cntl_buffer[1] = 0x00;
+                dev->cntl_buffer[2] = CMD_EOF;
+                break;
+        case CMD_SET:
+                data++;
+                /* FALL THROUGH */
+        case '0' ... '9':
+                set = 1;
+                c = c2 = simple_strtoull(data, NULL, 0);
+                dev->cntl_buffer[0] = CMD_SET;
+                for (i = 1; i < 6; i++) {
+                        dev->cntl_buffer[i] = (c>>32) & 0xff;
+                        c <<= 8;
+                }
+                buffer[6] = CMD_EOF;
+                break;
+        default:
+                mutex_unlock(&dev->io_mutex);
+                return -EINVAL;
+        }
+
+        /* send the data as the control msg */
+        prepare_to_wait(&dev->waitq, &wait, TASK_INTERRUPTIBLE);
+        dbg("%s - submit %c", __func__, dev->cntl_buffer[0]);
+        retval = usb_submit_urb(dev->cntl_urb, GFP_KERNEL);
+        if (retval >= 0)
+                timeout = schedule_timeout(YUREX_WRITE_TIMEOUT);
+        finish_wait(&dev->waitq, &wait);
+
+        mutex_unlock(&dev->io_mutex);
+
+        if (retval < 0) {
+                err("%s - failed to send bulk msg, error %d", __func__, retval);
+                goto error;
+        }
+        if (set && timeout)
+                dev->bbu = c2;
+        return timeout ? count : -EIO;
+
+error:
+        return retval;
+}
+
+static const struct file_operations yurex_fops = {
+        .owner =        THIS_MODULE,
+        .read =         yurex_read,
+        .write =        yurex_write,
+        .open =         yurex_open,
+        .release =      yurex_release,
+        .fasync =       yurex_fasync,
+        .llseek =       default_llseek,
+};
+
+
+static int __init usb_yurex_init(void)
+{
+        int result;
+
+        /* register this driver with the USB subsystem */
+        result = usb_register(&yurex_driver);
+        if (result)
+                err("usb_register failed. Error number %d", result);
+
+        return result;
+}
+
+static void __exit usb_yurex_exit(void)
+{
+        /* deregister this driver with the USB subsystem */
+        usb_deregister(&yurex_driver);
+}
+
+module_init(usb_yurex_init);
+module_exit(usb_yurex_exit);
+
+MODULE_LICENSE("GPL");
diff --git a/drivers/usb/mon/Makefile b/drivers/usb/mon/Makefile
index 384b198faa7c..8ed24ab08698 100644
--- a/drivers/usb/mon/Makefile
+++ b/drivers/usb/mon/Makefile
@@ -2,6 +2,6 @@
 # Makefile for USB monitor
 #
 
-usbmon-objs     := mon_main.o mon_stat.o mon_text.o mon_bin.o
+usbmon-y := mon_main.o mon_stat.o mon_text.o mon_bin.o
 
 obj-$(CONFIG_USB_MON)   += usbmon.o
diff --git a/drivers/usb/mon/mon_bin.c b/drivers/usb/mon/mon_bin.c
index 44cb37b5a4dc..a09dbd243eb3 100644
--- a/drivers/usb/mon/mon_bin.c
+++ b/drivers/usb/mon/mon_bin.c
@@ -15,7 +15,6 @@
 #include <linux/poll.h>
 #include <linux/compat.h>
 #include <linux/mm.h>
-#include <linux/smp_lock.h>
 #include <linux/scatterlist.h>
 #include <linux/slab.h>
 
@@ -437,6 +436,28 @@ static unsigned int mon_bin_get_data(const struct mon_reader_bin *rp,
         return length;
 }
 
+/*
+ * This is the look-ahead pass in case of 'C Zi', when actual_length cannot
+ * be used to determine the length of the whole contiguous buffer.
+ */
+static unsigned int mon_bin_collate_isodesc(const struct mon_reader_bin *rp,
+    struct urb *urb, unsigned int ndesc)
+{
+        struct usb_iso_packet_descriptor *fp;
+        unsigned int length;
+
+        length = 0;
+        fp = urb->iso_frame_desc;
+        while (ndesc-- != 0) {
+                if (fp->actual_length != 0) {
+                        if (fp->offset + fp->actual_length > length)
+                                length = fp->offset + fp->actual_length;
+                }
+                fp++;
+        }
+        return length;
+}
+
 static void mon_bin_get_isodesc(const struct mon_reader_bin *rp,
     unsigned int offset, struct urb *urb, char ev_type, unsigned int ndesc)
 {
@@ -479,6 +500,10 @@ static void mon_bin_event(struct mon_reader_bin *rp, struct urb *urb,
         /*
          * Find the maximum allowable length, then allocate space.
          */
+        urb_length = (ev_type == 'S') ?
+            urb->transfer_buffer_length : urb->actual_length;
+        length = urb_length;
+
         if (usb_endpoint_xfer_isoc(epd)) {
                 if (urb->number_of_packets < 0) {
                         ndesc = 0;
@@ -487,14 +512,16 @@ static void mon_bin_event(struct mon_reader_bin *rp, struct urb *urb,
                 } else {
                         ndesc = urb->number_of_packets;
                 }
+                if (ev_type == 'C' && usb_urb_dir_in(urb))
+                        length = mon_bin_collate_isodesc(rp, urb, ndesc);
         } else {
                 ndesc = 0;
         }
         lendesc = ndesc*sizeof(struct mon_bin_isodesc);
 
-        urb_length = (ev_type == 'S') ?
-            urb->transfer_buffer_length : urb->actual_length;
-        length = urb_length;
+        /* not an issue unless there's a subtle bug in a HCD somewhere */
+        if (length >= urb->transfer_buffer_length)
+                length = urb->transfer_buffer_length;
 
         if (length >= rp->b_size/5)
                 length = rp->b_size/5;
diff --git a/drivers/usb/mon/mon_main.c b/drivers/usb/mon/mon_main.c
index 812dc288bb8c..10405119985c 100644
--- a/drivers/usb/mon/mon_main.c
+++ b/drivers/usb/mon/mon_main.c
@@ -90,7 +90,6 @@ static void mon_bus_submit(struct mon_bus *mbus, struct urb *urb)
                 r->rnf_submit(r->r_data, urb);
         }
         spin_unlock_irqrestore(&mbus->lock, flags);
-        return;
 }
 
 static void mon_submit(struct usb_bus *ubus, struct urb *urb)
@@ -117,7 +116,6 @@ static void mon_bus_submit_error(struct mon_bus *mbus, struct urb *urb, int erro
                 r->rnf_error(r->r_data, urb, error);
         }
         spin_unlock_irqrestore(&mbus->lock, flags);
-        return;
 }
 
 static void mon_submit_error(struct usb_bus *ubus, struct urb *urb, int error)
diff --git a/drivers/usb/mon/mon_stat.c b/drivers/usb/mon/mon_stat.c
index 8ec94f15a738..e5ce42bd316e 100644
--- a/drivers/usb/mon/mon_stat.c
+++ b/drivers/usb/mon/mon_stat.c
@@ -11,7 +11,6 @@
 #include <linux/slab.h>
 #include <linux/usb.h>
 #include <linux/fs.h>
-#include <linux/smp_lock.h>
 #include <asm/uaccess.h>
 
 #include "usb_mon.h"
diff --git a/drivers/usb/mon/mon_text.c b/drivers/usb/mon/mon_text.c
index a545d65f6e57..c302e1983c70 100644
--- a/drivers/usb/mon/mon_text.c
+++ b/drivers/usb/mon/mon_text.c
@@ -236,6 +236,9 @@ static void mon_text_event(struct mon_reader_text *rp, struct urb *urb,
                         fp++;
                         dp++;
                 }
+                /* Wasteful, but simple to understand: ISO 'C' is sparse. */
+                if (ev_type == 'C')
+                        ep->length = urb->transfer_buffer_length;
         }
 
         ep->setup_flag = mon_text_get_setup(ep, urb, ev_type, rp->r.m_bus);
diff --git a/drivers/usb/musb/Kconfig b/drivers/usb/musb/Kconfig
index cfd38edfcf9e..13093481f918 100644
--- a/drivers/usb/musb/Kconfig
+++ b/drivers/usb/musb/Kconfig
@@ -12,6 +12,7 @@ config USB_MUSB_HDRC
         depends on (ARM || (BF54x && !BF544) || (BF52x && !BF522 && !BF523))
         select NOP_USB_XCEIV if (ARCH_DAVINCI || MACH_OMAP3EVM || BLACKFIN)
         select TWL4030_USB if MACH_OMAP_3430SDP
+        select TWL6030_USB if MACH_OMAP_4430SDP || MACH_OMAP4_PANDA
         select USB_OTG_UTILS
         tristate 'Inventra Highspeed Dual Role Controller (TI, ADI, ...)'
         help
@@ -30,43 +31,41 @@ config USB_MUSB_HDRC
           If you do not know what this is, please say N.
 
           To compile this driver as a module, choose M here; the
-          module will be called "musb_hdrc".
+          module will be called "musb-hdrc".
 
-config USB_MUSB_SOC
-        boolean
+choice
+        prompt "Platform Glue Layer"
         depends on USB_MUSB_HDRC
-        default y if ARCH_DAVINCI
-        default y if ARCH_OMAP2430
-        default y if ARCH_OMAP3
-        default y if ARCH_OMAP4
-        default y if (BF54x && !BF544)
-        default y if (BF52x && !BF522 && !BF523)
 
-comment "DaVinci 35x and 644x USB support"
-        depends on USB_MUSB_HDRC && ARCH_DAVINCI_DMx
+config USB_MUSB_DAVINCI
+        tristate "DaVinci"
+        depends on ARCH_DAVINCI_DMx
 
-comment "OMAP 243x high speed USB support"
-        depends on USB_MUSB_HDRC && ARCH_OMAP2430
+config USB_MUSB_DA8XX
+        tristate "DA8xx/OMAP-L1x"
+        depends on ARCH_DAVINCI_DA8XX
 
-comment "OMAP 343x high speed USB support"
-        depends on USB_MUSB_HDRC && ARCH_OMAP3
+config USB_MUSB_TUSB6010
+        tristate "TUSB6010"
+        depends on ARCH_OMAP
 
-comment "OMAP 44xx high speed USB support"
-        depends on USB_MUSB_HDRC && ARCH_OMAP4
+config USB_MUSB_OMAP2PLUS
+        tristate "OMAP2430 and onwards"
+        depends on ARCH_OMAP2PLUS
 
-comment "Blackfin high speed USB Support"
-        depends on USB_MUSB_HDRC && ((BF54x && !BF544) || (BF52x && !BF522 && !BF523))
+config USB_MUSB_AM35X
+        tristate "AM35x"
+        depends on ARCH_OMAP
 
-config USB_TUSB6010
-        boolean "TUSB 6010 support"
-        depends on USB_MUSB_HDRC && !USB_MUSB_SOC
-        select NOP_USB_XCEIV
-        default y
-        help
-          The TUSB 6010 chip, from Texas Instruments, connects a discrete
-          HDRC core using a 16-bit parallel bus (NOR flash style) or VLYNQ
-          (a high speed serial link).  It can use system-specific external
-          DMA controllers.
+config USB_MUSB_BLACKFIN
+        tristate "Blackfin"
+        depends on (BF54x && !BF544) || (BF52x && ! BF522 && !BF523)
+
+config USB_MUSB_UX500
+        tristate "U8500 and U5500"
+        depends on (ARCH_U8500 && AB8500_USB) || (ARCH_U5500)
+
+endchoice
 
 choice
         prompt "Driver Mode"
@@ -144,7 +143,7 @@ config USB_MUSB_HDRC_HCD
 config MUSB_PIO_ONLY
         bool 'Disable DMA (always use PIO)'
         depends on USB_MUSB_HDRC
-        default y if USB_TUSB6010
+        default USB_MUSB_TUSB6010 || USB_MUSB_DA8XX || USB_MUSB_AM35X
         help
           All data is copied between memory and FIFO by the CPU.
           DMA controllers are ignored.
@@ -154,34 +153,33 @@ config MUSB_PIO_ONLY
           you can still disable it at run time using the "use_dma=n" module
           parameter.
 
+config USB_UX500_DMA
+        bool
+        depends on USB_MUSB_HDRC && !MUSB_PIO_ONLY
+        default USB_MUSB_UX500
+        help
+          Enable DMA transfers on UX500 platforms.
+
 config USB_INVENTRA_DMA
         bool
         depends on USB_MUSB_HDRC && !MUSB_PIO_ONLY
-        default ARCH_OMAP2430 || ARCH_OMAP3 || BLACKFIN || ARCH_OMAP4
+        default USB_MUSB_OMAP2PLUS || USB_MUSB_BLACKFIN
         help
           Enable DMA transfers using Mentor's engine.
 
 config USB_TI_CPPI_DMA
         bool
         depends on USB_MUSB_HDRC && !MUSB_PIO_ONLY
-        default ARCH_DAVINCI
+        default USB_MUSB_DAVINCI
         help
           Enable DMA transfers when TI CPPI DMA is available.
 
 config USB_TUSB_OMAP_DMA
         bool
         depends on USB_MUSB_HDRC && !MUSB_PIO_ONLY
-        depends on USB_TUSB6010
+        depends on USB_MUSB_TUSB6010
         depends on ARCH_OMAP
         default y
         help
           Enable DMA transfers on TUSB 6010 when OMAP DMA is available.
 
-config  USB_MUSB_DEBUG
-        depends on USB_MUSB_HDRC
-        bool "Enable debugging messages"
-        default n
-        help
-          This enables musb debugging. To set the logging level use the debug
-          module parameter. Starting at level 3, per-transfer (urb, usb_request,
-          packet, or dma transfer) tracing may kick in.
diff --git a/drivers/usb/musb/Makefile b/drivers/usb/musb/Makefile
index 9705f716386e..c4d228b6ef8a 100644
--- a/drivers/usb/musb/Makefile
+++ b/drivers/usb/musb/Makefile
@@ -2,49 +2,22 @@
 # for USB OTG silicon based on Mentor Graphics INVENTRA designs
 #
 
-musb_hdrc-objs := musb_core.o
+obj-$(CONFIG_USB_MUSB_HDRC) += musb_hdrc.o
 
-obj-$(CONFIG_USB_MUSB_HDRC)     += musb_hdrc.o
+musb_hdrc-y := musb_core.o
 
-ifeq ($(CONFIG_ARCH_DAVINCI_DMx),y)
-        musb_hdrc-objs  += davinci.o
-endif
-
-ifeq ($(CONFIG_USB_TUSB6010),y)
-        musb_hdrc-objs  += tusb6010.o
-endif
-
-ifeq ($(CONFIG_ARCH_OMAP2430),y)
-        musb_hdrc-objs  += omap2430.o
-endif
-
-ifeq ($(CONFIG_ARCH_OMAP3430),y)
-        musb_hdrc-objs  += omap2430.o
-endif
-
-ifeq ($(CONFIG_ARCH_OMAP4),y)
-        musb_hdrc-objs  += omap2430.o
-endif
-
-ifeq ($(CONFIG_BF54x),y)
-        musb_hdrc-objs  += blackfin.o
-endif
-
-ifeq ($(CONFIG_BF52x),y)
-        musb_hdrc-objs  += blackfin.o
-endif
-
-ifeq ($(CONFIG_USB_GADGET_MUSB_HDRC),y)
-        musb_hdrc-objs          += musb_gadget_ep0.o musb_gadget.o
-endif
+musb_hdrc-$(CONFIG_USB_GADGET_MUSB_HDRC)        += musb_gadget_ep0.o musb_gadget.o
+musb_hdrc-$(CONFIG_USB_MUSB_HDRC_HCD)           += musb_virthub.o musb_host.o
+musb_hdrc-$(CONFIG_DEBUG_FS)                    += musb_debugfs.o
 
-ifeq ($(CONFIG_USB_MUSB_HDRC_HCD),y)
-        musb_hdrc-objs          += musb_virthub.o musb_host.o
-endif
-
-ifeq ($(CONFIG_DEBUG_FS),y)
-        musb_hdrc-objs          += musb_debugfs.o
-endif
+# Hardware Glue Layer
+obj-$(CONFIG_USB_MUSB_OMAP2PLUS)                += omap2430.o
+obj-$(CONFIG_USB_MUSB_AM35X)                    += am35x.o
+obj-$(CONFIG_USB_MUSB_TUSB6010)                 += tusb6010.o
+obj-$(CONFIG_USB_MUSB_DAVINCI)                  += davinci.o
+obj-$(CONFIG_USB_MUSB_DA8XX)                    += da8xx.o
+obj-$(CONFIG_USB_MUSB_BLACKFIN)                 += blackfin.o
+obj-$(CONFIG_USB_MUSB_UX500)                    += ux500.o
 
 # the kconfig must guarantee that only one of the
 # possible I/O schemes will be enabled at a time ...
@@ -54,26 +27,22 @@ endif
 ifneq ($(CONFIG_MUSB_PIO_ONLY),y)
 
   ifeq ($(CONFIG_USB_INVENTRA_DMA),y)
-    musb_hdrc-objs              += musbhsdma.o
+    musb_hdrc-y                 += musbhsdma.o
 
   else
     ifeq ($(CONFIG_USB_TI_CPPI_DMA),y)
-      musb_hdrc-objs            += cppi_dma.o
+      musb_hdrc-y               += cppi_dma.o
 
     else
       ifeq ($(CONFIG_USB_TUSB_OMAP_DMA),y)
-        musb_hdrc-objs          += tusb6010_omap.o
+        musb_hdrc-y             += tusb6010_omap.o
 
+      else
+        ifeq ($(CONFIG_USB_UX500_DMA),y)
+          musb_hdrc-y           += ux500_dma.o
+
+        endif
       endif
     endif
   endif
 endif
-
-
-################################################################################
-
-# Debugging
-
-ifeq ($(CONFIG_USB_MUSB_DEBUG),y)
-        EXTRA_CFLAGS += -DDEBUG
-endif
diff --git a/drivers/usb/musb/am35x.c b/drivers/usb/musb/am35x.c
new file mode 100644
index 000000000000..23ac28f98d91
--- /dev/null
+++ b/drivers/usb/musb/am35x.c
@@ -0,0 +1,657 @@
+/*
+ * Texas Instruments AM35x "glue layer"
+ *
+ * Copyright (c) 2010, by Texas Instruments
+ *
+ * Based on the DA8xx "glue layer" code.
+ * Copyright (c) 2008-2009, MontaVista Software, Inc. <source@mvista.com>
+ *
+ * This file is part of the Inventra Controller Driver for Linux.
+ *
+ * The Inventra Controller Driver for Linux is free software; you
+ * can redistribute it and/or modify it under the terms of the GNU
+ * General Public License version 2 as published by the Free Software
+ * Foundation.
+ *
+ * The Inventra Controller Driver for Linux 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 The Inventra Controller Driver for Linux ; if not,
+ * write to the Free Software Foundation, Inc., 59 Temple Place,
+ * Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+#include <linux/init.h>
+#include <linux/clk.h>
+#include <linux/io.h>
+#include <linux/platform_device.h>
+#include <linux/dma-mapping.h>
+
+#include <plat/usb.h>
+
+#include "musb_core.h"
+
+/*
+ * AM35x specific definitions
+ */
+/* USB 2.0 OTG module registers */
+#define USB_REVISION_REG        0x00
+#define USB_CTRL_REG            0x04
+#define USB_STAT_REG            0x08
+#define USB_EMULATION_REG       0x0c
+/* 0x10 Reserved */
+#define USB_AUTOREQ_REG         0x14
+#define USB_SRP_FIX_TIME_REG    0x18
+#define USB_TEARDOWN_REG        0x1c
+#define EP_INTR_SRC_REG         0x20
+#define EP_INTR_SRC_SET_REG     0x24
+#define EP_INTR_SRC_CLEAR_REG   0x28
+#define EP_INTR_MASK_REG        0x2c
+#define EP_INTR_MASK_SET_REG    0x30
+#define EP_INTR_MASK_CLEAR_REG  0x34
+#define EP_INTR_SRC_MASKED_REG  0x38
+#define CORE_INTR_SRC_REG       0x40
+#define CORE_INTR_SRC_SET_REG   0x44
+#define CORE_INTR_SRC_CLEAR_REG 0x48
+#define CORE_INTR_MASK_REG      0x4c
+#define CORE_INTR_MASK_SET_REG  0x50
+#define CORE_INTR_MASK_CLEAR_REG 0x54
+#define CORE_INTR_SRC_MASKED_REG 0x58
+/* 0x5c Reserved */
+#define USB_END_OF_INTR_REG     0x60
+
+/* Control register bits */
+#define AM35X_SOFT_RESET_MASK   1
+
+/* USB interrupt register bits */
+#define AM35X_INTR_USB_SHIFT    16
+#define AM35X_INTR_USB_MASK     (0x1ff << AM35X_INTR_USB_SHIFT)
+#define AM35X_INTR_DRVVBUS      0x100
+#define AM35X_INTR_RX_SHIFT     16
+#define AM35X_INTR_TX_SHIFT     0
+#define AM35X_TX_EP_MASK        0xffff          /* EP0 + 15 Tx EPs */
+#define AM35X_RX_EP_MASK        0xfffe          /* 15 Rx EPs */
+#define AM35X_TX_INTR_MASK      (AM35X_TX_EP_MASK << AM35X_INTR_TX_SHIFT)
+#define AM35X_RX_INTR_MASK      (AM35X_RX_EP_MASK << AM35X_INTR_RX_SHIFT)
+
+#define USB_MENTOR_CORE_OFFSET  0x400
+
+struct am35x_glue {
+        struct device           *dev;
+        struct platform_device  *musb;
+        struct clk              *phy_clk;
+        struct clk              *clk;
+};
+#define glue_to_musb(g)         platform_get_drvdata(g->musb)
+
+/*
+ * am35x_musb_enable - enable interrupts
+ */
+static void am35x_musb_enable(struct musb *musb)
+{
+        void __iomem *reg_base = musb->ctrl_base;
+        u32 epmask;
+
+        /* Workaround: setup IRQs through both register sets. */
+        epmask = ((musb->epmask & AM35X_TX_EP_MASK) << AM35X_INTR_TX_SHIFT) |
+               ((musb->epmask & AM35X_RX_EP_MASK) << AM35X_INTR_RX_SHIFT);
+
+        musb_writel(reg_base, EP_INTR_MASK_SET_REG, epmask);
+        musb_writel(reg_base, CORE_INTR_MASK_SET_REG, AM35X_INTR_USB_MASK);
+
+        /* Force the DRVVBUS IRQ so we can start polling for ID change. */
+        if (is_otg_enabled(musb))
+                musb_writel(reg_base, CORE_INTR_SRC_SET_REG,
+                            AM35X_INTR_DRVVBUS << AM35X_INTR_USB_SHIFT);
+}
+
+/*
+ * am35x_musb_disable - disable HDRC and flush interrupts
+ */
+static void am35x_musb_disable(struct musb *musb)
+{
+        void __iomem *reg_base = musb->ctrl_base;
+
+        musb_writel(reg_base, CORE_INTR_MASK_CLEAR_REG, AM35X_INTR_USB_MASK);
+        musb_writel(reg_base, EP_INTR_MASK_CLEAR_REG,
+                         AM35X_TX_INTR_MASK | AM35X_RX_INTR_MASK);
+        musb_writeb(musb->mregs, MUSB_DEVCTL, 0);
+        musb_writel(reg_base, USB_END_OF_INTR_REG, 0);
+}
+
+#ifdef CONFIG_USB_MUSB_HDRC_HCD
+#define portstate(stmt)         stmt
+#else
+#define portstate(stmt)
+#endif
+
+static void am35x_musb_set_vbus(struct musb *musb, int is_on)
+{
+        WARN_ON(is_on && is_peripheral_active(musb));
+}
+
+#define POLL_SECONDS    2
+
+static struct timer_list otg_workaround;
+
+static void otg_timer(unsigned long _musb)
+{
+        struct musb             *musb = (void *)_musb;
+        void __iomem            *mregs = musb->mregs;
+        u8                      devctl;
+        unsigned long           flags;
+
+        /*
+         * We poll because AM35x's won't expose several OTG-critical
+         * status change events (from the transceiver) otherwise.
+         */
+        devctl = musb_readb(mregs, MUSB_DEVCTL);
+        dev_dbg(musb->controller, "Poll devctl %02x (%s)\n", devctl,
+                otg_state_string(musb->xceiv->state));
+
+        spin_lock_irqsave(&musb->lock, flags);
+        switch (musb->xceiv->state) {
+        case OTG_STATE_A_WAIT_BCON:
+                devctl &= ~MUSB_DEVCTL_SESSION;
+                musb_writeb(musb->mregs, MUSB_DEVCTL, devctl);
+
+                devctl = musb_readb(musb->mregs, MUSB_DEVCTL);
+                if (devctl & MUSB_DEVCTL_BDEVICE) {
+                        musb->xceiv->state = OTG_STATE_B_IDLE;
+                        MUSB_DEV_MODE(musb);
+                } else {
+                        musb->xceiv->state = OTG_STATE_A_IDLE;
+                        MUSB_HST_MODE(musb);
+                }
+                break;
+        case OTG_STATE_A_WAIT_VFALL:
+                musb->xceiv->state = OTG_STATE_A_WAIT_VRISE;
+                musb_writel(musb->ctrl_base, CORE_INTR_SRC_SET_REG,
+                            MUSB_INTR_VBUSERROR << AM35X_INTR_USB_SHIFT);
+                break;
+        case OTG_STATE_B_IDLE:
+                if (!is_peripheral_enabled(musb))
+                        break;
+
+                devctl = musb_readb(mregs, MUSB_DEVCTL);
+                if (devctl & MUSB_DEVCTL_BDEVICE)
+                        mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);
+                else
+                        musb->xceiv->state = OTG_STATE_A_IDLE;
+                break;
+        default:
+                break;
+        }
+        spin_unlock_irqrestore(&musb->lock, flags);
+}
+
+static void am35x_musb_try_idle(struct musb *musb, unsigned long timeout)
+{
+        static unsigned long last_timer;
+
+        if (!is_otg_enabled(musb))
+                return;
+
+        if (timeout == 0)
+                timeout = jiffies + msecs_to_jiffies(3);
+
+        /* Never idle if active, or when VBUS timeout is not set as host */
+        if (musb->is_active || (musb->a_wait_bcon == 0 &&
+                                musb->xceiv->state == OTG_STATE_A_WAIT_BCON)) {
+                dev_dbg(musb->controller, "%s active, deleting timer\n",
+                        otg_state_string(musb->xceiv->state));
+                del_timer(&otg_workaround);
+                last_timer = jiffies;
+                return;
+        }
+
+        if (time_after(last_timer, timeout) && timer_pending(&otg_workaround)) {
+                dev_dbg(musb->controller, "Longer idle timer already pending, ignoring...\n");
+                return;
+        }
+        last_timer = timeout;
+
+        dev_dbg(musb->controller, "%s inactive, starting idle timer for %u ms\n",
+                otg_state_string(musb->xceiv->state),
+                jiffies_to_msecs(timeout - jiffies));
+        mod_timer(&otg_workaround, timeout);
+}
+
+static irqreturn_t am35x_musb_interrupt(int irq, void *hci)
+{
+        struct musb  *musb = hci;
+        void __iomem *reg_base = musb->ctrl_base;
+        struct device *dev = musb->controller;
+        struct musb_hdrc_platform_data *plat = dev->platform_data;
+        struct omap_musb_board_data *data = plat->board_data;
+        unsigned long flags;
+        irqreturn_t ret = IRQ_NONE;
+        u32 epintr, usbintr;
+
+        spin_lock_irqsave(&musb->lock, flags);
+
+        /* Get endpoint interrupts */
+        epintr = musb_readl(reg_base, EP_INTR_SRC_MASKED_REG);
+
+        if (epintr) {
+                musb_writel(reg_base, EP_INTR_SRC_CLEAR_REG, epintr);
+
+                musb->int_rx =
+                        (epintr & AM35X_RX_INTR_MASK) >> AM35X_INTR_RX_SHIFT;
+                musb->int_tx =
+                        (epintr & AM35X_TX_INTR_MASK) >> AM35X_INTR_TX_SHIFT;
+        }
+
+        /* Get usb core interrupts */
+        usbintr = musb_readl(reg_base, CORE_INTR_SRC_MASKED_REG);
+        if (!usbintr && !epintr)
+                goto eoi;
+
+        if (usbintr) {
+                musb_writel(reg_base, CORE_INTR_SRC_CLEAR_REG, usbintr);
+
+                musb->int_usb =
+                        (usbintr & AM35X_INTR_USB_MASK) >> AM35X_INTR_USB_SHIFT;
+        }
+        /*
+         * DRVVBUS IRQs are the only proxy we have (a very poor one!) for
+         * AM35x's missing ID change IRQ.  We need an ID change IRQ to
+         * switch appropriately between halves of the OTG state machine.
+         * Managing DEVCTL.SESSION per Mentor docs requires that we know its
+         * value but DEVCTL.BDEVICE is invalid without DEVCTL.SESSION set.
+         * Also, DRVVBUS pulses for SRP (but not at 5V) ...
+         */
+        if (usbintr & (AM35X_INTR_DRVVBUS << AM35X_INTR_USB_SHIFT)) {
+                int drvvbus = musb_readl(reg_base, USB_STAT_REG);
+                void __iomem *mregs = musb->mregs;
+                u8 devctl = musb_readb(mregs, MUSB_DEVCTL);
+                int err;
+
+                err = is_host_enabled(musb) && (musb->int_usb &
+                                                MUSB_INTR_VBUSERROR);
+                if (err) {
+                        /*
+                         * The Mentor core doesn't debounce VBUS as needed
+                         * to cope with device connect current spikes. This
+                         * means it's not uncommon for bus-powered devices
+                         * to get VBUS errors during enumeration.
+                         *
+                         * This is a workaround, but newer RTL from Mentor
+                         * seems to allow a better one: "re"-starting sessions
+                         * without waiting for VBUS to stop registering in
+                         * devctl.
+                         */
+                        musb->int_usb &= ~MUSB_INTR_VBUSERROR;
+                        musb->xceiv->state = OTG_STATE_A_WAIT_VFALL;
+                        mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);
+                        WARNING("VBUS error workaround (delay coming)\n");
+                } else if (is_host_enabled(musb) && drvvbus) {
+                        MUSB_HST_MODE(musb);
+                        musb->xceiv->default_a = 1;
+                        musb->xceiv->state = OTG_STATE_A_WAIT_VRISE;
+                        portstate(musb->port1_status |= USB_PORT_STAT_POWER);
+                        del_timer(&otg_workaround);
+                } else {
+                        musb->is_active = 0;
+                        MUSB_DEV_MODE(musb);
+                        musb->xceiv->default_a = 0;
+                        musb->xceiv->state = OTG_STATE_B_IDLE;
+                        portstate(musb->port1_status &= ~USB_PORT_STAT_POWER);
+                }
+
+                /* NOTE: this must complete power-on within 100 ms. */
+                dev_dbg(musb->controller, "VBUS %s (%s)%s, devctl %02x\n",
+                                drvvbus ? "on" : "off",
+                                otg_state_string(musb->xceiv->state),
+                                err ? " ERROR" : "",
+                                devctl);
+                ret = IRQ_HANDLED;
+        }
+
+        if (musb->int_tx || musb->int_rx || musb->int_usb)
+                ret |= musb_interrupt(musb);
+
+eoi:
+        /* EOI needs to be written for the IRQ to be re-asserted. */
+        if (ret == IRQ_HANDLED || epintr || usbintr) {
+                /* clear level interrupt */
+                if (data->clear_irq)
+                        data->clear_irq();
+                /* write EOI */
+                musb_writel(reg_base, USB_END_OF_INTR_REG, 0);
+        }
+
+        /* Poll for ID change */
+        if (is_otg_enabled(musb) && musb->xceiv->state == OTG_STATE_B_IDLE)
+                mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);
+
+        spin_unlock_irqrestore(&musb->lock, flags);
+
+        return ret;
+}
+
+static int am35x_musb_set_mode(struct musb *musb, u8 musb_mode)
+{
+        struct device *dev = musb->controller;
+        struct musb_hdrc_platform_data *plat = dev->platform_data;
+        struct omap_musb_board_data *data = plat->board_data;
+        int     retval = 0;
+
+        if (data->set_mode)
+                data->set_mode(musb_mode);
+        else
+                retval = -EIO;
+
+        return retval;
+}
+
+static int am35x_musb_init(struct musb *musb)
+{
+        struct device *dev = musb->controller;
+        struct musb_hdrc_platform_data *plat = dev->platform_data;
+        struct omap_musb_board_data *data = plat->board_data;
+        void __iomem *reg_base = musb->ctrl_base;
+        u32 rev;
+
+        musb->mregs += USB_MENTOR_CORE_OFFSET;
+
+        /* Returns zero if e.g. not clocked */
+        rev = musb_readl(reg_base, USB_REVISION_REG);
+        if (!rev)
+                return -ENODEV;
+
+        usb_nop_xceiv_register();
+        musb->xceiv = otg_get_transceiver();
+        if (!musb->xceiv)
+                return -ENODEV;
+
+        if (is_host_enabled(musb))
+                setup_timer(&otg_workaround, otg_timer, (unsigned long) musb);
+
+        /* Reset the musb */
+        if (data->reset)
+                data->reset();
+
+        /* Reset the controller */
+        musb_writel(reg_base, USB_CTRL_REG, AM35X_SOFT_RESET_MASK);
+
+        /* Start the on-chip PHY and its PLL. */
+        if (data->set_phy_power)
+                data->set_phy_power(1);
+
+        msleep(5);
+
+        musb->isr = am35x_musb_interrupt;
+
+        /* clear level interrupt */
+        if (data->clear_irq)
+                data->clear_irq();
+
+        return 0;
+}
+
+static int am35x_musb_exit(struct musb *musb)
+{
+        struct device *dev = musb->controller;
+        struct musb_hdrc_platform_data *plat = dev->platform_data;
+        struct omap_musb_board_data *data = plat->board_data;
+
+        if (is_host_enabled(musb))
+                del_timer_sync(&otg_workaround);
+
+        /* Shutdown the on-chip PHY and its PLL. */
+        if (data->set_phy_power)
+                data->set_phy_power(0);
+
+        otg_put_transceiver(musb->xceiv);
+        usb_nop_xceiv_unregister();
+
+        return 0;
+}
+
+/* AM35x supports only 32bit read operation */
+void musb_read_fifo(struct musb_hw_ep *hw_ep, u16 len, u8 *dst)
+{
+        void __iomem *fifo = hw_ep->fifo;
+        u32             val;
+        int             i;
+
+        /* Read for 32bit-aligned destination address */
+        if (likely((0x03 & (unsigned long) dst) == 0) && len >= 4) {
+                readsl(fifo, dst, len >> 2);
+                dst += len & ~0x03;
+                len &= 0x03;
+        }
+        /*
+         * Now read the remaining 1 to 3 byte or complete length if
+         * unaligned address.
+         */
+        if (len > 4) {
+                for (i = 0; i < (len >> 2); i++) {
+                        *(u32 *) dst = musb_readl(fifo, 0);
+                        dst += 4;
+                }
+                len &= 0x03;
+        }
+        if (len > 0) {
+                val = musb_readl(fifo, 0);
+                memcpy(dst, &val, len);
+        }
+}
+
+static const struct musb_platform_ops am35x_ops = {
+        .init           = am35x_musb_init,
+        .exit           = am35x_musb_exit,
+
+        .enable         = am35x_musb_enable,
+        .disable        = am35x_musb_disable,
+
+        .set_mode       = am35x_musb_set_mode,
+        .try_idle       = am35x_musb_try_idle,
+
+        .set_vbus       = am35x_musb_set_vbus,
+};
+
+static u64 am35x_dmamask = DMA_BIT_MASK(32);
+
+static int __init am35x_probe(struct platform_device *pdev)
+{
+        struct musb_hdrc_platform_data  *pdata = pdev->dev.platform_data;
+        struct platform_device          *musb;
+        struct am35x_glue               *glue;
+
+        struct clk                      *phy_clk;
+        struct clk                      *clk;
+
+        int                             ret = -ENOMEM;
+
+        glue = kzalloc(sizeof(*glue), GFP_KERNEL);
+        if (!glue) {
+                dev_err(&pdev->dev, "failed to allocate glue context\n");
+                goto err0;
+        }
+
+        musb = platform_device_alloc("musb-hdrc", -1);
+        if (!musb) {
+                dev_err(&pdev->dev, "failed to allocate musb device\n");
+                goto err1;
+        }
+
+        phy_clk = clk_get(&pdev->dev, "fck");
+        if (IS_ERR(phy_clk)) {
+                dev_err(&pdev->dev, "failed to get PHY clock\n");
+                ret = PTR_ERR(phy_clk);
+                goto err2;
+        }
+
+        clk = clk_get(&pdev->dev, "ick");
+        if (IS_ERR(clk)) {
+                dev_err(&pdev->dev, "failed to get clock\n");
+                ret = PTR_ERR(clk);
+                goto err3;
+        }
+
+        ret = clk_enable(phy_clk);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to enable PHY clock\n");
+                goto err4;
+        }
+
+        ret = clk_enable(clk);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to enable clock\n");
+                goto err5;
+        }
+
+        musb->dev.parent                = &pdev->dev;
+        musb->dev.dma_mask              = &am35x_dmamask;
+        musb->dev.coherent_dma_mask     = am35x_dmamask;
+
+        glue->dev                       = &pdev->dev;
+        glue->musb                      = musb;
+        glue->phy_clk                   = phy_clk;
+        glue->clk                       = clk;
+
+        pdata->platform_ops             = &am35x_ops;
+
+        platform_set_drvdata(pdev, glue);
+
+        ret = platform_device_add_resources(musb, pdev->resource,
+                        pdev->num_resources);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to add resources\n");
+                goto err6;
+        }
+
+        ret = platform_device_add_data(musb, pdata, sizeof(*pdata));
+        if (ret) {
+                dev_err(&pdev->dev, "failed to add platform_data\n");
+                goto err6;
+        }
+
+        ret = platform_device_add(musb);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to register musb device\n");
+                goto err6;
+        }
+
+        return 0;
+
+err6:
+        clk_disable(clk);
+
+err5:
+        clk_disable(phy_clk);
+
+err4:
+        clk_put(clk);
+
+err3:
+        clk_put(phy_clk);
+
+err2:
+        platform_device_put(musb);
+
+err1:
+        kfree(glue);
+
+err0:
+        return ret;
+}
+
+static int __exit am35x_remove(struct platform_device *pdev)
+{
+        struct am35x_glue       *glue = platform_get_drvdata(pdev);
+
+        platform_device_del(glue->musb);
+        platform_device_put(glue->musb);
+        clk_disable(glue->clk);
+        clk_disable(glue->phy_clk);
+        clk_put(glue->clk);
+        clk_put(glue->phy_clk);
+        kfree(glue);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int am35x_suspend(struct device *dev)
+{
+        struct am35x_glue       *glue = dev_get_drvdata(dev);
+        struct musb_hdrc_platform_data *plat = dev->platform_data;
+        struct omap_musb_board_data *data = plat->board_data;
+
+        /* Shutdown the on-chip PHY and its PLL. */
+        if (data->set_phy_power)
+                data->set_phy_power(0);
+
+        clk_disable(glue->phy_clk);
+        clk_disable(glue->clk);
+
+        return 0;
+}
+
+static int am35x_resume(struct device *dev)
+{
+        struct am35x_glue       *glue = dev_get_drvdata(dev);
+        struct musb_hdrc_platform_data *plat = dev->platform_data;
+        struct omap_musb_board_data *data = plat->board_data;
+        int                     ret;
+
+        /* Start the on-chip PHY and its PLL. */
+        if (data->set_phy_power)
+                data->set_phy_power(1);
+
+        ret = clk_enable(glue->phy_clk);
+        if (ret) {
+                dev_err(dev, "failed to enable PHY clock\n");
+                return ret;
+        }
+
+        ret = clk_enable(glue->clk);
+        if (ret) {
+                dev_err(dev, "failed to enable clock\n");
+                return ret;
+        }
+
+        return 0;
+}
+
+static struct dev_pm_ops am35x_pm_ops = {
+        .suspend        = am35x_suspend,
+        .resume         = am35x_resume,
+};
+
+#define DEV_PM_OPS      &am35x_pm_ops
+#else
+#define DEV_PM_OPS      NULL
+#endif
+
+static struct platform_driver am35x_driver = {
+        .remove         = __exit_p(am35x_remove),
+        .driver         = {
+                .name   = "musb-am35x",
+                .pm     = DEV_PM_OPS,
+        },
+};
+
+MODULE_DESCRIPTION("AM35x MUSB Glue Layer");
+MODULE_AUTHOR("Ajay Kumar Gupta <ajay.gupta@ti.com>");
+MODULE_LICENSE("GPL v2");
+
+static int __init am35x_init(void)
+{
+        return platform_driver_probe(&am35x_driver, am35x_probe);
+}
+subsys_initcall(am35x_init);
+
+static void __exit am35x_exit(void)
+{
+        platform_driver_unregister(&am35x_driver);
+}
+module_exit(am35x_exit);
diff --git a/drivers/usb/musb/blackfin.c b/drivers/usb/musb/blackfin.c
index b611420a8050..ae8c39617743 100644
--- a/drivers/usb/musb/blackfin.c
+++ b/drivers/usb/musb/blackfin.c
@@ -15,17 +15,27 @@
 #include <linux/list.h>
 #include <linux/gpio.h>
 #include <linux/io.h>
+#include <linux/platform_device.h>
+#include <linux/dma-mapping.h>
 
 #include <asm/cacheflush.h>
 
 #include "musb_core.h"
+#include "musbhsdma.h"
 #include "blackfin.h"
 
+struct bfin_glue {
+        struct device           *dev;
+        struct platform_device  *musb;
+};
+#define glue_to_musb(g)         platform_get_drvdata(g->musb)
+
 /*
  * Load an endpoint's FIFO
  */
 void musb_write_fifo(struct musb_hw_ep *hw_ep, u16 len, const u8 *src)
 {
+        struct musb *musb = hw_ep->musb;
         void __iomem *fifo = hw_ep->fifo;
         void __iomem *epio = hw_ep->regs;
         u8 epnum = hw_ep->epnum;
@@ -34,7 +44,7 @@ void musb_write_fifo(struct musb_hw_ep *hw_ep, u16 len, const u8 *src)
 
         musb_writew(epio, MUSB_TXCOUNT, len);
 
-        DBG(4, "TX ep%d fifo %p count %d buf %p, epio %p\n",
+        dev_dbg(musb->controller, "TX ep%d fifo %p count %d buf %p, epio %p\n",
                         hw_ep->epnum, fifo, len, src, epio);
 
         dump_fifo_data(src, len);
@@ -89,6 +99,7 @@ void musb_write_fifo(struct musb_hw_ep *hw_ep, u16 len, const u8 *src)
  */
 void musb_read_fifo(struct musb_hw_ep *hw_ep, u16 len, u8 *dst)
 {
+        struct musb *musb = hw_ep->musb;
         void __iomem *fifo = hw_ep->fifo;
         u8 epnum = hw_ep->epnum;
 
@@ -145,7 +156,7 @@ void musb_read_fifo(struct musb_hw_ep *hw_ep, u16 len, u8 *dst)
                                 *(dst + len - 1) = (u8)inw((unsigned long)fifo + 4);
                 }
         }
-        DBG(4, "%cX ep%d fifo %p count %d buf %p\n",
+        dev_dbg(musb->controller, "%cX ep%d fifo %p count %d buf %p\n",
                         'R', hw_ep->epnum, fifo, len, dst);
 
         dump_fifo_data(dst, len);
@@ -171,8 +182,9 @@ static irqreturn_t blackfin_interrupt(int irq, void *__hci)
         }
 
         /* Start sampling ID pin, when plug is removed from MUSB */
-        if (is_otg_enabled(musb) && (musb->xceiv->state == OTG_STATE_B_IDLE
-                || musb->xceiv->state == OTG_STATE_A_WAIT_BCON)) {
+        if ((is_otg_enabled(musb) && (musb->xceiv->state == OTG_STATE_B_IDLE
+                || musb->xceiv->state == OTG_STATE_A_WAIT_BCON)) ||
+                (musb->int_usb & MUSB_INTR_DISCONNECT && is_host_active(musb))) {
                 mod_timer(&musb_conn_timer, jiffies + TIMER_DELAY);
                 musb->a_wait_bcon = TIMER_DELAY;
         }
@@ -269,15 +281,17 @@ static void musb_conn_timer_handler(unsigned long _musb)
                 }
                 break;
         default:
-                DBG(1, "%s state not handled\n", otg_state_string(musb));
+                dev_dbg(musb->controller, "%s state not handled\n",
+                        otg_state_string(musb->xceiv->state));
                 break;
         }
         spin_unlock_irqrestore(&musb->lock, flags);
 
-        DBG(4, "state is %s\n", otg_state_string(musb));
+        dev_dbg(musb->controller, "state is %s\n",
+                otg_state_string(musb->xceiv->state));
 }
 
-void musb_platform_enable(struct musb *musb)
+static void bfin_musb_enable(struct musb *musb)
 {
         if (!is_otg_enabled(musb) && is_host_enabled(musb)) {
                 mod_timer(&musb_conn_timer, jiffies + TIMER_DELAY);
@@ -285,66 +299,67 @@ void musb_platform_enable(struct musb *musb)
         }
 }
 
-void musb_platform_disable(struct musb *musb)
+static void bfin_musb_disable(struct musb *musb)
 {
 }
 
-static void bfin_set_vbus(struct musb *musb, int is_on)
+static void bfin_musb_set_vbus(struct musb *musb, int is_on)
 {
         int value = musb->config->gpio_vrsel_active;
         if (!is_on)
                 value = !value;
         gpio_set_value(musb->config->gpio_vrsel, value);
 
-        DBG(1, "VBUS %s, devctl %02x "
+        dev_dbg(musb->controller, "VBUS %s, devctl %02x "
                 /* otg %3x conf %08x prcm %08x */ "\n",
-                otg_state_string(musb),
+                otg_state_string(musb->xceiv->state),
                 musb_readb(musb->mregs, MUSB_DEVCTL));
 }
 
-static int bfin_set_power(struct otg_transceiver *x, unsigned mA)
+static int bfin_musb_set_power(struct otg_transceiver *x, unsigned mA)
 {
         return 0;
 }
 
-void musb_platform_try_idle(struct musb *musb, unsigned long timeout)
+static void bfin_musb_try_idle(struct musb *musb, unsigned long timeout)
 {
         if (!is_otg_enabled(musb) && is_host_enabled(musb))
                 mod_timer(&musb_conn_timer, jiffies + TIMER_DELAY);
 }
 
-int musb_platform_get_vbus_status(struct musb *musb)
+static int bfin_musb_vbus_status(struct musb *musb)
 {
         return 0;
 }
 
-int musb_platform_set_mode(struct musb *musb, u8 musb_mode)
+static int bfin_musb_set_mode(struct musb *musb, u8 musb_mode)
 {
         return -EIO;
 }
 
-int __init musb_platform_init(struct musb *musb, void *board_data)
+static int bfin_musb_adjust_channel_params(struct dma_channel *channel,
+                                u16 packet_sz, u8 *mode,
+                                dma_addr_t *dma_addr, u32 *len)
 {
+        struct musb_dma_channel *musb_channel = channel->private_data;
 
         /*
-         * Rev 1.0 BF549 EZ-KITs require PE7 to be high for both DEVICE
-         * and OTG HOST modes, while rev 1.1 and greater require PE7 to
-         * be low for DEVICE mode and high for HOST mode. We set it high
-         * here because we are in host mode
+         * Anomaly 05000450 might cause data corruption when using DMA
+         * MODE 1 transmits with short packet.  So to work around this,
+         * we truncate all MODE 1 transfers down to a multiple of the
+         * max packet size, and then do the last short packet transfer
+         * (if there is any) using MODE 0.
          */
-
-        if (gpio_request(musb->config->gpio_vrsel, "USB_VRSEL")) {
-                printk(KERN_ERR "Failed ro request USB_VRSEL GPIO_%d \n",
-                        musb->config->gpio_vrsel);
-                return -ENODEV;
+        if (ANOMALY_05000450) {
+                if (musb_channel->transmit && *mode == 1)
+                        *len = *len - (*len % packet_sz);
         }
-        gpio_direction_output(musb->config->gpio_vrsel, 0);
 
-        usb_nop_xceiv_register();
-        musb->xceiv = otg_get_transceiver();
-        if (!musb->xceiv)
-                return -ENODEV;
+        return 0;
+}
 
+static void bfin_musb_reg_init(struct musb *musb)
+{
         if (ANOMALY_05000346) {
                 bfin_write_USB_APHY_CALIB(ANOMALY_05000346_value);
                 SSYNC();
@@ -356,7 +371,8 @@ int __init musb_platform_init(struct musb *musb, void *board_data)
         }
 
         /* Configure PLL oscillator register */
-        bfin_write_USB_PLLOSC_CTRL(0x30a8);
+        bfin_write_USB_PLLOSC_CTRL(0x3080 |
+                        ((480/musb->config->clkin) << 1));
         SSYNC();
 
         bfin_write_USB_SRP_CLKDIV((get_sclk()/1000) / 32 - 1);
@@ -378,24 +394,205 @@ int __init musb_platform_init(struct musb *musb, void *board_data)
                                 EP2_RX_ENA | EP3_RX_ENA | EP4_RX_ENA |
                                 EP5_RX_ENA | EP6_RX_ENA | EP7_RX_ENA);
         SSYNC();
+}
+
+static int bfin_musb_init(struct musb *musb)
+{
+
+        /*
+         * Rev 1.0 BF549 EZ-KITs require PE7 to be high for both DEVICE
+         * and OTG HOST modes, while rev 1.1 and greater require PE7 to
+         * be low for DEVICE mode and high for HOST mode. We set it high
+         * here because we are in host mode
+         */
+
+        if (gpio_request(musb->config->gpio_vrsel, "USB_VRSEL")) {
+                printk(KERN_ERR "Failed ro request USB_VRSEL GPIO_%d\n",
+                        musb->config->gpio_vrsel);
+                return -ENODEV;
+        }
+        gpio_direction_output(musb->config->gpio_vrsel, 0);
+
+        usb_nop_xceiv_register();
+        musb->xceiv = otg_get_transceiver();
+        if (!musb->xceiv) {
+                gpio_free(musb->config->gpio_vrsel);
+                return -ENODEV;
+        }
+
+        bfin_musb_reg_init(musb);
 
         if (is_host_enabled(musb)) {
-                musb->board_set_vbus = bfin_set_vbus;
                 setup_timer(&musb_conn_timer,
                         musb_conn_timer_handler, (unsigned long) musb);
         }
         if (is_peripheral_enabled(musb))
-                musb->xceiv->set_power = bfin_set_power;
+                musb->xceiv->set_power = bfin_musb_set_power;
 
         musb->isr = blackfin_interrupt;
+        musb->double_buffer_not_ok = true;
 
         return 0;
 }
 
-int musb_platform_exit(struct musb *musb)
+static int bfin_musb_exit(struct musb *musb)
 {
-
         gpio_free(musb->config->gpio_vrsel);
 
+        otg_put_transceiver(musb->xceiv);
+        usb_nop_xceiv_unregister();
+        return 0;
+}
+
+static const struct musb_platform_ops bfin_ops = {
+        .init           = bfin_musb_init,
+        .exit           = bfin_musb_exit,
+
+        .enable         = bfin_musb_enable,
+        .disable        = bfin_musb_disable,
+
+        .set_mode       = bfin_musb_set_mode,
+        .try_idle       = bfin_musb_try_idle,
+
+        .vbus_status    = bfin_musb_vbus_status,
+        .set_vbus       = bfin_musb_set_vbus,
+
+        .adjust_channel_params = bfin_musb_adjust_channel_params,
+};
+
+static u64 bfin_dmamask = DMA_BIT_MASK(32);
+
+static int __init bfin_probe(struct platform_device *pdev)
+{
+        struct musb_hdrc_platform_data  *pdata = pdev->dev.platform_data;
+        struct platform_device          *musb;
+        struct bfin_glue                *glue;
+
+        int                             ret = -ENOMEM;
+
+        glue = kzalloc(sizeof(*glue), GFP_KERNEL);
+        if (!glue) {
+                dev_err(&pdev->dev, "failed to allocate glue context\n");
+                goto err0;
+        }
+
+        musb = platform_device_alloc("musb-hdrc", -1);
+        if (!musb) {
+                dev_err(&pdev->dev, "failed to allocate musb device\n");
+                goto err1;
+        }
+
+        musb->dev.parent                = &pdev->dev;
+        musb->dev.dma_mask              = &bfin_dmamask;
+        musb->dev.coherent_dma_mask     = bfin_dmamask;
+
+        glue->dev                       = &pdev->dev;
+        glue->musb                      = musb;
+
+        pdata->platform_ops             = &bfin_ops;
+
+        platform_set_drvdata(pdev, glue);
+
+        ret = platform_device_add_resources(musb, pdev->resource,
+                        pdev->num_resources);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to add resources\n");
+                goto err2;
+        }
+
+        ret = platform_device_add_data(musb, pdata, sizeof(*pdata));
+        if (ret) {
+                dev_err(&pdev->dev, "failed to add platform_data\n");
+                goto err2;
+        }
+
+        ret = platform_device_add(musb);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to register musb device\n");
+                goto err2;
+        }
+
+        return 0;
+
+err2:
+        platform_device_put(musb);
+
+err1:
+        kfree(glue);
+
+err0:
+        return ret;
+}
+
+static int __exit bfin_remove(struct platform_device *pdev)
+{
+        struct bfin_glue                *glue = platform_get_drvdata(pdev);
+
+        platform_device_del(glue->musb);
+        platform_device_put(glue->musb);
+        kfree(glue);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int bfin_suspend(struct device *dev)
+{
+        struct bfin_glue        *glue = dev_get_drvdata(dev);
+        struct musb             *musb = glue_to_musb(glue);
+
+        if (is_host_active(musb))
+                /*
+                 * During hibernate gpio_vrsel will change from high to low
+                 * low which will generate wakeup event resume the system
+                 * immediately.  Set it to 0 before hibernate to avoid this
+                 * wakeup event.
+                 */
+                gpio_set_value(musb->config->gpio_vrsel, 0);
+
         return 0;
 }
+
+static int bfin_resume(struct device *dev)
+{
+        struct bfin_glue        *glue = dev_get_drvdata(dev);
+        struct musb             *musb = glue_to_musb(glue);
+
+        bfin_musb_reg_init(musb);
+
+        return 0;
+}
+
+static struct dev_pm_ops bfin_pm_ops = {
+        .suspend        = bfin_suspend,
+        .resume         = bfin_resume,
+};
+
+#define DEV_PM_OPS      &bfin_pm_ops
+#else
+#define DEV_PM_OPS      NULL
+#endif
+
+static struct platform_driver bfin_driver = {
+        .remove         = __exit_p(bfin_remove),
+        .driver         = {
+                .name   = "musb-blackfin",
+                .pm     = DEV_PM_OPS,
+        },
+};
+
+MODULE_DESCRIPTION("Blackfin MUSB Glue Layer");
+MODULE_AUTHOR("Bryan Wy <cooloney@kernel.org>");
+MODULE_LICENSE("GPL v2");
+
+static int __init bfin_init(void)
+{
+        return platform_driver_probe(&bfin_driver, bfin_probe);
+}
+subsys_initcall(bfin_init);
+
+static void __exit bfin_exit(void)
+{
+        platform_driver_unregister(&bfin_driver);
+}
+module_exit(bfin_exit);
diff --git a/drivers/usb/musb/cppi_dma.c b/drivers/usb/musb/cppi_dma.c
index 5ab5bb89bae3..149f3f310a0a 100644
--- a/drivers/usb/musb/cppi_dma.c
+++ b/drivers/usb/musb/cppi_dma.c
@@ -236,7 +236,7 @@ static int cppi_controller_stop(struct dma_controller *c)
         musb_writel(tibase, DAVINCI_RXCPPI_INTCLR_REG,
                         DAVINCI_DMA_ALL_CHANNELS_ENABLE);
 
-        DBG(1, "Tearing down RX and TX Channels\n");
+        dev_dbg(musb->controller, "Tearing down RX and TX Channels\n");
         for (i = 0; i < ARRAY_SIZE(controller->tx); i++) {
                 /* FIXME restructure of txdma to use bds like rxdma */
                 controller->tx[i].last_processed = NULL;
@@ -301,13 +301,13 @@ cppi_channel_allocate(struct dma_controller *c,
          */
         if (transmit) {
                 if (index >= ARRAY_SIZE(controller->tx)) {
-                        DBG(1, "no %cX%d CPPI channel\n", 'T', index);
+                        dev_dbg(musb->controller, "no %cX%d CPPI channel\n", 'T', index);
                         return NULL;
                 }
                 cppi_ch = controller->tx + index;
         } else {
                 if (index >= ARRAY_SIZE(controller->rx)) {
-                        DBG(1, "no %cX%d CPPI channel\n", 'R', index);
+                        dev_dbg(musb->controller, "no %cX%d CPPI channel\n", 'R', index);
                         return NULL;
                 }
                 cppi_ch = controller->rx + index;
@@ -318,13 +318,13 @@ cppi_channel_allocate(struct dma_controller *c,
          * with the other DMA engine too
          */
         if (cppi_ch->hw_ep)
-                DBG(1, "re-allocating DMA%d %cX channel %p\n",
+                dev_dbg(musb->controller, "re-allocating DMA%d %cX channel %p\n",
                                 index, transmit ? 'T' : 'R', cppi_ch);
         cppi_ch->hw_ep = ep;
         cppi_ch->channel.status = MUSB_DMA_STATUS_FREE;
         cppi_ch->channel.max_len = 0x7fffffff;
 
-        DBG(4, "Allocate CPPI%d %cX\n", index, transmit ? 'T' : 'R');
+        dev_dbg(musb->controller, "Allocate CPPI%d %cX\n", index, transmit ? 'T' : 'R');
         return &cppi_ch->channel;
 }
 
@@ -339,7 +339,7 @@ static void cppi_channel_release(struct dma_channel *channel)
         c = container_of(channel, struct cppi_channel, channel);
         tibase = c->controller->tibase;
         if (!c->hw_ep)
-                DBG(1, "releasing idle DMA channel %p\n", c);
+                dev_dbg(musb->controller, "releasing idle DMA channel %p\n", c);
         else if (!c->transmit)
                 core_rxirq_enable(tibase, c->index + 1);
 
@@ -597,12 +597,12 @@ cppi_next_tx_segment(struct musb *musb, struct cppi_channel *tx)
                 length = min(n_bds * maxpacket, length);
         }
 
-        DBG(4, "TX DMA%d, pktSz %d %s bds %d dma 0x%x len %u\n",
+        dev_dbg(musb->controller, "TX DMA%d, pktSz %d %s bds %d dma 0x%llx len %u\n",
                         tx->index,
                         maxpacket,
                         rndis ? "rndis" : "transparent",
                         n_bds,
-                        addr, length);
+                        (unsigned long long)addr, length);
 
         cppi_rndis_update(tx, 0, musb->ctrl_base, rndis);
 
@@ -654,7 +654,7 @@ cppi_next_tx_segment(struct musb *musb, struct cppi_channel *tx)
                                 bd->hw_options |= CPPI_ZERO_SET;
                 }
 
-                DBG(5, "TXBD %p: nxt %08x buf %08x len %04x opt %08x\n",
+                dev_dbg(musb->controller, "TXBD %p: nxt %08x buf %08x len %04x opt %08x\n",
                                 bd, bd->hw_next, bd->hw_bufp,
                                 bd->hw_off_len, bd->hw_options);
 
@@ -819,8 +819,8 @@ cppi_next_rx_segment(struct musb *musb, struct cppi_channel *rx, int onepacket)
 
         length = min(n_bds * maxpacket, length);
 
-        DBG(4, "RX DMA%d seg, maxp %d %s bds %d (cnt %d) "
-                        "dma 0x%x len %u %u/%u\n",
+        dev_dbg(musb->controller, "RX DMA%d seg, maxp %d %s bds %d (cnt %d) "
+                        "dma 0x%llx len %u %u/%u\n",
                         rx->index, maxpacket,
                         onepacket
                                 ? (is_rndis ? "rndis" : "onepacket")
@@ -829,7 +829,8 @@ cppi_next_rx_segment(struct musb *musb, struct cppi_channel *rx, int onepacket)
                         musb_readl(tibase,
                                 DAVINCI_RXCPPI_BUFCNT0_REG + (rx->index * 4))
                                         & 0xffff,
-                        addr, length, rx->channel.actual_len, rx->buf_len);
+                        (unsigned long long)addr, length,
+                        rx->channel.actual_len, rx->buf_len);
 
         /* only queue one segment at a time, since the hardware prevents
          * correct queue shutdown after unexpected short packets
@@ -935,7 +936,7 @@ cppi_next_rx_segment(struct musb *musb, struct cppi_channel *rx, int onepacket)
                         DAVINCI_RXCPPI_BUFCNT0_REG + (rx->index * 4))
                         & 0xffff;
         if (i < (2 + n_bds)) {
-                DBG(2, "bufcnt%d underrun - %d (for %d)\n",
+                dev_dbg(musb->controller, "bufcnt%d underrun - %d (for %d)\n",
                                         rx->index, i, n_bds);
                 musb_writel(tibase,
                         DAVINCI_RXCPPI_BUFCNT0_REG + (rx->index * 4),
@@ -984,7 +985,7 @@ static int cppi_channel_program(struct dma_channel *ch,
                 /* WARN_ON(1); */
                 break;
         case MUSB_DMA_STATUS_UNKNOWN:
-                DBG(1, "%cX DMA%d not allocated!\n",
+                dev_dbg(musb->controller, "%cX DMA%d not allocated!\n",
                                 cppi_ch->transmit ? 'T' : 'R',
                                 cppi_ch->index);
                 /* FALLTHROUGH */
@@ -1039,9 +1040,9 @@ static bool cppi_rx_scan(struct cppi *cppi, unsigned ch)
                 if (!completed && (bd->hw_options & CPPI_OWN_SET))
                         break;
 
-                DBG(5, "C/RXBD %08x: nxt %08x buf %08x "
+                dev_dbg(musb->controller, "C/RXBD %llx: nxt %08x buf %08x "
                         "off.len %08x opt.len %08x (%d)\n",
-                        bd->dma, bd->hw_next, bd->hw_bufp,
+                        (unsigned long long)bd->dma, bd->hw_next, bd->hw_bufp,
                         bd->hw_off_len, bd->hw_options,
                         rx->channel.actual_len);
 
@@ -1061,7 +1062,7 @@ static bool cppi_rx_scan(struct cppi *cppi, unsigned ch)
                          * CPPI ignores those BDs even though OWN is still set.
                          */
                         completed = true;
-                        DBG(3, "rx short %d/%d (%d)\n",
+                        dev_dbg(musb->controller, "rx short %d/%d (%d)\n",
                                         len, bd->buflen,
                                         rx->channel.actual_len);
                 }
@@ -1111,11 +1112,12 @@ static bool cppi_rx_scan(struct cppi *cppi, unsigned ch)
                 musb_ep_select(cppi->mregs, rx->index + 1);
                 csr = musb_readw(regs, MUSB_RXCSR);
                 if (csr & MUSB_RXCSR_DMAENAB) {
-                        DBG(4, "list%d %p/%p, last %08x%s, csr %04x\n",
+                        dev_dbg(musb->controller, "list%d %p/%p, last %llx%s, csr %04x\n",
                                 rx->index,
                                 rx->head, rx->tail,
                                 rx->last_processed
-                                        ? rx->last_processed->dma
+                                        ? (unsigned long long)
+                                                rx->last_processed->dma
                                         : 0,
                                 completed ? ", completed" : "",
                                 csr);
@@ -1156,7 +1158,7 @@ irqreturn_t cppi_interrupt(int irq, void *dev_id)
         struct musb_hw_ep       *hw_ep = NULL;
         u32                     rx, tx;
         int                     i, index;
-        unsigned long           flags;
+        unsigned long           uninitialized_var(flags);
 
         cppi = container_of(musb->dma_controller, struct cppi, controller);
         if (cppi->irq)
@@ -1167,10 +1169,13 @@ irqreturn_t cppi_interrupt(int irq, void *dev_id)
         tx = musb_readl(tibase, DAVINCI_TXCPPI_MASKED_REG);
         rx = musb_readl(tibase, DAVINCI_RXCPPI_MASKED_REG);
 
-        if (!tx && !rx)
+        if (!tx && !rx) {
+                if (cppi->irq)
+                        spin_unlock_irqrestore(&musb->lock, flags);
                 return IRQ_NONE;
+        }
 
-        DBG(4, "CPPI IRQ Tx%x Rx%x\n", tx, rx);
+        dev_dbg(musb->controller, "CPPI IRQ Tx%x Rx%x\n", tx, rx);
 
         /* process TX channels */
         for (index = 0; tx; tx = tx >> 1, index++) {
@@ -1198,8 +1203,8 @@ irqreturn_t cppi_interrupt(int irq, void *dev_id)
                  * that needs to be acknowledged.
                  */
                 if (NULL == bd) {
-                        DBG(1, "null BD\n");
-                        tx_ram->tx_complete = 0;
+                        dev_dbg(musb->controller, "null BD\n");
+                        musb_writel(&tx_ram->tx_complete, 0, 0);
                         continue;
                 }
 
@@ -1213,7 +1218,7 @@ irqreturn_t cppi_interrupt(int irq, void *dev_id)
                         if (bd->hw_options & CPPI_OWN_SET)
                                 break;
 
-                        DBG(5, "C/TXBD %p n %x b %x off %x opt %x\n",
+                        dev_dbg(musb->controller, "C/TXBD %p n %x b %x off %x opt %x\n",
                                         bd, bd->hw_next, bd->hw_bufp,
                                         bd->hw_off_len, bd->hw_options);
 
@@ -1308,7 +1313,7 @@ dma_controller_create(struct musb *musb, void __iomem *mregs)
         struct cppi             *controller;
         struct device           *dev = musb->controller;
         struct platform_device  *pdev = to_platform_device(dev);
-        int                     irq = platform_get_irq(pdev, 1);
+        int                     irq = platform_get_irq_byname(pdev, "dma");
 
         controller = kzalloc(sizeof *controller, GFP_KERNEL);
         if (!controller)
@@ -1452,7 +1457,7 @@ static int cppi_channel_abort(struct dma_channel *channel)
                  *    compare mode by writing 1 to the tx_complete register.
                  */
                 cppi_reset_tx(tx_ram, 1);
-                cppi_ch->head = 0;
+                cppi_ch->head = NULL;
                 musb_writel(&tx_ram->tx_complete, 0, 1);
                 cppi_dump_tx(5, cppi_ch, " (done teardown)");
 
diff --git a/drivers/usb/musb/da8xx.c b/drivers/usb/musb/da8xx.c
new file mode 100644
index 000000000000..662ed34980bd
--- /dev/null
+++ b/drivers/usb/musb/da8xx.c
@@ -0,0 +1,608 @@
+/*
+ * Texas Instruments DA8xx/OMAP-L1x "glue layer"
+ *
+ * Copyright (c) 2008-2009 MontaVista Software, Inc. <source@mvista.com>
+ *
+ * Based on the DaVinci "glue layer" code.
+ * Copyright (C) 2005-2006 by Texas Instruments
+ *
+ * This file is part of the Inventra Controller Driver for Linux.
+ *
+ * The Inventra Controller Driver for Linux is free software; you
+ * can redistribute it and/or modify it under the terms of the GNU
+ * General Public License version 2 as published by the Free Software
+ * Foundation.
+ *
+ * The Inventra Controller Driver for Linux 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 The Inventra Controller Driver for Linux ; if not,
+ * write to the Free Software Foundation, Inc., 59 Temple Place,
+ * Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+#include <linux/init.h>
+#include <linux/clk.h>
+#include <linux/io.h>
+#include <linux/platform_device.h>
+#include <linux/dma-mapping.h>
+
+#include <mach/da8xx.h>
+#include <mach/usb.h>
+
+#include "musb_core.h"
+
+/*
+ * DA8XX specific definitions
+ */
+
+/* USB 2.0 OTG module registers */
+#define DA8XX_USB_REVISION_REG  0x00
+#define DA8XX_USB_CTRL_REG      0x04
+#define DA8XX_USB_STAT_REG      0x08
+#define DA8XX_USB_EMULATION_REG 0x0c
+#define DA8XX_USB_MODE_REG      0x10    /* Transparent, CDC, [Generic] RNDIS */
+#define DA8XX_USB_AUTOREQ_REG   0x14
+#define DA8XX_USB_SRP_FIX_TIME_REG 0x18
+#define DA8XX_USB_TEARDOWN_REG  0x1c
+#define DA8XX_USB_INTR_SRC_REG  0x20
+#define DA8XX_USB_INTR_SRC_SET_REG 0x24
+#define DA8XX_USB_INTR_SRC_CLEAR_REG 0x28
+#define DA8XX_USB_INTR_MASK_REG 0x2c
+#define DA8XX_USB_INTR_MASK_SET_REG 0x30
+#define DA8XX_USB_INTR_MASK_CLEAR_REG 0x34
+#define DA8XX_USB_INTR_SRC_MASKED_REG 0x38
+#define DA8XX_USB_END_OF_INTR_REG 0x3c
+#define DA8XX_USB_GENERIC_RNDIS_EP_SIZE_REG(n) (0x50 + (((n) - 1) << 2))
+
+/* Control register bits */
+#define DA8XX_SOFT_RESET_MASK   1
+
+#define DA8XX_USB_TX_EP_MASK    0x1f            /* EP0 + 4 Tx EPs */
+#define DA8XX_USB_RX_EP_MASK    0x1e            /* 4 Rx EPs */
+
+/* USB interrupt register bits */
+#define DA8XX_INTR_USB_SHIFT    16
+#define DA8XX_INTR_USB_MASK     (0x1ff << DA8XX_INTR_USB_SHIFT) /* 8 Mentor */
+                                        /* interrupts and DRVVBUS interrupt */
+#define DA8XX_INTR_DRVVBUS      0x100
+#define DA8XX_INTR_RX_SHIFT     8
+#define DA8XX_INTR_RX_MASK      (DA8XX_USB_RX_EP_MASK << DA8XX_INTR_RX_SHIFT)
+#define DA8XX_INTR_TX_SHIFT     0
+#define DA8XX_INTR_TX_MASK      (DA8XX_USB_TX_EP_MASK << DA8XX_INTR_TX_SHIFT)
+
+#define DA8XX_MENTOR_CORE_OFFSET 0x400
+
+#define CFGCHIP2        IO_ADDRESS(DA8XX_SYSCFG0_BASE + DA8XX_CFGCHIP2_REG)
+
+struct da8xx_glue {
+        struct device           *dev;
+        struct platform_device  *musb;
+        struct clk              *clk;
+};
+
+/*
+ * REVISIT (PM): we should be able to keep the PHY in low power mode most
+ * of the time (24 MHz oscillator and PLL off, etc.) by setting POWER.D0
+ * and, when in host mode, autosuspending idle root ports... PHY_PLLON
+ * (overriding SUSPENDM?) then likely needs to stay off.
+ */
+
+static inline void phy_on(void)
+{
+        u32 cfgchip2 = __raw_readl(CFGCHIP2);
+
+        /*
+         * Start the on-chip PHY and its PLL.
+         */
+        cfgchip2 &= ~(CFGCHIP2_RESET | CFGCHIP2_PHYPWRDN | CFGCHIP2_OTGPWRDN);
+        cfgchip2 |= CFGCHIP2_PHY_PLLON;
+        __raw_writel(cfgchip2, CFGCHIP2);
+
+        pr_info("Waiting for USB PHY clock good...\n");
+        while (!(__raw_readl(CFGCHIP2) & CFGCHIP2_PHYCLKGD))
+                cpu_relax();
+}
+
+static inline void phy_off(void)
+{
+        u32 cfgchip2 = __raw_readl(CFGCHIP2);
+
+        /*
+         * Ensure that USB 1.1 reference clock is not being sourced from
+         * USB 2.0 PHY.  Otherwise do not power down the PHY.
+         */
+        if (!(cfgchip2 & CFGCHIP2_USB1PHYCLKMUX) &&
+             (cfgchip2 & CFGCHIP2_USB1SUSPENDM)) {
+                pr_warning("USB 1.1 clocked from USB 2.0 PHY -- "
+                           "can't power it down\n");
+                return;
+        }
+
+        /*
+         * Power down the on-chip PHY.
+         */
+        cfgchip2 |= CFGCHIP2_PHYPWRDN | CFGCHIP2_OTGPWRDN;
+        __raw_writel(cfgchip2, CFGCHIP2);
+}
+
+/*
+ * Because we don't set CTRL.UINT, it's "important" to:
+ *      - not read/write INTRUSB/INTRUSBE (except during
+ *        initial setup, as a workaround);
+ *      - use INTSET/INTCLR instead.
+ */
+
+/**
+ * da8xx_musb_enable - enable interrupts
+ */
+static void da8xx_musb_enable(struct musb *musb)
+{
+        void __iomem *reg_base = musb->ctrl_base;
+        u32 mask;
+
+        /* Workaround: setup IRQs through both register sets. */
+        mask = ((musb->epmask & DA8XX_USB_TX_EP_MASK) << DA8XX_INTR_TX_SHIFT) |
+               ((musb->epmask & DA8XX_USB_RX_EP_MASK) << DA8XX_INTR_RX_SHIFT) |
+               DA8XX_INTR_USB_MASK;
+        musb_writel(reg_base, DA8XX_USB_INTR_MASK_SET_REG, mask);
+
+        /* Force the DRVVBUS IRQ so we can start polling for ID change. */
+        if (is_otg_enabled(musb))
+                musb_writel(reg_base, DA8XX_USB_INTR_SRC_SET_REG,
+                            DA8XX_INTR_DRVVBUS << DA8XX_INTR_USB_SHIFT);
+}
+
+/**
+ * da8xx_musb_disable - disable HDRC and flush interrupts
+ */
+static void da8xx_musb_disable(struct musb *musb)
+{
+        void __iomem *reg_base = musb->ctrl_base;
+
+        musb_writel(reg_base, DA8XX_USB_INTR_MASK_CLEAR_REG,
+                    DA8XX_INTR_USB_MASK |
+                    DA8XX_INTR_TX_MASK | DA8XX_INTR_RX_MASK);
+        musb_writeb(musb->mregs, MUSB_DEVCTL, 0);
+        musb_writel(reg_base, DA8XX_USB_END_OF_INTR_REG, 0);
+}
+
+#ifdef CONFIG_USB_MUSB_HDRC_HCD
+#define portstate(stmt)         stmt
+#else
+#define portstate(stmt)
+#endif
+
+static void da8xx_musb_set_vbus(struct musb *musb, int is_on)
+{
+        WARN_ON(is_on && is_peripheral_active(musb));
+}
+
+#define POLL_SECONDS    2
+
+static struct timer_list otg_workaround;
+
+static void otg_timer(unsigned long _musb)
+{
+        struct musb             *musb = (void *)_musb;
+        void __iomem            *mregs = musb->mregs;
+        u8                      devctl;
+        unsigned long           flags;
+
+        /*
+         * We poll because DaVinci's won't expose several OTG-critical
+         * status change events (from the transceiver) otherwise.
+         */
+        devctl = musb_readb(mregs, MUSB_DEVCTL);
+        dev_dbg(musb->controller, "Poll devctl %02x (%s)\n", devctl,
+                otg_state_string(musb->xceiv->state));
+
+        spin_lock_irqsave(&musb->lock, flags);
+        switch (musb->xceiv->state) {
+        case OTG_STATE_A_WAIT_BCON:
+                devctl &= ~MUSB_DEVCTL_SESSION;
+                musb_writeb(musb->mregs, MUSB_DEVCTL, devctl);
+
+                devctl = musb_readb(musb->mregs, MUSB_DEVCTL);
+                if (devctl & MUSB_DEVCTL_BDEVICE) {
+                        musb->xceiv->state = OTG_STATE_B_IDLE;
+                        MUSB_DEV_MODE(musb);
+                } else {
+                        musb->xceiv->state = OTG_STATE_A_IDLE;
+                        MUSB_HST_MODE(musb);
+                }
+                break;
+        case OTG_STATE_A_WAIT_VFALL:
+                /*
+                 * Wait till VBUS falls below SessionEnd (~0.2 V); the 1.3
+                 * RTL seems to mis-handle session "start" otherwise (or in
+                 * our case "recover"), in routine "VBUS was valid by the time
+                 * VBUSERR got reported during enumeration" cases.
+                 */
+                if (devctl & MUSB_DEVCTL_VBUS) {
+                        mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);
+                        break;
+                }
+                musb->xceiv->state = OTG_STATE_A_WAIT_VRISE;
+                musb_writel(musb->ctrl_base, DA8XX_USB_INTR_SRC_SET_REG,
+                            MUSB_INTR_VBUSERROR << DA8XX_INTR_USB_SHIFT);
+                break;
+        case OTG_STATE_B_IDLE:
+                if (!is_peripheral_enabled(musb))
+                        break;
+
+                /*
+                 * There's no ID-changed IRQ, so we have no good way to tell
+                 * when to switch to the A-Default state machine (by setting
+                 * the DEVCTL.Session bit).
+                 *
+                 * Workaround:  whenever we're in B_IDLE, try setting the
+                 * session flag every few seconds.  If it works, ID was
+                 * grounded and we're now in the A-Default state machine.
+                 *
+                 * NOTE: setting the session flag is _supposed_ to trigger
+                 * SRP but clearly it doesn't.
+                 */
+                musb_writeb(mregs, MUSB_DEVCTL, devctl | MUSB_DEVCTL_SESSION);
+                devctl = musb_readb(mregs, MUSB_DEVCTL);
+                if (devctl & MUSB_DEVCTL_BDEVICE)
+                        mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);
+                else
+                        musb->xceiv->state = OTG_STATE_A_IDLE;
+                break;
+        default:
+                break;
+        }
+        spin_unlock_irqrestore(&musb->lock, flags);
+}
+
+static void da8xx_musb_try_idle(struct musb *musb, unsigned long timeout)
+{
+        static unsigned long last_timer;
+
+        if (!is_otg_enabled(musb))
+                return;
+
+        if (timeout == 0)
+                timeout = jiffies + msecs_to_jiffies(3);
+
+        /* Never idle if active, or when VBUS timeout is not set as host */
+        if (musb->is_active || (musb->a_wait_bcon == 0 &&
+                                musb->xceiv->state == OTG_STATE_A_WAIT_BCON)) {
+                dev_dbg(musb->controller, "%s active, deleting timer\n",
+                        otg_state_string(musb->xceiv->state));
+                del_timer(&otg_workaround);
+                last_timer = jiffies;
+                return;
+        }
+
+        if (time_after(last_timer, timeout) && timer_pending(&otg_workaround)) {
+                dev_dbg(musb->controller, "Longer idle timer already pending, ignoring...\n");
+                return;
+        }
+        last_timer = timeout;
+
+        dev_dbg(musb->controller, "%s inactive, starting idle timer for %u ms\n",
+                otg_state_string(musb->xceiv->state),
+                jiffies_to_msecs(timeout - jiffies));
+        mod_timer(&otg_workaround, timeout);
+}
+
+static irqreturn_t da8xx_musb_interrupt(int irq, void *hci)
+{
+        struct musb             *musb = hci;
+        void __iomem            *reg_base = musb->ctrl_base;
+        unsigned long           flags;
+        irqreturn_t             ret = IRQ_NONE;
+        u32                     status;
+
+        spin_lock_irqsave(&musb->lock, flags);
+
+        /*
+         * NOTE: DA8XX shadows the Mentor IRQs.  Don't manage them through
+         * the Mentor registers (except for setup), use the TI ones and EOI.
+         */
+
+        /* Acknowledge and handle non-CPPI interrupts */
+        status = musb_readl(reg_base, DA8XX_USB_INTR_SRC_MASKED_REG);
+        if (!status)
+                goto eoi;
+
+        musb_writel(reg_base, DA8XX_USB_INTR_SRC_CLEAR_REG, status);
+        dev_dbg(musb->controller, "USB IRQ %08x\n", status);
+
+        musb->int_rx = (status & DA8XX_INTR_RX_MASK) >> DA8XX_INTR_RX_SHIFT;
+        musb->int_tx = (status & DA8XX_INTR_TX_MASK) >> DA8XX_INTR_TX_SHIFT;
+        musb->int_usb = (status & DA8XX_INTR_USB_MASK) >> DA8XX_INTR_USB_SHIFT;
+
+        /*
+         * DRVVBUS IRQs are the only proxy we have (a very poor one!) for
+         * DA8xx's missing ID change IRQ.  We need an ID change IRQ to
+         * switch appropriately between halves of the OTG state machine.
+         * Managing DEVCTL.Session per Mentor docs requires that we know its
+         * value but DEVCTL.BDevice is invalid without DEVCTL.Session set.
+         * Also, DRVVBUS pulses for SRP (but not at 5 V)...
+         */
+        if (status & (DA8XX_INTR_DRVVBUS << DA8XX_INTR_USB_SHIFT)) {
+                int drvvbus = musb_readl(reg_base, DA8XX_USB_STAT_REG);
+                void __iomem *mregs = musb->mregs;
+                u8 devctl = musb_readb(mregs, MUSB_DEVCTL);
+                int err;
+
+                err = is_host_enabled(musb) && (musb->int_usb &
+                                                MUSB_INTR_VBUSERROR);
+                if (err) {
+                        /*
+                         * The Mentor core doesn't debounce VBUS as needed
+                         * to cope with device connect current spikes. This
+                         * means it's not uncommon for bus-powered devices
+                         * to get VBUS errors during enumeration.
+                         *
+                         * This is a workaround, but newer RTL from Mentor
+                         * seems to allow a better one: "re"-starting sessions
+                         * without waiting for VBUS to stop registering in
+                         * devctl.
+                         */
+                        musb->int_usb &= ~MUSB_INTR_VBUSERROR;
+                        musb->xceiv->state = OTG_STATE_A_WAIT_VFALL;
+                        mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);
+                        WARNING("VBUS error workaround (delay coming)\n");
+                } else if (is_host_enabled(musb) && drvvbus) {
+                        MUSB_HST_MODE(musb);
+                        musb->xceiv->default_a = 1;
+                        musb->xceiv->state = OTG_STATE_A_WAIT_VRISE;
+                        portstate(musb->port1_status |= USB_PORT_STAT_POWER);
+                        del_timer(&otg_workaround);
+                } else {
+                        musb->is_active = 0;
+                        MUSB_DEV_MODE(musb);
+                        musb->xceiv->default_a = 0;
+                        musb->xceiv->state = OTG_STATE_B_IDLE;
+                        portstate(musb->port1_status &= ~USB_PORT_STAT_POWER);
+                }
+
+                dev_dbg(musb->controller, "VBUS %s (%s)%s, devctl %02x\n",
+                                drvvbus ? "on" : "off",
+                                otg_state_string(musb->xceiv->state),
+                                err ? " ERROR" : "",
+                                devctl);
+                ret = IRQ_HANDLED;
+        }
+
+        if (musb->int_tx || musb->int_rx || musb->int_usb)
+                ret |= musb_interrupt(musb);
+
+ eoi:
+        /* EOI needs to be written for the IRQ to be re-asserted. */
+        if (ret == IRQ_HANDLED || status)
+                musb_writel(reg_base, DA8XX_USB_END_OF_INTR_REG, 0);
+
+        /* Poll for ID change */
+        if (is_otg_enabled(musb) && musb->xceiv->state == OTG_STATE_B_IDLE)
+                mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);
+
+        spin_unlock_irqrestore(&musb->lock, flags);
+
+        return ret;
+}
+
+static int da8xx_musb_set_mode(struct musb *musb, u8 musb_mode)
+{
+        u32 cfgchip2 = __raw_readl(CFGCHIP2);
+
+        cfgchip2 &= ~CFGCHIP2_OTGMODE;
+        switch (musb_mode) {
+#ifdef  CONFIG_USB_MUSB_HDRC_HCD
+        case MUSB_HOST:         /* Force VBUS valid, ID = 0 */
+                cfgchip2 |= CFGCHIP2_FORCE_HOST;
+                break;
+#endif
+#ifdef  CONFIG_USB_GADGET_MUSB_HDRC
+        case MUSB_PERIPHERAL:   /* Force VBUS valid, ID = 1 */
+                cfgchip2 |= CFGCHIP2_FORCE_DEVICE;
+                break;
+#endif
+#ifdef  CONFIG_USB_MUSB_OTG
+        case MUSB_OTG:          /* Don't override the VBUS/ID comparators */
+                cfgchip2 |= CFGCHIP2_NO_OVERRIDE;
+                break;
+#endif
+        default:
+                dev_dbg(musb->controller, "Trying to set unsupported mode %u\n", musb_mode);
+        }
+
+        __raw_writel(cfgchip2, CFGCHIP2);
+        return 0;
+}
+
+static int da8xx_musb_init(struct musb *musb)
+{
+        void __iomem *reg_base = musb->ctrl_base;
+        u32 rev;
+
+        musb->mregs += DA8XX_MENTOR_CORE_OFFSET;
+
+        /* Returns zero if e.g. not clocked */
+        rev = musb_readl(reg_base, DA8XX_USB_REVISION_REG);
+        if (!rev)
+                goto fail;
+
+        usb_nop_xceiv_register();
+        musb->xceiv = otg_get_transceiver();
+        if (!musb->xceiv)
+                goto fail;
+
+        if (is_host_enabled(musb))
+                setup_timer(&otg_workaround, otg_timer, (unsigned long)musb);
+
+        /* Reset the controller */
+        musb_writel(reg_base, DA8XX_USB_CTRL_REG, DA8XX_SOFT_RESET_MASK);
+
+        /* Start the on-chip PHY and its PLL. */
+        phy_on();
+
+        msleep(5);
+
+        /* NOTE: IRQs are in mixed mode, not bypass to pure MUSB */
+        pr_debug("DA8xx OTG revision %08x, PHY %03x, control %02x\n",
+                 rev, __raw_readl(CFGCHIP2),
+                 musb_readb(reg_base, DA8XX_USB_CTRL_REG));
+
+        musb->isr = da8xx_musb_interrupt;
+        return 0;
+fail:
+        return -ENODEV;
+}
+
+static int da8xx_musb_exit(struct musb *musb)
+{
+        if (is_host_enabled(musb))
+                del_timer_sync(&otg_workaround);
+
+        phy_off();
+
+        otg_put_transceiver(musb->xceiv);
+        usb_nop_xceiv_unregister();
+
+        return 0;
+}
+
+static const struct musb_platform_ops da8xx_ops = {
+        .init           = da8xx_musb_init,
+        .exit           = da8xx_musb_exit,
+
+        .enable         = da8xx_musb_enable,
+        .disable        = da8xx_musb_disable,
+
+        .set_mode       = da8xx_musb_set_mode,
+        .try_idle       = da8xx_musb_try_idle,
+
+        .set_vbus       = da8xx_musb_set_vbus,
+};
+
+static u64 da8xx_dmamask = DMA_BIT_MASK(32);
+
+static int __init da8xx_probe(struct platform_device *pdev)
+{
+        struct musb_hdrc_platform_data  *pdata = pdev->dev.platform_data;
+        struct platform_device          *musb;
+        struct da8xx_glue               *glue;
+
+        struct clk                      *clk;
+
+        int                             ret = -ENOMEM;
+
+        glue = kzalloc(sizeof(*glue), GFP_KERNEL);
+        if (!glue) {
+                dev_err(&pdev->dev, "failed to allocate glue context\n");
+                goto err0;
+        }
+
+        musb = platform_device_alloc("musb-hdrc", -1);
+        if (!musb) {
+                dev_err(&pdev->dev, "failed to allocate musb device\n");
+                goto err1;
+        }
+
+        clk = clk_get(&pdev->dev, "usb20");
+        if (IS_ERR(clk)) {
+                dev_err(&pdev->dev, "failed to get clock\n");
+                ret = PTR_ERR(clk);
+                goto err2;
+        }
+
+        ret = clk_enable(clk);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to enable clock\n");
+                goto err3;
+        }
+
+        musb->dev.parent                = &pdev->dev;
+        musb->dev.dma_mask              = &da8xx_dmamask;
+        musb->dev.coherent_dma_mask     = da8xx_dmamask;
+
+        glue->dev                       = &pdev->dev;
+        glue->musb                      = musb;
+        glue->clk                       = clk;
+
+        pdata->platform_ops             = &da8xx_ops;
+
+        platform_set_drvdata(pdev, glue);
+
+        ret = platform_device_add_resources(musb, pdev->resource,
+                        pdev->num_resources);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to add resources\n");
+                goto err4;
+        }
+
+        ret = platform_device_add_data(musb, pdata, sizeof(*pdata));
+        if (ret) {
+                dev_err(&pdev->dev, "failed to add platform_data\n");
+                goto err4;
+        }
+
+        ret = platform_device_add(musb);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to register musb device\n");
+                goto err4;
+        }
+
+        return 0;
+
+err4:
+        clk_disable(clk);
+
+err3:
+        clk_put(clk);
+
+err2:
+        platform_device_put(musb);
+
+err1:
+        kfree(glue);
+
+err0:
+        return ret;
+}
+
+static int __exit da8xx_remove(struct platform_device *pdev)
+{
+        struct da8xx_glue               *glue = platform_get_drvdata(pdev);
+
+        platform_device_del(glue->musb);
+        platform_device_put(glue->musb);
+        clk_disable(glue->clk);
+        clk_put(glue->clk);
+        kfree(glue);
+
+        return 0;
+}
+
+static struct platform_driver da8xx_driver = {
+        .remove         = __exit_p(da8xx_remove),
+        .driver         = {
+                .name   = "musb-da8xx",
+        },
+};
+
+MODULE_DESCRIPTION("DA8xx/OMAP-L1x MUSB Glue Layer");
+MODULE_AUTHOR("Sergei Shtylyov <sshtylyov@ru.mvista.com>");
+MODULE_LICENSE("GPL v2");
+
+static int __init da8xx_init(void)
+{
+        return platform_driver_probe(&da8xx_driver, da8xx_probe);
+}
+subsys_initcall(da8xx_init);
+
+static void __exit da8xx_exit(void)
+{
+        platform_driver_unregister(&da8xx_driver);
+}
+module_exit(da8xx_exit);
diff --git a/drivers/usb/musb/davinci.c b/drivers/usb/musb/davinci.c
index 57624361c1de..2a2adf6492cd 100644
--- a/drivers/usb/musb/davinci.c
+++ b/drivers/usb/musb/davinci.c
@@ -30,6 +30,8 @@
 #include <linux/clk.h>
 #include <linux/io.h>
 #include <linux/gpio.h>
+#include <linux/platform_device.h>
+#include <linux/dma-mapping.h>
 
 #include <mach/hardware.h>
 #include <mach/memory.h>
@@ -51,6 +53,12 @@
 #define USB_PHY_CTRL    IO_ADDRESS(USBPHY_CTL_PADDR)
 #define DM355_DEEPSLEEP IO_ADDRESS(DM355_DEEPSLEEP_PADDR)
 
+struct davinci_glue {
+        struct device           *dev;
+        struct platform_device  *musb;
+        struct clk              *clk;
+};
+
 /* REVISIT (PM) we should be able to keep the PHY in low power mode most
  * of the time (24 MHZ oscillator and PLL off, etc) by setting POWER.D0
  * and, when in host mode, autosuspending idle root ports... PHYPLLON
@@ -83,7 +91,7 @@ static inline void phy_off(void)
 
 static int dma_off = 1;
 
-void musb_platform_enable(struct musb *musb)
+static void davinci_musb_enable(struct musb *musb)
 {
         u32     tmp, old, val;
 
@@ -116,7 +124,7 @@ void musb_platform_enable(struct musb *musb)
 /*
  * Disable the HDRC and flush interrupts
  */
-void musb_platform_disable(struct musb *musb)
+static void davinci_musb_disable(struct musb *musb)
 {
         /* because we don't set CTRLR.UINT, "important" to:
          *  - not read/write INTRUSB/INTRUSBE
@@ -167,7 +175,7 @@ static void evm_deferred_drvvbus(struct work_struct *ignored)
 
 #endif  /* EVM */
 
-static void davinci_source_power(struct musb *musb, int is_on, int immediate)
+static void davinci_musb_source_power(struct musb *musb, int is_on, int immediate)
 {
 #ifdef CONFIG_MACH_DAVINCI_EVM
         if (is_on)
@@ -190,10 +198,10 @@ static void davinci_source_power(struct musb *musb, int is_on, int immediate)
 #endif
 }
 
-static void davinci_set_vbus(struct musb *musb, int is_on)
+static void davinci_musb_set_vbus(struct musb *musb, int is_on)
 {
         WARN_ON(is_on && is_peripheral_active(musb));
-        davinci_source_power(musb, is_on, 0);
+        davinci_musb_source_power(musb, is_on, 0);
 }
 
 
@@ -212,7 +220,8 @@ static void otg_timer(unsigned long _musb)
         * status change events (from the transceiver) otherwise.
          */
         devctl = musb_readb(mregs, MUSB_DEVCTL);
-        DBG(7, "poll devctl %02x (%s)\n", devctl, otg_state_string(musb));
+        dev_dbg(musb->controller, "poll devctl %02x (%s)\n", devctl,
+                otg_state_string(musb->xceiv->state));
 
         spin_lock_irqsave(&musb->lock, flags);
         switch (musb->xceiv->state) {
@@ -259,7 +268,7 @@ static void otg_timer(unsigned long _musb)
         spin_unlock_irqrestore(&musb->lock, flags);
 }
 
-static irqreturn_t davinci_interrupt(int irq, void *__hci)
+static irqreturn_t davinci_musb_interrupt(int irq, void *__hci)
 {
         unsigned long   flags;
         irqreturn_t     retval = IRQ_NONE;
@@ -289,7 +298,7 @@ static irqreturn_t davinci_interrupt(int irq, void *__hci)
         /* ack and handle non-CPPI interrupts */
         tmp = musb_readl(tibase, DAVINCI_USB_INT_SRC_MASKED_REG);
         musb_writel(tibase, DAVINCI_USB_INT_SRC_CLR_REG, tmp);
-        DBG(4, "IRQ %08x\n", tmp);
+        dev_dbg(musb->controller, "IRQ %08x\n", tmp);
 
         musb->int_rx = (tmp & DAVINCI_USB_RXINT_MASK)
                         >> DAVINCI_USB_RXINT_SHIFT;
@@ -345,10 +354,10 @@ static irqreturn_t davinci_interrupt(int irq, void *__hci)
                 /* NOTE:  this must complete poweron within 100 msec
                  * (OTG_TIME_A_WAIT_VRISE) but we don't check for that.
                  */
-                davinci_source_power(musb, drvvbus, 0);
-                DBG(2, "VBUS %s (%s)%s, devctl %02x\n",
+                davinci_musb_source_power(musb, drvvbus, 0);
+                dev_dbg(musb->controller, "VBUS %s (%s)%s, devctl %02x\n",
                                 drvvbus ? "on" : "off",
-                                otg_state_string(musb),
+                                otg_state_string(musb->xceiv->state),
                                 err ? " ERROR" : "",
                                 devctl);
                 retval = IRQ_HANDLED;
@@ -370,13 +379,13 @@ static irqreturn_t davinci_interrupt(int irq, void *__hci)
         return retval;
 }
 
-int musb_platform_set_mode(struct musb *musb, u8 mode)
+static int davinci_musb_set_mode(struct musb *musb, u8 mode)
 {
         /* EVM can't do this (right?) */
         return -EIO;
 }
 
-int __init musb_platform_init(struct musb *musb, void *board_data)
+static int davinci_musb_init(struct musb *musb)
 {
         void __iomem    *tibase = musb->ctrl_base;
         u32             revision;
@@ -388,8 +397,6 @@ int __init musb_platform_init(struct musb *musb, void *board_data)
 
         musb->mregs += DAVINCI_BASE_OFFSET;
 
-        clk_enable(musb->clock);
-
         /* returns zero if e.g. not clocked */
         revision = musb_readl(tibase, DAVINCI_USB_VERSION_REG);
         if (revision == 0)
@@ -398,8 +405,7 @@ int __init musb_platform_init(struct musb *musb, void *board_data)
         if (is_host_enabled(musb))
                 setup_timer(&otg_workaround, otg_timer, (unsigned long) musb);
 
-        musb->board_set_vbus = davinci_set_vbus;
-        davinci_source_power(musb, 0, 1);
+        davinci_musb_source_power(musb, 0, 1);
 
         /* dm355 EVM swaps D+/D- for signal integrity, and
          * is clocked from the main 24 MHz crystal.
@@ -440,17 +446,16 @@ int __init musb_platform_init(struct musb *musb, void *board_data)
                 revision, __raw_readl(USB_PHY_CTRL),
                 musb_readb(tibase, DAVINCI_USB_CTRL_REG));
 
-        musb->isr = davinci_interrupt;
+        musb->isr = davinci_musb_interrupt;
         return 0;
 
 fail:
-        clk_disable(musb->clock);
-
+        otg_put_transceiver(musb->xceiv);
         usb_nop_xceiv_unregister();
         return -ENODEV;
 }
 
-int musb_platform_exit(struct musb *musb)
+static int davinci_musb_exit(struct musb *musb)
 {
         if (is_host_enabled(musb))
                 del_timer_sync(&otg_workaround);
@@ -464,7 +469,7 @@ int musb_platform_exit(struct musb *musb)
                 __raw_writel(deepsleep, DM355_DEEPSLEEP);
         }
 
-        davinci_source_power(musb, 0 /*off*/, 1);
+        davinci_musb_source_power(musb, 0 /*off*/, 1);
 
         /* delay, to avoid problems with module reload */
         if (is_host_enabled(musb) && musb->xceiv->default_a) {
@@ -480,7 +485,7 @@ int musb_platform_exit(struct musb *musb)
                                 break;
                         if ((devctl & MUSB_DEVCTL_VBUS) != warn) {
                                 warn = devctl & MUSB_DEVCTL_VBUS;
-                                DBG(1, "VBUS %d\n",
+                                dev_dbg(musb->controller, "VBUS %d\n",
                                         warn >> MUSB_DEVCTL_VBUS_SHIFT);
                         }
                         msleep(1000);
@@ -489,14 +494,146 @@ int musb_platform_exit(struct musb *musb)
 
                 /* in OTG mode, another host might be connected */
                 if (devctl & MUSB_DEVCTL_VBUS)
-                        DBG(1, "VBUS off timeout (devctl %02x)\n", devctl);
+                        dev_dbg(musb->controller, "VBUS off timeout (devctl %02x)\n", devctl);
         }
 
         phy_off();
 
-        clk_disable(musb->clock);
-
+        otg_put_transceiver(musb->xceiv);
         usb_nop_xceiv_unregister();
 
         return 0;
 }
+
+static const struct musb_platform_ops davinci_ops = {
+        .init           = davinci_musb_init,
+        .exit           = davinci_musb_exit,
+
+        .enable         = davinci_musb_enable,
+        .disable        = davinci_musb_disable,
+
+        .set_mode       = davinci_musb_set_mode,
+
+        .set_vbus       = davinci_musb_set_vbus,
+};
+
+static u64 davinci_dmamask = DMA_BIT_MASK(32);
+
+static int __init davinci_probe(struct platform_device *pdev)
+{
+        struct musb_hdrc_platform_data  *pdata = pdev->dev.platform_data;
+        struct platform_device          *musb;
+        struct davinci_glue             *glue;
+        struct clk                      *clk;
+
+        int                             ret = -ENOMEM;
+
+        glue = kzalloc(sizeof(*glue), GFP_KERNEL);
+        if (!glue) {
+                dev_err(&pdev->dev, "failed to allocate glue context\n");
+                goto err0;
+        }
+
+        musb = platform_device_alloc("musb-hdrc", -1);
+        if (!musb) {
+                dev_err(&pdev->dev, "failed to allocate musb device\n");
+                goto err1;
+        }
+
+        clk = clk_get(&pdev->dev, "usb");
+        if (IS_ERR(clk)) {
+                dev_err(&pdev->dev, "failed to get clock\n");
+                ret = PTR_ERR(clk);
+                goto err2;
+        }
+
+        ret = clk_enable(clk);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to enable clock\n");
+                goto err3;
+        }
+
+        musb->dev.parent                = &pdev->dev;
+        musb->dev.dma_mask              = &davinci_dmamask;
+        musb->dev.coherent_dma_mask     = davinci_dmamask;
+
+        glue->dev                       = &pdev->dev;
+        glue->musb                      = musb;
+        glue->clk                       = clk;
+
+        pdata->platform_ops             = &davinci_ops;
+
+        platform_set_drvdata(pdev, glue);
+
+        ret = platform_device_add_resources(musb, pdev->resource,
+                        pdev->num_resources);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to add resources\n");
+                goto err4;
+        }
+
+        ret = platform_device_add_data(musb, pdata, sizeof(*pdata));
+        if (ret) {
+                dev_err(&pdev->dev, "failed to add platform_data\n");
+                goto err4;
+        }
+
+        ret = platform_device_add(musb);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to register musb device\n");
+                goto err4;
+        }
+
+        return 0;
+
+err4:
+        clk_disable(clk);
+
+err3:
+        clk_put(clk);
+
+err2:
+        platform_device_put(musb);
+
+err1:
+        kfree(glue);
+
+err0:
+        return ret;
+}
+
+static int __exit davinci_remove(struct platform_device *pdev)
+{
+        struct davinci_glue             *glue = platform_get_drvdata(pdev);
+
+        platform_device_del(glue->musb);
+        platform_device_put(glue->musb);
+        clk_disable(glue->clk);
+        clk_put(glue->clk);
+        kfree(glue);
+
+        return 0;
+}
+
+static struct platform_driver davinci_driver = {
+        .remove         = __exit_p(davinci_remove),
+        .driver         = {
+                .name   = "musb-davinci",
+        },
+};
+
+MODULE_DESCRIPTION("DaVinci MUSB Glue Layer");
+MODULE_AUTHOR("Felipe Balbi <balbi@ti.com>");
+MODULE_LICENSE("GPL v2");
+
+static int __init davinci_init(void)
+{
+        return platform_driver_probe(&davinci_driver, davinci_probe);
+}
+subsys_initcall(davinci_init);
+
+static void __exit davinci_exit(void)
+{
+        platform_driver_unregister(&davinci_driver);
+}
+module_exit(davinci_exit);
diff --git a/drivers/usb/musb/musb_core.c b/drivers/usb/musb/musb_core.c
index 540c766c4f86..c71b0372786e 100644
--- a/drivers/usb/musb/musb_core.c
+++ b/drivers/usb/musb/musb_core.c
@@ -96,29 +96,15 @@
 #include <linux/init.h>
 #include <linux/list.h>
 #include <linux/kobject.h>
+#include <linux/prefetch.h>
 #include <linux/platform_device.h>
 #include <linux/io.h>
 
-#ifdef  CONFIG_ARM
-#include <mach/hardware.h>
-#include <mach/memory.h>
-#include <asm/mach-types.h>
-#endif
-
 #include "musb_core.h"
 
-
-#ifdef CONFIG_ARCH_DAVINCI
-#include "davinci.h"
-#endif
-
 #define TA_WAIT_BCON(m) max_t(int, (m)->a_wait_bcon, OTG_TIME_A_WAIT_BCON)
 
 
-unsigned musb_debug;
-module_param_named(debug, musb_debug, uint, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Debug message level. Default = 0");
-
 #define DRIVER_AUTHOR "Mentor Graphics, Texas Instruments, Nokia"
 #define DRIVER_DESC "Inventra Dual-Role USB Controller Driver"
 
@@ -126,7 +112,7 @@ MODULE_PARM_DESC(debug, "Debug message level. Default = 0");
 
 #define DRIVER_INFO DRIVER_DESC ", v" MUSB_VERSION
 
-#define MUSB_DRIVER_NAME "musb_hdrc"
+#define MUSB_DRIVER_NAME "musb-hdrc"
 const char musb_driver_name[] = MUSB_DRIVER_NAME;
 
 MODULE_DESCRIPTION(DRIVER_INFO);
@@ -139,12 +125,7 @@ MODULE_ALIAS("platform:" MUSB_DRIVER_NAME);
 
 static inline struct musb *dev_to_musb(struct device *dev)
 {
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
-        /* usbcore insists dev->driver_data is a "struct hcd *" */
-        return hcd_to_musb(dev_get_drvdata(dev));
-#else
         return dev_get_drvdata(dev);
-#endif
 }
 
 /*-------------------------------------------------------------------------*/
@@ -173,10 +154,8 @@ static int musb_ulpi_read(struct otg_transceiver *otg, u32 offset)
         while (!(musb_readb(addr, MUSB_ULPI_REG_CONTROL)
                                 & MUSB_ULPI_REG_CMPLT)) {
                 i++;
-                if (i == 10000) {
-                        DBG(3, "ULPI read timed out\n");
+                if (i == 10000)
                         return -ETIMEDOUT;
-                }
 
         }
         r = musb_readb(addr, MUSB_ULPI_REG_CONTROL);
@@ -206,10 +185,8 @@ static int musb_ulpi_write(struct otg_transceiver *otg,
         while (!(musb_readb(addr, MUSB_ULPI_REG_CONTROL)
                                 & MUSB_ULPI_REG_CMPLT)) {
                 i++;
-                if (i == 10000) {
-                        DBG(3, "ULPI write timed out\n");
+                if (i == 10000)
                         return -ETIMEDOUT;
-                }
         }
 
         r = musb_readb(addr, MUSB_ULPI_REG_CONTROL);
@@ -230,18 +207,19 @@ static struct otg_io_access_ops musb_ulpi_access = {
 
 /*-------------------------------------------------------------------------*/
 
-#if !defined(CONFIG_USB_TUSB6010) && !defined(CONFIG_BLACKFIN)
+#if !defined(CONFIG_USB_MUSB_TUSB6010) && !defined(CONFIG_USB_MUSB_BLACKFIN)
 
 /*
  * Load an endpoint's FIFO
  */
 void musb_write_fifo(struct musb_hw_ep *hw_ep, u16 len, const u8 *src)
 {
+        struct musb *musb = hw_ep->musb;
         void __iomem *fifo = hw_ep->fifo;
 
         prefetch((u8 *)src);
 
-        DBG(4, "%cX ep%d fifo %p count %d buf %p\n",
+        dev_dbg(musb->controller, "%cX ep%d fifo %p count %d buf %p\n",
                         'T', hw_ep->epnum, fifo, len, src);
 
         /* we can't assume unaligned reads work */
@@ -272,14 +250,16 @@ void musb_write_fifo(struct musb_hw_ep *hw_ep, u16 len, const u8 *src)
         }
 }
 
+#if !defined(CONFIG_USB_MUSB_AM35X)
 /*
  * Unload an endpoint's FIFO
  */
 void musb_read_fifo(struct musb_hw_ep *hw_ep, u16 len, u8 *dst)
 {
+        struct musb *musb = hw_ep->musb;
         void __iomem *fifo = hw_ep->fifo;
 
-        DBG(4, "%cX ep%d fifo %p count %d buf %p\n",
+        dev_dbg(musb->controller, "%cX ep%d fifo %p count %d buf %p\n",
                         'R', hw_ep->epnum, fifo, len, dst);
 
         /* we can't assume unaligned writes work */
@@ -309,6 +289,7 @@ void musb_read_fifo(struct musb_hw_ep *hw_ep, u16 len, u8 *dst)
                 readsb(fifo, dst, len);
         }
 }
+#endif
 
 #endif  /* normal PIO */
 
@@ -347,26 +328,6 @@ void musb_load_testpacket(struct musb *musb)
 
 /*-------------------------------------------------------------------------*/
 
-const char *otg_state_string(struct musb *musb)
-{
-        switch (musb->xceiv->state) {
-        case OTG_STATE_A_IDLE:          return "a_idle";
-        case OTG_STATE_A_WAIT_VRISE:    return "a_wait_vrise";
-        case OTG_STATE_A_WAIT_BCON:     return "a_wait_bcon";
-        case OTG_STATE_A_HOST:          return "a_host";
-        case OTG_STATE_A_SUSPEND:       return "a_suspend";
-        case OTG_STATE_A_PERIPHERAL:    return "a_peripheral";
-        case OTG_STATE_A_WAIT_VFALL:    return "a_wait_vfall";
-        case OTG_STATE_A_VBUS_ERR:      return "a_vbus_err";
-        case OTG_STATE_B_IDLE:          return "b_idle";
-        case OTG_STATE_B_SRP_INIT:      return "b_srp_init";
-        case OTG_STATE_B_PERIPHERAL:    return "b_peripheral";
-        case OTG_STATE_B_WAIT_ACON:     return "b_wait_acon";
-        case OTG_STATE_B_HOST:          return "b_host";
-        default:                        return "UNDEFINED";
-        }
-}
-
 #ifdef  CONFIG_USB_MUSB_OTG
 
 /*
@@ -380,19 +341,21 @@ void musb_otg_timer_func(unsigned long data)
         spin_lock_irqsave(&musb->lock, flags);
         switch (musb->xceiv->state) {
         case OTG_STATE_B_WAIT_ACON:
-                DBG(1, "HNP: b_wait_acon timeout; back to b_peripheral\n");
+                dev_dbg(musb->controller, "HNP: b_wait_acon timeout; back to b_peripheral\n");
                 musb_g_disconnect(musb);
                 musb->xceiv->state = OTG_STATE_B_PERIPHERAL;
                 musb->is_active = 0;
                 break;
         case OTG_STATE_A_SUSPEND:
         case OTG_STATE_A_WAIT_BCON:
-                DBG(1, "HNP: %s timeout\n", otg_state_string(musb));
-                musb_set_vbus(musb, 0);
+                dev_dbg(musb->controller, "HNP: %s timeout\n",
+                        otg_state_string(musb->xceiv->state));
+                musb_platform_set_vbus(musb, 0);
                 musb->xceiv->state = OTG_STATE_A_WAIT_VFALL;
                 break;
         default:
-                DBG(1, "HNP: Unhandled mode %s\n", otg_state_string(musb));
+                dev_dbg(musb->controller, "HNP: Unhandled mode %s\n",
+                        otg_state_string(musb->xceiv->state));
         }
         musb->ignore_disconnect = 0;
         spin_unlock_irqrestore(&musb->lock, flags);
@@ -407,15 +370,16 @@ void musb_hnp_stop(struct musb *musb)
         void __iomem    *mbase = musb->mregs;
         u8      reg;
 
-        DBG(1, "HNP: stop from %s\n", otg_state_string(musb));
+        dev_dbg(musb->controller, "HNP: stop from %s\n", otg_state_string(musb->xceiv->state));
 
         switch (musb->xceiv->state) {
         case OTG_STATE_A_PERIPHERAL:
                 musb_g_disconnect(musb);
-                DBG(1, "HNP: back to %s\n", otg_state_string(musb));
+                dev_dbg(musb->controller, "HNP: back to %s\n",
+                        otg_state_string(musb->xceiv->state));
                 break;
         case OTG_STATE_B_HOST:
-                DBG(1, "HNP: Disabling HR\n");
+                dev_dbg(musb->controller, "HNP: Disabling HR\n");
                 hcd->self.is_b_host = 0;
                 musb->xceiv->state = OTG_STATE_B_PERIPHERAL;
                 MUSB_DEV_MODE(musb);
@@ -425,8 +389,8 @@ void musb_hnp_stop(struct musb *musb)
                 /* REVISIT: Start SESSION_REQUEST here? */
                 break;
         default:
-                DBG(1, "HNP: Stopping in unknown state %s\n",
-                        otg_state_string(musb));
+                dev_dbg(musb->controller, "HNP: Stopping in unknown state %s\n",
+                        otg_state_string(musb->xceiv->state));
         }
 
         /*
@@ -456,7 +420,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
 {
         irqreturn_t handled = IRQ_NONE;
 
-        DBG(3, "<== Power=%02x, DevCtl=%02x, int_usb=0x%x\n", power, devctl,
+        dev_dbg(musb->controller, "<== Power=%02x, DevCtl=%02x, int_usb=0x%x\n", power, devctl,
                 int_usb);
 
         /* in host mode, the peripheral may issue remote wakeup.
@@ -465,7 +429,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
          */
         if (int_usb & MUSB_INTR_RESUME) {
                 handled = IRQ_HANDLED;
-                DBG(3, "RESUME (%s)\n", otg_state_string(musb));
+                dev_dbg(musb->controller, "RESUME (%s)\n", otg_state_string(musb->xceiv->state));
 
                 if (devctl & MUSB_DEVCTL_HM) {
 #ifdef CONFIG_USB_MUSB_HDRC_HCD
@@ -480,7 +444,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                                 if (power & MUSB_POWER_SUSPENDM) {
                                         /* spurious */
                                         musb->int_usb &= ~MUSB_INTR_SUSPEND;
-                                        DBG(2, "Spurious SUSPENDM\n");
+                                        dev_dbg(musb->controller, "Spurious SUSPENDM\n");
                                         break;
                                 }
 
@@ -506,7 +470,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                         default:
                                 WARNING("bogus %s RESUME (%s)\n",
                                         "host",
-                                        otg_state_string(musb));
+                                        otg_state_string(musb->xceiv->state));
                         }
 #endif
                 } else {
@@ -540,7 +504,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                         default:
                                 WARNING("bogus %s RESUME (%s)\n",
                                         "peripheral",
-                                        otg_state_string(musb));
+                                        otg_state_string(musb->xceiv->state));
                         }
                 }
         }
@@ -550,7 +514,14 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
         if (int_usb & MUSB_INTR_SESSREQ) {
                 void __iomem *mbase = musb->mregs;
 
-                DBG(1, "SESSION_REQUEST (%s)\n", otg_state_string(musb));
+                if ((devctl & MUSB_DEVCTL_VBUS) == MUSB_DEVCTL_VBUS
+                                && (devctl & MUSB_DEVCTL_BDEVICE)) {
+                        dev_dbg(musb->controller, "SessReq while on B state\n");
+                        return IRQ_HANDLED;
+                }
+
+                dev_dbg(musb->controller, "SESSION_REQUEST (%s)\n",
+                        otg_state_string(musb->xceiv->state));
 
                 /* IRQ arrives from ID pin sense or (later, if VBUS power
                  * is removed) SRP.  responses are time critical:
@@ -563,7 +534,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                 musb->ep0_stage = MUSB_EP0_START;
                 musb->xceiv->state = OTG_STATE_A_IDLE;
                 MUSB_HST_MODE(musb);
-                musb_set_vbus(musb, 1);
+                musb_platform_set_vbus(musb, 1);
 
                 handled = IRQ_HANDLED;
         }
@@ -614,8 +585,8 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                         break;
                 }
 
-                DBG(1, "VBUS_ERROR in %s (%02x, %s), retry #%d, port1 %08x\n",
-                                otg_state_string(musb),
+                dev_dbg(musb->controller, "VBUS_ERROR in %s (%02x, %s), retry #%d, port1 %08x\n",
+                                otg_state_string(musb->xceiv->state),
                                 devctl,
                                 ({ char *s;
                                 switch (devctl & MUSB_DEVCTL_VBUS) {
@@ -634,14 +605,14 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
 
                 /* go through A_WAIT_VFALL then start a new session */
                 if (!ignore)
-                        musb_set_vbus(musb, 0);
+                        musb_platform_set_vbus(musb, 0);
                 handled = IRQ_HANDLED;
         }
 
 #endif
         if (int_usb & MUSB_INTR_SUSPEND) {
-                DBG(1, "SUSPEND (%s) devctl %02x power %02x\n",
-                                otg_state_string(musb), devctl, power);
+                dev_dbg(musb->controller, "SUSPEND (%s) devctl %02x power %02x\n",
+                        otg_state_string(musb->xceiv->state), devctl, power);
                 handled = IRQ_HANDLED;
 
                 switch (musb->xceiv->state) {
@@ -673,7 +644,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                         if (musb->is_active) {
 #ifdef  CONFIG_USB_MUSB_OTG
                                 musb->xceiv->state = OTG_STATE_B_WAIT_ACON;
-                                DBG(1, "HNP: Setting timer for b_ase0_brst\n");
+                                dev_dbg(musb->controller, "HNP: Setting timer for b_ase0_brst\n");
                                 mod_timer(&musb->otg_timer, jiffies
                                         + msecs_to_jiffies(
                                                         OTG_TIME_B_ASE0_BRST));
@@ -692,7 +663,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                         break;
                 case OTG_STATE_B_HOST:
                         /* Transition to B_PERIPHERAL, see 6.8.2.6 p 44 */
-                        DBG(1, "REVISIT: SUSPEND as B_HOST\n");
+                        dev_dbg(musb->controller, "REVISIT: SUSPEND as B_HOST\n");
                         break;
                 default:
                         /* "should not happen" */
@@ -735,14 +706,14 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                 switch (musb->xceiv->state) {
                 case OTG_STATE_B_PERIPHERAL:
                         if (int_usb & MUSB_INTR_SUSPEND) {
-                                DBG(1, "HNP: SUSPEND+CONNECT, now b_host\n");
+                                dev_dbg(musb->controller, "HNP: SUSPEND+CONNECT, now b_host\n");
                                 int_usb &= ~MUSB_INTR_SUSPEND;
                                 goto b_host;
                         } else
-                                DBG(1, "CONNECT as b_peripheral???\n");
+                                dev_dbg(musb->controller, "CONNECT as b_peripheral???\n");
                         break;
                 case OTG_STATE_B_WAIT_ACON:
-                        DBG(1, "HNP: CONNECT, now b_host\n");
+                        dev_dbg(musb->controller, "HNP: CONNECT, now b_host\n");
 b_host:
                         musb->xceiv->state = OTG_STATE_B_HOST;
                         hcd->self.is_b_host = 1;
@@ -765,14 +736,14 @@ b_host:
                 else
                         usb_hcd_resume_root_hub(hcd);
 
-                DBG(1, "CONNECT (%s) devctl %02x\n",
-                                otg_state_string(musb), devctl);
+                dev_dbg(musb->controller, "CONNECT (%s) devctl %02x\n",
+                                otg_state_string(musb->xceiv->state), devctl);
         }
 #endif  /* CONFIG_USB_MUSB_HDRC_HCD */
 
         if ((int_usb & MUSB_INTR_DISCONNECT) && !musb->ignore_disconnect) {
-                DBG(1, "DISCONNECT (%s) as %s, devctl %02x\n",
-                                otg_state_string(musb),
+                dev_dbg(musb->controller, "DISCONNECT (%s) as %s, devctl %02x\n",
+                                otg_state_string(musb->xceiv->state),
                                 MUSB_MODE(musb), devctl);
                 handled = IRQ_HANDLED;
 
@@ -815,7 +786,7 @@ b_host:
 #endif  /* GADGET */
                 default:
                         WARNING("unhandled DISCONNECT transition (%s)\n",
-                                otg_state_string(musb));
+                                otg_state_string(musb->xceiv->state));
                         break;
                 }
         }
@@ -834,13 +805,14 @@ b_host:
                          * stop the session.
                          */
                         if (devctl & (MUSB_DEVCTL_FSDEV | MUSB_DEVCTL_LSDEV))
-                                DBG(1, "BABBLE devctl: %02x\n", devctl);
+                                dev_dbg(musb->controller, "BABBLE devctl: %02x\n", devctl);
                         else {
                                 ERR("Stopping host session -- babble\n");
                                 musb_writeb(musb->mregs, MUSB_DEVCTL, 0);
                         }
                 } else if (is_peripheral_capable()) {
-                        DBG(1, "BUS RESET as %s\n", otg_state_string(musb));
+                        dev_dbg(musb->controller, "BUS RESET as %s\n",
+                                otg_state_string(musb->xceiv->state));
                         switch (musb->xceiv->state) {
 #ifdef CONFIG_USB_OTG
                         case OTG_STATE_A_SUSPEND:
@@ -853,9 +825,9 @@ b_host:
                                 /* FALLTHROUGH */
                         case OTG_STATE_A_WAIT_BCON:     /* OPT TD.4.7-900ms */
                                 /* never use invalid T(a_wait_bcon) */
-                                DBG(1, "HNP: in %s, %d msec timeout\n",
-                                                otg_state_string(musb),
-                                                TA_WAIT_BCON(musb));
+                                dev_dbg(musb->controller, "HNP: in %s, %d msec timeout\n",
+                                        otg_state_string(musb->xceiv->state),
+                                        TA_WAIT_BCON(musb));
                                 mod_timer(&musb->otg_timer, jiffies
                                         + msecs_to_jiffies(TA_WAIT_BCON(musb)));
                                 break;
@@ -865,8 +837,8 @@ b_host:
                                 musb_g_reset(musb);
                                 break;
                         case OTG_STATE_B_WAIT_ACON:
-                                DBG(1, "HNP: RESET (%s), to b_peripheral\n",
-                                        otg_state_string(musb));
+                                dev_dbg(musb->controller, "HNP: RESET (%s), to b_peripheral\n",
+                                        otg_state_string(musb->xceiv->state));
                                 musb->xceiv->state = OTG_STATE_B_PERIPHERAL;
                                 musb_g_reset(musb);
                                 break;
@@ -878,8 +850,8 @@ b_host:
                                 musb_g_reset(musb);
                                 break;
                         default:
-                                DBG(1, "Unhandled BUS RESET as %s\n",
-                                        otg_state_string(musb));
+                                dev_dbg(musb->controller, "Unhandled BUS RESET as %s\n",
+                                        otg_state_string(musb->xceiv->state));
                         }
                 }
         }
@@ -902,7 +874,7 @@ b_host:
                 u8 epnum;
                 u16 frame;
 
-                DBG(6, "START_OF_FRAME\n");
+                dev_dbg(musb->controller, "START_OF_FRAME\n");
                 handled = IRQ_HANDLED;
 
                 /* start any periodic Tx transfers waiting for current frame */
@@ -944,7 +916,7 @@ void musb_start(struct musb *musb)
         void __iomem    *regs = musb->mregs;
         u8              devctl = musb_readb(regs, MUSB_DEVCTL);
 
-        DBG(2, "<== devctl %02x\n", devctl);
+        dev_dbg(musb->controller, "<== devctl %02x\n", devctl);
 
         /*  Set INT enable registers, enable interrupts */
         musb_writew(regs, MUSB_INTRTXE, musb->epmask);
@@ -1021,7 +993,7 @@ void musb_stop(struct musb *musb)
         /* stop IRQs, timers, ... */
         musb_platform_disable(musb);
         musb_generic_disable(musb);
-        DBG(3, "HDRC disabled\n");
+        dev_dbg(musb->controller, "HDRC disabled\n");
 
         /* FIXME
          *  - mark host and/or peripheral drivers unusable/inactive
@@ -1038,13 +1010,18 @@ static void musb_shutdown(struct platform_device *pdev)
         struct musb     *musb = dev_to_musb(&pdev->dev);
         unsigned long   flags;
 
+        pm_runtime_get_sync(musb->controller);
         spin_lock_irqsave(&musb->lock, flags);
         musb_platform_disable(musb);
         musb_generic_disable(musb);
-        if (musb->clock)
-                clk_put(musb->clock);
         spin_unlock_irqrestore(&musb->lock, flags);
 
+        if (!is_otg_enabled(musb) && is_host_enabled(musb))
+                usb_remove_hcd(musb_to_hcd(musb));
+        musb_writeb(musb->mregs, MUSB_DEVCTL, 0);
+        musb_platform_exit(musb);
+
+        pm_runtime_put(musb->controller);
         /* FIXME power down */
 }
 
@@ -1061,10 +1038,11 @@ static void musb_shutdown(struct platform_device *pdev)
  * We don't currently use dynamic fifo setup capability to do anything
  * more than selecting one of a bunch of predefined configurations.
  */
-#if defined(CONFIG_USB_TUSB6010) || \
-        defined(CONFIG_ARCH_OMAP2430) || defined(CONFIG_ARCH_OMAP3) \
-        || defined(CONFIG_ARCH_OMAP4)
+#if defined(CONFIG_USB_MUSB_TUSB6010) || defined(CONFIG_USB_MUSB_OMAP2PLUS) \
+        || defined(CONFIG_USB_MUSB_AM35X)
 static ushort __initdata fifo_mode = 4;
+#elif defined(CONFIG_USB_MUSB_UX500)
+static ushort __initdata fifo_mode = 5;
 #else
 static ushort __initdata fifo_mode = 2;
 #endif
@@ -1361,7 +1339,7 @@ static int __init ep_config_from_hw(struct musb *musb)
         void *mbase = musb->mregs;
         int ret = 0;
 
-        DBG(2, "<== static silicon ep config\n");
+        dev_dbg(musb->controller, "<== static silicon ep config\n");
 
         /* FIXME pick up ep0 maxpacket size */
 
@@ -1488,7 +1466,7 @@ static int __init musb_core_init(u16 musb_type, struct musb *musb)
                 struct musb_hw_ep       *hw_ep = musb->endpoints + i;
 
                 hw_ep->fifo = MUSB_FIFO_OFFSET(i) + mbase;
-#ifdef CONFIG_USB_TUSB6010
+#ifdef CONFIG_USB_MUSB_TUSB6010
                 hw_ep->fifo_async = musb->async + 0x400 + MUSB_FIFO_OFFSET(i);
                 hw_ep->fifo_sync = musb->sync + 0x400 + MUSB_FIFO_OFFSET(i);
                 hw_ep->fifo_sync_va =
@@ -1508,7 +1486,7 @@ static int __init musb_core_init(u16 musb_type, struct musb *musb)
 #endif
 
                 if (hw_ep->max_packet_sz_tx) {
-                        DBG(1,
+                        dev_dbg(musb->controller,
                                 "%s: hw_ep %d%s, %smax %d\n",
                                 musb_driver_name, i,
                                 hw_ep->is_shared_fifo ? "shared" : "tx",
@@ -1517,7 +1495,7 @@ static int __init musb_core_init(u16 musb_type, struct musb *musb)
                                 hw_ep->max_packet_sz_tx);
                 }
                 if (hw_ep->max_packet_sz_rx && !hw_ep->is_shared_fifo) {
-                        DBG(1,
+                        dev_dbg(musb->controller,
                                 "%s: hw_ep %d%s, %smax %d\n",
                                 musb_driver_name, i,
                                 "rx",
@@ -1526,7 +1504,7 @@ static int __init musb_core_init(u16 musb_type, struct musb *musb)
                                 hw_ep->max_packet_sz_rx);
                 }
                 if (!(hw_ep->max_packet_sz_tx || hw_ep->max_packet_sz_rx))
-                        DBG(1, "hw_ep %d not configured\n", i);
+                        dev_dbg(musb->controller, "hw_ep %d not configured\n", i);
         }
 
         return 0;
@@ -1534,8 +1512,9 @@ static int __init musb_core_init(u16 musb_type, struct musb *musb)
 
 /*-------------------------------------------------------------------------*/
 
-#if defined(CONFIG_ARCH_OMAP2430) || defined(CONFIG_ARCH_OMAP3430) || \
-        defined(CONFIG_ARCH_OMAP4)
+#if defined(CONFIG_SOC_OMAP2430) || defined(CONFIG_SOC_OMAP3430) || \
+        defined(CONFIG_ARCH_OMAP4) || defined(CONFIG_ARCH_U8500) || \
+        defined(CONFIG_ARCH_U5500)
 
 static irqreturn_t generic_interrupt(int irq, void *__hci)
 {
@@ -1578,14 +1557,14 @@ irqreturn_t musb_interrupt(struct musb *musb)
         devctl = musb_readb(musb->mregs, MUSB_DEVCTL);
         power = musb_readb(musb->mregs, MUSB_POWER);
 
-        DBG(4, "** IRQ %s usb%04x tx%04x rx%04x\n",
+        dev_dbg(musb->controller, "** IRQ %s usb%04x tx%04x rx%04x\n",
                 (devctl & MUSB_DEVCTL_HM) ? "host" : "peripheral",
                 musb->int_usb, musb->int_tx, musb->int_rx);
 
 #ifdef CONFIG_USB_GADGET_MUSB_HDRC
         if (is_otg_enabled(musb) || is_peripheral_enabled(musb))
                 if (!musb->gadget_driver) {
-                        DBG(5, "No gadget driver loaded\n");
+                        dev_dbg(musb->controller, "No gadget driver loaded\n");
                         return IRQ_HANDLED;
                 }
 #endif
@@ -1650,7 +1629,7 @@ irqreturn_t musb_interrupt(struct musb *musb)
 
         return retval;
 }
-
+EXPORT_SYMBOL_GPL(musb_interrupt);
 
 #ifndef CONFIG_MUSB_PIO_ONLY
 static int __initdata use_dma = 1;
@@ -1714,7 +1693,7 @@ musb_mode_show(struct device *dev, struct device_attribute *attr, char *buf)
         int ret = -EINVAL;
 
         spin_lock_irqsave(&musb->lock, flags);
-        ret = sprintf(buf, "%s\n", otg_state_string(musb));
+        ret = sprintf(buf, "%s\n", otg_state_string(musb->xceiv->state));
         spin_unlock_irqrestore(&musb->lock, flags);
 
         return ret;
@@ -1867,6 +1846,7 @@ allocate_instance(struct device *dev,
         INIT_LIST_HEAD(&musb->out_bulk);
 
         hcd->uses_new_polling = 1;
+        hcd->has_tt = 1;
 
         musb->vbuserr_retry = VBUSERR_RETRY_COUNT;
         musb->a_wait_bcon = OTG_TIME_A_WAIT_BCON;
@@ -1874,10 +1854,9 @@ allocate_instance(struct device *dev,
         musb = kzalloc(sizeof *musb, GFP_KERNEL);
         if (!musb)
                 return NULL;
-        dev_set_drvdata(dev, musb);
 
 #endif
-
+        dev_set_drvdata(dev, musb);
         musb->mregs = mbase;
         musb->ctrl_base = mbase;
         musb->nIrq = -ENODEV;
@@ -1891,6 +1870,7 @@ allocate_instance(struct device *dev,
         }
 
         musb->controller = dev;
+
         return musb;
 }
 
@@ -1921,10 +1901,6 @@ static void musb_free(struct musb *musb)
                 dma_controller_destroy(c);
         }
 
-#ifdef CONFIG_USB_MUSB_OTG
-        put_device(musb->xceiv->dev);
-#endif
-
 #ifdef CONFIG_USB_MUSB_HDRC_HCD
         usb_put_hcd(musb_to_hcd(musb));
 #else
@@ -1956,31 +1932,6 @@ musb_init_controller(struct device *dev, int nIrq, void __iomem *ctrl)
                 goto fail0;
         }
 
-        switch (plat->mode) {
-        case MUSB_HOST:
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
-                break;
-#else
-                goto bad_config;
-#endif
-        case MUSB_PERIPHERAL:
-#ifdef CONFIG_USB_GADGET_MUSB_HDRC
-                break;
-#else
-                goto bad_config;
-#endif
-        case MUSB_OTG:
-#ifdef CONFIG_USB_MUSB_OTG
-                break;
-#else
-bad_config:
-#endif
-        default:
-                dev_err(dev, "incompatible Kconfig role setting\n");
-                status = -EINVAL;
-                goto fail0;
-        }
-
         /* allocate */
         musb = allocate_instance(dev, plat->config, ctrl);
         if (!musb) {
@@ -1988,33 +1939,21 @@ bad_config:
                 goto fail0;
         }
 
+        pm_runtime_use_autosuspend(musb->controller);
+        pm_runtime_set_autosuspend_delay(musb->controller, 200);
+        pm_runtime_enable(musb->controller);
+
         spin_lock_init(&musb->lock);
         musb->board_mode = plat->mode;
         musb->board_set_power = plat->set_power;
-        musb->set_clock = plat->set_clock;
         musb->min_power = plat->min_power;
-
-        /* Clock usage is chip-specific ... functional clock (DaVinci,
-         * OMAP2430), or PHY ref (some TUSB6010 boards).  All this core
-         * code does is make sure a clock handle is available; platform
-         * code manages it during start/stop and suspend/resume.
-         */
-        if (plat->clock) {
-                musb->clock = clk_get(dev, plat->clock);
-                if (IS_ERR(musb->clock)) {
-                        status = PTR_ERR(musb->clock);
-                        musb->clock = NULL;
-                        goto fail1;
-                }
-        }
+        musb->ops = plat->platform_ops;
 
         /* The musb_platform_init() call:
          *   - adjusts musb->mregs and musb->isr if needed,
          *   - may initialize an integrated tranceiver
          *   - initializes musb->xceiv, usually by otg_get_transceiver()
-         *   - activates clocks.
          *   - stops powering VBUS
-         *   - assigns musb->board_set_vbus if host mode is enabled
          *
          * There are various transciever configurations.  Blackfin,
          * DaVinci, TUSB60x0, and others integrate them.  OMAP3 uses
@@ -2022,9 +1961,9 @@ bad_config:
          * isp1504, non-OTG, etc) mostly hooking up through ULPI.
          */
         musb->isr = generic_interrupt;
-        status = musb_platform_init(musb, plat->board_data);
+        status = musb_platform_init(musb);
         if (status < 0)
-                goto fail2;
+                goto fail1;
 
         if (!musb->isr) {
                 status = -ENODEV;
@@ -2107,13 +2046,16 @@ bad_config:
          * Otherwise, wait till the gadget driver hooks up.
          */
         if (!is_otg_enabled(musb) && is_host_enabled(musb)) {
+                struct usb_hcd  *hcd = musb_to_hcd(musb);
+
                 MUSB_HST_MODE(musb);
                 musb->xceiv->default_a = 1;
                 musb->xceiv->state = OTG_STATE_A_IDLE;
 
                 status = usb_add_hcd(musb_to_hcd(musb), -1, 0);
 
-                DBG(1, "%s mode, status %d, devctl %02x %c\n",
+                hcd->self.uses_pio_for_control = 1;
+                dev_dbg(musb->controller, "%s mode, status %d, devctl %02x %c\n",
                         "HOST", status,
                         musb_readb(musb->mregs, MUSB_DEVCTL),
                         (musb_readb(musb->mregs, MUSB_DEVCTL)
@@ -2127,7 +2069,7 @@ bad_config:
 
                 status = musb_gadget_setup(musb);
 
-                DBG(1, "%s mode, status %d, dev%02x\n",
+                dev_dbg(musb->controller, "%s mode, status %d, dev%02x\n",
                         is_otg_enabled(musb) ? "OTG" : "PERIPHERAL",
                         status,
                         musb_readb(musb->mregs, MUSB_DEVCTL));
@@ -2136,6 +2078,8 @@ bad_config:
         if (status < 0)
                 goto fail3;
 
+        pm_runtime_put(musb->controller);
+
         status = musb_init_debugfs(musb);
         if (status < 0)
                 goto fail4;
@@ -2174,10 +2118,6 @@ fail3:
                 device_init_wakeup(dev, 0);
         musb_platform_exit(musb);
 
-fail2:
-        if (musb->clock)
-                clk_put(musb->clock);
-
 fail1:
         dev_err(musb->controller,
                 "musb_init_controller failed with status %d\n", status);
@@ -2203,13 +2143,13 @@ static u64	*orig_dma_mask;
 static int __init musb_probe(struct platform_device *pdev)
 {
         struct device   *dev = &pdev->dev;
-        int             irq = platform_get_irq(pdev, 0);
+        int             irq = platform_get_irq_byname(pdev, "mc");
         int             status;
         struct resource *iomem;
         void __iomem    *base;
 
         iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!iomem || irq == 0)
+        if (!iomem || irq <= 0)
                 return -ENODEV;
 
         base = ioremap(iomem->start, resource_size(iomem));
@@ -2239,16 +2179,11 @@ static int __exit musb_remove(struct platform_device *pdev)
          *  - Peripheral mode: peripheral is deactivated (or never-activated)
          *  - OTG mode: both roles are deactivated (or never-activated)
          */
+        pm_runtime_get_sync(musb->controller);
         musb_exit_debugfs(musb);
         musb_shutdown(pdev);
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
-        if (musb->board_mode == MUSB_HOST)
-                usb_remove_hcd(musb_to_hcd(musb));
-#endif
-        musb_writeb(musb->mregs, MUSB_DEVCTL, 0);
-        musb_platform_exit(musb);
-        musb_writeb(musb->mregs, MUSB_DEVCTL, 0);
 
+        pm_runtime_put(musb->controller);
         musb_free(musb);
         iounmap(ctrl_base);
         device_init_wakeup(&pdev->dev, 0);
@@ -2260,148 +2195,140 @@ static int __exit musb_remove(struct platform_device *pdev)
 
 #ifdef  CONFIG_PM
 
-static struct musb_context_registers musb_context;
-
-void musb_save_context(struct musb *musb)
+static void musb_save_context(struct musb *musb)
 {
         int i;
         void __iomem *musb_base = musb->mregs;
+        void __iomem *epio;
 
         if (is_host_enabled(musb)) {
-                musb_context.frame = musb_readw(musb_base, MUSB_FRAME);
-                musb_context.testmode = musb_readb(musb_base, MUSB_TESTMODE);
-                musb_context.busctl = musb_read_ulpi_buscontrol(musb->mregs);
+                musb->context.frame = musb_readw(musb_base, MUSB_FRAME);
+                musb->context.testmode = musb_readb(musb_base, MUSB_TESTMODE);
+                musb->context.busctl = musb_read_ulpi_buscontrol(musb->mregs);
         }
-        musb_context.power = musb_readb(musb_base, MUSB_POWER);
-        musb_context.intrtxe = musb_readw(musb_base, MUSB_INTRTXE);
-        musb_context.intrrxe = musb_readw(musb_base, MUSB_INTRRXE);
-        musb_context.intrusbe = musb_readb(musb_base, MUSB_INTRUSBE);
-        musb_context.index = musb_readb(musb_base, MUSB_INDEX);
-        musb_context.devctl = musb_readb(musb_base, MUSB_DEVCTL);
-
-        for (i = 0; i < MUSB_C_NUM_EPS; ++i) {
-                musb_writeb(musb_base, MUSB_INDEX, i);
-                musb_context.index_regs[i].txmaxp =
-                        musb_readw(musb_base, 0x10 + MUSB_TXMAXP);
-                musb_context.index_regs[i].txcsr =
-                        musb_readw(musb_base, 0x10 + MUSB_TXCSR);
-                musb_context.index_regs[i].rxmaxp =
-                        musb_readw(musb_base, 0x10 + MUSB_RXMAXP);
-                musb_context.index_regs[i].rxcsr =
-                        musb_readw(musb_base, 0x10 + MUSB_RXCSR);
+        musb->context.power = musb_readb(musb_base, MUSB_POWER);
+        musb->context.intrtxe = musb_readw(musb_base, MUSB_INTRTXE);
+        musb->context.intrrxe = musb_readw(musb_base, MUSB_INTRRXE);
+        musb->context.intrusbe = musb_readb(musb_base, MUSB_INTRUSBE);
+        musb->context.index = musb_readb(musb_base, MUSB_INDEX);
+        musb->context.devctl = musb_readb(musb_base, MUSB_DEVCTL);
+
+        for (i = 0; i < musb->config->num_eps; ++i) {
+                epio = musb->endpoints[i].regs;
+                musb->context.index_regs[i].txmaxp =
+                        musb_readw(epio, MUSB_TXMAXP);
+                musb->context.index_regs[i].txcsr =
+                        musb_readw(epio, MUSB_TXCSR);
+                musb->context.index_regs[i].rxmaxp =
+                        musb_readw(epio, MUSB_RXMAXP);
+                musb->context.index_regs[i].rxcsr =
+                        musb_readw(epio, MUSB_RXCSR);
 
                 if (musb->dyn_fifo) {
-                        musb_context.index_regs[i].txfifoadd =
+                        musb->context.index_regs[i].txfifoadd =
                                         musb_read_txfifoadd(musb_base);
-                        musb_context.index_regs[i].rxfifoadd =
+                        musb->context.index_regs[i].rxfifoadd =
                                         musb_read_rxfifoadd(musb_base);
-                        musb_context.index_regs[i].txfifosz =
+                        musb->context.index_regs[i].txfifosz =
                                         musb_read_txfifosz(musb_base);
-                        musb_context.index_regs[i].rxfifosz =
+                        musb->context.index_regs[i].rxfifosz =
                                         musb_read_rxfifosz(musb_base);
                 }
                 if (is_host_enabled(musb)) {
-                        musb_context.index_regs[i].txtype =
-                                musb_readb(musb_base, 0x10 + MUSB_TXTYPE);
-                        musb_context.index_regs[i].txinterval =
-                                musb_readb(musb_base, 0x10 + MUSB_TXINTERVAL);
-                        musb_context.index_regs[i].rxtype =
-                                musb_readb(musb_base, 0x10 + MUSB_RXTYPE);
-                        musb_context.index_regs[i].rxinterval =
-                                musb_readb(musb_base, 0x10 + MUSB_RXINTERVAL);
-
-                        musb_context.index_regs[i].txfunaddr =
+                        musb->context.index_regs[i].txtype =
+                                musb_readb(epio, MUSB_TXTYPE);
+                        musb->context.index_regs[i].txinterval =
+                                musb_readb(epio, MUSB_TXINTERVAL);
+                        musb->context.index_regs[i].rxtype =
+                                musb_readb(epio, MUSB_RXTYPE);
+                        musb->context.index_regs[i].rxinterval =
+                                musb_readb(epio, MUSB_RXINTERVAL);
+
+                        musb->context.index_regs[i].txfunaddr =
                                 musb_read_txfunaddr(musb_base, i);
-                        musb_context.index_regs[i].txhubaddr =
+                        musb->context.index_regs[i].txhubaddr =
                                 musb_read_txhubaddr(musb_base, i);
-                        musb_context.index_regs[i].txhubport =
+                        musb->context.index_regs[i].txhubport =
                                 musb_read_txhubport(musb_base, i);
 
-                        musb_context.index_regs[i].rxfunaddr =
+                        musb->context.index_regs[i].rxfunaddr =
                                 musb_read_rxfunaddr(musb_base, i);
-                        musb_context.index_regs[i].rxhubaddr =
+                        musb->context.index_regs[i].rxhubaddr =
                                 musb_read_rxhubaddr(musb_base, i);
-                        musb_context.index_regs[i].rxhubport =
+                        musb->context.index_regs[i].rxhubport =
                                 musb_read_rxhubport(musb_base, i);
                 }
         }
-
-        musb_writeb(musb_base, MUSB_INDEX, musb_context.index);
-
-        musb_platform_save_context(musb, &musb_context);
 }
 
-void musb_restore_context(struct musb *musb)
+static void musb_restore_context(struct musb *musb)
 {
         int i;
         void __iomem *musb_base = musb->mregs;
         void __iomem *ep_target_regs;
-
-        musb_platform_restore_context(musb, &musb_context);
+        void __iomem *epio;
 
         if (is_host_enabled(musb)) {
-                musb_writew(musb_base, MUSB_FRAME, musb_context.frame);
-                musb_writeb(musb_base, MUSB_TESTMODE, musb_context.testmode);
-                musb_write_ulpi_buscontrol(musb->mregs, musb_context.busctl);
+                musb_writew(musb_base, MUSB_FRAME, musb->context.frame);
+                musb_writeb(musb_base, MUSB_TESTMODE, musb->context.testmode);
+                musb_write_ulpi_buscontrol(musb->mregs, musb->context.busctl);
         }
-        musb_writeb(musb_base, MUSB_POWER, musb_context.power);
-        musb_writew(musb_base, MUSB_INTRTXE, musb_context.intrtxe);
-        musb_writew(musb_base, MUSB_INTRRXE, musb_context.intrrxe);
-        musb_writeb(musb_base, MUSB_INTRUSBE, musb_context.intrusbe);
-        musb_writeb(musb_base, MUSB_DEVCTL, musb_context.devctl);
-
-        for (i = 0; i < MUSB_C_NUM_EPS; ++i) {
-                musb_writeb(musb_base, MUSB_INDEX, i);
-                musb_writew(musb_base, 0x10 + MUSB_TXMAXP,
-                        musb_context.index_regs[i].txmaxp);
-                musb_writew(musb_base, 0x10 + MUSB_TXCSR,
-                        musb_context.index_regs[i].txcsr);
-                musb_writew(musb_base, 0x10 + MUSB_RXMAXP,
-                        musb_context.index_regs[i].rxmaxp);
-                musb_writew(musb_base, 0x10 + MUSB_RXCSR,
-                        musb_context.index_regs[i].rxcsr);
+        musb_writeb(musb_base, MUSB_POWER, musb->context.power);
+        musb_writew(musb_base, MUSB_INTRTXE, musb->context.intrtxe);
+        musb_writew(musb_base, MUSB_INTRRXE, musb->context.intrrxe);
+        musb_writeb(musb_base, MUSB_INTRUSBE, musb->context.intrusbe);
+        musb_writeb(musb_base, MUSB_DEVCTL, musb->context.devctl);
+
+        for (i = 0; i < musb->config->num_eps; ++i) {
+                epio = musb->endpoints[i].regs;
+                musb_writew(epio, MUSB_TXMAXP,
+                        musb->context.index_regs[i].txmaxp);
+                musb_writew(epio, MUSB_TXCSR,
+                        musb->context.index_regs[i].txcsr);
+                musb_writew(epio, MUSB_RXMAXP,
+                        musb->context.index_regs[i].rxmaxp);
+                musb_writew(epio, MUSB_RXCSR,
+                        musb->context.index_regs[i].rxcsr);
 
                 if (musb->dyn_fifo) {
                         musb_write_txfifosz(musb_base,
-                                musb_context.index_regs[i].txfifosz);
+                                musb->context.index_regs[i].txfifosz);
                         musb_write_rxfifosz(musb_base,
-                                musb_context.index_regs[i].rxfifosz);
+                                musb->context.index_regs[i].rxfifosz);
                         musb_write_txfifoadd(musb_base,
-                                musb_context.index_regs[i].txfifoadd);
+                                musb->context.index_regs[i].txfifoadd);
                         musb_write_rxfifoadd(musb_base,
-                                musb_context.index_regs[i].rxfifoadd);
+                                musb->context.index_regs[i].rxfifoadd);
                 }
 
                 if (is_host_enabled(musb)) {
-                        musb_writeb(musb_base, 0x10 + MUSB_TXTYPE,
-                                musb_context.index_regs[i].txtype);
-                        musb_writeb(musb_base, 0x10 + MUSB_TXINTERVAL,
-                                musb_context.index_regs[i].txinterval);
-                        musb_writeb(musb_base, 0x10 + MUSB_RXTYPE,
-                                musb_context.index_regs[i].rxtype);
-                        musb_writeb(musb_base, 0x10 + MUSB_RXINTERVAL,
-
-                        musb_context.index_regs[i].rxinterval);
+                        musb_writeb(epio, MUSB_TXTYPE,
+                                musb->context.index_regs[i].txtype);
+                        musb_writeb(epio, MUSB_TXINTERVAL,
+                                musb->context.index_regs[i].txinterval);
+                        musb_writeb(epio, MUSB_RXTYPE,
+                                musb->context.index_regs[i].rxtype);
+                        musb_writeb(epio, MUSB_RXINTERVAL,
+
+                        musb->context.index_regs[i].rxinterval);
                         musb_write_txfunaddr(musb_base, i,
-                                musb_context.index_regs[i].txfunaddr);
+                                musb->context.index_regs[i].txfunaddr);
                         musb_write_txhubaddr(musb_base, i,
-                                musb_context.index_regs[i].txhubaddr);
+                                musb->context.index_regs[i].txhubaddr);
                         musb_write_txhubport(musb_base, i,
-                                musb_context.index_regs[i].txhubport);
+                                musb->context.index_regs[i].txhubport);
 
                         ep_target_regs =
                                 musb_read_target_reg_base(i, musb_base);
 
                         musb_write_rxfunaddr(ep_target_regs,
-                                musb_context.index_regs[i].rxfunaddr);
+                                musb->context.index_regs[i].rxfunaddr);
                         musb_write_rxhubaddr(ep_target_regs,
-                                musb_context.index_regs[i].rxhubaddr);
+                                musb->context.index_regs[i].rxhubaddr);
                         musb_write_rxhubport(ep_target_regs,
-                                musb_context.index_regs[i].rxhubport);
+                                musb->context.index_regs[i].rxhubport);
                 }
         }
-
-        musb_writeb(musb_base, MUSB_INDEX, musb_context.index);
 }
 
 static int musb_suspend(struct device *dev)
@@ -2410,9 +2337,6 @@ static int musb_suspend(struct device *dev)
         unsigned long   flags;
         struct musb     *musb = dev_to_musb(&pdev->dev);
 
-        if (!musb->clock)
-                return 0;
-
         spin_lock_irqsave(&musb->lock, flags);
 
         if (is_peripheral_active(musb)) {
@@ -2427,10 +2351,6 @@ static int musb_suspend(struct device *dev)
 
         musb_save_context(musb);
 
-        if (musb->set_clock)
-                musb->set_clock(musb->clock, 0);
-        else
-                clk_disable(musb->clock);
         spin_unlock_irqrestore(&musb->lock, flags);
         return 0;
 }
@@ -2440,14 +2360,6 @@ static int musb_resume_noirq(struct device *dev)
         struct platform_device *pdev = to_platform_device(dev);
         struct musb     *musb = dev_to_musb(&pdev->dev);
 
-        if (!musb->clock)
-                return 0;
-
-        if (musb->set_clock)
-                musb->set_clock(musb->clock, 1);
-        else
-                clk_enable(musb->clock);
-
         musb_restore_context(musb);
 
         /* for static cmos like DaVinci, register values were preserved
@@ -2457,9 +2369,41 @@ static int musb_resume_noirq(struct device *dev)
         return 0;
 }
 
+static int musb_runtime_suspend(struct device *dev)
+{
+        struct musb     *musb = dev_to_musb(dev);
+
+        musb_save_context(musb);
+
+        return 0;
+}
+
+static int musb_runtime_resume(struct device *dev)
+{
+        struct musb     *musb = dev_to_musb(dev);
+        static int      first = 1;
+
+        /*
+         * When pm_runtime_get_sync called for the first time in driver
+         * init,  some of the structure is still not initialized which is
+         * used in restore function. But clock needs to be
+         * enabled before any register access, so
+         * pm_runtime_get_sync has to be called.
+         * Also context restore without save does not make
+         * any sense
+         */
+        if (!first)
+                musb_restore_context(musb);
+        first = 0;
+
+        return 0;
+}
+
 static const struct dev_pm_ops musb_dev_pm_ops = {
         .suspend        = musb_suspend,
         .resume_noirq   = musb_resume_noirq,
+        .runtime_suspend = musb_runtime_suspend,
+        .runtime_resume = musb_runtime_resume,
 };
 
 #define MUSB_DEV_PM_OPS (&musb_dev_pm_ops)
@@ -2496,6 +2440,8 @@ static int __init musb_init(void)
                 "musb-dma"
 #elif defined(CONFIG_USB_TUSB_OMAP_DMA)
                 "tusb-omap-dma"
+#elif defined(CONFIG_USB_UX500_DMA)
+                "ux500-dma"
 #else
                 "?dma?"
 #endif
@@ -2507,8 +2453,8 @@ static int __init musb_init(void)
 #elif defined(CONFIG_USB_MUSB_HDRC_HCD)
                 "host"
 #endif
-                ", debug=%d\n",
-                musb_driver_name, musb_debug);
+                ,
+                musb_driver_name);
         return platform_driver_probe(&musb_driver, musb_probe);
 }
 
diff --git a/drivers/usb/musb/musb_core.h b/drivers/usb/musb/musb_core.h
index 91d67794e350..0e053b587960 100644
--- a/drivers/usb/musb/musb_core.h
+++ b/drivers/usb/musb/musb_core.h
@@ -212,8 +212,8 @@ enum musb_g_ep0_state {
  * directly with the "flat" model, or after setting up an index register.
  */
 
-#if defined(CONFIG_ARCH_DAVINCI) || defined(CONFIG_ARCH_OMAP2430) \
-                || defined(CONFIG_ARCH_OMAP3430) || defined(CONFIG_BLACKFIN) \
+#if defined(CONFIG_ARCH_DAVINCI) || defined(CONFIG_SOC_OMAP2430) \
+                || defined(CONFIG_SOC_OMAP3430) || defined(CONFIG_BLACKFIN) \
                 || defined(CONFIG_ARCH_OMAP4)
 /* REVISIT indexed access seemed to
  * misbehave (on DaVinci) for at least peripheral IN ...
@@ -222,7 +222,7 @@ enum musb_g_ep0_state {
 #endif
 
 /* TUSB mapping: "flat" plus ep0 special cases */
-#if     defined(CONFIG_USB_TUSB6010)
+#if     defined(CONFIG_USB_MUSB_TUSB6010)
 #define musb_ep_select(_mbase, _epnum) \
         musb_writeb((_mbase), MUSB_INDEX, (_epnum))
 #define MUSB_EP_OFFSET                  MUSB_TUSB_OFFSET
@@ -253,6 +253,34 @@ enum musb_g_ep0_state {
 
 /******************************** TYPES *************************************/
 
+/**
+ * struct musb_platform_ops - Operations passed to musb_core by HW glue layer
+ * @init:       turns on clocks, sets up platform-specific registers, etc
+ * @exit:       undoes @init
+ * @set_mode:   forcefully changes operating mode
+ * @try_ilde:   tries to idle the IP
+ * @vbus_status: returns vbus status if possible
+ * @set_vbus:   forces vbus status
+ * @channel_program: pre check for standard dma channel_program func
+ */
+struct musb_platform_ops {
+        int     (*init)(struct musb *musb);
+        int     (*exit)(struct musb *musb);
+
+        void    (*enable)(struct musb *musb);
+        void    (*disable)(struct musb *musb);
+
+        int     (*set_mode)(struct musb *musb, u8 mode);
+        void    (*try_idle)(struct musb *musb, unsigned long timeout);
+
+        int     (*vbus_status)(struct musb *musb);
+        void    (*set_vbus)(struct musb *musb, int on);
+
+        int     (*adjust_channel_params)(struct dma_channel *channel,
+                                u16 packet_sz, u8 *mode,
+                                dma_addr_t *dma_addr, u32 *len);
+};
+
 /*
  * struct musb_hw_ep - endpoint hardware (bidirectional)
  *
@@ -263,7 +291,7 @@ struct musb_hw_ep {
         void __iomem            *fifo;
         void __iomem            *regs;
 
-#ifdef CONFIG_USB_TUSB6010
+#ifdef CONFIG_USB_MUSB_TUSB6010
         void __iomem            *conf;
 #endif
 
@@ -280,7 +308,7 @@ struct musb_hw_ep {
         struct dma_channel      *tx_channel;
         struct dma_channel      *rx_channel;
 
-#ifdef CONFIG_USB_TUSB6010
+#ifdef CONFIG_USB_MUSB_TUSB6010
         /* TUSB has "asynchronous" and "synchronous" dma modes */
         dma_addr_t              fifo_async;
         dma_addr_t              fifo_sync;
@@ -305,7 +333,7 @@ struct musb_hw_ep {
 #endif
 };
 
-static inline struct usb_request *next_in_request(struct musb_hw_ep *hw_ep)
+static inline struct musb_request *next_in_request(struct musb_hw_ep *hw_ep)
 {
 #ifdef CONFIG_USB_GADGET_MUSB_HDRC
         return next_request(&hw_ep->ep_in);
@@ -314,7 +342,7 @@ static inline struct usb_request *next_in_request(struct musb_hw_ep *hw_ep)
 #endif
 }
 
-static inline struct usb_request *next_out_request(struct musb_hw_ep *hw_ep)
+static inline struct musb_request *next_out_request(struct musb_hw_ep *hw_ep)
 {
 #ifdef CONFIG_USB_GADGET_MUSB_HDRC
         return next_request(&hw_ep->ep_out);
@@ -323,13 +351,39 @@ static inline struct usb_request *next_out_request(struct musb_hw_ep *hw_ep)
 #endif
 }
 
+struct musb_csr_regs {
+        /* FIFO registers */
+        u16 txmaxp, txcsr, rxmaxp, rxcsr;
+        u16 rxfifoadd, txfifoadd;
+        u8 txtype, txinterval, rxtype, rxinterval;
+        u8 rxfifosz, txfifosz;
+        u8 txfunaddr, txhubaddr, txhubport;
+        u8 rxfunaddr, rxhubaddr, rxhubport;
+};
+
+struct musb_context_registers {
+
+        u8 power;
+        u16 intrtxe, intrrxe;
+        u8 intrusbe;
+        u16 frame;
+        u8 index, testmode;
+
+        u8 devctl, busctl, misc;
+
+        struct musb_csr_regs index_regs[MUSB_C_NUM_EPS];
+};
+
 /*
  * struct musb - Driver instance data.
  */
 struct musb {
         /* device lock */
         spinlock_t              lock;
-        struct clk              *clock;
+
+        const struct musb_platform_ops *ops;
+        struct musb_context_registers context;
+
         irqreturn_t             (*isr)(int, void *);
         struct work_struct      irq_work;
         u16                     hwvers;
@@ -358,11 +412,7 @@ struct musb {
 
         struct timer_list       otg_timer;
 #endif
-
-        /* called with IRQs blocked; ON/nonzero implies starting a session,
-         * and waiting at least a_wait_vrise_tmout.
-         */
-        void                    (*board_set_vbus)(struct musb *, int is_on);
+        struct notifier_block   nb;
 
         struct dma_controller   *dma_controller;
 
@@ -370,7 +420,7 @@ struct musb {
         void __iomem            *ctrl_base;
         void __iomem            *mregs;
 
-#ifdef CONFIG_USB_TUSB6010
+#ifdef CONFIG_USB_MUSB_TUSB6010
         dma_addr_t              async;
         dma_addr_t              sync;
         void __iomem            *sync_va;
@@ -397,8 +447,6 @@ struct musb {
         u8 board_mode;          /* enum musb_mode */
         int                     (*board_set_power)(int state);
 
-        int                     (*set_clock)(struct clk *clk, int is_active);
-
         u8                      min_power;      /* vbus for periph, in mA/2 */
 
         bool                    is_host;
@@ -450,6 +498,19 @@ struct musb {
         struct usb_gadget_driver *gadget_driver;        /* its driver */
 #endif
 
+        /*
+         * FIXME: Remove this flag.
+         *
+         * This is only added to allow Blackfin to work
+         * with current driver. For some unknown reason
+         * Blackfin doesn't work with double buffering
+         * and that's enabled by default.
+         *
+         * We added this flag to forcefully disable double
+         * buffering until we get it working.
+         */
+        unsigned                double_buffer_not_ok:1 __deprecated;
+
         struct musb_hdrc_config *config;
 
 #ifdef MUSB_CONFIG_PROC_FS
@@ -457,52 +518,6 @@ struct musb {
 #endif
 };
 
-#ifdef CONFIG_PM
-struct musb_csr_regs {
-        /* FIFO registers */
-        u16 txmaxp, txcsr, rxmaxp, rxcsr;
-        u16 rxfifoadd, txfifoadd;
-        u8 txtype, txinterval, rxtype, rxinterval;
-        u8 rxfifosz, txfifosz;
-        u8 txfunaddr, txhubaddr, txhubport;
-        u8 rxfunaddr, rxhubaddr, rxhubport;
-};
-
-struct musb_context_registers {
-
-#if defined(CONFIG_ARCH_OMAP2430) || defined(CONFIG_ARCH_OMAP3) || \
-    defined(CONFIG_ARCH_OMAP4)
-        u32 otg_sysconfig, otg_forcestandby;
-#endif
-        u8 power;
-        u16 intrtxe, intrrxe;
-        u8 intrusbe;
-        u16 frame;
-        u8 index, testmode;
-
-        u8 devctl, busctl, misc;
-
-        struct musb_csr_regs index_regs[MUSB_C_NUM_EPS];
-};
-
-#if defined(CONFIG_ARCH_OMAP2430) || defined(CONFIG_ARCH_OMAP3) || \
-    defined(CONFIG_ARCH_OMAP4)
-extern void musb_platform_save_context(struct musb *musb,
-                struct musb_context_registers *musb_context);
-extern void musb_platform_restore_context(struct musb *musb,
-                struct musb_context_registers *musb_context);
-#else
-#define musb_platform_save_context(m, x)        do {} while (0)
-#define musb_platform_restore_context(m, x)     do {} while (0)
-#endif
-
-#endif
-
-static inline void musb_set_vbus(struct musb *musb, int is_on)
-{
-        musb->board_set_vbus(musb, is_on);
-}
-
 #ifdef CONFIG_USB_GADGET_MUSB_HDRC
 static inline struct musb *gadget_to_musb(struct usb_gadget *g)
 {
@@ -591,28 +606,63 @@ extern void musb_load_testpacket(struct musb *);
 
 extern irqreturn_t musb_interrupt(struct musb *);
 
-extern void musb_platform_enable(struct musb *musb);
-extern void musb_platform_disable(struct musb *musb);
-
 extern void musb_hnp_stop(struct musb *musb);
 
-extern int musb_platform_set_mode(struct musb *musb, u8 musb_mode);
+static inline void musb_platform_set_vbus(struct musb *musb, int is_on)
+{
+        if (musb->ops->set_vbus)
+                musb->ops->set_vbus(musb, is_on);
+}
 
-#if defined(CONFIG_USB_TUSB6010) || defined(CONFIG_BLACKFIN) || \
-        defined(CONFIG_ARCH_OMAP2430) || defined(CONFIG_ARCH_OMAP3) || \
-        defined(CONFIG_ARCH_OMAP4)
-extern void musb_platform_try_idle(struct musb *musb, unsigned long timeout);
-#else
-#define musb_platform_try_idle(x, y)            do {} while (0)
-#endif
+static inline void musb_platform_enable(struct musb *musb)
+{
+        if (musb->ops->enable)
+                musb->ops->enable(musb);
+}
 
-#if defined(CONFIG_USB_TUSB6010) || defined(CONFIG_BLACKFIN)
-extern int musb_platform_get_vbus_status(struct musb *musb);
-#else
-#define musb_platform_get_vbus_status(x)        0
-#endif
+static inline void musb_platform_disable(struct musb *musb)
+{
+        if (musb->ops->disable)
+                musb->ops->disable(musb);
+}
+
+static inline int musb_platform_set_mode(struct musb *musb, u8 mode)
+{
+        if (!musb->ops->set_mode)
+                return 0;
+
+        return musb->ops->set_mode(musb, mode);
+}
+
+static inline void musb_platform_try_idle(struct musb *musb,
+                unsigned long timeout)
+{
+        if (musb->ops->try_idle)
+                musb->ops->try_idle(musb, timeout);
+}
 
-extern int __init musb_platform_init(struct musb *musb, void *board_data);
-extern int musb_platform_exit(struct musb *musb);
+static inline int musb_platform_get_vbus_status(struct musb *musb)
+{
+        if (!musb->ops->vbus_status)
+                return 0;
+
+        return musb->ops->vbus_status(musb);
+}
+
+static inline int musb_platform_init(struct musb *musb)
+{
+        if (!musb->ops->init)
+                return -EINVAL;
+
+        return musb->ops->init(musb);
+}
+
+static inline int musb_platform_exit(struct musb *musb)
+{
+        if (!musb->ops->exit)
+                return -EINVAL;
+
+        return musb->ops->exit(musb);
+}
 
 #endif  /* __MUSB_CORE_H__ */
diff --git a/drivers/usb/musb/musb_debug.h b/drivers/usb/musb/musb_debug.h
index d73afdbde3ee..742eada5002e 100644
--- a/drivers/usb/musb/musb_debug.h
+++ b/drivers/usb/musb/musb_debug.h
@@ -42,23 +42,6 @@
 #define INFO(fmt, args...) yprintk(KERN_INFO, fmt, ## args)
 #define ERR(fmt, args...) yprintk(KERN_ERR, fmt, ## args)
 
-#define xprintk(level, facility, format, args...) do { \
-        if (_dbg_level(level)) { \
-                printk(facility "%s %d: " format , \
-                                __func__, __LINE__ , ## args); \
-        } } while (0)
-
-extern unsigned musb_debug;
-
-static inline int _dbg_level(unsigned l)
-{
-        return musb_debug >= l;
-}
-
-#define DBG(level, fmt, args...) xprintk(level, KERN_DEBUG, fmt, ## args)
-
-extern const char *otg_state_string(struct musb *);
-
 #ifdef CONFIG_DEBUG_FS
 extern int musb_init_debugfs(struct musb *musb);
 extern void musb_exit_debugfs(struct musb *musb);
diff --git a/drivers/usb/musb/musb_debugfs.c b/drivers/usb/musb/musb_debugfs.c
index 9e8639d4e862..b0176e4569e0 100644
--- a/drivers/usb/musb/musb_debugfs.c
+++ b/drivers/usb/musb/musb_debugfs.c
@@ -36,7 +36,6 @@
 #include <linux/sched.h>
 #include <linux/init.h>
 #include <linux/list.h>
-#include <linux/kobject.h>
 #include <linux/platform_device.h>
 #include <linux/io.h>
 #include <linux/debugfs.h>
diff --git a/drivers/usb/musb/musb_dma.h b/drivers/usb/musb/musb_dma.h
index 916065ba9e70..3a97c4e2d4f5 100644
--- a/drivers/usb/musb/musb_dma.h
+++ b/drivers/usb/musb/musb_dma.h
@@ -169,6 +169,9 @@ struct dma_controller {
                                                         dma_addr_t dma_addr,
                                                         u32 length);
         int                     (*channel_abort)(struct dma_channel *);
+        int                     (*is_compatible)(struct dma_channel *channel,
+                                                        u16 maxpacket,
+                                                        void *buf, u32 length);
 };
 
 /* called after channel_program(), may indicate a fault */
diff --git a/drivers/usb/musb/musb_gadget.c b/drivers/usb/musb/musb_gadget.c
index d065e23f123e..6aeb363e63e7 100644
--- a/drivers/usb/musb/musb_gadget.c
+++ b/drivers/usb/musb/musb_gadget.c
@@ -92,6 +92,84 @@
 
 /* ----------------------------------------------------------------------- */
 
+#define is_buffer_mapped(req) (is_dma_capable() && \
+                                        (req->map_state != UN_MAPPED))
+
+/* Maps the buffer to dma  */
+
+static inline void map_dma_buffer(struct musb_request *request,
+                        struct musb *musb, struct musb_ep *musb_ep)
+{
+        int compatible = true;
+        struct dma_controller *dma = musb->dma_controller;
+
+        request->map_state = UN_MAPPED;
+
+        if (!is_dma_capable() || !musb_ep->dma)
+                return;
+
+        /* Check if DMA engine can handle this request.
+         * DMA code must reject the USB request explicitly.
+         * Default behaviour is to map the request.
+         */
+        if (dma->is_compatible)
+                compatible = dma->is_compatible(musb_ep->dma,
+                                musb_ep->packet_sz, request->request.buf,
+                                request->request.length);
+        if (!compatible)
+                return;
+
+        if (request->request.dma == DMA_ADDR_INVALID) {
+                request->request.dma = dma_map_single(
+                                musb->controller,
+                                request->request.buf,
+                                request->request.length,
+                                request->tx
+                                        ? DMA_TO_DEVICE
+                                        : DMA_FROM_DEVICE);
+                request->map_state = MUSB_MAPPED;
+        } else {
+                dma_sync_single_for_device(musb->controller,
+                        request->request.dma,
+                        request->request.length,
+                        request->tx
+                                ? DMA_TO_DEVICE
+                                : DMA_FROM_DEVICE);
+                request->map_state = PRE_MAPPED;
+        }
+}
+
+/* Unmap the buffer from dma and maps it back to cpu */
+static inline void unmap_dma_buffer(struct musb_request *request,
+                                struct musb *musb)
+{
+        if (!is_buffer_mapped(request))
+                return;
+
+        if (request->request.dma == DMA_ADDR_INVALID) {
+                dev_vdbg(musb->controller,
+                                "not unmapping a never mapped buffer\n");
+                return;
+        }
+        if (request->map_state == MUSB_MAPPED) {
+                dma_unmap_single(musb->controller,
+                        request->request.dma,
+                        request->request.length,
+                        request->tx
+                                ? DMA_TO_DEVICE
+                                : DMA_FROM_DEVICE);
+                request->request.dma = DMA_ADDR_INVALID;
+        } else { /* PRE_MAPPED */
+                dma_sync_single_for_cpu(musb->controller,
+                        request->request.dma,
+                        request->request.length,
+                        request->tx
+                                ? DMA_TO_DEVICE
+                                : DMA_FROM_DEVICE);
+        }
+        request->map_state = UN_MAPPED;
+}
+
 /*
  * Immediately complete a request.
  *
@@ -112,37 +190,20 @@ __acquires(ep->musb->lock)
 
         req = to_musb_request(request);
 
-        list_del(&request->list);
+        list_del(&req->list);
         if (req->request.status == -EINPROGRESS)
                 req->request.status = status;
         musb = req->musb;
 
         ep->busy = 1;
         spin_unlock(&musb->lock);
-        if (is_dma_capable()) {
-                if (req->mapped) {
-                        dma_unmap_single(musb->controller,
-                                        req->request.dma,
-                                        req->request.length,
-                                        req->tx
-                                                ? DMA_TO_DEVICE
-                                                : DMA_FROM_DEVICE);
-                        req->request.dma = DMA_ADDR_INVALID;
-                        req->mapped = 0;
-                } else if (req->request.dma != DMA_ADDR_INVALID)
-                        dma_sync_single_for_cpu(musb->controller,
-                                        req->request.dma,
-                                        req->request.length,
-                                        req->tx
-                                                ? DMA_TO_DEVICE
-                                                : DMA_FROM_DEVICE);
-        }
+        unmap_dma_buffer(req, musb);
         if (request->status == 0)
-                DBG(5, "%s done request %p,  %d/%d\n",
+                dev_dbg(musb->controller, "%s done request %p,  %d/%d\n",
                                 ep->end_point.name, request,
                                 req->request.actual, req->request.length);
         else
-                DBG(2, "%s request %p, %d/%d fault %d\n",
+                dev_dbg(musb->controller, "%s request %p, %d/%d fault %d\n",
                                 ep->end_point.name, request,
                                 req->request.actual, req->request.length,
                                 request->status);
@@ -159,6 +220,7 @@ __acquires(ep->musb->lock)
  */
 static void nuke(struct musb_ep *ep, const int status)
 {
+        struct musb             *musb = ep->musb;
         struct musb_request     *req = NULL;
         void __iomem *epio = ep->musb->endpoints[ep->current_epnum].regs;
 
@@ -186,14 +248,14 @@ static void nuke(struct musb_ep *ep, const int status)
                 }
 
                 value = c->channel_abort(ep->dma);
-                DBG(value ? 1 : 6, "%s: abort DMA --> %d\n", ep->name, value);
+                dev_dbg(musb->controller, "%s: abort DMA --> %d\n",
+                                ep->name, value);
                 c->channel_release(ep->dma);
                 ep->dma = NULL;
         }
 
-        while (!list_empty(&(ep->req_list))) {
-                req = container_of(ep->req_list.next, struct musb_request,
-                                request.list);
+        while (!list_empty(&ep->req_list)) {
+                req = list_first_entry(&ep->req_list, struct musb_request, list);
                 musb_g_giveback(ep, &req->request, status);
         }
 }
@@ -270,7 +332,7 @@ static void txstate(struct musb *musb, struct musb_request *req)
 
         /* we shouldn't get here while DMA is active ... but we do ... */
         if (dma_channel_status(musb_ep->dma) == MUSB_DMA_STATUS_BUSY) {
-                DBG(4, "dma pending...\n");
+                dev_dbg(musb->controller, "dma pending...\n");
                 return;
         }
 
@@ -282,23 +344,23 @@ static void txstate(struct musb *musb, struct musb_request *req)
                         (int)(request->length - request->actual));
 
         if (csr & MUSB_TXCSR_TXPKTRDY) {
-                DBG(5, "%s old packet still ready , txcsr %03x\n",
+                dev_dbg(musb->controller, "%s old packet still ready , txcsr %03x\n",
                                 musb_ep->end_point.name, csr);
                 return;
         }
 
         if (csr & MUSB_TXCSR_P_SENDSTALL) {
-                DBG(5, "%s stalling, txcsr %03x\n",
+                dev_dbg(musb->controller, "%s stalling, txcsr %03x\n",
                                 musb_ep->end_point.name, csr);
                 return;
         }
 
-        DBG(4, "hw_ep%d, maxpacket %d, fifo count %d, txcsr %03x\n",
+        dev_dbg(musb->controller, "hw_ep%d, maxpacket %d, fifo count %d, txcsr %03x\n",
                         epnum, musb_ep->packet_sz, fifo_count,
                         csr);
 
 #ifndef CONFIG_MUSB_PIO_ONLY
-        if (is_dma_capable() && musb_ep->dma) {
+        if (is_buffer_mapped(req)) {
                 struct dma_controller   *c = musb->dma_controller;
                 size_t request_size;
 
@@ -310,7 +372,7 @@ static void txstate(struct musb *musb, struct musb_request *req)
 
                 /* MUSB_TXCSR_P_ISO is still set correctly */
 
-#ifdef CONFIG_USB_INVENTRA_DMA
+#if defined(CONFIG_USB_INVENTRA_DMA) || defined(CONFIG_USB_UX500_DMA)
                 {
                         if (request_size < musb_ep->packet_sz)
                                 musb_ep->dma->desired_mode = 0;
@@ -337,13 +399,15 @@ static void txstate(struct musb *musb, struct musb_request *req)
                                         csr |= (MUSB_TXCSR_DMAENAB |
                                                         MUSB_TXCSR_MODE);
                                         /* against programming guide */
-                                } else
-                                        csr |= (MUSB_TXCSR_AUTOSET
-                                                        | MUSB_TXCSR_DMAENAB
+                                } else {
+                                        csr |= (MUSB_TXCSR_DMAENAB
                                                         | MUSB_TXCSR_DMAMODE
                                                         | MUSB_TXCSR_MODE);
-
+                                        if (!musb_ep->hb_mult)
+                                                csr |= MUSB_TXCSR_AUTOSET;
+                                }
                                 csr &= ~MUSB_TXCSR_P_UNDERRUN;
+
                                 musb_writew(epio, MUSB_TXCSR, csr);
                         }
                 }
@@ -393,6 +457,12 @@ static void txstate(struct musb *musb, struct musb_request *req)
 #endif
 
         if (!use_dma) {
+                /*
+                 * Unmap the dma buffer back to cpu if dma channel
+                 * programming fails
+                 */
+                unmap_dma_buffer(req, musb);
+
                 musb_write_fifo(musb_ep->hw_ep, fifo_count,
                                 (u8 *) (request->buf + request->actual));
                 request->actual += fifo_count;
@@ -402,7 +472,7 @@ static void txstate(struct musb *musb, struct musb_request *req)
         }
 
         /* host may already have the data when this message shows... */
-        DBG(3, "%s TX/IN %s len %d/%d, txcsr %04x, fifo %d/%d\n",
+        dev_dbg(musb->controller, "%s TX/IN %s len %d/%d, txcsr %04x, fifo %d/%d\n",
                         musb_ep->end_point.name, use_dma ? "dma" : "pio",
                         request->actual, request->length,
                         musb_readw(epio, MUSB_TXCSR),
@@ -417,6 +487,7 @@ static void txstate(struct musb *musb, struct musb_request *req)
 void musb_g_tx(struct musb *musb, u8 epnum)
 {
         u16                     csr;
+        struct musb_request     *req;
         struct usb_request      *request;
         u8 __iomem              *mbase = musb->mregs;
         struct musb_ep          *musb_ep = &musb->endpoints[epnum].ep_in;
@@ -424,10 +495,11 @@ void musb_g_tx(struct musb *musb, u8 epnum)
         struct dma_channel      *dma;
 
         musb_ep_select(mbase, epnum);
-        request = next_request(musb_ep);
+        req = next_request(musb_ep);
+        request = &req->request;
 
         csr = musb_readw(epio, MUSB_TXCSR);
-        DBG(4, "<== %s, txcsr %04x\n", musb_ep->end_point.name, csr);
+        dev_dbg(musb->controller, "<== %s, txcsr %04x\n", musb_ep->end_point.name, csr);
 
         dma = is_dma_capable() ? musb_ep->dma : NULL;
 
@@ -447,7 +519,8 @@ void musb_g_tx(struct musb *musb, u8 epnum)
                 csr |=   MUSB_TXCSR_P_WZC_BITS;
                 csr &= ~(MUSB_TXCSR_P_UNDERRUN | MUSB_TXCSR_TXPKTRDY);
                 musb_writew(epio, MUSB_TXCSR, csr);
-                DBG(20, "underrun on ep%d, req %p\n", epnum, request);
+                dev_vdbg(musb->controller, "underrun on ep%d, req %p\n",
+                                epnum, request);
         }
 
         if (dma_channel_status(dma) == MUSB_DMA_STATUS_BUSY) {
@@ -455,7 +528,7 @@ void musb_g_tx(struct musb *musb, u8 epnum)
                  * SHOULD NOT HAPPEN... has with CPPI though, after
                  * changing SENDSTALL (and other cases); harmless?
                  */
-                DBG(5, "%s dma still busy?\n", musb_ep->end_point.name);
+                dev_dbg(musb->controller, "%s dma still busy?\n", musb_ep->end_point.name);
                 return;
         }
 
@@ -466,53 +539,52 @@ void musb_g_tx(struct musb *musb, u8 epnum)
                         is_dma = 1;
                         csr |= MUSB_TXCSR_P_WZC_BITS;
                         csr &= ~(MUSB_TXCSR_DMAENAB | MUSB_TXCSR_P_UNDERRUN |
-                                 MUSB_TXCSR_TXPKTRDY);
+                                 MUSB_TXCSR_TXPKTRDY | MUSB_TXCSR_AUTOSET);
                         musb_writew(epio, MUSB_TXCSR, csr);
                         /* Ensure writebuffer is empty. */
                         csr = musb_readw(epio, MUSB_TXCSR);
                         request->actual += musb_ep->dma->actual_len;
-                        DBG(4, "TXCSR%d %04x, DMA off, len %zu, req %p\n",
+                        dev_dbg(musb->controller, "TXCSR%d %04x, DMA off, len %zu, req %p\n",
                                 epnum, csr, musb_ep->dma->actual_len, request);
                 }
 
-                if (is_dma || request->actual == request->length) {
+                /*
+                 * First, maybe a terminating short packet. Some DMA
+                 * engines might handle this by themselves.
+                 */
+                if ((request->zero && request->length
+                        && (request->length % musb_ep->packet_sz == 0)
+                        && (request->actual == request->length))
+#if defined(CONFIG_USB_INVENTRA_DMA) || defined(CONFIG_USB_UX500_DMA)
+                        || (is_dma && (!dma->desired_mode ||
+                                (request->actual &
+                                        (musb_ep->packet_sz - 1))))
+#endif
+                ) {
                         /*
-                         * First, maybe a terminating short packet. Some DMA
-                         * engines might handle this by themselves.
+                         * On DMA completion, FIFO may not be
+                         * available yet...
                          */
-                        if ((request->zero && request->length
-                                && request->length % musb_ep->packet_sz == 0)
-#ifdef CONFIG_USB_INVENTRA_DMA
-                                || (is_dma && (!dma->desired_mode ||
-                                        (request->actual &
-                                                (musb_ep->packet_sz - 1))))
-#endif
-                        ) {
-                                /*
-                                 * On DMA completion, FIFO may not be
-                                 * available yet...
-                                 */
-                                if (csr & MUSB_TXCSR_TXPKTRDY)
-                                        return;
+                        if (csr & MUSB_TXCSR_TXPKTRDY)
+                                return;
 
-                                DBG(4, "sending zero pkt\n");
-                                musb_writew(epio, MUSB_TXCSR, MUSB_TXCSR_MODE
-                                                | MUSB_TXCSR_TXPKTRDY);
-                                request->zero = 0;
-                        }
+                        dev_dbg(musb->controller, "sending zero pkt\n");
+                        musb_writew(epio, MUSB_TXCSR, MUSB_TXCSR_MODE
+                                        | MUSB_TXCSR_TXPKTRDY);
+                        request->zero = 0;
+                }
 
-                        if (request->actual == request->length) {
-                                musb_g_giveback(musb_ep, request, 0);
-                                request = musb_ep->desc ? next_request(musb_ep) : NULL;
-                                if (!request) {
-                                        DBG(4, "%s idle now\n",
-                                                musb_ep->end_point.name);
-                                        return;
-                                }
+                if (request->actual == request->length) {
+                        musb_g_giveback(musb_ep, request, 0);
+                        req = musb_ep->desc ? next_request(musb_ep) : NULL;
+                        if (!req) {
+                                dev_dbg(musb->controller, "%s idle now\n",
+                                        musb_ep->end_point.name);
+                                return;
                         }
                 }
 
-                txstate(musb, to_musb_request(request));
+                txstate(musb, req);
         }
 }
 
@@ -572,17 +644,17 @@ static void rxstate(struct musb *musb, struct musb_request *req)
 
         /* We shouldn't get here while DMA is active, but we do... */
         if (dma_channel_status(musb_ep->dma) == MUSB_DMA_STATUS_BUSY) {
-                DBG(4, "DMA pending...\n");
+                dev_dbg(musb->controller, "DMA pending...\n");
                 return;
         }
 
         if (csr & MUSB_RXCSR_P_SENDSTALL) {
-                DBG(5, "%s stalling, RXCSR %04x\n",
+                dev_dbg(musb->controller, "%s stalling, RXCSR %04x\n",
                     musb_ep->end_point.name, csr);
                 return;
         }
 
-        if (is_cppi_enabled() && musb_ep->dma) {
+        if (is_cppi_enabled() && is_buffer_mapped(req)) {
                 struct dma_controller   *c = musb->dma_controller;
                 struct dma_channel      *channel = musb_ep->dma;
 
@@ -613,7 +685,7 @@ static void rxstate(struct musb *musb, struct musb_request *req)
                 len = musb_readw(epio, MUSB_RXCOUNT);
                 if (request->actual < request->length) {
 #ifdef CONFIG_USB_INVENTRA_DMA
-                        if (is_dma_capable() && musb_ep->dma) {
+                        if (is_buffer_mapped(req)) {
                                 struct dma_controller   *c;
                                 struct dma_channel      *channel;
                                 int                     use_dma = 0;
@@ -643,8 +715,8 @@ static void rxstate(struct musb *musb, struct musb_request *req)
          */
 
                                 csr |= MUSB_RXCSR_DMAENAB;
-                                csr |= MUSB_RXCSR_AUTOCLEAR;
 #ifdef USE_MODE1
+                                csr |= MUSB_RXCSR_AUTOCLEAR;
                                 /* csr |= MUSB_RXCSR_DMAMODE; */
 
                                 /* this special sequence (enabling and then
@@ -653,6 +725,10 @@ static void rxstate(struct musb *musb, struct musb_request *req)
                                  */
                                 musb_writew(epio, MUSB_RXCSR,
                                         csr | MUSB_RXCSR_DMAMODE);
+#else
+                                if (!musb_ep->hb_mult &&
+                                        musb_ep->hw_ep->rx_double_buffered)
+                                        csr |= MUSB_RXCSR_AUTOCLEAR;
 #endif
                                 musb_writew(epio, MUSB_RXCSR, csr);
 
@@ -682,10 +758,57 @@ static void rxstate(struct musb *musb, struct musb_request *req)
                                 if (use_dma)
                                         return;
                         }
+#elif defined(CONFIG_USB_UX500_DMA)
+                        if ((is_buffer_mapped(req)) &&
+                                (request->actual < request->length)) {
+
+                                struct dma_controller *c;
+                                struct dma_channel *channel;
+                                int transfer_size = 0;
+
+                                c = musb->dma_controller;
+                                channel = musb_ep->dma;
+
+                                /* In case first packet is short */
+                                if (len < musb_ep->packet_sz)
+                                        transfer_size = len;
+                                else if (request->short_not_ok)
+                                        transfer_size = min(request->length -
+                                                        request->actual,
+                                                        channel->max_len);
+                                else
+                                        transfer_size = min(request->length -
+                                                        request->actual,
+                                                        (unsigned)len);
+
+                                csr &= ~MUSB_RXCSR_DMAMODE;
+                                csr |= (MUSB_RXCSR_DMAENAB |
+                                        MUSB_RXCSR_AUTOCLEAR);
+
+                                musb_writew(epio, MUSB_RXCSR, csr);
+
+                                if (transfer_size <= musb_ep->packet_sz) {
+                                        musb_ep->dma->desired_mode = 0;
+                                } else {
+                                        musb_ep->dma->desired_mode = 1;
+                                        /* Mode must be set after DMAENAB */
+                                        csr |= MUSB_RXCSR_DMAMODE;
+                                        musb_writew(epio, MUSB_RXCSR, csr);
+                                }
+
+                                if (c->channel_program(channel,
+                                                        musb_ep->packet_sz,
+                                                        channel->desired_mode,
+                                                        request->dma
+                                                        + request->actual,
+                                                        transfer_size))
+
+                                        return;
+                        }
 #endif  /* Mentor's DMA */
 
                         fifo_count = request->length - request->actual;
-                        DBG(3, "%s OUT/RX pio fifo %d/%d, maxpacket %d\n",
+                        dev_dbg(musb->controller, "%s OUT/RX pio fifo %d/%d, maxpacket %d\n",
                                         musb_ep->end_point.name,
                                         len, fifo_count,
                                         musb_ep->packet_sz);
@@ -693,7 +816,7 @@ static void rxstate(struct musb *musb, struct musb_request *req)
                         fifo_count = min_t(unsigned, len, fifo_count);
 
 #ifdef  CONFIG_USB_TUSB_OMAP_DMA
-                        if (tusb_dma_omap() && musb_ep->dma) {
+                        if (tusb_dma_omap() && is_buffer_mapped(req)) {
                                 struct dma_controller *c = musb->dma_controller;
                                 struct dma_channel *channel = musb_ep->dma;
                                 u32 dma_addr = request->dma + request->actual;
@@ -708,6 +831,21 @@ static void rxstate(struct musb *musb, struct musb_request *req)
                                         return;
                         }
 #endif
+                        /*
+                         * Unmap the dma buffer back to cpu if dma channel
+                         * programming fails. This buffer is mapped if the
+                         * channel allocation is successful
+                         */
+                         if (is_buffer_mapped(req)) {
+                                unmap_dma_buffer(req, musb);
+
+                                /*
+                                 * Clear DMAENAB and AUTOCLEAR for the
+                                 * PIO mode transfer
+                                 */
+                                csr &= ~(MUSB_RXCSR_DMAENAB | MUSB_RXCSR_AUTOCLEAR);
+                                musb_writew(epio, MUSB_RXCSR, csr);
+                        }
 
                         musb_read_fifo(musb_ep->hw_ep, fifo_count, (u8 *)
                                         (request->buf + request->actual));
@@ -735,6 +873,7 @@ static void rxstate(struct musb *musb, struct musb_request *req)
 void musb_g_rx(struct musb *musb, u8 epnum)
 {
         u16                     csr;
+        struct musb_request     *req;
         struct usb_request      *request;
         void __iomem            *mbase = musb->mregs;
         struct musb_ep          *musb_ep;
@@ -749,14 +888,16 @@ void musb_g_rx(struct musb *musb, u8 epnum)
 
         musb_ep_select(mbase, epnum);
 
-        request = next_request(musb_ep);
-        if (!request)
+        req = next_request(musb_ep);
+        if (!req)
                 return;
 
+        request = &req->request;
+
         csr = musb_readw(epio, MUSB_RXCSR);
         dma = is_dma_capable() ? musb_ep->dma : NULL;
 
-        DBG(4, "<== %s, rxcsr %04x%s %p\n", musb_ep->end_point.name,
+        dev_dbg(musb->controller, "<== %s, rxcsr %04x%s %p\n", musb_ep->end_point.name,
                         csr, dma ? " (dma)" : "", request);
 
         if (csr & MUSB_RXCSR_P_SENTSTALL) {
@@ -771,19 +912,18 @@ void musb_g_rx(struct musb *musb, u8 epnum)
                 csr &= ~MUSB_RXCSR_P_OVERRUN;
                 musb_writew(epio, MUSB_RXCSR, csr);
 
-                DBG(3, "%s iso overrun on %p\n", musb_ep->name, request);
-                if (request && request->status == -EINPROGRESS)
+                dev_dbg(musb->controller, "%s iso overrun on %p\n", musb_ep->name, request);
+                if (request->status == -EINPROGRESS)
                         request->status = -EOVERFLOW;
         }
         if (csr & MUSB_RXCSR_INCOMPRX) {
                 /* REVISIT not necessarily an error */
-                DBG(4, "%s, incomprx\n", musb_ep->end_point.name);
+                dev_dbg(musb->controller, "%s, incomprx\n", musb_ep->end_point.name);
         }
 
         if (dma_channel_status(dma) == MUSB_DMA_STATUS_BUSY) {
                 /* "should not happen"; likely RXPKTRDY pending for DMA */
-                DBG((csr & MUSB_RXCSR_DMAENAB) ? 4 : 1,
-                        "%s busy, csr %04x\n",
+                dev_dbg(musb->controller, "%s busy, csr %04x\n",
                         musb_ep->end_point.name, csr);
                 return;
         }
@@ -797,14 +937,15 @@ void musb_g_rx(struct musb *musb, u8 epnum)
 
                 request->actual += musb_ep->dma->actual_len;
 
-                DBG(4, "RXCSR%d %04x, dma off, %04x, len %zu, req %p\n",
+                dev_dbg(musb->controller, "RXCSR%d %04x, dma off, %04x, len %zu, req %p\n",
                         epnum, csr,
                         musb_readw(epio, MUSB_RXCSR),
                         musb_ep->dma->actual_len, request);
 
-#if defined(CONFIG_USB_INVENTRA_DMA) || defined(CONFIG_USB_TUSB_OMAP_DMA)
+#if defined(CONFIG_USB_INVENTRA_DMA) || defined(CONFIG_USB_TUSB_OMAP_DMA) || \
+        defined(CONFIG_USB_UX500_DMA)
                 /* Autoclear doesn't clear RxPktRdy for short packets */
-                if ((dma->desired_mode == 0)
+                if ((dma->desired_mode == 0 && !hw_ep->rx_double_buffered)
                                 || (dma->actual_len
                                         & (musb_ep->packet_sz - 1))) {
                         /* ack the read! */
@@ -815,24 +956,29 @@ void musb_g_rx(struct musb *musb, u8 epnum)
                 /* incomplete, and not short? wait for next IN packet */
                 if ((request->actual < request->length)
                                 && (musb_ep->dma->actual_len
-                                        == musb_ep->packet_sz))
+                                        == musb_ep->packet_sz)) {
+                        /* In double buffer case, continue to unload fifo if
+                         * there is Rx packet in FIFO.
+                         **/
+                        csr = musb_readw(epio, MUSB_RXCSR);
+                        if ((csr & MUSB_RXCSR_RXPKTRDY) &&
+                                hw_ep->rx_double_buffered)
+                                goto exit;
                         return;
+                }
 #endif
                 musb_g_giveback(musb_ep, request, 0);
 
-                request = next_request(musb_ep);
-                if (!request)
+                req = next_request(musb_ep);
+                if (!req)
                         return;
         }
-
-        /* analyze request if the ep is hot */
-        if (request)
-                rxstate(musb, to_musb_request(request));
-        else
-                DBG(3, "packet waiting for %s%s request\n",
-                                musb_ep->desc ? "" : "inactive ",
-                                musb_ep->end_point.name);
-        return;
+#if defined(CONFIG_USB_INVENTRA_DMA) || defined(CONFIG_USB_TUSB_OMAP_DMA) || \
+        defined(CONFIG_USB_UX500_DMA)
+exit:
+#endif
+        /* Analyze request */
+        rxstate(musb, req);
 }
 
 /* ------------------------------------------------------------ */
@@ -875,9 +1021,25 @@ static int musb_gadget_enable(struct usb_ep *ep,
 
         /* REVISIT this rules out high bandwidth periodic transfers */
         tmp = le16_to_cpu(desc->wMaxPacketSize);
-        if (tmp & ~0x07ff)
-                goto fail;
-        musb_ep->packet_sz = tmp;
+        if (tmp & ~0x07ff) {
+                int ok;
+
+                if (usb_endpoint_dir_in(desc))
+                        ok = musb->hb_iso_tx;
+                else
+                        ok = musb->hb_iso_rx;
+
+                if (!ok) {
+                        dev_dbg(musb->controller, "no support for high bandwidth ISO\n");
+                        goto fail;
+                }
+                musb_ep->hb_mult = (tmp >> 11) & 3;
+        } else {
+                musb_ep->hb_mult = 0;
+        }
+
+        musb_ep->packet_sz = tmp & 0x7ff;
+        tmp = musb_ep->packet_sz * (musb_ep->hb_mult + 1);
 
         /* enable the interrupts for the endpoint, set the endpoint
          * packet size (or fail), set the mode, clear the fifo
@@ -890,8 +1052,11 @@ static int musb_gadget_enable(struct usb_ep *ep,
                         musb_ep->is_in = 1;
                 if (!musb_ep->is_in)
                         goto fail;
-                if (tmp > hw_ep->max_packet_sz_tx)
+
+                if (tmp > hw_ep->max_packet_sz_tx) {
+                        dev_dbg(musb->controller, "packet size beyond hardware FIFO size\n");
                         goto fail;
+                }
 
                 int_txe |= (1 << epnum);
                 musb_writew(mbase, MUSB_INTRTXE, int_txe);
@@ -900,13 +1065,13 @@ static int musb_gadget_enable(struct usb_ep *ep,
                  * likewise high bandwidth periodic tx
                  */
                 /* Set TXMAXP with the FIFO size of the endpoint
-                 * to disable double buffering mode. Currently, It seems that double
-                 * buffering has problem if musb RTL revision number < 2.0.
+                 * to disable double buffering mode.
                  */
-                if (musb->hwvers < MUSB_HWVERS_2000)
+                if (musb->double_buffer_not_ok)
                         musb_writew(regs, MUSB_TXMAXP, hw_ep->max_packet_sz_tx);
                 else
-                        musb_writew(regs, MUSB_TXMAXP, tmp);
+                        musb_writew(regs, MUSB_TXMAXP, musb_ep->packet_sz
+                                        | (musb_ep->hb_mult << 11));
 
                 csr = MUSB_TXCSR_MODE | MUSB_TXCSR_CLRDATATOG;
                 if (musb_readw(regs, MUSB_TXCSR)
@@ -927,8 +1092,11 @@ static int musb_gadget_enable(struct usb_ep *ep,
                         musb_ep->is_in = 0;
                 if (musb_ep->is_in)
                         goto fail;
-                if (tmp > hw_ep->max_packet_sz_rx)
+
+                if (tmp > hw_ep->max_packet_sz_rx) {
+                        dev_dbg(musb->controller, "packet size beyond hardware FIFO size\n");
                         goto fail;
+                }
 
                 int_rxe |= (1 << epnum);
                 musb_writew(mbase, MUSB_INTRRXE, int_rxe);
@@ -939,10 +1107,11 @@ static int musb_gadget_enable(struct usb_ep *ep,
                 /* Set RXMAXP with the FIFO size of the endpoint
                  * to disable double buffering mode.
                  */
-                if (musb->hwvers < MUSB_HWVERS_2000)
-                        musb_writew(regs, MUSB_RXMAXP, hw_ep->max_packet_sz_rx);
+                if (musb->double_buffer_not_ok)
+                        musb_writew(regs, MUSB_RXMAXP, hw_ep->max_packet_sz_tx);
                 else
-                        musb_writew(regs, MUSB_RXMAXP, tmp);
+                        musb_writew(regs, MUSB_RXMAXP, musb_ep->packet_sz
+                                        | (musb_ep->hb_mult << 11));
 
                 /* force shared fifo to OUT-only mode */
                 if (hw_ep->is_shared_fifo) {
@@ -1038,7 +1207,7 @@ static int musb_gadget_disable(struct usb_ep *ep)
 
         spin_unlock_irqrestore(&(musb->lock), flags);
 
-        DBG(2, "%s\n", musb_ep->end_point.name);
+        dev_dbg(musb->controller, "%s\n", musb_ep->end_point.name);
 
         return status;
 }
@@ -1050,16 +1219,19 @@ static int musb_gadget_disable(struct usb_ep *ep)
 struct usb_request *musb_alloc_request(struct usb_ep *ep, gfp_t gfp_flags)
 {
         struct musb_ep          *musb_ep = to_musb_ep(ep);
+        struct musb             *musb = musb_ep->musb;
         struct musb_request     *request = NULL;
 
         request = kzalloc(sizeof *request, gfp_flags);
-        if (request) {
-                INIT_LIST_HEAD(&request->request.list);
-                request->request.dma = DMA_ADDR_INVALID;
-                request->epnum = musb_ep->current_epnum;
-                request->ep = musb_ep;
+        if (!request) {
+                dev_dbg(musb->controller, "not enough memory\n");
+                return NULL;
         }
 
+        request->request.dma = DMA_ADDR_INVALID;
+        request->epnum = musb_ep->current_epnum;
+        request->ep = musb_ep;
+
         return &request->request;
 }
 
@@ -1086,7 +1258,7 @@ struct free_record {
  */
 void musb_ep_restart(struct musb *musb, struct musb_request *req)
 {
-        DBG(3, "<== %s request %p len %u on hw_ep%d\n",
+        dev_dbg(musb->controller, "<== %s request %p len %u on hw_ep%d\n",
                 req->tx ? "TX/IN" : "RX/OUT",
                 &req->request, req->request.length, req->epnum);
 
@@ -1120,7 +1292,7 @@ static int musb_gadget_queue(struct usb_ep *ep, struct usb_request *req,
         if (request->ep != musb_ep)
                 return -EINVAL;
 
-        DBG(4, "<== to %s request=%p\n", ep->name, req);
+        dev_dbg(musb->controller, "<== to %s request=%p\n", ep->name, req);
 
         /* request is mine now... */
         request->request.actual = 0;
@@ -1128,45 +1300,23 @@ static int musb_gadget_queue(struct usb_ep *ep, struct usb_request *req,
         request->epnum = musb_ep->current_epnum;
         request->tx = musb_ep->is_in;
 
-        if (is_dma_capable() && musb_ep->dma) {
-                if (request->request.dma == DMA_ADDR_INVALID) {
-                        request->request.dma = dma_map_single(
-                                        musb->controller,
-                                        request->request.buf,
-                                        request->request.length,
-                                        request->tx
-                                                ? DMA_TO_DEVICE
-                                                : DMA_FROM_DEVICE);
-                        request->mapped = 1;
-                } else {
-                        dma_sync_single_for_device(musb->controller,
-                                        request->request.dma,
-                                        request->request.length,
-                                        request->tx
-                                                ? DMA_TO_DEVICE
-                                                : DMA_FROM_DEVICE);
-                        request->mapped = 0;
-                }
-        } else if (!req->buf) {
-                return -ENODATA;
-        } else
-                request->mapped = 0;
+        map_dma_buffer(request, musb, musb_ep);
 
         spin_lock_irqsave(&musb->lock, lockflags);
 
         /* don't queue if the ep is down */
         if (!musb_ep->desc) {
-                DBG(4, "req %p queued to %s while ep %s\n",
+                dev_dbg(musb->controller, "req %p queued to %s while ep %s\n",
                                 req, ep->name, "disabled");
                 status = -ESHUTDOWN;
                 goto cleanup;
         }
 
         /* add request to the list */
-        list_add_tail(&(request->request.list), &(musb_ep->req_list));
+        list_add_tail(&request->list, &musb_ep->req_list);
 
         /* it this is the head of the queue, start i/o ... */
-        if (!musb_ep->busy && &request->request.list == musb_ep->req_list.next)
+        if (!musb_ep->busy && &request->list == musb_ep->req_list.next)
                 musb_ep_restart(musb, request);
 
 cleanup:
@@ -1177,7 +1327,8 @@ cleanup:
 static int musb_gadget_dequeue(struct usb_ep *ep, struct usb_request *request)
 {
         struct musb_ep          *musb_ep = to_musb_ep(ep);
-        struct usb_request      *r;
+        struct musb_request     *req = to_musb_request(request);
+        struct musb_request     *r;
         unsigned long           flags;
         int                     status = 0;
         struct musb             *musb = musb_ep->musb;
@@ -1188,17 +1339,17 @@ static int musb_gadget_dequeue(struct usb_ep *ep, struct usb_request *request)
         spin_lock_irqsave(&musb->lock, flags);
 
         list_for_each_entry(r, &musb_ep->req_list, list) {
-                if (r == request)
+                if (r == req)
                         break;
         }
-        if (r != request) {
-                DBG(3, "request %p not queued to %s\n", request, ep->name);
+        if (r != req) {
+                dev_dbg(musb->controller, "request %p not queued to %s\n", request, ep->name);
                 status = -EINVAL;
                 goto done;
         }
 
         /* if the hardware doesn't have the request, easy ... */
-        if (musb_ep->req_list.next != &request->list || musb_ep->busy)
+        if (musb_ep->req_list.next != &req->list || musb_ep->busy)
                 musb_g_giveback(musb_ep, request, -ECONNRESET);
 
         /* ... else abort the dma transfer ... */
@@ -1255,10 +1406,10 @@ static int musb_gadget_set_halt(struct usb_ep *ep, int value)
 
         musb_ep_select(mbase, epnum);
 
-        request = to_musb_request(next_request(musb_ep));
+        request = next_request(musb_ep);
         if (value) {
                 if (request) {
-                        DBG(3, "request in progress, cannot halt %s\n",
+                        dev_dbg(musb->controller, "request in progress, cannot halt %s\n",
                             ep->name);
                         status = -EAGAIN;
                         goto done;
@@ -1267,7 +1418,7 @@ static int musb_gadget_set_halt(struct usb_ep *ep, int value)
                 if (musb_ep->is_in) {
                         csr = musb_readw(epio, MUSB_TXCSR);
                         if (csr & MUSB_TXCSR_FIFONOTEMPTY) {
-                                DBG(3, "FIFO busy, cannot halt %s\n", ep->name);
+                                dev_dbg(musb->controller, "FIFO busy, cannot halt %s\n", ep->name);
                                 status = -EAGAIN;
                                 goto done;
                         }
@@ -1276,7 +1427,7 @@ static int musb_gadget_set_halt(struct usb_ep *ep, int value)
                 musb_ep->wedged = 0;
 
         /* set/clear the stall and toggle bits */
-        DBG(2, "%s: %s stall\n", ep->name, value ? "set" : "clear");
+        dev_dbg(musb->controller, "%s: %s stall\n", ep->name, value ? "set" : "clear");
         if (musb_ep->is_in) {
                 csr = musb_readw(epio, MUSB_TXCSR);
                 csr |= MUSB_TXCSR_P_WZC_BITS
@@ -1303,7 +1454,7 @@ static int musb_gadget_set_halt(struct usb_ep *ep, int value)
 
         /* maybe start the first request in the queue */
         if (!musb_ep->busy && !value && request) {
-                DBG(3, "restarting the request\n");
+                dev_dbg(musb->controller, "restarting the request\n");
                 musb_ep_restart(musb, request);
         }
 
@@ -1373,6 +1524,12 @@ static void musb_gadget_fifo_flush(struct usb_ep *ep)
                 csr = musb_readw(epio, MUSB_TXCSR);
                 if (csr & MUSB_TXCSR_FIFONOTEMPTY) {
                         csr |= MUSB_TXCSR_FLUSHFIFO | MUSB_TXCSR_P_WZC_BITS;
+                        /*
+                         * Setting both TXPKTRDY and FLUSHFIFO makes controller
+                         * to interrupt current FIFO loading, but not flushing
+                         * the already loaded ones.
+                         */
+                        csr &= ~MUSB_TXCSR_TXPKTRDY;
                         musb_writew(epio, MUSB_TXCSR, csr);
                         /* REVISIT may be inappropriate w/o FIFONOTEMPTY ... */
                         musb_writew(epio, MUSB_TXCSR, csr);
@@ -1434,7 +1591,7 @@ static int musb_gadget_wakeup(struct usb_gadget *gadget)
         case OTG_STATE_B_IDLE:
                 /* Start SRP ... OTG not required. */
                 devctl = musb_readb(mregs, MUSB_DEVCTL);
-                DBG(2, "Sending SRP: devctl: %02x\n", devctl);
+                dev_dbg(musb->controller, "Sending SRP: devctl: %02x\n", devctl);
                 devctl |= MUSB_DEVCTL_SESSION;
                 musb_writeb(mregs, MUSB_DEVCTL, devctl);
                 devctl = musb_readb(mregs, MUSB_DEVCTL);
@@ -1451,6 +1608,10 @@ static int musb_gadget_wakeup(struct usb_gadget *gadget)
                                 break;
                 }
 
+                spin_unlock_irqrestore(&musb->lock, flags);
+                otg_start_srp(musb->xceiv);
+                spin_lock_irqsave(&musb->lock, flags);
+
                 /* Block idling for at least 1s */
                 musb_platform_try_idle(musb,
                         jiffies + msecs_to_jiffies(1 * HZ));
@@ -1458,7 +1619,8 @@ static int musb_gadget_wakeup(struct usb_gadget *gadget)
                 status = 0;
                 goto done;
         default:
-                DBG(2, "Unhandled wake: %s\n", otg_state_string(musb));
+                dev_dbg(musb->controller, "Unhandled wake: %s\n",
+                        otg_state_string(musb->xceiv->state));
                 goto done;
         }
 
@@ -1467,7 +1629,7 @@ static int musb_gadget_wakeup(struct usb_gadget *gadget)
         power = musb_readb(mregs, MUSB_POWER);
         power |= MUSB_POWER_RESUME;
         musb_writeb(mregs, MUSB_POWER, power);
-        DBG(2, "issue wakeup\n");
+        dev_dbg(musb->controller, "issue wakeup\n");
 
         /* FIXME do this next chunk in a timer callback, no udelay */
         mdelay(2);
@@ -1501,7 +1663,7 @@ static void musb_pullup(struct musb *musb, int is_on)
 
         /* FIXME if on, HdrcStart; if off, HdrcStop */
 
-        DBG(3, "gadget %s D+ pullup %s\n",
+        dev_dbg(musb->controller, "gadget %s D+ pullup %s\n",
                 musb->gadget_driver->function, is_on ? "on" : "off");
         musb_writeb(musb->mregs, MUSB_POWER, power);
 }
@@ -1509,7 +1671,7 @@ static void musb_pullup(struct musb *musb, int is_on)
 #if 0
 static int musb_gadget_vbus_session(struct usb_gadget *gadget, int is_active)
 {
-        DBG(2, "<= %s =>\n", __func__);
+        dev_dbg(musb->controller, "<= %s =>\n", __func__);
 
         /*
          * FIXME iff driver's softconnect flag is set (as it is during probe,
@@ -1617,7 +1779,7 @@ static inline void __init musb_g_init_endpoints(struct musb *musb)
         struct musb_hw_ep       *hw_ep;
         unsigned                count = 0;
 
-        /* intialize endpoint list just once */
+        /* initialize endpoint list just once */
         INIT_LIST_HEAD(&(musb->g.ep_list));
 
         for (epnum = 0, hw_ep = musb->endpoints;
@@ -1676,8 +1838,10 @@ int __init musb_gadget_setup(struct musb *musb)
         musb_platform_try_idle(musb, 0);
 
         status = device_register(&musb->g.dev);
-        if (status != 0)
+        if (status != 0) {
+                put_device(&musb->g.dev);
                 the_gadget = NULL;
+        }
         return status;
 }
 
@@ -1696,97 +1860,115 @@ void musb_gadget_cleanup(struct musb *musb)
  *
  * -EINVAL something went wrong (not driver)
  * -EBUSY another gadget is already using the controller
- * -ENOMEM no memeory to perform the operation
+ * -ENOMEM no memory to perform the operation
  *
  * @param driver the gadget driver
+ * @param bind the driver's bind function
  * @return <0 if error, 0 if everything is fine
  */
-int usb_gadget_register_driver(struct usb_gadget_driver *driver)
+int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
+                int (*bind)(struct usb_gadget *))
 {
-        int retval;
-        unsigned long flags;
-        struct musb *musb = the_gadget;
+        struct musb             *musb = the_gadget;
+        unsigned long           flags;
+        int                     retval = -EINVAL;
 
         if (!driver
                         || driver->speed != USB_SPEED_HIGH
-                        || !driver->bind
-                        || !driver->setup)
-                return -EINVAL;
+                        || !bind || !driver->setup)
+                goto err0;
 
         /* driver must be initialized to support peripheral mode */
         if (!musb) {
-                DBG(1, "%s, no dev??\n", __func__);
-                return -ENODEV;
+                dev_dbg(musb->controller, "no dev??\n");
+                retval = -ENODEV;
+                goto err0;
         }
 
-        DBG(3, "registering driver %s\n", driver->function);
-        spin_lock_irqsave(&musb->lock, flags);
+        pm_runtime_get_sync(musb->controller);
+
+        dev_dbg(musb->controller, "registering driver %s\n", driver->function);
 
         if (musb->gadget_driver) {
-                DBG(1, "%s is already bound to %s\n",
+                dev_dbg(musb->controller, "%s is already bound to %s\n",
                                 musb_driver_name,
                                 musb->gadget_driver->driver.name);
                 retval = -EBUSY;
-        } else {
-                musb->gadget_driver = driver;
-                musb->g.dev.driver = &driver->driver;
-                driver->driver.bus = NULL;
-                musb->softconnect = 1;
-                retval = 0;
+                goto err0;
         }
 
+        spin_lock_irqsave(&musb->lock, flags);
+        musb->gadget_driver = driver;
+        musb->g.dev.driver = &driver->driver;
+        driver->driver.bus = NULL;
+        musb->softconnect = 1;
         spin_unlock_irqrestore(&musb->lock, flags);
 
-        if (retval == 0) {
-                retval = driver->bind(&musb->g);
-                if (retval != 0) {
-                        DBG(3, "bind to driver %s failed --> %d\n",
-                                        driver->driver.name, retval);
-                        musb->gadget_driver = NULL;
-                        musb->g.dev.driver = NULL;
-                }
+        retval = bind(&musb->g);
+        if (retval) {
+                dev_dbg(musb->controller, "bind to driver %s failed --> %d\n",
+                                driver->driver.name, retval);
+                goto err1;
+        }
 
-                spin_lock_irqsave(&musb->lock, flags);
+        spin_lock_irqsave(&musb->lock, flags);
 
-                otg_set_peripheral(musb->xceiv, &musb->g);
-                musb->xceiv->state = OTG_STATE_B_IDLE;
-                musb->is_active = 1;
+        otg_set_peripheral(musb->xceiv, &musb->g);
+        musb->xceiv->state = OTG_STATE_B_IDLE;
+        musb->is_active = 1;
 
-                /* FIXME this ignores the softconnect flag.  Drivers are
-                 * allowed hold the peripheral inactive until for example
-                 * userspace hooks up printer hardware or DSP codecs, so
-                 * hosts only see fully functional devices.
-                 */
+        /*
+         * FIXME this ignores the softconnect flag.  Drivers are
+         * allowed hold the peripheral inactive until for example
+         * userspace hooks up printer hardware or DSP codecs, so
+         * hosts only see fully functional devices.
+         */
 
-                if (!is_otg_enabled(musb))
-                        musb_start(musb);
+        if (!is_otg_enabled(musb))
+                musb_start(musb);
 
-                otg_set_peripheral(musb->xceiv, &musb->g);
+        otg_set_peripheral(musb->xceiv, &musb->g);
 
-                spin_unlock_irqrestore(&musb->lock, flags);
+        spin_unlock_irqrestore(&musb->lock, flags);
 
-                if (is_otg_enabled(musb)) {
-                        DBG(3, "OTG startup...\n");
+        if (is_otg_enabled(musb)) {
+                struct usb_hcd  *hcd = musb_to_hcd(musb);
 
-                        /* REVISIT:  funcall to other code, which also
-                         * handles power budgeting ... this way also
-                         * ensures HdrcStart is indirectly called.
-                         */
-                        retval = usb_add_hcd(musb_to_hcd(musb), -1, 0);
-                        if (retval < 0) {
-                                DBG(1, "add_hcd failed, %d\n", retval);
-                                spin_lock_irqsave(&musb->lock, flags);
-                                otg_set_peripheral(musb->xceiv, NULL);
-                                musb->gadget_driver = NULL;
-                                musb->g.dev.driver = NULL;
-                                spin_unlock_irqrestore(&musb->lock, flags);
-                        }
+                dev_dbg(musb->controller, "OTG startup...\n");
+
+                /* REVISIT:  funcall to other code, which also
+                 * handles power budgeting ... this way also
+                 * ensures HdrcStart is indirectly called.
+                 */
+                retval = usb_add_hcd(musb_to_hcd(musb), -1, 0);
+                if (retval < 0) {
+                        dev_dbg(musb->controller, "add_hcd failed, %d\n", retval);
+                        goto err2;
                 }
+
+                if ((musb->xceiv->last_event == USB_EVENT_ID)
+                                        && musb->xceiv->set_vbus)
+                        otg_set_vbus(musb->xceiv, 1);
+
+                hcd->self.uses_pio_for_control = 1;
         }
+        if (musb->xceiv->last_event == USB_EVENT_NONE)
+                pm_runtime_put(musb->controller);
+
+        return 0;
 
+err2:
+        if (!is_otg_enabled(musb))
+                musb_stop(musb);
+
+err1:
+        musb->gadget_driver = NULL;
+        musb->g.dev.driver = NULL;
+
+err0:
         return retval;
 }
-EXPORT_SYMBOL(usb_gadget_register_driver);
+EXPORT_SYMBOL(usb_gadget_probe_driver);
 
 static void stop_activity(struct musb *musb, struct usb_gadget_driver *driver)
 {
@@ -1838,14 +2020,20 @@ static void stop_activity(struct musb *musb, struct usb_gadget_driver *driver)
  */
 int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
 {
-        unsigned long   flags;
-        int             retval = 0;
         struct musb     *musb = the_gadget;
+        unsigned long   flags;
 
         if (!driver || !driver->unbind || !musb)
                 return -EINVAL;
 
-        /* REVISIT always use otg_set_peripheral() here too;
+        if (!musb->gadget_driver)
+                return -EINVAL;
+
+        if (musb->xceiv->last_event == USB_EVENT_NONE)
+                pm_runtime_get_sync(musb->controller);
+
+        /*
+         * REVISIT always use otg_set_peripheral() here too;
          * this needs to shut down the OTG engine.
          */
 
@@ -1855,29 +2043,26 @@ int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
         musb_hnp_stop(musb);
 #endif
 
-        if (musb->gadget_driver == driver) {
+        (void) musb_gadget_vbus_draw(&musb->g, 0);
 
-                (void) musb_gadget_vbus_draw(&musb->g, 0);
+        musb->xceiv->state = OTG_STATE_UNDEFINED;
+        stop_activity(musb, driver);
+        otg_set_peripheral(musb->xceiv, NULL);
 
-                musb->xceiv->state = OTG_STATE_UNDEFINED;
-                stop_activity(musb, driver);
-                otg_set_peripheral(musb->xceiv, NULL);
+        dev_dbg(musb->controller, "unregistering driver %s\n", driver->function);
 
-                DBG(3, "unregistering driver %s\n", driver->function);
-                spin_unlock_irqrestore(&musb->lock, flags);
-                driver->unbind(&musb->g);
-                spin_lock_irqsave(&musb->lock, flags);
+        spin_unlock_irqrestore(&musb->lock, flags);
+        driver->unbind(&musb->g);
+        spin_lock_irqsave(&musb->lock, flags);
 
-                musb->gadget_driver = NULL;
-                musb->g.dev.driver = NULL;
+        musb->gadget_driver = NULL;
+        musb->g.dev.driver = NULL;
 
-                musb->is_active = 0;
-                musb_platform_try_idle(musb, 0);
-        } else
-                retval = -EINVAL;
+        musb->is_active = 0;
+        musb_platform_try_idle(musb, 0);
         spin_unlock_irqrestore(&musb->lock, flags);
 
-        if (is_otg_enabled(musb) && retval == 0) {
+        if (is_otg_enabled(musb)) {
                 usb_remove_hcd(musb_to_hcd(musb));
                 /* FIXME we need to be able to register another
                  * gadget driver here and have everything work;
@@ -1885,7 +2070,12 @@ int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
                  */
         }
 
-        return retval;
+        if (!is_otg_enabled(musb))
+                musb_stop(musb);
+
+        pm_runtime_put(musb->controller);
+
+        return 0;
 }
 EXPORT_SYMBOL(usb_gadget_unregister_driver);
 
@@ -1911,7 +2101,7 @@ void musb_g_resume(struct musb *musb)
                 break;
         default:
                 WARNING("unhandled RESUME transition (%s)\n",
-                                otg_state_string(musb));
+                                otg_state_string(musb->xceiv->state));
         }
 }
 
@@ -1921,7 +2111,7 @@ void musb_g_suspend(struct musb *musb)
         u8      devctl;
 
         devctl = musb_readb(musb->mregs, MUSB_DEVCTL);
-        DBG(3, "devctl %02x\n", devctl);
+        dev_dbg(musb->controller, "devctl %02x\n", devctl);
 
         switch (musb->xceiv->state) {
         case OTG_STATE_B_IDLE:
@@ -1941,7 +2131,7 @@ void musb_g_suspend(struct musb *musb)
                  * A_PERIPHERAL may need care too
                  */
                 WARNING("unhandled SUSPEND transition (%s)\n",
-                                otg_state_string(musb));
+                                otg_state_string(musb->xceiv->state));
         }
 }
 
@@ -1957,7 +2147,7 @@ void musb_g_disconnect(struct musb *musb)
         void __iomem    *mregs = musb->mregs;
         u8      devctl = musb_readb(mregs, MUSB_DEVCTL);
 
-        DBG(3, "devctl %02x\n", devctl);
+        dev_dbg(musb->controller, "devctl %02x\n", devctl);
 
         /* clear HR */
         musb_writeb(mregs, MUSB_DEVCTL, devctl & MUSB_DEVCTL_SESSION);
@@ -1975,8 +2165,8 @@ void musb_g_disconnect(struct musb *musb)
         switch (musb->xceiv->state) {
         default:
 #ifdef  CONFIG_USB_MUSB_OTG
-                DBG(2, "Unhandled disconnect %s, setting a_idle\n",
-                        otg_state_string(musb));
+                dev_dbg(musb->controller, "Unhandled disconnect %s, setting a_idle\n",
+                        otg_state_string(musb->xceiv->state));
                 musb->xceiv->state = OTG_STATE_A_IDLE;
                 MUSB_HST_MODE(musb);
                 break;
@@ -2006,7 +2196,7 @@ __acquires(musb->lock)
         u8              devctl = musb_readb(mbase, MUSB_DEVCTL);
         u8              power;
 
-        DBG(3, "<== %s addr=%x driver '%s'\n",
+        dev_dbg(musb->controller, "<== %s addr=%x driver '%s'\n",
                         (devctl & MUSB_DEVCTL_BDEVICE)
                                 ? "B-Device" : "A-Device",
                         musb_readb(mbase, MUSB_FADDR),
diff --git a/drivers/usb/musb/musb_gadget.h b/drivers/usb/musb/musb_gadget.h
index 572b1da7f2dc..66b7c5e0fb44 100644
--- a/drivers/usb/musb/musb_gadget.h
+++ b/drivers/usb/musb/musb_gadget.h
@@ -35,13 +35,22 @@
 #ifndef __MUSB_GADGET_H
 #define __MUSB_GADGET_H
 
+#include <linux/list.h>
+
+enum buffer_map_state {
+        UN_MAPPED = 0,
+        PRE_MAPPED,
+        MUSB_MAPPED
+};
+
 struct musb_request {
         struct usb_request      request;
+        struct list_head        list;
         struct musb_ep          *ep;
         struct musb             *musb;
         u8 tx;                  /* endpoint direction */
         u8 epnum;
-        u8 mapped;
+        enum buffer_map_state map_state;
 };
 
 static inline struct musb_request *to_musb_request(struct usb_request *req)
@@ -79,6 +88,8 @@ struct musb_ep {
 
         /* true if lock must be dropped but req_list may not be advanced */
         u8                              busy;
+
+        u8                              hb_mult;
 };
 
 static inline struct musb_ep *to_musb_ep(struct usb_ep *ep)
@@ -86,13 +97,13 @@ static inline struct musb_ep *to_musb_ep(struct usb_ep *ep)
         return ep ? container_of(ep, struct musb_ep, end_point) : NULL;
 }
 
-static inline struct usb_request *next_request(struct musb_ep *ep)
+static inline struct musb_request *next_request(struct musb_ep *ep)
 {
         struct list_head        *queue = &ep->req_list;
 
         if (list_empty(queue))
                 return NULL;
-        return container_of(queue->next, struct usb_request, list);
+        return container_of(queue->next, struct musb_request, list);
 }
 
 extern void musb_g_tx(struct musb *musb, u8 epnum);
diff --git a/drivers/usb/musb/musb_gadget_ep0.c b/drivers/usb/musb/musb_gadget_ep0.c
index 6dd03f4c5f49..b2faff235507 100644
--- a/drivers/usb/musb/musb_gadget_ep0.c
+++ b/drivers/usb/musb/musb_gadget_ep0.c
@@ -209,7 +209,7 @@ static inline void musb_try_b_hnp_enable(struct musb *musb)
         void __iomem    *mbase = musb->mregs;
         u8              devctl;
 
-        DBG(1, "HNP: Setting HR\n");
+        dev_dbg(musb->controller, "HNP: Setting HR\n");
         devctl = musb_readb(mbase, MUSB_DEVCTL);
         musb_writeb(mbase, MUSB_DEVCTL, devctl | MUSB_DEVCTL_HR);
 }
@@ -304,10 +304,9 @@ __acquires(musb->lock)
                                 }
 
                                 /* Maybe start the first request in the queue */
-                                request = to_musb_request(
-                                                next_request(musb_ep));
+                                request = next_request(musb_ep);
                                 if (!musb_ep->busy && request) {
-                                        DBG(3, "restarting the request\n");
+                                        dev_dbg(musb->controller, "restarting the request\n");
                                         musb_ep_restart(musb, request);
                                 }
 
@@ -491,10 +490,12 @@ stall:
 static void ep0_rxstate(struct musb *musb)
 {
         void __iomem            *regs = musb->control_ep->regs;
+        struct musb_request     *request;
         struct usb_request      *req;
         u16                     count, csr;
 
-        req = next_ep0_request(musb);
+        request = next_ep0_request(musb);
+        req = &request->request;
 
         /* read packet and ack; or stall because of gadget driver bug:
          * should have provided the rx buffer before setup() returned.
@@ -544,17 +545,20 @@ static void ep0_rxstate(struct musb *musb)
 static void ep0_txstate(struct musb *musb)
 {
         void __iomem            *regs = musb->control_ep->regs;
-        struct usb_request      *request = next_ep0_request(musb);
+        struct musb_request     *req = next_ep0_request(musb);
+        struct usb_request      *request;
         u16                     csr = MUSB_CSR0_TXPKTRDY;
         u8                      *fifo_src;
         u8                      fifo_count;
 
-        if (!request) {
+        if (!req) {
                 /* WARN_ON(1); */
-                DBG(2, "odd; csr0 %04x\n", musb_readw(regs, MUSB_CSR0));
+                dev_dbg(musb->controller, "odd; csr0 %04x\n", musb_readw(regs, MUSB_CSR0));
                 return;
         }
 
+        request = &req->request;
+
         /* load the data */
         fifo_src = (u8 *) request->buf + request->actual;
         fifo_count = min((unsigned) MUSB_EP0_FIFOSIZE,
@@ -598,7 +602,7 @@ static void ep0_txstate(struct musb *musb)
 static void
 musb_read_setup(struct musb *musb, struct usb_ctrlrequest *req)
 {
-        struct usb_request      *r;
+        struct musb_request     *r;
         void __iomem            *regs = musb->control_ep->regs;
 
         musb_read_fifo(&musb->endpoints[0], sizeof *req, (u8 *)req);
@@ -606,7 +610,7 @@ musb_read_setup(struct musb *musb, struct usb_ctrlrequest *req)
         /* NOTE:  earlier 2.6 versions changed setup packets to host
          * order, but now USB packets always stay in USB byte order.
          */
-        DBG(3, "SETUP req%02x.%02x v%04x i%04x l%d\n",
+        dev_dbg(musb->controller, "SETUP req%02x.%02x v%04x i%04x l%d\n",
                 req->bRequestType,
                 req->bRequest,
                 le16_to_cpu(req->wValue),
@@ -616,7 +620,7 @@ musb_read_setup(struct musb *musb, struct usb_ctrlrequest *req)
         /* clean up any leftover transfers */
         r = next_ep0_request(musb);
         if (r)
-                musb_g_ep0_giveback(musb, r);
+                musb_g_ep0_giveback(musb, &r->request);
 
         /* For zero-data requests we want to delay the STATUS stage to
          * avoid SETUPEND errors.  If we read data (OUT), delay accepting
@@ -674,7 +678,7 @@ irqreturn_t musb_g_ep0_irq(struct musb *musb)
         csr = musb_readw(regs, MUSB_CSR0);
         len = musb_readb(regs, MUSB_COUNT0);
 
-        DBG(4, "csr %04x, count %d, myaddr %d, ep0stage %s\n",
+        dev_dbg(musb->controller, "csr %04x, count %d, myaddr %d, ep0stage %s\n",
                         csr, len,
                         musb_readb(mbase, MUSB_FADDR),
                         decode_ep0stage(musb->ep0_state));
@@ -745,7 +749,7 @@ irqreturn_t musb_g_ep0_irq(struct musb *musb)
 
                 /* enter test mode if needed (exit by reset) */
                 else if (musb->test_mode) {
-                        DBG(1, "entering TESTMODE\n");
+                        dev_dbg(musb->controller, "entering TESTMODE\n");
 
                         if (MUSB_TEST_PACKET == musb->test_mode_nr)
                                 musb_load_testpacket(musb);
@@ -758,11 +762,11 @@ irqreturn_t musb_g_ep0_irq(struct musb *musb)
         case MUSB_EP0_STAGE_STATUSOUT:
                 /* end of sequence #1: write to host (TX state) */
                 {
-                        struct usb_request      *req;
+                        struct musb_request     *req;
 
                         req = next_ep0_request(musb);
                         if (req)
-                                musb_g_ep0_giveback(musb, req);
+                                musb_g_ep0_giveback(musb, &req->request);
                 }
 
                 /*
@@ -857,7 +861,7 @@ setup:
                                 break;
                         }
 
-                        DBG(3, "handled %d, csr %04x, ep0stage %s\n",
+                        dev_dbg(musb->controller, "handled %d, csr %04x, ep0stage %s\n",
                                 handled, csr,
                                 decode_ep0stage(musb->ep0_state));
 
@@ -874,7 +878,7 @@ setup:
                         if (handled < 0) {
                                 musb_ep_select(mbase, 0);
 stall:
-                                DBG(3, "stall (%d)\n", handled);
+                                dev_dbg(musb->controller, "stall (%d)\n", handled);
                                 musb->ackpend |= MUSB_CSR0_P_SENDSTALL;
                                 musb->ep0_state = MUSB_EP0_STAGE_IDLE;
 finish:
@@ -954,16 +958,16 @@ musb_g_ep0_queue(struct usb_ep *e, struct usb_request *r, gfp_t gfp_flags)
                 status = 0;
                 break;
         default:
-                DBG(1, "ep0 request queued in state %d\n",
+                dev_dbg(musb->controller, "ep0 request queued in state %d\n",
                                 musb->ep0_state);
                 status = -EINVAL;
                 goto cleanup;
         }
 
         /* add request to the list */
-        list_add_tail(&(req->request.list), &(ep->req_list));
+        list_add_tail(&req->list, &ep->req_list);
 
-        DBG(3, "queue to %s (%s), length=%d\n",
+        dev_dbg(musb->controller, "queue to %s (%s), length=%d\n",
                         ep->name, ep->is_in ? "IN/TX" : "OUT/RX",
                         req->request.length);
 
@@ -1056,7 +1060,7 @@ static int musb_g_ep0_halt(struct usb_ep *e, int value)
                 musb->ackpend = 0;
                 break;
         default:
-                DBG(1, "ep0 can't halt in state %d\n", musb->ep0_state);
+                dev_dbg(musb->controller, "ep0 can't halt in state %d\n", musb->ep0_state);
                 status = -EINVAL;
         }
 
diff --git a/drivers/usb/musb/musb_host.c b/drivers/usb/musb/musb_host.c
index 9e65c47cc98b..8b2473fa0f47 100644
--- a/drivers/usb/musb/musb_host.c
+++ b/drivers/usb/musb/musb_host.c
@@ -41,6 +41,7 @@
 #include <linux/errno.h>
 #include <linux/init.h>
 #include <linux/list.h>
+#include <linux/dma-mapping.h>
 
 #include "musb_core.h"
 #include "musb_host.h"
@@ -105,6 +106,7 @@ static void musb_ep_program(struct musb *musb, u8 epnum,
  */
 static void musb_h_tx_flush_fifo(struct musb_hw_ep *ep)
 {
+        struct musb     *musb = ep->musb;
         void __iomem    *epio = ep->regs;
         u16             csr;
         u16             lastcsr = 0;
@@ -113,7 +115,7 @@ static void musb_h_tx_flush_fifo(struct musb_hw_ep *ep)
         csr = musb_readw(epio, MUSB_TXCSR);
         while (csr & MUSB_TXCSR_FIFONOTEMPTY) {
                 if (csr != lastcsr)
-                        DBG(3, "Host TX FIFONOTEMPTY csr: %02x\n", csr);
+                        dev_dbg(musb->controller, "Host TX FIFONOTEMPTY csr: %02x\n", csr);
                 lastcsr = csr;
                 csr |= MUSB_TXCSR_FLUSHFIFO;
                 musb_writew(epio, MUSB_TXCSR, csr);
@@ -239,7 +241,7 @@ musb_start_urb(struct musb *musb, int is_in, struct musb_qh *qh)
                 len = urb->transfer_buffer_length - urb->actual_length;
         }
 
-        DBG(4, "qh %p urb %p dev%d ep%d%s%s, hw_ep %d, %p/%d\n",
+        dev_dbg(musb->controller, "qh %p urb %p dev%d ep%d%s%s, hw_ep %d, %p/%d\n",
                         qh, urb, address, qh->epnum,
                         is_in ? "in" : "out",
                         ({char *s; switch (qh->type) {
@@ -262,7 +264,7 @@ musb_start_urb(struct musb *musb, int is_in, struct musb_qh *qh)
         switch (qh->type) {
         case USB_ENDPOINT_XFER_ISOC:
         case USB_ENDPOINT_XFER_INT:
-                DBG(3, "check whether there's still time for periodic Tx\n");
+                dev_dbg(musb->controller, "check whether there's still time for periodic Tx\n");
                 frame = musb_readw(mbase, MUSB_FRAME);
                 /* FIXME this doesn't implement that scheduling policy ...
                  * or handle framecounter wrapping
@@ -277,7 +279,7 @@ musb_start_urb(struct musb *musb, int is_in, struct musb_qh *qh)
                 } else {
                         qh->frame = urb->start_frame;
                         /* enable SOF interrupt so we can count down */
-                        DBG(1, "SOF for %d\n", epnum);
+                        dev_dbg(musb->controller, "SOF for %d\n", epnum);
 #if 1 /* ifndef CONFIG_ARCH_DAVINCI */
                         musb_writeb(mbase, MUSB_INTRUSBE, 0xff);
 #endif
@@ -285,7 +287,7 @@ musb_start_urb(struct musb *musb, int is_in, struct musb_qh *qh)
                 break;
         default:
 start:
-                DBG(4, "Start TX%d %s\n", epnum,
+                dev_dbg(musb->controller, "Start TX%d %s\n", epnum,
                         hw_ep->tx_channel ? "dma" : "pio");
 
                 if (!hw_ep->tx_channel)
@@ -300,21 +302,7 @@ static void musb_giveback(struct musb *musb, struct urb *urb, int status)
 __releases(musb->lock)
 __acquires(musb->lock)
 {
-        DBG(({ int level; switch (status) {
-                                case 0:
-                                        level = 4;
-                                        break;
-                                /* common/boring faults */
-                                case -EREMOTEIO:
-                                case -ESHUTDOWN:
-                                case -ECONNRESET:
-                                case -EPIPE:
-                                        level = 3;
-                                        break;
-                                default:
-                                        level = 2;
-                                        break;
-                                }; level; }),
+        dev_dbg(musb->controller,
                         "complete %p %pF (%d), dev%d ep%d%s, %d/%d\n",
                         urb, urb->complete, status,
                         usb_pipedevice(urb->pipe),
@@ -425,7 +413,7 @@ static void musb_advance_schedule(struct musb *musb, struct urb *urb,
         }
 
         if (qh != NULL && qh->is_ready) {
-                DBG(4, "... next ep%d %cX urb %p\n",
+                dev_dbg(musb->controller, "... next ep%d %cX urb %p\n",
                     hw_ep->epnum, is_in ? 'R' : 'T', next_urb(qh));
                 musb_start_urb(musb, is_in, qh);
         }
@@ -470,7 +458,7 @@ musb_host_packet_rx(struct musb *musb, struct urb *urb, u8 epnum, u8 iso_err)
 
         /* musb_ep_select(mbase, epnum); */
         rx_count = musb_readw(epio, MUSB_RXCOUNT);
-        DBG(3, "RX%d count %d, buffer %p len %d/%d\n", epnum, rx_count,
+        dev_dbg(musb->controller, "RX%d count %d, buffer %p len %d/%d\n", epnum, rx_count,
                         urb->transfer_buffer, qh->offset,
                         urb->transfer_buffer_length);
 
@@ -492,7 +480,7 @@ musb_host_packet_rx(struct musb *musb, struct urb *urb, u8 epnum, u8 iso_err)
                                 status = -EOVERFLOW;
                                 urb->error_count++;
                         }
-                        DBG(2, "** OVERFLOW %d into %d\n", rx_count, length);
+                        dev_dbg(musb->controller, "** OVERFLOW %d into %d\n", rx_count, length);
                         do_flush = 1;
                 } else
                         length = rx_count;
@@ -510,7 +498,7 @@ musb_host_packet_rx(struct musb *musb, struct urb *urb, u8 epnum, u8 iso_err)
                 if (rx_count > length) {
                         if (urb->status == -EINPROGRESS)
                                 urb->status = -EOVERFLOW;
-                        DBG(2, "** OVERFLOW %d into %d\n", rx_count, length);
+                        dev_dbg(musb->controller, "** OVERFLOW %d into %d\n", rx_count, length);
                         do_flush = 1;
                 } else
                         length = rx_count;
@@ -608,7 +596,7 @@ musb_rx_reinit(struct musb *musb, struct musb_qh *qh, struct musb_hw_ep *ep)
         /* Set RXMAXP with the FIFO size of the endpoint
          * to disable double buffer mode.
          */
-        if (musb->hwvers < MUSB_HWVERS_2000)
+        if (musb->double_buffer_not_ok)
                 musb_writew(ep->regs, MUSB_RXMAXP, ep->max_packet_sz_rx);
         else
                 musb_writew(ep->regs, MUSB_RXMAXP,
@@ -696,7 +684,7 @@ static void musb_ep_program(struct musb *musb, u8 epnum,
         struct musb_qh          *qh = musb_ep_get_qh(hw_ep, !is_out);
         u16                     packet_sz = qh->maxpacket;
 
-        DBG(3, "%s hw%d urb %p spd%d dev%d ep%d%s "
+        dev_dbg(musb->controller, "%s hw%d urb %p spd%d dev%d ep%d%s "
                                 "h_addr%02x h_port%02x bytes %d\n",
                         is_out ? "-->" : "<--",
                         epnum, urb, urb->dev->speed,
@@ -783,14 +771,13 @@ static void musb_ep_program(struct musb *musb, u8 epnum,
                 /* protocol/endpoint/interval/NAKlimit */
                 if (epnum) {
                         musb_writeb(epio, MUSB_TXTYPE, qh->type_reg);
-                        if (can_bulk_split(musb, qh->type))
+                        if (musb->double_buffer_not_ok)
                                 musb_writew(epio, MUSB_TXMAXP,
-                                        packet_sz
-                                        | ((hw_ep->max_packet_sz_tx /
-                                                packet_sz) - 1) << 11);
+                                                hw_ep->max_packet_sz_tx);
                         else
                                 musb_writew(epio, MUSB_TXMAXP,
-                                        packet_sz);
+                                                qh->maxpacket |
+                                                ((qh->hb_mult - 1) << 11));
                         musb_writeb(epio, MUSB_TXINTERVAL, qh->intv_reg);
                 } else {
                         musb_writeb(epio, MUSB_NAKLIMIT0, qh->intv_reg);
@@ -850,37 +837,32 @@ static void musb_ep_program(struct musb *musb, u8 epnum,
                 /* kick things off */
 
                 if ((is_cppi_enabled() || tusb_dma_omap()) && dma_channel) {
-                        /* candidate for DMA */
-                        if (dma_channel) {
-                                dma_channel->actual_len = 0L;
-                                qh->segsize = len;
-
-                                /* AUTOREQ is in a DMA register */
-                                musb_writew(hw_ep->regs, MUSB_RXCSR, csr);
-                                csr = musb_readw(hw_ep->regs,
-                                                MUSB_RXCSR);
-
-                                /* unless caller treats short rx transfers as
-                                 * errors, we dare not queue multiple transfers.
-                                 */
-                                dma_ok = dma_controller->channel_program(
-                                                dma_channel, packet_sz,
-                                                !(urb->transfer_flags
-                                                        & URB_SHORT_NOT_OK),
-                                                urb->transfer_dma + offset,
-                                                qh->segsize);
-                                if (!dma_ok) {
-                                        dma_controller->channel_release(
-                                                        dma_channel);
-                                        hw_ep->rx_channel = NULL;
-                                        dma_channel = NULL;
-                                } else
-                                        csr |= MUSB_RXCSR_DMAENAB;
-                        }
+                        /* Candidate for DMA */
+                        dma_channel->actual_len = 0L;
+                        qh->segsize = len;
+
+                        /* AUTOREQ is in a DMA register */
+                        musb_writew(hw_ep->regs, MUSB_RXCSR, csr);
+                        csr = musb_readw(hw_ep->regs, MUSB_RXCSR);
+
+                        /*
+                         * Unless caller treats short RX transfers as
+                         * errors, we dare not queue multiple transfers.
+                         */
+                        dma_ok = dma_controller->channel_program(dma_channel,
+                                        packet_sz, !(urb->transfer_flags &
+                                                     URB_SHORT_NOT_OK),
+                                        urb->transfer_dma + offset,
+                                        qh->segsize);
+                        if (!dma_ok) {
+                                dma_controller->channel_release(dma_channel);
+                                hw_ep->rx_channel = dma_channel = NULL;
+                        } else
+                                csr |= MUSB_RXCSR_DMAENAB;
                 }
 
                 csr |= MUSB_RXCSR_H_REQPKT;
-                DBG(7, "RXCSR%d := %04x\n", epnum, csr);
+                dev_dbg(musb->controller, "RXCSR%d := %04x\n", epnum, csr);
                 musb_writew(hw_ep->regs, MUSB_RXCSR, csr);
                 csr = musb_readw(hw_ep->regs, MUSB_RXCSR);
         }
@@ -923,15 +905,15 @@ static bool musb_h_ep0_continue(struct musb *musb, u16 len, struct urb *urb)
                 request = (struct usb_ctrlrequest *) urb->setup_packet;
 
                 if (!request->wLength) {
-                        DBG(4, "start no-DATA\n");
+                        dev_dbg(musb->controller, "start no-DATA\n");
                         break;
                 } else if (request->bRequestType & USB_DIR_IN) {
-                        DBG(4, "start IN-DATA\n");
+                        dev_dbg(musb->controller, "start IN-DATA\n");
                         musb->ep0_stage = MUSB_EP0_IN;
                         more = true;
                         break;
                 } else {
-                        DBG(4, "start OUT-DATA\n");
+                        dev_dbg(musb->controller, "start OUT-DATA\n");
                         musb->ep0_stage = MUSB_EP0_OUT;
                         more = true;
                 }
@@ -943,7 +925,7 @@ static bool musb_h_ep0_continue(struct musb *musb, u16 len, struct urb *urb)
                 if (fifo_count) {
                         fifo_dest = (u8 *) (urb->transfer_buffer
                                         + urb->actual_length);
-                        DBG(3, "Sending %d byte%s to ep0 fifo %p\n",
+                        dev_dbg(musb->controller, "Sending %d byte%s to ep0 fifo %p\n",
                                         fifo_count,
                                         (fifo_count == 1) ? "" : "s",
                                         fifo_dest);
@@ -988,7 +970,7 @@ irqreturn_t musb_h_ep0_irq(struct musb *musb)
                         ? musb_readb(epio, MUSB_COUNT0)
                         : 0;
 
-        DBG(4, "<== csr0 %04x, qh %p, count %d, urb %p, stage %d\n",
+        dev_dbg(musb->controller, "<== csr0 %04x, qh %p, count %d, urb %p, stage %d\n",
                 csr, qh, len, urb, musb->ep0_stage);
 
         /* if we just did status stage, we are done */
@@ -999,15 +981,15 @@ irqreturn_t musb_h_ep0_irq(struct musb *musb)
 
         /* prepare status */
         if (csr & MUSB_CSR0_H_RXSTALL) {
-                DBG(6, "STALLING ENDPOINT\n");
+                dev_dbg(musb->controller, "STALLING ENDPOINT\n");
                 status = -EPIPE;
 
         } else if (csr & MUSB_CSR0_H_ERROR) {
-                DBG(2, "no response, csr0 %04x\n", csr);
+                dev_dbg(musb->controller, "no response, csr0 %04x\n", csr);
                 status = -EPROTO;
 
         } else if (csr & MUSB_CSR0_H_NAKTIMEOUT) {
-                DBG(2, "control NAK timeout\n");
+                dev_dbg(musb->controller, "control NAK timeout\n");
 
                 /* NOTE:  this code path would be a good place to PAUSE a
                  * control transfer, if another one is queued, so that
@@ -1022,7 +1004,7 @@ irqreturn_t musb_h_ep0_irq(struct musb *musb)
         }
 
         if (status) {
-                DBG(6, "aborting\n");
+                dev_dbg(musb->controller, "aborting\n");
                 retval = IRQ_HANDLED;
                 if (urb)
                         urb->status = status;
@@ -1072,7 +1054,7 @@ irqreturn_t musb_h_ep0_irq(struct musb *musb)
                         /* flag status stage */
                         musb->ep0_stage = MUSB_EP0_STATUS;
 
-                        DBG(5, "ep0 STATUS, csr %04x\n", csr);
+                        dev_dbg(musb->controller, "ep0 STATUS, csr %04x\n", csr);
 
                 }
                 musb_writew(epio, MUSB_CSR0, csr);
@@ -1119,37 +1101,38 @@ void musb_host_tx(struct musb *musb, u8 epnum)
         u32                     status = 0;
         void __iomem            *mbase = musb->mregs;
         struct dma_channel      *dma;
+        bool                    transfer_pending = false;
 
         musb_ep_select(mbase, epnum);
         tx_csr = musb_readw(epio, MUSB_TXCSR);
 
         /* with CPPI, DMA sometimes triggers "extra" irqs */
         if (!urb) {
-                DBG(4, "extra TX%d ready, csr %04x\n", epnum, tx_csr);
+                dev_dbg(musb->controller, "extra TX%d ready, csr %04x\n", epnum, tx_csr);
                 return;
         }
 
         pipe = urb->pipe;
         dma = is_dma_capable() ? hw_ep->tx_channel : NULL;
-        DBG(4, "OUT/TX%d end, csr %04x%s\n", epnum, tx_csr,
+        dev_dbg(musb->controller, "OUT/TX%d end, csr %04x%s\n", epnum, tx_csr,
                         dma ? ", dma" : "");
 
         /* check for errors */
         if (tx_csr & MUSB_TXCSR_H_RXSTALL) {
                 /* dma was disabled, fifo flushed */
-                DBG(3, "TX end %d stall\n", epnum);
+                dev_dbg(musb->controller, "TX end %d stall\n", epnum);
 
                 /* stall; record URB status */
                 status = -EPIPE;
 
         } else if (tx_csr & MUSB_TXCSR_H_ERROR) {
                 /* (NON-ISO) dma was disabled, fifo flushed */
-                DBG(3, "TX 3strikes on ep=%d\n", epnum);
+                dev_dbg(musb->controller, "TX 3strikes on ep=%d\n", epnum);
 
                 status = -ETIMEDOUT;
 
         } else if (tx_csr & MUSB_TXCSR_H_NAKTIMEOUT) {
-                DBG(6, "TX end=%d device not responding\n", epnum);
+                dev_dbg(musb->controller, "TX end=%d device not responding\n", epnum);
 
                 /* NOTE:  this code path would be a good place to PAUSE a
                  * transfer, if there's some other (nonperiodic) tx urb
@@ -1194,7 +1177,7 @@ void musb_host_tx(struct musb *musb, u8 epnum)
 
         /* second cppi case */
         if (dma_channel_status(dma) == MUSB_DMA_STATUS_BUSY) {
-                DBG(4, "extra TX%d ready, csr %04x\n", epnum, tx_csr);
+                dev_dbg(musb->controller, "extra TX%d ready, csr %04x\n", epnum, tx_csr);
                 return;
         }
 
@@ -1253,7 +1236,7 @@ void musb_host_tx(struct musb *musb, u8 epnum)
                  * FIFO mode too...
                  */
                 if (tx_csr & (MUSB_TXCSR_FIFONOTEMPTY | MUSB_TXCSR_TXPKTRDY)) {
-                        DBG(2, "DMA complete but packet still in FIFO, "
+                        dev_dbg(musb->controller, "DMA complete but packet still in FIFO, "
                             "CSR %04x\n", tx_csr);
                         return;
                 }
@@ -1279,7 +1262,7 @@ void musb_host_tx(struct musb *musb, u8 epnum)
                                 offset = d->offset;
                                 length = d->length;
                         }
-                } else if (dma) {
+                } else if (dma && urb->transfer_buffer_length == qh->offset) {
                         done = true;
                 } else {
                         /* see if we need to send more data, or ZLP */
@@ -1292,6 +1275,7 @@ void musb_host_tx(struct musb *musb, u8 epnum)
                         if (!done) {
                                 offset = qh->offset;
                                 length = urb->transfer_buffer_length - offset;
+                                transfer_pending = true;
                         }
                 }
         }
@@ -1311,7 +1295,7 @@ void musb_host_tx(struct musb *musb, u8 epnum)
                 urb->actual_length = qh->offset;
                 musb_advance_schedule(musb, urb, hw_ep, USB_DIR_OUT);
                 return;
-        } else  if (usb_pipeisoc(pipe) && dma) {
+        } else if ((usb_pipeisoc(pipe) || transfer_pending) && dma) {
                 if (musb_tx_dma_program(musb->dma_controller, hw_ep, qh, urb,
                                 offset, length)) {
                         if (is_cppi_enabled() || tusb_dma_omap())
@@ -1319,7 +1303,7 @@ void musb_host_tx(struct musb *musb, u8 epnum)
                         return;
                 }
         } else  if (tx_csr & MUSB_TXCSR_DMAENAB) {
-                DBG(1, "not complete, but DMA enabled?\n");
+                dev_dbg(musb->controller, "not complete, but DMA enabled?\n");
                 return;
         }
 
@@ -1332,6 +1316,8 @@ void musb_host_tx(struct musb *musb, u8 epnum)
          */
         if (length > qh->maxpacket)
                 length = qh->maxpacket;
+        /* Unmap the buffer so that CPU can use it */
+        usb_hcd_unmap_urb_for_dma(musb_to_hcd(musb), urb);
         musb_write_fifo(hw_ep, length, urb->transfer_buffer + offset);
         qh->segsize = length;
 
@@ -1458,7 +1444,7 @@ void musb_host_rx(struct musb *musb, u8 epnum)
                  * usbtest #11 (unlinks) triggers it regularly, sometimes
                  * with fifo full.  (Only with DMA??)
                  */
-                DBG(3, "BOGUS RX%d ready, csr %04x, count %d\n", epnum, val,
+                dev_dbg(musb->controller, "BOGUS RX%d ready, csr %04x, count %d\n", epnum, val,
                         musb_readw(epio, MUSB_RXCOUNT));
                 musb_h_flush_rxfifo(hw_ep, MUSB_RXCSR_CLRDATATOG);
                 return;
@@ -1466,20 +1452,20 @@ void musb_host_rx(struct musb *musb, u8 epnum)
 
         pipe = urb->pipe;
 
-        DBG(5, "<== hw %d rxcsr %04x, urb actual %d (+dma %zu)\n",
+        dev_dbg(musb->controller, "<== hw %d rxcsr %04x, urb actual %d (+dma %zu)\n",
                 epnum, rx_csr, urb->actual_length,
                 dma ? dma->actual_len : 0);
 
         /* check for errors, concurrent stall & unlink is not really
          * handled yet! */
         if (rx_csr & MUSB_RXCSR_H_RXSTALL) {
-                DBG(3, "RX end %d STALL\n", epnum);
+                dev_dbg(musb->controller, "RX end %d STALL\n", epnum);
 
                 /* stall; record URB status */
                 status = -EPIPE;
 
         } else if (rx_csr & MUSB_RXCSR_H_ERROR) {
-                DBG(3, "end %d RX proto error\n", epnum);
+                dev_dbg(musb->controller, "end %d RX proto error\n", epnum);
 
                 status = -EPROTO;
                 musb_writeb(epio, MUSB_RXINTERVAL, 0);
@@ -1487,7 +1473,7 @@ void musb_host_rx(struct musb *musb, u8 epnum)
         } else if (rx_csr & MUSB_RXCSR_DATAERROR) {
 
                 if (USB_ENDPOINT_XFER_ISOC != qh->type) {
-                        DBG(6, "RX end %d NAK timeout\n", epnum);
+                        dev_dbg(musb->controller, "RX end %d NAK timeout\n", epnum);
 
                         /* NOTE: NAKing is *NOT* an error, so we want to
                          * continue.  Except ... if there's a request for
@@ -1510,12 +1496,12 @@ void musb_host_rx(struct musb *musb, u8 epnum)
 
                         goto finish;
                 } else {
-                        DBG(4, "RX end %d ISO data error\n", epnum);
+                        dev_dbg(musb->controller, "RX end %d ISO data error\n", epnum);
                         /* packet error reported later */
                         iso_err = true;
                 }
         } else if (rx_csr & MUSB_RXCSR_INCOMPRX) {
-                DBG(3, "end %d high bandwidth incomplete ISO packet RX\n",
+                dev_dbg(musb->controller, "end %d high bandwidth incomplete ISO packet RX\n",
                                 epnum);
                 status = -EPROTO;
         }
@@ -1561,7 +1547,7 @@ void musb_host_rx(struct musb *musb, u8 epnum)
                         done = true;
                 }
 
-                DBG(2, "RXCSR%d %04x, reqpkt, len %zu%s\n", epnum, rx_csr,
+                dev_dbg(musb->controller, "RXCSR%d %04x, reqpkt, len %zu%s\n", epnum, rx_csr,
                                 xfer_len, dma ? ", dma" : "");
                 rx_csr &= ~MUSB_RXCSR_H_REQPKT;
 
@@ -1589,7 +1575,7 @@ void musb_host_rx(struct musb *musb, u8 epnum)
                         /* even if there was an error, we did the dma
                          * for iso_frame_desc->length
                          */
-                        if (d->status != EILSEQ && d->status != -EOVERFLOW)
+                        if (d->status != -EILSEQ && d->status != -EOVERFLOW)
                                 d->status = 0;
 
                         if (++qh->iso_idx >= urb->number_of_packets)
@@ -1611,7 +1597,7 @@ void musb_host_rx(struct musb *musb, u8 epnum)
                                 MUSB_RXCSR_H_WZC_BITS | val);
                 }
 
-                DBG(4, "ep %d dma %s, rxcsr %04x, rxcount %d\n", epnum,
+                dev_dbg(musb->controller, "ep %d dma %s, rxcsr %04x, rxcount %d\n", epnum,
                         done ? "off" : "reset",
                         musb_readw(epio, MUSB_RXCSR),
                         musb_readw(epio, MUSB_RXCOUNT));
@@ -1644,7 +1630,7 @@ void musb_host_rx(struct musb *musb, u8 epnum)
 
                         rx_count = musb_readw(epio, MUSB_RXCOUNT);
 
-                        DBG(2, "RX%d count %d, buffer 0x%x len %d/%d\n",
+                        dev_dbg(musb->controller, "RX%d count %d, buffer 0x%x len %d/%d\n",
                                         epnum, rx_count,
                                         urb->transfer_dma
                                                 + urb->actual_length,
@@ -1668,7 +1654,7 @@ void musb_host_rx(struct musb *musb, u8 epnum)
                                                 d_status = -EOVERFLOW;
                                                 urb->error_count++;
                                         }
-                                        DBG(2, "** OVERFLOW %d into %d\n",\
+                                        dev_dbg(musb->controller, "** OVERFLOW %d into %d\n",\
                                             rx_count, d->length);
 
                                         length = d->length;
@@ -1752,9 +1738,11 @@ void musb_host_rx(struct musb *musb, u8 epnum)
 #endif  /* Mentor DMA */
 
                 if (!dma) {
+                        /* Unmap the buffer so that CPU can use it */
+                        usb_hcd_unmap_urb_for_dma(musb_to_hcd(musb), urb);
                         done = musb_host_packet_rx(musb, urb,
                                         epnum, iso_err);
-                        DBG(6, "read %spacket\n", done ? "last " : "");
+                        dev_dbg(musb->controller, "read %spacket\n", done ? "last " : "");
                 }
         }
 
@@ -1875,7 +1863,7 @@ static int musb_schedule(
         idle = 1;
         qh->mux = 0;
         hw_ep = musb->endpoints + best_end;
-        DBG(4, "qh %p periodic slot %d\n", qh, best_end);
+        dev_dbg(musb->controller, "qh %p periodic slot %d\n", qh, best_end);
 success:
         if (head) {
                 idle = list_empty(head);
@@ -2081,6 +2069,7 @@ done:
 static int musb_cleanup_urb(struct urb *urb, struct musb_qh *qh)
 {
         struct musb_hw_ep       *ep = qh->hw_ep;
+        struct musb             *musb = ep->musb;
         void __iomem            *epio = ep->regs;
         unsigned                hw_end = ep->epnum;
         void __iomem            *regs = ep->musb->mregs;
@@ -2096,7 +2085,7 @@ static int musb_cleanup_urb(struct urb *urb, struct musb_qh *qh)
                 dma = is_in ? ep->rx_channel : ep->tx_channel;
                 if (dma) {
                         status = ep->musb->dma_controller->channel_abort(dma);
-                        DBG(status ? 1 : 3,
+                        dev_dbg(musb->controller,
                                 "abort %cX%d DMA for urb %p --> %d\n",
                                 is_in ? 'R' : 'T', ep->epnum,
                                 urb, status);
@@ -2143,7 +2132,7 @@ static int musb_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
         int                     is_in  = usb_pipein(urb->pipe);
         int                     ret;
 
-        DBG(4, "urb=%p, dev%d ep%d%s\n", urb,
+        dev_dbg(musb->controller, "urb=%p, dev%d ep%d%s\n", urb,
                         usb_pipedevice(urb->pipe),
                         usb_pipeendpoint(urb->pipe),
                         is_in ? "in" : "out");
@@ -2298,7 +2287,7 @@ static int musb_bus_suspend(struct usb_hcd *hcd)
 
         if (musb->is_active) {
                 WARNING("trying to suspend as %s while active\n",
-                                otg_state_string(musb));
+                                otg_state_string(musb->xceiv->state));
                 return -EBUSY;
         } else
                 return 0;
diff --git a/drivers/usb/musb/musb_io.h b/drivers/usb/musb/musb_io.h
index b06e9ef00cfc..03c6ccdbb3be 100644
--- a/drivers/usb/musb/musb_io.h
+++ b/drivers/usb/musb/musb_io.h
@@ -74,7 +74,7 @@ static inline void musb_writel(void __iomem *addr, unsigned offset, u32 data)
         { __raw_writel(data, addr + offset); }
 
 
-#ifdef CONFIG_USB_TUSB6010
+#ifdef CONFIG_USB_MUSB_TUSB6010
 
 /*
  * TUSB6010 doesn't allow 8-bit access; 16-bit access is the minimum.
@@ -114,7 +114,7 @@ static inline u8 musb_readb(const void __iomem *addr, unsigned offset)
 static inline void musb_writeb(void __iomem *addr, unsigned offset, u8 data)
         { __raw_writeb(data, addr + offset); }
 
-#endif  /* CONFIG_USB_TUSB6010 */
+#endif  /* CONFIG_USB_MUSB_TUSB6010 */
 
 #else
 
diff --git a/drivers/usb/musb/musb_regs.h b/drivers/usb/musb/musb_regs.h
index 244267527a60..82410703dcd3 100644
--- a/drivers/usb/musb/musb_regs.h
+++ b/drivers/usb/musb/musb_regs.h
@@ -234,7 +234,7 @@
 #define MUSB_TESTMODE           0x0F    /* 8 bit */
 
 /* Get offset for a given FIFO from musb->mregs */
-#ifdef  CONFIG_USB_TUSB6010
+#ifdef  CONFIG_USB_MUSB_TUSB6010
 #define MUSB_FIFO_OFFSET(epnum) (0x200 + ((epnum) * 0x20))
 #else
 #define MUSB_FIFO_OFFSET(epnum) (0x20 + ((epnum) * 4))
@@ -295,7 +295,7 @@
 #define MUSB_FLAT_OFFSET(_epnum, _offset)       \
         (0x100 + (0x10*(_epnum)) + (_offset))
 
-#ifdef CONFIG_USB_TUSB6010
+#ifdef CONFIG_USB_MUSB_TUSB6010
 /* TUSB6010 EP0 configuration register is special */
 #define MUSB_TUSB_OFFSET(_epnum, _offset)       \
         (0x10 + _offset)
@@ -633,8 +633,9 @@ static inline u8  musb_read_txhubaddr(void __iomem *mbase, u8 epnum)
         return 0;
 }
 
-static inline void  musb_read_txhubport(void __iomem *mbase, u8 epnum)
+static inline u8 musb_read_txhubport(void __iomem *mbase, u8 epnum)
 {
+        return 0;
 }
 
 #endif /* CONFIG_BLACKFIN */
diff --git a/drivers/usb/musb/musb_virthub.c b/drivers/usb/musb/musb_virthub.c
index 43233c397b6e..2d80a5758838 100644
--- a/drivers/usb/musb/musb_virthub.c
+++ b/drivers/usb/musb/musb_virthub.c
@@ -74,7 +74,7 @@ static void musb_port_suspend(struct musb *musb, bool do_suspend)
                                 break;
                 }
 
-                DBG(3, "Root port suspended, power %02x\n", power);
+                dev_dbg(musb->controller, "Root port suspended, power %02x\n", power);
 
                 musb->port1_status |= USB_PORT_STAT_SUSPEND;
                 switch (musb->xceiv->state) {
@@ -97,15 +97,15 @@ static void musb_port_suspend(struct musb *musb, bool do_suspend)
                         break;
 #endif
                 default:
-                        DBG(1, "bogus rh suspend? %s\n",
-                                otg_state_string(musb));
+                        dev_dbg(musb->controller, "bogus rh suspend? %s\n",
+                                otg_state_string(musb->xceiv->state));
                 }
         } else if (power & MUSB_POWER_SUSPENDM) {
                 power &= ~MUSB_POWER_SUSPENDM;
                 power |= MUSB_POWER_RESUME;
                 musb_writeb(mbase, MUSB_POWER, power);
 
-                DBG(3, "Root port resuming, power %02x\n", power);
+                dev_dbg(musb->controller, "Root port resuming, power %02x\n", power);
 
                 /* later, GetPortStatus will stop RESUME signaling */
                 musb->port1_status |= MUSB_PORT_STAT_RESUME;
@@ -120,7 +120,7 @@ static void musb_port_reset(struct musb *musb, bool do_reset)
 
 #ifdef CONFIG_USB_MUSB_OTG
         if (musb->xceiv->state == OTG_STATE_B_IDLE) {
-                DBG(2, "HNP: Returning from HNP; no hub reset from b_idle\n");
+                dev_dbg(musb->controller, "HNP: Returning from HNP; no hub reset from b_idle\n");
                 musb->port1_status &= ~USB_PORT_STAT_RESET;
                 return;
         }
@@ -159,7 +159,7 @@ static void musb_port_reset(struct musb *musb, bool do_reset)
                 musb->port1_status &= ~USB_PORT_STAT_ENABLE;
                 musb->rh_timer = jiffies + msecs_to_jiffies(50);
         } else {
-                DBG(4, "root port reset stopped\n");
+                dev_dbg(musb->controller, "root port reset stopped\n");
                 musb_writeb(mbase, MUSB_POWER,
                                 power & ~MUSB_POWER_RESET);
 
@@ -167,7 +167,7 @@ static void musb_port_reset(struct musb *musb, bool do_reset)
 
                 power = musb_readb(mbase, MUSB_POWER);
                 if (power & MUSB_POWER_HSMODE) {
-                        DBG(4, "high-speed device connected\n");
+                        dev_dbg(musb->controller, "high-speed device connected\n");
                         musb->port1_status |= USB_PORT_STAT_HIGH_SPEED;
                 }
 
@@ -208,7 +208,8 @@ void musb_root_disconnect(struct musb *musb)
                 musb->xceiv->state = OTG_STATE_B_IDLE;
                 break;
         default:
-                DBG(1, "host disconnect (%s)\n", otg_state_string(musb));
+                dev_dbg(musb->controller, "host disconnect (%s)\n",
+                        otg_state_string(musb->xceiv->state));
         }
 }
 
@@ -276,7 +277,7 @@ int musb_hub_control(
                         break;
                 case USB_PORT_FEAT_POWER:
                         if (!(is_otg_enabled(musb) && hcd->self.is_b_host))
-                                musb_set_vbus(musb, 0);
+                                musb_platform_set_vbus(musb, 0);
                         break;
                 case USB_PORT_FEAT_C_CONNECTION:
                 case USB_PORT_FEAT_C_ENABLE:
@@ -287,7 +288,7 @@ int musb_hub_control(
                 default:
                         goto error;
                 }
-                DBG(5, "clear feature %d\n", wValue);
+                dev_dbg(musb->controller, "clear feature %d\n", wValue);
                 musb->port1_status &= ~(1 << wValue);
                 break;
         case GetHubDescriptor:
@@ -305,8 +306,8 @@ int musb_hub_control(
                 desc->bHubContrCurrent = 0;
 
                 /* workaround bogus struct definition */
-                desc->DeviceRemovable[0] = 0x02;        /* port 1 */
-                desc->DeviceRemovable[1] = 0xff;
+                desc->u.hs.DeviceRemovable[0] = 0x02;   /* port 1 */
+                desc->u.hs.DeviceRemovable[1] = 0xff;
                 }
                 break;
         case GetHubStatus:
@@ -329,7 +330,7 @@ int musb_hub_control(
 
                         power = musb_readb(musb->mregs, MUSB_POWER);
                         power &= ~MUSB_POWER_RESUME;
-                        DBG(4, "root port resume stopped, power %02x\n",
+                        dev_dbg(musb->controller, "root port resume stopped, power %02x\n",
                                         power);
                         musb_writeb(musb->mregs, MUSB_POWER, power);
 
@@ -352,7 +353,7 @@ int musb_hub_control(
                                 (__le32 *) buf);
 
                 /* port change status is more interesting */
-                DBG(get_unaligned((u16 *)(buf+2)) ? 2 : 5, "port status %08x\n",
+                dev_dbg(musb->controller, "port status %08x\n",
                                 musb->port1_status);
                 break;
         case SetPortFeature:
@@ -423,7 +424,7 @@ int musb_hub_control(
                 default:
                         goto error;
                 }
-                DBG(5, "set feature %d\n", wValue);
+                dev_dbg(musb->controller, "set feature %d\n", wValue);
                 musb->port1_status |= 1 << wValue;
                 break;
 
diff --git a/drivers/usb/musb/musbhsdma.c b/drivers/usb/musb/musbhsdma.c
index 6dc107f25245..f70c5a577736 100644
--- a/drivers/usb/musb/musbhsdma.c
+++ b/drivers/usb/musb/musbhsdma.c
@@ -91,7 +91,7 @@ static struct dma_channel *dma_channel_allocate(struct dma_controller *c,
                         channel = &(musb_channel->channel);
                         channel->private_data = musb_channel;
                         channel->status = MUSB_DMA_STATUS_FREE;
-                        channel->max_len = 0x10000;
+                        channel->max_len = 0x100000;
                         /* Tx => mode 1; Rx => mode 0 */
                         channel->desired_mode = transmit;
                         channel->actual_len = 0;
@@ -122,11 +122,12 @@ static void configure_channel(struct dma_channel *channel,
 {
         struct musb_dma_channel *musb_channel = channel->private_data;
         struct musb_dma_controller *controller = musb_channel->controller;
+        struct musb *musb = controller->private_data;
         void __iomem *mbase = controller->base;
         u8 bchannel = musb_channel->idx;
         u16 csr = 0;
 
-        DBG(4, "%p, pkt_sz %d, addr 0x%x, len %d, mode %d\n",
+        dev_dbg(musb->controller, "%p, pkt_sz %d, addr 0x%x, len %d, mode %d\n",
                         channel, packet_sz, dma_addr, len, mode);
 
         if (mode) {
@@ -158,8 +159,10 @@ static int dma_channel_program(struct dma_channel *channel,
                                 dma_addr_t dma_addr, u32 len)
 {
         struct musb_dma_channel *musb_channel = channel->private_data;
+        struct musb_dma_controller *controller = musb_channel->controller;
+        struct musb *musb = controller->private_data;
 
-        DBG(2, "ep%d-%s pkt_sz %d, dma_addr 0x%x length %d, mode %d\n",
+        dev_dbg(musb->controller, "ep%d-%s pkt_sz %d, dma_addr 0x%x length %d, mode %d\n",
                 musb_channel->epnum,
                 musb_channel->transmit ? "Tx" : "Rx",
                 packet_sz, dma_addr, len, mode);
@@ -167,6 +170,26 @@ static int dma_channel_program(struct dma_channel *channel,
         BUG_ON(channel->status == MUSB_DMA_STATUS_UNKNOWN ||
                 channel->status == MUSB_DMA_STATUS_BUSY);
 
+        /* Let targets check/tweak the arguments */
+        if (musb->ops->adjust_channel_params) {
+                int ret = musb->ops->adjust_channel_params(channel,
+                        packet_sz, &mode, &dma_addr, &len);
+                if (ret)
+                        return ret;
+        }
+
+        /*
+         * The DMA engine in RTL1.8 and above cannot handle
+         * DMA addresses that are not aligned to a 4 byte boundary.
+         * It ends up masking the last two bits of the address
+         * programmed in DMA_ADDR.
+         *
+         * Fail such DMA transfers, so that the backup PIO mode
+         * can carry out the transfer
+         */
+        if ((musb->hwvers >= MUSB_HWVERS_1800) && (dma_addr % 4))
+                return false;
+
         channel->actual_len = 0;
         musb_channel->start_addr = dma_addr;
         musb_channel->len = len;
@@ -252,7 +275,7 @@ static irqreturn_t dma_controller_irq(int irq, void *private_data)
 #endif
 
         if (!int_hsdma) {
-                DBG(2, "spurious DMA irq\n");
+                dev_dbg(musb->controller, "spurious DMA irq\n");
 
                 for (bchannel = 0; bchannel < MUSB_HSDMA_CHANNELS; bchannel++) {
                         musb_channel = (struct musb_dma_channel *)
@@ -266,7 +289,7 @@ static irqreturn_t dma_controller_irq(int irq, void *private_data)
                         }
                 }
 
-                DBG(2, "int_hsdma = 0x%x\n", int_hsdma);
+                dev_dbg(musb->controller, "int_hsdma = 0x%x\n", int_hsdma);
 
                 if (!int_hsdma)
                         goto done;
@@ -293,7 +316,7 @@ static irqreturn_t dma_controller_irq(int irq, void *private_data)
                                 channel->actual_len = addr
                                         - musb_channel->start_addr;
 
-                                DBG(2, "ch %p, 0x%x -> 0x%x (%zu / %d) %s\n",
+                                dev_dbg(musb->controller, "ch %p, 0x%x -> 0x%x (%zu / %d) %s\n",
                                         channel, musb_channel->start_addr,
                                         addr, channel->actual_len,
                                         musb_channel->len,
@@ -363,7 +386,7 @@ dma_controller_create(struct musb *musb, void __iomem *base)
         struct musb_dma_controller *controller;
         struct device *dev = musb->controller;
         struct platform_device *pdev = to_platform_device(dev);
-        int irq = platform_get_irq(pdev, 1);
+        int irq = platform_get_irq_byname(pdev, "dma");
 
         if (irq == 0) {
                 dev_err(dev, "No DMA interrupt line!\n");
diff --git a/drivers/usb/musb/musbhsdma.h b/drivers/usb/musb/musbhsdma.h
index f763d62f151c..320fd4afb93f 100644
--- a/drivers/usb/musb/musbhsdma.h
+++ b/drivers/usb/musb/musbhsdma.h
@@ -31,7 +31,7 @@
  *
  */
 
-#if defined(CONFIG_ARCH_OMAP2430) || defined(CONFIG_ARCH_OMAP3430)
+#if defined(CONFIG_SOC_OMAP2430) || defined(CONFIG_SOC_OMAP3430)
 #include "omap2430.h"
 #endif
 
@@ -94,24 +94,33 @@ static inline void musb_write_hsdma_addr(void __iomem *mbase,
 {
         musb_writew(mbase,
                 MUSB_HSDMA_CHANNEL_OFFSET(bchannel, MUSB_HSDMA_ADDR_LOW),
-                ((u16)((u32) dma_addr & 0xFFFF)));
+                dma_addr);
         musb_writew(mbase,
                 MUSB_HSDMA_CHANNEL_OFFSET(bchannel, MUSB_HSDMA_ADDR_HIGH),
-                ((u16)(((u32) dma_addr >> 16) & 0xFFFF)));
+                (dma_addr >> 16));
 }
 
 static inline u32 musb_read_hsdma_count(void __iomem *mbase, u8 bchannel)
 {
-        return musb_readl(mbase,
+        u32 count = musb_readw(mbase,
                 MUSB_HSDMA_CHANNEL_OFFSET(bchannel, MUSB_HSDMA_COUNT_HIGH));
+
+        count = count << 16;
+
+        count |= musb_readw(mbase,
+                MUSB_HSDMA_CHANNEL_OFFSET(bchannel, MUSB_HSDMA_COUNT_LOW));
+
+        return count;
 }
 
 static inline void musb_write_hsdma_count(void __iomem *mbase,
                                 u8 bchannel, u32 len)
 {
-        musb_writel(mbase,
+        musb_writew(mbase,
+                MUSB_HSDMA_CHANNEL_OFFSET(bchannel, MUSB_HSDMA_COUNT_LOW),len);
+        musb_writew(mbase,
                 MUSB_HSDMA_CHANNEL_OFFSET(bchannel, MUSB_HSDMA_COUNT_HIGH),
-                len);
+                (len >> 16));
 }
 
 #endif /* CONFIG_BLACKFIN */
diff --git a/drivers/usb/musb/omap2430.c b/drivers/usb/musb/omap2430.c
index 2111a241dd03..c5d4c44d0ffa 100644
--- a/drivers/usb/musb/omap2430.c
+++ b/drivers/usb/musb/omap2430.c
@@ -31,10 +31,19 @@
 #include <linux/list.h>
 #include <linux/clk.h>
 #include <linux/io.h>
+#include <linux/platform_device.h>
+#include <linux/dma-mapping.h>
+#include <linux/pm_runtime.h>
+#include <linux/err.h>
 
 #include "musb_core.h"
 #include "omap2430.h"
 
+struct omap2430_glue {
+        struct device           *dev;
+        struct platform_device  *musb;
+};
+#define glue_to_musb(g)         platform_get_drvdata(g->musb)
 
 static struct timer_list musb_idle_timer;
 
@@ -49,12 +58,8 @@ static void musb_do_idle(unsigned long _musb)
 
         spin_lock_irqsave(&musb->lock, flags);
 
-        devctl = musb_readb(musb->mregs, MUSB_DEVCTL);
-
         switch (musb->xceiv->state) {
         case OTG_STATE_A_WAIT_BCON:
-                devctl &= ~MUSB_DEVCTL_SESSION;
-                musb_writeb(musb->mregs, MUSB_DEVCTL, devctl);
 
                 devctl = musb_readb(musb->mregs, MUSB_DEVCTL);
                 if (devctl & MUSB_DEVCTL_BDEVICE) {
@@ -71,7 +76,7 @@ static void musb_do_idle(unsigned long _musb)
                 if (musb->port1_status & MUSB_PORT_STAT_RESUME) {
                         power = musb_readb(musb->mregs, MUSB_POWER);
                         power &= ~MUSB_POWER_RESUME;
-                        DBG(1, "root port resume stopped, power %02x\n", power);
+                        dev_dbg(musb->controller, "root port resume stopped, power %02x\n", power);
                         musb_writeb(musb->mregs, MUSB_POWER, power);
                         musb->is_active = 1;
                         musb->port1_status &= ~(USB_PORT_STAT_SUSPEND
@@ -98,7 +103,7 @@ static void musb_do_idle(unsigned long _musb)
 }
 
 
-void musb_platform_try_idle(struct musb *musb, unsigned long timeout)
+static void omap2430_musb_try_idle(struct musb *musb, unsigned long timeout)
 {
         unsigned long           default_timeout = jiffies + msecs_to_jiffies(3);
         static unsigned long    last_timer;
@@ -109,7 +114,8 @@ void musb_platform_try_idle(struct musb *musb, unsigned long timeout)
         /* Never idle if active, or when VBUS timeout is not set as host */
         if (musb->is_active || ((musb->a_wait_bcon == 0)
                         && (musb->xceiv->state == OTG_STATE_A_WAIT_BCON))) {
-                DBG(4, "%s active, deleting timer\n", otg_state_string(musb));
+                dev_dbg(musb->controller, "%s active, deleting timer\n",
+                        otg_state_string(musb->xceiv->state));
                 del_timer(&musb_idle_timer);
                 last_timer = jiffies;
                 return;
@@ -119,27 +125,23 @@ void musb_platform_try_idle(struct musb *musb, unsigned long timeout)
                 if (!timer_pending(&musb_idle_timer))
                         last_timer = timeout;
                 else {
-                        DBG(4, "Longer idle timer already pending, ignoring\n");
+                        dev_dbg(musb->controller, "Longer idle timer already pending, ignoring\n");
                         return;
                 }
         }
         last_timer = timeout;
 
-        DBG(4, "%s inactive, for idle timer for %lu ms\n",
-                otg_state_string(musb),
+        dev_dbg(musb->controller, "%s inactive, for idle timer for %lu ms\n",
+                otg_state_string(musb->xceiv->state),
                 (unsigned long)jiffies_to_msecs(timeout - jiffies));
         mod_timer(&musb_idle_timer, timeout);
 }
 
-void musb_platform_enable(struct musb *musb)
-{
-}
-void musb_platform_disable(struct musb *musb)
-{
-}
-static void omap_set_vbus(struct musb *musb, int is_on)
+static void omap2430_musb_set_vbus(struct musb *musb, int is_on)
 {
         u8              devctl;
+        unsigned long timeout = jiffies + msecs_to_jiffies(1000);
+        int ret = 1;
         /* HDRC controls CPEN, but beware current surges during device
          * connect.  They can trigger transient overcurrent conditions
          * that must be ignored.
@@ -148,12 +150,35 @@ static void omap_set_vbus(struct musb *musb, int is_on)
         devctl = musb_readb(musb->mregs, MUSB_DEVCTL);
 
         if (is_on) {
-                musb->is_active = 1;
-                musb->xceiv->default_a = 1;
-                musb->xceiv->state = OTG_STATE_A_WAIT_VRISE;
-                devctl |= MUSB_DEVCTL_SESSION;
-
-                MUSB_HST_MODE(musb);
+                if (musb->xceiv->state == OTG_STATE_A_IDLE) {
+                        /* start the session */
+                        devctl |= MUSB_DEVCTL_SESSION;
+                        musb_writeb(musb->mregs, MUSB_DEVCTL, devctl);
+                        /*
+                         * Wait for the musb to set as A device to enable the
+                         * VBUS
+                         */
+                        while (musb_readb(musb->mregs, MUSB_DEVCTL) & 0x80) {
+
+                                cpu_relax();
+
+                                if (time_after(jiffies, timeout)) {
+                                        dev_err(musb->controller,
+                                        "configured as A device timeout");
+                                        ret = -EINVAL;
+                                        break;
+                                }
+                        }
+
+                        if (ret && musb->xceiv->set_vbus)
+                                otg_set_vbus(musb->xceiv, 1);
+                } else {
+                        musb->is_active = 1;
+                        musb->xceiv->default_a = 1;
+                        musb->xceiv->state = OTG_STATE_A_WAIT_VRISE;
+                        devctl |= MUSB_DEVCTL_SESSION;
+                        MUSB_HST_MODE(musb);
+                }
         } else {
                 musb->is_active = 0;
 
@@ -169,15 +194,13 @@ static void omap_set_vbus(struct musb *musb, int is_on)
         }
         musb_writeb(musb->mregs, MUSB_DEVCTL, devctl);
 
-        DBG(1, "VBUS %s, devctl %02x "
+        dev_dbg(musb->controller, "VBUS %s, devctl %02x "
                 /* otg %3x conf %08x prcm %08x */ "\n",
-                otg_state_string(musb),
+                otg_state_string(musb->xceiv->state),
                 musb_readb(musb->mregs, MUSB_DEVCTL));
 }
 
-static int musb_platform_resume(struct musb *musb);
-
-int musb_platform_set_mode(struct musb *musb, u8 musb_mode)
+static int omap2430_musb_set_mode(struct musb *musb, u8 musb_mode)
 {
         u8      devctl = musb_readb(musb->mregs, MUSB_DEVCTL);
 
@@ -187,10 +210,95 @@ int musb_platform_set_mode(struct musb *musb, u8 musb_mode)
         return 0;
 }
 
-int __init musb_platform_init(struct musb *musb, void *board_data)
+static inline void omap2430_low_level_exit(struct musb *musb)
 {
         u32 l;
-        struct omap_musb_board_data *data = board_data;
+
+        /* in any role */
+        l = musb_readl(musb->mregs, OTG_FORCESTDBY);
+        l |= ENABLEFORCE;       /* enable MSTANDBY */
+        musb_writel(musb->mregs, OTG_FORCESTDBY, l);
+}
+
+static inline void omap2430_low_level_init(struct musb *musb)
+{
+        u32 l;
+
+        l = musb_readl(musb->mregs, OTG_FORCESTDBY);
+        l &= ~ENABLEFORCE;      /* disable MSTANDBY */
+        musb_writel(musb->mregs, OTG_FORCESTDBY, l);
+}
+
+/* blocking notifier support */
+static int musb_otg_notifications(struct notifier_block *nb,
+                unsigned long event, void *unused)
+{
+        struct musb     *musb = container_of(nb, struct musb, nb);
+        struct device *dev = musb->controller;
+        struct musb_hdrc_platform_data *pdata = dev->platform_data;
+        struct omap_musb_board_data *data = pdata->board_data;
+
+        switch (event) {
+        case USB_EVENT_ID:
+                dev_dbg(musb->controller, "ID GND\n");
+
+                if (is_otg_enabled(musb)) {
+#ifdef CONFIG_USB_GADGET_MUSB_HDRC
+                        if (musb->gadget_driver) {
+                                pm_runtime_get_sync(musb->controller);
+                                otg_init(musb->xceiv);
+                                omap2430_musb_set_vbus(musb, 1);
+                        }
+#endif
+                } else {
+                        pm_runtime_get_sync(musb->controller);
+                        otg_init(musb->xceiv);
+                        omap2430_musb_set_vbus(musb, 1);
+                }
+                break;
+
+        case USB_EVENT_VBUS:
+                dev_dbg(musb->controller, "VBUS Connect\n");
+
+#ifdef CONFIG_USB_GADGET_MUSB_HDRC
+                if (musb->gadget_driver)
+                        pm_runtime_get_sync(musb->controller);
+#endif
+                otg_init(musb->xceiv);
+                break;
+
+        case USB_EVENT_NONE:
+                dev_dbg(musb->controller, "VBUS Disconnect\n");
+
+#ifdef CONFIG_USB_GADGET_MUSB_HDRC
+                if (is_otg_enabled(musb) || is_peripheral_enabled(musb))
+                        if (musb->gadget_driver)
+#endif
+                        {
+                                pm_runtime_mark_last_busy(musb->controller);
+                                pm_runtime_put_autosuspend(musb->controller);
+                        }
+
+                if (data->interface_type == MUSB_INTERFACE_UTMI) {
+                        if (musb->xceiv->set_vbus)
+                                otg_set_vbus(musb->xceiv, 0);
+                }
+                otg_shutdown(musb->xceiv);
+                break;
+        default:
+                dev_dbg(musb->controller, "ID float\n");
+                return NOTIFY_DONE;
+        }
+
+        return NOTIFY_OK;
+}
+
+static int omap2430_musb_init(struct musb *musb)
+{
+        u32 l, status = 0;
+        struct device *dev = musb->controller;
+        struct musb_hdrc_platform_data *plat = dev->platform_data;
+        struct omap_musb_board_data *data = plat->board_data;
 
         /* We require some kind of external transceiver, hooked
          * up through ULPI.  TWL4030-family PMICs include one,
@@ -202,22 +310,11 @@ int __init musb_platform_init(struct musb *musb, void *board_data)
                 return -ENODEV;
         }
 
-        musb_platform_resume(musb);
-
-        l = musb_readl(musb->mregs, OTG_SYSCONFIG);
-        l &= ~ENABLEWAKEUP;     /* disable wakeup */
-        l &= ~NOSTDBY;          /* remove possible nostdby */
-        l |= SMARTSTDBY;        /* enable smart standby */
-        l &= ~AUTOIDLE;         /* disable auto idle */
-        l &= ~NOIDLE;           /* remove possible noidle */
-        l |= SMARTIDLE;         /* enable smart idle */
-        /*
-         * MUSB AUTOIDLE don't work in 3430.
-         * Workaround by Richard Woodruff/TI
-         */
-        if (!cpu_is_omap3430())
-                l |= AUTOIDLE;          /* enable auto idle */
-        musb_writel(musb->mregs, OTG_SYSCONFIG, l);
+        status = pm_runtime_get_sync(dev);
+        if (status < 0) {
+                dev_err(dev, "pm_runtime_get_sync FAILED");
+                goto err1;
+        }
 
         l = musb_readl(musb->mregs, OTG_INTERFSEL);
 
@@ -239,86 +336,221 @@ int __init musb_platform_init(struct musb *musb, void *board_data)
                         musb_readl(musb->mregs, OTG_INTERFSEL),
                         musb_readl(musb->mregs, OTG_SIMENABLE));
 
-        if (is_host_enabled(musb))
-                musb->board_set_vbus = omap_set_vbus;
+        musb->nb.notifier_call = musb_otg_notifications;
+        status = otg_register_notifier(musb->xceiv, &musb->nb);
+
+        if (status)
+                dev_dbg(musb->controller, "notification register failed\n");
 
         setup_timer(&musb_idle_timer, musb_do_idle, (unsigned long) musb);
 
         return 0;
+
+err1:
+        pm_runtime_disable(dev);
+        return status;
 }
 
-#ifdef CONFIG_PM
-void musb_platform_save_context(struct musb *musb,
-                struct musb_context_registers *musb_context)
+static void omap2430_musb_enable(struct musb *musb)
 {
-        musb_context->otg_sysconfig = musb_readl(musb->mregs, OTG_SYSCONFIG);
-        musb_context->otg_forcestandby = musb_readl(musb->mregs, OTG_FORCESTDBY);
+        u8              devctl;
+        unsigned long timeout = jiffies + msecs_to_jiffies(1000);
+        struct device *dev = musb->controller;
+        struct musb_hdrc_platform_data *pdata = dev->platform_data;
+        struct omap_musb_board_data *data = pdata->board_data;
+
+        switch (musb->xceiv->last_event) {
+
+        case USB_EVENT_ID:
+                otg_init(musb->xceiv);
+                if (data->interface_type == MUSB_INTERFACE_UTMI) {
+                        devctl = musb_readb(musb->mregs, MUSB_DEVCTL);
+                        /* start the session */
+                        devctl |= MUSB_DEVCTL_SESSION;
+                        musb_writeb(musb->mregs, MUSB_DEVCTL, devctl);
+                        while (musb_readb(musb->mregs, MUSB_DEVCTL) &
+                                                MUSB_DEVCTL_BDEVICE) {
+                                cpu_relax();
+
+                                if (time_after(jiffies, timeout)) {
+                                        dev_err(musb->controller,
+                                        "configured as A device timeout");
+                                        break;
+                                }
+                        }
+                }
+                break;
+
+        case USB_EVENT_VBUS:
+                otg_init(musb->xceiv);
+                break;
+
+        default:
+                break;
+        }
 }
 
-void musb_platform_restore_context(struct musb *musb,
-                struct musb_context_registers *musb_context)
+static void omap2430_musb_disable(struct musb *musb)
 {
-        musb_writel(musb->mregs, OTG_SYSCONFIG, musb_context->otg_sysconfig);
-        musb_writel(musb->mregs, OTG_FORCESTDBY, musb_context->otg_forcestandby);
+        if (musb->xceiv->last_event)
+                otg_shutdown(musb->xceiv);
 }
-#endif
 
-static int musb_platform_suspend(struct musb *musb)
+static int omap2430_musb_exit(struct musb *musb)
 {
-        u32 l;
+        del_timer_sync(&musb_idle_timer);
 
-        if (!musb->clock)
-                return 0;
+        omap2430_low_level_exit(musb);
+        otg_put_transceiver(musb->xceiv);
 
-        /* in any role */
-        l = musb_readl(musb->mregs, OTG_FORCESTDBY);
-        l |= ENABLEFORCE;       /* enable MSTANDBY */
-        musb_writel(musb->mregs, OTG_FORCESTDBY, l);
+        return 0;
+}
 
-        l = musb_readl(musb->mregs, OTG_SYSCONFIG);
-        l |= ENABLEWAKEUP;      /* enable wakeup */
-        musb_writel(musb->mregs, OTG_SYSCONFIG, l);
+static const struct musb_platform_ops omap2430_ops = {
+        .init           = omap2430_musb_init,
+        .exit           = omap2430_musb_exit,
 
-        otg_set_suspend(musb->xceiv, 1);
+        .set_mode       = omap2430_musb_set_mode,
+        .try_idle       = omap2430_musb_try_idle,
+
+        .set_vbus       = omap2430_musb_set_vbus,
+
+        .enable         = omap2430_musb_enable,
+        .disable        = omap2430_musb_disable,
+};
 
-        if (musb->set_clock)
-                musb->set_clock(musb->clock, 0);
-        else
-                clk_disable(musb->clock);
+static u64 omap2430_dmamask = DMA_BIT_MASK(32);
+
+static int __init omap2430_probe(struct platform_device *pdev)
+{
+        struct musb_hdrc_platform_data  *pdata = pdev->dev.platform_data;
+        struct platform_device          *musb;
+        struct omap2430_glue            *glue;
+        int                             ret = -ENOMEM;
+
+        glue = kzalloc(sizeof(*glue), GFP_KERNEL);
+        if (!glue) {
+                dev_err(&pdev->dev, "failed to allocate glue context\n");
+                goto err0;
+        }
+
+        musb = platform_device_alloc("musb-hdrc", -1);
+        if (!musb) {
+                dev_err(&pdev->dev, "failed to allocate musb device\n");
+                goto err1;
+        }
+
+        musb->dev.parent                = &pdev->dev;
+        musb->dev.dma_mask              = &omap2430_dmamask;
+        musb->dev.coherent_dma_mask     = omap2430_dmamask;
+
+        glue->dev                       = &pdev->dev;
+        glue->musb                      = musb;
+
+        pdata->platform_ops             = &omap2430_ops;
+
+        platform_set_drvdata(pdev, glue);
+
+        ret = platform_device_add_resources(musb, pdev->resource,
+                        pdev->num_resources);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to add resources\n");
+                goto err2;
+        }
+
+        ret = platform_device_add_data(musb, pdata, sizeof(*pdata));
+        if (ret) {
+                dev_err(&pdev->dev, "failed to add platform_data\n");
+                goto err2;
+        }
+
+        ret = platform_device_add(musb);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to register musb device\n");
+                goto err2;
+        }
+
+        pm_runtime_enable(&pdev->dev);
 
         return 0;
+
+err2:
+        platform_device_put(musb);
+
+err1:
+        kfree(glue);
+
+err0:
+        return ret;
 }
 
-static int musb_platform_resume(struct musb *musb)
+static int __exit omap2430_remove(struct platform_device *pdev)
 {
-        u32 l;
+        struct omap2430_glue            *glue = platform_get_drvdata(pdev);
 
-        if (!musb->clock)
-                return 0;
+        platform_device_del(glue->musb);
+        platform_device_put(glue->musb);
+        pm_runtime_put(&pdev->dev);
+        pm_runtime_disable(&pdev->dev);
+        kfree(glue);
 
-        otg_set_suspend(musb->xceiv, 0);
+        return 0;
+}
 
-        if (musb->set_clock)
-                musb->set_clock(musb->clock, 1);
-        else
-                clk_enable(musb->clock);
+#ifdef CONFIG_PM
 
-        l = musb_readl(musb->mregs, OTG_SYSCONFIG);
-        l &= ~ENABLEWAKEUP;     /* disable wakeup */
-        musb_writel(musb->mregs, OTG_SYSCONFIG, l);
+static int omap2430_runtime_suspend(struct device *dev)
+{
+        struct omap2430_glue            *glue = dev_get_drvdata(dev);
+        struct musb                     *musb = glue_to_musb(glue);
 
-        l = musb_readl(musb->mregs, OTG_FORCESTDBY);
-        l &= ~ENABLEFORCE;      /* disable MSTANDBY */
-        musb_writel(musb->mregs, OTG_FORCESTDBY, l);
+        omap2430_low_level_exit(musb);
+        otg_set_suspend(musb->xceiv, 1);
 
         return 0;
 }
 
-
-int musb_platform_exit(struct musb *musb)
+static int omap2430_runtime_resume(struct device *dev)
 {
+        struct omap2430_glue            *glue = dev_get_drvdata(dev);
+        struct musb                     *musb = glue_to_musb(glue);
 
-        musb_platform_suspend(musb);
+        omap2430_low_level_init(musb);
+        otg_set_suspend(musb->xceiv, 0);
 
         return 0;
 }
+
+static struct dev_pm_ops omap2430_pm_ops = {
+        .runtime_suspend = omap2430_runtime_suspend,
+        .runtime_resume = omap2430_runtime_resume,
+};
+
+#define DEV_PM_OPS      (&omap2430_pm_ops)
+#else
+#define DEV_PM_OPS      NULL
+#endif
+
+static struct platform_driver omap2430_driver = {
+        .remove         = __exit_p(omap2430_remove),
+        .driver         = {
+                .name   = "musb-omap2430",
+                .pm     = DEV_PM_OPS,
+        },
+};
+
+MODULE_DESCRIPTION("OMAP2PLUS MUSB Glue Layer");
+MODULE_AUTHOR("Felipe Balbi <balbi@ti.com>");
+MODULE_LICENSE("GPL v2");
+
+static int __init omap2430_init(void)
+{
+        return platform_driver_probe(&omap2430_driver, omap2430_probe);
+}
+subsys_initcall(omap2430_init);
+
+static void __exit omap2430_exit(void)
+{
+        platform_driver_unregister(&omap2430_driver);
+}
+module_exit(omap2430_exit);
diff --git a/drivers/usb/musb/tusb6010.c b/drivers/usb/musb/tusb6010.c
index 3c48e77a0aa2..b410357cf016 100644
--- a/drivers/usb/musb/tusb6010.c
+++ b/drivers/usb/musb/tusb6010.c
@@ -21,10 +21,16 @@
 #include <linux/usb.h>
 #include <linux/irq.h>
 #include <linux/platform_device.h>
+#include <linux/dma-mapping.h>
 
 #include "musb_core.h"
 
-static void tusb_source_power(struct musb *musb, int is_on);
+struct tusb6010_glue {
+        struct device           *dev;
+        struct platform_device  *musb;
+};
+
+static void tusb_musb_set_vbus(struct musb *musb, int is_on);
 
 #define TUSB_REV_MAJOR(reg_val)         ((reg_val >> 4) & 0xf)
 #define TUSB_REV_MINOR(reg_val)         (reg_val & 0xf)
@@ -50,7 +56,7 @@ u8 tusb_get_revision(struct musb *musb)
         return rev;
 }
 
-static int __init tusb_print_revision(struct musb *musb)
+static int tusb_print_revision(struct musb *musb)
 {
         void __iomem    *tbase = musb->ctrl_base;
         u8              rev;
@@ -100,7 +106,7 @@ static void tusb_wbus_quirk(struct musb *musb, int enabled)
                 tmp = phy_otg_ena & ~WBUS_QUIRK_MASK;
                 tmp |= TUSB_PHY_OTG_CTRL_WRPROTECT | TUSB_PHY_OTG_CTRL_TESTM2;
                 musb_writel(tbase, TUSB_PHY_OTG_CTRL_ENABLE, tmp);
-                DBG(2, "Enabled tusb wbus quirk ctrl %08x ena %08x\n",
+                dev_dbg(musb->controller, "Enabled tusb wbus quirk ctrl %08x ena %08x\n",
                         musb_readl(tbase, TUSB_PHY_OTG_CTRL),
                         musb_readl(tbase, TUSB_PHY_OTG_CTRL_ENABLE));
         } else if (musb_readl(tbase, TUSB_PHY_OTG_CTRL_ENABLE)
@@ -109,7 +115,7 @@ static void tusb_wbus_quirk(struct musb *musb, int enabled)
                 musb_writel(tbase, TUSB_PHY_OTG_CTRL, tmp);
                 tmp = TUSB_PHY_OTG_CTRL_WRPROTECT | phy_otg_ena;
                 musb_writel(tbase, TUSB_PHY_OTG_CTRL_ENABLE, tmp);
-                DBG(2, "Disabled tusb wbus quirk ctrl %08x ena %08x\n",
+                dev_dbg(musb->controller, "Disabled tusb wbus quirk ctrl %08x ena %08x\n",
                         musb_readl(tbase, TUSB_PHY_OTG_CTRL),
                         musb_readl(tbase, TUSB_PHY_OTG_CTRL_ENABLE));
                 phy_otg_ctrl = 0;
@@ -166,13 +172,14 @@ static inline void tusb_fifo_read_unaligned(void __iomem *fifo,
 
 void musb_write_fifo(struct musb_hw_ep *hw_ep, u16 len, const u8 *buf)
 {
+        struct musb *musb = hw_ep->musb;
         void __iomem    *ep_conf = hw_ep->conf;
         void __iomem    *fifo = hw_ep->fifo;
         u8              epnum = hw_ep->epnum;
 
         prefetch(buf);
 
-        DBG(4, "%cX ep%d fifo %p count %d buf %p\n",
+        dev_dbg(musb->controller, "%cX ep%d fifo %p count %d buf %p\n",
                         'T', epnum, fifo, len, buf);
 
         if (epnum)
@@ -215,11 +222,12 @@ void musb_write_fifo(struct musb_hw_ep *hw_ep, u16 len, const u8 *buf)
 
 void musb_read_fifo(struct musb_hw_ep *hw_ep, u16 len, u8 *buf)
 {
+        struct musb *musb = hw_ep->musb;
         void __iomem    *ep_conf = hw_ep->conf;
         void __iomem    *fifo = hw_ep->fifo;
         u8              epnum = hw_ep->epnum;
 
-        DBG(4, "%cX ep%d fifo %p count %d buf %p\n",
+        dev_dbg(musb->controller, "%cX ep%d fifo %p count %d buf %p\n",
                         'R', epnum, fifo, len, buf);
 
         if (epnum)
@@ -275,17 +283,6 @@ static int tusb_draw_power(struct otg_transceiver *x, unsigned mA)
         void __iomem    *tbase = musb->ctrl_base;
         u32             reg;
 
-        /*
-         * Keep clock active when enabled. Note that this is not tied to
-         * drawing VBUS, as with OTG mA can be less than musb->min_power.
-         */
-        if (musb->set_clock) {
-                if (mA)
-                        musb->set_clock(musb->clock, 1);
-                else
-                        musb->set_clock(musb->clock, 0);
-        }
-
         /* tps65030 seems to consume max 100mA, with maybe 60mA available
          * (measured on one board) for things other than tps and tusb.
          *
@@ -309,7 +306,7 @@ static int tusb_draw_power(struct otg_transceiver *x, unsigned mA)
         }
         musb_writel(tbase, TUSB_PRCM_MNGMT, reg);
 
-        DBG(2, "draw max %d mA VBUS\n", mA);
+        dev_dbg(musb->controller, "draw max %d mA VBUS\n", mA);
         return 0;
 }
 
@@ -348,7 +345,7 @@ static void tusb_set_clock_source(struct musb *musb, unsigned mode)
  * USB link is not suspended ... and tells us the relevant wakeup
  * events.  SW_EN for voltage is handled separately.
  */
-void tusb_allow_idle(struct musb *musb, u32 wakeup_enables)
+static void tusb_allow_idle(struct musb *musb, u32 wakeup_enables)
 {
         void __iomem    *tbase = musb->ctrl_base;
         u32             reg;
@@ -379,13 +376,13 @@ void tusb_allow_idle(struct musb *musb, u32 wakeup_enables)
         reg |= TUSB_PRCM_MNGMT_PM_IDLE | TUSB_PRCM_MNGMT_DEV_IDLE;
         musb_writel(tbase, TUSB_PRCM_MNGMT, reg);
 
-        DBG(6, "idle, wake on %02x\n", wakeup_enables);
+        dev_dbg(musb->controller, "idle, wake on %02x\n", wakeup_enables);
 }
 
 /*
  * Updates cable VBUS status. Caller must take care of locking.
  */
-int musb_platform_get_vbus_status(struct musb *musb)
+static int tusb_musb_vbus_status(struct musb *musb)
 {
         void __iomem    *tbase = musb->ctrl_base;
         u32             otg_stat, prcm_mngmt;
@@ -426,12 +423,12 @@ static void musb_do_idle(unsigned long _musb)
                 if ((musb->a_wait_bcon != 0)
                         && (musb->idle_timeout == 0
                                 || time_after(jiffies, musb->idle_timeout))) {
-                        DBG(4, "Nothing connected %s, turning off VBUS\n",
-                                        otg_state_string(musb));
+                        dev_dbg(musb->controller, "Nothing connected %s, turning off VBUS\n",
+                                        otg_state_string(musb->xceiv->state));
                 }
                 /* FALLTHROUGH */
         case OTG_STATE_A_IDLE:
-                tusb_source_power(musb, 0);
+                tusb_musb_set_vbus(musb, 0);
         default:
                 break;
         }
@@ -475,7 +472,7 @@ done:
  * we don't want to treat that full speed J as a wakeup event.
  * ... peripherals must draw only suspend current after 10 msec.
  */
-void musb_platform_try_idle(struct musb *musb, unsigned long timeout)
+static void tusb_musb_try_idle(struct musb *musb, unsigned long timeout)
 {
         unsigned long           default_timeout = jiffies + msecs_to_jiffies(3);
         static unsigned long    last_timer;
@@ -486,7 +483,8 @@ void musb_platform_try_idle(struct musb *musb, unsigned long timeout)
         /* Never idle if active, or when VBUS timeout is not set as host */
         if (musb->is_active || ((musb->a_wait_bcon == 0)
                         && (musb->xceiv->state == OTG_STATE_A_WAIT_BCON))) {
-                DBG(4, "%s active, deleting timer\n", otg_state_string(musb));
+                dev_dbg(musb->controller, "%s active, deleting timer\n",
+                        otg_state_string(musb->xceiv->state));
                 del_timer(&musb_idle_timer);
                 last_timer = jiffies;
                 return;
@@ -496,14 +494,14 @@ void musb_platform_try_idle(struct musb *musb, unsigned long timeout)
                 if (!timer_pending(&musb_idle_timer))
                         last_timer = timeout;
                 else {
-                        DBG(4, "Longer idle timer already pending, ignoring\n");
+                        dev_dbg(musb->controller, "Longer idle timer already pending, ignoring\n");
                         return;
                 }
         }
         last_timer = timeout;
 
-        DBG(4, "%s inactive, for idle timer for %lu ms\n",
-                otg_state_string(musb),
+        dev_dbg(musb->controller, "%s inactive, for idle timer for %lu ms\n",
+                otg_state_string(musb->xceiv->state),
                 (unsigned long)jiffies_to_msecs(timeout - jiffies));
         mod_timer(&musb_idle_timer, timeout);
 }
@@ -515,7 +513,7 @@ void musb_platform_try_idle(struct musb *musb, unsigned long timeout)
                                 | TUSB_DEV_OTG_TIMER_ENABLE) \
                 : 0)
 
-static void tusb_source_power(struct musb *musb, int is_on)
+static void tusb_musb_set_vbus(struct musb *musb, int is_on)
 {
         void __iomem    *tbase = musb->ctrl_base;
         u32             conf, prcm, timer;
@@ -531,8 +529,6 @@ static void tusb_source_power(struct musb *musb, int is_on)
         devctl = musb_readb(musb->mregs, MUSB_DEVCTL);
 
         if (is_on) {
-                if (musb->set_clock)
-                        musb->set_clock(musb->clock, 1);
                 timer = OTG_TIMER_MS(OTG_TIME_A_WAIT_VRISE);
                 musb->xceiv->default_a = 1;
                 musb->xceiv->state = OTG_STATE_A_WAIT_VRISE;
@@ -571,8 +567,6 @@ static void tusb_source_power(struct musb *musb, int is_on)
 
                 devctl &= ~MUSB_DEVCTL_SESSION;
                 conf &= ~TUSB_DEV_CONF_USB_HOST_MODE;
-                if (musb->set_clock)
-                        musb->set_clock(musb->clock, 0);
         }
         prcm &= ~(TUSB_PRCM_MNGMT_15_SW_EN | TUSB_PRCM_MNGMT_33_SW_EN);
 
@@ -581,8 +575,8 @@ static void tusb_source_power(struct musb *musb, int is_on)
         musb_writel(tbase, TUSB_DEV_CONF, conf);
         musb_writeb(musb->mregs, MUSB_DEVCTL, devctl);
 
-        DBG(1, "VBUS %s, devctl %02x otg %3x conf %08x prcm %08x\n",
-                otg_state_string(musb),
+        dev_dbg(musb->controller, "VBUS %s, devctl %02x otg %3x conf %08x prcm %08x\n",
+                otg_state_string(musb->xceiv->state),
                 musb_readb(musb->mregs, MUSB_DEVCTL),
                 musb_readl(tbase, TUSB_DEV_OTG_STAT),
                 conf, prcm);
@@ -599,7 +593,7 @@ static void tusb_source_power(struct musb *musb, int is_on)
  * and peripheral modes in non-OTG configurations by reconfiguring hardware
  * and then setting musb->board_mode. For now, only support OTG mode.
  */
-int musb_platform_set_mode(struct musb *musb, u8 musb_mode)
+static int tusb_musb_set_mode(struct musb *musb, u8 musb_mode)
 {
         void __iomem    *tbase = musb->ctrl_base;
         u32             otg_stat, phy_otg_ctrl, phy_otg_ena, dev_conf;
@@ -642,7 +636,7 @@ int musb_platform_set_mode(struct musb *musb, u8 musb_mode)
 #endif
 
         default:
-                DBG(2, "Trying to set mode %i\n", musb_mode);
+                dev_dbg(musb->controller, "Trying to set mode %i\n", musb_mode);
                 return -EINVAL;
         }
 
@@ -675,9 +669,9 @@ tusb_otg_ints(struct musb *musb, u32 int_src, void __iomem *tbase)
                         default_a = !(otg_stat & TUSB_DEV_OTG_STAT_ID_STATUS);
                 else
                         default_a = is_host_enabled(musb);
-                DBG(2, "Default-%c\n", default_a ? 'A' : 'B');
+                dev_dbg(musb->controller, "Default-%c\n", default_a ? 'A' : 'B');
                 musb->xceiv->default_a = default_a;
-                tusb_source_power(musb, default_a);
+                tusb_musb_set_vbus(musb, default_a);
 
                 /* Don't allow idling immediately */
                 if (default_a)
@@ -702,7 +696,7 @@ tusb_otg_ints(struct musb *musb, u32 int_src, void __iomem *tbase)
 #endif
 
                         if (otg_stat & TUSB_DEV_OTG_STAT_SESS_END) {
-                                DBG(1, "Forcing disconnect (no interrupt)\n");
+                                dev_dbg(musb->controller, "Forcing disconnect (no interrupt)\n");
                                 if (musb->xceiv->state != OTG_STATE_B_IDLE) {
                                         /* INTR_DISCONNECT can hide... */
                                         musb->xceiv->state = OTG_STATE_B_IDLE;
@@ -710,19 +704,19 @@ tusb_otg_ints(struct musb *musb, u32 int_src, void __iomem *tbase)
                                 }
                                 musb->is_active = 0;
                         }
-                        DBG(2, "vbus change, %s, otg %03x\n",
-                                otg_state_string(musb), otg_stat);
+                        dev_dbg(musb->controller, "vbus change, %s, otg %03x\n",
+                                otg_state_string(musb->xceiv->state), otg_stat);
                         idle_timeout = jiffies + (1 * HZ);
                         schedule_work(&musb->irq_work);
 
                 } else /* A-dev state machine */ {
-                        DBG(2, "vbus change, %s, otg %03x\n",
-                                otg_state_string(musb), otg_stat);
+                        dev_dbg(musb->controller, "vbus change, %s, otg %03x\n",
+                                otg_state_string(musb->xceiv->state), otg_stat);
 
                         switch (musb->xceiv->state) {
                         case OTG_STATE_A_IDLE:
-                                DBG(2, "Got SRP, turning on VBUS\n");
-                                musb_set_vbus(musb, 1);
+                                dev_dbg(musb->controller, "Got SRP, turning on VBUS\n");
+                                musb_platform_set_vbus(musb, 1);
 
                                 /* CONNECT can wake if a_wait_bcon is set */
                                 if (musb->a_wait_bcon != 0)
@@ -748,11 +742,11 @@ tusb_otg_ints(struct musb *musb, u32 int_src, void __iomem *tbase)
                                  */
                                 if (musb->vbuserr_retry) {
                                         musb->vbuserr_retry--;
-                                        tusb_source_power(musb, 1);
+                                        tusb_musb_set_vbus(musb, 1);
                                 } else {
                                         musb->vbuserr_retry
                                                 = VBUSERR_RETRY_COUNT;
-                                        tusb_source_power(musb, 0);
+                                        tusb_musb_set_vbus(musb, 0);
                                 }
                                 break;
                         default:
@@ -765,7 +759,8 @@ tusb_otg_ints(struct musb *musb, u32 int_src, void __iomem *tbase)
         if (int_src & TUSB_INT_SRC_OTG_TIMEOUT) {
                 u8      devctl;
 
-                DBG(4, "%s timer, %03x\n", otg_state_string(musb), otg_stat);
+                dev_dbg(musb->controller, "%s timer, %03x\n",
+                        otg_state_string(musb->xceiv->state), otg_stat);
 
                 switch (musb->xceiv->state) {
                 case OTG_STATE_A_WAIT_VRISE:
@@ -776,7 +771,7 @@ tusb_otg_ints(struct musb *musb, u32 int_src, void __iomem *tbase)
                         if (otg_stat & TUSB_DEV_OTG_STAT_VBUS_VALID) {
                                 if ((devctl & MUSB_DEVCTL_VBUS)
                                                 != MUSB_DEVCTL_VBUS) {
-                                        DBG(2, "devctl %02x\n", devctl);
+                                        dev_dbg(musb->controller, "devctl %02x\n", devctl);
                                         break;
                                 }
                                 musb->xceiv->state = OTG_STATE_A_WAIT_BCON;
@@ -786,7 +781,7 @@ tusb_otg_ints(struct musb *musb, u32 int_src, void __iomem *tbase)
                         } else {
                                 /* REVISIT report overcurrent to hub? */
                                 ERR("vbus too slow, devctl %02x\n", devctl);
-                                tusb_source_power(musb, 0);
+                                tusb_musb_set_vbus(musb, 0);
                         }
                         break;
                 case OTG_STATE_A_WAIT_BCON:
@@ -807,7 +802,7 @@ tusb_otg_ints(struct musb *musb, u32 int_src, void __iomem *tbase)
         return idle_timeout;
 }
 
-static irqreturn_t tusb_interrupt(int irq, void *__hci)
+static irqreturn_t tusb_musb_interrupt(int irq, void *__hci)
 {
         struct musb     *musb = __hci;
         void __iomem    *tbase = musb->ctrl_base;
@@ -821,7 +816,7 @@ static irqreturn_t tusb_interrupt(int irq, void *__hci)
         musb_writel(tbase, TUSB_INT_MASK, ~TUSB_INT_MASK_RESERVED_BITS);
 
         int_src = musb_readl(tbase, TUSB_INT_SRC) & ~TUSB_INT_SRC_RESERVED_BITS;
-        DBG(3, "TUSB IRQ %08x\n", int_src);
+        dev_dbg(musb->controller, "TUSB IRQ %08x\n", int_src);
 
         musb->int_usb = (u8) int_src;
 
@@ -842,7 +837,7 @@ static irqreturn_t tusb_interrupt(int irq, void *__hci)
                         reg = musb_readl(tbase, TUSB_SCRATCH_PAD);
                         if (reg == i)
                                 break;
-                        DBG(6, "TUSB NOR not ready\n");
+                        dev_dbg(musb->controller, "TUSB NOR not ready\n");
                 }
 
                 /* work around issue 13 (2nd half) */
@@ -854,7 +849,7 @@ static irqreturn_t tusb_interrupt(int irq, void *__hci)
                         musb->is_active = 1;
                         schedule_work(&musb->irq_work);
                 }
-                DBG(3, "wake %sactive %02x\n",
+                dev_dbg(musb->controller, "wake %sactive %02x\n",
                                 musb->is_active ? "" : "in", reg);
 
                 /* REVISIT host side TUSB_PRCM_WHOSTDISCON, TUSB_PRCM_WBUS */
@@ -876,7 +871,7 @@ static irqreturn_t tusb_interrupt(int irq, void *__hci)
                 u32     dma_src = musb_readl(tbase, TUSB_DMA_INT_SRC);
                 u32     real_dma_src = musb_readl(tbase, TUSB_DMA_INT_MASK);
 
-                DBG(3, "DMA IRQ %08x\n", dma_src);
+                dev_dbg(musb->controller, "DMA IRQ %08x\n", dma_src);
                 real_dma_src = ~real_dma_src & dma_src;
                 if (tusb_dma_omap() && real_dma_src) {
                         int     tx_source = (real_dma_src & 0xffff);
@@ -884,7 +879,7 @@ static irqreturn_t tusb_interrupt(int irq, void *__hci)
 
                         for (i = 1; i <= 15; i++) {
                                 if (tx_source & (1 << i)) {
-                                        DBG(3, "completing ep%i %s\n", i, "tx");
+                                        dev_dbg(musb->controller, "completing ep%i %s\n", i, "tx");
                                         musb_dma_completion(musb, i, 1);
                                 }
                         }
@@ -911,7 +906,7 @@ static irqreturn_t tusb_interrupt(int irq, void *__hci)
         musb_writel(tbase, TUSB_INT_SRC_CLEAR,
                 int_src & ~TUSB_INT_MASK_RESERVED_BITS);
 
-        musb_platform_try_idle(musb, idle_timeout);
+        tusb_musb_try_idle(musb, idle_timeout);
 
         musb_writel(tbase, TUSB_INT_MASK, int_mask);
         spin_unlock_irqrestore(&musb->lock, flags);
@@ -926,7 +921,7 @@ static int dma_off;
  * REVISIT:
  * - Check what is unnecessary in MGC_HdrcStart()
  */
-void musb_platform_enable(struct musb *musb)
+static void tusb_musb_enable(struct musb *musb)
 {
         void __iomem    *tbase = musb->ctrl_base;
 
@@ -952,7 +947,7 @@ void musb_platform_enable(struct musb *musb)
         musb_writel(tbase, TUSB_INT_CTRL_CONF,
                         TUSB_INT_CTRL_CONF_INT_RELCYC(0));
 
-        set_irq_type(musb->nIrq, IRQ_TYPE_LEVEL_LOW);
+        irq_set_irq_type(musb->nIrq, IRQ_TYPE_LEVEL_LOW);
 
         /* maybe force into the Default-A OTG state machine */
         if (!(musb_readl(tbase, TUSB_DEV_OTG_STAT)
@@ -970,7 +965,7 @@ void musb_platform_enable(struct musb *musb)
 /*
  * Disables TUSB6010. Caller must take care of locking.
  */
-void musb_platform_disable(struct musb *musb)
+static void tusb_musb_disable(struct musb *musb)
 {
         void __iomem    *tbase = musb->ctrl_base;
 
@@ -995,7 +990,7 @@ void musb_platform_disable(struct musb *musb)
  * Sets up TUSB6010 CPU interface specific signals and registers
  * Note: Settings optimized for OMAP24xx
  */
-static void __init tusb_setup_cpu_interface(struct musb *musb)
+static void tusb_setup_cpu_interface(struct musb *musb)
 {
         void __iomem    *tbase = musb->ctrl_base;
 
@@ -1022,7 +1017,7 @@ static void __init tusb_setup_cpu_interface(struct musb *musb)
         musb_writel(tbase, TUSB_WAIT_COUNT, 1);
 }
 
-static int __init tusb_start(struct musb *musb)
+static int tusb_musb_start(struct musb *musb)
 {
         void __iomem    *tbase = musb->ctrl_base;
         int             ret = 0;
@@ -1091,7 +1086,7 @@ err:
         return -ENODEV;
 }
 
-int __init musb_platform_init(struct musb *musb, void *board_data)
+static int tusb_musb_init(struct musb *musb)
 {
         struct platform_device  *pdev;
         struct resource         *mem;
@@ -1131,16 +1126,14 @@ int __init musb_platform_init(struct musb *musb, void *board_data)
          */
         musb->mregs += TUSB_BASE_OFFSET;
 
-        ret = tusb_start(musb);
+        ret = tusb_musb_start(musb);
         if (ret) {
                 printk(KERN_ERR "Could not start tusb6010 (%d)\n",
                                 ret);
                 goto done;
         }
-        musb->isr = tusb_interrupt;
+        musb->isr = tusb_musb_interrupt;
 
-        if (is_host_enabled(musb))
-                musb->board_set_vbus = tusb_source_power;
         if (is_peripheral_enabled(musb)) {
                 musb->xceiv->set_power = tusb_draw_power;
                 the_musb = musb;
@@ -1152,12 +1145,14 @@ done:
         if (ret < 0) {
                 if (sync)
                         iounmap(sync);
+
+                otg_put_transceiver(musb->xceiv);
                 usb_nop_xceiv_unregister();
         }
         return ret;
 }
 
-int musb_platform_exit(struct musb *musb)
+static int tusb_musb_exit(struct musb *musb)
 {
         del_timer_sync(&musb_idle_timer);
         the_musb = NULL;
@@ -1166,6 +1161,120 @@ int musb_platform_exit(struct musb *musb)
                 musb->board_set_power(0);
 
         iounmap(musb->sync_va);
+
+        otg_put_transceiver(musb->xceiv);
         usb_nop_xceiv_unregister();
         return 0;
 }
+
+static const struct musb_platform_ops tusb_ops = {
+        .init           = tusb_musb_init,
+        .exit           = tusb_musb_exit,
+
+        .enable         = tusb_musb_enable,
+        .disable        = tusb_musb_disable,
+
+        .set_mode       = tusb_musb_set_mode,
+        .try_idle       = tusb_musb_try_idle,
+
+        .vbus_status    = tusb_musb_vbus_status,
+        .set_vbus       = tusb_musb_set_vbus,
+};
+
+static u64 tusb_dmamask = DMA_BIT_MASK(32);
+
+static int __init tusb_probe(struct platform_device *pdev)
+{
+        struct musb_hdrc_platform_data  *pdata = pdev->dev.platform_data;
+        struct platform_device          *musb;
+        struct tusb6010_glue            *glue;
+
+        int                             ret = -ENOMEM;
+
+        glue = kzalloc(sizeof(*glue), GFP_KERNEL);
+        if (!glue) {
+                dev_err(&pdev->dev, "failed to allocate glue context\n");
+                goto err0;
+        }
+
+        musb = platform_device_alloc("musb-hdrc", -1);
+        if (!musb) {
+                dev_err(&pdev->dev, "failed to allocate musb device\n");
+                goto err1;
+        }
+
+        musb->dev.parent                = &pdev->dev;
+        musb->dev.dma_mask              = &tusb_dmamask;
+        musb->dev.coherent_dma_mask     = tusb_dmamask;
+
+        glue->dev                       = &pdev->dev;
+        glue->musb                      = musb;
+
+        pdata->platform_ops             = &tusb_ops;
+
+        platform_set_drvdata(pdev, glue);
+
+        ret = platform_device_add_resources(musb, pdev->resource,
+                        pdev->num_resources);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to add resources\n");
+                goto err2;
+        }
+
+        ret = platform_device_add_data(musb, pdata, sizeof(*pdata));
+        if (ret) {
+                dev_err(&pdev->dev, "failed to add platform_data\n");
+                goto err2;
+        }
+
+        ret = platform_device_add(musb);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to register musb device\n");
+                goto err1;
+        }
+
+        return 0;
+
+err2:
+        platform_device_put(musb);
+
+err1:
+        kfree(glue);
+
+err0:
+        return ret;
+}
+
+static int __exit tusb_remove(struct platform_device *pdev)
+{
+        struct tusb6010_glue            *glue = platform_get_drvdata(pdev);
+
+        platform_device_del(glue->musb);
+        platform_device_put(glue->musb);
+        kfree(glue);
+
+        return 0;
+}
+
+static struct platform_driver tusb_driver = {
+        .remove         = __exit_p(tusb_remove),
+        .driver         = {
+                .name   = "musb-tusb",
+        },
+};
+
+MODULE_DESCRIPTION("TUSB6010 MUSB Glue Layer");
+MODULE_AUTHOR("Felipe Balbi <balbi@ti.com>");
+MODULE_LICENSE("GPL v2");
+
+static int __init tusb_init(void)
+{
+        return platform_driver_probe(&tusb_driver, tusb_probe);
+}
+subsys_initcall(tusb_init);
+
+static void __exit tusb_exit(void)
+{
+        platform_driver_unregister(&tusb_driver);
+}
+module_exit(tusb_exit);
diff --git a/drivers/usb/musb/tusb6010_omap.c b/drivers/usb/musb/tusb6010_omap.c
index c061a88f2b0f..c784e6c03aac 100644
--- a/drivers/usb/musb/tusb6010_omap.c
+++ b/drivers/usb/musb/tusb6010_omap.c
@@ -65,7 +65,7 @@ static int tusb_omap_dma_start(struct dma_controller *c)
 
         tusb_dma = container_of(c, struct tusb_omap_dma, controller);
 
-        /* DBG(3, "ep%i ch: %i\n", chdat->epnum, chdat->ch); */
+        /* dev_dbg(musb->controller, "ep%i ch: %i\n", chdat->epnum, chdat->ch); */
 
         return 0;
 }
@@ -76,7 +76,7 @@ static int tusb_omap_dma_stop(struct dma_controller *c)
 
         tusb_dma = container_of(c, struct tusb_omap_dma, controller);
 
-        /* DBG(3, "ep%i ch: %i\n", chdat->epnum, chdat->ch); */
+        /* dev_dbg(musb->controller, "ep%i ch: %i\n", chdat->epnum, chdat->ch); */
 
         return 0;
 }
@@ -89,7 +89,7 @@ static inline int tusb_omap_use_shared_dmareq(struct tusb_omap_dma_ch *chdat)
         u32             reg = musb_readl(chdat->tbase, TUSB_DMA_EP_MAP);
 
         if (reg != 0) {
-                DBG(3, "ep%i dmareq0 is busy for ep%i\n",
+                dev_dbg(musb->controller, "ep%i dmareq0 is busy for ep%i\n",
                         chdat->epnum, reg & 0xf);
                 return -EAGAIN;
         }
@@ -143,7 +143,7 @@ static void tusb_omap_dma_cb(int lch, u16 ch_status, void *data)
         if (ch_status != OMAP_DMA_BLOCK_IRQ)
                 printk(KERN_ERR "TUSB DMA error status: %i\n", ch_status);
 
-        DBG(3, "ep%i %s dma callback ch: %i status: %x\n",
+        dev_dbg(musb->controller, "ep%i %s dma callback ch: %i status: %x\n",
                 chdat->epnum, chdat->tx ? "tx" : "rx",
                 ch, ch_status);
 
@@ -156,7 +156,7 @@ static void tusb_omap_dma_cb(int lch, u16 ch_status, void *data)
 
         /* HW issue #10: XFR_SIZE may get corrupt on DMA (both async & sync) */
         if (unlikely(remaining > chdat->transfer_len)) {
-                DBG(2, "Corrupt %s dma ch%i XFR_SIZE: 0x%08lx\n",
+                dev_dbg(musb->controller, "Corrupt %s dma ch%i XFR_SIZE: 0x%08lx\n",
                         chdat->tx ? "tx" : "rx", chdat->ch,
                         remaining);
                 remaining = 0;
@@ -165,13 +165,13 @@ static void tusb_omap_dma_cb(int lch, u16 ch_status, void *data)
         channel->actual_len = chdat->transfer_len - remaining;
         pio = chdat->len - channel->actual_len;
 
-        DBG(3, "DMA remaining %lu/%u\n", remaining, chdat->transfer_len);
+        dev_dbg(musb->controller, "DMA remaining %lu/%u\n", remaining, chdat->transfer_len);
 
         /* Transfer remaining 1 - 31 bytes */
         if (pio > 0 && pio < 32) {
                 u8      *buf;
 
-                DBG(3, "Using PIO for remaining %lu bytes\n", pio);
+                dev_dbg(musb->controller, "Using PIO for remaining %lu bytes\n", pio);
                 buf = phys_to_virt((u32)chdat->dma_addr) + chdat->transfer_len;
                 if (chdat->tx) {
                         dma_unmap_single(dev, chdat->dma_addr,
@@ -209,7 +209,7 @@ static void tusb_omap_dma_cb(int lch, u16 ch_status, void *data)
                 u16     csr;
 
                 if (chdat->tx) {
-                        DBG(3, "terminating short tx packet\n");
+                        dev_dbg(musb->controller, "terminating short tx packet\n");
                         musb_ep_select(mbase, chdat->epnum);
                         csr = musb_readw(hw_ep->regs, MUSB_TXCSR);
                         csr |= MUSB_TXCSR_MODE | MUSB_TXCSR_TXPKTRDY
@@ -264,7 +264,7 @@ static int tusb_omap_dma_program(struct dma_channel *channel, u16 packet_sz,
 
         dma_remaining = TUSB_EP_CONFIG_XFR_SIZE(dma_remaining);
         if (dma_remaining) {
-                DBG(2, "Busy %s dma ch%i, not using: %08x\n",
+                dev_dbg(musb->controller, "Busy %s dma ch%i, not using: %08x\n",
                         chdat->tx ? "tx" : "rx", chdat->ch,
                         dma_remaining);
                 return false;
@@ -283,7 +283,7 @@ static int tusb_omap_dma_program(struct dma_channel *channel, u16 packet_sz,
                 sync_dev = chdat->sync_dev;
         } else {
                 if (tusb_omap_use_shared_dmareq(chdat) != 0) {
-                        DBG(3, "could not get dma for ep%i\n", chdat->epnum);
+                        dev_dbg(musb->controller, "could not get dma for ep%i\n", chdat->epnum);
                         return false;
                 }
                 if (tusb_dma->ch < 0) {
@@ -326,7 +326,7 @@ static int tusb_omap_dma_program(struct dma_channel *channel, u16 packet_sz,
 
         dma_params.frame_count  = chdat->transfer_len / 32; /* Burst sz frame */
 
-        DBG(3, "ep%i %s dma ch%i dma: %08x len: %u(%u) packet_sz: %i(%i)\n",
+        dev_dbg(musb->controller, "ep%i %s dma ch%i dma: %08x len: %u(%u) packet_sz: %i(%i)\n",
                 chdat->epnum, chdat->tx ? "tx" : "rx",
                 ch, dma_addr, chdat->transfer_len, len,
                 chdat->transfer_packet_sz, packet_sz);
@@ -370,7 +370,7 @@ static int tusb_omap_dma_program(struct dma_channel *channel, u16 packet_sz,
                 dst_burst = OMAP_DMA_DATA_BURST_16;     /* 16x32 write */
         }
 
-        DBG(3, "ep%i %s using %i-bit %s dma from 0x%08lx to 0x%08lx\n",
+        dev_dbg(musb->controller, "ep%i %s using %i-bit %s dma from 0x%08lx to 0x%08lx\n",
                 chdat->epnum, chdat->tx ? "tx" : "rx",
                 (dma_params.data_type == OMAP_DMA_DATA_TYPE_S32) ? 32 : 16,
                 ((dma_addr & 0x3) == 0) ? "sync" : "async",
@@ -525,7 +525,7 @@ tusb_omap_dma_allocate(struct dma_controller *c,
 
         /* REVISIT: Why does dmareq5 not work? */
         if (hw_ep->epnum == 0) {
-                DBG(3, "Not allowing DMA for ep0 %s\n", tx ? "tx" : "rx");
+                dev_dbg(musb->controller, "Not allowing DMA for ep0 %s\n", tx ? "tx" : "rx");
                 return NULL;
         }
 
@@ -585,7 +585,7 @@ tusb_omap_dma_allocate(struct dma_controller *c,
                 chdat->ch = -1;
         }
 
-        DBG(3, "ep%i %s dma: %s dma%i dmareq%i sync%i\n",
+        dev_dbg(musb->controller, "ep%i %s dma: %s dma%i dmareq%i sync%i\n",
                 chdat->epnum,
                 chdat->tx ? "tx" : "rx",
                 chdat->ch >= 0 ? "dedicated" : "shared",
@@ -598,7 +598,7 @@ tusb_omap_dma_allocate(struct dma_controller *c,
 free_dmareq:
         tusb_omap_dma_free_dmareq(chdat);
 
-        DBG(3, "ep%i: Could not get a DMA channel\n", chdat->epnum);
+        dev_dbg(musb->controller, "ep%i: Could not get a DMA channel\n", chdat->epnum);
         channel->status = MUSB_DMA_STATUS_UNKNOWN;
 
         return NULL;
@@ -611,7 +611,7 @@ static void tusb_omap_dma_release(struct dma_channel *channel)
         void __iomem            *tbase = musb->ctrl_base;
         u32                     reg;
 
-        DBG(3, "ep%i ch%i\n", chdat->epnum, chdat->ch);
+        dev_dbg(musb->controller, "ep%i ch%i\n", chdat->epnum, chdat->ch);
 
         reg = musb_readl(tbase, TUSB_DMA_INT_MASK);
         if (chdat->tx)
@@ -680,7 +680,7 @@ dma_controller_create(struct musb *musb, void __iomem *base)
 
         tusb_dma = kzalloc(sizeof(struct tusb_omap_dma), GFP_KERNEL);
         if (!tusb_dma)
-                goto cleanup;
+                goto out;
 
         tusb_dma->musb = musb;
         tusb_dma->tbase = musb->ctrl_base;
@@ -721,6 +721,6 @@ dma_controller_create(struct musb *musb, void __iomem *base)
 
 cleanup:
         dma_controller_destroy(&tusb_dma->controller);
-
+out:
         return NULL;
 }
diff --git a/drivers/usb/musb/ux500.c b/drivers/usb/musb/ux500.c
new file mode 100644
index 000000000000..f7e04bf34a13
--- /dev/null
+++ b/drivers/usb/musb/ux500.c
@@ -0,0 +1,218 @@
+/*
+ * Copyright (C) 2010 ST-Ericsson AB
+ * Mian Yousaf Kaukab <mian.yousaf.kaukab@stericsson.com>
+ *
+ * Based on omap2430.c
+ *
+ * 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.
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/clk.h>
+#include <linux/io.h>
+#include <linux/platform_device.h>
+
+#include "musb_core.h"
+
+struct ux500_glue {
+        struct device           *dev;
+        struct platform_device  *musb;
+        struct clk              *clk;
+};
+#define glue_to_musb(g) platform_get_drvdata(g->musb)
+
+static int ux500_musb_init(struct musb *musb)
+{
+        musb->xceiv = otg_get_transceiver();
+        if (!musb->xceiv) {
+                pr_err("HS USB OTG: no transceiver configured\n");
+                return -ENODEV;
+        }
+
+        return 0;
+}
+
+static int ux500_musb_exit(struct musb *musb)
+{
+        otg_put_transceiver(musb->xceiv);
+
+        return 0;
+}
+
+static const struct musb_platform_ops ux500_ops = {
+        .init           = ux500_musb_init,
+        .exit           = ux500_musb_exit,
+};
+
+static int __init ux500_probe(struct platform_device *pdev)
+{
+        struct musb_hdrc_platform_data  *pdata = pdev->dev.platform_data;
+        struct platform_device          *musb;
+        struct ux500_glue               *glue;
+        struct clk                      *clk;
+
+        int                             ret = -ENOMEM;
+
+        glue = kzalloc(sizeof(*glue), GFP_KERNEL);
+        if (!glue) {
+                dev_err(&pdev->dev, "failed to allocate glue context\n");
+                goto err0;
+        }
+
+        musb = platform_device_alloc("musb-hdrc", -1);
+        if (!musb) {
+                dev_err(&pdev->dev, "failed to allocate musb device\n");
+                goto err1;
+        }
+
+        clk = clk_get(&pdev->dev, "usb");
+        if (IS_ERR(clk)) {
+                dev_err(&pdev->dev, "failed to get clock\n");
+                ret = PTR_ERR(clk);
+                goto err2;
+        }
+
+        ret = clk_enable(clk);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to enable clock\n");
+                goto err3;
+        }
+
+        musb->dev.parent                = &pdev->dev;
+        musb->dev.dma_mask              = pdev->dev.dma_mask;
+        musb->dev.coherent_dma_mask     = pdev->dev.coherent_dma_mask;
+
+        glue->dev                       = &pdev->dev;
+        glue->musb                      = musb;
+        glue->clk                       = clk;
+
+        pdata->platform_ops             = &ux500_ops;
+
+        platform_set_drvdata(pdev, glue);
+
+        ret = platform_device_add_resources(musb, pdev->resource,
+                        pdev->num_resources);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to add resources\n");
+                goto err4;
+        }
+
+        ret = platform_device_add_data(musb, pdata, sizeof(*pdata));
+        if (ret) {
+                dev_err(&pdev->dev, "failed to add platform_data\n");
+                goto err4;
+        }
+
+        ret = platform_device_add(musb);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to register musb device\n");
+                goto err4;
+        }
+
+        return 0;
+
+err4:
+        clk_disable(clk);
+
+err3:
+        clk_put(clk);
+
+err2:
+        platform_device_put(musb);
+
+err1:
+        kfree(glue);
+
+err0:
+        return ret;
+}
+
+static int __exit ux500_remove(struct platform_device *pdev)
+{
+        struct ux500_glue       *glue = platform_get_drvdata(pdev);
+
+        platform_device_del(glue->musb);
+        platform_device_put(glue->musb);
+        clk_disable(glue->clk);
+        clk_put(glue->clk);
+        kfree(glue);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int ux500_suspend(struct device *dev)
+{
+        struct ux500_glue       *glue = dev_get_drvdata(dev);
+        struct musb             *musb = glue_to_musb(glue);
+
+        otg_set_suspend(musb->xceiv, 1);
+        clk_disable(glue->clk);
+
+        return 0;
+}
+
+static int ux500_resume(struct device *dev)
+{
+        struct ux500_glue       *glue = dev_get_drvdata(dev);
+        struct musb             *musb = glue_to_musb(glue);
+        int                     ret;
+
+        ret = clk_enable(glue->clk);
+        if (ret) {
+                dev_err(dev, "failed to enable clock\n");
+                return ret;
+        }
+
+        otg_set_suspend(musb->xceiv, 0);
+
+        return 0;
+}
+
+static const struct dev_pm_ops ux500_pm_ops = {
+        .suspend        = ux500_suspend,
+        .resume         = ux500_resume,
+};
+
+#define DEV_PM_OPS      (&ux500_pm_ops)
+#else
+#define DEV_PM_OPS      NULL
+#endif
+
+static struct platform_driver ux500_driver = {
+        .remove         = __exit_p(ux500_remove),
+        .driver         = {
+                .name   = "musb-ux500",
+                .pm     = DEV_PM_OPS,
+        },
+};
+
+MODULE_DESCRIPTION("UX500 MUSB Glue Layer");
+MODULE_AUTHOR("Mian Yousaf Kaukab <mian.yousaf.kaukab@stericsson.com>");
+MODULE_LICENSE("GPL v2");
+
+static int __init ux500_init(void)
+{
+        return platform_driver_probe(&ux500_driver, ux500_probe);
+}
+subsys_initcall(ux500_init);
+
+static void __exit ux500_exit(void)
+{
+        platform_driver_unregister(&ux500_driver);
+}
+module_exit(ux500_exit);
diff --git a/drivers/usb/musb/ux500_dma.c b/drivers/usb/musb/ux500_dma.c
new file mode 100644
index 000000000000..cecace411832
--- /dev/null
+++ b/drivers/usb/musb/ux500_dma.c
@@ -0,0 +1,422 @@
+/*
+ * drivers/usb/musb/ux500_dma.c
+ *
+ * U8500 and U5500 DMA support code
+ *
+ * Copyright (C) 2009 STMicroelectronics
+ * Copyright (C) 2011 ST-Ericsson SA
+ * Authors:
+ *      Mian Yousaf Kaukab <mian.yousaf.kaukab@stericsson.com>
+ *      Praveena Nadahally <praveen.nadahally@stericsson.com>
+ *      Rajaram Regupathy <ragupathy.rajaram@stericsson.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
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <linux/device.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+#include <linux/dma-mapping.h>
+#include <linux/dmaengine.h>
+#include <linux/pfn.h>
+#include <mach/usb.h>
+#include "musb_core.h"
+
+struct ux500_dma_channel {
+        struct dma_channel channel;
+        struct ux500_dma_controller *controller;
+        struct musb_hw_ep *hw_ep;
+        struct work_struct channel_work;
+        struct dma_chan *dma_chan;
+        unsigned int cur_len;
+        dma_cookie_t cookie;
+        u8 ch_num;
+        u8 is_tx;
+        u8 is_allocated;
+};
+
+struct ux500_dma_controller {
+        struct dma_controller controller;
+        struct ux500_dma_channel rx_channel[UX500_MUSB_DMA_NUM_RX_CHANNELS];
+        struct ux500_dma_channel tx_channel[UX500_MUSB_DMA_NUM_TX_CHANNELS];
+        u32     num_rx_channels;
+        u32     num_tx_channels;
+        void *private_data;
+        dma_addr_t phy_base;
+};
+
+/* Work function invoked from DMA callback to handle tx transfers. */
+static void ux500_tx_work(struct work_struct *data)
+{
+        struct ux500_dma_channel *ux500_channel = container_of(data,
+                struct ux500_dma_channel, channel_work);
+        struct musb_hw_ep       *hw_ep = ux500_channel->hw_ep;
+        struct musb *musb = hw_ep->musb;
+        unsigned long flags;
+
+        DBG(4, "DMA tx transfer done on hw_ep=%d\n", hw_ep->epnum);
+
+        spin_lock_irqsave(&musb->lock, flags);
+        ux500_channel->channel.actual_len = ux500_channel->cur_len;
+        ux500_channel->channel.status = MUSB_DMA_STATUS_FREE;
+        musb_dma_completion(musb, hw_ep->epnum,
+                                ux500_channel->is_tx);
+        spin_unlock_irqrestore(&musb->lock, flags);
+}
+
+/* Work function invoked from DMA callback to handle rx transfers. */
+static void ux500_rx_work(struct work_struct *data)
+{
+        struct ux500_dma_channel *ux500_channel = container_of(data,
+                struct ux500_dma_channel, channel_work);
+        struct musb_hw_ep       *hw_ep = ux500_channel->hw_ep;
+        struct musb *musb = hw_ep->musb;
+        unsigned long flags;
+
+        DBG(4, "DMA rx transfer done on hw_ep=%d\n", hw_ep->epnum);
+
+        spin_lock_irqsave(&musb->lock, flags);
+        ux500_channel->channel.actual_len = ux500_channel->cur_len;
+        ux500_channel->channel.status = MUSB_DMA_STATUS_FREE;
+        musb_dma_completion(musb, hw_ep->epnum,
+                ux500_channel->is_tx);
+        spin_unlock_irqrestore(&musb->lock, flags);
+}
+
+void ux500_dma_callback(void *private_data)
+{
+        struct dma_channel *channel = (struct dma_channel *)private_data;
+        struct ux500_dma_channel *ux500_channel = channel->private_data;
+
+        schedule_work(&ux500_channel->channel_work);
+}
+
+static bool ux500_configure_channel(struct dma_channel *channel,
+                                u16 packet_sz, u8 mode,
+                                dma_addr_t dma_addr, u32 len)
+{
+        struct ux500_dma_channel *ux500_channel = channel->private_data;
+        struct musb_hw_ep *hw_ep = ux500_channel->hw_ep;
+        struct dma_chan *dma_chan = ux500_channel->dma_chan;
+        struct dma_async_tx_descriptor *dma_desc;
+        enum dma_data_direction direction;
+        struct scatterlist sg;
+        struct dma_slave_config slave_conf;
+        enum dma_slave_buswidth addr_width;
+        dma_addr_t usb_fifo_addr = (MUSB_FIFO_OFFSET(hw_ep->epnum) +
+                                        ux500_channel->controller->phy_base);
+
+        DBG(4, "packet_sz=%d, mode=%d, dma_addr=0x%x, len=%d is_tx=%d\n",
+                        packet_sz, mode, dma_addr, len, ux500_channel->is_tx);
+
+        ux500_channel->cur_len = len;
+
+        sg_init_table(&sg, 1);
+        sg_set_page(&sg, pfn_to_page(PFN_DOWN(dma_addr)), len,
+                                            offset_in_page(dma_addr));
+        sg_dma_address(&sg) = dma_addr;
+        sg_dma_len(&sg) = len;
+
+        direction = ux500_channel->is_tx ? DMA_TO_DEVICE : DMA_FROM_DEVICE;
+        addr_width = (len & 0x3) ? DMA_SLAVE_BUSWIDTH_1_BYTE :
+                                        DMA_SLAVE_BUSWIDTH_4_BYTES;
+
+        slave_conf.direction = direction;
+        if (direction == DMA_FROM_DEVICE) {
+                slave_conf.src_addr = usb_fifo_addr;
+                slave_conf.src_addr_width = addr_width;
+                slave_conf.src_maxburst = 16;
+        } else {
+                slave_conf.dst_addr = usb_fifo_addr;
+                slave_conf.dst_addr_width = addr_width;
+                slave_conf.dst_maxburst = 16;
+        }
+        dma_chan->device->device_control(dma_chan, DMA_SLAVE_CONFIG,
+                                             (unsigned long) &slave_conf);
+
+        dma_desc = dma_chan->device->
+                        device_prep_slave_sg(dma_chan, &sg, 1, direction,
+                                             DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
+        if (!dma_desc)
+                return false;
+
+        dma_desc->callback = ux500_dma_callback;
+        dma_desc->callback_param = channel;
+        ux500_channel->cookie = dma_desc->tx_submit(dma_desc);
+
+        dma_async_issue_pending(dma_chan);
+
+        return true;
+}
+
+static struct dma_channel *ux500_dma_channel_allocate(struct dma_controller *c,
+                                struct musb_hw_ep *hw_ep, u8 is_tx)
+{
+        struct ux500_dma_controller *controller = container_of(c,
+                        struct ux500_dma_controller, controller);
+        struct ux500_dma_channel *ux500_channel = NULL;
+        u8 ch_num = hw_ep->epnum - 1;
+        u32 max_ch;
+
+        /* Max 8 DMA channels (0 - 7). Each DMA channel can only be allocated
+         * to specified hw_ep. For example DMA channel 0 can only be allocated
+         * to hw_ep 1 and 9.
+         */
+        if (ch_num > 7)
+                ch_num -= 8;
+
+        max_ch = is_tx ? controller->num_tx_channels :
+                        controller->num_rx_channels;
+
+        if (ch_num >= max_ch)
+                return NULL;
+
+        ux500_channel = is_tx ? &(controller->tx_channel[ch_num]) :
+                                &(controller->rx_channel[ch_num]) ;
+
+        /* Check if channel is already used. */
+        if (ux500_channel->is_allocated)
+                return NULL;
+
+        ux500_channel->hw_ep = hw_ep;
+        ux500_channel->is_allocated = 1;
+
+        DBG(7, "hw_ep=%d, is_tx=0x%x, channel=%d\n",
+                hw_ep->epnum, is_tx, ch_num);
+
+        return &(ux500_channel->channel);
+}
+
+static void ux500_dma_channel_release(struct dma_channel *channel)
+{
+        struct ux500_dma_channel *ux500_channel = channel->private_data;
+
+        DBG(7, "channel=%d\n", ux500_channel->ch_num);
+
+        if (ux500_channel->is_allocated) {
+                ux500_channel->is_allocated = 0;
+                channel->status = MUSB_DMA_STATUS_FREE;
+                channel->actual_len = 0;
+        }
+}
+
+static int ux500_dma_is_compatible(struct dma_channel *channel,
+                u16 maxpacket, void *buf, u32 length)
+{
+        if ((maxpacket & 0x3)           ||
+                ((int)buf & 0x3)        ||
+                (length < 512)          ||
+                (length & 0x3))
+                return false;
+        else
+                return true;
+}
+
+static int ux500_dma_channel_program(struct dma_channel *channel,
+                                u16 packet_sz, u8 mode,
+                                dma_addr_t dma_addr, u32 len)
+{
+        int ret;
+
+        BUG_ON(channel->status == MUSB_DMA_STATUS_UNKNOWN ||
+                channel->status == MUSB_DMA_STATUS_BUSY);
+
+        if (!ux500_dma_is_compatible(channel, packet_sz, (void *)dma_addr, len))
+                return false;
+
+        channel->status = MUSB_DMA_STATUS_BUSY;
+        channel->actual_len = 0;
+        ret = ux500_configure_channel(channel, packet_sz, mode, dma_addr, len);
+        if (!ret)
+                channel->status = MUSB_DMA_STATUS_FREE;
+
+        return ret;
+}
+
+static int ux500_dma_channel_abort(struct dma_channel *channel)
+{
+        struct ux500_dma_channel *ux500_channel = channel->private_data;
+        struct ux500_dma_controller *controller = ux500_channel->controller;
+        struct musb *musb = controller->private_data;
+        void __iomem *epio = musb->endpoints[ux500_channel->hw_ep->epnum].regs;
+        u16 csr;
+
+        DBG(4, "channel=%d, is_tx=%d\n", ux500_channel->ch_num,
+                                                ux500_channel->is_tx);
+
+        if (channel->status == MUSB_DMA_STATUS_BUSY) {
+                if (ux500_channel->is_tx) {
+                        csr = musb_readw(epio, MUSB_TXCSR);
+                        csr &= ~(MUSB_TXCSR_AUTOSET |
+                                 MUSB_TXCSR_DMAENAB |
+                                 MUSB_TXCSR_DMAMODE);
+                        musb_writew(epio, MUSB_TXCSR, csr);
+                } else {
+                        csr = musb_readw(epio, MUSB_RXCSR);
+                        csr &= ~(MUSB_RXCSR_AUTOCLEAR |
+                                 MUSB_RXCSR_DMAENAB |
+                                 MUSB_RXCSR_DMAMODE);
+                        musb_writew(epio, MUSB_RXCSR, csr);
+                }
+
+                ux500_channel->dma_chan->device->
+                                device_control(ux500_channel->dma_chan,
+                                        DMA_TERMINATE_ALL, 0);
+                channel->status = MUSB_DMA_STATUS_FREE;
+        }
+        return 0;
+}
+
+static int ux500_dma_controller_stop(struct dma_controller *c)
+{
+        struct ux500_dma_controller *controller = container_of(c,
+                        struct ux500_dma_controller, controller);
+        struct ux500_dma_channel *ux500_channel;
+        struct dma_channel *channel;
+        u8 ch_num;
+
+        for (ch_num = 0; ch_num < controller->num_rx_channels; ch_num++) {
+                channel = &controller->rx_channel[ch_num].channel;
+                ux500_channel = channel->private_data;
+
+                ux500_dma_channel_release(channel);
+
+                if (ux500_channel->dma_chan)
+                        dma_release_channel(ux500_channel->dma_chan);
+        }
+
+        for (ch_num = 0; ch_num < controller->num_tx_channels; ch_num++) {
+                channel = &controller->tx_channel[ch_num].channel;
+                ux500_channel = channel->private_data;
+
+                ux500_dma_channel_release(channel);
+
+                if (ux500_channel->dma_chan)
+                        dma_release_channel(ux500_channel->dma_chan);
+        }
+
+        return 0;
+}
+
+static int ux500_dma_controller_start(struct dma_controller *c)
+{
+        struct ux500_dma_controller *controller = container_of(c,
+                        struct ux500_dma_controller, controller);
+        struct ux500_dma_channel *ux500_channel = NULL;
+        struct musb *musb = controller->private_data;
+        struct device *dev = musb->controller;
+        struct musb_hdrc_platform_data *plat = dev->platform_data;
+        struct ux500_musb_board_data *data = plat->board_data;
+        struct dma_channel *dma_channel = NULL;
+        u32 ch_num;
+        u8 dir;
+        u8 is_tx = 0;
+
+        void **param_array;
+        struct ux500_dma_channel *channel_array;
+        u32 ch_count;
+        void (*musb_channel_work)(struct work_struct *);
+        dma_cap_mask_t mask;
+
+        if ((data->num_rx_channels > UX500_MUSB_DMA_NUM_RX_CHANNELS) ||
+                (data->num_tx_channels > UX500_MUSB_DMA_NUM_TX_CHANNELS))
+                return -EINVAL;
+
+        controller->num_rx_channels = data->num_rx_channels;
+        controller->num_tx_channels = data->num_tx_channels;
+
+        dma_cap_zero(mask);
+        dma_cap_set(DMA_SLAVE, mask);
+
+        /* Prepare the loop for RX channels */
+        channel_array = controller->rx_channel;
+        ch_count = data->num_rx_channels;
+        param_array = data->dma_rx_param_array;
+        musb_channel_work = ux500_rx_work;
+
+        for (dir = 0; dir < 2; dir++) {
+                for (ch_num = 0; ch_num < ch_count; ch_num++) {
+                        ux500_channel = &channel_array[ch_num];
+                        ux500_channel->controller = controller;
+                        ux500_channel->ch_num = ch_num;
+                        ux500_channel->is_tx = is_tx;
+
+                        dma_channel = &(ux500_channel->channel);
+                        dma_channel->private_data = ux500_channel;
+                        dma_channel->status = MUSB_DMA_STATUS_FREE;
+                        dma_channel->max_len = SZ_16M;
+
+                        ux500_channel->dma_chan = dma_request_channel(mask,
+                                                        data->dma_filter,
+                                                        param_array[ch_num]);
+                        if (!ux500_channel->dma_chan) {
+                                ERR("Dma pipe allocation error dir=%d ch=%d\n",
+                                        dir, ch_num);
+
+                                /* Release already allocated channels */
+                                ux500_dma_controller_stop(c);
+
+                                return -EBUSY;
+                        }
+
+                        INIT_WORK(&ux500_channel->channel_work,
+                                musb_channel_work);
+                }
+
+                /* Prepare the loop for TX channels */
+                channel_array = controller->tx_channel;
+                ch_count = data->num_tx_channels;
+                param_array = data->dma_tx_param_array;
+                musb_channel_work = ux500_tx_work;
+                is_tx = 1;
+        }
+
+        return 0;
+}
+
+void dma_controller_destroy(struct dma_controller *c)
+{
+        struct ux500_dma_controller *controller = container_of(c,
+                        struct ux500_dma_controller, controller);
+
+        kfree(controller);
+}
+
+struct dma_controller *__init
+dma_controller_create(struct musb *musb, void __iomem *base)
+{
+        struct ux500_dma_controller *controller;
+        struct platform_device *pdev = to_platform_device(musb->controller);
+        struct resource *iomem;
+
+        controller = kzalloc(sizeof(*controller), GFP_KERNEL);
+        if (!controller)
+                return NULL;
+
+        controller->private_data = musb;
+
+        /* Save physical address for DMA controller. */
+        iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        controller->phy_base = (dma_addr_t) iomem->start;
+
+        controller->controller.start = ux500_dma_controller_start;
+        controller->controller.stop = ux500_dma_controller_stop;
+        controller->controller.channel_alloc = ux500_dma_channel_allocate;
+        controller->controller.channel_release = ux500_dma_channel_release;
+        controller->controller.channel_program = ux500_dma_channel_program;
+        controller->controller.channel_abort = ux500_dma_channel_abort;
+        controller->controller.is_compatible = ux500_dma_is_compatible;
+
+        return &controller->controller;
+}
diff --git a/drivers/usb/otg/Kconfig b/drivers/usb/otg/Kconfig
index 3b1289572d72..c66481ad98d7 100644
--- a/drivers/usb/otg/Kconfig
+++ b/drivers/usb/otg/Kconfig
@@ -49,6 +49,13 @@ config USB_ULPI
           Enable this to support ULPI connected USB OTG transceivers which
           are likely found on embedded boards.
 
+config USB_ULPI_VIEWPORT
+        bool
+        depends on USB_ULPI
+        help
+          Provides read/write operations to the ULPI phy register set for
+          controllers with a viewport register (e.g. Chipidea/ARC controllers).
+
 config TWL4030_USB
         tristate "TWL4030 USB Transceiver Driver"
         depends on TWL4030_CORE && REGULATOR_TWL4030
@@ -59,6 +66,18 @@ config TWL4030_USB
           This transceiver supports high and full speed devices plus,
           in host mode, low speed.
 
+config TWL6030_USB
+        tristate "TWL6030 USB Transceiver Driver"
+        depends on TWL4030_CORE
+        select USB_OTG_UTILS
+        help
+          Enable this to support the USB OTG transceiver on TWL6030
+          family chips. This TWL6030 transceiver has the VBUS and ID GND
+          and OTG SRP events capabilities. For all other transceiver functionality
+          UTMI PHY is embedded in OMAP4430. The internal PHY configurations APIs
+          are hooked to this driver through platform_data structure.
+          The definition of internal PHY APIs are in the mach-omap2 layer.
+
 config NOP_USB_XCEIV
         tristate "NOP USB Transceiver Driver"
         select USB_OTG_UTILS
@@ -67,4 +86,48 @@ config NOP_USB_XCEIV
          built-in with usb ip or which are autonomous and doesn't require any
          phy programming such as ISP1x04 etc.
 
+config USB_LANGWELL_OTG
+        tristate "Intel Langwell USB OTG dual-role support"
+        depends on USB && PCI && INTEL_SCU_IPC
+        select USB_OTG
+        select USB_OTG_UTILS
+        help
+          Say Y here if you want to build Intel Langwell USB OTG
+          transciever driver in kernel. This driver implements role
+          switch between EHCI host driver and Langwell USB OTG
+          client driver.
+
+          To compile this driver as a module, choose M here: the
+          module will be called langwell_otg.
+
+config USB_MSM_OTG
+        tristate "OTG support for Qualcomm on-chip USB controller"
+        depends on (USB || USB_GADGET) && ARCH_MSM
+        select USB_OTG_UTILS
+        help
+          Enable this to support the USB OTG transceiver on MSM chips. It
+          handles PHY initialization, clock management, and workarounds
+          required after resetting the hardware and power management.
+          This driver is required even for peripheral only or host only
+          mode configurations.
+          This driver is not supported on boards like trout which
+          has an external PHY.
+
+config AB8500_USB
+        tristate "AB8500 USB Transceiver Driver"
+        depends on AB8500_CORE
+        select USB_OTG_UTILS
+        help
+          Enable this to support the USB OTG transceiver in AB8500 chip.
+          This transceiver supports high and full speed devices plus,
+          in host mode, low speed.
+
+config FSL_USB2_OTG
+        bool "Freescale USB OTG Transceiver Driver"
+        depends on USB_EHCI_FSL && USB_GADGET_FSL_USB2
+        select USB_OTG
+        select USB_OTG_UTILS
+        help
+          Enable this to support Freescale USB OTG transceiver.
+
 endif # USB || OTG
diff --git a/drivers/usb/otg/Makefile b/drivers/usb/otg/Makefile
index aeb49a8ec412..566655c53331 100644
--- a/drivers/usb/otg/Makefile
+++ b/drivers/usb/otg/Makefile
@@ -2,6 +2,9 @@
 # OTG infrastructure and transceiver drivers
 #
 
+ccflags-$(CONFIG_USB_DEBUG)             := -DDEBUG
+ccflags-$(CONFIG_USB_GADGET_DEBUG)      += -DDEBUG
+
 # infrastructure
 obj-$(CONFIG_USB_OTG_UTILS)     += otg.o
 
@@ -9,9 +12,12 @@ obj-$(CONFIG_USB_OTG_UTILS)	+= otg.o
 obj-$(CONFIG_USB_GPIO_VBUS)     += gpio_vbus.o
 obj-$(CONFIG_ISP1301_OMAP)      += isp1301_omap.o
 obj-$(CONFIG_TWL4030_USB)       += twl4030-usb.o
+obj-$(CONFIG_TWL6030_USB)       += twl6030-usb.o
+obj-$(CONFIG_USB_LANGWELL_OTG)  += langwell_otg.o
 obj-$(CONFIG_NOP_USB_XCEIV)     += nop-usb-xceiv.o
 obj-$(CONFIG_USB_ULPI)          += ulpi.o
-
-ccflags-$(CONFIG_USB_DEBUG)     += -DDEBUG
-ccflags-$(CONFIG_USB_GADGET_DEBUG) += -DDEBUG
-
+obj-$(CONFIG_USB_ULPI_VIEWPORT) += ulpi_viewport.o
+obj-$(CONFIG_USB_MSM_OTG)       += msm_otg.o
+obj-$(CONFIG_AB8500_USB)        += ab8500-usb.o
+fsl_usb2_otg-objs               := fsl_otg.o otg_fsm.o
+obj-$(CONFIG_FSL_USB2_OTG)      += fsl_usb2_otg.o
diff --git a/drivers/usb/otg/ab8500-usb.c b/drivers/usb/otg/ab8500-usb.c
new file mode 100644
index 000000000000..07ccea9ada40
--- /dev/null
+++ b/drivers/usb/otg/ab8500-usb.c
@@ -0,0 +1,585 @@
+/*
+ * drivers/usb/otg/ab8500_usb.c
+ *
+ * USB transceiver driver for AB8500 chip
+ *
+ * Copyright (C) 2010 ST-Ericsson AB
+ * Mian Yousaf Kaukab <mian.yousaf.kaukab@stericsson.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
+ * 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.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/usb/otg.h>
+#include <linux/slab.h>
+#include <linux/notifier.h>
+#include <linux/interrupt.h>
+#include <linux/delay.h>
+#include <linux/mfd/abx500.h>
+#include <linux/mfd/ab8500.h>
+
+#define AB8500_MAIN_WD_CTRL_REG 0x01
+#define AB8500_USB_LINE_STAT_REG 0x80
+#define AB8500_USB_PHY_CTRL_REG 0x8A
+
+#define AB8500_BIT_OTG_STAT_ID (1 << 0)
+#define AB8500_BIT_PHY_CTRL_HOST_EN (1 << 0)
+#define AB8500_BIT_PHY_CTRL_DEVICE_EN (1 << 1)
+#define AB8500_BIT_WD_CTRL_ENABLE (1 << 0)
+#define AB8500_BIT_WD_CTRL_KICK (1 << 1)
+
+#define AB8500_V1x_LINK_STAT_WAIT (HZ/10)
+#define AB8500_WD_KICK_DELAY_US 100 /* usec */
+#define AB8500_WD_V11_DISABLE_DELAY_US 100 /* usec */
+#define AB8500_WD_V10_DISABLE_DELAY_MS 100 /* ms */
+
+/* Usb line status register */
+enum ab8500_usb_link_status {
+        USB_LINK_NOT_CONFIGURED = 0,
+        USB_LINK_STD_HOST_NC,
+        USB_LINK_STD_HOST_C_NS,
+        USB_LINK_STD_HOST_C_S,
+        USB_LINK_HOST_CHG_NM,
+        USB_LINK_HOST_CHG_HS,
+        USB_LINK_HOST_CHG_HS_CHIRP,
+        USB_LINK_DEDICATED_CHG,
+        USB_LINK_ACA_RID_A,
+        USB_LINK_ACA_RID_B,
+        USB_LINK_ACA_RID_C_NM,
+        USB_LINK_ACA_RID_C_HS,
+        USB_LINK_ACA_RID_C_HS_CHIRP,
+        USB_LINK_HM_IDGND,
+        USB_LINK_RESERVED,
+        USB_LINK_NOT_VALID_LINK
+};
+
+struct ab8500_usb {
+        struct otg_transceiver otg;
+        struct device *dev;
+        int irq_num_id_rise;
+        int irq_num_id_fall;
+        int irq_num_vbus_rise;
+        int irq_num_vbus_fall;
+        int irq_num_link_status;
+        unsigned vbus_draw;
+        struct delayed_work dwork;
+        struct work_struct phy_dis_work;
+        unsigned long link_status_wait;
+        int rev;
+};
+
+static inline struct ab8500_usb *xceiv_to_ab(struct otg_transceiver *x)
+{
+        return container_of(x, struct ab8500_usb, otg);
+}
+
+static void ab8500_usb_wd_workaround(struct ab8500_usb *ab)
+{
+        abx500_set_register_interruptible(ab->dev,
+                AB8500_SYS_CTRL2_BLOCK,
+                AB8500_MAIN_WD_CTRL_REG,
+                AB8500_BIT_WD_CTRL_ENABLE);
+
+        udelay(AB8500_WD_KICK_DELAY_US);
+
+        abx500_set_register_interruptible(ab->dev,
+                AB8500_SYS_CTRL2_BLOCK,
+                AB8500_MAIN_WD_CTRL_REG,
+                (AB8500_BIT_WD_CTRL_ENABLE
+                | AB8500_BIT_WD_CTRL_KICK));
+
+        if (ab->rev > 0x10) /* v1.1 v2.0 */
+                udelay(AB8500_WD_V11_DISABLE_DELAY_US);
+        else /* v1.0 */
+                msleep(AB8500_WD_V10_DISABLE_DELAY_MS);
+
+        abx500_set_register_interruptible(ab->dev,
+                AB8500_SYS_CTRL2_BLOCK,
+                AB8500_MAIN_WD_CTRL_REG,
+                0);
+}
+
+static void ab8500_usb_phy_ctrl(struct ab8500_usb *ab, bool sel_host,
+                                        bool enable)
+{
+        u8 ctrl_reg;
+        abx500_get_register_interruptible(ab->dev,
+                                AB8500_USB,
+                                AB8500_USB_PHY_CTRL_REG,
+                                &ctrl_reg);
+        if (sel_host) {
+                if (enable)
+                        ctrl_reg |= AB8500_BIT_PHY_CTRL_HOST_EN;
+                else
+                        ctrl_reg &= ~AB8500_BIT_PHY_CTRL_HOST_EN;
+        } else {
+                if (enable)
+                        ctrl_reg |= AB8500_BIT_PHY_CTRL_DEVICE_EN;
+                else
+                        ctrl_reg &= ~AB8500_BIT_PHY_CTRL_DEVICE_EN;
+        }
+
+        abx500_set_register_interruptible(ab->dev,
+                                AB8500_USB,
+                                AB8500_USB_PHY_CTRL_REG,
+                                ctrl_reg);
+
+        /* Needed to enable the phy.*/
+        if (enable)
+                ab8500_usb_wd_workaround(ab);
+}
+
+#define ab8500_usb_host_phy_en(ab)      ab8500_usb_phy_ctrl(ab, true, true)
+#define ab8500_usb_host_phy_dis(ab)     ab8500_usb_phy_ctrl(ab, true, false)
+#define ab8500_usb_peri_phy_en(ab)      ab8500_usb_phy_ctrl(ab, false, true)
+#define ab8500_usb_peri_phy_dis(ab)     ab8500_usb_phy_ctrl(ab, false, false)
+
+static int ab8500_usb_link_status_update(struct ab8500_usb *ab)
+{
+        u8 reg;
+        enum ab8500_usb_link_status lsts;
+        void *v = NULL;
+        enum usb_xceiv_events event;
+
+        abx500_get_register_interruptible(ab->dev,
+                        AB8500_USB,
+                        AB8500_USB_LINE_STAT_REG,
+                        &reg);
+
+        lsts = (reg >> 3) & 0x0F;
+
+        switch (lsts) {
+        case USB_LINK_NOT_CONFIGURED:
+        case USB_LINK_RESERVED:
+        case USB_LINK_NOT_VALID_LINK:
+                /* TODO: Disable regulators. */
+                ab8500_usb_host_phy_dis(ab);
+                ab8500_usb_peri_phy_dis(ab);
+                ab->otg.state = OTG_STATE_B_IDLE;
+                ab->otg.default_a = false;
+                ab->vbus_draw = 0;
+                event = USB_EVENT_NONE;
+                break;
+
+        case USB_LINK_STD_HOST_NC:
+        case USB_LINK_STD_HOST_C_NS:
+        case USB_LINK_STD_HOST_C_S:
+        case USB_LINK_HOST_CHG_NM:
+        case USB_LINK_HOST_CHG_HS:
+        case USB_LINK_HOST_CHG_HS_CHIRP:
+                if (ab->otg.gadget) {
+                        /* TODO: Enable regulators. */
+                        ab8500_usb_peri_phy_en(ab);
+                        v = ab->otg.gadget;
+                }
+                event = USB_EVENT_VBUS;
+                break;
+
+        case USB_LINK_HM_IDGND:
+                if (ab->otg.host) {
+                        /* TODO: Enable regulators. */
+                        ab8500_usb_host_phy_en(ab);
+                        v = ab->otg.host;
+                }
+                ab->otg.state = OTG_STATE_A_IDLE;
+                ab->otg.default_a = true;
+                event = USB_EVENT_ID;
+                break;
+
+        case USB_LINK_ACA_RID_A:
+        case USB_LINK_ACA_RID_B:
+                /* TODO */
+        case USB_LINK_ACA_RID_C_NM:
+        case USB_LINK_ACA_RID_C_HS:
+        case USB_LINK_ACA_RID_C_HS_CHIRP:
+        case USB_LINK_DEDICATED_CHG:
+                /* TODO: vbus_draw */
+                event = USB_EVENT_CHARGER;
+                break;
+        }
+
+        atomic_notifier_call_chain(&ab->otg.notifier, event, v);
+
+        return 0;
+}
+
+static void ab8500_usb_delayed_work(struct work_struct *work)
+{
+        struct ab8500_usb *ab = container_of(work, struct ab8500_usb,
+                                                dwork.work);
+
+        ab8500_usb_link_status_update(ab);
+}
+
+static irqreturn_t ab8500_usb_v1x_common_irq(int irq, void *data)
+{
+        struct ab8500_usb *ab = (struct ab8500_usb *) data;
+
+        /* Wait for link status to become stable. */
+        schedule_delayed_work(&ab->dwork, ab->link_status_wait);
+
+        return IRQ_HANDLED;
+}
+
+static irqreturn_t ab8500_usb_v1x_vbus_fall_irq(int irq, void *data)
+{
+        struct ab8500_usb *ab = (struct ab8500_usb *) data;
+
+        /* Link status will not be updated till phy is disabled. */
+        ab8500_usb_peri_phy_dis(ab);
+
+        /* Wait for link status to become stable. */
+        schedule_delayed_work(&ab->dwork, ab->link_status_wait);
+
+        return IRQ_HANDLED;
+}
+
+static irqreturn_t ab8500_usb_v20_irq(int irq, void *data)
+{
+        struct ab8500_usb *ab = (struct ab8500_usb *) data;
+
+        ab8500_usb_link_status_update(ab);
+
+        return IRQ_HANDLED;
+}
+
+static void ab8500_usb_phy_disable_work(struct work_struct *work)
+{
+        struct ab8500_usb *ab = container_of(work, struct ab8500_usb,
+                                                phy_dis_work);
+
+        if (!ab->otg.host)
+                ab8500_usb_host_phy_dis(ab);
+
+        if (!ab->otg.gadget)
+                ab8500_usb_peri_phy_dis(ab);
+}
+
+static int ab8500_usb_set_power(struct otg_transceiver *otg, unsigned mA)
+{
+        struct ab8500_usb *ab;
+
+        if (!otg)
+                return -ENODEV;
+
+        ab = xceiv_to_ab(otg);
+
+        ab->vbus_draw = mA;
+
+        if (mA)
+                atomic_notifier_call_chain(&ab->otg.notifier,
+                                USB_EVENT_ENUMERATED, ab->otg.gadget);
+        return 0;
+}
+
+/* TODO: Implement some way for charging or other drivers to read
+ * ab->vbus_draw.
+ */
+
+static int ab8500_usb_set_suspend(struct otg_transceiver *x, int suspend)
+{
+        /* TODO */
+        return 0;
+}
+
+static int ab8500_usb_set_peripheral(struct otg_transceiver *otg,
+                struct usb_gadget *gadget)
+{
+        struct ab8500_usb *ab;
+
+        if (!otg)
+                return -ENODEV;
+
+        ab = xceiv_to_ab(otg);
+
+        /* Some drivers call this function in atomic context.
+         * Do not update ab8500 registers directly till this
+         * is fixed.
+         */
+
+        if (!gadget) {
+                /* TODO: Disable regulators. */
+                ab->otg.gadget = NULL;
+                schedule_work(&ab->phy_dis_work);
+        } else {
+                ab->otg.gadget = gadget;
+                ab->otg.state = OTG_STATE_B_IDLE;
+
+                /* Phy will not be enabled if cable is already
+                 * plugged-in. Schedule to enable phy.
+                 * Use same delay to avoid any race condition.
+                 */
+                schedule_delayed_work(&ab->dwork, ab->link_status_wait);
+        }
+
+        return 0;
+}
+
+static int ab8500_usb_set_host(struct otg_transceiver *otg,
+                                        struct usb_bus *host)
+{
+        struct ab8500_usb *ab;
+
+        if (!otg)
+                return -ENODEV;
+
+        ab = xceiv_to_ab(otg);
+
+        /* Some drivers call this function in atomic context.
+         * Do not update ab8500 registers directly till this
+         * is fixed.
+         */
+
+        if (!host) {
+                /* TODO: Disable regulators. */
+                ab->otg.host = NULL;
+                schedule_work(&ab->phy_dis_work);
+        } else {
+                ab->otg.host = host;
+                /* Phy will not be enabled if cable is already
+                 * plugged-in. Schedule to enable phy.
+                 * Use same delay to avoid any race condition.
+                 */
+                schedule_delayed_work(&ab->dwork, ab->link_status_wait);
+        }
+
+        return 0;
+}
+
+static void ab8500_usb_irq_free(struct ab8500_usb *ab)
+{
+        if (ab->rev < 0x20) {
+                free_irq(ab->irq_num_id_rise, ab);
+                free_irq(ab->irq_num_id_fall, ab);
+                free_irq(ab->irq_num_vbus_rise, ab);
+                free_irq(ab->irq_num_vbus_fall, ab);
+        } else {
+                free_irq(ab->irq_num_link_status, ab);
+        }
+}
+
+static int ab8500_usb_v1x_res_setup(struct platform_device *pdev,
+                                struct ab8500_usb *ab)
+{
+        int err;
+
+        ab->irq_num_id_rise = platform_get_irq_byname(pdev, "ID_WAKEUP_R");
+        if (ab->irq_num_id_rise < 0) {
+                dev_err(&pdev->dev, "ID rise irq not found\n");
+                return ab->irq_num_id_rise;
+        }
+        err = request_threaded_irq(ab->irq_num_id_rise, NULL,
+                ab8500_usb_v1x_common_irq,
+                IRQF_NO_SUSPEND | IRQF_SHARED,
+                "usb-id-rise", ab);
+        if (err < 0) {
+                dev_err(ab->dev, "request_irq failed for ID rise irq\n");
+                goto fail0;
+        }
+
+        ab->irq_num_id_fall = platform_get_irq_byname(pdev, "ID_WAKEUP_F");
+        if (ab->irq_num_id_fall < 0) {
+                dev_err(&pdev->dev, "ID fall irq not found\n");
+                return ab->irq_num_id_fall;
+        }
+        err = request_threaded_irq(ab->irq_num_id_fall, NULL,
+                ab8500_usb_v1x_common_irq,
+                IRQF_NO_SUSPEND | IRQF_SHARED,
+                "usb-id-fall", ab);
+        if (err < 0) {
+                dev_err(ab->dev, "request_irq failed for ID fall irq\n");
+                goto fail1;
+        }
+
+        ab->irq_num_vbus_rise = platform_get_irq_byname(pdev, "VBUS_DET_R");
+        if (ab->irq_num_vbus_rise < 0) {
+                dev_err(&pdev->dev, "VBUS rise irq not found\n");
+                return ab->irq_num_vbus_rise;
+        }
+        err = request_threaded_irq(ab->irq_num_vbus_rise, NULL,
+                ab8500_usb_v1x_common_irq,
+                IRQF_NO_SUSPEND | IRQF_SHARED,
+                "usb-vbus-rise", ab);
+        if (err < 0) {
+                dev_err(ab->dev, "request_irq failed for Vbus rise irq\n");
+                goto fail2;
+        }
+
+        ab->irq_num_vbus_fall = platform_get_irq_byname(pdev, "VBUS_DET_F");
+        if (ab->irq_num_vbus_fall < 0) {
+                dev_err(&pdev->dev, "VBUS fall irq not found\n");
+                return ab->irq_num_vbus_fall;
+        }
+        err = request_threaded_irq(ab->irq_num_vbus_fall, NULL,
+                ab8500_usb_v1x_vbus_fall_irq,
+                IRQF_NO_SUSPEND | IRQF_SHARED,
+                "usb-vbus-fall", ab);
+        if (err < 0) {
+                dev_err(ab->dev, "request_irq failed for Vbus fall irq\n");
+                goto fail3;
+        }
+
+        return 0;
+fail3:
+        free_irq(ab->irq_num_vbus_rise, ab);
+fail2:
+        free_irq(ab->irq_num_id_fall, ab);
+fail1:
+        free_irq(ab->irq_num_id_rise, ab);
+fail0:
+        return err;
+}
+
+static int ab8500_usb_v2_res_setup(struct platform_device *pdev,
+                                struct ab8500_usb *ab)
+{
+        int err;
+
+        ab->irq_num_link_status = platform_get_irq_byname(pdev,
+                                                "USB_LINK_STATUS");
+        if (ab->irq_num_link_status < 0) {
+                dev_err(&pdev->dev, "Link status irq not found\n");
+                return ab->irq_num_link_status;
+        }
+
+        err = request_threaded_irq(ab->irq_num_link_status, NULL,
+                ab8500_usb_v20_irq,
+                IRQF_NO_SUSPEND | IRQF_SHARED,
+                "usb-link-status", ab);
+        if (err < 0) {
+                dev_err(ab->dev,
+                        "request_irq failed for link status irq\n");
+                return err;
+        }
+
+        return 0;
+}
+
+static int __devinit ab8500_usb_probe(struct platform_device *pdev)
+{
+        struct ab8500_usb       *ab;
+        int err;
+        int rev;
+
+        rev = abx500_get_chip_id(&pdev->dev);
+        if (rev < 0) {
+                dev_err(&pdev->dev, "Chip id read failed\n");
+                return rev;
+        } else if (rev < 0x10) {
+                dev_err(&pdev->dev, "Unsupported AB8500 chip\n");
+                return -ENODEV;
+        }
+
+        ab = kzalloc(sizeof *ab, GFP_KERNEL);
+        if (!ab)
+                return -ENOMEM;
+
+        ab->dev                 = &pdev->dev;
+        ab->rev                 = rev;
+        ab->otg.dev             = ab->dev;
+        ab->otg.label           = "ab8500";
+        ab->otg.state           = OTG_STATE_UNDEFINED;
+        ab->otg.set_host        = ab8500_usb_set_host;
+        ab->otg.set_peripheral  = ab8500_usb_set_peripheral;
+        ab->otg.set_suspend     = ab8500_usb_set_suspend;
+        ab->otg.set_power       = ab8500_usb_set_power;
+
+        platform_set_drvdata(pdev, ab);
+
+        ATOMIC_INIT_NOTIFIER_HEAD(&ab->otg.notifier);
+
+        /* v1: Wait for link status to become stable.
+         * all: Updates form set_host and set_peripheral as they are atomic.
+         */
+        INIT_DELAYED_WORK(&ab->dwork, ab8500_usb_delayed_work);
+
+        /* all: Disable phy when called from set_host and set_peripheral */
+        INIT_WORK(&ab->phy_dis_work, ab8500_usb_phy_disable_work);
+
+        if (ab->rev < 0x20) {
+                err = ab8500_usb_v1x_res_setup(pdev, ab);
+                ab->link_status_wait = AB8500_V1x_LINK_STAT_WAIT;
+        } else {
+                err = ab8500_usb_v2_res_setup(pdev, ab);
+        }
+
+        if (err < 0)
+                goto fail0;
+
+        err = otg_set_transceiver(&ab->otg);
+        if (err) {
+                dev_err(&pdev->dev, "Can't register transceiver\n");
+                goto fail1;
+        }
+
+        dev_info(&pdev->dev, "AB8500 usb driver initialized\n");
+
+        return 0;
+fail1:
+        ab8500_usb_irq_free(ab);
+fail0:
+        kfree(ab);
+        return err;
+}
+
+static int __devexit ab8500_usb_remove(struct platform_device *pdev)
+{
+        struct ab8500_usb *ab = platform_get_drvdata(pdev);
+
+        ab8500_usb_irq_free(ab);
+
+        cancel_delayed_work_sync(&ab->dwork);
+
+        cancel_work_sync(&ab->phy_dis_work);
+
+        otg_set_transceiver(NULL);
+
+        ab8500_usb_host_phy_dis(ab);
+        ab8500_usb_peri_phy_dis(ab);
+
+        platform_set_drvdata(pdev, NULL);
+
+        kfree(ab);
+
+        return 0;
+}
+
+static struct platform_driver ab8500_usb_driver = {
+        .probe          = ab8500_usb_probe,
+        .remove         = __devexit_p(ab8500_usb_remove),
+        .driver         = {
+                .name   = "ab8500-usb",
+                .owner  = THIS_MODULE,
+        },
+};
+
+static int __init ab8500_usb_init(void)
+{
+        return platform_driver_register(&ab8500_usb_driver);
+}
+subsys_initcall(ab8500_usb_init);
+
+static void __exit ab8500_usb_exit(void)
+{
+        platform_driver_unregister(&ab8500_usb_driver);
+}
+module_exit(ab8500_usb_exit);
+
+MODULE_ALIAS("platform:ab8500_usb");
+MODULE_AUTHOR("ST-Ericsson AB");
+MODULE_DESCRIPTION("AB8500 usb transceiver driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/usb/otg/fsl_otg.c b/drivers/usb/otg/fsl_otg.c
new file mode 100644
index 000000000000..0f420b25e9a9
--- /dev/null
+++ b/drivers/usb/otg/fsl_otg.c
@@ -0,0 +1,1169 @@
+/*
+ * Copyright (C) 2007,2008 Freescale semiconductor, Inc.
+ *
+ * Author: Li Yang <LeoLi@freescale.com>
+ *         Jerry Huang <Chang-Ming.Huang@freescale.com>
+ *
+ * Initialization based on code from Shlomi Gridish.
+ *
+ * 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.
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/delay.h>
+#include <linux/slab.h>
+#include <linux/proc_fs.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/timer.h>
+#include <linux/usb.h>
+#include <linux/device.h>
+#include <linux/usb/ch9.h>
+#include <linux/usb/gadget.h>
+#include <linux/workqueue.h>
+#include <linux/time.h>
+#include <linux/fsl_devices.h>
+#include <linux/platform_device.h>
+#include <linux/uaccess.h>
+
+#include <asm/unaligned.h>
+
+#include "fsl_otg.h"
+
+#define DRIVER_VERSION "Rev. 1.55"
+#define DRIVER_AUTHOR "Jerry Huang/Li Yang"
+#define DRIVER_DESC "Freescale USB OTG Transceiver Driver"
+#define DRIVER_INFO DRIVER_DESC " " DRIVER_VERSION
+
+static const char driver_name[] = "fsl-usb2-otg";
+
+const pm_message_t otg_suspend_state = {
+        .event = 1,
+};
+
+#define HA_DATA_PULSE
+
+static struct usb_dr_mmap *usb_dr_regs;
+static struct fsl_otg *fsl_otg_dev;
+static int srp_wait_done;
+
+/* FSM timers */
+struct fsl_otg_timer *a_wait_vrise_tmr, *a_wait_bcon_tmr, *a_aidl_bdis_tmr,
+        *b_ase0_brst_tmr, *b_se0_srp_tmr;
+
+/* Driver specific timers */
+struct fsl_otg_timer *b_data_pulse_tmr, *b_vbus_pulse_tmr, *b_srp_fail_tmr,
+        *b_srp_wait_tmr, *a_wait_enum_tmr;
+
+static struct list_head active_timers;
+
+static struct fsl_otg_config fsl_otg_initdata = {
+        .otg_port = 1,
+};
+
+#ifdef CONFIG_PPC32
+static u32 _fsl_readl_be(const unsigned __iomem *p)
+{
+        return in_be32(p);
+}
+
+static u32 _fsl_readl_le(const unsigned __iomem *p)
+{
+        return in_le32(p);
+}
+
+static void _fsl_writel_be(u32 v, unsigned __iomem *p)
+{
+        out_be32(p, v);
+}
+
+static void _fsl_writel_le(u32 v, unsigned __iomem *p)
+{
+        out_le32(p, v);
+}
+
+static u32 (*_fsl_readl)(const unsigned __iomem *p);
+static void (*_fsl_writel)(u32 v, unsigned __iomem *p);
+
+#define fsl_readl(p)            (*_fsl_readl)((p))
+#define fsl_writel(v, p)        (*_fsl_writel)((v), (p))
+
+#else
+#define fsl_readl(addr)         readl(addr)
+#define fsl_writel(val, addr)   writel(val, addr)
+#endif /* CONFIG_PPC32 */
+
+/* Routines to access transceiver ULPI registers */
+u8 view_ulpi(u8 addr)
+{
+        u32 temp;
+
+        temp = 0x40000000 | (addr << 16);
+        fsl_writel(temp, &usb_dr_regs->ulpiview);
+        udelay(1000);
+        while (temp & 0x40)
+                temp = fsl_readl(&usb_dr_regs->ulpiview);
+        return (le32_to_cpu(temp) & 0x0000ff00) >> 8;
+}
+
+int write_ulpi(u8 addr, u8 data)
+{
+        u32 temp;
+
+        temp = 0x60000000 | (addr << 16) | data;
+        fsl_writel(temp, &usb_dr_regs->ulpiview);
+        return 0;
+}
+
+/* -------------------------------------------------------------*/
+/* Operations that will be called from OTG Finite State Machine */
+
+/* Charge vbus for vbus pulsing in SRP */
+void fsl_otg_chrg_vbus(int on)
+{
+        u32 tmp;
+
+        tmp = fsl_readl(&usb_dr_regs->otgsc) & ~OTGSC_INTSTS_MASK;
+
+        if (on)
+                /* stop discharging, start charging */
+                tmp = (tmp & ~OTGSC_CTRL_VBUS_DISCHARGE) |
+                        OTGSC_CTRL_VBUS_CHARGE;
+        else
+                /* stop charging */
+                tmp &= ~OTGSC_CTRL_VBUS_CHARGE;
+
+        fsl_writel(tmp, &usb_dr_regs->otgsc);
+}
+
+/* Discharge vbus through a resistor to ground */
+void fsl_otg_dischrg_vbus(int on)
+{
+        u32 tmp;
+
+        tmp = fsl_readl(&usb_dr_regs->otgsc) & ~OTGSC_INTSTS_MASK;
+
+        if (on)
+                /* stop charging, start discharging */
+                tmp = (tmp & ~OTGSC_CTRL_VBUS_CHARGE) |
+                        OTGSC_CTRL_VBUS_DISCHARGE;
+        else
+                /* stop discharging */
+                tmp &= ~OTGSC_CTRL_VBUS_DISCHARGE;
+
+        fsl_writel(tmp, &usb_dr_regs->otgsc);
+}
+
+/* A-device driver vbus, controlled through PP bit in PORTSC */
+void fsl_otg_drv_vbus(int on)
+{
+        u32 tmp;
+
+        if (on) {
+                tmp = fsl_readl(&usb_dr_regs->portsc) & ~PORTSC_W1C_BITS;
+                fsl_writel(tmp | PORTSC_PORT_POWER, &usb_dr_regs->portsc);
+        } else {
+                tmp = fsl_readl(&usb_dr_regs->portsc) &
+                      ~PORTSC_W1C_BITS & ~PORTSC_PORT_POWER;
+                fsl_writel(tmp, &usb_dr_regs->portsc);
+        }
+}
+
+/*
+ * Pull-up D+, signalling connect by periperal. Also used in
+ * data-line pulsing in SRP
+ */
+void fsl_otg_loc_conn(int on)
+{
+        u32 tmp;
+
+        tmp = fsl_readl(&usb_dr_regs->otgsc) & ~OTGSC_INTSTS_MASK;
+
+        if (on)
+                tmp |= OTGSC_CTRL_DATA_PULSING;
+        else
+                tmp &= ~OTGSC_CTRL_DATA_PULSING;
+
+        fsl_writel(tmp, &usb_dr_regs->otgsc);
+}
+
+/*
+ * Generate SOF by host.  This is controlled through suspend/resume the
+ * port.  In host mode, controller will automatically send SOF.
+ * Suspend will block the data on the port.
+ */
+void fsl_otg_loc_sof(int on)
+{
+        u32 tmp;
+
+        tmp = fsl_readl(&fsl_otg_dev->dr_mem_map->portsc) & ~PORTSC_W1C_BITS;
+        if (on)
+                tmp |= PORTSC_PORT_FORCE_RESUME;
+        else
+                tmp |= PORTSC_PORT_SUSPEND;
+
+        fsl_writel(tmp, &fsl_otg_dev->dr_mem_map->portsc);
+
+}
+
+/* Start SRP pulsing by data-line pulsing, followed with v-bus pulsing. */
+void fsl_otg_start_pulse(void)
+{
+        u32 tmp;
+
+        srp_wait_done = 0;
+#ifdef HA_DATA_PULSE
+        tmp = fsl_readl(&usb_dr_regs->otgsc) & ~OTGSC_INTSTS_MASK;
+        tmp |= OTGSC_HA_DATA_PULSE;
+        fsl_writel(tmp, &usb_dr_regs->otgsc);
+#else
+        fsl_otg_loc_conn(1);
+#endif
+
+        fsl_otg_add_timer(b_data_pulse_tmr);
+}
+
+void b_data_pulse_end(unsigned long foo)
+{
+#ifdef HA_DATA_PULSE
+#else
+        fsl_otg_loc_conn(0);
+#endif
+
+        /* Do VBUS pulse after data pulse */
+        fsl_otg_pulse_vbus();
+}
+
+void fsl_otg_pulse_vbus(void)
+{
+        srp_wait_done = 0;
+        fsl_otg_chrg_vbus(1);
+        /* start the timer to end vbus charge */
+        fsl_otg_add_timer(b_vbus_pulse_tmr);
+}
+
+void b_vbus_pulse_end(unsigned long foo)
+{
+        fsl_otg_chrg_vbus(0);
+
+        /*
+         * As USB3300 using the same a_sess_vld and b_sess_vld voltage
+         * we need to discharge the bus for a while to distinguish
+         * residual voltage of vbus pulsing and A device pull up
+         */
+        fsl_otg_dischrg_vbus(1);
+        fsl_otg_add_timer(b_srp_wait_tmr);
+}
+
+void b_srp_end(unsigned long foo)
+{
+        fsl_otg_dischrg_vbus(0);
+        srp_wait_done = 1;
+
+        if ((fsl_otg_dev->otg.state == OTG_STATE_B_SRP_INIT) &&
+            fsl_otg_dev->fsm.b_sess_vld)
+                fsl_otg_dev->fsm.b_srp_done = 1;
+}
+
+/*
+ * Workaround for a_host suspending too fast.  When a_bus_req=0,
+ * a_host will start by SRP.  It needs to set b_hnp_enable before
+ * actually suspending to start HNP
+ */
+void a_wait_enum(unsigned long foo)
+{
+        VDBG("a_wait_enum timeout\n");
+        if (!fsl_otg_dev->otg.host->b_hnp_enable)
+                fsl_otg_add_timer(a_wait_enum_tmr);
+        else
+                otg_statemachine(&fsl_otg_dev->fsm);
+}
+
+/* The timeout callback function to set time out bit */
+void set_tmout(unsigned long indicator)
+{
+        *(int *)indicator = 1;
+}
+
+/* Initialize timers */
+int fsl_otg_init_timers(struct otg_fsm *fsm)
+{
+        /* FSM used timers */
+        a_wait_vrise_tmr = otg_timer_initializer(&set_tmout, TA_WAIT_VRISE,
+                                (unsigned long)&fsm->a_wait_vrise_tmout);
+        if (!a_wait_vrise_tmr)
+                return -ENOMEM;
+
+        a_wait_bcon_tmr = otg_timer_initializer(&set_tmout, TA_WAIT_BCON,
+                                (unsigned long)&fsm->a_wait_bcon_tmout);
+        if (!a_wait_bcon_tmr)
+                return -ENOMEM;
+
+        a_aidl_bdis_tmr = otg_timer_initializer(&set_tmout, TA_AIDL_BDIS,
+                                (unsigned long)&fsm->a_aidl_bdis_tmout);
+        if (!a_aidl_bdis_tmr)
+                return -ENOMEM;
+
+        b_ase0_brst_tmr = otg_timer_initializer(&set_tmout, TB_ASE0_BRST,
+                                (unsigned long)&fsm->b_ase0_brst_tmout);
+        if (!b_ase0_brst_tmr)
+                return -ENOMEM;
+
+        b_se0_srp_tmr = otg_timer_initializer(&set_tmout, TB_SE0_SRP,
+                                (unsigned long)&fsm->b_se0_srp);
+        if (!b_se0_srp_tmr)
+                return -ENOMEM;
+
+        b_srp_fail_tmr = otg_timer_initializer(&set_tmout, TB_SRP_FAIL,
+                                (unsigned long)&fsm->b_srp_done);
+        if (!b_srp_fail_tmr)
+                return -ENOMEM;
+
+        a_wait_enum_tmr = otg_timer_initializer(&a_wait_enum, 10,
+                                (unsigned long)&fsm);
+        if (!a_wait_enum_tmr)
+                return -ENOMEM;
+
+        /* device driver used timers */
+        b_srp_wait_tmr = otg_timer_initializer(&b_srp_end, TB_SRP_WAIT, 0);
+        if (!b_srp_wait_tmr)
+                return -ENOMEM;
+
+        b_data_pulse_tmr = otg_timer_initializer(&b_data_pulse_end,
+                                TB_DATA_PLS, 0);
+        if (!b_data_pulse_tmr)
+                return -ENOMEM;
+
+        b_vbus_pulse_tmr = otg_timer_initializer(&b_vbus_pulse_end,
+                                TB_VBUS_PLS, 0);
+        if (!b_vbus_pulse_tmr)
+                return -ENOMEM;
+
+        return 0;
+}
+
+/* Uninitialize timers */
+void fsl_otg_uninit_timers(void)
+{
+        /* FSM used timers */
+        if (a_wait_vrise_tmr != NULL)
+                kfree(a_wait_vrise_tmr);
+        if (a_wait_bcon_tmr != NULL)
+                kfree(a_wait_bcon_tmr);
+        if (a_aidl_bdis_tmr != NULL)
+                kfree(a_aidl_bdis_tmr);
+        if (b_ase0_brst_tmr != NULL)
+                kfree(b_ase0_brst_tmr);
+        if (b_se0_srp_tmr != NULL)
+                kfree(b_se0_srp_tmr);
+        if (b_srp_fail_tmr != NULL)
+                kfree(b_srp_fail_tmr);
+        if (a_wait_enum_tmr != NULL)
+                kfree(a_wait_enum_tmr);
+
+        /* device driver used timers */
+        if (b_srp_wait_tmr != NULL)
+                kfree(b_srp_wait_tmr);
+        if (b_data_pulse_tmr != NULL)
+                kfree(b_data_pulse_tmr);
+        if (b_vbus_pulse_tmr != NULL)
+                kfree(b_vbus_pulse_tmr);
+}
+
+/* Add timer to timer list */
+void fsl_otg_add_timer(void *gtimer)
+{
+        struct fsl_otg_timer *timer = gtimer;
+        struct fsl_otg_timer *tmp_timer;
+
+        /*
+         * Check if the timer is already in the active list,
+         * if so update timer count
+         */
+        list_for_each_entry(tmp_timer, &active_timers, list)
+            if (tmp_timer == timer) {
+                timer->count = timer->expires;
+                return;
+        }
+        timer->count = timer->expires;
+        list_add_tail(&timer->list, &active_timers);
+}
+
+/* Remove timer from the timer list; clear timeout status */
+void fsl_otg_del_timer(void *gtimer)
+{
+        struct fsl_otg_timer *timer = gtimer;
+        struct fsl_otg_timer *tmp_timer, *del_tmp;
+
+        list_for_each_entry_safe(tmp_timer, del_tmp, &active_timers, list)
+                if (tmp_timer == timer)
+                        list_del(&timer->list);
+}
+
+/*
+ * Reduce timer count by 1, and find timeout conditions.
+ * Called by fsl_otg 1ms timer interrupt
+ */
+int fsl_otg_tick_timer(void)
+{
+        struct fsl_otg_timer *tmp_timer, *del_tmp;
+        int expired = 0;
+
+        list_for_each_entry_safe(tmp_timer, del_tmp, &active_timers, list) {
+                tmp_timer->count--;
+                /* check if timer expires */
+                if (!tmp_timer->count) {
+                        list_del(&tmp_timer->list);
+                        tmp_timer->function(tmp_timer->data);
+                        expired = 1;
+                }
+        }
+
+        return expired;
+}
+
+/* Reset controller, not reset the bus */
+void otg_reset_controller(void)
+{
+        u32 command;
+
+        command = fsl_readl(&usb_dr_regs->usbcmd);
+        command |= (1 << 1);
+        fsl_writel(command, &usb_dr_regs->usbcmd);
+        while (fsl_readl(&usb_dr_regs->usbcmd) & (1 << 1))
+                ;
+}
+
+/* Call suspend/resume routines in host driver */
+int fsl_otg_start_host(struct otg_fsm *fsm, int on)
+{
+        struct otg_transceiver *xceiv = fsm->transceiver;
+        struct device *dev;
+        struct fsl_otg *otg_dev = container_of(xceiv, struct fsl_otg, otg);
+        u32 retval = 0;
+
+        if (!xceiv->host)
+                return -ENODEV;
+        dev = xceiv->host->controller;
+
+        /*
+         * Update a_vbus_vld state as a_vbus_vld int is disabled
+         * in device mode
+         */
+        fsm->a_vbus_vld =
+                !!(fsl_readl(&usb_dr_regs->otgsc) & OTGSC_STS_A_VBUS_VALID);
+        if (on) {
+                /* start fsl usb host controller */
+                if (otg_dev->host_working)
+                        goto end;
+                else {
+                        otg_reset_controller();
+                        VDBG("host on......\n");
+                        if (dev->driver->pm && dev->driver->pm->resume) {
+                                retval = dev->driver->pm->resume(dev);
+                                if (fsm->id) {
+                                        /* default-b */
+                                        fsl_otg_drv_vbus(1);
+                                        /*
+                                         * Workaround: b_host can't driver
+                                         * vbus, but PP in PORTSC needs to
+                                         * be 1 for host to work.
+                                         * So we set drv_vbus bit in
+                                         * transceiver to 0 thru ULPI.
+                                         */
+                                        write_ulpi(0x0c, 0x20);
+                                }
+                        }
+
+                        otg_dev->host_working = 1;
+                }
+        } else {
+                /* stop fsl usb host controller */
+                if (!otg_dev->host_working)
+                        goto end;
+                else {
+                        VDBG("host off......\n");
+                        if (dev && dev->driver) {
+                                if (dev->driver->pm && dev->driver->pm->suspend)
+                                        retval = dev->driver->pm->suspend(dev);
+                                if (fsm->id)
+                                        /* default-b */
+                                        fsl_otg_drv_vbus(0);
+                        }
+                        otg_dev->host_working = 0;
+                }
+        }
+end:
+        return retval;
+}
+
+/*
+ * Call suspend and resume function in udc driver
+ * to stop and start udc driver.
+ */
+int fsl_otg_start_gadget(struct otg_fsm *fsm, int on)
+{
+        struct otg_transceiver *xceiv = fsm->transceiver;
+        struct device *dev;
+
+        if (!xceiv->gadget || !xceiv->gadget->dev.parent)
+                return -ENODEV;
+
+        VDBG("gadget %s\n", on ? "on" : "off");
+        dev = xceiv->gadget->dev.parent;
+
+        if (on) {
+                if (dev->driver->resume)
+                        dev->driver->resume(dev);
+        } else {
+                if (dev->driver->suspend)
+                        dev->driver->suspend(dev, otg_suspend_state);
+        }
+
+        return 0;
+}
+
+/*
+ * Called by initialization code of host driver.  Register host controller
+ * to the OTG.  Suspend host for OTG role detection.
+ */
+static int fsl_otg_set_host(struct otg_transceiver *otg_p, struct usb_bus *host)
+{
+        struct fsl_otg *otg_dev = container_of(otg_p, struct fsl_otg, otg);
+
+        if (!otg_p || otg_dev != fsl_otg_dev)
+                return -ENODEV;
+
+        otg_p->host = host;
+
+        otg_dev->fsm.a_bus_drop = 0;
+        otg_dev->fsm.a_bus_req = 1;
+
+        if (host) {
+                VDBG("host off......\n");
+
+                otg_p->host->otg_port = fsl_otg_initdata.otg_port;
+                otg_p->host->is_b_host = otg_dev->fsm.id;
+                /*
+                 * must leave time for khubd to finish its thing
+                 * before yanking the host driver out from under it,
+                 * so suspend the host after a short delay.
+                 */
+                otg_dev->host_working = 1;
+                schedule_delayed_work(&otg_dev->otg_event, 100);
+                return 0;
+        } else {
+                /* host driver going away */
+                if (!(fsl_readl(&otg_dev->dr_mem_map->otgsc) &
+                      OTGSC_STS_USB_ID)) {
+                        /* Mini-A cable connected */
+                        struct otg_fsm *fsm = &otg_dev->fsm;
+
+                        otg_p->state = OTG_STATE_UNDEFINED;
+                        fsm->protocol = PROTO_UNDEF;
+                }
+        }
+
+        otg_dev->host_working = 0;
+
+        otg_statemachine(&otg_dev->fsm);
+
+        return 0;
+}
+
+/* Called by initialization code of udc.  Register udc to OTG. */
+static int fsl_otg_set_peripheral(struct otg_transceiver *otg_p,
+                                  struct usb_gadget *gadget)
+{
+        struct fsl_otg *otg_dev = container_of(otg_p, struct fsl_otg, otg);
+
+        VDBG("otg_dev 0x%x\n", (int)otg_dev);
+        VDBG("fsl_otg_dev 0x%x\n", (int)fsl_otg_dev);
+
+        if (!otg_p || otg_dev != fsl_otg_dev)
+                return -ENODEV;
+
+        if (!gadget) {
+                if (!otg_dev->otg.default_a)
+                        otg_p->gadget->ops->vbus_draw(otg_p->gadget, 0);
+                usb_gadget_vbus_disconnect(otg_dev->otg.gadget);
+                otg_dev->otg.gadget = 0;
+                otg_dev->fsm.b_bus_req = 0;
+                otg_statemachine(&otg_dev->fsm);
+                return 0;
+        }
+
+        otg_p->gadget = gadget;
+        otg_p->gadget->is_a_peripheral = !otg_dev->fsm.id;
+
+        otg_dev->fsm.b_bus_req = 1;
+
+        /* start the gadget right away if the ID pin says Mini-B */
+        DBG("ID pin=%d\n", otg_dev->fsm.id);
+        if (otg_dev->fsm.id == 1) {
+                fsl_otg_start_host(&otg_dev->fsm, 0);
+                otg_drv_vbus(&otg_dev->fsm, 0);
+                fsl_otg_start_gadget(&otg_dev->fsm, 1);
+        }
+
+        return 0;
+}
+
+/* Set OTG port power, only for B-device */
+static int fsl_otg_set_power(struct otg_transceiver *otg_p, unsigned mA)
+{
+        if (!fsl_otg_dev)
+                return -ENODEV;
+        if (otg_p->state == OTG_STATE_B_PERIPHERAL)
+                pr_info("FSL OTG: Draw %d mA\n", mA);
+
+        return 0;
+}
+
+/*
+ * Delayed pin detect interrupt processing.
+ *
+ * When the Mini-A cable is disconnected from the board,
+ * the pin-detect interrupt happens before the disconnnect
+ * interrupts for the connected device(s).  In order to
+ * process the disconnect interrupt(s) prior to switching
+ * roles, the pin-detect interrupts are delayed, and handled
+ * by this routine.
+ */
+static void fsl_otg_event(struct work_struct *work)
+{
+        struct fsl_otg *og = container_of(work, struct fsl_otg, otg_event.work);
+        struct otg_fsm *fsm = &og->fsm;
+
+        if (fsm->id) {          /* switch to gadget */
+                fsl_otg_start_host(fsm, 0);
+                otg_drv_vbus(fsm, 0);
+                fsl_otg_start_gadget(fsm, 1);
+        }
+}
+
+/* B-device start SRP */
+static int fsl_otg_start_srp(struct otg_transceiver *otg_p)
+{
+        struct fsl_otg *otg_dev = container_of(otg_p, struct fsl_otg, otg);
+
+        if (!otg_p || otg_dev != fsl_otg_dev
+            || otg_p->state != OTG_STATE_B_IDLE)
+                return -ENODEV;
+
+        otg_dev->fsm.b_bus_req = 1;
+        otg_statemachine(&otg_dev->fsm);
+
+        return 0;
+}
+
+/* A_host suspend will call this function to start hnp */
+static int fsl_otg_start_hnp(struct otg_transceiver *otg_p)
+{
+        struct fsl_otg *otg_dev = container_of(otg_p, struct fsl_otg, otg);
+
+        if (!otg_p || otg_dev != fsl_otg_dev)
+                return -ENODEV;
+
+        DBG("start_hnp...n");
+
+        /* clear a_bus_req to enter a_suspend state */
+        otg_dev->fsm.a_bus_req = 0;
+        otg_statemachine(&otg_dev->fsm);
+
+        return 0;
+}
+
+/*
+ * Interrupt handler.  OTG/host/peripheral share the same int line.
+ * OTG driver clears OTGSC interrupts and leaves USB interrupts
+ * intact.  It needs to have knowledge of some USB interrupts
+ * such as port change.
+ */
+irqreturn_t fsl_otg_isr(int irq, void *dev_id)
+{
+        struct otg_fsm *fsm = &((struct fsl_otg *)dev_id)->fsm;
+        struct otg_transceiver *otg = &((struct fsl_otg *)dev_id)->otg;
+        u32 otg_int_src, otg_sc;
+
+        otg_sc = fsl_readl(&usb_dr_regs->otgsc);
+        otg_int_src = otg_sc & OTGSC_INTSTS_MASK & (otg_sc >> 8);
+
+        /* Only clear otg interrupts */
+        fsl_writel(otg_sc, &usb_dr_regs->otgsc);
+
+        /*FIXME: ID change not generate when init to 0 */
+        fsm->id = (otg_sc & OTGSC_STS_USB_ID) ? 1 : 0;
+        otg->default_a = (fsm->id == 0);
+
+        /* process OTG interrupts */
+        if (otg_int_src) {
+                if (otg_int_src & OTGSC_INTSTS_USB_ID) {
+                        fsm->id = (otg_sc & OTGSC_STS_USB_ID) ? 1 : 0;
+                        otg->default_a = (fsm->id == 0);
+                        /* clear conn information */
+                        if (fsm->id)
+                                fsm->b_conn = 0;
+                        else
+                                fsm->a_conn = 0;
+
+                        if (otg->host)
+                                otg->host->is_b_host = fsm->id;
+                        if (otg->gadget)
+                                otg->gadget->is_a_peripheral = !fsm->id;
+                        VDBG("ID int (ID is %d)\n", fsm->id);
+
+                        if (fsm->id) {  /* switch to gadget */
+                                schedule_delayed_work(
+                                        &((struct fsl_otg *)dev_id)->otg_event,
+                                        100);
+                        } else {        /* switch to host */
+                                cancel_delayed_work(&
+                                                    ((struct fsl_otg *)dev_id)->
+                                                    otg_event);
+                                fsl_otg_start_gadget(fsm, 0);
+                                otg_drv_vbus(fsm, 1);
+                                fsl_otg_start_host(fsm, 1);
+                        }
+                        return IRQ_HANDLED;
+                }
+        }
+        return IRQ_NONE;
+}
+
+static struct otg_fsm_ops fsl_otg_ops = {
+        .chrg_vbus = fsl_otg_chrg_vbus,
+        .drv_vbus = fsl_otg_drv_vbus,
+        .loc_conn = fsl_otg_loc_conn,
+        .loc_sof = fsl_otg_loc_sof,
+        .start_pulse = fsl_otg_start_pulse,
+
+        .add_timer = fsl_otg_add_timer,
+        .del_timer = fsl_otg_del_timer,
+
+        .start_host = fsl_otg_start_host,
+        .start_gadget = fsl_otg_start_gadget,
+};
+
+/* Initialize the global variable fsl_otg_dev and request IRQ for OTG */
+static int fsl_otg_conf(struct platform_device *pdev)
+{
+        struct fsl_otg *fsl_otg_tc;
+        int status;
+
+        if (fsl_otg_dev)
+                return 0;
+
+        /* allocate space to fsl otg device */
+        fsl_otg_tc = kzalloc(sizeof(struct fsl_otg), GFP_KERNEL);
+        if (!fsl_otg_tc)
+                return -ENOMEM;
+
+        INIT_DELAYED_WORK(&fsl_otg_tc->otg_event, fsl_otg_event);
+
+        INIT_LIST_HEAD(&active_timers);
+        status = fsl_otg_init_timers(&fsl_otg_tc->fsm);
+        if (status) {
+                pr_info("Couldn't init OTG timers\n");
+                goto err;
+        }
+        spin_lock_init(&fsl_otg_tc->fsm.lock);
+
+        /* Set OTG state machine operations */
+        fsl_otg_tc->fsm.ops = &fsl_otg_ops;
+
+        /* initialize the otg structure */
+        fsl_otg_tc->otg.label = DRIVER_DESC;
+        fsl_otg_tc->otg.set_host = fsl_otg_set_host;
+        fsl_otg_tc->otg.set_peripheral = fsl_otg_set_peripheral;
+        fsl_otg_tc->otg.set_power = fsl_otg_set_power;
+        fsl_otg_tc->otg.start_hnp = fsl_otg_start_hnp;
+        fsl_otg_tc->otg.start_srp = fsl_otg_start_srp;
+
+        fsl_otg_dev = fsl_otg_tc;
+
+        /* Store the otg transceiver */
+        status = otg_set_transceiver(&fsl_otg_tc->otg);
+        if (status) {
+                pr_warn(FSL_OTG_NAME ": unable to register OTG transceiver.\n");
+                goto err;
+        }
+
+        return 0;
+err:
+        fsl_otg_uninit_timers();
+        kfree(fsl_otg_tc);
+        return status;
+}
+
+/* OTG Initialization */
+int usb_otg_start(struct platform_device *pdev)
+{
+        struct fsl_otg *p_otg;
+        struct otg_transceiver *otg_trans = otg_get_transceiver();
+        struct otg_fsm *fsm;
+        int status;
+        struct resource *res;
+        u32 temp;
+        struct fsl_usb2_platform_data *pdata = pdev->dev.platform_data;
+
+        p_otg = container_of(otg_trans, struct fsl_otg, otg);
+        fsm = &p_otg->fsm;
+
+        /* Initialize the state machine structure with default values */
+        SET_OTG_STATE(otg_trans, OTG_STATE_UNDEFINED);
+        fsm->transceiver = &p_otg->otg;
+
+        /* We don't require predefined MEM/IRQ resource index */
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res)
+                return -ENXIO;
+
+        /* We don't request_mem_region here to enable resource sharing
+         * with host/device */
+
+        usb_dr_regs = ioremap(res->start, sizeof(struct usb_dr_mmap));
+        p_otg->dr_mem_map = (struct usb_dr_mmap *)usb_dr_regs;
+        pdata->regs = (void *)usb_dr_regs;
+
+        if (pdata->init && pdata->init(pdev) != 0)
+                return -EINVAL;
+
+        if (pdata->big_endian_mmio) {
+                _fsl_readl = _fsl_readl_be;
+                _fsl_writel = _fsl_writel_be;
+        } else {
+                _fsl_readl = _fsl_readl_le;
+                _fsl_writel = _fsl_writel_le;
+        }
+
+        /* request irq */
+        p_otg->irq = platform_get_irq(pdev, 0);
+        status = request_irq(p_otg->irq, fsl_otg_isr,
+                                IRQF_SHARED, driver_name, p_otg);
+        if (status) {
+                dev_dbg(p_otg->otg.dev, "can't get IRQ %d, error %d\n",
+                        p_otg->irq, status);
+                iounmap(p_otg->dr_mem_map);
+                kfree(p_otg);
+                return status;
+        }
+
+        /* stop the controller */
+        temp = fsl_readl(&p_otg->dr_mem_map->usbcmd);
+        temp &= ~USB_CMD_RUN_STOP;
+        fsl_writel(temp, &p_otg->dr_mem_map->usbcmd);
+
+        /* reset the controller */
+        temp = fsl_readl(&p_otg->dr_mem_map->usbcmd);
+        temp |= USB_CMD_CTRL_RESET;
+        fsl_writel(temp, &p_otg->dr_mem_map->usbcmd);
+
+        /* wait reset completed */
+        while (fsl_readl(&p_otg->dr_mem_map->usbcmd) & USB_CMD_CTRL_RESET)
+                ;
+
+        /* configure the VBUSHS as IDLE(both host and device) */
+        temp = USB_MODE_STREAM_DISABLE | (pdata->es ? USB_MODE_ES : 0);
+        fsl_writel(temp, &p_otg->dr_mem_map->usbmode);
+
+        /* configure PHY interface */
+        temp = fsl_readl(&p_otg->dr_mem_map->portsc);
+        temp &= ~(PORTSC_PHY_TYPE_SEL | PORTSC_PTW);
+        switch (pdata->phy_mode) {
+        case FSL_USB2_PHY_ULPI:
+                temp |= PORTSC_PTS_ULPI;
+                break;
+        case FSL_USB2_PHY_UTMI_WIDE:
+                temp |= PORTSC_PTW_16BIT;
+                /* fall through */
+        case FSL_USB2_PHY_UTMI:
+                temp |= PORTSC_PTS_UTMI;
+                /* fall through */
+        default:
+                break;
+        }
+        fsl_writel(temp, &p_otg->dr_mem_map->portsc);
+
+        if (pdata->have_sysif_regs) {
+                /* configure control enable IO output, big endian register */
+                temp = __raw_readl(&p_otg->dr_mem_map->control);
+                temp |= USB_CTRL_IOENB;
+                __raw_writel(temp, &p_otg->dr_mem_map->control);
+        }
+
+        /* disable all interrupt and clear all OTGSC status */
+        temp = fsl_readl(&p_otg->dr_mem_map->otgsc);
+        temp &= ~OTGSC_INTERRUPT_ENABLE_BITS_MASK;
+        temp |= OTGSC_INTERRUPT_STATUS_BITS_MASK | OTGSC_CTRL_VBUS_DISCHARGE;
+        fsl_writel(temp, &p_otg->dr_mem_map->otgsc);
+
+        /*
+         * The identification (id) input is FALSE when a Mini-A plug is inserted
+         * in the devices Mini-AB receptacle. Otherwise, this input is TRUE.
+         * Also: record initial state of ID pin
+         */
+        if (fsl_readl(&p_otg->dr_mem_map->otgsc) & OTGSC_STS_USB_ID) {
+                p_otg->otg.state = OTG_STATE_UNDEFINED;
+                p_otg->fsm.id = 1;
+        } else {
+                p_otg->otg.state = OTG_STATE_A_IDLE;
+                p_otg->fsm.id = 0;
+        }
+
+        DBG("initial ID pin=%d\n", p_otg->fsm.id);
+
+        /* enable OTG ID pin interrupt */
+        temp = fsl_readl(&p_otg->dr_mem_map->otgsc);
+        temp |= OTGSC_INTR_USB_ID_EN;
+        temp &= ~(OTGSC_CTRL_VBUS_DISCHARGE | OTGSC_INTR_1MS_TIMER_EN);
+        fsl_writel(temp, &p_otg->dr_mem_map->otgsc);
+
+        return 0;
+}
+
+/*
+ * state file in sysfs
+ */
+static int show_fsl_usb2_otg_state(struct device *dev,
+                                   struct device_attribute *attr, char *buf)
+{
+        struct otg_fsm *fsm = &fsl_otg_dev->fsm;
+        char *next = buf;
+        unsigned size = PAGE_SIZE;
+        unsigned long flags;
+        int t;
+
+        spin_lock_irqsave(&fsm->lock, flags);
+
+        /* basic driver infomation */
+        t = scnprintf(next, size,
+                        DRIVER_DESC "\n" "fsl_usb2_otg version: %s\n\n",
+                        DRIVER_VERSION);
+        size -= t;
+        next += t;
+
+        /* Registers */
+        t = scnprintf(next, size,
+                        "OTGSC:   0x%08x\n"
+                        "PORTSC:  0x%08x\n"
+                        "USBMODE: 0x%08x\n"
+                        "USBCMD:  0x%08x\n"
+                        "USBSTS:  0x%08x\n"
+                        "USBINTR: 0x%08x\n",
+                        fsl_readl(&usb_dr_regs->otgsc),
+                        fsl_readl(&usb_dr_regs->portsc),
+                        fsl_readl(&usb_dr_regs->usbmode),
+                        fsl_readl(&usb_dr_regs->usbcmd),
+                        fsl_readl(&usb_dr_regs->usbsts),
+                        fsl_readl(&usb_dr_regs->usbintr));
+        size -= t;
+        next += t;
+
+        /* State */
+        t = scnprintf(next, size,
+                      "OTG state: %s\n\n",
+                      otg_state_string(fsl_otg_dev->otg.state));
+        size -= t;
+        next += t;
+
+        /* State Machine Variables */
+        t = scnprintf(next, size,
+                        "a_bus_req: %d\n"
+                        "b_bus_req: %d\n"
+                        "a_bus_resume: %d\n"
+                        "a_bus_suspend: %d\n"
+                        "a_conn: %d\n"
+                        "a_sess_vld: %d\n"
+                        "a_srp_det: %d\n"
+                        "a_vbus_vld: %d\n"
+                        "b_bus_resume: %d\n"
+                        "b_bus_suspend: %d\n"
+                        "b_conn: %d\n"
+                        "b_se0_srp: %d\n"
+                        "b_sess_end: %d\n"
+                        "b_sess_vld: %d\n"
+                        "id: %d\n",
+                        fsm->a_bus_req,
+                        fsm->b_bus_req,
+                        fsm->a_bus_resume,
+                        fsm->a_bus_suspend,
+                        fsm->a_conn,
+                        fsm->a_sess_vld,
+                        fsm->a_srp_det,
+                        fsm->a_vbus_vld,
+                        fsm->b_bus_resume,
+                        fsm->b_bus_suspend,
+                        fsm->b_conn,
+                        fsm->b_se0_srp,
+                        fsm->b_sess_end,
+                        fsm->b_sess_vld,
+                        fsm->id);
+        size -= t;
+        next += t;
+
+        spin_unlock_irqrestore(&fsm->lock, flags);
+
+        return PAGE_SIZE - size;
+}
+
+static DEVICE_ATTR(fsl_usb2_otg_state, S_IRUGO, show_fsl_usb2_otg_state, NULL);
+
+
+/* Char driver interface to control some OTG input */
+
+/*
+ * Handle some ioctl command, such as get otg
+ * status and set host suspend
+ */
+static long fsl_otg_ioctl(struct file *file, unsigned int cmd,
+                          unsigned long arg)
+{
+        u32 retval = 0;
+
+        switch (cmd) {
+        case GET_OTG_STATUS:
+                retval = fsl_otg_dev->host_working;
+                break;
+
+        case SET_A_SUSPEND_REQ:
+                fsl_otg_dev->fsm.a_suspend_req = arg;
+                break;
+
+        case SET_A_BUS_DROP:
+                fsl_otg_dev->fsm.a_bus_drop = arg;
+                break;
+
+        case SET_A_BUS_REQ:
+                fsl_otg_dev->fsm.a_bus_req = arg;
+                break;
+
+        case SET_B_BUS_REQ:
+                fsl_otg_dev->fsm.b_bus_req = arg;
+                break;
+
+        default:
+                break;
+        }
+
+        otg_statemachine(&fsl_otg_dev->fsm);
+
+        return retval;
+}
+
+static int fsl_otg_open(struct inode *inode, struct file *file)
+{
+        return 0;
+}
+
+static int fsl_otg_release(struct inode *inode, struct file *file)
+{
+        return 0;
+}
+
+static const struct file_operations otg_fops = {
+        .owner = THIS_MODULE,
+        .llseek = NULL,
+        .read = NULL,
+        .write = NULL,
+        .unlocked_ioctl = fsl_otg_ioctl,
+        .open = fsl_otg_open,
+        .release = fsl_otg_release,
+};
+
+static int __devinit fsl_otg_probe(struct platform_device *pdev)
+{
+        int ret;
+
+        if (!pdev->dev.platform_data)
+                return -ENODEV;
+
+        /* configure the OTG */
+        ret = fsl_otg_conf(pdev);
+        if (ret) {
+                dev_err(&pdev->dev, "Couldn't configure OTG module\n");
+                return ret;
+        }
+
+        /* start OTG */
+        ret = usb_otg_start(pdev);
+        if (ret) {
+                dev_err(&pdev->dev, "Can't init FSL OTG device\n");
+                return ret;
+        }
+
+        ret = register_chrdev(FSL_OTG_MAJOR, FSL_OTG_NAME, &otg_fops);
+        if (ret) {
+                dev_err(&pdev->dev, "unable to register FSL OTG device\n");
+                return ret;
+        }
+
+        ret = device_create_file(&pdev->dev, &dev_attr_fsl_usb2_otg_state);
+        if (ret)
+                dev_warn(&pdev->dev, "Can't register sysfs attribute\n");
+
+        return ret;
+}
+
+static int __devexit fsl_otg_remove(struct platform_device *pdev)
+{
+        struct fsl_usb2_platform_data *pdata = pdev->dev.platform_data;
+
+        otg_set_transceiver(NULL);
+        free_irq(fsl_otg_dev->irq, fsl_otg_dev);
+
+        iounmap((void *)usb_dr_regs);
+
+        fsl_otg_uninit_timers();
+        kfree(fsl_otg_dev);
+
+        device_remove_file(&pdev->dev, &dev_attr_fsl_usb2_otg_state);
+
+        unregister_chrdev(FSL_OTG_MAJOR, FSL_OTG_NAME);
+
+        if (pdata->exit)
+                pdata->exit(pdev);
+
+        return 0;
+}
+
+struct platform_driver fsl_otg_driver = {
+        .probe = fsl_otg_probe,
+        .remove = __devexit_p(fsl_otg_remove),
+        .driver = {
+                .name = driver_name,
+                .owner = THIS_MODULE,
+        },
+};
+
+static int __init fsl_usb_otg_init(void)
+{
+        pr_info(DRIVER_INFO "\n");
+        return platform_driver_register(&fsl_otg_driver);
+}
+module_init(fsl_usb_otg_init);
+
+static void __exit fsl_usb_otg_exit(void)
+{
+        platform_driver_unregister(&fsl_otg_driver);
+}
+module_exit(fsl_usb_otg_exit);
+
+MODULE_DESCRIPTION(DRIVER_INFO);
+MODULE_AUTHOR(DRIVER_AUTHOR);
+MODULE_LICENSE("GPL");
diff --git a/drivers/usb/otg/fsl_otg.h b/drivers/usb/otg/fsl_otg.h
new file mode 100644
index 000000000000..3f8ef731aac9
--- /dev/null
+++ b/drivers/usb/otg/fsl_otg.h
@@ -0,0 +1,406 @@
+/* Copyright (C) 2007,2008 Freescale Semiconductor, Inc.
+ *
+ * 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.
+ */
+
+#include "otg_fsm.h"
+#include <linux/usb/otg.h>
+#include <linux/ioctl.h>
+
+/* USB Command Register Bit Masks */
+#define USB_CMD_RUN_STOP                (0x1<<0)
+#define USB_CMD_CTRL_RESET              (0x1<<1)
+#define USB_CMD_PERIODIC_SCHEDULE_EN    (0x1<<4)
+#define USB_CMD_ASYNC_SCHEDULE_EN       (0x1<<5)
+#define USB_CMD_INT_AA_DOORBELL         (0x1<<6)
+#define USB_CMD_ASP                     (0x3<<8)
+#define USB_CMD_ASYNC_SCH_PARK_EN       (0x1<<11)
+#define USB_CMD_SUTW                    (0x1<<13)
+#define USB_CMD_ATDTW                   (0x1<<14)
+#define USB_CMD_ITC                     (0xFF<<16)
+
+/* bit 15,3,2 are frame list size */
+#define USB_CMD_FRAME_SIZE_1024         (0x0<<15 | 0x0<<2)
+#define USB_CMD_FRAME_SIZE_512          (0x0<<15 | 0x1<<2)
+#define USB_CMD_FRAME_SIZE_256          (0x0<<15 | 0x2<<2)
+#define USB_CMD_FRAME_SIZE_128          (0x0<<15 | 0x3<<2)
+#define USB_CMD_FRAME_SIZE_64           (0x1<<15 | 0x0<<2)
+#define USB_CMD_FRAME_SIZE_32           (0x1<<15 | 0x1<<2)
+#define USB_CMD_FRAME_SIZE_16           (0x1<<15 | 0x2<<2)
+#define USB_CMD_FRAME_SIZE_8            (0x1<<15 | 0x3<<2)
+
+/* bit 9-8 are async schedule park mode count */
+#define USB_CMD_ASP_00                  (0x0<<8)
+#define USB_CMD_ASP_01                  (0x1<<8)
+#define USB_CMD_ASP_10                  (0x2<<8)
+#define USB_CMD_ASP_11                  (0x3<<8)
+#define USB_CMD_ASP_BIT_POS             (8)
+
+/* bit 23-16 are interrupt threshold control */
+#define USB_CMD_ITC_NO_THRESHOLD        (0x00<<16)
+#define USB_CMD_ITC_1_MICRO_FRM         (0x01<<16)
+#define USB_CMD_ITC_2_MICRO_FRM         (0x02<<16)
+#define USB_CMD_ITC_4_MICRO_FRM         (0x04<<16)
+#define USB_CMD_ITC_8_MICRO_FRM         (0x08<<16)
+#define USB_CMD_ITC_16_MICRO_FRM        (0x10<<16)
+#define USB_CMD_ITC_32_MICRO_FRM        (0x20<<16)
+#define USB_CMD_ITC_64_MICRO_FRM        (0x40<<16)
+#define USB_CMD_ITC_BIT_POS             (16)
+
+/* USB Status Register Bit Masks */
+#define USB_STS_INT                     (0x1<<0)
+#define USB_STS_ERR                     (0x1<<1)
+#define USB_STS_PORT_CHANGE             (0x1<<2)
+#define USB_STS_FRM_LST_ROLL            (0x1<<3)
+#define USB_STS_SYS_ERR                 (0x1<<4)
+#define USB_STS_IAA                     (0x1<<5)
+#define USB_STS_RESET_RECEIVED          (0x1<<6)
+#define USB_STS_SOF                     (0x1<<7)
+#define USB_STS_DCSUSPEND               (0x1<<8)
+#define USB_STS_HC_HALTED               (0x1<<12)
+#define USB_STS_RCL                     (0x1<<13)
+#define USB_STS_PERIODIC_SCHEDULE       (0x1<<14)
+#define USB_STS_ASYNC_SCHEDULE          (0x1<<15)
+
+/* USB Interrupt Enable Register Bit Masks */
+#define USB_INTR_INT_EN                 (0x1<<0)
+#define USB_INTR_ERR_INT_EN             (0x1<<1)
+#define USB_INTR_PC_DETECT_EN           (0x1<<2)
+#define USB_INTR_FRM_LST_ROLL_EN        (0x1<<3)
+#define USB_INTR_SYS_ERR_EN             (0x1<<4)
+#define USB_INTR_ASYN_ADV_EN            (0x1<<5)
+#define USB_INTR_RESET_EN               (0x1<<6)
+#define USB_INTR_SOF_EN                 (0x1<<7)
+#define USB_INTR_DEVICE_SUSPEND         (0x1<<8)
+
+/* Device Address bit masks */
+#define USB_DEVICE_ADDRESS_MASK         (0x7F<<25)
+#define USB_DEVICE_ADDRESS_BIT_POS      (25)
+/* PORTSC  Register Bit Masks,Only one PORT in OTG mode*/
+#define PORTSC_CURRENT_CONNECT_STATUS   (0x1<<0)
+#define PORTSC_CONNECT_STATUS_CHANGE    (0x1<<1)
+#define PORTSC_PORT_ENABLE              (0x1<<2)
+#define PORTSC_PORT_EN_DIS_CHANGE       (0x1<<3)
+#define PORTSC_OVER_CURRENT_ACT         (0x1<<4)
+#define PORTSC_OVER_CUURENT_CHG         (0x1<<5)
+#define PORTSC_PORT_FORCE_RESUME        (0x1<<6)
+#define PORTSC_PORT_SUSPEND             (0x1<<7)
+#define PORTSC_PORT_RESET               (0x1<<8)
+#define PORTSC_LINE_STATUS_BITS         (0x3<<10)
+#define PORTSC_PORT_POWER               (0x1<<12)
+#define PORTSC_PORT_INDICTOR_CTRL       (0x3<<14)
+#define PORTSC_PORT_TEST_CTRL           (0xF<<16)
+#define PORTSC_WAKE_ON_CONNECT_EN       (0x1<<20)
+#define PORTSC_WAKE_ON_CONNECT_DIS      (0x1<<21)
+#define PORTSC_WAKE_ON_OVER_CURRENT     (0x1<<22)
+#define PORTSC_PHY_LOW_POWER_SPD        (0x1<<23)
+#define PORTSC_PORT_FORCE_FULL_SPEED    (0x1<<24)
+#define PORTSC_PORT_SPEED_MASK          (0x3<<26)
+#define PORTSC_TRANSCEIVER_WIDTH        (0x1<<28)
+#define PORTSC_PHY_TYPE_SEL             (0x3<<30)
+/* bit 11-10 are line status */
+#define PORTSC_LINE_STATUS_SE0          (0x0<<10)
+#define PORTSC_LINE_STATUS_JSTATE       (0x1<<10)
+#define PORTSC_LINE_STATUS_KSTATE       (0x2<<10)
+#define PORTSC_LINE_STATUS_UNDEF        (0x3<<10)
+#define PORTSC_LINE_STATUS_BIT_POS      (10)
+
+/* bit 15-14 are port indicator control */
+#define PORTSC_PIC_OFF                  (0x0<<14)
+#define PORTSC_PIC_AMBER                (0x1<<14)
+#define PORTSC_PIC_GREEN                (0x2<<14)
+#define PORTSC_PIC_UNDEF                (0x3<<14)
+#define PORTSC_PIC_BIT_POS              (14)
+
+/* bit 19-16 are port test control */
+#define PORTSC_PTC_DISABLE              (0x0<<16)
+#define PORTSC_PTC_JSTATE               (0x1<<16)
+#define PORTSC_PTC_KSTATE               (0x2<<16)
+#define PORTSC_PTC_SEQNAK               (0x3<<16)
+#define PORTSC_PTC_PACKET               (0x4<<16)
+#define PORTSC_PTC_FORCE_EN             (0x5<<16)
+#define PORTSC_PTC_BIT_POS              (16)
+
+/* bit 27-26 are port speed */
+#define PORTSC_PORT_SPEED_FULL          (0x0<<26)
+#define PORTSC_PORT_SPEED_LOW           (0x1<<26)
+#define PORTSC_PORT_SPEED_HIGH          (0x2<<26)
+#define PORTSC_PORT_SPEED_UNDEF         (0x3<<26)
+#define PORTSC_SPEED_BIT_POS            (26)
+
+/* bit 28 is parallel transceiver width for UTMI interface */
+#define PORTSC_PTW                      (0x1<<28)
+#define PORTSC_PTW_8BIT                 (0x0<<28)
+#define PORTSC_PTW_16BIT                (0x1<<28)
+
+/* bit 31-30 are port transceiver select */
+#define PORTSC_PTS_UTMI                 (0x0<<30)
+#define PORTSC_PTS_ULPI                 (0x2<<30)
+#define PORTSC_PTS_FSLS_SERIAL          (0x3<<30)
+#define PORTSC_PTS_BIT_POS              (30)
+
+#define PORTSC_W1C_BITS                 \
+        (PORTSC_CONNECT_STATUS_CHANGE | \
+         PORTSC_PORT_EN_DIS_CHANGE    | \
+         PORTSC_OVER_CUURENT_CHG)
+
+/* OTG Status Control Register Bit Masks */
+#define OTGSC_CTRL_VBUS_DISCHARGE       (0x1<<0)
+#define OTGSC_CTRL_VBUS_CHARGE          (0x1<<1)
+#define OTGSC_CTRL_OTG_TERMINATION      (0x1<<3)
+#define OTGSC_CTRL_DATA_PULSING         (0x1<<4)
+#define OTGSC_CTRL_ID_PULL_EN           (0x1<<5)
+#define OTGSC_HA_DATA_PULSE             (0x1<<6)
+#define OTGSC_HA_BA                     (0x1<<7)
+#define OTGSC_STS_USB_ID                (0x1<<8)
+#define OTGSC_STS_A_VBUS_VALID          (0x1<<9)
+#define OTGSC_STS_A_SESSION_VALID       (0x1<<10)
+#define OTGSC_STS_B_SESSION_VALID       (0x1<<11)
+#define OTGSC_STS_B_SESSION_END         (0x1<<12)
+#define OTGSC_STS_1MS_TOGGLE            (0x1<<13)
+#define OTGSC_STS_DATA_PULSING          (0x1<<14)
+#define OTGSC_INTSTS_USB_ID             (0x1<<16)
+#define OTGSC_INTSTS_A_VBUS_VALID       (0x1<<17)
+#define OTGSC_INTSTS_A_SESSION_VALID    (0x1<<18)
+#define OTGSC_INTSTS_B_SESSION_VALID    (0x1<<19)
+#define OTGSC_INTSTS_B_SESSION_END      (0x1<<20)
+#define OTGSC_INTSTS_1MS                (0x1<<21)
+#define OTGSC_INTSTS_DATA_PULSING       (0x1<<22)
+#define OTGSC_INTR_USB_ID_EN            (0x1<<24)
+#define OTGSC_INTR_A_VBUS_VALID_EN      (0x1<<25)
+#define OTGSC_INTR_A_SESSION_VALID_EN   (0x1<<26)
+#define OTGSC_INTR_B_SESSION_VALID_EN   (0x1<<27)
+#define OTGSC_INTR_B_SESSION_END_EN     (0x1<<28)
+#define OTGSC_INTR_1MS_TIMER_EN         (0x1<<29)
+#define OTGSC_INTR_DATA_PULSING_EN      (0x1<<30)
+#define OTGSC_INTSTS_MASK               (0x00ff0000)
+
+/* USB MODE Register Bit Masks */
+#define  USB_MODE_CTRL_MODE_IDLE        (0x0<<0)
+#define  USB_MODE_CTRL_MODE_DEVICE      (0x2<<0)
+#define  USB_MODE_CTRL_MODE_HOST        (0x3<<0)
+#define  USB_MODE_CTRL_MODE_RSV         (0x1<<0)
+#define  USB_MODE_SETUP_LOCK_OFF        (0x1<<3)
+#define  USB_MODE_STREAM_DISABLE        (0x1<<4)
+#define  USB_MODE_ES                    (0x1<<2) /* Endian Select */
+
+/* control Register Bit Masks */
+#define  USB_CTRL_IOENB                 (0x1<<2)
+#define  USB_CTRL_ULPI_INT0EN           (0x1<<0)
+
+/* BCSR5 */
+#define BCSR5_INT_USB                   (0x02)
+
+/* USB module clk cfg */
+#define SCCR_OFFS                       (0xA08)
+#define SCCR_USB_CLK_DISABLE            (0x00000000)    /* USB clk disable */
+#define SCCR_USB_MPHCM_11               (0x00c00000)
+#define SCCR_USB_MPHCM_01               (0x00400000)
+#define SCCR_USB_MPHCM_10               (0x00800000)
+#define SCCR_USB_DRCM_11                (0x00300000)
+#define SCCR_USB_DRCM_01                (0x00100000)
+#define SCCR_USB_DRCM_10                (0x00200000)
+
+#define SICRL_OFFS                      (0x114)
+#define SICRL_USB0                      (0x40000000)
+#define SICRL_USB1                      (0x20000000)
+
+#define SICRH_OFFS                      (0x118)
+#define SICRH_USB_UTMI                  (0x00020000)
+
+/* OTG interrupt enable bit masks */
+#define  OTGSC_INTERRUPT_ENABLE_BITS_MASK  \
+        (OTGSC_INTR_USB_ID_EN            | \
+        OTGSC_INTR_1MS_TIMER_EN          | \
+        OTGSC_INTR_A_VBUS_VALID_EN       | \
+        OTGSC_INTR_A_SESSION_VALID_EN    | \
+        OTGSC_INTR_B_SESSION_VALID_EN    | \
+        OTGSC_INTR_B_SESSION_END_EN      | \
+        OTGSC_INTR_DATA_PULSING_EN)
+
+/* OTG interrupt status bit masks */
+#define  OTGSC_INTERRUPT_STATUS_BITS_MASK  \
+        (OTGSC_INTSTS_USB_ID          |    \
+        OTGSC_INTR_1MS_TIMER_EN       |    \
+        OTGSC_INTSTS_A_VBUS_VALID     |    \
+        OTGSC_INTSTS_A_SESSION_VALID  |    \
+        OTGSC_INTSTS_B_SESSION_VALID  |    \
+        OTGSC_INTSTS_B_SESSION_END    |    \
+        OTGSC_INTSTS_DATA_PULSING)
+
+/*
+ *  A-DEVICE timing  constants
+ */
+
+/* Wait for VBUS Rise  */
+#define TA_WAIT_VRISE   (100)   /* a_wait_vrise 100 ms, section: 6.6.5.1 */
+
+/* Wait for B-Connect */
+#define TA_WAIT_BCON    (10000)  /* a_wait_bcon > 1 sec, section: 6.6.5.2
+                                  * This is only used to get out of
+                                  * OTG_STATE_A_WAIT_BCON state if there was
+                                  * no connection for these many milliseconds
+                                  */
+
+/* A-Idle to B-Disconnect */
+/* It is necessary for this timer to be more than 750 ms because of a bug in OPT
+ * test 5.4 in which B OPT disconnects after 750 ms instead of 75ms as stated
+ * in the test description
+ */
+#define TA_AIDL_BDIS    (5000)  /* a_suspend minimum 200 ms, section: 6.6.5.3 */
+
+/* B-Idle to A-Disconnect */
+#define TA_BIDL_ADIS    (12)    /* 3 to 200 ms */
+
+/* B-device timing constants */
+
+
+/* Data-Line Pulse Time*/
+#define TB_DATA_PLS     (10)    /* b_srp_init,continue 5~10ms, section:5.3.3 */
+#define TB_DATA_PLS_MIN (5)     /* minimum 5 ms */
+#define TB_DATA_PLS_MAX (10)    /* maximum 10 ms */
+
+/* SRP Initiate Time  */
+#define TB_SRP_INIT     (100)   /* b_srp_init,maximum 100 ms, section:5.3.8 */
+
+/* SRP Fail Time  */
+#define TB_SRP_FAIL     (7000)  /* b_srp_init,Fail time 5~30s, section:6.8.2.2*/
+
+/* SRP result wait time */
+#define TB_SRP_WAIT     (60)
+
+/* VBus time */
+#define TB_VBUS_PLS     (30)    /* time to keep vbus pulsing asserted */
+
+/* Discharge time */
+/* This time should be less than 10ms. It varies from system to system. */
+#define TB_VBUS_DSCHRG  (8)
+
+/* A-SE0 to B-Reset  */
+#define TB_ASE0_BRST    (20)    /* b_wait_acon, mini 3.125 ms,section:6.8.2.4 */
+
+/* A bus suspend timer before we can switch to b_wait_aconn */
+#define TB_A_SUSPEND    (7)
+#define TB_BUS_RESUME   (12)
+
+/* SE0 Time Before SRP */
+#define TB_SE0_SRP      (2)     /* b_idle,minimum 2 ms, section:5.3.2 */
+
+#define SET_OTG_STATE(otg_ptr, newstate)        ((otg_ptr)->state = newstate)
+
+struct usb_dr_mmap {
+        /* Capability register */
+        u8 res1[256];
+        u16 caplength;          /* Capability Register Length */
+        u16 hciversion;         /* Host Controller Interface Version */
+        u32 hcsparams;          /* Host Controller Structual Parameters */
+        u32 hccparams;          /* Host Controller Capability Parameters */
+        u8 res2[20];
+        u32 dciversion;         /* Device Controller Interface Version */
+        u32 dccparams;          /* Device Controller Capability Parameters */
+        u8 res3[24];
+        /* Operation register */
+        u32 usbcmd;             /* USB Command Register */
+        u32 usbsts;             /* USB Status Register */
+        u32 usbintr;            /* USB Interrupt Enable Register */
+        u32 frindex;            /* Frame Index Register */
+        u8 res4[4];
+        u32 deviceaddr;         /* Device Address */
+        u32 endpointlistaddr;   /* Endpoint List Address Register */
+        u8 res5[4];
+        u32 burstsize;          /* Master Interface Data Burst Size Register */
+        u32 txttfilltuning;     /* Transmit FIFO Tuning Controls Register */
+        u8 res6[8];
+        u32 ulpiview;           /* ULPI register access */
+        u8 res7[12];
+        u32 configflag;         /* Configure Flag Register */
+        u32 portsc;             /* Port 1 Status and Control Register */
+        u8 res8[28];
+        u32 otgsc;              /* On-The-Go Status and Control */
+        u32 usbmode;            /* USB Mode Register */
+        u32 endptsetupstat;     /* Endpoint Setup Status Register */
+        u32 endpointprime;      /* Endpoint Initialization Register */
+        u32 endptflush;         /* Endpoint Flush Register */
+        u32 endptstatus;        /* Endpoint Status Register */
+        u32 endptcomplete;      /* Endpoint Complete Register */
+        u32 endptctrl[6];       /* Endpoint Control Registers */
+        u8 res9[552];
+        u32 snoop1;
+        u32 snoop2;
+        u32 age_cnt_thresh;     /* Age Count Threshold Register */
+        u32 pri_ctrl;           /* Priority Control Register */
+        u32 si_ctrl;            /* System Interface Control Register */
+        u8 res10[236];
+        u32 control;            /* General Purpose Control Register */
+};
+
+struct fsl_otg_timer {
+        unsigned long expires;  /* Number of count increase to timeout */
+        unsigned long count;    /* Tick counter */
+        void (*function)(unsigned long);        /* Timeout function */
+        unsigned long data;     /* Data passed to function */
+        struct list_head list;
+};
+
+inline struct fsl_otg_timer *otg_timer_initializer
+(void (*function)(unsigned long), unsigned long expires, unsigned long data)
+{
+        struct fsl_otg_timer *timer;
+
+        timer = kmalloc(sizeof(struct fsl_otg_timer), GFP_KERNEL);
+        if (!timer)
+                return NULL;
+        timer->function = function;
+        timer->expires = expires;
+        timer->data = data;
+        return timer;
+}
+
+struct fsl_otg {
+        struct otg_transceiver otg;
+        struct otg_fsm fsm;
+        struct usb_dr_mmap *dr_mem_map;
+        struct delayed_work otg_event;
+
+        /* used for usb host */
+        struct work_struct work_wq;
+        u8      host_working;
+
+        int irq;
+};
+
+struct fsl_otg_config {
+        u8 otg_port;
+};
+
+/* For SRP and HNP handle */
+#define FSL_OTG_MAJOR           240
+#define FSL_OTG_NAME            "fsl-usb2-otg"
+/* Command to OTG driver ioctl */
+#define OTG_IOCTL_MAGIC         FSL_OTG_MAJOR
+/* if otg work as host, it should return 1, otherwise return 0 */
+#define GET_OTG_STATUS          _IOR(OTG_IOCTL_MAGIC, 1, int)
+#define SET_A_SUSPEND_REQ       _IOW(OTG_IOCTL_MAGIC, 2, int)
+#define SET_A_BUS_DROP          _IOW(OTG_IOCTL_MAGIC, 3, int)
+#define SET_A_BUS_REQ           _IOW(OTG_IOCTL_MAGIC, 4, int)
+#define SET_B_BUS_REQ           _IOW(OTG_IOCTL_MAGIC, 5, int)
+#define GET_A_SUSPEND_REQ       _IOR(OTG_IOCTL_MAGIC, 6, int)
+#define GET_A_BUS_DROP          _IOR(OTG_IOCTL_MAGIC, 7, int)
+#define GET_A_BUS_REQ           _IOR(OTG_IOCTL_MAGIC, 8, int)
+#define GET_B_BUS_REQ           _IOR(OTG_IOCTL_MAGIC, 9, int)
+
+void fsl_otg_add_timer(void *timer);
+void fsl_otg_del_timer(void *timer);
+void fsl_otg_pulse_vbus(void);
diff --git a/drivers/usb/otg/gpio_vbus.c b/drivers/usb/otg/gpio_vbus.c
index 221c44444ec6..52733d9959b4 100644
--- a/drivers/usb/otg/gpio_vbus.c
+++ b/drivers/usb/otg/gpio_vbus.c
@@ -279,6 +279,13 @@ static int __init gpio_vbus_probe(struct platform_device *pdev)
         }
         INIT_WORK(&gpio_vbus->work, gpio_vbus_work);
 
+        gpio_vbus->vbus_draw = regulator_get(&pdev->dev, "vbus_draw");
+        if (IS_ERR(gpio_vbus->vbus_draw)) {
+                dev_dbg(&pdev->dev, "can't get vbus_draw regulator, err: %ld\n",
+                        PTR_ERR(gpio_vbus->vbus_draw));
+                gpio_vbus->vbus_draw = NULL;
+        }
+
         /* only active when a gadget is registered */
         err = otg_set_transceiver(&gpio_vbus->otg);
         if (err) {
@@ -287,13 +294,6 @@ static int __init gpio_vbus_probe(struct platform_device *pdev)
                 goto err_otg;
         }
 
-        gpio_vbus->vbus_draw = regulator_get(&pdev->dev, "vbus_draw");
-        if (IS_ERR(gpio_vbus->vbus_draw)) {
-                dev_dbg(&pdev->dev, "can't get vbus_draw regulator, err: %ld\n",
-                        PTR_ERR(gpio_vbus->vbus_draw));
-                gpio_vbus->vbus_draw = NULL;
-        }
-
         return 0;
 err_otg:
         free_irq(irq, &pdev->dev);
diff --git a/drivers/usb/otg/isp1301_omap.c b/drivers/usb/otg/isp1301_omap.c
index 456969492410..8c282258e1bd 100644
--- a/drivers/usb/otg/isp1301_omap.c
+++ b/drivers/usb/otg/isp1301_omap.c
@@ -234,29 +234,9 @@ isp1301_clear_bits(struct isp1301 *isp, u8 reg, u8 bits)
 
 /*-------------------------------------------------------------------------*/
 
-static const char *state_string(enum usb_otg_state state)
-{
-        switch (state) {
-        case OTG_STATE_A_IDLE:          return "a_idle";
-        case OTG_STATE_A_WAIT_VRISE:    return "a_wait_vrise";
-        case OTG_STATE_A_WAIT_BCON:     return "a_wait_bcon";
-        case OTG_STATE_A_HOST:          return "a_host";
-        case OTG_STATE_A_SUSPEND:       return "a_suspend";
-        case OTG_STATE_A_PERIPHERAL:    return "a_peripheral";
-        case OTG_STATE_A_WAIT_VFALL:    return "a_wait_vfall";
-        case OTG_STATE_A_VBUS_ERR:      return "a_vbus_err";
-        case OTG_STATE_B_IDLE:          return "b_idle";
-        case OTG_STATE_B_SRP_INIT:      return "b_srp_init";
-        case OTG_STATE_B_PERIPHERAL:    return "b_peripheral";
-        case OTG_STATE_B_WAIT_ACON:     return "b_wait_acon";
-        case OTG_STATE_B_HOST:          return "b_host";
-        default:                        return "UNDEFINED";
-        }
-}
-
 static inline const char *state_name(struct isp1301 *isp)
 {
-        return state_string(isp->otg.state);
+        return otg_state_string(isp->otg.state);
 }
 
 /*-------------------------------------------------------------------------*/
@@ -501,7 +481,7 @@ static void check_state(struct isp1301 *isp, const char *tag)
         if (isp->otg.state == state && !extra)
                 return;
         pr_debug("otg: %s FSM %s/%02x, %s, %06x\n", tag,
-                state_string(state), fsm, state_name(isp),
+                otg_state_string(state), fsm, state_name(isp),
                 omap_readl(OTG_CTRL));
 }
 
@@ -1095,7 +1075,7 @@ static void isp_update_otg(struct isp1301 *isp, u8 stat)
 
         if (state != isp->otg.state)
                 pr_debug("  isp, %s -> %s\n",
-                                state_string(state), state_name(isp));
+                                otg_state_string(state), state_name(isp));
 
 #ifdef  CONFIG_USB_OTG
         /* update the OTG controller state to match the isp1301; may
@@ -1247,7 +1227,7 @@ static int __exit isp1301_remove(struct i2c_client *i2c)
         isp->timer.data = 0;
         set_bit(WORK_STOP, &isp->todo);
         del_timer_sync(&isp->timer);
-        flush_scheduled_work();
+        flush_work_sync(&isp->work);
 
         put_device(&i2c->dev);
         the_transceiver = NULL;
@@ -1510,7 +1490,7 @@ isp1301_start_hnp(struct otg_transceiver *dev)
 
 /*-------------------------------------------------------------------------*/
 
-static int __init
+static int __devinit
 isp1301_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
 {
         int                     status;
@@ -1531,7 +1511,7 @@ isp1301_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
         i2c_set_clientdata(i2c, isp);
         isp->client = i2c;
 
-        /* verify the chip (shouldn't be necesary) */
+        /* verify the chip (shouldn't be necessary) */
         status = isp1301_get_u16(isp, ISP1301_VENDOR_ID);
         if (status != I2C_VENDOR_ID_PHILIPS) {
                 dev_dbg(&i2c->dev, "not philips id: %d\n", status);
diff --git a/drivers/usb/otg/langwell_otg.c b/drivers/usb/otg/langwell_otg.c
new file mode 100644
index 000000000000..f08f784086f7
--- /dev/null
+++ b/drivers/usb/otg/langwell_otg.c
@@ -0,0 +1,2347 @@
+/*
+ * Intel Langwell USB OTG transceiver driver
+ * Copyright (C) 2008 - 2010, Intel Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope 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.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ */
+/* This driver helps to switch Langwell OTG controller function between host
+ * and peripheral. It works with EHCI driver and Langwell client controller
+ * driver together.
+ */
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/pci.h>
+#include <linux/errno.h>
+#include <linux/interrupt.h>
+#include <linux/kernel.h>
+#include <linux/device.h>
+#include <linux/moduleparam.h>
+#include <linux/usb/ch9.h>
+#include <linux/usb/gadget.h>
+#include <linux/usb.h>
+#include <linux/usb/otg.h>
+#include <linux/usb/hcd.h>
+#include <linux/notifier.h>
+#include <linux/delay.h>
+#include <asm/intel_scu_ipc.h>
+
+#include <linux/usb/langwell_otg.h>
+
+#define DRIVER_DESC             "Intel Langwell USB OTG transceiver driver"
+#define DRIVER_VERSION          "July 10, 2010"
+
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_AUTHOR("Henry Yuan <hang.yuan@intel.com>, Hao Wu <hao.wu@intel.com>");
+MODULE_VERSION(DRIVER_VERSION);
+MODULE_LICENSE("GPL");
+
+static const char driver_name[] = "langwell_otg";
+
+static int langwell_otg_probe(struct pci_dev *pdev,
+                        const struct pci_device_id *id);
+static void langwell_otg_remove(struct pci_dev *pdev);
+static int langwell_otg_suspend(struct pci_dev *pdev, pm_message_t message);
+static int langwell_otg_resume(struct pci_dev *pdev);
+
+static int langwell_otg_set_host(struct otg_transceiver *otg,
+                                struct usb_bus *host);
+static int langwell_otg_set_peripheral(struct otg_transceiver *otg,
+                                struct usb_gadget *gadget);
+static int langwell_otg_start_srp(struct otg_transceiver *otg);
+
+static const struct pci_device_id pci_ids[] = {{
+        .class =        ((PCI_CLASS_SERIAL_USB << 8) | 0xfe),
+        .class_mask =   ~0,
+        .vendor =       0x8086,
+        .device =       0x0811,
+        .subvendor =    PCI_ANY_ID,
+        .subdevice =    PCI_ANY_ID,
+}, { /* end: all zeroes */ }
+};
+
+static struct pci_driver otg_pci_driver = {
+        .name =         (char *) driver_name,
+        .id_table =     pci_ids,
+
+        .probe =        langwell_otg_probe,
+        .remove =       langwell_otg_remove,
+
+        .suspend =      langwell_otg_suspend,
+        .resume =       langwell_otg_resume,
+};
+
+/* HSM timers */
+static inline struct langwell_otg_timer *otg_timer_initializer
+(void (*function)(unsigned long), unsigned long expires, unsigned long data)
+{
+        struct langwell_otg_timer *timer;
+        timer = kmalloc(sizeof(struct langwell_otg_timer), GFP_KERNEL);
+        if (timer == NULL)
+                return timer;
+
+        timer->function = function;
+        timer->expires = expires;
+        timer->data = data;
+        return timer;
+}
+
+static struct langwell_otg_timer *a_wait_vrise_tmr, *a_aidl_bdis_tmr,
+        *b_se0_srp_tmr, *b_srp_init_tmr;
+
+static struct list_head active_timers;
+
+static struct langwell_otg *the_transceiver;
+
+/* host/client notify transceiver when event affects HNP state */
+void langwell_update_transceiver(void)
+{
+        struct langwell_otg *lnw = the_transceiver;
+
+        dev_dbg(lnw->dev, "transceiver is updated\n");
+
+        if (!lnw->qwork)
+                return ;
+
+        queue_work(lnw->qwork, &lnw->work);
+}
+EXPORT_SYMBOL(langwell_update_transceiver);
+
+static int langwell_otg_set_host(struct otg_transceiver *otg,
+                                        struct usb_bus *host)
+{
+        otg->host = host;
+
+        return 0;
+}
+
+static int langwell_otg_set_peripheral(struct otg_transceiver *otg,
+                                        struct usb_gadget *gadget)
+{
+        otg->gadget = gadget;
+
+        return 0;
+}
+
+static int langwell_otg_set_power(struct otg_transceiver *otg,
+                                unsigned mA)
+{
+        return 0;
+}
+
+/* A-device drives vbus, controlled through IPC commands */
+static int langwell_otg_set_vbus(struct otg_transceiver *otg, bool enabled)
+{
+        struct langwell_otg             *lnw = the_transceiver;
+        u8                              sub_id;
+
+        dev_dbg(lnw->dev, "%s <--- %s\n", __func__, enabled ? "on" : "off");
+
+        if (enabled)
+                sub_id = 0x8; /* Turn on the VBus */
+        else
+                sub_id = 0x9; /* Turn off the VBus */
+
+        if (intel_scu_ipc_simple_command(0xef, sub_id)) {
+                dev_dbg(lnw->dev, "Failed to set Vbus via IPC commands\n");
+                return -EBUSY;
+        }
+
+        dev_dbg(lnw->dev, "%s --->\n", __func__);
+
+        return 0;
+}
+
+/* charge vbus or discharge vbus through a resistor to ground */
+static void langwell_otg_chrg_vbus(int on)
+{
+        struct langwell_otg     *lnw = the_transceiver;
+        u32     val;
+
+        val = readl(lnw->iotg.base + CI_OTGSC);
+
+        if (on)
+                writel((val & ~OTGSC_INTSTS_MASK) | OTGSC_VC,
+                                lnw->iotg.base + CI_OTGSC);
+        else
+                writel((val & ~OTGSC_INTSTS_MASK) | OTGSC_VD,
+                                lnw->iotg.base + CI_OTGSC);
+}
+
+/* Start SRP */
+static int langwell_otg_start_srp(struct otg_transceiver *otg)
+{
+        struct langwell_otg             *lnw = the_transceiver;
+        struct intel_mid_otg_xceiv      *iotg = &lnw->iotg;
+        u32                             val;
+
+        dev_dbg(lnw->dev, "%s --->\n", __func__);
+
+        val = readl(iotg->base + CI_OTGSC);
+
+        writel((val & ~OTGSC_INTSTS_MASK) | OTGSC_HADP,
+                                iotg->base + CI_OTGSC);
+
+        /* Check if the data plus is finished or not */
+        msleep(8);
+        val = readl(iotg->base + CI_OTGSC);
+        if (val & (OTGSC_HADP | OTGSC_DP))
+                dev_dbg(lnw->dev, "DataLine SRP Error\n");
+
+        /* Disable interrupt - b_sess_vld */
+        val = readl(iotg->base + CI_OTGSC);
+        val &= (~(OTGSC_BSVIE | OTGSC_BSEIE));
+        writel(val, iotg->base + CI_OTGSC);
+
+        /* Start VBus SRP, drive vbus to generate VBus pulse */
+        iotg->otg.set_vbus(&iotg->otg, true);
+        msleep(15);
+        iotg->otg.set_vbus(&iotg->otg, false);
+
+        /* Enable interrupt - b_sess_vld*/
+        val = readl(iotg->base + CI_OTGSC);
+        dev_dbg(lnw->dev, "after VBUS pulse otgsc = %x\n", val);
+
+        val |= (OTGSC_BSVIE | OTGSC_BSEIE);
+        writel(val, iotg->base + CI_OTGSC);
+
+        /* If Vbus is valid, then update the hsm */
+        if (val & OTGSC_BSV) {
+                dev_dbg(lnw->dev, "no b_sess_vld interrupt\n");
+
+                lnw->iotg.hsm.b_sess_vld = 1;
+                langwell_update_transceiver();
+        }
+
+        dev_dbg(lnw->dev, "%s <---\n", __func__);
+        return 0;
+}
+
+/* stop SOF via bus_suspend */
+static void langwell_otg_loc_sof(int on)
+{
+        struct langwell_otg     *lnw = the_transceiver;
+        struct usb_hcd          *hcd;
+        int                     err;
+
+        dev_dbg(lnw->dev, "%s ---> %s\n", __func__, on ? "suspend" : "resume");
+
+        hcd = bus_to_hcd(lnw->iotg.otg.host);
+        if (on)
+                err = hcd->driver->bus_resume(hcd);
+        else
+                err = hcd->driver->bus_suspend(hcd);
+
+        if (err)
+                dev_dbg(lnw->dev, "Fail to resume/suspend USB bus - %d\n", err);
+
+        dev_dbg(lnw->dev, "%s <---\n", __func__);
+}
+
+static int langwell_otg_check_otgsc(void)
+{
+        struct langwell_otg             *lnw = the_transceiver;
+        u32                             otgsc, usbcfg;
+
+        dev_dbg(lnw->dev, "check sync OTGSC and USBCFG registers\n");
+
+        otgsc = readl(lnw->iotg.base + CI_OTGSC);
+        usbcfg = readl(lnw->usbcfg);
+
+        dev_dbg(lnw->dev, "OTGSC = %08x, USBCFG = %08x\n",
+                                        otgsc, usbcfg);
+        dev_dbg(lnw->dev, "OTGSC_AVV = %d\n", !!(otgsc & OTGSC_AVV));
+        dev_dbg(lnw->dev, "USBCFG.VBUSVAL = %d\n",
+                                        !!(usbcfg & USBCFG_VBUSVAL));
+        dev_dbg(lnw->dev, "OTGSC_ASV = %d\n", !!(otgsc & OTGSC_ASV));
+        dev_dbg(lnw->dev, "USBCFG.AVALID = %d\n",
+                                        !!(usbcfg & USBCFG_AVALID));
+        dev_dbg(lnw->dev, "OTGSC_BSV = %d\n", !!(otgsc & OTGSC_BSV));
+        dev_dbg(lnw->dev, "USBCFG.BVALID = %d\n",
+                                        !!(usbcfg & USBCFG_BVALID));
+        dev_dbg(lnw->dev, "OTGSC_BSE = %d\n", !!(otgsc & OTGSC_BSE));
+        dev_dbg(lnw->dev, "USBCFG.SESEND = %d\n",
+                                        !!(usbcfg & USBCFG_SESEND));
+
+        /* Check USBCFG VBusValid/AValid/BValid/SessEnd */
+        if (!!(otgsc & OTGSC_AVV) ^ !!(usbcfg & USBCFG_VBUSVAL)) {
+                dev_dbg(lnw->dev, "OTGSC.AVV != USBCFG.VBUSVAL\n");
+                goto err;
+        }
+        if (!!(otgsc & OTGSC_ASV) ^ !!(usbcfg & USBCFG_AVALID)) {
+                dev_dbg(lnw->dev, "OTGSC.ASV != USBCFG.AVALID\n");
+                goto err;
+        }
+        if (!!(otgsc & OTGSC_BSV) ^ !!(usbcfg & USBCFG_BVALID)) {
+                dev_dbg(lnw->dev, "OTGSC.BSV != USBCFG.BVALID\n");
+                goto err;
+        }
+        if (!!(otgsc & OTGSC_BSE) ^ !!(usbcfg & USBCFG_SESEND)) {
+                dev_dbg(lnw->dev, "OTGSC.BSE != USBCFG.SESSEN\n");
+                goto err;
+        }
+
+        dev_dbg(lnw->dev, "OTGSC and USBCFG are synced\n");
+
+        return 0;
+
+err:
+        dev_warn(lnw->dev, "OTGSC isn't equal to USBCFG\n");
+        return -EPIPE;
+}
+
+
+static void langwell_otg_phy_low_power(int on)
+{
+        struct langwell_otg             *lnw = the_transceiver;
+        struct intel_mid_otg_xceiv      *iotg = &lnw->iotg;
+        u8                              val, phcd;
+        int                             retval;
+
+        dev_dbg(lnw->dev, "%s ---> %s mode\n",
+                        __func__, on ? "Low power" : "Normal");
+
+        phcd = 0x40;
+
+        val = readb(iotg->base + CI_HOSTPC1 + 2);
+
+        if (on) {
+                /* Due to hardware issue, after set PHCD, sync will failed
+                 * between USBCFG and OTGSC, so before set PHCD, check if
+                 * sync is in process now. If the answer is "yes", then do
+                 * not touch PHCD bit */
+                retval = langwell_otg_check_otgsc();
+                if (retval) {
+                        dev_dbg(lnw->dev, "Skip PHCD programming..\n");
+                        return ;
+                }
+
+                writeb(val | phcd, iotg->base + CI_HOSTPC1 + 2);
+        } else
+                writeb(val & ~phcd, iotg->base + CI_HOSTPC1 + 2);
+
+        dev_dbg(lnw->dev, "%s <--- done\n", __func__);
+}
+
+/* After drv vbus, add 5 ms delay to set PHCD */
+static void langwell_otg_phy_low_power_wait(int on)
+{
+        struct langwell_otg     *lnw = the_transceiver;
+
+        dev_dbg(lnw->dev, "add 5ms delay before programing PHCD\n");
+
+        mdelay(5);
+        langwell_otg_phy_low_power(on);
+}
+
+/* Enable/Disable OTG interrupt */
+static void langwell_otg_intr(int on)
+{
+        struct langwell_otg             *lnw = the_transceiver;
+        struct intel_mid_otg_xceiv      *iotg = &lnw->iotg;
+        u32                             val;
+
+        dev_dbg(lnw->dev, "%s ---> %s\n", __func__, on ? "on" : "off");
+
+        val = readl(iotg->base + CI_OTGSC);
+
+        /* OTGSC_INT_MASK doesn't contains 1msInt */
+        if (on) {
+                val = val | (OTGSC_INT_MASK);
+                writel(val, iotg->base + CI_OTGSC);
+        } else {
+                val = val & ~(OTGSC_INT_MASK);
+                writel(val, iotg->base + CI_OTGSC);
+        }
+
+        dev_dbg(lnw->dev, "%s <---\n", __func__);
+}
+
+/* set HAAR: Hardware Assist Auto-Reset */
+static void langwell_otg_HAAR(int on)
+{
+        struct langwell_otg             *lnw = the_transceiver;
+        struct intel_mid_otg_xceiv      *iotg = &lnw->iotg;
+        u32                             val;
+
+        dev_dbg(lnw->dev, "%s ---> %s\n", __func__, on ? "on" : "off");
+
+        val = readl(iotg->base + CI_OTGSC);
+        if (on)
+                writel((val & ~OTGSC_INTSTS_MASK) | OTGSC_HAAR,
+                                        iotg->base + CI_OTGSC);
+        else
+                writel((val & ~OTGSC_INTSTS_MASK) & ~OTGSC_HAAR,
+                                        iotg->base + CI_OTGSC);
+
+        dev_dbg(lnw->dev, "%s <---\n", __func__);
+}
+
+/* set HABA: Hardware Assist B-Disconnect to A-Connect */
+static void langwell_otg_HABA(int on)
+{
+        struct langwell_otg             *lnw = the_transceiver;
+        struct intel_mid_otg_xceiv      *iotg = &lnw->iotg;
+        u32                             val;
+
+        dev_dbg(lnw->dev, "%s ---> %s\n", __func__, on ? "on" : "off");
+
+        val = readl(iotg->base + CI_OTGSC);
+        if (on)
+                writel((val & ~OTGSC_INTSTS_MASK) | OTGSC_HABA,
+                                        iotg->base + CI_OTGSC);
+        else
+                writel((val & ~OTGSC_INTSTS_MASK) & ~OTGSC_HABA,
+                                        iotg->base + CI_OTGSC);
+
+        dev_dbg(lnw->dev, "%s <---\n", __func__);
+}
+
+static int langwell_otg_check_se0_srp(int on)
+{
+        struct langwell_otg     *lnw = the_transceiver;
+        int                     delay_time = TB_SE0_SRP * 10;
+        u32                     val;
+
+        dev_dbg(lnw->dev, "%s --->\n", __func__);
+
+        do {
+                udelay(100);
+                if (!delay_time--)
+                        break;
+                val = readl(lnw->iotg.base + CI_PORTSC1);
+                val &= PORTSC_LS;
+        } while (!val);
+
+        dev_dbg(lnw->dev, "%s <---\n", __func__);
+        return val;
+}
+
+/* The timeout callback function to set time out bit */
+static void set_tmout(unsigned long indicator)
+{
+        *(int *)indicator = 1;
+}
+
+void langwell_otg_nsf_msg(unsigned long indicator)
+{
+        struct langwell_otg     *lnw = the_transceiver;
+
+        switch (indicator) {
+        case 2:
+        case 4:
+        case 6:
+        case 7:
+                dev_warn(lnw->dev,
+                        "OTG:NSF-%lu - deivce not responding\n", indicator);
+                break;
+        case 3:
+                dev_warn(lnw->dev,
+                        "OTG:NSF-%lu - deivce not supported\n", indicator);
+                break;
+        default:
+                dev_warn(lnw->dev, "Do not have this kind of NSF\n");
+                break;
+        }
+}
+
+/* Initialize timers */
+static int langwell_otg_init_timers(struct otg_hsm *hsm)
+{
+        /* HSM used timers */
+        a_wait_vrise_tmr = otg_timer_initializer(&set_tmout, TA_WAIT_VRISE,
+                                (unsigned long)&hsm->a_wait_vrise_tmout);
+        if (a_wait_vrise_tmr == NULL)
+                return -ENOMEM;
+        a_aidl_bdis_tmr = otg_timer_initializer(&set_tmout, TA_AIDL_BDIS,
+                                (unsigned long)&hsm->a_aidl_bdis_tmout);
+        if (a_aidl_bdis_tmr == NULL)
+                return -ENOMEM;
+        b_se0_srp_tmr = otg_timer_initializer(&set_tmout, TB_SE0_SRP,
+                                (unsigned long)&hsm->b_se0_srp);
+        if (b_se0_srp_tmr == NULL)
+                return -ENOMEM;
+        b_srp_init_tmr = otg_timer_initializer(&set_tmout, TB_SRP_INIT,
+                                (unsigned long)&hsm->b_srp_init_tmout);
+        if (b_srp_init_tmr == NULL)
+                return -ENOMEM;
+
+        return 0;
+}
+
+/* Free timers */
+static void langwell_otg_free_timers(void)
+{
+        kfree(a_wait_vrise_tmr);
+        kfree(a_aidl_bdis_tmr);
+        kfree(b_se0_srp_tmr);
+        kfree(b_srp_init_tmr);
+}
+
+/* The timeout callback function to set time out bit */
+static void langwell_otg_timer_fn(unsigned long indicator)
+{
+        struct langwell_otg *lnw = the_transceiver;
+
+        *(int *)indicator = 1;
+
+        dev_dbg(lnw->dev, "kernel timer - timeout\n");
+
+        langwell_update_transceiver();
+}
+
+/* kernel timer used instead of HW based interrupt */
+static void langwell_otg_add_ktimer(enum langwell_otg_timer_type timers)
+{
+        struct langwell_otg             *lnw = the_transceiver;
+        struct intel_mid_otg_xceiv      *iotg = &lnw->iotg;
+        unsigned long           j = jiffies;
+        unsigned long           data, time;
+
+        switch (timers) {
+        case TA_WAIT_VRISE_TMR:
+                iotg->hsm.a_wait_vrise_tmout = 0;
+                data = (unsigned long)&iotg->hsm.a_wait_vrise_tmout;
+                time = TA_WAIT_VRISE;
+                break;
+        case TA_WAIT_BCON_TMR:
+                iotg->hsm.a_wait_bcon_tmout = 0;
+                data = (unsigned long)&iotg->hsm.a_wait_bcon_tmout;
+                time = TA_WAIT_BCON;
+                break;
+        case TA_AIDL_BDIS_TMR:
+                iotg->hsm.a_aidl_bdis_tmout = 0;
+                data = (unsigned long)&iotg->hsm.a_aidl_bdis_tmout;
+                time = TA_AIDL_BDIS;
+                break;
+        case TB_ASE0_BRST_TMR:
+                iotg->hsm.b_ase0_brst_tmout = 0;
+                data = (unsigned long)&iotg->hsm.b_ase0_brst_tmout;
+                time = TB_ASE0_BRST;
+                break;
+        case TB_SRP_INIT_TMR:
+                iotg->hsm.b_srp_init_tmout = 0;
+                data = (unsigned long)&iotg->hsm.b_srp_init_tmout;
+                time = TB_SRP_INIT;
+                break;
+        case TB_SRP_FAIL_TMR:
+                iotg->hsm.b_srp_fail_tmout = 0;
+                data = (unsigned long)&iotg->hsm.b_srp_fail_tmout;
+                time = TB_SRP_FAIL;
+                break;
+        case TB_BUS_SUSPEND_TMR:
+                iotg->hsm.b_bus_suspend_tmout = 0;
+                data = (unsigned long)&iotg->hsm.b_bus_suspend_tmout;
+                time = TB_BUS_SUSPEND;
+                break;
+        default:
+                dev_dbg(lnw->dev, "unknown timer, cannot enable it\n");
+                return;
+        }
+
+        lnw->hsm_timer.data = data;
+        lnw->hsm_timer.function = langwell_otg_timer_fn;
+        lnw->hsm_timer.expires = j + time * HZ / 1000; /* milliseconds */
+
+        add_timer(&lnw->hsm_timer);
+
+        dev_dbg(lnw->dev, "add timer successfully\n");
+}
+
+/* Add timer to timer list */
+static void langwell_otg_add_timer(void *gtimer)
+{
+        struct langwell_otg_timer *timer = (struct langwell_otg_timer *)gtimer;
+        struct langwell_otg_timer *tmp_timer;
+        struct intel_mid_otg_xceiv *iotg = &the_transceiver->iotg;
+        u32     val32;
+
+        /* Check if the timer is already in the active list,
+         * if so update timer count
+         */
+        list_for_each_entry(tmp_timer, &active_timers, list)
+                if (tmp_timer == timer) {
+                        timer->count = timer->expires;
+                        return;
+                }
+        timer->count = timer->expires;
+
+        if (list_empty(&active_timers)) {
+                val32 = readl(iotg->base + CI_OTGSC);
+                writel(val32 | OTGSC_1MSE, iotg->base + CI_OTGSC);
+        }
+
+        list_add_tail(&timer->list, &active_timers);
+}
+
+/* Remove timer from the timer list; clear timeout status */
+static void langwell_otg_del_timer(void *gtimer)
+{
+        struct langwell_otg *lnw = the_transceiver;
+        struct langwell_otg_timer *timer = (struct langwell_otg_timer *)gtimer;
+        struct langwell_otg_timer *tmp_timer, *del_tmp;
+        u32 val32;
+
+        list_for_each_entry_safe(tmp_timer, del_tmp, &active_timers, list)
+                if (tmp_timer == timer)
+                        list_del(&timer->list);
+
+        if (list_empty(&active_timers)) {
+                val32 = readl(lnw->iotg.base + CI_OTGSC);
+                writel(val32 & ~OTGSC_1MSE, lnw->iotg.base + CI_OTGSC);
+        }
+}
+
+/* Reduce timer count by 1, and find timeout conditions.*/
+static int langwell_otg_tick_timer(u32 *int_sts)
+{
+        struct langwell_otg     *lnw = the_transceiver;
+        struct langwell_otg_timer *tmp_timer, *del_tmp;
+        int expired = 0;
+
+        list_for_each_entry_safe(tmp_timer, del_tmp, &active_timers, list) {
+                tmp_timer->count--;
+                /* check if timer expires */
+                if (!tmp_timer->count) {
+                        list_del(&tmp_timer->list);
+                        tmp_timer->function(tmp_timer->data);
+                        expired = 1;
+                }
+        }
+
+        if (list_empty(&active_timers)) {
+                dev_dbg(lnw->dev, "tick timer: disable 1ms int\n");
+                *int_sts = *int_sts & ~OTGSC_1MSE;
+        }
+        return expired;
+}
+
+static void reset_otg(void)
+{
+        struct langwell_otg     *lnw = the_transceiver;
+        int                     delay_time = 1000;
+        u32                     val;
+
+        dev_dbg(lnw->dev, "reseting OTG controller ...\n");
+        val = readl(lnw->iotg.base + CI_USBCMD);
+        writel(val | USBCMD_RST, lnw->iotg.base + CI_USBCMD);
+        do {
+                udelay(100);
+                if (!delay_time--)
+                        dev_dbg(lnw->dev, "reset timeout\n");
+                val = readl(lnw->iotg.base + CI_USBCMD);
+                val &= USBCMD_RST;
+        } while (val != 0);
+        dev_dbg(lnw->dev, "reset done.\n");
+}
+
+static void set_host_mode(void)
+{
+        struct langwell_otg     *lnw = the_transceiver;
+        u32                     val;
+
+        reset_otg();
+        val = readl(lnw->iotg.base + CI_USBMODE);
+        val = (val & (~USBMODE_CM)) | USBMODE_HOST;
+        writel(val, lnw->iotg.base + CI_USBMODE);
+}
+
+static void set_client_mode(void)
+{
+        struct langwell_otg     *lnw = the_transceiver;
+        u32                     val;
+
+        reset_otg();
+        val = readl(lnw->iotg.base + CI_USBMODE);
+        val = (val & (~USBMODE_CM)) | USBMODE_DEVICE;
+        writel(val, lnw->iotg.base + CI_USBMODE);
+}
+
+static void init_hsm(void)
+{
+        struct langwell_otg             *lnw = the_transceiver;
+        struct intel_mid_otg_xceiv      *iotg = &lnw->iotg;
+        u32                             val32;
+
+        /* read OTGSC after reset */
+        val32 = readl(lnw->iotg.base + CI_OTGSC);
+        dev_dbg(lnw->dev, "%s: OTGSC init value = 0x%x\n", __func__, val32);
+
+        /* set init state */
+        if (val32 & OTGSC_ID) {
+                iotg->hsm.id = 1;
+                iotg->otg.default_a = 0;
+                set_client_mode();
+                iotg->otg.state = OTG_STATE_B_IDLE;
+        } else {
+                iotg->hsm.id = 0;
+                iotg->otg.default_a = 1;
+                set_host_mode();
+                iotg->otg.state = OTG_STATE_A_IDLE;
+        }
+
+        /* set session indicator */
+        if (val32 & OTGSC_BSE)
+                iotg->hsm.b_sess_end = 1;
+        if (val32 & OTGSC_BSV)
+                iotg->hsm.b_sess_vld = 1;
+        if (val32 & OTGSC_ASV)
+                iotg->hsm.a_sess_vld = 1;
+        if (val32 & OTGSC_AVV)
+                iotg->hsm.a_vbus_vld = 1;
+
+        /* defautly power the bus */
+        iotg->hsm.a_bus_req = 1;
+        iotg->hsm.a_bus_drop = 0;
+        /* defautly don't request bus as B device */
+        iotg->hsm.b_bus_req = 0;
+        /* no system error */
+        iotg->hsm.a_clr_err = 0;
+
+        langwell_otg_phy_low_power_wait(1);
+}
+
+static void update_hsm(void)
+{
+        struct langwell_otg             *lnw = the_transceiver;
+        struct intel_mid_otg_xceiv      *iotg = &lnw->iotg;
+        u32                             val32;
+
+        /* read OTGSC */
+        val32 = readl(lnw->iotg.base + CI_OTGSC);
+        dev_dbg(lnw->dev, "%s: OTGSC value = 0x%x\n", __func__, val32);
+
+        iotg->hsm.id = !!(val32 & OTGSC_ID);
+        iotg->hsm.b_sess_end = !!(val32 & OTGSC_BSE);
+        iotg->hsm.b_sess_vld = !!(val32 & OTGSC_BSV);
+        iotg->hsm.a_sess_vld = !!(val32 & OTGSC_ASV);
+        iotg->hsm.a_vbus_vld = !!(val32 & OTGSC_AVV);
+}
+
+static irqreturn_t otg_dummy_irq(int irq, void *_dev)
+{
+        struct langwell_otg     *lnw = the_transceiver;
+        void __iomem            *reg_base = _dev;
+        u32                     val;
+        u32                     int_mask = 0;
+
+        val = readl(reg_base + CI_USBMODE);
+        if ((val & USBMODE_CM) != USBMODE_DEVICE)
+                return IRQ_NONE;
+
+        val = readl(reg_base + CI_USBSTS);
+        int_mask = val & INTR_DUMMY_MASK;
+
+        if (int_mask == 0)
+                return IRQ_NONE;
+
+        /* clear hsm.b_conn here since host driver can't detect it
+        *  otg_dummy_irq called means B-disconnect happened.
+        */
+        if (lnw->iotg.hsm.b_conn) {
+                lnw->iotg.hsm.b_conn = 0;
+                if (spin_trylock(&lnw->wq_lock)) {
+                        langwell_update_transceiver();
+                        spin_unlock(&lnw->wq_lock);
+                }
+        }
+
+        /* Clear interrupts */
+        writel(int_mask, reg_base + CI_USBSTS);
+        return IRQ_HANDLED;
+}
+
+static irqreturn_t otg_irq(int irq, void *_dev)
+{
+        struct langwell_otg             *lnw = _dev;
+        struct intel_mid_otg_xceiv      *iotg = &lnw->iotg;
+        u32                             int_sts, int_en;
+        u32                             int_mask = 0;
+        int                             flag = 0;
+
+        int_sts = readl(lnw->iotg.base + CI_OTGSC);
+        int_en = (int_sts & OTGSC_INTEN_MASK) >> 8;
+        int_mask = int_sts & int_en;
+        if (int_mask == 0)
+                return IRQ_NONE;
+
+        if (int_mask & OTGSC_IDIS) {
+                dev_dbg(lnw->dev, "%s: id change int\n", __func__);
+                iotg->hsm.id = (int_sts & OTGSC_ID) ? 1 : 0;
+                dev_dbg(lnw->dev, "id = %d\n", iotg->hsm.id);
+                flag = 1;
+        }
+        if (int_mask & OTGSC_DPIS) {
+                dev_dbg(lnw->dev, "%s: data pulse int\n", __func__);
+                iotg->hsm.a_srp_det = (int_sts & OTGSC_DPS) ? 1 : 0;
+                dev_dbg(lnw->dev, "data pulse = %d\n", iotg->hsm.a_srp_det);
+                flag = 1;
+        }
+        if (int_mask & OTGSC_BSEIS) {
+                dev_dbg(lnw->dev, "%s: b session end int\n", __func__);
+                iotg->hsm.b_sess_end = (int_sts & OTGSC_BSE) ? 1 : 0;
+                dev_dbg(lnw->dev, "b_sess_end = %d\n", iotg->hsm.b_sess_end);
+                flag = 1;
+        }
+        if (int_mask & OTGSC_BSVIS) {
+                dev_dbg(lnw->dev, "%s: b session valid int\n", __func__);
+                iotg->hsm.b_sess_vld = (int_sts & OTGSC_BSV) ? 1 : 0;
+                dev_dbg(lnw->dev, "b_sess_vld = %d\n", iotg->hsm.b_sess_end);
+                flag = 1;
+        }
+        if (int_mask & OTGSC_ASVIS) {
+                dev_dbg(lnw->dev, "%s: a session valid int\n", __func__);
+                iotg->hsm.a_sess_vld = (int_sts & OTGSC_ASV) ? 1 : 0;
+                dev_dbg(lnw->dev, "a_sess_vld = %d\n", iotg->hsm.a_sess_vld);
+                flag = 1;
+        }
+        if (int_mask & OTGSC_AVVIS) {
+                dev_dbg(lnw->dev, "%s: a vbus valid int\n", __func__);
+                iotg->hsm.a_vbus_vld = (int_sts & OTGSC_AVV) ? 1 : 0;
+                dev_dbg(lnw->dev, "a_vbus_vld = %d\n", iotg->hsm.a_vbus_vld);
+                flag = 1;
+        }
+
+        if (int_mask & OTGSC_1MSS) {
+                /* need to schedule otg_work if any timer is expired */
+                if (langwell_otg_tick_timer(&int_sts))
+                        flag = 1;
+        }
+
+        writel((int_sts & ~OTGSC_INTSTS_MASK) | int_mask,
+                                        lnw->iotg.base + CI_OTGSC);
+        if (flag)
+                langwell_update_transceiver();
+
+        return IRQ_HANDLED;
+}
+
+static int langwell_otg_iotg_notify(struct notifier_block *nb,
+                                unsigned long action, void *data)
+{
+        struct langwell_otg             *lnw = the_transceiver;
+        struct intel_mid_otg_xceiv      *iotg = data;
+        int                             flag = 0;
+
+        if (iotg == NULL)
+                return NOTIFY_BAD;
+
+        if (lnw == NULL)
+                return NOTIFY_BAD;
+
+        switch (action) {
+        case MID_OTG_NOTIFY_CONNECT:
+                dev_dbg(lnw->dev, "Lnw OTG Notify Connect Event\n");
+                if (iotg->otg.default_a == 1)
+                        iotg->hsm.b_conn = 1;
+                else
+                        iotg->hsm.a_conn = 1;
+                flag = 1;
+                break;
+        case MID_OTG_NOTIFY_DISCONN:
+                dev_dbg(lnw->dev, "Lnw OTG Notify Disconnect Event\n");
+                if (iotg->otg.default_a == 1)
+                        iotg->hsm.b_conn = 0;
+                else
+                        iotg->hsm.a_conn = 0;
+                flag = 1;
+                break;
+        case MID_OTG_NOTIFY_HSUSPEND:
+                dev_dbg(lnw->dev, "Lnw OTG Notify Host Bus suspend Event\n");
+                if (iotg->otg.default_a == 1)
+                        iotg->hsm.a_suspend_req = 1;
+                else
+                        iotg->hsm.b_bus_req = 0;
+                flag = 1;
+                break;
+        case MID_OTG_NOTIFY_HRESUME:
+                dev_dbg(lnw->dev, "Lnw OTG Notify Host Bus resume Event\n");
+                if (iotg->otg.default_a == 1)
+                        iotg->hsm.b_bus_resume = 1;
+                flag = 1;
+                break;
+        case MID_OTG_NOTIFY_CSUSPEND:
+                dev_dbg(lnw->dev, "Lnw OTG Notify Client Bus suspend Event\n");
+                if (iotg->otg.default_a == 1) {
+                        if (iotg->hsm.b_bus_suspend_vld == 2) {
+                                iotg->hsm.b_bus_suspend = 1;
+                                iotg->hsm.b_bus_suspend_vld = 0;
+                                flag = 1;
+                        } else {
+                                iotg->hsm.b_bus_suspend_vld++;
+                                flag = 0;
+                        }
+                } else {
+                        if (iotg->hsm.a_bus_suspend == 0) {
+                                iotg->hsm.a_bus_suspend = 1;
+                                flag = 1;
+                        }
+                }
+                break;
+        case MID_OTG_NOTIFY_CRESUME:
+                dev_dbg(lnw->dev, "Lnw OTG Notify Client Bus resume Event\n");
+                if (iotg->otg.default_a == 0)
+                        iotg->hsm.a_bus_suspend = 0;
+                flag = 0;
+                break;
+        case MID_OTG_NOTIFY_HOSTADD:
+                dev_dbg(lnw->dev, "Lnw OTG Nofity Host Driver Add\n");
+                flag = 1;
+                break;
+        case MID_OTG_NOTIFY_HOSTREMOVE:
+                dev_dbg(lnw->dev, "Lnw OTG Nofity Host Driver remove\n");
+                flag = 1;
+                break;
+        case MID_OTG_NOTIFY_CLIENTADD:
+                dev_dbg(lnw->dev, "Lnw OTG Nofity Client Driver Add\n");
+                flag = 1;
+                break;
+        case MID_OTG_NOTIFY_CLIENTREMOVE:
+                dev_dbg(lnw->dev, "Lnw OTG Nofity Client Driver remove\n");
+                flag = 1;
+                break;
+        default:
+                dev_dbg(lnw->dev, "Lnw OTG Nofity unknown notify message\n");
+                return NOTIFY_DONE;
+        }
+
+        if (flag)
+                langwell_update_transceiver();
+
+        return NOTIFY_OK;
+}
+
+static void langwell_otg_work(struct work_struct *work)
+{
+        struct langwell_otg             *lnw;
+        struct intel_mid_otg_xceiv      *iotg;
+        int                             retval;
+        struct pci_dev                  *pdev;
+
+        lnw = container_of(work, struct langwell_otg, work);
+        iotg = &lnw->iotg;
+        pdev = to_pci_dev(lnw->dev);
+
+        dev_dbg(lnw->dev, "%s: old state = %s\n", __func__,
+                        otg_state_string(iotg->otg.state));
+
+        switch (iotg->otg.state) {
+        case OTG_STATE_UNDEFINED:
+        case OTG_STATE_B_IDLE:
+                if (!iotg->hsm.id) {
+                        langwell_otg_del_timer(b_srp_init_tmr);
+                        del_timer_sync(&lnw->hsm_timer);
+
+                        iotg->otg.default_a = 1;
+                        iotg->hsm.a_srp_det = 0;
+
+                        langwell_otg_chrg_vbus(0);
+                        set_host_mode();
+                        langwell_otg_phy_low_power(1);
+
+                        iotg->otg.state = OTG_STATE_A_IDLE;
+                        langwell_update_transceiver();
+                } else if (iotg->hsm.b_sess_vld) {
+                        langwell_otg_del_timer(b_srp_init_tmr);
+                        del_timer_sync(&lnw->hsm_timer);
+                        iotg->hsm.b_sess_end = 0;
+                        iotg->hsm.a_bus_suspend = 0;
+                        langwell_otg_chrg_vbus(0);
+
+                        if (lnw->iotg.start_peripheral) {
+                                lnw->iotg.start_peripheral(&lnw->iotg);
+                                iotg->otg.state = OTG_STATE_B_PERIPHERAL;
+                        } else
+                                dev_dbg(lnw->dev, "client driver not loaded\n");
+
+                } else if (iotg->hsm.b_srp_init_tmout) {
+                        iotg->hsm.b_srp_init_tmout = 0;
+                        dev_warn(lnw->dev, "SRP init timeout\n");
+                } else if (iotg->hsm.b_srp_fail_tmout) {
+                        iotg->hsm.b_srp_fail_tmout = 0;
+                        iotg->hsm.b_bus_req = 0;
+
+                        /* No silence failure */
+                        langwell_otg_nsf_msg(6);
+                } else if (iotg->hsm.b_bus_req && iotg->hsm.b_sess_end) {
+                        del_timer_sync(&lnw->hsm_timer);
+                        /* workaround for b_se0_srp detection */
+                        retval = langwell_otg_check_se0_srp(0);
+                        if (retval) {
+                                iotg->hsm.b_bus_req = 0;
+                                dev_dbg(lnw->dev, "LS isn't SE0, try later\n");
+                        } else {
+                                /* clear the PHCD before start srp */
+                                langwell_otg_phy_low_power(0);
+
+                                /* Start SRP */
+                                langwell_otg_add_timer(b_srp_init_tmr);
+                                iotg->otg.start_srp(&iotg->otg);
+                                langwell_otg_del_timer(b_srp_init_tmr);
+                                langwell_otg_add_ktimer(TB_SRP_FAIL_TMR);
+
+                                /* reset PHY low power mode here */
+                                langwell_otg_phy_low_power_wait(1);
+                        }
+                }
+                break;
+        case OTG_STATE_B_SRP_INIT:
+                if (!iotg->hsm.id) {
+                        iotg->otg.default_a = 1;
+                        iotg->hsm.a_srp_det = 0;
+
+                        /* Turn off VBus */
+                        iotg->otg.set_vbus(&iotg->otg, false);
+                        langwell_otg_chrg_vbus(0);
+                        set_host_mode();
+                        langwell_otg_phy_low_power(1);
+                        iotg->otg.state = OTG_STATE_A_IDLE;
+                        langwell_update_transceiver();
+                } else if (iotg->hsm.b_sess_vld) {
+                        langwell_otg_chrg_vbus(0);
+                        if (lnw->iotg.start_peripheral) {
+                                lnw->iotg.start_peripheral(&lnw->iotg);
+                                iotg->otg.state = OTG_STATE_B_PERIPHERAL;
+                        } else
+                                dev_dbg(lnw->dev, "client driver not loaded\n");
+                }
+                break;
+        case OTG_STATE_B_PERIPHERAL:
+                if (!iotg->hsm.id) {
+                        iotg->otg.default_a = 1;
+                        iotg->hsm.a_srp_det = 0;
+
+                        langwell_otg_chrg_vbus(0);
+
+                        if (lnw->iotg.stop_peripheral)
+                                lnw->iotg.stop_peripheral(&lnw->iotg);
+                        else
+                                dev_dbg(lnw->dev,
+                                        "client driver has been removed.\n");
+
+                        set_host_mode();
+                        langwell_otg_phy_low_power(1);
+                        iotg->otg.state = OTG_STATE_A_IDLE;
+                        langwell_update_transceiver();
+                } else if (!iotg->hsm.b_sess_vld) {
+                        iotg->hsm.b_hnp_enable = 0;
+
+                        if (lnw->iotg.stop_peripheral)
+                                lnw->iotg.stop_peripheral(&lnw->iotg);
+                        else
+                                dev_dbg(lnw->dev,
+                                        "client driver has been removed.\n");
+
+                        iotg->otg.state = OTG_STATE_B_IDLE;
+                } else if (iotg->hsm.b_bus_req && iotg->otg.gadget &&
+                                        iotg->otg.gadget->b_hnp_enable &&
+                                        iotg->hsm.a_bus_suspend) {
+
+                        if (lnw->iotg.stop_peripheral)
+                                lnw->iotg.stop_peripheral(&lnw->iotg);
+                        else
+                                dev_dbg(lnw->dev,
+                                        "client driver has been removed.\n");
+
+                        langwell_otg_HAAR(1);
+                        iotg->hsm.a_conn = 0;
+
+                        if (lnw->iotg.start_host) {
+                                lnw->iotg.start_host(&lnw->iotg);
+                                iotg->otg.state = OTG_STATE_B_WAIT_ACON;
+                        } else
+                                dev_dbg(lnw->dev,
+                                                "host driver not loaded.\n");
+
+                        iotg->hsm.a_bus_resume = 0;
+                        langwell_otg_add_ktimer(TB_ASE0_BRST_TMR);
+                }
+                break;
+
+        case OTG_STATE_B_WAIT_ACON:
+                if (!iotg->hsm.id) {
+                        /* delete hsm timer for b_ase0_brst_tmr */
+                        del_timer_sync(&lnw->hsm_timer);
+
+                        iotg->otg.default_a = 1;
+                        iotg->hsm.a_srp_det = 0;
+
+                        langwell_otg_chrg_vbus(0);
+
+                        langwell_otg_HAAR(0);
+                        if (lnw->iotg.stop_host)
+                                lnw->iotg.stop_host(&lnw->iotg);
+                        else
+                                dev_dbg(lnw->dev,
+                                        "host driver has been removed.\n");
+
+                        set_host_mode();
+                        langwell_otg_phy_low_power(1);
+                        iotg->otg.state = OTG_STATE_A_IDLE;
+                        langwell_update_transceiver();
+                } else if (!iotg->hsm.b_sess_vld) {
+                        /* delete hsm timer for b_ase0_brst_tmr */
+                        del_timer_sync(&lnw->hsm_timer);
+
+                        iotg->hsm.b_hnp_enable = 0;
+                        iotg->hsm.b_bus_req = 0;
+
+                        langwell_otg_chrg_vbus(0);
+                        langwell_otg_HAAR(0);
+
+                        if (lnw->iotg.stop_host)
+                                lnw->iotg.stop_host(&lnw->iotg);
+                        else
+                                dev_dbg(lnw->dev,
+                                        "host driver has been removed.\n");
+
+                        set_client_mode();
+                        langwell_otg_phy_low_power(1);
+                        iotg->otg.state = OTG_STATE_B_IDLE;
+                } else if (iotg->hsm.a_conn) {
+                        /* delete hsm timer for b_ase0_brst_tmr */
+                        del_timer_sync(&lnw->hsm_timer);
+
+                        langwell_otg_HAAR(0);
+                        iotg->otg.state = OTG_STATE_B_HOST;
+                        langwell_update_transceiver();
+                } else if (iotg->hsm.a_bus_resume ||
+                                iotg->hsm.b_ase0_brst_tmout) {
+                        /* delete hsm timer for b_ase0_brst_tmr */
+                        del_timer_sync(&lnw->hsm_timer);
+
+                        langwell_otg_HAAR(0);
+                        langwell_otg_nsf_msg(7);
+
+                        if (lnw->iotg.stop_host)
+                                lnw->iotg.stop_host(&lnw->iotg);
+                        else
+                                dev_dbg(lnw->dev,
+                                        "host driver has been removed.\n");
+
+                        iotg->hsm.a_bus_suspend = 0;
+                        iotg->hsm.b_bus_req = 0;
+
+                        if (lnw->iotg.start_peripheral)
+                                lnw->iotg.start_peripheral(&lnw->iotg);
+                        else
+                                dev_dbg(lnw->dev,
+                                        "client driver not loaded.\n");
+
+                        iotg->otg.state = OTG_STATE_B_PERIPHERAL;
+                }
+                break;
+
+        case OTG_STATE_B_HOST:
+                if (!iotg->hsm.id) {
+                        iotg->otg.default_a = 1;
+                        iotg->hsm.a_srp_det = 0;
+
+                        langwell_otg_chrg_vbus(0);
+
+                        if (lnw->iotg.stop_host)
+                                lnw->iotg.stop_host(&lnw->iotg);
+                        else
+                                dev_dbg(lnw->dev,
+                                        "host driver has been removed.\n");
+
+                        set_host_mode();
+                        langwell_otg_phy_low_power(1);
+                        iotg->otg.state = OTG_STATE_A_IDLE;
+                        langwell_update_transceiver();
+                } else if (!iotg->hsm.b_sess_vld) {
+                        iotg->hsm.b_hnp_enable = 0;
+                        iotg->hsm.b_bus_req = 0;
+
+                        langwell_otg_chrg_vbus(0);
+                        if (lnw->iotg.stop_host)
+                                lnw->iotg.stop_host(&lnw->iotg);
+                        else
+                                dev_dbg(lnw->dev,
+                                        "host driver has been removed.\n");
+
+                        set_client_mode();
+                        langwell_otg_phy_low_power(1);
+                        iotg->otg.state = OTG_STATE_B_IDLE;
+                } else if ((!iotg->hsm.b_bus_req) ||
+                                (!iotg->hsm.a_conn)) {
+                        iotg->hsm.b_bus_req = 0;
+                        langwell_otg_loc_sof(0);
+
+                        if (lnw->iotg.stop_host)
+                                lnw->iotg.stop_host(&lnw->iotg);
+                        else
+                                dev_dbg(lnw->dev,
+                                        "host driver has been removed.\n");
+
+                        iotg->hsm.a_bus_suspend = 0;
+
+                        if (lnw->iotg.start_peripheral)
+                                lnw->iotg.start_peripheral(&lnw->iotg);
+                        else
+                                dev_dbg(lnw->dev,
+                                                "client driver not loaded.\n");
+
+                        iotg->otg.state = OTG_STATE_B_PERIPHERAL;
+                }
+                break;
+
+        case OTG_STATE_A_IDLE:
+                iotg->otg.default_a = 1;
+                if (iotg->hsm.id) {
+                        iotg->otg.default_a = 0;
+                        iotg->hsm.b_bus_req = 0;
+                        iotg->hsm.vbus_srp_up = 0;
+
+                        langwell_otg_chrg_vbus(0);
+                        set_client_mode();
+                        langwell_otg_phy_low_power(1);
+                        iotg->otg.state = OTG_STATE_B_IDLE;
+                        langwell_update_transceiver();
+                } else if (!iotg->hsm.a_bus_drop &&
+                        (iotg->hsm.a_srp_det || iotg->hsm.a_bus_req)) {
+                        langwell_otg_phy_low_power(0);
+
+                        /* Turn on VBus */
+                        iotg->otg.set_vbus(&iotg->otg, true);
+
+                        iotg->hsm.vbus_srp_up = 0;
+                        iotg->hsm.a_wait_vrise_tmout = 0;
+                        langwell_otg_add_timer(a_wait_vrise_tmr);
+                        iotg->otg.state = OTG_STATE_A_WAIT_VRISE;
+                        langwell_update_transceiver();
+                } else if (!iotg->hsm.a_bus_drop && iotg->hsm.a_sess_vld) {
+                        iotg->hsm.vbus_srp_up = 1;
+                } else if (!iotg->hsm.a_sess_vld && iotg->hsm.vbus_srp_up) {
+                        msleep(10);
+                        langwell_otg_phy_low_power(0);
+
+                        /* Turn on VBus */
+                        iotg->otg.set_vbus(&iotg->otg, true);
+                        iotg->hsm.a_srp_det = 1;
+                        iotg->hsm.vbus_srp_up = 0;
+                        iotg->hsm.a_wait_vrise_tmout = 0;
+                        langwell_otg_add_timer(a_wait_vrise_tmr);
+                        iotg->otg.state = OTG_STATE_A_WAIT_VRISE;
+                        langwell_update_transceiver();
+                } else if (!iotg->hsm.a_sess_vld &&
+                                !iotg->hsm.vbus_srp_up) {
+                        langwell_otg_phy_low_power(1);
+                }
+                break;
+        case OTG_STATE_A_WAIT_VRISE:
+                if (iotg->hsm.id) {
+                        langwell_otg_del_timer(a_wait_vrise_tmr);
+                        iotg->hsm.b_bus_req = 0;
+                        iotg->otg.default_a = 0;
+
+                        /* Turn off VBus */
+                        iotg->otg.set_vbus(&iotg->otg, false);
+                        set_client_mode();
+                        langwell_otg_phy_low_power_wait(1);
+                        iotg->otg.state = OTG_STATE_B_IDLE;
+                } else if (iotg->hsm.a_vbus_vld) {
+                        langwell_otg_del_timer(a_wait_vrise_tmr);
+                        iotg->hsm.b_conn = 0;
+                        if (lnw->iotg.start_host)
+                                lnw->iotg.start_host(&lnw->iotg);
+                        else {
+                                dev_dbg(lnw->dev, "host driver not loaded.\n");
+                                break;
+                        }
+
+                        langwell_otg_add_ktimer(TA_WAIT_BCON_TMR);
+                        iotg->otg.state = OTG_STATE_A_WAIT_BCON;
+                } else if (iotg->hsm.a_wait_vrise_tmout) {
+                        iotg->hsm.b_conn = 0;
+                        if (iotg->hsm.a_vbus_vld) {
+                                if (lnw->iotg.start_host)
+                                        lnw->iotg.start_host(&lnw->iotg);
+                                else {
+                                        dev_dbg(lnw->dev,
+                                                "host driver not loaded.\n");
+                                        break;
+                                }
+                                langwell_otg_add_ktimer(TA_WAIT_BCON_TMR);
+                                iotg->otg.state = OTG_STATE_A_WAIT_BCON;
+                        } else {
+
+                                /* Turn off VBus */
+                                iotg->otg.set_vbus(&iotg->otg, false);
+                                langwell_otg_phy_low_power_wait(1);
+                                iotg->otg.state = OTG_STATE_A_VBUS_ERR;
+                        }
+                }
+                break;
+        case OTG_STATE_A_WAIT_BCON:
+                if (iotg->hsm.id) {
+                        /* delete hsm timer for a_wait_bcon_tmr */
+                        del_timer_sync(&lnw->hsm_timer);
+
+                        iotg->otg.default_a = 0;
+                        iotg->hsm.b_bus_req = 0;
+
+                        if (lnw->iotg.stop_host)
+                                lnw->iotg.stop_host(&lnw->iotg);
+                        else
+                                dev_dbg(lnw->dev,
+                                        "host driver has been removed.\n");
+
+                        /* Turn off VBus */
+                        iotg->otg.set_vbus(&iotg->otg, false);
+                        set_client_mode();
+                        langwell_otg_phy_low_power_wait(1);
+                        iotg->otg.state = OTG_STATE_B_IDLE;
+                        langwell_update_transceiver();
+                } else if (!iotg->hsm.a_vbus_vld) {
+                        /* delete hsm timer for a_wait_bcon_tmr */
+                        del_timer_sync(&lnw->hsm_timer);
+
+                        if (lnw->iotg.stop_host)
+                                lnw->iotg.stop_host(&lnw->iotg);
+                        else
+                                dev_dbg(lnw->dev,
+                                        "host driver has been removed.\n");
+
+                        /* Turn off VBus */
+                        iotg->otg.set_vbus(&iotg->otg, false);
+                        langwell_otg_phy_low_power_wait(1);
+                        iotg->otg.state = OTG_STATE_A_VBUS_ERR;
+                } else if (iotg->hsm.a_bus_drop ||
+                                (iotg->hsm.a_wait_bcon_tmout &&
+                                !iotg->hsm.a_bus_req)) {
+                        /* delete hsm timer for a_wait_bcon_tmr */
+                        del_timer_sync(&lnw->hsm_timer);
+
+                        if (lnw->iotg.stop_host)
+                                lnw->iotg.stop_host(&lnw->iotg);
+                        else
+                                dev_dbg(lnw->dev,
+                                        "host driver has been removed.\n");
+
+                        /* Turn off VBus */
+                        iotg->otg.set_vbus(&iotg->otg, false);
+                        iotg->otg.state = OTG_STATE_A_WAIT_VFALL;
+                } else if (iotg->hsm.b_conn) {
+                        /* delete hsm timer for a_wait_bcon_tmr */
+                        del_timer_sync(&lnw->hsm_timer);
+
+                        iotg->hsm.a_suspend_req = 0;
+                        iotg->otg.state = OTG_STATE_A_HOST;
+                        if (iotg->hsm.a_srp_det && iotg->otg.host &&
+                                        !iotg->otg.host->b_hnp_enable) {
+                                /* SRP capable peripheral-only device */
+                                iotg->hsm.a_bus_req = 1;
+                                iotg->hsm.a_srp_det = 0;
+                        } else if (!iotg->hsm.a_bus_req && iotg->otg.host &&
+                                        iotg->otg.host->b_hnp_enable) {
+                                /* It is not safe enough to do a fast
+                                 * transition from A_WAIT_BCON to
+                                 * A_SUSPEND */
+                                msleep(10000);
+                                if (iotg->hsm.a_bus_req)
+                                        break;
+
+                                if (request_irq(pdev->irq,
+                                        otg_dummy_irq, IRQF_SHARED,
+                                        driver_name, iotg->base) != 0) {
+                                        dev_dbg(lnw->dev,
+                                                "request interrupt %d fail\n",
+                                                pdev->irq);
+                                }
+
+                                langwell_otg_HABA(1);
+                                iotg->hsm.b_bus_resume = 0;
+                                iotg->hsm.a_aidl_bdis_tmout = 0;
+
+                                langwell_otg_loc_sof(0);
+                                /* clear PHCD to enable HW timer */
+                                langwell_otg_phy_low_power(0);
+                                langwell_otg_add_timer(a_aidl_bdis_tmr);
+                                iotg->otg.state = OTG_STATE_A_SUSPEND;
+                        } else if (!iotg->hsm.a_bus_req && iotg->otg.host &&
+                                !iotg->otg.host->b_hnp_enable) {
+                                if (lnw->iotg.stop_host)
+                                        lnw->iotg.stop_host(&lnw->iotg);
+                                else
+                                        dev_dbg(lnw->dev,
+                                                "host driver removed.\n");
+
+                                /* Turn off VBus */
+                                iotg->otg.set_vbus(&iotg->otg, false);
+                                iotg->otg.state = OTG_STATE_A_WAIT_VFALL;
+                        }
+                }
+                break;
+        case OTG_STATE_A_HOST:
+                if (iotg->hsm.id) {
+                        iotg->otg.default_a = 0;
+                        iotg->hsm.b_bus_req = 0;
+
+                        if (lnw->iotg.stop_host)
+                                lnw->iotg.stop_host(&lnw->iotg);
+                        else
+                                dev_dbg(lnw->dev,
+                                        "host driver has been removed.\n");
+
+                        /* Turn off VBus */
+                        iotg->otg.set_vbus(&iotg->otg, false);
+                        set_client_mode();
+                        langwell_otg_phy_low_power_wait(1);
+                        iotg->otg.state = OTG_STATE_B_IDLE;
+                        langwell_update_transceiver();
+                } else if (iotg->hsm.a_bus_drop ||
+                                (iotg->otg.host &&
+                                !iotg->otg.host->b_hnp_enable &&
+                                        !iotg->hsm.a_bus_req)) {
+                        if (lnw->iotg.stop_host)
+                                lnw->iotg.stop_host(&lnw->iotg);
+                        else
+                                dev_dbg(lnw->dev,
+                                        "host driver has been removed.\n");
+
+                        /* Turn off VBus */
+                        iotg->otg.set_vbus(&iotg->otg, false);
+                        iotg->otg.state = OTG_STATE_A_WAIT_VFALL;
+                } else if (!iotg->hsm.a_vbus_vld) {
+                        if (lnw->iotg.stop_host)
+                                lnw->iotg.stop_host(&lnw->iotg);
+                        else
+                                dev_dbg(lnw->dev,
+                                        "host driver has been removed.\n");
+
+                        /* Turn off VBus */
+                        iotg->otg.set_vbus(&iotg->otg, false);
+                        langwell_otg_phy_low_power_wait(1);
+                        iotg->otg.state = OTG_STATE_A_VBUS_ERR;
+                } else if (iotg->otg.host &&
+                                iotg->otg.host->b_hnp_enable &&
+                                !iotg->hsm.a_bus_req) {
+                        /* Set HABA to enable hardware assistance to signal
+                         *  A-connect after receiver B-disconnect. Hardware
+                         *  will then set client mode and enable URE, SLE and
+                         *  PCE after the assistance. otg_dummy_irq is used to
+                         *  clean these ints when client driver is not resumed.
+                         */
+                        if (request_irq(pdev->irq, otg_dummy_irq, IRQF_SHARED,
+                                        driver_name, iotg->base) != 0) {
+                                dev_dbg(lnw->dev,
+                                        "request interrupt %d failed\n",
+                                                pdev->irq);
+                        }
+
+                        /* set HABA */
+                        langwell_otg_HABA(1);
+                        iotg->hsm.b_bus_resume = 0;
+                        iotg->hsm.a_aidl_bdis_tmout = 0;
+                        langwell_otg_loc_sof(0);
+                        /* clear PHCD to enable HW timer */
+                        langwell_otg_phy_low_power(0);
+                        langwell_otg_add_timer(a_aidl_bdis_tmr);
+                        iotg->otg.state = OTG_STATE_A_SUSPEND;
+                } else if (!iotg->hsm.b_conn || !iotg->hsm.a_bus_req) {
+                        langwell_otg_add_ktimer(TA_WAIT_BCON_TMR);
+                        iotg->otg.state = OTG_STATE_A_WAIT_BCON;
+                }
+                break;
+        case OTG_STATE_A_SUSPEND:
+                if (iotg->hsm.id) {
+                        langwell_otg_del_timer(a_aidl_bdis_tmr);
+                        langwell_otg_HABA(0);
+                        free_irq(pdev->irq, iotg->base);
+                        iotg->otg.default_a = 0;
+                        iotg->hsm.b_bus_req = 0;
+
+                        if (lnw->iotg.stop_host)
+                                lnw->iotg.stop_host(&lnw->iotg);
+                        else
+                                dev_dbg(lnw->dev,
+                                        "host driver has been removed.\n");
+
+                        /* Turn off VBus */
+                        iotg->otg.set_vbus(&iotg->otg, false);
+                        set_client_mode();
+                        langwell_otg_phy_low_power(1);
+                        iotg->otg.state = OTG_STATE_B_IDLE;
+                        langwell_update_transceiver();
+                } else if (iotg->hsm.a_bus_req ||
+                                iotg->hsm.b_bus_resume) {
+                        langwell_otg_del_timer(a_aidl_bdis_tmr);
+                        langwell_otg_HABA(0);
+                        free_irq(pdev->irq, iotg->base);
+                        iotg->hsm.a_suspend_req = 0;
+                        langwell_otg_loc_sof(1);
+                        iotg->otg.state = OTG_STATE_A_HOST;
+                } else if (iotg->hsm.a_aidl_bdis_tmout ||
+                                iotg->hsm.a_bus_drop) {
+                        langwell_otg_del_timer(a_aidl_bdis_tmr);
+                        langwell_otg_HABA(0);
+                        free_irq(pdev->irq, iotg->base);
+                        if (lnw->iotg.stop_host)
+                                lnw->iotg.stop_host(&lnw->iotg);
+                        else
+                                dev_dbg(lnw->dev,
+                                        "host driver has been removed.\n");
+
+                        /* Turn off VBus */
+                        iotg->otg.set_vbus(&iotg->otg, false);
+                        iotg->otg.state = OTG_STATE_A_WAIT_VFALL;
+                } else if (!iotg->hsm.b_conn && iotg->otg.host &&
+                                iotg->otg.host->b_hnp_enable) {
+                        langwell_otg_del_timer(a_aidl_bdis_tmr);
+                        langwell_otg_HABA(0);
+                        free_irq(pdev->irq, iotg->base);
+
+                        if (lnw->iotg.stop_host)
+                                lnw->iotg.stop_host(&lnw->iotg);
+                        else
+                                dev_dbg(lnw->dev,
+                                        "host driver has been removed.\n");
+
+                        iotg->hsm.b_bus_suspend = 0;
+                        iotg->hsm.b_bus_suspend_vld = 0;
+
+                        /* msleep(200); */
+                        if (lnw->iotg.start_peripheral)
+                                lnw->iotg.start_peripheral(&lnw->iotg);
+                        else
+                                dev_dbg(lnw->dev,
+                                        "client driver not loaded.\n");
+
+                        langwell_otg_add_ktimer(TB_BUS_SUSPEND_TMR);
+                        iotg->otg.state = OTG_STATE_A_PERIPHERAL;
+                        break;
+                } else if (!iotg->hsm.a_vbus_vld) {
+                        langwell_otg_del_timer(a_aidl_bdis_tmr);
+                        langwell_otg_HABA(0);
+                        free_irq(pdev->irq, iotg->base);
+                        if (lnw->iotg.stop_host)
+                                lnw->iotg.stop_host(&lnw->iotg);
+                        else
+                                dev_dbg(lnw->dev,
+                                        "host driver has been removed.\n");
+
+                        /* Turn off VBus */
+                        iotg->otg.set_vbus(&iotg->otg, false);
+                        langwell_otg_phy_low_power_wait(1);
+                        iotg->otg.state = OTG_STATE_A_VBUS_ERR;
+                }
+                break;
+        case OTG_STATE_A_PERIPHERAL:
+                if (iotg->hsm.id) {
+                        /* delete hsm timer for b_bus_suspend_tmr */
+                        del_timer_sync(&lnw->hsm_timer);
+                        iotg->otg.default_a = 0;
+                        iotg->hsm.b_bus_req = 0;
+                        if (lnw->iotg.stop_peripheral)
+                                lnw->iotg.stop_peripheral(&lnw->iotg);
+                        else
+                                dev_dbg(lnw->dev,
+                                        "client driver has been removed.\n");
+
+                        /* Turn off VBus */
+                        iotg->otg.set_vbus(&iotg->otg, false);
+                        set_client_mode();
+                        langwell_otg_phy_low_power_wait(1);
+                        iotg->otg.state = OTG_STATE_B_IDLE;
+                        langwell_update_transceiver();
+                } else if (!iotg->hsm.a_vbus_vld) {
+                        /* delete hsm timer for b_bus_suspend_tmr */
+                        del_timer_sync(&lnw->hsm_timer);
+
+                        if (lnw->iotg.stop_peripheral)
+                                lnw->iotg.stop_peripheral(&lnw->iotg);
+                        else
+                                dev_dbg(lnw->dev,
+                                        "client driver has been removed.\n");
+
+                        /* Turn off VBus */
+                        iotg->otg.set_vbus(&iotg->otg, false);
+                        langwell_otg_phy_low_power_wait(1);
+                        iotg->otg.state = OTG_STATE_A_VBUS_ERR;
+                } else if (iotg->hsm.a_bus_drop) {
+                        /* delete hsm timer for b_bus_suspend_tmr */
+                        del_timer_sync(&lnw->hsm_timer);
+
+                        if (lnw->iotg.stop_peripheral)
+                                lnw->iotg.stop_peripheral(&lnw->iotg);
+                        else
+                                dev_dbg(lnw->dev,
+                                        "client driver has been removed.\n");
+
+                        /* Turn off VBus */
+                        iotg->otg.set_vbus(&iotg->otg, false);
+                        iotg->otg.state = OTG_STATE_A_WAIT_VFALL;
+                } else if (iotg->hsm.b_bus_suspend) {
+                        /* delete hsm timer for b_bus_suspend_tmr */
+                        del_timer_sync(&lnw->hsm_timer);
+
+                        if (lnw->iotg.stop_peripheral)
+                                lnw->iotg.stop_peripheral(&lnw->iotg);
+                        else
+                                dev_dbg(lnw->dev,
+                                        "client driver has been removed.\n");
+
+                        if (lnw->iotg.start_host)
+                                lnw->iotg.start_host(&lnw->iotg);
+                        else
+                                dev_dbg(lnw->dev,
+                                                "host driver not loaded.\n");
+                        langwell_otg_add_ktimer(TA_WAIT_BCON_TMR);
+                        iotg->otg.state = OTG_STATE_A_WAIT_BCON;
+                } else if (iotg->hsm.b_bus_suspend_tmout) {
+                        u32     val;
+                        val = readl(lnw->iotg.base + CI_PORTSC1);
+                        if (!(val & PORTSC_SUSP))
+                                break;
+
+                        if (lnw->iotg.stop_peripheral)
+                                lnw->iotg.stop_peripheral(&lnw->iotg);
+                        else
+                                dev_dbg(lnw->dev,
+                                        "client driver has been removed.\n");
+
+                        if (lnw->iotg.start_host)
+                                lnw->iotg.start_host(&lnw->iotg);
+                        else
+                                dev_dbg(lnw->dev,
+                                                "host driver not loaded.\n");
+                        langwell_otg_add_ktimer(TA_WAIT_BCON_TMR);
+                        iotg->otg.state = OTG_STATE_A_WAIT_BCON;
+                }
+                break;
+        case OTG_STATE_A_VBUS_ERR:
+                if (iotg->hsm.id) {
+                        iotg->otg.default_a = 0;
+                        iotg->hsm.a_clr_err = 0;
+                        iotg->hsm.a_srp_det = 0;
+                        set_client_mode();
+                        langwell_otg_phy_low_power(1);
+                        iotg->otg.state = OTG_STATE_B_IDLE;
+                        langwell_update_transceiver();
+                } else if (iotg->hsm.a_clr_err) {
+                        iotg->hsm.a_clr_err = 0;
+                        iotg->hsm.a_srp_det = 0;
+                        reset_otg();
+                        init_hsm();
+                        if (iotg->otg.state == OTG_STATE_A_IDLE)
+                                langwell_update_transceiver();
+                } else {
+                        /* FW will clear PHCD bit when any VBus
+                         * event detected. Reset PHCD to 1 again */
+                        langwell_otg_phy_low_power(1);
+                }
+                break;
+        case OTG_STATE_A_WAIT_VFALL:
+                if (iotg->hsm.id) {
+                        iotg->otg.default_a = 0;
+                        set_client_mode();
+                        langwell_otg_phy_low_power(1);
+                        iotg->otg.state = OTG_STATE_B_IDLE;
+                        langwell_update_transceiver();
+                } else if (iotg->hsm.a_bus_req) {
+
+                        /* Turn on VBus */
+                        iotg->otg.set_vbus(&iotg->otg, true);
+                        iotg->hsm.a_wait_vrise_tmout = 0;
+                        langwell_otg_add_timer(a_wait_vrise_tmr);
+                        iotg->otg.state = OTG_STATE_A_WAIT_VRISE;
+                } else if (!iotg->hsm.a_sess_vld) {
+                        iotg->hsm.a_srp_det = 0;
+                        set_host_mode();
+                        langwell_otg_phy_low_power(1);
+                        iotg->otg.state = OTG_STATE_A_IDLE;
+                }
+                break;
+        default:
+                ;
+        }
+
+        dev_dbg(lnw->dev, "%s: new state = %s\n", __func__,
+                        otg_state_string(iotg->otg.state));
+}
+
+static ssize_t
+show_registers(struct device *_dev, struct device_attribute *attr, char *buf)
+{
+        struct langwell_otg     *lnw = the_transceiver;
+        char                    *next;
+        unsigned                size, t;
+
+        next = buf;
+        size = PAGE_SIZE;
+
+        t = scnprintf(next, size,
+                "\n"
+                "USBCMD = 0x%08x\n"
+                "USBSTS = 0x%08x\n"
+                "USBINTR = 0x%08x\n"
+                "ASYNCLISTADDR = 0x%08x\n"
+                "PORTSC1 = 0x%08x\n"
+                "HOSTPC1 = 0x%08x\n"
+                "OTGSC = 0x%08x\n"
+                "USBMODE = 0x%08x\n",
+                readl(lnw->iotg.base + 0x30),
+                readl(lnw->iotg.base + 0x34),
+                readl(lnw->iotg.base + 0x38),
+                readl(lnw->iotg.base + 0x48),
+                readl(lnw->iotg.base + 0x74),
+                readl(lnw->iotg.base + 0xb4),
+                readl(lnw->iotg.base + 0xf4),
+                readl(lnw->iotg.base + 0xf8)
+             );
+        size -= t;
+        next += t;
+
+        return PAGE_SIZE - size;
+}
+static DEVICE_ATTR(registers, S_IRUGO, show_registers, NULL);
+
+static ssize_t
+show_hsm(struct device *_dev, struct device_attribute *attr, char *buf)
+{
+        struct langwell_otg             *lnw = the_transceiver;
+        struct intel_mid_otg_xceiv      *iotg = &lnw->iotg;
+        char                            *next;
+        unsigned                        size, t;
+
+        next = buf;
+        size = PAGE_SIZE;
+
+        if (iotg->otg.host)
+                iotg->hsm.a_set_b_hnp_en = iotg->otg.host->b_hnp_enable;
+
+        if (iotg->otg.gadget)
+                iotg->hsm.b_hnp_enable = iotg->otg.gadget->b_hnp_enable;
+
+        t = scnprintf(next, size,
+                "\n"
+                "current state = %s\n"
+                "a_bus_resume = \t%d\n"
+                "a_bus_suspend = \t%d\n"
+                "a_conn = \t%d\n"
+                "a_sess_vld = \t%d\n"
+                "a_srp_det = \t%d\n"
+                "a_vbus_vld = \t%d\n"
+                "b_bus_resume = \t%d\n"
+                "b_bus_suspend = \t%d\n"
+                "b_conn = \t%d\n"
+                "b_se0_srp = \t%d\n"
+                "b_sess_end = \t%d\n"
+                "b_sess_vld = \t%d\n"
+                "id = \t%d\n"
+                "a_set_b_hnp_en = \t%d\n"
+                "b_srp_done = \t%d\n"
+                "b_hnp_enable = \t%d\n"
+                "a_wait_vrise_tmout = \t%d\n"
+                "a_wait_bcon_tmout = \t%d\n"
+                "a_aidl_bdis_tmout = \t%d\n"
+                "b_ase0_brst_tmout = \t%d\n"
+                "a_bus_drop = \t%d\n"
+                "a_bus_req = \t%d\n"
+                "a_clr_err = \t%d\n"
+                "a_suspend_req = \t%d\n"
+                "b_bus_req = \t%d\n"
+                "b_bus_suspend_tmout = \t%d\n"
+                "b_bus_suspend_vld = \t%d\n",
+                otg_state_string(iotg->otg.state),
+                iotg->hsm.a_bus_resume,
+                iotg->hsm.a_bus_suspend,
+                iotg->hsm.a_conn,
+                iotg->hsm.a_sess_vld,
+                iotg->hsm.a_srp_det,
+                iotg->hsm.a_vbus_vld,
+                iotg->hsm.b_bus_resume,
+                iotg->hsm.b_bus_suspend,
+                iotg->hsm.b_conn,
+                iotg->hsm.b_se0_srp,
+                iotg->hsm.b_sess_end,
+                iotg->hsm.b_sess_vld,
+                iotg->hsm.id,
+                iotg->hsm.a_set_b_hnp_en,
+                iotg->hsm.b_srp_done,
+                iotg->hsm.b_hnp_enable,
+                iotg->hsm.a_wait_vrise_tmout,
+                iotg->hsm.a_wait_bcon_tmout,
+                iotg->hsm.a_aidl_bdis_tmout,
+                iotg->hsm.b_ase0_brst_tmout,
+                iotg->hsm.a_bus_drop,
+                iotg->hsm.a_bus_req,
+                iotg->hsm.a_clr_err,
+                iotg->hsm.a_suspend_req,
+                iotg->hsm.b_bus_req,
+                iotg->hsm.b_bus_suspend_tmout,
+                iotg->hsm.b_bus_suspend_vld
+                );
+        size -= t;
+        next += t;
+
+        return PAGE_SIZE - size;
+}
+static DEVICE_ATTR(hsm, S_IRUGO, show_hsm, NULL);
+
+static ssize_t
+get_a_bus_req(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        struct langwell_otg     *lnw = the_transceiver;
+        char                    *next;
+        unsigned                size, t;
+
+        next = buf;
+        size = PAGE_SIZE;
+
+        t = scnprintf(next, size, "%d", lnw->iotg.hsm.a_bus_req);
+        size -= t;
+        next += t;
+
+        return PAGE_SIZE - size;
+}
+
+static ssize_t
+set_a_bus_req(struct device *dev, struct device_attribute *attr,
+                const char *buf, size_t count)
+{
+        struct langwell_otg             *lnw = the_transceiver;
+        struct intel_mid_otg_xceiv      *iotg = &lnw->iotg;
+
+        if (!iotg->otg.default_a)
+                return -1;
+        if (count > 2)
+                return -1;
+
+        if (buf[0] == '0') {
+                iotg->hsm.a_bus_req = 0;
+                dev_dbg(lnw->dev, "User request: a_bus_req = 0\n");
+        } else if (buf[0] == '1') {
+                /* If a_bus_drop is TRUE, a_bus_req can't be set */
+                if (iotg->hsm.a_bus_drop)
+                        return -1;
+                iotg->hsm.a_bus_req = 1;
+                dev_dbg(lnw->dev, "User request: a_bus_req = 1\n");
+        }
+        if (spin_trylock(&lnw->wq_lock)) {
+                langwell_update_transceiver();
+                spin_unlock(&lnw->wq_lock);
+        }
+        return count;
+}
+static DEVICE_ATTR(a_bus_req, S_IRUGO | S_IWUSR, get_a_bus_req, set_a_bus_req);
+
+static ssize_t
+get_a_bus_drop(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        struct langwell_otg     *lnw = the_transceiver;
+        char                    *next;
+        unsigned                size, t;
+
+        next = buf;
+        size = PAGE_SIZE;
+
+        t = scnprintf(next, size, "%d", lnw->iotg.hsm.a_bus_drop);
+        size -= t;
+        next += t;
+
+        return PAGE_SIZE - size;
+}
+
+static ssize_t
+set_a_bus_drop(struct device *dev, struct device_attribute *attr,
+                const char *buf, size_t count)
+{
+        struct langwell_otg             *lnw = the_transceiver;
+        struct intel_mid_otg_xceiv      *iotg = &lnw->iotg;
+
+        if (!iotg->otg.default_a)
+                return -1;
+        if (count > 2)
+                return -1;
+
+        if (buf[0] == '0') {
+                iotg->hsm.a_bus_drop = 0;
+                dev_dbg(lnw->dev, "User request: a_bus_drop = 0\n");
+        } else if (buf[0] == '1') {
+                iotg->hsm.a_bus_drop = 1;
+                iotg->hsm.a_bus_req = 0;
+                dev_dbg(lnw->dev, "User request: a_bus_drop = 1\n");
+                dev_dbg(lnw->dev, "User request: and a_bus_req = 0\n");
+        }
+        if (spin_trylock(&lnw->wq_lock)) {
+                langwell_update_transceiver();
+                spin_unlock(&lnw->wq_lock);
+        }
+        return count;
+}
+static DEVICE_ATTR(a_bus_drop, S_IRUGO | S_IWUSR, get_a_bus_drop, set_a_bus_drop);
+
+static ssize_t
+get_b_bus_req(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        struct langwell_otg     *lnw = the_transceiver;
+        char                    *next;
+        unsigned                size, t;
+
+        next = buf;
+        size = PAGE_SIZE;
+
+        t = scnprintf(next, size, "%d", lnw->iotg.hsm.b_bus_req);
+        size -= t;
+        next += t;
+
+        return PAGE_SIZE - size;
+}
+
+static ssize_t
+set_b_bus_req(struct device *dev, struct device_attribute *attr,
+                const char *buf, size_t count)
+{
+        struct langwell_otg             *lnw = the_transceiver;
+        struct intel_mid_otg_xceiv      *iotg = &lnw->iotg;
+
+        if (iotg->otg.default_a)
+                return -1;
+
+        if (count > 2)
+                return -1;
+
+        if (buf[0] == '0') {
+                iotg->hsm.b_bus_req = 0;
+                dev_dbg(lnw->dev, "User request: b_bus_req = 0\n");
+        } else if (buf[0] == '1') {
+                iotg->hsm.b_bus_req = 1;
+                dev_dbg(lnw->dev, "User request: b_bus_req = 1\n");
+        }
+        if (spin_trylock(&lnw->wq_lock)) {
+                langwell_update_transceiver();
+                spin_unlock(&lnw->wq_lock);
+        }
+        return count;
+}
+static DEVICE_ATTR(b_bus_req, S_IRUGO | S_IWUSR, get_b_bus_req, set_b_bus_req);
+
+static ssize_t
+set_a_clr_err(struct device *dev, struct device_attribute *attr,
+                const char *buf, size_t count)
+{
+        struct langwell_otg             *lnw = the_transceiver;
+        struct intel_mid_otg_xceiv      *iotg = &lnw->iotg;
+
+        if (!iotg->otg.default_a)
+                return -1;
+        if (count > 2)
+                return -1;
+
+        if (buf[0] == '1') {
+                iotg->hsm.a_clr_err = 1;
+                dev_dbg(lnw->dev, "User request: a_clr_err = 1\n");
+        }
+        if (spin_trylock(&lnw->wq_lock)) {
+                langwell_update_transceiver();
+                spin_unlock(&lnw->wq_lock);
+        }
+        return count;
+}
+static DEVICE_ATTR(a_clr_err, S_IWUSR, NULL, set_a_clr_err);
+
+static struct attribute *inputs_attrs[] = {
+        &dev_attr_a_bus_req.attr,
+        &dev_attr_a_bus_drop.attr,
+        &dev_attr_b_bus_req.attr,
+        &dev_attr_a_clr_err.attr,
+        NULL,
+};
+
+static struct attribute_group debug_dev_attr_group = {
+        .name = "inputs",
+        .attrs = inputs_attrs,
+};
+
+static int langwell_otg_probe(struct pci_dev *pdev,
+                const struct pci_device_id *id)
+{
+        unsigned long           resource, len;
+        void __iomem            *base = NULL;
+        int                     retval;
+        u32                     val32;
+        struct langwell_otg     *lnw;
+        char                    qname[] = "langwell_otg_queue";
+
+        retval = 0;
+        dev_dbg(&pdev->dev, "\notg controller is detected.\n");
+        if (pci_enable_device(pdev) < 0) {
+                retval = -ENODEV;
+                goto done;
+        }
+
+        lnw = kzalloc(sizeof *lnw, GFP_KERNEL);
+        if (lnw == NULL) {
+                retval = -ENOMEM;
+                goto done;
+        }
+        the_transceiver = lnw;
+
+        /* control register: BAR 0 */
+        resource = pci_resource_start(pdev, 0);
+        len = pci_resource_len(pdev, 0);
+        if (!request_mem_region(resource, len, driver_name)) {
+                retval = -EBUSY;
+                goto err;
+        }
+        lnw->region = 1;
+
+        base = ioremap_nocache(resource, len);
+        if (base == NULL) {
+                retval = -EFAULT;
+                goto err;
+        }
+        lnw->iotg.base = base;
+
+        if (!request_mem_region(USBCFG_ADDR, USBCFG_LEN, driver_name)) {
+                retval = -EBUSY;
+                goto err;
+        }
+        lnw->cfg_region = 1;
+
+        /* For the SCCB.USBCFG register */
+        base = ioremap_nocache(USBCFG_ADDR, USBCFG_LEN);
+        if (base == NULL) {
+                retval = -EFAULT;
+                goto err;
+        }
+        lnw->usbcfg = base;
+
+        if (!pdev->irq) {
+                dev_dbg(&pdev->dev, "No IRQ.\n");
+                retval = -ENODEV;
+                goto err;
+        }
+
+        lnw->qwork = create_singlethread_workqueue(qname);
+        if (!lnw->qwork) {
+                dev_dbg(&pdev->dev, "cannot create workqueue %s\n", qname);
+                retval = -ENOMEM;
+                goto err;
+        }
+        INIT_WORK(&lnw->work, langwell_otg_work);
+
+        /* OTG common part */
+        lnw->dev = &pdev->dev;
+        lnw->iotg.otg.dev = lnw->dev;
+        lnw->iotg.otg.label = driver_name;
+        lnw->iotg.otg.set_host = langwell_otg_set_host;
+        lnw->iotg.otg.set_peripheral = langwell_otg_set_peripheral;
+        lnw->iotg.otg.set_power = langwell_otg_set_power;
+        lnw->iotg.otg.set_vbus = langwell_otg_set_vbus;
+        lnw->iotg.otg.start_srp = langwell_otg_start_srp;
+        lnw->iotg.otg.state = OTG_STATE_UNDEFINED;
+
+        if (otg_set_transceiver(&lnw->iotg.otg)) {
+                dev_dbg(lnw->dev, "can't set transceiver\n");
+                retval = -EBUSY;
+                goto err;
+        }
+
+        reset_otg();
+        init_hsm();
+
+        spin_lock_init(&lnw->lock);
+        spin_lock_init(&lnw->wq_lock);
+        INIT_LIST_HEAD(&active_timers);
+        retval = langwell_otg_init_timers(&lnw->iotg.hsm);
+        if (retval) {
+                dev_dbg(&pdev->dev, "Failed to init timers\n");
+                goto err;
+        }
+
+        init_timer(&lnw->hsm_timer);
+        ATOMIC_INIT_NOTIFIER_HEAD(&lnw->iotg.iotg_notifier);
+
+        lnw->iotg_notifier.notifier_call = langwell_otg_iotg_notify;
+
+        retval = intel_mid_otg_register_notifier(&lnw->iotg,
+                                                &lnw->iotg_notifier);
+        if (retval) {
+                dev_dbg(lnw->dev, "Failed to register notifier\n");
+                goto err;
+        }
+
+        if (request_irq(pdev->irq, otg_irq, IRQF_SHARED,
+                                driver_name, lnw) != 0) {
+                dev_dbg(lnw->dev, "request interrupt %d failed\n", pdev->irq);
+                retval = -EBUSY;
+                goto err;
+        }
+
+        /* enable OTGSC int */
+        val32 = OTGSC_DPIE | OTGSC_BSEIE | OTGSC_BSVIE |
+                OTGSC_ASVIE | OTGSC_AVVIE | OTGSC_IDIE | OTGSC_IDPU;
+        writel(val32, lnw->iotg.base + CI_OTGSC);
+
+        retval = device_create_file(&pdev->dev, &dev_attr_registers);
+        if (retval < 0) {
+                dev_dbg(lnw->dev,
+                        "Can't register sysfs attribute: %d\n", retval);
+                goto err;
+        }
+
+        retval = device_create_file(&pdev->dev, &dev_attr_hsm);
+        if (retval < 0) {
+                dev_dbg(lnw->dev, "Can't hsm sysfs attribute: %d\n", retval);
+                goto err;
+        }
+
+        retval = sysfs_create_group(&pdev->dev.kobj, &debug_dev_attr_group);
+        if (retval < 0) {
+                dev_dbg(lnw->dev,
+                        "Can't register sysfs attr group: %d\n", retval);
+                goto err;
+        }
+
+        if (lnw->iotg.otg.state == OTG_STATE_A_IDLE)
+                langwell_update_transceiver();
+
+        return 0;
+
+err:
+        if (the_transceiver)
+                langwell_otg_remove(pdev);
+done:
+        return retval;
+}
+
+static void langwell_otg_remove(struct pci_dev *pdev)
+{
+        struct langwell_otg *lnw = the_transceiver;
+
+        if (lnw->qwork) {
+                flush_workqueue(lnw->qwork);
+                destroy_workqueue(lnw->qwork);
+        }
+        intel_mid_otg_unregister_notifier(&lnw->iotg, &lnw->iotg_notifier);
+        langwell_otg_free_timers();
+
+        /* disable OTGSC interrupt as OTGSC doesn't change in reset */
+        writel(0, lnw->iotg.base + CI_OTGSC);
+
+        if (pdev->irq)
+                free_irq(pdev->irq, lnw);
+        if (lnw->usbcfg)
+                iounmap(lnw->usbcfg);
+        if (lnw->cfg_region)
+                release_mem_region(USBCFG_ADDR, USBCFG_LEN);
+        if (lnw->iotg.base)
+                iounmap(lnw->iotg.base);
+        if (lnw->region)
+                release_mem_region(pci_resource_start(pdev, 0),
+                                pci_resource_len(pdev, 0));
+
+        otg_set_transceiver(NULL);
+        pci_disable_device(pdev);
+        sysfs_remove_group(&pdev->dev.kobj, &debug_dev_attr_group);
+        device_remove_file(&pdev->dev, &dev_attr_hsm);
+        device_remove_file(&pdev->dev, &dev_attr_registers);
+        kfree(lnw);
+        lnw = NULL;
+}
+
+static void transceiver_suspend(struct pci_dev *pdev)
+{
+        pci_save_state(pdev);
+        pci_set_power_state(pdev, PCI_D3hot);
+        langwell_otg_phy_low_power(1);
+}
+
+static int langwell_otg_suspend(struct pci_dev *pdev, pm_message_t message)
+{
+        struct langwell_otg             *lnw = the_transceiver;
+        struct intel_mid_otg_xceiv      *iotg = &lnw->iotg;
+        int                             ret = 0;
+
+        /* Disbale OTG interrupts */
+        langwell_otg_intr(0);
+
+        if (pdev->irq)
+                free_irq(pdev->irq, lnw);
+
+        /* Prevent more otg_work */
+        flush_workqueue(lnw->qwork);
+        destroy_workqueue(lnw->qwork);
+        lnw->qwork = NULL;
+
+        /* start actions */
+        switch (iotg->otg.state) {
+        case OTG_STATE_A_WAIT_VFALL:
+                iotg->otg.state = OTG_STATE_A_IDLE;
+        case OTG_STATE_A_IDLE:
+        case OTG_STATE_B_IDLE:
+        case OTG_STATE_A_VBUS_ERR:
+                transceiver_suspend(pdev);
+                break;
+        case OTG_STATE_A_WAIT_VRISE:
+                langwell_otg_del_timer(a_wait_vrise_tmr);
+                iotg->hsm.a_srp_det = 0;
+
+                /* Turn off VBus */
+                iotg->otg.set_vbus(&iotg->otg, false);
+                iotg->otg.state = OTG_STATE_A_IDLE;
+                transceiver_suspend(pdev);
+                break;
+        case OTG_STATE_A_WAIT_BCON:
+                del_timer_sync(&lnw->hsm_timer);
+                if (lnw->iotg.stop_host)
+                        lnw->iotg.stop_host(&lnw->iotg);
+                else
+                        dev_dbg(&pdev->dev, "host driver has been removed.\n");
+
+                iotg->hsm.a_srp_det = 0;
+
+                /* Turn off VBus */
+                iotg->otg.set_vbus(&iotg->otg, false);
+                iotg->otg.state = OTG_STATE_A_IDLE;
+                transceiver_suspend(pdev);
+                break;
+        case OTG_STATE_A_HOST:
+                if (lnw->iotg.stop_host)
+                        lnw->iotg.stop_host(&lnw->iotg);
+                else
+                        dev_dbg(&pdev->dev, "host driver has been removed.\n");
+
+                iotg->hsm.a_srp_det = 0;
+
+                /* Turn off VBus */
+                iotg->otg.set_vbus(&iotg->otg, false);
+
+                iotg->otg.state = OTG_STATE_A_IDLE;
+                transceiver_suspend(pdev);
+                break;
+        case OTG_STATE_A_SUSPEND:
+                langwell_otg_del_timer(a_aidl_bdis_tmr);
+                langwell_otg_HABA(0);
+                if (lnw->iotg.stop_host)
+                        lnw->iotg.stop_host(&lnw->iotg);
+                else
+                        dev_dbg(lnw->dev, "host driver has been removed.\n");
+                iotg->hsm.a_srp_det = 0;
+
+                /* Turn off VBus */
+                iotg->otg.set_vbus(&iotg->otg, false);
+                iotg->otg.state = OTG_STATE_A_IDLE;
+                transceiver_suspend(pdev);
+                break;
+        case OTG_STATE_A_PERIPHERAL:
+                del_timer_sync(&lnw->hsm_timer);
+
+                if (lnw->iotg.stop_peripheral)
+                        lnw->iotg.stop_peripheral(&lnw->iotg);
+                else
+                        dev_dbg(&pdev->dev,
+                                "client driver has been removed.\n");
+                iotg->hsm.a_srp_det = 0;
+
+                /* Turn off VBus */
+                iotg->otg.set_vbus(&iotg->otg, false);
+                iotg->otg.state = OTG_STATE_A_IDLE;
+                transceiver_suspend(pdev);
+                break;
+        case OTG_STATE_B_HOST:
+                if (lnw->iotg.stop_host)
+                        lnw->iotg.stop_host(&lnw->iotg);
+                else
+                        dev_dbg(&pdev->dev, "host driver has been removed.\n");
+                iotg->hsm.b_bus_req = 0;
+                iotg->otg.state = OTG_STATE_B_IDLE;
+                transceiver_suspend(pdev);
+                break;
+        case OTG_STATE_B_PERIPHERAL:
+                if (lnw->iotg.stop_peripheral)
+                        lnw->iotg.stop_peripheral(&lnw->iotg);
+                else
+                        dev_dbg(&pdev->dev,
+                                "client driver has been removed.\n");
+                iotg->otg.state = OTG_STATE_B_IDLE;
+                transceiver_suspend(pdev);
+                break;
+        case OTG_STATE_B_WAIT_ACON:
+                /* delete hsm timer for b_ase0_brst_tmr */
+                del_timer_sync(&lnw->hsm_timer);
+
+                langwell_otg_HAAR(0);
+
+                if (lnw->iotg.stop_host)
+                        lnw->iotg.stop_host(&lnw->iotg);
+                else
+                        dev_dbg(&pdev->dev, "host driver has been removed.\n");
+                iotg->hsm.b_bus_req = 0;
+                iotg->otg.state = OTG_STATE_B_IDLE;
+                transceiver_suspend(pdev);
+                break;
+        default:
+                dev_dbg(lnw->dev, "error state before suspend\n");
+                break;
+        }
+
+        return ret;
+}
+
+static void transceiver_resume(struct pci_dev *pdev)
+{
+        pci_restore_state(pdev);
+        pci_set_power_state(pdev, PCI_D0);
+}
+
+static int langwell_otg_resume(struct pci_dev *pdev)
+{
+        struct langwell_otg     *lnw = the_transceiver;
+        int                     ret = 0;
+
+        transceiver_resume(pdev);
+
+        lnw->qwork = create_singlethread_workqueue("langwell_otg_queue");
+        if (!lnw->qwork) {
+                dev_dbg(&pdev->dev, "cannot create langwell otg workqueuen");
+                ret = -ENOMEM;
+                goto error;
+        }
+
+        if (request_irq(pdev->irq, otg_irq, IRQF_SHARED,
+                                driver_name, lnw) != 0) {
+                dev_dbg(&pdev->dev, "request interrupt %d failed\n", pdev->irq);
+                ret = -EBUSY;
+                goto error;
+        }
+
+        /* enable OTG interrupts */
+        langwell_otg_intr(1);
+
+        update_hsm();
+
+        langwell_update_transceiver();
+
+        return ret;
+error:
+        langwell_otg_intr(0);
+        transceiver_suspend(pdev);
+        return ret;
+}
+
+static int __init langwell_otg_init(void)
+{
+        return pci_register_driver(&otg_pci_driver);
+}
+module_init(langwell_otg_init);
+
+static void __exit langwell_otg_cleanup(void)
+{
+        pci_unregister_driver(&otg_pci_driver);
+}
+module_exit(langwell_otg_cleanup);
diff --git a/drivers/usb/otg/msm_otg.c b/drivers/usb/otg/msm_otg.c
new file mode 100644
index 000000000000..b276f8fcdeba
--- /dev/null
+++ b/drivers/usb/otg/msm_otg.c
@@ -0,0 +1,1761 @@
+/* Copyright (c) 2009-2011, Code Aurora Forum. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/device.h>
+#include <linux/platform_device.h>
+#include <linux/clk.h>
+#include <linux/slab.h>
+#include <linux/interrupt.h>
+#include <linux/err.h>
+#include <linux/delay.h>
+#include <linux/io.h>
+#include <linux/ioport.h>
+#include <linux/uaccess.h>
+#include <linux/debugfs.h>
+#include <linux/seq_file.h>
+#include <linux/pm_runtime.h>
+
+#include <linux/usb.h>
+#include <linux/usb/otg.h>
+#include <linux/usb/ulpi.h>
+#include <linux/usb/gadget.h>
+#include <linux/usb/hcd.h>
+#include <linux/usb/msm_hsusb.h>
+#include <linux/usb/msm_hsusb_hw.h>
+#include <linux/regulator/consumer.h>
+
+#include <mach/clk.h>
+
+#define MSM_USB_BASE    (motg->regs)
+#define DRIVER_NAME     "msm_otg"
+
+#define ULPI_IO_TIMEOUT_USEC    (10 * 1000)
+
+#define USB_PHY_3P3_VOL_MIN     3050000 /* uV */
+#define USB_PHY_3P3_VOL_MAX     3300000 /* uV */
+#define USB_PHY_3P3_HPM_LOAD    50000   /* uA */
+#define USB_PHY_3P3_LPM_LOAD    4000    /* uA */
+
+#define USB_PHY_1P8_VOL_MIN     1800000 /* uV */
+#define USB_PHY_1P8_VOL_MAX     1800000 /* uV */
+#define USB_PHY_1P8_HPM_LOAD    50000   /* uA */
+#define USB_PHY_1P8_LPM_LOAD    4000    /* uA */
+
+#define USB_PHY_VDD_DIG_VOL_MIN 1000000 /* uV */
+#define USB_PHY_VDD_DIG_VOL_MAX 1320000 /* uV */
+
+static struct regulator *hsusb_3p3;
+static struct regulator *hsusb_1p8;
+static struct regulator *hsusb_vddcx;
+
+static int msm_hsusb_init_vddcx(struct msm_otg *motg, int init)
+{
+        int ret = 0;
+
+        if (init) {
+                hsusb_vddcx = regulator_get(motg->otg.dev, "HSUSB_VDDCX");
+                if (IS_ERR(hsusb_vddcx)) {
+                        dev_err(motg->otg.dev, "unable to get hsusb vddcx\n");
+                        return PTR_ERR(hsusb_vddcx);
+                }
+
+                ret = regulator_set_voltage(hsusb_vddcx,
+                                USB_PHY_VDD_DIG_VOL_MIN,
+                                USB_PHY_VDD_DIG_VOL_MAX);
+                if (ret) {
+                        dev_err(motg->otg.dev, "unable to set the voltage "
+                                        "for hsusb vddcx\n");
+                        regulator_put(hsusb_vddcx);
+                        return ret;
+                }
+
+                ret = regulator_enable(hsusb_vddcx);
+                if (ret) {
+                        dev_err(motg->otg.dev, "unable to enable hsusb vddcx\n");
+                        regulator_put(hsusb_vddcx);
+                }
+        } else {
+                ret = regulator_set_voltage(hsusb_vddcx, 0,
+                        USB_PHY_VDD_DIG_VOL_MAX);
+                if (ret)
+                        dev_err(motg->otg.dev, "unable to set the voltage "
+                                        "for hsusb vddcx\n");
+                ret = regulator_disable(hsusb_vddcx);
+                if (ret)
+                        dev_err(motg->otg.dev, "unable to disable hsusb vddcx\n");
+
+                regulator_put(hsusb_vddcx);
+        }
+
+        return ret;
+}
+
+static int msm_hsusb_ldo_init(struct msm_otg *motg, int init)
+{
+        int rc = 0;
+
+        if (init) {
+                hsusb_3p3 = regulator_get(motg->otg.dev, "HSUSB_3p3");
+                if (IS_ERR(hsusb_3p3)) {
+                        dev_err(motg->otg.dev, "unable to get hsusb 3p3\n");
+                        return PTR_ERR(hsusb_3p3);
+                }
+
+                rc = regulator_set_voltage(hsusb_3p3, USB_PHY_3P3_VOL_MIN,
+                                USB_PHY_3P3_VOL_MAX);
+                if (rc) {
+                        dev_err(motg->otg.dev, "unable to set voltage level "
+                                        "for hsusb 3p3\n");
+                        goto put_3p3;
+                }
+                rc = regulator_enable(hsusb_3p3);
+                if (rc) {
+                        dev_err(motg->otg.dev, "unable to enable the hsusb 3p3\n");
+                        goto put_3p3;
+                }
+                hsusb_1p8 = regulator_get(motg->otg.dev, "HSUSB_1p8");
+                if (IS_ERR(hsusb_1p8)) {
+                        dev_err(motg->otg.dev, "unable to get hsusb 1p8\n");
+                        rc = PTR_ERR(hsusb_1p8);
+                        goto disable_3p3;
+                }
+                rc = regulator_set_voltage(hsusb_1p8, USB_PHY_1P8_VOL_MIN,
+                                USB_PHY_1P8_VOL_MAX);
+                if (rc) {
+                        dev_err(motg->otg.dev, "unable to set voltage level "
+                                        "for hsusb 1p8\n");
+                        goto put_1p8;
+                }
+                rc = regulator_enable(hsusb_1p8);
+                if (rc) {
+                        dev_err(motg->otg.dev, "unable to enable the hsusb 1p8\n");
+                        goto put_1p8;
+                }
+
+                return 0;
+        }
+
+        regulator_disable(hsusb_1p8);
+put_1p8:
+        regulator_put(hsusb_1p8);
+disable_3p3:
+        regulator_disable(hsusb_3p3);
+put_3p3:
+        regulator_put(hsusb_3p3);
+        return rc;
+}
+
+#ifdef CONFIG_PM_SLEEP
+#define USB_PHY_SUSP_DIG_VOL  500000
+static int msm_hsusb_config_vddcx(int high)
+{
+        int max_vol = USB_PHY_VDD_DIG_VOL_MAX;
+        int min_vol;
+        int ret;
+
+        if (high)
+                min_vol = USB_PHY_VDD_DIG_VOL_MIN;
+        else
+                min_vol = USB_PHY_SUSP_DIG_VOL;
+
+        ret = regulator_set_voltage(hsusb_vddcx, min_vol, max_vol);
+        if (ret) {
+                pr_err("%s: unable to set the voltage for regulator "
+                        "HSUSB_VDDCX\n", __func__);
+                return ret;
+        }
+
+        pr_debug("%s: min_vol:%d max_vol:%d\n", __func__, min_vol, max_vol);
+
+        return ret;
+}
+#endif
+
+static int msm_hsusb_ldo_set_mode(int on)
+{
+        int ret = 0;
+
+        if (!hsusb_1p8 || IS_ERR(hsusb_1p8)) {
+                pr_err("%s: HSUSB_1p8 is not initialized\n", __func__);
+                return -ENODEV;
+        }
+
+        if (!hsusb_3p3 || IS_ERR(hsusb_3p3)) {
+                pr_err("%s: HSUSB_3p3 is not initialized\n", __func__);
+                return -ENODEV;
+        }
+
+        if (on) {
+                ret = regulator_set_optimum_mode(hsusb_1p8,
+                                USB_PHY_1P8_HPM_LOAD);
+                if (ret < 0) {
+                        pr_err("%s: Unable to set HPM of the regulator "
+                                "HSUSB_1p8\n", __func__);
+                        return ret;
+                }
+                ret = regulator_set_optimum_mode(hsusb_3p3,
+                                USB_PHY_3P3_HPM_LOAD);
+                if (ret < 0) {
+                        pr_err("%s: Unable to set HPM of the regulator "
+                                "HSUSB_3p3\n", __func__);
+                        regulator_set_optimum_mode(hsusb_1p8,
+                                USB_PHY_1P8_LPM_LOAD);
+                        return ret;
+                }
+        } else {
+                ret = regulator_set_optimum_mode(hsusb_1p8,
+                                USB_PHY_1P8_LPM_LOAD);
+                if (ret < 0)
+                        pr_err("%s: Unable to set LPM of the regulator "
+                                "HSUSB_1p8\n", __func__);
+                ret = regulator_set_optimum_mode(hsusb_3p3,
+                                USB_PHY_3P3_LPM_LOAD);
+                if (ret < 0)
+                        pr_err("%s: Unable to set LPM of the regulator "
+                                "HSUSB_3p3\n", __func__);
+        }
+
+        pr_debug("reg (%s)\n", on ? "HPM" : "LPM");
+        return ret < 0 ? ret : 0;
+}
+
+static int ulpi_read(struct otg_transceiver *otg, u32 reg)
+{
+        struct msm_otg *motg = container_of(otg, struct msm_otg, otg);
+        int cnt = 0;
+
+        /* initiate read operation */
+        writel(ULPI_RUN | ULPI_READ | ULPI_ADDR(reg),
+               USB_ULPI_VIEWPORT);
+
+        /* wait for completion */
+        while (cnt < ULPI_IO_TIMEOUT_USEC) {
+                if (!(readl(USB_ULPI_VIEWPORT) & ULPI_RUN))
+                        break;
+                udelay(1);
+                cnt++;
+        }
+
+        if (cnt >= ULPI_IO_TIMEOUT_USEC) {
+                dev_err(otg->dev, "ulpi_read: timeout %08x\n",
+                        readl(USB_ULPI_VIEWPORT));
+                return -ETIMEDOUT;
+        }
+        return ULPI_DATA_READ(readl(USB_ULPI_VIEWPORT));
+}
+
+static int ulpi_write(struct otg_transceiver *otg, u32 val, u32 reg)
+{
+        struct msm_otg *motg = container_of(otg, struct msm_otg, otg);
+        int cnt = 0;
+
+        /* initiate write operation */
+        writel(ULPI_RUN | ULPI_WRITE |
+               ULPI_ADDR(reg) | ULPI_DATA(val),
+               USB_ULPI_VIEWPORT);
+
+        /* wait for completion */
+        while (cnt < ULPI_IO_TIMEOUT_USEC) {
+                if (!(readl(USB_ULPI_VIEWPORT) & ULPI_RUN))
+                        break;
+                udelay(1);
+                cnt++;
+        }
+
+        if (cnt >= ULPI_IO_TIMEOUT_USEC) {
+                dev_err(otg->dev, "ulpi_write: timeout\n");
+                return -ETIMEDOUT;
+        }
+        return 0;
+}
+
+static struct otg_io_access_ops msm_otg_io_ops = {
+        .read = ulpi_read,
+        .write = ulpi_write,
+};
+
+static void ulpi_init(struct msm_otg *motg)
+{
+        struct msm_otg_platform_data *pdata = motg->pdata;
+        int *seq = pdata->phy_init_seq;
+
+        if (!seq)
+                return;
+
+        while (seq[0] >= 0) {
+                dev_vdbg(motg->otg.dev, "ulpi: write 0x%02x to 0x%02x\n",
+                                seq[0], seq[1]);
+                ulpi_write(&motg->otg, seq[0], seq[1]);
+                seq += 2;
+        }
+}
+
+static int msm_otg_link_clk_reset(struct msm_otg *motg, bool assert)
+{
+        int ret;
+
+        if (assert) {
+                ret = clk_reset(motg->clk, CLK_RESET_ASSERT);
+                if (ret)
+                        dev_err(motg->otg.dev, "usb hs_clk assert failed\n");
+        } else {
+                ret = clk_reset(motg->clk, CLK_RESET_DEASSERT);
+                if (ret)
+                        dev_err(motg->otg.dev, "usb hs_clk deassert failed\n");
+        }
+        return ret;
+}
+
+static int msm_otg_phy_clk_reset(struct msm_otg *motg)
+{
+        int ret;
+
+        ret = clk_reset(motg->phy_reset_clk, CLK_RESET_ASSERT);
+        if (ret) {
+                dev_err(motg->otg.dev, "usb phy clk assert failed\n");
+                return ret;
+        }
+        usleep_range(10000, 12000);
+        ret = clk_reset(motg->phy_reset_clk, CLK_RESET_DEASSERT);
+        if (ret)
+                dev_err(motg->otg.dev, "usb phy clk deassert failed\n");
+        return ret;
+}
+
+static int msm_otg_phy_reset(struct msm_otg *motg)
+{
+        u32 val;
+        int ret;
+        int retries;
+
+        ret = msm_otg_link_clk_reset(motg, 1);
+        if (ret)
+                return ret;
+        ret = msm_otg_phy_clk_reset(motg);
+        if (ret)
+                return ret;
+        ret = msm_otg_link_clk_reset(motg, 0);
+        if (ret)
+                return ret;
+
+        val = readl(USB_PORTSC) & ~PORTSC_PTS_MASK;
+        writel(val | PORTSC_PTS_ULPI, USB_PORTSC);
+
+        for (retries = 3; retries > 0; retries--) {
+                ret = ulpi_write(&motg->otg, ULPI_FUNC_CTRL_SUSPENDM,
+                                ULPI_CLR(ULPI_FUNC_CTRL));
+                if (!ret)
+                        break;
+                ret = msm_otg_phy_clk_reset(motg);
+                if (ret)
+                        return ret;
+        }
+        if (!retries)
+                return -ETIMEDOUT;
+
+        /* This reset calibrates the phy, if the above write succeeded */
+        ret = msm_otg_phy_clk_reset(motg);
+        if (ret)
+                return ret;
+
+        for (retries = 3; retries > 0; retries--) {
+                ret = ulpi_read(&motg->otg, ULPI_DEBUG);
+                if (ret != -ETIMEDOUT)
+                        break;
+                ret = msm_otg_phy_clk_reset(motg);
+                if (ret)
+                        return ret;
+        }
+        if (!retries)
+                return -ETIMEDOUT;
+
+        dev_info(motg->otg.dev, "phy_reset: success\n");
+        return 0;
+}
+
+#define LINK_RESET_TIMEOUT_USEC         (250 * 1000)
+static int msm_otg_reset(struct otg_transceiver *otg)
+{
+        struct msm_otg *motg = container_of(otg, struct msm_otg, otg);
+        struct msm_otg_platform_data *pdata = motg->pdata;
+        int cnt = 0;
+        int ret;
+        u32 val = 0;
+        u32 ulpi_val = 0;
+
+        ret = msm_otg_phy_reset(motg);
+        if (ret) {
+                dev_err(otg->dev, "phy_reset failed\n");
+                return ret;
+        }
+
+        ulpi_init(motg);
+
+        writel(USBCMD_RESET, USB_USBCMD);
+        while (cnt < LINK_RESET_TIMEOUT_USEC) {
+                if (!(readl(USB_USBCMD) & USBCMD_RESET))
+                        break;
+                udelay(1);
+                cnt++;
+        }
+        if (cnt >= LINK_RESET_TIMEOUT_USEC)
+                return -ETIMEDOUT;
+
+        /* select ULPI phy */
+        writel(0x80000000, USB_PORTSC);
+
+        msleep(100);
+
+        writel(0x0, USB_AHBBURST);
+        writel(0x00, USB_AHBMODE);
+
+        if (pdata->otg_control == OTG_PHY_CONTROL) {
+                val = readl(USB_OTGSC);
+                if (pdata->mode == USB_OTG) {
+                        ulpi_val = ULPI_INT_IDGRD | ULPI_INT_SESS_VALID;
+                        val |= OTGSC_IDIE | OTGSC_BSVIE;
+                } else if (pdata->mode == USB_PERIPHERAL) {
+                        ulpi_val = ULPI_INT_SESS_VALID;
+                        val |= OTGSC_BSVIE;
+                }
+                writel(val, USB_OTGSC);
+                ulpi_write(otg, ulpi_val, ULPI_USB_INT_EN_RISE);
+                ulpi_write(otg, ulpi_val, ULPI_USB_INT_EN_FALL);
+        }
+
+        return 0;
+}
+
+#define PHY_SUSPEND_TIMEOUT_USEC        (500 * 1000)
+#define PHY_RESUME_TIMEOUT_USEC (100 * 1000)
+
+#ifdef CONFIG_PM_SLEEP
+static int msm_otg_suspend(struct msm_otg *motg)
+{
+        struct otg_transceiver *otg = &motg->otg;
+        struct usb_bus *bus = otg->host;
+        struct msm_otg_platform_data *pdata = motg->pdata;
+        int cnt = 0;
+
+        if (atomic_read(&motg->in_lpm))
+                return 0;
+
+        disable_irq(motg->irq);
+        /*
+         * Chipidea 45-nm PHY suspend sequence:
+         *
+         * Interrupt Latch Register auto-clear feature is not present
+         * in all PHY versions. Latch register is clear on read type.
+         * Clear latch register to avoid spurious wakeup from
+         * low power mode (LPM).
+         *
+         * PHY comparators are disabled when PHY enters into low power
+         * mode (LPM). Keep PHY comparators ON in LPM only when we expect
+         * VBUS/Id notifications from USB PHY. Otherwise turn off USB
+         * PHY comparators. This save significant amount of power.
+         *
+         * PLL is not turned off when PHY enters into low power mode (LPM).
+         * Disable PLL for maximum power savings.
+         */
+
+        if (motg->pdata->phy_type == CI_45NM_INTEGRATED_PHY) {
+                ulpi_read(otg, 0x14);
+                if (pdata->otg_control == OTG_PHY_CONTROL)
+                        ulpi_write(otg, 0x01, 0x30);
+                ulpi_write(otg, 0x08, 0x09);
+        }
+
+        /*
+         * PHY may take some time or even fail to enter into low power
+         * mode (LPM). Hence poll for 500 msec and reset the PHY and link
+         * in failure case.
+         */
+        writel(readl(USB_PORTSC) | PORTSC_PHCD, USB_PORTSC);
+        while (cnt < PHY_SUSPEND_TIMEOUT_USEC) {
+                if (readl(USB_PORTSC) & PORTSC_PHCD)
+                        break;
+                udelay(1);
+                cnt++;
+        }
+
+        if (cnt >= PHY_SUSPEND_TIMEOUT_USEC) {
+                dev_err(otg->dev, "Unable to suspend PHY\n");
+                msm_otg_reset(otg);
+                enable_irq(motg->irq);
+                return -ETIMEDOUT;
+        }
+
+        /*
+         * PHY has capability to generate interrupt asynchronously in low
+         * power mode (LPM). This interrupt is level triggered. So USB IRQ
+         * line must be disabled till async interrupt enable bit is cleared
+         * in USBCMD register. Assert STP (ULPI interface STOP signal) to
+         * block data communication from PHY.
+         */
+        writel(readl(USB_USBCMD) | ASYNC_INTR_CTRL | ULPI_STP_CTRL, USB_USBCMD);
+
+        if (motg->pdata->phy_type == SNPS_28NM_INTEGRATED_PHY &&
+                        motg->pdata->otg_control == OTG_PMIC_CONTROL)
+                writel(readl(USB_PHY_CTRL) | PHY_RETEN, USB_PHY_CTRL);
+
+        clk_disable(motg->pclk);
+        clk_disable(motg->clk);
+        if (motg->core_clk)
+                clk_disable(motg->core_clk);
+
+        if (!IS_ERR(motg->pclk_src))
+                clk_disable(motg->pclk_src);
+
+        if (motg->pdata->phy_type == SNPS_28NM_INTEGRATED_PHY &&
+                        motg->pdata->otg_control == OTG_PMIC_CONTROL) {
+                msm_hsusb_ldo_set_mode(0);
+                msm_hsusb_config_vddcx(0);
+        }
+
+        if (device_may_wakeup(otg->dev))
+                enable_irq_wake(motg->irq);
+        if (bus)
+                clear_bit(HCD_FLAG_HW_ACCESSIBLE, &(bus_to_hcd(bus))->flags);
+
+        atomic_set(&motg->in_lpm, 1);
+        enable_irq(motg->irq);
+
+        dev_info(otg->dev, "USB in low power mode\n");
+
+        return 0;
+}
+
+static int msm_otg_resume(struct msm_otg *motg)
+{
+        struct otg_transceiver *otg = &motg->otg;
+        struct usb_bus *bus = otg->host;
+        int cnt = 0;
+        unsigned temp;
+
+        if (!atomic_read(&motg->in_lpm))
+                return 0;
+
+        if (!IS_ERR(motg->pclk_src))
+                clk_enable(motg->pclk_src);
+
+        clk_enable(motg->pclk);
+        clk_enable(motg->clk);
+        if (motg->core_clk)
+                clk_enable(motg->core_clk);
+
+        if (motg->pdata->phy_type == SNPS_28NM_INTEGRATED_PHY &&
+                        motg->pdata->otg_control == OTG_PMIC_CONTROL) {
+                msm_hsusb_ldo_set_mode(1);
+                msm_hsusb_config_vddcx(1);
+                writel(readl(USB_PHY_CTRL) & ~PHY_RETEN, USB_PHY_CTRL);
+        }
+
+        temp = readl(USB_USBCMD);
+        temp &= ~ASYNC_INTR_CTRL;
+        temp &= ~ULPI_STP_CTRL;
+        writel(temp, USB_USBCMD);
+
+        /*
+         * PHY comes out of low power mode (LPM) in case of wakeup
+         * from asynchronous interrupt.
+         */
+        if (!(readl(USB_PORTSC) & PORTSC_PHCD))
+                goto skip_phy_resume;
+
+        writel(readl(USB_PORTSC) & ~PORTSC_PHCD, USB_PORTSC);
+        while (cnt < PHY_RESUME_TIMEOUT_USEC) {
+                if (!(readl(USB_PORTSC) & PORTSC_PHCD))
+                        break;
+                udelay(1);
+                cnt++;
+        }
+
+        if (cnt >= PHY_RESUME_TIMEOUT_USEC) {
+                /*
+                 * This is a fatal error. Reset the link and
+                 * PHY. USB state can not be restored. Re-insertion
+                 * of USB cable is the only way to get USB working.
+                 */
+                dev_err(otg->dev, "Unable to resume USB."
+                                "Re-plugin the cable\n");
+                msm_otg_reset(otg);
+        }
+
+skip_phy_resume:
+        if (device_may_wakeup(otg->dev))
+                disable_irq_wake(motg->irq);
+        if (bus)
+                set_bit(HCD_FLAG_HW_ACCESSIBLE, &(bus_to_hcd(bus))->flags);
+
+        atomic_set(&motg->in_lpm, 0);
+
+        if (motg->async_int) {
+                motg->async_int = 0;
+                pm_runtime_put(otg->dev);
+                enable_irq(motg->irq);
+        }
+
+        dev_info(otg->dev, "USB exited from low power mode\n");
+
+        return 0;
+}
+#endif
+
+static void msm_otg_notify_charger(struct msm_otg *motg, unsigned mA)
+{
+        if (motg->cur_power == mA)
+                return;
+
+        /* TODO: Notify PMIC about available current */
+        dev_info(motg->otg.dev, "Avail curr from USB = %u\n", mA);
+        motg->cur_power = mA;
+}
+
+static int msm_otg_set_power(struct otg_transceiver *otg, unsigned mA)
+{
+        struct msm_otg *motg = container_of(otg, struct msm_otg, otg);
+
+        /*
+         * Gadget driver uses set_power method to notify about the
+         * available current based on suspend/configured states.
+         *
+         * IDEV_CHG can be drawn irrespective of suspend/un-configured
+         * states when CDP/ACA is connected.
+         */
+        if (motg->chg_type == USB_SDP_CHARGER)
+                msm_otg_notify_charger(motg, mA);
+
+        return 0;
+}
+
+static void msm_otg_start_host(struct otg_transceiver *otg, int on)
+{
+        struct msm_otg *motg = container_of(otg, struct msm_otg, otg);
+        struct msm_otg_platform_data *pdata = motg->pdata;
+        struct usb_hcd *hcd;
+
+        if (!otg->host)
+                return;
+
+        hcd = bus_to_hcd(otg->host);
+
+        if (on) {
+                dev_dbg(otg->dev, "host on\n");
+
+                if (pdata->vbus_power)
+                        pdata->vbus_power(1);
+                /*
+                 * Some boards have a switch cotrolled by gpio
+                 * to enable/disable internal HUB. Enable internal
+                 * HUB before kicking the host.
+                 */
+                if (pdata->setup_gpio)
+                        pdata->setup_gpio(OTG_STATE_A_HOST);
+#ifdef CONFIG_USB
+                usb_add_hcd(hcd, hcd->irq, IRQF_SHARED);
+#endif
+        } else {
+                dev_dbg(otg->dev, "host off\n");
+
+#ifdef CONFIG_USB
+                usb_remove_hcd(hcd);
+#endif
+                if (pdata->setup_gpio)
+                        pdata->setup_gpio(OTG_STATE_UNDEFINED);
+                if (pdata->vbus_power)
+                        pdata->vbus_power(0);
+        }
+}
+
+static int msm_otg_set_host(struct otg_transceiver *otg, struct usb_bus *host)
+{
+        struct msm_otg *motg = container_of(otg, struct msm_otg, otg);
+        struct usb_hcd *hcd;
+
+        /*
+         * Fail host registration if this board can support
+         * only peripheral configuration.
+         */
+        if (motg->pdata->mode == USB_PERIPHERAL) {
+                dev_info(otg->dev, "Host mode is not supported\n");
+                return -ENODEV;
+        }
+
+        if (!host) {
+                if (otg->state == OTG_STATE_A_HOST) {
+                        pm_runtime_get_sync(otg->dev);
+                        msm_otg_start_host(otg, 0);
+                        otg->host = NULL;
+                        otg->state = OTG_STATE_UNDEFINED;
+                        schedule_work(&motg->sm_work);
+                } else {
+                        otg->host = NULL;
+                }
+
+                return 0;
+        }
+
+        hcd = bus_to_hcd(host);
+        hcd->power_budget = motg->pdata->power_budget;
+
+        otg->host = host;
+        dev_dbg(otg->dev, "host driver registered w/ tranceiver\n");
+
+        /*
+         * Kick the state machine work, if peripheral is not supported
+         * or peripheral is already registered with us.
+         */
+        if (motg->pdata->mode == USB_HOST || otg->gadget) {
+                pm_runtime_get_sync(otg->dev);
+                schedule_work(&motg->sm_work);
+        }
+
+        return 0;
+}
+
+static void msm_otg_start_peripheral(struct otg_transceiver *otg, int on)
+{
+        struct msm_otg *motg = container_of(otg, struct msm_otg, otg);
+        struct msm_otg_platform_data *pdata = motg->pdata;
+
+        if (!otg->gadget)
+                return;
+
+        if (on) {
+                dev_dbg(otg->dev, "gadget on\n");
+                /*
+                 * Some boards have a switch cotrolled by gpio
+                 * to enable/disable internal HUB. Disable internal
+                 * HUB before kicking the gadget.
+                 */
+                if (pdata->setup_gpio)
+                        pdata->setup_gpio(OTG_STATE_B_PERIPHERAL);
+                usb_gadget_vbus_connect(otg->gadget);
+        } else {
+                dev_dbg(otg->dev, "gadget off\n");
+                usb_gadget_vbus_disconnect(otg->gadget);
+                if (pdata->setup_gpio)
+                        pdata->setup_gpio(OTG_STATE_UNDEFINED);
+        }
+
+}
+
+static int msm_otg_set_peripheral(struct otg_transceiver *otg,
+                        struct usb_gadget *gadget)
+{
+        struct msm_otg *motg = container_of(otg, struct msm_otg, otg);
+
+        /*
+         * Fail peripheral registration if this board can support
+         * only host configuration.
+         */
+        if (motg->pdata->mode == USB_HOST) {
+                dev_info(otg->dev, "Peripheral mode is not supported\n");
+                return -ENODEV;
+        }
+
+        if (!gadget) {
+                if (otg->state == OTG_STATE_B_PERIPHERAL) {
+                        pm_runtime_get_sync(otg->dev);
+                        msm_otg_start_peripheral(otg, 0);
+                        otg->gadget = NULL;
+                        otg->state = OTG_STATE_UNDEFINED;
+                        schedule_work(&motg->sm_work);
+                } else {
+                        otg->gadget = NULL;
+                }
+
+                return 0;
+        }
+        otg->gadget = gadget;
+        dev_dbg(otg->dev, "peripheral driver registered w/ tranceiver\n");
+
+        /*
+         * Kick the state machine work, if host is not supported
+         * or host is already registered with us.
+         */
+        if (motg->pdata->mode == USB_PERIPHERAL || otg->host) {
+                pm_runtime_get_sync(otg->dev);
+                schedule_work(&motg->sm_work);
+        }
+
+        return 0;
+}
+
+static bool msm_chg_check_secondary_det(struct msm_otg *motg)
+{
+        struct otg_transceiver *otg = &motg->otg;
+        u32 chg_det;
+        bool ret = false;
+
+        switch (motg->pdata->phy_type) {
+        case CI_45NM_INTEGRATED_PHY:
+                chg_det = ulpi_read(otg, 0x34);
+                ret = chg_det & (1 << 4);
+                break;
+        case SNPS_28NM_INTEGRATED_PHY:
+                chg_det = ulpi_read(otg, 0x87);
+                ret = chg_det & 1;
+                break;
+        default:
+                break;
+        }
+        return ret;
+}
+
+static void msm_chg_enable_secondary_det(struct msm_otg *motg)
+{
+        struct otg_transceiver *otg = &motg->otg;
+        u32 chg_det;
+
+        switch (motg->pdata->phy_type) {
+        case CI_45NM_INTEGRATED_PHY:
+                chg_det = ulpi_read(otg, 0x34);
+                /* Turn off charger block */
+                chg_det |= ~(1 << 1);
+                ulpi_write(otg, chg_det, 0x34);
+                udelay(20);
+                /* control chg block via ULPI */
+                chg_det &= ~(1 << 3);
+                ulpi_write(otg, chg_det, 0x34);
+                /* put it in host mode for enabling D- source */
+                chg_det &= ~(1 << 2);
+                ulpi_write(otg, chg_det, 0x34);
+                /* Turn on chg detect block */
+                chg_det &= ~(1 << 1);
+                ulpi_write(otg, chg_det, 0x34);
+                udelay(20);
+                /* enable chg detection */
+                chg_det &= ~(1 << 0);
+                ulpi_write(otg, chg_det, 0x34);
+                break;
+        case SNPS_28NM_INTEGRATED_PHY:
+                /*
+                 * Configure DM as current source, DP as current sink
+                 * and enable battery charging comparators.
+                 */
+                ulpi_write(otg, 0x8, 0x85);
+                ulpi_write(otg, 0x2, 0x85);
+                ulpi_write(otg, 0x1, 0x85);
+                break;
+        default:
+                break;
+        }
+}
+
+static bool msm_chg_check_primary_det(struct msm_otg *motg)
+{
+        struct otg_transceiver *otg = &motg->otg;
+        u32 chg_det;
+        bool ret = false;
+
+        switch (motg->pdata->phy_type) {
+        case CI_45NM_INTEGRATED_PHY:
+                chg_det = ulpi_read(otg, 0x34);
+                ret = chg_det & (1 << 4);
+                break;
+        case SNPS_28NM_INTEGRATED_PHY:
+                chg_det = ulpi_read(otg, 0x87);
+                ret = chg_det & 1;
+                break;
+        default:
+                break;
+        }
+        return ret;
+}
+
+static void msm_chg_enable_primary_det(struct msm_otg *motg)
+{
+        struct otg_transceiver *otg = &motg->otg;
+        u32 chg_det;
+
+        switch (motg->pdata->phy_type) {
+        case CI_45NM_INTEGRATED_PHY:
+                chg_det = ulpi_read(otg, 0x34);
+                /* enable chg detection */
+                chg_det &= ~(1 << 0);
+                ulpi_write(otg, chg_det, 0x34);
+                break;
+        case SNPS_28NM_INTEGRATED_PHY:
+                /*
+                 * Configure DP as current source, DM as current sink
+                 * and enable battery charging comparators.
+                 */
+                ulpi_write(otg, 0x2, 0x85);
+                ulpi_write(otg, 0x1, 0x85);
+                break;
+        default:
+                break;
+        }
+}
+
+static bool msm_chg_check_dcd(struct msm_otg *motg)
+{
+        struct otg_transceiver *otg = &motg->otg;
+        u32 line_state;
+        bool ret = false;
+
+        switch (motg->pdata->phy_type) {
+        case CI_45NM_INTEGRATED_PHY:
+                line_state = ulpi_read(otg, 0x15);
+                ret = !(line_state & 1);
+                break;
+        case SNPS_28NM_INTEGRATED_PHY:
+                line_state = ulpi_read(otg, 0x87);
+                ret = line_state & 2;
+                break;
+        default:
+                break;
+        }
+        return ret;
+}
+
+static void msm_chg_disable_dcd(struct msm_otg *motg)
+{
+        struct otg_transceiver *otg = &motg->otg;
+        u32 chg_det;
+
+        switch (motg->pdata->phy_type) {
+        case CI_45NM_INTEGRATED_PHY:
+                chg_det = ulpi_read(otg, 0x34);
+                chg_det &= ~(1 << 5);
+                ulpi_write(otg, chg_det, 0x34);
+                break;
+        case SNPS_28NM_INTEGRATED_PHY:
+                ulpi_write(otg, 0x10, 0x86);
+                break;
+        default:
+                break;
+        }
+}
+
+static void msm_chg_enable_dcd(struct msm_otg *motg)
+{
+        struct otg_transceiver *otg = &motg->otg;
+        u32 chg_det;
+
+        switch (motg->pdata->phy_type) {
+        case CI_45NM_INTEGRATED_PHY:
+                chg_det = ulpi_read(otg, 0x34);
+                /* Turn on D+ current source */
+                chg_det |= (1 << 5);
+                ulpi_write(otg, chg_det, 0x34);
+                break;
+        case SNPS_28NM_INTEGRATED_PHY:
+                /* Data contact detection enable */
+                ulpi_write(otg, 0x10, 0x85);
+                break;
+        default:
+                break;
+        }
+}
+
+static void msm_chg_block_on(struct msm_otg *motg)
+{
+        struct otg_transceiver *otg = &motg->otg;
+        u32 func_ctrl, chg_det;
+
+        /* put the controller in non-driving mode */
+        func_ctrl = ulpi_read(otg, ULPI_FUNC_CTRL);
+        func_ctrl &= ~ULPI_FUNC_CTRL_OPMODE_MASK;
+        func_ctrl |= ULPI_FUNC_CTRL_OPMODE_NONDRIVING;
+        ulpi_write(otg, func_ctrl, ULPI_FUNC_CTRL);
+
+        switch (motg->pdata->phy_type) {
+        case CI_45NM_INTEGRATED_PHY:
+                chg_det = ulpi_read(otg, 0x34);
+                /* control chg block via ULPI */
+                chg_det &= ~(1 << 3);
+                ulpi_write(otg, chg_det, 0x34);
+                /* Turn on chg detect block */
+                chg_det &= ~(1 << 1);
+                ulpi_write(otg, chg_det, 0x34);
+                udelay(20);
+                break;
+        case SNPS_28NM_INTEGRATED_PHY:
+                /* Clear charger detecting control bits */
+                ulpi_write(otg, 0x3F, 0x86);
+                /* Clear alt interrupt latch and enable bits */
+                ulpi_write(otg, 0x1F, 0x92);
+                ulpi_write(otg, 0x1F, 0x95);
+                udelay(100);
+                break;
+        default:
+                break;
+        }
+}
+
+static void msm_chg_block_off(struct msm_otg *motg)
+{
+        struct otg_transceiver *otg = &motg->otg;
+        u32 func_ctrl, chg_det;
+
+        switch (motg->pdata->phy_type) {
+        case CI_45NM_INTEGRATED_PHY:
+                chg_det = ulpi_read(otg, 0x34);
+                /* Turn off charger block */
+                chg_det |= ~(1 << 1);
+                ulpi_write(otg, chg_det, 0x34);
+                break;
+        case SNPS_28NM_INTEGRATED_PHY:
+                /* Clear charger detecting control bits */
+                ulpi_write(otg, 0x3F, 0x86);
+                /* Clear alt interrupt latch and enable bits */
+                ulpi_write(otg, 0x1F, 0x92);
+                ulpi_write(otg, 0x1F, 0x95);
+                break;
+        default:
+                break;
+        }
+
+        /* put the controller in normal mode */
+        func_ctrl = ulpi_read(otg, ULPI_FUNC_CTRL);
+        func_ctrl &= ~ULPI_FUNC_CTRL_OPMODE_MASK;
+        func_ctrl |= ULPI_FUNC_CTRL_OPMODE_NORMAL;
+        ulpi_write(otg, func_ctrl, ULPI_FUNC_CTRL);
+}
+
+#define MSM_CHG_DCD_POLL_TIME           (100 * HZ/1000) /* 100 msec */
+#define MSM_CHG_DCD_MAX_RETRIES         6 /* Tdcd_tmout = 6 * 100 msec */
+#define MSM_CHG_PRIMARY_DET_TIME        (40 * HZ/1000) /* TVDPSRC_ON */
+#define MSM_CHG_SECONDARY_DET_TIME      (40 * HZ/1000) /* TVDMSRC_ON */
+static void msm_chg_detect_work(struct work_struct *w)
+{
+        struct msm_otg *motg = container_of(w, struct msm_otg, chg_work.work);
+        struct otg_transceiver *otg = &motg->otg;
+        bool is_dcd, tmout, vout;
+        unsigned long delay;
+
+        dev_dbg(otg->dev, "chg detection work\n");
+        switch (motg->chg_state) {
+        case USB_CHG_STATE_UNDEFINED:
+                pm_runtime_get_sync(otg->dev);
+                msm_chg_block_on(motg);
+                msm_chg_enable_dcd(motg);
+                motg->chg_state = USB_CHG_STATE_WAIT_FOR_DCD;
+                motg->dcd_retries = 0;
+                delay = MSM_CHG_DCD_POLL_TIME;
+                break;
+        case USB_CHG_STATE_WAIT_FOR_DCD:
+                is_dcd = msm_chg_check_dcd(motg);
+                tmout = ++motg->dcd_retries == MSM_CHG_DCD_MAX_RETRIES;
+                if (is_dcd || tmout) {
+                        msm_chg_disable_dcd(motg);
+                        msm_chg_enable_primary_det(motg);
+                        delay = MSM_CHG_PRIMARY_DET_TIME;
+                        motg->chg_state = USB_CHG_STATE_DCD_DONE;
+                } else {
+                        delay = MSM_CHG_DCD_POLL_TIME;
+                }
+                break;
+        case USB_CHG_STATE_DCD_DONE:
+                vout = msm_chg_check_primary_det(motg);
+                if (vout) {
+                        msm_chg_enable_secondary_det(motg);
+                        delay = MSM_CHG_SECONDARY_DET_TIME;
+                        motg->chg_state = USB_CHG_STATE_PRIMARY_DONE;
+                } else {
+                        motg->chg_type = USB_SDP_CHARGER;
+                        motg->chg_state = USB_CHG_STATE_DETECTED;
+                        delay = 0;
+                }
+                break;
+        case USB_CHG_STATE_PRIMARY_DONE:
+                vout = msm_chg_check_secondary_det(motg);
+                if (vout)
+                        motg->chg_type = USB_DCP_CHARGER;
+                else
+                        motg->chg_type = USB_CDP_CHARGER;
+                motg->chg_state = USB_CHG_STATE_SECONDARY_DONE;
+                /* fall through */
+        case USB_CHG_STATE_SECONDARY_DONE:
+                motg->chg_state = USB_CHG_STATE_DETECTED;
+        case USB_CHG_STATE_DETECTED:
+                msm_chg_block_off(motg);
+                dev_dbg(otg->dev, "charger = %d\n", motg->chg_type);
+                schedule_work(&motg->sm_work);
+                return;
+        default:
+                return;
+        }
+
+        schedule_delayed_work(&motg->chg_work, delay);
+}
+
+/*
+ * We support OTG, Peripheral only and Host only configurations. In case
+ * of OTG, mode switch (host-->peripheral/peripheral-->host) can happen
+ * via Id pin status or user request (debugfs). Id/BSV interrupts are not
+ * enabled when switch is controlled by user and default mode is supplied
+ * by board file, which can be changed by userspace later.
+ */
+static void msm_otg_init_sm(struct msm_otg *motg)
+{
+        struct msm_otg_platform_data *pdata = motg->pdata;
+        u32 otgsc = readl(USB_OTGSC);
+
+        switch (pdata->mode) {
+        case USB_OTG:
+                if (pdata->otg_control == OTG_PHY_CONTROL) {
+                        if (otgsc & OTGSC_ID)
+                                set_bit(ID, &motg->inputs);
+                        else
+                                clear_bit(ID, &motg->inputs);
+
+                        if (otgsc & OTGSC_BSV)
+                                set_bit(B_SESS_VLD, &motg->inputs);
+                        else
+                                clear_bit(B_SESS_VLD, &motg->inputs);
+                } else if (pdata->otg_control == OTG_USER_CONTROL) {
+                        if (pdata->default_mode == USB_HOST) {
+                                clear_bit(ID, &motg->inputs);
+                        } else if (pdata->default_mode == USB_PERIPHERAL) {
+                                set_bit(ID, &motg->inputs);
+                                set_bit(B_SESS_VLD, &motg->inputs);
+                        } else {
+                                set_bit(ID, &motg->inputs);
+                                clear_bit(B_SESS_VLD, &motg->inputs);
+                        }
+                }
+                break;
+        case USB_HOST:
+                clear_bit(ID, &motg->inputs);
+                break;
+        case USB_PERIPHERAL:
+                set_bit(ID, &motg->inputs);
+                if (otgsc & OTGSC_BSV)
+                        set_bit(B_SESS_VLD, &motg->inputs);
+                else
+                        clear_bit(B_SESS_VLD, &motg->inputs);
+                break;
+        default:
+                break;
+        }
+}
+
+static void msm_otg_sm_work(struct work_struct *w)
+{
+        struct msm_otg *motg = container_of(w, struct msm_otg, sm_work);
+        struct otg_transceiver *otg = &motg->otg;
+
+        switch (otg->state) {
+        case OTG_STATE_UNDEFINED:
+                dev_dbg(otg->dev, "OTG_STATE_UNDEFINED state\n");
+                msm_otg_reset(otg);
+                msm_otg_init_sm(motg);
+                otg->state = OTG_STATE_B_IDLE;
+                /* FALL THROUGH */
+        case OTG_STATE_B_IDLE:
+                dev_dbg(otg->dev, "OTG_STATE_B_IDLE state\n");
+                if (!test_bit(ID, &motg->inputs) && otg->host) {
+                        /* disable BSV bit */
+                        writel(readl(USB_OTGSC) & ~OTGSC_BSVIE, USB_OTGSC);
+                        msm_otg_start_host(otg, 1);
+                        otg->state = OTG_STATE_A_HOST;
+                } else if (test_bit(B_SESS_VLD, &motg->inputs)) {
+                        switch (motg->chg_state) {
+                        case USB_CHG_STATE_UNDEFINED:
+                                msm_chg_detect_work(&motg->chg_work.work);
+                                break;
+                        case USB_CHG_STATE_DETECTED:
+                                switch (motg->chg_type) {
+                                case USB_DCP_CHARGER:
+                                        msm_otg_notify_charger(motg,
+                                                        IDEV_CHG_MAX);
+                                        break;
+                                case USB_CDP_CHARGER:
+                                        msm_otg_notify_charger(motg,
+                                                        IDEV_CHG_MAX);
+                                        msm_otg_start_peripheral(otg, 1);
+                                        otg->state = OTG_STATE_B_PERIPHERAL;
+                                        break;
+                                case USB_SDP_CHARGER:
+                                        msm_otg_notify_charger(motg, IUNIT);
+                                        msm_otg_start_peripheral(otg, 1);
+                                        otg->state = OTG_STATE_B_PERIPHERAL;
+                                        break;
+                                default:
+                                        break;
+                                }
+                                break;
+                        default:
+                                break;
+                        }
+                } else {
+                        /*
+                         * If charger detection work is pending, decrement
+                         * the pm usage counter to balance with the one that
+                         * is incremented in charger detection work.
+                         */
+                        if (cancel_delayed_work_sync(&motg->chg_work)) {
+                                pm_runtime_put_sync(otg->dev);
+                                msm_otg_reset(otg);
+                        }
+                        msm_otg_notify_charger(motg, 0);
+                        motg->chg_state = USB_CHG_STATE_UNDEFINED;
+                        motg->chg_type = USB_INVALID_CHARGER;
+                }
+                pm_runtime_put_sync(otg->dev);
+                break;
+        case OTG_STATE_B_PERIPHERAL:
+                dev_dbg(otg->dev, "OTG_STATE_B_PERIPHERAL state\n");
+                if (!test_bit(B_SESS_VLD, &motg->inputs) ||
+                                !test_bit(ID, &motg->inputs)) {
+                        msm_otg_notify_charger(motg, 0);
+                        msm_otg_start_peripheral(otg, 0);
+                        motg->chg_state = USB_CHG_STATE_UNDEFINED;
+                        motg->chg_type = USB_INVALID_CHARGER;
+                        otg->state = OTG_STATE_B_IDLE;
+                        msm_otg_reset(otg);
+                        schedule_work(w);
+                }
+                break;
+        case OTG_STATE_A_HOST:
+                dev_dbg(otg->dev, "OTG_STATE_A_HOST state\n");
+                if (test_bit(ID, &motg->inputs)) {
+                        msm_otg_start_host(otg, 0);
+                        otg->state = OTG_STATE_B_IDLE;
+                        msm_otg_reset(otg);
+                        schedule_work(w);
+                }
+                break;
+        default:
+                break;
+        }
+}
+
+static irqreturn_t msm_otg_irq(int irq, void *data)
+{
+        struct msm_otg *motg = data;
+        struct otg_transceiver *otg = &motg->otg;
+        u32 otgsc = 0;
+
+        if (atomic_read(&motg->in_lpm)) {
+                disable_irq_nosync(irq);
+                motg->async_int = 1;
+                pm_runtime_get(otg->dev);
+                return IRQ_HANDLED;
+        }
+
+        otgsc = readl(USB_OTGSC);
+        if (!(otgsc & (OTGSC_IDIS | OTGSC_BSVIS)))
+                return IRQ_NONE;
+
+        if ((otgsc & OTGSC_IDIS) && (otgsc & OTGSC_IDIE)) {
+                if (otgsc & OTGSC_ID)
+                        set_bit(ID, &motg->inputs);
+                else
+                        clear_bit(ID, &motg->inputs);
+                dev_dbg(otg->dev, "ID set/clear\n");
+                pm_runtime_get_noresume(otg->dev);
+        } else if ((otgsc & OTGSC_BSVIS) && (otgsc & OTGSC_BSVIE)) {
+                if (otgsc & OTGSC_BSV)
+                        set_bit(B_SESS_VLD, &motg->inputs);
+                else
+                        clear_bit(B_SESS_VLD, &motg->inputs);
+                dev_dbg(otg->dev, "BSV set/clear\n");
+                pm_runtime_get_noresume(otg->dev);
+        }
+
+        writel(otgsc, USB_OTGSC);
+        schedule_work(&motg->sm_work);
+        return IRQ_HANDLED;
+}
+
+static int msm_otg_mode_show(struct seq_file *s, void *unused)
+{
+        struct msm_otg *motg = s->private;
+        struct otg_transceiver *otg = &motg->otg;
+
+        switch (otg->state) {
+        case OTG_STATE_A_HOST:
+                seq_printf(s, "host\n");
+                break;
+        case OTG_STATE_B_PERIPHERAL:
+                seq_printf(s, "peripheral\n");
+                break;
+        default:
+                seq_printf(s, "none\n");
+                break;
+        }
+
+        return 0;
+}
+
+static int msm_otg_mode_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, msm_otg_mode_show, inode->i_private);
+}
+
+static ssize_t msm_otg_mode_write(struct file *file, const char __user *ubuf,
+                                size_t count, loff_t *ppos)
+{
+        struct seq_file *s = file->private_data;
+        struct msm_otg *motg = s->private;
+        char buf[16];
+        struct otg_transceiver *otg = &motg->otg;
+        int status = count;
+        enum usb_mode_type req_mode;
+
+        memset(buf, 0x00, sizeof(buf));
+
+        if (copy_from_user(&buf, ubuf, min_t(size_t, sizeof(buf) - 1, count))) {
+                status = -EFAULT;
+                goto out;
+        }
+
+        if (!strncmp(buf, "host", 4)) {
+                req_mode = USB_HOST;
+        } else if (!strncmp(buf, "peripheral", 10)) {
+                req_mode = USB_PERIPHERAL;
+        } else if (!strncmp(buf, "none", 4)) {
+                req_mode = USB_NONE;
+        } else {
+                status = -EINVAL;
+                goto out;
+        }
+
+        switch (req_mode) {
+        case USB_NONE:
+                switch (otg->state) {
+                case OTG_STATE_A_HOST:
+                case OTG_STATE_B_PERIPHERAL:
+                        set_bit(ID, &motg->inputs);
+                        clear_bit(B_SESS_VLD, &motg->inputs);
+                        break;
+                default:
+                        goto out;
+                }
+                break;
+        case USB_PERIPHERAL:
+                switch (otg->state) {
+                case OTG_STATE_B_IDLE:
+                case OTG_STATE_A_HOST:
+                        set_bit(ID, &motg->inputs);
+                        set_bit(B_SESS_VLD, &motg->inputs);
+                        break;
+                default:
+                        goto out;
+                }
+                break;
+        case USB_HOST:
+                switch (otg->state) {
+                case OTG_STATE_B_IDLE:
+                case OTG_STATE_B_PERIPHERAL:
+                        clear_bit(ID, &motg->inputs);
+                        break;
+                default:
+                        goto out;
+                }
+                break;
+        default:
+                goto out;
+        }
+
+        pm_runtime_get_sync(otg->dev);
+        schedule_work(&motg->sm_work);
+out:
+        return status;
+}
+
+const struct file_operations msm_otg_mode_fops = {
+        .open = msm_otg_mode_open,
+        .read = seq_read,
+        .write = msm_otg_mode_write,
+        .llseek = seq_lseek,
+        .release = single_release,
+};
+
+static struct dentry *msm_otg_dbg_root;
+static struct dentry *msm_otg_dbg_mode;
+
+static int msm_otg_debugfs_init(struct msm_otg *motg)
+{
+        msm_otg_dbg_root = debugfs_create_dir("msm_otg", NULL);
+
+        if (!msm_otg_dbg_root || IS_ERR(msm_otg_dbg_root))
+                return -ENODEV;
+
+        msm_otg_dbg_mode = debugfs_create_file("mode", S_IRUGO | S_IWUSR,
+                                msm_otg_dbg_root, motg, &msm_otg_mode_fops);
+        if (!msm_otg_dbg_mode) {
+                debugfs_remove(msm_otg_dbg_root);
+                msm_otg_dbg_root = NULL;
+                return -ENODEV;
+        }
+
+        return 0;
+}
+
+static void msm_otg_debugfs_cleanup(void)
+{
+        debugfs_remove(msm_otg_dbg_mode);
+        debugfs_remove(msm_otg_dbg_root);
+}
+
+static int __init msm_otg_probe(struct platform_device *pdev)
+{
+        int ret = 0;
+        struct resource *res;
+        struct msm_otg *motg;
+        struct otg_transceiver *otg;
+
+        dev_info(&pdev->dev, "msm_otg probe\n");
+        if (!pdev->dev.platform_data) {
+                dev_err(&pdev->dev, "No platform data given. Bailing out\n");
+                return -ENODEV;
+        }
+
+        motg = kzalloc(sizeof(struct msm_otg), GFP_KERNEL);
+        if (!motg) {
+                dev_err(&pdev->dev, "unable to allocate msm_otg\n");
+                return -ENOMEM;
+        }
+
+        motg->pdata = pdev->dev.platform_data;
+        otg = &motg->otg;
+        otg->dev = &pdev->dev;
+
+        motg->phy_reset_clk = clk_get(&pdev->dev, "usb_phy_clk");
+        if (IS_ERR(motg->phy_reset_clk)) {
+                dev_err(&pdev->dev, "failed to get usb_phy_clk\n");
+                ret = PTR_ERR(motg->phy_reset_clk);
+                goto free_motg;
+        }
+
+        motg->clk = clk_get(&pdev->dev, "usb_hs_clk");
+        if (IS_ERR(motg->clk)) {
+                dev_err(&pdev->dev, "failed to get usb_hs_clk\n");
+                ret = PTR_ERR(motg->clk);
+                goto put_phy_reset_clk;
+        }
+        clk_set_rate(motg->clk, 60000000);
+
+        /*
+         * If USB Core is running its protocol engine based on CORE CLK,
+         * CORE CLK  must be running at >55Mhz for correct HSUSB
+         * operation and USB core cannot tolerate frequency changes on
+         * CORE CLK. For such USB cores, vote for maximum clk frequency
+         * on pclk source
+         */
+         if (motg->pdata->pclk_src_name) {
+                motg->pclk_src = clk_get(&pdev->dev,
+                        motg->pdata->pclk_src_name);
+                if (IS_ERR(motg->pclk_src))
+                        goto put_clk;
+                clk_set_rate(motg->pclk_src, INT_MAX);
+                clk_enable(motg->pclk_src);
+        } else
+                motg->pclk_src = ERR_PTR(-ENOENT);
+
+
+        motg->pclk = clk_get(&pdev->dev, "usb_hs_pclk");
+        if (IS_ERR(motg->pclk)) {
+                dev_err(&pdev->dev, "failed to get usb_hs_pclk\n");
+                ret = PTR_ERR(motg->pclk);
+                goto put_pclk_src;
+        }
+
+        /*
+         * USB core clock is not present on all MSM chips. This
+         * clock is introduced to remove the dependency on AXI
+         * bus frequency.
+         */
+        motg->core_clk = clk_get(&pdev->dev, "usb_hs_core_clk");
+        if (IS_ERR(motg->core_clk))
+                motg->core_clk = NULL;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(&pdev->dev, "failed to get platform resource mem\n");
+                ret = -ENODEV;
+                goto put_core_clk;
+        }
+
+        motg->regs = ioremap(res->start, resource_size(res));
+        if (!motg->regs) {
+                dev_err(&pdev->dev, "ioremap failed\n");
+                ret = -ENOMEM;
+                goto put_core_clk;
+        }
+        dev_info(&pdev->dev, "OTG regs = %p\n", motg->regs);
+
+        motg->irq = platform_get_irq(pdev, 0);
+        if (!motg->irq) {
+                dev_err(&pdev->dev, "platform_get_irq failed\n");
+                ret = -ENODEV;
+                goto free_regs;
+        }
+
+        clk_enable(motg->clk);
+        clk_enable(motg->pclk);
+
+        ret = msm_hsusb_init_vddcx(motg, 1);
+        if (ret) {
+                dev_err(&pdev->dev, "hsusb vddcx configuration failed\n");
+                goto free_regs;
+        }
+
+        ret = msm_hsusb_ldo_init(motg, 1);
+        if (ret) {
+                dev_err(&pdev->dev, "hsusb vreg configuration failed\n");
+                goto vddcx_exit;
+        }
+        ret = msm_hsusb_ldo_set_mode(1);
+        if (ret) {
+                dev_err(&pdev->dev, "hsusb vreg enable failed\n");
+                goto ldo_exit;
+        }
+
+        if (motg->core_clk)
+                clk_enable(motg->core_clk);
+
+        writel(0, USB_USBINTR);
+        writel(0, USB_OTGSC);
+
+        INIT_WORK(&motg->sm_work, msm_otg_sm_work);
+        INIT_DELAYED_WORK(&motg->chg_work, msm_chg_detect_work);
+        ret = request_irq(motg->irq, msm_otg_irq, IRQF_SHARED,
+                                        "msm_otg", motg);
+        if (ret) {
+                dev_err(&pdev->dev, "request irq failed\n");
+                goto disable_clks;
+        }
+
+        otg->init = msm_otg_reset;
+        otg->set_host = msm_otg_set_host;
+        otg->set_peripheral = msm_otg_set_peripheral;
+        otg->set_power = msm_otg_set_power;
+
+        otg->io_ops = &msm_otg_io_ops;
+
+        ret = otg_set_transceiver(&motg->otg);
+        if (ret) {
+                dev_err(&pdev->dev, "otg_set_transceiver failed\n");
+                goto free_irq;
+        }
+
+        platform_set_drvdata(pdev, motg);
+        device_init_wakeup(&pdev->dev, 1);
+
+        if (motg->pdata->mode == USB_OTG &&
+                        motg->pdata->otg_control == OTG_USER_CONTROL) {
+                ret = msm_otg_debugfs_init(motg);
+                if (ret)
+                        dev_dbg(&pdev->dev, "mode debugfs file is"
+                                        "not available\n");
+        }
+
+        pm_runtime_set_active(&pdev->dev);
+        pm_runtime_enable(&pdev->dev);
+
+        return 0;
+free_irq:
+        free_irq(motg->irq, motg);
+disable_clks:
+        clk_disable(motg->pclk);
+        clk_disable(motg->clk);
+ldo_exit:
+        msm_hsusb_ldo_init(motg, 0);
+vddcx_exit:
+        msm_hsusb_init_vddcx(motg, 0);
+free_regs:
+        iounmap(motg->regs);
+put_core_clk:
+        if (motg->core_clk)
+                clk_put(motg->core_clk);
+        clk_put(motg->pclk);
+put_pclk_src:
+        if (!IS_ERR(motg->pclk_src)) {
+                clk_disable(motg->pclk_src);
+                clk_put(motg->pclk_src);
+        }
+put_clk:
+        clk_put(motg->clk);
+put_phy_reset_clk:
+        clk_put(motg->phy_reset_clk);
+free_motg:
+        kfree(motg);
+        return ret;
+}
+
+static int __devexit msm_otg_remove(struct platform_device *pdev)
+{
+        struct msm_otg *motg = platform_get_drvdata(pdev);
+        struct otg_transceiver *otg = &motg->otg;
+        int cnt = 0;
+
+        if (otg->host || otg->gadget)
+                return -EBUSY;
+
+        msm_otg_debugfs_cleanup();
+        cancel_delayed_work_sync(&motg->chg_work);
+        cancel_work_sync(&motg->sm_work);
+
+        pm_runtime_resume(&pdev->dev);
+
+        device_init_wakeup(&pdev->dev, 0);
+        pm_runtime_disable(&pdev->dev);
+
+        otg_set_transceiver(NULL);
+        free_irq(motg->irq, motg);
+
+        /*
+         * Put PHY in low power mode.
+         */
+        ulpi_read(otg, 0x14);
+        ulpi_write(otg, 0x08, 0x09);
+
+        writel(readl(USB_PORTSC) | PORTSC_PHCD, USB_PORTSC);
+        while (cnt < PHY_SUSPEND_TIMEOUT_USEC) {
+                if (readl(USB_PORTSC) & PORTSC_PHCD)
+                        break;
+                udelay(1);
+                cnt++;
+        }
+        if (cnt >= PHY_SUSPEND_TIMEOUT_USEC)
+                dev_err(otg->dev, "Unable to suspend PHY\n");
+
+        clk_disable(motg->pclk);
+        clk_disable(motg->clk);
+        if (motg->core_clk)
+                clk_disable(motg->core_clk);
+        if (!IS_ERR(motg->pclk_src)) {
+                clk_disable(motg->pclk_src);
+                clk_put(motg->pclk_src);
+        }
+        msm_hsusb_ldo_init(motg, 0);
+
+        iounmap(motg->regs);
+        pm_runtime_set_suspended(&pdev->dev);
+
+        clk_put(motg->phy_reset_clk);
+        clk_put(motg->pclk);
+        clk_put(motg->clk);
+        if (motg->core_clk)
+                clk_put(motg->core_clk);
+
+        kfree(motg);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM_RUNTIME
+static int msm_otg_runtime_idle(struct device *dev)
+{
+        struct msm_otg *motg = dev_get_drvdata(dev);
+        struct otg_transceiver *otg = &motg->otg;
+
+        dev_dbg(dev, "OTG runtime idle\n");
+
+        /*
+         * It is observed some times that a spurious interrupt
+         * comes when PHY is put into LPM immediately after PHY reset.
+         * This 1 sec delay also prevents entering into LPM immediately
+         * after asynchronous interrupt.
+         */
+        if (otg->state != OTG_STATE_UNDEFINED)
+                pm_schedule_suspend(dev, 1000);
+
+        return -EAGAIN;
+}
+
+static int msm_otg_runtime_suspend(struct device *dev)
+{
+        struct msm_otg *motg = dev_get_drvdata(dev);
+
+        dev_dbg(dev, "OTG runtime suspend\n");
+        return msm_otg_suspend(motg);
+}
+
+static int msm_otg_runtime_resume(struct device *dev)
+{
+        struct msm_otg *motg = dev_get_drvdata(dev);
+
+        dev_dbg(dev, "OTG runtime resume\n");
+        return msm_otg_resume(motg);
+}
+#endif
+
+#ifdef CONFIG_PM_SLEEP
+static int msm_otg_pm_suspend(struct device *dev)
+{
+        struct msm_otg *motg = dev_get_drvdata(dev);
+
+        dev_dbg(dev, "OTG PM suspend\n");
+        return msm_otg_suspend(motg);
+}
+
+static int msm_otg_pm_resume(struct device *dev)
+{
+        struct msm_otg *motg = dev_get_drvdata(dev);
+        int ret;
+
+        dev_dbg(dev, "OTG PM resume\n");
+
+        ret = msm_otg_resume(motg);
+        if (ret)
+                return ret;
+
+        /*
+         * Runtime PM Documentation recommends bringing the
+         * device to full powered state upon resume.
+         */
+        pm_runtime_disable(dev);
+        pm_runtime_set_active(dev);
+        pm_runtime_enable(dev);
+
+        return 0;
+}
+#endif
+
+#ifdef CONFIG_PM
+static const struct dev_pm_ops msm_otg_dev_pm_ops = {
+        SET_SYSTEM_SLEEP_PM_OPS(msm_otg_pm_suspend, msm_otg_pm_resume)
+        SET_RUNTIME_PM_OPS(msm_otg_runtime_suspend, msm_otg_runtime_resume,
+                                msm_otg_runtime_idle)
+};
+#endif
+
+static struct platform_driver msm_otg_driver = {
+        .remove = __devexit_p(msm_otg_remove),
+        .driver = {
+                .name = DRIVER_NAME,
+                .owner = THIS_MODULE,
+#ifdef CONFIG_PM
+                .pm = &msm_otg_dev_pm_ops,
+#endif
+        },
+};
+
+static int __init msm_otg_init(void)
+{
+        return platform_driver_probe(&msm_otg_driver, msm_otg_probe);
+}
+
+static void __exit msm_otg_exit(void)
+{
+        platform_driver_unregister(&msm_otg_driver);
+}
+
+module_init(msm_otg_init);
+module_exit(msm_otg_exit);
+
+MODULE_LICENSE("GPL v2");
+MODULE_DESCRIPTION("MSM USB transceiver driver");
diff --git a/drivers/usb/otg/nop-usb-xceiv.c b/drivers/usb/otg/nop-usb-xceiv.c
index e70014ab0976..c1e360046435 100644
--- a/drivers/usb/otg/nop-usb-xceiv.c
+++ b/drivers/usb/otg/nop-usb-xceiv.c
@@ -132,6 +132,8 @@ static int __devinit nop_usb_xceiv_probe(struct platform_device *pdev)
 
         platform_set_drvdata(pdev, nop);
 
+        ATOMIC_INIT_NOTIFIER_HEAD(&nop->otg.notifier);
+
         return 0;
 exit:
         kfree(nop);
diff --git a/drivers/usb/otg/otg.c b/drivers/usb/otg/otg.c
index 0a43a7db750f..fb7adeff9ffa 100644
--- a/drivers/usb/otg/otg.c
+++ b/drivers/usb/otg/otg.c
@@ -64,3 +64,38 @@ int otg_set_transceiver(struct otg_transceiver *x)
         return 0;
 }
 EXPORT_SYMBOL(otg_set_transceiver);
+
+const char *otg_state_string(enum usb_otg_state state)
+{
+        switch (state) {
+        case OTG_STATE_A_IDLE:
+                return "a_idle";
+        case OTG_STATE_A_WAIT_VRISE:
+                return "a_wait_vrise";
+        case OTG_STATE_A_WAIT_BCON:
+                return "a_wait_bcon";
+        case OTG_STATE_A_HOST:
+                return "a_host";
+        case OTG_STATE_A_SUSPEND:
+                return "a_suspend";
+        case OTG_STATE_A_PERIPHERAL:
+                return "a_peripheral";
+        case OTG_STATE_A_WAIT_VFALL:
+                return "a_wait_vfall";
+        case OTG_STATE_A_VBUS_ERR:
+                return "a_vbus_err";
+        case OTG_STATE_B_IDLE:
+                return "b_idle";
+        case OTG_STATE_B_SRP_INIT:
+                return "b_srp_init";
+        case OTG_STATE_B_PERIPHERAL:
+                return "b_peripheral";
+        case OTG_STATE_B_WAIT_ACON:
+                return "b_wait_acon";
+        case OTG_STATE_B_HOST:
+                return "b_host";
+        default:
+                return "UNDEFINED";
+        }
+}
+EXPORT_SYMBOL(otg_state_string);
diff --git a/drivers/usb/otg/otg_fsm.c b/drivers/usb/otg/otg_fsm.c
new file mode 100644
index 000000000000..b0cc422f2ff9
--- /dev/null
+++ b/drivers/usb/otg/otg_fsm.c
@@ -0,0 +1,349 @@
+/*
+ * OTG Finite State Machine from OTG spec
+ *
+ * Copyright (C) 2007,2008 Freescale Semiconductor, Inc.
+ *
+ * Author:      Li Yang <LeoLi@freescale.com>
+ *              Jerry Huang <Chang-Ming.Huang@freescale.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 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.
+ */
+
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/spinlock.h>
+#include <linux/delay.h>
+#include <linux/usb.h>
+#include <linux/usb/gadget.h>
+#include <linux/usb/otg.h>
+#include <linux/types.h>
+
+#include "otg_fsm.h"
+
+/* Change USB protocol when there is a protocol change */
+static int otg_set_protocol(struct otg_fsm *fsm, int protocol)
+{
+        int ret = 0;
+
+        if (fsm->protocol != protocol) {
+                VDBG("Changing role fsm->protocol= %d; new protocol= %d\n",
+                        fsm->protocol, protocol);
+                /* stop old protocol */
+                if (fsm->protocol == PROTO_HOST)
+                        ret = fsm->ops->start_host(fsm, 0);
+                else if (fsm->protocol == PROTO_GADGET)
+                        ret = fsm->ops->start_gadget(fsm, 0);
+                if (ret)
+                        return ret;
+
+                /* start new protocol */
+                if (protocol == PROTO_HOST)
+                        ret = fsm->ops->start_host(fsm, 1);
+                else if (protocol == PROTO_GADGET)
+                        ret = fsm->ops->start_gadget(fsm, 1);
+                if (ret)
+                        return ret;
+
+                fsm->protocol = protocol;
+                return 0;
+        }
+
+        return 0;
+}
+
+static int state_changed;
+
+/* Called when leaving a state.  Do state clean up jobs here */
+void otg_leave_state(struct otg_fsm *fsm, enum usb_otg_state old_state)
+{
+        switch (old_state) {
+        case OTG_STATE_B_IDLE:
+                otg_del_timer(fsm, b_se0_srp_tmr);
+                fsm->b_se0_srp = 0;
+                break;
+        case OTG_STATE_B_SRP_INIT:
+                fsm->b_srp_done = 0;
+                break;
+        case OTG_STATE_B_PERIPHERAL:
+                break;
+        case OTG_STATE_B_WAIT_ACON:
+                otg_del_timer(fsm, b_ase0_brst_tmr);
+                fsm->b_ase0_brst_tmout = 0;
+                break;
+        case OTG_STATE_B_HOST:
+                break;
+        case OTG_STATE_A_IDLE:
+                break;
+        case OTG_STATE_A_WAIT_VRISE:
+                otg_del_timer(fsm, a_wait_vrise_tmr);
+                fsm->a_wait_vrise_tmout = 0;
+                break;
+        case OTG_STATE_A_WAIT_BCON:
+                otg_del_timer(fsm, a_wait_bcon_tmr);
+                fsm->a_wait_bcon_tmout = 0;
+                break;
+        case OTG_STATE_A_HOST:
+                otg_del_timer(fsm, a_wait_enum_tmr);
+                break;
+        case OTG_STATE_A_SUSPEND:
+                otg_del_timer(fsm, a_aidl_bdis_tmr);
+                fsm->a_aidl_bdis_tmout = 0;
+                fsm->a_suspend_req = 0;
+                break;
+        case OTG_STATE_A_PERIPHERAL:
+                break;
+        case OTG_STATE_A_WAIT_VFALL:
+                otg_del_timer(fsm, a_wait_vrise_tmr);
+                break;
+        case OTG_STATE_A_VBUS_ERR:
+                break;
+        default:
+                break;
+        }
+}
+
+/* Called when entering a state */
+int otg_set_state(struct otg_fsm *fsm, enum usb_otg_state new_state)
+{
+        state_changed = 1;
+        if (fsm->transceiver->state == new_state)
+                return 0;
+        VDBG("Set state: %s\n", otg_state_string(new_state));
+        otg_leave_state(fsm, fsm->transceiver->state);
+        switch (new_state) {
+        case OTG_STATE_B_IDLE:
+                otg_drv_vbus(fsm, 0);
+                otg_chrg_vbus(fsm, 0);
+                otg_loc_conn(fsm, 0);
+                otg_loc_sof(fsm, 0);
+                otg_set_protocol(fsm, PROTO_UNDEF);
+                otg_add_timer(fsm, b_se0_srp_tmr);
+                break;
+        case OTG_STATE_B_SRP_INIT:
+                otg_start_pulse(fsm);
+                otg_loc_sof(fsm, 0);
+                otg_set_protocol(fsm, PROTO_UNDEF);
+                otg_add_timer(fsm, b_srp_fail_tmr);
+                break;
+        case OTG_STATE_B_PERIPHERAL:
+                otg_chrg_vbus(fsm, 0);
+                otg_loc_conn(fsm, 1);
+                otg_loc_sof(fsm, 0);
+                otg_set_protocol(fsm, PROTO_GADGET);
+                break;
+        case OTG_STATE_B_WAIT_ACON:
+                otg_chrg_vbus(fsm, 0);
+                otg_loc_conn(fsm, 0);
+                otg_loc_sof(fsm, 0);
+                otg_set_protocol(fsm, PROTO_HOST);
+                otg_add_timer(fsm, b_ase0_brst_tmr);
+                fsm->a_bus_suspend = 0;
+                break;
+        case OTG_STATE_B_HOST:
+                otg_chrg_vbus(fsm, 0);
+                otg_loc_conn(fsm, 0);
+                otg_loc_sof(fsm, 1);
+                otg_set_protocol(fsm, PROTO_HOST);
+                usb_bus_start_enum(fsm->transceiver->host,
+                                fsm->transceiver->host->otg_port);
+                break;
+        case OTG_STATE_A_IDLE:
+                otg_drv_vbus(fsm, 0);
+                otg_chrg_vbus(fsm, 0);
+                otg_loc_conn(fsm, 0);
+                otg_loc_sof(fsm, 0);
+                otg_set_protocol(fsm, PROTO_HOST);
+                break;
+        case OTG_STATE_A_WAIT_VRISE:
+                otg_drv_vbus(fsm, 1);
+                otg_loc_conn(fsm, 0);
+                otg_loc_sof(fsm, 0);
+                otg_set_protocol(fsm, PROTO_HOST);
+                otg_add_timer(fsm, a_wait_vrise_tmr);
+                break;
+        case OTG_STATE_A_WAIT_BCON:
+                otg_drv_vbus(fsm, 1);
+                otg_loc_conn(fsm, 0);
+                otg_loc_sof(fsm, 0);
+                otg_set_protocol(fsm, PROTO_HOST);
+                otg_add_timer(fsm, a_wait_bcon_tmr);
+                break;
+        case OTG_STATE_A_HOST:
+                otg_drv_vbus(fsm, 1);
+                otg_loc_conn(fsm, 0);
+                otg_loc_sof(fsm, 1);
+                otg_set_protocol(fsm, PROTO_HOST);
+                /*
+                 * When HNP is triggered while a_bus_req = 0, a_host will
+                 * suspend too fast to complete a_set_b_hnp_en
+                 */
+                if (!fsm->a_bus_req || fsm->a_suspend_req)
+                        otg_add_timer(fsm, a_wait_enum_tmr);
+                break;
+        case OTG_STATE_A_SUSPEND:
+                otg_drv_vbus(fsm, 1);
+                otg_loc_conn(fsm, 0);
+                otg_loc_sof(fsm, 0);
+                otg_set_protocol(fsm, PROTO_HOST);
+                otg_add_timer(fsm, a_aidl_bdis_tmr);
+
+                break;
+        case OTG_STATE_A_PERIPHERAL:
+                otg_loc_conn(fsm, 1);
+                otg_loc_sof(fsm, 0);
+                otg_set_protocol(fsm, PROTO_GADGET);
+                otg_drv_vbus(fsm, 1);
+                break;
+        case OTG_STATE_A_WAIT_VFALL:
+                otg_drv_vbus(fsm, 0);
+                otg_loc_conn(fsm, 0);
+                otg_loc_sof(fsm, 0);
+                otg_set_protocol(fsm, PROTO_HOST);
+                break;
+        case OTG_STATE_A_VBUS_ERR:
+                otg_drv_vbus(fsm, 0);
+                otg_loc_conn(fsm, 0);
+                otg_loc_sof(fsm, 0);
+                otg_set_protocol(fsm, PROTO_UNDEF);
+                break;
+        default:
+                break;
+        }
+
+        fsm->transceiver->state = new_state;
+        return 0;
+}
+
+/* State change judgement */
+int otg_statemachine(struct otg_fsm *fsm)
+{
+        enum usb_otg_state state;
+        unsigned long flags;
+
+        spin_lock_irqsave(&fsm->lock, flags);
+
+        state = fsm->transceiver->state;
+        state_changed = 0;
+        /* State machine state change judgement */
+
+        switch (state) {
+        case OTG_STATE_UNDEFINED:
+                VDBG("fsm->id = %d\n", fsm->id);
+                if (fsm->id)
+                        otg_set_state(fsm, OTG_STATE_B_IDLE);
+                else
+                        otg_set_state(fsm, OTG_STATE_A_IDLE);
+                break;
+        case OTG_STATE_B_IDLE:
+                if (!fsm->id)
+                        otg_set_state(fsm, OTG_STATE_A_IDLE);
+                else if (fsm->b_sess_vld && fsm->transceiver->gadget)
+                        otg_set_state(fsm, OTG_STATE_B_PERIPHERAL);
+                else if (fsm->b_bus_req && fsm->b_sess_end && fsm->b_se0_srp)
+                        otg_set_state(fsm, OTG_STATE_B_SRP_INIT);
+                break;
+        case OTG_STATE_B_SRP_INIT:
+                if (!fsm->id || fsm->b_srp_done)
+                        otg_set_state(fsm, OTG_STATE_B_IDLE);
+                break;
+        case OTG_STATE_B_PERIPHERAL:
+                if (!fsm->id || !fsm->b_sess_vld)
+                        otg_set_state(fsm, OTG_STATE_B_IDLE);
+                else if (fsm->b_bus_req && fsm->transceiver->
+                                gadget->b_hnp_enable && fsm->a_bus_suspend)
+                        otg_set_state(fsm, OTG_STATE_B_WAIT_ACON);
+                break;
+        case OTG_STATE_B_WAIT_ACON:
+                if (fsm->a_conn)
+                        otg_set_state(fsm, OTG_STATE_B_HOST);
+                else if (!fsm->id || !fsm->b_sess_vld)
+                        otg_set_state(fsm, OTG_STATE_B_IDLE);
+                else if (fsm->a_bus_resume || fsm->b_ase0_brst_tmout) {
+                        fsm->b_ase0_brst_tmout = 0;
+                        otg_set_state(fsm, OTG_STATE_B_PERIPHERAL);
+                }
+                break;
+        case OTG_STATE_B_HOST:
+                if (!fsm->id || !fsm->b_sess_vld)
+                        otg_set_state(fsm, OTG_STATE_B_IDLE);
+                else if (!fsm->b_bus_req || !fsm->a_conn)
+                        otg_set_state(fsm, OTG_STATE_B_PERIPHERAL);
+                break;
+        case OTG_STATE_A_IDLE:
+                if (fsm->id)
+                        otg_set_state(fsm, OTG_STATE_B_IDLE);
+                else if (!fsm->a_bus_drop && (fsm->a_bus_req || fsm->a_srp_det))
+                        otg_set_state(fsm, OTG_STATE_A_WAIT_VRISE);
+                break;
+        case OTG_STATE_A_WAIT_VRISE:
+                if (fsm->id || fsm->a_bus_drop || fsm->a_vbus_vld ||
+                                fsm->a_wait_vrise_tmout) {
+                        otg_set_state(fsm, OTG_STATE_A_WAIT_BCON);
+                }
+                break;
+        case OTG_STATE_A_WAIT_BCON:
+                if (!fsm->a_vbus_vld)
+                        otg_set_state(fsm, OTG_STATE_A_VBUS_ERR);
+                else if (fsm->b_conn)
+                        otg_set_state(fsm, OTG_STATE_A_HOST);
+                else if (fsm->id | fsm->a_bus_drop | fsm->a_wait_bcon_tmout)
+                        otg_set_state(fsm, OTG_STATE_A_WAIT_VFALL);
+                break;
+        case OTG_STATE_A_HOST:
+                if ((!fsm->a_bus_req || fsm->a_suspend_req) &&
+                                fsm->transceiver->host->b_hnp_enable)
+                        otg_set_state(fsm, OTG_STATE_A_SUSPEND);
+                else if (fsm->id || !fsm->b_conn || fsm->a_bus_drop)
+                        otg_set_state(fsm, OTG_STATE_A_WAIT_BCON);
+                else if (!fsm->a_vbus_vld)
+                        otg_set_state(fsm, OTG_STATE_A_VBUS_ERR);
+                break;
+        case OTG_STATE_A_SUSPEND:
+                if (!fsm->b_conn && fsm->transceiver->host->b_hnp_enable)
+                        otg_set_state(fsm, OTG_STATE_A_PERIPHERAL);
+                else if (!fsm->b_conn && !fsm->transceiver->host->b_hnp_enable)
+                        otg_set_state(fsm, OTG_STATE_A_WAIT_BCON);
+                else if (fsm->a_bus_req || fsm->b_bus_resume)
+                        otg_set_state(fsm, OTG_STATE_A_HOST);
+                else if (fsm->id || fsm->a_bus_drop || fsm->a_aidl_bdis_tmout)
+                        otg_set_state(fsm, OTG_STATE_A_WAIT_VFALL);
+                else if (!fsm->a_vbus_vld)
+                        otg_set_state(fsm, OTG_STATE_A_VBUS_ERR);
+                break;
+        case OTG_STATE_A_PERIPHERAL:
+                if (fsm->id || fsm->a_bus_drop)
+                        otg_set_state(fsm, OTG_STATE_A_WAIT_VFALL);
+                else if (fsm->b_bus_suspend)
+                        otg_set_state(fsm, OTG_STATE_A_WAIT_BCON);
+                else if (!fsm->a_vbus_vld)
+                        otg_set_state(fsm, OTG_STATE_A_VBUS_ERR);
+                break;
+        case OTG_STATE_A_WAIT_VFALL:
+                if (fsm->id || fsm->a_bus_req || (!fsm->a_sess_vld &&
+                                        !fsm->b_conn))
+                        otg_set_state(fsm, OTG_STATE_A_IDLE);
+                break;
+        case OTG_STATE_A_VBUS_ERR:
+                if (fsm->id || fsm->a_bus_drop || fsm->a_clr_err)
+                        otg_set_state(fsm, OTG_STATE_A_WAIT_VFALL);
+                break;
+        default:
+                break;
+        }
+        spin_unlock_irqrestore(&fsm->lock, flags);
+
+        VDBG("quit statemachine, changed = %d\n", state_changed);
+        return state_changed;
+}
diff --git a/drivers/usb/otg/otg_fsm.h b/drivers/usb/otg/otg_fsm.h
new file mode 100644
index 000000000000..0cecf1d593a0
--- /dev/null
+++ b/drivers/usb/otg/otg_fsm.h
@@ -0,0 +1,154 @@
+/* Copyright (C) 2007,2008 Freescale Semiconductor, Inc.
+ *
+ * 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.
+ */
+
+#undef DEBUG
+#undef VERBOSE
+
+#ifdef DEBUG
+#define DBG(fmt, args...) printk(KERN_DEBUG "[%s]  " fmt , \
+                                 __func__, ## args)
+#else
+#define DBG(fmt, args...)       do {} while (0)
+#endif
+
+#ifdef VERBOSE
+#define VDBG            DBG
+#else
+#define VDBG(stuff...)  do {} while (0)
+#endif
+
+#ifdef VERBOSE
+#define MPC_LOC printk("Current Location [%s]:[%d]\n", __FILE__, __LINE__)
+#else
+#define MPC_LOC do {} while (0)
+#endif
+
+#define PROTO_UNDEF     (0)
+#define PROTO_HOST      (1)
+#define PROTO_GADGET    (2)
+
+/* OTG state machine according to the OTG spec */
+struct otg_fsm {
+        /* Input */
+        int a_bus_resume;
+        int a_bus_suspend;
+        int a_conn;
+        int a_sess_vld;
+        int a_srp_det;
+        int a_vbus_vld;
+        int b_bus_resume;
+        int b_bus_suspend;
+        int b_conn;
+        int b_se0_srp;
+        int b_sess_end;
+        int b_sess_vld;
+        int id;
+
+        /* Internal variables */
+        int a_set_b_hnp_en;
+        int b_srp_done;
+        int b_hnp_enable;
+
+        /* Timeout indicator for timers */
+        int a_wait_vrise_tmout;
+        int a_wait_bcon_tmout;
+        int a_aidl_bdis_tmout;
+        int b_ase0_brst_tmout;
+
+        /* Informative variables */
+        int a_bus_drop;
+        int a_bus_req;
+        int a_clr_err;
+        int a_suspend_req;
+        int b_bus_req;
+
+        /* Output */
+        int drv_vbus;
+        int loc_conn;
+        int loc_sof;
+
+        struct otg_fsm_ops *ops;
+        struct otg_transceiver *transceiver;
+
+        /* Current usb protocol used: 0:undefine; 1:host; 2:client */
+        int protocol;
+        spinlock_t lock;
+};
+
+struct otg_fsm_ops {
+        void    (*chrg_vbus)(int on);
+        void    (*drv_vbus)(int on);
+        void    (*loc_conn)(int on);
+        void    (*loc_sof)(int on);
+        void    (*start_pulse)(void);
+        void    (*add_timer)(void *timer);
+        void    (*del_timer)(void *timer);
+        int     (*start_host)(struct otg_fsm *fsm, int on);
+        int     (*start_gadget)(struct otg_fsm *fsm, int on);
+};
+
+
+static inline void otg_chrg_vbus(struct otg_fsm *fsm, int on)
+{
+        fsm->ops->chrg_vbus(on);
+}
+
+static inline void otg_drv_vbus(struct otg_fsm *fsm, int on)
+{
+        if (fsm->drv_vbus != on) {
+                fsm->drv_vbus = on;
+                fsm->ops->drv_vbus(on);
+        }
+}
+
+static inline void otg_loc_conn(struct otg_fsm *fsm, int on)
+{
+        if (fsm->loc_conn != on) {
+                fsm->loc_conn = on;
+                fsm->ops->loc_conn(on);
+        }
+}
+
+static inline void otg_loc_sof(struct otg_fsm *fsm, int on)
+{
+        if (fsm->loc_sof != on) {
+                fsm->loc_sof = on;
+                fsm->ops->loc_sof(on);
+        }
+}
+
+static inline void otg_start_pulse(struct otg_fsm *fsm)
+{
+        fsm->ops->start_pulse();
+}
+
+static inline void otg_add_timer(struct otg_fsm *fsm, void *timer)
+{
+        fsm->ops->add_timer(timer);
+}
+
+static inline void otg_del_timer(struct otg_fsm *fsm, void *timer)
+{
+        fsm->ops->del_timer(timer);
+}
+
+int otg_statemachine(struct otg_fsm *fsm);
+
+/* Defined by device specific driver, for different timer implementation */
+extern struct fsl_otg_timer *a_wait_vrise_tmr, *a_wait_bcon_tmr,
+        *a_aidl_bdis_tmr, *b_ase0_brst_tmr, *b_se0_srp_tmr, *b_srp_fail_tmr,
+        *a_wait_enum_tmr;
diff --git a/drivers/usb/otg/twl4030-usb.c b/drivers/usb/otg/twl4030-usb.c
index 0bc97698af15..efeb4d1517ff 100644
--- a/drivers/usb/otg/twl4030-usb.c
+++ b/drivers/usb/otg/twl4030-usb.c
@@ -124,7 +124,6 @@
 #define PHY_DPLL_CLK                    (1 << 0)
 
 /* In module TWL4030_MODULE_PM_MASTER */
-#define PROTECT_KEY                     0x0E
 #define STS_HW_CONDITIONS               0x0F
 
 /* In module TWL4030_MODULE_PM_RECEIVER */
@@ -161,6 +160,7 @@ struct twl4030_usb {
 
         int                     irq;
         u8                      linkstat;
+        bool                    vbus_supplied;
         u8                      asleep;
         bool                    irq_enabled;
 };
@@ -251,6 +251,8 @@ static enum usb_xceiv_events twl4030_usb_linkstat(struct twl4030_usb *twl)
         int     status;
         int     linkstat = USB_EVENT_NONE;
 
+        twl->vbus_supplied = false;
+
         /*
          * For ID/VBUS sensing, see manual section 15.4.8 ...
          * except when using only battery backup power, two
@@ -266,6 +268,9 @@ static enum usb_xceiv_events twl4030_usb_linkstat(struct twl4030_usb *twl)
         if (status < 0)
                 dev_err(twl->dev, "USB link status err %d\n", status);
         else if (status & (BIT(7) | BIT(2))) {
+                if (status & (BIT(7)))
+                        twl->vbus_supplied = true;
+
                 if (status & BIT(2))
                         linkstat = USB_EVENT_ID;
                 else
@@ -276,6 +281,8 @@ static enum usb_xceiv_events twl4030_usb_linkstat(struct twl4030_usb *twl)
         dev_dbg(twl->dev, "HW_CONDITIONS 0x%02x/%d; link %d\n",
                         status, status, linkstat);
 
+        twl->otg.last_event = linkstat;
+
         /* REVISIT this assumes host and peripheral controllers
          * are registered, and that both are active...
          */
@@ -418,8 +425,13 @@ static void twl4030_phy_resume(struct twl4030_usb *twl)
 static int twl4030_usb_ldo_init(struct twl4030_usb *twl)
 {
         /* Enable writing to power configuration registers */
-        twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, 0xC0, PROTECT_KEY);
-        twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, 0x0C, PROTECT_KEY);
+        twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER,
+                        TWL4030_PM_MASTER_KEY_CFG1,
+                        TWL4030_PM_MASTER_PROTECT_KEY);
+
+        twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER,
+                        TWL4030_PM_MASTER_KEY_CFG2,
+                        TWL4030_PM_MASTER_PROTECT_KEY);
 
         /* Keep VUSB3V1 LDO in sleep state until VBUS/ID change detected*/
         /*twl_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0, VUSB_DEDICATED2);*/
@@ -455,7 +467,8 @@ static int twl4030_usb_ldo_init(struct twl4030_usb *twl)
         twl_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0, VUSB1V8_TYPE);
 
         /* disable access to power configuration registers */
-        twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, 0, PROTECT_KEY);
+        twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, 0,
+                        TWL4030_PM_MASTER_PROTECT_KEY);
 
         return 0;
 
@@ -477,7 +490,7 @@ static ssize_t twl4030_usb_vbus_show(struct device *dev,
 
         spin_lock_irqsave(&twl->lock, flags);
         ret = sprintf(buf, "%s\n",
-                        (twl->linkstat == USB_EVENT_VBUS) ? "on" : "off");
+                        twl->vbus_supplied ? "on" : "off");
         spin_unlock_irqrestore(&twl->lock, flags);
 
         return ret;
@@ -507,7 +520,7 @@ static irqreturn_t twl4030_usb_irq(int irq, void *_twl)
                 else
                         twl4030_phy_resume(twl);
 
-                blocking_notifier_call_chain(&twl->otg.notifier, status,
+                atomic_notifier_call_chain(&twl->otg.notifier, status,
                                 twl->otg.gadget);
         }
         sysfs_notify(&twl->dev->kobj, NULL, "vbus");
@@ -529,7 +542,7 @@ static void twl4030_usb_phy_init(struct twl4030_usb *twl)
                         twl->asleep = 0;
                 }
 
-                blocking_notifier_call_chain(&twl->otg.notifier, status,
+                atomic_notifier_call_chain(&twl->otg.notifier, status,
                                 twl->otg.gadget);
         }
         sysfs_notify(&twl->dev->kobj, NULL, "vbus");
@@ -601,6 +614,7 @@ static int __devinit twl4030_usb_probe(struct platform_device *pdev)
         twl->otg.set_peripheral = twl4030_set_peripheral;
         twl->otg.set_suspend    = twl4030_set_suspend;
         twl->usb_mode           = pdata->usb_mode;
+        twl->vbus_supplied      = false;
         twl->asleep = 1;
 
         /* init spinlock for workqueue */
@@ -618,7 +632,7 @@ static int __devinit twl4030_usb_probe(struct platform_device *pdev)
         if (device_create_file(&pdev->dev, &dev_attr_vbus))
                 dev_warn(&pdev->dev, "could not create sysfs file\n");
 
-        BLOCKING_INIT_NOTIFIER_HEAD(&twl->otg.notifier);
+        ATOMIC_INIT_NOTIFIER_HEAD(&twl->otg.notifier);
 
         /* Our job is to use irqs and status from the power module
          * to keep the transceiver disabled when nothing's connected.
@@ -673,7 +687,8 @@ static int __exit twl4030_usb_remove(struct platform_device *pdev)
         /* disable complete OTG block */
         twl4030_usb_clear_bits(twl, POWER_CTRL, POWER_CTRL_OTG_ENAB);
 
-        twl4030_phy_power(twl, 0);
+        if (!twl->asleep)
+                twl4030_phy_power(twl, 0);
         regulator_put(twl->usb1v5);
         regulator_put(twl->usb1v8);
         regulator_put(twl->usb3v1);
diff --git a/drivers/usb/otg/twl6030-usb.c b/drivers/usb/otg/twl6030-usb.c
new file mode 100644
index 000000000000..cfb5aa72b196
--- /dev/null
+++ b/drivers/usb/otg/twl6030-usb.c
@@ -0,0 +1,526 @@
+/*
+ * twl6030_usb - TWL6030 USB transceiver, talking to OMAP OTG driver.
+ *
+ * Copyright (C) 2010 Texas Instruments Incorporated - http://www.ti.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
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Author: Hema HK <hemahk@ti.com>
+ *
+ * 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.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+#include <linux/io.h>
+#include <linux/usb/otg.h>
+#include <linux/i2c/twl.h>
+#include <linux/regulator/consumer.h>
+#include <linux/err.h>
+#include <linux/notifier.h>
+#include <linux/slab.h>
+#include <linux/delay.h>
+
+/* usb register definitions */
+#define USB_VENDOR_ID_LSB               0x00
+#define USB_VENDOR_ID_MSB               0x01
+#define USB_PRODUCT_ID_LSB              0x02
+#define USB_PRODUCT_ID_MSB              0x03
+#define USB_VBUS_CTRL_SET               0x04
+#define USB_VBUS_CTRL_CLR               0x05
+#define USB_ID_CTRL_SET                 0x06
+#define USB_ID_CTRL_CLR                 0x07
+#define USB_VBUS_INT_SRC                0x08
+#define USB_VBUS_INT_LATCH_SET          0x09
+#define USB_VBUS_INT_LATCH_CLR          0x0A
+#define USB_VBUS_INT_EN_LO_SET          0x0B
+#define USB_VBUS_INT_EN_LO_CLR          0x0C
+#define USB_VBUS_INT_EN_HI_SET          0x0D
+#define USB_VBUS_INT_EN_HI_CLR          0x0E
+#define USB_ID_INT_SRC                  0x0F
+#define USB_ID_INT_LATCH_SET            0x10
+#define USB_ID_INT_LATCH_CLR            0x11
+
+#define USB_ID_INT_EN_LO_SET            0x12
+#define USB_ID_INT_EN_LO_CLR            0x13
+#define USB_ID_INT_EN_HI_SET            0x14
+#define USB_ID_INT_EN_HI_CLR            0x15
+#define USB_OTG_ADP_CTRL                0x16
+#define USB_OTG_ADP_HIGH                0x17
+#define USB_OTG_ADP_LOW                 0x18
+#define USB_OTG_ADP_RISE                0x19
+#define USB_OTG_REVISION                0x1A
+
+/* to be moved to LDO */
+#define TWL6030_MISC2                   0xE5
+#define TWL6030_CFG_LDO_PD2             0xF5
+#define TWL6030_BACKUP_REG              0xFA
+
+#define STS_HW_CONDITIONS               0x21
+
+/* In module TWL6030_MODULE_PM_MASTER */
+#define STS_HW_CONDITIONS               0x21
+#define STS_USB_ID                      BIT(2)
+
+/* In module TWL6030_MODULE_PM_RECEIVER */
+#define VUSB_CFG_TRANS                  0x71
+#define VUSB_CFG_STATE                  0x72
+#define VUSB_CFG_VOLTAGE                0x73
+
+/* in module TWL6030_MODULE_MAIN_CHARGE */
+
+#define CHARGERUSB_CTRL1                0x8
+
+#define CONTROLLER_STAT1                0x03
+#define VBUS_DET                        BIT(2)
+
+struct twl6030_usb {
+        struct otg_transceiver  otg;
+        struct device           *dev;
+
+        /* for vbus reporting with irqs disabled */
+        spinlock_t              lock;
+
+        struct regulator                *usb3v3;
+
+        int                     irq1;
+        int                     irq2;
+        u8                      linkstat;
+        u8                      asleep;
+        bool                    irq_enabled;
+        unsigned long           features;
+};
+
+#define xceiv_to_twl(x)         container_of((x), struct twl6030_usb, otg)
+
+/*-------------------------------------------------------------------------*/
+
+static inline int twl6030_writeb(struct twl6030_usb *twl, u8 module,
+                                                u8 data, u8 address)
+{
+        int ret = 0;
+
+        ret = twl_i2c_write_u8(module, data, address);
+        if (ret < 0)
+                dev_err(twl->dev,
+                        "Write[0x%x] Error %d\n", address, ret);
+        return ret;
+}
+
+static inline u8 twl6030_readb(struct twl6030_usb *twl, u8 module, u8 address)
+{
+        u8 data, ret = 0;
+
+        ret = twl_i2c_read_u8(module, &data, address);
+        if (ret >= 0)
+                ret = data;
+        else
+                dev_err(twl->dev,
+                        "readb[0x%x,0x%x] Error %d\n",
+                                        module, address, ret);
+        return ret;
+}
+
+/*-------------------------------------------------------------------------*/
+static int twl6030_set_phy_clk(struct otg_transceiver *x, int on)
+{
+        struct twl6030_usb *twl;
+        struct device *dev;
+        struct twl4030_usb_data *pdata;
+
+        twl = xceiv_to_twl(x);
+        dev  = twl->dev;
+        pdata = dev->platform_data;
+
+        pdata->phy_set_clock(twl->dev, on);
+
+        return 0;
+}
+
+static int twl6030_phy_init(struct otg_transceiver *x)
+{
+        struct twl6030_usb *twl;
+        struct device *dev;
+        struct twl4030_usb_data *pdata;
+
+        twl = xceiv_to_twl(x);
+        dev  = twl->dev;
+        pdata = dev->platform_data;
+
+        if (twl->linkstat == USB_EVENT_ID)
+                pdata->phy_power(twl->dev, 1, 1);
+        else
+                pdata->phy_power(twl->dev, 0, 1);
+
+        return 0;
+}
+
+static void twl6030_phy_shutdown(struct otg_transceiver *x)
+{
+        struct twl6030_usb *twl;
+        struct device *dev;
+        struct twl4030_usb_data *pdata;
+
+        twl = xceiv_to_twl(x);
+        dev  = twl->dev;
+        pdata = dev->platform_data;
+        pdata->phy_power(twl->dev, 0, 0);
+}
+
+static int twl6030_phy_suspend(struct otg_transceiver *x, int suspend)
+{
+        struct twl6030_usb *twl = xceiv_to_twl(x);
+        struct device *dev = twl->dev;
+        struct twl4030_usb_data *pdata = dev->platform_data;
+
+        pdata->phy_suspend(dev, suspend);
+
+        return 0;
+}
+
+static int twl6030_start_srp(struct otg_transceiver *x)
+{
+        struct twl6030_usb *twl = xceiv_to_twl(x);
+
+        twl6030_writeb(twl, TWL_MODULE_USB, 0x24, USB_VBUS_CTRL_SET);
+        twl6030_writeb(twl, TWL_MODULE_USB, 0x84, USB_VBUS_CTRL_SET);
+
+        mdelay(100);
+        twl6030_writeb(twl, TWL_MODULE_USB, 0xa0, USB_VBUS_CTRL_CLR);
+
+        return 0;
+}
+
+static int twl6030_usb_ldo_init(struct twl6030_usb *twl)
+{
+        char *regulator_name;
+
+        if (twl->features & TWL6025_SUBCLASS)
+                regulator_name = "ldousb";
+        else
+                regulator_name = "vusb";
+
+        /* Set to OTG_REV 1.3 and turn on the ID_WAKEUP_COMP */
+        twl6030_writeb(twl, TWL6030_MODULE_ID0 , 0x1, TWL6030_BACKUP_REG);
+
+        /* Program CFG_LDO_PD2 register and set VUSB bit */
+        twl6030_writeb(twl, TWL6030_MODULE_ID0 , 0x1, TWL6030_CFG_LDO_PD2);
+
+        /* Program MISC2 register and set bit VUSB_IN_VBAT */
+        twl6030_writeb(twl, TWL6030_MODULE_ID0 , 0x10, TWL6030_MISC2);
+
+        twl->usb3v3 = regulator_get(twl->dev, regulator_name);
+        if (IS_ERR(twl->usb3v3))
+                return -ENODEV;
+
+        /* Program the USB_VBUS_CTRL_SET and set VBUS_ACT_COMP bit */
+        twl6030_writeb(twl, TWL_MODULE_USB, 0x4, USB_VBUS_CTRL_SET);
+
+        /*
+         * Program the USB_ID_CTRL_SET register to enable GND drive
+         * and the ID comparators
+         */
+        twl6030_writeb(twl, TWL_MODULE_USB, 0x14, USB_ID_CTRL_SET);
+
+        return 0;
+}
+
+static ssize_t twl6030_usb_vbus_show(struct device *dev,
+                        struct device_attribute *attr, char *buf)
+{
+        struct twl6030_usb *twl = dev_get_drvdata(dev);
+        unsigned long flags;
+        int ret = -EINVAL;
+
+        spin_lock_irqsave(&twl->lock, flags);
+
+        switch (twl->linkstat) {
+        case USB_EVENT_VBUS:
+               ret = snprintf(buf, PAGE_SIZE, "vbus\n");
+               break;
+        case USB_EVENT_ID:
+               ret = snprintf(buf, PAGE_SIZE, "id\n");
+               break;
+        case USB_EVENT_NONE:
+               ret = snprintf(buf, PAGE_SIZE, "none\n");
+               break;
+        default:
+               ret = snprintf(buf, PAGE_SIZE, "UNKNOWN\n");
+        }
+        spin_unlock_irqrestore(&twl->lock, flags);
+
+        return ret;
+}
+static DEVICE_ATTR(vbus, 0444, twl6030_usb_vbus_show, NULL);
+
+static irqreturn_t twl6030_usb_irq(int irq, void *_twl)
+{
+        struct twl6030_usb *twl = _twl;
+        int status;
+        u8 vbus_state, hw_state;
+
+        hw_state = twl6030_readb(twl, TWL6030_MODULE_ID0, STS_HW_CONDITIONS);
+
+        vbus_state = twl6030_readb(twl, TWL_MODULE_MAIN_CHARGE,
+                                                CONTROLLER_STAT1);
+        if (!(hw_state & STS_USB_ID)) {
+                if (vbus_state & VBUS_DET) {
+                        regulator_enable(twl->usb3v3);
+                        twl->asleep = 1;
+                        status = USB_EVENT_VBUS;
+                        twl->otg.default_a = false;
+                        twl->otg.state = OTG_STATE_B_IDLE;
+                        twl->linkstat = status;
+                        twl->otg.last_event = status;
+                        atomic_notifier_call_chain(&twl->otg.notifier,
+                                                status, twl->otg.gadget);
+                } else {
+                        status = USB_EVENT_NONE;
+                        twl->linkstat = status;
+                        twl->otg.last_event = status;
+                        atomic_notifier_call_chain(&twl->otg.notifier,
+                                                status, twl->otg.gadget);
+                        if (twl->asleep) {
+                                regulator_disable(twl->usb3v3);
+                                twl->asleep = 0;
+                        }
+                }
+        }
+        sysfs_notify(&twl->dev->kobj, NULL, "vbus");
+
+        return IRQ_HANDLED;
+}
+
+static irqreturn_t twl6030_usbotg_irq(int irq, void *_twl)
+{
+        struct twl6030_usb *twl = _twl;
+        int status = USB_EVENT_NONE;
+        u8 hw_state;
+
+        hw_state = twl6030_readb(twl, TWL6030_MODULE_ID0, STS_HW_CONDITIONS);
+
+        if (hw_state & STS_USB_ID) {
+
+                regulator_enable(twl->usb3v3);
+                twl->asleep = 1;
+                twl6030_writeb(twl, TWL_MODULE_USB, USB_ID_INT_EN_HI_CLR, 0x1);
+                twl6030_writeb(twl, TWL_MODULE_USB, USB_ID_INT_EN_HI_SET,
+                                                                0x10);
+                status = USB_EVENT_ID;
+                twl->otg.default_a = true;
+                twl->otg.state = OTG_STATE_A_IDLE;
+                twl->linkstat = status;
+                twl->otg.last_event = status;
+                atomic_notifier_call_chain(&twl->otg.notifier, status,
+                                                        twl->otg.gadget);
+        } else  {
+                twl6030_writeb(twl, TWL_MODULE_USB, USB_ID_INT_EN_HI_CLR,
+                                                                0x10);
+                twl6030_writeb(twl, TWL_MODULE_USB, USB_ID_INT_EN_HI_SET,
+                                                                0x1);
+        }
+        twl6030_writeb(twl, TWL_MODULE_USB, USB_ID_INT_LATCH_CLR, status);
+
+        return IRQ_HANDLED;
+}
+
+static int twl6030_set_peripheral(struct otg_transceiver *x,
+                struct usb_gadget *gadget)
+{
+        struct twl6030_usb *twl;
+
+        if (!x)
+                return -ENODEV;
+
+        twl = xceiv_to_twl(x);
+        twl->otg.gadget = gadget;
+        if (!gadget)
+                twl->otg.state = OTG_STATE_UNDEFINED;
+
+        return 0;
+}
+
+static int twl6030_enable_irq(struct otg_transceiver *x)
+{
+        struct twl6030_usb *twl = xceiv_to_twl(x);
+
+        twl6030_writeb(twl, TWL_MODULE_USB, USB_ID_INT_EN_HI_SET, 0x1);
+        twl6030_interrupt_unmask(0x05, REG_INT_MSK_LINE_C);
+        twl6030_interrupt_unmask(0x05, REG_INT_MSK_STS_C);
+
+        twl6030_interrupt_unmask(TWL6030_CHARGER_CTRL_INT_MASK,
+                                REG_INT_MSK_LINE_C);
+        twl6030_interrupt_unmask(TWL6030_CHARGER_CTRL_INT_MASK,
+                                REG_INT_MSK_STS_C);
+        twl6030_usb_irq(twl->irq2, twl);
+        twl6030_usbotg_irq(twl->irq1, twl);
+
+        return 0;
+}
+
+static int twl6030_set_vbus(struct otg_transceiver *x, bool enabled)
+{
+        struct twl6030_usb *twl = xceiv_to_twl(x);
+
+        /*
+         * Start driving VBUS. Set OPA_MODE bit in CHARGERUSB_CTRL1
+         * register. This enables boost mode.
+         */
+        if (enabled)
+                twl6030_writeb(twl, TWL_MODULE_MAIN_CHARGE , 0x40,
+                                                CHARGERUSB_CTRL1);
+         else
+                twl6030_writeb(twl, TWL_MODULE_MAIN_CHARGE , 0x00,
+                                                CHARGERUSB_CTRL1);
+        return 0;
+}
+
+static int twl6030_set_host(struct otg_transceiver *x, struct usb_bus *host)
+{
+        struct twl6030_usb *twl;
+
+        if (!x)
+                return -ENODEV;
+
+        twl = xceiv_to_twl(x);
+        twl->otg.host = host;
+        if (!host)
+                twl->otg.state = OTG_STATE_UNDEFINED;
+        return 0;
+}
+
+static int __devinit twl6030_usb_probe(struct platform_device *pdev)
+{
+        struct twl6030_usb      *twl;
+        int                     status, err;
+        struct twl4030_usb_data *pdata;
+        struct device *dev = &pdev->dev;
+        pdata = dev->platform_data;
+
+        twl = kzalloc(sizeof *twl, GFP_KERNEL);
+        if (!twl)
+                return -ENOMEM;
+
+        twl->dev                = &pdev->dev;
+        twl->irq1               = platform_get_irq(pdev, 0);
+        twl->irq2               = platform_get_irq(pdev, 1);
+        twl->features           = pdata->features;
+        twl->otg.dev            = twl->dev;
+        twl->otg.label          = "twl6030";
+        twl->otg.set_host       = twl6030_set_host;
+        twl->otg.set_peripheral = twl6030_set_peripheral;
+        twl->otg.set_vbus       = twl6030_set_vbus;
+        twl->otg.init           = twl6030_phy_init;
+        twl->otg.shutdown       = twl6030_phy_shutdown;
+        twl->otg.set_suspend    = twl6030_phy_suspend;
+        twl->otg.start_srp      = twl6030_start_srp;
+
+        /* init spinlock for workqueue */
+        spin_lock_init(&twl->lock);
+
+        err = twl6030_usb_ldo_init(twl);
+        if (err) {
+                dev_err(&pdev->dev, "ldo init failed\n");
+                kfree(twl);
+                return err;
+        }
+        otg_set_transceiver(&twl->otg);
+
+        platform_set_drvdata(pdev, twl);
+        if (device_create_file(&pdev->dev, &dev_attr_vbus))
+                dev_warn(&pdev->dev, "could not create sysfs file\n");
+
+        ATOMIC_INIT_NOTIFIER_HEAD(&twl->otg.notifier);
+
+        twl->irq_enabled = true;
+        status = request_threaded_irq(twl->irq1, NULL, twl6030_usbotg_irq,
+                        IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
+                        "twl6030_usb", twl);
+        if (status < 0) {
+                dev_err(&pdev->dev, "can't get IRQ %d, err %d\n",
+                        twl->irq1, status);
+                device_remove_file(twl->dev, &dev_attr_vbus);
+                kfree(twl);
+                return status;
+        }
+
+        status = request_threaded_irq(twl->irq2, NULL, twl6030_usb_irq,
+                        IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
+                        "twl6030_usb", twl);
+        if (status < 0) {
+                dev_err(&pdev->dev, "can't get IRQ %d, err %d\n",
+                        twl->irq2, status);
+                free_irq(twl->irq1, twl);
+                device_remove_file(twl->dev, &dev_attr_vbus);
+                kfree(twl);
+                return status;
+        }
+
+        twl->asleep = 0;
+        pdata->phy_init(dev);
+        twl6030_phy_suspend(&twl->otg, 0);
+        twl6030_enable_irq(&twl->otg);
+        dev_info(&pdev->dev, "Initialized TWL6030 USB module\n");
+
+        return 0;
+}
+
+static int __exit twl6030_usb_remove(struct platform_device *pdev)
+{
+        struct twl6030_usb *twl = platform_get_drvdata(pdev);
+
+        struct twl4030_usb_data *pdata;
+        struct device *dev = &pdev->dev;
+        pdata = dev->platform_data;
+
+        twl6030_interrupt_mask(TWL6030_USBOTG_INT_MASK,
+                REG_INT_MSK_LINE_C);
+        twl6030_interrupt_mask(TWL6030_USBOTG_INT_MASK,
+                        REG_INT_MSK_STS_C);
+        free_irq(twl->irq1, twl);
+        free_irq(twl->irq2, twl);
+        regulator_put(twl->usb3v3);
+        pdata->phy_exit(twl->dev);
+        device_remove_file(twl->dev, &dev_attr_vbus);
+        kfree(twl);
+
+        return 0;
+}
+
+static struct platform_driver twl6030_usb_driver = {
+        .probe          = twl6030_usb_probe,
+        .remove         = __exit_p(twl6030_usb_remove),
+        .driver         = {
+                .name   = "twl6030_usb",
+                .owner  = THIS_MODULE,
+        },
+};
+
+static int __init twl6030_usb_init(void)
+{
+        return platform_driver_register(&twl6030_usb_driver);
+}
+subsys_initcall(twl6030_usb_init);
+
+static void __exit twl6030_usb_exit(void)
+{
+        platform_driver_unregister(&twl6030_usb_driver);
+}
+module_exit(twl6030_usb_exit);
+
+MODULE_ALIAS("platform:twl6030_usb");
+MODULE_AUTHOR("Hema HK <hemahk@ti.com>");
+MODULE_DESCRIPTION("TWL6030 USB transceiver driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/usb/otg/ulpi.c b/drivers/usb/otg/ulpi.c
index ccc81950822b..770d799d5afb 100644
--- a/drivers/usb/otg/ulpi.c
+++ b/drivers/usb/otg/ulpi.c
@@ -29,12 +29,23 @@
 #include <linux/usb/otg.h>
 #include <linux/usb/ulpi.h>
 
+
+struct ulpi_info {
+        unsigned int    id;
+        char            *name;
+};
+
 #define ULPI_ID(vendor, product) (((vendor) << 16) | (product))
+#define ULPI_INFO(_id, _name)           \
+        {                               \
+                .id     = (_id),        \
+                .name   = (_name),      \
+        }
 
 /* ULPI hardcoded IDs, used for probing */
-static unsigned int ulpi_ids[] = {
-        ULPI_ID(0x04cc, 0x1504),        /* NXP ISP1504 */
-        ULPI_ID(0x0424, 0x0006),        /* SMSC USB3319 */
+static struct ulpi_info ulpi_ids[] = {
+        ULPI_INFO(ULPI_ID(0x04cc, 0x1504), "NXP ISP1504"),
+        ULPI_INFO(ULPI_ID(0x0424, 0x0006), "SMSC USB331x"),
 };
 
 static int ulpi_set_otg_flags(struct otg_transceiver *otg)
@@ -137,6 +148,32 @@ static int ulpi_set_flags(struct otg_transceiver *otg)
         return ulpi_set_fc_flags(otg);
 }
 
+static int ulpi_check_integrity(struct otg_transceiver *otg)
+{
+        int ret, i;
+        unsigned int val = 0x55;
+
+        for (i = 0; i < 2; i++) {
+                ret = otg_io_write(otg, val, ULPI_SCRATCH);
+                if (ret < 0)
+                        return ret;
+
+                ret = otg_io_read(otg, ULPI_SCRATCH);
+                if (ret < 0)
+                        return ret;
+
+                if (ret != val) {
+                        pr_err("ULPI integrity check: failed!");
+                        return -ENODEV;
+                }
+                val = val << 1;
+        }
+
+        pr_info("ULPI integrity check: passed.\n");
+
+        return 0;
+}
+
 static int ulpi_init(struct otg_transceiver *otg)
 {
         int i, vid, pid, ret;
@@ -153,12 +190,19 @@ static int ulpi_init(struct otg_transceiver *otg)
 
         pr_info("ULPI transceiver vendor/product ID 0x%04x/0x%04x\n", vid, pid);
 
-        for (i = 0; i < ARRAY_SIZE(ulpi_ids); i++)
-                if (ulpi_ids[i] == ULPI_ID(vid, pid))
-                        return ulpi_set_flags(otg);
+        for (i = 0; i < ARRAY_SIZE(ulpi_ids); i++) {
+                if (ulpi_ids[i].id == ULPI_ID(vid, pid)) {
+                        pr_info("Found %s ULPI transceiver.\n",
+                                ulpi_ids[i].name);
+                        break;
+                }
+        }
+
+        ret = ulpi_check_integrity(otg);
+        if (ret)
+                return ret;
 
-        pr_err("ULPI ID does not match any known transceiver.\n");
-        return -ENODEV;
+        return ulpi_set_flags(otg);
 }
 
 static int ulpi_set_host(struct otg_transceiver *otg, struct usb_bus *host)
diff --git a/drivers/usb/otg/ulpi_viewport.c b/drivers/usb/otg/ulpi_viewport.c
new file mode 100644
index 000000000000..e9a37f90994f
--- /dev/null
+++ b/drivers/usb/otg/ulpi_viewport.c
@@ -0,0 +1,80 @@
+/*
+ * Copyright (C) 2011 Google, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * 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.
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/usb.h>
+#include <linux/io.h>
+#include <linux/usb/otg.h>
+#include <linux/usb/ulpi.h>
+
+#define ULPI_VIEW_WAKEUP        (1 << 31)
+#define ULPI_VIEW_RUN           (1 << 30)
+#define ULPI_VIEW_WRITE         (1 << 29)
+#define ULPI_VIEW_READ          (0 << 29)
+#define ULPI_VIEW_ADDR(x)       (((x) & 0xff) << 16)
+#define ULPI_VIEW_DATA_READ(x)  (((x) >> 8) & 0xff)
+#define ULPI_VIEW_DATA_WRITE(x) ((x) & 0xff)
+
+static int ulpi_viewport_wait(void __iomem *view, u32 mask)
+{
+        unsigned long usec = 2000;
+
+        while (usec--) {
+                if (!(readl(view) & mask))
+                        return 0;
+
+                udelay(1);
+        };
+
+        return -ETIMEDOUT;
+}
+
+static int ulpi_viewport_read(struct otg_transceiver *otg, u32 reg)
+{
+        int ret;
+        void __iomem *view = otg->io_priv;
+
+        writel(ULPI_VIEW_WAKEUP | ULPI_VIEW_WRITE, view);
+        ret = ulpi_viewport_wait(view, ULPI_VIEW_WAKEUP);
+        if (ret)
+                return ret;
+
+        writel(ULPI_VIEW_RUN | ULPI_VIEW_READ | ULPI_VIEW_ADDR(reg), view);
+        ret = ulpi_viewport_wait(view, ULPI_VIEW_RUN);
+        if (ret)
+                return ret;
+
+        return ULPI_VIEW_DATA_READ(readl(view));
+}
+
+static int ulpi_viewport_write(struct otg_transceiver *otg, u32 val, u32 reg)
+{
+        int ret;
+        void __iomem *view = otg->io_priv;
+
+        writel(ULPI_VIEW_WAKEUP | ULPI_VIEW_WRITE, view);
+        ret = ulpi_viewport_wait(view, ULPI_VIEW_WAKEUP);
+        if (ret)
+                return ret;
+
+        writel(ULPI_VIEW_RUN | ULPI_VIEW_WRITE | ULPI_VIEW_DATA_WRITE(val) |
+                                                 ULPI_VIEW_ADDR(reg), view);
+
+        return ulpi_viewport_wait(view, ULPI_VIEW_RUN);
+}
+
+struct otg_io_access_ops ulpi_viewport_access_ops = {
+        .read   = ulpi_viewport_read,
+        .write  = ulpi_viewport_write,
+};
diff --git a/drivers/usb/renesas_usbhs/Kconfig b/drivers/usb/renesas_usbhs/Kconfig
new file mode 100644
index 000000000000..b2e64918884c
--- /dev/null
+++ b/drivers/usb/renesas_usbhs/Kconfig
@@ -0,0 +1,16 @@
+#
+# Renesas USB 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" and force all
+           gadget drivers to also be dynamically linked.
diff --git a/drivers/usb/renesas_usbhs/Makefile b/drivers/usb/renesas_usbhs/Makefile
new file mode 100644
index 000000000000..b8798ad16278
--- /dev/null
+++ b/drivers/usb/renesas_usbhs/Makefile
@@ -0,0 +1,9 @@
+#
+# for Renesas USB
+#
+
+obj-$(CONFIG_USB_RENESAS_USBHS) += renesas_usbhs.o
+
+renesas_usbhs-y                 := common.o mod.o pipe.o
+
+renesas_usbhs-$(CONFIG_USB_RENESAS_USBHS_UDC)   += mod_gadget.o
diff --git a/drivers/usb/renesas_usbhs/common.c b/drivers/usb/renesas_usbhs/common.c
new file mode 100644
index 000000000000..f3664d6af661
--- /dev/null
+++ b/drivers/usb/renesas_usbhs/common.c
@@ -0,0 +1,437 @@
+/*
+ * Renesas USB driver
+ *
+ * Copyright (C) 2011 Renesas Solutions Corp.
+ * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
+ *
+ * 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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+#include <linux/io.h>
+#include <linux/module.h>
+#include <linux/pm_runtime.h>
+#include <linux/slab.h>
+#include <linux/sysfs.h>
+#include "./common.h"
+
+#define USBHSF_RUNTIME_PWCTRL   (1 << 0)
+
+/* status */
+#define usbhsc_flags_init(p)   do {(p)->flags = 0; } while (0)
+#define usbhsc_flags_set(p, b) ((p)->flags |=  (b))
+#define usbhsc_flags_clr(p, b) ((p)->flags &= ~(b))
+#define usbhsc_flags_has(p, b) ((p)->flags &   (b))
+
+/*
+ * platform call back
+ *
+ * renesas usb support platform callback function.
+ * Below macro call it.
+ * if platform doesn't have callback, it return 0 (no error)
+ */
+#define usbhs_platform_call(priv, func, args...)\
+        (!(priv) ? -ENODEV :                    \
+         !((priv)->pfunc->func) ? 0 :           \
+         (priv)->pfunc->func(args))
+
+/*
+ *              common functions
+ */
+u16 usbhs_read(struct usbhs_priv *priv, u32 reg)
+{
+        return ioread16(priv->base + reg);
+}
+
+void usbhs_write(struct usbhs_priv *priv, u32 reg, u16 data)
+{
+        iowrite16(data, priv->base + reg);
+}
+
+void usbhs_bset(struct usbhs_priv *priv, u32 reg, u16 mask, u16 data)
+{
+        u16 val = usbhs_read(priv, reg);
+
+        val &= ~mask;
+        val |= data & mask;
+
+        usbhs_write(priv, reg, val);
+}
+
+struct usbhs_priv *usbhs_pdev_to_priv(struct platform_device *pdev)
+{
+        return dev_get_drvdata(&pdev->dev);
+}
+
+/*
+ *              syscfg functions
+ */
+void usbhs_sys_clock_ctrl(struct usbhs_priv *priv, int enable)
+{
+        usbhs_bset(priv, SYSCFG, SCKE, enable ? SCKE : 0);
+}
+
+void usbhs_sys_hispeed_ctrl(struct usbhs_priv *priv, int enable)
+{
+        usbhs_bset(priv, SYSCFG, HSE, enable ? HSE : 0);
+}
+
+void usbhs_sys_usb_ctrl(struct usbhs_priv *priv, int enable)
+{
+        usbhs_bset(priv, SYSCFG, USBE, enable ? USBE : 0);
+}
+
+void usbhs_sys_host_ctrl(struct usbhs_priv *priv, int enable)
+{
+        u16 mask = DCFM | DRPD | DPRPU;
+        u16 val  = DCFM | DRPD;
+
+        /*
+         * if enable
+         *
+         * - select Host mode
+         * - D+ Line/D- Line Pull-down
+         */
+        usbhs_bset(priv, SYSCFG, mask, enable ? val : 0);
+}
+
+void usbhs_sys_function_ctrl(struct usbhs_priv *priv, int enable)
+{
+        u16 mask = DCFM | DRPD | DPRPU;
+        u16 val  = DPRPU;
+
+        /*
+         * if enable
+         *
+         * - select Function mode
+         * - D+ Line Pull-up
+         */
+        usbhs_bset(priv, SYSCFG, mask, enable ? val : 0);
+}
+
+/*
+ *              frame functions
+ */
+int usbhs_frame_get_num(struct usbhs_priv *priv)
+{
+        return usbhs_read(priv, FRMNUM) & FRNM_MASK;
+}
+
+/*
+ *              local functions
+ */
+static void usbhsc_bus_ctrl(struct usbhs_priv *priv, int enable)
+{
+        int wait = usbhs_get_dparam(priv, buswait_bwait);
+        u16 data = 0;
+
+        if (enable) {
+                /* set bus wait if platform have */
+                if (wait)
+                        usbhs_bset(priv, BUSWAIT, 0x000F, wait);
+        }
+        usbhs_write(priv, DVSTCTR, data);
+}
+
+/*
+ *              platform default param
+ */
+static u32 usbhsc_default_pipe_type[] = {
+                USB_ENDPOINT_XFER_CONTROL,
+                USB_ENDPOINT_XFER_ISOC,
+                USB_ENDPOINT_XFER_ISOC,
+                USB_ENDPOINT_XFER_BULK,
+                USB_ENDPOINT_XFER_BULK,
+                USB_ENDPOINT_XFER_BULK,
+                USB_ENDPOINT_XFER_INT,
+                USB_ENDPOINT_XFER_INT,
+                USB_ENDPOINT_XFER_INT,
+                USB_ENDPOINT_XFER_INT,
+};
+
+/*
+ *              power control
+ */
+static void usbhsc_power_ctrl(struct usbhs_priv *priv, int enable)
+{
+        struct device *dev = usbhs_priv_to_dev(priv);
+
+        if (enable) {
+                /* enable PM */
+                pm_runtime_get_sync(dev);
+
+                /* USB on */
+                usbhs_sys_clock_ctrl(priv, enable);
+                usbhsc_bus_ctrl(priv, enable);
+        } else {
+                /* USB off */
+                usbhsc_bus_ctrl(priv, enable);
+                usbhs_sys_clock_ctrl(priv, enable);
+
+                /* disable PM */
+                pm_runtime_put_sync(dev);
+        }
+}
+
+/*
+ *              notify hotplug
+ */
+static void usbhsc_notify_hotplug(struct work_struct *work)
+{
+        struct usbhs_priv *priv = container_of(work,
+                                               struct usbhs_priv,
+                                               notify_hotplug_work.work);
+        struct platform_device *pdev = usbhs_priv_to_pdev(priv);
+        struct usbhs_mod *mod = usbhs_mod_get_current(priv);
+        int id;
+        int enable;
+        int ret;
+
+        /*
+         * get vbus status from platform
+         */
+        enable = usbhs_platform_call(priv, get_vbus, pdev);
+
+        /*
+         * get id from platform
+         */
+        id = usbhs_platform_call(priv, get_id, pdev);
+
+        if (enable && !mod) {
+                ret = usbhs_mod_change(priv, id);
+                if (ret < 0)
+                        return;
+
+                dev_dbg(&pdev->dev, "%s enable\n", __func__);
+
+                /* power on */
+                if (usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL))
+                        usbhsc_power_ctrl(priv, enable);
+
+                /* module start */
+                usbhs_mod_call(priv, start, priv);
+
+        } else if (!enable && mod) {
+                dev_dbg(&pdev->dev, "%s disable\n", __func__);
+
+                /* module stop */
+                usbhs_mod_call(priv, stop, priv);
+
+                /* power off */
+                if (usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL))
+                        usbhsc_power_ctrl(priv, enable);
+
+                usbhs_mod_change(priv, -1);
+
+                /* reset phy for next connection */
+                usbhs_platform_call(priv, phy_reset, pdev);
+        }
+}
+
+int usbhsc_drvcllbck_notify_hotplug(struct platform_device *pdev)
+{
+        struct usbhs_priv *priv = usbhs_pdev_to_priv(pdev);
+        int delay = usbhs_get_dparam(priv, detection_delay);
+
+        /*
+         * This functions will be called in interrupt.
+         * To make sure safety context,
+         * use workqueue for usbhs_notify_hotplug
+         */
+        schedule_delayed_work(&priv->notify_hotplug_work, delay);
+        return 0;
+}
+
+/*
+ *              platform functions
+ */
+static int __devinit usbhs_probe(struct platform_device *pdev)
+{
+        struct renesas_usbhs_platform_info *info = pdev->dev.platform_data;
+        struct renesas_usbhs_driver_callback *dfunc;
+        struct usbhs_priv *priv;
+        struct resource *res;
+        unsigned int irq;
+        int ret;
+
+        /* check platform information */
+        if (!info ||
+            !info->platform_callback.get_id) {
+                dev_err(&pdev->dev, "no platform information\n");
+                return -EINVAL;
+        }
+
+        /* platform data */
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        irq = platform_get_irq(pdev, 0);
+        if (!res || (int)irq <= 0) {
+                dev_err(&pdev->dev, "Not enough Renesas USB platform resources.\n");
+                return -ENODEV;
+        }
+
+        /* usb private data */
+        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+        if (!priv) {
+                dev_err(&pdev->dev, "Could not allocate priv\n");
+                return -ENOMEM;
+        }
+
+        priv->base = ioremap_nocache(res->start, resource_size(res));
+        if (!priv->base) {
+                dev_err(&pdev->dev, "ioremap error.\n");
+                ret = -ENOMEM;
+                goto probe_end_kfree;
+        }
+
+        /*
+         * care platform info
+         */
+        priv->pfunc     = &info->platform_callback;
+        priv->dparam    = &info->driver_param;
+
+        /* set driver callback functions for platform */
+        dfunc                   = &info->driver_callback;
+        dfunc->notify_hotplug   = usbhsc_drvcllbck_notify_hotplug;
+
+        /* set default param if platform doesn't have */
+        if (!priv->dparam->pipe_type) {
+                priv->dparam->pipe_type = usbhsc_default_pipe_type;
+                priv->dparam->pipe_size = ARRAY_SIZE(usbhsc_default_pipe_type);
+        }
+
+        /* FIXME */
+        /* runtime power control ? */
+        if (priv->pfunc->get_vbus)
+                usbhsc_flags_set(priv, USBHSF_RUNTIME_PWCTRL);
+
+        /*
+         * priv settings
+         */
+        priv->irq       = irq;
+        priv->pdev      = pdev;
+        INIT_DELAYED_WORK(&priv->notify_hotplug_work, usbhsc_notify_hotplug);
+        spin_lock_init(usbhs_priv_to_lock(priv));
+
+        /* call pipe and module init */
+        ret = usbhs_pipe_probe(priv);
+        if (ret < 0)
+                goto probe_end_iounmap;
+
+        ret = usbhs_mod_probe(priv);
+        if (ret < 0)
+                goto probe_end_pipe_exit;
+
+        /* dev_set_drvdata should be called after usbhs_mod_init */
+        dev_set_drvdata(&pdev->dev, priv);
+
+        /*
+         * deviece reset here because
+         * USB device might be used in boot loader.
+         */
+        usbhs_sys_clock_ctrl(priv, 0);
+
+        /*
+         * platform call
+         *
+         * USB phy setup might depend on CPU/Board.
+         * If platform has its callback functions,
+         * call it here.
+         */
+        ret = usbhs_platform_call(priv, hardware_init, pdev);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "platform prove failed.\n");
+                goto probe_end_mod_exit;
+        }
+
+        /* reset phy for connection */
+        usbhs_platform_call(priv, phy_reset, pdev);
+
+        /* power control */
+        pm_runtime_enable(&pdev->dev);
+        if (!usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL)) {
+                usbhsc_power_ctrl(priv, 1);
+                usbhs_mod_autonomy_mode(priv);
+        }
+
+        /*
+         * manual call notify_hotplug for cold plug
+         */
+        ret = usbhsc_drvcllbck_notify_hotplug(pdev);
+        if (ret < 0)
+                goto probe_end_call_remove;
+
+        dev_info(&pdev->dev, "probed\n");
+
+        return ret;
+
+probe_end_call_remove:
+        usbhs_platform_call(priv, hardware_exit, pdev);
+probe_end_mod_exit:
+        usbhs_mod_remove(priv);
+probe_end_pipe_exit:
+        usbhs_pipe_remove(priv);
+probe_end_iounmap:
+        iounmap(priv->base);
+probe_end_kfree:
+        kfree(priv);
+
+        dev_info(&pdev->dev, "probe failed\n");
+
+        return ret;
+}
+
+static int __devexit usbhs_remove(struct platform_device *pdev)
+{
+        struct usbhs_priv *priv = usbhs_pdev_to_priv(pdev);
+        struct renesas_usbhs_platform_info *info = pdev->dev.platform_data;
+        struct renesas_usbhs_driver_callback *dfunc = &info->driver_callback;
+
+        dev_dbg(&pdev->dev, "usb remove\n");
+
+        dfunc->notify_hotplug = NULL;
+
+        /* power off */
+        if (!usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL))
+                usbhsc_power_ctrl(priv, 0);
+
+        pm_runtime_disable(&pdev->dev);
+
+        usbhs_platform_call(priv, hardware_exit, pdev);
+        usbhs_mod_remove(priv);
+        usbhs_pipe_remove(priv);
+        iounmap(priv->base);
+        kfree(priv);
+
+        return 0;
+}
+
+static struct platform_driver renesas_usbhs_driver = {
+        .driver         = {
+                .name   = "renesas_usbhs",
+        },
+        .probe          = usbhs_probe,
+        .remove         = __devexit_p(usbhs_remove),
+};
+
+static int __init usbhs_init(void)
+{
+        return platform_driver_register(&renesas_usbhs_driver);
+}
+
+static void __exit usbhs_exit(void)
+{
+        platform_driver_unregister(&renesas_usbhs_driver);
+}
+
+module_init(usbhs_init);
+module_exit(usbhs_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("Renesas USB driver");
+MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>");
diff --git a/drivers/usb/renesas_usbhs/common.h b/drivers/usb/renesas_usbhs/common.h
new file mode 100644
index 000000000000..0aadcb402764
--- /dev/null
+++ b/drivers/usb/renesas_usbhs/common.h
@@ -0,0 +1,230 @@
+/*
+ * Renesas USB driver
+ *
+ * Copyright (C) 2011 Renesas Solutions Corp.
+ * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
+ *
+ * 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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+#ifndef RENESAS_USB_DRIVER_H
+#define RENESAS_USB_DRIVER_H
+
+#include <linux/platform_device.h>
+#include <linux/usb/renesas_usbhs.h>
+
+struct usbhs_priv;
+
+#include "./mod.h"
+#include "./pipe.h"
+
+/*
+ *
+ *              register define
+ *
+ */
+#define SYSCFG          0x0000
+#define BUSWAIT         0x0002
+#define DVSTCTR         0x0008
+#define CFIFO           0x0014
+#define CFIFOSEL        0x0020
+#define CFIFOCTR        0x0022
+#define INTENB0         0x0030
+#define INTENB1         0x0032
+#define BRDYENB         0x0036
+#define NRDYENB         0x0038
+#define BEMPENB         0x003A
+#define INTSTS0         0x0040
+#define INTSTS1         0x0042
+#define BRDYSTS         0x0046
+#define NRDYSTS         0x0048
+#define BEMPSTS         0x004A
+#define FRMNUM          0x004C
+#define USBREQ          0x0054  /* USB request type register */
+#define USBVAL          0x0056  /* USB request value register */
+#define USBINDX         0x0058  /* USB request index register */
+#define USBLENG         0x005A  /* USB request length register */
+#define DCPCFG          0x005C
+#define DCPMAXP         0x005E
+#define DCPCTR          0x0060
+#define PIPESEL         0x0064
+#define PIPECFG         0x0068
+#define PIPEBUF         0x006A
+#define PIPEMAXP        0x006C
+#define PIPEPERI        0x006E
+#define PIPEnCTR        0x0070
+
+/* SYSCFG */
+#define SCKE    (1 << 10)       /* USB Module Clock Enable */
+#define HSE     (1 << 7)        /* High-Speed Operation Enable */
+#define DCFM    (1 << 6)        /* Controller Function Select */
+#define DRPD    (1 << 5)        /* D+ Line/D- Line Resistance Control */
+#define DPRPU   (1 << 4)        /* D+ Line Resistance Control */
+#define USBE    (1 << 0)        /* USB Module Operation Enable */
+
+/* DVSTCTR */
+#define EXTLP   (1 << 10)       /* Controls the EXTLP pin output state */
+#define PWEN    (1 << 9)        /* Controls the PWEN pin output state */
+#define RHST    (0x7)           /* Reset Handshake */
+#define  RHST_LOW_SPEED  1      /* Low-speed connection */
+#define  RHST_FULL_SPEED 2      /* Full-speed connection */
+#define  RHST_HIGH_SPEED 3      /* High-speed connection */
+
+/* CFIFOSEL */
+#define MBW_32  (0x2 << 10)     /* CFIFO Port Access Bit Width */
+
+/* CFIFOCTR */
+#define BVAL    (1 << 15)       /* Buffer Memory Enable Flag */
+#define BCLR    (1 << 14)       /* CPU buffer clear */
+#define FRDY    (1 << 13)       /* FIFO Port Ready */
+#define DTLN_MASK (0x0FFF)      /* Receive Data Length */
+
+/* INTENB0 */
+#define VBSE    (1 << 15)       /* Enable IRQ VBUS_0 and VBUSIN_0 */
+#define RSME    (1 << 14)       /* Enable IRQ Resume */
+#define SOFE    (1 << 13)       /* Enable IRQ Frame Number Update */
+#define DVSE    (1 << 12)       /* Enable IRQ Device State Transition */
+#define CTRE    (1 << 11)       /* Enable IRQ Control Stage Transition */
+#define BEMPE   (1 << 10)       /* Enable IRQ Buffer Empty */
+#define NRDYE   (1 << 9)        /* Enable IRQ Buffer Not Ready Response */
+#define BRDYE   (1 << 8)        /* Enable IRQ Buffer Ready */
+
+/* INTENB1 */
+#define BCHGE   (1 << 14)       /* USB Bus Change Interrupt Enable */
+#define DTCHE   (1 << 12)       /* Disconnection Detect Interrupt Enable */
+#define ATTCHE  (1 << 11)       /* Connection Detect Interrupt Enable */
+#define EOFERRE (1 << 6)        /* EOF Error Detect Interrupt Enable */
+#define SIGNE   (1 << 5)        /* Setup Transaction Error Interrupt Enable */
+#define SACKE   (1 << 4)        /* Setup Transaction ACK Interrupt Enable */
+
+/* INTSTS0 */
+#define VBINT   (1 << 15)       /* VBUS0_0 and VBUS1_0 Interrupt Status */
+#define DVST    (1 << 12)       /* Device State Transition Interrupt Status */
+#define CTRT    (1 << 11)       /* Control Stage Interrupt Status */
+#define BEMP    (1 << 10)       /* Buffer Empty Interrupt Status */
+#define BRDY    (1 << 8)        /* Buffer Ready Interrupt Status */
+#define VBSTS   (1 << 7)        /* VBUS_0 and VBUSIN_0 Input Status */
+#define VALID   (1 << 3)        /* USB Request Receive */
+
+#define DVSQ_MASK               (0x3 << 4)      /* Device State */
+#define  POWER_STATE            (0 << 4)
+#define  DEFAULT_STATE          (1 << 4)
+#define  ADDRESS_STATE          (2 << 4)
+#define  CONFIGURATION_STATE    (3 << 4)
+
+#define CTSQ_MASK               (0x7)   /* Control Transfer Stage */
+#define  IDLE_SETUP_STAGE       0       /* Idle stage or setup stage */
+#define  READ_DATA_STAGE        1       /* Control read data stage */
+#define  READ_STATUS_STAGE      2       /* Control read status stage */
+#define  WRITE_DATA_STAGE       3       /* Control write data stage */
+#define  WRITE_STATUS_STAGE     4       /* Control write status stage */
+#define  NODATA_STATUS_STAGE    5       /* Control write NoData status stage */
+#define  SEQUENCE_ERROR         6       /* Control transfer sequence error */
+
+/* PIPECFG */
+/* DCPCFG */
+#define TYPE_NONE       (0 << 14)       /* Transfer Type */
+#define TYPE_BULK       (1 << 14)
+#define TYPE_INT        (2 << 14)
+#define TYPE_ISO        (3 << 14)
+#define DBLB            (1 << 9)        /* Double Buffer Mode */
+#define SHTNAK          (1 << 7)        /* Pipe Disable in Transfer End */
+#define DIR_OUT         (1 << 4)        /* Transfer Direction */
+
+/* PIPEMAXP */
+/* DCPMAXP */
+#define DEVSEL_MASK     (0xF << 12)     /* Device Select */
+#define DCP_MAXP_MASK   (0x7F)
+#define PIPE_MAXP_MASK  (0x7FF)
+
+/* PIPEBUF */
+#define BUFSIZE_SHIFT   10
+#define BUFSIZE_MASK    (0x1F << BUFSIZE_SHIFT)
+#define BUFNMB_MASK     (0xFF)
+
+/* PIPEnCTR */
+/* DCPCTR */
+#define BSTS            (1 << 15)       /* Buffer Status */
+#define CSSTS           (1 << 12)       /* CSSTS Status */
+#define SQCLR           (1 << 8)        /* Toggle Bit Clear */
+#define ACLRM           (1 << 9)        /* Buffer Auto-Clear Mode */
+#define PBUSY           (1 << 5)        /* Pipe Busy */
+#define PID_MASK        (0x3)           /* Response PID */
+#define  PID_NAK        0
+#define  PID_BUF        1
+#define  PID_STALL10    2
+#define  PID_STALL11    3
+
+#define CCPL            (1 << 2)        /* Control Transfer End Enable */
+
+/* FRMNUM */
+#define FRNM_MASK       (0x7FF)
+
+/*
+ *              struct
+ */
+struct usbhs_priv {
+
+        void __iomem *base;
+        unsigned int irq;
+
+        struct renesas_usbhs_platform_callback  *pfunc;
+        struct renesas_usbhs_driver_param       *dparam;
+
+        struct delayed_work notify_hotplug_work;
+        struct platform_device *pdev;
+
+        spinlock_t              lock;
+
+        u32 flags;
+
+        /*
+         * module control
+         */
+        struct usbhs_mod_info mod_info;
+
+        /*
+         * pipe control
+         */
+        struct usbhs_pipe_info pipe_info;
+};
+
+/*
+ * common
+ */
+u16 usbhs_read(struct usbhs_priv *priv, u32 reg);
+void usbhs_write(struct usbhs_priv *priv, u32 reg, u16 data);
+void usbhs_bset(struct usbhs_priv *priv, u32 reg, u16 mask, u16 data);
+
+int usbhsc_drvcllbck_notify_hotplug(struct platform_device *pdev);
+/*
+ * sysconfig
+ */
+void usbhs_sys_clock_ctrl(struct usbhs_priv *priv, int enable);
+void usbhs_sys_hispeed_ctrl(struct usbhs_priv *priv, int enable);
+void usbhs_sys_usb_ctrl(struct usbhs_priv *priv, int enable);
+void usbhs_sys_host_ctrl(struct usbhs_priv *priv, int enable);
+void usbhs_sys_function_ctrl(struct usbhs_priv *priv, int enable);
+
+/*
+ * frame
+ */
+int usbhs_frame_get_num(struct usbhs_priv *priv);
+
+/*
+ * data
+ */
+struct usbhs_priv *usbhs_pdev_to_priv(struct platform_device *pdev);
+#define usbhs_get_dparam(priv, param)   (priv->dparam->param)
+#define usbhs_priv_to_pdev(priv)        (priv->pdev)
+#define usbhs_priv_to_dev(priv)         (&priv->pdev->dev)
+#define usbhs_priv_to_lock(priv)        (&priv->lock)
+
+#endif /* RENESAS_USB_DRIVER_H */
diff --git a/drivers/usb/renesas_usbhs/mod.c b/drivers/usb/renesas_usbhs/mod.c
new file mode 100644
index 000000000000..a577f8f4064c
--- /dev/null
+++ b/drivers/usb/renesas_usbhs/mod.c
@@ -0,0 +1,328 @@
+/*
+ * Renesas USB driver
+ *
+ * Copyright (C) 2011 Renesas Solutions Corp.
+ * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
+ *
+ * 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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+#include <linux/interrupt.h>
+
+#include "./common.h"
+#include "./mod.h"
+
+#define usbhs_priv_to_modinfo(priv) (&priv->mod_info)
+#define usbhs_mod_info_call(priv, func, param...)       \
+({                                              \
+        struct usbhs_mod_info *info;            \
+        info = usbhs_priv_to_modinfo(priv);     \
+        !info->func ? 0 :                       \
+         info->func(param);                     \
+})
+
+/*
+ *              autonomy
+ *
+ * these functions are used if platform doesn't have external phy.
+ *  -> there is no "notify_hotplug" callback from platform
+ *  -> call "notify_hotplug" by itself
+ *  -> use own interrupt to connect/disconnect
+ *  -> it mean module clock is always ON
+ *             ~~~~~~~~~~~~~~~~~~~~~~~~~
+ */
+static int usbhsm_autonomy_get_vbus(struct platform_device *pdev)
+{
+        struct usbhs_priv *priv = usbhs_pdev_to_priv(pdev);
+
+        return  VBSTS & usbhs_read(priv, INTSTS0);
+}
+
+static int usbhsm_autonomy_irq_vbus(struct usbhs_priv *priv,
+                                    struct usbhs_irq_state *irq_state)
+{
+        struct platform_device *pdev = usbhs_priv_to_pdev(priv);
+
+        return usbhsc_drvcllbck_notify_hotplug(pdev);
+}
+
+void usbhs_mod_autonomy_mode(struct usbhs_priv *priv)
+{
+        struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv);
+
+        info->irq_vbus          = usbhsm_autonomy_irq_vbus;
+        priv->pfunc->get_vbus   = usbhsm_autonomy_get_vbus;
+
+        usbhs_irq_callback_update(priv, NULL);
+}
+
+/*
+ *              host / gadget functions
+ *
+ * renesas_usbhs host/gadget can register itself by below functions.
+ * these functions are called when probe
+ *
+ */
+void usbhs_mod_register(struct usbhs_priv *priv, struct usbhs_mod *mod, int id)
+{
+        struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv);
+
+        info->mod[id]   = mod;
+        mod->priv       = priv;
+}
+
+struct usbhs_mod *usbhs_mod_get(struct usbhs_priv *priv, int id)
+{
+        struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv);
+        struct usbhs_mod *ret = NULL;
+
+        switch (id) {
+        case USBHS_HOST:
+        case USBHS_GADGET:
+                ret = info->mod[id];
+                break;
+        }
+
+        return ret;
+}
+
+int usbhs_mod_is_host(struct usbhs_priv *priv, struct usbhs_mod *mod)
+{
+        struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv);
+
+        if (!mod)
+                return -EINVAL;
+
+        return info->mod[USBHS_HOST] == mod;
+}
+
+struct usbhs_mod *usbhs_mod_get_current(struct usbhs_priv *priv)
+{
+        struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv);
+
+        return info->curt;
+}
+
+int usbhs_mod_change(struct usbhs_priv *priv, int id)
+{
+        struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv);
+        struct usbhs_mod *mod = NULL;
+        int ret = 0;
+
+        /* id < 0 mean no current */
+        switch (id) {
+        case USBHS_HOST:
+        case USBHS_GADGET:
+                mod = info->mod[id];
+                break;
+        default:
+                ret = -EINVAL;
+        }
+        info->curt = mod;
+
+        return ret;
+}
+
+static irqreturn_t usbhs_interrupt(int irq, void *data);
+int usbhs_mod_probe(struct usbhs_priv *priv)
+{
+        struct device *dev = usbhs_priv_to_dev(priv);
+        int ret;
+
+        /*
+         * install host/gadget driver
+         */
+        ret = usbhs_mod_gadget_probe(priv);
+        if (ret < 0)
+                return ret;
+
+        /* irq settings */
+        ret = request_irq(priv->irq, usbhs_interrupt,
+                          IRQF_DISABLED, dev_name(dev), priv);
+        if (ret) {
+                dev_err(dev, "irq request err\n");
+                goto mod_init_gadget_err;
+        }
+
+        return ret;
+
+mod_init_gadget_err:
+        usbhs_mod_gadget_remove(priv);
+
+        return ret;
+}
+
+void usbhs_mod_remove(struct usbhs_priv *priv)
+{
+        usbhs_mod_gadget_remove(priv);
+        free_irq(priv->irq, priv);
+}
+
+/*
+ *              status functions
+ */
+int usbhs_status_get_usb_speed(struct usbhs_irq_state *irq_state)
+{
+        switch (irq_state->dvstctr & RHST) {
+        case RHST_LOW_SPEED:
+                return USB_SPEED_LOW;
+        case RHST_FULL_SPEED:
+                return USB_SPEED_FULL;
+        case RHST_HIGH_SPEED:
+                return USB_SPEED_HIGH;
+        }
+
+        return USB_SPEED_UNKNOWN;
+}
+
+int usbhs_status_get_device_state(struct usbhs_irq_state *irq_state)
+{
+        int state = irq_state->intsts0 & DVSQ_MASK;
+
+        switch (state) {
+        case POWER_STATE:
+        case DEFAULT_STATE:
+        case ADDRESS_STATE:
+        case CONFIGURATION_STATE:
+                return state;
+        }
+
+        return -EIO;
+}
+
+int usbhs_status_get_ctrl_stage(struct usbhs_irq_state *irq_state)
+{
+        /*
+         * return value
+         *
+         * IDLE_SETUP_STAGE
+         * READ_DATA_STAGE
+         * READ_STATUS_STAGE
+         * WRITE_DATA_STAGE
+         * WRITE_STATUS_STAGE
+         * NODATA_STATUS_STAGE
+         * SEQUENCE_ERROR
+         */
+        return (int)irq_state->intsts0 & CTSQ_MASK;
+}
+
+static void usbhs_status_get_each_irq(struct usbhs_priv *priv,
+                                      struct usbhs_irq_state *state)
+{
+        struct usbhs_mod *mod = usbhs_mod_get_current(priv);
+
+        state->intsts0 = usbhs_read(priv, INTSTS0);
+        state->intsts1 = usbhs_read(priv, INTSTS1);
+
+        state->dvstctr = usbhs_read(priv, DVSTCTR);
+
+        /* mask */
+        if (mod) {
+                state->brdysts = usbhs_read(priv, BRDYSTS);
+                state->nrdysts = usbhs_read(priv, NRDYSTS);
+                state->bempsts = usbhs_read(priv, BEMPSTS);
+
+                state->bempsts &= mod->irq_bempsts;
+                state->brdysts &= mod->irq_brdysts;
+        }
+}
+
+/*
+ *              interrupt
+ */
+#define INTSTS0_MAGIC 0xF800 /* acknowledge magical interrupt sources */
+#define INTSTS1_MAGIC 0xA870 /* acknowledge magical interrupt sources */
+static irqreturn_t usbhs_interrupt(int irq, void *data)
+{
+        struct usbhs_priv *priv = data;
+        struct usbhs_irq_state irq_state;
+
+        usbhs_status_get_each_irq(priv, &irq_state);
+
+        /*
+         * clear interrupt
+         *
+         * The hardware is _very_ picky to clear interrupt bit.
+         * Especially INTSTS0_MAGIC, INTSTS1_MAGIC value.
+         *
+         * see
+         *      "Operation"
+         *       - "Control Transfer (DCP)"
+         *         - Function :: VALID bit should 0
+         */
+        usbhs_write(priv, INTSTS0, ~irq_state.intsts0 & INTSTS0_MAGIC);
+        usbhs_write(priv, INTSTS1, ~irq_state.intsts1 & INTSTS1_MAGIC);
+
+        usbhs_write(priv, BRDYSTS, 0);
+        usbhs_write(priv, NRDYSTS, 0);
+        usbhs_write(priv, BEMPSTS, 0);
+
+        /*
+         * call irq callback functions
+         * see also
+         *      usbhs_irq_setting_update
+         */
+        if (irq_state.intsts0 & VBINT)
+                usbhs_mod_info_call(priv, irq_vbus, priv, &irq_state);
+
+        if (irq_state.intsts0 & DVST)
+                usbhs_mod_call(priv, irq_dev_state, priv, &irq_state);
+
+        if (irq_state.intsts0 & CTRT)
+                usbhs_mod_call(priv, irq_ctrl_stage, priv, &irq_state);
+
+        if (irq_state.intsts0 & BEMP)
+                usbhs_mod_call(priv, irq_empty, priv, &irq_state);
+
+        if (irq_state.intsts0 & BRDY)
+                usbhs_mod_call(priv, irq_ready, priv, &irq_state);
+
+        return IRQ_HANDLED;
+}
+
+void usbhs_irq_callback_update(struct usbhs_priv *priv, struct usbhs_mod *mod)
+{
+        u16 intenb0 = 0;
+        struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv);
+
+        usbhs_write(priv, INTENB0, 0);
+
+        usbhs_write(priv, BEMPENB, 0);
+        usbhs_write(priv, BRDYENB, 0);
+
+        /*
+         * see also
+         *      usbhs_interrupt
+         */
+
+        /*
+         * it don't enable DVSE (intenb0) here
+         * but "mod->irq_dev_state" will be called.
+         */
+        if (info->irq_vbus)
+                intenb0 |= VBSE;
+
+        if (mod) {
+                if (mod->irq_ctrl_stage)
+                        intenb0 |= CTRE;
+
+                if (mod->irq_empty && mod->irq_bempsts) {
+                        usbhs_write(priv, BEMPENB, mod->irq_bempsts);
+                        intenb0 |= BEMPE;
+                }
+
+                if (mod->irq_ready && mod->irq_brdysts) {
+                        usbhs_write(priv, BRDYENB, mod->irq_brdysts);
+                        intenb0 |= BRDYE;
+                }
+        }
+
+        usbhs_write(priv, INTENB0, intenb0);
+}
diff --git a/drivers/usb/renesas_usbhs/mod.h b/drivers/usb/renesas_usbhs/mod.h
new file mode 100644
index 000000000000..5c845a28a21c
--- /dev/null
+++ b/drivers/usb/renesas_usbhs/mod.h
@@ -0,0 +1,137 @@
+/*
+ * Renesas USB driver
+ *
+ * Copyright (C) 2011 Renesas Solutions Corp.
+ * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
+ *
+ * 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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+#ifndef RENESAS_USB_MOD_H
+#define RENESAS_USB_MOD_H
+
+#include <linux/spinlock.h>
+#include <linux/usb/renesas_usbhs.h>
+#include "./common.h"
+
+/*
+ *      struct
+ */
+struct usbhs_irq_state {
+        u16 intsts0;
+        u16 intsts1;
+        u16 brdysts;
+        u16 nrdysts;
+        u16 bempsts;
+        u16 dvstctr;
+};
+
+struct usbhs_mod {
+        char *name;
+
+        /*
+         * entry point from common.c
+         */
+        int (*start)(struct usbhs_priv *priv);
+        int (*stop)(struct usbhs_priv *priv);
+
+        /* INTSTS0 :: DVST (DVSQ) */
+        int (*irq_dev_state)(struct usbhs_priv *priv,
+                             struct usbhs_irq_state *irq_state);
+
+        /* INTSTS0 :: CTRT (CTSQ) */
+        int (*irq_ctrl_stage)(struct usbhs_priv *priv,
+                              struct usbhs_irq_state *irq_state);
+
+        /* INTSTS0 :: BEMP */
+        /* BEMPSTS */
+        int (*irq_empty)(struct usbhs_priv *priv,
+                         struct usbhs_irq_state *irq_state);
+        u16 irq_bempsts;
+
+        /* INTSTS0 :: BRDY */
+        /* BRDYSTS */
+        int (*irq_ready)(struct usbhs_priv *priv,
+                         struct usbhs_irq_state *irq_state);
+        u16 irq_brdysts;
+
+        struct usbhs_priv *priv;
+};
+
+struct usbhs_mod_info {
+        struct usbhs_mod *mod[USBHS_MAX];
+        struct usbhs_mod *curt; /* current mod */
+
+        /*
+         * INTSTS0 :: VBINT
+         *
+         * This function will be used as autonomy mode
+         * when platform cannot call notify_hotplug.
+         *
+         * This callback cannot be member of "struct usbhs_mod"
+         * because it will be used even though
+         * host/gadget has not been selected.
+         */
+        int (*irq_vbus)(struct usbhs_priv *priv,
+                        struct usbhs_irq_state *irq_state);
+};
+
+/*
+ *              for host/gadget module
+ */
+struct usbhs_mod *usbhs_mod_get(struct usbhs_priv *priv, int id);
+struct usbhs_mod *usbhs_mod_get_current(struct usbhs_priv *priv);
+void usbhs_mod_register(struct usbhs_priv *priv, struct usbhs_mod *usb, int id);
+int usbhs_mod_is_host(struct usbhs_priv *priv, struct usbhs_mod *mod);
+int usbhs_mod_change(struct usbhs_priv *priv, int id);
+int usbhs_mod_probe(struct usbhs_priv *priv);
+void usbhs_mod_remove(struct usbhs_priv *priv);
+
+void usbhs_mod_autonomy_mode(struct usbhs_priv *priv);
+
+/*
+ *              status functions
+ */
+int usbhs_status_get_usb_speed(struct usbhs_irq_state *irq_state);
+int usbhs_status_get_device_state(struct usbhs_irq_state *irq_state);
+int usbhs_status_get_ctrl_stage(struct usbhs_irq_state *irq_state);
+
+/*
+ *              callback functions
+ */
+void usbhs_irq_callback_update(struct usbhs_priv *priv, struct usbhs_mod *mod);
+
+
+#define usbhs_mod_call(priv, func, param...)            \
+        ({                                              \
+                struct usbhs_mod *mod;                  \
+                mod = usbhs_mod_get_current(priv);      \
+                !mod            ? -ENODEV :             \
+                !mod->func      ? 0 :                   \
+                 mod->func(param);                      \
+        })
+
+/*
+ * gadget control
+ */
+#ifdef CONFIG_USB_RENESAS_USBHS_UDC
+extern int __devinit usbhs_mod_gadget_probe(struct usbhs_priv *priv);
+extern void __devexit usbhs_mod_gadget_remove(struct usbhs_priv *priv);
+#else
+static inline int usbhs_mod_gadget_probe(struct usbhs_priv *priv)
+{
+        return 0;
+}
+static inline void usbhs_mod_gadget_remove(struct usbhs_priv *priv)
+{
+}
+#endif
+
+#endif /* RENESAS_USB_MOD_H */
diff --git a/drivers/usb/renesas_usbhs/mod_gadget.c b/drivers/usb/renesas_usbhs/mod_gadget.c
new file mode 100644
index 000000000000..547486ccd059
--- /dev/null
+++ b/drivers/usb/renesas_usbhs/mod_gadget.c
@@ -0,0 +1,1385 @@
+/*
+ * Renesas USB driver
+ *
+ * Copyright (C) 2011 Renesas Solutions Corp.
+ * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
+ *
+ * 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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+#include <linux/io.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/usb/ch9.h>
+#include <linux/usb/gadget.h>
+#include "common.h"
+
+/*
+ *              struct
+ */
+struct usbhsg_request {
+        struct usb_request      req;
+        struct list_head        node;
+};
+
+#define EP_NAME_SIZE 8
+struct usbhsg_gpriv;
+struct usbhsg_pipe_handle;
+struct usbhsg_uep {
+        struct usb_ep            ep;
+        struct usbhs_pipe       *pipe;
+        struct list_head         list;
+
+        char ep_name[EP_NAME_SIZE];
+
+        struct usbhsg_gpriv *gpriv;
+        struct usbhsg_pipe_handle *handler;
+};
+
+struct usbhsg_gpriv {
+        struct usb_gadget        gadget;
+        struct usbhs_mod         mod;
+
+        struct usbhsg_uep       *uep;
+        int                      uep_size;
+
+        struct usb_gadget_driver        *driver;
+
+        u32     status;
+#define USBHSG_STATUS_STARTED           (1 << 0)
+#define USBHSG_STATUS_REGISTERD         (1 << 1)
+#define USBHSG_STATUS_WEDGE             (1 << 2)
+};
+
+struct usbhsg_pipe_handle {
+        int (*prepare)(struct usbhsg_uep *uep, struct usbhsg_request *ureq);
+        int (*try_run)(struct usbhsg_uep *uep, struct usbhsg_request *ureq);
+        void (*irq_mask)(struct usbhsg_uep *uep, int enable);
+};
+
+struct usbhsg_recip_handle {
+        char *name;
+        int (*device)(struct usbhs_priv *priv, struct usbhsg_uep *uep,
+                      struct usb_ctrlrequest *ctrl);
+        int (*interface)(struct usbhs_priv *priv, struct usbhsg_uep *uep,
+                         struct usb_ctrlrequest *ctrl);
+        int (*endpoint)(struct usbhs_priv *priv, struct usbhsg_uep *uep,
+                        struct usb_ctrlrequest *ctrl);
+};
+
+/*
+ *              macro
+ */
+#define usbhsg_priv_to_gpriv(priv)                      \
+        container_of(                                   \
+                usbhs_mod_get(priv, USBHS_GADGET),      \
+                struct usbhsg_gpriv, mod)
+
+#define __usbhsg_for_each_uep(start, pos, g, i) \
+        for (i = start, pos = (g)->uep;         \
+             i < (g)->uep_size;                 \
+             i++, pos = (g)->uep + i)
+
+#define usbhsg_for_each_uep(pos, gpriv, i)      \
+        __usbhsg_for_each_uep(1, pos, gpriv, i)
+
+#define usbhsg_for_each_uep_with_dcp(pos, gpriv, i)     \
+        __usbhsg_for_each_uep(0, pos, gpriv, i)
+
+#define usbhsg_gadget_to_gpriv(g)\
+        container_of(g, struct usbhsg_gpriv, gadget)
+
+#define usbhsg_req_to_ureq(r)\
+        container_of(r, struct usbhsg_request, req)
+
+#define usbhsg_ep_to_uep(e)             container_of(e, struct usbhsg_uep, ep)
+#define usbhsg_gpriv_to_lock(gp)        usbhs_priv_to_lock((gp)->mod.priv)
+#define usbhsg_gpriv_to_dev(gp)         usbhs_priv_to_dev((gp)->mod.priv)
+#define usbhsg_gpriv_to_priv(gp)        ((gp)->mod.priv)
+#define usbhsg_gpriv_to_dcp(gp)         ((gp)->uep)
+#define usbhsg_gpriv_to_nth_uep(gp, i)  ((gp)->uep + i)
+#define usbhsg_uep_to_gpriv(u)          ((u)->gpriv)
+#define usbhsg_uep_to_pipe(u)           ((u)->pipe)
+#define usbhsg_pipe_to_uep(p)           ((p)->mod_private)
+#define usbhsg_is_dcp(u)                ((u) == usbhsg_gpriv_to_dcp((u)->gpriv))
+
+#define usbhsg_is_not_connected(gp) ((gp)->gadget.speed == USB_SPEED_UNKNOWN)
+
+/* status */
+#define usbhsg_status_init(gp)   do {(gp)->status = 0; } while (0)
+#define usbhsg_status_set(gp, b) (gp->status |=  b)
+#define usbhsg_status_clr(gp, b) (gp->status &= ~b)
+#define usbhsg_status_has(gp, b) (gp->status &   b)
+
+/*
+ *              usbhsg_trylock
+ *
+ * This driver don't use spin_try_lock
+ * to avoid warning of CONFIG_DEBUG_SPINLOCK
+ */
+static spinlock_t *usbhsg_trylock(struct usbhsg_gpriv *gpriv,
+                                  unsigned long *flags)
+{
+        spinlock_t *lock = usbhsg_gpriv_to_lock(gpriv);
+
+        /* check spin lock status
+         * to avoid deadlock/nest */
+        if (spin_is_locked(lock))
+                return NULL;
+
+        spin_lock_irqsave(lock, *flags);
+
+        return lock;
+}
+
+static void usbhsg_unlock(spinlock_t *lock, unsigned long *flags)
+{
+        if (!lock)
+                return;
+
+        spin_unlock_irqrestore(lock, *flags);
+}
+
+/*
+ *              list push/pop
+ */
+static void usbhsg_queue_push(struct usbhsg_uep *uep,
+                              struct usbhsg_request *ureq)
+{
+        struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
+        struct device *dev = usbhsg_gpriv_to_dev(gpriv);
+        struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
+
+        /*
+         *********  assume under spin lock  *********
+         */
+        list_del_init(&ureq->node);
+        list_add_tail(&ureq->node, &uep->list);
+        ureq->req.actual = 0;
+        ureq->req.status = -EINPROGRESS;
+
+        dev_dbg(dev, "pipe %d : queue push (%d)\n",
+                usbhs_pipe_number(pipe),
+                ureq->req.length);
+}
+
+static struct usbhsg_request *usbhsg_queue_get(struct usbhsg_uep *uep)
+{
+        /*
+         *********  assume under spin lock  *********
+         */
+        if (list_empty(&uep->list))
+                return NULL;
+
+        return list_entry(uep->list.next, struct usbhsg_request, node);
+}
+
+#define usbhsg_queue_prepare(uep) __usbhsg_queue_handler(uep, 1);
+#define usbhsg_queue_handle(uep)  __usbhsg_queue_handler(uep, 0);
+static int __usbhsg_queue_handler(struct usbhsg_uep *uep, int prepare)
+{
+        struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
+        struct device *dev = usbhsg_gpriv_to_dev(gpriv);
+        struct usbhsg_request *ureq;
+        spinlock_t *lock;
+        unsigned long flags;
+        int ret = 0;
+
+        if (!uep->handler) {
+                dev_err(dev, "no handler function\n");
+                return -EIO;
+        }
+
+        /*
+         * CAUTION [*queue handler*]
+         *
+         * This function will be called for start/restart queue operation.
+         * OTOH the most much worry for USB driver is spinlock nest.
+         * Specially it are
+         *   - usb_ep_ops  :: queue
+         *   - usb_request :: complete
+         *
+         * But the caller of this function need not care about spinlock.
+         * This function is using usbhsg_trylock for it.
+         * if "is_locked" is 1, this mean this function lock it.
+         * but if it is 0, this mean it is already under spin lock.
+         * see also
+         *   CAUTION [*endpoint queue*]
+         *   CAUTION [*request complete*]
+         */
+
+        /******************  spin try lock *******************/
+        lock = usbhsg_trylock(gpriv, &flags);
+
+        ureq = usbhsg_queue_get(uep);
+        if (ureq) {
+                if (prepare)
+                        ret = uep->handler->prepare(uep, ureq);
+                else
+                        ret = uep->handler->try_run(uep, ureq);
+        }
+        usbhsg_unlock(lock, &flags);
+        /********************  spin unlock ******************/
+
+        return ret;
+}
+
+static void usbhsg_queue_pop(struct usbhsg_uep *uep,
+                             struct usbhsg_request *ureq,
+                             int status)
+{
+        struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
+        struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
+        struct device *dev = usbhsg_gpriv_to_dev(gpriv);
+
+        /*
+         *********  assume under spin lock  *********
+         */
+
+        /*
+         * CAUTION [*request complete*]
+         *
+         * There is a possibility not to be called in correct order
+         * if "complete" is called without spinlock.
+         *
+         * So, this function assume it is under spinlock,
+         * and call usb_request :: complete.
+         *
+         * But this "complete" will push next usb_request.
+         * It mean "usb_ep_ops :: queue" which is using spinlock is called
+         * under spinlock.
+         *
+         * To avoid dead-lock, this driver is using usbhsg_trylock.
+         *   CAUTION [*endpoint queue*]
+         *   CAUTION [*queue handler*]
+         */
+
+        dev_dbg(dev, "pipe %d : queue pop\n", usbhs_pipe_number(pipe));
+
+        list_del_init(&ureq->node);
+
+        ureq->req.status = status;
+        ureq->req.complete(&uep->ep, &ureq->req);
+
+        /* more request ? */
+        if (0 == status)
+                usbhsg_queue_prepare(uep);
+}
+
+/*
+ *              irq enable/disable function
+ */
+#define usbhsg_irq_callback_ctrl(uep, status, enable)                   \
+        ({                                                              \
+                struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);  \
+                struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);      \
+                struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv);  \
+                struct usbhs_mod *mod = usbhs_mod_get_current(priv);    \
+                if (!mod)                                               \
+                        return;                                         \
+                if (enable)                                             \
+                        mod->irq_##status |= (1 << usbhs_pipe_number(pipe)); \
+                else                                                    \
+                        mod->irq_##status &= ~(1 << usbhs_pipe_number(pipe)); \
+                usbhs_irq_callback_update(priv, mod);                   \
+        })
+
+static void usbhsg_irq_empty_ctrl(struct usbhsg_uep *uep, int enable)
+{
+        usbhsg_irq_callback_ctrl(uep, bempsts, enable);
+}
+
+static void usbhsg_irq_ready_ctrl(struct usbhsg_uep *uep, int enable)
+{
+        usbhsg_irq_callback_ctrl(uep, brdysts, enable);
+}
+
+/*
+ *              handler function
+ */
+static int usbhsg_try_run_ctrl_stage_end(struct usbhsg_uep *uep,
+                                         struct usbhsg_request *ureq)
+{
+        struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
+
+        /*
+         *********  assume under spin lock  *********
+         */
+
+        usbhs_dcp_control_transfer_done(pipe);
+        usbhsg_queue_pop(uep, ureq, 0);
+
+        return 0;
+}
+
+static int usbhsg_try_run_send_packet(struct usbhsg_uep *uep,
+                                      struct usbhsg_request *ureq)
+{
+        struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
+        struct usb_request *req = &ureq->req;
+        struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
+        struct device *dev = usbhsg_gpriv_to_dev(gpriv);
+        void *buf;
+        int remainder, send;
+        int is_done = 0;
+        int enable;
+        int maxp;
+
+        /*
+         *********  assume under spin lock  *********
+         */
+
+        maxp            = usbhs_pipe_get_maxpacket(pipe);
+        buf             = req->buf    + req->actual;
+        remainder       = req->length - req->actual;
+
+        send = usbhs_fifo_write(pipe, buf, remainder);
+
+        /*
+         * send < 0 : pipe busy
+         * send = 0 : send zero packet
+         * send > 0 : send data
+         *
+         * send <= max_packet
+         */
+        if (send > 0)
+                req->actual += send;
+
+        /* send all packet ? */
+        if (send < remainder)
+                is_done = 0;            /* there are remainder data */
+        else if (send < maxp)
+                is_done = 1;            /* short packet */
+        else
+                is_done = !req->zero;   /* send zero packet ? */
+
+        dev_dbg(dev, "  send %d (%d/ %d/ %d/ %d)\n",
+                usbhs_pipe_number(pipe),
+                remainder, send, is_done, req->zero);
+
+        /*
+         * enable interrupt and send again in irq handler
+         * if it still have remainder data which should be sent.
+         */
+        enable = !is_done;
+        uep->handler->irq_mask(uep, enable);
+
+        /*
+         * usbhs_fifo_enable execute
+         *  - after callback_update,
+         *  - before queue_pop / stage_end
+         */
+        usbhs_fifo_enable(pipe);
+
+        /*
+         * all data were sent ?
+         */
+        if (is_done) {
+                /* it care below call in
+                   "function mode" */
+                if (usbhsg_is_dcp(uep))
+                        usbhs_dcp_control_transfer_done(pipe);
+
+                usbhsg_queue_pop(uep, ureq, 0);
+        }
+
+        return 0;
+}
+
+static int usbhsg_prepare_send_packet(struct usbhsg_uep *uep,
+                                      struct usbhsg_request *ureq)
+{
+        struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
+
+        /*
+         *********  assume under spin lock  *********
+         */
+
+        usbhs_fifo_prepare_write(pipe);
+        usbhsg_try_run_send_packet(uep, ureq);
+
+        return 0;
+}
+
+static int usbhsg_try_run_receive_packet(struct usbhsg_uep *uep,
+                                         struct usbhsg_request *ureq)
+{
+        struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
+        struct usb_request *req = &ureq->req;
+        struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
+        struct device *dev = usbhsg_gpriv_to_dev(gpriv);
+        void *buf;
+        int maxp;
+        int remainder, recv;
+        int is_done = 0;
+
+        /*
+         *********  assume under spin lock  *********
+         */
+
+        maxp            = usbhs_pipe_get_maxpacket(pipe);
+        buf             = req->buf    + req->actual;
+        remainder       = req->length - req->actual;
+
+        recv = usbhs_fifo_read(pipe, buf, remainder);
+        /*
+         * recv < 0  : pipe busy
+         * recv >= 0 : receive data
+         *
+         * recv <= max_packet
+         */
+        if (recv < 0)
+                return -EBUSY;
+
+        /* update parameters */
+        req->actual += recv;
+
+        if ((recv == remainder) ||      /* receive all data */
+            (recv < maxp))              /* short packet */
+                is_done = 1;
+
+        dev_dbg(dev, "  recv %d (%d/ %d/ %d/ %d)\n",
+                usbhs_pipe_number(pipe),
+                remainder, recv, is_done, req->zero);
+
+        /* read all data ? */
+        if (is_done) {
+                int disable = 0;
+
+                uep->handler->irq_mask(uep, disable);
+                usbhs_fifo_disable(pipe);
+                usbhsg_queue_pop(uep, ureq, 0);
+        }
+
+        return 0;
+}
+
+static int usbhsg_prepare_receive_packet(struct usbhsg_uep *uep,
+                                         struct usbhsg_request *ureq)
+{
+        struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
+        int enable = 1;
+        int ret;
+
+        /*
+         *********  assume under spin lock  *********
+         */
+
+        ret = usbhs_fifo_prepare_read(pipe);
+        if (ret < 0)
+                return ret;
+
+        /*
+         * data will be read in interrupt handler
+         */
+        uep->handler->irq_mask(uep, enable);
+
+        return ret;
+}
+
+static struct usbhsg_pipe_handle usbhsg_handler_send_by_empty = {
+        .prepare        = usbhsg_prepare_send_packet,
+        .try_run        = usbhsg_try_run_send_packet,
+        .irq_mask       = usbhsg_irq_empty_ctrl,
+};
+
+static struct usbhsg_pipe_handle usbhsg_handler_send_by_ready = {
+        .prepare        = usbhsg_prepare_send_packet,
+        .try_run        = usbhsg_try_run_send_packet,
+        .irq_mask       = usbhsg_irq_ready_ctrl,
+};
+
+static struct usbhsg_pipe_handle usbhsg_handler_recv_by_ready = {
+        .prepare        = usbhsg_prepare_receive_packet,
+        .try_run        = usbhsg_try_run_receive_packet,
+        .irq_mask       = usbhsg_irq_ready_ctrl,
+};
+
+static struct usbhsg_pipe_handle usbhsg_handler_ctrl_stage_end = {
+        .prepare        = usbhsg_try_run_ctrl_stage_end,
+        .try_run        = usbhsg_try_run_ctrl_stage_end,
+};
+
+/*
+ * DCP pipe can NOT use "ready interrupt" for "send"
+ * it should use "empty" interrupt.
+ * see
+ *   "Operation" - "Interrupt Function" - "BRDY Interrupt"
+ *
+ * on the other hand, normal pipe can use "ready interrupt" for "send"
+ * even though it is single/double buffer
+ */
+#define usbhsg_handler_send_ctrl        usbhsg_handler_send_by_empty
+#define usbhsg_handler_recv_ctrl        usbhsg_handler_recv_by_ready
+
+#define usbhsg_handler_send_packet      usbhsg_handler_send_by_ready
+#define usbhsg_handler_recv_packet      usbhsg_handler_recv_by_ready
+
+/*
+ *              USB_TYPE_STANDARD / clear feature functions
+ */
+static int usbhsg_recip_handler_std_control_done(struct usbhs_priv *priv,
+                                                 struct usbhsg_uep *uep,
+                                                 struct usb_ctrlrequest *ctrl)
+{
+        struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
+        struct usbhsg_uep *dcp = usbhsg_gpriv_to_dcp(gpriv);
+        struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(dcp);
+
+        usbhs_dcp_control_transfer_done(pipe);
+
+        return 0;
+}
+
+static int usbhsg_recip_handler_std_clear_endpoint(struct usbhs_priv *priv,
+                                                   struct usbhsg_uep *uep,
+                                                   struct usb_ctrlrequest *ctrl)
+{
+        struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
+        struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
+
+        if (!usbhsg_status_has(gpriv, USBHSG_STATUS_WEDGE)) {
+                usbhs_fifo_disable(pipe);
+                usbhs_pipe_clear_sequence(pipe);
+                usbhs_fifo_enable(pipe);
+        }
+
+        usbhsg_recip_handler_std_control_done(priv, uep, ctrl);
+
+        usbhsg_queue_prepare(uep);
+
+        return 0;
+}
+
+struct usbhsg_recip_handle req_clear_feature = {
+        .name           = "clear feature",
+        .device         = usbhsg_recip_handler_std_control_done,
+        .interface      = usbhsg_recip_handler_std_control_done,
+        .endpoint       = usbhsg_recip_handler_std_clear_endpoint,
+};
+
+/*
+ *              USB_TYPE handler
+ */
+static int usbhsg_recip_run_handle(struct usbhs_priv *priv,
+                                   struct usbhsg_recip_handle *handler,
+                                   struct usb_ctrlrequest *ctrl)
+{
+        struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
+        struct device *dev = usbhsg_gpriv_to_dev(gpriv);
+        struct usbhsg_uep *uep;
+        int recip = ctrl->bRequestType & USB_RECIP_MASK;
+        int nth = le16_to_cpu(ctrl->wIndex) & USB_ENDPOINT_NUMBER_MASK;
+        int ret;
+        int (*func)(struct usbhs_priv *priv, struct usbhsg_uep *uep,
+                    struct usb_ctrlrequest *ctrl);
+        char *msg;
+
+        uep = usbhsg_gpriv_to_nth_uep(gpriv, nth);
+        if (!usbhsg_uep_to_pipe(uep)) {
+                dev_err(dev, "wrong recip request\n");
+                return -EINVAL;
+        }
+
+        switch (recip) {
+        case USB_RECIP_DEVICE:
+                msg     = "DEVICE";
+                func    = handler->device;
+                break;
+        case USB_RECIP_INTERFACE:
+                msg     = "INTERFACE";
+                func    = handler->interface;
+                break;
+        case USB_RECIP_ENDPOINT:
+                msg     = "ENDPOINT";
+                func    = handler->endpoint;
+                break;
+        default:
+                dev_warn(dev, "unsupported RECIP(%d)\n", recip);
+                func = NULL;
+                ret = -EINVAL;
+        }
+
+        if (func) {
+                dev_dbg(dev, "%s (pipe %d :%s)\n", handler->name, nth, msg);
+                ret = func(priv, uep, ctrl);
+        }
+
+        return ret;
+}
+
+/*
+ *              irq functions
+ *
+ * it will be called from usbhs_interrupt
+ */
+static int usbhsg_irq_dev_state(struct usbhs_priv *priv,
+                                struct usbhs_irq_state *irq_state)
+{
+        struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
+        struct device *dev = usbhsg_gpriv_to_dev(gpriv);
+
+        gpriv->gadget.speed = usbhs_status_get_usb_speed(irq_state);
+
+        dev_dbg(dev, "state = %x : speed : %d\n",
+                usbhs_status_get_device_state(irq_state),
+                gpriv->gadget.speed);
+
+        return 0;
+}
+
+static int usbhsg_irq_ctrl_stage(struct usbhs_priv *priv,
+                                 struct usbhs_irq_state *irq_state)
+{
+        struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
+        struct usbhsg_uep *dcp = usbhsg_gpriv_to_dcp(gpriv);
+        struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(dcp);
+        struct device *dev = usbhsg_gpriv_to_dev(gpriv);
+        struct usb_ctrlrequest ctrl;
+        struct usbhsg_recip_handle *recip_handler = NULL;
+        int stage = usbhs_status_get_ctrl_stage(irq_state);
+        int ret = 0;
+
+        dev_dbg(dev, "stage = %d\n", stage);
+
+        /*
+         * see Manual
+         *
+         *  "Operation"
+         *  - "Interrupt Function"
+         *    - "Control Transfer Stage Transition Interrupt"
+         *      - Fig. "Control Transfer Stage Transitions"
+         */
+
+        switch (stage) {
+        case READ_DATA_STAGE:
+                dcp->handler = &usbhsg_handler_send_ctrl;
+                break;
+        case WRITE_DATA_STAGE:
+                dcp->handler = &usbhsg_handler_recv_ctrl;
+                break;
+        case NODATA_STATUS_STAGE:
+                dcp->handler = &usbhsg_handler_ctrl_stage_end;
+                break;
+        default:
+                return ret;
+        }
+
+        /*
+         * get usb request
+         */
+        usbhs_usbreq_get_val(priv, &ctrl);
+
+        switch (ctrl.bRequestType & USB_TYPE_MASK) {
+        case USB_TYPE_STANDARD:
+                switch (ctrl.bRequest) {
+                case USB_REQ_CLEAR_FEATURE:
+                        recip_handler = &req_clear_feature;
+                        break;
+                }
+        }
+
+        /*
+         * setup stage / run recip
+         */
+        if (recip_handler)
+                ret = usbhsg_recip_run_handle(priv, recip_handler, &ctrl);
+        else
+                ret = gpriv->driver->setup(&gpriv->gadget, &ctrl);
+
+        if (ret < 0)
+                usbhs_fifo_stall(pipe);
+
+        return ret;
+}
+
+static int usbhsg_irq_empty(struct usbhs_priv *priv,
+                            struct usbhs_irq_state *irq_state)
+{
+        struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
+        struct usbhsg_uep *uep;
+        struct usbhs_pipe *pipe;
+        struct device *dev = usbhsg_gpriv_to_dev(gpriv);
+        int i, ret;
+
+        if (!irq_state->bempsts) {
+                dev_err(dev, "debug %s !!\n", __func__);
+                return -EIO;
+        }
+
+        dev_dbg(dev, "irq empty [0x%04x]\n", irq_state->bempsts);
+
+        /*
+         * search interrupted "pipe"
+         * not "uep".
+         */
+        usbhs_for_each_pipe_with_dcp(pipe, priv, i) {
+                if (!(irq_state->bempsts & (1 << i)))
+                        continue;
+
+                uep     = usbhsg_pipe_to_uep(pipe);
+                ret     = usbhsg_queue_handle(uep);
+                if (ret < 0)
+                        dev_err(dev, "send error %d : %d\n", i, ret);
+        }
+
+        return 0;
+}
+
+static int usbhsg_irq_ready(struct usbhs_priv *priv,
+                            struct usbhs_irq_state *irq_state)
+{
+        struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
+        struct usbhsg_uep *uep;
+        struct usbhs_pipe *pipe;
+        struct device *dev = usbhsg_gpriv_to_dev(gpriv);
+        int i, ret;
+
+        if (!irq_state->brdysts) {
+                dev_err(dev, "debug %s !!\n", __func__);
+                return -EIO;
+        }
+
+        dev_dbg(dev, "irq ready [0x%04x]\n", irq_state->brdysts);
+
+        /*
+         * search interrupted "pipe"
+         * not "uep".
+         */
+        usbhs_for_each_pipe_with_dcp(pipe, priv, i) {
+                if (!(irq_state->brdysts & (1 << i)))
+                        continue;
+
+                uep     = usbhsg_pipe_to_uep(pipe);
+                ret     = usbhsg_queue_handle(uep);
+                if (ret < 0)
+                        dev_err(dev, "receive error %d : %d\n", i, ret);
+        }
+
+        return 0;
+}
+
+/*
+ *
+ *              usb_dcp_ops
+ *
+ */
+static int usbhsg_dcp_enable(struct usbhsg_uep *uep)
+{
+        struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
+        struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv);
+        struct usbhs_pipe *pipe;
+
+        /*
+         *********  assume under spin lock  *********
+         */
+
+        pipe = usbhs_dcp_malloc(priv);
+        if (!pipe)
+                return -EIO;
+
+        uep->pipe               = pipe;
+        uep->pipe->mod_private  = uep;
+        INIT_LIST_HEAD(&uep->list);
+
+        return 0;
+}
+
+#define usbhsg_dcp_disable usbhsg_pipe_disable
+static int usbhsg_pipe_disable(struct usbhsg_uep *uep)
+{
+        struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
+        struct usbhsg_request *ureq;
+        int disable = 0;
+
+        /*
+         *********  assume under spin lock  *********
+         */
+
+        usbhs_fifo_disable(pipe);
+
+        /*
+         * disable pipe irq
+         */
+        usbhsg_irq_empty_ctrl(uep, disable);
+        usbhsg_irq_ready_ctrl(uep, disable);
+
+        while (1) {
+                ureq = usbhsg_queue_get(uep);
+                if (!ureq)
+                        break;
+
+                usbhsg_queue_pop(uep, ureq, -ECONNRESET);
+        }
+
+        return 0;
+}
+
+static void usbhsg_uep_init(struct usbhsg_gpriv *gpriv)
+{
+        int i;
+        struct usbhsg_uep *uep;
+
+        usbhsg_for_each_uep_with_dcp(uep, gpriv, i)
+                uep->pipe = NULL;
+}
+
+/*
+ *
+ *              usb_ep_ops
+ *
+ */
+static int usbhsg_ep_enable(struct usb_ep *ep,
+                         const struct usb_endpoint_descriptor *desc)
+{
+        struct usbhsg_uep *uep   = usbhsg_ep_to_uep(ep);
+        struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
+        struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv);
+        struct usbhs_pipe *pipe;
+        spinlock_t *lock;
+        unsigned long flags;
+        int ret = -EIO;
+
+        /*
+         * if it already have pipe,
+         * nothing to do
+         */
+        if (uep->pipe)
+                return 0;
+
+        /********************  spin lock ********************/
+        lock = usbhsg_trylock(gpriv, &flags);
+
+        pipe = usbhs_pipe_malloc(priv, desc);
+        if (pipe) {
+                uep->pipe               = pipe;
+                pipe->mod_private       = uep;
+                INIT_LIST_HEAD(&uep->list);
+
+                if (usb_endpoint_dir_in(desc))
+                        uep->handler = &usbhsg_handler_send_packet;
+                else
+                        uep->handler = &usbhsg_handler_recv_packet;
+
+                ret = 0;
+        }
+
+        usbhsg_unlock(lock, &flags);
+        /********************  spin unlock ******************/
+
+        return ret;
+}
+
+static int usbhsg_ep_disable(struct usb_ep *ep)
+{
+        struct usbhsg_uep *uep = usbhsg_ep_to_uep(ep);
+        struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
+        spinlock_t *lock;
+        unsigned long flags;
+        int ret;
+
+        /********************  spin lock ********************/
+        lock = usbhsg_trylock(gpriv, &flags);
+
+        ret = usbhsg_pipe_disable(uep);
+
+        usbhsg_unlock(lock, &flags);
+        /********************  spin unlock ******************/
+
+        return ret;
+}
+
+static struct usb_request *usbhsg_ep_alloc_request(struct usb_ep *ep,
+                                                   gfp_t gfp_flags)
+{
+        struct usbhsg_request *ureq;
+
+        ureq = kzalloc(sizeof *ureq, gfp_flags);
+        if (!ureq)
+                return NULL;
+
+        INIT_LIST_HEAD(&ureq->node);
+        return &ureq->req;
+}
+
+static void usbhsg_ep_free_request(struct usb_ep *ep,
+                                   struct usb_request *req)
+{
+        struct usbhsg_request *ureq = usbhsg_req_to_ureq(req);
+
+        WARN_ON(!list_empty(&ureq->node));
+        kfree(ureq);
+}
+
+static int usbhsg_ep_queue(struct usb_ep *ep, struct usb_request *req,
+                          gfp_t gfp_flags)
+{
+        struct usbhsg_uep *uep = usbhsg_ep_to_uep(ep);
+        struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
+        struct usbhsg_request *ureq = usbhsg_req_to_ureq(req);
+        struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
+        spinlock_t *lock;
+        unsigned long flags;
+        int ret = 0;
+
+        /*
+         * CAUTION [*endpoint queue*]
+         *
+         * This function will be called from usb_request :: complete
+         * or usb driver timing.
+         * If this function is called from usb_request :: complete,
+         * it is already under spinlock on this driver.
+         * but it is called frm usb driver, this function should call spinlock.
+         *
+         * This function is using usbshg_trylock to solve this issue.
+         * if "is_locked" is 1, this mean this function lock it.
+         * but if it is 0, this mean it is already under spin lock.
+         * see also
+         *   CAUTION [*queue handler*]
+         *   CAUTION [*request complete*]
+         */
+
+        /********************  spin lock ********************/
+        lock = usbhsg_trylock(gpriv, &flags);
+
+        /* param check */
+        if (usbhsg_is_not_connected(gpriv)      ||
+            unlikely(!gpriv->driver)            ||
+            unlikely(!pipe))
+                ret = -ESHUTDOWN;
+        else
+                usbhsg_queue_push(uep, ureq);
+
+        usbhsg_unlock(lock, &flags);
+        /********************  spin unlock ******************/
+
+        usbhsg_queue_prepare(uep);
+
+        return ret;
+}
+
+static int usbhsg_ep_dequeue(struct usb_ep *ep, struct usb_request *req)
+{
+        struct usbhsg_uep *uep = usbhsg_ep_to_uep(ep);
+        struct usbhsg_request *ureq = usbhsg_req_to_ureq(req);
+        struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
+        spinlock_t *lock;
+        unsigned long flags;
+
+        /*
+         * see
+         *   CAUTION [*queue handler*]
+         *   CAUTION [*endpoint queue*]
+         *   CAUTION [*request complete*]
+         */
+
+        /********************  spin lock ********************/
+        lock = usbhsg_trylock(gpriv, &flags);
+
+        usbhsg_queue_pop(uep, ureq, -ECONNRESET);
+
+        usbhsg_unlock(lock, &flags);
+        /********************  spin unlock ******************/
+
+        return 0;
+}
+
+static int __usbhsg_ep_set_halt_wedge(struct usb_ep *ep, int halt, int wedge)
+{
+        struct usbhsg_uep *uep = usbhsg_ep_to_uep(ep);
+        struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
+        struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
+        struct device *dev = usbhsg_gpriv_to_dev(gpriv);
+        spinlock_t *lock;
+        unsigned long flags;
+        int ret = -EAGAIN;
+
+        /*
+         * see
+         *   CAUTION [*queue handler*]
+         *   CAUTION [*endpoint queue*]
+         *   CAUTION [*request complete*]
+         */
+
+        /********************  spin lock ********************/
+        lock = usbhsg_trylock(gpriv, &flags);
+        if (!usbhsg_queue_get(uep)) {
+
+                dev_dbg(dev, "set halt %d (pipe %d)\n",
+                        halt, usbhs_pipe_number(pipe));
+
+                if (halt)
+                        usbhs_fifo_stall(pipe);
+                else
+                        usbhs_fifo_disable(pipe);
+
+                if (halt && wedge)
+                        usbhsg_status_set(gpriv, USBHSG_STATUS_WEDGE);
+                else
+                        usbhsg_status_clr(gpriv, USBHSG_STATUS_WEDGE);
+
+                ret = 0;
+        }
+
+        usbhsg_unlock(lock, &flags);
+        /********************  spin unlock ******************/
+
+        return ret;
+}
+
+static int usbhsg_ep_set_halt(struct usb_ep *ep, int value)
+{
+        return __usbhsg_ep_set_halt_wedge(ep, value, 0);
+}
+
+static int usbhsg_ep_set_wedge(struct usb_ep *ep)
+{
+        return __usbhsg_ep_set_halt_wedge(ep, 1, 1);
+}
+
+static struct usb_ep_ops usbhsg_ep_ops = {
+        .enable         = usbhsg_ep_enable,
+        .disable        = usbhsg_ep_disable,
+
+        .alloc_request  = usbhsg_ep_alloc_request,
+        .free_request   = usbhsg_ep_free_request,
+
+        .queue          = usbhsg_ep_queue,
+        .dequeue        = usbhsg_ep_dequeue,
+
+        .set_halt       = usbhsg_ep_set_halt,
+        .set_wedge      = usbhsg_ep_set_wedge,
+};
+
+/*
+ *              usb module start/end
+ */
+static int usbhsg_try_start(struct usbhs_priv *priv, u32 status)
+{
+        struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
+        struct usbhsg_uep *dcp = usbhsg_gpriv_to_dcp(gpriv);
+        struct usbhs_mod *mod = usbhs_mod_get_current(priv);
+        struct device *dev = usbhs_priv_to_dev(priv);
+        spinlock_t *lock;
+        unsigned long flags;
+
+        /********************  spin lock ********************/
+        lock = usbhsg_trylock(gpriv, &flags);
+
+        /*
+         * enable interrupt and systems if ready
+         */
+        usbhsg_status_set(gpriv, status);
+        if (!(usbhsg_status_has(gpriv, USBHSG_STATUS_STARTED) &&
+              usbhsg_status_has(gpriv, USBHSG_STATUS_REGISTERD)))
+                goto usbhsg_try_start_unlock;
+
+        dev_dbg(dev, "start gadget\n");
+
+        /*
+         * pipe initialize and enable DCP
+         */
+        usbhs_pipe_init(priv);
+        usbhsg_uep_init(gpriv);
+        usbhsg_dcp_enable(dcp);
+
+        /*
+         * system config enble
+         * - HI speed
+         * - function
+         * - usb module
+         */
+        usbhs_sys_hispeed_ctrl(priv, 1);
+        usbhs_sys_function_ctrl(priv, 1);
+        usbhs_sys_usb_ctrl(priv, 1);
+
+        /*
+         * enable irq callback
+         */
+        mod->irq_dev_state      = usbhsg_irq_dev_state;
+        mod->irq_ctrl_stage     = usbhsg_irq_ctrl_stage;
+        mod->irq_empty          = usbhsg_irq_empty;
+        mod->irq_ready          = usbhsg_irq_ready;
+        mod->irq_bempsts        = 0;
+        mod->irq_brdysts        = 0;
+        usbhs_irq_callback_update(priv, mod);
+
+usbhsg_try_start_unlock:
+        usbhsg_unlock(lock, &flags);
+        /********************  spin unlock ********************/
+
+        return 0;
+}
+
+static int usbhsg_try_stop(struct usbhs_priv *priv, u32 status)
+{
+        struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
+        struct usbhs_mod *mod = usbhs_mod_get_current(priv);
+        struct usbhsg_uep *dcp = usbhsg_gpriv_to_dcp(gpriv);
+        struct device *dev = usbhs_priv_to_dev(priv);
+        spinlock_t *lock;
+        unsigned long flags;
+
+        /********************  spin lock ********************/
+        lock = usbhsg_trylock(gpriv, &flags);
+
+        /*
+         * disable interrupt and systems if 1st try
+         */
+        usbhsg_status_clr(gpriv, status);
+        if (!usbhsg_status_has(gpriv, USBHSG_STATUS_STARTED) &&
+            !usbhsg_status_has(gpriv, USBHSG_STATUS_REGISTERD))
+                goto usbhsg_try_stop_unlock;
+
+        /* disable all irq */
+        mod->irq_dev_state      = NULL;
+        mod->irq_ctrl_stage     = NULL;
+        mod->irq_empty          = NULL;
+        mod->irq_ready          = NULL;
+        mod->irq_bempsts        = 0;
+        mod->irq_brdysts        = 0;
+        usbhs_irq_callback_update(priv, mod);
+
+        usbhsg_dcp_disable(dcp);
+
+        gpriv->gadget.speed = USB_SPEED_UNKNOWN;
+
+        /* disable sys */
+        usbhs_sys_hispeed_ctrl(priv, 0);
+        usbhs_sys_function_ctrl(priv, 0);
+        usbhs_sys_usb_ctrl(priv, 0);
+
+        usbhsg_unlock(lock, &flags);
+        /********************  spin unlock ********************/
+
+        if (gpriv->driver &&
+            gpriv->driver->disconnect)
+                gpriv->driver->disconnect(&gpriv->gadget);
+
+        dev_dbg(dev, "stop gadget\n");
+
+        return 0;
+
+usbhsg_try_stop_unlock:
+        usbhsg_unlock(lock, &flags);
+
+        return 0;
+}
+
+/*
+ *
+ *              linux usb function
+ *
+ */
+struct usbhsg_gpriv *the_controller;
+int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
+                            int (*bind)(struct usb_gadget *))
+{
+        struct usbhsg_gpriv *gpriv = the_controller;
+        struct usbhs_priv *priv;
+        struct device *dev;
+        int ret;
+
+        if (!bind               ||
+            !driver             ||
+            !driver->setup      ||
+            driver->speed != USB_SPEED_HIGH)
+                return -EINVAL;
+        if (!gpriv)
+                return -ENODEV;
+        if (gpriv->driver)
+                return -EBUSY;
+
+        dev  = usbhsg_gpriv_to_dev(gpriv);
+        priv = usbhsg_gpriv_to_priv(gpriv);
+
+        /* first hook up the driver ... */
+        gpriv->driver = driver;
+        gpriv->gadget.dev.driver = &driver->driver;
+
+        ret = device_add(&gpriv->gadget.dev);
+        if (ret) {
+                dev_err(dev, "device_add error %d\n", ret);
+                goto add_fail;
+        }
+
+        ret = bind(&gpriv->gadget);
+        if (ret) {
+                dev_err(dev, "bind to driver %s error %d\n",
+                        driver->driver.name, ret);
+                goto bind_fail;
+        }
+
+        dev_dbg(dev, "bind %s\n", driver->driver.name);
+
+        return usbhsg_try_start(priv, USBHSG_STATUS_REGISTERD);
+
+bind_fail:
+        device_del(&gpriv->gadget.dev);
+add_fail:
+        gpriv->driver = NULL;
+        gpriv->gadget.dev.driver = NULL;
+
+        return ret;
+}
+EXPORT_SYMBOL(usb_gadget_probe_driver);
+
+int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
+{
+        struct usbhsg_gpriv *gpriv = the_controller;
+        struct usbhs_priv *priv;
+        struct device *dev = usbhsg_gpriv_to_dev(gpriv);
+
+        if (!gpriv)
+                return -ENODEV;
+
+        if (!driver             ||
+            !driver->unbind     ||
+            driver != gpriv->driver)
+                return -EINVAL;
+
+        dev  = usbhsg_gpriv_to_dev(gpriv);
+        priv = usbhsg_gpriv_to_priv(gpriv);
+
+        usbhsg_try_stop(priv, USBHSG_STATUS_REGISTERD);
+        device_del(&gpriv->gadget.dev);
+        gpriv->driver = NULL;
+
+        if (driver->disconnect)
+                driver->disconnect(&gpriv->gadget);
+
+        driver->unbind(&gpriv->gadget);
+        dev_dbg(dev, "unbind %s\n", driver->driver.name);
+
+        return 0;
+}
+EXPORT_SYMBOL(usb_gadget_unregister_driver);
+
+/*
+ *              usb gadget ops
+ */
+static int usbhsg_get_frame(struct usb_gadget *gadget)
+{
+        struct usbhsg_gpriv *gpriv = usbhsg_gadget_to_gpriv(gadget);
+        struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv);
+
+        return usbhs_frame_get_num(priv);
+}
+
+static struct usb_gadget_ops usbhsg_gadget_ops = {
+        .get_frame              = usbhsg_get_frame,
+};
+
+static int usbhsg_start(struct usbhs_priv *priv)
+{
+        return usbhsg_try_start(priv, USBHSG_STATUS_STARTED);
+}
+
+static int usbhsg_stop(struct usbhs_priv *priv)
+{
+        return usbhsg_try_stop(priv, USBHSG_STATUS_STARTED);
+}
+
+int __devinit usbhs_mod_gadget_probe(struct usbhs_priv *priv)
+{
+        struct usbhsg_gpriv *gpriv;
+        struct usbhsg_uep *uep;
+        struct device *dev = usbhs_priv_to_dev(priv);
+        int pipe_size = usbhs_get_dparam(priv, pipe_size);
+        int i;
+
+        gpriv = kzalloc(sizeof(struct usbhsg_gpriv), GFP_KERNEL);
+        if (!gpriv) {
+                dev_err(dev, "Could not allocate gadget priv\n");
+                return -ENOMEM;
+        }
+
+        uep = kzalloc(sizeof(struct usbhsg_uep) * pipe_size, GFP_KERNEL);
+        if (!uep) {
+                dev_err(dev, "Could not allocate ep\n");
+                goto usbhs_mod_gadget_probe_err_gpriv;
+        }
+
+        /*
+         * CAUTION
+         *
+         * There is no guarantee that it is possible to access usb module here.
+         * Don't accesses to it.
+         * The accesse will be enable after "usbhsg_start"
+         */
+
+        /*
+         * register itself
+         */
+        usbhs_mod_register(priv, &gpriv->mod, USBHS_GADGET);
+
+        /* init gpriv */
+        gpriv->mod.name         = "gadget";
+        gpriv->mod.start        = usbhsg_start;
+        gpriv->mod.stop         = usbhsg_stop;
+        gpriv->uep              = uep;
+        gpriv->uep_size         = pipe_size;
+        usbhsg_status_init(gpriv);
+
+        /*
+         * init gadget
+         */
+        device_initialize(&gpriv->gadget.dev);
+        dev_set_name(&gpriv->gadget.dev, "gadget");
+        gpriv->gadget.dev.parent        = dev;
+        gpriv->gadget.name              = "renesas_usbhs_udc";
+        gpriv->gadget.ops               = &usbhsg_gadget_ops;
+        gpriv->gadget.is_dualspeed      = 1;
+
+        INIT_LIST_HEAD(&gpriv->gadget.ep_list);
+
+        /*
+         * init usb_ep
+         */
+        usbhsg_for_each_uep_with_dcp(uep, gpriv, i) {
+                uep->gpriv      = gpriv;
+                snprintf(uep->ep_name, EP_NAME_SIZE, "ep%d", i);
+
+                uep->ep.name            = uep->ep_name;
+                uep->ep.ops             = &usbhsg_ep_ops;
+                INIT_LIST_HEAD(&uep->ep.ep_list);
+                INIT_LIST_HEAD(&uep->list);
+
+                /* init DCP */
+                if (usbhsg_is_dcp(uep)) {
+                        gpriv->gadget.ep0 = &uep->ep;
+                        uep->ep.maxpacket = 64;
+                }
+                /* init normal pipe */
+                else {
+                        uep->ep.maxpacket = 512;
+                        list_add_tail(&uep->ep.ep_list, &gpriv->gadget.ep_list);
+                }
+        }
+
+        the_controller = gpriv;
+
+        dev_info(dev, "gadget probed\n");
+
+        return 0;
+
+usbhs_mod_gadget_probe_err_gpriv:
+        kfree(gpriv);
+
+        return -ENOMEM;
+}
+
+void __devexit usbhs_mod_gadget_remove(struct usbhs_priv *priv)
+{
+        struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
+
+        kfree(gpriv->uep);
+        kfree(gpriv);
+}
diff --git a/drivers/usb/renesas_usbhs/pipe.c b/drivers/usb/renesas_usbhs/pipe.c
new file mode 100644
index 000000000000..bc4521c54261
--- /dev/null
+++ b/drivers/usb/renesas_usbhs/pipe.c
@@ -0,0 +1,874 @@
+/*
+ * Renesas USB driver
+ *
+ * Copyright (C) 2011 Renesas Solutions Corp.
+ * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
+ *
+ * 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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+#include <linux/delay.h>
+#include <linux/io.h>
+#include <linux/slab.h>
+#include "./common.h"
+#include "./pipe.h"
+
+/*
+ *              macros
+ */
+#define usbhsp_priv_to_pipeinfo(pr)     (&(pr)->pipe_info)
+#define usbhsp_pipe_to_priv(p)          ((p)->priv)
+
+#define usbhsp_addr_offset(p)   ((usbhs_pipe_number(p) - 1) * 2)
+
+#define usbhsp_is_dcp(p)        ((p)->priv->pipe_info.pipe == (p))
+
+#define usbhsp_flags_set(p, f)  ((p)->flags |=  USBHS_PIPE_FLAGS_##f)
+#define usbhsp_flags_clr(p, f)  ((p)->flags &= ~USBHS_PIPE_FLAGS_##f)
+#define usbhsp_flags_has(p, f)  ((p)->flags &   USBHS_PIPE_FLAGS_##f)
+#define usbhsp_flags_init(p)    do {(p)->flags = 0; } while (0)
+
+#define usbhsp_type(p)          ((p)->pipe_type)
+#define usbhsp_type_is(p, t)    ((p)->pipe_type == t)
+
+/*
+ * for debug
+ */
+static char *usbhsp_pipe_name[] = {
+        [USB_ENDPOINT_XFER_CONTROL]     = "DCP",
+        [USB_ENDPOINT_XFER_BULK]        = "BULK",
+        [USB_ENDPOINT_XFER_INT]         = "INT",
+        [USB_ENDPOINT_XFER_ISOC]        = "ISO",
+};
+
+/*
+ *              usb request functions
+ */
+void usbhs_usbreq_get_val(struct usbhs_priv *priv, struct usb_ctrlrequest *req)
+{
+        u16 val;
+
+        val = usbhs_read(priv, USBREQ);
+        req->bRequest           = (val >> 8) & 0xFF;
+        req->bRequestType       = (val >> 0) & 0xFF;
+
+        req->wValue     = usbhs_read(priv, USBVAL);
+        req->wIndex     = usbhs_read(priv, USBINDX);
+        req->wLength    = usbhs_read(priv, USBLENG);
+}
+
+void usbhs_usbreq_set_val(struct usbhs_priv *priv, struct usb_ctrlrequest *req)
+{
+        usbhs_write(priv, USBREQ,  (req->bRequest << 8) | req->bRequestType);
+        usbhs_write(priv, USBVAL,  req->wValue);
+        usbhs_write(priv, USBINDX, req->wIndex);
+        usbhs_write(priv, USBLENG, req->wLength);
+}
+
+/*
+ *              DCPCTR/PIPEnCTR functions
+ */
+static void usbhsp_pipectrl_set(struct usbhs_pipe *pipe, u16 mask, u16 val)
+{
+        struct usbhs_priv *priv = usbhsp_pipe_to_priv(pipe);
+        int offset = usbhsp_addr_offset(pipe);
+
+        if (usbhsp_is_dcp(pipe))
+                usbhs_bset(priv, DCPCTR, mask, val);
+        else
+                usbhs_bset(priv, PIPEnCTR + offset, mask, val);
+}
+
+static u16 usbhsp_pipectrl_get(struct usbhs_pipe *pipe)
+{
+        struct usbhs_priv *priv = usbhsp_pipe_to_priv(pipe);
+        int offset = usbhsp_addr_offset(pipe);
+
+        if (usbhsp_is_dcp(pipe))
+                return usbhs_read(priv, DCPCTR);
+        else
+                return usbhs_read(priv, PIPEnCTR + offset);
+}
+
+/*
+ *              DCP/PIPE functions
+ */
+static void __usbhsp_pipe_xxx_set(struct usbhs_pipe *pipe,
+                                  u16 dcp_reg, u16 pipe_reg,
+                                  u16 mask, u16 val)
+{
+        struct usbhs_priv *priv = usbhsp_pipe_to_priv(pipe);
+
+        if (usbhsp_is_dcp(pipe))
+                usbhs_bset(priv, dcp_reg, mask, val);
+        else
+                usbhs_bset(priv, pipe_reg, mask, val);
+}
+
+static u16 __usbhsp_pipe_xxx_get(struct usbhs_pipe *pipe,
+                                 u16 dcp_reg, u16 pipe_reg)
+{
+        struct usbhs_priv *priv = usbhsp_pipe_to_priv(pipe);
+
+        if (usbhsp_is_dcp(pipe))
+                return usbhs_read(priv, dcp_reg);
+        else
+                return usbhs_read(priv, pipe_reg);
+}
+
+/*
+ *              DCPCFG/PIPECFG functions
+ */
+static void usbhsp_pipe_cfg_set(struct usbhs_pipe *pipe, u16 mask, u16 val)
+{
+        __usbhsp_pipe_xxx_set(pipe, DCPCFG, PIPECFG, mask, val);
+}
+
+/*
+ *              PIPEBUF
+ */
+static void usbhsp_pipe_buf_set(struct usbhs_pipe *pipe, u16 mask, u16 val)
+{
+        if (usbhsp_is_dcp(pipe))
+                return;
+
+        __usbhsp_pipe_xxx_set(pipe, 0, PIPEBUF, mask, val);
+}
+
+/*
+ *              DCPMAXP/PIPEMAXP
+ */
+static void usbhsp_pipe_maxp_set(struct usbhs_pipe *pipe, u16 mask, u16 val)
+{
+        __usbhsp_pipe_xxx_set(pipe, DCPMAXP, PIPEMAXP, mask, val);
+}
+
+static u16 usbhsp_pipe_maxp_get(struct usbhs_pipe *pipe)
+{
+        return __usbhsp_pipe_xxx_get(pipe, DCPMAXP, PIPEMAXP);
+}
+
+/*
+ *              pipe control functions
+ */
+static void usbhsp_pipe_select(struct usbhs_pipe *pipe)
+{
+        struct usbhs_priv *priv = usbhsp_pipe_to_priv(pipe);
+
+        /*
+         * On pipe, this is necessary before
+         * accesses to below registers.
+         *
+         * PIPESEL      : usbhsp_pipe_select
+         * PIPECFG      : usbhsp_pipe_cfg_xxx
+         * PIPEBUF      : usbhsp_pipe_buf_xxx
+         * PIPEMAXP     : usbhsp_pipe_maxp_xxx
+         * PIPEPERI
+         */
+
+        /*
+         * if pipe is dcp, no pipe is selected.
+         * it is no problem, because dcp have its register
+         */
+        usbhs_write(priv, PIPESEL, 0xF & usbhs_pipe_number(pipe));
+}
+
+static int usbhsp_pipe_barrier(struct usbhs_pipe *pipe)
+{
+        struct usbhs_priv *priv = usbhsp_pipe_to_priv(pipe);
+        int timeout = 1024;
+        u16 val;
+
+        /*
+         * make sure....
+         *
+         * Modify these bits when CSSTS = 0, PID = NAK, and no pipe number is
+         * specified by the CURPIPE bits.
+         * When changing the setting of this bit after changing
+         * the PID bits for the selected pipe from BUF to NAK,
+         * check that CSSTS = 0 and PBUSY = 0.
+         */
+
+        /*
+         * CURPIPE bit = 0
+         *
+         * see also
+         *  "Operation"
+         *  - "Pipe Control"
+         *   - "Pipe Control Registers Switching Procedure"
+         */
+        usbhs_write(priv, CFIFOSEL, 0);
+        usbhs_fifo_disable(pipe);
+
+        do {
+                val  = usbhsp_pipectrl_get(pipe);
+                val &= CSSTS | PID_MASK;
+                if (!val)
+                        return 0;
+
+                udelay(10);
+
+        } while (timeout--);
+
+        return -EBUSY;
+}
+
+static int usbhsp_pipe_is_accessible(struct usbhs_pipe *pipe)
+{
+        u16 val;
+
+        val = usbhsp_pipectrl_get(pipe);
+        if (val & BSTS)
+                return 0;
+
+        return -EBUSY;
+}
+
+/*
+ *              PID ctrl
+ */
+static void __usbhsp_pid_try_nak_if_stall(struct usbhs_pipe *pipe)
+{
+        u16 pid = usbhsp_pipectrl_get(pipe);
+
+        pid &= PID_MASK;
+
+        /*
+         * see
+         * "Pipe n Control Register" - "PID"
+         */
+        switch (pid) {
+        case PID_STALL11:
+                usbhsp_pipectrl_set(pipe, PID_MASK, PID_STALL10);
+                /* fall-through */
+        case PID_STALL10:
+                usbhsp_pipectrl_set(pipe, PID_MASK, PID_NAK);
+        }
+}
+
+void usbhs_fifo_disable(struct usbhs_pipe *pipe)
+{
+        int timeout = 1024;
+        u16 val;
+
+        /* see "Pipe n Control Register" - "PID" */
+        __usbhsp_pid_try_nak_if_stall(pipe);
+
+        usbhsp_pipectrl_set(pipe, PID_MASK, PID_NAK);
+
+        do {
+                val  = usbhsp_pipectrl_get(pipe);
+                val &= PBUSY;
+                if (!val)
+                        break;
+
+                udelay(10);
+        } while (timeout--);
+}
+
+void usbhs_fifo_enable(struct usbhs_pipe *pipe)
+{
+        /* see "Pipe n Control Register" - "PID" */
+        __usbhsp_pid_try_nak_if_stall(pipe);
+
+        usbhsp_pipectrl_set(pipe, PID_MASK, PID_BUF);
+}
+
+void usbhs_fifo_stall(struct usbhs_pipe *pipe)
+{
+        u16 pid = usbhsp_pipectrl_get(pipe);
+
+        pid &= PID_MASK;
+
+        /*
+         * see
+         * "Pipe n Control Register" - "PID"
+         */
+        switch (pid) {
+        case PID_NAK:
+                usbhsp_pipectrl_set(pipe, PID_MASK, PID_STALL10);
+                break;
+        case PID_BUF:
+                usbhsp_pipectrl_set(pipe, PID_MASK, PID_STALL11);
+                break;
+        }
+}
+
+/*
+ *              CFIFO ctrl
+ */
+void usbhs_fifo_send_terminator(struct usbhs_pipe *pipe)
+{
+        struct usbhs_priv *priv = usbhsp_pipe_to_priv(pipe);
+
+        usbhs_bset(priv, CFIFOCTR, BVAL, BVAL);
+}
+
+static void usbhsp_fifo_clear(struct usbhs_pipe *pipe)
+{
+        struct usbhs_priv *priv = usbhsp_pipe_to_priv(pipe);
+
+        usbhs_write(priv, CFIFOCTR, BCLR);
+}
+
+static int usbhsp_fifo_barrier(struct usbhs_priv *priv)
+{
+        int timeout = 1024;
+
+        do {
+                /* The FIFO port is accessible */
+                if (usbhs_read(priv, CFIFOCTR) & FRDY)
+                        return 0;
+
+                udelay(10);
+        } while (timeout--);
+
+        return -EBUSY;
+}
+
+static int usbhsp_fifo_rcv_len(struct usbhs_priv *priv)
+{
+        return usbhs_read(priv, CFIFOCTR) & DTLN_MASK;
+}
+
+static int usbhsp_fifo_select(struct usbhs_pipe *pipe, int write)
+{
+        struct usbhs_priv *priv = usbhsp_pipe_to_priv(pipe);
+        struct device *dev = usbhs_priv_to_dev(priv);
+        int timeout = 1024;
+        u16 mask = ((1 << 5) | 0xF);            /* mask of ISEL | CURPIPE */
+        u16 base = usbhs_pipe_number(pipe);     /* CURPIPE */
+
+        if (usbhsp_is_dcp(pipe))
+                base |= (1 == write) << 5;      /* ISEL */
+
+        /* "base" will be used below  */
+        usbhs_write(priv, CFIFOSEL, base | MBW_32);
+
+        /* check ISEL and CURPIPE value */
+        while (timeout--) {
+                if (base == (mask & usbhs_read(priv, CFIFOSEL)))
+                        return 0;
+                udelay(10);
+        }
+
+        dev_err(dev, "fifo select error\n");
+
+        return -EIO;
+}
+
+int usbhs_fifo_prepare_write(struct usbhs_pipe *pipe)
+{
+        return usbhsp_fifo_select(pipe, 1);
+}
+
+int usbhs_fifo_write(struct usbhs_pipe *pipe, u8 *buf, int len)
+{
+        struct usbhs_priv *priv = usbhsp_pipe_to_priv(pipe);
+        void __iomem *addr = priv->base + CFIFO;
+        int maxp = usbhs_pipe_get_maxpacket(pipe);
+        int total_len;
+        int i, ret;
+
+        ret = usbhsp_pipe_is_accessible(pipe);
+        if (ret < 0)
+                return ret;
+
+        ret = usbhsp_fifo_select(pipe, 1);
+        if (ret < 0)
+                return ret;
+
+        ret = usbhsp_fifo_barrier(priv);
+        if (ret < 0)
+                return ret;
+
+        len = min(len, maxp);
+        total_len = len;
+
+        /*
+         * FIXME
+         *
+         * 32-bit access only
+         */
+        if (len >= 4 &&
+            !((unsigned long)buf & 0x03)) {
+                iowrite32_rep(addr, buf, len / 4);
+                len %= 4;
+                buf += total_len - len;
+        }
+
+        /* the rest operation */
+        for (i = 0; i < len; i++)
+                iowrite8(buf[i], addr + (0x03 - (i & 0x03)));
+
+        if (total_len < maxp)
+                usbhs_fifo_send_terminator(pipe);
+
+        return total_len;
+}
+
+int usbhs_fifo_prepare_read(struct usbhs_pipe *pipe)
+{
+        int ret;
+
+        /*
+         * select pipe and enable it to prepare packet receive
+         */
+        ret = usbhsp_fifo_select(pipe, 0);
+        if (ret < 0)
+                return ret;
+
+        usbhs_fifo_enable(pipe);
+
+        return ret;
+}
+
+int usbhs_fifo_read(struct usbhs_pipe *pipe, u8 *buf, int len)
+{
+        struct usbhs_priv *priv = usbhsp_pipe_to_priv(pipe);
+        void __iomem *addr = priv->base + CFIFO;
+        int rcv_len;
+        int i, ret;
+        int total_len;
+        u32 data = 0;
+
+        ret = usbhsp_fifo_select(pipe, 0);
+        if (ret < 0)
+                return ret;
+
+        ret = usbhsp_fifo_barrier(priv);
+        if (ret < 0)
+                return ret;
+
+        rcv_len = usbhsp_fifo_rcv_len(priv);
+
+        /*
+         * Buffer clear if Zero-Length packet
+         *
+         * see
+         * "Operation" - "FIFO Buffer Memory" - "FIFO Port Function"
+         */
+        if (0 == rcv_len) {
+                usbhsp_fifo_clear(pipe);
+                return 0;
+        }
+
+        len = min(rcv_len, len);
+        total_len = len;
+
+        /*
+         * FIXME
+         *
+         * 32-bit access only
+         */
+        if (len >= 4 &&
+            !((unsigned long)buf & 0x03)) {
+                ioread32_rep(addr, buf, len / 4);
+                len %= 4;
+                buf += rcv_len - len;
+        }
+
+        /* the rest operation */
+        for (i = 0; i < len; i++) {
+                if (!(i & 0x03))
+                        data = ioread32(addr);
+
+                buf[i] = (data >> ((i & 0x03) * 8)) & 0xff;
+        }
+
+        return total_len;
+}
+
+/*
+ *              pipe setup
+ */
+static int usbhsp_possible_double_buffer(struct usbhs_pipe *pipe)
+{
+        /*
+         * only ISO / BULK pipe can use double buffer
+         */
+        if (usbhsp_type_is(pipe, USB_ENDPOINT_XFER_BULK) ||
+            usbhsp_type_is(pipe, USB_ENDPOINT_XFER_ISOC))
+                return 1;
+
+        return 0;
+}
+
+static u16 usbhsp_setup_pipecfg(struct usbhs_pipe *pipe,
+                                const struct usb_endpoint_descriptor *desc,
+                                int is_host)
+{
+        u16 type = 0;
+        u16 bfre = 0;
+        u16 dblb = 0;
+        u16 cntmd = 0;
+        u16 dir = 0;
+        u16 epnum = 0;
+        u16 shtnak = 0;
+        u16 type_array[] = {
+                [USB_ENDPOINT_XFER_BULK] = TYPE_BULK,
+                [USB_ENDPOINT_XFER_INT]  = TYPE_INT,
+                [USB_ENDPOINT_XFER_ISOC] = TYPE_ISO,
+        };
+        int is_double = usbhsp_possible_double_buffer(pipe);
+
+        if (usbhsp_is_dcp(pipe))
+                return -EINVAL;
+
+        /*
+         * PIPECFG
+         *
+         * see
+         *  - "Register Descriptions" - "PIPECFG" register
+         *  - "Features"  - "Pipe configuration"
+         *  - "Operation" - "Pipe Control"
+         */
+
+        /* TYPE */
+        type = type_array[usbhsp_type(pipe)];
+
+        /* BFRE */
+        if (usbhsp_type_is(pipe, USB_ENDPOINT_XFER_ISOC) ||
+            usbhsp_type_is(pipe, USB_ENDPOINT_XFER_BULK))
+                bfre = 0; /* FIXME */
+
+        /* DBLB */
+        if (usbhsp_type_is(pipe, USB_ENDPOINT_XFER_ISOC) ||
+            usbhsp_type_is(pipe, USB_ENDPOINT_XFER_BULK))
+                dblb = (is_double) ? DBLB : 0;
+
+        /* CNTMD */
+        if (usbhsp_type_is(pipe, USB_ENDPOINT_XFER_BULK))
+                cntmd = 0; /* FIXME */
+
+        /* DIR */
+        if (usb_endpoint_dir_in(desc))
+                usbhsp_flags_set(pipe, IS_DIR_IN);
+
+        if ((is_host  && usb_endpoint_dir_out(desc)) ||
+            (!is_host && usb_endpoint_dir_in(desc)))
+                dir |= DIR_OUT;
+
+        /* SHTNAK */
+        if (usbhsp_type_is(pipe, USB_ENDPOINT_XFER_BULK) &&
+            !dir)
+                shtnak = SHTNAK;
+
+        /* EPNUM */
+        epnum = 0xF & usb_endpoint_num(desc);
+
+        return  type    |
+                bfre    |
+                dblb    |
+                cntmd   |
+                dir     |
+                shtnak  |
+                epnum;
+}
+
+static u16 usbhsp_setup_pipemaxp(struct usbhs_pipe *pipe,
+                                 const struct usb_endpoint_descriptor *desc,
+                                 int is_host)
+{
+        /* host should set DEVSEL */
+
+        /* reutn MXPS */
+        return PIPE_MAXP_MASK & le16_to_cpu(desc->wMaxPacketSize);
+}
+
+static u16 usbhsp_setup_pipebuff(struct usbhs_pipe *pipe,
+                                 const struct usb_endpoint_descriptor *desc,
+                                 int is_host)
+{
+        struct usbhs_priv *priv = usbhsp_pipe_to_priv(pipe);
+        struct usbhs_pipe_info *info = usbhsp_priv_to_pipeinfo(priv);
+        struct device *dev = usbhs_priv_to_dev(priv);
+        int pipe_num = usbhs_pipe_number(pipe);
+        int is_double = usbhsp_possible_double_buffer(pipe);
+        u16 buff_size;
+        u16 bufnmb;
+        u16 bufnmb_cnt;
+
+        /*
+         * PIPEBUF
+         *
+         * see
+         *  - "Register Descriptions" - "PIPEBUF" register
+         *  - "Features"  - "Pipe configuration"
+         *  - "Operation" - "FIFO Buffer Memory"
+         *  - "Operation" - "Pipe Control"
+         *
+         * ex) if pipe6 - pipe9 are USB_ENDPOINT_XFER_INT (SH7724)
+         *
+         * BUFNMB:      PIPE
+         * 0:           pipe0 (DCP 256byte)
+         * 1:           -
+         * 2:           -
+         * 3:           -
+         * 4:           pipe6 (INT 64byte)
+         * 5:           pipe7 (INT 64byte)
+         * 6:           pipe8 (INT 64byte)
+         * 7:           pipe9 (INT 64byte)
+         * 8 - xx:      free (for BULK, ISOC)
+         */
+
+        /*
+         * FIXME
+         *
+         * it doesn't have good buffer allocator
+         *
+         * DCP : 256 byte
+         * BULK: 512 byte
+         * INT :  64 byte
+         * ISOC: 512 byte
+         */
+        if (usbhsp_type_is(pipe, USB_ENDPOINT_XFER_CONTROL))
+                buff_size = 256;
+        else if (usbhsp_type_is(pipe, USB_ENDPOINT_XFER_INT))
+                buff_size = 64;
+        else
+                buff_size = 512;
+
+        /* change buff_size to register value */
+        bufnmb_cnt = (buff_size / 64) - 1;
+
+        /* BUFNMB has been reserved for INT pipe
+         * see above */
+        if (usbhsp_type_is(pipe, USB_ENDPOINT_XFER_INT)) {
+                bufnmb = pipe_num - 2;
+        } else {
+                bufnmb = info->bufnmb_last;
+                info->bufnmb_last += bufnmb_cnt + 1;
+
+                /*
+                 * double buffer
+                 */
+                if (is_double)
+                        info->bufnmb_last += bufnmb_cnt + 1;
+        }
+
+        dev_dbg(dev, "pipe : %d : buff_size 0x%x: bufnmb 0x%x\n",
+                pipe_num, buff_size, bufnmb);
+
+        return  (0x1f & bufnmb_cnt)     << 10 |
+                (0xff & bufnmb)         <<  0;
+}
+
+/*
+ *              pipe control
+ */
+int usbhs_pipe_get_maxpacket(struct usbhs_pipe *pipe)
+{
+        u16 mask = usbhsp_is_dcp(pipe) ? DCP_MAXP_MASK : PIPE_MAXP_MASK;
+
+        usbhsp_pipe_select(pipe);
+
+        return (int)(usbhsp_pipe_maxp_get(pipe) & mask);
+}
+
+int usbhs_pipe_is_dir_in(struct usbhs_pipe *pipe)
+{
+        return usbhsp_flags_has(pipe, IS_DIR_IN);
+}
+
+void usbhs_pipe_clear_sequence(struct usbhs_pipe *pipe)
+{
+        usbhsp_pipectrl_set(pipe, SQCLR, SQCLR);
+}
+
+static struct usbhs_pipe *usbhsp_get_pipe(struct usbhs_priv *priv, u32 type)
+{
+        struct usbhs_pipe *pos, *pipe;
+        int i;
+
+        /*
+         * find target pipe
+         */
+        pipe = NULL;
+        usbhs_for_each_pipe_with_dcp(pos, priv, i) {
+                if (!usbhsp_type_is(pos, type))
+                        continue;
+                if (usbhsp_flags_has(pos, IS_USED))
+                        continue;
+
+                pipe = pos;
+                break;
+        }
+
+        if (!pipe)
+                return NULL;
+
+        /*
+         * initialize pipe flags
+         */
+        usbhsp_flags_init(pipe);
+        usbhsp_flags_set(pipe, IS_USED);
+
+        return pipe;
+}
+
+void usbhs_pipe_init(struct usbhs_priv *priv)
+{
+        struct usbhs_pipe_info *info = usbhsp_priv_to_pipeinfo(priv);
+        struct usbhs_pipe *pipe;
+        int i;
+
+        /*
+         * FIXME
+         *
+         * driver needs good allocator.
+         *
+         * find first free buffer area (BULK, ISOC)
+         * (DCP, INT area is fixed)
+         *
+         * buffer number 0 - 3 have been reserved for DCP
+         * see
+         *      usbhsp_to_bufnmb
+         */
+        info->bufnmb_last = 4;
+        usbhs_for_each_pipe_with_dcp(pipe, priv, i) {
+                if (usbhsp_type_is(pipe, USB_ENDPOINT_XFER_INT))
+                        info->bufnmb_last++;
+
+                usbhsp_flags_init(pipe);
+                pipe->mod_private = NULL;
+
+                usbhsp_fifo_clear(pipe);
+        }
+}
+
+struct usbhs_pipe *usbhs_pipe_malloc(struct usbhs_priv *priv,
+                                     const struct usb_endpoint_descriptor *desc)
+{
+        struct device *dev = usbhs_priv_to_dev(priv);
+        struct usbhs_mod *mod = usbhs_mod_get_current(priv);
+        struct usbhs_pipe *pipe;
+        int is_host = usbhs_mod_is_host(priv, mod);
+        int ret;
+        u16 pipecfg, pipebuf, pipemaxp;
+
+        pipe = usbhsp_get_pipe(priv, usb_endpoint_type(desc));
+        if (!pipe) {
+                dev_err(dev, "can't get pipe (%s)\n",
+                        usbhsp_pipe_name[usb_endpoint_type(desc)]);
+                return NULL;
+        }
+
+        usbhs_fifo_disable(pipe);
+
+        /* make sure pipe is not busy */
+        ret = usbhsp_pipe_barrier(pipe);
+        if (ret < 0) {
+                dev_err(dev, "pipe setup failed %d\n", usbhs_pipe_number(pipe));
+                return NULL;
+        }
+
+        pipecfg  = usbhsp_setup_pipecfg(pipe,  desc, is_host);
+        pipebuf  = usbhsp_setup_pipebuff(pipe, desc, is_host);
+        pipemaxp = usbhsp_setup_pipemaxp(pipe, desc, is_host);
+
+        /* buffer clear
+         * see PIPECFG :: BFRE */
+        usbhsp_pipectrl_set(pipe, ACLRM, ACLRM);
+        usbhsp_pipectrl_set(pipe, ACLRM, 0);
+
+        usbhsp_pipe_select(pipe);
+        usbhsp_pipe_cfg_set(pipe, 0xFFFF, pipecfg);
+        usbhsp_pipe_buf_set(pipe, 0xFFFF, pipebuf);
+        usbhsp_pipe_maxp_set(pipe, 0xFFFF, pipemaxp);
+
+        usbhs_pipe_clear_sequence(pipe);
+
+        dev_dbg(dev, "enable pipe %d : %s (%s)\n",
+                usbhs_pipe_number(pipe),
+                usbhsp_pipe_name[usb_endpoint_type(desc)],
+                usbhs_pipe_is_dir_in(pipe) ? "in" : "out");
+
+        return pipe;
+}
+
+/*
+ *              dcp control
+ */
+struct usbhs_pipe *usbhs_dcp_malloc(struct usbhs_priv *priv)
+{
+        struct usbhs_pipe *pipe;
+
+        pipe = usbhsp_get_pipe(priv, USB_ENDPOINT_XFER_CONTROL);
+        if (!pipe)
+                return NULL;
+
+        /*
+         * dcpcfg  : default
+         * dcpmaxp : default
+         * pipebuf : nothing to do
+         */
+
+        usbhsp_pipe_select(pipe);
+        usbhs_pipe_clear_sequence(pipe);
+
+        return pipe;
+}
+
+void usbhs_dcp_control_transfer_done(struct usbhs_pipe *pipe)
+{
+        WARN_ON(!usbhsp_is_dcp(pipe));
+
+        usbhs_fifo_enable(pipe);
+        usbhsp_pipectrl_set(pipe, CCPL, CCPL);
+}
+
+
+/*
+ *              pipe module function
+ */
+int usbhs_pipe_probe(struct usbhs_priv *priv)
+{
+        struct usbhs_pipe_info *info = usbhsp_priv_to_pipeinfo(priv);
+        struct usbhs_pipe *pipe;
+        struct device *dev = usbhs_priv_to_dev(priv);
+        u32 *pipe_type = usbhs_get_dparam(priv, pipe_type);
+        int pipe_size = usbhs_get_dparam(priv, pipe_size);
+        int i;
+
+        /* This driver expects 1st pipe is DCP */
+        if (pipe_type[0] != USB_ENDPOINT_XFER_CONTROL) {
+                dev_err(dev, "1st PIPE is not DCP\n");
+                return -EINVAL;
+        }
+
+        info->pipe = kzalloc(sizeof(struct usbhs_pipe) * pipe_size, GFP_KERNEL);
+        if (!info->pipe) {
+                dev_err(dev, "Could not allocate pipe\n");
+                return -ENOMEM;
+        }
+
+        info->size = pipe_size;
+
+        /*
+         * init pipe
+         */
+        usbhs_for_each_pipe_with_dcp(pipe, priv, i) {
+                pipe->priv = priv;
+                usbhsp_type(pipe) = pipe_type[i] & USB_ENDPOINT_XFERTYPE_MASK;
+
+                dev_dbg(dev, "pipe %x\t: %s\n",
+                        i, usbhsp_pipe_name[pipe_type[i]]);
+        }
+
+        return 0;
+}
+
+void usbhs_pipe_remove(struct usbhs_priv *priv)
+{
+        struct usbhs_pipe_info *info = usbhsp_priv_to_pipeinfo(priv);
+
+        kfree(info->pipe);
+}
diff --git a/drivers/usb/renesas_usbhs/pipe.h b/drivers/usb/renesas_usbhs/pipe.h
new file mode 100644
index 000000000000..1cca9b7fb266
--- /dev/null
+++ b/drivers/usb/renesas_usbhs/pipe.h
@@ -0,0 +1,104 @@
+/*
+ * Renesas USB driver
+ *
+ * Copyright (C) 2011 Renesas Solutions Corp.
+ * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
+ *
+ * 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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+#ifndef RENESAS_USB_PIPE_H
+#define RENESAS_USB_PIPE_H
+
+#include "./common.h"
+
+/*
+ *      struct
+ */
+struct usbhs_pipe {
+        u32 pipe_type;  /* USB_ENDPOINT_XFER_xxx */
+
+        struct usbhs_priv *priv;
+
+        u32 flags;
+#define USBHS_PIPE_FLAGS_IS_USED                (1 << 0)
+#define USBHS_PIPE_FLAGS_IS_DIR_IN              (1 << 1)
+
+        void *mod_private;
+};
+
+struct usbhs_pipe_info {
+        struct usbhs_pipe *pipe;
+        int size;       /* array size of "pipe" */
+        int bufnmb_last;        /* FIXME : driver needs good allocator */
+};
+
+/*
+ * pipe list
+ */
+#define __usbhs_for_each_pipe(start, pos, info, i)      \
+        for (i = start, pos = (info)->pipe;             \
+             i < (info)->size;                          \
+             i++, pos = (info)->pipe + i)
+
+#define usbhs_for_each_pipe(pos, priv, i)                       \
+        __usbhs_for_each_pipe(1, pos, &((priv)->pipe_info), i)
+
+#define usbhs_for_each_pipe_with_dcp(pos, priv, i)              \
+        __usbhs_for_each_pipe(0, pos, &((priv)->pipe_info), i)
+
+/*
+ * pipe module probe / remove
+ */
+int usbhs_pipe_probe(struct usbhs_priv *priv);
+void usbhs_pipe_remove(struct usbhs_priv *priv);
+
+/*
+ * cfifo
+ */
+int usbhs_fifo_write(struct usbhs_pipe *pipe, u8 *buf, int len);
+int usbhs_fifo_read(struct usbhs_pipe *pipe, u8 *buf, int len);
+int usbhs_fifo_prepare_write(struct usbhs_pipe *pipe);
+int usbhs_fifo_prepare_read(struct usbhs_pipe *pipe);
+
+void usbhs_fifo_enable(struct usbhs_pipe *pipe);
+void usbhs_fifo_disable(struct usbhs_pipe *pipe);
+void usbhs_fifo_stall(struct usbhs_pipe *pipe);
+
+void usbhs_fifo_send_terminator(struct usbhs_pipe *pipe);
+
+
+/*
+ * usb request
+ */
+void usbhs_usbreq_get_val(struct usbhs_priv *priv, struct usb_ctrlrequest *req);
+void usbhs_usbreq_set_val(struct usbhs_priv *priv, struct usb_ctrlrequest *req);
+
+/*
+ * pipe control
+ */
+struct usbhs_pipe
+*usbhs_pipe_malloc(struct usbhs_priv *priv,
+                   const struct usb_endpoint_descriptor *desc);
+
+int usbhs_pipe_is_dir_in(struct usbhs_pipe *pipe);
+void usbhs_pipe_init(struct usbhs_priv *priv);
+int usbhs_pipe_get_maxpacket(struct usbhs_pipe *pipe);
+void usbhs_pipe_clear_sequence(struct usbhs_pipe *pipe);
+
+#define usbhs_pipe_number(p)    (int)((p) - (p)->priv->pipe_info.pipe)
+
+/*
+ * dcp control
+ */
+struct usbhs_pipe *usbhs_dcp_malloc(struct usbhs_priv *priv);
+void usbhs_dcp_control_transfer_done(struct usbhs_pipe *pipe);
+
+#endif /* RENESAS_USB_PIPE_H */
diff --git a/drivers/usb/serial/Kconfig b/drivers/usb/serial/Kconfig
index 916b2b6d765f..b71e309116a3 100644
--- a/drivers/usb/serial/Kconfig
+++ b/drivers/usb/serial/Kconfig
@@ -176,7 +176,7 @@ config USB_SERIAL_VISOR
         help
           Say Y here if you want to connect to your HandSpring Visor, Palm
           m500 or m505 through its USB docking station. See
-          <http://usbvisor.sourceforge.net/> for more information on using this
+          <http://usbvisor.sourceforge.net/index.php3> for more information on using this
           driver.
 
           To compile this driver as a module, choose M here: the
@@ -289,7 +289,7 @@ config USB_SERIAL_KEYSPAN
           and was developed with their support.  You must also include
           firmware to support your particular device(s).
 
-          See <http://misc.nu/hugh/keyspan.html> for more information.
+          See <http://blemings.org/hugh/keyspan.html> for more information.
 
           To compile this driver as a module, choose M here: the
           module will be called keyspan.
diff --git a/drivers/usb/serial/Makefile b/drivers/usb/serial/Makefile
index 40ebe17b6ea8..9e536eefb32c 100644
--- a/drivers/usb/serial/Makefile
+++ b/drivers/usb/serial/Makefile
@@ -6,10 +6,10 @@
 
 obj-$(CONFIG_USB_SERIAL)                        += usbserial.o
 
-usbserial-obj-$(CONFIG_USB_SERIAL_CONSOLE)      += console.o
-usbserial-obj-$(CONFIG_USB_EZUSB)               += ezusb.o
+usbserial-y := usb-serial.o generic.o bus.o
 
-usbserial-objs  := usb-serial.o generic.o bus.o $(usbserial-obj-y)
+usbserial-$(CONFIG_USB_SERIAL_CONSOLE)  += console.o
+usbserial-$(CONFIG_USB_EZUSB)           += ezusb.o
 
 obj-$(CONFIG_USB_SERIAL_AIRCABLE)               += aircable.o
 obj-$(CONFIG_USB_SERIAL_ARK3116)                += ark3116.o
@@ -58,6 +58,5 @@ obj-$(CONFIG_USB_SERIAL_TI)			+= ti_usb_3410_5052.o
 obj-$(CONFIG_USB_SERIAL_VISOR)                  += visor.o
 obj-$(CONFIG_USB_SERIAL_WHITEHEAT)              += whiteheat.o
 obj-$(CONFIG_USB_SERIAL_XIRCOM)                 += keyspan_pda.o
-obj-$(CONFIG_USB_SERIAL_VIVOPAY_SERIAL) += vivopay-serial.o
+obj-$(CONFIG_USB_SERIAL_VIVOPAY_SERIAL)         += vivopay-serial.o
 obj-$(CONFIG_USB_SERIAL_ZIO)                    += zio.o
-
diff --git a/drivers/usb/serial/aircable.c b/drivers/usb/serial/aircable.c
index 0db6ace16f7b..aba201cb872c 100644
--- a/drivers/usb/serial/aircable.c
+++ b/drivers/usb/serial/aircable.c
@@ -16,7 +16,7 @@
  * When reading the process is almost equal except that the header starts with
  * 0x00 0x20.
  *
- * The device simply need some stuff to understand data comming from the usb
+ * The device simply need some stuff to understand data coming from the usb
  * buffer: The First and Second byte is used for a Header, the Third and Fourth
  * tells the  device the amount of information the package holds.
  * Packages are 60 bytes long Header Stuff.
@@ -30,7 +30,7 @@
  * one.
  *
  * The driver registers himself with the USB-serial core and the USB Core. I had
- * to implement a probe function agains USB-serial, because other way, the
+ * to implement a probe function against USB-serial, because other way, the
  * driver was attaching himself to both interfaces. I have tryed with different
  * configurations of usb_serial_driver with out exit, only the probe function
  * could handle this correctly.
diff --git a/drivers/usb/serial/ark3116.c b/drivers/usb/serial/ark3116.c
index 4e41a2a39422..5cdb9d912275 100644
--- a/drivers/usb/serial/ark3116.c
+++ b/drivers/usb/serial/ark3116.c
@@ -411,7 +411,27 @@ err_out:
         return result;
 }
 
-static int ark3116_ioctl(struct tty_struct *tty, struct file *file,
+static int ark3116_get_icount(struct tty_struct *tty,
+                                        struct serial_icounter_struct *icount)
+{
+        struct usb_serial_port *port = tty->driver_data;
+        struct ark3116_private *priv = usb_get_serial_port_data(port);
+        struct async_icount cnow = priv->icount;
+        icount->cts = cnow.cts;
+        icount->dsr = cnow.dsr;
+        icount->rng = cnow.rng;
+        icount->dcd = cnow.dcd;
+        icount->rx = cnow.rx;
+        icount->tx = cnow.tx;
+        icount->frame = cnow.frame;
+        icount->overrun = cnow.overrun;
+        icount->parity = cnow.parity;
+        icount->brk = cnow.brk;
+        icount->buf_overrun = cnow.buf_overrun;
+        return 0;
+}
+
+static int ark3116_ioctl(struct tty_struct *tty,
                          unsigned int cmd, unsigned long arg)
 {
         struct usb_serial_port *port = tty->driver_data;
@@ -460,31 +480,12 @@ static int ark3116_ioctl(struct tty_struct *tty, struct file *file,
                                 return 0;
                 }
                 break;
-        case TIOCGICOUNT: {
-                struct serial_icounter_struct icount;
-                struct async_icount cnow = priv->icount;
-                memset(&icount, 0, sizeof(icount));
-                icount.cts = cnow.cts;
-                icount.dsr = cnow.dsr;
-                icount.rng = cnow.rng;
-                icount.dcd = cnow.dcd;
-                icount.rx = cnow.rx;
-                icount.tx = cnow.tx;
-                icount.frame = cnow.frame;
-                icount.overrun = cnow.overrun;
-                icount.parity = cnow.parity;
-                icount.brk = cnow.brk;
-                icount.buf_overrun = cnow.buf_overrun;
-                if (copy_to_user(user_arg, &icount, sizeof(icount)))
-                        return -EFAULT;
-                return 0;
-        }
         }
 
         return -ENOIOCTLCMD;
 }
 
-static int ark3116_tiocmget(struct tty_struct *tty, struct file *file)
+static int ark3116_tiocmget(struct tty_struct *tty)
 {
         struct usb_serial_port *port = tty->driver_data;
         struct ark3116_private *priv = usb_get_serial_port_data(port);
@@ -510,7 +511,7 @@ static int ark3116_tiocmget(struct tty_struct *tty, struct file *file)
                 (ctrl   & UART_MCR_OUT2 ? TIOCM_OUT2 : 0);
 }
 
-static int ark3116_tiocmset(struct tty_struct *tty, struct file *file,
+static int ark3116_tiocmset(struct tty_struct *tty,
                         unsigned set, unsigned clr)
 {
         struct usb_serial_port *port = tty->driver_data;
@@ -736,6 +737,7 @@ static struct usb_serial_driver ark3116_device = {
         .ioctl =                ark3116_ioctl,
         .tiocmget =             ark3116_tiocmget,
         .tiocmset =             ark3116_tiocmset,
+        .get_icount =           ark3116_get_icount,
         .open =                 ark3116_open,
         .close =                ark3116_close,
         .break_ctl =            ark3116_break_ctl,
diff --git a/drivers/usb/serial/belkin_sa.c b/drivers/usb/serial/belkin_sa.c
index 36df35295db2..d6921fa1403c 100644
--- a/drivers/usb/serial/belkin_sa.c
+++ b/drivers/usb/serial/belkin_sa.c
@@ -100,8 +100,8 @@ static void belkin_sa_process_read_urb(struct urb *urb);
 static void belkin_sa_set_termios(struct tty_struct *tty,
                         struct usb_serial_port *port, struct ktermios * old);
 static void belkin_sa_break_ctl(struct tty_struct *tty, int break_state);
-static int  belkin_sa_tiocmget(struct tty_struct *tty, struct file *file);
-static int  belkin_sa_tiocmset(struct tty_struct *tty, struct file *file,
+static int  belkin_sa_tiocmget(struct tty_struct *tty);
+static int  belkin_sa_tiocmset(struct tty_struct *tty,
                                         unsigned int set, unsigned int clear);
 
 
@@ -497,7 +497,7 @@ static void belkin_sa_break_ctl(struct tty_struct *tty, int break_state)
                 dev_err(&port->dev, "Set break_ctl %d\n", break_state);
 }
 
-static int belkin_sa_tiocmget(struct tty_struct *tty, struct file *file)
+static int belkin_sa_tiocmget(struct tty_struct *tty)
 {
         struct usb_serial_port *port = tty->driver_data;
         struct belkin_sa_private *priv = usb_get_serial_port_data(port);
@@ -513,7 +513,7 @@ static int belkin_sa_tiocmget(struct tty_struct *tty, struct file *file)
         return control_state;
 }
 
-static int belkin_sa_tiocmset(struct tty_struct *tty, struct file *file,
+static int belkin_sa_tiocmset(struct tty_struct *tty,
                                unsigned int set, unsigned int clear)
 {
         struct usb_serial_port *port = tty->driver_data;
diff --git a/drivers/usb/serial/ch341.c b/drivers/usb/serial/ch341.c
index 63f7cc45bcac..6ae1c0688b5e 100644
--- a/drivers/usb/serial/ch341.c
+++ b/drivers/usb/serial/ch341.c
@@ -75,6 +75,7 @@ static int debug;
 static const struct usb_device_id id_table[] = {
         { USB_DEVICE(0x4348, 0x5523) },
         { USB_DEVICE(0x1a86, 0x7523) },
+        { USB_DEVICE(0x1a86, 0x5523) },
         { },
 };
 MODULE_DEVICE_TABLE(usb, id_table);
@@ -431,7 +432,7 @@ out:
         kfree(break_reg);
 }
 
-static int ch341_tiocmset(struct tty_struct *tty, struct file *file,
+static int ch341_tiocmset(struct tty_struct *tty,
                           unsigned int set, unsigned int clear)
 {
         struct usb_serial_port *port = tty->driver_data;
@@ -486,12 +487,22 @@ static void ch341_read_int_callback(struct urb *urb)
         if (actual_length >= 4) {
                 struct ch341_private *priv = usb_get_serial_port_data(port);
                 unsigned long flags;
+                u8 prev_line_status = priv->line_status;
 
                 spin_lock_irqsave(&priv->lock, flags);
                 priv->line_status = (~(data[2])) & CH341_BITS_MODEM_STAT;
                 if ((data[1] & CH341_MULT_STAT))
                         priv->multi_status_change = 1;
                 spin_unlock_irqrestore(&priv->lock, flags);
+
+                if ((priv->line_status ^ prev_line_status) & CH341_BIT_DCD) {
+                        struct tty_struct *tty = tty_port_tty_get(&port->port);
+                        if (tty)
+                                usb_serial_handle_dcd_change(port, tty,
+                                            priv->line_status & CH341_BIT_DCD);
+                        tty_kref_put(tty);
+                }
+
                 wake_up_interruptible(&priv->delta_msr_wait);
         }
 
@@ -542,8 +553,7 @@ static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
         return 0;
 }
 
-/*static int ch341_ioctl(struct usb_serial_port *port, struct file *file,*/
-static int ch341_ioctl(struct tty_struct *tty, struct file *file,
+static int ch341_ioctl(struct tty_struct *tty,
                         unsigned int cmd, unsigned long arg)
 {
         struct usb_serial_port *port = tty->driver_data;
@@ -562,7 +572,7 @@ static int ch341_ioctl(struct tty_struct *tty, struct file *file,
         return -ENOIOCTLCMD;
 }
 
-static int ch341_tiocmget(struct tty_struct *tty, struct file *file)
+static int ch341_tiocmget(struct tty_struct *tty)
 {
         struct usb_serial_port *port = tty->driver_data;
         struct ch341_private *priv = usb_get_serial_port_data(port);
diff --git a/drivers/usb/serial/cp210x.c b/drivers/usb/serial/cp210x.c
index 4f1744c5871f..fd67cc53545b 100644
--- a/drivers/usb/serial/cp210x.c
+++ b/drivers/usb/serial/cp210x.c
@@ -41,19 +41,18 @@ static void cp210x_get_termios_port(struct usb_serial_port *port,
         unsigned int *cflagp, unsigned int *baudp);
 static void cp210x_set_termios(struct tty_struct *, struct usb_serial_port *,
                                                         struct ktermios*);
-static int cp210x_tiocmget(struct tty_struct *, struct file *);
-static int cp210x_tiocmset(struct tty_struct *, struct file *,
-                unsigned int, unsigned int);
-static int cp210x_tiocmset_port(struct usb_serial_port *port, struct file *,
+static int cp210x_tiocmget(struct tty_struct *);
+static int cp210x_tiocmset(struct tty_struct *, unsigned int, unsigned int);
+static int cp210x_tiocmset_port(struct usb_serial_port *port,
                 unsigned int, unsigned int);
 static void cp210x_break_ctl(struct tty_struct *, int);
 static int cp210x_startup(struct usb_serial *);
 static void cp210x_dtr_rts(struct usb_serial_port *p, int on);
-static int cp210x_carrier_raised(struct usb_serial_port *p);
 
 static int debug;
 
 static const struct usb_device_id id_table[] = {
+        { USB_DEVICE(0x045B, 0x0053) }, /* Renesas RX610 RX-Stick */
         { USB_DEVICE(0x0471, 0x066A) }, /* AKTAKOM ACE-1001 cable */
         { USB_DEVICE(0x0489, 0xE000) }, /* Pirelli Broadband S.p.A, DP-L10 SIP/GSM Mobile */
         { USB_DEVICE(0x0489, 0xE003) }, /* Pirelli Broadband S.p.A, DP-L10 SIP/GSM Mobile */
@@ -86,7 +85,6 @@ static const struct usb_device_id id_table[] = {
         { USB_DEVICE(0x10C4, 0x8115) }, /* Arygon NFC/Mifare Reader */
         { USB_DEVICE(0x10C4, 0x813D) }, /* Burnside Telecom Deskmobile */
         { USB_DEVICE(0x10C4, 0x813F) }, /* Tams Master Easy Control */
-        { USB_DEVICE(0x10C4, 0x8149) }, /* West Mountain Radio Computerized Battery Analyzer */
         { USB_DEVICE(0x10C4, 0x814A) }, /* West Mountain Radio RIGblaster P&P */
         { USB_DEVICE(0x10C4, 0x814B) }, /* West Mountain Radio RIGtalk */
         { USB_DEVICE(0x10C4, 0x8156) }, /* B&G H3000 link cable */
@@ -103,15 +101,21 @@ static const struct usb_device_id id_table[] = {
         { USB_DEVICE(0x10C4, 0x81F2) }, /* C1007 HF band RFID controller */
         { USB_DEVICE(0x10C4, 0x8218) }, /* Lipowsky Industrie Elektronik GmbH, HARP-1 */
         { USB_DEVICE(0x10C4, 0x822B) }, /* Modem EDGE(GSM) Comander 2 */
-        { USB_DEVICE(0x10C4, 0x826B) }, /* Cygnal Integrated Products, Inc., Fasttrax GPS demostration module */
-        { USB_DEVICE(0x10C4, 0x8293) }, /* Telegesys ETRX2USB */
+        { USB_DEVICE(0x10C4, 0x826B) }, /* Cygnal Integrated Products, Inc., Fasttrax GPS demonstration module */
+        { USB_DEVICE(0x10C4, 0x8293) }, /* Telegesis ETRX2USB */
         { USB_DEVICE(0x10C4, 0x82F9) }, /* Procyon AVS */
         { USB_DEVICE(0x10C4, 0x8341) }, /* Siemens MC35PU GPRS Modem */
         { USB_DEVICE(0x10C4, 0x8382) }, /* Cygnal Integrated Products, Inc. */
         { USB_DEVICE(0x10C4, 0x83A8) }, /* Amber Wireless AMB2560 */
+        { USB_DEVICE(0x10C4, 0x83D8) }, /* DekTec DTA Plus VHF/UHF Booster/Attenuator */
         { USB_DEVICE(0x10C4, 0x8411) }, /* Kyocera GPS Module */
+        { USB_DEVICE(0x10C4, 0x8418) }, /* IRZ Automation Teleport SG-10 GSM/GPRS Modem */
         { USB_DEVICE(0x10C4, 0x846E) }, /* BEI USB Sensor Interface (VCP) */
         { USB_DEVICE(0x10C4, 0x8477) }, /* Balluff RFID */
+        { USB_DEVICE(0x10C4, 0x85EA) }, /* AC-Services IBUS-IF */
+        { USB_DEVICE(0x10C4, 0x85EB) }, /* AC-Services CIS-IBUS */
+        { USB_DEVICE(0x10C4, 0x8664) }, /* AC-Services CAN-IF */
+        { USB_DEVICE(0x10C4, 0x8665) }, /* AC-Services OBD-IF */
         { USB_DEVICE(0x10C4, 0xEA60) }, /* Silicon Labs factory default */
         { USB_DEVICE(0x10C4, 0xEA61) }, /* Silicon Labs factory default */
         { USB_DEVICE(0x10C4, 0xEA71) }, /* Infinity GPS-MIC-1 Radio Monophone */
@@ -132,6 +136,7 @@ static const struct usb_device_id id_table[] = {
         { USB_DEVICE(0x17F4, 0xAAAA) }, /* Wavesense Jazz blood glucose meter */
         { USB_DEVICE(0x1843, 0x0200) }, /* Vaisala USB Instrument Cable */
         { USB_DEVICE(0x18EF, 0xE00F) }, /* ELV USB-I2C-Interface */
+        { USB_DEVICE(0x1BE3, 0x07A6) }, /* WAGO 750-923 USB Service Cable */
         { USB_DEVICE(0x413C, 0x9500) }, /* DW700 GPS USB interface */
         { } /* Terminating Entry */
 };
@@ -163,8 +168,7 @@ static struct usb_serial_driver cp210x_device = {
         .tiocmget               = cp210x_tiocmget,
         .tiocmset               = cp210x_tiocmset,
         .attach                 = cp210x_startup,
-        .dtr_rts                = cp210x_dtr_rts,
-        .carrier_raised         = cp210x_carrier_raised
+        .dtr_rts                = cp210x_dtr_rts
 };
 
 /* Config request types */
@@ -697,14 +701,14 @@ static void cp210x_set_termios(struct tty_struct *tty,
 
 }
 
-static int cp210x_tiocmset (struct tty_struct *tty, struct file *file,
+static int cp210x_tiocmset (struct tty_struct *tty,
                 unsigned int set, unsigned int clear)
 {
         struct usb_serial_port *port = tty->driver_data;
-        return cp210x_tiocmset_port(port, file, set, clear);
+        return cp210x_tiocmset_port(port, set, clear);
 }
 
-static int cp210x_tiocmset_port(struct usb_serial_port *port, struct file *file,
+static int cp210x_tiocmset_port(struct usb_serial_port *port,
                 unsigned int set, unsigned int clear)
 {
         unsigned int control = 0;
@@ -736,12 +740,12 @@ static int cp210x_tiocmset_port(struct usb_serial_port *port, struct file *file,
 static void cp210x_dtr_rts(struct usb_serial_port *p, int on)
 {
         if (on)
-                cp210x_tiocmset_port(p, NULL,  TIOCM_DTR|TIOCM_RTS, 0);
+                cp210x_tiocmset_port(p, TIOCM_DTR|TIOCM_RTS, 0);
         else
-                cp210x_tiocmset_port(p, NULL,  0, TIOCM_DTR|TIOCM_RTS);
+                cp210x_tiocmset_port(p, 0, TIOCM_DTR|TIOCM_RTS);
 }
 
-static int cp210x_tiocmget (struct tty_struct *tty, struct file *file)
+static int cp210x_tiocmget (struct tty_struct *tty)
 {
         struct usb_serial_port *port = tty->driver_data;
         unsigned int control;
@@ -763,15 +767,6 @@ static int cp210x_tiocmget (struct tty_struct *tty, struct file *file)
         return result;
 }
 
-static int cp210x_carrier_raised(struct usb_serial_port *p)
-{
-        unsigned int control;
-        cp210x_get_config(p, CP210X_GET_MDMSTS, &control, 1);
-        if (control & CONTROL_DCD)
-                return 1;
-        return 0;
-}
-
 static void cp210x_break_ctl (struct tty_struct *tty, int break_state)
 {
         struct usb_serial_port *port = tty->driver_data;
diff --git a/drivers/usb/serial/cypress_m8.c b/drivers/usb/serial/cypress_m8.c
index f5d06746cc3b..d9906eb9d16a 100644
--- a/drivers/usb/serial/cypress_m8.c
+++ b/drivers/usb/serial/cypress_m8.c
@@ -35,7 +35,7 @@
  *
  *  Lonnie Mendez <dignome@gmail.com>
  *  04-10-2004
- *      Driver modified to support dynamic line settings.  Various improvments
+ *      Driver modified to support dynamic line settings.  Various improvements
  *      and features.
  *
  *  Neil Whelchel
@@ -169,12 +169,12 @@ static int  cypress_write(struct tty_struct *tty, struct usb_serial_port *port,
                         const unsigned char *buf, int count);
 static void cypress_send(struct usb_serial_port *port);
 static int  cypress_write_room(struct tty_struct *tty);
-static int  cypress_ioctl(struct tty_struct *tty, struct file *file,
+static int  cypress_ioctl(struct tty_struct *tty,
                         unsigned int cmd, unsigned long arg);
 static void cypress_set_termios(struct tty_struct *tty,
                         struct usb_serial_port *port, struct ktermios *old);
-static int  cypress_tiocmget(struct tty_struct *tty, struct file *file);
-static int  cypress_tiocmset(struct tty_struct *tty, struct file *file,
+static int  cypress_tiocmget(struct tty_struct *tty);
+static int  cypress_tiocmset(struct tty_struct *tty,
                         unsigned int set, unsigned int clear);
 static int  cypress_chars_in_buffer(struct tty_struct *tty);
 static void cypress_throttle(struct tty_struct *tty);
@@ -864,7 +864,7 @@ static int cypress_write_room(struct tty_struct *tty)
 }
 
 
-static int cypress_tiocmget(struct tty_struct *tty, struct file *file)
+static int cypress_tiocmget(struct tty_struct *tty)
 {
         struct usb_serial_port *port = tty->driver_data;
         struct cypress_private *priv = usb_get_serial_port_data(port);
@@ -892,7 +892,7 @@ static int cypress_tiocmget(struct tty_struct *tty, struct file *file)
 }
 
 
-static int cypress_tiocmset(struct tty_struct *tty, struct file *file,
+static int cypress_tiocmset(struct tty_struct *tty,
                                unsigned int set, unsigned int clear)
 {
         struct usb_serial_port *port = tty->driver_data;
@@ -917,7 +917,7 @@ static int cypress_tiocmset(struct tty_struct *tty, struct file *file,
 }
 
 
-static int cypress_ioctl(struct tty_struct *tty, struct file *file,
+static int cypress_ioctl(struct tty_struct *tty,
                                         unsigned int cmd, unsigned long arg)
 {
         struct usb_serial_port *port = tty->driver_data;
@@ -1320,8 +1320,6 @@ continue_read:
                         cypress_set_dead(port);
                 }
         }
-
-        return;
 } /* cypress_read_int_callback */
 
 
diff --git a/drivers/usb/serial/digi_acceleport.c b/drivers/usb/serial/digi_acceleport.c
index b92070c103cd..86fbba6336c9 100644
--- a/drivers/usb/serial/digi_acceleport.c
+++ b/drivers/usb/serial/digi_acceleport.c
@@ -445,17 +445,16 @@ static void digi_rx_unthrottle(struct tty_struct *tty);
 static void digi_set_termios(struct tty_struct *tty,
                 struct usb_serial_port *port, struct ktermios *old_termios);
 static void digi_break_ctl(struct tty_struct *tty, int break_state);
-static int digi_tiocmget(struct tty_struct *tty, struct file *file);
-static int digi_tiocmset(struct tty_struct *tty, struct file *file,
-        unsigned int set, unsigned int clear);
+static int digi_tiocmget(struct tty_struct *tty);
+static int digi_tiocmset(struct tty_struct *tty, unsigned int set,
+                unsigned int clear);
 static int digi_write(struct tty_struct *tty, struct usb_serial_port *port,
-        const unsigned char *buf, int count);
+                const unsigned char *buf, int count);
 static void digi_write_bulk_callback(struct urb *urb);
 static int digi_write_room(struct tty_struct *tty);
 static int digi_chars_in_buffer(struct tty_struct *tty);
 static int digi_open(struct tty_struct *tty, struct usb_serial_port *port);
 static void digi_close(struct usb_serial_port *port);
-static int digi_carrier_raised(struct usb_serial_port *port);
 static void digi_dtr_rts(struct usb_serial_port *port, int on);
 static int digi_startup_device(struct usb_serial *serial);
 static int digi_startup(struct usb_serial *serial);
@@ -511,7 +510,6 @@ static struct usb_serial_driver digi_acceleport_2_device = {
         .open =                         digi_open,
         .close =                        digi_close,
         .dtr_rts =                      digi_dtr_rts,
-        .carrier_raised =               digi_carrier_raised,
         .write =                        digi_write,
         .write_room =                   digi_write_room,
         .write_bulk_callback =          digi_write_bulk_callback,
@@ -1120,7 +1118,7 @@ static void digi_break_ctl(struct tty_struct *tty, int break_state)
 }
 
 
-static int digi_tiocmget(struct tty_struct *tty, struct file *file)
+static int digi_tiocmget(struct tty_struct *tty)
 {
         struct usb_serial_port *port = tty->driver_data;
         struct digi_port *priv = usb_get_serial_port_data(port);
@@ -1136,8 +1134,8 @@ static int digi_tiocmget(struct tty_struct *tty, struct file *file)
 }
 
 
-static int digi_tiocmset(struct tty_struct *tty, struct file *file,
-        unsigned int set, unsigned int clear)
+static int digi_tiocmset(struct tty_struct *tty,
+                                        unsigned int set, unsigned int clear)
 {
         struct usb_serial_port *port = tty->driver_data;
         struct digi_port *priv = usb_get_serial_port_data(port);
@@ -1339,14 +1337,6 @@ static void digi_dtr_rts(struct usb_serial_port *port, int on)
         digi_set_modem_signals(port, on * (TIOCM_DTR|TIOCM_RTS), 1);
 }
 
-static int digi_carrier_raised(struct usb_serial_port *port)
-{
-        struct digi_port *priv = usb_get_serial_port_data(port);
-        if (priv->dp_modem_signals & TIOCM_CD)
-                return 1;
-        return 0;
-}
-
 static int digi_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
         int ret;
diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
index 97cc87d654ce..2e06b90aa1f8 100644
--- a/drivers/usb/serial/ftdi_sio.c
+++ b/drivers/usb/serial/ftdi_sio.c
@@ -17,7 +17,7 @@
  * See Documentation/usb/usb-serial.txt for more information on using this
  * driver
  *
- * See http://ftdi-usb-sio.sourceforge.net for upto date testing info
+ * See http://ftdi-usb-sio.sourceforge.net for up to date testing info
  *      and extra documentation
  *
  * Change entries from 2004 and earlier can be found in versions of this
@@ -75,6 +75,7 @@ struct ftdi_private {
         unsigned long last_dtr_rts;     /* saved modem control outputs */
         wait_queue_head_t delta_msr_wait; /* Used for TIOCMIWAIT */
         char prev_status, diff_status;        /* Used for TIOCMIWAIT */
+        char transmit_empty;    /* If transmitter is empty or not */
         struct usb_serial_port *port;
         __u16 interface;        /* FT2232C, FT2232H or FT4232H port interface
                                    (0 for FT232/245) */
@@ -99,6 +100,7 @@ struct ftdi_sio_quirk {
 static int   ftdi_jtag_probe(struct usb_serial *serial);
 static int   ftdi_mtxorb_hack_setup(struct usb_serial *serial);
 static int   ftdi_NDI_device_setup(struct usb_serial *serial);
+static int   ftdi_stmclite_probe(struct usb_serial *serial);
 static void  ftdi_USB_UIRT_setup(struct ftdi_private *priv);
 static void  ftdi_HE_TIRA1_setup(struct ftdi_private *priv);
 
@@ -122,6 +124,10 @@ static struct ftdi_sio_quirk ftdi_HE_TIRA1_quirk = {
         .port_probe = ftdi_HE_TIRA1_setup,
 };
 
+static struct ftdi_sio_quirk ftdi_stmclite_quirk = {
+        .probe  = ftdi_stmclite_probe,
+};
+
 /*
  * The 8U232AM has the same API as the sio except for:
  * - it can support MUCH higher baudrates; up to:
@@ -145,6 +151,8 @@ static struct ftdi_sio_quirk ftdi_HE_TIRA1_quirk = {
  * /sys/bus/usb/ftdi_sio/new_id, then send patch/report!
  */
 static struct usb_device_id id_table_combined [] = {
+        { USB_DEVICE(FTDI_VID, FTDI_CTI_MINI_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_CTI_NANO_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_AMC232_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_CANUSB_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_CANDAPTER_PID) },
@@ -171,12 +179,14 @@ static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(FTDI_VID, FTDI_232RL_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_8U2232C_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_4232H_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_232H_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_MICRO_CHAMELEON_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_RELAIS_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_OPENDCC_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_OPENDCC_SNIFFER_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_OPENDCC_THROTTLE_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_OPENDCC_GATEWAY_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_OPENDCC_GBM_PID) },
         { USB_DEVICE(INTERBIOMETRICS_VID, INTERBIOMETRICS_IOBOARD_PID) },
         { USB_DEVICE(INTERBIOMETRICS_VID, INTERBIOMETRICS_MINI_IOBOARD_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_SPROG_II) },
@@ -200,6 +210,7 @@ static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(FTDI_VID, FTDI_MTXORB_5_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_MTXORB_6_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_R2000KU_TRUE_RNG) },
+        { USB_DEVICE(FTDI_VID, FTDI_VARDAAN_PID) },
         { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0100_PID) },
         { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0101_PID) },
         { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0102_PID) },
@@ -517,6 +528,7 @@ static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_8_PID) },
         { USB_DEVICE(IDTECH_VID, IDTECH_IDT1221U_PID) },
         { USB_DEVICE(OCT_VID, OCT_US101_PID) },
+        { USB_DEVICE(OCT_VID, OCT_DK201_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_HE_TIRA1_PID),
                 .driver_info = (kernel_ulong_t)&ftdi_HE_TIRA1_quirk },
         { USB_DEVICE(FTDI_VID, FTDI_USB_UIRT_PID),
@@ -555,6 +567,7 @@ static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(FTDI_VID, FTDI_IBS_APP70_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_IBS_PEDO_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_IBS_PROD_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_TAVIR_STK500_PID) },
         /*
          * ELV devices:
          */
@@ -613,6 +626,7 @@ static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(FTDI_VID, FTDI_OCEANIC_PID) },
         { USB_DEVICE(TTI_VID, TTI_QL355P_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_RM_CANVIEW_PID) },
+        { USB_DEVICE(ACTON_VID, ACTON_SPECTRAPRO_PID) },
         { USB_DEVICE(CONTEC_VID, CONTEC_COM1USBH_PID) },
         { USB_DEVICE(BANDB_VID, BANDB_USOTL4_PID) },
         { USB_DEVICE(BANDB_VID, BANDB_USTL4_PID) },
@@ -634,6 +648,7 @@ static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(FTDI_VID, EVER_ECO_PRO_CDS) },
         { USB_DEVICE(FTDI_VID, FTDI_4N_GALAXY_DE_1_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_4N_GALAXY_DE_2_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_4N_GALAXY_DE_3_PID) },
         { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_0_PID) },
         { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_1_PID) },
         { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_2_PID) },
@@ -673,8 +688,17 @@ static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(FTDI_VID, FTDI_PCDJ_DAC2_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_RRCIRKITS_LOCOBUFFER_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_ASK_RDR400_PID) },
-        { USB_DEVICE(ICOM_ID1_VID, ICOM_ID1_PID) },
-        { USB_DEVICE(PAPOUCH_VID, PAPOUCH_TMU_PID) },
+        { USB_DEVICE(ICOM_VID, ICOM_ID_1_PID) },
+        { USB_DEVICE(ICOM_VID, ICOM_OPC_U_UC_PID) },
+        { USB_DEVICE(ICOM_VID, ICOM_ID_RP2C1_PID) },
+        { USB_DEVICE(ICOM_VID, ICOM_ID_RP2C2_PID) },
+        { USB_DEVICE(ICOM_VID, ICOM_ID_RP2D_PID) },
+        { USB_DEVICE(ICOM_VID, ICOM_ID_RP2VT_PID) },
+        { USB_DEVICE(ICOM_VID, ICOM_ID_RP2VR_PID) },
+        { USB_DEVICE(ICOM_VID, ICOM_ID_RP4KVT_PID) },
+        { USB_DEVICE(ICOM_VID, ICOM_ID_RP4KVR_PID) },
+        { USB_DEVICE(ICOM_VID, ICOM_ID_RP2KVT_PID) },
+        { USB_DEVICE(ICOM_VID, ICOM_ID_RP2KVR_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_ACG_HFDUAL_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_YEI_SERVOCENTER31_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_THORLABS_PID) },
@@ -696,6 +720,7 @@ static struct usb_device_id id_table_combined [] = {
                 .driver_info = (kernel_ulong_t)&ftdi_NDI_device_quirk },
         { USB_DEVICE(TELLDUS_VID, TELLDUS_TELLSTICK_PID) },
         { USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_SERIAL_VX7_PID) },
+        { USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_CT29B_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_MAXSTREAM_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_PHI_FISCO_PID) },
         { USB_DEVICE(TML_VID, TML_USB_SERIAL_PID) },
@@ -703,6 +728,8 @@ static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(FTDI_VID, FTDI_PROPOX_JTAGCABLEII_PID) },
         { USB_DEVICE(OLIMEX_VID, OLIMEX_ARM_USB_OCD_PID),
                 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
+        { USB_DEVICE(OLIMEX_VID, OLIMEX_ARM_USB_OCD_H_PID),
+                .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
         { USB_DEVICE(FIC_VID, FIC_NEO1973_DEBUG_PID),
                 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
         { USB_DEVICE(FTDI_VID, FTDI_OOCDLINK_PID),
@@ -715,8 +742,37 @@ static struct usb_device_id id_table_combined [] = {
                 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
         { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID_USB60F) },
         { USB_DEVICE(FTDI_VID, FTDI_REU_TINY_PID) },
+
+        /* Papouch devices based on FTDI chip */
+        { USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB485_PID) },
+        { USB_DEVICE(PAPOUCH_VID, PAPOUCH_AP485_PID) },
+        { USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB422_PID) },
+        { USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB485_2_PID) },
+        { USB_DEVICE(PAPOUCH_VID, PAPOUCH_AP485_2_PID) },
+        { USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB422_2_PID) },
+        { USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB485S_PID) },
+        { USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB485C_PID) },
+        { USB_DEVICE(PAPOUCH_VID, PAPOUCH_LEC_PID) },
+        { USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB232_PID) },
+        { USB_DEVICE(PAPOUCH_VID, PAPOUCH_TMU_PID) },
+        { USB_DEVICE(PAPOUCH_VID, PAPOUCH_IRAMP_PID) },
+        { USB_DEVICE(PAPOUCH_VID, PAPOUCH_DRAK5_PID) },
+        { USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO8x8_PID) },
         { USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO4x4_PID) },
+        { USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO2x2_PID) },
+        { USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO10x1_PID) },
+        { USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO30x3_PID) },
+        { USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO60x3_PID) },
+        { USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO2x16_PID) },
+        { USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO3x32_PID) },
+        { USB_DEVICE(PAPOUCH_VID, PAPOUCH_DRAK6_PID) },
+        { USB_DEVICE(PAPOUCH_VID, PAPOUCH_UPSUSB_PID) },
+        { USB_DEVICE(PAPOUCH_VID, PAPOUCH_MU_PID) },
+        { USB_DEVICE(PAPOUCH_VID, PAPOUCH_SIMUKEY_PID) },
         { USB_DEVICE(PAPOUCH_VID, PAPOUCH_AD4USB_PID) },
+        { USB_DEVICE(PAPOUCH_VID, PAPOUCH_GMUX_PID) },
+        { USB_DEVICE(PAPOUCH_VID, PAPOUCH_GMSR_PID) },
+
         { USB_DEVICE(FTDI_VID, FTDI_DOMINTELL_DGQG_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_DOMINTELL_DUSB_PID) },
         { USB_DEVICE(ALTI2_VID, ALTI2_N3_PID) },
@@ -737,6 +793,8 @@ static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(FTDI_VID, MARVELL_OPENRD_PID),
                 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
         { USB_DEVICE(FTDI_VID, HAMEG_HO820_PID) },
+        { USB_DEVICE(FTDI_VID, HAMEG_HO720_PID) },
+        { USB_DEVICE(FTDI_VID, HAMEG_HO730_PID) },
         { USB_DEVICE(FTDI_VID, HAMEG_HO870_PID) },
         { USB_DEVICE(FTDI_VID, MJSG_GENERIC_PID) },
         { USB_DEVICE(FTDI_VID, MJSG_SR_RADIO_PID) },
@@ -751,6 +809,7 @@ static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(FTDI_VID, XVERVE_SIGNALYZER_SH4_PID),
                 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
         { USB_DEVICE(FTDI_VID, SEGWAY_RMP200_PID) },
+        { USB_DEVICE(FTDI_VID, ACCESIO_COM4SM_PID) },
         { USB_DEVICE(IONICS_VID, IONICS_PLUGCOMPUTER_PID),
                 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
         { USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_24_MASTER_WING_PID) },
@@ -761,6 +820,14 @@ static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_MAXI_WING_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_MEDIA_WING_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_WING_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_SCIENCESCOPE_LOGBOOKML_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_SCIENCESCOPE_LS_LOGBOOK_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_SCIENCESCOPE_HS_LOGBOOK_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_DOTEC_PID) },
+        { USB_DEVICE(QIHARDWARE_VID, MILKYMISTONE_JTAGSERIAL_PID),
+                .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
+        { USB_DEVICE(ST_VID, ST_STMCLT1030_PID),
+                .driver_info = (kernel_ulong_t)&ftdi_stmclite_quirk },
         { },                                    /* Optional parameter entry */
         { }                                     /* Terminating entry */
 };
@@ -782,7 +849,8 @@ static const char *ftdi_chip_name[] = {
         [FT2232C] = "FT2232C",
         [FT232RL] = "FT232RL",
         [FT2232H] = "FT2232H",
-        [FT4232H] = "FT4232H"
+        [FT4232H] = "FT4232H",
+        [FT232H]  = "FT232H"
 };
 
 
@@ -807,10 +875,10 @@ static int ftdi_prepare_write_buffer(struct usb_serial_port *port,
                                                 void *dest, size_t size);
 static void ftdi_set_termios(struct tty_struct *tty,
                         struct usb_serial_port *port, struct ktermios *old);
-static int  ftdi_tiocmget(struct tty_struct *tty, struct file *file);
-static int  ftdi_tiocmset(struct tty_struct *tty, struct file *file,
+static int  ftdi_tiocmget(struct tty_struct *tty);
+static int  ftdi_tiocmset(struct tty_struct *tty,
                         unsigned int set, unsigned int clear);
-static int  ftdi_ioctl(struct tty_struct *tty, struct file *file,
+static int  ftdi_ioctl(struct tty_struct *tty,
                         unsigned int cmd, unsigned long arg);
 static void ftdi_break_ctl(struct tty_struct *tty, int break_state);
 
@@ -916,7 +984,7 @@ static __u32 ftdi_2232h_baud_base_to_divisor(int baud, int base)
         int divisor3;
 
         /* hi-speed baud rate is 10-bit sampling instead of 16-bit */
-        divisor3 = (base / 10 / baud) * 8;
+        divisor3 = base * 8 / (baud * 10);
 
         divisor = divisor3 >> 3;
         divisor |= (__u32)divfrac[divisor3 & 0x7] << 14;
@@ -1102,6 +1170,7 @@ static __u32 get_ftdi_divisor(struct tty_struct *tty,
                 break;
         case FT2232H: /* FT2232H chip */
         case FT4232H: /* FT4232H chip */
+        case FT232H:  /* FT232H chip */
                 if ((baud <= 12000000) & (baud >= 1200)) {
                         div_value = ftdi_2232h_baud_to_divisor(baud);
                 } else if (baud < 1200) {
@@ -1285,6 +1354,23 @@ check_and_exit:
         return 0;
 }
 
+static int get_lsr_info(struct usb_serial_port *port,
+                        struct serial_struct __user *retinfo)
+{
+        struct ftdi_private *priv = usb_get_serial_port_data(port);
+        unsigned int result = 0;
+
+        if (!retinfo)
+                return -EFAULT;
+
+        if (priv->transmit_empty)
+                result = TIOCSER_TEMT;
+
+        if (copy_to_user(retinfo, &result, sizeof(unsigned int)))
+                return -EFAULT;
+        return 0;
+}
+
 
 /* Determine type of FTDI chip based on USB config and descriptor. */
 static void ftdi_determine_type(struct usb_serial_port *port)
@@ -1346,9 +1432,12 @@ static void ftdi_determine_type(struct usb_serial_port *port)
         } else if (version < 0x600) {
                 /* Assume it's an FT232BM (or FT245BM) */
                 priv->chip_type = FT232BM;
-        } else {
-                /* Assume it's an FT232R */
+        } else if (version < 0x900) {
+                /* Assume it's an FT232RL */
                 priv->chip_type = FT232RL;
+        } else {
+                /* Assume it's an FT232H */
+                priv->chip_type = FT232H;
         }
         dev_info(&udev->dev, "Detected %s\n", ftdi_chip_name[priv->chip_type]);
 }
@@ -1476,7 +1565,8 @@ static int create_sysfs_attrs(struct usb_serial_port *port)
                      priv->chip_type == FT2232C ||
                      priv->chip_type == FT232RL ||
                      priv->chip_type == FT2232H ||
-                     priv->chip_type == FT4232H)) {
+                     priv->chip_type == FT4232H ||
+                     priv->chip_type == FT232H)) {
                         retval = device_create_file(&port->dev,
                                                     &dev_attr_latency_timer);
                 }
@@ -1497,7 +1587,8 @@ static void remove_sysfs_attrs(struct usb_serial_port *port)
                     priv->chip_type == FT2232C ||
                     priv->chip_type == FT232RL ||
                     priv->chip_type == FT2232H ||
-                    priv->chip_type == FT4232H) {
+                    priv->chip_type == FT4232H ||
+                    priv->chip_type == FT232H) {
                         device_remove_file(&port->dev, &dev_attr_latency_timer);
                 }
         }
@@ -1559,6 +1650,7 @@ static int ftdi_sio_port_probe(struct usb_serial_port *port)
         ftdi_set_max_packet_size(port);
         if (read_latency_timer(port) < 0)
                 priv->latency = 16;
+        write_latency_timer(port);
         create_sysfs_attrs(port);
         return 0;
 }
@@ -1642,6 +1734,25 @@ static int ftdi_jtag_probe(struct usb_serial *serial)
 }
 
 /*
+ * First and second port on STMCLiteadaptors is reserved for JTAG interface
+ * and the forth port for pio
+ */
+static int ftdi_stmclite_probe(struct usb_serial *serial)
+{
+        struct usb_device *udev = serial->dev;
+        struct usb_interface *interface = serial->interface;
+
+        dbg("%s", __func__);
+
+        if (interface == udev->actconfig->interface[2])
+                return 0;
+
+        dev_info(&udev->dev, "Ignoring serial port reserved for JTAG\n");
+
+        return -ENODEV;
+}
+
+/*
  * The Matrix Orbital VK204-25-USB has an invalid IN endpoint.
  * We have to correct it if we want to read from it.
  */
@@ -1687,8 +1798,6 @@ static int ftdi_open(struct tty_struct *tty, struct usb_serial_port *port)
 
         dbg("%s", __func__);
 
-        write_latency_timer(port);
-
         /* No error checking for this (will get errors later anyway) */
         /* See ftdi_sio.h for description of what is reset */
         usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
@@ -1835,6 +1944,12 @@ static int ftdi_process_packet(struct tty_struct *tty,
                         tty_insert_flip_char(tty, 0, TTY_OVERRUN);
         }
 
+        /* save if the transmitter is empty or not */
+        if (packet[1] & FTDI_RS_TEMT)
+                priv->transmit_empty = 1;
+        else
+                priv->transmit_empty = 0;
+
         len -= 2;
         if (!len)
                 return 0;       /* status only */
@@ -2028,8 +2143,6 @@ static void ftdi_set_termios(struct tty_struct *tty,
                                 "urb failed to set to rts/cts flow control\n");
                 }
 
-                /* raise DTR/RTS */
-                set_mctrl(port, TIOCM_DTR | TIOCM_RTS);
         } else {
                 /*
                  * Xon/Xoff code
@@ -2077,13 +2190,10 @@ static void ftdi_set_termios(struct tty_struct *tty,
                         }
                 }
 
-                /* lower DTR/RTS */
-                clear_mctrl(port, TIOCM_DTR | TIOCM_RTS);
         }
-        return;
 }
 
-static int ftdi_tiocmget(struct tty_struct *tty, struct file *file)
+static int ftdi_tiocmget(struct tty_struct *tty)
 {
         struct usb_serial_port *port = tty->driver_data;
         struct ftdi_private *priv = usb_get_serial_port_data(port);
@@ -2110,6 +2220,7 @@ static int ftdi_tiocmget(struct tty_struct *tty, struct file *file)
         case FT232RL:
         case FT2232H:
         case FT4232H:
+        case FT232H:
                 len = 2;
                 break;
         default:
@@ -2136,7 +2247,7 @@ out:
         return ret;
 }
 
-static int ftdi_tiocmset(struct tty_struct *tty, struct file *file,
+static int ftdi_tiocmset(struct tty_struct *tty,
                         unsigned int set, unsigned int clear)
 {
         struct usb_serial_port *port = tty->driver_data;
@@ -2144,7 +2255,7 @@ static int ftdi_tiocmset(struct tty_struct *tty, struct file *file,
         return update_mctrl(port, set, clear);
 }
 
-static int ftdi_ioctl(struct tty_struct *tty, struct file *file,
+static int ftdi_ioctl(struct tty_struct *tty,
                                         unsigned int cmd, unsigned long arg)
 {
         struct usb_serial_port *port = tty->driver_data;
@@ -2168,6 +2279,7 @@ static int ftdi_ioctl(struct tty_struct *tty, struct file *file,
          * - mask passed in arg for lines of interest
          *   (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
          * Caller should use TIOCGICOUNT to see which one it was.
+         * (except that the driver doesn't support it !)
          *
          * This code is borrowed from linux/drivers/char/serial.c
          */
@@ -2202,6 +2314,9 @@ static int ftdi_ioctl(struct tty_struct *tty, struct file *file,
                         }
                 }
                 return 0;
+        case TIOCSERGETLSR:
+                return get_lsr_info(port, (struct serial_struct __user *)arg);
+                break;
         default:
                 break;
         }
diff --git a/drivers/usb/serial/ftdi_sio.h b/drivers/usb/serial/ftdi_sio.h
index 213fe3d61282..19584faa86f9 100644
--- a/drivers/usb/serial/ftdi_sio.h
+++ b/drivers/usb/serial/ftdi_sio.h
@@ -156,7 +156,8 @@ enum ftdi_chip_type {
         FT2232C = 4,
         FT232RL = 5,
         FT2232H = 6,
-        FT4232H = 7
+        FT4232H = 7,
+        FT232H  = 8
 };
 
 enum ftdi_sio_baudrate {
diff --git a/drivers/usb/serial/ftdi_sio_ids.h b/drivers/usb/serial/ftdi_sio_ids.h
index 15a4583775ad..19156d1049fe 100644
--- a/drivers/usb/serial/ftdi_sio_ids.h
+++ b/drivers/usb/serial/ftdi_sio_ids.h
@@ -22,6 +22,7 @@
 #define FTDI_8U232AM_ALT_PID 0x6006 /* FTDI's alternate PID for above */
 #define FTDI_8U2232C_PID 0x6010 /* Dual channel device */
 #define FTDI_4232H_PID 0x6011 /* Quad channel hi-speed device */
+#define FTDI_232H_PID  0x6014 /* Single channel hi-speed device */
 #define FTDI_SIO_PID    0x8372  /* Product Id SIO application of 8U100AX */
 #define FTDI_232RL_PID  0xFBFA  /* Product ID for FT232RL */
 
@@ -46,7 +47,7 @@
 #define FTDI_USINT_RS232_PID    0xb812  /* Navigator RS232 and CONFIG lines */
 
 /* OOCDlink by Joern Kaipf <joernk@web.de>
- * (http://www.joernonline.de/dw/doku.php?id=start&idx=projects:oocdlink) */
+ * (http://www.joernonline.de/) */
 #define FTDI_OOCDLINK_PID       0xbaf8  /* Amontec JTAGkey */
 
 /* Luminary Micro Stellaris Boards, VID = FTDI_VID */
@@ -61,6 +62,7 @@
 #define FTDI_OPENDCC_SNIFFER_PID        0xBFD9
 #define FTDI_OPENDCC_THROTTLE_PID       0xBFDA
 #define FTDI_OPENDCC_GATEWAY_PID        0xBFDB
+#define FTDI_OPENDCC_GBM_PID    0xBFDC
 
 /*
  * RR-CirKits LocoBuffer USB (http://www.rr-cirkits.com)
@@ -113,6 +115,9 @@
 /* Lenz LI-USB Computer Interface. */
 #define FTDI_LENZ_LIUSB_PID     0xD780
 
+/* Vardaan Enterprises Serial Interface VEUSB422R3 */
+#define FTDI_VARDAAN_PID        0xF070
+
 /*
  * Xsens Technologies BV products (http://www.xsens.com).
  */
@@ -296,6 +301,8 @@
  * Hameg HO820 and HO870 interface (using VID 0x0403)
  */
 #define HAMEG_HO820_PID                 0xed74
+#define HAMEG_HO730_PID                 0xed73
+#define HAMEG_HO720_PID                 0xed72
 #define HAMEG_HO870_PID                 0xed71
 
 /*
@@ -335,7 +342,7 @@
 #define FTDI_PIEGROUP_PID       0xF208  /* Product Id */
 
 /* ACT Solutions HomePro ZWave interface
-   (http://www.act-solutions.com/HomePro.htm) */
+   (http://www.act-solutions.com/HomePro-Product-Matrix.html) */
 #define FTDI_ACTZWAVE_PID       0xF2D0
 
 /*
@@ -345,6 +352,7 @@
  */
 #define FTDI_4N_GALAXY_DE_1_PID 0xF3C0
 #define FTDI_4N_GALAXY_DE_2_PID 0xF3C1
+#define FTDI_4N_GALAXY_DE_3_PID 0xF3C2
 
 /*
  * Linx Technologies product ids
@@ -366,7 +374,7 @@
 #define FTDI_SUUNTO_SPORTS_PID  0xF680  /* Suunto Sports instrument */
 
 /* USB-UIRT - An infrared receiver and transmitter using the 8U232AM chip */
-/* http://home.earthlink.net/~jrhees/USBUIRT/index.htm */
+/* http://www.usbuirt.com/ */
 #define FTDI_USB_UIRT_PID       0xF850  /* Product Id */
 
 /* CCS Inc. ICDU/ICDU40 product ID -
@@ -395,7 +403,7 @@
  */
 #define FTDI_HE_TIRA1_PID       0xFA78  /* Tira-1 IR transceiver */
 
-/* Inside Accesso contactless reader (http://www.insidefr.com) */
+/* Inside Accesso contactless reader (http://www.insidecontactless.com/) */
 #define INSIDE_ACCESSO          0xFAD0
 
 /*
@@ -485,6 +493,11 @@
 /* www.canusb.com Lawicel CANUSB device (FTDI_VID) */
 #define FTDI_CANUSB_PID 0xFFA8 /* Product Id */
 
+/*
+ * TavIR AVR product ids (FTDI_VID)
+ */
+#define FTDI_TAVIR_STK500_PID   0xFA33  /* STK500 AVR programmer */
+
 
 
 /********************************/
@@ -514,6 +527,12 @@
 #define RATOC_PRODUCT_ID_USB60F 0xb020
 
 /*
+ * Acton Research Corp.
+ */
+#define ACTON_VID               0x0647  /* Vendor ID */
+#define ACTON_SPECTRAPRO_PID    0x0100
+
+/*
  * Contec products (http://www.contec.com)
  * Submitted by Daniel Sangorrin
  */
@@ -562,14 +581,27 @@
 /* Note: OCT US101 is also rebadged as Dick Smith Electronics (NZ) XH6381 */
 /* Also rebadged as Dick Smith Electronics (Aus) XH6451 */
 /* Also rebadged as SIIG Inc. model US2308 hardware version 1 */
+#define OCT_DK201_PID           0x0103  /* OCT DK201 USB docking station */
 #define OCT_US101_PID           0x0421  /* OCT US101 USB to RS-232 */
 
 /*
- * Icom ID-1 digital transceiver
+ * Definitions for Icom Inc. devices
  */
-
-#define ICOM_ID1_VID            0x0C26
-#define ICOM_ID1_PID            0x0004
+#define ICOM_VID                0x0C26 /* Icom vendor ID */
+/* Note: ID-1 is a communications tranceiver for HAM-radio operators */
+#define ICOM_ID_1_PID           0x0004 /* ID-1 USB to RS-232 */
+/* Note: OPC is an Optional cable to connect an Icom Tranceiver */
+#define ICOM_OPC_U_UC_PID       0x0018 /* OPC-478UC, OPC-1122U cloning cable */
+/* Note: ID-RP* devices are Icom Repeater Devices for HAM-radio */
+#define ICOM_ID_RP2C1_PID       0x0009 /* ID-RP2C Asset 1 to RS-232 */
+#define ICOM_ID_RP2C2_PID       0x000A /* ID-RP2C Asset 2 to RS-232 */
+#define ICOM_ID_RP2D_PID        0x000B /* ID-RP2D configuration port*/
+#define ICOM_ID_RP2VT_PID       0x000C /* ID-RP2V Transmit config port */
+#define ICOM_ID_RP2VR_PID       0x000D /* ID-RP2V Receive config port */
+#define ICOM_ID_RP4KVT_PID      0x0010 /* ID-RP4000V Transmit config port */
+#define ICOM_ID_RP4KVR_PID      0x0011 /* ID-RP4000V Receive config port */
+#define ICOM_ID_RP2KVT_PID      0x0012 /* ID-RP2000V Transmit config port */
+#define ICOM_ID_RP2KVR_PID      0x0013 /* ID-RP2000V Receive config port */
 
 /*
  * GN Otometrics (http://www.otometrics.com)
@@ -634,14 +666,14 @@
 
 /*
  * JETI SPECTROMETER SPECBOS 1201
- * http://www.jeti.com/products/sys/scb/scb1201.php
+ * http://www.jeti.com/cms/index.php/instruments/other-instruments/specbos-2101
  */
 #define JETI_VID                0x0c6c
 #define JETI_SPC1201_PID        0x04b2
 
 /*
  * FTDI USB UART chips used in construction projects from the
- * Elektor Electronics magazine (http://elektor-electronics.co.uk)
+ * Elektor Electronics magazine (http://www.elektor.com/)
  */
 #define ELEKTOR_VID             0x0C7D
 #define ELEKTOR_FT323R_PID      0x0005  /* RFID-Reader, issue 09-2006 */
@@ -708,6 +740,7 @@
 /* Olimex */
 #define OLIMEX_VID                      0x15BA
 #define OLIMEX_ARM_USB_OCD_PID          0x0003
+#define OLIMEX_ARM_USB_OCD_H_PID        0x002b
 
 /*
  * Telldus Technologies
@@ -720,6 +753,7 @@
  */
 #define RTSYSTEMS_VID                   0x2100  /* Vendor ID */
 #define RTSYSTEMS_SERIAL_VX7_PID        0x9e52  /* Serial converter for VX-7 Radios using FT232RL */
+#define RTSYSTEMS_CT29B_PID             0x9e54  /* CT29B Radio Cable */
 
 /*
  * Bayer Ascensia Contour blood glucose meter USB-converter cable.
@@ -1017,14 +1051,45 @@
 #define WHT_PID                 0x0004 /* Wireless Handheld Terminal */
 
 /*
+ * STMicroelectonics
+ */
+#define ST_VID                  0x0483
+#define ST_STMCLT1030_PID       0x3747 /* ST Micro Connect Lite STMCLT1030 */
+
+/*
  * Papouch products (http://www.papouch.com/)
  * Submitted by Folkert van Heusden
  */
 
 #define PAPOUCH_VID                     0x5050  /* Vendor ID */
+#define PAPOUCH_SB485_PID               0x0100  /* Papouch SB485 USB-485/422 Converter */
+#define PAPOUCH_AP485_PID               0x0101  /* AP485 USB-RS485 Converter */
+#define PAPOUCH_SB422_PID               0x0102  /* Papouch SB422 USB-RS422 Converter  */
+#define PAPOUCH_SB485_2_PID             0x0103  /* Papouch SB485 USB-485/422 Converter */
+#define PAPOUCH_AP485_2_PID             0x0104  /* AP485 USB-RS485 Converter */
+#define PAPOUCH_SB422_2_PID             0x0105  /* Papouch SB422 USB-RS422 Converter  */
+#define PAPOUCH_SB485S_PID              0x0106  /* Papouch SB485S USB-485/422 Converter */
+#define PAPOUCH_SB485C_PID              0x0107  /* Papouch SB485C USB-485/422 Converter */
+#define PAPOUCH_LEC_PID                 0x0300  /* LEC USB Converter */
+#define PAPOUCH_SB232_PID               0x0301  /* Papouch SB232 USB-RS232 Converter */
 #define PAPOUCH_TMU_PID                 0x0400  /* TMU USB Thermometer */
-#define PAPOUCH_QUIDO4x4_PID            0x0900  /* Quido 4/4 Module */
+#define PAPOUCH_IRAMP_PID               0x0500  /* Papouch IRAmp Duplex */
+#define PAPOUCH_DRAK5_PID               0x0700  /* Papouch DRAK5 */
+#define PAPOUCH_QUIDO8x8_PID            0x0800  /* Papouch Quido 8/8 Module */
+#define PAPOUCH_QUIDO4x4_PID            0x0900  /* Papouch Quido 4/4 Module */
+#define PAPOUCH_QUIDO2x2_PID            0x0a00  /* Papouch Quido 2/2 Module */
+#define PAPOUCH_QUIDO10x1_PID           0x0b00  /* Papouch Quido 10/1 Module */
+#define PAPOUCH_QUIDO30x3_PID           0x0c00  /* Papouch Quido 30/3 Module */
+#define PAPOUCH_QUIDO60x3_PID           0x0d00  /* Papouch Quido 60(100)/3 Module */
+#define PAPOUCH_QUIDO2x16_PID           0x0e00  /* Papouch Quido 2/16 Module */
+#define PAPOUCH_QUIDO3x32_PID           0x0f00  /* Papouch Quido 3/32 Module */
+#define PAPOUCH_DRAK6_PID               0x1000  /* Papouch DRAK6 */
+#define PAPOUCH_UPSUSB_PID              0x8000  /* Papouch UPS-USB adapter */
+#define PAPOUCH_MU_PID                  0x8001  /* MU controller */
+#define PAPOUCH_SIMUKEY_PID             0x8002  /* Papouch SimuKey */
 #define PAPOUCH_AD4USB_PID              0x8003  /* AD4USB Measurement Module */
+#define PAPOUCH_GMUX_PID                0x8004  /* Papouch GOLIATH MUX */
+#define PAPOUCH_GMSR_PID                0x8005  /* Papouch GOLIATH MSR */
 
 /*
  * Marvell SheevaPlug
@@ -1051,6 +1116,11 @@
 #define MJSG_HD_RADIO_PID       0x937C
 
 /*
+ * D.O.Tec products (http://www.directout.eu)
+ */
+#define FTDI_DOTEC_PID 0x9868
+
+/*
  * Xverve Signalyzer tools (http://www.signalyzer.com/)
  */
 #define XVERVE_SIGNALYZER_ST_PID        0xBCA0
@@ -1063,3 +1133,30 @@
  * Submitted by John G. Rogers
  */
 #define SEGWAY_RMP200_PID       0xe729
+
+
+/*
+ * Accesio USB Data Acquisition products (http://www.accesio.com/)
+ */
+#define ACCESIO_COM4SM_PID      0xD578
+
+/* www.sciencescope.co.uk educational dataloggers */
+#define FTDI_SCIENCESCOPE_LOGBOOKML_PID         0xFF18
+#define FTDI_SCIENCESCOPE_LS_LOGBOOK_PID        0xFF1C
+#define FTDI_SCIENCESCOPE_HS_LOGBOOK_PID        0xFF1D
+
+/*
+ * Milkymist One JTAG/Serial
+ */
+#define QIHARDWARE_VID                  0x20B7
+#define MILKYMISTONE_JTAGSERIAL_PID     0x0713
+
+/*
+ * CTI GmbH RS485 Converter http://www.cti-lean.com/
+ */
+/* USB-485-Mini*/
+#define FTDI_CTI_MINI_PID       0xF608
+/* USB-Nano-485*/
+#define FTDI_CTI_NANO_PID       0xF60B
+
+
diff --git a/drivers/usb/serial/garmin_gps.c b/drivers/usb/serial/garmin_gps.c
index a42b29a695b2..b0a7a9e909a4 100644
--- a/drivers/usb/serial/garmin_gps.c
+++ b/drivers/usb/serial/garmin_gps.c
@@ -1,7 +1,7 @@
 /*
  * Garmin GPS driver
  *
- * Copyright (C) 2006-2009 Hermann Kneissel herkne@users.sourceforge.net
+ * Copyright (C) 2006-2011 Hermann Kneissel herkne@gmx.de
  *
  * The latest version of the driver can be found at
  * http://sourceforge.net/projects/garmin-gps/
@@ -51,7 +51,7 @@ static int debug;
  */
 
 #define VERSION_MAJOR   0
-#define VERSION_MINOR   33
+#define VERSION_MINOR   36
 
 #define _STR(s) #s
 #define _DRIVER_VERSION(a, b) "v" _STR(a) "." _STR(b)
@@ -410,6 +410,7 @@ static int gsp_send_ack(struct garmin_data *garmin_data_p, __u8 pkt_id)
  */
 static int gsp_rec_packet(struct garmin_data *garmin_data_p, int count)
 {
+        unsigned long flags;
         const __u8 *recpkt = garmin_data_p->inbuffer+GSP_INITIAL_OFFSET;
         __le32 *usbdata = (__le32 *) garmin_data_p->inbuffer;
 
@@ -458,7 +459,9 @@ static int gsp_rec_packet(struct garmin_data *garmin_data_p, int count)
         /* if this was an abort-transfer command, flush all
            queued data. */
         if (isAbortTrfCmnd(garmin_data_p->inbuffer)) {
+                spin_lock_irqsave(&garmin_data_p->lock, flags);
                 garmin_data_p->flags |= FLAGS_DROP_DATA;
+                spin_unlock_irqrestore(&garmin_data_p->lock, flags);
                 pkt_clear(garmin_data_p);
         }
 
@@ -943,7 +946,7 @@ static int garmin_open(struct tty_struct *tty, struct usb_serial_port *port)
         spin_lock_irqsave(&garmin_data_p->lock, flags);
         garmin_data_p->mode  = initial_mode;
         garmin_data_p->count = 0;
-        garmin_data_p->flags = 0;
+        garmin_data_p->flags &= FLAGS_SESSION_REPLY1_SEEN;
         spin_unlock_irqrestore(&garmin_data_p->lock, flags);
 
         /* shutdown any bulk reads that might be going on */
@@ -1178,7 +1181,8 @@ static int garmin_write_room(struct tty_struct *tty)
 
 
 static void garmin_read_process(struct garmin_data *garmin_data_p,
-                                 unsigned char *data, unsigned data_length)
+                                 unsigned char *data, unsigned data_length,
+                                 int bulk_data)
 {
         unsigned long flags;
 
@@ -1193,7 +1197,8 @@ static void garmin_read_process(struct garmin_data *garmin_data_p,
                    send it directly to the tty port */
                 if (garmin_data_p->flags & FLAGS_QUEUING) {
                         pkt_add(garmin_data_p, data, data_length);
-                } else if (getLayerId(data) == GARMIN_LAYERID_APPL) {
+                } else if (bulk_data || 
+                           getLayerId(data) == GARMIN_LAYERID_APPL) {
 
                         spin_lock_irqsave(&garmin_data_p->lock, flags);
                         garmin_data_p->flags |= APP_RESP_SEEN;
@@ -1237,7 +1242,7 @@ static void garmin_read_bulk_callback(struct urb *urb)
         usb_serial_debug_data(debug, &port->dev,
                                 __func__, urb->actual_length, data);
 
-        garmin_read_process(garmin_data_p, data, urb->actual_length);
+        garmin_read_process(garmin_data_p, data, urb->actual_length, 1);
 
         if (urb->actual_length == 0 &&
                         0 != (garmin_data_p->flags & FLAGS_BULK_IN_RESTART)) {
@@ -1264,7 +1269,6 @@ static void garmin_read_bulk_callback(struct urb *urb)
                 garmin_data_p->flags &= ~FLAGS_BULK_IN_ACTIVE;
                 spin_unlock_irqrestore(&garmin_data_p->lock, flags);
         }
-        return;
 }
 
 
@@ -1347,7 +1351,7 @@ static void garmin_read_int_callback(struct urb *urb)
                         __func__, garmin_data_p->serial_num);
         }
 
-        garmin_read_process(garmin_data_p, data, urb->actual_length);
+        garmin_read_process(garmin_data_p, data, urb->actual_length, 0);
 
         port->interrupt_in_urb->dev = port->serial->dev;
         retval = usb_submit_urb(urb, GFP_ATOMIC);
@@ -1462,6 +1466,7 @@ static int garmin_attach(struct usb_serial *serial)
         garmin_data_p->timer.function = timeout_handler;
         garmin_data_p->port = port;
         garmin_data_p->state = 0;
+        garmin_data_p->flags = 0;
         garmin_data_p->count = 0;
         usb_set_serial_port_data(port, garmin_data_p);
 
diff --git a/drivers/usb/serial/generic.c b/drivers/usb/serial/generic.c
index e6833e216fc9..e4db5ad2bc55 100644
--- a/drivers/usb/serial/generic.c
+++ b/drivers/usb/serial/generic.c
@@ -479,6 +479,26 @@ int usb_serial_handle_break(struct usb_serial_port *port)
 }
 EXPORT_SYMBOL_GPL(usb_serial_handle_break);
 
+/**
+ *      usb_serial_handle_dcd_change - handle a change of carrier detect state
+ *      @port: usb_serial_port structure for the open port
+ *      @tty: tty_struct structure for the port
+ *      @status: new carrier detect status, nonzero if active
+ */
+void usb_serial_handle_dcd_change(struct usb_serial_port *usb_port,
+                                struct tty_struct *tty, unsigned int status)
+{
+        struct tty_port *port = &usb_port->port;
+
+        dbg("%s - port %d, status %d", __func__, usb_port->number, status);
+
+        if (status)
+                wake_up_interruptible(&port->open_wait);
+        else if (tty && !C_CLOCAL(tty))
+                tty_hangup(tty);
+}
+EXPORT_SYMBOL_GPL(usb_serial_handle_dcd_change);
+
 int usb_serial_generic_resume(struct usb_serial *serial)
 {
         struct usb_serial_port *port;
diff --git a/drivers/usb/serial/io_edgeport.c b/drivers/usb/serial/io_edgeport.c
index 76e6fb3aab7a..abf095be5753 100644
--- a/drivers/usb/serial/io_edgeport.c
+++ b/drivers/usb/serial/io_edgeport.c
@@ -216,12 +216,14 @@ static void edge_unthrottle(struct tty_struct *tty);
 static void edge_set_termios(struct tty_struct *tty,
                                         struct usb_serial_port *port,
                                         struct ktermios *old_termios);
-static int  edge_ioctl(struct tty_struct *tty, struct file *file,
+static int  edge_ioctl(struct tty_struct *tty,
                                         unsigned int cmd, unsigned long arg);
 static void edge_break(struct tty_struct *tty, int break_state);
-static int  edge_tiocmget(struct tty_struct *tty, struct file *file);
-static int  edge_tiocmset(struct tty_struct *tty, struct file *file,
+static int  edge_tiocmget(struct tty_struct *tty);
+static int  edge_tiocmset(struct tty_struct *tty,
                                         unsigned int set, unsigned int clear);
+static int  edge_get_icount(struct tty_struct *tty,
+                                struct serial_icounter_struct *icount);
 static int  edge_startup(struct usb_serial *serial);
 static void edge_disconnect(struct usb_serial *serial);
 static void edge_release(struct usb_serial *serial);
@@ -1465,8 +1467,6 @@ static void edge_throttle(struct tty_struct *tty)
                 if (status != 0)
                         return;
         }
-
-        return;
 }
 
 
@@ -1568,7 +1568,7 @@ static int get_lsr_info(struct edgeport_port *edge_port,
         return 0;
 }
 
-static int edge_tiocmset(struct tty_struct *tty, struct file *file,
+static int edge_tiocmset(struct tty_struct *tty,
                                         unsigned int set, unsigned int clear)
 {
         struct usb_serial_port *port = tty->driver_data;
@@ -1599,7 +1599,7 @@ static int edge_tiocmset(struct tty_struct *tty, struct file *file,
         return 0;
 }
 
-static int edge_tiocmget(struct tty_struct *tty, struct file *file)
+static int edge_tiocmget(struct tty_struct *tty)
 {
         struct usb_serial_port *port = tty->driver_data;
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
@@ -1624,6 +1624,31 @@ static int edge_tiocmget(struct tty_struct *tty, struct file *file)
         return result;
 }
 
+static int edge_get_icount(struct tty_struct *tty,
+                                struct serial_icounter_struct *icount)
+{
+        struct usb_serial_port *port = tty->driver_data;
+        struct edgeport_port *edge_port = usb_get_serial_port_data(port);
+        struct async_icount cnow;
+        cnow = edge_port->icount;
+
+        icount->cts = cnow.cts;
+        icount->dsr = cnow.dsr;
+        icount->rng = cnow.rng;
+        icount->dcd = cnow.dcd;
+        icount->rx = cnow.rx;
+        icount->tx = cnow.tx;
+        icount->frame = cnow.frame;
+        icount->overrun = cnow.overrun;
+        icount->parity = cnow.parity;
+        icount->brk = cnow.brk;
+        icount->buf_overrun = cnow.buf_overrun;
+
+        dbg("%s (%d) TIOCGICOUNT RX=%d, TX=%d",
+                        __func__,  port->number, icount->rx, icount->tx);
+        return 0;
+}
+
 static int get_serial_info(struct edgeport_port *edge_port,
                                 struct serial_struct __user *retinfo)
 {
@@ -1650,12 +1675,11 @@ static int get_serial_info(struct edgeport_port *edge_port,
 }
 
 
-
 /*****************************************************************************
  * SerialIoctl
  *      this function handles any ioctl calls to the driver
  *****************************************************************************/
-static int edge_ioctl(struct tty_struct *tty, struct file *file,
+static int edge_ioctl(struct tty_struct *tty,
                                         unsigned int cmd, unsigned long arg)
 {
         struct usb_serial_port *port = tty->driver_data;
@@ -1663,7 +1687,6 @@ static int edge_ioctl(struct tty_struct *tty, struct file *file,
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
         struct async_icount cnow;
         struct async_icount cprev;
-        struct serial_icounter_struct icount;
 
         dbg("%s - port %d, cmd = 0x%x", __func__, port->number, cmd);
 
@@ -1702,26 +1725,6 @@ static int edge_ioctl(struct tty_struct *tty, struct file *file,
                 /* NOTREACHED */
                 break;
 
-        case TIOCGICOUNT:
-                cnow = edge_port->icount;
-                memset(&icount, 0, sizeof(icount));
-                icount.cts = cnow.cts;
-                icount.dsr = cnow.dsr;
-                icount.rng = cnow.rng;
-                icount.dcd = cnow.dcd;
-                icount.rx = cnow.rx;
-                icount.tx = cnow.tx;
-                icount.frame = cnow.frame;
-                icount.overrun = cnow.overrun;
-                icount.parity = cnow.parity;
-                icount.brk = cnow.brk;
-                icount.buf_overrun = cnow.buf_overrun;
-
-                dbg("%s (%d) TIOCGICOUNT RX=%d, TX=%d",
-                                __func__,  port->number, icount.rx, icount.tx);
-                if (copy_to_user((void __user *)arg, &icount, sizeof(icount)))
-                        return -EFAULT;
-                return 0;
         }
         return -ENOIOCTLCMD;
 }
@@ -1770,8 +1773,6 @@ static void edge_break(struct tty_struct *tty, int break_state)
                         dbg("%s - error sending break set/clear command.",
                                 __func__);
         }
-
-        return;
 }
 
 
@@ -1980,7 +1981,7 @@ static void process_rcvd_status(struct edgeport_serial *edge_serial,
         if (code == IOSP_STATUS_OPEN_RSP) {
                 edge_port->txCredits = GET_TX_BUFFER_SIZE(byte3);
                 edge_port->maxTxCredits = edge_port->txCredits;
-                dbg("%s - Port %u Open Response Inital MSR = %02x TxBufferSize = %d", __func__, edge_serial->rxPort, byte2, edge_port->txCredits);
+                dbg("%s - Port %u Open Response Initial MSR = %02x TxBufferSize = %d", __func__, edge_serial->rxPort, byte2, edge_port->txCredits);
                 handle_new_msr(edge_port, byte2);
 
                 /* send the current line settings to the port so we are
@@ -2042,7 +2043,6 @@ static void process_rcvd_status(struct edgeport_serial *edge_serial,
                 dbg("%s - Unrecognized IOSP status code %u", __func__, code);
                 break;
         }
-        return;
 }
 
 
@@ -2095,8 +2095,6 @@ static void handle_new_msr(struct edgeport_port *edge_port, __u8 newMsr)
 
         /* Save the new modem status */
         edge_port->shadowMSR = newMsr & 0xf0;
-
-        return;
 }
 
 
@@ -2143,8 +2141,6 @@ static void handle_new_lsr(struct edgeport_port *edge_port, __u8 lsrData,
                 icount->parity++;
         if (newLsr & LSR_FRM_ERR)
                 icount->frame++;
-
-        return;
 }
 
 
@@ -2347,7 +2343,6 @@ static int write_cmd_usb(struct edgeport_port *edge_port,
                                 usb_get_serial_data(edge_port->port->serial);
         int status = 0;
         struct urb *urb;
-        int timeout;
 
         usb_serial_debug_data(debug, &edge_port->port->dev,
                                                 __func__, length, buffer);
@@ -2380,8 +2375,6 @@ static int write_cmd_usb(struct edgeport_port *edge_port,
                 return status;
         }
 
-        /* wait for command to finish */
-        timeout = COMMAND_TIMEOUT;
 #if 0
         wait_event(&edge_port->wait_command, !edge_port->commandPending);
 
@@ -2720,7 +2713,6 @@ static void change_port_settings(struct tty_struct *tty,
                 baud = tty_termios_baud_rate(old_termios);
                 tty_encode_baud_rate(tty, baud, baud);
         }
-        return;
 }
 
 
@@ -2894,8 +2886,8 @@ static void load_application_firmware(struct edgeport_serial *edge_serial)
 
         dbg("%s %d.%d.%d", fw_info, rec->data[0], rec->data[1], build);
 
-        edge_serial->product_info.FirmwareMajorVersion = fw->data[0];
-        edge_serial->product_info.FirmwareMinorVersion = fw->data[1];
+        edge_serial->product_info.FirmwareMajorVersion = rec->data[0];
+        edge_serial->product_info.FirmwareMinorVersion = rec->data[1];
         edge_serial->product_info.FirmwareBuildNumber = cpu_to_le16(build);
 
         for (rec = ihex_next_binrec(rec); rec;
@@ -2922,7 +2914,6 @@ static void load_application_firmware(struct edgeport_serial *edge_serial)
                                     0x40, 0x4000, 0x0001, NULL, 0, 3000);
 
         release_firmware(fw);
-        return;
 }
 
 
diff --git a/drivers/usb/serial/io_edgeport.h b/drivers/usb/serial/io_edgeport.h
index dced7ec65470..ad9c1d47a619 100644
--- a/drivers/usb/serial/io_edgeport.h
+++ b/drivers/usb/serial/io_edgeport.h
@@ -68,7 +68,7 @@ struct comMapper {
 #define PROC_SET_COM_ENTRY              2
 
 
-/* The following sturcture is passed to the write */
+/* The following structure is passed to the write */
 struct procWrite {
         int     Command;
         union {
diff --git a/drivers/usb/serial/io_tables.h b/drivers/usb/serial/io_tables.h
index feb56a4ca799..178b22eb32b1 100644
--- a/drivers/usb/serial/io_tables.h
+++ b/drivers/usb/serial/io_tables.h
@@ -123,6 +123,7 @@ static struct usb_serial_driver edgeport_2port_device = {
         .set_termios            = edge_set_termios,
         .tiocmget               = edge_tiocmget,
         .tiocmset               = edge_tiocmset,
+        .get_icount             = edge_get_icount,
         .write                  = edge_write,
         .write_room             = edge_write_room,
         .chars_in_buffer        = edge_chars_in_buffer,
@@ -152,6 +153,7 @@ static struct usb_serial_driver edgeport_4port_device = {
         .set_termios            = edge_set_termios,
         .tiocmget               = edge_tiocmget,
         .tiocmset               = edge_tiocmset,
+        .get_icount             = edge_get_icount,
         .write                  = edge_write,
         .write_room             = edge_write_room,
         .chars_in_buffer        = edge_chars_in_buffer,
@@ -181,6 +183,7 @@ static struct usb_serial_driver edgeport_8port_device = {
         .set_termios            = edge_set_termios,
         .tiocmget               = edge_tiocmget,
         .tiocmset               = edge_tiocmset,
+        .get_icount             = edge_get_icount,
         .write                  = edge_write,
         .write_room             = edge_write_room,
         .chars_in_buffer        = edge_chars_in_buffer,
@@ -196,6 +199,7 @@ static struct usb_serial_driver epic_device = {
                 .name           = "epic",
         },
         .description            = "EPiC device",
+        .usb_driver             = &io_driver,
         .id_table               = Epic_port_id_table,
         .num_ports              = 1,
         .open                   = edge_open,
@@ -209,6 +213,7 @@ static struct usb_serial_driver epic_device = {
         .set_termios            = edge_set_termios,
         .tiocmget               = edge_tiocmget,
         .tiocmset               = edge_tiocmset,
+        .get_icount             = edge_get_icount,
         .write                  = edge_write,
         .write_room             = edge_write_room,
         .chars_in_buffer        = edge_chars_in_buffer,
diff --git a/drivers/usb/serial/io_ti.c b/drivers/usb/serial/io_ti.c
index a7cfc5952937..0aac00afb5c8 100644
--- a/drivers/usb/serial/io_ti.c
+++ b/drivers/usb/serial/io_ti.c
@@ -433,7 +433,7 @@ static int write_i2c_mem(struct edgeport_serial *serial,
 
         /* We can only send a maximum of 1 aligned byte page at a time */
 
-        /* calulate the number of bytes left in the first page */
+        /* calculate the number of bytes left in the first page */
         write_length = EPROM_PAGE_SIZE -
                                 (start_address & (EPROM_PAGE_SIZE - 1));
 
@@ -1571,8 +1571,6 @@ static void handle_new_msr(struct edgeport_port *edge_port, __u8 msr)
                 }
         }
         tty_kref_put(tty);
-
-        return;
 }
 
 static void handle_new_lsr(struct edgeport_port *edge_port, int lsr_data,
@@ -2424,7 +2422,6 @@ static void change_port_settings(struct tty_struct *tty,
                 dbg("%s - error %d when trying to write config to device",
                      __func__, status);
         kfree(config);
-        return;
 }
 
 static void edge_set_termios(struct tty_struct *tty,
@@ -2445,10 +2442,9 @@ static void edge_set_termios(struct tty_struct *tty,
                 return;
         /* change the port settings to the new ones specified */
         change_port_settings(tty, edge_port, old_termios);
-        return;
 }
 
-static int edge_tiocmset(struct tty_struct *tty, struct file *file,
+static int edge_tiocmset(struct tty_struct *tty,
                                         unsigned int set, unsigned int clear)
 {
         struct usb_serial_port *port = tty->driver_data;
@@ -2481,7 +2477,7 @@ static int edge_tiocmset(struct tty_struct *tty, struct file *file,
         return 0;
 }
 
-static int edge_tiocmget(struct tty_struct *tty, struct file *file)
+static int edge_tiocmget(struct tty_struct *tty)
 {
         struct usb_serial_port *port = tty->driver_data;
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
@@ -2510,6 +2506,27 @@ static int edge_tiocmget(struct tty_struct *tty, struct file *file)
         return result;
 }
 
+static int edge_get_icount(struct tty_struct *tty,
+                                struct serial_icounter_struct *icount)
+{
+        struct usb_serial_port *port = tty->driver_data;
+        struct edgeport_port *edge_port = usb_get_serial_port_data(port);
+        struct async_icount *ic = &edge_port->icount;
+
+        icount->cts = ic->cts;
+        icount->dsr = ic->dsr;
+        icount->rng = ic->rng;
+        icount->dcd = ic->dcd;
+        icount->tx = ic->tx;
+        icount->rx = ic->rx;
+        icount->frame = ic->frame;
+        icount->parity = ic->parity;
+        icount->overrun = ic->overrun;
+        icount->brk = ic->brk;
+        icount->buf_overrun = ic->buf_overrun;
+        return 0;
+}
+
 static int get_serial_info(struct edgeport_port *edge_port,
                                 struct serial_struct __user *retinfo)
 {
@@ -2535,7 +2552,7 @@ static int get_serial_info(struct edgeport_port *edge_port,
         return 0;
 }
 
-static int edge_ioctl(struct tty_struct *tty, struct file *file,
+static int edge_ioctl(struct tty_struct *tty,
                                         unsigned int cmd, unsigned long arg)
 {
         struct usb_serial_port *port = tty->driver_data;
@@ -2572,13 +2589,6 @@ static int edge_ioctl(struct tty_struct *tty, struct file *file,
                 }
                 /* not reached */
                 break;
-        case TIOCGICOUNT:
-                dbg("%s - (%d) TIOCGICOUNT RX=%d, TX=%d", __func__,
-                     port->number, edge_port->icount.rx, edge_port->icount.tx);
-                if (copy_to_user((void __user *)arg, &edge_port->icount,
-                                sizeof(edge_port->icount)))
-                        return -EFAULT;
-                return 0;
         }
         return -ENOIOCTLCMD;
 }
@@ -2758,6 +2768,7 @@ static struct usb_serial_driver edgeport_1port_device = {
         .set_termios            = edge_set_termios,
         .tiocmget               = edge_tiocmget,
         .tiocmset               = edge_tiocmset,
+        .get_icount             = edge_get_icount,
         .write                  = edge_write,
         .write_room             = edge_write_room,
         .chars_in_buffer        = edge_chars_in_buffer,
diff --git a/drivers/usb/serial/iuu_phoenix.c b/drivers/usb/serial/iuu_phoenix.c
index efc72113216b..6aca631a407a 100644
--- a/drivers/usb/serial/iuu_phoenix.c
+++ b/drivers/usb/serial/iuu_phoenix.c
@@ -150,7 +150,7 @@ static void iuu_release(struct usb_serial *serial)
         }
 }
 
-static int iuu_tiocmset(struct tty_struct *tty, struct file *file,
+static int iuu_tiocmset(struct tty_struct *tty,
                         unsigned int set, unsigned int clear)
 {
         struct usb_serial_port *port = tty->driver_data;
@@ -179,7 +179,7 @@ static int iuu_tiocmset(struct tty_struct *tty, struct file *file,
  * When no card , the reader respond with TIOCM_CD
  * This is known as CD autodetect mechanism
  */
-static int iuu_tiocmget(struct tty_struct *tty, struct file *file)
+static int iuu_tiocmget(struct tty_struct *tty)
 {
         struct usb_serial_port *port = tty->driver_data;
         struct iuu_private *priv = usb_get_serial_port_data(port);
@@ -807,7 +807,6 @@ static void read_rxcmd_callback(struct urb *urb)
                           iuu_uart_read_callback, port);
         result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
         dbg("%s - submit result = %d", __func__, result);
-        return;
 }
 
 static int iuu_uart_on(struct usb_serial_port *port)
@@ -1276,6 +1275,7 @@ static struct usb_serial_driver iuu_device = {
                    .name = "iuu_phoenix",
                    },
         .id_table = id_table,
+        .usb_driver = &iuu_driver,
         .num_ports = 1,
         .bulk_in_size = 512,
         .bulk_out_size = 512,
diff --git a/drivers/usb/serial/keyspan.c b/drivers/usb/serial/keyspan.c
index 297163c3c610..a442352d7b61 100644
--- a/drivers/usb/serial/keyspan.c
+++ b/drivers/usb/serial/keyspan.c
@@ -9,7 +9,7 @@
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
 
-  See http://misc.nu/hugh/keyspan.html for more information.
+  See http://blemings.org/hugh/keyspan.html for more information.
 
   Code in this driver inspired by and in a number of places taken
   from Brian Warner's original Keyspan-PDA driver.
@@ -301,7 +301,7 @@ static void keyspan_set_termios(struct tty_struct *tty,
         keyspan_send_setup(port, 0);
 }
 
-static int keyspan_tiocmget(struct tty_struct *tty, struct file *file)
+static int keyspan_tiocmget(struct tty_struct *tty)
 {
         struct usb_serial_port *port = tty->driver_data;
         struct keyspan_port_private *p_priv = usb_get_serial_port_data(port);
@@ -317,7 +317,7 @@ static int keyspan_tiocmget(struct tty_struct *tty, struct file *file)
         return value;
 }
 
-static int keyspan_tiocmset(struct tty_struct *tty, struct file *file,
+static int keyspan_tiocmset(struct tty_struct *tty,
                             unsigned int set, unsigned int clear)
 {
         struct usb_serial_port *port = tty->driver_data;
@@ -2121,16 +2121,16 @@ static int keyspan_usa49_send_setup(struct usb_serial *serial,
         /* Work out which port within the device is being setup */
         device_port = port->number - port->serial->minor;
 
-        dbg("%s - endpoint %d port %d (%d)",
-                        __func__, usb_pipeendpoint(this_urb->pipe),
-                        port->number, device_port);
-
-                /* Make sure we have an urb then send the message */
+        /* Make sure we have an urb then send the message */
         if (this_urb == NULL) {
                 dbg("%s - oops no urb for port %d.", __func__, port->number);
                 return -1;
         }
 
+        dbg("%s - endpoint %d port %d (%d)",
+                        __func__, usb_pipeendpoint(this_urb->pipe),
+                        port->number, device_port);
+
         /* Save reset port val for resend.
            Don't overwrite resend for open/close condition. */
         if ((reset_port + 1) > p_priv->resend_cont)
diff --git a/drivers/usb/serial/keyspan.h b/drivers/usb/serial/keyspan.h
index bf3297ddd186..13fa1d1cc900 100644
--- a/drivers/usb/serial/keyspan.h
+++ b/drivers/usb/serial/keyspan.h
@@ -9,7 +9,7 @@
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
 
-  See http://misc.nu/hugh/keyspan.html for more information.
+  See http://blemings.org/hugh/keyspan.html for more information.
   
   Code in this driver inspired by and in a number of places taken
   from Brian Warner's original Keyspan-PDA driver.
@@ -58,10 +58,9 @@ static void keyspan_set_termios		(struct tty_struct *tty,
                                          struct ktermios *old);
 static void keyspan_break_ctl           (struct tty_struct *tty,
                                          int break_state);
-static int  keyspan_tiocmget            (struct tty_struct *tty,
-                                         struct file *file);
+static int  keyspan_tiocmget            (struct tty_struct *tty);
 static int  keyspan_tiocmset            (struct tty_struct *tty,
-                                         struct file *file, unsigned int set,
+                                         unsigned int set,
                                          unsigned int clear);
 static int  keyspan_fake_startup        (struct usb_serial *serial);
 
@@ -546,6 +545,7 @@ static struct usb_serial_driver keyspan_pre_device = {
                 .name           = "keyspan_no_firm",
         },
         .description            = "Keyspan - (without firmware)",
+        .usb_driver             = &keyspan_driver,
         .id_table               = keyspan_pre_ids,
         .num_ports              = 1,
         .attach                 = keyspan_fake_startup,
@@ -557,6 +557,7 @@ static struct usb_serial_driver keyspan_1port_device = {
                 .name           = "keyspan_1",
         },
         .description            = "Keyspan 1 port adapter",
+        .usb_driver             = &keyspan_driver,
         .id_table               = keyspan_1port_ids,
         .num_ports              = 1,
         .open                   = keyspan_open,
@@ -579,6 +580,7 @@ static struct usb_serial_driver keyspan_2port_device = {
                 .name           = "keyspan_2",
         },
         .description            = "Keyspan 2 port adapter",
+        .usb_driver             = &keyspan_driver,
         .id_table               = keyspan_2port_ids,
         .num_ports              = 2,
         .open                   = keyspan_open,
@@ -601,6 +603,7 @@ static struct usb_serial_driver keyspan_4port_device = {
                 .name           = "keyspan_4",
         },
         .description            = "Keyspan 4 port adapter",
+        .usb_driver             = &keyspan_driver,
         .id_table               = keyspan_4port_ids,
         .num_ports              = 4,
         .open                   = keyspan_open,
diff --git a/drivers/usb/serial/keyspan_pda.c b/drivers/usb/serial/keyspan_pda.c
index 185fe9a7d4e0..d5c0c6ab4966 100644
--- a/drivers/usb/serial/keyspan_pda.c
+++ b/drivers/usb/serial/keyspan_pda.c
@@ -173,7 +173,8 @@ static void keyspan_pda_wakeup_write(struct work_struct *work)
                 container_of(work, struct keyspan_pda_private, wakeup_work);
         struct usb_serial_port *port = priv->port;
         struct tty_struct *tty = tty_port_tty_get(&port->port);
-        tty_wakeup(tty);
+        if (tty)
+                tty_wakeup(tty);
         tty_kref_put(tty);
 }
 
@@ -206,7 +207,7 @@ static void keyspan_pda_request_unthrottle(struct work_struct *work)
 static void keyspan_pda_rx_interrupt(struct urb *urb)
 {
         struct usb_serial_port *port = urb->context;
-        struct tty_struct *tty = tty_port_tty_get(&port->port);
+        struct tty_struct *tty;
         unsigned char *data = urb->transfer_buffer;
         int retval;
         int status = urb->status;
@@ -223,7 +224,7 @@ static void keyspan_pda_rx_interrupt(struct urb *urb)
                 /* this urb is terminated, clean up */
                 dbg("%s - urb shutting down with status: %d",
                     __func__, status);
-                goto out;
+                return;
         default:
                 dbg("%s - nonzero urb status received: %d",
                     __func__, status);
@@ -233,12 +234,14 @@ static void keyspan_pda_rx_interrupt(struct urb *urb)
         /* see if the message is data or a status interrupt */
         switch (data[0]) {
         case 0:
-                /* rest of message is rx data */
-                if (urb->actual_length) {
+                tty = tty_port_tty_get(&port->port);
+                 /* rest of message is rx data */
+                if (tty && urb->actual_length) {
                         tty_insert_flip_string(tty, data + 1,
                                                 urb->actual_length - 1);
                         tty_flip_buffer_push(tty);
                 }
+                tty_kref_put(tty);
                 break;
         case 1:
                 /* status interrupt */
@@ -265,8 +268,6 @@ exit:
                 dev_err(&port->dev,
                         "%s - usb_submit_urb failed with result %d",
                         __func__, retval);
-out:
-        tty_kref_put(tty);                   
 }
 
 
@@ -292,7 +293,6 @@ static void keyspan_pda_rx_unthrottle(struct tty_struct *tty)
         port->interrupt_in_urb->dev = port->serial->dev;
         if (usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL))
                 dbg(" usb_submit_urb(read urb) failed");
-        return;
 }
 
 
@@ -458,7 +458,7 @@ static int keyspan_pda_set_modem_info(struct usb_serial *serial,
         return rc;
 }
 
-static int keyspan_pda_tiocmget(struct tty_struct *tty, struct file *file)
+static int keyspan_pda_tiocmget(struct tty_struct *tty)
 {
         struct usb_serial_port *port = tty->driver_data;
         struct usb_serial *serial = port->serial;
@@ -479,7 +479,7 @@ static int keyspan_pda_tiocmget(struct tty_struct *tty, struct file *file)
         return value;
 }
 
-static int keyspan_pda_tiocmset(struct tty_struct *tty, struct file *file,
+static int keyspan_pda_tiocmset(struct tty_struct *tty,
                                 unsigned int set, unsigned int clear)
 {
         struct usb_serial_port *port = tty->driver_data;
@@ -680,22 +680,6 @@ static void keyspan_pda_dtr_rts(struct usb_serial_port *port, int on)
         }
 }
 
-static int keyspan_pda_carrier_raised(struct usb_serial_port *port)
-{
-        struct usb_serial *serial = port->serial;
-        unsigned char modembits;
-
-        /* If we can read the modem status and the DCD is low then
-           carrier is not raised yet */
-        if (keyspan_pda_get_modem_info(serial, &modembits) >= 0) {
-                if (!(modembits & (1>>6)))
-                        return 0;
-        }
-        /* Carrier raised, or we failed (eg disconnected) so
-           progress accordingly */
-        return 1;
-}
-
 
 static int keyspan_pda_open(struct tty_struct *tty,
                                         struct usb_serial_port *port)
@@ -882,7 +866,6 @@ static struct usb_serial_driver keyspan_pda_device = {
         .id_table =             id_table_std,
         .num_ports =            1,
         .dtr_rts =              keyspan_pda_dtr_rts,
-        .carrier_raised =       keyspan_pda_carrier_raised,
         .open =                 keyspan_pda_open,
         .close =                keyspan_pda_close,
         .write =                keyspan_pda_write,
diff --git a/drivers/usb/serial/kl5kusb105.c b/drivers/usb/serial/kl5kusb105.c
index e8a65ce45a2f..19373cb7c5bf 100644
--- a/drivers/usb/serial/kl5kusb105.c
+++ b/drivers/usb/serial/kl5kusb105.c
@@ -68,8 +68,8 @@ static int  klsi_105_open(struct tty_struct *tty, struct usb_serial_port *port);
 static void klsi_105_close(struct usb_serial_port *port);
 static void klsi_105_set_termios(struct tty_struct *tty,
                         struct usb_serial_port *port, struct ktermios *old);
-static int  klsi_105_tiocmget(struct tty_struct *tty, struct file *file);
-static int  klsi_105_tiocmset(struct tty_struct *tty, struct file *file,
+static int  klsi_105_tiocmget(struct tty_struct *tty);
+static int  klsi_105_tiocmset(struct tty_struct *tty,
                         unsigned int set, unsigned int clear);
 static void klsi_105_process_read_urb(struct urb *urb);
 static int klsi_105_prepare_write_buffer(struct usb_serial_port *port,
@@ -637,7 +637,7 @@ static void mct_u232_break_ctl(struct tty_struct *tty, int break_state)
 }
 #endif
 
-static int klsi_105_tiocmget(struct tty_struct *tty, struct file *file)
+static int klsi_105_tiocmget(struct tty_struct *tty)
 {
         struct usb_serial_port *port = tty->driver_data;
         struct klsi_105_private *priv = usb_get_serial_port_data(port);
@@ -661,7 +661,7 @@ static int klsi_105_tiocmget(struct tty_struct *tty, struct file *file)
         return (int)line_state;
 }
 
-static int klsi_105_tiocmset(struct tty_struct *tty, struct file *file,
+static int klsi_105_tiocmset(struct tty_struct *tty,
                              unsigned int set, unsigned int clear)
 {
         int retval = -EINVAL;
diff --git a/drivers/usb/serial/kobil_sct.c b/drivers/usb/serial/kobil_sct.c
index bd5bd8589e04..ddd146300ddb 100644
--- a/drivers/usb/serial/kobil_sct.c
+++ b/drivers/usb/serial/kobil_sct.c
@@ -75,10 +75,10 @@ static void kobil_close(struct usb_serial_port *port);
 static int  kobil_write(struct tty_struct *tty, struct usb_serial_port *port,
                          const unsigned char *buf, int count);
 static int  kobil_write_room(struct tty_struct *tty);
-static int  kobil_ioctl(struct tty_struct *tty, struct file *file,
+static int  kobil_ioctl(struct tty_struct *tty,
                         unsigned int cmd, unsigned long arg);
-static int  kobil_tiocmget(struct tty_struct *tty, struct file *file);
-static int  kobil_tiocmset(struct tty_struct *tty, struct file *file,
+static int  kobil_tiocmget(struct tty_struct *tty);
+static int  kobil_tiocmset(struct tty_struct *tty,
                            unsigned int set, unsigned int clear);
 static void kobil_read_int_callback(struct urb *urb);
 static void kobil_write_callback(struct urb *purb);
@@ -372,7 +372,7 @@ static void kobil_read_int_callback(struct urb *urb)
         }
 
         tty = tty_port_tty_get(&port->port);
-        if (urb->actual_length) {
+        if (tty && urb->actual_length) {
 
                 /* BEGIN DEBUG */
                 /*
@@ -504,7 +504,7 @@ static int kobil_write_room(struct tty_struct *tty)
 }
 
 
-static int kobil_tiocmget(struct tty_struct *tty, struct file *file)
+static int kobil_tiocmget(struct tty_struct *tty)
 {
         struct usb_serial_port *port = tty->driver_data;
         struct kobil_private *priv;
@@ -544,7 +544,7 @@ static int kobil_tiocmget(struct tty_struct *tty, struct file *file)
         return result;
 }
 
-static int kobil_tiocmset(struct tty_struct *tty, struct file *file,
+static int kobil_tiocmset(struct tty_struct *tty,
                            unsigned int set, unsigned int clear)
 {
         struct usb_serial_port *port = tty->driver_data;
@@ -668,7 +668,7 @@ static void kobil_set_termios(struct tty_struct *tty,
                 );
 }
 
-static int kobil_ioctl(struct tty_struct *tty, struct file *file,
+static int kobil_ioctl(struct tty_struct *tty,
                                         unsigned int cmd, unsigned long arg)
 {
         struct usb_serial_port *port = tty->driver_data;
diff --git a/drivers/usb/serial/mct_u232.c b/drivers/usb/serial/mct_u232.c
index 7aa01b95b1d4..ba0d28727ccb 100644
--- a/drivers/usb/serial/mct_u232.c
+++ b/drivers/usb/serial/mct_u232.c
@@ -78,6 +78,8 @@
 #include <asm/unaligned.h>
 #include <linux/usb.h>
 #include <linux/usb/serial.h>
+#include <linux/serial.h>
+#include <linux/ioctl.h>
 #include "mct_u232.h"
 
 /*
@@ -101,9 +103,13 @@ static void mct_u232_read_int_callback(struct urb *urb);
 static void mct_u232_set_termios(struct tty_struct *tty,
                         struct usb_serial_port *port, struct ktermios *old);
 static void mct_u232_break_ctl(struct tty_struct *tty, int break_state);
-static int  mct_u232_tiocmget(struct tty_struct *tty, struct file *file);
-static int  mct_u232_tiocmset(struct tty_struct *tty, struct file *file,
+static int  mct_u232_tiocmget(struct tty_struct *tty);
+static int  mct_u232_tiocmset(struct tty_struct *tty,
                         unsigned int set, unsigned int clear);
+static int  mct_u232_ioctl(struct tty_struct *tty,
+                        unsigned int cmd, unsigned long arg);
+static int  mct_u232_get_icount(struct tty_struct *tty,
+                        struct serial_icounter_struct *icount);
 static void mct_u232_throttle(struct tty_struct *tty);
 static void mct_u232_unthrottle(struct tty_struct *tty);
 
@@ -150,9 +156,10 @@ static struct usb_serial_driver mct_u232_device = {
         .tiocmset =          mct_u232_tiocmset,
         .attach =            mct_u232_startup,
         .release =           mct_u232_release,
+        .ioctl =             mct_u232_ioctl,
+        .get_icount =        mct_u232_get_icount,
 };
 
-
 struct mct_u232_private {
         spinlock_t lock;
         unsigned int         control_state; /* Modem Line Setting (TIOCM) */
@@ -160,6 +167,9 @@ struct mct_u232_private {
         unsigned char        last_lsr;      /* Line Status Register */
         unsigned char        last_msr;      /* Modem Status Register */
         unsigned int         rx_flags;      /* Throttling flags */
+        struct async_icount  icount;
+        wait_queue_head_t    msr_wait;  /* for handling sleeping while waiting
+                                                for msr change to happen */
 };
 
 #define THROTTLED               0x01
@@ -386,6 +396,20 @@ static int mct_u232_get_modem_stat(struct usb_serial *serial,
         return rc;
 } /* mct_u232_get_modem_stat */
 
+static void mct_u232_msr_to_icount(struct async_icount *icount,
+                                                unsigned char msr)
+{
+        /* Translate Control Line states */
+        if (msr & MCT_U232_MSR_DDSR)
+                icount->dsr++;
+        if (msr & MCT_U232_MSR_DCTS)
+                icount->cts++;
+        if (msr & MCT_U232_MSR_DRI)
+                icount->rng++;
+        if (msr & MCT_U232_MSR_DCD)
+                icount->dcd++;
+} /* mct_u232_msr_to_icount */
+
 static void mct_u232_msr_to_state(unsigned int *control_state,
                                                 unsigned char msr)
 {
@@ -422,6 +446,7 @@ static int mct_u232_startup(struct usb_serial *serial)
         if (!priv)
                 return -ENOMEM;
         spin_lock_init(&priv->lock);
+        init_waitqueue_head(&priv->msr_wait);
         usb_set_serial_port_data(serial->port[0], priv);
 
         init_waitqueue_head(&serial->port[0]->write_wait);
@@ -549,9 +574,12 @@ static void mct_u232_close(struct usb_serial_port *port)
 {
         dbg("%s port %d", __func__, port->number);
 
-        usb_serial_generic_close(port);
-        if (port->serial->dev)
+        if (port->serial->dev) {
+                /* shutdown our urbs */
+                usb_kill_urb(port->write_urb);
+                usb_kill_urb(port->read_urb);
                 usb_kill_urb(port->interrupt_in_urb);
+        }
 } /* mct_u232_close */
 
 
@@ -618,6 +646,8 @@ static void mct_u232_read_int_callback(struct urb *urb)
         /* Record Control Line states */
         mct_u232_msr_to_state(&priv->control_state, priv->last_msr);
 
+        mct_u232_msr_to_icount(&priv->icount, priv->last_msr);
+
 #if 0
         /* Not yet handled. See belkin_sa.c for further information */
         /* Now to report any errors */
@@ -644,6 +674,7 @@ static void mct_u232_read_int_callback(struct urb *urb)
                 tty_kref_put(tty);
         }
 #endif
+        wake_up_interruptible(&priv->msr_wait);
         spin_unlock_irqrestore(&priv->lock, flags);
 exit:
         retval = usb_submit_urb(urb, GFP_ATOMIC);
@@ -759,7 +790,7 @@ static void mct_u232_break_ctl(struct tty_struct *tty, int break_state)
 } /* mct_u232_break_ctl */
 
 
-static int mct_u232_tiocmget(struct tty_struct *tty, struct file *file)
+static int mct_u232_tiocmget(struct tty_struct *tty)
 {
         struct usb_serial_port *port = tty->driver_data;
         struct mct_u232_private *priv = usb_get_serial_port_data(port);
@@ -775,7 +806,7 @@ static int mct_u232_tiocmget(struct tty_struct *tty, struct file *file)
         return control_state;
 }
 
-static int mct_u232_tiocmset(struct tty_struct *tty, struct file *file,
+static int mct_u232_tiocmset(struct tty_struct *tty,
                               unsigned int set, unsigned int clear)
 {
         struct usb_serial_port *port = tty->driver_data;
@@ -823,7 +854,6 @@ static void mct_u232_throttle(struct tty_struct *tty)
         }
 }
 
-
 static void mct_u232_unthrottle(struct tty_struct *tty)
 {
         struct usb_serial_port *port = tty->driver_data;
@@ -844,6 +874,82 @@ static void mct_u232_unthrottle(struct tty_struct *tty)
         }
 }
 
+static int  mct_u232_ioctl(struct tty_struct *tty,
+                        unsigned int cmd, unsigned long arg)
+{
+        DEFINE_WAIT(wait);
+        struct usb_serial_port *port = tty->driver_data;
+        struct mct_u232_private *mct_u232_port = usb_get_serial_port_data(port);
+        struct async_icount cnow, cprev;
+        unsigned long flags;
+
+        dbg("%s - port %d, cmd = 0x%x", __func__, port->number, cmd);
+
+        switch (cmd) {
+
+        case TIOCMIWAIT:
+
+                dbg("%s (%d) TIOCMIWAIT", __func__,  port->number);
+
+                spin_lock_irqsave(&mct_u232_port->lock, flags);
+                cprev = mct_u232_port->icount;
+                spin_unlock_irqrestore(&mct_u232_port->lock, flags);
+                for ( ; ; ) {
+                        prepare_to_wait(&mct_u232_port->msr_wait,
+                                        &wait, TASK_INTERRUPTIBLE);
+                        schedule();
+                        finish_wait(&mct_u232_port->msr_wait, &wait);
+                        /* see if a signal did it */
+                        if (signal_pending(current))
+                                return -ERESTARTSYS;
+                        spin_lock_irqsave(&mct_u232_port->lock, flags);
+                        cnow = mct_u232_port->icount;
+                        spin_unlock_irqrestore(&mct_u232_port->lock, flags);
+                        if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
+                            cnow.dcd == cprev.dcd && cnow.cts == cprev.cts)
+                                return -EIO; /* no change => error */
+                        if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
+                            ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
+                            ((arg & TIOCM_CD)  && (cnow.dcd != cprev.dcd)) ||
+                            ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) {
+                                return 0;
+                        }
+                        cprev = cnow;
+                }
+
+        }
+        return -ENOIOCTLCMD;
+}
+
+static int  mct_u232_get_icount(struct tty_struct *tty,
+                        struct serial_icounter_struct *icount)
+{
+        struct usb_serial_port *port = tty->driver_data;
+        struct mct_u232_private *mct_u232_port = usb_get_serial_port_data(port);
+        struct async_icount *ic = &mct_u232_port->icount;
+        unsigned long flags;
+
+        spin_lock_irqsave(&mct_u232_port->lock, flags);
+
+        icount->cts = ic->cts;
+        icount->dsr = ic->dsr;
+        icount->rng = ic->rng;
+        icount->dcd = ic->dcd;
+        icount->rx = ic->rx;
+        icount->tx = ic->tx;
+        icount->frame = ic->frame;
+        icount->overrun = ic->overrun;
+        icount->parity = ic->parity;
+        icount->brk = ic->brk;
+        icount->buf_overrun = ic->buf_overrun;
+
+        spin_unlock_irqrestore(&mct_u232_port->lock, flags);
+
+        dbg("%s (%d) TIOCGICOUNT RX=%d, TX=%d",
+                __func__,  port->number, icount->rx, icount->tx);
+        return 0;
+}
+
 static int __init mct_u232_init(void)
 {
         int retval;
diff --git a/drivers/usb/serial/mct_u232.h b/drivers/usb/serial/mct_u232.h
index 3a3f5e6b8f96..d325bb8cb583 100644
--- a/drivers/usb/serial/mct_u232.h
+++ b/drivers/usb/serial/mct_u232.h
@@ -10,10 +10,9 @@
  *
  * This driver is for the device MCT USB-RS232 Converter (25 pin, Model No.
  * U232-P25) from Magic Control Technology Corp. (there is also a 9 pin
- * Model No. U232-P9). See http://www.mct.com.tw/p_u232.html for further
- * information. The properties of this device are listed at the end of this
- * file. This device is available from various distributors. I know Hana,
- * http://www.hana.de and D-Link, http://www.dlink.com/products/usb/dsbs25.
+ * Model No. U232-P9). See http://www.mct.com.tw/products/product_us232.html 
+ * for further information. The properties of this device are listed at the end 
+ * of this file. This device was used in the Dlink DSB-S25.
  *
  * All of the information about the device was acquired by using SniffUSB
  * on Windows98. The technical details of the reverse engineering are
@@ -458,7 +457,7 @@ static int mct_u232_calculate_baud_rate(struct usb_serial *serial,
  * embedded UART.  Exhaustive documentation for these is available at:
  *
  *   http://www.semiconductors.philips.com/pip/p87c52ubaa
- *   http://www.semiconductors.philips.com/pip/pdiusbd12
+ *   http://www.nxp.com/acrobat_download/various/PDIUSBD12_PROGRAMMING_GUIDE.pdf
  *
  * Thanks to Julian Highfield for the pointer to the Philips database.
  *
diff --git a/drivers/usb/serial/mos7720.c b/drivers/usb/serial/mos7720.c
index aa665817a272..40abedbc5943 100644
--- a/drivers/usb/serial/mos7720.c
+++ b/drivers/usb/serial/mos7720.c
@@ -827,7 +827,6 @@ exit:
                 dev_err(&urb->dev->dev,
                         "%s - Error %d submitting control urb\n",
                         __func__, result);
-        return;
 }
 
 /*
@@ -907,7 +906,6 @@ exit:
                 dev_err(&urb->dev->dev,
                         "%s - Error %d submitting control urb\n",
                         __func__, result);
-        return;
 }
 
 /*
@@ -1227,8 +1225,6 @@ static void mos7720_break(struct tty_struct *tty, int break_state)
         mos7720_port->shadowLCR  = data;
         write_mos_reg(serial, port->number - port->serial->minor,
                       LCR, mos7720_port->shadowLCR);
-
-        return;
 }
 
 /*
@@ -1746,7 +1742,6 @@ static void change_port_settings(struct tty_struct *tty,
                         dbg("usb_submit_urb(read bulk) failed, status = %d",
                             status);
         }
-        return;
 }
 
 /*
@@ -1803,7 +1798,6 @@ static void mos7720_set_termios(struct tty_struct *tty,
                         dbg("usb_submit_urb(read bulk) failed, status = %d",
                             status);
         }
-        return;
 }
 
 /*
@@ -1839,7 +1833,7 @@ static int get_lsr_info(struct tty_struct *tty,
         return 0;
 }
 
-static int mos7720_tiocmget(struct tty_struct *tty, struct file *file)
+static int mos7720_tiocmget(struct tty_struct *tty)
 {
         struct usb_serial_port *port = tty->driver_data;
         struct moschip_port *mos7720_port = usb_get_serial_port_data(port);
@@ -1864,14 +1858,14 @@ static int mos7720_tiocmget(struct tty_struct *tty, struct file *file)
         return result;
 }
 
-static int mos7720_tiocmset(struct tty_struct *tty, struct file *file,
+static int mos7720_tiocmset(struct tty_struct *tty,
                             unsigned int set, unsigned int clear)
 {
         struct usb_serial_port *port = tty->driver_data;
         struct moschip_port *mos7720_port = usb_get_serial_port_data(port);
         unsigned int mcr ;
         dbg("%s - port %d", __func__, port->number);
-        dbg("he was at tiocmget");
+        dbg("he was at tiocmset");
 
         mcr = mos7720_port->shadowMCR;
 
@@ -1896,10 +1890,37 @@ static int mos7720_tiocmset(struct tty_struct *tty, struct file *file,
         return 0;
 }
 
+static int mos7720_get_icount(struct tty_struct *tty,
+                                struct serial_icounter_struct *icount)
+{
+        struct usb_serial_port *port = tty->driver_data;
+        struct moschip_port *mos7720_port;
+        struct async_icount cnow;
+
+        mos7720_port = usb_get_serial_port_data(port);
+        cnow = mos7720_port->icount;
+
+        icount->cts = cnow.cts;
+        icount->dsr = cnow.dsr;
+        icount->rng = cnow.rng;
+        icount->dcd = cnow.dcd;
+        icount->rx = cnow.rx;
+        icount->tx = cnow.tx;
+        icount->frame = cnow.frame;
+        icount->overrun = cnow.overrun;
+        icount->parity = cnow.parity;
+        icount->brk = cnow.brk;
+        icount->buf_overrun = cnow.buf_overrun;
+
+        dbg("%s (%d) TIOCGICOUNT RX=%d, TX=%d", __func__,
+                port->number, icount->rx, icount->tx);
+        return 0;
+}
+
 static int set_modem_info(struct moschip_port *mos7720_port, unsigned int cmd,
                           unsigned int __user *value)
 {
-        unsigned int mcr ;
+        unsigned int mcr;
         unsigned int arg;
 
         struct usb_serial_port *port;
@@ -1966,14 +1987,13 @@ static int get_serial_info(struct moschip_port *mos7720_port,
         return 0;
 }
 
-static int mos7720_ioctl(struct tty_struct *tty, struct file *file,
+static int mos7720_ioctl(struct tty_struct *tty,
                          unsigned int cmd, unsigned long arg)
 {
         struct usb_serial_port *port = tty->driver_data;
         struct moschip_port *mos7720_port;
         struct async_icount cnow;
         struct async_icount cprev;
-        struct serial_icounter_struct icount;
 
         mos7720_port = usb_get_serial_port_data(port);
         if (mos7720_port == NULL)
@@ -2021,29 +2041,6 @@ static int mos7720_ioctl(struct tty_struct *tty, struct file *file,
                 }
                 /* NOTREACHED */
                 break;
-
-        case TIOCGICOUNT:
-                cnow = mos7720_port->icount;
-
-                memset(&icount, 0, sizeof(struct serial_icounter_struct));
-
-                icount.cts = cnow.cts;
-                icount.dsr = cnow.dsr;
-                icount.rng = cnow.rng;
-                icount.dcd = cnow.dcd;
-                icount.rx = cnow.rx;
-                icount.tx = cnow.tx;
-                icount.frame = cnow.frame;
-                icount.overrun = cnow.overrun;
-                icount.parity = cnow.parity;
-                icount.brk = cnow.brk;
-                icount.buf_overrun = cnow.buf_overrun;
-
-                dbg("%s (%d) TIOCGICOUNT RX=%d, TX=%d", __func__,
-                    port->number, icount.rx, icount.tx);
-                if (copy_to_user((void __user *)arg, &icount, sizeof(icount)))
-                        return -EFAULT;
-                return 0;
         }
 
         return -ENOIOCTLCMD;
@@ -2055,7 +2052,7 @@ static int mos7720_startup(struct usb_serial *serial)
         struct usb_device *dev;
         int i;
         char data;
-        u16 product = le16_to_cpu(serial->dev->descriptor.idProduct);
+        u16 product;
         int ret_val;
 
         dbg("%s: Entering ..........", __func__);
@@ -2065,6 +2062,7 @@ static int mos7720_startup(struct usb_serial *serial)
                 return -ENODEV;
         }
 
+        product = le16_to_cpu(serial->dev->descriptor.idProduct);
         dev = serial->dev;
 
         /*
@@ -2212,6 +2210,7 @@ static struct usb_serial_driver moschip7720_2port_driver = {
         .ioctl                  = mos7720_ioctl,
         .tiocmget               = mos7720_tiocmget,
         .tiocmset               = mos7720_tiocmset,
+        .get_icount             = mos7720_get_icount,
         .set_termios            = mos7720_set_termios,
         .write                  = mos7720_write,
         .write_room             = mos7720_write_room,
diff --git a/drivers/usb/serial/mos7840.c b/drivers/usb/serial/mos7840.c
index 1a42bc213799..7b50aa122752 100644
--- a/drivers/usb/serial/mos7840.c
+++ b/drivers/usb/serial/mos7840.c
@@ -1367,8 +1367,6 @@ static void mos7840_break(struct tty_struct *tty, int break_state)
             mos7840_port->shadowLCR);
         mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER,
                              mos7840_port->shadowLCR);
-
-        return;
 }
 
 /*****************************************************************************
@@ -1599,8 +1597,6 @@ static void mos7840_throttle(struct tty_struct *tty)
                 if (status < 0)
                         return;
         }
-
-        return;
 }
 
 /*****************************************************************************
@@ -1648,7 +1644,7 @@ static void mos7840_unthrottle(struct tty_struct *tty)
         }
 }
 
-static int mos7840_tiocmget(struct tty_struct *tty, struct file *file)
+static int mos7840_tiocmget(struct tty_struct *tty)
 {
         struct usb_serial_port *port = tty->driver_data;
         struct moschip_port *mos7840_port;
@@ -1678,7 +1674,7 @@ static int mos7840_tiocmget(struct tty_struct *tty, struct file *file)
         return result;
 }
 
-static int mos7840_tiocmset(struct tty_struct *tty, struct file *file,
+static int mos7840_tiocmset(struct tty_struct *tty,
                             unsigned int set, unsigned int clear)
 {
         struct usb_serial_port *port = tty->driver_data;
@@ -2075,8 +2071,6 @@ static void mos7840_change_port_settings(struct tty_struct *tty,
         mos7840_port->delta_msr_cond = 1;
         dbg("mos7840_change_port_settings mos7840_port->shadowLCR is End %x",
             mos7840_port->shadowLCR);
-
-        return;
 }
 
 /*****************************************************************************
@@ -2145,7 +2139,6 @@ static void mos7840_set_termios(struct tty_struct *tty,
                         mos7840_port->read_urb_busy = false;
                 }
         }
-        return;
 }
 
 /*****************************************************************************
@@ -2209,12 +2202,40 @@ static int mos7840_get_serial_info(struct moschip_port *mos7840_port,
         return 0;
 }
 
+static int mos7840_get_icount(struct tty_struct *tty,
+                        struct serial_icounter_struct *icount)
+{
+        struct usb_serial_port *port = tty->driver_data;
+        struct moschip_port *mos7840_port;
+        struct async_icount cnow;
+
+        mos7840_port = mos7840_get_port_private(port);
+        cnow = mos7840_port->icount;
+
+        smp_rmb();
+        icount->cts = cnow.cts;
+        icount->dsr = cnow.dsr;
+        icount->rng = cnow.rng;
+        icount->dcd = cnow.dcd;
+        icount->rx = cnow.rx;
+        icount->tx = cnow.tx;
+        icount->frame = cnow.frame;
+        icount->overrun = cnow.overrun;
+        icount->parity = cnow.parity;
+        icount->brk = cnow.brk;
+        icount->buf_overrun = cnow.buf_overrun;
+
+        dbg("%s (%d) TIOCGICOUNT RX=%d, TX=%d", __func__,
+                port->number, icount->rx, icount->tx);
+        return 0;
+}
+
 /*****************************************************************************
  * SerialIoctl
  *      this function handles any ioctl calls to the driver
  *****************************************************************************/
 
-static int mos7840_ioctl(struct tty_struct *tty, struct file *file,
+static int mos7840_ioctl(struct tty_struct *tty,
                          unsigned int cmd, unsigned long arg)
 {
         struct usb_serial_port *port = tty->driver_data;
@@ -2223,7 +2244,6 @@ static int mos7840_ioctl(struct tty_struct *tty, struct file *file,
 
         struct async_icount cnow;
         struct async_icount cprev;
-        struct serial_icounter_struct icount;
 
         if (mos7840_port_paranoia_check(port, __func__)) {
                 dbg("%s", "Invalid port");
@@ -2282,29 +2302,6 @@ static int mos7840_ioctl(struct tty_struct *tty, struct file *file,
                 /* NOTREACHED */
                 break;
 
-        case TIOCGICOUNT:
-                cnow = mos7840_port->icount;
-                smp_rmb();
-
-                memset(&icount, 0, sizeof(struct serial_icounter_struct));
-
-                icount.cts = cnow.cts;
-                icount.dsr = cnow.dsr;
-                icount.rng = cnow.rng;
-                icount.dcd = cnow.dcd;
-                icount.rx = cnow.rx;
-                icount.tx = cnow.tx;
-                icount.frame = cnow.frame;
-                icount.overrun = cnow.overrun;
-                icount.parity = cnow.parity;
-                icount.brk = cnow.brk;
-                icount.buf_overrun = cnow.buf_overrun;
-
-                dbg("%s (%d) TIOCGICOUNT RX=%d, TX=%d", __func__,
-                    port->number, icount.rx, icount.tx);
-                if (copy_to_user(argp, &icount, sizeof(icount)))
-                        return -EFAULT;
-                return 0;
         default:
                 break;
         }
@@ -2674,6 +2671,7 @@ static struct usb_serial_driver moschip7840_4port_device = {
         .break_ctl = mos7840_break,
         .tiocmget = mos7840_tiocmget,
         .tiocmset = mos7840_tiocmset,
+        .get_icount = mos7840_get_icount,
         .attach = mos7840_startup,
         .disconnect = mos7840_disconnect,
         .release = mos7840_release,
diff --git a/drivers/usb/serial/moto_modem.c b/drivers/usb/serial/moto_modem.c
index cf1718394e18..e2bfecc46402 100644
--- a/drivers/usb/serial/moto_modem.c
+++ b/drivers/usb/serial/moto_modem.c
@@ -25,6 +25,7 @@ static const struct usb_device_id id_table[] = {
         { USB_DEVICE(0x05c6, 0x3197) }, /* unknown Motorola phone */
         { USB_DEVICE(0x0c44, 0x0022) }, /* unknown Mororola phone */
         { USB_DEVICE(0x22b8, 0x2a64) }, /* Motorola KRZR K1m */
+        { USB_DEVICE(0x22b8, 0x2c84) }, /* Motorola VE240 phone */
         { USB_DEVICE(0x22b8, 0x2c64) }, /* Motorola V950 phone */
         { },
 };
@@ -44,6 +45,7 @@ static struct usb_serial_driver moto_device = {
                 .name =         "moto-modem",
         },
         .id_table =             id_table,
+        .usb_driver =           &moto_driver,
         .num_ports =            1,
 };
 
diff --git a/drivers/usb/serial/omninet.c b/drivers/usb/serial/omninet.c
index 89c724c0ac0a..60f38d5e64fc 100644
--- a/drivers/usb/serial/omninet.c
+++ b/drivers/usb/serial/omninet.c
@@ -246,8 +246,6 @@ static void omninet_read_bulk_callback(struct urb *urb)
                 dev_err(&port->dev,
                         "%s - failed resubmitting read urb, error %d\n",
                         __func__, result);
-
-        return;
 }
 
 static int omninet_write(struct tty_struct *tty, struct usb_serial_port *port,
diff --git a/drivers/usb/serial/opticon.c b/drivers/usb/serial/opticon.c
index ed01f3b2de8c..96423f3c8ef3 100644
--- a/drivers/usb/serial/opticon.c
+++ b/drivers/usb/serial/opticon.c
@@ -1,6 +1,7 @@
 /*
  * Opticon USB barcode to serial driver
  *
+ * Copyright (C) 2011 Martin Jansen <martin.jansen@opticon.com>
  * Copyright (C) 2008 - 2009 Greg Kroah-Hartman <gregkh@suse.de>
  * Copyright (C) 2008 - 2009 Novell Inc.
  *
@@ -21,6 +22,16 @@
 #include <linux/usb/serial.h>
 #include <linux/uaccess.h>
 
+#define CONTROL_RTS                     0x02
+#define RESEND_CTS_STATE        0x03
+
+/* max number of write urbs in flight */
+#define URB_UPPER_LIMIT 8
+
+/* This driver works for the Opticon 1D barcode reader
+ * an examples of 1D barcode types are EAN, UPC, Code39, IATA etc.. */
+#define DRIVER_DESC     "Opticon USB barcode to serial driver (1D)"
+
 static int debug;
 
 static const struct usb_device_id id_table[] = {
@@ -42,13 +53,13 @@ struct opticon_private {
         bool throttled;
         bool actually_throttled;
         bool rts;
+        bool cts;
         int outstanding_urbs;
 };
 
-/* max number of write urbs in flight */
-#define URB_UPPER_LIMIT 4
 
-static void opticon_bulk_callback(struct urb *urb)
+
+static void opticon_read_bulk_callback(struct urb *urb)
 {
         struct opticon_private *priv = urb->context;
         unsigned char *data = urb->transfer_buffer;
@@ -57,6 +68,7 @@ static void opticon_bulk_callback(struct urb *urb)
         struct tty_struct *tty;
         int result;
         int data_length;
+        unsigned long flags;
 
         dbg("%s - port %d", __func__, port->number);
 
@@ -87,31 +99,34 @@ static void opticon_bulk_callback(struct urb *urb)
                  * Data from the device comes with a 2 byte header:
                  *
                  * <0x00><0x00>data...
-                 *      This is real data to be sent to the tty layer
+                 *      This is real data to be sent to the tty layer
                  * <0x00><0x01)level
-                 *      This is a RTS level change, the third byte is the RTS
-                 *      value (0 for low, 1 for high).
+                 *      This is a CTS level change, the third byte is the CTS
+                 *      value (0 for low, 1 for high).
                  */
                 if ((data[0] == 0x00) && (data[1] == 0x00)) {
                         /* real data, send it to the tty layer */
                         tty = tty_port_tty_get(&port->port);
                         if (tty) {
-                                tty_insert_flip_string(tty, data,
-                                                               data_length);
+                                tty_insert_flip_string(tty, data + 2,
+                                                       data_length);
                                 tty_flip_buffer_push(tty);
                                 tty_kref_put(tty);
                         }
                 } else {
                         if ((data[0] == 0x00) && (data[1] == 0x01)) {
+                                spin_lock_irqsave(&priv->lock, flags);
+                                /* CTS status information package */
                                 if (data[2] == 0x00)
-                                        priv->rts = false;
+                                        priv->cts = false;
                                 else
-                                        priv->rts = true;
+                                        priv->cts = true;
+                                spin_unlock_irqrestore(&priv->lock, flags);
                         } else {
-                        dev_dbg(&priv->udev->dev,
-                                "Unknown data packet received from the device:"
-                                " %2x %2x\n",
-                                data[0], data[1]);
+                                dev_dbg(&priv->udev->dev,
+                                        "Unknown data packet received from the device:"
+                                        " %2x %2x\n",
+                                        data[0], data[1]);
                         }
                 }
         } else {
@@ -129,8 +144,8 @@ exit:
                                   usb_rcvbulkpipe(priv->udev,
                                                   priv->bulk_address),
                                   priv->bulk_in_buffer, priv->buffer_size,
-                                  opticon_bulk_callback, priv);
-                result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
+                                  opticon_read_bulk_callback, priv);
+                result = usb_submit_urb(priv->bulk_read_urb, GFP_ATOMIC);
                 if (result)
                         dev_err(&port->dev,
                             "%s - failed resubmitting read urb, error %d\n",
@@ -140,6 +155,24 @@ exit:
         spin_unlock(&priv->lock);
 }
 
+static int send_control_msg(struct usb_serial_port *port, u8 requesttype,
+                                u8 val)
+{
+        struct usb_serial *serial = port->serial;
+        int retval;
+        u8 buffer[2];
+
+        buffer[0] = val;
+        /* Send the message to the vendor control endpoint
+         * of the connected device */
+        retval = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
+                                requesttype,
+                                USB_DIR_OUT|USB_TYPE_VENDOR|USB_RECIP_INTERFACE,
+                                0, 0, buffer, 1, 0);
+
+        return retval;
+}
+
 static int opticon_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
         struct opticon_private *priv = usb_get_serial_data(port->serial);
@@ -152,19 +185,30 @@ static int opticon_open(struct tty_struct *tty, struct usb_serial_port *port)
         priv->throttled = false;
         priv->actually_throttled = false;
         priv->port = port;
+        priv->rts = false;
         spin_unlock_irqrestore(&priv->lock, flags);
 
-        /* Start reading from the device */
+        /* Clear RTS line */
+        send_control_msg(port, CONTROL_RTS, 0);
+
+        /* Setup the read URB and start reading from the device */
         usb_fill_bulk_urb(priv->bulk_read_urb, priv->udev,
                           usb_rcvbulkpipe(priv->udev,
                                           priv->bulk_address),
                           priv->bulk_in_buffer, priv->buffer_size,
-                          opticon_bulk_callback, priv);
+                          opticon_read_bulk_callback, priv);
+
+        /* clear the halt status of the enpoint */
+        usb_clear_halt(priv->udev, priv->bulk_read_urb->pipe);
+
         result = usb_submit_urb(priv->bulk_read_urb, GFP_KERNEL);
         if (result)
                 dev_err(&port->dev,
                         "%s - failed resubmitting read urb, error %d\n",
                         __func__, result);
+        /* Request CTS line state, sometimes during opening the current
+         * CTS state can be missed. */
+        send_control_msg(port, RESEND_CTS_STATE, 1);
         return result;
 }
 
@@ -178,7 +222,7 @@ static void opticon_close(struct usb_serial_port *port)
         usb_kill_urb(priv->bulk_read_urb);
 }
 
-static void opticon_write_bulk_callback(struct urb *urb)
+static void opticon_write_control_callback(struct urb *urb)
 {
         struct opticon_private *priv = urb->context;
         int status = urb->status;
@@ -187,6 +231,9 @@ static void opticon_write_bulk_callback(struct urb *urb)
         /* free up the transfer buffer, as usb_free_urb() does not do this */
         kfree(urb->transfer_buffer);
 
+        /* setup packet may be set if we're using it for writing */
+        kfree(urb->setup_packet);
+
         if (status)
                 dbg("%s - nonzero write bulk status received: %d",
                     __func__, status);
@@ -207,6 +254,7 @@ static int opticon_write(struct tty_struct *tty, struct usb_serial_port *port,
         unsigned char *buffer;
         unsigned long flags;
         int status;
+        struct usb_ctrlrequest *dr;
 
         dbg("%s - port %d", __func__, port->number);
 
@@ -223,6 +271,7 @@ static int opticon_write(struct tty_struct *tty, struct usb_serial_port *port,
         if (!buffer) {
                 dev_err(&port->dev, "out of memory\n");
                 count = -ENOMEM;
+
                 goto error_no_buffer;
         }
 
@@ -237,16 +286,31 @@ static int opticon_write(struct tty_struct *tty, struct usb_serial_port *port,
 
         usb_serial_debug_data(debug, &port->dev, __func__, count, buffer);
 
-        usb_fill_bulk_urb(urb, serial->dev,
-                          usb_sndbulkpipe(serial->dev,
-                                          port->bulk_out_endpointAddress),
-                          buffer, count, opticon_write_bulk_callback, priv);
+        /* The conncected devices do not have a bulk write endpoint,
+         * to transmit data to de barcode device the control endpoint is used */
+        dr = kmalloc(sizeof(struct usb_ctrlrequest), GFP_NOIO);
+        if (!dr) {
+                dev_err(&port->dev, "out of memory\n");
+                count = -ENOMEM;
+                goto error;
+        }
+
+        dr->bRequestType = USB_TYPE_VENDOR | USB_RECIP_INTERFACE | USB_DIR_OUT;
+        dr->bRequest = 0x01;
+        dr->wValue = 0;
+        dr->wIndex = 0;
+        dr->wLength = cpu_to_le16(count);
+
+        usb_fill_control_urb(urb, serial->dev,
+                usb_sndctrlpipe(serial->dev, 0),
+                (unsigned char *)dr, buffer, count,
+                opticon_write_control_callback, priv);
 
         /* send it down the pipe */
         status = usb_submit_urb(urb, GFP_ATOMIC);
         if (status) {
                 dev_err(&port->dev,
-                   "%s - usb_submit_urb(write bulk) failed with status = %d\n",
+                "%s - usb_submit_urb(write endpoint) failed status = %d\n",
                                                         __func__, status);
                 count = status;
                 goto error;
@@ -330,7 +394,7 @@ static void opticon_unthrottle(struct tty_struct *tty)
         }
 }
 
-static int opticon_tiocmget(struct tty_struct *tty, struct file *file)
+static int opticon_tiocmget(struct tty_struct *tty)
 {
         struct usb_serial_port *port = tty->driver_data;
         struct opticon_private *priv = usb_get_serial_data(port->serial);
@@ -338,16 +402,49 @@ static int opticon_tiocmget(struct tty_struct *tty, struct file *file)
         int result = 0;
 
         dbg("%s - port %d", __func__, port->number);
+        if (!usb_get_intfdata(port->serial->interface))
+                return -ENODEV;
 
         spin_lock_irqsave(&priv->lock, flags);
         if (priv->rts)
-                result = TIOCM_RTS;
+                result |= TIOCM_RTS;
+        if (priv->cts)
+                result |= TIOCM_CTS;
         spin_unlock_irqrestore(&priv->lock, flags);
 
         dbg("%s - %x", __func__, result);
         return result;
 }
 
+static int opticon_tiocmset(struct tty_struct *tty,
+                           unsigned int set, unsigned int clear)
+{
+        struct usb_serial_port *port = tty->driver_data;
+        struct opticon_private *priv = usb_get_serial_data(port->serial);
+        unsigned long flags;
+        bool rts;
+        bool changed = false;
+
+        if (!usb_get_intfdata(port->serial->interface))
+                return -ENODEV;
+        /* We only support RTS so we only handle that */
+        spin_lock_irqsave(&priv->lock, flags);
+
+        rts = priv->rts;
+        if (set & TIOCM_RTS)
+                priv->rts = true;
+        if (clear & TIOCM_RTS)
+                priv->rts = false;
+        changed = rts ^ priv->rts;
+        spin_unlock_irqrestore(&priv->lock, flags);
+
+        if (!changed)
+                return 0;
+
+        /* Send the new RTS state to the connected device */
+        return send_control_msg(port, CONTROL_RTS, !rts);
+}
+
 static int get_serial_info(struct opticon_private *priv,
                            struct serial_struct __user *serial)
 {
@@ -374,7 +471,7 @@ static int get_serial_info(struct opticon_private *priv,
         return 0;
 }
 
-static int opticon_ioctl(struct tty_struct *tty, struct file *file,
+static int opticon_ioctl(struct tty_struct *tty,
                          unsigned int cmd, unsigned long arg)
 {
         struct usb_serial_port *port = tty->driver_data;
@@ -409,6 +506,7 @@ static int opticon_startup(struct usb_serial *serial)
         priv->serial = serial;
         priv->port = serial->port[0];
         priv->udev = serial->dev;
+        priv->outstanding_urbs = 0;     /* Init the outstanding urbs */
 
         /* find our bulk endpoint */
         intf = serial->interface->altsetting;
@@ -434,13 +532,6 @@ static int opticon_startup(struct usb_serial *serial)
 
                 priv->bulk_address = endpoint->bEndpointAddress;
 
-                /* set up our bulk urb */
-                usb_fill_bulk_urb(priv->bulk_read_urb, priv->udev,
-                                  usb_rcvbulkpipe(priv->udev,
-                                                  endpoint->bEndpointAddress),
-                                  priv->bulk_in_buffer, priv->buffer_size,
-                                  opticon_bulk_callback, priv);
-
                 bulk_in_found = true;
                 break;
                 }
@@ -536,6 +627,7 @@ static struct usb_serial_driver opticon_device = {
         .unthrottle =           opticon_unthrottle,
         .ioctl =                opticon_ioctl,
         .tiocmget =             opticon_tiocmget,
+        .tiocmset =             opticon_tiocmset,
 };
 
 static int __init opticon_init(void)
@@ -559,6 +651,7 @@ static void __exit opticon_exit(void)
 
 module_init(opticon_init);
 module_exit(opticon_exit);
+MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE("GPL");
 
 module_param(debug, bool, S_IRUGO | S_IWUSR);
diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
index c46911af282f..60b25d8ea0e2 100644
--- a/drivers/usb/serial/option.c
+++ b/drivers/usb/serial/option.c
@@ -149,6 +149,7 @@ static void option_instat_callback(struct urb *urb);
 #define HUAWEI_PRODUCT_K3765                    0x1465
 #define HUAWEI_PRODUCT_E14AC                    0x14AC
 #define HUAWEI_PRODUCT_ETS1220                  0x1803
+#define HUAWEI_PRODUCT_E353                     0x1506
 
 #define QUANTA_VENDOR_ID                        0x0408
 #define QUANTA_PRODUCT_Q101                     0xEA02
@@ -310,10 +311,6 @@ static void option_instat_callback(struct urb *urb);
 #define ZTE_PRODUCT_AC2726                      0xfff5
 #define ZTE_PRODUCT_AC8710T                     0xffff
 
-/* ZTE PRODUCTS -- alternate vendor ID */
-#define ZTE_VENDOR_ID2                          0x1d6b
-#define ZTE_PRODUCT_MF_330                      0x0002
-
 #define BENQ_VENDOR_ID                          0x04a5
 #define BENQ_PRODUCT_H10                        0x4068
 
@@ -339,11 +336,12 @@ static void option_instat_callback(struct urb *urb);
 #define TOSHIBA_PRODUCT_G450                    0x0d45
 
 #define ALINK_VENDOR_ID                         0x1e0e
+#define ALINK_PRODUCT_PH300                     0x9100
 #define ALINK_PRODUCT_3GU                       0x9200
 
 /* ALCATEL PRODUCTS */
 #define ALCATEL_VENDOR_ID                       0x1bbb
-#define ALCATEL_PRODUCT_X060S                   0x0000
+#define ALCATEL_PRODUCT_X060S_X200              0x0000
 
 #define PIRELLI_VENDOR_ID                       0x1266
 #define PIRELLI_PRODUCT_C100_1                  0x1002
@@ -378,11 +376,23 @@ static void option_instat_callback(struct urb *urb);
  * It seems to contain a Qualcomm QSC6240/6290 chipset            */
 #define FOUR_G_SYSTEMS_PRODUCT_W14              0x9603
 
+/* Zoom */
+#define ZOOM_PRODUCT_4597                       0x9607
+
 /* Haier products */
 #define HAIER_VENDOR_ID                         0x201e
 #define HAIER_PRODUCT_CE100                     0x2009
 
-#define CINTERION_VENDOR_ID                     0x0681
+/* Cinterion (formerly Siemens) products */
+#define SIEMENS_VENDOR_ID                               0x0681
+#define CINTERION_VENDOR_ID                             0x1e2d
+#define CINTERION_PRODUCT_HC25_MDM              0x0047
+#define CINTERION_PRODUCT_HC25_MDMNET   0x0040
+#define CINTERION_PRODUCT_HC28_MDM              0x004C
+#define CINTERION_PRODUCT_HC28_MDMNET   0x004A /* same for HC28J */
+#define CINTERION_PRODUCT_EU3_E                 0x0051
+#define CINTERION_PRODUCT_EU3_P                 0x0052
+#define CINTERION_PRODUCT_PH8                   0x0053
 
 /* Olivetti products */
 #define OLIVETTI_VENDOR_ID                      0x0b3c
@@ -392,6 +402,16 @@ static void option_instat_callback(struct urb *urb);
 #define CELOT_VENDOR_ID                         0x211f
 #define CELOT_PRODUCT_CT680M                    0x6801
 
+/* ONDA Communication vendor id */
+#define ONDA_VENDOR_ID       0x1ee8
+
+/* ONDA MT825UP HSDPA 14.2 modem */
+#define ONDA_MT825UP         0x000b
+
+/* Samsung products */
+#define SAMSUNG_VENDOR_ID                       0x04e8
+#define SAMSUNG_PRODUCT_GT_B3730                0x6889
+
 /* some devices interfaces need special handling due to a number of reasons */
 enum option_blacklist_reason {
                 OPTION_BLACKLIST_NONE = 0,
@@ -412,6 +432,20 @@ static const struct option_blacklist_info four_g_w14_blacklist = {
         .reason = OPTION_BLACKLIST_SENDSETUP
 };
 
+static const u8 alcatel_x200_no_sendsetup[] = { 0, 1 };
+static const struct option_blacklist_info alcatel_x200_blacklist = {
+        .infolen = ARRAY_SIZE(alcatel_x200_no_sendsetup),
+        .ifaceinfo = alcatel_x200_no_sendsetup,
+        .reason = OPTION_BLACKLIST_SENDSETUP
+};
+
+static const u8 zte_k3765_z_no_sendsetup[] = { 0, 1, 2 };
+static const struct option_blacklist_info zte_k3765_z_blacklist = {
+        .infolen = ARRAY_SIZE(zte_k3765_z_no_sendsetup),
+        .ifaceinfo = zte_k3765_z_no_sendsetup,
+        .reason = OPTION_BLACKLIST_SENDSETUP
+};
+
 static const struct usb_device_id option_ids[] = {
         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COLT) },
         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA) },
@@ -512,7 +546,8 @@ static const struct usb_device_id option_ids[] = {
         { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K4505, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K3765, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_ETS1220, 0xff, 0xff, 0xff) },
-        { USB_DEVICE(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E14AC) },
+        { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E14AC, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E353, 0xff, 0x01, 0x01) },
         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_V640) },
         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_V620) },
         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_V740) },
@@ -609,7 +644,6 @@ static const struct usb_device_id option_ids[] = {
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0004, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0005, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0006, 0xff, 0xff, 0xff) },
-        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0007, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0008, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0009, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x000a, 0xff, 0xff, 0xff) },
@@ -622,6 +656,7 @@ static const struct usb_device_id option_ids[] = {
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0011, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0012, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0013, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0014, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_MF628, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0016, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0017, 0xff, 0xff, 0xff) },
@@ -633,38 +668,53 @@ static const struct usb_device_id option_ids[] = {
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0023, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0024, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0025, 0xff, 0xff, 0xff) },
-        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0026, 0xff, 0xff, 0xff) },
+        /* { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0026, 0xff, 0xff, 0xff) }, */
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0028, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0029, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0030, 0xff, 0xff, 0xff) },
-        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_MF626, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_MF626, 0xff,
+          0xff, 0xff), .driver_info = (kernel_ulong_t)&four_g_w14_blacklist },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0032, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0033, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0034, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0037, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0038, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0039, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0040, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0042, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0043, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0044, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0048, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0049, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0050, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0051, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0052, 0xff, 0xff, 0xff) },
+        /* { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0053, 0xff, 0xff, 0xff) }, */
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0054, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0055, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0056, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0057, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0058, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0059, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0061, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0062, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0063, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0064, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0065, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0066, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0067, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0069, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0070, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0076, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0077, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0078, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0079, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0082, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0083, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0086, 0xff, 0xff, 0xff) },
-        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x2002, 0xff, 0xff, 0xff) },
-        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x2003, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0087, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0104, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0105, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0106, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0108, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0113, 0xff, 0xff, 0xff) },
@@ -880,11 +930,13 @@ static const struct usb_device_id option_ids[] = {
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0073, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0130, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0141, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x2002, 0xff,
+          0xff, 0xff), .driver_info = (kernel_ulong_t)&zte_k3765_z_blacklist },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x2003, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_CDMA_TECH, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_AC8710, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_AC2726, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_AC8710T, 0xff, 0xff, 0xff) },
-        { USB_DEVICE(ZTE_VENDOR_ID2, ZTE_PRODUCT_MF_330) },
         { USB_DEVICE(BENQ_VENDOR_ID, BENQ_PRODUCT_H10) },
         { USB_DEVICE(DLINK_VENDOR_ID, DLINK_PRODUCT_DWM_652) },
         { USB_DEVICE(ALINK_VENDOR_ID, DLINK_PRODUCT_DWM_652_U5) }, /* Yes, ALINK_VENDOR_ID */
@@ -897,13 +949,17 @@ static const struct usb_device_id option_ids[] = {
         { USB_DEVICE(TOSHIBA_VENDOR_ID, TOSHIBA_PRODUCT_G450) },
         { USB_DEVICE(TOSHIBA_VENDOR_ID, TOSHIBA_PRODUCT_HSDPA_MINICARD ) }, /* Toshiba 3G HSDPA == Novatel Expedite EU870D MiniCard */
         { USB_DEVICE(ALINK_VENDOR_ID, 0x9000) },
+        { USB_DEVICE(ALINK_VENDOR_ID, ALINK_PRODUCT_PH300) },
         { USB_DEVICE_AND_INTERFACE_INFO(ALINK_VENDOR_ID, ALINK_PRODUCT_3GU, 0xff, 0xff, 0xff) },
-        { USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_X060S) },
+        { USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_X060S_X200),
+          .driver_info = (kernel_ulong_t)&alcatel_x200_blacklist
+        },
         { USB_DEVICE(AIRPLUS_VENDOR_ID, AIRPLUS_PRODUCT_MCD650) },
         { USB_DEVICE(TLAYTECH_VENDOR_ID, TLAYTECH_PRODUCT_TEU800) },
         { USB_DEVICE(LONGCHEER_VENDOR_ID, FOUR_G_SYSTEMS_PRODUCT_W14),
           .driver_info = (kernel_ulong_t)&four_g_w14_blacklist
         },
+        { USB_DEVICE(LONGCHEER_VENDOR_ID, ZOOM_PRODUCT_4597) },
         { USB_DEVICE(HAIER_VENDOR_ID, HAIER_PRODUCT_CE100) },
         /* Pirelli  */
         { USB_DEVICE(PIRELLI_VENDOR_ID, PIRELLI_PRODUCT_C100_1)},
@@ -922,9 +978,21 @@ static const struct usb_device_id option_ids[] = {
         { USB_DEVICE(PIRELLI_VENDOR_ID, PIRELLI_PRODUCT_100F) },
         { USB_DEVICE(PIRELLI_VENDOR_ID, PIRELLI_PRODUCT_1011)},
         { USB_DEVICE(PIRELLI_VENDOR_ID, PIRELLI_PRODUCT_1012)},
-        { USB_DEVICE(CINTERION_VENDOR_ID, 0x0047) },
+        /* Cinterion */
+        { USB_DEVICE(CINTERION_VENDOR_ID, CINTERION_PRODUCT_EU3_E) },
+        { USB_DEVICE(CINTERION_VENDOR_ID, CINTERION_PRODUCT_EU3_P) },
+        { USB_DEVICE(CINTERION_VENDOR_ID, CINTERION_PRODUCT_PH8) },
+        { USB_DEVICE(CINTERION_VENDOR_ID, CINTERION_PRODUCT_HC28_MDM) }, 
+        { USB_DEVICE(CINTERION_VENDOR_ID, CINTERION_PRODUCT_HC28_MDMNET) },
+        { USB_DEVICE(SIEMENS_VENDOR_ID, CINTERION_PRODUCT_HC25_MDM) },
+        { USB_DEVICE(SIEMENS_VENDOR_ID, CINTERION_PRODUCT_HC25_MDMNET) },
+        { USB_DEVICE(SIEMENS_VENDOR_ID, CINTERION_PRODUCT_HC28_MDM) }, /* HC28 enumerates with Siemens or Cinterion VID depending on FW revision */
+        { USB_DEVICE(SIEMENS_VENDOR_ID, CINTERION_PRODUCT_HC28_MDMNET) },
+
         { USB_DEVICE(OLIVETTI_VENDOR_ID, OLIVETTI_PRODUCT_OLICARD100) },
         { USB_DEVICE(CELOT_VENDOR_ID, CELOT_PRODUCT_CT680M) }, /* CT-650 CDMA 450 1xEVDO modem */
+        { USB_DEVICE(ONDA_VENDOR_ID, ONDA_MT825UP) }, /* ONDA MT825UP modem */
+        { USB_DEVICE_AND_INTERFACE_INFO(SAMSUNG_VENDOR_ID, SAMSUNG_PRODUCT_GT_B3730, USB_CLASS_CDC_DATA, 0x00, 0x00) }, /* Samsung GT-B3730 LTE USB modem.*/
         { } /* Terminating entry */
 };
 MODULE_DEVICE_TABLE(usb, option_ids);
@@ -965,6 +1033,7 @@ static struct usb_serial_driver option_1port_device = {
         .set_termios       = usb_wwan_set_termios,
         .tiocmget          = usb_wwan_tiocmget,
         .tiocmset          = usb_wwan_tiocmset,
+        .ioctl             = usb_wwan_ioctl,
         .attach            = usb_wwan_startup,
         .disconnect        = usb_wwan_disconnect,
         .release           = usb_wwan_release,
@@ -1060,6 +1129,12 @@ static int option_probe(struct usb_serial *serial,
                 serial->interface->cur_altsetting->desc.bInterfaceNumber == 1)
                 return -ENODEV;
 
+        /* Don't bind network interface on Samsung GT-B3730, it is handled by a separate module */
+        if (serial->dev->descriptor.idVendor == SAMSUNG_VENDOR_ID &&
+                serial->dev->descriptor.idProduct == SAMSUNG_PRODUCT_GT_B3730 &&
+                serial->interface->cur_altsetting->desc.bInterfaceClass != USB_CLASS_CDC_DATA)
+                return -ENODEV;
+
         data = serial->private = kzalloc(sizeof(struct usb_wwan_intf_private), GFP_KERNEL);
 
         if (!data)
diff --git a/drivers/usb/serial/oti6858.c b/drivers/usb/serial/oti6858.c
index e199b0f4f99c..4c29e6c2bda7 100644
--- a/drivers/usb/serial/oti6858.c
+++ b/drivers/usb/serial/oti6858.c
@@ -135,7 +135,7 @@ static void oti6858_close(struct usb_serial_port *port);
 static void oti6858_set_termios(struct tty_struct *tty,
                         struct usb_serial_port *port, struct ktermios *old);
 static void oti6858_init_termios(struct tty_struct *tty);
-static int oti6858_ioctl(struct tty_struct *tty, struct file *file,
+static int oti6858_ioctl(struct tty_struct *tty,
                         unsigned int cmd, unsigned long arg);
 static void oti6858_read_int_callback(struct urb *urb);
 static void oti6858_read_bulk_callback(struct urb *urb);
@@ -144,8 +144,8 @@ static int oti6858_write(struct tty_struct *tty, struct usb_serial_port *port,
                         const unsigned char *buf, int count);
 static int oti6858_write_room(struct tty_struct *tty);
 static int oti6858_chars_in_buffer(struct tty_struct *tty);
-static int oti6858_tiocmget(struct tty_struct *tty, struct file *file);
-static int oti6858_tiocmset(struct tty_struct *tty, struct file *file,
+static int oti6858_tiocmget(struct tty_struct *tty);
+static int oti6858_tiocmset(struct tty_struct *tty,
                                 unsigned int set, unsigned int clear);
 static int oti6858_startup(struct usb_serial *serial);
 static void oti6858_release(struct usb_serial *serial);
@@ -157,6 +157,7 @@ static struct usb_serial_driver oti6858_device = {
                 .name =         "oti6858",
         },
         .id_table =             id_table,
+        .usb_driver =           &oti6858_driver,
         .num_ports =            1,
         .open =                 oti6858_open,
         .close =                oti6858_close,
@@ -613,9 +614,8 @@ static void oti6858_close(struct usb_serial_port *port)
         dbg("%s(): after buf_clear()", __func__);
 
         /* cancel scheduled setup */
-        cancel_delayed_work(&priv->delayed_setup_work);
-        cancel_delayed_work(&priv->delayed_write_work);
-        flush_scheduled_work();
+        cancel_delayed_work_sync(&priv->delayed_setup_work);
+        cancel_delayed_work_sync(&priv->delayed_write_work);
 
         /* shutdown our urbs */
         dbg("%s(): shutting down urbs", __func__);
@@ -624,7 +624,7 @@ static void oti6858_close(struct usb_serial_port *port)
         usb_kill_urb(port->interrupt_in_urb);
 }
 
-static int oti6858_tiocmset(struct tty_struct *tty, struct file *file,
+static int oti6858_tiocmset(struct tty_struct *tty,
                                 unsigned int set, unsigned int clear)
 {
         struct usb_serial_port *port = tty->driver_data;
@@ -657,7 +657,7 @@ static int oti6858_tiocmset(struct tty_struct *tty, struct file *file,
         return 0;
 }
 
-static int oti6858_tiocmget(struct tty_struct *tty, struct file *file)
+static int oti6858_tiocmget(struct tty_struct *tty)
 {
         struct usb_serial_port *port = tty->driver_data;
         struct oti6858_private *priv = usb_get_serial_port_data(port);
@@ -728,7 +728,7 @@ static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
         return 0;
 }
 
-static int oti6858_ioctl(struct tty_struct *tty, struct file *file,
+static int oti6858_ioctl(struct tty_struct *tty,
                         unsigned int cmd, unsigned long arg)
 {
         struct usb_serial_port *port = tty->driver_data;
diff --git a/drivers/usb/serial/pl2303.c b/drivers/usb/serial/pl2303.c
index 8ae4c6cbc38a..30461fcc2206 100644
--- a/drivers/usb/serial/pl2303.c
+++ b/drivers/usb/serial/pl2303.c
@@ -50,6 +50,7 @@ static const struct usb_device_id id_table[] = {
         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MMX) },
         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GPRS) },
         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_HCR331) },
+        { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MOTOROLA) },
         { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID) },
         { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID_RSAQ5) },
         { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID) },
@@ -504,7 +505,7 @@ static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
         return 0;
 }
 
-static int pl2303_tiocmset(struct tty_struct *tty, struct file *file,
+static int pl2303_tiocmset(struct tty_struct *tty,
                            unsigned int set, unsigned int clear)
 {
         struct usb_serial_port *port = tty->driver_data;
@@ -530,7 +531,7 @@ static int pl2303_tiocmset(struct tty_struct *tty, struct file *file,
         return set_control_lines(port->serial->dev, control);
 }
 
-static int pl2303_tiocmget(struct tty_struct *tty, struct file *file)
+static int pl2303_tiocmget(struct tty_struct *tty)
 {
         struct usb_serial_port *port = tty->driver_data;
         struct pl2303_private *priv = usb_get_serial_port_data(port);
@@ -605,7 +606,7 @@ static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
         return 0;
 }
 
-static int pl2303_ioctl(struct tty_struct *tty, struct file *file,
+static int pl2303_ioctl(struct tty_struct *tty,
                         unsigned int cmd, unsigned long arg)
 {
         struct serial_struct ser;
@@ -677,9 +678,11 @@ static void pl2303_update_line_status(struct usb_serial_port *port,
 {
 
         struct pl2303_private *priv = usb_get_serial_port_data(port);
+        struct tty_struct *tty;
         unsigned long flags;
         u8 status_idx = UART_STATE;
         u8 length = UART_STATE + 1;
+        u8 prev_line_status;
         u16 idv, idp;
 
         idv = le16_to_cpu(port->serial->dev->descriptor.idVendor);
@@ -701,11 +704,20 @@ static void pl2303_update_line_status(struct usb_serial_port *port,
 
         /* Save off the uart status for others to look at */
         spin_lock_irqsave(&priv->lock, flags);
+        prev_line_status = priv->line_status;
         priv->line_status = data[status_idx];
         spin_unlock_irqrestore(&priv->lock, flags);
         if (priv->line_status & UART_BREAK_ERROR)
                 usb_serial_handle_break(port);
         wake_up_interruptible(&priv->delta_msr_wait);
+
+        tty = tty_port_tty_get(&port->port);
+        if (!tty)
+                return;
+        if ((priv->line_status ^ prev_line_status) & UART_DCD)
+                usb_serial_handle_dcd_change(port, tty,
+                                priv->line_status & UART_DCD);
+        tty_kref_put(tty);
 }
 
 static void pl2303_read_int_callback(struct urb *urb)
diff --git a/drivers/usb/serial/pl2303.h b/drivers/usb/serial/pl2303.h
index 43eb9bdad422..1b025f75dafd 100644
--- a/drivers/usb/serial/pl2303.h
+++ b/drivers/usb/serial/pl2303.h
@@ -21,6 +21,7 @@
 #define PL2303_PRODUCT_ID_MMX           0x0612
 #define PL2303_PRODUCT_ID_GPRS          0x0609
 #define PL2303_PRODUCT_ID_HCR331        0x331a
+#define PL2303_PRODUCT_ID_MOTOROLA      0x0307
 
 #define ATEN_VENDOR_ID          0x0557
 #define ATEN_VENDOR_ID2         0x0547
diff --git a/drivers/usb/serial/qcaux.c b/drivers/usb/serial/qcaux.c
index 214a3e504292..30b73e68a904 100644
--- a/drivers/usb/serial/qcaux.c
+++ b/drivers/usb/serial/qcaux.c
@@ -36,6 +36,7 @@
 #define UTSTARCOM_PRODUCT_UM175_V1              0x3712
 #define UTSTARCOM_PRODUCT_UM175_V2              0x3714
 #define UTSTARCOM_PRODUCT_UM175_ALLTEL          0x3715
+#define PANTECH_PRODUCT_UML290_VZW              0x3718
 
 /* CMOTECH devices */
 #define CMOTECH_VENDOR_ID                       0x16d8
@@ -66,6 +67,7 @@ static struct usb_device_id id_table[] = {
         { USB_DEVICE_AND_INTERFACE_INFO(LG_VENDOR_ID, LG_PRODUCT_VX4400_6000, 0xff, 0xff, 0x00) },
         { USB_DEVICE_AND_INTERFACE_INFO(SANYO_VENDOR_ID, SANYO_PRODUCT_KATANA_LX, 0xff, 0xff, 0x00) },
         { USB_DEVICE_AND_INTERFACE_INFO(SAMSUNG_VENDOR_ID, SAMSUNG_PRODUCT_U520, 0xff, 0x00, 0x00) },
+        { USB_DEVICE_AND_INTERFACE_INFO(UTSTARCOM_VENDOR_ID, PANTECH_PRODUCT_UML290_VZW, 0xff, 0xff, 0xff) },
         { },
 };
 MODULE_DEVICE_TABLE(usb, id_table);
@@ -84,6 +86,7 @@ static struct usb_serial_driver qcaux_device = {
                 .name =         "qcaux",
         },
         .id_table =             id_table,
+        .usb_driver =           &qcaux_driver,
         .num_ports =            1,
 };
 
diff --git a/drivers/usb/serial/qcserial.c b/drivers/usb/serial/qcserial.c
index cde67cacb2c3..54a9dab1f33b 100644
--- a/drivers/usb/serial/qcserial.c
+++ b/drivers/usb/serial/qcserial.c
@@ -111,13 +111,15 @@ static int qcprobe(struct usb_serial *serial, const struct usb_device_id *id)
         ifnum = intf->desc.bInterfaceNumber;
         dbg("This Interface = %d", ifnum);
 
-        data = serial->private = kzalloc(sizeof(struct usb_wwan_intf_private),
+        data = kzalloc(sizeof(struct usb_wwan_intf_private),
                                          GFP_KERNEL);
         if (!data)
                 return -ENOMEM;
 
         spin_lock_init(&data->susp_lock);
 
+        usb_enable_autosuspend(serial->dev);
+
         switch (nintf) {
         case 1:
                 /* QDL mode */
@@ -132,8 +134,10 @@ static int qcprobe(struct usb_serial *serial, const struct usb_device_id *id)
                     usb_endpoint_is_bulk_out(&intf->endpoint[1].desc)) {
                         dbg("QDL port found");
 
-                        if (serial->interface->num_altsetting == 1)
-                                return 0;
+                        if (serial->interface->num_altsetting == 1) {
+                                retval = 0; /* Success */
+                                break;
+                        }
 
                         retval = usb_set_interface(serial->dev, ifnum, 1);
                         if (retval < 0) {
@@ -143,14 +147,29 @@ static int qcprobe(struct usb_serial *serial, const struct usb_device_id *id)
                                 retval = -ENODEV;
                                 kfree(data);
                         }
-                        return retval;
                 }
                 break;
 
         case 3:
         case 4:
                 /* Composite mode */
-                if (ifnum == 2) {
+                /* ifnum == 0 is a broadband network adapter */
+                if (ifnum == 1) {
+                        /*
+                         * Diagnostics Monitor (serial line 9600 8N1)
+                         * Qualcomm DM protocol
+                         * use "libqcdm" (ModemManager) for communication
+                         */
+                        dbg("Diagnostics Monitor found");
+                        retval = usb_set_interface(serial->dev, ifnum, 0);
+                        if (retval < 0) {
+                                dev_err(&serial->dev->dev,
+                                        "Could not set interface, error %d\n",
+                                        retval);
+                                retval = -ENODEV;
+                                kfree(data);
+                        }
+                } else if (ifnum == 2) {
                         dbg("Modem port found");
                         retval = usb_set_interface(serial->dev, ifnum, 0);
                         if (retval < 0) {
@@ -160,7 +179,21 @@ static int qcprobe(struct usb_serial *serial, const struct usb_device_id *id)
                                 retval = -ENODEV;
                                 kfree(data);
                         }
-                        return retval;
+                } else if (ifnum==3) {
+                        /*
+                         * NMEA (serial line 9600 8N1)
+                         * # echo "\$GPS_START" > /dev/ttyUSBx
+                         * # echo "\$GPS_STOP"  > /dev/ttyUSBx
+                         */
+                        dbg("NMEA GPS interface found");
+                        retval = usb_set_interface(serial->dev, ifnum, 0);
+                        if (retval < 0) {
+                                dev_err(&serial->dev->dev,
+                                        "Could not set interface, error %d\n",
+                                        retval);
+                                retval = -ENODEV;
+                                kfree(data);
+                        }
                 }
                 break;
 
@@ -168,12 +201,27 @@ static int qcprobe(struct usb_serial *serial, const struct usb_device_id *id)
                 dev_err(&serial->dev->dev,
                         "unknown number of interfaces: %d\n", nintf);
                 kfree(data);
-                return -ENODEV;
+                retval = -ENODEV;
         }
 
+        /* Set serial->private if not returning -ENODEV */
+        if (retval != -ENODEV)
+                usb_set_serial_data(serial, data);
         return retval;
 }
 
+static void qc_release(struct usb_serial *serial)
+{
+        struct usb_wwan_intf_private *priv = usb_get_serial_data(serial);
+
+        dbg("%s", __func__);
+
+        /* Call usb_wwan release & free the private data allocated in qcprobe */
+        usb_wwan_release(serial);
+        usb_set_serial_data(serial, NULL);
+        kfree(priv);
+}
+
 static struct usb_serial_driver qcdevice = {
         .driver = {
                 .owner     = THIS_MODULE,
@@ -191,7 +239,7 @@ static struct usb_serial_driver qcdevice = {
         .chars_in_buffer     = usb_wwan_chars_in_buffer,
         .attach              = usb_wwan_startup,
         .disconnect          = usb_wwan_disconnect,
-        .release             = usb_wwan_release,
+        .release             = qc_release,
 #ifdef CONFIG_PM
         .suspend             = usb_wwan_suspend,
         .resume              = usb_wwan_resume,
diff --git a/drivers/usb/serial/siemens_mpi.c b/drivers/usb/serial/siemens_mpi.c
index cb8195cabfde..74cd4ccdb3fc 100644
--- a/drivers/usb/serial/siemens_mpi.c
+++ b/drivers/usb/serial/siemens_mpi.c
@@ -42,6 +42,7 @@ static struct usb_serial_driver siemens_usb_mpi_device = {
                 .name =         "siemens_mpi",
         },
         .id_table =             id_table,
+        .usb_driver =           &siemens_usb_mpi_driver,
         .num_ports =            1,
 };
 
diff --git a/drivers/usb/serial/sierra.c b/drivers/usb/serial/sierra.c
index d47b56e9e8ce..d5d136a53b61 100644
--- a/drivers/usb/serial/sierra.c
+++ b/drivers/usb/serial/sierra.c
@@ -301,6 +301,9 @@ static const struct usb_device_id id_table[] = {
         { USB_DEVICE(0x1199, 0x68A3),   /* Sierra Wireless Direct IP modems */
           .driver_info = (kernel_ulong_t)&direct_ip_interface_blacklist
         },
+        { USB_DEVICE(0x0f3d, 0x68A3),   /* Airprime/Sierra Wireless Direct IP modems */
+          .driver_info = (kernel_ulong_t)&direct_ip_interface_blacklist
+        },
        { USB_DEVICE(0x413C, 0x08133) }, /* Dell Computer Corp. Wireless 5720 VZW Mobile Broadband (EVDO Rev-A) Minicard GPS Port */
 
         { }
@@ -373,7 +376,10 @@ static int sierra_send_setup(struct usb_serial_port *port)
         if (!do_send)
                 return 0;
 
-        usb_autopm_get_interface(serial->interface);
+        retval = usb_autopm_get_interface(serial->interface);
+        if (retval < 0)
+                return retval;
+
         retval = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
                 0x22, 0x21, val, interface, NULL, 0, USB_CTRL_SET_TIMEOUT);
         usb_autopm_put_interface(serial->interface);
@@ -389,7 +395,7 @@ static void sierra_set_termios(struct tty_struct *tty,
         sierra_send_setup(port);
 }
 
-static int sierra_tiocmget(struct tty_struct *tty, struct file *file)
+static int sierra_tiocmget(struct tty_struct *tty)
 {
         struct usb_serial_port *port = tty->driver_data;
         unsigned int value;
@@ -408,7 +414,7 @@ static int sierra_tiocmget(struct tty_struct *tty, struct file *file)
         return value;
 }
 
-static int sierra_tiocmset(struct tty_struct *tty, struct file *file,
+static int sierra_tiocmset(struct tty_struct *tty,
                         unsigned int set, unsigned int clear)
 {
         struct usb_serial_port *port = tty->driver_data;
@@ -620,8 +626,6 @@ static void sierra_indat_callback(struct urb *urb)
                         dev_err(&port->dev, "resubmit read urb failed."
                                 "(%d)\n", err);
         }
-
-        return;
 }
 
 static void sierra_instat_callback(struct urb *urb)
@@ -810,8 +814,12 @@ static void sierra_close(struct usb_serial_port *port)
                 mutex_lock(&serial->disc_mutex);
                 if (!serial->disconnected) {
                         serial->interface->needs_remote_wakeup = 0;
-                        usb_autopm_get_interface(serial->interface);
-                        sierra_send_setup(port);
+                        /* odd error handling due to pm counters */
+                        if (!usb_autopm_get_interface(serial->interface))
+                                sierra_send_setup(port);
+                        else
+                                usb_autopm_get_interface_no_resume(serial->interface);
+                                
                 }
                 mutex_unlock(&serial->disc_mutex);
                 spin_lock_irq(&intfdata->susp_lock);
@@ -864,7 +872,8 @@ static int sierra_open(struct tty_struct *tty, struct usb_serial_port *port)
                 /* get rid of everything as in close */
                 sierra_close(port);
                 /* restore balance for autopm */
-                usb_autopm_put_interface(serial->interface);
+                if (!serial->disconnected)
+                        usb_autopm_put_interface(serial->interface);
                 return err;
         }
         sierra_send_setup(port);
diff --git a/drivers/usb/serial/spcp8x5.c b/drivers/usb/serial/spcp8x5.c
index 329d311a35d9..180ea6c7911c 100644
--- a/drivers/usb/serial/spcp8x5.c
+++ b/drivers/usb/serial/spcp8x5.c
@@ -133,7 +133,7 @@ struct spcp8x5_usb_ctrl_arg {
 
 /* how come ??? */
 #define UART_STATE                      0x08
-#define UART_STATE_TRANSIENT_MASK       0x74
+#define UART_STATE_TRANSIENT_MASK       0x75
 #define UART_DCD                        0x01
 #define UART_DSR                        0x02
 #define UART_BREAK_ERROR                0x04
@@ -441,7 +441,6 @@ static void spcp8x5_set_termios(struct tty_struct *tty,
                 spcp8x5_set_workMode(serial->dev, 0x000a,
                                      SET_WORKING_MODE_U2C, priv->type);
         }
-        return;
 }
 
 /* open the serial port. do some usb system call. set termios and get the line
@@ -526,6 +525,10 @@ static void spcp8x5_process_read_urb(struct urb *urb)
                 /* overrun is special, not associated with a char */
                 if (status & UART_OVERRUN_ERROR)
                         tty_insert_flip_char(tty, 0, TTY_OVERRUN);
+
+                if (status & UART_DCD)
+                        usb_serial_handle_dcd_change(port, tty,
+                                   priv->line_status & MSR_STATUS_LINE_DCD);
         }
 
         tty_insert_flip_string_fixed_flag(tty, data, tty_flag,
@@ -573,7 +576,7 @@ static int spcp8x5_wait_modem_info(struct usb_serial_port *port,
         return 0;
 }
 
-static int spcp8x5_ioctl(struct tty_struct *tty, struct file *file,
+static int spcp8x5_ioctl(struct tty_struct *tty,
                          unsigned int cmd, unsigned long arg)
 {
         struct usb_serial_port *port = tty->driver_data;
@@ -592,7 +595,7 @@ static int spcp8x5_ioctl(struct tty_struct *tty, struct file *file,
         return -ENOIOCTLCMD;
 }
 
-static int spcp8x5_tiocmset(struct tty_struct *tty, struct file *file,
+static int spcp8x5_tiocmset(struct tty_struct *tty,
                             unsigned int set, unsigned int clear)
 {
         struct usb_serial_port *port = tty->driver_data;
@@ -615,7 +618,7 @@ static int spcp8x5_tiocmset(struct tty_struct *tty, struct file *file,
         return spcp8x5_set_ctrlLine(port->serial->dev, control , priv->type);
 }
 
-static int spcp8x5_tiocmget(struct tty_struct *tty, struct file *file)
+static int spcp8x5_tiocmget(struct tty_struct *tty)
 {
         struct usb_serial_port *port = tty->driver_data;
         struct spcp8x5_private *priv = usb_get_serial_port_data(port);
@@ -646,6 +649,7 @@ static struct usb_serial_driver spcp8x5_device = {
                 .name =         "SPCP8x5",
         },
         .id_table               = id_table,
+        .usb_driver             = &spcp8x5_driver,
         .num_ports              = 1,
         .open                   = spcp8x5_open,
         .dtr_rts                = spcp8x5_dtr_rts,
diff --git a/drivers/usb/serial/ssu100.c b/drivers/usb/serial/ssu100.c
index e986002b3844..87362e48796e 100644
--- a/drivers/usb/serial/ssu100.c
+++ b/drivers/usb/serial/ssu100.c
@@ -79,7 +79,6 @@ struct ssu100_port_private {
         u8 shadowLSR;
         u8 shadowMSR;
         wait_queue_head_t delta_msr_wait; /* Used for TIOCMIWAIT */
-        unsigned short max_packet_size;
         struct async_icount icount;
 };
 
@@ -416,12 +415,34 @@ static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
         return 0;
 }
 
-static int ssu100_ioctl(struct tty_struct *tty, struct file *file,
-                    unsigned int cmd, unsigned long arg)
+static int ssu100_get_icount(struct tty_struct *tty,
+                        struct serial_icounter_struct *icount)
 {
         struct usb_serial_port *port = tty->driver_data;
         struct ssu100_port_private *priv = usb_get_serial_port_data(port);
-        void __user *user_arg = (void __user *)arg;
+        struct async_icount cnow = priv->icount;
+
+        icount->cts = cnow.cts;
+        icount->dsr = cnow.dsr;
+        icount->rng = cnow.rng;
+        icount->dcd = cnow.dcd;
+        icount->rx = cnow.rx;
+        icount->tx = cnow.tx;
+        icount->frame = cnow.frame;
+        icount->overrun = cnow.overrun;
+        icount->parity = cnow.parity;
+        icount->brk = cnow.brk;
+        icount->buf_overrun = cnow.buf_overrun;
+
+        return 0;
+}
+
+
+
+static int ssu100_ioctl(struct tty_struct *tty,
+                    unsigned int cmd, unsigned long arg)
+{
+        struct usb_serial_port *port = tty->driver_data;
 
         dbg("%s cmd 0x%04x", __func__, cmd);
 
@@ -433,27 +454,6 @@ static int ssu100_ioctl(struct tty_struct *tty, struct file *file,
         case TIOCMIWAIT:
                 return wait_modem_info(port, arg);
 
-        case TIOCGICOUNT:
-        {
-                struct serial_icounter_struct icount;
-                struct async_icount cnow = priv->icount;
-                memset(&icount, 0, sizeof(icount));
-                icount.cts = cnow.cts;
-                icount.dsr = cnow.dsr;
-                icount.rng = cnow.rng;
-                icount.dcd = cnow.dcd;
-                icount.rx = cnow.rx;
-                icount.tx = cnow.tx;
-                icount.frame = cnow.frame;
-                icount.overrun = cnow.overrun;
-                icount.parity = cnow.parity;
-                icount.brk = cnow.brk;
-                icount.buf_overrun = cnow.buf_overrun;
-                if (copy_to_user(user_arg, &icount, sizeof(icount)))
-                        return -EFAULT;
-                return 0;
-        }
-
         default:
                 break;
         }
@@ -463,36 +463,6 @@ static int ssu100_ioctl(struct tty_struct *tty, struct file *file,
         return -ENOIOCTLCMD;
 }
 
-static void ssu100_set_max_packet_size(struct usb_serial_port *port)
-{
-        struct ssu100_port_private *priv = usb_get_serial_port_data(port);
-        struct usb_serial *serial = port->serial;
-        struct usb_device *udev = serial->dev;
-
-        struct usb_interface *interface = serial->interface;
-        struct usb_endpoint_descriptor *ep_desc = &interface->cur_altsetting->endpoint[1].desc;
-
-        unsigned num_endpoints;
-        int i;
-        unsigned long flags;
-
-        num_endpoints = interface->cur_altsetting->desc.bNumEndpoints;
-        dev_info(&udev->dev, "Number of endpoints %d\n", num_endpoints);
-
-        for (i = 0; i < num_endpoints; i++) {
-                dev_info(&udev->dev, "Endpoint %d MaxPacketSize %d\n", i+1,
-                        interface->cur_altsetting->endpoint[i].desc.wMaxPacketSize);
-                ep_desc = &interface->cur_altsetting->endpoint[i].desc;
-        }
-
-        /* set max packet size based on descriptor */
-        spin_lock_irqsave(&priv->status_lock, flags);
-        priv->max_packet_size = ep_desc->wMaxPacketSize;
-        spin_unlock_irqrestore(&priv->status_lock, flags);
-
-        dev_info(&udev->dev, "Setting MaxPacketSize %d\n", priv->max_packet_size);
-}
-
 static int ssu100_attach(struct usb_serial *serial)
 {
         struct ssu100_port_private *priv;
@@ -510,12 +480,11 @@ static int ssu100_attach(struct usb_serial *serial)
         spin_lock_init(&priv->status_lock);
         init_waitqueue_head(&priv->delta_msr_wait);
         usb_set_serial_port_data(port, priv);
-        ssu100_set_max_packet_size(port);
 
         return ssu100_initdevice(serial->dev);
 }
 
-static int ssu100_tiocmget(struct tty_struct *tty, struct file *file)
+static int ssu100_tiocmget(struct tty_struct *tty)
 {
         struct usb_serial_port *port = tty->driver_data;
         struct usb_device *dev = port->serial->dev;
@@ -548,7 +517,7 @@ mget_out:
         return r;
 }
 
-static int ssu100_tiocmset(struct tty_struct *tty, struct file *file,
+static int ssu100_tiocmset(struct tty_struct *tty,
                            unsigned int set, unsigned int clear)
 {
         struct usb_serial_port *port = tty->driver_data;
@@ -640,13 +609,14 @@ static void ssu100_update_lsr(struct usb_serial_port *port, u8 lsr,
 
 }
 
-static int ssu100_process_packet(struct tty_struct *tty,
-                                 struct usb_serial_port *port,
-                                 struct ssu100_port_private *priv,
-                                 char *packet, int len)
+static int ssu100_process_packet(struct urb *urb,
+                                 struct tty_struct *tty)
 {
-        int i;
+        struct usb_serial_port *port = urb->context;
+        char *packet = (char *)urb->transfer_buffer;
         char flag = TTY_NORMAL;
+        u32 len = urb->actual_length;
+        int i;
         char *ch;
 
         dbg("%s - port %d", __func__, port->number);
@@ -684,12 +654,8 @@ static int ssu100_process_packet(struct tty_struct *tty,
 static void ssu100_process_read_urb(struct urb *urb)
 {
         struct usb_serial_port *port = urb->context;
-        struct ssu100_port_private *priv = usb_get_serial_port_data(port);
-        char *data = (char *)urb->transfer_buffer;
         struct tty_struct *tty;
-        int count = 0;
-        int i;
-        int len;
+        int count;
 
         dbg("%s", __func__);
 
@@ -697,10 +663,7 @@ static void ssu100_process_read_urb(struct urb *urb)
         if (!tty)
                 return;
 
-        for (i = 0; i < urb->actual_length; i += priv->max_packet_size) {
-                len = min_t(int, urb->actual_length - i, priv->max_packet_size);
-                count += ssu100_process_packet(tty, port, priv, &data[i], len);
-        }
+        count = ssu100_process_packet(urb, tty);
 
         if (count)
                 tty_flip_buffer_push(tty);
@@ -716,8 +679,6 @@ static struct usb_serial_driver ssu100_device = {
         .id_table            = id_table,
         .usb_driver          = &ssu100_driver,
         .num_ports           = 1,
-        .bulk_in_size        = 256,
-        .bulk_out_size       = 256,
         .open                = ssu100_open,
         .close               = ssu100_close,
         .attach              = ssu100_attach,
@@ -726,6 +687,7 @@ static struct usb_serial_driver ssu100_device = {
         .process_read_urb    = ssu100_process_read_urb,
         .tiocmget            = ssu100_tiocmget,
         .tiocmset            = ssu100_tiocmset,
+        .get_icount          = ssu100_get_icount,
         .ioctl               = ssu100_ioctl,
         .set_termios         = ssu100_set_termios,
         .disconnect          = usb_serial_generic_disconnect,
diff --git a/drivers/usb/serial/ti_usb_3410_5052.c b/drivers/usb/serial/ti_usb_3410_5052.c
index 90979a1f5311..ea8445689c85 100644
--- a/drivers/usb/serial/ti_usb_3410_5052.c
+++ b/drivers/usb/serial/ti_usb_3410_5052.c
@@ -106,12 +106,14 @@ static int ti_write_room(struct tty_struct *tty);
 static int ti_chars_in_buffer(struct tty_struct *tty);
 static void ti_throttle(struct tty_struct *tty);
 static void ti_unthrottle(struct tty_struct *tty);
-static int ti_ioctl(struct tty_struct *tty, struct file *file,
+static int ti_ioctl(struct tty_struct *tty,
                 unsigned int cmd, unsigned long arg);
+static int ti_get_icount(struct tty_struct *tty,
+                struct serial_icounter_struct *icount);
 static void ti_set_termios(struct tty_struct *tty,
                 struct usb_serial_port *port, struct ktermios *old_termios);
-static int ti_tiocmget(struct tty_struct *tty, struct file *file);
-static int ti_tiocmset(struct tty_struct *tty, struct file *file,
+static int ti_tiocmget(struct tty_struct *tty);
+static int ti_tiocmset(struct tty_struct *tty,
                 unsigned int set, unsigned int clear);
 static void ti_break(struct tty_struct *tty, int break_state);
 static void ti_interrupt_callback(struct urb *urb);
@@ -237,6 +239,7 @@ static struct usb_serial_driver ti_1port_device = {
         .set_termios            = ti_set_termios,
         .tiocmget               = ti_tiocmget,
         .tiocmset               = ti_tiocmset,
+        .get_icount             = ti_get_icount,
         .break_ctl              = ti_break,
         .read_int_callback      = ti_interrupt_callback,
         .read_bulk_callback     = ti_bulk_in_callback,
@@ -265,6 +268,7 @@ static struct usb_serial_driver ti_2port_device = {
         .set_termios            = ti_set_termios,
         .tiocmget               = ti_tiocmget,
         .tiocmset               = ti_tiocmset,
+        .get_icount             = ti_get_icount,
         .break_ctl              = ti_break,
         .read_int_callback      = ti_interrupt_callback,
         .read_bulk_callback     = ti_bulk_in_callback,
@@ -365,9 +369,9 @@ failed_1port:
 
 static void __exit ti_exit(void)
 {
+        usb_deregister(&ti_usb_driver);
         usb_serial_deregister(&ti_1port_device);
         usb_serial_deregister(&ti_2port_device);
-        usb_deregister(&ti_usb_driver);
 }
 
 
@@ -788,8 +792,33 @@ static void ti_unthrottle(struct tty_struct *tty)
         }
 }
 
+static int ti_get_icount(struct tty_struct *tty,
+                struct serial_icounter_struct *icount)
+{
+        struct usb_serial_port *port = tty->driver_data;
+        struct ti_port *tport = usb_get_serial_port_data(port);
+        struct async_icount cnow = tport->tp_icount;
+
+        dbg("%s - (%d) TIOCGICOUNT RX=%d, TX=%d",
+                __func__, port->number,
+                cnow.rx, cnow.tx);
+
+        icount->cts = cnow.cts;
+        icount->dsr = cnow.dsr;
+        icount->rng = cnow.rng;
+        icount->dcd = cnow.dcd;
+        icount->rx = cnow.rx;
+        icount->tx = cnow.tx;
+        icount->frame = cnow.frame;
+        icount->overrun = cnow.overrun;
+        icount->parity = cnow.parity;
+        icount->brk = cnow.brk;
+        icount->buf_overrun = cnow.buf_overrun;
 
-static int ti_ioctl(struct tty_struct *tty, struct file *file,
+        return 0;
+}
+
+static int ti_ioctl(struct tty_struct *tty,
         unsigned int cmd, unsigned long arg)
 {
         struct usb_serial_port *port = tty->driver_data;
@@ -830,14 +859,6 @@ static int ti_ioctl(struct tty_struct *tty, struct file *file,
                         cprev = cnow;
                 }
                 break;
-        case TIOCGICOUNT:
-                dbg("%s - (%d) TIOCGICOUNT RX=%d, TX=%d",
-                                __func__, port->number,
-                                tport->tp_icount.rx, tport->tp_icount.tx);
-                if (copy_to_user((void __user *)arg, &tport->tp_icount,
-                                        sizeof(tport->tp_icount)))
-                        return -EFAULT;
-                return 0;
         }
         return -ENOIOCTLCMD;
 }
@@ -979,7 +1000,7 @@ static void ti_set_termios(struct tty_struct *tty,
 }
 
 
-static int ti_tiocmget(struct tty_struct *tty, struct file *file)
+static int ti_tiocmget(struct tty_struct *tty)
 {
         struct usb_serial_port *port = tty->driver_data;
         struct ti_port *tport = usb_get_serial_port_data(port);
@@ -1012,8 +1033,8 @@ static int ti_tiocmget(struct tty_struct *tty, struct file *file)
 }
 
 
-static int ti_tiocmset(struct tty_struct *tty, struct file *file,
-        unsigned int set, unsigned int clear)
+static int ti_tiocmset(struct tty_struct *tty,
+                                unsigned int set, unsigned int clear)
 {
         struct usb_serial_port *port = tty->driver_data;
         struct ti_port *tport = usb_get_serial_port_data(port);
@@ -1724,6 +1745,7 @@ static int ti_download_firmware(struct ti_device *tdev)
         }
         if (fw_p->size > TI_FIRMWARE_BUF_SIZE) {
                 dev_err(&dev->dev, "%s - firmware too large %zu\n", __func__, fw_p->size);
+                release_firmware(fw_p);
                 return -ENOENT;
         }
 
diff --git a/drivers/usb/serial/usb-serial.c b/drivers/usb/serial/usb-serial.c
index 7a2177c79bde..1c031309ab25 100644
--- a/drivers/usb/serial/usb-serial.c
+++ b/drivers/usb/serial/usb-serial.c
@@ -21,7 +21,6 @@
 #include <linux/errno.h>
 #include <linux/init.h>
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
 #include <linux/tty.h>
 #include <linux/tty_driver.h>
 #include <linux/tty_flip.h>
@@ -52,6 +51,7 @@ static struct usb_driver usb_serial_driver = {
         .suspend =      usb_serial_suspend,
         .resume =       usb_serial_resume,
         .no_dynamic_id =        1,
+        .supports_autosuspend = 1,
 };
 
 /* There is no MODULE_DEVICE_TABLE for usbserial.c.  Instead
@@ -406,7 +406,7 @@ static void serial_unthrottle(struct tty_struct *tty)
                 port->serial->type->unthrottle(tty);
 }
 
-static int serial_ioctl(struct tty_struct *tty, struct file *file,
+static int serial_ioctl(struct tty_struct *tty,
                                         unsigned int cmd, unsigned long arg)
 {
         struct usb_serial_port *port = tty->driver_data;
@@ -417,7 +417,7 @@ static int serial_ioctl(struct tty_struct *tty, struct file *file,
         /* pass on to the driver specific version of this function
            if it is available */
         if (port->serial->type->ioctl) {
-                retval = port->serial->type->ioctl(tty, file, cmd, arg);
+                retval = port->serial->type->ioctl(tty, cmd, arg);
         } else
                 retval = -ENOIOCTLCMD;
         return retval;
@@ -496,18 +496,18 @@ static const struct file_operations serial_proc_fops = {
         .release        = single_release,
 };
 
-static int serial_tiocmget(struct tty_struct *tty, struct file *file)
+static int serial_tiocmget(struct tty_struct *tty)
 {
         struct usb_serial_port *port = tty->driver_data;
 
         dbg("%s - port %d", __func__, port->number);
 
         if (port->serial->type->tiocmget)
-                return port->serial->type->tiocmget(tty, file);
+                return port->serial->type->tiocmget(tty);
         return -EINVAL;
 }
 
-static int serial_tiocmset(struct tty_struct *tty, struct file *file,
+static int serial_tiocmset(struct tty_struct *tty,
                             unsigned int set, unsigned int clear)
 {
         struct usb_serial_port *port = tty->driver_data;
@@ -515,7 +515,19 @@ static int serial_tiocmset(struct tty_struct *tty, struct file *file,
         dbg("%s - port %d", __func__, port->number);
 
         if (port->serial->type->tiocmset)
-                return port->serial->type->tiocmset(tty, file, set, clear);
+                return port->serial->type->tiocmset(tty, set, clear);
+        return -EINVAL;
+}
+
+static int serial_get_icount(struct tty_struct *tty,
+                                struct serial_icounter_struct *icount)
+{
+        struct usb_serial_port *port = tty->driver_data;
+
+        dbg("%s - port %d", __func__, port->number);
+
+        if (port->serial->type->get_icount)
+                return port->serial->type->get_icount(tty, icount);
         return -EINVAL;
 }
 
@@ -899,9 +911,8 @@ int usb_serial_probe(struct usb_interface *interface,
                         dev_err(&interface->dev, "No free urbs available\n");
                         goto probe_error;
                 }
-                buffer_size = serial->type->bulk_in_size;
-                if (!buffer_size)
-                        buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
+                buffer_size = max_t(int, serial->type->bulk_in_size,
+                                le16_to_cpu(endpoint->wMaxPacketSize));
                 port->bulk_in_size = buffer_size;
                 port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
                 port->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
@@ -1195,6 +1206,7 @@ static const struct tty_operations serial_ops = {
         .chars_in_buffer =      serial_chars_in_buffer,
         .tiocmget =             serial_tiocmget,
         .tiocmset =             serial_tiocmset,
+        .get_icount =           serial_get_icount,
         .cleanup =              serial_cleanup,
         .install =              serial_install,
         .proc_fops =            &serial_proc_fops,
@@ -1334,6 +1346,12 @@ int usb_serial_register(struct usb_serial_driver *driver)
 
         if (!driver->description)
                 driver->description = driver->driver.name;
+        if (!driver->usb_driver) {
+                WARN(1, "Serial driver %s has no usb_driver\n",
+                                driver->description);
+                return -EINVAL;
+        }
+        driver->usb_driver->supports_autosuspend = 1;
 
         /* Add this device to our list of devices */
         mutex_lock(&table_lock);
diff --git a/drivers/usb/serial/usb-wwan.h b/drivers/usb/serial/usb-wwan.h
index 2be298a1305b..c47b6ec03063 100644
--- a/drivers/usb/serial/usb-wwan.h
+++ b/drivers/usb/serial/usb-wwan.h
@@ -15,9 +15,11 @@ extern int usb_wwan_write_room(struct tty_struct *tty);
 extern void usb_wwan_set_termios(struct tty_struct *tty,
                                  struct usb_serial_port *port,
                                  struct ktermios *old);
-extern int usb_wwan_tiocmget(struct tty_struct *tty, struct file *file);
-extern int usb_wwan_tiocmset(struct tty_struct *tty, struct file *file,
+extern int usb_wwan_tiocmget(struct tty_struct *tty);
+extern int usb_wwan_tiocmset(struct tty_struct *tty,
                              unsigned int set, unsigned int clear);
+extern int usb_wwan_ioctl(struct tty_struct *tty,
+                          unsigned int cmd, unsigned long arg);
 extern int usb_wwan_send_setup(struct usb_serial_port *port);
 extern int usb_wwan_write(struct tty_struct *tty, struct usb_serial_port *port,
                           const unsigned char *buf, int count);
diff --git a/drivers/usb/serial/usb_debug.c b/drivers/usb/serial/usb_debug.c
index f2ed6a31be77..95a82148ee81 100644
--- a/drivers/usb/serial/usb_debug.c
+++ b/drivers/usb/serial/usb_debug.c
@@ -75,6 +75,7 @@ static struct usb_serial_driver debug_device = {
                 .name =         "debug",
         },
         .id_table =             id_table,
+        .usb_driver =           &debug_driver,
         .num_ports =            1,
         .bulk_out_size =        USB_DEBUG_MAX_PACKET_SIZE,
         .break_ctl =            usb_debug_break_ctl,
diff --git a/drivers/usb/serial/usb_wwan.c b/drivers/usb/serial/usb_wwan.c
index 0c70b4a621bb..e4fad5e643d7 100644
--- a/drivers/usb/serial/usb_wwan.c
+++ b/drivers/usb/serial/usb_wwan.c
@@ -31,8 +31,10 @@
 #include <linux/tty_flip.h>
 #include <linux/module.h>
 #include <linux/bitops.h>
+#include <linux/uaccess.h>
 #include <linux/usb.h>
 #include <linux/usb/serial.h>
+#include <linux/serial.h>
 #include "usb-wwan.h"
 
 static int debug;
@@ -77,7 +79,7 @@ void usb_wwan_set_termios(struct tty_struct *tty,
 }
 EXPORT_SYMBOL(usb_wwan_set_termios);
 
-int usb_wwan_tiocmget(struct tty_struct *tty, struct file *file)
+int usb_wwan_tiocmget(struct tty_struct *tty)
 {
         struct usb_serial_port *port = tty->driver_data;
         unsigned int value;
@@ -96,7 +98,7 @@ int usb_wwan_tiocmget(struct tty_struct *tty, struct file *file)
 }
 EXPORT_SYMBOL(usb_wwan_tiocmget);
 
-int usb_wwan_tiocmset(struct tty_struct *tty, struct file *file,
+int usb_wwan_tiocmset(struct tty_struct *tty,
                       unsigned int set, unsigned int clear)
 {
         struct usb_serial_port *port = tty->driver_data;
@@ -123,6 +125,83 @@ int usb_wwan_tiocmset(struct tty_struct *tty, struct file *file,
 }
 EXPORT_SYMBOL(usb_wwan_tiocmset);
 
+static int get_serial_info(struct usb_serial_port *port,
+                           struct serial_struct __user *retinfo)
+{
+        struct serial_struct tmp;
+
+        if (!retinfo)
+                return -EFAULT;
+
+        memset(&tmp, 0, sizeof(tmp));
+        tmp.line            = port->serial->minor;
+        tmp.port            = port->number;
+        tmp.baud_base       = tty_get_baud_rate(port->port.tty);
+        tmp.close_delay     = port->port.close_delay / 10;
+        tmp.closing_wait    = port->port.closing_wait == ASYNC_CLOSING_WAIT_NONE ?
+                                 ASYNC_CLOSING_WAIT_NONE :
+                                 port->port.closing_wait / 10;
+
+        if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
+                return -EFAULT;
+        return 0;
+}
+
+static int set_serial_info(struct usb_serial_port *port,
+                           struct serial_struct __user *newinfo)
+{
+        struct serial_struct new_serial;
+        unsigned int closing_wait, close_delay;
+        int retval = 0;
+
+        if (copy_from_user(&new_serial, newinfo, sizeof(new_serial)))
+                return -EFAULT;
+
+        close_delay = new_serial.close_delay * 10;
+        closing_wait = new_serial.closing_wait == ASYNC_CLOSING_WAIT_NONE ?
+                        ASYNC_CLOSING_WAIT_NONE : new_serial.closing_wait * 10;
+
+        mutex_lock(&port->port.mutex);
+
+        if (!capable(CAP_SYS_ADMIN)) {
+                if ((close_delay != port->port.close_delay) ||
+                    (closing_wait != port->port.closing_wait))
+                        retval = -EPERM;
+                else
+                        retval = -EOPNOTSUPP;
+        } else {
+                port->port.close_delay  = close_delay;
+                port->port.closing_wait = closing_wait;
+        }
+
+        mutex_unlock(&port->port.mutex);
+        return retval;
+}
+
+int usb_wwan_ioctl(struct tty_struct *tty,
+                   unsigned int cmd, unsigned long arg)
+{
+        struct usb_serial_port *port = tty->driver_data;
+
+        dbg("%s cmd 0x%04x", __func__, cmd);
+
+        switch (cmd) {
+        case TIOCGSERIAL:
+                return get_serial_info(port,
+                                       (struct serial_struct __user *) arg);
+        case TIOCSSERIAL:
+                return set_serial_info(port,
+                                       (struct serial_struct __user *) arg);
+        default:
+                break;
+        }
+
+        dbg("%s arg not supported", __func__);
+
+        return -ENOIOCTLCMD;
+}
+EXPORT_SYMBOL(usb_wwan_ioctl);
+
 /* Write */
 int usb_wwan_write(struct tty_struct *tty, struct usb_serial_port *port,
                    const unsigned char *buf, int count)
@@ -182,7 +261,8 @@ int usb_wwan_write(struct tty_struct *tty, struct usb_serial_port *port,
                                 intfdata->in_flight--;
                                 spin_unlock_irqrestore(&intfdata->susp_lock,
                                                        flags);
-                                continue;
+                                usb_autopm_put_interface_async(port->serial->interface);
+                                break;
                         }
                 }
 
@@ -216,25 +296,32 @@ static void usb_wwan_indat_callback(struct urb *urb)
                     __func__, status, endpoint);
         } else {
                 tty = tty_port_tty_get(&port->port);
-                if (urb->actual_length) {
-                        tty_insert_flip_string(tty, data, urb->actual_length);
-                        tty_flip_buffer_push(tty);
-                } else
-                        dbg("%s: empty read urb received", __func__);
-                tty_kref_put(tty);
+                if (tty) {
+                        if (urb->actual_length) {
+                                tty_insert_flip_string(tty, data,
+                                                urb->actual_length);
+                                tty_flip_buffer_push(tty);
+                        } else
+                                dbg("%s: empty read urb received", __func__);
+                        tty_kref_put(tty);
+                }
 
                 /* Resubmit urb so we continue receiving */
                 if (status != -ESHUTDOWN) {
                         err = usb_submit_urb(urb, GFP_ATOMIC);
-                        if (err && err != -EPERM)
-                                printk(KERN_ERR "%s: resubmit read urb failed. "
-                                       "(%d)", __func__, err);
-                        else
+                        if (err) {
+                                if (err != -EPERM) {
+                                        printk(KERN_ERR "%s: resubmit read urb failed. "
+                                                "(%d)", __func__, err);
+                                        /* busy also in error unless we are killed */
+                                        usb_mark_last_busy(port->serial->dev);
+                                }
+                        } else {
                                 usb_mark_last_busy(port->serial->dev);
+                        }
                 }
 
         }
-        return;
 }
 
 static void usb_wwan_outdat_callback(struct urb *urb)
@@ -340,6 +427,7 @@ int usb_wwan_open(struct tty_struct *tty, struct usb_serial_port *port)
         spin_lock_irq(&intfdata->susp_lock);
         portdata->opened = 1;
         spin_unlock_irq(&intfdata->susp_lock);
+        /* this balances a get in the generic USB serial code */
         usb_autopm_put_interface(serial->interface);
 
         return 0;
@@ -366,7 +454,8 @@ void usb_wwan_close(struct usb_serial_port *port)
                         usb_kill_urb(portdata->in_urbs[i]);
                 for (i = 0; i < N_OUT_URB; i++)
                         usb_kill_urb(portdata->out_urbs[i]);
-                usb_autopm_get_interface(serial->interface);
+                /* balancing - important as an error cannot be handled*/
+                usb_autopm_get_interface_no_resume(serial->interface);
                 serial->interface->needs_remote_wakeup = 0;
         }
 }
@@ -580,6 +669,18 @@ int usb_wwan_suspend(struct usb_serial *serial, pm_message_t message)
 }
 EXPORT_SYMBOL(usb_wwan_suspend);
 
+static void unbusy_queued_urb(struct urb *urb, struct usb_wwan_port_private *portdata)
+{
+        int i;
+
+        for (i = 0; i < N_OUT_URB; i++) {
+                if (urb == portdata->out_urbs[i]) {
+                        clear_bit(i, &portdata->out_busy);
+                        break;
+                }
+        }
+}
+
 static void play_delayed(struct usb_serial_port *port)
 {
         struct usb_wwan_intf_private *data;
@@ -591,8 +692,16 @@ static void play_delayed(struct usb_serial_port *port)
         data = port->serial->private;
         while ((urb = usb_get_from_anchor(&portdata->delayed))) {
                 err = usb_submit_urb(urb, GFP_ATOMIC);
-                if (!err)
+                if (!err) {
                         data->in_flight++;
+                } else {
+                        /* we have to throw away the rest */
+                        do {
+                                unbusy_queued_urb(urb, portdata);
+                                usb_autopm_put_interface_no_suspend(port->serial->interface);
+                        } while ((urb = usb_get_from_anchor(&portdata->delayed)));
+                        break;
+                }
         }
 }
 
diff --git a/drivers/usb/serial/visor.c b/drivers/usb/serial/visor.c
index eb76aaef4268..1c11959a7d58 100644
--- a/drivers/usb/serial/visor.c
+++ b/drivers/usb/serial/visor.c
@@ -27,6 +27,7 @@
 #include <linux/uaccess.h>
 #include <linux/usb.h>
 #include <linux/usb/serial.h>
+#include <linux/usb/cdc.h>
 #include "visor.h"
 
 /*
@@ -479,6 +480,17 @@ static int visor_probe(struct usb_serial *serial,
 
         dbg("%s", __func__);
 
+        /*
+         * some Samsung Android phones in modem mode have the same ID
+         * as SPH-I500, but they are ACM devices, so dont bind to them
+         */
+        if (id->idVendor == SAMSUNG_VENDOR_ID &&
+                id->idProduct == SAMSUNG_SPH_I500_ID &&
+                serial->dev->descriptor.bDeviceClass == USB_CLASS_COMM &&
+                serial->dev->descriptor.bDeviceSubClass ==
+                        USB_CDC_SUBCLASS_ACM)
+                return -ENODEV;
+
         if (serial->dev->actconfig->desc.bConfigurationValue != 1) {
                 dev_err(&serial->dev->dev, "active config #%d != 1 ??\n",
                         serial->dev->actconfig->desc.bConfigurationValue);
@@ -606,6 +618,10 @@ static int treo_attach(struct usb_serial *serial)
 
 static int clie_5_attach(struct usb_serial *serial)
 {
+        struct usb_serial_port *port;
+        unsigned int pipe;
+        int j;
+
         dbg("%s", __func__);
 
         /* TH55 registers 2 ports.
@@ -621,9 +637,14 @@ static int clie_5_attach(struct usb_serial *serial)
                 return -1;
 
         /* port 0 now uses the modified endpoint Address */
-        serial->port[0]->bulk_out_endpointAddress =
+        port = serial->port[0];
+        port->bulk_out_endpointAddress =
                                 serial->port[1]->bulk_out_endpointAddress;
 
+        pipe = usb_sndbulkpipe(serial->dev, port->bulk_out_endpointAddress);
+        for (j = 0; j < ARRAY_SIZE(port->write_urbs); ++j)
+                port->write_urbs[j]->pipe = pipe;
+
         return 0;
 }
 
diff --git a/drivers/usb/serial/whiteheat.c b/drivers/usb/serial/whiteheat.c
index 12ed8209ca72..5b073bcc807b 100644
--- a/drivers/usb/serial/whiteheat.c
+++ b/drivers/usb/serial/whiteheat.c
@@ -152,12 +152,12 @@ static int  whiteheat_write(struct tty_struct *tty,
                         struct usb_serial_port *port,
                         const unsigned char *buf, int count);
 static int  whiteheat_write_room(struct tty_struct *tty);
-static int  whiteheat_ioctl(struct tty_struct *tty, struct file *file,
+static int  whiteheat_ioctl(struct tty_struct *tty,
                         unsigned int cmd, unsigned long arg);
 static void whiteheat_set_termios(struct tty_struct *tty,
                         struct usb_serial_port *port, struct ktermios *old);
-static int  whiteheat_tiocmget(struct tty_struct *tty, struct file *file);
-static int  whiteheat_tiocmset(struct tty_struct *tty, struct file *file,
+static int  whiteheat_tiocmget(struct tty_struct *tty);
+static int  whiteheat_tiocmset(struct tty_struct *tty,
                         unsigned int set, unsigned int clear);
 static void whiteheat_break_ctl(struct tty_struct *tty, int break_state);
 static int  whiteheat_chars_in_buffer(struct tty_struct *tty);
@@ -655,8 +655,6 @@ static void whiteheat_release(struct usb_serial *serial)
                 }
                 kfree(info);
         }
-
-        return;
 }
 
 static int whiteheat_open(struct tty_struct *tty, struct usb_serial_port *port)
@@ -835,7 +833,7 @@ static int whiteheat_write_room(struct tty_struct *tty)
         return (room);
 }
 
-static int whiteheat_tiocmget(struct tty_struct *tty, struct file *file)
+static int whiteheat_tiocmget(struct tty_struct *tty)
 {
         struct usb_serial_port *port = tty->driver_data;
         struct whiteheat_private *info = usb_get_serial_port_data(port);
@@ -852,7 +850,7 @@ static int whiteheat_tiocmget(struct tty_struct *tty, struct file *file)
         return modem_signals;
 }
 
-static int whiteheat_tiocmset(struct tty_struct *tty, struct file *file,
+static int whiteheat_tiocmset(struct tty_struct *tty,
                                unsigned int set, unsigned int clear)
 {
         struct usb_serial_port *port = tty->driver_data;
@@ -876,7 +874,7 @@ static int whiteheat_tiocmset(struct tty_struct *tty, struct file *file,
 }
 
 
-static int whiteheat_ioctl(struct tty_struct *tty, struct file *file,
+static int whiteheat_ioctl(struct tty_struct *tty,
                                         unsigned int cmd, unsigned long arg)
 {
         struct usb_serial_port *port = tty->driver_data;
@@ -955,8 +953,6 @@ static void whiteheat_throttle(struct tty_struct *tty)
         spin_lock_irq(&info->lock);
         info->flags |= THROTTLED;
         spin_unlock_irq(&info->lock);
-
-        return;
 }
 
 
@@ -975,8 +971,6 @@ static void whiteheat_unthrottle(struct tty_struct *tty)
 
         if (actually_throttled)
                 rx_data_softint(&info->rx_work);
-
-        return;
 }
 
 
diff --git a/drivers/usb/storage/Kconfig b/drivers/usb/storage/Kconfig
index 8a372bac0e43..97987255be75 100644
--- a/drivers/usb/storage/Kconfig
+++ b/drivers/usb/storage/Kconfig
@@ -31,12 +31,22 @@ config USB_STORAGE_DEBUG
           Say Y here in order to have the USB Mass Storage code generate
           verbose debugging messages.
 
+config USB_STORAGE_REALTEK
+        tristate "Realtek Card Reader support"
+        depends on USB_STORAGE
+        help
+          Say Y here to include additional code to support the power-saving function
+          for Realtek RTS51xx USB card readers.
+
+          If this driver is compiled as a module, it will be named ums-realtek.
+
+
 config USB_STORAGE_DATAFAB
         tristate "Datafab Compact Flash Reader support"
         depends on USB_STORAGE
         help
           Support for certain Datafab CompactFlash readers.
-          Datafab has a web page at <http://www.datafabusa.com/>.
+          Datafab has a web page at <http://www.datafab.com/>.
 
           If this driver is compiled as a module, it will be named ums-datafab.
 
@@ -172,6 +182,34 @@ config USB_STORAGE_CYPRESS_ATACB
 
           If this driver is compiled as a module, it will be named ums-cypress.
 
+config USB_STORAGE_ENE_UB6250
+        tristate "USB ENE card reader support"
+        depends on USB && SCSI
+        depends on USB_STORAGE
+        ---help---
+          Say Y here if you wish to control a ENE SD Card reader.
+          To use SM/MS card, please build driver/staging/keucr/keucr.ko
+
+          This option depends on 'SCSI' support being enabled, but you
+          probably also need 'SCSI device support: SCSI disk support'
+          (BLK_DEV_SD) for most USB storage devices.
+
+          To compile this driver as a module, choose M here: the
+          module will be called ums-eneub6250.
+
+config USB_UAS
+        tristate "USB Attached SCSI"
+        depends on USB && SCSI
+        help
+          The USB Attached SCSI protocol is supported by some USB
+          storage devices.  It permits higher performance by supporting
+          multiple outstanding commands.
+
+          If you don't know whether you have a UAS device, it is safe to
+          say 'Y' or 'M' here and the kernel will use the right driver.
+
+          If you compile this driver as a module, it will be named uas.
+
 config USB_LIBUSUAL
         bool "The shared table of common (or usual) storage devices"
         depends on USB
diff --git a/drivers/usb/storage/Makefile b/drivers/usb/storage/Makefile
index ef7e5a8ceab5..82e6416a2d47 100644
--- a/drivers/usb/storage/Makefile
+++ b/drivers/usb/storage/Makefile
@@ -5,42 +5,47 @@
 # Rewritten to use lists instead of if-statements.
 #
 
-EXTRA_CFLAGS    := -Idrivers/scsi
+ccflags-y := -Idrivers/scsi
 
+obj-$(CONFIG_USB_UAS)           += uas.o
 obj-$(CONFIG_USB_STORAGE)       += usb-storage.o
 
-usb-storage-obj-$(CONFIG_USB_STORAGE_DEBUG)     += debug.o
+usb-storage-y := scsiglue.o protocol.o transport.o usb.o
+usb-storage-y += initializers.o sierra_ms.o option_ms.o
 
-usb-storage-objs :=     scsiglue.o protocol.o transport.o usb.o \
-                        initializers.o sierra_ms.o option_ms.o $(usb-storage-obj-y)
+usb-storage-$(CONFIG_USB_STORAGE_DEBUG) += debug.o
 
 ifeq ($(CONFIG_USB_LIBUSUAL),)
-        usb-storage-objs        += usual-tables.o
+        usb-storage-y           += usual-tables.o
 else
         obj-$(CONFIG_USB)       += usb-libusual.o
-        usb-libusual-objs       := libusual.o usual-tables.o
+        usb-libusual-y          := libusual.o usual-tables.o
 endif
 
 obj-$(CONFIG_USB_STORAGE_ALAUDA)        += ums-alauda.o
 obj-$(CONFIG_USB_STORAGE_CYPRESS_ATACB) += ums-cypress.o
 obj-$(CONFIG_USB_STORAGE_DATAFAB)       += ums-datafab.o
+obj-$(CONFIG_USB_STORAGE_ENE_UB6250)    += ums-eneub6250.o
 obj-$(CONFIG_USB_STORAGE_FREECOM)       += ums-freecom.o
 obj-$(CONFIG_USB_STORAGE_ISD200)        += ums-isd200.o
 obj-$(CONFIG_USB_STORAGE_JUMPSHOT)      += ums-jumpshot.o
 obj-$(CONFIG_USB_STORAGE_KARMA)         += ums-karma.o
 obj-$(CONFIG_USB_STORAGE_ONETOUCH)      += ums-onetouch.o
+obj-$(CONFIG_USB_STORAGE_REALTEK)       += ums-realtek.o
 obj-$(CONFIG_USB_STORAGE_SDDR09)        += ums-sddr09.o
 obj-$(CONFIG_USB_STORAGE_SDDR55)        += ums-sddr55.o
 obj-$(CONFIG_USB_STORAGE_USBAT)         += ums-usbat.o
 
-ums-alauda-objs         := alauda.o
-ums-cypress-objs        := cypress_atacb.o
-ums-datafab-objs        := datafab.o
-ums-freecom-objs        := freecom.o
-ums-isd200-objs         := isd200.o
-ums-jumpshot-objs       := jumpshot.o
-ums-karma-objs          := karma.o
-ums-onetouch-objs       := onetouch.o
-ums-sddr09-objs         := sddr09.o
-ums-sddr55-objs         := sddr55.o
-ums-usbat-objs          := shuttle_usbat.o
+ums-alauda-y            := alauda.o
+ums-cypress-y           := cypress_atacb.o
+ums-datafab-y           := datafab.o
+ums-eneub6250-y         := ene_ub6250.o
+ums-freecom-y           := freecom.o
+ums-isd200-y            := isd200.o
+ums-jumpshot-y          := jumpshot.o
+ums-karma-y             := karma.o
+ums-onetouch-y          := onetouch.o
+ums-realtek-y           := realtek_cr.o
+ums-sddr09-y            := sddr09.o
+ums-sddr55-y            := sddr55.o
+ums-usbat-y             := shuttle_usbat.o
diff --git a/drivers/usb/storage/ene_ub6250.c b/drivers/usb/storage/ene_ub6250.c
new file mode 100644
index 000000000000..31645afff5fc
--- /dev/null
+++ b/drivers/usb/storage/ene_ub6250.c
@@ -0,0 +1,803 @@
+/*
+ *
+ * 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, 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.
+ */
+#include <linux/jiffies.h>
+#include <linux/errno.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+
+#include <scsi/scsi.h>
+#include <scsi/scsi_cmnd.h>
+
+#include <linux/firmware.h>
+
+#include "usb.h"
+#include "transport.h"
+#include "protocol.h"
+#include "debug.h"
+
+MODULE_DESCRIPTION("Driver for ENE UB6250 reader");
+MODULE_LICENSE("GPL");
+
+
+/*
+ * The table of devices
+ */
+#define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
+                    vendorName, productName, useProtocol, useTransport, \
+                    initFunction, flags) \
+{ USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
+        .driver_info = (flags)|(USB_US_TYPE_STOR<<24) }
+
+struct usb_device_id ene_ub6250_usb_ids[] = {
+#       include "unusual_ene_ub6250.h"
+        { }             /* Terminating entry */
+};
+MODULE_DEVICE_TABLE(usb, ene_ub6250_usb_ids);
+
+#undef UNUSUAL_DEV
+
+/*
+ * The flags table
+ */
+#define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
+                    vendor_name, product_name, use_protocol, use_transport, \
+                    init_function, Flags) \
+{ \
+        .vendorName = vendor_name,      \
+        .productName = product_name,    \
+        .useProtocol = use_protocol,    \
+        .useTransport = use_transport,  \
+        .initFunction = init_function,  \
+}
+
+static struct us_unusual_dev ene_ub6250_unusual_dev_list[] = {
+#       include "unusual_ene_ub6250.h"
+        { }             /* Terminating entry */
+};
+
+#undef UNUSUAL_DEV
+
+
+
+/* ENE bin code len */
+#define ENE_BIN_CODE_LEN    0x800
+/* EnE HW Register */
+#define REG_CARD_STATUS     0xFF83
+#define REG_HW_TRAP1        0xFF89
+
+/* SRB Status */
+#define SS_SUCCESS                  0x00      /* No Sense */
+#define SS_NOT_READY                0x02
+#define SS_MEDIUM_ERR               0x03
+#define SS_HW_ERR                   0x04
+#define SS_ILLEGAL_REQUEST          0x05
+#define SS_UNIT_ATTENTION           0x06
+
+/* ENE Load FW Pattern */
+#define SD_INIT1_PATTERN   1
+#define SD_INIT2_PATTERN   2
+#define SD_RW_PATTERN      3
+#define MS_INIT_PATTERN    4
+#define MSP_RW_PATTERN     5
+#define MS_RW_PATTERN      6
+#define SM_INIT_PATTERN    7
+#define SM_RW_PATTERN      8
+
+#define FDIR_WRITE         0
+#define FDIR_READ          1
+
+
+struct SD_STATUS {
+        u8    Insert:1;
+        u8    Ready:1;
+        u8    MediaChange:1;
+        u8    IsMMC:1;
+        u8    HiCapacity:1;
+        u8    HiSpeed:1;
+        u8    WtP:1;
+        u8    Reserved:1;
+};
+
+struct MS_STATUS {
+        u8    Insert:1;
+        u8    Ready:1;
+        u8    MediaChange:1;
+        u8    IsMSPro:1;
+        u8    IsMSPHG:1;
+        u8    Reserved1:1;
+        u8    WtP:1;
+        u8    Reserved2:1;
+};
+
+struct SM_STATUS {
+        u8    Insert:1;
+        u8    Ready:1;
+        u8    MediaChange:1;
+        u8    Reserved:3;
+        u8    WtP:1;
+        u8    IsMS:1;
+};
+
+
+/* SD Block Length */
+/* 2^9 = 512 Bytes, The HW maximum read/write data length */
+#define SD_BLOCK_LEN  9
+
+struct ene_ub6250_info {
+        /* for 6250 code */
+        struct SD_STATUS        SD_Status;
+        struct MS_STATUS        MS_Status;
+        struct SM_STATUS        SM_Status;
+
+        /* ----- SD Control Data ---------------- */
+        /*SD_REGISTER SD_Regs; */
+        u16             SD_Block_Mult;
+        u8              SD_READ_BL_LEN;
+        u16             SD_C_SIZE;
+        u8              SD_C_SIZE_MULT;
+
+        /* SD/MMC New spec. */
+        u8              SD_SPEC_VER;
+        u8              SD_CSD_VER;
+        u8              SD20_HIGH_CAPACITY;
+        u32             HC_C_SIZE;
+        u8              MMC_SPEC_VER;
+        u8              MMC_BusWidth;
+        u8              MMC_HIGH_CAPACITY;
+
+        /*----- MS Control Data ---------------- */
+        bool            MS_SWWP;
+        u32             MSP_TotalBlock;
+        /*MS_LibControl       MS_Lib;*/
+        bool            MS_IsRWPage;
+        u16             MS_Model;
+
+        /*----- SM Control Data ---------------- */
+        u8              SM_DeviceID;
+        u8              SM_CardID;
+
+        unsigned char   *testbuf;
+        u8              BIN_FLAG;
+        u32             bl_num;
+        int             SrbStatus;
+
+        /*------Power Managerment ---------------*/
+        bool            Power_IsResum;
+};
+
+static int ene_sd_init(struct us_data *us);
+static int ene_load_bincode(struct us_data *us, unsigned char flag);
+
+static void ene_ub6250_info_destructor(void *extra)
+{
+        if (!extra)
+                return;
+}
+
+static int ene_send_scsi_cmd(struct us_data *us, u8 fDir, void *buf, int use_sg)
+{
+        struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
+        struct bulk_cs_wrap *bcs = (struct bulk_cs_wrap *) us->iobuf;
+
+        int result;
+        unsigned int residue;
+        unsigned int cswlen = 0, partial = 0;
+        unsigned int transfer_length = bcb->DataTransferLength;
+
+        /* US_DEBUGP("transport --- ene_send_scsi_cmd\n"); */
+        /* send cmd to out endpoint */
+        result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe,
+                                            bcb, US_BULK_CB_WRAP_LEN, NULL);
+        if (result != USB_STOR_XFER_GOOD) {
+                US_DEBUGP("send cmd to out endpoint fail ---\n");
+                return USB_STOR_TRANSPORT_ERROR;
+        }
+
+        if (buf) {
+                unsigned int pipe = fDir;
+
+                if (fDir  == FDIR_READ)
+                        pipe = us->recv_bulk_pipe;
+                else
+                        pipe = us->send_bulk_pipe;
+
+                /* Bulk */
+                if (use_sg) {
+                        result = usb_stor_bulk_srb(us, pipe, us->srb);
+                } else {
+                        result = usb_stor_bulk_transfer_sg(us, pipe, buf,
+                                                transfer_length, 0, &partial);
+                }
+                if (result != USB_STOR_XFER_GOOD) {
+                        US_DEBUGP("data transfer fail ---\n");
+                        return USB_STOR_TRANSPORT_ERROR;
+                }
+        }
+
+        /* Get CSW for device status */
+        result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, bcs,
+                                            US_BULK_CS_WRAP_LEN, &cswlen);
+
+        if (result == USB_STOR_XFER_SHORT && cswlen == 0) {
+                US_DEBUGP("Received 0-length CSW; retrying...\n");
+                result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
+                                            bcs, US_BULK_CS_WRAP_LEN, &cswlen);
+        }
+
+        if (result == USB_STOR_XFER_STALLED) {
+                /* get the status again */
+                US_DEBUGP("Attempting to get CSW (2nd try)...\n");
+                result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
+                                                bcs, US_BULK_CS_WRAP_LEN, NULL);
+        }
+
+        if (result != USB_STOR_XFER_GOOD)
+                return USB_STOR_TRANSPORT_ERROR;
+
+        /* check bulk status */
+        residue = le32_to_cpu(bcs->Residue);
+
+        /* try to compute the actual residue, based on how much data
+         * was really transferred and what the device tells us */
+        if (residue && !(us->fflags & US_FL_IGNORE_RESIDUE)) {
+                residue = min(residue, transfer_length);
+                if (us->srb != NULL)
+                        scsi_set_resid(us->srb, max(scsi_get_resid(us->srb),
+                                                                (int)residue));
+        }
+
+        if (bcs->Status != US_BULK_STAT_OK)
+                return USB_STOR_TRANSPORT_ERROR;
+
+        return USB_STOR_TRANSPORT_GOOD;
+}
+
+static int sd_scsi_test_unit_ready(struct us_data *us, struct scsi_cmnd *srb)
+{
+        struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
+
+        if (info->SD_Status.Insert && info->SD_Status.Ready)
+                return USB_STOR_TRANSPORT_GOOD;
+        else {
+                ene_sd_init(us);
+                return USB_STOR_TRANSPORT_GOOD;
+        }
+
+        return USB_STOR_TRANSPORT_GOOD;
+}
+
+static int sd_scsi_inquiry(struct us_data *us, struct scsi_cmnd *srb)
+{
+        unsigned char data_ptr[36] = {
+                0x00, 0x80, 0x02, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x55,
+                0x53, 0x42, 0x32, 0x2E, 0x30, 0x20, 0x20, 0x43, 0x61,
+                0x72, 0x64, 0x52, 0x65, 0x61, 0x64, 0x65, 0x72, 0x20,
+                0x20, 0x20, 0x20, 0x20, 0x20, 0x30, 0x31, 0x30, 0x30 };
+
+        usb_stor_set_xfer_buf(data_ptr, 36, srb);
+        return USB_STOR_TRANSPORT_GOOD;
+}
+
+static int sd_scsi_mode_sense(struct us_data *us, struct scsi_cmnd *srb)
+{
+        struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
+        unsigned char mediaNoWP[12] = {
+                0x0b, 0x00, 0x00, 0x08, 0x00, 0x00,
+                0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 };
+        unsigned char mediaWP[12]   = {
+                0x0b, 0x00, 0x80, 0x08, 0x00, 0x00,
+                0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 };
+
+        if (info->SD_Status.WtP)
+                usb_stor_set_xfer_buf(mediaWP, 12, srb);
+        else
+                usb_stor_set_xfer_buf(mediaNoWP, 12, srb);
+
+
+        return USB_STOR_TRANSPORT_GOOD;
+}
+
+static int sd_scsi_read_capacity(struct us_data *us, struct scsi_cmnd *srb)
+{
+        u32   bl_num;
+        u16    bl_len;
+        unsigned int offset = 0;
+        unsigned char    buf[8];
+        struct scatterlist *sg = NULL;
+        struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
+
+        US_DEBUGP("sd_scsi_read_capacity\n");
+        if (info->SD_Status.HiCapacity) {
+                bl_len = 0x200;
+                if (info->SD_Status.IsMMC)
+                        bl_num = info->HC_C_SIZE-1;
+                else
+                        bl_num = (info->HC_C_SIZE + 1) * 1024 - 1;
+        } else {
+                bl_len = 1<<(info->SD_READ_BL_LEN);
+                bl_num = info->SD_Block_Mult * (info->SD_C_SIZE + 1)
+                                * (1 << (info->SD_C_SIZE_MULT + 2)) - 1;
+        }
+        info->bl_num = bl_num;
+        US_DEBUGP("bl_len = %x\n", bl_len);
+        US_DEBUGP("bl_num = %x\n", bl_num);
+
+        /*srb->request_bufflen = 8; */
+        buf[0] = (bl_num >> 24) & 0xff;
+        buf[1] = (bl_num >> 16) & 0xff;
+        buf[2] = (bl_num >> 8) & 0xff;
+        buf[3] = (bl_num >> 0) & 0xff;
+        buf[4] = (bl_len >> 24) & 0xff;
+        buf[5] = (bl_len >> 16) & 0xff;
+        buf[6] = (bl_len >> 8) & 0xff;
+        buf[7] = (bl_len >> 0) & 0xff;
+
+        usb_stor_access_xfer_buf(buf, 8, srb, &sg, &offset, TO_XFER_BUF);
+
+        return USB_STOR_TRANSPORT_GOOD;
+}
+
+static int sd_scsi_read(struct us_data *us, struct scsi_cmnd *srb)
+{
+        int result;
+        unsigned char *cdb = srb->cmnd;
+        struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
+        struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
+
+        u32 bn = ((cdb[2] << 24) & 0xff000000) | ((cdb[3] << 16) & 0x00ff0000) |
+                 ((cdb[4] << 8) & 0x0000ff00) | ((cdb[5] << 0) & 0x000000ff);
+        u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff);
+        u32 bnByte = bn * 0x200;
+        u32 blenByte = blen * 0x200;
+
+        if (bn > info->bl_num)
+                return USB_STOR_TRANSPORT_ERROR;
+
+        result = ene_load_bincode(us, SD_RW_PATTERN);
+        if (result != USB_STOR_XFER_GOOD) {
+                US_DEBUGP("Load SD RW pattern Fail !!\n");
+                return USB_STOR_TRANSPORT_ERROR;
+        }
+
+        if (info->SD_Status.HiCapacity)
+                bnByte = bn;
+
+        /* set up the command wrapper */
+        memset(bcb, 0, sizeof(struct bulk_cb_wrap));
+        bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
+        bcb->DataTransferLength = blenByte;
+        bcb->Flags  = 0x80;
+        bcb->CDB[0] = 0xF1;
+        bcb->CDB[5] = (unsigned char)(bnByte);
+        bcb->CDB[4] = (unsigned char)(bnByte>>8);
+        bcb->CDB[3] = (unsigned char)(bnByte>>16);
+        bcb->CDB[2] = (unsigned char)(bnByte>>24);
+
+        result = ene_send_scsi_cmd(us, FDIR_READ, scsi_sglist(srb), 1);
+        return result;
+}
+
+static int sd_scsi_write(struct us_data *us, struct scsi_cmnd *srb)
+{
+        int result;
+        unsigned char *cdb = srb->cmnd;
+        struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
+        struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
+
+        u32 bn = ((cdb[2] << 24) & 0xff000000) | ((cdb[3] << 16) & 0x00ff0000) |
+                 ((cdb[4] << 8) & 0x0000ff00) | ((cdb[5] << 0) & 0x000000ff);
+        u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff);
+        u32 bnByte = bn * 0x200;
+        u32 blenByte = blen * 0x200;
+
+        if (bn > info->bl_num)
+                return USB_STOR_TRANSPORT_ERROR;
+
+        result = ene_load_bincode(us, SD_RW_PATTERN);
+        if (result != USB_STOR_XFER_GOOD) {
+                US_DEBUGP("Load SD RW pattern Fail !!\n");
+                return USB_STOR_TRANSPORT_ERROR;
+        }
+
+        if (info->SD_Status.HiCapacity)
+                bnByte = bn;
+
+        /* set up the command wrapper */
+        memset(bcb, 0, sizeof(struct bulk_cb_wrap));
+        bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
+        bcb->DataTransferLength = blenByte;
+        bcb->Flags  = 0x00;
+        bcb->CDB[0] = 0xF0;
+        bcb->CDB[5] = (unsigned char)(bnByte);
+        bcb->CDB[4] = (unsigned char)(bnByte>>8);
+        bcb->CDB[3] = (unsigned char)(bnByte>>16);
+        bcb->CDB[2] = (unsigned char)(bnByte>>24);
+
+        result = ene_send_scsi_cmd(us, FDIR_WRITE, scsi_sglist(srb), 1);
+        return result;
+}
+
+static int ene_get_card_type(struct us_data *us, u16 index, void *buf)
+{
+        struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
+        int result;
+
+        memset(bcb, 0, sizeof(struct bulk_cb_wrap));
+        bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
+        bcb->DataTransferLength = 0x01;
+        bcb->Flags                      = 0x80;
+        bcb->CDB[0]                     = 0xED;
+        bcb->CDB[2]                     = (unsigned char)(index>>8);
+        bcb->CDB[3]                     = (unsigned char)index;
+
+        result = ene_send_scsi_cmd(us, FDIR_READ, buf, 0);
+        return result;
+}
+
+static int ene_get_card_status(struct us_data *us, u8 *buf)
+{
+        u16 tmpreg;
+        u32 reg4b;
+        struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
+
+        /*US_DEBUGP("transport --- ENE_ReadSDReg\n");*/
+        reg4b = *(u32 *)&buf[0x18];
+        info->SD_READ_BL_LEN = (u8)((reg4b >> 8) & 0x0f);
+
+        tmpreg = (u16) reg4b;
+        reg4b = *(u32 *)(&buf[0x14]);
+        if (info->SD_Status.HiCapacity && !info->SD_Status.IsMMC)
+                info->HC_C_SIZE = (reg4b >> 8) & 0x3fffff;
+
+        info->SD_C_SIZE = ((tmpreg & 0x03) << 10) | (u16)(reg4b >> 22);
+        info->SD_C_SIZE_MULT = (u8)(reg4b >> 7)  & 0x07;
+        if (info->SD_Status.HiCapacity && info->SD_Status.IsMMC)
+                info->HC_C_SIZE = *(u32 *)(&buf[0x100]);
+
+        if (info->SD_READ_BL_LEN > SD_BLOCK_LEN) {
+                info->SD_Block_Mult = 1 << (info->SD_READ_BL_LEN-SD_BLOCK_LEN);
+                info->SD_READ_BL_LEN = SD_BLOCK_LEN;
+        } else {
+                info->SD_Block_Mult = 1;
+        }
+
+        return USB_STOR_TRANSPORT_GOOD;
+}
+
+static int ene_load_bincode(struct us_data *us, unsigned char flag)
+{
+        int err;
+        char *fw_name = NULL;
+        unsigned char *buf = NULL;
+        const struct firmware *sd_fw = NULL;
+        int result = USB_STOR_TRANSPORT_ERROR;
+        struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
+        struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
+
+        if (info->BIN_FLAG == flag)
+                return USB_STOR_TRANSPORT_GOOD;
+
+        switch (flag) {
+        /* For SD */
+        case SD_INIT1_PATTERN:
+                US_DEBUGP("SD_INIT1_PATTERN\n");
+                fw_name = "ene-ub6250/sd_init1.bin";
+                break;
+        case SD_INIT2_PATTERN:
+                US_DEBUGP("SD_INIT2_PATTERN\n");
+                fw_name = "ene-ub6250/sd_init2.bin";
+                break;
+        case SD_RW_PATTERN:
+                US_DEBUGP("SD_RDWR_PATTERN\n");
+                fw_name = "ene-ub6250/sd_rdwr.bin";
+                break;
+        default:
+                US_DEBUGP("----------- Unknown PATTERN ----------\n");
+                goto nofw;
+        }
+
+        err = request_firmware(&sd_fw, fw_name, &us->pusb_dev->dev);
+        if (err) {
+                US_DEBUGP("load firmware %s failed\n", fw_name);
+                goto nofw;
+        }
+        buf = kmalloc(sd_fw->size, GFP_KERNEL);
+        if (buf == NULL) {
+                US_DEBUGP("Malloc memory for fireware failed!\n");
+                goto nofw;
+        }
+        memcpy(buf, sd_fw->data, sd_fw->size);
+        memset(bcb, 0, sizeof(struct bulk_cb_wrap));
+        bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
+        bcb->DataTransferLength = sd_fw->size;
+        bcb->Flags = 0x00;
+        bcb->CDB[0] = 0xEF;
+
+        result = ene_send_scsi_cmd(us, FDIR_WRITE, buf, 0);
+        info->BIN_FLAG = flag;
+        kfree(buf);
+
+nofw:
+        if (sd_fw != NULL) {
+                release_firmware(sd_fw);
+                sd_fw = NULL;
+        }
+
+        return result;
+}
+
+static int ene_sd_init(struct us_data *us)
+{
+        int result;
+        u8  buf[0x200];
+        struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
+        struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
+
+        US_DEBUGP("transport --- ENE_SDInit\n");
+        /* SD Init Part-1 */
+        result = ene_load_bincode(us, SD_INIT1_PATTERN);
+        if (result != USB_STOR_XFER_GOOD) {
+                US_DEBUGP("Load SD Init Code Part-1 Fail !!\n");
+                return USB_STOR_TRANSPORT_ERROR;
+        }
+
+        memset(bcb, 0, sizeof(struct bulk_cb_wrap));
+        bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
+        bcb->Flags = 0x80;
+        bcb->CDB[0] = 0xF2;
+
+        result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0);
+        if (result != USB_STOR_XFER_GOOD) {
+                US_DEBUGP("Execution SD Init Code Fail !!\n");
+                return USB_STOR_TRANSPORT_ERROR;
+        }
+
+        /* SD Init Part-2 */
+        result = ene_load_bincode(us, SD_INIT2_PATTERN);
+        if (result != USB_STOR_XFER_GOOD) {
+                US_DEBUGP("Load SD Init Code Part-2 Fail !!\n");
+                return USB_STOR_TRANSPORT_ERROR;
+        }
+
+        memset(bcb, 0, sizeof(struct bulk_cb_wrap));
+        bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
+        bcb->DataTransferLength = 0x200;
+        bcb->Flags              = 0x80;
+        bcb->CDB[0]             = 0xF1;
+
+        result = ene_send_scsi_cmd(us, FDIR_READ, &buf, 0);
+        if (result != USB_STOR_XFER_GOOD) {
+                US_DEBUGP("Execution SD Init Code Fail !!\n");
+                return USB_STOR_TRANSPORT_ERROR;
+        }
+
+        info->SD_Status =  *(struct SD_STATUS *)&buf[0];
+        if (info->SD_Status.Insert && info->SD_Status.Ready) {
+                ene_get_card_status(us, (unsigned char *)&buf);
+                US_DEBUGP("Insert     = %x\n", info->SD_Status.Insert);
+                US_DEBUGP("Ready      = %x\n", info->SD_Status.Ready);
+                US_DEBUGP("IsMMC      = %x\n", info->SD_Status.IsMMC);
+                US_DEBUGP("HiCapacity = %x\n", info->SD_Status.HiCapacity);
+                US_DEBUGP("HiSpeed    = %x\n", info->SD_Status.HiSpeed);
+                US_DEBUGP("WtP        = %x\n", info->SD_Status.WtP);
+        } else {
+                US_DEBUGP("SD Card Not Ready --- %x\n", buf[0]);
+                return USB_STOR_TRANSPORT_ERROR;
+        }
+        return USB_STOR_TRANSPORT_GOOD;
+}
+
+
+static int ene_init(struct us_data *us)
+{
+        int result;
+        u8  misc_reg03 = 0;
+        struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
+
+        result = ene_get_card_type(us, REG_CARD_STATUS, &misc_reg03);
+        if (result != USB_STOR_XFER_GOOD)
+                return USB_STOR_TRANSPORT_ERROR;
+
+        if (misc_reg03 & 0x01) {
+                if (!info->SD_Status.Ready) {
+                        result = ene_sd_init(us);
+                        if (result != USB_STOR_XFER_GOOD)
+                                return USB_STOR_TRANSPORT_ERROR;
+                }
+        }
+
+        return result;
+}
+
+/*----- sd_scsi_irp() ---------*/
+static int sd_scsi_irp(struct us_data *us, struct scsi_cmnd *srb)
+{
+        int    result;
+        struct ene_ub6250_info *info = (struct ene_ub6250_info *)us->extra;
+
+        info->SrbStatus = SS_SUCCESS;
+        switch (srb->cmnd[0]) {
+        case TEST_UNIT_READY:
+                result = sd_scsi_test_unit_ready(us, srb);
+                break; /* 0x00 */
+        case INQUIRY:
+                result = sd_scsi_inquiry(us, srb);
+                break; /* 0x12 */
+        case MODE_SENSE:
+                result = sd_scsi_mode_sense(us, srb);
+                break; /* 0x1A */
+        /*
+        case START_STOP:
+                result = SD_SCSI_Start_Stop(us, srb);
+                break; //0x1B
+        */
+        case READ_CAPACITY:
+                result = sd_scsi_read_capacity(us, srb);
+                break; /* 0x25 */
+        case READ_10:
+                result = sd_scsi_read(us, srb);
+                break; /* 0x28 */
+        case WRITE_10:
+                result = sd_scsi_write(us, srb);
+                break; /* 0x2A */
+        default:
+                info->SrbStatus = SS_ILLEGAL_REQUEST;
+                result = USB_STOR_TRANSPORT_FAILED;
+                break;
+        }
+        return result;
+}
+
+static int ene_transport(struct scsi_cmnd *srb, struct us_data *us)
+{
+        int result = 0;
+        struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
+
+        /*US_DEBUG(usb_stor_show_command(srb)); */
+        scsi_set_resid(srb, 0);
+        if (unlikely(!info->SD_Status.Ready))
+                result = ene_init(us);
+        else
+                result = sd_scsi_irp(us, srb);
+
+        return 0;
+}
+
+
+static int ene_ub6250_probe(struct usb_interface *intf,
+                         const struct usb_device_id *id)
+{
+        int result;
+        u8  misc_reg03 = 0;
+        struct us_data *us;
+
+        result = usb_stor_probe1(&us, intf, id,
+                   (id - ene_ub6250_usb_ids) + ene_ub6250_unusual_dev_list);
+        if (result)
+                return result;
+
+        /* FIXME: where should the code alloc extra buf ? */
+        if (!us->extra) {
+                us->extra = kzalloc(sizeof(struct ene_ub6250_info), GFP_KERNEL);
+                if (!us->extra)
+                        return -ENOMEM;
+                us->extra_destructor = ene_ub6250_info_destructor;
+        }
+
+        us->transport_name = "ene_ub6250";
+        us->transport = ene_transport;
+        us->max_lun = 0;
+
+        result = usb_stor_probe2(us);
+        if (result)
+                return result;
+
+        /* probe card type */
+        result = ene_get_card_type(us, REG_CARD_STATUS, &misc_reg03);
+        if (result != USB_STOR_XFER_GOOD) {
+                usb_stor_disconnect(intf);
+                return USB_STOR_TRANSPORT_ERROR;
+        }
+
+        if (!(misc_reg03 & 0x01)) {
+                result = -ENODEV;
+                printk(KERN_NOTICE "ums_eneub6250: The driver only supports SD card. "
+                       "To use SM/MS card, please build driver/staging/keucr\n");
+                usb_stor_disconnect(intf);
+        }
+
+        return result;
+}
+
+
+#ifdef CONFIG_PM
+
+static int ene_ub6250_resume(struct usb_interface *iface)
+{
+        u8 tmp = 0;
+        struct us_data *us = usb_get_intfdata(iface);
+        struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
+
+        mutex_lock(&us->dev_mutex);
+
+        US_DEBUGP("%s\n", __func__);
+        if (us->suspend_resume_hook)
+                (us->suspend_resume_hook)(us, US_RESUME);
+
+        mutex_unlock(&us->dev_mutex);
+
+        info->Power_IsResum = true;
+        /*info->SD_Status.Ready = 0; */
+        info->SD_Status = *(struct SD_STATUS *)&tmp;
+        info->MS_Status = *(struct MS_STATUS *)&tmp;
+        info->SM_Status = *(struct SM_STATUS *)&tmp;
+
+        return 0;
+}
+
+static int ene_ub6250_reset_resume(struct usb_interface *iface)
+{
+        u8 tmp = 0;
+        struct us_data *us = usb_get_intfdata(iface);
+        struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
+        US_DEBUGP("%s\n", __func__);
+        /* Report the reset to the SCSI core */
+        usb_stor_reset_resume(iface);
+
+        /* FIXME: Notify the subdrivers that they need to reinitialize
+         * the device */
+        info->Power_IsResum = true;
+        /*info->SD_Status.Ready = 0; */
+        info->SD_Status = *(struct SD_STATUS *)&tmp;
+        info->MS_Status = *(struct MS_STATUS *)&tmp;
+        info->SM_Status = *(struct SM_STATUS *)&tmp;
+
+        return 0;
+}
+
+#else
+
+#define ene_ub6250_resume               NULL
+#define ene_ub6250_reset_resume         NULL
+
+#endif
+
+static struct usb_driver ene_ub6250_driver = {
+        .name =         "ums_eneub6250",
+        .probe =        ene_ub6250_probe,
+        .disconnect =   usb_stor_disconnect,
+        .suspend =      usb_stor_suspend,
+        .resume =       ene_ub6250_resume,
+        .reset_resume = ene_ub6250_reset_resume,
+        .pre_reset =    usb_stor_pre_reset,
+        .post_reset =   usb_stor_post_reset,
+        .id_table =     ene_ub6250_usb_ids,
+        .soft_unbind =  1,
+};
+
+static int __init ene_ub6250_init(void)
+{
+        return usb_register(&ene_ub6250_driver);
+}
+
+static void __exit ene_ub6250_exit(void)
+{
+        usb_deregister(&ene_ub6250_driver);
+}
+
+module_init(ene_ub6250_init);
+module_exit(ene_ub6250_exit);
diff --git a/drivers/usb/storage/isd200.c b/drivers/usb/storage/isd200.c
index 6b9982cd5423..ffc4193e9505 100644
--- a/drivers/usb/storage/isd200.c
+++ b/drivers/usb/storage/isd200.c
@@ -499,7 +499,6 @@ static int isd200_action( struct us_data *us, int action,
         memset(&ata, 0, sizeof(ata));
         srb->cmnd = info->cmnd;
         srb->device = &srb_dev;
-        ++srb->serial_number;
 
         ata.generic.SignatureByte0 = info->ConfigData.ATAMajorCommand;
         ata.generic.SignatureByte1 = info->ConfigData.ATAMinorCommand;
@@ -1510,7 +1509,7 @@ static int isd200_Initialization(struct us_data *us)
  * Protocol and Transport for the ISD200 ASIC
  *
  * This protocol and transport are for ATA devices connected to an ISD200
- * ASIC.  An ATAPI device that is conected as a slave device will be
+ * ASIC.  An ATAPI device that is connected as a slave device will be
  * detected in the driver initialization function and the protocol will
  * be changed to an ATAPI protocol (Transparent SCSI).
  *
diff --git a/drivers/usb/storage/realtek_cr.c b/drivers/usb/storage/realtek_cr.c
new file mode 100644
index 000000000000..d509a4a7d74f
--- /dev/null
+++ b/drivers/usb/storage/realtek_cr.c
@@ -0,0 +1,675 @@
+/* Driver for Realtek RTS51xx USB card reader
+ *
+ * Copyright(c) 2009 Realtek Semiconductor Corp. All rights reserved.
+ *
+ * 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, 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, see <http://www.gnu.org/licenses/>.
+ *
+ * Author:
+ *   wwang (wei_wang@realsil.com.cn)
+ *   No. 450, Shenhu Road, Suzhou Industry Park, Suzhou, China
+ */
+
+#include <linux/module.h>
+#include <linux/blkdev.h>
+#include <linux/kthread.h>
+#include <linux/sched.h>
+#include <linux/workqueue.h>
+#include <linux/kernel.h>
+#include <linux/version.h>
+
+#include <scsi/scsi.h>
+#include <scsi/scsi_cmnd.h>
+#include <scsi/scsi_device.h>
+#include <linux/cdrom.h>
+
+#include <linux/usb.h>
+#include <linux/slab.h>
+#include <linux/usb_usual.h>
+
+#include "usb.h"
+#include "transport.h"
+#include "protocol.h"
+#include "debug.h"
+
+MODULE_DESCRIPTION("Driver for Realtek USB Card Reader");
+MODULE_AUTHOR("wwang <wei_wang@realsil.com.cn>");
+MODULE_LICENSE("GPL");
+MODULE_VERSION("1.03");
+
+static int auto_delink_en = 1;
+module_param(auto_delink_en, int, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(auto_delink_en, "enable auto delink");
+
+struct rts51x_status {
+        u16 vid;
+        u16 pid;
+        u8 cur_lun;
+        u8 card_type;
+        u8 total_lun;
+        u16 fw_ver;
+        u8 phy_exist;
+        u8 multi_flag;
+        u8 multi_card;
+        u8 log_exist;
+        union {
+                u8 detailed_type1;
+                u8 detailed_type2;
+        } detailed_type;
+        u8 function[2];
+};
+
+struct rts51x_chip {
+        u16                     vendor_id;
+        u16                     product_id;
+        char                    max_lun;
+
+        struct rts51x_status    *status;
+        int                     status_len;
+
+        u32                     flag;
+};
+
+/* flag definition */
+#define FLIDX_AUTO_DELINK               0x01
+
+#define SCSI_LUN(srb)                   ((srb)->device->lun)
+
+/* Bit Operation */
+#define SET_BIT(data, idx)              ((data) |= 1 << (idx))
+#define CLR_BIT(data, idx)              ((data) &= ~(1 << (idx)))
+#define CHK_BIT(data, idx)              ((data) & (1 << (idx)))
+
+#define SET_AUTO_DELINK(chip)           ((chip)->flag |= FLIDX_AUTO_DELINK)
+#define CLR_AUTO_DELINK(chip)           ((chip)->flag &= ~FLIDX_AUTO_DELINK)
+#define CHK_AUTO_DELINK(chip)           ((chip)->flag & FLIDX_AUTO_DELINK)
+
+#define RTS51X_GET_VID(chip)            ((chip)->vendor_id)
+#define RTS51X_GET_PID(chip)            ((chip)->product_id)
+
+#define FW_VERSION(chip)                ((chip)->status[0].fw_ver)
+#define STATUS_LEN(chip)                ((chip)->status_len)
+
+/* Check card reader function */
+#define SUPPORT_DETAILED_TYPE1(chip)    \
+                CHK_BIT((chip)->status[0].function[0], 1)
+#define SUPPORT_OT(chip)                \
+                CHK_BIT((chip)->status[0].function[0], 2)
+#define SUPPORT_OC(chip)                \
+                CHK_BIT((chip)->status[0].function[0], 3)
+#define SUPPORT_AUTO_DELINK(chip)       \
+                CHK_BIT((chip)->status[0].function[0], 4)
+#define SUPPORT_SDIO(chip)              \
+                CHK_BIT((chip)->status[0].function[1], 0)
+#define SUPPORT_DETAILED_TYPE2(chip)    \
+                CHK_BIT((chip)->status[0].function[1], 1)
+
+#define CHECK_PID(chip, pid)            (RTS51X_GET_PID(chip) == (pid))
+#define CHECK_FW_VER(chip, fw_ver)      (FW_VERSION(chip) == (fw_ver))
+#define CHECK_ID(chip, pid, fw_ver)     \
+                (CHECK_PID((chip), (pid)) && CHECK_FW_VER((chip), (fw_ver)))
+
+#define wait_timeout_x(task_state, msecs)       \
+do {                                            \
+        set_current_state((task_state));        \
+        schedule_timeout((msecs) * HZ / 1000);  \
+} while (0)
+
+#define wait_timeout(msecs)             \
+                wait_timeout_x(TASK_INTERRUPTIBLE, (msecs))
+
+static int init_realtek_cr(struct us_data *us);
+
+/*
+ * The table of devices
+ */
+#define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
+                    vendorName, productName, useProtocol, useTransport, \
+                    initFunction, flags) \
+{\
+        USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
+        .driver_info = (flags)|(USB_US_TYPE_STOR<<24)\
+}
+
+static const struct usb_device_id realtek_cr_ids[] = {
+#       include "unusual_realtek.h"
+        { }             /* Terminating entry */
+};
+MODULE_DEVICE_TABLE(usb, realtek_cr_ids);
+
+#undef UNUSUAL_DEV
+
+/*
+ * The flags table
+ */
+#define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
+                    vendor_name, product_name, use_protocol, use_transport, \
+                    init_function, Flags) \
+{ \
+        .vendorName = vendor_name,      \
+        .productName = product_name,    \
+        .useProtocol = use_protocol,    \
+        .useTransport = use_transport,  \
+        .initFunction = init_function,  \
+}
+
+static struct us_unusual_dev realtek_cr_unusual_dev_list[] = {
+#       include "unusual_realtek.h"
+        { }             /* Terminating entry */
+};
+
+#undef UNUSUAL_DEV
+
+static int rts51x_bulk_transport(struct us_data *us, u8 lun,
+                                 u8 *cmd, int cmd_len, u8 *buf, int buf_len,
+                                 enum dma_data_direction dir, int *act_len)
+{
+        struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
+        struct bulk_cs_wrap *bcs = (struct bulk_cs_wrap *) us->iobuf;
+        int result;
+        unsigned int residue;
+        unsigned int cswlen;
+        unsigned int cbwlen = US_BULK_CB_WRAP_LEN;
+
+        /* set up the command wrapper */
+        bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
+        bcb->DataTransferLength = cpu_to_le32(buf_len);
+        bcb->Flags = (dir == DMA_FROM_DEVICE) ? 1 << 7 : 0;
+        bcb->Tag = ++us->tag;
+        bcb->Lun = lun;
+        bcb->Length = cmd_len;
+
+        /* copy the command payload */
+        memset(bcb->CDB, 0, sizeof(bcb->CDB));
+        memcpy(bcb->CDB, cmd, bcb->Length);
+
+        /* send it to out endpoint */
+        result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe,
+                                bcb, cbwlen, NULL);
+        if (result != USB_STOR_XFER_GOOD)
+                return USB_STOR_TRANSPORT_ERROR;
+
+        /* DATA STAGE */
+        /* send/receive data payload, if there is any */
+
+        if (buf && buf_len) {
+                unsigned int pipe = (dir == DMA_FROM_DEVICE) ?
+                                us->recv_bulk_pipe : us->send_bulk_pipe;
+                result = usb_stor_bulk_transfer_buf(us, pipe,
+                                buf, buf_len, NULL);
+                if (result == USB_STOR_XFER_ERROR)
+                        return USB_STOR_TRANSPORT_ERROR;
+        }
+
+        /* get CSW for device status */
+        result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
+                                bcs, US_BULK_CS_WRAP_LEN, &cswlen);
+        if (result != USB_STOR_XFER_GOOD)
+                return USB_STOR_TRANSPORT_ERROR;
+
+        /* check bulk status */
+        if (bcs->Signature != cpu_to_le32(US_BULK_CS_SIGN)) {
+                US_DEBUGP("Signature mismatch: got %08X, expecting %08X\n",
+                          le32_to_cpu(bcs->Signature),
+                          US_BULK_CS_SIGN);
+                return USB_STOR_TRANSPORT_ERROR;
+        }
+
+        residue = bcs->Residue;
+        if (bcs->Tag != us->tag)
+                return USB_STOR_TRANSPORT_ERROR;
+
+        /* try to compute the actual residue, based on how much data
+         * was really transferred and what the device tells us */
+        if (residue)
+                residue = residue < buf_len ? residue : buf_len;
+
+        if (act_len)
+                *act_len = buf_len - residue;
+
+        /* based on the status code, we report good or bad */
+        switch (bcs->Status) {
+        case US_BULK_STAT_OK:
+                /* command good -- note that data could be short */
+                return USB_STOR_TRANSPORT_GOOD;
+
+        case US_BULK_STAT_FAIL:
+                /* command failed */
+                return USB_STOR_TRANSPORT_FAILED;
+
+        case US_BULK_STAT_PHASE:
+                /* phase error -- note that a transport reset will be
+                        * invoked by the invoke_transport() function
+                        */
+                return USB_STOR_TRANSPORT_ERROR;
+        }
+
+        /* we should never get here, but if we do, we're in trouble */
+        return USB_STOR_TRANSPORT_ERROR;
+}
+
+/* Determine what the maximum LUN supported is */
+static int rts51x_get_max_lun(struct us_data *us)
+{
+        int result;
+
+        /* issue the command */
+        us->iobuf[0] = 0;
+        result = usb_stor_control_msg(us, us->recv_ctrl_pipe,
+                                 US_BULK_GET_MAX_LUN,
+                                 USB_DIR_IN | USB_TYPE_CLASS |
+                                 USB_RECIP_INTERFACE,
+                                 0, us->ifnum, us->iobuf, 1, 10*HZ);
+
+        US_DEBUGP("GetMaxLUN command result is %d, data is %d\n",
+                  result, us->iobuf[0]);
+
+        /* if we have a successful request, return the result */
+        if (result > 0)
+                return us->iobuf[0];
+
+        return 0;
+}
+
+static int rts51x_read_mem(struct us_data *us, u16 addr, u8 *data, u16 len)
+{
+        int retval;
+        u8 cmnd[12] = {0};
+
+        US_DEBUGP("%s, addr = 0x%x, len = %d\n", __func__, addr, len);
+
+        cmnd[0] = 0xF0;
+        cmnd[1] = 0x0D;
+        cmnd[2] = (u8)(addr >> 8);
+        cmnd[3] = (u8)addr;
+        cmnd[4] = (u8)(len >> 8);
+        cmnd[5] = (u8)len;
+
+        retval = rts51x_bulk_transport(us, 0, cmnd, 12,
+                                       data, len, DMA_FROM_DEVICE, NULL);
+        if (retval != USB_STOR_TRANSPORT_GOOD)
+                return -EIO;
+
+        return 0;
+}
+
+static int rts51x_write_mem(struct us_data *us, u16 addr, u8 *data, u16 len)
+{
+        int retval;
+        u8 cmnd[12] = {0};
+
+        US_DEBUGP("%s, addr = 0x%x, len = %d\n", __func__, addr, len);
+
+        cmnd[0] = 0xF0;
+        cmnd[1] = 0x0E;
+        cmnd[2] = (u8)(addr >> 8);
+        cmnd[3] = (u8)addr;
+        cmnd[4] = (u8)(len >> 8);
+        cmnd[5] = (u8)len;
+
+        retval = rts51x_bulk_transport(us, 0, cmnd, 12,
+                                       data, len, DMA_TO_DEVICE, NULL);
+        if (retval != USB_STOR_TRANSPORT_GOOD)
+                return -EIO;
+
+        return 0;
+}
+
+static int rts51x_read_status(struct us_data *us,
+                              u8 lun, u8 *status, int len, int *actlen)
+{
+        int retval;
+        u8 cmnd[12] = {0};
+
+        US_DEBUGP("%s, lun = %d\n", __func__, lun);
+
+        cmnd[0] = 0xF0;
+        cmnd[1] = 0x09;
+
+        retval = rts51x_bulk_transport(us, lun, cmnd, 12,
+                                       status, len, DMA_FROM_DEVICE, actlen);
+        if (retval != USB_STOR_TRANSPORT_GOOD)
+                return -EIO;
+
+        return 0;
+}
+
+static int rts51x_check_status(struct us_data *us, u8 lun)
+{
+        struct rts51x_chip *chip = (struct rts51x_chip *)(us->extra);
+        int retval;
+        u8 buf[16];
+
+        retval = rts51x_read_status(us, lun, buf, 16, &(chip->status_len));
+        if (retval < 0)
+                return -EIO;
+
+        US_DEBUGP("chip->status_len = %d\n", chip->status_len);
+
+        chip->status[lun].vid = ((u16)buf[0] << 8) | buf[1];
+        chip->status[lun].pid = ((u16)buf[2] << 8) | buf[3];
+        chip->status[lun].cur_lun = buf[4];
+        chip->status[lun].card_type = buf[5];
+        chip->status[lun].total_lun = buf[6];
+        chip->status[lun].fw_ver = ((u16)buf[7] << 8) | buf[8];
+        chip->status[lun].phy_exist = buf[9];
+        chip->status[lun].multi_flag = buf[10];
+        chip->status[lun].multi_card = buf[11];
+        chip->status[lun].log_exist = buf[12];
+        if (chip->status_len == 16) {
+                chip->status[lun].detailed_type.detailed_type1 = buf[13];
+                chip->status[lun].function[0] = buf[14];
+                chip->status[lun].function[1] = buf[15];
+        }
+
+        return 0;
+}
+
+static int enable_oscillator(struct us_data *us)
+{
+        int retval;
+        u8 value;
+
+        retval = rts51x_read_mem(us, 0xFE77, &value, 1);
+        if (retval < 0)
+                return -EIO;
+
+        value |= 0x04;
+        retval = rts51x_write_mem(us, 0xFE77, &value, 1);
+        if (retval < 0)
+                return -EIO;
+
+        retval = rts51x_read_mem(us, 0xFE77, &value, 1);
+        if (retval < 0)
+                return -EIO;
+
+        if (!(value & 0x04))
+                return -EIO;
+
+        return 0;
+}
+
+static int do_config_autodelink(struct us_data *us, int enable, int force)
+{
+        int retval;
+        u8 value;
+
+        retval = rts51x_read_mem(us, 0xFE47, &value, 1);
+        if (retval < 0)
+                return -EIO;
+
+        if (enable) {
+                if (force)
+                        value |= 0x03;
+                else
+                        value |= 0x01;
+        } else {
+                value &= ~0x03;
+        }
+
+        US_DEBUGP("In %s,set 0xfe47 to 0x%x\n", __func__, value);
+
+        retval = rts51x_write_mem(us, 0xFE47, &value, 1);
+        if (retval < 0)
+                return -EIO;
+
+        return 0;
+}
+
+static int config_autodelink_after_power_on(struct us_data *us)
+{
+        struct rts51x_chip *chip = (struct rts51x_chip *)(us->extra);
+        int retval;
+        u8 value;
+
+        if (!CHK_AUTO_DELINK(chip))
+                return 0;
+
+        retval = rts51x_read_mem(us, 0xFE47, &value, 1);
+        if (retval < 0)
+                return -EIO;
+
+        if (auto_delink_en) {
+                CLR_BIT(value, 0);
+                CLR_BIT(value, 1);
+                SET_BIT(value, 2);
+
+                if (CHECK_ID(chip, 0x0138, 0x3882))
+                        CLR_BIT(value, 2);
+
+                SET_BIT(value, 7);
+
+                retval = rts51x_write_mem(us, 0xFE47, &value, 1);
+                if (retval < 0)
+                        return -EIO;
+
+                retval = enable_oscillator(us);
+                if (retval == 0)
+                        (void)do_config_autodelink(us, 1, 0);
+        } else {
+                /* Autodelink controlled by firmware */
+
+                SET_BIT(value, 2);
+
+                if (CHECK_ID(chip, 0x0138, 0x3882))
+                        CLR_BIT(value, 2);
+
+                if (CHECK_ID(chip, 0x0159, 0x5889) ||
+                                CHECK_ID(chip, 0x0138, 0x3880)) {
+                        CLR_BIT(value, 0);
+                        CLR_BIT(value, 7);
+                }
+
+                retval = rts51x_write_mem(us, 0xFE47, &value, 1);
+                if (retval < 0)
+                        return -EIO;
+
+                if (CHECK_ID(chip, 0x0159, 0x5888)) {
+                        value = 0xFF;
+                        retval = rts51x_write_mem(us, 0xFE79, &value, 1);
+                        if (retval < 0)
+                                return -EIO;
+
+                        value = 0x01;
+                        retval = rts51x_write_mem(us, 0x48, &value, 1);
+                        if (retval < 0)
+                                return -EIO;
+                }
+        }
+
+        return 0;
+}
+
+static int config_autodelink_before_power_down(struct us_data *us)
+{
+        struct rts51x_chip *chip = (struct rts51x_chip *)(us->extra);
+        int retval;
+        u8 value;
+
+        if (!CHK_AUTO_DELINK(chip))
+                return 0;
+
+        if (auto_delink_en) {
+                retval = rts51x_read_mem(us, 0xFE77, &value, 1);
+                if (retval < 0)
+                        return -EIO;
+
+                SET_BIT(value, 2);
+                retval = rts51x_write_mem(us, 0xFE77, &value, 1);
+                if (retval < 0)
+                        return -EIO;
+
+                if (CHECK_ID(chip, 0x0159, 0x5888)) {
+                        value = 0x01;
+                        retval = rts51x_write_mem(us, 0x48, &value, 1);
+                        if (retval < 0)
+                                return -EIO;
+                }
+
+                retval = rts51x_read_mem(us, 0xFE47, &value, 1);
+                if (retval < 0)
+                        return -EIO;
+
+                SET_BIT(value, 0);
+                if (CHECK_ID(chip, 0x0138, 0x3882))
+                        SET_BIT(value, 2);
+                retval = rts51x_write_mem(us, 0xFE77, &value, 1);
+                if (retval < 0)
+                        return -EIO;
+        } else {
+                if (CHECK_ID(chip, 0x0159, 0x5889) ||
+                                CHECK_ID(chip, 0x0138, 0x3880) ||
+                                CHECK_ID(chip, 0x0138, 0x3882)) {
+                        retval = rts51x_read_mem(us, 0xFE47, &value, 1);
+                        if (retval < 0)
+                                return -EIO;
+
+                        if (CHECK_ID(chip, 0x0159, 0x5889) ||
+                                        CHECK_ID(chip, 0x0138, 0x3880)) {
+                                SET_BIT(value, 0);
+                                SET_BIT(value, 7);
+                        }
+
+                        if (CHECK_ID(chip, 0x0138, 0x3882))
+                                SET_BIT(value, 2);
+
+                        retval = rts51x_write_mem(us, 0xFE47, &value, 1);
+                        if (retval < 0)
+                                return -EIO;
+                }
+
+                if (CHECK_ID(chip, 0x0159, 0x5888)) {
+                        value = 0x01;
+                        retval = rts51x_write_mem(us, 0x48, &value, 1);
+                        if (retval < 0)
+                                return -EIO;
+                }
+        }
+
+        return 0;
+}
+
+static void realtek_cr_destructor(void *extra)
+{
+        struct rts51x_chip *chip = (struct rts51x_chip *)extra;
+
+        if (!chip)
+                return;
+
+        kfree(chip->status);
+}
+
+#ifdef CONFIG_PM
+static void realtek_pm_hook(struct us_data *us, int pm_state)
+{
+        if (pm_state == US_SUSPEND)
+                (void)config_autodelink_before_power_down(us);
+}
+#endif
+
+static int init_realtek_cr(struct us_data *us)
+{
+        struct rts51x_chip *chip;
+        int size, i, retval;
+
+        chip = kzalloc(sizeof(struct rts51x_chip), GFP_KERNEL);
+        if (!chip)
+                return -ENOMEM;
+
+        us->extra = chip;
+        us->extra_destructor = realtek_cr_destructor;
+#ifdef CONFIG_PM
+        us->suspend_resume_hook = realtek_pm_hook;
+#endif
+
+        us->max_lun = chip->max_lun = rts51x_get_max_lun(us);
+
+        US_DEBUGP("chip->max_lun = %d\n", chip->max_lun);
+
+        size = (chip->max_lun + 1) * sizeof(struct rts51x_status);
+        chip->status = kzalloc(size, GFP_KERNEL);
+        if (!chip->status)
+                goto INIT_FAIL;
+
+        for (i = 0; i <= (int)(chip->max_lun); i++) {
+                retval = rts51x_check_status(us, (u8)i);
+                if (retval < 0)
+                        goto INIT_FAIL;
+        }
+
+        if (CHECK_FW_VER(chip, 0x5888) || CHECK_FW_VER(chip, 0x5889) ||
+                        CHECK_FW_VER(chip, 0x5901))
+                SET_AUTO_DELINK(chip);
+        if (STATUS_LEN(chip) == 16) {
+                if (SUPPORT_AUTO_DELINK(chip))
+                        SET_AUTO_DELINK(chip);
+        }
+
+        US_DEBUGP("chip->flag = 0x%x\n", chip->flag);
+
+        (void)config_autodelink_after_power_on(us);
+
+        return 0;
+
+INIT_FAIL:
+        if (us->extra) {
+                kfree(chip->status);
+                kfree(us->extra);
+                us->extra = NULL;
+        }
+
+        return -EIO;
+}
+
+static int realtek_cr_probe(struct usb_interface *intf,
+                         const struct usb_device_id *id)
+{
+        struct us_data *us;
+        int result;
+
+        US_DEBUGP("Probe Realtek Card Reader!\n");
+
+        result = usb_stor_probe1(&us, intf, id,
+                        (id - realtek_cr_ids) + realtek_cr_unusual_dev_list);
+        if (result)
+                return result;
+
+        result = usb_stor_probe2(us);
+        return result;
+}
+
+static struct usb_driver realtek_cr_driver = {
+        .name =         "ums-realtek",
+        .probe =        realtek_cr_probe,
+        .disconnect =   usb_stor_disconnect,
+        .suspend =      usb_stor_suspend,
+        .resume =       usb_stor_resume,
+        .reset_resume = usb_stor_reset_resume,
+        .pre_reset =    usb_stor_pre_reset,
+        .post_reset =   usb_stor_post_reset,
+        .id_table =     realtek_cr_ids,
+        .soft_unbind =  1,
+};
+
+static int __init realtek_cr_init(void)
+{
+        return usb_register(&realtek_cr_driver);
+}
+
+static void __exit realtek_cr_exit(void)
+{
+        usb_deregister(&realtek_cr_driver);
+}
+
+module_init(realtek_cr_init);
+module_exit(realtek_cr_exit);
diff --git a/drivers/usb/storage/scsiglue.c b/drivers/usb/storage/scsiglue.c
index d8d98cfecada..13b8bcdf3dba 100644
--- a/drivers/usb/storage/scsiglue.c
+++ b/drivers/usb/storage/scsiglue.c
@@ -113,7 +113,7 @@ static int slave_alloc (struct scsi_device *sdev)
          * Let the scanning code know if this target merely sets
          * Peripheral Device Type to 0x1f to indicate no LUN.
          */
-        if (us->subclass == US_SC_UFI)
+        if (us->subclass == USB_SC_UFI)
                 sdev->sdev_target->pdt_1f_for_no_lun = 1;
 
         return 0;
@@ -123,7 +123,7 @@ static int slave_configure(struct scsi_device *sdev)
 {
         struct us_data *us = host_to_us(sdev->host);
 
-        /* Many devices have trouble transfering more than 32KB at a time,
+        /* Many devices have trouble transferring more than 32KB at a time,
          * while others have trouble with more than 64K. At this time we
          * are limiting both to 32K (64 sectores).
          */
@@ -176,7 +176,7 @@ static int slave_configure(struct scsi_device *sdev)
                 /* Disk-type devices use MODE SENSE(6) if the protocol
                  * (SubClass) is Transparent SCSI, otherwise they use
                  * MODE SENSE(10). */
-                if (us->subclass != US_SC_SCSI && us->subclass != US_SC_CYP_ATACB)
+                if (us->subclass != USB_SC_SCSI && us->subclass != USB_SC_CYP_ATACB)
                         sdev->use_10_for_ms = 1;
 
                 /* Many disks only accept MODE SENSE transfer lengths of
@@ -209,6 +209,10 @@ static int slave_configure(struct scsi_device *sdev)
                 if (us->fflags & US_FL_CAPACITY_HEURISTICS)
                         sdev->guess_capacity = 1;
 
+                /* Some devices cannot handle READ_CAPACITY_16 */
+                if (us->fflags & US_FL_NO_READ_CAPACITY_16)
+                        sdev->no_read_capacity_16 = 1;
+
                 /* assume SPC3 or latter devices support sense size > 18 */
                 if (sdev->scsi_level > SCSI_SPC_2)
                         us->fflags |= US_FL_SANE_SENSE;
@@ -245,7 +249,7 @@ static int slave_configure(struct scsi_device *sdev)
                  * capacity will be decremented or is correct. */
                 if (!(us->fflags & (US_FL_FIX_CAPACITY | US_FL_CAPACITY_OK |
                                         US_FL_SCM_MULT_TARG)) &&
-                                us->protocol == US_PR_BULK)
+                                us->protocol == USB_PR_BULK)
                         us->use_last_sector_hacks = 1;
         } else {
 
@@ -253,6 +257,10 @@ static int slave_configure(struct scsi_device *sdev)
                  * or to force 192-byte transfer lengths for MODE SENSE.
                  * But they do need to use MODE SENSE(10). */
                 sdev->use_10_for_ms = 1;
+
+                /* Some (fake) usb cdrom devices don't like READ_DISC_INFO */
+                if (us->fflags & US_FL_NO_READ_DISC_INFO)
+                        sdev->no_read_disc_info = 1;
         }
 
         /* The CB and CBI transports have no way to pass LUN values
@@ -261,7 +269,7 @@ static int slave_configure(struct scsi_device *sdev)
          * scsi_level == 0 (UNKNOWN).  Hence such devices must necessarily
          * be single-LUN.
          */
-        if ((us->protocol == US_PR_CB || us->protocol == US_PR_CBI) &&
+        if ((us->protocol == USB_PR_CB || us->protocol == USB_PR_CBI) &&
                         sdev->scsi_level == SCSI_UNKNOWN)
                 us->max_lun = 0;
 
@@ -277,7 +285,7 @@ static int slave_configure(struct scsi_device *sdev)
 
 /* queue a command */
 /* This is always called with scsi_lock(host) held */
-static int queuecommand(struct scsi_cmnd *srb,
+static int queuecommand_lck(struct scsi_cmnd *srb,
                         void (*done)(struct scsi_cmnd *))
 {
         struct us_data *us = host_to_us(srb->device->host);
@@ -307,6 +315,8 @@ static int queuecommand(struct scsi_cmnd *srb,
         return 0;
 }
 
+static DEF_SCSI_QCMD(queuecommand)
+
 /***********************************************************************
  * Error handling functions
  ***********************************************************************/
diff --git a/drivers/usb/storage/sddr09.c b/drivers/usb/storage/sddr09.c
index ab5f9f37575a..bcb9a709d349 100644
--- a/drivers/usb/storage/sddr09.c
+++ b/drivers/usb/storage/sddr09.c
@@ -1760,7 +1760,7 @@ static int sddr09_probe(struct usb_interface *intf,
         if (result)
                 return result;
 
-        if (us->protocol == US_PR_DPCM_USB) {
+        if (us->protocol == USB_PR_DPCM_USB) {
                 us->transport_name = "Control/Bulk-EUSB/SDDR09";
                 us->transport = dpcm_transport;
                 us->transport_reset = usb_stor_CB_reset;
diff --git a/drivers/usb/storage/shuttle_usbat.c b/drivers/usb/storage/shuttle_usbat.c
index bd3f415893d8..0b00091d2ae9 100644
--- a/drivers/usb/storage/shuttle_usbat.c
+++ b/drivers/usb/storage/shuttle_usbat.c
@@ -340,7 +340,7 @@ static int usbat_check_status(struct us_data *us)
 }
 
 /*
- * Stores critical information in internal registers in prepartion for the execution
+ * Stores critical information in internal registers in preparation for the execution
  * of a conditional usbat_read_blocks or usbat_write_blocks call.
  */
 static int usbat_set_shuttle_features(struct us_data *us,
diff --git a/drivers/usb/storage/sierra_ms.c b/drivers/usb/storage/sierra_ms.c
index 57fc2f532cab..1deca07c8265 100644
--- a/drivers/usb/storage/sierra_ms.c
+++ b/drivers/usb/storage/sierra_ms.c
@@ -121,18 +121,16 @@ static ssize_t show_truinst(struct device *dev, struct device_attribute *attr,
         }
         return result;
 }
-static DEVICE_ATTR(truinst, S_IWUGO | S_IRUGO, show_truinst, NULL);
+static DEVICE_ATTR(truinst, S_IRUGO, show_truinst, NULL);
 
 int sierra_ms_init(struct us_data *us)
 {
         int result, retries;
-        signed long delay_t;
         struct swoc_info *swocInfo;
         struct usb_device *udev;
         struct Scsi_Host *sh;
         struct scsi_device *sd;
 
-        delay_t = 2;
         retries = 3;
         result = 0;
         udev = us->pusb_dev;
diff --git a/drivers/usb/storage/transport.c b/drivers/usb/storage/transport.c
index 64ec073e89de..e8ae21b2d387 100644
--- a/drivers/usb/storage/transport.c
+++ b/drivers/usb/storage/transport.c
@@ -642,7 +642,7 @@ void usb_stor_invoke_transport(struct scsi_cmnd *srb, struct us_data *us)
          * unless the operation involved a data-in transfer.  Devices
          * can signal most data-in errors by stalling the bulk-in pipe.
          */
-        if ((us->protocol == US_PR_CB || us->protocol == US_PR_DPCM_USB) &&
+        if ((us->protocol == USB_PR_CB || us->protocol == USB_PR_DPCM_USB) &&
                         srb->sc_data_direction != DMA_FROM_DEVICE) {
                 US_DEBUGP("-- CB transport device requiring auto-sense\n");
                 need_auto_sense = 1;
@@ -701,8 +701,8 @@ Retry_Sense:
                 scsi_eh_prep_cmnd(srb, &ses, NULL, 0, sense_size);
 
                 /* FIXME: we must do the protocol translation here */
-                if (us->subclass == US_SC_RBC || us->subclass == US_SC_SCSI ||
-                                us->subclass == US_SC_CYP_ATACB)
+                if (us->subclass == USB_SC_RBC || us->subclass == USB_SC_SCSI ||
+                                us->subclass == USB_SC_CYP_ATACB)
                         srb->cmd_len = 6;
                 else
                         srb->cmd_len = 12;
@@ -819,6 +819,35 @@ Retry_Sense:
                 }
         }
 
+        /*
+         * Some devices don't work or return incorrect data the first
+         * time they get a READ(10) command, or for the first READ(10)
+         * after a media change.  If the INITIAL_READ10 flag is set,
+         * keep track of whether READ(10) commands succeed.  If the
+         * previous one succeeded and this one failed, set the REDO_READ10
+         * flag to force a retry.
+         */
+        if (unlikely((us->fflags & US_FL_INITIAL_READ10) &&
+                        srb->cmnd[0] == READ_10)) {
+                if (srb->result == SAM_STAT_GOOD) {
+                        set_bit(US_FLIDX_READ10_WORKED, &us->dflags);
+                } else if (test_bit(US_FLIDX_READ10_WORKED, &us->dflags)) {
+                        clear_bit(US_FLIDX_READ10_WORKED, &us->dflags);
+                        set_bit(US_FLIDX_REDO_READ10, &us->dflags);
+                }
+
+                /*
+                 * Next, if the REDO_READ10 flag is set, return a result
+                 * code that will cause the SCSI core to retry the READ(10)
+                 * command immediately.
+                 */
+                if (test_bit(US_FLIDX_REDO_READ10, &us->dflags)) {
+                        clear_bit(US_FLIDX_REDO_READ10, &us->dflags);
+                        srb->result = DID_IMM_RETRY << 16;
+                        srb->sense_buffer[0] = 0;
+                }
+        }
+
         /* Did we transfer less than the minimum amount required? */
         if ((srb->result == SAM_STAT_GOOD || srb->sense_buffer[2] == 0) &&
                         scsi_bufflen(srb) - scsi_get_resid(srb) < srb->underflow)
@@ -926,7 +955,7 @@ int usb_stor_CB_transport(struct scsi_cmnd *srb, struct us_data *us)
         /* NOTE: CB does not have a status stage.  Silly, I know.  So
          * we have to catch this at a higher level.
          */
-        if (us->protocol != US_PR_CBI)
+        if (us->protocol != USB_PR_CBI)
                 return USB_STOR_TRANSPORT_GOOD;
 
         result = usb_stor_intr_transfer(us, us->iobuf, 2);
@@ -942,7 +971,7 @@ int usb_stor_CB_transport(struct scsi_cmnd *srb, struct us_data *us)
          * that this means we could be ignoring a real error on these
          * commands, but that can't be helped.
          */
-        if (us->subclass == US_SC_UFI) {
+        if (us->subclass == USB_SC_UFI) {
                 if (srb->cmnd[0] == REQUEST_SENSE ||
                     srb->cmnd[0] == INQUIRY)
                         return USB_STOR_TRANSPORT_GOOD;
diff --git a/drivers/usb/storage/uas.c b/drivers/usb/storage/uas.c
new file mode 100644
index 000000000000..23f0dd9c36d4
--- /dev/null
+++ b/drivers/usb/storage/uas.c
@@ -0,0 +1,776 @@
+/*
+ * USB Attached SCSI
+ * Note that this is not the same as the USB Mass Storage driver
+ *
+ * Copyright Matthew Wilcox for Intel Corp, 2010
+ * Copyright Sarah Sharp for Intel Corp, 2010
+ *
+ * Distributed under the terms of the GNU GPL, version two.
+ */
+
+#include <linux/blkdev.h>
+#include <linux/slab.h>
+#include <linux/types.h>
+#include <linux/usb.h>
+#include <linux/usb/storage.h>
+
+#include <scsi/scsi.h>
+#include <scsi/scsi_dbg.h>
+#include <scsi/scsi_cmnd.h>
+#include <scsi/scsi_device.h>
+#include <scsi/scsi_host.h>
+#include <scsi/scsi_tcq.h>
+
+/* Common header for all IUs */
+struct iu {
+        __u8 iu_id;
+        __u8 rsvd1;
+        __be16 tag;
+};
+
+enum {
+        IU_ID_COMMAND           = 0x01,
+        IU_ID_STATUS            = 0x03,
+        IU_ID_RESPONSE          = 0x04,
+        IU_ID_TASK_MGMT         = 0x05,
+        IU_ID_READ_READY        = 0x06,
+        IU_ID_WRITE_READY       = 0x07,
+};
+
+struct command_iu {
+        __u8 iu_id;
+        __u8 rsvd1;
+        __be16 tag;
+        __u8 prio_attr;
+        __u8 rsvd5;
+        __u8 len;
+        __u8 rsvd7;
+        struct scsi_lun lun;
+        __u8 cdb[16];   /* XXX: Overflow-checking tools may misunderstand */
+};
+
+/*
+ * Also used for the Read Ready and Write Ready IUs since they have the
+ * same first four bytes
+ */
+struct sense_iu {
+        __u8 iu_id;
+        __u8 rsvd1;
+        __be16 tag;
+        __be16 status_qual;
+        __u8 status;
+        __u8 rsvd7[7];
+        __be16 len;
+        __u8 sense[SCSI_SENSE_BUFFERSIZE];
+};
+
+/*
+ * The r00-r01c specs define this version of the SENSE IU data structure.
+ * It's still in use by several different firmware releases.
+ */
+struct sense_iu_old {
+        __u8 iu_id;
+        __u8 rsvd1;
+        __be16 tag;
+        __be16 len;
+        __u8 status;
+        __u8 service_response;
+        __u8 sense[SCSI_SENSE_BUFFERSIZE];
+};
+
+enum {
+        CMD_PIPE_ID             = 1,
+        STATUS_PIPE_ID          = 2,
+        DATA_IN_PIPE_ID         = 3,
+        DATA_OUT_PIPE_ID        = 4,
+
+        UAS_SIMPLE_TAG          = 0,
+        UAS_HEAD_TAG            = 1,
+        UAS_ORDERED_TAG         = 2,
+        UAS_ACA                 = 4,
+};
+
+struct uas_dev_info {
+        struct usb_interface *intf;
+        struct usb_device *udev;
+        int qdepth;
+        unsigned cmd_pipe, status_pipe, data_in_pipe, data_out_pipe;
+        unsigned use_streams:1;
+        unsigned uas_sense_old:1;
+};
+
+enum {
+        ALLOC_STATUS_URB        = (1 << 0),
+        SUBMIT_STATUS_URB       = (1 << 1),
+        ALLOC_DATA_IN_URB       = (1 << 2),
+        SUBMIT_DATA_IN_URB      = (1 << 3),
+        ALLOC_DATA_OUT_URB      = (1 << 4),
+        SUBMIT_DATA_OUT_URB     = (1 << 5),
+        ALLOC_CMD_URB           = (1 << 6),
+        SUBMIT_CMD_URB          = (1 << 7),
+};
+
+/* Overrides scsi_pointer */
+struct uas_cmd_info {
+        unsigned int state;
+        unsigned int stream;
+        struct urb *cmd_urb;
+        struct urb *status_urb;
+        struct urb *data_in_urb;
+        struct urb *data_out_urb;
+        struct list_head list;
+};
+
+/* I hate forward declarations, but I actually have a loop */
+static int uas_submit_urbs(struct scsi_cmnd *cmnd,
+                                struct uas_dev_info *devinfo, gfp_t gfp);
+
+static DEFINE_SPINLOCK(uas_work_lock);
+static LIST_HEAD(uas_work_list);
+
+static void uas_do_work(struct work_struct *work)
+{
+        struct uas_cmd_info *cmdinfo;
+        struct list_head list;
+
+        spin_lock_irq(&uas_work_lock);
+        list_replace_init(&uas_work_list, &list);
+        spin_unlock_irq(&uas_work_lock);
+
+        list_for_each_entry(cmdinfo, &list, list) {
+                struct scsi_pointer *scp = (void *)cmdinfo;
+                struct scsi_cmnd *cmnd = container_of(scp,
+                                                        struct scsi_cmnd, SCp);
+                uas_submit_urbs(cmnd, cmnd->device->hostdata, GFP_NOIO);
+        }
+}
+
+static DECLARE_WORK(uas_work, uas_do_work);
+
+static void uas_sense(struct urb *urb, struct scsi_cmnd *cmnd)
+{
+        struct sense_iu *sense_iu = urb->transfer_buffer;
+        struct scsi_device *sdev = cmnd->device;
+
+        if (urb->actual_length > 16) {
+                unsigned len = be16_to_cpup(&sense_iu->len);
+                if (len + 16 != urb->actual_length) {
+                        int newlen = min(len + 16, urb->actual_length) - 16;
+                        if (newlen < 0)
+                                newlen = 0;
+                        sdev_printk(KERN_INFO, sdev, "%s: urb length %d "
+                                "disagrees with IU sense data length %d, "
+                                "using %d bytes of sense data\n", __func__,
+                                        urb->actual_length, len, newlen);
+                        len = newlen;
+                }
+                memcpy(cmnd->sense_buffer, sense_iu->sense, len);
+        }
+
+        cmnd->result = sense_iu->status;
+        if (sdev->current_cmnd)
+                sdev->current_cmnd = NULL;
+        cmnd->scsi_done(cmnd);
+        usb_free_urb(urb);
+}
+
+static void uas_sense_old(struct urb *urb, struct scsi_cmnd *cmnd)
+{
+        struct sense_iu_old *sense_iu = urb->transfer_buffer;
+        struct scsi_device *sdev = cmnd->device;
+
+        if (urb->actual_length > 8) {
+                unsigned len = be16_to_cpup(&sense_iu->len) - 2;
+                if (len + 8 != urb->actual_length) {
+                        int newlen = min(len + 8, urb->actual_length) - 8;
+                        if (newlen < 0)
+                                newlen = 0;
+                        sdev_printk(KERN_INFO, sdev, "%s: urb length %d "
+                                "disagrees with IU sense data length %d, "
+                                "using %d bytes of sense data\n", __func__,
+                                        urb->actual_length, len, newlen);
+                        len = newlen;
+                }
+                memcpy(cmnd->sense_buffer, sense_iu->sense, len);
+        }
+
+        cmnd->result = sense_iu->status;
+        if (sdev->current_cmnd)
+                sdev->current_cmnd = NULL;
+        cmnd->scsi_done(cmnd);
+        usb_free_urb(urb);
+}
+
+static void uas_xfer_data(struct urb *urb, struct scsi_cmnd *cmnd,
+                                                        unsigned direction)
+{
+        struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp;
+        int err;
+
+        cmdinfo->state = direction | SUBMIT_STATUS_URB;
+        err = uas_submit_urbs(cmnd, cmnd->device->hostdata, GFP_ATOMIC);
+        if (err) {
+                spin_lock(&uas_work_lock);
+                list_add_tail(&cmdinfo->list, &uas_work_list);
+                spin_unlock(&uas_work_lock);
+                schedule_work(&uas_work);
+        }
+}
+
+static void uas_stat_cmplt(struct urb *urb)
+{
+        struct iu *iu = urb->transfer_buffer;
+        struct scsi_device *sdev = urb->context;
+        struct uas_dev_info *devinfo = sdev->hostdata;
+        struct scsi_cmnd *cmnd;
+        u16 tag;
+
+        if (urb->status) {
+                dev_err(&urb->dev->dev, "URB BAD STATUS %d\n", urb->status);
+                usb_free_urb(urb);
+                return;
+        }
+
+        tag = be16_to_cpup(&iu->tag) - 1;
+        if (sdev->current_cmnd)
+                cmnd = sdev->current_cmnd;
+        else
+                cmnd = scsi_find_tag(sdev, tag);
+        if (!cmnd)
+                return;
+
+        switch (iu->iu_id) {
+        case IU_ID_STATUS:
+                if (urb->actual_length < 16)
+                        devinfo->uas_sense_old = 1;
+                if (devinfo->uas_sense_old)
+                        uas_sense_old(urb, cmnd);
+                else
+                        uas_sense(urb, cmnd);
+                break;
+        case IU_ID_READ_READY:
+                uas_xfer_data(urb, cmnd, SUBMIT_DATA_IN_URB);
+                break;
+        case IU_ID_WRITE_READY:
+                uas_xfer_data(urb, cmnd, SUBMIT_DATA_OUT_URB);
+                break;
+        default:
+                scmd_printk(KERN_ERR, cmnd,
+                        "Bogus IU (%d) received on status pipe\n", iu->iu_id);
+        }
+}
+
+static void uas_data_cmplt(struct urb *urb)
+{
+        struct scsi_data_buffer *sdb = urb->context;
+        sdb->resid = sdb->length - urb->actual_length;
+        usb_free_urb(urb);
+}
+
+static struct urb *uas_alloc_data_urb(struct uas_dev_info *devinfo, gfp_t gfp,
+                                unsigned int pipe, u16 stream_id,
+                                struct scsi_data_buffer *sdb,
+                                enum dma_data_direction dir)
+{
+        struct usb_device *udev = devinfo->udev;
+        struct urb *urb = usb_alloc_urb(0, gfp);
+
+        if (!urb)
+                goto out;
+        usb_fill_bulk_urb(urb, udev, pipe, NULL, sdb->length, uas_data_cmplt,
+                                                                        sdb);
+        if (devinfo->use_streams)
+                urb->stream_id = stream_id;
+        urb->num_sgs = udev->bus->sg_tablesize ? sdb->table.nents : 0;
+        urb->sg = sdb->table.sgl;
+ out:
+        return urb;
+}
+
+static struct urb *uas_alloc_sense_urb(struct uas_dev_info *devinfo, gfp_t gfp,
+                                        struct scsi_cmnd *cmnd, u16 stream_id)
+{
+        struct usb_device *udev = devinfo->udev;
+        struct urb *urb = usb_alloc_urb(0, gfp);
+        struct sense_iu *iu;
+
+        if (!urb)
+                goto out;
+
+        iu = kzalloc(sizeof(*iu), gfp);
+        if (!iu)
+                goto free;
+
+        usb_fill_bulk_urb(urb, udev, devinfo->status_pipe, iu, sizeof(*iu),
+                                                uas_stat_cmplt, cmnd->device);
+        urb->stream_id = stream_id;
+        urb->transfer_flags |= URB_FREE_BUFFER;
+ out:
+        return urb;
+ free:
+        usb_free_urb(urb);
+        return NULL;
+}
+
+static struct urb *uas_alloc_cmd_urb(struct uas_dev_info *devinfo, gfp_t gfp,
+                                        struct scsi_cmnd *cmnd, u16 stream_id)
+{
+        struct usb_device *udev = devinfo->udev;
+        struct scsi_device *sdev = cmnd->device;
+        struct urb *urb = usb_alloc_urb(0, gfp);
+        struct command_iu *iu;
+        int len;
+
+        if (!urb)
+                goto out;
+
+        len = cmnd->cmd_len - 16;
+        if (len < 0)
+                len = 0;
+        len = ALIGN(len, 4);
+        iu = kzalloc(sizeof(*iu) + len, gfp);
+        if (!iu)
+                goto free;
+
+        iu->iu_id = IU_ID_COMMAND;
+        iu->tag = cpu_to_be16(stream_id);
+        iu->prio_attr = UAS_SIMPLE_TAG;
+        iu->len = len;
+        int_to_scsilun(sdev->lun, &iu->lun);
+        memcpy(iu->cdb, cmnd->cmnd, cmnd->cmd_len);
+
+        usb_fill_bulk_urb(urb, udev, devinfo->cmd_pipe, iu, sizeof(*iu) + len,
+                                                        usb_free_urb, NULL);
+        urb->transfer_flags |= URB_FREE_BUFFER;
+ out:
+        return urb;
+ free:
+        usb_free_urb(urb);
+        return NULL;
+}
+
+/*
+ * Why should I request the Status IU before sending the Command IU?  Spec
+ * says to, but also says the device may receive them in any order.  Seems
+ * daft to me.
+ */
+
+static int uas_submit_urbs(struct scsi_cmnd *cmnd,
+                                        struct uas_dev_info *devinfo, gfp_t gfp)
+{
+        struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp;
+
+        if (cmdinfo->state & ALLOC_STATUS_URB) {
+                cmdinfo->status_urb = uas_alloc_sense_urb(devinfo, gfp, cmnd,
+                                                          cmdinfo->stream);
+                if (!cmdinfo->status_urb)
+                        return SCSI_MLQUEUE_DEVICE_BUSY;
+                cmdinfo->state &= ~ALLOC_STATUS_URB;
+        }
+
+        if (cmdinfo->state & SUBMIT_STATUS_URB) {
+                if (usb_submit_urb(cmdinfo->status_urb, gfp)) {
+                        scmd_printk(KERN_INFO, cmnd,
+                                        "sense urb submission failure\n");
+                        return SCSI_MLQUEUE_DEVICE_BUSY;
+                }
+                cmdinfo->state &= ~SUBMIT_STATUS_URB;
+        }
+
+        if (cmdinfo->state & ALLOC_DATA_IN_URB) {
+                cmdinfo->data_in_urb = uas_alloc_data_urb(devinfo, gfp,
+                                        devinfo->data_in_pipe, cmdinfo->stream,
+                                        scsi_in(cmnd), DMA_FROM_DEVICE);
+                if (!cmdinfo->data_in_urb)
+                        return SCSI_MLQUEUE_DEVICE_BUSY;
+                cmdinfo->state &= ~ALLOC_DATA_IN_URB;
+        }
+
+        if (cmdinfo->state & SUBMIT_DATA_IN_URB) {
+                if (usb_submit_urb(cmdinfo->data_in_urb, gfp)) {
+                        scmd_printk(KERN_INFO, cmnd,
+                                        "data in urb submission failure\n");
+                        return SCSI_MLQUEUE_DEVICE_BUSY;
+                }
+                cmdinfo->state &= ~SUBMIT_DATA_IN_URB;
+        }
+
+        if (cmdinfo->state & ALLOC_DATA_OUT_URB) {
+                cmdinfo->data_out_urb = uas_alloc_data_urb(devinfo, gfp,
+                                        devinfo->data_out_pipe, cmdinfo->stream,
+                                        scsi_out(cmnd), DMA_TO_DEVICE);
+                if (!cmdinfo->data_out_urb)
+                        return SCSI_MLQUEUE_DEVICE_BUSY;
+                cmdinfo->state &= ~ALLOC_DATA_OUT_URB;
+        }
+
+        if (cmdinfo->state & SUBMIT_DATA_OUT_URB) {
+                if (usb_submit_urb(cmdinfo->data_out_urb, gfp)) {
+                        scmd_printk(KERN_INFO, cmnd,
+                                        "data out urb submission failure\n");
+                        return SCSI_MLQUEUE_DEVICE_BUSY;
+                }
+                cmdinfo->state &= ~SUBMIT_DATA_OUT_URB;
+        }
+
+        if (cmdinfo->state & ALLOC_CMD_URB) {
+                cmdinfo->cmd_urb = uas_alloc_cmd_urb(devinfo, gfp, cmnd,
+                                                        cmdinfo->stream);
+                if (!cmdinfo->cmd_urb)
+                        return SCSI_MLQUEUE_DEVICE_BUSY;
+                cmdinfo->state &= ~ALLOC_CMD_URB;
+        }
+
+        if (cmdinfo->state & SUBMIT_CMD_URB) {
+                if (usb_submit_urb(cmdinfo->cmd_urb, gfp)) {
+                        scmd_printk(KERN_INFO, cmnd,
+                                        "cmd urb submission failure\n");
+                        return SCSI_MLQUEUE_DEVICE_BUSY;
+                }
+                cmdinfo->state &= ~SUBMIT_CMD_URB;
+        }
+
+        return 0;
+}
+
+static int uas_queuecommand_lck(struct scsi_cmnd *cmnd,
+                                        void (*done)(struct scsi_cmnd *))
+{
+        struct scsi_device *sdev = cmnd->device;
+        struct uas_dev_info *devinfo = sdev->hostdata;
+        struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp;
+        int err;
+
+        BUILD_BUG_ON(sizeof(struct uas_cmd_info) > sizeof(struct scsi_pointer));
+
+        if (!cmdinfo->status_urb && sdev->current_cmnd)
+                return SCSI_MLQUEUE_DEVICE_BUSY;
+
+        if (blk_rq_tagged(cmnd->request)) {
+                cmdinfo->stream = cmnd->request->tag + 1;
+        } else {
+                sdev->current_cmnd = cmnd;
+                cmdinfo->stream = 1;
+        }
+
+        cmnd->scsi_done = done;
+
+        cmdinfo->state = ALLOC_STATUS_URB | SUBMIT_STATUS_URB |
+                        ALLOC_CMD_URB | SUBMIT_CMD_URB;
+
+        switch (cmnd->sc_data_direction) {
+        case DMA_FROM_DEVICE:
+                cmdinfo->state |= ALLOC_DATA_IN_URB | SUBMIT_DATA_IN_URB;
+                break;
+        case DMA_BIDIRECTIONAL:
+                cmdinfo->state |= ALLOC_DATA_IN_URB | SUBMIT_DATA_IN_URB;
+        case DMA_TO_DEVICE:
+                cmdinfo->state |= ALLOC_DATA_OUT_URB | SUBMIT_DATA_OUT_URB;
+        case DMA_NONE:
+                break;
+        }
+
+        if (!devinfo->use_streams) {
+                cmdinfo->state &= ~(SUBMIT_DATA_IN_URB | SUBMIT_DATA_OUT_URB);
+                cmdinfo->stream = 0;
+        }
+
+        err = uas_submit_urbs(cmnd, devinfo, GFP_ATOMIC);
+        if (err) {
+                /* If we did nothing, give up now */
+                if (cmdinfo->state & SUBMIT_STATUS_URB) {
+                        usb_free_urb(cmdinfo->status_urb);
+                        return SCSI_MLQUEUE_DEVICE_BUSY;
+                }
+                spin_lock(&uas_work_lock);
+                list_add_tail(&cmdinfo->list, &uas_work_list);
+                spin_unlock(&uas_work_lock);
+                schedule_work(&uas_work);
+        }
+
+        return 0;
+}
+
+static DEF_SCSI_QCMD(uas_queuecommand)
+
+static int uas_eh_abort_handler(struct scsi_cmnd *cmnd)
+{
+        struct scsi_device *sdev = cmnd->device;
+        sdev_printk(KERN_INFO, sdev, "%s tag %d\n", __func__,
+                                                        cmnd->request->tag);
+
+/* XXX: Send ABORT TASK Task Management command */
+        return FAILED;
+}
+
+static int uas_eh_device_reset_handler(struct scsi_cmnd *cmnd)
+{
+        struct scsi_device *sdev = cmnd->device;
+        sdev_printk(KERN_INFO, sdev, "%s tag %d\n", __func__,
+                                                        cmnd->request->tag);
+
+/* XXX: Send LOGICAL UNIT RESET Task Management command */
+        return FAILED;
+}
+
+static int uas_eh_target_reset_handler(struct scsi_cmnd *cmnd)
+{
+        struct scsi_device *sdev = cmnd->device;
+        sdev_printk(KERN_INFO, sdev, "%s tag %d\n", __func__,
+                                                        cmnd->request->tag);
+
+/* XXX: Can we reset just the one USB interface?
+ * Would calling usb_set_interface() have the right effect?
+ */
+        return FAILED;
+}
+
+static int uas_eh_bus_reset_handler(struct scsi_cmnd *cmnd)
+{
+        struct scsi_device *sdev = cmnd->device;
+        struct uas_dev_info *devinfo = sdev->hostdata;
+        struct usb_device *udev = devinfo->udev;
+
+        sdev_printk(KERN_INFO, sdev, "%s tag %d\n", __func__,
+                                                        cmnd->request->tag);
+
+        if (usb_reset_device(udev))
+                return SUCCESS;
+
+        return FAILED;
+}
+
+static int uas_slave_alloc(struct scsi_device *sdev)
+{
+        sdev->hostdata = (void *)sdev->host->hostdata[0];
+        return 0;
+}
+
+static int uas_slave_configure(struct scsi_device *sdev)
+{
+        struct uas_dev_info *devinfo = sdev->hostdata;
+        scsi_set_tag_type(sdev, MSG_ORDERED_TAG);
+        scsi_activate_tcq(sdev, devinfo->qdepth - 1);
+        return 0;
+}
+
+static struct scsi_host_template uas_host_template = {
+        .module = THIS_MODULE,
+        .name = "uas",
+        .queuecommand = uas_queuecommand,
+        .slave_alloc = uas_slave_alloc,
+        .slave_configure = uas_slave_configure,
+        .eh_abort_handler = uas_eh_abort_handler,
+        .eh_device_reset_handler = uas_eh_device_reset_handler,
+        .eh_target_reset_handler = uas_eh_target_reset_handler,
+        .eh_bus_reset_handler = uas_eh_bus_reset_handler,
+        .can_queue = 65536,     /* Is there a limit on the _host_ ? */
+        .this_id = -1,
+        .sg_tablesize = SG_NONE,
+        .cmd_per_lun = 1,       /* until we override it */
+        .skip_settle_delay = 1,
+        .ordered_tag = 1,
+};
+
+static struct usb_device_id uas_usb_ids[] = {
+        { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, USB_SC_SCSI, USB_PR_BULK) },
+        { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, USB_SC_SCSI, USB_PR_UAS) },
+        /* 0xaa is a prototype device I happen to have access to */
+        { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, USB_SC_SCSI, 0xaa) },
+        { }
+};
+MODULE_DEVICE_TABLE(usb, uas_usb_ids);
+
+static int uas_is_interface(struct usb_host_interface *intf)
+{
+        return (intf->desc.bInterfaceClass == USB_CLASS_MASS_STORAGE &&
+                intf->desc.bInterfaceSubClass == USB_SC_SCSI &&
+                intf->desc.bInterfaceProtocol == USB_PR_UAS);
+}
+
+static int uas_switch_interface(struct usb_device *udev,
+                                                struct usb_interface *intf)
+{
+        int i;
+
+        if (uas_is_interface(intf->cur_altsetting))
+                return 0;
+
+        for (i = 0; i < intf->num_altsetting; i++) {
+                struct usb_host_interface *alt = &intf->altsetting[i];
+                if (alt == intf->cur_altsetting)
+                        continue;
+                if (uas_is_interface(alt))
+                        return usb_set_interface(udev,
+                                                alt->desc.bInterfaceNumber,
+                                                alt->desc.bAlternateSetting);
+        }
+
+        return -ENODEV;
+}
+
+static void uas_configure_endpoints(struct uas_dev_info *devinfo)
+{
+        struct usb_host_endpoint *eps[4] = { };
+        struct usb_interface *intf = devinfo->intf;
+        struct usb_device *udev = devinfo->udev;
+        struct usb_host_endpoint *endpoint = intf->cur_altsetting->endpoint;
+        unsigned i, n_endpoints = intf->cur_altsetting->desc.bNumEndpoints;
+
+        devinfo->uas_sense_old = 0;
+
+        for (i = 0; i < n_endpoints; i++) {
+                unsigned char *extra = endpoint[i].extra;
+                int len = endpoint[i].extralen;
+                while (len > 1) {
+                        if (extra[1] == USB_DT_PIPE_USAGE) {
+                                unsigned pipe_id = extra[2];
+                                if (pipe_id > 0 && pipe_id < 5)
+                                        eps[pipe_id - 1] = &endpoint[i];
+                                break;
+                        }
+                        len -= extra[0];
+                        extra += extra[0];
+                }
+        }
+
+        /*
+         * Assume that if we didn't find a control pipe descriptor, we're
+         * using a device with old firmware that happens to be set up like
+         * this.
+         */
+        if (!eps[0]) {
+                devinfo->cmd_pipe = usb_sndbulkpipe(udev, 1);
+                devinfo->status_pipe = usb_rcvbulkpipe(udev, 1);
+                devinfo->data_in_pipe = usb_rcvbulkpipe(udev, 2);
+                devinfo->data_out_pipe = usb_sndbulkpipe(udev, 2);
+
+                eps[1] = usb_pipe_endpoint(udev, devinfo->status_pipe);
+                eps[2] = usb_pipe_endpoint(udev, devinfo->data_in_pipe);
+                eps[3] = usb_pipe_endpoint(udev, devinfo->data_out_pipe);
+        } else {
+                devinfo->cmd_pipe = usb_sndbulkpipe(udev,
+                                                eps[0]->desc.bEndpointAddress);
+                devinfo->status_pipe = usb_rcvbulkpipe(udev,
+                                                eps[1]->desc.bEndpointAddress);
+                devinfo->data_in_pipe = usb_rcvbulkpipe(udev,
+                                                eps[2]->desc.bEndpointAddress);
+                devinfo->data_out_pipe = usb_sndbulkpipe(udev,
+                                                eps[3]->desc.bEndpointAddress);
+        }
+
+        devinfo->qdepth = usb_alloc_streams(devinfo->intf, eps + 1, 3, 256,
+                                                                GFP_KERNEL);
+        if (devinfo->qdepth < 0) {
+                devinfo->qdepth = 256;
+                devinfo->use_streams = 0;
+        } else {
+                devinfo->use_streams = 1;
+        }
+}
+
+/*
+ * XXX: What I'd like to do here is register a SCSI host for each USB host in
+ * the system.  Follow usb-storage's design of registering a SCSI host for
+ * each USB device for the moment.  Can implement this by walking up the
+ * USB hierarchy until we find a USB host.
+ */
+static int uas_probe(struct usb_interface *intf, const struct usb_device_id *id)
+{
+        int result;
+        struct Scsi_Host *shost;
+        struct uas_dev_info *devinfo;
+        struct usb_device *udev = interface_to_usbdev(intf);
+
+        if (uas_switch_interface(udev, intf))
+                return -ENODEV;
+
+        devinfo = kmalloc(sizeof(struct uas_dev_info), GFP_KERNEL);
+        if (!devinfo)
+                return -ENOMEM;
+
+        result = -ENOMEM;
+        shost = scsi_host_alloc(&uas_host_template, sizeof(void *));
+        if (!shost)
+                goto free;
+
+        shost->max_cmd_len = 16 + 252;
+        shost->max_id = 1;
+        shost->sg_tablesize = udev->bus->sg_tablesize;
+
+        result = scsi_add_host(shost, &intf->dev);
+        if (result)
+                goto free;
+        shost->hostdata[0] = (unsigned long)devinfo;
+
+        devinfo->intf = intf;
+        devinfo->udev = udev;
+        uas_configure_endpoints(devinfo);
+
+        scsi_scan_host(shost);
+        usb_set_intfdata(intf, shost);
+        return result;
+ free:
+        kfree(devinfo);
+        if (shost)
+                scsi_host_put(shost);
+        return result;
+}
+
+static int uas_pre_reset(struct usb_interface *intf)
+{
+/* XXX: Need to return 1 if it's not our device in error handling */
+        return 0;
+}
+
+static int uas_post_reset(struct usb_interface *intf)
+{
+/* XXX: Need to return 1 if it's not our device in error handling */
+        return 0;
+}
+
+static void uas_disconnect(struct usb_interface *intf)
+{
+        struct usb_device *udev = interface_to_usbdev(intf);
+        struct usb_host_endpoint *eps[3];
+        struct Scsi_Host *shost = usb_get_intfdata(intf);
+        struct uas_dev_info *devinfo = (void *)shost->hostdata[0];
+
+        scsi_remove_host(shost);
+
+        eps[0] = usb_pipe_endpoint(udev, devinfo->status_pipe);
+        eps[1] = usb_pipe_endpoint(udev, devinfo->data_in_pipe);
+        eps[2] = usb_pipe_endpoint(udev, devinfo->data_out_pipe);
+        usb_free_streams(intf, eps, 3, GFP_KERNEL);
+
+        kfree(devinfo);
+}
+
+/*
+ * XXX: Should this plug into libusual so we can auto-upgrade devices from
+ * Bulk-Only to UAS?
+ */
+static struct usb_driver uas_driver = {
+        .name = "uas",
+        .probe = uas_probe,
+        .disconnect = uas_disconnect,
+        .pre_reset = uas_pre_reset,
+        .post_reset = uas_post_reset,
+        .id_table = uas_usb_ids,
+};
+
+static int uas_init(void)
+{
+        return usb_register(&uas_driver);
+}
+
+static void uas_exit(void)
+{
+        usb_deregister(&uas_driver);
+}
+
+module_init(uas_init);
+module_exit(uas_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Matthew Wilcox and Sarah Sharp");
diff --git a/drivers/usb/storage/unusual_alauda.h b/drivers/usb/storage/unusual_alauda.h
index 8c412f885dd2..fa3e9edaa2cf 100644
--- a/drivers/usb/storage/unusual_alauda.h
+++ b/drivers/usb/storage/unusual_alauda.h
@@ -21,11 +21,11 @@
 UNUSUAL_DEV(  0x0584, 0x0008, 0x0102, 0x0102,
                 "Fujifilm",
                 "DPC-R1 (Alauda)",
-                US_SC_SCSI, US_PR_ALAUDA, init_alauda, 0),
+                USB_SC_SCSI, USB_PR_ALAUDA, init_alauda, 0),
 
 UNUSUAL_DEV(  0x07b4, 0x010a, 0x0102, 0x0102,
                 "Olympus",
                 "MAUSB-10 (Alauda)",
-                US_SC_SCSI, US_PR_ALAUDA, init_alauda, 0),
+                USB_SC_SCSI, USB_PR_ALAUDA, init_alauda, 0),
 
 #endif /* defined(CONFIG_USB_STORAGE_ALAUDA) || ... */
diff --git a/drivers/usb/storage/unusual_cypress.h b/drivers/usb/storage/unusual_cypress.h
index 44be6d75dab6..2c8553026222 100644
--- a/drivers/usb/storage/unusual_cypress.h
+++ b/drivers/usb/storage/unusual_cypress.h
@@ -23,12 +23,17 @@
 UNUSUAL_DEV(  0x04b4, 0x6830, 0x0000, 0x9999,
                 "Cypress",
                 "Cypress AT2LP",
-                US_SC_CYP_ATACB, US_PR_DEVICE, NULL, 0),
+                USB_SC_CYP_ATACB, USB_PR_DEVICE, NULL, 0),
 
 /* CY7C68310 : support atacb and atacb2 */
 UNUSUAL_DEV(  0x04b4, 0x6831, 0x0000, 0x9999,
                 "Cypress",
                 "Cypress ISD-300LP",
-                US_SC_CYP_ATACB, US_PR_DEVICE, NULL, 0),
+                USB_SC_CYP_ATACB, USB_PR_DEVICE, NULL, 0),
+
+UNUSUAL_DEV( 0x14cd, 0x6116, 0x0000, 0x9999,
+                "Super Top",
+                "USB 2.0  SATA BRIDGE",
+                USB_SC_CYP_ATACB, USB_PR_DEVICE, NULL, 0),
 
 #endif /* defined(CONFIG_USB_STORAGE_CYPRESS_ATACB) || ... */
diff --git a/drivers/usb/storage/unusual_datafab.h b/drivers/usb/storage/unusual_datafab.h
index c9298ce9f223..582a603c78be 100644
--- a/drivers/usb/storage/unusual_datafab.h
+++ b/drivers/usb/storage/unusual_datafab.h
@@ -21,7 +21,7 @@
 UNUSUAL_DEV(  0x07c4, 0xa000, 0x0000, 0x0015,
                 "Datafab",
                 "MDCFE-B USB CF Reader",
-                US_SC_SCSI, US_PR_DATAFAB, NULL,
+                USB_SC_SCSI, USB_PR_DATAFAB, NULL,
                 0),
 
 /*
@@ -38,45 +38,45 @@ UNUSUAL_DEV(  0x07c4, 0xa000, 0x0000, 0x0015,
 UNUSUAL_DEV( 0x07c4, 0xa001, 0x0000, 0xffff,
                 "SIIG/Datafab",
                 "SIIG/Datafab Memory Stick+CF Reader/Writer",
-                US_SC_SCSI, US_PR_DATAFAB, NULL,
+                USB_SC_SCSI, USB_PR_DATAFAB, NULL,
                 0),
 
 /* Reported by Josef Reisinger <josef.reisinger@netcologne.de> */
 UNUSUAL_DEV( 0x07c4, 0xa002, 0x0000, 0xffff,
                 "Datafab/Unknown",
                 "MD2/MD3 Disk enclosure",
-                US_SC_SCSI, US_PR_DATAFAB, NULL,
+                USB_SC_SCSI, USB_PR_DATAFAB, NULL,
                 US_FL_SINGLE_LUN),
 
 UNUSUAL_DEV( 0x07c4, 0xa003, 0x0000, 0xffff,
                 "Datafab/Unknown",
                 "Datafab-based Reader",
-                US_SC_SCSI, US_PR_DATAFAB, NULL,
+                USB_SC_SCSI, USB_PR_DATAFAB, NULL,
                 0),
 
 UNUSUAL_DEV( 0x07c4, 0xa004, 0x0000, 0xffff,
                 "Datafab/Unknown",
                 "Datafab-based Reader",
-                US_SC_SCSI, US_PR_DATAFAB, NULL,
+                USB_SC_SCSI, USB_PR_DATAFAB, NULL,
                 0),
 
 UNUSUAL_DEV( 0x07c4, 0xa005, 0x0000, 0xffff,
                 "PNY/Datafab",
                 "PNY/Datafab CF+SM Reader",
-                US_SC_SCSI, US_PR_DATAFAB, NULL,
+                USB_SC_SCSI, USB_PR_DATAFAB, NULL,
                 0),
 
 UNUSUAL_DEV( 0x07c4, 0xa006, 0x0000, 0xffff,
                 "Simple Tech/Datafab",
                 "Simple Tech/Datafab CF+SM Reader",
-                US_SC_SCSI, US_PR_DATAFAB, NULL,
+                USB_SC_SCSI, USB_PR_DATAFAB, NULL,
                 0),
 
 /* Submitted by Olaf Hering <olh@suse.de> */
 UNUSUAL_DEV(  0x07c4, 0xa109, 0x0000, 0xffff,
                 "Datafab Systems, Inc.",
                 "USB to CF + SM Combo (LC1)",
-                US_SC_SCSI, US_PR_DATAFAB, NULL,
+                USB_SC_SCSI, USB_PR_DATAFAB, NULL,
                 0),
 
 /* Reported by Felix Moeller <felix@derklecks.de>
@@ -86,13 +86,13 @@ UNUSUAL_DEV(  0x07c4, 0xa109, 0x0000, 0xffff,
 UNUSUAL_DEV(  0x07c4, 0xa10b, 0x0000, 0xffff,
                 "DataFab Systems Inc.",
                 "USB CF+MS",
-                US_SC_SCSI, US_PR_DATAFAB, NULL,
+                USB_SC_SCSI, USB_PR_DATAFAB, NULL,
                 0),
 
 UNUSUAL_DEV( 0x0c0b, 0xa109, 0x0000, 0xffff,
                 "Acomdata",
                 "CF",
-                US_SC_SCSI, US_PR_DATAFAB, NULL,
+                USB_SC_SCSI, USB_PR_DATAFAB, NULL,
                 US_FL_SINGLE_LUN),
 
 #endif /* defined(CONFIG_USB_STORAGE_DATAFAB) || ... */
diff --git a/drivers/usb/storage/unusual_devs.h b/drivers/usb/storage/unusual_devs.h
index 2c897eefadde..ccff3483eebc 100644
--- a/drivers/usb/storage/unusual_devs.h
+++ b/drivers/usb/storage/unusual_devs.h
@@ -63,26 +63,26 @@
 UNUSUAL_DEV(  0x03eb, 0x2002, 0x0100, 0x0100,
                 "ATMEL",
                 "SND1 Storage",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_IGNORE_RESIDUE),
 
 /* Reported by Rodolfo Quesada <rquesada@roqz.net> */
 UNUSUAL_DEV(  0x03ee, 0x6906, 0x0003, 0x0003,
                 "VIA Technologies Inc.",
                 "Mitsumi multi cardreader",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_IGNORE_RESIDUE ),
 
 UNUSUAL_DEV(  0x03f0, 0x0107, 0x0200, 0x0200,
                 "HP",
                 "CD-Writer+",
-                US_SC_8070, US_PR_CB, NULL, 0),
+                USB_SC_8070, USB_PR_CB, NULL, 0),
 
 /* Reported by Ben Efros <ben@pc-doctor.com> */
 UNUSUAL_DEV(  0x03f0, 0x070c, 0x0000, 0x0000,
                 "HP",
                 "Personal Media Drive",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_SANE_SENSE ),
 
 /* Reported by Grant Grundler <grundler@parisc-linux.org>
@@ -91,7 +91,7 @@ UNUSUAL_DEV(  0x03f0, 0x070c, 0x0000, 0x0000,
 UNUSUAL_DEV(  0x03f0, 0x4002, 0x0001, 0x0001,
                 "HP",
                 "PhotoSmart R707",
-                US_SC_DEVICE, US_PR_DEVICE, NULL, US_FL_FIX_CAPACITY),
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL, US_FL_FIX_CAPACITY),
 
 /* Reported by Sebastian Kapfer <sebastian_kapfer@gmx.net>
  * and Olaf Hering <olh@suse.de> (different bcd's, same vendor/product)
@@ -100,14 +100,14 @@ UNUSUAL_DEV(  0x03f0, 0x4002, 0x0001, 0x0001,
 UNUSUAL_DEV(  0x0409, 0x0040, 0x0000, 0x9999,
                 "NEC",
                 "NEC USB UF000x",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_SINGLE_LUN ),
 
 /* Patch submitted by Mihnea-Costin Grigore <mihnea@zulu.ro> */
 UNUSUAL_DEV(  0x040d, 0x6205, 0x0003, 0x0003,
                 "VIA Technologies Inc.",
                 "USB 2.0 Card Reader",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_IGNORE_RESIDUE ),
 
 /* Deduced by Jonathan Woithe <jwoithe@physics.adelaide.edu.au>
@@ -117,40 +117,40 @@ UNUSUAL_DEV(  0x040d, 0x6205, 0x0003, 0x0003,
 UNUSUAL_DEV(  0x0411, 0x001c, 0x0113, 0x0113,
                 "Buffalo",
                 "DUB-P40G HDD",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_FIX_INQUIRY ),
 
 /* Submitted by Ernestas Vaiciukevicius <ernisv@gmail.com> */
 UNUSUAL_DEV(  0x0419, 0x0100, 0x0100, 0x0100,
                 "Samsung Info. Systems America, Inc.",
                 "MP3 Player",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_IGNORE_RESIDUE ),
 
 /* Reported by Orgad Shaneh <orgads@gmail.com> */
 UNUSUAL_DEV(  0x0419, 0xaace, 0x0100, 0x0100,
                 "Samsung", "MP3 Player",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_IGNORE_RESIDUE ),
 
 /* Reported by Christian Leber <christian@leber.de> */
 UNUSUAL_DEV(  0x0419, 0xaaf5, 0x0100, 0x0100,
                 "TrekStor",
                 "i.Beat 115 2.0",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_IGNORE_RESIDUE | US_FL_NOT_LOCKABLE ),
 
 /* Reported by Stefan Werner <dustbln@gmx.de> */
 UNUSUAL_DEV(  0x0419, 0xaaf6, 0x0100, 0x0100,
                 "TrekStor",
                 "i.Beat Joy 2.0",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_IGNORE_RESIDUE ),
 
 /* Reported by Pete Zaitcev <zaitcev@redhat.com>, bz#176584 */
 UNUSUAL_DEV(  0x0420, 0x0001, 0x0100, 0x0100,
                 "GENERIC", "MP3 PLAYER", /* MyMusix PD-205 on the outside. */
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_IGNORE_RESIDUE ),
 
 /* Reported by Andrew Nayenko <relan@bk.ru>
@@ -158,28 +158,28 @@ UNUSUAL_DEV(  0x0420, 0x0001, 0x0100, 0x0100,
 UNUSUAL_DEV(  0x0421, 0x0019, 0x0592, 0x0610,
                 "Nokia",
                 "Nokia 6288",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_MAX_SECTORS_64 ),
 
 /* Reported by Mario Rettig <mariorettig@web.de> */
 UNUSUAL_DEV(  0x0421, 0x042e, 0x0100, 0x0100,
                 "Nokia",
                 "Nokia 3250",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_IGNORE_RESIDUE | US_FL_FIX_CAPACITY ),
 
 /* Reported by <honkkis@gmail.com> */
 UNUSUAL_DEV(  0x0421, 0x0433, 0x0100, 0x0100,
                 "Nokia",
                 "E70",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_IGNORE_RESIDUE | US_FL_FIX_CAPACITY ),
 
 /* Reported by Jon Hart <Jon.Hart@web.de> */
 UNUSUAL_DEV(  0x0421, 0x0434, 0x0100, 0x0100,
                 "Nokia",
                 "E60",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_FIX_CAPACITY | US_FL_IGNORE_RESIDUE ),
 
 /* Reported by Sumedha Swamy <sumedhaswamy@gmail.com> and
@@ -187,7 +187,7 @@ UNUSUAL_DEV(  0x0421, 0x0434, 0x0100, 0x0100,
 UNUSUAL_DEV(  0x0421, 0x0444, 0x0100, 0x0100,
                 "Nokia",
                 "N91",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_IGNORE_RESIDUE | US_FL_FIX_CAPACITY ),
 
 /* Reported by Jiri Slaby <jirislaby@gmail.com> and
@@ -195,42 +195,42 @@ UNUSUAL_DEV(  0x0421, 0x0444, 0x0100, 0x0100,
 UNUSUAL_DEV(  0x0421, 0x0446, 0x0100, 0x0100,
                 "Nokia",
                 "N80",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_IGNORE_RESIDUE | US_FL_FIX_CAPACITY ),
 
 /* Reported by Matthew Bloch <matthew@bytemark.co.uk> */
 UNUSUAL_DEV(  0x0421, 0x044e, 0x0100, 0x0100,
                 "Nokia",
                 "E61",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_IGNORE_RESIDUE | US_FL_FIX_CAPACITY ),
 
 /* Reported by Bardur Arantsson <bardur@scientician.net> */
 UNUSUAL_DEV(  0x0421, 0x047c, 0x0370, 0x0610,
                 "Nokia",
                 "6131",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_MAX_SECTORS_64 ),
 
 /* Reported by Manuel Osdoba <manuel.osdoba@tu-ilmenau.de> */
 UNUSUAL_DEV( 0x0421, 0x0492, 0x0452, 0x9999,
                 "Nokia",
                 "Nokia 6233",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_MAX_SECTORS_64 ),
 
 /* Reported by Alex Corcoles <alex@corcoles.net> */
 UNUSUAL_DEV(  0x0421, 0x0495, 0x0370, 0x0370,
                 "Nokia",
                 "6234",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_MAX_SECTORS_64 ),
 
 #ifdef NO_SDDR09
 UNUSUAL_DEV(  0x0436, 0x0005, 0x0100, 0x0100,
                 "Microtech",
                 "CameraMate",
-                US_SC_SCSI, US_PR_CB, NULL,
+                USB_SC_SCSI, USB_PR_CB, NULL,
                 US_FL_SINGLE_LUN ),
 #endif
 
@@ -239,7 +239,7 @@ UNUSUAL_DEV(  0x0436, 0x0005, 0x0100, 0x0100,
 UNUSUAL_DEV(  0x0451, 0x5416, 0x0100, 0x0100,
                 "Neuros Audio",
                 "USB 2.0 HD 2.5",
-                US_SC_DEVICE, US_PR_BULK, NULL,
+                USB_SC_DEVICE, USB_PR_BULK, NULL,
                 US_FL_NEED_OVERRIDE ),
 
 /*
@@ -250,7 +250,7 @@ UNUSUAL_DEV(  0x0451, 0x5416, 0x0100, 0x0100,
 UNUSUAL_DEV(  0x0457, 0x0150, 0x0100, 0x0100,
                 "USBest Technology",    /* sold by Transcend */
                 "USB Mass Storage Device",
-                US_SC_DEVICE, US_PR_DEVICE, NULL, US_FL_NOT_LOCKABLE ),
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL, US_FL_NOT_LOCKABLE ),
 
 /*
 * Bohdan Linda <bohdan.linda@gmail.com>
@@ -260,7 +260,7 @@ UNUSUAL_DEV(  0x0457, 0x0150, 0x0100, 0x0100,
 UNUSUAL_DEV(  0x0457, 0x0151, 0x0100, 0x0100,
                 "USB 2.0",
                 "Flash Disk",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_NOT_LOCKABLE ),
 
 /* Reported by Tamas Kerecsen <kerecsen@bigfoot.com>
@@ -272,7 +272,7 @@ UNUSUAL_DEV(  0x0457, 0x0151, 0x0100, 0x0100,
 UNUSUAL_DEV(  0x045e, 0xffff, 0x0000, 0x0000,
                 "Mitac",
                 "GPS",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_MAX_SECTORS_64 ),
 
 /*
@@ -284,32 +284,32 @@ UNUSUAL_DEV(  0x045e, 0xffff, 0x0000, 0x0000,
 UNUSUAL_DEV(  0x046b, 0xff40, 0x0100, 0x0100,
                 "AMI",
                 "Virtual Floppy",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_NO_WP_DETECT),
 
 /* Patch submitted by Philipp Friedrich <philipp@void.at> */
 UNUSUAL_DEV(  0x0482, 0x0100, 0x0100, 0x0100,
                 "Kyocera",
                 "Finecam S3x",
-                US_SC_8070, US_PR_CB, NULL, US_FL_FIX_INQUIRY),
+                USB_SC_8070, USB_PR_CB, NULL, US_FL_FIX_INQUIRY),
 
 /* Patch submitted by Philipp Friedrich <philipp@void.at> */
 UNUSUAL_DEV(  0x0482, 0x0101, 0x0100, 0x0100,
                 "Kyocera",
                 "Finecam S4",
-                US_SC_8070, US_PR_CB, NULL, US_FL_FIX_INQUIRY),
+                USB_SC_8070, USB_PR_CB, NULL, US_FL_FIX_INQUIRY),
 
 /* Patch submitted by Stephane Galles <stephane.galles@free.fr> */
 UNUSUAL_DEV(  0x0482, 0x0103, 0x0100, 0x0100,
                 "Kyocera",
                 "Finecam S5",
-                US_SC_DEVICE, US_PR_DEVICE, NULL, US_FL_FIX_INQUIRY),
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL, US_FL_FIX_INQUIRY),
 
 /* Patch submitted by Jens Taprogge <jens.taprogge@taprogge.org> */
 UNUSUAL_DEV(  0x0482, 0x0107, 0x0100, 0x0100,
                 "Kyocera",
                 "CONTAX SL300R T*",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_FIX_CAPACITY | US_FL_NOT_LOCKABLE),
 
 /* Reported by Paul Stewart <stewart@wetlogic.net>
@@ -317,7 +317,7 @@ UNUSUAL_DEV(  0x0482, 0x0107, 0x0100, 0x0100,
 UNUSUAL_DEV(  0x04a4, 0x0004, 0x0001, 0x0001,
                 "Hitachi",
                 "DVD-CAM DZ-MV100A Camcorder",
-                US_SC_SCSI, US_PR_CB, NULL, US_FL_SINGLE_LUN),
+                USB_SC_SCSI, USB_PR_CB, NULL, US_FL_SINGLE_LUN),
 
 /* BENQ DC5330
  * Reported by Manuel Fombuena <mfombuena@ya.com> and
@@ -325,7 +325,7 @@ UNUSUAL_DEV(  0x04a4, 0x0004, 0x0001, 0x0001,
 UNUSUAL_DEV(  0x04a5, 0x3010, 0x0100, 0x0100,
                 "Tekom Technologies, Inc",
                 "300_CAMERA",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_IGNORE_RESIDUE ),
 
 /* Patch for Nikon coolpix 2000
@@ -333,14 +333,14 @@ UNUSUAL_DEV(  0x04a5, 0x3010, 0x0100, 0x0100,
 UNUSUAL_DEV(  0x04b0, 0x0301, 0x0010, 0x0010,
                 "NIKON",
                 "NIKON DSC E2000",
-                US_SC_DEVICE, US_PR_DEVICE,NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE,NULL,
                 US_FL_NOT_LOCKABLE ),
 
 /* Reported by Doug Maxey (dwm@austin.ibm.com) */
 UNUSUAL_DEV(  0x04b3, 0x4001, 0x0110, 0x0110,
                 "IBM",
                 "IBM RSA2",
-                US_SC_DEVICE, US_PR_CB, NULL,
+                USB_SC_DEVICE, USB_PR_CB, NULL,
                 US_FL_MAX_SECTORS_MIN),
 
 /* Reported by Simon Levitt <simon@whattf.com>
@@ -348,14 +348,14 @@ UNUSUAL_DEV(  0x04b3, 0x4001, 0x0110, 0x0110,
 UNUSUAL_DEV(  0x04b8, 0x0601, 0x0100, 0x0100,
                 "Epson",
                 "875DC Storage",
-                US_SC_SCSI, US_PR_CB, NULL, US_FL_FIX_INQUIRY),
+                USB_SC_SCSI, USB_PR_CB, NULL, US_FL_FIX_INQUIRY),
 
 /* Reported by Khalid Aziz <khalid@gonehiking.org>
  * This entry is needed because the device reports Sub=ff */
 UNUSUAL_DEV(  0x04b8, 0x0602, 0x0110, 0x0110,
                 "Epson",
                 "785EPX Storage",
-                US_SC_SCSI, US_PR_BULK, NULL, US_FL_SINGLE_LUN),
+                USB_SC_SCSI, USB_PR_BULK, NULL, US_FL_SINGLE_LUN),
 
 /* Not sure who reported this originally but
  * Pavel Machek <pavel@ucw.cz> reported that the extra US_FL_SINGLE_LUN
@@ -363,7 +363,7 @@ UNUSUAL_DEV(  0x04b8, 0x0602, 0x0110, 0x0110,
 UNUSUAL_DEV(  0x04cb, 0x0100, 0x0000, 0x2210,
                 "Fujifilm",
                 "FinePix 1400Zoom",
-                US_SC_UFI, US_PR_DEVICE, NULL, US_FL_FIX_INQUIRY | US_FL_SINGLE_LUN),
+                USB_SC_UFI, USB_PR_DEVICE, NULL, US_FL_FIX_INQUIRY | US_FL_SINGLE_LUN),
 
 /* Reported by Ondrej Zary <linux@rainbow-software.org>
  * The device reports one sector more and breaks when that sector is accessed
@@ -371,7 +371,7 @@ UNUSUAL_DEV(  0x04cb, 0x0100, 0x0000, 0x2210,
 UNUSUAL_DEV(  0x04ce, 0x0002, 0x026c, 0x026c,
                 "ScanLogic",
                 "SL11R-IDE",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_FIX_CAPACITY),
 
 /* Reported by Kriston Fincher <kriston@airmail.net>
@@ -382,27 +382,27 @@ UNUSUAL_DEV(  0x04ce, 0x0002, 0x026c, 0x026c,
 UNUSUAL_DEV(  0x04da, 0x0901, 0x0100, 0x0200,
                 "Panasonic",
                 "LS-120 Camera",
-                US_SC_UFI, US_PR_DEVICE, NULL, 0),
+                USB_SC_UFI, USB_PR_DEVICE, NULL, 0),
 
 /* From Yukihiro Nakai, via zaitcev@yahoo.com.
  * This is needed for CB instead of CBI */
 UNUSUAL_DEV(  0x04da, 0x0d05, 0x0000, 0x0000,
                 "Sharp CE-CW05",
                 "CD-R/RW Drive",
-                US_SC_8070, US_PR_CB, NULL, 0),
+                USB_SC_8070, USB_PR_CB, NULL, 0),
 
 /* Reported by Adriaan Penning <a.penning@luon.net> */
 UNUSUAL_DEV(  0x04da, 0x2372, 0x0000, 0x9999,
                 "Panasonic",
                 "DMC-LCx Camera",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_FIX_CAPACITY | US_FL_NOT_LOCKABLE ),
 
 /* Reported by Simeon Simeonov <simeonov_2000@yahoo.com> */
 UNUSUAL_DEV(  0x04da, 0x2373, 0x0000, 0x9999,
                 "LEICA",
                 "D-LUX Camera",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_FIX_CAPACITY | US_FL_NOT_LOCKABLE ),
 
 /* Most of the following entries were developed with the help of
@@ -411,19 +411,19 @@ UNUSUAL_DEV(  0x04da, 0x2373, 0x0000, 0x9999,
 UNUSUAL_DEV(  0x04e6, 0x0001, 0x0200, 0x0200,
                 "Matshita",
                 "LS-120",
-                US_SC_8020, US_PR_CB, NULL, 0),
+                USB_SC_8020, USB_PR_CB, NULL, 0),
 
 UNUSUAL_DEV(  0x04e6, 0x0002, 0x0100, 0x0100,
                 "Shuttle",
                 "eUSCSI Bridge",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_euscsi_init, 
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_euscsi_init,
                 US_FL_SCM_MULT_TARG ),
 
 #ifdef NO_SDDR09
 UNUSUAL_DEV(  0x04e6, 0x0005, 0x0100, 0x0208,
                 "SCM Microsystems",
                 "eUSB CompactFlash Adapter",
-                US_SC_SCSI, US_PR_CB, NULL,
+                USB_SC_SCSI, USB_PR_CB, NULL,
                 US_FL_SINGLE_LUN),
 #endif
 
@@ -431,56 +431,63 @@ UNUSUAL_DEV(  0x04e6, 0x0005, 0x0100, 0x0208,
 UNUSUAL_DEV(  0x04e6, 0x0006, 0x0100, 0x0100,
                 "SCM Microsystems Inc.",
                 "eUSB MMC Adapter",
-                US_SC_SCSI, US_PR_CB, NULL,
+                USB_SC_SCSI, USB_PR_CB, NULL,
                 US_FL_SINGLE_LUN),
 
 /* Reported by Daniel Nouri <dpunktnpunkt@web.de> */
 UNUSUAL_DEV(  0x04e6, 0x0006, 0x0205, 0x0205,
                 "Shuttle",
                 "eUSB MMC Adapter",
-                US_SC_SCSI, US_PR_DEVICE, NULL,
+                USB_SC_SCSI, USB_PR_DEVICE, NULL,
                 US_FL_SINGLE_LUN),
 
 UNUSUAL_DEV(  0x04e6, 0x0007, 0x0100, 0x0200,
                 "Sony",
                 "Hifd",
-                US_SC_SCSI, US_PR_CB, NULL,
+                USB_SC_SCSI, USB_PR_CB, NULL,
                 US_FL_SINGLE_LUN),
 
 UNUSUAL_DEV(  0x04e6, 0x0009, 0x0200, 0x0200,
                 "Shuttle",
                 "eUSB ATA/ATAPI Adapter",
-                US_SC_8020, US_PR_CB, NULL, 0),
+                USB_SC_8020, USB_PR_CB, NULL, 0),
 
 UNUSUAL_DEV(  0x04e6, 0x000a, 0x0200, 0x0200,
                 "Shuttle",
                 "eUSB CompactFlash Adapter",
-                US_SC_8020, US_PR_CB, NULL, 0),
+                USB_SC_8020, USB_PR_CB, NULL, 0),
 
 UNUSUAL_DEV(  0x04e6, 0x000B, 0x0100, 0x0100,
                 "Shuttle",
                 "eUSCSI Bridge",
-                US_SC_SCSI, US_PR_BULK, usb_stor_euscsi_init,
+                USB_SC_SCSI, USB_PR_BULK, usb_stor_euscsi_init,
                 US_FL_SCM_MULT_TARG ), 
 
 UNUSUAL_DEV(  0x04e6, 0x000C, 0x0100, 0x0100,
                 "Shuttle",
                 "eUSCSI Bridge",
-                US_SC_SCSI, US_PR_BULK, usb_stor_euscsi_init,
+                USB_SC_SCSI, USB_PR_BULK, usb_stor_euscsi_init,
                 US_FL_SCM_MULT_TARG ),
 
 UNUSUAL_DEV(  0x04e6, 0x0101, 0x0200, 0x0200,
                 "Shuttle",
                 "CD-RW Device",
-                US_SC_8020, US_PR_CB, NULL, 0),
+                USB_SC_8020, USB_PR_CB, NULL, 0),
 
 /* Reported by Dmitry Khlystov <adminimus@gmail.com> */
 UNUSUAL_DEV(  0x04e8, 0x507c, 0x0220, 0x0220,
                 "Samsung",
                 "YP-U3",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_MAX_SECTORS_64),
 
+/* Reported by Vitaly Kuznetsov <vitty@altlinux.ru> */
+UNUSUAL_DEV(  0x04e8, 0x5122, 0x0000, 0x9999,
+                "Samsung",
+                "YP-CP3",
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
+                US_FL_MAX_SECTORS_64 | US_FL_BULK_IGNORE_TAG),
+
 /* Entry and supporting patch by Theodore Kilgore <kilgota@auburn.edu>.
  * Device uses standards-violating 32-byte Bulk Command Block Wrappers and
  * reports itself as "Proprietary SCSI Bulk." Cf. device entry 0x084d:0x0011.
@@ -488,14 +495,14 @@ UNUSUAL_DEV(  0x04e8, 0x507c, 0x0220, 0x0220,
 UNUSUAL_DEV(  0x04fc, 0x80c2, 0x0100, 0x0100,
                 "Kobian Mercury",
                 "Binocam DCB-132",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_BULK32),
 
 /* Reported by Bob Sass <rls@vectordb.com> -- only rev 1.33 tested */
 UNUSUAL_DEV(  0x050d, 0x0115, 0x0133, 0x0133,
                 "Belkin",
                 "USB SCSI Adaptor",
-                US_SC_SCSI, US_PR_BULK, usb_stor_euscsi_init,
+                USB_SC_SCSI, USB_PR_BULK, usb_stor_euscsi_init,
                 US_FL_SCM_MULT_TARG ),
 
 /* Iomega Clik! Drive 
@@ -505,14 +512,14 @@ UNUSUAL_DEV(  0x050d, 0x0115, 0x0133, 0x0133,
 UNUSUAL_DEV(  0x0525, 0xa140, 0x0100, 0x0100,
                 "Iomega",
                 "USB Clik! 40",
-                US_SC_8070, US_PR_DEVICE, NULL,
+                USB_SC_8070, USB_PR_DEVICE, NULL,
                 US_FL_FIX_INQUIRY ),
 
 /* Added by Alan Stern <stern@rowland.harvard.edu> */
 COMPLIANT_DEV(0x0525, 0xa4a5, 0x0000, 0x9999,
                 "Linux",
                 "File-backed Storage Gadget",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_CAPACITY_OK ),
 
 /* Yakumo Mega Image 37
@@ -520,7 +527,7 @@ COMPLIANT_DEV(0x0525, 0xa4a5, 0x0000, 0x9999,
 UNUSUAL_DEV(  0x052b, 0x1801, 0x0100, 0x0100,
                 "Tekom Technologies, Inc",
                 "300_CAMERA",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_IGNORE_RESIDUE ),
 
 /* Another Yakumo camera.
@@ -528,14 +535,14 @@ UNUSUAL_DEV(  0x052b, 0x1801, 0x0100, 0x0100,
 UNUSUAL_DEV(  0x052b, 0x1804, 0x0100, 0x0100,
                 "Tekom Technologies, Inc",
                 "300_CAMERA",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_IGNORE_RESIDUE ),
 
 /* Reported by Iacopo Spalletti <avvisi@spalletti.it> */
 UNUSUAL_DEV(  0x052b, 0x1807, 0x0100, 0x0100,
                 "Tekom Technologies, Inc",
                 "300_CAMERA",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_IGNORE_RESIDUE ),
 
 /* Yakumo Mega Image 47
@@ -543,7 +550,7 @@ UNUSUAL_DEV(  0x052b, 0x1807, 0x0100, 0x0100,
 UNUSUAL_DEV(  0x052b, 0x1905, 0x0100, 0x0100,
                 "Tekom Technologies, Inc",
                 "400_CAMERA",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_IGNORE_RESIDUE ),
 
 /* Reported by Paul Ortyl <ortylp@3miasto.net>
@@ -551,13 +558,13 @@ UNUSUAL_DEV(  0x052b, 0x1905, 0x0100, 0x0100,
 UNUSUAL_DEV(  0x052b, 0x1911, 0x0100, 0x0100,
                 "Tekom Technologies, Inc",
                 "400_CAMERA",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_IGNORE_RESIDUE ),
 
 UNUSUAL_DEV(  0x054c, 0x0010, 0x0106, 0x0450,
                 "Sony",
                 "DSC-S30/S70/S75/505V/F505/F707/F717/P8",
-                US_SC_SCSI, US_PR_DEVICE, NULL,
+                USB_SC_SCSI, USB_PR_DEVICE, NULL,
                 US_FL_SINGLE_LUN | US_FL_NOT_LOCKABLE | US_FL_NO_WP_DETECT ),
 
 /* Submitted by Lars Jacob <jacob.lars@googlemail.com>
@@ -565,7 +572,7 @@ UNUSUAL_DEV(  0x054c, 0x0010, 0x0106, 0x0450,
 UNUSUAL_DEV(  0x054c, 0x0010, 0x0500, 0x0610,
                 "Sony",
                 "DSC-T1/T5/H5",
-                US_SC_8070, US_PR_DEVICE, NULL,
+                USB_SC_8070, USB_PR_DEVICE, NULL,
                 US_FL_SINGLE_LUN ),
 
 
@@ -573,88 +580,88 @@ UNUSUAL_DEV(  0x054c, 0x0010, 0x0500, 0x0610,
 UNUSUAL_DEV(  0x054c, 0x0025, 0x0100, 0x0100,
                 "Sony",
                 "Memorystick NW-MS7",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_SINGLE_LUN ),
 
 /* Submitted by Olaf Hering, <olh@suse.de> SuSE Bugzilla #49049 */
 UNUSUAL_DEV(  0x054c, 0x002c, 0x0501, 0x2000,
                 "Sony",
                 "USB Floppy Drive",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_SINGLE_LUN ),
 
 UNUSUAL_DEV(  0x054c, 0x002d, 0x0100, 0x0100,
                 "Sony",
                 "Memorystick MSAC-US1",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_SINGLE_LUN ),
 
 /* Submitted by Klaus Mueller <k.mueller@intershop.de> */
 UNUSUAL_DEV(  0x054c, 0x002e, 0x0106, 0x0310,
                 "Sony",
                 "Handycam",
-                US_SC_SCSI, US_PR_DEVICE, NULL,
+                USB_SC_SCSI, USB_PR_DEVICE, NULL,
                 US_FL_SINGLE_LUN ),
 
 /* Submitted by Rajesh Kumble Nayak <nayak@obs-nice.fr> */
 UNUSUAL_DEV(  0x054c, 0x002e, 0x0500, 0x0500,
                 "Sony",
                 "Handycam HC-85",
-                US_SC_UFI, US_PR_DEVICE, NULL,
+                USB_SC_UFI, USB_PR_DEVICE, NULL,
                 US_FL_SINGLE_LUN ),
 
 UNUSUAL_DEV(  0x054c, 0x0032, 0x0000, 0x9999,
                 "Sony",
                 "Memorystick MSC-U01N",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_SINGLE_LUN ),
 
 /* Submitted by Michal Mlotek <mlotek@foobar.pl> */
 UNUSUAL_DEV(  0x054c, 0x0058, 0x0000, 0x9999,
                 "Sony",
                 "PEG N760c Memorystick",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_FIX_INQUIRY ),
                 
 UNUSUAL_DEV(  0x054c, 0x0069, 0x0000, 0x9999,
                 "Sony",
                 "Memorystick MSC-U03",
-                US_SC_UFI, US_PR_CB, NULL,
+                USB_SC_UFI, USB_PR_CB, NULL,
                 US_FL_SINGLE_LUN ),
 
 /* Submitted by Nathan Babb <nathan@lexi.com> */
 UNUSUAL_DEV(  0x054c, 0x006d, 0x0000, 0x9999,
                 "Sony",
                 "PEG Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_FIX_INQUIRY ),
 
 /* Submitted by Frank Engel <frankie@cse.unsw.edu.au> */
 UNUSUAL_DEV(  0x054c, 0x0099, 0x0000, 0x9999,
                 "Sony",
                 "PEG Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_FIX_INQUIRY ),
 
 /* Submitted by Mike Alborn <malborn@deandra.homeip.net> */
 UNUSUAL_DEV(  0x054c, 0x016a, 0x0000, 0x9999,
                 "Sony",
                 "PEG Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_FIX_INQUIRY ),
 
 /* floppy reports multiple luns */
 UNUSUAL_DEV(  0x055d, 0x2020, 0x0000, 0x0210,
                 "SAMSUNG",
                 "SFD-321U [FW 0C]",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_SINGLE_LUN ),
 
 /* We keep this entry to force the transport; firmware 3.00 and later is ok. */
 UNUSUAL_DEV(  0x057b, 0x0000, 0x0000, 0x0299,
                 "Y-E Data",
                 "Flashbuster-U",
-                US_SC_DEVICE,  US_PR_CB, NULL,
+                USB_SC_DEVICE,  USB_PR_CB, NULL,
                 US_FL_SINGLE_LUN),
 
 /* Reported by Johann Cardon <johann.cardon@free.fr>
@@ -664,20 +671,20 @@ UNUSUAL_DEV(  0x057b, 0x0000, 0x0000, 0x0299,
 UNUSUAL_DEV(  0x057b, 0x0022, 0x0000, 0x9999,
                 "Y-E Data",
                 "Silicon Media R/W",
-                US_SC_DEVICE, US_PR_DEVICE, NULL, 0),
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL, 0),
 
 /* Reported by RTE <raszilki@yandex.ru> */
 UNUSUAL_DEV(  0x058f, 0x6387, 0x0141, 0x0141,
                 "JetFlash",
                 "TS1GJF2A/120",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_MAX_SECTORS_64 ),
 
 /* Fabrizio Fellini <fello@libero.it> */
 UNUSUAL_DEV(  0x0595, 0x4343, 0x0000, 0x2210,
                 "Fujifilm",
                 "Digital Camera EX-20 DSC",
-                US_SC_8070, US_PR_DEVICE, NULL, 0 ),
+                USB_SC_8070, USB_PR_DEVICE, NULL, 0 ),
 
 /* Reported by Andre Welter <a.r.welter@gmx.de>
  * This antique device predates the release of the Bulk-only Transport
@@ -688,14 +695,14 @@ UNUSUAL_DEV(  0x0595, 0x4343, 0x0000, 0x2210,
 UNUSUAL_DEV(  0x059b, 0x0001, 0x0100, 0x0100,
                 "Iomega",
                 "ZIP 100",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_SINGLE_LUN ),
 
 /* Reported by <Hendryk.Pfeiffer@gmx.de> */
 UNUSUAL_DEV(  0x059f, 0x0643, 0x0000, 0x0000,
                 "LaCie",
                 "DVD+-RW",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_GO_SLOW ),
 
 /* Submitted by Joel Bourquard <numlock@freesurf.ch>
@@ -705,7 +712,7 @@ UNUSUAL_DEV(  0x059f, 0x0643, 0x0000, 0x0000,
 UNUSUAL_DEV(  0x05ab, 0x0060, 0x1104, 0x1110,
                 "In-System",
                 "PyroGate External CD-ROM Enclosure (FCD-523)",
-                US_SC_SCSI, US_PR_BULK, NULL,
+                USB_SC_SCSI, USB_PR_BULK, NULL,
                 US_FL_NEED_OVERRIDE ),
 
 /* Submitted by Sven Anderson <sven-linux@anderson.de>
@@ -717,26 +724,26 @@ UNUSUAL_DEV(  0x05ab, 0x0060, 0x1104, 0x1110,
 UNUSUAL_DEV( 0x05ac, 0x1202, 0x0000, 0x9999,
                 "Apple",
                 "iPod",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_FIX_CAPACITY ),
 
 /* Reported by Avi Kivity <avi@argo.co.il> */
 UNUSUAL_DEV( 0x05ac, 0x1203, 0x0000, 0x9999,
                 "Apple",
                 "iPod",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_FIX_CAPACITY ),
 
 UNUSUAL_DEV( 0x05ac, 0x1204, 0x0000, 0x9999,
                 "Apple",
                 "iPod",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_FIX_CAPACITY | US_FL_NOT_LOCKABLE ),
 
 UNUSUAL_DEV( 0x05ac, 0x1205, 0x0000, 0x9999,
                 "Apple",
                 "iPod",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_FIX_CAPACITY ),
 
 /*
@@ -746,7 +753,7 @@ UNUSUAL_DEV( 0x05ac, 0x1205, 0x0000, 0x9999,
 UNUSUAL_DEV( 0x05ac, 0x120a, 0x0000, 0x9999,
                 "Apple",
                 "iPod",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_FIX_CAPACITY ),
 
 /* Reported by Dan Williams <dcbw@redhat.com>
@@ -758,14 +765,14 @@ UNUSUAL_DEV( 0x05ac, 0x120a, 0x0000, 0x9999,
 UNUSUAL_DEV(  0x05c6, 0x1000, 0x0000, 0x9999,
                 "Option N.V.",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, option_ms_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, option_ms_init,
                 0),
 
 /* Reported by Blake Matheny <bmatheny@purdue.edu> */
 UNUSUAL_DEV(  0x05dc, 0xb002, 0x0000, 0x0113,
                 "Lexar",
                 "USB CF Reader",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_FIX_INQUIRY ),
 
 /* The following two entries are for a Genesys USB to IDE
@@ -782,20 +789,20 @@ UNUSUAL_DEV(  0x05dc, 0xb002, 0x0000, 0x0113,
 UNUSUAL_DEV(  0x05e3, 0x0701, 0x0000, 0xffff,
                 "Genesys Logic",
                 "USB to IDE Optical",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_GO_SLOW | US_FL_MAX_SECTORS_64 | US_FL_IGNORE_RESIDUE ),
 
 UNUSUAL_DEV(  0x05e3, 0x0702, 0x0000, 0xffff,
                 "Genesys Logic",
                 "USB to IDE Disk",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_GO_SLOW | US_FL_MAX_SECTORS_64 | US_FL_IGNORE_RESIDUE ),
 
 /* Reported by Ben Efros <ben@pc-doctor.com> */
 UNUSUAL_DEV(  0x05e3, 0x0723, 0x9451, 0x9451,
                 "Genesys Logic",
                 "USB to SATA",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_SANE_SENSE ),
 
 /* Reported by Hanno Boeck <hanno@gmx.de>
@@ -803,33 +810,33 @@ UNUSUAL_DEV(  0x05e3, 0x0723, 0x9451, 0x9451,
 UNUSUAL_DEV(  0x0636, 0x0003, 0x0000, 0x9999,
                 "Vivitar",
                 "Vivicam 35Xx",
-                US_SC_SCSI, US_PR_BULK, NULL,
+                USB_SC_SCSI, USB_PR_BULK, NULL,
                 US_FL_FIX_INQUIRY ),
 
 UNUSUAL_DEV(  0x0644, 0x0000, 0x0100, 0x0100,
                 "TEAC",
                 "Floppy Drive",
-                US_SC_UFI, US_PR_CB, NULL, 0 ),
+                USB_SC_UFI, USB_PR_CB, NULL, 0 ),
 
 /* Reported by Darsen Lu <darsen@micro.ee.nthu.edu.tw> */
 UNUSUAL_DEV( 0x066f, 0x8000, 0x0001, 0x0001,
                 "SigmaTel",
                 "USBMSC Audio Player",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_FIX_CAPACITY ),
 
 /* Reported by Daniel Kukula <daniel.kuku@gmail.com> */
 UNUSUAL_DEV( 0x067b, 0x1063, 0x0100, 0x0100,
                 "Prolific Technology, Inc.",
                 "Prolific Storage Gadget",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_BAD_SENSE ),
 
 /* Reported by Rogerio Brito <rbrito@ime.usp.br> */
 UNUSUAL_DEV( 0x067b, 0x2317, 0x0001, 0x001,
                 "Prolific Technology, Inc.",
                 "Mass Storage Device",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_NOT_LOCKABLE ),
 
 /* Reported by Richard -=[]=- <micro_flyer@hotmail.com> */
@@ -838,46 +845,47 @@ UNUSUAL_DEV( 0x067b, 0x2317, 0x0001, 0x001,
 UNUSUAL_DEV( 0x067b, 0x2507, 0x0001, 0x0100,
                 "Prolific Technology Inc.",
                 "Mass Storage Device",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_FIX_CAPACITY | US_FL_GO_SLOW ),
 
 /* Reported by Alex Butcher <alex.butcher@assursys.co.uk> */
 UNUSUAL_DEV( 0x067b, 0x3507, 0x0001, 0x0101,
                 "Prolific Technology Inc.",
                 "ATAPI-6 Bridge Controller",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_FIX_CAPACITY | US_FL_GO_SLOW ),
 
 /* Submitted by Benny Sjostrand <benny@hostmobility.com> */
 UNUSUAL_DEV( 0x0686, 0x4011, 0x0001, 0x0001,
                 "Minolta",
                 "Dimage F300",
-                US_SC_SCSI, US_PR_BULK, NULL, 0 ),
+                USB_SC_SCSI, USB_PR_BULK, NULL, 0 ),
 
 /* Reported by Miguel A. Fosas <amn3s1a@ono.com> */
 UNUSUAL_DEV(  0x0686, 0x4017, 0x0001, 0x0001,
                 "Minolta",
                 "DIMAGE E223",
-                US_SC_SCSI, US_PR_DEVICE, NULL, 0 ),
+                USB_SC_SCSI, USB_PR_DEVICE, NULL, 0 ),
 
 UNUSUAL_DEV(  0x0693, 0x0005, 0x0100, 0x0100,
                 "Hagiwara",
                 "Flashgate",
-                US_SC_SCSI, US_PR_BULK, NULL, 0 ),
+                USB_SC_SCSI, USB_PR_BULK, NULL, 0 ),
 
 /* Reported by David Hamilton <niftimusmaximus@lycos.com> */
 UNUSUAL_DEV(  0x069b, 0x3004, 0x0001, 0x0001,
                 "Thomson Multimedia Inc.",
                 "RCA RD1080 MP3 Player",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_FIX_CAPACITY ),
 
 /* Reported by Adrian Pilchowiec <adi1981@epf.pl> */
 UNUSUAL_DEV(  0x071b, 0x3203, 0x0000, 0x0000,
                 "RockChip",
                 "MP3",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
-                US_FL_NO_WP_DETECT | US_FL_MAX_SECTORS_64),
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
+                US_FL_NO_WP_DETECT | US_FL_MAX_SECTORS_64 |
+                US_FL_NO_READ_CAPACITY_16),
 
 /* Reported by Jean-Baptiste Onofre <jb@nanthrax.net>
  * Support the following product :
@@ -886,7 +894,7 @@ UNUSUAL_DEV(  0x071b, 0x3203, 0x0000, 0x0000,
 UNUSUAL_DEV(  0x071b, 0x32bb, 0x0000, 0x0000,
                 "RockChip",
                 "MTP",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_NO_WP_DETECT | US_FL_MAX_SECTORS_64),
 
 /* Reported by Massimiliano Ghilardi <massimiliano.ghilardi@gmail.com>
@@ -902,59 +910,59 @@ UNUSUAL_DEV(  0x071b, 0x32bb, 0x0000, 0x0000,
 UNUSUAL_DEV(  0x071b, 0x3203, 0x0100, 0x0100,
                 "RockChip",
                 "ROCK MP3",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_MAX_SECTORS_64),
 
 /* Reported by Olivier Blondeau <zeitoun@gmail.com> */
 UNUSUAL_DEV(  0x0727, 0x0306, 0x0100, 0x0100,
                 "ATMEL",
                 "SND1 Storage",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_IGNORE_RESIDUE),
 
 /* Submitted by Roman Hodek <roman@hodek.net> */
 UNUSUAL_DEV(  0x0781, 0x0001, 0x0200, 0x0200,
                 "Sandisk",
                 "ImageMate SDDR-05a",
-                US_SC_SCSI, US_PR_CB, NULL,
+                USB_SC_SCSI, USB_PR_CB, NULL,
                 US_FL_SINGLE_LUN ),
 
 UNUSUAL_DEV(  0x0781, 0x0002, 0x0009, 0x0009,
                 "SanDisk Corporation",
                 "ImageMate CompactFlash USB",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_FIX_CAPACITY ),
 
 UNUSUAL_DEV(  0x0781, 0x0100, 0x0100, 0x0100,
                 "Sandisk",
                 "ImageMate SDDR-12",
-                US_SC_SCSI, US_PR_CB, NULL,
+                USB_SC_SCSI, USB_PR_CB, NULL,
                 US_FL_SINGLE_LUN ),
 
 /* Reported by Eero Volotinen <eero@ping-viini.org> */
 UNUSUAL_DEV(  0x07ab, 0xfccd, 0x0000, 0x9999,
                 "Freecom Technologies",
                 "FHD-Classic",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_FIX_CAPACITY),
 
 UNUSUAL_DEV(  0x07af, 0x0004, 0x0100, 0x0133,
                 "Microtech",
                 "USB-SCSI-DB25",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_euscsi_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_euscsi_init,
                 US_FL_SCM_MULT_TARG ), 
 
 UNUSUAL_DEV(  0x07af, 0x0005, 0x0100, 0x0100,
                 "Microtech",
                 "USB-SCSI-HD50",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_euscsi_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_euscsi_init,
                 US_FL_SCM_MULT_TARG ),
 
 #ifdef NO_SDDR09
 UNUSUAL_DEV(  0x07af, 0x0006, 0x0100, 0x0100,
                 "Microtech",
                 "CameraMate",
-                US_SC_SCSI, US_PR_CB, NULL,
+                USB_SC_SCSI, USB_PR_CB, NULL,
                 US_FL_SINGLE_LUN ),
 #endif
 
@@ -967,7 +975,7 @@ UNUSUAL_DEV(  0x07af, 0x0006, 0x0100, 0x0100,
 UNUSUAL_DEV(  0x07c4, 0xa400, 0x0000, 0xffff,
                 "Datafab",
                 "KECF-USB",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_FIX_INQUIRY | US_FL_FIX_CAPACITY ),
 
 /* Reported by Rauch Wolke <rauchwolke@gmx.net>
@@ -976,7 +984,7 @@ UNUSUAL_DEV(  0x07c4, 0xa400, 0x0000, 0xffff,
 UNUSUAL_DEV(  0x07c4, 0xa4a5, 0x0000, 0xffff,
                 "Simple Tech/Datafab",
                 "CF+SM Reader",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_IGNORE_RESIDUE | US_FL_MAX_SECTORS_64 ),
 
 /* Casio QV 2x00/3x00/4000/8000 digital still cameras are not conformant
@@ -986,42 +994,42 @@ UNUSUAL_DEV(  0x07c4, 0xa4a5, 0x0000, 0xffff,
  * - They don't like the INQUIRY command. So we must handle this command
  *   of the SCSI layer ourselves.
  * - Some cameras with idProduct=0x1001 and bcdDevice=0x1000 have
- *   bInterfaceProtocol=0x00 (US_PR_CBI) while others have 0x01 (US_PR_CB).
- *   So don't remove the US_PR_CB override!
- * - Cameras with bcdDevice=0x9009 require the US_SC_8070 override.
+ *   bInterfaceProtocol=0x00 (USB_PR_CBI) while others have 0x01 (USB_PR_CB).
+ *   So don't remove the USB_PR_CB override!
+ * - Cameras with bcdDevice=0x9009 require the USB_SC_8070 override.
  */
 UNUSUAL_DEV( 0x07cf, 0x1001, 0x1000, 0x9999,
                 "Casio",
                 "QV DigitalCamera",
-                US_SC_8070, US_PR_CB, NULL,
+                USB_SC_8070, USB_PR_CB, NULL,
                 US_FL_NEED_OVERRIDE | US_FL_FIX_INQUIRY ),
 
 /* Submitted by Hartmut Wahl <hwahl@hwahl.de>*/
 UNUSUAL_DEV( 0x0839, 0x000a, 0x0001, 0x0001,
                 "Samsung",
                 "Digimax 410",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_FIX_INQUIRY),
 
 /* Reported by Luciano Rocha <luciano@eurotux.com> */
 UNUSUAL_DEV( 0x0840, 0x0082, 0x0001, 0x0001,
                 "Argosy",
                 "Storage",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_FIX_CAPACITY),
 
 /* Reported and patched by Nguyen Anh Quynh <aquynh@gmail.com> */
 UNUSUAL_DEV( 0x0840, 0x0084, 0x0001, 0x0001,
                 "Argosy",
                 "Storage",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_FIX_CAPACITY),
 
 /* Reported by Martijn Hijdra <martijn.hijdra@gmail.com> */
 UNUSUAL_DEV( 0x0840, 0x0085, 0x0001, 0x0001,
                 "Argosy",
                 "Storage",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_FIX_CAPACITY),
 
 /* Entry and supporting patch by Theodore Kilgore <kilgota@auburn.edu>.
@@ -1033,9 +1041,18 @@ UNUSUAL_DEV( 0x0840, 0x0085, 0x0001, 0x0001,
 UNUSUAL_DEV(  0x084d, 0x0011, 0x0110, 0x0110,
                 "Grandtech",
                 "DC2MEGA",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_BULK32),
 
+/* Reported by <ttkspam@free.fr>
+ * The device reports a vendor-specific device class, requiring an
+ * explicit vendor/product match.
+ */
+UNUSUAL_DEV(  0x0851, 0x1542, 0x0002, 0x0002,
+                "MagicPixel",
+                "FW_Omega2",
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL, 0),
+
 /* Andrew Lunn <andrew@lunn.ch>
  * PanDigital Digital Picture Frame. Does not like ALLOW_MEDIUM_REMOVAL
  * on LUN 4.
@@ -1044,14 +1061,14 @@ UNUSUAL_DEV(  0x084d, 0x0011, 0x0110, 0x0110,
 UNUSUAL_DEV(  0x0851, 0x1543, 0x0200, 0x0200,
                 "PanDigital",
                 "Photo Frame",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_NOT_LOCKABLE),
 
 /* Submitted by Jan De Luyck <lkml@kcore.org> */
 UNUSUAL_DEV(  0x08bd, 0x1100, 0x0000, 0x0000,
                 "CITIZEN",
                 "X1DE-USB",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_SINGLE_LUN),
 
 /* Submitted by Dylan Taft <d13f00l@gmail.com>
@@ -1060,7 +1077,7 @@ UNUSUAL_DEV(  0x08bd, 0x1100, 0x0000, 0x0000,
 UNUSUAL_DEV(  0x08ca, 0x3103, 0x0100, 0x0100,
                 "AIPTEK",
                 "Aiptek USB Keychain MP3 Player",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_IGNORE_RESIDUE),
 
 /* Entry needed for flags. Moreover, all devices with this ID use
@@ -1071,7 +1088,7 @@ UNUSUAL_DEV(  0x08ca, 0x3103, 0x0100, 0x0100,
 UNUSUAL_DEV(  0x090a, 0x1001, 0x0100, 0x0100,
                 "Trumpion",
                 "t33520 USB Flash Card Controller",
-                US_SC_DEVICE, US_PR_BULK, NULL,
+                USB_SC_DEVICE, USB_PR_BULK, NULL,
                 US_FL_NEED_OVERRIDE ),
 
 /* Reported by Filippo Bardelli <filibard@libero.it>
@@ -1080,23 +1097,33 @@ UNUSUAL_DEV(  0x090a, 0x1001, 0x0100, 0x0100,
 UNUSUAL_DEV(  0x090a, 0x1050, 0x0100, 0x0100,
                 "Trumpion Microelectronics, Inc.",
                 "33520 USB Digital Voice Recorder",
-                US_SC_UFI, US_PR_DEVICE, NULL,
+                USB_SC_UFI, USB_PR_DEVICE, NULL,
                 0),
 
 /* Trumpion Microelectronics MP3 player (felipe_alfaro@linuxmail.org) */
 UNUSUAL_DEV( 0x090a, 0x1200, 0x0000, 0x9999,
                 "Trumpion",
                 "MP3 player",
-                US_SC_RBC, US_PR_BULK, NULL,
+                USB_SC_RBC, USB_PR_BULK, NULL,
                 0 ),
 
 /* aeb */
 UNUSUAL_DEV( 0x090c, 0x1132, 0x0000, 0xffff,
                 "Feiya",
                 "5-in-1 Card Reader",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_FIX_CAPACITY ),
 
+/* Reported by Paul Hartman <paul.hartman+linux@gmail.com>
+ * This card reader returns "Illegal Request, Logical Block Address
+ * Out of Range" for the first READ(10) after a new card is inserted.
+ */
+UNUSUAL_DEV(  0x090c, 0x6000, 0x0100, 0x0100,
+                "Feiya",
+                "SD/SDHC Card Reader",
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
+                US_FL_INITIAL_READ10 ),
+
 /* This Pentax still camera is not conformant
  * to the USB storage specification: -
  * - It does not like the INQUIRY command. So we must handle this command
@@ -1107,7 +1134,7 @@ UNUSUAL_DEV( 0x090c, 0x1132, 0x0000, 0xffff,
 UNUSUAL_DEV( 0x0a17, 0x0004, 0x1000, 0x1000,
                 "Pentax",
                 "Optio 2/3/400",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_FIX_INQUIRY ),
 
 /* These are virtual windows driver CDs, which the zd1211rw driver
@@ -1115,13 +1142,13 @@ UNUSUAL_DEV( 0x0a17, 0x0004, 0x1000, 0x1000,
 UNUSUAL_DEV( 0x0ace, 0x2011, 0x0101, 0x0101,
                 "ZyXEL",
                 "G-220F USB-WLAN Install",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_IGNORE_DEVICE ),
 
 UNUSUAL_DEV( 0x0ace, 0x20ff, 0x0101, 0x0101,
                 "SiteCom",
                 "WL-117 USB-WLAN Install",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_IGNORE_DEVICE ),
 
 /* Reported by Dan Williams <dcbw@redhat.com>
@@ -1133,7 +1160,7 @@ UNUSUAL_DEV( 0x0ace, 0x20ff, 0x0101, 0x0101,
 UNUSUAL_DEV(  0x0af0, 0x6971, 0x0000, 0x9999,
                 "Option N.V.",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, option_ms_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, option_ms_init,
                 0),
 
 /* Reported by F. Aben <f.aben@option.com>
@@ -1143,7 +1170,7 @@ UNUSUAL_DEV(  0x0af0, 0x6971, 0x0000, 0x9999,
 UNUSUAL_DEV( 0x0af0, 0x7401, 0x0000, 0x0000,
                 "Option",
                 "GI 0401 SD-Card",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 0 ),
 
 /* Reported by Jan Dumon <j.dumon@option.com>
@@ -1153,104 +1180,104 @@ UNUSUAL_DEV( 0x0af0, 0x7401, 0x0000, 0x0000,
 UNUSUAL_DEV( 0x0af0, 0x7501, 0x0000, 0x0000,
                 "Option",
                 "GI 0431 SD-Card",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 0 ),
 
 UNUSUAL_DEV( 0x0af0, 0x7701, 0x0000, 0x0000,
                 "Option",
                 "GI 0451 SD-Card",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 0 ),
 
 UNUSUAL_DEV( 0x0af0, 0x7706, 0x0000, 0x0000,
                 "Option",
                 "GI 0451 SD-Card",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 0 ),
 
 UNUSUAL_DEV( 0x0af0, 0x7901, 0x0000, 0x0000,
                 "Option",
                 "GI 0452 SD-Card",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 0 ),
 
 UNUSUAL_DEV( 0x0af0, 0x7A01, 0x0000, 0x0000,
                 "Option",
                 "GI 0461 SD-Card",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 0 ),
 
 UNUSUAL_DEV( 0x0af0, 0x7A05, 0x0000, 0x0000,
                 "Option",
                 "GI 0461 SD-Card",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 0 ),
 
 UNUSUAL_DEV( 0x0af0, 0x8300, 0x0000, 0x0000,
                 "Option",
                 "GI 033x SD-Card",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 0 ),
 
 UNUSUAL_DEV( 0x0af0, 0x8302, 0x0000, 0x0000,
                 "Option",
                 "GI 033x SD-Card",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 0 ),
 
 UNUSUAL_DEV( 0x0af0, 0x8304, 0x0000, 0x0000,
                 "Option",
                 "GI 033x SD-Card",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 0 ),
 
 UNUSUAL_DEV( 0x0af0, 0xc100, 0x0000, 0x0000,
                 "Option",
                 "GI 070x SD-Card",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 0 ),
 
 UNUSUAL_DEV( 0x0af0, 0xd057, 0x0000, 0x0000,
                 "Option",
                 "GI 1505 SD-Card",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 0 ),
 
 UNUSUAL_DEV( 0x0af0, 0xd058, 0x0000, 0x0000,
                 "Option",
                 "GI 1509 SD-Card",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 0 ),
 
 UNUSUAL_DEV( 0x0af0, 0xd157, 0x0000, 0x0000,
                 "Option",
                 "GI 1515 SD-Card",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 0 ),
 
 UNUSUAL_DEV( 0x0af0, 0xd257, 0x0000, 0x0000,
                 "Option",
                 "GI 1215 SD-Card",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 0 ),
 
 UNUSUAL_DEV( 0x0af0, 0xd357, 0x0000, 0x0000,
                 "Option",
                 "GI 1505 SD-Card",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 0 ),
 
 /* Reported by Ben Efros <ben@pc-doctor.com> */
 UNUSUAL_DEV( 0x0bc2, 0x3010, 0x0000, 0x0000,
                 "Seagate",
                 "FreeAgent Pro",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_SANE_SENSE ),
 
 UNUSUAL_DEV(  0x0d49, 0x7310, 0x0000, 0x9999,
                 "Maxtor",
                 "USB to SATA",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_SANE_SENSE),
 
 /*
@@ -1260,14 +1287,14 @@ UNUSUAL_DEV(  0x0d49, 0x7310, 0x0000, 0x9999,
 UNUSUAL_DEV( 0x0c45, 0x1060, 0x0100, 0x0100,
                 "Unknown",
                 "Unknown",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_SINGLE_LUN ),
 
 /* Submitted by Joris Struyve <joris@struyve.be> */
 UNUSUAL_DEV( 0x0d96, 0x410a, 0x0001, 0xffff,
                 "Medion",
                 "MD 7425",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_FIX_INQUIRY),
 
 /*
@@ -1278,13 +1305,13 @@ UNUSUAL_DEV( 0x0d96, 0x410a, 0x0001, 0xffff,
 UNUSUAL_DEV(  0x0d96, 0x5200, 0x0001, 0x0200,
                 "Jenoptik",
                 "JD 5200 z3",
-                US_SC_DEVICE, US_PR_DEVICE, NULL, US_FL_FIX_INQUIRY),
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL, US_FL_FIX_INQUIRY),
 
 /* Reported by  Jason Johnston <killean@shaw.ca> */
 UNUSUAL_DEV(  0x0dc4, 0x0073, 0x0000, 0x0000,
                 "Macpower Technology Co.LTD.",
                 "USB 2.0 3.5\" DEVICE",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_FIX_CAPACITY),
 
 /* Reported by Lubomir Blaha <tritol@trilogic.cz>
@@ -1295,7 +1322,7 @@ UNUSUAL_DEV(  0x0dc4, 0x0073, 0x0000, 0x0000,
 UNUSUAL_DEV( 0x0dd8, 0x1060, 0x0000, 0xffff,
                 "Netac",
                 "USB-CF-Card",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_FIX_INQUIRY ),
 
 /* Reported by Edward Chapman (taken from linux-usb mailing list)
@@ -1303,7 +1330,7 @@ UNUSUAL_DEV( 0x0dd8, 0x1060, 0x0000, 0xffff,
 UNUSUAL_DEV( 0x0dd8, 0xd202, 0x0000, 0x9999,
                 "Netac",
                 "USB Flash Disk",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_IGNORE_RESIDUE ),
 
 
@@ -1312,28 +1339,28 @@ UNUSUAL_DEV( 0x0dd8, 0xd202, 0x0000, 0x9999,
 UNUSUAL_DEV( 0x0dda, 0x0001, 0x0012, 0x0012,
                 "WINWARD",
                 "Music Disk",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_IGNORE_RESIDUE ),
 
 /* Reported by Ian McConnell <ian at emit.demon.co.uk> */
 UNUSUAL_DEV(  0x0dda, 0x0301, 0x0012, 0x0012,
                 "PNP_MP3",
                 "PNP_MP3 PLAYER",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_IGNORE_RESIDUE ),
 
 /* Reported by Jim McCloskey <mcclosk@ucsc.edu> */
 UNUSUAL_DEV( 0x0e21, 0x0520, 0x0100, 0x0100,
                 "Cowon Systems",
                 "iAUDIO M5",
-                US_SC_DEVICE, US_PR_BULK, NULL,
+                USB_SC_DEVICE, USB_PR_BULK, NULL,
                 US_FL_NEED_OVERRIDE ),
 
 /* Submitted by Antoine Mairesse <antoine.mairesse@free.fr> */
 UNUSUAL_DEV( 0x0ed1, 0x6660, 0x0100, 0x0300,
                 "USB",
                 "Solid state disk",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_FIX_INQUIRY ),
 
 /* Submitted by Daniel Drake <dsd@gentoo.org>
@@ -1341,14 +1368,14 @@ UNUSUAL_DEV( 0x0ed1, 0x6660, 0x0100, 0x0300,
 UNUSUAL_DEV(  0x0ea0, 0x2168, 0x0110, 0x0110,
                 "Ours Technology",
                 "Flash Disk",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_IGNORE_RESIDUE ),
 
 /* Reported by Rastislav Stanik <rs_kernel@yahoo.com> */
 UNUSUAL_DEV(  0x0ea0, 0x6828, 0x0110, 0x0110,
                 "USB",
                 "Flash Disk",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_IGNORE_RESIDUE ),
 
 /* Reported by Benjamin Schiller <sbenni@gmx.de>
@@ -1356,7 +1383,7 @@ UNUSUAL_DEV(  0x0ea0, 0x6828, 0x0110, 0x0110,
 UNUSUAL_DEV(  0x0ed1, 0x7636, 0x0103, 0x0103,
                 "Typhoon",
                 "My DJ 1820",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_IGNORE_RESIDUE | US_FL_GO_SLOW | US_FL_MAX_SECTORS_64),
 
 /* Patch by Leonid Petrov mail at lpetrov.net
@@ -1367,7 +1394,7 @@ UNUSUAL_DEV(  0x0ed1, 0x7636, 0x0103, 0x0103,
 UNUSUAL_DEV(  0x0f19, 0x0103, 0x0100, 0x0100,
                 "Oracom Co., Ltd",
                 "ORC-200M",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_IGNORE_RESIDUE ),
 
 /* David Kuehling <dvdkhlng@gmx.de>:
@@ -1377,21 +1404,28 @@ UNUSUAL_DEV(  0x0f19, 0x0103, 0x0100, 0x0100,
 UNUSUAL_DEV(  0x0f19, 0x0105, 0x0100, 0x0100,
                 "C-MEX",
                 "A-VOX",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_IGNORE_RESIDUE ),
 
+/* Submitted by Nick Holloway */
+UNUSUAL_DEV( 0x0f88, 0x042e, 0x0100, 0x0100,
+                "VTech",
+                "Kidizoom",
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
+                US_FL_FIX_CAPACITY ),
+
 /* Reported by Michael Stattmann <michael@stattmann.com> */
 UNUSUAL_DEV(  0x0fce, 0xd008, 0x0000, 0x0000,
                 "Sony Ericsson",
                 "V800-Vodafone 802",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_NO_WP_DETECT ),
 
 /* Reported by The Solutor <thesolutor@gmail.com> */
 UNUSUAL_DEV(  0x0fce, 0xd0e1, 0x0000, 0x0000,
                 "Sony Ericsson",
                 "MD400",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_IGNORE_DEVICE),
 
 /* Reported by Jan Mate <mate@fiit.stuba.sk>
@@ -1399,21 +1433,21 @@ UNUSUAL_DEV(  0x0fce, 0xd0e1, 0x0000, 0x0000,
 UNUSUAL_DEV(  0x0fce, 0xe030, 0x0000, 0x0000,
                 "Sony Ericsson",
                 "P990i",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_FIX_CAPACITY | US_FL_IGNORE_RESIDUE ),
 
 /* Reported by Emmanuel Vasilakis <evas@forthnet.gr> */
 UNUSUAL_DEV(  0x0fce, 0xe031, 0x0000, 0x0000,
                 "Sony Ericsson",
                 "M600i",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_IGNORE_RESIDUE | US_FL_FIX_CAPACITY ),
 
 /* Reported by Ricardo Barberis <ricardo@dattatec.com> */
 UNUSUAL_DEV(  0x0fce, 0xe092, 0x0000, 0x0000,
                 "Sony Ericsson",
                 "P1i",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_IGNORE_RESIDUE ),
 
 /* Reported by Kevin Cernekee <kpc-usbdev@gelato.uiuc.edu>
@@ -1425,13 +1459,13 @@ UNUSUAL_DEV(  0x0fce, 0xe092, 0x0000, 0x0000,
 UNUSUAL_DEV(  0x1019, 0x0c55, 0x0000, 0x0110,
                 "Desknote",
                 "UCR-61S2B",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_ucr61s2b_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_ucr61s2b_init,
                 0 ),
 
 UNUSUAL_DEV(  0x1058, 0x0704, 0x0000, 0x9999,
                 "Western Digital",
                 "External HDD",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_SANE_SENSE),
 
 /* Reported by Fabio Venturi <f.venturi@tdnet.it>
@@ -1440,7 +1474,7 @@ UNUSUAL_DEV(  0x1058, 0x0704, 0x0000, 0x9999,
 UNUSUAL_DEV(  0x10d6, 0x2200, 0x0100, 0x0100,
                 "Actions Semiconductor",
                 "Mtp device",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 0),
 
 /* Reported by Pascal Terjan <pterjan@mandriva.com>
@@ -1449,7 +1483,7 @@ UNUSUAL_DEV(  0x10d6, 0x2200, 0x0100, 0x0100,
 UNUSUAL_DEV(  0x1186, 0x3e04, 0x0000, 0x0000,
            "D-Link",
            "USB Mass Storage",
-           US_SC_DEVICE, US_PR_DEVICE, option_ms_init, US_FL_IGNORE_DEVICE),
+           USB_SC_DEVICE, USB_PR_DEVICE, option_ms_init, US_FL_IGNORE_DEVICE),
 
 /* Reported by Kevin Lloyd <linux@sierrawireless.com>
  * Entry is needed for the initializer function override,
@@ -1459,7 +1493,7 @@ UNUSUAL_DEV(  0x1186, 0x3e04, 0x0000, 0x0000,
 UNUSUAL_DEV(  0x1199, 0x0fff, 0x0000, 0x9999,
                 "Sierra Wireless",
                 "USB MMC Storage",
-                US_SC_DEVICE, US_PR_DEVICE, sierra_ms_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, sierra_ms_init,
                 0),
 
 /* Reported by Jaco Kroon <jaco@kroon.co.za>
@@ -1469,7 +1503,7 @@ UNUSUAL_DEV(  0x1199, 0x0fff, 0x0000, 0x9999,
 UNUSUAL_DEV(  0x1210, 0x0003, 0x0100, 0x0100,
                 "Digitech HMG",
                 "DigiTech Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_IGNORE_RESIDUE ),
 
 /* Reported by fangxiaozhi <huananhu@huawei.com>
@@ -1478,353 +1512,353 @@ UNUSUAL_DEV(  0x1210, 0x0003, 0x0100, 0x0100,
 UNUSUAL_DEV(  0x12d1, 0x1001, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x1003, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x1004, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x1401, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x1402, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x1403, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x1404, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x1405, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x1406, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x1407, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x1408, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x1409, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x140A, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x140B, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x140C, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x140D, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x140E, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x140F, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x1410, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x1411, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x1412, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x1413, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x1414, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x1415, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x1416, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x1417, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x1418, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x1419, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x141A, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x141B, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x141C, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x141D, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x141E, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x141F, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x1420, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x1421, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x1422, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x1423, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x1424, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x1425, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x1426, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x1427, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x1428, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x1429, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x142A, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x142B, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x142C, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x142D, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x142E, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x142F, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x1430, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x1431, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x1432, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x1433, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x1434, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x1435, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x1436, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x1437, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x1438, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x1439, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x143A, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x143B, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x143C, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x143D, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x143E, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 UNUSUAL_DEV(  0x12d1, 0x143F, 0x0000, 0x0000,
                 "HUAWEI MOBILE",
                 "Mass Storage",
-                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_huawei_e220_init,
                 0),
 
 /* Reported by Vilius Bilinkevicius <vilisas AT xxx DOT lt) */
 UNUSUAL_DEV(  0x132b, 0x000b, 0x0001, 0x0001,
                 "Minolta",
                 "Dimage Z10",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 0 ),
 
 /* Reported by Kotrla Vitezslav <kotrla@ceb.cz> */
 UNUSUAL_DEV(  0x1370, 0x6828, 0x0110, 0x0110,
                 "SWISSBIT",
                 "Black Silver",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_IGNORE_RESIDUE ),
 
 /* Reported by Francesco Foresti <frafore@tiscali.it> */
 UNUSUAL_DEV(  0x14cd, 0x6600, 0x0201, 0x0201,
                 "Super Top",
                 "IDE DEVICE",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_IGNORE_RESIDUE ),
 
 /* Reported by Alexandre Oliva <oliva@lsd.ic.unicamp.br>
@@ -1833,7 +1867,7 @@ UNUSUAL_DEV(  0x14cd, 0x6600, 0x0201, 0x0201,
 UNUSUAL_DEV(  0x152d, 0x2329, 0x0100, 0x0100,
                 "JMicron",
                 "USB to ATA/ATAPI Bridge",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_IGNORE_RESIDUE | US_FL_SANE_SENSE ),
 
 /* Reported by Robert Schedel <r.schedel@yahoo.de>
@@ -1841,7 +1875,7 @@ UNUSUAL_DEV(  0x152d, 0x2329, 0x0100, 0x0100,
 UNUSUAL_DEV(  0x1652, 0x6600, 0x0201, 0x0201,
                 "Teac",
                 "HD-35PUK-B",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_IGNORE_RESIDUE ),
 
 /* Reported by Hans de Goede <hdegoede@redhat.com>
@@ -1851,18 +1885,48 @@ UNUSUAL_DEV(  0x1652, 0x6600, 0x0201, 0x0201,
 UNUSUAL_DEV( 0x1908, 0x1315, 0x0000, 0x0000,
                 "BUILDWIN",
                 "Photo Frame",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_BAD_SENSE ),
 UNUSUAL_DEV( 0x1908, 0x1320, 0x0000, 0x0000,
                 "BUILDWIN",
                 "Photo Frame",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_BAD_SENSE ),
+UNUSUAL_DEV( 0x1908, 0x3335, 0x0200, 0x0200,
+                "BUILDWIN",
+                "Photo Frame",
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
+                US_FL_NO_READ_DISC_INFO ),
+
+/* Reported by Sven Geggus <sven-usbst@geggus.net>
+ * This encrypted pen drive returns bogus data for the initial READ(10).
+ */
+UNUSUAL_DEV(  0x1b1c, 0x1ab5, 0x0200, 0x0200,
+                "Corsair",
+                "Padlock v2",
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
+                US_FL_INITIAL_READ10 ),
+
+/* Patch by Richard Schütz <r.schtz@t-online.de>
+ * This external hard drive enclosure uses a JMicron chip which
+ * needs the US_FL_IGNORE_RESIDUE flag to work properly. */
+UNUSUAL_DEV(  0x1e68, 0x001b, 0x0000, 0x0000,
+                "TrekStor GmbH & Co. KG",
+                "DataStation maxi g.u",
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
+                US_FL_IGNORE_RESIDUE | US_FL_SANE_SENSE ),
+
+/* Reported by Jasper Mackenzie <scarletpimpernal@hotmail.com> */
+UNUSUAL_DEV( 0x1e74, 0x4621, 0x0000, 0x0000,
+                "Coby Electronics",
+                "MP3 Player",
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
+                US_FL_BULK_IGNORE_TAG | US_FL_MAX_SECTORS_64 ),
 
 UNUSUAL_DEV( 0x2116, 0x0320, 0x0001, 0x0001,
                 "ST",
                 "2A",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_FIX_CAPACITY),
 
 /* patch submitted by Davide Perini <perini.davide@dpsoftware.org>
@@ -1871,7 +1935,7 @@ UNUSUAL_DEV( 0x2116, 0x0320, 0x0001, 0x0001,
 UNUSUAL_DEV(  0x22b8, 0x3010, 0x0001, 0x0001,
                 "Motorola",
                 "RAZR V3x",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_FIX_CAPACITY | US_FL_IGNORE_RESIDUE ),
 
 /*
@@ -1882,14 +1946,14 @@ UNUSUAL_DEV(  0x22b8, 0x3010, 0x0001, 0x0001,
 UNUSUAL_DEV(  0x22b8, 0x6426, 0x0101, 0x0101,
                 "Motorola",
                 "MSnc.",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_FIX_INQUIRY | US_FL_FIX_CAPACITY | US_FL_BULK_IGNORE_TAG),
 
 /* Reported by Radovan Garabik <garabik@kassiopeia.juls.savba.sk> */
 UNUSUAL_DEV(  0x2735, 0x100b, 0x0000, 0x9999,
                 "MPIO",
                 "HS200",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_GO_SLOW ),
 
 /* Reported by Frederic Marchal <frederic.marchal@wowcompany.com>
@@ -1898,21 +1962,21 @@ UNUSUAL_DEV(  0x2735, 0x100b, 0x0000, 0x9999,
 UNUSUAL_DEV(  0x3340, 0xffff, 0x0000, 0x0000,
                 "Mitac",
                 "Mio DigiWalker USB Sync",
-                US_SC_DEVICE,US_PR_DEVICE,NULL,
+                USB_SC_DEVICE,USB_PR_DEVICE,NULL,
                 US_FL_MAX_SECTORS_64 ),
 
 /* Reported by Andrey Rahmatullin <wrar@altlinux.org> */
 UNUSUAL_DEV(  0x4102, 0x1020, 0x0100,  0x0100,
                 "iRiver",
                 "MP3 T10",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_IGNORE_RESIDUE ),
 
 /* Reported by Sergey Pinaev <dfo@antex.ru> */
 UNUSUAL_DEV(  0x4102, 0x1059, 0x0000,  0x0000,
                "iRiver",
                "P7K",
-               US_SC_DEVICE, US_PR_DEVICE, NULL,
+               USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                US_FL_MAX_SECTORS_64 ),
 
 /*
@@ -1922,41 +1986,41 @@ UNUSUAL_DEV(  0x4102, 0x1059, 0x0000,  0x0000,
 UNUSUAL_DEV(  0x4146, 0xba01, 0x0100, 0x0100,
                 "Iomega",
                 "Micro Mini 1GB",
-                US_SC_DEVICE, US_PR_DEVICE, NULL, US_FL_NOT_LOCKABLE ),
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL, US_FL_NOT_LOCKABLE ),
 
 /* Reported by Andrew Simmons <andrew.simmons@gmail.com> */
 UNUSUAL_DEV(  0xed06, 0x4500, 0x0001, 0x0001,
                 "DataStor",
                 "USB4500 FW1.04",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_CAPACITY_HEURISTICS),
 
 /* Reported by Alessio Treglia <quadrispro@ubuntu.com> */
 UNUSUAL_DEV( 0xed10, 0x7636, 0x0001, 0x0001,
                 "TGE",
                 "Digital MP3 Audio Player",
-                US_SC_DEVICE, US_PR_DEVICE, NULL, US_FL_NOT_LOCKABLE ),
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL, US_FL_NOT_LOCKABLE ),
 
 /* Control/Bulk transport for all SubClass values */
-USUAL_DEV(US_SC_RBC, US_PR_CB, USB_US_TYPE_STOR),
-USUAL_DEV(US_SC_8020, US_PR_CB, USB_US_TYPE_STOR),
-USUAL_DEV(US_SC_QIC, US_PR_CB, USB_US_TYPE_STOR),
-USUAL_DEV(US_SC_UFI, US_PR_CB, USB_US_TYPE_STOR),
-USUAL_DEV(US_SC_8070, US_PR_CB, USB_US_TYPE_STOR),
-USUAL_DEV(US_SC_SCSI, US_PR_CB, USB_US_TYPE_STOR),
+USUAL_DEV(USB_SC_RBC, USB_PR_CB, USB_US_TYPE_STOR),
+USUAL_DEV(USB_SC_8020, USB_PR_CB, USB_US_TYPE_STOR),
+USUAL_DEV(USB_SC_QIC, USB_PR_CB, USB_US_TYPE_STOR),
+USUAL_DEV(USB_SC_UFI, USB_PR_CB, USB_US_TYPE_STOR),
+USUAL_DEV(USB_SC_8070, USB_PR_CB, USB_US_TYPE_STOR),
+USUAL_DEV(USB_SC_SCSI, USB_PR_CB, USB_US_TYPE_STOR),
 
 /* Control/Bulk/Interrupt transport for all SubClass values */
-USUAL_DEV(US_SC_RBC, US_PR_CBI, USB_US_TYPE_STOR),
-USUAL_DEV(US_SC_8020, US_PR_CBI, USB_US_TYPE_STOR),
-USUAL_DEV(US_SC_QIC, US_PR_CBI, USB_US_TYPE_STOR),
-USUAL_DEV(US_SC_UFI, US_PR_CBI, USB_US_TYPE_STOR),
-USUAL_DEV(US_SC_8070, US_PR_CBI, USB_US_TYPE_STOR),
-USUAL_DEV(US_SC_SCSI, US_PR_CBI, USB_US_TYPE_STOR),
+USUAL_DEV(USB_SC_RBC, USB_PR_CBI, USB_US_TYPE_STOR),
+USUAL_DEV(USB_SC_8020, USB_PR_CBI, USB_US_TYPE_STOR),
+USUAL_DEV(USB_SC_QIC, USB_PR_CBI, USB_US_TYPE_STOR),
+USUAL_DEV(USB_SC_UFI, USB_PR_CBI, USB_US_TYPE_STOR),
+USUAL_DEV(USB_SC_8070, USB_PR_CBI, USB_US_TYPE_STOR),
+USUAL_DEV(USB_SC_SCSI, USB_PR_CBI, USB_US_TYPE_STOR),
 
 /* Bulk-only transport for all SubClass values */
-USUAL_DEV(US_SC_RBC, US_PR_BULK, USB_US_TYPE_STOR),
-USUAL_DEV(US_SC_8020, US_PR_BULK, USB_US_TYPE_STOR),
-USUAL_DEV(US_SC_QIC, US_PR_BULK, USB_US_TYPE_STOR),
-USUAL_DEV(US_SC_UFI, US_PR_BULK, USB_US_TYPE_STOR),
-USUAL_DEV(US_SC_8070, US_PR_BULK, USB_US_TYPE_STOR),
-USUAL_DEV(US_SC_SCSI, US_PR_BULK, 0),
+USUAL_DEV(USB_SC_RBC, USB_PR_BULK, USB_US_TYPE_STOR),
+USUAL_DEV(USB_SC_8020, USB_PR_BULK, USB_US_TYPE_STOR),
+USUAL_DEV(USB_SC_QIC, USB_PR_BULK, USB_US_TYPE_STOR),
+USUAL_DEV(USB_SC_UFI, USB_PR_BULK, USB_US_TYPE_STOR),
+USUAL_DEV(USB_SC_8070, USB_PR_BULK, USB_US_TYPE_STOR),
+USUAL_DEV(USB_SC_SCSI, USB_PR_BULK, 0),
diff --git a/drivers/usb/storage/unusual_ene_ub6250.h b/drivers/usb/storage/unusual_ene_ub6250.h
new file mode 100644
index 000000000000..5667f5d365c6
--- /dev/null
+++ b/drivers/usb/storage/unusual_ene_ub6250.h
@@ -0,0 +1,26 @@
+/*
+ *
+ * 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, 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.
+ */
+
+#if defined(CONFIG_USB_STORAGE_ENE_UB6250) || \
+                defined(CONFIG_USB_STORAGE_ENE_UB6250_MODULE)
+
+UNUSUAL_DEV(0x0cf2, 0x6250, 0x0000, 0x9999,
+                "ENE",
+                "ENE UB6250 reader",
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL, 0),
+
+#endif /* defined(CONFIG_USB_STORAGE_ENE_UB6250) || ... */
diff --git a/drivers/usb/storage/unusual_freecom.h b/drivers/usb/storage/unusual_freecom.h
index 375867942391..59a261155b98 100644
--- a/drivers/usb/storage/unusual_freecom.h
+++ b/drivers/usb/storage/unusual_freecom.h
@@ -21,6 +21,6 @@
 UNUSUAL_DEV(  0x07ab, 0xfc01, 0x0000, 0x9999,
                 "Freecom",
                 "USB-IDE",
-                US_SC_QIC, US_PR_FREECOM, init_freecom, 0),
+                USB_SC_QIC, USB_PR_FREECOM, init_freecom, 0),
 
 #endif /* defined(CONFIG_USB_STORAGE_FREECOM) || ... */
diff --git a/drivers/usb/storage/unusual_isd200.h b/drivers/usb/storage/unusual_isd200.h
index 0d99dde3382a..14cca0c48302 100644
--- a/drivers/usb/storage/unusual_isd200.h
+++ b/drivers/usb/storage/unusual_isd200.h
@@ -21,37 +21,37 @@
 UNUSUAL_DEV(  0x054c, 0x002b, 0x0100, 0x0110,
                 "Sony",
                 "Portable USB Harddrive V2",
-                US_SC_ISD200, US_PR_BULK, isd200_Initialization,
+                USB_SC_ISD200, USB_PR_BULK, isd200_Initialization,
                 0),
 
 UNUSUAL_DEV(  0x05ab, 0x0031, 0x0100, 0x0110,
                 "In-System",
                 "USB/IDE Bridge (ATA/ATAPI)",
-                US_SC_ISD200, US_PR_BULK, isd200_Initialization,
+                USB_SC_ISD200, USB_PR_BULK, isd200_Initialization,
                 0),
 
 UNUSUAL_DEV(  0x05ab, 0x0301, 0x0100, 0x0110,
                 "In-System",
                 "Portable USB Harddrive V2",
-                US_SC_ISD200, US_PR_BULK, isd200_Initialization,
+                USB_SC_ISD200, USB_PR_BULK, isd200_Initialization,
                 0),
 
 UNUSUAL_DEV(  0x05ab, 0x0351, 0x0100, 0x0110,
                 "In-System",
                 "Portable USB Harddrive V2",
-                US_SC_ISD200, US_PR_BULK, isd200_Initialization,
+                USB_SC_ISD200, USB_PR_BULK, isd200_Initialization,
                 0),
 
 UNUSUAL_DEV(  0x05ab, 0x5701, 0x0100, 0x0110,
                 "In-System",
                 "USB Storage Adapter V2",
-                US_SC_ISD200, US_PR_BULK, isd200_Initialization,
+                USB_SC_ISD200, USB_PR_BULK, isd200_Initialization,
                 0),
 
 UNUSUAL_DEV(  0x0bf6, 0xa001, 0x0100, 0x0110,
                 "ATI",
                 "USB Cable 205",
-                US_SC_ISD200, US_PR_BULK, isd200_Initialization,
+                USB_SC_ISD200, USB_PR_BULK, isd200_Initialization,
                 0),
 
 #endif /* defined(CONFIG_USB_STORAGE_ISD200) || ... */
diff --git a/drivers/usb/storage/unusual_jumpshot.h b/drivers/usb/storage/unusual_jumpshot.h
index 2e549b1c2c62..54be78b5d643 100644
--- a/drivers/usb/storage/unusual_jumpshot.h
+++ b/drivers/usb/storage/unusual_jumpshot.h
@@ -21,7 +21,7 @@
 UNUSUAL_DEV(  0x05dc, 0x0001, 0x0000, 0x0001,
                 "Lexar",
                 "Jumpshot USB CF Reader",
-                US_SC_SCSI, US_PR_JUMPSHOT, NULL,
+                USB_SC_SCSI, USB_PR_JUMPSHOT, NULL,
                 US_FL_NEED_OVERRIDE),
 
 #endif /* defined(CONFIG_USB_STORAGE_JUMPSHOT) || ... */
diff --git a/drivers/usb/storage/unusual_karma.h b/drivers/usb/storage/unusual_karma.h
index 12ae3a03e802..6df03972a22c 100644
--- a/drivers/usb/storage/unusual_karma.h
+++ b/drivers/usb/storage/unusual_karma.h
@@ -21,6 +21,6 @@
 UNUSUAL_DEV(  0x045a, 0x5210, 0x0101, 0x0101,
                 "Rio",
                 "Rio Karma",
-                US_SC_SCSI, US_PR_KARMA, rio_karma_init, 0),
+                USB_SC_SCSI, USB_PR_KARMA, rio_karma_init, 0),
 
 #endif /* defined(CONFIG_USB_STORAGE_KARMA) || ... */
diff --git a/drivers/usb/storage/unusual_onetouch.h b/drivers/usb/storage/unusual_onetouch.h
index bd9306b637df..0abb819c7405 100644
--- a/drivers/usb/storage/unusual_onetouch.h
+++ b/drivers/usb/storage/unusual_onetouch.h
@@ -24,13 +24,13 @@
 UNUSUAL_DEV(  0x0d49, 0x7000, 0x0000, 0x9999,
                 "Maxtor",
                 "OneTouch External Harddrive",
-                US_SC_DEVICE, US_PR_DEVICE, onetouch_connect_input,
+                USB_SC_DEVICE, USB_PR_DEVICE, onetouch_connect_input,
                 0),
 
 UNUSUAL_DEV(  0x0d49, 0x7010, 0x0000, 0x9999,
                 "Maxtor",
                 "OneTouch External Harddrive",
-                US_SC_DEVICE, US_PR_DEVICE, onetouch_connect_input,
+                USB_SC_DEVICE, USB_PR_DEVICE, onetouch_connect_input,
                 0),
 
 #endif /* defined(CONFIG_USB_STORAGE_ONETOUCH) || ... */
diff --git a/drivers/usb/storage/unusual_realtek.h b/drivers/usb/storage/unusual_realtek.h
new file mode 100644
index 000000000000..e41f50c95ed4
--- /dev/null
+++ b/drivers/usb/storage/unusual_realtek.h
@@ -0,0 +1,41 @@
+/* Driver for Realtek RTS51xx USB card reader
+ *
+ * Copyright(c) 2009 Realtek Semiconductor Corp. All rights reserved.
+ *
+ * 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, 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, see <http://www.gnu.org/licenses/>.
+ *
+ * Author:
+ *   wwang (wei_wang@realsil.com.cn)
+ *   No. 450, Shenhu Road, Suzhou Industry Park, Suzhou, China
+ */
+
+#if defined(CONFIG_USB_STORAGE_REALTEK) || \
+                defined(CONFIG_USB_STORAGE_REALTEK_MODULE)
+
+UNUSUAL_DEV(0x0bda, 0x0138, 0x0000, 0x9999,
+                "Realtek",
+                "USB Card Reader",
+                USB_SC_DEVICE, USB_PR_DEVICE, init_realtek_cr, 0),
+
+UNUSUAL_DEV(0x0bda, 0x0158, 0x0000, 0x9999,
+                "Realtek",
+                "USB Card Reader",
+                USB_SC_DEVICE, USB_PR_DEVICE, init_realtek_cr, 0),
+
+UNUSUAL_DEV(0x0bda, 0x0159, 0x0000, 0x9999,
+                "Realtek",
+                "USB Card Reader",
+                USB_SC_DEVICE, USB_PR_DEVICE, init_realtek_cr, 0),
+
+#endif  /* defined(CONFIG_USB_STORAGE_REALTEK) || ... */
diff --git a/drivers/usb/storage/unusual_sddr09.h b/drivers/usb/storage/unusual_sddr09.h
index 50cab511a4d7..59a7e37b6c11 100644
--- a/drivers/usb/storage/unusual_sddr09.h
+++ b/drivers/usb/storage/unusual_sddr09.h
@@ -21,36 +21,36 @@
 UNUSUAL_DEV(  0x0436, 0x0005, 0x0100, 0x0100,
                 "Microtech",
                 "CameraMate (DPCM_USB)",
-                US_SC_SCSI, US_PR_DPCM_USB, NULL, 0),
+                USB_SC_SCSI, USB_PR_DPCM_USB, NULL, 0),
 
 UNUSUAL_DEV(  0x04e6, 0x0003, 0x0000, 0x9999,
                 "Sandisk",
                 "ImageMate SDDR09",
-                US_SC_SCSI, US_PR_EUSB_SDDR09, usb_stor_sddr09_init,
+                USB_SC_SCSI, USB_PR_EUSB_SDDR09, usb_stor_sddr09_init,
                 0),
 
 /* This entry is from Andries.Brouwer@cwi.nl */
 UNUSUAL_DEV(  0x04e6, 0x0005, 0x0100, 0x0208,
                 "SCM Microsystems",
                 "eUSB SmartMedia / CompactFlash Adapter",
-                US_SC_SCSI, US_PR_DPCM_USB, usb_stor_sddr09_dpcm_init,
+                USB_SC_SCSI, USB_PR_DPCM_USB, usb_stor_sddr09_dpcm_init,
                 0),
 
 UNUSUAL_DEV(  0x066b, 0x0105, 0x0100, 0x0100,
                 "Olympus",
                 "Camedia MAUSB-2",
-                US_SC_SCSI, US_PR_EUSB_SDDR09, usb_stor_sddr09_init,
+                USB_SC_SCSI, USB_PR_EUSB_SDDR09, usb_stor_sddr09_init,
                 0),
 
 UNUSUAL_DEV(  0x0781, 0x0200, 0x0000, 0x9999,
                 "Sandisk",
                 "ImageMate SDDR-09",
-                US_SC_SCSI, US_PR_EUSB_SDDR09, usb_stor_sddr09_init,
+                USB_SC_SCSI, USB_PR_EUSB_SDDR09, usb_stor_sddr09_init,
                 0),
 
 UNUSUAL_DEV(  0x07af, 0x0006, 0x0100, 0x0100,
                 "Microtech",
                 "CameraMate (DPCM_USB)",
-                US_SC_SCSI, US_PR_DPCM_USB, NULL, 0),
+                USB_SC_SCSI, USB_PR_DPCM_USB, NULL, 0),
 
 #endif /* defined(CONFIG_USB_STORAGE_SDDR09) || ... */
diff --git a/drivers/usb/storage/unusual_sddr55.h b/drivers/usb/storage/unusual_sddr55.h
index ae81ef7a1cfd..fcb7e12c598f 100644
--- a/drivers/usb/storage/unusual_sddr55.h
+++ b/drivers/usb/storage/unusual_sddr55.h
@@ -22,23 +22,23 @@
 UNUSUAL_DEV( 0x07c4, 0xa103, 0x0000, 0x9999,
                 "Datafab",
                 "MDSM-B reader",
-                US_SC_SCSI, US_PR_SDDR55, NULL,
+                USB_SC_SCSI, USB_PR_SDDR55, NULL,
                 US_FL_FIX_INQUIRY),
 
 /* SM part - aeb <Andries.Brouwer@cwi.nl> */
 UNUSUAL_DEV(  0x07c4, 0xa109, 0x0000, 0xffff,
                 "Datafab Systems, Inc.",
                 "USB to CF + SM Combo (LC1)",
-                US_SC_SCSI, US_PR_SDDR55, NULL, 0),
+                USB_SC_SCSI, USB_PR_SDDR55, NULL, 0),
 
 UNUSUAL_DEV( 0x0c0b, 0xa109, 0x0000, 0xffff,
                 "Acomdata",
                 "SM",
-                US_SC_SCSI, US_PR_SDDR55, NULL, 0),
+                USB_SC_SCSI, USB_PR_SDDR55, NULL, 0),
 
 UNUSUAL_DEV(  0x55aa, 0xa103, 0x0000, 0x9999,
                 "Sandisk",
                 "ImageMate SDDR55",
-                US_SC_SCSI, US_PR_SDDR55, NULL, 0),
+                USB_SC_SCSI, USB_PR_SDDR55, NULL, 0),
 
 #endif /* defined(CONFIG_USB_STORAGE_SDDR55) || ... */
diff --git a/drivers/usb/storage/unusual_usbat.h b/drivers/usb/storage/unusual_usbat.h
index 80e869f10180..38e79c4e6d6a 100644
--- a/drivers/usb/storage/unusual_usbat.h
+++ b/drivers/usb/storage/unusual_usbat.h
@@ -21,23 +21,23 @@
 UNUSUAL_DEV(  0x03f0, 0x0207, 0x0001, 0x0001,
                 "HP",
                 "CD-Writer+ 8200e",
-                US_SC_8070, US_PR_USBAT, init_usbat_cd, 0),
+                USB_SC_8070, USB_PR_USBAT, init_usbat_cd, 0),
 
 UNUSUAL_DEV(  0x03f0, 0x0307, 0x0001, 0x0001,
                 "HP",
                 "CD-Writer+ CD-4e",
-                US_SC_8070, US_PR_USBAT, init_usbat_cd, 0),
+                USB_SC_8070, USB_PR_USBAT, init_usbat_cd, 0),
 
 UNUSUAL_DEV(  0x04e6, 0x1010, 0x0000, 0x9999,
                 "Shuttle/SCM",
                 "USBAT-02",
-                US_SC_SCSI, US_PR_USBAT, init_usbat_flash,
+                USB_SC_SCSI, USB_PR_USBAT, init_usbat_flash,
                 US_FL_SINGLE_LUN),
 
 UNUSUAL_DEV(  0x0781, 0x0005, 0x0005, 0x0005,
                 "Sandisk",
                 "ImageMate SDDR-05b",
-                US_SC_SCSI, US_PR_USBAT, init_usbat_flash,
+                USB_SC_SCSI, USB_PR_USBAT, init_usbat_flash,
                 US_FL_SINGLE_LUN),
 
 #endif /* defined(CONFIG_USB_STORAGE_USBAT) || ... */
diff --git a/drivers/usb/storage/usb.c b/drivers/usb/storage/usb.c
index 90bb0175a152..0ca095820f3e 100644
--- a/drivers/usb/storage/usb.c
+++ b/drivers/usb/storage/usb.c
@@ -439,7 +439,9 @@ static void adjust_quirks(struct us_data *us)
                         US_FL_CAPACITY_HEURISTICS | US_FL_IGNORE_DEVICE |
                         US_FL_NOT_LOCKABLE | US_FL_MAX_SECTORS_64 |
                         US_FL_CAPACITY_OK | US_FL_IGNORE_RESIDUE |
-                        US_FL_SINGLE_LUN | US_FL_NO_WP_DETECT);
+                        US_FL_SINGLE_LUN | US_FL_NO_WP_DETECT |
+                        US_FL_NO_READ_DISC_INFO | US_FL_NO_READ_CAPACITY_16 |
+                        US_FL_INITIAL_READ10);
 
         p = quirks;
         while (*p) {
@@ -471,6 +473,12 @@ static void adjust_quirks(struct us_data *us)
                 case 'c':
                         f |= US_FL_FIX_CAPACITY;
                         break;
+                case 'd':
+                        f |= US_FL_NO_READ_DISC_INFO;
+                        break;
+                case 'e':
+                        f |= US_FL_NO_READ_CAPACITY_16;
+                        break;
                 case 'h':
                         f |= US_FL_CAPACITY_HEURISTICS;
                         break;
@@ -483,6 +491,9 @@ static void adjust_quirks(struct us_data *us)
                 case 'm':
                         f |= US_FL_MAX_SECTORS_64;
                         break;
+                case 'n':
+                        f |= US_FL_INITIAL_READ10;
+                        break;
                 case 'o':
                         f |= US_FL_CAPACITY_OK;
                         break;
@@ -512,10 +523,10 @@ static int get_device_info(struct us_data *us, const struct usb_device_id *id,
 
         /* Store the entries */
         us->unusual_dev = unusual_dev;
-        us->subclass = (unusual_dev->useProtocol == US_SC_DEVICE) ?
+        us->subclass = (unusual_dev->useProtocol == USB_SC_DEVICE) ?
                         idesc->bInterfaceSubClass :
                         unusual_dev->useProtocol;
-        us->protocol = (unusual_dev->useTransport == US_PR_DEVICE) ?
+        us->protocol = (unusual_dev->useTransport == USB_PR_DEVICE) ?
                         idesc->bInterfaceProtocol :
                         unusual_dev->useTransport;
         us->fflags = USB_US_ORIG_FLAGS(id->driver_info);
@@ -552,10 +563,10 @@ static int get_device_info(struct us_data *us, const struct usb_device_id *id,
                 struct usb_device_descriptor *ddesc = &dev->descriptor;
                 int msg = -1;
 
-                if (unusual_dev->useProtocol != US_SC_DEVICE &&
+                if (unusual_dev->useProtocol != USB_SC_DEVICE &&
                         us->subclass == idesc->bInterfaceSubClass)
                         msg += 1;
-                if (unusual_dev->useTransport != US_PR_DEVICE &&
+                if (unusual_dev->useTransport != USB_PR_DEVICE &&
                         us->protocol == idesc->bInterfaceProtocol)
                         msg += 2;
                 if (msg >= 0 && !(us->fflags & US_FL_NEED_OVERRIDE))
@@ -582,21 +593,21 @@ static int get_device_info(struct us_data *us, const struct usb_device_id *id,
 static void get_transport(struct us_data *us)
 {
         switch (us->protocol) {
-        case US_PR_CB:
+        case USB_PR_CB:
                 us->transport_name = "Control/Bulk";
                 us->transport = usb_stor_CB_transport;
                 us->transport_reset = usb_stor_CB_reset;
                 us->max_lun = 7;
                 break;
 
-        case US_PR_CBI:
+        case USB_PR_CBI:
                 us->transport_name = "Control/Bulk/Interrupt";
                 us->transport = usb_stor_CB_transport;
                 us->transport_reset = usb_stor_CB_reset;
                 us->max_lun = 7;
                 break;
 
-        case US_PR_BULK:
+        case USB_PR_BULK:
                 us->transport_name = "Bulk";
                 us->transport = usb_stor_Bulk_transport;
                 us->transport_reset = usb_stor_Bulk_reset;
@@ -608,35 +619,35 @@ static void get_transport(struct us_data *us)
 static void get_protocol(struct us_data *us)
 {
         switch (us->subclass) {
-        case US_SC_RBC:
+        case USB_SC_RBC:
                 us->protocol_name = "Reduced Block Commands (RBC)";
                 us->proto_handler = usb_stor_transparent_scsi_command;
                 break;
 
-        case US_SC_8020:
+        case USB_SC_8020:
                 us->protocol_name = "8020i";
                 us->proto_handler = usb_stor_pad12_command;
                 us->max_lun = 0;
                 break;
 
-        case US_SC_QIC:
+        case USB_SC_QIC:
                 us->protocol_name = "QIC-157";
                 us->proto_handler = usb_stor_pad12_command;
                 us->max_lun = 0;
                 break;
 
-        case US_SC_8070:
+        case USB_SC_8070:
                 us->protocol_name = "8070i";
                 us->proto_handler = usb_stor_pad12_command;
                 us->max_lun = 0;
                 break;
 
-        case US_SC_SCSI:
+        case USB_SC_SCSI:
                 us->protocol_name = "Transparent SCSI";
                 us->proto_handler = usb_stor_transparent_scsi_command;
                 break;
 
-        case US_SC_UFI:
+        case USB_SC_UFI:
                 us->protocol_name = "Uniform Floppy Interface (UFI)";
                 us->proto_handler = usb_stor_ufi_command;
                 break;
@@ -679,7 +690,7 @@ static int get_pipes(struct us_data *us)
                 }
         }
 
-        if (!ep_in || !ep_out || (us->protocol == US_PR_CBI && !ep_int)) {
+        if (!ep_in || !ep_out || (us->protocol == USB_PR_CBI && !ep_int)) {
                 US_DEBUGP("Endpoint sanity check failed! Rejecting dev.\n");
                 return -EIO;
         }
@@ -834,7 +845,7 @@ static int usb_stor_scan_thread(void * __us)
         if (!test_bit(US_FLIDX_DONT_SCAN, &us->dflags)) {
 
                 /* For bulk-only devices, determine the max LUN value */
-                if (us->protocol == US_PR_BULK &&
+                if (us->protocol == USB_PR_BULK &&
                                 !(us->fflags & US_FL_SINGLE_LUN)) {
                         mutex_lock(&us->dev_mutex);
                         us->max_lun = usb_stor_Bulk_max_lun(us);
@@ -946,6 +957,13 @@ int usb_stor_probe2(struct us_data *us)
         if (result)
                 goto BadDevice;
 
+        /*
+         * If the device returns invalid data for the first READ(10)
+         * command, indicate the command should be retried.
+         */
+        if (us->fflags & US_FL_INITIAL_READ10)
+                set_bit(US_FLIDX_REDO_READ10, &us->dflags);
+
         /* Acquire all the other resources and add the host */
         result = usb_stor_acquire_resources(us);
         if (result)
diff --git a/drivers/usb/storage/usb.h b/drivers/usb/storage/usb.h
index 89d3bfff98df..7b0f2113632e 100644
--- a/drivers/usb/storage/usb.h
+++ b/drivers/usb/storage/usb.h
@@ -73,6 +73,8 @@ struct us_unusual_dev {
 #define US_FLIDX_RESETTING      4       /* device reset in progress */
 #define US_FLIDX_TIMED_OUT      5       /* SCSI midlayer timed out  */
 #define US_FLIDX_DONT_SCAN      6       /* don't scan (disconnect)  */
+#define US_FLIDX_REDO_READ10    7       /* redo READ(10) command    */
+#define US_FLIDX_READ10_WORKED  8       /* previous READ(10) succeeded */
 
 #define USB_STOR_STRING_LEN 32
 
diff --git a/drivers/usb/storage/usual-tables.c b/drivers/usb/storage/usual-tables.c
index 468bde7d1971..b96927914f89 100644
--- a/drivers/usb/storage/usual-tables.c
+++ b/drivers/usb/storage/usual-tables.c
@@ -80,11 +80,13 @@ static struct ignore_entry ignore_ids[] = {
 #       include "unusual_alauda.h"
 #       include "unusual_cypress.h"
 #       include "unusual_datafab.h"
+#       include "unusual_ene_ub6250.h"
 #       include "unusual_freecom.h"
 #       include "unusual_isd200.h"
 #       include "unusual_jumpshot.h"
 #       include "unusual_karma.h"
 #       include "unusual_onetouch.h"
+#       include "unusual_realtek.h"
 #       include "unusual_sddr09.h"
 #       include "unusual_sddr55.h"
 #       include "unusual_usbat.h"
diff --git a/drivers/usb/usb-skeleton.c b/drivers/usb/usb-skeleton.c
index 552679b8dbd1..e24ce3123071 100644
--- a/drivers/usb/usb-skeleton.c
+++ b/drivers/usb/usb-skeleton.c
@@ -507,6 +507,7 @@ static const struct file_operations skel_fops = {
         .open =         skel_open,
         .release =      skel_release,
         .flush =        skel_flush,
+        .llseek =       noop_llseek,
 };
 
 /*
diff --git a/drivers/usb/wusbcore/Makefile b/drivers/usb/wusbcore/Makefile
index 75f1ade66258..b3bd313032b1 100644
--- a/drivers/usb/wusbcore/Makefile
+++ b/drivers/usb/wusbcore/Makefile
@@ -1,9 +1,11 @@
+ccflags-$(CONFIG_USB_WUSB_CBAF_DEBUG) := -DDEBUG
+
 obj-$(CONFIG_USB_WUSB)          += wusbcore.o
 obj-$(CONFIG_USB_HWA_HCD)       += wusb-wa.o
 obj-$(CONFIG_USB_WUSB_CBAF)     += wusb-cbaf.o
 
 
-wusbcore-objs :=        \
+wusbcore-y :=           \
         crypto.o        \
         devconnect.o    \
         dev-sysfs.o     \
@@ -14,13 +16,10 @@ wusbcore-objs := 	\
         security.o      \
         wusbhc.o
 
-wusb-cbaf-objs := cbaf.o
-
-wusb-wa-objs := wa-hc.o         \
-                wa-nep.o        \
-                wa-rpipe.o      \
-                wa-xfer.o
+wusb-cbaf-y := cbaf.o
 
-ifeq ($(CONFIG_USB_WUSB_CBAF_DEBUG),y)
-EXTRA_CFLAGS += -DDEBUG
-endif
+wusb-wa-y :=            \
+        wa-hc.o         \
+        wa-nep.o        \
+        wa-rpipe.o      \
+        wa-xfer.o
diff --git a/drivers/usb/wusbcore/crypto.c b/drivers/usb/wusbcore/crypto.c
index 827c87f10cc5..7e4bf95f8f7b 100644
--- a/drivers/usb/wusbcore/crypto.c
+++ b/drivers/usb/wusbcore/crypto.c
@@ -180,7 +180,7 @@ static void bytewise_xor(void *_bo, const void *_bi1, const void *_bi2,
  *     using the 14 bytes of @a to fill up
  *     b1.{mac_header,e0,security_reserved,padding}.
  *
- * NOTE: The definiton of l(a) in WUSB1.0[6.5] vs the definition of
+ * NOTE: The definition of l(a) in WUSB1.0[6.5] vs the definition of
  *       l(m) is orthogonal, they bear no relationship, so it is not
  *       in conflict with the parameter's relation that
  *       WUSB1.0[6.4.2]) defines.
@@ -272,7 +272,7 @@ static int wusb_ccm_mac(struct crypto_blkcipher *tfm_cbc,
 
         /* Now we crypt the MIC Tag (*iv) with Ax -- values per WUSB1.0[6.5]
          * The procedure is to AES crypt the A0 block and XOR the MIC
-         * Tag agains it; we only do the first 8 bytes and place it
+         * Tag against it; we only do the first 8 bytes and place it
          * directly in the destination buffer.
          *
          * POS Crypto API: size is assumed to be AES's block size.
diff --git a/drivers/usb/wusbcore/reservation.c b/drivers/usb/wusbcore/reservation.c
index 4ed97360c046..6f4fafdc2401 100644
--- a/drivers/usb/wusbcore/reservation.c
+++ b/drivers/usb/wusbcore/reservation.c
@@ -71,7 +71,7 @@ static void wusbhc_rsv_complete_cb(struct uwb_rsv *rsv)
 
 /**
  * wusbhc_rsv_establish - establish a reservation for the cluster
- * @wusbhc: the WUSB HC requesting a bandwith reservation
+ * @wusbhc: the WUSB HC requesting a bandwidth reservation
  */
 int wusbhc_rsv_establish(struct wusbhc *wusbhc)
 {
diff --git a/drivers/usb/wusbcore/rh.c b/drivers/usb/wusbcore/rh.c
index a68ad7aa0b59..39de3900ad20 100644
--- a/drivers/usb/wusbcore/rh.c
+++ b/drivers/usb/wusbcore/rh.c
@@ -133,7 +133,7 @@ static int wusbhc_rh_port_reset(struct wusbhc *wusbhc, u8 port_idx)
  *           big of a problem [and we can't make it an spinlock
  *           because other parts need to take it and sleep] .
  *
- *           @usb_hcd is refcounted, so it won't dissapear under us
+ *           @usb_hcd is refcounted, so it won't disappear under us
  *           and before killing a host, the polling of the root hub
  *           would be stopped anyway.
  */
@@ -156,7 +156,7 @@ int wusbhc_rh_status_data(struct usb_hcd *usb_hcd, char *_buf)
 EXPORT_SYMBOL_GPL(wusbhc_rh_status_data);
 
 /*
- * Return the hub's desciptor
+ * Return the hub's descriptor
  *
  * NOTE: almost cut and paste from ehci-hub.c
  *
@@ -184,8 +184,8 @@ static int wusbhc_rh_get_hub_descr(struct wusbhc *wusbhc, u16 wValue,
         descr->bPwrOn2PwrGood = 0;
         descr->bHubContrCurrent = 0;
         /* two bitmaps:  ports removable, and usb 1.0 legacy PortPwrCtrlMask */
-        memset(&descr->bitmap[0], 0, temp);
-        memset(&descr->bitmap[temp], 0xff, temp);
+        memset(&descr->u.hs.DeviceRemovable[0], 0, temp);
+        memset(&descr->u.hs.DeviceRemovable[temp], 0xff, temp);
         return 0;
 }
 
diff --git a/drivers/usb/wusbcore/wa-rpipe.c b/drivers/usb/wusbcore/wa-rpipe.c
index c7b1d8108de9..ca80171f42c6 100644
--- a/drivers/usb/wusbcore/wa-rpipe.c
+++ b/drivers/usb/wusbcore/wa-rpipe.c
@@ -24,7 +24,7 @@
  *
  * RPIPE
  *
- *   Targetted at different downstream endpoints
+ *   Targeted at different downstream endpoints
  *
  *   Descriptor: use to config the remote pipe.
  *
@@ -49,7 +49,7 @@
  *
  *  USB Stack port number    4 (1 based)
  *  WUSB code port index     3 (0 based)
- *  USB Addresss             5 (2 based -- 0 is for default, 1 for root hub)
+ *  USB Address             5 (2 based -- 0 is for default, 1 for root hub)
  *
  *  Now, because we don't use the concept as default address exactly
  *  like the (wired) USB code does, we need to kind of skip it. So we
diff --git a/drivers/usb/wusbcore/wa-xfer.c b/drivers/usb/wusbcore/wa-xfer.c
index 84b744c428a4..6ccd93a9b909 100644
--- a/drivers/usb/wusbcore/wa-xfer.c
+++ b/drivers/usb/wusbcore/wa-xfer.c
@@ -61,7 +61,7 @@
  *
  *     Two methods it could be done:
  *
- *     (a) set up a timer everytime an rpipe's use count drops to 1
+ *     (a) set up a timer every time an rpipe's use count drops to 1
  *         (which means unused) or when a transfer ends. Reset the
  *         timer when a xfer is queued. If the timer expires, release
  *         the rpipe [see rpipe_ep_disable()].
@@ -140,7 +140,7 @@ struct wa_xfer {
 
         struct wahc *wa;                /* Wire adapter we are plugged to */
         struct usb_host_endpoint *ep;
-        struct urb *urb;                /* URB we are transfering for */
+        struct urb *urb;                /* URB we are transferring for */
         struct wa_seg **seg;            /* transfer segments */
         u8 segs, segs_submitted, segs_done;
         unsigned is_inbound:1;
@@ -161,7 +161,7 @@ static inline void wa_xfer_init(struct wa_xfer *xfer)
 }
 
 /*
- * Destory a transfer structure
+ * Destroy a transfer structure
  *
  * Note that the xfer->seg[index] thingies follow the URB life cycle,
  * so we need to put them, not free them.
@@ -494,7 +494,7 @@ static void __wa_xfer_setup_hdr0(struct wa_xfer *xfer,
  * function does almost the same thing and they work closely
  * together.
  *
- * If the seg request has failed but this DTO phase has suceeded,
+ * If the seg request has failed but this DTO phase has succeeded,
  * wa_seg_cb() has already failed the segment and moved the
  * status to WA_SEG_ERROR, so this will go through 'case 0' and
  * effectively do nothing.
diff --git a/drivers/usb/wusbcore/wusbhc.c b/drivers/usb/wusbcore/wusbhc.c
index 2054d4ee9774..0faca16df765 100644
--- a/drivers/usb/wusbcore/wusbhc.c
+++ b/drivers/usb/wusbcore/wusbhc.c
@@ -320,7 +320,7 @@ u8 wusb_cluster_id_get(void)
         u8 id;
         spin_lock(&wusb_cluster_ids_lock);
         id = find_first_zero_bit(wusb_cluster_id_table, CLUSTER_IDS);
-        if (id > CLUSTER_IDS) {
+        if (id >= CLUSTER_IDS) {
                 id = 0;
                 goto out;
         }
diff --git a/drivers/usb/wusbcore/wusbhc.h b/drivers/usb/wusbcore/wusbhc.h
index 3d94c4247f46..3a2d09162e70 100644
--- a/drivers/usb/wusbcore/wusbhc.h
+++ b/drivers/usb/wusbcore/wusbhc.h
@@ -132,7 +132,7 @@ static inline void wusb_dev_put(struct wusb_dev *wusb_dev)
 }
 
 /**
- * Wireless USB Host Controlller root hub "fake" ports
+ * Wireless USB Host Controller root hub "fake" ports
  * (state and device information)
  *
  * Wireless USB is wireless, so there are no ports; but we
@@ -231,7 +231,7 @@ struct wusb_port {
  *
  *    Most of the times when you need to use it, it will be non-NULL,
  *    so there is no real need to check for it (wusb_dev will
- *    dissapear before usb_dev).
+ *    disappear before usb_dev).
  *
  *  - The following fields need to be filled out before calling
  *    wusbhc_create(): ports_max, mmcies_max, mmcie_{add,rm}.