[linux-2.6-block.git] / drivers / usb / chipidea / ci_hdrc_imx.c

/*
 * Copyright 2012 Freescale Semiconductor, Inc.
 * Copyright (C) 2012 Marek Vasut <marex@denx.de>
 * on behalf of DENX Software Engineering GmbH
 *
 * 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/of_gpio.h>
#include <linux/platform_device.h>
#include <linux/pm_runtime.h>
#include <linux/dma-mapping.h>
#include <linux/usb/chipidea.h>
#include <linux/clk.h>

#include "ci.h"
#include "ci_hdrc_imx.h"

struct ci_hdrc_imx_platform_flag {
	unsigned int flags;
	bool runtime_pm;
};

static const struct ci_hdrc_imx_platform_flag imx27_usb_data = {
		CI_HDRC_DISABLE_STREAMING,
};

static const struct ci_hdrc_imx_platform_flag imx28_usb_data = {
	.flags = CI_HDRC_IMX28_WRITE_FIX |
		CI_HDRC_TURN_VBUS_EARLY_ON |
		CI_HDRC_DISABLE_STREAMING,
};

static const struct ci_hdrc_imx_platform_flag imx6q_usb_data = {
	.flags = CI_HDRC_SUPPORTS_RUNTIME_PM |
		CI_HDRC_TURN_VBUS_EARLY_ON |
		CI_HDRC_DISABLE_STREAMING,
};

static const struct ci_hdrc_imx_platform_flag imx6sl_usb_data = {
	.flags = CI_HDRC_SUPPORTS_RUNTIME_PM |
		CI_HDRC_TURN_VBUS_EARLY_ON |
		CI_HDRC_DISABLE_HOST_STREAMING,
};

static const struct ci_hdrc_imx_platform_flag imx6sx_usb_data = {
	.flags = CI_HDRC_SUPPORTS_RUNTIME_PM |
		CI_HDRC_TURN_VBUS_EARLY_ON |
		CI_HDRC_DISABLE_HOST_STREAMING,
};

static const struct ci_hdrc_imx_platform_flag imx6ul_usb_data = {
	.flags = CI_HDRC_SUPPORTS_RUNTIME_PM |
		CI_HDRC_TURN_VBUS_EARLY_ON,
};

static const struct ci_hdrc_imx_platform_flag imx7d_usb_data = {
	.flags = CI_HDRC_SUPPORTS_RUNTIME_PM,
};

static const struct of_device_id ci_hdrc_imx_dt_ids[] = {
	{ .compatible = "fsl,imx28-usb", .data = &imx28_usb_data},
	{ .compatible = "fsl,imx27-usb", .data = &imx27_usb_data},
	{ .compatible = "fsl,imx6q-usb", .data = &imx6q_usb_data},
	{ .compatible = "fsl,imx6sl-usb", .data = &imx6sl_usb_data},
	{ .compatible = "fsl,imx6sx-usb", .data = &imx6sx_usb_data},
	{ .compatible = "fsl,imx6ul-usb", .data = &imx6ul_usb_data},
	{ .compatible = "fsl,imx7d-usb", .data = &imx7d_usb_data},
	{ /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, ci_hdrc_imx_dt_ids);

struct ci_hdrc_imx_data {
	struct usb_phy *phy;
	struct platform_device *ci_pdev;
	struct clk *clk;
	struct imx_usbmisc_data *usbmisc_data;
	bool supports_runtime_pm;
	bool in_lpm;
	/* SoC before i.mx6 (except imx23/imx28) needs three clks */
	bool need_three_clks;
	struct clk *clk_ipg;
	struct clk *clk_ahb;
	struct clk *clk_per;
	/* --------------------------------- */
};

/* Common functions shared by usbmisc drivers */

static struct imx_usbmisc_data *usbmisc_get_init_data(struct device *dev)
{
	struct platform_device *misc_pdev;
	struct device_node *np = dev->of_node;
	struct of_phandle_args args;
	struct imx_usbmisc_data *data;
	int ret;

	/*
	 * In case the fsl,usbmisc property is not present this device doesn't
	 * need usbmisc. Return NULL (which is no error here)
	 */
	if (!of_get_property(np, "fsl,usbmisc", NULL))
		return NULL;

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

	ret = of_parse_phandle_with_args(np, "fsl,usbmisc", "#index-cells",
					0, &args);
	if (ret) {
		dev_err(dev, "Failed to parse property fsl,usbmisc, errno %d\n",
			ret);
		return ERR_PTR(ret);
	}

