]>
Commit | Line | Data |
---|---|---|
2874c5fd | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
0cdfcc0f MB |
2 | /* |
3 | * devres.c -- Voltage/Current Regulator framework devres implementation. | |
4 | * | |
5 | * Copyright 2013 Linaro Ltd | |
0cdfcc0f MB |
6 | */ |
7 | ||
8 | #include <linux/kernel.h> | |
9 | #include <linux/err.h> | |
10 | #include <linux/regmap.h> | |
11 | #include <linux/regulator/consumer.h> | |
12 | #include <linux/regulator/driver.h> | |
13 | #include <linux/module.h> | |
14 | ||
15 | #include "internal.h" | |
16 | ||
0cdfcc0f MB |
17 | static void devm_regulator_release(struct device *dev, void *res) |
18 | { | |
19 | regulator_put(*(struct regulator **)res); | |
20 | } | |
21 | ||
22 | static struct regulator *_devm_regulator_get(struct device *dev, const char *id, | |
23 | int get_type) | |
24 | { | |
25 | struct regulator **ptr, *regulator; | |
26 | ||
27 | ptr = devres_alloc(devm_regulator_release, sizeof(*ptr), GFP_KERNEL); | |
28 | if (!ptr) | |
29 | return ERR_PTR(-ENOMEM); | |
30 | ||
a8bd42a9 | 31 | regulator = _regulator_get(dev, id, get_type); |
0cdfcc0f MB |
32 | if (!IS_ERR(regulator)) { |
33 | *ptr = regulator; | |
34 | devres_add(dev, ptr); | |
35 | } else { | |
36 | devres_free(ptr); | |
37 | } | |
38 | ||
39 | return regulator; | |
40 | } | |
41 | ||
42 | /** | |
43 | * devm_regulator_get - Resource managed regulator_get() | |
44 | * @dev: device for regulator "consumer" | |
45 | * @id: Supply name or regulator ID. | |
46 | * | |
47 | * Managed regulator_get(). Regulators returned from this function are | |
48 | * automatically regulator_put() on driver detach. See regulator_get() for more | |
49 | * information. | |
50 | */ | |
51 | struct regulator *devm_regulator_get(struct device *dev, const char *id) | |
52 | { | |
53 | return _devm_regulator_get(dev, id, NORMAL_GET); | |
54 | } | |
55 | EXPORT_SYMBOL_GPL(devm_regulator_get); | |
56 | ||
57 | /** | |
58 | * devm_regulator_get_exclusive - Resource managed regulator_get_exclusive() | |
59 | * @dev: device for regulator "consumer" | |
60 | * @id: Supply name or regulator ID. | |
61 | * | |
62 | * Managed regulator_get_exclusive(). Regulators returned from this function | |
63 | * are automatically regulator_put() on driver detach. See regulator_get() for | |
64 | * more information. | |
65 | */ | |
66 | struct regulator *devm_regulator_get_exclusive(struct device *dev, | |
67 | const char *id) | |
68 | { | |
69 | return _devm_regulator_get(dev, id, EXCLUSIVE_GET); | |
70 | } | |
71 | EXPORT_SYMBOL_GPL(devm_regulator_get_exclusive); | |
72 | ||
73 | /** | |
74 | * devm_regulator_get_optional - Resource managed regulator_get_optional() | |
75 | * @dev: device for regulator "consumer" | |
76 | * @id: Supply name or regulator ID. | |
77 | * | |
78 | * Managed regulator_get_optional(). Regulators returned from this | |
79 | * function are automatically regulator_put() on driver detach. See | |
80 | * regulator_get_optional() for more information. | |
81 | */ | |
82 | struct regulator *devm_regulator_get_optional(struct device *dev, | |
83 | const char *id) | |
84 | { | |
85 | return _devm_regulator_get(dev, id, OPTIONAL_GET); | |
86 | } | |
87 | EXPORT_SYMBOL_GPL(devm_regulator_get_optional); | |
88 | ||
89 | static int devm_regulator_match(struct device *dev, void *res, void *data) | |
90 | { | |
91 | struct regulator **r = res; | |
92 | if (!r || !*r) { | |
93 | WARN_ON(!r || !*r); | |
94 | return 0; | |
95 | } | |
96 | return *r == data; | |
97 | } | |
98 | ||
99 | /** | |
100 | * devm_regulator_put - Resource managed regulator_put() | |
101 | * @regulator: regulator to free | |
102 | * | |
103 | * Deallocate a regulator allocated with devm_regulator_get(). Normally | |
104 | * this function will not need to be called and the resource management | |
105 | * code will ensure that the resource is freed. | |
106 | */ | |
107 | void devm_regulator_put(struct regulator *regulator) | |
108 | { | |
109 | int rc; | |
110 | ||
111 | rc = devres_release(regulator->dev, devm_regulator_release, | |
112 | devm_regulator_match, regulator); | |
113 | if (rc != 0) | |
114 | WARN_ON(rc); | |
115 | } | |
116 | EXPORT_SYMBOL_GPL(devm_regulator_put); | |
117 | ||
3eaeb475 DT |
118 | struct regulator_bulk_devres { |
119 | struct regulator_bulk_data *consumers; | |
120 | int num_consumers; | |
121 | }; | |
122 | ||
123 | static void devm_regulator_bulk_release(struct device *dev, void *res) | |
124 | { | |
125 | struct regulator_bulk_devres *devres = res; | |
126 | ||
127 | regulator_bulk_free(devres->num_consumers, devres->consumers); | |
128 | } | |
129 | ||
0cdfcc0f MB |
130 | /** |
131 | * devm_regulator_bulk_get - managed get multiple regulator consumers | |
132 | * | |
133 | * @dev: Device to supply | |
134 | * @num_consumers: Number of consumers to register | |
135 | * @consumers: Configuration of consumers; clients are stored here. | |
136 | * | |
137 | * @return 0 on success, an errno on failure. | |
138 | * | |
139 | * This helper function allows drivers to get several regulator | |
140 | * consumers in one operation with management, the regulators will | |
141 | * automatically be freed when the device is unbound. If any of the | |
142 | * regulators cannot be acquired then any regulators that were | |
143 | * allocated will be freed before returning to the caller. | |
144 | */ | |
145 | int devm_regulator_bulk_get(struct device *dev, int num_consumers, | |
146 | struct regulator_bulk_data *consumers) | |
147 | { | |
3eaeb475 | 148 | struct regulator_bulk_devres *devres; |
0cdfcc0f MB |
149 | int ret; |
150 | ||
3eaeb475 DT |
151 | devres = devres_alloc(devm_regulator_bulk_release, |
152 | sizeof(*devres), GFP_KERNEL); | |
153 | if (!devres) | |
154 | return -ENOMEM; | |
0cdfcc0f | 155 | |
3eaeb475 DT |
156 | ret = regulator_bulk_get(dev, num_consumers, consumers); |
157 | if (!ret) { | |
158 | devres->consumers = consumers; | |
159 | devres->num_consumers = num_consumers; | |
160 | devres_add(dev, devres); | |
161 | } else { | |
162 | devres_free(devres); | |
163 | } | |
0cdfcc0f MB |
164 | |
165 | return ret; | |
166 | } | |
167 | EXPORT_SYMBOL_GPL(devm_regulator_bulk_get); | |
168 | ||
169 | static void devm_rdev_release(struct device *dev, void *res) | |
170 | { | |
171 | regulator_unregister(*(struct regulator_dev **)res); | |
172 | } | |
173 | ||
174 | /** | |
175 | * devm_regulator_register - Resource managed regulator_register() | |
176 | * @regulator_desc: regulator to register | |
177 | * @config: runtime configuration for regulator | |
178 | * | |
179 | * Called by regulator drivers to register a regulator. Returns a | |
180 | * valid pointer to struct regulator_dev on success or an ERR_PTR() on | |
181 | * error. The regulator will automatically be released when the device | |
182 | * is unbound. | |
183 | */ | |
184 | struct regulator_dev *devm_regulator_register(struct device *dev, | |
185 | const struct regulator_desc *regulator_desc, | |
186 | const struct regulator_config *config) | |
187 | { | |
188 | struct regulator_dev **ptr, *rdev; | |
189 | ||
190 | ptr = devres_alloc(devm_rdev_release, sizeof(*ptr), | |
191 | GFP_KERNEL); | |
192 | if (!ptr) | |
193 | return ERR_PTR(-ENOMEM); | |
194 | ||
195 | rdev = regulator_register(regulator_desc, config); | |
196 | if (!IS_ERR(rdev)) { | |
197 | *ptr = rdev; | |
198 | devres_add(dev, ptr); | |
199 | } else { | |
200 | devres_free(ptr); | |
201 | } | |
202 | ||
203 | return rdev; | |
204 | } | |
205 | EXPORT_SYMBOL_GPL(devm_regulator_register); | |
206 | ||
207 | static int devm_rdev_match(struct device *dev, void *res, void *data) | |
208 | { | |
209 | struct regulator_dev **r = res; | |
210 | if (!r || !*r) { | |
211 | WARN_ON(!r || !*r); | |
212 | return 0; | |
213 | } | |
214 | return *r == data; | |
215 | } | |
216 | ||
217 | /** | |
218 | * devm_regulator_unregister - Resource managed regulator_unregister() | |
219 | * @regulator: regulator to free | |
220 | * | |
221 | * Unregister a regulator registered with devm_regulator_register(). | |
222 | * Normally this function will not need to be called and the resource | |
223 | * management code will ensure that the resource is freed. | |
224 | */ | |
225 | void devm_regulator_unregister(struct device *dev, struct regulator_dev *rdev) | |
226 | { | |
227 | int rc; | |
228 | ||
229 | rc = devres_release(dev, devm_rdev_release, devm_rdev_match, rdev); | |
230 | if (rc != 0) | |
231 | WARN_ON(rc); | |
232 | } | |
233 | EXPORT_SYMBOL_GPL(devm_regulator_unregister); | |
a06ccd9c CK |
234 | |
235 | struct regulator_supply_alias_match { | |
236 | struct device *dev; | |
237 | const char *id; | |
238 | }; | |
239 | ||
240 | static int devm_regulator_match_supply_alias(struct device *dev, void *res, | |
241 | void *data) | |
242 | { | |
243 | struct regulator_supply_alias_match *match = res; | |
244 | struct regulator_supply_alias_match *target = data; | |
245 | ||
246 | return match->dev == target->dev && strcmp(match->id, target->id) == 0; | |
247 | } | |
248 | ||
249 | static void devm_regulator_destroy_supply_alias(struct device *dev, void *res) | |
250 | { | |
251 | struct regulator_supply_alias_match *match = res; | |
252 | ||
253 | regulator_unregister_supply_alias(match->dev, match->id); | |
254 | } | |
255 | ||
256 | /** | |
257 | * devm_regulator_register_supply_alias - Resource managed | |
258 | * regulator_register_supply_alias() | |
259 | * | |
260 | * @dev: device that will be given as the regulator "consumer" | |
261 | * @id: Supply name or regulator ID | |
262 | * @alias_dev: device that should be used to lookup the supply | |
263 | * @alias_id: Supply name or regulator ID that should be used to lookup the | |
264 | * supply | |
265 | * | |
266 | * The supply alias will automatically be unregistered when the source | |
267 | * device is unbound. | |
268 | */ | |
269 | int devm_regulator_register_supply_alias(struct device *dev, const char *id, | |
270 | struct device *alias_dev, | |
271 | const char *alias_id) | |
272 | { | |
273 | struct regulator_supply_alias_match *match; | |
274 | int ret; | |
275 | ||
276 | match = devres_alloc(devm_regulator_destroy_supply_alias, | |
277 | sizeof(struct regulator_supply_alias_match), | |
278 | GFP_KERNEL); | |
279 | if (!match) | |
280 | return -ENOMEM; | |
281 | ||
282 | match->dev = dev; | |
283 | match->id = id; | |
284 | ||
285 | ret = regulator_register_supply_alias(dev, id, alias_dev, alias_id); | |
286 | if (ret < 0) { | |
287 | devres_free(match); | |
288 | return ret; | |
289 | } | |
290 | ||
291 | devres_add(dev, match); | |
292 | ||
293 | return 0; | |
294 | } | |
295 | EXPORT_SYMBOL_GPL(devm_regulator_register_supply_alias); | |
296 | ||
297 | /** | |
298 | * devm_regulator_unregister_supply_alias - Resource managed | |
299 | * regulator_unregister_supply_alias() | |
300 | * | |
301 | * @dev: device that will be given as the regulator "consumer" | |
302 | * @id: Supply name or regulator ID | |
303 | * | |
304 | * Unregister an alias registered with | |
305 | * devm_regulator_register_supply_alias(). Normally this function | |
306 | * will not need to be called and the resource management code | |
307 | * will ensure that the resource is freed. | |
308 | */ | |
309 | void devm_regulator_unregister_supply_alias(struct device *dev, const char *id) | |
310 | { | |
311 | struct regulator_supply_alias_match match; | |
312 | int rc; | |
313 | ||
314 | match.dev = dev; | |
315 | match.id = id; | |
316 | ||
317 | rc = devres_release(dev, devm_regulator_destroy_supply_alias, | |
318 | devm_regulator_match_supply_alias, &match); | |
319 | if (rc != 0) | |
320 | WARN_ON(rc); | |
321 | } | |
322 | EXPORT_SYMBOL_GPL(devm_regulator_unregister_supply_alias); | |
323 | ||
324 | /** | |
325 | * devm_regulator_bulk_register_supply_alias - Managed register | |
326 | * multiple aliases | |
327 | * | |
328 | * @dev: device that will be given as the regulator "consumer" | |
329 | * @id: List of supply names or regulator IDs | |
330 | * @alias_dev: device that should be used to lookup the supply | |
331 | * @alias_id: List of supply names or regulator IDs that should be used to | |
332 | * lookup the supply | |
333 | * @num_id: Number of aliases to register | |
334 | * | |
335 | * @return 0 on success, an errno on failure. | |
336 | * | |
337 | * This helper function allows drivers to register several supply | |
338 | * aliases in one operation, the aliases will be automatically | |
339 | * unregisters when the source device is unbound. If any of the | |
340 | * aliases cannot be registered any aliases that were registered | |
341 | * will be removed before returning to the caller. | |
342 | */ | |
343 | int devm_regulator_bulk_register_supply_alias(struct device *dev, | |
9f8c0fe9 | 344 | const char *const *id, |
a06ccd9c | 345 | struct device *alias_dev, |
9f8c0fe9 | 346 | const char *const *alias_id, |
a06ccd9c CK |
347 | int num_id) |
348 | { | |
349 | int i; | |
350 | int ret; | |
351 | ||
352 | for (i = 0; i < num_id; ++i) { | |
353 | ret = devm_regulator_register_supply_alias(dev, id[i], | |
354 | alias_dev, | |
355 | alias_id[i]); | |
356 | if (ret < 0) | |
357 | goto err; | |
358 | } | |
359 | ||
360 | return 0; | |
361 | ||
362 | err: | |
363 | dev_err(dev, | |
364 | "Failed to create supply alias %s,%s -> %s,%s\n", | |
365 | id[i], dev_name(dev), alias_id[i], dev_name(alias_dev)); | |
366 | ||
367 | while (--i >= 0) | |
368 | devm_regulator_unregister_supply_alias(dev, id[i]); | |
369 | ||
370 | return ret; | |
371 | } | |
372 | EXPORT_SYMBOL_GPL(devm_regulator_bulk_register_supply_alias); | |
373 | ||
374 | /** | |
375 | * devm_regulator_bulk_unregister_supply_alias - Managed unregister | |
376 | * multiple aliases | |
377 | * | |
378 | * @dev: device that will be given as the regulator "consumer" | |
379 | * @id: List of supply names or regulator IDs | |
380 | * @num_id: Number of aliases to unregister | |
381 | * | |
382 | * Unregister aliases registered with | |
383 | * devm_regulator_bulk_register_supply_alias(). Normally this function | |
384 | * will not need to be called and the resource management code | |
385 | * will ensure that the resource is freed. | |
386 | */ | |
387 | void devm_regulator_bulk_unregister_supply_alias(struct device *dev, | |
9f8c0fe9 | 388 | const char *const *id, |
a06ccd9c CK |
389 | int num_id) |
390 | { | |
391 | int i; | |
392 | ||
393 | for (i = 0; i < num_id; ++i) | |
394 | devm_regulator_unregister_supply_alias(dev, id[i]); | |
395 | } | |
396 | EXPORT_SYMBOL_GPL(devm_regulator_bulk_unregister_supply_alias); | |
046db763 CK |
397 | |
398 | struct regulator_notifier_match { | |
399 | struct regulator *regulator; | |
400 | struct notifier_block *nb; | |
401 | }; | |
402 | ||
403 | static int devm_regulator_match_notifier(struct device *dev, void *res, | |
404 | void *data) | |
405 | { | |
406 | struct regulator_notifier_match *match = res; | |
407 | struct regulator_notifier_match *target = data; | |
408 | ||
409 | return match->regulator == target->regulator && match->nb == target->nb; | |
410 | } | |
411 | ||
412 | static void devm_regulator_destroy_notifier(struct device *dev, void *res) | |
413 | { | |
414 | struct regulator_notifier_match *match = res; | |
415 | ||
416 | regulator_unregister_notifier(match->regulator, match->nb); | |
417 | } | |
418 | ||
419 | /** | |
420 | * devm_regulator_register_notifier - Resource managed | |
421 | * regulator_register_notifier | |
422 | * | |
423 | * @regulator: regulator source | |
424 | * @nb: notifier block | |
425 | * | |
426 | * The notifier will be registers under the consumer device and be | |
427 | * automatically be unregistered when the source device is unbound. | |
428 | */ | |
429 | int devm_regulator_register_notifier(struct regulator *regulator, | |
430 | struct notifier_block *nb) | |
431 | { | |
432 | struct regulator_notifier_match *match; | |
433 | int ret; | |
434 | ||
435 | match = devres_alloc(devm_regulator_destroy_notifier, | |
436 | sizeof(struct regulator_notifier_match), | |
437 | GFP_KERNEL); | |
438 | if (!match) | |
439 | return -ENOMEM; | |
440 | ||
441 | match->regulator = regulator; | |
442 | match->nb = nb; | |
443 | ||
444 | ret = regulator_register_notifier(regulator, nb); | |
445 | if (ret < 0) { | |
446 | devres_free(match); | |
447 | return ret; | |
448 | } | |
449 | ||
450 | devres_add(regulator->dev, match); | |
451 | ||
452 | return 0; | |
453 | } | |
454 | EXPORT_SYMBOL_GPL(devm_regulator_register_notifier); | |
455 | ||
456 | /** | |
457 | * devm_regulator_unregister_notifier - Resource managed | |
458 | * regulator_unregister_notifier() | |
459 | * | |
460 | * @regulator: regulator source | |
461 | * @nb: notifier block | |
462 | * | |
463 | * Unregister a notifier registered with devm_regulator_register_notifier(). | |
464 | * Normally this function will not need to be called and the resource | |
465 | * management code will ensure that the resource is freed. | |
466 | */ | |
467 | void devm_regulator_unregister_notifier(struct regulator *regulator, | |
468 | struct notifier_block *nb) | |
469 | { | |
470 | struct regulator_notifier_match match; | |
471 | int rc; | |
472 | ||
473 | match.regulator = regulator; | |
474 | match.nb = nb; | |
475 | ||
476 | rc = devres_release(regulator->dev, devm_regulator_destroy_notifier, | |
477 | devm_regulator_match_notifier, &match); | |
478 | if (rc != 0) | |
479 | WARN_ON(rc); | |
480 | } | |
481 | EXPORT_SYMBOL_GPL(devm_regulator_unregister_notifier); |