tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Generic platform ehci driver
4 *
5 * Copyright 2007 Steven Brown <sbrown@cortland.com>
6 * Copyright 2010-2012 Hauke Mehrtens <hauke@hauke-m.de>
7 * Copyright 2014 Hans de Goede <hdegoede@redhat.com>
8 *
9 * Derived from the ohci-ssb driver
10 * Copyright 2007 Michael Buesch <m@bues.ch>
11 *
12 * Derived from the EHCI-PCI driver
13 * Copyright (c) 2000-2004 by David Brownell
14 *
15 * Derived from the ohci-pci driver
16 * Copyright 1999 Roman Weissgaerber
17 * Copyright 2000-2002 David Brownell
18 * Copyright 1999 Linus Torvalds
19 * Copyright 1999 Gregory P. Smith
20 */
21#include <linux/acpi.h>
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>
27#include <linux/io.h>
28#include <linux/module.h>
29#include <linux/of.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>
36#include <linux/usb/of.h>
37
38#include "ehci.h"
39
40#define DRIVER_DESC "EHCI generic platform driver"
41#define EHCI_MAX_CLKS 4
42#define hcd_to_ehci_priv(h) ((struct ehci_platform_priv *)hcd_to_ehci(h)->priv)
43
44struct ehci_platform_priv {
45 struct clk *clks[EHCI_MAX_CLKS];
46 struct reset_control *rsts;
47 struct phy **phys;
48 int num_phys;
49 bool reset_on_resume;
50};
51
52static const char hcd_name[] = "ehci-platform";
53
54static int ehci_platform_reset(struct usb_hcd *hcd)
55{
56 struct platform_device *pdev = to_platform_device(hcd->self.controller);
57 struct usb_ehci_pdata *pdata = dev_get_platdata(&pdev->dev);
58 struct ehci_hcd *ehci = hcd_to_ehci(hcd);
59 int retval;
60
61 ehci->has_synopsys_hc_bug = pdata->has_synopsys_hc_bug;
62
63 if (pdata->pre_setup) {
64 retval = pdata->pre_setup(hcd);
65 if (retval < 0)
66 return retval;
67 }
68
69 ehci->caps = hcd->regs + pdata->caps_offset;
70 retval = ehci_setup(hcd);
71 if (retval)
72 return retval;
73
74 if (pdata->no_io_watchdog)
75 ehci->need_io_watchdog = 0;
76 return 0;
77}
78
79static int ehci_platform_power_on(struct platform_device *dev)
80{
81 struct usb_hcd *hcd = platform_get_drvdata(dev);
82 struct ehci_platform_priv *priv = hcd_to_ehci_priv(hcd);
83 int clk, ret, phy_num;
84
85 for (clk = 0; clk < EHCI_MAX_CLKS && priv->clks[clk]; clk++) {
86 ret = clk_prepare_enable(priv->clks[clk]);
87 if (ret)
88 goto err_disable_clks;
89 }
90
91 for (phy_num = 0; phy_num < priv->num_phys; phy_num++) {
92 ret = phy_init(priv->phys[phy_num]);
93 if (ret)
94 goto err_exit_phy;
95 ret = phy_power_on(priv->phys[phy_num]);
96 if (ret) {
97 phy_exit(priv->phys[phy_num]);
98 goto err_exit_phy;
99 }
100 }
101
102 return 0;
103
104err_exit_phy:
105 while (--phy_num >= 0) {
106 phy_power_off(priv->phys[phy_num]);
107 phy_exit(priv->phys[phy_num]);
108 }
109err_disable_clks:
110 while (--clk >= 0)
111 clk_disable_unprepare(priv->clks[clk]);
112
113 return ret;
114}
115
116static void ehci_platform_power_off(struct platform_device *dev)
117{
118 struct usb_hcd *hcd = platform_get_drvdata(dev);
119 struct ehci_platform_priv *priv = hcd_to_ehci_priv(hcd);
120 int clk, phy_num;
121
122 for (phy_num = 0; phy_num < priv->num_phys; phy_num++) {
123 phy_power_off(priv->phys[phy_num]);
124 phy_exit(priv->phys[phy_num]);
125 }
126
127 for (clk = EHCI_MAX_CLKS - 1; clk >= 0; clk--)
128 if (priv->clks[clk])
129 clk_disable_unprepare(priv->clks[clk]);
130}
131
132static struct hc_driver __read_mostly ehci_platform_hc_driver;
133
134static const struct ehci_driver_overrides platform_overrides __initconst = {
135 .reset = ehci_platform_reset,
136 .extra_priv_size = sizeof(struct ehci_platform_priv),
137};
138
139static struct usb_ehci_pdata ehci_platform_defaults = {
140 .power_on = ehci_platform_power_on,
141 .power_suspend = ehci_platform_power_off,
142 .power_off = ehci_platform_power_off,
143};
144
145static int ehci_platform_probe(struct platform_device *dev)
146{
147 struct usb_hcd *hcd;
148 struct resource *res_mem;
149 struct usb_ehci_pdata *pdata = dev_get_platdata(&dev->dev);
150 struct ehci_platform_priv *priv;
151 struct ehci_hcd *ehci;
152 int err, irq, phy_num, clk = 0;
153
154 if (usb_disabled())
155 return -ENODEV;
156
157 /*
158 * Use reasonable defaults so platforms don't have to provide these
159 * with DT probing on ARM.
160 */
161 if (!pdata)
162 pdata = &ehci_platform_defaults;
163
164 err = dma_coerce_mask_and_coherent(&dev->dev,
165 pdata->dma_mask_64 ? DMA_BIT_MASK(64) : DMA_BIT_MASK(32));
166 if (err) {
167 dev_err(&dev->dev, "Error: DMA mask configuration failed\n");
168 return err;
169 }
170
171 irq = platform_get_irq(dev, 0);
172 if (irq < 0) {
173 dev_err(&dev->dev, "no irq provided");
174 return irq;
175 }
176
177 hcd = usb_create_hcd(&ehci_platform_hc_driver, &dev->dev,
178 dev_name(&dev->dev));
179 if (!hcd)
180 return -ENOMEM;
181
182 platform_set_drvdata(dev, hcd);
183 dev->dev.platform_data = pdata;
184 priv = hcd_to_ehci_priv(hcd);
185 ehci = hcd_to_ehci(hcd);
186
187 if (pdata == &ehci_platform_defaults && dev->dev.of_node) {
188 if (of_property_read_bool(dev->dev.of_node, "big-endian-regs"))
189 ehci->big_endian_mmio = 1;
190
191 if (of_property_read_bool(dev->dev.of_node, "big-endian-desc"))
192 ehci->big_endian_desc = 1;
193
194 if (of_property_read_bool(dev->dev.of_node, "big-endian"))
195 ehci->big_endian_mmio = ehci->big_endian_desc = 1;
196
197 if (of_property_read_bool(dev->dev.of_node,
198 "needs-reset-on-resume"))
199 priv->reset_on_resume = true;
200
201 if (of_property_read_bool(dev->dev.of_node,
202 "has-transaction-translator"))
203 hcd->has_tt = 1;
204
205 priv->num_phys = of_count_phandle_with_args(dev->dev.of_node,
206 "phys", "#phy-cells");
207
208 if (priv->num_phys > 0) {
209 priv->phys = devm_kcalloc(&dev->dev, priv->num_phys,
210 sizeof(struct phy *), GFP_KERNEL);
211 if (!priv->phys)
212 return -ENOMEM;
213 } else
214 priv->num_phys = 0;
215
216 for (phy_num = 0; phy_num < priv->num_phys; phy_num++) {
217 priv->phys[phy_num] = devm_of_phy_get_by_index(
218 &dev->dev, dev->dev.of_node, phy_num);
219 if (IS_ERR(priv->phys[phy_num])) {
220 err = PTR_ERR(priv->phys[phy_num]);
221 goto err_put_hcd;
222 } else if (!hcd->phy) {
223 /* Avoiding phy_get() in usb_add_hcd() */
224 hcd->phy = priv->phys[phy_num];
225 }
226 }
227
228 for (clk = 0; clk < EHCI_MAX_CLKS; clk++) {
229 priv->clks[clk] = of_clk_get(dev->dev.of_node, clk);
230 if (IS_ERR(priv->clks[clk])) {
231 err = PTR_ERR(priv->clks[clk]);
232 if (err == -EPROBE_DEFER)
233 goto err_put_clks;
234 priv->clks[clk] = NULL;
235 break;
236 }
237 }
238 }
239
240 priv->rsts = devm_reset_control_array_get_optional_shared(&dev->dev);
241 if (IS_ERR(priv->rsts)) {
242 err = PTR_ERR(priv->rsts);
243 goto err_put_clks;
244 }
245
246 err = reset_control_deassert(priv->rsts);
247 if (err)
248 goto err_put_clks;
249
250 if (pdata->big_endian_desc)
251 ehci->big_endian_desc = 1;
252 if (pdata->big_endian_mmio)
253 ehci->big_endian_mmio = 1;
254 if (pdata->has_tt)
255 hcd->has_tt = 1;
256 if (pdata->reset_on_resume)
257 priv->reset_on_resume = true;
258
259#ifndef CONFIG_USB_EHCI_BIG_ENDIAN_MMIO
260 if (ehci->big_endian_mmio) {
261 dev_err(&dev->dev,
262 "Error: CONFIG_USB_EHCI_BIG_ENDIAN_MMIO not set\n");
263 err = -EINVAL;
264 goto err_reset;
265 }
266#endif
267#ifndef CONFIG_USB_EHCI_BIG_ENDIAN_DESC
268 if (ehci->big_endian_desc) {
269 dev_err(&dev->dev,
270 "Error: CONFIG_USB_EHCI_BIG_ENDIAN_DESC not set\n");
271 err = -EINVAL;
272 goto err_reset;
273 }
274#endif
275
276 if (pdata->power_on) {
277 err = pdata->power_on(dev);
278 if (err < 0)
279 goto err_reset;
280 }
281
282 res_mem = platform_get_resource(dev, IORESOURCE_MEM, 0);
283 hcd->regs = devm_ioremap_resource(&dev->dev, res_mem);
284 if (IS_ERR(hcd->regs)) {
285 err = PTR_ERR(hcd->regs);
286 goto err_power;
287 }
288 hcd->rsrc_start = res_mem->start;
289 hcd->rsrc_len = resource_size(res_mem);
290
291 err = usb_add_hcd(hcd, irq, IRQF_SHARED);
292 if (err)
293 goto err_power;
294
295 device_wakeup_enable(hcd->self.controller);
296 device_enable_async_suspend(hcd->self.controller);
297 platform_set_drvdata(dev, hcd);
298
299 return err;
300
301err_power:
302 if (pdata->power_off)
303 pdata->power_off(dev);
304err_reset:
305 reset_control_assert(priv->rsts);
306err_put_clks:
307 while (--clk >= 0)
308 clk_put(priv->clks[clk]);
309err_put_hcd:
310 if (pdata == &ehci_platform_defaults)
311 dev->dev.platform_data = NULL;
312
313 usb_put_hcd(hcd);
314
315 return err;
316}
317
318static int ehci_platform_remove(struct platform_device *dev)
319{
320 struct usb_hcd *hcd = platform_get_drvdata(dev);
321 struct usb_ehci_pdata *pdata = dev_get_platdata(&dev->dev);
322 struct ehci_platform_priv *priv = hcd_to_ehci_priv(hcd);
323 int clk;
324
325 usb_remove_hcd(hcd);
326
327 if (pdata->power_off)
328 pdata->power_off(dev);
329
330 reset_control_assert(priv->rsts);
331
332 for (clk = 0; clk < EHCI_MAX_CLKS && priv->clks[clk]; clk++)
333 clk_put(priv->clks[clk]);
334
335 usb_put_hcd(hcd);
336
337 if (pdata == &ehci_platform_defaults)
338 dev->dev.platform_data = NULL;
339
340 return 0;
341}
342
343#ifdef CONFIG_PM_SLEEP
344static int ehci_platform_suspend(struct device *dev)
345{
346 struct usb_hcd *hcd = dev_get_drvdata(dev);
347 struct usb_ehci_pdata *pdata = dev_get_platdata(dev);
348 struct platform_device *pdev = to_platform_device(dev);
349 bool do_wakeup = device_may_wakeup(dev);
350 int ret;
351
352 ret = ehci_suspend(hcd, do_wakeup);
353 if (ret)
354 return ret;
355
356 if (pdata->power_suspend)
357 pdata->power_suspend(pdev);
358
359 return ret;
360}
361
362static int ehci_platform_resume(struct device *dev)
363{
364 struct usb_hcd *hcd = dev_get_drvdata(dev);
365 struct usb_ehci_pdata *pdata = dev_get_platdata(dev);
366 struct platform_device *pdev = to_platform_device(dev);
367 struct ehci_platform_priv *priv = hcd_to_ehci_priv(hcd);
368 struct device *companion_dev;
369
370 if (pdata->power_on) {
371 int err = pdata->power_on(pdev);
372 if (err < 0)
373 return err;
374 }
375
376 companion_dev = usb_of_get_companion_dev(hcd->self.controller);
377 if (companion_dev) {
378 device_pm_wait_for_dev(hcd->self.controller, companion_dev);
379 put_device(companion_dev);
380 }
381
382 ehci_resume(hcd, priv->reset_on_resume);
383 return 0;
384}
385#endif /* CONFIG_PM_SLEEP */
386
387static const struct of_device_id vt8500_ehci_ids[] = {
388 { .compatible = "via,vt8500-ehci", },
389 { .compatible = "wm,prizm-ehci", },
390 { .compatible = "generic-ehci", },
391 { .compatible = "cavium,octeon-6335-ehci", },
392 {}
393};
394MODULE_DEVICE_TABLE(of, vt8500_ehci_ids);
395
396static const struct acpi_device_id ehci_acpi_match[] = {
397 { "PNP0D20", 0 }, /* EHCI controller without debug */
398 { }
399};
400MODULE_DEVICE_TABLE(acpi, ehci_acpi_match);
401
402static const struct platform_device_id ehci_platform_table[] = {
403 { "ehci-platform", 0 },
404 { }
405};
406MODULE_DEVICE_TABLE(platform, ehci_platform_table);
407
408static SIMPLE_DEV_PM_OPS(ehci_platform_pm_ops, ehci_platform_suspend,
409 ehci_platform_resume);
410
411static struct platform_driver ehci_platform_driver = {
412 .id_table = ehci_platform_table,
413 .probe = ehci_platform_probe,
414 .remove = ehci_platform_remove,
415 .shutdown = usb_hcd_platform_shutdown,
416 .driver = {
417 .name = "ehci-platform",
418 .pm = &ehci_platform_pm_ops,
419 .of_match_table = vt8500_ehci_ids,
420 .acpi_match_table = ACPI_PTR(ehci_acpi_match),
421 }
422};
423
424static int __init ehci_platform_init(void)
425{
426 if (usb_disabled())
427 return -ENODEV;
428
429 pr_info("%s: " DRIVER_DESC "\n", hcd_name);
430
431 ehci_init_driver(&ehci_platform_hc_driver, &platform_overrides);
432 return platform_driver_register(&ehci_platform_driver);
433}
434module_init(ehci_platform_init);
435
436static void __exit ehci_platform_cleanup(void)
437{
438 platform_driver_unregister(&ehci_platform_driver);
439}
440module_exit(ehci_platform_cleanup);
441
442MODULE_DESCRIPTION(DRIVER_DESC);
443MODULE_AUTHOR("Hauke Mehrtens");
444MODULE_AUTHOR("Alan Stern");
445MODULE_LICENSE("GPL");