	data->index = args.args[0];

	misc_pdev = of_find_device_by_node(args.np);
	of_node_put(args.np);

	if (!misc_pdev || !platform_get_drvdata(misc_pdev))
		return ERR_PTR(-EPROBE_DEFER);

	data->dev = &misc_pdev->dev;

	if (of_find_property(np, "disable-over-current", NULL))
		data->disable_oc = 1;

	if (of_find_property(np, "external-vbus-divider", NULL))
		data->evdo = 1;

	return data;
}

/* End of common functions shared by usbmisc drivers*/
static int imx_get_clks(struct device *dev)
{
	struct ci_hdrc_imx_data *data = dev_get_drvdata(dev);
	int ret = 0;

	data->clk_ipg = devm_clk_get(dev, "ipg");
	if (IS_ERR(data->clk_ipg)) {
		/* If the platform only needs one clocks */
		data->clk = devm_clk_get(dev, NULL);
		if (IS_ERR(data->clk)) {
			ret = PTR_ERR(data->clk);
			dev_err(dev,
				"Failed to get clks, err=%ld,%ld\n",
				PTR_ERR(data->clk), PTR_ERR(data->clk_ipg));
			return ret;
		}
		return ret;
	}

	data->clk_ahb = devm_clk_get(dev, "ahb");
	if (IS_ERR(data->clk_ahb)) {
		ret = PTR_ERR(data->clk_ahb);
		dev_err(dev,
			"Failed to get ahb clock, err=%d\n", ret);
		return ret;
	}

	data->clk_per = devm_clk_get(dev, "per");
	if (IS_ERR(data->clk_per)) {
		ret = PTR_ERR(data->clk_per);
		dev_err(dev,
			"Failed to get per clock, err=%d\n", ret);
		return ret;
	}

	data->need_three_clks = true;
	return ret;
}

static int imx_prepare_enable_clks(struct device *dev)
{
	struct ci_hdrc_imx_data *data = dev_get_drvdata(dev);
	int ret = 0;

	if (data->need_three_clks) {
		ret = clk_prepare_enable(data->clk_ipg);
		if (ret) {
			dev_err(dev,
				"Failed to prepare/enable ipg clk, err=%d\n",
				ret);
			return ret;
		}

		ret = clk_prepare_enable(data->clk_ahb);
		if (ret) {
			dev_err(dev,
				"Failed to prepare/enable ahb clk, err=%d\n",
				ret);
			clk_disable_unprepare(data->clk_ipg);
			return ret;
		}

		ret = clk_prepare_enable(data->clk_per);
		if (ret) {
			dev_err(dev,
				"Failed to prepare/enable per clk, err=%d\n",
				ret);
			clk_disable_unprepare(data->clk_ahb);
			clk_disable_unprepare(data->clk_ipg);
			return ret;
		}
	} else {
		ret = clk_prepare_enable(data->clk);
		if (ret) {
			dev_err(dev,
				"Failed to prepare/enable clk, err=%d\n",
				ret);
			return ret;
		}
	}

	return ret;
}

static void imx_disable_unprepare_clks(struct device *dev)
{
	struct ci_hdrc_imx_data *data = dev_get_drvdata(dev);

	if (data->need_three_clks) {
		clk_disable_unprepare(data->clk_per);
		clk_disable_unprepare(data->clk_ahb);
		clk_disable_unprepare(data->clk_ipg);
	} else {
		clk_disable_unprepare(data->clk);
	}
}

