Merge branch 'modsplit-Oct31_2011' of git://git.kernel.org/pub/scm/linux/kernel/git...
[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
83         return info->voltages[selector] * 1000;
84 }
85
86
87 static int __tps6586x_ldo_set_voltage(struct device *parent,
88                                       struct tps6586x_regulator *ri,
89                                       int min_uV, int max_uV,
90                                       unsigned *selector)
91 {
92         int val, uV;
93         uint8_t mask;
94
95         for (val = 0; val < ri->desc.n_voltages; val++) {
96                 uV = ri->voltages[val] * 1000;
97
98                 /* LDO0 has minimal voltage 1.2 rather than 1.25 */
99                 if (ri->desc.id == TPS6586X_ID_LDO_0 && val == 0)
100                         uV -= 50 * 1000;
101
102                 /* use the first in-range value */
103                 if (min_uV <= uV && uV <= max_uV) {
104
105                         *selector = val;
106
107                         val <<= ri->volt_shift;
108                         mask = ((1 << ri->volt_nbits) - 1) << ri->volt_shift;
109
110                         return tps6586x_update(parent, ri->volt_reg, val, mask);
111                 }
112         }
113
114         return -EINVAL;
115 }
116
117 static int tps6586x_ldo_set_voltage(struct regulator_dev *rdev,
118                                     int min_uV, int max_uV, unsigned *selector)
119 {
120         struct tps6586x_regulator *ri = rdev_get_drvdata(rdev);
121         struct device *parent = to_tps6586x_dev(rdev);
122
123         return __tps6586x_ldo_set_voltage(parent, ri, min_uV, max_uV,
124                                           selector);
125 }
126
127 static int tps6586x_ldo_get_voltage(struct regulator_dev *rdev)
128 {
129         struct tps6586x_regulator *ri = rdev_get_drvdata(rdev);
130         struct device *parent = to_tps6586x_dev(rdev);
131         uint8_t val, mask;
132         int ret;
133
134         ret = tps6586x_read(parent, ri->volt_reg, &val);
135         if (ret)
136                 return ret;
137
138         mask = ((1 << ri->volt_nbits) - 1) << ri->volt_shift;
139         val = (val & mask) >> ri->volt_shift;
140
141         if (val >= ri->desc.n_voltages)
142                 BUG();
143
144         return ri->voltages[val] * 1000;
145 }
146
147 static int tps6586x_dvm_set_voltage(struct regulator_dev *rdev,
148                                     int min_uV, int max_uV, unsigned *selector)
149 {
150         struct tps6586x_regulator *ri = rdev_get_drvdata(rdev);
151         struct device *parent = to_tps6586x_dev(rdev);
152         int ret;
153
154         ret = __tps6586x_ldo_set_voltage(parent, ri, min_uV, max_uV,
155                                          selector);
156         if (ret)
157                 return ret;
158
159         return tps6586x_set_bits(parent, ri->go_reg, 1 << ri->go_bit);
160 }
161
162 static int tps6586x_regulator_enable(struct regulator_dev *rdev)
163 {
164         struct tps6586x_regulator *ri = rdev_get_drvdata(rdev);
165         struct device *parent = to_tps6586x_dev(rdev);
166
167         return tps6586x_set_bits(parent, ri->enable_reg[0],
168                                  1 << ri->enable_bit[0]);
169 }
170
171 static int tps6586x_regulator_disable(struct regulator_dev *rdev)
172 {
173         struct tps6586x_regulator *ri = rdev_get_drvdata(rdev);
174         struct device *parent = to_tps6586x_dev(rdev);
175
176         return tps6586x_clr_bits(parent, ri->enable_reg[0],
177                                  1 << ri->enable_bit[0]);
178 }
179
180 static int tps6586x_regulator_is_enabled(struct regulator_dev *rdev)
181 {
182         struct tps6586x_regulator *ri = rdev_get_drvdata(rdev);
183         struct device *parent = to_tps6586x_dev(rdev);
184         uint8_t reg_val;
185         int ret;
186
187         ret = tps6586x_read(parent, ri->enable_reg[0], &reg_val);
188         if (ret)
189                 return ret;
190
191         return !!(reg_val & (1 << ri->enable_bit[0]));
192 }
193
194 static struct regulator_ops tps6586x_regulator_ldo_ops = {
195         .list_voltage = tps6586x_ldo_list_voltage,
196         .get_voltage = tps6586x_ldo_get_voltage,
197         .set_voltage = tps6586x_ldo_set_voltage,
198
199         .is_enabled = tps6586x_regulator_is_enabled,
200         .enable = tps6586x_regulator_enable,
201         .disable = tps6586x_regulator_disable,
202 };
203
204 static struct regulator_ops tps6586x_regulator_dvm_ops = {
205         .list_voltage = tps6586x_ldo_list_voltage,
206         .get_voltage = tps6586x_ldo_get_voltage,
207         .set_voltage = tps6586x_dvm_set_voltage,
208
209         .is_enabled = tps6586x_regulator_is_enabled,
210         .enable = tps6586x_regulator_enable,
211         .disable = tps6586x_regulator_disable,
212 };
213
214 static int tps6586x_ldo_voltages[] = {
215         1250, 1500, 1800, 2500, 2700, 2850, 3100, 3300,
216 };
217
218 static int tps6586x_ldo4_voltages[] = {
219         1700, 1725, 1750, 1775, 1800, 1825, 1850, 1875,
220         1900, 1925, 1950, 1975, 2000, 2025, 2050, 2075,
221         2100, 2125, 2150, 2175, 2200, 2225, 2250, 2275,
222         2300, 2325, 2350, 2375, 2400, 2425, 2450, 2475,
223 };
224
225 static int tps6586x_sm2_voltages[] = {
226         3000, 3050, 3100, 3150, 3200, 3250, 3300, 3350,
227         3400, 3450, 3500, 3550, 3600, 3650, 3700, 3750,
228         3800, 3850, 3900, 3950, 4000, 4050, 4100, 4150,
229         4200, 4250, 4300, 4350, 4400, 4450, 4500, 4550,
230 };
231
232 static int tps6586x_dvm_voltages[] = {
233          725,  750,  775,  800,  825,  850,  875,  900,
234          925,  950,  975, 1000, 1025, 1050, 1075, 1100,
235         1125, 1150, 1175, 1200, 1225, 1250, 1275, 1300,
236         1325, 1350, 1375, 1400, 1425, 1450, 1475, 1500,
237 };
238
239 #define TPS6586X_REGULATOR(_id, vdata, _ops, vreg, shift, nbits,        \
240                            ereg0, ebit0, ereg1, ebit1)                  \
241         .desc   = {                                                     \
242                 .name   = "REG-" #_id,                                  \
243                 .ops    = &tps6586x_regulator_##_ops,                   \
244                 .type   = REGULATOR_VOLTAGE,                            \
245                 .id     = TPS6586X_ID_##_id,                            \
246                 .n_voltages = ARRAY_SIZE(tps6586x_##vdata##_voltages),  \
247                 .owner  = THIS_MODULE,                                  \
248         },                                                              \
249         .volt_reg       = TPS6586X_##vreg,                              \
250         .volt_shift     = (shift),                                      \
251         .volt_nbits     = (nbits),                                      \
252         .enable_reg[0]  = TPS6586X_SUPPLY##ereg0,                       \
253         .enable_bit[0]  = (ebit0),                                      \
254         .enable_reg[1]  = TPS6586X_SUPPLY##ereg1,                       \
255         .enable_bit[1]  = (ebit1),                                      \
256         .voltages       = tps6586x_##vdata##_voltages,
257
258 #define TPS6586X_REGULATOR_DVM_GOREG(goreg, gobit)                      \
259         .go_reg = TPS6586X_##goreg,                                     \
260         .go_bit = (gobit),
261
262 #define TPS6586X_LDO(_id, vdata, vreg, shift, nbits,                    \
263                      ereg0, ebit0, ereg1, ebit1)                        \
264 {                                                                       \
265         TPS6586X_REGULATOR(_id, vdata, ldo_ops, vreg, shift, nbits,     \
266                            ereg0, ebit0, ereg1, ebit1)                  \
267 }
268
269 #define TPS6586X_DVM(_id, vdata, vreg, shift, nbits,                    \
270                      ereg0, ebit0, ereg1, ebit1, goreg, gobit)          \
271 {                                                                       \
272         TPS6586X_REGULATOR(_id, vdata, dvm_ops, vreg, shift, nbits,     \
273                            ereg0, ebit0, ereg1, ebit1)                  \
274         TPS6586X_REGULATOR_DVM_GOREG(goreg, gobit)                      \
275 }
276
277 static struct tps6586x_regulator tps6586x_regulator[] = {
278         TPS6586X_LDO(LDO_0, ldo, SUPPLYV1, 5, 3, ENC, 0, END, 0),
279         TPS6586X_LDO(LDO_3, ldo, SUPPLYV4, 0, 3, ENC, 2, END, 2),
280         TPS6586X_LDO(LDO_5, ldo, SUPPLYV6, 0, 3, ENE, 6, ENE, 6),
281         TPS6586X_LDO(LDO_6, ldo, SUPPLYV3, 0, 3, ENC, 4, END, 4),
282         TPS6586X_LDO(LDO_7, ldo, SUPPLYV3, 3, 3, ENC, 5, END, 5),
283         TPS6586X_LDO(LDO_8, ldo, SUPPLYV2, 5, 3, ENC, 6, END, 6),
284         TPS6586X_LDO(LDO_9, ldo, SUPPLYV6, 3, 3, ENE, 7, ENE, 7),
285         TPS6586X_LDO(LDO_RTC, ldo, SUPPLYV4, 3, 3, V4, 7, V4, 7),
286         TPS6586X_LDO(LDO_1, dvm, SUPPLYV1, 0, 5, ENC, 1, END, 1),
287         TPS6586X_LDO(SM_2, sm2, SUPPLYV2, 0, 5, ENC, 7, END, 7),
288
289         TPS6586X_DVM(LDO_2, dvm, LDO2BV1, 0, 5, ENA, 3, ENB, 3, VCC2, 6),
290         TPS6586X_DVM(LDO_4, ldo4, LDO4V1, 0, 5, ENC, 3, END, 3, VCC1, 6),
291         TPS6586X_DVM(SM_0, dvm, SM0V1, 0, 5, ENA, 1, ENB, 1, VCC1, 2),
292         TPS6586X_DVM(SM_1, dvm, SM1V1, 0, 5, ENA, 0, ENB, 0, VCC1, 0),
293 };
294
295 /*
296  * TPS6586X has 2 enable bits that are OR'ed to determine the actual
297  * regulator state. Clearing one of this bits allows switching
298  * regulator on and of with single register write.
299  */
300 static inline int tps6586x_regulator_preinit(struct device *parent,
301                                              struct tps6586x_regulator *ri)
302 {
303         uint8_t val1, val2;
304         int ret;
305
306         if (ri->enable_reg[0] == ri->enable_reg[1] &&
307             ri->enable_bit[0] == ri->enable_bit[1])
308                         return 0;
309
310         ret = tps6586x_read(parent, ri->enable_reg[0], &val1);
311         if (ret)
312                 return ret;
313
314         ret = tps6586x_read(parent, ri->enable_reg[1], &val2);
315         if (ret)
316                 return ret;
317
318         if (!(val2 & (1 << ri->enable_bit[1])))
319                 return 0;
320
321         /*
322          * The regulator is on, but it's enabled with the bit we don't
323          * want to use, so we switch the enable bits
324          */
325         if (!(val1 & (1 << ri->enable_bit[0]))) {
326                 ret = tps6586x_set_bits(parent, ri->enable_reg[0],
327                                         1 << ri->enable_bit[0]);
328                 if (ret)
329                         return ret;
330         }
331
332         return tps6586x_clr_bits(parent, ri->enable_reg[1],
333                                  1 << ri->enable_bit[1]);
334 }
335
336 static int tps6586x_regulator_set_slew_rate(struct platform_device *pdev)
337 {
338         struct device *parent = pdev->dev.parent;
339         struct regulator_init_data *p = pdev->dev.platform_data;
340         struct tps6586x_settings *setting = p->driver_data;
341         uint8_t reg;
342
343         if (setting == NULL)
344                 return 0;
345
346         if (!(setting->slew_rate & TPS6586X_SLEW_RATE_SET))
347                 return 0;
348
349         /* only SM0 and SM1 can have the slew rate settings */
350         switch (pdev->id) {
351         case TPS6586X_ID_SM_0:
352                 reg = TPS6586X_SM0SL;
353                 break;
354         case TPS6586X_ID_SM_1:
355                 reg = TPS6586X_SM1SL;
356                 break;
357         default:
358                 dev_warn(&pdev->dev, "Only SM0/SM1 can set slew rate\n");
359                 return -EINVAL;
360         }
361
362         return tps6586x_write(parent, reg,
363                         setting->slew_rate & TPS6586X_SLEW_RATE_MASK);
364 }
365
366 static inline struct tps6586x_regulator *find_regulator_info(int id)
367 {
368         struct tps6586x_regulator *ri;
369         int i;
370
371         for (i = 0; i < ARRAY_SIZE(tps6586x_regulator); i++) {
372                 ri = &tps6586x_regulator[i];
373                 if (ri->desc.id == id)
374                         return ri;
375         }
376         return NULL;
377 }
378
379 static int __devinit tps6586x_regulator_probe(struct platform_device *pdev)
380 {
381         struct tps6586x_regulator *ri = NULL;
382         struct regulator_dev *rdev;
383         int id = pdev->id;
384         int err;
385
386         dev_dbg(&pdev->dev, "Probing reulator %d\n", id);
387
388         ri = find_regulator_info(id);
389         if (ri == NULL) {
390                 dev_err(&pdev->dev, "invalid regulator ID specified\n");
391                 return -EINVAL;
392         }
393
394         err = tps6586x_regulator_preinit(pdev->dev.parent, ri);
395         if (err)
396                 return err;
397
398         rdev = regulator_register(&ri->desc, &pdev->dev,
399                                   pdev->dev.platform_data, ri);
400         if (IS_ERR(rdev)) {
401                 dev_err(&pdev->dev, "failed to register regulator %s\n",
402                                 ri->desc.name);
403                 return PTR_ERR(rdev);
404         }
405
406         platform_set_drvdata(pdev, rdev);
407
408         return tps6586x_regulator_set_slew_rate(pdev);
409 }
410
411 static int __devexit tps6586x_regulator_remove(struct platform_device *pdev)
412 {
413         struct regulator_dev *rdev = platform_get_drvdata(pdev);
414
415         regulator_unregister(rdev);
416         return 0;
417 }
418
419 static struct platform_driver tps6586x_regulator_driver = {
420         .driver = {
421                 .name   = "tps6586x-regulator",
422                 .owner  = THIS_MODULE,
423         },
424         .probe          = tps6586x_regulator_probe,
425         .remove         = __devexit_p(tps6586x_regulator_remove),
426 };
427
428 static int __init tps6586x_regulator_init(void)
429 {
430         return platform_driver_register(&tps6586x_regulator_driver);
431 }
432 subsys_initcall(tps6586x_regulator_init);
433
434 static void __exit tps6586x_regulator_exit(void)
435 {
436         platform_driver_unregister(&tps6586x_regulator_driver);
437 }
438 module_exit(tps6586x_regulator_exit);
439
440 MODULE_LICENSE("GPL");
441 MODULE_AUTHOR("Mike Rapoport <mike@compulab.co.il>");
442 MODULE_DESCRIPTION("Regulator Driver for TI TPS6586X PMIC");
443 MODULE_ALIAS("platform:tps6586x-regulator");