Richard Zhao | d142d6b | 2012-09-12 14:58:05 +0300 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2012 Freescale Semiconductor, Inc. |
| 3 | * |
| 4 | * The code contained herein is licensed under the GNU General Public |
| 5 | * License. You may obtain a copy of the GNU General Public License |
| 6 | * Version 2 or later at the following locations: |
| 7 | * |
| 8 | * http://www.opensource.org/licenses/gpl-license.html |
| 9 | * http://www.gnu.org/copyleft/gpl.html |
| 10 | */ |
| 11 | |
| 12 | #include <linux/module.h> |
| 13 | #include <linux/of_platform.h> |
| 14 | #include <linux/clk.h> |
| 15 | #include <linux/err.h> |
| 16 | #include <linux/io.h> |
Michael Grzeschik | a068533 | 2013-03-30 12:54:01 +0200 | [diff] [blame] | 17 | #include <linux/delay.h> |
Richard Zhao | d142d6b | 2012-09-12 14:58:05 +0300 | [diff] [blame] | 18 | |
Alexander Shishkin | 8e22978 | 2013-06-24 14:46:36 +0300 | [diff] [blame] | 19 | #include "ci_hdrc_imx.h" |
Richard Zhao | d142d6b | 2012-09-12 14:58:05 +0300 | [diff] [blame] | 20 | |
Michael Grzeschik | a068533 | 2013-03-30 12:54:01 +0200 | [diff] [blame] | 21 | #define MX25_USB_PHY_CTRL_OFFSET 0x08 |
| 22 | #define MX25_BM_EXTERNAL_VBUS_DIVIDER BIT(23) |
| 23 | |
Michael Grzeschik | f0c910b | 2013-03-30 12:54:00 +0200 | [diff] [blame] | 24 | #define MX53_USB_OTG_PHY_CTRL_0_OFFSET 0x08 |
| 25 | #define MX53_USB_UH2_CTRL_OFFSET 0x14 |
| 26 | #define MX53_USB_UH3_CTRL_OFFSET 0x18 |
| 27 | #define MX53_BM_OVER_CUR_DIS_H1 BIT(5) |
| 28 | #define MX53_BM_OVER_CUR_DIS_OTG BIT(8) |
| 29 | #define MX53_BM_OVER_CUR_DIS_UHx BIT(30) |
| 30 | |
Marc Kleine-Budde | e609108 | 2013-03-30 12:53:59 +0200 | [diff] [blame] | 31 | #define MX6_BM_OVER_CUR_DIS BIT(7) |
Richard Zhao | d142d6b | 2012-09-12 14:58:05 +0300 | [diff] [blame] | 32 | |
Sascha Hauer | 05986ba | 2013-08-14 12:44:16 +0300 | [diff] [blame] | 33 | struct usbmisc_ops { |
| 34 | /* It's called once when probe a usb device */ |
| 35 | int (*init)(struct imx_usbmisc_data *data); |
| 36 | /* It's called once after adding a usb device */ |
| 37 | int (*post)(struct imx_usbmisc_data *data); |
| 38 | }; |
| 39 | |
Michael Grzeschik | a7bc2fd | 2013-03-30 12:53:56 +0200 | [diff] [blame] | 40 | struct imx_usbmisc { |
Richard Zhao | d142d6b | 2012-09-12 14:58:05 +0300 | [diff] [blame] | 41 | void __iomem *base; |
| 42 | spinlock_t lock; |
| 43 | struct clk *clk; |
Marc Kleine-Budde | e609108 | 2013-03-30 12:53:59 +0200 | [diff] [blame] | 44 | const struct usbmisc_ops *ops; |
Richard Zhao | d142d6b | 2012-09-12 14:58:05 +0300 | [diff] [blame] | 45 | }; |
| 46 | |
Michael Grzeschik | a7bc2fd | 2013-03-30 12:53:56 +0200 | [diff] [blame] | 47 | static struct imx_usbmisc *usbmisc; |
Richard Zhao | d142d6b | 2012-09-12 14:58:05 +0300 | [diff] [blame] | 48 | |
Sascha Hauer | 05986ba | 2013-08-14 12:44:16 +0300 | [diff] [blame] | 49 | static int usbmisc_imx25_post(struct imx_usbmisc_data *data) |
Richard Zhao | d142d6b | 2012-09-12 14:58:05 +0300 | [diff] [blame] | 50 | { |
Michael Grzeschik | a068533 | 2013-03-30 12:54:01 +0200 | [diff] [blame] | 51 | void __iomem *reg; |
| 52 | unsigned long flags; |
| 53 | u32 val; |
| 54 | |
Sascha Hauer | 05986ba | 2013-08-14 12:44:16 +0300 | [diff] [blame] | 55 | if (data->index > 2) |
| 56 | return -EINVAL; |
Michael Grzeschik | a068533 | 2013-03-30 12:54:01 +0200 | [diff] [blame] | 57 | |
| 58 | reg = usbmisc->base + MX25_USB_PHY_CTRL_OFFSET; |
| 59 | |
Sascha Hauer | 05986ba | 2013-08-14 12:44:16 +0300 | [diff] [blame] | 60 | if (data->evdo) { |
Michael Grzeschik | a068533 | 2013-03-30 12:54:01 +0200 | [diff] [blame] | 61 | spin_lock_irqsave(&usbmisc->lock, flags); |
| 62 | val = readl(reg); |
| 63 | writel(val | MX25_BM_EXTERNAL_VBUS_DIVIDER, reg); |
| 64 | spin_unlock_irqrestore(&usbmisc->lock, flags); |
| 65 | usleep_range(5000, 10000); /* needed to stabilize voltage */ |
| 66 | } |
| 67 | |
| 68 | return 0; |
| 69 | } |
| 70 | |
Sascha Hauer | 05986ba | 2013-08-14 12:44:16 +0300 | [diff] [blame] | 71 | static int usbmisc_imx53_init(struct imx_usbmisc_data *data) |
Michael Grzeschik | f0c910b | 2013-03-30 12:54:00 +0200 | [diff] [blame] | 72 | { |
Michael Grzeschik | f0c910b | 2013-03-30 12:54:00 +0200 | [diff] [blame] | 73 | void __iomem *reg = NULL; |
| 74 | unsigned long flags; |
| 75 | u32 val = 0; |
| 76 | |
Sascha Hauer | 05986ba | 2013-08-14 12:44:16 +0300 | [diff] [blame] | 77 | if (data->index > 3) |
| 78 | return -EINVAL; |
Michael Grzeschik | f0c910b | 2013-03-30 12:54:00 +0200 | [diff] [blame] | 79 | |
Sascha Hauer | 05986ba | 2013-08-14 12:44:16 +0300 | [diff] [blame] | 80 | if (data->disable_oc) { |
Michael Grzeschik | f0c910b | 2013-03-30 12:54:00 +0200 | [diff] [blame] | 81 | spin_lock_irqsave(&usbmisc->lock, flags); |
Sascha Hauer | 05986ba | 2013-08-14 12:44:16 +0300 | [diff] [blame] | 82 | switch (data->index) { |
Michael Grzeschik | f0c910b | 2013-03-30 12:54:00 +0200 | [diff] [blame] | 83 | case 0: |
| 84 | reg = usbmisc->base + MX53_USB_OTG_PHY_CTRL_0_OFFSET; |
| 85 | val = readl(reg) | MX53_BM_OVER_CUR_DIS_OTG; |
| 86 | break; |
| 87 | case 1: |
| 88 | reg = usbmisc->base + MX53_USB_OTG_PHY_CTRL_0_OFFSET; |
| 89 | val = readl(reg) | MX53_BM_OVER_CUR_DIS_H1; |
| 90 | break; |
| 91 | case 2: |
| 92 | reg = usbmisc->base + MX53_USB_UH2_CTRL_OFFSET; |
| 93 | val = readl(reg) | MX53_BM_OVER_CUR_DIS_UHx; |
| 94 | break; |
| 95 | case 3: |
| 96 | reg = usbmisc->base + MX53_USB_UH3_CTRL_OFFSET; |
| 97 | val = readl(reg) | MX53_BM_OVER_CUR_DIS_UHx; |
| 98 | break; |
| 99 | } |
| 100 | if (reg && val) |
| 101 | writel(val, reg); |
| 102 | spin_unlock_irqrestore(&usbmisc->lock, flags); |
| 103 | } |
| 104 | |
| 105 | return 0; |
| 106 | } |
| 107 | |
Sascha Hauer | 05986ba | 2013-08-14 12:44:16 +0300 | [diff] [blame] | 108 | static int usbmisc_imx6q_init(struct imx_usbmisc_data *data) |
Richard Zhao | d142d6b | 2012-09-12 14:58:05 +0300 | [diff] [blame] | 109 | { |
Richard Zhao | d142d6b | 2012-09-12 14:58:05 +0300 | [diff] [blame] | 110 | unsigned long flags; |
| 111 | u32 reg; |
| 112 | |
Sascha Hauer | 05986ba | 2013-08-14 12:44:16 +0300 | [diff] [blame] | 113 | if (data->index > 3) |
| 114 | return -EINVAL; |
Richard Zhao | d142d6b | 2012-09-12 14:58:05 +0300 | [diff] [blame] | 115 | |
Sascha Hauer | 05986ba | 2013-08-14 12:44:16 +0300 | [diff] [blame] | 116 | if (data->disable_oc) { |
Richard Zhao | d142d6b | 2012-09-12 14:58:05 +0300 | [diff] [blame] | 117 | spin_lock_irqsave(&usbmisc->lock, flags); |
Sascha Hauer | 05986ba | 2013-08-14 12:44:16 +0300 | [diff] [blame] | 118 | reg = readl(usbmisc->base + data->index * 4); |
Marc Kleine-Budde | e609108 | 2013-03-30 12:53:59 +0200 | [diff] [blame] | 119 | writel(reg | MX6_BM_OVER_CUR_DIS, |
Sascha Hauer | 05986ba | 2013-08-14 12:44:16 +0300 | [diff] [blame] | 120 | usbmisc->base + data->index * 4); |
Richard Zhao | d142d6b | 2012-09-12 14:58:05 +0300 | [diff] [blame] | 121 | spin_unlock_irqrestore(&usbmisc->lock, flags); |
| 122 | } |
| 123 | |
| 124 | return 0; |
| 125 | } |
| 126 | |
Michael Grzeschik | a068533 | 2013-03-30 12:54:01 +0200 | [diff] [blame] | 127 | static const struct usbmisc_ops imx25_usbmisc_ops = { |
| 128 | .post = usbmisc_imx25_post, |
| 129 | }; |
| 130 | |
Michael Grzeschik | f0c910b | 2013-03-30 12:54:00 +0200 | [diff] [blame] | 131 | static const struct usbmisc_ops imx53_usbmisc_ops = { |
| 132 | .init = usbmisc_imx53_init, |
| 133 | }; |
| 134 | |
Richard Zhao | d142d6b | 2012-09-12 14:58:05 +0300 | [diff] [blame] | 135 | static const struct usbmisc_ops imx6q_usbmisc_ops = { |
| 136 | .init = usbmisc_imx6q_init, |
| 137 | }; |
| 138 | |
Sascha Hauer | 05986ba | 2013-08-14 12:44:16 +0300 | [diff] [blame] | 139 | int imx_usbmisc_init(struct imx_usbmisc_data *data) |
| 140 | { |
| 141 | if (!usbmisc) |
| 142 | return -EPROBE_DEFER; |
| 143 | if (!usbmisc->ops->init) |
| 144 | return 0; |
| 145 | return usbmisc->ops->init(data); |
| 146 | } |
| 147 | EXPORT_SYMBOL_GPL(imx_usbmisc_init); |
| 148 | |
| 149 | int imx_usbmisc_init_post(struct imx_usbmisc_data *data) |
| 150 | { |
| 151 | if (!usbmisc) |
| 152 | return -EPROBE_DEFER; |
| 153 | if (!usbmisc->ops->post) |
| 154 | return 0; |
| 155 | return usbmisc->ops->post(data); |
| 156 | } |
| 157 | EXPORT_SYMBOL_GPL(imx_usbmisc_init_post); |
| 158 | |
Michael Grzeschik | a7bc2fd | 2013-03-30 12:53:56 +0200 | [diff] [blame] | 159 | static const struct of_device_id usbmisc_imx_dt_ids[] = { |
Marc Kleine-Budde | e609108 | 2013-03-30 12:53:59 +0200 | [diff] [blame] | 160 | { |
Michael Grzeschik | a068533 | 2013-03-30 12:54:01 +0200 | [diff] [blame] | 161 | .compatible = "fsl,imx25-usbmisc", |
| 162 | .data = &imx25_usbmisc_ops, |
| 163 | }, |
| 164 | { |
Michael Grzeschik | f0c910b | 2013-03-30 12:54:00 +0200 | [diff] [blame] | 165 | .compatible = "fsl,imx53-usbmisc", |
| 166 | .data = &imx53_usbmisc_ops, |
| 167 | }, |
| 168 | { |
Marc Kleine-Budde | e609108 | 2013-03-30 12:53:59 +0200 | [diff] [blame] | 169 | .compatible = "fsl,imx6q-usbmisc", |
| 170 | .data = &imx6q_usbmisc_ops, |
| 171 | }, |
Richard Zhao | d142d6b | 2012-09-12 14:58:05 +0300 | [diff] [blame] | 172 | { /* sentinel */ } |
| 173 | }; |
Arnaud Patard (Rtp) | 269b83d | 2013-06-20 23:33:25 +0200 | [diff] [blame] | 174 | MODULE_DEVICE_TABLE(of, usbmisc_imx_dt_ids); |
Richard Zhao | d142d6b | 2012-09-12 14:58:05 +0300 | [diff] [blame] | 175 | |
Michael Grzeschik | a7bc2fd | 2013-03-30 12:53:56 +0200 | [diff] [blame] | 176 | static int usbmisc_imx_probe(struct platform_device *pdev) |
Richard Zhao | d142d6b | 2012-09-12 14:58:05 +0300 | [diff] [blame] | 177 | { |
| 178 | struct resource *res; |
Michael Grzeschik | a7bc2fd | 2013-03-30 12:53:56 +0200 | [diff] [blame] | 179 | struct imx_usbmisc *data; |
Richard Zhao | d142d6b | 2012-09-12 14:58:05 +0300 | [diff] [blame] | 180 | int ret; |
Marc Kleine-Budde | e609108 | 2013-03-30 12:53:59 +0200 | [diff] [blame] | 181 | struct of_device_id *tmp_dev; |
Richard Zhao | d142d6b | 2012-09-12 14:58:05 +0300 | [diff] [blame] | 182 | |
| 183 | if (usbmisc) |
| 184 | return -EBUSY; |
| 185 | |
| 186 | data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL); |
| 187 | if (!data) |
| 188 | return -ENOMEM; |
| 189 | |
| 190 | spin_lock_init(&data->lock); |
| 191 | |
| 192 | res = platform_get_resource(pdev, IORESOURCE_MEM, 0); |
Thierry Reding | 148e113 | 2013-01-21 11:09:22 +0100 | [diff] [blame] | 193 | data->base = devm_ioremap_resource(&pdev->dev, res); |
| 194 | if (IS_ERR(data->base)) |
| 195 | return PTR_ERR(data->base); |
Richard Zhao | d142d6b | 2012-09-12 14:58:05 +0300 | [diff] [blame] | 196 | |
| 197 | data->clk = devm_clk_get(&pdev->dev, NULL); |
| 198 | if (IS_ERR(data->clk)) { |
| 199 | dev_err(&pdev->dev, |
| 200 | "failed to get clock, err=%ld\n", PTR_ERR(data->clk)); |
| 201 | return PTR_ERR(data->clk); |
| 202 | } |
| 203 | |
| 204 | ret = clk_prepare_enable(data->clk); |
| 205 | if (ret) { |
| 206 | dev_err(&pdev->dev, |
| 207 | "clk_prepare_enable failed, err=%d\n", ret); |
| 208 | return ret; |
| 209 | } |
| 210 | |
Marc Kleine-Budde | e609108 | 2013-03-30 12:53:59 +0200 | [diff] [blame] | 211 | tmp_dev = (struct of_device_id *) |
| 212 | of_match_device(usbmisc_imx_dt_ids, &pdev->dev); |
| 213 | data->ops = (const struct usbmisc_ops *)tmp_dev->data; |
Marc Kleine-Budde | 00b9a1f9 | 2013-03-30 12:53:58 +0200 | [diff] [blame] | 214 | usbmisc = data; |
Richard Zhao | d142d6b | 2012-09-12 14:58:05 +0300 | [diff] [blame] | 215 | |
Richard Zhao | d142d6b | 2012-09-12 14:58:05 +0300 | [diff] [blame] | 216 | return 0; |
| 217 | } |
| 218 | |
Michael Grzeschik | a7bc2fd | 2013-03-30 12:53:56 +0200 | [diff] [blame] | 219 | static int usbmisc_imx_remove(struct platform_device *pdev) |
Richard Zhao | d142d6b | 2012-09-12 14:58:05 +0300 | [diff] [blame] | 220 | { |
Richard Zhao | d142d6b | 2012-09-12 14:58:05 +0300 | [diff] [blame] | 221 | clk_disable_unprepare(usbmisc->clk); |
Marc Kleine-Budde | d48a24d | 2013-03-30 12:53:57 +0200 | [diff] [blame] | 222 | usbmisc = NULL; |
Richard Zhao | d142d6b | 2012-09-12 14:58:05 +0300 | [diff] [blame] | 223 | return 0; |
| 224 | } |
| 225 | |
Michael Grzeschik | a7bc2fd | 2013-03-30 12:53:56 +0200 | [diff] [blame] | 226 | static struct platform_driver usbmisc_imx_driver = { |
| 227 | .probe = usbmisc_imx_probe, |
| 228 | .remove = usbmisc_imx_remove, |
Richard Zhao | d142d6b | 2012-09-12 14:58:05 +0300 | [diff] [blame] | 229 | .driver = { |
Michael Grzeschik | a7bc2fd | 2013-03-30 12:53:56 +0200 | [diff] [blame] | 230 | .name = "usbmisc_imx", |
Richard Zhao | d142d6b | 2012-09-12 14:58:05 +0300 | [diff] [blame] | 231 | .owner = THIS_MODULE, |
Michael Grzeschik | a7bc2fd | 2013-03-30 12:53:56 +0200 | [diff] [blame] | 232 | .of_match_table = usbmisc_imx_dt_ids, |
Richard Zhao | d142d6b | 2012-09-12 14:58:05 +0300 | [diff] [blame] | 233 | }, |
| 234 | }; |
| 235 | |
Philipp Zabel | 0404ae0 | 2013-06-13 17:59:59 +0300 | [diff] [blame] | 236 | module_platform_driver(usbmisc_imx_driver); |
Richard Zhao | d142d6b | 2012-09-12 14:58:05 +0300 | [diff] [blame] | 237 | |
Michael Grzeschik | a7bc2fd | 2013-03-30 12:53:56 +0200 | [diff] [blame] | 238 | MODULE_ALIAS("platform:usbmisc-imx"); |
Richard Zhao | d142d6b | 2012-09-12 14:58:05 +0300 | [diff] [blame] | 239 | MODULE_LICENSE("GPL v2"); |
Michael Grzeschik | a7bc2fd | 2013-03-30 12:53:56 +0200 | [diff] [blame] | 240 | MODULE_DESCRIPTION("driver for imx usb non-core registers"); |
Richard Zhao | d142d6b | 2012-09-12 14:58:05 +0300 | [diff] [blame] | 241 | MODULE_AUTHOR("Richard Zhao <richard.zhao@freescale.com>"); |