6f69798e3452589c328f98db986d58d675a04a02
[firefly-linux-kernel-4.4.55.git] / drivers / usb / host / ehci-platform.c
1 /*
2  * Generic platform ehci driver
3  *
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>
7  *
8  * Derived from the ohci-ssb driver
9  * Copyright 2007 Michael Buesch <m@bues.ch>
10  *
11  * Derived from the EHCI-PCI driver
12  * Copyright (c) 2000-2004 by David Brownell
13  *
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
19  *
20  * Licensed under the GNU/GPL. See COPYING for details.
21  */
22 #include <linux/acpi.h>
23 #include <linux/clk.h>
24 #include <linux/dma-mapping.h>
25 #include <linux/err.h>
26 #include <linux/kernel.h>
27 #include <linux/hrtimer.h>
28 #include <linux/io.h>
29 #include <linux/module.h>
30 #include <linux/of.h>
31 #include <linux/phy/phy.h>
32 #include <linux/platform_device.h>
33 #include <linux/reset.h>
34 #include <linux/usb.h>
35 #include <linux/usb/hcd.h>
36 #include <linux/usb/ehci_pdriver.h>
37
38 #include "ehci.h"
39
40 #define DRIVER_DESC "EHCI generic platform driver"
41 #define EHCI_MAX_CLKS 3
42 #define hcd_to_ehci_priv(h) ((struct ehci_platform_priv *)hcd_to_ehci(h)->priv)
43
44 struct ehci_platform_priv {
45         struct clk *clks[EHCI_MAX_CLKS];
46         struct reset_control *rst;
47         struct phy **phys;
48         int num_phys;
49         bool reset_on_resume;
50 };
51
52 static const char hcd_name[] = "ehci-platform";
53
54 static 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
79 static 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
104 err_exit_phy:
105         while (--phy_num >= 0) {
106                 phy_power_off(priv->phys[phy_num]);
107                 phy_exit(priv->phys[phy_num]);
108         }
109 err_disable_clks:
110         while (--clk >= 0)
111                 clk_disable_unprepare(priv->clks[clk]);
112
113         return ret;
114 }
115
116 static 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
132 static struct hc_driver __read_mostly ehci_platform_hc_driver;
133
134 static const struct ehci_driver_overrides platform_overrides __initconst = {
135         .reset =                ehci_platform_reset,
136         .extra_priv_size =      sizeof(struct ehci_platform_priv),
137 };
138
139 static 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
145 static 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                         }
223                 }
224
225                 for (clk = 0; clk < EHCI_MAX_CLKS; clk++) {
226                         priv->clks[clk] = of_clk_get(dev->dev.of_node, clk);
227                         if (IS_ERR(priv->clks[clk])) {
228                                 err = PTR_ERR(priv->clks[clk]);
229                                 if (err == -EPROBE_DEFER)
230                                         goto err_put_clks;
231                                 priv->clks[clk] = NULL;
232                                 break;
233                         }
234                 }
235         }
236
237         priv->rst = devm_reset_control_get_optional(&dev->dev, NULL);
238         if (IS_ERR(priv->rst)) {
239                 err = PTR_ERR(priv->rst);
240                 if (err == -EPROBE_DEFER)
241                         goto err_put_clks;
242                 priv->rst = NULL;
243         } else {
244                 err = reset_control_deassert(priv->rst);
245                 if (err)
246                         goto err_put_clks;
247         }
248
249         if (pdata->big_endian_desc)
250                 ehci->big_endian_desc = 1;
251         if (pdata->big_endian_mmio)
252                 ehci->big_endian_mmio = 1;
253         if (pdata->has_tt)
254                 hcd->has_tt = 1;
255         if (pdata->reset_on_resume)
256                 priv->reset_on_resume = true;
257
258 #ifndef CONFIG_USB_EHCI_BIG_ENDIAN_MMIO
259         if (ehci->big_endian_mmio) {
260                 dev_err(&dev->dev,
261                         "Error: CONFIG_USB_EHCI_BIG_ENDIAN_MMIO not set\n");
262                 err = -EINVAL;
263                 goto err_reset;
264         }
265 #endif
266 #ifndef CONFIG_USB_EHCI_BIG_ENDIAN_DESC
267         if (ehci->big_endian_desc) {
268                 dev_err(&dev->dev,
269                         "Error: CONFIG_USB_EHCI_BIG_ENDIAN_DESC not set\n");
270                 err = -EINVAL;
271                 goto err_reset;
272         }
273 #endif
274
275         if (pdata->power_on) {
276                 err = pdata->power_on(dev);
277                 if (err < 0)
278                         goto err_reset;
279         }
280
281         res_mem = platform_get_resource(dev, IORESOURCE_MEM, 0);
282         hcd->regs = devm_ioremap_resource(&dev->dev, res_mem);
283         if (IS_ERR(hcd->regs)) {
284                 err = PTR_ERR(hcd->regs);
285                 goto err_power;
286         }
287         hcd->rsrc_start = res_mem->start;
288         hcd->rsrc_len = resource_size(res_mem);
289         if (priv->num_phys == 1)
290                 hcd->phy = priv->phys[0];
291
292         err = usb_add_hcd(hcd, irq, IRQF_SHARED);
293         if (err)
294                 goto err_power;
295
296         device_wakeup_enable(hcd->self.controller);
297         platform_set_drvdata(dev, hcd);
298
299         return err;
300
301 err_power:
302         if (pdata->power_off)
303                 pdata->power_off(dev);
304 err_reset:
305         if (priv->rst)
306                 reset_control_assert(priv->rst);
307 err_put_clks:
308         while (--clk >= 0)
309                 clk_put(priv->clks[clk]);
310 err_put_hcd:
311         if (pdata == &ehci_platform_defaults)
312                 dev->dev.platform_data = NULL;
313
314         usb_put_hcd(hcd);
315
316         return err;
317 }
318
319 static int ehci_platform_remove(struct platform_device *dev)
320 {
321         struct usb_hcd *hcd = platform_get_drvdata(dev);
322         struct usb_ehci_pdata *pdata = dev_get_platdata(&dev->dev);
323         struct ehci_platform_priv *priv = hcd_to_ehci_priv(hcd);
324         int clk;
325
326         usb_remove_hcd(hcd);
327
328         if (pdata->power_off)
329                 pdata->power_off(dev);
330
331         if (priv->rst)
332                 reset_control_assert(priv->rst);
333
334         for (clk = 0; clk < EHCI_MAX_CLKS && priv->clks[clk]; clk++)
335                 clk_put(priv->clks[clk]);
336
337         usb_put_hcd(hcd);
338
339         if (pdata == &ehci_platform_defaults)
340                 dev->dev.platform_data = NULL;
341
342         return 0;
343 }
344
345 #ifdef CONFIG_PM_SLEEP
346 static int ehci_platform_suspend(struct device *dev)
347 {
348         struct usb_hcd *hcd = dev_get_drvdata(dev);
349         struct usb_ehci_pdata *pdata = dev_get_platdata(dev);
350         struct platform_device *pdev =
351                 container_of(dev, struct platform_device, dev);
352         bool do_wakeup = device_may_wakeup(dev);
353         int ret;
354
355         ret = ehci_suspend(hcd, do_wakeup);
356         if (ret)
357                 return ret;
358
359         if (pdata->power_suspend)
360                 pdata->power_suspend(pdev);
361
362         return ret;
363 }
364
365 static int ehci_platform_resume(struct device *dev)
366 {
367         struct usb_hcd *hcd = dev_get_drvdata(dev);
368         struct usb_ehci_pdata *pdata = dev_get_platdata(dev);
369         struct platform_device *pdev =
370                 container_of(dev, struct platform_device, dev);
371         struct ehci_platform_priv *priv = hcd_to_ehci_priv(hcd);
372
373         if (pdata->power_on) {
374                 int err = pdata->power_on(pdev);
375                 if (err < 0)
376                         return err;
377         }
378
379         ehci_resume(hcd, priv->reset_on_resume);
380         return 0;
381 }
382 #endif /* CONFIG_PM_SLEEP */
383
384 static const struct of_device_id vt8500_ehci_ids[] = {
385         { .compatible = "via,vt8500-ehci", },
386         { .compatible = "wm,prizm-ehci", },
387         { .compatible = "generic-ehci", },
388         { .compatible = "cavium,octeon-6335-ehci", },
389         {}
390 };
391 MODULE_DEVICE_TABLE(of, vt8500_ehci_ids);
392
393 static const struct acpi_device_id ehci_acpi_match[] = {
394         { "PNP0D20", 0 }, /* EHCI controller without debug */
395         { }
396 };
397 MODULE_DEVICE_TABLE(acpi, ehci_acpi_match);
398
399 static const struct platform_device_id ehci_platform_table[] = {
400         { "ehci-platform", 0 },
401         { }
402 };
403 MODULE_DEVICE_TABLE(platform, ehci_platform_table);
404
405 static SIMPLE_DEV_PM_OPS(ehci_platform_pm_ops, ehci_platform_suspend,
406         ehci_platform_resume);
407
408 static struct platform_driver ehci_platform_driver = {
409         .id_table       = ehci_platform_table,
410         .probe          = ehci_platform_probe,
411         .remove         = ehci_platform_remove,
412         .shutdown       = usb_hcd_platform_shutdown,
413         .driver         = {
414                 .name   = "ehci-platform",
415                 .pm     = &ehci_platform_pm_ops,
416                 .of_match_table = vt8500_ehci_ids,
417                 .acpi_match_table = ACPI_PTR(ehci_acpi_match),
418         }
419 };
420
421 static int __init ehci_platform_init(void)
422 {
423         if (usb_disabled())
424                 return -ENODEV;
425
426         pr_info("%s: " DRIVER_DESC "\n", hcd_name);
427
428         ehci_init_driver(&ehci_platform_hc_driver, &platform_overrides);
429         return platform_driver_register(&ehci_platform_driver);
430 }
431 module_init(ehci_platform_init);
432
433 static void __exit ehci_platform_cleanup(void)
434 {
435         platform_driver_unregister(&ehci_platform_driver);
436 }
437 module_exit(ehci_platform_cleanup);
438
439 MODULE_DESCRIPTION(DRIVER_DESC);
440 MODULE_AUTHOR("Hauke Mehrtens");
441 MODULE_AUTHOR("Alan Stern");
442 MODULE_LICENSE("GPL");