1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * xhci-plat.c - xHCI host controller driver platform Bus Glue.
4 *
5 * Copyright (C) 2012 Texas Instruments Incorporated - https://www.ti.com
6 * Author: Sebastian Andrzej Siewior <bigeasy@linutronix.de>
7 *
8 * A lot of code borrowed from the Linux xHCI driver.
9 */
10
11 #include <linux/clk.h>
12 #include <linux/dma-mapping.h>
13 #include <linux/module.h>
14 #include <linux/pci.h>
15 #include <linux/of.h>
16 #include <linux/of_device.h>
17 #include <linux/platform_device.h>
18 #include <linux/usb/phy.h>
19 #include <linux/slab.h>
20 #include <linux/acpi.h>
21 #include <linux/usb/of.h>
22
23 #include "xhci.h"
24 #include "xhci-plat.h"
25 #include "xhci-mvebu.h"
26 #include "xhci-rcar.h"
27
28 static struct hc_driver __read_mostly xhci_plat_hc_driver;
29
30 static int xhci_plat_setup(struct usb_hcd *hcd);
31 static int xhci_plat_start(struct usb_hcd *hcd);
32
33 static const struct xhci_driver_overrides xhci_plat_overrides __initconst = {
34 .extra_priv_size = sizeof(struct xhci_plat_priv),
35 .reset = xhci_plat_setup,
36 .start = xhci_plat_start,
37 };
38
xhci_priv_plat_start(struct usb_hcd * hcd)39 static void xhci_priv_plat_start(struct usb_hcd *hcd)
40 {
41 struct xhci_plat_priv *priv = hcd_to_xhci_priv(hcd);
42
43 if (priv->plat_start)
44 priv->plat_start(hcd);
45 }
46
xhci_priv_plat_setup(struct usb_hcd * hcd)47 static int xhci_priv_plat_setup(struct usb_hcd *hcd)
48 {
49 struct xhci_plat_priv *priv = hcd_to_xhci_priv(hcd);
50
51 if (!priv->plat_setup)
52 return 0;
53
54 return priv->plat_setup(hcd);
55 }
56
xhci_priv_init_quirk(struct usb_hcd * hcd)57 static int xhci_priv_init_quirk(struct usb_hcd *hcd)
58 {
59 struct xhci_plat_priv *priv = hcd_to_xhci_priv(hcd);
60
61 if (!priv->init_quirk)
62 return 0;
63
64 return priv->init_quirk(hcd);
65 }
66
xhci_priv_suspend_quirk(struct usb_hcd * hcd)67 static int xhci_priv_suspend_quirk(struct usb_hcd *hcd)
68 {
69 struct xhci_plat_priv *priv = hcd_to_xhci_priv(hcd);
70
71 if (!priv->suspend_quirk)
72 return 0;
73
74 return priv->suspend_quirk(hcd);
75 }
76
xhci_priv_resume_quirk(struct usb_hcd * hcd)77 static int xhci_priv_resume_quirk(struct usb_hcd *hcd)
78 {
79 struct xhci_plat_priv *priv = hcd_to_xhci_priv(hcd);
80
81 if (!priv->resume_quirk)
82 return 0;
83
84 return priv->resume_quirk(hcd);
85 }
86
xhci_plat_quirks(struct device * dev,struct xhci_hcd * xhci)87 static void xhci_plat_quirks(struct device *dev, struct xhci_hcd *xhci)
88 {
89 struct xhci_plat_priv *priv = xhci_to_priv(xhci);
90
91 /*
92 * As of now platform drivers don't provide MSI support so we ensure
93 * here that the generic code does not try to make a pci_dev from our
94 * dev struct in order to setup MSI
95 */
96 xhci->quirks |= XHCI_PLAT | priv->quirks;
97 }
98
99 /* called during probe() after chip reset completes */
xhci_plat_setup(struct usb_hcd * hcd)100 static int xhci_plat_setup(struct usb_hcd *hcd)
101 {
102 int ret;
103
104
105 ret = xhci_priv_init_quirk(hcd);
106 if (ret)
107 return ret;
108
109 return xhci_gen_setup(hcd, xhci_plat_quirks);
110 }
111
xhci_plat_start(struct usb_hcd * hcd)112 static int xhci_plat_start(struct usb_hcd *hcd)
113 {
114 xhci_priv_plat_start(hcd);
115 return xhci_run(hcd);
116 }
117
118 #ifdef CONFIG_OF
119 static const struct xhci_plat_priv xhci_plat_marvell_armada = {
120 .init_quirk = xhci_mvebu_mbus_init_quirk,
121 };
122
123 static const struct xhci_plat_priv xhci_plat_marvell_armada3700 = {
124 .plat_setup = xhci_mvebu_a3700_plat_setup,
125 .init_quirk = xhci_mvebu_a3700_init_quirk,
126 };
127
128 static const struct xhci_plat_priv xhci_plat_renesas_rcar_gen2 = {
129 SET_XHCI_PLAT_PRIV_FOR_RCAR(XHCI_RCAR_FIRMWARE_NAME_V1)
130 };
131
132 static const struct xhci_plat_priv xhci_plat_renesas_rcar_gen3 = {
133 SET_XHCI_PLAT_PRIV_FOR_RCAR(XHCI_RCAR_FIRMWARE_NAME_V3)
134 };
135
136 static const struct xhci_plat_priv xhci_plat_brcm = {
137 .quirks = XHCI_RESET_ON_RESUME | XHCI_SUSPEND_RESUME_CLKS,
138 };
139
140 static const struct of_device_id usb_xhci_of_match[] = {
141 {
142 .compatible = "generic-xhci",
143 }, {
144 .compatible = "xhci-platform",
145 #ifndef CONFIG_ARCH_ROCKCHIP
146 }, {
147 .compatible = "marvell,armada-375-xhci",
148 .data = &xhci_plat_marvell_armada,
149 }, {
150 .compatible = "marvell,armada-380-xhci",
151 .data = &xhci_plat_marvell_armada,
152 }, {
153 .compatible = "marvell,armada3700-xhci",
154 .data = &xhci_plat_marvell_armada3700,
155 }, {
156 .compatible = "renesas,xhci-r8a7790",
157 .data = &xhci_plat_renesas_rcar_gen2,
158 }, {
159 .compatible = "renesas,xhci-r8a7791",
160 .data = &xhci_plat_renesas_rcar_gen2,
161 }, {
162 .compatible = "renesas,xhci-r8a7793",
163 .data = &xhci_plat_renesas_rcar_gen2,
164 }, {
165 .compatible = "renesas,xhci-r8a7795",
166 .data = &xhci_plat_renesas_rcar_gen3,
167 }, {
168 .compatible = "renesas,xhci-r8a7796",
169 .data = &xhci_plat_renesas_rcar_gen3,
170 }, {
171 .compatible = "renesas,rcar-gen2-xhci",
172 .data = &xhci_plat_renesas_rcar_gen2,
173 }, {
174 .compatible = "renesas,rcar-gen3-xhci",
175 .data = &xhci_plat_renesas_rcar_gen3,
176 }, {
177 .compatible = "brcm,xhci-brcm-v2",
178 .data = &xhci_plat_brcm,
179 }, {
180 .compatible = "brcm,bcm7445-xhci",
181 .data = &xhci_plat_brcm,
182 #endif
183 },
184 {},
185 };
186 MODULE_DEVICE_TABLE(of, usb_xhci_of_match);
187 #endif
188
189 static struct xhci_plat_priv_overwrite xhci_plat_vendor_overwrite;
190
xhci_plat_register_vendor_ops(struct xhci_vendor_ops * vendor_ops)191 int xhci_plat_register_vendor_ops(struct xhci_vendor_ops *vendor_ops)
192 {
193 if (vendor_ops == NULL)
194 return -EINVAL;
195
196 xhci_plat_vendor_overwrite.vendor_ops = vendor_ops;
197
198 return 0;
199 }
200 EXPORT_SYMBOL_GPL(xhci_plat_register_vendor_ops);
201
xhci_vendor_init(struct xhci_hcd * xhci)202 static int xhci_vendor_init(struct xhci_hcd *xhci)
203 {
204 struct xhci_vendor_ops *ops = NULL;
205
206 if (xhci_plat_vendor_overwrite.vendor_ops)
207 ops = xhci->vendor_ops = xhci_plat_vendor_overwrite.vendor_ops;
208
209 if (ops && ops->vendor_init)
210 return ops->vendor_init(xhci);
211 return 0;
212 }
213
xhci_vendor_cleanup(struct xhci_hcd * xhci)214 static void xhci_vendor_cleanup(struct xhci_hcd *xhci)
215 {
216 struct xhci_vendor_ops *ops = xhci_vendor_get_ops(xhci);
217
218 if (ops && ops->vendor_cleanup)
219 ops->vendor_cleanup(xhci);
220
221 xhci->vendor_ops = NULL;
222 }
223
xhci_plat_probe(struct platform_device * pdev)224 static int xhci_plat_probe(struct platform_device *pdev)
225 {
226 const struct xhci_plat_priv *priv_match;
227 const struct hc_driver *driver;
228 struct device *sysdev, *tmpdev;
229 struct xhci_hcd *xhci;
230 struct resource *res;
231 struct usb_hcd *hcd;
232 int ret;
233 int irq;
234 struct xhci_plat_priv *priv = NULL;
235
236
237 if (usb_disabled())
238 return -ENODEV;
239
240 driver = &xhci_plat_hc_driver;
241
242 irq = platform_get_irq(pdev, 0);
243 if (irq < 0)
244 return irq;
245
246 /*
247 * sysdev must point to a device that is known to the system firmware
248 * or PCI hardware. We handle these three cases here:
249 * 1. xhci_plat comes from firmware
250 * 2. xhci_plat is child of a device from firmware (dwc3-plat)
251 * 3. xhci_plat is grandchild of a pci device (dwc3-pci)
252 */
253 for (sysdev = &pdev->dev; sysdev; sysdev = sysdev->parent) {
254 if (is_of_node(sysdev->fwnode) ||
255 is_acpi_device_node(sysdev->fwnode))
256 break;
257 #ifdef CONFIG_PCI
258 else if (sysdev->bus == &pci_bus_type)
259 break;
260 #endif
261 }
262
263 if (!sysdev)
264 sysdev = &pdev->dev;
265
266 /* Try to set 64-bit DMA first */
267 if (WARN_ON(!sysdev->dma_mask))
268 /* Platform did not initialize dma_mask */
269 ret = dma_coerce_mask_and_coherent(sysdev,
270 DMA_BIT_MASK(64));
271 else
272 ret = dma_set_mask_and_coherent(sysdev, DMA_BIT_MASK(64));
273
274 /* If seting 64-bit DMA mask fails, fall back to 32-bit DMA mask */
275 if (ret) {
276 ret = dma_set_mask_and_coherent(sysdev, DMA_BIT_MASK(32));
277 if (ret)
278 return ret;
279 }
280
281 pm_runtime_set_active(&pdev->dev);
282 pm_runtime_enable(&pdev->dev);
283 pm_runtime_get_noresume(&pdev->dev);
284
285 hcd = __usb_create_hcd(driver, sysdev, &pdev->dev,
286 dev_name(&pdev->dev), NULL);
287 if (!hcd) {
288 ret = -ENOMEM;
289 goto disable_runtime;
290 }
291
292 hcd->regs = devm_platform_get_and_ioremap_resource(pdev, 0, &res);
293 if (IS_ERR(hcd->regs)) {
294 ret = PTR_ERR(hcd->regs);
295 goto put_hcd;
296 }
297
298 hcd->rsrc_start = res->start;
299 hcd->rsrc_len = resource_size(res);
300
301 xhci = hcd_to_xhci(hcd);
302
303 /*
304 * Not all platforms have clks so it is not an error if the
305 * clock do not exist.
306 */
307 xhci->reg_clk = devm_clk_get_optional(&pdev->dev, "reg");
308 if (IS_ERR(xhci->reg_clk)) {
309 ret = PTR_ERR(xhci->reg_clk);
310 goto put_hcd;
311 }
312
313 ret = clk_prepare_enable(xhci->reg_clk);
314 if (ret)
315 goto put_hcd;
316
317 xhci->clk = devm_clk_get_optional(&pdev->dev, NULL);
318 if (IS_ERR(xhci->clk)) {
319 ret = PTR_ERR(xhci->clk);
320 goto disable_reg_clk;
321 }
322
323 ret = clk_prepare_enable(xhci->clk);
324 if (ret)
325 goto disable_reg_clk;
326
327 if (pdev->dev.of_node)
328 priv_match = of_device_get_match_data(&pdev->dev);
329 else
330 priv_match = dev_get_platdata(&pdev->dev);
331
332 if (priv_match) {
333 priv = hcd_to_xhci_priv(hcd);
334 /* Just copy data for now */
335 *priv = *priv_match;
336 }
337
338 device_set_wakeup_capable(&pdev->dev, true);
339
340 xhci->main_hcd = hcd;
341 xhci->shared_hcd = __usb_create_hcd(driver, sysdev, &pdev->dev,
342 dev_name(&pdev->dev), hcd);
343 if (!xhci->shared_hcd) {
344 ret = -ENOMEM;
345 goto disable_clk;
346 }
347
348 /* imod_interval is the interrupt moderation value in nanoseconds. */
349 xhci->imod_interval = 40000;
350
351 /* Iterate over all parent nodes for finding quirks */
352 for (tmpdev = &pdev->dev; tmpdev; tmpdev = tmpdev->parent) {
353
354 if (device_property_read_bool(tmpdev, "usb2-lpm-disable"))
355 xhci->quirks |= XHCI_HW_LPM_DISABLE;
356
357 if (device_property_read_bool(tmpdev, "usb3-lpm-capable"))
358 xhci->quirks |= XHCI_LPM_SUPPORT;
359
360 if (device_property_read_bool(tmpdev, "quirk-broken-port-ped"))
361 xhci->quirks |= XHCI_BROKEN_PORT_PED;
362
363 if (device_property_read_bool(tmpdev, "quirk-skip-phy-init"))
364 xhci->quirks |= XHCI_SKIP_PHY_INIT;
365
366 if (device_property_read_bool(tmpdev,
367 "xhci-u2-broken-suspend"))
368 xhci->quirks |= XHCI_U2_BROKEN_SUSPEND;
369
370 device_property_read_u32(tmpdev, "imod-interval-ns",
371 &xhci->imod_interval);
372 }
373
374 hcd->usb_phy = devm_usb_get_phy_by_phandle(sysdev, "usb-phy", 0);
375 if (IS_ERR(hcd->usb_phy)) {
376 ret = PTR_ERR(hcd->usb_phy);
377 if (ret == -EPROBE_DEFER)
378 goto put_usb3_hcd;
379 hcd->usb_phy = NULL;
380 } else {
381 ret = usb_phy_init(hcd->usb_phy);
382 if (ret)
383 goto put_usb3_hcd;
384 }
385
386 ret = xhci_vendor_init(xhci);
387 if (ret)
388 goto disable_usb_phy;
389
390 hcd->tpl_support = of_usb_host_tpl_support(sysdev->of_node);
391 xhci->shared_hcd->tpl_support = hcd->tpl_support;
392
393 if (priv) {
394 ret = xhci_priv_plat_setup(hcd);
395 if (ret)
396 goto disable_usb_phy;
397 }
398
399 if ((xhci->quirks & XHCI_SKIP_PHY_INIT) || (priv && (priv->quirks & XHCI_SKIP_PHY_INIT)))
400 hcd->skip_phy_initialization = 1;
401
402 if (priv && (priv->quirks & XHCI_SG_TRB_CACHE_SIZE_QUIRK))
403 xhci->quirks |= XHCI_SG_TRB_CACHE_SIZE_QUIRK;
404
405 ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
406 if (ret)
407 goto disable_usb_phy;
408
409 if (HCC_MAX_PSA(xhci->hcc_params) >= 4)
410 xhci->shared_hcd->can_do_streams = 1;
411
412 ret = usb_add_hcd(xhci->shared_hcd, irq, IRQF_SHARED);
413 if (ret)
414 goto dealloc_usb2_hcd;
415
416 device_enable_async_suspend(&pdev->dev);
417 pm_runtime_put_noidle(&pdev->dev);
418
419 /*
420 * Prevent runtime pm from being on as default, users should enable
421 * runtime pm using power/control in sysfs.
422 */
423 pm_runtime_forbid(&pdev->dev);
424
425 return 0;
426
427
428 dealloc_usb2_hcd:
429 usb_remove_hcd(hcd);
430
431 disable_usb_phy:
432 usb_phy_shutdown(hcd->usb_phy);
433
434 put_usb3_hcd:
435 usb_put_hcd(xhci->shared_hcd);
436
437 disable_clk:
438 clk_disable_unprepare(xhci->clk);
439
440 disable_reg_clk:
441 clk_disable_unprepare(xhci->reg_clk);
442
443 put_hcd:
444 usb_put_hcd(hcd);
445
446 disable_runtime:
447 pm_runtime_put_noidle(&pdev->dev);
448 pm_runtime_disable(&pdev->dev);
449
450 return ret;
451 }
452
xhci_plat_remove(struct platform_device * dev)453 static int xhci_plat_remove(struct platform_device *dev)
454 {
455 struct usb_hcd *hcd = platform_get_drvdata(dev);
456 struct xhci_hcd *xhci = hcd_to_xhci(hcd);
457 struct clk *clk = xhci->clk;
458 struct clk *reg_clk = xhci->reg_clk;
459 struct usb_hcd *shared_hcd = xhci->shared_hcd;
460
461 pm_runtime_get_sync(&dev->dev);
462 xhci->xhc_state |= XHCI_STATE_REMOVING;
463
464 usb_remove_hcd(shared_hcd);
465 xhci->shared_hcd = NULL;
466 usb_phy_shutdown(hcd->usb_phy);
467
468 usb_remove_hcd(hcd);
469
470 xhci_vendor_cleanup(xhci);
471
472 usb_put_hcd(shared_hcd);
473 clk_disable_unprepare(clk);
474 clk_disable_unprepare(reg_clk);
475 usb_put_hcd(hcd);
476
477 pm_runtime_disable(&dev->dev);
478 pm_runtime_put_noidle(&dev->dev);
479 pm_runtime_set_suspended(&dev->dev);
480
481 return 0;
482 }
483
xhci_plat_suspend(struct device * dev)484 static int __maybe_unused xhci_plat_suspend(struct device *dev)
485 {
486 struct usb_hcd *hcd = dev_get_drvdata(dev);
487 struct xhci_hcd *xhci = hcd_to_xhci(hcd);
488 int ret;
489
490 if (pm_runtime_suspended(dev))
491 pm_runtime_resume(dev);
492
493 ret = xhci_priv_suspend_quirk(hcd);
494 if (ret)
495 return ret;
496 /*
497 * xhci_suspend() needs `do_wakeup` to know whether host is allowed
498 * to do wakeup during suspend.
499 */
500 ret = xhci_suspend(xhci, device_may_wakeup(dev));
501 if (ret)
502 return ret;
503
504 if (!device_may_wakeup(dev) && (xhci->quirks & XHCI_SUSPEND_RESUME_CLKS)) {
505 clk_disable_unprepare(xhci->clk);
506 clk_disable_unprepare(xhci->reg_clk);
507 }
508
509 return 0;
510 }
511
xhci_plat_resume(struct device * dev)512 static int __maybe_unused xhci_plat_resume(struct device *dev)
513 {
514 struct usb_hcd *hcd = dev_get_drvdata(dev);
515 struct xhci_hcd *xhci = hcd_to_xhci(hcd);
516 int ret;
517
518 if (!device_may_wakeup(dev) && (xhci->quirks & XHCI_SUSPEND_RESUME_CLKS)) {
519 clk_prepare_enable(xhci->clk);
520 clk_prepare_enable(xhci->reg_clk);
521 }
522
523 ret = xhci_priv_resume_quirk(hcd);
524 if (ret)
525 return ret;
526
527 ret = xhci_resume(xhci, 0);
528 if (ret)
529 return ret;
530
531 pm_runtime_disable(dev);
532 pm_runtime_set_active(dev);
533 pm_runtime_enable(dev);
534
535 return 0;
536 }
537
xhci_plat_runtime_suspend(struct device * dev)538 static int __maybe_unused xhci_plat_runtime_suspend(struct device *dev)
539 {
540 struct usb_hcd *hcd = dev_get_drvdata(dev);
541 struct xhci_hcd *xhci = hcd_to_xhci(hcd);
542 int ret;
543
544 ret = xhci_priv_suspend_quirk(hcd);
545 if (ret)
546 return ret;
547
548 return xhci_suspend(xhci, true);
549 }
550
xhci_plat_runtime_resume(struct device * dev)551 static int __maybe_unused xhci_plat_runtime_resume(struct device *dev)
552 {
553 struct usb_hcd *hcd = dev_get_drvdata(dev);
554 struct xhci_hcd *xhci = hcd_to_xhci(hcd);
555
556 return xhci_resume(xhci, 0);
557 }
558
559 static const struct dev_pm_ops xhci_plat_pm_ops = {
560 SET_SYSTEM_SLEEP_PM_OPS(xhci_plat_suspend, xhci_plat_resume)
561
562 SET_RUNTIME_PM_OPS(xhci_plat_runtime_suspend,
563 xhci_plat_runtime_resume,
564 NULL)
565 };
566
567 #ifdef CONFIG_ACPI
568 static const struct acpi_device_id usb_xhci_acpi_match[] = {
569 /* XHCI-compliant USB Controller */
570 { "PNP0D10", },
571 { }
572 };
573 MODULE_DEVICE_TABLE(acpi, usb_xhci_acpi_match);
574 #endif
575
576 static struct platform_driver usb_xhci_driver = {
577 .probe = xhci_plat_probe,
578 .remove = xhci_plat_remove,
579 .shutdown = usb_hcd_platform_shutdown,
580 .driver = {
581 .name = "xhci-hcd",
582 .pm = &xhci_plat_pm_ops,
583 .of_match_table = of_match_ptr(usb_xhci_of_match),
584 .acpi_match_table = ACPI_PTR(usb_xhci_acpi_match),
585 },
586 };
587 MODULE_ALIAS("platform:xhci-hcd");
588
xhci_plat_init(void)589 static int __init xhci_plat_init(void)
590 {
591 xhci_init_driver(&xhci_plat_hc_driver, &xhci_plat_overrides);
592 return platform_driver_register(&usb_xhci_driver);
593 }
594 module_init(xhci_plat_init);
595
xhci_plat_exit(void)596 static void __exit xhci_plat_exit(void)
597 {
598 platform_driver_unregister(&usb_xhci_driver);
599 }
600 module_exit(xhci_plat_exit);
601
602 MODULE_DESCRIPTION("xHCI Platform Host Controller Driver");
603 MODULE_LICENSE("GPL");
604