drivers/regulator/da9062-regulator.c

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