static int ci_hdrc_imx_probe(struct platform_device *pdev)
{
	struct ci_hdrc_imx_data *data;
	struct ci_hdrc_platform_data pdata = {
		.name		= dev_name(&pdev->dev),
		.capoffset	= DEF_CAPOFFSET,
		.flags		= CI_HDRC_SET_NON_ZERO_TTHA,
	};
	int ret;
	const struct of_device_id *of_id =
			of_match_device(ci_hdrc_imx_dt_ids, &pdev->dev);
	const struct ci_hdrc_imx_platform_flag *imx_platform_flag = of_id->data;

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

	platform_set_drvdata(pdev, data);
	data->usbmisc_data = usbmisc_get_init_data(&pdev->dev);
	if (IS_ERR(data->usbmisc_data))
		return PTR_ERR(data->usbmisc_data);

	ret = imx_get_clks(&pdev->dev);
	if (ret)
		return ret;

	ret = imx_prepare_enable_clks(&pdev->dev);
	if (ret)
		return ret;

	data->phy = devm_usb_get_phy_by_phandle(&pdev->dev, "fsl,usbphy", 0);
	if (IS_ERR(data->phy)) {
		ret = PTR_ERR(data->phy);
		/* Return -EINVAL if no usbphy is available */
		if (ret == -ENODEV)
			ret = -EINVAL;
		goto err_clk;
	}

	pdata.usb_phy = data->phy;
	pdata.flags |= imx_platform_flag->flags;
	if (pdata.flags & CI_HDRC_SUPPORTS_RUNTIME_PM)
		data->supports_runtime_pm = true;

	ret = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
	if (ret)
		goto err_clk;

	ret = imx_usbmisc_init(data->usbmisc_data);
	if (ret) {
		dev_err(&pdev->dev, "usbmisc init failed, ret=%d\n", ret);
		goto err_clk;
	}

	data->ci_pdev = ci_hdrc_add_device(&pdev->dev,
				pdev->resource, pdev->num_resources,
				&pdata);
	if (IS_ERR(data->ci_pdev)) {
		ret = PTR_ERR(data->ci_pdev);
		dev_err(&pdev->dev,
			"Can't register ci_hdrc platform device, err=%d\n",
			ret);
		goto err_clk;
	}

	ret = imx_usbmisc_init_post(data->usbmisc_data);
	if (ret) {
		dev_err(&pdev->dev, "usbmisc post failed, ret=%d\n", ret);
		goto disable_device;
	}

	if (data->supports_runtime_pm) {
		pm_runtime_set_active(&pdev->dev);
		pm_runtime_enable(&pdev->dev);
	}

	device_set_wakeup_capable(&pdev->dev, true);

	return 0;

disable_device:
	ci_hdrc_remove_device(data->ci_pdev);
err_clk:
	imx_disable_unprepare_clks(&pdev->dev);
	return ret;
}

static int ci_hdrc_imx_remove(struct platform_device *pdev)
{
	struct ci_hdrc_imx_data *data = platform_get_drvdata(pdev);

	if (data->supports_runtime_pm) {
		pm_runtime_get_sync(&pdev->dev);
		pm_runtime_disable(&pdev->dev);
		pm_runtime_put_noidle(&pdev->dev);
	}
	ci_hdrc_remove_device(data->ci_pdev);
	imx_disable_unprepare_clks(&pdev->dev);

	return 0;
}

#ifdef CONFIG_PM
static int imx_controller_suspend(struct device *dev)
{
	struct ci_hdrc_imx_data *data = dev_get_drvdata(dev);

	dev_dbg(dev, "at %s\n", __func__);

	imx_disable_unprepare_clks(dev);
	data->in_lpm = true;

	return 0;
}

static int imx_controller_resume(struct device *dev)
{
	struct ci_hdrc_imx_data *data = dev_get_drvdata(dev);
	int ret = 0;

	dev_dbg(dev, "at %s\n", __func__);

	if (!data->in_lpm) {
		WARN_ON(1);
		return 0;
	}

	ret = imx_prepare_enable_clks(dev);
	if (ret)
		return ret;

	data->in_lpm = false;

	ret = imx_usbmisc_set_wakeup(data->usbmisc_data, false);
	if (ret) {
		dev_err(dev, "usbmisc set_wakeup failed, ret=%d\n", ret);
		goto clk_disable;
	}

	return 0;

clk_disable:
	imx_disable_unprepare_clks(dev);
	return ret;
}

#ifdef CONFIG_PM_SLEEP
static int ci_hdrc_imx_suspend(struct device *dev)
{
	int ret;

	struct ci_hdrc_imx_data *data = dev_get_drvdata(dev);

	if (data->in_lpm)
		/* The core's suspend doesn't run */
		return 0;

	if (device_may_wakeup(dev)) {
		ret = imx_usbmisc_set_wakeup(data->usbmisc_data, true);
		if (ret) {
			dev_err(dev, "usbmisc set_wakeup failed, ret=%d\n",
					ret);
			return ret;
		}
	}

	return imx_controller_suspend(dev);
}

static int ci_hdrc_imx_resume(struct device *dev)
{
	struct ci_hdrc_imx_data *data = dev_get_drvdata(dev);
	int ret;

	ret = imx_controller_resume(dev);
	if (!ret && data->supports_runtime_pm) {
		pm_runtime_disable(dev);
		pm_runtime_set_active(dev);
		pm_runtime_enable(dev);
	}

	return ret;
}
#endif /* CONFIG_PM_SLEEP */

