[linux.git] / drivers / regulator / tps51632-regulator.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * tps51632-regulator.c -- TI TPS51632
 *
 * Regulator driver for TPS51632 3-2-1 Phase D-Cap Step Down Driverless
 * Controller with serial VID control and DVFS.
 *
 * Copyright (c) 2012, NVIDIA Corporation.
 *
 * Author: Laxman Dewangan <ldewangan@nvidia.com>
 */

#include <linux/err.h>
#include <linux/i2c.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/regmap.h>
#include <linux/regulator/driver.h>
#include <linux/regulator/machine.h>
#include <linux/regulator/of_regulator.h>
#include <linux/regulator/tps51632-regulator.h>
#include <linux/slab.h>

/* Register definitions */
#define TPS51632_VOLTAGE_SELECT_REG		0x0
#define TPS51632_VOLTAGE_BASE_REG		0x1
#define TPS51632_OFFSET_REG			0x2
#define TPS51632_IMON_REG			0x3
#define TPS51632_VMAX_REG			0x4
#define TPS51632_DVFS_CONTROL_REG		0x5
#define TPS51632_POWER_STATE_REG		0x6
#define TPS51632_SLEW_REGS			0x7
#define TPS51632_FAULT_REG			0x14

#define TPS51632_MAX_REG			0x15

#define TPS51632_VOUT_MASK			0x7F
#define TPS51632_VOUT_OFFSET_MASK		0x1F
#define TPS51632_VMAX_MASK			0x7F
#define TPS51632_VMAX_LOCK			0x80

/* TPS51632_DVFS_CONTROL_REG */
#define TPS51632_DVFS_PWMEN			0x1
#define TPS51632_DVFS_STEP_20			0x2
#define TPS51632_DVFS_VMAX_PG			0x4
#define TPS51632_DVFS_PWMRST			0x8
#define TPS51632_DVFS_OCA_EN			0x10
#define TPS51632_DVFS_FCCM			0x20

/* TPS51632_POWER_STATE_REG */
#define TPS51632_POWER_STATE_MASK		0x03
#define TPS51632_POWER_STATE_MULTI_PHASE_CCM	0x0
#define TPS51632_POWER_STATE_SINGLE_PHASE_CCM	0x1
#define TPS51632_POWER_STATE_SINGLE_PHASE_DCM	0x2

#define TPS51632_MIN_VOLTAGE			500000
#define TPS51632_MAX_VOLTAGE			1520000
#define TPS51632_VOLTAGE_STEP_10mV		10000
#define TPS51632_VOLTAGE_STEP_20mV		20000
#define TPS51632_MAX_VSEL			0x7F
#define TPS51632_MIN_VSEL			0x19
#define TPS51632_DEFAULT_RAMP_DELAY		6000
#define TPS51632_VOLT_VSEL(uV)					\
		(DIV_ROUND_UP(uV - TPS51632_MIN_VOLTAGE,	\
			TPS51632_VOLTAGE_STEP_10mV) +		\
			TPS51632_MIN_VSEL)

/* TPS51632 chip information */
struct tps51632_chip {
	struct device *dev;
	struct regulator_desc desc;
	struct regulator_dev *rdev;
	struct regmap *regmap;
};

static int tps51632_dcdc_set_ramp_delay(struct regulator_dev *rdev,
		int ramp_delay)
{
	struct tps51632_chip *tps = rdev_get_drvdata(rdev);
	int bit;
	int ret;

	if (ramp_delay == 0)
		bit = 0;
	else
		bit = DIV_ROUND_UP(ramp_delay, 6000) - 1;

	ret = regmap_write(tps->regmap, TPS51632_SLEW_REGS, BIT(bit));
	if (ret < 0)
		dev_err(tps->dev, "SLEW reg write failed, err %d\n", ret);
	return ret;
}

static const struct regulator_ops tps51632_dcdc_ops = {
	.get_voltage_sel	= regulator_get_voltage_sel_regmap,
	.set_voltage_sel	= regulator_set_voltage_sel_regmap,
	.list_voltage		= regulator_list_voltage_linear,
	.set_voltage_time_sel	= regulator_set_voltage_time_sel,
	.set_ramp_delay		= tps51632_dcdc_set_ramp_delay,
};

