[deliverable/linux.git] / drivers / regulator / tps65218-regulator.c

/*
 * tps65218-regulator.c
 *
 * Regulator driver for TPS65218 PMIC
 *
 * Copyright (C) 2014 Texas Instruments Incorporated - http://www.ti.com/
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * This program is distributed "as is" WITHOUT ANY WARRANTY of any
 * kind, whether expressed or implied; without even the implied warranty
 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License version 2 for more details.
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/device.h>
#include <linux/init.h>
#include <linux/err.h>
#include <linux/platform_device.h>
#include <linux/of_device.h>
#include <linux/regulator/of_regulator.h>
#include <linux/regulator/driver.h>
#include <linux/regulator/machine.h>
#include <linux/mfd/tps65218.h>

static unsigned int tps65218_ramp_delay = 4000;

enum tps65218_regulators { DCDC1, DCDC2, DCDC3, DCDC4, DCDC5, DCDC6, LDO1 };

#define TPS65218_REGULATOR(_name, _id, _ops, _n, _vr, _vm, _er, _em, _t, \
			    _lr, _nlr)				\
	{							\
		.name			= _name,		\
		.id			= _id,			\
		.ops			= &_ops,		\
		.n_voltages		= _n,			\
		.type			= REGULATOR_VOLTAGE,	\
		.owner			= THIS_MODULE,		\
		.vsel_reg		= _vr,			\
		.vsel_mask		= _vm,			\
		.enable_reg		= _er,			\
		.enable_mask		= _em,			\
		.volt_table		= _t,			\
		.linear_ranges		= _lr,			\
		.n_linear_ranges	= _nlr,			\
	}							\

#define TPS65218_INFO(_id, _nm, _min, _max)	\
	{						\
		.id		= _id,			\
		.name		= _nm,			\
		.min_uV		= _min,			\
		.max_uV		= _max,			\
	}

static const struct regulator_linear_range dcdc1_dcdc2_ranges[] = {
	REGULATOR_LINEAR_RANGE(850000, 0x0, 0x32, 10000),
	REGULATOR_LINEAR_RANGE(1375000, 0x33, 0x3f, 25000),
};

static const struct regulator_linear_range ldo1_dcdc3_ranges[] = {
	REGULATOR_LINEAR_RANGE(900000, 0x0, 0x1a, 25000),
	REGULATOR_LINEAR_RANGE(1600000, 0x1b, 0x3f, 50000),
};

static const struct regulator_linear_range dcdc4_ranges[] = {
	REGULATOR_LINEAR_RANGE(1175000, 0x0, 0xf, 25000),
	REGULATOR_LINEAR_RANGE(1550000, 0x10, 0x34, 50000),
};

static struct tps_info tps65218_pmic_regs[] = {
	TPS65218_INFO(0, "DCDC1", 850000, 167500),
	TPS65218_INFO(1, "DCDC2", 850000, 1675000),
	TPS65218_INFO(2, "DCDC3", 900000, 3400000),
	TPS65218_INFO(3, "DCDC4", 1175000, 3400000),
	TPS65218_INFO(4, "DCDC5", 1000000, 1000000),
	TPS65218_INFO(5, "DCDC6", 1800000, 1800000),
	TPS65218_INFO(6, "LDO1", 900000, 3400000),
};

#define TPS65218_OF_MATCH(comp, label) \
	{ \
		.compatible = comp, \
		.data = &label, \
	}

static const struct of_device_id tps65218_of_match[] = {
	TPS65218_OF_MATCH("ti,tps65218-dcdc1", tps65218_pmic_regs[DCDC1]),
	TPS65218_OF_MATCH("ti,tps65218-dcdc2", tps65218_pmic_regs[DCDC2]),
	TPS65218_OF_MATCH("ti,tps65218-dcdc3", tps65218_pmic_regs[DCDC3]),
	TPS65218_OF_MATCH("ti,tps65218-dcdc4", tps65218_pmic_regs[DCDC4]),
	TPS65218_OF_MATCH("ti,tps65218-dcdc5", tps65218_pmic_regs[DCDC5]),
	TPS65218_OF_MATCH("ti,tps65218-dcdc6", tps65218_pmic_regs[DCDC6]),
	TPS65218_OF_MATCH("ti,tps65218-ldo1", tps65218_pmic_regs[LDO1]),
};
MODULE_DEVICE_TABLE(of, tps65218_of_match);

static int tps65218_pmic_set_voltage_sel(struct regulator_dev *dev,
					 unsigned selector)
{
	int ret;
	struct tps65218 *tps = rdev_get_drvdata(dev);
	unsigned int rid = rdev_get_id(dev);

	/* Set the voltage based on vsel value and write protect level is 2 */
	ret = tps65218_set_bits(tps, dev->desc->vsel_reg, dev->desc->vsel_mask,
				selector, TPS65218_PROTECT_L1);

	/* Set GO bit for DCDC1/2 to initiate voltage transistion */
	switch (rid) {
	case TPS65218_DCDC_1:
	case TPS65218_DCDC_2:
		ret = tps65218_set_bits(tps, TPS65218_REG_CONTRL_SLEW_RATE,
					TPS65218_SLEW_RATE_GO,
					TPS65218_SLEW_RATE_GO,
					TPS65218_PROTECT_L1);
		break;
	}

	return ret;
}

