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

source code of linux/drivers/regulator/bd718x7-regulator.c