Merge "regulator: core: clean up debugfs monitoring and control features"

drivers/regulator/core.c

@@ -3900,38 +3900,34 @@ static struct class regulator_class = {
 
 #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)
 {
-	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)
 {
-	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;
 }
-
 DEFINE_SIMPLE_ATTRIBUTE(reg_enable_fops, reg_debug_enable_get,
 			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_dev *rdev = regulator->rdev;
 	bool enable = false;
-	int rc = 0;
+	int ret = 0;
 
 	mutex_lock(&rdev->mutex);
 	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 {
 		enable = (rdev->bypass_count == rdev->open_count
 			  - rdev->open_offset);
@@ -3955,7 +3951,7 @@ static int reg_debug_bypass_enable_get(void *data, u64 *val)
 
 	*val = enable;
 
-	return rc;
+	return ret;
 }
 
 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,
 			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) {
-		mutex_lock(&debug_buf_mutex);
+		if (copy_from_user(buf, ubuf, count))
-
-		if (copy_from_user(debug_buf, (void __user *) buf, count))
 			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 {
-		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;
 }
 
-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)
 {
-	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;
+
 	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)
 {
-	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)
 {
-	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,
-DEFINE_SIMPLE_ATTRIBUTE(reg_mode_fops, reg_debug_mode_get,
+			"%llu\n");
-			reg_debug_mode_set, "%llu\n");
 
 static int reg_debug_set_load(void *data, u64 val)
 {
-	int err_info;
+	struct regulator *regulator = data;
-	if (IS_ERR(data) || data == NULL) {
+	int load = val;
-		pr_err("Function Input Error %ld\n", PTR_ERR(data));
+	int ret;
-		return -ENOMEM;
-	}
 
-	err_info = regulator_set_load(data, (unsigned int)val);
+	ret = regulator_set_load(regulator, load);
+	if (ret)
+		rdev_err(regulator->rdev, "set load=%d failed, ret=%d\n",
+			load, ret);
 
-	if (err_info < 0) {
+	return ret;
-		pr_err("Regulator_set_optimum_mode returned an error!\n");
-		return err_info;
-	}
-
-	return 0;
 }
-
 DEFINE_SIMPLE_ATTRIBUTE(reg_set_load_fops, reg_debug_mode_get,
 			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;
 	char *supply_name;
 
-	if (!rdev) {
-		pr_err("regulator device missing");
-		return -EINVAL;
-	}
-
 	mutex_lock(&rdev->mutex);
 
 	/* Print a header if there are consumers. */
 	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) {
 		if (reg->supply_name)
@@ -4189,17 +4158,10 @@ static void rdev_init_debugfs(struct regulator_dev *rdev)
 	struct device *parent = rdev->dev.parent;
 	const char *rname = rdev_get_name(rdev);
 	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;
 
-	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 */
 	if (parent && rname == rdev->desc->name) {
 		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);
 	if (!rdev->debugfs) {
 		rdev_warn(rdev, "Failed to create debugfs directory\n");
-		rdev->debugfs = NULL;
+		return;
-		goto error;
 	}
 
 	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,
 			    &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;
-	reg_ops = rdev->desc->ops;
+	ops = rdev->desc->ops;
-	mode = S_IRUGO | S_IWUSR;
-	/* Enabled File */
-	if (mode)
-		err_ptr = debugfs_create_file("enable", mode, rdev->debugfs,
-						reg, &reg_enable_fops);
-	if (IS_ERR(err_ptr)) {
-		pr_err("Error-Could not create enable file\n");
-		goto error;
-	}
 
-	mode = 0;
+	debugfs_create_file("enable", 0644, rdev->debugfs, regulator,
-	/* Bypass Enable File */
+				&reg_enable_fops);
-	if (reg_ops->set_bypass)
+	if (ops->set_bypass)
-		mode = S_IWUSR | S_IRUGO;
+		debugfs_create_file("bypass", 0644, rdev->debugfs, regulator,
-
-	if (mode)
-		err_ptr = debugfs_create_file("bypass", mode,
-					      rdev->debugfs, reg,
 					&reg_bypass_enable_fops);
-	if (IS_ERR(err_ptr)) {
-		pr_err("Error-Could not create bypass enable file\n");
-		goto error;
-	}
 
 	mode = 0;
-	/* Force-Disable File */
+	if (ops->is_enabled)
-	if (reg_ops->is_enabled)
+		mode |= 0444;
-		mode |= S_IRUGO;
+	if (ops->disable)
-	if (reg_ops->enable || reg_ops->disable)
+		mode |= 0200;
-		mode |= S_IWUSR;
 	if (mode)
-		err_ptr = debugfs_create_file("force_disable", mode,
+		debugfs_create_file("force_disable", mode, rdev->debugfs,
-					rdev->debugfs, reg, &reg_fdisable_fops);
+					regulator, &reg_force_disable_fops);
-	if (IS_ERR(err_ptr)) {
-		pr_err("Error-Could not create force_disable file\n");
-		goto error;
-	}
 
 	mode = 0;
-	/* Voltage File */
+	if (ops->get_voltage || ops->get_voltage_sel)
-	if (reg_ops->get_voltage)
+		mode |= 0444;
-		mode |= S_IRUGO;
+	if (ops->set_voltage || ops->set_voltage_sel)
-	if (reg_ops->set_voltage)
+		mode |= 0200;
-		mode |= S_IWUSR;
 	if (mode)
-		err_ptr = debugfs_create_file("voltage", mode, rdev->debugfs,
+		debugfs_create_file("voltage", mode, rdev->debugfs, regulator,
-						reg, &reg_volt_fops);
+					&reg_voltage_fops);
-	if (IS_ERR(err_ptr)) {
-		pr_err("Error-Could not create voltage file\n");
-		goto error;
-	}
 
 	mode = 0;
-	/* Mode File */
+	if (ops->get_mode)
-	if (reg_ops->get_mode)
+		mode |= 0444;
-		mode |= S_IRUGO;
+	if (ops->set_mode)
-	if (reg_ops->set_mode)
+		mode |= 0200;
-		mode |= S_IWUSR;
 	if (mode)
-		err_ptr = debugfs_create_file("mode", mode, rdev->debugfs,
+		debugfs_create_file("mode", mode, rdev->debugfs, regulator,
-						reg, &reg_mode_fops);
+					&reg_mode_fops);
-	if (IS_ERR(err_ptr)) {
-		pr_err("Error-Could not create mode file\n");
-		goto error;
-	}
 
 	mode = 0;
-	/* Optimum 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)
-		err_ptr = debugfs_create_file("load", mode,
+		debugfs_create_file("load", mode, rdev->debugfs, regulator,
-				rdev->debugfs, reg, &reg_set_load_fops);
+					&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