forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
470 lines
13 KiB
470 lines
13 KiB
// SPDX-License-Identifier: GPL-2.0-or-later |
|
/* |
|
* devres.c -- Voltage/Current Regulator framework devres implementation. |
|
* |
|
* Copyright 2013 Linaro Ltd |
|
*/ |
|
|
|
#include <linux/kernel.h> |
|
#include <linux/err.h> |
|
#include <linux/regmap.h> |
|
#include <linux/regulator/consumer.h> |
|
#include <linux/regulator/driver.h> |
|
#include <linux/module.h> |
|
|
|
#include "internal.h" |
|
|
|
static void devm_regulator_release(struct device *dev, void *res) |
|
{ |
|
regulator_put(*(struct regulator **)res); |
|
} |
|
|
|
static struct regulator *_devm_regulator_get(struct device *dev, const char *id, |
|
int get_type) |
|
{ |
|
struct regulator **ptr, *regulator; |
|
|
|
ptr = devres_alloc(devm_regulator_release, sizeof(*ptr), GFP_KERNEL); |
|
if (!ptr) |
|
return ERR_PTR(-ENOMEM); |
|
|
|
regulator = _regulator_get(dev, id, get_type); |
|
if (!IS_ERR(regulator)) { |
|
*ptr = regulator; |
|
devres_add(dev, ptr); |
|
} else { |
|
devres_free(ptr); |
|
} |
|
|
|
return regulator; |
|
} |
|
|
|
/** |
|
* devm_regulator_get - Resource managed regulator_get() |
|
* @dev: device to supply |
|
* @id: supply name or regulator ID. |
|
* |
|
* Managed regulator_get(). Regulators returned from this function are |
|
* automatically regulator_put() on driver detach. See regulator_get() for more |
|
* information. |
|
*/ |
|
struct regulator *devm_regulator_get(struct device *dev, const char *id) |
|
{ |
|
return _devm_regulator_get(dev, id, NORMAL_GET); |
|
} |
|
EXPORT_SYMBOL_GPL(devm_regulator_get); |
|
|
|
/** |
|
* devm_regulator_get_exclusive - Resource managed regulator_get_exclusive() |
|
* @dev: device to supply |
|
* @id: supply name or regulator ID. |
|
* |
|
* Managed regulator_get_exclusive(). Regulators returned from this function |
|
* are automatically regulator_put() on driver detach. See regulator_get() for |
|
* more information. |
|
*/ |
|
struct regulator *devm_regulator_get_exclusive(struct device *dev, |
|
const char *id) |
|
{ |
|
return _devm_regulator_get(dev, id, EXCLUSIVE_GET); |
|
} |
|
EXPORT_SYMBOL_GPL(devm_regulator_get_exclusive); |
|
|
|
/** |
|
* devm_regulator_get_optional - Resource managed regulator_get_optional() |
|
* @dev: device to supply |
|
* @id: supply name or regulator ID. |
|
* |
|
* Managed regulator_get_optional(). Regulators returned from this |
|
* function are automatically regulator_put() on driver detach. See |
|
* regulator_get_optional() for more information. |
|
*/ |
|
struct regulator *devm_regulator_get_optional(struct device *dev, |
|
const char *id) |
|
{ |
|
return _devm_regulator_get(dev, id, OPTIONAL_GET); |
|
} |
|
EXPORT_SYMBOL_GPL(devm_regulator_get_optional); |
|
|
|
static int devm_regulator_match(struct device *dev, void *res, void *data) |
|
{ |
|
struct regulator **r = res; |
|
if (!r || !*r) { |
|
WARN_ON(!r || !*r); |
|
return 0; |
|
} |
|
return *r == data; |
|
} |
|
|
|
/** |
|
* devm_regulator_put - Resource managed regulator_put() |
|
* @regulator: regulator to free |
|
* |
|
* Deallocate a regulator allocated with devm_regulator_get(). Normally |
|
* this function will not need to be called and the resource management |
|
* code will ensure that the resource is freed. |
|
*/ |
|
void devm_regulator_put(struct regulator *regulator) |
|
{ |
|
int rc; |
|
|
|
rc = devres_release(regulator->dev, devm_regulator_release, |
|
devm_regulator_match, regulator); |
|
if (rc != 0) |
|
WARN_ON(rc); |
|
} |
|
EXPORT_SYMBOL_GPL(devm_regulator_put); |
|
|
|
struct regulator_bulk_devres { |
|
struct regulator_bulk_data *consumers; |
|
int num_consumers; |
|
}; |
|
|
|
static void devm_regulator_bulk_release(struct device *dev, void *res) |
|
{ |
|
struct regulator_bulk_devres *devres = res; |
|
|
|
regulator_bulk_free(devres->num_consumers, devres->consumers); |
|
} |
|
|
|
/** |
|
* devm_regulator_bulk_get - managed get multiple regulator consumers |
|
* |
|
* @dev: device to supply |
|
* @num_consumers: number of consumers to register |
|
* @consumers: configuration of consumers; clients are stored here. |
|
* |
|
* @return 0 on success, an errno on failure. |
|
* |
|
* This helper function allows drivers to get several regulator |
|
* consumers in one operation with management, the regulators will |
|
* automatically be freed when the device is unbound. If any of the |
|
* regulators cannot be acquired then any regulators that were |
|
* allocated will be freed before returning to the caller. |
|
*/ |
|
int devm_regulator_bulk_get(struct device *dev, int num_consumers, |
|
struct regulator_bulk_data *consumers) |
|
{ |
|
struct regulator_bulk_devres *devres; |
|
int ret; |
|
|
|
devres = devres_alloc(devm_regulator_bulk_release, |
|
sizeof(*devres), GFP_KERNEL); |
|
if (!devres) |
|
return -ENOMEM; |
|
|
|
ret = regulator_bulk_get(dev, num_consumers, consumers); |
|
if (!ret) { |
|
devres->consumers = consumers; |
|
devres->num_consumers = num_consumers; |
|
devres_add(dev, devres); |
|
} else { |
|
devres_free(devres); |
|
} |
|
|
|
return ret; |
|
} |
|
EXPORT_SYMBOL_GPL(devm_regulator_bulk_get); |
|
|
|
static void devm_rdev_release(struct device *dev, void *res) |
|
{ |
|
regulator_unregister(*(struct regulator_dev **)res); |
|
} |
|
|
|
/** |
|
* devm_regulator_register - Resource managed regulator_register() |
|
* @dev: device to supply |
|
* @regulator_desc: regulator to register |
|
* @config: runtime configuration for regulator |
|
* |
|
* Called by regulator drivers to register a regulator. Returns a |
|
* valid pointer to struct regulator_dev on success or an ERR_PTR() on |
|
* error. The regulator will automatically be released when the device |
|
* is unbound. |
|
*/ |
|
struct regulator_dev *devm_regulator_register(struct device *dev, |
|
const struct regulator_desc *regulator_desc, |
|
const struct regulator_config *config) |
|
{ |
|
struct regulator_dev **ptr, *rdev; |
|
|
|
ptr = devres_alloc(devm_rdev_release, sizeof(*ptr), |
|
GFP_KERNEL); |
|
if (!ptr) |
|
return ERR_PTR(-ENOMEM); |
|
|
|
rdev = regulator_register(regulator_desc, config); |
|
if (!IS_ERR(rdev)) { |
|
*ptr = rdev; |
|
devres_add(dev, ptr); |
|
} else { |
|
devres_free(ptr); |
|
} |
|
|
|
return rdev; |
|
} |
|
EXPORT_SYMBOL_GPL(devm_regulator_register); |
|
|
|
struct regulator_supply_alias_match { |
|
struct device *dev; |
|
const char *id; |
|
}; |
|
|
|
static int devm_regulator_match_supply_alias(struct device *dev, void *res, |
|
void *data) |
|
{ |
|
struct regulator_supply_alias_match *match = res; |
|
struct regulator_supply_alias_match *target = data; |
|
|
|
return match->dev == target->dev && strcmp(match->id, target->id) == 0; |
|
} |
|
|
|
static void devm_regulator_destroy_supply_alias(struct device *dev, void *res) |
|
{ |
|
struct regulator_supply_alias_match *match = res; |
|
|
|
regulator_unregister_supply_alias(match->dev, match->id); |
|
} |
|
|
|
/** |
|
* devm_regulator_register_supply_alias - Resource managed |
|
* regulator_register_supply_alias() |
|
* |
|
* @dev: device to supply |
|
* @id: supply name or regulator ID |
|
* @alias_dev: device that should be used to lookup the supply |
|
* @alias_id: supply name or regulator ID that should be used to lookup the |
|
* supply |
|
* |
|
* The supply alias will automatically be unregistered when the source |
|
* device is unbound. |
|
*/ |
|
int devm_regulator_register_supply_alias(struct device *dev, const char *id, |
|
struct device *alias_dev, |
|
const char *alias_id) |
|
{ |
|
struct regulator_supply_alias_match *match; |
|
int ret; |
|
|
|
match = devres_alloc(devm_regulator_destroy_supply_alias, |
|
sizeof(struct regulator_supply_alias_match), |
|
GFP_KERNEL); |
|
if (!match) |
|
return -ENOMEM; |
|
|
|
match->dev = dev; |
|
match->id = id; |
|
|
|
ret = regulator_register_supply_alias(dev, id, alias_dev, alias_id); |
|
if (ret < 0) { |
|
devres_free(match); |
|
return ret; |
|
} |
|
|
|
devres_add(dev, match); |
|
|
|
return 0; |
|
} |
|
EXPORT_SYMBOL_GPL(devm_regulator_register_supply_alias); |
|
|
|
static void devm_regulator_unregister_supply_alias(struct device *dev, |
|
const char *id) |
|
{ |
|
struct regulator_supply_alias_match match; |
|
int rc; |
|
|
|
match.dev = dev; |
|
match.id = id; |
|
|
|
rc = devres_release(dev, devm_regulator_destroy_supply_alias, |
|
devm_regulator_match_supply_alias, &match); |
|
if (rc != 0) |
|
WARN_ON(rc); |
|
} |
|
|
|
/** |
|
* devm_regulator_bulk_register_supply_alias - Managed register |
|
* multiple aliases |
|
* |
|
* @dev: device to supply |
|
* @id: list of supply names or regulator IDs |
|
* @alias_dev: device that should be used to lookup the supply |
|
* @alias_id: list of supply names or regulator IDs that should be used to |
|
* lookup the supply |
|
* @num_id: number of aliases to register |
|
* |
|
* @return 0 on success, an errno on failure. |
|
* |
|
* This helper function allows drivers to register several supply |
|
* aliases in one operation, the aliases will be automatically |
|
* unregisters when the source device is unbound. If any of the |
|
* aliases cannot be registered any aliases that were registered |
|
* will be removed before returning to the caller. |
|
*/ |
|
int devm_regulator_bulk_register_supply_alias(struct device *dev, |
|
const char *const *id, |
|
struct device *alias_dev, |
|
const char *const *alias_id, |
|
int num_id) |
|
{ |
|
int i; |
|
int ret; |
|
|
|
for (i = 0; i < num_id; ++i) { |
|
ret = devm_regulator_register_supply_alias(dev, id[i], |
|
alias_dev, |
|
alias_id[i]); |
|
if (ret < 0) |
|
goto err; |
|
} |
|
|
|
return 0; |
|
|
|
err: |
|
dev_err(dev, |
|
"Failed to create supply alias %s,%s -> %s,%s\n", |
|
id[i], dev_name(dev), alias_id[i], dev_name(alias_dev)); |
|
|
|
while (--i >= 0) |
|
devm_regulator_unregister_supply_alias(dev, id[i]); |
|
|
|
return ret; |
|
} |
|
EXPORT_SYMBOL_GPL(devm_regulator_bulk_register_supply_alias); |
|
|
|
struct regulator_notifier_match { |
|
struct regulator *regulator; |
|
struct notifier_block *nb; |
|
}; |
|
|
|
static int devm_regulator_match_notifier(struct device *dev, void *res, |
|
void *data) |
|
{ |
|
struct regulator_notifier_match *match = res; |
|
struct regulator_notifier_match *target = data; |
|
|
|
return match->regulator == target->regulator && match->nb == target->nb; |
|
} |
|
|
|
static void devm_regulator_destroy_notifier(struct device *dev, void *res) |
|
{ |
|
struct regulator_notifier_match *match = res; |
|
|
|
regulator_unregister_notifier(match->regulator, match->nb); |
|
} |
|
|
|
/** |
|
* devm_regulator_register_notifier - Resource managed |
|
* regulator_register_notifier |
|
* |
|
* @regulator: regulator source |
|
* @nb: notifier block |
|
* |
|
* The notifier will be registers under the consumer device and be |
|
* automatically be unregistered when the source device is unbound. |
|
*/ |
|
int devm_regulator_register_notifier(struct regulator *regulator, |
|
struct notifier_block *nb) |
|
{ |
|
struct regulator_notifier_match *match; |
|
int ret; |
|
|
|
match = devres_alloc(devm_regulator_destroy_notifier, |
|
sizeof(struct regulator_notifier_match), |
|
GFP_KERNEL); |
|
if (!match) |
|
return -ENOMEM; |
|
|
|
match->regulator = regulator; |
|
match->nb = nb; |
|
|
|
ret = regulator_register_notifier(regulator, nb); |
|
if (ret < 0) { |
|
devres_free(match); |
|
return ret; |
|
} |
|
|
|
devres_add(regulator->dev, match); |
|
|
|
return 0; |
|
} |
|
EXPORT_SYMBOL_GPL(devm_regulator_register_notifier); |
|
|
|
/** |
|
* devm_regulator_unregister_notifier - Resource managed |
|
* regulator_unregister_notifier() |
|
* |
|
* @regulator: regulator source |
|
* @nb: notifier block |
|
* |
|
* Unregister a notifier registered with devm_regulator_register_notifier(). |
|
* Normally this function will not need to be called and the resource |
|
* management code will ensure that the resource is freed. |
|
*/ |
|
void devm_regulator_unregister_notifier(struct regulator *regulator, |
|
struct notifier_block *nb) |
|
{ |
|
struct regulator_notifier_match match; |
|
int rc; |
|
|
|
match.regulator = regulator; |
|
match.nb = nb; |
|
|
|
rc = devres_release(regulator->dev, devm_regulator_destroy_notifier, |
|
devm_regulator_match_notifier, &match); |
|
if (rc != 0) |
|
WARN_ON(rc); |
|
} |
|
EXPORT_SYMBOL_GPL(devm_regulator_unregister_notifier); |
|
|
|
static void regulator_irq_helper_drop(void *res) |
|
{ |
|
regulator_irq_helper_cancel(&res); |
|
} |
|
|
|
/** |
|
* devm_regulator_irq_helper - resource managed registration of IRQ based |
|
* regulator event/error notifier |
|
* |
|
* @dev: device to which lifetime the helper's lifetime is |
|
* bound. |
|
* @d: IRQ helper descriptor. |
|
* @irq: IRQ used to inform events/errors to be notified. |
|
* @irq_flags: Extra IRQ flags to be OR'ed with the default |
|
* IRQF_ONESHOT when requesting the (threaded) irq. |
|
* @common_errs: Errors which can be flagged by this IRQ for all rdevs. |
|
* When IRQ is re-enabled these errors will be cleared |
|
* from all associated regulators |
|
* @per_rdev_errs: Optional error flag array describing errors specific |
|
* for only some of the regulators. These errors will be |
|
* or'ed with common errors. If this is given the array |
|
* should contain rdev_amount flags. Can be set to NULL |
|
* if there is no regulator specific error flags for this |
|
* IRQ. |
|
* @rdev: Array of pointers to regulators associated with this |
|
* IRQ. |
|
* @rdev_amount: Amount of regulators associated with this IRQ. |
|
* |
|
* Return: handle to irq_helper or an ERR_PTR() encoded error code. |
|
*/ |
|
void *devm_regulator_irq_helper(struct device *dev, |
|
const struct regulator_irq_desc *d, int irq, |
|
int irq_flags, int common_errs, |
|
int *per_rdev_errs, |
|
struct regulator_dev **rdev, int rdev_amount) |
|
{ |
|
void *ptr; |
|
int ret; |
|
|
|
ptr = regulator_irq_helper(dev, d, irq, irq_flags, common_errs, |
|
per_rdev_errs, rdev, rdev_amount); |
|
if (IS_ERR(ptr)) |
|
return ptr; |
|
|
|
ret = devm_add_action_or_reset(dev, regulator_irq_helper_drop, ptr); |
|
if (ret) |
|
return ERR_PTR(ret); |
|
|
|
return ptr; |
|
} |
|
EXPORT_SYMBOL_GPL(devm_regulator_irq_helper);
|
|
|