evie/android_kernel_oneplus_msm8998
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

regulator: core: clean up debugfs monitoring and control features

Browse source 
Fix checkpatch warnings and other style issues in the regulator
debugfs functions.  Refactor the code to remove unnecessary error
checks as well as a shared buffer and mutex.  Rename variables
and functions to better follow the naming conventions found in
the core.c file.  Update the conditions used for allowing the
creation of 'voltage' and 'load' debugfs files.

Change-Id: I59881078ce9e908de11e74d15372edf233eb17b0
Signed-off-by: David Collins <collinsd@codeaurora.org>
This commit is contained in:
David Collins 2017-01-11 14:07:51 -08:00
parent 2dc96b1cbb
commit 6e51ed6ba9
1 changed files with 144 additions and 225 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

369
drivers/regulator/core.c
View file

@ -3900,38 +3900,34 @@ static struct class regulator_class = {
#ifdef CONFIG_DEBUG_FS #ifdef CONFIG_DEBUG_FS
#define MAX_DEBUG_BUF_LEN 50
static DEFINE_MUTEX(debug_buf_mutex);
static char debug_buf[MAX_DEBUG_BUF_LEN];
static int reg_debug_enable_set(void *data, u64 val) static int reg_debug_enable_set(void *data, u64 val)
{ {
int err_info; struct regulator *regulator = data;
if (IS_ERR(data) || data == NULL) { int ret;
pr_err("Function Input Error %ld\n", PTR_ERR(data));
return -ENOMEM; if (val) {
ret = regulator_enable(regulator);
if (ret)
rdev_err(regulator->rdev, "enable failed, ret=%d\n",
ret);
} else {
ret = regulator_disable(regulator);
if (ret)
rdev_err(regulator->rdev, "disable failed, ret=%d\n",
ret);
} }
if (val) return ret;
err_info = regulator_enable(data);
else
err_info = regulator_disable(data);
return err_info;
} }
static int reg_debug_enable_get(void *data, u64 *val) static int reg_debug_enable_get(void *data, u64 *val)
{ {
if (IS_ERR(data) || data == NULL) { struct regulator *regulator = data;
pr_err("Function Input Error %ld\n", PTR_ERR(data));
return -ENOMEM; *val = regulator_is_enabled(regulator);
}
*val = regulator_is_enabled(data);
return 0; return 0;
} }
DEFINE_SIMPLE_ATTRIBUTE(reg_enable_fops, reg_debug_enable_get, DEFINE_SIMPLE_ATTRIBUTE(reg_enable_fops, reg_debug_enable_get,
reg_debug_enable_set, "%llu\n"); reg_debug_enable_set, "%llu\n");
@ -3940,13 +3936,13 @@ static int reg_debug_bypass_enable_get(void *data, u64 *val)
struct regulator *regulator = data; struct regulator *regulator = data;
struct regulator_dev *rdev = regulator->rdev; struct regulator_dev *rdev = regulator->rdev;
bool enable = false; bool enable = false;
int rc = 0; int ret = 0;
mutex_lock(&rdev->mutex); mutex_lock(&rdev->mutex);
if (rdev->desc->ops->get_bypass) { if (rdev->desc->ops->get_bypass) {
rc = rdev->desc->ops->get_bypass(rdev, &enable); ret = rdev->desc->ops->get_bypass(rdev, &enable);
if (rc) if (ret)
pr_err("get_bypass() failed, rc=%d\n", rc); rdev_err(rdev, "get_bypass() failed, ret=%d\n", ret);
} else { } else {
enable = (rdev->bypass_count == rdev->open_count enable = (rdev->bypass_count == rdev->open_count
- rdev->open_offset); - rdev->open_offset);
@ -3955,7 +3951,7 @@ static int reg_debug_bypass_enable_get(void *data, u64 *val)
*val = enable; *val = enable;
return rc; return ret;
} }
static int reg_debug_bypass_enable_set(void *data, u64 val) static int reg_debug_bypass_enable_set(void *data, u64 val)
@ -3975,155 +3971,133 @@ static int reg_debug_bypass_enable_set(void *data, u64 val)
DEFINE_SIMPLE_ATTRIBUTE(reg_bypass_enable_fops, reg_debug_bypass_enable_get, DEFINE_SIMPLE_ATTRIBUTE(reg_bypass_enable_fops, reg_debug_bypass_enable_get,
reg_debug_bypass_enable_set, "%llu\n"); reg_debug_bypass_enable_set, "%llu\n");
static int reg_debug_fdisable_set(void *data, u64 val) static int reg_debug_force_disable_set(void *data, u64 val)
{ {
int err_info; struct regulator *regulator = data;
if (IS_ERR(data) || data == NULL) { int ret = 0;
pr_err("Function Input Error %ld\n", PTR_ERR(data));
return -ENOMEM; if (val > 0) {
ret = regulator_force_disable(regulator);
if (ret)
rdev_err(regulator->rdev, "force_disable failed, ret=%d\n",
ret);
} }
if (val > 0) return ret;
err_info = regulator_force_disable(data);
else
err_info = 0;
return err_info;
} }
DEFINE_SIMPLE_ATTRIBUTE(reg_force_disable_fops, reg_debug_enable_get,
reg_debug_force_disable_set, "%llu\n");
DEFINE_SIMPLE_ATTRIBUTE(reg_fdisable_fops, reg_debug_enable_get, #define MAX_DEBUG_BUF_LEN 50
reg_debug_fdisable_set, "%llu\n");
static ssize_t reg_debug_volt_set(struct file *file, const char __user *buf, static ssize_t reg_debug_voltage_write(struct file *file,
size_t count, loff_t *ppos) const char __user *ubuf, size_t count, loff_t *ppos)
{ {
int err_info, filled; struct regulator *regulator = file->private_data;
int min, max = -1; char buf[MAX_DEBUG_BUF_LEN];
if (IS_ERR(file) || file == NULL) { int ret, filled;
pr_err("Function Input Error %ld\n", PTR_ERR(file)); int min_uV, max_uV = -1;
return -ENOMEM;
}
if (count < MAX_DEBUG_BUF_LEN) { if (count < MAX_DEBUG_BUF_LEN) {
mutex_lock(&debug_buf_mutex); if (copy_from_user(buf, ubuf, count))
if (copy_from_user(debug_buf, (void __user *) buf, count))
return -EFAULT; return -EFAULT;
debug_buf[count] = '\0'; buf[count] = '\0';
filled = sscanf(debug_buf, "%d %d", &min, &max); filled = sscanf(buf, "%d %d", &min_uV, &max_uV);
mutex_unlock(&debug_buf_mutex); /* Check that both min and max voltage were specified. */
/* check that user entered two numbers */ if (filled < 2 || min_uV < 0 || max_uV < min_uV) {
if (filled < 2 || min < 0 || max < min) { rdev_err(regulator->rdev, "incorrect values specified: \"%s\"; should be: \"min_uV max_uV\"\n",
pr_info("Error, correct format: 'echo \"min max\"" buf);
" > voltage"); return -EINVAL;
return -ENOMEM; }
} else {
err_info = regulator_set_voltage(file->private_data, ret = regulator_set_voltage(regulator, min_uV, max_uV);
min, max); if (ret) {
rdev_err(regulator->rdev, "set voltage(%d, %d) failed, ret=%d\n",
min_uV, max_uV, ret);
return ret;
} }
} else { } else {
pr_err("Error-Input voltage pair" rdev_err(regulator->rdev, "voltage request string exceeds maximum buffer size\n");
" string exceeds maximum buffer length"); return -EINVAL;
return -ENOMEM;
} }
return count; return count;
} }
static ssize_t reg_debug_volt_get(struct file *file, char __user *buf, static ssize_t reg_debug_voltage_read(struct file *file, char __user *ubuf,
size_t count, loff_t *ppos) size_t count, loff_t *ppos)
{ {
int voltage, output, rc; struct regulator *regulator = file->private_data;
if (IS_ERR(file) || file == NULL) { char buf[MAX_DEBUG_BUF_LEN];
pr_err("Function Input Error %ld\n", PTR_ERR(file)); int voltage, ret;
return -ENOMEM;
}
voltage = regulator_get_voltage(file->private_data); voltage = regulator_get_voltage(regulator);
mutex_lock(&debug_buf_mutex);
output = snprintf(debug_buf, MAX_DEBUG_BUF_LEN-1, "%d\n", voltage); ret = snprintf(buf, MAX_DEBUG_BUF_LEN - 1, "%d\n", voltage);
rc = simple_read_from_buffer((void __user *) buf, output, ppos,
(void *) debug_buf, output);
mutex_unlock(&debug_buf_mutex); return simple_read_from_buffer(ubuf, count, ppos, buf, ret);
return rc;
} }
static int reg_debug_volt_open(struct inode *inode, struct file *file) static int reg_debug_voltage_open(struct inode *inode, struct file *file)
{ {
if (IS_ERR(file) || file == NULL) {
pr_err("Function Input Error %ld\n", PTR_ERR(file));
return -ENOMEM;
}
file->private_data = inode->i_private; file->private_data = inode->i_private;
return 0; return 0;
} }
static const struct file_operations reg_volt_fops = { static const struct file_operations reg_voltage_fops = {
.write = reg_debug_volt_set, .write = reg_debug_voltage_write,
.open = reg_debug_volt_open, .open = reg_debug_voltage_open,
.read = reg_debug_volt_get, .read = reg_debug_voltage_read,
}; };
static int reg_debug_mode_set(void *data, u64 val) static int reg_debug_mode_set(void *data, u64 val)
{ {
int err_info; struct regulator *regulator = data;
if (IS_ERR(data) || data == NULL) { unsigned int mode = val;
pr_err("Function Input Error %ld\n", PTR_ERR(data)); int ret;
return -ENOMEM;
}
err_info = regulator_set_mode(data, (unsigned int)val); ret = regulator_set_mode(regulator, mode);
if (ret)
rdev_err(regulator->rdev, "set mode=%u failed, ret=%d\n",
mode, ret);
return err_info; return ret;
} }
static int reg_debug_mode_get(void *data, u64 *val) static int reg_debug_mode_get(void *data, u64 *val)
{ {
int err_info; struct regulator *regulator = data;
if (IS_ERR(data) || data == NULL) { int mode;
pr_err("Function Input Error %ld\n", PTR_ERR(data));
return -ENOMEM; mode = regulator_get_mode(regulator);
if (mode < 0) {
rdev_err(regulator->rdev, "get mode failed, ret=%d\n", mode);
return mode;
} }
err_info = regulator_get_mode(data); *val = mode;
if (err_info < 0) {
pr_err("Regulator_get_mode returned an error!\n");
return -ENOMEM;
} else {
*val = err_info;
return 0;
}
}
DEFINE_SIMPLE_ATTRIBUTE(reg_mode_fops, reg_debug_mode_get,
reg_debug_mode_set, "%llu\n");
static int reg_debug_set_load(void *data, u64 val)
{
int err_info;
if (IS_ERR(data) || data == NULL) {
pr_err("Function Input Error %ld\n", PTR_ERR(data));
return -ENOMEM;
}
err_info = regulator_set_load(data, (unsigned int)val);
if (err_info < 0) {
pr_err("Regulator_set_optimum_mode returned an error!\n");
return err_info;
}
return 0; return 0;
} }
DEFINE_SIMPLE_ATTRIBUTE(reg_mode_fops, reg_debug_mode_get, reg_debug_mode_set,
"%llu\n");
static int reg_debug_set_load(void *data, u64 val)
{
struct regulator *regulator = data;
int load = val;
int ret;
ret = regulator_set_load(regulator, load);
if (ret)
rdev_err(regulator->rdev, "set load=%d failed, ret=%d\n",
load, ret);
return ret;
}
DEFINE_SIMPLE_ATTRIBUTE(reg_set_load_fops, reg_debug_mode_get, DEFINE_SIMPLE_ATTRIBUTE(reg_set_load_fops, reg_debug_mode_get,
reg_debug_set_load, "%llu\n"); reg_debug_set_load, "%llu\n");
@ -4133,17 +4107,12 @@ static int reg_debug_consumers_show(struct seq_file *m, void *v)
struct regulator *reg; struct regulator *reg;
char *supply_name; char *supply_name;
if (!rdev) {
pr_err("regulator device missing");
return -EINVAL;
}
mutex_lock(&rdev->mutex); mutex_lock(&rdev->mutex);
/* Print a header if there are consumers. */ /* Print a header if there are consumers. */
if (rdev->open_count) if (rdev->open_count)
seq_printf(m, "Device-Supply " seq_printf(m, "%-32s EN Min_uV Max_uV load_uA\n",
"EN Min_uV Max_uV load_uA\n"); "Device-Supply");
list_for_each_entry(reg, &rdev->consumer_list, list) { list_for_each_entry(reg, &rdev->consumer_list, list) {
if (reg->supply_name) if (reg->supply_name)
@ -4189,17 +4158,10 @@ static void rdev_init_debugfs(struct regulator_dev *rdev)
struct device *parent = rdev->dev.parent; struct device *parent = rdev->dev.parent;
const char *rname = rdev_get_name(rdev); const char *rname = rdev_get_name(rdev);
char name[NAME_MAX]; char name[NAME_MAX];
struct dentry *err_ptr = NULL; struct regulator *regulator;
struct regulator *reg; const struct regulator_ops *ops;
const struct regulator_ops *reg_ops;
mode_t mode; mode_t mode;
if (IS_ERR(rdev) || rdev == NULL ||
IS_ERR(debugfs_root) || debugfs_root == NULL) {
pr_err("Error-Bad Function Input\n");
goto error;
}
/* Avoid duplicate debugfs directory names */ /* Avoid duplicate debugfs directory names */
if (parent && rname == rdev->desc->name) { if (parent && rname == rdev->desc->name) {
snprintf(name, sizeof(name), "%s-%s", dev_name(parent), snprintf(name, sizeof(name), "%s-%s", dev_name(parent),
@ -4210,8 +4172,7 @@ static void rdev_init_debugfs(struct regulator_dev *rdev)
rdev->debugfs = debugfs_create_dir(rname, debugfs_root); rdev->debugfs = debugfs_create_dir(rname, debugfs_root);
if (!rdev->debugfs) { if (!rdev->debugfs) {
rdev_warn(rdev, "Failed to create debugfs directory\n"); rdev_warn(rdev, "Failed to create debugfs directory\n");
rdev->debugfs = NULL; return;
goto error;
} }
debugfs_create_u32("use_count", 0444, rdev->debugfs, debugfs_create_u32("use_count", 0444, rdev->debugfs,
@ -4223,100 +4184,58 @@ static void rdev_init_debugfs(struct regulator_dev *rdev)
debugfs_create_file("consumers", 0444, rdev->debugfs, rdev, debugfs_create_file("consumers", 0444, rdev->debugfs, rdev,
&reg_consumers_fops); &reg_consumers_fops);
reg = regulator_get(NULL, rdev_get_name(rdev)); regulator = regulator_get(NULL, rdev_get_name(rdev));
if (IS_ERR(reg) || reg == NULL) { if (IS_ERR(regulator)) {
pr_err("Error-Bad Function Input\n"); rdev_err(rdev, "regulator get failed, ret=%ld\n",
goto error; PTR_ERR(regulator));
return;
} }
rdev->debug_consumer = reg; rdev->debug_consumer = regulator;
rdev->open_offset = 1; rdev->open_offset = 1;
reg_ops = rdev->desc->ops; ops = rdev->desc->ops;
mode = S_IRUGO | S_IWUSR;
/* Enabled File */ debugfs_create_file("enable", 0644, rdev->debugfs, regulator,
if (mode) &reg_enable_fops);
err_ptr = debugfs_create_file("enable", mode, rdev->debugfs, if (ops->set_bypass)
reg, &reg_enable_fops); debugfs_create_file("bypass", 0644, rdev->debugfs, regulator,
if (IS_ERR(err_ptr)) { &reg_bypass_enable_fops);
pr_err("Error-Could not create enable file\n");
goto error;
}
mode = 0; mode = 0;
/* Bypass Enable File */ if (ops->is_enabled)
if (reg_ops->set_bypass) mode |= 0444;
mode = S_IWUSR | S_IRUGO; if (ops->disable)
mode |= 0200;
if (mode) if (mode)
err_ptr = debugfs_create_file("bypass", mode, debugfs_create_file("force_disable", mode, rdev->debugfs,
rdev->debugfs, reg, regulator, &reg_force_disable_fops);
&reg_bypass_enable_fops);
if (IS_ERR(err_ptr)) {
pr_err("Error-Could not create bypass enable file\n");
goto error;
}
mode = 0; mode = 0;
/* Force-Disable File */ if (ops->get_voltage || ops->get_voltage_sel)
if (reg_ops->is_enabled) mode |= 0444;
mode |= S_IRUGO; if (ops->set_voltage || ops->set_voltage_sel)
if (reg_ops->enable || reg_ops->disable) mode |= 0200;
mode |= S_IWUSR;
if (mode) if (mode)
err_ptr = debugfs_create_file("force_disable", mode, debugfs_create_file("voltage", mode, rdev->debugfs, regulator,
rdev->debugfs, reg, &reg_fdisable_fops); &reg_voltage_fops);
if (IS_ERR(err_ptr)) {
pr_err("Error-Could not create force_disable file\n");
goto error;
}
mode = 0; mode = 0;
/* Voltage File */ if (ops->get_mode)
if (reg_ops->get_voltage) mode |= 0444;
mode |= S_IRUGO; if (ops->set_mode)
if (reg_ops->set_voltage) mode |= 0200;
mode |= S_IWUSR;
if (mode) if (mode)
err_ptr = debugfs_create_file("voltage", mode, rdev->debugfs, debugfs_create_file("mode", mode, rdev->debugfs, regulator,
reg, &reg_volt_fops); &reg_mode_fops);
if (IS_ERR(err_ptr)) {
pr_err("Error-Could not create voltage file\n");
goto error;
}
mode = 0; mode = 0;
/* Mode File */ if (ops->get_mode)
if (reg_ops->get_mode) mode |= 0444;
mode |= S_IRUGO; if (ops->set_load || (ops->get_optimum_mode && ops->set_mode))
if (reg_ops->set_mode) mode |= 0200;
mode |= S_IWUSR;
if (mode) if (mode)
err_ptr = debugfs_create_file("mode", mode, rdev->debugfs, debugfs_create_file("load", mode, rdev->debugfs, regulator,
reg, &reg_mode_fops); &reg_set_load_fops);
if (IS_ERR(err_ptr)) {
pr_err("Error-Could not create mode file\n");
goto error;
}
mode = 0;
/* Optimum Mode File */
if (reg_ops->get_mode)
mode |= S_IRUGO;
if (reg_ops->set_mode)
mode |= S_IWUSR;
if (mode)
err_ptr = debugfs_create_file("load", mode,
rdev->debugfs, reg, &reg_set_load_fops);
if (IS_ERR(err_ptr)) {
pr_err("Error-Could not create optimum_mode file\n");
goto error;
}
return;
error:
rdev_deinit_debugfs(rdev);
return;
} }
#else #else