static int tps51632_init_dcdc(struct tps51632_chip *tps,
		struct tps51632_regulator_platform_data *pdata)
{
	int ret;
	uint8_t	control = 0;
	int vsel;

	if (!pdata->enable_pwm_dvfs)
		goto skip_pwm_config;

	control |= TPS51632_DVFS_PWMEN;
	vsel = TPS51632_VOLT_VSEL(pdata->base_voltage_uV);
	ret = regmap_write(tps->regmap, TPS51632_VOLTAGE_BASE_REG, vsel);
	if (ret < 0) {
		dev_err(tps->dev, "BASE reg write failed, err %d\n", ret);
		return ret;
	}

	if (pdata->dvfs_step_20mV)
		control |= TPS51632_DVFS_STEP_20;

	if (pdata->max_voltage_uV) {
		unsigned int vmax;
		/**
		 * TPS51632 hw behavior: VMAX register can be write only
		 * once as it get locked after first write. The lock get
		 * reset only when device is power-reset.
		 * Write register only when lock bit is not enabled.
		 */
		ret = regmap_read(tps->regmap, TPS51632_VMAX_REG, &vmax);
		if (ret < 0) {
			dev_err(tps->dev, "VMAX read failed, err %d\n", ret);
			return ret;
		}
		if (!(vmax & TPS51632_VMAX_LOCK)) {
			vsel = TPS51632_VOLT_VSEL(pdata->max_voltage_uV);
			ret = regmap_write(tps->regmap, TPS51632_VMAX_REG,
					vsel);
			if (ret < 0) {
				dev_err(tps->dev,
					"VMAX write failed, err %d\n", ret);
				return ret;
			}
		}
	}

skip_pwm_config:
	ret = regmap_write(tps->regmap, TPS51632_DVFS_CONTROL_REG, control);
	if (ret < 0)
		dev_err(tps->dev, "DVFS reg write failed, err %d\n", ret);
	return ret;
}

static bool is_volatile_reg(struct device *dev, unsigned int reg)
{
	switch (reg) {
	case TPS51632_OFFSET_REG:
	case TPS51632_FAULT_REG:
	case TPS51632_IMON_REG:
		return true;
	default:
		return false;
	}
}

static bool is_read_reg(struct device *dev, unsigned int reg)
{
	switch (reg) {
	case 0x08 ... 0x0F:
		return false;
	default:
		return true;
	}
}

static bool is_write_reg(struct device *dev, unsigned int reg)
{
	switch (reg) {
	case TPS51632_VOLTAGE_SELECT_REG:
	case TPS51632_VOLTAGE_BASE_REG:
	case TPS51632_VMAX_REG:
	case TPS51632_DVFS_CONTROL_REG:
	case TPS51632_POWER_STATE_REG:
	case TPS51632_SLEW_REGS:
		return true;
	default:
		return false;
	}
}

static const struct regmap_config tps51632_regmap_config = {
	.reg_bits		= 8,
	.val_bits		= 8,
	.writeable_reg		= is_write_reg,
	.readable_reg		= is_read_reg,
	.volatile_reg		= is_volatile_reg,
	.max_register		= TPS51632_MAX_REG - 1,
	.cache_type		= REGCACHE_RBTREE,
};

#if defined(CONFIG_OF)
static const struct of_device_id tps51632_of_match[] = {
	{ .compatible = "ti,tps51632",},
	{},
};
MODULE_DEVICE_TABLE(of, tps51632_of_match);

static struct tps51632_regulator_platform_data *
	of_get_tps51632_platform_data(struct device *dev,
				      const struct regulator_desc *desc)
{
	struct tps51632_regulator_platform_data *pdata;
	struct device_node *np = dev->of_node;

	pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
	if (!pdata)
		return NULL;

	pdata->reg_init_data = of_get_regulator_init_data(dev, dev->of_node,
							  desc);
	if (!pdata->reg_init_data) {
		dev_err(dev, "Not able to get OF regulator init data\n");
		return NULL;
	}

	pdata->enable_pwm_dvfs =
			of_property_read_bool(np, "ti,enable-pwm-dvfs");
	pdata->dvfs_step_20mV = of_property_read_bool(np, "ti,dvfs-step-20mV");

	pdata->base_voltage_uV = pdata->reg_init_data->constraints.min_uV ? :
					TPS51632_MIN_VOLTAGE;
	pdata->max_voltage_uV = pdata->reg_init_data->constraints.max_uV ? :
					TPS51632_MAX_VOLTAGE;
	return pdata;
}
#else
static struct tps51632_regulator_platform_data *
	of_get_tps51632_platform_data(struct device *dev,
				      const struct regulator_desc *desc)
{
	return NULL;
}
#endif

