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 /*
  19  * BUCK1/2/3/4
  20  * BUCK1RAMPRATE[1:0] BUCK1 DVS ramp rate setting
  21  * 00: 10.00mV/usec 10mV 1uS
  22  * 01: 5.00mV/usec      10mV 2uS
  23  * 10: 2.50mV/usec      10mV 4uS
  24  * 11: 1.25mV/usec      10mV 8uS
  25  */
  26 static int bd718xx_buck1234_set_ramp_delay(struct regulator_dev *rdev,
  27                                            int ramp_delay)
  28 {
  29         int id = rdev_get_id(rdev);
  30         unsigned int ramp_value;
  31
  32         dev_dbg(&rdev->dev, "Buck[%d] Set Ramp = %d\n", id + 1,
  33                 ramp_delay);
  34         switch (ramp_delay) {
  35         case 1 ... 1250:
  36                 ramp_value = BUCK_RAMPRATE_1P25MV;
  37                 break;
  38         case 1251 ... 2500:
  39                 ramp_value = BUCK_RAMPRATE_2P50MV;
  40                 break;
  41         case 2501 ... 5000:
  42                 ramp_value = BUCK_RAMPRATE_5P00MV;
  43                 break;
  44         case 5001 ... 10000:
  45                 ramp_value = BUCK_RAMPRATE_10P00MV;
  46                 break;
  47         default:
  48                 ramp_value = BUCK_RAMPRATE_10P00MV;
  49                 dev_err(&rdev->dev,
  50                         "%s: ramp_delay: %d not supported, setting 10000mV//us\n",
  51                         rdev->desc->name, ramp_delay);
  52         }
  53
  54         return regmap_update_bits(rdev->regmap, BD718XX_REG_BUCK1_CTRL + id,
  55                                   BUCK_RAMPRATE_MASK, ramp_value << 6);
  56 }
  57
  58 /*
  59  * On BD71837 (not on BD71847, BD71850, ...)
  60  * Bucks 1 to 4 support DVS. PWM mode is used when voltage is changed.
  61  * Bucks 5 to 8 and LDOs can use PFM and must be disabled when voltage
  62  * is changed. Hence we return -EBUSY for these if voltage is changed
  63  * when BUCK/LDO is enabled.
  64  *
  65  * On BD71847, BD71850, ... The LDO voltage can be changed when LDO is
  66  * enabled. But if voltage is increased the LDO power-good monitoring
  67  * must be disabled for the duration of changing + 1mS to ensure voltage
  68  * has reached the higher level before HW does next under voltage detection
  69  * cycle.
  70  */
  71 static int bd71837_set_voltage_sel_restricted(struct regulator_dev *rdev,
  72                                                     unsigned int sel)
  73 {
  74         if (regulator_is_enabled_regmap(rdev))
  75                 return -EBUSY;
  76
  77         return regulator_set_voltage_sel_regmap(rdev, sel);
  78 }
  79
  80 static void voltage_change_done(struct regulator_dev *rdev, unsigned int sel,
  81                                 unsigned int *mask)
  82 {
  83         int ret;
  84
  85         if (*mask) {
  86                 /*
  87                  * Let's allow scheduling as we use I2C anyways. We just need to
  88                  * guarantee minimum of 1ms sleep - it shouldn't matter if we
  89                  * exceed it due to the scheduling.
  90                  */
  91                 msleep(1);
  92                 /*
  93                  * Note for next hacker. The PWRGOOD should not be masked on
  94                  * BD71847 so we will just unconditionally enable detection
  95                  * when voltage is set.
  96                  * If someone want's to disable PWRGOOD he must implement
  97                  * caching and restoring the old value here. I am not
  98                  * aware of such use-cases so for the sake of the simplicity
  99                  * we just always enable PWRGOOD here.
 100                  */
 101                 ret = regmap_update_bits(rdev->regmap, BD718XX_REG_MVRFLTMASK2,
 102                                          *mask, 0);
 103                 if (ret)
 104                         dev_err(&rdev->dev,
 105                                 "Failed to re-enable voltage monitoring (%d)\n",
 106                                 ret);
 107         }
 108 }
 109
 110 static int voltage_change_prepare(struct regulator_dev *rdev, unsigned int sel,
 111                                   unsigned int *mask)
 112 {
 113         int ret;
 114
 115         *mask = 0;
 116         if (regulator_is_enabled_regmap(rdev)) {
 117                 int now, new;
 118
 119                 now = rdev->desc->ops->get_voltage_sel(rdev);
 120                 if (now < 0)
 121                         return now;
 122
 123                 now = rdev->desc->ops->list_voltage(rdev, now);
 124                 if (now < 0)
 125                         return now;
 126
 127                 new = rdev->desc->ops->list_voltage(rdev, sel);
 128                 if (new < 0)
 129                         return new;
 130
 131                 /*
 132                  * If we increase LDO voltage when LDO is enabled we need to
 133                  * disable the power-good detection until voltage has reached
 134                  * the new level. According to HW colleagues the maximum time
 135                  * it takes is 1000us. I assume that on systems with light load
 136                  * this might be less - and we could probably use DT to give
 137                  * system specific delay value if performance matters.
 138                  *
 139                  * Well, knowing we use I2C here and can add scheduling delays
 140                  * I don't think it is worth the hassle and I just add fixed
 141                  * 1ms sleep here (and allow scheduling). If this turns out to
 142                  * be a problem we can change it to delay and make the delay
 143                  * time configurable.
 144                  */
 145                 if (new > now) {
 146                         int ldo_offset = rdev->desc->id - BD718XX_LDO1;
 147
 148                         *mask = BD718XX_LDO1_VRMON80 << ldo_offset;
 149                         ret = regmap_update_bits(rdev->regmap,
 150                                                  BD718XX_REG_MVRFLTMASK2,
 151                                                  *mask, *mask);
 152                         if (ret) {
 153                                 dev_err(&rdev->dev,
 154                                         "Failed to stop voltage monitoring\n");
 155                                 return ret;
 156                         }
 157                 }
 158         }
 159
 160         return 0;
 161 }
 162
 163 static int bd718xx_set_voltage_sel_restricted(struct regulator_dev *rdev,
 164                                                     unsigned int sel)
 165 {
 166         int ret;
 167         int mask;
 168
 169         ret = voltage_change_prepare(rdev, sel, &mask);
 170         if (ret)
 171                 return ret;
 172
 173         ret = regulator_set_voltage_sel_regmap(rdev, sel);
 174         voltage_change_done(rdev, sel, &mask);
 175
 176         return ret;
 177 }
 178
 179 static int bd718xx_set_voltage_sel_pickable_restricted(
 180                 struct regulator_dev *rdev, unsigned int sel)
 181 {
 182         int ret;
 183         int mask;
 184
 185         ret = voltage_change_prepare(rdev, sel, &mask);
 186         if (ret)
 187                 return ret;
 188
 189         ret = regulator_set_voltage_sel_pickable_regmap(rdev, sel);
 190         voltage_change_done(rdev, sel, &mask);
 191
 192         return ret;
 193 }
 194
 195 static int bd71837_set_voltage_sel_pickable_restricted(
 196                 struct regulator_dev *rdev, unsigned int sel)
 197 {
 198         if (regulator_is_enabled_regmap(rdev))
 199                 return -EBUSY;
 200
 201         return regulator_set_voltage_sel_pickable_regmap(rdev, sel);
 202 }
 203
 204 static const struct regulator_ops bd718xx_pickable_range_ldo_ops = {
 205         .enable = regulator_enable_regmap,
 206         .disable = regulator_disable_regmap,
 207         .is_enabled = regulator_is_enabled_regmap,
 208         .list_voltage = regulator_list_voltage_pickable_linear_range,
 209         .set_voltage_sel = bd718xx_set_voltage_sel_pickable_restricted,
 210         .get_voltage_sel = regulator_get_voltage_sel_pickable_regmap,
 211
 212 };
 213
 214 static const struct regulator_ops bd71837_pickable_range_ldo_ops = {
 215         .enable = regulator_enable_regmap,
 216         .disable = regulator_disable_regmap,
 217         .is_enabled = regulator_is_enabled_regmap,
 218         .list_voltage = regulator_list_voltage_pickable_linear_range,
 219         .set_voltage_sel = bd71837_set_voltage_sel_pickable_restricted,
 220         .get_voltage_sel = regulator_get_voltage_sel_pickable_regmap,
 221 };
 222
 223 static const struct regulator_ops bd718xx_pickable_range_buck_ops = {
 224         .enable = regulator_enable_regmap,
 225         .disable = regulator_disable_regmap,
 226         .is_enabled = regulator_is_enabled_regmap,
 227         .list_voltage = regulator_list_voltage_pickable_linear_range,
 228         .set_voltage_sel = regulator_set_voltage_sel_pickable_regmap,
 229         .get_voltage_sel = regulator_get_voltage_sel_pickable_regmap,
 230         .set_voltage_time_sel = regulator_set_voltage_time_sel,
 231 };
 232
 233 static const struct regulator_ops bd71837_pickable_range_buck_ops = {
 234         .enable = regulator_enable_regmap,
 235         .disable = regulator_disable_regmap,
 236         .is_enabled = regulator_is_enabled_regmap,
 237         .list_voltage = regulator_list_voltage_pickable_linear_range,
 238         .set_voltage_sel = bd71837_set_voltage_sel_pickable_restricted,
 239         .get_voltage_sel = regulator_get_voltage_sel_pickable_regmap,
 240         .set_voltage_time_sel = regulator_set_voltage_time_sel,
 241 };
 242
 243 static const struct regulator_ops bd71837_ldo_regulator_ops = {
 244         .enable = regulator_enable_regmap,
 245         .disable = regulator_disable_regmap,
 246         .is_enabled = regulator_is_enabled_regmap,
 247         .list_voltage = regulator_list_voltage_linear_range,
 248         .set_voltage_sel = bd71837_set_voltage_sel_restricted,
 249         .get_voltage_sel = regulator_get_voltage_sel_regmap,
 250 };
 251
 252 static const struct regulator_ops bd718xx_ldo_regulator_ops = {
 253         .enable = regulator_enable_regmap,
 254         .disable = regulator_disable_regmap,
 255         .is_enabled = regulator_is_enabled_regmap,
 256         .list_voltage = regulator_list_voltage_linear_range,
 257         .set_voltage_sel = bd718xx_set_voltage_sel_restricted,
 258         .get_voltage_sel = regulator_get_voltage_sel_regmap,
 259 };
 260
 261 static const struct regulator_ops bd71837_ldo_regulator_nolinear_ops = {
 262         .enable = regulator_enable_regmap,
 263         .disable = regulator_disable_regmap,
 264         .is_enabled = regulator_is_enabled_regmap,
 265         .list_voltage = regulator_list_voltage_table,
 266         .set_voltage_sel = bd71837_set_voltage_sel_restricted,
 267         .get_voltage_sel = regulator_get_voltage_sel_regmap,
 268 };
 269
 270 static const struct regulator_ops bd718xx_ldo_regulator_nolinear_ops = {
 271         .enable = regulator_enable_regmap,
 272         .disable = regulator_disable_regmap,
 273         .is_enabled = regulator_is_enabled_regmap,
 274         .list_voltage = regulator_list_voltage_table,
 275         .set_voltage_sel = bd718xx_set_voltage_sel_restricted,
 276         .get_voltage_sel = regulator_get_voltage_sel_regmap,
 277 };
 278
 279 static const struct regulator_ops bd718xx_buck_regulator_ops = {
 280         .enable = regulator_enable_regmap,
 281         .disable = regulator_disable_regmap,
 282         .is_enabled = regulator_is_enabled_regmap,
 283         .list_voltage = regulator_list_voltage_linear_range,
 284         .set_voltage_sel = regulator_set_voltage_sel_regmap,
 285         .get_voltage_sel = regulator_get_voltage_sel_regmap,
 286         .set_voltage_time_sel = regulator_set_voltage_time_sel,
 287 };
 288
 289 static const struct regulator_ops bd71837_buck_regulator_ops = {
 290         .enable = regulator_enable_regmap,
 291         .disable = regulator_disable_regmap,
 292         .is_enabled = regulator_is_enabled_regmap,
 293         .list_voltage = regulator_list_voltage_linear_range,
 294         .set_voltage_sel = bd71837_set_voltage_sel_restricted,
 295         .get_voltage_sel = regulator_get_voltage_sel_regmap,
 296         .set_voltage_time_sel = regulator_set_voltage_time_sel,
 297 };
 298
 299 static const struct regulator_ops bd718xx_buck_regulator_nolinear_ops = {
 300         .enable = regulator_enable_regmap,
 301         .disable = regulator_disable_regmap,
 302         .is_enabled = regulator_is_enabled_regmap,
 303         .list_voltage = regulator_list_voltage_table,
 304         .map_voltage = regulator_map_voltage_ascend,
 305         .set_voltage_sel = regulator_set_voltage_sel_regmap,
 306         .get_voltage_sel = regulator_get_voltage_sel_regmap,
 307         .set_voltage_time_sel = regulator_set_voltage_time_sel,
 308 };
 309
 310 static const struct regulator_ops bd71837_buck_regulator_nolinear_ops = {
 311         .enable = regulator_enable_regmap,
 312         .disable = regulator_disable_regmap,
 313         .is_enabled = regulator_is_enabled_regmap,
 314         .list_voltage = regulator_list_voltage_table,
 315         .map_voltage = regulator_map_voltage_ascend,
 316         .set_voltage_sel = bd718xx_set_voltage_sel_restricted,
 317         .get_voltage_sel = regulator_get_voltage_sel_regmap,
 318         .set_voltage_time_sel = regulator_set_voltage_time_sel,
 319 };
 320
 321 static const struct regulator_ops bd718xx_dvs_buck_regulator_ops = {
 322         .enable = regulator_enable_regmap,
 323         .disable = regulator_disable_regmap,
 324         .is_enabled = regulator_is_enabled_regmap,
 325         .list_voltage = regulator_list_voltage_linear_range,
 326         .set_voltage_sel = regulator_set_voltage_sel_regmap,
 327         .get_voltage_sel = regulator_get_voltage_sel_regmap,
 328         .set_voltage_time_sel = regulator_set_voltage_time_sel,
 329         .set_ramp_delay = bd718xx_buck1234_set_ramp_delay,
 330 };
 331
 332 /*
 333  * BD71837 BUCK1/2/3/4
 334  * BD71847 BUCK1/2
 335  * 0.70 to 1.30V (10mV step)
 336  */
 337 static const struct linear_range bd718xx_dvs_buck_volts[] = {
 338         REGULATOR_LINEAR_RANGE(700000, 0x00, 0x3C, 10000),
 339         REGULATOR_LINEAR_RANGE(1300000, 0x3D, 0x3F, 0),
 340 };
 341
 342 /*
 343  * BD71837 BUCK5
 344  * 0.7V to 1.35V  (range 0)
 345  * and
 346  * 0.675 to 1.325 (range 1)
 347  */
 348 static const struct linear_range bd71837_buck5_volts[] = {
 349         /* Ranges when VOLT_SEL bit is 0 */
 350         REGULATOR_LINEAR_RANGE(700000, 0x00, 0x03, 100000),
 351         REGULATOR_LINEAR_RANGE(1050000, 0x04, 0x05, 50000),
 352         REGULATOR_LINEAR_RANGE(1200000, 0x06, 0x07, 150000),
 353         /* Ranges when VOLT_SEL bit is 1  */
 354         REGULATOR_LINEAR_RANGE(675000, 0x0, 0x3, 100000),
 355         REGULATOR_LINEAR_RANGE(1025000, 0x4, 0x5, 50000),
 356         REGULATOR_LINEAR_RANGE(1175000, 0x6, 0x7, 150000),
 357 };
 358
 359 /*
 360  * Range selector for first 3 linear ranges is 0x0
 361  * and 0x1 for last 3 ranges.
 362  */
 363 static const unsigned int bd71837_buck5_volt_range_sel[] = {
 364         0x0, 0x0, 0x0, 0x80, 0x80, 0x80
 365 };
 366
 367 /*
 368  * BD71847 BUCK3
 369  */
 370 static const struct linear_range bd71847_buck3_volts[] = {
 371         /* Ranges when VOLT_SEL bits are 00 */
 372         REGULATOR_LINEAR_RANGE(700000, 0x00, 0x03, 100000),
 373         REGULATOR_LINEAR_RANGE(1050000, 0x04, 0x05, 50000),
 374         REGULATOR_LINEAR_RANGE(1200000, 0x06, 0x07, 150000),
 375         /* Ranges when VOLT_SEL bits are 01 */
 376         REGULATOR_LINEAR_RANGE(550000, 0x0, 0x7, 50000),
 377         /* Ranges when VOLT_SEL bits are 11 */
 378         REGULATOR_LINEAR_RANGE(675000, 0x0, 0x3, 100000),
 379         REGULATOR_LINEAR_RANGE(1025000, 0x4, 0x5, 50000),
 380         REGULATOR_LINEAR_RANGE(1175000, 0x6, 0x7, 150000),
 381 };
 382
 383 static const unsigned int bd71847_buck3_volt_range_sel[] = {
 384         0x0, 0x0, 0x0, 0x40, 0x80, 0x80, 0x80
 385 };
 386
 387 static const struct linear_range bd71847_buck4_volts[] = {
 388         REGULATOR_LINEAR_RANGE(3000000, 0x00, 0x03, 100000),
 389         REGULATOR_LINEAR_RANGE(2600000, 0x00, 0x03, 100000),
 390 };
 391
 392 static const unsigned int bd71847_buck4_volt_range_sel[] = { 0x0, 0x40 };
 393
 394 /*
 395  * BUCK6
 396  * 3.0V to 3.3V (step 100mV)
 397  */
 398 static const struct linear_range bd71837_buck6_volts[] = {
 399         REGULATOR_LINEAR_RANGE(3000000, 0x00, 0x03, 100000),
 400 };
 401
 402 /*
 403  * BD71837 BUCK7
 404  * BD71847 BUCK5
 405  * 000 = 1.605V
 406  * 001 = 1.695V
 407  * 010 = 1.755V
 408  * 011 = 1.8V (Initial)
 409  * 100 = 1.845V
 410  * 101 = 1.905V
 411  * 110 = 1.95V
 412  * 111 = 1.995V
 413  */
 414 static const unsigned int bd718xx_3rd_nodvs_buck_volts[] = {
 415         1605000, 1695000, 1755000, 1800000, 1845000, 1905000, 1950000, 1995000
 416 };
 417
 418 /*
 419  * BUCK8
 420  * 0.8V to 1.40V (step 10mV)
 421  */
 422 static const struct linear_range bd718xx_4th_nodvs_buck_volts[] = {
 423         REGULATOR_LINEAR_RANGE(800000, 0x00, 0x3C, 10000),
 424 };
 425
 426 /*
 427  * LDO1
 428  * 3.0 to 3.3V (100mV step)
 429  */
 430 static const struct linear_range bd718xx_ldo1_volts[] = {
 431         REGULATOR_LINEAR_RANGE(3000000, 0x00, 0x03, 100000),
 432         REGULATOR_LINEAR_RANGE(1600000, 0x00, 0x03, 100000),
 433 };
 434
 435 static const unsigned int bd718xx_ldo1_volt_range_sel[] = { 0x0, 0x20 };
 436
 437 /*
 438  * LDO2
 439  * 0.8 or 0.9V
 440  */
 441 static const unsigned int ldo_2_volts[] = {
 442         900000, 800000
 443 };
 444
 445 /*
 446  * LDO3
 447  * 1.8 to 3.3V (100mV step)
 448  */
 449 static const struct linear_range bd718xx_ldo3_volts[] = {
 450         REGULATOR_LINEAR_RANGE(1800000, 0x00, 0x0F, 100000),
 451 };
 452
 453 /*
 454  * LDO4
 455  * 0.9 to 1.8V (100mV step)
 456  */
 457 static const struct linear_range bd718xx_ldo4_volts[] = {
 458         REGULATOR_LINEAR_RANGE(900000, 0x00, 0x09, 100000),
 459 };
 460
 461 /*
 462  * LDO5 for BD71837
 463  * 1.8 to 3.3V (100mV step)
 464  */
 465 static const struct linear_range bd71837_ldo5_volts[] = {
 466         REGULATOR_LINEAR_RANGE(1800000, 0x00, 0x0F, 100000),
 467 };
 468
 469 /*
 470  * LDO5 for BD71837
 471  * 1.8 to 3.3V (100mV step)
 472  */
 473 static const struct linear_range bd71847_ldo5_volts[] = {
 474         REGULATOR_LINEAR_RANGE(1800000, 0x00, 0x0F, 100000),
 475         REGULATOR_LINEAR_RANGE(800000, 0x00, 0x0F, 100000),
 476 };
 477
 478 static const unsigned int bd71847_ldo5_volt_range_sel[] = { 0x0, 0x20 };
 479
 480 /*
 481  * LDO6
 482  * 0.9 to 1.8V (100mV step)
 483  */
 484 static const struct linear_range bd718xx_ldo6_volts[] = {
 485         REGULATOR_LINEAR_RANGE(900000, 0x00, 0x09, 100000),
 486 };
 487
 488 /*
 489  * LDO7
 490  * 1.8 to 3.3V (100mV step)
 491  */
 492 static const struct linear_range bd71837_ldo7_volts[] = {
 493         REGULATOR_LINEAR_RANGE(1800000, 0x00, 0x0F, 100000),
 494 };
 495
 496 struct reg_init {
 497         unsigned int reg;
 498         unsigned int mask;
 499         unsigned int val;
 500 };
 501 struct bd718xx_regulator_data {
 502         struct regulator_desc desc;
 503         const struct rohm_dvs_config dvs;
 504         const struct reg_init init;
 505         const struct reg_init *additional_inits;
 506         int additional_init_amnt;
 507 };
 508
 509 /*
 510  * There is a HW quirk in BD71837. The shutdown sequence timings for
 511  * bucks/LDOs which are controlled via register interface are changed.
 512  * At PMIC poweroff the voltage for BUCK6/7 is cut immediately at the
 513  * beginning of shut-down sequence. As bucks 6 and 7 are parent
 514  * supplies for LDO5 and LDO6 - this causes LDO5/6 voltage
 515  * monitoring to errorneously detect under voltage and force PMIC to
 516  * emergency state instead of poweroff. In order to avoid this we
 517  * disable voltage monitoring for LDO5 and LDO6
 518  */
 519 static const struct reg_init bd71837_ldo5_inits[] = {
 520         {
 521                 .reg = BD718XX_REG_MVRFLTMASK2,
 522                 .mask = BD718XX_LDO5_VRMON80,
 523                 .val = BD718XX_LDO5_VRMON80,
 524         },
 525 };
 526
 527 static const struct reg_init bd71837_ldo6_inits[] = {
 528         {
 529                 .reg = BD718XX_REG_MVRFLTMASK2,
 530                 .mask = BD718XX_LDO6_VRMON80,
 531                 .val = BD718XX_LDO6_VRMON80,
 532         },
 533 };
 534
 535 static int buck_set_hw_dvs_levels(struct device_node *np,
 536                             const struct regulator_desc *desc,
 537                             struct regulator_config *cfg)
 538 {
 539         struct bd718xx_regulator_data *data;
 540
 541         data = container_of(desc, struct bd718xx_regulator_data, desc);
 542
 543         return rohm_regulator_set_dvs_levels(&data->dvs, np, desc, cfg->regmap);
 544 }
 545
 546 static const struct bd718xx_regulator_data bd71847_regulators[] = {
 547         {
 548                 .desc = {
 549                         .name = "buck1",
 550                         .of_match = of_match_ptr("BUCK1"),
 551                         .regulators_node = of_match_ptr("regulators"),
 552                         .id = BD718XX_BUCK1,
 553                         .ops = &bd718xx_dvs_buck_regulator_ops,
 554                         .type = REGULATOR_VOLTAGE,
 555                         .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
 556                         .linear_ranges = bd718xx_dvs_buck_volts,
 557                         .n_linear_ranges =
 558                                 ARRAY_SIZE(bd718xx_dvs_buck_volts),
 559                         .vsel_reg = BD718XX_REG_BUCK1_VOLT_RUN,
 560                         .vsel_mask = DVS_BUCK_RUN_MASK,
 561                         .enable_reg = BD718XX_REG_BUCK1_CTRL,
 562                         .enable_mask = BD718XX_BUCK_EN,
 563                         .owner = THIS_MODULE,
 564                         .of_parse_cb = buck_set_hw_dvs_levels,
 565                 },
 566                 .dvs = {
 567                         .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
 568                                      ROHM_DVS_LEVEL_SUSPEND,
 569                         .run_reg = BD718XX_REG_BUCK1_VOLT_RUN,
 570                         .run_mask = DVS_BUCK_RUN_MASK,
 571                         .idle_reg = BD718XX_REG_BUCK1_VOLT_IDLE,
 572                         .idle_mask = DVS_BUCK_RUN_MASK,
 573                         .suspend_reg = BD718XX_REG_BUCK1_VOLT_SUSP,
 574                         .suspend_mask = DVS_BUCK_RUN_MASK,
 575                 },
 576                 .init = {
 577                         .reg = BD718XX_REG_BUCK1_CTRL,
 578                         .mask = BD718XX_BUCK_SEL,
 579                         .val = BD718XX_BUCK_SEL,
 580                 },
 581         },
 582         {
 583                 .desc = {
 584                         .name = "buck2",
 585                         .of_match = of_match_ptr("BUCK2"),
 586                         .regulators_node = of_match_ptr("regulators"),
 587                         .id = BD718XX_BUCK2,
 588                         .ops = &bd718xx_dvs_buck_regulator_ops,
 589                         .type = REGULATOR_VOLTAGE,
 590                         .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
 591                         .linear_ranges = bd718xx_dvs_buck_volts,
 592                         .n_linear_ranges = ARRAY_SIZE(bd718xx_dvs_buck_volts),
 593                         .vsel_reg = BD718XX_REG_BUCK2_VOLT_RUN,
 594                         .vsel_mask = DVS_BUCK_RUN_MASK,
 595                         .enable_reg = BD718XX_REG_BUCK2_CTRL,
 596                         .enable_mask = BD718XX_BUCK_EN,
 597                         .owner = THIS_MODULE,
 598                         .of_parse_cb = buck_set_hw_dvs_levels,
 599                 },
 600                 .dvs = {
 601                         .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE,
 602                         .run_reg = BD718XX_REG_BUCK2_VOLT_RUN,
 603                         .run_mask = DVS_BUCK_RUN_MASK,
 604                         .idle_reg = BD718XX_REG_BUCK2_VOLT_IDLE,
 605                         .idle_mask = DVS_BUCK_RUN_MASK,
 606                 },
 607                 .init = {
 608                         .reg = BD718XX_REG_BUCK2_CTRL,
 609                         .mask = BD718XX_BUCK_SEL,
 610                         .val = BD718XX_BUCK_SEL,
 611                 },
 612         },
 613         {
 614                 .desc = {
 615                         .name = "buck3",
 616                         .of_match = of_match_ptr("BUCK3"),
 617                         .regulators_node = of_match_ptr("regulators"),
 618                         .id = BD718XX_BUCK3,
 619                         .ops = &bd718xx_pickable_range_buck_ops,
 620                         .type = REGULATOR_VOLTAGE,
 621                         .n_voltages = BD71847_BUCK3_VOLTAGE_NUM,
 622                         .linear_ranges = bd71847_buck3_volts,
 623                         .n_linear_ranges =
 624                                 ARRAY_SIZE(bd71847_buck3_volts),
 625                         .vsel_reg = BD718XX_REG_1ST_NODVS_BUCK_VOLT,
 626                         .vsel_mask = BD718XX_1ST_NODVS_BUCK_MASK,
 627                         .vsel_range_reg = BD718XX_REG_1ST_NODVS_BUCK_VOLT,
 628                         .vsel_range_mask = BD71847_BUCK3_RANGE_MASK,
 629                         .linear_range_selectors = bd71847_buck3_volt_range_sel,
 630                         .enable_reg = BD718XX_REG_1ST_NODVS_BUCK_CTRL,
 631                         .enable_mask = BD718XX_BUCK_EN,
 632                         .owner = THIS_MODULE,
 633                 },
 634                 .init = {
 635                         .reg = BD718XX_REG_1ST_NODVS_BUCK_CTRL,
 636                         .mask = BD718XX_BUCK_SEL,
 637                         .val = BD718XX_BUCK_SEL,
 638                 },
 639         },
 640         {
 641                 .desc = {
 642                         .name = "buck4",
 643                         .of_match = of_match_ptr("BUCK4"),
 644                         .regulators_node = of_match_ptr("regulators"),
 645                         .id = BD718XX_BUCK4,
 646                         .ops = &bd718xx_pickable_range_buck_ops,
 647                         .type = REGULATOR_VOLTAGE,
 648                         .n_voltages = BD71847_BUCK4_VOLTAGE_NUM,
 649                         .linear_ranges = bd71847_buck4_volts,
 650                         .n_linear_ranges =
 651                                 ARRAY_SIZE(bd71847_buck4_volts),
 652                         .enable_reg = BD718XX_REG_2ND_NODVS_BUCK_CTRL,
 653                         .vsel_reg = BD718XX_REG_2ND_NODVS_BUCK_VOLT,
 654                         .vsel_mask = BD71847_BUCK4_MASK,
 655                         .vsel_range_reg = BD718XX_REG_2ND_NODVS_BUCK_VOLT,
 656                         .vsel_range_mask = BD71847_BUCK4_RANGE_MASK,
 657                         .linear_range_selectors = bd71847_buck4_volt_range_sel,
 658                         .enable_mask = BD718XX_BUCK_EN,
 659                         .owner = THIS_MODULE,
 660                 },
 661                 .init = {
 662                         .reg = BD718XX_REG_2ND_NODVS_BUCK_CTRL,
 663                         .mask = BD718XX_BUCK_SEL,
 664                         .val = BD718XX_BUCK_SEL,
 665                 },
 666         },
 667         {
 668                 .desc = {
 669                         .name = "buck5",
 670                         .of_match = of_match_ptr("BUCK5"),
 671                         .regulators_node = of_match_ptr("regulators"),
 672                         .id = BD718XX_BUCK5,
 673                         .ops = &bd718xx_buck_regulator_nolinear_ops,
 674                         .type = REGULATOR_VOLTAGE,
 675                         .volt_table = &bd718xx_3rd_nodvs_buck_volts[0],
 676                         .n_voltages = ARRAY_SIZE(bd718xx_3rd_nodvs_buck_volts),
 677                         .vsel_reg = BD718XX_REG_3RD_NODVS_BUCK_VOLT,
 678                         .vsel_mask = BD718XX_3RD_NODVS_BUCK_MASK,
 679                         .enable_reg = BD718XX_REG_3RD_NODVS_BUCK_CTRL,
 680                         .enable_mask = BD718XX_BUCK_EN,
 681                         .owner = THIS_MODULE,
 682                 },
 683                 .init = {
 684                         .reg = BD718XX_REG_3RD_NODVS_BUCK_CTRL,
 685                         .mask = BD718XX_BUCK_SEL,
 686                         .val = BD718XX_BUCK_SEL,
 687                 },
 688         },
 689         {
 690                 .desc = {
 691                         .name = "buck6",
 692                         .of_match = of_match_ptr("BUCK6"),
 693                         .regulators_node = of_match_ptr("regulators"),
 694                         .id = BD718XX_BUCK6,
 695                         .ops = &bd718xx_buck_regulator_ops,
 696                         .type = REGULATOR_VOLTAGE,
 697                         .n_voltages = BD718XX_4TH_NODVS_BUCK_VOLTAGE_NUM,
 698                         .linear_ranges = bd718xx_4th_nodvs_buck_volts,
 699                         .n_linear_ranges =
 700                                 ARRAY_SIZE(bd718xx_4th_nodvs_buck_volts),
 701                         .vsel_reg = BD718XX_REG_4TH_NODVS_BUCK_VOLT,
 702                         .vsel_mask = BD718XX_4TH_NODVS_BUCK_MASK,
 703                         .enable_reg = BD718XX_REG_4TH_NODVS_BUCK_CTRL,
 704                         .enable_mask = BD718XX_BUCK_EN,
 705                         .owner = THIS_MODULE,
 706                 },
 707                 .init = {
 708                         .reg = BD718XX_REG_4TH_NODVS_BUCK_CTRL,
 709                         .mask = BD718XX_BUCK_SEL,
 710                         .val = BD718XX_BUCK_SEL,
 711                 },
 712         },
 713         {
 714                 .desc = {
 715                         .name = "ldo1",
 716                         .of_match = of_match_ptr("LDO1"),
 717                         .regulators_node = of_match_ptr("regulators"),
 718                         .id = BD718XX_LDO1,
 719                         .ops = &bd718xx_pickable_range_ldo_ops,
 720                         .type = REGULATOR_VOLTAGE,
 721                         .n_voltages = BD718XX_LDO1_VOLTAGE_NUM,
 722                         .linear_ranges = bd718xx_ldo1_volts,
 723                         .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo1_volts),
 724                         .vsel_reg = BD718XX_REG_LDO1_VOLT,
 725                         .vsel_mask = BD718XX_LDO1_MASK,
 726                         .vsel_range_reg = BD718XX_REG_LDO1_VOLT,
 727                         .vsel_range_mask = BD718XX_LDO1_RANGE_MASK,
 728                         .linear_range_selectors = bd718xx_ldo1_volt_range_sel,
 729                         .enable_reg = BD718XX_REG_LDO1_VOLT,
 730                         .enable_mask = BD718XX_LDO_EN,
 731                         .owner = THIS_MODULE,
 732                 },
 733                 .init = {
 734                         .reg = BD718XX_REG_LDO1_VOLT,
 735                         .mask = BD718XX_LDO_SEL,
 736                         .val = BD718XX_LDO_SEL,
 737                 },
 738         },
 739         {
 740                 .desc = {
 741                         .name = "ldo2",
 742                         .of_match = of_match_ptr("LDO2"),
 743                         .regulators_node = of_match_ptr("regulators"),
 744                         .id = BD718XX_LDO2,
 745                         .ops = &bd718xx_ldo_regulator_nolinear_ops,
 746                         .type = REGULATOR_VOLTAGE,
 747                         .volt_table = &ldo_2_volts[0],
 748                         .vsel_reg = BD718XX_REG_LDO2_VOLT,
 749                         .vsel_mask = BD718XX_LDO2_MASK,
 750                         .n_voltages = ARRAY_SIZE(ldo_2_volts),
 751                         .enable_reg = BD718XX_REG_LDO2_VOLT,
 752                         .enable_mask = BD718XX_LDO_EN,
 753                         .owner = THIS_MODULE,
 754                 },
 755                 .init = {
 756                         .reg = BD718XX_REG_LDO2_VOLT,
 757                         .mask = BD718XX_LDO_SEL,
 758                         .val = BD718XX_LDO_SEL,
 759                 },
 760         },
 761         {
 762                 .desc = {
 763                         .name = "ldo3",
 764                         .of_match = of_match_ptr("LDO3"),
 765                         .regulators_node = of_match_ptr("regulators"),
 766                         .id = BD718XX_LDO3,
 767                         .ops = &bd718xx_ldo_regulator_ops,
 768                         .type = REGULATOR_VOLTAGE,
 769                         .n_voltages = BD718XX_LDO3_VOLTAGE_NUM,
 770                         .linear_ranges = bd718xx_ldo3_volts,
 771                         .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo3_volts),
 772                         .vsel_reg = BD718XX_REG_LDO3_VOLT,
 773                         .vsel_mask = BD718XX_LDO3_MASK,
 774                         .enable_reg = BD718XX_REG_LDO3_VOLT,
 775                         .enable_mask = BD718XX_LDO_EN,
 776                         .owner = THIS_MODULE,
 777                 },
 778                 .init = {
 779                         .reg = BD718XX_REG_LDO3_VOLT,
 780                         .mask = BD718XX_LDO_SEL,
 781                         .val = BD718XX_LDO_SEL,
 782                 },
 783         },
 784         {
 785                 .desc = {
 786                         .name = "ldo4",
 787                         .of_match = of_match_ptr("LDO4"),
 788                         .regulators_node = of_match_ptr("regulators"),
 789                         .id = BD718XX_LDO4,
 790                         .ops = &bd718xx_ldo_regulator_ops,
 791                         .type = REGULATOR_VOLTAGE,
 792                         .n_voltages = BD718XX_LDO4_VOLTAGE_NUM,
 793                         .linear_ranges = bd718xx_ldo4_volts,
 794                         .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo4_volts),
 795                         .vsel_reg = BD718XX_REG_LDO4_VOLT,
 796                         .vsel_mask = BD718XX_LDO4_MASK,
 797                         .enable_reg = BD718XX_REG_LDO4_VOLT,
 798                         .enable_mask = BD718XX_LDO_EN,
 799                         .owner = THIS_MODULE,
 800                 },
 801                 .init = {
 802                         .reg = BD718XX_REG_LDO4_VOLT,
 803                         .mask = BD718XX_LDO_SEL,
 804                         .val = BD718XX_LDO_SEL,
 805                 },
 806         },
 807         {
 808                 .desc = {
 809                         .name = "ldo5",
 810                         .of_match = of_match_ptr("LDO5"),
 811                         .regulators_node = of_match_ptr("regulators"),
 812                         .id = BD718XX_LDO5,
 813                         .ops = &bd718xx_pickable_range_ldo_ops,
 814                         .type = REGULATOR_VOLTAGE,
 815                         .n_voltages = BD71847_LDO5_VOLTAGE_NUM,
 816                         .linear_ranges = bd71847_ldo5_volts,
 817                         .n_linear_ranges = ARRAY_SIZE(bd71847_ldo5_volts),
 818                         .vsel_reg = BD718XX_REG_LDO5_VOLT,
 819                         .vsel_mask = BD71847_LDO5_MASK,
 820                         .vsel_range_reg = BD718XX_REG_LDO5_VOLT,
 821                         .vsel_range_mask = BD71847_LDO5_RANGE_MASK,
 822                         .linear_range_selectors = bd71847_ldo5_volt_range_sel,
 823                         .enable_reg = BD718XX_REG_LDO5_VOLT,
 824                         .enable_mask = BD718XX_LDO_EN,
 825                         .owner = THIS_MODULE,
 826                 },
 827                 .init = {
 828                         .reg = BD718XX_REG_LDO5_VOLT,
 829                         .mask = BD718XX_LDO_SEL,
 830                         .val = BD718XX_LDO_SEL,
 831                 },
 832         },
 833         {
 834                 .desc = {
 835                         .name = "ldo6",
 836                         .of_match = of_match_ptr("LDO6"),
 837                         .regulators_node = of_match_ptr("regulators"),
 838                         .id = BD718XX_LDO6,
 839                         .ops = &bd718xx_ldo_regulator_ops,
 840                         .type = REGULATOR_VOLTAGE,
 841                         .n_voltages = BD718XX_LDO6_VOLTAGE_NUM,
 842                         .linear_ranges = bd718xx_ldo6_volts,
 843                         .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo6_volts),
 844                         /* LDO6 is supplied by buck5 */
 845                         .supply_name = "buck5",
 846                         .vsel_reg = BD718XX_REG_LDO6_VOLT,
 847                         .vsel_mask = BD718XX_LDO6_MASK,
 848                         .enable_reg = BD718XX_REG_LDO6_VOLT,
 849                         .enable_mask = BD718XX_LDO_EN,
 850                         .owner = THIS_MODULE,
 851                 },
 852                 .init = {
 853                         .reg = BD718XX_REG_LDO6_VOLT,
 854                         .mask = BD718XX_LDO_SEL,
 855                         .val = BD718XX_LDO_SEL,
 856                 },
 857         },
 858 };
 859
 860 static const struct bd718xx_regulator_data bd71837_regulators[] = {
 861         {
 862                 .desc = {
 863                         .name = "buck1",
 864                         .of_match = of_match_ptr("BUCK1"),
 865                         .regulators_node = of_match_ptr("regulators"),
 866                         .id = BD718XX_BUCK1,
 867                         .ops = &bd718xx_dvs_buck_regulator_ops,
 868                         .type = REGULATOR_VOLTAGE,
 869                         .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
 870                         .linear_ranges = bd718xx_dvs_buck_volts,
 871                         .n_linear_ranges = ARRAY_SIZE(bd718xx_dvs_buck_volts),
 872                         .vsel_reg = BD718XX_REG_BUCK1_VOLT_RUN,
 873                         .vsel_mask = DVS_BUCK_RUN_MASK,
 874                         .enable_reg = BD718XX_REG_BUCK1_CTRL,
 875                         .enable_mask = BD718XX_BUCK_EN,
 876                         .owner = THIS_MODULE,
 877                         .of_parse_cb = buck_set_hw_dvs_levels,
 878                 },
 879                 .dvs = {
 880                         .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
 881                                      ROHM_DVS_LEVEL_SUSPEND,
 882                         .run_reg = BD718XX_REG_BUCK1_VOLT_RUN,
 883                         .run_mask = DVS_BUCK_RUN_MASK,
 884                         .idle_reg = BD718XX_REG_BUCK1_VOLT_IDLE,
 885                         .idle_mask = DVS_BUCK_RUN_MASK,
 886                         .suspend_reg = BD718XX_REG_BUCK1_VOLT_SUSP,
 887                         .suspend_mask = DVS_BUCK_RUN_MASK,
 888                 },
 889                 .init = {
 890                         .reg = BD718XX_REG_BUCK1_CTRL,
 891                         .mask = BD718XX_BUCK_SEL,
 892                         .val = BD718XX_BUCK_SEL,
 893                 },
 894         },
 895         {
 896                 .desc = {
 897                         .name = "buck2",
 898                         .of_match = of_match_ptr("BUCK2"),
 899                         .regulators_node = of_match_ptr("regulators"),
 900                         .id = BD718XX_BUCK2,
 901                         .ops = &bd718xx_dvs_buck_regulator_ops,
 902                         .type = REGULATOR_VOLTAGE,
 903                         .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
 904                         .linear_ranges = bd718xx_dvs_buck_volts,
 905                         .n_linear_ranges = ARRAY_SIZE(bd718xx_dvs_buck_volts),
 906                         .vsel_reg = BD718XX_REG_BUCK2_VOLT_RUN,
 907                         .vsel_mask = DVS_BUCK_RUN_MASK,
 908                         .enable_reg = BD718XX_REG_BUCK2_CTRL,
 909                         .enable_mask = BD718XX_BUCK_EN,
 910                         .owner = THIS_MODULE,
 911                         .of_parse_cb = buck_set_hw_dvs_levels,
 912                 },
 913                 .dvs = {
 914                         .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE,
 915                         .run_reg = BD718XX_REG_BUCK2_VOLT_RUN,
 916                         .run_mask = DVS_BUCK_RUN_MASK,
 917                         .idle_reg = BD718XX_REG_BUCK2_VOLT_IDLE,
 918                         .idle_mask = DVS_BUCK_RUN_MASK,
 919                 },
 920                 .init = {
 921                         .reg = BD718XX_REG_BUCK2_CTRL,
 922                         .mask = BD718XX_BUCK_SEL,
 923                         .val = BD718XX_BUCK_SEL,
 924                 },
 925         },
 926         {
 927                 .desc = {
 928                         .name = "buck3",
 929                         .of_match = of_match_ptr("BUCK3"),
 930                         .regulators_node = of_match_ptr("regulators"),
 931                         .id = BD718XX_BUCK3,
 932                         .ops = &bd718xx_dvs_buck_regulator_ops,
 933                         .type = REGULATOR_VOLTAGE,
 934                         .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
 935                         .linear_ranges = bd718xx_dvs_buck_volts,
 936                         .n_linear_ranges = ARRAY_SIZE(bd718xx_dvs_buck_volts),
 937                         .vsel_reg = BD71837_REG_BUCK3_VOLT_RUN,
 938                         .vsel_mask = DVS_BUCK_RUN_MASK,
 939                         .enable_reg = BD71837_REG_BUCK3_CTRL,
 940                         .enable_mask = BD718XX_BUCK_EN,
 941                         .owner = THIS_MODULE,
 942                         .of_parse_cb = buck_set_hw_dvs_levels,
 943                 },
 944                 .dvs = {
 945                         .level_map = ROHM_DVS_LEVEL_RUN,
 946                         .run_reg = BD71837_REG_BUCK3_VOLT_RUN,
 947                         .run_mask = DVS_BUCK_RUN_MASK,
 948                 },
 949                 .init = {
 950                         .reg = BD71837_REG_BUCK3_CTRL,
 951                         .mask = BD718XX_BUCK_SEL,
 952                         .val = BD718XX_BUCK_SEL,
 953                 },
 954         },
 955         {
 956                 .desc = {
 957                         .name = "buck4",
 958                         .of_match = of_match_ptr("BUCK4"),
 959                         .regulators_node = of_match_ptr("regulators"),
 960                         .id = BD718XX_BUCK4,
 961                         .ops = &bd718xx_dvs_buck_regulator_ops,
 962                         .type = REGULATOR_VOLTAGE,
 963                         .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
 964                         .linear_ranges = bd718xx_dvs_buck_volts,
 965                         .n_linear_ranges = ARRAY_SIZE(bd718xx_dvs_buck_volts),
 966                         .vsel_reg = BD71837_REG_BUCK4_VOLT_RUN,
 967                         .vsel_mask = DVS_BUCK_RUN_MASK,
 968                         .enable_reg = BD71837_REG_BUCK4_CTRL,
 969                         .enable_mask = BD718XX_BUCK_EN,
 970                         .owner = THIS_MODULE,
 971                         .of_parse_cb = buck_set_hw_dvs_levels,
 972                 },
 973                 .dvs = {
 974                         .level_map = ROHM_DVS_LEVEL_RUN,
 975                         .run_reg = BD71837_REG_BUCK4_VOLT_RUN,
 976                         .run_mask = DVS_BUCK_RUN_MASK,
 977                 },
 978                 .init = {
 979                         .reg = BD71837_REG_BUCK4_CTRL,
 980                         .mask = BD718XX_BUCK_SEL,
 981                         .val = BD718XX_BUCK_SEL,
 982                 },
 983         },
 984         {
 985                 .desc = {
 986                         .name = "buck5",
 987                         .of_match = of_match_ptr("BUCK5"),
 988                         .regulators_node = of_match_ptr("regulators"),
 989                         .id = BD718XX_BUCK5,
 990                         .ops = &bd71837_pickable_range_buck_ops,
 991                         .type = REGULATOR_VOLTAGE,
 992                         .n_voltages = BD71837_BUCK5_VOLTAGE_NUM,
 993                         .linear_ranges = bd71837_buck5_volts,
 994                         .n_linear_ranges =
 995                                 ARRAY_SIZE(bd71837_buck5_volts),
 996                         .vsel_reg = BD718XX_REG_1ST_NODVS_BUCK_VOLT,
 997                         .vsel_mask = BD71837_BUCK5_MASK,
 998                         .vsel_range_reg = BD718XX_REG_1ST_NODVS_BUCK_VOLT,
 999                         .vsel_range_mask = BD71837_BUCK5_RANGE_MASK,
1000                         .linear_range_selectors = bd71837_buck5_volt_range_sel,
1001                         .enable_reg = BD718XX_REG_1ST_NODVS_BUCK_CTRL,
1002                         .enable_mask = BD718XX_BUCK_EN,
1003                         .owner = THIS_MODULE,
1004                 },
1005                 .init = {
1006                         .reg = BD718XX_REG_1ST_NODVS_BUCK_CTRL,
1007                         .mask = BD718XX_BUCK_SEL,
1008                         .val = BD718XX_BUCK_SEL,
1009                 },
1010         },
1011         {
1012                 .desc = {
1013                         .name = "buck6",
1014                         .of_match = of_match_ptr("BUCK6"),
1015                         .regulators_node = of_match_ptr("regulators"),
1016                         .id = BD718XX_BUCK6,
1017                         .ops = &bd71837_buck_regulator_ops,
1018                         .type = REGULATOR_VOLTAGE,
1019                         .n_voltages = BD71837_BUCK6_VOLTAGE_NUM,
1020                         .linear_ranges = bd71837_buck6_volts,
1021                         .n_linear_ranges =
1022                                 ARRAY_SIZE(bd71837_buck6_volts),
1023                         .vsel_reg = BD718XX_REG_2ND_NODVS_BUCK_VOLT,
1024                         .vsel_mask = BD71837_BUCK6_MASK,
1025                         .enable_reg = BD718XX_REG_2ND_NODVS_BUCK_CTRL,
1026                         .enable_mask = BD718XX_BUCK_EN,
1027                         .owner = THIS_MODULE,
1028                 },
1029                 .init = {
1030                         .reg = BD718XX_REG_2ND_NODVS_BUCK_CTRL,
1031                         .mask = BD718XX_BUCK_SEL,
1032                         .val = BD718XX_BUCK_SEL,
1033                 },
1034         },
1035         {
1036                 .desc = {
1037                         .name = "buck7",
1038                         .of_match = of_match_ptr("BUCK7"),
1039                         .regulators_node = of_match_ptr("regulators"),
1040                         .id = BD718XX_BUCK7,
1041                         .ops = &bd71837_buck_regulator_nolinear_ops,
1042                         .type = REGULATOR_VOLTAGE,
1043                         .volt_table = &bd718xx_3rd_nodvs_buck_volts[0],
1044                         .n_voltages = ARRAY_SIZE(bd718xx_3rd_nodvs_buck_volts),
1045                         .vsel_reg = BD718XX_REG_3RD_NODVS_BUCK_VOLT,
1046                         .vsel_mask = BD718XX_3RD_NODVS_BUCK_MASK,
1047                         .enable_reg = BD718XX_REG_3RD_NODVS_BUCK_CTRL,
1048                         .enable_mask = BD718XX_BUCK_EN,
1049                         .owner = THIS_MODULE,
1050                 },
1051                 .init = {
1052                         .reg = BD718XX_REG_3RD_NODVS_BUCK_CTRL,
1053                         .mask = BD718XX_BUCK_SEL,
1054                         .val = BD718XX_BUCK_SEL,
1055                 },
1056         },
1057         {
1058                 .desc = {
1059                         .name = "buck8",
1060                         .of_match = of_match_ptr("BUCK8"),
1061                         .regulators_node = of_match_ptr("regulators"),
1062                         .id = BD718XX_BUCK8,
1063                         .ops = &bd71837_buck_regulator_ops,
1064                         .type = REGULATOR_VOLTAGE,
1065                         .n_voltages = BD718XX_4TH_NODVS_BUCK_VOLTAGE_NUM,
1066                         .linear_ranges = bd718xx_4th_nodvs_buck_volts,
1067                         .n_linear_ranges =
1068                                 ARRAY_SIZE(bd718xx_4th_nodvs_buck_volts),
1069                         .vsel_reg = BD718XX_REG_4TH_NODVS_BUCK_VOLT,
1070                         .vsel_mask = BD718XX_4TH_NODVS_BUCK_MASK,
1071                         .enable_reg = BD718XX_REG_4TH_NODVS_BUCK_CTRL,
1072                         .enable_mask = BD718XX_BUCK_EN,
1073                         .owner = THIS_MODULE,
1074                 },
1075                 .init = {
1076                         .reg = BD718XX_REG_4TH_NODVS_BUCK_CTRL,
1077                         .mask = BD718XX_BUCK_SEL,
1078                         .val = BD718XX_BUCK_SEL,
1079                 },
1080         },
1081         {
1082                 .desc = {
1083                         .name = "ldo1",
1084                         .of_match = of_match_ptr("LDO1"),
1085                         .regulators_node = of_match_ptr("regulators"),
1086                         .id = BD718XX_LDO1,
1087                         .ops = &bd71837_pickable_range_ldo_ops,
1088                         .type = REGULATOR_VOLTAGE,
1089                         .n_voltages = BD718XX_LDO1_VOLTAGE_NUM,
1090                         .linear_ranges = bd718xx_ldo1_volts,
1091                         .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo1_volts),
1092                         .vsel_reg = BD718XX_REG_LDO1_VOLT,
1093                         .vsel_mask = BD718XX_LDO1_MASK,
1094                         .vsel_range_reg = BD718XX_REG_LDO1_VOLT,
1095                         .vsel_range_mask = BD718XX_LDO1_RANGE_MASK,
1096                         .linear_range_selectors = bd718xx_ldo1_volt_range_sel,
1097                         .enable_reg = BD718XX_REG_LDO1_VOLT,
1098                         .enable_mask = BD718XX_LDO_EN,
1099                         .owner = THIS_MODULE,
1100                 },
1101                 .init = {
1102                         .reg = BD718XX_REG_LDO1_VOLT,
1103                         .mask = BD718XX_LDO_SEL,
1104                         .val = BD718XX_LDO_SEL,
1105                 },
1106         },
1107         {
1108                 .desc = {
1109                         .name = "ldo2",
1110                         .of_match = of_match_ptr("LDO2"),
1111                         .regulators_node = of_match_ptr("regulators"),
1112                         .id = BD718XX_LDO2,
1113                         .ops = &bd71837_ldo_regulator_nolinear_ops,
1114                         .type = REGULATOR_VOLTAGE,
1115                         .volt_table = &ldo_2_volts[0],
1116                         .vsel_reg = BD718XX_REG_LDO2_VOLT,
1117                         .vsel_mask = BD718XX_LDO2_MASK,
1118                         .n_voltages = ARRAY_SIZE(ldo_2_volts),
1119                         .enable_reg = BD718XX_REG_LDO2_VOLT,
1120                         .enable_mask = BD718XX_LDO_EN,
1121                         .owner = THIS_MODULE,
1122                 },
1123                 .init = {
1124                         .reg = BD718XX_REG_LDO2_VOLT,
1125                         .mask = BD718XX_LDO_SEL,
1126                         .val = BD718XX_LDO_SEL,
1127                 },
1128         },
1129         {
1130                 .desc = {
1131                         .name = "ldo3",
1132                         .of_match = of_match_ptr("LDO3"),
1133                         .regulators_node = of_match_ptr("regulators"),
1134                         .id = BD718XX_LDO3,
1135                         .ops = &bd71837_ldo_regulator_ops,
1136                         .type = REGULATOR_VOLTAGE,
1137                         .n_voltages = BD718XX_LDO3_VOLTAGE_NUM,
1138                         .linear_ranges = bd718xx_ldo3_volts,
1139                         .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo3_volts),
1140                         .vsel_reg = BD718XX_REG_LDO3_VOLT,
1141                         .vsel_mask = BD718XX_LDO3_MASK,
1142                         .enable_reg = BD718XX_REG_LDO3_VOLT,
1143                         .enable_mask = BD718XX_LDO_EN,
1144                         .owner = THIS_MODULE,
1145                 },
1146                 .init = {
1147                         .reg = BD718XX_REG_LDO3_VOLT,
1148                         .mask = BD718XX_LDO_SEL,
1149                         .val = BD718XX_LDO_SEL,
1150                 },
1151         },
1152         {
1153                 .desc = {
1154                         .name = "ldo4",
1155                         .of_match = of_match_ptr("LDO4"),
1156                         .regulators_node = of_match_ptr("regulators"),
1157                         .id = BD718XX_LDO4,
1158                         .ops = &bd71837_ldo_regulator_ops,
1159                         .type = REGULATOR_VOLTAGE,
1160                         .n_voltages = BD718XX_LDO4_VOLTAGE_NUM,
1161                         .linear_ranges = bd718xx_ldo4_volts,
1162                         .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo4_volts),
1163                         .vsel_reg = BD718XX_REG_LDO4_VOLT,
1164                         .vsel_mask = BD718XX_LDO4_MASK,
1165                         .enable_reg = BD718XX_REG_LDO4_VOLT,
1166                         .enable_mask = BD718XX_LDO_EN,
1167                         .owner = THIS_MODULE,
1168                 },
1169                 .init = {
1170                         .reg = BD718XX_REG_LDO4_VOLT,
1171                         .mask = BD718XX_LDO_SEL,
1172                         .val = BD718XX_LDO_SEL,
1173                 },
1174         },
1175         {
1176                 .desc = {
1177                         .name = "ldo5",
1178                         .of_match = of_match_ptr("LDO5"),
1179                         .regulators_node = of_match_ptr("regulators"),
1180                         .id = BD718XX_LDO5,
1181                         .ops = &bd71837_ldo_regulator_ops,
1182                         .type = REGULATOR_VOLTAGE,
1183                         .n_voltages = BD71837_LDO5_VOLTAGE_NUM,
1184                         .linear_ranges = bd71837_ldo5_volts,
1185                         .n_linear_ranges = ARRAY_SIZE(bd71837_ldo5_volts),
1186                         /* LDO5 is supplied by buck6 */
1187                         .supply_name = "buck6",
1188                         .vsel_reg = BD718XX_REG_LDO5_VOLT,
1189                         .vsel_mask = BD71837_LDO5_MASK,
1190                         .enable_reg = BD718XX_REG_LDO5_VOLT,
1191                         .enable_mask = BD718XX_LDO_EN,
1192                         .owner = THIS_MODULE,
1193                 },
1194                 .init = {
1195                         .reg = BD718XX_REG_LDO5_VOLT,
1196                         .mask = BD718XX_LDO_SEL,
1197                         .val = BD718XX_LDO_SEL,
1198                 },
1199                 .additional_inits = bd71837_ldo5_inits,
1200                 .additional_init_amnt = ARRAY_SIZE(bd71837_ldo5_inits),
1201         },
1202         {
1203                 .desc = {
1204                         .name = "ldo6",
1205                         .of_match = of_match_ptr("LDO6"),
1206                         .regulators_node = of_match_ptr("regulators"),
1207                         .id = BD718XX_LDO6,
1208                         .ops = &bd71837_ldo_regulator_ops,
1209                         .type = REGULATOR_VOLTAGE,
1210                         .n_voltages = BD718XX_LDO6_VOLTAGE_NUM,
1211                         .linear_ranges = bd718xx_ldo6_volts,
1212                         .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo6_volts),
1213                         /* LDO6 is supplied by buck7 */
1214                         .supply_name = "buck7",
1215                         .vsel_reg = BD718XX_REG_LDO6_VOLT,
1216                         .vsel_mask = BD718XX_LDO6_MASK,
1217                         .enable_reg = BD718XX_REG_LDO6_VOLT,
1218                         .enable_mask = BD718XX_LDO_EN,
1219                         .owner = THIS_MODULE,
1220                 },
1221                 .init = {
1222                         .reg = BD718XX_REG_LDO6_VOLT,
1223                         .mask = BD718XX_LDO_SEL,
1224                         .val = BD718XX_LDO_SEL,
1225                 },
1226                 .additional_inits = bd71837_ldo6_inits,
1227                 .additional_init_amnt = ARRAY_SIZE(bd71837_ldo6_inits),
1228         },
1229         {
1230                 .desc = {
1231                         .name = "ldo7",
1232                         .of_match = of_match_ptr("LDO7"),
1233                         .regulators_node = of_match_ptr("regulators"),
1234                         .id = BD718XX_LDO7,
1235                         .ops = &bd71837_ldo_regulator_ops,
1236                         .type = REGULATOR_VOLTAGE,
1237                         .n_voltages = BD71837_LDO7_VOLTAGE_NUM,
1238                         .linear_ranges = bd71837_ldo7_volts,
1239                         .n_linear_ranges = ARRAY_SIZE(bd71837_ldo7_volts),
1240                         .vsel_reg = BD71837_REG_LDO7_VOLT,
1241                         .vsel_mask = BD71837_LDO7_MASK,
1242                         .enable_reg = BD71837_REG_LDO7_VOLT,
1243                         .enable_mask = BD718XX_LDO_EN,
1244                         .owner = THIS_MODULE,
1245                 },
1246                 .init = {
1247                         .reg = BD71837_REG_LDO7_VOLT,
1248                         .mask = BD718XX_LDO_SEL,
1249                         .val = BD718XX_LDO_SEL,
1250                 },
1251         },
1252 };
1253
1254 static int bd718xx_probe(struct platform_device *pdev)
1255 {
1256         struct bd718xx *mfd;
1257         struct regulator_config config = { 0 };
1258         int i, j, err;
1259         bool use_snvs;
1260         const struct bd718xx_regulator_data *reg_data;
1261         unsigned int num_reg_data;
1262         enum rohm_chip_type chip = platform_get_device_id(pdev)->driver_data;
1263
1264         mfd = dev_get_drvdata(pdev->dev.parent);
1265         if (!mfd) {
1266                 dev_err(&pdev->dev, "No MFD driver data\n");
1267                 err = -EINVAL;
1268                 goto err;
1269         }
1270
1271         switch (chip) {
1272         case ROHM_CHIP_TYPE_BD71837:
1273                 reg_data = bd71837_regulators;
1274                 num_reg_data = ARRAY_SIZE(bd71837_regulators);
1275                 break;
1276         case ROHM_CHIP_TYPE_BD71847:
1277                 reg_data = bd71847_regulators;
1278                 num_reg_data = ARRAY_SIZE(bd71847_regulators);
1279                 break;
1280         default:
1281                 dev_err(&pdev->dev, "Unsupported chip type\n");
1282                 err = -EINVAL;
1283                 goto err;
1284         }
1285
1286         /* Register LOCK release */
1287         err = regmap_update_bits(mfd->chip.regmap, BD718XX_REG_REGLOCK,
1288                                  (REGLOCK_PWRSEQ | REGLOCK_VREG), 0);
1289         if (err) {
1290                 dev_err(&pdev->dev, "Failed to unlock PMIC (%d)\n", err);
1291                 goto err;
1292         } else {
1293                 dev_dbg(&pdev->dev, "Unlocked lock register 0x%x\n",
1294                         BD718XX_REG_REGLOCK);
1295         }
1296
1297         use_snvs = of_property_read_bool(pdev->dev.parent->of_node,
1298                                          "rohm,reset-snvs-powered");
1299
1300         /*
1301          * Change the next stage from poweroff to be READY instead of SNVS
1302          * for all reset types because OTP loading at READY will clear SEL
1303          * bit allowing HW defaults for power rails to be used
1304          */
1305         if (!use_snvs) {
1306                 err = regmap_update_bits(mfd->chip.regmap,
1307                                          BD718XX_REG_TRANS_COND1,
1308                                          BD718XX_ON_REQ_POWEROFF_MASK |
1309                                          BD718XX_SWRESET_POWEROFF_MASK |
1310                                          BD718XX_WDOG_POWEROFF_MASK |
1311                                          BD718XX_KEY_L_POWEROFF_MASK,
1312                                          BD718XX_POWOFF_TO_RDY);
1313                 if (err) {
1314                         dev_err(&pdev->dev, "Failed to change reset target\n");
1315                         goto err;
1316                 } else {
1317                         dev_dbg(&pdev->dev,
1318                                 "Changed all resets from SVNS to READY\n");
1319                 }
1320         }
1321
1322         for (i = 0; i < num_reg_data; i++) {
1323
1324                 const struct regulator_desc *desc;
1325                 struct regulator_dev *rdev;
1326                 const struct bd718xx_regulator_data *r;
1327
1328                 r = &reg_data[i];
1329                 desc = &r->desc;
1330
1331                 config.dev = pdev->dev.parent;
1332                 config.regmap = mfd->chip.regmap;
1333
1334                 rdev = devm_regulator_register(&pdev->dev, desc, &config);
1335                 if (IS_ERR(rdev)) {
1336                         dev_err(&pdev->dev,
1337                                 "failed to register %s regulator\n",
1338                                 desc->name);
1339                         err = PTR_ERR(rdev);
1340                         goto err;
1341                 }
1342
1343                 /*
1344                  * Regulator register gets the regulator constraints and
1345                  * applies them (set_machine_constraints). This should have
1346                  * turned the control register(s) to correct values and we
1347                  * can now switch the control from PMIC state machine to the
1348                  * register interface
1349                  *
1350                  * At poweroff transition PMIC HW disables EN bit for
1351                  * regulators but leaves SEL bit untouched. So if state
1352                  * transition from POWEROFF is done to SNVS - then all power
1353                  * rails controlled by SW (having SEL bit set) stay disabled
1354                  * as EN is cleared. This will result boot failure if any
1355                  * crucial systems are powered by these rails. We don't
1356                  * enable SW control for crucial regulators if snvs state is
1357                  * used
1358                  */
1359                 if (!use_snvs || !rdev->constraints->always_on ||
1360                     !rdev->constraints->boot_on) {
1361                         err = regmap_update_bits(mfd->chip.regmap, r->init.reg,
1362                                                  r->init.mask, r->init.val);
1363                         if (err) {
1364                                 dev_err(&pdev->dev,
1365                                         "Failed to take control for (%s)\n",
1366                                         desc->name);
1367                                 goto err;
1368                         }
1369                 }
1370                 for (j = 0; j < r->additional_init_amnt; j++) {
1371                         err = regmap_update_bits(mfd->chip.regmap,
1372                                                  r->additional_inits[j].reg,
1373                                                  r->additional_inits[j].mask,
1374                                                  r->additional_inits[j].val);
1375                         if (err) {
1376                                 dev_err(&pdev->dev,
1377                                         "Buck (%s) initialization failed\n",
1378                                         desc->name);
1379                                 goto err;
1380                         }
1381                 }
1382         }
1383
1384 err:
1385         return err;
1386 }
1387
1388 static const struct platform_device_id bd718x7_pmic_id[] = {
1389         { "bd71837-pmic", ROHM_CHIP_TYPE_BD71837 },
1390         { "bd71847-pmic", ROHM_CHIP_TYPE_BD71847 },
1391         { },
1392 };
1393 MODULE_DEVICE_TABLE(platform, bd718x7_pmic_id);
1394
1395 static struct platform_driver bd718xx_regulator = {
1396         .driver = {
1397                 .name = "bd718xx-pmic",
1398         },
1399         .probe = bd718xx_probe,
1400         .id_table = bd718x7_pmic_id,
1401 };
1402
1403 module_platform_driver(bd718xx_regulator);
1404
1405 MODULE_AUTHOR("Matti Vaittinen <matti.vaittinen@fi.rohmeurope.com>");
1406 MODULE_DESCRIPTION("BD71837/BD71847 voltage regulator driver");
1407 MODULE_LICENSE("GPL");
1408 MODULE_ALIAS("platform:bd718xx-pmic");