2dbb0d86daaaa93543bc4458d66a8919f2da70a5
[releases.git] / ehci-st.c
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(&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(threshold, 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(dev);
66         struct st_ehci_platform_priv *priv = hcd_to_ehci_priv(hcd);
67         int clk, ret;
68
69         ret = reset_control_deassert(priv->pwr);
70         if (ret)
71                 return ret;
72
73         ret = reset_control_deassert(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(priv->clk48, 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(priv->clks[clk]);
87                 if (ret)
88                         goto err_disable_clks;
89         }
90
91         ret = phy_init(priv->phy);
92         if (ret)
93                 goto err_disable_clks;
94
95         ret = phy_power_on(priv->phy);
96         if (ret)
97                 goto err_exit_phy;
98
99         return 0;
100
101 err_exit_phy:
102         phy_exit(priv->phy);
103 err_disable_clks:
104         while (--clk >= 0)
105                 clk_disable_unprepare(priv->clks[clk]);
106 err_assert_reset:
107         reset_control_assert(priv->rst);
108 err_assert_power:
109         reset_control_assert(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(dev);
117         struct st_ehci_platform_priv *priv = hcd_to_ehci_priv(hcd);
118         int clk;
119
120         reset_control_assert(priv->pwr);
121
122         reset_control_assert(priv->rst);
123
124         phy_power_off(priv->phy);
125
126         phy_exit(priv->phy);
127
128         for (clk = USB_MAX_CLKS - 1; clk >= 0; clk--)
129                 if (priv->clks[clk])
130                         clk_disable_unprepare(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(&ehci_platform_hc_driver, &dev->dev,
163                              dev_name(&dev->dev));
164         if (!hcd)
165                 return -ENOMEM;
166
167         platform_set_drvdata(dev, hcd);
168         dev->dev.platform_data = pdata;
169         priv = hcd_to_ehci_priv(hcd);
170
171         priv->phy = devm_phy_get(&dev->dev, "usb");
172         if (IS_ERR(priv->phy)) {
173                 err = PTR_ERR(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(dev->dev.of_node, clk);
179                 if (IS_ERR(priv->clks[clk])) {
180                         err = PTR_ERR(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, "clk48");
191         if (IS_ERR(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, "power");
198         if (IS_ERR(priv->pwr)) {
199                 err = PTR_ERR(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, "softreset");
207         if (IS_ERR(priv->rst)) {
208                 err = PTR_ERR(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(dev, 0, &res_mem);
221         if (IS_ERR(hcd->regs)) {
222                 err = PTR_ERR(hcd->regs);
223                 goto err_put_clks;
224         }
225         hcd->rsrc_start = res_mem->start;
226         hcd->rsrc_len = resource_size(res_mem);
227
228         err = usb_add_hcd(hcd, irq, IRQF_SHARED);
229         if (err)
230                 goto err_put_clks;
231
232         device_wakeup_enable(hcd->self.controller);
233         platform_set_drvdata(dev, hcd);
234
235         return err;
236
237 err_put_clks:
238         while (--clk >= 0)
239                 clk_put(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(dev);
252         struct usb_ehci_pdata *pdata = dev_get_platdata(&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(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, 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(&ehci_platform_hc_driver, &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");