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 /**
 107  * regulator_get_voltage_sel_regmap - standard get_voltage_sel for regmap users
 108  *
 109  * @rdev: regulator to operate on
 110  *
 111  * Regulators that use regmap for their register I/O can set the
 112  * vsel_reg and vsel_mask fields in their descriptor and then use this
 113  * as their get_voltage_vsel operation, saving some code.
 114  */
 115 int regulator_get_voltage_sel_regmap(struct regulator_dev *rdev)
 116 {
 117         unsigned int val;
 118         int ret;
 119
 120         ret = regmap_read(rdev->regmap, rdev->desc->vsel_reg, &val);
 121         if (ret != 0)
 122                 return ret;
 123
 124         val &= rdev->desc->vsel_mask;
 125         val >>= ffs(rdev->desc->vsel_mask) - 1;
 126
 127         return val;
 128 }
 129 EXPORT_SYMBOL_GPL(regulator_get_voltage_sel_regmap);
 130
 131 /**
 132  * regulator_set_voltage_sel_regmap - standard set_voltage_sel for regmap users
 133  *
 134  * @rdev: regulator to operate on
 135  * @sel: Selector to set
 136  *
 137  * Regulators that use regmap for their register I/O can set the
 138  * vsel_reg and vsel_mask fields in their descriptor and then use this
 139  * as their set_voltage_vsel operation, saving some code.
 140  */
 141 int regulator_set_voltage_sel_regmap(struct regulator_dev *rdev, unsigned sel)
 142 {
 143         int ret;
 144
 145         sel <<= ffs(rdev->desc->vsel_mask) - 1;
 146
 147         ret = regmap_update_bits(rdev->regmap, rdev->desc->vsel_reg,
 148                                   rdev->desc->vsel_mask, sel);
 149         if (ret)
 150                 return ret;
 151
 152         if (rdev->desc->apply_bit)
 153                 ret = regmap_update_bits(rdev->regmap, rdev->desc->apply_reg,
 154                                          rdev->desc->apply_bit,
 155                                          rdev->desc->apply_bit);
 156         return ret;
 157 }
 158 EXPORT_SYMBOL_GPL(regulator_set_voltage_sel_regmap);
 159
 160 /**
 161  * regulator_map_voltage_iterate - map_voltage() based on list_voltage()
 162  *
 163  * @rdev: Regulator to operate on
 164  * @min_uV: Lower bound for voltage
 165  * @max_uV: Upper bound for voltage
 166  *
 167  * Drivers implementing set_voltage_sel() and list_voltage() can use
 168  * this as their map_voltage() operation.  It will find a suitable
 169  * voltage by calling list_voltage() until it gets something in bounds
 170  * for the requested voltages.
 171  */
 172 int regulator_map_voltage_iterate(struct regulator_dev *rdev,
 173                                   int min_uV, int max_uV)
 174 {
 175         int best_val = INT_MAX;
 176         int selector = 0;
 177         int i, ret;
 178
 179         /* Find the smallest voltage that falls within the specified
 180          * range.
 181          */
 182         for (i = 0; i < rdev->desc->n_voltages; i++) {
 183                 ret = rdev->desc->ops->list_voltage(rdev, i);
 184                 if (ret < 0)
 185                         continue;
 186
 187                 if (ret < best_val && ret >= min_uV && ret <= max_uV) {
 188                         best_val = ret;
 189                         selector = i;
 190                 }
 191         }
 192
 193         if (best_val != INT_MAX)
 194                 return selector;
 195         else
 196                 return -EINVAL;
 197 }
 198 EXPORT_SYMBOL_GPL(regulator_map_voltage_iterate);
 199
 200 /**
 201  * regulator_map_voltage_ascend - map_voltage() for ascendant voltage list
 202  *
 203  * @rdev: Regulator to operate on
 204  * @min_uV: Lower bound for voltage
 205  * @max_uV: Upper bound for voltage
 206  *
 207  * Drivers that have ascendant voltage list can use this as their
 208  * map_voltage() operation.
 209  */
 210 int regulator_map_voltage_ascend(struct regulator_dev *rdev,
 211                                  int min_uV, int max_uV)
 212 {
 213         int i, ret;
 214
 215         for (i = 0; i < rdev->desc->n_voltages; i++) {
 216                 ret = rdev->desc->ops->list_voltage(rdev, i);
 217                 if (ret < 0)
 218                         continue;
 219
 220                 if (ret > max_uV)
 221                         break;
 222
 223                 if (ret >= min_uV && ret <= max_uV)
 224                         return i;
 225         }
 226
 227         return -EINVAL;
 228 }
 229 EXPORT_SYMBOL_GPL(regulator_map_voltage_ascend);
 230
 231 /**
 232  * regulator_map_voltage_linear - map_voltage() for simple linear mappings
 233  *
 234  * @rdev: Regulator to operate on
 235  * @min_uV: Lower bound for voltage
 236  * @max_uV: Upper bound for voltage
 237  *
 238  * Drivers providing min_uV and uV_step in their regulator_desc can
 239  * use this as their map_voltage() operation.
 240  */
 241 int regulator_map_voltage_linear(struct regulator_dev *rdev,
 242                                  int min_uV, int max_uV)
 243 {
 244         int ret, voltage;
 245
 246         /* Allow uV_step to be 0 for fixed voltage */
 247         if (rdev->desc->n_voltages == 1 && rdev->desc->uV_step == 0) {
 248                 if (min_uV <= rdev->desc->min_uV && rdev->desc->min_uV <= max_uV)
 249                         return 0;
 250                 else
 251                         return -EINVAL;
 252         }
 253
 254         if (!rdev->desc->uV_step) {
 255                 BUG_ON(!rdev->desc->uV_step);
 256                 return -EINVAL;
 257         }
 258
 259         if (min_uV < rdev->desc->min_uV)
 260                 min_uV = rdev->desc->min_uV;
 261
 262         ret = DIV_ROUND_UP(min_uV - rdev->desc->min_uV, rdev->desc->uV_step);
 263         if (ret < 0)
 264                 return ret;
 265
 266         ret += rdev->desc->linear_min_sel;
 267
 268         /* Map back into a voltage to verify we're still in bounds */
 269         voltage = rdev->desc->ops->list_voltage(rdev, ret);
 270         if (voltage < min_uV || voltage > max_uV)
 271                 return -EINVAL;
 272
 273         return ret;
 274 }
 275 EXPORT_SYMBOL_GPL(regulator_map_voltage_linear);
 276
 277 /**
 278  * regulator_map_voltage_linear_range - map_voltage() for multiple linear ranges
 279  *
 280  * @rdev: Regulator to operate on
 281  * @min_uV: Lower bound for voltage
 282  * @max_uV: Upper bound for voltage
 283  *
 284  * Drivers providing linear_ranges in their descriptor can use this as
 285  * their map_voltage() callback.
 286  */
 287 int regulator_map_voltage_linear_range(struct regulator_dev *rdev,
 288                                        int min_uV, int max_uV)
 289 {
 290         const struct regulator_linear_range *range;
 291         int ret = -EINVAL;
 292         int voltage, i;
 293
 294         if (!rdev->desc->n_linear_ranges) {
 295                 BUG_ON(!rdev->desc->n_linear_ranges);
 296                 return -EINVAL;
 297         }
 298
 299         for (i = 0; i < rdev->desc->n_linear_ranges; i++) {
 300                 int linear_max_uV;
 301
 302                 range = &rdev->desc->linear_ranges[i];
 303                 linear_max_uV = range->min_uV +
 304                         (range->max_sel - range->min_sel) * range->uV_step;
 305
 306                 if (!(min_uV <= linear_max_uV && max_uV >= range->min_uV))
 307                         continue;
 308
 309                 if (min_uV <= range->min_uV)
 310                         min_uV = range->min_uV;
 311
 312                 /* range->uV_step == 0 means fixed voltage range */
 313                 if (range->uV_step == 0) {
 314                         ret = 0;
 315                 } else {
 316                         ret = DIV_ROUND_UP(min_uV - range->min_uV,
 317                                            range->uV_step);
 318                         if (ret < 0)
 319                                 return ret;
 320                 }
 321
 322                 ret += range->min_sel;
 323
 324                 break;
 325         }
 326
 327         if (i == rdev->desc->n_linear_ranges)
 328                 return -EINVAL;
 329
 330         /* Map back into a voltage to verify we're still in bounds */
 331         voltage = rdev->desc->ops->list_voltage(rdev, ret);
 332         if (voltage < min_uV || voltage > max_uV)
 333                 return -EINVAL;
 334
 335         return ret;
 336 }
 337 EXPORT_SYMBOL_GPL(regulator_map_voltage_linear_range);
 338
 339 /**
 340  * regulator_list_voltage_linear - List voltages with simple calculation
 341  *
 342  * @rdev: Regulator device
 343  * @selector: Selector to convert into a voltage
 344  *
 345  * Regulators with a simple linear mapping between voltages and
 346  * selectors can set min_uV and uV_step in the regulator descriptor
 347  * and then use this function as their list_voltage() operation,
 348  */
 349 int regulator_list_voltage_linear(struct regulator_dev *rdev,
 350                                   unsigned int selector)
 351 {
 352         if (selector >= rdev->desc->n_voltages)
 353                 return -EINVAL;
 354         if (selector < rdev->desc->linear_min_sel)
 355                 return 0;
 356
 357         selector -= rdev->desc->linear_min_sel;
 358
 359         return rdev->desc->min_uV + (rdev->desc->uV_step * selector);
 360 }
 361 EXPORT_SYMBOL_GPL(regulator_list_voltage_linear);
 362
 363 /**
 364  * regulator_list_voltage_linear_range - List voltages for linear ranges
 365  *
 366  * @rdev: Regulator device
 367  * @selector: Selector to convert into a voltage
 368  *
 369  * Regulators with a series of simple linear mappings between voltages
 370  * and selectors can set linear_ranges in the regulator descriptor and
 371  * then use this function as their list_voltage() operation,
 372  */
 373 int regulator_list_voltage_linear_range(struct regulator_dev *rdev,
 374                                         unsigned int selector)
 375 {
 376         const struct regulator_linear_range *range;
 377         int i;
 378
 379         if (!rdev->desc->n_linear_ranges) {
 380                 BUG_ON(!rdev->desc->n_linear_ranges);
 381                 return -EINVAL;
 382         }
 383
 384         for (i = 0; i < rdev->desc->n_linear_ranges; i++) {
 385                 range = &rdev->desc->linear_ranges[i];
 386
 387                 if (!(selector >= range->min_sel &&
 388                       selector <= range->max_sel))
 389                         continue;
 390
 391                 selector -= range->min_sel;
 392
 393                 return range->min_uV + (range->uV_step * selector);
 394         }
 395
 396         return -EINVAL;
 397 }
 398 EXPORT_SYMBOL_GPL(regulator_list_voltage_linear_range);
 399
 400 /**
 401  * regulator_list_voltage_table - List voltages with table based mapping
 402  *
 403  * @rdev: Regulator device
 404  * @selector: Selector to convert into a voltage
 405  *
 406  * Regulators with table based mapping between voltages and
 407  * selectors can set volt_table in the regulator descriptor
 408  * and then use this function as their list_voltage() operation.
 409  */
 410 int regulator_list_voltage_table(struct regulator_dev *rdev,
 411                                  unsigned int selector)
 412 {
 413         if (!rdev->desc->volt_table) {
 414                 BUG_ON(!rdev->desc->volt_table);
 415                 return -EINVAL;
 416         }
 417
 418         if (selector >= rdev->desc->n_voltages)
 419                 return -EINVAL;
 420
 421         return rdev->desc->volt_table[selector];
 422 }
 423 EXPORT_SYMBOL_GPL(regulator_list_voltage_table);
 424
 425 /**
 426  * regulator_set_bypass_regmap - Default set_bypass() using regmap
 427  *
 428  * @rdev: device to operate on.
 429  * @enable: state to set.
 430  */
 431 int regulator_set_bypass_regmap(struct regulator_dev *rdev, bool enable)
 432 {
 433         unsigned int val;
 434
 435         if (enable) {
 436                 val = rdev->desc->bypass_val_on;
 437                 if (!val)
 438                         val = rdev->desc->bypass_mask;
 439         } else {
 440                 val = rdev->desc->bypass_val_off;
 441         }
 442
 443         return regmap_update_bits(rdev->regmap, rdev->desc->bypass_reg,
 444                                   rdev->desc->bypass_mask, val);
 445 }
 446 EXPORT_SYMBOL_GPL(regulator_set_bypass_regmap);
 447
 448 /**
 449  * regulator_get_bypass_regmap - Default get_bypass() using regmap
 450  *
 451  * @rdev: device to operate on.
 452  * @enable: current state.
 453  */
 454 int regulator_get_bypass_regmap(struct regulator_dev *rdev, bool *enable)
 455 {
 456         unsigned int val;
 457         int ret;
 458
 459         ret = regmap_read(rdev->regmap, rdev->desc->bypass_reg, &val);
 460         if (ret != 0)
 461                 return ret;
 462
 463         *enable = (val & rdev->desc->bypass_mask) == rdev->desc->bypass_val_on;
 464
 465         return 0;
 466 }
 467 EXPORT_SYMBOL_GPL(regulator_get_bypass_regmap);
 468
 469 /**
 470  * regulator_set_active_discharge_regmap - Default set_active_discharge()
 471  *                                         using regmap
 472  *
 473  * @rdev: device to operate on.
 474  * @enable: state to set, 0 to disable and 1 to enable.
 475  */
 476 int regulator_set_active_discharge_regmap(struct regulator_dev *rdev,
 477                                           bool enable)
 478 {
 479         unsigned int val;
 480
 481         if (enable)
 482                 val = rdev->desc->active_discharge_on;
 483         else
 484                 val = rdev->desc->active_discharge_off;
 485
 486         return regmap_update_bits(rdev->regmap,
 487                                   rdev->desc->active_discharge_reg,
 488                                   rdev->desc->active_discharge_mask, val);
 489 }
 490 EXPORT_SYMBOL_GPL(regulator_set_active_discharge_regmap);