drivers/regulator/bd71828-regulator.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 // Copyright (C) 2019 ROHM Semiconductors
   3 // bd71828-regulator.c ROHM BD71828GW-DS1 regulator driver
   4 //
   5
   6 #include <linux/delay.h>
   7 #include <linux/err.h>
   8 #include <linux/gpio.h>
   9 #include <linux/interrupt.h>
  10 #include <linux/kernel.h>
  11 #include <linux/mfd/rohm-bd71828.h>
  12 #include <linux/module.h>
  13 #include <linux/of.h>
  14 #include <linux/platform_device.h>
  15 #include <linux/regmap.h>
  16 #include <linux/regulator/driver.h>
  17 #include <linux/regulator/machine.h>
  18 #include <linux/regulator/of_regulator.h>
  19
  20 struct reg_init {
  21         unsigned int reg;
  22         unsigned int mask;
  23         unsigned int val;
  24 };
  25 struct bd71828_regulator_data {
  26         struct regulator_desc desc;
  27         const struct rohm_dvs_config dvs;
  28         const struct reg_init *reg_inits;
  29         int reg_init_amnt;
  30 };
  31
  32 static const struct reg_init buck1_inits[] = {
  33         /*
  34          * DVS Buck voltages can be changed by register values or via GPIO.
  35          * Use register accesses by default.
  36          */
  37         {
  38                 .reg = BD71828_REG_PS_CTRL_1,
  39                 .mask = BD71828_MASK_DVS_BUCK1_CTRL,
  40                 .val = BD71828_DVS_BUCK1_CTRL_I2C,
  41         },
  42 };
  43
  44 static const struct reg_init buck2_inits[] = {
  45         {
  46                 .reg = BD71828_REG_PS_CTRL_1,
  47                 .mask = BD71828_MASK_DVS_BUCK2_CTRL,
  48                 .val = BD71828_DVS_BUCK2_CTRL_I2C,
  49         },
  50 };
  51
  52 static const struct reg_init buck6_inits[] = {
  53         {
  54                 .reg = BD71828_REG_PS_CTRL_1,
  55                 .mask = BD71828_MASK_DVS_BUCK6_CTRL,
  56                 .val = BD71828_DVS_BUCK6_CTRL_I2C,
  57         },
  58 };
  59
  60 static const struct reg_init buck7_inits[] = {
  61         {
  62                 .reg = BD71828_REG_PS_CTRL_1,
  63                 .mask = BD71828_MASK_DVS_BUCK7_CTRL,
  64                 .val = BD71828_DVS_BUCK7_CTRL_I2C,
  65         },
  66 };
  67
  68 static const struct linear_range bd71828_buck1267_volts[] = {
  69         REGULATOR_LINEAR_RANGE(500000, 0x00, 0xef, 6250),
  70         REGULATOR_LINEAR_RANGE(2000000, 0xf0, 0xff, 0),
  71 };
  72
  73 static const struct linear_range bd71828_buck3_volts[] = {
  74         REGULATOR_LINEAR_RANGE(1200000, 0x00, 0x0f, 50000),
  75         REGULATOR_LINEAR_RANGE(2000000, 0x10, 0x1f, 0),
  76 };
  77
  78 static const struct linear_range bd71828_buck4_volts[] = {
  79         REGULATOR_LINEAR_RANGE(1000000, 0x00, 0x1f, 25000),
  80         REGULATOR_LINEAR_RANGE(1800000, 0x20, 0x3f, 0),
  81 };
  82
  83 static const struct linear_range bd71828_buck5_volts[] = {
  84         REGULATOR_LINEAR_RANGE(2500000, 0x00, 0x0f, 50000),
  85         REGULATOR_LINEAR_RANGE(3300000, 0x10, 0x1f, 0),
  86 };
  87
  88 static const struct linear_range bd71828_ldo_volts[] = {
  89         REGULATOR_LINEAR_RANGE(800000, 0x00, 0x31, 50000),
  90         REGULATOR_LINEAR_RANGE(3300000, 0x32, 0x3f, 0),
  91 };
  92
  93 static int bd71828_set_ramp_delay(struct regulator_dev *rdev, int ramp_delay)
  94 {
  95         unsigned int val;
  96
  97         switch (ramp_delay) {
  98         case 1 ... 2500:
  99                 val = 0;
 100                 break;
 101         case 2501 ... 5000:
 102                 val = 1;
 103                 break;
 104         case 5001 ... 10000:
 105                 val = 2;
 106                 break;
 107         case 10001 ... 20000:
 108                 val = 3;
 109                 break;
 110         default:
 111                 val = 3;
 112                 dev_err(&rdev->dev,
 113                         "ramp_delay: %d not supported, setting 20mV/uS",
 114                          ramp_delay);
 115         }
 116
 117         /*
 118          * On BD71828 the ramp delay level control reg is at offset +2 to
 119          * enable reg
 120          */
 121         return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg + 2,
 122                                   BD71828_MASK_RAMP_DELAY,
 123                                   val << (ffs(BD71828_MASK_RAMP_DELAY) - 1));
 124 }
 125
 126 static int buck_set_hw_dvs_levels(struct device_node *np,
 127                                   const struct regulator_desc *desc,
 128                                   struct regulator_config *cfg)
 129 {
 130         struct bd71828_regulator_data *data;
 131
 132         data = container_of(desc, struct bd71828_regulator_data, desc);
 133
 134         return rohm_regulator_set_dvs_levels(&data->dvs, np, desc, cfg->regmap);
 135 }
 136
 137 static int ldo6_parse_dt(struct device_node *np,
 138                          const struct regulator_desc *desc,
 139                          struct regulator_config *cfg)
 140 {
 141         int ret, i;
 142         uint32_t uv = 0;
 143         unsigned int en;
 144         struct regmap *regmap = cfg->regmap;
 145         static const char * const props[] = { "rohm,dvs-run-voltage",
 146                                               "rohm,dvs-idle-voltage",
 147                                               "rohm,dvs-suspend-voltage",
 148                                               "rohm,dvs-lpsr-voltage" };
 149         unsigned int mask[] = { BD71828_MASK_RUN_EN, BD71828_MASK_IDLE_EN,
 150                                BD71828_MASK_SUSP_EN, BD71828_MASK_LPSR_EN };
 151
 152         for (i = 0; i < ARRAY_SIZE(props); i++) {
 153                 ret = of_property_read_u32(np, props[i], &uv);
 154                 if (ret) {
 155                         if (ret != -EINVAL)
 156                                 return ret;
 157                         continue;
 158                 }
 159                 if (uv)
 160                         en = 0xffffffff;
 161                 else
 162                         en = 0;
 163
 164                 ret = regmap_update_bits(regmap, desc->enable_reg, mask[i], en);
 165                 if (ret)
 166                         return ret;
 167         }
 168         return 0;
 169 }
 170
 171 static const struct regulator_ops bd71828_buck_ops = {
 172         .enable = regulator_enable_regmap,
 173         .disable = regulator_disable_regmap,
 174         .is_enabled = regulator_is_enabled_regmap,
 175         .list_voltage = regulator_list_voltage_linear_range,
 176         .set_voltage_sel = regulator_set_voltage_sel_regmap,
 177         .get_voltage_sel = regulator_get_voltage_sel_regmap,
 178 };
 179
 180 static const struct regulator_ops bd71828_dvs_buck_ops = {
 181         .enable = regulator_enable_regmap,
 182         .disable = regulator_disable_regmap,
 183         .is_enabled = regulator_is_enabled_regmap,
 184         .list_voltage = regulator_list_voltage_linear_range,
 185         .set_voltage_sel = regulator_set_voltage_sel_regmap,
 186         .get_voltage_sel = regulator_get_voltage_sel_regmap,
 187         .set_voltage_time_sel = regulator_set_voltage_time_sel,
 188         .set_ramp_delay = bd71828_set_ramp_delay,
 189 };
 190
 191 static const struct regulator_ops bd71828_ldo_ops = {
 192         .enable = regulator_enable_regmap,
 193         .disable = regulator_disable_regmap,
 194         .is_enabled = regulator_is_enabled_regmap,
 195         .list_voltage = regulator_list_voltage_linear_range,
 196         .set_voltage_sel = regulator_set_voltage_sel_regmap,
 197         .get_voltage_sel = regulator_get_voltage_sel_regmap,
 198 };
 199
 200 static const struct regulator_ops bd71828_ldo6_ops = {
 201         .enable = regulator_enable_regmap,
 202         .disable = regulator_disable_regmap,
 203         .is_enabled = regulator_is_enabled_regmap,
 204 };
 205
 206 static const struct bd71828_regulator_data bd71828_rdata[] = {
 207         {
 208                 .desc = {
 209                         .name = "buck1",
 210                         .of_match = of_match_ptr("BUCK1"),
 211                         .regulators_node = of_match_ptr("regulators"),
 212                         .id = BD71828_BUCK1,
 213                         .ops = &bd71828_dvs_buck_ops,
 214                         .type = REGULATOR_VOLTAGE,
 215                         .linear_ranges = bd71828_buck1267_volts,
 216                         .n_linear_ranges = ARRAY_SIZE(bd71828_buck1267_volts),
 217                         .n_voltages = BD71828_BUCK1267_VOLTS,
 218                         .enable_reg = BD71828_REG_BUCK1_EN,
 219                         .enable_mask = BD71828_MASK_RUN_EN,
 220                         .vsel_reg = BD71828_REG_BUCK1_VOLT,
 221                         .vsel_mask = BD71828_MASK_BUCK1267_VOLT,
 222                         .owner = THIS_MODULE,
 223                         .of_parse_cb = buck_set_hw_dvs_levels,
 224                 },
 225                 .dvs = {
 226                         .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
 227                                      ROHM_DVS_LEVEL_SUSPEND |
 228                                      ROHM_DVS_LEVEL_LPSR,
 229                         .run_reg = BD71828_REG_BUCK1_VOLT,
 230                         .run_mask = BD71828_MASK_BUCK1267_VOLT,
 231                         .idle_reg = BD71828_REG_BUCK1_IDLE_VOLT,
 232                         .idle_mask = BD71828_MASK_BUCK1267_VOLT,
 233                         .idle_on_mask = BD71828_MASK_IDLE_EN,
 234                         .suspend_reg = BD71828_REG_BUCK1_SUSP_VOLT,
 235                         .suspend_mask = BD71828_MASK_BUCK1267_VOLT,
 236                         .suspend_on_mask = BD71828_MASK_SUSP_EN,
 237                         .lpsr_on_mask = BD71828_MASK_LPSR_EN,
 238                         /*
 239                          * LPSR voltage is same as SUSPEND voltage. Allow
 240                          * setting it so that regulator can be set enabled at
 241                          * LPSR state
 242                          */
 243                         .lpsr_reg = BD71828_REG_BUCK1_SUSP_VOLT,
 244                         .lpsr_mask = BD71828_MASK_BUCK1267_VOLT,
 245                 },
 246                 .reg_inits = buck1_inits,
 247                 .reg_init_amnt = ARRAY_SIZE(buck1_inits),
 248         },
 249         {
 250                 .desc = {
 251                         .name = "buck2",
 252                         .of_match = of_match_ptr("BUCK2"),
 253                         .regulators_node = of_match_ptr("regulators"),
 254                         .id = BD71828_BUCK2,
 255                         .ops = &bd71828_dvs_buck_ops,
 256                         .type = REGULATOR_VOLTAGE,
 257                         .linear_ranges = bd71828_buck1267_volts,
 258                         .n_linear_ranges = ARRAY_SIZE(bd71828_buck1267_volts),
 259                         .n_voltages = BD71828_BUCK1267_VOLTS,
 260                         .enable_reg = BD71828_REG_BUCK2_EN,
 261                         .enable_mask = BD71828_MASK_RUN_EN,
 262                         .vsel_reg = BD71828_REG_BUCK2_VOLT,
 263                         .vsel_mask = BD71828_MASK_BUCK1267_VOLT,
 264                         .owner = THIS_MODULE,
 265                         .of_parse_cb = buck_set_hw_dvs_levels,
 266                 },
 267                 .dvs = {
 268                         .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
 269                                      ROHM_DVS_LEVEL_SUSPEND |
 270                                      ROHM_DVS_LEVEL_LPSR,
 271                         .run_reg = BD71828_REG_BUCK2_VOLT,
 272                         .run_mask = BD71828_MASK_BUCK1267_VOLT,
 273                         .idle_reg = BD71828_REG_BUCK2_IDLE_VOLT,
 274                         .idle_mask = BD71828_MASK_BUCK1267_VOLT,
 275                         .idle_on_mask = BD71828_MASK_IDLE_EN,
 276                         .suspend_reg = BD71828_REG_BUCK2_SUSP_VOLT,
 277                         .suspend_mask = BD71828_MASK_BUCK1267_VOLT,
 278                         .suspend_on_mask = BD71828_MASK_SUSP_EN,
 279                         .lpsr_on_mask = BD71828_MASK_LPSR_EN,
 280                         .lpsr_reg = BD71828_REG_BUCK2_SUSP_VOLT,
 281                         .lpsr_mask = BD71828_MASK_BUCK1267_VOLT,
 282                 },
 283                 .reg_inits = buck2_inits,
 284                 .reg_init_amnt = ARRAY_SIZE(buck2_inits),
 285         },
 286         {
 287                 .desc = {
 288                         .name = "buck3",
 289                         .of_match = of_match_ptr("BUCK3"),
 290                         .regulators_node = of_match_ptr("regulators"),
 291                         .id = BD71828_BUCK3,
 292                         .ops = &bd71828_buck_ops,
 293                         .type = REGULATOR_VOLTAGE,
 294                         .linear_ranges = bd71828_buck3_volts,
 295                         .n_linear_ranges = ARRAY_SIZE(bd71828_buck3_volts),
 296                         .n_voltages = BD71828_BUCK3_VOLTS,
 297                         .enable_reg = BD71828_REG_BUCK3_EN,
 298                         .enable_mask = BD71828_MASK_RUN_EN,
 299                         .vsel_reg = BD71828_REG_BUCK3_VOLT,
 300                         .vsel_mask = BD71828_MASK_BUCK3_VOLT,
 301                         .owner = THIS_MODULE,
 302                         .of_parse_cb = buck_set_hw_dvs_levels,
 303                 },
 304                 .dvs = {
 305                         /*
 306                          * BUCK3 only supports single voltage for all states.
 307                          * voltage can be individually enabled for each state
 308                          * though => allow setting all states to support
 309                          * enabling power rail on different states.
 310                          */
 311                         .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
 312                                      ROHM_DVS_LEVEL_SUSPEND |
 313                                      ROHM_DVS_LEVEL_LPSR,
 314                         .run_reg = BD71828_REG_BUCK3_VOLT,
 315                         .idle_reg = BD71828_REG_BUCK3_VOLT,
 316                         .suspend_reg = BD71828_REG_BUCK3_VOLT,
 317                         .lpsr_reg = BD71828_REG_BUCK3_VOLT,
 318                         .run_mask = BD71828_MASK_BUCK3_VOLT,
 319                         .idle_mask = BD71828_MASK_BUCK3_VOLT,
 320                         .suspend_mask = BD71828_MASK_BUCK3_VOLT,
 321                         .lpsr_mask = BD71828_MASK_BUCK3_VOLT,
 322                         .idle_on_mask = BD71828_MASK_IDLE_EN,
 323                         .suspend_on_mask = BD71828_MASK_SUSP_EN,
 324                         .lpsr_on_mask = BD71828_MASK_LPSR_EN,
 325                 },
 326         },
 327         {
 328                 .desc = {
 329                         .name = "buck4",
 330                         .of_match = of_match_ptr("BUCK4"),
 331                         .regulators_node = of_match_ptr("regulators"),
 332                         .id = BD71828_BUCK4,
 333                         .ops = &bd71828_buck_ops,
 334                         .type = REGULATOR_VOLTAGE,
 335                         .linear_ranges = bd71828_buck4_volts,
 336                         .n_linear_ranges = ARRAY_SIZE(bd71828_buck4_volts),
 337                         .n_voltages = BD71828_BUCK4_VOLTS,
 338                         .enable_reg = BD71828_REG_BUCK4_EN,
 339                         .enable_mask = BD71828_MASK_RUN_EN,
 340                         .vsel_reg = BD71828_REG_BUCK4_VOLT,
 341                         .vsel_mask = BD71828_MASK_BUCK4_VOLT,
 342                         .owner = THIS_MODULE,
 343                         .of_parse_cb = buck_set_hw_dvs_levels,
 344                 },
 345                 .dvs = {
 346                         /*
 347                          * BUCK4 only supports single voltage for all states.
 348                          * voltage can be individually enabled for each state
 349                          * though => allow setting all states to support
 350                          * enabling power rail on different states.
 351                          */
 352                         .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
 353                                      ROHM_DVS_LEVEL_SUSPEND |
 354                                      ROHM_DVS_LEVEL_LPSR,
 355                         .run_reg = BD71828_REG_BUCK4_VOLT,
 356                         .idle_reg = BD71828_REG_BUCK4_VOLT,
 357                         .suspend_reg = BD71828_REG_BUCK4_VOLT,
 358                         .lpsr_reg = BD71828_REG_BUCK4_VOLT,
 359                         .run_mask = BD71828_MASK_BUCK4_VOLT,
 360                         .idle_mask = BD71828_MASK_BUCK4_VOLT,
 361                         .suspend_mask = BD71828_MASK_BUCK4_VOLT,
 362                         .lpsr_mask = BD71828_MASK_BUCK4_VOLT,
 363                         .idle_on_mask = BD71828_MASK_IDLE_EN,
 364                         .suspend_on_mask = BD71828_MASK_SUSP_EN,
 365                         .lpsr_on_mask = BD71828_MASK_LPSR_EN,
 366                 },
 367         },
 368         {
 369                 .desc = {
 370                         .name = "buck5",
 371                         .of_match = of_match_ptr("BUCK5"),
 372                         .regulators_node = of_match_ptr("regulators"),
 373                         .id = BD71828_BUCK5,
 374                         .ops = &bd71828_buck_ops,
 375                         .type = REGULATOR_VOLTAGE,
 376                         .linear_ranges = bd71828_buck5_volts,
 377                         .n_linear_ranges = ARRAY_SIZE(bd71828_buck5_volts),
 378                         .n_voltages = BD71828_BUCK5_VOLTS,
 379                         .enable_reg = BD71828_REG_BUCK5_EN,
 380                         .enable_mask = BD71828_MASK_RUN_EN,
 381                         .vsel_reg = BD71828_REG_BUCK5_VOLT,
 382                         .vsel_mask = BD71828_MASK_BUCK5_VOLT,
 383                         .owner = THIS_MODULE,
 384                         .of_parse_cb = buck_set_hw_dvs_levels,
 385                 },
 386                 .dvs = {
 387                         /*
 388                          * BUCK5 only supports single voltage for all states.
 389                          * voltage can be individually enabled for each state
 390                          * though => allow setting all states to support
 391                          * enabling power rail on different states.
 392                          */
 393                         .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
 394                                      ROHM_DVS_LEVEL_SUSPEND |
 395                                      ROHM_DVS_LEVEL_LPSR,
 396                         .run_reg = BD71828_REG_BUCK5_VOLT,
 397                         .idle_reg = BD71828_REG_BUCK5_VOLT,
 398                         .suspend_reg = BD71828_REG_BUCK5_VOLT,
 399                         .lpsr_reg = BD71828_REG_BUCK5_VOLT,
 400                         .run_mask = BD71828_MASK_BUCK5_VOLT,
 401                         .idle_mask = BD71828_MASK_BUCK5_VOLT,
 402                         .suspend_mask = BD71828_MASK_BUCK5_VOLT,
 403                         .lpsr_mask = BD71828_MASK_BUCK5_VOLT,
 404                         .idle_on_mask = BD71828_MASK_IDLE_EN,
 405                         .suspend_on_mask = BD71828_MASK_SUSP_EN,
 406                         .lpsr_on_mask = BD71828_MASK_LPSR_EN,
 407                 },
 408         },
 409         {
 410                 .desc = {
 411                         .name = "buck6",
 412                         .of_match = of_match_ptr("BUCK6"),
 413                         .regulators_node = of_match_ptr("regulators"),
 414                         .id = BD71828_BUCK6,
 415                         .ops = &bd71828_dvs_buck_ops,
 416                         .type = REGULATOR_VOLTAGE,
 417                         .linear_ranges = bd71828_buck1267_volts,
 418                         .n_linear_ranges = ARRAY_SIZE(bd71828_buck1267_volts),
 419                         .n_voltages = BD71828_BUCK1267_VOLTS,
 420                         .enable_reg = BD71828_REG_BUCK6_EN,
 421                         .enable_mask = BD71828_MASK_RUN_EN,
 422                         .vsel_reg = BD71828_REG_BUCK6_VOLT,
 423                         .vsel_mask = BD71828_MASK_BUCK1267_VOLT,
 424                         .owner = THIS_MODULE,
 425                         .of_parse_cb = buck_set_hw_dvs_levels,
 426                 },
 427                 .dvs = {
 428                         .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
 429                                      ROHM_DVS_LEVEL_SUSPEND |
 430                                      ROHM_DVS_LEVEL_LPSR,
 431                         .run_reg = BD71828_REG_BUCK6_VOLT,
 432                         .run_mask = BD71828_MASK_BUCK1267_VOLT,
 433                         .idle_reg = BD71828_REG_BUCK6_IDLE_VOLT,
 434                         .idle_mask = BD71828_MASK_BUCK1267_VOLT,
 435                         .idle_on_mask = BD71828_MASK_IDLE_EN,
 436                         .suspend_reg = BD71828_REG_BUCK6_SUSP_VOLT,
 437                         .suspend_mask = BD71828_MASK_BUCK1267_VOLT,
 438                         .suspend_on_mask = BD71828_MASK_SUSP_EN,
 439                         .lpsr_on_mask = BD71828_MASK_LPSR_EN,
 440                         .lpsr_reg = BD71828_REG_BUCK6_SUSP_VOLT,
 441                         .lpsr_mask = BD71828_MASK_BUCK1267_VOLT,
 442                 },
 443                 .reg_inits = buck6_inits,
 444                 .reg_init_amnt = ARRAY_SIZE(buck6_inits),
 445         },
 446         {
 447                 .desc = {
 448                         .name = "buck7",
 449                         .of_match = of_match_ptr("BUCK7"),
 450                         .regulators_node = of_match_ptr("regulators"),
 451                         .id = BD71828_BUCK7,
 452                         .ops = &bd71828_dvs_buck_ops,
 453                         .type = REGULATOR_VOLTAGE,
 454                         .linear_ranges = bd71828_buck1267_volts,
 455                         .n_linear_ranges = ARRAY_SIZE(bd71828_buck1267_volts),
 456                         .n_voltages = BD71828_BUCK1267_VOLTS,
 457                         .enable_reg = BD71828_REG_BUCK7_EN,
 458                         .enable_mask = BD71828_MASK_RUN_EN,
 459                         .vsel_reg = BD71828_REG_BUCK7_VOLT,
 460                         .vsel_mask = BD71828_MASK_BUCK1267_VOLT,
 461                         .owner = THIS_MODULE,
 462                         .of_parse_cb = buck_set_hw_dvs_levels,
 463                 },
 464                 .dvs = {
 465                         .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
 466                                      ROHM_DVS_LEVEL_SUSPEND |
 467                                      ROHM_DVS_LEVEL_LPSR,
 468                         .run_reg = BD71828_REG_BUCK7_VOLT,
 469                         .run_mask = BD71828_MASK_BUCK1267_VOLT,
 470                         .idle_reg = BD71828_REG_BUCK7_IDLE_VOLT,
 471                         .idle_mask = BD71828_MASK_BUCK1267_VOLT,
 472                         .idle_on_mask = BD71828_MASK_IDLE_EN,
 473                         .suspend_reg = BD71828_REG_BUCK7_SUSP_VOLT,
 474                         .suspend_mask = BD71828_MASK_BUCK1267_VOLT,
 475                         .suspend_on_mask = BD71828_MASK_SUSP_EN,
 476                         .lpsr_on_mask = BD71828_MASK_LPSR_EN,
 477                         .lpsr_reg = BD71828_REG_BUCK7_SUSP_VOLT,
 478                         .lpsr_mask = BD71828_MASK_BUCK1267_VOLT,
 479                 },
 480                 .reg_inits = buck7_inits,
 481                 .reg_init_amnt = ARRAY_SIZE(buck7_inits),
 482         },
 483         {
 484                 .desc = {
 485                         .name = "ldo1",
 486                         .of_match = of_match_ptr("LDO1"),
 487                         .regulators_node = of_match_ptr("regulators"),
 488                         .id = BD71828_LDO1,
 489                         .ops = &bd71828_ldo_ops,
 490                         .type = REGULATOR_VOLTAGE,
 491                         .linear_ranges = bd71828_ldo_volts,
 492                         .n_linear_ranges = ARRAY_SIZE(bd71828_ldo_volts),
 493                         .n_voltages = BD71828_LDO_VOLTS,
 494                         .enable_reg = BD71828_REG_LDO1_EN,
 495                         .enable_mask = BD71828_MASK_RUN_EN,
 496                         .vsel_reg = BD71828_REG_LDO1_VOLT,
 497                         .vsel_mask = BD71828_MASK_LDO_VOLT,
 498                         .owner = THIS_MODULE,
 499                         .of_parse_cb = buck_set_hw_dvs_levels,
 500                 },
 501                 .dvs = {
 502                         /*
 503                          * LDO1 only supports single voltage for all states.
 504                          * voltage can be individually enabled for each state
 505                          * though => allow setting all states to support
 506                          * enabling power rail on different states.
 507                          */
 508                         .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
 509                                      ROHM_DVS_LEVEL_SUSPEND |
 510                                      ROHM_DVS_LEVEL_LPSR,
 511                         .run_reg = BD71828_REG_LDO1_VOLT,
 512                         .idle_reg = BD71828_REG_LDO1_VOLT,
 513                         .suspend_reg = BD71828_REG_LDO1_VOLT,
 514                         .lpsr_reg = BD71828_REG_LDO1_VOLT,
 515                         .run_mask = BD71828_MASK_LDO_VOLT,
 516                         .idle_mask = BD71828_MASK_LDO_VOLT,
 517                         .suspend_mask = BD71828_MASK_LDO_VOLT,
 518                         .lpsr_mask = BD71828_MASK_LDO_VOLT,
 519                         .idle_on_mask = BD71828_MASK_IDLE_EN,
 520                         .suspend_on_mask = BD71828_MASK_SUSP_EN,
 521                         .lpsr_on_mask = BD71828_MASK_LPSR_EN,
 522                 },
 523         }, {
 524                 .desc = {
 525                         .name = "ldo2",
 526                         .of_match = of_match_ptr("LDO2"),
 527                         .regulators_node = of_match_ptr("regulators"),
 528                         .id = BD71828_LDO2,
 529                         .ops = &bd71828_ldo_ops,
 530                         .type = REGULATOR_VOLTAGE,
 531                         .linear_ranges = bd71828_ldo_volts,
 532                         .n_linear_ranges = ARRAY_SIZE(bd71828_ldo_volts),
 533                         .n_voltages = BD71828_LDO_VOLTS,
 534                         .enable_reg = BD71828_REG_LDO2_EN,
 535                         .enable_mask = BD71828_MASK_RUN_EN,
 536                         .vsel_reg = BD71828_REG_LDO2_VOLT,
 537                         .vsel_mask = BD71828_MASK_LDO_VOLT,
 538                         .owner = THIS_MODULE,
 539                         .of_parse_cb = buck_set_hw_dvs_levels,
 540                 },
 541                 .dvs = {
 542                         /*
 543                          * LDO2 only supports single voltage for all states.
 544                          * voltage can be individually enabled for each state
 545                          * though => allow setting all states to support
 546                          * enabling power rail on different states.
 547                          */
 548                         .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
 549                                      ROHM_DVS_LEVEL_SUSPEND |
 550                                      ROHM_DVS_LEVEL_LPSR,
 551                         .run_reg = BD71828_REG_LDO2_VOLT,
 552                         .idle_reg = BD71828_REG_LDO2_VOLT,
 553                         .suspend_reg = BD71828_REG_LDO2_VOLT,
 554                         .lpsr_reg = BD71828_REG_LDO2_VOLT,
 555                         .run_mask = BD71828_MASK_LDO_VOLT,
 556                         .idle_mask = BD71828_MASK_LDO_VOLT,
 557                         .suspend_mask = BD71828_MASK_LDO_VOLT,
 558                         .lpsr_mask = BD71828_MASK_LDO_VOLT,
 559                         .idle_on_mask = BD71828_MASK_IDLE_EN,
 560                         .suspend_on_mask = BD71828_MASK_SUSP_EN,
 561                         .lpsr_on_mask = BD71828_MASK_LPSR_EN,
 562                 },
 563         }, {
 564                 .desc = {
 565                         .name = "ldo3",
 566                         .of_match = of_match_ptr("LDO3"),
 567                         .regulators_node = of_match_ptr("regulators"),
 568                         .id = BD71828_LDO3,
 569                         .ops = &bd71828_ldo_ops,
 570                         .type = REGULATOR_VOLTAGE,
 571                         .linear_ranges = bd71828_ldo_volts,
 572                         .n_linear_ranges = ARRAY_SIZE(bd71828_ldo_volts),
 573                         .n_voltages = BD71828_LDO_VOLTS,
 574                         .enable_reg = BD71828_REG_LDO3_EN,
 575                         .enable_mask = BD71828_MASK_RUN_EN,
 576                         .vsel_reg = BD71828_REG_LDO3_VOLT,
 577                         .vsel_mask = BD71828_MASK_LDO_VOLT,
 578                         .owner = THIS_MODULE,
 579                         .of_parse_cb = buck_set_hw_dvs_levels,
 580                 },
 581                 .dvs = {
 582                         /*
 583                          * LDO3 only supports single voltage for all states.
 584                          * voltage can be individually enabled for each state
 585                          * though => allow setting all states to support
 586                          * enabling power rail on different states.
 587                          */
 588                         .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
 589                                      ROHM_DVS_LEVEL_SUSPEND |
 590                                      ROHM_DVS_LEVEL_LPSR,
 591                         .run_reg = BD71828_REG_LDO3_VOLT,
 592                         .idle_reg = BD71828_REG_LDO3_VOLT,
 593                         .suspend_reg = BD71828_REG_LDO3_VOLT,
 594                         .lpsr_reg = BD71828_REG_LDO3_VOLT,
 595                         .run_mask = BD71828_MASK_LDO_VOLT,
 596                         .idle_mask = BD71828_MASK_LDO_VOLT,
 597                         .suspend_mask = BD71828_MASK_LDO_VOLT,
 598                         .lpsr_mask = BD71828_MASK_LDO_VOLT,
 599                         .idle_on_mask = BD71828_MASK_IDLE_EN,
 600                         .suspend_on_mask = BD71828_MASK_SUSP_EN,
 601                         .lpsr_on_mask = BD71828_MASK_LPSR_EN,
 602                 },
 603
 604         }, {
 605                 .desc = {
 606                         .name = "ldo4",
 607                         .of_match = of_match_ptr("LDO4"),
 608                         .regulators_node = of_match_ptr("regulators"),
 609                         .id = BD71828_LDO4,
 610                         .ops = &bd71828_ldo_ops,
 611                         .type = REGULATOR_VOLTAGE,
 612                         .linear_ranges = bd71828_ldo_volts,
 613                         .n_linear_ranges = ARRAY_SIZE(bd71828_ldo_volts),
 614                         .n_voltages = BD71828_LDO_VOLTS,
 615                         .enable_reg = BD71828_REG_LDO4_EN,
 616                         .enable_mask = BD71828_MASK_RUN_EN,
 617                         .vsel_reg = BD71828_REG_LDO4_VOLT,
 618                         .vsel_mask = BD71828_MASK_LDO_VOLT,
 619                         .owner = THIS_MODULE,
 620                         .of_parse_cb = buck_set_hw_dvs_levels,
 621                 },
 622                 .dvs = {
 623                         /*
 624                          * LDO1 only supports single voltage for all states.
 625                          * voltage can be individually enabled for each state
 626                          * though => allow setting all states to support
 627                          * enabling power rail on different states.
 628                          */
 629                         .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
 630                                      ROHM_DVS_LEVEL_SUSPEND |
 631                                      ROHM_DVS_LEVEL_LPSR,
 632                         .run_reg = BD71828_REG_LDO4_VOLT,
 633                         .idle_reg = BD71828_REG_LDO4_VOLT,
 634                         .suspend_reg = BD71828_REG_LDO4_VOLT,
 635                         .lpsr_reg = BD71828_REG_LDO4_VOLT,
 636                         .run_mask = BD71828_MASK_LDO_VOLT,
 637                         .idle_mask = BD71828_MASK_LDO_VOLT,
 638                         .suspend_mask = BD71828_MASK_LDO_VOLT,
 639                         .lpsr_mask = BD71828_MASK_LDO_VOLT,
 640                         .idle_on_mask = BD71828_MASK_IDLE_EN,
 641                         .suspend_on_mask = BD71828_MASK_SUSP_EN,
 642                         .lpsr_on_mask = BD71828_MASK_LPSR_EN,
 643                 },
 644         }, {
 645                 .desc = {
 646                         .name = "ldo5",
 647                         .of_match = of_match_ptr("LDO5"),
 648                         .regulators_node = of_match_ptr("regulators"),
 649                         .id = BD71828_LDO5,
 650                         .ops = &bd71828_ldo_ops,
 651                         .type = REGULATOR_VOLTAGE,
 652                         .linear_ranges = bd71828_ldo_volts,
 653                         .n_linear_ranges = ARRAY_SIZE(bd71828_ldo_volts),
 654                         .n_voltages = BD71828_LDO_VOLTS,
 655                         .enable_reg = BD71828_REG_LDO5_EN,
 656                         .enable_mask = BD71828_MASK_RUN_EN,
 657                         .vsel_reg = BD71828_REG_LDO5_VOLT,
 658                         .vsel_mask = BD71828_MASK_LDO_VOLT,
 659                         .of_parse_cb = buck_set_hw_dvs_levels,
 660                         .owner = THIS_MODULE,
 661                 },
 662                 /*
 663                  * LDO5 is special. It can choose vsel settings to be configured
 664                  * from 2 different registers (by GPIO).
 665                  *
 666                  * This driver supports only configuration where
 667                  * BD71828_REG_LDO5_VOLT_L is used.
 668                  */
 669                 .dvs = {
 670                         .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
 671                                      ROHM_DVS_LEVEL_SUSPEND |
 672                                      ROHM_DVS_LEVEL_LPSR,
 673                         .run_reg = BD71828_REG_LDO5_VOLT,
 674                         .idle_reg = BD71828_REG_LDO5_VOLT,
 675                         .suspend_reg = BD71828_REG_LDO5_VOLT,
 676                         .lpsr_reg = BD71828_REG_LDO5_VOLT,
 677                         .run_mask = BD71828_MASK_LDO_VOLT,
 678                         .idle_mask = BD71828_MASK_LDO_VOLT,
 679                         .suspend_mask = BD71828_MASK_LDO_VOLT,
 680                         .lpsr_mask = BD71828_MASK_LDO_VOLT,
 681                         .idle_on_mask = BD71828_MASK_IDLE_EN,
 682                         .suspend_on_mask = BD71828_MASK_SUSP_EN,
 683                         .lpsr_on_mask = BD71828_MASK_LPSR_EN,
 684                 },
 685
 686         }, {
 687                 .desc = {
 688                         .name = "ldo6",
 689                         .of_match = of_match_ptr("LDO6"),
 690                         .regulators_node = of_match_ptr("regulators"),
 691                         .id = BD71828_LDO6,
 692                         .ops = &bd71828_ldo6_ops,
 693                         .type = REGULATOR_VOLTAGE,
 694                         .fixed_uV = BD71828_LDO_6_VOLTAGE,
 695                         .n_voltages = 1,
 696                         .enable_reg = BD71828_REG_LDO6_EN,
 697                         .enable_mask = BD71828_MASK_RUN_EN,
 698                         .owner = THIS_MODULE,
 699                         /*
 700                          * LDO6 only supports enable/disable for all states.
 701                          * Voltage for LDO6 is fixed.
 702                          */
 703                         .of_parse_cb = ldo6_parse_dt,
 704                 },
 705         }, {
 706                 .desc = {
 707                         /* SNVS LDO in data-sheet */
 708                         .name = "ldo7",
 709                         .of_match = of_match_ptr("LDO7"),
 710                         .regulators_node = of_match_ptr("regulators"),
 711                         .id = BD71828_LDO_SNVS,
 712                         .ops = &bd71828_ldo_ops,
 713                         .type = REGULATOR_VOLTAGE,
 714                         .linear_ranges = bd71828_ldo_volts,
 715                         .n_linear_ranges = ARRAY_SIZE(bd71828_ldo_volts),
 716                         .n_voltages = BD71828_LDO_VOLTS,
 717                         .enable_reg = BD71828_REG_LDO7_EN,
 718                         .enable_mask = BD71828_MASK_RUN_EN,
 719                         .vsel_reg = BD71828_REG_LDO7_VOLT,
 720                         .vsel_mask = BD71828_MASK_LDO_VOLT,
 721                         .owner = THIS_MODULE,
 722                         .of_parse_cb = buck_set_hw_dvs_levels,
 723                 },
 724                 .dvs = {
 725                         /*
 726                          * LDO7 only supports single voltage for all states.
 727                          * voltage can be individually enabled for each state
 728                          * though => allow setting all states to support
 729                          * enabling power rail on different states.
 730                          */
 731                         .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
 732                                      ROHM_DVS_LEVEL_SUSPEND |
 733                                      ROHM_DVS_LEVEL_LPSR,
 734                         .run_reg = BD71828_REG_LDO7_VOLT,
 735                         .idle_reg = BD71828_REG_LDO7_VOLT,
 736                         .suspend_reg = BD71828_REG_LDO7_VOLT,
 737                         .lpsr_reg = BD71828_REG_LDO7_VOLT,
 738                         .run_mask = BD71828_MASK_LDO_VOLT,
 739                         .idle_mask = BD71828_MASK_LDO_VOLT,
 740                         .suspend_mask = BD71828_MASK_LDO_VOLT,
 741                         .lpsr_mask = BD71828_MASK_LDO_VOLT,
 742                         .idle_on_mask = BD71828_MASK_IDLE_EN,
 743                         .suspend_on_mask = BD71828_MASK_SUSP_EN,
 744                         .lpsr_on_mask = BD71828_MASK_LPSR_EN,
 745                 },
 746
 747         },
 748 };
 749
 750 static int bd71828_probe(struct platform_device *pdev)
 751 {
 752         struct rohm_regmap_dev *bd71828;
 753         int i, j, ret;
 754         struct regulator_config config = {
 755                 .dev = pdev->dev.parent,
 756         };
 757
 758         bd71828 = dev_get_drvdata(pdev->dev.parent);
 759         if (!bd71828) {
 760                 dev_err(&pdev->dev, "No MFD driver data\n");
 761                 return -EINVAL;
 762         }
 763
 764         config.regmap = bd71828->regmap;
 765
 766         for (i = 0; i < ARRAY_SIZE(bd71828_rdata); i++) {
 767                 struct regulator_dev *rdev;
 768                 const struct bd71828_regulator_data *rd;
 769
 770                 rd = &bd71828_rdata[i];
 771                 rdev = devm_regulator_register(&pdev->dev,
 772                                                &rd->desc, &config);
 773                 if (IS_ERR(rdev)) {
 774                         dev_err(&pdev->dev,
 775                                 "failed to register %s regulator\n",
 776                                 rd->desc.name);
 777                         return PTR_ERR(rdev);
 778                 }
 779                 for (j = 0; j < rd->reg_init_amnt; j++) {
 780                         ret = regmap_update_bits(bd71828->regmap,
 781                                                  rd->reg_inits[j].reg,
 782                                                  rd->reg_inits[j].mask,
 783                                                  rd->reg_inits[j].val);
 784                         if (ret) {
 785                                 dev_err(&pdev->dev,
 786                                         "regulator %s init failed\n",
 787                                         rd->desc.name);
 788                                 return ret;
 789                         }
 790                 }
 791         }
 792         return 0;
 793 }
 794
 795 static struct platform_driver bd71828_regulator = {
 796         .driver = {
 797                 .name = "bd71828-pmic"
 798         },
 799         .probe = bd71828_probe,
 800 };
 801
 802 module_platform_driver(bd71828_regulator);
 803
 804 MODULE_AUTHOR("Matti Vaittinen <matti.vaittinen@fi.rohmeurope.com>");
 805 MODULE_DESCRIPTION("BD71828 voltage regulator driver");
 806 MODULE_LICENSE("GPL");
 807 MODULE_ALIAS("platform:bd71828-pmic");