1/*
2 * SuperH EHCI host controller driver
3 *
4 * Copyright (C) 2010  Paul Mundt
5 *
6 * Based on ohci-sh.c and ehci-atmel.c.
7 *
8 * This file is subject to the terms and conditions of the GNU General Public
9 * License.  See the file "COPYING" in the main directory of this archive
10 * for more details.
11 */
12#include <linux/platform_device.h>
13#include <linux/clk.h>
14#include <linux/platform_data/ehci-sh.h>
15
16struct ehci_sh_priv {
17	struct clk *iclk, *fclk;
18	struct usb_hcd *hcd;
19};
20
21static int ehci_sh_reset(struct usb_hcd *hcd)
22{
23	struct ehci_hcd	*ehci = hcd_to_ehci(hcd);
24
25	ehci->caps = hcd->regs;
26
27	return ehci_setup(hcd);
28}
29
30static const struct hc_driver ehci_sh_hc_driver = {
31	.description			= hcd_name,
32	.product_desc			= "SuperH EHCI",
33	.hcd_priv_size			= sizeof(struct ehci_hcd),
34
35	/*
36	 * generic hardware linkage
37	 */
38	.irq				= ehci_irq,
39	.flags				= HCD_USB2 | HCD_MEMORY | HCD_BH,
40
41	/*
42	 * basic lifecycle operations
43	 */
44	.reset				= ehci_sh_reset,
45	.start				= ehci_run,
46	.stop				= ehci_stop,
47	.shutdown			= ehci_shutdown,
48
49	/*
50	 * managing i/o requests and associated device resources
51	 */
52	.urb_enqueue			= ehci_urb_enqueue,
53	.urb_dequeue			= ehci_urb_dequeue,
54	.endpoint_disable		= ehci_endpoint_disable,
55	.endpoint_reset			= ehci_endpoint_reset,
56
57	/*
58	 * scheduling support
59	 */
60	.get_frame_number		= ehci_get_frame,
61
62	/*
63	 * root hub support
64	 */
65	.hub_status_data		= ehci_hub_status_data,
66	.hub_control			= ehci_hub_control,
67
68#ifdef CONFIG_PM
69	.bus_suspend			= ehci_bus_suspend,
70	.bus_resume			= ehci_bus_resume,
71#endif
72
73	.relinquish_port		= ehci_relinquish_port,
74	.port_handed_over		= ehci_port_handed_over,
75	.clear_tt_buffer_complete	= ehci_clear_tt_buffer_complete,
76};
77
78static int ehci_hcd_sh_probe(struct platform_device *pdev)
79{
80	struct resource *res;
81	struct ehci_sh_priv *priv;
82	struct ehci_sh_platdata *pdata;
83	struct usb_hcd *hcd;
84	int irq, ret;
85
86	if (usb_disabled())
87		return -ENODEV;
88
89	irq = platform_get_irq(pdev, 0);
90	if (irq <= 0) {
91		dev_err(&pdev->dev,
92			"Found HC with no IRQ. Check %s setup!\n",
93			dev_name(&pdev->dev));
94		ret = -ENODEV;
95		goto fail_create_hcd;
96	}
97
98	pdata = dev_get_platdata(&pdev->dev);
99
100	/* initialize hcd */
101	hcd = usb_create_hcd(&ehci_sh_hc_driver, &pdev->dev,
102			     dev_name(&pdev->dev));
103	if (!hcd) {
104		ret = -ENOMEM;
105		goto fail_create_hcd;
106	}
107
108	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
109	hcd->regs = devm_ioremap_resource(&pdev->dev, res);
110	if (IS_ERR(hcd->regs)) {
111		ret = PTR_ERR(hcd->regs);
112		goto fail_request_resource;
113	}
114	hcd->rsrc_start = res->start;
115	hcd->rsrc_len = resource_size(res);
116
117	priv = devm_kzalloc(&pdev->dev, sizeof(struct ehci_sh_priv),
118			    GFP_KERNEL);
119	if (!priv) {
120		ret = -ENOMEM;
121		goto fail_request_resource;
122	}
123
124	/* These are optional, we don't care if they fail */
125	priv->fclk = devm_clk_get(&pdev->dev, "usb_fck");
126	if (IS_ERR(priv->fclk))
127		priv->fclk = NULL;
128
129	priv->iclk = devm_clk_get(&pdev->dev, "usb_ick");
130	if (IS_ERR(priv->iclk))
131		priv->iclk = NULL;
132
133	clk_enable(priv->fclk);
134	clk_enable(priv->iclk);
135
136	if (pdata && pdata->phy_init)
137		pdata->phy_init();
138
139	ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
140	if (ret != 0) {
141		dev_err(&pdev->dev, "Failed to add hcd");
142		goto fail_add_hcd;
143	}
144	device_wakeup_enable(hcd->self.controller);
145
146	priv->hcd = hcd;
147	platform_set_drvdata(pdev, priv);
148
149	return ret;
150
151fail_add_hcd:
152	clk_disable(priv->iclk);
153	clk_disable(priv->fclk);
154
155fail_request_resource:
156	usb_put_hcd(hcd);
157fail_create_hcd:
158	dev_err(&pdev->dev, "init %s fail, %d\n", dev_name(&pdev->dev), ret);
159
160	return ret;
161}
162
163static int ehci_hcd_sh_remove(struct platform_device *pdev)
164{
165	struct ehci_sh_priv *priv = platform_get_drvdata(pdev);
166	struct usb_hcd *hcd = priv->hcd;
167
168	usb_remove_hcd(hcd);
169	usb_put_hcd(hcd);
170
171	clk_disable(priv->fclk);
172	clk_disable(priv->iclk);
173
174	return 0;
175}
176
177static void ehci_hcd_sh_shutdown(struct platform_device *pdev)
178{
179	struct ehci_sh_priv *priv = platform_get_drvdata(pdev);
180	struct usb_hcd *hcd = priv->hcd;
181
182	if (hcd->driver->shutdown)
183		hcd->driver->shutdown(hcd);
184}
185
186static struct platform_driver ehci_hcd_sh_driver = {
187	.probe		= ehci_hcd_sh_probe,
188	.remove		= ehci_hcd_sh_remove,
189	.shutdown	= ehci_hcd_sh_shutdown,
190	.driver		= {
191		.name	= "sh_ehci",
192	},
193};
194
195MODULE_ALIAS("platform:sh_ehci");
196