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
29static 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
35struct atmel_ehci_priv {
36	struct clk *iclk;
37	struct clk *uclk;
38	bool clocked;
39};
40
41static struct hc_driver __read_mostly ehci_atmel_hc_driver;
42
43static const struct ehci_driver_overrides ehci_atmel_drv_overrides __initconst = {
44	.extra_priv_size = sizeof(struct atmel_ehci_priv),
45};
46
47/*-------------------------------------------------------------------------*/
48
49static 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
59static 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
69static 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
78static 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
89static 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
165fail_add_hcd:
166	atmel_stop_ehci(pdev);
167fail_request_resource:
168	usb_put_hcd(hcd);
169fail_create_hcd:
170	dev_err(&pdev->dev, "init %s fail, %d\n",
171		dev_name(&pdev->dev), retval);
172
173	return retval;
174}
175
176static 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
189static 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
203static 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
214static const struct of_device_id atmel_ehci_dt_ids[] = {
215	{ .compatible = "atmel,at91sam9g45-ehci" },
216	{ /* sentinel */ }
217};
218
219MODULE_DEVICE_TABLE(of, atmel_ehci_dt_ids);
220#endif
221
222static SIMPLE_DEV_PM_OPS(ehci_atmel_pm_ops, ehci_atmel_drv_suspend,
223					ehci_atmel_drv_resume);
224
225static 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
236static 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}
245module_init(ehci_atmel_init);
246
247static void __exit ehci_atmel_cleanup(void)
248{
249	platform_driver_unregister(&ehci_atmel_driver);
250}
251module_exit(ehci_atmel_cleanup);
252
253MODULE_DESCRIPTION(DRIVER_DESC);
254MODULE_ALIAS("platform:atmel-ehci");
255MODULE_AUTHOR("Nicolas Ferre");
256MODULE_LICENSE("GPL");
257