Merge branch 'topic/tps6586x' of git://git.kernel.org/pub/scm/linux/kernel/git/brooni...
[linux-3.10.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/of.h>
21 #include <linux/slab.h>
22 #include <linux/platform_device.h>
23 #include <linux/regulator/driver.h>
24 #include <linux/regulator/machine.h>
25 #include <linux/regulator/of_regulator.h>
26 #include <linux/mfd/tps6586x.h>
27
28 /* supply control and voltage setting  */
29 #define TPS6586X_SUPPLYENA      0x10
30 #define TPS6586X_SUPPLYENB      0x11
31 #define TPS6586X_SUPPLYENC      0x12
32 #define TPS6586X_SUPPLYEND      0x13
33 #define TPS6586X_SUPPLYENE      0x14
34 #define TPS6586X_VCC1           0x20
35 #define TPS6586X_VCC2           0x21
36 #define TPS6586X_SM1V1          0x23
37 #define TPS6586X_SM1V2          0x24
38 #define TPS6586X_SM1SL          0x25
39 #define TPS6586X_SM0V1          0x26
40 #define TPS6586X_SM0V2          0x27
41 #define TPS6586X_SM0SL          0x28
42 #define TPS6586X_LDO2AV1        0x29
43 #define TPS6586X_LDO2AV2        0x2A
44 #define TPS6586X_LDO2BV1        0x2F
45 #define TPS6586X_LDO2BV2        0x30
46 #define TPS6586X_LDO4V1         0x32
47 #define TPS6586X_LDO4V2         0x33
48
49 /* converter settings  */
50 #define TPS6586X_SUPPLYV1       0x41
51 #define TPS6586X_SUPPLYV2       0x42
52 #define TPS6586X_SUPPLYV3       0x43
53 #define TPS6586X_SUPPLYV4       0x44
54 #define TPS6586X_SUPPLYV5       0x45
55 #define TPS6586X_SUPPLYV6       0x46
56 #define TPS6586X_SMODE1         0x47
57 #define TPS6586X_SMODE2         0x48
58
59 struct tps6586x_regulator {
60         struct regulator_desc desc;
61
62         int enable_bit[2];
63         int enable_reg[2];
64
65         /* for DVM regulators */
66         int go_reg;
67         int go_bit;
68 };
69
70 static inline struct device *to_tps6586x_dev(struct regulator_dev *rdev)
71 {
72         return rdev_get_dev(rdev)->parent;
73 }
74
75 static int tps6586x_set_voltage_sel(struct regulator_dev *rdev,
76                                     unsigned selector)
77 {
78         struct tps6586x_regulator *ri = rdev_get_drvdata(rdev);
79         struct device *parent = to_tps6586x_dev(rdev);
80         int ret, val, rid = rdev_get_id(rdev);
81         uint8_t mask;
82
83         val = selector << (ffs(rdev->desc->vsel_mask) - 1);
84         mask = rdev->desc->vsel_mask;
85
86         ret = tps6586x_update(parent, rdev->desc->vsel_reg, val, mask);
87         if (ret)
88                 return ret;
89
90         /* Update go bit for DVM regulators */
91         switch (rid) {
92         case TPS6586X_ID_LDO_2:
93         case TPS6586X_ID_LDO_4:
94         case TPS6586X_ID_SM_0:
95         case TPS6586X_ID_SM_1:
96                 ret = tps6586x_set_bits(parent, ri->go_reg, 1 << ri->go_bit);
97                 break;
98         }
99         return ret;
100 }
101
102 static struct regulator_ops tps6586x_regulator_ops = {
103         .list_voltage = regulator_list_voltage_table,
104         .get_voltage_sel = regulator_get_voltage_sel_regmap,
105         .set_voltage_sel = tps6586x_set_voltage_sel,
106
107         .is_enabled = regulator_is_enabled_regmap,
108         .enable = regulator_enable_regmap,
109         .disable = regulator_disable_regmap,
110 };
111
112 static struct regulator_ops tps6586x_sys_regulator_ops = {
113 };
114
115 static const unsigned int tps6586x_ldo0_voltages[] = {
116         1200000, 1500000, 1800000, 2500000, 2700000, 2850000, 3100000, 3300000,
117 };
118
119 static const unsigned int tps6586x_ldo4_voltages[] = {
120         1700000, 1725000, 1750000, 1775000, 1800000, 1825000, 1850000, 1875000,
121         1900000, 1925000, 1950000, 1975000, 2000000, 2025000, 2050000, 2075000,
122         2100000, 2125000, 2150000, 2175000, 2200000, 2225000, 2250000, 2275000,
123         2300000, 2325000, 2350000, 2375000, 2400000, 2425000, 2450000, 2475000,
124 };
125
126 static const unsigned int tps6586x_ldo_voltages[] = {
127         1250000, 1500000, 1800000, 2500000, 2700000, 2850000, 3100000, 3300000,
128 };
129
130 static const unsigned int tps6586x_sm2_voltages[] = {
131         3000000, 3050000, 3100000, 3150000, 3200000, 3250000, 3300000, 3350000,
132         3400000, 3450000, 3500000, 3550000, 3600000, 3650000, 3700000, 3750000,
133         3800000, 3850000, 3900000, 3950000, 4000000, 4050000, 4100000, 4150000,
134         4200000, 4250000, 4300000, 4350000, 4400000, 4450000, 4500000, 4550000,
135 };
136
137 static const unsigned int tps6586x_dvm_voltages[] = {
138          725000,  750000,  775000,  800000,  825000,  850000,  875000,  900000,
139          925000,  950000,  975000, 1000000, 1025000, 1050000, 1075000, 1100000,
140         1125000, 1150000, 1175000, 1200000, 1225000, 1250000, 1275000, 1300000,
141         1325000, 1350000, 1375000, 1400000, 1425000, 1450000, 1475000, 1500000,
142 };
143
144 #define TPS6586X_REGULATOR(_id, _pin_name, vdata, vreg, shift, nbits,   \
145                            ereg0, ebit0, ereg1, ebit1)                  \
146         .desc   = {                                                     \
147                 .supply_name = _pin_name,                               \
148                 .name   = "REG-" #_id,                                  \
149                 .ops    = &tps6586x_regulator_ops,                      \
150                 .type   = REGULATOR_VOLTAGE,                            \
151                 .id     = TPS6586X_ID_##_id,                            \
152                 .n_voltages = ARRAY_SIZE(tps6586x_##vdata##_voltages),  \
153                 .volt_table = tps6586x_##vdata##_voltages,              \
154                 .owner  = THIS_MODULE,                                  \
155                 .enable_reg = TPS6586X_SUPPLY##ereg0,                   \
156                 .enable_mask = 1 << (ebit0),                            \
157                 .vsel_reg = TPS6586X_##vreg,                            \
158                 .vsel_mask = ((1 << (nbits)) - 1) << (shift),           \
159         },                                                              \
160         .enable_reg[0]  = TPS6586X_SUPPLY##ereg0,                       \
161         .enable_bit[0]  = (ebit0),                                      \
162         .enable_reg[1]  = TPS6586X_SUPPLY##ereg1,                       \
163         .enable_bit[1]  = (ebit1),
164
165 #define TPS6586X_REGULATOR_DVM_GOREG(goreg, gobit)                      \
166         .go_reg = TPS6586X_##goreg,                                     \
167         .go_bit = (gobit),
168
169 #define TPS6586X_LDO(_id, _pname, vdata, vreg, shift, nbits,            \
170                      ereg0, ebit0, ereg1, ebit1)                        \
171 {                                                                       \
172         TPS6586X_REGULATOR(_id, _pname, vdata, vreg, shift, nbits,      \
173                            ereg0, ebit0, ereg1, ebit1)                  \
174 }
175
176 #define TPS6586X_DVM(_id, _pname, vdata, vreg, shift, nbits,            \
177                      ereg0, ebit0, ereg1, ebit1, goreg, gobit)          \
178 {                                                                       \
179         TPS6586X_REGULATOR(_id, _pname, vdata, vreg, shift, nbits,      \
180                            ereg0, ebit0, ereg1, ebit1)                  \
181         TPS6586X_REGULATOR_DVM_GOREG(goreg, gobit)                      \
182 }
183
184 #define TPS6586X_SYS_REGULATOR()                                        \
185 {                                                                       \
186         .desc   = {                                                     \
187                 .supply_name = "sys",                                   \
188                 .name   = "REG-SYS",                                    \
189                 .ops    = &tps6586x_sys_regulator_ops,                  \
190                 .type   = REGULATOR_VOLTAGE,                            \
191                 .id     = TPS6586X_ID_SYS,                              \
192                 .owner  = THIS_MODULE,                                  \
193         },                                                              \
194 }
195
196 static struct tps6586x_regulator tps6586x_regulator[] = {
197         TPS6586X_SYS_REGULATOR(),
198         TPS6586X_LDO(LDO_0, "vinldo01", ldo0, SUPPLYV1, 5, 3, ENC, 0, END, 0),
199         TPS6586X_LDO(LDO_3, "vinldo23", ldo, SUPPLYV4, 0, 3, ENC, 2, END, 2),
200         TPS6586X_LDO(LDO_5, "REG-SYS", ldo, SUPPLYV6, 0, 3, ENE, 6, ENE, 6),
201         TPS6586X_LDO(LDO_6, "vinldo678", ldo, SUPPLYV3, 0, 3, ENC, 4, END, 4),
202         TPS6586X_LDO(LDO_7, "vinldo678", ldo, SUPPLYV3, 3, 3, ENC, 5, END, 5),
203         TPS6586X_LDO(LDO_8, "vinldo678", ldo, SUPPLYV2, 5, 3, ENC, 6, END, 6),
204         TPS6586X_LDO(LDO_9, "vinldo9", ldo, SUPPLYV6, 3, 3, ENE, 7, ENE, 7),
205         TPS6586X_LDO(LDO_RTC, "REG-SYS", ldo, SUPPLYV4, 3, 3, V4, 7, V4, 7),
206         TPS6586X_LDO(LDO_1, "vinldo01", dvm, SUPPLYV1, 0, 5, ENC, 1, END, 1),
207         TPS6586X_LDO(SM_2, "vin-sm2", sm2, SUPPLYV2, 0, 5, ENC, 7, END, 7),
208
209         TPS6586X_DVM(LDO_2, "vinldo23", dvm, LDO2BV1, 0, 5, ENA, 3,
210                                         ENB, 3, VCC2, 6),
211         TPS6586X_DVM(LDO_4, "vinldo4", ldo4, LDO4V1, 0, 5, ENC, 3,
212                                         END, 3, VCC1, 6),
213         TPS6586X_DVM(SM_0, "vin-sm0", dvm, SM0V1, 0, 5, ENA, 1,
214                                         ENB, 1, VCC1, 2),
215         TPS6586X_DVM(SM_1, "vin-sm1", dvm, SM1V1, 0, 5, ENA, 0,
216                                         ENB, 0, VCC1, 0),
217 };
218
219 /*
220  * TPS6586X has 2 enable bits that are OR'ed to determine the actual
221  * regulator state. Clearing one of this bits allows switching
222  * regulator on and of with single register write.
223  */
224 static inline int tps6586x_regulator_preinit(struct device *parent,
225                                              struct tps6586x_regulator *ri)
226 {
227         uint8_t val1, val2;
228         int ret;
229
230         if (ri->enable_reg[0] == ri->enable_reg[1] &&
231             ri->enable_bit[0] == ri->enable_bit[1])
232                         return 0;
233
234         ret = tps6586x_read(parent, ri->enable_reg[0], &val1);
235         if (ret)
236                 return ret;
237
238         ret = tps6586x_read(parent, ri->enable_reg[1], &val2);
239         if (ret)
240                 return ret;
241
242         if (!(val2 & (1 << ri->enable_bit[1])))
243                 return 0;
244
245         /*
246          * The regulator is on, but it's enabled with the bit we don't
247          * want to use, so we switch the enable bits
248          */
249         if (!(val1 & (1 << ri->enable_bit[0]))) {
250                 ret = tps6586x_set_bits(parent, ri->enable_reg[0],
251                                         1 << ri->enable_bit[0]);
252                 if (ret)
253                         return ret;
254         }
255
256         return tps6586x_clr_bits(parent, ri->enable_reg[1],
257                                  1 << ri->enable_bit[1]);
258 }
259
260 static int tps6586x_regulator_set_slew_rate(struct platform_device *pdev,
261                         int id, struct regulator_init_data *p)
262 {
263         struct device *parent = pdev->dev.parent;
264         struct tps6586x_settings *setting = p->driver_data;
265         uint8_t reg;
266
267         if (setting == NULL)
268                 return 0;
269
270         if (!(setting->slew_rate & TPS6586X_SLEW_RATE_SET))
271                 return 0;
272
273         /* only SM0 and SM1 can have the slew rate settings */
274         switch (id) {
275         case TPS6586X_ID_SM_0:
276                 reg = TPS6586X_SM0SL;
277                 break;
278         case TPS6586X_ID_SM_1:
279                 reg = TPS6586X_SM1SL;
280                 break;
281         default:
282                 dev_warn(&pdev->dev, "Only SM0/SM1 can set slew rate\n");
283                 return -EINVAL;
284         }
285
286         return tps6586x_write(parent, reg,
287                         setting->slew_rate & TPS6586X_SLEW_RATE_MASK);
288 }
289
290 static inline struct tps6586x_regulator *find_regulator_info(int id)
291 {
292         struct tps6586x_regulator *ri;
293         int i;
294
295         for (i = 0; i < ARRAY_SIZE(tps6586x_regulator); i++) {
296                 ri = &tps6586x_regulator[i];
297                 if (ri->desc.id == id)
298                         return ri;
299         }
300         return NULL;
301 }
302
303 #ifdef CONFIG_OF
304 static struct of_regulator_match tps6586x_matches[] = {
305         { .name = "sys",     .driver_data = (void *)TPS6586X_ID_SYS     },
306         { .name = "sm0",     .driver_data = (void *)TPS6586X_ID_SM_0    },
307         { .name = "sm1",     .driver_data = (void *)TPS6586X_ID_SM_1    },
308         { .name = "sm2",     .driver_data = (void *)TPS6586X_ID_SM_2    },
309         { .name = "ldo0",    .driver_data = (void *)TPS6586X_ID_LDO_0   },
310         { .name = "ldo1",    .driver_data = (void *)TPS6586X_ID_LDO_1   },
311         { .name = "ldo2",    .driver_data = (void *)TPS6586X_ID_LDO_2   },
312         { .name = "ldo3",    .driver_data = (void *)TPS6586X_ID_LDO_3   },
313         { .name = "ldo4",    .driver_data = (void *)TPS6586X_ID_LDO_4   },
314         { .name = "ldo5",    .driver_data = (void *)TPS6586X_ID_LDO_5   },
315         { .name = "ldo6",    .driver_data = (void *)TPS6586X_ID_LDO_6   },
316         { .name = "ldo7",    .driver_data = (void *)TPS6586X_ID_LDO_7   },
317         { .name = "ldo8",    .driver_data = (void *)TPS6586X_ID_LDO_8   },
318         { .name = "ldo9",    .driver_data = (void *)TPS6586X_ID_LDO_9   },
319         { .name = "ldo_rtc", .driver_data = (void *)TPS6586X_ID_LDO_RTC },
320 };
321
322 static struct tps6586x_platform_data *tps6586x_parse_regulator_dt(
323                 struct platform_device *pdev,
324                 struct of_regulator_match **tps6586x_reg_matches)
325 {
326         const unsigned int num = ARRAY_SIZE(tps6586x_matches);
327         struct device_node *np = pdev->dev.parent->of_node;
328         struct device_node *regs;
329         const char *sys_rail = NULL;
330         unsigned int i;
331         struct tps6586x_platform_data *pdata;
332         int err;
333
334         regs = of_find_node_by_name(np, "regulators");
335         if (!regs) {
336                 dev_err(&pdev->dev, "regulator node not found\n");
337                 return NULL;
338         }
339
340         err = of_regulator_match(&pdev->dev, regs, tps6586x_matches, num);
341         if (err < 0) {
342                 dev_err(&pdev->dev, "Regulator match failed, e %d\n", err);
343                 of_node_put(regs);
344                 return NULL;
345         }
346
347         of_node_put(regs);
348
349         pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
350         if (!pdata) {
351                 dev_err(&pdev->dev, "Memory alloction failed\n");
352                 return NULL;
353         }
354
355         for (i = 0; i < num; i++) {
356                 int id;
357                 if (!tps6586x_matches[i].init_data)
358                         continue;
359
360                 pdata->reg_init_data[i] = tps6586x_matches[i].init_data;
361                 id = (int)tps6586x_matches[i].driver_data;
362                 if (id == TPS6586X_ID_SYS)
363                         sys_rail = pdata->reg_init_data[i]->constraints.name;
364
365                 if ((id == TPS6586X_ID_LDO_5) || (id == TPS6586X_ID_LDO_RTC))
366                         pdata->reg_init_data[i]->supply_regulator = sys_rail;
367         }
368         *tps6586x_reg_matches = tps6586x_matches;
369         return pdata;
370 }
371 #else
372 static struct tps6586x_platform_data *tps6586x_parse_regulator_dt(
373                 struct platform_device *pdev,
374                 struct of_regulator_match **tps6586x_reg_matches)
375 {
376         *tps6586x_reg_matches = NULL;
377         return NULL;
378 }
379 #endif
380
381 static int tps6586x_regulator_probe(struct platform_device *pdev)
382 {
383         struct tps6586x_regulator *ri = NULL;
384         struct regulator_config config = { };
385         struct regulator_dev **rdev;
386         struct regulator_init_data *reg_data;
387         struct tps6586x_platform_data *pdata;
388         struct of_regulator_match *tps6586x_reg_matches = NULL;
389         int id;
390         int err;
391
392         dev_dbg(&pdev->dev, "Probing regulator %d\n", id);
393
394         pdata = dev_get_platdata(pdev->dev.parent);
395         if ((!pdata) && (pdev->dev.parent->of_node))
396                 pdata = tps6586x_parse_regulator_dt(pdev,
397                                         &tps6586x_reg_matches);
398
399         if (!pdata) {
400                 dev_err(&pdev->dev, "Platform data not available, exiting\n");
401                 return -ENODEV;
402         }
403
404         rdev = devm_kzalloc(&pdev->dev, TPS6586X_ID_MAX_REGULATOR *
405                                 sizeof(*rdev), GFP_KERNEL);
406         if (!rdev) {
407                 dev_err(&pdev->dev, "Mmemory alloc failed\n");
408                 return -ENOMEM;
409         }
410
411         for (id = 0; id < TPS6586X_ID_MAX_REGULATOR; ++id) {
412                 reg_data = pdata->reg_init_data[id];
413
414                 ri = find_regulator_info(id);
415                 if (!ri) {
416                         dev_err(&pdev->dev, "invalid regulator ID specified\n");
417                         err = -EINVAL;
418                         goto fail;
419                 }
420
421                 err = tps6586x_regulator_preinit(pdev->dev.parent, ri);
422                 if (err) {
423                         dev_err(&pdev->dev,
424                                 "regulator %d preinit failed, e %d\n", id, err);
425                         goto fail;
426                 }
427
428                 config.dev = pdev->dev.parent;
429                 config.init_data = reg_data;
430                 config.driver_data = ri;
431
432                 if (tps6586x_reg_matches)
433                         config.of_node = tps6586x_reg_matches[id].of_node;
434
435                 rdev[id] = regulator_register(&ri->desc, &config);
436                 if (IS_ERR(rdev[id])) {
437                         dev_err(&pdev->dev, "failed to register regulator %s\n",
438                                         ri->desc.name);
439                         err = PTR_ERR(rdev[id]);
440                         goto fail;
441                 }
442
443                 if (reg_data) {
444                         err = tps6586x_regulator_set_slew_rate(pdev, id,
445                                         reg_data);
446                         if (err < 0) {
447                                 dev_err(&pdev->dev,
448                                         "Slew rate config failed, e %d\n", err);
449                                 regulator_unregister(rdev[id]);
450                                 goto fail;
451                         }
452                 }
453         }
454
455         platform_set_drvdata(pdev, rdev);
456         return 0;
457
458 fail:
459         while (--id >= 0)
460                 regulator_unregister(rdev[id]);
461         return err;
462 }
463
464 static int __devexit tps6586x_regulator_remove(struct platform_device *pdev)
465 {
466         struct regulator_dev **rdev = platform_get_drvdata(pdev);
467         int id = TPS6586X_ID_MAX_REGULATOR;
468
469         while (--id >= 0)
470                 regulator_unregister(rdev[id]);
471
472         return 0;
473 }
474
475 static struct platform_driver tps6586x_regulator_driver = {
476         .driver = {
477                 .name   = "tps6586x-pmic",
478                 .owner  = THIS_MODULE,
479         },
480         .probe          = tps6586x_regulator_probe,
481         .remove         = tps6586x_regulator_remove,
482 };
483
484 static int __init tps6586x_regulator_init(void)
485 {
486         return platform_driver_register(&tps6586x_regulator_driver);
487 }
488 subsys_initcall(tps6586x_regulator_init);
489
490 static void __exit tps6586x_regulator_exit(void)
491 {
492         platform_driver_unregister(&tps6586x_regulator_driver);
493 }
494 module_exit(tps6586x_regulator_exit);
495
496 MODULE_LICENSE("GPL");
497 MODULE_AUTHOR("Mike Rapoport <mike@compulab.co.il>");
498 MODULE_DESCRIPTION("Regulator Driver for TI TPS6586X PMIC");
499 MODULE_ALIAS("platform:tps6586x-regulator");