]>
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() | |
a7c15187 LJ |
44 | * @dev: device to supply |
45 | * @id: supply name or regulator ID. | |
0cdfcc0f MB |
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() | |
a7c15187 LJ |
59 | * @dev: device to supply |
60 | * @id: supply name or regulator ID. | |
0cdfcc0f MB |
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() | |
a7c15187 LJ |
75 | * @dev: device to supply |
76 | * @id: supply name or regulator ID. | |
0cdfcc0f MB |
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 | * | |
a7c15187 LJ |
133 | * @dev: device to supply |
134 | * @num_consumers: number of consumers to register | |
135 | * @consumers: configuration of consumers; clients are stored here. | |
0cdfcc0f MB |
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() | |
a7c15187 | 176 | * @dev: device to supply |
0cdfcc0f | 177 | * @regulator_desc: regulator to register |
a7c15187 | 178 | * @config: runtime configuration for regulator |
0cdfcc0f MB |
179 | * |
180 | * Called by regulator drivers to register a regulator. Returns a | |
181 | * valid pointer to struct regulator_dev on success or an ERR_PTR() on | |
182 | * error. The regulator will automatically be released when the device | |
183 | * is unbound. | |
184 | */ | |
185 | struct regulator_dev *devm_regulator_register(struct device *dev, | |
186 | const struct regulator_desc *regulator_desc, | |
187 | const struct regulator_config *config) | |
188 | { | |
189 | struct regulator_dev **ptr, *rdev; | |
190 | ||
191 | ptr = devres_alloc(devm_rdev_release, sizeof(*ptr), | |
192 | GFP_KERNEL); | |
193 | if (!ptr) | |
194 | return ERR_PTR(-ENOMEM); | |
195 | ||
196 | rdev = regulator_register(regulator_desc, config); | |
197 | if (!IS_ERR(rdev)) { | |
198 | *ptr = rdev; | |
199 | devres_add(dev, ptr); | |
200 | } else { | |
201 | devres_free(ptr); | |
202 | } | |
203 | ||
204 | return rdev; | |
205 | } | |
206 | EXPORT_SYMBOL_GPL(devm_regulator_register); | |
207 | ||
208 | static int devm_rdev_match(struct device *dev, void *res, void *data) | |
209 | { | |
210 | struct regulator_dev **r = res; | |
211 | if (!r || !*r) { | |
212 | WARN_ON(!r || !*r); | |
213 | return 0; | |
214 | } | |
215 | return *r == data; | |
216 | } | |
217 | ||
218 | /** | |
219 | * devm_regulator_unregister - Resource managed regulator_unregister() | |
9565cccd LJ |
220 | * @dev: device to supply |
221 | * @rdev: regulator to free | |
0cdfcc0f MB |
222 | * |
223 | * Unregister a regulator registered with devm_regulator_register(). | |
224 | * Normally this function will not need to be called and the resource | |
225 | * management code will ensure that the resource is freed. | |
226 | */ | |
227 | void devm_regulator_unregister(struct device *dev, struct regulator_dev *rdev) | |
228 | { | |
229 | int rc; | |
230 | ||
231 | rc = devres_release(dev, devm_rdev_release, devm_rdev_match, rdev); | |
232 | if (rc != 0) | |
233 | WARN_ON(rc); | |
234 | } | |
235 | EXPORT_SYMBOL_GPL(devm_regulator_unregister); | |
a06ccd9c CK |
236 | |
237 | struct regulator_supply_alias_match { | |
238 | struct device *dev; | |
239 | const char *id; | |
240 | }; | |
241 | ||
242 | static int devm_regulator_match_supply_alias(struct device *dev, void *res, | |
243 | void *data) | |
244 | { | |
245 | struct regulator_supply_alias_match *match = res; | |
246 | struct regulator_supply_alias_match *target = data; | |
247 | ||
248 | return match->dev == target->dev && strcmp(match->id, target->id) == 0; | |
249 | } | |
250 | ||
251 | static void devm_regulator_destroy_supply_alias(struct device *dev, void *res) | |
252 | { | |
253 | struct regulator_supply_alias_match *match = res; | |
254 | ||
255 | regulator_unregister_supply_alias(match->dev, match->id); | |
256 | } | |
257 | ||
258 | /** | |
259 | * devm_regulator_register_supply_alias - Resource managed | |
260 | * regulator_register_supply_alias() | |
261 | * | |
a7c15187 LJ |
262 | * @dev: device to supply |
263 | * @id: supply name or regulator ID | |
a06ccd9c | 264 | * @alias_dev: device that should be used to lookup the supply |
a7c15187 | 265 | * @alias_id: supply name or regulator ID that should be used to lookup the |
a06ccd9c CK |
266 | * supply |
267 | * | |
268 | * The supply alias will automatically be unregistered when the source | |
269 | * device is unbound. | |
270 | */ | |
271 | int devm_regulator_register_supply_alias(struct device *dev, const char *id, | |
272 | struct device *alias_dev, | |
273 | const char *alias_id) | |
274 | { | |
275 | struct regulator_supply_alias_match *match; | |
276 | int ret; | |
277 | ||
278 | match = devres_alloc(devm_regulator_destroy_supply_alias, | |
279 | sizeof(struct regulator_supply_alias_match), | |
280 | GFP_KERNEL); | |
281 | if (!match) | |
282 | return -ENOMEM; | |
283 | ||
284 | match->dev = dev; | |
285 | match->id = id; | |
286 | ||
287 | ret = regulator_register_supply_alias(dev, id, alias_dev, alias_id); | |
288 | if (ret < 0) { | |
289 | devres_free(match); | |
290 | return ret; | |
291 | } | |
292 | ||
293 | devres_add(dev, match); | |
294 | ||
295 | return 0; | |
296 | } | |
297 | EXPORT_SYMBOL_GPL(devm_regulator_register_supply_alias); | |
298 | ||
299 | /** | |
300 | * devm_regulator_unregister_supply_alias - Resource managed | |
301 | * regulator_unregister_supply_alias() | |
302 | * | |
a7c15187 LJ |
303 | * @dev: device to supply |
304 | * @id: supply name or regulator ID | |
a06ccd9c CK |
305 | * |
306 | * Unregister an alias registered with | |
307 | * devm_regulator_register_supply_alias(). Normally this function | |
308 | * will not need to be called and the resource management code | |
309 | * will ensure that the resource is freed. | |
310 | */ | |
311 | void devm_regulator_unregister_supply_alias(struct device *dev, const char *id) | |
312 | { | |
313 | struct regulator_supply_alias_match match; | |
314 | int rc; | |
315 | ||
316 | match.dev = dev; | |
317 | match.id = id; | |
318 | ||
319 | rc = devres_release(dev, devm_regulator_destroy_supply_alias, | |
320 | devm_regulator_match_supply_alias, &match); | |
321 | if (rc != 0) | |
322 | WARN_ON(rc); | |
323 | } | |
324 | EXPORT_SYMBOL_GPL(devm_regulator_unregister_supply_alias); | |
325 | ||
326 | /** | |
327 | * devm_regulator_bulk_register_supply_alias - Managed register | |
328 | * multiple aliases | |
329 | * | |
a7c15187 LJ |
330 | * @dev: device to supply |
331 | * @id: list of supply names or regulator IDs | |
a06ccd9c | 332 | * @alias_dev: device that should be used to lookup the supply |
a7c15187 LJ |
333 | * @alias_id: list of supply names or regulator IDs that should be used to |
334 | * lookup the supply | |
335 | * @num_id: number of aliases to register | |
a06ccd9c CK |
336 | * |
337 | * @return 0 on success, an errno on failure. | |
338 | * | |
339 | * This helper function allows drivers to register several supply | |
340 | * aliases in one operation, the aliases will be automatically | |
341 | * unregisters when the source device is unbound. If any of the | |
342 | * aliases cannot be registered any aliases that were registered | |
343 | * will be removed before returning to the caller. | |
344 | */ | |
345 | int devm_regulator_bulk_register_supply_alias(struct device *dev, | |
9f8c0fe9 | 346 | const char *const *id, |
a06ccd9c | 347 | struct device *alias_dev, |
9f8c0fe9 | 348 | const char *const *alias_id, |
a06ccd9c CK |
349 | int num_id) |
350 | { | |
351 | int i; | |
352 | int ret; | |
353 | ||
354 | for (i = 0; i < num_id; ++i) { | |
355 | ret = devm_regulator_register_supply_alias(dev, id[i], | |
356 | alias_dev, | |
357 | alias_id[i]); | |
358 | if (ret < 0) | |
359 | goto err; | |
360 | } | |
361 | ||
362 | return 0; | |
363 | ||
364 | err: | |
365 | dev_err(dev, | |
366 | "Failed to create supply alias %s,%s -> %s,%s\n", | |
367 | id[i], dev_name(dev), alias_id[i], dev_name(alias_dev)); | |
368 | ||
369 | while (--i >= 0) | |
370 | devm_regulator_unregister_supply_alias(dev, id[i]); | |
371 | ||
372 | return ret; | |
373 | } | |
374 | EXPORT_SYMBOL_GPL(devm_regulator_bulk_register_supply_alias); | |
375 | ||
376 | /** | |
377 | * devm_regulator_bulk_unregister_supply_alias - Managed unregister | |
378 | * multiple aliases | |
379 | * | |
a7c15187 LJ |
380 | * @dev: device to supply |
381 | * @id: list of supply names or regulator IDs | |
382 | * @num_id: number of aliases to unregister | |
a06ccd9c CK |
383 | * |
384 | * Unregister aliases registered with | |
385 | * devm_regulator_bulk_register_supply_alias(). Normally this function | |
386 | * will not need to be called and the resource management code | |
387 | * will ensure that the resource is freed. | |
388 | */ | |
389 | void devm_regulator_bulk_unregister_supply_alias(struct device *dev, | |
9f8c0fe9 | 390 | const char *const *id, |
a06ccd9c CK |
391 | int num_id) |
392 | { | |
393 | int i; | |
394 | ||
395 | for (i = 0; i < num_id; ++i) | |
396 | devm_regulator_unregister_supply_alias(dev, id[i]); | |
397 | } | |
398 | EXPORT_SYMBOL_GPL(devm_regulator_bulk_unregister_supply_alias); | |
046db763 CK |
399 | |
400 | struct regulator_notifier_match { | |
401 | struct regulator *regulator; | |
402 | struct notifier_block *nb; | |
403 | }; | |
404 | ||
405 | static int devm_regulator_match_notifier(struct device *dev, void *res, | |
406 | void *data) | |
407 | { | |
408 | struct regulator_notifier_match *match = res; | |
409 | struct regulator_notifier_match *target = data; | |
410 | ||
411 | return match->regulator == target->regulator && match->nb == target->nb; | |
412 | } | |
413 | ||
414 | static void devm_regulator_destroy_notifier(struct device *dev, void *res) | |
415 | { | |
416 | struct regulator_notifier_match *match = res; | |
417 | ||
418 | regulator_unregister_notifier(match->regulator, match->nb); | |
419 | } | |
420 | ||
421 | /** | |
422 | * devm_regulator_register_notifier - Resource managed | |
423 | * regulator_register_notifier | |
424 | * | |
425 | * @regulator: regulator source | |
a7c15187 | 426 | * @nb: notifier block |
046db763 CK |
427 | * |
428 | * The notifier will be registers under the consumer device and be | |
429 | * automatically be unregistered when the source device is unbound. | |
430 | */ | |
431 | int devm_regulator_register_notifier(struct regulator *regulator, | |
432 | struct notifier_block *nb) | |
433 | { | |
434 | struct regulator_notifier_match *match; | |
435 | int ret; | |
436 | ||
437 | match = devres_alloc(devm_regulator_destroy_notifier, | |
438 | sizeof(struct regulator_notifier_match), | |
439 | GFP_KERNEL); | |
440 | if (!match) | |
441 | return -ENOMEM; | |
442 | ||
443 | match->regulator = regulator; | |
444 | match->nb = nb; | |
445 | ||
446 | ret = regulator_register_notifier(regulator, nb); | |
447 | if (ret < 0) { | |
448 | devres_free(match); | |
449 | return ret; | |
450 | } | |
451 | ||
452 | devres_add(regulator->dev, match); | |
453 | ||
454 | return 0; | |
455 | } | |
456 | EXPORT_SYMBOL_GPL(devm_regulator_register_notifier); | |
457 | ||
458 | /** | |
459 | * devm_regulator_unregister_notifier - Resource managed | |
460 | * regulator_unregister_notifier() | |
461 | * | |
462 | * @regulator: regulator source | |
a7c15187 | 463 | * @nb: notifier block |
046db763 CK |
464 | * |
465 | * Unregister a notifier registered with devm_regulator_register_notifier(). | |
466 | * Normally this function will not need to be called and the resource | |
467 | * management code will ensure that the resource is freed. | |
468 | */ | |
469 | void devm_regulator_unregister_notifier(struct regulator *regulator, | |
470 | struct notifier_block *nb) | |
471 | { | |
472 | struct regulator_notifier_match match; | |
473 | int rc; | |
474 | ||
475 | match.regulator = regulator; | |
476 | match.nb = nb; | |
477 | ||
478 | rc = devres_release(regulator->dev, devm_regulator_destroy_notifier, | |
479 | devm_regulator_match_notifier, &match); | |
480 | if (rc != 0) | |
481 | WARN_ON(rc); | |
482 | } | |
483 | EXPORT_SYMBOL_GPL(devm_regulator_unregister_notifier); |