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