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(map: rdev->regmap, reg: rdev->desc->enable_reg, val: &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(msecs: 1);
141
142 ret = regmap_clear_bits(map: rdev->regmap, reg: BD718XX_REG_MVRFLTMASK2,
143 bits: *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(map: rdev->regmap, reg: BD718XX_REG_MVRFLTMASK2,
193 val: &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(map: rdev->regmap,
203 reg: BD718XX_REG_MVRFLTMASK2,
204 bits: 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: &mask);
226 if (ret)
227 return ret;
228
229 ret = regulator_set_voltage_sel_regmap(rdev, sel);
230 voltage_change_done(rdev, sel, mask: &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: &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: &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(map: rdev->regmap, reg: BD718XX_REG_MVRFLTMASK2,
474 bits: prot_bit);
475
476 return regmap_set_bits(map: rdev->regmap, reg: BD718XX_REG_MVRFLTMASK2,
477 bits: 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(id: rdev->desc->id, reg: &reg, bit: &bit);
532 if (ret)
533 return ret;
534
535 if (enable)
536 return regmap_clear_bits(map: rdev->regmap, reg, bits: bit);
537
538 return regmap_set_bits(map: rdev->regmap, reg, bits: 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(id: rdev->desc->id, reg: &reg, bit: &bit);
553 if (ret)
554 return ret;
555
556 if (enable)
557 return regmap_clear_bits(map: rdev->regmap, reg, bits: bit);
558
559 return regmap_set_bits(map: rdev->regmap, reg, bits: 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(dvs: &data->dvs, np, desc, regmap: 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, name: 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 = &reg_data[i].desc;
1574 int j;
1575
1576 if (!of_node_name_eq(np, name: 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, propname: "rohm,feedback-pull-up-r1-ohms",
1584 out_value: &r1);
1585 if (ret)
1586 return ret;
1587
1588 if (!r1)
1589 return -EINVAL;
1590
1591 ret = of_property_read_u32(np, propname: "rohm,feedback-pull-up-r2-ohms",
1592 out_value: &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, size: 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(node: nproot, name: "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, propname: "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, propname: "rohm,fb-pull-up-microvolt",
1654 out_value: &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, fb_uv: uv);
1663 if (ret)
1664 goto err_out;
1665 }
1666
1667 of_node_put(node: nproot);
1668 return 0;
1669
1670err_out:
1671 of_node_put(node: np);
1672 of_node_put(node: 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(dev: 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(map: regmap, reg: BD718XX_REG_REGLOCK,
1714 mask: (REGLOCK_PWRSEQ | REGLOCK_VREG), val: 0);
1715 if (err)
1716 return dev_err_probe(dev: &pdev->dev, err, fmt: "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(np: pdev->dev.parent->of_node,
1722 propname: "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(map: regmap, reg: 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(dev: &pdev->dev, err,
1738 fmt: "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(dev: pdev->dev.parent, reg_data, num_reg_data,
1756 info: &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 = &reg_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(dev: &pdev->dev, regulator_desc: desc, config: &config);
1776 if (IS_ERR(ptr: rdev))
1777 return dev_err_probe(dev: &pdev->dev, err: PTR_ERR(ptr: rdev),
1778 fmt: "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(map: regmap, reg: r->init.reg,
1801 mask: r->init.mask, val: r->init.val);
1802 if (err)
1803 return dev_err_probe(dev: &pdev->dev, err,
1804 fmt: "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(map: regmap,
1809 reg: r->additional_inits[j].reg,
1810 mask: r->additional_inits[j].mask,
1811 val: r->additional_inits[j].val);
1812 if (err)
1813 return dev_err_probe(dev: &pdev->dev, err,
1814 fmt: "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");
1844

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