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