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