Loading...
1/*
2 * tps65023-regulator.c
3 *
4 * Supports TPS65023 Regulator
5 *
6 * Copyright (C) 2009 Texas Instrument Incorporated - https://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, 0);
315
316 return 0;
317}
318
319static const struct of_device_id tps65023_of_match[] = {
320 { .compatible = "ti,tps65020", .data = &tps65020_drv_data},
321 { .compatible = "ti,tps65021", .data = &tps65021_drv_data},
322 { .compatible = "ti,tps65023", .data = &tps65023_drv_data},
323 {},
324};
325MODULE_DEVICE_TABLE(of, tps65023_of_match);
326
327static const struct i2c_device_id tps_65023_id[] = {
328 {
329 .name = "tps65023",
330 .driver_data = (kernel_ulong_t)&tps65023_drv_data
331 }, {
332 .name = "tps65021",
333 .driver_data = (kernel_ulong_t)&tps65021_drv_data
334 }, {
335 .name = "tps65020",
336 .driver_data = (kernel_ulong_t)&tps65020_drv_data
337 },
338 { },
339};
340MODULE_DEVICE_TABLE(i2c, tps_65023_id);
341
342static struct i2c_driver tps_65023_i2c_driver = {
343 .driver = {
344 .name = "tps65023",
345 .of_match_table = of_match_ptr(tps65023_of_match),
346 },
347 .probe = tps_65023_probe,
348 .id_table = tps_65023_id,
349};
350
351static int __init tps_65023_init(void)
352{
353 return i2c_add_driver(&tps_65023_i2c_driver);
354}
355subsys_initcall(tps_65023_init);
356
357static void __exit tps_65023_cleanup(void)
358{
359 i2c_del_driver(&tps_65023_i2c_driver);
360}
361module_exit(tps_65023_cleanup);
362
363MODULE_AUTHOR("Texas Instruments");
364MODULE_DESCRIPTION("TPS65023 voltage regulator driver");
365MODULE_LICENSE("GPL v2");
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/* LDO_CTRL bitfields */
73#define TPS65023_LDO_CTRL_LDOx_SHIFT(ldo_id) ((ldo_id)*4)
74#define TPS65023_LDO_CTRL_LDOx_MASK(ldo_id) (0x07 << ((ldo_id)*4))
75
76/* Number of step-down converters available */
77#define TPS65023_NUM_DCDC 3
78/* Number of LDO voltage regulators available */
79#define TPS65023_NUM_LDO 2
80/* Number of total regulators available */
81#define TPS65023_NUM_REGULATOR (TPS65023_NUM_DCDC + TPS65023_NUM_LDO)
82
83/* DCDCs */
84#define TPS65023_DCDC_1 0
85#define TPS65023_DCDC_2 1
86#define TPS65023_DCDC_3 2
87/* LDOs */
88#define TPS65023_LDO_1 3
89#define TPS65023_LDO_2 4
90
91#define TPS65023_MAX_REG_ID TPS65023_LDO_2
92
93/* Supported voltage values for regulators */
94static const u16 VCORE_VSEL_table[] = {
95 800, 825, 850, 875,
96 900, 925, 950, 975,
97 1000, 1025, 1050, 1075,
98 1100, 1125, 1150, 1175,
99 1200, 1225, 1250, 1275,
100 1300, 1325, 1350, 1375,
101 1400, 1425, 1450, 1475,
102 1500, 1525, 1550, 1600,
103};
104
105/* Supported voltage values for LDO regulators for tps65020 */
106static const u16 TPS65020_LDO1_VSEL_table[] = {
107 1000, 1050, 1100, 1300,
108 1800, 2500, 3000, 3300,
109};
110
111static const u16 TPS65020_LDO2_VSEL_table[] = {
112 1000, 1050, 1100, 1300,
113 1800, 2500, 3000, 3300,
114};
115
116/* Supported voltage values for LDO regulators
117 * for tps65021 and tps65023 */
118static const u16 TPS65023_LDO1_VSEL_table[] = {
119 1000, 1100, 1300, 1800,
120 2200, 2600, 2800, 3150,
121};
122
123static const u16 TPS65023_LDO2_VSEL_table[] = {
124 1050, 1200, 1300, 1800,
125 2500, 2800, 3000, 3300,
126};
127
128/* Regulator specific details */
129struct tps_info {
130 const char *name;
131 unsigned min_uV;
132 unsigned max_uV;
133 bool fixed;
134 u8 table_len;
135 const u16 *table;
136};
137
138/* PMIC details */
139struct tps_pmic {
140 struct regulator_desc desc[TPS65023_NUM_REGULATOR];
141 struct regulator_dev *rdev[TPS65023_NUM_REGULATOR];
142 const struct tps_info *info[TPS65023_NUM_REGULATOR];
143 struct regmap *regmap;
144 u8 core_regulator;
145};
146
147/* Struct passed as driver data */
148struct tps_driver_data {
149 const struct tps_info *info;
150 u8 core_regulator;
151};
152
153static int tps65023_dcdc_get_voltage(struct regulator_dev *dev)
154{
155 struct tps_pmic *tps = rdev_get_drvdata(dev);
156 int ret;
157 int data, dcdc = rdev_get_id(dev);
158
159 if (dcdc < TPS65023_DCDC_1 || dcdc > TPS65023_DCDC_3)
160 return -EINVAL;
161
162 if (dcdc == tps->core_regulator) {
163 ret = regmap_read(tps->regmap, TPS65023_REG_DEF_CORE, &data);
164 if (ret != 0)
165 return ret;
166 data &= (tps->info[dcdc]->table_len - 1);
167 return tps->info[dcdc]->table[data] * 1000;
168 } else
169 return tps->info[dcdc]->min_uV;
170}
171
172static int tps65023_dcdc_set_voltage_sel(struct regulator_dev *dev,
173 unsigned selector)
174{
175 struct tps_pmic *tps = rdev_get_drvdata(dev);
176 int dcdc = rdev_get_id(dev);
177 int ret;
178
179 if (dcdc != tps->core_regulator)
180 return -EINVAL;
181
182 ret = regmap_write(tps->regmap, TPS65023_REG_DEF_CORE, selector);
183 if (ret)
184 goto out;
185
186 /* Tell the chip that we have changed the value in DEFCORE
187 * and its time to update the core voltage
188 */
189 ret = regmap_update_bits(tps->regmap, TPS65023_REG_CON_CTRL2,
190 TPS65023_REG_CTRL2_GO, TPS65023_REG_CTRL2_GO);
191
192out:
193 return ret;
194}
195
196static int tps65023_ldo_get_voltage(struct regulator_dev *dev)
197{
198 struct tps_pmic *tps = rdev_get_drvdata(dev);
199 int data, ldo = rdev_get_id(dev);
200 int ret;
201
202 if (ldo < TPS65023_LDO_1 || ldo > TPS65023_LDO_2)
203 return -EINVAL;
204
205 ret = regmap_read(tps->regmap, TPS65023_REG_LDO_CTRL, &data);
206 if (ret != 0)
207 return ret;
208
209 data >>= (TPS65023_LDO_CTRL_LDOx_SHIFT(ldo - TPS65023_LDO_1));
210 data &= (tps->info[ldo]->table_len - 1);
211 return tps->info[ldo]->table[data] * 1000;
212}
213
214static int tps65023_ldo_set_voltage_sel(struct regulator_dev *dev,
215 unsigned selector)
216{
217 struct tps_pmic *tps = rdev_get_drvdata(dev);
218 int ldo_index = rdev_get_id(dev) - TPS65023_LDO_1;
219
220 return regmap_update_bits(tps->regmap, TPS65023_REG_LDO_CTRL,
221 TPS65023_LDO_CTRL_LDOx_MASK(ldo_index),
222 selector << TPS65023_LDO_CTRL_LDOx_SHIFT(ldo_index));
223}
224
225static int tps65023_dcdc_list_voltage(struct regulator_dev *dev,
226 unsigned selector)
227{
228 struct tps_pmic *tps = rdev_get_drvdata(dev);
229 int dcdc = rdev_get_id(dev);
230
231 if (dcdc < TPS65023_DCDC_1 || dcdc > TPS65023_DCDC_3)
232 return -EINVAL;
233
234 if (dcdc == tps->core_regulator) {
235 if (selector >= tps->info[dcdc]->table_len)
236 return -EINVAL;
237 else
238 return tps->info[dcdc]->table[selector] * 1000;
239 } else
240 return tps->info[dcdc]->min_uV;
241}
242
243static int tps65023_ldo_list_voltage(struct regulator_dev *dev,
244 unsigned selector)
245{
246 struct tps_pmic *tps = rdev_get_drvdata(dev);
247 int ldo = rdev_get_id(dev);
248
249 if (ldo < TPS65023_LDO_1 || ldo > TPS65023_LDO_2)
250 return -EINVAL;
251
252 if (selector >= tps->info[ldo]->table_len)
253 return -EINVAL;
254 else
255 return tps->info[ldo]->table[selector] * 1000;
256}
257
258/* Operations permitted on VDCDCx */
259static struct regulator_ops tps65023_dcdc_ops = {
260 .is_enabled = regulator_is_enabled_regmap,
261 .enable = regulator_enable_regmap,
262 .disable = regulator_disable_regmap,
263 .get_voltage = tps65023_dcdc_get_voltage,
264 .set_voltage_sel = tps65023_dcdc_set_voltage_sel,
265 .list_voltage = tps65023_dcdc_list_voltage,
266};
267
268/* Operations permitted on LDOx */
269static struct regulator_ops tps65023_ldo_ops = {
270 .is_enabled = regulator_is_enabled_regmap,
271 .enable = regulator_enable_regmap,
272 .disable = regulator_disable_regmap,
273 .get_voltage = tps65023_ldo_get_voltage,
274 .set_voltage_sel = tps65023_ldo_set_voltage_sel,
275 .list_voltage = tps65023_ldo_list_voltage,
276};
277
278static struct regmap_config tps65023_regmap_config = {
279 .reg_bits = 8,
280 .val_bits = 8,
281};
282
283static int __devinit tps_65023_probe(struct i2c_client *client,
284 const struct i2c_device_id *id)
285{
286 const struct tps_driver_data *drv_data = (void *)id->driver_data;
287 const struct tps_info *info = drv_data->info;
288 struct regulator_config config = { };
289 struct regulator_init_data *init_data;
290 struct regulator_dev *rdev;
291 struct tps_pmic *tps;
292 int i;
293 int error;
294
295 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
296 return -EIO;
297
298 /**
299 * init_data points to array of regulator_init structures
300 * coming from the board-evm file.
301 */
302 init_data = client->dev.platform_data;
303 if (!init_data)
304 return -EIO;
305
306 tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL);
307 if (!tps)
308 return -ENOMEM;
309
310 tps->regmap = devm_regmap_init_i2c(client, &tps65023_regmap_config);
311 if (IS_ERR(tps->regmap)) {
312 error = PTR_ERR(tps->regmap);
313 dev_err(&client->dev, "Failed to allocate register map: %d\n",
314 error);
315 return error;
316 }
317
318 /* common for all regulators */
319 tps->core_regulator = drv_data->core_regulator;
320
321 for (i = 0; i < TPS65023_NUM_REGULATOR; i++, info++, init_data++) {
322 /* Store regulator specific information */
323 tps->info[i] = info;
324
325 tps->desc[i].name = info->name;
326 tps->desc[i].id = i;
327 tps->desc[i].n_voltages = info->table_len;
328 tps->desc[i].ops = (i > TPS65023_DCDC_3 ?
329 &tps65023_ldo_ops : &tps65023_dcdc_ops);
330 tps->desc[i].type = REGULATOR_VOLTAGE;
331 tps->desc[i].owner = THIS_MODULE;
332
333 tps->desc[i].enable_reg = TPS65023_REG_REG_CTRL;
334 if (i == TPS65023_LDO_1)
335 tps->desc[i].enable_mask = 1 << 1;
336 else if (i == TPS65023_LDO_2)
337 tps->desc[i].enable_mask = 1 << 2;
338 else /* DCDCx */
339 tps->desc[i].enable_mask =
340 1 << (TPS65023_NUM_REGULATOR - i);
341
342 config.dev = &client->dev;
343 config.init_data = init_data;
344 config.driver_data = tps;
345 config.regmap = tps->regmap;
346
347 /* Register the regulators */
348 rdev = regulator_register(&tps->desc[i], &config);
349 if (IS_ERR(rdev)) {
350 dev_err(&client->dev, "failed to register %s\n",
351 id->name);
352 error = PTR_ERR(rdev);
353 goto fail;
354 }
355
356 /* Save regulator for cleanup */
357 tps->rdev[i] = rdev;
358 }
359
360 i2c_set_clientdata(client, tps);
361
362 /* Enable setting output voltage by I2C */
363 regmap_update_bits(tps->regmap, TPS65023_REG_CON_CTRL2,
364 TPS65023_REG_CTRL2_CORE_ADJ, TPS65023_REG_CTRL2_CORE_ADJ);
365
366 return 0;
367
368 fail:
369 while (--i >= 0)
370 regulator_unregister(tps->rdev[i]);
371 return error;
372}
373
374static int __devexit tps_65023_remove(struct i2c_client *client)
375{
376 struct tps_pmic *tps = i2c_get_clientdata(client);
377 int i;
378
379 for (i = 0; i < TPS65023_NUM_REGULATOR; i++)
380 regulator_unregister(tps->rdev[i]);
381 return 0;
382}
383
384static const struct tps_info tps65020_regs[] = {
385 {
386 .name = "VDCDC1",
387 .min_uV = 3300000,
388 .max_uV = 3300000,
389 .fixed = 1,
390 },
391 {
392 .name = "VDCDC2",
393 .min_uV = 1800000,
394 .max_uV = 1800000,
395 .fixed = 1,
396 },
397 {
398 .name = "VDCDC3",
399 .min_uV = 800000,
400 .max_uV = 1600000,
401 .table_len = ARRAY_SIZE(VCORE_VSEL_table),
402 .table = VCORE_VSEL_table,
403 },
404
405 {
406 .name = "LDO1",
407 .min_uV = 1000000,
408 .max_uV = 3150000,
409 .table_len = ARRAY_SIZE(TPS65020_LDO1_VSEL_table),
410 .table = TPS65020_LDO1_VSEL_table,
411 },
412 {
413 .name = "LDO2",
414 .min_uV = 1050000,
415 .max_uV = 3300000,
416 .table_len = ARRAY_SIZE(TPS65020_LDO2_VSEL_table),
417 .table = TPS65020_LDO2_VSEL_table,
418 },
419};
420
421static const struct tps_info tps65021_regs[] = {
422 {
423 .name = "VDCDC1",
424 .min_uV = 3300000,
425 .max_uV = 3300000,
426 .fixed = 1,
427 },
428 {
429 .name = "VDCDC2",
430 .min_uV = 1800000,
431 .max_uV = 1800000,
432 .fixed = 1,
433 },
434 {
435 .name = "VDCDC3",
436 .min_uV = 800000,
437 .max_uV = 1600000,
438 .table_len = ARRAY_SIZE(VCORE_VSEL_table),
439 .table = VCORE_VSEL_table,
440 },
441 {
442 .name = "LDO1",
443 .min_uV = 1000000,
444 .max_uV = 3150000,
445 .table_len = ARRAY_SIZE(TPS65023_LDO1_VSEL_table),
446 .table = TPS65023_LDO1_VSEL_table,
447 },
448 {
449 .name = "LDO2",
450 .min_uV = 1050000,
451 .max_uV = 3300000,
452 .table_len = ARRAY_SIZE(TPS65023_LDO2_VSEL_table),
453 .table = TPS65023_LDO2_VSEL_table,
454 },
455};
456
457static const struct tps_info tps65023_regs[] = {
458 {
459 .name = "VDCDC1",
460 .min_uV = 800000,
461 .max_uV = 1600000,
462 .table_len = ARRAY_SIZE(VCORE_VSEL_table),
463 .table = VCORE_VSEL_table,
464 },
465 {
466 .name = "VDCDC2",
467 .min_uV = 3300000,
468 .max_uV = 3300000,
469 .fixed = 1,
470 },
471 {
472 .name = "VDCDC3",
473 .min_uV = 1800000,
474 .max_uV = 1800000,
475 .fixed = 1,
476 },
477 {
478 .name = "LDO1",
479 .min_uV = 1000000,
480 .max_uV = 3150000,
481 .table_len = ARRAY_SIZE(TPS65023_LDO1_VSEL_table),
482 .table = TPS65023_LDO1_VSEL_table,
483 },
484 {
485 .name = "LDO2",
486 .min_uV = 1050000,
487 .max_uV = 3300000,
488 .table_len = ARRAY_SIZE(TPS65023_LDO2_VSEL_table),
489 .table = TPS65023_LDO2_VSEL_table,
490 },
491};
492
493static struct tps_driver_data tps65020_drv_data = {
494 .info = tps65020_regs,
495 .core_regulator = TPS65023_DCDC_3,
496};
497
498static struct tps_driver_data tps65021_drv_data = {
499 .info = tps65021_regs,
500 .core_regulator = TPS65023_DCDC_3,
501};
502
503static struct tps_driver_data tps65023_drv_data = {
504 .info = tps65023_regs,
505 .core_regulator = TPS65023_DCDC_1,
506};
507
508static const struct i2c_device_id tps_65023_id[] = {
509 {.name = "tps65023",
510 .driver_data = (unsigned long) &tps65023_drv_data},
511 {.name = "tps65021",
512 .driver_data = (unsigned long) &tps65021_drv_data,},
513 {.name = "tps65020",
514 .driver_data = (unsigned long) &tps65020_drv_data},
515 { },
516};
517
518MODULE_DEVICE_TABLE(i2c, tps_65023_id);
519
520static struct i2c_driver tps_65023_i2c_driver = {
521 .driver = {
522 .name = "tps65023",
523 .owner = THIS_MODULE,
524 },
525 .probe = tps_65023_probe,
526 .remove = __devexit_p(tps_65023_remove),
527 .id_table = tps_65023_id,
528};
529
530static int __init tps_65023_init(void)
531{
532 return i2c_add_driver(&tps_65023_i2c_driver);
533}
534subsys_initcall(tps_65023_init);
535
536static void __exit tps_65023_cleanup(void)
537{
538 i2c_del_driver(&tps_65023_i2c_driver);
539}
540module_exit(tps_65023_cleanup);
541
542MODULE_AUTHOR("Texas Instruments");
543MODULE_DESCRIPTION("TPS65023 voltage regulator driver");
544MODULE_LICENSE("GPL v2");