1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * Copyright (c) 2008 Sascha Hauer <s.hauer@pengutronix.de>, Pengutronix
4 * Copyright (c) 2009 Daniel Mack <daniel@caiaq.de>
5 */
6
7#include <linux/kernel.h>
8#include <linux/module.h>
9#include <linux/io.h>
10#include <linux/platform_device.h>
11#include <linux/clk.h>
12#include <linux/delay.h>
13#include <linux/usb/otg.h>
14#include <linux/usb/ulpi.h>
15#include <linux/slab.h>
16#include <linux/usb.h>
17#include <linux/usb/hcd.h>
18#include <linux/platform_data/usb-ehci-mxc.h>
19#include "ehci.h"
20
21#define DRIVER_DESC "Freescale On-Chip EHCI Host driver"
22
23static const char hcd_name[] = "ehci-mxc";
24
25#define ULPI_VIEWPORT_OFFSET	0x170
26
27struct ehci_mxc_priv {
28	struct clk *usbclk, *ahbclk, *phyclk;
29};
30
31static struct hc_driver __read_mostly ehci_mxc_hc_driver;
32
33static const struct ehci_driver_overrides ehci_mxc_overrides __initconst = {
34	.extra_priv_size =	sizeof(struct ehci_mxc_priv),
35};
36
37static int ehci_mxc_drv_probe(struct platform_device *pdev)
38{
39	struct device *dev = &pdev->dev;
40	struct mxc_usbh_platform_data *pdata = dev_get_platdata(dev);
41	struct usb_hcd *hcd;
42	struct resource *res;
43	int irq, ret;
44	struct ehci_mxc_priv *priv;
45	struct ehci_hcd *ehci;
46
47	if (!pdata) {
48		dev_err(dev, "No platform data given, bailing out.\n");
49		return -EINVAL;
50	}
51
52	irq = platform_get_irq(pdev, 0);
53	if (irq < 0)
54		return irq;
55
56	hcd = usb_create_hcd(&ehci_mxc_hc_driver, dev, dev_name(dev));
57	if (!hcd)
58		return -ENOMEM;
59
60	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
61	hcd->regs = devm_ioremap_resource(dev, res);
62	if (IS_ERR(hcd->regs)) {
63		ret = PTR_ERR(hcd->regs);
64		goto err_alloc;
65	}
66	hcd->rsrc_start = res->start;
67	hcd->rsrc_len = resource_size(res);
68
69	hcd->has_tt = 1;
70	ehci = hcd_to_ehci(hcd);
71	priv = (struct ehci_mxc_priv *) ehci->priv;
72
73	/* enable clocks */
74	priv->usbclk = devm_clk_get(dev, "ipg");
75	if (IS_ERR(priv->usbclk)) {
76		ret = PTR_ERR(priv->usbclk);
77		goto err_alloc;
78	}
79	clk_prepare_enable(priv->usbclk);
80
81	priv->ahbclk = devm_clk_get(dev, "ahb");
82	if (IS_ERR(priv->ahbclk)) {
83		ret = PTR_ERR(priv->ahbclk);
84		goto err_clk_ahb;
85	}
86	clk_prepare_enable(priv->ahbclk);
87
88	/* "dr" device has its own clock on i.MX51 */
89	priv->phyclk = devm_clk_get(dev, "phy");
90	if (IS_ERR(priv->phyclk))
91		priv->phyclk = NULL;
92	if (priv->phyclk)
93		clk_prepare_enable(priv->phyclk);
94
95	/* call platform specific init function */
96	if (pdata->init) {
97		ret = pdata->init(pdev);
98		if (ret) {
99			dev_err(dev, "platform init failed\n");
100			goto err_init;
101		}
102		/* platforms need some time to settle changed IO settings */
103		mdelay(10);
104	}
105
106	/* EHCI registers start at offset 0x100 */
107	ehci->caps = hcd->regs + 0x100;
108	ehci->regs = hcd->regs + 0x100 +
109		HC_LENGTH(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
110
111	/* set up the PORTSCx register */
112	ehci_writel(ehci, pdata->portsc, &ehci->regs->port_status[0]);
113
114	/* is this really needed? */
115	msleep(10);
116
117	/* Initialize the transceiver */
118	if (pdata->otg) {
119		pdata->otg->io_priv = hcd->regs + ULPI_VIEWPORT_OFFSET;
120		ret = usb_phy_init(pdata->otg);
121		if (ret) {
122			dev_err(dev, "unable to init transceiver, probably missing\n");
123			ret = -ENODEV;
124			goto err_add;
125		}
126		ret = otg_set_vbus(pdata->otg->otg, 1);
127		if (ret) {
128			dev_err(dev, "unable to enable vbus on transceiver\n");
129			goto err_add;
130		}
131	}
132
133	platform_set_drvdata(pdev, hcd);
134
135	ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
136	if (ret)
137		goto err_add;
138
139	device_wakeup_enable(hcd->self.controller);
140	return 0;
141
142err_add:
143	if (pdata && pdata->exit)
144		pdata->exit(pdev);
145err_init:
146	if (priv->phyclk)
147		clk_disable_unprepare(priv->phyclk);
148
149	clk_disable_unprepare(priv->ahbclk);
150err_clk_ahb:
151	clk_disable_unprepare(priv->usbclk);
152err_alloc:
153	usb_put_hcd(hcd);
154	return ret;
155}
156
157static int ehci_mxc_drv_remove(struct platform_device *pdev)
158{
159	struct mxc_usbh_platform_data *pdata = dev_get_platdata(&pdev->dev);
160	struct usb_hcd *hcd = platform_get_drvdata(pdev);
161	struct ehci_hcd *ehci = hcd_to_ehci(hcd);
162	struct ehci_mxc_priv *priv = (struct ehci_mxc_priv *) ehci->priv;
163
164	usb_remove_hcd(hcd);
165
166	if (pdata && pdata->exit)
167		pdata->exit(pdev);
168
169	if (pdata && pdata->otg)
170		usb_phy_shutdown(pdata->otg);
171
172	clk_disable_unprepare(priv->usbclk);
173	clk_disable_unprepare(priv->ahbclk);
174
175	if (priv->phyclk)
176		clk_disable_unprepare(priv->phyclk);
177
178	usb_put_hcd(hcd);
179	return 0;
180}
181
182MODULE_ALIAS("platform:mxc-ehci");
183
184static struct platform_driver ehci_mxc_driver = {
185	.probe = ehci_mxc_drv_probe,
186	.remove = ehci_mxc_drv_remove,
187	.shutdown = usb_hcd_platform_shutdown,
188	.driver = {
189		   .name = "mxc-ehci",
190	},
191};
192
193static int __init ehci_mxc_init(void)
194{
195	if (usb_disabled())
196		return -ENODEV;
197
198	pr_info("%s: " DRIVER_DESC "\n", hcd_name);
199
200	ehci_init_driver(&ehci_mxc_hc_driver, &ehci_mxc_overrides);
201	return platform_driver_register(&ehci_mxc_driver);
202}
203module_init(ehci_mxc_init);
204
205static void __exit ehci_mxc_cleanup(void)
206{
207	platform_driver_unregister(&ehci_mxc_driver);
208}
209module_exit(ehci_mxc_cleanup);
210
211MODULE_DESCRIPTION(DRIVER_DESC);
212MODULE_AUTHOR("Sascha Hauer");
213MODULE_LICENSE("GPL");
214