drivers/power/regulator/s2mps11_regulator.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *  Copyright (C) 2018 Samsung Electronics
   4  *  Jaehoon Chung <jh80.chung@samsung.com>
   5  */
   6
   7 #include <common.h>
   8 #include <fdtdec.h>
   9 #include <errno.h>
  10 #include <dm.h>
  11 #include <i2c.h>
  12 #include <power/pmic.h>
  13 #include <power/regulator.h>
  14 #include <power/s2mps11.h>
  15
  16 #define MODE(_id, _val, _name) { \
  17         .id = _id, \
  18         .register_value = _val, \
  19         .name = _name, \
  20 }
  21
  22 /* BUCK : 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 */
  23 static struct dm_regulator_mode s2mps11_buck_modes[] = {
  24         MODE(OP_OFF, S2MPS11_BUCK_MODE_OFF, "OFF"),
  25         MODE(OP_STANDBY, S2MPS11_BUCK_MODE_STANDBY, "ON/OFF"),
  26         MODE(OP_ON, S2MPS11_BUCK_MODE_STANDBY, "ON"),
  27 };
  28
  29 static struct dm_regulator_mode s2mps11_ldo_modes[] = {
  30         MODE(OP_OFF, S2MPS11_LDO_MODE_OFF, "OFF"),
  31         MODE(OP_STANDBY, S2MPS11_LDO_MODE_STANDBY, "ON/OFF"),
  32         MODE(OP_STANDBY_LPM, S2MPS11_LDO_MODE_STANDBY_LPM, "ON/LPM"),
  33         MODE(OP_ON, S2MPS11_LDO_MODE_ON, "ON"),
  34 };
  35
  36 static const char s2mps11_buck_ctrl[] = {
  37         0xff, 0x25, 0x27, 0x29, 0x2b, 0x2d, 0x33, 0x35, 0x37, 0x39, 0x3b
  38 };
  39
  40 static const char s2mps11_buck_out[] = {
  41         0xff, 0x26, 0x28, 0x2a, 0x2c, 0x2f, 0x34, 0x36, 0x38, 0x3a, 0x3c
  42 };
  43
  44 static int s2mps11_buck_hex2volt(int buck, int hex)
  45 {
  46         unsigned int uV = 0;
  47
  48         if (hex < 0)
  49                 goto bad;
  50
  51         switch (buck) {
  52         case 7:
  53         case 8:
  54         case 10:
  55                 if (hex > S2MPS11_BUCK7_8_10_VOLT_MAX_HEX)
  56                         goto bad;
  57
  58                 uV = hex * S2MPS11_BUCK_HSTEP + S2MPS11_BUCK_UV_HMIN;
  59                 break;
  60         case 9:
  61                 if (hex > S2MPS11_BUCK9_VOLT_MAX_HEX)
  62                         goto bad;
  63                 uV = hex * S2MPS11_BUCK9_STEP * 2 + S2MPS11_BUCK9_UV_MIN;
  64                 break;
  65         default:
  66                 if (buck == 5 && hex > S2MPS11_BUCK5_VOLT_MAX_HEX)
  67                         goto bad;
  68                 else if (buck != 5 && hex > S2MPS11_BUCK_VOLT_MAX_HEX)
  69                         goto bad;
  70
  71                 uV = hex * S2MPS11_BUCK_LSTEP + S2MPS11_BUCK_UV_MIN;
  72                 break;
  73         }
  74
  75         return uV;
  76 bad:
  77         pr_err("Value: %#x is wrong for BUCK%d", hex, buck);
  78         return -EINVAL;
  79 }
  80
  81 static int s2mps11_buck_volt2hex(int buck, int uV)
  82 {
  83         int hex;
  84
  85         switch (buck) {
  86         case 7:
  87         case 8:
  88         case 10:
  89                 hex = (uV - S2MPS11_BUCK_UV_HMIN) / S2MPS11_BUCK_HSTEP;
  90                 if (hex > S2MPS11_BUCK7_8_10_VOLT_MAX_HEX)
  91                         goto bad;
  92
  93                 break;
  94         case 9:
  95                 hex = (uV - S2MPS11_BUCK9_UV_MIN) / S2MPS11_BUCK9_STEP;
  96                 if (hex > S2MPS11_BUCK9_VOLT_MAX_HEX)
  97                         goto bad;
  98                 break;
  99         default:
 100                 hex = (uV - S2MPS11_BUCK_UV_MIN) / S2MPS11_BUCK_LSTEP;
 101                 if (buck == 5 && hex > S2MPS11_BUCK5_VOLT_MAX_HEX)
 102                         goto bad;
 103                 else if (buck != 5 && hex > S2MPS11_BUCK_VOLT_MAX_HEX)
 104                         goto bad;
 105                 break;
 106         };
 107
 108         if (hex >= 0)
 109                 return hex;
 110
 111 bad:
 112         pr_err("Value: %d uV is wrong for BUCK%d", uV, buck);
 113         return -EINVAL;
 114 }
 115
 116 static int s2mps11_buck_val(struct udevice *dev, int op, int *uV)
 117 {
 118         int hex, buck, ret;
 119         u32 mask, addr;
 120         u8 val;
 121
 122         buck = dev->driver_data;
 123         if (buck < 1 || buck > S2MPS11_BUCK_NUM) {
 124                 pr_err("Wrong buck number: %d\n", buck);
 125                 return -EINVAL;
 126         }
 127
 128         if (op == PMIC_OP_GET)
 129                 *uV = 0;
 130
 131         addr = s2mps11_buck_out[buck];
 132
 133         switch (buck) {
 134         case 9:
 135                 mask = S2MPS11_BUCK9_VOLT_MASK;
 136                 break;
 137         default:
 138                 mask = S2MPS11_BUCK_VOLT_MASK;
 139                 break;
 140         }
 141
 142         ret = pmic_read(dev->parent, addr, &val, 1);
 143         if (ret)
 144                 return ret;
 145
 146         if (op == PMIC_OP_GET) {
 147                 val &= mask;
 148                 ret = s2mps11_buck_hex2volt(buck, val);
 149                 if (ret < 0)
 150                         return ret;
 151                 *uV = ret;
 152                 return 0;
 153         }
 154
 155         hex = s2mps11_buck_volt2hex(buck, *uV);
 156         if (hex < 0)
 157                 return hex;
 158
 159         val &= ~mask;
 160         val |= hex;
 161         ret = pmic_write(dev->parent, addr, &val, 1);
 162
 163         return ret;
 164 }
 165
 166 static int s2mps11_buck_mode(struct udevice *dev, int op, int *opmode)
 167 {
 168         unsigned int addr, mode;
 169         unsigned char val;
 170         int buck, ret;
 171
 172         buck = dev->driver_data;
 173         if (buck < 1 || buck > S2MPS11_BUCK_NUM) {
 174                 pr_err("Wrong buck number: %d\n", buck);
 175                 return -EINVAL;
 176         }
 177
 178         addr = s2mps11_buck_ctrl[buck];
 179
 180         ret = pmic_read(dev->parent, addr, &val, 1);
 181         if (ret)
 182                 return ret;
 183
 184         if (op == PMIC_OP_GET) {
 185                 val &= (S2MPS11_BUCK_MODE_MASK << S2MPS11_BUCK_MODE_SHIFT);
 186                 switch (val) {
 187                 case S2MPS11_BUCK_MODE_OFF:
 188                         *opmode = OP_OFF;
 189                         break;
 190                 case S2MPS11_BUCK_MODE_STANDBY:
 191                         *opmode = OP_STANDBY;
 192                         break;
 193                 case S2MPS11_BUCK_MODE_ON:
 194                         *opmode = OP_ON;
 195                         break;
 196                 default:
 197                         return -EINVAL;
 198                 }
 199                 return 0;
 200         }
 201
 202         switch (*opmode) {
 203         case OP_OFF:
 204                 mode = S2MPS11_BUCK_MODE_OFF;
 205                 break;
 206         case OP_STANDBY:
 207                 mode = S2MPS11_BUCK_MODE_STANDBY;
 208                 break;
 209         case OP_ON:
 210                 mode = S2MPS11_BUCK_MODE_ON;
 211                 break;
 212         default:
 213                 pr_err("Wrong mode: %d for buck: %d\n", *opmode, buck);
 214                 return -EINVAL;
 215         }
 216
 217         val &= ~(S2MPS11_BUCK_MODE_MASK << S2MPS11_BUCK_MODE_SHIFT);
 218         val |= mode;
 219         ret = pmic_write(dev->parent, addr, &val, 1);
 220
 221         return ret;
 222 }
 223
 224 static int s2mps11_buck_enable(struct udevice *dev, int op, bool *enable)
 225 {
 226         int ret, on_off;
 227
 228         if (op == PMIC_OP_GET) {
 229                 ret = s2mps11_buck_mode(dev, op, &on_off);
 230                 if (ret)
 231                         return ret;
 232                 switch (on_off) {
 233                 case OP_OFF:
 234                         *enable = false;
 235                         break;
 236                 case OP_ON:
 237                         *enable = true;
 238                         break;
 239                 default:
 240                         return -EINVAL;
 241                 }
 242         } else if (op == PMIC_OP_SET) {
 243                 if (*enable)
 244                         on_off = OP_ON;
 245                 else
 246                         on_off = OP_OFF;
 247
 248                 ret = s2mps11_buck_mode(dev, op, &on_off);
 249                 if (ret)
 250                         return ret;
 251         }
 252
 253         return 0;
 254 }
 255
 256 static int buck_get_value(struct udevice *dev)
 257 {
 258         int uV;
 259         int ret;
 260
 261         ret = s2mps11_buck_val(dev, PMIC_OP_GET, &uV);
 262         if (ret)
 263                 return ret;
 264         return uV;
 265 }
 266
 267 static int buck_set_value(struct udevice *dev, int uV)
 268 {
 269         return s2mps11_buck_val(dev, PMIC_OP_SET, &uV);
 270 }
 271
 272 static int buck_get_enable(struct udevice *dev)
 273 {
 274         bool enable = false;
 275         int ret;
 276
 277         ret = s2mps11_buck_enable(dev, PMIC_OP_GET, &enable);
 278         if (ret)
 279                 return ret;
 280         return enable;
 281 }
 282
 283 static int buck_set_enable(struct udevice *dev, bool enable)
 284 {
 285         return s2mps11_buck_enable(dev, PMIC_OP_SET, &enable);
 286 }
 287
 288 static int buck_get_mode(struct udevice *dev)
 289 {
 290         int mode;
 291         int ret;
 292
 293         ret = s2mps11_buck_mode(dev, PMIC_OP_GET, &mode);
 294         if (ret)
 295                 return ret;
 296
 297         return mode;
 298 }
 299
 300 static int buck_set_mode(struct udevice *dev, int mode)
 301 {
 302         return s2mps11_buck_mode(dev, PMIC_OP_SET, &mode);
 303 }
 304
 305 static int s2mps11_buck_probe(struct udevice *dev)
 306 {
 307         struct dm_regulator_uclass_platdata *uc_pdata;
 308
 309         uc_pdata = dev_get_uclass_platdata(dev);
 310
 311         uc_pdata->type = REGULATOR_TYPE_BUCK;
 312         uc_pdata->mode = s2mps11_buck_modes;
 313         uc_pdata->mode_count = ARRAY_SIZE(s2mps11_buck_modes);
 314
 315         return 0;
 316 }
 317
 318 static const struct dm_regulator_ops s2mps11_buck_ops = {
 319         .get_value      = buck_get_value,
 320         .set_value      = buck_set_value,
 321         .get_enable     = buck_get_enable,
 322         .set_enable     = buck_set_enable,
 323         .get_mode       = buck_get_mode,
 324         .set_mode       = buck_set_mode,
 325 };
 326
 327 U_BOOT_DRIVER(s2mps11_buck) = {
 328         .name = S2MPS11_BUCK_DRIVER,
 329         .id = UCLASS_REGULATOR,
 330         .ops = &s2mps11_buck_ops,
 331         .probe = s2mps11_buck_probe,
 332 };
 333
 334 static int s2mps11_ldo_hex2volt(int ldo, int hex)
 335 {
 336         unsigned int uV = 0;
 337
 338         if (hex > S2MPS11_LDO_VOLT_MAX_HEX) {
 339                 pr_err("Value: %#x is wrong for LDO%d", hex, ldo);
 340                 return -EINVAL;
 341         }
 342
 343         switch (ldo) {
 344         case 1:
 345         case 6:
 346         case 11:
 347         case 22:
 348         case 23:
 349                 uV = hex * S2MPS11_LDO_STEP + S2MPS11_LDO_UV_MIN;
 350                 break;
 351         default:
 352                 uV = hex * S2MPS11_LDO_STEP * 2 + S2MPS11_LDO_UV_MIN;
 353                 break;
 354         }
 355
 356         return uV;
 357 }
 358
 359 static int s2mps11_ldo_volt2hex(int ldo, int uV)
 360 {
 361         int hex = 0;
 362
 363         switch (ldo) {
 364         case 1:
 365         case 6:
 366         case 11:
 367         case 22:
 368         case 23:
 369                 hex = (uV - S2MPS11_LDO_UV_MIN) / S2MPS11_LDO_STEP;
 370                 break;
 371         default:
 372                 hex = (uV - S2MPS11_LDO_UV_MIN) / (S2MPS11_LDO_STEP * 2);
 373                 break;
 374         }
 375
 376         if (hex >= 0 && hex <= S2MPS11_LDO_VOLT_MAX_HEX)
 377                 return hex;
 378
 379         pr_err("Value: %d uV is wrong for LDO%d", uV, ldo);
 380         return -EINVAL;
 381
 382         return 0;
 383 }
 384
 385 static int s2mps11_ldo_val(struct udevice *dev, int op, int *uV)
 386 {
 387         unsigned int addr;
 388         unsigned char val;
 389         int hex, ldo, ret;
 390
 391         ldo = dev->driver_data;
 392         if (ldo < 1 || ldo > S2MPS11_LDO_NUM) {
 393                 pr_err("Wrong ldo number: %d\n", ldo);
 394                 return -EINVAL;
 395         }
 396
 397         addr = S2MPS11_REG_L1CTRL + ldo - 1;
 398
 399         ret = pmic_read(dev->parent, addr, &val, 1);
 400         if (ret)
 401                 return ret;
 402
 403         if (op == PMIC_OP_GET) {
 404                 *uV = 0;
 405                 val &= S2MPS11_LDO_VOLT_MASK;
 406                 ret = s2mps11_ldo_hex2volt(ldo, val);
 407                 if (ret < 0)
 408                         return ret;
 409
 410                 *uV = ret;
 411                 return 0;
 412         }
 413
 414         hex = s2mps11_ldo_volt2hex(ldo, *uV);
 415         if (hex < 0)
 416                 return hex;
 417
 418         val &= ~S2MPS11_LDO_VOLT_MASK;
 419         val |= hex;
 420         ret = pmic_write(dev->parent, addr, &val, 1);
 421
 422         return ret;
 423 }
 424
 425 static int s2mps11_ldo_mode(struct udevice *dev, int op, int *opmode)
 426 {
 427         unsigned int addr, mode;
 428         unsigned char val;
 429         int ldo, ret;
 430
 431         ldo = dev->driver_data;
 432         if (ldo < 1 || ldo > S2MPS11_LDO_NUM) {
 433                 pr_err("Wrong ldo number: %d\n", ldo);
 434                 return -EINVAL;
 435         }
 436         addr = S2MPS11_REG_L1CTRL + ldo - 1;
 437
 438         ret = pmic_read(dev->parent, addr, &val, 1);
 439         if (ret)
 440                 return ret;
 441
 442         if (op == PMIC_OP_GET) {
 443                 val &= (S2MPS11_LDO_MODE_MASK << S2MPS11_LDO_MODE_SHIFT);
 444                 switch (val) {
 445                 case S2MPS11_LDO_MODE_OFF:
 446                         *opmode = OP_OFF;
 447                         break;
 448                 case S2MPS11_LDO_MODE_STANDBY:
 449                         *opmode = OP_STANDBY;
 450                         break;
 451                 case S2MPS11_LDO_MODE_STANDBY_LPM:
 452                         *opmode = OP_STANDBY_LPM;
 453                         break;
 454                 case S2MPS11_LDO_MODE_ON:
 455                         *opmode = OP_ON;
 456                         break;
 457                 default:
 458                         return -EINVAL;
 459                 }
 460                 return 0;
 461         }
 462
 463         switch (*opmode) {
 464         case OP_OFF:
 465                 mode = S2MPS11_LDO_MODE_OFF;
 466                 break;
 467         case OP_STANDBY:
 468                 mode = S2MPS11_LDO_MODE_STANDBY;
 469                 break;
 470         case OP_STANDBY_LPM:
 471                 mode = S2MPS11_LDO_MODE_STANDBY_LPM;
 472                 break;
 473         case OP_ON:
 474                 mode = S2MPS11_LDO_MODE_ON;
 475                 break;
 476         default:
 477                 pr_err("Wrong mode: %d for ldo: %d\n", *opmode, ldo);
 478                 return -EINVAL;
 479         }
 480
 481         val &= ~(S2MPS11_LDO_MODE_MASK << S2MPS11_LDO_MODE_SHIFT);
 482         val |= mode;
 483         ret = pmic_write(dev->parent, addr, &val, 1);
 484
 485         return ret;
 486 }
 487
 488 static int s2mps11_ldo_enable(struct udevice *dev, int op, bool *enable)
 489 {
 490         int ret, on_off;
 491
 492         if (op == PMIC_OP_GET) {
 493                 ret = s2mps11_ldo_mode(dev, op, &on_off);
 494                 if (ret)
 495                         return ret;
 496                 switch (on_off) {
 497                 case OP_OFF:
 498                         *enable = false;
 499                         break;
 500                 case OP_ON:
 501                         *enable = true;
 502                         break;
 503                 default:
 504                         return -EINVAL;
 505                 }
 506         } else if (op == PMIC_OP_SET) {
 507                 if (*enable)
 508                         on_off = OP_ON;
 509                 else
 510                         on_off = OP_OFF;
 511
 512                 ret = s2mps11_ldo_mode(dev, op, &on_off);
 513                 if (ret)
 514                         return ret;
 515         }
 516
 517         return 0;
 518 }
 519
 520 static int ldo_get_value(struct udevice *dev)
 521 {
 522         int uV;
 523         int ret;
 524
 525         ret = s2mps11_ldo_val(dev, PMIC_OP_GET, &uV);
 526         if (ret)
 527                 return ret;
 528
 529         return uV;
 530 }
 531
 532 static int ldo_set_value(struct udevice *dev, int uV)
 533 {
 534         return s2mps11_ldo_val(dev, PMIC_OP_SET, &uV);
 535 }
 536
 537 static int ldo_get_enable(struct udevice *dev)
 538 {
 539         bool enable = false;
 540         int ret;
 541
 542         ret = s2mps11_ldo_enable(dev, PMIC_OP_GET, &enable);
 543         if (ret)
 544                 return ret;
 545         return enable;
 546 }
 547
 548 static int ldo_set_enable(struct udevice *dev, bool enable)
 549 {
 550         return s2mps11_ldo_enable(dev, PMIC_OP_SET, &enable);
 551 }
 552
 553 static int ldo_get_mode(struct udevice *dev)
 554 {
 555         int mode, ret;
 556
 557         ret = s2mps11_ldo_mode(dev, PMIC_OP_GET, &mode);
 558         if (ret)
 559                 return ret;
 560         return mode;
 561 }
 562
 563 static int ldo_set_mode(struct udevice *dev, int mode)
 564 {
 565         return s2mps11_ldo_mode(dev, PMIC_OP_SET, &mode);
 566 }
 567
 568 static int s2mps11_ldo_probe(struct udevice *dev)
 569 {
 570         struct dm_regulator_uclass_platdata *uc_pdata;
 571
 572         uc_pdata = dev_get_uclass_platdata(dev);
 573         uc_pdata->type = REGULATOR_TYPE_LDO;
 574         uc_pdata->mode = s2mps11_ldo_modes;
 575         uc_pdata->mode_count = ARRAY_SIZE(s2mps11_ldo_modes);
 576
 577         return 0;
 578 }
 579
 580 static const struct dm_regulator_ops s2mps11_ldo_ops = {
 581         .get_value      = ldo_get_value,
 582         .set_value      = ldo_set_value,
 583         .get_enable     = ldo_get_enable,
 584         .set_enable     = ldo_set_enable,
 585         .get_mode       = ldo_get_mode,
 586         .set_mode       = ldo_set_mode,
 587 };
 588
 589 U_BOOT_DRIVER(s2mps11_ldo) = {
 590         .name = S2MPS11_LDO_DRIVER,
 591         .id = UCLASS_REGULATOR,
 592         .ops = &s2mps11_ldo_ops,
 593         .probe = s2mps11_ldo_probe,
 594 };