2 * Driver for Regulator part of Palmas PMIC Chips
4 * Copyright 2011-2013 Texas Instruments Inc.
6 * Author: Graeme Gregory <gg@slimlogic.co.uk>
7 * Author: Ian Lartey <ian@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/regmap.h>
25 #include <linux/mfd/palmas.h>
27 #include <linux/of_platform.h>
28 #include <linux/regulator/of_regulator.h>
38 static const struct regs_info palmas_regs_info
[] = {
42 .vsel_addr
= PALMAS_SMPS12_VOLTAGE
,
43 .ctrl_addr
= PALMAS_SMPS12_CTRL
,
44 .tstep_addr
= PALMAS_SMPS12_TSTEP
,
49 .vsel_addr
= PALMAS_SMPS12_VOLTAGE
,
50 .ctrl_addr
= PALMAS_SMPS12_CTRL
,
51 .tstep_addr
= PALMAS_SMPS12_TSTEP
,
56 .vsel_addr
= PALMAS_SMPS3_VOLTAGE
,
57 .ctrl_addr
= PALMAS_SMPS3_CTRL
,
62 .vsel_addr
= PALMAS_SMPS45_VOLTAGE
,
63 .ctrl_addr
= PALMAS_SMPS45_CTRL
,
64 .tstep_addr
= PALMAS_SMPS45_TSTEP
,
69 .vsel_addr
= PALMAS_SMPS45_VOLTAGE
,
70 .ctrl_addr
= PALMAS_SMPS45_CTRL
,
71 .tstep_addr
= PALMAS_SMPS45_TSTEP
,
76 .vsel_addr
= PALMAS_SMPS6_VOLTAGE
,
77 .ctrl_addr
= PALMAS_SMPS6_CTRL
,
78 .tstep_addr
= PALMAS_SMPS6_TSTEP
,
83 .vsel_addr
= PALMAS_SMPS7_VOLTAGE
,
84 .ctrl_addr
= PALMAS_SMPS7_CTRL
,
89 .vsel_addr
= PALMAS_SMPS8_VOLTAGE
,
90 .ctrl_addr
= PALMAS_SMPS8_CTRL
,
91 .tstep_addr
= PALMAS_SMPS8_TSTEP
,
96 .vsel_addr
= PALMAS_SMPS9_VOLTAGE
,
97 .ctrl_addr
= PALMAS_SMPS9_CTRL
,
101 .sname
= "smps10-in",
102 .ctrl_addr
= PALMAS_SMPS10_CTRL
,
107 .vsel_addr
= PALMAS_LDO1_VOLTAGE
,
108 .ctrl_addr
= PALMAS_LDO1_CTRL
,
113 .vsel_addr
= PALMAS_LDO2_VOLTAGE
,
114 .ctrl_addr
= PALMAS_LDO2_CTRL
,
119 .vsel_addr
= PALMAS_LDO3_VOLTAGE
,
120 .ctrl_addr
= PALMAS_LDO3_CTRL
,
125 .vsel_addr
= PALMAS_LDO4_VOLTAGE
,
126 .ctrl_addr
= PALMAS_LDO4_CTRL
,
131 .vsel_addr
= PALMAS_LDO5_VOLTAGE
,
132 .ctrl_addr
= PALMAS_LDO5_CTRL
,
137 .vsel_addr
= PALMAS_LDO6_VOLTAGE
,
138 .ctrl_addr
= PALMAS_LDO6_CTRL
,
143 .vsel_addr
= PALMAS_LDO7_VOLTAGE
,
144 .ctrl_addr
= PALMAS_LDO7_CTRL
,
149 .vsel_addr
= PALMAS_LDO8_VOLTAGE
,
150 .ctrl_addr
= PALMAS_LDO8_CTRL
,
155 .vsel_addr
= PALMAS_LDO9_VOLTAGE
,
156 .ctrl_addr
= PALMAS_LDO9_CTRL
,
161 .vsel_addr
= PALMAS_LDOLN_VOLTAGE
,
162 .ctrl_addr
= PALMAS_LDOLN_CTRL
,
166 .sname
= "ldousb-in",
167 .vsel_addr
= PALMAS_LDOUSB_VOLTAGE
,
168 .ctrl_addr
= PALMAS_LDOUSB_CTRL
,
172 .ctrl_addr
= PALMAS_REGEN1_CTRL
,
176 .ctrl_addr
= PALMAS_REGEN2_CTRL
,
180 .ctrl_addr
= PALMAS_REGEN3_CTRL
,
184 .ctrl_addr
= PALMAS_SYSEN1_CTRL
,
188 .ctrl_addr
= PALMAS_SYSEN2_CTRL
,
192 static unsigned int palmas_smps_ramp_delay
[4] = {0, 10000, 5000, 2500};
194 #define SMPS_CTRL_MODE_OFF 0x00
195 #define SMPS_CTRL_MODE_ON 0x01
196 #define SMPS_CTRL_MODE_ECO 0x02
197 #define SMPS_CTRL_MODE_PWM 0x03
199 /* These values are derived from the data sheet. And are the number of steps
200 * where there is a voltage change, the ranges at beginning and end of register
201 * max/min values where there are no change are ommitted.
203 * So they are basically (maxV-minV)/stepV
205 #define PALMAS_SMPS_NUM_VOLTAGES 117
206 #define PALMAS_SMPS10_NUM_VOLTAGES 2
207 #define PALMAS_LDO_NUM_VOLTAGES 50
209 #define SMPS10_VSEL (1<<3)
210 #define SMPS10_BOOST_EN (1<<2)
211 #define SMPS10_BYPASS_EN (1<<1)
212 #define SMPS10_SWITCH_EN (1<<0)
214 #define REGULATOR_SLAVE 0
216 static int palmas_smps_read(struct palmas
*palmas
, unsigned int reg
,
221 addr
= PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE
, reg
);
223 return regmap_read(palmas
->regmap
[REGULATOR_SLAVE
], addr
, dest
);
226 static int palmas_smps_write(struct palmas
*palmas
, unsigned int reg
,
231 addr
= PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE
, reg
);
233 return regmap_write(palmas
->regmap
[REGULATOR_SLAVE
], addr
, value
);
236 static int palmas_ldo_read(struct palmas
*palmas
, unsigned int reg
,
241 addr
= PALMAS_BASE_TO_REG(PALMAS_LDO_BASE
, reg
);
243 return regmap_read(palmas
->regmap
[REGULATOR_SLAVE
], addr
, dest
);
246 static int palmas_ldo_write(struct palmas
*palmas
, unsigned int reg
,
251 addr
= PALMAS_BASE_TO_REG(PALMAS_LDO_BASE
, reg
);
253 return regmap_write(palmas
->regmap
[REGULATOR_SLAVE
], addr
, value
);
256 static int palmas_is_enabled_smps(struct regulator_dev
*dev
)
258 struct palmas_pmic
*pmic
= rdev_get_drvdata(dev
);
259 int id
= rdev_get_id(dev
);
262 palmas_smps_read(pmic
->palmas
, palmas_regs_info
[id
].ctrl_addr
, ®
);
264 reg
&= PALMAS_SMPS12_CTRL_STATUS_MASK
;
265 reg
>>= PALMAS_SMPS12_CTRL_STATUS_SHIFT
;
270 static int palmas_enable_smps(struct regulator_dev
*dev
)
272 struct palmas_pmic
*pmic
= rdev_get_drvdata(dev
);
273 int id
= rdev_get_id(dev
);
276 palmas_smps_read(pmic
->palmas
, palmas_regs_info
[id
].ctrl_addr
, ®
);
278 reg
&= ~PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK
;
279 if (pmic
->current_reg_mode
[id
])
280 reg
|= pmic
->current_reg_mode
[id
];
282 reg
|= SMPS_CTRL_MODE_ON
;
284 palmas_smps_write(pmic
->palmas
, palmas_regs_info
[id
].ctrl_addr
, reg
);
289 static int palmas_disable_smps(struct regulator_dev
*dev
)
291 struct palmas_pmic
*pmic
= rdev_get_drvdata(dev
);
292 int id
= rdev_get_id(dev
);
295 palmas_smps_read(pmic
->palmas
, palmas_regs_info
[id
].ctrl_addr
, ®
);
297 reg
&= ~PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK
;
299 palmas_smps_write(pmic
->palmas
, palmas_regs_info
[id
].ctrl_addr
, reg
);
304 static int palmas_set_mode_smps(struct regulator_dev
*dev
, unsigned int mode
)
306 struct palmas_pmic
*pmic
= rdev_get_drvdata(dev
);
307 int id
= rdev_get_id(dev
);
309 bool rail_enable
= true;
311 palmas_smps_read(pmic
->palmas
, palmas_regs_info
[id
].ctrl_addr
, ®
);
312 reg
&= ~PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK
;
314 if (reg
== SMPS_CTRL_MODE_OFF
)
318 case REGULATOR_MODE_NORMAL
:
319 reg
|= SMPS_CTRL_MODE_ON
;
321 case REGULATOR_MODE_IDLE
:
322 reg
|= SMPS_CTRL_MODE_ECO
;
324 case REGULATOR_MODE_FAST
:
325 reg
|= SMPS_CTRL_MODE_PWM
;
331 pmic
->current_reg_mode
[id
] = reg
& PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK
;
333 palmas_smps_write(pmic
->palmas
,
334 palmas_regs_info
[id
].ctrl_addr
, reg
);
338 static unsigned int palmas_get_mode_smps(struct regulator_dev
*dev
)
340 struct palmas_pmic
*pmic
= rdev_get_drvdata(dev
);
341 int id
= rdev_get_id(dev
);
344 reg
= pmic
->current_reg_mode
[id
] & PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK
;
347 case SMPS_CTRL_MODE_ON
:
348 return REGULATOR_MODE_NORMAL
;
349 case SMPS_CTRL_MODE_ECO
:
350 return REGULATOR_MODE_IDLE
;
351 case SMPS_CTRL_MODE_PWM
:
352 return REGULATOR_MODE_FAST
;
358 static int palmas_list_voltage_smps(struct regulator_dev
*dev
,
361 struct palmas_pmic
*pmic
= rdev_get_drvdata(dev
);
362 int id
= rdev_get_id(dev
);
365 /* Read the multiplier set in VSEL register to return
366 * the correct voltage.
373 else if (selector
< 6)
374 return 500000 * mult
;
376 /* Voltage is linear mapping starting from selector 6,
377 * volt = (0.49V + ((selector - 5) * 0.01V)) * RANGE
378 * RANGE is either x1 or x2
380 return (490000 + ((selector
- 5) * 10000)) * mult
;
383 static int palmas_map_voltage_smps(struct regulator_dev
*rdev
,
384 int min_uV
, int max_uV
)
386 struct palmas_pmic
*pmic
= rdev_get_drvdata(rdev
);
387 int id
= rdev_get_id(rdev
);
393 if (pmic
->range
[id
]) { /* RANGE is x2 */
394 if (min_uV
< 1000000)
396 ret
= DIV_ROUND_UP(min_uV
- 1000000, 20000) + 6;
397 } else { /* RANGE is x1 */
400 ret
= DIV_ROUND_UP(min_uV
- 500000, 10000) + 6;
403 /* Map back into a voltage to verify we're still in bounds */
404 voltage
= palmas_list_voltage_smps(rdev
, ret
);
405 if (voltage
< min_uV
|| voltage
> max_uV
)
411 static int palma_smps_set_voltage_smps_time_sel(struct regulator_dev
*rdev
,
412 unsigned int old_selector
, unsigned int new_selector
)
414 struct palmas_pmic
*pmic
= rdev_get_drvdata(rdev
);
415 int id
= rdev_get_id(rdev
);
417 unsigned int ramp_delay
= pmic
->ramp_delay
[id
];
422 old_uv
= palmas_list_voltage_smps(rdev
, old_selector
);
426 new_uv
= palmas_list_voltage_smps(rdev
, new_selector
);
430 return DIV_ROUND_UP(abs(old_uv
- new_uv
), ramp_delay
);
433 static int palmas_smps_set_ramp_delay(struct regulator_dev
*rdev
,
436 struct palmas_pmic
*pmic
= rdev_get_drvdata(rdev
);
437 int id
= rdev_get_id(rdev
);
438 unsigned int reg
= 0;
439 unsigned int addr
= palmas_regs_info
[id
].tstep_addr
;
442 /* SMPS3 and SMPS7 do not have tstep_addr setting */
444 case PALMAS_REG_SMPS3
:
445 case PALMAS_REG_SMPS7
:
451 else if (ramp_delay
<= 2500)
453 else if (ramp_delay
<= 5000)
458 ret
= palmas_smps_write(pmic
->palmas
, addr
, reg
);
460 dev_err(pmic
->palmas
->dev
, "TSTEP write failed: %d\n", ret
);
464 pmic
->ramp_delay
[id
] = palmas_smps_ramp_delay
[reg
];
468 static struct regulator_ops palmas_ops_smps
= {
469 .is_enabled
= palmas_is_enabled_smps
,
470 .enable
= palmas_enable_smps
,
471 .disable
= palmas_disable_smps
,
472 .set_mode
= palmas_set_mode_smps
,
473 .get_mode
= palmas_get_mode_smps
,
474 .get_voltage_sel
= regulator_get_voltage_sel_regmap
,
475 .set_voltage_sel
= regulator_set_voltage_sel_regmap
,
476 .list_voltage
= palmas_list_voltage_smps
,
477 .map_voltage
= palmas_map_voltage_smps
,
478 .set_voltage_time_sel
= palma_smps_set_voltage_smps_time_sel
,
479 .set_ramp_delay
= palmas_smps_set_ramp_delay
,
482 static struct regulator_ops palmas_ops_smps10
= {
483 .is_enabled
= regulator_is_enabled_regmap
,
484 .enable
= regulator_enable_regmap
,
485 .disable
= regulator_disable_regmap
,
486 .get_voltage_sel
= regulator_get_voltage_sel_regmap
,
487 .set_voltage_sel
= regulator_set_voltage_sel_regmap
,
488 .list_voltage
= regulator_list_voltage_linear
,
489 .map_voltage
= regulator_map_voltage_linear
,
492 static int palmas_is_enabled_ldo(struct regulator_dev
*dev
)
494 struct palmas_pmic
*pmic
= rdev_get_drvdata(dev
);
495 int id
= rdev_get_id(dev
);
498 palmas_ldo_read(pmic
->palmas
, palmas_regs_info
[id
].ctrl_addr
, ®
);
500 reg
&= PALMAS_LDO1_CTRL_STATUS
;
505 static struct regulator_ops palmas_ops_ldo
= {
506 .is_enabled
= palmas_is_enabled_ldo
,
507 .enable
= regulator_enable_regmap
,
508 .disable
= regulator_disable_regmap
,
509 .get_voltage_sel
= regulator_get_voltage_sel_regmap
,
510 .set_voltage_sel
= regulator_set_voltage_sel_regmap
,
511 .list_voltage
= regulator_list_voltage_linear
,
512 .map_voltage
= regulator_map_voltage_linear
,
515 static struct regulator_ops palmas_ops_extreg
= {
516 .is_enabled
= regulator_is_enabled_regmap
,
517 .enable
= regulator_enable_regmap
,
518 .disable
= regulator_disable_regmap
,
522 * setup the hardware based sleep configuration of the SMPS/LDO regulators
523 * from the platform data. This is different to the software based control
524 * supported by the regulator framework as it is controlled by toggling
525 * pins on the PMIC such as PREQ, SYSEN, ...
527 static int palmas_smps_init(struct palmas
*palmas
, int id
,
528 struct palmas_reg_init
*reg_init
)
534 addr
= palmas_regs_info
[id
].ctrl_addr
;
536 ret
= palmas_smps_read(palmas
, addr
, ®
);
541 case PALMAS_REG_SMPS10
:
542 reg
&= ~PALMAS_SMPS10_CTRL_MODE_SLEEP_MASK
;
543 if (reg_init
->mode_sleep
)
544 reg
|= reg_init
->mode_sleep
<<
545 PALMAS_SMPS10_CTRL_MODE_SLEEP_SHIFT
;
548 if (reg_init
->warm_reset
)
549 reg
|= PALMAS_SMPS12_CTRL_WR_S
;
551 reg
&= ~PALMAS_SMPS12_CTRL_WR_S
;
553 if (reg_init
->roof_floor
)
554 reg
|= PALMAS_SMPS12_CTRL_ROOF_FLOOR_EN
;
556 reg
&= ~PALMAS_SMPS12_CTRL_ROOF_FLOOR_EN
;
558 reg
&= ~PALMAS_SMPS12_CTRL_MODE_SLEEP_MASK
;
559 if (reg_init
->mode_sleep
)
560 reg
|= reg_init
->mode_sleep
<<
561 PALMAS_SMPS12_CTRL_MODE_SLEEP_SHIFT
;
564 ret
= palmas_smps_write(palmas
, addr
, reg
);
568 if (palmas_regs_info
[id
].vsel_addr
&& reg_init
->vsel
) {
569 addr
= palmas_regs_info
[id
].vsel_addr
;
571 reg
= reg_init
->vsel
;
573 ret
= palmas_smps_write(palmas
, addr
, reg
);
582 static int palmas_ldo_init(struct palmas
*palmas
, int id
,
583 struct palmas_reg_init
*reg_init
)
589 addr
= palmas_regs_info
[id
].ctrl_addr
;
591 ret
= palmas_ldo_read(palmas
, addr
, ®
);
595 if (reg_init
->warm_reset
)
596 reg
|= PALMAS_LDO1_CTRL_WR_S
;
598 reg
&= ~PALMAS_LDO1_CTRL_WR_S
;
600 if (reg_init
->mode_sleep
)
601 reg
|= PALMAS_LDO1_CTRL_MODE_SLEEP
;
603 reg
&= ~PALMAS_LDO1_CTRL_MODE_SLEEP
;
605 ret
= palmas_ldo_write(palmas
, addr
, reg
);
612 static int palmas_extreg_init(struct palmas
*palmas
, int id
,
613 struct palmas_reg_init
*reg_init
)
617 unsigned int val
= 0;
619 addr
= palmas_regs_info
[id
].ctrl_addr
;
621 if (reg_init
->mode_sleep
)
622 val
= PALMAS_REGEN1_CTRL_MODE_SLEEP
;
624 ret
= palmas_update_bits(palmas
, PALMAS_RESOURCE_BASE
,
625 addr
, PALMAS_REGEN1_CTRL_MODE_SLEEP
, val
);
627 dev_err(palmas
->dev
, "Resource reg 0x%02x update failed %d\n",
634 static void palmas_enable_ldo8_track(struct palmas
*palmas
)
640 addr
= palmas_regs_info
[PALMAS_REG_LDO8
].ctrl_addr
;
642 ret
= palmas_ldo_read(palmas
, addr
, ®
);
644 dev_err(palmas
->dev
, "Error in reading ldo8 control reg\n");
648 reg
|= PALMAS_LDO8_CTRL_LDO_TRACKING_EN
;
649 ret
= palmas_ldo_write(palmas
, addr
, reg
);
651 dev_err(palmas
->dev
, "Error in enabling tracking mode\n");
655 * When SMPS45 is set to off and LDO8 tracking is enabled, the LDO8
656 * output is defined by the LDO8_VOLTAGE.VSEL register divided by two,
657 * and can be set from 0.45 to 1.65 V.
659 addr
= palmas_regs_info
[PALMAS_REG_LDO8
].vsel_addr
;
660 ret
= palmas_ldo_read(palmas
, addr
, ®
);
662 dev_err(palmas
->dev
, "Error in reading ldo8 voltage reg\n");
666 reg
= (reg
<< 1) & PALMAS_LDO8_VOLTAGE_VSEL_MASK
;
667 ret
= palmas_ldo_write(palmas
, addr
, reg
);
669 dev_err(palmas
->dev
, "Error in setting ldo8 voltage reg\n");
674 static struct of_regulator_match palmas_matches
[] = {
675 { .name
= "smps12", },
676 { .name
= "smps123", },
677 { .name
= "smps3", },
678 { .name
= "smps45", },
679 { .name
= "smps457", },
680 { .name
= "smps6", },
681 { .name
= "smps7", },
682 { .name
= "smps8", },
683 { .name
= "smps9", },
684 { .name
= "smps10", },
694 { .name
= "ldoln", },
695 { .name
= "ldousb", },
696 { .name
= "regen1", },
697 { .name
= "regen2", },
698 { .name
= "regen3", },
699 { .name
= "sysen1", },
700 { .name
= "sysen2", },
703 static void palmas_dt_to_pdata(struct device
*dev
,
704 struct device_node
*node
,
705 struct palmas_pmic_platform_data
*pdata
)
707 struct device_node
*regulators
;
711 node
= of_node_get(node
);
712 regulators
= of_find_node_by_name(node
, "regulators");
714 dev_info(dev
, "regulator node not found\n");
718 ret
= of_regulator_match(dev
, regulators
, palmas_matches
,
720 of_node_put(regulators
);
722 dev_err(dev
, "Error parsing regulator init data: %d\n", ret
);
726 for (idx
= 0; idx
< PALMAS_NUM_REGS
; idx
++) {
727 if (!palmas_matches
[idx
].init_data
||
728 !palmas_matches
[idx
].of_node
)
731 pdata
->reg_data
[idx
] = palmas_matches
[idx
].init_data
;
733 pdata
->reg_init
[idx
] = devm_kzalloc(dev
,
734 sizeof(struct palmas_reg_init
), GFP_KERNEL
);
736 pdata
->reg_init
[idx
]->warm_reset
=
737 of_property_read_bool(palmas_matches
[idx
].of_node
,
740 pdata
->reg_init
[idx
]->roof_floor
=
741 of_property_read_bool(palmas_matches
[idx
].of_node
,
744 ret
= of_property_read_u32(palmas_matches
[idx
].of_node
,
745 "ti,mode-sleep", &prop
);
747 pdata
->reg_init
[idx
]->mode_sleep
= prop
;
749 ret
= of_property_read_bool(palmas_matches
[idx
].of_node
,
752 pdata
->reg_init
[idx
]->vsel
=
753 PALMAS_SMPS12_VOLTAGE_RANGE
;
755 if (idx
== PALMAS_REG_LDO8
)
756 pdata
->enable_ldo8_tracking
= of_property_read_bool(
757 palmas_matches
[idx
].of_node
,
758 "ti,enable-ldo8-tracking");
761 pdata
->ldo6_vibrator
= of_property_read_bool(node
, "ti,ldo6-vibrator");
765 static int palmas_regulators_probe(struct platform_device
*pdev
)
767 struct palmas
*palmas
= dev_get_drvdata(pdev
->dev
.parent
);
768 struct palmas_pmic_platform_data
*pdata
= pdev
->dev
.platform_data
;
769 struct device_node
*node
= pdev
->dev
.of_node
;
770 struct regulator_dev
*rdev
;
771 struct regulator_config config
= { };
772 struct palmas_pmic
*pmic
;
773 struct palmas_reg_init
*reg_init
;
775 unsigned int addr
, reg
;
777 if (node
&& !pdata
) {
778 pdata
= devm_kzalloc(&pdev
->dev
, sizeof(*pdata
), GFP_KERNEL
);
783 palmas_dt_to_pdata(&pdev
->dev
, node
, pdata
);
786 pmic
= devm_kzalloc(&pdev
->dev
, sizeof(*pmic
), GFP_KERNEL
);
790 pmic
->dev
= &pdev
->dev
;
791 pmic
->palmas
= palmas
;
793 platform_set_drvdata(pdev
, pmic
);
795 ret
= palmas_smps_read(palmas
, PALMAS_SMPS_CTRL
, ®
);
799 if (reg
& PALMAS_SMPS_CTRL_SMPS12_SMPS123_EN
)
802 if (reg
& PALMAS_SMPS_CTRL_SMPS45_SMPS457_EN
)
805 config
.regmap
= palmas
->regmap
[REGULATOR_SLAVE
];
806 config
.dev
= &pdev
->dev
;
807 config
.driver_data
= pmic
;
809 for (id
= 0; id
< PALMAS_REG_LDO1
; id
++) {
810 bool ramp_delay_support
= false;
813 * Miss out regulators which are not available due
814 * to slaving configurations.
817 case PALMAS_REG_SMPS12
:
818 case PALMAS_REG_SMPS3
:
821 if (id
== PALMAS_REG_SMPS12
)
822 ramp_delay_support
= true;
824 case PALMAS_REG_SMPS123
:
827 ramp_delay_support
= true;
829 case PALMAS_REG_SMPS45
:
830 case PALMAS_REG_SMPS7
:
833 if (id
== PALMAS_REG_SMPS45
)
834 ramp_delay_support
= true;
836 case PALMAS_REG_SMPS457
:
839 ramp_delay_support
= true;
843 if ((id
== PALMAS_REG_SMPS6
) || (id
== PALMAS_REG_SMPS8
))
844 ramp_delay_support
= true;
846 if (ramp_delay_support
) {
847 addr
= palmas_regs_info
[id
].tstep_addr
;
848 ret
= palmas_smps_read(pmic
->palmas
, addr
, ®
);
851 "reading TSTEP reg failed: %d\n", ret
);
852 goto err_unregister_regulator
;
854 pmic
->desc
[id
].ramp_delay
=
855 palmas_smps_ramp_delay
[reg
& 0x3];
856 pmic
->ramp_delay
[id
] = pmic
->desc
[id
].ramp_delay
;
859 /* Initialise sleep/init values from platform data */
860 if (pdata
&& pdata
->reg_init
[id
]) {
861 reg_init
= pdata
->reg_init
[id
];
862 ret
= palmas_smps_init(palmas
, id
, reg_init
);
864 goto err_unregister_regulator
;
867 /* Register the regulators */
868 pmic
->desc
[id
].name
= palmas_regs_info
[id
].name
;
869 pmic
->desc
[id
].id
= id
;
872 case PALMAS_REG_SMPS10
:
873 pmic
->desc
[id
].n_voltages
= PALMAS_SMPS10_NUM_VOLTAGES
;
874 pmic
->desc
[id
].ops
= &palmas_ops_smps10
;
875 pmic
->desc
[id
].vsel_reg
=
876 PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE
,
878 pmic
->desc
[id
].vsel_mask
= SMPS10_VSEL
;
879 pmic
->desc
[id
].enable_reg
=
880 PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE
,
882 pmic
->desc
[id
].enable_mask
= SMPS10_BOOST_EN
;
883 pmic
->desc
[id
].min_uV
= 3750000;
884 pmic
->desc
[id
].uV_step
= 1250000;
888 * Read and store the RANGE bit for later use
889 * This must be done before regulator is probed,
890 * otherwise we error in probe with unsupportable
891 * ranges. Read the current smps mode for later use.
893 addr
= palmas_regs_info
[id
].vsel_addr
;
895 ret
= palmas_smps_read(pmic
->palmas
, addr
, ®
);
897 goto err_unregister_regulator
;
898 if (reg
& PALMAS_SMPS12_VOLTAGE_RANGE
)
901 pmic
->desc
[id
].ops
= &palmas_ops_smps
;
902 pmic
->desc
[id
].n_voltages
= PALMAS_SMPS_NUM_VOLTAGES
;
903 pmic
->desc
[id
].vsel_reg
=
904 PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE
,
905 palmas_regs_info
[id
].vsel_addr
);
906 pmic
->desc
[id
].vsel_mask
=
907 PALMAS_SMPS12_VOLTAGE_VSEL_MASK
;
909 /* Read the smps mode for later use. */
910 addr
= palmas_regs_info
[id
].ctrl_addr
;
911 ret
= palmas_smps_read(pmic
->palmas
, addr
, ®
);
913 goto err_unregister_regulator
;
914 pmic
->current_reg_mode
[id
] = reg
&
915 PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK
;
918 pmic
->desc
[id
].type
= REGULATOR_VOLTAGE
;
919 pmic
->desc
[id
].owner
= THIS_MODULE
;
922 config
.init_data
= pdata
->reg_data
[id
];
924 config
.init_data
= NULL
;
926 pmic
->desc
[id
].supply_name
= palmas_regs_info
[id
].sname
;
927 config
.of_node
= palmas_matches
[id
].of_node
;
929 rdev
= regulator_register(&pmic
->desc
[id
], &config
);
932 "failed to register %s regulator\n",
935 goto err_unregister_regulator
;
938 /* Save regulator for cleanup */
939 pmic
->rdev
[id
] = rdev
;
942 /* Start this loop from the id left from previous loop */
943 for (; id
< PALMAS_NUM_REGS
; id
++) {
945 /* Miss out regulators which are not available due
946 * to alternate functions.
949 /* Register the regulators */
950 pmic
->desc
[id
].name
= palmas_regs_info
[id
].name
;
951 pmic
->desc
[id
].id
= id
;
952 pmic
->desc
[id
].type
= REGULATOR_VOLTAGE
;
953 pmic
->desc
[id
].owner
= THIS_MODULE
;
955 if (id
< PALMAS_REG_REGEN1
) {
956 pmic
->desc
[id
].n_voltages
= PALMAS_LDO_NUM_VOLTAGES
;
957 pmic
->desc
[id
].ops
= &palmas_ops_ldo
;
958 pmic
->desc
[id
].min_uV
= 900000;
959 pmic
->desc
[id
].uV_step
= 50000;
960 pmic
->desc
[id
].linear_min_sel
= 1;
961 pmic
->desc
[id
].vsel_reg
=
962 PALMAS_BASE_TO_REG(PALMAS_LDO_BASE
,
963 palmas_regs_info
[id
].vsel_addr
);
964 pmic
->desc
[id
].vsel_mask
=
965 PALMAS_LDO1_VOLTAGE_VSEL_MASK
;
966 pmic
->desc
[id
].enable_reg
=
967 PALMAS_BASE_TO_REG(PALMAS_LDO_BASE
,
968 palmas_regs_info
[id
].ctrl_addr
);
969 pmic
->desc
[id
].enable_mask
=
970 PALMAS_LDO1_CTRL_MODE_ACTIVE
;
972 /* Check if LDO8 is in tracking mode or not */
973 if (pdata
&& (id
== PALMAS_REG_LDO8
) &&
974 pdata
->enable_ldo8_tracking
) {
975 palmas_enable_ldo8_track(palmas
);
976 pmic
->desc
[id
].min_uV
= 450000;
977 pmic
->desc
[id
].uV_step
= 25000;
980 pmic
->desc
[id
].n_voltages
= 1;
981 pmic
->desc
[id
].ops
= &palmas_ops_extreg
;
982 pmic
->desc
[id
].enable_reg
=
983 PALMAS_BASE_TO_REG(PALMAS_RESOURCE_BASE
,
984 palmas_regs_info
[id
].ctrl_addr
);
985 pmic
->desc
[id
].enable_mask
=
986 PALMAS_REGEN1_CTRL_MODE_ACTIVE
;
990 config
.init_data
= pdata
->reg_data
[id
];
992 config
.init_data
= NULL
;
994 pmic
->desc
[id
].supply_name
= palmas_regs_info
[id
].sname
;
995 config
.of_node
= palmas_matches
[id
].of_node
;
997 rdev
= regulator_register(&pmic
->desc
[id
], &config
);
1000 "failed to register %s regulator\n",
1002 ret
= PTR_ERR(rdev
);
1003 goto err_unregister_regulator
;
1006 /* Save regulator for cleanup */
1007 pmic
->rdev
[id
] = rdev
;
1009 /* Initialise sleep/init values from platform data */
1011 reg_init
= pdata
->reg_init
[id
];
1013 if (id
< PALMAS_REG_REGEN1
)
1014 ret
= palmas_ldo_init(palmas
,
1017 ret
= palmas_extreg_init(palmas
,
1020 regulator_unregister(pmic
->rdev
[id
]);
1021 goto err_unregister_regulator
;
1030 err_unregister_regulator
:
1032 regulator_unregister(pmic
->rdev
[id
]);
1036 static int palmas_regulators_remove(struct platform_device
*pdev
)
1038 struct palmas_pmic
*pmic
= platform_get_drvdata(pdev
);
1041 for (id
= 0; id
< PALMAS_NUM_REGS
; id
++)
1042 regulator_unregister(pmic
->rdev
[id
]);
1046 static struct of_device_id of_palmas_match_tbl
[] = {
1047 { .compatible
= "ti,palmas-pmic", },
1048 { .compatible
= "ti,twl6035-pmic", },
1049 { .compatible
= "ti,twl6036-pmic", },
1050 { .compatible
= "ti,twl6037-pmic", },
1051 { .compatible
= "ti,tps65913-pmic", },
1052 { .compatible
= "ti,tps65914-pmic", },
1053 { .compatible
= "ti,tps80036-pmic", },
1057 static struct platform_driver palmas_driver
= {
1059 .name
= "palmas-pmic",
1060 .of_match_table
= of_palmas_match_tbl
,
1061 .owner
= THIS_MODULE
,
1063 .probe
= palmas_regulators_probe
,
1064 .remove
= palmas_regulators_remove
,
1067 static int __init
palmas_init(void)
1069 return platform_driver_register(&palmas_driver
);
1071 subsys_initcall(palmas_init
);
1073 static void __exit
palmas_exit(void)
1075 platform_driver_unregister(&palmas_driver
);
1077 module_exit(palmas_exit
);
1079 MODULE_AUTHOR("Graeme Gregory <gg@slimlogic.co.uk>");
1080 MODULE_DESCRIPTION("Palmas voltage regulator driver");
1081 MODULE_LICENSE("GPL");
1082 MODULE_ALIAS("platform:palmas-pmic");
1083 MODULE_DEVICE_TABLE(of
, of_palmas_match_tbl
);