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/delay.h>
24 #include <linux/slab.h>
25 #include <linux/gpio.h>
26 #include <linux/mfd/tps65910.h>
28 #define TPS65910_SUPPLY_STATE_ENABLED 0x1
30 /* supported VIO voltages in milivolts */
31 static const u16 VIO_VSEL_table
[] = {
32 1500, 1800, 2500, 3300,
35 /* VSEL tables for TPS65910 specific LDOs and dcdc's */
37 /* supported VDD3 voltages in milivolts */
38 static const u16 VDD3_VSEL_table
[] = {
42 /* supported VDIG1 voltages in milivolts */
43 static const u16 VDIG1_VSEL_table
[] = {
44 1200, 1500, 1800, 2700,
47 /* supported VDIG2 voltages in milivolts */
48 static const u16 VDIG2_VSEL_table
[] = {
49 1000, 1100, 1200, 1800,
52 /* supported VPLL voltages in milivolts */
53 static const u16 VPLL_VSEL_table
[] = {
54 1000, 1100, 1800, 2500,
57 /* supported VDAC voltages in milivolts */
58 static const u16 VDAC_VSEL_table
[] = {
59 1800, 2600, 2800, 2850,
62 /* supported VAUX1 voltages in milivolts */
63 static const u16 VAUX1_VSEL_table
[] = {
64 1800, 2500, 2800, 2850,
67 /* supported VAUX2 voltages in milivolts */
68 static const u16 VAUX2_VSEL_table
[] = {
69 1800, 2800, 2900, 3300,
72 /* supported VAUX33 voltages in milivolts */
73 static const u16 VAUX33_VSEL_table
[] = {
74 1800, 2000, 2800, 3300,
77 /* supported VMMC voltages in milivolts */
78 static const u16 VMMC_VSEL_table
[] = {
79 1800, 2800, 3000, 3300,
90 static struct tps_info tps65910_regs
[] = {
98 .table_len
= ARRAY_SIZE(VIO_VSEL_table
),
99 .table
= VIO_VSEL_table
,
115 .table_len
= ARRAY_SIZE(VDD3_VSEL_table
),
116 .table
= VDD3_VSEL_table
,
122 .table_len
= ARRAY_SIZE(VDIG1_VSEL_table
),
123 .table
= VDIG1_VSEL_table
,
129 .table_len
= ARRAY_SIZE(VDIG2_VSEL_table
),
130 .table
= VDIG2_VSEL_table
,
136 .table_len
= ARRAY_SIZE(VPLL_VSEL_table
),
137 .table
= VPLL_VSEL_table
,
143 .table_len
= ARRAY_SIZE(VDAC_VSEL_table
),
144 .table
= VDAC_VSEL_table
,
150 .table_len
= ARRAY_SIZE(VAUX1_VSEL_table
),
151 .table
= VAUX1_VSEL_table
,
157 .table_len
= ARRAY_SIZE(VAUX2_VSEL_table
),
158 .table
= VAUX2_VSEL_table
,
164 .table_len
= ARRAY_SIZE(VAUX33_VSEL_table
),
165 .table
= VAUX33_VSEL_table
,
171 .table_len
= ARRAY_SIZE(VMMC_VSEL_table
),
172 .table
= VMMC_VSEL_table
,
176 static struct tps_info tps65911_regs
[] = {
184 .table_len
= ARRAY_SIZE(VIO_VSEL_table
),
185 .table
= VIO_VSEL_table
,
255 struct tps65910_reg
{
256 struct regulator_desc
*desc
;
257 struct tps65910
*mfd
;
258 struct regulator_dev
**rdev
;
259 struct tps_info
**info
;
263 int (*get_ctrl_reg
)(int);
266 static inline int tps65910_read(struct tps65910_reg
*pmic
, u8 reg
)
271 err
= pmic
->mfd
->read(pmic
->mfd
, reg
, 1, &val
);
278 static inline int tps65910_write(struct tps65910_reg
*pmic
, u8 reg
, u8 val
)
280 return pmic
->mfd
->write(pmic
->mfd
, reg
, 1, &val
);
283 static int tps65910_modify_bits(struct tps65910_reg
*pmic
, u8 reg
,
284 u8 set_mask
, u8 clear_mask
)
288 mutex_lock(&pmic
->mutex
);
290 data
= tps65910_read(pmic
, reg
);
292 dev_err(pmic
->mfd
->dev
, "Read from reg 0x%x failed\n", reg
);
299 err
= tps65910_write(pmic
, reg
, data
);
301 dev_err(pmic
->mfd
->dev
, "Write for reg 0x%x failed\n", reg
);
304 mutex_unlock(&pmic
->mutex
);
308 static int tps65910_reg_read(struct tps65910_reg
*pmic
, u8 reg
)
312 mutex_lock(&pmic
->mutex
);
314 data
= tps65910_read(pmic
, reg
);
316 dev_err(pmic
->mfd
->dev
, "Read from reg 0x%x failed\n", reg
);
318 mutex_unlock(&pmic
->mutex
);
322 static int tps65910_reg_write(struct tps65910_reg
*pmic
, u8 reg
, u8 val
)
326 mutex_lock(&pmic
->mutex
);
328 err
= tps65910_write(pmic
, reg
, val
);
330 dev_err(pmic
->mfd
->dev
, "Write for reg 0x%x failed\n", reg
);
332 mutex_unlock(&pmic
->mutex
);
336 static int tps65910_get_ctrl_register(int id
)
339 case TPS65910_REG_VRTC
:
340 return TPS65910_VRTC
;
341 case TPS65910_REG_VIO
:
343 case TPS65910_REG_VDD1
:
344 return TPS65910_VDD1
;
345 case TPS65910_REG_VDD2
:
346 return TPS65910_VDD2
;
347 case TPS65910_REG_VDD3
:
348 return TPS65910_VDD3
;
349 case TPS65910_REG_VDIG1
:
350 return TPS65910_VDIG1
;
351 case TPS65910_REG_VDIG2
:
352 return TPS65910_VDIG2
;
353 case TPS65910_REG_VPLL
:
354 return TPS65910_VPLL
;
355 case TPS65910_REG_VDAC
:
356 return TPS65910_VDAC
;
357 case TPS65910_REG_VAUX1
:
358 return TPS65910_VAUX1
;
359 case TPS65910_REG_VAUX2
:
360 return TPS65910_VAUX2
;
361 case TPS65910_REG_VAUX33
:
362 return TPS65910_VAUX33
;
363 case TPS65910_REG_VMMC
:
364 return TPS65910_VMMC
;
370 static int tps65911_get_ctrl_register(int id
)
373 case TPS65910_REG_VRTC
:
374 return TPS65910_VRTC
;
375 case TPS65910_REG_VIO
:
377 case TPS65910_REG_VDD1
:
378 return TPS65910_VDD1
;
379 case TPS65910_REG_VDD2
:
380 return TPS65910_VDD2
;
381 case TPS65911_REG_VDDCTRL
:
382 return TPS65911_VDDCTRL
;
383 case TPS65911_REG_LDO1
:
384 return TPS65911_LDO1
;
385 case TPS65911_REG_LDO2
:
386 return TPS65911_LDO2
;
387 case TPS65911_REG_LDO3
:
388 return TPS65911_LDO3
;
389 case TPS65911_REG_LDO4
:
390 return TPS65911_LDO4
;
391 case TPS65911_REG_LDO5
:
392 return TPS65911_LDO5
;
393 case TPS65911_REG_LDO6
:
394 return TPS65911_LDO6
;
395 case TPS65911_REG_LDO7
:
396 return TPS65911_LDO7
;
397 case TPS65911_REG_LDO8
:
398 return TPS65911_LDO8
;
404 static int tps65910_is_enabled(struct regulator_dev
*dev
)
406 struct tps65910_reg
*pmic
= rdev_get_drvdata(dev
);
407 int reg
, value
, id
= rdev_get_id(dev
);
409 reg
= pmic
->get_ctrl_reg(id
);
413 value
= tps65910_reg_read(pmic
, reg
);
417 return value
& TPS65910_SUPPLY_STATE_ENABLED
;
420 static int tps65910_enable(struct regulator_dev
*dev
)
422 struct tps65910_reg
*pmic
= rdev_get_drvdata(dev
);
423 struct tps65910
*mfd
= pmic
->mfd
;
424 int reg
, id
= rdev_get_id(dev
);
426 reg
= pmic
->get_ctrl_reg(id
);
430 return tps65910_set_bits(mfd
, reg
, TPS65910_SUPPLY_STATE_ENABLED
);
433 static int tps65910_disable(struct regulator_dev
*dev
)
435 struct tps65910_reg
*pmic
= rdev_get_drvdata(dev
);
436 struct tps65910
*mfd
= pmic
->mfd
;
437 int reg
, id
= rdev_get_id(dev
);
439 reg
= pmic
->get_ctrl_reg(id
);
443 return tps65910_clear_bits(mfd
, reg
, TPS65910_SUPPLY_STATE_ENABLED
);
447 static int tps65910_set_mode(struct regulator_dev
*dev
, unsigned int mode
)
449 struct tps65910_reg
*pmic
= rdev_get_drvdata(dev
);
450 struct tps65910
*mfd
= pmic
->mfd
;
451 int reg
, value
, id
= rdev_get_id(dev
);
453 reg
= pmic
->get_ctrl_reg(id
);
458 case REGULATOR_MODE_NORMAL
:
459 return tps65910_modify_bits(pmic
, reg
, LDO_ST_ON_BIT
,
461 case REGULATOR_MODE_IDLE
:
462 value
= LDO_ST_ON_BIT
| LDO_ST_MODE_BIT
;
463 return tps65910_set_bits(mfd
, reg
, value
);
464 case REGULATOR_MODE_STANDBY
:
465 return tps65910_clear_bits(mfd
, reg
, LDO_ST_ON_BIT
);
471 static unsigned int tps65910_get_mode(struct regulator_dev
*dev
)
473 struct tps65910_reg
*pmic
= rdev_get_drvdata(dev
);
474 int reg
, value
, id
= rdev_get_id(dev
);
476 reg
= pmic
->get_ctrl_reg(id
);
480 value
= tps65910_reg_read(pmic
, reg
);
484 if (value
& LDO_ST_ON_BIT
)
485 return REGULATOR_MODE_STANDBY
;
486 else if (value
& LDO_ST_MODE_BIT
)
487 return REGULATOR_MODE_IDLE
;
489 return REGULATOR_MODE_NORMAL
;
492 static int tps65910_get_voltage_dcdc(struct regulator_dev
*dev
)
494 struct tps65910_reg
*pmic
= rdev_get_drvdata(dev
);
495 int id
= rdev_get_id(dev
), voltage
= 0;
496 int opvsel
= 0, srvsel
= 0, vselmax
= 0, mult
= 0, sr
= 0;
499 case TPS65910_REG_VDD1
:
500 opvsel
= tps65910_reg_read(pmic
, TPS65910_VDD1_OP
);
501 mult
= tps65910_reg_read(pmic
, TPS65910_VDD1
);
502 mult
= (mult
& VDD1_VGAIN_SEL_MASK
) >> VDD1_VGAIN_SEL_SHIFT
;
503 srvsel
= tps65910_reg_read(pmic
, TPS65910_VDD1_SR
);
504 sr
= opvsel
& VDD1_OP_CMD_MASK
;
505 opvsel
&= VDD1_OP_SEL_MASK
;
506 srvsel
&= VDD1_SR_SEL_MASK
;
509 case TPS65910_REG_VDD2
:
510 opvsel
= tps65910_reg_read(pmic
, TPS65910_VDD2_OP
);
511 mult
= tps65910_reg_read(pmic
, TPS65910_VDD2
);
512 mult
= (mult
& VDD2_VGAIN_SEL_MASK
) >> VDD2_VGAIN_SEL_SHIFT
;
513 srvsel
= tps65910_reg_read(pmic
, TPS65910_VDD2_SR
);
514 sr
= opvsel
& VDD2_OP_CMD_MASK
;
515 opvsel
&= VDD2_OP_SEL_MASK
;
516 srvsel
&= VDD2_SR_SEL_MASK
;
519 case TPS65911_REG_VDDCTRL
:
520 opvsel
= tps65910_reg_read(pmic
, TPS65911_VDDCTRL_OP
);
521 srvsel
= tps65910_reg_read(pmic
, TPS65911_VDDCTRL_SR
);
522 sr
= opvsel
& VDDCTRL_OP_CMD_MASK
;
523 opvsel
&= VDDCTRL_OP_SEL_MASK
;
524 srvsel
&= VDDCTRL_SR_SEL_MASK
;
529 /* multiplier 0 == 1 but 2,3 normal */
534 /* normalise to valid range */
537 if (srvsel
> vselmax
)
541 voltage
= (srvsel
* VDD1_2_OFFSET
+ VDD1_2_MIN_VOLT
) * 100;
544 /* normalise to valid range*/
547 if (opvsel
> vselmax
)
551 voltage
= (opvsel
* VDD1_2_OFFSET
+ VDD1_2_MIN_VOLT
) * 100;
559 static int tps65910_get_voltage(struct regulator_dev
*dev
)
561 struct tps65910_reg
*pmic
= rdev_get_drvdata(dev
);
562 int reg
, value
, id
= rdev_get_id(dev
), voltage
= 0;
564 reg
= pmic
->get_ctrl_reg(id
);
568 value
= tps65910_reg_read(pmic
, reg
);
573 case TPS65910_REG_VIO
:
574 case TPS65910_REG_VDIG1
:
575 case TPS65910_REG_VDIG2
:
576 case TPS65910_REG_VPLL
:
577 case TPS65910_REG_VDAC
:
578 case TPS65910_REG_VAUX1
:
579 case TPS65910_REG_VAUX2
:
580 case TPS65910_REG_VAUX33
:
581 case TPS65910_REG_VMMC
:
582 value
&= LDO_SEL_MASK
;
583 value
>>= LDO_SEL_SHIFT
;
589 voltage
= pmic
->info
[id
]->table
[value
] * 1000;
594 static int tps65910_get_voltage_vdd3(struct regulator_dev
*dev
)
596 return 5 * 1000 * 1000;
599 static int tps65911_get_voltage(struct regulator_dev
*dev
)
601 struct tps65910_reg
*pmic
= rdev_get_drvdata(dev
);
602 int step_mv
, id
= rdev_get_id(dev
);
605 reg
= pmic
->get_ctrl_reg(id
);
607 value
= tps65910_reg_read(pmic
, reg
);
610 case TPS65911_REG_LDO1
:
611 case TPS65911_REG_LDO2
:
612 case TPS65911_REG_LDO4
:
613 value
&= LDO1_SEL_MASK
;
614 value
>>= LDO_SEL_SHIFT
;
615 /* The first 5 values of the selector correspond to 1V */
623 case TPS65911_REG_LDO3
:
624 case TPS65911_REG_LDO5
:
625 case TPS65911_REG_LDO6
:
626 case TPS65911_REG_LDO7
:
627 case TPS65911_REG_LDO8
:
628 value
&= LDO3_SEL_MASK
;
629 value
>>= LDO_SEL_SHIFT
;
630 /* The first 3 values of the selector correspond to 1V */
638 case TPS65910_REG_VIO
:
639 return pmic
->info
[id
]->table
[value
] * 1000;
645 return (LDO_MIN_VOLT
+ value
* step_mv
) * 1000;
648 static int tps65910_set_voltage_dcdc(struct regulator_dev
*dev
,
651 struct tps65910_reg
*pmic
= rdev_get_drvdata(dev
);
652 int id
= rdev_get_id(dev
), vsel
;
656 case TPS65910_REG_VDD1
:
657 dcdc_mult
= (selector
/ VDD1_2_NUM_VOLT_FINE
) + 1;
660 vsel
= (selector
% VDD1_2_NUM_VOLT_FINE
) + 3;
662 tps65910_modify_bits(pmic
, TPS65910_VDD1
,
663 (dcdc_mult
<< VDD1_VGAIN_SEL_SHIFT
),
664 VDD1_VGAIN_SEL_MASK
);
665 tps65910_reg_write(pmic
, TPS65910_VDD1_OP
, vsel
);
667 case TPS65910_REG_VDD2
:
668 dcdc_mult
= (selector
/ VDD1_2_NUM_VOLT_FINE
) + 1;
671 vsel
= (selector
% VDD1_2_NUM_VOLT_FINE
) + 3;
673 tps65910_modify_bits(pmic
, TPS65910_VDD2
,
674 (dcdc_mult
<< VDD2_VGAIN_SEL_SHIFT
),
675 VDD1_VGAIN_SEL_MASK
);
676 tps65910_reg_write(pmic
, TPS65910_VDD2_OP
, vsel
);
678 case TPS65911_REG_VDDCTRL
:
680 tps65910_reg_write(pmic
, TPS65911_VDDCTRL_OP
, vsel
);
686 static int tps65910_set_voltage(struct regulator_dev
*dev
, unsigned selector
)
688 struct tps65910_reg
*pmic
= rdev_get_drvdata(dev
);
689 int reg
, id
= rdev_get_id(dev
);
691 reg
= pmic
->get_ctrl_reg(id
);
696 case TPS65910_REG_VIO
:
697 case TPS65910_REG_VDIG1
:
698 case TPS65910_REG_VDIG2
:
699 case TPS65910_REG_VPLL
:
700 case TPS65910_REG_VDAC
:
701 case TPS65910_REG_VAUX1
:
702 case TPS65910_REG_VAUX2
:
703 case TPS65910_REG_VAUX33
:
704 case TPS65910_REG_VMMC
:
705 return tps65910_modify_bits(pmic
, reg
,
706 (selector
<< LDO_SEL_SHIFT
), LDO_SEL_MASK
);
712 static int tps65911_set_voltage(struct regulator_dev
*dev
, unsigned selector
)
714 struct tps65910_reg
*pmic
= rdev_get_drvdata(dev
);
715 int reg
, id
= rdev_get_id(dev
);
717 reg
= pmic
->get_ctrl_reg(id
);
722 case TPS65911_REG_LDO1
:
723 case TPS65911_REG_LDO2
:
724 case TPS65911_REG_LDO4
:
725 return tps65910_modify_bits(pmic
, reg
,
726 (selector
<< LDO_SEL_SHIFT
), LDO1_SEL_MASK
);
727 case TPS65911_REG_LDO3
:
728 case TPS65911_REG_LDO5
:
729 case TPS65911_REG_LDO6
:
730 case TPS65911_REG_LDO7
:
731 case TPS65911_REG_LDO8
:
732 case TPS65910_REG_VIO
:
733 return tps65910_modify_bits(pmic
, reg
,
734 (selector
<< LDO_SEL_SHIFT
), LDO3_SEL_MASK
);
741 static int tps65910_list_voltage_dcdc(struct regulator_dev
*dev
,
744 int volt
, mult
= 1, id
= rdev_get_id(dev
);
747 case TPS65910_REG_VDD1
:
748 case TPS65910_REG_VDD2
:
749 mult
= (selector
/ VDD1_2_NUM_VOLT_FINE
) + 1;
750 volt
= VDD1_2_MIN_VOLT
+
751 (selector
% VDD1_2_NUM_VOLT_FINE
) * VDD1_2_OFFSET
;
753 case TPS65911_REG_VDDCTRL
:
754 volt
= VDDCTRL_MIN_VOLT
+ (selector
* VDDCTRL_OFFSET
);
761 return volt
* 100 * mult
;
764 static int tps65910_list_voltage(struct regulator_dev
*dev
,
767 struct tps65910_reg
*pmic
= rdev_get_drvdata(dev
);
768 int id
= rdev_get_id(dev
), voltage
;
770 if (id
< TPS65910_REG_VIO
|| id
> TPS65910_REG_VMMC
)
773 if (selector
>= pmic
->info
[id
]->table_len
)
776 voltage
= pmic
->info
[id
]->table
[selector
] * 1000;
781 static int tps65911_list_voltage(struct regulator_dev
*dev
, unsigned selector
)
783 struct tps65910_reg
*pmic
= rdev_get_drvdata(dev
);
784 int step_mv
= 0, id
= rdev_get_id(dev
);
787 case TPS65911_REG_LDO1
:
788 case TPS65911_REG_LDO2
:
789 case TPS65911_REG_LDO4
:
790 /* The first 5 values of the selector correspond to 1V */
798 case TPS65911_REG_LDO3
:
799 case TPS65911_REG_LDO5
:
800 case TPS65911_REG_LDO6
:
801 case TPS65911_REG_LDO7
:
802 case TPS65911_REG_LDO8
:
803 /* The first 3 values of the selector correspond to 1V */
811 case TPS65910_REG_VIO
:
812 return pmic
->info
[id
]->table
[selector
] * 1000;
817 return (LDO_MIN_VOLT
+ selector
* step_mv
) * 1000;
820 /* Regulator ops (except VRTC) */
821 static struct regulator_ops tps65910_ops_dcdc
= {
822 .is_enabled
= tps65910_is_enabled
,
823 .enable
= tps65910_enable
,
824 .disable
= tps65910_disable
,
825 .set_mode
= tps65910_set_mode
,
826 .get_mode
= tps65910_get_mode
,
827 .get_voltage
= tps65910_get_voltage_dcdc
,
828 .set_voltage_sel
= tps65910_set_voltage_dcdc
,
829 .list_voltage
= tps65910_list_voltage_dcdc
,
832 static struct regulator_ops tps65910_ops_vdd3
= {
833 .is_enabled
= tps65910_is_enabled
,
834 .enable
= tps65910_enable
,
835 .disable
= tps65910_disable
,
836 .set_mode
= tps65910_set_mode
,
837 .get_mode
= tps65910_get_mode
,
838 .get_voltage
= tps65910_get_voltage_vdd3
,
839 .list_voltage
= tps65910_list_voltage
,
842 static struct regulator_ops tps65910_ops
= {
843 .is_enabled
= tps65910_is_enabled
,
844 .enable
= tps65910_enable
,
845 .disable
= tps65910_disable
,
846 .set_mode
= tps65910_set_mode
,
847 .get_mode
= tps65910_get_mode
,
848 .get_voltage
= tps65910_get_voltage
,
849 .set_voltage_sel
= tps65910_set_voltage
,
850 .list_voltage
= tps65910_list_voltage
,
853 static struct regulator_ops tps65911_ops
= {
854 .is_enabled
= tps65910_is_enabled
,
855 .enable
= tps65910_enable
,
856 .disable
= tps65910_disable
,
857 .set_mode
= tps65910_set_mode
,
858 .get_mode
= tps65910_get_mode
,
859 .get_voltage
= tps65911_get_voltage
,
860 .set_voltage_sel
= tps65911_set_voltage
,
861 .list_voltage
= tps65911_list_voltage
,
864 static __devinit
int tps65910_probe(struct platform_device
*pdev
)
866 struct tps65910
*tps65910
= dev_get_drvdata(pdev
->dev
.parent
);
867 struct tps_info
*info
;
868 struct regulator_init_data
*reg_data
;
869 struct regulator_dev
*rdev
;
870 struct tps65910_reg
*pmic
;
871 struct tps65910_board
*pmic_plat_data
;
874 pmic_plat_data
= dev_get_platdata(tps65910
->dev
);
878 pmic
= kzalloc(sizeof(*pmic
), GFP_KERNEL
);
882 mutex_init(&pmic
->mutex
);
883 pmic
->mfd
= tps65910
;
884 platform_set_drvdata(pdev
, pmic
);
886 /* Give control of all register to control port */
887 tps65910_set_bits(pmic
->mfd
, TPS65910_DEVCTRL
,
888 DEVCTRL_SR_CTL_I2C_SEL_MASK
);
890 switch(tps65910_chip_id(tps65910
)) {
892 pmic
->get_ctrl_reg
= &tps65910_get_ctrl_register
;
893 pmic
->num_regulators
= ARRAY_SIZE(tps65910_regs
);
894 info
= tps65910_regs
;
897 pmic
->get_ctrl_reg
= &tps65911_get_ctrl_register
;
898 pmic
->num_regulators
= ARRAY_SIZE(tps65911_regs
);
899 info
= tps65911_regs
;
902 pr_err("Invalid tps chip version\n");
907 pmic
->desc
= kcalloc(pmic
->num_regulators
,
908 sizeof(struct regulator_desc
), GFP_KERNEL
);
914 pmic
->info
= kcalloc(pmic
->num_regulators
,
915 sizeof(struct tps_info
*), GFP_KERNEL
);
921 pmic
->rdev
= kcalloc(pmic
->num_regulators
,
922 sizeof(struct regulator_dev
*), GFP_KERNEL
);
928 for (i
= 0; i
< pmic
->num_regulators
&& i
< TPS65910_NUM_REGS
;
931 reg_data
= pmic_plat_data
->tps65910_pmic_init_data
[i
];
933 /* Regulator API handles empty constraints but not NULL
938 /* Register the regulators */
939 pmic
->info
[i
] = info
;
941 pmic
->desc
[i
].name
= info
->name
;
942 pmic
->desc
[i
].id
= i
;
943 pmic
->desc
[i
].n_voltages
= info
->table_len
;
945 if (i
== TPS65910_REG_VDD1
|| i
== TPS65910_REG_VDD2
) {
946 pmic
->desc
[i
].ops
= &tps65910_ops_dcdc
;
947 pmic
->desc
[i
].n_voltages
= VDD1_2_NUM_VOLT_FINE
*
948 VDD1_2_NUM_VOLT_COARSE
;
949 } else if (i
== TPS65910_REG_VDD3
) {
950 if (tps65910_chip_id(tps65910
) == TPS65910
)
951 pmic
->desc
[i
].ops
= &tps65910_ops_vdd3
;
953 pmic
->desc
[i
].ops
= &tps65910_ops_dcdc
;
955 if (tps65910_chip_id(tps65910
) == TPS65910
)
956 pmic
->desc
[i
].ops
= &tps65910_ops
;
958 pmic
->desc
[i
].ops
= &tps65911_ops
;
961 pmic
->desc
[i
].type
= REGULATOR_VOLTAGE
;
962 pmic
->desc
[i
].owner
= THIS_MODULE
;
964 rdev
= regulator_register(&pmic
->desc
[i
],
965 tps65910
->dev
, reg_data
, pmic
, NULL
);
967 dev_err(tps65910
->dev
,
968 "failed to register %s regulator\n",
971 goto err_unregister_regulator
;
974 /* Save regulator for cleanup */
975 pmic
->rdev
[i
] = rdev
;
979 err_unregister_regulator
:
981 regulator_unregister(pmic
->rdev
[i
]);
992 static int __devexit
tps65910_remove(struct platform_device
*pdev
)
994 struct tps65910_reg
*pmic
= platform_get_drvdata(pdev
);
997 for (i
= 0; i
< pmic
->num_regulators
; i
++)
998 regulator_unregister(pmic
->rdev
[i
]);
1007 static struct platform_driver tps65910_driver
= {
1009 .name
= "tps65910-pmic",
1010 .owner
= THIS_MODULE
,
1012 .probe
= tps65910_probe
,
1013 .remove
= __devexit_p(tps65910_remove
),
1016 static int __init
tps65910_init(void)
1018 return platform_driver_register(&tps65910_driver
);
1020 subsys_initcall(tps65910_init
);
1022 static void __exit
tps65910_cleanup(void)
1024 platform_driver_unregister(&tps65910_driver
);
1026 module_exit(tps65910_cleanup
);
1028 MODULE_AUTHOR("Graeme Gregory <gg@slimlogic.co.uk>");
1029 MODULE_DESCRIPTION("TPS6507x voltage regulator driver");
1030 MODULE_LICENSE("GPL v2");
1031 MODULE_ALIAS("platform:tps65910-pmic");