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 static int devm_rdev_match(struct device *dev, void *res, void *data)
210 struct regulator_dev **r = res;
219 * devm_regulator_unregister - Resource managed regulator_unregister()
220 * @dev: device to supply
221 * @rdev: regulator to free
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.
227 void devm_regulator_unregister(struct device *dev, struct regulator_dev *rdev)
231 rc = devres_release(dev, devm_rdev_release, devm_rdev_match, rdev);
235 EXPORT_SYMBOL_GPL(devm_regulator_unregister);
237 struct regulator_supply_alias_match {
242 static int devm_regulator_match_supply_alias(struct device *dev, void *res,
245 struct regulator_supply_alias_match *match = res;
246 struct regulator_supply_alias_match *target = data;
248 return match->dev == target->dev && strcmp(match->id, target->id) == 0;
251 static void devm_regulator_destroy_supply_alias(struct device *dev, void *res)
253 struct regulator_supply_alias_match *match = res;
255 regulator_unregister_supply_alias(match->dev, match->id);
259 * devm_regulator_register_supply_alias - Resource managed
260 * regulator_register_supply_alias()
262 * @dev: device to supply
263 * @id: supply name or regulator ID
264 * @alias_dev: device that should be used to lookup the supply
265 * @alias_id: supply name or regulator ID that should be used to lookup the
268 * The supply alias will automatically be unregistered when the source
271 int devm_regulator_register_supply_alias(struct device *dev, const char *id,
272 struct device *alias_dev,
273 const char *alias_id)
275 struct regulator_supply_alias_match *match;
278 match = devres_alloc(devm_regulator_destroy_supply_alias,
279 sizeof(struct regulator_supply_alias_match),
287 ret = regulator_register_supply_alias(dev, id, alias_dev, alias_id);
293 devres_add(dev, match);
297 EXPORT_SYMBOL_GPL(devm_regulator_register_supply_alias);
300 * devm_regulator_unregister_supply_alias - Resource managed
301 * regulator_unregister_supply_alias()
303 * @dev: device to supply
304 * @id: supply name or regulator ID
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.
311 void devm_regulator_unregister_supply_alias(struct device *dev, const char *id)
313 struct regulator_supply_alias_match match;
319 rc = devres_release(dev, devm_regulator_destroy_supply_alias,
320 devm_regulator_match_supply_alias, &match);
324 EXPORT_SYMBOL_GPL(devm_regulator_unregister_supply_alias);
327 * devm_regulator_bulk_register_supply_alias - Managed register
330 * @dev: device to supply
331 * @id: list of supply names or regulator IDs
332 * @alias_dev: device that should be used to lookup the supply
333 * @alias_id: list of supply names or regulator IDs that should be used to
335 * @num_id: number of aliases to register
337 * @return 0 on success, an errno on failure.
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.
345 int devm_regulator_bulk_register_supply_alias(struct device *dev,
346 const char *const *id,
347 struct device *alias_dev,
348 const char *const *alias_id,
354 for (i = 0; i < num_id; ++i) {
355 ret = devm_regulator_register_supply_alias(dev, id[i],
366 "Failed to create supply alias %s,%s -> %s,%s\n",
367 id[i], dev_name(dev), alias_id[i], dev_name(alias_dev));
370 devm_regulator_unregister_supply_alias(dev, id[i]);
374 EXPORT_SYMBOL_GPL(devm_regulator_bulk_register_supply_alias);
377 * devm_regulator_bulk_unregister_supply_alias - Managed unregister
380 * @dev: device to supply
381 * @id: list of supply names or regulator IDs
382 * @num_id: number of aliases to unregister
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.
389 void devm_regulator_bulk_unregister_supply_alias(struct device *dev,
390 const char *const *id,
395 for (i = 0; i < num_id; ++i)
396 devm_regulator_unregister_supply_alias(dev, id[i]);
398 EXPORT_SYMBOL_GPL(devm_regulator_bulk_unregister_supply_alias);
400 struct regulator_notifier_match {
401 struct regulator *regulator;
402 struct notifier_block *nb;
405 static int devm_regulator_match_notifier(struct device *dev, void *res,
408 struct regulator_notifier_match *match = res;
409 struct regulator_notifier_match *target = data;
411 return match->regulator == target->regulator && match->nb == target->nb;
414 static void devm_regulator_destroy_notifier(struct device *dev, void *res)
416 struct regulator_notifier_match *match = res;
418 regulator_unregister_notifier(match->regulator, match->nb);
422 * devm_regulator_register_notifier - Resource managed
423 * regulator_register_notifier
425 * @regulator: regulator source
426 * @nb: notifier block
428 * The notifier will be registers under the consumer device and be
429 * automatically be unregistered when the source device is unbound.
431 int devm_regulator_register_notifier(struct regulator *regulator,
432 struct notifier_block *nb)
434 struct regulator_notifier_match *match;
437 match = devres_alloc(devm_regulator_destroy_notifier,
438 sizeof(struct regulator_notifier_match),
443 match->regulator = regulator;
446 ret = regulator_register_notifier(regulator, nb);
452 devres_add(regulator->dev, match);
456 EXPORT_SYMBOL_GPL(devm_regulator_register_notifier);
459 * devm_regulator_unregister_notifier - Resource managed
460 * regulator_unregister_notifier()
462 * @regulator: regulator source
463 * @nb: notifier block
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.
469 void devm_regulator_unregister_notifier(struct regulator *regulator,
470 struct notifier_block *nb)
472 struct regulator_notifier_match match;
475 match.regulator = regulator;
478 rc = devres_release(regulator->dev, devm_regulator_destroy_notifier,
479 devm_regulator_match_notifier, &match);
483 EXPORT_SYMBOL_GPL(devm_regulator_unregister_notifier);