drivers/regulator/dw8768-regulator.c - kernel/msm - Git at Google

 /*
  * Copyright (c) 2015 LGE Inc. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 and
  * only version 2 as published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  */

 #define pr_fmt(fmt) "%s: " fmt, __func__

 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/regulator/of_regulator.h>
 #include <linux/regulator/driver.h>
 #include <linux/regulator/machine.h>
 #include <linux/i2c.h>
 #include <linux/of_gpio.h>
 #include <linux/regmap.h>
 #include <linux/delay.h>

 #ifdef DW8768_DEBUG
 #define dw_info(...)	pr_info(__VA_ARGS__)
 #else
 #define dw_info(...)	do { } while (0)
 #endif

 struct dw8768_regulator {
 	struct device			*dev;
 	struct regulator_desc		rdesc;
 	struct regulator_dev		*rdev;
 	struct regulator_init_data	*init_data;
 	struct regmap 			*i2c_regmap;
 	struct device_node		*reg_node;
 	int				ena_gpio;
 	int				enm_gpio;
 	int				pre_on_usleep;
 	int				post_on_usleep;
 	int				pre_off_usleep;
 	int				post_off_usleep;
 	bool				is_enabled;
 	int				curr_uV;
 	u8				vol_set_val;
 	bool				vol_set_postponed;
 };

 #define DW8768_REG_VPOS_ADDR		0x00
 #define DW8768_REG_VNEG_ADDR		0x01
 #define DW8768_REG_V_MASK		0x1f
 #define DW8768_REG_EN_ADDR		0x05	/* when no enm*/

 #define DW8768_VOLTAGE_MIN		4000000
 #define DW8768_VOLTAGE_MAX		6000000
 #define DW8768_VOLTAGE_STEP		100000
 #define DW8768_VOLTAGE_LEVELS	\
 		((DW8768_VOLTAGE_MAX - DW8768_VOLTAGE_MIN) \
 		 / DW8768_VOLTAGE_STEP + 1)

 #define DW8768_VOLTAGE_DEFAULT		5500000

 static struct of_regulator_match dw8768_reg_matches[] = {
 	{ .name = "dw8768-dsv", .driver_data = (void *)0 },
 };

 static int dw8768_regulator_enable(struct regulator_dev *rdev)
 {
 	struct dw8768_regulator *reg_data = rdev_get_drvdata(rdev);
 	int rc = 0;

 	if (!rdev->regmap) {
 		pr_err("invalid regmap\n");
 		return -EINVAL;
 	}

 	dw_info("enable, postponed:%d\n", reg_data->vol_set_postponed);

 	if (reg_data->pre_on_usleep)
 		usleep(reg_data->pre_on_usleep);

 	if (gpio_is_valid(reg_data->ena_gpio)) {
 		gpio_set_value(reg_data->ena_gpio, 1);
 		if (gpio_is_valid(reg_data->enm_gpio)) {
 			gpio_set_value(reg_data->enm_gpio, 1);
 		} else {
 			rc = regmap_write(rdev->regmap,
 					DW8768_REG_EN_ADDR, 0x0F);
 			if (rc)
 				pr_err("Failed to write i2c. rc=%d\n", rc);
 		}
 		reg_data->is_enabled = true;
 	} else {
 		pr_err("gpio ena is not configured\n");
 		rc = -EINVAL;
 	}

 	if (reg_data->vol_set_postponed) {
 		rc = regmap_write(rdev->regmap, DW8768_REG_VPOS_ADDR,
 						reg_data->vol_set_val);
 		if (rc) {
 			pr_err("failed to write postponed +V(%d)\n",
 						reg_data->vol_set_val);
 			return rc;
 		}
 		rc = regmap_write(rdev->regmap, DW8768_REG_VNEG_ADDR,
 						reg_data->vol_set_val);
 		if (rc) {
 			pr_err("failed to write postponed -V(%d)\n",
 						reg_data->vol_set_val);
 			return rc;
 		}
 		reg_data->vol_set_postponed = false;
 	}

 	if (reg_data->post_on_usleep)
 		usleep(reg_data->post_on_usleep);
 	return rc;
 }

 static int dw8768_regulator_disable(struct regulator_dev *rdev)
 {
 	struct dw8768_regulator *reg_data = rdev_get_drvdata(rdev);
 	int rc = 0;

 	if (!rdev->regmap) {
 		pr_err("invalid regmap\n");
 		return -EINVAL;
 	}

 	dw_info("disable, postponed:%d\n", reg_data->vol_set_postponed);

 	if (reg_data->pre_off_usleep)
 		usleep(reg_data->pre_off_usleep);

 	if (gpio_is_valid(reg_data->ena_gpio)) {
 		if (gpio_is_valid(reg_data->enm_gpio)) {
 			gpio_set_value(reg_data->enm_gpio, 0);
 		} else {
 			rc = regmap_write(rdev->regmap,
 					DW8768_REG_EN_ADDR, 0x07);
 			if (rc)
 				pr_err("Failed to write i2c. rc=%d\n", rc);
 		}
 		gpio_set_value(reg_data->ena_gpio, 0);
 		reg_data->is_enabled = false;
 	} else {
 		pr_err("gpio ena is not configured\n");
 		rc = -EINVAL;
 	}

 	if (reg_data->post_off_usleep)
 		usleep(reg_data->post_off_usleep);
 	return rc;
 }

 static int dw8768_regulator_is_enabled(struct regulator_dev *rdev)
 {
 	struct dw8768_regulator *reg_data = rdev_get_drvdata(rdev);

 	return reg_data->is_enabled ? 1 : 0;
 }

 static int dw8768_regulator_set_voltage(struct regulator_dev *rdev,
 			int min_uV, int max_uV, unsigned *selector)
 {
 	struct dw8768_regulator *reg_data = rdev_get_drvdata(rdev);
 	int rc, val, new_uV;

 	if (!rdev->regmap) {
 		pr_err("invalid regmap\n");
 		return -EINVAL;
 	}

 	val = DIV_ROUND_UP(min_uV - DW8768_VOLTAGE_MIN, DW8768_VOLTAGE_STEP);
 	val = val & DW8768_REG_V_MASK;
 	new_uV = DW8768_VOLTAGE_MIN + (val * DW8768_VOLTAGE_STEP);
 	if (new_uV == reg_data->curr_uV) {
 		dw_info("curV and newV are same\n");
 		return 0;
 	}
 	if (new_uV > max_uV) {
 		pr_err("failed to set voltage (%d %d)\n", min_uV, max_uV);
 		return -EINVAL;
 	}

 	reg_data->vol_set_val = val;
 	if (!reg_data->is_enabled) {
 		reg_data->vol_set_postponed = true;
 	} else {
 		rc = regmap_write(rdev->regmap, DW8768_REG_VPOS_ADDR, val);
 		if (rc) {
 			pr_err("failed to write +V(%d %d)\n", min_uV, max_uV);
 			return rc;
 		}
 		rc = regmap_write(rdev->regmap, DW8768_REG_VNEG_ADDR, val);
 		if (rc) {
 			pr_err("failed to write -V(%d %d)\n", min_uV, max_uV);
 			return rc;
 		}
 	}

 	reg_data->curr_uV = new_uV;
 	*selector = val;

 	dw_info("uV:%d reg:%x postponed:%d\n", new_uV, val,
 					reg_data->vol_set_postponed);
 	return 0;
 }

 static int dw8768_regulator_get_voltage(struct regulator_dev *rdev)
 {
 	struct dw8768_regulator *reg_data = rdev_get_drvdata(rdev);
 	int rc, posval, negval;

 	if (!rdev->regmap) {
 		pr_err("invalid regmap\n");
 		return -EINVAL;
 	}

 	if (!reg_data->is_enabled) {
 		dw_info("curr_uV:%d (no_enabled)\n", reg_data->curr_uV);
 		return reg_data->curr_uV;
 	}

 	rc = regmap_read(rdev->regmap, DW8768_REG_VPOS_ADDR, &posval);
 	if (rc) {
 		pr_err("failed to read +V\n");
 		return rc;
 	}
 	rc = regmap_read(rdev->regmap, DW8768_REG_VNEG_ADDR, &negval);
 	if (rc) {
 		pr_err("failed to read -V\n");
 		return rc;
 	}
 	if (posval != negval) {
 		pr_err("mismatch between +V(%d) and -V(%d)\n",
 							posval, negval);
 		return -EINVAL;
 	}
 	reg_data->curr_uV = (posval & DW8768_REG_V_MASK)* DW8768_VOLTAGE_STEP
 				+ DW8768_VOLTAGE_MIN;

 	dw_info("curr_uV:%d\n", reg_data->curr_uV);

 	return reg_data->curr_uV;
 }

 static int dw8768_regulator_list_voltage(struct regulator_dev *rdev,
 			unsigned selector)
 {
 	if (selector >= DW8768_VOLTAGE_LEVELS)
 		return 0;
 	return selector * DW8768_VOLTAGE_STEP + DW8768_VOLTAGE_MIN;
 }

 static struct regulator_ops dw8768_ops = {
 	.set_voltage = dw8768_regulator_set_voltage,
 	.get_voltage = dw8768_regulator_get_voltage,
 	.list_voltage = dw8768_regulator_list_voltage,
 	.enable = dw8768_regulator_enable,
 	.disable = dw8768_regulator_disable,
 	.is_enabled = dw8768_regulator_is_enabled,
 };

 static int dw8768_parse_dt_reg(struct dw8768_regulator *reg_data,
 				struct device_node *node)
 {
 	int temp;

 	reg_data->ena_gpio = of_get_named_gpio(node, "dw,ena-gpio", 0);
 	if (!gpio_is_valid(reg_data->ena_gpio)) {
 		pr_err("ena-gpio not specified. rd=%d\n",
 						reg_data->ena_gpio);
 		return -EINVAL;
 	}

 	reg_data->enm_gpio = of_get_named_gpio(node, "dw,enm-gpio", 0);
 	if (!gpio_is_valid(reg_data->enm_gpio)) {
 		pr_err("enm-gpio not specified. rd=%d\n",
 						reg_data->enm_gpio);
 	}

 	if (!of_property_read_u32(node, "dw,pre-on-sleep-us", &temp))
 		reg_data->pre_on_usleep = temp;
 	if (!of_property_read_u32(node, "dw,post-on-sleep-us", &temp))
 		reg_data->post_on_usleep = temp;
 	else
 		reg_data->post_on_usleep = 3700;
 	if (!of_property_read_u32(node, "dw,pre-off-sleep-us", &temp))
 		reg_data->pre_off_usleep = temp;
 	if (!of_property_read_u32(node, "dw,post-off-sleep-us", &temp))
 		reg_data->post_off_usleep = temp;

 	dw_info("pre-on:%d post-on:%d pre-off:%d post-off:%d\n",
 		reg_data->pre_on_usleep, reg_data->post_on_usleep,
 		reg_data->pre_off_usleep, reg_data->post_off_usleep);

 	return 0;
 }

 static int dw8768_parse_dt(struct dw8768_regulator *reg_data,
 					struct i2c_client *client)
 {
 	struct device_node *node;
 	struct regulation_constraints *constraints;
 	int rc;

 	if (!client->dev.of_node) {
 		pr_err("Can't find device tree\n");
 		return -ENOTSUPP;
 	}
 	node = of_find_node_by_name(client->dev.of_node,
 						"regulators");
 	if (!node) {
 		pr_err("Can't find regulator node\n");
 		return -EINVAL;
 	}

 	rc = of_regulator_match(&client->dev, node, dw8768_reg_matches,
 					ARRAY_SIZE(dw8768_reg_matches));
 	if (IS_ERR_VALUE(rc)) {
 		pr_err("Can't match regulator. rc=%d\n", rc);
 		return rc;
 	}
 	if (!dw8768_reg_matches[0].init_data) {
 		pr_err("Failed to match regulator\n");
 		return -EINVAL;
 	}
 	constraints = &dw8768_reg_matches[0].init_data->constraints;
 	if (!constraints) {
 		pr_err("Failed to init constraints\n");
 		return -EINVAL;
 	}
 	constraints->input_uV = constraints->max_uV;
 	constraints->valid_ops_mask = REGULATOR_CHANGE_VOLTAGE |
 					REGULATOR_CHANGE_STATUS;

 	reg_data->init_data = dw8768_reg_matches[0].init_data;
 	reg_data->reg_node = dw8768_reg_matches[0].of_node;
 	reg_data->rdesc.name = constraints->name;

 	rc = dw8768_parse_dt_reg(reg_data,
 				dw8768_reg_matches[0].of_node);
 	return rc;
 }

 static struct regmap_config dw8768_i2c_regmap = {
 	.reg_bits = 8,
 	.val_bits = 8,
 };

 static int dw8768_regulator_probe(struct i2c_client *client,
 					const struct i2c_device_id *id)
 {
 	struct dw8768_regulator *reg_data;
 	struct regulator_config config = {};
 	struct regulator_desc *rdesc;
 	int rc;

 	reg_data = devm_kzalloc(&client->dev,
 				sizeof(struct dw8768_regulator),
 				GFP_KERNEL);
 	if (!reg_data) {
 		pr_err("Can't allocate dw8768_regulator memory\n");
 		return -ENOMEM;
 	}

 	rc = dw8768_parse_dt(reg_data, client);
 	if (rc) {
 		pr_err("Failed to parse device tree. rc=%d\n", rc);
 		goto error;
 	}

 	if (!gpio_is_valid(reg_data->ena_gpio)) {
 		pr_err("Invalid gpio ena\n");
 		goto error;
 	}
 	rc = gpio_request_one(reg_data->ena_gpio,
 				GPIOF_OUT_INIT_HIGH, "dw8768_ena");
 	if (rc) {
 		pr_err("Failed to request gpio ena. rc=%d\n", rc);
 		goto error;
 	}

 	if (gpio_is_valid(reg_data->enm_gpio)) {
 		rc = gpio_request_one(reg_data->enm_gpio,
 				GPIOF_OUT_INIT_HIGH, "dw8768_enm");
 		if (rc) {
 			pr_err("Failed to request gpio enm. rc=%d\n", rc);
 			goto error_enm;
 		}
 	}

 	reg_data->i2c_regmap = devm_regmap_init_i2c(client,
 						&dw8768_i2c_regmap);
 	if (IS_ERR(reg_data->i2c_regmap)) {
 		rc = PTR_ERR(reg_data->i2c_regmap);
 		pr_err("Failed to init i2c. rc=%d\n", rc);
 		goto error_i2c;
 	}

 	i2c_set_clientdata(client, reg_data);

 	reg_data->dev = &client->dev;

 	config.dev = &client->dev;
 	config.init_data = reg_data->init_data;
 	config.driver_data = reg_data;
 	config.of_node = reg_data->reg_node;
 	config.regmap = reg_data->i2c_regmap;

 	rdesc = &reg_data->rdesc;
 	rdesc->type = REGULATOR_VOLTAGE;
 	rdesc->owner = THIS_MODULE;
 	rdesc->n_voltages = DW8768_VOLTAGE_LEVELS;
 	rdesc->ops = &dw8768_ops;

 	reg_data->curr_uV = DW8768_VOLTAGE_DEFAULT;
 	reg_data->rdev = regulator_register(rdesc, &config);
 	if (IS_ERR(reg_data->rdev)) {
 		rc = PTR_ERR(reg_data->rdev);
 		pr_err("Failed to register regulator. rc=%d\n", rc);
 		goto error_i2c;
 	}

 	return rc;

 error_i2c:
 	if (gpio_is_valid(reg_data->enm_gpio))
 		gpio_free(reg_data->enm_gpio);
 error_enm:
 	if (gpio_is_valid(reg_data->ena_gpio))
 		gpio_free(reg_data->ena_gpio);
 error:
 	if (reg_data) {
 		devm_kfree(&client->dev, reg_data);
 	}
 	return rc;
 }

 static int dw8768_regulator_remove(struct i2c_client *client)
 {
 	struct dw8768_regulator *reg_data =
 				i2c_get_clientdata(client);

 	regulator_unregister(reg_data->rdev);
 	if (gpio_is_valid(reg_data->ena_gpio))
 		gpio_free(reg_data->ena_gpio);
 	if (gpio_is_valid(reg_data->enm_gpio))
 		gpio_free(reg_data->enm_gpio);

 	return 0;
 }

 static struct of_device_id dw8768_match_table[] = {
 	{ .compatible = "dw,dw8768", },
 	{},
 };

 static const struct i2c_device_id dw8768_id[] = {
 	{ "dw8768", 0 },
 	{ },
 };
 MODULE_DEVICE_TABLE(i2c, dw8768_id);

 static struct i2c_driver dw8768_regulator_driver = {
 	.driver = {
 		.name = "dw8768",
 		.owner = THIS_MODULE,
 		.of_match_table = dw8768_match_table,
 	},
 	.probe = dw8768_regulator_probe,
 	.remove = dw8768_regulator_remove,
 	.id_table = dw8768_id,
 };

 static int __init dw8768_init(void)
 {
 	return i2c_add_driver(&dw8768_regulator_driver);
 }
 subsys_initcall(dw8768_init);

 static void __exit dw8768_exit(void)
 {
 	i2c_del_driver(&dw8768_regulator_driver);
 }
 module_exit(dw8768_exit);

 MODULE_DESCRIPTION("DONGWOON DW8768 regulator driver");
 MODULE_LICENSE("GPL v2");
	/*
	* Copyright (c) 2015 LGE Inc. All rights reserved.
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License version 2 and
	* only version 2 as published by the Free Software Foundation.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*/

	#define pr_fmt(fmt) "%s: " fmt, __func__

	#include <linux/init.h>
	#include <linux/kernel.h>
	#include <linux/module.h>
	#include <linux/regulator/of_regulator.h>
	#include <linux/regulator/driver.h>
	#include <linux/regulator/machine.h>
	#include <linux/i2c.h>
	#include <linux/of_gpio.h>
	#include <linux/regmap.h>
	#include <linux/delay.h>

	#ifdef DW8768_DEBUG
	#define dw_info(...) pr_info(__VA_ARGS__)
	#else
	#define dw_info(...) do { } while (0)
	#endif

	struct dw8768_regulator {
	struct device *dev;
	struct regulator_desc rdesc;
	struct regulator_dev *rdev;
	struct regulator_init_data *init_data;
	struct regmap *i2c_regmap;
	struct device_node *reg_node;
	int ena_gpio;
	int enm_gpio;
	int pre_on_usleep;
	int post_on_usleep;
	int pre_off_usleep;
	int post_off_usleep;
	bool is_enabled;
	int curr_uV;
	u8 vol_set_val;
	bool vol_set_postponed;
	};

	#define DW8768_REG_VPOS_ADDR 0x00
	#define DW8768_REG_VNEG_ADDR 0x01
	#define DW8768_REG_V_MASK 0x1f
	#define DW8768_REG_EN_ADDR 0x05 /* when no enm*/

	#define DW8768_VOLTAGE_MIN 4000000
	#define DW8768_VOLTAGE_MAX 6000000
	#define DW8768_VOLTAGE_STEP 100000
	#define DW8768_VOLTAGE_LEVELS \
	((DW8768_VOLTAGE_MAX - DW8768_VOLTAGE_MIN) \
	/ DW8768_VOLTAGE_STEP + 1)

	#define DW8768_VOLTAGE_DEFAULT 5500000

	static struct of_regulator_match dw8768_reg_matches[] = {
	{ .name = "dw8768-dsv", .driver_data = (void *)0 },
	};

	static int dw8768_regulator_enable(struct regulator_dev *rdev)
	{
	struct dw8768_regulator *reg_data = rdev_get_drvdata(rdev);
	int rc = 0;

	if (!rdev->regmap) {
	pr_err("invalid regmap\n");
	return -EINVAL;
	}

	dw_info("enable, postponed:%d\n", reg_data->vol_set_postponed);

	if (reg_data->pre_on_usleep)
	usleep(reg_data->pre_on_usleep);

	if (gpio_is_valid(reg_data->ena_gpio)) {
	gpio_set_value(reg_data->ena_gpio, 1);
	if (gpio_is_valid(reg_data->enm_gpio)) {
	gpio_set_value(reg_data->enm_gpio, 1);
	} else {
	rc = regmap_write(rdev->regmap,
	DW8768_REG_EN_ADDR, 0x0F);
	if (rc)
	pr_err("Failed to write i2c. rc=%d\n", rc);
	}
	reg_data->is_enabled = true;
	} else {
	pr_err("gpio ena is not configured\n");
	rc = -EINVAL;
	}

	if (reg_data->vol_set_postponed) {
	rc = regmap_write(rdev->regmap, DW8768_REG_VPOS_ADDR,
	reg_data->vol_set_val);
	if (rc) {
	pr_err("failed to write postponed +V(%d)\n",
	reg_data->vol_set_val);
	return rc;
	}
	rc = regmap_write(rdev->regmap, DW8768_REG_VNEG_ADDR,
	reg_data->vol_set_val);
	if (rc) {
	pr_err("failed to write postponed -V(%d)\n",
	reg_data->vol_set_val);
	return rc;
	}
	reg_data->vol_set_postponed = false;
	}

	if (reg_data->post_on_usleep)
	usleep(reg_data->post_on_usleep);
	return rc;
	}

	static int dw8768_regulator_disable(struct regulator_dev *rdev)
	{
	struct dw8768_regulator *reg_data = rdev_get_drvdata(rdev);
	int rc = 0;

	if (!rdev->regmap) {
	pr_err("invalid regmap\n");
	return -EINVAL;
	}

	dw_info("disable, postponed:%d\n", reg_data->vol_set_postponed);

	if (reg_data->pre_off_usleep)
	usleep(reg_data->pre_off_usleep);

	if (gpio_is_valid(reg_data->ena_gpio)) {
	if (gpio_is_valid(reg_data->enm_gpio)) {
	gpio_set_value(reg_data->enm_gpio, 0);
	} else {
	rc = regmap_write(rdev->regmap,
	DW8768_REG_EN_ADDR, 0x07);
	if (rc)
	pr_err("Failed to write i2c. rc=%d\n", rc);
	}
	gpio_set_value(reg_data->ena_gpio, 0);
	reg_data->is_enabled = false;
	} else {
	pr_err("gpio ena is not configured\n");
	rc = -EINVAL;
	}

	if (reg_data->post_off_usleep)
	usleep(reg_data->post_off_usleep);
	return rc;
	}

	static int dw8768_regulator_is_enabled(struct regulator_dev *rdev)
	{
	struct dw8768_regulator *reg_data = rdev_get_drvdata(rdev);

	return reg_data->is_enabled ? 1 : 0;
	}

	static int dw8768_regulator_set_voltage(struct regulator_dev *rdev,
	int min_uV, int max_uV, unsigned *selector)
	{
	struct dw8768_regulator *reg_data = rdev_get_drvdata(rdev);
	int rc, val, new_uV;

	if (!rdev->regmap) {
	pr_err("invalid regmap\n");
	return -EINVAL;
	}

	val = DIV_ROUND_UP(min_uV - DW8768_VOLTAGE_MIN, DW8768_VOLTAGE_STEP);
	val = val & DW8768_REG_V_MASK;
	new_uV = DW8768_VOLTAGE_MIN + (val * DW8768_VOLTAGE_STEP);
	if (new_uV == reg_data->curr_uV) {
	dw_info("curV and newV are same\n");
	return 0;
	}
	if (new_uV > max_uV) {
	pr_err("failed to set voltage (%d %d)\n", min_uV, max_uV);
	return -EINVAL;
	}

	reg_data->vol_set_val = val;
	if (!reg_data->is_enabled) {
	reg_data->vol_set_postponed = true;
	} else {
	rc = regmap_write(rdev->regmap, DW8768_REG_VPOS_ADDR, val);
	if (rc) {
	pr_err("failed to write +V(%d %d)\n", min_uV, max_uV);
	return rc;
	}
	rc = regmap_write(rdev->regmap, DW8768_REG_VNEG_ADDR, val);
	if (rc) {
	pr_err("failed to write -V(%d %d)\n", min_uV, max_uV);
	return rc;
	}
	}

	reg_data->curr_uV = new_uV;
	*selector = val;

	dw_info("uV:%d reg:%x postponed:%d\n", new_uV, val,
	reg_data->vol_set_postponed);
	return 0;
	}

	static int dw8768_regulator_get_voltage(struct regulator_dev *rdev)
	{
	struct dw8768_regulator *reg_data = rdev_get_drvdata(rdev);
	int rc, posval, negval;

	if (!rdev->regmap) {
	pr_err("invalid regmap\n");
	return -EINVAL;
	}

	if (!reg_data->is_enabled) {
	dw_info("curr_uV:%d (no_enabled)\n", reg_data->curr_uV);
	return reg_data->curr_uV;
	}

	rc = regmap_read(rdev->regmap, DW8768_REG_VPOS_ADDR, &posval);
	if (rc) {
	pr_err("failed to read +V\n");
	return rc;
	}
	rc = regmap_read(rdev->regmap, DW8768_REG_VNEG_ADDR, &negval);
	if (rc) {
	pr_err("failed to read -V\n");
	return rc;
	}
	if (posval != negval) {
	pr_err("mismatch between +V(%d) and -V(%d)\n",
	posval, negval);
	return -EINVAL;
	}
	reg_data->curr_uV = (posval & DW8768_REG_V_MASK)* DW8768_VOLTAGE_STEP
	+ DW8768_VOLTAGE_MIN;

	dw_info("curr_uV:%d\n", reg_data->curr_uV);

	return reg_data->curr_uV;
	}

	static int dw8768_regulator_list_voltage(struct regulator_dev *rdev,
	unsigned selector)
	{
	if (selector >= DW8768_VOLTAGE_LEVELS)
	return 0;
	return selector * DW8768_VOLTAGE_STEP + DW8768_VOLTAGE_MIN;
	}

	static struct regulator_ops dw8768_ops = {
	.set_voltage = dw8768_regulator_set_voltage,
	.get_voltage = dw8768_regulator_get_voltage,
	.list_voltage = dw8768_regulator_list_voltage,
	.enable = dw8768_regulator_enable,
	.disable = dw8768_regulator_disable,
	.is_enabled = dw8768_regulator_is_enabled,
	};

	static int dw8768_parse_dt_reg(struct dw8768_regulator *reg_data,
	struct device_node *node)
	{
	int temp;

	reg_data->ena_gpio = of_get_named_gpio(node, "dw,ena-gpio", 0);
	if (!gpio_is_valid(reg_data->ena_gpio)) {
	pr_err("ena-gpio not specified. rd=%d\n",
	reg_data->ena_gpio);
	return -EINVAL;
	}

	reg_data->enm_gpio = of_get_named_gpio(node, "dw,enm-gpio", 0);
	if (!gpio_is_valid(reg_data->enm_gpio)) {
	pr_err("enm-gpio not specified. rd=%d\n",
	reg_data->enm_gpio);
	}

	if (!of_property_read_u32(node, "dw,pre-on-sleep-us", &temp))
	reg_data->pre_on_usleep = temp;
	if (!of_property_read_u32(node, "dw,post-on-sleep-us", &temp))
	reg_data->post_on_usleep = temp;
	else
	reg_data->post_on_usleep = 3700;
	if (!of_property_read_u32(node, "dw,pre-off-sleep-us", &temp))
	reg_data->pre_off_usleep = temp;
	if (!of_property_read_u32(node, "dw,post-off-sleep-us", &temp))
	reg_data->post_off_usleep = temp;

	dw_info("pre-on:%d post-on:%d pre-off:%d post-off:%d\n",
	reg_data->pre_on_usleep, reg_data->post_on_usleep,
	reg_data->pre_off_usleep, reg_data->post_off_usleep);

	return 0;
	}

	static int dw8768_parse_dt(struct dw8768_regulator *reg_data,
	struct i2c_client *client)
	{
	struct device_node *node;
	struct regulation_constraints *constraints;
	int rc;

	if (!client->dev.of_node) {
	pr_err("Can't find device tree\n");
	return -ENOTSUPP;
	}
	node = of_find_node_by_name(client->dev.of_node,
	"regulators");
	if (!node) {
	pr_err("Can't find regulator node\n");
	return -EINVAL;
	}

	rc = of_regulator_match(&client->dev, node, dw8768_reg_matches,
	ARRAY_SIZE(dw8768_reg_matches));
	if (IS_ERR_VALUE(rc)) {
	pr_err("Can't match regulator. rc=%d\n", rc);
	return rc;
	}
	if (!dw8768_reg_matches[0].init_data) {
	pr_err("Failed to match regulator\n");
	return -EINVAL;
	}
	constraints = &dw8768_reg_matches[0].init_data->constraints;
	if (!constraints) {
	pr_err("Failed to init constraints\n");
	return -EINVAL;
	}
	constraints->input_uV = constraints->max_uV;
	constraints->valid_ops_mask = REGULATOR_CHANGE_VOLTAGE \|
	REGULATOR_CHANGE_STATUS;

	reg_data->init_data = dw8768_reg_matches[0].init_data;
	reg_data->reg_node = dw8768_reg_matches[0].of_node;
	reg_data->rdesc.name = constraints->name;

	rc = dw8768_parse_dt_reg(reg_data,
	dw8768_reg_matches[0].of_node);
	return rc;
	}

	static struct regmap_config dw8768_i2c_regmap = {
	.reg_bits = 8,
	.val_bits = 8,
	};

	static int dw8768_regulator_probe(struct i2c_client *client,
	const struct i2c_device_id *id)
	{
	struct dw8768_regulator *reg_data;
	struct regulator_config config = {};
	struct regulator_desc *rdesc;
	int rc;

	reg_data = devm_kzalloc(&client->dev,
	sizeof(struct dw8768_regulator),
	GFP_KERNEL);
	if (!reg_data) {
	pr_err("Can't allocate dw8768_regulator memory\n");
	return -ENOMEM;
	}

	rc = dw8768_parse_dt(reg_data, client);
	if (rc) {
	pr_err("Failed to parse device tree. rc=%d\n", rc);
	goto error;
	}

	if (!gpio_is_valid(reg_data->ena_gpio)) {
	pr_err("Invalid gpio ena\n");
	goto error;
	}
	rc = gpio_request_one(reg_data->ena_gpio,
	GPIOF_OUT_INIT_HIGH, "dw8768_ena");
	if (rc) {
	pr_err("Failed to request gpio ena. rc=%d\n", rc);
	goto error;
	}

	if (gpio_is_valid(reg_data->enm_gpio)) {
	rc = gpio_request_one(reg_data->enm_gpio,
	GPIOF_OUT_INIT_HIGH, "dw8768_enm");
	if (rc) {
	pr_err("Failed to request gpio enm. rc=%d\n", rc);
	goto error_enm;
	}
	}

	reg_data->i2c_regmap = devm_regmap_init_i2c(client,
	&dw8768_i2c_regmap);
	if (IS_ERR(reg_data->i2c_regmap)) {
	rc = PTR_ERR(reg_data->i2c_regmap);
	pr_err("Failed to init i2c. rc=%d\n", rc);
	goto error_i2c;
	}

	i2c_set_clientdata(client, reg_data);

	reg_data->dev = &client->dev;

	config.dev = &client->dev;
	config.init_data = reg_data->init_data;
	config.driver_data = reg_data;
	config.of_node = reg_data->reg_node;
	config.regmap = reg_data->i2c_regmap;

	rdesc = &reg_data->rdesc;
	rdesc->type = REGULATOR_VOLTAGE;
	rdesc->owner = THIS_MODULE;
	rdesc->n_voltages = DW8768_VOLTAGE_LEVELS;
	rdesc->ops = &dw8768_ops;

	reg_data->curr_uV = DW8768_VOLTAGE_DEFAULT;
	reg_data->rdev = regulator_register(rdesc, &config);
	if (IS_ERR(reg_data->rdev)) {
	rc = PTR_ERR(reg_data->rdev);
	pr_err("Failed to register regulator. rc=%d\n", rc);
	goto error_i2c;
	}

	return rc;

	error_i2c:
	if (gpio_is_valid(reg_data->enm_gpio))
	gpio_free(reg_data->enm_gpio);
	error_enm:
	if (gpio_is_valid(reg_data->ena_gpio))
	gpio_free(reg_data->ena_gpio);
	error:
	if (reg_data) {
	devm_kfree(&client->dev, reg_data);
	}
	return rc;
	}

	static int dw8768_regulator_remove(struct i2c_client *client)
	{
	struct dw8768_regulator *reg_data =
	i2c_get_clientdata(client);

	regulator_unregister(reg_data->rdev);
	if (gpio_is_valid(reg_data->ena_gpio))
	gpio_free(reg_data->ena_gpio);
	if (gpio_is_valid(reg_data->enm_gpio))
	gpio_free(reg_data->enm_gpio);

	return 0;
	}

	static struct of_device_id dw8768_match_table[] = {
	{ .compatible = "dw,dw8768", },
	{},
	};

	static const struct i2c_device_id dw8768_id[] = {
	{ "dw8768", 0 },
	{ },
	};
	MODULE_DEVICE_TABLE(i2c, dw8768_id);

	static struct i2c_driver dw8768_regulator_driver = {
	.driver = {
	.name = "dw8768",
	.owner = THIS_MODULE,
	.of_match_table = dw8768_match_table,
	},
	.probe = dw8768_regulator_probe,
	.remove = dw8768_regulator_remove,
	.id_table = dw8768_id,
	};

	static int __init dw8768_init(void)
	{
	return i2c_add_driver(&dw8768_regulator_driver);
	}
	subsys_initcall(dw8768_init);

	static void __exit dw8768_exit(void)
	{
	i2c_del_driver(&dw8768_regulator_driver);
	}
	module_exit(dw8768_exit);

	MODULE_DESCRIPTION("DONGWOON DW8768 regulator driver");
	MODULE_LICENSE("GPL v2");