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                         /*
 210                          * LPSR voltage is same as SUSPEND voltage. Allow
 211                          * only enabling/disabling regulator for LPSR state
 212                          */
 213                         .lpsr_on_mask = BD71828_MASK_LPSR_EN,
 214                 },
 215                 .reg_inits = buck1_inits,
 216                 .reg_init_amnt = ARRAY_SIZE(buck1_inits),
 217         },
 218         {
 219                 .desc = {
 220                         .name = "buck2",
 221                         .of_match = of_match_ptr("BUCK2"),
 222                         .regulators_node = of_match_ptr("regulators"),
 223                         .id = BD71828_BUCK2,
 224                         .ops = &bd71828_dvs_buck_ops,
 225                         .type = REGULATOR_VOLTAGE,
 226                         .linear_ranges = bd71828_buck1267_volts,
 227                         .n_linear_ranges = ARRAY_SIZE(bd71828_buck1267_volts),
 228                         .n_voltages = BD71828_BUCK1267_VOLTS,
 229                         .enable_reg = BD71828_REG_BUCK2_EN,
 230                         .enable_mask = BD71828_MASK_RUN_EN,
 231                         .vsel_reg = BD71828_REG_BUCK2_VOLT,
 232                         .vsel_mask = BD71828_MASK_BUCK1267_VOLT,
 233                         .ramp_delay_table = bd71828_ramp_delay,
 234                         .n_ramp_values = ARRAY_SIZE(bd71828_ramp_delay),
 235                         .ramp_reg = BD71828_REG_BUCK2_MODE,
 236                         .ramp_mask = BD71828_MASK_RAMP_DELAY,
 237                         .owner = THIS_MODULE,
 238                         .of_parse_cb = buck_set_hw_dvs_levels,
 239                 },
 240                 .dvs = {
 241                         .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
 242                                      ROHM_DVS_LEVEL_SUSPEND |
 243                                      ROHM_DVS_LEVEL_LPSR,
 244                         .run_reg = BD71828_REG_BUCK2_VOLT,
 245                         .run_mask = BD71828_MASK_BUCK1267_VOLT,
 246                         .idle_reg = BD71828_REG_BUCK2_IDLE_VOLT,
 247                         .idle_mask = BD71828_MASK_BUCK1267_VOLT,
 248                         .idle_on_mask = BD71828_MASK_IDLE_EN,
 249                         .suspend_reg = BD71828_REG_BUCK2_SUSP_VOLT,
 250                         .suspend_mask = BD71828_MASK_BUCK1267_VOLT,
 251                         .suspend_on_mask = BD71828_MASK_SUSP_EN,
 252                         .lpsr_on_mask = BD71828_MASK_LPSR_EN,
 253                         .lpsr_reg = BD71828_REG_BUCK2_SUSP_VOLT,
 254                         .lpsr_mask = BD71828_MASK_BUCK1267_VOLT,
 255                 },
 256                 .reg_inits = buck2_inits,
 257                 .reg_init_amnt = ARRAY_SIZE(buck2_inits),
 258         },
 259         {
 260                 .desc = {
 261                         .name = "buck3",
 262                         .of_match = of_match_ptr("BUCK3"),
 263                         .regulators_node = of_match_ptr("regulators"),
 264                         .id = BD71828_BUCK3,
 265                         .ops = &bd71828_buck_ops,
 266                         .type = REGULATOR_VOLTAGE,
 267                         .linear_ranges = bd71828_buck3_volts,
 268                         .n_linear_ranges = ARRAY_SIZE(bd71828_buck3_volts),
 269                         .n_voltages = BD71828_BUCK3_VOLTS,
 270                         .enable_reg = BD71828_REG_BUCK3_EN,
 271                         .enable_mask = BD71828_MASK_RUN_EN,
 272                         .vsel_reg = BD71828_REG_BUCK3_VOLT,
 273                         .vsel_mask = BD71828_MASK_BUCK3_VOLT,
 274                         .owner = THIS_MODULE,
 275                         .of_parse_cb = buck_set_hw_dvs_levels,
 276                 },
 277                 .dvs = {
 278                         /*
 279                          * BUCK3 only supports single voltage for all states.
 280                          * voltage can be individually enabled for each state
 281                          * though => allow setting all states to support
 282                          * enabling power rail on different states.
 283                          */
 284                         .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
 285                                      ROHM_DVS_LEVEL_SUSPEND |
 286                                      ROHM_DVS_LEVEL_LPSR,
 287                         .run_reg = BD71828_REG_BUCK3_VOLT,
 288                         .run_mask = BD71828_MASK_BUCK3_VOLT,
 289                         .idle_on_mask = BD71828_MASK_IDLE_EN,
 290                         .suspend_on_mask = BD71828_MASK_SUSP_EN,
 291                         .lpsr_on_mask = BD71828_MASK_LPSR_EN,
 292                 },
 293         },
 294         {
 295                 .desc = {
 296                         .name = "buck4",
 297                         .of_match = of_match_ptr("BUCK4"),
 298                         .regulators_node = of_match_ptr("regulators"),
 299                         .id = BD71828_BUCK4,
 300                         .ops = &bd71828_buck_ops,
 301                         .type = REGULATOR_VOLTAGE,
 302                         .linear_ranges = bd71828_buck4_volts,
 303                         .n_linear_ranges = ARRAY_SIZE(bd71828_buck4_volts),
 304                         .n_voltages = BD71828_BUCK4_VOLTS,
 305                         .enable_reg = BD71828_REG_BUCK4_EN,
 306                         .enable_mask = BD71828_MASK_RUN_EN,
 307                         .vsel_reg = BD71828_REG_BUCK4_VOLT,
 308                         .vsel_mask = BD71828_MASK_BUCK4_VOLT,
 309                         .owner = THIS_MODULE,
 310                         .of_parse_cb = buck_set_hw_dvs_levels,
 311                 },
 312                 .dvs = {
 313                         /*
 314                          * BUCK4 only supports single voltage for all states.
 315                          * voltage can be individually enabled for each state
 316                          * though => allow setting all states to support
 317                          * enabling power rail on different states.
 318                          */
 319                         .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
 320                                      ROHM_DVS_LEVEL_SUSPEND |
 321                                      ROHM_DVS_LEVEL_LPSR,
 322                         .run_reg = BD71828_REG_BUCK4_VOLT,
 323                         .run_mask = BD71828_MASK_BUCK4_VOLT,
 324                         .idle_on_mask = BD71828_MASK_IDLE_EN,
 325                         .suspend_on_mask = BD71828_MASK_SUSP_EN,
 326                         .lpsr_on_mask = BD71828_MASK_LPSR_EN,
 327                 },
 328         },
 329         {
 330                 .desc = {
 331                         .name = "buck5",
 332                         .of_match = of_match_ptr("BUCK5"),
 333                         .regulators_node = of_match_ptr("regulators"),
 334                         .id = BD71828_BUCK5,
 335                         .ops = &bd71828_buck_ops,
 336                         .type = REGULATOR_VOLTAGE,
 337                         .linear_ranges = bd71828_buck5_volts,
 338                         .n_linear_ranges = ARRAY_SIZE(bd71828_buck5_volts),
 339                         .n_voltages = BD71828_BUCK5_VOLTS,
 340                         .enable_reg = BD71828_REG_BUCK5_EN,
 341                         .enable_mask = BD71828_MASK_RUN_EN,
 342                         .vsel_reg = BD71828_REG_BUCK5_VOLT,
 343                         .vsel_mask = BD71828_MASK_BUCK5_VOLT,
 344                         .owner = THIS_MODULE,
 345                         .of_parse_cb = buck_set_hw_dvs_levels,
 346                 },
 347                 .dvs = {
 348                         /*
 349                          * BUCK5 only supports single voltage for all states.
 350                          * voltage can be individually enabled for each state
 351                          * though => allow setting all states to support
 352                          * enabling power rail on different states.
 353                          */
 354                         .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
 355                                      ROHM_DVS_LEVEL_SUSPEND |
 356                                      ROHM_DVS_LEVEL_LPSR,
 357                         .run_reg = BD71828_REG_BUCK5_VOLT,
 358                         .run_mask = BD71828_MASK_BUCK5_VOLT,
 359                         .idle_on_mask = BD71828_MASK_IDLE_EN,
 360                         .suspend_on_mask = BD71828_MASK_SUSP_EN,
 361                         .lpsr_on_mask = BD71828_MASK_LPSR_EN,
 362                 },
 363         },
 364         {
 365                 .desc = {
 366                         .name = "buck6",
 367                         .of_match = of_match_ptr("BUCK6"),
 368                         .regulators_node = of_match_ptr("regulators"),
 369                         .id = BD71828_BUCK6,
 370                         .ops = &bd71828_dvs_buck_ops,
 371                         .type = REGULATOR_VOLTAGE,
 372                         .linear_ranges = bd71828_buck1267_volts,
 373                         .n_linear_ranges = ARRAY_SIZE(bd71828_buck1267_volts),
 374                         .n_voltages = BD71828_BUCK1267_VOLTS,
 375                         .enable_reg = BD71828_REG_BUCK6_EN,
 376                         .enable_mask = BD71828_MASK_RUN_EN,
 377                         .vsel_reg = BD71828_REG_BUCK6_VOLT,
 378                         .vsel_mask = BD71828_MASK_BUCK1267_VOLT,
 379                         .ramp_delay_table = bd71828_ramp_delay,
 380                         .n_ramp_values = ARRAY_SIZE(bd71828_ramp_delay),
 381                         .ramp_reg = BD71828_REG_BUCK6_MODE,
 382                         .ramp_mask = BD71828_MASK_RAMP_DELAY,
 383                         .owner = THIS_MODULE,
 384                         .of_parse_cb = buck_set_hw_dvs_levels,
 385                 },
 386                 .dvs = {
 387                         .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
 388                                      ROHM_DVS_LEVEL_SUSPEND |
 389                                      ROHM_DVS_LEVEL_LPSR,
 390                         .run_reg = BD71828_REG_BUCK6_VOLT,
 391                         .run_mask = BD71828_MASK_BUCK1267_VOLT,
 392                         .idle_reg = BD71828_REG_BUCK6_IDLE_VOLT,
 393                         .idle_mask = BD71828_MASK_BUCK1267_VOLT,
 394                         .idle_on_mask = BD71828_MASK_IDLE_EN,
 395                         .suspend_reg = BD71828_REG_BUCK6_SUSP_VOLT,
 396                         .suspend_mask = BD71828_MASK_BUCK1267_VOLT,
 397                         .suspend_on_mask = BD71828_MASK_SUSP_EN,
 398                         .lpsr_on_mask = BD71828_MASK_LPSR_EN,
 399                         .lpsr_reg = BD71828_REG_BUCK6_SUSP_VOLT,
 400                         .lpsr_mask = BD71828_MASK_BUCK1267_VOLT,
 401                 },
 402                 .reg_inits = buck6_inits,
 403                 .reg_init_amnt = ARRAY_SIZE(buck6_inits),
 404         },
 405         {
 406                 .desc = {
 407                         .name = "buck7",
 408                         .of_match = of_match_ptr("BUCK7"),
 409                         .regulators_node = of_match_ptr("regulators"),
 410                         .id = BD71828_BUCK7,
 411                         .ops = &bd71828_dvs_buck_ops,
 412                         .type = REGULATOR_VOLTAGE,
 413                         .linear_ranges = bd71828_buck1267_volts,
 414                         .n_linear_ranges = ARRAY_SIZE(bd71828_buck1267_volts),
 415                         .n_voltages = BD71828_BUCK1267_VOLTS,
 416                         .enable_reg = BD71828_REG_BUCK7_EN,
 417                         .enable_mask = BD71828_MASK_RUN_EN,
 418                         .vsel_reg = BD71828_REG_BUCK7_VOLT,
 419                         .vsel_mask = BD71828_MASK_BUCK1267_VOLT,
 420                         .ramp_delay_table = bd71828_ramp_delay,
 421                         .n_ramp_values = ARRAY_SIZE(bd71828_ramp_delay),
 422                         .ramp_reg = BD71828_REG_BUCK7_MODE,
 423                         .ramp_mask = BD71828_MASK_RAMP_DELAY,
 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_BUCK7_VOLT,
 432                         .run_mask = BD71828_MASK_BUCK1267_VOLT,
 433                         .idle_reg = BD71828_REG_BUCK7_IDLE_VOLT,
 434                         .idle_mask = BD71828_MASK_BUCK1267_VOLT,
 435                         .idle_on_mask = BD71828_MASK_IDLE_EN,
 436                         .suspend_reg = BD71828_REG_BUCK7_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_BUCK7_SUSP_VOLT,
 441                         .lpsr_mask = BD71828_MASK_BUCK1267_VOLT,
 442                 },
 443                 .reg_inits = buck7_inits,
 444                 .reg_init_amnt = ARRAY_SIZE(buck7_inits),
 445         },
 446         {
 447                 .desc = {
 448                         .name = "ldo1",
 449                         .of_match = of_match_ptr("LDO1"),
 450                         .regulators_node = of_match_ptr("regulators"),
 451                         .id = BD71828_LDO1,
 452                         .ops = &bd71828_ldo_ops,
 453                         .type = REGULATOR_VOLTAGE,
 454                         .linear_ranges = bd71828_ldo_volts,
 455                         .n_linear_ranges = ARRAY_SIZE(bd71828_ldo_volts),
 456                         .n_voltages = BD71828_LDO_VOLTS,
 457                         .enable_reg = BD71828_REG_LDO1_EN,
 458                         .enable_mask = BD71828_MASK_RUN_EN,
 459                         .vsel_reg = BD71828_REG_LDO1_VOLT,
 460                         .vsel_mask = BD71828_MASK_LDO_VOLT,
 461                         .owner = THIS_MODULE,
 462                         .of_parse_cb = buck_set_hw_dvs_levels,
 463                 },
 464                 .dvs = {
 465                         /*
 466                          * LDO1 only supports single voltage for all states.
 467                          * voltage can be individually enabled for each state
 468                          * though => allow setting all states to support
 469                          * enabling power rail on different states.
 470                          */
 471                         .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
 472                                      ROHM_DVS_LEVEL_SUSPEND |
 473                                      ROHM_DVS_LEVEL_LPSR,
 474                         .run_reg = BD71828_REG_LDO1_VOLT,
 475                         .run_mask = BD71828_MASK_LDO_VOLT,
 476                         .idle_on_mask = BD71828_MASK_IDLE_EN,
 477                         .suspend_on_mask = BD71828_MASK_SUSP_EN,
 478                         .lpsr_on_mask = BD71828_MASK_LPSR_EN,
 479                 },
 480         }, {
 481                 .desc = {
 482                         .name = "ldo2",
 483                         .of_match = of_match_ptr("LDO2"),
 484                         .regulators_node = of_match_ptr("regulators"),
 485                         .id = BD71828_LDO2,
 486                         .ops = &bd71828_ldo_ops,
 487                         .type = REGULATOR_VOLTAGE,
 488                         .linear_ranges = bd71828_ldo_volts,
 489                         .n_linear_ranges = ARRAY_SIZE(bd71828_ldo_volts),
 490                         .n_voltages = BD71828_LDO_VOLTS,
 491                         .enable_reg = BD71828_REG_LDO2_EN,
 492                         .enable_mask = BD71828_MASK_RUN_EN,
 493                         .vsel_reg = BD71828_REG_LDO2_VOLT,
 494                         .vsel_mask = BD71828_MASK_LDO_VOLT,
 495                         .owner = THIS_MODULE,
 496                         .of_parse_cb = buck_set_hw_dvs_levels,
 497                 },
 498                 .dvs = {
 499                         /*
 500                          * LDO2 only supports single voltage for all states.
 501                          * voltage can be individually enabled for each state
 502                          * though => allow setting all states to support
 503                          * enabling power rail on different states.
 504                          */
 505                         .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
 506                                      ROHM_DVS_LEVEL_SUSPEND |
 507                                      ROHM_DVS_LEVEL_LPSR,
 508                         .run_reg = BD71828_REG_LDO2_VOLT,
 509                         .run_mask = BD71828_MASK_LDO_VOLT,
 510                         .idle_on_mask = BD71828_MASK_IDLE_EN,
 511                         .suspend_on_mask = BD71828_MASK_SUSP_EN,
 512                         .lpsr_on_mask = BD71828_MASK_LPSR_EN,
 513                 },
 514         }, {
 515                 .desc = {
 516                         .name = "ldo3",
 517                         .of_match = of_match_ptr("LDO3"),
 518                         .regulators_node = of_match_ptr("regulators"),
 519                         .id = BD71828_LDO3,
 520                         .ops = &bd71828_ldo_ops,
 521                         .type = REGULATOR_VOLTAGE,
 522                         .linear_ranges = bd71828_ldo_volts,
 523                         .n_linear_ranges = ARRAY_SIZE(bd71828_ldo_volts),
 524                         .n_voltages = BD71828_LDO_VOLTS,
 525                         .enable_reg = BD71828_REG_LDO3_EN,
 526                         .enable_mask = BD71828_MASK_RUN_EN,
 527                         .vsel_reg = BD71828_REG_LDO3_VOLT,
 528                         .vsel_mask = BD71828_MASK_LDO_VOLT,
 529                         .owner = THIS_MODULE,
 530                         .of_parse_cb = buck_set_hw_dvs_levels,
 531                 },
 532                 .dvs = {
 533                         /*
 534                          * LDO3 only supports single voltage for all states.
 535                          * voltage can be individually enabled for each state
 536                          * though => allow setting all states to support
 537                          * enabling power rail on different states.
 538                          */
 539                         .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
 540                                      ROHM_DVS_LEVEL_SUSPEND |
 541                                      ROHM_DVS_LEVEL_LPSR,
 542                         .run_reg = BD71828_REG_LDO3_VOLT,
 543                         .run_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         }, {
 550                 .desc = {
 551                         .name = "ldo4",
 552                         .of_match = of_match_ptr("LDO4"),
 553                         .regulators_node = of_match_ptr("regulators"),
 554                         .id = BD71828_LDO4,
 555                         .ops = &bd71828_ldo_ops,
 556                         .type = REGULATOR_VOLTAGE,
 557                         .linear_ranges = bd71828_ldo_volts,
 558                         .n_linear_ranges = ARRAY_SIZE(bd71828_ldo_volts),
 559                         .n_voltages = BD71828_LDO_VOLTS,
 560                         .enable_reg = BD71828_REG_LDO4_EN,
 561                         .enable_mask = BD71828_MASK_RUN_EN,
 562                         .vsel_reg = BD71828_REG_LDO4_VOLT,
 563                         .vsel_mask = BD71828_MASK_LDO_VOLT,
 564                         .owner = THIS_MODULE,
 565                         .of_parse_cb = buck_set_hw_dvs_levels,
 566                 },
 567                 .dvs = {
 568                         /*
 569                          * LDO1 only supports single voltage for all states.
 570                          * voltage can be individually enabled for each state
 571                          * though => allow setting all states to support
 572                          * enabling power rail on different states.
 573                          */
 574                         .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
 575                                      ROHM_DVS_LEVEL_SUSPEND |
 576                                      ROHM_DVS_LEVEL_LPSR,
 577                         .run_reg = BD71828_REG_LDO4_VOLT,
 578                         .run_mask = BD71828_MASK_LDO_VOLT,
 579                         .idle_on_mask = BD71828_MASK_IDLE_EN,
 580                         .suspend_on_mask = BD71828_MASK_SUSP_EN,
 581                         .lpsr_on_mask = BD71828_MASK_LPSR_EN,
 582                 },
 583         }, {
 584                 .desc = {
 585                         .name = "ldo5",
 586                         .of_match = of_match_ptr("LDO5"),
 587                         .regulators_node = of_match_ptr("regulators"),
 588                         .id = BD71828_LDO5,
 589                         .ops = &bd71828_ldo_ops,
 590                         .type = REGULATOR_VOLTAGE,
 591                         .linear_ranges = bd71828_ldo_volts,
 592                         .n_linear_ranges = ARRAY_SIZE(bd71828_ldo_volts),
 593                         .n_voltages = BD71828_LDO_VOLTS,
 594                         .enable_reg = BD71828_REG_LDO5_EN,
 595                         .enable_mask = BD71828_MASK_RUN_EN,
 596                         .vsel_reg = BD71828_REG_LDO5_VOLT,
 597                         .vsel_mask = BD71828_MASK_LDO_VOLT,
 598                         .of_parse_cb = buck_set_hw_dvs_levels,
 599                         .owner = THIS_MODULE,
 600                 },
 601                 /*
 602                  * LDO5 is special. It can choose vsel settings to be configured
 603                  * from 2 different registers (by GPIO).
 604                  *
 605                  * This driver supports only configuration where
 606                  * BD71828_REG_LDO5_VOLT_L is used.
 607                  */
 608                 .dvs = {
 609                         .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
 610                                      ROHM_DVS_LEVEL_SUSPEND |
 611                                      ROHM_DVS_LEVEL_LPSR,
 612                         .run_reg = BD71828_REG_LDO5_VOLT,
 613                         .run_mask = BD71828_MASK_LDO_VOLT,
 614                         .idle_on_mask = BD71828_MASK_IDLE_EN,
 615                         .suspend_on_mask = BD71828_MASK_SUSP_EN,
 616                         .lpsr_on_mask = BD71828_MASK_LPSR_EN,
 617                 },
 618
 619         }, {
 620                 .desc = {
 621                         .name = "ldo6",
 622                         .of_match = of_match_ptr("LDO6"),
 623                         .regulators_node = of_match_ptr("regulators"),
 624                         .id = BD71828_LDO6,
 625                         .ops = &bd71828_ldo6_ops,
 626                         .type = REGULATOR_VOLTAGE,
 627                         .fixed_uV = BD71828_LDO_6_VOLTAGE,
 628                         .n_voltages = 1,
 629                         .enable_reg = BD71828_REG_LDO6_EN,
 630                         .enable_mask = BD71828_MASK_RUN_EN,
 631                         .owner = THIS_MODULE,
 632                         /*
 633                          * LDO6 only supports enable/disable for all states.
 634                          * Voltage for LDO6 is fixed.
 635                          */
 636                         .of_parse_cb = ldo6_parse_dt,
 637                 },
 638         }, {
 639                 .desc = {
 640                         /* SNVS LDO in data-sheet */
 641                         .name = "ldo7",
 642                         .of_match = of_match_ptr("LDO7"),
 643                         .regulators_node = of_match_ptr("regulators"),
 644                         .id = BD71828_LDO_SNVS,
 645                         .ops = &bd71828_ldo_ops,
 646                         .type = REGULATOR_VOLTAGE,
 647                         .linear_ranges = bd71828_ldo_volts,
 648                         .n_linear_ranges = ARRAY_SIZE(bd71828_ldo_volts),
 649                         .n_voltages = BD71828_LDO_VOLTS,
 650                         .enable_reg = BD71828_REG_LDO7_EN,
 651                         .enable_mask = BD71828_MASK_RUN_EN,
 652                         .vsel_reg = BD71828_REG_LDO7_VOLT,
 653                         .vsel_mask = BD71828_MASK_LDO_VOLT,
 654                         .owner = THIS_MODULE,
 655                         .of_parse_cb = buck_set_hw_dvs_levels,
 656                 },
 657                 .dvs = {
 658                         /*
 659                          * LDO7 only supports single voltage for all states.
 660                          * voltage can be individually enabled for each state
 661                          * though => allow setting all states to support
 662                          * enabling power rail on different states.
 663                          */
 664                         .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
 665                                      ROHM_DVS_LEVEL_SUSPEND |
 666                                      ROHM_DVS_LEVEL_LPSR,
 667                         .run_reg = BD71828_REG_LDO7_VOLT,
 668                         .idle_reg = BD71828_REG_LDO7_VOLT,
 669                         .suspend_reg = BD71828_REG_LDO7_VOLT,
 670                         .lpsr_reg = BD71828_REG_LDO7_VOLT,
 671                         .run_mask = BD71828_MASK_LDO_VOLT,
 672                         .idle_on_mask = BD71828_MASK_IDLE_EN,
 673                         .suspend_on_mask = BD71828_MASK_SUSP_EN,
 674                         .lpsr_on_mask = BD71828_MASK_LPSR_EN,
 675                 },
 676
 677         },
 678 };
 679
 680 static int bd71828_probe(struct platform_device *pdev)
 681 {
 682         int i, j, ret;
 683         struct regulator_config config = {
 684                 .dev = pdev->dev.parent,
 685         };
 686
 687         config.regmap = dev_get_regmap(pdev->dev.parent, NULL);
 688         if (!config.regmap)
 689                 return -ENODEV;
 690
 691         for (i = 0; i < ARRAY_SIZE(bd71828_rdata); i++) {
 692                 struct regulator_dev *rdev;
 693                 const struct bd71828_regulator_data *rd;
 694
 695                 rd = &bd71828_rdata[i];
 696                 rdev = devm_regulator_register(&pdev->dev,
 697                                                &rd->desc, &config);
 698                 if (IS_ERR(rdev))
 699                         return dev_err_probe(&pdev->dev, PTR_ERR(rdev),
 700                                              "failed to register %s regulator\n",
 701                                              rd->desc.name);
 702
 703                 for (j = 0; j < rd->reg_init_amnt; j++) {
 704                         ret = regmap_update_bits(config.regmap,
 705                                                  rd->reg_inits[j].reg,
 706                                                  rd->reg_inits[j].mask,
 707                                                  rd->reg_inits[j].val);
 708                         if (ret)
 709                                 return dev_err_probe(&pdev->dev, ret,
 710                                                      "regulator %s init failed\n",
 711                                                      rd->desc.name);
 712                 }
 713         }
 714         return 0;
 715 }
 716
 717 static struct platform_driver bd71828_regulator = {
 718         .driver = {
 719                 .name = "bd71828-pmic",
 720                 .probe_type = PROBE_PREFER_ASYNCHRONOUS,
 721         },
 722         .probe = bd71828_probe,
 723 };
 724
 725 module_platform_driver(bd71828_regulator);
 726
 727 MODULE_AUTHOR("Matti Vaittinen <[email protected]>");
 728 MODULE_DESCRIPTION("BD71828 voltage regulator driver");
 729 MODULE_LICENSE("GPL");
 730 MODULE_ALIAS("platform:bd71828-pmic");