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