iio: ABI: add ABI file for the LTC2688 DAC
[linux-2.6-microblaze.git] / drivers / usb / dwc3 / dwc3-imx8mp.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * dwc3-imx8mp.c - NXP imx8mp Specific Glue layer
4  *
5  * Copyright (c) 2020 NXP.
6  */
7
8 #include <linux/clk.h>
9 #include <linux/interrupt.h>
10 #include <linux/io.h>
11 #include <linux/kernel.h>
12 #include <linux/module.h>
13 #include <linux/of_platform.h>
14 #include <linux/platform_device.h>
15 #include <linux/pm_runtime.h>
16
17 #include "core.h"
18
19 /* USB wakeup registers */
20 #define USB_WAKEUP_CTRL                 0x00
21
22 /* Global wakeup interrupt enable, also used to clear interrupt */
23 #define USB_WAKEUP_EN                   BIT(31)
24 /* Wakeup from connect or disconnect, only for superspeed */
25 #define USB_WAKEUP_SS_CONN              BIT(5)
26 /* 0 select vbus_valid, 1 select sessvld */
27 #define USB_WAKEUP_VBUS_SRC_SESS_VAL    BIT(4)
28 /* Enable signal for wake up from u3 state */
29 #define USB_WAKEUP_U3_EN                BIT(3)
30 /* Enable signal for wake up from id change */
31 #define USB_WAKEUP_ID_EN                BIT(2)
32 /* Enable signal for wake up from vbus change */
33 #define USB_WAKEUP_VBUS_EN              BIT(1)
34 /* Enable signal for wake up from dp/dm change */
35 #define USB_WAKEUP_DPDM_EN              BIT(0)
36
37 #define USB_WAKEUP_EN_MASK              GENMASK(5, 0)
38
39 struct dwc3_imx8mp {
40         struct device                   *dev;
41         struct platform_device          *dwc3;
42         void __iomem                    *glue_base;
43         struct clk                      *hsio_clk;
44         struct clk                      *suspend_clk;
45         int                             irq;
46         bool                            pm_suspended;
47         bool                            wakeup_pending;
48 };
49
50 static void dwc3_imx8mp_wakeup_enable(struct dwc3_imx8mp *dwc3_imx)
51 {
52         struct dwc3     *dwc3 = platform_get_drvdata(dwc3_imx->dwc3);
53         u32             val;
54
55         if (!dwc3)
56                 return;
57
58         val = readl(dwc3_imx->glue_base + USB_WAKEUP_CTRL);
59
60         if ((dwc3->current_dr_role == DWC3_GCTL_PRTCAP_HOST) && dwc3->xhci)
61                 val |= USB_WAKEUP_EN | USB_WAKEUP_SS_CONN |
62                        USB_WAKEUP_U3_EN | USB_WAKEUP_DPDM_EN;
63         else if (dwc3->current_dr_role == DWC3_GCTL_PRTCAP_DEVICE)
64                 val |= USB_WAKEUP_EN | USB_WAKEUP_VBUS_EN |
65                        USB_WAKEUP_VBUS_SRC_SESS_VAL;
66
67         writel(val, dwc3_imx->glue_base + USB_WAKEUP_CTRL);
68 }
69
70 static void dwc3_imx8mp_wakeup_disable(struct dwc3_imx8mp *dwc3_imx)
71 {
72         u32 val;
73
74         val = readl(dwc3_imx->glue_base + USB_WAKEUP_CTRL);
75         val &= ~(USB_WAKEUP_EN | USB_WAKEUP_EN_MASK);
76         writel(val, dwc3_imx->glue_base + USB_WAKEUP_CTRL);
77 }
78
79 static irqreturn_t dwc3_imx8mp_interrupt(int irq, void *_dwc3_imx)
80 {
81         struct dwc3_imx8mp      *dwc3_imx = _dwc3_imx;
82         struct dwc3             *dwc = platform_get_drvdata(dwc3_imx->dwc3);
83
84         if (!dwc3_imx->pm_suspended)
85                 return IRQ_HANDLED;
86
87         disable_irq_nosync(dwc3_imx->irq);
88         dwc3_imx->wakeup_pending = true;
89
90         if ((dwc->current_dr_role == DWC3_GCTL_PRTCAP_HOST) && dwc->xhci)
91                 pm_runtime_resume(&dwc->xhci->dev);
92         else if (dwc->current_dr_role == DWC3_GCTL_PRTCAP_DEVICE)
93                 pm_runtime_get(dwc->dev);
94
95         return IRQ_HANDLED;
96 }
97
98 static int dwc3_imx8mp_probe(struct platform_device *pdev)
99 {
100         struct device           *dev = &pdev->dev;
101         struct device_node      *dwc3_np, *node = dev->of_node;
102         struct dwc3_imx8mp      *dwc3_imx;
103         int                     err, irq;
104
105         if (!node) {
106                 dev_err(dev, "device node not found\n");
107                 return -EINVAL;
108         }
109
110         dwc3_imx = devm_kzalloc(dev, sizeof(*dwc3_imx), GFP_KERNEL);
111         if (!dwc3_imx)
112                 return -ENOMEM;
113
114         platform_set_drvdata(pdev, dwc3_imx);
115
116         dwc3_imx->dev = dev;
117
118         dwc3_imx->glue_base = devm_platform_ioremap_resource(pdev, 0);
119         if (IS_ERR(dwc3_imx->glue_base))
120                 return PTR_ERR(dwc3_imx->glue_base);
121
122         dwc3_imx->hsio_clk = devm_clk_get(dev, "hsio");
123         if (IS_ERR(dwc3_imx->hsio_clk)) {
124                 err = PTR_ERR(dwc3_imx->hsio_clk);
125                 dev_err(dev, "Failed to get hsio clk, err=%d\n", err);
126                 return err;
127         }
128
129         err = clk_prepare_enable(dwc3_imx->hsio_clk);
130         if (err) {
131                 dev_err(dev, "Failed to enable hsio clk, err=%d\n", err);
132                 return err;
133         }
134
135         dwc3_imx->suspend_clk = devm_clk_get(dev, "suspend");
136         if (IS_ERR(dwc3_imx->suspend_clk)) {
137                 err = PTR_ERR(dwc3_imx->suspend_clk);
138                 dev_err(dev, "Failed to get suspend clk, err=%d\n", err);
139                 goto disable_hsio_clk;
140         }
141
142         err = clk_prepare_enable(dwc3_imx->suspend_clk);
143         if (err) {
144                 dev_err(dev, "Failed to enable suspend clk, err=%d\n", err);
145                 goto disable_hsio_clk;
146         }
147
148         irq = platform_get_irq(pdev, 0);
149         if (irq < 0) {
150                 err = irq;
151                 goto disable_clks;
152         }
153         dwc3_imx->irq = irq;
154
155         pm_runtime_set_active(dev);
156         pm_runtime_enable(dev);
157         err = pm_runtime_get_sync(dev);
158         if (err < 0)
159                 goto disable_rpm;
160
161         dwc3_np = of_get_compatible_child(node, "snps,dwc3");
162         if (!dwc3_np) {
163                 err = -ENODEV;
164                 dev_err(dev, "failed to find dwc3 core child\n");
165                 goto disable_rpm;
166         }
167
168         err = of_platform_populate(node, NULL, NULL, dev);
169         if (err) {
170                 dev_err(&pdev->dev, "failed to create dwc3 core\n");
171                 goto err_node_put;
172         }
173
174         dwc3_imx->dwc3 = of_find_device_by_node(dwc3_np);
175         if (!dwc3_imx->dwc3) {
176                 dev_err(dev, "failed to get dwc3 platform device\n");
177                 err = -ENODEV;
178                 goto depopulate;
179         }
180         of_node_put(dwc3_np);
181
182         err = devm_request_threaded_irq(dev, irq, NULL, dwc3_imx8mp_interrupt,
183                                         IRQF_ONESHOT, dev_name(dev), dwc3_imx);
184         if (err) {
185                 dev_err(dev, "failed to request IRQ #%d --> %d\n", irq, err);
186                 goto depopulate;
187         }
188
189         device_set_wakeup_capable(dev, true);
190         pm_runtime_put(dev);
191
192         return 0;
193
194 depopulate:
195         of_platform_depopulate(dev);
196 err_node_put:
197         of_node_put(dwc3_np);
198 disable_rpm:
199         pm_runtime_disable(dev);
200         pm_runtime_put_noidle(dev);
201 disable_clks:
202         clk_disable_unprepare(dwc3_imx->suspend_clk);
203 disable_hsio_clk:
204         clk_disable_unprepare(dwc3_imx->hsio_clk);
205
206         return err;
207 }
208
209 static int dwc3_imx8mp_remove(struct platform_device *pdev)
210 {
211         struct dwc3_imx8mp *dwc3_imx = platform_get_drvdata(pdev);
212         struct device *dev = &pdev->dev;
213
214         pm_runtime_get_sync(dev);
215         of_platform_depopulate(dev);
216
217         clk_disable_unprepare(dwc3_imx->suspend_clk);
218         clk_disable_unprepare(dwc3_imx->hsio_clk);
219
220         pm_runtime_disable(dev);
221         pm_runtime_put_noidle(dev);
222         platform_set_drvdata(pdev, NULL);
223
224         return 0;
225 }
226
227 static int __maybe_unused dwc3_imx8mp_suspend(struct dwc3_imx8mp *dwc3_imx,
228                                               pm_message_t msg)
229 {
230         if (dwc3_imx->pm_suspended)
231                 return 0;
232
233         /* Wakeup enable */
234         if (PMSG_IS_AUTO(msg) || device_may_wakeup(dwc3_imx->dev))
235                 dwc3_imx8mp_wakeup_enable(dwc3_imx);
236
237         dwc3_imx->pm_suspended = true;
238
239         return 0;
240 }
241
242 static int __maybe_unused dwc3_imx8mp_resume(struct dwc3_imx8mp *dwc3_imx,
243                                              pm_message_t msg)
244 {
245         struct dwc3     *dwc = platform_get_drvdata(dwc3_imx->dwc3);
246         int ret = 0;
247
248         if (!dwc3_imx->pm_suspended)
249                 return 0;
250
251         /* Wakeup disable */
252         dwc3_imx8mp_wakeup_disable(dwc3_imx);
253         dwc3_imx->pm_suspended = false;
254
255         if (dwc3_imx->wakeup_pending) {
256                 dwc3_imx->wakeup_pending = false;
257                 if (dwc->current_dr_role == DWC3_GCTL_PRTCAP_DEVICE) {
258                         pm_runtime_mark_last_busy(dwc->dev);
259                         pm_runtime_put_autosuspend(dwc->dev);
260                 } else {
261                         /*
262                          * Add wait for xhci switch from suspend
263                          * clock to normal clock to detect connection.
264                          */
265                         usleep_range(9000, 10000);
266                 }
267                 enable_irq(dwc3_imx->irq);
268         }
269
270         return ret;
271 }
272
273 static int __maybe_unused dwc3_imx8mp_pm_suspend(struct device *dev)
274 {
275         struct dwc3_imx8mp *dwc3_imx = dev_get_drvdata(dev);
276         int ret;
277
278         ret = dwc3_imx8mp_suspend(dwc3_imx, PMSG_SUSPEND);
279
280         if (device_may_wakeup(dwc3_imx->dev))
281                 enable_irq_wake(dwc3_imx->irq);
282         else
283                 clk_disable_unprepare(dwc3_imx->suspend_clk);
284
285         clk_disable_unprepare(dwc3_imx->hsio_clk);
286         dev_dbg(dev, "dwc3 imx8mp pm suspend.\n");
287
288         return ret;
289 }
290
291 static int __maybe_unused dwc3_imx8mp_pm_resume(struct device *dev)
292 {
293         struct dwc3_imx8mp *dwc3_imx = dev_get_drvdata(dev);
294         int ret;
295
296         if (device_may_wakeup(dwc3_imx->dev)) {
297                 disable_irq_wake(dwc3_imx->irq);
298         } else {
299                 ret = clk_prepare_enable(dwc3_imx->suspend_clk);
300                 if (ret)
301                         return ret;
302         }
303
304         ret = clk_prepare_enable(dwc3_imx->hsio_clk);
305         if (ret)
306                 return ret;
307
308         ret = dwc3_imx8mp_resume(dwc3_imx, PMSG_RESUME);
309
310         pm_runtime_disable(dev);
311         pm_runtime_set_active(dev);
312         pm_runtime_enable(dev);
313
314         dev_dbg(dev, "dwc3 imx8mp pm resume.\n");
315
316         return ret;
317 }
318
319 static int __maybe_unused dwc3_imx8mp_runtime_suspend(struct device *dev)
320 {
321         struct dwc3_imx8mp *dwc3_imx = dev_get_drvdata(dev);
322
323         dev_dbg(dev, "dwc3 imx8mp runtime suspend.\n");
324
325         return dwc3_imx8mp_suspend(dwc3_imx, PMSG_AUTO_SUSPEND);
326 }
327
328 static int __maybe_unused dwc3_imx8mp_runtime_resume(struct device *dev)
329 {
330         struct dwc3_imx8mp *dwc3_imx = dev_get_drvdata(dev);
331
332         dev_dbg(dev, "dwc3 imx8mp runtime resume.\n");
333
334         return dwc3_imx8mp_resume(dwc3_imx, PMSG_AUTO_RESUME);
335 }
336
337 static const struct dev_pm_ops dwc3_imx8mp_dev_pm_ops = {
338         SET_SYSTEM_SLEEP_PM_OPS(dwc3_imx8mp_pm_suspend, dwc3_imx8mp_pm_resume)
339         SET_RUNTIME_PM_OPS(dwc3_imx8mp_runtime_suspend,
340                            dwc3_imx8mp_runtime_resume, NULL)
341 };
342
343 static const struct of_device_id dwc3_imx8mp_of_match[] = {
344         { .compatible = "fsl,imx8mp-dwc3", },
345         {},
346 };
347 MODULE_DEVICE_TABLE(of, dwc3_imx8mp_of_match);
348
349 static struct platform_driver dwc3_imx8mp_driver = {
350         .probe          = dwc3_imx8mp_probe,
351         .remove         = dwc3_imx8mp_remove,
352         .driver         = {
353                 .name   = "imx8mp-dwc3",
354                 .pm     = &dwc3_imx8mp_dev_pm_ops,
355                 .of_match_table = dwc3_imx8mp_of_match,
356         },
357 };
358
359 module_platform_driver(dwc3_imx8mp_driver);
360
361 MODULE_ALIAS("platform:imx8mp-dwc3");
362 MODULE_AUTHOR("jun.li@nxp.com");
363 MODULE_LICENSE("GPL v2");
364 MODULE_DESCRIPTION("DesignWare USB3 imx8mp Glue Layer");