4 * Copyright (c) 2011 Samsung Electronics Co., Ltd
5 * http://www.samsung.com
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the
9 * Free Software Foundation; either version 2 of the License, or (at your
10 * option) any later version.
14 #include <linux/err.h>
15 #include <linux/of_gpio.h>
16 #include <linux/module.h>
17 #include <linux/platform_device.h>
18 #include <linux/regulator/driver.h>
19 #include <linux/regulator/machine.h>
20 #include <linux/mfd/samsung/core.h>
21 #include <linux/mfd/samsung/s5m8767.h>
22 #include <linux/regulator/of_regulator.h>
23 #include <linux/regmap.h>
25 #define S5M8767_OPMODE_NORMAL_MODE 0x1
29 struct sec_pmic_dev
*iodev
;
31 struct regulator_dev
**rdev
;
32 struct sec_opmode_data
*opmode
;
50 struct sec_voltage_desc
{
56 static const struct sec_voltage_desc buck_voltage_val1
= {
62 static const struct sec_voltage_desc buck_voltage_val2
= {
68 static const struct sec_voltage_desc buck_voltage_val3
= {
74 static const struct sec_voltage_desc ldo_voltage_val1
= {
80 static const struct sec_voltage_desc ldo_voltage_val2
= {
86 static const struct sec_voltage_desc
*reg_voltage_map
[] = {
87 [S5M8767_LDO1
] = &ldo_voltage_val2
,
88 [S5M8767_LDO2
] = &ldo_voltage_val2
,
89 [S5M8767_LDO3
] = &ldo_voltage_val1
,
90 [S5M8767_LDO4
] = &ldo_voltage_val1
,
91 [S5M8767_LDO5
] = &ldo_voltage_val1
,
92 [S5M8767_LDO6
] = &ldo_voltage_val2
,
93 [S5M8767_LDO7
] = &ldo_voltage_val2
,
94 [S5M8767_LDO8
] = &ldo_voltage_val2
,
95 [S5M8767_LDO9
] = &ldo_voltage_val1
,
96 [S5M8767_LDO10
] = &ldo_voltage_val1
,
97 [S5M8767_LDO11
] = &ldo_voltage_val1
,
98 [S5M8767_LDO12
] = &ldo_voltage_val1
,
99 [S5M8767_LDO13
] = &ldo_voltage_val1
,
100 [S5M8767_LDO14
] = &ldo_voltage_val1
,
101 [S5M8767_LDO15
] = &ldo_voltage_val2
,
102 [S5M8767_LDO16
] = &ldo_voltage_val1
,
103 [S5M8767_LDO17
] = &ldo_voltage_val1
,
104 [S5M8767_LDO18
] = &ldo_voltage_val1
,
105 [S5M8767_LDO19
] = &ldo_voltage_val1
,
106 [S5M8767_LDO20
] = &ldo_voltage_val1
,
107 [S5M8767_LDO21
] = &ldo_voltage_val1
,
108 [S5M8767_LDO22
] = &ldo_voltage_val1
,
109 [S5M8767_LDO23
] = &ldo_voltage_val1
,
110 [S5M8767_LDO24
] = &ldo_voltage_val1
,
111 [S5M8767_LDO25
] = &ldo_voltage_val1
,
112 [S5M8767_LDO26
] = &ldo_voltage_val1
,
113 [S5M8767_LDO27
] = &ldo_voltage_val1
,
114 [S5M8767_LDO28
] = &ldo_voltage_val1
,
115 [S5M8767_BUCK1
] = &buck_voltage_val1
,
116 [S5M8767_BUCK2
] = &buck_voltage_val2
,
117 [S5M8767_BUCK3
] = &buck_voltage_val2
,
118 [S5M8767_BUCK4
] = &buck_voltage_val2
,
119 [S5M8767_BUCK5
] = &buck_voltage_val1
,
120 [S5M8767_BUCK6
] = &buck_voltage_val1
,
121 [S5M8767_BUCK7
] = &buck_voltage_val3
,
122 [S5M8767_BUCK8
] = &buck_voltage_val3
,
123 [S5M8767_BUCK9
] = &buck_voltage_val3
,
126 static unsigned int s5m8767_opmode_reg
[][4] = {
127 /* {OFF, ON, LOWPOWER, SUSPEND} */
129 {0x0, 0x3, 0x2, 0x1}, /* LDO1 */
130 {0x0, 0x3, 0x2, 0x1},
131 {0x0, 0x3, 0x2, 0x1},
132 {0x0, 0x0, 0x0, 0x0},
133 {0x0, 0x3, 0x2, 0x1}, /* LDO5 */
134 {0x0, 0x3, 0x2, 0x1},
135 {0x0, 0x3, 0x2, 0x1},
136 {0x0, 0x3, 0x2, 0x1},
137 {0x0, 0x3, 0x2, 0x1},
138 {0x0, 0x3, 0x2, 0x1}, /* LDO10 */
139 {0x0, 0x3, 0x2, 0x1},
140 {0x0, 0x3, 0x2, 0x1},
141 {0x0, 0x3, 0x2, 0x1},
142 {0x0, 0x3, 0x2, 0x1},
143 {0x0, 0x3, 0x2, 0x1}, /* LDO15 */
144 {0x0, 0x3, 0x2, 0x1},
145 {0x0, 0x3, 0x2, 0x1},
146 {0x0, 0x0, 0x0, 0x0},
147 {0x0, 0x3, 0x2, 0x1},
148 {0x0, 0x3, 0x2, 0x1}, /* LDO20 */
149 {0x0, 0x3, 0x2, 0x1},
150 {0x0, 0x3, 0x2, 0x1},
151 {0x0, 0x0, 0x0, 0x0},
152 {0x0, 0x3, 0x2, 0x1},
153 {0x0, 0x3, 0x2, 0x1}, /* LDO25 */
154 {0x0, 0x3, 0x2, 0x1},
155 {0x0, 0x3, 0x2, 0x1},
156 {0x0, 0x3, 0x2, 0x1}, /* LDO28 */
158 /* BUCK1 ... BUCK9 */
159 {0x0, 0x3, 0x1, 0x1}, /* BUCK1 */
160 {0x0, 0x3, 0x1, 0x1},
161 {0x0, 0x3, 0x1, 0x1},
162 {0x0, 0x3, 0x1, 0x1},
163 {0x0, 0x3, 0x2, 0x1}, /* BUCK5 */
164 {0x0, 0x3, 0x1, 0x1},
165 {0x0, 0x3, 0x1, 0x1},
166 {0x0, 0x3, 0x1, 0x1},
167 {0x0, 0x3, 0x1, 0x1}, /* BUCK9 */
170 static int s5m8767_get_register(struct s5m8767_info
*s5m8767
, int reg_id
,
171 int *reg
, int *enable_ctrl
)
177 case S5M8767_LDO1
... S5M8767_LDO2
:
178 *reg
= S5M8767_REG_LDO1CTRL
+ (reg_id
- S5M8767_LDO1
);
180 case S5M8767_LDO3
... S5M8767_LDO28
:
181 *reg
= S5M8767_REG_LDO3CTRL
+ (reg_id
- S5M8767_LDO3
);
184 *reg
= S5M8767_REG_BUCK1CTRL1
;
186 case S5M8767_BUCK2
... S5M8767_BUCK4
:
187 *reg
= S5M8767_REG_BUCK2CTRL
+ (reg_id
- S5M8767_BUCK2
) * 9;
190 *reg
= S5M8767_REG_BUCK5CTRL1
;
192 case S5M8767_BUCK6
... S5M8767_BUCK9
:
193 *reg
= S5M8767_REG_BUCK6CTRL1
+ (reg_id
- S5M8767_BUCK6
) * 2;
199 for (i
= 0; i
< s5m8767
->num_regulators
; i
++) {
200 if (s5m8767
->opmode
[i
].id
== reg_id
) {
201 mode
= s5m8767
->opmode
[i
].mode
;
206 if (i
< s5m8767
->num_regulators
)
208 s5m8767_opmode_reg
[reg_id
][mode
] << S5M8767_ENCTRL_SHIFT
;
213 static int s5m8767_get_vsel_reg(int reg_id
, struct s5m8767_info
*s5m8767
)
218 case S5M8767_LDO1
... S5M8767_LDO2
:
219 reg
= S5M8767_REG_LDO1CTRL
+ (reg_id
- S5M8767_LDO1
);
221 case S5M8767_LDO3
... S5M8767_LDO28
:
222 reg
= S5M8767_REG_LDO3CTRL
+ (reg_id
- S5M8767_LDO3
);
225 reg
= S5M8767_REG_BUCK1CTRL2
;
228 reg
= S5M8767_REG_BUCK2DVS1
;
229 if (s5m8767
->buck2_gpiodvs
)
230 reg
+= s5m8767
->buck_gpioindex
;
233 reg
= S5M8767_REG_BUCK3DVS1
;
234 if (s5m8767
->buck3_gpiodvs
)
235 reg
+= s5m8767
->buck_gpioindex
;
238 reg
= S5M8767_REG_BUCK4DVS1
;
239 if (s5m8767
->buck4_gpiodvs
)
240 reg
+= s5m8767
->buck_gpioindex
;
243 reg
= S5M8767_REG_BUCK5CTRL2
;
245 case S5M8767_BUCK6
... S5M8767_BUCK9
:
246 reg
= S5M8767_REG_BUCK6CTRL2
+ (reg_id
- S5M8767_BUCK6
) * 2;
255 static int s5m8767_convert_voltage_to_sel(const struct sec_voltage_desc
*desc
,
263 if (min_vol
> desc
->max
)
266 if (min_vol
< desc
->min
)
269 selector
= DIV_ROUND_UP(min_vol
- desc
->min
, desc
->step
);
271 if (desc
->min
+ desc
->step
* selector
> desc
->max
)
277 static inline int s5m8767_set_high(struct s5m8767_info
*s5m8767
)
279 int temp_index
= s5m8767
->buck_gpioindex
;
281 gpio_set_value(s5m8767
->buck_gpios
[0], (temp_index
>> 2) & 0x1);
282 gpio_set_value(s5m8767
->buck_gpios
[1], (temp_index
>> 1) & 0x1);
283 gpio_set_value(s5m8767
->buck_gpios
[2], temp_index
& 0x1);
288 static inline int s5m8767_set_low(struct s5m8767_info
*s5m8767
)
290 int temp_index
= s5m8767
->buck_gpioindex
;
292 gpio_set_value(s5m8767
->buck_gpios
[2], temp_index
& 0x1);
293 gpio_set_value(s5m8767
->buck_gpios
[1], (temp_index
>> 1) & 0x1);
294 gpio_set_value(s5m8767
->buck_gpios
[0], (temp_index
>> 2) & 0x1);
299 static int s5m8767_set_voltage_sel(struct regulator_dev
*rdev
,
302 struct s5m8767_info
*s5m8767
= rdev_get_drvdata(rdev
);
303 int reg_id
= rdev_get_id(rdev
);
304 int old_index
, index
= 0;
305 u8
*buck234_vol
= NULL
;
308 case S5M8767_LDO1
... S5M8767_LDO28
:
310 case S5M8767_BUCK1
... S5M8767_BUCK6
:
311 if (reg_id
== S5M8767_BUCK2
&& s5m8767
->buck2_gpiodvs
)
312 buck234_vol
= &s5m8767
->buck2_vol
[0];
313 else if (reg_id
== S5M8767_BUCK3
&& s5m8767
->buck3_gpiodvs
)
314 buck234_vol
= &s5m8767
->buck3_vol
[0];
315 else if (reg_id
== S5M8767_BUCK4
&& s5m8767
->buck4_gpiodvs
)
316 buck234_vol
= &s5m8767
->buck4_vol
[0];
318 case S5M8767_BUCK7
... S5M8767_BUCK8
:
326 /* buck234_vol != NULL means to control buck234 voltage via DVS GPIO */
328 while (*buck234_vol
!= selector
) {
332 old_index
= s5m8767
->buck_gpioindex
;
333 s5m8767
->buck_gpioindex
= index
;
335 if (index
> old_index
)
336 return s5m8767_set_high(s5m8767
);
338 return s5m8767_set_low(s5m8767
);
340 return regulator_set_voltage_sel_regmap(rdev
, selector
);
344 static int s5m8767_set_voltage_time_sel(struct regulator_dev
*rdev
,
345 unsigned int old_sel
,
346 unsigned int new_sel
)
348 struct s5m8767_info
*s5m8767
= rdev_get_drvdata(rdev
);
349 const struct sec_voltage_desc
*desc
;
350 int reg_id
= rdev_get_id(rdev
);
352 desc
= reg_voltage_map
[reg_id
];
354 if ((old_sel
< new_sel
) && s5m8767
->ramp_delay
)
355 return DIV_ROUND_UP(desc
->step
* (new_sel
- old_sel
),
356 s5m8767
->ramp_delay
* 1000);
360 static struct regulator_ops s5m8767_ops
= {
361 .list_voltage
= regulator_list_voltage_linear
,
362 .is_enabled
= regulator_is_enabled_regmap
,
363 .enable
= regulator_enable_regmap
,
364 .disable
= regulator_disable_regmap
,
365 .get_voltage_sel
= regulator_get_voltage_sel_regmap
,
366 .set_voltage_sel
= s5m8767_set_voltage_sel
,
367 .set_voltage_time_sel
= s5m8767_set_voltage_time_sel
,
370 static struct regulator_ops s5m8767_buck78_ops
= {
371 .list_voltage
= regulator_list_voltage_linear
,
372 .is_enabled
= regulator_is_enabled_regmap
,
373 .enable
= regulator_enable_regmap
,
374 .disable
= regulator_disable_regmap
,
375 .get_voltage_sel
= regulator_get_voltage_sel_regmap
,
376 .set_voltage_sel
= regulator_set_voltage_sel_regmap
,
379 #define s5m8767_regulator_desc(_name) { \
381 .id = S5M8767_##_name, \
382 .ops = &s5m8767_ops, \
383 .type = REGULATOR_VOLTAGE, \
384 .owner = THIS_MODULE, \
387 #define s5m8767_regulator_buck78_desc(_name) { \
389 .id = S5M8767_##_name, \
390 .ops = &s5m8767_buck78_ops, \
391 .type = REGULATOR_VOLTAGE, \
392 .owner = THIS_MODULE, \
395 static struct regulator_desc regulators
[] = {
396 s5m8767_regulator_desc(LDO1
),
397 s5m8767_regulator_desc(LDO2
),
398 s5m8767_regulator_desc(LDO3
),
399 s5m8767_regulator_desc(LDO4
),
400 s5m8767_regulator_desc(LDO5
),
401 s5m8767_regulator_desc(LDO6
),
402 s5m8767_regulator_desc(LDO7
),
403 s5m8767_regulator_desc(LDO8
),
404 s5m8767_regulator_desc(LDO9
),
405 s5m8767_regulator_desc(LDO10
),
406 s5m8767_regulator_desc(LDO11
),
407 s5m8767_regulator_desc(LDO12
),
408 s5m8767_regulator_desc(LDO13
),
409 s5m8767_regulator_desc(LDO14
),
410 s5m8767_regulator_desc(LDO15
),
411 s5m8767_regulator_desc(LDO16
),
412 s5m8767_regulator_desc(LDO17
),
413 s5m8767_regulator_desc(LDO18
),
414 s5m8767_regulator_desc(LDO19
),
415 s5m8767_regulator_desc(LDO20
),
416 s5m8767_regulator_desc(LDO21
),
417 s5m8767_regulator_desc(LDO22
),
418 s5m8767_regulator_desc(LDO23
),
419 s5m8767_regulator_desc(LDO24
),
420 s5m8767_regulator_desc(LDO25
),
421 s5m8767_regulator_desc(LDO26
),
422 s5m8767_regulator_desc(LDO27
),
423 s5m8767_regulator_desc(LDO28
),
424 s5m8767_regulator_desc(BUCK1
),
425 s5m8767_regulator_desc(BUCK2
),
426 s5m8767_regulator_desc(BUCK3
),
427 s5m8767_regulator_desc(BUCK4
),
428 s5m8767_regulator_desc(BUCK5
),
429 s5m8767_regulator_desc(BUCK6
),
430 s5m8767_regulator_buck78_desc(BUCK7
),
431 s5m8767_regulator_buck78_desc(BUCK8
),
432 s5m8767_regulator_desc(BUCK9
),
436 * Enable GPIO control over BUCK9 in regulator_config for that regulator.
438 static void s5m8767_regulator_config_ext_control(struct s5m8767_info
*s5m8767
,
439 struct sec_regulator_data
*rdata
,
440 struct regulator_config
*config
)
444 if (rdata
->id
!= S5M8767_BUCK9
)
447 /* Check if opmode for regulator matches S5M8767_ENCTRL_USE_GPIO */
448 for (i
= 0; i
< s5m8767
->num_regulators
; i
++) {
449 const struct sec_opmode_data
*opmode
= &s5m8767
->opmode
[i
];
450 if (opmode
->id
== rdata
->id
) {
451 mode
= s5m8767_opmode_reg
[rdata
->id
][opmode
->mode
];
455 if (mode
!= S5M8767_ENCTRL_USE_GPIO
) {
456 dev_warn(s5m8767
->dev
,
457 "ext-control for %s: mismatched op_mode (%x), ignoring\n",
458 rdata
->reg_node
->name
, mode
);
462 if (!gpio_is_valid(rdata
->ext_control_gpio
)) {
463 dev_warn(s5m8767
->dev
,
464 "ext-control for %s: GPIO not valid, ignoring\n",
465 rdata
->reg_node
->name
);
469 config
->ena_gpio
= rdata
->ext_control_gpio
;
470 config
->ena_gpio_flags
= GPIOF_OUT_INIT_HIGH
;
474 * Turn on GPIO control over BUCK9.
476 static int s5m8767_enable_ext_control(struct s5m8767_info
*s5m8767
,
477 struct regulator_dev
*rdev
)
479 int id
= rdev_get_id(rdev
);
480 int ret
, reg
, enable_ctrl
;
482 if (id
!= S5M8767_BUCK9
)
485 ret
= s5m8767_get_register(s5m8767
, id
, ®
, &enable_ctrl
);
489 return regmap_update_bits(s5m8767
->iodev
->regmap_pmic
,
490 reg
, S5M8767_ENCTRL_MASK
,
491 S5M8767_ENCTRL_USE_GPIO
<< S5M8767_ENCTRL_SHIFT
);
496 static int s5m8767_pmic_dt_parse_dvs_gpio(struct sec_pmic_dev
*iodev
,
497 struct sec_platform_data
*pdata
,
498 struct device_node
*pmic_np
)
502 for (i
= 0; i
< 3; i
++) {
503 gpio
= of_get_named_gpio(pmic_np
,
504 "s5m8767,pmic-buck-dvs-gpios", i
);
505 if (!gpio_is_valid(gpio
)) {
506 dev_err(iodev
->dev
, "invalid gpio[%d]: %d\n", i
, gpio
);
509 pdata
->buck_gpios
[i
] = gpio
;
514 static int s5m8767_pmic_dt_parse_ds_gpio(struct sec_pmic_dev
*iodev
,
515 struct sec_platform_data
*pdata
,
516 struct device_node
*pmic_np
)
520 for (i
= 0; i
< 3; i
++) {
521 gpio
= of_get_named_gpio(pmic_np
,
522 "s5m8767,pmic-buck-ds-gpios", i
);
523 if (!gpio_is_valid(gpio
)) {
524 dev_err(iodev
->dev
, "invalid gpio[%d]: %d\n", i
, gpio
);
527 pdata
->buck_ds
[i
] = gpio
;
532 static void s5m8767_pmic_dt_parse_ext_control_gpio(struct sec_pmic_dev
*iodev
,
533 struct sec_regulator_data
*rdata
,
534 struct device_node
*reg_np
)
536 rdata
->ext_control_gpio
= of_get_named_gpio(reg_np
,
537 "s5m8767,pmic-ext-control-gpios", 0);
538 if (!gpio_is_valid(rdata
->ext_control_gpio
))
539 rdata
->ext_control_gpio
= 0;
542 static int s5m8767_pmic_dt_parse_pdata(struct platform_device
*pdev
,
543 struct sec_platform_data
*pdata
)
545 struct sec_pmic_dev
*iodev
= dev_get_drvdata(pdev
->dev
.parent
);
546 struct device_node
*pmic_np
, *regulators_np
, *reg_np
;
547 struct sec_regulator_data
*rdata
;
548 struct sec_opmode_data
*rmode
;
549 unsigned int i
, dvs_voltage_nr
= 8, ret
;
551 pmic_np
= iodev
->dev
->of_node
;
553 dev_err(iodev
->dev
, "could not find pmic sub-node\n");
557 regulators_np
= of_get_child_by_name(pmic_np
, "regulators");
558 if (!regulators_np
) {
559 dev_err(iodev
->dev
, "could not find regulators sub-node\n");
563 /* count the number of regulators to be supported in pmic */
564 pdata
->num_regulators
= of_get_child_count(regulators_np
);
566 rdata
= devm_kzalloc(&pdev
->dev
, sizeof(*rdata
) *
567 pdata
->num_regulators
, GFP_KERNEL
);
571 rmode
= devm_kzalloc(&pdev
->dev
, sizeof(*rmode
) *
572 pdata
->num_regulators
, GFP_KERNEL
);
576 pdata
->regulators
= rdata
;
577 pdata
->opmode
= rmode
;
578 for_each_child_of_node(regulators_np
, reg_np
) {
579 for (i
= 0; i
< ARRAY_SIZE(regulators
); i
++)
580 if (!of_node_cmp(reg_np
->name
, regulators
[i
].name
))
583 if (i
== ARRAY_SIZE(regulators
)) {
585 "don't know how to configure regulator %s\n",
590 s5m8767_pmic_dt_parse_ext_control_gpio(iodev
, rdata
, reg_np
);
593 rdata
->initdata
= of_get_regulator_init_data(
595 rdata
->reg_node
= reg_np
;
598 if (of_property_read_u32(reg_np
, "op_mode",
601 "no op_mode property property at %s\n",
604 rmode
->mode
= S5M8767_OPMODE_NORMAL_MODE
;
609 of_node_put(regulators_np
);
611 if (of_get_property(pmic_np
, "s5m8767,pmic-buck2-uses-gpio-dvs", NULL
)) {
612 pdata
->buck2_gpiodvs
= true;
614 if (of_property_read_u32_array(pmic_np
,
615 "s5m8767,pmic-buck2-dvs-voltage",
616 pdata
->buck2_voltage
, dvs_voltage_nr
)) {
617 dev_err(iodev
->dev
, "buck2 voltages not specified\n");
622 if (of_get_property(pmic_np
, "s5m8767,pmic-buck3-uses-gpio-dvs", NULL
)) {
623 pdata
->buck3_gpiodvs
= true;
625 if (of_property_read_u32_array(pmic_np
,
626 "s5m8767,pmic-buck3-dvs-voltage",
627 pdata
->buck3_voltage
, dvs_voltage_nr
)) {
628 dev_err(iodev
->dev
, "buck3 voltages not specified\n");
633 if (of_get_property(pmic_np
, "s5m8767,pmic-buck4-uses-gpio-dvs", NULL
)) {
634 pdata
->buck4_gpiodvs
= true;
636 if (of_property_read_u32_array(pmic_np
,
637 "s5m8767,pmic-buck4-dvs-voltage",
638 pdata
->buck4_voltage
, dvs_voltage_nr
)) {
639 dev_err(iodev
->dev
, "buck4 voltages not specified\n");
644 if (pdata
->buck2_gpiodvs
|| pdata
->buck3_gpiodvs
||
645 pdata
->buck4_gpiodvs
) {
646 ret
= s5m8767_pmic_dt_parse_dvs_gpio(iodev
, pdata
, pmic_np
);
650 if (of_property_read_u32(pmic_np
,
651 "s5m8767,pmic-buck-default-dvs-idx",
652 &pdata
->buck_default_idx
)) {
653 pdata
->buck_default_idx
= 0;
655 if (pdata
->buck_default_idx
>= 8) {
656 pdata
->buck_default_idx
= 0;
658 "invalid value for default dvs index, use 0\n");
663 ret
= s5m8767_pmic_dt_parse_ds_gpio(iodev
, pdata
, pmic_np
);
667 if (of_get_property(pmic_np
, "s5m8767,pmic-buck2-ramp-enable", NULL
))
668 pdata
->buck2_ramp_enable
= true;
670 if (of_get_property(pmic_np
, "s5m8767,pmic-buck3-ramp-enable", NULL
))
671 pdata
->buck3_ramp_enable
= true;
673 if (of_get_property(pmic_np
, "s5m8767,pmic-buck4-ramp-enable", NULL
))
674 pdata
->buck4_ramp_enable
= true;
676 if (pdata
->buck2_ramp_enable
|| pdata
->buck3_ramp_enable
677 || pdata
->buck4_ramp_enable
) {
678 if (of_property_read_u32(pmic_np
, "s5m8767,pmic-buck-ramp-delay",
679 &pdata
->buck_ramp_delay
))
680 pdata
->buck_ramp_delay
= 0;
686 static int s5m8767_pmic_dt_parse_pdata(struct platform_device
*pdev
,
687 struct sec_platform_data
*pdata
)
691 #endif /* CONFIG_OF */
693 static int s5m8767_pmic_probe(struct platform_device
*pdev
)
695 struct sec_pmic_dev
*iodev
= dev_get_drvdata(pdev
->dev
.parent
);
696 struct sec_platform_data
*pdata
= iodev
->pdata
;
697 struct regulator_config config
= { };
698 struct regulator_dev
**rdev
;
699 struct s5m8767_info
*s5m8767
;
700 int i
, ret
, size
, buck_init
;
703 dev_err(pdev
->dev
.parent
, "Platform data not supplied\n");
707 if (iodev
->dev
->of_node
) {
708 ret
= s5m8767_pmic_dt_parse_pdata(pdev
, pdata
);
713 if (pdata
->buck2_gpiodvs
) {
714 if (pdata
->buck3_gpiodvs
|| pdata
->buck4_gpiodvs
) {
715 dev_err(&pdev
->dev
, "S5M8767 GPIO DVS NOT VALID\n");
720 if (pdata
->buck3_gpiodvs
) {
721 if (pdata
->buck2_gpiodvs
|| pdata
->buck4_gpiodvs
) {
722 dev_err(&pdev
->dev
, "S5M8767 GPIO DVS NOT VALID\n");
727 if (pdata
->buck4_gpiodvs
) {
728 if (pdata
->buck2_gpiodvs
|| pdata
->buck3_gpiodvs
) {
729 dev_err(&pdev
->dev
, "S5M8767 GPIO DVS NOT VALID\n");
734 s5m8767
= devm_kzalloc(&pdev
->dev
, sizeof(struct s5m8767_info
),
739 size
= sizeof(struct regulator_dev
*) * (S5M8767_REG_MAX
- 2);
740 s5m8767
->rdev
= devm_kzalloc(&pdev
->dev
, size
, GFP_KERNEL
);
744 rdev
= s5m8767
->rdev
;
745 s5m8767
->dev
= &pdev
->dev
;
746 s5m8767
->iodev
= iodev
;
747 s5m8767
->num_regulators
= pdata
->num_regulators
;
748 platform_set_drvdata(pdev
, s5m8767
);
750 s5m8767
->buck_gpioindex
= pdata
->buck_default_idx
;
751 s5m8767
->buck2_gpiodvs
= pdata
->buck2_gpiodvs
;
752 s5m8767
->buck3_gpiodvs
= pdata
->buck3_gpiodvs
;
753 s5m8767
->buck4_gpiodvs
= pdata
->buck4_gpiodvs
;
754 s5m8767
->buck_gpios
[0] = pdata
->buck_gpios
[0];
755 s5m8767
->buck_gpios
[1] = pdata
->buck_gpios
[1];
756 s5m8767
->buck_gpios
[2] = pdata
->buck_gpios
[2];
757 s5m8767
->buck_ds
[0] = pdata
->buck_ds
[0];
758 s5m8767
->buck_ds
[1] = pdata
->buck_ds
[1];
759 s5m8767
->buck_ds
[2] = pdata
->buck_ds
[2];
761 s5m8767
->ramp_delay
= pdata
->buck_ramp_delay
;
762 s5m8767
->buck2_ramp
= pdata
->buck2_ramp_enable
;
763 s5m8767
->buck3_ramp
= pdata
->buck3_ramp_enable
;
764 s5m8767
->buck4_ramp
= pdata
->buck4_ramp_enable
;
765 s5m8767
->opmode
= pdata
->opmode
;
767 buck_init
= s5m8767_convert_voltage_to_sel(&buck_voltage_val2
,
770 regmap_write(s5m8767
->iodev
->regmap_pmic
, S5M8767_REG_BUCK2DVS2
,
773 buck_init
= s5m8767_convert_voltage_to_sel(&buck_voltage_val2
,
776 regmap_write(s5m8767
->iodev
->regmap_pmic
, S5M8767_REG_BUCK3DVS2
,
779 buck_init
= s5m8767_convert_voltage_to_sel(&buck_voltage_val2
,
782 regmap_write(s5m8767
->iodev
->regmap_pmic
, S5M8767_REG_BUCK4DVS2
,
785 for (i
= 0; i
< 8; i
++) {
786 if (s5m8767
->buck2_gpiodvs
) {
787 s5m8767
->buck2_vol
[i
] =
788 s5m8767_convert_voltage_to_sel(
790 pdata
->buck2_voltage
[i
]);
793 if (s5m8767
->buck3_gpiodvs
) {
794 s5m8767
->buck3_vol
[i
] =
795 s5m8767_convert_voltage_to_sel(
797 pdata
->buck3_voltage
[i
]);
800 if (s5m8767
->buck4_gpiodvs
) {
801 s5m8767
->buck4_vol
[i
] =
802 s5m8767_convert_voltage_to_sel(
804 pdata
->buck4_voltage
[i
]);
808 if (pdata
->buck2_gpiodvs
|| pdata
->buck3_gpiodvs
||
809 pdata
->buck4_gpiodvs
) {
811 if (!gpio_is_valid(pdata
->buck_gpios
[0]) ||
812 !gpio_is_valid(pdata
->buck_gpios
[1]) ||
813 !gpio_is_valid(pdata
->buck_gpios
[2])) {
814 dev_err(&pdev
->dev
, "GPIO NOT VALID\n");
818 ret
= devm_gpio_request(&pdev
->dev
, pdata
->buck_gpios
[0],
823 ret
= devm_gpio_request(&pdev
->dev
, pdata
->buck_gpios
[1],
828 ret
= devm_gpio_request(&pdev
->dev
, pdata
->buck_gpios
[2],
834 gpio_direction_output(pdata
->buck_gpios
[0],
835 (s5m8767
->buck_gpioindex
>> 2) & 0x1);
837 gpio_direction_output(pdata
->buck_gpios
[1],
838 (s5m8767
->buck_gpioindex
>> 1) & 0x1);
840 gpio_direction_output(pdata
->buck_gpios
[2],
841 (s5m8767
->buck_gpioindex
>> 0) & 0x1);
844 ret
= devm_gpio_request(&pdev
->dev
, pdata
->buck_ds
[0], "S5M8767 DS2");
848 ret
= devm_gpio_request(&pdev
->dev
, pdata
->buck_ds
[1], "S5M8767 DS3");
852 ret
= devm_gpio_request(&pdev
->dev
, pdata
->buck_ds
[2], "S5M8767 DS4");
857 gpio_direction_output(pdata
->buck_ds
[0], 0x0);
859 gpio_direction_output(pdata
->buck_ds
[1], 0x0);
861 gpio_direction_output(pdata
->buck_ds
[2], 0x0);
863 if (pdata
->buck2_gpiodvs
|| pdata
->buck3_gpiodvs
||
864 pdata
->buck4_gpiodvs
) {
865 regmap_update_bits(s5m8767
->iodev
->regmap_pmic
,
866 S5M8767_REG_BUCK2CTRL
, 1 << 1,
867 (pdata
->buck2_gpiodvs
) ? (1 << 1) : (0 << 1));
868 regmap_update_bits(s5m8767
->iodev
->regmap_pmic
,
869 S5M8767_REG_BUCK3CTRL
, 1 << 1,
870 (pdata
->buck3_gpiodvs
) ? (1 << 1) : (0 << 1));
871 regmap_update_bits(s5m8767
->iodev
->regmap_pmic
,
872 S5M8767_REG_BUCK4CTRL
, 1 << 1,
873 (pdata
->buck4_gpiodvs
) ? (1 << 1) : (0 << 1));
876 /* Initialize GPIO DVS registers */
877 for (i
= 0; i
< 8; i
++) {
878 if (s5m8767
->buck2_gpiodvs
) {
879 regmap_write(s5m8767
->iodev
->regmap_pmic
,
880 S5M8767_REG_BUCK2DVS1
+ i
,
881 s5m8767
->buck2_vol
[i
]);
884 if (s5m8767
->buck3_gpiodvs
) {
885 regmap_write(s5m8767
->iodev
->regmap_pmic
,
886 S5M8767_REG_BUCK3DVS1
+ i
,
887 s5m8767
->buck3_vol
[i
]);
890 if (s5m8767
->buck4_gpiodvs
) {
891 regmap_write(s5m8767
->iodev
->regmap_pmic
,
892 S5M8767_REG_BUCK4DVS1
+ i
,
893 s5m8767
->buck4_vol
[i
]);
897 if (s5m8767
->buck2_ramp
)
898 regmap_update_bits(s5m8767
->iodev
->regmap_pmic
,
899 S5M8767_REG_DVSRAMP
, 0x08, 0x08);
901 if (s5m8767
->buck3_ramp
)
902 regmap_update_bits(s5m8767
->iodev
->regmap_pmic
,
903 S5M8767_REG_DVSRAMP
, 0x04, 0x04);
905 if (s5m8767
->buck4_ramp
)
906 regmap_update_bits(s5m8767
->iodev
->regmap_pmic
,
907 S5M8767_REG_DVSRAMP
, 0x02, 0x02);
909 if (s5m8767
->buck2_ramp
|| s5m8767
->buck3_ramp
910 || s5m8767
->buck4_ramp
) {
912 switch (s5m8767
->ramp_delay
) {
914 val
= S5M8767_DVS_BUCK_RAMP_5
;
917 val
= S5M8767_DVS_BUCK_RAMP_10
;
920 val
= S5M8767_DVS_BUCK_RAMP_25
;
923 val
= S5M8767_DVS_BUCK_RAMP_50
;
926 val
= S5M8767_DVS_BUCK_RAMP_100
;
929 val
= S5M8767_DVS_BUCK_RAMP_10
;
931 regmap_update_bits(s5m8767
->iodev
->regmap_pmic
,
933 S5M8767_DVS_BUCK_RAMP_MASK
,
934 val
<< S5M8767_DVS_BUCK_RAMP_SHIFT
);
937 for (i
= 0; i
< pdata
->num_regulators
; i
++) {
938 const struct sec_voltage_desc
*desc
;
939 int id
= pdata
->regulators
[i
].id
;
940 int enable_reg
, enable_val
;
942 desc
= reg_voltage_map
[id
];
944 regulators
[id
].n_voltages
=
945 (desc
->max
- desc
->min
) / desc
->step
+ 1;
946 regulators
[id
].min_uV
= desc
->min
;
947 regulators
[id
].uV_step
= desc
->step
;
948 regulators
[id
].vsel_reg
=
949 s5m8767_get_vsel_reg(id
, s5m8767
);
950 if (id
< S5M8767_BUCK1
)
951 regulators
[id
].vsel_mask
= 0x3f;
953 regulators
[id
].vsel_mask
= 0xff;
955 s5m8767_get_register(s5m8767
, id
, &enable_reg
,
957 regulators
[id
].enable_reg
= enable_reg
;
958 regulators
[id
].enable_mask
= S5M8767_ENCTRL_MASK
;
959 regulators
[id
].enable_val
= enable_val
;
962 config
.dev
= s5m8767
->dev
;
963 config
.init_data
= pdata
->regulators
[i
].initdata
;
964 config
.driver_data
= s5m8767
;
965 config
.regmap
= iodev
->regmap_pmic
;
966 config
.of_node
= pdata
->regulators
[i
].reg_node
;
967 if (pdata
->regulators
[i
].ext_control_gpio
)
968 s5m8767_regulator_config_ext_control(s5m8767
,
969 &pdata
->regulators
[i
], &config
);
971 rdev
[i
] = devm_regulator_register(&pdev
->dev
, ®ulators
[id
],
973 if (IS_ERR(rdev
[i
])) {
974 ret
= PTR_ERR(rdev
[i
]);
975 dev_err(s5m8767
->dev
, "regulator init failed for %d\n",
980 if (pdata
->regulators
[i
].ext_control_gpio
) {
981 ret
= s5m8767_enable_ext_control(s5m8767
, rdev
[i
]);
983 dev_err(s5m8767
->dev
,
984 "failed to enable gpio control over %s: %d\n",
985 rdev
[i
]->desc
->name
, ret
);
994 static const struct platform_device_id s5m8767_pmic_id
[] = {
995 { "s5m8767-pmic", 0},
998 MODULE_DEVICE_TABLE(platform
, s5m8767_pmic_id
);
1000 static struct platform_driver s5m8767_pmic_driver
= {
1002 .name
= "s5m8767-pmic",
1003 .owner
= THIS_MODULE
,
1005 .probe
= s5m8767_pmic_probe
,
1006 .id_table
= s5m8767_pmic_id
,
1009 static int __init
s5m8767_pmic_init(void)
1011 return platform_driver_register(&s5m8767_pmic_driver
);
1013 subsys_initcall(s5m8767_pmic_init
);
1015 static void __exit
s5m8767_pmic_exit(void)
1017 platform_driver_unregister(&s5m8767_pmic_driver
);
1019 module_exit(s5m8767_pmic_exit
);
1021 /* Module information */
1022 MODULE_AUTHOR("Sangbeom Kim <sbkim73@samsung.com>");
1023 MODULE_DESCRIPTION("SAMSUNG S5M8767 Regulator Driver");
1024 MODULE_LICENSE("GPL");