usb: fix building musb drivers

Commit 3dacdf11 "usb: factor out state_string() on otg drivers"
broke building musb drivers since there is already another
otg_state_string() function in musb drivers, but with different
prototype. Fix musb drivers to use common otg_state_string(), too.

Also provide a nop for otg_state_string() if CONFIG_USB_OTG_UTILS
is not defined.

Signed-off-by: Anatolij Gustschin <agust@denx.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

diff --git a/drivers/usb/musb/am35x.c b/drivers/usb/musb/am35x.c
index d5a3da37c90c953ef69b3c1da6bc19a11dda7b9d..9e6209f87d3be9bf1b2f1d2974a9f0f48378f2f1 100644 (file)
--- a/drivers/usb/musb/am35x.c
+++ b/drivers/usb/musb/am35x.c
@@ -151,7 +151,8 @@ static void otg_timer(unsigned long _musb)
         * status change events (from the transceiver) otherwise.
         */
        devctl = musb_readb(mregs, MUSB_DEVCTL);
-       DBG(7, "Poll devctl %02x (%s)\n", devctl, otg_state_string(musb));
+       DBG(7, "Poll devctl %02x (%s)\n", devctl,
+               otg_state_string(musb->xceiv->state));
 
        spin_lock_irqsave(&musb->lock, flags);
        switch (musb->xceiv->state) {
@@ -202,7 +203,8 @@ static void am35x_musb_try_idle(struct musb *musb, unsigned long timeout)
        /* Never idle if active, or when VBUS timeout is not set as host */
        if (musb->is_active || (musb->a_wait_bcon == 0 &&
                                musb->xceiv->state == OTG_STATE_A_WAIT_BCON)) {
-               DBG(4, "%s active, deleting timer\n", otg_state_string(musb));
+               DBG(4, "%s active, deleting timer\n",
+                       otg_state_string(musb->xceiv->state));
                del_timer(&otg_workaround);
                last_timer = jiffies;
                return;
@@ -215,7 +217,8 @@ static void am35x_musb_try_idle(struct musb *musb, unsigned long timeout)
        last_timer = timeout;
 
        DBG(4, "%s inactive, starting idle timer for %u ms\n",
-           otg_state_string(musb), jiffies_to_msecs(timeout - jiffies));
+               otg_state_string(musb->xceiv->state),
+               jiffies_to_msecs(timeout - jiffies));
        mod_timer(&otg_workaround, timeout);
 }
 
@@ -304,7 +307,7 @@ static irqreturn_t am35x_musb_interrupt(int irq, void *hci)
                /* NOTE: this must complete power-on within 100 ms. */
                DBG(2, "VBUS %s (%s)%s, devctl %02x\n",
                                drvvbus ? "on" : "off",
-                               otg_state_string(musb),
+                               otg_state_string(musb->xceiv->state),
                                err ? " ERROR" : "",
                                devctl);
                ret = IRQ_HANDLED;

diff --git a/drivers/usb/musb/blackfin.c b/drivers/usb/musb/blackfin.c
index 8e2a1ff8a35a8b71cbe6296bf5d546b0d46035c6..e141d89656e17174a641f2e20ac79cad0cc33202 100644 (file)
--- a/drivers/usb/musb/blackfin.c
+++ b/drivers/usb/musb/blackfin.c
@@ -279,12 +279,13 @@ static void musb_conn_timer_handler(unsigned long _musb)
                }
                break;
        default:
-               DBG(1, "%s state not handled\n", otg_state_string(musb));
+               DBG(1, "%s state not handled\n",
+                       otg_state_string(musb->xceiv->state));
                break;
        }
        spin_unlock_irqrestore(&musb->lock, flags);
 
-       DBG(4, "state is %s\n", otg_state_string(musb));
+       DBG(4, "state is %s\n", otg_state_string(musb->xceiv->state));
 }
 
 static void bfin_musb_enable(struct musb *musb)
@@ -308,7 +309,7 @@ static void bfin_musb_set_vbus(struct musb *musb, int is_on)
 
        DBG(1, "VBUS %s, devctl %02x "
                /* otg %3x conf %08x prcm %08x */ "\n",
-               otg_state_string(musb),
+               otg_state_string(musb->xceiv->state),
                musb_readb(musb->mregs, MUSB_DEVCTL));
 }
 

