[mirror_ubuntu-bionic-kernel.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 "ci13xxx_imx.h"

#define USB_DEV_MAX 4

#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 imx_usbmisc {
	void __iomem *base;
	spinlock_t lock;
	struct clk *clk;
	struct usbmisc_usb_device usbdev[USB_DEV_MAX];
	const struct usbmisc_ops *ops;
};

static struct imx_usbmisc *usbmisc;

static struct usbmisc_usb_device *get_usbdev(struct device *dev)
{
	int i, ret;

	for (i = 0; i < USB_DEV_MAX; i++) {
		if (usbmisc->usbdev[i].dev == dev)
			return &usbmisc->usbdev[i];
		else if (!usbmisc->usbdev[i].dev)
			break;
	}

	if (i >= USB_DEV_MAX)
		return ERR_PTR(-EBUSY);

	ret = usbmisc_get_init_data(dev, &usbmisc->usbdev[i]);
	if (ret)
		return ERR_PTR(ret);

	return &usbmisc->usbdev[i];
}

static int usbmisc_imx53_init(struct device *dev)
{
	struct usbmisc_usb_device *usbdev;
	void __iomem *reg = NULL;
	unsigned long flags;
	u32 val = 0;

	usbdev = get_usbdev(dev);
	if (IS_ERR(usbdev))
		return PTR_ERR(usbdev);

	if (usbdev->disable_oc) {
		spin_lock_irqsave(&usbmisc->lock, flags);
		switch (usbdev->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 device *dev)
{

	struct usbmisc_usb_device *usbdev;
	unsigned long flags;
	u32 reg;

	usbdev = get_usbdev(dev);
	if (IS_ERR(usbdev))
		return PTR_ERR(usbdev);

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

	return 0;
}

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

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

static const struct of_device_id usbmisc_imx_dt_ids[] = {
	{
		.compatible = "fsl,imx53-usbmisc",
		.data = &imx53_usbmisc_ops,
	},
	{
		.compatible = "fsl,imx6q-usbmisc",
		.data = &imx6q_usbmisc_ops,
	},
	{ /* sentinel */ }
};

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;
	ret = usbmisc_set_ops(data->ops);
	if (ret) {
		usbmisc = NULL;
		clk_disable_unprepare(data->clk);
		return ret;
	}

	return 0;
}

static int usbmisc_imx_remove(struct platform_device *pdev)
{
	usbmisc_unset_ops(usbmisc->ops);
	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,
	 },
};

int usbmisc_imx_drv_init(void)
{
	return platform_driver_register(&usbmisc_imx_driver);
}
subsys_initcall(usbmisc_imx_drv_init);

void usbmisc_imx_drv_exit(void)
{
	platform_driver_unregister(&usbmisc_imx_driver);
}
module_exit(usbmisc_imx_drv_exit);

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>
	17
	18	#include "ci13xxx_imx.h"
	19
	20	#define USB_DEV_MAX 4
	21
f0c910b6 MG	22	#define MX53_USB_OTG_PHY_CTRL_0_OFFSET 0x08
	23	#define MX53_USB_UH2_CTRL_OFFSET 0x14
	24	#define MX53_USB_UH3_CTRL_OFFSET 0x18
	25	#define MX53_BM_OVER_CUR_DIS_H1 BIT(5)
	26	#define MX53_BM_OVER_CUR_DIS_OTG BIT(8)
	27	#define MX53_BM_OVER_CUR_DIS_UHx BIT(30)
	28
