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
;
45 static const char hcd_name
[] = "ohci-platform";
47 static int ohci_platform_power_on(struct platform_device
*dev
)
49 struct usb_hcd
*hcd
= platform_get_drvdata(dev
);
50 struct ohci_platform_priv
*priv
= hcd_to_ohci_priv(hcd
);
51 int clk
, ret
, phy_num
;
53 for (clk
= 0; clk
< OHCI_MAX_CLKS
&& priv
->clks
[clk
]; clk
++) {
54 ret
= clk_prepare_enable(priv
->clks
[clk
]);
56 goto err_disable_clks
;
59 for (phy_num
= 0; phy_num
< priv
->num_phys
; phy_num
++) {
60 if (priv
->phys
[phy_num
]) {
61 ret
= phy_init(priv
->phys
[phy_num
]);
64 ret
= phy_power_on(priv
->phys
[phy_num
]);
66 phy_exit(priv
->phys
[phy_num
]);
75 while (--phy_num
>= 0) {
76 if (priv
->phys
[phy_num
]) {
77 phy_power_off(priv
->phys
[phy_num
]);
78 phy_exit(priv
->phys
[phy_num
]);
83 clk_disable_unprepare(priv
->clks
[clk
]);
88 static void ohci_platform_power_off(struct platform_device
*dev
)
90 struct usb_hcd
*hcd
= platform_get_drvdata(dev
);
91 struct ohci_platform_priv
*priv
= hcd_to_ohci_priv(hcd
);
94 for (phy_num
= 0; phy_num
< priv
->num_phys
; phy_num
++) {
95 if (priv
->phys
[phy_num
]) {
96 phy_power_off(priv
->phys
[phy_num
]);
97 phy_exit(priv
->phys
[phy_num
]);
101 for (clk
= OHCI_MAX_CLKS
- 1; clk
>= 0; clk
--)
103 clk_disable_unprepare(priv
->clks
[clk
]);
106 static struct hc_driver __read_mostly ohci_platform_hc_driver
;
108 static const struct ohci_driver_overrides platform_overrides __initconst
= {
109 .product_desc
= "Generic Platform OHCI controller",
110 .extra_priv_size
= sizeof(struct ohci_platform_priv
),
113 static struct usb_ohci_pdata ohci_platform_defaults
= {
114 .power_on
= ohci_platform_power_on
,
115 .power_suspend
= ohci_platform_power_off
,
116 .power_off
= ohci_platform_power_off
,
119 static int ohci_platform_probe(struct platform_device
*dev
)
122 struct resource
*res_mem
;
123 struct usb_ohci_pdata
*pdata
= dev_get_platdata(&dev
->dev
);
124 struct ohci_platform_priv
*priv
;
125 struct ohci_hcd
*ohci
;
126 const char *phy_name
;
127 int err
, irq
, phy_num
, clk
= 0;
133 * Use reasonable defaults so platforms don't have to provide these
134 * with DT probing on ARM.
137 pdata
= &ohci_platform_defaults
;
139 err
= dma_coerce_mask_and_coherent(&dev
->dev
, DMA_BIT_MASK(32));
143 irq
= platform_get_irq(dev
, 0);
145 dev_err(&dev
->dev
, "no irq provided");
149 hcd
= usb_create_hcd(&ohci_platform_hc_driver
, &dev
->dev
,
150 dev_name(&dev
->dev
));
154 platform_set_drvdata(dev
, hcd
);
155 dev
->dev
.platform_data
= pdata
;
156 priv
= hcd_to_ohci_priv(hcd
);
157 ohci
= hcd_to_ohci(hcd
);
159 if (pdata
== &ohci_platform_defaults
&& dev
->dev
.of_node
) {
160 if (of_property_read_bool(dev
->dev
.of_node
, "big-endian-regs"))
161 ohci
->flags
|= OHCI_QUIRK_BE_MMIO
;
163 if (of_property_read_bool(dev
->dev
.of_node
, "big-endian-desc"))
164 ohci
->flags
|= OHCI_QUIRK_BE_DESC
;
166 if (of_property_read_bool(dev
->dev
.of_node
, "big-endian"))
167 ohci
->flags
|= OHCI_QUIRK_BE_MMIO
| OHCI_QUIRK_BE_DESC
;
169 if (of_property_read_bool(dev
->dev
.of_node
, "no-big-frame-no"))
170 ohci
->flags
|= OHCI_QUIRK_FRAME_NO
;
172 of_property_read_u32(dev
->dev
.of_node
, "num-ports",
175 priv
->num_phys
= of_count_phandle_with_args(dev
->dev
.of_node
,
176 "phys", "#phy-cells");
177 priv
->num_phys
= priv
->num_phys
> 0 ? priv
->num_phys
: 1;
179 priv
->phys
= devm_kcalloc(&dev
->dev
, priv
->num_phys
,
180 sizeof(struct phy
*), GFP_KERNEL
);
184 for (phy_num
= 0; phy_num
< priv
->num_phys
; phy_num
++) {
185 err
= of_property_read_string_index(
187 "phy-names", phy_num
,
191 if (priv
->num_phys
> 1) {
192 dev_err(&dev
->dev
, "phy-names not provided");
198 priv
->phys
[phy_num
] = devm_phy_get(&dev
->dev
,
200 if (IS_ERR(priv
->phys
[phy_num
])) {
201 err
= PTR_ERR(priv
->phys
[phy_num
]);
202 if ((priv
->num_phys
> 1) ||
203 (err
== -EPROBE_DEFER
))
205 priv
->phys
[phy_num
] = NULL
;
209 for (clk
= 0; clk
< OHCI_MAX_CLKS
; clk
++) {
210 priv
->clks
[clk
] = of_clk_get(dev
->dev
.of_node
, clk
);
211 if (IS_ERR(priv
->clks
[clk
])) {
212 err
= PTR_ERR(priv
->clks
[clk
]);
213 if (err
== -EPROBE_DEFER
)
215 priv
->clks
[clk
] = NULL
;
222 priv
->rst
= devm_reset_control_get_optional(&dev
->dev
, NULL
);
223 if (IS_ERR(priv
->rst
)) {
224 err
= PTR_ERR(priv
->rst
);
225 if (err
== -EPROBE_DEFER
)
229 err
= reset_control_deassert(priv
->rst
);
234 if (pdata
->big_endian_desc
)
235 ohci
->flags
|= OHCI_QUIRK_BE_DESC
;
236 if (pdata
->big_endian_mmio
)
237 ohci
->flags
|= OHCI_QUIRK_BE_MMIO
;
238 if (pdata
->no_big_frame_no
)
239 ohci
->flags
|= OHCI_QUIRK_FRAME_NO
;
240 if (pdata
->num_ports
)
241 ohci
->num_ports
= pdata
->num_ports
;
243 #ifndef CONFIG_USB_OHCI_BIG_ENDIAN_MMIO
244 if (ohci
->flags
& OHCI_QUIRK_BE_MMIO
) {
246 "Error: CONFIG_USB_OHCI_BIG_ENDIAN_MMIO not set\n");
251 #ifndef CONFIG_USB_OHCI_BIG_ENDIAN_DESC
252 if (ohci
->flags
& OHCI_QUIRK_BE_DESC
) {
254 "Error: CONFIG_USB_OHCI_BIG_ENDIAN_DESC not set\n");
260 if (pdata
->power_on
) {
261 err
= pdata
->power_on(dev
);
266 res_mem
= platform_get_resource(dev
, IORESOURCE_MEM
, 0);
267 hcd
->regs
= devm_ioremap_resource(&dev
->dev
, res_mem
);
268 if (IS_ERR(hcd
->regs
)) {
269 err
= PTR_ERR(hcd
->regs
);
272 hcd
->rsrc_start
= res_mem
->start
;
273 hcd
->rsrc_len
= resource_size(res_mem
);
275 err
= usb_add_hcd(hcd
, irq
, IRQF_SHARED
);
279 device_wakeup_enable(hcd
->self
.controller
);
281 platform_set_drvdata(dev
, hcd
);
286 if (pdata
->power_off
)
287 pdata
->power_off(dev
);
290 reset_control_assert(priv
->rst
);
293 clk_put(priv
->clks
[clk
]);
295 if (pdata
== &ohci_platform_defaults
)
296 dev
->dev
.platform_data
= NULL
;
303 static int ohci_platform_remove(struct platform_device
*dev
)
305 struct usb_hcd
*hcd
= platform_get_drvdata(dev
);
306 struct usb_ohci_pdata
*pdata
= dev_get_platdata(&dev
->dev
);
307 struct ohci_platform_priv
*priv
= hcd_to_ohci_priv(hcd
);
312 if (pdata
->power_off
)
313 pdata
->power_off(dev
);
316 reset_control_assert(priv
->rst
);
318 for (clk
= 0; clk
< OHCI_MAX_CLKS
&& priv
->clks
[clk
]; clk
++)
319 clk_put(priv
->clks
[clk
]);
323 if (pdata
== &ohci_platform_defaults
)
324 dev
->dev
.platform_data
= NULL
;
329 #ifdef CONFIG_PM_SLEEP
330 static int ohci_platform_suspend(struct device
*dev
)
332 struct usb_hcd
*hcd
= dev_get_drvdata(dev
);
333 struct usb_ohci_pdata
*pdata
= dev
->platform_data
;
334 struct platform_device
*pdev
=
335 container_of(dev
, struct platform_device
, dev
);
336 bool do_wakeup
= device_may_wakeup(dev
);
339 ret
= ohci_suspend(hcd
, do_wakeup
);
343 if (pdata
->power_suspend
)
344 pdata
->power_suspend(pdev
);
349 static int ohci_platform_resume(struct device
*dev
)
351 struct usb_hcd
*hcd
= dev_get_drvdata(dev
);
352 struct usb_ohci_pdata
*pdata
= dev_get_platdata(dev
);
353 struct platform_device
*pdev
=
354 container_of(dev
, struct platform_device
, dev
);
356 if (pdata
->power_on
) {
357 int err
= pdata
->power_on(pdev
);
362 ohci_resume(hcd
, false);
365 #endif /* CONFIG_PM_SLEEP */
367 static const struct of_device_id ohci_platform_ids
[] = {
368 { .compatible
= "generic-ohci", },
369 { .compatible
= "cavium,octeon-6335-ohci", },
372 MODULE_DEVICE_TABLE(of
, ohci_platform_ids
);
374 static const struct platform_device_id ohci_platform_table
[] = {
375 { "ohci-platform", 0 },
378 MODULE_DEVICE_TABLE(platform
, ohci_platform_table
);
380 static SIMPLE_DEV_PM_OPS(ohci_platform_pm_ops
, ohci_platform_suspend
,
381 ohci_platform_resume
);
383 static struct platform_driver ohci_platform_driver
= {
384 .id_table
= ohci_platform_table
,
385 .probe
= ohci_platform_probe
,
386 .remove
= ohci_platform_remove
,
387 .shutdown
= usb_hcd_platform_shutdown
,
389 .name
= "ohci-platform",
390 .pm
= &ohci_platform_pm_ops
,
391 .of_match_table
= ohci_platform_ids
,
395 static int __init
ohci_platform_init(void)
400 pr_info("%s: " DRIVER_DESC
"\n", hcd_name
);
402 ohci_init_driver(&ohci_platform_hc_driver
, &platform_overrides
);
403 return platform_driver_register(&ohci_platform_driver
);
405 module_init(ohci_platform_init
);
407 static void __exit
ohci_platform_cleanup(void)
409 platform_driver_unregister(&ohci_platform_driver
);
411 module_exit(ohci_platform_cleanup
);
413 MODULE_DESCRIPTION(DRIVER_DESC
);
414 MODULE_AUTHOR("Hauke Mehrtens");
415 MODULE_AUTHOR("Alan Stern");
416 MODULE_LICENSE("GPL");