diff --git a/drivers/usb/musb/da8xx.c b/drivers/usb/musb/da8xx.c
index 69a0da3c8f09b4b25887af382eb6eb1b33daa5d6..0d8984993a38ab645b6ba46cd5fd084df86da438 100644 (file)
--- a/drivers/usb/musb/da8xx.c
+++ b/drivers/usb/musb/da8xx.c
@@ -199,7 +199,8 @@ static void otg_timer(unsigned long _musb)
         * status change events (from the transceiver) otherwise.
         */
        devctl = musb_readb(mregs, MUSB_DEVCTL);
-       DBG(7, "Poll devctl %02x (%s)\n", devctl, otg_state_string(musb));
+       DBG(7, "Poll devctl %02x (%s)\n", devctl,
+               otg_state_string(musb->xceiv->state));
 
        spin_lock_irqsave(&musb->lock, flags);
        switch (musb->xceiv->state) {
@@ -273,7 +274,8 @@ static void da8xx_musb_try_idle(struct musb *musb, unsigned long timeout)
        /* Never idle if active, or when VBUS timeout is not set as host */
        if (musb->is_active || (musb->a_wait_bcon == 0 &&
                                musb->xceiv->state == OTG_STATE_A_WAIT_BCON)) {
-               DBG(4, "%s active, deleting timer\n", otg_state_string(musb));
+               DBG(4, "%s active, deleting timer\n",
+                       otg_state_string(musb->xceiv->state));
                del_timer(&otg_workaround);
                last_timer = jiffies;
                return;
@@ -286,7 +288,8 @@ static void da8xx_musb_try_idle(struct musb *musb, unsigned long timeout)
        last_timer = timeout;
 
        DBG(4, "%s inactive, starting idle timer for %u ms\n",
-           otg_state_string(musb), jiffies_to_msecs(timeout - jiffies));
+               otg_state_string(musb->xceiv->state),
+               jiffies_to_msecs(timeout - jiffies));
        mod_timer(&otg_workaround, timeout);
 }
 
@@ -365,7 +368,7 @@ static irqreturn_t da8xx_musb_interrupt(int irq, void *hci)
 
                DBG(2, "VBUS %s (%s)%s, devctl %02x\n",
                                drvvbus ? "on" : "off",
-                               otg_state_string(musb),
+                               otg_state_string(musb->xceiv->state),
                                err ? " ERROR" : "",
                                devctl);
                ret = IRQ_HANDLED;

diff --git a/drivers/usb/musb/davinci.c b/drivers/usb/musb/davinci.c
index e6de097fb7e823c8d5b663d0efc22e3e0276d717..3661b81a957124987d8273835d75469df077ff0c 100644 (file)
--- a/drivers/usb/musb/davinci.c
+++ b/drivers/usb/musb/davinci.c
@@ -220,7 +220,8 @@ static void otg_timer(unsigned long _musb)
        * status change events (from the transceiver) otherwise.
         */
        devctl = musb_readb(mregs, MUSB_DEVCTL);
