2 * drivers/regulator/ab3100.c
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>
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 #include <linux/mfd/core.h>
22 /* LDO registers and some handy masking definitions for AB3100 */
23 #define AB3100_LDO_A 0x40
24 #define AB3100_LDO_C 0x41
25 #define AB3100_LDO_D 0x42
26 #define AB3100_LDO_E 0x43
27 #define AB3100_LDO_E_SLEEP 0x44
28 #define AB3100_LDO_F 0x45
29 #define AB3100_LDO_G 0x46
30 #define AB3100_LDO_H 0x47
31 #define AB3100_LDO_H_SLEEP_MODE 0
32 #define AB3100_LDO_H_SLEEP_EN 2
33 #define AB3100_LDO_ON 4
34 #define AB3100_LDO_H_VSEL_AC 5
35 #define AB3100_LDO_K 0x48
36 #define AB3100_LDO_EXT 0x49
37 #define AB3100_BUCK 0x4A
38 #define AB3100_BUCK_SLEEP 0x4B
39 #define AB3100_REG_ON_MASK 0x10
42 * struct ab3100_regulator
43 * A struct passed around the individual regulator functions
44 * @platform_device: platform device holding this regulator
45 * @dev: handle to the device
46 * @plfdata: AB3100 platform data passed in at probe time
47 * @regreg: regulator register number in the AB3100
48 * @fixed_voltage: a fixed voltage for this regulator, if this
49 * 0 the voltages array is used instead.
50 * @typ_voltages: an array of available typical voltages for
52 * @voltages_len: length of the array of available voltages
54 struct ab3100_regulator {
55 struct regulator_dev *rdev;
57 struct ab3100_platform_data *plfdata;
60 int const *typ_voltages;
64 /* The order in which registers are initialized */
65 static const u8 ab3100_reg_init_order[AB3100_NUM_REGULATORS+2] = {
80 /* Preset (hardware defined) voltages for these regulators */
81 #define LDO_A_VOLTAGE 2750000
82 #define LDO_C_VOLTAGE 2650000
83 #define LDO_D_VOLTAGE 2650000
85 static const int ldo_e_buck_typ_voltages[] = {
95 static const int ldo_f_typ_voltages[] = {
106 static const int ldo_g_typ_voltages[] = {
113 static const int ldo_h_typ_voltages[] = {
120 static const int ldo_k_typ_voltages[] = {
126 /* The regulator devices */
127 static struct ab3100_regulator
128 ab3100_regulators[AB3100_NUM_REGULATORS] = {
130 .regreg = AB3100_LDO_A,
131 .fixed_voltage = LDO_A_VOLTAGE,
134 .regreg = AB3100_LDO_C,
135 .fixed_voltage = LDO_C_VOLTAGE,
138 .regreg = AB3100_LDO_D,
139 .fixed_voltage = LDO_D_VOLTAGE,
142 .regreg = AB3100_LDO_E,
143 .typ_voltages = ldo_e_buck_typ_voltages,
144 .voltages_len = ARRAY_SIZE(ldo_e_buck_typ_voltages),
147 .regreg = AB3100_LDO_F,
148 .typ_voltages = ldo_f_typ_voltages,
149 .voltages_len = ARRAY_SIZE(ldo_f_typ_voltages),
152 .regreg = AB3100_LDO_G,
153 .typ_voltages = ldo_g_typ_voltages,
154 .voltages_len = ARRAY_SIZE(ldo_g_typ_voltages),
157 .regreg = AB3100_LDO_H,
158 .typ_voltages = ldo_h_typ_voltages,
159 .voltages_len = ARRAY_SIZE(ldo_h_typ_voltages),
162 .regreg = AB3100_LDO_K,
163 .typ_voltages = ldo_k_typ_voltages,
164 .voltages_len = ARRAY_SIZE(ldo_k_typ_voltages),
167 .regreg = AB3100_LDO_EXT,
168 /* No voltages for the external regulator */
171 .regreg = AB3100_BUCK,
172 .typ_voltages = ldo_e_buck_typ_voltages,
173 .voltages_len = ARRAY_SIZE(ldo_e_buck_typ_voltages),
178 * General functions for enable, disable and is_enabled used for
179 * LDO: A,C,E,F,G,H,K,EXT and BUCK
181 static int ab3100_enable_regulator(struct regulator_dev *reg)
183 struct ab3100_regulator *abreg = reg->reg_data;
187 err = abx500_get_register_interruptible(abreg->dev, 0, abreg->regreg,
190 dev_warn(®->dev, "failed to get regid %d value\n",
195 /* The regulator is already on, no reason to go further */
196 if (regval & AB3100_REG_ON_MASK)
199 regval |= AB3100_REG_ON_MASK;
201 err = abx500_set_register_interruptible(abreg->dev, 0, abreg->regreg,
204 dev_warn(®->dev, "failed to set regid %d value\n",
209 /* Per-regulator power on delay from spec */
210 switch (abreg->regreg) {
211 case AB3100_LDO_A: /* Fallthrough */
212 case AB3100_LDO_C: /* Fallthrough */
213 case AB3100_LDO_D: /* Fallthrough */
214 case AB3100_LDO_E: /* Fallthrough */
215 case AB3100_LDO_H: /* Fallthrough */
235 static int ab3100_disable_regulator(struct regulator_dev *reg)
237 struct ab3100_regulator *abreg = reg->reg_data;
242 * LDO D is a special regulator. When it is disabled, the entire
243 * system is shut down. So this is handled specially.
245 pr_info("Called ab3100_disable_regulator\n");
246 if (abreg->regreg == AB3100_LDO_D) {
247 dev_info(®->dev, "disabling LDO D - shut down system\n");
248 /* Setting LDO D to 0x00 cuts the power to the SoC */
249 return abx500_set_register_interruptible(abreg->dev, 0,
250 AB3100_LDO_D, 0x00U);
254 * All other regulators are handled here
256 err = abx500_get_register_interruptible(abreg->dev, 0, abreg->regreg,
259 dev_err(®->dev, "unable to get register 0x%x\n",
263 regval &= ~AB3100_REG_ON_MASK;
264 return abx500_set_register_interruptible(abreg->dev, 0, abreg->regreg,
268 static int ab3100_is_enabled_regulator(struct regulator_dev *reg)
270 struct ab3100_regulator *abreg = reg->reg_data;
274 err = abx500_get_register_interruptible(abreg->dev, 0, abreg->regreg,
277 dev_err(®->dev, "unable to get register 0x%x\n",
282 return regval & AB3100_REG_ON_MASK;
285 static int ab3100_list_voltage_regulator(struct regulator_dev *reg,
288 struct ab3100_regulator *abreg = reg->reg_data;
290 if (selector >= abreg->voltages_len)
292 return abreg->typ_voltages[selector];
295 static int ab3100_get_voltage_regulator(struct regulator_dev *reg)
297 struct ab3100_regulator *abreg = reg->reg_data;
301 /* Return the voltage for fixed regulators immediately */
302 if (abreg->fixed_voltage)
303 return abreg->fixed_voltage;
306 * For variable types, read out setting and index into
307 * supplied voltage list.
309 err = abx500_get_register_interruptible(abreg->dev, 0,
310 abreg->regreg, ®val);
313 "failed to get regulator value in register %02x\n",
318 /* The 3 highest bits index voltages */
322 if (regval >= abreg->voltages_len) {
324 "regulator register %02x contains an illegal voltage setting\n",
329 return abreg->typ_voltages[regval];
332 static int ab3100_get_best_voltage_index(struct regulator_dev *reg,
333 int min_uV, int max_uV)
335 struct ab3100_regulator *abreg = reg->reg_data;
341 * Locate the minimum voltage fitting the criteria on
342 * this regulator. The switchable voltages are not
343 * in strict falling order so we need to check them
344 * all for the best match.
348 for (i = 0; i < abreg->voltages_len; i++) {
349 if (abreg->typ_voltages[i] <= max_uV &&
350 abreg->typ_voltages[i] >= min_uV &&
351 abreg->typ_voltages[i] < bestmatch) {
352 bestmatch = abreg->typ_voltages[i];
358 dev_warn(®->dev, "requested %d<=x<=%d uV, out of range!\n",
365 static int ab3100_set_voltage_regulator(struct regulator_dev *reg,
366 int min_uV, int max_uV,
369 struct ab3100_regulator *abreg = reg->reg_data;
374 bestindex = ab3100_get_best_voltage_index(reg, min_uV, max_uV);
378 *selector = bestindex;
380 err = abx500_get_register_interruptible(abreg->dev, 0,
381 abreg->regreg, ®val);
384 "failed to get regulator register %02x\n",
389 /* The highest three bits control the variable regulators */
391 regval |= (bestindex << 5);
393 err = abx500_set_register_interruptible(abreg->dev, 0,
394 abreg->regreg, regval);
396 dev_warn(®->dev, "failed to set regulator register %02x\n",
402 static int ab3100_set_suspend_voltage_regulator(struct regulator_dev *reg,
405 struct ab3100_regulator *abreg = reg->reg_data;
411 if (abreg->regreg == AB3100_LDO_E)
412 targetreg = AB3100_LDO_E_SLEEP;
413 else if (abreg->regreg == AB3100_BUCK)
414 targetreg = AB3100_BUCK_SLEEP;
418 /* LDO E and BUCK have special suspend voltages you can set */
419 bestindex = ab3100_get_best_voltage_index(reg, uV, uV);
421 err = abx500_get_register_interruptible(abreg->dev, 0,
425 "failed to get regulator register %02x\n",
430 /* The highest three bits control the variable regulators */
432 regval |= (bestindex << 5);
434 err = abx500_set_register_interruptible(abreg->dev, 0,
437 dev_warn(®->dev, "failed to set regulator register %02x\n",
444 * The external regulator can just define a fixed voltage.
446 static int ab3100_get_voltage_regulator_external(struct regulator_dev *reg)
448 struct ab3100_regulator *abreg = reg->reg_data;
450 return abreg->plfdata->external_voltage;
453 static struct regulator_ops regulator_ops_fixed = {
454 .enable = ab3100_enable_regulator,
455 .disable = ab3100_disable_regulator,
456 .is_enabled = ab3100_is_enabled_regulator,
457 .get_voltage = ab3100_get_voltage_regulator,
460 static struct regulator_ops regulator_ops_variable = {
461 .enable = ab3100_enable_regulator,
462 .disable = ab3100_disable_regulator,
463 .is_enabled = ab3100_is_enabled_regulator,
464 .get_voltage = ab3100_get_voltage_regulator,
465 .set_voltage = ab3100_set_voltage_regulator,
466 .list_voltage = ab3100_list_voltage_regulator,
469 static struct regulator_ops regulator_ops_variable_sleepable = {
470 .enable = ab3100_enable_regulator,
471 .disable = ab3100_disable_regulator,
472 .is_enabled = ab3100_is_enabled_regulator,
473 .get_voltage = ab3100_get_voltage_regulator,
474 .set_voltage = ab3100_set_voltage_regulator,
475 .set_suspend_voltage = ab3100_set_suspend_voltage_regulator,
476 .list_voltage = ab3100_list_voltage_regulator,
480 * LDO EXT is an external regulator so it is really
481 * not possible to set any voltage locally here, AB3100
482 * is an on/off switch plain an simple. The external
483 * voltage is defined in the board set-up if any.
485 static struct regulator_ops regulator_ops_external = {
486 .enable = ab3100_enable_regulator,
487 .disable = ab3100_disable_regulator,
488 .is_enabled = ab3100_is_enabled_regulator,
489 .get_voltage = ab3100_get_voltage_regulator_external,
492 static struct regulator_desc
493 ab3100_regulator_desc[AB3100_NUM_REGULATORS] = {
497 .ops = ®ulator_ops_fixed,
498 .type = REGULATOR_VOLTAGE,
499 .owner = THIS_MODULE,
504 .ops = ®ulator_ops_fixed,
505 .type = REGULATOR_VOLTAGE,
506 .owner = THIS_MODULE,
511 .ops = ®ulator_ops_fixed,
512 .type = REGULATOR_VOLTAGE,
513 .owner = THIS_MODULE,
518 .ops = ®ulator_ops_variable_sleepable,
519 .n_voltages = ARRAY_SIZE(ldo_e_buck_typ_voltages),
520 .type = REGULATOR_VOLTAGE,
521 .owner = THIS_MODULE,
526 .ops = ®ulator_ops_variable,
527 .n_voltages = ARRAY_SIZE(ldo_f_typ_voltages),
528 .type = REGULATOR_VOLTAGE,
529 .owner = THIS_MODULE,
534 .ops = ®ulator_ops_variable,
535 .n_voltages = ARRAY_SIZE(ldo_g_typ_voltages),
536 .type = REGULATOR_VOLTAGE,
537 .owner = THIS_MODULE,
542 .ops = ®ulator_ops_variable,
543 .n_voltages = ARRAY_SIZE(ldo_h_typ_voltages),
544 .type = REGULATOR_VOLTAGE,
545 .owner = THIS_MODULE,
550 .ops = ®ulator_ops_variable,
551 .n_voltages = ARRAY_SIZE(ldo_k_typ_voltages),
552 .type = REGULATOR_VOLTAGE,
553 .owner = THIS_MODULE,
557 .id = AB3100_LDO_EXT,
558 .ops = ®ulator_ops_external,
559 .type = REGULATOR_VOLTAGE,
560 .owner = THIS_MODULE,
565 .ops = ®ulator_ops_variable_sleepable,
566 .n_voltages = ARRAY_SIZE(ldo_e_buck_typ_voltages),
567 .type = REGULATOR_VOLTAGE,
568 .owner = THIS_MODULE,
573 * NOTE: the following functions are regulators pluralis - it is the
574 * binding to the AB3100 core driver and the parent platform device
575 * for all the different regulators.
578 static int __devinit ab3100_regulators_probe(struct platform_device *pdev)
580 struct ab3100_platform_data *plfdata = mfd_get_data(pdev);
585 /* Check chip state */
586 err = abx500_get_register_interruptible(&pdev->dev, 0,
587 AB3100_LDO_D, &data);
589 dev_err(&pdev->dev, "could not read initial status of LDO_D\n");
593 dev_notice(&pdev->dev,
594 "chip is already in active mode (Warm start)\n");
596 dev_notice(&pdev->dev,
597 "chip is in inactive mode (Cold start)\n");
599 /* Set up regulators */
600 for (i = 0; i < ARRAY_SIZE(ab3100_reg_init_order); i++) {
601 err = abx500_set_register_interruptible(&pdev->dev, 0,
602 ab3100_reg_init_order[i],
603 plfdata->reg_initvals[i]);
605 dev_err(&pdev->dev, "regulator initialization failed with error %d\n",
611 /* Register the regulators */
612 for (i = 0; i < AB3100_NUM_REGULATORS; i++) {
613 struct ab3100_regulator *reg = &ab3100_regulators[i];
614 struct regulator_dev *rdev;
617 * Initialize per-regulator struct.
618 * Inherit platform data, this comes down from the
619 * i2c boarddata, from the machine. So if you want to
620 * see what it looks like for a certain machine, go
621 * into the machine I2C setup.
623 reg->dev = &pdev->dev;
624 reg->plfdata = plfdata;
627 * Register the regulator, pass around
628 * the ab3100_regulator struct
630 rdev = regulator_register(&ab3100_regulator_desc[i],
632 &plfdata->reg_constraints[i],
638 "%s: failed to register regulator %s err %d\n",
639 __func__, ab3100_regulator_desc[i].name,
641 /* remove the already registered regulators */
643 regulator_unregister(ab3100_regulators[i].rdev);
647 /* Then set a pointer back to the registered regulator */
654 static int __devexit ab3100_regulators_remove(struct platform_device *pdev)
658 for (i = 0; i < AB3100_NUM_REGULATORS; i++) {
659 struct ab3100_regulator *reg = &ab3100_regulators[i];
661 regulator_unregister(reg->rdev);
666 static struct platform_driver ab3100_regulators_driver = {
668 .name = "ab3100-regulators",
669 .owner = THIS_MODULE,
671 .probe = ab3100_regulators_probe,
672 .remove = __devexit_p(ab3100_regulators_remove),
675 static __init int ab3100_regulators_init(void)
677 return platform_driver_register(&ab3100_regulators_driver);
680 static __exit void ab3100_regulators_exit(void)
682 platform_driver_unregister(&ab3100_regulators_driver);
685 subsys_initcall(ab3100_regulators_init);
686 module_exit(ab3100_regulators_exit);
688 MODULE_AUTHOR("Mattias Wallin <mattias.wallin@stericsson.com>");
689 MODULE_DESCRIPTION("AB3100 Regulator driver");
690 MODULE_LICENSE("GPL");
691 MODULE_ALIAS("platform:ab3100-regulators");