1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  *  Copyright (C) 2012-2015 Samsung Electronics
4  *
5  *  Rajeshwari Shinde <rajeshwari.s@samsung.com>
6  *  Przemyslaw Marczak <p.marczak@samsung.com>
7  */
8 
9 #include <common.h>
10 #include <fdtdec.h>
11 #include <errno.h>
12 #include <dm.h>
13 #include <i2c.h>
14 #include <power/pmic.h>
15 #include <power/regulator.h>
16 #include <power/max77686_pmic.h>
17 
18 #define MODE(_id, _val, _name) { \
19 	.id = _id, \
20 	.register_value = _val, \
21 	.name = _name, \
22 }
23 
24 /* LDO: 1,3,4,5,9,17,18,19,20,21,22,23,24,26,26,27 */
25 static struct dm_regulator_mode max77686_ldo_mode_standby1[] = {
26 	MODE(OPMODE_OFF, MAX77686_LDO_MODE_OFF, "OFF"),
27 	MODE(OPMODE_LPM, MAX77686_LDO_MODE_LPM, "LPM"),
28 	MODE(OPMODE_STANDBY_LPM, MAX77686_LDO_MODE_STANDBY_LPM, "ON/LPM"),
29 	MODE(OPMODE_ON, MAX77686_LDO_MODE_ON, "ON"),
30 };
31 
32 /* LDO: 2,6,7,8,10,11,12,14,15,16 */
33 static struct dm_regulator_mode max77686_ldo_mode_standby2[] = {
34 	MODE(OPMODE_OFF, MAX77686_LDO_MODE_OFF, "OFF"),
35 	MODE(OPMODE_STANDBY, MAX77686_LDO_MODE_STANDBY, "ON/OFF"),
36 	MODE(OPMODE_STANDBY_LPM, MAX77686_LDO_MODE_STANDBY_LPM, "ON/LPM"),
37 	MODE(OPMODE_ON, MAX77686_LDO_MODE_ON, "ON"),
38 };
39 
40 /* Buck: 1 */
41 static struct dm_regulator_mode max77686_buck_mode_standby[] = {
42 	MODE(OPMODE_OFF, MAX77686_BUCK_MODE_OFF, "OFF"),
43 	MODE(OPMODE_STANDBY, MAX77686_BUCK_MODE_STANDBY, "ON/OFF"),
44 	MODE(OPMODE_ON, MAX77686_BUCK_MODE_ON, "ON"),
45 };
46 
47 /* Buck: 2,3,4 */
48 static struct dm_regulator_mode max77686_buck_mode_lpm[] = {
49 	MODE(OPMODE_OFF, MAX77686_BUCK_MODE_OFF, "OFF"),
50 	MODE(OPMODE_STANDBY, MAX77686_BUCK_MODE_STANDBY, "ON/OFF"),
51 	MODE(OPMODE_LPM, MAX77686_BUCK_MODE_LPM, "LPM"),
52 	MODE(OPMODE_ON, MAX77686_BUCK_MODE_ON, "ON"),
53 };
54 
55 /* Buck: 5,6,7,8,9 */
56 static struct dm_regulator_mode max77686_buck_mode_onoff[] = {
57 	MODE(OPMODE_OFF, MAX77686_BUCK_MODE_OFF, "OFF"),
58 	MODE(OPMODE_ON, MAX77686_BUCK_MODE_ON, "ON"),
59 };
60 
61 static const char max77686_buck_ctrl[] = {
62 	0xff, 0x10, 0x12, 0x1c, 0x26, 0x30, 0x32, 0x34, 0x36, 0x38
63 };
64 
65 static const char max77686_buck_out[] = {
66 	0xff, 0x11, 0x14, 0x1e, 0x28, 0x31, 0x33, 0x35, 0x37, 0x39
67 };
68 
69 static int max77686_buck_volt2hex(int buck, int uV)
70 {
71 	int hex = 0;
72 	int hex_max = 0;
73 
74 	switch (buck) {
75 	case 2:
76 	case 3:
77 	case 4:
78 		/* hex = (uV - 600000) / 12500; */
79 		hex = (uV - MAX77686_BUCK_UV_LMIN) / MAX77686_BUCK_UV_LSTEP;
80 		hex_max = MAX77686_BUCK234_VOLT_MAX_HEX;
81 		break;
82 	default:
83 		/*
84 		 * hex = (uV - 750000) / 50000. We assume that dynamic voltage
85 		 * scaling via GPIOs is not enabled and don't support that.
86 		 * If this is enabled then the driver will need to take that
87 		 * into account and check different registers depending on
88 		 * the current setting. See the datasheet for details.
89 		 */
90 		hex = (uV - MAX77686_BUCK_UV_HMIN) / MAX77686_BUCK_UV_HSTEP;
91 		hex_max = MAX77686_BUCK_VOLT_MAX_HEX;
92 		break;
93 	}
94 
95 	if (hex >= 0 && hex <= hex_max)
96 		return hex;
97 
98 	pr_err("Value: %d uV is wrong for BUCK%d", uV, buck);
99 	return -EINVAL;
100 }
101 
102 static int max77686_buck_hex2volt(int buck, int hex)
103 {
104 	unsigned uV = 0;
105 	int hex_max = 0;
106 
107 	if (hex < 0)
108 		goto bad_hex;
109 
110 	switch (buck) {
111 	case 2:
112 	case 3:
113 	case 4:
114 		hex_max = MAX77686_BUCK234_VOLT_MAX_HEX;
115 		if (hex > hex_max)
116 			goto bad_hex;
117 
118 		/* uV = hex * 12500 + 600000; */
119 		uV = hex * MAX77686_BUCK_UV_LSTEP + MAX77686_BUCK_UV_LMIN;
120 		break;
121 	default:
122 		hex_max = MAX77686_BUCK_VOLT_MAX_HEX;
123 		if (hex > hex_max)
124 			goto bad_hex;
125 
126 		/* uV = hex * 50000 + 750000; */
127 		uV = hex * MAX77686_BUCK_UV_HSTEP + MAX77686_BUCK_UV_HMIN;
128 		break;
129 	}
130 
131 	return uV;
132 
133 bad_hex:
134 	pr_err("Value: %#x is wrong for BUCK%d", hex, buck);
135 	return -EINVAL;
136 }
137 
138 static int max77686_ldo_volt2hex(int ldo, int uV)
139 {
140 	int hex = 0;
141 
142 	switch (ldo) {
143 	case 1:
144 	case 2:
145 	case 6:
146 	case 7:
147 	case 8:
148 	case 15:
149 		hex = (uV - MAX77686_LDO_UV_MIN) / MAX77686_LDO_UV_LSTEP;
150 		/* hex = (uV - 800000) / 25000; */
151 		break;
152 	default:
153 		hex = (uV - MAX77686_LDO_UV_MIN) / MAX77686_LDO_UV_HSTEP;
154 		/* hex = (uV - 800000) / 50000; */
155 	}
156 
157 	if (hex >= 0 && hex <= MAX77686_LDO_VOLT_MAX_HEX)
158 		return hex;
159 
160 	pr_err("Value: %d uV is wrong for LDO%d", uV, ldo);
161 	return -EINVAL;
162 }
163 
164 static int max77686_ldo_hex2volt(int ldo, int hex)
165 {
166 	unsigned int uV = 0;
167 
168 	if (hex > MAX77686_LDO_VOLT_MAX_HEX)
169 		goto bad_hex;
170 
171 	switch (ldo) {
172 	case 1:
173 	case 2:
174 	case 6:
175 	case 7:
176 	case 8:
177 	case 15:
178 		/* uV = hex * 25000 + 800000; */
179 		uV = hex * MAX77686_LDO_UV_LSTEP + MAX77686_LDO_UV_MIN;
180 		break;
181 	default:
182 		/* uV = hex * 50000 + 800000; */
183 		uV = hex * MAX77686_LDO_UV_HSTEP + MAX77686_LDO_UV_MIN;
184 	}
185 
186 	return uV;
187 
188 bad_hex:
189 	pr_err("Value: %#x is wrong for ldo%d", hex, ldo);
190 	return -EINVAL;
191 }
192 
193 static int max77686_ldo_hex2mode(int ldo, int hex)
194 {
195 	if (hex > MAX77686_LDO_MODE_MASK)
196 		return -EINVAL;
197 
198 	switch (hex) {
199 	case MAX77686_LDO_MODE_OFF:
200 		return OPMODE_OFF;
201 	case MAX77686_LDO_MODE_LPM: /* == MAX77686_LDO_MODE_STANDBY: */
202 		/* The same mode values but different meaning for each ldo */
203 		switch (ldo) {
204 		case 2:
205 		case 6:
206 		case 7:
207 		case 8:
208 		case 10:
209 		case 11:
210 		case 12:
211 		case 14:
212 		case 15:
213 		case 16:
214 			return OPMODE_STANDBY;
215 		default:
216 			return OPMODE_LPM;
217 		}
218 	case MAX77686_LDO_MODE_STANDBY_LPM:
219 		return OPMODE_STANDBY_LPM;
220 	case MAX77686_LDO_MODE_ON:
221 		return OPMODE_ON;
222 	default:
223 		return -EINVAL;
224 	}
225 }
226 
227 static int max77686_buck_hex2mode(int buck, int hex)
228 {
229 	if (hex > MAX77686_BUCK_MODE_MASK)
230 		return -EINVAL;
231 
232 	switch (hex) {
233 	case MAX77686_BUCK_MODE_OFF:
234 		return OPMODE_OFF;
235 	case MAX77686_BUCK_MODE_ON:
236 		return OPMODE_ON;
237 	case MAX77686_BUCK_MODE_STANDBY:
238 		switch (buck) {
239 		case 1:
240 		case 2:
241 		case 3:
242 		case 4:
243 			return OPMODE_STANDBY;
244 		default:
245 			return -EINVAL;
246 		}
247 	case MAX77686_BUCK_MODE_LPM:
248 		switch (buck) {
249 		case 2:
250 		case 3:
251 		case 4:
252 			return OPMODE_LPM;
253 		default:
254 			return -EINVAL;
255 		}
256 	default:
257 		return -EINVAL;
258 	}
259 }
260 
261 static int max77686_buck_modes(int buck, struct dm_regulator_mode **modesp)
262 {
263 	int ret = -EINVAL;
264 
265 	if (buck < 1 || buck > MAX77686_BUCK_NUM)
266 		return ret;
267 
268 	switch (buck) {
269 	case 1:
270 		*modesp = max77686_buck_mode_standby;
271 		ret = ARRAY_SIZE(max77686_buck_mode_standby);
272 		break;
273 	case 2:
274 	case 3:
275 	case 4:
276 		*modesp = max77686_buck_mode_lpm;
277 		ret = ARRAY_SIZE(max77686_buck_mode_lpm);
278 		break;
279 	default:
280 		*modesp = max77686_buck_mode_onoff;
281 		ret = ARRAY_SIZE(max77686_buck_mode_onoff);
282 	}
283 
284 	return ret;
285 }
286 
287 static int max77686_ldo_modes(int ldo, struct dm_regulator_mode **modesp,
288 				struct udevice *dev)
289 {
290 	int ret = -EINVAL;
291 
292 	if (ldo < 1 || ldo > MAX77686_LDO_NUM)
293 		return ret;
294 
295 	switch (ldo) {
296 	case 2:
297 	case 6:
298 	case 7:
299 	case 8:
300 	case 10:
301 	case 11:
302 	case 12:
303 	case 14:
304 	case 15:
305 	case 16:
306 		*modesp = max77686_ldo_mode_standby2;
307 		ret = ARRAY_SIZE(max77686_ldo_mode_standby2);
308 		break;
309 	default:
310 		*modesp = max77686_ldo_mode_standby1;
311 		ret = ARRAY_SIZE(max77686_ldo_mode_standby1);
312 	}
313 
314 	return ret;
315 }
316 
317 static int max77686_ldo_val(struct udevice *dev, int op, int *uV)
318 {
319 	unsigned int adr;
320 	unsigned char val;
321 	int hex, ldo, ret;
322 
323 	if (op == PMIC_OP_GET)
324 		*uV = 0;
325 
326 	ldo = dev->driver_data;
327 	if (ldo < 1 || ldo > MAX77686_LDO_NUM) {
328 		pr_err("Wrong ldo number: %d", ldo);
329 		return -EINVAL;
330 	}
331 
332 	adr = MAX77686_REG_PMIC_LDO1CTRL1 + ldo - 1;
333 
334 	ret = pmic_read(dev->parent, adr, &val, 1);
335 	if (ret)
336 		return ret;
337 
338 	if (op == PMIC_OP_GET) {
339 		val &= MAX77686_LDO_VOLT_MASK;
340 		ret = max77686_ldo_hex2volt(ldo, val);
341 		if (ret < 0)
342 			return ret;
343 		*uV = ret;
344 		return 0;
345 	}
346 
347 	hex = max77686_ldo_volt2hex(ldo, *uV);
348 	if (hex < 0)
349 		return hex;
350 
351 	val &= ~MAX77686_LDO_VOLT_MASK;
352 	val |= hex;
353 	ret = pmic_write(dev->parent, adr, &val, 1);
354 
355 	return ret;
356 }
357 
358 static int max77686_buck_val(struct udevice *dev, int op, int *uV)
359 {
360 	unsigned int mask, adr;
361 	unsigned char val;
362 	int hex, buck, ret;
363 
364 	buck = dev->driver_data;
365 	if (buck < 1 || buck > MAX77686_BUCK_NUM) {
366 		pr_err("Wrong buck number: %d", buck);
367 		return -EINVAL;
368 	}
369 
370 	if (op == PMIC_OP_GET)
371 		*uV = 0;
372 
373 	/* &buck_out = ctrl + 1 */
374 	adr = max77686_buck_out[buck];
375 
376 	/* mask */
377 	switch (buck) {
378 	case 2:
379 	case 3:
380 	case 4:
381 		mask = MAX77686_BUCK234_VOLT_MASK;
382 		break;
383 	default:
384 		mask = MAX77686_BUCK_VOLT_MASK;
385 		break;
386 	}
387 
388 	ret = pmic_read(dev->parent, adr, &val, 1);
389 	if (ret)
390 		return ret;
391 
392 	if (op == PMIC_OP_GET) {
393 		val &= mask;
394 		ret = max77686_buck_hex2volt(buck, val);
395 		if (ret < 0)
396 			return ret;
397 		*uV = ret;
398 		return 0;
399 	}
400 
401 	hex = max77686_buck_volt2hex(buck, *uV);
402 	if (hex < 0)
403 		return hex;
404 
405 	val &= ~mask;
406 	val |= hex;
407 	ret = pmic_write(dev->parent, adr, &val, 1);
408 
409 	return ret;
410 }
411 
412 static int max77686_ldo_mode(struct udevice *dev, int op, int *opmode)
413 {
414 	unsigned int adr, mode;
415 	unsigned char val;
416 	int ldo, ret;
417 
418 	if (op == PMIC_OP_GET)
419 		*opmode = -EINVAL;
420 
421 	ldo = dev->driver_data;
422 	if (ldo < 1 || ldo > MAX77686_LDO_NUM) {
423 		pr_err("Wrong ldo number: %d", ldo);
424 		return -EINVAL;
425 	}
426 
427 	adr = MAX77686_REG_PMIC_LDO1CTRL1 + ldo - 1;
428 
429 	ret = pmic_read(dev->parent, adr, &val, 1);
430 	if (ret)
431 		return ret;
432 
433 	if (op == PMIC_OP_GET) {
434 		val &= MAX77686_LDO_MODE_MASK;
435 		ret = max77686_ldo_hex2mode(ldo, val);
436 		if (ret < 0)
437 			return ret;
438 		*opmode = ret;
439 		return 0;
440 	}
441 
442 	/* mode */
443 	switch (*opmode) {
444 	case OPMODE_OFF:
445 		mode = MAX77686_LDO_MODE_OFF;
446 		break;
447 	case OPMODE_LPM:
448 		switch (ldo) {
449 		case 2:
450 		case 6:
451 		case 7:
452 		case 8:
453 		case 10:
454 		case 11:
455 		case 12:
456 		case 14:
457 		case 15:
458 		case 16:
459 			return -EINVAL;
460 		default:
461 			mode = MAX77686_LDO_MODE_LPM;
462 		}
463 		break;
464 	case OPMODE_STANDBY:
465 		switch (ldo) {
466 		case 2:
467 		case 6:
468 		case 7:
469 		case 8:
470 		case 10:
471 		case 11:
472 		case 12:
473 		case 14:
474 		case 15:
475 		case 16:
476 			mode = MAX77686_LDO_MODE_STANDBY;
477 			break;
478 		default:
479 			return -EINVAL;
480 		}
481 		break;
482 	case OPMODE_STANDBY_LPM:
483 		mode = MAX77686_LDO_MODE_STANDBY_LPM;
484 		break;
485 	case OPMODE_ON:
486 		mode = MAX77686_LDO_MODE_ON;
487 		break;
488 	default:
489 		mode = 0xff;
490 	}
491 
492 	if (mode == 0xff) {
493 		pr_err("Wrong mode: %d for ldo%d", *opmode, ldo);
494 		return -EINVAL;
495 	}
496 
497 	val &= ~MAX77686_LDO_MODE_MASK;
498 	val |= mode;
499 	ret = pmic_write(dev->parent, adr, &val, 1);
500 
501 	return ret;
502 }
503 
504 static int max77686_ldo_enable(struct udevice *dev, int op, bool *enable)
505 {
506 	int ret, on_off;
507 
508 	if (op == PMIC_OP_GET) {
509 		ret = max77686_ldo_mode(dev, op, &on_off);
510 		if (ret)
511 			return ret;
512 
513 		switch (on_off) {
514 		case OPMODE_OFF:
515 			*enable = false;
516 			break;
517 		case OPMODE_ON:
518 			*enable = true;
519 			break;
520 		default:
521 			return -EINVAL;
522 		}
523 	} else if (op == PMIC_OP_SET) {
524 		if (*enable)
525 			on_off = OPMODE_ON;
526 		else
527 			on_off = OPMODE_OFF;
528 
529 		ret = max77686_ldo_mode(dev, op, &on_off);
530 		if (ret)
531 			return ret;
532 	}
533 
534 	return 0;
535 }
536 
537 static int max77686_buck_mode(struct udevice *dev, int op, int *opmode)
538 {
539 	unsigned int mask, adr, mode, mode_shift;
540 	unsigned char val;
541 	int buck, ret;
542 
543 	buck = dev->driver_data;
544 	if (buck < 1 || buck > MAX77686_BUCK_NUM) {
545 		pr_err("Wrong buck number: %d", buck);
546 		return -EINVAL;
547 	}
548 
549 	adr = max77686_buck_ctrl[buck];
550 
551 	/* mask */
552 	switch (buck) {
553 	case 2:
554 	case 3:
555 	case 4:
556 		mode_shift = MAX77686_BUCK_MODE_SHIFT_2;
557 		break;
558 	default:
559 		mode_shift = MAX77686_BUCK_MODE_SHIFT_1;
560 	}
561 
562 	mask = MAX77686_BUCK_MODE_MASK << mode_shift;
563 
564 	ret = pmic_read(dev->parent, adr, &val, 1);
565 	if (ret)
566 		return ret;
567 
568 	if (op == PMIC_OP_GET) {
569 		val &= mask;
570 		val >>= mode_shift;
571 		ret = max77686_buck_hex2mode(buck, val);
572 		if (ret < 0)
573 			return ret;
574 		*opmode = ret;
575 		return 0;
576 	}
577 
578 	/* mode */
579 	switch (*opmode) {
580 	case OPMODE_OFF:
581 		mode = MAX77686_BUCK_MODE_OFF;
582 		break;
583 	case OPMODE_STANDBY:
584 		switch (buck) {
585 		case 1:
586 		case 2:
587 		case 3:
588 		case 4:
589 			mode = MAX77686_BUCK_MODE_STANDBY << mode_shift;
590 			break;
591 		default:
592 			mode = 0xff;
593 		}
594 		break;
595 	case OPMODE_LPM:
596 		switch (buck) {
597 		case 2:
598 		case 3:
599 		case 4:
600 			mode = MAX77686_BUCK_MODE_LPM << mode_shift;
601 			break;
602 		default:
603 			mode = 0xff;
604 		}
605 		break;
606 	case OPMODE_ON:
607 		mode = MAX77686_BUCK_MODE_ON << mode_shift;
608 		break;
609 	default:
610 		mode = 0xff;
611 	}
612 
613 	if (mode == 0xff) {
614 		pr_err("Wrong mode: %d for buck: %d\n", *opmode, buck);
615 		return -EINVAL;
616 	}
617 
618 	val &= ~mask;
619 	val |= mode;
620 	ret = pmic_write(dev->parent, adr, &val, 1);
621 
622 	return ret;
623 }
624 
625 static int max77686_buck_enable(struct udevice *dev, int op, bool *enable)
626 {
627 	int ret, on_off;
628 
629 	if (op == PMIC_OP_GET) {
630 		ret = max77686_buck_mode(dev, op, &on_off);
631 		if (ret)
632 			return ret;
633 
634 		switch (on_off) {
635 		case OPMODE_OFF:
636 			*enable = false;
637 			break;
638 		case OPMODE_ON:
639 			*enable = true;
640 			break;
641 		default:
642 			return -EINVAL;
643 		}
644 	} else if (op == PMIC_OP_SET) {
645 		if (*enable)
646 			on_off = OPMODE_ON;
647 		else
648 			on_off = OPMODE_OFF;
649 
650 		ret = max77686_buck_mode(dev, op, &on_off);
651 		if (ret)
652 			return ret;
653 	}
654 
655 	return 0;
656 }
657 
658 static int max77686_ldo_probe(struct udevice *dev)
659 {
660 	struct dm_regulator_uclass_platdata *uc_pdata;
661 
662 	uc_pdata = dev_get_uclass_platdata(dev);
663 
664 	uc_pdata->type = REGULATOR_TYPE_LDO;
665 	uc_pdata->mode_count = max77686_ldo_modes(dev->driver_data,
666 						  &uc_pdata->mode, dev);
667 
668 	return 0;
669 }
670 
671 static int ldo_get_value(struct udevice *dev)
672 {
673 	int uV;
674 	int ret;
675 
676 	ret = max77686_ldo_val(dev, PMIC_OP_GET, &uV);
677 	if (ret)
678 		return ret;
679 
680 	return uV;
681 }
682 
683 static int ldo_set_value(struct udevice *dev, int uV)
684 {
685 	return max77686_ldo_val(dev, PMIC_OP_SET, &uV);
686 }
687 
688 static int ldo_get_enable(struct udevice *dev)
689 {
690 	bool enable = false;
691 	int ret;
692 
693 	ret = max77686_ldo_enable(dev, PMIC_OP_GET, &enable);
694 	if (ret)
695 		return ret;
696 
697 	return enable;
698 }
699 
700 static int ldo_set_enable(struct udevice *dev, bool enable)
701 {
702 	return max77686_ldo_enable(dev, PMIC_OP_SET, &enable);
703 }
704 
705 static int ldo_get_mode(struct udevice *dev)
706 {
707 	int mode;
708 	int ret;
709 
710 	ret = max77686_ldo_mode(dev, PMIC_OP_GET, &mode);
711 	if (ret)
712 		return ret;
713 
714 	return mode;
715 }
716 
717 static int ldo_set_mode(struct udevice *dev, int mode)
718 {
719 	return max77686_ldo_mode(dev, PMIC_OP_SET, &mode);
720 }
721 
722 static int max77686_buck_probe(struct udevice *dev)
723 {
724 	struct dm_regulator_uclass_platdata *uc_pdata;
725 
726 	uc_pdata = dev_get_uclass_platdata(dev);
727 
728 	uc_pdata->type = REGULATOR_TYPE_BUCK;
729 	uc_pdata->mode_count = max77686_buck_modes(dev->driver_data,
730 						   &uc_pdata->mode);
731 
732 	return 0;
733 }
734 
735 static int buck_get_value(struct udevice *dev)
736 {
737 	int uV;
738 	int ret;
739 
740 	ret = max77686_buck_val(dev, PMIC_OP_GET, &uV);
741 	if (ret)
742 		return ret;
743 
744 	return uV;
745 }
746 
747 static int buck_set_value(struct udevice *dev, int uV)
748 {
749 	return max77686_buck_val(dev, PMIC_OP_SET, &uV);
750 }
751 
752 static int buck_get_enable(struct udevice *dev)
753 {
754 	bool enable = false;
755 	int ret;
756 
757 	ret = max77686_buck_enable(dev, PMIC_OP_GET, &enable);
758 	if (ret)
759 		return ret;
760 
761 	return enable;
762 }
763 
764 static int buck_set_enable(struct udevice *dev, bool enable)
765 {
766 	return max77686_buck_enable(dev, PMIC_OP_SET, &enable);
767 }
768 
769 static int buck_get_mode(struct udevice *dev)
770 {
771 	int mode;
772 	int ret;
773 
774 	ret = max77686_buck_mode(dev, PMIC_OP_GET, &mode);
775 	if (ret)
776 		return ret;
777 
778 	return mode;
779 }
780 
781 static int buck_set_mode(struct udevice *dev, int mode)
782 {
783 	return max77686_buck_mode(dev, PMIC_OP_SET, &mode);
784 }
785 
786 static const struct dm_regulator_ops max77686_ldo_ops = {
787 	.get_value  = ldo_get_value,
788 	.set_value  = ldo_set_value,
789 	.get_enable = ldo_get_enable,
790 	.set_enable = ldo_set_enable,
791 	.get_mode   = ldo_get_mode,
792 	.set_mode   = ldo_set_mode,
793 };
794 
795 U_BOOT_DRIVER(max77686_ldo) = {
796 	.name = MAX77686_LDO_DRIVER,
797 	.id = UCLASS_REGULATOR,
798 	.ops = &max77686_ldo_ops,
799 	.probe = max77686_ldo_probe,
800 };
801 
802 static const struct dm_regulator_ops max77686_buck_ops = {
803 	.get_value  = buck_get_value,
804 	.set_value  = buck_set_value,
805 	.get_enable = buck_get_enable,
806 	.set_enable = buck_set_enable,
807 	.get_mode   = buck_get_mode,
808 	.set_mode   = buck_set_mode,
809 };
810 
811 U_BOOT_DRIVER(max77686_buck) = {
812 	.name = MAX77686_BUCK_DRIVER,
813 	.id = UCLASS_REGULATOR,
814 	.ops = &max77686_buck_ops,
815 	.probe = max77686_buck_probe,
816 };
817