linux/drivers/regulator/da9062-regulator.c
<<
>>
Prefs
   1/*
   2 * Regulator device driver for DA9061 and DA9062.
   3 * Copyright (C) 2015-2017  Dialog Semiconductor
   4 *
   5 * This program is free software; you can redistribute it and/or
   6 * modify it under the terms of the GNU General Public License
   7 * as published by the Free Software Foundation; either version 2
   8 * of the License, or (at your option) any later version.
   9 *
  10 * This program is distributed in the hope that it will be useful,
  11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 * GNU General Public License for more details.
  14 */
  15#include <linux/kernel.h>
  16#include <linux/module.h>
  17#include <linux/init.h>
  18#include <linux/err.h>
  19#include <linux/slab.h>
  20#include <linux/of.h>
  21#include <linux/platform_device.h>
  22#include <linux/regmap.h>
  23#include <linux/regulator/driver.h>
  24#include <linux/regulator/machine.h>
  25#include <linux/regulator/of_regulator.h>
  26#include <linux/mfd/da9062/core.h>
  27#include <linux/mfd/da9062/registers.h>
  28
  29/* Regulator IDs */
  30enum {
  31        DA9061_ID_BUCK1,
  32        DA9061_ID_BUCK2,
  33        DA9061_ID_BUCK3,
  34        DA9061_ID_LDO1,
  35        DA9061_ID_LDO2,
  36        DA9061_ID_LDO3,
  37        DA9061_ID_LDO4,
  38        DA9061_MAX_REGULATORS,
  39};
  40
  41enum {
  42        DA9062_ID_BUCK1,
  43        DA9062_ID_BUCK2,
  44        DA9062_ID_BUCK3,
  45        DA9062_ID_BUCK4,
  46        DA9062_ID_LDO1,
  47        DA9062_ID_LDO2,
  48        DA9062_ID_LDO3,
  49        DA9062_ID_LDO4,
  50        DA9062_MAX_REGULATORS,
  51};
  52
  53/* Regulator capabilities and registers description */
  54struct da9062_regulator_info {
  55        struct regulator_desc desc;
  56        /* Current limiting */
  57        unsigned int n_current_limits;
  58        const int *current_limits;
  59        /* Main register fields */
  60        struct reg_field mode;
  61        struct reg_field suspend;
  62        struct reg_field sleep;
  63        struct reg_field suspend_sleep;
  64        unsigned int suspend_vsel_reg;
  65        struct reg_field ilimit;
  66        /* Event detection bit */
  67        struct reg_field oc_event;
  68};
  69
  70/* Single regulator settings */
  71struct da9062_regulator {
  72        struct regulator_desc                   desc;
  73        struct regulator_dev                    *rdev;
  74        struct da9062                           *hw;
  75        const struct da9062_regulator_info      *info;
  76
  77        struct regmap_field                     *mode;
  78        struct regmap_field                     *suspend;
  79        struct regmap_field                     *sleep;
  80        struct regmap_field                     *suspend_sleep;
  81        struct regmap_field                     *ilimit;
  82};
  83
  84/* Encapsulates all information for the regulators driver */
  85struct da9062_regulators {
  86        int                                     irq_ldo_lim;
  87        unsigned                                n_regulators;
  88        /* Array size to be defined during init. Keep at end. */
  89        struct da9062_regulator                 regulator[0];
  90};
  91
  92/* BUCK modes */
  93enum {
  94        BUCK_MODE_MANUAL,       /* 0 */
  95        BUCK_MODE_SLEEP,        /* 1 */
  96        BUCK_MODE_SYNC,         /* 2 */
  97        BUCK_MODE_AUTO          /* 3 */
  98};
  99
 100/* Regulator operations */
 101
 102/* Current limits array (in uA)
 103 * - DA9061_ID_[BUCK1|BUCK3]
 104 * - DA9062_ID_[BUCK1|BUCK2|BUCK4]
 105 * Entry indexes corresponds to register values.
 106 */
 107static const int da9062_buck_a_limits[] = {
 108         500000,  600000,  700000,  800000,  900000, 1000000, 1100000, 1200000,
 109        1300000, 1400000, 1500000, 1600000, 1700000, 1800000, 1900000, 2000000
 110};
 111
 112/* Current limits array (in uA)
 113 * - DA9061_ID_BUCK2
 114 * - DA9062_ID_BUCK3
 115 * Entry indexes corresponds to register values.
 116 */
 117static const int da9062_buck_b_limits[] = {
 118        1500000, 1600000, 1700000, 1800000, 1900000, 2000000, 2100000, 2200000,
 119        2300000, 2400000, 2500000, 2600000, 2700000, 2800000, 2900000, 3000000
 120};
 121
 122static int da9062_set_current_limit(struct regulator_dev *rdev,
 123                                    int min_ua, int max_ua)
 124{
 125        struct da9062_regulator *regl = rdev_get_drvdata(rdev);
 126        const struct da9062_regulator_info *rinfo = regl->info;
 127        int n, tval;
 128
 129        for (n = 0; n < rinfo->n_current_limits; n++) {
 130                tval = rinfo->current_limits[n];
 131                if (tval >= min_ua && tval <= max_ua)
 132                        return regmap_field_write(regl->ilimit, n);
 133        }
 134
 135        return -EINVAL;
 136}
 137
 138static int da9062_get_current_limit(struct regulator_dev *rdev)
 139{
 140        struct da9062_regulator *regl = rdev_get_drvdata(rdev);
 141        const struct da9062_regulator_info *rinfo = regl->info;
 142        unsigned int sel;
 143        int ret;
 144
 145        ret = regmap_field_read(regl->ilimit, &sel);
 146        if (ret < 0)
 147                return ret;
 148
 149        if (sel >= rinfo->n_current_limits)
 150                sel = rinfo->n_current_limits - 1;
 151
 152        return rinfo->current_limits[sel];
 153}
 154
 155static int da9062_buck_set_mode(struct regulator_dev *rdev, unsigned mode)
 156{
 157        struct da9062_regulator *regl = rdev_get_drvdata(rdev);
 158        unsigned val;
 159
 160        switch (mode) {
 161        case REGULATOR_MODE_FAST:
 162                val = BUCK_MODE_SYNC;
 163                break;
 164        case REGULATOR_MODE_NORMAL:
 165                val = BUCK_MODE_AUTO;
 166                break;
 167        case REGULATOR_MODE_STANDBY:
 168                val = BUCK_MODE_SLEEP;
 169                break;
 170        default:
 171                return -EINVAL;
 172        }
 173
 174        return regmap_field_write(regl->mode, val);
 175}
 176
 177/*
 178 * Bucks use single mode register field for normal operation
 179 * and suspend state.
 180 * There are 3 modes to map to: FAST, NORMAL, and STANDBY.
 181 */
 182
 183static unsigned da9062_buck_get_mode(struct regulator_dev *rdev)
 184{
 185        struct da9062_regulator *regl = rdev_get_drvdata(rdev);
 186        struct regmap_field *field;
 187        unsigned int val, mode = 0;
 188        int ret;
 189
 190        ret = regmap_field_read(regl->mode, &val);
 191        if (ret < 0)
 192                return ret;
 193
 194        switch (val) {
 195        default:
 196        case BUCK_MODE_MANUAL:
 197                mode = REGULATOR_MODE_FAST | REGULATOR_MODE_STANDBY;
 198                /* Sleep flag bit decides the mode */
 199                break;
 200        case BUCK_MODE_SLEEP:
 201                return REGULATOR_MODE_STANDBY;
 202        case BUCK_MODE_SYNC:
 203                return REGULATOR_MODE_FAST;
 204        case BUCK_MODE_AUTO:
 205                return REGULATOR_MODE_NORMAL;
 206        }
 207
 208        /* Detect current regulator state */
 209        ret = regmap_field_read(regl->suspend, &val);
 210        if (ret < 0)
 211                return 0;
 212
 213        /* Read regulator mode from proper register, depending on state */
 214        if (val)
 215                field = regl->suspend_sleep;
 216        else
 217                field = regl->sleep;
 218
 219        ret = regmap_field_read(field, &val);
 220        if (ret < 0)
 221                return 0;
 222
 223        if (val)
 224                mode &= REGULATOR_MODE_STANDBY;
 225        else
 226                mode &= REGULATOR_MODE_NORMAL | REGULATOR_MODE_FAST;
 227
 228        return mode;
 229}
 230
 231/*
 232 * LDOs use sleep flags - one for normal and one for suspend state.
 233 * There are 2 modes to map to: NORMAL and STANDBY (sleep) for each state.
 234 */
 235
 236static int da9062_ldo_set_mode(struct regulator_dev *rdev, unsigned mode)
 237{
 238        struct da9062_regulator *regl = rdev_get_drvdata(rdev);
 239        unsigned val;
 240
 241        switch (mode) {
 242        case REGULATOR_MODE_NORMAL:
 243                val = 0;
 244                break;
 245        case REGULATOR_MODE_STANDBY:
 246                val = 1;
 247                break;
 248        default:
 249                return -EINVAL;
 250        }
 251
 252        return regmap_field_write(regl->sleep, val);
 253}
 254
 255static unsigned da9062_ldo_get_mode(struct regulator_dev *rdev)
 256{
 257        struct da9062_regulator *regl = rdev_get_drvdata(rdev);
 258        struct regmap_field *field;
 259        int ret, val;
 260
 261        /* Detect current regulator state */
 262        ret = regmap_field_read(regl->suspend, &val);
 263        if (ret < 0)
 264                return 0;
 265
 266        /* Read regulator mode from proper register, depending on state */
 267        if (val)
 268                field = regl->suspend_sleep;
 269        else
 270                field = regl->sleep;
 271
 272        ret = regmap_field_read(field, &val);
 273        if (ret < 0)
 274                return 0;
 275
 276        if (val)
 277                return REGULATOR_MODE_STANDBY;
 278        else
 279                return REGULATOR_MODE_NORMAL;
 280}
 281
 282static int da9062_buck_get_status(struct regulator_dev *rdev)
 283{
 284        int ret = regulator_is_enabled_regmap(rdev);
 285
 286        if (ret == 0) {
 287                ret = REGULATOR_STATUS_OFF;
 288        } else if (ret > 0) {
 289                ret = da9062_buck_get_mode(rdev);
 290                if (ret > 0)
 291                        ret = regulator_mode_to_status(ret);
 292                else if (ret == 0)
 293                        ret = -EIO;
 294        }
 295
 296        return ret;
 297}
 298
 299static int da9062_ldo_get_status(struct regulator_dev *rdev)
 300{
 301        int ret = regulator_is_enabled_regmap(rdev);
 302
 303        if (ret == 0) {
 304                ret = REGULATOR_STATUS_OFF;
 305        } else if (ret > 0) {
 306                ret = da9062_ldo_get_mode(rdev);
 307                if (ret > 0)
 308                        ret = regulator_mode_to_status(ret);
 309                else if (ret == 0)
 310                        ret = -EIO;
 311        }
 312
 313        return ret;
 314}
 315
 316static int da9062_set_suspend_voltage(struct regulator_dev *rdev, int uv)
 317{
 318        struct da9062_regulator *regl = rdev_get_drvdata(rdev);
 319        const struct da9062_regulator_info *rinfo = regl->info;
 320        int ret, sel;
 321
 322        sel = regulator_map_voltage_linear(rdev, uv, uv);
 323        if (sel < 0)
 324                return sel;
 325
 326        sel <<= ffs(rdev->desc->vsel_mask) - 1;
 327
 328        ret = regmap_update_bits(regl->hw->regmap, rinfo->suspend_vsel_reg,
 329                                 rdev->desc->vsel_mask, sel);
 330
 331        return ret;
 332}
 333
 334static int da9062_suspend_enable(struct regulator_dev *rdev)
 335{
 336        struct da9062_regulator *regl = rdev_get_drvdata(rdev);
 337
 338        return regmap_field_write(regl->suspend, 1);
 339}
 340
 341static int da9062_suspend_disable(struct regulator_dev *rdev)
 342{
 343        struct da9062_regulator *regl = rdev_get_drvdata(rdev);
 344
 345        return regmap_field_write(regl->suspend, 0);
 346}
 347
 348static int da9062_buck_set_suspend_mode(struct regulator_dev *rdev,
 349                                        unsigned mode)
 350{
 351        struct da9062_regulator *regl = rdev_get_drvdata(rdev);
 352        int val;
 353
 354        switch (mode) {
 355        case REGULATOR_MODE_FAST:
 356                val = BUCK_MODE_SYNC;
 357                break;
 358        case REGULATOR_MODE_NORMAL:
 359                val = BUCK_MODE_AUTO;
 360                break;
 361        case REGULATOR_MODE_STANDBY:
 362                val = BUCK_MODE_SLEEP;
 363                break;
 364        default:
 365                return -EINVAL;
 366        }
 367
 368        return regmap_field_write(regl->mode, val);
 369}
 370
 371static int da9062_ldo_set_suspend_mode(struct regulator_dev *rdev,
 372                                                unsigned mode)
 373{
 374        struct da9062_regulator *regl = rdev_get_drvdata(rdev);
 375        unsigned val;
 376
 377        switch (mode) {
 378        case REGULATOR_MODE_NORMAL:
 379                val = 0;
 380                break;
 381        case REGULATOR_MODE_STANDBY:
 382                val = 1;
 383                break;
 384        default:
 385                return -EINVAL;
 386        }
 387
 388        return regmap_field_write(regl->suspend_sleep, val);
 389}
 390
 391static const struct regulator_ops da9062_buck_ops = {
 392        .enable                 = regulator_enable_regmap,
 393        .disable                = regulator_disable_regmap,
 394        .is_enabled             = regulator_is_enabled_regmap,
 395        .get_voltage_sel        = regulator_get_voltage_sel_regmap,
 396        .set_voltage_sel        = regulator_set_voltage_sel_regmap,
 397        .list_voltage           = regulator_list_voltage_linear,
 398        .set_current_limit      = da9062_set_current_limit,
 399        .get_current_limit      = da9062_get_current_limit,
 400        .set_mode               = da9062_buck_set_mode,
 401        .get_mode               = da9062_buck_get_mode,
 402        .get_status             = da9062_buck_get_status,
 403        .set_suspend_voltage    = da9062_set_suspend_voltage,
 404        .set_suspend_enable     = da9062_suspend_enable,
 405        .set_suspend_disable    = da9062_suspend_disable,
 406        .set_suspend_mode       = da9062_buck_set_suspend_mode,
 407};
 408
 409static const struct regulator_ops da9062_ldo_ops = {
 410        .enable                 = regulator_enable_regmap,
 411        .disable                = regulator_disable_regmap,
 412        .is_enabled             = regulator_is_enabled_regmap,
 413        .get_voltage_sel        = regulator_get_voltage_sel_regmap,
 414        .set_voltage_sel        = regulator_set_voltage_sel_regmap,
 415        .list_voltage           = regulator_list_voltage_linear,
 416        .set_mode               = da9062_ldo_set_mode,
 417        .get_mode               = da9062_ldo_get_mode,
 418        .get_status             = da9062_ldo_get_status,
 419        .set_suspend_voltage    = da9062_set_suspend_voltage,
 420        .set_suspend_enable     = da9062_suspend_enable,
 421        .set_suspend_disable    = da9062_suspend_disable,
 422        .set_suspend_mode       = da9062_ldo_set_suspend_mode,
 423};
 424
 425/* DA9061 Regulator information */
 426static const struct da9062_regulator_info local_da9061_regulator_info[] = {
 427        {
 428                .desc.id = DA9061_ID_BUCK1,
 429                .desc.name = "DA9061 BUCK1",
 430                .desc.of_match = of_match_ptr("buck1"),
 431                .desc.regulators_node = of_match_ptr("regulators"),
 432                .desc.ops = &da9062_buck_ops,
 433                .desc.min_uV = (300) * 1000,
 434                .desc.uV_step = (10) * 1000,
 435                .desc.n_voltages = ((1570) - (300))/(10) + 1,
 436                .current_limits = da9062_buck_a_limits,
 437                .n_current_limits = ARRAY_SIZE(da9062_buck_a_limits),
 438                .desc.enable_reg = DA9062AA_BUCK1_CONT,
 439                .desc.enable_mask = DA9062AA_BUCK1_EN_MASK,
 440                .desc.vsel_reg = DA9062AA_VBUCK1_A,
 441                .desc.vsel_mask = DA9062AA_VBUCK1_A_MASK,
 442                .desc.linear_min_sel = 0,
 443                .sleep = REG_FIELD(DA9062AA_VBUCK1_A,
 444                        __builtin_ffs((int)DA9062AA_BUCK1_SL_A_MASK) - 1,
 445                        sizeof(unsigned int) * 8 -
 446                        __builtin_clz((DA9062AA_BUCK1_SL_A_MASK)) - 1),
 447                .suspend_sleep = REG_FIELD(DA9062AA_VBUCK1_B,
 448                        __builtin_ffs((int)DA9062AA_BUCK1_SL_B_MASK) - 1,
 449                        sizeof(unsigned int) * 8 -
 450                        __builtin_clz((DA9062AA_BUCK1_SL_B_MASK)) - 1),
 451                .suspend_vsel_reg = DA9062AA_VBUCK1_B,
 452                .mode = REG_FIELD(DA9062AA_BUCK1_CFG,
 453                        __builtin_ffs((int)DA9062AA_BUCK1_MODE_MASK) - 1,
 454                        sizeof(unsigned int) * 8 -
 455                        __builtin_clz((DA9062AA_BUCK1_MODE_MASK)) - 1),
 456                .suspend = REG_FIELD(DA9062AA_DVC_1,
 457                        __builtin_ffs((int)DA9062AA_VBUCK1_SEL_MASK) - 1,
 458                        sizeof(unsigned int) * 8 -
 459                        __builtin_clz((DA9062AA_VBUCK1_SEL_MASK)) - 1),
 460                .ilimit = REG_FIELD(DA9062AA_BUCK_ILIM_C,
 461                        __builtin_ffs((int)DA9062AA_BUCK1_ILIM_MASK) - 1,
 462                        sizeof(unsigned int) * 8 -
 463                        __builtin_clz((DA9062AA_BUCK1_ILIM_MASK)) - 1),
 464        },
 465        {
 466                .desc.id = DA9061_ID_BUCK2,
 467                .desc.name = "DA9061 BUCK2",
 468                .desc.of_match = of_match_ptr("buck2"),
 469                .desc.regulators_node = of_match_ptr("regulators"),
 470                .desc.ops = &da9062_buck_ops,
 471                .desc.min_uV = (800) * 1000,
 472                .desc.uV_step = (20) * 1000,
 473                .desc.n_voltages = ((3340) - (800))/(20) + 1,
 474                .current_limits = da9062_buck_b_limits,
 475                .n_current_limits = ARRAY_SIZE(da9062_buck_b_limits),
 476                .desc.enable_reg = DA9062AA_BUCK3_CONT,
 477                .desc.enable_mask = DA9062AA_BUCK3_EN_MASK,
 478                .desc.vsel_reg = DA9062AA_VBUCK3_A,
 479                .desc.vsel_mask = DA9062AA_VBUCK3_A_MASK,
 480                .desc.linear_min_sel = 0,
 481                .sleep = REG_FIELD(DA9062AA_VBUCK3_A,
 482                        __builtin_ffs((int)DA9062AA_BUCK3_SL_A_MASK) - 1,
 483                        sizeof(unsigned int) * 8 -
 484                        __builtin_clz((DA9062AA_BUCK3_SL_A_MASK)) - 1),
 485                .suspend_sleep = REG_FIELD(DA9062AA_VBUCK3_B,
 486                        __builtin_ffs((int)DA9062AA_BUCK3_SL_B_MASK) - 1,
 487                        sizeof(unsigned int) * 8 -
 488                        __builtin_clz((DA9062AA_BUCK3_SL_B_MASK)) - 1),
 489                .suspend_vsel_reg = DA9062AA_VBUCK3_B,
 490                .mode = REG_FIELD(DA9062AA_BUCK3_CFG,
 491                        __builtin_ffs((int)DA9062AA_BUCK3_MODE_MASK) - 1,
 492                        sizeof(unsigned int) * 8 -
 493                        __builtin_clz((DA9062AA_BUCK3_MODE_MASK)) - 1),
 494                .suspend = REG_FIELD(DA9062AA_DVC_1,
 495                        __builtin_ffs((int)DA9062AA_VBUCK3_SEL_MASK) - 1,
 496                        sizeof(unsigned int) * 8 -
 497                        __builtin_clz((DA9062AA_VBUCK3_SEL_MASK)) - 1),
 498                .ilimit = REG_FIELD(DA9062AA_BUCK_ILIM_A,
 499                        __builtin_ffs((int)DA9062AA_BUCK3_ILIM_MASK) - 1,
 500                        sizeof(unsigned int) * 8 -
 501                        __builtin_clz((DA9062AA_BUCK3_ILIM_MASK)) - 1),
 502        },
 503        {
 504                .desc.id = DA9061_ID_BUCK3,
 505                .desc.name = "DA9061 BUCK3",
 506                .desc.of_match = of_match_ptr("buck3"),
 507                .desc.regulators_node = of_match_ptr("regulators"),
 508                .desc.ops = &da9062_buck_ops,
 509                .desc.min_uV = (530) * 1000,
 510                .desc.uV_step = (10) * 1000,
 511                .desc.n_voltages = ((1800) - (530))/(10) + 1,
 512                .current_limits = da9062_buck_a_limits,
 513                .n_current_limits = ARRAY_SIZE(da9062_buck_a_limits),
 514                .desc.enable_reg = DA9062AA_BUCK4_CONT,
 515                .desc.enable_mask = DA9062AA_BUCK4_EN_MASK,
 516                .desc.vsel_reg = DA9062AA_VBUCK4_A,
 517                .desc.vsel_mask = DA9062AA_VBUCK4_A_MASK,
 518                .desc.linear_min_sel = 0,
 519                .sleep = REG_FIELD(DA9062AA_VBUCK4_A,
 520                        __builtin_ffs((int)DA9062AA_BUCK4_SL_A_MASK) - 1,
 521                        sizeof(unsigned int) * 8 -
 522                        __builtin_clz((DA9062AA_BUCK4_SL_A_MASK)) - 1),
 523                .suspend_sleep = REG_FIELD(DA9062AA_VBUCK4_B,
 524                        __builtin_ffs((int)DA9062AA_BUCK4_SL_B_MASK) - 1,
 525                        sizeof(unsigned int) * 8 -
 526                        __builtin_clz((DA9062AA_BUCK4_SL_B_MASK)) - 1),
 527                .suspend_vsel_reg = DA9062AA_VBUCK4_B,
 528                .mode = REG_FIELD(DA9062AA_BUCK4_CFG,
 529                        __builtin_ffs((int)DA9062AA_BUCK4_MODE_MASK) - 1,
 530                        sizeof(unsigned int) * 8 -
 531                        __builtin_clz((DA9062AA_BUCK4_MODE_MASK)) - 1),
 532                .suspend = REG_FIELD(DA9062AA_DVC_1,
 533                        __builtin_ffs((int)DA9062AA_VBUCK4_SEL_MASK) - 1,
 534                        sizeof(unsigned int) * 8 -
 535                        __builtin_clz((DA9062AA_VBUCK4_SEL_MASK)) - 1),
 536                .ilimit = REG_FIELD(DA9062AA_BUCK_ILIM_B,
 537                        __builtin_ffs((int)DA9062AA_BUCK4_ILIM_MASK) - 1,
 538                        sizeof(unsigned int) * 8 -
 539                        __builtin_clz((DA9062AA_BUCK4_ILIM_MASK)) - 1),
 540        },
 541        {
 542                .desc.id = DA9061_ID_LDO1,
 543                .desc.name = "DA9061 LDO1",
 544                .desc.of_match = of_match_ptr("ldo1"),
 545                .desc.regulators_node = of_match_ptr("regulators"),
 546                .desc.ops = &da9062_ldo_ops,
 547                .desc.min_uV = (900) * 1000,
 548                .desc.uV_step = (50) * 1000,
 549                .desc.n_voltages = ((3600) - (900))/(50) + 1,
 550                .desc.enable_reg = DA9062AA_LDO1_CONT,
 551                .desc.enable_mask = DA9062AA_LDO1_EN_MASK,
 552                .desc.vsel_reg = DA9062AA_VLDO1_A,
 553                .desc.vsel_mask = DA9062AA_VLDO1_A_MASK,
 554                .desc.linear_min_sel = 0,
 555                .sleep = REG_FIELD(DA9062AA_VLDO1_A,
 556                        __builtin_ffs((int)DA9062AA_LDO1_SL_A_MASK) - 1,
 557                        sizeof(unsigned int) * 8 -
 558                        __builtin_clz((DA9062AA_LDO1_SL_A_MASK)) - 1),
 559                .suspend_sleep = REG_FIELD(DA9062AA_VLDO1_B,
 560                        __builtin_ffs((int)DA9062AA_LDO1_SL_B_MASK) - 1,
 561                        sizeof(unsigned int) * 8 -
 562                        __builtin_clz((DA9062AA_LDO1_SL_B_MASK)) - 1),
 563                .suspend_vsel_reg = DA9062AA_VLDO1_B,
 564                .suspend = REG_FIELD(DA9062AA_DVC_1,
 565                        __builtin_ffs((int)DA9062AA_VLDO1_SEL_MASK) - 1,
 566                        sizeof(unsigned int) * 8 -
 567                        __builtin_clz((DA9062AA_VLDO1_SEL_MASK)) - 1),
 568                .oc_event = REG_FIELD(DA9062AA_STATUS_D,
 569                        __builtin_ffs((int)DA9062AA_LDO1_ILIM_MASK) - 1,
 570                        sizeof(unsigned int) * 8 -
 571                        __builtin_clz((DA9062AA_LDO1_ILIM_MASK)) - 1),
 572        },
 573        {
 574                .desc.id = DA9061_ID_LDO2,
 575                .desc.name = "DA9061 LDO2",
 576                .desc.of_match = of_match_ptr("ldo2"),
 577                .desc.regulators_node = of_match_ptr("regulators"),
 578                .desc.ops = &da9062_ldo_ops,
 579                .desc.min_uV = (900) * 1000,
 580                .desc.uV_step = (50) * 1000,
 581                .desc.n_voltages = ((3600) - (600))/(50) + 1,
 582                .desc.enable_reg = DA9062AA_LDO2_CONT,
 583                .desc.enable_mask = DA9062AA_LDO2_EN_MASK,
 584                .desc.vsel_reg = DA9062AA_VLDO2_A,
 585                .desc.vsel_mask = DA9062AA_VLDO2_A_MASK,
 586                .desc.linear_min_sel = 0,
 587                .sleep = REG_FIELD(DA9062AA_VLDO2_A,
 588                        __builtin_ffs((int)DA9062AA_LDO2_SL_A_MASK) - 1,
 589                        sizeof(unsigned int) * 8 -
 590                        __builtin_clz((DA9062AA_LDO2_SL_A_MASK)) - 1),
 591                .suspend_sleep = REG_FIELD(DA9062AA_VLDO2_B,
 592                        __builtin_ffs((int)DA9062AA_LDO2_SL_B_MASK) - 1,
 593                        sizeof(unsigned int) * 8 -
 594                        __builtin_clz((DA9062AA_LDO2_SL_B_MASK)) - 1),
 595                .suspend_vsel_reg = DA9062AA_VLDO2_B,
 596                .suspend = REG_FIELD(DA9062AA_DVC_1,
 597                        __builtin_ffs((int)DA9062AA_VLDO2_SEL_MASK) - 1,
 598                        sizeof(unsigned int) * 8 -
 599                        __builtin_clz((DA9062AA_VLDO2_SEL_MASK)) - 1),
 600                .oc_event = REG_FIELD(DA9062AA_STATUS_D,
 601                        __builtin_ffs((int)DA9062AA_LDO2_ILIM_MASK) - 1,
 602                        sizeof(unsigned int) * 8 -
 603                        __builtin_clz((DA9062AA_LDO2_ILIM_MASK)) - 1),
 604        },
 605        {
 606                .desc.id = DA9061_ID_LDO3,
 607                .desc.name = "DA9061 LDO3",
 608                .desc.of_match = of_match_ptr("ldo3"),
 609                .desc.regulators_node = of_match_ptr("regulators"),
 610                .desc.ops = &da9062_ldo_ops,
 611                .desc.min_uV = (900) * 1000,
 612                .desc.uV_step = (50) * 1000,
 613                .desc.n_voltages = ((3600) - (900))/(50) + 1,
 614                .desc.enable_reg = DA9062AA_LDO3_CONT,
 615                .desc.enable_mask = DA9062AA_LDO3_EN_MASK,
 616                .desc.vsel_reg = DA9062AA_VLDO3_A,
 617                .desc.vsel_mask = DA9062AA_VLDO3_A_MASK,
 618                .desc.linear_min_sel = 0,
 619                .sleep = REG_FIELD(DA9062AA_VLDO3_A,
 620                        __builtin_ffs((int)DA9062AA_LDO3_SL_A_MASK) - 1,
 621                        sizeof(unsigned int) * 8 -
 622                        __builtin_clz((DA9062AA_LDO3_SL_A_MASK)) - 1),
 623                .suspend_sleep = REG_FIELD(DA9062AA_VLDO3_B,
 624                        __builtin_ffs((int)DA9062AA_LDO3_SL_B_MASK) - 1,
 625                        sizeof(unsigned int) * 8 -
 626                        __builtin_clz((DA9062AA_LDO3_SL_B_MASK)) - 1),
 627                .suspend_vsel_reg = DA9062AA_VLDO3_B,
 628                .suspend = REG_FIELD(DA9062AA_DVC_1,
 629                        __builtin_ffs((int)DA9062AA_VLDO3_SEL_MASK) - 1,
 630                        sizeof(unsigned int) * 8 -
 631                        __builtin_clz((DA9062AA_VLDO3_SEL_MASK)) - 1),
 632                .oc_event = REG_FIELD(DA9062AA_STATUS_D,
 633                        __builtin_ffs((int)DA9062AA_LDO3_ILIM_MASK) - 1,
 634                        sizeof(unsigned int) * 8 -
 635                        __builtin_clz((DA9062AA_LDO3_ILIM_MASK)) - 1),
 636        },
 637        {
 638                .desc.id = DA9061_ID_LDO4,
 639                .desc.name = "DA9061 LDO4",
 640                .desc.of_match = of_match_ptr("ldo4"),
 641                .desc.regulators_node = of_match_ptr("regulators"),
 642                .desc.ops = &da9062_ldo_ops,
 643                .desc.min_uV = (900) * 1000,
 644                .desc.uV_step = (50) * 1000,
 645                .desc.n_voltages = ((3600) - (900))/(50) + 1,
 646                .desc.enable_reg = DA9062AA_LDO4_CONT,
 647                .desc.enable_mask = DA9062AA_LDO4_EN_MASK,
 648                .desc.vsel_reg = DA9062AA_VLDO4_A,
 649                .desc.vsel_mask = DA9062AA_VLDO4_A_MASK,
 650                .desc.linear_min_sel = 0,
 651                .sleep = REG_FIELD(DA9062AA_VLDO4_A,
 652                        __builtin_ffs((int)DA9062AA_LDO4_SL_A_MASK) - 1,
 653                        sizeof(unsigned int) * 8 -
 654                        __builtin_clz((DA9062AA_LDO4_SL_A_MASK)) - 1),
 655                .suspend_sleep = REG_FIELD(DA9062AA_VLDO4_B,
 656                        __builtin_ffs((int)DA9062AA_LDO4_SL_B_MASK) - 1,
 657                        sizeof(unsigned int) * 8 -
 658                        __builtin_clz((DA9062AA_LDO4_SL_B_MASK)) - 1),
 659                .suspend_vsel_reg = DA9062AA_VLDO4_B,
 660                .suspend = REG_FIELD(DA9062AA_DVC_1,
 661                        __builtin_ffs((int)DA9062AA_VLDO4_SEL_MASK) - 1,
 662                        sizeof(unsigned int) * 8 -
 663                        __builtin_clz((DA9062AA_VLDO4_SEL_MASK)) - 1),
 664                .oc_event = REG_FIELD(DA9062AA_STATUS_D,
 665                        __builtin_ffs((int)DA9062AA_LDO4_ILIM_MASK) - 1,
 666                        sizeof(unsigned int) * 8 -
 667                        __builtin_clz((DA9062AA_LDO4_ILIM_MASK)) - 1),
 668        },
 669};
 670
 671/* DA9062 Regulator information */
 672static const struct da9062_regulator_info local_da9062_regulator_info[] = {
 673        {
 674                .desc.id = DA9062_ID_BUCK1,
 675                .desc.name = "DA9062 BUCK1",
 676                .desc.of_match = of_match_ptr("buck1"),
 677                .desc.regulators_node = of_match_ptr("regulators"),
 678                .desc.ops = &da9062_buck_ops,
 679                .desc.min_uV = (300) * 1000,
 680                .desc.uV_step = (10) * 1000,
 681                .desc.n_voltages = ((1570) - (300))/(10) + 1,
 682                .current_limits = da9062_buck_a_limits,
 683                .n_current_limits = ARRAY_SIZE(da9062_buck_a_limits),
 684                .desc.enable_reg = DA9062AA_BUCK1_CONT,
 685                .desc.enable_mask = DA9062AA_BUCK1_EN_MASK,
 686                .desc.vsel_reg = DA9062AA_VBUCK1_A,
 687                .desc.vsel_mask = DA9062AA_VBUCK1_A_MASK,
 688                .desc.linear_min_sel = 0,
 689                .sleep = REG_FIELD(DA9062AA_VBUCK1_A,
 690                        __builtin_ffs((int)DA9062AA_BUCK1_SL_A_MASK) - 1,
 691                        sizeof(unsigned int) * 8 -
 692                        __builtin_clz((DA9062AA_BUCK1_SL_A_MASK)) - 1),
 693                .suspend_sleep = REG_FIELD(DA9062AA_VBUCK1_B,
 694                        __builtin_ffs((int)DA9062AA_BUCK1_SL_B_MASK) - 1,
 695                        sizeof(unsigned int) * 8 -
 696                        __builtin_clz((DA9062AA_BUCK1_SL_B_MASK)) - 1),
 697                .suspend_vsel_reg = DA9062AA_VBUCK1_B,
 698                .mode = REG_FIELD(DA9062AA_BUCK1_CFG,
 699                        __builtin_ffs((int)DA9062AA_BUCK1_MODE_MASK) - 1,
 700                        sizeof(unsigned int) * 8 -
 701                        __builtin_clz((DA9062AA_BUCK1_MODE_MASK)) - 1),
 702                .suspend = REG_FIELD(DA9062AA_DVC_1,
 703                        __builtin_ffs((int)DA9062AA_VBUCK1_SEL_MASK) - 1,
 704                        sizeof(unsigned int) * 8 -
 705                        __builtin_clz((DA9062AA_VBUCK1_SEL_MASK)) - 1),
 706                .ilimit = REG_FIELD(DA9062AA_BUCK_ILIM_C,
 707                        __builtin_ffs((int)DA9062AA_BUCK1_ILIM_MASK) - 1,
 708                        sizeof(unsigned int) * 8 -
 709                        __builtin_clz((DA9062AA_BUCK1_ILIM_MASK)) - 1),
 710        },
 711        {
 712                .desc.id = DA9062_ID_BUCK2,
 713                .desc.name = "DA9062 BUCK2",
 714                .desc.of_match = of_match_ptr("buck2"),
 715                .desc.regulators_node = of_match_ptr("regulators"),
 716                .desc.ops = &da9062_buck_ops,
 717                .desc.min_uV = (300) * 1000,
 718                .desc.uV_step = (10) * 1000,
 719                .desc.n_voltages = ((1570) - (300))/(10) + 1,
 720                .current_limits = da9062_buck_a_limits,
 721                .n_current_limits = ARRAY_SIZE(da9062_buck_a_limits),
 722                .desc.enable_reg = DA9062AA_BUCK2_CONT,
 723                .desc.enable_mask = DA9062AA_BUCK2_EN_MASK,
 724                .desc.vsel_reg = DA9062AA_VBUCK2_A,
 725                .desc.vsel_mask = DA9062AA_VBUCK2_A_MASK,
 726                .desc.linear_min_sel = 0,
 727                .sleep = REG_FIELD(DA9062AA_VBUCK2_A,
 728                        __builtin_ffs((int)DA9062AA_BUCK2_SL_A_MASK) - 1,
 729                        sizeof(unsigned int) * 8 -
 730                        __builtin_clz((DA9062AA_BUCK2_SL_A_MASK)) - 1),
 731                .suspend_sleep = REG_FIELD(DA9062AA_VBUCK2_B,
 732                        __builtin_ffs((int)DA9062AA_BUCK2_SL_B_MASK) - 1,
 733                        sizeof(unsigned int) * 8 -
 734                        __builtin_clz((DA9062AA_BUCK2_SL_B_MASK)) - 1),
 735                .suspend_vsel_reg = DA9062AA_VBUCK2_B,
 736                .mode = REG_FIELD(DA9062AA_BUCK2_CFG,
 737                        __builtin_ffs((int)DA9062AA_BUCK2_MODE_MASK) - 1,
 738                        sizeof(unsigned int) * 8 -
 739                        __builtin_clz((DA9062AA_BUCK2_MODE_MASK)) - 1),
 740                .suspend = REG_FIELD(DA9062AA_DVC_1,
 741                        __builtin_ffs((int)DA9062AA_VBUCK2_SEL_MASK) - 1,
 742                        sizeof(unsigned int) * 8 -
 743                        __builtin_clz((DA9062AA_VBUCK2_SEL_MASK)) - 1),
 744                .ilimit = REG_FIELD(DA9062AA_BUCK_ILIM_C,
 745                        __builtin_ffs((int)DA9062AA_BUCK2_ILIM_MASK) - 1,
 746                        sizeof(unsigned int) * 8 -
 747                        __builtin_clz((DA9062AA_BUCK2_ILIM_MASK)) - 1),
 748        },
 749        {
 750                .desc.id = DA9062_ID_BUCK3,
 751                .desc.name = "DA9062 BUCK3",
 752                .desc.of_match = of_match_ptr("buck3"),
 753                .desc.regulators_node = of_match_ptr("regulators"),
 754                .desc.ops = &da9062_buck_ops,
 755                .desc.min_uV = (800) * 1000,
 756                .desc.uV_step = (20) * 1000,
 757                .desc.n_voltages = ((3340) - (800))/(20) + 1,
 758                .current_limits = da9062_buck_b_limits,
 759                .n_current_limits = ARRAY_SIZE(da9062_buck_b_limits),
 760                .desc.enable_reg = DA9062AA_BUCK3_CONT,
 761                .desc.enable_mask = DA9062AA_BUCK3_EN_MASK,
 762                .desc.vsel_reg = DA9062AA_VBUCK3_A,
 763                .desc.vsel_mask = DA9062AA_VBUCK3_A_MASK,
 764                .desc.linear_min_sel = 0,
 765                .sleep = REG_FIELD(DA9062AA_VBUCK3_A,
 766                        __builtin_ffs((int)DA9062AA_BUCK3_SL_A_MASK) - 1,
 767                        sizeof(unsigned int) * 8 -
 768                        __builtin_clz((DA9062AA_BUCK3_SL_A_MASK)) - 1),
 769                .suspend_sleep = REG_FIELD(DA9062AA_VBUCK3_B,
 770                        __builtin_ffs((int)DA9062AA_BUCK3_SL_B_MASK) - 1,
 771                        sizeof(unsigned int) * 8 -
 772                        __builtin_clz((DA9062AA_BUCK3_SL_B_MASK)) - 1),
 773                .suspend_vsel_reg = DA9062AA_VBUCK3_B,
 774                .mode = REG_FIELD(DA9062AA_BUCK3_CFG,
 775                        __builtin_ffs((int)DA9062AA_BUCK3_MODE_MASK) - 1,
 776                        sizeof(unsigned int) * 8 -
 777                        __builtin_clz((DA9062AA_BUCK3_MODE_MASK)) - 1),
 778                .suspend = REG_FIELD(DA9062AA_DVC_1,
 779                        __builtin_ffs((int)DA9062AA_VBUCK3_SEL_MASK) - 1,
 780                        sizeof(unsigned int) * 8 -
 781                        __builtin_clz((DA9062AA_VBUCK3_SEL_MASK)) - 1),
 782                .ilimit = REG_FIELD(DA9062AA_BUCK_ILIM_A,
 783                        __builtin_ffs((int)DA9062AA_BUCK3_ILIM_MASK) - 1,
 784                        sizeof(unsigned int) * 8 -
 785                        __builtin_clz((DA9062AA_BUCK3_ILIM_MASK)) - 1),
 786        },
 787        {
 788                .desc.id = DA9062_ID_BUCK4,
 789                .desc.name = "DA9062 BUCK4",
 790                .desc.of_match = of_match_ptr("buck4"),
 791                .desc.regulators_node = of_match_ptr("regulators"),
 792                .desc.ops = &da9062_buck_ops,
 793                .desc.min_uV = (530) * 1000,
 794                .desc.uV_step = (10) * 1000,
 795                .desc.n_voltages = ((1800) - (530))/(10) + 1,
 796                .current_limits = da9062_buck_a_limits,
 797                .n_current_limits = ARRAY_SIZE(da9062_buck_a_limits),
 798                .desc.enable_reg = DA9062AA_BUCK4_CONT,
 799                .desc.enable_mask = DA9062AA_BUCK4_EN_MASK,
 800                .desc.vsel_reg = DA9062AA_VBUCK4_A,
 801                .desc.vsel_mask = DA9062AA_VBUCK4_A_MASK,
 802                .desc.linear_min_sel = 0,
 803                .sleep = REG_FIELD(DA9062AA_VBUCK4_A,
 804                        __builtin_ffs((int)DA9062AA_BUCK4_SL_A_MASK) - 1,
 805                        sizeof(unsigned int) * 8 -
 806                        __builtin_clz((DA9062AA_BUCK4_SL_A_MASK)) - 1),
 807                .suspend_sleep = REG_FIELD(DA9062AA_VBUCK4_B,
 808                        __builtin_ffs((int)DA9062AA_BUCK4_SL_B_MASK) - 1,
 809                        sizeof(unsigned int) * 8 -
 810                        __builtin_clz((DA9062AA_BUCK4_SL_B_MASK)) - 1),
 811                .suspend_vsel_reg = DA9062AA_VBUCK4_B,
 812                .mode = REG_FIELD(DA9062AA_BUCK4_CFG,
 813                        __builtin_ffs((int)DA9062AA_BUCK4_MODE_MASK) - 1,
 814                        sizeof(unsigned int) * 8 -
 815                        __builtin_clz((DA9062AA_BUCK4_MODE_MASK)) - 1),
 816                .suspend = REG_FIELD(DA9062AA_DVC_1,
 817                        __builtin_ffs((int)DA9062AA_VBUCK4_SEL_MASK) - 1,
 818                        sizeof(unsigned int) * 8 -
 819                        __builtin_clz((DA9062AA_VBUCK4_SEL_MASK)) - 1),
 820                .ilimit = REG_FIELD(DA9062AA_BUCK_ILIM_B,
 821                        __builtin_ffs((int)DA9062AA_BUCK4_ILIM_MASK) - 1,
 822                        sizeof(unsigned int) * 8 -
 823                        __builtin_clz((DA9062AA_BUCK4_ILIM_MASK)) - 1),
 824        },
 825        {
 826                .desc.id = DA9062_ID_LDO1,
 827                .desc.name = "DA9062 LDO1",
 828                .desc.of_match = of_match_ptr("ldo1"),
 829                .desc.regulators_node = of_match_ptr("regulators"),
 830                .desc.ops = &da9062_ldo_ops,
 831                .desc.min_uV = (900) * 1000,
 832                .desc.uV_step = (50) * 1000,
 833                .desc.n_voltages = ((3600) - (900))/(50) + 1,
 834                .desc.enable_reg = DA9062AA_LDO1_CONT,
 835                .desc.enable_mask = DA9062AA_LDO1_EN_MASK,
 836                .desc.vsel_reg = DA9062AA_VLDO1_A,
 837                .desc.vsel_mask = DA9062AA_VLDO1_A_MASK,
 838                .desc.linear_min_sel = 0,
 839                .sleep = REG_FIELD(DA9062AA_VLDO1_A,
 840                        __builtin_ffs((int)DA9062AA_LDO1_SL_A_MASK) - 1,
 841                        sizeof(unsigned int) * 8 -
 842                        __builtin_clz((DA9062AA_LDO1_SL_A_MASK)) - 1),
 843                .suspend_sleep = REG_FIELD(DA9062AA_VLDO1_B,
 844                        __builtin_ffs((int)DA9062AA_LDO1_SL_B_MASK) - 1,
 845                        sizeof(unsigned int) * 8 -
 846                        __builtin_clz((DA9062AA_LDO1_SL_B_MASK)) - 1),
 847                .suspend_vsel_reg = DA9062AA_VLDO1_B,
 848                .suspend = REG_FIELD(DA9062AA_DVC_1,
 849                        __builtin_ffs((int)DA9062AA_VLDO1_SEL_MASK) - 1,
 850                        sizeof(unsigned int) * 8 -
 851                        __builtin_clz((DA9062AA_VLDO1_SEL_MASK)) - 1),
 852                .oc_event = REG_FIELD(DA9062AA_STATUS_D,
 853                        __builtin_ffs((int)DA9062AA_LDO1_ILIM_MASK) - 1,
 854                        sizeof(unsigned int) * 8 -
 855                        __builtin_clz((DA9062AA_LDO1_ILIM_MASK)) - 1),
 856        },
 857        {
 858                .desc.id = DA9062_ID_LDO2,
 859                .desc.name = "DA9062 LDO2",
 860                .desc.of_match = of_match_ptr("ldo2"),
 861                .desc.regulators_node = of_match_ptr("regulators"),
 862                .desc.ops = &da9062_ldo_ops,
 863                .desc.min_uV = (900) * 1000,
 864                .desc.uV_step = (50) * 1000,
 865                .desc.n_voltages = ((3600) - (600))/(50) + 1,
 866                .desc.enable_reg = DA9062AA_LDO2_CONT,
 867                .desc.enable_mask = DA9062AA_LDO2_EN_MASK,
 868                .desc.vsel_reg = DA9062AA_VLDO2_A,
 869                .desc.vsel_mask = DA9062AA_VLDO2_A_MASK,
 870                .desc.linear_min_sel = 0,
 871                .sleep = REG_FIELD(DA9062AA_VLDO2_A,
 872                        __builtin_ffs((int)DA9062AA_LDO2_SL_A_MASK) - 1,
 873                        sizeof(unsigned int) * 8 -
 874                        __builtin_clz((DA9062AA_LDO2_SL_A_MASK)) - 1),
 875                .suspend_sleep = REG_FIELD(DA9062AA_VLDO2_B,
 876                        __builtin_ffs((int)DA9062AA_LDO2_SL_B_MASK) - 1,
 877                        sizeof(unsigned int) * 8 -
 878                        __builtin_clz((DA9062AA_LDO2_SL_B_MASK)) - 1),
 879                .suspend_vsel_reg = DA9062AA_VLDO2_B,
 880                .suspend = REG_FIELD(DA9062AA_DVC_1,
 881                        __builtin_ffs((int)DA9062AA_VLDO2_SEL_MASK) - 1,
 882                        sizeof(unsigned int) * 8 -
 883                        __builtin_clz((DA9062AA_VLDO2_SEL_MASK)) - 1),
 884                .oc_event = REG_FIELD(DA9062AA_STATUS_D,
 885                        __builtin_ffs((int)DA9062AA_LDO2_ILIM_MASK) - 1,
 886                        sizeof(unsigned int) * 8 -
 887                        __builtin_clz((DA9062AA_LDO2_ILIM_MASK)) - 1),
 888        },
 889        {
 890                .desc.id = DA9062_ID_LDO3,
 891                .desc.name = "DA9062 LDO3",
 892                .desc.of_match = of_match_ptr("ldo3"),
 893                .desc.regulators_node = of_match_ptr("regulators"),
 894                .desc.ops = &da9062_ldo_ops,
 895                .desc.min_uV = (900) * 1000,
 896                .desc.uV_step = (50) * 1000,
 897                .desc.n_voltages = ((3600) - (900))/(50) + 1,
 898                .desc.enable_reg = DA9062AA_LDO3_CONT,
 899                .desc.enable_mask = DA9062AA_LDO3_EN_MASK,
 900                .desc.vsel_reg = DA9062AA_VLDO3_A,
 901                .desc.vsel_mask = DA9062AA_VLDO3_A_MASK,
 902                .desc.linear_min_sel = 0,
 903                .sleep = REG_FIELD(DA9062AA_VLDO3_A,
 904                        __builtin_ffs((int)DA9062AA_LDO3_SL_A_MASK) - 1,
 905                        sizeof(unsigned int) * 8 -
 906                        __builtin_clz((DA9062AA_LDO3_SL_A_MASK)) - 1),
 907                .suspend_sleep = REG_FIELD(DA9062AA_VLDO3_B,
 908                        __builtin_ffs((int)DA9062AA_LDO3_SL_B_MASK) - 1,
 909                        sizeof(unsigned int) * 8 -
 910                        __builtin_clz((DA9062AA_LDO3_SL_B_MASK)) - 1),
 911                .suspend_vsel_reg = DA9062AA_VLDO3_B,
 912                .suspend = REG_FIELD(DA9062AA_DVC_1,
 913                        __builtin_ffs((int)DA9062AA_VLDO3_SEL_MASK) - 1,
 914                        sizeof(unsigned int) * 8 -
 915                        __builtin_clz((DA9062AA_VLDO3_SEL_MASK)) - 1),
 916                .oc_event = REG_FIELD(DA9062AA_STATUS_D,
 917                        __builtin_ffs((int)DA9062AA_LDO3_ILIM_MASK) - 1,
 918                        sizeof(unsigned int) * 8 -
 919                        __builtin_clz((DA9062AA_LDO3_ILIM_MASK)) - 1),
 920        },
 921        {
 922                .desc.id = DA9062_ID_LDO4,
 923                .desc.name = "DA9062 LDO4",
 924                .desc.of_match = of_match_ptr("ldo4"),
 925                .desc.regulators_node = of_match_ptr("regulators"),
 926                .desc.ops = &da9062_ldo_ops,
 927                .desc.min_uV = (900) * 1000,
 928                .desc.uV_step = (50) * 1000,
 929                .desc.n_voltages = ((3600) - (900))/(50) + 1,
 930                .desc.enable_reg = DA9062AA_LDO4_CONT,
 931                .desc.enable_mask = DA9062AA_LDO4_EN_MASK,
 932                .desc.vsel_reg = DA9062AA_VLDO4_A,
 933                .desc.vsel_mask = DA9062AA_VLDO4_A_MASK,
 934                .desc.linear_min_sel = 0,
 935                .sleep = REG_FIELD(DA9062AA_VLDO4_A,
 936                        __builtin_ffs((int)DA9062AA_LDO4_SL_A_MASK) - 1,
 937                        sizeof(unsigned int) * 8 -
 938                        __builtin_clz((DA9062AA_LDO4_SL_A_MASK)) - 1),
 939                .suspend_sleep = REG_FIELD(DA9062AA_VLDO4_B,
 940                        __builtin_ffs((int)DA9062AA_LDO4_SL_B_MASK) - 1,
 941                        sizeof(unsigned int) * 8 -
 942                        __builtin_clz((DA9062AA_LDO4_SL_B_MASK)) - 1),
 943                .suspend_vsel_reg = DA9062AA_VLDO4_B,
 944                .suspend = REG_FIELD(DA9062AA_DVC_1,
 945                        __builtin_ffs((int)DA9062AA_VLDO4_SEL_MASK) - 1,
 946                        sizeof(unsigned int) * 8 -
 947                        __builtin_clz((DA9062AA_VLDO4_SEL_MASK)) - 1),
 948                .oc_event = REG_FIELD(DA9062AA_STATUS_D,
 949                        __builtin_ffs((int)DA9062AA_LDO4_ILIM_MASK) - 1,
 950                        sizeof(unsigned int) * 8 -
 951                        __builtin_clz((DA9062AA_LDO4_ILIM_MASK)) - 1),
 952        },
 953};
 954
 955/* Regulator interrupt handlers */
 956static irqreturn_t da9062_ldo_lim_event(int irq, void *data)
 957{
 958        struct da9062_regulators *regulators = data;
 959        struct da9062 *hw = regulators->regulator[0].hw;
 960        struct da9062_regulator *regl;
 961        int handled = IRQ_NONE;
 962        int bits, i, ret;
 963
 964        ret = regmap_read(hw->regmap, DA9062AA_STATUS_D, &bits);
 965        if (ret < 0) {
 966                dev_err(hw->dev,
 967                        "Failed to read LDO overcurrent indicator\n");
 968                goto ldo_lim_error;
 969        }
 970
 971        for (i = regulators->n_regulators - 1; i >= 0; i--) {
 972                regl = &regulators->regulator[i];
 973                if (regl->info->oc_event.reg != DA9062AA_STATUS_D)
 974                        continue;
 975
 976                if (BIT(regl->info->oc_event.lsb) & bits) {
 977                        regulator_notifier_call_chain(regl->rdev,
 978                                        REGULATOR_EVENT_OVER_CURRENT, NULL);
 979                        handled = IRQ_HANDLED;
 980                }
 981        }
 982
 983ldo_lim_error:
 984        return handled;
 985}
 986
 987static int da9062_regulator_probe(struct platform_device *pdev)
 988{
 989        struct da9062 *chip = dev_get_drvdata(pdev->dev.parent);
 990        struct da9062_regulators *regulators;
 991        struct da9062_regulator *regl;
 992        struct regulator_config config = { };
 993        const struct da9062_regulator_info *rinfo;
 994        int irq, n, ret;
 995        size_t size;
 996        int max_regulators;
 997
 998        switch (chip->chip_type) {
 999        case COMPAT_TYPE_DA9061:
1000                max_regulators = DA9061_MAX_REGULATORS;
1001                rinfo = local_da9061_regulator_info;
1002                break;
1003        case COMPAT_TYPE_DA9062:
1004                max_regulators = DA9062_MAX_REGULATORS;
1005                rinfo = local_da9062_regulator_info;
1006                break;
1007        default:
1008                dev_err(chip->dev, "Unrecognised chip type\n");
1009                return -ENODEV;
1010        }
1011
1012        /* Allocate memory required by usable regulators */
1013        size = sizeof(struct da9062_regulators) +
1014                max_regulators * sizeof(struct da9062_regulator);
1015        regulators = devm_kzalloc(&pdev->dev, size, GFP_KERNEL);
1016        if (!regulators)
1017                return -ENOMEM;
1018
1019        regulators->n_regulators = max_regulators;
1020        platform_set_drvdata(pdev, regulators);
1021
1022        n = 0;
1023        while (n < regulators->n_regulators) {
1024                /* Initialise regulator structure */
1025                regl = &regulators->regulator[n];
1026                regl->hw = chip;
1027                regl->info = &rinfo[n];
1028                regl->desc = regl->info->desc;
1029                regl->desc.type = REGULATOR_VOLTAGE;
1030                regl->desc.owner = THIS_MODULE;
1031
1032                if (regl->info->mode.reg)
1033                        regl->mode = devm_regmap_field_alloc(
1034                                        &pdev->dev,
1035                                        chip->regmap,
1036                                        regl->info->mode);
1037                if (regl->info->suspend.reg)
1038                        regl->suspend = devm_regmap_field_alloc(
1039                                        &pdev->dev,
1040                                        chip->regmap,
1041                                        regl->info->suspend);
1042                if (regl->info->sleep.reg)
1043                        regl->sleep = devm_regmap_field_alloc(
1044                                        &pdev->dev,
1045                                        chip->regmap,
1046                                        regl->info->sleep);
1047                if (regl->info->suspend_sleep.reg)
1048                        regl->suspend_sleep = devm_regmap_field_alloc(
1049                                        &pdev->dev,
1050                                        chip->regmap,
1051                                        regl->info->suspend_sleep);
1052                if (regl->info->ilimit.reg)
1053                        regl->ilimit = devm_regmap_field_alloc(
1054                                        &pdev->dev,
1055                                        chip->regmap,
1056                                        regl->info->ilimit);
1057
1058                /* Register regulator */
1059                memset(&config, 0, sizeof(config));
1060                config.dev = chip->dev;
1061                config.driver_data = regl;
1062                config.regmap = chip->regmap;
1063
1064                regl->rdev = devm_regulator_register(&pdev->dev, &regl->desc,
1065                                                     &config);
1066                if (IS_ERR(regl->rdev)) {
1067                        dev_err(&pdev->dev,
1068                                "Failed to register %s regulator\n",
1069                                regl->desc.name);
1070                        return PTR_ERR(regl->rdev);
1071                }
1072
1073                n++;
1074        }
1075
1076        /* LDOs overcurrent event support */
1077        irq = platform_get_irq_byname(pdev, "LDO_LIM");
1078        if (irq < 0) {
1079                dev_err(&pdev->dev, "Failed to get IRQ.\n");
1080                return irq;
1081        }
1082        regulators->irq_ldo_lim = irq;
1083
1084        ret = devm_request_threaded_irq(&pdev->dev, irq,
1085                                        NULL, da9062_ldo_lim_event,
1086                                        IRQF_TRIGGER_LOW | IRQF_ONESHOT,
1087                                        "LDO_LIM", regulators);
1088        if (ret) {
1089                dev_warn(&pdev->dev,
1090                         "Failed to request LDO_LIM IRQ.\n");
1091                regulators->irq_ldo_lim = -ENXIO;
1092        }
1093
1094        return 0;
1095}
1096
1097static struct platform_driver da9062_regulator_driver = {
1098        .driver = {
1099                .name = "da9062-regulators",
1100        },
1101        .probe = da9062_regulator_probe,
1102};
1103
1104static int __init da9062_regulator_init(void)
1105{
1106        return platform_driver_register(&da9062_regulator_driver);
1107}
1108subsys_initcall(da9062_regulator_init);
1109
1110static void __exit da9062_regulator_cleanup(void)
1111{
1112        platform_driver_unregister(&da9062_regulator_driver);
1113}
1114module_exit(da9062_regulator_cleanup);
1115
1116/* Module information */
1117MODULE_AUTHOR("S Twiss <stwiss.opensource@diasemi.com>");
1118MODULE_DESCRIPTION("REGULATOR device driver for Dialog DA9062 and DA9061");
1119MODULE_LICENSE("GPL");
1120MODULE_ALIAS("platform:da9062-regulators");
1121