Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15

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

  1 /*
  2  * SAMSUNG EXYNOS USB HOST EHCI Controller
  3  *
  4  * Copyright (C) 2011 Samsung Electronics Co.Ltd
  5  * Author: Jingoo Han <jg1.han@samsung.com>
  6  * Author: Joonyoung Shim <jy0922.shim@samsung.com>
  7  *
  8  * This program is free software; you can redistribute  it and/or modify it
  9  * under  the terms of  the GNU General  Public License as published by the
 10  * Free Software Foundation;  either version 2 of the  License, or (at your
 11  * option) any later version.
 12  *
 13  */
 14 
 15 #include <linux/clk.h>
 16 #include <linux/dma-mapping.h>
 17 #include <linux/io.h>
 18 #include <linux/kernel.h>
 19 #include <linux/module.h>
 20 #include <linux/of.h>
 21 #include <linux/of_gpio.h>
 22 #include <linux/platform_device.h>
 23 #include <linux/usb/phy.h>
 24 #include <linux/usb/samsung_usb_phy.h>
 25 #include <linux/usb.h>
 26 #include <linux/usb/hcd.h>
 27 #include <linux/usb/otg.h>
 28 
 29 #include "ehci.h"
 30 
 31 #define DRIVER_DESC "EHCI EXYNOS driver"
 32 
 33 #define EHCI_INSNREG00(base)                    (base + 0x90)
 34 #define EHCI_INSNREG00_ENA_INCR16               (0x1 << 25)
 35 #define EHCI_INSNREG00_ENA_INCR8                (0x1 << 24)
 36 #define EHCI_INSNREG00_ENA_INCR4                (0x1 << 23)
 37 #define EHCI_INSNREG00_ENA_INCRX_ALIGN          (0x1 << 22)
 38 #define EHCI_INSNREG00_ENABLE_DMA_BURST \
 39         (EHCI_INSNREG00_ENA_INCR16 | EHCI_INSNREG00_ENA_INCR8 | \
 40          EHCI_INSNREG00_ENA_INCR4 | EHCI_INSNREG00_ENA_INCRX_ALIGN)
 41 
 42 static const char hcd_name[] = "ehci-exynos";
 43 static struct hc_driver __read_mostly exynos_ehci_hc_driver;
 44 
 45 struct exynos_ehci_hcd {
 46         struct clk *clk;
 47         struct usb_phy *phy;
 48         struct usb_otg *otg;
 49 };
 50 
 51 #define to_exynos_ehci(hcd) (struct exynos_ehci_hcd *)(hcd_to_ehci(hcd)->priv)
 52 
 53 static void exynos_setup_vbus_gpio(struct platform_device *pdev)
 54 {
 55         struct device *dev = &pdev->dev;
 56         int err;
 57         int gpio;
 58 
 59         if (!dev->of_node)
 60                 return;
 61 
 62         gpio = of_get_named_gpio(dev->of_node, "samsung,vbus-gpio", 0);
 63         if (!gpio_is_valid(gpio))
 64                 return;
 65 
 66         err = devm_gpio_request_one(dev, gpio, GPIOF_OUT_INIT_HIGH,
 67                                     "ehci_vbus_gpio");
 68         if (err)
 69                 dev_err(dev, "can't request ehci vbus gpio %d", gpio);
 70 }
 71 
 72 static int exynos_ehci_probe(struct platform_device *pdev)
 73 {
 74         struct exynos_ehci_hcd *exynos_ehci;
 75         struct usb_hcd *hcd;
 76         struct ehci_hcd *ehci;
 77         struct resource *res;
 78         struct usb_phy *phy;
 79         int irq;
 80         int err;
 81 
 82         /*
 83          * Right now device-tree probed devices don't get dma_mask set.
 84          * Since shared usb code relies on it, set it here for now.
 85          * Once we move to full device tree support this will vanish off.
 86          */
 87         err = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
 88         if (err)
 89                 return err;
 90 
 91         exynos_setup_vbus_gpio(pdev);
 92 
 93         hcd = usb_create_hcd(&exynos_ehci_hc_driver,
 94                              &pdev->dev, dev_name(&pdev->dev));
 95         if (!hcd) {
 96                 dev_err(&pdev->dev, "Unable to create HCD\n");
 97                 return -ENOMEM;
 98         }
 99         exynos_ehci = to_exynos_ehci(hcd);
100 
101         if (of_device_is_compatible(pdev->dev.of_node,
102                                         "samsung,exynos5440-ehci"))
103                 goto skip_phy;
104 
105         phy = devm_usb_get_phy(&pdev->dev, USB_PHY_TYPE_USB2);
106         if (IS_ERR(phy)) {
107                 usb_put_hcd(hcd);
108                 dev_warn(&pdev->dev, "no platform data or transceiver defined\n");
109                 return -EPROBE_DEFER;
110         } else {
111                 exynos_ehci->phy = phy;
112                 exynos_ehci->otg = phy->otg;
113         }
114 
115 skip_phy:
116 
117         exynos_ehci->clk = devm_clk_get(&pdev->dev, "usbhost");
118 
119         if (IS_ERR(exynos_ehci->clk)) {
120                 dev_err(&pdev->dev, "Failed to get usbhost clock\n");
121                 err = PTR_ERR(exynos_ehci->clk);
122                 goto fail_clk;
123         }
124 
125         err = clk_prepare_enable(exynos_ehci->clk);
126         if (err)
127                 goto fail_clk;
128 
129         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
130         if (!res) {
131                 dev_err(&pdev->dev, "Failed to get I/O memory\n");
132                 err = -ENXIO;
133                 goto fail_io;
134         }
135 
136         hcd->rsrc_start = res->start;
137         hcd->rsrc_len = resource_size(res);
138         hcd->regs = devm_ioremap(&pdev->dev, res->start, hcd->rsrc_len);
139         if (!hcd->regs) {
140                 dev_err(&pdev->dev, "Failed to remap I/O memory\n");
141                 err = -ENOMEM;
142                 goto fail_io;
143         }
144 
145         irq = platform_get_irq(pdev, 0);
146         if (!irq) {
147                 dev_err(&pdev->dev, "Failed to get IRQ\n");
148                 err = -ENODEV;
149                 goto fail_io;
150         }
151 
152         if (exynos_ehci->otg)
153                 exynos_ehci->otg->set_host(exynos_ehci->otg, &hcd->self);
154 
155         if (exynos_ehci->phy)
156                 usb_phy_init(exynos_ehci->phy);
157 
158         ehci = hcd_to_ehci(hcd);
159         ehci->caps = hcd->regs;
160 
161         /* DMA burst Enable */
162         writel(EHCI_INSNREG00_ENABLE_DMA_BURST, EHCI_INSNREG00(hcd->regs));
163 
164         err = usb_add_hcd(hcd, irq, IRQF_SHARED);
165         if (err) {
166                 dev_err(&pdev->dev, "Failed to add USB HCD\n");
167                 goto fail_add_hcd;
168         }
169         device_wakeup_enable(hcd->self.controller);
170 
171         platform_set_drvdata(pdev, hcd);
172 
173         return 0;
174 
175 fail_add_hcd:
176         if (exynos_ehci->phy)
177                 usb_phy_shutdown(exynos_ehci->phy);
178 fail_io:
179         clk_disable_unprepare(exynos_ehci->clk);
180 fail_clk:
181         usb_put_hcd(hcd);
182         return err;
183 }
184 
185 static int exynos_ehci_remove(struct platform_device *pdev)
186 {
187         struct usb_hcd *hcd = platform_get_drvdata(pdev);
188         struct exynos_ehci_hcd *exynos_ehci = to_exynos_ehci(hcd);
189 
190         usb_remove_hcd(hcd);
191 
192         if (exynos_ehci->otg)
193                 exynos_ehci->otg->set_host(exynos_ehci->otg, &hcd->self);
194 
195         if (exynos_ehci->phy)
196                 usb_phy_shutdown(exynos_ehci->phy);
197 
198         clk_disable_unprepare(exynos_ehci->clk);
199 
200         usb_put_hcd(hcd);
201 
202         return 0;
203 }
204 
205 #ifdef CONFIG_PM
206 static int exynos_ehci_suspend(struct device *dev)
207 {
208         struct usb_hcd *hcd = dev_get_drvdata(dev);
209         struct exynos_ehci_hcd *exynos_ehci = to_exynos_ehci(hcd);
210 
211         bool do_wakeup = device_may_wakeup(dev);
212         int rc;
213 
214         rc = ehci_suspend(hcd, do_wakeup);
215         if (rc)
216                 return rc;
217 
218         if (exynos_ehci->otg)
219                 exynos_ehci->otg->set_host(exynos_ehci->otg, &hcd->self);
220 
221         if (exynos_ehci->phy)
222                 usb_phy_shutdown(exynos_ehci->phy);
223 
224         clk_disable_unprepare(exynos_ehci->clk);
225 
226         return rc;
227 }
228 
229 static int exynos_ehci_resume(struct device *dev)
230 {
231         struct usb_hcd *hcd = dev_get_drvdata(dev);
232         struct exynos_ehci_hcd *exynos_ehci = to_exynos_ehci(hcd);
233 
234         clk_prepare_enable(exynos_ehci->clk);
235 
236         if (exynos_ehci->otg)
237                 exynos_ehci->otg->set_host(exynos_ehci->otg, &hcd->self);
238 
239         if (exynos_ehci->phy)
240                 usb_phy_init(exynos_ehci->phy);
241 
242         /* DMA burst Enable */
243         writel(EHCI_INSNREG00_ENABLE_DMA_BURST, EHCI_INSNREG00(hcd->regs));
244 
245         ehci_resume(hcd, false);
246         return 0;
247 }
248 #else
249 #define exynos_ehci_suspend     NULL
250 #define exynos_ehci_resume      NULL
251 #endif
252 
253 static const struct dev_pm_ops exynos_ehci_pm_ops = {
254         .suspend        = exynos_ehci_suspend,
255         .resume         = exynos_ehci_resume,
256 };
257 
258 #ifdef CONFIG_OF
259 static const struct of_device_id exynos_ehci_match[] = {
260         { .compatible = "samsung,exynos4210-ehci" },
261         { .compatible = "samsung,exynos5440-ehci" },
262         {},
263 };
264 MODULE_DEVICE_TABLE(of, exynos_ehci_match);
265 #endif
266 
267 static struct platform_driver exynos_ehci_driver = {
268         .probe          = exynos_ehci_probe,
269         .remove         = exynos_ehci_remove,
270         .shutdown       = usb_hcd_platform_shutdown,
271         .driver = {
272                 .name   = "exynos-ehci",
273                 .owner  = THIS_MODULE,
274                 .pm     = &exynos_ehci_pm_ops,
275                 .of_match_table = of_match_ptr(exynos_ehci_match),
276         }
277 };
278 static const struct ehci_driver_overrides exynos_overrides __initdata = {
279         .extra_priv_size = sizeof(struct exynos_ehci_hcd),
280 };
281 
282 static int __init ehci_exynos_init(void)
283 {
284         if (usb_disabled())
285                 return -ENODEV;
286 
287         pr_info("%s: " DRIVER_DESC "\n", hcd_name);
288         ehci_init_driver(&exynos_ehci_hc_driver, &exynos_overrides);
289         return platform_driver_register(&exynos_ehci_driver);
290 }
291 module_init(ehci_exynos_init);
292 
293 static void __exit ehci_exynos_cleanup(void)
294 {
295         platform_driver_unregister(&exynos_ehci_driver);
296 }
297 module_exit(ehci_exynos_cleanup);
298 
299 MODULE_DESCRIPTION(DRIVER_DESC);
300 MODULE_ALIAS("platform:exynos-ehci");
301 MODULE_AUTHOR("Jingoo Han");
302 MODULE_AUTHOR("Joonyoung Shim");
303 MODULE_LICENSE("GPL v2");
304 

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