1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * devres.c -- Voltage/Current Regulator framework devres implementation.
5 * Copyright 2013 Linaro Ltd
8 #include <linux/kernel.h>
10 #include <linux/regmap.h>
11 #include <linux/regulator/consumer.h>
12 #include <linux/regulator/driver.h>
13 #include <linux/module.h>
17 static void devm_regulator_release(struct device
*dev
, void *res
)
19 regulator_put(*(struct regulator
**)res
);
22 static struct regulator
*_devm_regulator_get(struct device
*dev
, const char *id
,
25 struct regulator
**ptr
, *regulator
;
27 ptr
= devres_alloc(devm_regulator_release
, sizeof(*ptr
), GFP_KERNEL
);
29 return ERR_PTR(-ENOMEM
);
31 regulator
= _regulator_get(dev
, id
, get_type
);
32 if (!IS_ERR(regulator
)) {
43 * devm_regulator_get - Resource managed regulator_get()
44 * @dev: device to supply
45 * @id: supply name or regulator ID.
47 * Managed regulator_get(). Regulators returned from this function are
48 * automatically regulator_put() on driver detach. See regulator_get() for more
51 struct regulator
*devm_regulator_get(struct device
*dev
, const char *id
)
53 return _devm_regulator_get(dev
, id
, NORMAL_GET
);
55 EXPORT_SYMBOL_GPL(devm_regulator_get
);
58 * devm_regulator_get_exclusive - Resource managed regulator_get_exclusive()
59 * @dev: device to supply
60 * @id: supply name or regulator ID.
62 * Managed regulator_get_exclusive(). Regulators returned from this function
63 * are automatically regulator_put() on driver detach. See regulator_get() for
66 struct regulator
*devm_regulator_get_exclusive(struct device
*dev
,
69 return _devm_regulator_get(dev
, id
, EXCLUSIVE_GET
);
71 EXPORT_SYMBOL_GPL(devm_regulator_get_exclusive
);
74 * devm_regulator_get_optional - Resource managed regulator_get_optional()
75 * @dev: device to supply
76 * @id: supply name or regulator ID.
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.
82 struct regulator
*devm_regulator_get_optional(struct device
*dev
,
85 return _devm_regulator_get(dev
, id
, OPTIONAL_GET
);
87 EXPORT_SYMBOL_GPL(devm_regulator_get_optional
);
89 static int devm_regulator_match(struct device
*dev
, void *res
, void *data
)
91 struct regulator
**r
= res
;
100 * devm_regulator_put - Resource managed regulator_put()
101 * @regulator: regulator to free
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.
107 void devm_regulator_put(struct regulator
*regulator
)
111 rc
= devres_release(regulator
->dev
, devm_regulator_release
,
112 devm_regulator_match
, regulator
);
116 EXPORT_SYMBOL_GPL(devm_regulator_put
);
118 struct regulator_bulk_devres
{
119 struct regulator_bulk_data
*consumers
;
123 static void devm_regulator_bulk_release(struct device
*dev
, void *res
)
125 struct regulator_bulk_devres
*devres
= res
;
127 regulator_bulk_free(devres
->num_consumers
, devres
->consumers
);
131 * devm_regulator_bulk_get - managed get multiple regulator consumers
133 * @dev: device to supply
134 * @num_consumers: number of consumers to register
135 * @consumers: configuration of consumers; clients are stored here.
137 * @return 0 on success, an errno on failure.
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.
145 int devm_regulator_bulk_get(struct device
*dev
, int num_consumers
,
146 struct regulator_bulk_data
*consumers
)
148 struct regulator_bulk_devres
*devres
;
151 devres
= devres_alloc(devm_regulator_bulk_release
,
152 sizeof(*devres
), GFP_KERNEL
);
156 ret
= regulator_bulk_get(dev
, num_consumers
, consumers
);
158 devres
->consumers
= consumers
;
159 devres
->num_consumers
= num_consumers
;
160 devres_add(dev
, devres
);
167 EXPORT_SYMBOL_GPL(devm_regulator_bulk_get
);
169 static void devm_rdev_release(struct device
*dev
, void *res
)
171 regulator_unregister(*(struct regulator_dev
**)res
);
175 * devm_regulator_register - Resource managed regulator_register()
176 * @dev: device to supply
177 * @regulator_desc: regulator to register
178 * @config: runtime configuration for regulator
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
185 struct regulator_dev
*devm_regulator_register(struct device
*dev
,
186 const struct regulator_desc
*regulator_desc
,
187 const struct regulator_config
*config
)
189 struct regulator_dev
**ptr
, *rdev
;
191 ptr
= devres_alloc(devm_rdev_release
, sizeof(*ptr
),
194 return ERR_PTR(-ENOMEM
);
196 rdev
= regulator_register(regulator_desc
, config
);
199 devres_add(dev
, ptr
);
206 EXPORT_SYMBOL_GPL(devm_regulator_register
);
208 struct regulator_supply_alias_match
{
213 static int devm_regulator_match_supply_alias(struct device
*dev
, void *res
,
216 struct regulator_supply_alias_match
*match
= res
;
217 struct regulator_supply_alias_match
*target
= data
;
219 return match
->dev
== target
->dev
&& strcmp(match
->id
, target
->id
) == 0;
222 static void devm_regulator_destroy_supply_alias(struct device
*dev
, void *res
)
224 struct regulator_supply_alias_match
*match
= res
;
226 regulator_unregister_supply_alias(match
->dev
, match
->id
);
230 * devm_regulator_register_supply_alias - Resource managed
231 * regulator_register_supply_alias()
233 * @dev: device to supply
234 * @id: supply name or regulator ID
235 * @alias_dev: device that should be used to lookup the supply
236 * @alias_id: supply name or regulator ID that should be used to lookup the
239 * The supply alias will automatically be unregistered when the source
242 int devm_regulator_register_supply_alias(struct device
*dev
, const char *id
,
243 struct device
*alias_dev
,
244 const char *alias_id
)
246 struct regulator_supply_alias_match
*match
;
249 match
= devres_alloc(devm_regulator_destroy_supply_alias
,
250 sizeof(struct regulator_supply_alias_match
),
258 ret
= regulator_register_supply_alias(dev
, id
, alias_dev
, alias_id
);
264 devres_add(dev
, match
);
268 EXPORT_SYMBOL_GPL(devm_regulator_register_supply_alias
);
270 static void devm_regulator_unregister_supply_alias(struct device
*dev
,
273 struct regulator_supply_alias_match match
;
279 rc
= devres_release(dev
, devm_regulator_destroy_supply_alias
,
280 devm_regulator_match_supply_alias
, &match
);
286 * devm_regulator_bulk_register_supply_alias - Managed register
289 * @dev: device to supply
290 * @id: list of supply names or regulator IDs
291 * @alias_dev: device that should be used to lookup the supply
292 * @alias_id: list of supply names or regulator IDs that should be used to
294 * @num_id: number of aliases to register
296 * @return 0 on success, an errno on failure.
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.
304 int devm_regulator_bulk_register_supply_alias(struct device
*dev
,
305 const char *const *id
,
306 struct device
*alias_dev
,
307 const char *const *alias_id
,
313 for (i
= 0; i
< num_id
; ++i
) {
314 ret
= devm_regulator_register_supply_alias(dev
, id
[i
],
325 "Failed to create supply alias %s,%s -> %s,%s\n",
326 id
[i
], dev_name(dev
), alias_id
[i
], dev_name(alias_dev
));
329 devm_regulator_unregister_supply_alias(dev
, id
[i
]);
333 EXPORT_SYMBOL_GPL(devm_regulator_bulk_register_supply_alias
);
335 struct regulator_notifier_match
{
336 struct regulator
*regulator
;
337 struct notifier_block
*nb
;
340 static int devm_regulator_match_notifier(struct device
*dev
, void *res
,
343 struct regulator_notifier_match
*match
= res
;
344 struct regulator_notifier_match
*target
= data
;
346 return match
->regulator
== target
->regulator
&& match
->nb
== target
->nb
;
349 static void devm_regulator_destroy_notifier(struct device
*dev
, void *res
)
351 struct regulator_notifier_match
*match
= res
;
353 regulator_unregister_notifier(match
->regulator
, match
->nb
);
357 * devm_regulator_register_notifier - Resource managed
358 * regulator_register_notifier
360 * @regulator: regulator source
361 * @nb: notifier block
363 * The notifier will be registers under the consumer device and be
364 * automatically be unregistered when the source device is unbound.
366 int devm_regulator_register_notifier(struct regulator
*regulator
,
367 struct notifier_block
*nb
)
369 struct regulator_notifier_match
*match
;
372 match
= devres_alloc(devm_regulator_destroy_notifier
,
373 sizeof(struct regulator_notifier_match
),
378 match
->regulator
= regulator
;
381 ret
= regulator_register_notifier(regulator
, nb
);
387 devres_add(regulator
->dev
, match
);
391 EXPORT_SYMBOL_GPL(devm_regulator_register_notifier
);
394 * devm_regulator_unregister_notifier - Resource managed
395 * regulator_unregister_notifier()
397 * @regulator: regulator source
398 * @nb: notifier block
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.
404 void devm_regulator_unregister_notifier(struct regulator
*regulator
,
405 struct notifier_block
*nb
)
407 struct regulator_notifier_match match
;
410 match
.regulator
= regulator
;
413 rc
= devres_release(regulator
->dev
, devm_regulator_destroy_notifier
,
414 devm_regulator_match_notifier
, &match
);
418 EXPORT_SYMBOL_GPL(devm_regulator_unregister_notifier
);
420 static void regulator_irq_helper_drop(void *res
)
422 regulator_irq_helper_cancel(&res
);
426 * devm_regulator_irq_helper - resource managed registration of IRQ based
427 * regulator event/error notifier
429 * @dev: device to which lifetime the helper's lifetime is
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
444 * @rdev: Array of pointers to regulators associated with this
446 * @rdev_amount: Amount of regulators associated with this IRQ.
448 * Return: handle to irq_helper or an ERR_PTR() encoded error code.
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
,
454 struct regulator_dev
**rdev
, int rdev_amount
)
459 ptr
= regulator_irq_helper(dev
, d
, irq
, irq_flags
, common_errs
,
460 per_rdev_errs
, rdev
, rdev_amount
);
464 ret
= devm_add_action_or_reset(dev
, regulator_irq_helper_drop
, ptr
);
470 EXPORT_SYMBOL_GPL(devm_regulator_irq_helper
);