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 sec_opmode_data
*opmode
;
49 struct sec_voltage_desc
{
55 static const struct sec_voltage_desc buck_voltage_val1
= {
61 static const struct sec_voltage_desc buck_voltage_val2
= {
67 static const struct sec_voltage_desc buck_voltage_val3
= {
73 static const struct sec_voltage_desc ldo_voltage_val1
= {
79 static const struct sec_voltage_desc ldo_voltage_val2
= {
85 static const struct sec_voltage_desc
*reg_voltage_map
[] = {
86 [S5M8767_LDO1
] = &ldo_voltage_val2
,
87 [S5M8767_LDO2
] = &ldo_voltage_val2
,
88 [S5M8767_LDO3
] = &ldo_voltage_val1
,
89 [S5M8767_LDO4
] = &ldo_voltage_val1
,
90 [S5M8767_LDO5
] = &ldo_voltage_val1
,
91 [S5M8767_LDO6
] = &ldo_voltage_val2
,
92 [S5M8767_LDO7
] = &ldo_voltage_val2
,
93 [S5M8767_LDO8
] = &ldo_voltage_val2
,
94 [S5M8767_LDO9
] = &ldo_voltage_val1
,
95 [S5M8767_LDO10
] = &ldo_voltage_val1
,
96 [S5M8767_LDO11
] = &ldo_voltage_val1
,
97 [S5M8767_LDO12
] = &ldo_voltage_val1
,
98 [S5M8767_LDO13
] = &ldo_voltage_val1
,
99 [S5M8767_LDO14
] = &ldo_voltage_val1
,
100 [S5M8767_LDO15
] = &ldo_voltage_val2
,
101 [S5M8767_LDO16
] = &ldo_voltage_val1
,
102 [S5M8767_LDO17
] = &ldo_voltage_val1
,
103 [S5M8767_LDO18
] = &ldo_voltage_val1
,
104 [S5M8767_LDO19
] = &ldo_voltage_val1
,
105 [S5M8767_LDO20
] = &ldo_voltage_val1
,
106 [S5M8767_LDO21
] = &ldo_voltage_val1
,
107 [S5M8767_LDO22
] = &ldo_voltage_val1
,
108 [S5M8767_LDO23
] = &ldo_voltage_val1
,
109 [S5M8767_LDO24
] = &ldo_voltage_val1
,
110 [S5M8767_LDO25
] = &ldo_voltage_val1
,
111 [S5M8767_LDO26
] = &ldo_voltage_val1
,
112 [S5M8767_LDO27
] = &ldo_voltage_val1
,
113 [S5M8767_LDO28
] = &ldo_voltage_val1
,
114 [S5M8767_BUCK1
] = &buck_voltage_val1
,
115 [S5M8767_BUCK2
] = &buck_voltage_val2
,
116 [S5M8767_BUCK3
] = &buck_voltage_val2
,
117 [S5M8767_BUCK4
] = &buck_voltage_val2
,
118 [S5M8767_BUCK5
] = &buck_voltage_val1
,
119 [S5M8767_BUCK6
] = &buck_voltage_val1
,
120 [S5M8767_BUCK7
] = &buck_voltage_val3
,
121 [S5M8767_BUCK8
] = &buck_voltage_val3
,
122 [S5M8767_BUCK9
] = &buck_voltage_val3
,
125 static unsigned int s5m8767_opmode_reg
[][4] = {
126 /* {OFF, ON, LOWPOWER, SUSPEND} */
128 {0x0, 0x3, 0x2, 0x1}, /* LDO1 */
129 {0x0, 0x3, 0x2, 0x1},
130 {0x0, 0x3, 0x2, 0x1},
131 {0x0, 0x0, 0x0, 0x0},
132 {0x0, 0x3, 0x2, 0x1}, /* LDO5 */
133 {0x0, 0x3, 0x2, 0x1},
134 {0x0, 0x3, 0x2, 0x1},
135 {0x0, 0x3, 0x2, 0x1},
136 {0x0, 0x3, 0x2, 0x1},
137 {0x0, 0x3, 0x2, 0x1}, /* LDO10 */
138 {0x0, 0x3, 0x2, 0x1},
139 {0x0, 0x3, 0x2, 0x1},
140 {0x0, 0x3, 0x2, 0x1},
141 {0x0, 0x3, 0x2, 0x1},
142 {0x0, 0x3, 0x2, 0x1}, /* LDO15 */
143 {0x0, 0x3, 0x2, 0x1},
144 {0x0, 0x3, 0x2, 0x1},
145 {0x0, 0x0, 0x0, 0x0},
146 {0x0, 0x3, 0x2, 0x1},
147 {0x0, 0x3, 0x2, 0x1}, /* LDO20 */
148 {0x0, 0x3, 0x2, 0x1},
149 {0x0, 0x3, 0x2, 0x1},
150 {0x0, 0x0, 0x0, 0x0},
151 {0x0, 0x3, 0x2, 0x1},
152 {0x0, 0x3, 0x2, 0x1}, /* LDO25 */
153 {0x0, 0x3, 0x2, 0x1},
154 {0x0, 0x3, 0x2, 0x1},
155 {0x0, 0x3, 0x2, 0x1}, /* LDO28 */
157 /* BUCK1 ... BUCK9 */
158 {0x0, 0x3, 0x1, 0x1}, /* BUCK1 */
159 {0x0, 0x3, 0x1, 0x1},
160 {0x0, 0x3, 0x1, 0x1},
161 {0x0, 0x3, 0x1, 0x1},
162 {0x0, 0x3, 0x2, 0x1}, /* BUCK5 */
163 {0x0, 0x3, 0x1, 0x1},
164 {0x0, 0x3, 0x1, 0x1},
165 {0x0, 0x3, 0x1, 0x1},
166 {0x0, 0x3, 0x1, 0x1}, /* BUCK9 */
169 static int s5m8767_get_register(struct s5m8767_info
*s5m8767
, int reg_id
,
170 int *reg
, int *enable_ctrl
)
176 case S5M8767_LDO1
... S5M8767_LDO2
:
177 *reg
= S5M8767_REG_LDO1CTRL
+ (reg_id
- S5M8767_LDO1
);
179 case S5M8767_LDO3
... S5M8767_LDO28
:
180 *reg
= S5M8767_REG_LDO3CTRL
+ (reg_id
- S5M8767_LDO3
);
183 *reg
= S5M8767_REG_BUCK1CTRL1
;
185 case S5M8767_BUCK2
... S5M8767_BUCK4
:
186 *reg
= S5M8767_REG_BUCK2CTRL
+ (reg_id
- S5M8767_BUCK2
) * 9;
189 *reg
= S5M8767_REG_BUCK5CTRL1
;
191 case S5M8767_BUCK6
... S5M8767_BUCK9
:
192 *reg
= S5M8767_REG_BUCK6CTRL1
+ (reg_id
- S5M8767_BUCK6
) * 2;
198 for (i
= 0; i
< s5m8767
->num_regulators
; i
++) {
199 if (s5m8767
->opmode
[i
].id
== reg_id
) {
200 mode
= s5m8767
->opmode
[i
].mode
;
205 if (i
>= s5m8767
->num_regulators
)
208 *enable_ctrl
= 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 int s5m8767_pmic_dt_parse_pdata(struct platform_device
*pdev
,
533 struct sec_platform_data
*pdata
)
535 struct sec_pmic_dev
*iodev
= dev_get_drvdata(pdev
->dev
.parent
);
536 struct device_node
*pmic_np
, *regulators_np
, *reg_np
;
537 struct sec_regulator_data
*rdata
;
538 struct sec_opmode_data
*rmode
;
539 unsigned int i
, dvs_voltage_nr
= 8, ret
;
541 pmic_np
= iodev
->dev
->of_node
;
543 dev_err(iodev
->dev
, "could not find pmic sub-node\n");
547 regulators_np
= of_get_child_by_name(pmic_np
, "regulators");
548 if (!regulators_np
) {
549 dev_err(iodev
->dev
, "could not find regulators sub-node\n");
553 /* count the number of regulators to be supported in pmic */
554 pdata
->num_regulators
= of_get_child_count(regulators_np
);
556 rdata
= devm_kzalloc(&pdev
->dev
, sizeof(*rdata
) *
557 pdata
->num_regulators
, GFP_KERNEL
);
561 rmode
= devm_kzalloc(&pdev
->dev
, sizeof(*rmode
) *
562 pdata
->num_regulators
, GFP_KERNEL
);
566 pdata
->regulators
= rdata
;
567 pdata
->opmode
= rmode
;
568 for_each_child_of_node(regulators_np
, reg_np
) {
569 for (i
= 0; i
< ARRAY_SIZE(regulators
); i
++)
570 if (!of_node_cmp(reg_np
->name
, regulators
[i
].name
))
573 if (i
== ARRAY_SIZE(regulators
)) {
575 "don't know how to configure regulator %s\n",
580 rdata
->ext_control_gpio
= of_get_named_gpio(reg_np
,
581 "s5m8767,pmic-ext-control-gpios", 0);
584 rdata
->initdata
= of_get_regulator_init_data(
587 rdata
->reg_node
= reg_np
;
590 if (of_property_read_u32(reg_np
, "op_mode",
593 "no op_mode property property at %s\n",
596 rmode
->mode
= S5M8767_OPMODE_NORMAL_MODE
;
601 of_node_put(regulators_np
);
603 if (of_get_property(pmic_np
, "s5m8767,pmic-buck2-uses-gpio-dvs", NULL
)) {
604 pdata
->buck2_gpiodvs
= true;
606 if (of_property_read_u32_array(pmic_np
,
607 "s5m8767,pmic-buck2-dvs-voltage",
608 pdata
->buck2_voltage
, dvs_voltage_nr
)) {
609 dev_err(iodev
->dev
, "buck2 voltages not specified\n");
614 if (of_get_property(pmic_np
, "s5m8767,pmic-buck3-uses-gpio-dvs", NULL
)) {
615 pdata
->buck3_gpiodvs
= true;
617 if (of_property_read_u32_array(pmic_np
,
618 "s5m8767,pmic-buck3-dvs-voltage",
619 pdata
->buck3_voltage
, dvs_voltage_nr
)) {
620 dev_err(iodev
->dev
, "buck3 voltages not specified\n");
625 if (of_get_property(pmic_np
, "s5m8767,pmic-buck4-uses-gpio-dvs", NULL
)) {
626 pdata
->buck4_gpiodvs
= true;
628 if (of_property_read_u32_array(pmic_np
,
629 "s5m8767,pmic-buck4-dvs-voltage",
630 pdata
->buck4_voltage
, dvs_voltage_nr
)) {
631 dev_err(iodev
->dev
, "buck4 voltages not specified\n");
636 if (pdata
->buck2_gpiodvs
|| pdata
->buck3_gpiodvs
||
637 pdata
->buck4_gpiodvs
) {
638 ret
= s5m8767_pmic_dt_parse_dvs_gpio(iodev
, pdata
, pmic_np
);
642 if (of_property_read_u32(pmic_np
,
643 "s5m8767,pmic-buck-default-dvs-idx",
644 &pdata
->buck_default_idx
)) {
645 pdata
->buck_default_idx
= 0;
647 if (pdata
->buck_default_idx
>= 8) {
648 pdata
->buck_default_idx
= 0;
650 "invalid value for default dvs index, use 0\n");
655 ret
= s5m8767_pmic_dt_parse_ds_gpio(iodev
, pdata
, pmic_np
);
659 if (of_get_property(pmic_np
, "s5m8767,pmic-buck2-ramp-enable", NULL
))
660 pdata
->buck2_ramp_enable
= true;
662 if (of_get_property(pmic_np
, "s5m8767,pmic-buck3-ramp-enable", NULL
))
663 pdata
->buck3_ramp_enable
= true;
665 if (of_get_property(pmic_np
, "s5m8767,pmic-buck4-ramp-enable", NULL
))
666 pdata
->buck4_ramp_enable
= true;
668 if (pdata
->buck2_ramp_enable
|| pdata
->buck3_ramp_enable
669 || pdata
->buck4_ramp_enable
) {
670 if (of_property_read_u32(pmic_np
, "s5m8767,pmic-buck-ramp-delay",
671 &pdata
->buck_ramp_delay
))
672 pdata
->buck_ramp_delay
= 0;
678 static int s5m8767_pmic_dt_parse_pdata(struct platform_device
*pdev
,
679 struct sec_platform_data
*pdata
)
683 #endif /* CONFIG_OF */
685 static int s5m8767_pmic_probe(struct platform_device
*pdev
)
687 struct sec_pmic_dev
*iodev
= dev_get_drvdata(pdev
->dev
.parent
);
688 struct sec_platform_data
*pdata
= iodev
->pdata
;
689 struct regulator_config config
= { };
690 struct s5m8767_info
*s5m8767
;
691 int i
, ret
, buck_init
;
694 dev_err(pdev
->dev
.parent
, "Platform data not supplied\n");
698 if (iodev
->dev
->of_node
) {
699 ret
= s5m8767_pmic_dt_parse_pdata(pdev
, pdata
);
704 if (pdata
->buck2_gpiodvs
) {
705 if (pdata
->buck3_gpiodvs
|| pdata
->buck4_gpiodvs
) {
706 dev_err(&pdev
->dev
, "S5M8767 GPIO DVS NOT VALID\n");
711 if (pdata
->buck3_gpiodvs
) {
712 if (pdata
->buck2_gpiodvs
|| pdata
->buck4_gpiodvs
) {
713 dev_err(&pdev
->dev
, "S5M8767 GPIO DVS NOT VALID\n");
718 if (pdata
->buck4_gpiodvs
) {
719 if (pdata
->buck2_gpiodvs
|| pdata
->buck3_gpiodvs
) {
720 dev_err(&pdev
->dev
, "S5M8767 GPIO DVS NOT VALID\n");
725 s5m8767
= devm_kzalloc(&pdev
->dev
, sizeof(struct s5m8767_info
),
730 s5m8767
->dev
= &pdev
->dev
;
731 s5m8767
->iodev
= iodev
;
732 s5m8767
->num_regulators
= pdata
->num_regulators
;
733 platform_set_drvdata(pdev
, s5m8767
);
735 s5m8767
->buck_gpioindex
= pdata
->buck_default_idx
;
736 s5m8767
->buck2_gpiodvs
= pdata
->buck2_gpiodvs
;
737 s5m8767
->buck3_gpiodvs
= pdata
->buck3_gpiodvs
;
738 s5m8767
->buck4_gpiodvs
= pdata
->buck4_gpiodvs
;
739 s5m8767
->buck_gpios
[0] = pdata
->buck_gpios
[0];
740 s5m8767
->buck_gpios
[1] = pdata
->buck_gpios
[1];
741 s5m8767
->buck_gpios
[2] = pdata
->buck_gpios
[2];
742 s5m8767
->buck_ds
[0] = pdata
->buck_ds
[0];
743 s5m8767
->buck_ds
[1] = pdata
->buck_ds
[1];
744 s5m8767
->buck_ds
[2] = pdata
->buck_ds
[2];
746 s5m8767
->ramp_delay
= pdata
->buck_ramp_delay
;
747 s5m8767
->buck2_ramp
= pdata
->buck2_ramp_enable
;
748 s5m8767
->buck3_ramp
= pdata
->buck3_ramp_enable
;
749 s5m8767
->buck4_ramp
= pdata
->buck4_ramp_enable
;
750 s5m8767
->opmode
= pdata
->opmode
;
752 buck_init
= s5m8767_convert_voltage_to_sel(&buck_voltage_val2
,
755 regmap_write(s5m8767
->iodev
->regmap_pmic
, S5M8767_REG_BUCK2DVS2
,
758 buck_init
= s5m8767_convert_voltage_to_sel(&buck_voltage_val2
,
761 regmap_write(s5m8767
->iodev
->regmap_pmic
, S5M8767_REG_BUCK3DVS2
,
764 buck_init
= s5m8767_convert_voltage_to_sel(&buck_voltage_val2
,
767 regmap_write(s5m8767
->iodev
->regmap_pmic
, S5M8767_REG_BUCK4DVS2
,
770 for (i
= 0; i
< 8; i
++) {
771 if (s5m8767
->buck2_gpiodvs
) {
772 s5m8767
->buck2_vol
[i
] =
773 s5m8767_convert_voltage_to_sel(
775 pdata
->buck2_voltage
[i
]);
778 if (s5m8767
->buck3_gpiodvs
) {
779 s5m8767
->buck3_vol
[i
] =
780 s5m8767_convert_voltage_to_sel(
782 pdata
->buck3_voltage
[i
]);
785 if (s5m8767
->buck4_gpiodvs
) {
786 s5m8767
->buck4_vol
[i
] =
787 s5m8767_convert_voltage_to_sel(
789 pdata
->buck4_voltage
[i
]);
793 if (pdata
->buck2_gpiodvs
|| pdata
->buck3_gpiodvs
||
794 pdata
->buck4_gpiodvs
) {
796 if (!gpio_is_valid(pdata
->buck_gpios
[0]) ||
797 !gpio_is_valid(pdata
->buck_gpios
[1]) ||
798 !gpio_is_valid(pdata
->buck_gpios
[2])) {
799 dev_err(&pdev
->dev
, "GPIO NOT VALID\n");
803 ret
= devm_gpio_request(&pdev
->dev
, pdata
->buck_gpios
[0],
808 ret
= devm_gpio_request(&pdev
->dev
, pdata
->buck_gpios
[1],
813 ret
= devm_gpio_request(&pdev
->dev
, pdata
->buck_gpios
[2],
819 gpio_direction_output(pdata
->buck_gpios
[0],
820 (s5m8767
->buck_gpioindex
>> 2) & 0x1);
822 gpio_direction_output(pdata
->buck_gpios
[1],
823 (s5m8767
->buck_gpioindex
>> 1) & 0x1);
825 gpio_direction_output(pdata
->buck_gpios
[2],
826 (s5m8767
->buck_gpioindex
>> 0) & 0x1);
829 ret
= devm_gpio_request(&pdev
->dev
, pdata
->buck_ds
[0], "S5M8767 DS2");
833 ret
= devm_gpio_request(&pdev
->dev
, pdata
->buck_ds
[1], "S5M8767 DS3");
837 ret
= devm_gpio_request(&pdev
->dev
, pdata
->buck_ds
[2], "S5M8767 DS4");
842 gpio_direction_output(pdata
->buck_ds
[0], 0x0);
844 gpio_direction_output(pdata
->buck_ds
[1], 0x0);
846 gpio_direction_output(pdata
->buck_ds
[2], 0x0);
848 if (pdata
->buck2_gpiodvs
|| pdata
->buck3_gpiodvs
||
849 pdata
->buck4_gpiodvs
) {
850 regmap_update_bits(s5m8767
->iodev
->regmap_pmic
,
851 S5M8767_REG_BUCK2CTRL
, 1 << 1,
852 (pdata
->buck2_gpiodvs
) ? (1 << 1) : (0 << 1));
853 regmap_update_bits(s5m8767
->iodev
->regmap_pmic
,
854 S5M8767_REG_BUCK3CTRL
, 1 << 1,
855 (pdata
->buck3_gpiodvs
) ? (1 << 1) : (0 << 1));
856 regmap_update_bits(s5m8767
->iodev
->regmap_pmic
,
857 S5M8767_REG_BUCK4CTRL
, 1 << 1,
858 (pdata
->buck4_gpiodvs
) ? (1 << 1) : (0 << 1));
861 /* Initialize GPIO DVS registers */
862 for (i
= 0; i
< 8; i
++) {
863 if (s5m8767
->buck2_gpiodvs
) {
864 regmap_write(s5m8767
->iodev
->regmap_pmic
,
865 S5M8767_REG_BUCK2DVS1
+ i
,
866 s5m8767
->buck2_vol
[i
]);
869 if (s5m8767
->buck3_gpiodvs
) {
870 regmap_write(s5m8767
->iodev
->regmap_pmic
,
871 S5M8767_REG_BUCK3DVS1
+ i
,
872 s5m8767
->buck3_vol
[i
]);
875 if (s5m8767
->buck4_gpiodvs
) {
876 regmap_write(s5m8767
->iodev
->regmap_pmic
,
877 S5M8767_REG_BUCK4DVS1
+ i
,
878 s5m8767
->buck4_vol
[i
]);
882 if (s5m8767
->buck2_ramp
)
883 regmap_update_bits(s5m8767
->iodev
->regmap_pmic
,
884 S5M8767_REG_DVSRAMP
, 0x08, 0x08);
886 if (s5m8767
->buck3_ramp
)
887 regmap_update_bits(s5m8767
->iodev
->regmap_pmic
,
888 S5M8767_REG_DVSRAMP
, 0x04, 0x04);
890 if (s5m8767
->buck4_ramp
)
891 regmap_update_bits(s5m8767
->iodev
->regmap_pmic
,
892 S5M8767_REG_DVSRAMP
, 0x02, 0x02);
894 if (s5m8767
->buck2_ramp
|| s5m8767
->buck3_ramp
895 || s5m8767
->buck4_ramp
) {
897 switch (s5m8767
->ramp_delay
) {
899 val
= S5M8767_DVS_BUCK_RAMP_5
;
902 val
= S5M8767_DVS_BUCK_RAMP_10
;
905 val
= S5M8767_DVS_BUCK_RAMP_25
;
908 val
= S5M8767_DVS_BUCK_RAMP_50
;
911 val
= S5M8767_DVS_BUCK_RAMP_100
;
914 val
= S5M8767_DVS_BUCK_RAMP_10
;
916 regmap_update_bits(s5m8767
->iodev
->regmap_pmic
,
918 S5M8767_DVS_BUCK_RAMP_MASK
,
919 val
<< S5M8767_DVS_BUCK_RAMP_SHIFT
);
922 for (i
= 0; i
< pdata
->num_regulators
; i
++) {
923 const struct sec_voltage_desc
*desc
;
924 int id
= pdata
->regulators
[i
].id
;
925 int enable_reg
, enable_val
;
926 struct regulator_dev
*rdev
;
928 desc
= reg_voltage_map
[id
];
930 regulators
[id
].n_voltages
=
931 (desc
->max
- desc
->min
) / desc
->step
+ 1;
932 regulators
[id
].min_uV
= desc
->min
;
933 regulators
[id
].uV_step
= desc
->step
;
934 regulators
[id
].vsel_reg
=
935 s5m8767_get_vsel_reg(id
, s5m8767
);
936 if (id
< S5M8767_BUCK1
)
937 regulators
[id
].vsel_mask
= 0x3f;
939 regulators
[id
].vsel_mask
= 0xff;
941 ret
= s5m8767_get_register(s5m8767
, id
, &enable_reg
,
944 dev_err(s5m8767
->dev
, "error reading registers\n");
947 regulators
[id
].enable_reg
= enable_reg
;
948 regulators
[id
].enable_mask
= S5M8767_ENCTRL_MASK
;
949 regulators
[id
].enable_val
= enable_val
;
952 config
.dev
= s5m8767
->dev
;
953 config
.init_data
= pdata
->regulators
[i
].initdata
;
954 config
.driver_data
= s5m8767
;
955 config
.regmap
= iodev
->regmap_pmic
;
956 config
.of_node
= pdata
->regulators
[i
].reg_node
;
957 config
.ena_gpio
= -EINVAL
;
958 config
.ena_gpio_flags
= 0;
959 config
.ena_gpio_initialized
= true;
960 if (gpio_is_valid(pdata
->regulators
[i
].ext_control_gpio
))
961 s5m8767_regulator_config_ext_control(s5m8767
,
962 &pdata
->regulators
[i
], &config
);
964 rdev
= devm_regulator_register(&pdev
->dev
, ®ulators
[id
],
968 dev_err(s5m8767
->dev
, "regulator init failed for %d\n",
973 if (gpio_is_valid(pdata
->regulators
[i
].ext_control_gpio
)) {
974 ret
= s5m8767_enable_ext_control(s5m8767
, rdev
);
976 dev_err(s5m8767
->dev
,
977 "failed to enable gpio control over %s: %d\n",
978 rdev
->desc
->name
, ret
);
987 static const struct platform_device_id s5m8767_pmic_id
[] = {
988 { "s5m8767-pmic", 0},
991 MODULE_DEVICE_TABLE(platform
, s5m8767_pmic_id
);
993 static struct platform_driver s5m8767_pmic_driver
= {
995 .name
= "s5m8767-pmic",
997 .probe
= s5m8767_pmic_probe
,
998 .id_table
= s5m8767_pmic_id
,
1001 static int __init
s5m8767_pmic_init(void)
1003 return platform_driver_register(&s5m8767_pmic_driver
);
1005 subsys_initcall(s5m8767_pmic_init
);
1007 static void __exit
s5m8767_pmic_exit(void)
1009 platform_driver_unregister(&s5m8767_pmic_driver
);
1011 module_exit(s5m8767_pmic_exit
);
1013 /* Module information */
1014 MODULE_AUTHOR("Sangbeom Kim <sbkim73@samsung.com>");
1015 MODULE_DESCRIPTION("SAMSUNG S5M8767 Regulator Driver");
1016 MODULE_LICENSE("GPL");