static int ci_hdrc_imx_runtime_suspend(struct device *dev)
{
	struct ci_hdrc_imx_data *data = dev_get_drvdata(dev);
	int ret;

	if (data->in_lpm) {
		WARN_ON(1);
		return 0;
	}

	ret = imx_usbmisc_set_wakeup(data->usbmisc_data, true);
	if (ret) {
		dev_err(dev, "usbmisc set_wakeup failed, ret=%d\n", ret);
		return ret;
	}

	return imx_controller_suspend(dev);
}

static int ci_hdrc_imx_runtime_resume(struct device *dev)
{
	return imx_controller_resume(dev);
}

#endif /* CONFIG_PM */

static const struct dev_pm_ops ci_hdrc_imx_pm_ops = {
	SET_SYSTEM_SLEEP_PM_OPS(ci_hdrc_imx_suspend, ci_hdrc_imx_resume)
	SET_RUNTIME_PM_OPS(ci_hdrc_imx_runtime_suspend,
			ci_hdrc_imx_runtime_resume, NULL)
};
static struct platform_driver ci_hdrc_imx_driver = {
	.probe = ci_hdrc_imx_probe,
	.remove = ci_hdrc_imx_remove,
	.driver = {
		.name = "imx_usb",
		.of_match_table = ci_hdrc_imx_dt_ids,
		.pm = &ci_hdrc_imx_pm_ops,
	 },
};

module_platform_driver(ci_hdrc_imx_driver);

MODULE_ALIAS("platform:imx-usb");
MODULE_LICENSE("GPL v2");
MODULE_DESCRIPTION("CI HDRC i.MX USB binding");
MODULE_AUTHOR("Marek Vasut <marex@denx.de>");
MODULE_AUTHOR("Richard Zhao <richard.zhao@freescale.com>");
Commit	Line	Data
15302800 RZ	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>
15302800 RZ	22
15302800 RZ	23	#include "ci.h"
8e22978c	24	#include "ci_hdrc_imx.h"
15302800	25
1071055e PC	26	struct ci_hdrc_imx_platform_flag {
1071055e PC	27	unsigned int flags;
e14db48d	28	bool runtime_pm;
1071055e PC	29	};
	30
	31	static const struct ci_hdrc_imx_platform_flag imx27_usb_data = {
0ef877a4	32	CI_HDRC_DISABLE_STREAMING,
1071055e PC	33	};
	34
	35	static const struct ci_hdrc_imx_platform_flag imx28_usb_data = {
6adb9b7b	36	.flags = CI_HDRC_IMX28_WRITE_FIX \|
0ef877a4 PC	37	CI_HDRC_TURN_VBUS_EARLY_ON \|
0ef877a4 PC	38	CI_HDRC_DISABLE_STREAMING,
1071055e PC	39	};
1071055e PC	40
e14db48d	41	static const struct ci_hdrc_imx_platform_flag imx6q_usb_data = {
6adb9b7b	42	.flags = CI_HDRC_SUPPORTS_RUNTIME_PM \|
0ef877a4 PC	43	CI_HDRC_TURN_VBUS_EARLY_ON \|
0ef877a4 PC	44	CI_HDRC_DISABLE_STREAMING,
e14db48d PC	45	};
	46
	47	static const struct ci_hdrc_imx_platform_flag imx6sl_usb_data = {
6adb9b7b	48	.flags = CI_HDRC_SUPPORTS_RUNTIME_PM \|
0ef877a4 PC	49	CI_HDRC_TURN_VBUS_EARLY_ON \|
0ef877a4 PC	50	CI_HDRC_DISABLE_HOST_STREAMING,
e14db48d PC	51	};
	52
	53	static const struct ci_hdrc_imx_platform_flag imx6sx_usb_data = {
6adb9b7b	54	.flags = CI_HDRC_SUPPORTS_RUNTIME_PM \|
0ef877a4 PC	55	CI_HDRC_TURN_VBUS_EARLY_ON \|
0ef877a4 PC	56	CI_HDRC_DISABLE_HOST_STREAMING,
e14db48d PC	57	};
e14db48d PC	58
52fe568e PC	59	static const struct ci_hdrc_imx_platform_flag imx6ul_usb_data = {
	60	.flags = CI_HDRC_SUPPORTS_RUNTIME_PM \|
	61	CI_HDRC_TURN_VBUS_EARLY_ON,
	62	};
	63
5cb377c5 PC	64	static const struct ci_hdrc_imx_platform_flag imx7d_usb_data = {
	65	.flags = CI_HDRC_SUPPORTS_RUNTIME_PM,
	66	};
	67
