1/*
2 * tps65023-regulator.c
3 *
4 * Supports TPS65023 Regulator
5 *
6 * Copyright (C) 2009 Texas Instrument 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 as
10 * published by the Free Software Foundation version 2.
11 *
12 * This program is distributed "as is" WITHOUT ANY WARRANTY of any kind,
13 * whether express or implied; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15 * General Public License for more details.
16 */
17
18#include <linux/kernel.h>
19#include <linux/module.h>
20#include <linux/init.h>
21#include <linux/err.h>
22#include <linux/platform_device.h>
23#include <linux/regulator/driver.h>
24#include <linux/regulator/machine.h>
25#include <linux/i2c.h>
26#include <linux/slab.h>
27#include <linux/regmap.h>
28
29/* Register definitions */
30#define	TPS65023_REG_VERSION		0
31#define	TPS65023_REG_PGOODZ		1
32#define	TPS65023_REG_MASK		2
33#define	TPS65023_REG_REG_CTRL		3
34#define	TPS65023_REG_CON_CTRL		4
35#define	TPS65023_REG_CON_CTRL2		5
36#define	TPS65023_REG_DEF_CORE		6
37#define	TPS65023_REG_DEFSLEW		7
38#define	TPS65023_REG_LDO_CTRL		8
39
40/* PGOODZ bitfields */
41#define	TPS65023_PGOODZ_PWRFAILZ	BIT(7)
42#define	TPS65023_PGOODZ_LOWBATTZ	BIT(6)
43#define	TPS65023_PGOODZ_VDCDC1		BIT(5)
44#define	TPS65023_PGOODZ_VDCDC2		BIT(4)
45#define	TPS65023_PGOODZ_VDCDC3		BIT(3)
46#define	TPS65023_PGOODZ_LDO2		BIT(2)
47#define	TPS65023_PGOODZ_LDO1		BIT(1)
48
49/* MASK bitfields */
50#define	TPS65023_MASK_PWRFAILZ		BIT(7)
51#define	TPS65023_MASK_LOWBATTZ		BIT(6)
52#define	TPS65023_MASK_VDCDC1		BIT(5)
53#define	TPS65023_MASK_VDCDC2		BIT(4)
54#define	TPS65023_MASK_VDCDC3		BIT(3)
55#define	TPS65023_MASK_LDO2		BIT(2)
56#define	TPS65023_MASK_LDO1		BIT(1)
57
58/* REG_CTRL bitfields */
59#define TPS65023_REG_CTRL_VDCDC1_EN	BIT(5)
60#define TPS65023_REG_CTRL_VDCDC2_EN	BIT(4)
61#define TPS65023_REG_CTRL_VDCDC3_EN	BIT(3)
62#define TPS65023_REG_CTRL_LDO2_EN	BIT(2)
63#define TPS65023_REG_CTRL_LDO1_EN	BIT(1)
64
65/* REG_CTRL2 bitfields */
66#define TPS65023_REG_CTRL2_GO		BIT(7)
67#define TPS65023_REG_CTRL2_CORE_ADJ	BIT(6)
68#define TPS65023_REG_CTRL2_DCDC2	BIT(2)
69#define TPS65023_REG_CTRL2_DCDC1	BIT(1)
70#define TPS65023_REG_CTRL2_DCDC3	BIT(0)
71
72/* Number of step-down converters available */
73#define TPS65023_NUM_DCDC		3
74/* Number of LDO voltage regulators  available */
75#define TPS65023_NUM_LDO		2
76/* Number of total regulators available */
77#define TPS65023_NUM_REGULATOR	(TPS65023_NUM_DCDC + TPS65023_NUM_LDO)
78
79/* DCDCs */
80#define TPS65023_DCDC_1			0
81#define TPS65023_DCDC_2			1
82#define TPS65023_DCDC_3			2
83/* LDOs */
84#define TPS65023_LDO_1			3
85#define TPS65023_LDO_2			4
86
87#define TPS65023_MAX_REG_ID		TPS65023_LDO_2
88
89#define TPS65023_REGULATOR_DCDC(_num, _t, _em)			\
90	{							\
91		.name		= "VDCDC"#_num,			\
92		.of_match	= of_match_ptr("VDCDC"#_num),	\
93		.regulators_node = of_match_ptr("regulators"),	\
94		.id		= TPS65023_DCDC_##_num,		\
95		.n_voltages     = ARRAY_SIZE(_t),		\
96		.ops		= &tps65023_dcdc_ops,		\
97		.type		= REGULATOR_VOLTAGE,		\
98		.owner		= THIS_MODULE,			\
99		.volt_table	= _t,				\
100		.vsel_reg	= TPS65023_REG_DEF_CORE,	\
101		.vsel_mask	= ARRAY_SIZE(_t) - 1,		\
102		.enable_mask	= _em,				\
103		.enable_reg	= TPS65023_REG_REG_CTRL,	\
104		.apply_reg	= TPS65023_REG_CON_CTRL2,	\
105		.apply_bit	= TPS65023_REG_CTRL2_GO,	\
106	}							\
107
108#define TPS65023_REGULATOR_LDO(_num, _t, _vm)			\
109	{							\
110		.name		= "LDO"#_num,			\
111		.of_match	= of_match_ptr("LDO"#_num),	\
112		.regulators_node = of_match_ptr("regulators"),	\
113		.id		= TPS65023_LDO_##_num,		\
114		.n_voltages     = ARRAY_SIZE(_t),		\
115		.ops		= &tps65023_ldo_ops,		\
116		.type		= REGULATOR_VOLTAGE,		\
117		.owner		= THIS_MODULE,			\
118		.volt_table	= _t,				\
119		.vsel_reg	= TPS65023_REG_LDO_CTRL,	\
120		.vsel_mask	= _vm,				\
121		.enable_mask	= 1 << (_num),			\
122		.enable_reg	= TPS65023_REG_REG_CTRL,	\
123	}							\
124
125/* Supported voltage values for regulators */
126static const unsigned int VCORE_VSEL_table[] = {
127	800000, 825000, 850000, 875000,
128	900000, 925000, 950000, 975000,
129	1000000, 1025000, 1050000, 1075000,
130	1100000, 1125000, 1150000, 1175000,
131	1200000, 1225000, 1250000, 1275000,
132	1300000, 1325000, 1350000, 1375000,
133	1400000, 1425000, 1450000, 1475000,
134	1500000, 1525000, 1550000, 1600000,
135};
136
137static const unsigned int DCDC_FIXED_3300000_VSEL_table[] = {
138	3300000,
139};
140
141static const unsigned int DCDC_FIXED_1800000_VSEL_table[] = {
142	1800000,
143};
144
145/* Supported voltage values for LDO regulators for tps65020 */
146static const unsigned int TPS65020_LDO_VSEL_table[] = {
147	1000000, 1050000, 1100000, 1300000,
148	1800000, 2500000, 3000000, 3300000,
149};
150
151/* Supported voltage values for LDO regulators
152 * for tps65021 and tps65023 */
153static const unsigned int TPS65023_LDO1_VSEL_table[] = {
154	1000000, 1100000, 1300000, 1800000,
155	2200000, 2600000, 2800000, 3150000,
156};
157
158static const unsigned int TPS65023_LDO2_VSEL_table[] = {
159	1050000, 1200000, 1300000, 1800000,
160	2500000, 2800000, 3000000, 3300000,
161};
162
163/* PMIC details */
164struct tps_pmic {
165	struct regulator_dev *rdev[TPS65023_NUM_REGULATOR];
166	const struct tps_driver_data *driver_data;
167	struct regmap *regmap;
168};
169
170/* Struct passed as driver data */
171struct tps_driver_data {
172	const struct regulator_desc *desc;
173	u8 core_regulator;
174};
175
176static int tps65023_dcdc_get_voltage_sel(struct regulator_dev *dev)
177{
178	struct tps_pmic *tps = rdev_get_drvdata(dev);
179	int dcdc = rdev_get_id(dev);
180
181	if (dcdc < TPS65023_DCDC_1 || dcdc > TPS65023_DCDC_3)
182		return -EINVAL;
183
184	if (dcdc != tps->driver_data->core_regulator)
185		return 0;
186
187	return regulator_get_voltage_sel_regmap(dev);
188}
189
190static int tps65023_dcdc_set_voltage_sel(struct regulator_dev *dev,
191					 unsigned selector)
192{
193	struct tps_pmic *tps = rdev_get_drvdata(dev);
194	int dcdc = rdev_get_id(dev);
195
196	if (dcdc != tps->driver_data->core_regulator)
197		return -EINVAL;
198
199	return regulator_set_voltage_sel_regmap(dev, selector);
200}
201
202/* Operations permitted on VDCDCx */
203static const struct regulator_ops tps65023_dcdc_ops = {
204	.is_enabled = regulator_is_enabled_regmap,
205	.enable = regulator_enable_regmap,
206	.disable = regulator_disable_regmap,
207	.get_voltage_sel = tps65023_dcdc_get_voltage_sel,
208	.set_voltage_sel = tps65023_dcdc_set_voltage_sel,
209	.list_voltage = regulator_list_voltage_table,
210	.map_voltage = regulator_map_voltage_ascend,
211};
212
213/* Operations permitted on LDOx */
214static const struct regulator_ops tps65023_ldo_ops = {
215	.is_enabled = regulator_is_enabled_regmap,
216	.enable = regulator_enable_regmap,
217	.disable = regulator_disable_regmap,
218	.get_voltage_sel = regulator_get_voltage_sel_regmap,
219	.set_voltage_sel = regulator_set_voltage_sel_regmap,
220	.list_voltage = regulator_list_voltage_table,
221	.map_voltage = regulator_map_voltage_ascend,
222};
223
224static const struct regmap_config tps65023_regmap_config = {
225	.reg_bits = 8,
226	.val_bits = 8,
227};
228
229static const struct regulator_desc tps65020_regulators[] = {
230	TPS65023_REGULATOR_DCDC(1, DCDC_FIXED_3300000_VSEL_table, 0x20),
231	TPS65023_REGULATOR_DCDC(2, DCDC_FIXED_1800000_VSEL_table, 0x10),
232	TPS65023_REGULATOR_DCDC(3, VCORE_VSEL_table, 0x08),
233	TPS65023_REGULATOR_LDO(1, TPS65020_LDO_VSEL_table, 0x07),
234	TPS65023_REGULATOR_LDO(2, TPS65020_LDO_VSEL_table, 0x70),
235};
236
237static const struct regulator_desc tps65021_regulators[] = {
238	TPS65023_REGULATOR_DCDC(1, DCDC_FIXED_3300000_VSEL_table, 0x20),
239	TPS65023_REGULATOR_DCDC(2, DCDC_FIXED_1800000_VSEL_table, 0x10),
240	TPS65023_REGULATOR_DCDC(3, VCORE_VSEL_table, 0x08),
241	TPS65023_REGULATOR_LDO(1, TPS65023_LDO1_VSEL_table, 0x07),
242	TPS65023_REGULATOR_LDO(2, TPS65023_LDO2_VSEL_table, 0x70),
243};
244
245static const struct regulator_desc tps65023_regulators[] = {
246	TPS65023_REGULATOR_DCDC(1, VCORE_VSEL_table, 0x20),
247	TPS65023_REGULATOR_DCDC(2, DCDC_FIXED_3300000_VSEL_table, 0x10),
248	TPS65023_REGULATOR_DCDC(3, DCDC_FIXED_1800000_VSEL_table, 0x08),
249	TPS65023_REGULATOR_LDO(1, TPS65023_LDO1_VSEL_table, 0x07),
250	TPS65023_REGULATOR_LDO(2, TPS65023_LDO2_VSEL_table, 0x70),
251};
252
253static struct tps_driver_data tps65020_drv_data = {
254	.desc = tps65020_regulators,
255	.core_regulator = TPS65023_DCDC_3,
256};
257
258static struct tps_driver_data tps65021_drv_data = {
259	.desc = tps65021_regulators,
260	.core_regulator = TPS65023_DCDC_3,
261};
262
263static struct tps_driver_data tps65023_drv_data = {
264	.desc = tps65023_regulators,
265	.core_regulator = TPS65023_DCDC_1,
266};
267
268static int tps_65023_probe(struct i2c_client *client,
269				     const struct i2c_device_id *id)
270{
271	struct regulator_init_data *init_data = dev_get_platdata(&client->dev);
272	struct regulator_config config = { };
273	struct tps_pmic *tps;
274	int i;
275	int error;
276
277	tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL);
278	if (!tps)
279		return -ENOMEM;
280
281	tps->driver_data = (struct tps_driver_data *)id->driver_data;
282
283	tps->regmap = devm_regmap_init_i2c(client, &tps65023_regmap_config);
284	if (IS_ERR(tps->regmap)) {
285		error = PTR_ERR(tps->regmap);
286		dev_err(&client->dev, "Failed to allocate register map: %d\n",
287			error);
288		return error;
289	}
290
291	/* common for all regulators */
292	config.dev = &client->dev;
293	config.driver_data = tps;
294	config.regmap = tps->regmap;
295
296	for (i = 0; i < TPS65023_NUM_REGULATOR; i++) {
297		if (init_data)
298			config.init_data = &init_data[i];
299
300		/* Register the regulators */
301		tps->rdev[i] = devm_regulator_register(&client->dev,
302					&tps->driver_data->desc[i], &config);
303		if (IS_ERR(tps->rdev[i])) {
304			dev_err(&client->dev, "failed to register %s\n",
305				id->name);
306			return PTR_ERR(tps->rdev[i]);
307		}
308	}
309
310	i2c_set_clientdata(client, tps);
311
312	/* Enable setting output voltage by I2C */
313	regmap_update_bits(tps->regmap, TPS65023_REG_CON_CTRL2,
314					TPS65023_REG_CTRL2_CORE_ADJ,
315					TPS65023_REG_CTRL2_CORE_ADJ);
316
317	return 0;
318}
319
320static const struct of_device_id tps65023_of_match[] = {
321	{ .compatible = "ti,tps65020", .data = &tps65020_drv_data},
322	{ .compatible = "ti,tps65021", .data = &tps65021_drv_data},
323	{ .compatible = "ti,tps65023", .data = &tps65023_drv_data},
324	{},
325};
326MODULE_DEVICE_TABLE(of, tps65023_of_match);
327
328static const struct i2c_device_id tps_65023_id[] = {
329	{
330		.name = "tps65023",
331		.driver_data = (kernel_ulong_t)&tps65023_drv_data
332	}, {
333		.name = "tps65021",
334		.driver_data = (kernel_ulong_t)&tps65021_drv_data
335	}, {
336		.name = "tps65020",
337		.driver_data = (kernel_ulong_t)&tps65020_drv_data
338	},
339	{ },
340};
341MODULE_DEVICE_TABLE(i2c, tps_65023_id);
342
343static struct i2c_driver tps_65023_i2c_driver = {
344	.driver = {
345		.name = "tps65023",
346		.of_match_table = of_match_ptr(tps65023_of_match),
347	},
348	.probe = tps_65023_probe,
349	.id_table = tps_65023_id,
350};
351
352static int __init tps_65023_init(void)
353{
354	return i2c_add_driver(&tps_65023_i2c_driver);
355}
356subsys_initcall(tps_65023_init);
357
358static void __exit tps_65023_cleanup(void)
359{
360	i2c_del_driver(&tps_65023_i2c_driver);
361}
362module_exit(tps_65023_cleanup);
363
364MODULE_AUTHOR("Texas Instruments");
365MODULE_DESCRIPTION("TPS65023 voltage regulator driver");
366MODULE_LICENSE("GPL v2");
367