e609108a	29	#define MX6_BM_OVER_CUR_DIS BIT(7)
d142d6be	30
a7bc2fdf	31	struct imx_usbmisc {
d142d6be RZ	32	void __iomem *base;
	33	spinlock_t lock;
	34	struct clk *clk;
	35	struct usbmisc_usb_device usbdev[USB_DEV_MAX];
e609108a	36	const struct usbmisc_ops *ops;
d142d6be RZ	37	};
d142d6be RZ	38
a7bc2fdf	39	static struct imx_usbmisc *usbmisc;
d142d6be RZ	40
	41	static struct usbmisc_usb_device get_usbdev(struct device dev)
	42	{
	43	int i, ret;
	44
	45	for (i = 0; i < USB_DEV_MAX; i++) {
	46	if (usbmisc->usbdev[i].dev == dev)
	47	return &usbmisc->usbdev[i];
	48	else if (!usbmisc->usbdev[i].dev)
	49	break;
	50	}
	51
	52	if (i >= USB_DEV_MAX)
	53	return ERR_PTR(-EBUSY);
	54
	55	ret = usbmisc_get_init_data(dev, &usbmisc->usbdev[i]);
	56	if (ret)
	57	return ERR_PTR(ret);
	58
	59	return &usbmisc->usbdev[i];
	60	}
	61
f0c910b6 MG	62	static int usbmisc_imx53_init(struct device *dev)
	63	{
	64	struct usbmisc_usb_device *usbdev;
	65	void __iomem *reg = NULL;
	66	unsigned long flags;
	67	u32 val = 0;
	68
	69	usbdev = get_usbdev(dev);
	70	if (IS_ERR(usbdev))
	71	return PTR_ERR(usbdev);
	72
	73	if (usbdev->disable_oc) {
	74	spin_lock_irqsave(&usbmisc->lock, flags);
	75	switch (usbdev->index) {
	76	case 0:
	77	reg = usbmisc->base + MX53_USB_OTG_PHY_CTRL_0_OFFSET;
	78	val = readl(reg) \| MX53_BM_OVER_CUR_DIS_OTG;
	79	break;
	80	case 1:
	81	reg = usbmisc->base + MX53_USB_OTG_PHY_CTRL_0_OFFSET;
	82	val = readl(reg) \| MX53_BM_OVER_CUR_DIS_H1;
	83	break;
	84	case 2:
	85	reg = usbmisc->base + MX53_USB_UH2_CTRL_OFFSET;
	86	val = readl(reg) \| MX53_BM_OVER_CUR_DIS_UHx;
	87	break;
	88	case 3:
	89	reg = usbmisc->base + MX53_USB_UH3_CTRL_OFFSET;
	90	val = readl(reg) \| MX53_BM_OVER_CUR_DIS_UHx;
	91	break;
	92	}
	93	if (reg && val)
	94	writel(val, reg);
	95	spin_unlock_irqrestore(&usbmisc->lock, flags);
	96	}
	97
	98	return 0;
	99	}
	100
d142d6be RZ	101	static int usbmisc_imx6q_init(struct device *dev)
	102	{
	103
	104	struct usbmisc_usb_device *usbdev;
	105	unsigned long flags;
	106	u32 reg;
	107
	108	usbdev = get_usbdev(dev);
	109	if (IS_ERR(usbdev))
	110	return PTR_ERR(usbdev);
	111
	112	if (usbdev->disable_oc) {
	113	spin_lock_irqsave(&usbmisc->lock, flags);
	114	reg = readl(usbmisc->base + usbdev->index * 4);
e609108a	115	writel(reg \| MX6_BM_OVER_CUR_DIS,
d142d6be RZ	116	usbmisc->base + usbdev->index * 4);
	117	spin_unlock_irqrestore(&usbmisc->lock, flags);
	118	}
	119
	120	return 0;
	121	}
	122
f0c910b6 MG	123	static const struct usbmisc_ops imx53_usbmisc_ops = {
	124	.init = usbmisc_imx53_init,
	125	};
	126
d142d6be RZ	127	static const struct usbmisc_ops imx6q_usbmisc_ops = {
	128	.init = usbmisc_imx6q_init,
	129	};
	130
a7bc2fdf	131	static const struct of_device_id usbmisc_imx_dt_ids[] = {
f0c910b6 MG	132	{
	133	.compatible = "fsl,imx53-usbmisc",
	134	.data = &imx53_usbmisc_ops,
	135	},
e609108a MKB	136	{
	137	.compatible = "fsl,imx6q-usbmisc",
	138	.data = &imx6q_usbmisc_ops,
	139	},
d142d6be RZ	140	{ /* sentinel */ }
	141	};
	142