1071055e PC	68	static const struct of_device_id ci_hdrc_imx_dt_ids[] = {
	69	{ .compatible = "fsl,imx28-usb", .data = &imx28_usb_data},
	70	{ .compatible = "fsl,imx27-usb", .data = &imx27_usb_data},
e14db48d PC	71	{ .compatible = "fsl,imx6q-usb", .data = &imx6q_usb_data},
e14db48d PC	72	{ .compatible = "fsl,imx6sl-usb", .data = &imx6sl_usb_data},
8315b77d	73	{ .compatible = "fsl,imx6sx-usb", .data = &imx6sx_usb_data},
52fe568e	74	{ .compatible = "fsl,imx6ul-usb", .data = &imx6ul_usb_data},
5cb377c5	75	{ .compatible = "fsl,imx7d-usb", .data = &imx7d_usb_data},
1071055e PC	76	{ /* sentinel */ }
	77	};
	78	MODULE_DEVICE_TABLE(of, ci_hdrc_imx_dt_ids);
	79
8e22978c	80	struct ci_hdrc_imx_data {
15302800 RZ	81	struct usb_phy *phy;
	82	struct platform_device *ci_pdev;
	83	struct clk *clk;
05986ba9	84	struct imx_usbmisc_data *usbmisc_data;
e14db48d PC	85	bool supports_runtime_pm;
e14db48d PC	86	bool in_lpm;
ae3e57ae PC	87	/* SoC before i.mx6 (except imx23/imx28) needs three clks */
	88	bool need_three_clks;
	89	struct clk *clk_ipg;
	90	struct clk *clk_ahb;
	91	struct clk *clk_per;
	92	/* --------------------------------- */
15302800 RZ	93	};
15302800 RZ	94
d142d6be RZ	95	/* Common functions shared by usbmisc drivers */
d142d6be RZ	96
05986ba9	97	static struct imx_usbmisc_data usbmisc_get_init_data(struct device dev)
d142d6be	98	{
f40017e0	99	struct platform_device *misc_pdev;
d142d6be RZ	100	struct device_node *np = dev->of_node;
d142d6be RZ	101	struct of_phandle_args args;
05986ba9	102	struct imx_usbmisc_data *data;
d142d6be RZ	103	int ret;
d142d6be RZ	104
05986ba9 SH	105	/*
	106	* In case the fsl,usbmisc property is not present this device doesn't
	107	* need usbmisc. Return NULL (which is no error here)
	108	*/
	109	if (!of_get_property(np, "fsl,usbmisc", NULL))
	110	return NULL;
	111
	112	data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
	113	if (!data)
	114	return ERR_PTR(-ENOMEM);
d142d6be RZ	115
	116	ret = of_parse_phandle_with_args(np, "fsl,usbmisc", "#index-cells",
	117	0, &args);
	118	if (ret) {
	119	dev_err(dev, "Failed to parse property fsl,usbmisc, errno %d\n",
	120	ret);
05986ba9	121	return ERR_PTR(ret);
d142d6be	122	}
05986ba9 SH	123
05986ba9 SH	124	data->index = args.args[0];
f40017e0 SA	125
f40017e0 SA	126	misc_pdev = of_find_device_by_node(args.np);
d142d6be RZ	127	of_node_put(args.np);
d142d6be RZ	128
ef12da91	129	if (!misc_pdev \|\| !platform_get_drvdata(misc_pdev))
f40017e0 SA	130	return ERR_PTR(-EPROBE_DEFER);
	131
	132	data->dev = &misc_pdev->dev;
	133
d142d6be	134	if (of_find_property(np, "disable-over-current", NULL))
05986ba9	135	data->disable_oc = 1;
d142d6be	136
a0685330	137	if (of_find_property(np, "external-vbus-divider", NULL))
05986ba9	138	data->evdo = 1;
a0685330	139
05986ba9	140	return data;
d142d6be	141	}
d142d6be RZ	142
d142d6be RZ	143	/* End of common functions shared by usbmisc drivers*/
ae3e57ae PC	144	static int imx_get_clks(struct device *dev)
	145	{
	146	struct ci_hdrc_imx_data *data = dev_get_drvdata(dev);
	147	int ret = 0;
	148
	149	data->clk_ipg = devm_clk_get(dev, "ipg");
	150	if (IS_ERR(data->clk_ipg)) {
	151	/* If the platform only needs one clocks */
	152	data->clk = devm_clk_get(dev, NULL);
	153	if (IS_ERR(data->clk)) {
	154	ret = PTR_ERR(data->clk);
	155	dev_err(dev,
	156	"Failed to get clks, err=%ld,%ld\n",
	157	PTR_ERR(data->clk), PTR_ERR(data->clk_ipg));
	158	return ret;
	159	}
	160	return ret;
	161	}
	162
	163	data->clk_ahb = devm_clk_get(dev, "ahb");
	164	if (IS_ERR(data->clk_ahb)) {
	165	ret = PTR_ERR(data->clk_ahb);
	166	dev_err(dev,
	167	"Failed to get ahb clock, err=%d\n", ret);
	168	return ret;
	169	}
	170
	171	data->clk_per = devm_clk_get(dev, "per");
	172	if (IS_ERR(data->clk_per)) {
	173	ret = PTR_ERR(data->clk_per);
	174	dev_err(dev,
	175	"Failed to get per clock, err=%d\n", ret);
	176	return ret;
	177	}
	178
	179	data->need_three_clks = true;
	180	return ret;
	181	}
	182
	183	static int imx_prepare_enable_clks(struct device *dev)
	184	{
	185	struct ci_hdrc_imx_data *data = dev_get_drvdata(dev);
	186	int ret = 0;
	187
	188	if (data->need_three_clks) {
	189	ret = clk_prepare_enable(data->clk_ipg);
	190	if (ret) {
	191	dev_err(dev,
	192	"Failed to prepare/enable ipg clk, err=%d\n",
	193	ret);
	194	return ret;
	195	}
	196
	197	ret = clk_prepare_enable(data->clk_ahb);
	198	if (ret) {
	199	dev_err(dev,
	200	"Failed to prepare/enable ahb clk, err=%d\n",
	201	ret);
	202	clk_disable_unprepare(data->clk_ipg);
	203	return ret;
	204	}
	205
	206	ret = clk_prepare_enable(data->clk_per);
	207	if (ret) {
208	dev_err(dev,
209	"Failed to prepare/enable per clk, err=%d\n",
210	ret);
211	clk_disable_unprepare(data->clk_ahb);
212	clk_disable_unprepare(data->clk_ipg);
213	return ret;
214	}
215	} else {
216	ret = clk_prepare_enable(data->clk);
217	if (ret) {
218	dev_err(dev,
219	"Failed to prepare/enable clk, err=%d\n",
220	ret);
221	return ret;
222	}
223	}
224
225	return ret;
226	}
227
228	static void imx_disable_unprepare_clks(struct device *dev)
229	{
230	struct ci_hdrc_imx_data *data = dev_get_drvdata(dev);
231
232	if (data->need_three_clks) {
233	clk_disable_unprepare(data->clk_per);
234	clk_disable_unprepare(data->clk_ahb);
235	clk_disable_unprepare(data->clk_ipg);
236	} else {
237	clk_disable_unprepare(data->clk);
238	}
239	}
d142d6be	240
8e22978c	241	static int ci_hdrc_imx_probe(struct platform_device *pdev)
15302800	242	{
8e22978c AS	243	struct ci_hdrc_imx_data *data;
8e22978c AS	244	struct ci_hdrc_platform_data pdata = {
c844d6c8	245	.name = dev_name(&pdev->dev),
f6a3b3a3	246	.capoffset = DEF_CAPOFFSET,
0ef877a4	247	.flags = CI_HDRC_SET_NON_ZERO_TTHA,
f6a3b3a3	248	};
15302800	249	int ret;
1071055e PC	250	const struct of_device_id *of_id =
	251	of_match_device(ci_hdrc_imx_dt_ids, &pdev->dev);
	252	const struct ci_hdrc_imx_platform_flag *imx_platform_flag = of_id->data;
15302800 RZ	253
15302800 RZ	254	data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
73529828	255	if (!data)
15302800	256	return -ENOMEM;
15302800	257
ae3e57ae	258	platform_set_drvdata(pdev, data);
05986ba9 SH	259	data->usbmisc_data = usbmisc_get_init_data(&pdev->dev);
	260	if (IS_ERR(data->usbmisc_data))
	261	return PTR_ERR(data->usbmisc_data);
	262
ae3e57ae PC	263	ret = imx_get_clks(&pdev->dev);
	264	if (ret)
	265	return ret;
15302800	266
ae3e57ae PC	267	ret = imx_prepare_enable_clks(&pdev->dev);
ae3e57ae PC	268	if (ret)
15302800	269	return ret;
15302800	270
046916de	271	data->phy = devm_usb_get_phy_by_phandle(&pdev->dev, "fsl,usbphy", 0);
af59a8b1 PC	272	if (IS_ERR(data->phy)) {
af59a8b1 PC	273	ret = PTR_ERR(data->phy);
16853d7b MP	274	/* Return -EINVAL if no usbphy is available */
	275	if (ret == -ENODEV)
	276	ret = -EINVAL;
ea1418b5	277	goto err_clk;
15302800 RZ	278	}
15302800 RZ	279
ef44cb42	280	pdata.usb_phy = data->phy;
56040087	281	pdata.flags \|= imx_platform_flag->flags;
e14db48d PC	282	if (pdata.flags & CI_HDRC_SUPPORTS_RUNTIME_PM)
e14db48d PC	283	data->supports_runtime_pm = true;
1071055e	284
e1fd7341	285	ret = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
22d9d8e8 RK	286	if (ret)
22d9d8e8 RK	287	goto err_clk;
d142d6be	288
a4cf1b14 PC	289	ret = imx_usbmisc_init(data->usbmisc_data);
	290	if (ret) {
	291	dev_err(&pdev->dev, "usbmisc init failed, ret=%d\n", ret);
	292	goto err_clk;
d142d6be RZ	293	}
d142d6be RZ	294
8e22978c	295	data->ci_pdev = ci_hdrc_add_device(&pdev->dev,
15302800	296	pdev->resource, pdev->num_resources,
f6a3b3a3	297	&pdata);
770719df FE	298	if (IS_ERR(data->ci_pdev)) {
770719df FE	299	ret = PTR_ERR(data->ci_pdev);
15302800 RZ	300	dev_err(&pdev->dev,
	301	"Can't register ci_hdrc platform device, err=%d\n",
	302	ret);
af59a8b1	303	goto err_clk;
15302800 RZ	304	}
15302800 RZ	305
a4cf1b14 PC	306	ret = imx_usbmisc_init_post(data->usbmisc_data);
	307	if (ret) {
	308	dev_err(&pdev->dev, "usbmisc post failed, ret=%d\n", ret);
	309	goto disable_device;
a0685330 MG	310	}
a0685330 MG	311
e14db48d PC	312	if (data->supports_runtime_pm) {
	313	pm_runtime_set_active(&pdev->dev);
	314	pm_runtime_enable(&pdev->dev);
	315	}
15302800	316
6d653110 PC	317	device_set_wakeup_capable(&pdev->dev, true);
6d653110 PC	318
15302800 RZ	319	return 0;
15302800 RZ	320
770719df	321	disable_device:
8e22978c	322	ci_hdrc_remove_device(data->ci_pdev);
ea1418b5	323	err_clk:
ae3e57ae	324	imx_disable_unprepare_clks(&pdev->dev);
15302800 RZ	325	return ret;
	326	}
	327
