Something went wrong. Try again.
(I'm so sorry!) Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374// SPDX-License-Identifier: GPL-2.0-or-later/* * reg-virtual-consumer.c * * Copyright 2008 Wolfson Microelectronics PLC. * * Author: Mark Brown <broonie@opensource.wolfsonmicro.com> */
#include <linux/err.h>#include <linux/mutex.h>#include <linux/platform_device.h>#include <linux/regulator/consumer.h>#include <linux/slab.h>#include <linux/module.h>#include <linux/of.h>
struct virtual_consumer_data { struct mutex lock; struct regulator *regulator; bool enabled; int min_uV; int max_uV; int min_uA; int max_uA; unsigned int mode;};
static void update_voltage_constraints(struct device *dev, struct virtual_consumer_data *data){ int ret;
if (data->min_uV && data->max_uV && data->min_uV <= data->max_uV) { dev_dbg(dev, "Requesting %d-%duV\n", data->min_uV, data->max_uV); ret = regulator_set_voltage(data->regulator, data->min_uV, data->max_uV); if (ret != 0) { dev_err(dev, "regulator_set_voltage() failed: %d\n", ret); return; } }
if (data->min_uV && data->max_uV && !data->enabled) { dev_dbg(dev, "Enabling regulator\n"); ret = regulator_enable(data->regulator); if (ret == 0) data->enabled = true; else dev_err(dev, "regulator_enable() failed: %d\n", ret); }
if (!(data->min_uV && data->max_uV) && data->enabled) { dev_dbg(dev, "Disabling regulator\n"); ret = regulator_disable(data->regulator); if (ret == 0) data->enabled = false; else dev_err(dev, "regulator_disable() failed: %d\n", ret); }}
static void update_current_limit_constraints(struct device *dev, struct virtual_consumer_data *data){ int ret;
if (data->max_uA && data->min_uA <= data->max_uA) { dev_dbg(dev, "Requesting %d-%duA\n", data->min_uA, data->max_uA); ret = regulator_set_current_limit(data->regulator, data->min_uA, data->max_uA); if (ret != 0) { dev_err(dev, "regulator_set_current_limit() failed: %d\n", ret); return; } }
if (data->max_uA && !data->enabled) { dev_dbg(dev, "Enabling regulator\n"); ret = regulator_enable(data->regulator); if (ret == 0) data->enabled = true; else dev_err(dev, "regulator_enable() failed: %d\n", ret); }
if (!(data->min_uA && data->max_uA) && data->enabled) { dev_dbg(dev, "Disabling regulator\n"); ret = regulator_disable(data->regulator); if (ret == 0) data->enabled = false; else dev_err(dev, "regulator_disable() failed: %d\n", ret); }}
static ssize_t show_min_uV(struct device *dev, struct device_attribute *attr, char *buf){ struct virtual_consumer_data *data = dev_get_drvdata(dev); return sprintf(buf, "%d\n", data->min_uV);}
static ssize_t set_min_uV(struct device *dev, struct device_attribute *attr, const char *buf, size_t count){ struct virtual_consumer_data *data = dev_get_drvdata(dev); long val;
if (kstrtol(buf, 10, &val) != 0) return count;
mutex_lock(&data->lock);
data->min_uV = val; update_voltage_constraints(dev, data);
mutex_unlock(&data->lock);
return count;}
static ssize_t show_max_uV(struct device *dev, struct device_attribute *attr, char *buf){ struct virtual_consumer_data *data = dev_get_drvdata(dev); return sprintf(buf, "%d\n", data->max_uV);}
static ssize_t set_max_uV(struct device *dev, struct device_attribute *attr, const char *buf, size_t count){ struct virtual_consumer_data *data = dev_get_drvdata(dev); long val;
if (kstrtol(buf, 10, &val) != 0) return count;
mutex_lock(&data->lock);
data->max_uV = val; update_voltage_constraints(dev, data);
mutex_unlock(&data->lock);
return count;}
static ssize_t show_min_uA(struct device *dev, struct device_attribute *attr, char *buf){ struct virtual_consumer_data *data = dev_get_drvdata(dev); return sprintf(buf, "%d\n", data->min_uA);}
static ssize_t set_min_uA(struct device *dev, struct device_attribute *attr, const char *buf, size_t count){ struct virtual_consumer_data *data = dev_get_drvdata(dev); long val;
if (kstrtol(buf, 10, &val) != 0) return count;
mutex_lock(&data->lock);
data->min_uA = val; update_current_limit_constraints(dev, data);
mutex_unlock(&data->lock);
return count;}
static ssize_t show_max_uA(struct device *dev, struct device_attribute *attr, char *buf){ struct virtual_consumer_data *data = dev_get_drvdata(dev); return sprintf(buf, "%d\n", data->max_uA);}
static ssize_t set_max_uA(struct device *dev, struct device_attribute *attr, const char *buf, size_t count){ struct virtual_consumer_data *data = dev_get_drvdata(dev); long val;
if (kstrtol(buf, 10, &val) != 0) return count;
mutex_lock(&data->lock);
data->max_uA = val; update_current_limit_constraints(dev, data);
mutex_unlock(&data->lock);
return count;}
static ssize_t show_mode(struct device *dev, struct device_attribute *attr, char *buf){ struct virtual_consumer_data *data = dev_get_drvdata(dev);
switch (data->mode) { case REGULATOR_MODE_FAST: return sprintf(buf, "fast\n"); case REGULATOR_MODE_NORMAL: return sprintf(buf, "normal\n"); case REGULATOR_MODE_IDLE: return sprintf(buf, "idle\n"); case REGULATOR_MODE_STANDBY: return sprintf(buf, "standby\n"); default: return sprintf(buf, "unknown\n"); }}
static ssize_t set_mode(struct device *dev, struct device_attribute *attr, const char *buf, size_t count){ struct virtual_consumer_data *data = dev_get_drvdata(dev); unsigned int mode; int ret;
/* * sysfs_streq() doesn't need the \n's, but we add them so the strings * will be shared with show_mode(), above. */ if (sysfs_streq(buf, "fast\n")) mode = REGULATOR_MODE_FAST; else if (sysfs_streq(buf, "normal\n")) mode = REGULATOR_MODE_NORMAL; else if (sysfs_streq(buf, "idle\n")) mode = REGULATOR_MODE_IDLE; else if (sysfs_streq(buf, "standby\n")) mode = REGULATOR_MODE_STANDBY; else { dev_err(dev, "Configuring invalid mode\n"); return count; }
mutex_lock(&data->lock); ret = regulator_set_mode(data->regulator, mode); if (ret == 0) data->mode = mode; else dev_err(dev, "Failed to configure mode: %d\n", ret); mutex_unlock(&data->lock);
return count;}
static DEVICE_ATTR(min_microvolts, 0664, show_min_uV, set_min_uV);static DEVICE_ATTR(max_microvolts, 0664, show_max_uV, set_max_uV);static DEVICE_ATTR(min_microamps, 0664, show_min_uA, set_min_uA);static DEVICE_ATTR(max_microamps, 0664, show_max_uA, set_max_uA);static DEVICE_ATTR(mode, 0664, show_mode, set_mode);
static struct attribute *regulator_virtual_attributes[] = { &dev_attr_min_microvolts.attr, &dev_attr_max_microvolts.attr, &dev_attr_min_microamps.attr, &dev_attr_max_microamps.attr, &dev_attr_mode.attr, NULL};
static const struct attribute_group regulator_virtual_attr_group = { .attrs = regulator_virtual_attributes,};
#ifdef CONFIG_OFstatic const struct of_device_id regulator_virtual_consumer_of_match[] = { { .compatible = "regulator-virtual-consumer" }, {},};MODULE_DEVICE_TABLE(of, regulator_virtual_consumer_of_match);#endif
static int regulator_virtual_probe(struct platform_device *pdev){ char *reg_id = dev_get_platdata(&pdev->dev); struct virtual_consumer_data *drvdata; static bool warned; int ret;
if (!warned) { warned = true; pr_warn("**********************************************************\n"); pr_warn("** NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE **\n"); pr_warn("** **\n"); pr_warn("** regulator-virtual-consumer is only for testing and **\n"); pr_warn("** debugging. Do not use it in a production kernel. **\n"); pr_warn("** **\n"); pr_warn("** NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE **\n"); pr_warn("**********************************************************\n"); }
drvdata = devm_kzalloc(&pdev->dev, sizeof(struct virtual_consumer_data), GFP_KERNEL); if (drvdata == NULL) return -ENOMEM;
/* * This virtual consumer does not have any hardware-defined supply * name, so just allow the regulator to be specified in a property * named "default-supply" when we're being probed from devicetree. */ if (!reg_id && pdev->dev.of_node) reg_id = "default";
mutex_init(&drvdata->lock);
drvdata->regulator = devm_regulator_get(&pdev->dev, reg_id); if (IS_ERR(drvdata->regulator)) return dev_err_probe(&pdev->dev, PTR_ERR(drvdata->regulator), "Failed to obtain supply '%s'\n", reg_id);
ret = sysfs_create_group(&pdev->dev.kobj, ®ulator_virtual_attr_group); if (ret != 0) { dev_err(&pdev->dev, "Failed to create attribute group: %d\n", ret); return ret; }
drvdata->mode = regulator_get_mode(drvdata->regulator);
platform_set_drvdata(pdev, drvdata);
return 0;}
static void regulator_virtual_remove(struct platform_device *pdev){ struct virtual_consumer_data *drvdata = platform_get_drvdata(pdev);
sysfs_remove_group(&pdev->dev.kobj, ®ulator_virtual_attr_group);
if (drvdata->enabled) regulator_disable(drvdata->regulator);}
static struct platform_driver regulator_virtual_consumer_driver = { .probe = regulator_virtual_probe, .remove = regulator_virtual_remove, .driver = { .name = "reg-virt-consumer", .probe_type = PROBE_PREFER_ASYNCHRONOUS, .of_match_table = of_match_ptr(regulator_virtual_consumer_of_match), },};
module_platform_driver(regulator_virtual_consumer_driver);
MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");MODULE_DESCRIPTION("Virtual regulator consumer");MODULE_LICENSE("GPL");MODULE_ALIAS("platform:reg-virt-consumer");