19 files changed, 131 insertions, 438 deletions

diff --git a/drivers/usb/musb/Kconfig b/drivers/usb/musb/Kconfig
index 13093481f91..fc34b8b1191 100644
--- a/drivers/usb/musb/Kconfig
+++ b/drivers/usb/musb/Kconfig
@@ -3,12 +3,9 @@
 # for silicon based on Mentor Graphics INVENTRA designs
 #
 
-comment "Enable Host or Gadget support to see Inventra options"
-        depends on !USB && USB_GADGET=n
-
 # (M)HDRC = (Multipoint) Highspeed Dual-Role Controller
 config USB_MUSB_HDRC
-        depends on (USB || USB_GADGET)
+        depends on USB && USB_GADGET
         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
@@ -67,79 +64,6 @@ config USB_MUSB_UX500
 
 endchoice
 
-choice
-        prompt "Driver Mode"
-        depends on USB_MUSB_HDRC
-        help
-          Dual-Role devices can support both host and peripheral roles,
-          as well as a the special "OTG Device" role which can switch
-          between both roles as needed.
-
-# use USB_MUSB_HDRC_HCD not USB_MUSB_HOST to #ifdef host side support;
-# OTG needs both roles, not just USB_MUSB_HOST.
-config USB_MUSB_HOST
-        depends on USB
-        bool "USB Host"
-        help
-          Say Y here if your system supports the USB host role.
-          If it has a USB "A" (rectangular), "Mini-A" (uncommon),
-          or "Mini-AB" connector, it supports the host role.
-          (With a "Mini-AB" connector, you should enable USB OTG.)
-
-# use USB_GADGET_MUSB_HDRC not USB_MUSB_PERIPHERAL to #ifdef peripheral
-# side support ... OTG needs both roles
-config USB_MUSB_PERIPHERAL
-        depends on USB_GADGET
-        bool "USB Peripheral (gadget stack)"
-        select USB_GADGET_MUSB_HDRC
-        help
-          Say Y here if your system supports the USB peripheral role.
-          If it has a USB "B" (squarish), "Mini-B", or "Mini-AB"
-          connector, it supports the peripheral role.
-          (With a "Mini-AB" connector, you should enable USB OTG.)
-
-config USB_MUSB_OTG
-        depends on USB && USB_GADGET && PM && EXPERIMENTAL
-        bool "Both host and peripheral:  USB OTG (On The Go) Device"
-        select USB_GADGET_MUSB_HDRC
-        select USB_OTG
-        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.
-
-           At this writing, the OTG support in this driver is incomplete,
-           omitting the mandatory HNP or SRP protocols.  However, some
-           of the cable based role switching works.  (That is, grounding
-           the ID pin switches the controller to host mode, while leaving
-           it floating leaves it in peripheral mode.)
-
-           Select this if your system has a Mini-AB connector, or
-           to simplify certain kinds of configuration.
-
-           To implement your OTG Targeted Peripherals List (TPL), enable
-           USB_OTG_WHITELIST and update "drivers/usb/core/otg_whitelist.h"
-           to match your requirements.
-
-endchoice
-
-# enable peripheral support (including with OTG)
-config USB_GADGET_MUSB_HDRC
-        bool
-        depends on USB_MUSB_HDRC && (USB_MUSB_PERIPHERAL || USB_MUSB_OTG)
-#       default y
-#       select USB_GADGET_DUALSPEED
-#       select USB_GADGET_SELECTED
-
-# enables host support (including with OTG)
-config USB_MUSB_HDRC_HCD
-        bool
-        depends on USB_MUSB_HDRC && (USB_MUSB_HOST || USB_MUSB_OTG)
-        select USB_OTG if USB_GADGET_MUSB_HDRC
-        default y
-
-
 config MUSB_PIO_ONLY
         bool 'Disable DMA (always use PIO)'
         depends on USB_MUSB_HDRC
diff --git a/drivers/usb/musb/Makefile b/drivers/usb/musb/Makefile
index c4d228b6ef8..d8fd9d092de 100644
--- a/drivers/usb/musb/Makefile
+++ b/drivers/usb/musb/Makefile
@@ -6,8 +6,8 @@ obj-$(CONFIG_USB_MUSB_HDRC) += musb_hdrc.o
 
 musb_hdrc-y := musb_core.o
 
-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-y                                     += musb_gadget_ep0.o musb_gadget.o
+musb_hdrc-y                                     += musb_virthub.o musb_host.o
 musb_hdrc-$(CONFIG_DEBUG_FS)                    += musb_debugfs.o
 
 # Hardware Glue Layer
