regulator: wm831x: Set the new rather than old value for DVS VSEL
[linux-2.6.git] / drivers / regulator / tps6586x-regulator.c
1 /*
2  * Regulator driver for TI TPS6586x
3  *
4  * Copyright (C) 2010 Compulab Ltd.
5  * Author: Mike Rapoport <mike@compulab.co.il>
6  *
7  * Based on da903x
8  * Copyright (C) 2006-2008 Marvell International Ltd.
9  * Copyright (C) 2008 Compulab Ltd.
10  *
11  * This program is free software; you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License version 2 as
13  * published by the Free Software Foundation.
14  */
15
16 #include <linux/kernel.h>
17 #include <linux/module.h>
18 #include <linux/init.h>
19 #include <linux/err.h>
20 #include <linux/slab.h>
21 #include <linux/platform_device.h>
22 #include <linux/regulator/driver.h>
23 #include <linux/regulator/machine.h>
24 #include <linux/mfd/tps6586x.h>
25
26 /* supply control and voltage setting  */
27 #define TPS6586X_SUPPLYENA      0x10
28 #define TPS6586X_SUPPLYENB      0x11
29 #define TPS6586X_SUPPLYENC      0x12
30 #define TPS6586X_SUPPLYEND      0x13
31 #define TPS6586X_SUPPLYENE      0x14
32 #define TPS6586X_VCC1           0x20
33 #define TPS6586X_VCC2           0x21
34 #define TPS6586X_SM1V1          0x23
35 #define TPS6586X_SM1V2          0x24
36 #define TPS6586X_SM1SL          0x25
37 #define TPS6586X_SM0V1          0x26
38 #define TPS6586X_SM0V2          0x27
39 #define TPS6586X_SM0SL          0x28
40 #define TPS6586X_LDO2AV1        0x29
41 #define TPS6586X_LDO2AV2        0x2A
42 #define TPS6586X_LDO2BV1        0x2F
43 #define TPS6586X_LDO2BV2        0x30
44 #define TPS6586X_LDO4V1         0x32
45 #define TPS6586X_LDO4V2         0x33
46
47 /* converter settings  */
48 #define TPS6586X_SUPPLYV1       0x41
49 #define TPS6586X_SUPPLYV2       0x42
50 #define TPS6586X_SUPPLYV3       0x43
51 #define TPS6586X_SUPPLYV4       0x44
52 #define TPS6586X_SUPPLYV5       0x45
53 #define TPS6586X_SUPPLYV6       0x46
54 #define TPS6586X_SMODE1         0x47
55 #define TPS6586X_SMODE2         0x48
56
57 struct tps6586x_regulator {
58         struct regulator_desc desc;
59
60         int volt_reg;
61         int volt_shift;
62         int volt_nbits;
63         int enable_bit[2];
64         int enable_reg[2];
65
66         int *voltages;
67
68         /* for DVM regulators */
69         int go_reg;
70         int go_bit;
71 };
72
73 static inline struct device *to_tps6586x_dev(struct regulator_dev *rdev)
74 {
75         return rdev_get_dev(rdev)->parent->parent;
76 }
77
78 static int tps6586x_ldo_list_voltage(struct regulator_dev *rdev,
79                                      unsigned selector)
80 {
81         struct tps6586x_regulator *info = rdev_get_drvdata(rdev);
82         int rid = rdev_get_id(rdev);
83
84         /* LDO0 has minimal voltage 1.2V rather than 1.25V */
85         if ((rid == TPS6586X_ID_LDO_0) && (selector == 0))
86                 return (info->voltages[0] - 50) * 1000;
87
88         return info->voltages[selector] * 1000;
89 }
90
91
92 static int __tps6586x_ldo_set_voltage(struct device *parent,
93                                       struct tps6586x_regulator *ri,
94                                       int min_uV, int max_uV,
95                                       unsigned *selector)
96 {
97         int val, uV;
98         uint8_t mask;
99
100         for (val = 0; val < ri->desc.n_voltages; val++) {
101                 uV = ri->voltages[val] * 1000;
102
103                 /* LDO0 has minimal voltage 1.2 rather than 1.25 */
104                 if (ri->desc.id == TPS6586X_ID_LDO_0 && val == 0)
105                         uV -= 50 * 1000;
106
107                 /* use the first in-range value */
108                 if (min_uV <= uV && uV <= max_uV) {
109
110                         *selector = val;
111
112                         val <<= ri->volt_shift;
113                         mask = ((1 << ri->volt_nbits) - 1) << ri->volt_shift;
114
115                         return tps6586x_update(parent, ri->volt_reg, val, mask);
116                 }
117         }
118
119         return -EINVAL;
120 }
121
122 static int tps6586x_ldo_set_voltage(struct regulator_dev *rdev,
123                                     int min_uV, int max_uV, unsigned *selector)
124 {
125         struct tps6586x_regulator *ri = rdev_get_drvdata(rdev);
126         struct device *parent = to_tps6586x_dev(rdev);
127
128         return __tps6586x_ldo_set_voltage(parent, ri, min_uV, max_uV,
129                                           selector);
130 }
131
132 static int tps6586x_ldo_get_voltage(struct regulator_dev *rdev)
133 {
134         struct tps6586x_regulator *ri = rdev_get_drvdata(rdev);
135         struct device *parent = to_tps6586x_dev(rdev);
136         uint8_t val, mask;
137         int ret;
138
139         ret = tps6586x_read(parent, ri->volt_reg, &val);
140         if (ret)
141                 return ret;
142
143         mask = ((1 << ri->volt_nbits) - 1) << ri->volt_shift;
144         val = (val & mask) >> ri->volt_shift;
145
146         if (val >= ri->desc.n_voltages)
147                 BUG();
148
149         return ri->voltages[val] * 1000;
150 }
151
152 static int tps6586x_dvm_set_voltage(struct regulator_dev *rdev,
153                                     int min_uV, int max_uV, unsigned *selector)
154 {
155         struct tps6586x_regulator *ri = rdev_get_drvdata(rdev);
156         struct device *parent = to_tps6586x_dev(rdev);
157         int ret;
158
159         ret = __tps6586x_ldo_set_voltage(parent, ri, min_uV, max_uV,
160                                          selector);
161         if (ret)
162                 return ret;
163
164         return tps6586x_set_bits(parent, ri->go_reg, 1 << ri->go_bit);
165 }
166
167 static int tps6586x_regulator_enable(struct regulator_dev *rdev)
168 {
169         struct tps6586x_regulator *ri = rdev_get_drvdata(rdev);
170         struct device *parent = to_tps6586x_dev(rdev);
171
172         return tps6586x_set_bits(parent, ri->enable_reg[0],
173                                  1 << ri->enable_bit[0]);
174 }
175
176 static int tps6586x_regulator_disable(struct regulator_dev *rdev)
177 {
178         struct tps6586x_regulator *ri = rdev_get_drvdata(rdev);
179         struct device *parent = to_tps6586x_dev(rdev);
180
181         return tps6586x_clr_bits(parent, ri->enable_reg[0],
182                                  1 << ri->enable_bit[0]);
183 }
184
185 static int tps6586x_regulator_is_enabled(struct regulator_dev *rdev)
186 {
187         struct tps6586x_regulator *ri = rdev_get_drvdata(rdev);
188         struct device *parent = to_tps6586x_dev(rdev);
189         uint8_t reg_val;
190         int ret;
191
192         ret = tps6586x_read(parent, ri->enable_reg[0], &reg_val);
193         if (ret)
194                 return ret;
195
196         return !!(reg_val & (1 << ri->enable_bit[0]));
197 }
198
199 static struct regulator_ops tps6586x_regulator_ldo_ops = {
200         .list_voltage = tps6586x_ldo_list_voltage,
201         .get_voltage = tps6586x_ldo_get_voltage,
202         .set_voltage = tps6586x_ldo_set_voltage,
203
204         .is_enabled = tps6586x_regulator_is_enabled,
205         .enable = tps6586x_regulator_enable,
206         .disable = tps6586x_regulator_disable,
207 };
208
209 static struct regulator_ops tps6586x_regulator_dvm_ops = {
210         .list_voltage = tps6586x_ldo_list_voltage,
211         .get_voltage = tps6586x_ldo_get_voltage,
212         .set_voltage = tps6586x_dvm_set_voltage,
213
214         .is_enabled = tps6586x_regulator_is_enabled,
215         .enable = tps6586x_regulator_enable,
216         .disable = tps6586x_regulator_disable,
217 };
218
219 static int tps6586x_ldo_voltages[] = {
220         1250, 1500, 1800, 2500, 2700, 2850, 3100, 3300,
221 };
222
223 static int tps6586x_ldo4_voltages[] = {
224         1700, 1725, 1750, 1775, 1800, 1825, 1850, 1875,
225         1900, 1925, 1950, 1975, 2000, 2025, 2050, 2075,
226         2100, 2125, 2150, 2175, 2200, 2225, 2250, 2275,
227         2300, 2325, 2350, 2375, 2400, 2425, 2450, 2475,
228 };
229
230 static int tps6586x_sm2_voltages[] = {
231         3000, 3050, 3100, 3150, 3200, 3250, 3300, 3350,
232         3400, 3450, 3500, 3550, 3600, 3650, 3700, 3750,
233         3800, 3850, 3900, 3950, 4000, 4050, 4100, 4150,
234         4200, 4250, 4300, 4350, 4400, 4450, 4500, 4550,
235 };
236
237 static int tps6586x_dvm_voltages[] = {
238          725,  750,  775,  800,  825,  850,  875,  900,
239          925,  950,  975, 1000, 1025, 1050, 1075, 1100,
240         1125, 1150, 1175, 1200, 1225, 1250, 1275, 1300,
241         1325, 1350, 1375, 1400, 1425, 1450, 1475, 1500,
242 };
243
244 #define TPS6586X_REGULATOR(_id, vdata, _ops, vreg, shift, nbits,        \
245                            ereg0, ebit0, ereg1, ebit1)                  \
246         .desc   = {                                                     \
247                 .name   = "REG-" #_id,                                  \
248                 .ops    = &tps6586x_regulator_##_ops,                   \
249                 .type   = REGULATOR_VOLTAGE,                            \
250                 .id     = TPS6586X_ID_##_id,                            \
251                 .n_voltages = ARRAY_SIZE(tps6586x_##vdata##_voltages),  \
252                 .owner  = THIS_MODULE,                                  \
253         },                                                              \
254         .volt_reg       = TPS6586X_##vreg,                              \
255         .volt_shift     = (shift),                                      \
256         .volt_nbits     = (nbits),                                      \
257         .enable_reg[0]  = TPS6586X_SUPPLY##ereg0,                       \
258         .enable_bit[0]  = (ebit0),                                      \
259         .enable_reg[1]  = TPS6586X_SUPPLY##ereg1,                       \
260         .enable_bit[1]  = (ebit1),                                      \
261         .voltages       = tps6586x_##vdata##_voltages,
262
263 #define TPS6586X_REGULATOR_DVM_GOREG(goreg, gobit)                      \
264         .go_reg = TPS6586X_##goreg,                                     \
265         .go_bit = (gobit),
266
267 #define TPS6586X_LDO(_id, vdata, vreg, shift, nbits,                    \
268                      ereg0, ebit0, ereg1, ebit1)                        \
269 {                                                                       \
270         TPS6586X_REGULATOR(_id, vdata, ldo_ops, vreg, shift, nbits,     \
271                            ereg0, ebit0, ereg1, ebit1)                  \
272 }
273
274 #define TPS6586X_DVM(_id, vdata, vreg, shift, nbits,                    \
275                      ereg0, ebit0, ereg1, ebit1, goreg, gobit)          \
276 {                                                                       \
277         TPS6586X_REGULATOR(_id, vdata, dvm_ops, vreg, shift, nbits,     \
278                            ereg0, ebit0, ereg1, ebit1)                  \
279         TPS6586X_REGULATOR_DVM_GOREG(goreg, gobit)                      \
280 }
281
282 static struct tps6586x_regulator tps6586x_regulator[] = {
283         TPS6586X_LDO(LDO_0, ldo, SUPPLYV1, 5, 3, ENC, 0, END, 0),
284         TPS6586X_LDO(LDO_3, ldo, SUPPLYV4, 0, 3, ENC, 2, END, 2),
285         TPS6586X_LDO(LDO_5, ldo, SUPPLYV6, 0, 3, ENE, 6, ENE, 6),
286         TPS6586X_LDO(LDO_6, ldo, SUPPLYV3, 0, 3, ENC, 4, END, 4),
287         TPS6586X_LDO(LDO_7, ldo, SUPPLYV3, 3, 3, ENC, 5, END, 5),
288         TPS6586X_LDO(LDO_8, ldo, SUPPLYV2, 5, 3, ENC, 6, END, 6),
289         TPS6586X_LDO(LDO_9, ldo, SUPPLYV6, 3, 3, ENE, 7, ENE, 7),
290         TPS6586X_LDO(LDO_RTC, ldo, SUPPLYV4, 3, 3, V4, 7, V4, 7),
291         TPS6586X_LDO(LDO_1, dvm, SUPPLYV1, 0, 5, ENC, 1, END, 1),
292         TPS6586X_LDO(SM_2, sm2, SUPPLYV2, 0, 5, ENC, 7, END, 7),
293
294         TPS6586X_DVM(LDO_2, dvm, LDO2BV1, 0, 5, ENA, 3, ENB, 3, VCC2, 6),
295         TPS6586X_DVM(LDO_4, ldo4, LDO4V1, 0, 5, ENC, 3, END, 3, VCC1, 6),
296         TPS6586X_DVM(SM_0, dvm, SM0V1, 0, 5, ENA, 1, ENB, 1, VCC1, 2),
297         TPS6586X_DVM(SM_1, dvm, SM1V1, 0, 5, ENA, 0, ENB, 0, VCC1, 0),
298 };
299
300 /*
301  * TPS6586X has 2 enable bits that are OR'ed to determine the actual
302  * regulator state. Clearing one of this bits allows switching
303  * regulator on and of with single register write.
304  */
305 static inline int tps6586x_regulator_preinit(struct device *parent,
306                                              struct tps6586x_regulator *ri)
307 {
308         uint8_t val1, val2;
309         int ret;
310
311         if (ri->enable_reg[0] == ri->enable_reg[1] &&
312             ri->enable_bit[0] == ri->enable_bit[1])
313                         return 0;
314
315         ret = tps6586x_read(parent, ri->enable_reg[0], &val1);
316         if (ret)
317                 return ret;
318
319         ret = tps6586x_read(parent, ri->enable_reg[1], &val2);
320         if (ret)
321                 return ret;
322
323         if (!(val2 & (1 << ri->enable_bit[1])))
324                 return 0;
325
326         /*
327          * The regulator is on, but it's enabled with the bit we don't
328          * want to use, so we switch the enable bits
329          */
330         if (!(val1 & (1 << ri->enable_bit[0]))) {
331                 ret = tps6586x_set_bits(parent, ri->enable_reg[0],
332                                         1 << ri->enable_bit[0]);
333                 if (ret)
334                         return ret;
335         }
336
337         return tps6586x_clr_bits(parent, ri->enable_reg[1],
338                                  1 << ri->enable_bit[1]);
339 }
340
341 static int tps6586x_regulator_set_slew_rate(struct platform_device *pdev)
342 {
343         struct device *parent = pdev->dev.parent;
344         struct regulator_init_data *p = pdev->dev.platform_data;
345         struct tps6586x_settings *setting = p->driver_data;
346         uint8_t reg;
347
348         if (setting == NULL)
349                 return 0;
350
351         if (!(setting->slew_rate & TPS6586X_SLEW_RATE_SET))
352                 return 0;
353
354         /* only SM0 and SM1 can have the slew rate settings */
355         switch (pdev->id) {
356         case TPS6586X_ID_SM_0:
357                 reg = TPS6586X_SM0SL;
358                 break;
359         case TPS6586X_ID_SM_1:
360                 reg = TPS6586X_SM1SL;
361                 break;
362         default:
363                 dev_warn(&pdev->dev, "Only SM0/SM1 can set slew rate\n");
364                 return -EINVAL;
365         }
366
367         return tps6586x_write(parent, reg,
368                         setting->slew_rate & TPS6586X_SLEW_RATE_MASK);
369 }
370
371 static inline struct tps6586x_regulator *find_regulator_info(int id)
372 {
373         struct tps6586x_regulator *ri;
374         int i;
375
376         for (i = 0; i < ARRAY_SIZE(tps6586x_regulator); i++) {
377                 ri = &tps6586x_regulator[i];
378                 if (ri->desc.id == id)
379                         return ri;
380         }
381         return NULL;
382 }
383
384 static int __devinit tps6586x_regulator_probe(struct platform_device *pdev)
385 {
386         struct tps6586x_regulator *ri = NULL;
387         struct regulator_dev *rdev;
388         int id = pdev->id;
389         int err;
390
391         dev_dbg(&pdev->dev, "Probing regulator %d\n", id);
392
393         ri = find_regulator_info(id);
394         if (ri == NULL) {
395                 dev_err(&pdev->dev, "invalid regulator ID specified\n");
396                 return -EINVAL;
397         }
398
399         err = tps6586x_regulator_preinit(pdev->dev.parent, ri);
400         if (err)
401                 return err;
402
403         rdev = regulator_register(&ri->desc, &pdev->dev,
404                                   pdev->dev.platform_data, ri, NULL);
405         if (IS_ERR(rdev)) {
406                 dev_err(&pdev->dev, "failed to register regulator %s\n",
407                                 ri->desc.name);
408                 return PTR_ERR(rdev);
409         }
410
411         platform_set_drvdata(pdev, rdev);
412
413         return tps6586x_regulator_set_slew_rate(pdev);
414 }
415
416 static int __devexit tps6586x_regulator_remove(struct platform_device *pdev)
417 {
418         struct regulator_dev *rdev = platform_get_drvdata(pdev);
419
420         regulator_unregister(rdev);
421         return 0;
422 }
423
424 static struct platform_driver tps6586x_regulator_driver = {
425         .driver = {
426                 .name   = "tps6586x-regulator",
427                 .owner  = THIS_MODULE,
428         },
429         .probe          = tps6586x_regulator_probe,
430         .remove         = __devexit_p(tps6586x_regulator_remove),
431 };
432
433 static int __init tps6586x_regulator_init(void)
434 {
435         return platform_driver_register(&tps6586x_regulator_driver);
436 }
437 subsys_initcall(tps6586x_regulator_init);
438
439 static void __exit tps6586x_regulator_exit(void)
440 {
441         platform_driver_unregister(&tps6586x_regulator_driver);
442 }
443 module_exit(tps6586x_regulator_exit);
444
445 MODULE_LICENSE("GPL");
446 MODULE_AUTHOR("Mike Rapoport <mike@compulab.co.il>");
447 MODULE_DESCRIPTION("Regulator Driver for TI TPS6586X PMIC");
448 MODULE_ALIAS("platform:tps6586x-regulator");