[deliverable/linux.git] / drivers / usb / chipidea / usbmisc_imx.c

/*
 * Copyright 2012 Freescale Semiconductor, Inc.
 *
 * The code contained herein is licensed under the GNU General Public
 * License. You may obtain a copy of the GNU General Public License
 * Version 2 or later at the following locations:
 *
 * http://www.opensource.org/licenses/gpl-license.html
 * http://www.gnu.org/copyleft/gpl.html
 */

#include <linux/module.h>
#include <linux/of_platform.h>
#include <linux/clk.h>
#include <linux/err.h>
#include <linux/io.h>
#include <linux/delay.h>

#include "ci_hdrc_imx.h"

#define MX25_USB_PHY_CTRL_OFFSET	0x08
#define MX25_BM_EXTERNAL_VBUS_DIVIDER	BIT(23)

#define MX27_H1_PM_BIT			BIT(8)
#define MX27_H2_PM_BIT			BIT(16)
#define MX27_OTG_PM_BIT			BIT(24)

#define MX53_USB_OTG_PHY_CTRL_0_OFFSET	0x08
#define MX53_USB_UH2_CTRL_OFFSET	0x14
#define MX53_USB_UH3_CTRL_OFFSET	0x18
#define MX53_BM_OVER_CUR_DIS_H1		BIT(5)
#define MX53_BM_OVER_CUR_DIS_OTG	BIT(8)
#define MX53_BM_OVER_CUR_DIS_UHx	BIT(30)

#define MX6_BM_OVER_CUR_DIS		BIT(7)

struct usbmisc_ops {
	/* It's called once when probe a usb device */
	int (*init)(struct imx_usbmisc_data *data);
	/* It's called once after adding a usb device */
	int (*post)(struct imx_usbmisc_data *data);
};

struct imx_usbmisc {
	void __iomem *base;
	spinlock_t lock;
	struct clk *clk;
	const struct usbmisc_ops *ops;
};

static struct imx_usbmisc *usbmisc;

static int usbmisc_imx25_post(struct imx_usbmisc_data *data)
{
	void __iomem *reg;
	unsigned long flags;
	u32 val;

	if (data->index > 2)
		return -EINVAL;

	reg = usbmisc->base + MX25_USB_PHY_CTRL_OFFSET;

	if (data->evdo) {
		spin_lock_irqsave(&usbmisc->lock, flags);
		val = readl(reg);
		writel(val | MX25_BM_EXTERNAL_VBUS_DIVIDER, reg);
		spin_unlock_irqrestore(&usbmisc->lock, flags);
		usleep_range(5000, 10000); /* needed to stabilize voltage */
	}

	return 0;
}

static int usbmisc_imx27_init(struct imx_usbmisc_data *data)
{
	unsigned long flags;
	u32 val;

	switch (data->index) {
	case 0:
		val = MX27_OTG_PM_BIT;
		break;
	case 1:
		val = MX27_H1_PM_BIT;
		break;
	case 2:
		val = MX27_H2_PM_BIT;
		break;
	default:
		return -EINVAL;
	};

	spin_lock_irqsave(&usbmisc->lock, flags);
	if (data->disable_oc)
		val = readl(usbmisc->base) | val;
	else
		val = readl(usbmisc->base) & ~val;
	writel(val, usbmisc->base);
	spin_unlock_irqrestore(&usbmisc->lock, flags);

	return 0;
}

static int usbmisc_imx53_init(struct imx_usbmisc_data *data)
{
	void __iomem *reg = NULL;
	unsigned long flags;
	u32 val = 0;

	if (data->index > 3)
		return -EINVAL;

	if (data->disable_oc) {
		spin_lock_irqsave(&usbmisc->lock, flags);
		switch (data->index) {
		case 0:
			reg = usbmisc->base + MX53_USB_OTG_PHY_CTRL_0_OFFSET;
			val = readl(reg) | MX53_BM_OVER_CUR_DIS_OTG;
			break;
		case 1:
			reg = usbmisc->base + MX53_USB_OTG_PHY_CTRL_0_OFFSET;
			val = readl(reg) | MX53_BM_OVER_CUR_DIS_H1;
			break;
		case 2:
			reg = usbmisc->base + MX53_USB_UH2_CTRL_OFFSET;
			val = readl(reg) | MX53_BM_OVER_CUR_DIS_UHx;
			break;
		case 3:
			reg = usbmisc->base + MX53_USB_UH3_CTRL_OFFSET;
			val = readl(reg) | MX53_BM_OVER_CUR_DIS_UHx;
			break;
		}
		if (reg && val)
			writel(val, reg);
		spin_unlock_irqrestore(&usbmisc->lock, flags);
	}

	return 0;
}

