drivers/usb/host/ehci-platform.c

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