Version:  2.0.40 2.2.26 2.4.37 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7

Linux/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 
290         err = usb_add_hcd(hcd, irq, IRQF_SHARED);
291         if (err)
292                 goto err_power;
293 
294         device_wakeup_enable(hcd->self.controller);
295         platform_set_drvdata(dev, hcd);
296 
297         return err;
298 
299 err_power:
300         if (pdata->power_off)
301                 pdata->power_off(dev);
302 err_reset:
303         if (priv->rst)
304                 reset_control_assert(priv->rst);
305 err_put_clks:
306         while (--clk >= 0)
307                 clk_put(priv->clks[clk]);
308 err_put_hcd:
309         if (pdata == &ehci_platform_defaults)
310                 dev->dev.platform_data = NULL;
311 
312         usb_put_hcd(hcd);
313 
314         return err;
315 }
316 
317 static int ehci_platform_remove(struct platform_device *dev)
318 {
319         struct usb_hcd *hcd = platform_get_drvdata(dev);
320         struct usb_ehci_pdata *pdata = dev_get_platdata(&dev->dev);
321         struct ehci_platform_priv *priv = hcd_to_ehci_priv(hcd);
322         int clk;
323 
324         usb_remove_hcd(hcd);
325 
326         if (pdata->power_off)
327                 pdata->power_off(dev);
328 
329         if (priv->rst)
330                 reset_control_assert(priv->rst);
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
344 static 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 
362 static 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 
369         if (pdata->power_on) {
370                 int err = pdata->power_on(pdev);
371                 if (err < 0)
372                         return err;
373         }
374 
375         ehci_resume(hcd, priv->reset_on_resume);
376         return 0;
377 }
378 #endif /* CONFIG_PM_SLEEP */
379 
380 static const struct of_device_id vt8500_ehci_ids[] = {
381         { .compatible = "via,vt8500-ehci", },
382         { .compatible = "wm,prizm-ehci", },
383         { .compatible = "generic-ehci", },
384         { .compatible = "cavium,octeon-6335-ehci", },
385         {}
386 };
387 MODULE_DEVICE_TABLE(of, vt8500_ehci_ids);
388 
389 static const struct acpi_device_id ehci_acpi_match[] = {
390         { "PNP0D20", 0 }, /* EHCI controller without debug */
391         { }
392 };
393 MODULE_DEVICE_TABLE(acpi, ehci_acpi_match);
394 
395 static const struct platform_device_id ehci_platform_table[] = {
396         { "ehci-platform", 0 },
397         { }
398 };
399 MODULE_DEVICE_TABLE(platform, ehci_platform_table);
400 
401 static SIMPLE_DEV_PM_OPS(ehci_platform_pm_ops, ehci_platform_suspend,
402         ehci_platform_resume);
403 
404 static struct platform_driver ehci_platform_driver = {
405         .id_table       = ehci_platform_table,
406         .probe          = ehci_platform_probe,
407         .remove         = ehci_platform_remove,
408         .shutdown       = usb_hcd_platform_shutdown,
409         .driver         = {
410                 .name   = "ehci-platform",
411                 .pm     = &ehci_platform_pm_ops,
412                 .of_match_table = vt8500_ehci_ids,
413                 .acpi_match_table = ACPI_PTR(ehci_acpi_match),
414         }
415 };
416 
417 static int __init ehci_platform_init(void)
418 {
419         if (usb_disabled())
420                 return -ENODEV;
421 
422         pr_info("%s: " DRIVER_DESC "\n", hcd_name);
423 
424         ehci_init_driver(&ehci_platform_hc_driver, &platform_overrides);
425         return platform_driver_register(&ehci_platform_driver);
426 }
427 module_init(ehci_platform_init);
428 
429 static void __exit ehci_platform_cleanup(void)
430 {
431         platform_driver_unregister(&ehci_platform_driver);
432 }
433 module_exit(ehci_platform_cleanup);
434 
435 MODULE_DESCRIPTION(DRIVER_DESC);
436 MODULE_AUTHOR("Hauke Mehrtens");
437 MODULE_AUTHOR("Alan Stern");
438 MODULE_LICENSE("GPL");
439 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us