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_desc_list_voltage_linear_range - List voltages for linear ranges
 598  *
 599  * @desc: Regulator desc for regulator which volatges are to be listed
 600  * @selector: Selector to convert into a voltage
 601  *
 602  * Regulators with a series of simple linear mappings between voltages
 603  * and selectors who have set linear_ranges in the regulator descriptor
 604  * can use this function prior regulator registration to list voltages.
 605  * This is useful when voltages need to be listed during device-tree
 606  * parsing.
 607  */
 608 int regulator_desc_list_voltage_linear_range(const struct regulator_desc *desc,
 609                                              unsigned int selector)
 610 {
 611         const struct regulator_linear_range *range;
 612         int i;
 613
 614         if (!desc->n_linear_ranges) {
 615                 BUG_ON(!desc->n_linear_ranges);
 616                 return -EINVAL;
 617         }
 618
 619         for (i = 0; i < desc->n_linear_ranges; i++) {
 620                 range = &desc->linear_ranges[i];
 621
 622                 if (!(selector >= range->min_sel &&
 623                       selector <= range->max_sel))
 624                         continue;
 625
 626                 selector -= range->min_sel;
 627
 628                 return range->min_uV + (range->uV_step * selector);
 629         }
 630
 631         return -EINVAL;
 632 }
 633 EXPORT_SYMBOL_GPL(regulator_desc_list_voltage_linear_range);
 634
 635 /**
 636  * regulator_list_voltage_linear_range - List voltages for linear ranges
 637  *
 638  * @rdev: Regulator device
 639  * @selector: Selector to convert into a voltage
 640  *
 641  * Regulators with a series of simple linear mappings between voltages
 642  * and selectors can set linear_ranges in the regulator descriptor and
 643  * then use this function as their list_voltage() operation,
 644  */
 645 int regulator_list_voltage_linear_range(struct regulator_dev *rdev,
 646                                         unsigned int selector)
 647 {
 648         return regulator_desc_list_voltage_linear_range(rdev->desc, selector);
 649 }
 650 EXPORT_SYMBOL_GPL(regulator_list_voltage_linear_range);
 651
 652 /**
 653  * regulator_list_voltage_table - List voltages with table based mapping
 654  *
 655  * @rdev: Regulator device
 656  * @selector: Selector to convert into a voltage
 657  *
 658  * Regulators with table based mapping between voltages and
 659  * selectors can set volt_table in the regulator descriptor
 660  * and then use this function as their list_voltage() operation.
 661  */
 662 int regulator_list_voltage_table(struct regulator_dev *rdev,
 663                                  unsigned int selector)
 664 {
 665         if (!rdev->desc->volt_table) {
 666                 BUG_ON(!rdev->desc->volt_table);
 667                 return -EINVAL;
 668         }
 669
 670         if (selector >= rdev->desc->n_voltages)
 671                 return -EINVAL;
 672
 673         return rdev->desc->volt_table[selector];
 674 }
 675 EXPORT_SYMBOL_GPL(regulator_list_voltage_table);
 676
 677 /**
 678  * regulator_set_bypass_regmap - Default set_bypass() using regmap
 679  *
 680  * @rdev: device to operate on.
 681  * @enable: state to set.
 682  */
 683 int regulator_set_bypass_regmap(struct regulator_dev *rdev, bool enable)
 684 {
 685         unsigned int val;
 686
 687         if (enable) {
 688                 val = rdev->desc->bypass_val_on;
 689                 if (!val)
 690                         val = rdev->desc->bypass_mask;
 691         } else {
 692                 val = rdev->desc->bypass_val_off;
 693         }
 694
 695         return regmap_update_bits(rdev->regmap, rdev->desc->bypass_reg,
 696                                   rdev->desc->bypass_mask, val);
 697 }
 698 EXPORT_SYMBOL_GPL(regulator_set_bypass_regmap);
 699
 700 /**
 701  * regulator_set_soft_start_regmap - Default set_soft_start() using regmap
 702  *
 703  * @rdev: device to operate on.
 704  */
 705 int regulator_set_soft_start_regmap(struct regulator_dev *rdev)
 706 {
 707         unsigned int val;
 708
 709         val = rdev->desc->soft_start_val_on;
 710         if (!val)
 711                 val = rdev->desc->soft_start_mask;
 712
 713         return regmap_update_bits(rdev->regmap, rdev->desc->soft_start_reg,
 714                                   rdev->desc->soft_start_mask, val);
 715 }
 716 EXPORT_SYMBOL_GPL(regulator_set_soft_start_regmap);
 717
 718 /**
 719  * regulator_set_pull_down_regmap - Default set_pull_down() using regmap
 720  *
 721  * @rdev: device to operate on.
 722  */
 723 int regulator_set_pull_down_regmap(struct regulator_dev *rdev)
 724 {
 725         unsigned int val;
 726
 727         val = rdev->desc->pull_down_val_on;
 728         if (!val)
 729                 val = rdev->desc->pull_down_mask;
 730
 731         return regmap_update_bits(rdev->regmap, rdev->desc->pull_down_reg,
 732                                   rdev->desc->pull_down_mask, val);
 733 }
 734 EXPORT_SYMBOL_GPL(regulator_set_pull_down_regmap);
 735
 736 /**
 737  * regulator_get_bypass_regmap - Default get_bypass() using regmap
 738  *
 739  * @rdev: device to operate on.
 740  * @enable: current state.
 741  */
 742 int regulator_get_bypass_regmap(struct regulator_dev *rdev, bool *enable)
 743 {
 744         unsigned int val;
 745         unsigned int val_on = rdev->desc->bypass_val_on;
 746         int ret;
 747
 748         ret = regmap_read(rdev->regmap, rdev->desc->bypass_reg, &val);
 749         if (ret != 0)
 750                 return ret;
 751
 752         if (!val_on)
 753                 val_on = rdev->desc->bypass_mask;
 754
 755         *enable = (val & rdev->desc->bypass_mask) == val_on;
 756
 757         return 0;
 758 }
 759 EXPORT_SYMBOL_GPL(regulator_get_bypass_regmap);
 760
 761 /**
 762  * regulator_set_active_discharge_regmap - Default set_active_discharge()
 763  *                                         using regmap
 764  *
 765  * @rdev: device to operate on.
 766  * @enable: state to set, 0 to disable and 1 to enable.
 767  */
 768 int regulator_set_active_discharge_regmap(struct regulator_dev *rdev,
 769                                           bool enable)
 770 {
 771         unsigned int val;
 772
 773         if (enable)
 774                 val = rdev->desc->active_discharge_on;
 775         else
 776                 val = rdev->desc->active_discharge_off;
 777
 778         return regmap_update_bits(rdev->regmap,
 779                                   rdev->desc->active_discharge_reg,
 780                                   rdev->desc->active_discharge_mask, val);
 781 }
 782 EXPORT_SYMBOL_GPL(regulator_set_active_discharge_regmap);
 783
 784 /**
 785  * regulator_set_current_limit_regmap - set_current_limit for regmap users
 786  *
 787  * @rdev: regulator to operate on
 788  * @min_uA: Lower bound for current limit
 789  * @max_uA: Upper bound for current limit
 790  *
 791  * Regulators that use regmap for their register I/O can set curr_table,
 792  * csel_reg and csel_mask fields in their descriptor and then use this
 793  * as their set_current_limit operation, saving some code.
 794  */
 795 int regulator_set_current_limit_regmap(struct regulator_dev *rdev,
 796                                        int min_uA, int max_uA)
 797 {
 798         unsigned int n_currents = rdev->desc->n_current_limits;
 799         int i, sel = -1;
 800
 801         if (n_currents == 0)
 802                 return -EINVAL;
 803
 804         if (rdev->desc->curr_table) {
 805                 const unsigned int *curr_table = rdev->desc->curr_table;
 806                 bool ascend = curr_table[n_currents - 1] > curr_table[0];
 807
 808                 /* search for closest to maximum */
 809                 if (ascend) {
 810                         for (i = n_currents - 1; i >= 0; i--) {
 811                                 if (min_uA <= curr_table[i] &&
 812                                     curr_table[i] <= max_uA) {
 813                                         sel = i;
 814                                         break;
 815                                 }
 816                         }
 817                 } else {
 818                         for (i = 0; i < n_currents; i++) {
 819                                 if (min_uA <= curr_table[i] &&
 820                                     curr_table[i] <= max_uA) {
 821                                         sel = i;
 822                                         break;
 823                                 }
 824                         }
 825                 }
 826         }
 827
 828         if (sel < 0)
 829                 return -EINVAL;
 830
 831         sel <<= ffs(rdev->desc->csel_mask) - 1;
 832
 833         return regmap_update_bits(rdev->regmap, rdev->desc->csel_reg,
 834                                   rdev->desc->csel_mask, sel);
 835 }
 836 EXPORT_SYMBOL_GPL(regulator_set_current_limit_regmap);
 837
 838 /**
 839  * regulator_get_current_limit_regmap - get_current_limit for regmap users
 840  *
 841  * @rdev: regulator to operate on
 842  *
 843  * Regulators that use regmap for their register I/O can set the
 844  * csel_reg and csel_mask fields in their descriptor and then use this
 845  * as their get_current_limit operation, saving some code.
 846  */
 847 int regulator_get_current_limit_regmap(struct regulator_dev *rdev)
 848 {
 849         unsigned int val;
 850         int ret;
 851
 852         ret = regmap_read(rdev->regmap, rdev->desc->csel_reg, &val);
 853         if (ret != 0)
 854                 return ret;
 855
 856         val &= rdev->desc->csel_mask;
 857         val >>= ffs(rdev->desc->csel_mask) - 1;
 858
 859         if (rdev->desc->curr_table) {
 860                 if (val >= rdev->desc->n_current_limits)
 861                         return -EINVAL;
 862
 863                 return rdev->desc->curr_table[val];
 864         }
 865
 866         return -EINVAL;
 867 }
 868 EXPORT_SYMBOL_GPL(regulator_get_current_limit_regmap);