Loading...
1// SPDX-License-Identifier: GPL-2.0
2// Copyright (C) 2018 ROHM Semiconductors
3// bd71837-regulator.c ROHM BD71837MWV/BD71847MWV regulator driver
4
5#include <linux/delay.h>
6#include <linux/err.h>
7#include <linux/interrupt.h>
8#include <linux/kernel.h>
9#include <linux/mfd/rohm-bd718x7.h>
10#include <linux/module.h>
11#include <linux/of.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>
17
18/*
19 * BUCK1/2/3/4
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
25 */
26static int bd718xx_buck1234_set_ramp_delay(struct regulator_dev *rdev,
27 int ramp_delay)
28{
29 int id = rdev_get_id(rdev);
30 unsigned int ramp_value;
31
32 dev_dbg(&rdev->dev, "Buck[%d] Set Ramp = %d\n", id + 1,
33 ramp_delay);
34 switch (ramp_delay) {
35 case 1 ... 1250:
36 ramp_value = BUCK_RAMPRATE_1P25MV;
37 break;
38 case 1251 ... 2500:
39 ramp_value = BUCK_RAMPRATE_2P50MV;
40 break;
41 case 2501 ... 5000:
42 ramp_value = BUCK_RAMPRATE_5P00MV;
43 break;
44 case 5001 ... 10000:
45 ramp_value = BUCK_RAMPRATE_10P00MV;
46 break;
47 default:
48 ramp_value = BUCK_RAMPRATE_10P00MV;
49 dev_err(&rdev->dev,
50 "%s: ramp_delay: %d not supported, setting 10000mV//us\n",
51 rdev->desc->name, ramp_delay);
52 }
53
54 return regmap_update_bits(rdev->regmap, BD718XX_REG_BUCK1_CTRL + id,
55 BUCK_RAMPRATE_MASK, ramp_value << 6);
56}
57
58/*
59 * On BD71837 (not on BD71847, BD71850, ...)
60 * Bucks 1 to 4 support DVS. PWM mode is used when voltage is changed.
61 * Bucks 5 to 8 and LDOs can use PFM and must be disabled when voltage
62 * is changed. Hence we return -EBUSY for these if voltage is changed
63 * when BUCK/LDO is enabled.
64 *
65 * On BD71847, BD71850, ... The LDO voltage can be changed when LDO is
66 * enabled. But if voltage is increased the LDO power-good monitoring
67 * must be disabled for the duration of changing + 1mS to ensure voltage
68 * has reached the higher level before HW does next under voltage detection
69 * cycle.
70 */
71static int bd71837_set_voltage_sel_restricted(struct regulator_dev *rdev,
72 unsigned int sel)
73{
74 if (regulator_is_enabled_regmap(rdev))
75 return -EBUSY;
76
77 return regulator_set_voltage_sel_regmap(rdev, sel);
78}
79
80static void voltage_change_done(struct regulator_dev *rdev, unsigned int sel,
81 unsigned int *mask)
82{
83 int ret;
84
85 if (*mask) {
86 /*
87 * Let's allow scheduling as we use I2C anyways. We just need to
88 * guarantee minimum of 1ms sleep - it shouldn't matter if we
89 * exceed it due to the scheduling.
90 */
91 msleep(1);
92 /*
93 * Note for next hacker. The PWRGOOD should not be masked on
94 * BD71847 so we will just unconditionally enable detection
95 * when voltage is set.
96 * If someone want's to disable PWRGOOD he must implement
97 * caching and restoring the old value here. I am not
98 * aware of such use-cases so for the sake of the simplicity
99 * we just always enable PWRGOOD here.
100 */
101 ret = regmap_update_bits(rdev->regmap, BD718XX_REG_MVRFLTMASK2,
102 *mask, 0);
103 if (ret)
104 dev_err(&rdev->dev,
105 "Failed to re-enable voltage monitoring (%d)\n",
106 ret);
107 }
108}
109
110static int voltage_change_prepare(struct regulator_dev *rdev, unsigned int sel,
111 unsigned int *mask)
112{
113 int ret;
114
115 *mask = 0;
116 if (regulator_is_enabled_regmap(rdev)) {
117 int now, new;
118
119 now = rdev->desc->ops->get_voltage_sel(rdev);
120 if (now < 0)
121 return now;
122
123 now = rdev->desc->ops->list_voltage(rdev, now);
124 if (now < 0)
125 return now;
126
127 new = rdev->desc->ops->list_voltage(rdev, sel);
128 if (new < 0)
129 return new;
130
131 /*
132 * If we increase LDO voltage when LDO is enabled we need to
133 * disable the power-good detection until voltage has reached
134 * the new level. According to HW colleagues the maximum time
135 * it takes is 1000us. I assume that on systems with light load
136 * this might be less - and we could probably use DT to give
137 * system specific delay value if performance matters.
138 *
139 * Well, knowing we use I2C here and can add scheduling delays
140 * I don't think it is worth the hassle and I just add fixed
141 * 1ms sleep here (and allow scheduling). If this turns out to
142 * be a problem we can change it to delay and make the delay
143 * time configurable.
144 */
145 if (new > now) {
146 int ldo_offset = rdev->desc->id - BD718XX_LDO1;
147
148 *mask = BD718XX_LDO1_VRMON80 << ldo_offset;
149 ret = regmap_update_bits(rdev->regmap,
150 BD718XX_REG_MVRFLTMASK2,
151 *mask, *mask);
152 if (ret) {
153 dev_err(&rdev->dev,
154 "Failed to stop voltage monitoring\n");
155 return ret;
156 }
157 }
158 }
159
160 return 0;
161}
162
163static int bd718xx_set_voltage_sel_restricted(struct regulator_dev *rdev,
164 unsigned int sel)
165{
166 int ret;
167 int mask;
168
169 ret = voltage_change_prepare(rdev, sel, &mask);
170 if (ret)
171 return ret;
172
173 ret = regulator_set_voltage_sel_regmap(rdev, sel);
174 voltage_change_done(rdev, sel, &mask);
175
176 return ret;
177}
178
179static int bd718xx_set_voltage_sel_pickable_restricted(
180 struct regulator_dev *rdev, unsigned int sel)
181{
182 int ret;
183 int mask;
184
185 ret = voltage_change_prepare(rdev, sel, &mask);
186 if (ret)
187 return ret;
188
189 ret = regulator_set_voltage_sel_pickable_regmap(rdev, sel);
190 voltage_change_done(rdev, sel, &mask);
191
192 return ret;
193}
194
195static int bd71837_set_voltage_sel_pickable_restricted(
196 struct regulator_dev *rdev, unsigned int sel)
197{
198 if (regulator_is_enabled_regmap(rdev))
199 return -EBUSY;
200
201 return regulator_set_voltage_sel_pickable_regmap(rdev, sel);
202}
203
204static const struct regulator_ops bd718xx_pickable_range_ldo_ops = {
205 .enable = regulator_enable_regmap,
206 .disable = regulator_disable_regmap,
207 .is_enabled = regulator_is_enabled_regmap,
208 .list_voltage = regulator_list_voltage_pickable_linear_range,
209 .set_voltage_sel = bd718xx_set_voltage_sel_pickable_restricted,
210 .get_voltage_sel = regulator_get_voltage_sel_pickable_regmap,
211
212};
213
214static const struct regulator_ops bd71837_pickable_range_ldo_ops = {
215 .enable = regulator_enable_regmap,
216 .disable = regulator_disable_regmap,
217 .is_enabled = regulator_is_enabled_regmap,
218 .list_voltage = regulator_list_voltage_pickable_linear_range,
219 .set_voltage_sel = bd71837_set_voltage_sel_pickable_restricted,
220 .get_voltage_sel = regulator_get_voltage_sel_pickable_regmap,
221};
222
223static const struct regulator_ops bd718xx_pickable_range_buck_ops = {
224 .enable = regulator_enable_regmap,
225 .disable = regulator_disable_regmap,
226 .is_enabled = regulator_is_enabled_regmap,
227 .list_voltage = regulator_list_voltage_pickable_linear_range,
228 .set_voltage_sel = regulator_set_voltage_sel_pickable_regmap,
229 .get_voltage_sel = regulator_get_voltage_sel_pickable_regmap,
230 .set_voltage_time_sel = regulator_set_voltage_time_sel,
231};
232
233static const struct regulator_ops bd71837_pickable_range_buck_ops = {
234 .enable = regulator_enable_regmap,
235 .disable = regulator_disable_regmap,
236 .is_enabled = regulator_is_enabled_regmap,
237 .list_voltage = regulator_list_voltage_pickable_linear_range,
238 .set_voltage_sel = bd71837_set_voltage_sel_pickable_restricted,
239 .get_voltage_sel = regulator_get_voltage_sel_pickable_regmap,
240 .set_voltage_time_sel = regulator_set_voltage_time_sel,
241};
242
243static const struct regulator_ops bd71837_ldo_regulator_ops = {
244 .enable = regulator_enable_regmap,
245 .disable = regulator_disable_regmap,
246 .is_enabled = regulator_is_enabled_regmap,
247 .list_voltage = regulator_list_voltage_linear_range,
248 .set_voltage_sel = bd71837_set_voltage_sel_restricted,
249 .get_voltage_sel = regulator_get_voltage_sel_regmap,
250};
251
252static const struct regulator_ops bd718xx_ldo_regulator_ops = {
253 .enable = regulator_enable_regmap,
254 .disable = regulator_disable_regmap,
255 .is_enabled = regulator_is_enabled_regmap,
256 .list_voltage = regulator_list_voltage_linear_range,
257 .set_voltage_sel = bd718xx_set_voltage_sel_restricted,
258 .get_voltage_sel = regulator_get_voltage_sel_regmap,
259};
260
261static const struct regulator_ops bd71837_ldo_regulator_nolinear_ops = {
262 .enable = regulator_enable_regmap,
263 .disable = regulator_disable_regmap,
264 .is_enabled = regulator_is_enabled_regmap,
265 .list_voltage = regulator_list_voltage_table,
266 .set_voltage_sel = bd71837_set_voltage_sel_restricted,
267 .get_voltage_sel = regulator_get_voltage_sel_regmap,
268};
269
270static const struct regulator_ops bd718xx_ldo_regulator_nolinear_ops = {
271 .enable = regulator_enable_regmap,
272 .disable = regulator_disable_regmap,
273 .is_enabled = regulator_is_enabled_regmap,
274 .list_voltage = regulator_list_voltage_table,
275 .set_voltage_sel = bd718xx_set_voltage_sel_restricted,
276 .get_voltage_sel = regulator_get_voltage_sel_regmap,
277};
278
279static const struct regulator_ops bd718xx_buck_regulator_ops = {
280 .enable = regulator_enable_regmap,
281 .disable = regulator_disable_regmap,
282 .is_enabled = regulator_is_enabled_regmap,
283 .list_voltage = regulator_list_voltage_linear_range,
284 .set_voltage_sel = regulator_set_voltage_sel_regmap,
285 .get_voltage_sel = regulator_get_voltage_sel_regmap,
286 .set_voltage_time_sel = regulator_set_voltage_time_sel,
287};
288
289static const struct regulator_ops bd71837_buck_regulator_ops = {
290 .enable = regulator_enable_regmap,
291 .disable = regulator_disable_regmap,
292 .is_enabled = regulator_is_enabled_regmap,
293 .list_voltage = regulator_list_voltage_linear_range,
294 .set_voltage_sel = bd71837_set_voltage_sel_restricted,
295 .get_voltage_sel = regulator_get_voltage_sel_regmap,
296 .set_voltage_time_sel = regulator_set_voltage_time_sel,
297};
298
299static const struct regulator_ops bd718xx_buck_regulator_nolinear_ops = {
300 .enable = regulator_enable_regmap,
301 .disable = regulator_disable_regmap,
302 .is_enabled = regulator_is_enabled_regmap,
303 .list_voltage = regulator_list_voltage_table,
304 .map_voltage = regulator_map_voltage_ascend,
305 .set_voltage_sel = regulator_set_voltage_sel_regmap,
306 .get_voltage_sel = regulator_get_voltage_sel_regmap,
307 .set_voltage_time_sel = regulator_set_voltage_time_sel,
308};
309
310static const struct regulator_ops bd71837_buck_regulator_nolinear_ops = {
311 .enable = regulator_enable_regmap,
312 .disable = regulator_disable_regmap,
313 .is_enabled = regulator_is_enabled_regmap,
314 .list_voltage = regulator_list_voltage_table,
315 .map_voltage = regulator_map_voltage_ascend,
316 .set_voltage_sel = bd718xx_set_voltage_sel_restricted,
317 .get_voltage_sel = regulator_get_voltage_sel_regmap,
318 .set_voltage_time_sel = regulator_set_voltage_time_sel,
319};
320
321static const struct regulator_ops bd718xx_dvs_buck_regulator_ops = {
322 .enable = regulator_enable_regmap,
323 .disable = regulator_disable_regmap,
324 .is_enabled = regulator_is_enabled_regmap,
325 .list_voltage = regulator_list_voltage_linear_range,
326 .set_voltage_sel = regulator_set_voltage_sel_regmap,
327 .get_voltage_sel = regulator_get_voltage_sel_regmap,
328 .set_voltage_time_sel = regulator_set_voltage_time_sel,
329 .set_ramp_delay = bd718xx_buck1234_set_ramp_delay,
330};
331
332/*
333 * BD71837 BUCK1/2/3/4
334 * BD71847 BUCK1/2
335 * 0.70 to 1.30V (10mV step)
336 */
337static const struct linear_range bd718xx_dvs_buck_volts[] = {
338 REGULATOR_LINEAR_RANGE(700000, 0x00, 0x3C, 10000),
339 REGULATOR_LINEAR_RANGE(1300000, 0x3D, 0x3F, 0),
340};
341
342/*
343 * BD71837 BUCK5
344 * 0.7V to 1.35V (range 0)
345 * and
346 * 0.675 to 1.325 (range 1)
347 */
348static const struct linear_range bd71837_buck5_volts[] = {
349 /* Ranges when VOLT_SEL bit is 0 */
350 REGULATOR_LINEAR_RANGE(700000, 0x00, 0x03, 100000),
351 REGULATOR_LINEAR_RANGE(1050000, 0x04, 0x05, 50000),
352 REGULATOR_LINEAR_RANGE(1200000, 0x06, 0x07, 150000),
353 /* Ranges when VOLT_SEL bit is 1 */
354 REGULATOR_LINEAR_RANGE(675000, 0x0, 0x3, 100000),
355 REGULATOR_LINEAR_RANGE(1025000, 0x4, 0x5, 50000),
356 REGULATOR_LINEAR_RANGE(1175000, 0x6, 0x7, 150000),
357};
358
359/*
360 * Range selector for first 3 linear ranges is 0x0
361 * and 0x1 for last 3 ranges.
362 */
363static const unsigned int bd71837_buck5_volt_range_sel[] = {
364 0x0, 0x0, 0x0, 0x80, 0x80, 0x80
365};
366
367/*
368 * BD71847 BUCK3
369 */
370static const struct linear_range bd71847_buck3_volts[] = {
371 /* Ranges when VOLT_SEL bits are 00 */
372 REGULATOR_LINEAR_RANGE(700000, 0x00, 0x03, 100000),
373 REGULATOR_LINEAR_RANGE(1050000, 0x04, 0x05, 50000),
374 REGULATOR_LINEAR_RANGE(1200000, 0x06, 0x07, 150000),
375 /* Ranges when VOLT_SEL bits are 01 */
376 REGULATOR_LINEAR_RANGE(550000, 0x0, 0x7, 50000),
377 /* Ranges when VOLT_SEL bits are 11 */
378 REGULATOR_LINEAR_RANGE(675000, 0x0, 0x3, 100000),
379 REGULATOR_LINEAR_RANGE(1025000, 0x4, 0x5, 50000),
380 REGULATOR_LINEAR_RANGE(1175000, 0x6, 0x7, 150000),
381};
382
383static const unsigned int bd71847_buck3_volt_range_sel[] = {
384 0x0, 0x0, 0x0, 0x40, 0x80, 0x80, 0x80
385};
386
387static const struct linear_range bd71847_buck4_volts[] = {
388 REGULATOR_LINEAR_RANGE(3000000, 0x00, 0x03, 100000),
389 REGULATOR_LINEAR_RANGE(2600000, 0x00, 0x03, 100000),
390};
391
392static const unsigned int bd71847_buck4_volt_range_sel[] = { 0x0, 0x40 };
393
394/*
395 * BUCK6
396 * 3.0V to 3.3V (step 100mV)
397 */
398static const struct linear_range bd71837_buck6_volts[] = {
399 REGULATOR_LINEAR_RANGE(3000000, 0x00, 0x03, 100000),
400};
401
402/*
403 * BD71837 BUCK7
404 * BD71847 BUCK5
405 * 000 = 1.605V
406 * 001 = 1.695V
407 * 010 = 1.755V
408 * 011 = 1.8V (Initial)
409 * 100 = 1.845V
410 * 101 = 1.905V
411 * 110 = 1.95V
412 * 111 = 1.995V
413 */
414static const unsigned int bd718xx_3rd_nodvs_buck_volts[] = {
415 1605000, 1695000, 1755000, 1800000, 1845000, 1905000, 1950000, 1995000
416};
417
418/*
419 * BUCK8
420 * 0.8V to 1.40V (step 10mV)
421 */
422static const struct linear_range bd718xx_4th_nodvs_buck_volts[] = {
423 REGULATOR_LINEAR_RANGE(800000, 0x00, 0x3C, 10000),
424};
425
426/*
427 * LDO1
428 * 3.0 to 3.3V (100mV step)
429 */
430static const struct linear_range bd718xx_ldo1_volts[] = {
431 REGULATOR_LINEAR_RANGE(3000000, 0x00, 0x03, 100000),
432 REGULATOR_LINEAR_RANGE(1600000, 0x00, 0x03, 100000),
433};
434
435static const unsigned int bd718xx_ldo1_volt_range_sel[] = { 0x0, 0x20 };
436
437/*
438 * LDO2
439 * 0.8 or 0.9V
440 */
441static const unsigned int ldo_2_volts[] = {
442 900000, 800000
443};
444
445/*
446 * LDO3
447 * 1.8 to 3.3V (100mV step)
448 */
449static const struct linear_range bd718xx_ldo3_volts[] = {
450 REGULATOR_LINEAR_RANGE(1800000, 0x00, 0x0F, 100000),
451};
452
453/*
454 * LDO4
455 * 0.9 to 1.8V (100mV step)
456 */
457static const struct linear_range bd718xx_ldo4_volts[] = {
458 REGULATOR_LINEAR_RANGE(900000, 0x00, 0x09, 100000),
459};
460
461/*
462 * LDO5 for BD71837
463 * 1.8 to 3.3V (100mV step)
464 */
465static const struct linear_range bd71837_ldo5_volts[] = {
466 REGULATOR_LINEAR_RANGE(1800000, 0x00, 0x0F, 100000),
467};
468
469/*
470 * LDO5 for BD71837
471 * 1.8 to 3.3V (100mV step)
472 */
473static const struct linear_range bd71847_ldo5_volts[] = {
474 REGULATOR_LINEAR_RANGE(1800000, 0x00, 0x0F, 100000),
475 REGULATOR_LINEAR_RANGE(800000, 0x00, 0x0F, 100000),
476};
477
478static const unsigned int bd71847_ldo5_volt_range_sel[] = { 0x0, 0x20 };
479
480/*
481 * LDO6
482 * 0.9 to 1.8V (100mV step)
483 */
484static const struct linear_range bd718xx_ldo6_volts[] = {
485 REGULATOR_LINEAR_RANGE(900000, 0x00, 0x09, 100000),
486};
487
488/*
489 * LDO7
490 * 1.8 to 3.3V (100mV step)
491 */
492static const struct linear_range bd71837_ldo7_volts[] = {
493 REGULATOR_LINEAR_RANGE(1800000, 0x00, 0x0F, 100000),
494};
495
496struct reg_init {
497 unsigned int reg;
498 unsigned int mask;
499 unsigned int val;
500};
501struct bd718xx_regulator_data {
502 struct regulator_desc desc;
503 const struct rohm_dvs_config dvs;
504 const struct reg_init init;
505 const struct reg_init *additional_inits;
506 int additional_init_amnt;
507};
508
509/*
510 * There is a HW quirk in BD71837. The shutdown sequence timings for
511 * bucks/LDOs which are controlled via register interface are changed.
512 * At PMIC poweroff the voltage for BUCK6/7 is cut immediately at the
513 * beginning of shut-down sequence. As bucks 6 and 7 are parent
514 * supplies for LDO5 and LDO6 - this causes LDO5/6 voltage
515 * monitoring to errorneously detect under voltage and force PMIC to
516 * emergency state instead of poweroff. In order to avoid this we
517 * disable voltage monitoring for LDO5 and LDO6
518 */
519static const struct reg_init bd71837_ldo5_inits[] = {
520 {
521 .reg = BD718XX_REG_MVRFLTMASK2,
522 .mask = BD718XX_LDO5_VRMON80,
523 .val = BD718XX_LDO5_VRMON80,
524 },
525};
526
527static const struct reg_init bd71837_ldo6_inits[] = {
528 {
529 .reg = BD718XX_REG_MVRFLTMASK2,
530 .mask = BD718XX_LDO6_VRMON80,
531 .val = BD718XX_LDO6_VRMON80,
532 },
533};
534
535static int buck_set_hw_dvs_levels(struct device_node *np,
536 const struct regulator_desc *desc,
537 struct regulator_config *cfg)
538{
539 struct bd718xx_regulator_data *data;
540
541 data = container_of(desc, struct bd718xx_regulator_data, desc);
542
543 return rohm_regulator_set_dvs_levels(&data->dvs, np, desc, cfg->regmap);
544}
545
546static const struct bd718xx_regulator_data bd71847_regulators[] = {
547 {
548 .desc = {
549 .name = "buck1",
550 .of_match = of_match_ptr("BUCK1"),
551 .regulators_node = of_match_ptr("regulators"),
552 .id = BD718XX_BUCK1,
553 .ops = &bd718xx_dvs_buck_regulator_ops,
554 .type = REGULATOR_VOLTAGE,
555 .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
556 .linear_ranges = bd718xx_dvs_buck_volts,
557 .n_linear_ranges =
558 ARRAY_SIZE(bd718xx_dvs_buck_volts),
559 .vsel_reg = BD718XX_REG_BUCK1_VOLT_RUN,
560 .vsel_mask = DVS_BUCK_RUN_MASK,
561 .enable_reg = BD718XX_REG_BUCK1_CTRL,
562 .enable_mask = BD718XX_BUCK_EN,
563 .owner = THIS_MODULE,
564 .of_parse_cb = buck_set_hw_dvs_levels,
565 },
566 .dvs = {
567 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
568 ROHM_DVS_LEVEL_SUSPEND,
569 .run_reg = BD718XX_REG_BUCK1_VOLT_RUN,
570 .run_mask = DVS_BUCK_RUN_MASK,
571 .idle_reg = BD718XX_REG_BUCK1_VOLT_IDLE,
572 .idle_mask = DVS_BUCK_RUN_MASK,
573 .suspend_reg = BD718XX_REG_BUCK1_VOLT_SUSP,
574 .suspend_mask = DVS_BUCK_RUN_MASK,
575 },
576 .init = {
577 .reg = BD718XX_REG_BUCK1_CTRL,
578 .mask = BD718XX_BUCK_SEL,
579 .val = BD718XX_BUCK_SEL,
580 },
581 },
582 {
583 .desc = {
584 .name = "buck2",
585 .of_match = of_match_ptr("BUCK2"),
586 .regulators_node = of_match_ptr("regulators"),
587 .id = BD718XX_BUCK2,
588 .ops = &bd718xx_dvs_buck_regulator_ops,
589 .type = REGULATOR_VOLTAGE,
590 .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
591 .linear_ranges = bd718xx_dvs_buck_volts,
592 .n_linear_ranges = ARRAY_SIZE(bd718xx_dvs_buck_volts),
593 .vsel_reg = BD718XX_REG_BUCK2_VOLT_RUN,
594 .vsel_mask = DVS_BUCK_RUN_MASK,
595 .enable_reg = BD718XX_REG_BUCK2_CTRL,
596 .enable_mask = BD718XX_BUCK_EN,
597 .owner = THIS_MODULE,
598 .of_parse_cb = buck_set_hw_dvs_levels,
599 },
600 .dvs = {
601 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE,
602 .run_reg = BD718XX_REG_BUCK2_VOLT_RUN,
603 .run_mask = DVS_BUCK_RUN_MASK,
604 .idle_reg = BD718XX_REG_BUCK2_VOLT_IDLE,
605 .idle_mask = DVS_BUCK_RUN_MASK,
606 },
607 .init = {
608 .reg = BD718XX_REG_BUCK2_CTRL,
609 .mask = BD718XX_BUCK_SEL,
610 .val = BD718XX_BUCK_SEL,
611 },
612 },
613 {
614 .desc = {
615 .name = "buck3",
616 .of_match = of_match_ptr("BUCK3"),
617 .regulators_node = of_match_ptr("regulators"),
618 .id = BD718XX_BUCK3,
619 .ops = &bd718xx_pickable_range_buck_ops,
620 .type = REGULATOR_VOLTAGE,
621 .n_voltages = BD71847_BUCK3_VOLTAGE_NUM,
622 .linear_ranges = bd71847_buck3_volts,
623 .n_linear_ranges =
624 ARRAY_SIZE(bd71847_buck3_volts),
625 .vsel_reg = BD718XX_REG_1ST_NODVS_BUCK_VOLT,
626 .vsel_mask = BD718XX_1ST_NODVS_BUCK_MASK,
627 .vsel_range_reg = BD718XX_REG_1ST_NODVS_BUCK_VOLT,
628 .vsel_range_mask = BD71847_BUCK3_RANGE_MASK,
629 .linear_range_selectors = bd71847_buck3_volt_range_sel,
630 .enable_reg = BD718XX_REG_1ST_NODVS_BUCK_CTRL,
631 .enable_mask = BD718XX_BUCK_EN,
632 .owner = THIS_MODULE,
633 },
634 .init = {
635 .reg = BD718XX_REG_1ST_NODVS_BUCK_CTRL,
636 .mask = BD718XX_BUCK_SEL,
637 .val = BD718XX_BUCK_SEL,
638 },
639 },
640 {
641 .desc = {
642 .name = "buck4",
643 .of_match = of_match_ptr("BUCK4"),
644 .regulators_node = of_match_ptr("regulators"),
645 .id = BD718XX_BUCK4,
646 .ops = &bd718xx_pickable_range_buck_ops,
647 .type = REGULATOR_VOLTAGE,
648 .n_voltages = BD71847_BUCK4_VOLTAGE_NUM,
649 .linear_ranges = bd71847_buck4_volts,
650 .n_linear_ranges =
651 ARRAY_SIZE(bd71847_buck4_volts),
652 .enable_reg = BD718XX_REG_2ND_NODVS_BUCK_CTRL,
653 .vsel_reg = BD718XX_REG_2ND_NODVS_BUCK_VOLT,
654 .vsel_mask = BD71847_BUCK4_MASK,
655 .vsel_range_reg = BD718XX_REG_2ND_NODVS_BUCK_VOLT,
656 .vsel_range_mask = BD71847_BUCK4_RANGE_MASK,
657 .linear_range_selectors = bd71847_buck4_volt_range_sel,
658 .enable_mask = BD718XX_BUCK_EN,
659 .owner = THIS_MODULE,
660 },
661 .init = {
662 .reg = BD718XX_REG_2ND_NODVS_BUCK_CTRL,
663 .mask = BD718XX_BUCK_SEL,
664 .val = BD718XX_BUCK_SEL,
665 },
666 },
667 {
668 .desc = {
669 .name = "buck5",
670 .of_match = of_match_ptr("BUCK5"),
671 .regulators_node = of_match_ptr("regulators"),
672 .id = BD718XX_BUCK5,
673 .ops = &bd718xx_buck_regulator_nolinear_ops,
674 .type = REGULATOR_VOLTAGE,
675 .volt_table = &bd718xx_3rd_nodvs_buck_volts[0],
676 .n_voltages = ARRAY_SIZE(bd718xx_3rd_nodvs_buck_volts),
677 .vsel_reg = BD718XX_REG_3RD_NODVS_BUCK_VOLT,
678 .vsel_mask = BD718XX_3RD_NODVS_BUCK_MASK,
679 .enable_reg = BD718XX_REG_3RD_NODVS_BUCK_CTRL,
680 .enable_mask = BD718XX_BUCK_EN,
681 .owner = THIS_MODULE,
682 },
683 .init = {
684 .reg = BD718XX_REG_3RD_NODVS_BUCK_CTRL,
685 .mask = BD718XX_BUCK_SEL,
686 .val = BD718XX_BUCK_SEL,
687 },
688 },
689 {
690 .desc = {
691 .name = "buck6",
692 .of_match = of_match_ptr("BUCK6"),
693 .regulators_node = of_match_ptr("regulators"),
694 .id = BD718XX_BUCK6,
695 .ops = &bd718xx_buck_regulator_ops,
696 .type = REGULATOR_VOLTAGE,
697 .n_voltages = BD718XX_4TH_NODVS_BUCK_VOLTAGE_NUM,
698 .linear_ranges = bd718xx_4th_nodvs_buck_volts,
699 .n_linear_ranges =
700 ARRAY_SIZE(bd718xx_4th_nodvs_buck_volts),
701 .vsel_reg = BD718XX_REG_4TH_NODVS_BUCK_VOLT,
702 .vsel_mask = BD718XX_4TH_NODVS_BUCK_MASK,
703 .enable_reg = BD718XX_REG_4TH_NODVS_BUCK_CTRL,
704 .enable_mask = BD718XX_BUCK_EN,
705 .owner = THIS_MODULE,
706 },
707 .init = {
708 .reg = BD718XX_REG_4TH_NODVS_BUCK_CTRL,
709 .mask = BD718XX_BUCK_SEL,
710 .val = BD718XX_BUCK_SEL,
711 },
712 },
713 {
714 .desc = {
715 .name = "ldo1",
716 .of_match = of_match_ptr("LDO1"),
717 .regulators_node = of_match_ptr("regulators"),
718 .id = BD718XX_LDO1,
719 .ops = &bd718xx_pickable_range_ldo_ops,
720 .type = REGULATOR_VOLTAGE,
721 .n_voltages = BD718XX_LDO1_VOLTAGE_NUM,
722 .linear_ranges = bd718xx_ldo1_volts,
723 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo1_volts),
724 .vsel_reg = BD718XX_REG_LDO1_VOLT,
725 .vsel_mask = BD718XX_LDO1_MASK,
726 .vsel_range_reg = BD718XX_REG_LDO1_VOLT,
727 .vsel_range_mask = BD718XX_LDO1_RANGE_MASK,
728 .linear_range_selectors = bd718xx_ldo1_volt_range_sel,
729 .enable_reg = BD718XX_REG_LDO1_VOLT,
730 .enable_mask = BD718XX_LDO_EN,
731 .owner = THIS_MODULE,
732 },
733 .init = {
734 .reg = BD718XX_REG_LDO1_VOLT,
735 .mask = BD718XX_LDO_SEL,
736 .val = BD718XX_LDO_SEL,
737 },
738 },
739 {
740 .desc = {
741 .name = "ldo2",
742 .of_match = of_match_ptr("LDO2"),
743 .regulators_node = of_match_ptr("regulators"),
744 .id = BD718XX_LDO2,
745 .ops = &bd718xx_ldo_regulator_nolinear_ops,
746 .type = REGULATOR_VOLTAGE,
747 .volt_table = &ldo_2_volts[0],
748 .vsel_reg = BD718XX_REG_LDO2_VOLT,
749 .vsel_mask = BD718XX_LDO2_MASK,
750 .n_voltages = ARRAY_SIZE(ldo_2_volts),
751 .enable_reg = BD718XX_REG_LDO2_VOLT,
752 .enable_mask = BD718XX_LDO_EN,
753 .owner = THIS_MODULE,
754 },
755 .init = {
756 .reg = BD718XX_REG_LDO2_VOLT,
757 .mask = BD718XX_LDO_SEL,
758 .val = BD718XX_LDO_SEL,
759 },
760 },
761 {
762 .desc = {
763 .name = "ldo3",
764 .of_match = of_match_ptr("LDO3"),
765 .regulators_node = of_match_ptr("regulators"),
766 .id = BD718XX_LDO3,
767 .ops = &bd718xx_ldo_regulator_ops,
768 .type = REGULATOR_VOLTAGE,
769 .n_voltages = BD718XX_LDO3_VOLTAGE_NUM,
770 .linear_ranges = bd718xx_ldo3_volts,
771 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo3_volts),
772 .vsel_reg = BD718XX_REG_LDO3_VOLT,
773 .vsel_mask = BD718XX_LDO3_MASK,
774 .enable_reg = BD718XX_REG_LDO3_VOLT,
775 .enable_mask = BD718XX_LDO_EN,
776 .owner = THIS_MODULE,
777 },
778 .init = {
779 .reg = BD718XX_REG_LDO3_VOLT,
780 .mask = BD718XX_LDO_SEL,
781 .val = BD718XX_LDO_SEL,
782 },
783 },
784 {
785 .desc = {
786 .name = "ldo4",
787 .of_match = of_match_ptr("LDO4"),
788 .regulators_node = of_match_ptr("regulators"),
789 .id = BD718XX_LDO4,
790 .ops = &bd718xx_ldo_regulator_ops,
791 .type = REGULATOR_VOLTAGE,
792 .n_voltages = BD718XX_LDO4_VOLTAGE_NUM,
793 .linear_ranges = bd718xx_ldo4_volts,
794 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo4_volts),
795 .vsel_reg = BD718XX_REG_LDO4_VOLT,
796 .vsel_mask = BD718XX_LDO4_MASK,
797 .enable_reg = BD718XX_REG_LDO4_VOLT,
798 .enable_mask = BD718XX_LDO_EN,
799 .owner = THIS_MODULE,
800 },
801 .init = {
802 .reg = BD718XX_REG_LDO4_VOLT,
803 .mask = BD718XX_LDO_SEL,
804 .val = BD718XX_LDO_SEL,
805 },
806 },
807 {
808 .desc = {
809 .name = "ldo5",
810 .of_match = of_match_ptr("LDO5"),
811 .regulators_node = of_match_ptr("regulators"),
812 .id = BD718XX_LDO5,
813 .ops = &bd718xx_pickable_range_ldo_ops,
814 .type = REGULATOR_VOLTAGE,
815 .n_voltages = BD71847_LDO5_VOLTAGE_NUM,
816 .linear_ranges = bd71847_ldo5_volts,
817 .n_linear_ranges = ARRAY_SIZE(bd71847_ldo5_volts),
818 .vsel_reg = BD718XX_REG_LDO5_VOLT,
819 .vsel_mask = BD71847_LDO5_MASK,
820 .vsel_range_reg = BD718XX_REG_LDO5_VOLT,
821 .vsel_range_mask = BD71847_LDO5_RANGE_MASK,
822 .linear_range_selectors = bd71847_ldo5_volt_range_sel,
823 .enable_reg = BD718XX_REG_LDO5_VOLT,
824 .enable_mask = BD718XX_LDO_EN,
825 .owner = THIS_MODULE,
826 },
827 .init = {
828 .reg = BD718XX_REG_LDO5_VOLT,
829 .mask = BD718XX_LDO_SEL,
830 .val = BD718XX_LDO_SEL,
831 },
832 },
833 {
834 .desc = {
835 .name = "ldo6",
836 .of_match = of_match_ptr("LDO6"),
837 .regulators_node = of_match_ptr("regulators"),
838 .id = BD718XX_LDO6,
839 .ops = &bd718xx_ldo_regulator_ops,
840 .type = REGULATOR_VOLTAGE,
841 .n_voltages = BD718XX_LDO6_VOLTAGE_NUM,
842 .linear_ranges = bd718xx_ldo6_volts,
843 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo6_volts),
844 /* LDO6 is supplied by buck5 */
845 .supply_name = "buck5",
846 .vsel_reg = BD718XX_REG_LDO6_VOLT,
847 .vsel_mask = BD718XX_LDO6_MASK,
848 .enable_reg = BD718XX_REG_LDO6_VOLT,
849 .enable_mask = BD718XX_LDO_EN,
850 .owner = THIS_MODULE,
851 },
852 .init = {
853 .reg = BD718XX_REG_LDO6_VOLT,
854 .mask = BD718XX_LDO_SEL,
855 .val = BD718XX_LDO_SEL,
856 },
857 },
858};
859
860static const struct bd718xx_regulator_data bd71837_regulators[] = {
861 {
862 .desc = {
863 .name = "buck1",
864 .of_match = of_match_ptr("BUCK1"),
865 .regulators_node = of_match_ptr("regulators"),
866 .id = BD718XX_BUCK1,
867 .ops = &bd718xx_dvs_buck_regulator_ops,
868 .type = REGULATOR_VOLTAGE,
869 .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
870 .linear_ranges = bd718xx_dvs_buck_volts,
871 .n_linear_ranges = ARRAY_SIZE(bd718xx_dvs_buck_volts),
872 .vsel_reg = BD718XX_REG_BUCK1_VOLT_RUN,
873 .vsel_mask = DVS_BUCK_RUN_MASK,
874 .enable_reg = BD718XX_REG_BUCK1_CTRL,
875 .enable_mask = BD718XX_BUCK_EN,
876 .owner = THIS_MODULE,
877 .of_parse_cb = buck_set_hw_dvs_levels,
878 },
879 .dvs = {
880 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
881 ROHM_DVS_LEVEL_SUSPEND,
882 .run_reg = BD718XX_REG_BUCK1_VOLT_RUN,
883 .run_mask = DVS_BUCK_RUN_MASK,
884 .idle_reg = BD718XX_REG_BUCK1_VOLT_IDLE,
885 .idle_mask = DVS_BUCK_RUN_MASK,
886 .suspend_reg = BD718XX_REG_BUCK1_VOLT_SUSP,
887 .suspend_mask = DVS_BUCK_RUN_MASK,
888 },
889 .init = {
890 .reg = BD718XX_REG_BUCK1_CTRL,
891 .mask = BD718XX_BUCK_SEL,
892 .val = BD718XX_BUCK_SEL,
893 },
894 },
895 {
896 .desc = {
897 .name = "buck2",
898 .of_match = of_match_ptr("BUCK2"),
899 .regulators_node = of_match_ptr("regulators"),
900 .id = BD718XX_BUCK2,
901 .ops = &bd718xx_dvs_buck_regulator_ops,
902 .type = REGULATOR_VOLTAGE,
903 .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
904 .linear_ranges = bd718xx_dvs_buck_volts,
905 .n_linear_ranges = ARRAY_SIZE(bd718xx_dvs_buck_volts),
906 .vsel_reg = BD718XX_REG_BUCK2_VOLT_RUN,
907 .vsel_mask = DVS_BUCK_RUN_MASK,
908 .enable_reg = BD718XX_REG_BUCK2_CTRL,
909 .enable_mask = BD718XX_BUCK_EN,
910 .owner = THIS_MODULE,
911 .of_parse_cb = buck_set_hw_dvs_levels,
912 },
913 .dvs = {
914 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE,
915 .run_reg = BD718XX_REG_BUCK2_VOLT_RUN,
916 .run_mask = DVS_BUCK_RUN_MASK,
917 .idle_reg = BD718XX_REG_BUCK2_VOLT_IDLE,
918 .idle_mask = DVS_BUCK_RUN_MASK,
919 },
920 .init = {
921 .reg = BD718XX_REG_BUCK2_CTRL,
922 .mask = BD718XX_BUCK_SEL,
923 .val = BD718XX_BUCK_SEL,
924 },
925 },
926 {
927 .desc = {
928 .name = "buck3",
929 .of_match = of_match_ptr("BUCK3"),
930 .regulators_node = of_match_ptr("regulators"),
931 .id = BD718XX_BUCK3,
932 .ops = &bd718xx_dvs_buck_regulator_ops,
933 .type = REGULATOR_VOLTAGE,
934 .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
935 .linear_ranges = bd718xx_dvs_buck_volts,
936 .n_linear_ranges = ARRAY_SIZE(bd718xx_dvs_buck_volts),
937 .vsel_reg = BD71837_REG_BUCK3_VOLT_RUN,
938 .vsel_mask = DVS_BUCK_RUN_MASK,
939 .enable_reg = BD71837_REG_BUCK3_CTRL,
940 .enable_mask = BD718XX_BUCK_EN,
941 .owner = THIS_MODULE,
942 .of_parse_cb = buck_set_hw_dvs_levels,
943 },
944 .dvs = {
945 .level_map = ROHM_DVS_LEVEL_RUN,
946 .run_reg = BD71837_REG_BUCK3_VOLT_RUN,
947 .run_mask = DVS_BUCK_RUN_MASK,
948 },
949 .init = {
950 .reg = BD71837_REG_BUCK3_CTRL,
951 .mask = BD718XX_BUCK_SEL,
952 .val = BD718XX_BUCK_SEL,
953 },
954 },
955 {
956 .desc = {
957 .name = "buck4",
958 .of_match = of_match_ptr("BUCK4"),
959 .regulators_node = of_match_ptr("regulators"),
960 .id = BD718XX_BUCK4,
961 .ops = &bd718xx_dvs_buck_regulator_ops,
962 .type = REGULATOR_VOLTAGE,
963 .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
964 .linear_ranges = bd718xx_dvs_buck_volts,
965 .n_linear_ranges = ARRAY_SIZE(bd718xx_dvs_buck_volts),
966 .vsel_reg = BD71837_REG_BUCK4_VOLT_RUN,
967 .vsel_mask = DVS_BUCK_RUN_MASK,
968 .enable_reg = BD71837_REG_BUCK4_CTRL,
969 .enable_mask = BD718XX_BUCK_EN,
970 .owner = THIS_MODULE,
971 .of_parse_cb = buck_set_hw_dvs_levels,
972 },
973 .dvs = {
974 .level_map = ROHM_DVS_LEVEL_RUN,
975 .run_reg = BD71837_REG_BUCK4_VOLT_RUN,
976 .run_mask = DVS_BUCK_RUN_MASK,
977 },
978 .init = {
979 .reg = BD71837_REG_BUCK4_CTRL,
980 .mask = BD718XX_BUCK_SEL,
981 .val = BD718XX_BUCK_SEL,
982 },
983 },
984 {
985 .desc = {
986 .name = "buck5",
987 .of_match = of_match_ptr("BUCK5"),
988 .regulators_node = of_match_ptr("regulators"),
989 .id = BD718XX_BUCK5,
990 .ops = &bd71837_pickable_range_buck_ops,
991 .type = REGULATOR_VOLTAGE,
992 .n_voltages = BD71837_BUCK5_VOLTAGE_NUM,
993 .linear_ranges = bd71837_buck5_volts,
994 .n_linear_ranges =
995 ARRAY_SIZE(bd71837_buck5_volts),
996 .vsel_reg = BD718XX_REG_1ST_NODVS_BUCK_VOLT,
997 .vsel_mask = BD71837_BUCK5_MASK,
998 .vsel_range_reg = BD718XX_REG_1ST_NODVS_BUCK_VOLT,
999 .vsel_range_mask = BD71837_BUCK5_RANGE_MASK,
1000 .linear_range_selectors = bd71837_buck5_volt_range_sel,
1001 .enable_reg = BD718XX_REG_1ST_NODVS_BUCK_CTRL,
1002 .enable_mask = BD718XX_BUCK_EN,
1003 .owner = THIS_MODULE,
1004 },
1005 .init = {
1006 .reg = BD718XX_REG_1ST_NODVS_BUCK_CTRL,
1007 .mask = BD718XX_BUCK_SEL,
1008 .val = BD718XX_BUCK_SEL,
1009 },
1010 },
1011 {
1012 .desc = {
1013 .name = "buck6",
1014 .of_match = of_match_ptr("BUCK6"),
1015 .regulators_node = of_match_ptr("regulators"),
1016 .id = BD718XX_BUCK6,
1017 .ops = &bd71837_buck_regulator_ops,
1018 .type = REGULATOR_VOLTAGE,
1019 .n_voltages = BD71837_BUCK6_VOLTAGE_NUM,
1020 .linear_ranges = bd71837_buck6_volts,
1021 .n_linear_ranges =
1022 ARRAY_SIZE(bd71837_buck6_volts),
1023 .vsel_reg = BD718XX_REG_2ND_NODVS_BUCK_VOLT,
1024 .vsel_mask = BD71837_BUCK6_MASK,
1025 .enable_reg = BD718XX_REG_2ND_NODVS_BUCK_CTRL,
1026 .enable_mask = BD718XX_BUCK_EN,
1027 .owner = THIS_MODULE,
1028 },
1029 .init = {
1030 .reg = BD718XX_REG_2ND_NODVS_BUCK_CTRL,
1031 .mask = BD718XX_BUCK_SEL,
1032 .val = BD718XX_BUCK_SEL,
1033 },
1034 },
1035 {
1036 .desc = {
1037 .name = "buck7",
1038 .of_match = of_match_ptr("BUCK7"),
1039 .regulators_node = of_match_ptr("regulators"),
1040 .id = BD718XX_BUCK7,
1041 .ops = &bd71837_buck_regulator_nolinear_ops,
1042 .type = REGULATOR_VOLTAGE,
1043 .volt_table = &bd718xx_3rd_nodvs_buck_volts[0],
1044 .n_voltages = ARRAY_SIZE(bd718xx_3rd_nodvs_buck_volts),
1045 .vsel_reg = BD718XX_REG_3RD_NODVS_BUCK_VOLT,
1046 .vsel_mask = BD718XX_3RD_NODVS_BUCK_MASK,
1047 .enable_reg = BD718XX_REG_3RD_NODVS_BUCK_CTRL,
1048 .enable_mask = BD718XX_BUCK_EN,
1049 .owner = THIS_MODULE,
1050 },
1051 .init = {
1052 .reg = BD718XX_REG_3RD_NODVS_BUCK_CTRL,
1053 .mask = BD718XX_BUCK_SEL,
1054 .val = BD718XX_BUCK_SEL,
1055 },
1056 },
1057 {
1058 .desc = {
1059 .name = "buck8",
1060 .of_match = of_match_ptr("BUCK8"),
1061 .regulators_node = of_match_ptr("regulators"),
1062 .id = BD718XX_BUCK8,
1063 .ops = &bd71837_buck_regulator_ops,
1064 .type = REGULATOR_VOLTAGE,
1065 .n_voltages = BD718XX_4TH_NODVS_BUCK_VOLTAGE_NUM,
1066 .linear_ranges = bd718xx_4th_nodvs_buck_volts,
1067 .n_linear_ranges =
1068 ARRAY_SIZE(bd718xx_4th_nodvs_buck_volts),
1069 .vsel_reg = BD718XX_REG_4TH_NODVS_BUCK_VOLT,
1070 .vsel_mask = BD718XX_4TH_NODVS_BUCK_MASK,
1071 .enable_reg = BD718XX_REG_4TH_NODVS_BUCK_CTRL,
1072 .enable_mask = BD718XX_BUCK_EN,
1073 .owner = THIS_MODULE,
1074 },
1075 .init = {
1076 .reg = BD718XX_REG_4TH_NODVS_BUCK_CTRL,
1077 .mask = BD718XX_BUCK_SEL,
1078 .val = BD718XX_BUCK_SEL,
1079 },
1080 },
1081 {
1082 .desc = {
1083 .name = "ldo1",
1084 .of_match = of_match_ptr("LDO1"),
1085 .regulators_node = of_match_ptr("regulators"),
1086 .id = BD718XX_LDO1,
1087 .ops = &bd71837_pickable_range_ldo_ops,
1088 .type = REGULATOR_VOLTAGE,
1089 .n_voltages = BD718XX_LDO1_VOLTAGE_NUM,
1090 .linear_ranges = bd718xx_ldo1_volts,
1091 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo1_volts),
1092 .vsel_reg = BD718XX_REG_LDO1_VOLT,
1093 .vsel_mask = BD718XX_LDO1_MASK,
1094 .vsel_range_reg = BD718XX_REG_LDO1_VOLT,
1095 .vsel_range_mask = BD718XX_LDO1_RANGE_MASK,
1096 .linear_range_selectors = bd718xx_ldo1_volt_range_sel,
1097 .enable_reg = BD718XX_REG_LDO1_VOLT,
1098 .enable_mask = BD718XX_LDO_EN,
1099 .owner = THIS_MODULE,
1100 },
1101 .init = {
1102 .reg = BD718XX_REG_LDO1_VOLT,
1103 .mask = BD718XX_LDO_SEL,
1104 .val = BD718XX_LDO_SEL,
1105 },
1106 },
1107 {
1108 .desc = {
1109 .name = "ldo2",
1110 .of_match = of_match_ptr("LDO2"),
1111 .regulators_node = of_match_ptr("regulators"),
1112 .id = BD718XX_LDO2,
1113 .ops = &bd71837_ldo_regulator_nolinear_ops,
1114 .type = REGULATOR_VOLTAGE,
1115 .volt_table = &ldo_2_volts[0],
1116 .vsel_reg = BD718XX_REG_LDO2_VOLT,
1117 .vsel_mask = BD718XX_LDO2_MASK,
1118 .n_voltages = ARRAY_SIZE(ldo_2_volts),
1119 .enable_reg = BD718XX_REG_LDO2_VOLT,
1120 .enable_mask = BD718XX_LDO_EN,
1121 .owner = THIS_MODULE,
1122 },
1123 .init = {
1124 .reg = BD718XX_REG_LDO2_VOLT,
1125 .mask = BD718XX_LDO_SEL,
1126 .val = BD718XX_LDO_SEL,
1127 },
1128 },
1129 {
1130 .desc = {
1131 .name = "ldo3",
1132 .of_match = of_match_ptr("LDO3"),
1133 .regulators_node = of_match_ptr("regulators"),
1134 .id = BD718XX_LDO3,
1135 .ops = &bd71837_ldo_regulator_ops,
1136 .type = REGULATOR_VOLTAGE,
1137 .n_voltages = BD718XX_LDO3_VOLTAGE_NUM,
1138 .linear_ranges = bd718xx_ldo3_volts,
1139 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo3_volts),
1140 .vsel_reg = BD718XX_REG_LDO3_VOLT,
1141 .vsel_mask = BD718XX_LDO3_MASK,
1142 .enable_reg = BD718XX_REG_LDO3_VOLT,
1143 .enable_mask = BD718XX_LDO_EN,
1144 .owner = THIS_MODULE,
1145 },
1146 .init = {
1147 .reg = BD718XX_REG_LDO3_VOLT,
1148 .mask = BD718XX_LDO_SEL,
1149 .val = BD718XX_LDO_SEL,
1150 },
1151 },
1152 {
1153 .desc = {
1154 .name = "ldo4",
1155 .of_match = of_match_ptr("LDO4"),
1156 .regulators_node = of_match_ptr("regulators"),
1157 .id = BD718XX_LDO4,
1158 .ops = &bd71837_ldo_regulator_ops,
1159 .type = REGULATOR_VOLTAGE,
1160 .n_voltages = BD718XX_LDO4_VOLTAGE_NUM,
1161 .linear_ranges = bd718xx_ldo4_volts,
1162 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo4_volts),
1163 .vsel_reg = BD718XX_REG_LDO4_VOLT,
1164 .vsel_mask = BD718XX_LDO4_MASK,
1165 .enable_reg = BD718XX_REG_LDO4_VOLT,
1166 .enable_mask = BD718XX_LDO_EN,
1167 .owner = THIS_MODULE,
1168 },
1169 .init = {
1170 .reg = BD718XX_REG_LDO4_VOLT,
1171 .mask = BD718XX_LDO_SEL,
1172 .val = BD718XX_LDO_SEL,
1173 },
1174 },
1175 {
1176 .desc = {
1177 .name = "ldo5",
1178 .of_match = of_match_ptr("LDO5"),
1179 .regulators_node = of_match_ptr("regulators"),
1180 .id = BD718XX_LDO5,
1181 .ops = &bd71837_ldo_regulator_ops,
1182 .type = REGULATOR_VOLTAGE,
1183 .n_voltages = BD71837_LDO5_VOLTAGE_NUM,
1184 .linear_ranges = bd71837_ldo5_volts,
1185 .n_linear_ranges = ARRAY_SIZE(bd71837_ldo5_volts),
1186 /* LDO5 is supplied by buck6 */
1187 .supply_name = "buck6",
1188 .vsel_reg = BD718XX_REG_LDO5_VOLT,
1189 .vsel_mask = BD71837_LDO5_MASK,
1190 .enable_reg = BD718XX_REG_LDO5_VOLT,
1191 .enable_mask = BD718XX_LDO_EN,
1192 .owner = THIS_MODULE,
1193 },
1194 .init = {
1195 .reg = BD718XX_REG_LDO5_VOLT,
1196 .mask = BD718XX_LDO_SEL,
1197 .val = BD718XX_LDO_SEL,
1198 },
1199 .additional_inits = bd71837_ldo5_inits,
1200 .additional_init_amnt = ARRAY_SIZE(bd71837_ldo5_inits),
1201 },
1202 {
1203 .desc = {
1204 .name = "ldo6",
1205 .of_match = of_match_ptr("LDO6"),
1206 .regulators_node = of_match_ptr("regulators"),
1207 .id = BD718XX_LDO6,
1208 .ops = &bd71837_ldo_regulator_ops,
1209 .type = REGULATOR_VOLTAGE,
1210 .n_voltages = BD718XX_LDO6_VOLTAGE_NUM,
1211 .linear_ranges = bd718xx_ldo6_volts,
1212 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo6_volts),
1213 /* LDO6 is supplied by buck7 */
1214 .supply_name = "buck7",
1215 .vsel_reg = BD718XX_REG_LDO6_VOLT,
1216 .vsel_mask = BD718XX_LDO6_MASK,
1217 .enable_reg = BD718XX_REG_LDO6_VOLT,
1218 .enable_mask = BD718XX_LDO_EN,
1219 .owner = THIS_MODULE,
1220 },
1221 .init = {
1222 .reg = BD718XX_REG_LDO6_VOLT,
1223 .mask = BD718XX_LDO_SEL,
1224 .val = BD718XX_LDO_SEL,
1225 },
1226 .additional_inits = bd71837_ldo6_inits,
1227 .additional_init_amnt = ARRAY_SIZE(bd71837_ldo6_inits),
1228 },
1229 {
1230 .desc = {
1231 .name = "ldo7",
1232 .of_match = of_match_ptr("LDO7"),
1233 .regulators_node = of_match_ptr("regulators"),
1234 .id = BD718XX_LDO7,
1235 .ops = &bd71837_ldo_regulator_ops,
1236 .type = REGULATOR_VOLTAGE,
1237 .n_voltages = BD71837_LDO7_VOLTAGE_NUM,
1238 .linear_ranges = bd71837_ldo7_volts,
1239 .n_linear_ranges = ARRAY_SIZE(bd71837_ldo7_volts),
1240 .vsel_reg = BD71837_REG_LDO7_VOLT,
1241 .vsel_mask = BD71837_LDO7_MASK,
1242 .enable_reg = BD71837_REG_LDO7_VOLT,
1243 .enable_mask = BD718XX_LDO_EN,
1244 .owner = THIS_MODULE,
1245 },
1246 .init = {
1247 .reg = BD71837_REG_LDO7_VOLT,
1248 .mask = BD718XX_LDO_SEL,
1249 .val = BD718XX_LDO_SEL,
1250 },
1251 },
1252};
1253
1254static int bd718xx_probe(struct platform_device *pdev)
1255{
1256 struct bd718xx *mfd;
1257 struct regulator_config config = { 0 };
1258 int i, j, err;
1259 bool use_snvs;
1260 const struct bd718xx_regulator_data *reg_data;
1261 unsigned int num_reg_data;
1262 enum rohm_chip_type chip = platform_get_device_id(pdev)->driver_data;
1263
1264 mfd = dev_get_drvdata(pdev->dev.parent);
1265 if (!mfd) {
1266 dev_err(&pdev->dev, "No MFD driver data\n");
1267 err = -EINVAL;
1268 goto err;
1269 }
1270
1271 switch (chip) {
1272 case ROHM_CHIP_TYPE_BD71837:
1273 reg_data = bd71837_regulators;
1274 num_reg_data = ARRAY_SIZE(bd71837_regulators);
1275 break;
1276 case ROHM_CHIP_TYPE_BD71847:
1277 reg_data = bd71847_regulators;
1278 num_reg_data = ARRAY_SIZE(bd71847_regulators);
1279 break;
1280 default:
1281 dev_err(&pdev->dev, "Unsupported chip type\n");
1282 err = -EINVAL;
1283 goto err;
1284 }
1285
1286 /* Register LOCK release */
1287 err = regmap_update_bits(mfd->chip.regmap, BD718XX_REG_REGLOCK,
1288 (REGLOCK_PWRSEQ | REGLOCK_VREG), 0);
1289 if (err) {
1290 dev_err(&pdev->dev, "Failed to unlock PMIC (%d)\n", err);
1291 goto err;
1292 } else {
1293 dev_dbg(&pdev->dev, "Unlocked lock register 0x%x\n",
1294 BD718XX_REG_REGLOCK);
1295 }
1296
1297 use_snvs = of_property_read_bool(pdev->dev.parent->of_node,
1298 "rohm,reset-snvs-powered");
1299
1300 /*
1301 * Change the next stage from poweroff to be READY instead of SNVS
1302 * for all reset types because OTP loading at READY will clear SEL
1303 * bit allowing HW defaults for power rails to be used
1304 */
1305 if (!use_snvs) {
1306 err = regmap_update_bits(mfd->chip.regmap,
1307 BD718XX_REG_TRANS_COND1,
1308 BD718XX_ON_REQ_POWEROFF_MASK |
1309 BD718XX_SWRESET_POWEROFF_MASK |
1310 BD718XX_WDOG_POWEROFF_MASK |
1311 BD718XX_KEY_L_POWEROFF_MASK,
1312 BD718XX_POWOFF_TO_RDY);
1313 if (err) {
1314 dev_err(&pdev->dev, "Failed to change reset target\n");
1315 goto err;
1316 } else {
1317 dev_dbg(&pdev->dev,
1318 "Changed all resets from SVNS to READY\n");
1319 }
1320 }
1321
1322 for (i = 0; i < num_reg_data; i++) {
1323
1324 const struct regulator_desc *desc;
1325 struct regulator_dev *rdev;
1326 const struct bd718xx_regulator_data *r;
1327
1328 r = ®_data[i];
1329 desc = &r->desc;
1330
1331 config.dev = pdev->dev.parent;
1332 config.regmap = mfd->chip.regmap;
1333
1334 rdev = devm_regulator_register(&pdev->dev, desc, &config);
1335 if (IS_ERR(rdev)) {
1336 dev_err(&pdev->dev,
1337 "failed to register %s regulator\n",
1338 desc->name);
1339 err = PTR_ERR(rdev);
1340 goto err;
1341 }
1342
1343 /*
1344 * Regulator register gets the regulator constraints and
1345 * applies them (set_machine_constraints). This should have
1346 * turned the control register(s) to correct values and we
1347 * can now switch the control from PMIC state machine to the
1348 * register interface
1349 *
1350 * At poweroff transition PMIC HW disables EN bit for
1351 * regulators but leaves SEL bit untouched. So if state
1352 * transition from POWEROFF is done to SNVS - then all power
1353 * rails controlled by SW (having SEL bit set) stay disabled
1354 * as EN is cleared. This will result boot failure if any
1355 * crucial systems are powered by these rails. We don't
1356 * enable SW control for crucial regulators if snvs state is
1357 * used
1358 */
1359 if (!use_snvs || !rdev->constraints->always_on ||
1360 !rdev->constraints->boot_on) {
1361 err = regmap_update_bits(mfd->chip.regmap, r->init.reg,
1362 r->init.mask, r->init.val);
1363 if (err) {
1364 dev_err(&pdev->dev,
1365 "Failed to take control for (%s)\n",
1366 desc->name);
1367 goto err;
1368 }
1369 }
1370 for (j = 0; j < r->additional_init_amnt; j++) {
1371 err = regmap_update_bits(mfd->chip.regmap,
1372 r->additional_inits[j].reg,
1373 r->additional_inits[j].mask,
1374 r->additional_inits[j].val);
1375 if (err) {
1376 dev_err(&pdev->dev,
1377 "Buck (%s) initialization failed\n",
1378 desc->name);
1379 goto err;
1380 }
1381 }
1382 }
1383
1384err:
1385 return err;
1386}
1387
1388static const struct platform_device_id bd718x7_pmic_id[] = {
1389 { "bd71837-pmic", ROHM_CHIP_TYPE_BD71837 },
1390 { "bd71847-pmic", ROHM_CHIP_TYPE_BD71847 },
1391 { },
1392};
1393MODULE_DEVICE_TABLE(platform, bd718x7_pmic_id);
1394
1395static struct platform_driver bd718xx_regulator = {
1396 .driver = {
1397 .name = "bd718xx-pmic",
1398 },
1399 .probe = bd718xx_probe,
1400 .id_table = bd718x7_pmic_id,
1401};
1402
1403module_platform_driver(bd718xx_regulator);
1404
1405MODULE_AUTHOR("Matti Vaittinen <matti.vaittinen@fi.rohmeurope.com>");
1406MODULE_DESCRIPTION("BD71837/BD71847 voltage regulator driver");
1407MODULE_LICENSE("GPL");
1408MODULE_ALIAS("platform:bd718xx-pmic");
1// SPDX-License-Identifier: GPL-2.0
2// Copyright (C) 2018 ROHM Semiconductors
3// bd71837-regulator.c ROHM BD71837MWV/BD71847MWV regulator driver
4
5#include <linux/delay.h>
6#include <linux/err.h>
7#include <linux/interrupt.h>
8#include <linux/kernel.h>
9#include <linux/mfd/rohm-bd718x7.h>
10#include <linux/module.h>
11#include <linux/of.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>
17
18/* Typical regulator startup times as per data sheet in uS */
19#define BD71847_BUCK1_STARTUP_TIME 144
20#define BD71847_BUCK2_STARTUP_TIME 162
21#define BD71847_BUCK3_STARTUP_TIME 162
22#define BD71847_BUCK4_STARTUP_TIME 240
23#define BD71847_BUCK5_STARTUP_TIME 270
24#define BD71847_BUCK6_STARTUP_TIME 200
25#define BD71847_LDO1_STARTUP_TIME 440
26#define BD71847_LDO2_STARTUP_TIME 370
27#define BD71847_LDO3_STARTUP_TIME 310
28#define BD71847_LDO4_STARTUP_TIME 400
29#define BD71847_LDO5_STARTUP_TIME 530
30#define BD71847_LDO6_STARTUP_TIME 400
31
32#define BD71837_BUCK1_STARTUP_TIME 160
33#define BD71837_BUCK2_STARTUP_TIME 180
34#define BD71837_BUCK3_STARTUP_TIME 180
35#define BD71837_BUCK4_STARTUP_TIME 180
36#define BD71837_BUCK5_STARTUP_TIME 160
37#define BD71837_BUCK6_STARTUP_TIME 240
38#define BD71837_BUCK7_STARTUP_TIME 220
39#define BD71837_BUCK8_STARTUP_TIME 200
40#define BD71837_LDO1_STARTUP_TIME 440
41#define BD71837_LDO2_STARTUP_TIME 370
42#define BD71837_LDO3_STARTUP_TIME 310
43#define BD71837_LDO4_STARTUP_TIME 400
44#define BD71837_LDO5_STARTUP_TIME 310
45#define BD71837_LDO6_STARTUP_TIME 400
46#define BD71837_LDO7_STARTUP_TIME 530
47
48/*
49 * BD718(37/47/50) have two "enable control modes". ON/OFF can either be
50 * controlled by software - or by PMIC internal HW state machine. Whether
51 * regulator should be under SW or HW control can be defined from device-tree.
52 * Let's provide separate ops for regulators to use depending on the "enable
53 * control mode".
54 */
55#define BD718XX_HWOPNAME(swopname) swopname##_hwcontrol
56
57#define BD718XX_OPS(name, _list_voltage, _map_voltage, _set_voltage_sel, \
58 _get_voltage_sel, _set_voltage_time_sel, _set_ramp_delay, \
59 _set_uvp, _set_ovp) \
60static const struct regulator_ops name = { \
61 .enable = regulator_enable_regmap, \
62 .disable = regulator_disable_regmap, \
63 .is_enabled = regulator_is_enabled_regmap, \
64 .list_voltage = (_list_voltage), \
65 .map_voltage = (_map_voltage), \
66 .set_voltage_sel = (_set_voltage_sel), \
67 .get_voltage_sel = (_get_voltage_sel), \
68 .set_voltage_time_sel = (_set_voltage_time_sel), \
69 .set_ramp_delay = (_set_ramp_delay), \
70 .set_under_voltage_protection = (_set_uvp), \
71 .set_over_voltage_protection = (_set_ovp), \
72}; \
73 \
74static const struct regulator_ops BD718XX_HWOPNAME(name) = { \
75 .is_enabled = always_enabled_by_hwstate, \
76 .list_voltage = (_list_voltage), \
77 .map_voltage = (_map_voltage), \
78 .set_voltage_sel = (_set_voltage_sel), \
79 .get_voltage_sel = (_get_voltage_sel), \
80 .set_voltage_time_sel = (_set_voltage_time_sel), \
81 .set_ramp_delay = (_set_ramp_delay), \
82 .set_under_voltage_protection = (_set_uvp), \
83 .set_over_voltage_protection = (_set_ovp), \
84} \
85
86/*
87 * BUCK1/2/3/4
88 * BUCK1RAMPRATE[1:0] BUCK1 DVS ramp rate setting
89 * 00: 10.00mV/usec 10mV 1uS
90 * 01: 5.00mV/usec 10mV 2uS
91 * 10: 2.50mV/usec 10mV 4uS
92 * 11: 1.25mV/usec 10mV 8uS
93 */
94static const unsigned int bd718xx_ramp_delay[] = { 10000, 5000, 2500, 1250 };
95
96/* These functions are used when regulators are under HW state machine control.
97 * We assume PMIC is in RUN state because SW running and able to query the
98 * status. Most of the regulators have fixed ON or OFF state at RUN/IDLE so for
99 * them we just return a constant. BD71837 BUCK3 and BUCK4 are exceptions as
100 * they support configuring the ON/OFF state for RUN.
101 *
102 * Note for next hacker - these PMICs have a register where the HW state can be
103 * read. If assuming RUN appears to be false in your use-case - you can
104 * implement state reading (although that is not going to be atomic) before
105 * returning the enable state.
106 */
107static int always_enabled_by_hwstate(struct regulator_dev *rdev)
108{
109 return 1;
110}
111
112static int never_enabled_by_hwstate(struct regulator_dev *rdev)
113{
114 return 0;
115}
116
117static int bd71837_get_buck34_enable_hwctrl(struct regulator_dev *rdev)
118{
119 int ret;
120 unsigned int val;
121
122 ret = regmap_read(rdev->regmap, rdev->desc->enable_reg, &val);
123 if (ret)
124 return ret;
125
126 return !!(BD718XX_BUCK_RUN_ON & val);
127}
128
129static void voltage_change_done(struct regulator_dev *rdev, unsigned int sel,
130 unsigned int *mask)
131{
132 int ret;
133
134 if (*mask) {
135 /*
136 * Let's allow scheduling as we use I2C anyways. We just need to
137 * guarantee minimum of 1ms sleep - it shouldn't matter if we
138 * exceed it due to the scheduling.
139 */
140 msleep(1);
141
142 ret = regmap_clear_bits(rdev->regmap, BD718XX_REG_MVRFLTMASK2,
143 *mask);
144 if (ret)
145 dev_err(&rdev->dev,
146 "Failed to re-enable voltage monitoring (%d)\n",
147 ret);
148 }
149}
150
151static int voltage_change_prepare(struct regulator_dev *rdev, unsigned int sel,
152 unsigned int *mask)
153{
154 int ret;
155
156 *mask = 0;
157 if (rdev->desc->ops->is_enabled(rdev)) {
158 int now, new;
159
160 now = rdev->desc->ops->get_voltage_sel(rdev);
161 if (now < 0)
162 return now;
163
164 now = rdev->desc->ops->list_voltage(rdev, now);
165 if (now < 0)
166 return now;
167
168 new = rdev->desc->ops->list_voltage(rdev, sel);
169 if (new < 0)
170 return new;
171
172 /*
173 * If we increase LDO voltage when LDO is enabled we need to
174 * disable the power-good detection until voltage has reached
175 * the new level. According to HW colleagues the maximum time
176 * it takes is 1000us. I assume that on systems with light load
177 * this might be less - and we could probably use DT to give
178 * system specific delay value if performance matters.
179 *
180 * Well, knowing we use I2C here and can add scheduling delays
181 * I don't think it is worth the hassle and I just add fixed
182 * 1ms sleep here (and allow scheduling). If this turns out to
183 * be a problem we can change it to delay and make the delay
184 * time configurable.
185 */
186 if (new > now) {
187 int tmp;
188 int prot_bit;
189 int ldo_offset = rdev->desc->id - BD718XX_LDO1;
190
191 prot_bit = BD718XX_LDO1_VRMON80 << ldo_offset;
192 ret = regmap_read(rdev->regmap, BD718XX_REG_MVRFLTMASK2,
193 &tmp);
194 if (ret) {
195 dev_err(&rdev->dev,
196 "Failed to read voltage monitoring state\n");
197 return ret;
198 }
199
200 if (!(tmp & prot_bit)) {
201 /* We disable protection if it was enabled... */
202 ret = regmap_set_bits(rdev->regmap,
203 BD718XX_REG_MVRFLTMASK2,
204 prot_bit);
205 /* ...and we also want to re-enable it */
206 *mask = prot_bit;
207 }
208 if (ret) {
209 dev_err(&rdev->dev,
210 "Failed to stop voltage monitoring\n");
211 return ret;
212 }
213 }
214 }
215
216 return 0;
217}
218
219static int bd718xx_set_voltage_sel_restricted(struct regulator_dev *rdev,
220 unsigned int sel)
221{
222 int ret;
223 int mask;
224
225 ret = voltage_change_prepare(rdev, sel, &mask);
226 if (ret)
227 return ret;
228
229 ret = regulator_set_voltage_sel_regmap(rdev, sel);
230 voltage_change_done(rdev, sel, &mask);
231
232 return ret;
233}
234
235static int bd718xx_set_voltage_sel_pickable_restricted(
236 struct regulator_dev *rdev, unsigned int sel)
237{
238 int ret;
239 int mask;
240
241 ret = voltage_change_prepare(rdev, sel, &mask);
242 if (ret)
243 return ret;
244
245 ret = regulator_set_voltage_sel_pickable_regmap(rdev, sel);
246 voltage_change_done(rdev, sel, &mask);
247
248 return ret;
249}
250
251static int bd71837_set_voltage_sel_pickable_restricted(
252 struct regulator_dev *rdev, unsigned int sel)
253{
254 if (rdev->desc->ops->is_enabled(rdev))
255 return -EBUSY;
256
257 return regulator_set_voltage_sel_pickable_regmap(rdev, sel);
258}
259
260/*
261 * BD71837 BUCK1/2/3/4
262 * BD71847 BUCK1/2
263 * 0.70 to 1.30V (10mV step)
264 */
265static const struct linear_range bd718xx_dvs_buck_volts[] = {
266 REGULATOR_LINEAR_RANGE(700000, 0x00, 0x3C, 10000),
267 REGULATOR_LINEAR_RANGE(1300000, 0x3D, 0x3F, 0),
268};
269
270/*
271 * BD71837 BUCK5
272 * 0.7V to 1.35V (range 0)
273 * and
274 * 0.675 to 1.325 (range 1)
275 */
276static const struct linear_range bd71837_buck5_volts[] = {
277 /* Ranges when VOLT_SEL bit is 0 */
278 REGULATOR_LINEAR_RANGE(700000, 0x00, 0x03, 100000),
279 REGULATOR_LINEAR_RANGE(1050000, 0x04, 0x05, 50000),
280 REGULATOR_LINEAR_RANGE(1200000, 0x06, 0x07, 150000),
281 /* Ranges when VOLT_SEL bit is 1 */
282 REGULATOR_LINEAR_RANGE(675000, 0x0, 0x3, 100000),
283 REGULATOR_LINEAR_RANGE(1025000, 0x4, 0x5, 50000),
284 REGULATOR_LINEAR_RANGE(1175000, 0x6, 0x7, 150000),
285};
286
287/*
288 * Range selector for first 3 linear ranges is 0x0
289 * and 0x1 for last 3 ranges.
290 */
291static const unsigned int bd71837_buck5_volt_range_sel[] = {
292 0x0, 0x0, 0x0, 0x1, 0x1, 0x1
293};
294
295/*
296 * BD71847 BUCK3
297 */
298static const struct linear_range bd71847_buck3_volts[] = {
299 /* Ranges when VOLT_SEL bits are 00 */
300 REGULATOR_LINEAR_RANGE(700000, 0x00, 0x03, 100000),
301 REGULATOR_LINEAR_RANGE(1050000, 0x04, 0x05, 50000),
302 REGULATOR_LINEAR_RANGE(1200000, 0x06, 0x07, 150000),
303 /* Ranges when VOLT_SEL bits are 01 */
304 REGULATOR_LINEAR_RANGE(550000, 0x0, 0x7, 50000),
305 /* Ranges when VOLT_SEL bits are 11 */
306 REGULATOR_LINEAR_RANGE(675000, 0x0, 0x3, 100000),
307 REGULATOR_LINEAR_RANGE(1025000, 0x4, 0x5, 50000),
308 REGULATOR_LINEAR_RANGE(1175000, 0x6, 0x7, 150000),
309};
310
311static const unsigned int bd71847_buck3_volt_range_sel[] = {
312 0x0, 0x0, 0x0, 0x1, 0x2, 0x2, 0x2
313};
314
315static const struct linear_range bd71847_buck4_volts[] = {
316 REGULATOR_LINEAR_RANGE(3000000, 0x00, 0x03, 100000),
317 REGULATOR_LINEAR_RANGE(2600000, 0x00, 0x03, 100000),
318};
319
320static const unsigned int bd71847_buck4_volt_range_sel[] = { 0x0, 0x1 };
321
322/*
323 * BUCK6
324 * 3.0V to 3.3V (step 100mV)
325 */
326static const struct linear_range bd71837_buck6_volts[] = {
327 REGULATOR_LINEAR_RANGE(3000000, 0x00, 0x03, 100000),
328};
329
330/*
331 * BD71837 BUCK7
332 * BD71847 BUCK5
333 * 000 = 1.605V
334 * 001 = 1.695V
335 * 010 = 1.755V
336 * 011 = 1.8V (Initial)
337 * 100 = 1.845V
338 * 101 = 1.905V
339 * 110 = 1.95V
340 * 111 = 1.995V
341 */
342static const unsigned int bd718xx_3rd_nodvs_buck_volts[] = {
343 1605000, 1695000, 1755000, 1800000, 1845000, 1905000, 1950000, 1995000
344};
345
346/*
347 * BUCK8
348 * 0.8V to 1.40V (step 10mV)
349 */
350static const struct linear_range bd718xx_4th_nodvs_buck_volts[] = {
351 REGULATOR_LINEAR_RANGE(800000, 0x00, 0x3C, 10000),
352};
353
354/*
355 * LDO1
356 * 3.0 to 3.3V (100mV step)
357 */
358static const struct linear_range bd718xx_ldo1_volts[] = {
359 REGULATOR_LINEAR_RANGE(3000000, 0x00, 0x03, 100000),
360 REGULATOR_LINEAR_RANGE(1600000, 0x00, 0x03, 100000),
361};
362
363static const unsigned int bd718xx_ldo1_volt_range_sel[] = { 0x0, 0x1 };
364
365/*
366 * LDO2
367 * 0.8 or 0.9V
368 */
369static const unsigned int ldo_2_volts[] = {
370 900000, 800000
371};
372
373/*
374 * LDO3
375 * 1.8 to 3.3V (100mV step)
376 */
377static const struct linear_range bd718xx_ldo3_volts[] = {
378 REGULATOR_LINEAR_RANGE(1800000, 0x00, 0x0F, 100000),
379};
380
381/*
382 * LDO4
383 * 0.9 to 1.8V (100mV step)
384 */
385static const struct linear_range bd718xx_ldo4_volts[] = {
386 REGULATOR_LINEAR_RANGE(900000, 0x00, 0x09, 100000),
387};
388
389/*
390 * LDO5 for BD71837
391 * 1.8 to 3.3V (100mV step)
392 */
393static const struct linear_range bd71837_ldo5_volts[] = {
394 REGULATOR_LINEAR_RANGE(1800000, 0x00, 0x0F, 100000),
395};
396
397/*
398 * LDO5 for BD71837
399 * 1.8 to 3.3V (100mV step)
400 */
401static const struct linear_range bd71847_ldo5_volts[] = {
402 REGULATOR_LINEAR_RANGE(1800000, 0x00, 0x0F, 100000),
403 REGULATOR_LINEAR_RANGE(800000, 0x00, 0x0F, 100000),
404};
405
406static const unsigned int bd71847_ldo5_volt_range_sel[] = { 0x0, 0x1 };
407
408/*
409 * LDO6
410 * 0.9 to 1.8V (100mV step)
411 */
412static const struct linear_range bd718xx_ldo6_volts[] = {
413 REGULATOR_LINEAR_RANGE(900000, 0x00, 0x09, 100000),
414};
415
416/*
417 * LDO7
418 * 1.8 to 3.3V (100mV step)
419 */
420static const struct linear_range bd71837_ldo7_volts[] = {
421 REGULATOR_LINEAR_RANGE(1800000, 0x00, 0x0F, 100000),
422};
423
424struct reg_init {
425 unsigned int reg;
426 unsigned int mask;
427 unsigned int val;
428};
429struct bd718xx_regulator_data {
430 struct regulator_desc desc;
431 const struct rohm_dvs_config dvs;
432 const struct reg_init init;
433 const struct reg_init *additional_inits;
434 int additional_init_amnt;
435};
436
437static int bd718x7_xvp_sanity_check(struct regulator_dev *rdev, int lim_uV,
438 int severity)
439{
440 /*
441 * BD71837/47/50 ... (ICs supported by this driver) do not provide
442 * warnings, only protection
443 */
444 if (severity != REGULATOR_SEVERITY_PROT) {
445 dev_err(&rdev->dev,
446 "Unsupported Under Voltage protection level\n");
447 return -EINVAL;
448 }
449
450 /*
451 * And protection limit is not changeable. It can only be enabled
452 * or disabled
453 */
454 if (lim_uV)
455 return -EINVAL;
456
457 return 0;
458}
459
460static int bd718x7_set_ldo_uvp(struct regulator_dev *rdev, int lim_uV,
461 int severity, bool enable)
462{
463 int ldo_offset = rdev->desc->id - BD718XX_LDO1;
464 int prot_bit, ret;
465
466 ret = bd718x7_xvp_sanity_check(rdev, lim_uV, severity);
467 if (ret)
468 return ret;
469
470 prot_bit = BD718XX_LDO1_VRMON80 << ldo_offset;
471
472 if (enable)
473 return regmap_clear_bits(rdev->regmap, BD718XX_REG_MVRFLTMASK2,
474 prot_bit);
475
476 return regmap_set_bits(rdev->regmap, BD718XX_REG_MVRFLTMASK2,
477 prot_bit);
478}
479
480static int bd718x7_get_buck_prot_reg(int id, int *reg)
481{
482
483 if (id > BD718XX_BUCK8) {
484 WARN_ON(id > BD718XX_BUCK8);
485 return -EINVAL;
486 }
487
488 if (id > BD718XX_BUCK4)
489 *reg = BD718XX_REG_MVRFLTMASK0;
490 else
491 *reg = BD718XX_REG_MVRFLTMASK1;
492
493 return 0;
494}
495
496static int bd718x7_get_buck_ovp_info(int id, int *reg, int *bit)
497{
498 int ret;
499
500 ret = bd718x7_get_buck_prot_reg(id, reg);
501 if (ret)
502 return ret;
503
504 *bit = BIT((id % 4) * 2 + 1);
505
506 return 0;
507}
508
509static int bd718x7_get_buck_uvp_info(int id, int *reg, int *bit)
510{
511 int ret;
512
513 ret = bd718x7_get_buck_prot_reg(id, reg);
514 if (ret)
515 return ret;
516
517 *bit = BIT((id % 4) * 2);
518
519 return 0;
520}
521
522static int bd718x7_set_buck_uvp(struct regulator_dev *rdev, int lim_uV,
523 int severity, bool enable)
524{
525 int bit, reg, ret;
526
527 ret = bd718x7_xvp_sanity_check(rdev, lim_uV, severity);
528 if (ret)
529 return ret;
530
531 ret = bd718x7_get_buck_uvp_info(rdev->desc->id, ®, &bit);
532 if (ret)
533 return ret;
534
535 if (enable)
536 return regmap_clear_bits(rdev->regmap, reg, bit);
537
538 return regmap_set_bits(rdev->regmap, reg, bit);
539
540}
541
542static int bd718x7_set_buck_ovp(struct regulator_dev *rdev, int lim_uV,
543 int severity,
544 bool enable)
545{
546 int bit, reg, ret;
547
548 ret = bd718x7_xvp_sanity_check(rdev, lim_uV, severity);
549 if (ret)
550 return ret;
551
552 ret = bd718x7_get_buck_ovp_info(rdev->desc->id, ®, &bit);
553 if (ret)
554 return ret;
555
556 if (enable)
557 return regmap_clear_bits(rdev->regmap, reg, bit);
558
559 return regmap_set_bits(rdev->regmap, reg, bit);
560}
561
562/*
563 * OPS common for BD71847 and BD71850
564 */
565BD718XX_OPS(bd718xx_pickable_range_ldo_ops,
566 regulator_list_voltage_pickable_linear_range, NULL,
567 bd718xx_set_voltage_sel_pickable_restricted,
568 regulator_get_voltage_sel_pickable_regmap, NULL, NULL,
569 bd718x7_set_ldo_uvp, NULL);
570
571/* BD71847 and BD71850 LDO 5 is by default OFF at RUN state */
572static const struct regulator_ops bd718xx_ldo5_ops_hwstate = {
573 .is_enabled = never_enabled_by_hwstate,
574 .list_voltage = regulator_list_voltage_pickable_linear_range,
575 .set_voltage_sel = bd718xx_set_voltage_sel_pickable_restricted,
576 .get_voltage_sel = regulator_get_voltage_sel_pickable_regmap,
577 .set_under_voltage_protection = bd718x7_set_ldo_uvp,
578};
579
580BD718XX_OPS(bd718xx_pickable_range_buck_ops,
581 regulator_list_voltage_pickable_linear_range, NULL,
582 regulator_set_voltage_sel_pickable_regmap,
583 regulator_get_voltage_sel_pickable_regmap,
584 regulator_set_voltage_time_sel, NULL, bd718x7_set_buck_uvp,
585 bd718x7_set_buck_ovp);
586
587BD718XX_OPS(bd718xx_ldo_regulator_ops, regulator_list_voltage_linear_range,
588 NULL, bd718xx_set_voltage_sel_restricted,
589 regulator_get_voltage_sel_regmap, NULL, NULL, bd718x7_set_ldo_uvp,
590 NULL);
591
592BD718XX_OPS(bd718xx_ldo_regulator_nolinear_ops, regulator_list_voltage_table,
593 NULL, bd718xx_set_voltage_sel_restricted,
594 regulator_get_voltage_sel_regmap, NULL, NULL, bd718x7_set_ldo_uvp,
595 NULL);
596
597BD718XX_OPS(bd718xx_buck_regulator_ops, regulator_list_voltage_linear_range,
598 NULL, regulator_set_voltage_sel_regmap,
599 regulator_get_voltage_sel_regmap, regulator_set_voltage_time_sel,
600 NULL, bd718x7_set_buck_uvp, bd718x7_set_buck_ovp);
601
602BD718XX_OPS(bd718xx_buck_regulator_nolinear_ops, regulator_list_voltage_table,
603 regulator_map_voltage_ascend, regulator_set_voltage_sel_regmap,
604 regulator_get_voltage_sel_regmap, regulator_set_voltage_time_sel,
605 NULL, bd718x7_set_buck_uvp, bd718x7_set_buck_ovp);
606
607/*
608 * OPS for BD71837
609 */
610BD718XX_OPS(bd71837_pickable_range_ldo_ops,
611 regulator_list_voltage_pickable_linear_range, NULL,
612 bd71837_set_voltage_sel_pickable_restricted,
613 regulator_get_voltage_sel_pickable_regmap, NULL, NULL,
614 bd718x7_set_ldo_uvp, NULL);
615
616BD718XX_OPS(bd71837_pickable_range_buck_ops,
617 regulator_list_voltage_pickable_linear_range, NULL,
618 bd71837_set_voltage_sel_pickable_restricted,
619 regulator_get_voltage_sel_pickable_regmap,
620 regulator_set_voltage_time_sel, NULL, bd718x7_set_buck_uvp,
621 bd718x7_set_buck_ovp);
622
623BD718XX_OPS(bd71837_ldo_regulator_ops, regulator_list_voltage_linear_range,
624 NULL, rohm_regulator_set_voltage_sel_restricted,
625 regulator_get_voltage_sel_regmap, NULL, NULL, bd718x7_set_ldo_uvp,
626 NULL);
627
628BD718XX_OPS(bd71837_ldo_regulator_nolinear_ops, regulator_list_voltage_table,
629 NULL, rohm_regulator_set_voltage_sel_restricted,
630 regulator_get_voltage_sel_regmap, NULL, NULL, bd718x7_set_ldo_uvp,
631 NULL);
632
633BD718XX_OPS(bd71837_buck_regulator_ops, regulator_list_voltage_linear_range,
634 NULL, rohm_regulator_set_voltage_sel_restricted,
635 regulator_get_voltage_sel_regmap, regulator_set_voltage_time_sel,
636 NULL, bd718x7_set_buck_uvp, bd718x7_set_buck_ovp);
637
638BD718XX_OPS(bd71837_buck_regulator_nolinear_ops, regulator_list_voltage_table,
639 regulator_map_voltage_ascend, rohm_regulator_set_voltage_sel_restricted,
640 regulator_get_voltage_sel_regmap, regulator_set_voltage_time_sel,
641 NULL, bd718x7_set_buck_uvp, bd718x7_set_buck_ovp);
642/*
643 * BD71837 bucks 3 and 4 support defining their enable/disable state also
644 * when buck enable state is under HW state machine control. In that case the
645 * bit [2] in CTRL register is used to indicate if regulator should be ON.
646 */
647static const struct regulator_ops bd71837_buck34_ops_hwctrl = {
648 .is_enabled = bd71837_get_buck34_enable_hwctrl,
649 .list_voltage = regulator_list_voltage_linear_range,
650 .set_voltage_sel = regulator_set_voltage_sel_regmap,
651 .get_voltage_sel = regulator_get_voltage_sel_regmap,
652 .set_voltage_time_sel = regulator_set_voltage_time_sel,
653 .set_ramp_delay = regulator_set_ramp_delay_regmap,
654 .set_under_voltage_protection = bd718x7_set_buck_uvp,
655 .set_over_voltage_protection = bd718x7_set_buck_ovp,
656};
657
658/*
659 * OPS for all of the ICs - BD718(37/47/50)
660 */
661BD718XX_OPS(bd718xx_dvs_buck_regulator_ops, regulator_list_voltage_linear_range,
662 NULL, regulator_set_voltage_sel_regmap,
663 regulator_get_voltage_sel_regmap, regulator_set_voltage_time_sel,
664 regulator_set_ramp_delay_regmap, bd718x7_set_buck_uvp,
665 bd718x7_set_buck_ovp);
666
667
668
669/*
670 * There is a HW quirk in BD71837. The shutdown sequence timings for
671 * bucks/LDOs which are controlled via register interface are changed.
672 * At PMIC poweroff the voltage for BUCK6/7 is cut immediately at the
673 * beginning of shut-down sequence. As bucks 6 and 7 are parent
674 * supplies for LDO5 and LDO6 - this causes LDO5/6 voltage
675 * monitoring to errorneously detect under voltage and force PMIC to
676 * emergency state instead of poweroff. In order to avoid this we
677 * disable voltage monitoring for LDO5 and LDO6
678 */
679static const struct reg_init bd71837_ldo5_inits[] = {
680 {
681 .reg = BD718XX_REG_MVRFLTMASK2,
682 .mask = BD718XX_LDO5_VRMON80,
683 .val = BD718XX_LDO5_VRMON80,
684 },
685};
686
687static const struct reg_init bd71837_ldo6_inits[] = {
688 {
689 .reg = BD718XX_REG_MVRFLTMASK2,
690 .mask = BD718XX_LDO6_VRMON80,
691 .val = BD718XX_LDO6_VRMON80,
692 },
693};
694
695static int buck_set_hw_dvs_levels(struct device_node *np,
696 const struct regulator_desc *desc,
697 struct regulator_config *cfg)
698{
699 struct bd718xx_regulator_data *data;
700
701 data = container_of(desc, struct bd718xx_regulator_data, desc);
702
703 return rohm_regulator_set_dvs_levels(&data->dvs, np, desc, cfg->regmap);
704}
705
706static const struct regulator_ops *bd71847_swcontrol_ops[] = {
707 &bd718xx_dvs_buck_regulator_ops, &bd718xx_dvs_buck_regulator_ops,
708 &bd718xx_pickable_range_buck_ops, &bd718xx_pickable_range_buck_ops,
709 &bd718xx_buck_regulator_nolinear_ops, &bd718xx_buck_regulator_ops,
710 &bd718xx_pickable_range_ldo_ops, &bd718xx_ldo_regulator_nolinear_ops,
711 &bd718xx_ldo_regulator_ops, &bd718xx_ldo_regulator_ops,
712 &bd718xx_pickable_range_ldo_ops, &bd718xx_ldo_regulator_ops,
713};
714
715static const struct regulator_ops *bd71847_hwcontrol_ops[] = {
716 &BD718XX_HWOPNAME(bd718xx_dvs_buck_regulator_ops),
717 &BD718XX_HWOPNAME(bd718xx_dvs_buck_regulator_ops),
718 &BD718XX_HWOPNAME(bd718xx_pickable_range_buck_ops),
719 &BD718XX_HWOPNAME(bd718xx_pickable_range_buck_ops),
720 &BD718XX_HWOPNAME(bd718xx_buck_regulator_nolinear_ops),
721 &BD718XX_HWOPNAME(bd718xx_buck_regulator_ops),
722 &BD718XX_HWOPNAME(bd718xx_pickable_range_ldo_ops),
723 &BD718XX_HWOPNAME(bd718xx_ldo_regulator_nolinear_ops),
724 &BD718XX_HWOPNAME(bd718xx_ldo_regulator_ops),
725 &BD718XX_HWOPNAME(bd718xx_ldo_regulator_ops),
726 &bd718xx_ldo5_ops_hwstate,
727 &BD718XX_HWOPNAME(bd718xx_ldo_regulator_ops),
728};
729
730static struct bd718xx_regulator_data bd71847_regulators[] = {
731 {
732 .desc = {
733 .name = "buck1",
734 .of_match = of_match_ptr("BUCK1"),
735 .regulators_node = of_match_ptr("regulators"),
736 .id = BD718XX_BUCK1,
737 .type = REGULATOR_VOLTAGE,
738 .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
739 .linear_ranges = bd718xx_dvs_buck_volts,
740 .n_linear_ranges =
741 ARRAY_SIZE(bd718xx_dvs_buck_volts),
742 .vsel_reg = BD718XX_REG_BUCK1_VOLT_RUN,
743 .vsel_mask = DVS_BUCK_RUN_MASK,
744 .enable_reg = BD718XX_REG_BUCK1_CTRL,
745 .enable_mask = BD718XX_BUCK_EN,
746 .enable_time = BD71847_BUCK1_STARTUP_TIME,
747 .owner = THIS_MODULE,
748 .ramp_delay_table = bd718xx_ramp_delay,
749 .n_ramp_values = ARRAY_SIZE(bd718xx_ramp_delay),
750 .ramp_reg = BD718XX_REG_BUCK1_CTRL,
751 .ramp_mask = BUCK_RAMPRATE_MASK,
752 .of_parse_cb = buck_set_hw_dvs_levels,
753 },
754 .dvs = {
755 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
756 ROHM_DVS_LEVEL_SUSPEND,
757 .run_reg = BD718XX_REG_BUCK1_VOLT_RUN,
758 .run_mask = DVS_BUCK_RUN_MASK,
759 .idle_reg = BD718XX_REG_BUCK1_VOLT_IDLE,
760 .idle_mask = DVS_BUCK_RUN_MASK,
761 .suspend_reg = BD718XX_REG_BUCK1_VOLT_SUSP,
762 .suspend_mask = DVS_BUCK_RUN_MASK,
763 },
764 .init = {
765 .reg = BD718XX_REG_BUCK1_CTRL,
766 .mask = BD718XX_BUCK_SEL,
767 .val = BD718XX_BUCK_SEL,
768 },
769 },
770 {
771 .desc = {
772 .name = "buck2",
773 .of_match = of_match_ptr("BUCK2"),
774 .regulators_node = of_match_ptr("regulators"),
775 .id = BD718XX_BUCK2,
776 .type = REGULATOR_VOLTAGE,
777 .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
778 .linear_ranges = bd718xx_dvs_buck_volts,
779 .n_linear_ranges = ARRAY_SIZE(bd718xx_dvs_buck_volts),
780 .vsel_reg = BD718XX_REG_BUCK2_VOLT_RUN,
781 .vsel_mask = DVS_BUCK_RUN_MASK,
782 .enable_reg = BD718XX_REG_BUCK2_CTRL,
783 .enable_mask = BD718XX_BUCK_EN,
784 .enable_time = BD71847_BUCK2_STARTUP_TIME,
785 .ramp_delay_table = bd718xx_ramp_delay,
786 .n_ramp_values = ARRAY_SIZE(bd718xx_ramp_delay),
787 .ramp_reg = BD718XX_REG_BUCK2_CTRL,
788 .ramp_mask = BUCK_RAMPRATE_MASK,
789 .owner = THIS_MODULE,
790 .of_parse_cb = buck_set_hw_dvs_levels,
791 },
792 .dvs = {
793 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE,
794 .run_reg = BD718XX_REG_BUCK2_VOLT_RUN,
795 .run_mask = DVS_BUCK_RUN_MASK,
796 .idle_reg = BD718XX_REG_BUCK2_VOLT_IDLE,
797 .idle_mask = DVS_BUCK_RUN_MASK,
798 },
799 .init = {
800 .reg = BD718XX_REG_BUCK2_CTRL,
801 .mask = BD718XX_BUCK_SEL,
802 .val = BD718XX_BUCK_SEL,
803 },
804 },
805 {
806 .desc = {
807 .name = "buck3",
808 .of_match = of_match_ptr("BUCK3"),
809 .regulators_node = of_match_ptr("regulators"),
810 .id = BD718XX_BUCK3,
811 .type = REGULATOR_VOLTAGE,
812 .n_voltages = BD71847_BUCK3_VOLTAGE_NUM,
813 .linear_ranges = bd71847_buck3_volts,
814 .n_linear_ranges =
815 ARRAY_SIZE(bd71847_buck3_volts),
816 .vsel_reg = BD718XX_REG_1ST_NODVS_BUCK_VOLT,
817 .vsel_mask = BD718XX_1ST_NODVS_BUCK_MASK,
818 .vsel_range_reg = BD718XX_REG_1ST_NODVS_BUCK_VOLT,
819 .vsel_range_mask = BD71847_BUCK3_RANGE_MASK,
820 .linear_range_selectors_bitfield = bd71847_buck3_volt_range_sel,
821 .enable_reg = BD718XX_REG_1ST_NODVS_BUCK_CTRL,
822 .enable_mask = BD718XX_BUCK_EN,
823 .enable_time = BD71847_BUCK3_STARTUP_TIME,
824 .owner = THIS_MODULE,
825 },
826 .init = {
827 .reg = BD718XX_REG_1ST_NODVS_BUCK_CTRL,
828 .mask = BD718XX_BUCK_SEL,
829 .val = BD718XX_BUCK_SEL,
830 },
831 },
832 {
833 .desc = {
834 .name = "buck4",
835 .of_match = of_match_ptr("BUCK4"),
836 .regulators_node = of_match_ptr("regulators"),
837 .id = BD718XX_BUCK4,
838 .type = REGULATOR_VOLTAGE,
839 .n_voltages = BD71847_BUCK4_VOLTAGE_NUM,
840 .linear_ranges = bd71847_buck4_volts,
841 .n_linear_ranges =
842 ARRAY_SIZE(bd71847_buck4_volts),
843 .enable_reg = BD718XX_REG_2ND_NODVS_BUCK_CTRL,
844 .vsel_reg = BD718XX_REG_2ND_NODVS_BUCK_VOLT,
845 .vsel_mask = BD71847_BUCK4_MASK,
846 .vsel_range_reg = BD718XX_REG_2ND_NODVS_BUCK_VOLT,
847 .vsel_range_mask = BD71847_BUCK4_RANGE_MASK,
848 .linear_range_selectors_bitfield = bd71847_buck4_volt_range_sel,
849 .enable_mask = BD718XX_BUCK_EN,
850 .enable_time = BD71847_BUCK4_STARTUP_TIME,
851 .owner = THIS_MODULE,
852 },
853 .init = {
854 .reg = BD718XX_REG_2ND_NODVS_BUCK_CTRL,
855 .mask = BD718XX_BUCK_SEL,
856 .val = BD718XX_BUCK_SEL,
857 },
858 },
859 {
860 .desc = {
861 .name = "buck5",
862 .of_match = of_match_ptr("BUCK5"),
863 .regulators_node = of_match_ptr("regulators"),
864 .id = BD718XX_BUCK5,
865 .type = REGULATOR_VOLTAGE,
866 .volt_table = &bd718xx_3rd_nodvs_buck_volts[0],
867 .n_voltages = ARRAY_SIZE(bd718xx_3rd_nodvs_buck_volts),
868 .vsel_reg = BD718XX_REG_3RD_NODVS_BUCK_VOLT,
869 .vsel_mask = BD718XX_3RD_NODVS_BUCK_MASK,
870 .enable_reg = BD718XX_REG_3RD_NODVS_BUCK_CTRL,
871 .enable_mask = BD718XX_BUCK_EN,
872 .enable_time = BD71847_BUCK5_STARTUP_TIME,
873 .owner = THIS_MODULE,
874 },
875 .init = {
876 .reg = BD718XX_REG_3RD_NODVS_BUCK_CTRL,
877 .mask = BD718XX_BUCK_SEL,
878 .val = BD718XX_BUCK_SEL,
879 },
880 },
881 {
882 .desc = {
883 .name = "buck6",
884 .of_match = of_match_ptr("BUCK6"),
885 .regulators_node = of_match_ptr("regulators"),
886 .id = BD718XX_BUCK6,
887 .type = REGULATOR_VOLTAGE,
888 .n_voltages = BD718XX_4TH_NODVS_BUCK_VOLTAGE_NUM,
889 .linear_ranges = bd718xx_4th_nodvs_buck_volts,
890 .n_linear_ranges =
891 ARRAY_SIZE(bd718xx_4th_nodvs_buck_volts),
892 .vsel_reg = BD718XX_REG_4TH_NODVS_BUCK_VOLT,
893 .vsel_mask = BD718XX_4TH_NODVS_BUCK_MASK,
894 .enable_reg = BD718XX_REG_4TH_NODVS_BUCK_CTRL,
895 .enable_mask = BD718XX_BUCK_EN,
896 .enable_time = BD71847_BUCK6_STARTUP_TIME,
897 .owner = THIS_MODULE,
898 },
899 .init = {
900 .reg = BD718XX_REG_4TH_NODVS_BUCK_CTRL,
901 .mask = BD718XX_BUCK_SEL,
902 .val = BD718XX_BUCK_SEL,
903 },
904 },
905 {
906 .desc = {
907 .name = "ldo1",
908 .of_match = of_match_ptr("LDO1"),
909 .regulators_node = of_match_ptr("regulators"),
910 .id = BD718XX_LDO1,
911 .type = REGULATOR_VOLTAGE,
912 .n_voltages = BD718XX_LDO1_VOLTAGE_NUM,
913 .linear_ranges = bd718xx_ldo1_volts,
914 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo1_volts),
915 .vsel_reg = BD718XX_REG_LDO1_VOLT,
916 .vsel_mask = BD718XX_LDO1_MASK,
917 .vsel_range_reg = BD718XX_REG_LDO1_VOLT,
918 .vsel_range_mask = BD718XX_LDO1_RANGE_MASK,
919 .linear_range_selectors_bitfield = bd718xx_ldo1_volt_range_sel,
920 .enable_reg = BD718XX_REG_LDO1_VOLT,
921 .enable_mask = BD718XX_LDO_EN,
922 .enable_time = BD71847_LDO1_STARTUP_TIME,
923 .owner = THIS_MODULE,
924 },
925 .init = {
926 .reg = BD718XX_REG_LDO1_VOLT,
927 .mask = BD718XX_LDO_SEL,
928 .val = BD718XX_LDO_SEL,
929 },
930 },
931 {
932 .desc = {
933 .name = "ldo2",
934 .of_match = of_match_ptr("LDO2"),
935 .regulators_node = of_match_ptr("regulators"),
936 .id = BD718XX_LDO2,
937 .type = REGULATOR_VOLTAGE,
938 .volt_table = &ldo_2_volts[0],
939 .vsel_reg = BD718XX_REG_LDO2_VOLT,
940 .vsel_mask = BD718XX_LDO2_MASK,
941 .n_voltages = ARRAY_SIZE(ldo_2_volts),
942 .enable_reg = BD718XX_REG_LDO2_VOLT,
943 .enable_mask = BD718XX_LDO_EN,
944 .enable_time = BD71847_LDO2_STARTUP_TIME,
945 .owner = THIS_MODULE,
946 },
947 .init = {
948 .reg = BD718XX_REG_LDO2_VOLT,
949 .mask = BD718XX_LDO_SEL,
950 .val = BD718XX_LDO_SEL,
951 },
952 },
953 {
954 .desc = {
955 .name = "ldo3",
956 .of_match = of_match_ptr("LDO3"),
957 .regulators_node = of_match_ptr("regulators"),
958 .id = BD718XX_LDO3,
959 .type = REGULATOR_VOLTAGE,
960 .n_voltages = BD718XX_LDO3_VOLTAGE_NUM,
961 .linear_ranges = bd718xx_ldo3_volts,
962 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo3_volts),
963 .vsel_reg = BD718XX_REG_LDO3_VOLT,
964 .vsel_mask = BD718XX_LDO3_MASK,
965 .enable_reg = BD718XX_REG_LDO3_VOLT,
966 .enable_mask = BD718XX_LDO_EN,
967 .enable_time = BD71847_LDO3_STARTUP_TIME,
968 .owner = THIS_MODULE,
969 },
970 .init = {
971 .reg = BD718XX_REG_LDO3_VOLT,
972 .mask = BD718XX_LDO_SEL,
973 .val = BD718XX_LDO_SEL,
974 },
975 },
976 {
977 .desc = {
978 .name = "ldo4",
979 .of_match = of_match_ptr("LDO4"),
980 .regulators_node = of_match_ptr("regulators"),
981 .id = BD718XX_LDO4,
982 .type = REGULATOR_VOLTAGE,
983 .n_voltages = BD718XX_LDO4_VOLTAGE_NUM,
984 .linear_ranges = bd718xx_ldo4_volts,
985 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo4_volts),
986 .vsel_reg = BD718XX_REG_LDO4_VOLT,
987 .vsel_mask = BD718XX_LDO4_MASK,
988 .enable_reg = BD718XX_REG_LDO4_VOLT,
989 .enable_mask = BD718XX_LDO_EN,
990 .enable_time = BD71847_LDO4_STARTUP_TIME,
991 .owner = THIS_MODULE,
992 },
993 .init = {
994 .reg = BD718XX_REG_LDO4_VOLT,
995 .mask = BD718XX_LDO_SEL,
996 .val = BD718XX_LDO_SEL,
997 },
998 },
999 {
1000 .desc = {
1001 .name = "ldo5",
1002 .of_match = of_match_ptr("LDO5"),
1003 .regulators_node = of_match_ptr("regulators"),
1004 .id = BD718XX_LDO5,
1005 .type = REGULATOR_VOLTAGE,
1006 .n_voltages = BD71847_LDO5_VOLTAGE_NUM,
1007 .linear_ranges = bd71847_ldo5_volts,
1008 .n_linear_ranges = ARRAY_SIZE(bd71847_ldo5_volts),
1009 .vsel_reg = BD718XX_REG_LDO5_VOLT,
1010 .vsel_mask = BD71847_LDO5_MASK,
1011 .vsel_range_reg = BD718XX_REG_LDO5_VOLT,
1012 .vsel_range_mask = BD71847_LDO5_RANGE_MASK,
1013 .linear_range_selectors_bitfield = bd71847_ldo5_volt_range_sel,
1014 .enable_reg = BD718XX_REG_LDO5_VOLT,
1015 .enable_mask = BD718XX_LDO_EN,
1016 .enable_time = BD71847_LDO5_STARTUP_TIME,
1017 .owner = THIS_MODULE,
1018 },
1019 .init = {
1020 .reg = BD718XX_REG_LDO5_VOLT,
1021 .mask = BD718XX_LDO_SEL,
1022 .val = BD718XX_LDO_SEL,
1023 },
1024 },
1025 {
1026 .desc = {
1027 .name = "ldo6",
1028 .of_match = of_match_ptr("LDO6"),
1029 .regulators_node = of_match_ptr("regulators"),
1030 .id = BD718XX_LDO6,
1031 .type = REGULATOR_VOLTAGE,
1032 .n_voltages = BD718XX_LDO6_VOLTAGE_NUM,
1033 .linear_ranges = bd718xx_ldo6_volts,
1034 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo6_volts),
1035 /* LDO6 is supplied by buck5 */
1036 .supply_name = "buck5",
1037 .vsel_reg = BD718XX_REG_LDO6_VOLT,
1038 .vsel_mask = BD718XX_LDO6_MASK,
1039 .enable_reg = BD718XX_REG_LDO6_VOLT,
1040 .enable_mask = BD718XX_LDO_EN,
1041 .enable_time = BD71847_LDO6_STARTUP_TIME,
1042 .owner = THIS_MODULE,
1043 },
1044 .init = {
1045 .reg = BD718XX_REG_LDO6_VOLT,
1046 .mask = BD718XX_LDO_SEL,
1047 .val = BD718XX_LDO_SEL,
1048 },
1049 },
1050};
1051
1052static const struct regulator_ops *bd71837_swcontrol_ops[] = {
1053 &bd718xx_dvs_buck_regulator_ops, &bd718xx_dvs_buck_regulator_ops,
1054 &bd718xx_dvs_buck_regulator_ops, &bd718xx_dvs_buck_regulator_ops,
1055 &bd71837_pickable_range_buck_ops, &bd71837_buck_regulator_ops,
1056 &bd71837_buck_regulator_nolinear_ops, &bd71837_buck_regulator_ops,
1057 &bd71837_pickable_range_ldo_ops, &bd71837_ldo_regulator_nolinear_ops,
1058 &bd71837_ldo_regulator_ops, &bd71837_ldo_regulator_ops,
1059 &bd71837_ldo_regulator_ops, &bd71837_ldo_regulator_ops,
1060 &bd71837_ldo_regulator_ops,
1061};
1062
1063static const struct regulator_ops *bd71837_hwcontrol_ops[] = {
1064 &BD718XX_HWOPNAME(bd718xx_dvs_buck_regulator_ops),
1065 &BD718XX_HWOPNAME(bd718xx_dvs_buck_regulator_ops),
1066 &bd71837_buck34_ops_hwctrl, &bd71837_buck34_ops_hwctrl,
1067 &BD718XX_HWOPNAME(bd71837_pickable_range_buck_ops),
1068 &BD718XX_HWOPNAME(bd71837_buck_regulator_ops),
1069 &BD718XX_HWOPNAME(bd71837_buck_regulator_nolinear_ops),
1070 &BD718XX_HWOPNAME(bd71837_buck_regulator_ops),
1071 &BD718XX_HWOPNAME(bd71837_pickable_range_ldo_ops),
1072 &BD718XX_HWOPNAME(bd71837_ldo_regulator_nolinear_ops),
1073 &BD718XX_HWOPNAME(bd71837_ldo_regulator_ops),
1074 &BD718XX_HWOPNAME(bd71837_ldo_regulator_ops),
1075 &BD718XX_HWOPNAME(bd71837_ldo_regulator_ops),
1076 &BD718XX_HWOPNAME(bd71837_ldo_regulator_ops),
1077 &BD718XX_HWOPNAME(bd71837_ldo_regulator_ops),
1078};
1079
1080static struct bd718xx_regulator_data bd71837_regulators[] = {
1081 {
1082 .desc = {
1083 .name = "buck1",
1084 .of_match = of_match_ptr("BUCK1"),
1085 .regulators_node = of_match_ptr("regulators"),
1086 .id = BD718XX_BUCK1,
1087 .type = REGULATOR_VOLTAGE,
1088 .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
1089 .linear_ranges = bd718xx_dvs_buck_volts,
1090 .n_linear_ranges = ARRAY_SIZE(bd718xx_dvs_buck_volts),
1091 .vsel_reg = BD718XX_REG_BUCK1_VOLT_RUN,
1092 .vsel_mask = DVS_BUCK_RUN_MASK,
1093 .enable_reg = BD718XX_REG_BUCK1_CTRL,
1094 .enable_mask = BD718XX_BUCK_EN,
1095 .enable_time = BD71837_BUCK1_STARTUP_TIME,
1096 .ramp_delay_table = bd718xx_ramp_delay,
1097 .n_ramp_values = ARRAY_SIZE(bd718xx_ramp_delay),
1098 .ramp_reg = BD718XX_REG_BUCK1_CTRL,
1099 .ramp_mask = BUCK_RAMPRATE_MASK,
1100 .owner = THIS_MODULE,
1101 .of_parse_cb = buck_set_hw_dvs_levels,
1102 },
1103 .dvs = {
1104 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
1105 ROHM_DVS_LEVEL_SUSPEND,
1106 .run_reg = BD718XX_REG_BUCK1_VOLT_RUN,
1107 .run_mask = DVS_BUCK_RUN_MASK,
1108 .idle_reg = BD718XX_REG_BUCK1_VOLT_IDLE,
1109 .idle_mask = DVS_BUCK_RUN_MASK,
1110 .suspend_reg = BD718XX_REG_BUCK1_VOLT_SUSP,
1111 .suspend_mask = DVS_BUCK_RUN_MASK,
1112 },
1113 .init = {
1114 .reg = BD718XX_REG_BUCK1_CTRL,
1115 .mask = BD718XX_BUCK_SEL,
1116 .val = BD718XX_BUCK_SEL,
1117 },
1118 },
1119 {
1120 .desc = {
1121 .name = "buck2",
1122 .of_match = of_match_ptr("BUCK2"),
1123 .regulators_node = of_match_ptr("regulators"),
1124 .id = BD718XX_BUCK2,
1125 .type = REGULATOR_VOLTAGE,
1126 .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
1127 .linear_ranges = bd718xx_dvs_buck_volts,
1128 .n_linear_ranges = ARRAY_SIZE(bd718xx_dvs_buck_volts),
1129 .vsel_reg = BD718XX_REG_BUCK2_VOLT_RUN,
1130 .vsel_mask = DVS_BUCK_RUN_MASK,
1131 .enable_reg = BD718XX_REG_BUCK2_CTRL,
1132 .enable_mask = BD718XX_BUCK_EN,
1133 .enable_time = BD71837_BUCK2_STARTUP_TIME,
1134 .ramp_delay_table = bd718xx_ramp_delay,
1135 .n_ramp_values = ARRAY_SIZE(bd718xx_ramp_delay),
1136 .ramp_reg = BD718XX_REG_BUCK2_CTRL,
1137 .ramp_mask = BUCK_RAMPRATE_MASK,
1138 .owner = THIS_MODULE,
1139 .of_parse_cb = buck_set_hw_dvs_levels,
1140 },
1141 .dvs = {
1142 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE,
1143 .run_reg = BD718XX_REG_BUCK2_VOLT_RUN,
1144 .run_mask = DVS_BUCK_RUN_MASK,
1145 .idle_reg = BD718XX_REG_BUCK2_VOLT_IDLE,
1146 .idle_mask = DVS_BUCK_RUN_MASK,
1147 },
1148 .init = {
1149 .reg = BD718XX_REG_BUCK2_CTRL,
1150 .mask = BD718XX_BUCK_SEL,
1151 .val = BD718XX_BUCK_SEL,
1152 },
1153 },
1154 {
1155 .desc = {
1156 .name = "buck3",
1157 .of_match = of_match_ptr("BUCK3"),
1158 .regulators_node = of_match_ptr("regulators"),
1159 .id = BD718XX_BUCK3,
1160 .type = REGULATOR_VOLTAGE,
1161 .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
1162 .linear_ranges = bd718xx_dvs_buck_volts,
1163 .n_linear_ranges = ARRAY_SIZE(bd718xx_dvs_buck_volts),
1164 .vsel_reg = BD71837_REG_BUCK3_VOLT_RUN,
1165 .vsel_mask = DVS_BUCK_RUN_MASK,
1166 .enable_reg = BD71837_REG_BUCK3_CTRL,
1167 .enable_mask = BD718XX_BUCK_EN,
1168 .enable_time = BD71837_BUCK3_STARTUP_TIME,
1169 .ramp_delay_table = bd718xx_ramp_delay,
1170 .n_ramp_values = ARRAY_SIZE(bd718xx_ramp_delay),
1171 .ramp_reg = BD71837_REG_BUCK3_CTRL,
1172 .ramp_mask = BUCK_RAMPRATE_MASK,
1173 .owner = THIS_MODULE,
1174 .of_parse_cb = buck_set_hw_dvs_levels,
1175 },
1176 .dvs = {
1177 .level_map = ROHM_DVS_LEVEL_RUN,
1178 .run_reg = BD71837_REG_BUCK3_VOLT_RUN,
1179 .run_mask = DVS_BUCK_RUN_MASK,
1180 },
1181 .init = {
1182 .reg = BD71837_REG_BUCK3_CTRL,
1183 .mask = BD718XX_BUCK_SEL,
1184 .val = BD718XX_BUCK_SEL,
1185 },
1186 },
1187 {
1188 .desc = {
1189 .name = "buck4",
1190 .of_match = of_match_ptr("BUCK4"),
1191 .regulators_node = of_match_ptr("regulators"),
1192 .id = BD718XX_BUCK4,
1193 .type = REGULATOR_VOLTAGE,
1194 .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
1195 .linear_ranges = bd718xx_dvs_buck_volts,
1196 .n_linear_ranges = ARRAY_SIZE(bd718xx_dvs_buck_volts),
1197 .vsel_reg = BD71837_REG_BUCK4_VOLT_RUN,
1198 .vsel_mask = DVS_BUCK_RUN_MASK,
1199 .enable_reg = BD71837_REG_BUCK4_CTRL,
1200 .enable_mask = BD718XX_BUCK_EN,
1201 .enable_time = BD71837_BUCK4_STARTUP_TIME,
1202 .ramp_delay_table = bd718xx_ramp_delay,
1203 .n_ramp_values = ARRAY_SIZE(bd718xx_ramp_delay),
1204 .ramp_reg = BD71837_REG_BUCK4_CTRL,
1205 .ramp_mask = BUCK_RAMPRATE_MASK,
1206 .owner = THIS_MODULE,
1207 .of_parse_cb = buck_set_hw_dvs_levels,
1208 },
1209 .dvs = {
1210 .level_map = ROHM_DVS_LEVEL_RUN,
1211 .run_reg = BD71837_REG_BUCK4_VOLT_RUN,
1212 .run_mask = DVS_BUCK_RUN_MASK,
1213 },
1214 .init = {
1215 .reg = BD71837_REG_BUCK4_CTRL,
1216 .mask = BD718XX_BUCK_SEL,
1217 .val = BD718XX_BUCK_SEL,
1218 },
1219 },
1220 {
1221 .desc = {
1222 .name = "buck5",
1223 .of_match = of_match_ptr("BUCK5"),
1224 .regulators_node = of_match_ptr("regulators"),
1225 .id = BD718XX_BUCK5,
1226 .type = REGULATOR_VOLTAGE,
1227 .n_voltages = BD71837_BUCK5_VOLTAGE_NUM,
1228 .linear_ranges = bd71837_buck5_volts,
1229 .n_linear_ranges =
1230 ARRAY_SIZE(bd71837_buck5_volts),
1231 .vsel_reg = BD718XX_REG_1ST_NODVS_BUCK_VOLT,
1232 .vsel_mask = BD71837_BUCK5_MASK,
1233 .vsel_range_reg = BD718XX_REG_1ST_NODVS_BUCK_VOLT,
1234 .vsel_range_mask = BD71837_BUCK5_RANGE_MASK,
1235 .linear_range_selectors_bitfield = bd71837_buck5_volt_range_sel,
1236 .enable_reg = BD718XX_REG_1ST_NODVS_BUCK_CTRL,
1237 .enable_mask = BD718XX_BUCK_EN,
1238 .enable_time = BD71837_BUCK5_STARTUP_TIME,
1239 .owner = THIS_MODULE,
1240 },
1241 .init = {
1242 .reg = BD718XX_REG_1ST_NODVS_BUCK_CTRL,
1243 .mask = BD718XX_BUCK_SEL,
1244 .val = BD718XX_BUCK_SEL,
1245 },
1246 },
1247 {
1248 .desc = {
1249 .name = "buck6",
1250 .of_match = of_match_ptr("BUCK6"),
1251 .regulators_node = of_match_ptr("regulators"),
1252 .id = BD718XX_BUCK6,
1253 .type = REGULATOR_VOLTAGE,
1254 .n_voltages = BD71837_BUCK6_VOLTAGE_NUM,
1255 .linear_ranges = bd71837_buck6_volts,
1256 .n_linear_ranges =
1257 ARRAY_SIZE(bd71837_buck6_volts),
1258 .vsel_reg = BD718XX_REG_2ND_NODVS_BUCK_VOLT,
1259 .vsel_mask = BD71837_BUCK6_MASK,
1260 .enable_reg = BD718XX_REG_2ND_NODVS_BUCK_CTRL,
1261 .enable_mask = BD718XX_BUCK_EN,
1262 .enable_time = BD71837_BUCK6_STARTUP_TIME,
1263 .owner = THIS_MODULE,
1264 },
1265 .init = {
1266 .reg = BD718XX_REG_2ND_NODVS_BUCK_CTRL,
1267 .mask = BD718XX_BUCK_SEL,
1268 .val = BD718XX_BUCK_SEL,
1269 },
1270 },
1271 {
1272 .desc = {
1273 .name = "buck7",
1274 .of_match = of_match_ptr("BUCK7"),
1275 .regulators_node = of_match_ptr("regulators"),
1276 .id = BD718XX_BUCK7,
1277 .type = REGULATOR_VOLTAGE,
1278 .volt_table = &bd718xx_3rd_nodvs_buck_volts[0],
1279 .n_voltages = ARRAY_SIZE(bd718xx_3rd_nodvs_buck_volts),
1280 .vsel_reg = BD718XX_REG_3RD_NODVS_BUCK_VOLT,
1281 .vsel_mask = BD718XX_3RD_NODVS_BUCK_MASK,
1282 .enable_reg = BD718XX_REG_3RD_NODVS_BUCK_CTRL,
1283 .enable_mask = BD718XX_BUCK_EN,
1284 .enable_time = BD71837_BUCK7_STARTUP_TIME,
1285 .owner = THIS_MODULE,
1286 },
1287 .init = {
1288 .reg = BD718XX_REG_3RD_NODVS_BUCK_CTRL,
1289 .mask = BD718XX_BUCK_SEL,
1290 .val = BD718XX_BUCK_SEL,
1291 },
1292 },
1293 {
1294 .desc = {
1295 .name = "buck8",
1296 .of_match = of_match_ptr("BUCK8"),
1297 .regulators_node = of_match_ptr("regulators"),
1298 .id = BD718XX_BUCK8,
1299 .type = REGULATOR_VOLTAGE,
1300 .n_voltages = BD718XX_4TH_NODVS_BUCK_VOLTAGE_NUM,
1301 .linear_ranges = bd718xx_4th_nodvs_buck_volts,
1302 .n_linear_ranges =
1303 ARRAY_SIZE(bd718xx_4th_nodvs_buck_volts),
1304 .vsel_reg = BD718XX_REG_4TH_NODVS_BUCK_VOLT,
1305 .vsel_mask = BD718XX_4TH_NODVS_BUCK_MASK,
1306 .enable_reg = BD718XX_REG_4TH_NODVS_BUCK_CTRL,
1307 .enable_mask = BD718XX_BUCK_EN,
1308 .enable_time = BD71837_BUCK8_STARTUP_TIME,
1309 .owner = THIS_MODULE,
1310 },
1311 .init = {
1312 .reg = BD718XX_REG_4TH_NODVS_BUCK_CTRL,
1313 .mask = BD718XX_BUCK_SEL,
1314 .val = BD718XX_BUCK_SEL,
1315 },
1316 },
1317 {
1318 .desc = {
1319 .name = "ldo1",
1320 .of_match = of_match_ptr("LDO1"),
1321 .regulators_node = of_match_ptr("regulators"),
1322 .id = BD718XX_LDO1,
1323 .type = REGULATOR_VOLTAGE,
1324 .n_voltages = BD718XX_LDO1_VOLTAGE_NUM,
1325 .linear_ranges = bd718xx_ldo1_volts,
1326 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo1_volts),
1327 .vsel_reg = BD718XX_REG_LDO1_VOLT,
1328 .vsel_mask = BD718XX_LDO1_MASK,
1329 .vsel_range_reg = BD718XX_REG_LDO1_VOLT,
1330 .vsel_range_mask = BD718XX_LDO1_RANGE_MASK,
1331 .linear_range_selectors_bitfield = bd718xx_ldo1_volt_range_sel,
1332 .enable_reg = BD718XX_REG_LDO1_VOLT,
1333 .enable_mask = BD718XX_LDO_EN,
1334 .enable_time = BD71837_LDO1_STARTUP_TIME,
1335 .owner = THIS_MODULE,
1336 },
1337 .init = {
1338 .reg = BD718XX_REG_LDO1_VOLT,
1339 .mask = BD718XX_LDO_SEL,
1340 .val = BD718XX_LDO_SEL,
1341 },
1342 },
1343 {
1344 .desc = {
1345 .name = "ldo2",
1346 .of_match = of_match_ptr("LDO2"),
1347 .regulators_node = of_match_ptr("regulators"),
1348 .id = BD718XX_LDO2,
1349 .type = REGULATOR_VOLTAGE,
1350 .volt_table = &ldo_2_volts[0],
1351 .vsel_reg = BD718XX_REG_LDO2_VOLT,
1352 .vsel_mask = BD718XX_LDO2_MASK,
1353 .n_voltages = ARRAY_SIZE(ldo_2_volts),
1354 .enable_reg = BD718XX_REG_LDO2_VOLT,
1355 .enable_mask = BD718XX_LDO_EN,
1356 .enable_time = BD71837_LDO2_STARTUP_TIME,
1357 .owner = THIS_MODULE,
1358 },
1359 .init = {
1360 .reg = BD718XX_REG_LDO2_VOLT,
1361 .mask = BD718XX_LDO_SEL,
1362 .val = BD718XX_LDO_SEL,
1363 },
1364 },
1365 {
1366 .desc = {
1367 .name = "ldo3",
1368 .of_match = of_match_ptr("LDO3"),
1369 .regulators_node = of_match_ptr("regulators"),
1370 .id = BD718XX_LDO3,
1371 .type = REGULATOR_VOLTAGE,
1372 .n_voltages = BD718XX_LDO3_VOLTAGE_NUM,
1373 .linear_ranges = bd718xx_ldo3_volts,
1374 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo3_volts),
1375 .vsel_reg = BD718XX_REG_LDO3_VOLT,
1376 .vsel_mask = BD718XX_LDO3_MASK,
1377 .enable_reg = BD718XX_REG_LDO3_VOLT,
1378 .enable_mask = BD718XX_LDO_EN,
1379 .enable_time = BD71837_LDO3_STARTUP_TIME,
1380 .owner = THIS_MODULE,
1381 },
1382 .init = {
1383 .reg = BD718XX_REG_LDO3_VOLT,
1384 .mask = BD718XX_LDO_SEL,
1385 .val = BD718XX_LDO_SEL,
1386 },
1387 },
1388 {
1389 .desc = {
1390 .name = "ldo4",
1391 .of_match = of_match_ptr("LDO4"),
1392 .regulators_node = of_match_ptr("regulators"),
1393 .id = BD718XX_LDO4,
1394 .type = REGULATOR_VOLTAGE,
1395 .n_voltages = BD718XX_LDO4_VOLTAGE_NUM,
1396 .linear_ranges = bd718xx_ldo4_volts,
1397 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo4_volts),
1398 .vsel_reg = BD718XX_REG_LDO4_VOLT,
1399 .vsel_mask = BD718XX_LDO4_MASK,
1400 .enable_reg = BD718XX_REG_LDO4_VOLT,
1401 .enable_mask = BD718XX_LDO_EN,
1402 .enable_time = BD71837_LDO4_STARTUP_TIME,
1403 .owner = THIS_MODULE,
1404 },
1405 .init = {
1406 .reg = BD718XX_REG_LDO4_VOLT,
1407 .mask = BD718XX_LDO_SEL,
1408 .val = BD718XX_LDO_SEL,
1409 },
1410 },
1411 {
1412 .desc = {
1413 .name = "ldo5",
1414 .of_match = of_match_ptr("LDO5"),
1415 .regulators_node = of_match_ptr("regulators"),
1416 .id = BD718XX_LDO5,
1417 .type = REGULATOR_VOLTAGE,
1418 .n_voltages = BD71837_LDO5_VOLTAGE_NUM,
1419 .linear_ranges = bd71837_ldo5_volts,
1420 .n_linear_ranges = ARRAY_SIZE(bd71837_ldo5_volts),
1421 /* LDO5 is supplied by buck6 */
1422 .supply_name = "buck6",
1423 .vsel_reg = BD718XX_REG_LDO5_VOLT,
1424 .vsel_mask = BD71837_LDO5_MASK,
1425 .enable_reg = BD718XX_REG_LDO5_VOLT,
1426 .enable_mask = BD718XX_LDO_EN,
1427 .enable_time = BD71837_LDO5_STARTUP_TIME,
1428 .owner = THIS_MODULE,
1429 },
1430 .init = {
1431 .reg = BD718XX_REG_LDO5_VOLT,
1432 .mask = BD718XX_LDO_SEL,
1433 .val = BD718XX_LDO_SEL,
1434 },
1435 .additional_inits = bd71837_ldo5_inits,
1436 .additional_init_amnt = ARRAY_SIZE(bd71837_ldo5_inits),
1437 },
1438 {
1439 .desc = {
1440 .name = "ldo6",
1441 .of_match = of_match_ptr("LDO6"),
1442 .regulators_node = of_match_ptr("regulators"),
1443 .id = BD718XX_LDO6,
1444 .type = REGULATOR_VOLTAGE,
1445 .n_voltages = BD718XX_LDO6_VOLTAGE_NUM,
1446 .linear_ranges = bd718xx_ldo6_volts,
1447 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo6_volts),
1448 /* LDO6 is supplied by buck7 */
1449 .supply_name = "buck7",
1450 .vsel_reg = BD718XX_REG_LDO6_VOLT,
1451 .vsel_mask = BD718XX_LDO6_MASK,
1452 .enable_reg = BD718XX_REG_LDO6_VOLT,
1453 .enable_mask = BD718XX_LDO_EN,
1454 .enable_time = BD71837_LDO6_STARTUP_TIME,
1455 .owner = THIS_MODULE,
1456 },
1457 .init = {
1458 .reg = BD718XX_REG_LDO6_VOLT,
1459 .mask = BD718XX_LDO_SEL,
1460 .val = BD718XX_LDO_SEL,
1461 },
1462 .additional_inits = bd71837_ldo6_inits,
1463 .additional_init_amnt = ARRAY_SIZE(bd71837_ldo6_inits),
1464 },
1465 {
1466 .desc = {
1467 .name = "ldo7",
1468 .of_match = of_match_ptr("LDO7"),
1469 .regulators_node = of_match_ptr("regulators"),
1470 .id = BD718XX_LDO7,
1471 .type = REGULATOR_VOLTAGE,
1472 .n_voltages = BD71837_LDO7_VOLTAGE_NUM,
1473 .linear_ranges = bd71837_ldo7_volts,
1474 .n_linear_ranges = ARRAY_SIZE(bd71837_ldo7_volts),
1475 .vsel_reg = BD71837_REG_LDO7_VOLT,
1476 .vsel_mask = BD71837_LDO7_MASK,
1477 .enable_reg = BD71837_REG_LDO7_VOLT,
1478 .enable_mask = BD718XX_LDO_EN,
1479 .enable_time = BD71837_LDO7_STARTUP_TIME,
1480 .owner = THIS_MODULE,
1481 },
1482 .init = {
1483 .reg = BD71837_REG_LDO7_VOLT,
1484 .mask = BD718XX_LDO_SEL,
1485 .val = BD718XX_LDO_SEL,
1486 },
1487 },
1488};
1489
1490static void mark_hw_controlled(struct device *dev, struct device_node *np,
1491 struct bd718xx_regulator_data *reg_data,
1492 unsigned int num_reg_data, int *info)
1493{
1494 int i;
1495
1496 for (i = 1; i <= num_reg_data; i++) {
1497 if (!of_node_name_eq(np, reg_data[i-1].desc.of_match))
1498 continue;
1499
1500 *info |= 1 << (i - 1);
1501 dev_dbg(dev, "regulator %d runlevel controlled\n", i);
1502 return;
1503 }
1504 dev_warn(dev, "Bad regulator node\n");
1505}
1506
1507/*
1508 * Setups where regulator (especially the buck8) output voltage is scaled
1509 * by adding external connection where some other regulator output is connected
1510 * to feedback-pin (over suitable resistors) is getting popular amongst users
1511 * of BD71837. (This allows for example scaling down the buck8 voltages to suit
1512 * lover GPU voltages for projects where buck8 is (ab)used to supply power
1513 * for GPU. Additionally some setups do allow DVS for buck8 but as this do
1514 * produce voltage spikes the HW must be evaluated to be able to survive this
1515 * - hence I keep the DVS disabled for non DVS bucks by default. I don't want
1516 * to help you burn your proto board)
1517 *
1518 * So we allow describing this external connection from DT and scale the
1519 * voltages accordingly. This is what the connection should look like:
1520 *
1521 * |------------|
1522 * | buck 8 |-------+----->Vout
1523 * | | |
1524 * |------------| |
1525 * | FB pin |
1526 * | |
1527 * +-------+--R2---+
1528 * |
1529 * R1
1530 * |
1531 * V FB-pull-up
1532 *
1533 * Here the buck output is sifted according to formula:
1534 *
1535 * Vout_o = Vo - (Vpu - Vo)*R2/R1
1536 * Linear_step = step_orig*(R1+R2)/R1
1537 *
1538 * where:
1539 * Vout_o is adjusted voltage output at vsel reg value 0
1540 * Vo is original voltage output at vsel reg value 0
1541 * Vpu is the pull-up voltage V FB-pull-up in the picture
1542 * R1 and R2 are resistor values.
1543 *
1544 * As a real world example for buck8 and a specific GPU:
1545 * VLDO = 1.6V (used as FB-pull-up)
1546 * R1 = 1000ohms
1547 * R2 = 150ohms
1548 * VSEL 0x0 => 0.8V – (VLDO – 0.8) * R2 / R1 = 0.68V
1549 * Linear Step = 10mV * (R1 + R2) / R1 = 11.5mV
1550 */
1551static int setup_feedback_loop(struct device *dev, struct device_node *np,
1552 struct bd718xx_regulator_data *reg_data,
1553 unsigned int num_reg_data, int fb_uv)
1554{
1555 int i, r1, r2, ret;
1556
1557 /*
1558 * We do adjust the values in the global desc based on DT settings.
1559 * This may not be best approach as it can cause problems if more than
1560 * one PMIC is controlled from same processor. I don't see such use-case
1561 * for BD718x7 now - so we spare some bits.
1562 *
1563 * If this will point out to be a problem - then we can allocate new
1564 * bd718xx_regulator_data array at probe and just use the global
1565 * array as a template where we copy initial values. Then we can
1566 * use allocated descs for regultor registration and do IC specific
1567 * modifications to this copy while leaving other PMICs untouched. But
1568 * that means allocating new array for each PMIC - and currently I see
1569 * no need for that.
1570 */
1571
1572 for (i = 0; i < num_reg_data; i++) {
1573 struct regulator_desc *desc = ®_data[i].desc;
1574 int j;
1575
1576 if (!of_node_name_eq(np, desc->of_match))
1577 continue;
1578
1579 /* The feedback loop connection does not make sense for LDOs */
1580 if (desc->id >= BD718XX_LDO1)
1581 return -EINVAL;
1582
1583 ret = of_property_read_u32(np, "rohm,feedback-pull-up-r1-ohms",
1584 &r1);
1585 if (ret)
1586 return ret;
1587
1588 if (!r1)
1589 return -EINVAL;
1590
1591 ret = of_property_read_u32(np, "rohm,feedback-pull-up-r2-ohms",
1592 &r2);
1593 if (ret)
1594 return ret;
1595
1596 if (desc->n_linear_ranges && desc->linear_ranges) {
1597 struct linear_range *new;
1598
1599 new = devm_kzalloc(dev, desc->n_linear_ranges *
1600 sizeof(struct linear_range),
1601 GFP_KERNEL);
1602 if (!new)
1603 return -ENOMEM;
1604
1605 for (j = 0; j < desc->n_linear_ranges; j++) {
1606 int min = desc->linear_ranges[j].min;
1607 int step = desc->linear_ranges[j].step;
1608
1609 min -= (fb_uv - min)*r2/r1;
1610 step = step * (r1 + r2);
1611 step /= r1;
1612
1613 new[j].min = min;
1614 new[j].step = step;
1615
1616 dev_dbg(dev, "%s: old range min %d, step %d\n",
1617 desc->name, desc->linear_ranges[j].min,
1618 desc->linear_ranges[j].step);
1619 dev_dbg(dev, "new range min %d, step %d\n", min,
1620 step);
1621 }
1622 desc->linear_ranges = new;
1623 }
1624 dev_dbg(dev, "regulator '%s' has FB pull-up configured\n",
1625 desc->name);
1626
1627 return 0;
1628 }
1629
1630 return -ENODEV;
1631}
1632
1633static int get_special_regulators(struct device *dev,
1634 struct bd718xx_regulator_data *reg_data,
1635 unsigned int num_reg_data, int *info)
1636{
1637 int ret;
1638 struct device_node *np;
1639 struct device_node *nproot = dev->of_node;
1640 int uv;
1641
1642 *info = 0;
1643
1644 nproot = of_get_child_by_name(nproot, "regulators");
1645 if (!nproot) {
1646 dev_err(dev, "failed to find regulators node\n");
1647 return -ENODEV;
1648 }
1649 for_each_child_of_node(nproot, np) {
1650 if (of_property_read_bool(np, "rohm,no-regulator-enable-control"))
1651 mark_hw_controlled(dev, np, reg_data, num_reg_data,
1652 info);
1653 ret = of_property_read_u32(np, "rohm,fb-pull-up-microvolt",
1654 &uv);
1655 if (ret) {
1656 if (ret == -EINVAL)
1657 continue;
1658 else
1659 goto err_out;
1660 }
1661
1662 ret = setup_feedback_loop(dev, np, reg_data, num_reg_data, uv);
1663 if (ret)
1664 goto err_out;
1665 }
1666
1667 of_node_put(nproot);
1668 return 0;
1669
1670err_out:
1671 of_node_put(np);
1672 of_node_put(nproot);
1673
1674 return ret;
1675}
1676
1677static int bd718xx_probe(struct platform_device *pdev)
1678{
1679 struct regmap *regmap;
1680 struct regulator_config config = { 0 };
1681 int i, j, err, omit_enable;
1682 bool use_snvs;
1683 struct bd718xx_regulator_data *reg_data;
1684 unsigned int num_reg_data;
1685 enum rohm_chip_type chip = platform_get_device_id(pdev)->driver_data;
1686 const struct regulator_ops **swops, **hwops;
1687
1688 regmap = dev_get_regmap(pdev->dev.parent, NULL);
1689 if (!regmap) {
1690 dev_err(&pdev->dev, "No MFD driver data\n");
1691 return -EINVAL;
1692 }
1693
1694 switch (chip) {
1695 case ROHM_CHIP_TYPE_BD71837:
1696 reg_data = bd71837_regulators;
1697 num_reg_data = ARRAY_SIZE(bd71837_regulators);
1698 swops = &bd71837_swcontrol_ops[0];
1699 hwops = &bd71837_hwcontrol_ops[0];
1700 break;
1701 case ROHM_CHIP_TYPE_BD71847:
1702 reg_data = bd71847_regulators;
1703 num_reg_data = ARRAY_SIZE(bd71847_regulators);
1704 swops = &bd71847_swcontrol_ops[0];
1705 hwops = &bd71847_hwcontrol_ops[0];
1706 break;
1707 default:
1708 dev_err(&pdev->dev, "Unsupported chip type\n");
1709 return -EINVAL;
1710 }
1711
1712 /* Register LOCK release */
1713 err = regmap_update_bits(regmap, BD718XX_REG_REGLOCK,
1714 (REGLOCK_PWRSEQ | REGLOCK_VREG), 0);
1715 if (err)
1716 return dev_err_probe(&pdev->dev, err, "Failed to unlock PMIC\n");
1717
1718 dev_dbg(&pdev->dev, "Unlocked lock register 0x%x\n",
1719 BD718XX_REG_REGLOCK);
1720
1721 use_snvs = of_property_read_bool(pdev->dev.parent->of_node,
1722 "rohm,reset-snvs-powered");
1723
1724 /*
1725 * Change the next stage from poweroff to be READY instead of SNVS
1726 * for all reset types because OTP loading at READY will clear SEL
1727 * bit allowing HW defaults for power rails to be used
1728 */
1729 if (!use_snvs) {
1730 err = regmap_update_bits(regmap, BD718XX_REG_TRANS_COND1,
1731 BD718XX_ON_REQ_POWEROFF_MASK |
1732 BD718XX_SWRESET_POWEROFF_MASK |
1733 BD718XX_WDOG_POWEROFF_MASK |
1734 BD718XX_KEY_L_POWEROFF_MASK,
1735 BD718XX_POWOFF_TO_RDY);
1736 if (err)
1737 return dev_err_probe(&pdev->dev, err,
1738 "Failed to change reset target\n");
1739
1740 dev_dbg(&pdev->dev, "Changed all resets from SVNS to READY\n");
1741 }
1742
1743 config.dev = pdev->dev.parent;
1744 config.regmap = regmap;
1745 /*
1746 * There are cases when we want to leave the enable-control for
1747 * the HW state machine and use this driver only for voltage control.
1748 * One special case is when we use PMIC_STBY_REQ line from SoC to PMIC
1749 * in order to set the system to SUSPEND state.
1750 *
1751 * If regulator is taken under SW control the regulator state will not
1752 * be affected by PMIC state machine - Eg. regulator is likely to stay
1753 * on even in SUSPEND
1754 */
1755 err = get_special_regulators(pdev->dev.parent, reg_data, num_reg_data,
1756 &omit_enable);
1757 if (err)
1758 return err;
1759
1760 for (i = 0; i < num_reg_data; i++) {
1761
1762 struct regulator_desc *desc;
1763 struct regulator_dev *rdev;
1764 struct bd718xx_regulator_data *r;
1765 int no_enable_control = omit_enable & (1 << i);
1766
1767 r = ®_data[i];
1768 desc = &r->desc;
1769
1770 if (no_enable_control)
1771 desc->ops = hwops[i];
1772 else
1773 desc->ops = swops[i];
1774
1775 rdev = devm_regulator_register(&pdev->dev, desc, &config);
1776 if (IS_ERR(rdev))
1777 return dev_err_probe(&pdev->dev, PTR_ERR(rdev),
1778 "failed to register %s regulator\n",
1779 desc->name);
1780
1781 /*
1782 * Regulator register gets the regulator constraints and
1783 * applies them (set_machine_constraints). This should have
1784 * turned the control register(s) to correct values and we
1785 * can now switch the control from PMIC state machine to the
1786 * register interface
1787 *
1788 * At poweroff transition PMIC HW disables EN bit for
1789 * regulators but leaves SEL bit untouched. So if state
1790 * transition from POWEROFF is done to SNVS - then all power
1791 * rails controlled by SW (having SEL bit set) stay disabled
1792 * as EN is cleared. This will result boot failure if any
1793 * crucial systems are powered by these rails. We don't
1794 * enable SW control for crucial regulators if snvs state is
1795 * used
1796 */
1797 if (!no_enable_control && (!use_snvs ||
1798 !rdev->constraints->always_on ||
1799 !rdev->constraints->boot_on)) {
1800 err = regmap_update_bits(regmap, r->init.reg,
1801 r->init.mask, r->init.val);
1802 if (err)
1803 return dev_err_probe(&pdev->dev, err,
1804 "Failed to take control for (%s)\n",
1805 desc->name);
1806 }
1807 for (j = 0; j < r->additional_init_amnt; j++) {
1808 err = regmap_update_bits(regmap,
1809 r->additional_inits[j].reg,
1810 r->additional_inits[j].mask,
1811 r->additional_inits[j].val);
1812 if (err)
1813 return dev_err_probe(&pdev->dev, err,
1814 "Buck (%s) initialization failed\n",
1815 desc->name);
1816 }
1817 }
1818
1819 return err;
1820}
1821
1822static const struct platform_device_id bd718x7_pmic_id[] = {
1823 { "bd71837-pmic", ROHM_CHIP_TYPE_BD71837 },
1824 { "bd71847-pmic", ROHM_CHIP_TYPE_BD71847 },
1825 { },
1826};
1827MODULE_DEVICE_TABLE(platform, bd718x7_pmic_id);
1828
1829static struct platform_driver bd718xx_regulator = {
1830 .driver = {
1831 .name = "bd718xx-pmic",
1832 .probe_type = PROBE_PREFER_ASYNCHRONOUS,
1833 },
1834 .probe = bd718xx_probe,
1835 .id_table = bd718x7_pmic_id,
1836};
1837
1838module_platform_driver(bd718xx_regulator);
1839
1840MODULE_AUTHOR("Matti Vaittinen <matti.vaittinen@fi.rohmeurope.com>");
1841MODULE_DESCRIPTION("BD71837/BD71847 voltage regulator driver");
1842MODULE_LICENSE("GPL");
1843MODULE_ALIAS("platform:bd718xx-pmic");