]>
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 | ||
a06ccd9c CK |
208 | struct regulator_supply_alias_match { |
209 | struct device *dev; | |
210 | const char *id; | |
211 | }; | |
212 | ||
213 | static int devm_regulator_match_supply_alias(struct device *dev, void *res, | |
214 | void *data) | |
215 | { | |
216 | struct regulator_supply_alias_match *match = res; | |
217 | struct regulator_supply_alias_match *target = data; | |
218 | ||
219 | return match->dev == target->dev && strcmp(match->id, target->id) == 0; | |
220 | } | |
221 | ||
222 | static void devm_regulator_destroy_supply_alias(struct device *dev, void *res) | |
223 | { | |
224 | struct regulator_supply_alias_match *match = res; | |
225 | ||
226 | regulator_unregister_supply_alias(match->dev, match->id); | |
227 | } | |
228 | ||
229 | /** | |
230 | * devm_regulator_register_supply_alias - Resource managed | |
231 | * regulator_register_supply_alias() | |
232 | * | |
a7c15187 LJ |
233 | * @dev: device to supply |
234 | * @id: supply name or regulator ID | |
a06ccd9c | 235 | * @alias_dev: device that should be used to lookup the supply |
a7c15187 | 236 | * @alias_id: supply name or regulator ID that should be used to lookup the |
a06ccd9c CK |
237 | * supply |
238 | * | |
239 | * The supply alias will automatically be unregistered when the source | |
240 | * device is unbound. | |
241 | */ | |
242 | int devm_regulator_register_supply_alias(struct device *dev, const char *id, | |
243 | struct device *alias_dev, | |
244 | const char *alias_id) | |
245 | { | |
246 | struct regulator_supply_alias_match *match; | |
247 | int ret; | |
248 | ||
249 | match = devres_alloc(devm_regulator_destroy_supply_alias, | |
250 | sizeof(struct regulator_supply_alias_match), | |
251 | GFP_KERNEL); | |
252 | if (!match) | |
253 | return -ENOMEM; | |
254 | ||
255 | match->dev = dev; | |
256 | match->id = id; | |
257 | ||
258 | ret = regulator_register_supply_alias(dev, id, alias_dev, alias_id); | |
259 | if (ret < 0) { | |
260 | devres_free(match); | |
261 | return ret; | |
262 | } | |
263 | ||
264 | devres_add(dev, match); | |
265 | ||
266 | return 0; | |
267 | } | |
268 | EXPORT_SYMBOL_GPL(devm_regulator_register_supply_alias); | |
269 | ||
4d9f4d1d AA |
270 | static void devm_regulator_unregister_supply_alias(struct device *dev, |
271 | const char *id) | |
a06ccd9c CK |
272 | { |
273 | struct regulator_supply_alias_match match; | |
274 | int rc; | |
275 | ||
276 | match.dev = dev; | |
277 | match.id = id; | |
278 | ||
279 | rc = devres_release(dev, devm_regulator_destroy_supply_alias, | |
280 | devm_regulator_match_supply_alias, &match); | |
281 | if (rc != 0) | |
282 | WARN_ON(rc); | |
283 | } | |
a06ccd9c CK |
284 | |
285 | /** | |
286 | * devm_regulator_bulk_register_supply_alias - Managed register | |
287 | * multiple aliases | |
288 | * | |
a7c15187 LJ |
289 | * @dev: device to supply |
290 | * @id: list of supply names or regulator IDs | |
a06ccd9c | 291 | * @alias_dev: device that should be used to lookup the supply |
a7c15187 LJ |
292 | * @alias_id: list of supply names or regulator IDs that should be used to |
293 | * lookup the supply | |
294 | * @num_id: number of aliases to register | |
a06ccd9c CK |
295 | * |
296 | * @return 0 on success, an errno on failure. | |
297 | * | |
298 | * This helper function allows drivers to register several supply | |
299 | * aliases in one operation, the aliases will be automatically | |
300 | * unregisters when the source device is unbound. If any of the | |
301 | * aliases cannot be registered any aliases that were registered | |
302 | * will be removed before returning to the caller. | |
303 | */ | |
304 | int devm_regulator_bulk_register_supply_alias(struct device *dev, | |
9f8c0fe9 | 305 | const char *const *id, |
a06ccd9c | 306 | struct device *alias_dev, |
9f8c0fe9 | 307 | const char *const *alias_id, |
a06ccd9c CK |
308 | int num_id) |
309 | { | |
310 | int i; | |
311 | int ret; | |
312 | ||
313 | for (i = 0; i < num_id; ++i) { | |
314 | ret = devm_regulator_register_supply_alias(dev, id[i], | |
315 | alias_dev, | |
316 | alias_id[i]); | |
317 | if (ret < 0) | |
318 | goto err; | |
319 | } | |
320 | ||
321 | return 0; | |
322 | ||
323 | err: | |
324 | dev_err(dev, | |
325 | "Failed to create supply alias %s,%s -> %s,%s\n", | |
326 | id[i], dev_name(dev), alias_id[i], dev_name(alias_dev)); | |
327 | ||
328 | while (--i >= 0) | |
329 | devm_regulator_unregister_supply_alias(dev, id[i]); | |
330 | ||
331 | return ret; | |
332 | } | |
333 | EXPORT_SYMBOL_GPL(devm_regulator_bulk_register_supply_alias); | |
334 | ||
046db763 CK |
335 | struct regulator_notifier_match { |
336 | struct regulator *regulator; | |
337 | struct notifier_block *nb; | |
338 | }; | |
339 | ||
340 | static int devm_regulator_match_notifier(struct device *dev, void *res, | |
341 | void *data) | |
342 | { | |
343 | struct regulator_notifier_match *match = res; | |
344 | struct regulator_notifier_match *target = data; | |
345 | ||
346 | return match->regulator == target->regulator && match->nb == target->nb; | |
347 | } | |
348 | ||
349 | static void devm_regulator_destroy_notifier(struct device *dev, void *res) | |
350 | { | |
351 | struct regulator_notifier_match *match = res; | |
352 | ||
353 | regulator_unregister_notifier(match->regulator, match->nb); | |
354 | } | |
355 | ||
356 | /** | |
357 | * devm_regulator_register_notifier - Resource managed | |
358 | * regulator_register_notifier | |
359 | * | |
360 | * @regulator: regulator source | |
a7c15187 | 361 | * @nb: notifier block |
046db763 CK |
362 | * |
363 | * The notifier will be registers under the consumer device and be | |
364 | * automatically be unregistered when the source device is unbound. | |
365 | */ | |
366 | int devm_regulator_register_notifier(struct regulator *regulator, | |
367 | struct notifier_block *nb) | |
368 | { | |
369 | struct regulator_notifier_match *match; | |
370 | int ret; | |
371 | ||
372 | match = devres_alloc(devm_regulator_destroy_notifier, | |
373 | sizeof(struct regulator_notifier_match), | |
374 | GFP_KERNEL); | |
375 | if (!match) | |
376 | return -ENOMEM; | |
377 | ||
378 | match->regulator = regulator; | |
379 | match->nb = nb; | |
380 | ||
381 | ret = regulator_register_notifier(regulator, nb); | |
382 | if (ret < 0) { | |
383 | devres_free(match); | |
384 | return ret; | |
385 | } | |
386 | ||
387 | devres_add(regulator->dev, match); | |
388 | ||
389 | return 0; | |
390 | } | |
391 | EXPORT_SYMBOL_GPL(devm_regulator_register_notifier); | |
392 | ||
393 | /** | |
394 | * devm_regulator_unregister_notifier - Resource managed | |
395 | * regulator_unregister_notifier() | |
396 | * | |
397 | * @regulator: regulator source | |
a7c15187 | 398 | * @nb: notifier block |
046db763 CK |
399 | * |
400 | * Unregister a notifier registered with devm_regulator_register_notifier(). | |
401 | * Normally this function will not need to be called and the resource | |
402 | * management code will ensure that the resource is freed. | |
403 | */ | |
404 | void devm_regulator_unregister_notifier(struct regulator *regulator, | |
405 | struct notifier_block *nb) | |
406 | { | |
407 | struct regulator_notifier_match match; | |
408 | int rc; | |
409 | ||
410 | match.regulator = regulator; | |
411 | match.nb = nb; | |
412 | ||
413 | rc = devres_release(regulator->dev, devm_regulator_destroy_notifier, | |
414 | devm_regulator_match_notifier, &match); | |
415 | if (rc != 0) | |
416 | WARN_ON(rc); | |
417 | } | |
418 | EXPORT_SYMBOL_GPL(devm_regulator_unregister_notifier); | |
7111c6d1 MV |
419 | |
420 | static void regulator_irq_helper_drop(void *res) | |
421 | { | |
422 | regulator_irq_helper_cancel(&res); | |
423 | } | |
424 | ||
425 | /** | |
426 | * devm_regulator_irq_helper - resource managed registration of IRQ based | |
427 | * regulator event/error notifier | |
428 | * | |
429 | * @dev: device to which lifetime the helper's lifetime is | |
430 | * bound. | |
431 | * @d: IRQ helper descriptor. | |
432 | * @irq: IRQ used to inform events/errors to be notified. | |
433 | * @irq_flags: Extra IRQ flags to be OR'ed with the default | |
434 | * IRQF_ONESHOT when requesting the (threaded) irq. | |
435 | * @common_errs: Errors which can be flagged by this IRQ for all rdevs. | |
436 | * When IRQ is re-enabled these errors will be cleared | |
437 | * from all associated regulators | |
438 | * @per_rdev_errs: Optional error flag array describing errors specific | |
439 | * for only some of the regulators. These errors will be | |
440 | * or'ed with common errors. If this is given the array | |
441 | * should contain rdev_amount flags. Can be set to NULL | |
442 | * if there is no regulator specific error flags for this | |
443 | * IRQ. | |
444 | * @rdev: Array of pointers to regulators associated with this | |
445 | * IRQ. | |
446 | * @rdev_amount: Amount of regulators associated with this IRQ. | |
447 | * | |
448 | * Return: handle to irq_helper or an ERR_PTR() encoded error code. | |
449 | */ | |
450 | void *devm_regulator_irq_helper(struct device *dev, | |
451 | const struct regulator_irq_desc *d, int irq, | |
452 | int irq_flags, int common_errs, | |
453 | int *per_rdev_errs, | |
454 | struct regulator_dev **rdev, int rdev_amount) | |
455 | { | |
456 | void *ptr; | |
457 | int ret; | |
458 | ||
459 | ptr = regulator_irq_helper(dev, d, irq, irq_flags, common_errs, | |
460 | per_rdev_errs, rdev, rdev_amount); | |
461 | if (IS_ERR(ptr)) | |
462 | return ptr; | |
463 | ||
464 | ret = devm_add_action_or_reset(dev, regulator_irq_helper_drop, ptr); | |
465 | if (ret) | |
466 | return ERR_PTR(ret); | |
467 | ||
468 | return ptr; | |
469 | } | |
470 | EXPORT_SYMBOL_GPL(devm_regulator_irq_helper); |