static int usbmisc_imx6q_init(struct imx_usbmisc_data *data)
{
	unsigned long flags;
	u32 reg;

	if (data->index > 3)
		return -EINVAL;

	if (data->disable_oc) {
		spin_lock_irqsave(&usbmisc->lock, flags);
		reg = readl(usbmisc->base + data->index * 4);
		writel(reg | MX6_BM_OVER_CUR_DIS,
			usbmisc->base + data->index * 4);
		spin_unlock_irqrestore(&usbmisc->lock, flags);
	}

	return 0;
}

static const struct usbmisc_ops imx25_usbmisc_ops = {
	.post = usbmisc_imx25_post,
};

static const struct usbmisc_ops imx27_usbmisc_ops = {
	.init = usbmisc_imx27_init,
};

static const struct usbmisc_ops imx53_usbmisc_ops = {
	.init = usbmisc_imx53_init,
};

static const struct usbmisc_ops imx6q_usbmisc_ops = {
	.init = usbmisc_imx6q_init,
};

int imx_usbmisc_init(struct imx_usbmisc_data *data)
{
	if (!usbmisc)
		return -EPROBE_DEFER;
	if (!usbmisc->ops->init)
		return 0;
	return usbmisc->ops->init(data);
}
EXPORT_SYMBOL_GPL(imx_usbmisc_init);

int imx_usbmisc_init_post(struct imx_usbmisc_data *data)
{
	if (!usbmisc)
		return -EPROBE_DEFER;
	if (!usbmisc->ops->post)
		return 0;
	return usbmisc->ops->post(data);
}
EXPORT_SYMBOL_GPL(imx_usbmisc_init_post);

