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