drivers/regulator/bd71837-regulator.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 // Copyright (C) 2018 ROHM Semiconductors
   3 // bd71837-regulator.c ROHM BD71837MWV 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/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 struct bd71837_pmic {
  19         struct regulator_desc descs[BD71837_REGULATOR_CNT];
  20         struct bd71837 *mfd;
  21         struct platform_device *pdev;
  22         struct regulator_dev *rdev[BD71837_REGULATOR_CNT];
  23 };
  24
  25 /*
  26  * BUCK1/2/3/4
  27  * BUCK1RAMPRATE[1:0] BUCK1 DVS ramp rate setting
  28  * 00: 10.00mV/usec 10mV 1uS
  29  * 01: 5.00mV/usec      10mV 2uS
  30  * 10: 2.50mV/usec      10mV 4uS
  31  * 11: 1.25mV/usec      10mV 8uS
  32  */
  33 static int bd71837_buck1234_set_ramp_delay(struct regulator_dev *rdev,
  34                                            int ramp_delay)
  35 {
  36         struct bd71837_pmic *pmic = rdev_get_drvdata(rdev);
  37         struct bd71837 *mfd = pmic->mfd;
  38         int id = rdev->desc->id;
  39         unsigned int ramp_value = BUCK_RAMPRATE_10P00MV;
  40
  41         dev_dbg(&pmic->pdev->dev, "Buck[%d] Set Ramp = %d\n", id + 1,
  42                 ramp_delay);
  43         switch (ramp_delay) {
  44         case 1 ... 1250:
  45                 ramp_value = BUCK_RAMPRATE_1P25MV;
  46                 break;
  47         case 1251 ... 2500:
  48                 ramp_value = BUCK_RAMPRATE_2P50MV;
  49                 break;
  50         case 2501 ... 5000:
  51                 ramp_value = BUCK_RAMPRATE_5P00MV;
  52                 break;
  53         case 5001 ... 10000:
  54                 ramp_value = BUCK_RAMPRATE_10P00MV;
  55                 break;
  56         default:
  57                 ramp_value = BUCK_RAMPRATE_10P00MV;
  58                 dev_err(&pmic->pdev->dev,
  59                         "%s: ramp_delay: %d not supported, setting 10000mV//us\n",
  60                         rdev->desc->name, ramp_delay);
  61         }
  62
  63         return regmap_update_bits(mfd->regmap, BD71837_REG_BUCK1_CTRL + id,
  64                                   BUCK_RAMPRATE_MASK, ramp_value << 6);
  65 }
  66
  67 /* Bucks 1 to 4 support DVS. PWM mode is used when voltage is changed.
  68  * Bucks 5 to 8 and LDOs can use PFM and must be disabled when voltage
  69  * is changed. Hence we return -EBUSY for these if voltage is changed
  70  * when BUCK/LDO is enabled.
  71  */
  72 static int bd71837_set_voltage_sel_restricted(struct regulator_dev *rdev,
  73                                                     unsigned int sel)
  74 {
  75         if (regulator_is_enabled_regmap(rdev))
  76                 return -EBUSY;
  77
  78         return regulator_set_voltage_sel_regmap(rdev, sel);
  79 }
  80
  81 static struct regulator_ops bd71837_ldo_regulator_ops = {
  82         .enable = regulator_enable_regmap,
  83         .disable = regulator_disable_regmap,
  84         .is_enabled = regulator_is_enabled_regmap,
  85         .list_voltage = regulator_list_voltage_linear_range,
  86         .set_voltage_sel = bd71837_set_voltage_sel_restricted,
  87         .get_voltage_sel = regulator_get_voltage_sel_regmap,
  88 };
  89
  90 static struct regulator_ops bd71837_ldo_regulator_nolinear_ops = {
  91         .enable = regulator_enable_regmap,
  92         .disable = regulator_disable_regmap,
  93         .is_enabled = regulator_is_enabled_regmap,
  94         .list_voltage = regulator_list_voltage_table,
  95         .set_voltage_sel = bd71837_set_voltage_sel_restricted,
  96         .get_voltage_sel = regulator_get_voltage_sel_regmap,
  97 };
  98
  99 static struct regulator_ops bd71837_buck_regulator_ops = {
 100         .enable = regulator_enable_regmap,
 101         .disable = regulator_disable_regmap,
 102         .is_enabled = regulator_is_enabled_regmap,
 103         .list_voltage = regulator_list_voltage_linear_range,
 104         .set_voltage_sel = bd71837_set_voltage_sel_restricted,
 105         .get_voltage_sel = regulator_get_voltage_sel_regmap,
 106         .set_voltage_time_sel = regulator_set_voltage_time_sel,
 107 };
 108
 109 static struct regulator_ops bd71837_buck_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 = bd71837_set_voltage_sel_restricted,
 115         .get_voltage_sel = regulator_get_voltage_sel_regmap,
 116         .set_voltage_time_sel = regulator_set_voltage_time_sel,
 117 };
 118
 119 static struct regulator_ops bd71837_buck1234_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 = regulator_set_voltage_sel_regmap,
 125         .get_voltage_sel = regulator_get_voltage_sel_regmap,
 126         .set_voltage_time_sel = regulator_set_voltage_time_sel,
 127         .set_ramp_delay = bd71837_buck1234_set_ramp_delay,
 128 };
 129
 130 /*
 131  * BUCK1/2/3/4
 132  * 0.70 to 1.30V (10mV step)
 133  */
 134 static const struct regulator_linear_range bd71837_buck1234_voltage_ranges[] = {
 135         REGULATOR_LINEAR_RANGE(700000, 0x00, 0x3C, 10000),
 136         REGULATOR_LINEAR_RANGE(1300000, 0x3D, 0x3F, 0),
 137 };
 138
 139 /*
 140  * BUCK5
 141  * 0.9V to 1.35V ()
 142  */
 143 static const struct regulator_linear_range bd71837_buck5_voltage_ranges[] = {
 144         REGULATOR_LINEAR_RANGE(700000, 0x00, 0x03, 100000),
 145         REGULATOR_LINEAR_RANGE(1050000, 0x04, 0x05, 50000),
 146         REGULATOR_LINEAR_RANGE(1200000, 0x06, 0x07, 150000),
 147 };
 148
 149 /*
 150  * BUCK6
 151  * 3.0V to 3.3V (step 100mV)
 152  */
 153 static const struct regulator_linear_range bd71837_buck6_voltage_ranges[] = {
 154         REGULATOR_LINEAR_RANGE(3000000, 0x00, 0x03, 100000),
 155 };
 156
 157 /*
 158  * BUCK7
 159  * 000 = 1.605V
 160  * 001 = 1.695V
 161  * 010 = 1.755V
 162  * 011 = 1.8V (Initial)
 163  * 100 = 1.845V
 164  * 101 = 1.905V
 165  * 110 = 1.95V
 166  * 111 = 1.995V
 167  */
 168 static const unsigned int buck_7_volts[] = {
 169         1605000, 1695000, 1755000, 1800000, 1845000, 1905000, 1950000, 1995000
 170 };
 171
 172 /*
 173  * BUCK8
 174  * 0.8V to 1.40V (step 10mV)
 175  */
 176 static const struct regulator_linear_range bd71837_buck8_voltage_ranges[] = {
 177         REGULATOR_LINEAR_RANGE(800000, 0x00, 0x3C, 10000),
 178         REGULATOR_LINEAR_RANGE(1400000, 0x3D, 0x3F, 0),
 179 };
 180
 181 /*
 182  * LDO1
 183  * 3.0 to 3.3V (100mV step)
 184  */
 185 static const struct regulator_linear_range bd71837_ldo1_voltage_ranges[] = {
 186         REGULATOR_LINEAR_RANGE(3000000, 0x00, 0x03, 100000),
 187 };
 188
 189 /*
 190  * LDO2
 191  * 0.8 or 0.9V
 192  */
 193 static const unsigned int ldo_2_volts[] = {
 194         900000, 800000
 195 };
 196
 197 /*
 198  * LDO3
 199  * 1.8 to 3.3V (100mV step)
 200  */
 201 static const struct regulator_linear_range bd71837_ldo3_voltage_ranges[] = {
 202         REGULATOR_LINEAR_RANGE(1800000, 0x00, 0x0F, 100000),
 203 };
 204
 205 /*
 206  * LDO4
 207  * 0.9 to 1.8V (100mV step)
 208  */
 209 static const struct regulator_linear_range bd71837_ldo4_voltage_ranges[] = {
 210         REGULATOR_LINEAR_RANGE(900000, 0x00, 0x09, 100000),
 211         REGULATOR_LINEAR_RANGE(1800000, 0x0A, 0x0F, 0),
 212 };
 213
 214 /*
 215  * LDO5
 216  * 1.8 to 3.3V (100mV step)
 217  */
 218 static const struct regulator_linear_range bd71837_ldo5_voltage_ranges[] = {
 219         REGULATOR_LINEAR_RANGE(1800000, 0x00, 0x0F, 100000),
 220 };
 221
 222 /*
 223  * LDO6
 224  * 0.9 to 1.8V (100mV step)
 225  */
 226 static const struct regulator_linear_range bd71837_ldo6_voltage_ranges[] = {
 227         REGULATOR_LINEAR_RANGE(900000, 0x00, 0x09, 100000),
 228         REGULATOR_LINEAR_RANGE(1800000, 0x0A, 0x0F, 0),
 229 };
 230
 231 /*
 232  * LDO7
 233  * 1.8 to 3.3V (100mV step)
 234  */
 235 static const struct regulator_linear_range bd71837_ldo7_voltage_ranges[] = {
 236         REGULATOR_LINEAR_RANGE(1800000, 0x00, 0x0F, 100000),
 237 };
 238
 239 static const struct regulator_desc bd71837_regulators[] = {
 240         {
 241                 .name = "buck1",
 242                 .of_match = of_match_ptr("BUCK1"),
 243                 .regulators_node = of_match_ptr("regulators"),
 244                 .id = BD71837_BUCK1,
 245                 .ops = &bd71837_buck1234_regulator_ops,
 246                 .type = REGULATOR_VOLTAGE,
 247                 .n_voltages = BD71837_BUCK1_VOLTAGE_NUM,
 248                 .linear_ranges = bd71837_buck1234_voltage_ranges,
 249                 .n_linear_ranges = ARRAY_SIZE(bd71837_buck1234_voltage_ranges),
 250                 .vsel_reg = BD71837_REG_BUCK1_VOLT_RUN,
 251                 .vsel_mask = BUCK1_RUN_MASK,
 252                 .enable_reg = BD71837_REG_BUCK1_CTRL,
 253                 .enable_mask = BD71837_BUCK_EN,
 254                 .owner = THIS_MODULE,
 255         },
 256         {
 257                 .name = "buck2",
 258                 .of_match = of_match_ptr("BUCK2"),
 259                 .regulators_node = of_match_ptr("regulators"),
 260                 .id = BD71837_BUCK2,
 261                 .ops = &bd71837_buck1234_regulator_ops,
 262                 .type = REGULATOR_VOLTAGE,
 263                 .n_voltages = BD71837_BUCK2_VOLTAGE_NUM,
 264                 .linear_ranges = bd71837_buck1234_voltage_ranges,
 265                 .n_linear_ranges = ARRAY_SIZE(bd71837_buck1234_voltage_ranges),
 266                 .vsel_reg = BD71837_REG_BUCK2_VOLT_RUN,
 267                 .vsel_mask = BUCK2_RUN_MASK,
 268                 .enable_reg = BD71837_REG_BUCK2_CTRL,
 269                 .enable_mask = BD71837_BUCK_EN,
 270                 .owner = THIS_MODULE,
 271         },
 272         {
 273                 .name = "buck3",
 274                 .of_match = of_match_ptr("BUCK3"),
 275                 .regulators_node = of_match_ptr("regulators"),
 276                 .id = BD71837_BUCK3,
 277                 .ops = &bd71837_buck1234_regulator_ops,
 278                 .type = REGULATOR_VOLTAGE,
 279                 .n_voltages = BD71837_BUCK3_VOLTAGE_NUM,
 280                 .linear_ranges = bd71837_buck1234_voltage_ranges,
 281                 .n_linear_ranges = ARRAY_SIZE(bd71837_buck1234_voltage_ranges),
 282                 .vsel_reg = BD71837_REG_BUCK3_VOLT_RUN,
 283                 .vsel_mask = BUCK3_RUN_MASK,
 284                 .enable_reg = BD71837_REG_BUCK3_CTRL,
 285                 .enable_mask = BD71837_BUCK_EN,
 286                 .owner = THIS_MODULE,
 287         },
 288         {
 289                 .name = "buck4",
 290                 .of_match = of_match_ptr("BUCK4"),
 291                 .regulators_node = of_match_ptr("regulators"),
 292                         .id = BD71837_BUCK4,
 293                 .ops = &bd71837_buck1234_regulator_ops,
 294                 .type = REGULATOR_VOLTAGE,
 295                 .n_voltages = BD71837_BUCK4_VOLTAGE_NUM,
 296                 .linear_ranges = bd71837_buck1234_voltage_ranges,
 297                 .n_linear_ranges = ARRAY_SIZE(bd71837_buck1234_voltage_ranges),
 298                 .vsel_reg = BD71837_REG_BUCK4_VOLT_RUN,
 299                 .vsel_mask = BUCK4_RUN_MASK,
 300                 .enable_reg = BD71837_REG_BUCK4_CTRL,
 301                 .enable_mask = BD71837_BUCK_EN,
 302                 .owner = THIS_MODULE,
 303         },
 304         {
 305                 .name = "buck5",
 306                 .of_match = of_match_ptr("BUCK5"),
 307                 .regulators_node = of_match_ptr("regulators"),
 308                 .id = BD71837_BUCK5,
 309                 .ops = &bd71837_buck_regulator_ops,
 310                 .type = REGULATOR_VOLTAGE,
 311                 .n_voltages = BD71837_BUCK5_VOLTAGE_NUM,
 312                 .linear_ranges = bd71837_buck5_voltage_ranges,
 313                 .n_linear_ranges = ARRAY_SIZE(bd71837_buck5_voltage_ranges),
 314                 .vsel_reg = BD71837_REG_BUCK5_VOLT,
 315                 .vsel_mask = BUCK5_MASK,
 316                 .enable_reg = BD71837_REG_BUCK5_CTRL,
 317                 .enable_mask = BD71837_BUCK_EN,
 318                 .owner = THIS_MODULE,
 319         },
 320         {
 321                 .name = "buck6",
 322                 .of_match = of_match_ptr("BUCK6"),
 323                 .regulators_node = of_match_ptr("regulators"),
 324                 .id = BD71837_BUCK6,
 325                 .ops = &bd71837_buck_regulator_ops,
 326                 .type = REGULATOR_VOLTAGE,
 327                 .n_voltages = BD71837_BUCK6_VOLTAGE_NUM,
 328                 .linear_ranges = bd71837_buck6_voltage_ranges,
 329                 .n_linear_ranges = ARRAY_SIZE(bd71837_buck6_voltage_ranges),
 330                 .vsel_reg = BD71837_REG_BUCK6_VOLT,
 331                 .vsel_mask = BUCK6_MASK,
 332                 .enable_reg = BD71837_REG_BUCK6_CTRL,
 333                 .enable_mask = BD71837_BUCK_EN,
 334                 .owner = THIS_MODULE,
 335         },
 336         {
 337                 .name = "buck7",
 338                 .of_match = of_match_ptr("BUCK7"),
 339                 .regulators_node = of_match_ptr("regulators"),
 340                 .id = BD71837_BUCK7,
 341                 .ops = &bd71837_buck_regulator_nolinear_ops,
 342                 .type = REGULATOR_VOLTAGE,
 343                 .volt_table = &buck_7_volts[0],
 344                 .n_voltages = ARRAY_SIZE(buck_7_volts),
 345                 .vsel_reg = BD71837_REG_BUCK7_VOLT,
 346                 .vsel_mask = BUCK7_MASK,
 347                 .enable_reg = BD71837_REG_BUCK7_CTRL,
 348                 .enable_mask = BD71837_BUCK_EN,
 349                 .owner = THIS_MODULE,
 350         },
 351         {
 352                 .name = "buck8",
 353                 .of_match = of_match_ptr("BUCK8"),
 354                 .regulators_node = of_match_ptr("regulators"),
 355                 .id = BD71837_BUCK8,
 356                 .ops = &bd71837_buck_regulator_ops,
 357                 .type = REGULATOR_VOLTAGE,
 358                 .n_voltages = BD71837_BUCK8_VOLTAGE_NUM,
 359                 .linear_ranges = bd71837_buck8_voltage_ranges,
 360                 .n_linear_ranges = ARRAY_SIZE(bd71837_buck8_voltage_ranges),
 361                 .vsel_reg = BD71837_REG_BUCK8_VOLT,
 362                 .vsel_mask = BUCK8_MASK,
 363                 .enable_reg = BD71837_REG_BUCK8_CTRL,
 364                 .enable_mask = BD71837_BUCK_EN,
 365                 .owner = THIS_MODULE,
 366         },
 367         {
 368                 .name = "ldo1",
 369                 .of_match = of_match_ptr("LDO1"),
 370                 .regulators_node = of_match_ptr("regulators"),
 371                 .id = BD71837_LDO1,
 372                 .ops = &bd71837_ldo_regulator_ops,
 373                 .type = REGULATOR_VOLTAGE,
 374                 .n_voltages = BD71837_LDO1_VOLTAGE_NUM,
 375                 .linear_ranges = bd71837_ldo1_voltage_ranges,
 376                 .n_linear_ranges = ARRAY_SIZE(bd71837_ldo1_voltage_ranges),
 377                 .vsel_reg = BD71837_REG_LDO1_VOLT,
 378                 .vsel_mask = LDO1_MASK,
 379                 .enable_reg = BD71837_REG_LDO1_VOLT,
 380                 .enable_mask = BD71837_LDO_EN,
 381                 .owner = THIS_MODULE,
 382         },
 383         {
 384                 .name = "ldo2",
 385                 .of_match = of_match_ptr("LDO2"),
 386                 .regulators_node = of_match_ptr("regulators"),
 387                 .id = BD71837_LDO2,
 388                 .ops = &bd71837_ldo_regulator_nolinear_ops,
 389                 .type = REGULATOR_VOLTAGE,
 390                 .volt_table = &ldo_2_volts[0],
 391                 .vsel_reg = BD71837_REG_LDO2_VOLT,
 392                 .vsel_mask = LDO2_MASK,
 393                 .n_voltages = ARRAY_SIZE(ldo_2_volts),
 394                 .n_voltages = BD71837_LDO2_VOLTAGE_NUM,
 395                 .enable_reg = BD71837_REG_LDO2_VOLT,
 396                 .enable_mask = BD71837_LDO_EN,
 397                 .owner = THIS_MODULE,
 398         },
 399         {
 400                 .name = "ldo3",
 401                 .of_match = of_match_ptr("LDO3"),
 402                 .regulators_node = of_match_ptr("regulators"),
 403                 .id = BD71837_LDO3,
 404                 .ops = &bd71837_ldo_regulator_ops,
 405                 .type = REGULATOR_VOLTAGE,
 406                 .n_voltages = BD71837_LDO3_VOLTAGE_NUM,
 407                 .linear_ranges = bd71837_ldo3_voltage_ranges,
 408                 .n_linear_ranges = ARRAY_SIZE(bd71837_ldo3_voltage_ranges),
 409                 .vsel_reg = BD71837_REG_LDO3_VOLT,
 410                 .vsel_mask = LDO3_MASK,
 411                 .enable_reg = BD71837_REG_LDO3_VOLT,
 412                 .enable_mask = BD71837_LDO_EN,
 413                 .owner = THIS_MODULE,
 414         },
 415         {
 416                 .name = "ldo4",
 417                 .of_match = of_match_ptr("LDO4"),
 418                 .regulators_node = of_match_ptr("regulators"),
 419                 .id = BD71837_LDO4,
 420                 .ops = &bd71837_ldo_regulator_ops,
 421                 .type = REGULATOR_VOLTAGE,
 422                 .n_voltages = BD71837_LDO4_VOLTAGE_NUM,
 423                 .linear_ranges = bd71837_ldo4_voltage_ranges,
 424                 .n_linear_ranges = ARRAY_SIZE(bd71837_ldo4_voltage_ranges),
 425                 .vsel_reg = BD71837_REG_LDO4_VOLT,
 426                 .vsel_mask = LDO4_MASK,
 427                 .enable_reg = BD71837_REG_LDO4_VOLT,
 428                 .enable_mask = BD71837_LDO_EN,
 429                 .owner = THIS_MODULE,
 430         },
 431         {
 432                 .name = "ldo5",
 433                 .of_match = of_match_ptr("LDO5"),
 434                 .regulators_node = of_match_ptr("regulators"),
 435                 .id = BD71837_LDO5,
 436                 .ops = &bd71837_ldo_regulator_ops,
 437                 .type = REGULATOR_VOLTAGE,
 438                 .n_voltages = BD71837_LDO5_VOLTAGE_NUM,
 439                 .linear_ranges = bd71837_ldo5_voltage_ranges,
 440                 .n_linear_ranges = ARRAY_SIZE(bd71837_ldo5_voltage_ranges),
 441                 /* LDO5 is supplied by buck6 */
 442                 .supply_name = "buck6",
 443                 .vsel_reg = BD71837_REG_LDO5_VOLT,
 444                 .vsel_mask = LDO5_MASK,
 445                 .enable_reg = BD71837_REG_LDO5_VOLT,
 446                 .enable_mask = BD71837_LDO_EN,
 447                 .owner = THIS_MODULE,
 448         },
 449         {
 450                 .name = "ldo6",
 451                 .of_match = of_match_ptr("LDO6"),
 452                 .regulators_node = of_match_ptr("regulators"),
 453                 .id = BD71837_LDO6,
 454                 .ops = &bd71837_ldo_regulator_ops,
 455                 .type = REGULATOR_VOLTAGE,
 456                 .n_voltages = BD71837_LDO6_VOLTAGE_NUM,
 457                 .linear_ranges = bd71837_ldo6_voltage_ranges,
 458                 .n_linear_ranges = ARRAY_SIZE(bd71837_ldo6_voltage_ranges),
 459                 /* LDO6 is supplied by buck7 */
 460                 .supply_name = "buck7",
 461                 .vsel_reg = BD71837_REG_LDO6_VOLT,
 462                 .vsel_mask = LDO6_MASK,
 463                 .enable_reg = BD71837_REG_LDO6_VOLT,
 464                 .enable_mask = BD71837_LDO_EN,
 465                 .owner = THIS_MODULE,
 466         },
 467         {
 468                 .name = "ldo7",
 469                 .of_match = of_match_ptr("LDO7"),
 470                 .regulators_node = of_match_ptr("regulators"),
 471                 .id = BD71837_LDO7,
 472                 .ops = &bd71837_ldo_regulator_ops,
 473                 .type = REGULATOR_VOLTAGE,
 474                 .n_voltages = BD71837_LDO7_VOLTAGE_NUM,
 475                 .linear_ranges = bd71837_ldo7_voltage_ranges,
 476                 .n_linear_ranges = ARRAY_SIZE(bd71837_ldo7_voltage_ranges),
 477                 .vsel_reg = BD71837_REG_LDO7_VOLT,
 478                 .vsel_mask = LDO7_MASK,
 479                 .enable_reg = BD71837_REG_LDO7_VOLT,
 480                 .enable_mask = BD71837_LDO_EN,
 481                 .owner = THIS_MODULE,
 482         },
 483 };
 484
 485 struct reg_init {
 486         unsigned int reg;
 487         unsigned int mask;
 488 };
 489
 490 static int bd71837_probe(struct platform_device *pdev)
 491 {
 492         struct bd71837_pmic *pmic;
 493         struct regulator_config config = { 0 };
 494         struct reg_init pmic_regulator_inits[] = {
 495                 {
 496                         .reg = BD71837_REG_BUCK1_CTRL,
 497                         .mask = BD71837_BUCK_SEL,
 498                 }, {
 499                         .reg = BD71837_REG_BUCK2_CTRL,
 500                         .mask = BD71837_BUCK_SEL,
 501                 }, {
 502                         .reg = BD71837_REG_BUCK3_CTRL,
 503                         .mask = BD71837_BUCK_SEL,
 504                 }, {
 505                         .reg = BD71837_REG_BUCK4_CTRL,
 506                         .mask = BD71837_BUCK_SEL,
 507                 }, {
 508                         .reg = BD71837_REG_BUCK5_CTRL,
 509                         .mask = BD71837_BUCK_SEL,
 510                 }, {
 511                         .reg = BD71837_REG_BUCK6_CTRL,
 512                         .mask = BD71837_BUCK_SEL,
 513                 }, {
 514                         .reg = BD71837_REG_BUCK7_CTRL,
 515                         .mask = BD71837_BUCK_SEL,
 516                 }, {
 517                         .reg = BD71837_REG_BUCK8_CTRL,
 518                         .mask = BD71837_BUCK_SEL,
 519                 }, {
 520                         .reg = BD71837_REG_LDO1_VOLT,
 521                         .mask = BD71837_LDO_SEL,
 522                 }, {
 523                         .reg = BD71837_REG_LDO2_VOLT,
 524                         .mask = BD71837_LDO_SEL,
 525                 }, {
 526                         .reg = BD71837_REG_LDO3_VOLT,
 527                         .mask = BD71837_LDO_SEL,
 528                 }, {
 529                         .reg = BD71837_REG_LDO4_VOLT,
 530                         .mask = BD71837_LDO_SEL,
 531                 }, {
 532                         .reg = BD71837_REG_LDO5_VOLT,
 533                         .mask = BD71837_LDO_SEL,
 534                 }, {
 535                         .reg = BD71837_REG_LDO6_VOLT,
 536                         .mask = BD71837_LDO_SEL,
 537                 }, {
 538                         .reg = BD71837_REG_LDO7_VOLT,
 539                         .mask = BD71837_LDO_SEL,
 540                 }
 541         };
 542
 543         int i, err;
 544
 545         pmic = devm_kzalloc(&pdev->dev, sizeof(*pmic), GFP_KERNEL);
 546         if (!pmic)
 547                 return -ENOMEM;
 548
 549         memcpy(pmic->descs, bd71837_regulators, sizeof(pmic->descs));
 550
 551         pmic->pdev = pdev;
 552         pmic->mfd = dev_get_drvdata(pdev->dev.parent);
 553
 554         if (!pmic->mfd) {
 555                 dev_err(&pdev->dev, "No MFD driver data\n");
 556                 err = -EINVAL;
 557                 goto err;
 558         }
 559         platform_set_drvdata(pdev, pmic);
 560
 561         /* Register LOCK release */
 562         err = regmap_update_bits(pmic->mfd->regmap, BD71837_REG_REGLOCK,
 563                                  (REGLOCK_PWRSEQ | REGLOCK_VREG), 0);
 564         if (err) {
 565                 dev_err(&pmic->pdev->dev, "Failed to unlock PMIC (%d)\n", err);
 566                 goto err;
 567         } else {
 568                 dev_dbg(&pmic->pdev->dev, "Unlocked lock register 0x%x\n",
 569                         BD71837_REG_REGLOCK);
 570         }
 571
 572         /*
 573          * There is a HW quirk in BD71837. The shutdown sequence timings for
 574          * bucks/LDOs which are controlled via register interface are changed.
 575          * At PMIC poweroff the voltage for BUCK6/7 is cut immediately at the
 576          * beginning of shut-down sequence. As bucks 6 and 7 are parent
 577          * supplies for LDO5 and LDO6 - this causes LDO5/6 voltage
 578          * monitoring to errorneously detect under voltage and force PMIC to
 579          * emergency state instead of poweroff. In order to avoid this we
 580          * disable voltage monitoring for LDO5 and LDO6
 581          */
 582         err = regmap_update_bits(pmic->mfd->regmap, BD718XX_REG_MVRFLTMASK2,
 583                                  BD718XX_LDO5_VRMON80 | BD718XX_LDO6_VRMON80,
 584                                  BD718XX_LDO5_VRMON80 | BD718XX_LDO6_VRMON80);
 585         if (err) {
 586                 dev_err(&pmic->pdev->dev,
 587                         "Failed to disable voltage monitoring\n");
 588                 goto err;
 589         }
 590
 591         for (i = 0; i < ARRAY_SIZE(pmic_regulator_inits); i++) {
 592
 593                 struct regulator_desc *desc;
 594                 struct regulator_dev *rdev;
 595
 596                 desc = &pmic->descs[i];
 597
 598                 config.dev = pdev->dev.parent;
 599                 config.driver_data = pmic;
 600                 config.regmap = pmic->mfd->regmap;
 601
 602                 rdev = devm_regulator_register(&pdev->dev, desc, &config);
 603                 if (IS_ERR(rdev)) {
 604                         dev_err(pmic->mfd->dev,
 605                                 "failed to register %s regulator\n",
 606                                 desc->name);
 607                         err = PTR_ERR(rdev);
 608                         goto err;
 609                 }
 610                 /* Regulator register gets the regulator constraints and
 611                  * applies them (set_machine_constraints). This should have
 612                  * turned the control register(s) to correct values and we
 613                  * can now switch the control from PMIC state machine to the
 614                  * register interface
 615                  */
 616                 err = regmap_update_bits(pmic->mfd->regmap,
 617                                          pmic_regulator_inits[i].reg,
 618                                          pmic_regulator_inits[i].mask,
 619                                          0xFFFFFFFF);
 620                 if (err) {
 621                         dev_err(&pmic->pdev->dev,
 622                                 "Failed to write BUCK/LDO SEL bit for (%s)\n",
 623                                 desc->name);
 624                         goto err;
 625                 }
 626
 627                 pmic->rdev[i] = rdev;
 628         }
 629
 630 err:
 631         return err;
 632 }
 633
 634 static struct platform_driver bd71837_regulator = {
 635         .driver = {
 636                 .name = "bd71837-pmic",
 637         },
 638         .probe = bd71837_probe,
 639 };
 640
 641 module_platform_driver(bd71837_regulator);
 642
 643 MODULE_AUTHOR("Matti Vaittinen <matti.vaittinen@fi.rohmeurope.com>");
 644 MODULE_DESCRIPTION("BD71837 voltage regulator driver");
 645 MODULE_LICENSE("GPL");