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