a7bc2fdf	143	static int usbmisc_imx_probe(struct platform_device *pdev)
d142d6be RZ	144	{
d142d6be RZ	145	struct resource *res;
a7bc2fdf	146	struct imx_usbmisc *data;
d142d6be	147	int ret;
e609108a	148	struct of_device_id *tmp_dev;
d142d6be RZ	149
	150	if (usbmisc)
	151	return -EBUSY;
	152
	153	data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
	154	if (!data)
	155	return -ENOMEM;
	156
	157	spin_lock_init(&data->lock);
	158
	159	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
148e1134 TR	160	data->base = devm_ioremap_resource(&pdev->dev, res);
	161	if (IS_ERR(data->base))
	162	return PTR_ERR(data->base);
d142d6be RZ	163
	164	data->clk = devm_clk_get(&pdev->dev, NULL);
	165	if (IS_ERR(data->clk)) {
	166	dev_err(&pdev->dev,
	167	"failed to get clock, err=%ld\n", PTR_ERR(data->clk));
	168	return PTR_ERR(data->clk);
	169	}
	170
	171	ret = clk_prepare_enable(data->clk);
	172	if (ret) {
	173	dev_err(&pdev->dev,
	174	"clk_prepare_enable failed, err=%d\n", ret);
	175	return ret;
	176	}
	177
e609108a MKB	178	tmp_dev = (struct of_device_id *)
	179	of_match_device(usbmisc_imx_dt_ids, &pdev->dev);
	180	data->ops = (const struct usbmisc_ops *)tmp_dev->data;
00b9a1f9	181	usbmisc = data;
e609108a	182	ret = usbmisc_set_ops(data->ops);
d142d6be	183	if (ret) {
00b9a1f9	184	usbmisc = NULL;
d142d6be RZ	185	clk_disable_unprepare(data->clk);
	186	return ret;
	187	}
	188
d142d6be RZ	189	return 0;
	190	}
	191
a7bc2fdf	192	static int usbmisc_imx_remove(struct platform_device *pdev)
d142d6be	193	{
e609108a	194	usbmisc_unset_ops(usbmisc->ops);
d142d6be	195	clk_disable_unprepare(usbmisc->clk);
d48a24db	196	usbmisc = NULL;
d142d6be RZ	197	return 0;
	198	}
	199
a7bc2fdf MG	200	static struct platform_driver usbmisc_imx_driver = {
	201	.probe = usbmisc_imx_probe,
	202	.remove = usbmisc_imx_remove,
d142d6be	203	.driver = {
a7bc2fdf	204	.name = "usbmisc_imx",
d142d6be	205	.owner = THIS_MODULE,
a7bc2fdf	206	.of_match_table = usbmisc_imx_dt_ids,
d142d6be RZ	207	},
	208	};
	209
a7bc2fdf	210	int usbmisc_imx_drv_init(void)
d142d6be	211	{
a7bc2fdf	212	return platform_driver_register(&usbmisc_imx_driver);
d142d6be	213	}
a7bc2fdf	214	subsys_initcall(usbmisc_imx_drv_init);
d142d6be	215
a7bc2fdf	216	void usbmisc_imx_drv_exit(void)
d142d6be	217	{
a7bc2fdf	218	platform_driver_unregister(&usbmisc_imx_driver);
d142d6be	219	}
a7bc2fdf	220	module_exit(usbmisc_imx_drv_exit);
d142d6be	221
a7bc2fdf	222	MODULE_ALIAS("platform:usbmisc-imx");
d142d6be	223	MODULE_LICENSE("GPL v2");
a7bc2fdf	224	MODULE_DESCRIPTION("driver for imx usb non-core registers");
d142d6be	225	MODULE_AUTHOR("Richard Zhao <richard.zhao@freescale.com>");