static int tps65218_pmic_enable(struct regulator_dev *dev)
{
	struct tps65218 *tps = rdev_get_drvdata(dev);
	unsigned int rid = rdev_get_id(dev);

	if (rid < TPS65218_DCDC_1 || rid > TPS65218_LDO_1)
		return -EINVAL;

	/* Enable the regulator and password protection is level 1 */
	return tps65218_set_bits(tps, dev->desc->enable_reg,
				 dev->desc->enable_mask, dev->desc->enable_mask,
				 TPS65218_PROTECT_L1);
}

static int tps65218_pmic_disable(struct regulator_dev *dev)
{
	struct tps65218 *tps = rdev_get_drvdata(dev);
	unsigned int rid = rdev_get_id(dev);

	if (rid < TPS65218_DCDC_1 || rid > TPS65218_LDO_1)
		return -EINVAL;

	/* Disable the regulator and password protection is level 1 */
	return tps65218_clear_bits(tps, dev->desc->enable_reg,
				   dev->desc->enable_mask, TPS65218_PROTECT_L1);
}

static int tps65218_set_voltage_time_sel(struct regulator_dev *rdev,
	unsigned int old_selector, unsigned int new_selector)
{
	int old_uv, new_uv;

	old_uv = regulator_list_voltage_linear_range(rdev, old_selector);
	if (old_uv < 0)
		return old_uv;

	new_uv = regulator_list_voltage_linear_range(rdev, new_selector);
	if (new_uv < 0)
		return new_uv;

	return DIV_ROUND_UP(abs(old_uv - new_uv), tps65218_ramp_delay);
}

/* Operations permitted on DCDC1, DCDC2 */
static struct regulator_ops tps65218_dcdc12_ops = {
	.is_enabled		= regulator_is_enabled_regmap,
	.enable			= tps65218_pmic_enable,
	.disable		= tps65218_pmic_disable,
	.get_voltage_sel	= regulator_get_voltage_sel_regmap,
	.set_voltage_sel	= tps65218_pmic_set_voltage_sel,
	.list_voltage		= regulator_list_voltage_linear_range,
	.map_voltage		= regulator_map_voltage_linear_range,
	.set_voltage_time_sel	= tps65218_set_voltage_time_sel,
};

/* Operations permitted on DCDC3, DCDC4 and LDO1 */
static struct regulator_ops tps65218_ldo1_dcdc34_ops = {
	.is_enabled		= regulator_is_enabled_regmap,
	.enable			= tps65218_pmic_enable,
	.disable		= tps65218_pmic_disable,
	.get_voltage_sel	= regulator_get_voltage_sel_regmap,
	.set_voltage_sel	= tps65218_pmic_set_voltage_sel,
	.list_voltage		= regulator_list_voltage_linear_range,
	.map_voltage		= regulator_map_voltage_linear_range,
};