static int tps51632_probe(struct i2c_client *client)
{
	struct tps51632_regulator_platform_data *pdata;
	struct regulator_dev *rdev;
	struct tps51632_chip *tps;
	int ret;
	struct regulator_config config = { };

	tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL);
	if (!tps)
		return -ENOMEM;

	tps->dev = &client->dev;
	tps->desc.name = client->name;
	tps->desc.id = 0;
	tps->desc.ramp_delay = TPS51632_DEFAULT_RAMP_DELAY;
	tps->desc.min_uV = TPS51632_MIN_VOLTAGE;
	tps->desc.uV_step = TPS51632_VOLTAGE_STEP_10mV;
	tps->desc.linear_min_sel = TPS51632_MIN_VSEL;
	tps->desc.n_voltages = TPS51632_MAX_VSEL + 1;
	tps->desc.ops = &tps51632_dcdc_ops;
	tps->desc.type = REGULATOR_VOLTAGE;
	tps->desc.owner = THIS_MODULE;

	pdata = dev_get_platdata(&client->dev);
	if (!pdata && client->dev.of_node)
		pdata = of_get_tps51632_platform_data(&client->dev, &tps->desc);
	if (!pdata) {
		dev_err(&client->dev, "No Platform data\n");
		return -EINVAL;
	}

	if (pdata->enable_pwm_dvfs) {
		if ((pdata->base_voltage_uV < TPS51632_MIN_VOLTAGE) ||
		    (pdata->base_voltage_uV > TPS51632_MAX_VOLTAGE)) {
			dev_err(&client->dev, "Invalid base_voltage_uV setting\n");
			return -EINVAL;
		}

		if ((pdata->max_voltage_uV) &&
		    ((pdata->max_voltage_uV < TPS51632_MIN_VOLTAGE) ||
		     (pdata->max_voltage_uV > TPS51632_MAX_VOLTAGE))) {
			dev_err(&client->dev, "Invalid max_voltage_uV setting\n");
			return -EINVAL;
		}
	}

	if (pdata->enable_pwm_dvfs)
		tps->desc.vsel_reg = TPS51632_VOLTAGE_BASE_REG;
	else
		tps->desc.vsel_reg = TPS51632_VOLTAGE_SELECT_REG;
	tps->desc.vsel_mask = TPS51632_VOUT_MASK;

	tps->regmap = devm_regmap_init_i2c(client, &tps51632_regmap_config);
	if (IS_ERR(tps->regmap)) {
		ret = PTR_ERR(tps->regmap);
		dev_err(&client->dev, "regmap init failed, err %d\n", ret);
		return ret;
	}
	i2c_set_clientdata(client, tps);

	ret = tps51632_init_dcdc(tps, pdata);
	if (ret < 0) {
		dev_err(tps->dev, "Init failed, err = %d\n", ret);
		return ret;
	}

	/* Register the regulators */
	config.dev = &client->dev;
	config.init_data = pdata->reg_init_data;
	config.driver_data = tps;
	config.regmap = tps->regmap;
	config.of_node = client->dev.of_node;

	rdev = devm_regulator_register(&client->dev, &tps->desc, &config);
	if (IS_ERR(rdev)) {
		dev_err(tps->dev, "regulator register failed\n");
		return PTR_ERR(rdev);
	}

	tps->rdev = rdev;
	return 0;
}

static const struct i2c_device_id tps51632_id[] = {
	{.name = "tps51632",},
	{},
};

MODULE_DEVICE_TABLE(i2c, tps51632_id);

static struct i2c_driver tps51632_i2c_driver = {
	.driver = {
		.name = "tps51632",
		.probe_type = PROBE_PREFER_ASYNCHRONOUS,
		.of_match_table = of_match_ptr(tps51632_of_match),
	},
	.probe = tps51632_probe,
	.id_table = tps51632_id,
};

static int __init tps51632_init(void)
{
	return i2c_add_driver(&tps51632_i2c_driver);
}
subsys_initcall(tps51632_init);

