Linux 4.11-rc8
[sfrench/cifs-2.6.git] / drivers / regulator / tps65023-regulator.c
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 */
126 static 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
137 static const unsigned int DCDC_FIXED_3300000_VSEL_table[] = {
138         3300000,
139 };
140
141 static const unsigned int DCDC_FIXED_1800000_VSEL_table[] = {
142         1800000,
143 };
144
145 /* Supported voltage values for LDO regulators for tps65020 */
146 static 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 */
153 static const unsigned int TPS65023_LDO1_VSEL_table[] = {
154         1000000, 1100000, 1300000, 1800000,
155         2200000, 2600000, 2800000, 3150000,
156 };
157
158 static const unsigned int TPS65023_LDO2_VSEL_table[] = {
159         1050000, 1200000, 1300000, 1800000,
160         2500000, 2800000, 3000000, 3300000,
161 };
162
163 /* PMIC details */
164 struct 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 */
171 struct tps_driver_data {
172         const struct regulator_desc *desc;
173         u8 core_regulator;
174 };
175
176 static 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
190 static 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 */
203 static 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 */
214 static 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
224 static const struct regmap_config tps65023_regmap_config = {
225         .reg_bits = 8,
226         .val_bits = 8,
227 };
228
229 static 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
237 static 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
245 static 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
253 static struct tps_driver_data tps65020_drv_data = {
254         .desc = tps65020_regulators,
255         .core_regulator = TPS65023_DCDC_3,
256 };
257
258 static struct tps_driver_data tps65021_drv_data = {
259         .desc = tps65021_regulators,
260         .core_regulator = TPS65023_DCDC_3,
261 };
262
263 static struct tps_driver_data tps65023_drv_data = {
264         .desc = tps65023_regulators,
265         .core_regulator = TPS65023_DCDC_1,
266 };
267
268 static 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
320 static 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 };
326 MODULE_DEVICE_TABLE(of, tps65023_of_match);
327
328 static 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 };
341 MODULE_DEVICE_TABLE(i2c, tps_65023_id);
342
343 static 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
352 static int __init tps_65023_init(void)
353 {
354         return i2c_add_driver(&tps_65023_i2c_driver);
355 }
356 subsys_initcall(tps_65023_init);
357
358 static void __exit tps_65023_cleanup(void)
359 {
360         i2c_del_driver(&tps_65023_i2c_driver);
361 }
362 module_exit(tps_65023_cleanup);
363
364 MODULE_AUTHOR("Texas Instruments");
365 MODULE_DESCRIPTION("TPS65023 voltage regulator driver");
366 MODULE_LICENSE("GPL v2");