drivers/regulator/max77620-regulator.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Maxim MAX77620 Regulator driver
   4  *
   5  * Copyright (c) 2016-2018, NVIDIA CORPORATION.  All rights reserved.
   6  *
   7  * Author: Mallikarjun Kasoju <mkasoju@nvidia.com>
   8  *      Laxman Dewangan <ldewangan@nvidia.com>
   9  */
  10
  11 #include <linux/init.h>
  12 #include <linux/mfd/max77620.h>
  13 #include <linux/module.h>
  14 #include <linux/of.h>
  15 #include <linux/platform_device.h>
  16 #include <linux/regmap.h>
  17 #include <linux/regulator/driver.h>
  18 #include <linux/regulator/machine.h>
  19 #include <linux/regulator/of_regulator.h>
  20
  21 #define max77620_rails(_name)   "max77620-"#_name
  22
  23 /* Power Mode */
  24 #define MAX77620_POWER_MODE_NORMAL              3
  25 #define MAX77620_POWER_MODE_LPM                 2
  26 #define MAX77620_POWER_MODE_GLPM                1
  27 #define MAX77620_POWER_MODE_DISABLE             0
  28
  29 /* SD Slew Rate */
  30 #define MAX77620_SD_SR_13_75                    0
  31 #define MAX77620_SD_SR_27_5                     1
  32 #define MAX77620_SD_SR_55                       2
  33 #define MAX77620_SD_SR_100                      3
  34
  35 enum max77620_regulators {
  36         MAX77620_REGULATOR_ID_SD0,
  37         MAX77620_REGULATOR_ID_SD1,
  38         MAX77620_REGULATOR_ID_SD2,
  39         MAX77620_REGULATOR_ID_SD3,
  40         MAX77620_REGULATOR_ID_SD4,
  41         MAX77620_REGULATOR_ID_LDO0,
  42         MAX77620_REGULATOR_ID_LDO1,
  43         MAX77620_REGULATOR_ID_LDO2,
  44         MAX77620_REGULATOR_ID_LDO3,
  45         MAX77620_REGULATOR_ID_LDO4,
  46         MAX77620_REGULATOR_ID_LDO5,
  47         MAX77620_REGULATOR_ID_LDO6,
  48         MAX77620_REGULATOR_ID_LDO7,
  49         MAX77620_REGULATOR_ID_LDO8,
  50         MAX77620_NUM_REGS,
  51 };
  52
  53 /* Regulator types */
  54 enum max77620_regulator_type {
  55         MAX77620_REGULATOR_TYPE_SD,
  56         MAX77620_REGULATOR_TYPE_LDO_N,
  57         MAX77620_REGULATOR_TYPE_LDO_P,
  58 };
  59
  60 struct max77620_regulator_info {
  61         u8 type;
  62         u8 fps_addr;
  63         u8 volt_addr;
  64         u8 cfg_addr;
  65         u8 power_mode_mask;
  66         u8 power_mode_shift;
  67         u8 remote_sense_addr;
  68         u8 remote_sense_mask;
  69         struct regulator_desc desc;
  70 };
  71
  72 struct max77620_regulator_pdata {
  73         int active_fps_src;
  74         int active_fps_pd_slot;
  75         int active_fps_pu_slot;
  76         int suspend_fps_src;
  77         int suspend_fps_pd_slot;
  78         int suspend_fps_pu_slot;
  79         int current_mode;
  80         int power_ok;
  81         int ramp_rate_setting;
  82 };
  83
  84 struct max77620_regulator {
  85         struct device *dev;
  86         struct regmap *rmap;
  87         struct max77620_regulator_info *rinfo[MAX77620_NUM_REGS];
  88         struct max77620_regulator_pdata reg_pdata[MAX77620_NUM_REGS];
  89         int enable_power_mode[MAX77620_NUM_REGS];
  90         int current_power_mode[MAX77620_NUM_REGS];
  91         int active_fps_src[MAX77620_NUM_REGS];
  92 };
  93
  94 #define fps_src_name(fps_src)   \
  95         (fps_src == MAX77620_FPS_SRC_0 ? "FPS_SRC_0" :  \
  96         fps_src == MAX77620_FPS_SRC_1 ? "FPS_SRC_1" :   \
  97         fps_src == MAX77620_FPS_SRC_2 ? "FPS_SRC_2" : "FPS_SRC_NONE")
  98
  99 static int max77620_regulator_get_fps_src(struct max77620_regulator *pmic,
 100                                           int id)
 101 {
 102         struct max77620_regulator_info *rinfo = pmic->rinfo[id];
 103         unsigned int val;
 104         int ret;
 105
 106         ret = regmap_read(pmic->rmap, rinfo->fps_addr, &val);
 107         if (ret < 0) {
 108                 dev_err(pmic->dev, "Reg 0x%02x read failed %d\n",
 109                         rinfo->fps_addr, ret);
 110                 return ret;
 111         }
 112
 113         return (val & MAX77620_FPS_SRC_MASK) >> MAX77620_FPS_SRC_SHIFT;
 114 }
 115
 116 static int max77620_regulator_set_fps_src(struct max77620_regulator *pmic,
 117                                           int fps_src, int id)
 118 {
 119         struct max77620_regulator_info *rinfo = pmic->rinfo[id];
 120         unsigned int val;
 121         int ret;
 122
 123         if (!rinfo)
 124                 return 0;
 125
 126         switch (fps_src) {
 127         case MAX77620_FPS_SRC_0:
 128         case MAX77620_FPS_SRC_1:
 129         case MAX77620_FPS_SRC_2:
 130         case MAX77620_FPS_SRC_NONE:
 131                 break;
 132
 133         case MAX77620_FPS_SRC_DEF:
 134                 ret = regmap_read(pmic->rmap, rinfo->fps_addr, &val);
 135                 if (ret < 0) {
 136                         dev_err(pmic->dev, "Reg 0x%02x read failed %d\n",
 137                                 rinfo->fps_addr, ret);
 138                         return ret;
 139                 }
 140                 ret = (val & MAX77620_FPS_SRC_MASK) >> MAX77620_FPS_SRC_SHIFT;
 141                 pmic->active_fps_src[id] = ret;
 142                 return 0;
 143
 144         default:
 145                 dev_err(pmic->dev, "Invalid FPS %d for regulator %d\n",
 146                         fps_src, id);
 147                 return -EINVAL;
 148         }
 149
 150         ret = regmap_update_bits(pmic->rmap, rinfo->fps_addr,
 151                                  MAX77620_FPS_SRC_MASK,
 152                                  fps_src << MAX77620_FPS_SRC_SHIFT);
 153         if (ret < 0) {
 154                 dev_err(pmic->dev, "Reg 0x%02x update failed %d\n",
 155                         rinfo->fps_addr, ret);
 156                 return ret;
 157         }
 158         pmic->active_fps_src[id] = fps_src;
 159
 160         return 0;
 161 }
 162
 163 static int max77620_regulator_set_fps_slots(struct max77620_regulator *pmic,
 164                                             int id, bool is_suspend)
 165 {
 166         struct max77620_regulator_pdata *rpdata = &pmic->reg_pdata[id];
 167         struct max77620_regulator_info *rinfo = pmic->rinfo[id];
 168         unsigned int val = 0;
 169         unsigned int mask = 0;
 170         int pu = rpdata->active_fps_pu_slot;
 171         int pd = rpdata->active_fps_pd_slot;
 172         int ret = 0;
 173
 174         if (!rinfo)
 175                 return 0;
 176
 177         if (is_suspend) {
 178                 pu = rpdata->suspend_fps_pu_slot;
 179                 pd = rpdata->suspend_fps_pd_slot;
 180         }
 181
 182         /* FPS power up period setting */
 183         if (pu >= 0) {
 184                 val |= (pu << MAX77620_FPS_PU_PERIOD_SHIFT);
 185                 mask |= MAX77620_FPS_PU_PERIOD_MASK;
 186         }
 187
 188         /* FPS power down period setting */
 189         if (pd >= 0) {
 190                 val |= (pd << MAX77620_FPS_PD_PERIOD_SHIFT);
 191                 mask |= MAX77620_FPS_PD_PERIOD_MASK;
 192         }
 193
 194         if (mask) {
 195                 ret = regmap_update_bits(pmic->rmap, rinfo->fps_addr,
 196                                          mask, val);
 197                 if (ret < 0) {
 198                         dev_err(pmic->dev, "Reg 0x%02x update failed: %d\n",
 199                                 rinfo->fps_addr, ret);
 200                         return ret;
 201                 }
 202         }
 203
 204         return ret;
 205 }
 206
 207 static int max77620_regulator_set_power_mode(struct max77620_regulator *pmic,
 208                                              int power_mode, int id)
 209 {
 210         struct max77620_regulator_info *rinfo = pmic->rinfo[id];
 211         u8 mask = rinfo->power_mode_mask;
 212         u8 shift = rinfo->power_mode_shift;
 213         u8 addr;
 214         int ret;
 215
 216         switch (rinfo->type) {
 217         case MAX77620_REGULATOR_TYPE_SD:
 218                 addr = rinfo->cfg_addr;
 219                 break;
 220         default:
 221                 addr = rinfo->volt_addr;
 222                 break;
 223         }
 224
 225         ret = regmap_update_bits(pmic->rmap, addr, mask, power_mode << shift);
 226         if (ret < 0) {
 227                 dev_err(pmic->dev, "Regulator %d mode set failed: %d\n",
 228                         id, ret);
 229                 return ret;
 230         }
 231         pmic->current_power_mode[id] = power_mode;
 232
 233         return ret;
 234 }
 235
 236 static int max77620_regulator_get_power_mode(struct max77620_regulator *pmic,
 237                                              int id)
 238 {
 239         struct max77620_regulator_info *rinfo = pmic->rinfo[id];
 240         unsigned int val, addr;
 241         u8 mask = rinfo->power_mode_mask;
 242         u8 shift = rinfo->power_mode_shift;
 243         int ret;
 244
 245         switch (rinfo->type) {
 246         case MAX77620_REGULATOR_TYPE_SD:
 247                 addr = rinfo->cfg_addr;
 248                 break;
 249         default:
 250                 addr = rinfo->volt_addr;
 251                 break;
 252         }
 253
 254         ret = regmap_read(pmic->rmap, addr, &val);
 255         if (ret < 0) {
 256                 dev_err(pmic->dev, "Regulator %d: Reg 0x%02x read failed: %d\n",
 257                         id, addr, ret);
 258                 return ret;
 259         }
 260
 261         return (val & mask) >> shift;
 262 }
 263
 264 static int max77620_read_slew_rate(struct max77620_regulator *pmic, int id)
 265 {
 266         struct max77620_regulator_info *rinfo = pmic->rinfo[id];
 267         unsigned int rval;
 268         int slew_rate;
 269         int ret;
 270
 271         ret = regmap_read(pmic->rmap, rinfo->cfg_addr, &rval);
 272         if (ret < 0) {
 273                 dev_err(pmic->dev, "Register 0x%02x read failed: %d\n",
 274                         rinfo->cfg_addr, ret);
 275                 return ret;
 276         }
 277
 278         switch (rinfo->type) {
 279         case MAX77620_REGULATOR_TYPE_SD:
 280                 slew_rate = (rval >> MAX77620_SD_SR_SHIFT) & 0x3;
 281                 switch (slew_rate) {
 282                 case 0:
 283                         slew_rate = 13750;
 284                         break;
 285                 case 1:
 286                         slew_rate = 27500;
 287                         break;
 288                 case 2:
 289                         slew_rate = 55000;
 290                         break;
 291                 case 3:
 292                         slew_rate = 100000;
 293                         break;
 294                 }
 295                 rinfo->desc.ramp_delay = slew_rate;
 296                 break;
 297         default:
 298                 slew_rate = rval & 0x1;
 299                 switch (slew_rate) {
 300                 case 0:
 301                         slew_rate = 100000;
 302                         break;
 303                 case 1:
 304                         slew_rate = 5000;
 305                         break;
 306                 }
 307                 rinfo->desc.ramp_delay = slew_rate;
 308                 break;
 309         }
 310
 311         return 0;
 312 }
 313
 314 static int max77620_set_slew_rate(struct max77620_regulator *pmic, int id,
 315                                   int slew_rate)
 316 {
 317         struct max77620_regulator_info *rinfo = pmic->rinfo[id];
 318         unsigned int val;
 319         int ret;
 320         u8 mask;
 321
 322         if (rinfo->type == MAX77620_REGULATOR_TYPE_SD) {
 323                 if (slew_rate <= 13750)
 324                         val = 0;
 325                 else if (slew_rate <= 27500)
 326                         val = 1;
 327                 else if (slew_rate <= 55000)
 328                         val = 2;
 329                 else
 330                         val = 3;
 331                 val <<= MAX77620_SD_SR_SHIFT;
 332                 mask = MAX77620_SD_SR_MASK;
 333         } else {
 334                 if (slew_rate <= 5000)
 335                         val = 1;
 336                 else
 337                         val = 0;
 338                 mask = MAX77620_LDO_SLEW_RATE_MASK;
 339         }
 340
 341         ret = regmap_update_bits(pmic->rmap, rinfo->cfg_addr, mask, val);
 342         if (ret < 0) {
 343                 dev_err(pmic->dev, "Regulator %d slew rate set failed: %d\n",
 344                         id, ret);
 345                 return ret;
 346         }
 347
 348         return 0;
 349 }
 350
 351 static int max77620_config_power_ok(struct max77620_regulator *pmic, int id)
 352 {
 353         struct max77620_regulator_pdata *rpdata = &pmic->reg_pdata[id];
 354         struct max77620_regulator_info *rinfo = pmic->rinfo[id];
 355         struct max77620_chip *chip = dev_get_drvdata(pmic->dev->parent);
 356         u8 val, mask;
 357         int ret;
 358
 359         switch (chip->chip_id) {
 360         case MAX20024:
 361                 if (rpdata->power_ok >= 0) {
 362                         if (rinfo->type == MAX77620_REGULATOR_TYPE_SD)
 363                                 mask = MAX20024_SD_CFG1_MPOK_MASK;
 364                         else
 365                                 mask = MAX20024_LDO_CFG2_MPOK_MASK;
 366
 367                         val = rpdata->power_ok ? mask : 0;
 368
 369                         ret = regmap_update_bits(pmic->rmap, rinfo->cfg_addr,
 370                                                  mask, val);
 371                         if (ret < 0) {
 372                                 dev_err(pmic->dev, "Reg 0x%02x update failed %d\n",
 373                                         rinfo->cfg_addr, ret);
 374                                 return ret;
 375                         }
 376                 }
 377                 break;
 378
 379         default:
 380                 break;
 381         }
 382
 383         return 0;
 384 }
 385
 386 static int max77620_init_pmic(struct max77620_regulator *pmic, int id)
 387 {
 388         struct max77620_regulator_pdata *rpdata = &pmic->reg_pdata[id];
 389         int ret;
 390
 391         max77620_config_power_ok(pmic, id);
 392
 393         /* Update power mode */
 394         ret = max77620_regulator_get_power_mode(pmic, id);
 395         if (ret < 0)
 396                 return ret;
 397
 398         pmic->current_power_mode[id] = ret;
 399         pmic->enable_power_mode[id] = MAX77620_POWER_MODE_NORMAL;
 400
 401         if (rpdata->active_fps_src == MAX77620_FPS_SRC_DEF) {
 402                 ret = max77620_regulator_get_fps_src(pmic, id);
 403                 if (ret < 0)
 404                         return ret;
 405                 rpdata->active_fps_src = ret;
 406         }
 407
 408          /* If rails are externally control of FPS then enable it always. */
 409         if (rpdata->active_fps_src == MAX77620_FPS_SRC_NONE) {
 410                 ret = max77620_regulator_set_power_mode(pmic,
 411                                         pmic->enable_power_mode[id], id);
 412                 if (ret < 0)
 413                         return ret;
 414         } else {
 415                 if (pmic->current_power_mode[id] !=
 416                      pmic->enable_power_mode[id]) {
 417                         ret = max77620_regulator_set_power_mode(pmic,
 418                                         pmic->enable_power_mode[id], id);
 419                         if (ret < 0)
 420                                 return ret;
 421                 }
 422         }
 423
 424         ret = max77620_regulator_set_fps_src(pmic, rpdata->active_fps_src, id);
 425         if (ret < 0)
 426                 return ret;
 427
 428         ret = max77620_regulator_set_fps_slots(pmic, id, false);
 429         if (ret < 0)
 430                 return ret;
 431
 432         if (rpdata->ramp_rate_setting) {
 433                 ret = max77620_set_slew_rate(pmic, id,
 434                                              rpdata->ramp_rate_setting);
 435                 if (ret < 0)
 436                         return ret;
 437         }
 438
 439         return 0;
 440 }
 441
 442 static int max77620_regulator_enable(struct regulator_dev *rdev)
 443 {
 444         struct max77620_regulator *pmic = rdev_get_drvdata(rdev);
 445         int id = rdev_get_id(rdev);
 446
 447         if (pmic->active_fps_src[id] != MAX77620_FPS_SRC_NONE)
 448                 return 0;
 449
 450         return max77620_regulator_set_power_mode(pmic,
 451                         pmic->enable_power_mode[id], id);
 452 }
 453
 454 static int max77620_regulator_disable(struct regulator_dev *rdev)
 455 {
 456         struct max77620_regulator *pmic = rdev_get_drvdata(rdev);
 457         int id = rdev_get_id(rdev);
 458
 459         if (pmic->active_fps_src[id] != MAX77620_FPS_SRC_NONE)
 460                 return 0;
 461
 462         return max77620_regulator_set_power_mode(pmic,
 463                         MAX77620_POWER_MODE_DISABLE, id);
 464 }
 465
 466 static int max77620_regulator_is_enabled(struct regulator_dev *rdev)
 467 {
 468         struct max77620_regulator *pmic = rdev_get_drvdata(rdev);
 469         int id = rdev_get_id(rdev);
 470         int ret;
 471
 472         if (pmic->active_fps_src[id] != MAX77620_FPS_SRC_NONE)
 473                 return 1;
 474
 475         ret = max77620_regulator_get_power_mode(pmic, id);
 476         if (ret < 0)
 477                 return ret;
 478
 479         if (ret != MAX77620_POWER_MODE_DISABLE)
 480                 return 1;
 481
 482         return 0;
 483 }
 484
 485 static int max77620_regulator_set_mode(struct regulator_dev *rdev,
 486                                        unsigned int mode)
 487 {
 488         struct max77620_regulator *pmic = rdev_get_drvdata(rdev);
 489         int id = rdev_get_id(rdev);
 490         struct max77620_regulator_info *rinfo = pmic->rinfo[id];
 491         struct max77620_regulator_pdata *rpdata = &pmic->reg_pdata[id];
 492         bool fpwm = false;
 493         int power_mode;
 494         int ret;
 495         u8 val;
 496
 497         switch (mode) {
 498         case REGULATOR_MODE_FAST:
 499                 fpwm = true;
 500                 power_mode = MAX77620_POWER_MODE_NORMAL;
 501                 break;
 502
 503         case REGULATOR_MODE_NORMAL:
 504                 power_mode = MAX77620_POWER_MODE_NORMAL;
 505                 break;
 506
 507         case REGULATOR_MODE_IDLE:
 508                 power_mode = MAX77620_POWER_MODE_LPM;
 509                 break;
 510
 511         default:
 512                 dev_err(pmic->dev, "Regulator %d mode %d is invalid\n",
 513                         id, mode);
 514                 return -EINVAL;
 515         }
 516
 517         if (rinfo->type != MAX77620_REGULATOR_TYPE_SD)
 518                 goto skip_fpwm;
 519
 520         val = (fpwm) ? MAX77620_SD_FPWM_MASK : 0;
 521         ret = regmap_update_bits(pmic->rmap, rinfo->cfg_addr,
 522                                  MAX77620_SD_FPWM_MASK, val);
 523         if (ret < 0) {
 524                 dev_err(pmic->dev, "Reg 0x%02x update failed: %d\n",
 525                         rinfo->cfg_addr, ret);
 526                 return ret;
 527         }
 528         rpdata->current_mode = mode;
 529
 530 skip_fpwm:
 531         ret = max77620_regulator_set_power_mode(pmic, power_mode, id);
 532         if (ret < 0)
 533                 return ret;
 534
 535         pmic->enable_power_mode[id] = power_mode;
 536
 537         return 0;
 538 }
 539
 540 static unsigned int max77620_regulator_get_mode(struct regulator_dev *rdev)
 541 {
 542         struct max77620_regulator *pmic = rdev_get_drvdata(rdev);
 543         int id = rdev_get_id(rdev);
 544         struct max77620_regulator_info *rinfo = pmic->rinfo[id];
 545         int fpwm = 0;
 546         int ret;
 547         int pm_mode, reg_mode;
 548         unsigned int val;
 549
 550         ret = max77620_regulator_get_power_mode(pmic, id);
 551         if (ret < 0)
 552                 return 0;
 553
 554         pm_mode = ret;
 555
 556         if (rinfo->type == MAX77620_REGULATOR_TYPE_SD) {
 557                 ret = regmap_read(pmic->rmap, rinfo->cfg_addr, &val);
 558                 if (ret < 0) {
 559                         dev_err(pmic->dev, "Reg 0x%02x read failed: %d\n",
 560                                 rinfo->cfg_addr, ret);
 561                         return ret;
 562                 }
 563                 fpwm = !!(val & MAX77620_SD_FPWM_MASK);
 564         }
 565
 566         switch (pm_mode) {
 567         case MAX77620_POWER_MODE_NORMAL:
 568         case MAX77620_POWER_MODE_DISABLE:
 569                 if (fpwm)
 570                         reg_mode = REGULATOR_MODE_FAST;
 571                 else
 572                         reg_mode = REGULATOR_MODE_NORMAL;
 573                 break;
 574         case MAX77620_POWER_MODE_LPM:
 575         case MAX77620_POWER_MODE_GLPM:
 576                 reg_mode = REGULATOR_MODE_IDLE;
 577                 break;
 578         default:
 579                 return 0;
 580         }
 581
 582         return reg_mode;
 583 }
 584
 585 static int max77620_regulator_set_ramp_delay(struct regulator_dev *rdev,
 586                                              int ramp_delay)
 587 {
 588         struct max77620_regulator *pmic = rdev_get_drvdata(rdev);
 589         int id = rdev_get_id(rdev);
 590         struct max77620_regulator_pdata *rpdata = &pmic->reg_pdata[id];
 591
 592         /* Device specific ramp rate setting tells that platform has
 593          * different ramp rate from advertised value. In this case,
 594          * do not configure anything and just return success.
 595          */
 596         if (rpdata->ramp_rate_setting)
 597                 return 0;
 598
 599         return max77620_set_slew_rate(pmic, id, ramp_delay);
 600 }
 601
 602 static int max77620_of_parse_cb(struct device_node *np,
 603                                 const struct regulator_desc *desc,
 604                                 struct regulator_config *config)
 605 {
 606         struct max77620_regulator *pmic = config->driver_data;
 607         struct max77620_regulator_pdata *rpdata = &pmic->reg_pdata[desc->id];
 608         u32 pval;
 609         int ret;
 610
 611         ret = of_property_read_u32(np, "maxim,active-fps-source", &pval);
 612         rpdata->active_fps_src = (!ret) ? pval : MAX77620_FPS_SRC_DEF;
 613
 614         ret = of_property_read_u32(np, "maxim,active-fps-power-up-slot", &pval);
 615         rpdata->active_fps_pu_slot = (!ret) ? pval : -1;
 616
 617         ret = of_property_read_u32(
 618                         np, "maxim,active-fps-power-down-slot", &pval);
 619         rpdata->active_fps_pd_slot = (!ret) ? pval : -1;
 620
 621         ret = of_property_read_u32(np, "maxim,suspend-fps-source", &pval);
 622         rpdata->suspend_fps_src = (!ret) ? pval : -1;
 623
 624         ret = of_property_read_u32(
 625                         np, "maxim,suspend-fps-power-up-slot", &pval);
 626         rpdata->suspend_fps_pu_slot = (!ret) ? pval : -1;
 627
 628         ret = of_property_read_u32(
 629                         np, "maxim,suspend-fps-power-down-slot", &pval);
 630         rpdata->suspend_fps_pd_slot = (!ret) ? pval : -1;
 631
 632         ret = of_property_read_u32(np, "maxim,power-ok-control", &pval);
 633         if (!ret)
 634                 rpdata->power_ok = pval;
 635         else
 636                 rpdata->power_ok = -1;
 637
 638         ret = of_property_read_u32(np, "maxim,ramp-rate-setting", &pval);
 639         rpdata->ramp_rate_setting = (!ret) ? pval : 0;
 640
 641         return max77620_init_pmic(pmic, desc->id);
 642 }
 643
 644 static const struct regulator_ops max77620_regulator_ops = {
 645         .is_enabled = max77620_regulator_is_enabled,
 646         .enable = max77620_regulator_enable,
 647         .disable = max77620_regulator_disable,
 648         .list_voltage = regulator_list_voltage_linear,
 649         .map_voltage = regulator_map_voltage_linear,
 650         .get_voltage_sel = regulator_get_voltage_sel_regmap,
 651         .set_voltage_sel = regulator_set_voltage_sel_regmap,
 652         .set_mode = max77620_regulator_set_mode,
 653         .get_mode = max77620_regulator_get_mode,
 654         .set_ramp_delay = max77620_regulator_set_ramp_delay,
 655         .set_voltage_time_sel = regulator_set_voltage_time_sel,
 656         .set_active_discharge = regulator_set_active_discharge_regmap,
 657 };
 658
 659 #define MAX77620_SD_CNF2_ROVS_EN_NONE   0
 660 #define RAIL_SD(_id, _name, _sname, _volt_mask, _min_uV, _max_uV,       \
 661                 _step_uV, _rs_add, _rs_mask)                            \
 662         [MAX77620_REGULATOR_ID_##_id] = {                               \
 663                 .type = MAX77620_REGULATOR_TYPE_SD,                     \
 664                 .volt_addr = MAX77620_REG_##_id,                        \
 665                 .cfg_addr = MAX77620_REG_##_id##_CFG,                   \
 666                 .fps_addr = MAX77620_REG_FPS_##_id,                     \
 667                 .remote_sense_addr = _rs_add,                           \
 668                 .remote_sense_mask = MAX77620_SD_CNF2_ROVS_EN_##_rs_mask, \
 669                 .power_mode_mask = MAX77620_SD_POWER_MODE_MASK,         \
 670                 .power_mode_shift = MAX77620_SD_POWER_MODE_SHIFT,       \
 671                 .desc = {                                               \
 672                         .name = max77620_rails(_name),                  \
 673                         .of_match = of_match_ptr(#_name),               \
 674                         .regulators_node = of_match_ptr("regulators"),  \
 675                         .of_parse_cb = max77620_of_parse_cb,            \
 676                         .supply_name = _sname,                          \
 677                         .id = MAX77620_REGULATOR_ID_##_id,              \
 678                         .ops = &max77620_regulator_ops,                 \
 679                         .n_voltages = ((_max_uV - _min_uV) / _step_uV) + 1, \
 680                         .min_uV = _min_uV,                              \
 681                         .uV_step = _step_uV,                            \
 682                         .enable_time = 500,                             \
 683                         .vsel_mask = MAX77620_##_volt_mask##_VOLT_MASK, \
 684                         .vsel_reg = MAX77620_REG_##_id,                 \
 685                         .active_discharge_off = 0,                      \
 686                         .active_discharge_on = MAX77620_SD_CFG1_ADE_ENABLE, \
 687                         .active_discharge_mask = MAX77620_SD_CFG1_ADE_MASK, \
 688                         .active_discharge_reg = MAX77620_REG_##_id##_CFG, \
 689                         .type = REGULATOR_VOLTAGE,                      \
 690                         .owner = THIS_MODULE,                           \
 691                 },                                                      \
 692         }
 693
 694 #define RAIL_LDO(_id, _name, _sname, _type, _min_uV, _max_uV, _step_uV) \
 695         [MAX77620_REGULATOR_ID_##_id] = {                               \
 696                 .type = MAX77620_REGULATOR_TYPE_LDO_##_type,            \
 697                 .volt_addr = MAX77620_REG_##_id##_CFG,                  \
 698                 .cfg_addr = MAX77620_REG_##_id##_CFG2,                  \
 699                 .fps_addr = MAX77620_REG_FPS_##_id,                     \
 700                 .remote_sense_addr = 0xFF,                              \
 701                 .power_mode_mask = MAX77620_LDO_POWER_MODE_MASK,        \
 702                 .power_mode_shift = MAX77620_LDO_POWER_MODE_SHIFT,      \
 703                 .desc = {                                               \
 704                         .name = max77620_rails(_name),                  \
 705                         .of_match = of_match_ptr(#_name),               \
 706                         .regulators_node = of_match_ptr("regulators"),  \
 707                         .of_parse_cb = max77620_of_parse_cb,            \
 708                         .supply_name = _sname,                          \
 709                         .id = MAX77620_REGULATOR_ID_##_id,              \
 710                         .ops = &max77620_regulator_ops,                 \
 711                         .n_voltages = ((_max_uV - _min_uV) / _step_uV) + 1, \
 712                         .min_uV = _min_uV,                              \
 713                         .uV_step = _step_uV,                            \
 714                         .enable_time = 500,                             \
 715                         .vsel_mask = MAX77620_LDO_VOLT_MASK,            \
 716                         .vsel_reg = MAX77620_REG_##_id##_CFG,           \
 717                         .active_discharge_off = 0,                      \
 718                         .active_discharge_on = MAX77620_LDO_CFG2_ADE_ENABLE, \
 719                         .active_discharge_mask = MAX77620_LDO_CFG2_ADE_MASK, \
 720                         .active_discharge_reg = MAX77620_REG_##_id##_CFG2, \
 721                         .type = REGULATOR_VOLTAGE,                      \
 722                         .owner = THIS_MODULE,                           \
 723                 },                                                      \
 724         }
 725
 726 static struct max77620_regulator_info max77620_regs_info[MAX77620_NUM_REGS] = {
 727         RAIL_SD(SD0, sd0, "in-sd0", SD0, 600000, 1400000, 12500, 0x22, SD0),
 728         RAIL_SD(SD1, sd1, "in-sd1", SD1, 600000, 1550000, 12500, 0x22, SD1),
 729         RAIL_SD(SD2, sd2, "in-sd2", SDX, 600000, 3787500, 12500, 0xFF, NONE),
 730         RAIL_SD(SD3, sd3, "in-sd3", SDX, 600000, 3787500, 12500, 0xFF, NONE),
 731
 732         RAIL_LDO(LDO0, ldo0, "in-ldo0-1", N, 800000, 2375000, 25000),
 733         RAIL_LDO(LDO1, ldo1, "in-ldo0-1", N, 800000, 2375000, 25000),
 734         RAIL_LDO(LDO2, ldo2, "in-ldo2",   P, 800000, 3950000, 50000),
 735         RAIL_LDO(LDO3, ldo3, "in-ldo3-5", P, 800000, 3950000, 50000),
 736         RAIL_LDO(LDO4, ldo4, "in-ldo4-6", P, 800000, 1587500, 12500),
 737         RAIL_LDO(LDO5, ldo5, "in-ldo3-5", P, 800000, 3950000, 50000),
 738         RAIL_LDO(LDO6, ldo6, "in-ldo4-6", P, 800000, 3950000, 50000),
 739         RAIL_LDO(LDO7, ldo7, "in-ldo7-8", N, 800000, 3950000, 50000),
 740         RAIL_LDO(LDO8, ldo8, "in-ldo7-8", N, 800000, 3950000, 50000),
 741 };
 742
 743 static struct max77620_regulator_info max20024_regs_info[MAX77620_NUM_REGS] = {
 744         RAIL_SD(SD0, sd0, "in-sd0", SD0, 800000, 1587500, 12500, 0x22, SD0),
 745         RAIL_SD(SD1, sd1, "in-sd1", SD1, 600000, 3387500, 12500, 0x22, SD1),
 746         RAIL_SD(SD2, sd2, "in-sd2", SDX, 600000, 3787500, 12500, 0xFF, NONE),
 747         RAIL_SD(SD3, sd3, "in-sd3", SDX, 600000, 3787500, 12500, 0xFF, NONE),
 748         RAIL_SD(SD4, sd4, "in-sd4", SDX, 600000, 3787500, 12500, 0xFF, NONE),
 749
 750         RAIL_LDO(LDO0, ldo0, "in-ldo0-1", N, 800000, 2375000, 25000),
 751         RAIL_LDO(LDO1, ldo1, "in-ldo0-1", N, 800000, 2375000, 25000),
 752         RAIL_LDO(LDO2, ldo2, "in-ldo2",   P, 800000, 3950000, 50000),
 753         RAIL_LDO(LDO3, ldo3, "in-ldo3-5", P, 800000, 3950000, 50000),
 754         RAIL_LDO(LDO4, ldo4, "in-ldo4-6", P, 800000, 1587500, 12500),
 755         RAIL_LDO(LDO5, ldo5, "in-ldo3-5", P, 800000, 3950000, 50000),
 756         RAIL_LDO(LDO6, ldo6, "in-ldo4-6", P, 800000, 3950000, 50000),
 757         RAIL_LDO(LDO7, ldo7, "in-ldo7-8", N, 800000, 3950000, 50000),
 758         RAIL_LDO(LDO8, ldo8, "in-ldo7-8", N, 800000, 3950000, 50000),
 759 };
 760
 761 static struct max77620_regulator_info max77663_regs_info[MAX77620_NUM_REGS] = {
 762         RAIL_SD(SD0, sd0, "in-sd0", SD0, 600000, 3387500, 12500, 0xFF, NONE),
 763         RAIL_SD(SD1, sd1, "in-sd1", SD1, 800000, 1587500, 12500, 0xFF, NONE),
 764         RAIL_SD(SD2, sd2, "in-sd2", SDX, 600000, 3787500, 12500, 0xFF, NONE),
 765         RAIL_SD(SD3, sd3, "in-sd3", SDX, 600000, 3787500, 12500, 0xFF, NONE),
 766         RAIL_SD(SD4, sd4, "in-sd4", SDX, 600000, 3787500, 12500, 0xFF, NONE),
 767
 768         RAIL_LDO(LDO0, ldo0, "in-ldo0-1", N, 800000, 2375000, 25000),
 769         RAIL_LDO(LDO1, ldo1, "in-ldo0-1", N, 800000, 2375000, 25000),
 770         RAIL_LDO(LDO2, ldo2, "in-ldo2",   P, 800000, 3950000, 50000),
 771         RAIL_LDO(LDO3, ldo3, "in-ldo3-5", P, 800000, 3950000, 50000),
 772         RAIL_LDO(LDO4, ldo4, "in-ldo4-6", P, 800000, 1587500, 12500),
 773         RAIL_LDO(LDO5, ldo5, "in-ldo3-5", P, 800000, 3950000, 50000),
 774         RAIL_LDO(LDO6, ldo6, "in-ldo4-6", P, 800000, 3950000, 50000),
 775         RAIL_LDO(LDO7, ldo7, "in-ldo7-8", N, 800000, 3950000, 50000),
 776         RAIL_LDO(LDO8, ldo8, "in-ldo7-8", N, 800000, 3950000, 50000),
 777 };
 778
 779 static int max77620_regulator_probe(struct platform_device *pdev)
 780 {
 781         struct max77620_chip *max77620_chip = dev_get_drvdata(pdev->dev.parent);
 782         struct max77620_regulator_info *rinfo;
 783         struct device *dev = &pdev->dev;
 784         struct regulator_config config = { };
 785         struct max77620_regulator *pmic;
 786         int ret = 0;
 787         int id;
 788
 789         pmic = devm_kzalloc(dev, sizeof(*pmic), GFP_KERNEL);
 790         if (!pmic)
 791                 return -ENOMEM;
 792
 793         platform_set_drvdata(pdev, pmic);
 794         pmic->dev = dev;
 795         pmic->rmap = max77620_chip->rmap;
 796         if (!dev->of_node)
 797                 dev->of_node = pdev->dev.parent->of_node;
 798
 799         switch (max77620_chip->chip_id) {
 800         case MAX77620:
 801                 rinfo = max77620_regs_info;
 802                 break;
 803         case MAX20024:
 804                 rinfo = max20024_regs_info;
 805                 break;
 806         case MAX77663:
 807                 rinfo = max77663_regs_info;
 808                 break;
 809         default:
 810                 return -EINVAL;
 811         }
 812
 813         config.regmap = pmic->rmap;
 814         config.dev = dev;
 815         config.driver_data = pmic;
 816
 817         /*
 818          * Set of_node_reuse flag to prevent driver core from attempting to
 819          * claim any pinmux resources already claimed by the parent device.
 820          * Otherwise PMIC driver will fail to re-probe.
 821          */
 822         device_set_of_node_from_dev(&pdev->dev, pdev->dev.parent);
 823
 824         for (id = 0; id < MAX77620_NUM_REGS; id++) {
 825                 struct regulator_dev *rdev;
 826                 struct regulator_desc *rdesc;
 827
 828                 if ((max77620_chip->chip_id == MAX77620) &&
 829                     (id == MAX77620_REGULATOR_ID_SD4))
 830                         continue;
 831
 832                 rdesc = &rinfo[id].desc;
 833                 pmic->rinfo[id] = &rinfo[id];
 834                 pmic->enable_power_mode[id] = MAX77620_POWER_MODE_NORMAL;
 835                 pmic->reg_pdata[id].active_fps_src = -1;
 836                 pmic->reg_pdata[id].active_fps_pd_slot = -1;
 837                 pmic->reg_pdata[id].active_fps_pu_slot = -1;
 838                 pmic->reg_pdata[id].suspend_fps_src = -1;
 839                 pmic->reg_pdata[id].suspend_fps_pd_slot = -1;
 840                 pmic->reg_pdata[id].suspend_fps_pu_slot = -1;
 841                 pmic->reg_pdata[id].power_ok = -1;
 842                 pmic->reg_pdata[id].ramp_rate_setting = -1;
 843
 844                 ret = max77620_read_slew_rate(pmic, id);
 845                 if (ret < 0)
 846                         return ret;
 847
 848                 rdev = devm_regulator_register(dev, rdesc, &config);
 849                 if (IS_ERR(rdev))
 850                         return dev_err_probe(dev, PTR_ERR(rdev),
 851                                              "Regulator registration %s failed\n",
 852                                              rdesc->name);
 853         }
 854
 855         return 0;
 856 }
 857
 858 #ifdef CONFIG_PM_SLEEP
 859 static int max77620_regulator_suspend(struct device *dev)
 860 {
 861         struct max77620_regulator *pmic = dev_get_drvdata(dev);
 862         struct max77620_regulator_pdata *reg_pdata;
 863         int id;
 864
 865         for (id = 0; id < MAX77620_NUM_REGS; id++) {
 866                 reg_pdata = &pmic->reg_pdata[id];
 867
 868                 max77620_regulator_set_fps_slots(pmic, id, true);
 869                 if (reg_pdata->suspend_fps_src < 0)
 870                         continue;
 871
 872                 max77620_regulator_set_fps_src(pmic, reg_pdata->suspend_fps_src,
 873                                                id);
 874         }
 875
 876         return 0;
 877 }
 878
 879 static int max77620_regulator_resume(struct device *dev)
 880 {
 881         struct max77620_regulator *pmic = dev_get_drvdata(dev);
 882         struct max77620_regulator_pdata *reg_pdata;
 883         int id;
 884
 885         for (id = 0; id < MAX77620_NUM_REGS; id++) {
 886                 reg_pdata = &pmic->reg_pdata[id];
 887
 888                 max77620_config_power_ok(pmic, id);
 889
 890                 max77620_regulator_set_fps_slots(pmic, id, false);
 891                 if (reg_pdata->active_fps_src < 0)
 892                         continue;
 893                 max77620_regulator_set_fps_src(pmic, reg_pdata->active_fps_src,
 894                                                id);
 895         }
 896
 897         return 0;
 898 }
 899 #endif
 900
 901 static const struct dev_pm_ops max77620_regulator_pm_ops = {
 902         SET_SYSTEM_SLEEP_PM_OPS(max77620_regulator_suspend,
 903                                 max77620_regulator_resume)
 904 };
 905
 906 static const struct platform_device_id max77620_regulator_devtype[] = {
 907         { .name = "max77620-pmic", },
 908         { .name = "max20024-pmic", },
 909         { .name = "max77663-pmic", },
 910         {},
 911 };
 912 MODULE_DEVICE_TABLE(platform, max77620_regulator_devtype);
 913
 914 static struct platform_driver max77620_regulator_driver = {
 915         .probe = max77620_regulator_probe,
 916         .id_table = max77620_regulator_devtype,
 917         .driver = {
 918                 .name = "max77620-pmic",
 919                 .pm = &max77620_regulator_pm_ops,
 920         },
 921 };
 922
 923 module_platform_driver(max77620_regulator_driver);
 924
 925 MODULE_DESCRIPTION("MAX77620/MAX20024 regulator driver");
 926 MODULE_AUTHOR("Mallikarjun Kasoju <mkasoju@nvidia.com>");
 927 MODULE_AUTHOR("Laxman Dewangan <ldewangan@nvidia.com>");
 928 MODULE_LICENSE("GPL v2");