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
,
100 .name
= "SMPS10_OUT2",
101 .sname
= "smps10-in",
102 .ctrl_addr
= PALMAS_SMPS10_CTRL
,
105 .name
= "SMPS10_OUT1",
106 .sname
= "smps10-out2",
107 .ctrl_addr
= PALMAS_SMPS10_CTRL
,
112 .vsel_addr
= PALMAS_LDO1_VOLTAGE
,
113 .ctrl_addr
= PALMAS_LDO1_CTRL
,
118 .vsel_addr
= PALMAS_LDO2_VOLTAGE
,
119 .ctrl_addr
= PALMAS_LDO2_CTRL
,
124 .vsel_addr
= PALMAS_LDO3_VOLTAGE
,
125 .ctrl_addr
= PALMAS_LDO3_CTRL
,
130 .vsel_addr
= PALMAS_LDO4_VOLTAGE
,
131 .ctrl_addr
= PALMAS_LDO4_CTRL
,
136 .vsel_addr
= PALMAS_LDO5_VOLTAGE
,
137 .ctrl_addr
= PALMAS_LDO5_CTRL
,
142 .vsel_addr
= PALMAS_LDO6_VOLTAGE
,
143 .ctrl_addr
= PALMAS_LDO6_CTRL
,
148 .vsel_addr
= PALMAS_LDO7_VOLTAGE
,
149 .ctrl_addr
= PALMAS_LDO7_CTRL
,
154 .vsel_addr
= PALMAS_LDO8_VOLTAGE
,
155 .ctrl_addr
= PALMAS_LDO8_CTRL
,
160 .vsel_addr
= PALMAS_LDO9_VOLTAGE
,
161 .ctrl_addr
= PALMAS_LDO9_CTRL
,
166 .vsel_addr
= PALMAS_LDOLN_VOLTAGE
,
167 .ctrl_addr
= PALMAS_LDOLN_CTRL
,
171 .sname
= "ldousb-in",
172 .vsel_addr
= PALMAS_LDOUSB_VOLTAGE
,
173 .ctrl_addr
= PALMAS_LDOUSB_CTRL
,
177 .ctrl_addr
= PALMAS_REGEN1_CTRL
,
181 .ctrl_addr
= PALMAS_REGEN2_CTRL
,
185 .ctrl_addr
= PALMAS_REGEN3_CTRL
,
189 .ctrl_addr
= PALMAS_SYSEN1_CTRL
,
193 .ctrl_addr
= PALMAS_SYSEN2_CTRL
,
197 static unsigned int palmas_smps_ramp_delay
[4] = {0, 10000, 5000, 2500};
199 #define SMPS_CTRL_MODE_OFF 0x00
200 #define SMPS_CTRL_MODE_ON 0x01
201 #define SMPS_CTRL_MODE_ECO 0x02
202 #define SMPS_CTRL_MODE_PWM 0x03
204 /* These values are derived from the data sheet. And are the number of steps
205 * where there is a voltage change, the ranges at beginning and end of register
206 * max/min values where there are no change are ommitted.
208 * So they are basically (maxV-minV)/stepV
210 #define PALMAS_SMPS_NUM_VOLTAGES 117
211 #define PALMAS_SMPS10_NUM_VOLTAGES 2
212 #define PALMAS_LDO_NUM_VOLTAGES 50
214 #define SMPS10_VSEL (1<<3)
215 #define SMPS10_BOOST_EN (1<<2)
216 #define SMPS10_BYPASS_EN (1<<1)
217 #define SMPS10_SWITCH_EN (1<<0)
219 #define REGULATOR_SLAVE 0
221 static int palmas_smps_read(struct palmas
*palmas
, unsigned int reg
,
226 addr
= PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE
, reg
);
228 return regmap_read(palmas
->regmap
[REGULATOR_SLAVE
], addr
, dest
);
231 static int palmas_smps_write(struct palmas
*palmas
, unsigned int reg
,
236 addr
= PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE
, reg
);
238 return regmap_write(palmas
->regmap
[REGULATOR_SLAVE
], addr
, value
);
241 static int palmas_ldo_read(struct palmas
*palmas
, unsigned int reg
,
246 addr
= PALMAS_BASE_TO_REG(PALMAS_LDO_BASE
, reg
);
248 return regmap_read(palmas
->regmap
[REGULATOR_SLAVE
], addr
, dest
);
251 static int palmas_ldo_write(struct palmas
*palmas
, unsigned int reg
,
256 addr
= PALMAS_BASE_TO_REG(PALMAS_LDO_BASE
, reg
);
258 return regmap_write(palmas
->regmap
[REGULATOR_SLAVE
], addr
, value
);
261 static int palmas_is_enabled_smps(struct regulator_dev
*dev
)
263 struct palmas_pmic
*pmic
= rdev_get_drvdata(dev
);
264 int id
= rdev_get_id(dev
);
267 palmas_smps_read(pmic
->palmas
, palmas_regs_info
[id
].ctrl_addr
, ®
);
269 reg
&= PALMAS_SMPS12_CTRL_STATUS_MASK
;
270 reg
>>= PALMAS_SMPS12_CTRL_STATUS_SHIFT
;
275 static int palmas_enable_smps(struct regulator_dev
*dev
)
277 struct palmas_pmic
*pmic
= rdev_get_drvdata(dev
);
278 int id
= rdev_get_id(dev
);
281 palmas_smps_read(pmic
->palmas
, palmas_regs_info
[id
].ctrl_addr
, ®
);
283 reg
&= ~PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK
;
284 if (pmic
->current_reg_mode
[id
])
285 reg
|= pmic
->current_reg_mode
[id
];
287 reg
|= SMPS_CTRL_MODE_ON
;
289 palmas_smps_write(pmic
->palmas
, palmas_regs_info
[id
].ctrl_addr
, reg
);
294 static int palmas_disable_smps(struct regulator_dev
*dev
)
296 struct palmas_pmic
*pmic
= rdev_get_drvdata(dev
);
297 int id
= rdev_get_id(dev
);
300 palmas_smps_read(pmic
->palmas
, palmas_regs_info
[id
].ctrl_addr
, ®
);
302 reg
&= ~PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK
;
304 palmas_smps_write(pmic
->palmas
, palmas_regs_info
[id
].ctrl_addr
, reg
);
309 static int palmas_set_mode_smps(struct regulator_dev
*dev
, unsigned int mode
)
311 struct palmas_pmic
*pmic
= rdev_get_drvdata(dev
);
312 int id
= rdev_get_id(dev
);
314 bool rail_enable
= true;
316 palmas_smps_read(pmic
->palmas
, palmas_regs_info
[id
].ctrl_addr
, ®
);
317 reg
&= ~PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK
;
319 if (reg
== SMPS_CTRL_MODE_OFF
)
323 case REGULATOR_MODE_NORMAL
:
324 reg
|= SMPS_CTRL_MODE_ON
;
326 case REGULATOR_MODE_IDLE
:
327 reg
|= SMPS_CTRL_MODE_ECO
;
329 case REGULATOR_MODE_FAST
:
330 reg
|= SMPS_CTRL_MODE_PWM
;
336 pmic
->current_reg_mode
[id
] = reg
& PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK
;
338 palmas_smps_write(pmic
->palmas
,
339 palmas_regs_info
[id
].ctrl_addr
, reg
);
343 static unsigned int palmas_get_mode_smps(struct regulator_dev
*dev
)
345 struct palmas_pmic
*pmic
= rdev_get_drvdata(dev
);
346 int id
= rdev_get_id(dev
);
349 reg
= pmic
->current_reg_mode
[id
] & PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK
;
352 case SMPS_CTRL_MODE_ON
:
353 return REGULATOR_MODE_NORMAL
;
354 case SMPS_CTRL_MODE_ECO
:
355 return REGULATOR_MODE_IDLE
;
356 case SMPS_CTRL_MODE_PWM
:
357 return REGULATOR_MODE_FAST
;
363 static int palmas_list_voltage_smps(struct regulator_dev
*dev
,
366 struct palmas_pmic
*pmic
= rdev_get_drvdata(dev
);
367 int id
= rdev_get_id(dev
);
370 /* Read the multiplier set in VSEL register to return
371 * the correct voltage.
378 else if (selector
< 6)
379 return 500000 * mult
;
381 /* Voltage is linear mapping starting from selector 6,
382 * volt = (0.49V + ((selector - 5) * 0.01V)) * RANGE
383 * RANGE is either x1 or x2
385 return (490000 + ((selector
- 5) * 10000)) * mult
;
388 static int palmas_map_voltage_smps(struct regulator_dev
*rdev
,
389 int min_uV
, int max_uV
)
391 struct palmas_pmic
*pmic
= rdev_get_drvdata(rdev
);
392 int id
= rdev_get_id(rdev
);
398 if (pmic
->range
[id
]) { /* RANGE is x2 */
399 if (min_uV
< 1000000)
401 ret
= DIV_ROUND_UP(min_uV
- 1000000, 20000) + 6;
402 } else { /* RANGE is x1 */
405 ret
= DIV_ROUND_UP(min_uV
- 500000, 10000) + 6;
408 /* Map back into a voltage to verify we're still in bounds */
409 voltage
= palmas_list_voltage_smps(rdev
, ret
);
410 if (voltage
< min_uV
|| voltage
> max_uV
)
416 static int palma_smps_set_voltage_smps_time_sel(struct regulator_dev
*rdev
,
417 unsigned int old_selector
, unsigned int new_selector
)
419 struct palmas_pmic
*pmic
= rdev_get_drvdata(rdev
);
420 int id
= rdev_get_id(rdev
);
422 unsigned int ramp_delay
= pmic
->ramp_delay
[id
];
427 old_uv
= palmas_list_voltage_smps(rdev
, old_selector
);
431 new_uv
= palmas_list_voltage_smps(rdev
, new_selector
);
435 return DIV_ROUND_UP(abs(old_uv
- new_uv
), ramp_delay
);
438 static int palmas_smps_set_ramp_delay(struct regulator_dev
*rdev
,
441 struct palmas_pmic
*pmic
= rdev_get_drvdata(rdev
);
442 int id
= rdev_get_id(rdev
);
443 unsigned int reg
= 0;
444 unsigned int addr
= palmas_regs_info
[id
].tstep_addr
;
447 /* SMPS3 and SMPS7 do not have tstep_addr setting */
449 case PALMAS_REG_SMPS3
:
450 case PALMAS_REG_SMPS7
:
456 else if (ramp_delay
<= 2500)
458 else if (ramp_delay
<= 5000)
463 ret
= palmas_smps_write(pmic
->palmas
, addr
, reg
);
465 dev_err(pmic
->palmas
->dev
, "TSTEP write failed: %d\n", ret
);
469 pmic
->ramp_delay
[id
] = palmas_smps_ramp_delay
[reg
];
473 static struct regulator_ops palmas_ops_smps
= {
474 .is_enabled
= palmas_is_enabled_smps
,
475 .enable
= palmas_enable_smps
,
476 .disable
= palmas_disable_smps
,
477 .set_mode
= palmas_set_mode_smps
,
478 .get_mode
= palmas_get_mode_smps
,
479 .get_voltage_sel
= regulator_get_voltage_sel_regmap
,
480 .set_voltage_sel
= regulator_set_voltage_sel_regmap
,
481 .list_voltage
= palmas_list_voltage_smps
,
482 .map_voltage
= palmas_map_voltage_smps
,
483 .set_voltage_time_sel
= palma_smps_set_voltage_smps_time_sel
,
484 .set_ramp_delay
= palmas_smps_set_ramp_delay
,
487 static struct regulator_ops palmas_ops_smps10
= {
488 .is_enabled
= regulator_is_enabled_regmap
,
489 .enable
= regulator_enable_regmap
,
490 .disable
= regulator_disable_regmap
,
491 .get_voltage_sel
= regulator_get_voltage_sel_regmap
,
492 .set_voltage_sel
= regulator_set_voltage_sel_regmap
,
493 .list_voltage
= regulator_list_voltage_linear
,
494 .map_voltage
= regulator_map_voltage_linear
,
495 .set_bypass
= regulator_set_bypass_regmap
,
496 .get_bypass
= regulator_get_bypass_regmap
,
499 static int palmas_is_enabled_ldo(struct regulator_dev
*dev
)
501 struct palmas_pmic
*pmic
= rdev_get_drvdata(dev
);
502 int id
= rdev_get_id(dev
);
505 palmas_ldo_read(pmic
->palmas
, palmas_regs_info
[id
].ctrl_addr
, ®
);
507 reg
&= PALMAS_LDO1_CTRL_STATUS
;
512 static struct regulator_ops palmas_ops_ldo
= {
513 .is_enabled
= palmas_is_enabled_ldo
,
514 .enable
= regulator_enable_regmap
,
515 .disable
= regulator_disable_regmap
,
516 .get_voltage_sel
= regulator_get_voltage_sel_regmap
,
517 .set_voltage_sel
= regulator_set_voltage_sel_regmap
,
518 .list_voltage
= regulator_list_voltage_linear
,
519 .map_voltage
= regulator_map_voltage_linear
,
522 static struct regulator_ops palmas_ops_extreg
= {
523 .is_enabled
= regulator_is_enabled_regmap
,
524 .enable
= regulator_enable_regmap
,
525 .disable
= regulator_disable_regmap
,
529 * setup the hardware based sleep configuration of the SMPS/LDO regulators
530 * from the platform data. This is different to the software based control
531 * supported by the regulator framework as it is controlled by toggling
532 * pins on the PMIC such as PREQ, SYSEN, ...
534 static int palmas_smps_init(struct palmas
*palmas
, int id
,
535 struct palmas_reg_init
*reg_init
)
541 addr
= palmas_regs_info
[id
].ctrl_addr
;
543 ret
= palmas_smps_read(palmas
, addr
, ®
);
548 case PALMAS_REG_SMPS10_OUT1
:
549 case PALMAS_REG_SMPS10_OUT2
:
550 reg
&= ~PALMAS_SMPS10_CTRL_MODE_SLEEP_MASK
;
551 if (reg_init
->mode_sleep
)
552 reg
|= reg_init
->mode_sleep
<<
553 PALMAS_SMPS10_CTRL_MODE_SLEEP_SHIFT
;
556 if (reg_init
->warm_reset
)
557 reg
|= PALMAS_SMPS12_CTRL_WR_S
;
559 reg
&= ~PALMAS_SMPS12_CTRL_WR_S
;
561 if (reg_init
->roof_floor
)
562 reg
|= PALMAS_SMPS12_CTRL_ROOF_FLOOR_EN
;
564 reg
&= ~PALMAS_SMPS12_CTRL_ROOF_FLOOR_EN
;
566 reg
&= ~PALMAS_SMPS12_CTRL_MODE_SLEEP_MASK
;
567 if (reg_init
->mode_sleep
)
568 reg
|= reg_init
->mode_sleep
<<
569 PALMAS_SMPS12_CTRL_MODE_SLEEP_SHIFT
;
572 ret
= palmas_smps_write(palmas
, addr
, reg
);
576 if (palmas_regs_info
[id
].vsel_addr
&& reg_init
->vsel
) {
577 addr
= palmas_regs_info
[id
].vsel_addr
;
579 reg
= reg_init
->vsel
;
581 ret
= palmas_smps_write(palmas
, addr
, reg
);
590 static int palmas_ldo_init(struct palmas
*palmas
, int id
,
591 struct palmas_reg_init
*reg_init
)
597 addr
= palmas_regs_info
[id
].ctrl_addr
;
599 ret
= palmas_ldo_read(palmas
, addr
, ®
);
603 if (reg_init
->warm_reset
)
604 reg
|= PALMAS_LDO1_CTRL_WR_S
;
606 reg
&= ~PALMAS_LDO1_CTRL_WR_S
;
608 if (reg_init
->mode_sleep
)
609 reg
|= PALMAS_LDO1_CTRL_MODE_SLEEP
;
611 reg
&= ~PALMAS_LDO1_CTRL_MODE_SLEEP
;
613 ret
= palmas_ldo_write(palmas
, addr
, reg
);
620 static int palmas_extreg_init(struct palmas
*palmas
, int id
,
621 struct palmas_reg_init
*reg_init
)
625 unsigned int val
= 0;
627 addr
= palmas_regs_info
[id
].ctrl_addr
;
629 if (reg_init
->mode_sleep
)
630 val
= PALMAS_REGEN1_CTRL_MODE_SLEEP
;
632 ret
= palmas_update_bits(palmas
, PALMAS_RESOURCE_BASE
,
633 addr
, PALMAS_REGEN1_CTRL_MODE_SLEEP
, val
);
635 dev_err(palmas
->dev
, "Resource reg 0x%02x update failed %d\n",
642 static void palmas_enable_ldo8_track(struct palmas
*palmas
)
648 addr
= palmas_regs_info
[PALMAS_REG_LDO8
].ctrl_addr
;
650 ret
= palmas_ldo_read(palmas
, addr
, ®
);
652 dev_err(palmas
->dev
, "Error in reading ldo8 control reg\n");
656 reg
|= PALMAS_LDO8_CTRL_LDO_TRACKING_EN
;
657 ret
= palmas_ldo_write(palmas
, addr
, reg
);
659 dev_err(palmas
->dev
, "Error in enabling tracking mode\n");
663 * When SMPS45 is set to off and LDO8 tracking is enabled, the LDO8
664 * output is defined by the LDO8_VOLTAGE.VSEL register divided by two,
665 * and can be set from 0.45 to 1.65 V.
667 addr
= palmas_regs_info
[PALMAS_REG_LDO8
].vsel_addr
;
668 ret
= palmas_ldo_read(palmas
, addr
, ®
);
670 dev_err(palmas
->dev
, "Error in reading ldo8 voltage reg\n");
674 reg
= (reg
<< 1) & PALMAS_LDO8_VOLTAGE_VSEL_MASK
;
675 ret
= palmas_ldo_write(palmas
, addr
, reg
);
677 dev_err(palmas
->dev
, "Error in setting ldo8 voltage reg\n");
682 static struct of_regulator_match palmas_matches
[] = {
683 { .name
= "smps12", },
684 { .name
= "smps123", },
685 { .name
= "smps3", },
686 { .name
= "smps45", },
687 { .name
= "smps457", },
688 { .name
= "smps6", },
689 { .name
= "smps7", },
690 { .name
= "smps8", },
691 { .name
= "smps9", },
692 { .name
= "smps10_out2", },
693 { .name
= "smps10_out1", },
703 { .name
= "ldoln", },
704 { .name
= "ldousb", },
705 { .name
= "regen1", },
706 { .name
= "regen2", },
707 { .name
= "regen3", },
708 { .name
= "sysen1", },
709 { .name
= "sysen2", },
712 static void palmas_dt_to_pdata(struct device
*dev
,
713 struct device_node
*node
,
714 struct palmas_pmic_platform_data
*pdata
)
716 struct device_node
*regulators
;
720 node
= of_node_get(node
);
721 regulators
= of_find_node_by_name(node
, "regulators");
723 dev_info(dev
, "regulator node not found\n");
727 ret
= of_regulator_match(dev
, regulators
, palmas_matches
,
729 of_node_put(regulators
);
731 dev_err(dev
, "Error parsing regulator init data: %d\n", ret
);
735 for (idx
= 0; idx
< PALMAS_NUM_REGS
; idx
++) {
736 if (!palmas_matches
[idx
].init_data
||
737 !palmas_matches
[idx
].of_node
)
740 pdata
->reg_data
[idx
] = palmas_matches
[idx
].init_data
;
742 pdata
->reg_init
[idx
] = devm_kzalloc(dev
,
743 sizeof(struct palmas_reg_init
), GFP_KERNEL
);
745 pdata
->reg_init
[idx
]->warm_reset
=
746 of_property_read_bool(palmas_matches
[idx
].of_node
,
749 pdata
->reg_init
[idx
]->roof_floor
=
750 of_property_read_bool(palmas_matches
[idx
].of_node
,
753 ret
= of_property_read_u32(palmas_matches
[idx
].of_node
,
754 "ti,mode-sleep", &prop
);
756 pdata
->reg_init
[idx
]->mode_sleep
= prop
;
758 ret
= of_property_read_bool(palmas_matches
[idx
].of_node
,
761 pdata
->reg_init
[idx
]->vsel
=
762 PALMAS_SMPS12_VOLTAGE_RANGE
;
764 if (idx
== PALMAS_REG_LDO8
)
765 pdata
->enable_ldo8_tracking
= of_property_read_bool(
766 palmas_matches
[idx
].of_node
,
767 "ti,enable-ldo8-tracking");
770 pdata
->ldo6_vibrator
= of_property_read_bool(node
, "ti,ldo6-vibrator");
774 static int palmas_regulators_probe(struct platform_device
*pdev
)
776 struct palmas
*palmas
= dev_get_drvdata(pdev
->dev
.parent
);
777 struct palmas_pmic_platform_data
*pdata
= dev_get_platdata(&pdev
->dev
);
778 struct device_node
*node
= pdev
->dev
.of_node
;
779 struct regulator_dev
*rdev
;
780 struct regulator_config config
= { };
781 struct palmas_pmic
*pmic
;
782 struct palmas_reg_init
*reg_init
;
784 unsigned int addr
, reg
;
786 if (node
&& !pdata
) {
787 pdata
= devm_kzalloc(&pdev
->dev
, sizeof(*pdata
), GFP_KERNEL
);
792 palmas_dt_to_pdata(&pdev
->dev
, node
, pdata
);
795 pmic
= devm_kzalloc(&pdev
->dev
, sizeof(*pmic
), GFP_KERNEL
);
799 pmic
->dev
= &pdev
->dev
;
800 pmic
->palmas
= palmas
;
802 platform_set_drvdata(pdev
, pmic
);
804 ret
= palmas_smps_read(palmas
, PALMAS_SMPS_CTRL
, ®
);
808 if (reg
& PALMAS_SMPS_CTRL_SMPS12_SMPS123_EN
)
811 if (reg
& PALMAS_SMPS_CTRL_SMPS45_SMPS457_EN
)
814 config
.regmap
= palmas
->regmap
[REGULATOR_SLAVE
];
815 config
.dev
= &pdev
->dev
;
816 config
.driver_data
= pmic
;
818 for (id
= 0; id
< PALMAS_REG_LDO1
; id
++) {
819 bool ramp_delay_support
= false;
822 * Miss out regulators which are not available due
823 * to slaving configurations.
826 case PALMAS_REG_SMPS12
:
827 case PALMAS_REG_SMPS3
:
830 if (id
== PALMAS_REG_SMPS12
)
831 ramp_delay_support
= true;
833 case PALMAS_REG_SMPS123
:
836 ramp_delay_support
= true;
838 case PALMAS_REG_SMPS45
:
839 case PALMAS_REG_SMPS7
:
842 if (id
== PALMAS_REG_SMPS45
)
843 ramp_delay_support
= true;
845 case PALMAS_REG_SMPS457
:
848 ramp_delay_support
= true;
850 case PALMAS_REG_SMPS10_OUT1
:
851 case PALMAS_REG_SMPS10_OUT2
:
852 if (!PALMAS_PMIC_HAS(palmas
, SMPS10_BOOST
))
856 if ((id
== PALMAS_REG_SMPS6
) || (id
== PALMAS_REG_SMPS8
))
857 ramp_delay_support
= true;
859 if (ramp_delay_support
) {
860 addr
= palmas_regs_info
[id
].tstep_addr
;
861 ret
= palmas_smps_read(pmic
->palmas
, addr
, ®
);
864 "reading TSTEP reg failed: %d\n", ret
);
865 goto err_unregister_regulator
;
867 pmic
->desc
[id
].ramp_delay
=
868 palmas_smps_ramp_delay
[reg
& 0x3];
869 pmic
->ramp_delay
[id
] = pmic
->desc
[id
].ramp_delay
;
872 /* Initialise sleep/init values from platform data */
873 if (pdata
&& pdata
->reg_init
[id
]) {
874 reg_init
= pdata
->reg_init
[id
];
875 ret
= palmas_smps_init(palmas
, id
, reg_init
);
877 goto err_unregister_regulator
;
880 /* Register the regulators */
881 pmic
->desc
[id
].name
= palmas_regs_info
[id
].name
;
882 pmic
->desc
[id
].id
= id
;
885 case PALMAS_REG_SMPS10_OUT1
:
886 case PALMAS_REG_SMPS10_OUT2
:
887 pmic
->desc
[id
].n_voltages
= PALMAS_SMPS10_NUM_VOLTAGES
;
888 pmic
->desc
[id
].ops
= &palmas_ops_smps10
;
889 pmic
->desc
[id
].vsel_reg
=
890 PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE
,
892 pmic
->desc
[id
].vsel_mask
= SMPS10_VSEL
;
893 pmic
->desc
[id
].enable_reg
=
894 PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE
,
896 if (id
== PALMAS_REG_SMPS10_OUT1
)
897 pmic
->desc
[id
].enable_mask
= SMPS10_SWITCH_EN
;
899 pmic
->desc
[id
].enable_mask
= SMPS10_BOOST_EN
;
900 pmic
->desc
[id
].bypass_reg
=
901 PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE
,
903 pmic
->desc
[id
].bypass_mask
= SMPS10_BYPASS_EN
;
904 pmic
->desc
[id
].min_uV
= 3750000;
905 pmic
->desc
[id
].uV_step
= 1250000;
909 * Read and store the RANGE bit for later use
910 * This must be done before regulator is probed,
911 * otherwise we error in probe with unsupportable
912 * ranges. Read the current smps mode for later use.
914 addr
= palmas_regs_info
[id
].vsel_addr
;
916 ret
= palmas_smps_read(pmic
->palmas
, addr
, ®
);
918 goto err_unregister_regulator
;
919 if (reg
& PALMAS_SMPS12_VOLTAGE_RANGE
)
922 pmic
->desc
[id
].ops
= &palmas_ops_smps
;
923 pmic
->desc
[id
].n_voltages
= PALMAS_SMPS_NUM_VOLTAGES
;
924 pmic
->desc
[id
].vsel_reg
=
925 PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE
,
926 palmas_regs_info
[id
].vsel_addr
);
927 pmic
->desc
[id
].vsel_mask
=
928 PALMAS_SMPS12_VOLTAGE_VSEL_MASK
;
930 /* Read the smps mode for later use. */
931 addr
= palmas_regs_info
[id
].ctrl_addr
;
932 ret
= palmas_smps_read(pmic
->palmas
, addr
, ®
);
934 goto err_unregister_regulator
;
935 pmic
->current_reg_mode
[id
] = reg
&
936 PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK
;
939 pmic
->desc
[id
].type
= REGULATOR_VOLTAGE
;
940 pmic
->desc
[id
].owner
= THIS_MODULE
;
943 config
.init_data
= pdata
->reg_data
[id
];
945 config
.init_data
= NULL
;
947 pmic
->desc
[id
].supply_name
= palmas_regs_info
[id
].sname
;
948 config
.of_node
= palmas_matches
[id
].of_node
;
950 rdev
= regulator_register(&pmic
->desc
[id
], &config
);
953 "failed to register %s regulator\n",
956 goto err_unregister_regulator
;
959 /* Save regulator for cleanup */
960 pmic
->rdev
[id
] = rdev
;
963 /* Start this loop from the id left from previous loop */
964 for (; id
< PALMAS_NUM_REGS
; id
++) {
966 /* Miss out regulators which are not available due
967 * to alternate functions.
970 /* Register the regulators */
971 pmic
->desc
[id
].name
= palmas_regs_info
[id
].name
;
972 pmic
->desc
[id
].id
= id
;
973 pmic
->desc
[id
].type
= REGULATOR_VOLTAGE
;
974 pmic
->desc
[id
].owner
= THIS_MODULE
;
976 if (id
< PALMAS_REG_REGEN1
) {
977 pmic
->desc
[id
].n_voltages
= PALMAS_LDO_NUM_VOLTAGES
;
978 pmic
->desc
[id
].ops
= &palmas_ops_ldo
;
979 pmic
->desc
[id
].min_uV
= 900000;
980 pmic
->desc
[id
].uV_step
= 50000;
981 pmic
->desc
[id
].linear_min_sel
= 1;
982 pmic
->desc
[id
].vsel_reg
=
983 PALMAS_BASE_TO_REG(PALMAS_LDO_BASE
,
984 palmas_regs_info
[id
].vsel_addr
);
985 pmic
->desc
[id
].vsel_mask
=
986 PALMAS_LDO1_VOLTAGE_VSEL_MASK
;
987 pmic
->desc
[id
].enable_reg
=
988 PALMAS_BASE_TO_REG(PALMAS_LDO_BASE
,
989 palmas_regs_info
[id
].ctrl_addr
);
990 pmic
->desc
[id
].enable_mask
=
991 PALMAS_LDO1_CTRL_MODE_ACTIVE
;
993 /* Check if LDO8 is in tracking mode or not */
994 if (pdata
&& (id
== PALMAS_REG_LDO8
) &&
995 pdata
->enable_ldo8_tracking
) {
996 palmas_enable_ldo8_track(palmas
);
997 pmic
->desc
[id
].min_uV
= 450000;
998 pmic
->desc
[id
].uV_step
= 25000;
1001 pmic
->desc
[id
].n_voltages
= 1;
1002 pmic
->desc
[id
].ops
= &palmas_ops_extreg
;
1003 pmic
->desc
[id
].enable_reg
=
1004 PALMAS_BASE_TO_REG(PALMAS_RESOURCE_BASE
,
1005 palmas_regs_info
[id
].ctrl_addr
);
1006 pmic
->desc
[id
].enable_mask
=
1007 PALMAS_REGEN1_CTRL_MODE_ACTIVE
;
1011 config
.init_data
= pdata
->reg_data
[id
];
1013 config
.init_data
= NULL
;
1015 pmic
->desc
[id
].supply_name
= palmas_regs_info
[id
].sname
;
1016 config
.of_node
= palmas_matches
[id
].of_node
;
1018 rdev
= regulator_register(&pmic
->desc
[id
], &config
);
1021 "failed to register %s regulator\n",
1023 ret
= PTR_ERR(rdev
);
1024 goto err_unregister_regulator
;
1027 /* Save regulator for cleanup */
1028 pmic
->rdev
[id
] = rdev
;
1030 /* Initialise sleep/init values from platform data */
1032 reg_init
= pdata
->reg_init
[id
];
1034 if (id
< PALMAS_REG_REGEN1
)
1035 ret
= palmas_ldo_init(palmas
,
1038 ret
= palmas_extreg_init(palmas
,
1041 regulator_unregister(pmic
->rdev
[id
]);
1042 goto err_unregister_regulator
;
1051 err_unregister_regulator
:
1053 regulator_unregister(pmic
->rdev
[id
]);
1057 static int palmas_regulators_remove(struct platform_device
*pdev
)
1059 struct palmas_pmic
*pmic
= platform_get_drvdata(pdev
);
1062 for (id
= 0; id
< PALMAS_NUM_REGS
; id
++)
1063 regulator_unregister(pmic
->rdev
[id
]);
1067 static struct of_device_id of_palmas_match_tbl
[] = {
1068 { .compatible
= "ti,palmas-pmic", },
1069 { .compatible
= "ti,twl6035-pmic", },
1070 { .compatible
= "ti,twl6036-pmic", },
1071 { .compatible
= "ti,twl6037-pmic", },
1072 { .compatible
= "ti,tps65913-pmic", },
1073 { .compatible
= "ti,tps65914-pmic", },
1074 { .compatible
= "ti,tps80036-pmic", },
1075 { .compatible
= "ti,tps659038-pmic", },
1079 static struct platform_driver palmas_driver
= {
1081 .name
= "palmas-pmic",
1082 .of_match_table
= of_palmas_match_tbl
,
1083 .owner
= THIS_MODULE
,
1085 .probe
= palmas_regulators_probe
,
1086 .remove
= palmas_regulators_remove
,
1089 static int __init
palmas_init(void)
1091 return platform_driver_register(&palmas_driver
);
1093 subsys_initcall(palmas_init
);
1095 static void __exit
palmas_exit(void)
1097 platform_driver_unregister(&palmas_driver
);
1099 module_exit(palmas_exit
);
1101 MODULE_AUTHOR("Graeme Gregory <gg@slimlogic.co.uk>");
1102 MODULE_DESCRIPTION("Palmas voltage regulator driver");
1103 MODULE_LICENSE("GPL");
1104 MODULE_ALIAS("platform:palmas-pmic");
1105 MODULE_DEVICE_TABLE(of
, of_palmas_match_tbl
);