[deliverable/linux.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;
	const struct ci_hdrc_imx_platform_flag *imx_platform_flag;

	of_id = of_match_device(ci_hdrc_imx_dt_ids, &pdev->dev);
	if (!of_id)
		return -ENODEV;

	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;
6f51bc34 LC	250	const struct of_device_id *of_id;
	251	const struct ci_hdrc_imx_platform_flag *imx_platform_flag;
	252
	253	of_id = of_match_device(ci_hdrc_imx_dt_ids, &pdev->dev);
	254	if (!of_id)
	255	return -ENODEV;
	256
	257	imx_platform_flag = of_id->data;
15302800 RZ	258
15302800 RZ	259	data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
73529828	260	if (!data)
15302800	261	return -ENOMEM;
15302800	262
ae3e57ae	263	platform_set_drvdata(pdev, data);
05986ba9 SH	264	data->usbmisc_data = usbmisc_get_init_data(&pdev->dev);
	265	if (IS_ERR(data->usbmisc_data))
	266	return PTR_ERR(data->usbmisc_data);
	267
ae3e57ae PC	268	ret = imx_get_clks(&pdev->dev);
	269	if (ret)
	270	return ret;
15302800	271
ae3e57ae PC	272	ret = imx_prepare_enable_clks(&pdev->dev);
ae3e57ae PC	273	if (ret)
15302800	274	return ret;
15302800	275
046916de	276	data->phy = devm_usb_get_phy_by_phandle(&pdev->dev, "fsl,usbphy", 0);
af59a8b1 PC	277	if (IS_ERR(data->phy)) {
af59a8b1 PC	278	ret = PTR_ERR(data->phy);
16853d7b MP	279	/* Return -EINVAL if no usbphy is available */
	280	if (ret == -ENODEV)
	281	ret = -EINVAL;
ea1418b5	282	goto err_clk;
15302800 RZ	283	}
15302800 RZ	284
ef44cb42	285	pdata.usb_phy = data->phy;
56040087	286	pdata.flags \|= imx_platform_flag->flags;
e14db48d PC	287	if (pdata.flags & CI_HDRC_SUPPORTS_RUNTIME_PM)
e14db48d PC	288	data->supports_runtime_pm = true;
1071055e	289
e1fd7341	290	ret = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
22d9d8e8 RK	291	if (ret)
22d9d8e8 RK	292	goto err_clk;
d142d6be	293
a4cf1b14 PC	294	ret = imx_usbmisc_init(data->usbmisc_data);
	295	if (ret) {
	296	dev_err(&pdev->dev, "usbmisc init failed, ret=%d\n", ret);
	297	goto err_clk;
d142d6be RZ	298	}
d142d6be RZ	299
8e22978c	300	data->ci_pdev = ci_hdrc_add_device(&pdev->dev,
15302800	301	pdev->resource, pdev->num_resources,
f6a3b3a3	302	&pdata);
770719df FE	303	if (IS_ERR(data->ci_pdev)) {
770719df FE	304	ret = PTR_ERR(data->ci_pdev);
15302800 RZ	305	dev_err(&pdev->dev,
	306	"Can't register ci_hdrc platform device, err=%d\n",
	307	ret);
af59a8b1	308	goto err_clk;
15302800 RZ	309	}
15302800 RZ	310
a4cf1b14 PC	311	ret = imx_usbmisc_init_post(data->usbmisc_data);
	312	if (ret) {
	313	dev_err(&pdev->dev, "usbmisc post failed, ret=%d\n", ret);
	314	goto disable_device;
a0685330 MG	315	}
a0685330 MG	316
e14db48d PC	317	if (data->supports_runtime_pm) {
	318	pm_runtime_set_active(&pdev->dev);
	319	pm_runtime_enable(&pdev->dev);
	320	}
15302800	321
6d653110 PC	322	device_set_wakeup_capable(&pdev->dev, true);
6d653110 PC	323
15302800 RZ	324	return 0;
15302800 RZ	325
770719df	326	disable_device:
8e22978c	327	ci_hdrc_remove_device(data->ci_pdev);
ea1418b5	328	err_clk:
ae3e57ae	329	imx_disable_unprepare_clks(&pdev->dev);
15302800 RZ	330	return ret;
	331	}
	332
8e22978c	333	static int ci_hdrc_imx_remove(struct platform_device *pdev)
15302800	334	{
8e22978c	335	struct ci_hdrc_imx_data *data = platform_get_drvdata(pdev);
15302800	336
e14db48d PC	337	if (data->supports_runtime_pm) {
	338	pm_runtime_get_sync(&pdev->dev);
	339	pm_runtime_disable(&pdev->dev);
	340	pm_runtime_put_noidle(&pdev->dev);
	341	}
8e22978c	342	ci_hdrc_remove_device(data->ci_pdev);
ae3e57ae	343	imx_disable_unprepare_clks(&pdev->dev);
15302800	344
15302800 RZ	345	return 0;
	346	}
	347