-       DBG(7, "poll devctl %02x (%s)\n", devctl, otg_state_string(musb));
+       DBG(7, "poll devctl %02x (%s)\n", devctl,
+               otg_state_string(musb->xceiv->state));
 
        spin_lock_irqsave(&musb->lock, flags);
        switch (musb->xceiv->state) {
@@ -356,7 +357,7 @@ static irqreturn_t davinci_musb_interrupt(int irq, void *__hci)
                davinci_musb_source_power(musb, drvvbus, 0);
                DBG(2, "VBUS %s (%s)%s, devctl %02x\n",
                                drvvbus ? "on" : "off",
-                               otg_state_string(musb),
+                               otg_state_string(musb->xceiv->state),
                                err ? " ERROR" : "",
                                devctl);
                retval = IRQ_HANDLED;

diff --git a/drivers/usb/musb/musb_core.c b/drivers/usb/musb/musb_core.c
index f10ff00ca09ea377bbd7dd6167e3723260bd78f9..9a280872c2b47fed320c89c7ffd869a2177baa8e 100644 (file)
--- a/drivers/usb/musb/musb_core.c
+++ b/drivers/usb/musb/musb_core.c
@@ -333,26 +333,6 @@ void musb_load_testpacket(struct musb *musb)
 
 /*-------------------------------------------------------------------------*/
 
-const char *otg_state_string(struct musb *musb)
-{
-       switch (musb->xceiv->state) {
-       case OTG_STATE_A_IDLE:          return "a_idle";
-       case OTG_STATE_A_WAIT_VRISE:    return "a_wait_vrise";
-       case OTG_STATE_A_WAIT_BCON:     return "a_wait_bcon";
-       case OTG_STATE_A_HOST:          return "a_host";
-       case OTG_STATE_A_SUSPEND:       return "a_suspend";
-       case OTG_STATE_A_PERIPHERAL:    return "a_peripheral";
-       case OTG_STATE_A_WAIT_VFALL:    return "a_wait_vfall";
-       case OTG_STATE_A_VBUS_ERR:      return "a_vbus_err";
-       case OTG_STATE_B_IDLE:          return "b_idle";
-       case OTG_STATE_B_SRP_INIT:      return "b_srp_init";
-       case OTG_STATE_B_PERIPHERAL:    return "b_peripheral";
-       case OTG_STATE_B_WAIT_ACON:     return "b_wait_acon";
-       case OTG_STATE_B_HOST:          return "b_host";
-       default:                        return "UNDEFINED";
-       }
-}
-
 #ifdef CONFIG_USB_MUSB_OTG
 
 /*
@@ -373,12 +353,14 @@ void musb_otg_timer_func(unsigned long data)
                break;
        case OTG_STATE_A_SUSPEND:
        case OTG_STATE_A_WAIT_BCON:
-               DBG(1, "HNP: %s timeout\n", otg_state_string(musb));
+               DBG(1, "HNP: %s timeout\n",
+                       otg_state_string(musb->xceiv->state));
                musb_platform_set_vbus(musb, 0);
                musb->xceiv->state = OTG_STATE_A_WAIT_VFALL;
                break;
        default:
-               DBG(1, "HNP: Unhandled mode %s\n", otg_state_string(musb));
+               DBG(1, "HNP: Unhandled mode %s\n",
+                       otg_state_string(musb->xceiv->state));
        }
        musb->ignore_disconnect = 0;
        spin_unlock_irqrestore(&musb->lock, flags);
@@ -393,12 +375,13 @@ void musb_hnp_stop(struct musb *musb)
        void __iomem    *mbase = musb->mregs;
        u8      reg;
 
-       DBG(1, "HNP: stop from %s\n", otg_state_string(musb));
+       DBG(1, "HNP: stop from %s\n", otg_state_string(musb->xceiv->state));
 
        switch (musb->xceiv->state) {
        case OTG_STATE_A_PERIPHERAL:
                musb_g_disconnect(musb);
-               DBG(1, "HNP: back to %s\n", otg_state_string(musb));
+               DBG(1, "HNP: back to %s\n",
+                       otg_state_string(musb->xceiv->state));
                break;
        case OTG_STATE_B_HOST:
                DBG(1, "HNP: Disabling HR\n");
@@ -412,7 +395,7 @@ void musb_hnp_stop(struct musb *musb)
                break;
        default:
                DBG(1, "HNP: Stopping in unknown state %s\n",
-                       otg_state_string(musb));
+                       otg_state_string(musb->xceiv->state));
        }
 
        /*
@@ -451,7 +434,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
         */
        if (int_usb & MUSB_INTR_RESUME) {
                handled = IRQ_HANDLED;
-               DBG(3, "RESUME (%s)\n", otg_state_string(musb));
+               DBG(3, "RESUME (%s)\n", otg_state_string(musb->xceiv->state));
 
                if (devctl & MUSB_DEVCTL_HM) {
 #ifdef CONFIG_USB_MUSB_HDRC_HCD
@@ -492,7 +475,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                        default:
                                WARNING("bogus %s RESUME (%s)\n",
                                        "host",
-                                       otg_state_string(musb));
+                                       otg_state_string(musb->xceiv->state));
                        }
 #endif
                } else {
@@ -526,7 +509,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                        default:
                                WARNING("bogus %s RESUME (%s)\n",
                                        "peripheral",
-                                       otg_state_string(musb));
+                                       otg_state_string(musb->xceiv->state));
                        }
                }
        }
