usb: musb: drop useless board_mode usage
authorFelipe Balbi <balbi@ti.com>
Thu, 24 Nov 2011 13:46:26 +0000 (15:46 +0200)
committerFelipe Balbi <balbi@ti.com>
Thu, 9 Aug 2012 09:34:46 +0000 (12:34 +0300)
we are compiling the driver always with full OTG
capabilities, so that board_mode trick becomes
useless.

Signed-off-by: Felipe Balbi <balbi@ti.com>
drivers/usb/musb/am35x.c
drivers/usb/musb/blackfin.c
drivers/usb/musb/da8xx.c
drivers/usb/musb/davinci.c
drivers/usb/musb/musb_core.c
drivers/usb/musb/musb_core.h
drivers/usb/musb/musb_dsps.c
drivers/usb/musb/musb_gadget.c
drivers/usb/musb/musb_virthub.c
drivers/usb/musb/omap2430.c
drivers/usb/musb/tusb6010.c

index 7a95ab87ac00feaafe788342305cfb1d36255fbc..9fbe736880377e39ec6325c260bf6b4a9ccc7bcf 100644 (file)
@@ -107,9 +107,8 @@ static void am35x_musb_enable(struct musb *musb)
        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);
+       musb_writel(reg_base, CORE_INTR_SRC_SET_REG,
+                       AM35X_INTR_DRVVBUS << AM35X_INTR_USB_SHIFT);
 }
 
 /*
@@ -173,9 +172,6 @@ static void otg_timer(unsigned long _musb)
                            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);
@@ -192,9 +188,6 @@ 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);
 
@@ -271,8 +264,7 @@ static irqreturn_t am35x_musb_interrupt(int irq, void *hci)
                u8 devctl = musb_readb(mregs, MUSB_DEVCTL);
                int err;
 
-               err = is_host_enabled(musb) && (musb->int_usb &
-                                               MUSB_INTR_VBUSERROR);
+               err = musb->int_usb & MUSB_INTR_VBUSERROR;
                if (err) {
                        /*
                         * The Mentor core doesn't debounce VBUS as needed
@@ -289,7 +281,7 @@ static irqreturn_t am35x_musb_interrupt(int irq, void *hci)
                        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) {
+               } else if (drvvbus) {
                        MUSB_HST_MODE(musb);
                        otg->default_a = 1;
                        musb->xceiv->state = OTG_STATE_A_WAIT_VRISE;
@@ -326,7 +318,7 @@ eoi:
        }
 
        /* Poll for ID change */
-       if (is_otg_enabled(musb) && musb->xceiv->state == OTG_STATE_B_IDLE)
+       if (musb->xceiv->state == OTG_STATE_B_IDLE)
                mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);
 
        spin_unlock_irqrestore(&musb->lock, flags);
@@ -369,8 +361,7 @@ static int am35x_musb_init(struct musb *musb)
        if (IS_ERR_OR_NULL(musb->xceiv))
                return -ENODEV;
 
-       if (is_host_enabled(musb))
-               setup_timer(&otg_workaround, otg_timer, (unsigned long) musb);
+       setup_timer(&otg_workaround, otg_timer, (unsigned long) musb);
 
        /* Reset the musb */
        if (data->reset)
@@ -400,8 +391,7 @@ static int am35x_musb_exit(struct musb *musb)
        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);
+       del_timer_sync(&otg_workaround);
 
        /* Shutdown the on-chip PHY and its PLL. */
        if (data->set_phy_power)
index 428e6aa3e78a46a3b917fe6a079434d933caf4e6..54f1b98b74de7f9b487c597fcefc0e097831b2eb 100644 (file)
@@ -184,8 +184,8 @@ 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 ((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;
@@ -228,18 +228,13 @@ static void musb_conn_timer_handler(unsigned long _musb)
 
                        val = MUSB_INTR_SUSPEND | MUSB_INTR_VBUSERROR;
                        musb_writeb(musb->mregs, MUSB_INTRUSB, val);
-                       if (is_otg_enabled(musb))
-                               musb->xceiv->state = OTG_STATE_B_IDLE;
-                       else
-                               musb_writeb(musb->mregs, MUSB_POWER, MUSB_POWER_HSENAB);
+                       musb->xceiv->state = OTG_STATE_B_IDLE;
                }
                mod_timer(&musb_conn_timer, jiffies + TIMER_DELAY);
                break;
        case OTG_STATE_B_IDLE:
-
-               if (!is_peripheral_enabled(musb))
-                       break;
-               /* Start a new session.  It seems that MUSB needs taking
+               /*
+                * Start a new session.  It seems that MUSB needs taking
                 * some time to recognize the type of the plug inserted?
                 */
                val = musb_readw(musb->mregs, MUSB_DEVCTL);
@@ -295,10 +290,7 @@ static void musb_conn_timer_handler(unsigned long _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);
-               musb->a_wait_bcon = TIMER_DELAY;
-       }
+       /* REVISIT is this really correct ? */
 }
 
 static void bfin_musb_disable(struct musb *musb)
@@ -323,12 +315,6 @@ static int bfin_musb_set_power(struct usb_phy *x, unsigned mA)
        return 0;
 }
 
