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