@@ -542,7 +525,8 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                        return IRQ_HANDLED;
                }
 
-               DBG(1, "SESSION_REQUEST (%s)\n", otg_state_string(musb));
+               DBG(1, "SESSION_REQUEST (%s)\n",
+                       otg_state_string(musb->xceiv->state));
 
                /* IRQ arrives from ID pin sense or (later, if VBUS power
                 * is removed) SRP.  responses are time critical:
@@ -607,7 +591,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                }
 
                DBG(1, "VBUS_ERROR in %s (%02x, %s), retry #%d, port1 %08x\n",
-                               otg_state_string(musb),
+                               otg_state_string(musb->xceiv->state),
                                devctl,
                                ({ char *s;
                                switch (devctl & MUSB_DEVCTL_VBUS) {
@@ -633,7 +617,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
 #endif
        if (int_usb & MUSB_INTR_SUSPEND) {
                DBG(1, "SUSPEND (%s) devctl %02x power %02x\n",
-                               otg_state_string(musb), devctl, power);
+                       otg_state_string(musb->xceiv->state), devctl, power);
                handled = IRQ_HANDLED;
 
                switch (musb->xceiv->state) {
@@ -758,13 +742,13 @@ b_host:
                        usb_hcd_resume_root_hub(hcd);
 
                DBG(1, "CONNECT (%s) devctl %02x\n",
-                               otg_state_string(musb), devctl);
+                               otg_state_string(musb->xceiv->state), devctl);
        }
 #endif /* CONFIG_USB_MUSB_HDRC_HCD */
 
        if ((int_usb & MUSB_INTR_DISCONNECT) && !musb->ignore_disconnect) {
                DBG(1, "DISCONNECT (%s) as %s, devctl %02x\n",
-                               otg_state_string(musb),
+                               otg_state_string(musb->xceiv->state),
                                MUSB_MODE(musb), devctl);
                handled = IRQ_HANDLED;
 
@@ -807,7 +791,7 @@ b_host:
 #endif /* GADGET */
                default:
                        WARNING("unhandled DISCONNECT transition (%s)\n",
-                               otg_state_string(musb));
+                               otg_state_string(musb->xceiv->state));
                        break;
                }
        }
@@ -832,7 +816,8 @@ b_host:
                                musb_writeb(musb->mregs, MUSB_DEVCTL, 0);
                        }
                } else if (is_peripheral_capable()) {
-                       DBG(1, "BUS RESET as %s\n", otg_state_string(musb));
+                       DBG(1, "BUS RESET as %s\n",
+                               otg_state_string(musb->xceiv->state));
                        switch (musb->xceiv->state) {
 #ifdef CONFIG_USB_OTG
                        case OTG_STATE_A_SUSPEND:
@@ -846,8 +831,8 @@ b_host:
                        case OTG_STATE_A_WAIT_BCON:     /* OPT TD.4.7-900ms */
                                /* never use invalid T(a_wait_bcon) */
                                DBG(1, "HNP: in %s, %d msec timeout\n",
-                                               otg_state_string(musb),
-                                               TA_WAIT_BCON(musb));
+                                       otg_state_string(musb->xceiv->state),
+                                       TA_WAIT_BCON(musb));
                                mod_timer(&musb->otg_timer, jiffies
                                        + msecs_to_jiffies(TA_WAIT_BCON(musb)));
                                break;
@@ -858,7 +843,7 @@ b_host:
                                break;
                        case OTG_STATE_B_WAIT_ACON:
                                DBG(1, "HNP: RESET (%s), to b_peripheral\n",
-                                       otg_state_string(musb));
+                                       otg_state_string(musb->xceiv->state));
                                musb->xceiv->state = OTG_STATE_B_PERIPHERAL;
                                musb_g_reset(musb);
                                break;