static void __exit tps51632_cleanup(void)
{
	i2c_del_driver(&tps51632_i2c_driver);
}
module_exit(tps51632_cleanup);

MODULE_AUTHOR("Laxman Dewangan <ldewangan@nvidia.com>");
MODULE_DESCRIPTION("TPS51632 voltage regulator driver");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
e634cf4e	1	// SPDX-License-Identifier: GPL-2.0-only
0c570674 LD	2	/*
	3	* tps51632-regulator.c -- TI TPS51632
	4	*
	5	* Regulator driver for TPS51632 3-2-1 Phase D-Cap Step Down Driverless
	6	* Controller with serial VID control and DVFS.
	7	*
	8	* Copyright (c) 2012, NVIDIA Corporation.
	9	*
	10	* Author: Laxman Dewangan <ldewangan@nvidia.com>
0c570674 LD	11	*/
	12
	13	#include <linux/err.h>
	14	#include <linux/i2c.h>
	15	#include <linux/init.h>
	16	#include <linux/kernel.h>
	17	#include <linux/module.h>
c51ce403	18	#include <linux/of.h>
0c570674 LD	19	#include <linux/platform_device.h>
	20	#include <linux/regmap.h>
	21	#include <linux/regulator/driver.h>
	22	#include <linux/regulator/machine.h>
c51ce403	23	#include <linux/regulator/of_regulator.h>
0c570674 LD	24	#include <linux/regulator/tps51632-regulator.h>
	25	#include <linux/slab.h>
	26
	27	/* Register definitions */
	28	#define TPS51632_VOLTAGE_SELECT_REG 0x0
	29	#define TPS51632_VOLTAGE_BASE_REG 0x1
	30	#define TPS51632_OFFSET_REG 0x2
	31	#define TPS51632_IMON_REG 0x3
	32	#define TPS51632_VMAX_REG 0x4
	33	#define TPS51632_DVFS_CONTROL_REG 0x5
	34	#define TPS51632_POWER_STATE_REG 0x6
	35	#define TPS51632_SLEW_REGS 0x7
	36	#define TPS51632_FAULT_REG 0x14
	37
	38	#define TPS51632_MAX_REG 0x15
	39
	40	#define TPS51632_VOUT_MASK 0x7F
	41	#define TPS51632_VOUT_OFFSET_MASK 0x1F
	42	#define TPS51632_VMAX_MASK 0x7F
	43	#define TPS51632_VMAX_LOCK 0x80
	44
	45	/* TPS51632_DVFS_CONTROL_REG */
	46	#define TPS51632_DVFS_PWMEN 0x1
	47	#define TPS51632_DVFS_STEP_20 0x2
	48	#define TPS51632_DVFS_VMAX_PG 0x4
	49	#define TPS51632_DVFS_PWMRST 0x8
	50	#define TPS51632_DVFS_OCA_EN 0x10
	51	#define TPS51632_DVFS_FCCM 0x20
	52
	53	/* TPS51632_POWER_STATE_REG */
	54	#define TPS51632_POWER_STATE_MASK 0x03
	55	#define TPS51632_POWER_STATE_MULTI_PHASE_CCM 0x0
	56	#define TPS51632_POWER_STATE_SINGLE_PHASE_CCM 0x1
	57	#define TPS51632_POWER_STATE_SINGLE_PHASE_DCM 0x2
	58
9d9339d3 FE	59	#define TPS51632_MIN_VOLTAGE 500000
	60	#define TPS51632_MAX_VOLTAGE 1520000
	61	#define TPS51632_VOLTAGE_STEP_10mV 10000
	62	#define TPS51632_VOLTAGE_STEP_20mV 20000
0c570674 LD	63	#define TPS51632_MAX_VSEL 0x7F
	64	#define TPS51632_MIN_VSEL 0x19
	65	#define TPS51632_DEFAULT_RAMP_DELAY 6000
	66	#define TPS51632_VOLT_VSEL(uV) \