static const struct of_device_id usbmisc_imx_dt_ids[] = {
	{
		.compatible = "fsl,imx25-usbmisc",
		.data = &imx25_usbmisc_ops,
	},
	{
		.compatible = "fsl,imx27-usbmisc",
		.data = &imx27_usbmisc_ops,
	},
	{
		.compatible = "fsl,imx53-usbmisc",
		.data = &imx53_usbmisc_ops,
	},
	{
		.compatible = "fsl,imx6q-usbmisc",
		.data = &imx6q_usbmisc_ops,
	},
	{ /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, usbmisc_imx_dt_ids);

static int usbmisc_imx_probe(struct platform_device *pdev)
{
	struct resource	*res;
	struct imx_usbmisc *data;
	int ret;
	struct of_device_id *tmp_dev;

	if (usbmisc)
		return -EBUSY;

	data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
	if (!data)
		return -ENOMEM;

	spin_lock_init(&data->lock);

	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	data->base = devm_ioremap_resource(&pdev->dev, res);
	if (IS_ERR(data->base))
		return PTR_ERR(data->base);

	data->clk = devm_clk_get(&pdev->dev, NULL);
	if (IS_ERR(data->clk)) {
		dev_err(&pdev->dev,
			"failed to get clock, err=%ld\n", PTR_ERR(data->clk));
		return PTR_ERR(data->clk);
	}

	ret = clk_prepare_enable(data->clk);
	if (ret) {
		dev_err(&pdev->dev,
			"clk_prepare_enable failed, err=%d\n", ret);
		return ret;
	}

	tmp_dev = (struct of_device_id *)
		of_match_device(usbmisc_imx_dt_ids, &pdev->dev);
	data->ops = (const struct usbmisc_ops *)tmp_dev->data;
	usbmisc = data;

	return 0;
}

static int usbmisc_imx_remove(struct platform_device *pdev)
{
	clk_disable_unprepare(usbmisc->clk);
	usbmisc = NULL;
	return 0;
}

static struct platform_driver usbmisc_imx_driver = {
	.probe = usbmisc_imx_probe,
	.remove = usbmisc_imx_remove,
	.driver = {
		.name = "usbmisc_imx",
		.owner = THIS_MODULE,
		.of_match_table = usbmisc_imx_dt_ids,
	 },
};

module_platform_driver(usbmisc_imx_driver);

MODULE_ALIAS("platform:usbmisc-imx");
MODULE_LICENSE("GPL v2");
MODULE_DESCRIPTION("driver for imx usb non-core registers");
MODULE_AUTHOR("Richard Zhao <richard.zhao@freescale.com>");
Commit	Line	Data
d142d6be RZ	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>
a0685330	17	#include <linux/delay.h>
d142d6be	18
8e22978c	19	#include "ci_hdrc_imx.h"
d142d6be	20
a0685330 MG	21	#define MX25_USB_PHY_CTRL_OFFSET 0x08
	22	#define MX25_BM_EXTERNAL_VBUS_DIVIDER BIT(23)
	23
9f90e111 AS	24	#define MX27_H1_PM_BIT BIT(8)
	25	#define MX27_H2_PM_BIT BIT(16)
	26	#define MX27_OTG_PM_BIT BIT(24)
	27
f0c910b6 MG	28	#define MX53_USB_OTG_PHY_CTRL_0_OFFSET 0x08
	29	#define MX53_USB_UH2_CTRL_OFFSET 0x14
	30	#define MX53_USB_UH3_CTRL_OFFSET 0x18
	31	#define MX53_BM_OVER_CUR_DIS_H1 BIT(5)
	32	#define MX53_BM_OVER_CUR_DIS_OTG BIT(8)
	33	#define MX53_BM_OVER_CUR_DIS_UHx BIT(30)
	34
e609108a	35	#define MX6_BM_OVER_CUR_DIS BIT(7)
d142d6be	36
05986ba9 SH	37	struct usbmisc_ops {
	38	/* It's called once when probe a usb device */
	39	int (init)(struct imx_usbmisc_data data);
	40	/* It's called once after adding a usb device */
	41	int (post)(struct imx_usbmisc_data data);
	42	};
	43
a7bc2fdf	44	struct imx_usbmisc {
d142d6be RZ	45	void __iomem *base;
	46	spinlock_t lock;
	47	struct clk *clk;
e609108a	48	const struct usbmisc_ops *ops;
d142d6be RZ	49	};
d142d6be RZ	50
a7bc2fdf	51	static struct imx_usbmisc *usbmisc;
d142d6be	52
05986ba9	53	static int usbmisc_imx25_post(struct imx_usbmisc_data *data)
a0685330	54	{
a0685330 MG	55	void __iomem *reg;
	56	unsigned long flags;
	57	u32 val;
	58
05986ba9 SH	59	if (data->index > 2)
05986ba9 SH	60	return -EINVAL;
a0685330 MG	61
	62	reg = usbmisc->base + MX25_USB_PHY_CTRL_OFFSET;
	63
05986ba9	64	if (data->evdo) {
a0685330 MG	65	spin_lock_irqsave(&usbmisc->lock, flags);
	66	val = readl(reg);
	67	writel(val \| MX25_BM_EXTERNAL_VBUS_DIVIDER, reg);
	68	spin_unlock_irqrestore(&usbmisc->lock, flags);
	69	usleep_range(5000, 10000); /* needed to stabilize voltage */
	70	}
	71
	72	return 0;
	73	}
	74
9f90e111 AS	75	static int usbmisc_imx27_init(struct imx_usbmisc_data *data)
	76	{
	77	unsigned long flags;
	78	u32 val;
	79
	80	switch (data->index) {
	81	case 0:
	82	val = MX27_OTG_PM_BIT;
	83	break;
	84	case 1:
	85	val = MX27_H1_PM_BIT;
	86	break;
	87	case 2:
	88	val = MX27_H2_PM_BIT;
	89	break;
	90	default:
	91	return -EINVAL;
	92	};
	93
	94	spin_lock_irqsave(&usbmisc->lock, flags);
	95	if (data->disable_oc)
	96	val = readl(usbmisc->base) \| val;
	97	else
	98	val = readl(usbmisc->base) & ~val;
	99	writel(val, usbmisc->base);
	100	spin_unlock_irqrestore(&usbmisc->lock, flags);
	101
	102	return 0;
	103	}
	104
05986ba9	105	static int usbmisc_imx53_init(struct imx_usbmisc_data *data)
f0c910b6	106	{
f0c910b6 MG	107	void __iomem *reg = NULL;
	108	unsigned long flags;
	109	u32 val = 0;
	110
05986ba9 SH	111	if (data->index > 3)
05986ba9 SH	112	return -EINVAL;
f0c910b6	113
05986ba9	114	if (data->disable_oc) {
f0c910b6	115	spin_lock_irqsave(&usbmisc->lock, flags);
05986ba9	116	switch (data->index) {
f0c910b6 MG	117	case 0:
	118	reg = usbmisc->base + MX53_USB_OTG_PHY_CTRL_0_OFFSET;
	119	val = readl(reg) \| MX53_BM_OVER_CUR_DIS_OTG;
	120	break;
	121	case 1:
	122	reg = usbmisc->base + MX53_USB_OTG_PHY_CTRL_0_OFFSET;
	123	val = readl(reg) \| MX53_BM_OVER_CUR_DIS_H1;
	124	break;
	125	case 2:
	126	reg = usbmisc->base + MX53_USB_UH2_CTRL_OFFSET;
	127	val = readl(reg) \| MX53_BM_OVER_CUR_DIS_UHx;
	128	break;
	129	case 3:
	130	reg = usbmisc->base + MX53_USB_UH3_CTRL_OFFSET;
	131	val = readl(reg) \| MX53_BM_OVER_CUR_DIS_UHx;
	132	break;
	133	}
	134	if (reg && val)
	135	writel(val, reg);
	136	spin_unlock_irqrestore(&usbmisc->lock, flags);
	137	}
	138
	139	return 0;
	140	}
	141
05986ba9	142	static int usbmisc_imx6q_init(struct imx_usbmisc_data *data)
d142d6be	143	{
d142d6be RZ	144	unsigned long flags;
	145	u32 reg;
	146
05986ba9 SH	147	if (data->index > 3)
05986ba9 SH	148	return -EINVAL;
d142d6be	149
05986ba9	150	if (data->disable_oc) {
d142d6be	151	spin_lock_irqsave(&usbmisc->lock, flags);
05986ba9	152	reg = readl(usbmisc->base + data->index * 4);
e609108a	153	writel(reg \| MX6_BM_OVER_CUR_DIS,
05986ba9	154	usbmisc->base + data->index * 4);
d142d6be RZ	155	spin_unlock_irqrestore(&usbmisc->lock, flags);
	156	}
	157
	158	return 0;
	159	}
	160
a0685330 MG	161	static const struct usbmisc_ops imx25_usbmisc_ops = {
	162	.post = usbmisc_imx25_post,
	163	};
	164
9f90e111 AS	165	static const struct usbmisc_ops imx27_usbmisc_ops = {
	166	.init = usbmisc_imx27_init,
	167	};
	168
f0c910b6 MG	169	static const struct usbmisc_ops imx53_usbmisc_ops = {
	170	.init = usbmisc_imx53_init,
	171	};
	172
d142d6be RZ	173	static const struct usbmisc_ops imx6q_usbmisc_ops = {
	174	.init = usbmisc_imx6q_init,
	175	};
	176
05986ba9 SH	177	int imx_usbmisc_init(struct imx_usbmisc_data *data)
	178	{
	179	if (!usbmisc)
	180	return -EPROBE_DEFER;
	181	if (!usbmisc->ops->init)
	182	return 0;
	183	return usbmisc->ops->init(data);
	184	}
	185	EXPORT_SYMBOL_GPL(imx_usbmisc_init);
	186
	187	int imx_usbmisc_init_post(struct imx_usbmisc_data *data)
	188	{
	189	if (!usbmisc)
	190	return -EPROBE_DEFER;
	191	if (!usbmisc->ops->post)
	192	return 0;
	193	return usbmisc->ops->post(data);
	194	}
	195	EXPORT_SYMBOL_GPL(imx_usbmisc_init_post);
	196
a7bc2fdf	197	static const struct of_device_id usbmisc_imx_dt_ids[] = {
a0685330 MG	198	{
	199	.compatible = "fsl,imx25-usbmisc",
	200	.data = &imx25_usbmisc_ops,
	201	},
9f90e111 AS	202	{
	203	.compatible = "fsl,imx27-usbmisc",
	204	.data = &imx27_usbmisc_ops,
	205	},
f0c910b6 MG	206	{
	207	.compatible = "fsl,imx53-usbmisc",
	208	.data = &imx53_usbmisc_ops,
	209	},
e609108a MKB	210	{
	211	.compatible = "fsl,imx6q-usbmisc",
	212	.data = &imx6q_usbmisc_ops,
	213	},
d142d6be RZ	214	{ /* sentinel */ }
d142d6be RZ	215	};
269b83dc	216	MODULE_DEVICE_TABLE(of, usbmisc_imx_dt_ids);
d142d6be	217
a7bc2fdf	218	static int usbmisc_imx_probe(struct platform_device *pdev)
d142d6be RZ	219	{
d142d6be RZ	220	struct resource *res;
a7bc2fdf	221	struct imx_usbmisc *data;
d142d6be	222	int ret;
e609108a	223	struct of_device_id *tmp_dev;
d142d6be RZ	224
	225	if (usbmisc)
	226	return -EBUSY;
	227
	228	data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
	229	if (!data)
	230	return -ENOMEM;
	231
	232	spin_lock_init(&data->lock);
	233
	234	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
148e1134 TR	235	data->base = devm_ioremap_resource(&pdev->dev, res);
	236	if (IS_ERR(data->base))
	237	return PTR_ERR(data->base);
d142d6be RZ	238
	239	data->clk = devm_clk_get(&pdev->dev, NULL);
	240	if (IS_ERR(data->clk)) {
	241	dev_err(&pdev->dev,
	242	"failed to get clock, err=%ld\n", PTR_ERR(data->clk));
	243	return PTR_ERR(data->clk);
	244	}
	245
	246	ret = clk_prepare_enable(data->clk);
	247	if (ret) {
	248	dev_err(&pdev->dev,
	249	"clk_prepare_enable failed, err=%d\n", ret);
	250	return ret;
	251	}
	252
e609108a MKB	253	tmp_dev = (struct of_device_id *)
	254	of_match_device(usbmisc_imx_dt_ids, &pdev->dev);
	255	data->ops = (const struct usbmisc_ops *)tmp_dev->data;
00b9a1f9	256	usbmisc = data;
d142d6be	257
d142d6be RZ	258	return 0;
	259	}
	260
a7bc2fdf	261	static int usbmisc_imx_remove(struct platform_device *pdev)
d142d6be	262	{
d142d6be	263	clk_disable_unprepare(usbmisc->clk);
d48a24db	264	usbmisc = NULL;
d142d6be RZ	265	return 0;
	266	}
	267
a7bc2fdf MG	268	static struct platform_driver usbmisc_imx_driver = {
	269	.probe = usbmisc_imx_probe,
	270	.remove = usbmisc_imx_remove,
d142d6be	271	.driver = {
a7bc2fdf	272	.name = "usbmisc_imx",
d142d6be	273	.owner = THIS_MODULE,
a7bc2fdf	274	.of_match_table = usbmisc_imx_dt_ids,
d142d6be RZ	275	},
	276	};
	277
0404ae03	278	module_platform_driver(usbmisc_imx_driver);
d142d6be	279
a7bc2fdf	280	MODULE_ALIAS("platform:usbmisc-imx");
d142d6be	281	MODULE_LICENSE("GPL v2");
a7bc2fdf	282	MODULE_DESCRIPTION("driver for imx usb non-core registers");
d142d6be	283	MODULE_AUTHOR("Richard Zhao <richard.zhao@freescale.com>");