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 = 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 369 if (pdata->power_on) { 370 int err = pdata->power_on(pdev); 371 if (err < 0) 372 return err; 373 } 374 375 ehci_resume(hcd, priv->reset_on_resume); 376 return 0; 377 } 378 #endif /* CONFIG_PM_SLEEP */ 379 380 static const struct of_device_id vt8500_ehci_ids[] = { 381 { .compatible = "via,vt8500-ehci", }, 382 { .compatible = "wm,prizm-ehci", }, 383 { .compatible = "generic-ehci", }, 384 { .compatible = "cavium,octeon-6335-ehci", }, 385 {} 386 }; 387 MODULE_DEVICE_TABLE(of, vt8500_ehci_ids); 388 389 static const struct acpi_device_id ehci_acpi_match[] = { 390 { "PNP0D20", 0 }, /* EHCI controller without debug */ 391 { } 392 }; 393 MODULE_DEVICE_TABLE(acpi, ehci_acpi_match); 394 395 static const struct platform_device_id ehci_platform_table[] = { 396 { "ehci-platform", 0 }, 397 { } 398 }; 399 MODULE_DEVICE_TABLE(platform, ehci_platform_table); 400 401 static SIMPLE_DEV_PM_OPS(ehci_platform_pm_ops, ehci_platform_suspend, 402 ehci_platform_resume); 403 404 static struct platform_driver ehci_platform_driver = { 405 .id_table = ehci_platform_table, 406 .probe = ehci_platform_probe, 407 .remove = ehci_platform_remove, 408 .shutdown = usb_hcd_platform_shutdown, 409 .driver = { 410 .name = "ehci-platform", 411 .pm = &ehci_platform_pm_ops, 412 .of_match_table = vt8500_ehci_ids, 413 .acpi_match_table = ACPI_PTR(ehci_acpi_match), 414 } 415 }; 416 417 static int __init ehci_platform_init(void) 418 { 419 if (usb_disabled()) 420 return -ENODEV; 421 422 pr_info("%s: " DRIVER_DESC "\n", hcd_name); 423 424 ehci_init_driver(&ehci_platform_hc_driver, &platform_overrides); 425 return platform_driver_register(&ehci_platform_driver); 426 } 427 module_init(ehci_platform_init); 428 429 static void __exit ehci_platform_cleanup(void) 430 { 431 platform_driver_unregister(&ehci_platform_driver); 432 } 433 module_exit(ehci_platform_cleanup); 434 435 MODULE_DESCRIPTION(DRIVER_DESC); 436 MODULE_AUTHOR("Hauke Mehrtens"); 437 MODULE_AUTHOR("Alan Stern"); 438 MODULE_LICENSE("GPL"); 439