2 * Driver for Regulator part of Palmas PMIC Chips
4 * Copyright 2011-2012 Texas Instruments Inc.
6 * Author: Graeme Gregory <gg@slimlogic.co.uk>
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the
10 * Free Software Foundation; either version 2 of the License, or (at your
11 * option) any later version.
15 #include <linux/kernel.h>
16 #include <linux/module.h>
17 #include <linux/init.h>
18 #include <linux/err.h>
19 #include <linux/platform_device.h>
20 #include <linux/regulator/driver.h>
21 #include <linux/regulator/machine.h>
22 #include <linux/slab.h>
23 #include <linux/regmap.h>
24 #include <linux/mfd/palmas.h>
26 #include <linux/of_platform.h>
27 #include <linux/regulator/of_regulator.h>
36 static const struct regs_info palmas_regs_info
[] = {
39 .vsel_addr
= PALMAS_SMPS12_VOLTAGE
,
40 .ctrl_addr
= PALMAS_SMPS12_CTRL
,
41 .tstep_addr
= PALMAS_SMPS12_TSTEP
,
45 .vsel_addr
= PALMAS_SMPS12_VOLTAGE
,
46 .ctrl_addr
= PALMAS_SMPS12_CTRL
,
47 .tstep_addr
= PALMAS_SMPS12_TSTEP
,
51 .vsel_addr
= PALMAS_SMPS3_VOLTAGE
,
52 .ctrl_addr
= PALMAS_SMPS3_CTRL
,
56 .vsel_addr
= PALMAS_SMPS45_VOLTAGE
,
57 .ctrl_addr
= PALMAS_SMPS45_CTRL
,
58 .tstep_addr
= PALMAS_SMPS45_TSTEP
,
62 .vsel_addr
= PALMAS_SMPS45_VOLTAGE
,
63 .ctrl_addr
= PALMAS_SMPS45_CTRL
,
64 .tstep_addr
= PALMAS_SMPS45_TSTEP
,
68 .vsel_addr
= PALMAS_SMPS6_VOLTAGE
,
69 .ctrl_addr
= PALMAS_SMPS6_CTRL
,
70 .tstep_addr
= PALMAS_SMPS6_TSTEP
,
74 .vsel_addr
= PALMAS_SMPS7_VOLTAGE
,
75 .ctrl_addr
= PALMAS_SMPS7_CTRL
,
79 .vsel_addr
= PALMAS_SMPS8_VOLTAGE
,
80 .ctrl_addr
= PALMAS_SMPS8_CTRL
,
81 .tstep_addr
= PALMAS_SMPS8_TSTEP
,
85 .vsel_addr
= PALMAS_SMPS9_VOLTAGE
,
86 .ctrl_addr
= PALMAS_SMPS9_CTRL
,
93 .vsel_addr
= PALMAS_LDO1_VOLTAGE
,
94 .ctrl_addr
= PALMAS_LDO1_CTRL
,
98 .vsel_addr
= PALMAS_LDO2_VOLTAGE
,
99 .ctrl_addr
= PALMAS_LDO2_CTRL
,
103 .vsel_addr
= PALMAS_LDO3_VOLTAGE
,
104 .ctrl_addr
= PALMAS_LDO3_CTRL
,
108 .vsel_addr
= PALMAS_LDO4_VOLTAGE
,
109 .ctrl_addr
= PALMAS_LDO4_CTRL
,
113 .vsel_addr
= PALMAS_LDO5_VOLTAGE
,
114 .ctrl_addr
= PALMAS_LDO5_CTRL
,
118 .vsel_addr
= PALMAS_LDO6_VOLTAGE
,
119 .ctrl_addr
= PALMAS_LDO6_CTRL
,
123 .vsel_addr
= PALMAS_LDO7_VOLTAGE
,
124 .ctrl_addr
= PALMAS_LDO7_CTRL
,
128 .vsel_addr
= PALMAS_LDO8_VOLTAGE
,
129 .ctrl_addr
= PALMAS_LDO8_CTRL
,
133 .vsel_addr
= PALMAS_LDO9_VOLTAGE
,
134 .ctrl_addr
= PALMAS_LDO9_CTRL
,
138 .vsel_addr
= PALMAS_LDOLN_VOLTAGE
,
139 .ctrl_addr
= PALMAS_LDOLN_CTRL
,
143 .vsel_addr
= PALMAS_LDOUSB_VOLTAGE
,
144 .ctrl_addr
= PALMAS_LDOUSB_CTRL
,
148 #define SMPS_CTRL_MODE_OFF 0x00
149 #define SMPS_CTRL_MODE_ON 0x01
150 #define SMPS_CTRL_MODE_ECO 0x02
151 #define SMPS_CTRL_MODE_PWM 0x03
153 /* These values are derived from the data sheet. And are the number of steps
154 * where there is a voltage change, the ranges at beginning and end of register
155 * max/min values where there are no change are ommitted.
157 * So they are basically (maxV-minV)/stepV
159 #define PALMAS_SMPS_NUM_VOLTAGES 116
160 #define PALMAS_SMPS10_NUM_VOLTAGES 2
161 #define PALMAS_LDO_NUM_VOLTAGES 50
163 #define SMPS10_VSEL (1<<3)
164 #define SMPS10_BOOST_EN (1<<2)
165 #define SMPS10_BYPASS_EN (1<<1)
166 #define SMPS10_SWITCH_EN (1<<0)
168 #define REGULATOR_SLAVE 0
170 static int palmas_smps_read(struct palmas
*palmas
, unsigned int reg
,
175 addr
= PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE
, reg
);
177 return regmap_read(palmas
->regmap
[REGULATOR_SLAVE
], addr
, dest
);
180 static int palmas_smps_write(struct palmas
*palmas
, unsigned int reg
,
185 addr
= PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE
, reg
);
187 return regmap_write(palmas
->regmap
[REGULATOR_SLAVE
], addr
, value
);
190 static int palmas_ldo_read(struct palmas
*palmas
, unsigned int reg
,
195 addr
= PALMAS_BASE_TO_REG(PALMAS_LDO_BASE
, reg
);
197 return regmap_read(palmas
->regmap
[REGULATOR_SLAVE
], addr
, dest
);
200 static int palmas_ldo_write(struct palmas
*palmas
, unsigned int reg
,
205 addr
= PALMAS_BASE_TO_REG(PALMAS_LDO_BASE
, reg
);
207 return regmap_write(palmas
->regmap
[REGULATOR_SLAVE
], addr
, value
);
210 static int palmas_is_enabled_smps(struct regulator_dev
*dev
)
212 struct palmas_pmic
*pmic
= rdev_get_drvdata(dev
);
213 int id
= rdev_get_id(dev
);
216 palmas_smps_read(pmic
->palmas
, palmas_regs_info
[id
].ctrl_addr
, ®
);
218 reg
&= PALMAS_SMPS12_CTRL_STATUS_MASK
;
219 reg
>>= PALMAS_SMPS12_CTRL_STATUS_SHIFT
;
224 static int palmas_enable_smps(struct regulator_dev
*dev
)
226 struct palmas_pmic
*pmic
= rdev_get_drvdata(dev
);
227 int id
= rdev_get_id(dev
);
230 palmas_smps_read(pmic
->palmas
, palmas_regs_info
[id
].ctrl_addr
, ®
);
232 reg
&= ~PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK
;
233 reg
|= SMPS_CTRL_MODE_ON
;
235 palmas_smps_write(pmic
->palmas
, palmas_regs_info
[id
].ctrl_addr
, reg
);
240 static int palmas_disable_smps(struct regulator_dev
*dev
)
242 struct palmas_pmic
*pmic
= rdev_get_drvdata(dev
);
243 int id
= rdev_get_id(dev
);
246 palmas_smps_read(pmic
->palmas
, palmas_regs_info
[id
].ctrl_addr
, ®
);
248 reg
&= ~PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK
;
250 palmas_smps_write(pmic
->palmas
, palmas_regs_info
[id
].ctrl_addr
, reg
);
256 static int palmas_set_mode_smps(struct regulator_dev
*dev
, unsigned int mode
)
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
, ®
);
263 reg
&= ~PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK
;
266 case REGULATOR_MODE_NORMAL
:
267 reg
|= SMPS_CTRL_MODE_ON
;
269 case REGULATOR_MODE_IDLE
:
270 reg
|= SMPS_CTRL_MODE_ECO
;
272 case REGULATOR_MODE_FAST
:
273 reg
|= SMPS_CTRL_MODE_PWM
;
278 palmas_smps_write(pmic
->palmas
, palmas_regs_info
[id
].ctrl_addr
, reg
);
283 static unsigned int palmas_get_mode_smps(struct regulator_dev
*dev
)
285 struct palmas_pmic
*pmic
= rdev_get_drvdata(dev
);
286 int id
= rdev_get_id(dev
);
289 palmas_smps_read(pmic
->palmas
, palmas_regs_info
[id
].ctrl_addr
, ®
);
290 reg
&= PALMAS_SMPS12_CTRL_STATUS_MASK
;
291 reg
>>= PALMAS_SMPS12_CTRL_STATUS_SHIFT
;
294 case SMPS_CTRL_MODE_ON
:
295 return REGULATOR_MODE_NORMAL
;
296 case SMPS_CTRL_MODE_ECO
:
297 return REGULATOR_MODE_IDLE
;
298 case SMPS_CTRL_MODE_PWM
:
299 return REGULATOR_MODE_FAST
;
305 static int palmas_list_voltage_smps(struct regulator_dev
*dev
,
308 struct palmas_pmic
*pmic
= rdev_get_drvdata(dev
);
309 int id
= rdev_get_id(dev
);
312 /* Read the multiplier set in VSEL register to return
313 * the correct voltage.
320 else if (selector
< 6)
321 return 500000 * mult
;
323 /* Voltage is linear mapping starting from selector 6,
324 * volt = (0.49V + ((selector - 5) * 0.01V)) * RANGE
325 * RANGE is either x1 or x2
327 return (490000 + ((selector
- 5) * 10000)) * mult
;
330 static int palmas_map_voltage_smps(struct regulator_dev
*rdev
,
331 int min_uV
, int max_uV
)
333 struct palmas_pmic
*pmic
= rdev_get_drvdata(rdev
);
334 int id
= rdev_get_id(rdev
);
340 if (pmic
->range
[id
]) { /* RANGE is x2 */
341 if (min_uV
< 1000000)
343 ret
= DIV_ROUND_UP(min_uV
- 1000000, 20000) + 6;
344 } else { /* RANGE is x1 */
347 ret
= DIV_ROUND_UP(min_uV
- 500000, 10000) + 6;
350 /* Map back into a voltage to verify we're still in bounds */
351 voltage
= palmas_list_voltage_smps(rdev
, ret
);
352 if (voltage
< min_uV
|| voltage
> max_uV
)
358 static struct regulator_ops palmas_ops_smps
= {
359 .is_enabled
= palmas_is_enabled_smps
,
360 .enable
= palmas_enable_smps
,
361 .disable
= palmas_disable_smps
,
362 .set_mode
= palmas_set_mode_smps
,
363 .get_mode
= palmas_get_mode_smps
,
364 .get_voltage_sel
= regulator_get_voltage_sel_regmap
,
365 .set_voltage_sel
= regulator_set_voltage_sel_regmap
,
366 .list_voltage
= palmas_list_voltage_smps
,
367 .map_voltage
= palmas_map_voltage_smps
,
370 static struct regulator_ops palmas_ops_smps10
= {
371 .is_enabled
= regulator_is_enabled_regmap
,
372 .enable
= regulator_enable_regmap
,
373 .disable
= regulator_disable_regmap
,
374 .get_voltage_sel
= regulator_get_voltage_sel_regmap
,
375 .set_voltage_sel
= regulator_set_voltage_sel_regmap
,
376 .list_voltage
= regulator_list_voltage_linear
,
377 .map_voltage
= regulator_map_voltage_linear
,
380 static int palmas_is_enabled_ldo(struct regulator_dev
*dev
)
382 struct palmas_pmic
*pmic
= rdev_get_drvdata(dev
);
383 int id
= rdev_get_id(dev
);
386 palmas_ldo_read(pmic
->palmas
, palmas_regs_info
[id
].ctrl_addr
, ®
);
388 reg
&= PALMAS_LDO1_CTRL_STATUS
;
393 static struct regulator_ops palmas_ops_ldo
= {
394 .is_enabled
= palmas_is_enabled_ldo
,
395 .enable
= regulator_enable_regmap
,
396 .disable
= regulator_disable_regmap
,
397 .get_voltage_sel
= regulator_get_voltage_sel_regmap
,
398 .set_voltage_sel
= regulator_set_voltage_sel_regmap
,
399 .list_voltage
= regulator_list_voltage_linear
,
400 .map_voltage
= regulator_map_voltage_linear
,
404 * setup the hardware based sleep configuration of the SMPS/LDO regulators
405 * from the platform data. This is different to the software based control
406 * supported by the regulator framework as it is controlled by toggling
407 * pins on the PMIC such as PREQ, SYSEN, ...
409 static int palmas_smps_init(struct palmas
*palmas
, int id
,
410 struct palmas_reg_init
*reg_init
)
416 addr
= palmas_regs_info
[id
].ctrl_addr
;
418 ret
= palmas_smps_read(palmas
, addr
, ®
);
423 case PALMAS_REG_SMPS10
:
424 if (reg_init
->mode_sleep
) {
425 reg
&= ~PALMAS_SMPS10_CTRL_MODE_SLEEP_MASK
;
426 reg
|= reg_init
->mode_sleep
<<
427 PALMAS_SMPS10_CTRL_MODE_SLEEP_SHIFT
;
431 if (reg_init
->warm_reset
)
432 reg
|= PALMAS_SMPS12_CTRL_WR_S
;
434 if (reg_init
->roof_floor
)
435 reg
|= PALMAS_SMPS12_CTRL_ROOF_FLOOR_EN
;
437 if (reg_init
->mode_sleep
) {
438 reg
&= ~PALMAS_SMPS12_CTRL_MODE_SLEEP_MASK
;
439 reg
|= reg_init
->mode_sleep
<<
440 PALMAS_SMPS12_CTRL_MODE_SLEEP_SHIFT
;
444 ret
= palmas_smps_write(palmas
, addr
, reg
);
448 if (palmas_regs_info
[id
].tstep_addr
&& reg_init
->tstep
) {
449 addr
= palmas_regs_info
[id
].tstep_addr
;
451 reg
= reg_init
->tstep
& PALMAS_SMPS12_TSTEP_TSTEP_MASK
;
453 ret
= palmas_smps_write(palmas
, addr
, reg
);
458 if (palmas_regs_info
[id
].vsel_addr
&& reg_init
->vsel
) {
459 addr
= palmas_regs_info
[id
].vsel_addr
;
461 reg
= reg_init
->vsel
;
463 ret
= palmas_smps_write(palmas
, addr
, reg
);
472 static int palmas_ldo_init(struct palmas
*palmas
, int id
,
473 struct palmas_reg_init
*reg_init
)
479 addr
= palmas_regs_info
[id
].ctrl_addr
;
481 ret
= palmas_ldo_read(palmas
, addr
, ®
);
485 if (reg_init
->warm_reset
)
486 reg
|= PALMAS_LDO1_CTRL_WR_S
;
488 if (reg_init
->mode_sleep
)
489 reg
|= PALMAS_LDO1_CTRL_MODE_SLEEP
;
491 ret
= palmas_ldo_write(palmas
, addr
, reg
);
498 static struct of_regulator_match palmas_matches
[] = {
499 { .name
= "smps12", },
500 { .name
= "smps123", },
501 { .name
= "smps3", },
502 { .name
= "smps45", },
503 { .name
= "smps457", },
504 { .name
= "smps6", },
505 { .name
= "smps7", },
506 { .name
= "smps8", },
507 { .name
= "smps9", },
508 { .name
= "smps10", },
518 { .name
= "ldoln", },
519 { .name
= "ldousb", },
522 static void palmas_dt_to_pdata(struct device
*dev
,
523 struct device_node
*node
,
524 struct palmas_pmic_platform_data
*pdata
)
526 struct device_node
*regulators
;
530 regulators
= of_find_node_by_name(node
, "regulators");
532 dev_info(dev
, "regulator node not found\n");
536 ret
= of_regulator_match(dev
, regulators
, palmas_matches
,
539 dev_err(dev
, "Error parsing regulator init data: %d\n", ret
);
543 for (idx
= 0; idx
< PALMAS_NUM_REGS
; idx
++) {
544 if (!palmas_matches
[idx
].init_data
||
545 !palmas_matches
[idx
].of_node
)
548 pdata
->reg_data
[idx
] = palmas_matches
[idx
].init_data
;
550 pdata
->reg_init
[idx
] = devm_kzalloc(dev
,
551 sizeof(struct palmas_reg_init
), GFP_KERNEL
);
553 ret
= of_property_read_u32(palmas_matches
[idx
].of_node
,
554 "ti,warm_reset", &prop
);
556 pdata
->reg_init
[idx
]->warm_reset
= prop
;
558 ret
= of_property_read_u32(palmas_matches
[idx
].of_node
,
559 "ti,roof_floor", &prop
);
561 pdata
->reg_init
[idx
]->roof_floor
= prop
;
563 ret
= of_property_read_u32(palmas_matches
[idx
].of_node
,
564 "ti,mode_sleep", &prop
);
566 pdata
->reg_init
[idx
]->mode_sleep
= prop
;
568 ret
= of_property_read_u32(palmas_matches
[idx
].of_node
,
569 "ti,warm_reset", &prop
);
571 pdata
->reg_init
[idx
]->warm_reset
= prop
;
573 ret
= of_property_read_u32(palmas_matches
[idx
].of_node
,
576 pdata
->reg_init
[idx
]->tstep
= prop
;
578 ret
= of_property_read_u32(palmas_matches
[idx
].of_node
,
581 pdata
->reg_init
[idx
]->vsel
= prop
;
584 ret
= of_property_read_u32(node
, "ti,ldo6_vibrator", &prop
);
586 pdata
->ldo6_vibrator
= prop
;
590 static int palmas_probe(struct platform_device
*pdev
)
592 struct palmas
*palmas
= dev_get_drvdata(pdev
->dev
.parent
);
593 struct palmas_pmic_platform_data
*pdata
= pdev
->dev
.platform_data
;
594 struct device_node
*node
= pdev
->dev
.of_node
;
595 struct regulator_dev
*rdev
;
596 struct regulator_config config
= { };
597 struct palmas_pmic
*pmic
;
598 struct palmas_reg_init
*reg_init
;
600 unsigned int addr
, reg
;
602 if (node
&& !pdata
) {
603 pdata
= devm_kzalloc(&pdev
->dev
, sizeof(*pdata
), GFP_KERNEL
);
608 palmas_dt_to_pdata(&pdev
->dev
, node
, pdata
);
611 pmic
= devm_kzalloc(&pdev
->dev
, sizeof(*pmic
), GFP_KERNEL
);
615 pmic
->dev
= &pdev
->dev
;
616 pmic
->palmas
= palmas
;
618 platform_set_drvdata(pdev
, pmic
);
620 ret
= palmas_smps_read(palmas
, PALMAS_SMPS_CTRL
, ®
);
624 if (reg
& PALMAS_SMPS_CTRL_SMPS12_SMPS123_EN
)
627 if (reg
& PALMAS_SMPS_CTRL_SMPS45_SMPS457_EN
)
630 config
.regmap
= palmas
->regmap
[REGULATOR_SLAVE
];
631 config
.dev
= &pdev
->dev
;
632 config
.driver_data
= pmic
;
634 for (id
= 0; id
< PALMAS_REG_LDO1
; id
++) {
637 * Miss out regulators which are not available due
638 * to slaving configurations.
641 case PALMAS_REG_SMPS12
:
642 case PALMAS_REG_SMPS3
:
646 case PALMAS_REG_SMPS123
:
650 case PALMAS_REG_SMPS45
:
651 case PALMAS_REG_SMPS7
:
655 case PALMAS_REG_SMPS457
:
660 /* Initialise sleep/init values from platform data */
661 if (pdata
&& pdata
->reg_init
[id
]) {
662 reg_init
= pdata
->reg_init
[id
];
663 ret
= palmas_smps_init(palmas
, id
, reg_init
);
665 goto err_unregister_regulator
;
668 /* Register the regulators */
669 pmic
->desc
[id
].name
= palmas_regs_info
[id
].name
;
670 pmic
->desc
[id
].id
= id
;
673 case PALMAS_REG_SMPS10
:
674 pmic
->desc
[id
].n_voltages
= PALMAS_SMPS10_NUM_VOLTAGES
;
675 pmic
->desc
[id
].ops
= &palmas_ops_smps10
;
676 pmic
->desc
[id
].vsel_reg
=
677 PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE
,
679 pmic
->desc
[id
].vsel_mask
= SMPS10_VSEL
;
680 pmic
->desc
[id
].enable_reg
=
681 PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE
,
682 PALMAS_SMPS10_STATUS
);
683 pmic
->desc
[id
].enable_mask
= SMPS10_BOOST_EN
;
684 pmic
->desc
[id
].min_uV
= 3750000;
685 pmic
->desc
[id
].uV_step
= 1250000;
689 * Read and store the RANGE bit for later use
690 * This must be done before regulator is probed,
691 * otherwise we error in probe with unsupportable ranges.
693 addr
= palmas_regs_info
[id
].vsel_addr
;
695 ret
= palmas_smps_read(pmic
->palmas
, addr
, ®
);
697 goto err_unregister_regulator
;
698 if (reg
& PALMAS_SMPS12_VOLTAGE_RANGE
)
701 pmic
->desc
[id
].ops
= &palmas_ops_smps
;
702 pmic
->desc
[id
].n_voltages
= PALMAS_SMPS_NUM_VOLTAGES
;
703 pmic
->desc
[id
].vsel_reg
=
704 PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE
,
705 palmas_regs_info
[id
].vsel_addr
);
706 pmic
->desc
[id
].vsel_mask
=
707 PALMAS_SMPS12_VOLTAGE_VSEL_MASK
;
710 pmic
->desc
[id
].type
= REGULATOR_VOLTAGE
;
711 pmic
->desc
[id
].owner
= THIS_MODULE
;
714 config
.init_data
= pdata
->reg_data
[id
];
716 config
.init_data
= NULL
;
718 config
.of_node
= palmas_matches
[id
].of_node
;
720 rdev
= regulator_register(&pmic
->desc
[id
], &config
);
723 "failed to register %s regulator\n",
726 goto err_unregister_regulator
;
729 /* Save regulator for cleanup */
730 pmic
->rdev
[id
] = rdev
;
733 /* Start this loop from the id left from previous loop */
734 for (; id
< PALMAS_NUM_REGS
; id
++) {
736 /* Miss out regulators which are not available due
737 * to alternate functions.
740 /* Register the regulators */
741 pmic
->desc
[id
].name
= palmas_regs_info
[id
].name
;
742 pmic
->desc
[id
].id
= id
;
743 pmic
->desc
[id
].n_voltages
= PALMAS_LDO_NUM_VOLTAGES
;
745 pmic
->desc
[id
].ops
= &palmas_ops_ldo
;
747 pmic
->desc
[id
].type
= REGULATOR_VOLTAGE
;
748 pmic
->desc
[id
].owner
= THIS_MODULE
;
749 pmic
->desc
[id
].min_uV
= 900000;
750 pmic
->desc
[id
].uV_step
= 50000;
751 pmic
->desc
[id
].linear_min_sel
= 1;
752 pmic
->desc
[id
].vsel_reg
= PALMAS_BASE_TO_REG(PALMAS_LDO_BASE
,
753 palmas_regs_info
[id
].vsel_addr
);
754 pmic
->desc
[id
].vsel_mask
= PALMAS_LDO1_VOLTAGE_VSEL_MASK
;
755 pmic
->desc
[id
].enable_reg
= PALMAS_BASE_TO_REG(PALMAS_LDO_BASE
,
756 palmas_regs_info
[id
].ctrl_addr
);
757 pmic
->desc
[id
].enable_mask
= PALMAS_LDO1_CTRL_MODE_ACTIVE
;
760 config
.init_data
= pdata
->reg_data
[id
];
762 config
.init_data
= NULL
;
764 config
.of_node
= palmas_matches
[id
].of_node
;
766 rdev
= regulator_register(&pmic
->desc
[id
], &config
);
769 "failed to register %s regulator\n",
772 goto err_unregister_regulator
;
775 /* Save regulator for cleanup */
776 pmic
->rdev
[id
] = rdev
;
778 /* Initialise sleep/init values from platform data */
780 reg_init
= pdata
->reg_init
[id
];
782 ret
= palmas_ldo_init(palmas
, id
, reg_init
);
784 regulator_unregister(pmic
->rdev
[id
]);
785 goto err_unregister_regulator
;
793 err_unregister_regulator
:
795 regulator_unregister(pmic
->rdev
[id
]);
799 static int palmas_remove(struct platform_device
*pdev
)
801 struct palmas_pmic
*pmic
= platform_get_drvdata(pdev
);
804 for (id
= 0; id
< PALMAS_NUM_REGS
; id
++)
805 regulator_unregister(pmic
->rdev
[id
]);
809 static struct of_device_id __devinitdata of_palmas_match_tbl
[] = {
810 { .compatible
= "ti,palmas-pmic", },
814 static struct platform_driver palmas_driver
= {
816 .name
= "palmas-pmic",
817 .of_match_table
= of_palmas_match_tbl
,
818 .owner
= THIS_MODULE
,
820 .probe
= palmas_probe
,
821 .remove
= palmas_remove
,
824 static int __init
palmas_init(void)
826 return platform_driver_register(&palmas_driver
);
828 subsys_initcall(palmas_init
);
830 static void __exit
palmas_exit(void)
832 platform_driver_unregister(&palmas_driver
);
834 module_exit(palmas_exit
);
836 MODULE_AUTHOR("Graeme Gregory <gg@slimlogic.co.uk>");
837 MODULE_DESCRIPTION("Palmas voltage regulator driver");
838 MODULE_LICENSE("GPL");
839 MODULE_ALIAS("platform:palmas-pmic");
840 MODULE_DEVICE_TABLE(of
, of_palmas_match_tbl
);