@@ -871,7 +856,7 @@ b_host:
                                break;
                        default:
                                DBG(1, "Unhandled BUS RESET as %s\n",
-                                       otg_state_string(musb));
+                                       otg_state_string(musb->xceiv->state));
                        }
                }
        }
@@ -1713,7 +1698,7 @@ musb_mode_show(struct device *dev, struct device_attribute *attr, char *buf)
        int ret = -EINVAL;
 
        spin_lock_irqsave(&musb->lock, flags);
-       ret = sprintf(buf, "%s\n", otg_state_string(musb));
+       ret = sprintf(buf, "%s\n", otg_state_string(musb->xceiv->state));
        spin_unlock_irqrestore(&musb->lock, flags);
 
        return ret;

diff --git a/drivers/usb/musb/musb_debug.h b/drivers/usb/musb/musb_debug.h
index 94f6973cf8f7c6b808dc8a8525d90f43cfda669b..f958a49a0124dea86783fc8b848d5d899ec1030b 100644 (file)
--- a/drivers/usb/musb/musb_debug.h
+++ b/drivers/usb/musb/musb_debug.h
@@ -54,8 +54,6 @@ static inline int _dbg_level(unsigned l)
        return musb_debug >= l;
 }
 
-extern const char *otg_state_string(struct musb *);
-
 #ifdef CONFIG_DEBUG_FS
 extern int musb_init_debugfs(struct musb *musb);
 extern void musb_exit_debugfs(struct musb *musb);

diff --git a/drivers/usb/musb/musb_gadget.c b/drivers/usb/musb/musb_gadget.c
index 6dfbf9ffd7a63660ef472b6b3a932ecf22fd0341..3d799195c8b4d33398320c272b4556c78b77f5cf 100644 (file)
--- a/drivers/usb/musb/musb_gadget.c
+++ b/drivers/usb/musb/musb_gadget.c
@@ -1556,7 +1556,8 @@ static int musb_gadget_wakeup(struct usb_gadget *gadget)
                status = 0;
                goto done;
        default:
-               DBG(2, "Unhandled wake: %s\n", otg_state_string(musb));
+               DBG(2, "Unhandled wake: %s\n",
+                       otg_state_string(musb->xceiv->state));
                goto done;
        }
 
@@ -2039,7 +2040,7 @@ void musb_g_resume(struct musb *musb)
                break;
        default:
                WARNING("unhandled RESUME transition (%s)\n",
-                               otg_state_string(musb));
+                               otg_state_string(musb->xceiv->state));
        }
 }
 
@@ -2069,7 +2070,7 @@ void musb_g_suspend(struct musb *musb)
                 * A_PERIPHERAL may need care too
                 */
                WARNING("unhandled SUSPEND transition (%s)\n",
-                               otg_state_string(musb));
+                               otg_state_string(musb->xceiv->state));
        }
 }
 
@@ -2104,7 +2105,7 @@ void musb_g_disconnect(struct musb *musb)
        default:
 #ifdef CONFIG_USB_MUSB_OTG
                DBG(2, "Unhandled disconnect %s, setting a_idle\n",
-                       otg_state_string(musb));
+                       otg_state_string(musb->xceiv->state));
                musb->xceiv->state = OTG_STATE_A_IDLE;
                MUSB_HST_MODE(musb);
                break;

diff --git a/drivers/usb/musb/musb_host.c b/drivers/usb/musb/musb_host.c
index 5eef4a8847dbdfaa1f234d554ab1efe9af0a09a8..07b106c7de82cdeb9f4d0d8d798add041a28f2a9 100644 (file)
--- a/drivers/usb/musb/musb_host.c
+++ b/drivers/usb/musb/musb_host.c
@@ -2304,7 +2304,7 @@ static int musb_bus_suspend(struct usb_hcd *hcd)
 
        if (musb->is_active) {
                WARNING("trying to suspend as %s while active\n",
-                               otg_state_string(musb));
+                               otg_state_string(musb->xceiv->state));
                return -EBUSY;
        } else
                return 0;

