drivers/regulator/bd718x7-regulator.c

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