drivers/regulator/bd718x7-regulator.c

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