drivers/regulator/helpers.c

   1 /*
   2  * helpers.c  --  Voltage/Current Regulator framework helper functions.
   3  *
   4  * Copyright 2007, 2008 Wolfson Microelectronics PLC.
   5  * Copyright 2008 SlimLogic Ltd.
   6  *
   7  *  This program is free software; you can redistribute  it and/or modify it
   8  *  under  the terms of  the GNU General  Public License as published by the
   9  *  Free Software Foundation;  either version 2 of the  License, or (at your
  10  *  option) any later version.
  11  *
  12  */
  13
  14 #include <linux/kernel.h>
  15 #include <linux/err.h>
  16 #include <linux/delay.h>
  17 #include <linux/regmap.h>
  18 #include <linux/regulator/consumer.h>
  19 #include <linux/regulator/driver.h>
  20 #include <linux/module.h>
  21
  22 /**
  23  * regulator_is_enabled_regmap - standard is_enabled() for regmap users
  24  *
  25  * @rdev: regulator to operate on
  26  *
  27  * Regulators that use regmap for their register I/O can set the
  28  * enable_reg and enable_mask fields in their descriptor and then use
  29  * this as their is_enabled operation, saving some code.
  30  */
  31 int regulator_is_enabled_regmap(struct regulator_dev *rdev)
  32 {
  33         unsigned int val;
  34         int ret;
  35
  36         ret = regmap_read(rdev->regmap, rdev->desc->enable_reg, &val);
  37         if (ret != 0)
  38                 return ret;
  39
  40         val &= rdev->desc->enable_mask;
  41
  42         if (rdev->desc->enable_is_inverted) {
  43                 if (rdev->desc->enable_val)
  44                         return val != rdev->desc->enable_val;
  45                 return val == 0;
  46         } else {
  47                 if (rdev->desc->enable_val)
  48                         return val == rdev->desc->enable_val;
  49                 return val != 0;
  50         }
  51 }
  52 EXPORT_SYMBOL_GPL(regulator_is_enabled_regmap);
  53
  54 /**
  55  * regulator_enable_regmap - standard enable() for regmap users
  56  *
  57  * @rdev: regulator to operate on
  58  *
  59  * Regulators that use regmap for their register I/O can set the
  60  * enable_reg and enable_mask fields in their descriptor and then use
  61  * this as their enable() operation, saving some code.
  62  */
  63 int regulator_enable_regmap(struct regulator_dev *rdev)
  64 {
  65         unsigned int val;
  66
  67         if (rdev->desc->enable_is_inverted) {
  68                 val = rdev->desc->disable_val;
  69         } else {
  70                 val = rdev->desc->enable_val;
  71                 if (!val)
  72                         val = rdev->desc->enable_mask;
  73         }
  74
  75         return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
  76                                   rdev->desc->enable_mask, val);
  77 }
  78 EXPORT_SYMBOL_GPL(regulator_enable_regmap);
  79
  80 /**
  81  * regulator_disable_regmap - standard disable() for regmap users
  82  *
  83  * @rdev: regulator to operate on
  84  *
  85  * Regulators that use regmap for their register I/O can set the
  86  * enable_reg and enable_mask fields in their descriptor and then use
  87  * this as their disable() operation, saving some code.
  88  */
  89 int regulator_disable_regmap(struct regulator_dev *rdev)
  90 {
  91         unsigned int val;
  92
  93         if (rdev->desc->enable_is_inverted) {
  94                 val = rdev->desc->enable_val;
  95                 if (!val)
  96                         val = rdev->desc->enable_mask;
  97         } else {
  98                 val = rdev->desc->disable_val;
  99         }
 100
 101         return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
 102                                   rdev->desc->enable_mask, val);
 103 }
 104 EXPORT_SYMBOL_GPL(regulator_disable_regmap);
 105
 106 static int regulator_range_selector_to_index(struct regulator_dev *rdev,
 107                                              unsigned int rval)
 108 {
 109         int i;
 110
 111         if (!rdev->desc->linear_range_selectors)
 112                 return -EINVAL;
 113
 114         rval &= rdev->desc->vsel_range_mask;
 115
 116         for (i = 0; i < rdev->desc->n_linear_ranges; i++) {
 117                 if (rdev->desc->linear_range_selectors[i] == rval)
 118                         return i;
 119         }
 120         return -EINVAL;
 121 }
 122
 123 /**
 124  * regulator_get_voltage_sel_pickable_regmap - pickable range get_voltage_sel
 125  *
 126  * @rdev: regulator to operate on
 127  *
 128  * Regulators that use regmap for their register I/O and use pickable
 129  * ranges can set the vsel_reg, vsel_mask, vsel_range_reg and vsel_range_mask
 130  * fields in their descriptor and then use this as their get_voltage_vsel
 131  * operation, saving some code.
 132  */
 133 int regulator_get_voltage_sel_pickable_regmap(struct regulator_dev *rdev)
 134 {
 135         unsigned int r_val;
 136         int range;
 137         unsigned int val;
 138         int ret, i;
 139         unsigned int voltages_in_range = 0;
 140
 141         if (!rdev->desc->linear_ranges)
 142                 return -EINVAL;
 143
 144         ret = regmap_read(rdev->regmap, rdev->desc->vsel_reg, &val);
 145         if (ret != 0)
 146                 return ret;
 147
 148         ret = regmap_read(rdev->regmap, rdev->desc->vsel_range_reg, &r_val);
 149         if (ret != 0)
 150                 return ret;
 151
 152         val &= rdev->desc->vsel_mask;
 153         val >>= ffs(rdev->desc->vsel_mask) - 1;
 154
 155         range = regulator_range_selector_to_index(rdev, r_val);
 156         if (range < 0)
 157                 return -EINVAL;
 158
 159         for (i = 0; i < range; i++)
 160                 voltages_in_range += (rdev->desc->linear_ranges[i].max_sel -
 161                                      rdev->desc->linear_ranges[i].min_sel) + 1;
 162
 163         return val + voltages_in_range;
 164 }
 165 EXPORT_SYMBOL_GPL(regulator_get_voltage_sel_pickable_regmap);
 166
 167 /**
 168  * regulator_set_voltage_sel_pickable_regmap - pickable range set_voltage_sel
 169  *
 170  * @rdev: regulator to operate on
 171  * @sel: Selector to set
 172  *
 173  * Regulators that use regmap for their register I/O and use pickable
 174  * ranges can set the vsel_reg, vsel_mask, vsel_range_reg and vsel_range_mask
 175  * fields in their descriptor and then use this as their set_voltage_vsel
 176  * operation, saving some code.
 177  */
 178 int regulator_set_voltage_sel_pickable_regmap(struct regulator_dev *rdev,
 179                                               unsigned int sel)
 180 {
 181         unsigned int range;
 182         int ret, i;
 183         unsigned int voltages_in_range = 0;
 184
 185         for (i = 0; i < rdev->desc->n_linear_ranges; i++) {
 186                 voltages_in_range = (rdev->desc->linear_ranges[i].max_sel -
 187                                      rdev->desc->linear_ranges[i].min_sel) + 1;
 188                 if (sel < voltages_in_range)
 189                         break;
 190                 sel -= voltages_in_range;
 191         }
 192
 193         if (i == rdev->desc->n_linear_ranges)
 194                 return -EINVAL;
 195
 196         sel <<= ffs(rdev->desc->vsel_mask) - 1;
 197         sel += rdev->desc->linear_ranges[i].min_sel;
 198
 199         range = rdev->desc->linear_range_selectors[i];
 200
 201         if (rdev->desc->vsel_reg == rdev->desc->vsel_range_reg) {
 202                 ret = regmap_update_bits(rdev->regmap,
 203                                          rdev->desc->vsel_reg,
 204                                          rdev->desc->vsel_range_mask |
 205                                          rdev->desc->vsel_mask, sel | range);
 206         } else {
 207                 ret = regmap_update_bits(rdev->regmap,
 208                                          rdev->desc->vsel_range_reg,
 209                                          rdev->desc->vsel_range_mask, range);
 210                 if (ret)
 211                         return ret;
 212
 213                 ret = regmap_update_bits(rdev->regmap, rdev->desc->vsel_reg,
 214                                   rdev->desc->vsel_mask, sel);
 215         }
 216
 217         if (ret)
 218                 return ret;
 219
 220         if (rdev->desc->apply_bit)
 221                 ret = regmap_update_bits(rdev->regmap, rdev->desc->apply_reg,
 222                                          rdev->desc->apply_bit,
 223                                          rdev->desc->apply_bit);
 224         return ret;
 225 }
 226 EXPORT_SYMBOL_GPL(regulator_set_voltage_sel_pickable_regmap);
 227
 228 /**
 229  * regulator_get_voltage_sel_regmap - standard get_voltage_sel for regmap users
 230  *
 231  * @rdev: regulator to operate on
 232  *
 233  * Regulators that use regmap for their register I/O can set the
 234  * vsel_reg and vsel_mask fields in their descriptor and then use this
 235  * as their get_voltage_vsel operation, saving some code.
 236  */
 237 int regulator_get_voltage_sel_regmap(struct regulator_dev *rdev)
 238 {
 239         unsigned int val;
 240         int ret;
 241
 242         ret = regmap_read(rdev->regmap, rdev->desc->vsel_reg, &val);
 243         if (ret != 0)
 244                 return ret;
 245
 246         val &= rdev->desc->vsel_mask;
 247         val >>= ffs(rdev->desc->vsel_mask) - 1;
 248
 249         return val;
 250 }
 251 EXPORT_SYMBOL_GPL(regulator_get_voltage_sel_regmap);
 252
 253 /**
 254  * regulator_set_voltage_sel_regmap - standard set_voltage_sel for regmap users
 255  *
 256  * @rdev: regulator to operate on
 257  * @sel: Selector to set
 258  *
 259  * Regulators that use regmap for their register I/O can set the
 260  * vsel_reg and vsel_mask fields in their descriptor and then use this
 261  * as their set_voltage_vsel operation, saving some code.
 262  */
 263 int regulator_set_voltage_sel_regmap(struct regulator_dev *rdev, unsigned sel)
 264 {
 265         int ret;
 266
 267         sel <<= ffs(rdev->desc->vsel_mask) - 1;
 268
 269         ret = regmap_update_bits(rdev->regmap, rdev->desc->vsel_reg,
 270                                   rdev->desc->vsel_mask, sel);
 271         if (ret)
 272                 return ret;
 273
 274         if (rdev->desc->apply_bit)
 275                 ret = regmap_update_bits(rdev->regmap, rdev->desc->apply_reg,
 276                                          rdev->desc->apply_bit,
 277                                          rdev->desc->apply_bit);
 278         return ret;
 279 }
 280 EXPORT_SYMBOL_GPL(regulator_set_voltage_sel_regmap);
 281
 282 /**
 283  * regulator_map_voltage_iterate - map_voltage() based on list_voltage()
 284  *
 285  * @rdev: Regulator to operate on
 286  * @min_uV: Lower bound for voltage
 287  * @max_uV: Upper bound for voltage
 288  *
 289  * Drivers implementing set_voltage_sel() and list_voltage() can use
 290  * this as their map_voltage() operation.  It will find a suitable
 291  * voltage by calling list_voltage() until it gets something in bounds
 292  * for the requested voltages.
 293  */
 294 int regulator_map_voltage_iterate(struct regulator_dev *rdev,
 295                                   int min_uV, int max_uV)
 296 {
 297         int best_val = INT_MAX;
 298         int selector = 0;
 299         int i, ret;
 300
 301         /* Find the smallest voltage that falls within the specified
 302          * range.
 303          */
 304         for (i = 0; i < rdev->desc->n_voltages; i++) {
 305                 ret = rdev->desc->ops->list_voltage(rdev, i);
 306                 if (ret < 0)
 307                         continue;
 308
 309                 if (ret < best_val && ret >= min_uV && ret <= max_uV) {
 310                         best_val = ret;
 311                         selector = i;
 312                 }
 313         }
 314
 315         if (best_val != INT_MAX)
 316                 return selector;
 317         else
 318                 return -EINVAL;
 319 }
 320 EXPORT_SYMBOL_GPL(regulator_map_voltage_iterate);
 321
 322 /**
 323  * regulator_map_voltage_ascend - map_voltage() for ascendant voltage list
 324  *
 325  * @rdev: Regulator to operate on
 326  * @min_uV: Lower bound for voltage
 327  * @max_uV: Upper bound for voltage
 328  *
 329  * Drivers that have ascendant voltage list can use this as their
 330  * map_voltage() operation.
 331  */
 332 int regulator_map_voltage_ascend(struct regulator_dev *rdev,
 333                                  int min_uV, int max_uV)
 334 {
 335         int i, ret;
 336
 337         for (i = 0; i < rdev->desc->n_voltages; i++) {
 338                 ret = rdev->desc->ops->list_voltage(rdev, i);
 339                 if (ret < 0)
 340                         continue;
 341
 342                 if (ret > max_uV)
 343                         break;
 344
 345                 if (ret >= min_uV && ret <= max_uV)
 346                         return i;
 347         }
 348
 349         return -EINVAL;
 350 }
 351 EXPORT_SYMBOL_GPL(regulator_map_voltage_ascend);
 352
 353 /**
 354  * regulator_map_voltage_linear - map_voltage() for simple linear mappings
 355  *
 356  * @rdev: Regulator to operate on
 357  * @min_uV: Lower bound for voltage
 358  * @max_uV: Upper bound for voltage
 359  *
 360  * Drivers providing min_uV and uV_step in their regulator_desc can
 361  * use this as their map_voltage() operation.
 362  */
 363 int regulator_map_voltage_linear(struct regulator_dev *rdev,
 364                                  int min_uV, int max_uV)
 365 {
 366         int ret, voltage;
 367
 368         /* Allow uV_step to be 0 for fixed voltage */
 369         if (rdev->desc->n_voltages == 1 && rdev->desc->uV_step == 0) {
 370                 if (min_uV <= rdev->desc->min_uV && rdev->desc->min_uV <= max_uV)
 371                         return 0;
 372                 else
 373                         return -EINVAL;
 374         }
 375
 376         if (!rdev->desc->uV_step) {
 377                 BUG_ON(!rdev->desc->uV_step);
 378                 return -EINVAL;
 379         }
 380
 381         if (min_uV < rdev->desc->min_uV)
 382                 min_uV = rdev->desc->min_uV;
 383
 384         ret = DIV_ROUND_UP(min_uV - rdev->desc->min_uV, rdev->desc->uV_step);
 385         if (ret < 0)
 386                 return ret;
 387
 388         ret += rdev->desc->linear_min_sel;
 389
 390         /* Map back into a voltage to verify we're still in bounds */
 391         voltage = rdev->desc->ops->list_voltage(rdev, ret);
 392         if (voltage < min_uV || voltage > max_uV)
 393                 return -EINVAL;
 394
 395         return ret;
 396 }
 397 EXPORT_SYMBOL_GPL(regulator_map_voltage_linear);
 398
 399 /**
 400  * regulator_map_voltage_linear_range - map_voltage() for multiple linear ranges
 401  *
 402  * @rdev: Regulator to operate on
 403  * @min_uV: Lower bound for voltage
 404  * @max_uV: Upper bound for voltage
 405  *
 406  * Drivers providing linear_ranges in their descriptor can use this as
 407  * their map_voltage() callback.
 408  */
 409 int regulator_map_voltage_linear_range(struct regulator_dev *rdev,
 410                                        int min_uV, int max_uV)
 411 {
 412         const struct regulator_linear_range *range;
 413         int ret = -EINVAL;
 414         int voltage, i;
 415
 416         if (!rdev->desc->n_linear_ranges) {
 417                 BUG_ON(!rdev->desc->n_linear_ranges);
 418                 return -EINVAL;
 419         }
 420
 421         for (i = 0; i < rdev->desc->n_linear_ranges; i++) {
 422                 int linear_max_uV;
 423
 424                 range = &rdev->desc->linear_ranges[i];
 425                 linear_max_uV = range->min_uV +
 426                         (range->max_sel - range->min_sel) * range->uV_step;
 427
 428                 if (!(min_uV <= linear_max_uV && max_uV >= range->min_uV))
 429                         continue;
 430
 431                 if (min_uV <= range->min_uV)
 432                         min_uV = range->min_uV;
 433
 434                 /* range->uV_step == 0 means fixed voltage range */
 435                 if (range->uV_step == 0) {
 436                         ret = 0;
 437                 } else {
 438                         ret = DIV_ROUND_UP(min_uV - range->min_uV,
 439                                            range->uV_step);
 440                         if (ret < 0)
 441                                 return ret;
 442                 }
 443
 444                 ret += range->min_sel;
 445
 446                 /*
 447                  * Map back into a voltage to verify we're still in bounds.
 448                  * If we are not, then continue checking rest of the ranges.
 449                  */
 450                 voltage = rdev->desc->ops->list_voltage(rdev, ret);
 451                 if (voltage >= min_uV && voltage <= max_uV)
 452                         break;
 453         }
 454
 455         if (i == rdev->desc->n_linear_ranges)
 456                 return -EINVAL;
 457
 458         return ret;
 459 }
 460 EXPORT_SYMBOL_GPL(regulator_map_voltage_linear_range);
 461
 462 /**
 463  * regulator_map_voltage_pickable_linear_range - map_voltage, pickable ranges
 464  *
 465  * @rdev: Regulator to operate on
 466  * @min_uV: Lower bound for voltage
 467  * @max_uV: Upper bound for voltage
 468  *
 469  * Drivers providing pickable linear_ranges in their descriptor can use
 470  * this as their map_voltage() callback.
 471  */
 472 int regulator_map_voltage_pickable_linear_range(struct regulator_dev *rdev,
 473                                                 int min_uV, int max_uV)
 474 {
 475         const struct regulator_linear_range *range;
 476         int ret = -EINVAL;
 477         int voltage, i;
 478         unsigned int selector = 0;
 479
 480         if (!rdev->desc->n_linear_ranges) {
 481                 BUG_ON(!rdev->desc->n_linear_ranges);
 482                 return -EINVAL;
 483         }
 484
 485         for (i = 0; i < rdev->desc->n_linear_ranges; i++) {
 486                 int linear_max_uV;
 487
 488                 range = &rdev->desc->linear_ranges[i];
 489                 linear_max_uV = range->min_uV +
 490                         (range->max_sel - range->min_sel) * range->uV_step;
 491
 492                 if (!(min_uV <= linear_max_uV && max_uV >= range->min_uV)) {
 493                         selector += (range->max_sel - range->min_sel + 1);
 494                         continue;
 495                 }
 496
 497                 if (min_uV <= range->min_uV)
 498                         min_uV = range->min_uV;
 499
 500                 /* range->uV_step == 0 means fixed voltage range */
 501                 if (range->uV_step == 0) {
 502                         ret = 0;
 503                 } else {
 504                         ret = DIV_ROUND_UP(min_uV - range->min_uV,
 505                                            range->uV_step);
 506                         if (ret < 0)
 507                                 return ret;
 508                 }
 509
 510                 ret += selector;
 511
 512                 voltage = rdev->desc->ops->list_voltage(rdev, ret);
 513
 514                 /*
 515                  * Map back into a voltage to verify we're still in bounds.
 516                  * We may have overlapping voltage ranges. Hence we don't
 517                  * exit but retry until we have checked all ranges.
 518                  */
 519                 if (voltage < min_uV || voltage > max_uV)
 520                         selector += (range->max_sel - range->min_sel + 1);
 521                 else
 522                         break;
 523         }
 524
 525         if (i == rdev->desc->n_linear_ranges)
 526                 return -EINVAL;
 527
 528         return ret;
 529 }
 530 EXPORT_SYMBOL_GPL(regulator_map_voltage_pickable_linear_range);
 531
 532 /**
 533  * regulator_list_voltage_linear - List voltages with simple calculation
 534  *
 535  * @rdev: Regulator device
 536  * @selector: Selector to convert into a voltage
 537  *
 538  * Regulators with a simple linear mapping between voltages and
 539  * selectors can set min_uV and uV_step in the regulator descriptor
 540  * and then use this function as their list_voltage() operation,
 541  */
 542 int regulator_list_voltage_linear(struct regulator_dev *rdev,
 543                                   unsigned int selector)
 544 {
 545         if (selector >= rdev->desc->n_voltages)
 546                 return -EINVAL;
 547         if (selector < rdev->desc->linear_min_sel)
 548                 return 0;
 549
 550         selector -= rdev->desc->linear_min_sel;
 551
 552         return rdev->desc->min_uV + (rdev->desc->uV_step * selector);
 553 }
 554 EXPORT_SYMBOL_GPL(regulator_list_voltage_linear);
 555
 556 /**
 557  * regulator_list_voltage_pickable_linear_range - pickable range list voltages
 558  *
 559  * @rdev: Regulator device
 560  * @selector: Selector to convert into a voltage
 561  *
 562  * list_voltage() operation, intended to be used by drivers utilizing pickable
 563  * ranges helpers.
 564  */
 565 int regulator_list_voltage_pickable_linear_range(struct regulator_dev *rdev,
 566                                                  unsigned int selector)
 567 {
 568         const struct regulator_linear_range *range;
 569         int i;
 570         unsigned int all_sels = 0;
 571
 572         if (!rdev->desc->n_linear_ranges) {
 573                 BUG_ON(!rdev->desc->n_linear_ranges);
 574                 return -EINVAL;
 575         }
 576
 577         for (i = 0; i < rdev->desc->n_linear_ranges; i++) {
 578                 unsigned int sels_in_range;
 579
 580                 range = &rdev->desc->linear_ranges[i];
 581
 582                 sels_in_range = range->max_sel - range->min_sel;
 583
 584                 if (all_sels + sels_in_range >= selector) {
 585                         selector -= all_sels;
 586                         return range->min_uV + (range->uV_step * selector);
 587                 }
 588
 589                 all_sels += (sels_in_range + 1);
 590         }
 591
 592         return -EINVAL;
 593 }
 594 EXPORT_SYMBOL_GPL(regulator_list_voltage_pickable_linear_range);
 595
 596 /**
 597  * regulator_list_voltage_linear_range - List voltages for linear ranges
 598  *
 599  * @rdev: Regulator device
 600  * @selector: Selector to convert into a voltage
 601  *
 602  * Regulators with a series of simple linear mappings between voltages
 603  * and selectors can set linear_ranges in the regulator descriptor and
 604  * then use this function as their list_voltage() operation,
 605  */
 606 int regulator_list_voltage_linear_range(struct regulator_dev *rdev,
 607                                         unsigned int selector)
 608 {
 609         const struct regulator_linear_range *range;
 610         int i;
 611
 612         if (!rdev->desc->n_linear_ranges) {
 613                 BUG_ON(!rdev->desc->n_linear_ranges);
 614                 return -EINVAL;
 615         }
 616
 617         for (i = 0; i < rdev->desc->n_linear_ranges; i++) {
 618                 range = &rdev->desc->linear_ranges[i];
 619
 620                 if (!(selector >= range->min_sel &&
 621                       selector <= range->max_sel))
 622                         continue;
 623
 624                 selector -= range->min_sel;
 625
 626                 return range->min_uV + (range->uV_step * selector);
 627         }
 628
 629         return -EINVAL;
 630 }
 631 EXPORT_SYMBOL_GPL(regulator_list_voltage_linear_range);
 632
 633 /**
 634  * regulator_list_voltage_table - List voltages with table based mapping
 635  *
 636  * @rdev: Regulator device
 637  * @selector: Selector to convert into a voltage
 638  *
 639  * Regulators with table based mapping between voltages and
 640  * selectors can set volt_table in the regulator descriptor
 641  * and then use this function as their list_voltage() operation.
 642  */
 643 int regulator_list_voltage_table(struct regulator_dev *rdev,
 644                                  unsigned int selector)
 645 {
 646         if (!rdev->desc->volt_table) {
 647                 BUG_ON(!rdev->desc->volt_table);
 648                 return -EINVAL;
 649         }
 650
 651         if (selector >= rdev->desc->n_voltages)
 652                 return -EINVAL;
 653
 654         return rdev->desc->volt_table[selector];
 655 }
 656 EXPORT_SYMBOL_GPL(regulator_list_voltage_table);
 657
 658 /**
 659  * regulator_set_bypass_regmap - Default set_bypass() using regmap
 660  *
 661  * @rdev: device to operate on.
 662  * @enable: state to set.
 663  */
 664 int regulator_set_bypass_regmap(struct regulator_dev *rdev, bool enable)
 665 {
 666         unsigned int val;
 667
 668         if (enable) {
 669                 val = rdev->desc->bypass_val_on;
 670                 if (!val)
 671                         val = rdev->desc->bypass_mask;
 672         } else {
 673                 val = rdev->desc->bypass_val_off;
 674         }
 675
 676         return regmap_update_bits(rdev->regmap, rdev->desc->bypass_reg,
 677                                   rdev->desc->bypass_mask, val);
 678 }
 679 EXPORT_SYMBOL_GPL(regulator_set_bypass_regmap);
 680
 681 /**
 682  * regulator_set_soft_start_regmap - Default set_soft_start() using regmap
 683  *
 684  * @rdev: device to operate on.
 685  */
 686 int regulator_set_soft_start_regmap(struct regulator_dev *rdev)
 687 {
 688         unsigned int val;
 689
 690         val = rdev->desc->soft_start_val_on;
 691         if (!val)
 692                 val = rdev->desc->soft_start_mask;
 693
 694         return regmap_update_bits(rdev->regmap, rdev->desc->soft_start_reg,
 695                                   rdev->desc->soft_start_mask, val);
 696 }
 697 EXPORT_SYMBOL_GPL(regulator_set_soft_start_regmap);
 698
 699 /**
 700  * regulator_set_pull_down_regmap - Default set_pull_down() using regmap
 701  *
 702  * @rdev: device to operate on.
 703  */
 704 int regulator_set_pull_down_regmap(struct regulator_dev *rdev)
 705 {
 706         unsigned int val;
 707
 708         val = rdev->desc->pull_down_val_on;
 709         if (!val)
 710                 val = rdev->desc->pull_down_mask;
 711
 712         return regmap_update_bits(rdev->regmap, rdev->desc->pull_down_reg,
 713                                   rdev->desc->pull_down_mask, val);
 714 }
 715 EXPORT_SYMBOL_GPL(regulator_set_pull_down_regmap);
 716
 717 /**
 718  * regulator_get_bypass_regmap - Default get_bypass() using regmap
 719  *
 720  * @rdev: device to operate on.
 721  * @enable: current state.
 722  */
 723 int regulator_get_bypass_regmap(struct regulator_dev *rdev, bool *enable)
 724 {
 725         unsigned int val;
 726         unsigned int val_on = rdev->desc->bypass_val_on;
 727         int ret;
 728
 729         ret = regmap_read(rdev->regmap, rdev->desc->bypass_reg, &val);
 730         if (ret != 0)
 731                 return ret;
 732
 733         if (!val_on)
 734                 val_on = rdev->desc->bypass_mask;
 735
 736         *enable = (val & rdev->desc->bypass_mask) == val_on;
 737
 738         return 0;
 739 }
 740 EXPORT_SYMBOL_GPL(regulator_get_bypass_regmap);
 741
 742 /**
 743  * regulator_set_active_discharge_regmap - Default set_active_discharge()
 744  *                                         using regmap
 745  *
 746  * @rdev: device to operate on.
 747  * @enable: state to set, 0 to disable and 1 to enable.
 748  */
 749 int regulator_set_active_discharge_regmap(struct regulator_dev *rdev,
 750                                           bool enable)
 751 {
 752         unsigned int val;
 753
 754         if (enable)
 755                 val = rdev->desc->active_discharge_on;
 756         else
 757                 val = rdev->desc->active_discharge_off;
 758
 759         return regmap_update_bits(rdev->regmap,
 760                                   rdev->desc->active_discharge_reg,
 761                                   rdev->desc->active_discharge_mask, val);
 762 }
 763 EXPORT_SYMBOL_GPL(regulator_set_active_discharge_regmap);