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  *
   7  * Derived from the ohci-ssb driver
   8  * Copyright 2007 Michael Buesch <m@bues.ch>
   9  *
  10  * Derived from the EHCI-PCI driver
  11  * Copyright (c) 2000-2004 by David Brownell
  12  *
  13  * Derived from the ohci-pci driver
  14  * Copyright 1999 Roman Weissgaerber
  15  * Copyright 2000-2002 David Brownell
  16  * Copyright 1999 Linus Torvalds
  17  * Copyright 1999 Gregory P. Smith
  18  *
  19  * Licensed under the GNU/GPL. See COPYING for details.
  20  */
  21 #include <linux/dma-mapping.h>
  22 #include <linux/err.h>
  23 #include <linux/kernel.h>
  24 #include <linux/hrtimer.h>
  25 #include <linux/io.h>
  26 #include <linux/module.h>
  27 #include <linux/of.h>
  28 #include <linux/platform_device.h>
  29 #include <linux/usb.h>
  30 #include <linux/usb/hcd.h>
  31 #include <linux/usb/ehci_pdriver.h>
  32
  33 #include "ehci.h"
  34
  35 #define DRIVER_DESC "EHCI generic platform driver"
  36
  37 static const char hcd_name[] = "ehci-platform";
  38
  39 static int ehci_platform_reset(struct usb_hcd *hcd)
  40 {
  41         struct platform_device *pdev = to_platform_device(hcd->self.controller);
  42         struct usb_ehci_pdata *pdata = dev_get_platdata(&pdev->dev);
  43         struct ehci_hcd *ehci = hcd_to_ehci(hcd);
  44         int retval;
  45
  46         hcd->has_tt = pdata->has_tt;
  47         ehci->has_synopsys_hc_bug = pdata->has_synopsys_hc_bug;
  48         ehci->big_endian_desc = pdata->big_endian_desc;
  49         ehci->big_endian_mmio = pdata->big_endian_mmio;
  50
  51         if (pdata->pre_setup) {
  52                 retval = pdata->pre_setup(hcd);
  53                 if (retval < 0)
  54                         return retval;
  55         }
  56
  57         ehci->caps = hcd->regs + pdata->caps_offset;
  58         retval = ehci_setup(hcd);
  59         if (retval)
  60                 return retval;
  61
  62         if (pdata->no_io_watchdog)
  63                 ehci->need_io_watchdog = 0;
  64         return 0;
  65 }
  66
  67 static struct hc_driver __read_mostly ehci_platform_hc_driver;
  68
  69 static const struct ehci_driver_overrides platform_overrides __initconst = {
  70         .reset =        ehci_platform_reset,
  71 };
  72
  73 static struct usb_ehci_pdata ehci_platform_defaults;
  74
  75 static int ehci_platform_probe(struct platform_device *dev)
  76 {
  77         struct usb_hcd *hcd;
  78         struct resource *res_mem;
  79         struct usb_ehci_pdata *pdata;
  80         int irq;
  81         int err;
  82
  83         if (usb_disabled())
  84                 return -ENODEV;
  85
  86         /*
  87          * use reasonable defaults so platforms don't have to provide these.
  88          * with DT probing on ARM, none of these are set.
  89          */
  90         if (!dev_get_platdata(&dev->dev))
  91                 dev->dev.platform_data = &ehci_platform_defaults;
  92
  93         err = dma_coerce_mask_and_coherent(&dev->dev, DMA_BIT_MASK(32));
  94         if (err)
  95                 return err;
  96
  97         pdata = dev_get_platdata(&dev->dev);
  98
  99         irq = platform_get_irq(dev, 0);
 100         if (irq < 0) {
 101                 dev_err(&dev->dev, "no irq provided");
 102                 return irq;
 103         }
 104         res_mem = platform_get_resource(dev, IORESOURCE_MEM, 0);
 105         if (!res_mem) {
 106                 dev_err(&dev->dev, "no memory resource provided");
 107                 return -ENXIO;
 108         }
 109
 110         if (pdata->power_on) {
 111                 err = pdata->power_on(dev);
 112                 if (err < 0)
 113                         return err;
 114         }
 115
 116         hcd = usb_create_hcd(&ehci_platform_hc_driver, &dev->dev,
 117                              dev_name(&dev->dev));
 118         if (!hcd) {
 119                 err = -ENOMEM;
 120                 goto err_power;
 121         }
 122
 123         hcd->rsrc_start = res_mem->start;
 124         hcd->rsrc_len = resource_size(res_mem);
 125
 126         hcd->regs = devm_ioremap_resource(&dev->dev, res_mem);
 127         if (IS_ERR(hcd->regs)) {
 128                 err = PTR_ERR(hcd->regs);
 129                 goto err_put_hcd;
 130         }
 131         err = usb_add_hcd(hcd, irq, IRQF_SHARED);
 132         if (err)
 133                 goto err_put_hcd;
 134
 135         platform_set_drvdata(dev, hcd);
 136
 137         return err;
 138
 139 err_put_hcd:
 140         usb_put_hcd(hcd);
 141 err_power:
 142         if (pdata->power_off)
 143                 pdata->power_off(dev);
 144
 145         return err;
 146 }
 147
 148 static int ehci_platform_remove(struct platform_device *dev)
 149 {
 150         struct usb_hcd *hcd = platform_get_drvdata(dev);
 151         struct usb_ehci_pdata *pdata = dev_get_platdata(&dev->dev);
 152
 153         usb_remove_hcd(hcd);
 154         usb_put_hcd(hcd);
 155
 156         if (pdata->power_off)
 157                 pdata->power_off(dev);
 158
 159         if (pdata == &ehci_platform_defaults)
 160                 dev->dev.platform_data = NULL;
 161
 162         return 0;
 163 }
 164
 165 #ifdef CONFIG_PM
 166
 167 static int ehci_platform_suspend(struct device *dev)
 168 {
 169         struct usb_hcd *hcd = dev_get_drvdata(dev);
 170         struct usb_ehci_pdata *pdata = dev_get_platdata(dev);
 171         struct platform_device *pdev =
 172                 container_of(dev, struct platform_device, dev);
 173         bool do_wakeup = device_may_wakeup(dev);
 174         int ret;
 175
 176         ret = ehci_suspend(hcd, do_wakeup);
 177
 178         if (pdata->power_suspend)
 179                 pdata->power_suspend(pdev);
 180
 181         return ret;
 182 }
 183
 184 static int ehci_platform_resume(struct device *dev)
 185 {
 186         struct usb_hcd *hcd = dev_get_drvdata(dev);
 187         struct usb_ehci_pdata *pdata = dev_get_platdata(dev);
 188         struct platform_device *pdev =
 189                 container_of(dev, struct platform_device, dev);
 190
 191         if (pdata->power_on) {
 192                 int err = pdata->power_on(pdev);
 193                 if (err < 0)
 194                         return err;
 195         }
 196
 197         ehci_resume(hcd, false);
 198         return 0;
 199 }
 200
 201 #else /* !CONFIG_PM */
 202 #define ehci_platform_suspend   NULL
 203 #define ehci_platform_resume    NULL
 204 #endif /* CONFIG_PM */
 205
 206 static const struct of_device_id vt8500_ehci_ids[] = {
 207         { .compatible = "via,vt8500-ehci", },
 208         { .compatible = "wm,prizm-ehci", },
 209         {}
 210 };
 211
 212 static const struct platform_device_id ehci_platform_table[] = {
 213         { "ehci-platform", 0 },
 214         { }
 215 };
 216 MODULE_DEVICE_TABLE(platform, ehci_platform_table);
 217
 218 static const struct dev_pm_ops ehci_platform_pm_ops = {
 219         .suspend        = ehci_platform_suspend,
 220         .resume         = ehci_platform_resume,
 221 };
 222
 223 static struct platform_driver ehci_platform_driver = {
 224         .id_table       = ehci_platform_table,
 225         .probe          = ehci_platform_probe,
 226         .remove         = ehci_platform_remove,
 227         .shutdown       = usb_hcd_platform_shutdown,
 228         .driver         = {
 229                 .owner  = THIS_MODULE,
 230                 .name   = "ehci-platform",
 231                 .pm     = &ehci_platform_pm_ops,
 232                 .of_match_table = vt8500_ehci_ids,
 233         }
 234 };
 235
 236 static int __init ehci_platform_init(void)
 237 {
 238         if (usb_disabled())
 239                 return -ENODEV;
 240
 241         pr_info("%s: " DRIVER_DESC "\n", hcd_name);
 242
 243         ehci_init_driver(&ehci_platform_hc_driver, &platform_overrides);
 244         return platform_driver_register(&ehci_platform_driver);
 245 }
 246 module_init(ehci_platform_init);
 247
 248 static void __exit ehci_platform_cleanup(void)
 249 {
 250         platform_driver_unregister(&ehci_platform_driver);
 251 }
 252 module_exit(ehci_platform_cleanup);
 253
 254 MODULE_DESCRIPTION(DRIVER_DESC);
 255 MODULE_AUTHOR("Hauke Mehrtens");
 256 MODULE_AUTHOR("Alan Stern");
 257 MODULE_LICENSE("GPL");