-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);
-}
-
 static int bfin_musb_vbus_status(struct musb *musb)
 {
        return 0;
@@ -424,12 +410,10 @@ static int bfin_musb_init(struct musb *musb)
 
        bfin_musb_reg_init(musb);
 
-       if (is_host_enabled(musb)) {
-               setup_timer(&musb_conn_timer,
-                       musb_conn_timer_handler, (unsigned long) musb);
-       }
-       if (is_peripheral_enabled(musb))
-               musb->xceiv->set_power = bfin_musb_set_power;
+       setup_timer(&musb_conn_timer, musb_conn_timer_handler,
+                       (unsigned long) musb);
+
+       musb->xceiv->set_power = bfin_musb_set_power;
 
        musb->isr = blackfin_interrupt;
        musb->double_buffer_not_ok = true;
@@ -454,7 +438,6 @@ static const struct musb_platform_ops bfin_ops = {
        .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,
index 0f9fcec4e1d3075d8c4e44c4aaa39066bece4f5c..4e4df9d2eee2a66d589fff0a75c844dd08fe7c0d 100644 (file)
@@ -155,9 +155,8 @@ static void da8xx_musb_enable(struct musb *musb)
        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);
+       musb_writel(reg_base, DA8XX_USB_INTR_SRC_SET_REG,
+                       DA8XX_INTR_DRVVBUS << DA8XX_INTR_USB_SHIFT);
 }
 
 /**
@@ -231,9 +230,6 @@ static void otg_timer(unsigned long _musb)
                            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
@@ -263,9 +259,6 @@ 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);
 
@@ -333,8 +326,7 @@ static irqreturn_t da8xx_musb_interrupt(int irq, void *hci)
                u8 devctl = musb_readb(mregs, MUSB_DEVCTL);
                int err;
 
-               err = is_host_enabled(musb) && (musb->int_usb &
-                                               MUSB_INTR_VBUSERROR);
+               err = musb->int_usb & USB_INTR_VBUSERROR;
                if (err) {
                        /*
                         * The Mentor core doesn't debounce VBUS as needed
@@ -351,7 +343,7 @@ static irqreturn_t da8xx_musb_interrupt(int irq, void *hci)
                        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) {
+               } else if (drvvbus) {
                        MUSB_HST_MODE(musb);
                        otg->default_a = 1;
                        musb->xceiv->state = OTG_STATE_A_WAIT_VRISE;
@@ -382,7 +374,7 @@ static irqreturn_t da8xx_musb_interrupt(int irq, void *hci)
                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)
+       if (musb->xceiv->state == OTG_STATE_B_IDLE)
                mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);
 
        spin_unlock_irqrestore(&musb->lock, flags);
@@ -430,8 +422,7 @@ static int da8xx_musb_init(struct musb *musb)
        if (IS_ERR_OR_NULL(musb->xceiv))
                goto fail;
 
-       if (is_host_enabled(musb))
-               setup_timer(&otg_workaround, otg_timer, (unsigned long)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);
@@ -454,8 +445,7 @@ fail:
 
 static int da8xx_musb_exit(struct musb *musb)
 {
-       if (is_host_enabled(musb))
-               del_timer_sync(&otg_workaround);
+       del_timer_sync(&otg_workaround);
 
        phy_off();
 
index 472c8b42d38b3a2007d3afa74c526b6431b031cf..8805f809175cee42afba33b2bb9fa590b5dca208 100644 (file)
@@ -115,8 +115,7 @@ static void davinci_musb_enable(struct musb *musb)
                dma_off = 0;
 
        /* force a DRVVBUS irq so we can start polling for ID change */
-       if (is_otg_enabled(musb))
-               musb_writel(musb->ctrl_base, DAVINCI_USB_INT_SET_REG,
+       musb_writel(musb->ctrl_base, DAVINCI_USB_INT_SET_REG,
                        DAVINCI_INTR_DRVVBUS << DAVINCI_USB_USBINT_SHIFT);
 }
 
@@ -234,10 +233,8 @@ static void otg_timer(unsigned long _musb)
                        MUSB_INTR_VBUSERROR << DAVINCI_USB_USBINT_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
+               /*
+                * 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 flag).
                 *
@@ -315,8 +312,7 @@ static irqreturn_t davinci_musb_interrupt(int irq, void *__hci)
                u8      devctl = musb_readb(mregs, MUSB_DEVCTL);
                int     err = musb->int_usb & MUSB_INTR_VBUSERROR;
 
-               err = is_host_enabled(musb)
-                               && (musb->int_usb & MUSB_INTR_VBUSERROR);
+               err = 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
@@ -332,7 +328,7 @@ static irqreturn_t davinci_musb_interrupt(int irq, void *__hci)
                        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) {
+               } else if (drvvbus) {
                        MUSB_HST_MODE(musb);
                        otg->default_a = 1;
                        musb->xceiv->state = OTG_STATE_A_WAIT_VRISE;
@@ -365,8 +361,7 @@ static irqreturn_t davinci_musb_interrupt(int irq, void *__hci)
        musb_writel(tibase, DAVINCI_USB_EOI_REG, 0);
 
        /* poll for ID change */
