[linux-2.6-block.git] / drivers / usb / dwc3 / dwc3-of-simple.c

// SPDX-License-Identifier: GPL-2.0
/**
 * dwc3-of-simple.c - OF glue layer for simple integrations
 *
 * Copyright (c) 2015 Texas Instruments Incorporated - http://www.ti.com
 *
 * Author: Felipe Balbi <balbi@ti.com>
 *
 * This is a combination of the old dwc3-qcom.c by Ivan T. Ivanov
 * <iivanov@mm-sol.com> and the original patch adding support for Xilinx' SoC
 * by Subbaraya Sundeep Bhatta <subbaraya.sundeep.bhatta@xilinx.com>
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/platform_device.h>
#include <linux/dma-mapping.h>
#include <linux/clk.h>
#include <linux/of.h>
#include <linux/of_platform.h>
#include <linux/pm_runtime.h>
#include <linux/reset.h>

struct dwc3_of_simple {
	struct device		*dev;
	struct clk		**clks;
	int			num_clocks;
	struct reset_control	*resets;
};

static int dwc3_of_simple_clk_init(struct dwc3_of_simple *simple, int count)
{
	struct device		*dev = simple->dev;
	struct device_node	*np = dev->of_node;
	int			i;

	simple->num_clocks = count;

	if (!count)
		return 0;

	simple->clks = devm_kcalloc(dev, simple->num_clocks,
			sizeof(struct clk *), GFP_KERNEL);
	if (!simple->clks)
		return -ENOMEM;

	for (i = 0; i < simple->num_clocks; i++) {
		struct clk	*clk;
		int		ret;

		clk = of_clk_get(np, i);
		if (IS_ERR(clk)) {
			while (--i >= 0) {
				clk_disable_unprepare(simple->clks[i]);
				clk_put(simple->clks[i]);
			}
			return PTR_ERR(clk);
		}

		ret = clk_prepare_enable(clk);
		if (ret < 0) {
			while (--i >= 0) {
				clk_disable_unprepare(simple->clks[i]);
				clk_put(simple->clks[i]);
			}
			clk_put(clk);

			return ret;
		}

		simple->clks[i] = clk;
	}

	return 0;
}

static int dwc3_of_simple_probe(struct platform_device *pdev)
{
	struct dwc3_of_simple	*simple;
	struct device		*dev = &pdev->dev;
	struct device_node	*np = dev->of_node;

	int			ret;
	int			i;

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

	platform_set_drvdata(pdev, simple);
	simple->dev = dev;

	simple->resets = of_reset_control_array_get_optional_exclusive(np);
	if (IS_ERR(simple->resets)) {
		ret = PTR_ERR(simple->resets);
		dev_err(dev, "failed to get device resets, err=%d\n", ret);
		return ret;
	}

	ret = reset_control_deassert(simple->resets);
	if (ret)
		goto err_resetc_put;

	ret = dwc3_of_simple_clk_init(simple, of_count_phandle_with_args(np,
						"clocks", "#clock-cells"));
	if (ret)
		goto err_resetc_assert;

	ret = of_platform_populate(np, NULL, NULL, dev);
	if (ret) {
		for (i = 0; i < simple->num_clocks; i++) {
			clk_disable_unprepare(simple->clks[i]);
			clk_put(simple->clks[i]);
		}

		goto err_resetc_assert;
	}

	pm_runtime_set_active(dev);
	pm_runtime_enable(dev);
	pm_runtime_get_sync(dev);

	return 0;

err_resetc_assert:
	reset_control_assert(simple->resets);

err_resetc_put:
	reset_control_put(simple->resets);
	return ret;
}

static int dwc3_of_simple_remove(struct platform_device *pdev)
{
	struct dwc3_of_simple	*simple = platform_get_drvdata(pdev);
	struct device		*dev = &pdev->dev;
	int			i;

	of_platform_depopulate(dev);

	for (i = 0; i < simple->num_clocks; i++) {
		clk_disable_unprepare(simple->clks[i]);
		clk_put(simple->clks[i]);
	}

	reset_control_assert(simple->resets);
	reset_control_put(simple->resets);

	pm_runtime_put_sync(dev);
	pm_runtime_disable(dev);

	return 0;
}

#ifdef CONFIG_PM
static int dwc3_of_simple_runtime_suspend(struct device *dev)
{
	struct dwc3_of_simple	*simple = dev_get_drvdata(dev);
	int			i;

	for (i = 0; i < simple->num_clocks; i++)
		clk_disable(simple->clks[i]);

	return 0;
}

static int dwc3_of_simple_runtime_resume(struct device *dev)
{
	struct dwc3_of_simple	*simple = dev_get_drvdata(dev);
	int			ret;
	int			i;

	for (i = 0; i < simple->num_clocks; i++) {
		ret = clk_enable(simple->clks[i]);
		if (ret < 0) {
			while (--i >= 0)
				clk_disable(simple->clks[i]);
			return ret;
		}
	}

	return 0;
}
#endif

static const struct dev_pm_ops dwc3_of_simple_dev_pm_ops = {
	SET_RUNTIME_PM_OPS(dwc3_of_simple_runtime_suspend,
			dwc3_of_simple_runtime_resume, NULL)
};

static const struct of_device_id of_dwc3_simple_match[] = {
	{ .compatible = "qcom,dwc3" },
	{ .compatible = "rockchip,rk3399-dwc3" },
	{ .compatible = "xlnx,zynqmp-dwc3" },
	{ .compatible = "cavium,octeon-7130-usb-uctl" },
	{ .compatible = "sprd,sc9860-dwc3" },
	{ /* Sentinel */ }
};
MODULE_DEVICE_TABLE(of, of_dwc3_simple_match);

