1 // SPDX-License-Identifier: GPL-2.0+
3 * Copyright 2012 Freescale Semiconductor, Inc.
4 * Copyright (C) 2012 Marek Vasut <marex@denx.de>
5 * on behalf of DENX Software Engineering GmbH
8 #include <linux/module.h>
9 #include <linux/of_platform.h>
10 #include <linux/of_gpio.h>
11 #include <linux/platform_device.h>
12 #include <linux/pm_runtime.h>
13 #include <linux/dma-mapping.h>
14 #include <linux/usb/chipidea.h>
15 #include <linux/usb/of.h>
16 #include <linux/clk.h>
19 #include "ci_hdrc_imx.h"
21 struct ci_hdrc_imx_platform_flag
{
25 static const struct ci_hdrc_imx_platform_flag imx23_usb_data
= {
26 .flags
= CI_HDRC_TURN_VBUS_EARLY_ON
|
27 CI_HDRC_DISABLE_STREAMING
,
30 static const struct ci_hdrc_imx_platform_flag imx27_usb_data
= {
31 .flags
= CI_HDRC_DISABLE_STREAMING
,
34 static const struct ci_hdrc_imx_platform_flag imx28_usb_data
= {
35 .flags
= CI_HDRC_IMX28_WRITE_FIX
|
36 CI_HDRC_TURN_VBUS_EARLY_ON
|
37 CI_HDRC_DISABLE_STREAMING
,
40 static const struct ci_hdrc_imx_platform_flag imx6q_usb_data
= {
41 .flags
= CI_HDRC_SUPPORTS_RUNTIME_PM
|
42 CI_HDRC_TURN_VBUS_EARLY_ON
|
43 CI_HDRC_DISABLE_STREAMING
,
46 static const struct ci_hdrc_imx_platform_flag imx6sl_usb_data
= {
47 .flags
= CI_HDRC_SUPPORTS_RUNTIME_PM
|
48 CI_HDRC_TURN_VBUS_EARLY_ON
|
49 CI_HDRC_DISABLE_HOST_STREAMING
,
52 static const struct ci_hdrc_imx_platform_flag imx6sx_usb_data
= {
53 .flags
= CI_HDRC_SUPPORTS_RUNTIME_PM
|
54 CI_HDRC_TURN_VBUS_EARLY_ON
|
55 CI_HDRC_DISABLE_HOST_STREAMING
,
58 static const struct ci_hdrc_imx_platform_flag imx6ul_usb_data
= {
59 .flags
= CI_HDRC_SUPPORTS_RUNTIME_PM
|
60 CI_HDRC_TURN_VBUS_EARLY_ON
,
63 static const struct ci_hdrc_imx_platform_flag imx7d_usb_data
= {
64 .flags
= CI_HDRC_SUPPORTS_RUNTIME_PM
,
67 static const struct of_device_id ci_hdrc_imx_dt_ids
[] = {
68 { .compatible
= "fsl,imx23-usb", .data
= &imx23_usb_data
},
69 { .compatible
= "fsl,imx28-usb", .data
= &imx28_usb_data
},
70 { .compatible
= "fsl,imx27-usb", .data
= &imx27_usb_data
},
71 { .compatible
= "fsl,imx6q-usb", .data
= &imx6q_usb_data
},
72 { .compatible
= "fsl,imx6sl-usb", .data
= &imx6sl_usb_data
},
73 { .compatible
= "fsl,imx6sx-usb", .data
= &imx6sx_usb_data
},
74 { .compatible
= "fsl,imx6ul-usb", .data
= &imx6ul_usb_data
},
75 { .compatible
= "fsl,imx7d-usb", .data
= &imx7d_usb_data
},
78 MODULE_DEVICE_TABLE(of
, ci_hdrc_imx_dt_ids
);
80 struct ci_hdrc_imx_data
{
82 struct platform_device
*ci_pdev
;
84 struct imx_usbmisc_data
*usbmisc_data
;
85 bool supports_runtime_pm
;
86 bool override_phy_control
;
88 /* SoC before i.mx6 (except imx23/imx28) needs three clks */
93 /* --------------------------------- */
96 /* Common functions shared by usbmisc drivers */
98 static struct imx_usbmisc_data
*usbmisc_get_init_data(struct device
*dev
)
100 struct platform_device
*misc_pdev
;
101 struct device_node
*np
= dev
->of_node
;
102 struct of_phandle_args args
;
103 struct imx_usbmisc_data
*data
;
107 * In case the fsl,usbmisc property is not present this device doesn't
108 * need usbmisc. Return NULL (which is no error here)
110 if (!of_get_property(np
, "fsl,usbmisc", NULL
))
113 data
= devm_kzalloc(dev
, sizeof(*data
), GFP_KERNEL
);
115 return ERR_PTR(-ENOMEM
);
117 ret
= of_parse_phandle_with_args(np
, "fsl,usbmisc", "#index-cells",
120 dev_err(dev
, "Failed to parse property fsl,usbmisc, errno %d\n",
125 data
->index
= args
.args
[0];
127 misc_pdev
= of_find_device_by_node(args
.np
);
128 of_node_put(args
.np
);
130 if (!misc_pdev
|| !platform_get_drvdata(misc_pdev
))
131 return ERR_PTR(-EPROBE_DEFER
);
133 data
->dev
= &misc_pdev
->dev
;
135 if (of_find_property(np
, "disable-over-current", NULL
))
136 data
->disable_oc
= 1;
138 if (of_find_property(np
, "over-current-active-high", NULL
))
139 data
->oc_polarity
= 1;
141 if (of_find_property(np
, "external-vbus-divider", NULL
))
144 if (of_usb_get_phy_mode(np
) == USBPHY_INTERFACE_MODE_ULPI
)
150 /* End of common functions shared by usbmisc drivers*/
151 static int imx_get_clks(struct device
*dev
)
153 struct ci_hdrc_imx_data
*data
= dev_get_drvdata(dev
);
156 data
->clk_ipg
= devm_clk_get(dev
, "ipg");
157 if (IS_ERR(data
->clk_ipg
)) {
158 /* If the platform only needs one clocks */
159 data
->clk
= devm_clk_get(dev
, NULL
);
160 if (IS_ERR(data
->clk
)) {
161 ret
= PTR_ERR(data
->clk
);
163 "Failed to get clks, err=%ld,%ld\n",
164 PTR_ERR(data
->clk
), PTR_ERR(data
->clk_ipg
));
170 data
->clk_ahb
= devm_clk_get(dev
, "ahb");
171 if (IS_ERR(data
->clk_ahb
)) {
172 ret
= PTR_ERR(data
->clk_ahb
);
174 "Failed to get ahb clock, err=%d\n", ret
);
178 data
->clk_per
= devm_clk_get(dev
, "per");
179 if (IS_ERR(data
->clk_per
)) {
180 ret
= PTR_ERR(data
->clk_per
);
182 "Failed to get per clock, err=%d\n", ret
);
186 data
->need_three_clks
= true;
190 static int imx_prepare_enable_clks(struct device
*dev
)
192 struct ci_hdrc_imx_data
*data
= dev_get_drvdata(dev
);
195 if (data
->need_three_clks
) {
196 ret
= clk_prepare_enable(data
->clk_ipg
);
199 "Failed to prepare/enable ipg clk, err=%d\n",
204 ret
= clk_prepare_enable(data
->clk_ahb
);
207 "Failed to prepare/enable ahb clk, err=%d\n",
209 clk_disable_unprepare(data
->clk_ipg
);
213 ret
= clk_prepare_enable(data
->clk_per
);
216 "Failed to prepare/enable per clk, err=%d\n",
218 clk_disable_unprepare(data
->clk_ahb
);
219 clk_disable_unprepare(data
->clk_ipg
);
223 ret
= clk_prepare_enable(data
->clk
);
226 "Failed to prepare/enable clk, err=%d\n",
235 static void imx_disable_unprepare_clks(struct device
*dev
)
237 struct ci_hdrc_imx_data
*data
= dev_get_drvdata(dev
);
239 if (data
->need_three_clks
) {
240 clk_disable_unprepare(data
->clk_per
);
241 clk_disable_unprepare(data
->clk_ahb
);
242 clk_disable_unprepare(data
->clk_ipg
);
244 clk_disable_unprepare(data
->clk
);
248 static int ci_hdrc_imx_probe(struct platform_device
*pdev
)
250 struct ci_hdrc_imx_data
*data
;
251 struct ci_hdrc_platform_data pdata
= {
252 .name
= dev_name(&pdev
->dev
),
253 .capoffset
= DEF_CAPOFFSET
,
256 const struct of_device_id
*of_id
;
257 const struct ci_hdrc_imx_platform_flag
*imx_platform_flag
;
258 struct device_node
*np
= pdev
->dev
.of_node
;
260 of_id
= of_match_device(ci_hdrc_imx_dt_ids
, &pdev
->dev
);
264 imx_platform_flag
= of_id
->data
;
266 data
= devm_kzalloc(&pdev
->dev
, sizeof(*data
), GFP_KERNEL
);
270 platform_set_drvdata(pdev
, data
);
271 data
->usbmisc_data
= usbmisc_get_init_data(&pdev
->dev
);
272 if (IS_ERR(data
->usbmisc_data
))
273 return PTR_ERR(data
->usbmisc_data
);
275 ret
= imx_get_clks(&pdev
->dev
);
279 ret
= imx_prepare_enable_clks(&pdev
->dev
);
283 data
->phy
= devm_usb_get_phy_by_phandle(&pdev
->dev
, "fsl,usbphy", 0);
284 if (IS_ERR(data
->phy
)) {
285 ret
= PTR_ERR(data
->phy
);
286 /* Return -EINVAL if no usbphy is available */
292 pdata
.usb_phy
= data
->phy
;
294 if (of_device_is_compatible(np
, "fsl,imx53-usb") && pdata
.usb_phy
&&
295 of_usb_get_phy_mode(np
) == USBPHY_INTERFACE_MODE_ULPI
) {
296 pdata
.flags
|= CI_HDRC_OVERRIDE_PHY_CONTROL
;
297 data
->override_phy_control
= true;
298 usb_phy_init(pdata
.usb_phy
);
301 pdata
.flags
|= imx_platform_flag
->flags
;
302 if (pdata
.flags
& CI_HDRC_SUPPORTS_RUNTIME_PM
)
303 data
->supports_runtime_pm
= true;
305 ret
= imx_usbmisc_init(data
->usbmisc_data
);
307 dev_err(&pdev
->dev
, "usbmisc init failed, ret=%d\n", ret
);
311 data
->ci_pdev
= ci_hdrc_add_device(&pdev
->dev
,
312 pdev
->resource
, pdev
->num_resources
,
314 if (IS_ERR(data
->ci_pdev
)) {
315 ret
= PTR_ERR(data
->ci_pdev
);
316 if (ret
!= -EPROBE_DEFER
)
318 "ci_hdrc_add_device failed, err=%d\n", ret
);
322 ret
= imx_usbmisc_init_post(data
->usbmisc_data
);
324 dev_err(&pdev
->dev
, "usbmisc post failed, ret=%d\n", ret
);
328 if (data
->supports_runtime_pm
) {
329 pm_runtime_set_active(&pdev
->dev
);
330 pm_runtime_enable(&pdev
->dev
);
333 device_set_wakeup_capable(&pdev
->dev
, true);
338 ci_hdrc_remove_device(data
->ci_pdev
);
340 imx_disable_unprepare_clks(&pdev
->dev
);
344 static int ci_hdrc_imx_remove(struct platform_device
*pdev
)
346 struct ci_hdrc_imx_data
*data
= platform_get_drvdata(pdev
);
348 if (data
->supports_runtime_pm
) {
349 pm_runtime_get_sync(&pdev
->dev
);
350 pm_runtime_disable(&pdev
->dev
);
351 pm_runtime_put_noidle(&pdev
->dev
);
353 ci_hdrc_remove_device(data
->ci_pdev
);
354 if (data
->override_phy_control
)
355 usb_phy_shutdown(data
->phy
);
356 imx_disable_unprepare_clks(&pdev
->dev
);
361 static void ci_hdrc_imx_shutdown(struct platform_device
*pdev
)
363 ci_hdrc_imx_remove(pdev
);
367 static int imx_controller_suspend(struct device
*dev
)
369 struct ci_hdrc_imx_data
*data
= dev_get_drvdata(dev
);
371 dev_dbg(dev
, "at %s\n", __func__
);
373 imx_disable_unprepare_clks(dev
);
379 static int imx_controller_resume(struct device
*dev
)
381 struct ci_hdrc_imx_data
*data
= dev_get_drvdata(dev
);
384 dev_dbg(dev
, "at %s\n", __func__
);
391 ret
= imx_prepare_enable_clks(dev
);
395 data
->in_lpm
= false;
397 ret
= imx_usbmisc_set_wakeup(data
->usbmisc_data
, false);
399 dev_err(dev
, "usbmisc set_wakeup failed, ret=%d\n", ret
);
406 imx_disable_unprepare_clks(dev
);
410 #ifdef CONFIG_PM_SLEEP
411 static int ci_hdrc_imx_suspend(struct device
*dev
)
415 struct ci_hdrc_imx_data
*data
= dev_get_drvdata(dev
);
418 /* The core's suspend doesn't run */
421 if (device_may_wakeup(dev
)) {
422 ret
= imx_usbmisc_set_wakeup(data
->usbmisc_data
, true);
424 dev_err(dev
, "usbmisc set_wakeup failed, ret=%d\n",
430 return imx_controller_suspend(dev
);
433 static int ci_hdrc_imx_resume(struct device
*dev
)
435 struct ci_hdrc_imx_data
*data
= dev_get_drvdata(dev
);
438 ret
= imx_controller_resume(dev
);
439 if (!ret
&& data
->supports_runtime_pm
) {
440 pm_runtime_disable(dev
);
441 pm_runtime_set_active(dev
);
442 pm_runtime_enable(dev
);
447 #endif /* CONFIG_PM_SLEEP */
449 static int ci_hdrc_imx_runtime_suspend(struct device
*dev
)
451 struct ci_hdrc_imx_data
*data
= dev_get_drvdata(dev
);
459 ret
= imx_usbmisc_set_wakeup(data
->usbmisc_data
, true);
461 dev_err(dev
, "usbmisc set_wakeup failed, ret=%d\n", ret
);
465 return imx_controller_suspend(dev
);
468 static int ci_hdrc_imx_runtime_resume(struct device
*dev
)
470 return imx_controller_resume(dev
);
473 #endif /* CONFIG_PM */
475 static const struct dev_pm_ops ci_hdrc_imx_pm_ops
= {
476 SET_SYSTEM_SLEEP_PM_OPS(ci_hdrc_imx_suspend
, ci_hdrc_imx_resume
)
477 SET_RUNTIME_PM_OPS(ci_hdrc_imx_runtime_suspend
,
478 ci_hdrc_imx_runtime_resume
, NULL
)
480 static struct platform_driver ci_hdrc_imx_driver
= {
481 .probe
= ci_hdrc_imx_probe
,
482 .remove
= ci_hdrc_imx_remove
,
483 .shutdown
= ci_hdrc_imx_shutdown
,
486 .of_match_table
= ci_hdrc_imx_dt_ids
,
487 .pm
= &ci_hdrc_imx_pm_ops
,
491 module_platform_driver(ci_hdrc_imx_driver
);
493 MODULE_ALIAS("platform:imx-usb");
494 MODULE_LICENSE("GPL v2");
495 MODULE_DESCRIPTION("CI HDRC i.MX USB binding");
496 MODULE_AUTHOR("Marek Vasut <marex@denx.de>");
497 MODULE_AUTHOR("Richard Zhao <richard.zhao@freescale.com>");