2 * Copyright 2012 Texas Instruments
4 * Author: Milo(Woogyom) Kim <milo.kim@ti.com>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
12 #include <linux/module.h>
13 #include <linux/slab.h>
14 #include <linux/i2c.h>
15 #include <linux/regmap.h>
16 #include <linux/err.h>
17 #include <linux/gpio.h>
18 #include <linux/regulator/lp872x.h>
19 #include <linux/regulator/driver.h>
20 #include <linux/platform_device.h>
22 #include <linux/of_gpio.h>
23 #include <linux/regulator/of_regulator.h>
25 /* Registers : LP8720/8725 shared */
26 #define LP872X_GENERAL_CFG 0x00
27 #define LP872X_LDO1_VOUT 0x01
28 #define LP872X_LDO2_VOUT 0x02
29 #define LP872X_LDO3_VOUT 0x03
30 #define LP872X_LDO4_VOUT 0x04
31 #define LP872X_LDO5_VOUT 0x05
33 /* Registers : LP8720 */
34 #define LP8720_BUCK_VOUT1 0x06
35 #define LP8720_BUCK_VOUT2 0x07
36 #define LP8720_ENABLE 0x08
38 /* Registers : LP8725 */
39 #define LP8725_LILO1_VOUT 0x06
40 #define LP8725_LILO2_VOUT 0x07
41 #define LP8725_BUCK1_VOUT1 0x08
42 #define LP8725_BUCK1_VOUT2 0x09
43 #define LP8725_BUCK2_VOUT1 0x0A
44 #define LP8725_BUCK2_VOUT2 0x0B
45 #define LP8725_BUCK_CTRL 0x0C
46 #define LP8725_LDO_CTRL 0x0D
48 /* Mask/shift : LP8720/LP8725 shared */
49 #define LP872X_VOUT_M 0x1F
50 #define LP872X_START_DELAY_M 0xE0
51 #define LP872X_START_DELAY_S 5
52 #define LP872X_EN_LDO1_M BIT(0)
53 #define LP872X_EN_LDO2_M BIT(1)
54 #define LP872X_EN_LDO3_M BIT(2)
55 #define LP872X_EN_LDO4_M BIT(3)
56 #define LP872X_EN_LDO5_M BIT(4)
58 /* Mask/shift : LP8720 */
59 #define LP8720_TIMESTEP_S 0 /* Addr 00h */
60 #define LP8720_TIMESTEP_M BIT(0)
61 #define LP8720_EXT_DVS_M BIT(2)
62 #define LP8720_BUCK_FPWM_S 5 /* Addr 07h */
63 #define LP8720_BUCK_FPWM_M BIT(5)
64 #define LP8720_EN_BUCK_M BIT(5) /* Addr 08h */
65 #define LP8720_DVS_SEL_M BIT(7)
67 /* Mask/shift : LP8725 */
68 #define LP8725_TIMESTEP_M 0xC0 /* Addr 00h */
69 #define LP8725_TIMESTEP_S 6
70 #define LP8725_BUCK1_EN_M BIT(0)
71 #define LP8725_DVS1_M BIT(2)
72 #define LP8725_DVS2_M BIT(3)
73 #define LP8725_BUCK2_EN_M BIT(4)
74 #define LP8725_BUCK_CL_M 0xC0 /* Addr 09h, 0Bh */
75 #define LP8725_BUCK_CL_S 6
76 #define LP8725_BUCK1_FPWM_S 1 /* Addr 0Ch */
77 #define LP8725_BUCK1_FPWM_M BIT(1)
78 #define LP8725_BUCK2_FPWM_S 5
79 #define LP8725_BUCK2_FPWM_M BIT(5)
80 #define LP8725_EN_LILO1_M BIT(5) /* Addr 0Dh */
81 #define LP8725_EN_LILO2_M BIT(6)
84 #define LP872X_FORCE_PWM 1
85 #define LP872X_AUTO_PWM 0
87 #define LP8720_NUM_REGULATORS 6
88 #define LP8725_NUM_REGULATORS 9
89 #define EXTERN_DVS_USED 0
92 /* Default DVS Mode */
93 #define LP8720_DEFAULT_DVS 0
94 #define LP8725_DEFAULT_DVS BIT(2)
96 /* dump registers in regmap-debugfs */
97 #define MAX_REGISTERS 0x0F
105 struct regmap
*regmap
;
107 enum lp872x_id chipid
;
108 struct lp872x_platform_data
*pdata
;
110 enum lp872x_dvs_state dvs_pin
;
113 /* LP8720/LP8725 shared voltage table for LDOs */
114 static const unsigned int lp872x_ldo_vtbl
[] = {
115 1200000, 1250000, 1300000, 1350000, 1400000, 1450000, 1500000, 1550000,
116 1600000, 1650000, 1700000, 1750000, 1800000, 1850000, 1900000, 2000000,
117 2100000, 2200000, 2300000, 2400000, 2500000, 2600000, 2650000, 2700000,
118 2750000, 2800000, 2850000, 2900000, 2950000, 3000000, 3100000, 3300000,
121 /* LP8720 LDO4 voltage table */
122 static const unsigned int lp8720_ldo4_vtbl
[] = {
123 800000, 850000, 900000, 1000000, 1100000, 1200000, 1250000, 1300000,
124 1350000, 1400000, 1450000, 1500000, 1550000, 1600000, 1650000, 1700000,
125 1750000, 1800000, 1850000, 1900000, 2000000, 2100000, 2200000, 2300000,
126 2400000, 2500000, 2600000, 2650000, 2700000, 2750000, 2800000, 2850000,
129 /* LP8725 LILO(Low Input Low Output) voltage table */
130 static const unsigned int lp8725_lilo_vtbl
[] = {
131 800000, 850000, 900000, 950000, 1000000, 1050000, 1100000, 1150000,
132 1200000, 1250000, 1300000, 1350000, 1400000, 1500000, 1600000, 1700000,
133 1800000, 1900000, 2000000, 2100000, 2200000, 2300000, 2400000, 2500000,
134 2600000, 2700000, 2800000, 2850000, 2900000, 3000000, 3100000, 3300000,
137 /* LP8720 BUCK voltage table */
138 #define EXT_R 0 /* external resistor divider */
139 static const unsigned int lp8720_buck_vtbl
[] = {
140 EXT_R
, 800000, 850000, 900000, 950000, 1000000, 1050000, 1100000,
141 1150000, 1200000, 1250000, 1300000, 1350000, 1400000, 1450000, 1500000,
142 1550000, 1600000, 1650000, 1700000, 1750000, 1800000, 1850000, 1900000,
143 1950000, 2000000, 2050000, 2100000, 2150000, 2200000, 2250000, 2300000,
146 /* LP8725 BUCK voltage table */
147 static const unsigned int lp8725_buck_vtbl
[] = {
148 800000, 850000, 900000, 950000, 1000000, 1050000, 1100000, 1150000,
149 1200000, 1250000, 1300000, 1350000, 1400000, 1500000, 1600000, 1700000,
150 1750000, 1800000, 1850000, 1900000, 2000000, 2100000, 2200000, 2300000,
151 2400000, 2500000, 2600000, 2700000, 2800000, 2850000, 2900000, 3000000,
154 /* LP8725 BUCK current limit */
155 static const unsigned int lp8725_buck_uA
[] = {
156 460000, 780000, 1050000, 1370000,
159 static int lp872x_read_byte(struct lp872x
*lp
, u8 addr
, u8
*data
)
164 ret
= regmap_read(lp
->regmap
, addr
, &val
);
166 dev_err(lp
->dev
, "failed to read 0x%.2x\n", addr
);
174 static inline int lp872x_write_byte(struct lp872x
*lp
, u8 addr
, u8 data
)
176 return regmap_write(lp
->regmap
, addr
, data
);
179 static inline int lp872x_update_bits(struct lp872x
*lp
, u8 addr
,
180 unsigned int mask
, u8 data
)
182 return regmap_update_bits(lp
->regmap
, addr
, mask
, data
);
185 static int lp872x_get_timestep_usec(struct lp872x
*lp
)
187 enum lp872x_id chip
= lp
->chipid
;
189 int *time_usec
, size
, ret
;
190 int lp8720_time_usec
[] = { 25, 50 };
191 int lp8725_time_usec
[] = { 32, 64, 128, 256 };
195 mask
= LP8720_TIMESTEP_M
;
196 shift
= LP8720_TIMESTEP_S
;
197 time_usec
= &lp8720_time_usec
[0];
198 size
= ARRAY_SIZE(lp8720_time_usec
);
201 mask
= LP8725_TIMESTEP_M
;
202 shift
= LP8725_TIMESTEP_S
;
203 time_usec
= &lp8725_time_usec
[0];
204 size
= ARRAY_SIZE(lp8725_time_usec
);
210 ret
= lp872x_read_byte(lp
, LP872X_GENERAL_CFG
, &val
);
214 val
= (val
& mask
) >> shift
;
218 return *(time_usec
+ val
);
221 static int lp872x_regulator_enable_time(struct regulator_dev
*rdev
)
223 struct lp872x
*lp
= rdev_get_drvdata(rdev
);
224 enum lp872x_regulator_id rid
= rdev_get_id(rdev
);
225 int time_step_us
= lp872x_get_timestep_usec(lp
);
229 if (time_step_us
< 0)
233 case LP8720_ID_LDO1
... LP8720_ID_BUCK
:
234 addr
= LP872X_LDO1_VOUT
+ rid
;
236 case LP8725_ID_LDO1
... LP8725_ID_BUCK1
:
237 addr
= LP872X_LDO1_VOUT
+ rid
- LP8725_ID_BASE
;
239 case LP8725_ID_BUCK2
:
240 addr
= LP8725_BUCK2_VOUT1
;
246 ret
= lp872x_read_byte(lp
, addr
, &val
);
250 val
= (val
& LP872X_START_DELAY_M
) >> LP872X_START_DELAY_S
;
252 return val
> MAX_DELAY
? 0 : val
* time_step_us
;
255 static void lp872x_set_dvs(struct lp872x
*lp
, enum lp872x_dvs_sel dvs_sel
,
258 enum lp872x_dvs_state state
;
260 state
= dvs_sel
== SEL_V1
? DVS_HIGH
: DVS_LOW
;
261 gpio_set_value(gpio
, state
);
265 static u8
lp872x_select_buck_vout_addr(struct lp872x
*lp
,
266 enum lp872x_regulator_id buck
)
270 if (lp872x_read_byte(lp
, LP872X_GENERAL_CFG
, &val
))
275 if (val
& LP8720_EXT_DVS_M
) {
276 addr
= (lp
->dvs_pin
== DVS_HIGH
) ?
277 LP8720_BUCK_VOUT1
: LP8720_BUCK_VOUT2
;
279 if (lp872x_read_byte(lp
, LP8720_ENABLE
, &val
))
282 addr
= val
& LP8720_DVS_SEL_M
?
283 LP8720_BUCK_VOUT1
: LP8720_BUCK_VOUT2
;
286 case LP8725_ID_BUCK1
:
287 if (val
& LP8725_DVS1_M
)
288 addr
= LP8725_BUCK1_VOUT1
;
290 addr
= (lp
->dvs_pin
== DVS_HIGH
) ?
291 LP8725_BUCK1_VOUT1
: LP8725_BUCK1_VOUT2
;
293 case LP8725_ID_BUCK2
:
294 addr
= val
& LP8725_DVS2_M
?
295 LP8725_BUCK2_VOUT1
: LP8725_BUCK2_VOUT2
;
304 static bool lp872x_is_valid_buck_addr(u8 addr
)
307 case LP8720_BUCK_VOUT1
:
308 case LP8720_BUCK_VOUT2
:
309 case LP8725_BUCK1_VOUT1
:
310 case LP8725_BUCK1_VOUT2
:
311 case LP8725_BUCK2_VOUT1
:
312 case LP8725_BUCK2_VOUT2
:
319 static int lp872x_buck_set_voltage_sel(struct regulator_dev
*rdev
,
322 struct lp872x
*lp
= rdev_get_drvdata(rdev
);
323 enum lp872x_regulator_id buck
= rdev_get_id(rdev
);
324 u8 addr
, mask
= LP872X_VOUT_M
;
325 struct lp872x_dvs
*dvs
= lp
->pdata
? lp
->pdata
->dvs
: NULL
;
327 if (dvs
&& gpio_is_valid(dvs
->gpio
))
328 lp872x_set_dvs(lp
, dvs
->vsel
, dvs
->gpio
);
330 addr
= lp872x_select_buck_vout_addr(lp
, buck
);
331 if (!lp872x_is_valid_buck_addr(addr
))
334 return lp872x_update_bits(lp
, addr
, mask
, selector
);
337 static int lp872x_buck_get_voltage_sel(struct regulator_dev
*rdev
)
339 struct lp872x
*lp
= rdev_get_drvdata(rdev
);
340 enum lp872x_regulator_id buck
= rdev_get_id(rdev
);
344 addr
= lp872x_select_buck_vout_addr(lp
, buck
);
345 if (!lp872x_is_valid_buck_addr(addr
))
348 ret
= lp872x_read_byte(lp
, addr
, &val
);
352 return val
& LP872X_VOUT_M
;
355 static int lp8725_buck_set_current_limit(struct regulator_dev
*rdev
,
356 int min_uA
, int max_uA
)
358 struct lp872x
*lp
= rdev_get_drvdata(rdev
);
359 enum lp872x_regulator_id buck
= rdev_get_id(rdev
);
364 case LP8725_ID_BUCK1
:
365 addr
= LP8725_BUCK1_VOUT2
;
367 case LP8725_ID_BUCK2
:
368 addr
= LP8725_BUCK2_VOUT2
;
374 for (i
= ARRAY_SIZE(lp8725_buck_uA
) - 1; i
>= 0; i
--) {
375 if (lp8725_buck_uA
[i
] >= min_uA
&&
376 lp8725_buck_uA
[i
] <= max_uA
)
377 return lp872x_update_bits(lp
, addr
,
379 i
<< LP8725_BUCK_CL_S
);
385 static int lp8725_buck_get_current_limit(struct regulator_dev
*rdev
)
387 struct lp872x
*lp
= rdev_get_drvdata(rdev
);
388 enum lp872x_regulator_id buck
= rdev_get_id(rdev
);
393 case LP8725_ID_BUCK1
:
394 addr
= LP8725_BUCK1_VOUT2
;
396 case LP8725_ID_BUCK2
:
397 addr
= LP8725_BUCK2_VOUT2
;
403 ret
= lp872x_read_byte(lp
, addr
, &val
);
407 val
= (val
& LP8725_BUCK_CL_M
) >> LP8725_BUCK_CL_S
;
409 return (val
< ARRAY_SIZE(lp8725_buck_uA
)) ?
410 lp8725_buck_uA
[val
] : -EINVAL
;
413 static int lp872x_buck_set_mode(struct regulator_dev
*rdev
, unsigned int mode
)
415 struct lp872x
*lp
= rdev_get_drvdata(rdev
);
416 enum lp872x_regulator_id buck
= rdev_get_id(rdev
);
417 u8 addr
, mask
, shift
, val
;
421 addr
= LP8720_BUCK_VOUT2
;
422 mask
= LP8720_BUCK_FPWM_M
;
423 shift
= LP8720_BUCK_FPWM_S
;
425 case LP8725_ID_BUCK1
:
426 addr
= LP8725_BUCK_CTRL
;
427 mask
= LP8725_BUCK1_FPWM_M
;
428 shift
= LP8725_BUCK1_FPWM_S
;
430 case LP8725_ID_BUCK2
:
431 addr
= LP8725_BUCK_CTRL
;
432 mask
= LP8725_BUCK2_FPWM_M
;
433 shift
= LP8725_BUCK2_FPWM_S
;
439 if (mode
== REGULATOR_MODE_FAST
)
440 val
= LP872X_FORCE_PWM
<< shift
;
441 else if (mode
== REGULATOR_MODE_NORMAL
)
442 val
= LP872X_AUTO_PWM
<< shift
;
446 return lp872x_update_bits(lp
, addr
, mask
, val
);
449 static unsigned int lp872x_buck_get_mode(struct regulator_dev
*rdev
)
451 struct lp872x
*lp
= rdev_get_drvdata(rdev
);
452 enum lp872x_regulator_id buck
= rdev_get_id(rdev
);
458 addr
= LP8720_BUCK_VOUT2
;
459 mask
= LP8720_BUCK_FPWM_M
;
461 case LP8725_ID_BUCK1
:
462 addr
= LP8725_BUCK_CTRL
;
463 mask
= LP8725_BUCK1_FPWM_M
;
465 case LP8725_ID_BUCK2
:
466 addr
= LP8725_BUCK_CTRL
;
467 mask
= LP8725_BUCK2_FPWM_M
;
473 ret
= lp872x_read_byte(lp
, addr
, &val
);
477 return val
& mask
? REGULATOR_MODE_FAST
: REGULATOR_MODE_NORMAL
;
480 static struct regulator_ops lp872x_ldo_ops
= {
481 .list_voltage
= regulator_list_voltage_table
,
482 .map_voltage
= regulator_map_voltage_ascend
,
483 .set_voltage_sel
= regulator_set_voltage_sel_regmap
,
484 .get_voltage_sel
= regulator_get_voltage_sel_regmap
,
485 .enable
= regulator_enable_regmap
,
486 .disable
= regulator_disable_regmap
,
487 .is_enabled
= regulator_is_enabled_regmap
,
488 .enable_time
= lp872x_regulator_enable_time
,
491 static struct regulator_ops lp8720_buck_ops
= {
492 .list_voltage
= regulator_list_voltage_table
,
493 .map_voltage
= regulator_map_voltage_ascend
,
494 .set_voltage_sel
= lp872x_buck_set_voltage_sel
,
495 .get_voltage_sel
= lp872x_buck_get_voltage_sel
,
496 .enable
= regulator_enable_regmap
,
497 .disable
= regulator_disable_regmap
,
498 .is_enabled
= regulator_is_enabled_regmap
,
499 .enable_time
= lp872x_regulator_enable_time
,
500 .set_mode
= lp872x_buck_set_mode
,
501 .get_mode
= lp872x_buck_get_mode
,
504 static struct regulator_ops lp8725_buck_ops
= {
505 .list_voltage
= regulator_list_voltage_table
,
506 .map_voltage
= regulator_map_voltage_ascend
,
507 .set_voltage_sel
= lp872x_buck_set_voltage_sel
,
508 .get_voltage_sel
= lp872x_buck_get_voltage_sel
,
509 .enable
= regulator_enable_regmap
,
510 .disable
= regulator_disable_regmap
,
511 .is_enabled
= regulator_is_enabled_regmap
,
512 .enable_time
= lp872x_regulator_enable_time
,
513 .set_mode
= lp872x_buck_set_mode
,
514 .get_mode
= lp872x_buck_get_mode
,
515 .set_current_limit
= lp8725_buck_set_current_limit
,
516 .get_current_limit
= lp8725_buck_get_current_limit
,
519 static struct regulator_desc lp8720_regulator_desc
[] = {
522 .of_match
= of_match_ptr("ldo1"),
523 .id
= LP8720_ID_LDO1
,
524 .ops
= &lp872x_ldo_ops
,
525 .n_voltages
= ARRAY_SIZE(lp872x_ldo_vtbl
),
526 .volt_table
= lp872x_ldo_vtbl
,
527 .type
= REGULATOR_VOLTAGE
,
528 .owner
= THIS_MODULE
,
529 .vsel_reg
= LP872X_LDO1_VOUT
,
530 .vsel_mask
= LP872X_VOUT_M
,
531 .enable_reg
= LP8720_ENABLE
,
532 .enable_mask
= LP872X_EN_LDO1_M
,
536 .of_match
= of_match_ptr("ldo2"),
537 .id
= LP8720_ID_LDO2
,
538 .ops
= &lp872x_ldo_ops
,
539 .n_voltages
= ARRAY_SIZE(lp872x_ldo_vtbl
),
540 .volt_table
= lp872x_ldo_vtbl
,
541 .type
= REGULATOR_VOLTAGE
,
542 .owner
= THIS_MODULE
,
543 .vsel_reg
= LP872X_LDO2_VOUT
,
544 .vsel_mask
= LP872X_VOUT_M
,
545 .enable_reg
= LP8720_ENABLE
,
546 .enable_mask
= LP872X_EN_LDO2_M
,
550 .of_match
= of_match_ptr("ldo3"),
551 .id
= LP8720_ID_LDO3
,
552 .ops
= &lp872x_ldo_ops
,
553 .n_voltages
= ARRAY_SIZE(lp872x_ldo_vtbl
),
554 .volt_table
= lp872x_ldo_vtbl
,
555 .type
= REGULATOR_VOLTAGE
,
556 .owner
= THIS_MODULE
,
557 .vsel_reg
= LP872X_LDO3_VOUT
,
558 .vsel_mask
= LP872X_VOUT_M
,
559 .enable_reg
= LP8720_ENABLE
,
560 .enable_mask
= LP872X_EN_LDO3_M
,
564 .of_match
= of_match_ptr("ldo4"),
565 .id
= LP8720_ID_LDO4
,
566 .ops
= &lp872x_ldo_ops
,
567 .n_voltages
= ARRAY_SIZE(lp8720_ldo4_vtbl
),
568 .volt_table
= lp8720_ldo4_vtbl
,
569 .type
= REGULATOR_VOLTAGE
,
570 .owner
= THIS_MODULE
,
571 .vsel_reg
= LP872X_LDO4_VOUT
,
572 .vsel_mask
= LP872X_VOUT_M
,
573 .enable_reg
= LP8720_ENABLE
,
574 .enable_mask
= LP872X_EN_LDO4_M
,
578 .of_match
= of_match_ptr("ldo5"),
579 .id
= LP8720_ID_LDO5
,
580 .ops
= &lp872x_ldo_ops
,
581 .n_voltages
= ARRAY_SIZE(lp872x_ldo_vtbl
),
582 .volt_table
= lp872x_ldo_vtbl
,
583 .type
= REGULATOR_VOLTAGE
,
584 .owner
= THIS_MODULE
,
585 .vsel_reg
= LP872X_LDO5_VOUT
,
586 .vsel_mask
= LP872X_VOUT_M
,
587 .enable_reg
= LP8720_ENABLE
,
588 .enable_mask
= LP872X_EN_LDO5_M
,
592 .of_match
= of_match_ptr("buck"),
593 .id
= LP8720_ID_BUCK
,
594 .ops
= &lp8720_buck_ops
,
595 .n_voltages
= ARRAY_SIZE(lp8720_buck_vtbl
),
596 .volt_table
= lp8720_buck_vtbl
,
597 .type
= REGULATOR_VOLTAGE
,
598 .owner
= THIS_MODULE
,
599 .enable_reg
= LP8720_ENABLE
,
600 .enable_mask
= LP8720_EN_BUCK_M
,
604 static struct regulator_desc lp8725_regulator_desc
[] = {
607 .of_match
= of_match_ptr("ldo1"),
608 .id
= LP8725_ID_LDO1
,
609 .ops
= &lp872x_ldo_ops
,
610 .n_voltages
= ARRAY_SIZE(lp872x_ldo_vtbl
),
611 .volt_table
= lp872x_ldo_vtbl
,
612 .type
= REGULATOR_VOLTAGE
,
613 .owner
= THIS_MODULE
,
614 .vsel_reg
= LP872X_LDO1_VOUT
,
615 .vsel_mask
= LP872X_VOUT_M
,
616 .enable_reg
= LP8725_LDO_CTRL
,
617 .enable_mask
= LP872X_EN_LDO1_M
,
621 .of_match
= of_match_ptr("ldo2"),
622 .id
= LP8725_ID_LDO2
,
623 .ops
= &lp872x_ldo_ops
,
624 .n_voltages
= ARRAY_SIZE(lp872x_ldo_vtbl
),
625 .volt_table
= lp872x_ldo_vtbl
,
626 .type
= REGULATOR_VOLTAGE
,
627 .owner
= THIS_MODULE
,
628 .vsel_reg
= LP872X_LDO2_VOUT
,
629 .vsel_mask
= LP872X_VOUT_M
,
630 .enable_reg
= LP8725_LDO_CTRL
,
631 .enable_mask
= LP872X_EN_LDO2_M
,
635 .of_match
= of_match_ptr("ldo3"),
636 .id
= LP8725_ID_LDO3
,
637 .ops
= &lp872x_ldo_ops
,
638 .n_voltages
= ARRAY_SIZE(lp872x_ldo_vtbl
),
639 .volt_table
= lp872x_ldo_vtbl
,
640 .type
= REGULATOR_VOLTAGE
,
641 .owner
= THIS_MODULE
,
642 .vsel_reg
= LP872X_LDO3_VOUT
,
643 .vsel_mask
= LP872X_VOUT_M
,
644 .enable_reg
= LP8725_LDO_CTRL
,
645 .enable_mask
= LP872X_EN_LDO3_M
,
649 .of_match
= of_match_ptr("ldo4"),
650 .id
= LP8725_ID_LDO4
,
651 .ops
= &lp872x_ldo_ops
,
652 .n_voltages
= ARRAY_SIZE(lp872x_ldo_vtbl
),
653 .volt_table
= lp872x_ldo_vtbl
,
654 .type
= REGULATOR_VOLTAGE
,
655 .owner
= THIS_MODULE
,
656 .vsel_reg
= LP872X_LDO4_VOUT
,
657 .vsel_mask
= LP872X_VOUT_M
,
658 .enable_reg
= LP8725_LDO_CTRL
,
659 .enable_mask
= LP872X_EN_LDO4_M
,
663 .of_match
= of_match_ptr("ldo5"),
664 .id
= LP8725_ID_LDO5
,
665 .ops
= &lp872x_ldo_ops
,
666 .n_voltages
= ARRAY_SIZE(lp872x_ldo_vtbl
),
667 .volt_table
= lp872x_ldo_vtbl
,
668 .type
= REGULATOR_VOLTAGE
,
669 .owner
= THIS_MODULE
,
670 .vsel_reg
= LP872X_LDO5_VOUT
,
671 .vsel_mask
= LP872X_VOUT_M
,
672 .enable_reg
= LP8725_LDO_CTRL
,
673 .enable_mask
= LP872X_EN_LDO5_M
,
677 .of_match
= of_match_ptr("lilo1"),
678 .id
= LP8725_ID_LILO1
,
679 .ops
= &lp872x_ldo_ops
,
680 .n_voltages
= ARRAY_SIZE(lp8725_lilo_vtbl
),
681 .volt_table
= lp8725_lilo_vtbl
,
682 .type
= REGULATOR_VOLTAGE
,
683 .owner
= THIS_MODULE
,
684 .vsel_reg
= LP8725_LILO1_VOUT
,
685 .vsel_mask
= LP872X_VOUT_M
,
686 .enable_reg
= LP8725_LDO_CTRL
,
687 .enable_mask
= LP8725_EN_LILO1_M
,
691 .of_match
= of_match_ptr("lilo2"),
692 .id
= LP8725_ID_LILO2
,
693 .ops
= &lp872x_ldo_ops
,
694 .n_voltages
= ARRAY_SIZE(lp8725_lilo_vtbl
),
695 .volt_table
= lp8725_lilo_vtbl
,
696 .type
= REGULATOR_VOLTAGE
,
697 .owner
= THIS_MODULE
,
698 .vsel_reg
= LP8725_LILO2_VOUT
,
699 .vsel_mask
= LP872X_VOUT_M
,
700 .enable_reg
= LP8725_LDO_CTRL
,
701 .enable_mask
= LP8725_EN_LILO2_M
,
705 .of_match
= of_match_ptr("buck1"),
706 .id
= LP8725_ID_BUCK1
,
707 .ops
= &lp8725_buck_ops
,
708 .n_voltages
= ARRAY_SIZE(lp8725_buck_vtbl
),
709 .volt_table
= lp8725_buck_vtbl
,
710 .type
= REGULATOR_VOLTAGE
,
711 .owner
= THIS_MODULE
,
712 .enable_reg
= LP872X_GENERAL_CFG
,
713 .enable_mask
= LP8725_BUCK1_EN_M
,
717 .of_match
= of_match_ptr("buck2"),
718 .id
= LP8725_ID_BUCK2
,
719 .ops
= &lp8725_buck_ops
,
720 .n_voltages
= ARRAY_SIZE(lp8725_buck_vtbl
),
721 .volt_table
= lp8725_buck_vtbl
,
722 .type
= REGULATOR_VOLTAGE
,
723 .owner
= THIS_MODULE
,
724 .enable_reg
= LP872X_GENERAL_CFG
,
725 .enable_mask
= LP8725_BUCK2_EN_M
,
729 static int lp872x_init_dvs(struct lp872x
*lp
)
732 struct lp872x_dvs
*dvs
= lp
->pdata
? lp
->pdata
->dvs
: NULL
;
733 enum lp872x_dvs_state pinstate
;
734 u8 mask
[] = { LP8720_EXT_DVS_M
, LP8725_DVS1_M
| LP8725_DVS2_M
};
735 u8 default_dvs_mode
[] = { LP8720_DEFAULT_DVS
, LP8725_DEFAULT_DVS
};
738 goto set_default_dvs_mode
;
741 if (!gpio_is_valid(gpio
)) {
742 dev_warn(lp
->dev
, "invalid gpio: %d\n", gpio
);
743 goto set_default_dvs_mode
;
746 pinstate
= dvs
->init_state
;
747 ret
= devm_gpio_request_one(lp
->dev
, gpio
, pinstate
, "LP872X DVS");
749 dev_err(lp
->dev
, "gpio request err: %d\n", ret
);
753 lp
->dvs_pin
= pinstate
;
757 set_default_dvs_mode
:
758 return lp872x_update_bits(lp
, LP872X_GENERAL_CFG
, mask
[lp
->chipid
],
759 default_dvs_mode
[lp
->chipid
]);
762 static int lp872x_config(struct lp872x
*lp
)
764 struct lp872x_platform_data
*pdata
= lp
->pdata
;
767 if (!pdata
|| !pdata
->update_config
)
770 ret
= lp872x_write_byte(lp
, LP872X_GENERAL_CFG
, pdata
->general_config
);
775 return lp872x_init_dvs(lp
);
778 static struct regulator_init_data
779 *lp872x_find_regulator_init_data(int id
, struct lp872x
*lp
)
781 struct lp872x_platform_data
*pdata
= lp
->pdata
;
787 for (i
= 0; i
< lp
->num_regulators
; i
++) {
788 if (pdata
->regulator_data
[i
].id
== id
)
789 return pdata
->regulator_data
[i
].init_data
;
795 static int lp872x_regulator_register(struct lp872x
*lp
)
797 struct regulator_desc
*desc
;
798 struct regulator_config cfg
= { };
799 struct regulator_dev
*rdev
;
802 for (i
= 0; i
< lp
->num_regulators
; i
++) {
803 desc
= (lp
->chipid
== LP8720
) ? &lp8720_regulator_desc
[i
] :
804 &lp8725_regulator_desc
[i
];
807 cfg
.init_data
= lp872x_find_regulator_init_data(desc
->id
, lp
);
808 cfg
.driver_data
= lp
;
809 cfg
.regmap
= lp
->regmap
;
811 rdev
= devm_regulator_register(lp
->dev
, desc
, &cfg
);
813 dev_err(lp
->dev
, "regulator register err");
814 return PTR_ERR(rdev
);
821 static const struct regmap_config lp872x_regmap_config
= {
824 .max_register
= MAX_REGISTERS
,
829 #define LP872X_VALID_OPMODE (REGULATOR_MODE_FAST | REGULATOR_MODE_NORMAL)
831 static struct of_regulator_match lp8720_matches
[] = {
832 { .name
= "ldo1", .driver_data
= (void *)LP8720_ID_LDO1
, },
833 { .name
= "ldo2", .driver_data
= (void *)LP8720_ID_LDO2
, },
834 { .name
= "ldo3", .driver_data
= (void *)LP8720_ID_LDO3
, },
835 { .name
= "ldo4", .driver_data
= (void *)LP8720_ID_LDO4
, },
836 { .name
= "ldo5", .driver_data
= (void *)LP8720_ID_LDO5
, },
837 { .name
= "buck", .driver_data
= (void *)LP8720_ID_BUCK
, },
840 static struct of_regulator_match lp8725_matches
[] = {
841 { .name
= "ldo1", .driver_data
= (void *)LP8725_ID_LDO1
, },
842 { .name
= "ldo2", .driver_data
= (void *)LP8725_ID_LDO2
, },
843 { .name
= "ldo3", .driver_data
= (void *)LP8725_ID_LDO3
, },
844 { .name
= "ldo4", .driver_data
= (void *)LP8725_ID_LDO4
, },
845 { .name
= "ldo5", .driver_data
= (void *)LP8725_ID_LDO5
, },
846 { .name
= "lilo1", .driver_data
= (void *)LP8725_ID_LILO1
, },
847 { .name
= "lilo2", .driver_data
= (void *)LP8725_ID_LILO2
, },
848 { .name
= "buck1", .driver_data
= (void *)LP8725_ID_BUCK1
, },
849 { .name
= "buck2", .driver_data
= (void *)LP8725_ID_BUCK2
, },
852 static struct lp872x_platform_data
853 *lp872x_populate_pdata_from_dt(struct device
*dev
, enum lp872x_id which
)
855 struct device_node
*np
= dev
->of_node
;
856 struct lp872x_platform_data
*pdata
;
857 struct of_regulator_match
*match
;
863 pdata
= devm_kzalloc(dev
, sizeof(*pdata
), GFP_KERNEL
);
865 return ERR_PTR(-ENOMEM
);
867 of_property_read_u8(np
, "ti,general-config", &pdata
->general_config
);
868 if (of_find_property(np
, "ti,update-config", NULL
))
869 pdata
->update_config
= true;
871 pdata
->dvs
= devm_kzalloc(dev
, sizeof(struct lp872x_dvs
), GFP_KERNEL
);
873 return ERR_PTR(-ENOMEM
);
875 pdata
->dvs
->gpio
= of_get_named_gpio(np
, "ti,dvs-gpio", 0);
876 of_property_read_u8(np
, "ti,dvs-vsel", (u8
*)&pdata
->dvs
->vsel
);
877 of_property_read_u8(np
, "ti,dvs-state", &dvs_state
);
878 pdata
->dvs
->init_state
= dvs_state
? DVS_HIGH
: DVS_LOW
;
880 if (of_get_child_count(np
) == 0)
885 match
= lp8720_matches
;
886 num_matches
= ARRAY_SIZE(lp8720_matches
);
889 match
= lp8725_matches
;
890 num_matches
= ARRAY_SIZE(lp8725_matches
);
896 count
= of_regulator_match(dev
, np
, match
, num_matches
);
900 for (i
= 0; i
< num_matches
; i
++) {
901 pdata
->regulator_data
[i
].id
=
902 (enum lp872x_regulator_id
)match
[i
].driver_data
;
903 pdata
->regulator_data
[i
].init_data
= match
[i
].init_data
;
909 static struct lp872x_platform_data
910 *lp872x_populate_pdata_from_dt(struct device
*dev
, enum lp872x_id which
)
916 static int lp872x_probe(struct i2c_client
*cl
, const struct i2c_device_id
*id
)
919 struct lp872x_platform_data
*pdata
;
921 const int lp872x_num_regulators
[] = {
922 [LP8720
] = LP8720_NUM_REGULATORS
,
923 [LP8725
] = LP8725_NUM_REGULATORS
,
926 if (cl
->dev
.of_node
) {
927 pdata
= lp872x_populate_pdata_from_dt(&cl
->dev
,
928 (enum lp872x_id
)id
->driver_data
);
930 return PTR_ERR(pdata
);
932 pdata
= dev_get_platdata(&cl
->dev
);
935 lp
= devm_kzalloc(&cl
->dev
, sizeof(struct lp872x
), GFP_KERNEL
);
939 lp
->num_regulators
= lp872x_num_regulators
[id
->driver_data
];
941 lp
->regmap
= devm_regmap_init_i2c(cl
, &lp872x_regmap_config
);
942 if (IS_ERR(lp
->regmap
)) {
943 ret
= PTR_ERR(lp
->regmap
);
944 dev_err(&cl
->dev
, "regmap init i2c err: %d\n", ret
);
950 lp
->chipid
= id
->driver_data
;
951 i2c_set_clientdata(cl
, lp
);
953 ret
= lp872x_config(lp
);
957 return lp872x_regulator_register(lp
);
960 static const struct of_device_id lp872x_dt_ids
[] = {
961 { .compatible
= "ti,lp8720", },
962 { .compatible
= "ti,lp8725", },
965 MODULE_DEVICE_TABLE(of
, lp872x_dt_ids
);
967 static const struct i2c_device_id lp872x_ids
[] = {
972 MODULE_DEVICE_TABLE(i2c
, lp872x_ids
);
974 static struct i2c_driver lp872x_driver
= {
977 .of_match_table
= of_match_ptr(lp872x_dt_ids
),
979 .probe
= lp872x_probe
,
980 .id_table
= lp872x_ids
,
983 module_i2c_driver(lp872x_driver
);
985 MODULE_DESCRIPTION("TI/National Semiconductor LP872x PMU Regulator Driver");
986 MODULE_AUTHOR("Milo Kim");
987 MODULE_LICENSE("GPL");