9d9339d3 FE	67	(DIV_ROUND_UP(uV - TPS51632_MIN_VOLTAGE, \
9d9339d3 FE	68	TPS51632_VOLTAGE_STEP_10mV) + \
0c570674 LD	69	TPS51632_MIN_VSEL)
	70
	71	/* TPS51632 chip information */
	72	struct tps51632_chip {
	73	struct device *dev;
	74	struct regulator_desc desc;
	75	struct regulator_dev *rdev;
	76	struct regmap *regmap;
0c570674 LD	77	};
0c570674 LD	78
0c570674 LD	79	static int tps51632_dcdc_set_ramp_delay(struct regulator_dev *rdev,
	80	int ramp_delay)
	81	{
	82	struct tps51632_chip *tps = rdev_get_drvdata(rdev);
c714a588	83	int bit;
0c570674 LD	84	int ret;
0c570674 LD	85
c714a588 AL	86	if (ramp_delay == 0)
	87	bit = 0;
	88	else
	89	bit = DIV_ROUND_UP(ramp_delay, 6000) - 1;
	90
0c570674 LD	91	ret = regmap_write(tps->regmap, TPS51632_SLEW_REGS, BIT(bit));
	92	if (ret < 0)
	93	dev_err(tps->dev, "SLEW reg write failed, err %d\n", ret);
	94	return ret;
	95	}
	96
dcb97c10	97	static const struct regulator_ops tps51632_dcdc_ops = {
d94d9aca AL	98	.get_voltage_sel = regulator_get_voltage_sel_regmap,
d94d9aca AL	99	.set_voltage_sel = regulator_set_voltage_sel_regmap,
0c570674 LD	100	.list_voltage = regulator_list_voltage_linear,
	101	.set_voltage_time_sel = regulator_set_voltage_time_sel,
	102	.set_ramp_delay = tps51632_dcdc_set_ramp_delay,
	103	};
	104
a5023574	105	static int tps51632_init_dcdc(struct tps51632_chip *tps,
0c570674 LD	106	struct tps51632_regulator_platform_data *pdata)
	107	{
	108	int ret;
	109	uint8_t control = 0;
	110	int vsel;
	111
	112	if (!pdata->enable_pwm_dvfs)
	113	goto skip_pwm_config;
	114
	115	control \|= TPS51632_DVFS_PWMEN;
0c570674 LD	116	vsel = TPS51632_VOLT_VSEL(pdata->base_voltage_uV);
	117	ret = regmap_write(tps->regmap, TPS51632_VOLTAGE_BASE_REG, vsel);
	118	if (ret < 0) {
	119	dev_err(tps->dev, "BASE reg write failed, err %d\n", ret);
	120	return ret;
	121	}
	122
	123	if (pdata->dvfs_step_20mV)
	124	control \|= TPS51632_DVFS_STEP_20;
	125
	126	if (pdata->max_voltage_uV) {
	127	unsigned int vmax;
	128	/**
	129	* TPS51632 hw behavior: VMAX register can be write only
	130	* once as it get locked after first write. The lock get
	131	* reset only when device is power-reset.
	132	* Write register only when lock bit is not enabled.
	133	*/
	134	ret = regmap_read(tps->regmap, TPS51632_VMAX_REG, &vmax);
	135	if (ret < 0) {
	136	dev_err(tps->dev, "VMAX read failed, err %d\n", ret);
	137	return ret;
	138	}
	139	if (!(vmax & TPS51632_VMAX_LOCK)) {
	140	vsel = TPS51632_VOLT_VSEL(pdata->max_voltage_uV);
	141	ret = regmap_write(tps->regmap, TPS51632_VMAX_REG,
	142	vsel);
	143	if (ret < 0) {
	144	dev_err(tps->dev,
	145	"VMAX write failed, err %d\n", ret);
	146	return ret;
	147	}
	148	}
	149	}
	150
	151	skip_pwm_config:
	152	ret = regmap_write(tps->regmap, TPS51632_DVFS_CONTROL_REG, control);
	153	if (ret < 0)
	154	dev_err(tps->dev, "DVFS reg write failed, err %d\n", ret);
	155	return ret;
	156	}
	157