static struct platform_driver dwc3_of_simple_driver = {
	.probe		= dwc3_of_simple_probe,
	.remove		= dwc3_of_simple_remove,
	.driver		= {
		.name	= "dwc3-of-simple",
		.of_match_table = of_dwc3_simple_match,
		.pm	= &dwc3_of_simple_dev_pm_ops,
	},
};

module_platform_driver(dwc3_of_simple_driver);
MODULE_LICENSE("GPL v2");
MODULE_DESCRIPTION("DesignWare USB3 OF Simple Glue Layer");
MODULE_AUTHOR("Felipe Balbi <balbi@ti.com>");
Commit	Line	Data
5fd54ace	1	// SPDX-License-Identifier: GPL-2.0
16adc674 FB	2	/**
	3	* dwc3-of-simple.c - OF glue layer for simple integrations
	4	*
	5	* Copyright (c) 2015 Texas Instruments Incorporated - http://www.ti.com
	6	*
	7	* Author: Felipe Balbi <balbi@ti.com>
	8	*
16adc674 FB	9	* This is a combination of the old dwc3-qcom.c by Ivan T. Ivanov
	10	* <iivanov@mm-sol.com> and the original patch adding support for Xilinx' SoC
	11	* by Subbaraya Sundeep Bhatta <subbaraya.sundeep.bhatta@xilinx.com>
	12	*/
	13
	14	#include <linux/module.h>
	15	#include <linux/kernel.h>
	16	#include <linux/slab.h>
	17	#include <linux/platform_device.h>
	18	#include <linux/dma-mapping.h>
	19	#include <linux/clk.h>
16adc674 FB	20	#include <linux/of.h>
	21	#include <linux/of_platform.h>
	22	#include <linux/pm_runtime.h>
06c47e62	23	#include <linux/reset.h>
16adc674 FB	24
	25	struct dwc3_of_simple {
	26	struct device *dev;
	27	struct clk **clks;
	28	int num_clocks;
06c47e62	29	struct reset_control *resets;
16adc674 FB	30	};
16adc674 FB	31
26c9cac4	32	static int dwc3_of_simple_clk_init(struct dwc3_of_simple *simple, int count)
16adc674	33	{
26c9cac4	34	struct device *dev = simple->dev;
16adc674	35	struct device_node *np = dev->of_node;
16adc674 FB	36	int i;
16adc674 FB	37
26c9cac4	38	simple->num_clocks = count;
16adc674	39
3d755dcc	40	if (!count)
26c9cac4	41	return 0;
16adc674 FB	42
	43	simple->clks = devm_kcalloc(dev, simple->num_clocks,
	44	sizeof(struct clk *), GFP_KERNEL);
	45	if (!simple->clks)
	46	return -ENOMEM;
	47
16adc674 FB	48	for (i = 0; i < simple->num_clocks; i++) {
16adc674 FB	49	struct clk *clk;
26c9cac4	50	int ret;
16adc674 FB	51
	52	clk = of_clk_get(np, i);
	53	if (IS_ERR(clk)) {
ded600ea AP	54	while (--i >= 0) {
ded600ea AP	55	clk_disable_unprepare(simple->clks[i]);
16adc674	56	clk_put(simple->clks[i]);
ded600ea	57	}
16adc674 FB	58	return PTR_ERR(clk);
	59	}
	60
	61	ret = clk_prepare_enable(clk);
	62	if (ret < 0) {
	63	while (--i >= 0) {
	64	clk_disable_unprepare(simple->clks[i]);
	65	clk_put(simple->clks[i]);
	66	}
	67	clk_put(clk);
	68
	69	return ret;
	70	}
	71
	72	simple->clks[i] = clk;
	73	}
	74
26c9cac4 FB	75	return 0;
	76	}
	77
	78	static int dwc3_of_simple_probe(struct platform_device *pdev)
	79	{
	80	struct dwc3_of_simple *simple;
	81	struct device *dev = &pdev->dev;
	82	struct device_node *np = dev->of_node;
	83
	84	int ret;
	85	int i;
	86
	87	simple = devm_kzalloc(dev, sizeof(*simple), GFP_KERNEL);
	88	if (!simple)
	89	return -ENOMEM;
	90
	91	platform_set_drvdata(pdev, simple);
	92	simple->dev = dev;
	93
06c47e62 VG	94	simple->resets = of_reset_control_array_get_optional_exclusive(np);
	95	if (IS_ERR(simple->resets)) {
	96	ret = PTR_ERR(simple->resets);
	97	dev_err(dev, "failed to get device resets, err=%d\n", ret);
	98	return ret;
	99	}
	100
	101	ret = reset_control_deassert(simple->resets);
	102	if (ret)
	103	goto err_resetc_put;
	104
e7059ef8 SG	105	ret = dwc3_of_simple_clk_init(simple, of_count_phandle_with_args(np,
e7059ef8 SG	106	"clocks", "#clock-cells"));
26c9cac4	107	if (ret)
06c47e62	108	goto err_resetc_assert;
26c9cac4	109
16adc674 FB	110	ret = of_platform_populate(np, NULL, NULL, dev);
	111	if (ret) {
	112	for (i = 0; i < simple->num_clocks; i++) {
	113	clk_disable_unprepare(simple->clks[i]);
	114	clk_put(simple->clks[i]);
	115	}
	116
06c47e62	117	goto err_resetc_assert;
16adc674 FB	118	}
	119
	120	pm_runtime_set_active(dev);
	121	pm_runtime_enable(dev);
	122	pm_runtime_get_sync(dev);
	123
	124	return 0;
06c47e62 VG	125
	126	err_resetc_assert:
	127	reset_control_assert(simple->resets);
	128
	129	err_resetc_put:
	130	reset_control_put(simple->resets);
	131	return ret;
16adc674 FB	132	}
	133
	134	static int dwc3_of_simple_remove(struct platform_device *pdev)
	135	{
	136	struct dwc3_of_simple *simple = platform_get_drvdata(pdev);
	137	struct device *dev = &pdev->dev;
	138	int i;
	139
d6d9c2a3 VG	140	of_platform_depopulate(dev);
d6d9c2a3 VG	141
16adc674	142	for (i = 0; i < simple->num_clocks; i++) {
8d53e626	143	clk_disable_unprepare(simple->clks[i]);
16adc674 FB	144	clk_put(simple->clks[i]);
	145	}
	146
06c47e62 VG	147	reset_control_assert(simple->resets);
	148	reset_control_put(simple->resets);
	149
16adc674 FB	150	pm_runtime_put_sync(dev);
	151	pm_runtime_disable(dev);
	152
	153	return 0;
	154	}
	155
