1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * ST OHCI driver
4  *
5  * Copyright (C) 2014 STMicroelectronics – All Rights Reserved
6  *
7  * Author: Peter Griffin <peter.griffin@linaro.org>
8  *
9  * Derived from ohci-platform.c
10  */
11 
12 #include <linux/clk.h>
13 #include <linux/dma-mapping.h>
14 #include <linux/hrtimer.h>
15 #include <linux/io.h>
16 #include <linux/kernel.h>
17 #include <linux/module.h>
18 #include <linux/err.h>
19 #include <linux/phy/phy.h>
20 #include <linux/platform_device.h>
21 #include <linux/reset.h>
22 #include <linux/usb/ohci_pdriver.h>
23 #include <linux/usb.h>
24 #include <linux/usb/hcd.h>
25 
26 #include "ohci.h"
27 
28 #define USB_MAX_CLKS 3
29 
30 struct st_ohci_platform_priv {
31 	struct clk *clks[USB_MAX_CLKS];
32 	struct clk *clk48;
33 	struct reset_control *rst;
34 	struct reset_control *pwr;
35 	struct phy *phy;
36 };
37 
38 #define DRIVER_DESC "OHCI STMicroelectronics driver"
39 
40 #define hcd_to_ohci_priv(h) \
41 	((struct st_ohci_platform_priv *)hcd_to_ohci(h)->priv)
42 
st_ohci_platform_power_on(struct platform_device * dev)43 static int st_ohci_platform_power_on(struct platform_device *dev)
44 {
45 	struct usb_hcd *hcd = platform_get_drvdata(dev);
46 	struct st_ohci_platform_priv *priv = hcd_to_ohci_priv(hcd);
47 	int clk, ret;
48 
49 	ret = reset_control_deassert(priv->pwr);
50 	if (ret)
51 		return ret;
52 
53 	ret = reset_control_deassert(priv->rst);
54 	if (ret)
55 		goto err_assert_power;
56 
57 	/* some SoCs don't have a dedicated 48Mhz clock, but those that do
58 	   need the rate to be explicitly set */
59 	if (priv->clk48) {
60 		ret = clk_set_rate(priv->clk48, 48000000);
61 		if (ret)
62 			goto err_assert_reset;
63 	}
64 
65 	for (clk = 0; clk < USB_MAX_CLKS && priv->clks[clk]; clk++) {
66 		ret = clk_prepare_enable(priv->clks[clk]);
67 		if (ret)
68 			goto err_disable_clks;
69 	}
70 
71 	ret = phy_init(priv->phy);
72 	if (ret)
73 		goto err_disable_clks;
74 
75 	ret = phy_power_on(priv->phy);
76 	if (ret)
77 		goto err_exit_phy;
78 
79 	return 0;
80 
81 err_exit_phy:
82 	phy_exit(priv->phy);
83 err_disable_clks:
84 	while (--clk >= 0)
85 		clk_disable_unprepare(priv->clks[clk]);
86 err_assert_reset:
87 	reset_control_assert(priv->rst);
88 err_assert_power:
89 	reset_control_assert(priv->pwr);
90 
91 	return ret;
92 }
93 
st_ohci_platform_power_off(struct platform_device * dev)94 static void st_ohci_platform_power_off(struct platform_device *dev)
95 {
96 	struct usb_hcd *hcd = platform_get_drvdata(dev);
97 	struct st_ohci_platform_priv *priv = hcd_to_ohci_priv(hcd);
98 
99 	int clk;
100 
101 	reset_control_assert(priv->pwr);
102 
103 	reset_control_assert(priv->rst);
104 
105 	phy_power_off(priv->phy);
106 
107 	phy_exit(priv->phy);
108 
109 	for (clk = USB_MAX_CLKS - 1; clk >= 0; clk--)
110 		if (priv->clks[clk])
111 			clk_disable_unprepare(priv->clks[clk]);
112 }
113 
114 static struct hc_driver __read_mostly ohci_platform_hc_driver;
115 
116 static const struct ohci_driver_overrides platform_overrides __initconst = {
117 	.product_desc =		"ST OHCI controller",
118 	.extra_priv_size =	sizeof(struct st_ohci_platform_priv),
119 };
120 
121 static struct usb_ohci_pdata ohci_platform_defaults = {
122 	.power_on =		st_ohci_platform_power_on,
123 	.power_suspend =	st_ohci_platform_power_off,
124 	.power_off =		st_ohci_platform_power_off,
125 };
126 
st_ohci_platform_probe(struct platform_device * dev)127 static int st_ohci_platform_probe(struct platform_device *dev)
128 {
129 	struct usb_hcd *hcd;
130 	struct resource *res_mem;
131 	struct usb_ohci_pdata *pdata = &ohci_platform_defaults;
132 	struct st_ohci_platform_priv *priv;
133 	int err, irq, clk = 0;
134 
135 	if (usb_disabled())
136 		return -ENODEV;
137 
138 	irq = platform_get_irq(dev, 0);
139 	if (irq < 0)
140 		return irq;
141 
142 	res_mem = platform_get_resource(dev, IORESOURCE_MEM, 0);
143 	if (!res_mem) {
144 		dev_err(&dev->dev, "no memory resource provided");
145 		return -ENXIO;
146 	}
147 
148 	hcd = usb_create_hcd(&ohci_platform_hc_driver, &dev->dev,
149 			dev_name(&dev->dev));
150 	if (!hcd)
151 		return -ENOMEM;
152 
153 	platform_set_drvdata(dev, hcd);
154 	dev->dev.platform_data = pdata;
155 	priv = hcd_to_ohci_priv(hcd);
156 
157 	priv->phy = devm_phy_get(&dev->dev, "usb");
158 	if (IS_ERR(priv->phy)) {
159 		err = PTR_ERR(priv->phy);
160 		goto err_put_hcd;
161 	}
162 
163 	for (clk = 0; clk < USB_MAX_CLKS; clk++) {
164 		priv->clks[clk] = of_clk_get(dev->dev.of_node, clk);
165 		if (IS_ERR(priv->clks[clk])) {
166 			err = PTR_ERR(priv->clks[clk]);
167 			if (err == -EPROBE_DEFER)
168 				goto err_put_clks;
169 			priv->clks[clk] = NULL;
170 			break;
171 		}
172 	}
173 
174 	/* some SoCs don't have a dedicated 48Mhz clock, but those that
175 	   do need the rate to be explicitly set */
176 	priv->clk48 = devm_clk_get(&dev->dev, "clk48");
177 	if (IS_ERR(priv->clk48)) {
178 		dev_info(&dev->dev, "48MHz clk not found\n");
179 		priv->clk48 = NULL;
180 	}
181 
182 	priv->pwr =
183 		devm_reset_control_get_optional_shared(&dev->dev, "power");
184 	if (IS_ERR(priv->pwr)) {
185 		err = PTR_ERR(priv->pwr);
186 		goto err_put_clks;
187 	}
188 
189 	priv->rst =
190 		devm_reset_control_get_optional_shared(&dev->dev, "softreset");
191 	if (IS_ERR(priv->rst)) {
192 		err = PTR_ERR(priv->rst);
193 		goto err_put_clks;
194 	}
195 
196 	if (pdata->power_on) {
197 		err = pdata->power_on(dev);
198 		if (err < 0)
199 			goto err_power;
200 	}
201 
202 	hcd->rsrc_start = res_mem->start;
203 	hcd->rsrc_len = resource_size(res_mem);
204 
205 	hcd->regs = devm_ioremap_resource(&dev->dev, res_mem);
206 	if (IS_ERR(hcd->regs)) {
207 		err = PTR_ERR(hcd->regs);
208 		goto err_power;
209 	}
210 	err = usb_add_hcd(hcd, irq, IRQF_SHARED);
211 	if (err)
212 		goto err_power;
213 
214 	device_wakeup_enable(hcd->self.controller);
215 
216 	platform_set_drvdata(dev, hcd);
217 
218 	return err;
219 
220 err_power:
221 	if (pdata->power_off)
222 		pdata->power_off(dev);
223 
224 err_put_clks:
225 	while (--clk >= 0)
226 		clk_put(priv->clks[clk]);
227 err_put_hcd:
228 	if (pdata == &ohci_platform_defaults)
229 		dev->dev.platform_data = NULL;
230 
231 	usb_put_hcd(hcd);
232 
233 	return err;
234 }
235 
st_ohci_platform_remove(struct platform_device * dev)236 static int st_ohci_platform_remove(struct platform_device *dev)
237 {
238 	struct usb_hcd *hcd = platform_get_drvdata(dev);
239 	struct usb_ohci_pdata *pdata = dev_get_platdata(&dev->dev);
240 	struct st_ohci_platform_priv *priv = hcd_to_ohci_priv(hcd);
241 	int clk;
242 
243 	usb_remove_hcd(hcd);
244 
245 	if (pdata->power_off)
246 		pdata->power_off(dev);
247 
248 
249 	for (clk = 0; clk < USB_MAX_CLKS && priv->clks[clk]; clk++)
250 		clk_put(priv->clks[clk]);
251 
252 	usb_put_hcd(hcd);
253 
254 	if (pdata == &ohci_platform_defaults)
255 		dev->dev.platform_data = NULL;
256 
257 	return 0;
258 }
259 
260 #ifdef CONFIG_PM_SLEEP
261 
st_ohci_suspend(struct device * dev)262 static int st_ohci_suspend(struct device *dev)
263 {
264 	struct usb_hcd *hcd = dev_get_drvdata(dev);
265 	struct usb_ohci_pdata *pdata = dev->platform_data;
266 	struct platform_device *pdev = to_platform_device(dev);
267 	bool do_wakeup = device_may_wakeup(dev);
268 	int ret;
269 
270 	ret = ohci_suspend(hcd, do_wakeup);
271 	if (ret)
272 		return ret;
273 
274 	if (pdata->power_suspend)
275 		pdata->power_suspend(pdev);
276 
277 	return ret;
278 }
279 
st_ohci_resume(struct device * dev)280 static int st_ohci_resume(struct device *dev)
281 {
282 	struct usb_hcd *hcd = dev_get_drvdata(dev);
283 	struct usb_ohci_pdata *pdata = dev_get_platdata(dev);
284 	struct platform_device *pdev = to_platform_device(dev);
285 	int err;
286 
287 	if (pdata->power_on) {
288 		err = pdata->power_on(pdev);
289 		if (err < 0)
290 			return err;
291 	}
292 
293 	ohci_resume(hcd, false);
294 	return 0;
295 }
296 
297 static SIMPLE_DEV_PM_OPS(st_ohci_pm_ops, st_ohci_suspend, st_ohci_resume);
298 
299 #endif /* CONFIG_PM_SLEEP */
300 
301 static const struct of_device_id st_ohci_platform_ids[] = {
302 	{ .compatible = "st,st-ohci-300x", },
303 	{ /* sentinel */ }
304 };
305 MODULE_DEVICE_TABLE(of, st_ohci_platform_ids);
306 
307 static struct platform_driver ohci_platform_driver = {
308 	.probe		= st_ohci_platform_probe,
309 	.remove		= st_ohci_platform_remove,
310 	.shutdown	= usb_hcd_platform_shutdown,
311 	.driver		= {
312 		.name	= "st-ohci",
313 #ifdef CONFIG_PM_SLEEP
314 		.pm	= &st_ohci_pm_ops,
315 #endif
316 		.of_match_table = st_ohci_platform_ids,
317 	}
318 };
319 
ohci_platform_init(void)320 static int __init ohci_platform_init(void)
321 {
322 	if (usb_disabled())
323 		return -ENODEV;
324 
325 	ohci_init_driver(&ohci_platform_hc_driver, &platform_overrides);
326 	return platform_driver_register(&ohci_platform_driver);
327 }
328 module_init(ohci_platform_init);
329 
ohci_platform_cleanup(void)330 static void __exit ohci_platform_cleanup(void)
331 {
332 	platform_driver_unregister(&ohci_platform_driver);
333 }
334 module_exit(ohci_platform_cleanup);
335 
336 MODULE_DESCRIPTION(DRIVER_DESC);
337 MODULE_AUTHOR("Peter Griffin <peter.griffin@linaro.org>");
338 MODULE_LICENSE("GPL");
339