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