Version:  2.0.40 2.2.26 2.4.37 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 4.8

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

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