drivers/regulator/bd718x7-regulator.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 // Copyright (C) 2018 ROHM Semiconductors
   3 // bd71837-regulator.c ROHM BD71837MWV/BD71847MWV regulator driver
   4
   5 #include <linux/delay.h>
   6 #include <linux/err.h>
   7 #include <linux/interrupt.h>
   8 #include <linux/kernel.h>
   9 #include <linux/mfd/rohm-bd718x7.h>
  10 #include <linux/module.h>
  11 #include <linux/of.h>
  12 #include <linux/platform_device.h>
  13 #include <linux/regulator/driver.h>
  14 #include <linux/regulator/machine.h>
  15 #include <linux/regulator/of_regulator.h>
  16 #include <linux/slab.h>
  17
  18 /* Typical regulator startup times as per data sheet in uS */
  19 #define BD71847_BUCK1_STARTUP_TIME 144
  20 #define BD71847_BUCK2_STARTUP_TIME 162
  21 #define BD71847_BUCK3_STARTUP_TIME 162
  22 #define BD71847_BUCK4_STARTUP_TIME 240
  23 #define BD71847_BUCK5_STARTUP_TIME 270
  24 #define BD71847_BUCK6_STARTUP_TIME 200
  25 #define BD71847_LDO1_STARTUP_TIME  440
  26 #define BD71847_LDO2_STARTUP_TIME  370
  27 #define BD71847_LDO3_STARTUP_TIME  310
  28 #define BD71847_LDO4_STARTUP_TIME  400
  29 #define BD71847_LDO5_STARTUP_TIME  530
  30 #define BD71847_LDO6_STARTUP_TIME  400
  31
  32 #define BD71837_BUCK1_STARTUP_TIME 160
  33 #define BD71837_BUCK2_STARTUP_TIME 180
  34 #define BD71837_BUCK3_STARTUP_TIME 180
  35 #define BD71837_BUCK4_STARTUP_TIME 180
  36 #define BD71837_BUCK5_STARTUP_TIME 160
  37 #define BD71837_BUCK6_STARTUP_TIME 240
  38 #define BD71837_BUCK7_STARTUP_TIME 220
  39 #define BD71837_BUCK8_STARTUP_TIME 200
  40 #define BD71837_LDO1_STARTUP_TIME  440
  41 #define BD71837_LDO2_STARTUP_TIME  370
  42 #define BD71837_LDO3_STARTUP_TIME  310
  43 #define BD71837_LDO4_STARTUP_TIME  400
  44 #define BD71837_LDO5_STARTUP_TIME  310
  45 #define BD71837_LDO6_STARTUP_TIME  400
  46 #define BD71837_LDO7_STARTUP_TIME  530
  47
  48 /*
  49  * BD718(37/47/50) have two "enable control modes". ON/OFF can either be
  50  * controlled by software - or by PMIC internal HW state machine. Whether
  51  * regulator should be under SW or HW control can be defined from device-tree.
  52  * Let's provide separate ops for regulators to use depending on the "enable
  53  * control mode".
  54  */
  55 #define BD718XX_HWOPNAME(swopname) swopname##_hwcontrol
  56
  57 #define BD718XX_OPS(name, _list_voltage, _map_voltage, _set_voltage_sel, \
  58                    _get_voltage_sel, _set_voltage_time_sel, _set_ramp_delay, \
  59                    _set_uvp, _set_ovp)                          \
  60 static const struct regulator_ops name = {                      \
  61         .enable = regulator_enable_regmap,                      \
  62         .disable = regulator_disable_regmap,                    \
  63         .is_enabled = regulator_is_enabled_regmap,              \
  64         .list_voltage = (_list_voltage),                        \
  65         .map_voltage = (_map_voltage),                          \
  66         .set_voltage_sel = (_set_voltage_sel),                  \
  67         .get_voltage_sel = (_get_voltage_sel),                  \
  68         .set_voltage_time_sel = (_set_voltage_time_sel),        \
  69         .set_ramp_delay = (_set_ramp_delay),                    \
  70         .set_under_voltage_protection = (_set_uvp),             \
  71         .set_over_voltage_protection = (_set_ovp),              \
  72 };                                                              \
  73                                                                 \
  74 static const struct regulator_ops BD718XX_HWOPNAME(name) = {    \
  75         .is_enabled = always_enabled_by_hwstate,                \
  76         .list_voltage = (_list_voltage),                        \
  77         .map_voltage = (_map_voltage),                          \
  78         .set_voltage_sel = (_set_voltage_sel),                  \
  79         .get_voltage_sel = (_get_voltage_sel),                  \
  80         .set_voltage_time_sel = (_set_voltage_time_sel),        \
  81         .set_ramp_delay = (_set_ramp_delay),                    \
  82         .set_under_voltage_protection = (_set_uvp),             \
  83         .set_over_voltage_protection = (_set_ovp),              \
  84 }                                                               \
  85
  86 /*
  87  * BUCK1/2/3/4
  88  * BUCK1RAMPRATE[1:0] BUCK1 DVS ramp rate setting
  89  * 00: 10.00mV/usec 10mV 1uS
  90  * 01: 5.00mV/usec      10mV 2uS
  91  * 10: 2.50mV/usec      10mV 4uS
  92  * 11: 1.25mV/usec      10mV 8uS
  93  */
  94 static const unsigned int bd718xx_ramp_delay[] = { 10000, 5000, 2500, 1250 };
  95
  96 /* These functions are used when regulators are under HW state machine control.
  97  * We assume PMIC is in RUN state because SW running and able to query the
  98  * status. Most of the regulators have fixed ON or OFF state at RUN/IDLE so for
  99  * them we just return a constant. BD71837 BUCK3 and BUCK4 are exceptions as
 100  * they support configuring the ON/OFF state for RUN.
 101  *
 102  * Note for next hacker - these PMICs have a register where the HW state can be
 103  * read. If assuming RUN appears to be false in your use-case - you can
 104  * implement state reading (although that is not going to be atomic) before
 105  * returning the enable state.
 106  */
 107 static int always_enabled_by_hwstate(struct regulator_dev *rdev)
 108 {
 109         return 1;
 110 }
 111
 112 static int never_enabled_by_hwstate(struct regulator_dev *rdev)
 113 {
 114         return 0;
 115 }
 116
 117 static int bd71837_get_buck34_enable_hwctrl(struct regulator_dev *rdev)
 118 {
 119         int ret;
 120         unsigned int val;
 121
 122         ret = regmap_read(rdev->regmap, rdev->desc->enable_reg, &val);
 123         if (ret)
 124                 return ret;
 125
 126         return !!(BD718XX_BUCK_RUN_ON & val);
 127 }
 128 /*
 129  * On BD71837 (not on BD71847, BD71850, ...)
 130  * Bucks 1 to 4 support DVS. PWM mode is used when voltage is changed.
 131  * Bucks 5 to 8 and LDOs can use PFM and must be disabled when voltage
 132  * is changed. Hence we return -EBUSY for these if voltage is changed
 133  * when BUCK/LDO is enabled.
 134  *
 135  * On BD71847, BD71850, ... The LDO voltage can be changed when LDO is
 136  * enabled. But if voltage is increased the LDO power-good monitoring
 137  * must be disabled for the duration of changing + 1mS to ensure voltage
 138  * has reached the higher level before HW does next under voltage detection
 139  * cycle.
 140  */
 141 static int bd71837_set_voltage_sel_restricted(struct regulator_dev *rdev,
 142                                                     unsigned int sel)
 143 {
 144         if (rdev->desc->ops->is_enabled(rdev))
 145                 return -EBUSY;
 146
 147         return regulator_set_voltage_sel_regmap(rdev, sel);
 148 }
 149
 150 static void voltage_change_done(struct regulator_dev *rdev, unsigned int sel,
 151                                 unsigned int *mask)
 152 {
 153         int ret;
 154
 155         if (*mask) {
 156                 /*
 157                  * Let's allow scheduling as we use I2C anyways. We just need to
 158                  * guarantee minimum of 1ms sleep - it shouldn't matter if we
 159                  * exceed it due to the scheduling.
 160                  */
 161                 msleep(1);
 162
 163                 ret = regmap_clear_bits(rdev->regmap, BD718XX_REG_MVRFLTMASK2,
 164                                          *mask);
 165                 if (ret)
 166                         dev_err(&rdev->dev,
 167                                 "Failed to re-enable voltage monitoring (%d)\n",
 168                                 ret);
 169         }
 170 }
 171
 172 static int voltage_change_prepare(struct regulator_dev *rdev, unsigned int sel,
 173                                   unsigned int *mask)
 174 {
 175         int ret;
 176
 177         *mask = 0;
 178         if (rdev->desc->ops->is_enabled(rdev)) {
 179                 int now, new;
 180
 181                 now = rdev->desc->ops->get_voltage_sel(rdev);
 182                 if (now < 0)
 183                         return now;
 184
 185                 now = rdev->desc->ops->list_voltage(rdev, now);
 186                 if (now < 0)
 187                         return now;
 188
 189                 new = rdev->desc->ops->list_voltage(rdev, sel);
 190                 if (new < 0)
 191                         return new;
 192
 193                 /*
 194                  * If we increase LDO voltage when LDO is enabled we need to
 195                  * disable the power-good detection until voltage has reached
 196                  * the new level. According to HW colleagues the maximum time
 197                  * it takes is 1000us. I assume that on systems with light load
 198                  * this might be less - and we could probably use DT to give
 199                  * system specific delay value if performance matters.
 200                  *
 201                  * Well, knowing we use I2C here and can add scheduling delays
 202                  * I don't think it is worth the hassle and I just add fixed
 203                  * 1ms sleep here (and allow scheduling). If this turns out to
 204                  * be a problem we can change it to delay and make the delay
 205                  * time configurable.
 206                  */
 207                 if (new > now) {
 208                         int tmp;
 209                         int prot_bit;
 210                         int ldo_offset = rdev->desc->id - BD718XX_LDO1;
 211
 212                         prot_bit = BD718XX_LDO1_VRMON80 << ldo_offset;
 213                         ret = regmap_read(rdev->regmap, BD718XX_REG_MVRFLTMASK2,
 214                                           &tmp);
 215                         if (ret) {
 216                                 dev_err(&rdev->dev,
 217                                         "Failed to read voltage monitoring state\n");
 218                                 return ret;
 219                         }
 220
 221                         if (!(tmp & prot_bit)) {
 222                                 /* We disable protection if it was enabled... */
 223                                 ret = regmap_set_bits(rdev->regmap,
 224                                                       BD718XX_REG_MVRFLTMASK2,
 225                                                       prot_bit);
 226                                 /* ...and we also want to re-enable it */
 227                                 *mask = prot_bit;
 228                         }
 229                         if (ret) {
 230                                 dev_err(&rdev->dev,
 231                                         "Failed to stop voltage monitoring\n");
 232                                 return ret;
 233                         }
 234                 }
 235         }
 236
 237         return 0;
 238 }
 239
 240 static int bd718xx_set_voltage_sel_restricted(struct regulator_dev *rdev,
 241                                                     unsigned int sel)
 242 {
 243         int ret;
 244         int mask;
 245
 246         ret = voltage_change_prepare(rdev, sel, &mask);
 247         if (ret)
 248                 return ret;
 249
 250         ret = regulator_set_voltage_sel_regmap(rdev, sel);
 251         voltage_change_done(rdev, sel, &mask);
 252
 253         return ret;
 254 }
 255
 256 static int bd718xx_set_voltage_sel_pickable_restricted(
 257                 struct regulator_dev *rdev, unsigned int sel)
 258 {
 259         int ret;
 260         int mask;
 261
 262         ret = voltage_change_prepare(rdev, sel, &mask);
 263         if (ret)
 264                 return ret;
 265
 266         ret = regulator_set_voltage_sel_pickable_regmap(rdev, sel);
 267         voltage_change_done(rdev, sel, &mask);
 268
 269         return ret;
 270 }
 271
 272 static int bd71837_set_voltage_sel_pickable_restricted(
 273                 struct regulator_dev *rdev, unsigned int sel)
 274 {
 275         if (rdev->desc->ops->is_enabled(rdev))
 276                 return -EBUSY;
 277
 278         return regulator_set_voltage_sel_pickable_regmap(rdev, sel);
 279 }
 280
 281 /*
 282  * BD71837 BUCK1/2/3/4
 283  * BD71847 BUCK1/2
 284  * 0.70 to 1.30V (10mV step)
 285  */
 286 static const struct linear_range bd718xx_dvs_buck_volts[] = {
 287         REGULATOR_LINEAR_RANGE(700000, 0x00, 0x3C, 10000),
 288         REGULATOR_LINEAR_RANGE(1300000, 0x3D, 0x3F, 0),
 289 };
 290
 291 /*
 292  * BD71837 BUCK5
 293  * 0.7V to 1.35V  (range 0)
 294  * and
 295  * 0.675 to 1.325 (range 1)
 296  */
 297 static const struct linear_range bd71837_buck5_volts[] = {
 298         /* Ranges when VOLT_SEL bit is 0 */
 299         REGULATOR_LINEAR_RANGE(700000, 0x00, 0x03, 100000),
 300         REGULATOR_LINEAR_RANGE(1050000, 0x04, 0x05, 50000),
 301         REGULATOR_LINEAR_RANGE(1200000, 0x06, 0x07, 150000),
 302         /* Ranges when VOLT_SEL bit is 1  */
 303         REGULATOR_LINEAR_RANGE(675000, 0x0, 0x3, 100000),
 304         REGULATOR_LINEAR_RANGE(1025000, 0x4, 0x5, 50000),
 305         REGULATOR_LINEAR_RANGE(1175000, 0x6, 0x7, 150000),
 306 };
 307
 308 /*
 309  * Range selector for first 3 linear ranges is 0x0
 310  * and 0x1 for last 3 ranges.
 311  */
 312 static const unsigned int bd71837_buck5_volt_range_sel[] = {
 313         0x0, 0x0, 0x0, 0x80, 0x80, 0x80
 314 };
 315
 316 /*
 317  * BD71847 BUCK3
 318  */
 319 static const struct linear_range bd71847_buck3_volts[] = {
 320         /* Ranges when VOLT_SEL bits are 00 */
 321         REGULATOR_LINEAR_RANGE(700000, 0x00, 0x03, 100000),
 322         REGULATOR_LINEAR_RANGE(1050000, 0x04, 0x05, 50000),
 323         REGULATOR_LINEAR_RANGE(1200000, 0x06, 0x07, 150000),
 324         /* Ranges when VOLT_SEL bits are 01 */
 325         REGULATOR_LINEAR_RANGE(550000, 0x0, 0x7, 50000),
 326         /* Ranges when VOLT_SEL bits are 11 */
 327         REGULATOR_LINEAR_RANGE(675000, 0x0, 0x3, 100000),
 328         REGULATOR_LINEAR_RANGE(1025000, 0x4, 0x5, 50000),
 329         REGULATOR_LINEAR_RANGE(1175000, 0x6, 0x7, 150000),
 330 };
 331
 332 static const unsigned int bd71847_buck3_volt_range_sel[] = {
 333         0x0, 0x0, 0x0, 0x40, 0x80, 0x80, 0x80
 334 };
 335
 336 static const struct linear_range bd71847_buck4_volts[] = {
 337         REGULATOR_LINEAR_RANGE(3000000, 0x00, 0x03, 100000),
 338         REGULATOR_LINEAR_RANGE(2600000, 0x00, 0x03, 100000),
 339 };
 340
 341 static const unsigned int bd71847_buck4_volt_range_sel[] = { 0x0, 0x40 };
 342
 343 /*
 344  * BUCK6
 345  * 3.0V to 3.3V (step 100mV)
 346  */
 347 static const struct linear_range bd71837_buck6_volts[] = {
 348         REGULATOR_LINEAR_RANGE(3000000, 0x00, 0x03, 100000),
 349 };
 350
 351 /*
 352  * BD71837 BUCK7
 353  * BD71847 BUCK5
 354  * 000 = 1.605V
 355  * 001 = 1.695V
 356  * 010 = 1.755V
 357  * 011 = 1.8V (Initial)
 358  * 100 = 1.845V
 359  * 101 = 1.905V
 360  * 110 = 1.95V
 361  * 111 = 1.995V
 362  */
 363 static const unsigned int bd718xx_3rd_nodvs_buck_volts[] = {
 364         1605000, 1695000, 1755000, 1800000, 1845000, 1905000, 1950000, 1995000
 365 };
 366
 367 /*
 368  * BUCK8
 369  * 0.8V to 1.40V (step 10mV)
 370  */
 371 static const struct linear_range bd718xx_4th_nodvs_buck_volts[] = {
 372         REGULATOR_LINEAR_RANGE(800000, 0x00, 0x3C, 10000),
 373 };
 374
 375 /*
 376  * LDO1
 377  * 3.0 to 3.3V (100mV step)
 378  */
 379 static const struct linear_range bd718xx_ldo1_volts[] = {
 380         REGULATOR_LINEAR_RANGE(3000000, 0x00, 0x03, 100000),
 381         REGULATOR_LINEAR_RANGE(1600000, 0x00, 0x03, 100000),
 382 };
 383
 384 static const unsigned int bd718xx_ldo1_volt_range_sel[] = { 0x0, 0x20 };
 385
 386 /*
 387  * LDO2
 388  * 0.8 or 0.9V
 389  */
 390 static const unsigned int ldo_2_volts[] = {
 391         900000, 800000
 392 };
 393
 394 /*
 395  * LDO3
 396  * 1.8 to 3.3V (100mV step)
 397  */
 398 static const struct linear_range bd718xx_ldo3_volts[] = {
 399         REGULATOR_LINEAR_RANGE(1800000, 0x00, 0x0F, 100000),
 400 };
 401
 402 /*
 403  * LDO4
 404  * 0.9 to 1.8V (100mV step)
 405  */
 406 static const struct linear_range bd718xx_ldo4_volts[] = {
 407         REGULATOR_LINEAR_RANGE(900000, 0x00, 0x09, 100000),
 408 };
 409
 410 /*
 411  * LDO5 for BD71837
 412  * 1.8 to 3.3V (100mV step)
 413  */
 414 static const struct linear_range bd71837_ldo5_volts[] = {
 415         REGULATOR_LINEAR_RANGE(1800000, 0x00, 0x0F, 100000),
 416 };
 417
 418 /*
 419  * LDO5 for BD71837
 420  * 1.8 to 3.3V (100mV step)
 421  */
 422 static const struct linear_range bd71847_ldo5_volts[] = {
 423         REGULATOR_LINEAR_RANGE(1800000, 0x00, 0x0F, 100000),
 424         REGULATOR_LINEAR_RANGE(800000, 0x00, 0x0F, 100000),
 425 };
 426
 427 static const unsigned int bd71847_ldo5_volt_range_sel[] = { 0x0, 0x20 };
 428
 429 /*
 430  * LDO6
 431  * 0.9 to 1.8V (100mV step)
 432  */
 433 static const struct linear_range bd718xx_ldo6_volts[] = {
 434         REGULATOR_LINEAR_RANGE(900000, 0x00, 0x09, 100000),
 435 };
 436
 437 /*
 438  * LDO7
 439  * 1.8 to 3.3V (100mV step)
 440  */
 441 static const struct linear_range bd71837_ldo7_volts[] = {
 442         REGULATOR_LINEAR_RANGE(1800000, 0x00, 0x0F, 100000),
 443 };
 444
 445 struct reg_init {
 446         unsigned int reg;
 447         unsigned int mask;
 448         unsigned int val;
 449 };
 450 struct bd718xx_regulator_data {
 451         struct regulator_desc desc;
 452         const struct rohm_dvs_config dvs;
 453         const struct reg_init init;
 454         const struct reg_init *additional_inits;
 455         int additional_init_amnt;
 456 };
 457
 458 static int bd718x7_xvp_sanity_check(struct regulator_dev *rdev, int lim_uV,
 459                                     int severity)
 460 {
 461         /*
 462          * BD71837/47/50 ... (ICs supported by this driver) do not provide
 463          * warnings, only protection
 464          */
 465         if (severity != REGULATOR_SEVERITY_PROT) {
 466                 dev_err(&rdev->dev,
 467                         "Unsupported Under Voltage protection level\n");
 468                 return -EINVAL;
 469         }
 470
 471         /*
 472          * And protection limit is not changeable. It can only be enabled
 473          * or disabled
 474          */
 475         if (lim_uV)
 476                 return -EINVAL;
 477
 478         return 0;
 479 }
 480
 481 static int bd718x7_set_ldo_uvp(struct regulator_dev *rdev, int lim_uV,
 482                                int severity, bool enable)
 483 {
 484         int ldo_offset = rdev->desc->id - BD718XX_LDO1;
 485         int prot_bit, ret;
 486
 487         ret = bd718x7_xvp_sanity_check(rdev, lim_uV, severity);
 488         if (ret)
 489                 return ret;
 490
 491         prot_bit = BD718XX_LDO1_VRMON80 << ldo_offset;
 492
 493         if (enable)
 494                 return regmap_clear_bits(rdev->regmap, BD718XX_REG_MVRFLTMASK2,
 495                                          prot_bit);
 496
 497         return regmap_set_bits(rdev->regmap, BD718XX_REG_MVRFLTMASK2,
 498                                prot_bit);
 499 }
 500
 501 static int bd718x7_get_buck_prot_reg(int id, int *reg)
 502 {
 503
 504         if (id > BD718XX_BUCK8) {
 505                 WARN_ON(id > BD718XX_BUCK8);
 506                 return -EINVAL;
 507         }
 508
 509         if (id > BD718XX_BUCK4)
 510                 *reg = BD718XX_REG_MVRFLTMASK0;
 511         else
 512                 *reg = BD718XX_REG_MVRFLTMASK1;
 513
 514         return 0;
 515 }
 516
 517 static int bd718x7_get_buck_ovp_info(int id, int *reg, int *bit)
 518 {
 519         int ret;
 520
 521         ret = bd718x7_get_buck_prot_reg(id, reg);
 522         if (ret)
 523                 return ret;
 524
 525         *bit = BIT((id % 4) * 2 + 1);
 526
 527         return 0;
 528 }
 529
 530 static int bd718x7_get_buck_uvp_info(int id, int *reg, int *bit)
 531 {
 532         int ret;
 533
 534         ret = bd718x7_get_buck_prot_reg(id, reg);
 535         if (ret)
 536                 return ret;
 537
 538         *bit = BIT((id % 4) * 2);
 539
 540         return 0;
 541 }
 542
 543 static int bd718x7_set_buck_uvp(struct regulator_dev *rdev, int lim_uV,
 544                                 int severity, bool enable)
 545 {
 546         int bit, reg, ret;
 547
 548         ret = bd718x7_xvp_sanity_check(rdev, lim_uV, severity);
 549         if (ret)
 550                 return ret;
 551
 552         ret = bd718x7_get_buck_uvp_info(rdev->desc->id, &reg, &bit);
 553         if (ret)
 554                 return ret;
 555
 556         if (enable)
 557                 return regmap_clear_bits(rdev->regmap, reg, bit);
 558
 559         return regmap_set_bits(rdev->regmap, reg, bit);
 560
 561 }
 562
 563 static int bd718x7_set_buck_ovp(struct regulator_dev *rdev, int lim_uV,
 564                                 int severity,
 565                                 bool enable)
 566 {
 567         int bit, reg, ret;
 568
 569         ret = bd718x7_xvp_sanity_check(rdev, lim_uV, severity);
 570         if (ret)
 571                 return ret;
 572
 573         ret = bd718x7_get_buck_ovp_info(rdev->desc->id, &reg, &bit);
 574         if (ret)
 575                 return ret;
 576
 577         if (enable)
 578                 return regmap_clear_bits(rdev->regmap, reg, bit);
 579
 580         return regmap_set_bits(rdev->regmap, reg, bit);
 581 }
 582
 583 /*
 584  * OPS common for BD71847 and BD71850
 585  */
 586 BD718XX_OPS(bd718xx_pickable_range_ldo_ops,
 587             regulator_list_voltage_pickable_linear_range, NULL,
 588             bd718xx_set_voltage_sel_pickable_restricted,
 589             regulator_get_voltage_sel_pickable_regmap, NULL, NULL,
 590             bd718x7_set_ldo_uvp, NULL);
 591
 592 /* BD71847 and BD71850 LDO 5 is by default OFF at RUN state */
 593 static const struct regulator_ops bd718xx_ldo5_ops_hwstate = {
 594         .is_enabled = never_enabled_by_hwstate,
 595         .list_voltage = regulator_list_voltage_pickable_linear_range,
 596         .set_voltage_sel = bd718xx_set_voltage_sel_pickable_restricted,
 597         .get_voltage_sel = regulator_get_voltage_sel_pickable_regmap,
 598         .set_under_voltage_protection = bd718x7_set_ldo_uvp,
 599 };
 600
 601 BD718XX_OPS(bd718xx_pickable_range_buck_ops,
 602             regulator_list_voltage_pickable_linear_range, NULL,
 603             regulator_set_voltage_sel_pickable_regmap,
 604             regulator_get_voltage_sel_pickable_regmap,
 605             regulator_set_voltage_time_sel, NULL, bd718x7_set_buck_uvp,
 606             bd718x7_set_buck_ovp);
 607
 608 BD718XX_OPS(bd718xx_ldo_regulator_ops, regulator_list_voltage_linear_range,
 609             NULL, bd718xx_set_voltage_sel_restricted,
 610             regulator_get_voltage_sel_regmap, NULL, NULL, bd718x7_set_ldo_uvp,
 611             NULL);
 612
 613 BD718XX_OPS(bd718xx_ldo_regulator_nolinear_ops, regulator_list_voltage_table,
 614             NULL, bd718xx_set_voltage_sel_restricted,
 615             regulator_get_voltage_sel_regmap, NULL, NULL, bd718x7_set_ldo_uvp,
 616             NULL);
 617
 618 BD718XX_OPS(bd718xx_buck_regulator_ops, regulator_list_voltage_linear_range,
 619             NULL, regulator_set_voltage_sel_regmap,
 620             regulator_get_voltage_sel_regmap, regulator_set_voltage_time_sel,
 621             NULL, bd718x7_set_buck_uvp, bd718x7_set_buck_ovp);
 622
 623 BD718XX_OPS(bd718xx_buck_regulator_nolinear_ops, regulator_list_voltage_table,
 624             regulator_map_voltage_ascend, regulator_set_voltage_sel_regmap,
 625             regulator_get_voltage_sel_regmap, regulator_set_voltage_time_sel,
 626             NULL, bd718x7_set_buck_uvp, bd718x7_set_buck_ovp);
 627
 628 /*
 629  * OPS for BD71837
 630  */
 631 BD718XX_OPS(bd71837_pickable_range_ldo_ops,
 632             regulator_list_voltage_pickable_linear_range, NULL,
 633             bd71837_set_voltage_sel_pickable_restricted,
 634             regulator_get_voltage_sel_pickable_regmap, NULL, NULL,
 635             bd718x7_set_ldo_uvp, NULL);
 636
 637 BD718XX_OPS(bd71837_pickable_range_buck_ops,
 638             regulator_list_voltage_pickable_linear_range, NULL,
 639             bd71837_set_voltage_sel_pickable_restricted,
 640             regulator_get_voltage_sel_pickable_regmap,
 641             regulator_set_voltage_time_sel, NULL, bd718x7_set_buck_uvp,
 642             bd718x7_set_buck_ovp);
 643
 644 BD718XX_OPS(bd71837_ldo_regulator_ops, regulator_list_voltage_linear_range,
 645             NULL, bd71837_set_voltage_sel_restricted,
 646             regulator_get_voltage_sel_regmap, NULL, NULL, bd718x7_set_ldo_uvp,
 647             NULL);
 648
 649 BD718XX_OPS(bd71837_ldo_regulator_nolinear_ops, regulator_list_voltage_table,
 650             NULL, bd71837_set_voltage_sel_restricted,
 651             regulator_get_voltage_sel_regmap, NULL, NULL, bd718x7_set_ldo_uvp,
 652             NULL);
 653
 654 BD718XX_OPS(bd71837_buck_regulator_ops, regulator_list_voltage_linear_range,
 655             NULL, bd71837_set_voltage_sel_restricted,
 656             regulator_get_voltage_sel_regmap, regulator_set_voltage_time_sel,
 657             NULL, bd718x7_set_buck_uvp, bd718x7_set_buck_ovp);
 658
 659 BD718XX_OPS(bd71837_buck_regulator_nolinear_ops, regulator_list_voltage_table,
 660             regulator_map_voltage_ascend, bd71837_set_voltage_sel_restricted,
 661             regulator_get_voltage_sel_regmap, regulator_set_voltage_time_sel,
 662             NULL, bd718x7_set_buck_uvp, bd718x7_set_buck_ovp);
 663 /*
 664  * BD71837 bucks 3 and 4 support defining their enable/disable state also
 665  * when buck enable state is under HW state machine control. In that case the
 666  * bit [2] in CTRL register is used to indicate if regulator should be ON.
 667  */
 668 static const struct regulator_ops bd71837_buck34_ops_hwctrl = {
 669         .is_enabled = bd71837_get_buck34_enable_hwctrl,
 670         .list_voltage = regulator_list_voltage_linear_range,
 671         .set_voltage_sel = regulator_set_voltage_sel_regmap,
 672         .get_voltage_sel = regulator_get_voltage_sel_regmap,
 673         .set_voltage_time_sel = regulator_set_voltage_time_sel,
 674         .set_ramp_delay = regulator_set_ramp_delay_regmap,
 675         .set_under_voltage_protection = bd718x7_set_buck_uvp,
 676         .set_over_voltage_protection = bd718x7_set_buck_ovp,
 677 };
 678
 679 /*
 680  * OPS for all of the ICs - BD718(37/47/50)
 681  */
 682 BD718XX_OPS(bd718xx_dvs_buck_regulator_ops, regulator_list_voltage_linear_range,
 683             NULL, regulator_set_voltage_sel_regmap,
 684             regulator_get_voltage_sel_regmap, regulator_set_voltage_time_sel,
 685             regulator_set_ramp_delay_regmap, bd718x7_set_buck_uvp,
 686             bd718x7_set_buck_ovp);
 687
 688
 689
 690 /*
 691  * There is a HW quirk in BD71837. The shutdown sequence timings for
 692  * bucks/LDOs which are controlled via register interface are changed.
 693  * At PMIC poweroff the voltage for BUCK6/7 is cut immediately at the
 694  * beginning of shut-down sequence. As bucks 6 and 7 are parent
 695  * supplies for LDO5 and LDO6 - this causes LDO5/6 voltage
 696  * monitoring to errorneously detect under voltage and force PMIC to
 697  * emergency state instead of poweroff. In order to avoid this we
 698  * disable voltage monitoring for LDO5 and LDO6
 699  */
 700 static const struct reg_init bd71837_ldo5_inits[] = {
 701         {
 702                 .reg = BD718XX_REG_MVRFLTMASK2,
 703                 .mask = BD718XX_LDO5_VRMON80,
 704                 .val = BD718XX_LDO5_VRMON80,
 705         },
 706 };
 707
 708 static const struct reg_init bd71837_ldo6_inits[] = {
 709         {
 710                 .reg = BD718XX_REG_MVRFLTMASK2,
 711                 .mask = BD718XX_LDO6_VRMON80,
 712                 .val = BD718XX_LDO6_VRMON80,
 713         },
 714 };
 715
 716 static int buck_set_hw_dvs_levels(struct device_node *np,
 717                             const struct regulator_desc *desc,
 718                             struct regulator_config *cfg)
 719 {
 720         struct bd718xx_regulator_data *data;
 721
 722         data = container_of(desc, struct bd718xx_regulator_data, desc);
 723
 724         return rohm_regulator_set_dvs_levels(&data->dvs, np, desc, cfg->regmap);
 725 }
 726
 727 static const struct regulator_ops *bd71847_swcontrol_ops[] = {
 728         &bd718xx_dvs_buck_regulator_ops, &bd718xx_dvs_buck_regulator_ops,
 729         &bd718xx_pickable_range_buck_ops, &bd718xx_pickable_range_buck_ops,
 730         &bd718xx_buck_regulator_nolinear_ops, &bd718xx_buck_regulator_ops,
 731         &bd718xx_pickable_range_ldo_ops, &bd718xx_ldo_regulator_nolinear_ops,
 732         &bd718xx_ldo_regulator_ops, &bd718xx_ldo_regulator_ops,
 733         &bd718xx_pickable_range_ldo_ops, &bd718xx_ldo_regulator_ops,
 734 };
 735
 736 static const struct regulator_ops *bd71847_hwcontrol_ops[] = {
 737         &BD718XX_HWOPNAME(bd718xx_dvs_buck_regulator_ops),
 738         &BD718XX_HWOPNAME(bd718xx_dvs_buck_regulator_ops),
 739         &BD718XX_HWOPNAME(bd718xx_pickable_range_buck_ops),
 740         &BD718XX_HWOPNAME(bd718xx_pickable_range_buck_ops),
 741         &BD718XX_HWOPNAME(bd718xx_buck_regulator_nolinear_ops),
 742         &BD718XX_HWOPNAME(bd718xx_buck_regulator_ops),
 743         &BD718XX_HWOPNAME(bd718xx_pickable_range_ldo_ops),
 744         &BD718XX_HWOPNAME(bd718xx_ldo_regulator_nolinear_ops),
 745         &BD718XX_HWOPNAME(bd718xx_ldo_regulator_ops),
 746         &BD718XX_HWOPNAME(bd718xx_ldo_regulator_ops),
 747         &bd718xx_ldo5_ops_hwstate,
 748         &BD718XX_HWOPNAME(bd718xx_ldo_regulator_ops),
 749 };
 750
 751 static struct bd718xx_regulator_data bd71847_regulators[] = {
 752         {
 753                 .desc = {
 754                         .name = "buck1",
 755                         .of_match = of_match_ptr("BUCK1"),
 756                         .regulators_node = of_match_ptr("regulators"),
 757                         .id = BD718XX_BUCK1,
 758                         .type = REGULATOR_VOLTAGE,
 759                         .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
 760                         .linear_ranges = bd718xx_dvs_buck_volts,
 761                         .n_linear_ranges =
 762                                 ARRAY_SIZE(bd718xx_dvs_buck_volts),
 763                         .vsel_reg = BD718XX_REG_BUCK1_VOLT_RUN,
 764                         .vsel_mask = DVS_BUCK_RUN_MASK,
 765                         .enable_reg = BD718XX_REG_BUCK1_CTRL,
 766                         .enable_mask = BD718XX_BUCK_EN,
 767                         .enable_time = BD71847_BUCK1_STARTUP_TIME,
 768                         .owner = THIS_MODULE,
 769                         .ramp_delay_table = bd718xx_ramp_delay,
 770                         .n_ramp_values = ARRAY_SIZE(bd718xx_ramp_delay),
 771                         .ramp_reg = BD718XX_REG_BUCK1_CTRL,
 772                         .ramp_mask = BUCK_RAMPRATE_MASK,
 773                         .of_parse_cb = buck_set_hw_dvs_levels,
 774                 },
 775                 .dvs = {
 776                         .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
 777                                      ROHM_DVS_LEVEL_SUSPEND,
 778                         .run_reg = BD718XX_REG_BUCK1_VOLT_RUN,
 779                         .run_mask = DVS_BUCK_RUN_MASK,
 780                         .idle_reg = BD718XX_REG_BUCK1_VOLT_IDLE,
 781                         .idle_mask = DVS_BUCK_RUN_MASK,
 782                         .suspend_reg = BD718XX_REG_BUCK1_VOLT_SUSP,
 783                         .suspend_mask = DVS_BUCK_RUN_MASK,
 784                 },
 785                 .init = {
 786                         .reg = BD718XX_REG_BUCK1_CTRL,
 787                         .mask = BD718XX_BUCK_SEL,
 788                         .val = BD718XX_BUCK_SEL,
 789                 },
 790         },
 791         {
 792                 .desc = {
 793                         .name = "buck2",
 794                         .of_match = of_match_ptr("BUCK2"),
 795                         .regulators_node = of_match_ptr("regulators"),
 796                         .id = BD718XX_BUCK2,
 797                         .type = REGULATOR_VOLTAGE,
 798                         .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
 799                         .linear_ranges = bd718xx_dvs_buck_volts,
 800                         .n_linear_ranges = ARRAY_SIZE(bd718xx_dvs_buck_volts),
 801                         .vsel_reg = BD718XX_REG_BUCK2_VOLT_RUN,
 802                         .vsel_mask = DVS_BUCK_RUN_MASK,
 803                         .enable_reg = BD718XX_REG_BUCK2_CTRL,
 804                         .enable_mask = BD718XX_BUCK_EN,
 805                         .enable_time = BD71847_BUCK2_STARTUP_TIME,
 806                         .ramp_delay_table = bd718xx_ramp_delay,
 807                         .n_ramp_values = ARRAY_SIZE(bd718xx_ramp_delay),
 808                         .ramp_reg = BD718XX_REG_BUCK2_CTRL,
 809                         .ramp_mask = BUCK_RAMPRATE_MASK,
 810                         .owner = THIS_MODULE,
 811                         .of_parse_cb = buck_set_hw_dvs_levels,
 812                 },
 813                 .dvs = {
 814                         .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE,
 815                         .run_reg = BD718XX_REG_BUCK2_VOLT_RUN,
 816                         .run_mask = DVS_BUCK_RUN_MASK,
 817                         .idle_reg = BD718XX_REG_BUCK2_VOLT_IDLE,
 818                         .idle_mask = DVS_BUCK_RUN_MASK,
 819                 },
 820                 .init = {
 821                         .reg = BD718XX_REG_BUCK2_CTRL,
 822                         .mask = BD718XX_BUCK_SEL,
 823                         .val = BD718XX_BUCK_SEL,
 824                 },
 825         },
 826         {
 827                 .desc = {
 828                         .name = "buck3",
 829                         .of_match = of_match_ptr("BUCK3"),
 830                         .regulators_node = of_match_ptr("regulators"),
 831                         .id = BD718XX_BUCK3,
 832                         .type = REGULATOR_VOLTAGE,
 833                         .n_voltages = BD71847_BUCK3_VOLTAGE_NUM,
 834                         .linear_ranges = bd71847_buck3_volts,
 835                         .n_linear_ranges =
 836                                 ARRAY_SIZE(bd71847_buck3_volts),
 837                         .vsel_reg = BD718XX_REG_1ST_NODVS_BUCK_VOLT,
 838                         .vsel_mask = BD718XX_1ST_NODVS_BUCK_MASK,
 839                         .vsel_range_reg = BD718XX_REG_1ST_NODVS_BUCK_VOLT,
 840                         .vsel_range_mask = BD71847_BUCK3_RANGE_MASK,
 841                         .linear_range_selectors = bd71847_buck3_volt_range_sel,
 842                         .enable_reg = BD718XX_REG_1ST_NODVS_BUCK_CTRL,
 843                         .enable_mask = BD718XX_BUCK_EN,
 844                         .enable_time = BD71847_BUCK3_STARTUP_TIME,
 845                         .owner = THIS_MODULE,
 846                 },
 847                 .init = {
 848                         .reg = BD718XX_REG_1ST_NODVS_BUCK_CTRL,
 849                         .mask = BD718XX_BUCK_SEL,
 850                         .val = BD718XX_BUCK_SEL,
 851                 },
 852         },
 853         {
 854                 .desc = {
 855                         .name = "buck4",
 856                         .of_match = of_match_ptr("BUCK4"),
 857                         .regulators_node = of_match_ptr("regulators"),
 858                         .id = BD718XX_BUCK4,
 859                         .type = REGULATOR_VOLTAGE,
 860                         .n_voltages = BD71847_BUCK4_VOLTAGE_NUM,
 861                         .linear_ranges = bd71847_buck4_volts,
 862                         .n_linear_ranges =
 863                                 ARRAY_SIZE(bd71847_buck4_volts),
 864                         .enable_reg = BD718XX_REG_2ND_NODVS_BUCK_CTRL,
 865                         .vsel_reg = BD718XX_REG_2ND_NODVS_BUCK_VOLT,
 866                         .vsel_mask = BD71847_BUCK4_MASK,
 867                         .vsel_range_reg = BD718XX_REG_2ND_NODVS_BUCK_VOLT,
 868                         .vsel_range_mask = BD71847_BUCK4_RANGE_MASK,
 869                         .linear_range_selectors = bd71847_buck4_volt_range_sel,
 870                         .enable_mask = BD718XX_BUCK_EN,
 871                         .enable_time = BD71847_BUCK4_STARTUP_TIME,
 872                         .owner = THIS_MODULE,
 873                 },
 874                 .init = {
 875                         .reg = BD718XX_REG_2ND_NODVS_BUCK_CTRL,
 876                         .mask = BD718XX_BUCK_SEL,
 877                         .val = BD718XX_BUCK_SEL,
 878                 },
 879         },
 880         {
 881                 .desc = {
 882                         .name = "buck5",
 883                         .of_match = of_match_ptr("BUCK5"),
 884                         .regulators_node = of_match_ptr("regulators"),
 885                         .id = BD718XX_BUCK5,
 886                         .type = REGULATOR_VOLTAGE,
 887                         .volt_table = &bd718xx_3rd_nodvs_buck_volts[0],
 888                         .n_voltages = ARRAY_SIZE(bd718xx_3rd_nodvs_buck_volts),
 889                         .vsel_reg = BD718XX_REG_3RD_NODVS_BUCK_VOLT,
 890                         .vsel_mask = BD718XX_3RD_NODVS_BUCK_MASK,
 891                         .enable_reg = BD718XX_REG_3RD_NODVS_BUCK_CTRL,
 892                         .enable_mask = BD718XX_BUCK_EN,
 893                         .enable_time = BD71847_BUCK5_STARTUP_TIME,
 894                         .owner = THIS_MODULE,
 895                 },
 896                 .init = {
 897                         .reg = BD718XX_REG_3RD_NODVS_BUCK_CTRL,
 898                         .mask = BD718XX_BUCK_SEL,
 899                         .val = BD718XX_BUCK_SEL,
 900                 },
 901         },
 902         {
 903                 .desc = {
 904                         .name = "buck6",
 905                         .of_match = of_match_ptr("BUCK6"),
 906                         .regulators_node = of_match_ptr("regulators"),
 907                         .id = BD718XX_BUCK6,
 908                         .type = REGULATOR_VOLTAGE,
 909                         .n_voltages = BD718XX_4TH_NODVS_BUCK_VOLTAGE_NUM,
 910                         .linear_ranges = bd718xx_4th_nodvs_buck_volts,
 911                         .n_linear_ranges =
 912                                 ARRAY_SIZE(bd718xx_4th_nodvs_buck_volts),
 913                         .vsel_reg = BD718XX_REG_4TH_NODVS_BUCK_VOLT,
 914                         .vsel_mask = BD718XX_4TH_NODVS_BUCK_MASK,
 915                         .enable_reg = BD718XX_REG_4TH_NODVS_BUCK_CTRL,
 916                         .enable_mask = BD718XX_BUCK_EN,
 917                         .enable_time = BD71847_BUCK6_STARTUP_TIME,
 918                         .owner = THIS_MODULE,
 919                 },
 920                 .init = {
 921                         .reg = BD718XX_REG_4TH_NODVS_BUCK_CTRL,
 922                         .mask = BD718XX_BUCK_SEL,
 923                         .val = BD718XX_BUCK_SEL,
 924                 },
 925         },
 926         {
 927                 .desc = {
 928                         .name = "ldo1",
 929                         .of_match = of_match_ptr("LDO1"),
 930                         .regulators_node = of_match_ptr("regulators"),
 931                         .id = BD718XX_LDO1,
 932                         .type = REGULATOR_VOLTAGE,
 933                         .n_voltages = BD718XX_LDO1_VOLTAGE_NUM,
 934                         .linear_ranges = bd718xx_ldo1_volts,
 935                         .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo1_volts),
 936                         .vsel_reg = BD718XX_REG_LDO1_VOLT,
 937                         .vsel_mask = BD718XX_LDO1_MASK,
 938                         .vsel_range_reg = BD718XX_REG_LDO1_VOLT,
 939                         .vsel_range_mask = BD718XX_LDO1_RANGE_MASK,
 940                         .linear_range_selectors = bd718xx_ldo1_volt_range_sel,
 941                         .enable_reg = BD718XX_REG_LDO1_VOLT,
 942                         .enable_mask = BD718XX_LDO_EN,
 943                         .enable_time = BD71847_LDO1_STARTUP_TIME,
 944                         .owner = THIS_MODULE,
 945                 },
 946                 .init = {
 947                         .reg = BD718XX_REG_LDO1_VOLT,
 948                         .mask = BD718XX_LDO_SEL,
 949                         .val = BD718XX_LDO_SEL,
 950                 },
 951         },
 952         {
 953                 .desc = {
 954                         .name = "ldo2",
 955                         .of_match = of_match_ptr("LDO2"),
 956                         .regulators_node = of_match_ptr("regulators"),
 957                         .id = BD718XX_LDO2,
 958                         .type = REGULATOR_VOLTAGE,
 959                         .volt_table = &ldo_2_volts[0],
 960                         .vsel_reg = BD718XX_REG_LDO2_VOLT,
 961                         .vsel_mask = BD718XX_LDO2_MASK,
 962                         .n_voltages = ARRAY_SIZE(ldo_2_volts),
 963                         .enable_reg = BD718XX_REG_LDO2_VOLT,
 964                         .enable_mask = BD718XX_LDO_EN,
 965                         .enable_time = BD71847_LDO2_STARTUP_TIME,
 966                         .owner = THIS_MODULE,
 967                 },
 968                 .init = {
 969                         .reg = BD718XX_REG_LDO2_VOLT,
 970                         .mask = BD718XX_LDO_SEL,
 971                         .val = BD718XX_LDO_SEL,
 972                 },
 973         },
 974         {
 975                 .desc = {
 976                         .name = "ldo3",
 977                         .of_match = of_match_ptr("LDO3"),
 978                         .regulators_node = of_match_ptr("regulators"),
 979                         .id = BD718XX_LDO3,
 980                         .type = REGULATOR_VOLTAGE,
 981                         .n_voltages = BD718XX_LDO3_VOLTAGE_NUM,
 982                         .linear_ranges = bd718xx_ldo3_volts,
 983                         .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo3_volts),
 984                         .vsel_reg = BD718XX_REG_LDO3_VOLT,
 985                         .vsel_mask = BD718XX_LDO3_MASK,
 986                         .enable_reg = BD718XX_REG_LDO3_VOLT,
 987                         .enable_mask = BD718XX_LDO_EN,
 988                         .enable_time = BD71847_LDO3_STARTUP_TIME,
 989                         .owner = THIS_MODULE,
 990                 },
 991                 .init = {
 992                         .reg = BD718XX_REG_LDO3_VOLT,
 993                         .mask = BD718XX_LDO_SEL,
 994                         .val = BD718XX_LDO_SEL,
 995                 },
 996         },
 997         {
 998                 .desc = {
 999                         .name = "ldo4",
1000                         .of_match = of_match_ptr("LDO4"),
1001                         .regulators_node = of_match_ptr("regulators"),
1002                         .id = BD718XX_LDO4,
1003                         .type = REGULATOR_VOLTAGE,
1004                         .n_voltages = BD718XX_LDO4_VOLTAGE_NUM,
1005                         .linear_ranges = bd718xx_ldo4_volts,
1006                         .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo4_volts),
1007                         .vsel_reg = BD718XX_REG_LDO4_VOLT,
1008                         .vsel_mask = BD718XX_LDO4_MASK,
1009                         .enable_reg = BD718XX_REG_LDO4_VOLT,
1010                         .enable_mask = BD718XX_LDO_EN,
1011                         .enable_time = BD71847_LDO4_STARTUP_TIME,
1012                         .owner = THIS_MODULE,
1013                 },
1014                 .init = {
1015                         .reg = BD718XX_REG_LDO4_VOLT,
1016                         .mask = BD718XX_LDO_SEL,
1017                         .val = BD718XX_LDO_SEL,
1018                 },
1019         },
1020         {
1021                 .desc = {
1022                         .name = "ldo5",
1023                         .of_match = of_match_ptr("LDO5"),
1024                         .regulators_node = of_match_ptr("regulators"),
1025                         .id = BD718XX_LDO5,
1026                         .type = REGULATOR_VOLTAGE,
1027                         .n_voltages = BD71847_LDO5_VOLTAGE_NUM,
1028                         .linear_ranges = bd71847_ldo5_volts,
1029                         .n_linear_ranges = ARRAY_SIZE(bd71847_ldo5_volts),
1030                         .vsel_reg = BD718XX_REG_LDO5_VOLT,
1031                         .vsel_mask = BD71847_LDO5_MASK,
1032                         .vsel_range_reg = BD718XX_REG_LDO5_VOLT,
1033                         .vsel_range_mask = BD71847_LDO5_RANGE_MASK,
1034                         .linear_range_selectors = bd71847_ldo5_volt_range_sel,
1035                         .enable_reg = BD718XX_REG_LDO5_VOLT,
1036                         .enable_mask = BD718XX_LDO_EN,
1037                         .enable_time = BD71847_LDO5_STARTUP_TIME,
1038                         .owner = THIS_MODULE,
1039                 },
1040                 .init = {
1041                         .reg = BD718XX_REG_LDO5_VOLT,
1042                         .mask = BD718XX_LDO_SEL,
1043                         .val = BD718XX_LDO_SEL,
1044                 },
1045         },
1046         {
1047                 .desc = {
1048                         .name = "ldo6",
1049                         .of_match = of_match_ptr("LDO6"),
1050                         .regulators_node = of_match_ptr("regulators"),
1051                         .id = BD718XX_LDO6,
1052                         .type = REGULATOR_VOLTAGE,
1053                         .n_voltages = BD718XX_LDO6_VOLTAGE_NUM,
1054                         .linear_ranges = bd718xx_ldo6_volts,
1055                         .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo6_volts),
1056                         /* LDO6 is supplied by buck5 */
1057                         .supply_name = "buck5",
1058                         .vsel_reg = BD718XX_REG_LDO6_VOLT,
1059                         .vsel_mask = BD718XX_LDO6_MASK,
1060                         .enable_reg = BD718XX_REG_LDO6_VOLT,
1061                         .enable_mask = BD718XX_LDO_EN,
1062                         .enable_time = BD71847_LDO6_STARTUP_TIME,
1063                         .owner = THIS_MODULE,
1064                 },
1065                 .init = {
1066                         .reg = BD718XX_REG_LDO6_VOLT,
1067                         .mask = BD718XX_LDO_SEL,
1068                         .val = BD718XX_LDO_SEL,
1069                 },
1070         },
1071 };
1072
1073 static const struct regulator_ops *bd71837_swcontrol_ops[] = {
1074         &bd718xx_dvs_buck_regulator_ops, &bd718xx_dvs_buck_regulator_ops,
1075         &bd718xx_dvs_buck_regulator_ops, &bd718xx_dvs_buck_regulator_ops,
1076         &bd71837_pickable_range_buck_ops, &bd71837_buck_regulator_ops,
1077         &bd71837_buck_regulator_nolinear_ops, &bd71837_buck_regulator_ops,
1078         &bd71837_pickable_range_ldo_ops, &bd71837_ldo_regulator_nolinear_ops,
1079         &bd71837_ldo_regulator_ops, &bd71837_ldo_regulator_ops,
1080         &bd71837_ldo_regulator_ops, &bd71837_ldo_regulator_ops,
1081         &bd71837_ldo_regulator_ops,
1082 };
1083
1084 static const struct regulator_ops *bd71837_hwcontrol_ops[] = {
1085         &BD718XX_HWOPNAME(bd718xx_dvs_buck_regulator_ops),
1086         &BD718XX_HWOPNAME(bd718xx_dvs_buck_regulator_ops),
1087         &bd71837_buck34_ops_hwctrl, &bd71837_buck34_ops_hwctrl,
1088         &BD718XX_HWOPNAME(bd71837_pickable_range_buck_ops),
1089         &BD718XX_HWOPNAME(bd71837_buck_regulator_ops),
1090         &BD718XX_HWOPNAME(bd71837_buck_regulator_nolinear_ops),
1091         &BD718XX_HWOPNAME(bd71837_buck_regulator_ops),
1092         &BD718XX_HWOPNAME(bd71837_pickable_range_ldo_ops),
1093         &BD718XX_HWOPNAME(bd71837_ldo_regulator_nolinear_ops),
1094         &BD718XX_HWOPNAME(bd71837_ldo_regulator_ops),
1095         &BD718XX_HWOPNAME(bd71837_ldo_regulator_ops),
1096         &BD718XX_HWOPNAME(bd71837_ldo_regulator_ops),
1097         &BD718XX_HWOPNAME(bd71837_ldo_regulator_ops),
1098         &BD718XX_HWOPNAME(bd71837_ldo_regulator_ops),
1099 };
1100
1101 static struct bd718xx_regulator_data bd71837_regulators[] = {
1102         {
1103                 .desc = {
1104                         .name = "buck1",
1105                         .of_match = of_match_ptr("BUCK1"),
1106                         .regulators_node = of_match_ptr("regulators"),
1107                         .id = BD718XX_BUCK1,
1108                         .type = REGULATOR_VOLTAGE,
1109                         .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
1110                         .linear_ranges = bd718xx_dvs_buck_volts,
1111                         .n_linear_ranges = ARRAY_SIZE(bd718xx_dvs_buck_volts),
1112                         .vsel_reg = BD718XX_REG_BUCK1_VOLT_RUN,
1113                         .vsel_mask = DVS_BUCK_RUN_MASK,
1114                         .enable_reg = BD718XX_REG_BUCK1_CTRL,
1115                         .enable_mask = BD718XX_BUCK_EN,
1116                         .enable_time = BD71837_BUCK1_STARTUP_TIME,
1117                         .ramp_delay_table = bd718xx_ramp_delay,
1118                         .n_ramp_values = ARRAY_SIZE(bd718xx_ramp_delay),
1119                         .ramp_reg = BD718XX_REG_BUCK1_CTRL,
1120                         .ramp_mask = BUCK_RAMPRATE_MASK,
1121                         .owner = THIS_MODULE,
1122                         .of_parse_cb = buck_set_hw_dvs_levels,
1123                 },
1124                 .dvs = {
1125                         .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
1126                                      ROHM_DVS_LEVEL_SUSPEND,
1127                         .run_reg = BD718XX_REG_BUCK1_VOLT_RUN,
1128                         .run_mask = DVS_BUCK_RUN_MASK,
1129                         .idle_reg = BD718XX_REG_BUCK1_VOLT_IDLE,
1130                         .idle_mask = DVS_BUCK_RUN_MASK,
1131                         .suspend_reg = BD718XX_REG_BUCK1_VOLT_SUSP,
1132                         .suspend_mask = DVS_BUCK_RUN_MASK,
1133                 },
1134                 .init = {
1135                         .reg = BD718XX_REG_BUCK1_CTRL,
1136                         .mask = BD718XX_BUCK_SEL,
1137                         .val = BD718XX_BUCK_SEL,
1138                 },
1139         },
1140         {
1141                 .desc = {
1142                         .name = "buck2",
1143                         .of_match = of_match_ptr("BUCK2"),
1144                         .regulators_node = of_match_ptr("regulators"),
1145                         .id = BD718XX_BUCK2,
1146                         .type = REGULATOR_VOLTAGE,
1147                         .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
1148                         .linear_ranges = bd718xx_dvs_buck_volts,
1149                         .n_linear_ranges = ARRAY_SIZE(bd718xx_dvs_buck_volts),
1150                         .vsel_reg = BD718XX_REG_BUCK2_VOLT_RUN,
1151                         .vsel_mask = DVS_BUCK_RUN_MASK,
1152                         .enable_reg = BD718XX_REG_BUCK2_CTRL,
1153                         .enable_mask = BD718XX_BUCK_EN,
1154                         .enable_time = BD71837_BUCK2_STARTUP_TIME,
1155                         .ramp_delay_table = bd718xx_ramp_delay,
1156                         .n_ramp_values = ARRAY_SIZE(bd718xx_ramp_delay),
1157                         .ramp_reg = BD718XX_REG_BUCK2_CTRL,
1158                         .ramp_mask = BUCK_RAMPRATE_MASK,
1159                         .owner = THIS_MODULE,
1160                         .of_parse_cb = buck_set_hw_dvs_levels,
1161                 },
1162                 .dvs = {
1163                         .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE,
1164                         .run_reg = BD718XX_REG_BUCK2_VOLT_RUN,
1165                         .run_mask = DVS_BUCK_RUN_MASK,
1166                         .idle_reg = BD718XX_REG_BUCK2_VOLT_IDLE,
1167                         .idle_mask = DVS_BUCK_RUN_MASK,
1168                 },
1169                 .init = {
1170                         .reg = BD718XX_REG_BUCK2_CTRL,
1171                         .mask = BD718XX_BUCK_SEL,
1172                         .val = BD718XX_BUCK_SEL,
1173                 },
1174         },
1175         {
1176                 .desc = {
1177                         .name = "buck3",
1178                         .of_match = of_match_ptr("BUCK3"),
1179                         .regulators_node = of_match_ptr("regulators"),
1180                         .id = BD718XX_BUCK3,
1181                         .type = REGULATOR_VOLTAGE,
1182                         .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
1183                         .linear_ranges = bd718xx_dvs_buck_volts,
1184                         .n_linear_ranges = ARRAY_SIZE(bd718xx_dvs_buck_volts),
1185                         .vsel_reg = BD71837_REG_BUCK3_VOLT_RUN,
1186                         .vsel_mask = DVS_BUCK_RUN_MASK,
1187                         .enable_reg = BD71837_REG_BUCK3_CTRL,
1188                         .enable_mask = BD718XX_BUCK_EN,
1189                         .enable_time = BD71837_BUCK3_STARTUP_TIME,
1190                         .ramp_delay_table = bd718xx_ramp_delay,
1191                         .n_ramp_values = ARRAY_SIZE(bd718xx_ramp_delay),
1192                         .ramp_reg = BD71837_REG_BUCK3_CTRL,
1193                         .ramp_mask = BUCK_RAMPRATE_MASK,
1194                         .owner = THIS_MODULE,
1195                         .of_parse_cb = buck_set_hw_dvs_levels,
1196                 },
1197                 .dvs = {
1198                         .level_map = ROHM_DVS_LEVEL_RUN,
1199                         .run_reg = BD71837_REG_BUCK3_VOLT_RUN,
1200                         .run_mask = DVS_BUCK_RUN_MASK,
1201                 },
1202                 .init = {
1203                         .reg = BD71837_REG_BUCK3_CTRL,
1204                         .mask = BD718XX_BUCK_SEL,
1205                         .val = BD718XX_BUCK_SEL,
1206                 },
1207         },
1208         {
1209                 .desc = {
1210                         .name = "buck4",
1211                         .of_match = of_match_ptr("BUCK4"),
1212                         .regulators_node = of_match_ptr("regulators"),
1213                         .id = BD718XX_BUCK4,
1214                         .type = REGULATOR_VOLTAGE,
1215                         .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
1216                         .linear_ranges = bd718xx_dvs_buck_volts,
1217                         .n_linear_ranges = ARRAY_SIZE(bd718xx_dvs_buck_volts),
1218                         .vsel_reg = BD71837_REG_BUCK4_VOLT_RUN,
1219                         .vsel_mask = DVS_BUCK_RUN_MASK,
1220                         .enable_reg = BD71837_REG_BUCK4_CTRL,
1221                         .enable_mask = BD718XX_BUCK_EN,
1222                         .enable_time = BD71837_BUCK4_STARTUP_TIME,
1223                         .ramp_delay_table = bd718xx_ramp_delay,
1224                         .n_ramp_values = ARRAY_SIZE(bd718xx_ramp_delay),
1225                         .ramp_reg = BD71837_REG_BUCK4_CTRL,
1226                         .ramp_mask = BUCK_RAMPRATE_MASK,
1227                         .owner = THIS_MODULE,
1228                         .of_parse_cb = buck_set_hw_dvs_levels,
1229                 },
1230                 .dvs = {
1231                         .level_map = ROHM_DVS_LEVEL_RUN,
1232                         .run_reg = BD71837_REG_BUCK4_VOLT_RUN,
1233                         .run_mask = DVS_BUCK_RUN_MASK,
1234                 },
1235                 .init = {
1236                         .reg = BD71837_REG_BUCK4_CTRL,
1237                         .mask = BD718XX_BUCK_SEL,
1238                         .val = BD718XX_BUCK_SEL,
1239                 },
1240         },
1241         {
1242                 .desc = {
1243                         .name = "buck5",
1244                         .of_match = of_match_ptr("BUCK5"),
1245                         .regulators_node = of_match_ptr("regulators"),
1246                         .id = BD718XX_BUCK5,
1247                         .type = REGULATOR_VOLTAGE,
1248                         .n_voltages = BD71837_BUCK5_VOLTAGE_NUM,
1249                         .linear_ranges = bd71837_buck5_volts,
1250                         .n_linear_ranges =
1251                                 ARRAY_SIZE(bd71837_buck5_volts),
1252                         .vsel_reg = BD718XX_REG_1ST_NODVS_BUCK_VOLT,
1253                         .vsel_mask = BD71837_BUCK5_MASK,
1254                         .vsel_range_reg = BD718XX_REG_1ST_NODVS_BUCK_VOLT,
1255                         .vsel_range_mask = BD71837_BUCK5_RANGE_MASK,
1256                         .linear_range_selectors = bd71837_buck5_volt_range_sel,
1257                         .enable_reg = BD718XX_REG_1ST_NODVS_BUCK_CTRL,
1258                         .enable_mask = BD718XX_BUCK_EN,
1259                         .enable_time = BD71837_BUCK5_STARTUP_TIME,
1260                         .owner = THIS_MODULE,
1261                 },
1262                 .init = {
1263                         .reg = BD718XX_REG_1ST_NODVS_BUCK_CTRL,
1264                         .mask = BD718XX_BUCK_SEL,
1265                         .val = BD718XX_BUCK_SEL,
1266                 },
1267         },
1268         {
1269                 .desc = {
1270                         .name = "buck6",
1271                         .of_match = of_match_ptr("BUCK6"),
1272                         .regulators_node = of_match_ptr("regulators"),
1273                         .id = BD718XX_BUCK6,
1274                         .type = REGULATOR_VOLTAGE,
1275                         .n_voltages = BD71837_BUCK6_VOLTAGE_NUM,
1276                         .linear_ranges = bd71837_buck6_volts,
1277                         .n_linear_ranges =
1278                                 ARRAY_SIZE(bd71837_buck6_volts),
1279                         .vsel_reg = BD718XX_REG_2ND_NODVS_BUCK_VOLT,
1280                         .vsel_mask = BD71837_BUCK6_MASK,
1281                         .enable_reg = BD718XX_REG_2ND_NODVS_BUCK_CTRL,
1282                         .enable_mask = BD718XX_BUCK_EN,
1283                         .enable_time = BD71837_BUCK6_STARTUP_TIME,
1284                         .owner = THIS_MODULE,
1285                 },
1286                 .init = {
1287                         .reg = BD718XX_REG_2ND_NODVS_BUCK_CTRL,
1288                         .mask = BD718XX_BUCK_SEL,
1289                         .val = BD718XX_BUCK_SEL,
1290                 },
1291         },
1292         {
1293                 .desc = {
1294                         .name = "buck7",
1295                         .of_match = of_match_ptr("BUCK7"),
1296                         .regulators_node = of_match_ptr("regulators"),
1297                         .id = BD718XX_BUCK7,
1298                         .type = REGULATOR_VOLTAGE,
1299                         .volt_table = &bd718xx_3rd_nodvs_buck_volts[0],
1300                         .n_voltages = ARRAY_SIZE(bd718xx_3rd_nodvs_buck_volts),
1301                         .vsel_reg = BD718XX_REG_3RD_NODVS_BUCK_VOLT,
1302                         .vsel_mask = BD718XX_3RD_NODVS_BUCK_MASK,
1303                         .enable_reg = BD718XX_REG_3RD_NODVS_BUCK_CTRL,
1304                         .enable_mask = BD718XX_BUCK_EN,
1305                         .enable_time = BD71837_BUCK7_STARTUP_TIME,
1306                         .owner = THIS_MODULE,
1307                 },
1308                 .init = {
1309                         .reg = BD718XX_REG_3RD_NODVS_BUCK_CTRL,
1310                         .mask = BD718XX_BUCK_SEL,
1311                         .val = BD718XX_BUCK_SEL,
1312                 },
1313         },
1314         {
1315                 .desc = {
1316                         .name = "buck8",
1317                         .of_match = of_match_ptr("BUCK8"),
1318                         .regulators_node = of_match_ptr("regulators"),
1319                         .id = BD718XX_BUCK8,
1320                         .type = REGULATOR_VOLTAGE,
1321                         .n_voltages = BD718XX_4TH_NODVS_BUCK_VOLTAGE_NUM,
1322                         .linear_ranges = bd718xx_4th_nodvs_buck_volts,
1323                         .n_linear_ranges =
1324                                 ARRAY_SIZE(bd718xx_4th_nodvs_buck_volts),
1325                         .vsel_reg = BD718XX_REG_4TH_NODVS_BUCK_VOLT,
1326                         .vsel_mask = BD718XX_4TH_NODVS_BUCK_MASK,
1327                         .enable_reg = BD718XX_REG_4TH_NODVS_BUCK_CTRL,
1328                         .enable_mask = BD718XX_BUCK_EN,
1329                         .enable_time = BD71837_BUCK8_STARTUP_TIME,
1330                         .owner = THIS_MODULE,
1331                 },
1332                 .init = {
1333                         .reg = BD718XX_REG_4TH_NODVS_BUCK_CTRL,
1334                         .mask = BD718XX_BUCK_SEL,
1335                         .val = BD718XX_BUCK_SEL,
1336                 },
1337         },
1338         {
1339                 .desc = {
1340                         .name = "ldo1",
1341                         .of_match = of_match_ptr("LDO1"),
1342                         .regulators_node = of_match_ptr("regulators"),
1343                         .id = BD718XX_LDO1,
1344                         .type = REGULATOR_VOLTAGE,
1345                         .n_voltages = BD718XX_LDO1_VOLTAGE_NUM,
1346                         .linear_ranges = bd718xx_ldo1_volts,
1347                         .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo1_volts),
1348                         .vsel_reg = BD718XX_REG_LDO1_VOLT,
1349                         .vsel_mask = BD718XX_LDO1_MASK,
1350                         .vsel_range_reg = BD718XX_REG_LDO1_VOLT,
1351                         .vsel_range_mask = BD718XX_LDO1_RANGE_MASK,
1352                         .linear_range_selectors = bd718xx_ldo1_volt_range_sel,
1353                         .enable_reg = BD718XX_REG_LDO1_VOLT,
1354                         .enable_mask = BD718XX_LDO_EN,
1355                         .enable_time = BD71837_LDO1_STARTUP_TIME,
1356                         .owner = THIS_MODULE,
1357                 },
1358                 .init = {
1359                         .reg = BD718XX_REG_LDO1_VOLT,
1360                         .mask = BD718XX_LDO_SEL,
1361                         .val = BD718XX_LDO_SEL,
1362                 },
1363         },
1364         {
1365                 .desc = {
1366                         .name = "ldo2",
1367                         .of_match = of_match_ptr("LDO2"),
1368                         .regulators_node = of_match_ptr("regulators"),
1369                         .id = BD718XX_LDO2,
1370                         .type = REGULATOR_VOLTAGE,
1371                         .volt_table = &ldo_2_volts[0],
1372                         .vsel_reg = BD718XX_REG_LDO2_VOLT,
1373                         .vsel_mask = BD718XX_LDO2_MASK,
1374                         .n_voltages = ARRAY_SIZE(ldo_2_volts),
1375                         .enable_reg = BD718XX_REG_LDO2_VOLT,
1376                         .enable_mask = BD718XX_LDO_EN,
1377                         .enable_time = BD71837_LDO2_STARTUP_TIME,
1378                         .owner = THIS_MODULE,
1379                 },
1380                 .init = {
1381                         .reg = BD718XX_REG_LDO2_VOLT,
1382                         .mask = BD718XX_LDO_SEL,
1383                         .val = BD718XX_LDO_SEL,
1384                 },
1385         },
1386         {
1387                 .desc = {
1388                         .name = "ldo3",
1389                         .of_match = of_match_ptr("LDO3"),
1390                         .regulators_node = of_match_ptr("regulators"),
1391                         .id = BD718XX_LDO3,
1392                         .type = REGULATOR_VOLTAGE,
1393                         .n_voltages = BD718XX_LDO3_VOLTAGE_NUM,
1394                         .linear_ranges = bd718xx_ldo3_volts,
1395                         .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo3_volts),
1396                         .vsel_reg = BD718XX_REG_LDO3_VOLT,
1397                         .vsel_mask = BD718XX_LDO3_MASK,
1398                         .enable_reg = BD718XX_REG_LDO3_VOLT,
1399                         .enable_mask = BD718XX_LDO_EN,
1400                         .enable_time = BD71837_LDO3_STARTUP_TIME,
1401                         .owner = THIS_MODULE,
1402                 },
1403                 .init = {
1404                         .reg = BD718XX_REG_LDO3_VOLT,
1405                         .mask = BD718XX_LDO_SEL,
1406                         .val = BD718XX_LDO_SEL,
1407                 },
1408         },
1409         {
1410                 .desc = {
1411                         .name = "ldo4",
1412                         .of_match = of_match_ptr("LDO4"),
1413                         .regulators_node = of_match_ptr("regulators"),
1414                         .id = BD718XX_LDO4,
1415                         .type = REGULATOR_VOLTAGE,
1416                         .n_voltages = BD718XX_LDO4_VOLTAGE_NUM,
1417                         .linear_ranges = bd718xx_ldo4_volts,
1418                         .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo4_volts),
1419                         .vsel_reg = BD718XX_REG_LDO4_VOLT,
1420                         .vsel_mask = BD718XX_LDO4_MASK,
1421                         .enable_reg = BD718XX_REG_LDO4_VOLT,
1422                         .enable_mask = BD718XX_LDO_EN,
1423                         .enable_time = BD71837_LDO4_STARTUP_TIME,
1424                         .owner = THIS_MODULE,
1425                 },
1426                 .init = {
1427                         .reg = BD718XX_REG_LDO4_VOLT,
1428                         .mask = BD718XX_LDO_SEL,
1429                         .val = BD718XX_LDO_SEL,
1430                 },
1431         },
1432         {
1433                 .desc = {
1434                         .name = "ldo5",
1435                         .of_match = of_match_ptr("LDO5"),
1436                         .regulators_node = of_match_ptr("regulators"),
1437                         .id = BD718XX_LDO5,
1438                         .type = REGULATOR_VOLTAGE,
1439                         .n_voltages = BD71837_LDO5_VOLTAGE_NUM,
1440                         .linear_ranges = bd71837_ldo5_volts,
1441                         .n_linear_ranges = ARRAY_SIZE(bd71837_ldo5_volts),
1442                         /* LDO5 is supplied by buck6 */
1443                         .supply_name = "buck6",
1444                         .vsel_reg = BD718XX_REG_LDO5_VOLT,
1445                         .vsel_mask = BD71837_LDO5_MASK,
1446                         .enable_reg = BD718XX_REG_LDO5_VOLT,
1447                         .enable_mask = BD718XX_LDO_EN,
1448                         .enable_time = BD71837_LDO5_STARTUP_TIME,
1449                         .owner = THIS_MODULE,
1450                 },
1451                 .init = {
1452                         .reg = BD718XX_REG_LDO5_VOLT,
1453                         .mask = BD718XX_LDO_SEL,
1454                         .val = BD718XX_LDO_SEL,
1455                 },
1456                 .additional_inits = bd71837_ldo5_inits,
1457                 .additional_init_amnt = ARRAY_SIZE(bd71837_ldo5_inits),
1458         },
1459         {
1460                 .desc = {
1461                         .name = "ldo6",
1462                         .of_match = of_match_ptr("LDO6"),
1463                         .regulators_node = of_match_ptr("regulators"),
1464                         .id = BD718XX_LDO6,
1465                         .type = REGULATOR_VOLTAGE,
1466                         .n_voltages = BD718XX_LDO6_VOLTAGE_NUM,
1467                         .linear_ranges = bd718xx_ldo6_volts,
1468                         .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo6_volts),
1469                         /* LDO6 is supplied by buck7 */
1470                         .supply_name = "buck7",
1471                         .vsel_reg = BD718XX_REG_LDO6_VOLT,
1472                         .vsel_mask = BD718XX_LDO6_MASK,
1473                         .enable_reg = BD718XX_REG_LDO6_VOLT,
1474                         .enable_mask = BD718XX_LDO_EN,
1475                         .enable_time = BD71837_LDO6_STARTUP_TIME,
1476                         .owner = THIS_MODULE,
1477                 },
1478                 .init = {
1479                         .reg = BD718XX_REG_LDO6_VOLT,
1480                         .mask = BD718XX_LDO_SEL,
1481                         .val = BD718XX_LDO_SEL,
1482                 },
1483                 .additional_inits = bd71837_ldo6_inits,
1484                 .additional_init_amnt = ARRAY_SIZE(bd71837_ldo6_inits),
1485         },
1486         {
1487                 .desc = {
1488                         .name = "ldo7",
1489                         .of_match = of_match_ptr("LDO7"),
1490                         .regulators_node = of_match_ptr("regulators"),
1491                         .id = BD718XX_LDO7,
1492                         .type = REGULATOR_VOLTAGE,
1493                         .n_voltages = BD71837_LDO7_VOLTAGE_NUM,
1494                         .linear_ranges = bd71837_ldo7_volts,
1495                         .n_linear_ranges = ARRAY_SIZE(bd71837_ldo7_volts),
1496                         .vsel_reg = BD71837_REG_LDO7_VOLT,
1497                         .vsel_mask = BD71837_LDO7_MASK,
1498                         .enable_reg = BD71837_REG_LDO7_VOLT,
1499                         .enable_mask = BD718XX_LDO_EN,
1500                         .enable_time = BD71837_LDO7_STARTUP_TIME,
1501                         .owner = THIS_MODULE,
1502                 },
1503                 .init = {
1504                         .reg = BD71837_REG_LDO7_VOLT,
1505                         .mask = BD718XX_LDO_SEL,
1506                         .val = BD718XX_LDO_SEL,
1507                 },
1508         },
1509 };
1510
1511 static void mark_hw_controlled(struct device *dev, struct device_node *np,
1512                                struct bd718xx_regulator_data *reg_data,
1513                                unsigned int num_reg_data, int *info)
1514 {
1515         int i;
1516
1517         for (i = 1; i <= num_reg_data; i++) {
1518                 if (!of_node_name_eq(np, reg_data[i-1].desc.of_match))
1519                         continue;
1520
1521                 *info |= 1 << (i - 1);
1522                 dev_dbg(dev, "regulator %d runlevel controlled\n", i);
1523                 return;
1524         }
1525         dev_warn(dev, "Bad regulator node\n");
1526 }
1527
1528 /*
1529  * Setups where regulator (especially the buck8) output voltage is scaled
1530  * by adding external connection where some other regulator output is connected
1531  * to feedback-pin (over suitable resistors) is getting popular amongst users
1532  * of BD71837. (This allows for example scaling down the buck8 voltages to suit
1533  * lover GPU voltages for projects where buck8 is (ab)used to supply power
1534  * for GPU. Additionally some setups do allow DVS for buck8 but as this do
1535  * produce voltage spikes the HW must be evaluated to be able to survive this
1536  * - hence I keep the DVS disabled for non DVS bucks by default. I don't want
1537  * to help you burn your proto board)
1538  *
1539  * So we allow describing this external connection from DT and scale the
1540  * voltages accordingly. This is what the connection should look like:
1541  *
1542  * |------------|
1543  * |    buck 8  |-------+----->Vout
1544  * |            |       |
1545  * |------------|       |
1546  *      | FB pin        |
1547  *      |               |
1548  *      +-------+--R2---+
1549  *              |
1550  *              R1
1551  *              |
1552  *      V FB-pull-up
1553  *
1554  *      Here the buck output is sifted according to formula:
1555  *
1556  * Vout_o = Vo - (Vpu - Vo)*R2/R1
1557  * Linear_step = step_orig*(R1+R2)/R1
1558  *
1559  * where:
1560  * Vout_o is adjusted voltage output at vsel reg value 0
1561  * Vo is original voltage output at vsel reg value 0
1562  * Vpu is the pull-up voltage V FB-pull-up in the picture
1563  * R1 and R2 are resistor values.
1564  *
1565  * As a real world example for buck8 and a specific GPU:
1566  * VLDO = 1.6V (used as FB-pull-up)
1567  * R1 = 1000ohms
1568  * R2 = 150ohms
1569  * VSEL 0x0 => 0.8V – (VLDO – 0.8) * R2 / R1 = 0.68V
1570  * Linear Step = 10mV * (R1 + R2) / R1 = 11.5mV
1571  */
1572 static int setup_feedback_loop(struct device *dev, struct device_node *np,
1573                                struct bd718xx_regulator_data *reg_data,
1574                                unsigned int num_reg_data, int fb_uv)
1575 {
1576         int i, r1, r2, ret;
1577
1578         /*
1579          * We do adjust the values in the global desc based on DT settings.
1580          * This may not be best approach as it can cause problems if more than
1581          * one PMIC is controlled from same processor. I don't see such use-case
1582          * for BD718x7 now - so we spare some bits.
1583          *
1584          * If this will point out to be a problem - then we can allocate new
1585          * bd718xx_regulator_data array at probe and just use the global
1586          * array as a template where we copy initial values. Then we can
1587          * use allocated descs for regultor registration and do IC specific
1588          * modifications to this copy while leaving other PMICs untouched. But
1589          * that means allocating new array for each PMIC - and currently I see
1590          * no need for that.
1591          */
1592
1593         for (i = 0; i < num_reg_data; i++) {
1594                 struct regulator_desc *desc = &reg_data[i].desc;
1595                 int j;
1596
1597                 if (!of_node_name_eq(np, desc->of_match))
1598                         continue;
1599
1600                 pr_info("Looking at node '%s'\n", desc->of_match);
1601
1602                 /* The feedback loop connection does not make sense for LDOs */
1603                 if (desc->id >= BD718XX_LDO1)
1604                         return -EINVAL;
1605
1606                 ret = of_property_read_u32(np, "rohm,feedback-pull-up-r1-ohms",
1607                                            &r1);
1608                 if (ret)
1609                         return ret;
1610
1611                 if (!r1)
1612                         return -EINVAL;
1613
1614                 ret = of_property_read_u32(np, "rohm,feedback-pull-up-r2-ohms",
1615                                            &r2);
1616                 if (ret)
1617                         return ret;
1618
1619                 if (desc->n_linear_ranges && desc->linear_ranges) {
1620                         struct linear_range *new;
1621
1622                         new = devm_kzalloc(dev, desc->n_linear_ranges *
1623                                            sizeof(struct linear_range),
1624                                            GFP_KERNEL);
1625                         if (!new)
1626                                 return -ENOMEM;
1627
1628                         for (j = 0; j < desc->n_linear_ranges; j++) {
1629                                 int min = desc->linear_ranges[j].min;
1630                                 int step = desc->linear_ranges[j].step;
1631
1632                                 min -= (fb_uv - min)*r2/r1;
1633                                 step = step * (r1 + r2);
1634                                 step /= r1;
1635
1636                                 new[j].min = min;
1637                                 new[j].step = step;
1638
1639                                 dev_dbg(dev, "%s: old range min %d, step %d\n",
1640                                         desc->name, desc->linear_ranges[j].min,
1641                                         desc->linear_ranges[j].step);
1642                                 dev_dbg(dev, "new range min %d, step %d\n", min,
1643                                         step);
1644                         }
1645                         desc->linear_ranges = new;
1646                 }
1647                 dev_dbg(dev, "regulator '%s' has FB pull-up configured\n",
1648                         desc->name);
1649
1650                 return 0;
1651         }
1652
1653         return -ENODEV;
1654 }
1655
1656 static int get_special_regulators(struct device *dev,
1657                                   struct bd718xx_regulator_data *reg_data,
1658                                   unsigned int num_reg_data, int *info)
1659 {
1660         int ret;
1661         struct device_node *np;
1662         struct device_node *nproot = dev->of_node;
1663         int uv;
1664
1665         *info = 0;
1666
1667         nproot = of_get_child_by_name(nproot, "regulators");
1668         if (!nproot) {
1669                 dev_err(dev, "failed to find regulators node\n");
1670                 return -ENODEV;
1671         }
1672         for_each_child_of_node(nproot, np) {
1673                 if (of_property_read_bool(np, "rohm,no-regulator-enable-control"))
1674                         mark_hw_controlled(dev, np, reg_data, num_reg_data,
1675                                            info);
1676                 ret = of_property_read_u32(np, "rohm,fb-pull-up-microvolt",
1677                                            &uv);
1678                 if (ret) {
1679                         if (ret == -EINVAL)
1680                                 continue;
1681                         else
1682                                 goto err_out;
1683                 }
1684
1685                 ret = setup_feedback_loop(dev, np, reg_data, num_reg_data, uv);
1686                 if (ret)
1687                         goto err_out;
1688         }
1689
1690         of_node_put(nproot);
1691         return 0;
1692
1693 err_out:
1694         of_node_put(np);
1695         of_node_put(nproot);
1696
1697         return ret;
1698 }
1699
1700 static int bd718xx_probe(struct platform_device *pdev)
1701 {
1702         struct regmap *regmap;
1703         struct regulator_config config = { 0 };
1704         int i, j, err, omit_enable;
1705         bool use_snvs;
1706         struct bd718xx_regulator_data *reg_data;
1707         unsigned int num_reg_data;
1708         enum rohm_chip_type chip = platform_get_device_id(pdev)->driver_data;
1709         const struct regulator_ops **swops, **hwops;
1710
1711         regmap = dev_get_regmap(pdev->dev.parent, NULL);
1712         if (!regmap) {
1713                 dev_err(&pdev->dev, "No MFD driver data\n");
1714                 return -EINVAL;
1715         }
1716
1717         switch (chip) {
1718         case ROHM_CHIP_TYPE_BD71837:
1719                 reg_data = bd71837_regulators;
1720                 num_reg_data = ARRAY_SIZE(bd71837_regulators);
1721                 swops = &bd71837_swcontrol_ops[0];
1722                 hwops = &bd71837_hwcontrol_ops[0];
1723                 break;
1724         case ROHM_CHIP_TYPE_BD71847:
1725                 reg_data = bd71847_regulators;
1726                 num_reg_data = ARRAY_SIZE(bd71847_regulators);
1727                 swops = &bd71847_swcontrol_ops[0];
1728                 hwops = &bd71847_hwcontrol_ops[0];
1729                 break;
1730         default:
1731                 dev_err(&pdev->dev, "Unsupported chip type\n");
1732                 err = -EINVAL;
1733                 goto err;
1734         }
1735
1736         /* Register LOCK release */
1737         err = regmap_update_bits(regmap, BD718XX_REG_REGLOCK,
1738                                  (REGLOCK_PWRSEQ | REGLOCK_VREG), 0);
1739         if (err) {
1740                 dev_err(&pdev->dev, "Failed to unlock PMIC (%d)\n", err);
1741                 goto err;
1742         } else {
1743                 dev_dbg(&pdev->dev, "Unlocked lock register 0x%x\n",
1744                         BD718XX_REG_REGLOCK);
1745         }
1746
1747         use_snvs = of_property_read_bool(pdev->dev.parent->of_node,
1748                                          "rohm,reset-snvs-powered");
1749
1750         /*
1751          * Change the next stage from poweroff to be READY instead of SNVS
1752          * for all reset types because OTP loading at READY will clear SEL
1753          * bit allowing HW defaults for power rails to be used
1754          */
1755         if (!use_snvs) {
1756                 err = regmap_update_bits(regmap, BD718XX_REG_TRANS_COND1,
1757                                          BD718XX_ON_REQ_POWEROFF_MASK |
1758                                          BD718XX_SWRESET_POWEROFF_MASK |
1759                                          BD718XX_WDOG_POWEROFF_MASK |
1760                                          BD718XX_KEY_L_POWEROFF_MASK,
1761                                          BD718XX_POWOFF_TO_RDY);
1762                 if (err) {
1763                         dev_err(&pdev->dev, "Failed to change reset target\n");
1764                         goto err;
1765                 } else {
1766                         dev_dbg(&pdev->dev,
1767                                 "Changed all resets from SVNS to READY\n");
1768                 }
1769         }
1770
1771         config.dev = pdev->dev.parent;
1772         config.regmap = regmap;
1773         /*
1774          * There are cases when we want to leave the enable-control for
1775          * the HW state machine and use this driver only for voltage control.
1776          * One special case is when we use PMIC_STBY_REQ line from SoC to PMIC
1777          * in order to set the system to SUSPEND state.
1778          *
1779          * If regulator is taken under SW control the regulator state will not
1780          * be affected by PMIC state machine - Eg. regulator is likely to stay
1781          * on even in SUSPEND
1782          */
1783         err = get_special_regulators(pdev->dev.parent, reg_data, num_reg_data,
1784                                      &omit_enable);
1785         if (err)
1786                 return err;
1787
1788         for (i = 0; i < num_reg_data; i++) {
1789
1790                 struct regulator_desc *desc;
1791                 struct regulator_dev *rdev;
1792                 struct bd718xx_regulator_data *r;
1793                 int no_enable_control = omit_enable & (1 << i);
1794
1795                 r = &reg_data[i];
1796                 desc = &r->desc;
1797
1798                 if (no_enable_control)
1799                         desc->ops = hwops[i];
1800                 else
1801                         desc->ops = swops[i];
1802
1803                 rdev = devm_regulator_register(&pdev->dev, desc, &config);
1804                 if (IS_ERR(rdev)) {
1805                         dev_err(&pdev->dev,
1806                                 "failed to register %s regulator\n",
1807                                 desc->name);
1808                         err = PTR_ERR(rdev);
1809                         goto err;
1810                 }
1811
1812                 /*
1813                  * Regulator register gets the regulator constraints and
1814                  * applies them (set_machine_constraints). This should have
1815                  * turned the control register(s) to correct values and we
1816                  * can now switch the control from PMIC state machine to the
1817                  * register interface
1818                  *
1819                  * At poweroff transition PMIC HW disables EN bit for
1820                  * regulators but leaves SEL bit untouched. So if state
1821                  * transition from POWEROFF is done to SNVS - then all power
1822                  * rails controlled by SW (having SEL bit set) stay disabled
1823                  * as EN is cleared. This will result boot failure if any
1824                  * crucial systems are powered by these rails. We don't
1825                  * enable SW control for crucial regulators if snvs state is
1826                  * used
1827                  */
1828                 if (!no_enable_control && (!use_snvs ||
1829                     !rdev->constraints->always_on ||
1830                     !rdev->constraints->boot_on)) {
1831                         err = regmap_update_bits(regmap, r->init.reg,
1832                                                  r->init.mask, r->init.val);
1833                         if (err) {
1834                                 dev_err(&pdev->dev,
1835                                         "Failed to take control for (%s)\n",
1836                                         desc->name);
1837                                 goto err;
1838                         }
1839                 }
1840                 for (j = 0; j < r->additional_init_amnt; j++) {
1841                         err = regmap_update_bits(regmap,
1842                                                  r->additional_inits[j].reg,
1843                                                  r->additional_inits[j].mask,
1844                                                  r->additional_inits[j].val);
1845                         if (err) {
1846                                 dev_err(&pdev->dev,
1847                                         "Buck (%s) initialization failed\n",
1848                                         desc->name);
1849                                 goto err;
1850                         }
1851                 }
1852         }
1853
1854 err:
1855         return err;
1856 }
1857
1858 static const struct platform_device_id bd718x7_pmic_id[] = {
1859         { "bd71837-pmic", ROHM_CHIP_TYPE_BD71837 },
1860         { "bd71847-pmic", ROHM_CHIP_TYPE_BD71847 },
1861         { },
1862 };
1863 MODULE_DEVICE_TABLE(platform, bd718x7_pmic_id);
1864
1865 static struct platform_driver bd718xx_regulator = {
1866         .driver = {
1867                 .name = "bd718xx-pmic",
1868         },
1869         .probe = bd718xx_probe,
1870         .id_table = bd718x7_pmic_id,
1871 };
1872
1873 module_platform_driver(bd718xx_regulator);
1874
1875 MODULE_AUTHOR("Matti Vaittinen <matti.vaittinen@fi.rohmeurope.com>");
1876 MODULE_DESCRIPTION("BD71837/BD71847 voltage regulator driver");
1877 MODULE_LICENSE("GPL");
1878 MODULE_ALIAS("platform:bd718xx-pmic");