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