1 // SPDX-License-Identifier: GPL-1.0+
3 * OHCI HCD (Host Controller Driver) for USB.
5 * (C) Copyright 1999 Roman Weissgaerber <weissg@vienna.at>
6 * (C) Copyright 2000-2005 David Brownell
7 * (C) Copyright 2002 Hewlett-Packard Company
11 * Modified for OMAP by Tony Lindgren <tony@atomide.com>
12 * Based on the 2.4 OMAP OHCI driver originally done by MontaVista Software Inc.
13 * and on ohci-sa1111.c by Christopher Hoover <ch@hpl.hp.com>
15 * This file is licenced under the GPL.
18 #include <linux/clk.h>
19 #include <linux/dma-mapping.h>
20 #include <linux/err.h>
21 #include <linux/gpio/consumer.h>
23 #include <linux/jiffies.h>
24 #include <linux/kernel.h>
25 #include <linux/module.h>
26 #include <linux/usb/otg.h>
27 #include <linux/platform_device.h>
28 #include <linux/signal.h>
29 #include <linux/usb.h>
30 #include <linux/usb/hcd.h>
35 #include <asm/mach-types.h>
39 #include <mach/hardware.h>
43 #define DRIVER_DESC "OHCI OMAP driver"
45 struct ohci_omap_priv
{
46 struct clk
*usb_host_ck
;
47 struct clk
*usb_dc_ck
;
48 struct gpio_desc
*power
;
49 struct gpio_desc
*overcurrent
;
52 static const char hcd_name
[] = "ohci-omap";
53 static struct hc_driver __read_mostly ohci_omap_hc_driver
;
55 #define hcd_to_ohci_omap_priv(h) \
56 ((struct ohci_omap_priv *)hcd_to_ohci(h)->priv)
58 static void omap_ohci_clock_power(struct ohci_omap_priv
*priv
, int on
)
61 clk_enable(priv
->usb_dc_ck
);
62 clk_enable(priv
->usb_host_ck
);
63 /* guesstimate for T5 == 1x 32K clock + APLL lock time */
66 clk_disable(priv
->usb_host_ck
);
67 clk_disable(priv
->usb_dc_ck
);
72 * Board specific gang-switched transceiver power on/off.
73 * NOTE: OSK supplies power from DC, not battery.
75 static int omap_ohci_transceiver_power(struct ohci_omap_priv
*priv
, int on
)
78 if (machine_is_omap_innovator() && cpu_is_omap1510())
79 __raw_writeb(__raw_readb(INNOVATOR_FPGA_CAM_USB_CONTROL
)
80 | ((1 << 5/*usb1*/) | (1 << 3/*usb2*/)),
81 INNOVATOR_FPGA_CAM_USB_CONTROL
);
83 gpiod_set_value_cansleep(priv
->power
, 0);
85 if (machine_is_omap_innovator() && cpu_is_omap1510())
86 __raw_writeb(__raw_readb(INNOVATOR_FPGA_CAM_USB_CONTROL
)
87 & ~((1 << 5/*usb1*/) | (1 << 3/*usb2*/)),
88 INNOVATOR_FPGA_CAM_USB_CONTROL
);
90 gpiod_set_value_cansleep(priv
->power
, 1);
98 static void start_hnp(struct ohci_hcd
*ohci
)
100 struct usb_hcd
*hcd
= ohci_to_hcd(ohci
);
101 const unsigned port
= hcd
->self
.otg_port
- 1;
105 otg_start_hnp(hcd
->usb_phy
->otg
);
107 local_irq_save(flags
);
108 hcd
->usb_phy
->otg
->state
= OTG_STATE_A_SUSPEND
;
109 writel (RH_PS_PSS
, &ohci
->regs
->roothub
.portstatus
[port
]);
110 l
= omap_readl(OTG_CTRL
);
112 omap_writel(l
, OTG_CTRL
);
113 local_irq_restore(flags
);
118 /*-------------------------------------------------------------------------*/
120 static int ohci_omap_reset(struct usb_hcd
*hcd
)
122 struct ohci_hcd
*ohci
= hcd_to_ohci(hcd
);
123 struct omap_usb_config
*config
= dev_get_platdata(hcd
->self
.controller
);
124 struct ohci_omap_priv
*priv
= hcd_to_ohci_omap_priv(hcd
);
125 int need_transceiver
= (config
->otg
!= 0);
128 dev_dbg(hcd
->self
.controller
, "starting USB Controller\n");
131 hcd
->self
.otg_port
= config
->otg
;
132 /* default/minimum OTG power budget: 8 mA */
133 hcd
->power_budget
= 8;
136 /* boards can use OTG transceivers in non-OTG modes */
137 need_transceiver
= need_transceiver
138 || machine_is_omap_h2() || machine_is_omap_h3();
140 /* XXX OMAP16xx only */
141 if (config
->ocpi_enable
)
142 config
->ocpi_enable();
144 #ifdef CONFIG_USB_OTG
145 if (need_transceiver
) {
146 hcd
->usb_phy
= usb_get_phy(USB_PHY_TYPE_USB2
);
147 if (!IS_ERR_OR_NULL(hcd
->usb_phy
)) {
148 int status
= otg_set_host(hcd
->usb_phy
->otg
,
149 &ohci_to_hcd(ohci
)->self
);
150 dev_dbg(hcd
->self
.controller
, "init %s phy, status %d\n",
151 hcd
->usb_phy
->label
, status
);
153 usb_put_phy(hcd
->usb_phy
);
157 return -EPROBE_DEFER
;
159 hcd
->skip_phy_initialization
= 1;
160 ohci
->start_hnp
= start_hnp
;
164 omap_ohci_clock_power(priv
, 1);
166 if (config
->lb_reset
)
169 ret
= ohci_setup(hcd
);
173 if (config
->otg
|| config
->rwc
) {
174 ohci
->hc_control
= OHCI_CTRL_RWC
;
175 writel(OHCI_CTRL_RWC
, &ohci
->regs
->control
);
178 /* board-specific power switching and overcurrent support */
179 if (machine_is_omap_osk() || machine_is_omap_innovator()) {
180 u32 rh
= roothub_a (ohci
);
182 /* power switching (ganged by default) */
185 /* TPS2045 switch for internal transceiver (port 1) */
186 if (machine_is_omap_osk()) {
187 ohci_to_hcd(ohci
)->power_budget
= 250;
191 /* gpio9 for overcurrent detction */
192 omap_cfg_reg(W8_1610_GPIO9
);
194 /* for paranoia's sake: disable USB.PUEN */
195 omap_cfg_reg(W4_USB_HIGHZ
);
197 ohci_writel(ohci
, rh
, &ohci
->regs
->roothub
.a
);
198 ohci
->flags
&= ~OHCI_QUIRK_HUB_POWER
;
199 } else if (machine_is_nokia770()) {
200 /* We require a self-powered hub, which should have
201 * plenty of power. */
202 ohci_to_hcd(ohci
)->power_budget
= 0;
205 /* FIXME hub_wq hub requests should manage power switching */
206 omap_ohci_transceiver_power(priv
, 1);
208 /* board init will have already handled HMC and mux setup.
209 * any external transceiver should already be initialized
210 * too, so all configured ports use the right signaling now.
216 /*-------------------------------------------------------------------------*/
219 * ohci_hcd_omap_probe - initialize OMAP-based HCDs
220 * @pdev: USB controller to probe
222 * Context: task context, might sleep
224 * Allocates basic resources for this USB host controller, and
225 * then invokes the start() method for the HCD associated with it
226 * through the hotplug entry's driver_data.
228 static int ohci_hcd_omap_probe(struct platform_device
*pdev
)
231 struct usb_hcd
*hcd
= 0;
232 struct ohci_omap_priv
*priv
;
234 if (pdev
->num_resources
!= 2) {
235 dev_err(&pdev
->dev
, "invalid num_resources: %i\n",
236 pdev
->num_resources
);
240 if (pdev
->resource
[0].flags
!= IORESOURCE_MEM
241 || pdev
->resource
[1].flags
!= IORESOURCE_IRQ
) {
242 dev_err(&pdev
->dev
, "invalid resource type\n");
246 hcd
= usb_create_hcd(&ohci_omap_hc_driver
, &pdev
->dev
,
247 dev_name(&pdev
->dev
));
251 hcd
->rsrc_start
= pdev
->resource
[0].start
;
252 hcd
->rsrc_len
= pdev
->resource
[0].end
- pdev
->resource
[0].start
+ 1;
253 priv
= hcd_to_ohci_omap_priv(hcd
);
255 /* Obtain two optional GPIO lines */
256 priv
->power
= devm_gpiod_get_optional(&pdev
->dev
, "power", GPIOD_ASIS
);
257 if (IS_ERR(priv
->power
)) {
258 retval
= PTR_ERR(priv
->power
);
262 gpiod_set_consumer_name(priv
->power
, "OHCI power");
265 * This "overcurrent" GPIO line isn't really used in the code,
266 * but has a designated hardware function.
267 * TODO: implement proper overcurrent handling.
269 priv
->overcurrent
= devm_gpiod_get_optional(&pdev
->dev
, "overcurrent",
271 if (IS_ERR(priv
->overcurrent
)) {
272 retval
= PTR_ERR(priv
->overcurrent
);
275 if (priv
->overcurrent
)
276 gpiod_set_consumer_name(priv
->overcurrent
, "OHCI overcurrent");
278 priv
->usb_host_ck
= clk_get(&pdev
->dev
, "usb_hhc_ck");
279 if (IS_ERR(priv
->usb_host_ck
)) {
280 retval
= PTR_ERR(priv
->usb_host_ck
);
284 if (!cpu_is_omap15xx())
285 priv
->usb_dc_ck
= clk_get(&pdev
->dev
, "usb_dc_ck");
287 priv
->usb_dc_ck
= clk_get(&pdev
->dev
, "lb_ck");
289 if (IS_ERR(priv
->usb_dc_ck
)) {
290 retval
= PTR_ERR(priv
->usb_dc_ck
);
291 goto err_put_host_ck
;
294 if (!request_mem_region(hcd
->rsrc_start
, hcd
->rsrc_len
, hcd_name
)) {
295 dev_dbg(&pdev
->dev
, "request_mem_region failed\n");
300 hcd
->regs
= ioremap(hcd
->rsrc_start
, hcd
->rsrc_len
);
302 dev_err(&pdev
->dev
, "can't ioremap OHCI HCD\n");
307 irq
= platform_get_irq(pdev
, 0);
312 retval
= usb_add_hcd(hcd
, irq
, 0);
316 device_wakeup_enable(hcd
->self
.controller
);
321 release_mem_region(hcd
->rsrc_start
, hcd
->rsrc_len
);
323 clk_put(priv
->usb_dc_ck
);
325 clk_put(priv
->usb_host_ck
);
332 /* may be called with controller, bus, and devices active */
335 * ohci_hcd_omap_remove - shutdown processing for OMAP-based HCDs
336 * @pdev: USB Host Controller being removed
338 * Context: task context, might sleep
340 * Reverses the effect of ohci_hcd_omap_probe(), first invoking
341 * the HCD's stop() method. It is always called from a thread
342 * context, normally "rmmod", "apmd", or something similar.
344 static int ohci_hcd_omap_remove(struct platform_device
*pdev
)
346 struct usb_hcd
*hcd
= platform_get_drvdata(pdev
);
347 struct ohci_omap_priv
*priv
= hcd_to_ohci_omap_priv(hcd
);
349 dev_dbg(hcd
->self
.controller
, "stopping USB Controller\n");
351 omap_ohci_clock_power(priv
, 0);
352 if (!IS_ERR_OR_NULL(hcd
->usb_phy
)) {
353 (void) otg_set_host(hcd
->usb_phy
->otg
, 0);
354 usb_put_phy(hcd
->usb_phy
);
357 release_mem_region(hcd
->rsrc_start
, hcd
->rsrc_len
);
358 clk_put(priv
->usb_dc_ck
);
359 clk_put(priv
->usb_host_ck
);
364 /*-------------------------------------------------------------------------*/
368 static int ohci_omap_suspend(struct platform_device
*pdev
, pm_message_t message
)
370 struct usb_hcd
*hcd
= platform_get_drvdata(pdev
);
371 struct ohci_hcd
*ohci
= hcd_to_ohci(hcd
);
372 struct ohci_omap_priv
*priv
= hcd_to_ohci_omap_priv(hcd
);
373 bool do_wakeup
= device_may_wakeup(&pdev
->dev
);
376 if (time_before(jiffies
, ohci
->next_statechange
))
378 ohci
->next_statechange
= jiffies
;
380 ret
= ohci_suspend(hcd
, do_wakeup
);
384 omap_ohci_clock_power(priv
, 0);
388 static int ohci_omap_resume(struct platform_device
*dev
)
390 struct usb_hcd
*hcd
= platform_get_drvdata(dev
);
391 struct ohci_hcd
*ohci
= hcd_to_ohci(hcd
);
392 struct ohci_omap_priv
*priv
= hcd_to_ohci_omap_priv(hcd
);
394 if (time_before(jiffies
, ohci
->next_statechange
))
396 ohci
->next_statechange
= jiffies
;
398 omap_ohci_clock_power(priv
, 1);
399 ohci_resume(hcd
, false);
405 /*-------------------------------------------------------------------------*/
408 * Driver definition to register with the OMAP bus
410 static struct platform_driver ohci_hcd_omap_driver
= {
411 .probe
= ohci_hcd_omap_probe
,
412 .remove
= ohci_hcd_omap_remove
,
413 .shutdown
= usb_hcd_platform_shutdown
,
415 .suspend
= ohci_omap_suspend
,
416 .resume
= ohci_omap_resume
,
423 static const struct ohci_driver_overrides omap_overrides __initconst
= {
424 .product_desc
= "OMAP OHCI",
425 .reset
= ohci_omap_reset
,
426 .extra_priv_size
= sizeof(struct ohci_omap_priv
),
429 static int __init
ohci_omap_init(void)
434 pr_info("%s: " DRIVER_DESC
"\n", hcd_name
);
436 ohci_init_driver(&ohci_omap_hc_driver
, &omap_overrides
);
437 return platform_driver_register(&ohci_hcd_omap_driver
);
439 module_init(ohci_omap_init
);
441 static void __exit
ohci_omap_cleanup(void)
443 platform_driver_unregister(&ohci_hcd_omap_driver
);
445 module_exit(ohci_omap_cleanup
);
447 MODULE_DESCRIPTION(DRIVER_DESC
);
448 MODULE_ALIAS("platform:ohci");
449 MODULE_LICENSE("GPL");