8e22978c	328	static int ci_hdrc_imx_remove(struct platform_device *pdev)
15302800	329	{
8e22978c	330	struct ci_hdrc_imx_data *data = platform_get_drvdata(pdev);
15302800	331
e14db48d PC	332	if (data->supports_runtime_pm) {
	333	pm_runtime_get_sync(&pdev->dev);
	334	pm_runtime_disable(&pdev->dev);
	335	pm_runtime_put_noidle(&pdev->dev);
	336	}
8e22978c	337	ci_hdrc_remove_device(data->ci_pdev);
ae3e57ae	338	imx_disable_unprepare_clks(&pdev->dev);
15302800	339
15302800 RZ	340	return 0;
	341	}
	342
e14db48d	343	#ifdef CONFIG_PM
2558c1f5 PC	344	static int imx_controller_suspend(struct device *dev)
	345	{
	346	struct ci_hdrc_imx_data *data = dev_get_drvdata(dev);
	347
	348	dev_dbg(dev, "at %s\n", __func__);
	349
ae3e57ae	350	imx_disable_unprepare_clks(dev);
e14db48d	351	data->in_lpm = true;
2558c1f5 PC	352
	353	return 0;
	354	}
	355
	356	static int imx_controller_resume(struct device *dev)
	357	{
	358	struct ci_hdrc_imx_data *data = dev_get_drvdata(dev);
e14db48d	359	int ret = 0;
2558c1f5 PC	360
	361	dev_dbg(dev, "at %s\n", __func__);
	362
e14db48d PC	363	if (!data->in_lpm) {
	364	WARN_ON(1);
	365	return 0;
	366	}
	367
ae3e57ae	368	ret = imx_prepare_enable_clks(dev);
e14db48d PC	369	if (ret)
	370	return ret;
	371
	372	data->in_lpm = false;
	373
	374	ret = imx_usbmisc_set_wakeup(data->usbmisc_data, false);
	375	if (ret) {
	376	dev_err(dev, "usbmisc set_wakeup failed, ret=%d\n", ret);
	377	goto clk_disable;
	378	}
	379
	380	return 0;
	381
	382	clk_disable:
ae3e57ae	383	imx_disable_unprepare_clks(dev);
e14db48d	384	return ret;
2558c1f5 PC	385	}
2558c1f5 PC	386
e14db48d	387	#ifdef CONFIG_PM_SLEEP
2558c1f5 PC	388	static int ci_hdrc_imx_suspend(struct device *dev)
2558c1f5 PC	389	{
6d653110 PC	390	int ret;
6d653110 PC	391
e14db48d PC	392	struct ci_hdrc_imx_data *data = dev_get_drvdata(dev);
	393
	394	if (data->in_lpm)
	395	/* The core's suspend doesn't run */
	396	return 0;
	397
6d653110 PC	398	if (device_may_wakeup(dev)) {
	399	ret = imx_usbmisc_set_wakeup(data->usbmisc_data, true);
	400	if (ret) {
	401	dev_err(dev, "usbmisc set_wakeup failed, ret=%d\n",
	402	ret);
	403	return ret;
	404	}
	405	}
	406
2558c1f5 PC	407	return imx_controller_suspend(dev);
	408	}
	409
	410	static int ci_hdrc_imx_resume(struct device *dev)
	411	{
e14db48d PC	412	struct ci_hdrc_imx_data *data = dev_get_drvdata(dev);
	413	int ret;
	414
	415	ret = imx_controller_resume(dev);
	416	if (!ret && data->supports_runtime_pm) {
	417	pm_runtime_disable(dev);
	418	pm_runtime_set_active(dev);
	419	pm_runtime_enable(dev);
	420	}
	421
	422	return ret;
2558c1f5 PC	423	}
	424	#endif /* CONFIG_PM_SLEEP */
	425
