Version:  2.0.40 2.2.26 2.4.37 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1

Linux/drivers/usb/host/ehci-atmel.c

  1 /*
  2  * Driver for EHCI UHP on Atmel chips
  3  *
  4  *  Copyright (C) 2009 Atmel Corporation,
  5  *                     Nicolas Ferre <nicolas.ferre@atmel.com>
  6  *
  7  *  Based on various ehci-*.c drivers
  8  *
  9  * This file is subject to the terms and conditions of the GNU General Public
 10  * License.  See the file COPYING in the main directory of this archive for
 11  * more details.
 12  */
 13 
 14 #include <linux/clk.h>
 15 #include <linux/dma-mapping.h>
 16 #include <linux/io.h>
 17 #include <linux/kernel.h>
 18 #include <linux/module.h>
 19 #include <linux/of.h>
 20 #include <linux/of_platform.h>
 21 #include <linux/platform_device.h>
 22 #include <linux/usb.h>
 23 #include <linux/usb/hcd.h>
 24 
 25 #include "ehci.h"
 26 
 27 #define DRIVER_DESC "EHCI Atmel driver"
 28 
 29 static const char hcd_name[] = "ehci-atmel";
 30 
 31 /* interface and function clocks */
 32 #define hcd_to_atmel_ehci_priv(h) \
 33         ((struct atmel_ehci_priv *)hcd_to_ehci(h)->priv)
 34 
 35 struct atmel_ehci_priv {
 36         struct clk *iclk;
 37         struct clk *uclk;
 38         bool clocked;
 39 };
 40 
 41 static struct hc_driver __read_mostly ehci_atmel_hc_driver;
 42 
 43 static const struct ehci_driver_overrides ehci_atmel_drv_overrides __initconst = {
 44         .extra_priv_size = sizeof(struct atmel_ehci_priv),
 45 };
 46 
 47 /*-------------------------------------------------------------------------*/
 48 
 49 static void atmel_start_clock(struct atmel_ehci_priv *atmel_ehci)
 50 {
 51         if (atmel_ehci->clocked)
 52                 return;
 53 
 54         clk_prepare_enable(atmel_ehci->uclk);
 55         clk_prepare_enable(atmel_ehci->iclk);
 56         atmel_ehci->clocked = true;
 57 }
 58 
 59 static void atmel_stop_clock(struct atmel_ehci_priv *atmel_ehci)
 60 {
 61         if (!atmel_ehci->clocked)
 62                 return;
 63 
 64         clk_disable_unprepare(atmel_ehci->iclk);
 65         clk_disable_unprepare(atmel_ehci->uclk);
 66         atmel_ehci->clocked = false;
 67 }
 68 
 69 static void atmel_start_ehci(struct platform_device *pdev)
 70 {
 71         struct usb_hcd *hcd = platform_get_drvdata(pdev);
 72         struct atmel_ehci_priv *atmel_ehci = hcd_to_atmel_ehci_priv(hcd);
 73 
 74         dev_dbg(&pdev->dev, "start\n");
 75         atmel_start_clock(atmel_ehci);
 76 }
 77 
 78 static void atmel_stop_ehci(struct platform_device *pdev)
 79 {
 80         struct usb_hcd *hcd = platform_get_drvdata(pdev);
 81         struct atmel_ehci_priv *atmel_ehci = hcd_to_atmel_ehci_priv(hcd);
 82 
 83         dev_dbg(&pdev->dev, "stop\n");
 84         atmel_stop_clock(atmel_ehci);
 85 }
 86 
 87 /*-------------------------------------------------------------------------*/
 88 
 89 static int ehci_atmel_drv_probe(struct platform_device *pdev)
 90 {
 91         struct usb_hcd *hcd;
 92         const struct hc_driver *driver = &ehci_atmel_hc_driver;
 93         struct resource *res;
 94         struct ehci_hcd *ehci;
 95         struct atmel_ehci_priv *atmel_ehci;
 96         int irq;
 97         int retval;
 98 
 99         if (usb_disabled())
100                 return -ENODEV;
101 
102         pr_debug("Initializing Atmel-SoC USB Host Controller\n");
103 
104         irq = platform_get_irq(pdev, 0);
105         if (irq <= 0) {
106                 dev_err(&pdev->dev,
107                         "Found HC with no IRQ. Check %s setup!\n",
108                         dev_name(&pdev->dev));
109                 retval = -ENODEV;
110                 goto fail_create_hcd;
111         }
112 
113         /* Right now device-tree probed devices don't get dma_mask set.
114          * Since shared usb code relies on it, set it here for now.
115          * Once we have dma capability bindings this can go away.
116          */
117         retval = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
118         if (retval)
119                 goto fail_create_hcd;
120 
121         hcd = usb_create_hcd(driver, &pdev->dev, dev_name(&pdev->dev));
122         if (!hcd) {
123                 retval = -ENOMEM;
124                 goto fail_create_hcd;
125         }
126         atmel_ehci = hcd_to_atmel_ehci_priv(hcd);
127 
128         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
129         hcd->regs = devm_ioremap_resource(&pdev->dev, res);
130         if (IS_ERR(hcd->regs)) {
131                 retval = PTR_ERR(hcd->regs);
132                 goto fail_request_resource;
133         }
134 
135         hcd->rsrc_start = res->start;
136         hcd->rsrc_len = resource_size(res);
137 
138         atmel_ehci->iclk = devm_clk_get(&pdev->dev, "ehci_clk");
139         if (IS_ERR(atmel_ehci->iclk)) {
140                 dev_err(&pdev->dev, "Error getting interface clock\n");
141                 retval = -ENOENT;
142                 goto fail_request_resource;
143         }
144 
145         atmel_ehci->uclk = devm_clk_get(&pdev->dev, "usb_clk");
146         if (IS_ERR(atmel_ehci->uclk)) {
147                 dev_err(&pdev->dev, "failed to get uclk\n");
148                 retval = PTR_ERR(atmel_ehci->uclk);
149                 goto fail_request_resource;
150         }
151 
152         ehci = hcd_to_ehci(hcd);
153         /* registers start at offset 0x0 */
154         ehci->caps = hcd->regs;
155 
156         atmel_start_ehci(pdev);
157 
158         retval = usb_add_hcd(hcd, irq, IRQF_SHARED);
159         if (retval)
160                 goto fail_add_hcd;
161         device_wakeup_enable(hcd->self.controller);
162 
163         return retval;
164 
165 fail_add_hcd:
166         atmel_stop_ehci(pdev);
167 fail_request_resource:
168         usb_put_hcd(hcd);
169 fail_create_hcd:
170         dev_err(&pdev->dev, "init %s fail, %d\n",
171                 dev_name(&pdev->dev), retval);
172 
173         return retval;
174 }
175 
176 static int ehci_atmel_drv_remove(struct platform_device *pdev)
177 {
178         struct usb_hcd *hcd = platform_get_drvdata(pdev);
179 
180         usb_remove_hcd(hcd);
181         usb_put_hcd(hcd);
182 
183         atmel_stop_ehci(pdev);
184 
185         return 0;
186 }
187 
188 #ifdef CONFIG_PM
189 static int ehci_atmel_drv_suspend(struct device *dev)
190 {
191         struct usb_hcd *hcd = dev_get_drvdata(dev);
192         struct atmel_ehci_priv *atmel_ehci = hcd_to_atmel_ehci_priv(hcd);
193         int ret;
194 
195         ret = ehci_suspend(hcd, false);
196         if (ret)
197                 return ret;
198 
199         atmel_stop_clock(atmel_ehci);
200         return 0;
201 }
202 
203 static int ehci_atmel_drv_resume(struct device *dev)
204 {
205         struct usb_hcd *hcd = dev_get_drvdata(dev);
206         struct atmel_ehci_priv *atmel_ehci = hcd_to_atmel_ehci_priv(hcd);
207 
208         atmel_start_clock(atmel_ehci);
209         return ehci_resume(hcd, false);
210 }
211 #endif
212 
213 #ifdef CONFIG_OF
214 static const struct of_device_id atmel_ehci_dt_ids[] = {
215         { .compatible = "atmel,at91sam9g45-ehci" },
216         { /* sentinel */ }
217 };
218 
219 MODULE_DEVICE_TABLE(of, atmel_ehci_dt_ids);
220 #endif
221 
222 static SIMPLE_DEV_PM_OPS(ehci_atmel_pm_ops, ehci_atmel_drv_suspend,
223                                         ehci_atmel_drv_resume);
224 
225 static struct platform_driver ehci_atmel_driver = {
226         .probe          = ehci_atmel_drv_probe,
227         .remove         = ehci_atmel_drv_remove,
228         .shutdown       = usb_hcd_platform_shutdown,
229         .driver         = {
230                 .name   = "atmel-ehci",
231                 .pm     = &ehci_atmel_pm_ops,
232                 .of_match_table = of_match_ptr(atmel_ehci_dt_ids),
233         },
234 };
235 
236 static int __init ehci_atmel_init(void)
237 {
238         if (usb_disabled())
239                 return -ENODEV;
240 
241         pr_info("%s: " DRIVER_DESC "\n", hcd_name);
242         ehci_init_driver(&ehci_atmel_hc_driver, &ehci_atmel_drv_overrides);
243         return platform_driver_register(&ehci_atmel_driver);
244 }
245 module_init(ehci_atmel_init);
246 
247 static void __exit ehci_atmel_cleanup(void)
248 {
249         platform_driver_unregister(&ehci_atmel_driver);
250 }
251 module_exit(ehci_atmel_cleanup);
252 
253 MODULE_DESCRIPTION(DRIVER_DESC);
254 MODULE_ALIAS("platform:atmel-ehci");
255 MODULE_AUTHOR("Nicolas Ferre");
256 MODULE_LICENSE("GPL");
257 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us