-       if (is_otg_enabled(musb)
-                       && musb->xceiv->state == OTG_STATE_B_IDLE)
+       if (musb->xceiv->state == OTG_STATE_B_IDLE)
                mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);
 
        spin_unlock_irqrestore(&musb->lock, flags);
@@ -397,8 +392,7 @@ static int davinci_musb_init(struct musb *musb)
        if (revision == 0)
                goto fail;
 
-       if (is_host_enabled(musb))
-               setup_timer(&otg_workaround, otg_timer, (unsigned long) musb);
+       setup_timer(&otg_workaround, otg_timer, (unsigned long) musb);
 
        davinci_musb_source_power(musb, 0, 1);
 
@@ -419,12 +413,7 @@ static int davinci_musb_init(struct musb *musb)
        if (cpu_is_davinci_dm355()) {
                u32     deepsleep = __raw_readl(DM355_DEEPSLEEP);
 
-               if (is_host_enabled(musb)) {
-                       deepsleep &= ~DRVVBUS_OVERRIDE;
-               } else {
-                       deepsleep &= ~DRVVBUS_FORCE;
-                       deepsleep |= DRVVBUS_OVERRIDE;
-               }
+               deepsleep &= ~DRVVBUS_FORCE;
                __raw_writel(deepsleep, DM355_DEEPSLEEP);
        }
 