5072cfc4	156	#ifdef CONFIG_PM
16adc674 FB	157	static int dwc3_of_simple_runtime_suspend(struct device *dev)
	158	{
	159	struct dwc3_of_simple *simple = dev_get_drvdata(dev);
	160	int i;
	161
	162	for (i = 0; i < simple->num_clocks; i++)
	163	clk_disable(simple->clks[i]);
	164
	165	return 0;
	166	}
	167
	168	static int dwc3_of_simple_runtime_resume(struct device *dev)
	169	{
	170	struct dwc3_of_simple *simple = dev_get_drvdata(dev);
	171	int ret;
	172	int i;
	173
	174	for (i = 0; i < simple->num_clocks; i++) {
	175	ret = clk_enable(simple->clks[i]);
	176	if (ret < 0) {
	177	while (--i >= 0)
	178	clk_disable(simple->clks[i]);
	179	return ret;
	180	}
	181	}
	182
	183	return 0;
	184	}
5072cfc4	185	#endif
16adc674 FB	186
	187	static const struct dev_pm_ops dwc3_of_simple_dev_pm_ops = {
	188	SET_RUNTIME_PM_OPS(dwc3_of_simple_runtime_suspend,
	189	dwc3_of_simple_runtime_resume, NULL)
	190	};
	191
	192	static const struct of_device_id of_dwc3_simple_match[] = {
	193	{ .compatible = "qcom,dwc3" },
f652191b	194	{ .compatible = "rockchip,rk3399-dwc3" },
16adc674	195	{ .compatible = "xlnx,zynqmp-dwc3" },
b281dc63	196	{ .compatible = "cavium,octeon-7130-usb-uctl" },
c3cdce45	197	{ .compatible = "sprd,sc9860-dwc3" },
16adc674 FB	198	{ /* Sentinel */ }
	199	};
	200	MODULE_DEVICE_TABLE(of, of_dwc3_simple_match);
	201
	202	static struct platform_driver dwc3_of_simple_driver = {
	203	.probe = dwc3_of_simple_probe,
	204	.remove = dwc3_of_simple_remove,
	205	.driver = {
	206	.name = "dwc3-of-simple",
	207	.of_match_table = of_dwc3_simple_match,
a0d8c4cf	208	.pm = &dwc3_of_simple_dev_pm_ops,
16adc674 FB	209	},
	210	};
	211
	212	module_platform_driver(dwc3_of_simple_driver);
	213	MODULE_LICENSE("GPL v2");
	214	MODULE_DESCRIPTION("DesignWare USB3 OF Simple Glue Layer");
	215	MODULE_AUTHOR("Felipe Balbi <balbi@ti.com>");