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