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>
17 #include <linux/delay.h>
18 
19 #include "ci_hdrc_imx.h"
20 
21 #define MX25_USB_PHY_CTRL_OFFSET	0x08
22 #define MX25_BM_EXTERNAL_VBUS_DIVIDER	BIT(23)
23 
24 #define MX25_EHCI_INTERFACE_SINGLE_UNI	(2 << 0)
25 #define MX25_EHCI_INTERFACE_DIFF_UNI	(0 << 0)
26 #define MX25_EHCI_INTERFACE_MASK	(0xf)
27 
28 #define MX25_OTG_SIC_SHIFT		29
29 #define MX25_OTG_SIC_MASK		(0x3 << MX25_OTG_SIC_SHIFT)
30 #define MX25_OTG_PM_BIT			BIT(24)
31 #define MX25_OTG_PP_BIT			BIT(11)
32 #define MX25_OTG_OCPOL_BIT		BIT(3)
33 
34 #define MX25_H1_SIC_SHIFT		21
35 #define MX25_H1_SIC_MASK		(0x3 << MX25_H1_SIC_SHIFT)
36 #define MX25_H1_PP_BIT			BIT(18)
37 #define MX25_H1_PM_BIT			BIT(16)
38 #define MX25_H1_IPPUE_UP_BIT		BIT(7)
39 #define MX25_H1_IPPUE_DOWN_BIT		BIT(6)
40 #define MX25_H1_TLL_BIT			BIT(5)
41 #define MX25_H1_USBTE_BIT		BIT(4)
42 #define MX25_H1_OCPOL_BIT		BIT(2)
43 
44 #define MX27_H1_PM_BIT			BIT(8)
45 #define MX27_H2_PM_BIT			BIT(16)
46 #define MX27_OTG_PM_BIT			BIT(24)
47 
48 #define MX53_USB_OTG_PHY_CTRL_0_OFFSET	0x08
49 #define MX53_USB_OTG_PHY_CTRL_1_OFFSET	0x0c
50 #define MX53_USB_UH2_CTRL_OFFSET	0x14
51 #define MX53_USB_UH3_CTRL_OFFSET	0x18
52 #define MX53_BM_OVER_CUR_DIS_H1		BIT(5)
53 #define MX53_BM_OVER_CUR_DIS_OTG	BIT(8)
54 #define MX53_BM_OVER_CUR_DIS_UHx	BIT(30)
55 #define MX53_USB_PHYCTRL1_PLLDIV_MASK	0x3
56 #define MX53_USB_PLL_DIV_24_MHZ		0x01
57 
58 #define MX6_BM_OVER_CUR_DIS		BIT(7)
59 
60 #define VF610_OVER_CUR_DIS		BIT(7)
61 
62 struct usbmisc_ops {
63 	/* It's called once when probe a usb device */
64 	int (*init)(struct imx_usbmisc_data *data);
65 	/* It's called once after adding a usb device */
66 	int (*post)(struct imx_usbmisc_data *data);
67 };
68 
69 struct imx_usbmisc {
70 	void __iomem *base;
71 	spinlock_t lock;
72 	struct clk *clk;
73 	const struct usbmisc_ops *ops;
74 };
75 
76 static int usbmisc_imx25_init(struct imx_usbmisc_data *data)
77 {
78 	struct imx_usbmisc *usbmisc = dev_get_drvdata(data->dev);
79 	unsigned long flags;
80 	u32 val = 0;
81 
82 	if (data->index > 1)
83 		return -EINVAL;
84 
85 	spin_lock_irqsave(&usbmisc->lock, flags);
86 	switch (data->index) {
87 	case 0:
88 		val = readl(usbmisc->base);
89 		val &= ~(MX25_OTG_SIC_MASK | MX25_OTG_PP_BIT);
90 		val |= (MX25_EHCI_INTERFACE_DIFF_UNI & MX25_EHCI_INTERFACE_MASK) << MX25_OTG_SIC_SHIFT;
91 		val |= (MX25_OTG_PM_BIT | MX25_OTG_OCPOL_BIT);
92 		writel(val, usbmisc->base);
93 		break;
94 	case 1:
95 		val = readl(usbmisc->base);
96 		val &= ~(MX25_H1_SIC_MASK | MX25_H1_PP_BIT |  MX25_H1_IPPUE_UP_BIT);
97 		val |= (MX25_EHCI_INTERFACE_SINGLE_UNI & MX25_EHCI_INTERFACE_MASK) << MX25_H1_SIC_SHIFT;
98 		val |= (MX25_H1_PM_BIT | MX25_H1_OCPOL_BIT | MX25_H1_TLL_BIT |
99 			MX25_H1_USBTE_BIT | MX25_H1_IPPUE_DOWN_BIT);
100 
101 		writel(val, usbmisc->base);
102 
103 		break;
104 	}
105 	spin_unlock_irqrestore(&usbmisc->lock, flags);
106 
107 	return 0;
108 }
109 
110 static int usbmisc_imx25_post(struct imx_usbmisc_data *data)
111 {
112 	struct imx_usbmisc *usbmisc = dev_get_drvdata(data->dev);
113 	void __iomem *reg;
114 	unsigned long flags;
115 	u32 val;
116 
117 	if (data->index > 2)
118 		return -EINVAL;
119 
120 	if (data->evdo) {
121 		spin_lock_irqsave(&usbmisc->lock, flags);
122 		reg = usbmisc->base + MX25_USB_PHY_CTRL_OFFSET;
123 		val = readl(reg);
124 		writel(val | MX25_BM_EXTERNAL_VBUS_DIVIDER, reg);
125 		spin_unlock_irqrestore(&usbmisc->lock, flags);
126 		usleep_range(5000, 10000); /* needed to stabilize voltage */
127 	}
128 
129 	return 0;
130 }
131 
132 static int usbmisc_imx27_init(struct imx_usbmisc_data *data)
133 {
134 	struct imx_usbmisc *usbmisc = dev_get_drvdata(data->dev);
135 	unsigned long flags;
136 	u32 val;
137 
138 	switch (data->index) {
139 	case 0:
140 		val = MX27_OTG_PM_BIT;
141 		break;
142 	case 1:
143 		val = MX27_H1_PM_BIT;
144 		break;
145 	case 2:
146 		val = MX27_H2_PM_BIT;
147 		break;
148 	default:
149 		return -EINVAL;
150 	};
151 
152 	spin_lock_irqsave(&usbmisc->lock, flags);
153 	if (data->disable_oc)
154 		val = readl(usbmisc->base) | val;
155 	else
156 		val = readl(usbmisc->base) & ~val;
157 	writel(val, usbmisc->base);
158 	spin_unlock_irqrestore(&usbmisc->lock, flags);
159 
160 	return 0;
161 }
162 
163 static int usbmisc_imx53_init(struct imx_usbmisc_data *data)
164 {
165 	struct imx_usbmisc *usbmisc = dev_get_drvdata(data->dev);
166 	void __iomem *reg = NULL;
167 	unsigned long flags;
168 	u32 val = 0;
169 
170 	if (data->index > 3)
171 		return -EINVAL;
172 
173 	/* Select a 24 MHz reference clock for the PHY  */
174 	val = readl(usbmisc->base + MX53_USB_OTG_PHY_CTRL_1_OFFSET);
175 	val &= ~MX53_USB_PHYCTRL1_PLLDIV_MASK;
176 	val |= MX53_USB_PLL_DIV_24_MHZ;
177 	writel(val, usbmisc->base + MX53_USB_OTG_PHY_CTRL_1_OFFSET);
178 
179 	if (data->disable_oc) {
180 		spin_lock_irqsave(&usbmisc->lock, flags);
181 		switch (data->index) {
182 		case 0:
183 			reg = usbmisc->base + MX53_USB_OTG_PHY_CTRL_0_OFFSET;
184 			val = readl(reg) | MX53_BM_OVER_CUR_DIS_OTG;
185 			break;
186 		case 1:
187 			reg = usbmisc->base + MX53_USB_OTG_PHY_CTRL_0_OFFSET;
188 			val = readl(reg) | MX53_BM_OVER_CUR_DIS_H1;
189 			break;
190 		case 2:
191 			reg = usbmisc->base + MX53_USB_UH2_CTRL_OFFSET;
192 			val = readl(reg) | MX53_BM_OVER_CUR_DIS_UHx;
193 			break;
194 		case 3:
195 			reg = usbmisc->base + MX53_USB_UH3_CTRL_OFFSET;
196 			val = readl(reg) | MX53_BM_OVER_CUR_DIS_UHx;
197 			break;
198 		}
199 		if (reg && val)
200 			writel(val, reg);
201 		spin_unlock_irqrestore(&usbmisc->lock, flags);
202 	}
203 
204 	return 0;
205 }
206 
207 static int usbmisc_imx6q_init(struct imx_usbmisc_data *data)
208 {
209 	struct imx_usbmisc *usbmisc = dev_get_drvdata(data->dev);
210 	unsigned long flags;
211 	u32 reg;
212 
213 	if (data->index > 3)
214 		return -EINVAL;
215 
216 	if (data->disable_oc) {
217 		spin_lock_irqsave(&usbmisc->lock, flags);
218 		reg = readl(usbmisc->base + data->index * 4);
219 		writel(reg | MX6_BM_OVER_CUR_DIS,
220 			usbmisc->base + data->index * 4);
221 		spin_unlock_irqrestore(&usbmisc->lock, flags);
222 	}
223 
224 	return 0;
225 }
226 
227 static int usbmisc_vf610_init(struct imx_usbmisc_data *data)
228 {
229 	struct imx_usbmisc *usbmisc = dev_get_drvdata(data->dev);
230 	u32 reg;
231 
232 	/*
233 	 * Vybrid only has one misc register set, but in two different
234 	 * areas. These is reflected in two instances of this driver.
235 	 */
236 	if (data->index >= 1)
237 		return -EINVAL;
238 
239 	if (data->disable_oc) {
240 		reg = readl(usbmisc->base);
241 		writel(reg | VF610_OVER_CUR_DIS, usbmisc->base);
242 	}
243 
244 	return 0;
245 }
246 
247 static const struct usbmisc_ops imx25_usbmisc_ops = {
248 	.init = usbmisc_imx25_init,
249 	.post = usbmisc_imx25_post,
250 };
251 
252 static const struct usbmisc_ops imx27_usbmisc_ops = {
253 	.init = usbmisc_imx27_init,
254 };
255 
256 static const struct usbmisc_ops imx53_usbmisc_ops = {
257 	.init = usbmisc_imx53_init,
258 };
259 
260 static const struct usbmisc_ops imx6q_usbmisc_ops = {
261 	.init = usbmisc_imx6q_init,
262 };
263 
264 static const struct usbmisc_ops vf610_usbmisc_ops = {
265 	.init = usbmisc_vf610_init,
266 };
267 
268 int imx_usbmisc_init(struct imx_usbmisc_data *data)
269 {
270 	struct imx_usbmisc *usbmisc = dev_get_drvdata(data->dev);
271 
272 	if (!usbmisc->ops->init)
273 		return 0;
274 	return usbmisc->ops->init(data);
275 }
276 EXPORT_SYMBOL_GPL(imx_usbmisc_init);
277 
278 int imx_usbmisc_init_post(struct imx_usbmisc_data *data)
279 {
280 	struct imx_usbmisc *usbmisc = dev_get_drvdata(data->dev);
281 
282 	if (!usbmisc->ops->post)
283 		return 0;
284 	return usbmisc->ops->post(data);
285 }
286 EXPORT_SYMBOL_GPL(imx_usbmisc_init_post);
287 
288 static const struct of_device_id usbmisc_imx_dt_ids[] = {
289 	{
290 		.compatible = "fsl,imx25-usbmisc",
291 		.data = &imx25_usbmisc_ops,
292 	},
293 	{
294 		.compatible = "fsl,imx35-usbmisc",
295 		.data = &imx25_usbmisc_ops,
296 	},
297 	{
298 		.compatible = "fsl,imx27-usbmisc",
299 		.data = &imx27_usbmisc_ops,
300 	},
301 	{
302 		.compatible = "fsl,imx51-usbmisc",
303 		.data = &imx53_usbmisc_ops,
304 	},
305 	{
306 		.compatible = "fsl,imx53-usbmisc",
307 		.data = &imx53_usbmisc_ops,
308 	},
309 	{
310 		.compatible = "fsl,imx6q-usbmisc",
311 		.data = &imx6q_usbmisc_ops,
312 	},
313 	{
314 		.compatible = "fsl,vf610-usbmisc",
315 		.data = &vf610_usbmisc_ops,
316 	},
317 	{ /* sentinel */ }
318 };
319 MODULE_DEVICE_TABLE(of, usbmisc_imx_dt_ids);
320 
321 static int usbmisc_imx_probe(struct platform_device *pdev)
322 {
323 	struct resource	*res;
324 	struct imx_usbmisc *data;
325 	int ret;
326 	struct of_device_id *tmp_dev;
327 
328 	data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
329 	if (!data)
330 		return -ENOMEM;
331 
332 	spin_lock_init(&data->lock);
333 
334 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
335 	data->base = devm_ioremap_resource(&pdev->dev, res);
336 	if (IS_ERR(data->base))
337 		return PTR_ERR(data->base);
338 
339 	data->clk = devm_clk_get(&pdev->dev, NULL);
340 	if (IS_ERR(data->clk)) {
341 		dev_err(&pdev->dev,
342 			"failed to get clock, err=%ld\n", PTR_ERR(data->clk));
343 		return PTR_ERR(data->clk);
344 	}
345 
346 	ret = clk_prepare_enable(data->clk);
347 	if (ret) {
348 		dev_err(&pdev->dev,
349 			"clk_prepare_enable failed, err=%d\n", ret);
350 		return ret;
351 	}
352 
353 	tmp_dev = (struct of_device_id *)
354 		of_match_device(usbmisc_imx_dt_ids, &pdev->dev);
355 	data->ops = (const struct usbmisc_ops *)tmp_dev->data;
356 	platform_set_drvdata(pdev, data);
357 
358 	return 0;
359 }
360 
361 static int usbmisc_imx_remove(struct platform_device *pdev)
362 {
363 	struct imx_usbmisc *usbmisc = dev_get_drvdata(&pdev->dev);
364 	clk_disable_unprepare(usbmisc->clk);
365 	return 0;
366 }
367 
368 static struct platform_driver usbmisc_imx_driver = {
369 	.probe = usbmisc_imx_probe,
370 	.remove = usbmisc_imx_remove,
371 	.driver = {
372 		.name = "usbmisc_imx",
373 		.of_match_table = usbmisc_imx_dt_ids,
374 	 },
375 };
376 
377 module_platform_driver(usbmisc_imx_driver);
378 
379 MODULE_ALIAS("platform:usbmisc-imx");
380 MODULE_LICENSE("GPL v2");
381 MODULE_DESCRIPTION("driver for imx usb non-core registers");
382 MODULE_AUTHOR("Richard Zhao <richard.zhao@freescale.com>");
383