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  */
107 static int always_enabled_by_hwstate(struct regulator_dev *rdev)
108 {
109 	return 1;
110 }
111 
112 static int never_enabled_by_hwstate(struct regulator_dev *rdev)
113 {
114 	return 0;
115 }
116 
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 
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 
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 
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 
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 
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, 0x80, 0x80, 0x80
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, 0x40, 0x80, 0x80, 0x80
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, 0x40 };
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, 0x20 };
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, 0x20 };
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 
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 
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 
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 
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 
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 
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, &reg, &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 
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, &reg, &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 
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 = 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 = 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 = 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 = 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 = 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 = 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 
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  */
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 = &reg_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 
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 
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 = &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(&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 	},
1833 	.probe = bd718xx_probe,
1834 	.id_table = bd718x7_pmic_id,
1835 };
1836 
1837 module_platform_driver(bd718xx_regulator);
1838 
1839 MODULE_AUTHOR("Matti Vaittinen <matti.vaittinen@fi.rohmeurope.com>");
1840 MODULE_DESCRIPTION("BD71837/BD71847 voltage regulator driver");
1841 MODULE_LICENSE("GPL");
1842 MODULE_ALIAS("platform:bd718xx-pmic");
1843