e14db48d	348	#ifdef CONFIG_PM
2558c1f5 PC	349	static int imx_controller_suspend(struct device *dev)
	350	{
	351	struct ci_hdrc_imx_data *data = dev_get_drvdata(dev);
	352
	353	dev_dbg(dev, "at %s\n", __func__);
	354
ae3e57ae	355	imx_disable_unprepare_clks(dev);
e14db48d	356	data->in_lpm = true;
2558c1f5 PC	357
	358	return 0;
	359	}
	360
	361	static int imx_controller_resume(struct device *dev)
	362	{
	363	struct ci_hdrc_imx_data *data = dev_get_drvdata(dev);
e14db48d	364	int ret = 0;
2558c1f5 PC	365
	366	dev_dbg(dev, "at %s\n", __func__);
	367
e14db48d PC	368	if (!data->in_lpm) {
	369	WARN_ON(1);
	370	return 0;
	371	}
	372
ae3e57ae	373	ret = imx_prepare_enable_clks(dev);
e14db48d PC	374	if (ret)
	375	return ret;
	376
	377	data->in_lpm = false;
	378
	379	ret = imx_usbmisc_set_wakeup(data->usbmisc_data, false);
	380	if (ret) {
	381	dev_err(dev, "usbmisc set_wakeup failed, ret=%d\n", ret);
	382	goto clk_disable;
	383	}
	384
	385	return 0;
	386
	387	clk_disable:
ae3e57ae	388	imx_disable_unprepare_clks(dev);
e14db48d	389	return ret;
2558c1f5 PC	390	}
2558c1f5 PC	391
e14db48d	392	#ifdef CONFIG_PM_SLEEP
2558c1f5 PC	393	static int ci_hdrc_imx_suspend(struct device *dev)
2558c1f5 PC	394	{
6d653110 PC	395	int ret;
6d653110 PC	396
e14db48d PC	397	struct ci_hdrc_imx_data *data = dev_get_drvdata(dev);
	398
	399	if (data->in_lpm)
	400	/* The core's suspend doesn't run */
	401	return 0;
	402
6d653110 PC	403	if (device_may_wakeup(dev)) {
	404	ret = imx_usbmisc_set_wakeup(data->usbmisc_data, true);
	405	if (ret) {
	406	dev_err(dev, "usbmisc set_wakeup failed, ret=%d\n",
	407	ret);
	408	return ret;
	409	}
	410	}
	411
2558c1f5 PC	412	return imx_controller_suspend(dev);
	413	}
	414
	415	static int ci_hdrc_imx_resume(struct device *dev)
	416	{
e14db48d PC	417	struct ci_hdrc_imx_data *data = dev_get_drvdata(dev);
	418	int ret;
	419
	420	ret = imx_controller_resume(dev);
	421	if (!ret && data->supports_runtime_pm) {
	422	pm_runtime_disable(dev);
	423	pm_runtime_set_active(dev);
	424	pm_runtime_enable(dev);
	425	}
	426
	427	return ret;
2558c1f5 PC	428	}
	429	#endif /* CONFIG_PM_SLEEP */
	430
e14db48d PC	431	static int ci_hdrc_imx_runtime_suspend(struct device *dev)
	432	{
	433	struct ci_hdrc_imx_data *data = dev_get_drvdata(dev);
	434	int ret;
	435
	436	if (data->in_lpm) {
	437	WARN_ON(1);
	438	return 0;
	439	}
	440
	441	ret = imx_usbmisc_set_wakeup(data->usbmisc_data, true);
	442	if (ret) {
	443	dev_err(dev, "usbmisc set_wakeup failed, ret=%d\n", ret);
	444	return ret;
	445	}
	446
	447	return imx_controller_suspend(dev);
	448	}
	449
	450	static int ci_hdrc_imx_runtime_resume(struct device *dev)
	451	{
	452	return imx_controller_resume(dev);
	453	}
	454
	455	#endif /* CONFIG_PM */
	456
2558c1f5 PC	457	static const struct dev_pm_ops ci_hdrc_imx_pm_ops = {
2558c1f5 PC	458	SET_SYSTEM_SLEEP_PM_OPS(ci_hdrc_imx_suspend, ci_hdrc_imx_resume)
e14db48d PC	459	SET_RUNTIME_PM_OPS(ci_hdrc_imx_runtime_suspend,
e14db48d PC	460	ci_hdrc_imx_runtime_resume, NULL)
2558c1f5	461	};
8e22978c AS	462	static struct platform_driver ci_hdrc_imx_driver = {
	463	.probe = ci_hdrc_imx_probe,
	464	.remove = ci_hdrc_imx_remove,
15302800 RZ	465	.driver = {
15302800 RZ	466	.name = "imx_usb",
8e22978c	467	.of_match_table = ci_hdrc_imx_dt_ids,
2558c1f5	468	.pm = &ci_hdrc_imx_pm_ops,
15302800 RZ	469	},
	470	};
	471
8e22978c	472	module_platform_driver(ci_hdrc_imx_driver);
15302800 RZ	473
	474	MODULE_ALIAS("platform:imx-usb");
	475	MODULE_LICENSE("GPL v2");
8e22978c	476	MODULE_DESCRIPTION("CI HDRC i.MX USB binding");
15302800 RZ	477	MODULE_AUTHOR("Marek Vasut <marex@denx.de>");
15302800 RZ	478	MODULE_AUTHOR("Richard Zhao <richard.zhao@freescale.com>");