1 /**
2  * dwc3-of-simple.c - OF glue layer for simple integrations
3  *
4  * Copyright (c) 2015 Texas Instruments Incorporated - http://www.ti.com
5  *
6  * Author: Felipe Balbi <balbi@ti.com>
7  *
8  * This program is free software: you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License version 2  of
10  * the License as published by the Free Software Foundation.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * This is a combination of the old dwc3-qcom.c by Ivan T. Ivanov
18  * <iivanov@mm-sol.com> and the original patch adding support for Xilinx' SoC
19  * by Subbaraya Sundeep Bhatta <subbaraya.sundeep.bhatta@xilinx.com>
20  */
21 
22 #include <linux/module.h>
23 #include <linux/kernel.h>
24 #include <linux/slab.h>
25 #include <linux/platform_device.h>
26 #include <linux/dma-mapping.h>
27 #include <linux/clk.h>
28 #include <linux/clk-provider.h>
29 #include <linux/of.h>
30 #include <linux/of_platform.h>
31 #include <linux/pm_runtime.h>
32 
33 struct dwc3_of_simple {
34 	struct device		*dev;
35 	struct clk		**clks;
36 	int			num_clocks;
37 };
38 
39 static int dwc3_of_simple_probe(struct platform_device *pdev)
40 {
41 	struct dwc3_of_simple	*simple;
42 	struct device		*dev = &pdev->dev;
43 	struct device_node	*np = dev->of_node;
44 
45 	unsigned int		count;
46 	int			ret;
47 	int			i;
48 
49 	simple = devm_kzalloc(dev, sizeof(*simple), GFP_KERNEL);
50 	if (!simple)
51 		return -ENOMEM;
52 
53 	count = of_clk_get_parent_count(np);
54 	if (!count)
55 		return -ENOENT;
56 
57 	simple->num_clocks = count;
58 
59 	simple->clks = devm_kcalloc(dev, simple->num_clocks,
60 			sizeof(struct clk *), GFP_KERNEL);
61 	if (!simple->clks)
62 		return -ENOMEM;
63 
64 	platform_set_drvdata(pdev, simple);
65 	simple->dev = dev;
66 
67 	for (i = 0; i < simple->num_clocks; i++) {
68 		struct clk	*clk;
69 
70 		clk = of_clk_get(np, i);
71 		if (IS_ERR(clk)) {
72 			while (--i >= 0)
73 				clk_put(simple->clks[i]);
74 			return PTR_ERR(clk);
75 		}
76 
77 		ret = clk_prepare_enable(clk);
78 		if (ret < 0) {
79 			while (--i >= 0) {
80 				clk_disable_unprepare(simple->clks[i]);
81 				clk_put(simple->clks[i]);
82 			}
83 			clk_put(clk);
84 
85 			return ret;
86 		}
87 
88 		simple->clks[i] = clk;
89 	}
90 
91 	ret = of_platform_populate(np, NULL, NULL, dev);
92 	if (ret) {
93 		for (i = 0; i < simple->num_clocks; i++) {
94 			clk_disable_unprepare(simple->clks[i]);
95 			clk_put(simple->clks[i]);
96 		}
97 
98 		return ret;
99 	}
100 
101 	pm_runtime_set_active(dev);
102 	pm_runtime_enable(dev);
103 	pm_runtime_get_sync(dev);
104 
105 	return 0;
106 }
107 
108 static int dwc3_of_simple_remove(struct platform_device *pdev)
109 {
110 	struct dwc3_of_simple	*simple = platform_get_drvdata(pdev);
111 	struct device		*dev = &pdev->dev;
112 	int			i;
113 
114 	for (i = 0; i < simple->num_clocks; i++) {
115 		clk_unprepare(simple->clks[i]);
116 		clk_put(simple->clks[i]);
117 	}
118 
119 	of_platform_depopulate(dev);
120 
121 	pm_runtime_put_sync(dev);
122 	pm_runtime_disable(dev);
123 
124 	return 0;
125 }
126 
127 #ifdef CONFIG_PM
128 static int dwc3_of_simple_runtime_suspend(struct device *dev)
129 {
130 	struct dwc3_of_simple	*simple = dev_get_drvdata(dev);
131 	int			i;
132 
133 	for (i = 0; i < simple->num_clocks; i++)
134 		clk_disable(simple->clks[i]);
135 
136 	return 0;
137 }
138 
139 static int dwc3_of_simple_runtime_resume(struct device *dev)
140 {
141 	struct dwc3_of_simple	*simple = dev_get_drvdata(dev);
142 	int			ret;
143 	int			i;
144 
145 	for (i = 0; i < simple->num_clocks; i++) {
146 		ret = clk_enable(simple->clks[i]);
147 		if (ret < 0) {
148 			while (--i >= 0)
149 				clk_disable(simple->clks[i]);
150 			return ret;
151 		}
152 	}
153 
154 	return 0;
155 }
156 #endif
157 
158 static const struct dev_pm_ops dwc3_of_simple_dev_pm_ops = {
159 	SET_RUNTIME_PM_OPS(dwc3_of_simple_runtime_suspend,
160 			dwc3_of_simple_runtime_resume, NULL)
161 };
162 
163 static const struct of_device_id of_dwc3_simple_match[] = {
164 	{ .compatible = "qcom,dwc3" },
165 	{ .compatible = "xlnx,zynqmp-dwc3" },
166 	{ /* Sentinel */ }
167 };
168 MODULE_DEVICE_TABLE(of, of_dwc3_simple_match);
169 
170 static struct platform_driver dwc3_of_simple_driver = {
171 	.probe		= dwc3_of_simple_probe,
172 	.remove		= dwc3_of_simple_remove,
173 	.driver		= {
174 		.name	= "dwc3-of-simple",
175 		.of_match_table = of_dwc3_simple_match,
176 	},
177 };
178 
179 module_platform_driver(dwc3_of_simple_driver);
180 MODULE_LICENSE("GPL v2");
181 MODULE_DESCRIPTION("DesignWare USB3 OF Simple Glue Layer");
182 MODULE_AUTHOR("Felipe Balbi <balbi@ti.com>");
183