regulator: tps80031: adjust tolerance if req minuV > dev minuV
[linux-2.6.git] / drivers / regulator / ab3100.c
1 /*
2  * drivers/regulator/ab3100.c
3  *
4  * Copyright (C) 2008-2009 ST-Ericsson AB
5  * License terms: GNU General Public License (GPL) version 2
6  * Low-level control of the AB3100 IC Low Dropout (LDO)
7  * regulators, external regulator and buck converter
8  * Author: Mattias Wallin <mattias.wallin@stericsson.com>
9  * Author: Linus Walleij <linus.walleij@stericsson.com>
10  */
11
12 #include <linux/module.h>
13 #include <linux/kernel.h>
14 #include <linux/init.h>
15 #include <linux/err.h>
16 #include <linux/delay.h>
17 #include <linux/platform_device.h>
18 #include <linux/regulator/driver.h>
19 #include <linux/mfd/abx500.h>
20
21 /* LDO registers and some handy masking definitions for AB3100 */
22 #define AB3100_LDO_A            0x40
23 #define AB3100_LDO_C            0x41
24 #define AB3100_LDO_D            0x42
25 #define AB3100_LDO_E            0x43
26 #define AB3100_LDO_E_SLEEP      0x44
27 #define AB3100_LDO_F            0x45
28 #define AB3100_LDO_G            0x46
29 #define AB3100_LDO_H            0x47
30 #define AB3100_LDO_H_SLEEP_MODE 0
31 #define AB3100_LDO_H_SLEEP_EN   2
32 #define AB3100_LDO_ON           4
33 #define AB3100_LDO_H_VSEL_AC    5
34 #define AB3100_LDO_K            0x48
35 #define AB3100_LDO_EXT          0x49
36 #define AB3100_BUCK             0x4A
37 #define AB3100_BUCK_SLEEP       0x4B
38 #define AB3100_REG_ON_MASK      0x10
39
40 /**
41  * struct ab3100_regulator
42  * A struct passed around the individual regulator functions
43  * @platform_device: platform device holding this regulator
44  * @dev: handle to the device
45  * @plfdata: AB3100 platform data passed in at probe time
46  * @regreg: regulator register number in the AB3100
47  * @fixed_voltage: a fixed voltage for this regulator, if this
48  *          0 the voltages array is used instead.
49  * @typ_voltages: an array of available typical voltages for
50  *          this regulator
51  * @voltages_len: length of the array of available voltages
52  */
53 struct ab3100_regulator {
54         struct regulator_dev *rdev;
55         struct device *dev;
56         struct ab3100_platform_data *plfdata;
57         u8 regreg;
58         int fixed_voltage;
59         int const *typ_voltages;
60         u8 voltages_len;
61 };
62
63 /* The order in which registers are initialized */
64 static const u8 ab3100_reg_init_order[AB3100_NUM_REGULATORS+2] = {
65         AB3100_LDO_A,
66         AB3100_LDO_C,
67         AB3100_LDO_E,
68         AB3100_LDO_E_SLEEP,
69         AB3100_LDO_F,
70         AB3100_LDO_G,
71         AB3100_LDO_H,
72         AB3100_LDO_K,
73         AB3100_LDO_EXT,
74         AB3100_BUCK,
75         AB3100_BUCK_SLEEP,
76         AB3100_LDO_D,
77 };
78
79 /* Preset (hardware defined) voltages for these regulators */
80 #define LDO_A_VOLTAGE 2750000
81 #define LDO_C_VOLTAGE 2650000
82 #define LDO_D_VOLTAGE 2650000
83
84 static const int ldo_e_buck_typ_voltages[] = {
85         1800000,
86         1400000,
87         1300000,
88         1200000,
89         1100000,
90         1050000,
91         900000,
92 };
93
94 static const int ldo_f_typ_voltages[] = {
95         1800000,
96         1400000,
97         1300000,
98         1200000,
99         1100000,
100         1050000,
101         2500000,
102         2650000,
103 };
104
105 static const int ldo_g_typ_voltages[] = {
106         2850000,
107         2750000,
108         1800000,
109         1500000,
110 };
111
112 static const int ldo_h_typ_voltages[] = {
113         2750000,
114         1800000,
115         1500000,
116         1200000,
117 };
118
119 static const int ldo_k_typ_voltages[] = {
120         2750000,
121         1800000,
122 };
123
124
125 /* The regulator devices */
126 static struct ab3100_regulator
127 ab3100_regulators[AB3100_NUM_REGULATORS] = {
128         {
129                 .regreg = AB3100_LDO_A,
130                 .fixed_voltage = LDO_A_VOLTAGE,
131         },
132         {
133                 .regreg = AB3100_LDO_C,
134                 .fixed_voltage = LDO_C_VOLTAGE,
135         },
136         {
137                 .regreg = AB3100_LDO_D,
138                 .fixed_voltage = LDO_D_VOLTAGE,
139         },
140         {
141                 .regreg = AB3100_LDO_E,
142                 .typ_voltages = ldo_e_buck_typ_voltages,
143                 .voltages_len = ARRAY_SIZE(ldo_e_buck_typ_voltages),
144         },
145         {
146                 .regreg = AB3100_LDO_F,
147                 .typ_voltages = ldo_f_typ_voltages,
148                 .voltages_len = ARRAY_SIZE(ldo_f_typ_voltages),
149         },
150         {
151                 .regreg = AB3100_LDO_G,
152                 .typ_voltages = ldo_g_typ_voltages,
153                 .voltages_len = ARRAY_SIZE(ldo_g_typ_voltages),
154         },
155         {
156                 .regreg = AB3100_LDO_H,
157                 .typ_voltages = ldo_h_typ_voltages,
158                 .voltages_len = ARRAY_SIZE(ldo_h_typ_voltages),
159         },
160         {
161                 .regreg = AB3100_LDO_K,
162                 .typ_voltages = ldo_k_typ_voltages,
163                 .voltages_len = ARRAY_SIZE(ldo_k_typ_voltages),
164         },
165         {
166                 .regreg = AB3100_LDO_EXT,
167                 /* No voltages for the external regulator */
168         },
169         {
170                 .regreg = AB3100_BUCK,
171                 .typ_voltages = ldo_e_buck_typ_voltages,
172                 .voltages_len = ARRAY_SIZE(ldo_e_buck_typ_voltages),
173         },
174 };
175
176 /*
177  * General functions for enable, disable and is_enabled used for
178  * LDO: A,C,E,F,G,H,K,EXT and BUCK
179  */
180 static int ab3100_enable_regulator(struct regulator_dev *reg)
181 {
182         struct ab3100_regulator *abreg = reg->reg_data;
183         int err;
184         u8 regval;
185
186         err = abx500_get_register_interruptible(abreg->dev, 0, abreg->regreg,
187                                                 &regval);
188         if (err) {
189                 dev_warn(&reg->dev, "failed to get regid %d value\n",
190                          abreg->regreg);
191                 return err;
192         }
193
194         /* The regulator is already on, no reason to go further */
195         if (regval & AB3100_REG_ON_MASK)
196                 return 0;
197
198         regval |= AB3100_REG_ON_MASK;
199
200         err = abx500_set_register_interruptible(abreg->dev, 0, abreg->regreg,
201                                                 regval);
202         if (err) {
203                 dev_warn(&reg->dev, "failed to set regid %d value\n",
204                          abreg->regreg);
205                 return err;
206         }
207
208         return 0;
209 }
210
211 static int ab3100_disable_regulator(struct regulator_dev *reg)
212 {
213         struct ab3100_regulator *abreg = reg->reg_data;
214         int err;
215         u8 regval;
216
217         /*
218          * LDO D is a special regulator. When it is disabled, the entire
219          * system is shut down. So this is handled specially.
220          */
221         pr_info("Called ab3100_disable_regulator\n");
222         if (abreg->regreg == AB3100_LDO_D) {
223                 dev_info(&reg->dev, "disabling LDO D - shut down system\n");
224                 /* Setting LDO D to 0x00 cuts the power to the SoC */
225                 return abx500_set_register_interruptible(abreg->dev, 0,
226                                                          AB3100_LDO_D, 0x00U);
227         }
228
229         /*
230          * All other regulators are handled here
231          */
232         err = abx500_get_register_interruptible(abreg->dev, 0, abreg->regreg,
233                                                 &regval);
234         if (err) {
235                 dev_err(&reg->dev, "unable to get register 0x%x\n",
236                         abreg->regreg);
237                 return err;
238         }
239         regval &= ~AB3100_REG_ON_MASK;
240         return abx500_set_register_interruptible(abreg->dev, 0, abreg->regreg,
241                                                  regval);
242 }
243
244 static int ab3100_is_enabled_regulator(struct regulator_dev *reg)
245 {
246         struct ab3100_regulator *abreg = reg->reg_data;
247         u8 regval;
248         int err;
249
250         err = abx500_get_register_interruptible(abreg->dev, 0, abreg->regreg,
251                                                 &regval);
252         if (err) {
253                 dev_err(&reg->dev, "unable to get register 0x%x\n",
254                         abreg->regreg);
255                 return err;
256         }
257
258         return regval & AB3100_REG_ON_MASK;
259 }
260
261 static int ab3100_list_voltage_regulator(struct regulator_dev *reg,
262                                          unsigned selector)
263 {
264         struct ab3100_regulator *abreg = reg->reg_data;
265
266         if (selector >= abreg->voltages_len)
267                 return -EINVAL;
268         return abreg->typ_voltages[selector];
269 }
270
271 static int ab3100_get_voltage_regulator(struct regulator_dev *reg)
272 {
273         struct ab3100_regulator *abreg = reg->reg_data;
274         u8 regval;
275         int err;
276
277         /* Return the voltage for fixed regulators immediately */
278         if (abreg->fixed_voltage)
279                 return abreg->fixed_voltage;
280
281         /*
282          * For variable types, read out setting and index into
283          * supplied voltage list.
284          */
285         err = abx500_get_register_interruptible(abreg->dev, 0,
286                                                 abreg->regreg, &regval);
287         if (err) {
288                 dev_warn(&reg->dev,
289                          "failed to get regulator value in register %02x\n",
290                          abreg->regreg);
291                 return err;
292         }
293
294         /* The 3 highest bits index voltages */
295         regval &= 0xE0;
296         regval >>= 5;
297
298         if (regval >= abreg->voltages_len) {
299                 dev_err(&reg->dev,
300                         "regulator register %02x contains an illegal voltage setting\n",
301                         abreg->regreg);
302                 return -EINVAL;
303         }
304
305         return abreg->typ_voltages[regval];
306 }
307
308 static int ab3100_get_best_voltage_index(struct regulator_dev *reg,
309                                    int min_uV, int max_uV)
310 {
311         struct ab3100_regulator *abreg = reg->reg_data;
312         int i;
313         int bestmatch;
314         int bestindex;
315
316         /*
317          * Locate the minimum voltage fitting the criteria on
318          * this regulator. The switchable voltages are not
319          * in strict falling order so we need to check them
320          * all for the best match.
321          */
322         bestmatch = INT_MAX;
323         bestindex = -1;
324         for (i = 0; i < abreg->voltages_len; i++) {
325                 if (abreg->typ_voltages[i] <= max_uV &&
326                     abreg->typ_voltages[i] >= min_uV &&
327                     abreg->typ_voltages[i] < bestmatch) {
328                         bestmatch = abreg->typ_voltages[i];
329                         bestindex = i;
330                 }
331         }
332
333         if (bestindex < 0) {
334                 dev_warn(&reg->dev, "requested %d<=x<=%d uV, out of range!\n",
335                          min_uV, max_uV);
336                 return -EINVAL;
337         }
338         return bestindex;
339 }
340
341 static int ab3100_set_voltage_regulator(struct regulator_dev *reg,
342                                         int min_uV, int max_uV,
343                                         unsigned *selector)
344 {
345         struct ab3100_regulator *abreg = reg->reg_data;
346         u8 regval;
347         int err;
348         int bestindex;
349
350         bestindex = ab3100_get_best_voltage_index(reg, min_uV, max_uV);
351         if (bestindex < 0)
352                 return bestindex;
353
354         *selector = bestindex;
355
356         err = abx500_get_register_interruptible(abreg->dev, 0,
357                                                 abreg->regreg, &regval);
358         if (err) {
359                 dev_warn(&reg->dev,
360                          "failed to get regulator register %02x\n",
361                          abreg->regreg);
362                 return err;
363         }
364
365         /* The highest three bits control the variable regulators */
366         regval &= ~0xE0;
367         regval |= (bestindex << 5);
368
369         err = abx500_set_register_interruptible(abreg->dev, 0,
370                                                 abreg->regreg, regval);
371         if (err)
372                 dev_warn(&reg->dev, "failed to set regulator register %02x\n",
373                         abreg->regreg);
374
375         return err;
376 }
377
378 static int ab3100_set_suspend_voltage_regulator(struct regulator_dev *reg,
379                                                 int uV)
380 {
381         struct ab3100_regulator *abreg = reg->reg_data;
382         u8 regval;
383         int err;
384         int bestindex;
385         u8 targetreg;
386
387         if (abreg->regreg == AB3100_LDO_E)
388                 targetreg = AB3100_LDO_E_SLEEP;
389         else if (abreg->regreg == AB3100_BUCK)
390                 targetreg = AB3100_BUCK_SLEEP;
391         else
392                 return -EINVAL;
393
394         /* LDO E and BUCK have special suspend voltages you can set */
395         bestindex = ab3100_get_best_voltage_index(reg, uV, uV);
396
397         err = abx500_get_register_interruptible(abreg->dev, 0,
398                                                 targetreg, &regval);
399         if (err) {
400                 dev_warn(&reg->dev,
401                          "failed to get regulator register %02x\n",
402                          targetreg);
403                 return err;
404         }
405
406         /* The highest three bits control the variable regulators */
407         regval &= ~0xE0;
408         regval |= (bestindex << 5);
409
410         err = abx500_set_register_interruptible(abreg->dev, 0,
411                                                 targetreg, regval);
412         if (err)
413                 dev_warn(&reg->dev, "failed to set regulator register %02x\n",
414                         abreg->regreg);
415
416         return err;
417 }
418
419 /*
420  * The external regulator can just define a fixed voltage.
421  */
422 static int ab3100_get_voltage_regulator_external(struct regulator_dev *reg)
423 {
424         struct ab3100_regulator *abreg = reg->reg_data;
425
426         return abreg->plfdata->external_voltage;
427 }
428
429 static int ab3100_enable_time_regulator(struct regulator_dev *reg)
430 {
431         struct ab3100_regulator *abreg = reg->reg_data;
432
433         /* Per-regulator power on delay from spec */
434         switch (abreg->regreg) {
435         case AB3100_LDO_A: /* Fallthrough */
436         case AB3100_LDO_C: /* Fallthrough */
437         case AB3100_LDO_D: /* Fallthrough */
438         case AB3100_LDO_E: /* Fallthrough */
439         case AB3100_LDO_H: /* Fallthrough */
440         case AB3100_LDO_K:
441                 return 200;
442         case AB3100_LDO_F:
443                 return 600;
444         case AB3100_LDO_G:
445                 return 400;
446         case AB3100_BUCK:
447                 return 1000;
448         default:
449                 break;
450         }
451         return 0;
452 }
453
454 static struct regulator_ops regulator_ops_fixed = {
455         .enable      = ab3100_enable_regulator,
456         .disable     = ab3100_disable_regulator,
457         .is_enabled  = ab3100_is_enabled_regulator,
458         .get_voltage = ab3100_get_voltage_regulator,
459         .enable_time = ab3100_enable_time_regulator,
460 };
461
462 static struct regulator_ops regulator_ops_variable = {
463         .enable      = ab3100_enable_regulator,
464         .disable     = ab3100_disable_regulator,
465         .is_enabled  = ab3100_is_enabled_regulator,
466         .get_voltage = ab3100_get_voltage_regulator,
467         .set_voltage = ab3100_set_voltage_regulator,
468         .list_voltage = ab3100_list_voltage_regulator,
469         .enable_time = ab3100_enable_time_regulator,
470 };
471
472 static struct regulator_ops regulator_ops_variable_sleepable = {
473         .enable      = ab3100_enable_regulator,
474         .disable     = ab3100_disable_regulator,
475         .is_enabled  = ab3100_is_enabled_regulator,
476         .get_voltage = ab3100_get_voltage_regulator,
477         .set_voltage = ab3100_set_voltage_regulator,
478         .set_suspend_voltage = ab3100_set_suspend_voltage_regulator,
479         .list_voltage = ab3100_list_voltage_regulator,
480         .enable_time = ab3100_enable_time_regulator,
481 };
482
483 /*
484  * LDO EXT is an external regulator so it is really
485  * not possible to set any voltage locally here, AB3100
486  * is an on/off switch plain an simple. The external
487  * voltage is defined in the board set-up if any.
488  */
489 static struct regulator_ops regulator_ops_external = {
490         .enable      = ab3100_enable_regulator,
491         .disable     = ab3100_disable_regulator,
492         .is_enabled  = ab3100_is_enabled_regulator,
493         .get_voltage = ab3100_get_voltage_regulator_external,
494 };
495
496 static struct regulator_desc
497 ab3100_regulator_desc[AB3100_NUM_REGULATORS] = {
498         {
499                 .name = "LDO_A",
500                 .id   = AB3100_LDO_A,
501                 .ops  = &regulator_ops_fixed,
502                 .type = REGULATOR_VOLTAGE,
503                 .owner = THIS_MODULE,
504         },
505         {
506                 .name = "LDO_C",
507                 .id   = AB3100_LDO_C,
508                 .ops  = &regulator_ops_fixed,
509                 .type = REGULATOR_VOLTAGE,
510                 .owner = THIS_MODULE,
511         },
512         {
513                 .name = "LDO_D",
514                 .id   = AB3100_LDO_D,
515                 .ops  = &regulator_ops_fixed,
516                 .type = REGULATOR_VOLTAGE,
517                 .owner = THIS_MODULE,
518         },
519         {
520                 .name = "LDO_E",
521                 .id   = AB3100_LDO_E,
522                 .ops  = &regulator_ops_variable_sleepable,
523                 .n_voltages = ARRAY_SIZE(ldo_e_buck_typ_voltages),
524                 .type = REGULATOR_VOLTAGE,
525                 .owner = THIS_MODULE,
526         },
527         {
528                 .name = "LDO_F",
529                 .id   = AB3100_LDO_F,
530                 .ops  = &regulator_ops_variable,
531                 .n_voltages = ARRAY_SIZE(ldo_f_typ_voltages),
532                 .type = REGULATOR_VOLTAGE,
533                 .owner = THIS_MODULE,
534         },
535         {
536                 .name = "LDO_G",
537                 .id   = AB3100_LDO_G,
538                 .ops  = &regulator_ops_variable,
539                 .n_voltages = ARRAY_SIZE(ldo_g_typ_voltages),
540                 .type = REGULATOR_VOLTAGE,
541                 .owner = THIS_MODULE,
542         },
543         {
544                 .name = "LDO_H",
545                 .id   = AB3100_LDO_H,
546                 .ops  = &regulator_ops_variable,
547                 .n_voltages = ARRAY_SIZE(ldo_h_typ_voltages),
548                 .type = REGULATOR_VOLTAGE,
549                 .owner = THIS_MODULE,
550         },
551         {
552                 .name = "LDO_K",
553                 .id   = AB3100_LDO_K,
554                 .ops  = &regulator_ops_variable,
555                 .n_voltages = ARRAY_SIZE(ldo_k_typ_voltages),
556                 .type = REGULATOR_VOLTAGE,
557                 .owner = THIS_MODULE,
558         },
559         {
560                 .name = "LDO_EXT",
561                 .id   = AB3100_LDO_EXT,
562                 .ops  = &regulator_ops_external,
563                 .type = REGULATOR_VOLTAGE,
564                 .owner = THIS_MODULE,
565         },
566         {
567                 .name = "BUCK",
568                 .id   = AB3100_BUCK,
569                 .ops  = &regulator_ops_variable_sleepable,
570                 .n_voltages = ARRAY_SIZE(ldo_e_buck_typ_voltages),
571                 .type = REGULATOR_VOLTAGE,
572                 .owner = THIS_MODULE,
573         },
574 };
575
576 /*
577  * NOTE: the following functions are regulators pluralis - it is the
578  * binding to the AB3100 core driver and the parent platform device
579  * for all the different regulators.
580  */
581
582 static int __devinit ab3100_regulators_probe(struct platform_device *pdev)
583 {
584         struct ab3100_platform_data *plfdata = pdev->dev.platform_data;
585         int err = 0;
586         u8 data;
587         int i;
588
589         /* Check chip state */
590         err = abx500_get_register_interruptible(&pdev->dev, 0,
591                                                 AB3100_LDO_D, &data);
592         if (err) {
593                 dev_err(&pdev->dev, "could not read initial status of LDO_D\n");
594                 return err;
595         }
596         if (data & 0x10)
597                 dev_notice(&pdev->dev,
598                            "chip is already in active mode (Warm start)\n");
599         else
600                 dev_notice(&pdev->dev,
601                            "chip is in inactive mode (Cold start)\n");
602
603         /* Set up regulators */
604         for (i = 0; i < ARRAY_SIZE(ab3100_reg_init_order); i++) {
605                 err = abx500_set_register_interruptible(&pdev->dev, 0,
606                                         ab3100_reg_init_order[i],
607                                         plfdata->reg_initvals[i]);
608                 if (err) {
609                         dev_err(&pdev->dev, "regulator initialization failed with error %d\n",
610                                 err);
611                         return err;
612                 }
613         }
614
615         /* Register the regulators */
616         for (i = 0; i < AB3100_NUM_REGULATORS; i++) {
617                 struct ab3100_regulator *reg = &ab3100_regulators[i];
618                 struct regulator_dev *rdev;
619
620                 /*
621                  * Initialize per-regulator struct.
622                  * Inherit platform data, this comes down from the
623                  * i2c boarddata, from the machine. So if you want to
624                  * see what it looks like for a certain machine, go
625                  * into the machine I2C setup.
626                  */
627                 reg->dev = &pdev->dev;
628                 reg->plfdata = plfdata;
629
630                 /*
631                  * Register the regulator, pass around
632                  * the ab3100_regulator struct
633                  */
634                 rdev = regulator_register(&ab3100_regulator_desc[i],
635                                           &pdev->dev,
636                                           &plfdata->reg_constraints[i],
637                                           reg, NULL);
638
639                 if (IS_ERR(rdev)) {
640                         err = PTR_ERR(rdev);
641                         dev_err(&pdev->dev,
642                                 "%s: failed to register regulator %s err %d\n",
643                                 __func__, ab3100_regulator_desc[i].name,
644                                 err);
645                         /* remove the already registered regulators */
646                         while (--i >= 0)
647                                 regulator_unregister(ab3100_regulators[i].rdev);
648                         return err;
649                 }
650
651                 /* Then set a pointer back to the registered regulator */
652                 reg->rdev = rdev;
653         }
654
655         return 0;
656 }
657
658 static int __devexit ab3100_regulators_remove(struct platform_device *pdev)
659 {
660         int i;
661
662         for (i = 0; i < AB3100_NUM_REGULATORS; i++) {
663                 struct ab3100_regulator *reg = &ab3100_regulators[i];
664
665                 regulator_unregister(reg->rdev);
666         }
667         return 0;
668 }
669
670 static struct platform_driver ab3100_regulators_driver = {
671         .driver = {
672                 .name  = "ab3100-regulators",
673                 .owner = THIS_MODULE,
674         },
675         .probe = ab3100_regulators_probe,
676         .remove = __devexit_p(ab3100_regulators_remove),
677 };
678
679 static __init int ab3100_regulators_init(void)
680 {
681         return platform_driver_register(&ab3100_regulators_driver);
682 }
683
684 static __exit void ab3100_regulators_exit(void)
685 {
686         platform_driver_unregister(&ab3100_regulators_driver);
687 }
688
689 subsys_initcall(ab3100_regulators_init);
690 module_exit(ab3100_regulators_exit);
691
692 MODULE_AUTHOR("Mattias Wallin <mattias.wallin@stericsson.com>");
693 MODULE_DESCRIPTION("AB3100 Regulator driver");
694 MODULE_LICENSE("GPL");
695 MODULE_ALIAS("platform:ab3100-regulators");