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