1 // SPDX-License-Identifier: GPL-2.0
2 // Copyright (C) 2018 ROHM Semiconductors
3 // bd71837-regulator.c ROHM BD71837MWV/BD71847MWV regulator driver
5 #include <linux/delay.h>
7 #include <linux/interrupt.h>
8 #include <linux/kernel.h>
9 #include <linux/mfd/rohm-bd718x7.h>
10 #include <linux/module.h>
12 #include <linux/platform_device.h>
13 #include <linux/regulator/driver.h>
14 #include <linux/regulator/machine.h>
15 #include <linux/regulator/of_regulator.h>
16 #include <linux/slab.h>
20 * BUCK1RAMPRATE[1:0] BUCK1 DVS ramp rate setting
21 * 00: 10.00mV/usec 10mV 1uS
22 * 01: 5.00mV/usec 10mV 2uS
23 * 10: 2.50mV/usec 10mV 4uS
24 * 11: 1.25mV/usec 10mV 8uS
26 static int bd718xx_buck1234_set_ramp_delay(struct regulator_dev *rdev,
29 int id = rdev_get_id(rdev);
30 unsigned int ramp_value;
32 dev_dbg(&rdev->dev, "Buck[%d] Set Ramp = %d\n", id + 1,
36 ramp_value = BUCK_RAMPRATE_1P25MV;
39 ramp_value = BUCK_RAMPRATE_2P50MV;
42 ramp_value = BUCK_RAMPRATE_5P00MV;
45 ramp_value = BUCK_RAMPRATE_10P00MV;
48 ramp_value = BUCK_RAMPRATE_10P00MV;
50 "%s: ramp_delay: %d not supported, setting 10000mV//us\n",
51 rdev->desc->name, ramp_delay);
54 return regmap_update_bits(rdev->regmap, BD718XX_REG_BUCK1_CTRL + id,
55 BUCK_RAMPRATE_MASK, ramp_value << 6);
58 /* Bucks 1 to 4 support DVS. PWM mode is used when voltage is changed.
59 * Bucks 5 to 8 and LDOs can use PFM and must be disabled when voltage
60 * is changed. Hence we return -EBUSY for these if voltage is changed
61 * when BUCK/LDO is enabled.
63 static int bd718xx_set_voltage_sel_restricted(struct regulator_dev *rdev,
66 if (regulator_is_enabled_regmap(rdev))
69 return regulator_set_voltage_sel_regmap(rdev, sel);
72 static int bd718xx_set_voltage_sel_pickable_restricted(
73 struct regulator_dev *rdev, unsigned int sel)
75 if (regulator_is_enabled_regmap(rdev))
78 return regulator_set_voltage_sel_pickable_regmap(rdev, sel);
81 static const struct regulator_ops bd718xx_pickable_range_ldo_ops = {
82 .enable = regulator_enable_regmap,
83 .disable = regulator_disable_regmap,
84 .is_enabled = regulator_is_enabled_regmap,
85 .list_voltage = regulator_list_voltage_pickable_linear_range,
86 .set_voltage_sel = bd718xx_set_voltage_sel_pickable_restricted,
87 .get_voltage_sel = regulator_get_voltage_sel_pickable_regmap,
90 static const struct regulator_ops bd718xx_pickable_range_buck_ops = {
91 .enable = regulator_enable_regmap,
92 .disable = regulator_disable_regmap,
93 .is_enabled = regulator_is_enabled_regmap,
94 .list_voltage = regulator_list_voltage_pickable_linear_range,
95 .set_voltage_sel = bd718xx_set_voltage_sel_pickable_restricted,
96 .get_voltage_sel = regulator_get_voltage_sel_pickable_regmap,
97 .set_voltage_time_sel = regulator_set_voltage_time_sel,
100 static const struct regulator_ops bd718xx_ldo_regulator_ops = {
101 .enable = regulator_enable_regmap,
102 .disable = regulator_disable_regmap,
103 .is_enabled = regulator_is_enabled_regmap,
104 .list_voltage = regulator_list_voltage_linear_range,
105 .set_voltage_sel = bd718xx_set_voltage_sel_restricted,
106 .get_voltage_sel = regulator_get_voltage_sel_regmap,
109 static const struct regulator_ops bd718xx_ldo_regulator_nolinear_ops = {
110 .enable = regulator_enable_regmap,
111 .disable = regulator_disable_regmap,
112 .is_enabled = regulator_is_enabled_regmap,
113 .list_voltage = regulator_list_voltage_table,
114 .set_voltage_sel = bd718xx_set_voltage_sel_restricted,
115 .get_voltage_sel = regulator_get_voltage_sel_regmap,
118 static const struct regulator_ops bd718xx_buck_regulator_ops = {
119 .enable = regulator_enable_regmap,
120 .disable = regulator_disable_regmap,
121 .is_enabled = regulator_is_enabled_regmap,
122 .list_voltage = regulator_list_voltage_linear_range,
123 .set_voltage_sel = bd718xx_set_voltage_sel_restricted,
124 .get_voltage_sel = regulator_get_voltage_sel_regmap,
125 .set_voltage_time_sel = regulator_set_voltage_time_sel,
128 static const struct regulator_ops bd718xx_buck_regulator_nolinear_ops = {
129 .enable = regulator_enable_regmap,
130 .disable = regulator_disable_regmap,
131 .is_enabled = regulator_is_enabled_regmap,
132 .list_voltage = regulator_list_voltage_table,
133 .map_voltage = regulator_map_voltage_ascend,
134 .set_voltage_sel = bd718xx_set_voltage_sel_restricted,
135 .get_voltage_sel = regulator_get_voltage_sel_regmap,
136 .set_voltage_time_sel = regulator_set_voltage_time_sel,
139 static const struct regulator_ops bd718xx_dvs_buck_regulator_ops = {
140 .enable = regulator_enable_regmap,
141 .disable = regulator_disable_regmap,
142 .is_enabled = regulator_is_enabled_regmap,
143 .list_voltage = regulator_list_voltage_linear_range,
144 .set_voltage_sel = regulator_set_voltage_sel_regmap,
145 .get_voltage_sel = regulator_get_voltage_sel_regmap,
146 .set_voltage_time_sel = regulator_set_voltage_time_sel,
147 .set_ramp_delay = bd718xx_buck1234_set_ramp_delay,
151 * BD71837 BUCK1/2/3/4
153 * 0.70 to 1.30V (10mV step)
155 static const struct regulator_linear_range bd718xx_dvs_buck_volts[] = {
156 REGULATOR_LINEAR_RANGE(700000, 0x00, 0x3C, 10000),
157 REGULATOR_LINEAR_RANGE(1300000, 0x3D, 0x3F, 0),
162 * 0.7V to 1.35V (range 0)
164 * 0.675 to 1.325 (range 1)
166 static const struct regulator_linear_range bd71837_buck5_volts[] = {
167 /* Ranges when VOLT_SEL bit is 0 */
168 REGULATOR_LINEAR_RANGE(700000, 0x00, 0x03, 100000),
169 REGULATOR_LINEAR_RANGE(1050000, 0x04, 0x05, 50000),
170 REGULATOR_LINEAR_RANGE(1200000, 0x06, 0x07, 150000),
171 /* Ranges when VOLT_SEL bit is 1 */
172 REGULATOR_LINEAR_RANGE(675000, 0x0, 0x3, 100000),
173 REGULATOR_LINEAR_RANGE(1025000, 0x4, 0x5, 50000),
174 REGULATOR_LINEAR_RANGE(1175000, 0x6, 0x7, 150000),
178 * Range selector for first 3 linear ranges is 0x0
179 * and 0x1 for last 3 ranges.
181 static const unsigned int bd71837_buck5_volt_range_sel[] = {
182 0x0, 0x0, 0x0, 0x80, 0x80, 0x80
188 static const struct regulator_linear_range bd71847_buck3_volts[] = {
189 /* Ranges when VOLT_SEL bits are 00 */
190 REGULATOR_LINEAR_RANGE(700000, 0x00, 0x03, 100000),
191 REGULATOR_LINEAR_RANGE(1050000, 0x04, 0x05, 50000),
192 REGULATOR_LINEAR_RANGE(1200000, 0x06, 0x07, 150000),
193 /* Ranges when VOLT_SEL bits are 01 */
194 REGULATOR_LINEAR_RANGE(550000, 0x0, 0x7, 50000),
195 /* Ranges when VOLT_SEL bits are 11 */
196 REGULATOR_LINEAR_RANGE(675000, 0x0, 0x3, 100000),
197 REGULATOR_LINEAR_RANGE(1025000, 0x4, 0x5, 50000),
198 REGULATOR_LINEAR_RANGE(1175000, 0x6, 0x7, 150000),
201 static const unsigned int bd71847_buck3_volt_range_sel[] = {
202 0x0, 0x0, 0x0, 0x40, 0x80, 0x80, 0x80
205 static const struct regulator_linear_range bd71847_buck4_volts[] = {
206 REGULATOR_LINEAR_RANGE(3000000, 0x00, 0x03, 100000),
207 REGULATOR_LINEAR_RANGE(2600000, 0x00, 0x03, 100000),
210 static const unsigned int bd71847_buck4_volt_range_sel[] = { 0x0, 0x40 };
214 * 3.0V to 3.3V (step 100mV)
216 static const struct regulator_linear_range bd71837_buck6_volts[] = {
217 REGULATOR_LINEAR_RANGE(3000000, 0x00, 0x03, 100000),
226 * 011 = 1.8V (Initial)
232 static const unsigned int bd718xx_3rd_nodvs_buck_volts[] = {
233 1605000, 1695000, 1755000, 1800000, 1845000, 1905000, 1950000, 1995000
238 * 0.8V to 1.40V (step 10mV)
240 static const struct regulator_linear_range bd718xx_4th_nodvs_buck_volts[] = {
241 REGULATOR_LINEAR_RANGE(800000, 0x00, 0x3C, 10000),
246 * 3.0 to 3.3V (100mV step)
248 static const struct regulator_linear_range bd718xx_ldo1_volts[] = {
249 REGULATOR_LINEAR_RANGE(3000000, 0x00, 0x03, 100000),
250 REGULATOR_LINEAR_RANGE(1600000, 0x00, 0x03, 100000),
253 static const unsigned int bd718xx_ldo1_volt_range_sel[] = { 0x0, 0x20 };
259 static const unsigned int ldo_2_volts[] = {
265 * 1.8 to 3.3V (100mV step)
267 static const struct regulator_linear_range bd718xx_ldo3_volts[] = {
268 REGULATOR_LINEAR_RANGE(1800000, 0x00, 0x0F, 100000),
273 * 0.9 to 1.8V (100mV step)
275 static const struct regulator_linear_range bd718xx_ldo4_volts[] = {
276 REGULATOR_LINEAR_RANGE(900000, 0x00, 0x09, 100000),
281 * 1.8 to 3.3V (100mV step)
283 static const struct regulator_linear_range bd71837_ldo5_volts[] = {
284 REGULATOR_LINEAR_RANGE(1800000, 0x00, 0x0F, 100000),
289 * 1.8 to 3.3V (100mV step)
291 static const struct regulator_linear_range bd71847_ldo5_volts[] = {
292 REGULATOR_LINEAR_RANGE(1800000, 0x00, 0x0F, 100000),
293 REGULATOR_LINEAR_RANGE(800000, 0x00, 0x0F, 100000),
296 static const unsigned int bd71847_ldo5_volt_range_sel[] = { 0x0, 0x20 };
300 * 0.9 to 1.8V (100mV step)
302 static const struct regulator_linear_range bd718xx_ldo6_volts[] = {
303 REGULATOR_LINEAR_RANGE(900000, 0x00, 0x09, 100000),
308 * 1.8 to 3.3V (100mV step)
310 static const struct regulator_linear_range bd71837_ldo7_volts[] = {
311 REGULATOR_LINEAR_RANGE(1800000, 0x00, 0x0F, 100000),
319 struct bd718xx_regulator_data {
320 struct regulator_desc desc;
321 const struct reg_init init;
322 const struct reg_init *additional_inits;
323 int additional_init_amnt;
327 * There is a HW quirk in BD71837. The shutdown sequence timings for
328 * bucks/LDOs which are controlled via register interface are changed.
329 * At PMIC poweroff the voltage for BUCK6/7 is cut immediately at the
330 * beginning of shut-down sequence. As bucks 6 and 7 are parent
331 * supplies for LDO5 and LDO6 - this causes LDO5/6 voltage
332 * monitoring to errorneously detect under voltage and force PMIC to
333 * emergency state instead of poweroff. In order to avoid this we
334 * disable voltage monitoring for LDO5 and LDO6
336 static const struct reg_init bd71837_ldo5_inits[] = {
338 .reg = BD718XX_REG_MVRFLTMASK2,
339 .mask = BD718XX_LDO5_VRMON80,
340 .val = BD718XX_LDO5_VRMON80,
344 static const struct reg_init bd71837_ldo6_inits[] = {
346 .reg = BD718XX_REG_MVRFLTMASK2,
347 .mask = BD718XX_LDO6_VRMON80,
348 .val = BD718XX_LDO6_VRMON80,
352 #define NUM_DVS_BUCKS 4
354 struct of_dvs_setting {
359 static int set_dvs_levels(const struct of_dvs_setting *dvs,
360 struct device_node *np,
361 const struct regulator_desc *desc,
362 struct regmap *regmap)
367 ret = of_property_read_u32(np, dvs->prop, &uv);
374 for (i = 0; i < desc->n_voltages; i++) {
375 ret = regulator_desc_list_voltage_linear_range(desc, i);
379 i <<= ffs(desc->vsel_mask) - 1;
380 ret = regmap_update_bits(regmap, dvs->reg,
381 DVS_BUCK_RUN_MASK, i);
388 static int buck4_set_hw_dvs_levels(struct device_node *np,
389 const struct regulator_desc *desc,
390 struct regulator_config *cfg)
393 const struct of_dvs_setting dvs[] = {
395 .prop = "rohm,dvs-run-voltage",
396 .reg = BD71837_REG_BUCK4_VOLT_RUN,
400 for (i = 0; i < ARRAY_SIZE(dvs); i++) {
401 ret = set_dvs_levels(&dvs[i], np, desc, cfg->regmap);
407 static int buck3_set_hw_dvs_levels(struct device_node *np,
408 const struct regulator_desc *desc,
409 struct regulator_config *cfg)
412 const struct of_dvs_setting dvs[] = {
414 .prop = "rohm,dvs-run-voltage",
415 .reg = BD71837_REG_BUCK3_VOLT_RUN,
419 for (i = 0; i < ARRAY_SIZE(dvs); i++) {
420 ret = set_dvs_levels(&dvs[i], np, desc, cfg->regmap);
427 static int buck2_set_hw_dvs_levels(struct device_node *np,
428 const struct regulator_desc *desc,
429 struct regulator_config *cfg)
432 const struct of_dvs_setting dvs[] = {
434 .prop = "rohm,dvs-run-voltage",
435 .reg = BD718XX_REG_BUCK2_VOLT_RUN,
438 .prop = "rohm,dvs-idle-voltage",
439 .reg = BD718XX_REG_BUCK2_VOLT_IDLE,
445 for (i = 0; i < ARRAY_SIZE(dvs); i++) {
446 ret = set_dvs_levels(&dvs[i], np, desc, cfg->regmap);
453 static int buck1_set_hw_dvs_levels(struct device_node *np,
454 const struct regulator_desc *desc,
455 struct regulator_config *cfg)
458 const struct of_dvs_setting dvs[] = {
460 .prop = "rohm,dvs-run-voltage",
461 .reg = BD718XX_REG_BUCK1_VOLT_RUN,
464 .prop = "rohm,dvs-idle-voltage",
465 .reg = BD718XX_REG_BUCK1_VOLT_IDLE,
468 .prop = "rohm,dvs-suspend-voltage",
469 .reg = BD718XX_REG_BUCK1_VOLT_SUSP,
473 for (i = 0; i < ARRAY_SIZE(dvs); i++) {
474 ret = set_dvs_levels(&dvs[i], np, desc, cfg->regmap);
481 static const struct bd718xx_regulator_data bd71847_regulators[] = {
485 .of_match = of_match_ptr("BUCK1"),
486 .regulators_node = of_match_ptr("regulators"),
488 .ops = &bd718xx_dvs_buck_regulator_ops,
489 .type = REGULATOR_VOLTAGE,
490 .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
491 .linear_ranges = bd718xx_dvs_buck_volts,
493 ARRAY_SIZE(bd718xx_dvs_buck_volts),
494 .vsel_reg = BD718XX_REG_BUCK1_VOLT_RUN,
495 .vsel_mask = DVS_BUCK_RUN_MASK,
496 .enable_reg = BD718XX_REG_BUCK1_CTRL,
497 .enable_mask = BD718XX_BUCK_EN,
498 .owner = THIS_MODULE,
499 .of_parse_cb = buck1_set_hw_dvs_levels,
502 .reg = BD718XX_REG_BUCK1_CTRL,
503 .mask = BD718XX_BUCK_SEL,
504 .val = BD718XX_BUCK_SEL,
510 .of_match = of_match_ptr("BUCK2"),
511 .regulators_node = of_match_ptr("regulators"),
513 .ops = &bd718xx_dvs_buck_regulator_ops,
514 .type = REGULATOR_VOLTAGE,
515 .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
516 .linear_ranges = bd718xx_dvs_buck_volts,
517 .n_linear_ranges = ARRAY_SIZE(bd718xx_dvs_buck_volts),
518 .vsel_reg = BD718XX_REG_BUCK2_VOLT_RUN,
519 .vsel_mask = DVS_BUCK_RUN_MASK,
520 .enable_reg = BD718XX_REG_BUCK2_CTRL,
521 .enable_mask = BD718XX_BUCK_EN,
522 .owner = THIS_MODULE,
523 .of_parse_cb = buck2_set_hw_dvs_levels,
526 .reg = BD718XX_REG_BUCK2_CTRL,
527 .mask = BD718XX_BUCK_SEL,
528 .val = BD718XX_BUCK_SEL,
534 .of_match = of_match_ptr("BUCK3"),
535 .regulators_node = of_match_ptr("regulators"),
537 .ops = &bd718xx_pickable_range_buck_ops,
538 .type = REGULATOR_VOLTAGE,
539 .n_voltages = BD71847_BUCK3_VOLTAGE_NUM,
540 .linear_ranges = bd71847_buck3_volts,
542 ARRAY_SIZE(bd71847_buck3_volts),
543 .vsel_reg = BD718XX_REG_1ST_NODVS_BUCK_VOLT,
544 .vsel_mask = BD718XX_1ST_NODVS_BUCK_MASK,
545 .vsel_range_reg = BD718XX_REG_1ST_NODVS_BUCK_VOLT,
546 .vsel_range_mask = BD71847_BUCK3_RANGE_MASK,
547 .linear_range_selectors = bd71847_buck3_volt_range_sel,
548 .enable_reg = BD718XX_REG_1ST_NODVS_BUCK_CTRL,
549 .enable_mask = BD718XX_BUCK_EN,
550 .owner = THIS_MODULE,
553 .reg = BD718XX_REG_1ST_NODVS_BUCK_CTRL,
554 .mask = BD718XX_BUCK_SEL,
555 .val = BD718XX_BUCK_SEL,
561 .of_match = of_match_ptr("BUCK4"),
562 .regulators_node = of_match_ptr("regulators"),
564 .ops = &bd718xx_pickable_range_buck_ops,
565 .type = REGULATOR_VOLTAGE,
566 .n_voltages = BD71847_BUCK4_VOLTAGE_NUM,
567 .linear_ranges = bd71847_buck4_volts,
569 ARRAY_SIZE(bd71847_buck4_volts),
570 .enable_reg = BD718XX_REG_2ND_NODVS_BUCK_CTRL,
571 .vsel_reg = BD718XX_REG_2ND_NODVS_BUCK_VOLT,
572 .vsel_mask = BD71847_BUCK4_MASK,
573 .vsel_range_reg = BD718XX_REG_2ND_NODVS_BUCK_VOLT,
574 .vsel_range_mask = BD71847_BUCK4_RANGE_MASK,
575 .linear_range_selectors = bd71847_buck4_volt_range_sel,
576 .enable_mask = BD718XX_BUCK_EN,
577 .owner = THIS_MODULE,
580 .reg = BD718XX_REG_2ND_NODVS_BUCK_CTRL,
581 .mask = BD718XX_BUCK_SEL,
582 .val = BD718XX_BUCK_SEL,
588 .of_match = of_match_ptr("BUCK5"),
589 .regulators_node = of_match_ptr("regulators"),
591 .ops = &bd718xx_buck_regulator_nolinear_ops,
592 .type = REGULATOR_VOLTAGE,
593 .volt_table = &bd718xx_3rd_nodvs_buck_volts[0],
594 .n_voltages = ARRAY_SIZE(bd718xx_3rd_nodvs_buck_volts),
595 .vsel_reg = BD718XX_REG_3RD_NODVS_BUCK_VOLT,
596 .vsel_mask = BD718XX_3RD_NODVS_BUCK_MASK,
597 .enable_reg = BD718XX_REG_3RD_NODVS_BUCK_CTRL,
598 .enable_mask = BD718XX_BUCK_EN,
599 .owner = THIS_MODULE,
602 .reg = BD718XX_REG_3RD_NODVS_BUCK_CTRL,
603 .mask = BD718XX_BUCK_SEL,
604 .val = BD718XX_BUCK_SEL,
610 .of_match = of_match_ptr("BUCK6"),
611 .regulators_node = of_match_ptr("regulators"),
613 .ops = &bd718xx_buck_regulator_ops,
614 .type = REGULATOR_VOLTAGE,
615 .n_voltages = BD718XX_4TH_NODVS_BUCK_VOLTAGE_NUM,
616 .linear_ranges = bd718xx_4th_nodvs_buck_volts,
618 ARRAY_SIZE(bd718xx_4th_nodvs_buck_volts),
619 .vsel_reg = BD718XX_REG_4TH_NODVS_BUCK_VOLT,
620 .vsel_mask = BD718XX_4TH_NODVS_BUCK_MASK,
621 .enable_reg = BD718XX_REG_4TH_NODVS_BUCK_CTRL,
622 .enable_mask = BD718XX_BUCK_EN,
623 .owner = THIS_MODULE,
626 .reg = BD718XX_REG_4TH_NODVS_BUCK_CTRL,
627 .mask = BD718XX_BUCK_SEL,
628 .val = BD718XX_BUCK_SEL,
634 .of_match = of_match_ptr("LDO1"),
635 .regulators_node = of_match_ptr("regulators"),
637 .ops = &bd718xx_pickable_range_ldo_ops,
638 .type = REGULATOR_VOLTAGE,
639 .n_voltages = BD718XX_LDO1_VOLTAGE_NUM,
640 .linear_ranges = bd718xx_ldo1_volts,
641 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo1_volts),
642 .vsel_reg = BD718XX_REG_LDO1_VOLT,
643 .vsel_mask = BD718XX_LDO1_MASK,
644 .vsel_range_reg = BD718XX_REG_LDO1_VOLT,
645 .vsel_range_mask = BD718XX_LDO1_RANGE_MASK,
646 .linear_range_selectors = bd718xx_ldo1_volt_range_sel,
647 .enable_reg = BD718XX_REG_LDO1_VOLT,
648 .enable_mask = BD718XX_LDO_EN,
649 .owner = THIS_MODULE,
652 .reg = BD718XX_REG_LDO1_VOLT,
653 .mask = BD718XX_LDO_SEL,
654 .val = BD718XX_LDO_SEL,
660 .of_match = of_match_ptr("LDO2"),
661 .regulators_node = of_match_ptr("regulators"),
663 .ops = &bd718xx_ldo_regulator_nolinear_ops,
664 .type = REGULATOR_VOLTAGE,
665 .volt_table = &ldo_2_volts[0],
666 .vsel_reg = BD718XX_REG_LDO2_VOLT,
667 .vsel_mask = BD718XX_LDO2_MASK,
668 .n_voltages = ARRAY_SIZE(ldo_2_volts),
669 .enable_reg = BD718XX_REG_LDO2_VOLT,
670 .enable_mask = BD718XX_LDO_EN,
671 .owner = THIS_MODULE,
674 .reg = BD718XX_REG_LDO2_VOLT,
675 .mask = BD718XX_LDO_SEL,
676 .val = BD718XX_LDO_SEL,
682 .of_match = of_match_ptr("LDO3"),
683 .regulators_node = of_match_ptr("regulators"),
685 .ops = &bd718xx_ldo_regulator_ops,
686 .type = REGULATOR_VOLTAGE,
687 .n_voltages = BD718XX_LDO3_VOLTAGE_NUM,
688 .linear_ranges = bd718xx_ldo3_volts,
689 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo3_volts),
690 .vsel_reg = BD718XX_REG_LDO3_VOLT,
691 .vsel_mask = BD718XX_LDO3_MASK,
692 .enable_reg = BD718XX_REG_LDO3_VOLT,
693 .enable_mask = BD718XX_LDO_EN,
694 .owner = THIS_MODULE,
697 .reg = BD718XX_REG_LDO3_VOLT,
698 .mask = BD718XX_LDO_SEL,
699 .val = BD718XX_LDO_SEL,
705 .of_match = of_match_ptr("LDO4"),
706 .regulators_node = of_match_ptr("regulators"),
708 .ops = &bd718xx_ldo_regulator_ops,
709 .type = REGULATOR_VOLTAGE,
710 .n_voltages = BD718XX_LDO4_VOLTAGE_NUM,
711 .linear_ranges = bd718xx_ldo4_volts,
712 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo4_volts),
713 .vsel_reg = BD718XX_REG_LDO4_VOLT,
714 .vsel_mask = BD718XX_LDO4_MASK,
715 .enable_reg = BD718XX_REG_LDO4_VOLT,
716 .enable_mask = BD718XX_LDO_EN,
717 .owner = THIS_MODULE,
720 .reg = BD718XX_REG_LDO4_VOLT,
721 .mask = BD718XX_LDO_SEL,
722 .val = BD718XX_LDO_SEL,
728 .of_match = of_match_ptr("LDO5"),
729 .regulators_node = of_match_ptr("regulators"),
731 .ops = &bd718xx_pickable_range_ldo_ops,
732 .type = REGULATOR_VOLTAGE,
733 .n_voltages = BD71847_LDO5_VOLTAGE_NUM,
734 .linear_ranges = bd71847_ldo5_volts,
735 .n_linear_ranges = ARRAY_SIZE(bd71847_ldo5_volts),
736 .vsel_reg = BD718XX_REG_LDO5_VOLT,
737 .vsel_mask = BD71847_LDO5_MASK,
738 .vsel_range_reg = BD718XX_REG_LDO5_VOLT,
739 .vsel_range_mask = BD71847_LDO5_RANGE_MASK,
740 .linear_range_selectors = bd71847_ldo5_volt_range_sel,
741 .enable_reg = BD718XX_REG_LDO5_VOLT,
742 .enable_mask = BD718XX_LDO_EN,
743 .owner = THIS_MODULE,
746 .reg = BD718XX_REG_LDO5_VOLT,
747 .mask = BD718XX_LDO_SEL,
748 .val = BD718XX_LDO_SEL,
754 .of_match = of_match_ptr("LDO6"),
755 .regulators_node = of_match_ptr("regulators"),
757 .ops = &bd718xx_ldo_regulator_ops,
758 .type = REGULATOR_VOLTAGE,
759 .n_voltages = BD718XX_LDO6_VOLTAGE_NUM,
760 .linear_ranges = bd718xx_ldo6_volts,
761 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo6_volts),
762 /* LDO6 is supplied by buck5 */
763 .supply_name = "buck5",
764 .vsel_reg = BD718XX_REG_LDO6_VOLT,
765 .vsel_mask = BD718XX_LDO6_MASK,
766 .enable_reg = BD718XX_REG_LDO6_VOLT,
767 .enable_mask = BD718XX_LDO_EN,
768 .owner = THIS_MODULE,
771 .reg = BD718XX_REG_LDO6_VOLT,
772 .mask = BD718XX_LDO_SEL,
773 .val = BD718XX_LDO_SEL,
778 static const struct bd718xx_regulator_data bd71837_regulators[] = {
782 .of_match = of_match_ptr("BUCK1"),
783 .regulators_node = of_match_ptr("regulators"),
785 .ops = &bd718xx_dvs_buck_regulator_ops,
786 .type = REGULATOR_VOLTAGE,
787 .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
788 .linear_ranges = bd718xx_dvs_buck_volts,
789 .n_linear_ranges = ARRAY_SIZE(bd718xx_dvs_buck_volts),
790 .vsel_reg = BD718XX_REG_BUCK1_VOLT_RUN,
791 .vsel_mask = DVS_BUCK_RUN_MASK,
792 .enable_reg = BD718XX_REG_BUCK1_CTRL,
793 .enable_mask = BD718XX_BUCK_EN,
794 .owner = THIS_MODULE,
795 .of_parse_cb = buck1_set_hw_dvs_levels,
798 .reg = BD718XX_REG_BUCK1_CTRL,
799 .mask = BD718XX_BUCK_SEL,
800 .val = BD718XX_BUCK_SEL,
806 .of_match = of_match_ptr("BUCK2"),
807 .regulators_node = of_match_ptr("regulators"),
809 .ops = &bd718xx_dvs_buck_regulator_ops,
810 .type = REGULATOR_VOLTAGE,
811 .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
812 .linear_ranges = bd718xx_dvs_buck_volts,
813 .n_linear_ranges = ARRAY_SIZE(bd718xx_dvs_buck_volts),
814 .vsel_reg = BD718XX_REG_BUCK2_VOLT_RUN,
815 .vsel_mask = DVS_BUCK_RUN_MASK,
816 .enable_reg = BD718XX_REG_BUCK2_CTRL,
817 .enable_mask = BD718XX_BUCK_EN,
818 .owner = THIS_MODULE,
819 .of_parse_cb = buck2_set_hw_dvs_levels,
822 .reg = BD718XX_REG_BUCK2_CTRL,
823 .mask = BD718XX_BUCK_SEL,
824 .val = BD718XX_BUCK_SEL,
830 .of_match = of_match_ptr("BUCK3"),
831 .regulators_node = of_match_ptr("regulators"),
833 .ops = &bd718xx_dvs_buck_regulator_ops,
834 .type = REGULATOR_VOLTAGE,
835 .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
836 .linear_ranges = bd718xx_dvs_buck_volts,
837 .n_linear_ranges = ARRAY_SIZE(bd718xx_dvs_buck_volts),
838 .vsel_reg = BD71837_REG_BUCK3_VOLT_RUN,
839 .vsel_mask = DVS_BUCK_RUN_MASK,
840 .enable_reg = BD71837_REG_BUCK3_CTRL,
841 .enable_mask = BD718XX_BUCK_EN,
842 .owner = THIS_MODULE,
843 .of_parse_cb = buck3_set_hw_dvs_levels,
846 .reg = BD71837_REG_BUCK3_CTRL,
847 .mask = BD718XX_BUCK_SEL,
848 .val = BD718XX_BUCK_SEL,
854 .of_match = of_match_ptr("BUCK4"),
855 .regulators_node = of_match_ptr("regulators"),
857 .ops = &bd718xx_dvs_buck_regulator_ops,
858 .type = REGULATOR_VOLTAGE,
859 .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
860 .linear_ranges = bd718xx_dvs_buck_volts,
861 .n_linear_ranges = ARRAY_SIZE(bd718xx_dvs_buck_volts),
862 .vsel_reg = BD71837_REG_BUCK4_VOLT_RUN,
863 .vsel_mask = DVS_BUCK_RUN_MASK,
864 .enable_reg = BD71837_REG_BUCK4_CTRL,
865 .enable_mask = BD718XX_BUCK_EN,
866 .owner = THIS_MODULE,
867 .of_parse_cb = buck4_set_hw_dvs_levels,
870 .reg = BD71837_REG_BUCK4_CTRL,
871 .mask = BD718XX_BUCK_SEL,
872 .val = BD718XX_BUCK_SEL,
878 .of_match = of_match_ptr("BUCK5"),
879 .regulators_node = of_match_ptr("regulators"),
881 .ops = &bd718xx_pickable_range_buck_ops,
882 .type = REGULATOR_VOLTAGE,
883 .n_voltages = BD71837_BUCK5_VOLTAGE_NUM,
884 .linear_ranges = bd71837_buck5_volts,
886 ARRAY_SIZE(bd71837_buck5_volts),
887 .vsel_reg = BD718XX_REG_1ST_NODVS_BUCK_VOLT,
888 .vsel_mask = BD71837_BUCK5_MASK,
889 .vsel_range_reg = BD718XX_REG_1ST_NODVS_BUCK_VOLT,
890 .vsel_range_mask = BD71837_BUCK5_RANGE_MASK,
891 .linear_range_selectors = bd71837_buck5_volt_range_sel,
892 .enable_reg = BD718XX_REG_1ST_NODVS_BUCK_CTRL,
893 .enable_mask = BD718XX_BUCK_EN,
894 .owner = THIS_MODULE,
897 .reg = BD718XX_REG_1ST_NODVS_BUCK_CTRL,
898 .mask = BD718XX_BUCK_SEL,
899 .val = BD718XX_BUCK_SEL,
905 .of_match = of_match_ptr("BUCK6"),
906 .regulators_node = of_match_ptr("regulators"),
908 .ops = &bd718xx_buck_regulator_ops,
909 .type = REGULATOR_VOLTAGE,
910 .n_voltages = BD71837_BUCK6_VOLTAGE_NUM,
911 .linear_ranges = bd71837_buck6_volts,
913 ARRAY_SIZE(bd71837_buck6_volts),
914 .vsel_reg = BD718XX_REG_2ND_NODVS_BUCK_VOLT,
915 .vsel_mask = BD71837_BUCK6_MASK,
916 .enable_reg = BD718XX_REG_2ND_NODVS_BUCK_CTRL,
917 .enable_mask = BD718XX_BUCK_EN,
918 .owner = THIS_MODULE,
921 .reg = BD718XX_REG_2ND_NODVS_BUCK_CTRL,
922 .mask = BD718XX_BUCK_SEL,
923 .val = BD718XX_BUCK_SEL,
929 .of_match = of_match_ptr("BUCK7"),
930 .regulators_node = of_match_ptr("regulators"),
932 .ops = &bd718xx_buck_regulator_nolinear_ops,
933 .type = REGULATOR_VOLTAGE,
934 .volt_table = &bd718xx_3rd_nodvs_buck_volts[0],
935 .n_voltages = ARRAY_SIZE(bd718xx_3rd_nodvs_buck_volts),
936 .vsel_reg = BD718XX_REG_3RD_NODVS_BUCK_VOLT,
937 .vsel_mask = BD718XX_3RD_NODVS_BUCK_MASK,
938 .enable_reg = BD718XX_REG_3RD_NODVS_BUCK_CTRL,
939 .enable_mask = BD718XX_BUCK_EN,
940 .owner = THIS_MODULE,
943 .reg = BD718XX_REG_3RD_NODVS_BUCK_CTRL,
944 .mask = BD718XX_BUCK_SEL,
945 .val = BD718XX_BUCK_SEL,
951 .of_match = of_match_ptr("BUCK8"),
952 .regulators_node = of_match_ptr("regulators"),
954 .ops = &bd718xx_buck_regulator_ops,
955 .type = REGULATOR_VOLTAGE,
956 .n_voltages = BD718XX_4TH_NODVS_BUCK_VOLTAGE_NUM,
957 .linear_ranges = bd718xx_4th_nodvs_buck_volts,
959 ARRAY_SIZE(bd718xx_4th_nodvs_buck_volts),
960 .vsel_reg = BD718XX_REG_4TH_NODVS_BUCK_VOLT,
961 .vsel_mask = BD718XX_4TH_NODVS_BUCK_MASK,
962 .enable_reg = BD718XX_REG_4TH_NODVS_BUCK_CTRL,
963 .enable_mask = BD718XX_BUCK_EN,
964 .owner = THIS_MODULE,
967 .reg = BD718XX_REG_4TH_NODVS_BUCK_CTRL,
968 .mask = BD718XX_BUCK_SEL,
969 .val = BD718XX_BUCK_SEL,
975 .of_match = of_match_ptr("LDO1"),
976 .regulators_node = of_match_ptr("regulators"),
978 .ops = &bd718xx_pickable_range_ldo_ops,
979 .type = REGULATOR_VOLTAGE,
980 .n_voltages = BD718XX_LDO1_VOLTAGE_NUM,
981 .linear_ranges = bd718xx_ldo1_volts,
982 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo1_volts),
983 .vsel_reg = BD718XX_REG_LDO1_VOLT,
984 .vsel_mask = BD718XX_LDO1_MASK,
985 .vsel_range_reg = BD718XX_REG_LDO1_VOLT,
986 .vsel_range_mask = BD718XX_LDO1_RANGE_MASK,
987 .linear_range_selectors = bd718xx_ldo1_volt_range_sel,
988 .enable_reg = BD718XX_REG_LDO1_VOLT,
989 .enable_mask = BD718XX_LDO_EN,
990 .owner = THIS_MODULE,
993 .reg = BD718XX_REG_LDO1_VOLT,
994 .mask = BD718XX_LDO_SEL,
995 .val = BD718XX_LDO_SEL,
1001 .of_match = of_match_ptr("LDO2"),
1002 .regulators_node = of_match_ptr("regulators"),
1004 .ops = &bd718xx_ldo_regulator_nolinear_ops,
1005 .type = REGULATOR_VOLTAGE,
1006 .volt_table = &ldo_2_volts[0],
1007 .vsel_reg = BD718XX_REG_LDO2_VOLT,
1008 .vsel_mask = BD718XX_LDO2_MASK,
1009 .n_voltages = ARRAY_SIZE(ldo_2_volts),
1010 .enable_reg = BD718XX_REG_LDO2_VOLT,
1011 .enable_mask = BD718XX_LDO_EN,
1012 .owner = THIS_MODULE,
1015 .reg = BD718XX_REG_LDO2_VOLT,
1016 .mask = BD718XX_LDO_SEL,
1017 .val = BD718XX_LDO_SEL,
1023 .of_match = of_match_ptr("LDO3"),
1024 .regulators_node = of_match_ptr("regulators"),
1026 .ops = &bd718xx_ldo_regulator_ops,
1027 .type = REGULATOR_VOLTAGE,
1028 .n_voltages = BD718XX_LDO3_VOLTAGE_NUM,
1029 .linear_ranges = bd718xx_ldo3_volts,
1030 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo3_volts),
1031 .vsel_reg = BD718XX_REG_LDO3_VOLT,
1032 .vsel_mask = BD718XX_LDO3_MASK,
1033 .enable_reg = BD718XX_REG_LDO3_VOLT,
1034 .enable_mask = BD718XX_LDO_EN,
1035 .owner = THIS_MODULE,
1038 .reg = BD718XX_REG_LDO3_VOLT,
1039 .mask = BD718XX_LDO_SEL,
1040 .val = BD718XX_LDO_SEL,
1046 .of_match = of_match_ptr("LDO4"),
1047 .regulators_node = of_match_ptr("regulators"),
1049 .ops = &bd718xx_ldo_regulator_ops,
1050 .type = REGULATOR_VOLTAGE,
1051 .n_voltages = BD718XX_LDO4_VOLTAGE_NUM,
1052 .linear_ranges = bd718xx_ldo4_volts,
1053 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo4_volts),
1054 .vsel_reg = BD718XX_REG_LDO4_VOLT,
1055 .vsel_mask = BD718XX_LDO4_MASK,
1056 .enable_reg = BD718XX_REG_LDO4_VOLT,
1057 .enable_mask = BD718XX_LDO_EN,
1058 .owner = THIS_MODULE,
1061 .reg = BD718XX_REG_LDO4_VOLT,
1062 .mask = BD718XX_LDO_SEL,
1063 .val = BD718XX_LDO_SEL,
1069 .of_match = of_match_ptr("LDO5"),
1070 .regulators_node = of_match_ptr("regulators"),
1072 .ops = &bd718xx_ldo_regulator_ops,
1073 .type = REGULATOR_VOLTAGE,
1074 .n_voltages = BD71837_LDO5_VOLTAGE_NUM,
1075 .linear_ranges = bd71837_ldo5_volts,
1076 .n_linear_ranges = ARRAY_SIZE(bd71837_ldo5_volts),
1077 /* LDO5 is supplied by buck6 */
1078 .supply_name = "buck6",
1079 .vsel_reg = BD718XX_REG_LDO5_VOLT,
1080 .vsel_mask = BD71837_LDO5_MASK,
1081 .enable_reg = BD718XX_REG_LDO5_VOLT,
1082 .enable_mask = BD718XX_LDO_EN,
1083 .owner = THIS_MODULE,
1086 .reg = BD718XX_REG_LDO5_VOLT,
1087 .mask = BD718XX_LDO_SEL,
1088 .val = BD718XX_LDO_SEL,
1090 .additional_inits = bd71837_ldo5_inits,
1091 .additional_init_amnt = ARRAY_SIZE(bd71837_ldo5_inits),
1096 .of_match = of_match_ptr("LDO6"),
1097 .regulators_node = of_match_ptr("regulators"),
1099 .ops = &bd718xx_ldo_regulator_ops,
1100 .type = REGULATOR_VOLTAGE,
1101 .n_voltages = BD718XX_LDO6_VOLTAGE_NUM,
1102 .linear_ranges = bd718xx_ldo6_volts,
1103 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo6_volts),
1104 /* LDO6 is supplied by buck7 */
1105 .supply_name = "buck7",
1106 .vsel_reg = BD718XX_REG_LDO6_VOLT,
1107 .vsel_mask = BD718XX_LDO6_MASK,
1108 .enable_reg = BD718XX_REG_LDO6_VOLT,
1109 .enable_mask = BD718XX_LDO_EN,
1110 .owner = THIS_MODULE,
1113 .reg = BD718XX_REG_LDO6_VOLT,
1114 .mask = BD718XX_LDO_SEL,
1115 .val = BD718XX_LDO_SEL,
1117 .additional_inits = bd71837_ldo6_inits,
1118 .additional_init_amnt = ARRAY_SIZE(bd71837_ldo6_inits),
1123 .of_match = of_match_ptr("LDO7"),
1124 .regulators_node = of_match_ptr("regulators"),
1126 .ops = &bd718xx_ldo_regulator_ops,
1127 .type = REGULATOR_VOLTAGE,
1128 .n_voltages = BD71837_LDO7_VOLTAGE_NUM,
1129 .linear_ranges = bd71837_ldo7_volts,
1130 .n_linear_ranges = ARRAY_SIZE(bd71837_ldo7_volts),
1131 .vsel_reg = BD71837_REG_LDO7_VOLT,
1132 .vsel_mask = BD71837_LDO7_MASK,
1133 .enable_reg = BD71837_REG_LDO7_VOLT,
1134 .enable_mask = BD718XX_LDO_EN,
1135 .owner = THIS_MODULE,
1138 .reg = BD71837_REG_LDO7_VOLT,
1139 .mask = BD718XX_LDO_SEL,
1140 .val = BD718XX_LDO_SEL,
1145 struct bd718xx_pmic_inits {
1146 const struct bd718xx_regulator_data *r_datas;
1147 unsigned int r_amount;
1150 static int bd718xx_probe(struct platform_device *pdev)
1152 struct bd718xx *mfd;
1153 struct regulator_config config = { 0 };
1154 struct bd718xx_pmic_inits pmic_regulators[ROHM_CHIP_TYPE_AMOUNT] = {
1155 [ROHM_CHIP_TYPE_BD71837] = {
1156 .r_datas = bd71837_regulators,
1157 .r_amount = ARRAY_SIZE(bd71837_regulators),
1159 [ROHM_CHIP_TYPE_BD71847] = {
1160 .r_datas = bd71847_regulators,
1161 .r_amount = ARRAY_SIZE(bd71847_regulators),
1168 mfd = dev_get_drvdata(pdev->dev.parent);
1170 dev_err(&pdev->dev, "No MFD driver data\n");
1175 if (mfd->chip.chip_type >= ROHM_CHIP_TYPE_AMOUNT ||
1176 !pmic_regulators[mfd->chip.chip_type].r_datas) {
1177 dev_err(&pdev->dev, "Unsupported chip type\n");
1182 /* Register LOCK release */
1183 err = regmap_update_bits(mfd->chip.regmap, BD718XX_REG_REGLOCK,
1184 (REGLOCK_PWRSEQ | REGLOCK_VREG), 0);
1186 dev_err(&pdev->dev, "Failed to unlock PMIC (%d)\n", err);
1189 dev_dbg(&pdev->dev, "Unlocked lock register 0x%x\n",
1190 BD718XX_REG_REGLOCK);
1193 use_snvs = of_property_read_bool(pdev->dev.parent->of_node,
1194 "rohm,reset-snvs-powered");
1197 * Change the next stage from poweroff to be READY instead of SNVS
1198 * for all reset types because OTP loading at READY will clear SEL
1199 * bit allowing HW defaults for power rails to be used
1202 err = regmap_update_bits(mfd->chip.regmap,
1203 BD718XX_REG_TRANS_COND1,
1204 BD718XX_ON_REQ_POWEROFF_MASK |
1205 BD718XX_SWRESET_POWEROFF_MASK |
1206 BD718XX_WDOG_POWEROFF_MASK |
1207 BD718XX_KEY_L_POWEROFF_MASK,
1208 BD718XX_POWOFF_TO_RDY);
1210 dev_err(&pdev->dev, "Failed to change reset target\n");
1214 "Changed all resets from SVNS to READY\n");
1218 for (i = 0; i < pmic_regulators[mfd->chip.chip_type].r_amount; i++) {
1220 const struct regulator_desc *desc;
1221 struct regulator_dev *rdev;
1222 const struct bd718xx_regulator_data *r;
1224 r = &pmic_regulators[mfd->chip.chip_type].r_datas[i];
1227 config.dev = pdev->dev.parent;
1228 config.regmap = mfd->chip.regmap;
1230 rdev = devm_regulator_register(&pdev->dev, desc, &config);
1233 "failed to register %s regulator\n",
1235 err = PTR_ERR(rdev);
1240 * Regulator register gets the regulator constraints and
1241 * applies them (set_machine_constraints). This should have
1242 * turned the control register(s) to correct values and we
1243 * can now switch the control from PMIC state machine to the
1244 * register interface
1246 * At poweroff transition PMIC HW disables EN bit for
1247 * regulators but leaves SEL bit untouched. So if state
1248 * transition from POWEROFF is done to SNVS - then all power
1249 * rails controlled by SW (having SEL bit set) stay disabled
1250 * as EN is cleared. This will result boot failure if any
1251 * crucial systems are powered by these rails. We don't
1252 * enable SW control for crucial regulators if snvs state is
1255 if (!use_snvs || !rdev->constraints->always_on ||
1256 !rdev->constraints->boot_on) {
1257 err = regmap_update_bits(mfd->chip.regmap, r->init.reg,
1258 r->init.mask, r->init.val);
1261 "Failed to take control for (%s)\n",
1266 for (j = 0; j < r->additional_init_amnt; j++) {
1267 err = regmap_update_bits(mfd->chip.regmap,
1268 r->additional_inits[j].reg,
1269 r->additional_inits[j].mask,
1270 r->additional_inits[j].val);
1273 "Buck (%s) initialization failed\n",
1284 static struct platform_driver bd718xx_regulator = {
1286 .name = "bd718xx-pmic",
1288 .probe = bd718xx_probe,
1291 module_platform_driver(bd718xx_regulator);
1293 MODULE_AUTHOR("Matti Vaittinen <matti.vaittinen@fi.rohmeurope.com>");
1294 MODULE_DESCRIPTION("BD71837/BD71847 voltage regulator driver");
1295 MODULE_LICENSE("GPL");
1296 MODULE_ALIAS("platform:bd718xx-pmic");