e14db48d PC	426	static int ci_hdrc_imx_runtime_suspend(struct device *dev)
	427	{
	428	struct ci_hdrc_imx_data *data = dev_get_drvdata(dev);
	429	int ret;
	430
	431	if (data->in_lpm) {
	432	WARN_ON(1);
	433	return 0;
	434	}
	435
	436	ret = imx_usbmisc_set_wakeup(data->usbmisc_data, true);
	437	if (ret) {
	438	dev_err(dev, "usbmisc set_wakeup failed, ret=%d\n", ret);
	439	return ret;
	440	}
	441
	442	return imx_controller_suspend(dev);
	443	}
	444
	445	static int ci_hdrc_imx_runtime_resume(struct device *dev)
	446	{
	447	return imx_controller_resume(dev);
	448	}
	449
	450	#endif /* CONFIG_PM */
	451
2558c1f5 PC	452	static const struct dev_pm_ops ci_hdrc_imx_pm_ops = {
2558c1f5 PC	453	SET_SYSTEM_SLEEP_PM_OPS(ci_hdrc_imx_suspend, ci_hdrc_imx_resume)
e14db48d PC	454	SET_RUNTIME_PM_OPS(ci_hdrc_imx_runtime_suspend,
e14db48d PC	455	ci_hdrc_imx_runtime_resume, NULL)
2558c1f5	456	};
8e22978c AS	457	static struct platform_driver ci_hdrc_imx_driver = {
	458	.probe = ci_hdrc_imx_probe,
	459	.remove = ci_hdrc_imx_remove,
15302800 RZ	460	.driver = {
15302800 RZ	461	.name = "imx_usb",
8e22978c	462	.of_match_table = ci_hdrc_imx_dt_ids,
2558c1f5	463	.pm = &ci_hdrc_imx_pm_ops,
15302800 RZ	464	},
	465	};
	466
8e22978c	467	module_platform_driver(ci_hdrc_imx_driver);
15302800 RZ	468
	469	MODULE_ALIAS("platform:imx-usb");
	470	MODULE_LICENSE("GPL v2");
8e22978c	471	MODULE_DESCRIPTION("CI HDRC i.MX USB binding");
15302800 RZ	472	MODULE_AUTHOR("Marek Vasut <marex@denx.de>");
15302800 RZ	473	MODULE_AUTHOR("Richard Zhao <richard.zhao@freescale.com>");