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