2 * tps65910.c -- TI tps65910
4 * Copyright 2010 Texas Instruments Inc.
6 * Author: Graeme Gregory <gg@slimlogic.co.uk>
7 * Author: Jorge Eduardo Candelaria <jedu@slimlogic.co.uk>
9 * This program is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU General Public License as published by the
11 * Free Software Foundation; either version 2 of the License, or (at your
12 * option) any later version.
16 #include <linux/kernel.h>
17 #include <linux/module.h>
18 #include <linux/init.h>
19 #include <linux/err.h>
20 #include <linux/platform_device.h>
21 #include <linux/regulator/driver.h>
22 #include <linux/regulator/machine.h>
23 #include <linux/slab.h>
24 #include <linux/gpio.h>
25 #include <linux/mfd/tps65910.h>
27 #define TPS65910_SUPPLY_STATE_ENABLED 0x1
28 #define EXT_SLEEP_CONTROL (TPS65910_SLEEP_CONTROL_EXT_INPUT_EN1 | \
29 TPS65910_SLEEP_CONTROL_EXT_INPUT_EN2 | \
30 TPS65910_SLEEP_CONTROL_EXT_INPUT_EN3 | \
31 TPS65911_SLEEP_CONTROL_EXT_INPUT_SLEEP)
33 /* supported VIO voltages in milivolts */
34 static const u16 VIO_VSEL_table
[] = {
35 1500, 1800, 2500, 3300,
38 /* VSEL tables for TPS65910 specific LDOs and dcdc's */
40 /* supported VDD3 voltages in milivolts */
41 static const u16 VDD3_VSEL_table
[] = {
45 /* supported VDIG1 voltages in milivolts */
46 static const u16 VDIG1_VSEL_table
[] = {
47 1200, 1500, 1800, 2700,
50 /* supported VDIG2 voltages in milivolts */
51 static const u16 VDIG2_VSEL_table
[] = {
52 1000, 1100, 1200, 1800,
55 /* supported VPLL voltages in milivolts */
56 static const u16 VPLL_VSEL_table
[] = {
57 1000, 1100, 1800, 2500,
60 /* supported VDAC voltages in milivolts */
61 static const u16 VDAC_VSEL_table
[] = {
62 1800, 2600, 2800, 2850,
65 /* supported VAUX1 voltages in milivolts */
66 static const u16 VAUX1_VSEL_table
[] = {
67 1800, 2500, 2800, 2850,
70 /* supported VAUX2 voltages in milivolts */
71 static const u16 VAUX2_VSEL_table
[] = {
72 1800, 2800, 2900, 3300,
75 /* supported VAUX33 voltages in milivolts */
76 static const u16 VAUX33_VSEL_table
[] = {
77 1800, 2000, 2800, 3300,
80 /* supported VMMC voltages in milivolts */
81 static const u16 VMMC_VSEL_table
[] = {
82 1800, 2800, 3000, 3300,
90 const u16
*voltage_table
;
94 static struct tps_info tps65910_regs
[] = {
97 .enable_time_us
= 2200,
103 .n_voltages
= ARRAY_SIZE(VIO_VSEL_table
),
104 .voltage_table
= VIO_VSEL_table
,
105 .enable_time_us
= 350,
111 .enable_time_us
= 350,
117 .enable_time_us
= 350,
123 .n_voltages
= ARRAY_SIZE(VDD3_VSEL_table
),
124 .voltage_table
= VDD3_VSEL_table
,
125 .enable_time_us
= 200,
131 .n_voltages
= ARRAY_SIZE(VDIG1_VSEL_table
),
132 .voltage_table
= VDIG1_VSEL_table
,
133 .enable_time_us
= 100,
139 .n_voltages
= ARRAY_SIZE(VDIG2_VSEL_table
),
140 .voltage_table
= VDIG2_VSEL_table
,
141 .enable_time_us
= 100,
147 .n_voltages
= ARRAY_SIZE(VPLL_VSEL_table
),
148 .voltage_table
= VPLL_VSEL_table
,
149 .enable_time_us
= 100,
155 .n_voltages
= ARRAY_SIZE(VDAC_VSEL_table
),
156 .voltage_table
= VDAC_VSEL_table
,
157 .enable_time_us
= 100,
163 .n_voltages
= ARRAY_SIZE(VAUX1_VSEL_table
),
164 .voltage_table
= VAUX1_VSEL_table
,
165 .enable_time_us
= 100,
171 .n_voltages
= ARRAY_SIZE(VAUX2_VSEL_table
),
172 .voltage_table
= VAUX2_VSEL_table
,
173 .enable_time_us
= 100,
179 .n_voltages
= ARRAY_SIZE(VAUX33_VSEL_table
),
180 .voltage_table
= VAUX33_VSEL_table
,
181 .enable_time_us
= 100,
187 .n_voltages
= ARRAY_SIZE(VMMC_VSEL_table
),
188 .voltage_table
= VMMC_VSEL_table
,
189 .enable_time_us
= 100,
193 static struct tps_info tps65911_regs
[] = {
196 .enable_time_us
= 2200,
202 .n_voltages
= ARRAY_SIZE(VIO_VSEL_table
),
203 .voltage_table
= VIO_VSEL_table
,
204 .enable_time_us
= 350,
211 .enable_time_us
= 350,
218 .enable_time_us
= 350,
225 .enable_time_us
= 900,
232 .enable_time_us
= 420,
239 .enable_time_us
= 420,
246 .enable_time_us
= 230,
253 .enable_time_us
= 230,
260 .enable_time_us
= 230,
267 .enable_time_us
= 230,
274 .enable_time_us
= 230,
281 .enable_time_us
= 230,
285 #define EXT_CONTROL_REG_BITS(id, regs_offs, bits) (((regs_offs) << 8) | (bits))
286 static unsigned int tps65910_ext_sleep_control
[] = {
288 EXT_CONTROL_REG_BITS(VIO
, 1, 0),
289 EXT_CONTROL_REG_BITS(VDD1
, 1, 1),
290 EXT_CONTROL_REG_BITS(VDD2
, 1, 2),
291 EXT_CONTROL_REG_BITS(VDD3
, 1, 3),
292 EXT_CONTROL_REG_BITS(VDIG1
, 0, 1),
293 EXT_CONTROL_REG_BITS(VDIG2
, 0, 2),
294 EXT_CONTROL_REG_BITS(VPLL
, 0, 6),
295 EXT_CONTROL_REG_BITS(VDAC
, 0, 7),
296 EXT_CONTROL_REG_BITS(VAUX1
, 0, 3),
297 EXT_CONTROL_REG_BITS(VAUX2
, 0, 4),
298 EXT_CONTROL_REG_BITS(VAUX33
, 0, 5),
299 EXT_CONTROL_REG_BITS(VMMC
, 0, 0),
302 static unsigned int tps65911_ext_sleep_control
[] = {
304 EXT_CONTROL_REG_BITS(VIO
, 1, 0),
305 EXT_CONTROL_REG_BITS(VDD1
, 1, 1),
306 EXT_CONTROL_REG_BITS(VDD2
, 1, 2),
307 EXT_CONTROL_REG_BITS(VDDCTRL
, 1, 3),
308 EXT_CONTROL_REG_BITS(LDO1
, 0, 1),
309 EXT_CONTROL_REG_BITS(LDO2
, 0, 2),
310 EXT_CONTROL_REG_BITS(LDO3
, 0, 7),
311 EXT_CONTROL_REG_BITS(LDO4
, 0, 6),
312 EXT_CONTROL_REG_BITS(LDO5
, 0, 3),
313 EXT_CONTROL_REG_BITS(LDO6
, 0, 0),
314 EXT_CONTROL_REG_BITS(LDO7
, 0, 5),
315 EXT_CONTROL_REG_BITS(LDO8
, 0, 4),
318 struct tps65910_reg
{
319 struct regulator_desc
*desc
;
320 struct tps65910
*mfd
;
321 struct regulator_dev
**rdev
;
322 struct tps_info
**info
;
326 int (*get_ctrl_reg
)(int);
327 unsigned int *ext_sleep_control
;
328 unsigned int board_ext_control
[TPS65910_NUM_REGS
];
331 static inline int tps65910_read(struct tps65910_reg
*pmic
, u8 reg
)
336 err
= pmic
->mfd
->read(pmic
->mfd
, reg
, 1, &val
);
343 static inline int tps65910_write(struct tps65910_reg
*pmic
, u8 reg
, u8 val
)
345 return pmic
->mfd
->write(pmic
->mfd
, reg
, 1, &val
);
348 static int tps65910_modify_bits(struct tps65910_reg
*pmic
, u8 reg
,
349 u8 set_mask
, u8 clear_mask
)
353 mutex_lock(&pmic
->mutex
);
355 data
= tps65910_read(pmic
, reg
);
357 dev_err(pmic
->mfd
->dev
, "Read from reg 0x%x failed\n", reg
);
364 err
= tps65910_write(pmic
, reg
, data
);
366 dev_err(pmic
->mfd
->dev
, "Write for reg 0x%x failed\n", reg
);
369 mutex_unlock(&pmic
->mutex
);
373 static int tps65910_reg_read(struct tps65910_reg
*pmic
, u8 reg
)
377 mutex_lock(&pmic
->mutex
);
379 data
= tps65910_read(pmic
, reg
);
381 dev_err(pmic
->mfd
->dev
, "Read from reg 0x%x failed\n", reg
);
383 mutex_unlock(&pmic
->mutex
);
387 static int tps65910_reg_write(struct tps65910_reg
*pmic
, u8 reg
, u8 val
)
391 mutex_lock(&pmic
->mutex
);
393 err
= tps65910_write(pmic
, reg
, val
);
395 dev_err(pmic
->mfd
->dev
, "Write for reg 0x%x failed\n", reg
);
397 mutex_unlock(&pmic
->mutex
);
401 static int tps65910_get_ctrl_register(int id
)
404 case TPS65910_REG_VRTC
:
405 return TPS65910_VRTC
;
406 case TPS65910_REG_VIO
:
408 case TPS65910_REG_VDD1
:
409 return TPS65910_VDD1
;
410 case TPS65910_REG_VDD2
:
411 return TPS65910_VDD2
;
412 case TPS65910_REG_VDD3
:
413 return TPS65910_VDD3
;
414 case TPS65910_REG_VDIG1
:
415 return TPS65910_VDIG1
;
416 case TPS65910_REG_VDIG2
:
417 return TPS65910_VDIG2
;
418 case TPS65910_REG_VPLL
:
419 return TPS65910_VPLL
;
420 case TPS65910_REG_VDAC
:
421 return TPS65910_VDAC
;
422 case TPS65910_REG_VAUX1
:
423 return TPS65910_VAUX1
;
424 case TPS65910_REG_VAUX2
:
425 return TPS65910_VAUX2
;
426 case TPS65910_REG_VAUX33
:
427 return TPS65910_VAUX33
;
428 case TPS65910_REG_VMMC
:
429 return TPS65910_VMMC
;
435 static int tps65911_get_ctrl_register(int id
)
438 case TPS65910_REG_VRTC
:
439 return TPS65910_VRTC
;
440 case TPS65910_REG_VIO
:
442 case TPS65910_REG_VDD1
:
443 return TPS65910_VDD1
;
444 case TPS65910_REG_VDD2
:
445 return TPS65910_VDD2
;
446 case TPS65911_REG_VDDCTRL
:
447 return TPS65911_VDDCTRL
;
448 case TPS65911_REG_LDO1
:
449 return TPS65911_LDO1
;
450 case TPS65911_REG_LDO2
:
451 return TPS65911_LDO2
;
452 case TPS65911_REG_LDO3
:
453 return TPS65911_LDO3
;
454 case TPS65911_REG_LDO4
:
455 return TPS65911_LDO4
;
456 case TPS65911_REG_LDO5
:
457 return TPS65911_LDO5
;
458 case TPS65911_REG_LDO6
:
459 return TPS65911_LDO6
;
460 case TPS65911_REG_LDO7
:
461 return TPS65911_LDO7
;
462 case TPS65911_REG_LDO8
:
463 return TPS65911_LDO8
;
469 static int tps65910_is_enabled(struct regulator_dev
*dev
)
471 struct tps65910_reg
*pmic
= rdev_get_drvdata(dev
);
472 int reg
, value
, id
= rdev_get_id(dev
);
474 reg
= pmic
->get_ctrl_reg(id
);
478 value
= tps65910_reg_read(pmic
, reg
);
482 return value
& TPS65910_SUPPLY_STATE_ENABLED
;
485 static int tps65910_enable(struct regulator_dev
*dev
)
487 struct tps65910_reg
*pmic
= rdev_get_drvdata(dev
);
488 struct tps65910
*mfd
= pmic
->mfd
;
489 int reg
, id
= rdev_get_id(dev
);
491 reg
= pmic
->get_ctrl_reg(id
);
495 return tps65910_set_bits(mfd
, reg
, TPS65910_SUPPLY_STATE_ENABLED
);
498 static int tps65910_disable(struct regulator_dev
*dev
)
500 struct tps65910_reg
*pmic
= rdev_get_drvdata(dev
);
501 struct tps65910
*mfd
= pmic
->mfd
;
502 int reg
, id
= rdev_get_id(dev
);
504 reg
= pmic
->get_ctrl_reg(id
);
508 return tps65910_clear_bits(mfd
, reg
, TPS65910_SUPPLY_STATE_ENABLED
);
511 static int tps65910_enable_time(struct regulator_dev
*dev
)
513 struct tps65910_reg
*pmic
= rdev_get_drvdata(dev
);
514 int id
= rdev_get_id(dev
);
515 return pmic
->info
[id
]->enable_time_us
;
518 static int tps65910_set_mode(struct regulator_dev
*dev
, unsigned int mode
)
520 struct tps65910_reg
*pmic
= rdev_get_drvdata(dev
);
521 struct tps65910
*mfd
= pmic
->mfd
;
522 int reg
, value
, id
= rdev_get_id(dev
);
524 reg
= pmic
->get_ctrl_reg(id
);
529 case REGULATOR_MODE_NORMAL
:
530 return tps65910_modify_bits(pmic
, reg
, LDO_ST_ON_BIT
,
532 case REGULATOR_MODE_IDLE
:
533 value
= LDO_ST_ON_BIT
| LDO_ST_MODE_BIT
;
534 return tps65910_set_bits(mfd
, reg
, value
);
535 case REGULATOR_MODE_STANDBY
:
536 return tps65910_clear_bits(mfd
, reg
, LDO_ST_ON_BIT
);
542 static unsigned int tps65910_get_mode(struct regulator_dev
*dev
)
544 struct tps65910_reg
*pmic
= rdev_get_drvdata(dev
);
545 int reg
, value
, id
= rdev_get_id(dev
);
547 reg
= pmic
->get_ctrl_reg(id
);
551 value
= tps65910_reg_read(pmic
, reg
);
555 if (!(value
& LDO_ST_ON_BIT
))
556 return REGULATOR_MODE_STANDBY
;
557 else if (value
& LDO_ST_MODE_BIT
)
558 return REGULATOR_MODE_IDLE
;
560 return REGULATOR_MODE_NORMAL
;
563 static int tps65910_get_voltage_dcdc_sel(struct regulator_dev
*dev
)
565 struct tps65910_reg
*pmic
= rdev_get_drvdata(dev
);
566 int id
= rdev_get_id(dev
);
567 int opvsel
= 0, srvsel
= 0, vselmax
= 0, mult
= 0, sr
= 0;
570 case TPS65910_REG_VDD1
:
571 opvsel
= tps65910_reg_read(pmic
, TPS65910_VDD1_OP
);
572 mult
= tps65910_reg_read(pmic
, TPS65910_VDD1
);
573 mult
= (mult
& VDD1_VGAIN_SEL_MASK
) >> VDD1_VGAIN_SEL_SHIFT
;
574 srvsel
= tps65910_reg_read(pmic
, TPS65910_VDD1_SR
);
575 sr
= opvsel
& VDD1_OP_CMD_MASK
;
576 opvsel
&= VDD1_OP_SEL_MASK
;
577 srvsel
&= VDD1_SR_SEL_MASK
;
580 case TPS65910_REG_VDD2
:
581 opvsel
= tps65910_reg_read(pmic
, TPS65910_VDD2_OP
);
582 mult
= tps65910_reg_read(pmic
, TPS65910_VDD2
);
583 mult
= (mult
& VDD2_VGAIN_SEL_MASK
) >> VDD2_VGAIN_SEL_SHIFT
;
584 srvsel
= tps65910_reg_read(pmic
, TPS65910_VDD2_SR
);
585 sr
= opvsel
& VDD2_OP_CMD_MASK
;
586 opvsel
&= VDD2_OP_SEL_MASK
;
587 srvsel
&= VDD2_SR_SEL_MASK
;
590 case TPS65911_REG_VDDCTRL
:
591 opvsel
= tps65910_reg_read(pmic
, TPS65911_VDDCTRL_OP
);
592 srvsel
= tps65910_reg_read(pmic
, TPS65911_VDDCTRL_SR
);
593 sr
= opvsel
& VDDCTRL_OP_CMD_MASK
;
594 opvsel
&= VDDCTRL_OP_SEL_MASK
;
595 srvsel
&= VDDCTRL_SR_SEL_MASK
;
600 /* multiplier 0 == 1 but 2,3 normal */
605 /* normalise to valid range */
608 if (srvsel
> vselmax
)
613 /* normalise to valid range*/
616 if (opvsel
> vselmax
)
623 static int tps65910_get_voltage(struct regulator_dev
*dev
)
625 struct tps65910_reg
*pmic
= rdev_get_drvdata(dev
);
626 int reg
, value
, id
= rdev_get_id(dev
), voltage
= 0;
628 reg
= pmic
->get_ctrl_reg(id
);
632 value
= tps65910_reg_read(pmic
, reg
);
637 case TPS65910_REG_VIO
:
638 case TPS65910_REG_VDIG1
:
639 case TPS65910_REG_VDIG2
:
640 case TPS65910_REG_VPLL
:
641 case TPS65910_REG_VDAC
:
642 case TPS65910_REG_VAUX1
:
643 case TPS65910_REG_VAUX2
:
644 case TPS65910_REG_VAUX33
:
645 case TPS65910_REG_VMMC
:
646 value
&= LDO_SEL_MASK
;
647 value
>>= LDO_SEL_SHIFT
;
653 voltage
= pmic
->info
[id
]->voltage_table
[value
] * 1000;
658 static int tps65910_get_voltage_vdd3(struct regulator_dev
*dev
)
660 return 5 * 1000 * 1000;
663 static int tps65911_get_voltage(struct regulator_dev
*dev
)
665 struct tps65910_reg
*pmic
= rdev_get_drvdata(dev
);
666 int step_mv
, id
= rdev_get_id(dev
);
669 reg
= pmic
->get_ctrl_reg(id
);
671 value
= tps65910_reg_read(pmic
, reg
);
674 case TPS65911_REG_LDO1
:
675 case TPS65911_REG_LDO2
:
676 case TPS65911_REG_LDO4
:
677 value
&= LDO1_SEL_MASK
;
678 value
>>= LDO_SEL_SHIFT
;
679 /* The first 5 values of the selector correspond to 1V */
687 case TPS65911_REG_LDO3
:
688 case TPS65911_REG_LDO5
:
689 case TPS65911_REG_LDO6
:
690 case TPS65911_REG_LDO7
:
691 case TPS65911_REG_LDO8
:
692 value
&= LDO3_SEL_MASK
;
693 value
>>= LDO_SEL_SHIFT
;
694 /* The first 3 values of the selector correspond to 1V */
702 case TPS65910_REG_VIO
:
703 value
&= LDO_SEL_MASK
;
704 value
>>= LDO_SEL_SHIFT
;
705 return pmic
->info
[id
]->voltage_table
[value
] * 1000;
710 return (LDO_MIN_VOLT
+ value
* step_mv
) * 1000;
713 static int tps65910_set_voltage_dcdc_sel(struct regulator_dev
*dev
,
716 struct tps65910_reg
*pmic
= rdev_get_drvdata(dev
);
717 int id
= rdev_get_id(dev
), vsel
;
721 case TPS65910_REG_VDD1
:
722 dcdc_mult
= (selector
/ VDD1_2_NUM_VOLT_FINE
) + 1;
725 vsel
= (selector
% VDD1_2_NUM_VOLT_FINE
) + 3;
727 tps65910_modify_bits(pmic
, TPS65910_VDD1
,
728 (dcdc_mult
<< VDD1_VGAIN_SEL_SHIFT
),
729 VDD1_VGAIN_SEL_MASK
);
730 tps65910_reg_write(pmic
, TPS65910_VDD1_OP
, vsel
);
732 case TPS65910_REG_VDD2
:
733 dcdc_mult
= (selector
/ VDD1_2_NUM_VOLT_FINE
) + 1;
736 vsel
= (selector
% VDD1_2_NUM_VOLT_FINE
) + 3;
738 tps65910_modify_bits(pmic
, TPS65910_VDD2
,
739 (dcdc_mult
<< VDD2_VGAIN_SEL_SHIFT
),
740 VDD1_VGAIN_SEL_MASK
);
741 tps65910_reg_write(pmic
, TPS65910_VDD2_OP
, vsel
);
743 case TPS65911_REG_VDDCTRL
:
745 tps65910_reg_write(pmic
, TPS65911_VDDCTRL_OP
, vsel
);
751 static int tps65910_set_voltage_sel(struct regulator_dev
*dev
,
754 struct tps65910_reg
*pmic
= rdev_get_drvdata(dev
);
755 int reg
, id
= rdev_get_id(dev
);
757 reg
= pmic
->get_ctrl_reg(id
);
762 case TPS65910_REG_VIO
:
763 case TPS65910_REG_VDIG1
:
764 case TPS65910_REG_VDIG2
:
765 case TPS65910_REG_VPLL
:
766 case TPS65910_REG_VDAC
:
767 case TPS65910_REG_VAUX1
:
768 case TPS65910_REG_VAUX2
:
769 case TPS65910_REG_VAUX33
:
770 case TPS65910_REG_VMMC
:
771 return tps65910_modify_bits(pmic
, reg
,
772 (selector
<< LDO_SEL_SHIFT
), LDO_SEL_MASK
);
778 static int tps65911_set_voltage_sel(struct regulator_dev
*dev
,
781 struct tps65910_reg
*pmic
= rdev_get_drvdata(dev
);
782 int reg
, id
= rdev_get_id(dev
);
784 reg
= pmic
->get_ctrl_reg(id
);
789 case TPS65911_REG_LDO1
:
790 case TPS65911_REG_LDO2
:
791 case TPS65911_REG_LDO4
:
792 return tps65910_modify_bits(pmic
, reg
,
793 (selector
<< LDO_SEL_SHIFT
), LDO1_SEL_MASK
);
794 case TPS65911_REG_LDO3
:
795 case TPS65911_REG_LDO5
:
796 case TPS65911_REG_LDO6
:
797 case TPS65911_REG_LDO7
:
798 case TPS65911_REG_LDO8
:
799 return tps65910_modify_bits(pmic
, reg
,
800 (selector
<< LDO_SEL_SHIFT
), LDO3_SEL_MASK
);
801 case TPS65910_REG_VIO
:
802 return tps65910_modify_bits(pmic
, reg
,
803 (selector
<< LDO_SEL_SHIFT
), LDO_SEL_MASK
);
810 static int tps65910_list_voltage_dcdc(struct regulator_dev
*dev
,
813 int volt
, mult
= 1, id
= rdev_get_id(dev
);
816 case TPS65910_REG_VDD1
:
817 case TPS65910_REG_VDD2
:
818 mult
= (selector
/ VDD1_2_NUM_VOLT_FINE
) + 1;
819 volt
= VDD1_2_MIN_VOLT
+
820 (selector
% VDD1_2_NUM_VOLT_FINE
) * VDD1_2_OFFSET
;
822 case TPS65911_REG_VDDCTRL
:
823 volt
= VDDCTRL_MIN_VOLT
+ (selector
* VDDCTRL_OFFSET
);
830 return volt
* 100 * mult
;
833 static int tps65910_list_voltage(struct regulator_dev
*dev
,
836 struct tps65910_reg
*pmic
= rdev_get_drvdata(dev
);
837 int id
= rdev_get_id(dev
), voltage
;
839 if (id
< TPS65910_REG_VIO
|| id
> TPS65910_REG_VMMC
)
842 if (selector
>= pmic
->info
[id
]->n_voltages
)
845 voltage
= pmic
->info
[id
]->voltage_table
[selector
] * 1000;
850 static int tps65911_list_voltage(struct regulator_dev
*dev
, unsigned selector
)
852 struct tps65910_reg
*pmic
= rdev_get_drvdata(dev
);
853 int step_mv
= 0, id
= rdev_get_id(dev
);
856 case TPS65911_REG_LDO1
:
857 case TPS65911_REG_LDO2
:
858 case TPS65911_REG_LDO4
:
859 /* The first 5 values of the selector correspond to 1V */
867 case TPS65911_REG_LDO3
:
868 case TPS65911_REG_LDO5
:
869 case TPS65911_REG_LDO6
:
870 case TPS65911_REG_LDO7
:
871 case TPS65911_REG_LDO8
:
872 /* The first 3 values of the selector correspond to 1V */
880 case TPS65910_REG_VIO
:
881 return pmic
->info
[id
]->voltage_table
[selector
] * 1000;
886 return (LDO_MIN_VOLT
+ selector
* step_mv
) * 1000;
889 static int tps65910_set_voltage_dcdc_time_sel(struct regulator_dev
*dev
,
890 unsigned int old_selector
, unsigned int new_selector
)
892 int id
= rdev_get_id(dev
);
893 int old_volt
, new_volt
;
895 old_volt
= tps65910_list_voltage_dcdc(dev
, old_selector
);
899 new_volt
= tps65910_list_voltage_dcdc(dev
, new_selector
);
903 /* VDD1 and VDD2 are 12.5mV/us, VDDCTRL is 100mV/20us */
905 case TPS65910_REG_VDD1
:
906 case TPS65910_REG_VDD2
:
907 return DIV_ROUND_UP(abs(old_volt
- new_volt
), 12500);
908 case TPS65911_REG_VDDCTRL
:
909 return DIV_ROUND_UP(abs(old_volt
- new_volt
), 5000);
914 /* Regulator ops (except VRTC) */
915 static struct regulator_ops tps65910_ops_dcdc
= {
916 .is_enabled
= tps65910_is_enabled
,
917 .enable
= tps65910_enable
,
918 .disable
= tps65910_disable
,
919 .enable_time
= tps65910_enable_time
,
920 .set_mode
= tps65910_set_mode
,
921 .get_mode
= tps65910_get_mode
,
922 .get_voltage_sel
= tps65910_get_voltage_dcdc_sel
,
923 .set_voltage_sel
= tps65910_set_voltage_dcdc_sel
,
924 .set_voltage_time_sel
= tps65910_set_voltage_dcdc_time_sel
,
925 .list_voltage
= tps65910_list_voltage_dcdc
,
928 static struct regulator_ops tps65910_ops_vdd3
= {
929 .is_enabled
= tps65910_is_enabled
,
930 .enable
= tps65910_enable
,
931 .disable
= tps65910_disable
,
932 .enable_time
= tps65910_enable_time
,
933 .set_mode
= tps65910_set_mode
,
934 .get_mode
= tps65910_get_mode
,
935 .get_voltage
= tps65910_get_voltage_vdd3
,
936 .list_voltage
= tps65910_list_voltage
,
939 static struct regulator_ops tps65910_ops
= {
940 .is_enabled
= tps65910_is_enabled
,
941 .enable
= tps65910_enable
,
942 .disable
= tps65910_disable
,
943 .enable_time
= tps65910_enable_time
,
944 .set_mode
= tps65910_set_mode
,
945 .get_mode
= tps65910_get_mode
,
946 .get_voltage
= tps65910_get_voltage
,
947 .set_voltage_sel
= tps65910_set_voltage_sel
,
948 .list_voltage
= tps65910_list_voltage
,
951 static struct regulator_ops tps65911_ops
= {
952 .is_enabled
= tps65910_is_enabled
,
953 .enable
= tps65910_enable
,
954 .disable
= tps65910_disable
,
955 .enable_time
= tps65910_enable_time
,
956 .set_mode
= tps65910_set_mode
,
957 .get_mode
= tps65910_get_mode
,
958 .get_voltage
= tps65911_get_voltage
,
959 .set_voltage_sel
= tps65911_set_voltage_sel
,
960 .list_voltage
= tps65911_list_voltage
,
963 static int tps65910_set_ext_sleep_config(struct tps65910_reg
*pmic
,
964 int id
, int ext_sleep_config
)
966 struct tps65910
*mfd
= pmic
->mfd
;
967 u8 regoffs
= (pmic
->ext_sleep_control
[id
] >> 8) & 0xFF;
968 u8 bit_pos
= (1 << pmic
->ext_sleep_control
[id
] & 0xFF);
972 * Regulator can not be control from multiple external input EN1, EN2
975 if (ext_sleep_config
& EXT_SLEEP_CONTROL
) {
977 en_count
= ((ext_sleep_config
&
978 TPS65910_SLEEP_CONTROL_EXT_INPUT_EN1
) != 0);
979 en_count
+= ((ext_sleep_config
&
980 TPS65910_SLEEP_CONTROL_EXT_INPUT_EN2
) != 0);
981 en_count
+= ((ext_sleep_config
&
982 TPS65910_SLEEP_CONTROL_EXT_INPUT_EN3
) != 0);
983 en_count
+= ((ext_sleep_config
&
984 TPS65911_SLEEP_CONTROL_EXT_INPUT_SLEEP
) != 0);
987 "External sleep control flag is not proper\n");
992 pmic
->board_ext_control
[id
] = ext_sleep_config
;
994 /* External EN1 control */
995 if (ext_sleep_config
& TPS65910_SLEEP_CONTROL_EXT_INPUT_EN1
)
996 ret
= tps65910_set_bits(mfd
,
997 TPS65910_EN1_LDO_ASS
+ regoffs
, bit_pos
);
999 ret
= tps65910_clear_bits(mfd
,
1000 TPS65910_EN1_LDO_ASS
+ regoffs
, bit_pos
);
1003 "Error in configuring external control EN1\n");
1007 /* External EN2 control */
1008 if (ext_sleep_config
& TPS65910_SLEEP_CONTROL_EXT_INPUT_EN2
)
1009 ret
= tps65910_set_bits(mfd
,
1010 TPS65910_EN2_LDO_ASS
+ regoffs
, bit_pos
);
1012 ret
= tps65910_clear_bits(mfd
,
1013 TPS65910_EN2_LDO_ASS
+ regoffs
, bit_pos
);
1016 "Error in configuring external control EN2\n");
1020 /* External EN3 control for TPS65910 LDO only */
1021 if ((tps65910_chip_id(mfd
) == TPS65910
) &&
1022 (id
>= TPS65910_REG_VDIG1
)) {
1023 if (ext_sleep_config
& TPS65910_SLEEP_CONTROL_EXT_INPUT_EN3
)
1024 ret
= tps65910_set_bits(mfd
,
1025 TPS65910_EN3_LDO_ASS
+ regoffs
, bit_pos
);
1027 ret
= tps65910_clear_bits(mfd
,
1028 TPS65910_EN3_LDO_ASS
+ regoffs
, bit_pos
);
1031 "Error in configuring external control EN3\n");
1036 /* Return if no external control is selected */
1037 if (!(ext_sleep_config
& EXT_SLEEP_CONTROL
)) {
1038 /* Clear all sleep controls */
1039 ret
= tps65910_clear_bits(mfd
,
1040 TPS65910_SLEEP_KEEP_LDO_ON
+ regoffs
, bit_pos
);
1042 ret
= tps65910_clear_bits(mfd
,
1043 TPS65910_SLEEP_SET_LDO_OFF
+ regoffs
, bit_pos
);
1046 "Error in configuring SLEEP register\n");
1051 * For regulator that has separate operational and sleep register make
1052 * sure that operational is used and clear sleep register to turn
1053 * regulator off when external control is inactive
1055 if ((id
== TPS65910_REG_VDD1
) ||
1056 (id
== TPS65910_REG_VDD2
) ||
1057 ((id
== TPS65911_REG_VDDCTRL
) &&
1058 (tps65910_chip_id(mfd
) == TPS65911
))) {
1059 int op_reg_add
= pmic
->get_ctrl_reg(id
) + 1;
1060 int sr_reg_add
= pmic
->get_ctrl_reg(id
) + 2;
1061 int opvsel
= tps65910_reg_read(pmic
, op_reg_add
);
1062 int srvsel
= tps65910_reg_read(pmic
, sr_reg_add
);
1063 if (opvsel
& VDD1_OP_CMD_MASK
) {
1064 u8 reg_val
= srvsel
& VDD1_OP_SEL_MASK
;
1065 ret
= tps65910_reg_write(pmic
, op_reg_add
, reg_val
);
1068 "Error in configuring op register\n");
1072 ret
= tps65910_reg_write(pmic
, sr_reg_add
, 0);
1074 dev_err(mfd
->dev
, "Error in settting sr register\n");
1079 ret
= tps65910_clear_bits(mfd
,
1080 TPS65910_SLEEP_KEEP_LDO_ON
+ regoffs
, bit_pos
);
1082 if (ext_sleep_config
& TPS65911_SLEEP_CONTROL_EXT_INPUT_SLEEP
)
1083 ret
= tps65910_set_bits(mfd
,
1084 TPS65910_SLEEP_SET_LDO_OFF
+ regoffs
, bit_pos
);
1086 ret
= tps65910_clear_bits(mfd
,
1087 TPS65910_SLEEP_SET_LDO_OFF
+ regoffs
, bit_pos
);
1091 "Error in configuring SLEEP register\n");
1096 static __devinit
int tps65910_probe(struct platform_device
*pdev
)
1098 struct tps65910
*tps65910
= dev_get_drvdata(pdev
->dev
.parent
);
1099 struct regulator_config config
= { };
1100 struct tps_info
*info
;
1101 struct regulator_init_data
*reg_data
;
1102 struct regulator_dev
*rdev
;
1103 struct tps65910_reg
*pmic
;
1104 struct tps65910_board
*pmic_plat_data
;
1107 pmic_plat_data
= dev_get_platdata(tps65910
->dev
);
1108 if (!pmic_plat_data
)
1111 pmic
= devm_kzalloc(&pdev
->dev
, sizeof(*pmic
), GFP_KERNEL
);
1115 mutex_init(&pmic
->mutex
);
1116 pmic
->mfd
= tps65910
;
1117 platform_set_drvdata(pdev
, pmic
);
1119 /* Give control of all register to control port */
1120 tps65910_set_bits(pmic
->mfd
, TPS65910_DEVCTRL
,
1121 DEVCTRL_SR_CTL_I2C_SEL_MASK
);
1123 switch(tps65910_chip_id(tps65910
)) {
1125 pmic
->get_ctrl_reg
= &tps65910_get_ctrl_register
;
1126 pmic
->num_regulators
= ARRAY_SIZE(tps65910_regs
);
1127 pmic
->ext_sleep_control
= tps65910_ext_sleep_control
;
1128 info
= tps65910_regs
;
1131 pmic
->get_ctrl_reg
= &tps65911_get_ctrl_register
;
1132 pmic
->num_regulators
= ARRAY_SIZE(tps65911_regs
);
1133 pmic
->ext_sleep_control
= tps65911_ext_sleep_control
;
1134 info
= tps65911_regs
;
1137 pr_err("Invalid tps chip version\n");
1141 pmic
->desc
= kcalloc(pmic
->num_regulators
,
1142 sizeof(struct regulator_desc
), GFP_KERNEL
);
1148 pmic
->info
= kcalloc(pmic
->num_regulators
,
1149 sizeof(struct tps_info
*), GFP_KERNEL
);
1155 pmic
->rdev
= kcalloc(pmic
->num_regulators
,
1156 sizeof(struct regulator_dev
*), GFP_KERNEL
);
1162 for (i
= 0; i
< pmic
->num_regulators
&& i
< TPS65910_NUM_REGS
;
1165 reg_data
= pmic_plat_data
->tps65910_pmic_init_data
[i
];
1167 /* Regulator API handles empty constraints but not NULL
1172 /* Register the regulators */
1173 pmic
->info
[i
] = info
;
1175 pmic
->desc
[i
].name
= info
->name
;
1176 pmic
->desc
[i
].id
= i
;
1177 pmic
->desc
[i
].n_voltages
= info
->n_voltages
;
1179 if (i
== TPS65910_REG_VDD1
|| i
== TPS65910_REG_VDD2
) {
1180 pmic
->desc
[i
].ops
= &tps65910_ops_dcdc
;
1181 pmic
->desc
[i
].n_voltages
= VDD1_2_NUM_VOLT_FINE
*
1182 VDD1_2_NUM_VOLT_COARSE
;
1183 } else if (i
== TPS65910_REG_VDD3
) {
1184 if (tps65910_chip_id(tps65910
) == TPS65910
)
1185 pmic
->desc
[i
].ops
= &tps65910_ops_vdd3
;
1187 pmic
->desc
[i
].ops
= &tps65910_ops_dcdc
;
1189 if (tps65910_chip_id(tps65910
) == TPS65910
)
1190 pmic
->desc
[i
].ops
= &tps65910_ops
;
1192 pmic
->desc
[i
].ops
= &tps65911_ops
;
1195 err
= tps65910_set_ext_sleep_config(pmic
, i
,
1196 pmic_plat_data
->regulator_ext_sleep_control
[i
]);
1198 * Failing on regulator for configuring externally control
1199 * is not a serious issue, just throw warning.
1202 dev_warn(tps65910
->dev
,
1203 "Failed to initialise ext control config\n");
1205 pmic
->desc
[i
].type
= REGULATOR_VOLTAGE
;
1206 pmic
->desc
[i
].owner
= THIS_MODULE
;
1208 config
.dev
= tps65910
->dev
;
1209 config
.init_data
= reg_data
;
1210 config
.driver_data
= pmic
;
1212 rdev
= regulator_register(&pmic
->desc
[i
], &config
);
1214 dev_err(tps65910
->dev
,
1215 "failed to register %s regulator\n",
1217 err
= PTR_ERR(rdev
);
1218 goto err_unregister_regulator
;
1221 /* Save regulator for cleanup */
1222 pmic
->rdev
[i
] = rdev
;
1226 err_unregister_regulator
:
1228 regulator_unregister(pmic
->rdev
[i
]);
1238 static int __devexit
tps65910_remove(struct platform_device
*pdev
)
1240 struct tps65910_reg
*pmic
= platform_get_drvdata(pdev
);
1243 for (i
= 0; i
< pmic
->num_regulators
; i
++)
1244 regulator_unregister(pmic
->rdev
[i
]);
1252 static void tps65910_shutdown(struct platform_device
*pdev
)
1254 struct tps65910_reg
*pmic
= platform_get_drvdata(pdev
);
1258 * Before bootloader jumps to kernel, it makes sure that required
1259 * external control signals are in desired state so that given rails
1260 * can be configure accordingly.
1261 * If rails are configured to be controlled from external control
1262 * then before shutting down/rebooting the system, the external
1263 * control configuration need to be remove from the rails so that
1264 * its output will be available as per register programming even
1265 * if external controls are removed. This is require when the POR
1266 * value of the control signals are not in active state and before
1267 * bootloader initializes it, the system requires the rail output
1268 * to be active for booting.
1270 for (i
= 0; i
< pmic
->num_regulators
; i
++) {
1275 err
= tps65910_set_ext_sleep_config(pmic
, i
, 0);
1278 "Error in clearing external control\n");
1282 static struct platform_driver tps65910_driver
= {
1284 .name
= "tps65910-pmic",
1285 .owner
= THIS_MODULE
,
1287 .probe
= tps65910_probe
,
1288 .remove
= __devexit_p(tps65910_remove
),
1289 .shutdown
= tps65910_shutdown
,
1292 static int __init
tps65910_init(void)
1294 return platform_driver_register(&tps65910_driver
);
1296 subsys_initcall(tps65910_init
);
1298 static void __exit
tps65910_cleanup(void)
1300 platform_driver_unregister(&tps65910_driver
);
1302 module_exit(tps65910_cleanup
);
1304 MODULE_AUTHOR("Graeme Gregory <gg@slimlogic.co.uk>");
1305 MODULE_DESCRIPTION("TPS65910/TPS65911 voltage regulator driver");
1306 MODULE_LICENSE("GPL v2");
1307 MODULE_ALIAS("platform:tps65910-pmic");