diff --git a/drivers/usb/musb/am35x.c b/drivers/usb/musb/am35x.c
index 23ac28f98d9..08f1d0b662a 100644
--- a/drivers/usb/musb/am35x.c
+++ b/drivers/usb/musb/am35x.c
@@ -124,11 +124,7 @@ static void am35x_musb_disable(struct musb *musb)
         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)
 {
diff --git a/drivers/usb/musb/blackfin.c b/drivers/usb/musb/blackfin.c
index ae8c3961774..5e7cfba5b07 100644
--- a/drivers/usb/musb/blackfin.c
+++ b/drivers/usb/musb/blackfin.c
@@ -17,6 +17,7 @@
 #include <linux/io.h>
 #include <linux/platform_device.h>
 #include <linux/dma-mapping.h>
+#include <linux/prefetch.h>
 
 #include <asm/cacheflush.h>
 
diff --git a/drivers/usb/musb/blackfin.h b/drivers/usb/musb/blackfin.h
index bd9352a2ef2..c84dae546dc 100644
--- a/drivers/usb/musb/blackfin.h
+++ b/drivers/usb/musb/blackfin.h
@@ -47,7 +47,7 @@
  * So, need to either use silicon v0.2+ or disable DMA mode in MUSB.
  */
 #if ANOMALY_05000380 && defined(CONFIG_BF52x) && \
-    defined(CONFIG_USB_MUSB_HDRC) && !defined(CONFIG_MUSB_PIO_ONLY)
+        !defined(CONFIG_MUSB_PIO_ONLY)
 # error "Please use PIO mode in MUSB driver on bf52x chip v0.0 and v0.1"
 #endif
 
diff --git a/drivers/usb/musb/cppi_dma.c b/drivers/usb/musb/cppi_dma.c
index 149f3f310a0..318fb4e8a88 100644
--- a/drivers/usb/musb/cppi_dma.c
+++ b/drivers/usb/musb/cppi_dma.c
@@ -226,8 +226,10 @@ static int cppi_controller_stop(struct dma_controller *c)
         struct cppi             *controller;
         void __iomem            *tibase;
         int                     i;
+        struct musb             *musb;
 
         controller = container_of(c, struct cppi, controller);
+        musb = controller->musb;
 
         tibase = controller->tibase;
         /* DISABLE INDIVIDUAL CHANNEL Interrupts */
@@ -289,9 +291,11 @@ cppi_channel_allocate(struct dma_controller *c,
         u8                      index;
         struct cppi_channel     *cppi_ch;
         void __iomem            *tibase;
+        struct musb             *musb;
 
         controller = container_of(c, struct cppi, controller);
         tibase = controller->tibase;
+        musb = controller->musb;
 
         /* ep0 doesn't use DMA; remember cppi indices are 0..N-1 */
         index = ep->epnum - 1;
@@ -339,7 +343,8 @@ 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)
-                dev_dbg(musb->controller, "releasing idle DMA channel %p\n", c);
+                dev_dbg(c->controller->musb->controller,
+                        "releasing idle DMA channel %p\n", c);
         else if (!c->transmit)
                 core_rxirq_enable(tibase, c->index + 1);
 
@@ -357,10 +362,11 @@ cppi_dump_rx(int level, struct cppi_channel *c, const char *tag)
 
         musb_ep_select(base, c->index + 1);
 
-        DBG(level, "RX DMA%d%s: %d left, csr %04x, "
-                        "%08x H%08x S%08x C%08x, "
-                        "B%08x L%08x %08x .. %08x"
-                        "\n",
+        dev_dbg(c->controller->musb->controller,
+                "RX DMA%d%s: %d left, csr %04x, "
+                "%08x H%08x S%08x C%08x, "
+                "B%08x L%08x %08x .. %08x"
+                "\n",
                 c->index, tag,
                 musb_readl(c->controller->tibase,
                         DAVINCI_RXCPPI_BUFCNT0_REG + 4 * c->index),
@@ -387,10 +393,11 @@ cppi_dump_tx(int level, struct cppi_channel *c, const char *tag)
 
         musb_ep_select(base, c->index + 1);
 
-        DBG(level, "TX DMA%d%s: csr %04x, "
-                        "H%08x S%08x C%08x %08x, "
-                        "F%08x L%08x .. %08x"
-                        "\n",
+        dev_dbg(c->controller->musb->controller,
+                "TX DMA%d%s: csr %04x, "
+                "H%08x S%08x C%08x %08x, "
+                "F%08x L%08x .. %08x"
+                "\n",
                 c->index, tag,
                 musb_readw(c->hw_ep->regs, MUSB_TXCSR),
 
@@ -1022,6 +1029,7 @@ static bool cppi_rx_scan(struct cppi *cppi, unsigned ch)
         int                             i;
         dma_addr_t                      safe2ack;
         void __iomem                    *regs = rx->hw_ep->regs;
+        struct musb                     *musb = cppi->musb;
 
         cppi_dump_rx(6, rx, "/K");
 
diff --git a/drivers/usb/musb/da8xx.c b/drivers/usb/musb/da8xx.c
index 662ed34980b..4da7492ddbd 100644
--- a/drivers/usb/musb/da8xx.c
+++ b/drivers/usb/musb/da8xx.c
@@ -172,11 +172,7 @@ static void da8xx_musb_disable(struct musb *musb)
         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
+#define portstate(stmt)         stmt
 
 static void da8xx_musb_set_vbus(struct musb *musb, int is_on)
 {
@@ -397,21 +393,15 @@ static int da8xx_musb_set_mode(struct musb *musb, u8 musb_mode)
 
         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);
         }
diff --git a/drivers/usb/musb/davinci.c b/drivers/usb/musb/davinci.c
index 2a2adf6492c..8bdf25a8b02 100644
--- a/drivers/usb/musb/davinci.c
+++ b/drivers/usb/musb/davinci.c
@@ -143,12 +143,7 @@ static void davinci_musb_disable(struct musb *musb)
 }
 
 
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
 #define portstate(stmt)         stmt
-#else
-#define portstate(stmt)
-#endif
-
 
 /*
  * VBUS SWITCHING IS BOARD-SPECIFIC ... at least for the DM6446 EVM,
diff --git a/drivers/usb/musb/musb_core.c b/drivers/usb/musb/musb_core.c
index c71b0372786..96c5dbd1e0e 100644
--- a/drivers/usb/musb/musb_core.c
+++ b/drivers/usb/musb/musb_core.c
@@ -328,8 +328,6 @@ void musb_load_testpacket(struct musb *musb)
 
 /*-------------------------------------------------------------------------*/
 
-#ifdef  CONFIG_USB_MUSB_OTG
-
 /*
  * Handles OTG hnp timeouts, such as b_ase0_brst
  */
@@ -401,8 +399,6 @@ void musb_hnp_stop(struct musb *musb)
         musb->port1_status &= ~(USB_PORT_STAT_C_CONNECTION << 16);
 }
 
-#endif
-
 /*
  * Interrupt Service Routine to record USB "global" interrupts.
  * Since these do not happen often and signify things of
@@ -432,7 +428,6 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                 dev_dbg(musb->controller, "RESUME (%s)\n", otg_state_string(musb->xceiv->state));
 
                 if (devctl & MUSB_DEVCTL_HM) {
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
                         void __iomem *mbase = musb->mregs;
 
                         switch (musb->xceiv->state) {
@@ -472,17 +467,13 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                                         "host",
                                         otg_state_string(musb->xceiv->state));
                         }
-#endif
                 } else {
                         switch (musb->xceiv->state) {
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
                         case OTG_STATE_A_SUSPEND:
                                 /* possibly DISCONNECT is upcoming */
                                 musb->xceiv->state = OTG_STATE_A_HOST;
                                 usb_hcd_resume_root_hub(musb_to_hcd(musb));
                                 break;
-#endif
-#ifdef CONFIG_USB_GADGET_MUSB_HDRC
                         case OTG_STATE_B_WAIT_ACON:
                         case OTG_STATE_B_PERIPHERAL:
                                 /* disconnect while suspended?  we may
@@ -500,7 +491,6 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                         case OTG_STATE_B_IDLE:
                                 musb->int_usb &= ~MUSB_INTR_SUSPEND;
                                 break;
-#endif
                         default:
                                 WARNING("bogus %s RESUME (%s)\n",
                                         "peripheral",
@@ -509,7 +499,6 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                 }
         }
 
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
         /* see manual for the order of the tests */
         if (int_usb & MUSB_INTR_SESSREQ) {
                 void __iomem *mbase = musb->mregs;
@@ -609,14 +598,12 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                 handled = IRQ_HANDLED;
         }
 
-#endif
         if (int_usb & MUSB_INTR_SUSPEND) {
                 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) {
-#ifdef  CONFIG_USB_MUSB_OTG
                 case OTG_STATE_A_PERIPHERAL:
                         /* We also come here if the cable is removed, since
                          * this silicon doesn't report ID-no-longer-grounded.
@@ -633,7 +620,6 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                                                 ? : OTG_TIME_A_WAIT_BCON));
 
                         break;
-#endif
                 case OTG_STATE_B_IDLE:
                         if (!musb->is_active)
                                 break;
@@ -642,13 +628,11 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                         musb->is_active = is_otg_enabled(musb)
                                         && musb->xceiv->gadget->b_hnp_enable;
                         if (musb->is_active) {
-#ifdef  CONFIG_USB_MUSB_OTG
                                 musb->xceiv->state = OTG_STATE_B_WAIT_ACON;
                                 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));
-#endif
                         }
                         break;
                 case OTG_STATE_A_WAIT_BCON:
@@ -672,7 +656,6 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                 }
         }
 
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
         if (int_usb & MUSB_INTR_CONNECT) {
                 struct usb_hcd *hcd = musb_to_hcd(musb);
 
@@ -682,7 +665,6 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
 
                 musb->ep0_stage = MUSB_EP0_START;
 
-#ifdef CONFIG_USB_MUSB_OTG
                 /* flush endpoints when transitioning from Device Mode */
                 if (is_peripheral_active(musb)) {
                         /* REVISIT HNP; just force disconnect */
@@ -690,7 +672,6 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                 musb_writew(musb->mregs, MUSB_INTRTXE, musb->epmask);
                 musb_writew(musb->mregs, MUSB_INTRRXE, musb->epmask & 0xfffe);
                 musb_writeb(musb->mregs, MUSB_INTRUSBE, 0xf7);
-#endif
                 musb->port1_status &= ~(USB_PORT_STAT_LOW_SPEED
                                         |USB_PORT_STAT_HIGH_SPEED
                                         |USB_PORT_STAT_ENABLE
@@ -739,7 +720,6 @@ b_host:
                 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) {
                 dev_dbg(musb->controller, "DISCONNECT (%s) as %s, devctl %02x\n",
@@ -748,7 +728,6 @@ b_host:
                 handled = IRQ_HANDLED;
 
                 switch (musb->xceiv->state) {
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
                 case OTG_STATE_A_HOST:
                 case OTG_STATE_A_SUSPEND:
                         usb_hcd_resume_root_hub(musb_to_hcd(musb));
@@ -757,8 +736,6 @@ b_host:
                                 musb_platform_try_idle(musb, jiffies
                                         + msecs_to_jiffies(musb->a_wait_bcon));
                         break;
-#endif  /* HOST */
-#ifdef CONFIG_USB_MUSB_OTG
                 case OTG_STATE_B_HOST:
                         /* REVISIT this behaves for "real disconnect"
                          * cases; make sure the other transitions from
@@ -777,13 +754,10 @@ b_host:
                         /* FALLTHROUGH */
                 case OTG_STATE_B_WAIT_ACON:
                         /* FALLTHROUGH */
-#endif  /* OTG */
-#ifdef CONFIG_USB_GADGET_MUSB_HDRC
                 case OTG_STATE_B_PERIPHERAL:
                 case OTG_STATE_B_IDLE:
                         musb_g_disconnect(musb);
                         break;
-#endif  /* GADGET */
                 default:
                         WARNING("unhandled DISCONNECT transition (%s)\n",
                                 otg_state_string(musb->xceiv->state));
@@ -814,7 +788,6 @@ b_host:
                         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:
                                 /* We need to ignore disconnect on suspend
                                  * otherwise tusb 2.0 won't reconnect after a
@@ -842,7 +815,6 @@ b_host:
                                 musb->xceiv->state = OTG_STATE_B_PERIPHERAL;
                                 musb_g_reset(musb);
                                 break;
-#endif
                         case OTG_STATE_B_IDLE:
                                 musb->xceiv->state = OTG_STATE_B_PERIPHERAL;
                                 /* FALLTHROUGH */
@@ -927,7 +899,6 @@ void musb_start(struct musb *musb)
 
         /* put into basic highspeed mode and start session */
         musb_writeb(regs, MUSB_POWER, MUSB_POWER_ISOUPDATE
-                                                | MUSB_POWER_SOFTCONN
                                                 | MUSB_POWER_HSENAB
                                                 /* ENSUSPEND wedges tusb */
                                                 /* | MUSB_POWER_ENSUSPEND */
@@ -1038,10 +1009,15 @@ 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_MUSB_TUSB6010) || defined(CONFIG_USB_MUSB_OMAP2PLUS) \
-        || defined(CONFIG_USB_MUSB_AM35X)
+#if defined(CONFIG_USB_MUSB_TUSB6010)                   \
+        || defined(CONFIG_USB_MUSB_TUSB6010_MODULE)     \
+        || defined(CONFIG_USB_MUSB_OMAP2PLUS)           \
+        || defined(CONFIG_USB_MUSB_OMAP2PLUS_MODULE)    \
+        || defined(CONFIG_USB_MUSB_AM35X)               \
+        || defined(CONFIG_USB_MUSB_AM35X_MODULE)
 static ushort __initdata fifo_mode = 4;
-#elif defined(CONFIG_USB_MUSB_UX500)
+#elif defined(CONFIG_USB_MUSB_UX500)                    \
+        || defined(CONFIG_USB_MUSB_UX500_MODULE)
 static ushort __initdata fifo_mode = 5;
 #else
 static ushort __initdata fifo_mode = 2;
@@ -1191,14 +1167,12 @@ fifo_setup(struct musb *musb, struct musb_hw_ep  *hw_ep,
         /* configure the FIFO */
         musb_writeb(mbase, MUSB_INDEX, hw_ep->epnum);
 
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
         /* EP0 reserved endpoint for control, bidirectional;
          * EP1 reserved for bulk, two unidirection halves.
          */
         if (hw_ep->epnum == 1)
                 musb->bulk_ep = hw_ep;
         /* REVISIT error check:  be sure ep0 can both rx and tx ... */
-#endif
         switch (cfg->style) {
         case FIFO_TX:
                 musb_write_txfifosz(mbase, c_size);
@@ -1317,12 +1291,10 @@ done:
                         n + 1, musb->config->num_eps * 2 - 1,
                         offset, (1 << (musb->config->ram_bits + 2)));
 
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
         if (!musb->bulk_ep) {
                 pr_debug("%s: missing bulk\n", musb_driver_name);
                 return -EINVAL;
         }
-#endif
 
         return 0;
 }
@@ -1353,7 +1325,6 @@ static int __init ep_config_from_hw(struct musb *musb)
 
                 /* FIXME set up hw_ep->{rx,tx}_double_buffered */
 
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
                 /* pick an RX/TX endpoint for bulk */
                 if (hw_ep->max_packet_sz_tx < 512
                                 || hw_ep->max_packet_sz_rx < 512)
@@ -1365,15 +1336,12 @@ static int __init ep_config_from_hw(struct musb *musb)
                 if (musb->bulk_ep)
                         continue;
                 musb->bulk_ep = hw_ep;
-#endif
         }
 
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
         if (!musb->bulk_ep) {
                 pr_debug("%s: missing bulk\n", musb_driver_name);
                 return -EINVAL;
         }
-#endif
 
         return 0;
 }
@@ -1429,13 +1397,11 @@ static int __init musb_core_init(u16 musb_type, struct musb *musb)
         } else {
                 musb->is_multipoint = 0;
                 type = "";
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
 #ifndef CONFIG_USB_OTG_BLACKLIST_HUB
                 printk(KERN_ERR
                         "%s: kernel must blacklist external hubs\n",
                         musb_driver_name);
 #endif
-#endif
         }
 
         /* log release info */
@@ -1479,11 +1445,9 @@ static int __init musb_core_init(u16 musb_type, struct musb *musb)
 #endif
 
                 hw_ep->regs = MUSB_EP_OFFSET(i, 0) + mbase;
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
                 hw_ep->target_regs = musb_read_target_reg_base(i, mbase);
                 hw_ep->rx_reinit = 1;
                 hw_ep->tx_reinit = 1;
-#endif
 
                 if (hw_ep->max_packet_sz_tx) {
                         dev_dbg(musb->controller,
@@ -1561,14 +1525,6 @@ irqreturn_t musb_interrupt(struct musb *musb)
                 (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) {
-                        dev_dbg(musb->controller, "No gadget driver loaded\n");
-                        return IRQ_HANDLED;
-                }
-#endif
-
         /* the core can interrupt us for multiple reasons; docs have
          * a generic interrupt flowchart to follow
          */
@@ -1767,8 +1723,6 @@ musb_vbus_show(struct device *dev, struct device_attribute *attr, char *buf)
 }
 static DEVICE_ATTR(vbus, 0644, musb_vbus_show, musb_vbus_store);
 
-#ifdef CONFIG_USB_GADGET_MUSB_HDRC
-
 /* Gadget drivers can't know that a host is connected so they might want
  * to start SRP, but users can.  This allows userspace to trigger SRP.
  */
@@ -1792,14 +1746,10 @@ musb_srp_store(struct device *dev, struct device_attribute *attr,
 }
 static DEVICE_ATTR(srp, 0644, NULL, musb_srp_store);
 
-#endif /* CONFIG_USB_GADGET_MUSB_HDRC */
-
 static struct attribute *musb_attributes[] = {
         &dev_attr_mode.attr,
         &dev_attr_vbus.attr,
-#ifdef CONFIG_USB_GADGET_MUSB_HDRC
         &dev_attr_srp.attr,
-#endif
         NULL
 };
 
@@ -1832,7 +1782,6 @@ allocate_instance(struct device *dev,
         struct musb             *musb;
         struct musb_hw_ep       *ep;
         int                     epnum;
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
         struct usb_hcd  *hcd;
 
         hcd = usb_create_hcd(&musb_hc_driver, dev, dev_name(dev));
@@ -1850,12 +1799,6 @@ allocate_instance(struct device *dev,
 
         musb->vbuserr_retry = VBUSERR_RETRY_COUNT;
         musb->a_wait_bcon = OTG_TIME_A_WAIT_BCON;
-#else
-        musb = kzalloc(sizeof *musb, GFP_KERNEL);
-        if (!musb)
-                return NULL;
-
-#endif
         dev_set_drvdata(dev, musb);
         musb->mregs = mbase;
         musb->ctrl_base = mbase;
@@ -1885,9 +1828,7 @@ static void musb_free(struct musb *musb)
         sysfs_remove_group(&musb->controller->kobj, &musb_attr_group);
 #endif
 
-#ifdef CONFIG_USB_GADGET_MUSB_HDRC
         musb_gadget_cleanup(musb);
-#endif
 
         if (musb->nIrq >= 0) {
                 if (musb->irq_wake)
@@ -1901,11 +1842,7 @@ static void musb_free(struct musb *musb)
                 dma_controller_destroy(c);
         }
 
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
-        usb_put_hcd(musb_to_hcd(musb));
-#else
         kfree(musb);
-#endif
 }
 
 /*
@@ -1955,7 +1892,7 @@ musb_init_controller(struct device *dev, int nIrq, void __iomem *ctrl)
          *   - initializes musb->xceiv, usually by otg_get_transceiver()
          *   - stops powering VBUS
          *
-         * There are various transciever configurations.  Blackfin,
+         * There are various transceiver configurations.  Blackfin,
          * DaVinci, TUSB60x0, and others integrate them.  OMAP3 uses
          * external/discrete ones in various flavors (twl4030 family,
          * isp1504, non-OTG, etc) mostly hooking up through ULPI.
@@ -2000,9 +1937,7 @@ musb_init_controller(struct device *dev, int nIrq, void __iomem *ctrl)
         if (status < 0)
                 goto fail3;
 
-#ifdef CONFIG_USB_MUSB_OTG
         setup_timer(&musb->otg_timer, musb_otg_timer_func, (unsigned long) musb);
-#endif
 
         /* Init IRQ workqueue before request_irq */
         INIT_WORK(&musb->irq_work, musb_irq_work);
@@ -2078,8 +2013,6 @@ musb_init_controller(struct device *dev, int nIrq, void __iomem *ctrl)
         if (status < 0)
                 goto fail3;
 
-        pm_runtime_put(musb->controller);
-
         status = musb_init_debugfs(musb);
         if (status < 0)
                 goto fail4;
@@ -2214,7 +2147,16 @@ static void musb_save_context(struct musb *musb)
         musb->context.devctl = musb_readb(musb_base, MUSB_DEVCTL);
 
         for (i = 0; i < musb->config->num_eps; ++i) {
-                epio = musb->endpoints[i].regs;
+                struct musb_hw_ep       *hw_ep;
+
+                hw_ep = &musb->endpoints[i];
+                if (!hw_ep)
+                        continue;
+
+                epio = hw_ep->regs;
+                if (!epio)
+                        continue;
+
                 musb->context.index_regs[i].txmaxp =
                         musb_readw(epio, MUSB_TXMAXP);
                 musb->context.index_regs[i].txcsr =
@@ -2280,7 +2222,16 @@ static void musb_restore_context(struct musb *musb)
         musb_writeb(musb_base, MUSB_DEVCTL, musb->context.devctl);
 
         for (i = 0; i < musb->config->num_eps; ++i) {
-                epio = musb->endpoints[i].regs;
+                struct musb_hw_ep       *hw_ep;
+
+                hw_ep = &musb->endpoints[i];
+                if (!hw_ep)
+                        continue;
+
+                epio = hw_ep->regs;
+                if (!epio)
+                        continue;
+
                 musb_writew(epio, MUSB_TXMAXP,
                         musb->context.index_regs[i].txmaxp);
                 musb_writew(epio, MUSB_TXCSR,
@@ -2329,13 +2280,13 @@ static void musb_restore_context(struct musb *musb)
                                 musb->context.index_regs[i].rxhubport);
                 }
         }
+        musb_writeb(musb_base, MUSB_INDEX, musb->context.index);
 }
 
 static int musb_suspend(struct device *dev)
 {
-        struct platform_device *pdev = to_platform_device(dev);
+        struct musb     *musb = dev_to_musb(dev);
         unsigned long   flags;
-        struct musb     *musb = dev_to_musb(&pdev->dev);
 
         spin_lock_irqsave(&musb->lock, flags);
 
@@ -2349,19 +2300,12 @@ static int musb_suspend(struct device *dev)
                  */
         }
 
-        musb_save_context(musb);
-
         spin_unlock_irqrestore(&musb->lock, flags);
         return 0;
 }
 
 static int musb_resume_noirq(struct device *dev)
 {
-        struct platform_device *pdev = to_platform_device(dev);
-        struct musb     *musb = dev_to_musb(&pdev->dev);
-
-        musb_restore_context(musb);
-
         /* for static cmos like DaVinci, register values were preserved
          * unless for some reason the whole soc powered down or the USB
          * module got reset through the PSC (vs just being disabled).
@@ -2426,34 +2370,13 @@ static struct platform_driver musb_driver = {
 
 static int __init musb_init(void)
 {
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
         if (usb_disabled())
                 return 0;
-#endif
 
         pr_info("%s: version " MUSB_VERSION ", "
-#ifdef CONFIG_MUSB_PIO_ONLY
-                "pio"
-#elif defined(CONFIG_USB_TI_CPPI_DMA)
-                "cppi-dma"
-#elif defined(CONFIG_USB_INVENTRA_DMA)
-                "musb-dma"
-#elif defined(CONFIG_USB_TUSB_OMAP_DMA)
-                "tusb-omap-dma"
-#elif defined(CONFIG_USB_UX500_DMA)
-                "ux500-dma"
-#else
                 "?dma?"
-#endif
                 ", "
-#ifdef CONFIG_USB_MUSB_OTG
-                "otg (peripheral+host)"
-#elif defined(CONFIG_USB_GADGET_MUSB_HDRC)
-                "peripheral"
-#elif defined(CONFIG_USB_MUSB_HDRC_HCD)
-                "host"
-#endif
-                ,
+                "otg (peripheral+host)",
                 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 0e053b58796..b3c065ab9db 100644
--- a/drivers/usb/musb/musb_core.h
+++ b/drivers/usb/musb/musb_core.h
@@ -72,10 +72,6 @@ struct musb_ep;
 #include <linux/usb/hcd.h>
 #include "musb_host.h"
 
-
-
-#ifdef CONFIG_USB_MUSB_OTG
-
 #define is_peripheral_enabled(musb)     ((musb)->board_mode != MUSB_HOST)
 #define is_host_enabled(musb)           ((musb)->board_mode != MUSB_PERIPHERAL)
 #define is_otg_enabled(musb)            ((musb)->board_mode == MUSB_OTG)
@@ -86,24 +82,6 @@ struct musb_ep;
 #define is_peripheral_active(m)         (!(m)->is_host)
 #define is_host_active(m)               ((m)->is_host)
 
-#else
-#define is_peripheral_enabled(musb)     is_peripheral_capable()
-#define is_host_enabled(musb)           is_host_capable()
-#define is_otg_enabled(musb)            0
-
-#define is_peripheral_active(musb)      is_peripheral_capable()
-#define is_host_active(musb)            is_host_capable()
-#endif
-
-#if defined(CONFIG_USB_MUSB_OTG) || defined(CONFIG_USB_MUSB_PERIPHERAL)
-/* for some reason, the "select USB_GADGET_MUSB_HDRC" doesn't always
- * override that choice selection (often USB_GADGET_DUMMY_HCD).
- */
-#ifndef CONFIG_USB_GADGET_MUSB_HDRC
-#error bogus Kconfig output ... select CONFIG_USB_GADGET_MUSB_HDRC
-#endif
-#endif  /* need MUSB gadget selection */
-
 #ifndef CONFIG_HAVE_CLK
 /* Dummy stub for clk framework */
 #define clk_get(dev, id)        NULL
@@ -119,8 +97,6 @@ struct musb_ep;
 
 /****************************** PERIPHERAL ROLE *****************************/
 
-#ifdef CONFIG_USB_GADGET_MUSB_HDRC
-
 #define is_peripheral_capable() (1)
 
 extern irqreturn_t musb_g_ep0_irq(struct musb *);
@@ -132,40 +108,14 @@ extern void musb_g_resume(struct musb *);
 extern void musb_g_wakeup(struct musb *);
 extern void musb_g_disconnect(struct musb *);
 
-#else
-
-#define is_peripheral_capable() (0)
-
-static inline irqreturn_t musb_g_ep0_irq(struct musb *m) { return IRQ_NONE; }
-static inline void musb_g_reset(struct musb *m) {}
-static inline void musb_g_suspend(struct musb *m) {}
-static inline void musb_g_resume(struct musb *m) {}
-static inline void musb_g_wakeup(struct musb *m) {}
-static inline void musb_g_disconnect(struct musb *m) {}
-
-#endif
-
 /****************************** HOST ROLE ***********************************/
 
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
-
 #define is_host_capable()       (1)
 
 extern irqreturn_t musb_h_ep0_irq(struct musb *);
 extern void musb_host_tx(struct musb *, u8);
 extern void musb_host_rx(struct musb *, u8);
 
-#else
-
-#define is_host_capable()       (0)
-
-static inline irqreturn_t musb_h_ep0_irq(struct musb *m) { return IRQ_NONE; }
-static inline void musb_host_tx(struct musb *m, u8 e) {}
-static inline void musb_host_rx(struct musb *m, u8 e) {}
-
-#endif
-
-
 /****************************** CONSTANTS ********************************/
 
 #ifndef MUSB_C_NUM_EPS
@@ -222,7 +172,8 @@ enum musb_g_ep0_state {
 #endif
 
 /* TUSB mapping: "flat" plus ep0 special cases */
-#if     defined(CONFIG_USB_MUSB_TUSB6010)
+#if defined(CONFIG_USB_MUSB_TUSB6010) || \
+        defined(CONFIG_USB_MUSB_TUSB6010_MODULE)
 #define musb_ep_select(_mbase, _epnum) \
         musb_writeb((_mbase), MUSB_INDEX, (_epnum))
 #define MUSB_EP_OFFSET                  MUSB_TUSB_OFFSET
@@ -261,7 +212,7 @@ enum musb_g_ep0_state {
  * @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
+ * @adjust_channel_params: pre check for standard dma channel_program func
  */
 struct musb_platform_ops {
         int     (*init)(struct musb *musb);
@@ -291,7 +242,8 @@ struct musb_hw_ep {
         void __iomem            *fifo;
         void __iomem            *regs;
 
-#ifdef CONFIG_USB_MUSB_TUSB6010
+#if defined(CONFIG_USB_MUSB_TUSB6010) || \
+        defined(CONFIG_USB_MUSB_TUSB6010_MODULE)
         void __iomem            *conf;
 #endif
 
@@ -308,14 +260,14 @@ struct musb_hw_ep {
         struct dma_channel      *tx_channel;
         struct dma_channel      *rx_channel;
 
-#ifdef CONFIG_USB_MUSB_TUSB6010
+#if defined(CONFIG_USB_MUSB_TUSB6010) || \
+        defined(CONFIG_USB_MUSB_TUSB6010_MODULE)
         /* TUSB has "asynchronous" and "synchronous" dma modes */
         dma_addr_t              fifo_async;
         dma_addr_t              fifo_sync;
         void __iomem            *fifo_sync_va;
 #endif
 
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
         void __iomem            *target_regs;
 
         /* currently scheduled peripheral endpoint */
@@ -324,31 +276,20 @@ struct musb_hw_ep {
 
         u8                      rx_reinit;
         u8                      tx_reinit;
-#endif
 
-#ifdef CONFIG_USB_GADGET_MUSB_HDRC
         /* peripheral side */
         struct musb_ep          ep_in;                  /* TX */
         struct musb_ep          ep_out;                 /* RX */
-#endif
 };
 
 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);
-#else
-        return NULL;
-#endif
 }
 
 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);
-#else
-        return NULL;
-#endif
 }
 
 struct musb_csr_regs {
@@ -393,7 +334,6 @@ struct musb {
 
         u32                     port1_status;
 
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
         unsigned long           rh_timer;
 
         enum musb_h_ep0_state   ep0_stage;
@@ -411,7 +351,6 @@ struct musb {
         struct list_head        out_bulk;       /* of musb_qh */
 
         struct timer_list       otg_timer;
-#endif
         struct notifier_block   nb;
 
         struct dma_controller   *dma_controller;
@@ -420,7 +359,8 @@ struct musb {
         void __iomem            *ctrl_base;
         void __iomem            *mregs;
 
-#ifdef CONFIG_USB_MUSB_TUSB6010
+#if defined(CONFIG_USB_MUSB_TUSB6010) || \
+        defined(CONFIG_USB_MUSB_TUSB6010_MODULE)
         dma_addr_t              async;
         dma_addr_t              sync;
         void __iomem            *sync_va;
@@ -472,7 +412,6 @@ struct musb {
 #define can_bulk_combine(musb,type) \
         (((type) == USB_ENDPOINT_XFER_BULK) && (musb)->bulk_combine)
 
-#ifdef CONFIG_USB_GADGET_MUSB_HDRC
         /* is_suspended means USB B_PERIPHERAL suspend */
         unsigned                is_suspended:1;
 
@@ -496,7 +435,6 @@ struct musb {
         enum musb_g_ep0_state   ep0_state;
         struct usb_gadget       g;                      /* the gadget */
         struct usb_gadget_driver *gadget_driver;        /* its driver */
-#endif
 
         /*
          * FIXME: Remove this flag.
@@ -518,12 +456,10 @@ struct musb {
 #endif
 };
 
-#ifdef CONFIG_USB_GADGET_MUSB_HDRC
 static inline struct musb *gadget_to_musb(struct usb_gadget *g)
 {
         return container_of(g, struct musb, g);
 }
-#endif
 
 #ifdef CONFIG_BLACKFIN
 static inline int musb_read_fifosize(struct musb *musb,
diff --git a/drivers/usb/musb/musb_gadget.c b/drivers/usb/musb/musb_gadget.c
index 6aeb363e63e..e81820370d6 100644
--- a/drivers/usb/musb/musb_gadget.c
+++ b/drivers/usb/musb/musb_gadget.c
@@ -1663,8 +1663,8 @@ static void musb_pullup(struct musb *musb, int is_on)
 
         /* FIXME if on, HdrcStart; if off, HdrcStop */
 
-        dev_dbg(musb->controller, "gadget %s D+ pullup %s\n",
-                musb->gadget_driver->function, is_on ? "on" : "off");
+        dev_dbg(musb->controller, "gadget D+ pullup %s\n",
+                is_on ? "on" : "off");
         musb_writeb(musb->mregs, MUSB_POWER, power);
 }
 
@@ -1698,6 +1698,8 @@ static int musb_gadget_pullup(struct usb_gadget *gadget, int is_on)
 
         is_on = !!is_on;
 
+        pm_runtime_get_sync(musb->controller);
+
         /* NOTE: this assumes we are sensing vbus; we'd rather
          * not pullup unless the B-session is active.
          */
@@ -1707,9 +1709,17 @@ static int musb_gadget_pullup(struct usb_gadget *gadget, int is_on)
                 musb_pullup(musb, is_on);
         }
         spin_unlock_irqrestore(&musb->lock, flags);
+
+        pm_runtime_put(musb->controller);
+
         return 0;
 }
 
+static int musb_gadget_start(struct usb_gadget *g,
+                struct usb_gadget_driver *driver);
+static int musb_gadget_stop(struct usb_gadget *g,
+                struct usb_gadget_driver *driver);
+
 static const struct usb_gadget_ops musb_gadget_operations = {
         .get_frame              = musb_gadget_get_frame,
         .wakeup                 = musb_gadget_wakeup,
@@ -1717,6 +1727,8 @@ static const struct usb_gadget_ops musb_gadget_operations = {
         /* .vbus_session                = musb_gadget_vbus_session, */
         .vbus_draw              = musb_gadget_vbus_draw,
         .pullup                 = musb_gadget_pullup,
+        .udc_start              = musb_gadget_start,
+        .udc_stop               = musb_gadget_stop,
 };
 
 /* ----------------------------------------------------------------------- */
@@ -1727,7 +1739,6 @@ static const struct usb_gadget_ops musb_gadget_operations = {
  * about there being only one external upstream port.  It assumes
  * all peripheral ports are external...
  */
-static struct musb *the_gadget;
 
 static void musb_gadget_release(struct device *dev)
 {
@@ -1814,9 +1825,6 @@ int __init musb_gadget_setup(struct musb *musb)
          * musb peripherals at the same time, only the bus lock
          * is probably held.
          */
-        if (the_gadget)
-                return -EBUSY;
-        the_gadget = musb;
 
         musb->g.ops = &musb_gadget_operations;
         musb->g.is_dualspeed = 1;
@@ -1840,18 +1848,24 @@ int __init musb_gadget_setup(struct musb *musb)
         status = device_register(&musb->g.dev);
         if (status != 0) {
                 put_device(&musb->g.dev);
-                the_gadget = NULL;
+                return status;
         }
+        status = usb_add_gadget_udc(musb->controller, &musb->g);
+        if (status)
+                goto err;
+
+        return 0;
+err:
+        musb->g.dev.parent = NULL;
+        device_unregister(&musb->g.dev);
         return status;
 }
 
 void musb_gadget_cleanup(struct musb *musb)
 {
-        if (musb != the_gadget)
-                return;
-
-        device_unregister(&musb->g.dev);
-        the_gadget = NULL;
+        usb_del_gadget_udc(&musb->g);
+        if (musb->g.dev.parent)
+                device_unregister(&musb->g.dev);
 }
 
 /*
@@ -1863,59 +1877,30 @@ void musb_gadget_cleanup(struct musb *musb)
  * -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_probe_driver(struct usb_gadget_driver *driver,
-                int (*bind)(struct usb_gadget *))
+static int musb_gadget_start(struct usb_gadget *g,
+                struct usb_gadget_driver *driver)
 {
-        struct musb             *musb = the_gadget;
+        struct musb             *musb = gadget_to_musb(g);
         unsigned long           flags;
         int                     retval = -EINVAL;
 
-        if (!driver
-                        || driver->speed != USB_SPEED_HIGH
-                        || !bind || !driver->setup)
+        if (driver->speed != USB_SPEED_HIGH)
                 goto err0;
 
-        /* driver must be initialized to support peripheral mode */
-        if (!musb) {
-                dev_dbg(musb->controller, "no dev??\n");
-                retval = -ENODEV;
-                goto err0;
-        }
-
         pm_runtime_get_sync(musb->controller);
 
         dev_dbg(musb->controller, "registering driver %s\n", driver->function);
 
-        if (musb->gadget_driver) {
-                dev_dbg(musb->controller, "%s is already bound to %s\n",
-                                musb_driver_name,
-                                musb->gadget_driver->driver.name);
-                retval = -EBUSY;
-                goto err0;
-        }
-
-        spin_lock_irqsave(&musb->lock, flags);
+        musb->softconnect = 0;
         musb->gadget_driver = driver;
-        musb->g.dev.driver = &driver->driver;
-        driver->driver.bus = NULL;
-        musb->softconnect = 1;
-        spin_unlock_irqrestore(&musb->lock, flags);
-
-        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);
+        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
@@ -1927,8 +1912,6 @@ int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
         if (!is_otg_enabled(musb))
                 musb_start(musb);
 
-        otg_set_peripheral(musb->xceiv, &musb->g);
-
         spin_unlock_irqrestore(&musb->lock, flags);
 
         if (is_otg_enabled(musb)) {
@@ -1960,15 +1943,9 @@ int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
 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_probe_driver);
 
 static void stop_activity(struct musb *musb, struct usb_gadget_driver *driver)
 {
@@ -2018,17 +1995,12 @@ static void stop_activity(struct musb *musb, struct usb_gadget_driver *driver)
  *
  * @param driver the gadget driver to unregister
  */
-int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
+static int musb_gadget_stop(struct usb_gadget *g,
+                struct usb_gadget_driver *driver)
 {
-        struct musb     *musb = the_gadget;
+        struct musb     *musb = gadget_to_musb(g);
         unsigned long   flags;
 
-        if (!driver || !driver->unbind || !musb)
-                return -EINVAL;
-
-        if (!musb->gadget_driver)
-                return -EINVAL;
-
         if (musb->xceiv->last_event == USB_EVENT_NONE)
                 pm_runtime_get_sync(musb->controller);
 
@@ -2039,9 +2011,7 @@ int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
 
         spin_lock_irqsave(&musb->lock, flags);
 
-#ifdef  CONFIG_USB_MUSB_OTG
         musb_hnp_stop(musb);
-#endif
 
         (void) musb_gadget_vbus_draw(&musb->g, 0);
 
@@ -2051,13 +2021,6 @@ int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
 
         dev_dbg(musb->controller, "unregistering driver %s\n", driver->function);
 
-        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->is_active = 0;
         musb_platform_try_idle(musb, 0);
         spin_unlock_irqrestore(&musb->lock, flags);
@@ -2077,8 +2040,6 @@ int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
 
         return 0;
 }
-EXPORT_SYMBOL(usb_gadget_unregister_driver);
-
 
 /* ----------------------------------------------------------------------- */
 
@@ -2164,7 +2125,6 @@ void musb_g_disconnect(struct musb *musb)
 
         switch (musb->xceiv->state) {
         default:
-#ifdef  CONFIG_USB_MUSB_OTG
                 dev_dbg(musb->controller, "Unhandled disconnect %s, setting a_idle\n",
                         otg_state_string(musb->xceiv->state));
                 musb->xceiv->state = OTG_STATE_A_IDLE;
@@ -2176,7 +2136,6 @@ void musb_g_disconnect(struct musb *musb)
                 break;
         case OTG_STATE_B_WAIT_ACON:
         case OTG_STATE_B_HOST:
-#endif
         case OTG_STATE_B_PERIPHERAL:
         case OTG_STATE_B_IDLE:
                 musb->xceiv->state = OTG_STATE_B_IDLE;
diff --git a/drivers/usb/musb/musb_gadget_ep0.c b/drivers/usb/musb/musb_gadget_ep0.c
index b2faff23550..9378b359c1f 100644
--- a/drivers/usb/musb/musb_gadget_ep0.c
+++ b/drivers/usb/musb/musb_gadget_ep0.c
@@ -88,7 +88,6 @@ static int service_tx_status_request(
         case USB_RECIP_DEVICE:
                 result[0] = musb->is_self_powered << USB_DEVICE_SELF_POWERED;
                 result[0] |= musb->may_wakeup << USB_DEVICE_REMOTE_WAKEUP;
-#ifdef CONFIG_USB_MUSB_OTG
                 if (musb->g.is_otg) {
                         result[0] |= musb->g.b_hnp_enable
                                 << USB_DEVICE_B_HNP_ENABLE;
@@ -97,7 +96,6 @@ static int service_tx_status_request(
                         result[0] |= musb->g.a_hnp_support
                                 << USB_DEVICE_A_HNP_SUPPORT;
                 }
-#endif
                 break;
 
         case USB_RECIP_INTERFACE:
@@ -392,7 +390,6 @@ __acquires(musb->lock)
                                         if (handled > 0)
                                                 musb->test_mode = true;
                                         break;
-#ifdef CONFIG_USB_MUSB_OTG
                                 case USB_DEVICE_B_HNP_ENABLE:
                                         if (!musb->g.is_otg)
                                                 goto stall;
@@ -409,7 +406,6 @@ __acquires(musb->lock)
                                                 goto stall;
                                         musb->g.a_alt_hnp_support = 1;
                                         break;
-#endif
                                 case USB_DEVICE_DEBUG_MODE:
                                         handled = 0;
                                         break;
diff --git a/drivers/usb/musb/musb_host.h b/drivers/usb/musb/musb_host.h
index 14b00776638..622d09fb9ab 100644
--- a/drivers/usb/musb/musb_host.h
+++ b/drivers/usb/musb/musb_host.h
@@ -95,7 +95,6 @@ extern const struct hc_driver musb_hc_driver;
 
 static inline struct urb *next_urb(struct musb_qh *qh)
 {
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
         struct list_head        *queue;
 
         if (!qh)
@@ -104,9 +103,6 @@ static inline struct urb *next_urb(struct musb_qh *qh)
         if (list_empty(queue))
                 return NULL;
         return list_entry(queue->next, struct urb, urb_list);
-#else
-        return NULL;
-#endif
 }
 
 #endif                          /* _MUSB_HOST_H */
diff --git a/drivers/usb/musb/musb_regs.h b/drivers/usb/musb/musb_regs.h
index 82410703dcd..03f2655af29 100644
--- a/drivers/usb/musb/musb_regs.h
+++ b/drivers/usb/musb/musb_regs.h
@@ -234,7 +234,8 @@
 #define MUSB_TESTMODE           0x0F    /* 8 bit */
 
 /* Get offset for a given FIFO from musb->mregs */
-#ifdef  CONFIG_USB_MUSB_TUSB6010
+#if defined(CONFIG_USB_MUSB_TUSB6010) ||        \
+        defined(CONFIG_USB_MUSB_TUSB6010_MODULE)
 #define MUSB_FIFO_OFFSET(epnum) (0x200 + ((epnum) * 0x20))
 #else
 #define MUSB_FIFO_OFFSET(epnum) (0x20 + ((epnum) * 4))
@@ -295,7 +296,8 @@
 #define MUSB_FLAT_OFFSET(_epnum, _offset)       \
         (0x100 + (0x10*(_epnum)) + (_offset))
 
-#ifdef CONFIG_USB_MUSB_TUSB6010
+#if defined(CONFIG_USB_MUSB_TUSB6010) ||        \
+        defined(CONFIG_USB_MUSB_TUSB6010_MODULE)
 /* TUSB6010 EP0 configuration register is special */
 #define MUSB_TUSB_OFFSET(_epnum, _offset)       \
         (0x10 + _offset)
diff --git a/drivers/usb/musb/musb_virthub.c b/drivers/usb/musb/musb_virthub.c
index 2d80a575883..e9f80adc45a 100644
--- a/drivers/usb/musb/musb_virthub.c
+++ b/drivers/usb/musb/musb_virthub.c
@@ -88,14 +88,12 @@ static void musb_port_suspend(struct musb *musb, bool do_suspend)
                                                 OTG_TIME_A_AIDL_BDIS));
                         musb_platform_try_idle(musb, 0);
                         break;
-#ifdef  CONFIG_USB_MUSB_OTG
                 case OTG_STATE_B_HOST:
                         musb->xceiv->state = OTG_STATE_B_WAIT_ACON;
                         musb->is_active = is_otg_enabled(musb)
                                         && musb->xceiv->host->b_hnp_enable;
                         musb_platform_try_idle(musb, 0);
                         break;
-#endif
                 default:
                         dev_dbg(musb->controller, "bogus rh suspend? %s\n",
                                 otg_state_string(musb->xceiv->state));
@@ -118,13 +116,11 @@ static void musb_port_reset(struct musb *musb, bool do_reset)
         u8              power;
         void __iomem    *mbase = musb->mregs;
 
-#ifdef CONFIG_USB_MUSB_OTG
         if (musb->xceiv->state == OTG_STATE_B_IDLE) {
                 dev_dbg(musb->controller, "HNP: Returning from HNP; no hub reset from b_idle\n");
                 musb->port1_status &= ~USB_PORT_STAT_RESET;
                 return;
         }
-#endif
 
         if (!is_host_active(musb))
                 return;
@@ -191,14 +187,12 @@ void musb_root_disconnect(struct musb *musb)
 
         switch (musb->xceiv->state) {
         case OTG_STATE_A_SUSPEND:
-#ifdef  CONFIG_USB_MUSB_OTG
                 if (is_otg_enabled(musb)
                                 && musb->xceiv->host->b_hnp_enable) {
                         musb->xceiv->state = OTG_STATE_A_PERIPHERAL;
                         musb->g.is_a_peripheral = 1;
                         break;
                 }
-#endif
                 /* FALLTHROUGH */
         case OTG_STATE_A_HOST:
                 musb->xceiv->state = OTG_STATE_A_WAIT_BCON;
diff --git a/drivers/usb/musb/omap2430.c b/drivers/usb/musb/omap2430.c
index c5d4c44d0ff..ba85f273e48 100644
--- a/drivers/usb/musb/omap2430.c
+++ b/drivers/usb/musb/omap2430.c
@@ -51,9 +51,7 @@ static void musb_do_idle(unsigned long _musb)
 {
         struct musb     *musb = (void *)_musb;
         unsigned long   flags;
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
         u8      power;
-#endif
         u8      devctl;
 
         spin_lock_irqsave(&musb->lock, flags);
@@ -70,7 +68,6 @@ static void musb_do_idle(unsigned long _musb)
                         MUSB_HST_MODE(musb);
                 }
                 break;
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
         case OTG_STATE_A_SUSPEND:
                 /* finish RESUME signaling? */
                 if (musb->port1_status & MUSB_PORT_STAT_RESUME) {
@@ -87,15 +84,12 @@ static void musb_do_idle(unsigned long _musb)
                         musb->xceiv->state = OTG_STATE_A_HOST;
                 }
                 break;
-#endif
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
         case OTG_STATE_A_HOST:
                 devctl = musb_readb(musb->mregs, MUSB_DEVCTL);
                 if (devctl &  MUSB_DEVCTL_BDEVICE)
                         musb->xceiv->state = OTG_STATE_B_IDLE;
                 else
                         musb->xceiv->state = OTG_STATE_A_WAIT_BCON;
-#endif
         default:
                 break;
         }
@@ -243,13 +237,11 @@ static int musb_otg_notifications(struct notifier_block *nb,
                 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);
@@ -260,21 +252,16 @@ static int musb_otg_notifications(struct notifier_block *nb,
         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
-                        {
+                        if (musb->gadget_driver) {
                                 pm_runtime_mark_last_busy(musb->controller);
                                 pm_runtime_put_autosuspend(musb->controller);
                         }
diff --git a/drivers/usb/musb/tusb6010.c b/drivers/usb/musb/tusb6010.c
index b410357cf01..ec1480191f7 100644
--- a/drivers/usb/musb/tusb6010.c
+++ b/drivers/usb/musb/tusb6010.c
@@ -18,6 +18,7 @@
 #include <linux/kernel.h>
 #include <linux/errno.h>
 #include <linux/init.h>
+#include <linux/prefetch.h>
 #include <linux/usb.h>
 #include <linux/irq.h>
 #include <linux/platform_device.h>
@@ -269,8 +270,6 @@ void musb_read_fifo(struct musb_hw_ep *hw_ep, u16 len, u8 *buf)
 
 static struct musb *the_musb;
 
-#ifdef CONFIG_USB_GADGET_MUSB_HDRC
-
 /* This is used by gadget drivers, and OTG transceiver logic, allowing
  * at most mA current to be drawn from VBUS during a Default-B session
  * (that is, while VBUS exceeds 4.4V).  In Default-A (including pure host
@@ -310,10 +309,6 @@ static int tusb_draw_power(struct otg_transceiver *x, unsigned mA)
         return 0;
 }
 
-#else
-#define tusb_draw_power NULL
-#endif
-
 /* workaround for issue 13:  change clock during chip idle
  * (to be fixed in rev3 silicon) ... symptoms include disconnect
  * or looping suspend/resume cycles
@@ -440,19 +435,15 @@ static void musb_do_idle(unsigned long _musb)
                 if (is_host_active(musb) && (musb->port1_status >> 16))
                         goto done;
 
-#ifdef CONFIG_USB_GADGET_MUSB_HDRC
-                if (is_peripheral_enabled(musb) && !musb->gadget_driver)
+                if (is_peripheral_enabled(musb) && !musb->gadget_driver) {
                         wakeups = 0;
-                else {
+                } else {
                         wakeups = TUSB_PRCM_WHOSTDISCON
-                                        | TUSB_PRCM_WBUS
+                                | TUSB_PRCM_WBUS
                                         | TUSB_PRCM_WVBUS;
                         if (is_otg_enabled(musb))
                                 wakeups |= TUSB_PRCM_WID;
                 }
-#else
-                wakeups = TUSB_PRCM_WHOSTDISCON | TUSB_PRCM_WBUS;
-#endif
                 tusb_allow_idle(musb, wakeups);
         }
 done:
@@ -610,30 +601,22 @@ static int tusb_musb_set_mode(struct musb *musb, u8 musb_mode)
 
         switch (musb_mode) {
 
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
         case MUSB_HOST:         /* Disable PHY ID detect, ground ID */
                 phy_otg_ctrl &= ~TUSB_PHY_OTG_CTRL_OTG_ID_PULLUP;
                 phy_otg_ena |= TUSB_PHY_OTG_CTRL_OTG_ID_PULLUP;
                 dev_conf |= TUSB_DEV_CONF_ID_SEL;
                 dev_conf &= ~TUSB_DEV_CONF_SOFT_ID;
                 break;
-#endif
-
-#ifdef CONFIG_USB_GADGET_MUSB_HDRC
         case MUSB_PERIPHERAL:   /* Disable PHY ID detect, keep ID pull-up on */
                 phy_otg_ctrl |= TUSB_PHY_OTG_CTRL_OTG_ID_PULLUP;
                 phy_otg_ena |= TUSB_PHY_OTG_CTRL_OTG_ID_PULLUP;
                 dev_conf |= (TUSB_DEV_CONF_ID_SEL | TUSB_DEV_CONF_SOFT_ID);
                 break;
-#endif
-
-#ifdef CONFIG_USB_MUSB_OTG
         case MUSB_OTG:          /* Use PHY ID detection */
                 phy_otg_ctrl |= TUSB_PHY_OTG_CTRL_OTG_ID_PULLUP;
                 phy_otg_ena |= TUSB_PHY_OTG_CTRL_OTG_ID_PULLUP;
                 dev_conf &= ~(TUSB_DEV_CONF_ID_SEL | TUSB_DEV_CONF_SOFT_ID);
                 break;
-#endif
 
         default:
                 dev_dbg(musb->controller, "Trying to set mode %i\n", musb_mode);
@@ -684,7 +667,6 @@ tusb_otg_ints(struct musb *musb, u32 int_src, void __iomem *tbase)
                 /* B-dev state machine:  no vbus ~= disconnect */
                 if ((is_otg_enabled(musb) && !musb->xceiv->default_a)
                                 || !is_host_enabled(musb)) {
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
                         /* ? musb_root_disconnect(musb); */
                         musb->port1_status &=
                                 ~(USB_PORT_STAT_CONNECTION
@@ -693,7 +675,6 @@ tusb_otg_ints(struct musb *musb, u32 int_src, void __iomem *tbase)
                                 | USB_PORT_STAT_HIGH_SPEED
                                 | USB_PORT_STAT_TEST
                                 );
-#endif
 
                         if (otg_stat & TUSB_DEV_OTG_STAT_SESS_END) {
                                 dev_dbg(musb->controller, "Forcing disconnect (no interrupt)\n");
diff --git a/drivers/usb/musb/tusb6010_omap.c b/drivers/usb/musb/tusb6010_omap.c
index c784e6c03aa..b67b4bc596c 100644
--- a/drivers/usb/musb/tusb6010_omap.c
+++ b/drivers/usb/musb/tusb6010_omap.c
@@ -20,6 +20,7 @@
 #include <plat/mux.h>
 
 #include "musb_core.h"
+#include "tusb6010.h"
 
 #define to_chdat(c)             ((struct tusb_omap_dma_ch *)(c)->private_data)
 
@@ -89,7 +90,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) {
-                dev_dbg(musb->controller, "ep%i dmareq0 is busy for ep%i\n",
+                dev_dbg(chdat->musb->controller, "ep%i dmareq0 is busy for ep%i\n",
                         chdat->epnum, reg & 0xf);
                 return -EAGAIN;
         }
diff --git a/drivers/usb/musb/ux500_dma.c b/drivers/usb/musb/ux500_dma.c
index cecace41183..ef4333f4bbe 100644
--- a/drivers/usb/musb/ux500_dma.c
+++ b/drivers/usb/musb/ux500_dma.c
@@ -65,7 +65,8 @@ static void ux500_tx_work(struct work_struct *data)
         struct musb *musb = hw_ep->musb;
         unsigned long flags;
 
-        DBG(4, "DMA tx transfer done on hw_ep=%d\n", hw_ep->epnum);
+        dev_dbg(musb->controller, "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;
@@ -84,7 +85,8 @@ static void ux500_rx_work(struct work_struct *data)
         struct musb *musb = hw_ep->musb;
         unsigned long flags;
 
-        DBG(4, "DMA rx transfer done on hw_ep=%d\n", hw_ep->epnum);
+        dev_dbg(musb->controller, "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;
@@ -116,9 +118,11 @@ static bool ux500_configure_channel(struct dma_channel *channel,
         enum dma_slave_buswidth addr_width;
         dma_addr_t usb_fifo_addr = (MUSB_FIFO_OFFSET(hw_ep->epnum) +
                                         ux500_channel->controller->phy_base);
+        struct musb *musb = ux500_channel->controller->private_data;
 
-        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);
+        dev_dbg(musb->controller,
+                "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;
 
@@ -133,15 +137,13 @@ static bool ux500_configure_channel(struct dma_channel *channel,
                                         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;
-        }
+        slave_conf.src_addr = usb_fifo_addr;
+        slave_conf.src_addr_width = addr_width;
+        slave_conf.src_maxburst = 16;
+        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);
 
@@ -166,6 +168,7 @@ static struct dma_channel *ux500_dma_channel_allocate(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;
         u8 ch_num = hw_ep->epnum - 1;
         u32 max_ch;
 
@@ -192,7 +195,7 @@ static struct dma_channel *ux500_dma_channel_allocate(struct dma_controller *c,
         ux500_channel->hw_ep = hw_ep;
         ux500_channel->is_allocated = 1;
 
-        DBG(7, "hw_ep=%d, is_tx=0x%x, channel=%d\n",
+        dev_dbg(musb->controller, "hw_ep=%d, is_tx=0x%x, channel=%d\n",
                 hw_ep->epnum, is_tx, ch_num);
 
         return &(ux500_channel->channel);
@@ -201,8 +204,9 @@ static struct dma_channel *ux500_dma_channel_allocate(struct dma_controller *c,
 static void ux500_dma_channel_release(struct dma_channel *channel)
 {
         struct ux500_dma_channel *ux500_channel = channel->private_data;
+        struct musb *musb = ux500_channel->controller->private_data;
 
-        DBG(7, "channel=%d\n", ux500_channel->ch_num);
+        dev_dbg(musb->controller, "channel=%d\n", ux500_channel->ch_num);
 
         if (ux500_channel->is_allocated) {
                 ux500_channel->is_allocated = 0;
@@ -252,8 +256,8 @@ static int ux500_dma_channel_abort(struct dma_channel *channel)
         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);
+        dev_dbg(musb->controller, "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) {