drivers/regulator/da9062-regulator.c

   1 /*
   2  * da9062-regulator.c - REGULATOR device driver for DA9062
   3  * Copyright (C) 2015  Dialog Semiconductor Ltd.
   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 */
  30 enum {
  31         DA9062_ID_BUCK1,
  32         DA9062_ID_BUCK2,
  33         DA9062_ID_BUCK3,
  34         DA9062_ID_BUCK4,
  35         DA9062_ID_LDO1,
  36         DA9062_ID_LDO2,
  37         DA9062_ID_LDO3,
  38         DA9062_ID_LDO4,
  39         DA9062_MAX_REGULATORS,
  40 };
  41
  42 /* Regulator capabilities and registers description */
  43 struct da9062_regulator_info {
  44         struct regulator_desc desc;
  45         /* Current limiting */
  46         unsigned int n_current_limits;
  47         const int *current_limits;
  48         /* Main register fields */
  49         struct reg_field mode;
  50         struct reg_field suspend;
  51         struct reg_field sleep;
  52         struct reg_field suspend_sleep;
  53         unsigned int suspend_vsel_reg;
  54         struct reg_field ilimit;
  55         /* Event detection bit */
  56         struct reg_field oc_event;
  57 };
  58
  59 /* Single regulator settings */
  60 struct da9062_regulator {
  61         struct regulator_desc                   desc;
  62         struct regulator_dev                    *rdev;
  63         struct da9062                           *hw;
  64         const struct da9062_regulator_info      *info;
  65
  66         struct regmap_field                     *mode;
  67         struct regmap_field                     *suspend;
  68         struct regmap_field                     *sleep;
  69         struct regmap_field                     *suspend_sleep;
  70         struct regmap_field                     *ilimit;
  71 };
  72
  73 /* Encapsulates all information for the regulators driver */
  74 struct da9062_regulators {
  75         int                                     irq_ldo_lim;
  76         unsigned                                n_regulators;
  77         /* Array size to be defined during init. Keep at end. */
  78         struct da9062_regulator                 regulator[0];
  79 };
  80
  81 /* BUCK modes */
  82 enum {
  83         BUCK_MODE_MANUAL,       /* 0 */
  84         BUCK_MODE_SLEEP,        /* 1 */
  85         BUCK_MODE_SYNC,         /* 2 */
  86         BUCK_MODE_AUTO          /* 3 */
  87 };
  88
  89 /* Regulator operations */
  90
  91 /* Current limits array (in uA) BUCK1 and BUCK3.
  92    Entry indexes corresponds to register values. */
  93 static const 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) for BUCK2.
  99    Entry indexes corresponds to register values. */
 100 static const int da9062_buck_b_limits[] = {
 101         1500000, 1600000, 1700000, 1800000, 1900000, 2000000, 2100000, 2200000,
 102         2300000, 2400000, 2500000, 2600000, 2700000, 2800000, 2900000, 3000000
 103 };
 104
 105 static int da9062_set_current_limit(struct regulator_dev *rdev,
 106                                     int min_ua, int max_ua)
 107 {
 108         struct da9062_regulator *regl = rdev_get_drvdata(rdev);
 109         const struct da9062_regulator_info *rinfo = regl->info;
 110         int n, tval;
 111
 112         for (n = 0; n < rinfo->n_current_limits; n++) {
 113                 tval = rinfo->current_limits[n];
 114                 if (tval >= min_ua && tval <= max_ua)
 115                         return regmap_field_write(regl->ilimit, n);
 116         }
 117
 118         return -EINVAL;
 119 }
 120
 121 static int da9062_get_current_limit(struct regulator_dev *rdev)
 122 {
 123         struct da9062_regulator *regl = rdev_get_drvdata(rdev);
 124         const struct da9062_regulator_info *rinfo = regl->info;
 125         unsigned int sel;
 126         int ret;
 127
 128         ret = regmap_field_read(regl->ilimit, &sel);
 129         if (ret < 0)
 130                 return ret;
 131
 132         if (sel >= rinfo->n_current_limits)
 133                 sel = rinfo->n_current_limits - 1;
 134
 135         return rinfo->current_limits[sel];
 136 }
 137
 138 static int da9062_buck_set_mode(struct regulator_dev *rdev, unsigned mode)
 139 {
 140         struct da9062_regulator *regl = rdev_get_drvdata(rdev);
 141         unsigned val;
 142
 143         switch (mode) {
 144         case REGULATOR_MODE_FAST:
 145                 val = BUCK_MODE_SYNC;
 146                 break;
 147         case REGULATOR_MODE_NORMAL:
 148                 val = BUCK_MODE_AUTO;
 149                 break;
 150         case REGULATOR_MODE_STANDBY:
 151                 val = BUCK_MODE_SLEEP;
 152                 break;
 153         default:
 154                 return -EINVAL;
 155         }
 156
 157         return regmap_field_write(regl->mode, val);
 158 }
 159
 160 /*
 161  * Bucks use single mode register field for normal operation
 162  * and suspend state.
 163  * There are 3 modes to map to: FAST, NORMAL, and STANDBY.
 164  */
 165
 166 static unsigned da9062_buck_get_mode(struct regulator_dev *rdev)
 167 {
 168         struct da9062_regulator *regl = rdev_get_drvdata(rdev);
 169         struct regmap_field *field;
 170         unsigned int val, mode = 0;
 171         int ret;
 172
 173         ret = regmap_field_read(regl->mode, &val);
 174         if (ret < 0)
 175                 return ret;
 176
 177         switch (val) {
 178         default:
 179         case BUCK_MODE_MANUAL:
 180                 mode = REGULATOR_MODE_FAST | REGULATOR_MODE_STANDBY;
 181                 /* Sleep flag bit decides the mode */
 182                 break;
 183         case BUCK_MODE_SLEEP:
 184                 return REGULATOR_MODE_STANDBY;
 185         case BUCK_MODE_SYNC:
 186                 return REGULATOR_MODE_FAST;
 187         case BUCK_MODE_AUTO:
 188                 return REGULATOR_MODE_NORMAL;
 189         }
 190
 191         /* Detect current regulator state */
 192         ret = regmap_field_read(regl->suspend, &val);
 193         if (ret < 0)
 194                 return 0;
 195
 196         /* Read regulator mode from proper register, depending on state */
 197         if (val)
 198                 field = regl->suspend_sleep;
 199         else
 200                 field = regl->sleep;
 201
 202         ret = regmap_field_read(field, &val);
 203         if (ret < 0)
 204                 return 0;
 205
 206         if (val)
 207                 mode &= REGULATOR_MODE_STANDBY;
 208         else
 209                 mode &= REGULATOR_MODE_NORMAL | REGULATOR_MODE_FAST;
 210
 211         return mode;
 212 }
 213
 214 /*
 215  * LDOs use sleep flags - one for normal and one for suspend state.
 216  * There are 2 modes to map to: NORMAL and STANDBY (sleep) for each state.
 217  */
 218
 219 static int da9062_ldo_set_mode(struct regulator_dev *rdev, unsigned mode)
 220 {
 221         struct da9062_regulator *regl = rdev_get_drvdata(rdev);
 222         unsigned val;
 223
 224         switch (mode) {
 225         case REGULATOR_MODE_NORMAL:
 226                 val = 0;
 227                 break;
 228         case REGULATOR_MODE_STANDBY:
 229                 val = 1;
 230                 break;
 231         default:
 232                 return -EINVAL;
 233         }
 234
 235         return regmap_field_write(regl->sleep, val);
 236 }
 237
 238 static unsigned da9062_ldo_get_mode(struct regulator_dev *rdev)
 239 {
 240         struct da9062_regulator *regl = rdev_get_drvdata(rdev);
 241         struct regmap_field *field;
 242         int ret, val;
 243
 244         /* Detect current regulator state */
 245         ret = regmap_field_read(regl->suspend, &val);
 246         if (ret < 0)
 247                 return 0;
 248
 249         /* Read regulator mode from proper register, depending on state */
 250         if (val)
 251                 field = regl->suspend_sleep;
 252         else
 253                 field = regl->sleep;
 254
 255         ret = regmap_field_read(field, &val);
 256         if (ret < 0)
 257                 return 0;
 258
 259         if (val)
 260                 return REGULATOR_MODE_STANDBY;
 261         else
 262                 return REGULATOR_MODE_NORMAL;
 263 }
 264
 265 static int da9062_buck_get_status(struct regulator_dev *rdev)
 266 {
 267         int ret = regulator_is_enabled_regmap(rdev);
 268
 269         if (ret == 0) {
 270                 ret = REGULATOR_STATUS_OFF;
 271         } else if (ret > 0) {
 272                 ret = da9062_buck_get_mode(rdev);
 273                 if (ret > 0)
 274                         ret = regulator_mode_to_status(ret);
 275                 else if (ret == 0)
 276                         ret = -EIO;
 277         }
 278
 279         return ret;
 280 }
 281
 282 static int da9062_ldo_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_ldo_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
 299 static int da9062_set_suspend_voltage(struct regulator_dev *rdev, int uv)
 300 {
 301         struct da9062_regulator *regl = rdev_get_drvdata(rdev);
 302         const struct da9062_regulator_info *rinfo = regl->info;
 303         int ret, sel;
 304
 305         sel = regulator_map_voltage_linear(rdev, uv, uv);
 306         if (sel < 0)
 307                 return sel;
 308
 309         sel <<= ffs(rdev->desc->vsel_mask) - 1;
 310
 311         ret = regmap_update_bits(regl->hw->regmap, rinfo->suspend_vsel_reg,
 312                                  rdev->desc->vsel_mask, sel);
 313
 314         return ret;
 315 }
 316
 317 static int da9062_suspend_enable(struct regulator_dev *rdev)
 318 {
 319         struct da9062_regulator *regl = rdev_get_drvdata(rdev);
 320
 321         return regmap_field_write(regl->suspend, 1);
 322 }
 323
 324 static int da9062_suspend_disable(struct regulator_dev *rdev)
 325 {
 326         struct da9062_regulator *regl = rdev_get_drvdata(rdev);
 327
 328         return regmap_field_write(regl->suspend, 0);
 329 }
 330
 331 static int da9062_buck_set_suspend_mode(struct regulator_dev *rdev,
 332                                         unsigned mode)
 333 {
 334         struct da9062_regulator *regl = rdev_get_drvdata(rdev);
 335         int val;
 336
 337         switch (mode) {
 338         case REGULATOR_MODE_FAST:
 339                 val = BUCK_MODE_SYNC;
 340                 break;
 341         case REGULATOR_MODE_NORMAL:
 342                 val = BUCK_MODE_AUTO;
 343                 break;
 344         case REGULATOR_MODE_STANDBY:
 345                 val = BUCK_MODE_SLEEP;
 346                 break;
 347         default:
 348                 return -EINVAL;
 349         }
 350
 351         return regmap_field_write(regl->mode, val);
 352 }
 353
 354 static int da9062_ldo_set_suspend_mode(struct regulator_dev *rdev,
 355                                                 unsigned mode)
 356 {
 357         struct da9062_regulator *regl = rdev_get_drvdata(rdev);
 358         unsigned val;
 359
 360         switch (mode) {
 361         case REGULATOR_MODE_NORMAL:
 362                 val = 0;
 363                 break;
 364         case REGULATOR_MODE_STANDBY:
 365                 val = 1;
 366                 break;
 367         default:
 368                 return -EINVAL;
 369         }
 370
 371         return regmap_field_write(regl->suspend_sleep, val);
 372 }
 373
 374 static struct regulator_ops da9062_buck_ops = {
 375         .enable                 = regulator_enable_regmap,
 376         .disable                = regulator_disable_regmap,
 377         .is_enabled             = regulator_is_enabled_regmap,
 378         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
 379         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
 380         .list_voltage           = regulator_list_voltage_linear,
 381         .set_current_limit      = da9062_set_current_limit,
 382         .get_current_limit      = da9062_get_current_limit,
 383         .set_mode               = da9062_buck_set_mode,
 384         .get_mode               = da9062_buck_get_mode,
 385         .get_status             = da9062_buck_get_status,
 386         .set_suspend_voltage    = da9062_set_suspend_voltage,
 387         .set_suspend_enable     = da9062_suspend_enable,
 388         .set_suspend_disable    = da9062_suspend_disable,
 389         .set_suspend_mode       = da9062_buck_set_suspend_mode,
 390 };
 391
 392 static struct regulator_ops da9062_ldo_ops = {
 393         .enable                 = regulator_enable_regmap,
 394         .disable                = regulator_disable_regmap,
 395         .is_enabled             = regulator_is_enabled_regmap,
 396         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
 397         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
 398         .list_voltage           = regulator_list_voltage_linear,
 399         .set_mode               = da9062_ldo_set_mode,
 400         .get_mode               = da9062_ldo_get_mode,
 401         .get_status             = da9062_ldo_get_status,
 402         .set_suspend_voltage    = da9062_set_suspend_voltage,
 403         .set_suspend_enable     = da9062_suspend_enable,
 404         .set_suspend_disable    = da9062_suspend_disable,
 405         .set_suspend_mode       = da9062_ldo_set_suspend_mode,
 406 };
 407
 408 /* Regulator information */
 409 static const struct da9062_regulator_info local_regulator_info[] = {
 410         {
 411                 .desc.id = DA9062_ID_BUCK1,
 412                 .desc.name = "DA9062 BUCK1",
 413                 .desc.of_match = of_match_ptr("buck1"),
 414                 .desc.regulators_node = of_match_ptr("regulators"),
 415                 .desc.ops = &da9062_buck_ops,
 416                 .desc.min_uV = (300) * 1000,
 417                 .desc.uV_step = (10) * 1000,
 418                 .desc.n_voltages = ((1570) - (300))/(10) + 1,
 419                 .current_limits = da9062_buck_a_limits,
 420                 .n_current_limits = ARRAY_SIZE(da9062_buck_a_limits),
 421                 .desc.enable_reg = DA9062AA_BUCK1_CONT,
 422                 .desc.enable_mask = DA9062AA_BUCK1_EN_MASK,
 423                 .desc.vsel_reg = DA9062AA_VBUCK1_A,
 424                 .desc.vsel_mask = DA9062AA_VBUCK1_A_MASK,
 425                 .desc.linear_min_sel = 0,
 426                 .sleep = REG_FIELD(DA9062AA_VBUCK1_A,
 427                         __builtin_ffs((int)DA9062AA_BUCK1_SL_A_MASK) - 1,
 428                         sizeof(unsigned int) * 8 -
 429                         __builtin_clz((DA9062AA_BUCK1_SL_A_MASK)) - 1),
 430                 .suspend_sleep = REG_FIELD(DA9062AA_VBUCK1_B,
 431                         __builtin_ffs((int)DA9062AA_BUCK1_SL_B_MASK) - 1,
 432                         sizeof(unsigned int) * 8 -
 433                         __builtin_clz((DA9062AA_BUCK1_SL_B_MASK)) - 1),
 434                 .suspend_vsel_reg = DA9062AA_VBUCK1_B,
 435                 .mode = REG_FIELD(DA9062AA_BUCK1_CFG,
 436                         __builtin_ffs((int)DA9062AA_BUCK1_MODE_MASK) - 1,
 437                         sizeof(unsigned int) * 8 -
 438                         __builtin_clz((DA9062AA_BUCK1_MODE_MASK)) - 1),
 439                 .suspend = REG_FIELD(DA9062AA_DVC_1,
 440                         __builtin_ffs((int)DA9062AA_VBUCK1_SEL_MASK) - 1,
 441                         sizeof(unsigned int) * 8 -
 442                         __builtin_clz((DA9062AA_VBUCK1_SEL_MASK)) - 1),
 443                 .ilimit = REG_FIELD(DA9062AA_BUCK_ILIM_C,
 444                         __builtin_ffs((int)DA9062AA_BUCK1_ILIM_MASK) - 1,
 445                         sizeof(unsigned int) * 8 -
 446                         __builtin_clz((DA9062AA_BUCK1_ILIM_MASK)) - 1),
 447         },
 448         {
 449                 .desc.id = DA9062_ID_BUCK2,
 450                 .desc.name = "DA9062 BUCK2",
 451                 .desc.of_match = of_match_ptr("buck2"),
 452                 .desc.regulators_node = of_match_ptr("regulators"),
 453                 .desc.ops = &da9062_buck_ops,
 454                 .desc.min_uV = (300) * 1000,
 455                 .desc.uV_step = (10) * 1000,
 456                 .desc.n_voltages = ((1570) - (300))/(10) + 1,
 457                 .current_limits = da9062_buck_a_limits,
 458                 .n_current_limits = ARRAY_SIZE(da9062_buck_a_limits),
 459                 .desc.enable_reg = DA9062AA_BUCK2_CONT,
 460                 .desc.enable_mask = DA9062AA_BUCK2_EN_MASK,
 461                 .desc.vsel_reg = DA9062AA_VBUCK2_A,
 462                 .desc.vsel_mask = DA9062AA_VBUCK2_A_MASK,
 463                 .desc.linear_min_sel = 0,
 464                 .sleep = REG_FIELD(DA9062AA_VBUCK2_A,
 465                         __builtin_ffs((int)DA9062AA_BUCK2_SL_A_MASK) - 1,
 466                         sizeof(unsigned int) * 8 -
 467                         __builtin_clz((DA9062AA_BUCK2_SL_A_MASK)) - 1),
 468                 .suspend_sleep = REG_FIELD(DA9062AA_VBUCK2_B,
 469                         __builtin_ffs((int)DA9062AA_BUCK2_SL_B_MASK) - 1,
 470                         sizeof(unsigned int) * 8 -
 471                         __builtin_clz((DA9062AA_BUCK2_SL_B_MASK)) - 1),
 472                 .suspend_vsel_reg = DA9062AA_VBUCK2_B,
 473                 .mode = REG_FIELD(DA9062AA_BUCK2_CFG,
 474                         __builtin_ffs((int)DA9062AA_BUCK2_MODE_MASK) - 1,
 475                         sizeof(unsigned int) * 8 -
 476                         __builtin_clz((DA9062AA_BUCK2_MODE_MASK)) - 1),
 477                 .suspend = REG_FIELD(DA9062AA_DVC_1,
 478                         __builtin_ffs((int)DA9062AA_VBUCK2_SEL_MASK) - 1,
 479                         sizeof(unsigned int) * 8 -
 480                         __builtin_clz((DA9062AA_VBUCK2_SEL_MASK)) - 1),
 481                 .ilimit = REG_FIELD(DA9062AA_BUCK_ILIM_C,
 482                         __builtin_ffs((int)DA9062AA_BUCK2_ILIM_MASK) - 1,
 483                         sizeof(unsigned int) * 8 -
 484                         __builtin_clz((DA9062AA_BUCK2_ILIM_MASK)) - 1),
 485         },
 486         {
 487                 .desc.id = DA9062_ID_BUCK3,
 488                 .desc.name = "DA9062 BUCK3",
 489                 .desc.of_match = of_match_ptr("buck3"),
 490                 .desc.regulators_node = of_match_ptr("regulators"),
 491                 .desc.ops = &da9062_buck_ops,
 492                 .desc.min_uV = (800) * 1000,
 493                 .desc.uV_step = (20) * 1000,
 494                 .desc.n_voltages = ((3340) - (800))/(20) + 1,
 495                 .current_limits = da9062_buck_b_limits,
 496                 .n_current_limits = ARRAY_SIZE(da9062_buck_b_limits),
 497                 .desc.enable_reg = DA9062AA_BUCK3_CONT,
 498                 .desc.enable_mask = DA9062AA_BUCK3_EN_MASK,
 499                 .desc.vsel_reg = DA9062AA_VBUCK3_A,
 500                 .desc.vsel_mask = DA9062AA_VBUCK3_A_MASK,
 501                 .desc.linear_min_sel = 0,
 502                 .sleep = REG_FIELD(DA9062AA_VBUCK3_A,
 503                         __builtin_ffs((int)DA9062AA_BUCK3_SL_A_MASK) - 1,
 504                         sizeof(unsigned int) * 8 -
 505                         __builtin_clz((DA9062AA_BUCK3_SL_A_MASK)) - 1),
 506                 .suspend_sleep = REG_FIELD(DA9062AA_VBUCK3_B,
 507                         __builtin_ffs((int)DA9062AA_BUCK3_SL_B_MASK) - 1,
 508                         sizeof(unsigned int) * 8 -
 509                         __builtin_clz((DA9062AA_BUCK3_SL_B_MASK)) - 1),
 510                 .suspend_vsel_reg = DA9062AA_VBUCK3_B,
 511                 .mode = REG_FIELD(DA9062AA_BUCK3_CFG,
 512                         __builtin_ffs((int)DA9062AA_BUCK3_MODE_MASK) - 1,
 513                         sizeof(unsigned int) * 8 -
 514                         __builtin_clz((DA9062AA_BUCK3_MODE_MASK)) - 1),
 515                 .suspend = REG_FIELD(DA9062AA_DVC_1,
 516                         __builtin_ffs((int)DA9062AA_VBUCK3_SEL_MASK) - 1,
 517                         sizeof(unsigned int) * 8 -
 518                         __builtin_clz((DA9062AA_VBUCK3_SEL_MASK)) - 1),
 519                 .ilimit = REG_FIELD(DA9062AA_BUCK_ILIM_A,
 520                         __builtin_ffs((int)DA9062AA_BUCK3_ILIM_MASK) - 1,
 521                         sizeof(unsigned int) * 8 -
 522                         __builtin_clz((DA9062AA_BUCK3_ILIM_MASK)) - 1),
 523         },
 524         {
 525                 .desc.id = DA9062_ID_BUCK4,
 526                 .desc.name = "DA9062 BUCK4",
 527                 .desc.of_match = of_match_ptr("buck4"),
 528                 .desc.regulators_node = of_match_ptr("regulators"),
 529                 .desc.ops = &da9062_buck_ops,
 530                 .desc.min_uV = (530) * 1000,
 531                 .desc.uV_step = (10) * 1000,
 532                 .desc.n_voltages = ((1800) - (530))/(10) + 1,
 533                 .current_limits = da9062_buck_a_limits,
 534                 .n_current_limits = ARRAY_SIZE(da9062_buck_a_limits),
 535                 .desc.enable_reg = DA9062AA_BUCK4_CONT,
 536                 .desc.enable_mask = DA9062AA_BUCK4_EN_MASK,
 537                 .desc.vsel_reg = DA9062AA_VBUCK4_A,
 538                 .desc.vsel_mask = DA9062AA_VBUCK4_A_MASK,
 539                 .desc.linear_min_sel = 0,
 540                 .sleep = REG_FIELD(DA9062AA_VBUCK4_A,
 541                         __builtin_ffs((int)DA9062AA_BUCK4_SL_A_MASK) - 1,
 542                         sizeof(unsigned int) * 8 -
 543                         __builtin_clz((DA9062AA_BUCK4_SL_A_MASK)) - 1),
 544                 .suspend_sleep = REG_FIELD(DA9062AA_VBUCK4_B,
 545                         __builtin_ffs((int)DA9062AA_BUCK4_SL_B_MASK) - 1,
 546                         sizeof(unsigned int) * 8 -
 547                         __builtin_clz((DA9062AA_BUCK4_SL_B_MASK)) - 1),
 548                 .suspend_vsel_reg = DA9062AA_VBUCK4_B,
 549                 .mode = REG_FIELD(DA9062AA_BUCK4_CFG,
 550                         __builtin_ffs((int)DA9062AA_BUCK4_MODE_MASK) - 1,
 551                         sizeof(unsigned int) * 8 -
 552                         __builtin_clz((DA9062AA_BUCK4_MODE_MASK)) - 1),
 553                 .suspend = REG_FIELD(DA9062AA_DVC_1,
 554                         __builtin_ffs((int)DA9062AA_VBUCK4_SEL_MASK) - 1,
 555                         sizeof(unsigned int) * 8 -
 556                         __builtin_clz((DA9062AA_VBUCK4_SEL_MASK)) - 1),
 557                 .ilimit = REG_FIELD(DA9062AA_BUCK_ILIM_B,
 558                         __builtin_ffs((int)DA9062AA_BUCK4_ILIM_MASK) - 1,
 559                         sizeof(unsigned int) * 8 -
 560                         __builtin_clz((DA9062AA_BUCK4_ILIM_MASK)) - 1),
 561         },
 562         {
 563                 .desc.id = DA9062_ID_LDO1,
 564                 .desc.name = "DA9062 LDO1",
 565                 .desc.of_match = of_match_ptr("ldo1"),
 566                 .desc.regulators_node = of_match_ptr("regulators"),
 567                 .desc.ops = &da9062_ldo_ops,
 568                 .desc.min_uV = (900) * 1000,
 569                 .desc.uV_step = (50) * 1000,
 570                 .desc.n_voltages = ((3600) - (900))/(50) + 1,
 571                 .desc.enable_reg = DA9062AA_LDO1_CONT,
 572                 .desc.enable_mask = DA9062AA_LDO1_EN_MASK,
 573                 .desc.vsel_reg = DA9062AA_VLDO1_A,
 574                 .desc.vsel_mask = DA9062AA_VLDO1_A_MASK,
 575                 .desc.linear_min_sel = 0,
 576                 .sleep = REG_FIELD(DA9062AA_VLDO1_A,
 577                         __builtin_ffs((int)DA9062AA_LDO1_SL_A_MASK) - 1,
 578                         sizeof(unsigned int) * 8 -
 579                         __builtin_clz((DA9062AA_LDO1_SL_A_MASK)) - 1),
 580                 .suspend_sleep = REG_FIELD(DA9062AA_VLDO1_B,
 581                         __builtin_ffs((int)DA9062AA_LDO1_SL_B_MASK) - 1,
 582                         sizeof(unsigned int) * 8 -
 583                         __builtin_clz((DA9062AA_LDO1_SL_B_MASK)) - 1),
 584                 .suspend_vsel_reg = DA9062AA_VLDO1_B,
 585                 .suspend = REG_FIELD(DA9062AA_DVC_1,
 586                         __builtin_ffs((int)DA9062AA_VLDO1_SEL_MASK) - 1,
 587                         sizeof(unsigned int) * 8 -
 588                         __builtin_clz((DA9062AA_VLDO1_SEL_MASK)) - 1),
 589                 .oc_event = REG_FIELD(DA9062AA_STATUS_D,
 590                         __builtin_ffs((int)DA9062AA_LDO1_ILIM_MASK) - 1,
 591                         sizeof(unsigned int) * 8 -
 592                         __builtin_clz((DA9062AA_LDO1_ILIM_MASK)) - 1),
 593         },
 594         {
 595                 .desc.id = DA9062_ID_LDO2,
 596                 .desc.name = "DA9062 LDO2",
 597                 .desc.of_match = of_match_ptr("ldo2"),
 598                 .desc.regulators_node = of_match_ptr("regulators"),
 599                 .desc.ops = &da9062_ldo_ops,
 600                 .desc.min_uV = (900) * 1000,
 601                 .desc.uV_step = (50) * 1000,
 602                 .desc.n_voltages = ((3600) - (600))/(50) + 1,
 603                 .desc.enable_reg = DA9062AA_LDO2_CONT,
 604                 .desc.enable_mask = DA9062AA_LDO2_EN_MASK,
 605                 .desc.vsel_reg = DA9062AA_VLDO2_A,
 606                 .desc.vsel_mask = DA9062AA_VLDO2_A_MASK,
 607                 .desc.linear_min_sel = 0,
 608                 .sleep = REG_FIELD(DA9062AA_VLDO2_A,
 609                         __builtin_ffs((int)DA9062AA_LDO2_SL_A_MASK) - 1,
 610                         sizeof(unsigned int) * 8 -
 611                         __builtin_clz((DA9062AA_LDO2_SL_A_MASK)) - 1),
 612                 .suspend_sleep = REG_FIELD(DA9062AA_VLDO2_B,
 613                         __builtin_ffs((int)DA9062AA_LDO2_SL_B_MASK) - 1,
 614                         sizeof(unsigned int) * 8 -
 615                         __builtin_clz((DA9062AA_LDO2_SL_B_MASK)) - 1),
 616                 .suspend_vsel_reg = DA9062AA_VLDO2_B,
 617                 .suspend = REG_FIELD(DA9062AA_DVC_1,
 618                         __builtin_ffs((int)DA9062AA_VLDO2_SEL_MASK) - 1,
 619                         sizeof(unsigned int) * 8 -
 620                         __builtin_clz((DA9062AA_VLDO2_SEL_MASK)) - 1),
 621                 .oc_event = REG_FIELD(DA9062AA_STATUS_D,
 622                         __builtin_ffs((int)DA9062AA_LDO2_ILIM_MASK) - 1,
 623                         sizeof(unsigned int) * 8 -
 624                         __builtin_clz((DA9062AA_LDO2_ILIM_MASK)) - 1),
 625         },
 626         {
 627                 .desc.id = DA9062_ID_LDO3,
 628                 .desc.name = "DA9062 LDO3",
 629                 .desc.of_match = of_match_ptr("ldo3"),
 630                 .desc.regulators_node = of_match_ptr("regulators"),
 631                 .desc.ops = &da9062_ldo_ops,
 632                 .desc.min_uV = (900) * 1000,
 633                 .desc.uV_step = (50) * 1000,
 634                 .desc.n_voltages = ((3600) - (900))/(50) + 1,
 635                 .desc.enable_reg = DA9062AA_LDO3_CONT,
 636                 .desc.enable_mask = DA9062AA_LDO3_EN_MASK,
 637                 .desc.vsel_reg = DA9062AA_VLDO3_A,
 638                 .desc.vsel_mask = DA9062AA_VLDO3_A_MASK,
 639                 .desc.linear_min_sel = 0,
 640                 .sleep = REG_FIELD(DA9062AA_VLDO3_A,
 641                         __builtin_ffs((int)DA9062AA_LDO3_SL_A_MASK) - 1,
 642                         sizeof(unsigned int) * 8 -
 643                         __builtin_clz((DA9062AA_LDO3_SL_A_MASK)) - 1),
 644                 .suspend_sleep = REG_FIELD(DA9062AA_VLDO3_B,
 645                         __builtin_ffs((int)DA9062AA_LDO3_SL_B_MASK) - 1,
 646                         sizeof(unsigned int) * 8 -
 647                         __builtin_clz((DA9062AA_LDO3_SL_B_MASK)) - 1),
 648                 .suspend_vsel_reg = DA9062AA_VLDO3_B,
 649                 .suspend = REG_FIELD(DA9062AA_DVC_1,
 650                         __builtin_ffs((int)DA9062AA_VLDO3_SEL_MASK) - 1,
 651                         sizeof(unsigned int) * 8 -
 652                         __builtin_clz((DA9062AA_VLDO3_SEL_MASK)) - 1),
 653                 .oc_event = REG_FIELD(DA9062AA_STATUS_D,
 654                         __builtin_ffs((int)DA9062AA_LDO3_ILIM_MASK) - 1,
 655                         sizeof(unsigned int) * 8 -
 656                         __builtin_clz((DA9062AA_LDO3_ILIM_MASK)) - 1),
 657         },
 658         {
 659                 .desc.id = DA9062_ID_LDO4,
 660                 .desc.name = "DA9062 LDO4",
 661                 .desc.of_match = of_match_ptr("ldo4"),
 662                 .desc.regulators_node = of_match_ptr("regulators"),
 663                 .desc.ops = &da9062_ldo_ops,
 664                 .desc.min_uV = (900) * 1000,
 665                 .desc.uV_step = (50) * 1000,
 666                 .desc.n_voltages = ((3600) - (900))/(50) + 1,
 667                 .desc.enable_reg = DA9062AA_LDO4_CONT,
 668                 .desc.enable_mask = DA9062AA_LDO4_EN_MASK,
 669                 .desc.vsel_reg = DA9062AA_VLDO4_A,
 670                 .desc.vsel_mask = DA9062AA_VLDO4_A_MASK,
 671                 .desc.linear_min_sel = 0,
 672                 .sleep = REG_FIELD(DA9062AA_VLDO4_A,
 673                         __builtin_ffs((int)DA9062AA_LDO4_SL_A_MASK) - 1,
 674                         sizeof(unsigned int) * 8 -
 675                         __builtin_clz((DA9062AA_LDO4_SL_A_MASK)) - 1),
 676                 .suspend_sleep = REG_FIELD(DA9062AA_VLDO4_B,
 677                         __builtin_ffs((int)DA9062AA_LDO4_SL_B_MASK) - 1,
 678                         sizeof(unsigned int) * 8 -
 679                         __builtin_clz((DA9062AA_LDO4_SL_B_MASK)) - 1),
 680                 .suspend_vsel_reg = DA9062AA_VLDO4_B,
 681                 .suspend = REG_FIELD(DA9062AA_DVC_1,
 682                         __builtin_ffs((int)DA9062AA_VLDO4_SEL_MASK) - 1,
 683                         sizeof(unsigned int) * 8 -
 684                         __builtin_clz((DA9062AA_VLDO4_SEL_MASK)) - 1),
 685                 .oc_event = REG_FIELD(DA9062AA_STATUS_D,
 686                         __builtin_ffs((int)DA9062AA_LDO4_ILIM_MASK) - 1,
 687                         sizeof(unsigned int) * 8 -
 688                         __builtin_clz((DA9062AA_LDO4_ILIM_MASK)) - 1),
 689         },
 690 };
 691
 692 /* Regulator interrupt handlers */
 693 static irqreturn_t da9062_ldo_lim_event(int irq, void *data)
 694 {
 695         struct da9062_regulators *regulators = data;
 696         struct da9062 *hw = regulators->regulator[0].hw;
 697         struct da9062_regulator *regl;
 698         int handled = IRQ_NONE;
 699         int bits, i, ret;
 700
 701         ret = regmap_read(hw->regmap, DA9062AA_STATUS_D, &bits);
 702         if (ret < 0) {
 703                 dev_err(hw->dev,
 704                         "Failed to read LDO overcurrent indicator\n");
 705                 goto ldo_lim_error;
 706         }
 707
 708         for (i = regulators->n_regulators - 1; i >= 0; i--) {
 709                 regl = &regulators->regulator[i];
 710                 if (regl->info->oc_event.reg != DA9062AA_STATUS_D)
 711                         continue;
 712
 713                 if (BIT(regl->info->oc_event.lsb) & bits) {
 714                         regulator_notifier_call_chain(regl->rdev,
 715                                         REGULATOR_EVENT_OVER_CURRENT, NULL);
 716                         handled = IRQ_HANDLED;
 717                 }
 718         }
 719
 720 ldo_lim_error:
 721         return handled;
 722 }
 723
 724 static int da9062_regulator_probe(struct platform_device *pdev)
 725 {
 726         struct da9062 *chip = dev_get_drvdata(pdev->dev.parent);
 727         struct da9062_regulators *regulators;
 728         struct da9062_regulator *regl;
 729         struct regulator_config config = { };
 730         int irq, n, ret;
 731         size_t size;
 732
 733         /* Allocate memory required by usable regulators */
 734         size = sizeof(struct da9062_regulators) +
 735                 DA9062_MAX_REGULATORS * sizeof(struct da9062_regulator);
 736         regulators = devm_kzalloc(&pdev->dev, size, GFP_KERNEL);
 737         if (!regulators)
 738                 return -ENOMEM;
 739
 740         regulators->n_regulators = DA9062_MAX_REGULATORS;
 741         platform_set_drvdata(pdev, regulators);
 742
 743         n = 0;
 744         while (n < regulators->n_regulators) {
 745                 /* Initialise regulator structure */
 746                 regl = &regulators->regulator[n];
 747                 regl->hw = chip;
 748                 regl->info = &local_regulator_info[n];
 749                 regl->desc = regl->info->desc;
 750                 regl->desc.type = REGULATOR_VOLTAGE;
 751                 regl->desc.owner = THIS_MODULE;
 752
 753                 if (regl->info->mode.reg)
 754                         regl->mode = devm_regmap_field_alloc(
 755                                         &pdev->dev,
 756                                         chip->regmap,
 757                                         regl->info->mode);
 758                 if (regl->info->suspend.reg)
 759                         regl->suspend = devm_regmap_field_alloc(
 760                                         &pdev->dev,
 761                                         chip->regmap,
 762                                         regl->info->suspend);
 763                 if (regl->info->sleep.reg)
 764                         regl->sleep = devm_regmap_field_alloc(
 765                                         &pdev->dev,
 766                                         chip->regmap,
 767                                         regl->info->sleep);
 768                 if (regl->info->suspend_sleep.reg)
 769                         regl->suspend_sleep = devm_regmap_field_alloc(
 770                                         &pdev->dev,
 771                                         chip->regmap,
 772                                         regl->info->suspend_sleep);
 773                 if (regl->info->ilimit.reg)
 774                         regl->ilimit = devm_regmap_field_alloc(
 775                                         &pdev->dev,
 776                                         chip->regmap,
 777                                         regl->info->ilimit);
 778
 779                 /* Register regulator */
 780                 memset(&config, 0, sizeof(config));
 781                 config.dev = chip->dev;
 782                 config.driver_data = regl;
 783                 config.regmap = chip->regmap;
 784
 785                 regl->rdev = devm_regulator_register(&pdev->dev, &regl->desc,
 786                                                      &config);
 787                 if (IS_ERR(regl->rdev)) {
 788                         dev_err(&pdev->dev,
 789                                 "Failed to register %s regulator\n",
 790                                 regl->desc.name);
 791                         return PTR_ERR(regl->rdev);
 792                 }
 793
 794                 n++;
 795         }
 796
 797         /* LDOs overcurrent event support */
 798         irq = platform_get_irq_byname(pdev, "LDO_LIM");
 799         if (irq < 0) {
 800                 dev_err(&pdev->dev, "Failed to get IRQ.\n");
 801                 return irq;
 802         }
 803         regulators->irq_ldo_lim = irq;
 804
 805         ret = devm_request_threaded_irq(&pdev->dev, irq,
 806                                         NULL, da9062_ldo_lim_event,
 807                                         IRQF_TRIGGER_LOW | IRQF_ONESHOT,
 808                                         "LDO_LIM", regulators);
 809         if (ret) {
 810                 dev_warn(&pdev->dev,
 811                          "Failed to request LDO_LIM IRQ.\n");
 812                 regulators->irq_ldo_lim = -ENXIO;
 813         }
 814
 815         return 0;
 816 }
 817
 818 static struct platform_driver da9062_regulator_driver = {
 819         .driver = {
 820                 .name = "da9062-regulators",
 821                 .owner = THIS_MODULE,
 822         },
 823         .probe = da9062_regulator_probe,
 824 };
 825
 826 static int __init da9062_regulator_init(void)
 827 {
 828         return platform_driver_register(&da9062_regulator_driver);
 829 }
 830 subsys_initcall(da9062_regulator_init);
 831
 832 static void __exit da9062_regulator_cleanup(void)
 833 {
 834         platform_driver_unregister(&da9062_regulator_driver);
 835 }
 836 module_exit(da9062_regulator_cleanup);
 837
 838 /* Module information */
 839 MODULE_AUTHOR("S Twiss <stwiss.opensource@diasemi.com>");
 840 MODULE_DESCRIPTION("REGULATOR device driver for Dialog DA9062");
 841 MODULE_LICENSE("GPL");
 842 MODULE_ALIAS("platform:da9062-regulators");