/* Operations permitted on DCDC5, DCDC6 */
static struct regulator_ops tps65218_dcdc56_pmic_ops = {
	.is_enabled		= regulator_is_enabled_regmap,
	.enable			= tps65218_pmic_enable,
	.disable		= tps65218_pmic_disable,
};

static const struct regulator_desc regulators[] = {
	TPS65218_REGULATOR("DCDC1", TPS65218_DCDC_1, tps65218_dcdc12_ops, 64,
			   TPS65218_REG_CONTROL_DCDC1,
			   TPS65218_CONTROL_DCDC1_MASK,
			   TPS65218_REG_ENABLE1, TPS65218_ENABLE1_DC1_EN, NULL,
			   dcdc1_dcdc2_ranges, 2),
	TPS65218_REGULATOR("DCDC2", TPS65218_DCDC_2, tps65218_dcdc12_ops, 64,
			   TPS65218_REG_CONTROL_DCDC2,
			   TPS65218_CONTROL_DCDC2_MASK,
			   TPS65218_REG_ENABLE1, TPS65218_ENABLE1_DC2_EN, NULL,
			   dcdc1_dcdc2_ranges, 2),
	TPS65218_REGULATOR("DCDC3", TPS65218_DCDC_3, tps65218_ldo1_dcdc34_ops,
			   64, TPS65218_REG_CONTROL_DCDC3,
			   TPS65218_CONTROL_DCDC3_MASK, TPS65218_REG_ENABLE1,
			   TPS65218_ENABLE1_DC3_EN, NULL,
			   ldo1_dcdc3_ranges, 2),
	TPS65218_REGULATOR("DCDC4", TPS65218_DCDC_4, tps65218_ldo1_dcdc34_ops,
			   53, TPS65218_REG_CONTROL_DCDC4,
			   TPS65218_CONTROL_DCDC4_MASK,
			   TPS65218_REG_ENABLE1, TPS65218_ENABLE1_DC4_EN, NULL,
			   dcdc4_ranges, 2),
	TPS65218_REGULATOR("DCDC5", TPS65218_DCDC_5, tps65218_dcdc56_pmic_ops,
			   1, -1, -1, TPS65218_REG_ENABLE1,
			   TPS65218_ENABLE1_DC5_EN, NULL, NULL, 0),
	TPS65218_REGULATOR("DCDC6", TPS65218_DCDC_6, tps65218_dcdc56_pmic_ops,
			   1, -1, -1, TPS65218_REG_ENABLE1,
			   TPS65218_ENABLE1_DC6_EN, NULL, NULL, 0),
	TPS65218_REGULATOR("LDO1", TPS65218_LDO_1, tps65218_ldo1_dcdc34_ops, 64,
			   TPS65218_REG_CONTROL_DCDC4,
			   TPS65218_CONTROL_LDO1_MASK, TPS65218_REG_ENABLE2,
			   TPS65218_ENABLE2_LDO1_EN, NULL, ldo1_dcdc3_ranges,
			   2),
};

static int tps65218_regulator_probe(struct platform_device *pdev)
{
	struct tps65218 *tps = dev_get_drvdata(pdev->dev.parent);
	struct regulator_init_data *init_data;
	const struct tps_info	*template;
	struct regulator_dev *rdev;
	const struct of_device_id	*match;
	struct regulator_config config = { };
	int id;

	match = of_match_device(tps65218_of_match, &pdev->dev);
	if (match) {
		template = match->data;
		id = template->id;
		init_data = of_get_regulator_init_data(&pdev->dev,
						      pdev->dev.of_node);
	} else {
		return -ENODEV;
	}

	platform_set_drvdata(pdev, tps);

	tps->info[id] = &tps65218_pmic_regs[id];
	config.dev = &pdev->dev;
	config.init_data = init_data;
	config.driver_data = tps;
	config.regmap = tps->regmap;

	rdev = devm_regulator_register(&pdev->dev, &regulators[id], &config);
	if (IS_ERR(rdev)) {
		dev_err(tps->dev, "failed to register %s regulator\n",
			pdev->name);
		return PTR_ERR(rdev);
	}

	/* Save regulator */
	tps->rdev[id] = rdev;

	return 0;
}

