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");