faa3b2d5	158	static bool is_volatile_reg(struct device *dev, unsigned int reg)
0c570674	159	{
faa3b2d5 LD	160	switch (reg) {
	161	case TPS51632_OFFSET_REG:
	162	case TPS51632_FAULT_REG:
	163	case TPS51632_IMON_REG:
	164	return true;
	165	default:
0c570674	166	return false;
faa3b2d5 LD	167	}
	168	}
	169
	170	static bool is_read_reg(struct device *dev, unsigned int reg)
	171	{
	172	switch (reg) {
	173	case 0x08 ... 0x0F:
	174	return false;
	175	default:
	176	return true;
	177	}
	178	}
	179
	180	static bool is_write_reg(struct device *dev, unsigned int reg)
	181	{
	182	switch (reg) {
	183	case TPS51632_VOLTAGE_SELECT_REG:
	184	case TPS51632_VOLTAGE_BASE_REG:
	185	case TPS51632_VMAX_REG:
	186	case TPS51632_DVFS_CONTROL_REG:
	187	case TPS51632_POWER_STATE_REG:
	188	case TPS51632_SLEW_REGS:
	189	return true;
	190	default:
	191	return false;
	192	}
0c570674 LD	193	}
	194
	195	static const struct regmap_config tps51632_regmap_config = {
	196	.reg_bits = 8,
	197	.val_bits = 8,
faa3b2d5 LD	198	.writeable_reg = is_write_reg,
	199	.readable_reg = is_read_reg,
	200	.volatile_reg = is_volatile_reg,
0c570674 LD	201	.max_register = TPS51632_MAX_REG - 1,
	202	.cache_type = REGCACHE_RBTREE,
	203	};
	204
c51ce403 LD	205	#if defined(CONFIG_OF)
	206	static const struct of_device_id tps51632_of_match[] = {
	207	{ .compatible = "ti,tps51632",},
	208	{},
	209	};
	210	MODULE_DEVICE_TABLE(of, tps51632_of_match);
	211
	212	static struct tps51632_regulator_platform_data *
072e78b1 JMC	213	of_get_tps51632_platform_data(struct device *dev,
072e78b1 JMC	214	const struct regulator_desc *desc)
c51ce403 LD	215	{
	216	struct tps51632_regulator_platform_data *pdata;
	217	struct device_node *np = dev->of_node;
	218
	219	pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
ef4bcf88	220	if (!pdata)
c51ce403	221	return NULL;
c51ce403	222
072e78b1 JMC	223	pdata->reg_init_data = of_get_regulator_init_data(dev, dev->of_node,
072e78b1 JMC	224	desc);
c51ce403 LD	225	if (!pdata->reg_init_data) {
	226	dev_err(dev, "Not able to get OF regulator init data\n");
	227	return NULL;
	228	}
	229
	230	pdata->enable_pwm_dvfs =
	231	of_property_read_bool(np, "ti,enable-pwm-dvfs");
	232	pdata->dvfs_step_20mV = of_property_read_bool(np, "ti,dvfs-step-20mV");
	233
	234	pdata->base_voltage_uV = pdata->reg_init_data->constraints.min_uV ? :
9d9339d3	235	TPS51632_MIN_VOLTAGE;
c51ce403	236	pdata->max_voltage_uV = pdata->reg_init_data->constraints.max_uV ? :
9d9339d3	237	TPS51632_MAX_VOLTAGE;
c51ce403 LD	238	return pdata;
	239	}
	240	#else
	241	static struct tps51632_regulator_platform_data *
072e78b1 JMC	242	of_get_tps51632_platform_data(struct device *dev,
072e78b1 JMC	243	const struct regulator_desc *desc)
c51ce403 LD	244	{
	245	return NULL;
	246	}
	247	#endif
	248
d4885f30	249	static int tps51632_probe(struct i2c_client *client)
0c570674 LD	250	{
	251	struct tps51632_regulator_platform_data *pdata;
	252	struct regulator_dev *rdev;
	253	struct tps51632_chip *tps;
	254	int ret;
	255	struct regulator_config config = { };
	256
072e78b1 JMC	257	tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL);
	258	if (!tps)
	259	return -ENOMEM;
	260
	261	tps->dev = &client->dev;
	262	tps->desc.name = client->name;
	263	tps->desc.id = 0;
	264	tps->desc.ramp_delay = TPS51632_DEFAULT_RAMP_DELAY;
	265	tps->desc.min_uV = TPS51632_MIN_VOLTAGE;
	266	tps->desc.uV_step = TPS51632_VOLTAGE_STEP_10mV;
	267	tps->desc.linear_min_sel = TPS51632_MIN_VSEL;
	268	tps->desc.n_voltages = TPS51632_MAX_VSEL + 1;
	269	tps->desc.ops = &tps51632_dcdc_ops;
	270	tps->desc.type = REGULATOR_VOLTAGE;
	271	tps->desc.owner = THIS_MODULE;
	272
