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/* Supported voltage values for regulators */
90static const unsigned int VCORE_VSEL_table[] = {
91	800000, 825000, 850000, 875000,
92	900000, 925000, 950000, 975000,
93	1000000, 1025000, 1050000, 1075000,
94	1100000, 1125000, 1150000, 1175000,
95	1200000, 1225000, 1250000, 1275000,
96	1300000, 1325000, 1350000, 1375000,
97	1400000, 1425000, 1450000, 1475000,
98	1500000, 1525000, 1550000, 1600000,
99};
100
101static const unsigned int DCDC_FIXED_3300000_VSEL_table[] = {
102	3300000,
103};
104
105static const unsigned int DCDC_FIXED_1800000_VSEL_table[] = {
106	1800000,
107};
108
109/* Supported voltage values for LDO regulators for tps65020 */
110static const unsigned int TPS65020_LDO_VSEL_table[] = {
111	1000000, 1050000, 1100000, 1300000,
112	1800000, 2500000, 3000000, 3300000,
113};
114
115/* Supported voltage values for LDO regulators
116 * for tps65021 and tps65023 */
117static const unsigned int TPS65023_LDO1_VSEL_table[] = {
118	1000000, 1100000, 1300000, 1800000,
119	2200000, 2600000, 2800000, 3150000,
120};
121
122static const unsigned int TPS65023_LDO2_VSEL_table[] = {
123	1050000, 1200000, 1300000, 1800000,
124	2500000, 2800000, 3000000, 3300000,
125};
126
127/* Regulator specific details */
128struct tps_info {
129	const char *name;
130	u8 table_len;
131	const unsigned int *table;
132};
133
134/* PMIC details */
135struct tps_pmic {
136	struct regulator_desc desc[TPS65023_NUM_REGULATOR];
137	struct regulator_dev *rdev[TPS65023_NUM_REGULATOR];
138	const struct tps_info *info[TPS65023_NUM_REGULATOR];
139	struct regmap *regmap;
140	u8 core_regulator;
141};
142
143/* Struct passed as driver data */
144struct tps_driver_data {
145	const struct tps_info *info;
146	u8 core_regulator;
147};
148
149static int tps65023_dcdc_get_voltage_sel(struct regulator_dev *dev)
150{
151	struct tps_pmic *tps = rdev_get_drvdata(dev);
152	int dcdc = rdev_get_id(dev);
153
154	if (dcdc < TPS65023_DCDC_1 || dcdc > TPS65023_DCDC_3)
155		return -EINVAL;
156
157	if (dcdc != tps->core_regulator)
158		return 0;
159
160	return regulator_get_voltage_sel_regmap(dev);
161}
162
163static int tps65023_dcdc_set_voltage_sel(struct regulator_dev *dev,
164					 unsigned selector)
165{
166	struct tps_pmic *tps = rdev_get_drvdata(dev);
167	int dcdc = rdev_get_id(dev);
168
169	if (dcdc != tps->core_regulator)
170		return -EINVAL;
171
172	return regulator_set_voltage_sel_regmap(dev, selector);
173}
174
175/* Operations permitted on VDCDCx */
176static struct regulator_ops tps65023_dcdc_ops = {
177	.is_enabled = regulator_is_enabled_regmap,
178	.enable = regulator_enable_regmap,
179	.disable = regulator_disable_regmap,
180	.get_voltage_sel = tps65023_dcdc_get_voltage_sel,
181	.set_voltage_sel = tps65023_dcdc_set_voltage_sel,
182	.list_voltage = regulator_list_voltage_table,
183	.map_voltage = regulator_map_voltage_ascend,
184};
185
186/* Operations permitted on LDOx */
187static struct regulator_ops tps65023_ldo_ops = {
188	.is_enabled = regulator_is_enabled_regmap,
189	.enable = regulator_enable_regmap,
190	.disable = regulator_disable_regmap,
191	.get_voltage_sel = regulator_get_voltage_sel_regmap,
192	.set_voltage_sel = regulator_set_voltage_sel_regmap,
193	.list_voltage = regulator_list_voltage_table,
194	.map_voltage = regulator_map_voltage_ascend,
195};
196
197static struct regmap_config tps65023_regmap_config = {
198	.reg_bits = 8,
199	.val_bits = 8,
200};
201
202static int tps_65023_probe(struct i2c_client *client,
203				     const struct i2c_device_id *id)
204{
205	const struct tps_driver_data *drv_data = (void *)id->driver_data;
206	const struct tps_info *info = drv_data->info;
207	struct regulator_config config = { };
208	struct regulator_init_data *init_data;
209	struct regulator_dev *rdev;
210	struct tps_pmic *tps;
211	int i;
212	int error;
213
214	/**
215	 * init_data points to array of regulator_init structures
216	 * coming from the board-evm file.
217	 */
218	init_data = dev_get_platdata(&client->dev);
219	if (!init_data)
220		return -EIO;
221
222	tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL);
223	if (!tps)
224		return -ENOMEM;
225
226	tps->regmap = devm_regmap_init_i2c(client, &tps65023_regmap_config);
227	if (IS_ERR(tps->regmap)) {
228		error = PTR_ERR(tps->regmap);
229		dev_err(&client->dev, "Failed to allocate register map: %d\n",
230			error);
231		return error;
232	}
233
234	/* common for all regulators */
235	tps->core_regulator = drv_data->core_regulator;
236
237	for (i = 0; i < TPS65023_NUM_REGULATOR; i++, info++, init_data++) {
238		/* Store regulator specific information */
239		tps->info[i] = info;
240
241		tps->desc[i].name = info->name;
242		tps->desc[i].id = i;
243		tps->desc[i].n_voltages = info->table_len;
244		tps->desc[i].volt_table = info->table;
245		tps->desc[i].ops = (i > TPS65023_DCDC_3 ?
246					&tps65023_ldo_ops : &tps65023_dcdc_ops);
247		tps->desc[i].type = REGULATOR_VOLTAGE;
248		tps->desc[i].owner = THIS_MODULE;
249
250		tps->desc[i].enable_reg = TPS65023_REG_REG_CTRL;
251		switch (i) {
252		case TPS65023_LDO_1:
253			tps->desc[i].vsel_reg = TPS65023_REG_LDO_CTRL;
254			tps->desc[i].vsel_mask = 0x07;
255			tps->desc[i].enable_mask = 1 << 1;
256			break;
257		case TPS65023_LDO_2:
258			tps->desc[i].vsel_reg = TPS65023_REG_LDO_CTRL;
259			tps->desc[i].vsel_mask = 0x70;
260			tps->desc[i].enable_mask = 1 << 2;
261			break;
262		default: /* DCDCx */
263			tps->desc[i].enable_mask =
264					1 << (TPS65023_NUM_REGULATOR - i);
265			tps->desc[i].vsel_reg = TPS65023_REG_DEF_CORE;
266			tps->desc[i].vsel_mask = info->table_len - 1;
267			tps->desc[i].apply_reg = TPS65023_REG_CON_CTRL2;
268			tps->desc[i].apply_bit = TPS65023_REG_CTRL2_GO;
269		}
270
271		config.dev = &client->dev;
272		config.init_data = init_data;
273		config.driver_data = tps;
274		config.regmap = tps->regmap;
275
276		/* Register the regulators */
277		rdev = devm_regulator_register(&client->dev, &tps->desc[i],
278					       &config);
279		if (IS_ERR(rdev)) {
280			dev_err(&client->dev, "failed to register %s\n",
281				id->name);
282			return PTR_ERR(rdev);
283		}
284
285		/* Save regulator for cleanup */
286		tps->rdev[i] = rdev;
287	}
288
289	i2c_set_clientdata(client, tps);
290
291	/* Enable setting output voltage by I2C */
292	regmap_update_bits(tps->regmap, TPS65023_REG_CON_CTRL2,
293					TPS65023_REG_CTRL2_CORE_ADJ,
294					TPS65023_REG_CTRL2_CORE_ADJ);
295
296	return 0;
297}
298
299static const struct tps_info tps65020_regs[] = {
300	{
301		.name = "VDCDC1",
302		.table_len = ARRAY_SIZE(DCDC_FIXED_3300000_VSEL_table),
303		.table = DCDC_FIXED_3300000_VSEL_table,
304	},
305	{
306		.name = "VDCDC2",
307		.table_len = ARRAY_SIZE(DCDC_FIXED_1800000_VSEL_table),
308		.table = DCDC_FIXED_1800000_VSEL_table,
309	},
310	{
311		.name = "VDCDC3",
312		.table_len = ARRAY_SIZE(VCORE_VSEL_table),
313		.table = VCORE_VSEL_table,
314	},
315	{
316		.name = "LDO1",
317		.table_len = ARRAY_SIZE(TPS65020_LDO_VSEL_table),
318		.table = TPS65020_LDO_VSEL_table,
319	},
320	{
321		.name = "LDO2",
322		.table_len = ARRAY_SIZE(TPS65020_LDO_VSEL_table),
323		.table = TPS65020_LDO_VSEL_table,
324	},
325};
326
327static const struct tps_info tps65021_regs[] = {
328	{
329		.name = "VDCDC1",
330		.table_len = ARRAY_SIZE(DCDC_FIXED_3300000_VSEL_table),
331		.table = DCDC_FIXED_3300000_VSEL_table,
332	},
333	{
334		.name = "VDCDC2",
335		.table_len = ARRAY_SIZE(DCDC_FIXED_1800000_VSEL_table),
336		.table = DCDC_FIXED_1800000_VSEL_table,
337	},
338	{
339		.name = "VDCDC3",
340		.table_len = ARRAY_SIZE(VCORE_VSEL_table),
341		.table = VCORE_VSEL_table,
342	},
343	{
344		.name = "LDO1",
345		.table_len = ARRAY_SIZE(TPS65023_LDO1_VSEL_table),
346		.table = TPS65023_LDO1_VSEL_table,
347	},
348	{
349		.name = "LDO2",
350		.table_len = ARRAY_SIZE(TPS65023_LDO2_VSEL_table),
351		.table = TPS65023_LDO2_VSEL_table,
352	},
353};
354
355static const struct tps_info tps65023_regs[] = {
356	{
357		.name = "VDCDC1",
358		.table_len = ARRAY_SIZE(VCORE_VSEL_table),
359		.table = VCORE_VSEL_table,
360	},
361	{
362		.name = "VDCDC2",
363		.table_len = ARRAY_SIZE(DCDC_FIXED_3300000_VSEL_table),
364		.table = DCDC_FIXED_3300000_VSEL_table,
365	},
366	{
367		.name = "VDCDC3",
368		.table_len = ARRAY_SIZE(DCDC_FIXED_1800000_VSEL_table),
369		.table = DCDC_FIXED_1800000_VSEL_table,
370	},
371	{
372		.name = "LDO1",
373		.table_len = ARRAY_SIZE(TPS65023_LDO1_VSEL_table),
374		.table = TPS65023_LDO1_VSEL_table,
375	},
376	{
377		.name = "LDO2",
378		.table_len = ARRAY_SIZE(TPS65023_LDO2_VSEL_table),
379		.table = TPS65023_LDO2_VSEL_table,
380	},
381};
382
383static struct tps_driver_data tps65020_drv_data = {
384	.info = tps65020_regs,
385	.core_regulator = TPS65023_DCDC_3,
386};
387
388static struct tps_driver_data tps65021_drv_data = {
389	.info = tps65021_regs,
390	.core_regulator = TPS65023_DCDC_3,
391};
392
393static struct tps_driver_data tps65023_drv_data = {
394	.info = tps65023_regs,
395	.core_regulator = TPS65023_DCDC_1,
396};
397
398static const struct i2c_device_id tps_65023_id[] = {
399	{.name = "tps65023",
400	.driver_data = (unsigned long) &tps65023_drv_data},
401	{.name = "tps65021",
402	.driver_data = (unsigned long) &tps65021_drv_data,},
403	{.name = "tps65020",
404	.driver_data = (unsigned long) &tps65020_drv_data},
405	{ },
406};
407
408MODULE_DEVICE_TABLE(i2c, tps_65023_id);
409
410static struct i2c_driver tps_65023_i2c_driver = {
411	.driver = {
412		.name = "tps65023",
413		.owner = THIS_MODULE,
414	},
415	.probe = tps_65023_probe,
416	.id_table = tps_65023_id,
417};
418
419static int __init tps_65023_init(void)
420{
421	return i2c_add_driver(&tps_65023_i2c_driver);
422}
423subsys_initcall(tps_65023_init);
424
425static void __exit tps_65023_cleanup(void)
426{
427	i2c_del_driver(&tps_65023_i2c_driver);
428}
429module_exit(tps_65023_cleanup);
430
431MODULE_AUTHOR("Texas Instruments");
432MODULE_DESCRIPTION("TPS65023 voltage regulator driver");
433MODULE_LICENSE("GPL v2");
434