@@ -453,8 +442,7 @@ unregister:
 
 static int davinci_musb_exit(struct musb *musb)
 {
-       if (is_host_enabled(musb))
-               del_timer_sync(&otg_workaround);
+       del_timer_sync(&otg_workaround);
 
        /* force VBUS off */
        if (cpu_is_davinci_dm355()) {
@@ -468,7 +456,7 @@ static int davinci_musb_exit(struct musb *musb)
        davinci_musb_source_power(musb, 0 /*off*/, 1);
 
        /* delay, to avoid problems with module reload */
-       if (is_host_enabled(musb) && musb->xceiv->otg->default_a) {
+       if (musb->xceiv->otg->default_a) {
                int     maxdelay = 30;
                u8      devctl, warn = 0;
 
index 65b3f5310922508b50658b7129fee6239a63e904..3d9b64707ba370cebfc604c5dafd4e1d71f191dd 100644 (file)
@@ -649,8 +649,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                                break;
                case OTG_STATE_B_PERIPHERAL:
                        musb_g_suspend(musb);
-                       musb->is_active = is_otg_enabled(musb)
-                                       && otg->gadget->b_hnp_enable;
+                       musb->is_active = otg->gadget->b_hnp_enable;
                        if (musb->is_active) {
                                musb->xceiv->state = OTG_STATE_B_WAIT_ACON;
                                dev_dbg(musb->controller, "HNP: Setting timer for b_ase0_brst\n");
@@ -666,8 +665,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                        break;
                case OTG_STATE_A_HOST:
                        musb->xceiv->state = OTG_STATE_A_SUSPEND;
-                       musb->is_active = is_otg_enabled(musb)
-                                       && otg->host->b_hnp_enable;
+                       musb->is_active = otg->host->b_hnp_enable;
                        break;
                case OTG_STATE_B_HOST:
                        /* Transition to B_PERIPHERAL, see 6.8.2.6 p 44 */
@@ -755,7 +753,7 @@ b_host:
                case OTG_STATE_A_SUSPEND:
                        usb_hcd_resume_root_hub(musb_to_hcd(musb));
                        musb_root_disconnect(musb);
-                       if (musb->a_wait_bcon != 0 && is_otg_enabled(musb))
+                       if (musb->a_wait_bcon != 0)
                                musb_platform_try_idle(musb, jiffies
                                        + msecs_to_jiffies(musb->a_wait_bcon));
                        break;
@@ -931,25 +929,16 @@ void musb_start(struct musb *musb)
        devctl = musb_readb(regs, MUSB_DEVCTL);
        devctl &= ~MUSB_DEVCTL_SESSION;
 
-       if (is_otg_enabled(musb)) {
-               /* session started after:
-                * (a) ID-grounded irq, host mode;
-                * (b) vbus present/connect IRQ, peripheral mode;
-                * (c) peripheral initiates, using SRP
-                */
-               if ((devctl & MUSB_DEVCTL_VBUS) == MUSB_DEVCTL_VBUS)
-                       musb->is_active = 1;
-               else
-                       devctl |= MUSB_DEVCTL_SESSION;
-
-       } else if (is_host_enabled(musb)) {
-               /* assume ID pin is hard-wired to ground */
+       /* session started after:
+        * (a) ID-grounded irq, host mode;
+        * (b) vbus present/connect IRQ, peripheral mode;
+        * (c) peripheral initiates, using SRP
+        */
+       if ((devctl & MUSB_DEVCTL_VBUS) == MUSB_DEVCTL_VBUS)
+               musb->is_active = 1;
+       else
                devctl |= MUSB_DEVCTL_SESSION;
 
-       } else /* peripheral is enabled */ {
-               if ((devctl & MUSB_DEVCTL_VBUS) == MUSB_DEVCTL_VBUS)
-                       musb->is_active = 1;
-       }
        musb_platform_enable(musb);
        musb_writeb(regs, MUSB_DEVCTL, devctl);
 }
@@ -1013,8 +1002,6 @@ static void musb_shutdown(struct platform_device *pdev)
        musb_generic_disable(musb);
        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);
 
@@ -1885,6 +1872,7 @@ musb_init_controller(struct device *dev, int nIrq, void __iomem *ctrl)
        int                     status;
        struct musb             *musb;
        struct musb_hdrc_platform_data *plat = dev->platform_data;
+       struct usb_hcd          *hcd;
 
        /* The driver might handle more features than the board; OK.
         * Fail when the board needs a feature that's not enabled.
@@ -1907,7 +1895,6 @@ musb_init_controller(struct device *dev, int nIrq, void __iomem *ctrl)
        pm_runtime_enable(musb->controller);
 
        spin_lock_init(&musb->lock);
-       musb->board_mode = plat->mode;
        musb->board_set_power = plat->set_power;
        musb->min_power = plat->min_power;
        musb->ops = plat->platform_ops;
@@ -1978,7 +1965,7 @@ musb_init_controller(struct device *dev, int nIrq, void __iomem *ctrl)
                goto fail3;
        }
        musb->nIrq = nIrq;
-/* FIXME this handles wakeup irqs wrong */
+       /* FIXME this handles wakeup irqs wrong */
        if (enable_irq_wake(nIrq) == 0) {
                musb->irq_wake = 1;
                device_init_wakeup(dev, 1);
@@ -1987,58 +1974,25 @@ musb_init_controller(struct device *dev, int nIrq, void __iomem *ctrl)
        }
 
        /* host side needs more setup */
-       if (is_host_enabled(musb)) {
-               struct usb_hcd  *hcd = musb_to_hcd(musb);
-
-               otg_set_host(musb->xceiv->otg, &hcd->self);
-
-               if (is_otg_enabled(musb))
-                       hcd->self.otg_port = 1;
-               musb->xceiv->otg->host = &hcd->self;
-               hcd->power_budget = 2 * (plat->power ? : 250);
-
-               /* program PHY to use external vBus if required */
-               if (plat->extvbus) {
-                       u8 busctl = musb_read_ulpi_buscontrol(musb->mregs);
-                       busctl |= MUSB_ULPI_USE_EXTVBUS;
-                       musb_write_ulpi_buscontrol(musb->mregs, busctl);
-               }
+       hcd = musb_to_hcd(musb);
+       otg_set_host(musb->xceiv->otg, &hcd->self);
+       hcd->self.otg_port = 1;
+       musb->xceiv->otg->host = &hcd->self;
+       hcd->power_budget = 2 * (plat->power ? : 250);
+
+       /* program PHY to use external vBus if required */
+       if (plat->extvbus) {
+               u8 busctl = musb_read_ulpi_buscontrol(musb->mregs);
+               busctl |= MUSB_ULPI_USE_EXTVBUS;
+               musb_write_ulpi_buscontrol(musb->mregs, busctl);
        }
 
-       /* For the host-only role, we can activate right away.
-        * (We expect the ID pin to be forcibly grounded!!)
-        * 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->otg->default_a = 1;
-               musb->xceiv->state = OTG_STATE_A_IDLE;
-
-               status = usb_add_hcd(musb_to_hcd(musb), 0, 0);
-
-               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)
-                                       & MUSB_DEVCTL_BDEVICE
-                               ? 'B' : 'A'));
-
-       } else /* peripheral is enabled */ {
-               MUSB_DEV_MODE(musb);
-               musb->xceiv->otg->default_a = 0;
-               musb->xceiv->state = OTG_STATE_B_IDLE;
-
-               status = musb_gadget_setup(musb);
+       MUSB_DEV_MODE(musb);
+       musb->xceiv->otg->default_a = 0;
+       musb->xceiv->state = OTG_STATE_B_IDLE;
 
-               dev_dbg(musb->controller, "%s mode, status %d, dev%02x\n",
-                       is_otg_enabled(musb) ? "OTG" : "PERIPHERAL",
-                       status,
-                       musb_readb(musb->mregs, MUSB_DEVCTL));
+       status = musb_gadget_setup(musb);
 
-       }
        if (status < 0)
                goto fail3;
 
@@ -2054,28 +2008,13 @@ musb_init_controller(struct device *dev, int nIrq, void __iomem *ctrl)
 
        pm_runtime_put(musb->controller);
 
-       dev_info(dev, "USB %s mode controller at %p using %s, IRQ %d\n",
-                       ({char *s;
-                        switch (musb->board_mode) {
-                        case MUSB_HOST:                s = "Host"; break;
-                        case MUSB_PERIPHERAL:  s = "Peripheral"; break;
-                        default:               s = "OTG"; break;
-                        }; s; }),
-                       ctrl,
-                       (is_dma_capable() && musb->dma_controller)
-                       ? "DMA" : "PIO",
-                       musb->nIrq);
-
        return 0;
 
 fail5:
        musb_exit_debugfs(musb);
 
 fail4:
-       if (!is_otg_enabled(musb) && is_host_enabled(musb))
-               usb_remove_hcd(musb_to_hcd(musb));
-       else
-               musb_gadget_cleanup(musb);
+       musb_gadget_cleanup(musb);
 
 fail3:
        pm_runtime_put_sync(musb->controller);
@@ -2166,11 +2105,9 @@ static void musb_save_context(struct musb *musb)
        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);
@@ -2209,30 +2146,29 @@ static void musb_save_context(struct musb *musb)
                        musb->context.index_regs[i].rxfifosz =
                                        musb_read_rxfifosz(musb_base);
                }
-               if (is_host_enabled(musb)) {
-                       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_read_txhubaddr(musb_base, i);
-                       musb->context.index_regs[i].txhubport =
-                               musb_read_txhubport(musb_base, i);
-
-                       musb->context.index_regs[i].rxfunaddr =
-                               musb_read_rxfunaddr(musb_base, i);
-                       musb->context.index_regs[i].rxhubaddr =
-                               musb_read_rxhubaddr(musb_base, i);
-                       musb->context.index_regs[i].rxhubport =
-                               musb_read_rxhubport(musb_base, i);
-               }
+
+               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_read_txhubaddr(musb_base, i);
+               musb->context.index_regs[i].txhubport =
+                       musb_read_txhubport(musb_base, i);
+
+               musb->context.index_regs[i].rxfunaddr =
+                       musb_read_rxfunaddr(musb_base, i);
+               musb->context.index_regs[i].rxhubaddr =
+                       musb_read_rxhubaddr(musb_base, i);
+               musb->context.index_regs[i].rxhubport =
+                       musb_read_rxhubport(musb_base, i);
        }
 }
 
