2 * Copyright (C) 2005-2007 by Texas Instruments
3 * Some code has been taken from tusb6010.c
4 * Copyrights for that are attributable to:
5 * Copyright (C) 2006 Nokia Corporation
6 * Tony Lindgren <tony@atomide.com>
8 * This file is part of the Inventra Controller Driver for Linux.
10 * The Inventra Controller Driver for Linux is free software; you
11 * can redistribute it and/or modify it under the terms of the GNU
12 * General Public License version 2 as published by the Free Software
15 * The Inventra Controller Driver for Linux is distributed in
16 * the hope that it will be useful, but WITHOUT ANY WARRANTY;
17 * without even the implied warranty of MERCHANTABILITY or
18 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
19 * License for more details.
21 * You should have received a copy of the GNU General Public License
22 * along with The Inventra Controller Driver for Linux ; if not,
23 * write to the Free Software Foundation, Inc., 59 Temple Place,
24 * Suite 330, Boston, MA 02111-1307 USA
27 #include <linux/module.h>
28 #include <linux/kernel.h>
29 #include <linux/sched.h>
30 #include <linux/init.h>
31 #include <linux/list.h>
33 #include <linux/platform_device.h>
34 #include <linux/dma-mapping.h>
35 #include <linux/pm_runtime.h>
36 #include <linux/err.h>
38 #include "musb_core.h"
41 struct omap2430_glue
{
43 struct platform_device
*musb
;
45 #define glue_to_musb(g) platform_get_drvdata(g->musb)
47 static struct timer_list musb_idle_timer
;
49 static void musb_do_idle(unsigned long _musb
)
51 struct musb
*musb
= (void *)_musb
;
56 spin_lock_irqsave(&musb
->lock
, flags
);
58 switch (musb
->xceiv
->state
) {
59 case OTG_STATE_A_WAIT_BCON
:
61 devctl
= musb_readb(musb
->mregs
, MUSB_DEVCTL
);
62 if (devctl
& MUSB_DEVCTL_BDEVICE
) {
63 musb
->xceiv
->state
= OTG_STATE_B_IDLE
;
66 musb
->xceiv
->state
= OTG_STATE_A_IDLE
;
70 case OTG_STATE_A_SUSPEND
:
71 /* finish RESUME signaling? */
72 if (musb
->port1_status
& MUSB_PORT_STAT_RESUME
) {
73 power
= musb_readb(musb
->mregs
, MUSB_POWER
);
74 power
&= ~MUSB_POWER_RESUME
;
75 dev_dbg(musb
->controller
, "root port resume stopped, power %02x\n", power
);
76 musb_writeb(musb
->mregs
, MUSB_POWER
, power
);
78 musb
->port1_status
&= ~(USB_PORT_STAT_SUSPEND
79 | MUSB_PORT_STAT_RESUME
);
80 musb
->port1_status
|= USB_PORT_STAT_C_SUSPEND
<< 16;
81 usb_hcd_poll_rh_status(musb_to_hcd(musb
));
82 /* NOTE: it might really be A_WAIT_BCON ... */
83 musb
->xceiv
->state
= OTG_STATE_A_HOST
;
86 case OTG_STATE_A_HOST
:
87 devctl
= musb_readb(musb
->mregs
, MUSB_DEVCTL
);
88 if (devctl
& MUSB_DEVCTL_BDEVICE
)
89 musb
->xceiv
->state
= OTG_STATE_B_IDLE
;
91 musb
->xceiv
->state
= OTG_STATE_A_WAIT_BCON
;
95 spin_unlock_irqrestore(&musb
->lock
, flags
);
99 static void omap2430_musb_try_idle(struct musb
*musb
, unsigned long timeout
)
101 unsigned long default_timeout
= jiffies
+ msecs_to_jiffies(3);
102 static unsigned long last_timer
;
105 timeout
= default_timeout
;
107 /* Never idle if active, or when VBUS timeout is not set as host */
108 if (musb
->is_active
|| ((musb
->a_wait_bcon
== 0)
109 && (musb
->xceiv
->state
== OTG_STATE_A_WAIT_BCON
))) {
110 dev_dbg(musb
->controller
, "%s active, deleting timer\n",
111 otg_state_string(musb
->xceiv
->state
));
112 del_timer(&musb_idle_timer
);
113 last_timer
= jiffies
;
117 if (time_after(last_timer
, timeout
)) {
118 if (!timer_pending(&musb_idle_timer
))
119 last_timer
= timeout
;
121 dev_dbg(musb
->controller
, "Longer idle timer already pending, ignoring\n");
125 last_timer
= timeout
;
127 dev_dbg(musb
->controller
, "%s inactive, for idle timer for %lu ms\n",
128 otg_state_string(musb
->xceiv
->state
),
129 (unsigned long)jiffies_to_msecs(timeout
- jiffies
));
130 mod_timer(&musb_idle_timer
, timeout
);
133 static void omap2430_musb_set_vbus(struct musb
*musb
, int is_on
)
135 struct usb_otg
*otg
= musb
->xceiv
->otg
;
137 unsigned long timeout
= jiffies
+ msecs_to_jiffies(1000);
139 /* HDRC controls CPEN, but beware current surges during device
140 * connect. They can trigger transient overcurrent conditions
141 * that must be ignored.
144 devctl
= musb_readb(musb
->mregs
, MUSB_DEVCTL
);
147 if (musb
->xceiv
->state
== OTG_STATE_A_IDLE
) {
148 /* start the session */
149 devctl
|= MUSB_DEVCTL_SESSION
;
150 musb_writeb(musb
->mregs
, MUSB_DEVCTL
, devctl
);
152 * Wait for the musb to set as A device to enable the
155 while (musb_readb(musb
->mregs
, MUSB_DEVCTL
) & 0x80) {
159 if (time_after(jiffies
, timeout
)) {
160 dev_err(musb
->controller
,
161 "configured as A device timeout");
167 if (ret
&& otg
->set_vbus
)
168 otg_set_vbus(otg
, 1);
172 musb
->xceiv
->state
= OTG_STATE_A_WAIT_VRISE
;
173 devctl
|= MUSB_DEVCTL_SESSION
;
179 /* NOTE: we're skipping A_WAIT_VFALL -> A_IDLE and
180 * jumping right to B_IDLE...
184 musb
->xceiv
->state
= OTG_STATE_B_IDLE
;
185 devctl
&= ~MUSB_DEVCTL_SESSION
;
189 musb_writeb(musb
->mregs
, MUSB_DEVCTL
, devctl
);
191 dev_dbg(musb
->controller
, "VBUS %s, devctl %02x "
192 /* otg %3x conf %08x prcm %08x */ "\n",
193 otg_state_string(musb
->xceiv
->state
),
194 musb_readb(musb
->mregs
, MUSB_DEVCTL
));
197 static int omap2430_musb_set_mode(struct musb
*musb
, u8 musb_mode
)
199 u8 devctl
= musb_readb(musb
->mregs
, MUSB_DEVCTL
);
201 devctl
|= MUSB_DEVCTL_SESSION
;
202 musb_writeb(musb
->mregs
, MUSB_DEVCTL
, devctl
);
207 static inline void omap2430_low_level_exit(struct musb
*musb
)
212 l
= musb_readl(musb
->mregs
, OTG_FORCESTDBY
);
213 l
|= ENABLEFORCE
; /* enable MSTANDBY */
214 musb_writel(musb
->mregs
, OTG_FORCESTDBY
, l
);
217 static inline void omap2430_low_level_init(struct musb
*musb
)
221 l
= musb_readl(musb
->mregs
, OTG_FORCESTDBY
);
222 l
&= ~ENABLEFORCE
; /* disable MSTANDBY */
223 musb_writel(musb
->mregs
, OTG_FORCESTDBY
, l
);
226 static int musb_otg_notifications(struct notifier_block
*nb
,
227 unsigned long event
, void *unused
)
229 struct musb
*musb
= container_of(nb
, struct musb
, nb
);
231 musb
->xceiv_event
= event
;
232 schedule_work(&musb
->otg_notifier_work
);
237 static void musb_otg_notifier_work(struct work_struct
*data_notifier_work
)
239 struct musb
*musb
= container_of(data_notifier_work
, struct musb
, otg_notifier_work
);
240 struct device
*dev
= musb
->controller
;
241 struct musb_hdrc_platform_data
*pdata
= dev
->platform_data
;
242 struct omap_musb_board_data
*data
= pdata
->board_data
;
244 switch (musb
->xceiv_event
) {
246 dev_dbg(musb
->controller
, "ID GND\n");
248 if (!is_otg_enabled(musb
) || musb
->gadget_driver
) {
249 pm_runtime_get_sync(musb
->controller
);
250 usb_phy_init(musb
->xceiv
);
251 omap2430_musb_set_vbus(musb
, 1);
256 dev_dbg(musb
->controller
, "VBUS Connect\n");
258 if (musb
->gadget_driver
)
259 pm_runtime_get_sync(musb
->controller
);
260 usb_phy_init(musb
->xceiv
);
264 dev_dbg(musb
->controller
, "VBUS Disconnect\n");
266 if (is_otg_enabled(musb
) || is_peripheral_enabled(musb
))
267 if (musb
->gadget_driver
) {
268 pm_runtime_mark_last_busy(musb
->controller
);
269 pm_runtime_put_autosuspend(musb
->controller
);
272 if (data
->interface_type
== MUSB_INTERFACE_UTMI
) {
273 if (musb
->xceiv
->otg
->set_vbus
)
274 otg_set_vbus(musb
->xceiv
->otg
, 0);
276 usb_phy_shutdown(musb
->xceiv
);
279 dev_dbg(musb
->controller
, "ID float\n");
283 static int omap2430_musb_init(struct musb
*musb
)
287 struct device
*dev
= musb
->controller
;
288 struct musb_hdrc_platform_data
*plat
= dev
->platform_data
;
289 struct omap_musb_board_data
*data
= plat
->board_data
;
291 /* We require some kind of external transceiver, hooked
292 * up through ULPI. TWL4030-family PMICs include one,
293 * which needs a driver, drivers aren't always needed.
295 musb
->xceiv
= usb_get_transceiver();
297 pr_err("HS USB OTG: no transceiver configured\n");
301 INIT_WORK(&musb
->otg_notifier_work
, musb_otg_notifier_work
);
303 status
= pm_runtime_get_sync(dev
);
305 dev_err(dev
, "pm_runtime_get_sync FAILED %d\n", status
);
309 l
= musb_readl(musb
->mregs
, OTG_INTERFSEL
);
311 if (data
->interface_type
== MUSB_INTERFACE_UTMI
) {
312 /* OMAP4 uses Internal PHY GS70 which uses UTMI interface */
313 l
&= ~ULPI_12PIN
; /* Disable ULPI */
314 l
|= UTMI_8BIT
; /* Enable UTMI */
319 musb_writel(musb
->mregs
, OTG_INTERFSEL
, l
);
321 pr_debug("HS USB OTG: revision 0x%x, sysconfig 0x%02x, "
322 "sysstatus 0x%x, intrfsel 0x%x, simenable 0x%x\n",
323 musb_readl(musb
->mregs
, OTG_REVISION
),
324 musb_readl(musb
->mregs
, OTG_SYSCONFIG
),
325 musb_readl(musb
->mregs
, OTG_SYSSTATUS
),
326 musb_readl(musb
->mregs
, OTG_INTERFSEL
),
327 musb_readl(musb
->mregs
, OTG_SIMENABLE
));
329 musb
->nb
.notifier_call
= musb_otg_notifications
;
330 status
= usb_register_notifier(musb
->xceiv
, &musb
->nb
);
333 dev_dbg(musb
->controller
, "notification register failed\n");
335 setup_timer(&musb_idle_timer
, musb_do_idle
, (unsigned long) musb
);
337 pm_runtime_put_noidle(musb
->controller
);
344 static void omap2430_musb_enable(struct musb
*musb
)
347 unsigned long timeout
= jiffies
+ msecs_to_jiffies(1000);
348 struct device
*dev
= musb
->controller
;
349 struct musb_hdrc_platform_data
*pdata
= dev
->platform_data
;
350 struct omap_musb_board_data
*data
= pdata
->board_data
;
352 switch (musb
->xceiv
->last_event
) {
355 usb_phy_init(musb
->xceiv
);
356 if (data
->interface_type
!= MUSB_INTERFACE_UTMI
)
358 devctl
= musb_readb(musb
->mregs
, MUSB_DEVCTL
);
359 /* start the session */
360 devctl
|= MUSB_DEVCTL_SESSION
;
361 musb_writeb(musb
->mregs
, MUSB_DEVCTL
, devctl
);
362 while (musb_readb(musb
->mregs
, MUSB_DEVCTL
) &
363 MUSB_DEVCTL_BDEVICE
) {
366 if (time_after(jiffies
, timeout
)) {
367 dev_err(dev
, "configured as A device timeout");
374 usb_phy_init(musb
->xceiv
);
382 static void omap2430_musb_disable(struct musb
*musb
)
384 if (musb
->xceiv
->last_event
)
385 usb_phy_shutdown(musb
->xceiv
);
388 static int omap2430_musb_exit(struct musb
*musb
)
390 del_timer_sync(&musb_idle_timer
);
391 cancel_work_sync(&musb
->otg_notifier_work
);
393 omap2430_low_level_exit(musb
);
394 usb_put_transceiver(musb
->xceiv
);
399 static const struct musb_platform_ops omap2430_ops
= {
400 .init
= omap2430_musb_init
,
401 .exit
= omap2430_musb_exit
,
403 .set_mode
= omap2430_musb_set_mode
,
404 .try_idle
= omap2430_musb_try_idle
,
406 .set_vbus
= omap2430_musb_set_vbus
,
408 .enable
= omap2430_musb_enable
,
409 .disable
= omap2430_musb_disable
,
412 static u64 omap2430_dmamask
= DMA_BIT_MASK(32);
414 static int __devinit
omap2430_probe(struct platform_device
*pdev
)
416 struct musb_hdrc_platform_data
*pdata
= pdev
->dev
.platform_data
;
417 struct platform_device
*musb
;
418 struct omap2430_glue
*glue
;
421 glue
= kzalloc(sizeof(*glue
), GFP_KERNEL
);
423 dev_err(&pdev
->dev
, "failed to allocate glue context\n");
427 musb
= platform_device_alloc("musb-hdrc", -1);
429 dev_err(&pdev
->dev
, "failed to allocate musb device\n");
433 musb
->dev
.parent
= &pdev
->dev
;
434 musb
->dev
.dma_mask
= &omap2430_dmamask
;
435 musb
->dev
.coherent_dma_mask
= omap2430_dmamask
;
437 glue
->dev
= &pdev
->dev
;
440 pdata
->platform_ops
= &omap2430_ops
;
442 platform_set_drvdata(pdev
, glue
);
444 ret
= platform_device_add_resources(musb
, pdev
->resource
,
445 pdev
->num_resources
);
447 dev_err(&pdev
->dev
, "failed to add resources\n");
451 ret
= platform_device_add_data(musb
, pdata
, sizeof(*pdata
));
453 dev_err(&pdev
->dev
, "failed to add platform_data\n");
457 pm_runtime_enable(&pdev
->dev
);
459 ret
= platform_device_add(musb
);
461 dev_err(&pdev
->dev
, "failed to register musb device\n");
468 platform_device_put(musb
);
477 static int __devexit
omap2430_remove(struct platform_device
*pdev
)
479 struct omap2430_glue
*glue
= platform_get_drvdata(pdev
);
481 platform_device_del(glue
->musb
);
482 platform_device_put(glue
->musb
);
490 static int omap2430_runtime_suspend(struct device
*dev
)
492 struct omap2430_glue
*glue
= dev_get_drvdata(dev
);
493 struct musb
*musb
= glue_to_musb(glue
);
496 musb
->context
.otg_interfsel
= musb_readl(musb
->mregs
,
499 omap2430_low_level_exit(musb
);
500 usb_phy_set_suspend(musb
->xceiv
, 1);
506 static int omap2430_runtime_resume(struct device
*dev
)
508 struct omap2430_glue
*glue
= dev_get_drvdata(dev
);
509 struct musb
*musb
= glue_to_musb(glue
);
512 omap2430_low_level_init(musb
);
513 musb_writel(musb
->mregs
, OTG_INTERFSEL
,
514 musb
->context
.otg_interfsel
);
516 usb_phy_set_suspend(musb
->xceiv
, 0);
522 static struct dev_pm_ops omap2430_pm_ops
= {
523 .runtime_suspend
= omap2430_runtime_suspend
,
524 .runtime_resume
= omap2430_runtime_resume
,
527 #define DEV_PM_OPS (&omap2430_pm_ops)
529 #define DEV_PM_OPS NULL
532 static struct platform_driver omap2430_driver
= {
533 .probe
= omap2430_probe
,
534 .remove
= __devexit_p(omap2430_remove
),
536 .name
= "musb-omap2430",
541 MODULE_DESCRIPTION("OMAP2PLUS MUSB Glue Layer");
542 MODULE_AUTHOR("Felipe Balbi <balbi@ti.com>");
543 MODULE_LICENSE("GPL v2");
545 static int __init
omap2430_init(void)
547 return platform_driver_register(&omap2430_driver
);
549 module_init(omap2430_init
);
551 static void __exit
omap2430_exit(void)
553 platform_driver_unregister(&omap2430_driver
);
555 module_exit(omap2430_exit
);