2 * Generic platform ohci driver
4 * Copyright 2007 Michael Buesch <m@bues.ch>
5 * Copyright 2011-2012 Hauke Mehrtens <hauke@hauke-m.de>
6 * Copyright 2014 Hans de Goede <hdegoede@redhat.com>
8 * Derived from the OCHI-SSB driver
9 * Derived from the OHCI-PCI driver
10 * Copyright 1999 Roman Weissgaerber
11 * Copyright 2000-2002 David Brownell
12 * Copyright 1999 Linus Torvalds
13 * Copyright 1999 Gregory P. Smith
15 * Licensed under the GNU/GPL. See COPYING for details.
18 #include <linux/clk.h>
19 #include <linux/dma-mapping.h>
20 #include <linux/hrtimer.h>
22 #include <linux/kernel.h>
23 #include <linux/module.h>
24 #include <linux/err.h>
25 #include <linux/phy/phy.h>
26 #include <linux/platform_device.h>
27 #include <linux/reset.h>
28 #include <linux/usb/ohci_pdriver.h>
29 #include <linux/usb.h>
30 #include <linux/usb/hcd.h>
34 #define DRIVER_DESC "OHCI generic platform driver"
35 #define OHCI_MAX_CLKS 3
36 #define hcd_to_ohci_priv(h) ((struct ohci_platform_priv *)hcd_to_ohci(h)->priv)
38 struct ohci_platform_priv
{
39 struct clk
*clks
[OHCI_MAX_CLKS
];
40 struct reset_control
*rst
;
44 static const char hcd_name
[] = "ohci-platform";
46 static int ohci_platform_reset(struct usb_hcd
*hcd
)
48 struct platform_device
*pdev
= to_platform_device(hcd
->self
.controller
);
49 struct usb_ohci_pdata
*pdata
= dev_get_platdata(&pdev
->dev
);
50 struct ohci_hcd
*ohci
= hcd_to_ohci(hcd
);
52 if (pdata
->no_big_frame_no
)
53 ohci
->flags
|= OHCI_QUIRK_FRAME_NO
;
55 ohci
->num_ports
= pdata
->num_ports
;
57 return ohci_setup(hcd
);
60 static int ohci_platform_power_on(struct platform_device
*dev
)
62 struct usb_hcd
*hcd
= platform_get_drvdata(dev
);
63 struct ohci_platform_priv
*priv
= hcd_to_ohci_priv(hcd
);
66 for (clk
= 0; clk
< OHCI_MAX_CLKS
&& priv
->clks
[clk
]; clk
++) {
67 ret
= clk_prepare_enable(priv
->clks
[clk
]);
69 goto err_disable_clks
;
73 ret
= phy_init(priv
->phy
);
75 goto err_disable_clks
;
77 ret
= phy_power_on(priv
->phy
);
88 clk_disable_unprepare(priv
->clks
[clk
]);
93 static void ohci_platform_power_off(struct platform_device
*dev
)
95 struct usb_hcd
*hcd
= platform_get_drvdata(dev
);
96 struct ohci_platform_priv
*priv
= hcd_to_ohci_priv(hcd
);
100 phy_power_off(priv
->phy
);
104 for (clk
= OHCI_MAX_CLKS
- 1; clk
>= 0; clk
--)
106 clk_disable_unprepare(priv
->clks
[clk
]);
109 static struct hc_driver __read_mostly ohci_platform_hc_driver
;
111 static const struct ohci_driver_overrides platform_overrides __initconst
= {
112 .product_desc
= "Generic Platform OHCI controller",
113 .reset
= ohci_platform_reset
,
114 .extra_priv_size
= sizeof(struct ohci_platform_priv
),
117 static struct usb_ohci_pdata ohci_platform_defaults
= {
118 .power_on
= ohci_platform_power_on
,
119 .power_suspend
= ohci_platform_power_off
,
120 .power_off
= ohci_platform_power_off
,
123 static int ohci_platform_probe(struct platform_device
*dev
)
126 struct resource
*res_mem
;
127 struct usb_ohci_pdata
*pdata
= dev_get_platdata(&dev
->dev
);
128 struct ohci_platform_priv
*priv
;
129 struct ohci_hcd
*ohci
;
130 int err
, irq
, clk
= 0;
136 * Use reasonable defaults so platforms don't have to provide these
137 * with DT probing on ARM.
140 pdata
= &ohci_platform_defaults
;
142 err
= dma_coerce_mask_and_coherent(&dev
->dev
, DMA_BIT_MASK(32));
146 irq
= platform_get_irq(dev
, 0);
148 dev_err(&dev
->dev
, "no irq provided");
152 res_mem
= platform_get_resource(dev
, IORESOURCE_MEM
, 0);
154 dev_err(&dev
->dev
, "no memory resource provided");
158 hcd
= usb_create_hcd(&ohci_platform_hc_driver
, &dev
->dev
,
159 dev_name(&dev
->dev
));
163 platform_set_drvdata(dev
, hcd
);
164 dev
->dev
.platform_data
= pdata
;
165 priv
= hcd_to_ohci_priv(hcd
);
166 ohci
= hcd_to_ohci(hcd
);
168 if (pdata
== &ohci_platform_defaults
&& dev
->dev
.of_node
) {
169 if (of_property_read_bool(dev
->dev
.of_node
, "big-endian-regs"))
170 ohci
->flags
|= OHCI_QUIRK_BE_MMIO
;
172 if (of_property_read_bool(dev
->dev
.of_node
, "big-endian-desc"))
173 ohci
->flags
|= OHCI_QUIRK_BE_DESC
;
175 if (of_property_read_bool(dev
->dev
.of_node
, "big-endian"))
176 ohci
->flags
|= OHCI_QUIRK_BE_MMIO
| OHCI_QUIRK_BE_DESC
;
178 priv
->phy
= devm_phy_get(&dev
->dev
, "usb");
179 if (IS_ERR(priv
->phy
)) {
180 err
= PTR_ERR(priv
->phy
);
181 if (err
== -EPROBE_DEFER
)
186 for (clk
= 0; clk
< OHCI_MAX_CLKS
; clk
++) {
187 priv
->clks
[clk
] = of_clk_get(dev
->dev
.of_node
, clk
);
188 if (IS_ERR(priv
->clks
[clk
])) {
189 err
= PTR_ERR(priv
->clks
[clk
]);
190 if (err
== -EPROBE_DEFER
)
192 priv
->clks
[clk
] = NULL
;
199 priv
->rst
= devm_reset_control_get_optional(&dev
->dev
, NULL
);
200 if (IS_ERR(priv
->rst
)) {
201 err
= PTR_ERR(priv
->rst
);
202 if (err
== -EPROBE_DEFER
)
206 err
= reset_control_deassert(priv
->rst
);
211 if (pdata
->big_endian_desc
)
212 ohci
->flags
|= OHCI_QUIRK_BE_DESC
;
213 if (pdata
->big_endian_mmio
)
214 ohci
->flags
|= OHCI_QUIRK_BE_MMIO
;
216 #ifndef CONFIG_USB_OHCI_BIG_ENDIAN_MMIO
217 if (ohci
->flags
& OHCI_QUIRK_BE_MMIO
) {
219 "Error: CONFIG_USB_OHCI_BIG_ENDIAN_MMIO not set\n");
224 #ifndef CONFIG_USB_OHCI_BIG_ENDIAN_DESC
225 if (ohci
->flags
& OHCI_QUIRK_BE_DESC
) {
227 "Error: CONFIG_USB_OHCI_BIG_ENDIAN_DESC not set\n");
233 if (pdata
->power_on
) {
234 err
= pdata
->power_on(dev
);
239 hcd
->rsrc_start
= res_mem
->start
;
240 hcd
->rsrc_len
= resource_size(res_mem
);
242 hcd
->regs
= devm_ioremap_resource(&dev
->dev
, res_mem
);
243 if (IS_ERR(hcd
->regs
)) {
244 err
= PTR_ERR(hcd
->regs
);
247 err
= usb_add_hcd(hcd
, irq
, IRQF_SHARED
);
251 device_wakeup_enable(hcd
->self
.controller
);
253 platform_set_drvdata(dev
, hcd
);
258 if (pdata
->power_off
)
259 pdata
->power_off(dev
);
262 reset_control_assert(priv
->rst
);
265 clk_put(priv
->clks
[clk
]);
267 if (pdata
== &ohci_platform_defaults
)
268 dev
->dev
.platform_data
= NULL
;
275 static int ohci_platform_remove(struct platform_device
*dev
)
277 struct usb_hcd
*hcd
= platform_get_drvdata(dev
);
278 struct usb_ohci_pdata
*pdata
= dev_get_platdata(&dev
->dev
);
279 struct ohci_platform_priv
*priv
= hcd_to_ohci_priv(hcd
);
284 if (pdata
->power_off
)
285 pdata
->power_off(dev
);
288 reset_control_assert(priv
->rst
);
290 for (clk
= 0; clk
< OHCI_MAX_CLKS
&& priv
->clks
[clk
]; clk
++)
291 clk_put(priv
->clks
[clk
]);
295 if (pdata
== &ohci_platform_defaults
)
296 dev
->dev
.platform_data
= NULL
;
303 static int ohci_platform_suspend(struct device
*dev
)
305 struct usb_hcd
*hcd
= dev_get_drvdata(dev
);
306 struct usb_ohci_pdata
*pdata
= dev
->platform_data
;
307 struct platform_device
*pdev
=
308 container_of(dev
, struct platform_device
, dev
);
309 bool do_wakeup
= device_may_wakeup(dev
);
312 ret
= ohci_suspend(hcd
, do_wakeup
);
316 if (pdata
->power_suspend
)
317 pdata
->power_suspend(pdev
);
322 static int ohci_platform_resume(struct device
*dev
)
324 struct usb_hcd
*hcd
= dev_get_drvdata(dev
);
325 struct usb_ohci_pdata
*pdata
= dev_get_platdata(dev
);
326 struct platform_device
*pdev
=
327 container_of(dev
, struct platform_device
, dev
);
329 if (pdata
->power_on
) {
330 int err
= pdata
->power_on(pdev
);
335 ohci_resume(hcd
, false);
339 #else /* !CONFIG_PM */
340 #define ohci_platform_suspend NULL
341 #define ohci_platform_resume NULL
342 #endif /* CONFIG_PM */
344 static const struct of_device_id ohci_platform_ids
[] = {
345 { .compatible
= "generic-ohci", },
348 MODULE_DEVICE_TABLE(of
, ohci_platform_ids
);
350 static const struct platform_device_id ohci_platform_table
[] = {
351 { "ohci-platform", 0 },
354 MODULE_DEVICE_TABLE(platform
, ohci_platform_table
);
356 static const struct dev_pm_ops ohci_platform_pm_ops
= {
357 .suspend
= ohci_platform_suspend
,
358 .resume
= ohci_platform_resume
,
361 static struct platform_driver ohci_platform_driver
= {
362 .id_table
= ohci_platform_table
,
363 .probe
= ohci_platform_probe
,
364 .remove
= ohci_platform_remove
,
365 .shutdown
= usb_hcd_platform_shutdown
,
367 .owner
= THIS_MODULE
,
368 .name
= "ohci-platform",
369 .pm
= &ohci_platform_pm_ops
,
370 .of_match_table
= ohci_platform_ids
,
374 static int __init
ohci_platform_init(void)
379 pr_info("%s: " DRIVER_DESC
"\n", hcd_name
);
381 ohci_init_driver(&ohci_platform_hc_driver
, &platform_overrides
);
382 return platform_driver_register(&ohci_platform_driver
);
384 module_init(ohci_platform_init
);
386 static void __exit
ohci_platform_cleanup(void)
388 platform_driver_unregister(&ohci_platform_driver
);
390 module_exit(ohci_platform_cleanup
);
392 MODULE_DESCRIPTION(DRIVER_DESC
);
393 MODULE_AUTHOR("Hauke Mehrtens");
394 MODULE_AUTHOR("Alan Stern");
395 MODULE_LICENSE("GPL");