@@ -2243,11 +2179,9 @@ static void musb_restore_context(struct musb *musb)
        void __iomem *ep_target_regs;
        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);
@@ -2286,33 +2220,31 @@ static void musb_restore_context(struct musb *musb)
                                musb->context.index_regs[i].rxfifoadd);
                }
 
-               if (is_host_enabled(musb)) {
-                       musb_writeb(epio, MUSB_TXTYPE,
+               musb_writeb(epio, MUSB_TXTYPE,
                                musb->context.index_regs[i].txtype);
-                       musb_writeb(epio, MUSB_TXINTERVAL,
+               musb_writeb(epio, MUSB_TXINTERVAL,
                                musb->context.index_regs[i].txinterval);
-                       musb_writeb(epio, MUSB_RXTYPE,
+               musb_writeb(epio, MUSB_RXTYPE,
                                musb->context.index_regs[i].rxtype);
-                       musb_writeb(epio, MUSB_RXINTERVAL,
+               musb_writeb(epio, MUSB_RXINTERVAL,
 
-                       musb->context.index_regs[i].rxinterval);
-                       musb_write_txfunaddr(musb_base, i,
+                               musb->context.index_regs[i].rxinterval);
+               musb_write_txfunaddr(musb_base, i,
                                musb->context.index_regs[i].txfunaddr);
-                       musb_write_txhubaddr(musb_base, i,
+               musb_write_txhubaddr(musb_base, i,
                                musb->context.index_regs[i].txhubaddr);
-                       musb_write_txhubport(musb_base, i,
+               musb_write_txhubport(musb_base, i,
                                musb->context.index_regs[i].txhubport);
 
-                       ep_target_regs =
-                               musb_read_target_reg_base(i, musb_base);
+               ep_target_regs =
+                       musb_read_target_reg_base(i, musb_base);
 
-                       musb_write_rxfunaddr(ep_target_regs,
+               musb_write_rxfunaddr(ep_target_regs,
                                musb->context.index_regs[i].rxfunaddr);
-                       musb_write_rxhubaddr(ep_target_regs,
+               musb_write_rxhubaddr(ep_target_regs,
                                musb->context.index_regs[i].rxhubaddr);
-                       musb_write_rxhubport(ep_target_regs,
+               musb_write_rxhubport(ep_target_regs,
                                musb->context.index_regs[i].rxhubport);
-               }
        }
        musb_writeb(musb_base, MUSB_INDEX, musb->context.index);
 }
index 8bb324dddd1761e411dcdd6f779b41180c3554c5..5dab2daddf7fcb668dc56ab0cfdbaa88bc8d85a7 100644 (file)
@@ -71,10 +71,6 @@ struct musb_ep;
 #include <linux/usb/hcd.h>
 #include "musb_host.h"
 
-#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)
-
 /* NOTE:  otg and peripheral-only state machines start at B_IDLE.
  * OTG or host-only go to A_IDLE when ID is sensed.
  */
@@ -376,7 +372,6 @@ struct musb {
        u16 epmask;
        u8 nr_endpoints;
 
-       u8 board_mode;          /* enum musb_mode */
        int                     (*board_set_power)(int state);
 
        u8                      min_power;      /* vbus for periph, in mA/2 */
index 217808d9fbe1991298da67295404d50cd71e593a..51ff1bbff381de95120909b2ba9acf985e5bdea6 100644 (file)
@@ -137,9 +137,8 @@ static void dsps_musb_enable(struct musb *musb)
        dsps_writel(reg_base, wrp->epintr_set, epmask);
        dsps_writel(reg_base, wrp->coreintr_set, coremask);
        /* Force the DRVVBUS IRQ so we can start polling for ID change. */
-       if (is_otg_enabled(musb))
-               dsps_writel(reg_base, wrp->coreintr_set,
-                           (1 << wrp->drvvbus) << wrp->usb_shift);
+       dsps_writel(reg_base, wrp->coreintr_set,
+                   (1 << wrp->drvvbus) << wrp->usb_shift);
 }
 
 /**
@@ -200,9 +199,6 @@ static void otg_timer(unsigned long _musb)
                            MUSB_INTR_VBUSERROR << wrp->usb_shift);
                break;
        case OTG_STATE_B_IDLE:
-               if (!is_peripheral_enabled(musb))
-                       break;
-
                devctl = dsps_readb(mregs, MUSB_DEVCTL);
                if (devctl & MUSB_DEVCTL_BDEVICE)
                        mod_timer(&glue->timer,
@@ -223,9 +219,6 @@ static void dsps_musb_try_idle(struct musb *musb, unsigned long timeout)
        struct dsps_glue *glue = platform_get_drvdata(pdev);
        static unsigned long last_timer;
 
-       if (!is_otg_enabled(musb))
-               return;
-
        if (timeout == 0)
                timeout = jiffies + msecs_to_jiffies(3);
 
@@ -293,7 +286,7 @@ static irqreturn_t dsps_interrupt(int irq, void *hci)
         * value but DEVCTL.BDEVICE is invalid without DEVCTL.SESSION set.
         * Also, DRVVBUS pulses for SRP (but not at 5V) ...
         */
-       if ((usbintr & MUSB_INTR_BABBLE) && is_host_enabled(musb))
+       if (usbintr & MUSB_INTR_BABBLE)
                pr_info("CAUTION: musb: Babble Interrupt Occured\n");
 
        if (usbintr & ((1 << wrp->drvvbus) << wrp->usb_shift)) {
@@ -302,8 +295,7 @@ static irqreturn_t dsps_interrupt(int irq, void *hci)
                u8 devctl = dsps_readb(mregs, MUSB_DEVCTL);
                int err;
 
-               err = is_host_enabled(musb) && (musb->int_usb &
-                                               MUSB_INTR_VBUSERROR);
+               err = musb->int_usb & MUSB_INTR_VBUSERROR;
                if (err) {
                        /*
                         * The Mentor core doesn't debounce VBUS as needed
@@ -321,7 +313,7 @@ static irqreturn_t dsps_interrupt(int irq, void *hci)
                        mod_timer(&glue->timer,
                                        jiffies + wrp->poll_seconds * HZ);
                        WARNING("VBUS error workaround (delay coming)\n");
-               } else if (is_host_enabled(musb) && drvvbus) {
+               } else if (drvvbus) {
                        musb->is_active = 1;
                        MUSB_HST_MODE(musb);
                        musb->xceiv->otg->default_a = 1;
@@ -352,7 +344,7 @@ static irqreturn_t dsps_interrupt(int irq, void *hci)
                dsps_writel(reg_base, wrp->eoi, 1);
 
        /* Poll for ID change */
-       if (is_otg_enabled(musb) && musb->xceiv->state == OTG_STATE_B_IDLE)
+       if (musb->xceiv->state == OTG_STATE_B_IDLE)
                mod_timer(&glue->timer, jiffies + wrp->poll_seconds * HZ);
 
        spin_unlock_irqrestore(&musb->lock, flags);
@@ -388,8 +380,7 @@ static int dsps_musb_init(struct musb *musb)
                goto err0;
        }
 
-       if (is_host_enabled(musb))
-               setup_timer(&glue->timer, otg_timer, (unsigned long) musb);
+       setup_timer(&glue->timer, otg_timer, (unsigned long) musb);
 
        /* Reset the musb */
        dsps_writel(reg_base, wrp->control, (1 << wrp->reset));
@@ -423,8 +414,7 @@ static int dsps_musb_exit(struct musb *musb)
        struct platform_device *pdev = to_platform_device(dev->parent);
        struct dsps_glue *glue = platform_get_drvdata(pdev);
 
-       if (is_host_enabled(musb))
-               del_timer_sync(&glue->timer);
+       del_timer_sync(&glue->timer);
 
        /* Shutdown the on-chip PHY and its PLL. */
        if (data->set_phy_power)
index 5c4392b02169ed464e2ec0f761fae861ad264fdb..7fb060d912821ce93cf9207c0499fcaec640be72 100644 (file)
@@ -1864,8 +1864,7 @@ int __devinit musb_gadget_setup(struct musb *musb)
        musb->g.dev.release = musb_gadget_release;
        musb->g.name = musb_driver_name;
 
-       if (is_otg_enabled(musb))
-               musb->g.is_otg = 1;
+       musb->g.is_otg = 1;
 
        musb_g_init_endpoints(musb);
 
@@ -1911,11 +1910,14 @@ static int musb_gadget_start(struct usb_gadget *g,
 {
        struct musb             *musb = gadget_to_musb(g);
        struct usb_otg          *otg = musb->xceiv->otg;
+       struct usb_hcd          *hcd = musb_to_hcd(musb);
        unsigned long           flags;
-       int                     retval = -EINVAL;
+       int                     retval = 0;
 
-       if (driver->max_speed < USB_SPEED_HIGH)
-               goto err0;
+       if (driver->max_speed < USB_SPEED_HIGH) {
+               retval = -EINVAL;
+               goto err;
+       }
 
        pm_runtime_get_sync(musb->controller);
 
@@ -1929,49 +1931,30 @@ static int musb_gadget_start(struct usb_gadget *g,
 
        otg_set_peripheral(otg, &musb->g);
        musb->xceiv->state = OTG_STATE_B_IDLE;
-
-       /*
-        * 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);
-
        spin_unlock_irqrestore(&musb->lock, flags);
 
-       if (is_otg_enabled(musb)) {
-               struct usb_hcd  *hcd = musb_to_hcd(musb);
-
-               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(hcd, 0, 0);
+       if (retval < 0) {
+               dev_dbg(musb->controller, "add_hcd failed, %d\n", retval);
+               goto err;
+       }
 
-               /* 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), 0, 0);
-               if (retval < 0) {
-                       dev_dbg(musb->controller, "add_hcd failed, %d\n", retval);
-                       goto err2;
-               }
+       if ((musb->xceiv->last_event == USB_EVENT_ID)
+                               && otg->set_vbus)
+               otg_set_vbus(otg, 1);
 
-               if ((musb->xceiv->last_event == USB_EVENT_ID)
-                                       && otg->set_vbus)
-                       otg_set_vbus(otg, 1);
+       hcd->self.uses_pio_for_control = 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);
-err0:
+err:
        return retval;
 }
 
@@ -2049,16 +2032,12 @@ static int musb_gadget_stop(struct usb_gadget *g,
        musb_platform_try_idle(musb, 0);
        spin_unlock_irqrestore(&musb->lock, flags);
 
-       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;
-                * that currently misbehaves.
-                */
-       }
-
-       if (!is_otg_enabled(musb))
-               musb_stop(musb);
+       usb_remove_hcd(musb_to_hcd(musb));
+       /*
+        * FIXME we need to be able to register another
+        * gadget driver here and have everything work;
+        * that currently misbehaves.
+        */
 
        pm_runtime_put(musb->controller);
 
@@ -2220,13 +2199,11 @@ __acquires(musb->lock)
        if (devctl & MUSB_DEVCTL_BDEVICE) {
                musb->xceiv->state = OTG_STATE_B_PERIPHERAL;
                musb->g.is_a_peripheral = 0;
-       } else if (is_otg_enabled(musb)) {
+       } else {
                musb->xceiv->state = OTG_STATE_A_PERIPHERAL;
                musb->g.is_a_peripheral = 1;
-       } else
-               WARN_ON(1);
+       }
 
        /* start with default limits on VBUS power draw */
-       (void) musb_gadget_vbus_draw(&musb->g,
-                       is_otg_enabled(musb) ? 8 : 100);
+       (void) musb_gadget_vbus_draw(&musb->g, 8);
 }
index 22ec3e3799808689f1b741188d5e2c01bf0991a7..f70579154ded77467ed33976e357ef763b478149 100644 (file)
@@ -81,8 +81,7 @@ static void musb_port_suspend(struct musb *musb, bool do_suspend)
                switch (musb->xceiv->state) {
                case OTG_STATE_A_HOST:
                        musb->xceiv->state = OTG_STATE_A_SUSPEND;
-                       musb->is_active = is_otg_enabled(musb)
-                                       && otg->host->b_hnp_enable;
+                       musb->is_active = otg->host->b_hnp_enable;
                        if (musb->is_active)
                                mod_timer(&musb->otg_timer, jiffies
                                        + msecs_to_jiffies(
@@ -91,8 +90,7 @@ static void musb_port_suspend(struct musb *musb, bool do_suspend)
                        break;
                case OTG_STATE_B_HOST:
                        musb->xceiv->state = OTG_STATE_B_WAIT_ACON;
-                       musb->is_active = is_otg_enabled(musb)
-                                       && otg->host->b_hnp_enable;
+                       musb->is_active = otg->host->b_hnp_enable;
                        musb_platform_try_idle(musb, 0);
                        break;
                default:
@@ -190,8 +188,7 @@ void musb_root_disconnect(struct musb *musb)
 
        switch (musb->xceiv->state) {
        case OTG_STATE_A_SUSPEND:
-               if (is_otg_enabled(musb)
-                               && otg->host->b_hnp_enable) {
+               if (otg->host->b_hnp_enable) {
                        musb->xceiv->state = OTG_STATE_A_PERIPHERAL;
                        musb->g.is_a_peripheral = 1;
                        break;
@@ -273,7 +270,7 @@ int musb_hub_control(
                        musb_port_suspend(musb, false);
                        break;
                case USB_PORT_FEAT_POWER:
-                       if (!(is_otg_enabled(musb) && hcd->self.is_b_host))
+                       if (!hcd->self.is_b_host)
                                musb_platform_set_vbus(musb, 0);
                        break;
                case USB_PORT_FEAT_C_CONNECTION:
@@ -369,7 +366,7 @@ int musb_hub_control(
                         * initialization logic, e.g. for OTG, or change any
                         * logic relating to VBUS power-up.
                         */
-                       if (!(is_otg_enabled(musb) && hcd->self.is_b_host))
+                       if (!hcd->self.is_b_host)
                                musb_start(musb);
                        break;
                case USB_PORT_FEAT_RESET:
index 392fc7a488f2d8da98e0fb06c3d6d72c889662ca..e32aff9920f2e780c040f925d61100f56511c04f 100644 (file)
@@ -258,7 +258,7 @@ static void omap_musb_set_mailbox(struct omap2430_glue *glue)
                otg->default_a = true;
                musb->xceiv->state = OTG_STATE_A_IDLE;
                musb->xceiv->last_event = USB_EVENT_ID;
-               if (!is_otg_enabled(musb) || musb->gadget_driver) {
+               if (musb->gadget_driver) {
                        pm_runtime_get_sync(dev);
                        usb_phy_init(musb->xceiv);
                        omap2430_musb_set_vbus(musb, 1);
@@ -281,11 +281,10 @@ static void omap_musb_set_mailbox(struct omap2430_glue *glue)
                dev_dbg(dev, "VBUS Disconnect\n");
 
                musb->xceiv->last_event = USB_EVENT_NONE;
-               if (is_otg_enabled(musb) || is_peripheral_enabled(musb))
-                       if (musb->gadget_driver) {
-                               pm_runtime_mark_last_busy(dev);
-                               pm_runtime_put_autosuspend(dev);
-                       }
+               if (musb->gadget_driver) {
+                       pm_runtime_mark_last_busy(dev);
+                       pm_runtime_put_autosuspend(dev);
+               }
 
                if (data->interface_type == MUSB_INTERFACE_UTMI) {
                        if (musb->xceiv->otg->set_vbus)
index 4073a6fa26337d24b323230204a67c952d1023d3..1d0c090be78cb9ef94644b47e2086e882a4404bc 100644 (file)
@@ -437,14 +437,13 @@ static void musb_do_idle(unsigned long _musb)
                if (is_host_active(musb) && (musb->port1_status >> 16))
                        goto done;
 
-               if (is_peripheral_enabled(musb) && !musb->gadget_driver) {
+               if (!musb->gadget_driver) {
                        wakeups = 0;
                } else {
                        wakeups = TUSB_PRCM_WHOSTDISCON
                                | TUSB_PRCM_WBUS
                                        | TUSB_PRCM_WVBUS;
-                       if (is_otg_enabled(musb))
-                               wakeups |= TUSB_PRCM_WID;
+                       wakeups |= TUSB_PRCM_WID;
                }
                tusb_allow_idle(musb, wakeups);
        }
@@ -582,21 +581,12 @@ static void tusb_musb_set_vbus(struct musb *musb, int is_on)
  *
  * Note that if a mini-A cable is plugged in the ID line will stay down as
  * the weak ID pull-up is not able to pull the ID up.
- *
- * REVISIT: It would be possible to add support for changing between host
- * and peripheral modes in non-OTG configurations by reconfiguring hardware
- * and then setting musb->board_mode. For now, only support OTG 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;
 
-       if (musb->board_mode != MUSB_OTG) {
-               ERR("Changing mode currently only supported in OTG mode\n");
-               return -EINVAL;
-       }
-
        otg_stat = musb_readl(tbase, TUSB_DEV_OTG_STAT);
        phy_otg_ctrl = musb_readl(tbase, TUSB_PHY_OTG_CTRL);
        phy_otg_ena = musb_readl(tbase, TUSB_PHY_OTG_CTRL_ENABLE);
@@ -652,10 +642,7 @@ tusb_otg_ints(struct musb *musb, u32 int_src, void __iomem *tbase)
        if ((int_src & TUSB_INT_SRC_ID_STATUS_CHNG)) {
                int     default_a;
 
-               if (is_otg_enabled(musb))
-                       default_a = !(otg_stat & TUSB_DEV_OTG_STAT_ID_STATUS);
-               else
-                       default_a = is_host_enabled(musb);
+               default_a = !(otg_stat & TUSB_DEV_OTG_STAT_ID_STATUS);
                dev_dbg(musb->controller, "Default-%c\n", default_a ? 'A' : 'B');
                otg->default_a = default_a;
                tusb_musb_set_vbus(musb, default_a);
@@ -669,8 +656,7 @@ tusb_otg_ints(struct musb *musb, u32 int_src, void __iomem *tbase)
        if (int_src & TUSB_INT_SRC_VBUS_SENSE_CHNG) {
 
                /* B-dev state machine:  no vbus ~= disconnect */
-               if ((is_otg_enabled(musb) && !otg->default_a)
-                               || !is_host_enabled(musb)) {
+               if (!otg->default_a) {
                        /* ? musb_root_disconnect(musb); */
                        musb->port1_status &=
                                ~(USB_PORT_STAT_CONNECTION
@@ -1119,10 +1105,8 @@ static int tusb_musb_init(struct musb *musb)
        }
        musb->isr = tusb_musb_interrupt;
 
-       if (is_peripheral_enabled(musb)) {
-               musb->xceiv->set_power = tusb_draw_power;
-               the_musb = musb;
-       }
+       musb->xceiv->set_power = tusb_draw_power;
+       the_musb = musb;
 
        setup_timer(&musb_idle_timer, musb_do_idle, (unsigned long) musb);