git.sur5r.net Git - u-boot/blob - drivers/power/regulator/max77686.c

   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         int hex = 0;
  75         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         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         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 adr;
 323         unsigned char val;
 324         int hex, 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 mask, adr;
 364         unsigned char val;
 365         int hex, 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 = false;
 519                         break;
 520                 case OPMODE_ON:
 521                         *enable = true;
 522                         break;
 523                 default:
 524                         return -EINVAL;
 525                 }
 526         } else if (op == PMIC_OP_SET) {
 527                 if (*enable)
 528                         on_off = OPMODE_ON;
 529                 else
 530                         on_off = OPMODE_OFF;
 531
 532                 ret = max77686_ldo_mode(dev, op, &on_off);
 533                 if (ret)
 534                         return ret;
 535         }
 536
 537         return 0;
 538 }
 539
 540 static int max77686_buck_mode(struct udevice *dev, int op, int *opmode)
 541 {
 542         unsigned int mask, adr, mode, mode_shift;
 543         unsigned char val;
 544         int buck, ret;
 545
 546         buck = dev->driver_data;
 547         if (buck < 1 || buck > MAX77686_BUCK_NUM) {
 548                 error("Wrong buck number: %d", buck);
 549                 return -EINVAL;
 550         }
 551
 552         adr = max77686_buck_ctrl[buck];
 553
 554         /* mask */
 555         switch (buck) {
 556         case 2:
 557         case 3:
 558         case 4:
 559                 mode_shift = MAX77686_BUCK_MODE_SHIFT_2;
 560                 break;
 561         default:
 562                 mode_shift = MAX77686_BUCK_MODE_SHIFT_1;
 563         }
 564
 565         mask = MAX77686_BUCK_MODE_MASK << mode_shift;
 566
 567         ret = pmic_read(dev->parent, adr, &val, 1);
 568         if (ret)
 569                 return ret;
 570
 571         if (op == PMIC_OP_GET) {
 572                 val &= mask;
 573                 val >>= mode_shift;
 574                 ret = max77686_buck_hex2mode(buck, val);
 575                 if (ret < 0)
 576                         return ret;
 577                 *opmode = ret;
 578                 return 0;
 579         }
 580
 581         /* mode */
 582         switch (*opmode) {
 583         case OPMODE_OFF:
 584                 mode = MAX77686_BUCK_MODE_OFF;
 585                 break;
 586         case OPMODE_STANDBY:
 587                 switch (buck) {
 588                 case 1:
 589                 case 2:
 590                 case 3:
 591                 case 4:
 592                         mode = MAX77686_BUCK_MODE_STANDBY << mode_shift;
 593                         break;
 594                 default:
 595                         mode = 0xff;
 596                 }
 597                 break;
 598         case OPMODE_LPM:
 599                 switch (buck) {
 600                 case 2:
 601                 case 3:
 602                 case 4:
 603                         mode = MAX77686_BUCK_MODE_LPM << mode_shift;
 604                         break;
 605                 default:
 606                         mode = 0xff;
 607                 }
 608                 break;
 609         case OPMODE_ON:
 610                 mode = MAX77686_BUCK_MODE_ON << mode_shift;
 611                 break;
 612         default:
 613                 mode = 0xff;
 614         }
 615
 616         if (mode == 0xff) {
 617                 error("Wrong mode: %d for buck: %d\n", *opmode, buck);
 618                 return -EINVAL;
 619         }
 620
 621         val &= ~mask;
 622         val |= mode;
 623         ret = pmic_write(dev->parent, adr, &val, 1);
 624
 625         return ret;
 626 }
 627
 628 static int max77686_buck_enable(struct udevice *dev, int op, bool *enable)
 629 {
 630         int ret, on_off;
 631
 632         if (op == PMIC_OP_GET) {
 633                 ret = max77686_buck_mode(dev, op, &on_off);
 634                 if (ret)
 635                         return ret;
 636
 637                 switch (on_off) {
 638                 case OPMODE_OFF:
 639                         *enable = false;
 640                         break;
 641                 case OPMODE_ON:
 642                         *enable = true;
 643                         break;
 644                 default:
 645                         return -EINVAL;
 646                 }
 647         } else if (op == PMIC_OP_SET) {
 648                 if (*enable)
 649                         on_off = OPMODE_ON;
 650                 else
 651                         on_off = OPMODE_OFF;
 652
 653                 ret = max77686_buck_mode(dev, op, &on_off);
 654                 if (ret)
 655                         return ret;
 656         }
 657
 658         return 0;
 659 }
 660
 661 static int max77686_ldo_probe(struct udevice *dev)
 662 {
 663         struct dm_regulator_uclass_platdata *uc_pdata;
 664
 665         uc_pdata = dev_get_uclass_platdata(dev);
 666
 667         uc_pdata->type = REGULATOR_TYPE_LDO;
 668         uc_pdata->mode_count = max77686_ldo_modes(dev->driver_data,
 669                                                   &uc_pdata->mode, dev);
 670
 671         return 0;
 672 }
 673
 674 static int ldo_get_value(struct udevice *dev)
 675 {
 676         int uV;
 677         int ret;
 678
 679         ret = max77686_ldo_val(dev, PMIC_OP_GET, &uV);
 680         if (ret)
 681                 return ret;
 682
 683         return uV;
 684 }
 685
 686 static int ldo_set_value(struct udevice *dev, int uV)
 687 {
 688         return max77686_ldo_val(dev, PMIC_OP_SET, &uV);
 689 }
 690
 691 static int ldo_get_enable(struct udevice *dev)
 692 {
 693         bool enable = false;
 694         int ret;
 695
 696         ret = max77686_ldo_enable(dev, PMIC_OP_GET, &enable);
 697         if (ret)
 698                 return ret;
 699
 700         return enable;
 701 }
 702
 703 static int ldo_set_enable(struct udevice *dev, bool enable)
 704 {
 705         return max77686_ldo_enable(dev, PMIC_OP_SET, &enable);
 706 }
 707
 708 static int ldo_get_mode(struct udevice *dev)
 709 {
 710         int mode;
 711         int ret;
 712
 713         ret = max77686_ldo_mode(dev, PMIC_OP_GET, &mode);
 714         if (ret)
 715                 return ret;
 716
 717         return mode;
 718 }
 719
 720 static int ldo_set_mode(struct udevice *dev, int mode)
 721 {
 722         return max77686_ldo_mode(dev, PMIC_OP_SET, &mode);
 723 }
 724
 725 static int max77686_buck_probe(struct udevice *dev)
 726 {
 727         struct dm_regulator_uclass_platdata *uc_pdata;
 728
 729         uc_pdata = dev_get_uclass_platdata(dev);
 730
 731         uc_pdata->type = REGULATOR_TYPE_BUCK;
 732         uc_pdata->mode_count = max77686_buck_modes(dev->driver_data,
 733                                                    &uc_pdata->mode);
 734
 735         return 0;
 736 }
 737
 738 static int buck_get_value(struct udevice *dev)
 739 {
 740         int uV;
 741         int ret;
 742
 743         ret = max77686_buck_val(dev, PMIC_OP_GET, &uV);
 744         if (ret)
 745                 return ret;
 746
 747         return uV;
 748 }
 749
 750 static int buck_set_value(struct udevice *dev, int uV)
 751 {
 752         return max77686_buck_val(dev, PMIC_OP_SET, &uV);
 753 }
 754
 755 static int buck_get_enable(struct udevice *dev)
 756 {
 757         bool enable = false;
 758         int ret;
 759
 760         ret = max77686_buck_enable(dev, PMIC_OP_GET, &enable);
 761         if (ret)
 762                 return ret;
 763
 764         return enable;
 765 }
 766
 767 static int buck_set_enable(struct udevice *dev, bool enable)
 768 {
 769         return max77686_buck_enable(dev, PMIC_OP_SET, &enable);
 770 }
 771
 772 static int buck_get_mode(struct udevice *dev)
 773 {
 774         int mode;
 775         int ret;
 776
 777         ret = max77686_buck_mode(dev, PMIC_OP_GET, &mode);
 778         if (ret)
 779                 return ret;
 780
 781         return mode;
 782 }
 783
 784 static int buck_set_mode(struct udevice *dev, int mode)
 785 {
 786         return max77686_buck_mode(dev, PMIC_OP_SET, &mode);
 787 }
 788
 789 static const struct dm_regulator_ops max77686_ldo_ops = {
 790         .get_value  = ldo_get_value,
 791         .set_value  = ldo_set_value,
 792         .get_enable = ldo_get_enable,
 793         .set_enable = ldo_set_enable,
 794         .get_mode   = ldo_get_mode,
 795         .set_mode   = ldo_set_mode,
 796 };
 797
 798 U_BOOT_DRIVER(max77686_ldo) = {
 799         .name = MAX77686_LDO_DRIVER,
 800         .id = UCLASS_REGULATOR,
 801         .ops = &max77686_ldo_ops,
 802         .probe = max77686_ldo_probe,
 803 };
 804
 805 static const struct dm_regulator_ops max77686_buck_ops = {
 806         .get_value  = buck_get_value,
 807         .set_value  = buck_set_value,
 808         .get_enable = buck_get_enable,
 809         .set_enable = buck_set_enable,
 810         .get_mode   = buck_get_mode,
 811         .set_mode   = buck_set_mode,
 812 };
 813
 814 U_BOOT_DRIVER(max77686_buck) = {
 815         .name = MAX77686_BUCK_DRIVER,
 816         .id = UCLASS_REGULATOR,
 817         .ops = &max77686_buck_ops,
 818         .probe = max77686_buck_probe,
 819 };