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>
33 static const struct regs_info palmas_regs_info
[] = {
36 .vsel_addr
= PALMAS_SMPS12_VOLTAGE
,
37 .ctrl_addr
= PALMAS_SMPS12_CTRL
,
38 .tstep_addr
= PALMAS_SMPS12_TSTEP
,
42 .vsel_addr
= PALMAS_SMPS12_VOLTAGE
,
43 .ctrl_addr
= PALMAS_SMPS12_CTRL
,
44 .tstep_addr
= PALMAS_SMPS12_TSTEP
,
48 .vsel_addr
= PALMAS_SMPS3_VOLTAGE
,
49 .ctrl_addr
= PALMAS_SMPS3_CTRL
,
53 .vsel_addr
= PALMAS_SMPS45_VOLTAGE
,
54 .ctrl_addr
= PALMAS_SMPS45_CTRL
,
55 .tstep_addr
= PALMAS_SMPS45_TSTEP
,
59 .vsel_addr
= PALMAS_SMPS45_VOLTAGE
,
60 .ctrl_addr
= PALMAS_SMPS45_CTRL
,
61 .tstep_addr
= PALMAS_SMPS45_TSTEP
,
65 .vsel_addr
= PALMAS_SMPS6_VOLTAGE
,
66 .ctrl_addr
= PALMAS_SMPS6_CTRL
,
67 .tstep_addr
= PALMAS_SMPS6_TSTEP
,
71 .vsel_addr
= PALMAS_SMPS7_VOLTAGE
,
72 .ctrl_addr
= PALMAS_SMPS7_CTRL
,
76 .vsel_addr
= PALMAS_SMPS8_VOLTAGE
,
77 .ctrl_addr
= PALMAS_SMPS8_CTRL
,
78 .tstep_addr
= PALMAS_SMPS8_TSTEP
,
82 .vsel_addr
= PALMAS_SMPS9_VOLTAGE
,
83 .ctrl_addr
= PALMAS_SMPS9_CTRL
,
90 .vsel_addr
= PALMAS_LDO1_VOLTAGE
,
91 .ctrl_addr
= PALMAS_LDO1_CTRL
,
95 .vsel_addr
= PALMAS_LDO2_VOLTAGE
,
96 .ctrl_addr
= PALMAS_LDO2_CTRL
,
100 .vsel_addr
= PALMAS_LDO3_VOLTAGE
,
101 .ctrl_addr
= PALMAS_LDO3_CTRL
,
105 .vsel_addr
= PALMAS_LDO4_VOLTAGE
,
106 .ctrl_addr
= PALMAS_LDO4_CTRL
,
110 .vsel_addr
= PALMAS_LDO5_VOLTAGE
,
111 .ctrl_addr
= PALMAS_LDO5_CTRL
,
115 .vsel_addr
= PALMAS_LDO6_VOLTAGE
,
116 .ctrl_addr
= PALMAS_LDO6_CTRL
,
120 .vsel_addr
= PALMAS_LDO7_VOLTAGE
,
121 .ctrl_addr
= PALMAS_LDO7_CTRL
,
125 .vsel_addr
= PALMAS_LDO8_VOLTAGE
,
126 .ctrl_addr
= PALMAS_LDO8_CTRL
,
130 .vsel_addr
= PALMAS_LDO9_VOLTAGE
,
131 .ctrl_addr
= PALMAS_LDO9_CTRL
,
135 .vsel_addr
= PALMAS_LDOLN_VOLTAGE
,
136 .ctrl_addr
= PALMAS_LDOLN_CTRL
,
140 .vsel_addr
= PALMAS_LDOUSB_VOLTAGE
,
141 .ctrl_addr
= PALMAS_LDOUSB_CTRL
,
145 #define SMPS_CTRL_MODE_OFF 0x00
146 #define SMPS_CTRL_MODE_ON 0x01
147 #define SMPS_CTRL_MODE_ECO 0x02
148 #define SMPS_CTRL_MODE_PWM 0x03
150 /* These values are derived from the data sheet. And are the number of steps
151 * where there is a voltage change, the ranges at beginning and end of register
152 * max/min values where there are no change are ommitted.
154 * So they are basically (maxV-minV)/stepV
156 #define PALMAS_SMPS_NUM_VOLTAGES 116
157 #define PALMAS_SMPS10_NUM_VOLTAGES 2
158 #define PALMAS_LDO_NUM_VOLTAGES 50
160 #define SMPS10_VSEL (1<<3)
161 #define SMPS10_BOOST_EN (1<<2)
162 #define SMPS10_BYPASS_EN (1<<1)
163 #define SMPS10_SWITCH_EN (1<<0)
165 #define REGULATOR_SLAVE 0
167 static int palmas_smps_read(struct palmas
*palmas
, unsigned int reg
,
172 addr
= PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE
, reg
);
174 return regmap_read(palmas
->regmap
[REGULATOR_SLAVE
], addr
, dest
);
177 static int palmas_smps_write(struct palmas
*palmas
, unsigned int reg
,
182 addr
= PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE
, reg
);
184 return regmap_write(palmas
->regmap
[REGULATOR_SLAVE
], addr
, value
);
187 static int palmas_ldo_read(struct palmas
*palmas
, unsigned int reg
,
192 addr
= PALMAS_BASE_TO_REG(PALMAS_LDO_BASE
, reg
);
194 return regmap_read(palmas
->regmap
[REGULATOR_SLAVE
], addr
, dest
);
197 static int palmas_ldo_write(struct palmas
*palmas
, unsigned int reg
,
202 addr
= PALMAS_BASE_TO_REG(PALMAS_LDO_BASE
, reg
);
204 return regmap_write(palmas
->regmap
[REGULATOR_SLAVE
], addr
, value
);
207 static int palmas_is_enabled_smps(struct regulator_dev
*dev
)
209 struct palmas_pmic
*pmic
= rdev_get_drvdata(dev
);
210 int id
= rdev_get_id(dev
);
213 palmas_smps_read(pmic
->palmas
, palmas_regs_info
[id
].ctrl_addr
, ®
);
215 reg
&= PALMAS_SMPS12_CTRL_STATUS_MASK
;
216 reg
>>= PALMAS_SMPS12_CTRL_STATUS_SHIFT
;
221 static int palmas_enable_smps(struct regulator_dev
*dev
)
223 struct palmas_pmic
*pmic
= rdev_get_drvdata(dev
);
224 int id
= rdev_get_id(dev
);
227 palmas_smps_read(pmic
->palmas
, palmas_regs_info
[id
].ctrl_addr
, ®
);
229 reg
&= ~PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK
;
230 reg
|= SMPS_CTRL_MODE_ON
;
232 palmas_smps_write(pmic
->palmas
, palmas_regs_info
[id
].ctrl_addr
, reg
);
237 static int palmas_disable_smps(struct regulator_dev
*dev
)
239 struct palmas_pmic
*pmic
= rdev_get_drvdata(dev
);
240 int id
= rdev_get_id(dev
);
243 palmas_smps_read(pmic
->palmas
, palmas_regs_info
[id
].ctrl_addr
, ®
);
245 reg
&= ~PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK
;
247 palmas_smps_write(pmic
->palmas
, palmas_regs_info
[id
].ctrl_addr
, reg
);
253 static int palmas_set_mode_smps(struct regulator_dev
*dev
, unsigned int mode
)
255 struct palmas_pmic
*pmic
= rdev_get_drvdata(dev
);
256 int id
= rdev_get_id(dev
);
259 palmas_smps_read(pmic
->palmas
, palmas_regs_info
[id
].ctrl_addr
, ®
);
260 reg
&= ~PALMAS_SMPS12_CTRL_STATUS_MASK
;
261 reg
>>= PALMAS_SMPS12_CTRL_STATUS_SHIFT
;
264 case REGULATOR_MODE_NORMAL
:
265 reg
|= SMPS_CTRL_MODE_ON
;
267 case REGULATOR_MODE_IDLE
:
268 reg
|= SMPS_CTRL_MODE_ECO
;
270 case REGULATOR_MODE_FAST
:
271 reg
|= SMPS_CTRL_MODE_PWM
;
276 palmas_smps_write(pmic
->palmas
, palmas_regs_info
[id
].ctrl_addr
, reg
);
281 static unsigned int palmas_get_mode_smps(struct regulator_dev
*dev
)
283 struct palmas_pmic
*pmic
= rdev_get_drvdata(dev
);
284 int id
= rdev_get_id(dev
);
287 palmas_smps_read(pmic
->palmas
, palmas_regs_info
[id
].ctrl_addr
, ®
);
288 reg
&= PALMAS_SMPS12_CTRL_STATUS_MASK
;
289 reg
>>= PALMAS_SMPS12_CTRL_STATUS_SHIFT
;
292 case SMPS_CTRL_MODE_ON
:
293 return REGULATOR_MODE_NORMAL
;
294 case SMPS_CTRL_MODE_ECO
:
295 return REGULATOR_MODE_IDLE
;
296 case SMPS_CTRL_MODE_PWM
:
297 return REGULATOR_MODE_FAST
;
303 static int palmas_list_voltage_smps(struct regulator_dev
*dev
,
306 struct palmas_pmic
*pmic
= rdev_get_drvdata(dev
);
307 int id
= rdev_get_id(dev
);
313 /* Read the multiplier set in VSEL register to return
314 * the correct voltage.
319 /* Voltage is (0.49V + (selector * 0.01V)) * RANGE
320 * as defined in data sheet. RANGE is either x1 or x2
322 return (490000 + (selector
* 10000)) * mult
;
325 static int palmas_get_voltage_smps_sel(struct regulator_dev
*dev
)
327 struct palmas_pmic
*pmic
= rdev_get_drvdata(dev
);
328 int id
= rdev_get_id(dev
);
333 addr
= palmas_regs_info
[id
].vsel_addr
;
335 palmas_smps_read(pmic
->palmas
, addr
, ®
);
337 selector
= reg
& PALMAS_SMPS12_VOLTAGE_VSEL_MASK
;
339 /* Adjust selector to match list_voltage ranges */
340 if ((selector
> 0) && (selector
< 6))
351 static int palmas_set_voltage_smps_sel(struct regulator_dev
*dev
,
354 struct palmas_pmic
*pmic
= rdev_get_drvdata(dev
);
355 int id
= rdev_get_id(dev
);
356 unsigned int reg
= 0;
359 addr
= palmas_regs_info
[id
].vsel_addr
;
361 /* Make sure we don't change the value of RANGE */
363 reg
|= PALMAS_SMPS12_VOLTAGE_RANGE
;
365 /* Adjust the linux selector into range used in VSEL register */
369 palmas_smps_write(pmic
->palmas
, addr
, reg
);
374 static int palmas_map_voltage_smps(struct regulator_dev
*rdev
,
375 int min_uV
, int max_uV
)
379 ret
= ((min_uV
- 500000) / 10000) + 1;
383 /* Map back into a voltage to verify we're still in bounds */
384 voltage
= palmas_list_voltage_smps(rdev
, ret
);
385 if (voltage
< min_uV
|| voltage
> max_uV
)
391 static struct regulator_ops palmas_ops_smps
= {
392 .is_enabled
= palmas_is_enabled_smps
,
393 .enable
= palmas_enable_smps
,
394 .disable
= palmas_disable_smps
,
395 .set_mode
= palmas_set_mode_smps
,
396 .get_mode
= palmas_get_mode_smps
,
397 .get_voltage_sel
= palmas_get_voltage_smps_sel
,
398 .set_voltage_sel
= palmas_set_voltage_smps_sel
,
399 .list_voltage
= palmas_list_voltage_smps
,
400 .map_voltage
= palmas_map_voltage_smps
,
403 static int palmas_list_voltage_smps10(struct regulator_dev
*dev
,
406 return 3750000 + (selector
* 1250000);
409 static struct regulator_ops palmas_ops_smps10
= {
410 .is_enabled
= regulator_is_enabled_regmap
,
411 .enable
= regulator_enable_regmap
,
412 .disable
= regulator_disable_regmap
,
413 .get_voltage_sel
= regulator_get_voltage_sel_regmap
,
414 .set_voltage_sel
= regulator_set_voltage_sel_regmap
,
415 .list_voltage
= palmas_list_voltage_smps10
,
418 static int palmas_is_enabled_ldo(struct regulator_dev
*dev
)
420 struct palmas_pmic
*pmic
= rdev_get_drvdata(dev
);
421 int id
= rdev_get_id(dev
);
424 palmas_ldo_read(pmic
->palmas
, palmas_regs_info
[id
].ctrl_addr
, ®
);
426 reg
&= PALMAS_LDO1_CTRL_STATUS
;
431 static int palmas_list_voltage_ldo(struct regulator_dev
*dev
,
437 /* voltage is 0.85V + (selector * 0.05v) */
438 return 850000 + (selector
* 50000);
441 static int palmas_get_voltage_ldo_sel(struct regulator_dev
*dev
)
443 struct palmas_pmic
*pmic
= rdev_get_drvdata(dev
);
444 int id
= rdev_get_id(dev
);
449 addr
= palmas_regs_info
[id
].vsel_addr
;
451 palmas_ldo_read(pmic
->palmas
, addr
, ®
);
453 selector
= reg
& PALMAS_LDO1_VOLTAGE_VSEL_MASK
;
455 /* Adjust selector to match list_voltage ranges */
462 static int palmas_set_voltage_ldo_sel(struct regulator_dev
*dev
,
465 struct palmas_pmic
*pmic
= rdev_get_drvdata(dev
);
466 int id
= rdev_get_id(dev
);
467 unsigned int reg
= 0;
470 addr
= palmas_regs_info
[id
].vsel_addr
;
474 palmas_ldo_write(pmic
->palmas
, addr
, reg
);
479 static int palmas_map_voltage_ldo(struct regulator_dev
*rdev
,
480 int min_uV
, int max_uV
)
484 ret
= ((min_uV
- 900000) / 50000) + 1;
488 /* Map back into a voltage to verify we're still in bounds */
489 voltage
= palmas_list_voltage_ldo(rdev
, ret
);
490 if (voltage
< min_uV
|| voltage
> max_uV
)
496 static struct regulator_ops palmas_ops_ldo
= {
497 .is_enabled
= palmas_is_enabled_ldo
,
498 .enable
= regulator_enable_regmap
,
499 .disable
= regulator_disable_regmap
,
500 .get_voltage_sel
= palmas_get_voltage_ldo_sel
,
501 .set_voltage_sel
= palmas_set_voltage_ldo_sel
,
502 .list_voltage
= palmas_list_voltage_ldo
,
503 .map_voltage
= palmas_map_voltage_ldo
,
507 * setup the hardware based sleep configuration of the SMPS/LDO regulators
508 * from the platform data. This is different to the software based control
509 * supported by the regulator framework as it is controlled by toggling
510 * pins on the PMIC such as PREQ, SYSEN, ...
512 static int palmas_smps_init(struct palmas
*palmas
, int id
,
513 struct palmas_reg_init
*reg_init
)
519 addr
= palmas_regs_info
[id
].ctrl_addr
;
521 ret
= palmas_smps_read(palmas
, addr
, ®
);
525 if (id
!= PALMAS_REG_SMPS10
) {
526 if (reg_init
->warm_reset
)
527 reg
|= PALMAS_SMPS12_CTRL_WR_S
;
529 if (reg_init
->roof_floor
)
530 reg
|= PALMAS_SMPS12_CTRL_ROOF_FLOOR_EN
;
532 if (reg_init
->mode_sleep
) {
533 reg
&= ~PALMAS_SMPS12_CTRL_MODE_SLEEP_MASK
;
534 reg
|= reg_init
->mode_sleep
<<
535 PALMAS_SMPS12_CTRL_MODE_SLEEP_SHIFT
;
538 if (reg_init
->mode_sleep
) {
539 reg
&= ~PALMAS_SMPS10_CTRL_MODE_SLEEP_MASK
;
540 reg
|= reg_init
->mode_sleep
<<
541 PALMAS_SMPS10_CTRL_MODE_SLEEP_SHIFT
;
545 ret
= palmas_smps_write(palmas
, addr
, reg
);
549 if (palmas_regs_info
[id
].tstep_addr
&& reg_init
->tstep
) {
550 addr
= palmas_regs_info
[id
].tstep_addr
;
552 reg
= reg_init
->tstep
& PALMAS_SMPS12_TSTEP_TSTEP_MASK
;
554 ret
= palmas_smps_write(palmas
, addr
, reg
);
559 if (palmas_regs_info
[id
].vsel_addr
&& reg_init
->vsel
) {
560 addr
= palmas_regs_info
[id
].vsel_addr
;
562 reg
= reg_init
->vsel
;
564 ret
= palmas_smps_write(palmas
, addr
, reg
);
573 static int palmas_ldo_init(struct palmas
*palmas
, int id
,
574 struct palmas_reg_init
*reg_init
)
580 addr
= palmas_regs_info
[id
].ctrl_addr
;
582 ret
= palmas_smps_read(palmas
, addr
, ®
);
586 if (reg_init
->warm_reset
)
587 reg
|= PALMAS_LDO1_CTRL_WR_S
;
589 if (reg_init
->mode_sleep
)
590 reg
|= PALMAS_LDO1_CTRL_MODE_SLEEP
;
592 ret
= palmas_smps_write(palmas
, addr
, reg
);
599 static __devinit
int palmas_probe(struct platform_device
*pdev
)
601 struct palmas
*palmas
= dev_get_drvdata(pdev
->dev
.parent
);
602 struct palmas_pmic_platform_data
*pdata
= pdev
->dev
.platform_data
;
603 struct regulator_dev
*rdev
;
604 struct regulator_config config
= { };
605 struct palmas_pmic
*pmic
;
606 struct palmas_reg_init
*reg_init
;
608 unsigned int addr
, reg
;
612 if (!pdata
->reg_data
)
615 pmic
= devm_kzalloc(&pdev
->dev
, sizeof(*pmic
), GFP_KERNEL
);
619 pmic
->dev
= &pdev
->dev
;
620 pmic
->palmas
= palmas
;
622 platform_set_drvdata(pdev
, pmic
);
624 ret
= palmas_smps_read(palmas
, PALMAS_SMPS_CTRL
, ®
);
626 goto err_unregister_regulator
;
628 if (reg
& PALMAS_SMPS_CTRL_SMPS12_SMPS123_EN
)
631 if (reg
& PALMAS_SMPS_CTRL_SMPS45_SMPS457_EN
)
634 config
.regmap
= palmas
->regmap
[REGULATOR_SLAVE
];
635 config
.dev
= &pdev
->dev
;
636 config
.driver_data
= pmic
;
638 for (id
= 0; id
< PALMAS_REG_LDO1
; id
++) {
641 * Miss out regulators which are not available due
642 * to slaving configurations.
645 case PALMAS_REG_SMPS12
:
646 case PALMAS_REG_SMPS3
:
650 case PALMAS_REG_SMPS123
:
654 case PALMAS_REG_SMPS45
:
655 case PALMAS_REG_SMPS7
:
659 case PALMAS_REG_SMPS457
:
664 /* Register the regulators */
665 pmic
->desc
[id
].name
= palmas_regs_info
[id
].name
;
666 pmic
->desc
[id
].id
= id
;
668 if (id
!= PALMAS_REG_SMPS10
) {
669 pmic
->desc
[id
].ops
= &palmas_ops_smps
;
670 pmic
->desc
[id
].n_voltages
= PALMAS_SMPS_NUM_VOLTAGES
;
672 pmic
->desc
[id
].n_voltages
= PALMAS_SMPS10_NUM_VOLTAGES
;
673 pmic
->desc
[id
].ops
= &palmas_ops_smps10
;
674 pmic
->desc
[id
].vsel_reg
= PALMAS_SMPS10_CTRL
;
675 pmic
->desc
[id
].vsel_mask
= SMPS10_VSEL
;
676 pmic
->desc
[id
].enable_reg
= PALMAS_SMPS10_STATUS
;
677 pmic
->desc
[id
].enable_mask
= SMPS10_BOOST_EN
;
680 pmic
->desc
[id
].type
= REGULATOR_VOLTAGE
;
681 pmic
->desc
[id
].owner
= THIS_MODULE
;
683 /* Initialise sleep/init values from platform data */
684 if (pdata
&& pdata
->reg_init
) {
685 reg_init
= pdata
->reg_init
[id
];
687 ret
= palmas_smps_init(palmas
, id
, reg_init
);
689 goto err_unregister_regulator
;
694 * read and store the RANGE bit for later use
695 * This must be done before regulator is probed otherwise
696 * we error in probe with unsuportable ranges.
698 if (id
!= PALMAS_REG_SMPS10
) {
699 addr
= palmas_regs_info
[id
].vsel_addr
;
701 ret
= palmas_smps_read(pmic
->palmas
, addr
, ®
);
703 goto err_unregister_regulator
;
704 if (reg
& PALMAS_SMPS12_VOLTAGE_RANGE
)
708 if (pdata
&& pdata
->reg_data
)
709 config
.init_data
= pdata
->reg_data
[id
];
711 config
.init_data
= NULL
;
713 rdev
= regulator_register(&pmic
->desc
[id
], &config
);
716 "failed to register %s regulator\n",
719 goto err_unregister_regulator
;
722 /* Save regulator for cleanup */
723 pmic
->rdev
[id
] = rdev
;
726 /* Start this loop from the id left from previous loop */
727 for (; id
< PALMAS_NUM_REGS
; id
++) {
729 /* Miss out regulators which are not available due
730 * to alternate functions.
733 /* Register the regulators */
734 pmic
->desc
[id
].name
= palmas_regs_info
[id
].name
;
735 pmic
->desc
[id
].id
= id
;
736 pmic
->desc
[id
].n_voltages
= PALMAS_LDO_NUM_VOLTAGES
;
738 pmic
->desc
[id
].ops
= &palmas_ops_ldo
;
740 pmic
->desc
[id
].type
= REGULATOR_VOLTAGE
;
741 pmic
->desc
[id
].owner
= THIS_MODULE
;
742 pmic
->desc
[id
].enable_reg
= palmas_regs_info
[id
].ctrl_addr
;
743 pmic
->desc
[id
].enable_mask
= PALMAS_LDO1_CTRL_MODE_ACTIVE
;
745 if (pdata
&& pdata
->reg_data
)
746 config
.init_data
= pdata
->reg_data
[id
];
748 config
.init_data
= NULL
;
750 rdev
= regulator_register(&pmic
->desc
[id
], &config
);
753 "failed to register %s regulator\n",
756 goto err_unregister_regulator
;
759 /* Save regulator for cleanup */
760 pmic
->rdev
[id
] = rdev
;
762 /* Initialise sleep/init values from platform data */
763 if (pdata
->reg_init
) {
764 reg_init
= pdata
->reg_init
[id
];
766 ret
= palmas_ldo_init(palmas
, id
, reg_init
);
768 goto err_unregister_regulator
;
775 err_unregister_regulator
:
777 regulator_unregister(pmic
->rdev
[id
]);
781 static int __devexit
palmas_remove(struct platform_device
*pdev
)
783 struct palmas_pmic
*pmic
= platform_get_drvdata(pdev
);
786 for (id
= 0; id
< PALMAS_NUM_REGS
; id
++)
787 regulator_unregister(pmic
->rdev
[id
]);
791 static struct platform_driver palmas_driver
= {
793 .name
= "palmas-pmic",
794 .owner
= THIS_MODULE
,
796 .probe
= palmas_probe
,
797 .remove
= __devexit_p(palmas_remove
),
800 static int __init
palmas_init(void)
802 return platform_driver_register(&palmas_driver
);
804 subsys_initcall(palmas_init
);
806 static void __exit
palmas_exit(void)
808 platform_driver_unregister(&palmas_driver
);
810 module_exit(palmas_exit
);
812 MODULE_AUTHOR("Graeme Gregory <gg@slimlogic.co.uk>");
813 MODULE_DESCRIPTION("Palmas voltage regulator driver");
814 MODULE_LICENSE("GPL");
815 MODULE_ALIAS("platform:palmas-pmic");