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>
34 #include <linux/platform_device.h>
35 #include <linux/dma-mapping.h>
36 #include <linux/pm_runtime.h>
37 #include <linux/err.h>
38 #include <linux/delay.h>
39 #include <linux/usb/musb-omap.h>
40 #include <linux/phy/omap_control_phy.h>
41 #include <linux/of_platform.h>
43 #include "musb_core.h"
46 struct omap2430_glue
{
48 struct platform_device
*musb
;
49 enum omap_musb_vbus_id_status status
;
50 struct work_struct omap_musb_mailbox_work
;
51 struct device
*control_otghs
;
53 #define glue_to_musb(g) platform_get_drvdata(g->musb)
55 static struct omap2430_glue
*_glue
;
57 static struct timer_list musb_idle_timer
;
59 static void musb_do_idle(unsigned long _musb
)
61 struct musb
*musb
= (void *)_musb
;
66 spin_lock_irqsave(&musb
->lock
, flags
);
68 switch (musb
->xceiv
->otg
->state
) {
69 case OTG_STATE_A_WAIT_BCON
:
71 devctl
= musb_readb(musb
->mregs
, MUSB_DEVCTL
);
72 if (devctl
& MUSB_DEVCTL_BDEVICE
) {
73 musb
->xceiv
->otg
->state
= OTG_STATE_B_IDLE
;
76 musb
->xceiv
->otg
->state
= OTG_STATE_A_IDLE
;
80 case OTG_STATE_A_SUSPEND
:
81 /* finish RESUME signaling? */
82 if (musb
->port1_status
& MUSB_PORT_STAT_RESUME
) {
83 power
= musb_readb(musb
->mregs
, MUSB_POWER
);
84 power
&= ~MUSB_POWER_RESUME
;
85 dev_dbg(musb
->controller
, "root port resume stopped, power %02x\n", power
);
86 musb_writeb(musb
->mregs
, MUSB_POWER
, power
);
88 musb
->port1_status
&= ~(USB_PORT_STAT_SUSPEND
89 | MUSB_PORT_STAT_RESUME
);
90 musb
->port1_status
|= USB_PORT_STAT_C_SUSPEND
<< 16;
91 usb_hcd_poll_rh_status(musb
->hcd
);
92 /* NOTE: it might really be A_WAIT_BCON ... */
93 musb
->xceiv
->otg
->state
= OTG_STATE_A_HOST
;
96 case OTG_STATE_A_HOST
:
97 devctl
= musb_readb(musb
->mregs
, MUSB_DEVCTL
);
98 if (devctl
& MUSB_DEVCTL_BDEVICE
)
99 musb
->xceiv
->otg
->state
= OTG_STATE_B_IDLE
;
101 musb
->xceiv
->otg
->state
= OTG_STATE_A_WAIT_BCON
;
105 spin_unlock_irqrestore(&musb
->lock
, flags
);
109 static void omap2430_musb_try_idle(struct musb
*musb
, unsigned long timeout
)
111 unsigned long default_timeout
= jiffies
+ msecs_to_jiffies(3);
112 static unsigned long last_timer
;
115 timeout
= default_timeout
;
117 /* Never idle if active, or when VBUS timeout is not set as host */
118 if (musb
->is_active
|| ((musb
->a_wait_bcon
== 0)
119 && (musb
->xceiv
->otg
->state
== OTG_STATE_A_WAIT_BCON
))) {
120 dev_dbg(musb
->controller
, "%s active, deleting timer\n",
121 usb_otg_state_string(musb
->xceiv
->otg
->state
));
122 del_timer(&musb_idle_timer
);
123 last_timer
= jiffies
;
127 if (time_after(last_timer
, timeout
)) {
128 if (!timer_pending(&musb_idle_timer
))
129 last_timer
= timeout
;
131 dev_dbg(musb
->controller
, "Longer idle timer already pending, ignoring\n");
135 last_timer
= timeout
;
137 dev_dbg(musb
->controller
, "%s inactive, for idle timer for %lu ms\n",
138 usb_otg_state_string(musb
->xceiv
->otg
->state
),
139 (unsigned long)jiffies_to_msecs(timeout
- jiffies
));
140 mod_timer(&musb_idle_timer
, timeout
);
143 static void omap2430_musb_set_vbus(struct musb
*musb
, int is_on
)
145 struct usb_otg
*otg
= musb
->xceiv
->otg
;
147 unsigned long timeout
= jiffies
+ msecs_to_jiffies(1000);
148 /* HDRC controls CPEN, but beware current surges during device
149 * connect. They can trigger transient overcurrent conditions
150 * that must be ignored.
153 devctl
= musb_readb(musb
->mregs
, MUSB_DEVCTL
);
156 if (musb
->xceiv
->otg
->state
== OTG_STATE_A_IDLE
) {
158 /* start the session */
159 devctl
|= MUSB_DEVCTL_SESSION
;
160 musb_writeb(musb
->mregs
, MUSB_DEVCTL
, devctl
);
162 * Wait for the musb to set as A device to enable the
165 while (musb_readb(musb
->mregs
, MUSB_DEVCTL
) &
166 MUSB_DEVCTL_BDEVICE
) {
171 if (time_after(jiffies
, timeout
)
173 dev_err(musb
->controller
,
174 "configured as A device timeout");
179 otg_set_vbus(otg
, 1);
183 musb
->xceiv
->otg
->state
= OTG_STATE_A_WAIT_VRISE
;
184 devctl
|= MUSB_DEVCTL_SESSION
;
190 /* NOTE: we're skipping A_WAIT_VFALL -> A_IDLE and
191 * jumping right to B_IDLE...
195 musb
->xceiv
->otg
->state
= OTG_STATE_B_IDLE
;
196 devctl
&= ~MUSB_DEVCTL_SESSION
;
200 musb_writeb(musb
->mregs
, MUSB_DEVCTL
, devctl
);
202 dev_dbg(musb
->controller
, "VBUS %s, devctl %02x "
203 /* otg %3x conf %08x prcm %08x */ "\n",
204 usb_otg_state_string(musb
->xceiv
->otg
->state
),
205 musb_readb(musb
->mregs
, MUSB_DEVCTL
));
208 static int omap2430_musb_set_mode(struct musb
*musb
, u8 musb_mode
)
210 u8 devctl
= musb_readb(musb
->mregs
, MUSB_DEVCTL
);
212 devctl
|= MUSB_DEVCTL_SESSION
;
213 musb_writeb(musb
->mregs
, MUSB_DEVCTL
, devctl
);
218 static inline void omap2430_low_level_exit(struct musb
*musb
)
223 l
= musb_readl(musb
->mregs
, OTG_FORCESTDBY
);
224 l
|= ENABLEFORCE
; /* enable MSTANDBY */
225 musb_writel(musb
->mregs
, OTG_FORCESTDBY
, l
);
228 static inline void omap2430_low_level_init(struct musb
*musb
)
232 l
= musb_readl(musb
->mregs
, OTG_FORCESTDBY
);
233 l
&= ~ENABLEFORCE
; /* disable MSTANDBY */
234 musb_writel(musb
->mregs
, OTG_FORCESTDBY
, l
);
237 void omap_musb_mailbox(enum omap_musb_vbus_id_status status
)
239 struct omap2430_glue
*glue
= _glue
;
242 pr_err("%s: musb core is not yet initialized\n", __func__
);
245 glue
->status
= status
;
247 if (!glue_to_musb(glue
)) {
248 pr_err("%s: musb core is not yet ready\n", __func__
);
252 schedule_work(&glue
->omap_musb_mailbox_work
);
254 EXPORT_SYMBOL_GPL(omap_musb_mailbox
);
256 static void omap_musb_set_mailbox(struct omap2430_glue
*glue
)
258 struct musb
*musb
= glue_to_musb(glue
);
259 struct device
*dev
= musb
->controller
;
260 struct musb_hdrc_platform_data
*pdata
= dev_get_platdata(dev
);
261 struct omap_musb_board_data
*data
= pdata
->board_data
;
262 struct usb_otg
*otg
= musb
->xceiv
->otg
;
264 switch (glue
->status
) {
265 case OMAP_MUSB_ID_GROUND
:
266 dev_dbg(dev
, "ID GND\n");
268 otg
->default_a
= true;
269 musb
->xceiv
->otg
->state
= OTG_STATE_A_IDLE
;
270 musb
->xceiv
->last_event
= USB_EVENT_ID
;
271 if (musb
->gadget_driver
) {
272 pm_runtime_get_sync(dev
);
273 omap_control_usb_set_mode(glue
->control_otghs
,
275 omap2430_musb_set_vbus(musb
, 1);
279 case OMAP_MUSB_VBUS_VALID
:
280 dev_dbg(dev
, "VBUS Connect\n");
282 otg
->default_a
= false;
283 musb
->xceiv
->otg
->state
= OTG_STATE_B_IDLE
;
284 musb
->xceiv
->last_event
= USB_EVENT_VBUS
;
285 if (musb
->gadget_driver
)
286 pm_runtime_get_sync(dev
);
287 omap_control_usb_set_mode(glue
->control_otghs
, USB_MODE_DEVICE
);
290 case OMAP_MUSB_ID_FLOAT
:
291 case OMAP_MUSB_VBUS_OFF
:
292 dev_dbg(dev
, "VBUS Disconnect\n");
294 musb
->xceiv
->last_event
= USB_EVENT_NONE
;
295 if (musb
->gadget_driver
) {
296 omap2430_musb_set_vbus(musb
, 0);
297 pm_runtime_mark_last_busy(dev
);
298 pm_runtime_put_autosuspend(dev
);
301 if (data
->interface_type
== MUSB_INTERFACE_UTMI
)
302 otg_set_vbus(musb
->xceiv
->otg
, 0);
304 omap_control_usb_set_mode(glue
->control_otghs
,
305 USB_MODE_DISCONNECT
);
308 dev_dbg(dev
, "ID float\n");
311 atomic_notifier_call_chain(&musb
->xceiv
->notifier
,
312 musb
->xceiv
->last_event
, NULL
);
316 static void omap_musb_mailbox_work(struct work_struct
*mailbox_work
)
318 struct omap2430_glue
*glue
= container_of(mailbox_work
,
319 struct omap2430_glue
, omap_musb_mailbox_work
);
320 struct musb
*musb
= glue_to_musb(glue
);
321 struct device
*dev
= musb
->controller
;
323 pm_runtime_get_sync(dev
);
324 omap_musb_set_mailbox(glue
);
325 pm_runtime_mark_last_busy(dev
);
326 pm_runtime_put_autosuspend(dev
);
329 static irqreturn_t
omap2430_musb_interrupt(int irq
, void *__hci
)
332 irqreturn_t retval
= IRQ_NONE
;
333 struct musb
*musb
= __hci
;
335 spin_lock_irqsave(&musb
->lock
, flags
);
337 musb
->int_usb
= musb_readb(musb
->mregs
, MUSB_INTRUSB
);
338 musb
->int_tx
= musb_readw(musb
->mregs
, MUSB_INTRTX
);
339 musb
->int_rx
= musb_readw(musb
->mregs
, MUSB_INTRRX
);
341 if (musb
->int_usb
|| musb
->int_tx
|| musb
->int_rx
)
342 retval
= musb_interrupt(musb
);
344 spin_unlock_irqrestore(&musb
->lock
, flags
);
349 static int omap2430_musb_init(struct musb
*musb
)
353 struct device
*dev
= musb
->controller
;
354 struct omap2430_glue
*glue
= dev_get_drvdata(dev
->parent
);
355 struct musb_hdrc_platform_data
*plat
= dev_get_platdata(dev
);
356 struct omap_musb_board_data
*data
= plat
->board_data
;
358 /* We require some kind of external transceiver, hooked
359 * up through ULPI. TWL4030-family PMICs include one,
360 * which needs a driver, drivers aren't always needed.
362 if (dev
->parent
->of_node
) {
363 musb
->phy
= devm_phy_get(dev
->parent
, "usb2-phy");
365 /* We can't totally remove musb->xceiv as of now because
366 * musb core uses xceiv.state and xceiv.otg. Once we have
367 * a separate state machine to handle otg, these can be moved
368 * out of xceiv and then we can start using the generic PHY
371 musb
->xceiv
= devm_usb_get_phy_by_phandle(dev
->parent
,
374 musb
->xceiv
= devm_usb_get_phy_dev(dev
, 0);
375 musb
->phy
= devm_phy_get(dev
, "usb");
378 if (IS_ERR(musb
->xceiv
)) {
379 status
= PTR_ERR(musb
->xceiv
);
381 if (status
== -ENXIO
)
384 pr_err("HS USB OTG: no transceiver configured\n");
385 return -EPROBE_DEFER
;
388 if (IS_ERR(musb
->phy
)) {
389 pr_err("HS USB OTG: no PHY configured\n");
390 return PTR_ERR(musb
->phy
);
392 musb
->isr
= omap2430_musb_interrupt
;
394 status
= pm_runtime_get_sync(dev
);
396 dev_err(dev
, "pm_runtime_get_sync FAILED %d\n", status
);
400 l
= musb_readl(musb
->mregs
, OTG_INTERFSEL
);
402 if (data
->interface_type
== MUSB_INTERFACE_UTMI
) {
403 /* OMAP4 uses Internal PHY GS70 which uses UTMI interface */
404 l
&= ~ULPI_12PIN
; /* Disable ULPI */
405 l
|= UTMI_8BIT
; /* Enable UTMI */
410 musb_writel(musb
->mregs
, OTG_INTERFSEL
, l
);
412 pr_debug("HS USB OTG: revision 0x%x, sysconfig 0x%02x, "
413 "sysstatus 0x%x, intrfsel 0x%x, simenable 0x%x\n",
414 musb_readl(musb
->mregs
, OTG_REVISION
),
415 musb_readl(musb
->mregs
, OTG_SYSCONFIG
),
416 musb_readl(musb
->mregs
, OTG_SYSSTATUS
),
417 musb_readl(musb
->mregs
, OTG_INTERFSEL
),
418 musb_readl(musb
->mregs
, OTG_SIMENABLE
));
420 setup_timer(&musb_idle_timer
, musb_do_idle
, (unsigned long) musb
);
422 if (glue
->status
!= OMAP_MUSB_UNKNOWN
)
423 omap_musb_set_mailbox(glue
);
426 phy_power_on(musb
->phy
);
428 pm_runtime_put_noidle(musb
->controller
);
435 static void omap2430_musb_enable(struct musb
*musb
)
438 unsigned long timeout
= jiffies
+ msecs_to_jiffies(1000);
439 struct device
*dev
= musb
->controller
;
440 struct omap2430_glue
*glue
= dev_get_drvdata(dev
->parent
);
441 struct musb_hdrc_platform_data
*pdata
= dev_get_platdata(dev
);
442 struct omap_musb_board_data
*data
= pdata
->board_data
;
444 switch (glue
->status
) {
446 case OMAP_MUSB_ID_GROUND
:
447 omap_control_usb_set_mode(glue
->control_otghs
, USB_MODE_HOST
);
448 if (data
->interface_type
!= MUSB_INTERFACE_UTMI
)
450 devctl
= musb_readb(musb
->mregs
, MUSB_DEVCTL
);
451 /* start the session */
452 devctl
|= MUSB_DEVCTL_SESSION
;
453 musb_writeb(musb
->mregs
, MUSB_DEVCTL
, devctl
);
454 while (musb_readb(musb
->mregs
, MUSB_DEVCTL
) &
455 MUSB_DEVCTL_BDEVICE
) {
458 if (time_after(jiffies
, timeout
)) {
459 dev_err(dev
, "configured as A device timeout");
465 case OMAP_MUSB_VBUS_VALID
:
466 omap_control_usb_set_mode(glue
->control_otghs
, USB_MODE_DEVICE
);
474 static void omap2430_musb_disable(struct musb
*musb
)
476 struct device
*dev
= musb
->controller
;
477 struct omap2430_glue
*glue
= dev_get_drvdata(dev
->parent
);
479 if (glue
->status
!= OMAP_MUSB_UNKNOWN
)
480 omap_control_usb_set_mode(glue
->control_otghs
,
481 USB_MODE_DISCONNECT
);
484 static int omap2430_musb_exit(struct musb
*musb
)
486 del_timer_sync(&musb_idle_timer
);
488 omap2430_low_level_exit(musb
);
489 phy_power_off(musb
->phy
);
495 static const struct musb_platform_ops omap2430_ops
= {
496 .init
= omap2430_musb_init
,
497 .exit
= omap2430_musb_exit
,
499 .set_mode
= omap2430_musb_set_mode
,
500 .try_idle
= omap2430_musb_try_idle
,
502 .set_vbus
= omap2430_musb_set_vbus
,
504 .enable
= omap2430_musb_enable
,
505 .disable
= omap2430_musb_disable
,
508 static u64 omap2430_dmamask
= DMA_BIT_MASK(32);
510 static int omap2430_probe(struct platform_device
*pdev
)
512 struct resource musb_resources
[3];
513 struct musb_hdrc_platform_data
*pdata
= dev_get_platdata(&pdev
->dev
);
514 struct omap_musb_board_data
*data
;
515 struct platform_device
*musb
;
516 struct omap2430_glue
*glue
;
517 struct device_node
*np
= pdev
->dev
.of_node
;
518 struct musb_hdrc_config
*config
;
521 glue
= devm_kzalloc(&pdev
->dev
, sizeof(*glue
), GFP_KERNEL
);
525 musb
= platform_device_alloc("musb-hdrc", PLATFORM_DEVID_AUTO
);
527 dev_err(&pdev
->dev
, "failed to allocate musb device\n");
531 musb
->dev
.parent
= &pdev
->dev
;
532 musb
->dev
.dma_mask
= &omap2430_dmamask
;
533 musb
->dev
.coherent_dma_mask
= omap2430_dmamask
;
535 glue
->dev
= &pdev
->dev
;
537 glue
->status
= OMAP_MUSB_UNKNOWN
;
538 glue
->control_otghs
= ERR_PTR(-ENODEV
);
541 struct device_node
*control_node
;
542 struct platform_device
*control_pdev
;
544 pdata
= devm_kzalloc(&pdev
->dev
, sizeof(*pdata
), GFP_KERNEL
);
548 data
= devm_kzalloc(&pdev
->dev
, sizeof(*data
), GFP_KERNEL
);
552 config
= devm_kzalloc(&pdev
->dev
, sizeof(*config
), GFP_KERNEL
);
556 of_property_read_u32(np
, "mode", (u32
*)&pdata
->mode
);
557 of_property_read_u32(np
, "interface-type",
558 (u32
*)&data
->interface_type
);
559 of_property_read_u32(np
, "num-eps", (u32
*)&config
->num_eps
);
560 of_property_read_u32(np
, "ram-bits", (u32
*)&config
->ram_bits
);
561 of_property_read_u32(np
, "power", (u32
*)&pdata
->power
);
562 config
->multipoint
= of_property_read_bool(np
, "multipoint");
564 pdata
->board_data
= data
;
565 pdata
->config
= config
;
567 control_node
= of_parse_phandle(np
, "ctrl-module", 0);
569 control_pdev
= of_find_device_by_node(control_node
);
571 dev_err(&pdev
->dev
, "Failed to get control device\n");
575 glue
->control_otghs
= &control_pdev
->dev
;
578 pdata
->platform_ops
= &omap2430_ops
;
580 platform_set_drvdata(pdev
, glue
);
583 * REVISIT if we ever have two instances of the wrapper, we will be
588 INIT_WORK(&glue
->omap_musb_mailbox_work
, omap_musb_mailbox_work
);
590 memset(musb_resources
, 0x00, sizeof(*musb_resources
) *
591 ARRAY_SIZE(musb_resources
));
593 musb_resources
[0].name
= pdev
->resource
[0].name
;
594 musb_resources
[0].start
= pdev
->resource
[0].start
;
595 musb_resources
[0].end
= pdev
->resource
[0].end
;
596 musb_resources
[0].flags
= pdev
->resource
[0].flags
;
598 musb_resources
[1].name
= pdev
->resource
[1].name
;
599 musb_resources
[1].start
= pdev
->resource
[1].start
;
600 musb_resources
[1].end
= pdev
->resource
[1].end
;
601 musb_resources
[1].flags
= pdev
->resource
[1].flags
;
603 musb_resources
[2].name
= pdev
->resource
[2].name
;
604 musb_resources
[2].start
= pdev
->resource
[2].start
;
605 musb_resources
[2].end
= pdev
->resource
[2].end
;
606 musb_resources
[2].flags
= pdev
->resource
[2].flags
;
608 ret
= platform_device_add_resources(musb
, musb_resources
,
609 ARRAY_SIZE(musb_resources
));
611 dev_err(&pdev
->dev
, "failed to add resources\n");
615 ret
= platform_device_add_data(musb
, pdata
, sizeof(*pdata
));
617 dev_err(&pdev
->dev
, "failed to add platform_data\n");
621 pm_runtime_enable(&pdev
->dev
);
623 ret
= platform_device_add(musb
);
625 dev_err(&pdev
->dev
, "failed to register musb device\n");
632 platform_device_put(musb
);
638 static int omap2430_remove(struct platform_device
*pdev
)
640 struct omap2430_glue
*glue
= platform_get_drvdata(pdev
);
642 cancel_work_sync(&glue
->omap_musb_mailbox_work
);
643 platform_device_unregister(glue
->musb
);
650 static int omap2430_runtime_suspend(struct device
*dev
)
652 struct omap2430_glue
*glue
= dev_get_drvdata(dev
);
653 struct musb
*musb
= glue_to_musb(glue
);
656 musb
->context
.otg_interfsel
= musb_readl(musb
->mregs
,
659 omap2430_low_level_exit(musb
);
665 static int omap2430_runtime_resume(struct device
*dev
)
667 struct omap2430_glue
*glue
= dev_get_drvdata(dev
);
668 struct musb
*musb
= glue_to_musb(glue
);
671 omap2430_low_level_init(musb
);
672 musb_writel(musb
->mregs
, OTG_INTERFSEL
,
673 musb
->context
.otg_interfsel
);
679 static struct dev_pm_ops omap2430_pm_ops
= {
680 .runtime_suspend
= omap2430_runtime_suspend
,
681 .runtime_resume
= omap2430_runtime_resume
,
684 #define DEV_PM_OPS (&omap2430_pm_ops)
686 #define DEV_PM_OPS NULL
690 static const struct of_device_id omap2430_id_table
[] = {
692 .compatible
= "ti,omap4-musb"
695 .compatible
= "ti,omap3-musb"
699 MODULE_DEVICE_TABLE(of
, omap2430_id_table
);
702 static struct platform_driver omap2430_driver
= {
703 .probe
= omap2430_probe
,
704 .remove
= omap2430_remove
,
706 .name
= "musb-omap2430",
708 .of_match_table
= of_match_ptr(omap2430_id_table
),
712 MODULE_DESCRIPTION("OMAP2PLUS MUSB Glue Layer");
713 MODULE_AUTHOR("Felipe Balbi <balbi@ti.com>");
714 MODULE_LICENSE("GPL v2");
716 static int __init
omap2430_init(void)
718 return platform_driver_register(&omap2430_driver
);
720 subsys_initcall(omap2430_init
);
722 static void __exit
omap2430_exit(void)
724 platform_driver_unregister(&omap2430_driver
);
726 module_exit(omap2430_exit
);