static int tps65218_regulator_remove(struct platform_device *pdev)
{
	struct tps65218 *tps = platform_get_drvdata(pdev);
	const struct of_device_id	*match;
	const struct tps_info		*template;

	match = of_match_device(tps65218_of_match, &pdev->dev);
	template = match->data;
	regulator_unregister(tps->rdev[template->id]);
	platform_set_drvdata(pdev, NULL);

	return 0;
}

static struct platform_driver tps65218_regulator_driver = {
	.driver = {
		.name = "tps65218-pmic",
		.owner = THIS_MODULE,
		.of_match_table = of_match_ptr(tps65218_of_match),
	},
	.probe = tps65218_regulator_probe,
	.remove = tps65218_regulator_remove,
};

module_platform_driver(tps65218_regulator_driver);

MODULE_AUTHOR("J Keerthy <j-keerthy@ti.com>");
MODULE_DESCRIPTION("TPS65218 voltage regulator driver");
MODULE_ALIAS("platform:tps65218-pmic");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
90e7d526 K	1	/*
	2	* tps65218-regulator.c
	3	*
	4	* Regulator driver for TPS65218 PMIC
	5	*
	6	* Copyright (C) 2014 Texas Instruments Incorporated - http://www.ti.com/
	7	*
	8	* This program is free software; you can redistribute it and/or
	9	* modify it under the terms of the GNU General Public License version 2 as
	10	* published by the Free Software Foundation.
	11	*
	12	* This program is distributed "as is" WITHOUT ANY WARRANTY of any
	13	* kind, whether expressed or implied; without even the implied warranty
	14	* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License version 2 for more details.
	16	*/
	17
	18	#include <linux/kernel.h>
	19	#include <linux/module.h>
	20	#include <linux/device.h>
	21	#include <linux/init.h>
	22	#include <linux/err.h>
	23	#include <linux/platform_device.h>
	24	#include <linux/of_device.h>
	25	#include <linux/regulator/of_regulator.h>
	26	#include <linux/regulator/driver.h>
	27	#include <linux/regulator/machine.h>
	28	#include <linux/mfd/tps65218.h>
	29
	30	static unsigned int tps65218_ramp_delay = 4000;
	31
	32	enum tps65218_regulators { DCDC1, DCDC2, DCDC3, DCDC4, DCDC5, DCDC6, LDO1 };
	33
	34	#define TPS65218_REGULATOR(_name, _id, _ops, _n, _vr, _vm, _er, _em, _t, \
	35	_lr, _nlr) \
	36	{ \
	37	.name = _name, \
	38	.id = _id, \
	39	.ops = &_ops, \
	40	.n_voltages = _n, \
	41	.type = REGULATOR_VOLTAGE, \
	42	.owner = THIS_MODULE, \
	43	.vsel_reg = _vr, \
	44	.vsel_mask = _vm, \
	45	.enable_reg = _er, \
	46	.enable_mask = _em, \
	47	.volt_table = _t, \
	48	.linear_ranges = _lr, \
	49	.n_linear_ranges = _nlr, \
	50	} \
	51
	52	#define TPS65218_INFO(_id, _nm, _min, _max) \
	53	{ \
	54	.id = _id, \
	55	.name = _nm, \
	56	.min_uV = _min, \
	57	.max_uV = _max, \
	58	}
	59
	60	static const struct regulator_linear_range dcdc1_dcdc2_ranges[] = {
	61	REGULATOR_LINEAR_RANGE(850000, 0x0, 0x32, 10000),
	62	REGULATOR_LINEAR_RANGE(1375000, 0x33, 0x3f, 25000),
	63	};
	64
