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