diff options
Diffstat (limited to 'drivers/usb')
-rw-r--r-- | drivers/usb/musb/am35x.c | 8 | ||||
-rw-r--r-- | drivers/usb/musb/blackfin.c | 6 | ||||
-rw-r--r-- | drivers/usb/musb/da8xx.c | 8 | ||||
-rw-r--r-- | drivers/usb/musb/davinci.c | 4 | ||||
-rw-r--r-- | drivers/usb/musb/musb_core.c | 39 | ||||
-rw-r--r-- | drivers/usb/musb/musb_dsps.c | 8 | ||||
-rw-r--r-- | drivers/usb/musb/musb_gadget.c | 8 | ||||
-rw-r--r-- | drivers/usb/musb/musb_host.c | 2 | ||||
-rw-r--r-- | drivers/usb/musb/musb_virthub.c | 4 | ||||
-rw-r--r-- | drivers/usb/musb/omap2430.c | 6 | ||||
-rw-r--r-- | drivers/usb/musb/tusb6010.c | 14 | ||||
-rw-r--r-- | drivers/usb/otg/fsl_otg.c | 2 | ||||
-rw-r--r-- | drivers/usb/otg/isp1301_omap.c | 6 | ||||
-rw-r--r-- | drivers/usb/otg/otg.c | 4 | ||||
-rw-r--r-- | drivers/usb/otg/otg_fsm.c | 2 |
15 files changed, 61 insertions, 60 deletions
diff --git a/drivers/usb/musb/am35x.c b/drivers/usb/musb/am35x.c index 59eea219034a..2231850c0625 100644 --- a/drivers/usb/musb/am35x.c +++ b/drivers/usb/musb/am35x.c | |||
@@ -149,7 +149,7 @@ static void otg_timer(unsigned long _musb) | |||
149 | */ | 149 | */ |
150 | devctl = musb_readb(mregs, MUSB_DEVCTL); | 150 | devctl = musb_readb(mregs, MUSB_DEVCTL); |
151 | dev_dbg(musb->controller, "Poll devctl %02x (%s)\n", devctl, | 151 | dev_dbg(musb->controller, "Poll devctl %02x (%s)\n", devctl, |
152 | otg_state_string(musb->xceiv->state)); | 152 | usb_otg_state_string(musb->xceiv->state)); |
153 | 153 | ||
154 | spin_lock_irqsave(&musb->lock, flags); | 154 | spin_lock_irqsave(&musb->lock, flags); |
155 | switch (musb->xceiv->state) { | 155 | switch (musb->xceiv->state) { |
@@ -195,7 +195,7 @@ static void am35x_musb_try_idle(struct musb *musb, unsigned long timeout) | |||
195 | if (musb->is_active || (musb->a_wait_bcon == 0 && | 195 | if (musb->is_active || (musb->a_wait_bcon == 0 && |
196 | musb->xceiv->state == OTG_STATE_A_WAIT_BCON)) { | 196 | musb->xceiv->state == OTG_STATE_A_WAIT_BCON)) { |
197 | dev_dbg(musb->controller, "%s active, deleting timer\n", | 197 | dev_dbg(musb->controller, "%s active, deleting timer\n", |
198 | otg_state_string(musb->xceiv->state)); | 198 | usb_otg_state_string(musb->xceiv->state)); |
199 | del_timer(&otg_workaround); | 199 | del_timer(&otg_workaround); |
200 | last_timer = jiffies; | 200 | last_timer = jiffies; |
201 | return; | 201 | return; |
@@ -208,7 +208,7 @@ static void am35x_musb_try_idle(struct musb *musb, unsigned long timeout) | |||
208 | last_timer = timeout; | 208 | last_timer = timeout; |
209 | 209 | ||
210 | dev_dbg(musb->controller, "%s inactive, starting idle timer for %u ms\n", | 210 | dev_dbg(musb->controller, "%s inactive, starting idle timer for %u ms\n", |
211 | otg_state_string(musb->xceiv->state), | 211 | usb_otg_state_string(musb->xceiv->state), |
212 | jiffies_to_msecs(timeout - jiffies)); | 212 | jiffies_to_msecs(timeout - jiffies)); |
213 | mod_timer(&otg_workaround, timeout); | 213 | mod_timer(&otg_workaround, timeout); |
214 | } | 214 | } |
@@ -298,7 +298,7 @@ static irqreturn_t am35x_musb_interrupt(int irq, void *hci) | |||
298 | /* NOTE: this must complete power-on within 100 ms. */ | 298 | /* NOTE: this must complete power-on within 100 ms. */ |
299 | dev_dbg(musb->controller, "VBUS %s (%s)%s, devctl %02x\n", | 299 | dev_dbg(musb->controller, "VBUS %s (%s)%s, devctl %02x\n", |
300 | drvvbus ? "on" : "off", | 300 | drvvbus ? "on" : "off", |
301 | otg_state_string(musb->xceiv->state), | 301 | usb_otg_state_string(musb->xceiv->state), |
302 | err ? " ERROR" : "", | 302 | err ? " ERROR" : "", |
303 | devctl); | 303 | devctl); |
304 | ret = IRQ_HANDLED; | 304 | ret = IRQ_HANDLED; |
diff --git a/drivers/usb/musb/blackfin.c b/drivers/usb/musb/blackfin.c index dbb31b30c7fa..5e63b160db0c 100644 --- a/drivers/usb/musb/blackfin.c +++ b/drivers/usb/musb/blackfin.c | |||
@@ -280,13 +280,13 @@ static void musb_conn_timer_handler(unsigned long _musb) | |||
280 | break; | 280 | break; |
281 | default: | 281 | default: |
282 | dev_dbg(musb->controller, "%s state not handled\n", | 282 | dev_dbg(musb->controller, "%s state not handled\n", |
283 | otg_state_string(musb->xceiv->state)); | 283 | usb_otg_state_string(musb->xceiv->state)); |
284 | break; | 284 | break; |
285 | } | 285 | } |
286 | spin_unlock_irqrestore(&musb->lock, flags); | 286 | spin_unlock_irqrestore(&musb->lock, flags); |
287 | 287 | ||
288 | dev_dbg(musb->controller, "state is %s\n", | 288 | dev_dbg(musb->controller, "state is %s\n", |
289 | otg_state_string(musb->xceiv->state)); | 289 | usb_otg_state_string(musb->xceiv->state)); |
290 | } | 290 | } |
291 | 291 | ||
292 | static void bfin_musb_enable(struct musb *musb) | 292 | static void bfin_musb_enable(struct musb *musb) |
@@ -307,7 +307,7 @@ static void bfin_musb_set_vbus(struct musb *musb, int is_on) | |||
307 | 307 | ||
308 | dev_dbg(musb->controller, "VBUS %s, devctl %02x " | 308 | dev_dbg(musb->controller, "VBUS %s, devctl %02x " |
309 | /* otg %3x conf %08x prcm %08x */ "\n", | 309 | /* otg %3x conf %08x prcm %08x */ "\n", |
310 | otg_state_string(musb->xceiv->state), | 310 | usb_otg_state_string(musb->xceiv->state), |
311 | musb_readb(musb->mregs, MUSB_DEVCTL)); | 311 | musb_readb(musb->mregs, MUSB_DEVCTL)); |
312 | } | 312 | } |
313 | 313 | ||
diff --git a/drivers/usb/musb/da8xx.c b/drivers/usb/musb/da8xx.c index 7c71769d71ff..ea7e591093ee 100644 --- a/drivers/usb/musb/da8xx.c +++ b/drivers/usb/musb/da8xx.c | |||
@@ -198,7 +198,7 @@ static void otg_timer(unsigned long _musb) | |||
198 | */ | 198 | */ |
199 | devctl = musb_readb(mregs, MUSB_DEVCTL); | 199 | devctl = musb_readb(mregs, MUSB_DEVCTL); |
200 | dev_dbg(musb->controller, "Poll devctl %02x (%s)\n", devctl, | 200 | dev_dbg(musb->controller, "Poll devctl %02x (%s)\n", devctl, |
201 | otg_state_string(musb->xceiv->state)); | 201 | usb_otg_state_string(musb->xceiv->state)); |
202 | 202 | ||
203 | spin_lock_irqsave(&musb->lock, flags); | 203 | spin_lock_irqsave(&musb->lock, flags); |
204 | switch (musb->xceiv->state) { | 204 | switch (musb->xceiv->state) { |
@@ -267,7 +267,7 @@ static void da8xx_musb_try_idle(struct musb *musb, unsigned long timeout) | |||
267 | if (musb->is_active || (musb->a_wait_bcon == 0 && | 267 | if (musb->is_active || (musb->a_wait_bcon == 0 && |
268 | musb->xceiv->state == OTG_STATE_A_WAIT_BCON)) { | 268 | musb->xceiv->state == OTG_STATE_A_WAIT_BCON)) { |
269 | dev_dbg(musb->controller, "%s active, deleting timer\n", | 269 | dev_dbg(musb->controller, "%s active, deleting timer\n", |
270 | otg_state_string(musb->xceiv->state)); | 270 | usb_otg_state_string(musb->xceiv->state)); |
271 | del_timer(&otg_workaround); | 271 | del_timer(&otg_workaround); |
272 | last_timer = jiffies; | 272 | last_timer = jiffies; |
273 | return; | 273 | return; |
@@ -280,7 +280,7 @@ static void da8xx_musb_try_idle(struct musb *musb, unsigned long timeout) | |||
280 | last_timer = timeout; | 280 | last_timer = timeout; |
281 | 281 | ||
282 | dev_dbg(musb->controller, "%s inactive, starting idle timer for %u ms\n", | 282 | dev_dbg(musb->controller, "%s inactive, starting idle timer for %u ms\n", |
283 | otg_state_string(musb->xceiv->state), | 283 | usb_otg_state_string(musb->xceiv->state), |
284 | jiffies_to_msecs(timeout - jiffies)); | 284 | jiffies_to_msecs(timeout - jiffies)); |
285 | mod_timer(&otg_workaround, timeout); | 285 | mod_timer(&otg_workaround, timeout); |
286 | } | 286 | } |
@@ -360,7 +360,7 @@ static irqreturn_t da8xx_musb_interrupt(int irq, void *hci) | |||
360 | 360 | ||
361 | dev_dbg(musb->controller, "VBUS %s (%s)%s, devctl %02x\n", | 361 | dev_dbg(musb->controller, "VBUS %s (%s)%s, devctl %02x\n", |
362 | drvvbus ? "on" : "off", | 362 | drvvbus ? "on" : "off", |
363 | otg_state_string(musb->xceiv->state), | 363 | usb_otg_state_string(musb->xceiv->state), |
364 | err ? " ERROR" : "", | 364 | err ? " ERROR" : "", |
365 | devctl); | 365 | devctl); |
366 | ret = IRQ_HANDLED; | 366 | ret = IRQ_HANDLED; |
diff --git a/drivers/usb/musb/davinci.c b/drivers/usb/musb/davinci.c index e040d9103735..bea6cc35471c 100644 --- a/drivers/usb/musb/davinci.c +++ b/drivers/usb/musb/davinci.c | |||
@@ -215,7 +215,7 @@ static void otg_timer(unsigned long _musb) | |||
215 | */ | 215 | */ |
216 | devctl = musb_readb(mregs, MUSB_DEVCTL); | 216 | devctl = musb_readb(mregs, MUSB_DEVCTL); |
217 | dev_dbg(musb->controller, "poll devctl %02x (%s)\n", devctl, | 217 | dev_dbg(musb->controller, "poll devctl %02x (%s)\n", devctl, |
218 | otg_state_string(musb->xceiv->state)); | 218 | usb_otg_state_string(musb->xceiv->state)); |
219 | 219 | ||
220 | spin_lock_irqsave(&musb->lock, flags); | 220 | spin_lock_irqsave(&musb->lock, flags); |
221 | switch (musb->xceiv->state) { | 221 | switch (musb->xceiv->state) { |
@@ -349,7 +349,7 @@ static irqreturn_t davinci_musb_interrupt(int irq, void *__hci) | |||
349 | davinci_musb_source_power(musb, drvvbus, 0); | 349 | davinci_musb_source_power(musb, drvvbus, 0); |
350 | dev_dbg(musb->controller, "VBUS %s (%s)%s, devctl %02x\n", | 350 | dev_dbg(musb->controller, "VBUS %s (%s)%s, devctl %02x\n", |
351 | drvvbus ? "on" : "off", | 351 | drvvbus ? "on" : "off", |
352 | otg_state_string(musb->xceiv->state), | 352 | usb_otg_state_string(musb->xceiv->state), |
353 | err ? " ERROR" : "", | 353 | err ? " ERROR" : "", |
354 | devctl); | 354 | devctl); |
355 | retval = IRQ_HANDLED; | 355 | retval = IRQ_HANDLED; |
diff --git a/drivers/usb/musb/musb_core.c b/drivers/usb/musb/musb_core.c index fad8571ed433..6bd879257e4c 100644 --- a/drivers/usb/musb/musb_core.c +++ b/drivers/usb/musb/musb_core.c | |||
@@ -372,13 +372,13 @@ static void musb_otg_timer_func(unsigned long data) | |||
372 | case OTG_STATE_A_SUSPEND: | 372 | case OTG_STATE_A_SUSPEND: |
373 | case OTG_STATE_A_WAIT_BCON: | 373 | case OTG_STATE_A_WAIT_BCON: |
374 | dev_dbg(musb->controller, "HNP: %s timeout\n", | 374 | dev_dbg(musb->controller, "HNP: %s timeout\n", |
375 | otg_state_string(musb->xceiv->state)); | 375 | usb_otg_state_string(musb->xceiv->state)); |
376 | musb_platform_set_vbus(musb, 0); | 376 | musb_platform_set_vbus(musb, 0); |
377 | musb->xceiv->state = OTG_STATE_A_WAIT_VFALL; | 377 | musb->xceiv->state = OTG_STATE_A_WAIT_VFALL; |
378 | break; | 378 | break; |
379 | default: | 379 | default: |
380 | dev_dbg(musb->controller, "HNP: Unhandled mode %s\n", | 380 | dev_dbg(musb->controller, "HNP: Unhandled mode %s\n", |
381 | otg_state_string(musb->xceiv->state)); | 381 | usb_otg_state_string(musb->xceiv->state)); |
382 | } | 382 | } |
383 | musb->ignore_disconnect = 0; | 383 | musb->ignore_disconnect = 0; |
384 | spin_unlock_irqrestore(&musb->lock, flags); | 384 | spin_unlock_irqrestore(&musb->lock, flags); |
@@ -393,13 +393,14 @@ void musb_hnp_stop(struct musb *musb) | |||
393 | void __iomem *mbase = musb->mregs; | 393 | void __iomem *mbase = musb->mregs; |
394 | u8 reg; | 394 | u8 reg; |
395 | 395 | ||
396 | dev_dbg(musb->controller, "HNP: stop from %s\n", otg_state_string(musb->xceiv->state)); | 396 | dev_dbg(musb->controller, "HNP: stop from %s\n", |
397 | usb_otg_state_string(musb->xceiv->state)); | ||
397 | 398 | ||
398 | switch (musb->xceiv->state) { | 399 | switch (musb->xceiv->state) { |
399 | case OTG_STATE_A_PERIPHERAL: | 400 | case OTG_STATE_A_PERIPHERAL: |
400 | musb_g_disconnect(musb); | 401 | musb_g_disconnect(musb); |
401 | dev_dbg(musb->controller, "HNP: back to %s\n", | 402 | dev_dbg(musb->controller, "HNP: back to %s\n", |
402 | otg_state_string(musb->xceiv->state)); | 403 | usb_otg_state_string(musb->xceiv->state)); |
403 | break; | 404 | break; |
404 | case OTG_STATE_B_HOST: | 405 | case OTG_STATE_B_HOST: |
405 | dev_dbg(musb->controller, "HNP: Disabling HR\n"); | 406 | dev_dbg(musb->controller, "HNP: Disabling HR\n"); |
@@ -413,7 +414,7 @@ void musb_hnp_stop(struct musb *musb) | |||
413 | break; | 414 | break; |
414 | default: | 415 | default: |
415 | dev_dbg(musb->controller, "HNP: Stopping in unknown state %s\n", | 416 | dev_dbg(musb->controller, "HNP: Stopping in unknown state %s\n", |
416 | otg_state_string(musb->xceiv->state)); | 417 | usb_otg_state_string(musb->xceiv->state)); |
417 | } | 418 | } |
418 | 419 | ||
419 | /* | 420 | /* |
@@ -451,7 +452,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb, | |||
451 | */ | 452 | */ |
452 | if (int_usb & MUSB_INTR_RESUME) { | 453 | if (int_usb & MUSB_INTR_RESUME) { |
453 | handled = IRQ_HANDLED; | 454 | handled = IRQ_HANDLED; |
454 | dev_dbg(musb->controller, "RESUME (%s)\n", otg_state_string(musb->xceiv->state)); | 455 | dev_dbg(musb->controller, "RESUME (%s)\n", usb_otg_state_string(musb->xceiv->state)); |
455 | 456 | ||
456 | if (devctl & MUSB_DEVCTL_HM) { | 457 | if (devctl & MUSB_DEVCTL_HM) { |
457 | void __iomem *mbase = musb->mregs; | 458 | void __iomem *mbase = musb->mregs; |
@@ -493,7 +494,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb, | |||
493 | default: | 494 | default: |
494 | WARNING("bogus %s RESUME (%s)\n", | 495 | WARNING("bogus %s RESUME (%s)\n", |
495 | "host", | 496 | "host", |
496 | otg_state_string(musb->xceiv->state)); | 497 | usb_otg_state_string(musb->xceiv->state)); |
497 | } | 498 | } |
498 | } else { | 499 | } else { |
499 | switch (musb->xceiv->state) { | 500 | switch (musb->xceiv->state) { |
@@ -522,7 +523,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb, | |||
522 | default: | 523 | default: |
523 | WARNING("bogus %s RESUME (%s)\n", | 524 | WARNING("bogus %s RESUME (%s)\n", |
524 | "peripheral", | 525 | "peripheral", |
525 | otg_state_string(musb->xceiv->state)); | 526 | usb_otg_state_string(musb->xceiv->state)); |
526 | } | 527 | } |
527 | } | 528 | } |
528 | } | 529 | } |
@@ -538,7 +539,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb, | |||
538 | } | 539 | } |
539 | 540 | ||
540 | dev_dbg(musb->controller, "SESSION_REQUEST (%s)\n", | 541 | dev_dbg(musb->controller, "SESSION_REQUEST (%s)\n", |
541 | otg_state_string(musb->xceiv->state)); | 542 | usb_otg_state_string(musb->xceiv->state)); |
542 | 543 | ||
543 | /* IRQ arrives from ID pin sense or (later, if VBUS power | 544 | /* IRQ arrives from ID pin sense or (later, if VBUS power |
544 | * is removed) SRP. responses are time critical: | 545 | * is removed) SRP. responses are time critical: |
@@ -603,7 +604,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb, | |||
603 | } | 604 | } |
604 | 605 | ||
605 | dev_dbg(musb->controller, "VBUS_ERROR in %s (%02x, %s), retry #%d, port1 %08x\n", | 606 | dev_dbg(musb->controller, "VBUS_ERROR in %s (%02x, %s), retry #%d, port1 %08x\n", |
606 | otg_state_string(musb->xceiv->state), | 607 | usb_otg_state_string(musb->xceiv->state), |
607 | devctl, | 608 | devctl, |
608 | ({ char *s; | 609 | ({ char *s; |
609 | switch (devctl & MUSB_DEVCTL_VBUS) { | 610 | switch (devctl & MUSB_DEVCTL_VBUS) { |
@@ -628,7 +629,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb, | |||
628 | 629 | ||
629 | if (int_usb & MUSB_INTR_SUSPEND) { | 630 | if (int_usb & MUSB_INTR_SUSPEND) { |
630 | dev_dbg(musb->controller, "SUSPEND (%s) devctl %02x\n", | 631 | dev_dbg(musb->controller, "SUSPEND (%s) devctl %02x\n", |
631 | otg_state_string(musb->xceiv->state), devctl); | 632 | usb_otg_state_string(musb->xceiv->state), devctl); |
632 | handled = IRQ_HANDLED; | 633 | handled = IRQ_HANDLED; |
633 | 634 | ||
634 | switch (musb->xceiv->state) { | 635 | switch (musb->xceiv->state) { |
@@ -745,12 +746,12 @@ b_host: | |||
745 | usb_hcd_resume_root_hub(hcd); | 746 | usb_hcd_resume_root_hub(hcd); |
746 | 747 | ||
747 | dev_dbg(musb->controller, "CONNECT (%s) devctl %02x\n", | 748 | dev_dbg(musb->controller, "CONNECT (%s) devctl %02x\n", |
748 | otg_state_string(musb->xceiv->state), devctl); | 749 | usb_otg_state_string(musb->xceiv->state), devctl); |
749 | } | 750 | } |
750 | 751 | ||
751 | if ((int_usb & MUSB_INTR_DISCONNECT) && !musb->ignore_disconnect) { | 752 | if ((int_usb & MUSB_INTR_DISCONNECT) && !musb->ignore_disconnect) { |
752 | dev_dbg(musb->controller, "DISCONNECT (%s) as %s, devctl %02x\n", | 753 | dev_dbg(musb->controller, "DISCONNECT (%s) as %s, devctl %02x\n", |
753 | otg_state_string(musb->xceiv->state), | 754 | usb_otg_state_string(musb->xceiv->state), |
754 | MUSB_MODE(musb), devctl); | 755 | MUSB_MODE(musb), devctl); |
755 | handled = IRQ_HANDLED; | 756 | handled = IRQ_HANDLED; |
756 | 757 | ||
@@ -787,7 +788,7 @@ b_host: | |||
787 | break; | 788 | break; |
788 | default: | 789 | default: |
789 | WARNING("unhandled DISCONNECT transition (%s)\n", | 790 | WARNING("unhandled DISCONNECT transition (%s)\n", |
790 | otg_state_string(musb->xceiv->state)); | 791 | usb_otg_state_string(musb->xceiv->state)); |
791 | break; | 792 | break; |
792 | } | 793 | } |
793 | } | 794 | } |
@@ -813,7 +814,7 @@ b_host: | |||
813 | } | 814 | } |
814 | } else { | 815 | } else { |
815 | dev_dbg(musb->controller, "BUS RESET as %s\n", | 816 | dev_dbg(musb->controller, "BUS RESET as %s\n", |
816 | otg_state_string(musb->xceiv->state)); | 817 | usb_otg_state_string(musb->xceiv->state)); |
817 | switch (musb->xceiv->state) { | 818 | switch (musb->xceiv->state) { |
818 | case OTG_STATE_A_SUSPEND: | 819 | case OTG_STATE_A_SUSPEND: |
819 | /* We need to ignore disconnect on suspend | 820 | /* We need to ignore disconnect on suspend |
@@ -826,7 +827,7 @@ b_host: | |||
826 | case OTG_STATE_A_WAIT_BCON: /* OPT TD.4.7-900ms */ | 827 | case OTG_STATE_A_WAIT_BCON: /* OPT TD.4.7-900ms */ |
827 | /* never use invalid T(a_wait_bcon) */ | 828 | /* never use invalid T(a_wait_bcon) */ |
828 | dev_dbg(musb->controller, "HNP: in %s, %d msec timeout\n", | 829 | dev_dbg(musb->controller, "HNP: in %s, %d msec timeout\n", |
829 | otg_state_string(musb->xceiv->state), | 830 | usb_otg_state_string(musb->xceiv->state), |
830 | TA_WAIT_BCON(musb)); | 831 | TA_WAIT_BCON(musb)); |
831 | mod_timer(&musb->otg_timer, jiffies | 832 | mod_timer(&musb->otg_timer, jiffies |
832 | + msecs_to_jiffies(TA_WAIT_BCON(musb))); | 833 | + msecs_to_jiffies(TA_WAIT_BCON(musb))); |
@@ -838,7 +839,7 @@ b_host: | |||
838 | break; | 839 | break; |
839 | case OTG_STATE_B_WAIT_ACON: | 840 | case OTG_STATE_B_WAIT_ACON: |
840 | dev_dbg(musb->controller, "HNP: RESET (%s), to b_peripheral\n", | 841 | dev_dbg(musb->controller, "HNP: RESET (%s), to b_peripheral\n", |
841 | otg_state_string(musb->xceiv->state)); | 842 | usb_otg_state_string(musb->xceiv->state)); |
842 | musb->xceiv->state = OTG_STATE_B_PERIPHERAL; | 843 | musb->xceiv->state = OTG_STATE_B_PERIPHERAL; |
843 | musb_g_reset(musb); | 844 | musb_g_reset(musb); |
844 | break; | 845 | break; |
@@ -850,7 +851,7 @@ b_host: | |||
850 | break; | 851 | break; |
851 | default: | 852 | default: |
852 | dev_dbg(musb->controller, "Unhandled BUS RESET as %s\n", | 853 | dev_dbg(musb->controller, "Unhandled BUS RESET as %s\n", |
853 | otg_state_string(musb->xceiv->state)); | 854 | usb_otg_state_string(musb->xceiv->state)); |
854 | } | 855 | } |
855 | } | 856 | } |
856 | } | 857 | } |
@@ -1632,7 +1633,7 @@ musb_mode_show(struct device *dev, struct device_attribute *attr, char *buf) | |||
1632 | int ret = -EINVAL; | 1633 | int ret = -EINVAL; |
1633 | 1634 | ||
1634 | spin_lock_irqsave(&musb->lock, flags); | 1635 | spin_lock_irqsave(&musb->lock, flags); |
1635 | ret = sprintf(buf, "%s\n", otg_state_string(musb->xceiv->state)); | 1636 | ret = sprintf(buf, "%s\n", usb_otg_state_string(musb->xceiv->state)); |
1636 | spin_unlock_irqrestore(&musb->lock, flags); | 1637 | spin_unlock_irqrestore(&musb->lock, flags); |
1637 | 1638 | ||
1638 | return ret; | 1639 | return ret; |
diff --git a/drivers/usb/musb/musb_dsps.c b/drivers/usb/musb/musb_dsps.c index 4b4987461adb..1ea553d2b77f 100644 --- a/drivers/usb/musb/musb_dsps.c +++ b/drivers/usb/musb/musb_dsps.c | |||
@@ -225,7 +225,7 @@ static void otg_timer(unsigned long _musb) | |||
225 | */ | 225 | */ |
226 | devctl = dsps_readb(mregs, MUSB_DEVCTL); | 226 | devctl = dsps_readb(mregs, MUSB_DEVCTL); |
227 | dev_dbg(musb->controller, "Poll devctl %02x (%s)\n", devctl, | 227 | dev_dbg(musb->controller, "Poll devctl %02x (%s)\n", devctl, |
228 | otg_state_string(musb->xceiv->state)); | 228 | usb_otg_state_string(musb->xceiv->state)); |
229 | 229 | ||
230 | spin_lock_irqsave(&musb->lock, flags); | 230 | spin_lock_irqsave(&musb->lock, flags); |
231 | switch (musb->xceiv->state) { | 231 | switch (musb->xceiv->state) { |
@@ -274,7 +274,7 @@ static void dsps_musb_try_idle(struct musb *musb, unsigned long timeout) | |||
274 | if (musb->is_active || (musb->a_wait_bcon == 0 && | 274 | if (musb->is_active || (musb->a_wait_bcon == 0 && |
275 | musb->xceiv->state == OTG_STATE_A_WAIT_BCON)) { | 275 | musb->xceiv->state == OTG_STATE_A_WAIT_BCON)) { |
276 | dev_dbg(musb->controller, "%s active, deleting timer\n", | 276 | dev_dbg(musb->controller, "%s active, deleting timer\n", |
277 | otg_state_string(musb->xceiv->state)); | 277 | usb_otg_state_string(musb->xceiv->state)); |
278 | del_timer(&glue->timer[pdev->id]); | 278 | del_timer(&glue->timer[pdev->id]); |
279 | glue->last_timer[pdev->id] = jiffies; | 279 | glue->last_timer[pdev->id] = jiffies; |
280 | return; | 280 | return; |
@@ -289,7 +289,7 @@ static void dsps_musb_try_idle(struct musb *musb, unsigned long timeout) | |||
289 | glue->last_timer[pdev->id] = timeout; | 289 | glue->last_timer[pdev->id] = timeout; |
290 | 290 | ||
291 | dev_dbg(musb->controller, "%s inactive, starting idle timer for %u ms\n", | 291 | dev_dbg(musb->controller, "%s inactive, starting idle timer for %u ms\n", |
292 | otg_state_string(musb->xceiv->state), | 292 | usb_otg_state_string(musb->xceiv->state), |
293 | jiffies_to_msecs(timeout - jiffies)); | 293 | jiffies_to_msecs(timeout - jiffies)); |
294 | mod_timer(&glue->timer[pdev->id], timeout); | 294 | mod_timer(&glue->timer[pdev->id], timeout); |
295 | } | 295 | } |
@@ -378,7 +378,7 @@ static irqreturn_t dsps_interrupt(int irq, void *hci) | |||
378 | /* NOTE: this must complete power-on within 100 ms. */ | 378 | /* NOTE: this must complete power-on within 100 ms. */ |
379 | dev_dbg(musb->controller, "VBUS %s (%s)%s, devctl %02x\n", | 379 | dev_dbg(musb->controller, "VBUS %s (%s)%s, devctl %02x\n", |
380 | drvvbus ? "on" : "off", | 380 | drvvbus ? "on" : "off", |
381 | otg_state_string(musb->xceiv->state), | 381 | usb_otg_state_string(musb->xceiv->state), |
382 | err ? " ERROR" : "", | 382 | err ? " ERROR" : "", |
383 | devctl); | 383 | devctl); |
384 | ret = IRQ_HANDLED; | 384 | ret = IRQ_HANDLED; |
diff --git a/drivers/usb/musb/musb_gadget.c b/drivers/usb/musb/musb_gadget.c index 6101ebf803fd..e8408883ab0d 100644 --- a/drivers/usb/musb/musb_gadget.c +++ b/drivers/usb/musb/musb_gadget.c | |||
@@ -1571,7 +1571,7 @@ static int musb_gadget_wakeup(struct usb_gadget *gadget) | |||
1571 | goto done; | 1571 | goto done; |
1572 | default: | 1572 | default: |
1573 | dev_dbg(musb->controller, "Unhandled wake: %s\n", | 1573 | dev_dbg(musb->controller, "Unhandled wake: %s\n", |
1574 | otg_state_string(musb->xceiv->state)); | 1574 | usb_otg_state_string(musb->xceiv->state)); |
1575 | goto done; | 1575 | goto done; |
1576 | } | 1576 | } |
1577 | 1577 | ||
@@ -1970,7 +1970,7 @@ void musb_g_resume(struct musb *musb) | |||
1970 | break; | 1970 | break; |
1971 | default: | 1971 | default: |
1972 | WARNING("unhandled RESUME transition (%s)\n", | 1972 | WARNING("unhandled RESUME transition (%s)\n", |
1973 | otg_state_string(musb->xceiv->state)); | 1973 | usb_otg_state_string(musb->xceiv->state)); |
1974 | } | 1974 | } |
1975 | } | 1975 | } |
1976 | 1976 | ||
@@ -2000,7 +2000,7 @@ void musb_g_suspend(struct musb *musb) | |||
2000 | * A_PERIPHERAL may need care too | 2000 | * A_PERIPHERAL may need care too |
2001 | */ | 2001 | */ |
2002 | WARNING("unhandled SUSPEND transition (%s)\n", | 2002 | WARNING("unhandled SUSPEND transition (%s)\n", |
2003 | otg_state_string(musb->xceiv->state)); | 2003 | usb_otg_state_string(musb->xceiv->state)); |
2004 | } | 2004 | } |
2005 | } | 2005 | } |
2006 | 2006 | ||
@@ -2034,7 +2034,7 @@ void musb_g_disconnect(struct musb *musb) | |||
2034 | switch (musb->xceiv->state) { | 2034 | switch (musb->xceiv->state) { |
2035 | default: | 2035 | default: |
2036 | dev_dbg(musb->controller, "Unhandled disconnect %s, setting a_idle\n", | 2036 | dev_dbg(musb->controller, "Unhandled disconnect %s, setting a_idle\n", |
2037 | otg_state_string(musb->xceiv->state)); | 2037 | usb_otg_state_string(musb->xceiv->state)); |
2038 | musb->xceiv->state = OTG_STATE_A_IDLE; | 2038 | musb->xceiv->state = OTG_STATE_A_IDLE; |
2039 | MUSB_HST_MODE(musb); | 2039 | MUSB_HST_MODE(musb); |
2040 | break; | 2040 | break; |
diff --git a/drivers/usb/musb/musb_host.c b/drivers/usb/musb/musb_host.c index 1ce1fcf3f3e7..51e9e8a38444 100644 --- a/drivers/usb/musb/musb_host.c +++ b/drivers/usb/musb/musb_host.c | |||
@@ -2453,7 +2453,7 @@ static int musb_bus_suspend(struct usb_hcd *hcd) | |||
2453 | 2453 | ||
2454 | if (musb->is_active) { | 2454 | if (musb->is_active) { |
2455 | WARNING("trying to suspend as %s while active\n", | 2455 | WARNING("trying to suspend as %s while active\n", |
2456 | otg_state_string(musb->xceiv->state)); | 2456 | usb_otg_state_string(musb->xceiv->state)); |
2457 | return -EBUSY; | 2457 | return -EBUSY; |
2458 | } else | 2458 | } else |
2459 | return 0; | 2459 | return 0; |
diff --git a/drivers/usb/musb/musb_virthub.c b/drivers/usb/musb/musb_virthub.c index f70579154ded..ef7d11045f56 100644 --- a/drivers/usb/musb/musb_virthub.c +++ b/drivers/usb/musb/musb_virthub.c | |||
@@ -95,7 +95,7 @@ static void musb_port_suspend(struct musb *musb, bool do_suspend) | |||
95 | break; | 95 | break; |
96 | default: | 96 | default: |
97 | dev_dbg(musb->controller, "bogus rh suspend? %s\n", | 97 | dev_dbg(musb->controller, "bogus rh suspend? %s\n", |
98 | otg_state_string(musb->xceiv->state)); | 98 | usb_otg_state_string(musb->xceiv->state)); |
99 | } | 99 | } |
100 | } else if (power & MUSB_POWER_SUSPENDM) { | 100 | } else if (power & MUSB_POWER_SUSPENDM) { |
101 | power &= ~MUSB_POWER_SUSPENDM; | 101 | power &= ~MUSB_POWER_SUSPENDM; |
@@ -203,7 +203,7 @@ void musb_root_disconnect(struct musb *musb) | |||
203 | break; | 203 | break; |
204 | default: | 204 | default: |
205 | dev_dbg(musb->controller, "host disconnect (%s)\n", | 205 | dev_dbg(musb->controller, "host disconnect (%s)\n", |
206 | otg_state_string(musb->xceiv->state)); | 206 | usb_otg_state_string(musb->xceiv->state)); |
207 | } | 207 | } |
208 | } | 208 | } |
209 | 209 | ||
diff --git a/drivers/usb/musb/omap2430.c b/drivers/usb/musb/omap2430.c index 1a42a458f2c4..8ba9bb2a91a7 100644 --- a/drivers/usb/musb/omap2430.c +++ b/drivers/usb/musb/omap2430.c | |||
@@ -117,7 +117,7 @@ static void omap2430_musb_try_idle(struct musb *musb, unsigned long timeout) | |||
117 | if (musb->is_active || ((musb->a_wait_bcon == 0) | 117 | if (musb->is_active || ((musb->a_wait_bcon == 0) |
118 | && (musb->xceiv->state == OTG_STATE_A_WAIT_BCON))) { | 118 | && (musb->xceiv->state == OTG_STATE_A_WAIT_BCON))) { |
119 | dev_dbg(musb->controller, "%s active, deleting timer\n", | 119 | dev_dbg(musb->controller, "%s active, deleting timer\n", |
120 | otg_state_string(musb->xceiv->state)); | 120 | usb_otg_state_string(musb->xceiv->state)); |
121 | del_timer(&musb_idle_timer); | 121 | del_timer(&musb_idle_timer); |
122 | last_timer = jiffies; | 122 | last_timer = jiffies; |
123 | return; | 123 | return; |
@@ -134,7 +134,7 @@ static void omap2430_musb_try_idle(struct musb *musb, unsigned long timeout) | |||
134 | last_timer = timeout; | 134 | last_timer = timeout; |
135 | 135 | ||
136 | dev_dbg(musb->controller, "%s inactive, for idle timer for %lu ms\n", | 136 | dev_dbg(musb->controller, "%s inactive, for idle timer for %lu ms\n", |
137 | otg_state_string(musb->xceiv->state), | 137 | usb_otg_state_string(musb->xceiv->state), |
138 | (unsigned long)jiffies_to_msecs(timeout - jiffies)); | 138 | (unsigned long)jiffies_to_msecs(timeout - jiffies)); |
139 | mod_timer(&musb_idle_timer, timeout); | 139 | mod_timer(&musb_idle_timer, timeout); |
140 | } | 140 | } |
@@ -200,7 +200,7 @@ static void omap2430_musb_set_vbus(struct musb *musb, int is_on) | |||
200 | 200 | ||
201 | dev_dbg(musb->controller, "VBUS %s, devctl %02x " | 201 | dev_dbg(musb->controller, "VBUS %s, devctl %02x " |
202 | /* otg %3x conf %08x prcm %08x */ "\n", | 202 | /* otg %3x conf %08x prcm %08x */ "\n", |
203 | otg_state_string(musb->xceiv->state), | 203 | usb_otg_state_string(musb->xceiv->state), |
204 | musb_readb(musb->mregs, MUSB_DEVCTL)); | 204 | musb_readb(musb->mregs, MUSB_DEVCTL)); |
205 | } | 205 | } |
206 | 206 | ||
diff --git a/drivers/usb/musb/tusb6010.c b/drivers/usb/musb/tusb6010.c index 464bd23cccda..7369ba33c94f 100644 --- a/drivers/usb/musb/tusb6010.c +++ b/drivers/usb/musb/tusb6010.c | |||
@@ -423,7 +423,7 @@ static void musb_do_idle(unsigned long _musb) | |||
423 | && (musb->idle_timeout == 0 | 423 | && (musb->idle_timeout == 0 |
424 | || time_after(jiffies, musb->idle_timeout))) { | 424 | || time_after(jiffies, musb->idle_timeout))) { |
425 | dev_dbg(musb->controller, "Nothing connected %s, turning off VBUS\n", | 425 | dev_dbg(musb->controller, "Nothing connected %s, turning off VBUS\n", |
426 | otg_state_string(musb->xceiv->state)); | 426 | usb_otg_state_string(musb->xceiv->state)); |
427 | } | 427 | } |
428 | /* FALLTHROUGH */ | 428 | /* FALLTHROUGH */ |
429 | case OTG_STATE_A_IDLE: | 429 | case OTG_STATE_A_IDLE: |
@@ -478,7 +478,7 @@ static void tusb_musb_try_idle(struct musb *musb, unsigned long timeout) | |||
478 | if (musb->is_active || ((musb->a_wait_bcon == 0) | 478 | if (musb->is_active || ((musb->a_wait_bcon == 0) |
479 | && (musb->xceiv->state == OTG_STATE_A_WAIT_BCON))) { | 479 | && (musb->xceiv->state == OTG_STATE_A_WAIT_BCON))) { |
480 | dev_dbg(musb->controller, "%s active, deleting timer\n", | 480 | dev_dbg(musb->controller, "%s active, deleting timer\n", |
481 | otg_state_string(musb->xceiv->state)); | 481 | usb_otg_state_string(musb->xceiv->state)); |
482 | del_timer(&musb_idle_timer); | 482 | del_timer(&musb_idle_timer); |
483 | last_timer = jiffies; | 483 | last_timer = jiffies; |
484 | return; | 484 | return; |
@@ -495,7 +495,7 @@ static void tusb_musb_try_idle(struct musb *musb, unsigned long timeout) | |||
495 | last_timer = timeout; | 495 | last_timer = timeout; |
496 | 496 | ||
497 | dev_dbg(musb->controller, "%s inactive, for idle timer for %lu ms\n", | 497 | dev_dbg(musb->controller, "%s inactive, for idle timer for %lu ms\n", |
498 | otg_state_string(musb->xceiv->state), | 498 | usb_otg_state_string(musb->xceiv->state), |
499 | (unsigned long)jiffies_to_msecs(timeout - jiffies)); | 499 | (unsigned long)jiffies_to_msecs(timeout - jiffies)); |
500 | mod_timer(&musb_idle_timer, timeout); | 500 | mod_timer(&musb_idle_timer, timeout); |
501 | } | 501 | } |
@@ -571,7 +571,7 @@ static void tusb_musb_set_vbus(struct musb *musb, int is_on) | |||
571 | musb_writeb(musb->mregs, MUSB_DEVCTL, devctl); | 571 | musb_writeb(musb->mregs, MUSB_DEVCTL, devctl); |
572 | 572 | ||
573 | dev_dbg(musb->controller, "VBUS %s, devctl %02x otg %3x conf %08x prcm %08x\n", | 573 | dev_dbg(musb->controller, "VBUS %s, devctl %02x otg %3x conf %08x prcm %08x\n", |
574 | otg_state_string(musb->xceiv->state), | 574 | usb_otg_state_string(musb->xceiv->state), |
575 | musb_readb(musb->mregs, MUSB_DEVCTL), | 575 | musb_readb(musb->mregs, MUSB_DEVCTL), |
576 | musb_readl(tbase, TUSB_DEV_OTG_STAT), | 576 | musb_readl(tbase, TUSB_DEV_OTG_STAT), |
577 | conf, prcm); | 577 | conf, prcm); |
@@ -678,13 +678,13 @@ tusb_otg_ints(struct musb *musb, u32 int_src, void __iomem *tbase) | |||
678 | musb->is_active = 0; | 678 | musb->is_active = 0; |
679 | } | 679 | } |
680 | dev_dbg(musb->controller, "vbus change, %s, otg %03x\n", | 680 | dev_dbg(musb->controller, "vbus change, %s, otg %03x\n", |
681 | otg_state_string(musb->xceiv->state), otg_stat); | 681 | usb_otg_state_string(musb->xceiv->state), otg_stat); |
682 | idle_timeout = jiffies + (1 * HZ); | 682 | idle_timeout = jiffies + (1 * HZ); |
683 | schedule_work(&musb->irq_work); | 683 | schedule_work(&musb->irq_work); |
684 | 684 | ||
685 | } else /* A-dev state machine */ { | 685 | } else /* A-dev state machine */ { |
686 | dev_dbg(musb->controller, "vbus change, %s, otg %03x\n", | 686 | dev_dbg(musb->controller, "vbus change, %s, otg %03x\n", |
687 | otg_state_string(musb->xceiv->state), otg_stat); | 687 | usb_otg_state_string(musb->xceiv->state), otg_stat); |
688 | 688 | ||
689 | switch (musb->xceiv->state) { | 689 | switch (musb->xceiv->state) { |
690 | case OTG_STATE_A_IDLE: | 690 | case OTG_STATE_A_IDLE: |
@@ -733,7 +733,7 @@ tusb_otg_ints(struct musb *musb, u32 int_src, void __iomem *tbase) | |||
733 | u8 devctl; | 733 | u8 devctl; |
734 | 734 | ||
735 | dev_dbg(musb->controller, "%s timer, %03x\n", | 735 | dev_dbg(musb->controller, "%s timer, %03x\n", |
736 | otg_state_string(musb->xceiv->state), otg_stat); | 736 | usb_otg_state_string(musb->xceiv->state), otg_stat); |
737 | 737 | ||
738 | switch (musb->xceiv->state) { | 738 | switch (musb->xceiv->state) { |
739 | case OTG_STATE_A_WAIT_VRISE: | 739 | case OTG_STATE_A_WAIT_VRISE: |
diff --git a/drivers/usb/otg/fsl_otg.c b/drivers/usb/otg/fsl_otg.c index 37e8e1578316..72a2a00c2487 100644 --- a/drivers/usb/otg/fsl_otg.c +++ b/drivers/usb/otg/fsl_otg.c | |||
@@ -992,7 +992,7 @@ static int show_fsl_usb2_otg_state(struct device *dev, | |||
992 | /* State */ | 992 | /* State */ |
993 | t = scnprintf(next, size, | 993 | t = scnprintf(next, size, |
994 | "OTG state: %s\n\n", | 994 | "OTG state: %s\n\n", |
995 | otg_state_string(fsl_otg_dev->phy.state)); | 995 | usb_otg_state_string(fsl_otg_dev->phy.state)); |
996 | size -= t; | 996 | size -= t; |
997 | next += t; | 997 | next += t; |
998 | 998 | ||
diff --git a/drivers/usb/otg/isp1301_omap.c b/drivers/usb/otg/isp1301_omap.c index af9cb11626b2..8fe0c3b95261 100644 --- a/drivers/usb/otg/isp1301_omap.c +++ b/drivers/usb/otg/isp1301_omap.c | |||
@@ -236,7 +236,7 @@ isp1301_clear_bits(struct isp1301 *isp, u8 reg, u8 bits) | |||
236 | 236 | ||
237 | static inline const char *state_name(struct isp1301 *isp) | 237 | static inline const char *state_name(struct isp1301 *isp) |
238 | { | 238 | { |
239 | return otg_state_string(isp->phy.state); | 239 | return usb_otg_state_string(isp->phy.state); |
240 | } | 240 | } |
241 | 241 | ||
242 | /*-------------------------------------------------------------------------*/ | 242 | /*-------------------------------------------------------------------------*/ |
@@ -481,7 +481,7 @@ static void check_state(struct isp1301 *isp, const char *tag) | |||
481 | if (isp->phy.state == state && !extra) | 481 | if (isp->phy.state == state && !extra) |
482 | return; | 482 | return; |
483 | pr_debug("otg: %s FSM %s/%02x, %s, %06x\n", tag, | 483 | pr_debug("otg: %s FSM %s/%02x, %s, %06x\n", tag, |
484 | otg_state_string(state), fsm, state_name(isp), | 484 | usb_otg_state_string(state), fsm, state_name(isp), |
485 | omap_readl(OTG_CTRL)); | 485 | omap_readl(OTG_CTRL)); |
486 | } | 486 | } |
487 | 487 | ||
@@ -1077,7 +1077,7 @@ static void isp_update_otg(struct isp1301 *isp, u8 stat) | |||
1077 | 1077 | ||
1078 | if (state != isp->phy.state) | 1078 | if (state != isp->phy.state) |
1079 | pr_debug(" isp, %s -> %s\n", | 1079 | pr_debug(" isp, %s -> %s\n", |
1080 | otg_state_string(state), state_name(isp)); | 1080 | usb_otg_state_string(state), state_name(isp)); |
1081 | 1081 | ||
1082 | #ifdef CONFIG_USB_OTG | 1082 | #ifdef CONFIG_USB_OTG |
1083 | /* update the OTG controller state to match the isp1301; may | 1083 | /* update the OTG controller state to match the isp1301; may |
diff --git a/drivers/usb/otg/otg.c b/drivers/usb/otg/otg.c index 358cfd9bce89..fd9a4b7bebe7 100644 --- a/drivers/usb/otg/otg.c +++ b/drivers/usb/otg/otg.c | |||
@@ -11,7 +11,7 @@ | |||
11 | #include <linux/export.h> | 11 | #include <linux/export.h> |
12 | #include <linux/usb/otg.h> | 12 | #include <linux/usb/otg.h> |
13 | 13 | ||
14 | const char *otg_state_string(enum usb_otg_state state) | 14 | const char *usb_otg_state_string(enum usb_otg_state state) |
15 | { | 15 | { |
16 | switch (state) { | 16 | switch (state) { |
17 | case OTG_STATE_A_IDLE: | 17 | case OTG_STATE_A_IDLE: |
@@ -44,4 +44,4 @@ const char *otg_state_string(enum usb_otg_state state) | |||
44 | return "UNDEFINED"; | 44 | return "UNDEFINED"; |
45 | } | 45 | } |
46 | } | 46 | } |
47 | EXPORT_SYMBOL(otg_state_string); | 47 | EXPORT_SYMBOL(usb_otg_state_string); |
diff --git a/drivers/usb/otg/otg_fsm.c b/drivers/usb/otg/otg_fsm.c index ade131a8ae5e..1f729a15decb 100644 --- a/drivers/usb/otg/otg_fsm.c +++ b/drivers/usb/otg/otg_fsm.c | |||
@@ -119,7 +119,7 @@ int otg_set_state(struct otg_fsm *fsm, enum usb_otg_state new_state) | |||
119 | state_changed = 1; | 119 | state_changed = 1; |
120 | if (fsm->otg->phy->state == new_state) | 120 | if (fsm->otg->phy->state == new_state) |
121 | return 0; | 121 | return 0; |
122 | VDBG("Set state: %s\n", otg_state_string(new_state)); | 122 | VDBG("Set state: %s\n", usb_otg_state_string(new_state)); |
123 | otg_leave_state(fsm, fsm->otg->phy->state); | 123 | otg_leave_state(fsm, fsm->otg->phy->state); |
124 | switch (new_state) { | 124 | switch (new_state) { |
125 | case OTG_STATE_B_IDLE: | 125 | case OTG_STATE_B_IDLE: |