65	static const struct regulator_linear_range ldo1_dcdc3_ranges[] = {
66	REGULATOR_LINEAR_RANGE(900000, 0x0, 0x1a, 25000),
67	REGULATOR_LINEAR_RANGE(1600000, 0x1b, 0x3f, 50000),
68	};
69
70	static const struct regulator_linear_range dcdc4_ranges[] = {
71	REGULATOR_LINEAR_RANGE(1175000, 0x0, 0xf, 25000),
72	REGULATOR_LINEAR_RANGE(1550000, 0x10, 0x34, 50000),
73	};
74
75	static struct tps_info tps65218_pmic_regs[] = {
76	TPS65218_INFO(0, "DCDC1", 850000, 167500),
77	TPS65218_INFO(1, "DCDC2", 850000, 1675000),
78	TPS65218_INFO(2, "DCDC3", 900000, 3400000),
79	TPS65218_INFO(3, "DCDC4", 1175000, 3400000),
80	TPS65218_INFO(4, "DCDC5", 1000000, 1000000),
81	TPS65218_INFO(5, "DCDC6", 1800000, 1800000),
82	TPS65218_INFO(6, "LDO1", 900000, 3400000),
83	};
84
85	#define TPS65218_OF_MATCH(comp, label) \
86	{ \
87	.compatible = comp, \
88	.data = &label, \
89	}
90
91	static const struct of_device_id tps65218_of_match[] = {
92	TPS65218_OF_MATCH("ti,tps65218-dcdc1", tps65218_pmic_regs[DCDC1]),
93	TPS65218_OF_MATCH("ti,tps65218-dcdc2", tps65218_pmic_regs[DCDC2]),
94	TPS65218_OF_MATCH("ti,tps65218-dcdc3", tps65218_pmic_regs[DCDC3]),
95	TPS65218_OF_MATCH("ti,tps65218-dcdc4", tps65218_pmic_regs[DCDC4]),
96	TPS65218_OF_MATCH("ti,tps65218-dcdc5", tps65218_pmic_regs[DCDC5]),
97	TPS65218_OF_MATCH("ti,tps65218-dcdc6", tps65218_pmic_regs[DCDC6]),
98	TPS65218_OF_MATCH("ti,tps65218-ldo1", tps65218_pmic_regs[LDO1]),
99	};
100	MODULE_DEVICE_TABLE(of, tps65218_of_match);
101
102	static int tps65218_pmic_set_voltage_sel(struct regulator_dev *dev,
103	unsigned selector)
104	{
105	int ret;
106	struct tps65218 *tps = rdev_get_drvdata(dev);
107	unsigned int rid = rdev_get_id(dev);
108
109	/* Set the voltage based on vsel value and write protect level is 2 */
110	ret = tps65218_set_bits(tps, dev->desc->vsel_reg, dev->desc->vsel_mask,
111	selector, TPS65218_PROTECT_L1);
112
113	/* Set GO bit for DCDC1/2 to initiate voltage transistion */
114	switch (rid) {
115	case TPS65218_DCDC_1:
116	case TPS65218_DCDC_2:
117	ret = tps65218_set_bits(tps, TPS65218_REG_CONTRL_SLEW_RATE,
118	TPS65218_SLEW_RATE_GO,
119	TPS65218_SLEW_RATE_GO,
120	TPS65218_PROTECT_L1);
121	break;
122	}
123
124	return ret;
125	}
126
127	static int tps65218_pmic_enable(struct regulator_dev *dev)
128	{
129	struct tps65218 *tps = rdev_get_drvdata(dev);
130	unsigned int rid = rdev_get_id(dev);
131
132	if (rid < TPS65218_DCDC_1 \|\| rid > TPS65218_LDO_1)
133	return -EINVAL;
134
135	/* Enable the regulator and password protection is level 1 */
136	return tps65218_set_bits(tps, dev->desc->enable_reg,
137	dev->desc->enable_mask, dev->desc->enable_mask,
138	TPS65218_PROTECT_L1);
139	}
140
141	static int tps65218_pmic_disable(struct regulator_dev *dev)
142	{
143	struct tps65218 *tps = rdev_get_drvdata(dev);
144	unsigned int rid = rdev_get_id(dev);
145
146	if (rid < TPS65218_DCDC_1 \|\| rid > TPS65218_LDO_1)
147	return -EINVAL;
148
149	/* Disable the regulator and password protection is level 1 */
150	return tps65218_clear_bits(tps, dev->desc->enable_reg,
151	dev->desc->enable_mask, TPS65218_PROTECT_L1);
152	}
153
154	static int tps65218_set_voltage_time_sel(struct regulator_dev *rdev,
155	unsigned int old_selector, unsigned int new_selector)
156	{
157	int old_uv, new_uv;
158
159	old_uv = regulator_list_voltage_linear_range(rdev, old_selector);
160	if (old_uv < 0)
161	return old_uv;
162
163	new_uv = regulator_list_voltage_linear_range(rdev, new_selector);
164	if (new_uv < 0)
165	return new_uv;
166
167	return DIV_ROUND_UP(abs(old_uv - new_uv), tps65218_ramp_delay);
168	}
169
170	/* Operations permitted on DCDC1, DCDC2 */
171	static struct regulator_ops tps65218_dcdc12_ops = {
172	.is_enabled = regulator_is_enabled_regmap,
173	.enable = tps65218_pmic_enable,
174	.disable = tps65218_pmic_disable,
175	.get_voltage_sel = regulator_get_voltage_sel_regmap,
176	.set_voltage_sel = tps65218_pmic_set_voltage_sel,
177	.list_voltage = regulator_list_voltage_linear_range,
178	.map_voltage = regulator_map_voltage_linear_range,
179	.set_voltage_time_sel = tps65218_set_voltage_time_sel,
180	};
181
182	/* Operations permitted on DCDC3, DCDC4 and LDO1 */
183	static struct regulator_ops tps65218_ldo1_dcdc34_ops = {
184	.is_enabled = regulator_is_enabled_regmap,
185	.enable = tps65218_pmic_enable,
186	.disable = tps65218_pmic_disable,
187	.get_voltage_sel = regulator_get_voltage_sel_regmap,
188	.set_voltage_sel = tps65218_pmic_set_voltage_sel,
189	.list_voltage = regulator_list_voltage_linear_range,
190	.map_voltage = regulator_map_voltage_linear_range,
191	};
192
193	/* Operations permitted on DCDC5, DCDC6 */
194	static struct regulator_ops tps65218_dcdc56_pmic_ops = {
195	.is_enabled = regulator_is_enabled_regmap,
196	.enable = tps65218_pmic_enable,
197	.disable = tps65218_pmic_disable,
198	};
199
200	static const struct regulator_desc regulators[] = {
201	TPS65218_REGULATOR("DCDC1", TPS65218_DCDC_1, tps65218_dcdc12_ops, 64,
202	TPS65218_REG_CONTROL_DCDC1,
203	TPS65218_CONTROL_DCDC1_MASK,
204	TPS65218_REG_ENABLE1, TPS65218_ENABLE1_DC1_EN, NULL,
205	dcdc1_dcdc2_ranges, 2),
206	TPS65218_REGULATOR("DCDC2", TPS65218_DCDC_2, tps65218_dcdc12_ops, 64,
207	TPS65218_REG_CONTROL_DCDC2,
208	TPS65218_CONTROL_DCDC2_MASK,
209	TPS65218_REG_ENABLE1, TPS65218_ENABLE1_DC2_EN, NULL,
210	dcdc1_dcdc2_ranges, 2),
211	TPS65218_REGULATOR("DCDC3", TPS65218_DCDC_3, tps65218_ldo1_dcdc34_ops,
212	64, TPS65218_REG_CONTROL_DCDC3,
213	TPS65218_CONTROL_DCDC3_MASK, TPS65218_REG_ENABLE1,
214	TPS65218_ENABLE1_DC3_EN, NULL,
215	ldo1_dcdc3_ranges, 2),
216	TPS65218_REGULATOR("DCDC4", TPS65218_DCDC_4, tps65218_ldo1_dcdc34_ops,
217	53, TPS65218_REG_CONTROL_DCDC4,
218	TPS65218_CONTROL_DCDC4_MASK,
219	TPS65218_REG_ENABLE1, TPS65218_ENABLE1_DC4_EN, NULL,
220	dcdc4_ranges, 2),
221	TPS65218_REGULATOR("DCDC5", TPS65218_DCDC_5, tps65218_dcdc56_pmic_ops,
222	1, -1, -1, TPS65218_REG_ENABLE1,
223	TPS65218_ENABLE1_DC5_EN, NULL, NULL, 0),
224	TPS65218_REGULATOR("DCDC6", TPS65218_DCDC_6, tps65218_dcdc56_pmic_ops,
225	1, -1, -1, TPS65218_REG_ENABLE1,
226	TPS65218_ENABLE1_DC6_EN, NULL, NULL, 0),
227	TPS65218_REGULATOR("LDO1", TPS65218_LDO_1, tps65218_ldo1_dcdc34_ops, 64,
228	TPS65218_REG_CONTROL_DCDC4,
229	TPS65218_CONTROL_LDO1_MASK, TPS65218_REG_ENABLE2,
230	TPS65218_ENABLE2_LDO1_EN, NULL, ldo1_dcdc3_ranges,
231	2),
232	};
233
234	static int tps65218_regulator_probe(struct platform_device *pdev)
235	{
236	struct tps65218 *tps = dev_get_drvdata(pdev->dev.parent);
237	struct regulator_init_data *init_data;
238	const struct tps_info *template;
239	struct regulator_dev *rdev;
240	const struct of_device_id *match;
241	struct regulator_config config = { };
242	int id;
243
244	match = of_match_device(tps65218_of_match, &pdev->dev);
245	if (match) {
246	template = match->data;
247	id = template->id;
248	init_data = of_get_regulator_init_data(&pdev->dev,
249	pdev->dev.of_node);
250	} else {
251	return -ENODEV;
252	}
253
254	platform_set_drvdata(pdev, tps);
255
256	tps->info[id] = &tps65218_pmic_regs[id];
257	config.dev = &pdev->dev;
258	config.init_data = init_data;
259	config.driver_data = tps;
260	config.regmap = tps->regmap;
261
262	rdev = devm_regulator_register(&pdev->dev, &regulators[id], &config);
263	if (IS_ERR(rdev)) {
264	dev_err(tps->dev, "failed to register %s regulator\n",
265	pdev->name);
266	return PTR_ERR(rdev);
267	}
268
269	/* Save regulator */
270	tps->rdev[id] = rdev;
271
272	return 0;
273	}
274
275	static int tps65218_regulator_remove(struct platform_device *pdev)
276	{
277	struct tps65218 *tps = platform_get_drvdata(pdev);
278	const struct of_device_id *match;
279	const struct tps_info *template;
280
281	match = of_match_device(tps65218_of_match, &pdev->dev);
282	template = match->data;
283	regulator_unregister(tps->rdev[template->id]);
284	platform_set_drvdata(pdev, NULL);
285
286	return 0;
287	}
288
289	static struct platform_driver tps65218_regulator_driver = {
290	.driver = {
291	.name = "tps65218-pmic",
292	.owner = THIS_MODULE,
293	.of_match_table = of_match_ptr(tps65218_of_match),
294	},
295	.probe = tps65218_regulator_probe,
296	.remove = tps65218_regulator_remove,
297	};
298
299	module_platform_driver(tps65218_regulator_driver);
300
301	MODULE_AUTHOR("J Keerthy <j-keerthy@ti.com>");
302	MODULE_DESCRIPTION("TPS65218 voltage regulator driver");
303	MODULE_ALIAS("platform:tps65218-pmic");
304	MODULE_LICENSE("GPL v2");