dff91d0b	273	pdata = dev_get_platdata(&client->dev);
c51ce403	274	if (!pdata && client->dev.of_node)
072e78b1	275	pdata = of_get_tps51632_platform_data(&client->dev, &tps->desc);
0c570674 LD	276	if (!pdata) {
	277	dev_err(&client->dev, "No Platform data\n");
	278	return -EINVAL;
	279	}
	280
dbc70518	281	if (pdata->enable_pwm_dvfs) {
9d9339d3 FE	282	if ((pdata->base_voltage_uV < TPS51632_MIN_VOLTAGE) \|\|
9d9339d3 FE	283	(pdata->base_voltage_uV > TPS51632_MAX_VOLTAGE)) {
dbc70518 AL	284	dev_err(&client->dev, "Invalid base_voltage_uV setting\n");
	285	return -EINVAL;
	286	}
	287
	288	if ((pdata->max_voltage_uV) &&
9d9339d3 FE	289	((pdata->max_voltage_uV < TPS51632_MIN_VOLTAGE) \|\|
9d9339d3 FE	290	(pdata->max_voltage_uV > TPS51632_MAX_VOLTAGE))) {
dbc70518 AL	291	dev_err(&client->dev, "Invalid max_voltage_uV setting\n");
	292	return -EINVAL;
	293	}
	294	}
	295
d94d9aca AL	296	if (pdata->enable_pwm_dvfs)
	297	tps->desc.vsel_reg = TPS51632_VOLTAGE_BASE_REG;
	298	else
	299	tps->desc.vsel_reg = TPS51632_VOLTAGE_SELECT_REG;
	300	tps->desc.vsel_mask = TPS51632_VOUT_MASK;
	301
0c570674 LD	302	tps->regmap = devm_regmap_init_i2c(client, &tps51632_regmap_config);
	303	if (IS_ERR(tps->regmap)) {
	304	ret = PTR_ERR(tps->regmap);
	305	dev_err(&client->dev, "regmap init failed, err %d\n", ret);
	306	return ret;
	307	}
	308	i2c_set_clientdata(client, tps);
	309
	310	ret = tps51632_init_dcdc(tps, pdata);
	311	if (ret < 0) {
	312	dev_err(tps->dev, "Init failed, err = %d\n", ret);
	313	return ret;
	314	}
	315
	316	/* Register the regulators */
	317	config.dev = &client->dev;
	318	config.init_data = pdata->reg_init_data;
	319	config.driver_data = tps;
	320	config.regmap = tps->regmap;
	321	config.of_node = client->dev.of_node;
	322
1084081d	323	rdev = devm_regulator_register(&client->dev, &tps->desc, &config);
0c570674 LD	324	if (IS_ERR(rdev)) {
	325	dev_err(tps->dev, "regulator register failed\n");
	326	return PTR_ERR(rdev);
	327	}
	328
	329	tps->rdev = rdev;
	330	return 0;
	331	}
	332
0c570674 LD	333	static const struct i2c_device_id tps51632_id[] = {
	334	{.name = "tps51632",},
	335	{},
	336	};
	337
	338	MODULE_DEVICE_TABLE(i2c, tps51632_id);
	339
	340	static struct i2c_driver tps51632_i2c_driver = {
	341	.driver = {
	342	.name = "tps51632",
259b93b2	343	.probe_type = PROBE_PREFER_ASYNCHRONOUS,
c51ce403	344	.of_match_table = of_match_ptr(tps51632_of_match),
0c570674	345	},
964e1865	346	.probe = tps51632_probe,
0c570674 LD	347	.id_table = tps51632_id,
	348	};
	349
	350	static int __init tps51632_init(void)
	351	{
	352	return i2c_add_driver(&tps51632_i2c_driver);
	353	}
	354	subsys_initcall(tps51632_init);
	355
	356	static void __exit tps51632_cleanup(void)
	357	{
	358	i2c_del_driver(&tps51632_i2c_driver);
	359	}
	360	module_exit(tps51632_cleanup);
	361
	362	MODULE_AUTHOR("Laxman Dewangan <ldewangan@nvidia.com>");
	363	MODULE_DESCRIPTION("TPS51632 voltage regulator driver");
	364	MODULE_LICENSE("GPL v2");