[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 imx23_usb_data = {
	.flags = CI_HDRC_TURN_VBUS_EARLY_ON |
		CI_HDRC_DISABLE_STREAMING,
};

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,imx23-usb", .data = &imx23_usb_data},
	{ .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,
	};
	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);
		if (ret != -EPROBE_DEFER)
			dev_err(&pdev->dev,
				"ci_hdrc_add_device failed, 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;
}

static void ci_hdrc_imx_shutdown(struct platform_device *pdev)
{
	ci_hdrc_imx_remove(pdev);
}

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