mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-21 08:19:28 +00:00
![Matti Vaittinen](/assets/img/avatar_default.png)
Provide helper function for IC's implementing regulator notifications when an IRQ fires. The helper also works for IRQs which can not be acked. Helper can be set to disable the IRQ at handler and then re-enabling it on delayed work later. The helper also adds regulator_get_error_flags() errors in cache for the duration of IRQ disabling. Signed-off-by: Matti Vaittinen <matti.vaittinen@fi.rohmeurope.com> Reviewed-by: Andy Shevchenko <andy.shevchenko@gmail.com> Link: https://lore.kernel.org/r/ebdf86d8c22b924667ec2385330e30fcbfac0119.1622628334.git.matti.vaittinen@fi.rohmeurope.com Signed-off-by: Mark Brown <broonie@kernel.org>
535 lines
14 KiB
C
535 lines
14 KiB
C
// 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);
|
|
|
|
static int devm_rdev_match(struct device *dev, void *res, void *data)
|
|
{
|
|
struct regulator_dev **r = res;
|
|
if (!r || !*r) {
|
|
WARN_ON(!r || !*r);
|
|
return 0;
|
|
}
|
|
return *r == data;
|
|
}
|
|
|
|
/**
|
|
* devm_regulator_unregister - Resource managed regulator_unregister()
|
|
* @dev: device to supply
|
|
* @rdev: regulator to free
|
|
*
|
|
* Unregister a regulator registered with devm_regulator_register().
|
|
* 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(struct device *dev, struct regulator_dev *rdev)
|
|
{
|
|
int rc;
|
|
|
|
rc = devres_release(dev, devm_rdev_release, devm_rdev_match, rdev);
|
|
if (rc != 0)
|
|
WARN_ON(rc);
|
|
}
|
|
EXPORT_SYMBOL_GPL(devm_regulator_unregister);
|
|
|
|
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);
|
|
|
|
/**
|
|
* devm_regulator_unregister_supply_alias - Resource managed
|
|
* regulator_unregister_supply_alias()
|
|
*
|
|
* @dev: device to supply
|
|
* @id: supply name or regulator ID
|
|
*
|
|
* Unregister an alias registered with
|
|
* devm_regulator_register_supply_alias(). 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_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);
|
|
}
|
|
EXPORT_SYMBOL_GPL(devm_regulator_unregister_supply_alias);
|
|
|
|
/**
|
|
* 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);
|
|
|
|
/**
|
|
* devm_regulator_bulk_unregister_supply_alias - Managed unregister
|
|
* multiple aliases
|
|
*
|
|
* @dev: device to supply
|
|
* @id: list of supply names or regulator IDs
|
|
* @num_id: number of aliases to unregister
|
|
*
|
|
* Unregister aliases registered with
|
|
* devm_regulator_bulk_register_supply_alias(). Normally this function
|
|
* will not need to be called and the resource management code
|
|
* will ensure that the resource is freed.
|
|
*/
|
|
void devm_regulator_bulk_unregister_supply_alias(struct device *dev,
|
|
const char *const *id,
|
|
int num_id)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < num_id; ++i)
|
|
devm_regulator_unregister_supply_alias(dev, id[i]);
|
|
}
|
|
EXPORT_SYMBOL_GPL(devm_regulator_bulk_unregister_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);
|