diff --git a/drivers/usb/musb/musb_virthub.c b/drivers/usb/musb/musb_virthub.c
index 489104a5ae14507f8d2f1010ced652981d0e59c2..bb1247d5fd0493866b6f623caecfc88df93162d7 100644 (file)
--- a/drivers/usb/musb/musb_virthub.c
+++ b/drivers/usb/musb/musb_virthub.c
@@ -98,7 +98,7 @@ static void musb_port_suspend(struct musb *musb, bool do_suspend)
 #endif
                default:
                        DBG(1, "bogus rh suspend? %s\n",
-                               otg_state_string(musb));
+                               otg_state_string(musb->xceiv->state));
                }
        } else if (power & MUSB_POWER_SUSPENDM) {
                power &= ~MUSB_POWER_SUSPENDM;
@@ -208,7 +208,8 @@ void musb_root_disconnect(struct musb *musb)
                musb->xceiv->state = OTG_STATE_B_IDLE;
                break;
        default:
-               DBG(1, "host disconnect (%s)\n", otg_state_string(musb));
+               DBG(1, "host disconnect (%s)\n",
+                       otg_state_string(musb->xceiv->state));
        }
 }
 

diff --git a/drivers/usb/musb/omap2430.c b/drivers/usb/musb/omap2430.c
index 57a27fa954b41fdd7b0fba880fd3c9da2b64b19c..d51b15adc0b0f92869c3dee76de8e6396a473afc 100644 (file)
--- a/drivers/usb/musb/omap2430.c
+++ b/drivers/usb/musb/omap2430.c
@@ -114,7 +114,8 @@ static void omap2430_musb_try_idle(struct musb *musb, unsigned long timeout)
        /* Never idle if active, or when VBUS timeout is not set as host */
        if (musb->is_active || ((musb->a_wait_bcon == 0)
                        && (musb->xceiv->state == OTG_STATE_A_WAIT_BCON))) {
-               DBG(4, "%s active, deleting timer\n", otg_state_string(musb));
+               DBG(4, "%s active, deleting timer\n",
+                       otg_state_string(musb->xceiv->state));
                del_timer(&musb_idle_timer);
                last_timer = jiffies;
                return;
@@ -131,7 +132,7 @@ static void omap2430_musb_try_idle(struct musb *musb, unsigned long timeout)
        last_timer = timeout;
 
        DBG(4, "%s inactive, for idle timer for %lu ms\n",
-               otg_state_string(musb),
+               otg_state_string(musb->xceiv->state),
                (unsigned long)jiffies_to_msecs(timeout - jiffies));
        mod_timer(&musb_idle_timer, timeout);
 }
@@ -195,7 +196,7 @@ static void omap2430_musb_set_vbus(struct musb *musb, int is_on)
 
        DBG(1, "VBUS %s, devctl %02x "
                /* otg %3x conf %08x prcm %08x */ "\n",
-               otg_state_string(musb),
+               otg_state_string(musb->xceiv->state),
                musb_readb(musb->mregs, MUSB_DEVCTL));
 }
 

diff --git a/drivers/usb/musb/tusb6010.c b/drivers/usb/musb/tusb6010.c
index c47aac4a1f98415d19a91c56c8d6deb4ebf9aeff..221feaaded725f3db90a3a2fd2bfeff1d0582bc5 100644 (file)
--- a/drivers/usb/musb/tusb6010.c
+++ b/drivers/usb/musb/tusb6010.c
@@ -422,7 +422,7 @@ static void musb_do_idle(unsigned long _musb)
                        && (musb->idle_timeout == 0
                                || time_after(jiffies, musb->idle_timeout))) {
                        DBG(4, "Nothing connected %s, turning off VBUS\n",
-                                       otg_state_string(musb));
+                                       otg_state_string(musb->xceiv->state));
                }
                /* FALLTHROUGH */
        case OTG_STATE_A_IDLE:
@@ -481,7 +481,8 @@ static void tusb_musb_try_idle(struct musb *musb, unsigned long timeout)
        /* Never idle if active, or when VBUS timeout is not set as host */
        if (musb->is_active || ((musb->a_wait_bcon == 0)
                        && (musb->xceiv->state == OTG_STATE_A_WAIT_BCON))) {
-               DBG(4, "%s active, deleting timer\n", otg_state_string(musb));
+               DBG(4, "%s active, deleting timer\n",
+                       otg_state_string(musb->xceiv->state));
                del_timer(&musb_idle_timer);
                last_timer = jiffies;
                return;
@@ -498,7 +499,7 @@ static void tusb_musb_try_idle(struct musb *musb, unsigned long timeout)
        last_timer = timeout;
 
        DBG(4, "%s inactive, for idle timer for %lu ms\n",
-               otg_state_string(musb),
+               otg_state_string(musb->xceiv->state),
                (unsigned long)jiffies_to_msecs(timeout - jiffies));
        mod_timer(&musb_idle_timer, timeout);
 }
@@ -573,7 +574,7 @@ static void tusb_musb_set_vbus(struct musb *musb, int is_on)
        musb_writeb(musb->mregs, MUSB_DEVCTL, devctl);
 
        DBG(1, "VBUS %s, devctl %02x otg %3x conf %08x prcm %08x\n",
-               otg_state_string(musb),
+               otg_state_string(musb->xceiv->state),
                musb_readb(musb->mregs, MUSB_DEVCTL),
                musb_readl(tbase, TUSB_DEV_OTG_STAT),
                conf, prcm);
@@ -702,13 +703,13 @@ tusb_otg_ints(struct musb *musb, u32 int_src, void __iomem *tbase)
                                musb->is_active = 0;
                        }
                        DBG(2, "vbus change, %s, otg %03x\n",
-                               otg_state_string(musb), otg_stat);
+                               otg_state_string(musb->xceiv->state), otg_stat);
                        idle_timeout = jiffies + (1 * HZ);
                        schedule_work(&musb->irq_work);
 
                } else /* A-dev state machine */ {
                        DBG(2, "vbus change, %s, otg %03x\n",
-                               otg_state_string(musb), otg_stat);
+                               otg_state_string(musb->xceiv->state), otg_stat);
 
                        switch (musb->xceiv->state) {
                        case OTG_STATE_A_IDLE:
@@ -756,7 +757,8 @@ tusb_otg_ints(struct musb *musb, u32 int_src, void __iomem *tbase)
        if (int_src & TUSB_INT_SRC_OTG_TIMEOUT) {
                u8      devctl;
 
-               DBG(4, "%s timer, %03x\n", otg_state_string(musb), otg_stat);
+               DBG(4, "%s timer, %03x\n",
+                       otg_state_string(musb->xceiv->state), otg_stat);
 
                switch (musb->xceiv->state) {
                case OTG_STATE_A_WAIT_VRISE:

diff --git a/include/linux/usb/otg.h b/include/linux/usb/otg.h
index bc84858b3a4df2f542f4344229b7bd4f087b8de1..d87f44f5b04e437c44405c294ef03781e40cb6ca 100644 (file)
--- a/include/linux/usb/otg.h
+++ b/include/linux/usb/otg.h
@@ -168,6 +168,7 @@ otg_shutdown(struct otg_transceiver *otg)
 #ifdef CONFIG_USB_OTG_UTILS
 extern struct otg_transceiver *otg_get_transceiver(void);
 extern void otg_put_transceiver(struct otg_transceiver *);
+extern const char *otg_state_string(enum usb_otg_state state);
 #else
 static inline struct otg_transceiver *otg_get_transceiver(void)
 {
@@ -177,6 +178,11 @@ static inline struct otg_transceiver *otg_get_transceiver(void)
 static inline void otg_put_transceiver(struct otg_transceiver *x)
 {
 }
+
+static inline const char *otg_state_string(enum usb_otg_state state)
+{
+       return NULL;
+}
 #endif
 
 /* Context: can sleep */
@@ -246,6 +252,5 @@ otg_unregister_notifier(struct otg_transceiver *otg, struct notifier_block *nb)
 
 /* for OTG controller drivers (and maybe other stuff) */
 extern int usb_bus_start_enum(struct usb_bus *bus, unsigned port_num);
-extern const char *otg_state_string(enum usb_otg_state state);
 
 #endif /* __LINUX_USB_OTG_H */