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) \
60 static 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 \
74 static 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 */
94 static 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 */
always_enabled_by_hwstate(struct regulator_dev * rdev)107 static int always_enabled_by_hwstate(struct regulator_dev *rdev)
108 {
109 return 1;
110 }
111
never_enabled_by_hwstate(struct regulator_dev * rdev)112 static int never_enabled_by_hwstate(struct regulator_dev *rdev)
113 {
114 return 0;
115 }
116
bd71837_get_buck34_enable_hwctrl(struct regulator_dev * rdev)117 static int bd71837_get_buck34_enable_hwctrl(struct regulator_dev *rdev)
118 {
119 int ret;
120 unsigned int val;
121
122 ret = regmap_read(rdev->regmap, rdev->desc->enable_reg, &val);
123 if (ret)
124 return ret;
125
126 return !!(BD718XX_BUCK_RUN_ON & val);
127 }
128
voltage_change_done(struct regulator_dev * rdev,unsigned int sel,unsigned int * mask)129 static void voltage_change_done(struct regulator_dev *rdev, unsigned int sel,
130 unsigned int *mask)
131 {
132 int ret;
133
134 if (*mask) {
135 /*
136 * Let's allow scheduling as we use I2C anyways. We just need to
137 * guarantee minimum of 1ms sleep - it shouldn't matter if we
138 * exceed it due to the scheduling.
139 */
140 msleep(1);
141
142 ret = regmap_clear_bits(rdev->regmap, BD718XX_REG_MVRFLTMASK2,
143 *mask);
144 if (ret)
145 dev_err(&rdev->dev,
146 "Failed to re-enable voltage monitoring (%d)\n",
147 ret);
148 }
149 }
150
voltage_change_prepare(struct regulator_dev * rdev,unsigned int sel,unsigned int * mask)151 static int voltage_change_prepare(struct regulator_dev *rdev, unsigned int sel,
152 unsigned int *mask)
153 {
154 int ret;
155
156 *mask = 0;
157 if (rdev->desc->ops->is_enabled(rdev)) {
158 int now, new;
159
160 now = rdev->desc->ops->get_voltage_sel(rdev);
161 if (now < 0)
162 return now;
163
164 now = rdev->desc->ops->list_voltage(rdev, now);
165 if (now < 0)
166 return now;
167
168 new = rdev->desc->ops->list_voltage(rdev, sel);
169 if (new < 0)
170 return new;
171
172 /*
173 * If we increase LDO voltage when LDO is enabled we need to
174 * disable the power-good detection until voltage has reached
175 * the new level. According to HW colleagues the maximum time
176 * it takes is 1000us. I assume that on systems with light load
177 * this might be less - and we could probably use DT to give
178 * system specific delay value if performance matters.
179 *
180 * Well, knowing we use I2C here and can add scheduling delays
181 * I don't think it is worth the hassle and I just add fixed
182 * 1ms sleep here (and allow scheduling). If this turns out to
183 * be a problem we can change it to delay and make the delay
184 * time configurable.
185 */
186 if (new > now) {
187 int tmp;
188 int prot_bit;
189 int ldo_offset = rdev->desc->id - BD718XX_LDO1;
190
191 prot_bit = BD718XX_LDO1_VRMON80 << ldo_offset;
192 ret = regmap_read(rdev->regmap, BD718XX_REG_MVRFLTMASK2,
193 &tmp);
194 if (ret) {
195 dev_err(&rdev->dev,
196 "Failed to read voltage monitoring state\n");
197 return ret;
198 }
199
200 if (!(tmp & prot_bit)) {
201 /* We disable protection if it was enabled... */
202 ret = regmap_set_bits(rdev->regmap,
203 BD718XX_REG_MVRFLTMASK2,
204 prot_bit);
205 /* ...and we also want to re-enable it */
206 *mask = prot_bit;
207 }
208 if (ret) {
209 dev_err(&rdev->dev,
210 "Failed to stop voltage monitoring\n");
211 return ret;
212 }
213 }
214 }
215
216 return 0;
217 }
218
bd718xx_set_voltage_sel_restricted(struct regulator_dev * rdev,unsigned int sel)219 static int bd718xx_set_voltage_sel_restricted(struct regulator_dev *rdev,
220 unsigned int sel)
221 {
222 int ret;
223 int mask;
224
225 ret = voltage_change_prepare(rdev, sel, &mask);
226 if (ret)
227 return ret;
228
229 ret = regulator_set_voltage_sel_regmap(rdev, sel);
230 voltage_change_done(rdev, sel, &mask);
231
232 return ret;
233 }
234
bd718xx_set_voltage_sel_pickable_restricted(struct regulator_dev * rdev,unsigned int sel)235 static int bd718xx_set_voltage_sel_pickable_restricted(
236 struct regulator_dev *rdev, unsigned int sel)
237 {
238 int ret;
239 int mask;
240
241 ret = voltage_change_prepare(rdev, sel, &mask);
242 if (ret)
243 return ret;
244
245 ret = regulator_set_voltage_sel_pickable_regmap(rdev, sel);
246 voltage_change_done(rdev, sel, &mask);
247
248 return ret;
249 }
250
bd71837_set_voltage_sel_pickable_restricted(struct regulator_dev * rdev,unsigned int sel)251 static 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 */
265 static 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 */
276 static 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 */
291 static const unsigned int bd71837_buck5_volt_range_sel[] = {
292 0x0, 0x0, 0x0, 0x1, 0x1, 0x1
293 };
294
295 /*
296 * BD71847 BUCK3
297 */
298 static 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
311 static const unsigned int bd71847_buck3_volt_range_sel[] = {
312 0x0, 0x0, 0x0, 0x1, 0x2, 0x2, 0x2
313 };
314
315 static 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
320 static const unsigned int bd71847_buck4_volt_range_sel[] = { 0x0, 0x1 };
321
322 /*
323 * BUCK6
324 * 3.0V to 3.3V (step 100mV)
325 */
326 static 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 */
342 static 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 */
350 static 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 */
358 static 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
363 static const unsigned int bd718xx_ldo1_volt_range_sel[] = { 0x0, 0x1 };
364
365 /*
366 * LDO2
367 * 0.8 or 0.9V
368 */
369 static const unsigned int ldo_2_volts[] = {
370 900000, 800000
371 };
372
373 /*
374 * LDO3
375 * 1.8 to 3.3V (100mV step)
376 */
377 static 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 */
385 static 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 */
393 static 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 */
401 static 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
406 static const unsigned int bd71847_ldo5_volt_range_sel[] = { 0x0, 0x1 };
407
408 /*
409 * LDO6
410 * 0.9 to 1.8V (100mV step)
411 */
412 static 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 */
420 static const struct linear_range bd71837_ldo7_volts[] = {
421 REGULATOR_LINEAR_RANGE(1800000, 0x00, 0x0F, 100000),
422 };
423
424 struct reg_init {
425 unsigned int reg;
426 unsigned int mask;
427 unsigned int val;
428 };
429 struct 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
bd718x7_xvp_sanity_check(struct regulator_dev * rdev,int lim_uV,int severity)437 static 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
bd718x7_set_ldo_uvp(struct regulator_dev * rdev,int lim_uV,int severity,bool enable)460 static int bd718x7_set_ldo_uvp(struct regulator_dev *rdev, int lim_uV,
461 int severity, bool enable)
462 {
463 int ldo_offset = rdev->desc->id - BD718XX_LDO1;
464 int prot_bit, ret;
465
466 ret = bd718x7_xvp_sanity_check(rdev, lim_uV, severity);
467 if (ret)
468 return ret;
469
470 prot_bit = BD718XX_LDO1_VRMON80 << ldo_offset;
471
472 if (enable)
473 return regmap_clear_bits(rdev->regmap, BD718XX_REG_MVRFLTMASK2,
474 prot_bit);
475
476 return regmap_set_bits(rdev->regmap, BD718XX_REG_MVRFLTMASK2,
477 prot_bit);
478 }
479
bd718x7_get_buck_prot_reg(int id,int * reg)480 static 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
bd718x7_get_buck_ovp_info(int id,int * reg,int * bit)496 static 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
bd718x7_get_buck_uvp_info(int id,int * reg,int * bit)509 static 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
bd718x7_set_buck_uvp(struct regulator_dev * rdev,int lim_uV,int severity,bool enable)522 static int bd718x7_set_buck_uvp(struct regulator_dev *rdev, int lim_uV,
523 int severity, bool enable)
524 {
525 int bit, reg, ret;
526
527 ret = bd718x7_xvp_sanity_check(rdev, lim_uV, severity);
528 if (ret)
529 return ret;
530
531 ret = bd718x7_get_buck_uvp_info(rdev->desc->id, ®, &bit);
532 if (ret)
533 return ret;
534
535 if (enable)
536 return regmap_clear_bits(rdev->regmap, reg, bit);
537
538 return regmap_set_bits(rdev->regmap, reg, bit);
539
540 }
541
bd718x7_set_buck_ovp(struct regulator_dev * rdev,int lim_uV,int severity,bool enable)542 static int bd718x7_set_buck_ovp(struct regulator_dev *rdev, int lim_uV,
543 int severity,
544 bool enable)
545 {
546 int bit, reg, ret;
547
548 ret = bd718x7_xvp_sanity_check(rdev, lim_uV, severity);
549 if (ret)
550 return ret;
551
552 ret = bd718x7_get_buck_ovp_info(rdev->desc->id, ®, &bit);
553 if (ret)
554 return ret;
555
556 if (enable)
557 return regmap_clear_bits(rdev->regmap, reg, bit);
558
559 return regmap_set_bits(rdev->regmap, reg, bit);
560 }
561
562 /*
563 * OPS common for BD71847 and BD71850
564 */
565 BD718XX_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 */
572 static 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
580 BD718XX_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
587 BD718XX_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
592 BD718XX_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
597 BD718XX_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
602 BD718XX_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 */
610 BD718XX_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
616 BD718XX_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
623 BD718XX_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
628 BD718XX_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
633 BD718XX_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
638 BD718XX_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 */
647 static 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 */
661 BD718XX_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 */
679 static 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
687 static 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
buck_set_hw_dvs_levels(struct device_node * np,const struct regulator_desc * desc,struct regulator_config * cfg)695 static int buck_set_hw_dvs_levels(struct device_node *np,
696 const struct regulator_desc *desc,
697 struct regulator_config *cfg)
698 {
699 struct bd718xx_regulator_data *data;
700
701 data = container_of(desc, struct bd718xx_regulator_data, desc);
702
703 return rohm_regulator_set_dvs_levels(&data->dvs, np, desc, cfg->regmap);
704 }
705
706 static 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
715 static 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
730 static 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
1052 static 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
1063 static 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
1080 static 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
mark_hw_controlled(struct device * dev,struct device_node * np,struct bd718xx_regulator_data * reg_data,unsigned int num_reg_data,int * info)1490 static void mark_hw_controlled(struct device *dev, struct device_node *np,
1491 struct bd718xx_regulator_data *reg_data,
1492 unsigned int num_reg_data, int *info)
1493 {
1494 int i;
1495
1496 for (i = 1; i <= num_reg_data; i++) {
1497 if (!of_node_name_eq(np, reg_data[i-1].desc.of_match))
1498 continue;
1499
1500 *info |= 1 << (i - 1);
1501 dev_dbg(dev, "regulator %d runlevel controlled\n", i);
1502 return;
1503 }
1504 dev_warn(dev, "Bad regulator node\n");
1505 }
1506
1507 /*
1508 * Setups where regulator (especially the buck8) output voltage is scaled
1509 * by adding external connection where some other regulator output is connected
1510 * to feedback-pin (over suitable resistors) is getting popular amongst users
1511 * of BD71837. (This allows for example scaling down the buck8 voltages to suit
1512 * lover GPU voltages for projects where buck8 is (ab)used to supply power
1513 * for GPU. Additionally some setups do allow DVS for buck8 but as this do
1514 * produce voltage spikes the HW must be evaluated to be able to survive this
1515 * - hence I keep the DVS disabled for non DVS bucks by default. I don't want
1516 * to help you burn your proto board)
1517 *
1518 * So we allow describing this external connection from DT and scale the
1519 * voltages accordingly. This is what the connection should look like:
1520 *
1521 * |------------|
1522 * | buck 8 |-------+----->Vout
1523 * | | |
1524 * |------------| |
1525 * | FB pin |
1526 * | |
1527 * +-------+--R2---+
1528 * |
1529 * R1
1530 * |
1531 * V FB-pull-up
1532 *
1533 * Here the buck output is sifted according to formula:
1534 *
1535 * Vout_o = Vo - (Vpu - Vo)*R2/R1
1536 * Linear_step = step_orig*(R1+R2)/R1
1537 *
1538 * where:
1539 * Vout_o is adjusted voltage output at vsel reg value 0
1540 * Vo is original voltage output at vsel reg value 0
1541 * Vpu is the pull-up voltage V FB-pull-up in the picture
1542 * R1 and R2 are resistor values.
1543 *
1544 * As a real world example for buck8 and a specific GPU:
1545 * VLDO = 1.6V (used as FB-pull-up)
1546 * R1 = 1000ohms
1547 * R2 = 150ohms
1548 * VSEL 0x0 => 0.8V – (VLDO – 0.8) * R2 / R1 = 0.68V
1549 * Linear Step = 10mV * (R1 + R2) / R1 = 11.5mV
1550 */
setup_feedback_loop(struct device * dev,struct device_node * np,struct bd718xx_regulator_data * reg_data,unsigned int num_reg_data,int fb_uv)1551 static int setup_feedback_loop(struct device *dev, struct device_node *np,
1552 struct bd718xx_regulator_data *reg_data,
1553 unsigned int num_reg_data, int fb_uv)
1554 {
1555 int i, r1, r2, ret;
1556
1557 /*
1558 * We do adjust the values in the global desc based on DT settings.
1559 * This may not be best approach as it can cause problems if more than
1560 * one PMIC is controlled from same processor. I don't see such use-case
1561 * for BD718x7 now - so we spare some bits.
1562 *
1563 * If this will point out to be a problem - then we can allocate new
1564 * bd718xx_regulator_data array at probe and just use the global
1565 * array as a template where we copy initial values. Then we can
1566 * use allocated descs for regultor registration and do IC specific
1567 * modifications to this copy while leaving other PMICs untouched. But
1568 * that means allocating new array for each PMIC - and currently I see
1569 * no need for that.
1570 */
1571
1572 for (i = 0; i < num_reg_data; i++) {
1573 struct regulator_desc *desc = ®_data[i].desc;
1574 int j;
1575
1576 if (!of_node_name_eq(np, desc->of_match))
1577 continue;
1578
1579 /* The feedback loop connection does not make sense for LDOs */
1580 if (desc->id >= BD718XX_LDO1)
1581 return -EINVAL;
1582
1583 ret = of_property_read_u32(np, "rohm,feedback-pull-up-r1-ohms",
1584 &r1);
1585 if (ret)
1586 return ret;
1587
1588 if (!r1)
1589 return -EINVAL;
1590
1591 ret = of_property_read_u32(np, "rohm,feedback-pull-up-r2-ohms",
1592 &r2);
1593 if (ret)
1594 return ret;
1595
1596 if (desc->n_linear_ranges && desc->linear_ranges) {
1597 struct linear_range *new;
1598
1599 new = devm_kzalloc(dev, desc->n_linear_ranges *
1600 sizeof(struct linear_range),
1601 GFP_KERNEL);
1602 if (!new)
1603 return -ENOMEM;
1604
1605 for (j = 0; j < desc->n_linear_ranges; j++) {
1606 int min = desc->linear_ranges[j].min;
1607 int step = desc->linear_ranges[j].step;
1608
1609 min -= (fb_uv - min)*r2/r1;
1610 step = step * (r1 + r2);
1611 step /= r1;
1612
1613 new[j].min = min;
1614 new[j].step = step;
1615
1616 dev_dbg(dev, "%s: old range min %d, step %d\n",
1617 desc->name, desc->linear_ranges[j].min,
1618 desc->linear_ranges[j].step);
1619 dev_dbg(dev, "new range min %d, step %d\n", min,
1620 step);
1621 }
1622 desc->linear_ranges = new;
1623 }
1624 dev_dbg(dev, "regulator '%s' has FB pull-up configured\n",
1625 desc->name);
1626
1627 return 0;
1628 }
1629
1630 return -ENODEV;
1631 }
1632
get_special_regulators(struct device * dev,struct bd718xx_regulator_data * reg_data,unsigned int num_reg_data,int * info)1633 static int get_special_regulators(struct device *dev,
1634 struct bd718xx_regulator_data *reg_data,
1635 unsigned int num_reg_data, int *info)
1636 {
1637 int ret;
1638 struct device_node *np;
1639 struct device_node *nproot = dev->of_node;
1640 int uv;
1641
1642 *info = 0;
1643
1644 nproot = of_get_child_by_name(nproot, "regulators");
1645 if (!nproot) {
1646 dev_err(dev, "failed to find regulators node\n");
1647 return -ENODEV;
1648 }
1649 for_each_child_of_node(nproot, np) {
1650 if (of_property_read_bool(np, "rohm,no-regulator-enable-control"))
1651 mark_hw_controlled(dev, np, reg_data, num_reg_data,
1652 info);
1653 ret = of_property_read_u32(np, "rohm,fb-pull-up-microvolt",
1654 &uv);
1655 if (ret) {
1656 if (ret == -EINVAL)
1657 continue;
1658 else
1659 goto err_out;
1660 }
1661
1662 ret = setup_feedback_loop(dev, np, reg_data, num_reg_data, uv);
1663 if (ret)
1664 goto err_out;
1665 }
1666
1667 of_node_put(nproot);
1668 return 0;
1669
1670 err_out:
1671 of_node_put(np);
1672 of_node_put(nproot);
1673
1674 return ret;
1675 }
1676
bd718xx_probe(struct platform_device * pdev)1677 static int bd718xx_probe(struct platform_device *pdev)
1678 {
1679 struct regmap *regmap;
1680 struct regulator_config config = { 0 };
1681 int i, j, err, omit_enable;
1682 bool use_snvs;
1683 struct bd718xx_regulator_data *reg_data;
1684 unsigned int num_reg_data;
1685 enum rohm_chip_type chip = platform_get_device_id(pdev)->driver_data;
1686 const struct regulator_ops **swops, **hwops;
1687
1688 regmap = dev_get_regmap(pdev->dev.parent, NULL);
1689 if (!regmap) {
1690 dev_err(&pdev->dev, "No MFD driver data\n");
1691 return -EINVAL;
1692 }
1693
1694 switch (chip) {
1695 case ROHM_CHIP_TYPE_BD71837:
1696 reg_data = bd71837_regulators;
1697 num_reg_data = ARRAY_SIZE(bd71837_regulators);
1698 swops = &bd71837_swcontrol_ops[0];
1699 hwops = &bd71837_hwcontrol_ops[0];
1700 break;
1701 case ROHM_CHIP_TYPE_BD71847:
1702 reg_data = bd71847_regulators;
1703 num_reg_data = ARRAY_SIZE(bd71847_regulators);
1704 swops = &bd71847_swcontrol_ops[0];
1705 hwops = &bd71847_hwcontrol_ops[0];
1706 break;
1707 default:
1708 dev_err(&pdev->dev, "Unsupported chip type\n");
1709 return -EINVAL;
1710 }
1711
1712 /* Register LOCK release */
1713 err = regmap_update_bits(regmap, BD718XX_REG_REGLOCK,
1714 (REGLOCK_PWRSEQ | REGLOCK_VREG), 0);
1715 if (err)
1716 return dev_err_probe(&pdev->dev, err, "Failed to unlock PMIC\n");
1717
1718 dev_dbg(&pdev->dev, "Unlocked lock register 0x%x\n",
1719 BD718XX_REG_REGLOCK);
1720
1721 use_snvs = of_property_read_bool(pdev->dev.parent->of_node,
1722 "rohm,reset-snvs-powered");
1723
1724 /*
1725 * Change the next stage from poweroff to be READY instead of SNVS
1726 * for all reset types because OTP loading at READY will clear SEL
1727 * bit allowing HW defaults for power rails to be used
1728 */
1729 if (!use_snvs) {
1730 err = regmap_update_bits(regmap, BD718XX_REG_TRANS_COND1,
1731 BD718XX_ON_REQ_POWEROFF_MASK |
1732 BD718XX_SWRESET_POWEROFF_MASK |
1733 BD718XX_WDOG_POWEROFF_MASK |
1734 BD718XX_KEY_L_POWEROFF_MASK,
1735 BD718XX_POWOFF_TO_RDY);
1736 if (err)
1737 return dev_err_probe(&pdev->dev, err,
1738 "Failed to change reset target\n");
1739
1740 dev_dbg(&pdev->dev, "Changed all resets from SVNS to READY\n");
1741 }
1742
1743 config.dev = pdev->dev.parent;
1744 config.regmap = regmap;
1745 /*
1746 * There are cases when we want to leave the enable-control for
1747 * the HW state machine and use this driver only for voltage control.
1748 * One special case is when we use PMIC_STBY_REQ line from SoC to PMIC
1749 * in order to set the system to SUSPEND state.
1750 *
1751 * If regulator is taken under SW control the regulator state will not
1752 * be affected by PMIC state machine - Eg. regulator is likely to stay
1753 * on even in SUSPEND
1754 */
1755 err = get_special_regulators(pdev->dev.parent, reg_data, num_reg_data,
1756 &omit_enable);
1757 if (err)
1758 return err;
1759
1760 for (i = 0; i < num_reg_data; i++) {
1761
1762 struct regulator_desc *desc;
1763 struct regulator_dev *rdev;
1764 struct bd718xx_regulator_data *r;
1765 int no_enable_control = omit_enable & (1 << i);
1766
1767 r = ®_data[i];
1768 desc = &r->desc;
1769
1770 if (no_enable_control)
1771 desc->ops = hwops[i];
1772 else
1773 desc->ops = swops[i];
1774
1775 rdev = devm_regulator_register(&pdev->dev, desc, &config);
1776 if (IS_ERR(rdev))
1777 return dev_err_probe(&pdev->dev, PTR_ERR(rdev),
1778 "failed to register %s regulator\n",
1779 desc->name);
1780
1781 /*
1782 * Regulator register gets the regulator constraints and
1783 * applies them (set_machine_constraints). This should have
1784 * turned the control register(s) to correct values and we
1785 * can now switch the control from PMIC state machine to the
1786 * register interface
1787 *
1788 * At poweroff transition PMIC HW disables EN bit for
1789 * regulators but leaves SEL bit untouched. So if state
1790 * transition from POWEROFF is done to SNVS - then all power
1791 * rails controlled by SW (having SEL bit set) stay disabled
1792 * as EN is cleared. This will result boot failure if any
1793 * crucial systems are powered by these rails. We don't
1794 * enable SW control for crucial regulators if snvs state is
1795 * used
1796 */
1797 if (!no_enable_control && (!use_snvs ||
1798 !rdev->constraints->always_on ||
1799 !rdev->constraints->boot_on)) {
1800 err = regmap_update_bits(regmap, r->init.reg,
1801 r->init.mask, r->init.val);
1802 if (err)
1803 return dev_err_probe(&pdev->dev, err,
1804 "Failed to take control for (%s)\n",
1805 desc->name);
1806 }
1807 for (j = 0; j < r->additional_init_amnt; j++) {
1808 err = regmap_update_bits(regmap,
1809 r->additional_inits[j].reg,
1810 r->additional_inits[j].mask,
1811 r->additional_inits[j].val);
1812 if (err)
1813 return dev_err_probe(&pdev->dev, err,
1814 "Buck (%s) initialization failed\n",
1815 desc->name);
1816 }
1817 }
1818
1819 return err;
1820 }
1821
1822 static const struct platform_device_id bd718x7_pmic_id[] = {
1823 { "bd71837-pmic", ROHM_CHIP_TYPE_BD71837 },
1824 { "bd71847-pmic", ROHM_CHIP_TYPE_BD71847 },
1825 { },
1826 };
1827 MODULE_DEVICE_TABLE(platform, bd718x7_pmic_id);
1828
1829 static 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
1838 module_platform_driver(bd718xx_regulator);
1839
1840 MODULE_AUTHOR("Matti Vaittinen <matti.vaittinen@fi.rohmeurope.com>");
1841 MODULE_DESCRIPTION("BD71837/BD71847 voltage regulator driver");
1842 MODULE_LICENSE("GPL");
1843 MODULE_ALIAS("platform:bd718xx-pmic");
1844