Loading...
1// SPDX-License-Identifier: GPL-2.0
2#include <linux/clk.h>
3#include <linux/device.h>
4#include <linux/export.h>
5#include <linux/gfp.h>
6
7struct devm_clk_state {
8 struct clk *clk;
9 void (*exit)(struct clk *clk);
10};
11
12static void devm_clk_release(struct device *dev, void *res)
13{
14 struct devm_clk_state *state = res;
15
16 if (state->exit)
17 state->exit(state->clk);
18
19 clk_put(state->clk);
20}
21
22static struct clk *__devm_clk_get(struct device *dev, const char *id,
23 struct clk *(*get)(struct device *dev, const char *id),
24 int (*init)(struct clk *clk),
25 void (*exit)(struct clk *clk))
26{
27 struct devm_clk_state *state;
28 struct clk *clk;
29 int ret;
30
31 state = devres_alloc(devm_clk_release, sizeof(*state), GFP_KERNEL);
32 if (!state)
33 return ERR_PTR(-ENOMEM);
34
35 clk = get(dev, id);
36 if (IS_ERR(clk)) {
37 ret = PTR_ERR(clk);
38 goto err_clk_get;
39 }
40
41 if (init) {
42 ret = init(clk);
43 if (ret)
44 goto err_clk_init;
45 }
46
47 state->clk = clk;
48 state->exit = exit;
49
50 devres_add(dev, state);
51
52 return clk;
53
54err_clk_init:
55
56 clk_put(clk);
57err_clk_get:
58
59 devres_free(state);
60 return ERR_PTR(ret);
61}
62
63struct clk *devm_clk_get(struct device *dev, const char *id)
64{
65 return __devm_clk_get(dev, id, clk_get, NULL, NULL);
66}
67EXPORT_SYMBOL(devm_clk_get);
68
69struct clk *devm_clk_get_prepared(struct device *dev, const char *id)
70{
71 return __devm_clk_get(dev, id, clk_get, clk_prepare, clk_unprepare);
72}
73EXPORT_SYMBOL_GPL(devm_clk_get_prepared);
74
75struct clk *devm_clk_get_enabled(struct device *dev, const char *id)
76{
77 return __devm_clk_get(dev, id, clk_get,
78 clk_prepare_enable, clk_disable_unprepare);
79}
80EXPORT_SYMBOL_GPL(devm_clk_get_enabled);
81
82struct clk *devm_clk_get_optional(struct device *dev, const char *id)
83{
84 return __devm_clk_get(dev, id, clk_get_optional, NULL, NULL);
85}
86EXPORT_SYMBOL(devm_clk_get_optional);
87
88struct clk *devm_clk_get_optional_prepared(struct device *dev, const char *id)
89{
90 return __devm_clk_get(dev, id, clk_get_optional,
91 clk_prepare, clk_unprepare);
92}
93EXPORT_SYMBOL_GPL(devm_clk_get_optional_prepared);
94
95struct clk *devm_clk_get_optional_enabled(struct device *dev, const char *id)
96{
97 return __devm_clk_get(dev, id, clk_get_optional,
98 clk_prepare_enable, clk_disable_unprepare);
99}
100EXPORT_SYMBOL_GPL(devm_clk_get_optional_enabled);
101
102struct clk *devm_clk_get_optional_enabled_with_rate(struct device *dev,
103 const char *id,
104 unsigned long rate)
105{
106 struct clk *clk;
107 int ret;
108
109 clk = __devm_clk_get(dev, id, clk_get_optional, NULL,
110 clk_disable_unprepare);
111 if (IS_ERR(clk))
112 return ERR_CAST(clk);
113
114 ret = clk_set_rate(clk, rate);
115 if (ret)
116 goto out_put_clk;
117
118 ret = clk_prepare_enable(clk);
119 if (ret)
120 goto out_put_clk;
121
122 return clk;
123
124out_put_clk:
125 devm_clk_put(dev, clk);
126 return ERR_PTR(ret);
127}
128EXPORT_SYMBOL_GPL(devm_clk_get_optional_enabled_with_rate);
129
130struct clk_bulk_devres {
131 struct clk_bulk_data *clks;
132 int num_clks;
133};
134
135static void devm_clk_bulk_release(struct device *dev, void *res)
136{
137 struct clk_bulk_devres *devres = res;
138
139 clk_bulk_put(devres->num_clks, devres->clks);
140}
141
142static int __devm_clk_bulk_get(struct device *dev, int num_clks,
143 struct clk_bulk_data *clks, bool optional)
144{
145 struct clk_bulk_devres *devres;
146 int ret;
147
148 devres = devres_alloc(devm_clk_bulk_release,
149 sizeof(*devres), GFP_KERNEL);
150 if (!devres)
151 return -ENOMEM;
152
153 if (optional)
154 ret = clk_bulk_get_optional(dev, num_clks, clks);
155 else
156 ret = clk_bulk_get(dev, num_clks, clks);
157 if (!ret) {
158 devres->clks = clks;
159 devres->num_clks = num_clks;
160 devres_add(dev, devres);
161 } else {
162 devres_free(devres);
163 }
164
165 return ret;
166}
167
168int __must_check devm_clk_bulk_get(struct device *dev, int num_clks,
169 struct clk_bulk_data *clks)
170{
171 return __devm_clk_bulk_get(dev, num_clks, clks, false);
172}
173EXPORT_SYMBOL_GPL(devm_clk_bulk_get);
174
175int __must_check devm_clk_bulk_get_optional(struct device *dev, int num_clks,
176 struct clk_bulk_data *clks)
177{
178 return __devm_clk_bulk_get(dev, num_clks, clks, true);
179}
180EXPORT_SYMBOL_GPL(devm_clk_bulk_get_optional);
181
182static void devm_clk_bulk_release_all(struct device *dev, void *res)
183{
184 struct clk_bulk_devres *devres = res;
185
186 clk_bulk_put_all(devres->num_clks, devres->clks);
187}
188
189int __must_check devm_clk_bulk_get_all(struct device *dev,
190 struct clk_bulk_data **clks)
191{
192 struct clk_bulk_devres *devres;
193 int ret;
194
195 devres = devres_alloc(devm_clk_bulk_release_all,
196 sizeof(*devres), GFP_KERNEL);
197 if (!devres)
198 return -ENOMEM;
199
200 ret = clk_bulk_get_all(dev, &devres->clks);
201 if (ret > 0) {
202 *clks = devres->clks;
203 devres->num_clks = ret;
204 devres_add(dev, devres);
205 } else {
206 devres_free(devres);
207 }
208
209 return ret;
210}
211EXPORT_SYMBOL_GPL(devm_clk_bulk_get_all);
212
213static void devm_clk_bulk_release_all_enable(struct device *dev, void *res)
214{
215 struct clk_bulk_devres *devres = res;
216
217 clk_bulk_disable_unprepare(devres->num_clks, devres->clks);
218 clk_bulk_put_all(devres->num_clks, devres->clks);
219}
220
221int __must_check devm_clk_bulk_get_all_enabled(struct device *dev,
222 struct clk_bulk_data **clks)
223{
224 struct clk_bulk_devres *devres;
225 int ret;
226
227 devres = devres_alloc(devm_clk_bulk_release_all_enable,
228 sizeof(*devres), GFP_KERNEL);
229 if (!devres)
230 return -ENOMEM;
231
232 ret = clk_bulk_get_all(dev, &devres->clks);
233 if (ret > 0) {
234 *clks = devres->clks;
235 devres->num_clks = ret;
236 } else {
237 devres_free(devres);
238 return ret;
239 }
240
241 ret = clk_bulk_prepare_enable(devres->num_clks, *clks);
242 if (!ret) {
243 devres_add(dev, devres);
244 } else {
245 clk_bulk_put_all(devres->num_clks, devres->clks);
246 devres_free(devres);
247 return ret;
248 }
249
250 return devres->num_clks;
251}
252EXPORT_SYMBOL_GPL(devm_clk_bulk_get_all_enabled);
253
254static int devm_clk_match(struct device *dev, void *res, void *data)
255{
256 struct clk **c = res;
257 if (!c || !*c) {
258 WARN_ON(!c || !*c);
259 return 0;
260 }
261 return *c == data;
262}
263
264void devm_clk_put(struct device *dev, struct clk *clk)
265{
266 int ret;
267
268 ret = devres_release(dev, devm_clk_release, devm_clk_match, clk);
269
270 WARN_ON(ret);
271}
272EXPORT_SYMBOL(devm_clk_put);
273
274struct clk *devm_get_clk_from_child(struct device *dev,
275 struct device_node *np, const char *con_id)
276{
277 struct devm_clk_state *state;
278 struct clk *clk;
279
280 state = devres_alloc(devm_clk_release, sizeof(*state), GFP_KERNEL);
281 if (!state)
282 return ERR_PTR(-ENOMEM);
283
284 clk = of_clk_get_by_name(np, con_id);
285 if (!IS_ERR(clk)) {
286 state->clk = clk;
287 devres_add(dev, state);
288 } else {
289 devres_free(state);
290 }
291
292 return clk;
293}
294EXPORT_SYMBOL(devm_get_clk_from_child);
1// SPDX-License-Identifier: GPL-2.0
2#include <linux/clk.h>
3#include <linux/device.h>
4#include <linux/export.h>
5#include <linux/gfp.h>
6
7struct devm_clk_state {
8 struct clk *clk;
9 void (*exit)(struct clk *clk);
10};
11
12static void devm_clk_release(struct device *dev, void *res)
13{
14 struct devm_clk_state *state = res;
15
16 if (state->exit)
17 state->exit(state->clk);
18
19 clk_put(state->clk);
20}
21
22static struct clk *__devm_clk_get(struct device *dev, const char *id,
23 struct clk *(*get)(struct device *dev, const char *id),
24 int (*init)(struct clk *clk),
25 void (*exit)(struct clk *clk))
26{
27 struct devm_clk_state *state;
28 struct clk *clk;
29 int ret;
30
31 state = devres_alloc(devm_clk_release, sizeof(*state), GFP_KERNEL);
32 if (!state)
33 return ERR_PTR(-ENOMEM);
34
35 clk = get(dev, id);
36 if (IS_ERR(clk)) {
37 ret = PTR_ERR(clk);
38 goto err_clk_get;
39 }
40
41 if (init) {
42 ret = init(clk);
43 if (ret)
44 goto err_clk_init;
45 }
46
47 state->clk = clk;
48 state->exit = exit;
49
50 devres_add(dev, state);
51
52 return clk;
53
54err_clk_init:
55
56 clk_put(clk);
57err_clk_get:
58
59 devres_free(state);
60 return ERR_PTR(ret);
61}
62
63struct clk *devm_clk_get(struct device *dev, const char *id)
64{
65 return __devm_clk_get(dev, id, clk_get, NULL, NULL);
66}
67EXPORT_SYMBOL(devm_clk_get);
68
69struct clk *devm_clk_get_prepared(struct device *dev, const char *id)
70{
71 return __devm_clk_get(dev, id, clk_get, clk_prepare, clk_unprepare);
72}
73EXPORT_SYMBOL_GPL(devm_clk_get_prepared);
74
75struct clk *devm_clk_get_enabled(struct device *dev, const char *id)
76{
77 return __devm_clk_get(dev, id, clk_get,
78 clk_prepare_enable, clk_disable_unprepare);
79}
80EXPORT_SYMBOL_GPL(devm_clk_get_enabled);
81
82struct clk *devm_clk_get_optional(struct device *dev, const char *id)
83{
84 return __devm_clk_get(dev, id, clk_get_optional, NULL, NULL);
85}
86EXPORT_SYMBOL(devm_clk_get_optional);
87
88struct clk *devm_clk_get_optional_prepared(struct device *dev, const char *id)
89{
90 return __devm_clk_get(dev, id, clk_get_optional,
91 clk_prepare, clk_unprepare);
92}
93EXPORT_SYMBOL_GPL(devm_clk_get_optional_prepared);
94
95struct clk *devm_clk_get_optional_enabled(struct device *dev, const char *id)
96{
97 return __devm_clk_get(dev, id, clk_get_optional,
98 clk_prepare_enable, clk_disable_unprepare);
99}
100EXPORT_SYMBOL_GPL(devm_clk_get_optional_enabled);
101
102struct clk_bulk_devres {
103 struct clk_bulk_data *clks;
104 int num_clks;
105};
106
107static void devm_clk_bulk_release(struct device *dev, void *res)
108{
109 struct clk_bulk_devres *devres = res;
110
111 clk_bulk_put(devres->num_clks, devres->clks);
112}
113
114static int __devm_clk_bulk_get(struct device *dev, int num_clks,
115 struct clk_bulk_data *clks, bool optional)
116{
117 struct clk_bulk_devres *devres;
118 int ret;
119
120 devres = devres_alloc(devm_clk_bulk_release,
121 sizeof(*devres), GFP_KERNEL);
122 if (!devres)
123 return -ENOMEM;
124
125 if (optional)
126 ret = clk_bulk_get_optional(dev, num_clks, clks);
127 else
128 ret = clk_bulk_get(dev, num_clks, clks);
129 if (!ret) {
130 devres->clks = clks;
131 devres->num_clks = num_clks;
132 devres_add(dev, devres);
133 } else {
134 devres_free(devres);
135 }
136
137 return ret;
138}
139
140int __must_check devm_clk_bulk_get(struct device *dev, int num_clks,
141 struct clk_bulk_data *clks)
142{
143 return __devm_clk_bulk_get(dev, num_clks, clks, false);
144}
145EXPORT_SYMBOL_GPL(devm_clk_bulk_get);
146
147int __must_check devm_clk_bulk_get_optional(struct device *dev, int num_clks,
148 struct clk_bulk_data *clks)
149{
150 return __devm_clk_bulk_get(dev, num_clks, clks, true);
151}
152EXPORT_SYMBOL_GPL(devm_clk_bulk_get_optional);
153
154static void devm_clk_bulk_release_all(struct device *dev, void *res)
155{
156 struct clk_bulk_devres *devres = res;
157
158 clk_bulk_put_all(devres->num_clks, devres->clks);
159}
160
161int __must_check devm_clk_bulk_get_all(struct device *dev,
162 struct clk_bulk_data **clks)
163{
164 struct clk_bulk_devres *devres;
165 int ret;
166
167 devres = devres_alloc(devm_clk_bulk_release_all,
168 sizeof(*devres), GFP_KERNEL);
169 if (!devres)
170 return -ENOMEM;
171
172 ret = clk_bulk_get_all(dev, &devres->clks);
173 if (ret > 0) {
174 *clks = devres->clks;
175 devres->num_clks = ret;
176 devres_add(dev, devres);
177 } else {
178 devres_free(devres);
179 }
180
181 return ret;
182}
183EXPORT_SYMBOL_GPL(devm_clk_bulk_get_all);
184
185static void devm_clk_bulk_release_all_enable(struct device *dev, void *res)
186{
187 struct clk_bulk_devres *devres = res;
188
189 clk_bulk_disable_unprepare(devres->num_clks, devres->clks);
190 clk_bulk_put_all(devres->num_clks, devres->clks);
191}
192
193int __must_check devm_clk_bulk_get_all_enable(struct device *dev,
194 struct clk_bulk_data **clks)
195{
196 struct clk_bulk_devres *devres;
197 int ret;
198
199 devres = devres_alloc(devm_clk_bulk_release_all_enable,
200 sizeof(*devres), GFP_KERNEL);
201 if (!devres)
202 return -ENOMEM;
203
204 ret = clk_bulk_get_all(dev, &devres->clks);
205 if (ret > 0) {
206 *clks = devres->clks;
207 devres->num_clks = ret;
208 } else {
209 devres_free(devres);
210 return ret;
211 }
212
213 ret = clk_bulk_prepare_enable(devres->num_clks, *clks);
214 if (!ret) {
215 devres_add(dev, devres);
216 } else {
217 clk_bulk_put_all(devres->num_clks, devres->clks);
218 devres_free(devres);
219 }
220
221 return ret;
222}
223EXPORT_SYMBOL_GPL(devm_clk_bulk_get_all_enable);
224
225static int devm_clk_match(struct device *dev, void *res, void *data)
226{
227 struct clk **c = res;
228 if (!c || !*c) {
229 WARN_ON(!c || !*c);
230 return 0;
231 }
232 return *c == data;
233}
234
235void devm_clk_put(struct device *dev, struct clk *clk)
236{
237 int ret;
238
239 ret = devres_release(dev, devm_clk_release, devm_clk_match, clk);
240
241 WARN_ON(ret);
242}
243EXPORT_SYMBOL(devm_clk_put);
244
245struct clk *devm_get_clk_from_child(struct device *dev,
246 struct device_node *np, const char *con_id)
247{
248 struct devm_clk_state *state;
249 struct clk *clk;
250
251 state = devres_alloc(devm_clk_release, sizeof(*state), GFP_KERNEL);
252 if (!state)
253 return ERR_PTR(-ENOMEM);
254
255 clk = of_clk_get_by_name(np, con_id);
256 if (!IS_ERR(clk)) {
257 state->clk = clk;
258 devres_add(dev, state);
259 } else {
260 devres_free(state);
261 }
262
263 return clk;
264}
265EXPORT_SYMBOL(devm_get_clk_from_child);