1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Generic platform ehci driver 4 * 5 * Copyright 2007 Steven Brown <sbrown@cortland.com> 6 * Copyright 2010-2012 Hauke Mehrtens <hauke@hauke-m.de> 7 * Copyright 2014 Hans de Goede <hdegoede@redhat.com> 8 * 9 * Derived from the ohci-ssb driver 10 * Copyright 2007 Michael Buesch <m@bues.ch> 11 * 12 * Derived from the EHCI-PCI driver 13 * Copyright (c) 2000-2004 by David Brownell 14 * 15 * Derived from the ohci-pci driver 16 * Copyright 1999 Roman Weissgaerber 17 * Copyright 2000-2002 David Brownell 18 * Copyright 1999 Linus Torvalds 19 * Copyright 1999 Gregory P. Smith 20 */ 21 #include <linux/acpi.h> 22 #include <linux/clk.h> 23 #include <linux/dma-mapping.h> 24 #include <linux/err.h> 25 #include <linux/kernel.h> 26 #include <linux/hrtimer.h> 27 #include <linux/io.h> 28 #include <linux/module.h> 29 #include <linux/of.h> 30 #include <linux/platform_device.h> 31 #include <linux/reset.h> 32 #include <linux/sys_soc.h> 33 #include <linux/timer.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 hcd_to_ehci_priv(h) ((struct ehci_platform_priv *)hcd_to_ehci(h)->priv) 44 45 #define BCM_USB_FIFO_THRESHOLD 0x00800040 46 47 struct ehci_platform_priv { 48 struct clk *clks[EHCI_MAX_CLKS]; 49 struct reset_control *rsts; 50 bool reset_on_resume; 51 bool quirk_poll; 52 struct timer_list poll_timer; 53 struct delayed_work poll_work; 54 }; 55 56 static const char hcd_name[] = "ehci-platform"; 57 58 static int ehci_platform_reset(struct usb_hcd *hcd) 59 { 60 struct platform_device *pdev = to_platform_device(hcd->self.controller); 61 struct usb_ehci_pdata *pdata = dev_get_platdata(&pdev->dev); 62 struct ehci_hcd *ehci = hcd_to_ehci(hcd); 63 int retval; 64 65 ehci->has_synopsys_hc_bug = pdata->has_synopsys_hc_bug; 66 67 if (pdata->pre_setup) { 68 retval = pdata->pre_setup(hcd); 69 if (retval < 0) 70 return retval; 71 } 72 73 ehci->caps = hcd->regs + pdata->caps_offset; 74 retval = ehci_setup(hcd); 75 if (retval) 76 return retval; 77 78 if (pdata->no_io_watchdog) 79 ehci->need_io_watchdog = 0; 80 81 if (of_device_is_compatible(pdev->dev.of_node, "brcm,xgs-iproc-ehci")) 82 ehci_writel(ehci, BCM_USB_FIFO_THRESHOLD, 83 &ehci->regs->brcm_insnreg[1]); 84 85 return 0; 86 } 87 88 static int ehci_platform_power_on(struct platform_device *dev) 89 { 90 struct usb_hcd *hcd = platform_get_drvdata(dev); 91 struct ehci_platform_priv *priv = hcd_to_ehci_priv(hcd); 92 int clk, ret; 93 94 for (clk = 0; clk < EHCI_MAX_CLKS && priv->clks[clk]; clk++) { 95 ret = clk_prepare_enable(priv->clks[clk]); 96 if (ret) 97 goto err_disable_clks; 98 } 99 100 return 0; 101 102 err_disable_clks: 103 while (--clk >= 0) 104 clk_disable_unprepare(priv->clks[clk]); 105 106 return ret; 107 } 108 109 static void ehci_platform_power_off(struct platform_device *dev) 110 { 111 struct usb_hcd *hcd = platform_get_drvdata(dev); 112 struct ehci_platform_priv *priv = hcd_to_ehci_priv(hcd); 113 int clk; 114 115 for (clk = EHCI_MAX_CLKS - 1; clk >= 0; clk--) 116 if (priv->clks[clk]) 117 clk_disable_unprepare(priv->clks[clk]); 118 } 119 120 static struct hc_driver __read_mostly ehci_platform_hc_driver; 121 122 static const struct ehci_driver_overrides platform_overrides __initconst = { 123 .reset = ehci_platform_reset, 124 .extra_priv_size = sizeof(struct ehci_platform_priv), 125 }; 126 127 static struct usb_ehci_pdata ehci_platform_defaults = { 128 .power_on = ehci_platform_power_on, 129 .power_suspend = ehci_platform_power_off, 130 .power_off = ehci_platform_power_off, 131 }; 132 133 /** 134 * quirk_poll_check_port_status - Poll port_status if the device sticks 135 * @ehci: the ehci hcd pointer 136 * 137 * Since EHCI/OHCI controllers on R-Car Gen3 SoCs are possible to be getting 138 * stuck very rarely after a full/low usb device was disconnected. To 139 * detect such a situation, the controllers require a special way which poll 140 * the EHCI PORTSC register. 141 * 142 * Return: true if the controller's port_status indicated getting stuck 143 */ 144 static bool quirk_poll_check_port_status(struct ehci_hcd *ehci) 145 { 146 u32 port_status = ehci_readl(ehci, &ehci->regs->port_status[0]); 147 148 if (!(port_status & PORT_OWNER) && 149 (port_status & PORT_POWER) && 150 !(port_status & PORT_CONNECT) && 151 (port_status & PORT_LS_MASK)) 152 return true; 153 154 return false; 155 } 156 157 /** 158 * quirk_poll_rebind_companion - rebind comanion device to recover 159 * @ehci: the ehci hcd pointer 160 * 161 * Since EHCI/OHCI controllers on R-Car Gen3 SoCs are possible to be getting 162 * stuck very rarely after a full/low usb device was disconnected. To 163 * recover from such a situation, the controllers require changing the OHCI 164 * functional state. 165 */ 166 static void quirk_poll_rebind_companion(struct ehci_hcd *ehci) 167 { 168 struct device *companion_dev; 169 struct usb_hcd *hcd = ehci_to_hcd(ehci); 170 171 companion_dev = usb_of_get_companion_dev(hcd->self.controller); 172 if (!companion_dev) 173 return; 174 175 device_release_driver(companion_dev); 176 if (device_attach(companion_dev) < 0) 177 ehci_err(ehci, "%s: failed\n", __func__); 178 179 put_device(companion_dev); 180 } 181 182 static void quirk_poll_work(struct work_struct *work) 183 { 184 struct ehci_platform_priv *priv = 185 container_of(to_delayed_work(work), struct ehci_platform_priv, 186 poll_work); 187 struct ehci_hcd *ehci = container_of((void *)priv, struct ehci_hcd, 188 priv); 189 190 /* check the status twice to reduce misdetection rate */ 191 if (!quirk_poll_check_port_status(ehci)) 192 return; 193 udelay(10); 194 if (!quirk_poll_check_port_status(ehci)) 195 return; 196 197 ehci_dbg(ehci, "%s: detected getting stuck. rebind now!\n", __func__); 198 quirk_poll_rebind_companion(ehci); 199 } 200 201 static void quirk_poll_timer(struct timer_list *t) 202 { 203 struct ehci_platform_priv *priv = from_timer(priv, t, poll_timer); 204 struct ehci_hcd *ehci = container_of((void *)priv, struct ehci_hcd, 205 priv); 206 207 if (quirk_poll_check_port_status(ehci)) { 208 /* 209 * Now scheduling the work for testing the port more. Note that 210 * updating the status is possible to be delayed when 211 * reconnection. So, this uses delayed work with 5 ms delay 212 * to avoid misdetection. 213 */ 214 schedule_delayed_work(&priv->poll_work, msecs_to_jiffies(5)); 215 } 216 217 mod_timer(&priv->poll_timer, jiffies + HZ); 218 } 219 220 static void quirk_poll_init(struct ehci_platform_priv *priv) 221 { 222 INIT_DELAYED_WORK(&priv->poll_work, quirk_poll_work); 223 timer_setup(&priv->poll_timer, quirk_poll_timer, 0); 224 mod_timer(&priv->poll_timer, jiffies + HZ); 225 } 226 227 static void quirk_poll_end(struct ehci_platform_priv *priv) 228 { 229 del_timer_sync(&priv->poll_timer); 230 cancel_delayed_work(&priv->poll_work); 231 } 232 233 static const struct soc_device_attribute quirk_poll_match[] = { 234 { .family = "R-Car Gen3" }, 235 { /* sentinel*/ } 236 }; 237 238 static int ehci_platform_probe(struct platform_device *dev) 239 { 240 struct usb_hcd *hcd; 241 struct resource *res_mem; 242 struct usb_ehci_pdata *pdata = dev_get_platdata(&dev->dev); 243 struct ehci_platform_priv *priv; 244 struct ehci_hcd *ehci; 245 int err, irq, clk = 0; 246 247 if (usb_disabled()) 248 return -ENODEV; 249 250 /* 251 * Use reasonable defaults so platforms don't have to provide these 252 * with DT probing on ARM. 253 */ 254 if (!pdata) 255 pdata = &ehci_platform_defaults; 256 257 err = dma_coerce_mask_and_coherent(&dev->dev, 258 pdata->dma_mask_64 ? DMA_BIT_MASK(64) : DMA_BIT_MASK(32)); 259 if (err) { 260 dev_err(&dev->dev, "Error: DMA mask configuration failed\n"); 261 return err; 262 } 263 264 irq = platform_get_irq(dev, 0); 265 if (irq < 0) 266 return irq; 267 268 hcd = usb_create_hcd(&ehci_platform_hc_driver, &dev->dev, 269 dev_name(&dev->dev)); 270 if (!hcd) 271 return -ENOMEM; 272 273 platform_set_drvdata(dev, hcd); 274 dev->dev.platform_data = pdata; 275 priv = hcd_to_ehci_priv(hcd); 276 ehci = hcd_to_ehci(hcd); 277 278 if (pdata == &ehci_platform_defaults && dev->dev.of_node) { 279 if (of_property_read_bool(dev->dev.of_node, "big-endian-regs")) 280 ehci->big_endian_mmio = 1; 281 282 if (of_property_read_bool(dev->dev.of_node, "big-endian-desc")) 283 ehci->big_endian_desc = 1; 284 285 if (of_property_read_bool(dev->dev.of_node, "big-endian")) 286 ehci->big_endian_mmio = ehci->big_endian_desc = 1; 287 288 if (of_property_read_bool(dev->dev.of_node, "spurious-oc")) 289 ehci->spurious_oc = 1; 290 291 if (of_property_read_bool(dev->dev.of_node, 292 "needs-reset-on-resume")) 293 priv->reset_on_resume = true; 294 295 if (of_property_read_bool(dev->dev.of_node, 296 "has-transaction-translator")) 297 hcd->has_tt = 1; 298 299 if (of_device_is_compatible(dev->dev.of_node, 300 "aspeed,ast2500-ehci") || 301 of_device_is_compatible(dev->dev.of_node, 302 "aspeed,ast2600-ehci")) 303 ehci->is_aspeed = 1; 304 305 if (soc_device_match(quirk_poll_match)) 306 priv->quirk_poll = true; 307 308 for (clk = 0; clk < EHCI_MAX_CLKS; clk++) { 309 priv->clks[clk] = of_clk_get(dev->dev.of_node, clk); 310 if (IS_ERR(priv->clks[clk])) { 311 err = PTR_ERR(priv->clks[clk]); 312 if (err == -EPROBE_DEFER) 313 goto err_put_clks; 314 priv->clks[clk] = NULL; 315 break; 316 } 317 } 318 } 319 320 priv->rsts = devm_reset_control_array_get_optional_shared(&dev->dev); 321 if (IS_ERR(priv->rsts)) { 322 err = PTR_ERR(priv->rsts); 323 goto err_put_clks; 324 } 325 326 err = reset_control_deassert(priv->rsts); 327 if (err) 328 goto err_put_clks; 329 330 if (pdata->big_endian_desc) 331 ehci->big_endian_desc = 1; 332 if (pdata->big_endian_mmio) 333 ehci->big_endian_mmio = 1; 334 if (pdata->has_tt) 335 hcd->has_tt = 1; 336 if (pdata->reset_on_resume) 337 priv->reset_on_resume = true; 338 if (pdata->spurious_oc) 339 ehci->spurious_oc = 1; 340 341 #ifndef CONFIG_USB_EHCI_BIG_ENDIAN_MMIO 342 if (ehci->big_endian_mmio) { 343 dev_err(&dev->dev, 344 "Error: CONFIG_USB_EHCI_BIG_ENDIAN_MMIO not set\n"); 345 err = -EINVAL; 346 goto err_reset; 347 } 348 #endif 349 #ifndef CONFIG_USB_EHCI_BIG_ENDIAN_DESC 350 if (ehci->big_endian_desc) { 351 dev_err(&dev->dev, 352 "Error: CONFIG_USB_EHCI_BIG_ENDIAN_DESC not set\n"); 353 err = -EINVAL; 354 goto err_reset; 355 } 356 #endif 357 358 if (pdata->power_on) { 359 err = pdata->power_on(dev); 360 if (err < 0) 361 goto err_reset; 362 } 363 364 res_mem = platform_get_resource(dev, IORESOURCE_MEM, 0); 365 hcd->regs = devm_ioremap_resource(&dev->dev, res_mem); 366 if (IS_ERR(hcd->regs)) { 367 err = PTR_ERR(hcd->regs); 368 goto err_power; 369 } 370 hcd->rsrc_start = res_mem->start; 371 hcd->rsrc_len = resource_size(res_mem); 372 373 hcd->tpl_support = of_usb_host_tpl_support(dev->dev.of_node); 374 375 err = usb_add_hcd(hcd, irq, IRQF_SHARED); 376 if (err) 377 goto err_power; 378 379 device_wakeup_enable(hcd->self.controller); 380 device_enable_async_suspend(hcd->self.controller); 381 platform_set_drvdata(dev, hcd); 382 383 if (priv->quirk_poll) 384 quirk_poll_init(priv); 385 386 return err; 387 388 err_power: 389 if (pdata->power_off) 390 pdata->power_off(dev); 391 err_reset: 392 reset_control_assert(priv->rsts); 393 err_put_clks: 394 while (--clk >= 0) 395 clk_put(priv->clks[clk]); 396 397 if (pdata == &ehci_platform_defaults) 398 dev->dev.platform_data = NULL; 399 400 usb_put_hcd(hcd); 401 402 return err; 403 } 404 405 static int ehci_platform_remove(struct platform_device *dev) 406 { 407 struct usb_hcd *hcd = platform_get_drvdata(dev); 408 struct usb_ehci_pdata *pdata = dev_get_platdata(&dev->dev); 409 struct ehci_platform_priv *priv = hcd_to_ehci_priv(hcd); 410 int clk; 411 412 if (priv->quirk_poll) 413 quirk_poll_end(priv); 414 415 usb_remove_hcd(hcd); 416 417 if (pdata->power_off) 418 pdata->power_off(dev); 419 420 reset_control_assert(priv->rsts); 421 422 for (clk = 0; clk < EHCI_MAX_CLKS && priv->clks[clk]; clk++) 423 clk_put(priv->clks[clk]); 424 425 usb_put_hcd(hcd); 426 427 if (pdata == &ehci_platform_defaults) 428 dev->dev.platform_data = NULL; 429 430 return 0; 431 } 432 433 static int __maybe_unused ehci_platform_suspend(struct device *dev) 434 { 435 struct usb_hcd *hcd = dev_get_drvdata(dev); 436 struct usb_ehci_pdata *pdata = dev_get_platdata(dev); 437 struct platform_device *pdev = to_platform_device(dev); 438 struct ehci_platform_priv *priv = hcd_to_ehci_priv(hcd); 439 bool do_wakeup = device_may_wakeup(dev); 440 int ret; 441 442 if (priv->quirk_poll) 443 quirk_poll_end(priv); 444 445 ret = ehci_suspend(hcd, do_wakeup); 446 if (ret) 447 return ret; 448 449 if (pdata->power_suspend) 450 pdata->power_suspend(pdev); 451 452 return ret; 453 } 454 455 static int __maybe_unused ehci_platform_resume(struct device *dev) 456 { 457 struct usb_hcd *hcd = dev_get_drvdata(dev); 458 struct usb_ehci_pdata *pdata = dev_get_platdata(dev); 459 struct platform_device *pdev = to_platform_device(dev); 460 struct ehci_platform_priv *priv = hcd_to_ehci_priv(hcd); 461 struct device *companion_dev; 462 463 if (pdata->power_on) { 464 int err = pdata->power_on(pdev); 465 if (err < 0) 466 return err; 467 } 468 469 companion_dev = usb_of_get_companion_dev(hcd->self.controller); 470 if (companion_dev) { 471 device_pm_wait_for_dev(hcd->self.controller, companion_dev); 472 put_device(companion_dev); 473 } 474 475 ehci_resume(hcd, priv->reset_on_resume); 476 477 pm_runtime_disable(dev); 478 pm_runtime_set_active(dev); 479 pm_runtime_enable(dev); 480 481 if (priv->quirk_poll) 482 quirk_poll_init(priv); 483 484 return 0; 485 } 486 487 static const struct of_device_id vt8500_ehci_ids[] = { 488 { .compatible = "via,vt8500-ehci", }, 489 { .compatible = "wm,prizm-ehci", }, 490 { .compatible = "generic-ehci", }, 491 { .compatible = "cavium,octeon-6335-ehci", }, 492 {} 493 }; 494 MODULE_DEVICE_TABLE(of, vt8500_ehci_ids); 495 496 #ifdef CONFIG_ACPI 497 static const struct acpi_device_id ehci_acpi_match[] = { 498 { "PNP0D20", 0 }, /* EHCI controller without debug */ 499 { } 500 }; 501 MODULE_DEVICE_TABLE(acpi, ehci_acpi_match); 502 #endif 503 504 static const struct platform_device_id ehci_platform_table[] = { 505 { "ehci-platform", 0 }, 506 { } 507 }; 508 MODULE_DEVICE_TABLE(platform, ehci_platform_table); 509 510 static SIMPLE_DEV_PM_OPS(ehci_platform_pm_ops, ehci_platform_suspend, 511 ehci_platform_resume); 512 513 static struct platform_driver ehci_platform_driver = { 514 .id_table = ehci_platform_table, 515 .probe = ehci_platform_probe, 516 .remove = ehci_platform_remove, 517 .shutdown = usb_hcd_platform_shutdown, 518 .driver = { 519 .name = "ehci-platform", 520 .pm = pm_ptr(&ehci_platform_pm_ops), 521 .of_match_table = vt8500_ehci_ids, 522 .acpi_match_table = ACPI_PTR(ehci_acpi_match), 523 .probe_type = PROBE_PREFER_ASYNCHRONOUS, 524 } 525 }; 526 527 static int __init ehci_platform_init(void) 528 { 529 if (usb_disabled()) 530 return -ENODEV; 531 532 pr_info("%s: " DRIVER_DESC "\n", hcd_name); 533 534 ehci_init_driver(&ehci_platform_hc_driver, &platform_overrides); 535 return platform_driver_register(&ehci_platform_driver); 536 } 537 module_init(ehci_platform_init); 538 539 static void __exit ehci_platform_cleanup(void) 540 { 541 platform_driver_unregister(&ehci_platform_driver); 542 } 543 module_exit(ehci_platform_cleanup); 544 545 MODULE_DESCRIPTION(DRIVER_DESC); 546 MODULE_AUTHOR("Hauke Mehrtens"); 547 MODULE_AUTHOR("Alan Stern"); 548 MODULE_LICENSE("GPL"); 549