Richard Zhao | 1530280 | 2012-07-07 22:56:48 +0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2012 Freescale Semiconductor, Inc. |
| 3 | * Copyright (C) 2012 Marek Vasut <marex@denx.de> |
| 4 | * on behalf of DENX Software Engineering GmbH |
| 5 | * |
| 6 | * The code contained herein is licensed under the GNU General Public |
| 7 | * License. You may obtain a copy of the GNU General Public License |
| 8 | * Version 2 or later at the following locations: |
| 9 | * |
| 10 | * http://www.opensource.org/licenses/gpl-license.html |
| 11 | * http://www.gnu.org/copyleft/gpl.html |
| 12 | */ |
| 13 | |
| 14 | #include <linux/module.h> |
| 15 | #include <linux/of_platform.h> |
| 16 | #include <linux/of_gpio.h> |
| 17 | #include <linux/platform_device.h> |
| 18 | #include <linux/pm_runtime.h> |
| 19 | #include <linux/dma-mapping.h> |
| 20 | #include <linux/usb/chipidea.h> |
| 21 | #include <linux/clk.h> |
Richard Zhao | 1530280 | 2012-07-07 22:56:48 +0800 | [diff] [blame] | 22 | |
| 23 | #include "ci.h" |
Alexander Shishkin | 8e22978 | 2013-06-24 14:46:36 +0300 | [diff] [blame] | 24 | #include "ci_hdrc_imx.h" |
Richard Zhao | 1530280 | 2012-07-07 22:56:48 +0800 | [diff] [blame] | 25 | |
Peter Chen | 1071055 | 2014-01-10 13:51:28 +0800 | [diff] [blame] | 26 | struct ci_hdrc_imx_platform_flag { |
| 27 | unsigned int flags; |
| 28 | }; |
| 29 | |
| 30 | static const struct ci_hdrc_imx_platform_flag imx27_usb_data = { |
| 31 | }; |
| 32 | |
| 33 | static const struct ci_hdrc_imx_platform_flag imx28_usb_data = { |
Peter Chen | 5604008 | 2015-02-11 12:44:42 +0800 | [diff] [blame] | 34 | .flags = CI_HDRC_IMX28_WRITE_FIX, |
Peter Chen | 1071055 | 2014-01-10 13:51:28 +0800 | [diff] [blame] | 35 | }; |
| 36 | |
| 37 | static const struct of_device_id ci_hdrc_imx_dt_ids[] = { |
| 38 | { .compatible = "fsl,imx28-usb", .data = &imx28_usb_data}, |
| 39 | { .compatible = "fsl,imx27-usb", .data = &imx27_usb_data}, |
| 40 | { /* sentinel */ } |
| 41 | }; |
| 42 | MODULE_DEVICE_TABLE(of, ci_hdrc_imx_dt_ids); |
| 43 | |
Alexander Shishkin | 8e22978 | 2013-06-24 14:46:36 +0300 | [diff] [blame] | 44 | struct ci_hdrc_imx_data { |
Richard Zhao | 1530280 | 2012-07-07 22:56:48 +0800 | [diff] [blame] | 45 | struct usb_phy *phy; |
| 46 | struct platform_device *ci_pdev; |
| 47 | struct clk *clk; |
Sascha Hauer | 05986ba | 2013-08-14 12:44:16 +0300 | [diff] [blame] | 48 | struct imx_usbmisc_data *usbmisc_data; |
Richard Zhao | 1530280 | 2012-07-07 22:56:48 +0800 | [diff] [blame] | 49 | }; |
| 50 | |
Richard Zhao | d142d6b | 2012-09-12 14:58:05 +0300 | [diff] [blame] | 51 | /* Common functions shared by usbmisc drivers */ |
| 52 | |
Sascha Hauer | 05986ba | 2013-08-14 12:44:16 +0300 | [diff] [blame] | 53 | static struct imx_usbmisc_data *usbmisc_get_init_data(struct device *dev) |
Richard Zhao | d142d6b | 2012-09-12 14:58:05 +0300 | [diff] [blame] | 54 | { |
Stefan Agner | f40017e | 2014-09-22 08:14:15 +0800 | [diff] [blame] | 55 | struct platform_device *misc_pdev; |
Richard Zhao | d142d6b | 2012-09-12 14:58:05 +0300 | [diff] [blame] | 56 | struct device_node *np = dev->of_node; |
| 57 | struct of_phandle_args args; |
Sascha Hauer | 05986ba | 2013-08-14 12:44:16 +0300 | [diff] [blame] | 58 | struct imx_usbmisc_data *data; |
Richard Zhao | d142d6b | 2012-09-12 14:58:05 +0300 | [diff] [blame] | 59 | int ret; |
| 60 | |
Sascha Hauer | 05986ba | 2013-08-14 12:44:16 +0300 | [diff] [blame] | 61 | /* |
| 62 | * In case the fsl,usbmisc property is not present this device doesn't |
| 63 | * need usbmisc. Return NULL (which is no error here) |
| 64 | */ |
| 65 | if (!of_get_property(np, "fsl,usbmisc", NULL)) |
| 66 | return NULL; |
| 67 | |
| 68 | data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); |
| 69 | if (!data) |
| 70 | return ERR_PTR(-ENOMEM); |
Richard Zhao | d142d6b | 2012-09-12 14:58:05 +0300 | [diff] [blame] | 71 | |
| 72 | ret = of_parse_phandle_with_args(np, "fsl,usbmisc", "#index-cells", |
| 73 | 0, &args); |
| 74 | if (ret) { |
| 75 | dev_err(dev, "Failed to parse property fsl,usbmisc, errno %d\n", |
| 76 | ret); |
Sascha Hauer | 05986ba | 2013-08-14 12:44:16 +0300 | [diff] [blame] | 77 | return ERR_PTR(ret); |
Richard Zhao | d142d6b | 2012-09-12 14:58:05 +0300 | [diff] [blame] | 78 | } |
Sascha Hauer | 05986ba | 2013-08-14 12:44:16 +0300 | [diff] [blame] | 79 | |
| 80 | data->index = args.args[0]; |
Stefan Agner | f40017e | 2014-09-22 08:14:15 +0800 | [diff] [blame] | 81 | |
| 82 | misc_pdev = of_find_device_by_node(args.np); |
Richard Zhao | d142d6b | 2012-09-12 14:58:05 +0300 | [diff] [blame] | 83 | of_node_put(args.np); |
| 84 | |
Stefan Agner | f40017e | 2014-09-22 08:14:15 +0800 | [diff] [blame] | 85 | if (!misc_pdev) |
| 86 | return ERR_PTR(-EPROBE_DEFER); |
| 87 | |
| 88 | data->dev = &misc_pdev->dev; |
| 89 | |
Richard Zhao | d142d6b | 2012-09-12 14:58:05 +0300 | [diff] [blame] | 90 | if (of_find_property(np, "disable-over-current", NULL)) |
Sascha Hauer | 05986ba | 2013-08-14 12:44:16 +0300 | [diff] [blame] | 91 | data->disable_oc = 1; |
Richard Zhao | d142d6b | 2012-09-12 14:58:05 +0300 | [diff] [blame] | 92 | |
Michael Grzeschik | a068533 | 2013-03-30 12:54:01 +0200 | [diff] [blame] | 93 | if (of_find_property(np, "external-vbus-divider", NULL)) |
Sascha Hauer | 05986ba | 2013-08-14 12:44:16 +0300 | [diff] [blame] | 94 | data->evdo = 1; |
Michael Grzeschik | a068533 | 2013-03-30 12:54:01 +0200 | [diff] [blame] | 95 | |
Sascha Hauer | 05986ba | 2013-08-14 12:44:16 +0300 | [diff] [blame] | 96 | return data; |
Richard Zhao | d142d6b | 2012-09-12 14:58:05 +0300 | [diff] [blame] | 97 | } |
Richard Zhao | d142d6b | 2012-09-12 14:58:05 +0300 | [diff] [blame] | 98 | |
| 99 | /* End of common functions shared by usbmisc drivers*/ |
| 100 | |
Alexander Shishkin | 8e22978 | 2013-06-24 14:46:36 +0300 | [diff] [blame] | 101 | static int ci_hdrc_imx_probe(struct platform_device *pdev) |
Richard Zhao | 1530280 | 2012-07-07 22:56:48 +0800 | [diff] [blame] | 102 | { |
Alexander Shishkin | 8e22978 | 2013-06-24 14:46:36 +0300 | [diff] [blame] | 103 | struct ci_hdrc_imx_data *data; |
| 104 | struct ci_hdrc_platform_data pdata = { |
Alexander Shiyan | c844d6c | 2014-03-11 13:47:38 +0800 | [diff] [blame] | 105 | .name = dev_name(&pdev->dev), |
Michael Grzeschik | f6a3b3a | 2013-06-13 17:59:58 +0300 | [diff] [blame] | 106 | .capoffset = DEF_CAPOFFSET, |
Peter Chen | 947c885 | 2014-11-26 13:44:31 +0800 | [diff] [blame] | 107 | .flags = CI_HDRC_DISABLE_STREAMING, |
Michael Grzeschik | f6a3b3a | 2013-06-13 17:59:58 +0300 | [diff] [blame] | 108 | }; |
Richard Zhao | 1530280 | 2012-07-07 22:56:48 +0800 | [diff] [blame] | 109 | int ret; |
Peter Chen | 1071055 | 2014-01-10 13:51:28 +0800 | [diff] [blame] | 110 | const struct of_device_id *of_id = |
| 111 | of_match_device(ci_hdrc_imx_dt_ids, &pdev->dev); |
| 112 | const struct ci_hdrc_imx_platform_flag *imx_platform_flag = of_id->data; |
Richard Zhao | 1530280 | 2012-07-07 22:56:48 +0800 | [diff] [blame] | 113 | |
| 114 | data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL); |
Fabio Estevam | 7352982 | 2014-11-26 13:44:24 +0800 | [diff] [blame] | 115 | if (!data) |
Richard Zhao | 1530280 | 2012-07-07 22:56:48 +0800 | [diff] [blame] | 116 | return -ENOMEM; |
Richard Zhao | 1530280 | 2012-07-07 22:56:48 +0800 | [diff] [blame] | 117 | |
Sascha Hauer | 05986ba | 2013-08-14 12:44:16 +0300 | [diff] [blame] | 118 | data->usbmisc_data = usbmisc_get_init_data(&pdev->dev); |
| 119 | if (IS_ERR(data->usbmisc_data)) |
| 120 | return PTR_ERR(data->usbmisc_data); |
| 121 | |
Richard Zhao | 1530280 | 2012-07-07 22:56:48 +0800 | [diff] [blame] | 122 | data->clk = devm_clk_get(&pdev->dev, NULL); |
| 123 | if (IS_ERR(data->clk)) { |
| 124 | dev_err(&pdev->dev, |
| 125 | "Failed to get clock, err=%ld\n", PTR_ERR(data->clk)); |
| 126 | return PTR_ERR(data->clk); |
| 127 | } |
| 128 | |
| 129 | ret = clk_prepare_enable(data->clk); |
| 130 | if (ret) { |
| 131 | dev_err(&pdev->dev, |
| 132 | "Failed to prepare or enable clock, err=%d\n", ret); |
| 133 | return ret; |
| 134 | } |
| 135 | |
Fabio Estevam | 046916d | 2013-06-25 12:58:05 +0300 | [diff] [blame] | 136 | data->phy = devm_usb_get_phy_by_phandle(&pdev->dev, "fsl,usbphy", 0); |
Peter Chen | af59a8b | 2013-09-24 12:47:54 +0800 | [diff] [blame] | 137 | if (IS_ERR(data->phy)) { |
| 138 | ret = PTR_ERR(data->phy); |
Markus Pargmann | 16853d7 | 2014-07-22 10:09:43 +0800 | [diff] [blame] | 139 | /* Return -EINVAL if no usbphy is available */ |
| 140 | if (ret == -ENODEV) |
| 141 | ret = -EINVAL; |
Sascha Hauer | ea1418b | 2013-06-13 18:00:00 +0300 | [diff] [blame] | 142 | goto err_clk; |
Richard Zhao | 1530280 | 2012-07-07 22:56:48 +0800 | [diff] [blame] | 143 | } |
| 144 | |
Antoine Tenart | ef44cb4 | 2014-10-30 18:41:16 +0100 | [diff] [blame] | 145 | pdata.usb_phy = data->phy; |
Peter Chen | 5604008 | 2015-02-11 12:44:42 +0800 | [diff] [blame] | 146 | pdata.flags |= imx_platform_flag->flags; |
Peter Chen | 1071055 | 2014-01-10 13:51:28 +0800 | [diff] [blame] | 147 | |
Russell King | e1fd734 | 2013-06-27 12:36:37 +0100 | [diff] [blame] | 148 | ret = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32)); |
Russell King | 22d9d8e | 2013-06-10 16:28:49 +0100 | [diff] [blame] | 149 | if (ret) |
| 150 | goto err_clk; |
Richard Zhao | d142d6b | 2012-09-12 14:58:05 +0300 | [diff] [blame] | 151 | |
Sascha Hauer | 05986ba | 2013-08-14 12:44:16 +0300 | [diff] [blame] | 152 | if (data->usbmisc_data) { |
| 153 | ret = imx_usbmisc_init(data->usbmisc_data); |
Richard Zhao | d142d6b | 2012-09-12 14:58:05 +0300 | [diff] [blame] | 154 | if (ret) { |
Sascha Hauer | 05986ba | 2013-08-14 12:44:16 +0300 | [diff] [blame] | 155 | dev_err(&pdev->dev, "usbmisc init failed, ret=%d\n", |
| 156 | ret); |
Peter Chen | af59a8b | 2013-09-24 12:47:54 +0800 | [diff] [blame] | 157 | goto err_clk; |
Richard Zhao | d142d6b | 2012-09-12 14:58:05 +0300 | [diff] [blame] | 158 | } |
| 159 | } |
| 160 | |
Alexander Shishkin | 8e22978 | 2013-06-24 14:46:36 +0300 | [diff] [blame] | 161 | data->ci_pdev = ci_hdrc_add_device(&pdev->dev, |
Richard Zhao | 1530280 | 2012-07-07 22:56:48 +0800 | [diff] [blame] | 162 | pdev->resource, pdev->num_resources, |
Michael Grzeschik | f6a3b3a | 2013-06-13 17:59:58 +0300 | [diff] [blame] | 163 | &pdata); |
Fabio Estevam | 770719d | 2013-06-13 17:59:48 +0300 | [diff] [blame] | 164 | if (IS_ERR(data->ci_pdev)) { |
| 165 | ret = PTR_ERR(data->ci_pdev); |
Richard Zhao | 1530280 | 2012-07-07 22:56:48 +0800 | [diff] [blame] | 166 | dev_err(&pdev->dev, |
| 167 | "Can't register ci_hdrc platform device, err=%d\n", |
| 168 | ret); |
Peter Chen | af59a8b | 2013-09-24 12:47:54 +0800 | [diff] [blame] | 169 | goto err_clk; |
Richard Zhao | 1530280 | 2012-07-07 22:56:48 +0800 | [diff] [blame] | 170 | } |
| 171 | |
Sascha Hauer | 05986ba | 2013-08-14 12:44:16 +0300 | [diff] [blame] | 172 | if (data->usbmisc_data) { |
| 173 | ret = imx_usbmisc_init_post(data->usbmisc_data); |
Michael Grzeschik | a068533 | 2013-03-30 12:54:01 +0200 | [diff] [blame] | 174 | if (ret) { |
Sascha Hauer | 05986ba | 2013-08-14 12:44:16 +0300 | [diff] [blame] | 175 | dev_err(&pdev->dev, "usbmisc post failed, ret=%d\n", |
| 176 | ret); |
Fabio Estevam | 770719d | 2013-06-13 17:59:48 +0300 | [diff] [blame] | 177 | goto disable_device; |
Michael Grzeschik | a068533 | 2013-03-30 12:54:01 +0200 | [diff] [blame] | 178 | } |
| 179 | } |
| 180 | |
Richard Zhao | 1530280 | 2012-07-07 22:56:48 +0800 | [diff] [blame] | 181 | platform_set_drvdata(pdev, data); |
| 182 | |
| 183 | pm_runtime_no_callbacks(&pdev->dev); |
| 184 | pm_runtime_enable(&pdev->dev); |
| 185 | |
| 186 | return 0; |
| 187 | |
Fabio Estevam | 770719d | 2013-06-13 17:59:48 +0300 | [diff] [blame] | 188 | disable_device: |
Alexander Shishkin | 8e22978 | 2013-06-24 14:46:36 +0300 | [diff] [blame] | 189 | ci_hdrc_remove_device(data->ci_pdev); |
Sascha Hauer | ea1418b | 2013-06-13 18:00:00 +0300 | [diff] [blame] | 190 | err_clk: |
Richard Zhao | 1530280 | 2012-07-07 22:56:48 +0800 | [diff] [blame] | 191 | clk_disable_unprepare(data->clk); |
| 192 | return ret; |
| 193 | } |
| 194 | |
Alexander Shishkin | 8e22978 | 2013-06-24 14:46:36 +0300 | [diff] [blame] | 195 | static int ci_hdrc_imx_remove(struct platform_device *pdev) |
Richard Zhao | 1530280 | 2012-07-07 22:56:48 +0800 | [diff] [blame] | 196 | { |
Alexander Shishkin | 8e22978 | 2013-06-24 14:46:36 +0300 | [diff] [blame] | 197 | struct ci_hdrc_imx_data *data = platform_get_drvdata(pdev); |
Richard Zhao | 1530280 | 2012-07-07 22:56:48 +0800 | [diff] [blame] | 198 | |
| 199 | pm_runtime_disable(&pdev->dev); |
Alexander Shishkin | 8e22978 | 2013-06-24 14:46:36 +0300 | [diff] [blame] | 200 | ci_hdrc_remove_device(data->ci_pdev); |
Richard Zhao | 1530280 | 2012-07-07 22:56:48 +0800 | [diff] [blame] | 201 | clk_disable_unprepare(data->clk); |
| 202 | |
Richard Zhao | 1530280 | 2012-07-07 22:56:48 +0800 | [diff] [blame] | 203 | return 0; |
| 204 | } |
| 205 | |
Peter Chen | 2558c1f | 2014-11-26 13:44:30 +0800 | [diff] [blame] | 206 | #ifdef CONFIG_PM_SLEEP |
| 207 | static int imx_controller_suspend(struct device *dev) |
| 208 | { |
| 209 | struct ci_hdrc_imx_data *data = dev_get_drvdata(dev); |
| 210 | |
| 211 | dev_dbg(dev, "at %s\n", __func__); |
| 212 | |
| 213 | clk_disable_unprepare(data->clk); |
| 214 | |
| 215 | return 0; |
| 216 | } |
| 217 | |
| 218 | static int imx_controller_resume(struct device *dev) |
| 219 | { |
| 220 | struct ci_hdrc_imx_data *data = dev_get_drvdata(dev); |
| 221 | |
| 222 | dev_dbg(dev, "at %s\n", __func__); |
| 223 | |
| 224 | return clk_prepare_enable(data->clk); |
| 225 | } |
| 226 | |
| 227 | static int ci_hdrc_imx_suspend(struct device *dev) |
| 228 | { |
| 229 | return imx_controller_suspend(dev); |
| 230 | } |
| 231 | |
| 232 | static int ci_hdrc_imx_resume(struct device *dev) |
| 233 | { |
| 234 | return imx_controller_resume(dev); |
| 235 | } |
| 236 | #endif /* CONFIG_PM_SLEEP */ |
| 237 | |
| 238 | static const struct dev_pm_ops ci_hdrc_imx_pm_ops = { |
| 239 | SET_SYSTEM_SLEEP_PM_OPS(ci_hdrc_imx_suspend, ci_hdrc_imx_resume) |
| 240 | }; |
Alexander Shishkin | 8e22978 | 2013-06-24 14:46:36 +0300 | [diff] [blame] | 241 | static struct platform_driver ci_hdrc_imx_driver = { |
| 242 | .probe = ci_hdrc_imx_probe, |
| 243 | .remove = ci_hdrc_imx_remove, |
Richard Zhao | 1530280 | 2012-07-07 22:56:48 +0800 | [diff] [blame] | 244 | .driver = { |
| 245 | .name = "imx_usb", |
Alexander Shishkin | 8e22978 | 2013-06-24 14:46:36 +0300 | [diff] [blame] | 246 | .of_match_table = ci_hdrc_imx_dt_ids, |
Peter Chen | 2558c1f | 2014-11-26 13:44:30 +0800 | [diff] [blame] | 247 | .pm = &ci_hdrc_imx_pm_ops, |
Richard Zhao | 1530280 | 2012-07-07 22:56:48 +0800 | [diff] [blame] | 248 | }, |
| 249 | }; |
| 250 | |
Alexander Shishkin | 8e22978 | 2013-06-24 14:46:36 +0300 | [diff] [blame] | 251 | module_platform_driver(ci_hdrc_imx_driver); |
Richard Zhao | 1530280 | 2012-07-07 22:56:48 +0800 | [diff] [blame] | 252 | |
| 253 | MODULE_ALIAS("platform:imx-usb"); |
| 254 | MODULE_LICENSE("GPL v2"); |
Alexander Shishkin | 8e22978 | 2013-06-24 14:46:36 +0300 | [diff] [blame] | 255 | MODULE_DESCRIPTION("CI HDRC i.MX USB binding"); |
Richard Zhao | 1530280 | 2012-07-07 22:56:48 +0800 | [diff] [blame] | 256 | MODULE_AUTHOR("Marek Vasut <marex@denx.de>"); |
| 257 | MODULE_AUTHOR("Richard Zhao <richard.zhao@freescale.com>"); |