2 * Generic platform ehci driver
4 * Copyright 2007 Steven Brown <sbrown@cortland.com>
5 * Copyright 2010-2012 Hauke Mehrtens <hauke@hauke-m.de>
6 * Copyright 2014 Hans de Goede <hdegoede@redhat.com>
8 * Derived from the ohci-ssb driver
9 * Copyright 2007 Michael Buesch <m@bues.ch>
11 * Derived from the EHCI-PCI driver
12 * Copyright (c) 2000-2004 by David Brownell
14 * Derived from the ohci-pci driver
15 * Copyright 1999 Roman Weissgaerber
16 * Copyright 2000-2002 David Brownell
17 * Copyright 1999 Linus Torvalds
18 * Copyright 1999 Gregory P. Smith
20 * Licensed under the GNU/GPL. See COPYING for details.
22 #include <linux/clk.h>
23 #include <linux/dma-mapping.h>
24 #include <linux/err.h>
25 #include <linux/kernel.h>
26 #include <linux/hrtimer.h>
28 #include <linux/module.h>
30 #include <linux/phy/phy.h>
31 #include <linux/platform_device.h>
32 #include <linux/reset.h>
33 #include <linux/usb.h>
34 #include <linux/usb/hcd.h>
35 #include <linux/usb/ehci_pdriver.h>
39 #define DRIVER_DESC "EHCI generic platform driver"
40 #define EHCI_MAX_CLKS 3
41 #define hcd_to_ehci_priv(h) ((struct ehci_platform_priv *)hcd_to_ehci(h)->priv)
43 struct ehci_platform_priv
{
44 struct clk
*clks
[EHCI_MAX_CLKS
];
45 struct reset_control
*rst
;
50 static const char hcd_name
[] = "ehci-platform";
52 static int ehci_platform_reset(struct usb_hcd
*hcd
)
54 struct platform_device
*pdev
= to_platform_device(hcd
->self
.controller
);
55 struct usb_ehci_pdata
*pdata
= dev_get_platdata(&pdev
->dev
);
56 struct ehci_hcd
*ehci
= hcd_to_ehci(hcd
);
59 hcd
->has_tt
= pdata
->has_tt
;
60 ehci
->has_synopsys_hc_bug
= pdata
->has_synopsys_hc_bug
;
62 if (pdata
->pre_setup
) {
63 retval
= pdata
->pre_setup(hcd
);
68 ehci
->caps
= hcd
->regs
+ pdata
->caps_offset
;
69 retval
= ehci_setup(hcd
);
73 if (pdata
->no_io_watchdog
)
74 ehci
->need_io_watchdog
= 0;
78 static int ehci_platform_power_on(struct platform_device
*dev
)
80 struct usb_hcd
*hcd
= platform_get_drvdata(dev
);
81 struct ehci_platform_priv
*priv
= hcd_to_ehci_priv(hcd
);
82 int clk
, ret
, phy_num
;
84 for (clk
= 0; clk
< EHCI_MAX_CLKS
&& priv
->clks
[clk
]; clk
++) {
85 ret
= clk_prepare_enable(priv
->clks
[clk
]);
87 goto err_disable_clks
;
90 for (phy_num
= 0; phy_num
< priv
->num_phys
; phy_num
++) {
91 if (priv
->phys
[phy_num
]) {
92 ret
= phy_init(priv
->phys
[phy_num
]);
95 ret
= phy_power_on(priv
->phys
[phy_num
]);
97 phy_exit(priv
->phys
[phy_num
]);
106 while (--phy_num
>= 0) {
107 if (priv
->phys
[phy_num
]) {
108 phy_power_off(priv
->phys
[phy_num
]);
109 phy_exit(priv
->phys
[phy_num
]);
114 clk_disable_unprepare(priv
->clks
[clk
]);
119 static void ehci_platform_power_off(struct platform_device
*dev
)
121 struct usb_hcd
*hcd
= platform_get_drvdata(dev
);
122 struct ehci_platform_priv
*priv
= hcd_to_ehci_priv(hcd
);
125 for (phy_num
= 0; phy_num
< priv
->num_phys
; phy_num
++) {
126 if (priv
->phys
[phy_num
]) {
127 phy_power_off(priv
->phys
[phy_num
]);
128 phy_exit(priv
->phys
[phy_num
]);
132 for (clk
= EHCI_MAX_CLKS
- 1; clk
>= 0; clk
--)
134 clk_disable_unprepare(priv
->clks
[clk
]);
137 static struct hc_driver __read_mostly ehci_platform_hc_driver
;
139 static const struct ehci_driver_overrides platform_overrides __initconst
= {
140 .reset
= ehci_platform_reset
,
141 .extra_priv_size
= sizeof(struct ehci_platform_priv
),
144 static struct usb_ehci_pdata ehci_platform_defaults
= {
145 .power_on
= ehci_platform_power_on
,
146 .power_suspend
= ehci_platform_power_off
,
147 .power_off
= ehci_platform_power_off
,
150 static int ehci_platform_probe(struct platform_device
*dev
)
153 struct resource
*res_mem
;
154 struct usb_ehci_pdata
*pdata
= dev_get_platdata(&dev
->dev
);
155 struct ehci_platform_priv
*priv
;
156 struct ehci_hcd
*ehci
;
157 const char *phy_name
;
158 int err
, irq
, phy_num
, clk
= 0;
164 * Use reasonable defaults so platforms don't have to provide these
165 * with DT probing on ARM.
168 pdata
= &ehci_platform_defaults
;
170 err
= dma_coerce_mask_and_coherent(&dev
->dev
,
171 pdata
->dma_mask_64
? DMA_BIT_MASK(64) : DMA_BIT_MASK(32));
175 irq
= platform_get_irq(dev
, 0);
177 dev_err(&dev
->dev
, "no irq provided");
181 hcd
= usb_create_hcd(&ehci_platform_hc_driver
, &dev
->dev
,
182 dev_name(&dev
->dev
));
186 platform_set_drvdata(dev
, hcd
);
187 dev
->dev
.platform_data
= pdata
;
188 priv
= hcd_to_ehci_priv(hcd
);
189 ehci
= hcd_to_ehci(hcd
);
191 if (pdata
== &ehci_platform_defaults
&& dev
->dev
.of_node
) {
192 if (of_property_read_bool(dev
->dev
.of_node
, "big-endian-regs"))
193 ehci
->big_endian_mmio
= 1;
195 if (of_property_read_bool(dev
->dev
.of_node
, "big-endian-desc"))
196 ehci
->big_endian_desc
= 1;
198 if (of_property_read_bool(dev
->dev
.of_node
, "big-endian"))
199 ehci
->big_endian_mmio
= ehci
->big_endian_desc
= 1;
201 if (of_property_read_bool(dev
->dev
.of_node
,
202 "needs-reset-on-resume"))
203 pdata
->reset_on_resume
= 1;
205 priv
->num_phys
= of_count_phandle_with_args(dev
->dev
.of_node
,
206 "phys", "#phy-cells");
207 priv
->num_phys
= priv
->num_phys
> 0 ? priv
->num_phys
: 1;
209 priv
->phys
= devm_kcalloc(&dev
->dev
, priv
->num_phys
,
210 sizeof(struct phy
*), GFP_KERNEL
);
214 for (phy_num
= 0; phy_num
< priv
->num_phys
; phy_num
++) {
215 err
= of_property_read_string_index(
217 "phy-names", phy_num
,
221 if (priv
->num_phys
> 1) {
222 dev_err(&dev
->dev
, "phy-names not provided");
228 priv
->phys
[phy_num
] = devm_phy_get(&dev
->dev
,
230 if (IS_ERR(priv
->phys
[phy_num
])) {
231 err
= PTR_ERR(priv
->phys
[phy_num
]);
232 if ((priv
->num_phys
> 1) ||
233 (err
== -EPROBE_DEFER
))
235 priv
->phys
[phy_num
] = NULL
;
239 for (clk
= 0; clk
< EHCI_MAX_CLKS
; clk
++) {
240 priv
->clks
[clk
] = of_clk_get(dev
->dev
.of_node
, clk
);
241 if (IS_ERR(priv
->clks
[clk
])) {
242 err
= PTR_ERR(priv
->clks
[clk
]);
243 if (err
== -EPROBE_DEFER
)
245 priv
->clks
[clk
] = NULL
;
251 priv
->rst
= devm_reset_control_get_optional(&dev
->dev
, NULL
);
252 if (IS_ERR(priv
->rst
)) {
253 err
= PTR_ERR(priv
->rst
);
254 if (err
== -EPROBE_DEFER
)
258 err
= reset_control_deassert(priv
->rst
);
263 if (pdata
->big_endian_desc
)
264 ehci
->big_endian_desc
= 1;
265 if (pdata
->big_endian_mmio
)
266 ehci
->big_endian_mmio
= 1;
268 #ifndef CONFIG_USB_EHCI_BIG_ENDIAN_MMIO
269 if (ehci
->big_endian_mmio
) {
271 "Error: CONFIG_USB_EHCI_BIG_ENDIAN_MMIO not set\n");
276 #ifndef CONFIG_USB_EHCI_BIG_ENDIAN_DESC
277 if (ehci
->big_endian_desc
) {
279 "Error: CONFIG_USB_EHCI_BIG_ENDIAN_DESC not set\n");
285 if (pdata
->power_on
) {
286 err
= pdata
->power_on(dev
);
291 res_mem
= platform_get_resource(dev
, IORESOURCE_MEM
, 0);
292 hcd
->regs
= devm_ioremap_resource(&dev
->dev
, res_mem
);
293 if (IS_ERR(hcd
->regs
)) {
294 err
= PTR_ERR(hcd
->regs
);
297 hcd
->rsrc_start
= res_mem
->start
;
298 hcd
->rsrc_len
= resource_size(res_mem
);
300 err
= usb_add_hcd(hcd
, irq
, IRQF_SHARED
);
304 device_wakeup_enable(hcd
->self
.controller
);
305 platform_set_drvdata(dev
, hcd
);
310 if (pdata
->power_off
)
311 pdata
->power_off(dev
);
314 reset_control_assert(priv
->rst
);
317 clk_put(priv
->clks
[clk
]);
319 if (pdata
== &ehci_platform_defaults
)
320 dev
->dev
.platform_data
= NULL
;
327 static int ehci_platform_remove(struct platform_device
*dev
)
329 struct usb_hcd
*hcd
= platform_get_drvdata(dev
);
330 struct usb_ehci_pdata
*pdata
= dev_get_platdata(&dev
->dev
);
331 struct ehci_platform_priv
*priv
= hcd_to_ehci_priv(hcd
);
336 if (pdata
->power_off
)
337 pdata
->power_off(dev
);
340 reset_control_assert(priv
->rst
);
342 for (clk
= 0; clk
< EHCI_MAX_CLKS
&& priv
->clks
[clk
]; clk
++)
343 clk_put(priv
->clks
[clk
]);
347 if (pdata
== &ehci_platform_defaults
)
348 dev
->dev
.platform_data
= NULL
;
353 #ifdef CONFIG_PM_SLEEP
354 static int ehci_platform_suspend(struct device
*dev
)
356 struct usb_hcd
*hcd
= dev_get_drvdata(dev
);
357 struct usb_ehci_pdata
*pdata
= dev_get_platdata(dev
);
358 struct platform_device
*pdev
=
359 container_of(dev
, struct platform_device
, dev
);
360 bool do_wakeup
= device_may_wakeup(dev
);
363 ret
= ehci_suspend(hcd
, do_wakeup
);
367 if (pdata
->power_suspend
)
368 pdata
->power_suspend(pdev
);
373 static int ehci_platform_resume(struct device
*dev
)
375 struct usb_hcd
*hcd
= dev_get_drvdata(dev
);
376 struct usb_ehci_pdata
*pdata
= dev_get_platdata(dev
);
377 struct platform_device
*pdev
=
378 container_of(dev
, struct platform_device
, dev
);
380 if (pdata
->power_on
) {
381 int err
= pdata
->power_on(pdev
);
386 ehci_resume(hcd
, pdata
->reset_on_resume
);
389 #endif /* CONFIG_PM_SLEEP */
391 static const struct of_device_id vt8500_ehci_ids
[] = {
392 { .compatible
= "via,vt8500-ehci", },
393 { .compatible
= "wm,prizm-ehci", },
394 { .compatible
= "generic-ehci", },
395 { .compatible
= "cavium,octeon-6335-ehci", },
398 MODULE_DEVICE_TABLE(of
, vt8500_ehci_ids
);
400 static const struct platform_device_id ehci_platform_table
[] = {
401 { "ehci-platform", 0 },
404 MODULE_DEVICE_TABLE(platform
, ehci_platform_table
);
406 static SIMPLE_DEV_PM_OPS(ehci_platform_pm_ops
, ehci_platform_suspend
,
407 ehci_platform_resume
);
409 static struct platform_driver ehci_platform_driver
= {
410 .id_table
= ehci_platform_table
,
411 .probe
= ehci_platform_probe
,
412 .remove
= ehci_platform_remove
,
413 .shutdown
= usb_hcd_platform_shutdown
,
415 .name
= "ehci-platform",
416 .pm
= &ehci_platform_pm_ops
,
417 .of_match_table
= vt8500_ehci_ids
,
421 static int __init
ehci_platform_init(void)
426 pr_info("%s: " DRIVER_DESC
"\n", hcd_name
);
428 ehci_init_driver(&ehci_platform_hc_driver
, &platform_overrides
);
429 return platform_driver_register(&ehci_platform_driver
);
431 module_init(ehci_platform_init
);
433 static void __exit
ehci_platform_cleanup(void)
435 platform_driver_unregister(&ehci_platform_driver
);
437 module_exit(ehci_platform_cleanup
);
439 MODULE_DESCRIPTION(DRIVER_DESC
);
440 MODULE_AUTHOR("Hauke Mehrtens");
441 MODULE_AUTHOR("Alan Stern");
442 MODULE_LICENSE("GPL");