1 /* 2 * Generic platform ehci driver 3 * 4 * Copyright 2007 Steven Brown <sbrown@cortland.com> 5 * Copyright 2010-2012 Hauke Mehrtens <hauke@hauke-m.de> 6 * Copyright 2014 Hans de Goede <hdegoede@redhat.com> 7 * 8 * Derived from the ohci-ssb driver 9 * Copyright 2007 Michael Buesch <m@bues.ch> 10 * 11 * Derived from the EHCI-PCI driver 12 * Copyright (c) 2000-2004 by David Brownell 13 * 14 * Derived from the ohci-pci driver 15 * Copyright 1999 Roman Weissgaerber 16 * Copyright 2000-2002 David Brownell 17 * Copyright 1999 Linus Torvalds 18 * Copyright 1999 Gregory P. Smith 19 * 20 * Licensed under the GNU/GPL. See COPYING for details. 21 */ 22 #include <linux/acpi.h> 23 #include <linux/clk.h> 24 #include <linux/dma-mapping.h> 25 #include <linux/err.h> 26 #include <linux/kernel.h> 27 #include <linux/hrtimer.h> 28 #include <linux/io.h> 29 #include <linux/module.h> 30 #include <linux/of.h> 31 #include <linux/phy/phy.h> 32 #include <linux/platform_device.h> 33 #include <linux/reset.h> 34 #include <linux/usb.h> 35 #include <linux/usb/hcd.h> 36 #include <linux/usb/ehci_pdriver.h> 37 38 #include "ehci.h" 39 40 #define DRIVER_DESC "EHCI generic platform driver" 41 #define EHCI_MAX_CLKS 3 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 *rst; 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 } 223 } 224 225 for (clk = 0; clk < EHCI_MAX_CLKS; clk++) { 226 priv->clks[clk] = of_clk_get(dev->dev.of_node, clk); 227 if (IS_ERR(priv->clks[clk])) { 228 err = PTR_ERR(priv->clks[clk]); 229 if (err == -EPROBE_DEFER) 230 goto err_put_clks; 231 priv->clks[clk] = NULL; 232 break; 233 } 234 } 235 } 236 237 priv->rst = devm_reset_control_get_optional(&dev->dev, NULL); 238 if (IS_ERR(priv->rst)) { 239 err = PTR_ERR(priv->rst); 240 if (err == -EPROBE_DEFER) 241 goto err_put_clks; 242 priv->rst = NULL; 243 } else { 244 err = reset_control_deassert(priv->rst); 245 if (err) 246 goto err_put_clks; 247 } 248 249 if (pdata->big_endian_desc) 250 ehci->big_endian_desc = 1; 251 if (pdata->big_endian_mmio) 252 ehci->big_endian_mmio = 1; 253 if (pdata->has_tt) 254 hcd->has_tt = 1; 255 if (pdata->reset_on_resume) 256 priv->reset_on_resume = true; 257 258 #ifndef CONFIG_USB_EHCI_BIG_ENDIAN_MMIO 259 if (ehci->big_endian_mmio) { 260 dev_err(&dev->dev, 261 "Error: CONFIG_USB_EHCI_BIG_ENDIAN_MMIO not set\n"); 262 err = -EINVAL; 263 goto err_reset; 264 } 265 #endif 266 #ifndef CONFIG_USB_EHCI_BIG_ENDIAN_DESC 267 if (ehci->big_endian_desc) { 268 dev_err(&dev->dev, 269 "Error: CONFIG_USB_EHCI_BIG_ENDIAN_DESC not set\n"); 270 err = -EINVAL; 271 goto err_reset; 272 } 273 #endif 274 275 if (pdata->power_on) { 276 err = pdata->power_on(dev); 277 if (err < 0) 278 goto err_reset; 279 } 280 281 res_mem = platform_get_resource(dev, IORESOURCE_MEM, 0); 282 hcd->regs = devm_ioremap_resource(&dev->dev, res_mem); 283 if (IS_ERR(hcd->regs)) { 284 err = PTR_ERR(hcd->regs); 285 goto err_power; 286 } 287 hcd->rsrc_start = res_mem->start; 288 hcd->rsrc_len = resource_size(res_mem); 289 290 err = usb_add_hcd(hcd, irq, IRQF_SHARED); 291 if (err) 292 goto err_power; 293 294 device_wakeup_enable(hcd->self.controller); 295 platform_set_drvdata(dev, hcd); 296 297 return err; 298 299 err_power: 300 if (pdata->power_off) 301 pdata->power_off(dev); 302 err_reset: 303 if (priv->rst) 304 reset_control_assert(priv->rst); 305 err_put_clks: 306 while (--clk >= 0) 307 clk_put(priv->clks[clk]); 308 err_put_hcd: 309 if (pdata == &ehci_platform_defaults) 310 dev->dev.platform_data = NULL; 311 312 usb_put_hcd(hcd); 313 314 return err; 315 } 316 317 static int ehci_platform_remove(struct platform_device *dev) 318 { 319 struct usb_hcd *hcd = platform_get_drvdata(dev); 320 struct usb_ehci_pdata *pdata = dev_get_platdata(&dev->dev); 321 struct ehci_platform_priv *priv = hcd_to_ehci_priv(hcd); 322 int clk; 323 324 usb_remove_hcd(hcd); 325 326 if (pdata->power_off) 327 pdata->power_off(dev); 328 329 if (priv->rst) 330 reset_control_assert(priv->rst); 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 = 349 container_of(dev, struct platform_device, dev); 350 bool do_wakeup = device_may_wakeup(dev); 351 int ret; 352 353 ret = ehci_suspend(hcd, do_wakeup); 354 if (ret) 355 return ret; 356 357 if (pdata->power_suspend) 358 pdata->power_suspend(pdev); 359 360 return ret; 361 } 362 363 static int ehci_platform_resume(struct device *dev) 364 { 365 struct usb_hcd *hcd = dev_get_drvdata(dev); 366 struct usb_ehci_pdata *pdata = dev_get_platdata(dev); 367 struct platform_device *pdev = 368 container_of(dev, struct platform_device, dev); 369 struct ehci_platform_priv *priv = hcd_to_ehci_priv(hcd); 370 371 if (pdata->power_on) { 372 int err = pdata->power_on(pdev); 373 if (err < 0) 374 return err; 375 } 376 377 ehci_resume(hcd, priv->reset_on_resume); 378 return 0; 379 } 380 #endif /* CONFIG_PM_SLEEP */ 381 382 static const struct of_device_id vt8500_ehci_ids[] = { 383 { .compatible = "via,vt8500-ehci", }, 384 { .compatible = "wm,prizm-ehci", }, 385 { .compatible = "generic-ehci", }, 386 { .compatible = "cavium,octeon-6335-ehci", }, 387 {} 388 }; 389 MODULE_DEVICE_TABLE(of, vt8500_ehci_ids); 390 391 static const struct acpi_device_id ehci_acpi_match[] = { 392 { "PNP0D20", 0 }, /* EHCI controller without debug */ 393 { } 394 }; 395 MODULE_DEVICE_TABLE(acpi, ehci_acpi_match); 396 397 static const struct platform_device_id ehci_platform_table[] = { 398 { "ehci-platform", 0 }, 399 { } 400 }; 401 MODULE_DEVICE_TABLE(platform, ehci_platform_table); 402 403 static SIMPLE_DEV_PM_OPS(ehci_platform_pm_ops, ehci_platform_suspend, 404 ehci_platform_resume); 405 406 static struct platform_driver ehci_platform_driver = { 407 .id_table = ehci_platform_table, 408 .probe = ehci_platform_probe, 409 .remove = ehci_platform_remove, 410 .shutdown = usb_hcd_platform_shutdown, 411 .driver = { 412 .name = "ehci-platform", 413 .pm = &ehci_platform_pm_ops, 414 .of_match_table = vt8500_ehci_ids, 415 .acpi_match_table = ACPI_PTR(ehci_acpi_match), 416 } 417 }; 418 419 static int __init ehci_platform_init(void) 420 { 421 if (usb_disabled()) 422 return -ENODEV; 423 424 pr_info("%s: " DRIVER_DESC "\n", hcd_name); 425 426 ehci_init_driver(&ehci_platform_hc_driver, &platform_overrides); 427 return platform_driver_register(&ehci_platform_driver); 428 } 429 module_init(ehci_platform_init); 430 431 static void __exit ehci_platform_cleanup(void) 432 { 433 platform_driver_unregister(&ehci_platform_driver); 434 } 435 module_exit(ehci_platform_cleanup); 436 437 MODULE_DESCRIPTION(DRIVER_DESC); 438 MODULE_AUTHOR("Hauke Mehrtens"); 439 MODULE_AUTHOR("Alan Stern"); 440 MODULE_LICENSE("GPL"); 441