drivers/regulator/core.c

   1 /*
   2  * core.c  --  Voltage/Current Regulator framework.
   3  *
   4  * Copyright 2007, 2008 Wolfson Microelectronics PLC.
   5  * Copyright 2008 SlimLogic Ltd.
   6  *
   7  * Author: Liam Girdwood <lrg@slimlogic.co.uk>
   8  *
   9  *  This program is free software; you can redistribute  it and/or modify it
  10  *  under  the terms of  the GNU General  Public License as published by the
  11  *  Free Software Foundation;  either version 2 of the  License, or (at your
  12  *  option) any later version.
  13  *
  14  */
  15
  16 #include <linux/kernel.h>
  17 #include <linux/init.h>
  18 #include <linux/debugfs.h>
  19 #include <linux/device.h>
  20 #include <linux/slab.h>
  21 #include <linux/async.h>
  22 #include <linux/err.h>
  23 #include <linux/mutex.h>
  24 #include <linux/suspend.h>
  25 #include <linux/delay.h>
  26 #include <linux/gpio.h>
  27 #include <linux/of.h>
  28 #include <linux/regmap.h>
  29 #include <linux/regulator/of_regulator.h>
  30 #include <linux/regulator/consumer.h>
  31 #include <linux/regulator/driver.h>
  32 #include <linux/regulator/machine.h>
  33 #include <linux/module.h>
  34
  35 #define CREATE_TRACE_POINTS
  36 #include <trace/events/regulator.h>
  37
  38 #include "dummy.h"
  39
  40 #define rdev_crit(rdev, fmt, ...)                                       \
  41         pr_crit("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
  42 #define rdev_err(rdev, fmt, ...)                                        \
  43         pr_err("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
  44 #define rdev_warn(rdev, fmt, ...)                                       \
  45         pr_warn("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
  46 #define rdev_info(rdev, fmt, ...)                                       \
  47         pr_info("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
  48 #define rdev_dbg(rdev, fmt, ...)                                        \
  49         pr_debug("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
  50
  51 static DEFINE_MUTEX(regulator_list_mutex);
  52 static LIST_HEAD(regulator_list);
  53 static LIST_HEAD(regulator_map_list);
  54 static bool has_full_constraints;
  55 static bool board_wants_dummy_regulator;
  56
  57 static struct dentry *debugfs_root;
  58
  59 /*
  60  * struct regulator_map
  61  *
  62  * Used to provide symbolic supply names to devices.
  63  */
  64 struct regulator_map {
  65         struct list_head list;
  66         const char *dev_name;   /* The dev_name() for the consumer */
  67         const char *supply;
  68         struct regulator_dev *regulator;
  69 };
  70
  71 /*
  72  * struct regulator
  73  *
  74  * One for each consumer device.
  75  */
  76 struct regulator {
  77         struct device *dev;
  78         struct list_head list;
  79         unsigned int always_on:1;
  80         int uA_load;
  81         int min_uV;
  82         int max_uV;
  83         char *supply_name;
  84         struct device_attribute dev_attr;
  85         struct regulator_dev *rdev;
  86         struct dentry *debugfs;
  87 };
  88
  89 static int _regulator_is_enabled(struct regulator_dev *rdev);
  90 static int _regulator_disable(struct regulator_dev *rdev);
  91 static int _regulator_get_voltage(struct regulator_dev *rdev);
  92 static int _regulator_get_current_limit(struct regulator_dev *rdev);
  93 static unsigned int _regulator_get_mode(struct regulator_dev *rdev);
  94 static void _notifier_call_chain(struct regulator_dev *rdev,
  95                                   unsigned long event, void *data);
  96 static int _regulator_do_set_voltage(struct regulator_dev *rdev,
  97                                      int min_uV, int max_uV);
  98 static struct regulator *create_regulator(struct regulator_dev *rdev,
  99                                           struct device *dev,
 100                                           const char *supply_name);
 101
 102 static const char *rdev_get_name(struct regulator_dev *rdev)
 103 {
 104         if (rdev->constraints && rdev->constraints->name)
 105                 return rdev->constraints->name;
 106         else if (rdev->desc->name)
 107                 return rdev->desc->name;
 108         else
 109                 return "";
 110 }
 111
 112 /**
 113  * of_get_regulator - get a regulator device node based on supply name
 114  * @dev: Device pointer for the consumer (of regulator) device
 115  * @supply: regulator supply name
 116  *
 117  * Extract the regulator device node corresponding to the supply name.
 118  * retruns the device node corresponding to the regulator if found, else
 119  * returns NULL.
 120  */
 121 static struct device_node *of_get_regulator(struct device *dev, const char *supply)
 122 {
 123         struct device_node *regnode = NULL;
 124         char prop_name[32]; /* 32 is max size of property name */
 125
 126         dev_dbg(dev, "Looking up %s-supply from device tree\n", supply);
 127
 128         snprintf(prop_name, 32, "%s-supply", supply);
 129         regnode = of_parse_phandle(dev->of_node, prop_name, 0);
 130
 131         if (!regnode) {
 132                 dev_dbg(dev, "Looking up %s property in node %s failed",
 133                                 prop_name, dev->of_node->full_name);
 134                 return NULL;
 135         }
 136         return regnode;
 137 }
 138
 139 static int _regulator_can_change_status(struct regulator_dev *rdev)
 140 {
 141         if (!rdev->constraints)
 142                 return 0;
 143
 144         if (rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_STATUS)
 145                 return 1;
 146         else
 147                 return 0;
 148 }
 149
 150 /* Platform voltage constraint check */
 151 static int regulator_check_voltage(struct regulator_dev *rdev,
 152                                    int *min_uV, int *max_uV)
 153 {
 154         BUG_ON(*min_uV > *max_uV);
 155
 156         if (!rdev->constraints) {
 157                 rdev_err(rdev, "no constraints\n");
 158                 return -ENODEV;
 159         }
 160         if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_VOLTAGE)) {
 161                 rdev_err(rdev, "operation not allowed\n");
 162                 return -EPERM;
 163         }
 164
 165         if (*max_uV > rdev->constraints->max_uV)
 166                 *max_uV = rdev->constraints->max_uV;
 167         if (*min_uV < rdev->constraints->min_uV)
 168                 *min_uV = rdev->constraints->min_uV;
 169
 170         if (*min_uV > *max_uV) {
 171                 rdev_err(rdev, "unsupportable voltage range: %d-%duV\n",
 172                          *min_uV, *max_uV);
 173                 return -EINVAL;
 174         }
 175
 176         return 0;
 177 }
 178
 179 /* Make sure we select a voltage that suits the needs of all
 180  * regulator consumers
 181  */
 182 static int regulator_check_consumers(struct regulator_dev *rdev,
 183                                      int *min_uV, int *max_uV)
 184 {
 185         struct regulator *regulator;
 186
 187         list_for_each_entry(regulator, &rdev->consumer_list, list) {
 188                 /*
 189                  * Assume consumers that didn't say anything are OK
 190                  * with anything in the constraint range.
 191                  */
 192                 if (!regulator->min_uV && !regulator->max_uV)
 193                         continue;
 194
 195                 if (*max_uV > regulator->max_uV)
 196                         *max_uV = regulator->max_uV;
 197                 if (*min_uV < regulator->min_uV)
 198                         *min_uV = regulator->min_uV;
 199         }
 200
 201         if (*min_uV > *max_uV)
 202                 return -EINVAL;
 203
 204         return 0;
 205 }
 206
 207 /* current constraint check */
 208 static int regulator_check_current_limit(struct regulator_dev *rdev,
 209                                         int *min_uA, int *max_uA)
 210 {
 211         BUG_ON(*min_uA > *max_uA);
 212
 213         if (!rdev->constraints) {
 214                 rdev_err(rdev, "no constraints\n");
 215                 return -ENODEV;
 216         }
 217         if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_CURRENT)) {
 218                 rdev_err(rdev, "operation not allowed\n");
 219                 return -EPERM;
 220         }
 221
 222         if (*max_uA > rdev->constraints->max_uA)
 223                 *max_uA = rdev->constraints->max_uA;
 224         if (*min_uA < rdev->constraints->min_uA)
 225                 *min_uA = rdev->constraints->min_uA;
 226
 227         if (*min_uA > *max_uA) {
 228                 rdev_err(rdev, "unsupportable current range: %d-%duA\n",
 229                          *min_uA, *max_uA);
 230                 return -EINVAL;
 231         }
 232
 233         return 0;
 234 }
 235
 236 /* operating mode constraint check */
 237 static int regulator_mode_constrain(struct regulator_dev *rdev, int *mode)
 238 {
 239         switch (*mode) {
 240         case REGULATOR_MODE_FAST:
 241         case REGULATOR_MODE_NORMAL:
 242         case REGULATOR_MODE_IDLE:
 243         case REGULATOR_MODE_STANDBY:
 244                 break;
 245         default:
 246                 rdev_err(rdev, "invalid mode %x specified\n", *mode);
 247                 return -EINVAL;
 248         }
 249
 250         if (!rdev->constraints) {
 251                 rdev_err(rdev, "no constraints\n");
 252                 return -ENODEV;
 253         }
 254         if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_MODE)) {
 255                 rdev_err(rdev, "operation not allowed\n");
 256                 return -EPERM;
 257         }
 258
 259         /* The modes are bitmasks, the most power hungry modes having
 260          * the lowest values. If the requested mode isn't supported
 261          * try higher modes. */
 262         while (*mode) {
 263                 if (rdev->constraints->valid_modes_mask & *mode)
 264                         return 0;
 265                 *mode /= 2;
 266         }
 267
 268         return -EINVAL;
 269 }
 270
 271 /* dynamic regulator mode switching constraint check */
 272 static int regulator_check_drms(struct regulator_dev *rdev)
 273 {
 274         if (!rdev->constraints) {
 275                 rdev_err(rdev, "no constraints\n");
 276                 return -ENODEV;
 277         }
 278         if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_DRMS)) {
 279                 rdev_err(rdev, "operation not allowed\n");
 280                 return -EPERM;
 281         }
 282         return 0;
 283 }
 284
 285 static ssize_t regulator_uV_show(struct device *dev,
 286                                 struct device_attribute *attr, char *buf)
 287 {
 288         struct regulator_dev *rdev = dev_get_drvdata(dev);
 289         ssize_t ret;
 290
 291         mutex_lock(&rdev->mutex);
 292         ret = sprintf(buf, "%d\n", _regulator_get_voltage(rdev));
 293         mutex_unlock(&rdev->mutex);
 294
 295         return ret;
 296 }
 297 static DEVICE_ATTR(microvolts, 0444, regulator_uV_show, NULL);
 298
 299 static ssize_t regulator_uA_show(struct device *dev,
 300                                 struct device_attribute *attr, char *buf)
 301 {
 302         struct regulator_dev *rdev = dev_get_drvdata(dev);
 303
 304         return sprintf(buf, "%d\n", _regulator_get_current_limit(rdev));
 305 }
 306 static DEVICE_ATTR(microamps, 0444, regulator_uA_show, NULL);
 307
 308 static ssize_t regulator_name_show(struct device *dev,
 309                              struct device_attribute *attr, char *buf)
 310 {
 311         struct regulator_dev *rdev = dev_get_drvdata(dev);
 312
 313         return sprintf(buf, "%s\n", rdev_get_name(rdev));
 314 }
 315
 316 static ssize_t regulator_print_opmode(char *buf, int mode)
 317 {
 318         switch (mode) {
 319         case REGULATOR_MODE_FAST:
 320                 return sprintf(buf, "fast\n");
 321         case REGULATOR_MODE_NORMAL:
 322                 return sprintf(buf, "normal\n");
 323         case REGULATOR_MODE_IDLE:
 324                 return sprintf(buf, "idle\n");
 325         case REGULATOR_MODE_STANDBY:
 326                 return sprintf(buf, "standby\n");
 327         }
 328         return sprintf(buf, "unknown\n");
 329 }
 330
 331 static ssize_t regulator_opmode_show(struct device *dev,
 332                                     struct device_attribute *attr, char *buf)
 333 {
 334         struct regulator_dev *rdev = dev_get_drvdata(dev);
 335
 336         return regulator_print_opmode(buf, _regulator_get_mode(rdev));
 337 }
 338 static DEVICE_ATTR(opmode, 0444, regulator_opmode_show, NULL);
 339
 340 static ssize_t regulator_print_state(char *buf, int state)
 341 {
 342         if (state > 0)
 343                 return sprintf(buf, "enabled\n");
 344         else if (state == 0)
 345                 return sprintf(buf, "disabled\n");
 346         else
 347                 return sprintf(buf, "unknown\n");
 348 }
 349
 350 static ssize_t regulator_state_show(struct device *dev,
 351                                    struct device_attribute *attr, char *buf)
 352 {
 353         struct regulator_dev *rdev = dev_get_drvdata(dev);
 354         ssize_t ret;
 355
 356         mutex_lock(&rdev->mutex);
 357         ret = regulator_print_state(buf, _regulator_is_enabled(rdev));
 358         mutex_unlock(&rdev->mutex);
 359
 360         return ret;
 361 }
 362 static DEVICE_ATTR(state, 0444, regulator_state_show, NULL);
 363
 364 static ssize_t regulator_status_show(struct device *dev,
 365                                    struct device_attribute *attr, char *buf)
 366 {
 367         struct regulator_dev *rdev = dev_get_drvdata(dev);
 368         int status;
 369         char *label;
 370
 371         status = rdev->desc->ops->get_status(rdev);
 372         if (status < 0)
 373                 return status;
 374
 375         switch (status) {
 376         case REGULATOR_STATUS_OFF:
 377                 label = "off";
 378                 break;
 379         case REGULATOR_STATUS_ON:
 380                 label = "on";
 381                 break;
 382         case REGULATOR_STATUS_ERROR:
 383                 label = "error";
 384                 break;
 385         case REGULATOR_STATUS_FAST:
 386                 label = "fast";
 387                 break;
 388         case REGULATOR_STATUS_NORMAL:
 389                 label = "normal";
 390                 break;
 391         case REGULATOR_STATUS_IDLE:
 392                 label = "idle";
 393                 break;
 394         case REGULATOR_STATUS_STANDBY:
 395                 label = "standby";
 396                 break;
 397         case REGULATOR_STATUS_UNDEFINED:
 398                 label = "undefined";
 399                 break;
 400         default:
 401                 return -ERANGE;
 402         }
 403
 404         return sprintf(buf, "%s\n", label);
 405 }
 406 static DEVICE_ATTR(status, 0444, regulator_status_show, NULL);
 407
 408 static ssize_t regulator_min_uA_show(struct device *dev,
 409                                     struct device_attribute *attr, char *buf)
 410 {
 411         struct regulator_dev *rdev = dev_get_drvdata(dev);
 412
 413         if (!rdev->constraints)
 414                 return sprintf(buf, "constraint not defined\n");
 415
 416         return sprintf(buf, "%d\n", rdev->constraints->min_uA);
 417 }
 418 static DEVICE_ATTR(min_microamps, 0444, regulator_min_uA_show, NULL);
 419
 420 static ssize_t regulator_max_uA_show(struct device *dev,
 421                                     struct device_attribute *attr, char *buf)
 422 {
 423         struct regulator_dev *rdev = dev_get_drvdata(dev);
 424
 425         if (!rdev->constraints)
 426                 return sprintf(buf, "constraint not defined\n");
 427
 428         return sprintf(buf, "%d\n", rdev->constraints->max_uA);
 429 }
 430 static DEVICE_ATTR(max_microamps, 0444, regulator_max_uA_show, NULL);
 431
 432 static ssize_t regulator_min_uV_show(struct device *dev,
 433                                     struct device_attribute *attr, char *buf)
 434 {
 435         struct regulator_dev *rdev = dev_get_drvdata(dev);
 436
 437         if (!rdev->constraints)
 438                 return sprintf(buf, "constraint not defined\n");
 439
 440         return sprintf(buf, "%d\n", rdev->constraints->min_uV);
 441 }
 442 static DEVICE_ATTR(min_microvolts, 0444, regulator_min_uV_show, NULL);
 443
 444 static ssize_t regulator_max_uV_show(struct device *dev,
 445                                     struct device_attribute *attr, char *buf)
 446 {
 447         struct regulator_dev *rdev = dev_get_drvdata(dev);
 448
 449         if (!rdev->constraints)
 450                 return sprintf(buf, "constraint not defined\n");
 451
 452         return sprintf(buf, "%d\n", rdev->constraints->max_uV);
 453 }
 454 static DEVICE_ATTR(max_microvolts, 0444, regulator_max_uV_show, NULL);
 455
 456 static ssize_t regulator_total_uA_show(struct device *dev,
 457                                       struct device_attribute *attr, char *buf)
 458 {
 459         struct regulator_dev *rdev = dev_get_drvdata(dev);
 460         struct regulator *regulator;
 461         int uA = 0;
 462
 463         mutex_lock(&rdev->mutex);
 464         list_for_each_entry(regulator, &rdev->consumer_list, list)
 465                 uA += regulator->uA_load;
 466         mutex_unlock(&rdev->mutex);
 467         return sprintf(buf, "%d\n", uA);
 468 }
 469 static DEVICE_ATTR(requested_microamps, 0444, regulator_total_uA_show, NULL);
 470
 471 static ssize_t regulator_num_users_show(struct device *dev,
 472                                       struct device_attribute *attr, char *buf)
 473 {
 474         struct regulator_dev *rdev = dev_get_drvdata(dev);
 475         return sprintf(buf, "%d\n", rdev->use_count);
 476 }
 477
 478 static ssize_t regulator_type_show(struct device *dev,
 479                                   struct device_attribute *attr, char *buf)
 480 {
 481         struct regulator_dev *rdev = dev_get_drvdata(dev);
 482
 483         switch (rdev->desc->type) {
 484         case REGULATOR_VOLTAGE:
 485                 return sprintf(buf, "voltage\n");
 486         case REGULATOR_CURRENT:
 487                 return sprintf(buf, "current\n");
 488         }
 489         return sprintf(buf, "unknown\n");
 490 }
 491
 492 static ssize_t regulator_suspend_mem_uV_show(struct device *dev,
 493                                 struct device_attribute *attr, char *buf)
 494 {
 495         struct regulator_dev *rdev = dev_get_drvdata(dev);
 496
 497         return sprintf(buf, "%d\n", rdev->constraints->state_mem.uV);
 498 }
 499 static DEVICE_ATTR(suspend_mem_microvolts, 0444,
 500                 regulator_suspend_mem_uV_show, NULL);
 501
 502 static ssize_t regulator_suspend_disk_uV_show(struct device *dev,
 503                                 struct device_attribute *attr, char *buf)
 504 {
 505         struct regulator_dev *rdev = dev_get_drvdata(dev);
 506
 507         return sprintf(buf, "%d\n", rdev->constraints->state_disk.uV);
 508 }
 509 static DEVICE_ATTR(suspend_disk_microvolts, 0444,
 510                 regulator_suspend_disk_uV_show, NULL);
 511
 512 static ssize_t regulator_suspend_standby_uV_show(struct device *dev,
 513                                 struct device_attribute *attr, char *buf)
 514 {
 515         struct regulator_dev *rdev = dev_get_drvdata(dev);
 516
 517         return sprintf(buf, "%d\n", rdev->constraints->state_standby.uV);
 518 }
 519 static DEVICE_ATTR(suspend_standby_microvolts, 0444,
 520                 regulator_suspend_standby_uV_show, NULL);
 521
 522 static ssize_t regulator_suspend_mem_mode_show(struct device *dev,
 523                                 struct device_attribute *attr, char *buf)
 524 {
 525         struct regulator_dev *rdev = dev_get_drvdata(dev);
 526
 527         return regulator_print_opmode(buf,
 528                 rdev->constraints->state_mem.mode);
 529 }
 530 static DEVICE_ATTR(suspend_mem_mode, 0444,
 531                 regulator_suspend_mem_mode_show, NULL);
 532
 533 static ssize_t regulator_suspend_disk_mode_show(struct device *dev,
 534                                 struct device_attribute *attr, char *buf)
 535 {
 536         struct regulator_dev *rdev = dev_get_drvdata(dev);
 537
 538         return regulator_print_opmode(buf,
 539                 rdev->constraints->state_disk.mode);
 540 }
 541 static DEVICE_ATTR(suspend_disk_mode, 0444,
 542                 regulator_suspend_disk_mode_show, NULL);
 543
 544 static ssize_t regulator_suspend_standby_mode_show(struct device *dev,
 545                                 struct device_attribute *attr, char *buf)
 546 {
 547         struct regulator_dev *rdev = dev_get_drvdata(dev);
 548
 549         return regulator_print_opmode(buf,
 550                 rdev->constraints->state_standby.mode);
 551 }
 552 static DEVICE_ATTR(suspend_standby_mode, 0444,
 553                 regulator_suspend_standby_mode_show, NULL);
 554
 555 static ssize_t regulator_suspend_mem_state_show(struct device *dev,
 556                                    struct device_attribute *attr, char *buf)
 557 {
 558         struct regulator_dev *rdev = dev_get_drvdata(dev);
 559
 560         return regulator_print_state(buf,
 561                         rdev->constraints->state_mem.enabled);
 562 }
 563 static DEVICE_ATTR(suspend_mem_state, 0444,
 564                 regulator_suspend_mem_state_show, NULL);
 565
 566 static ssize_t regulator_suspend_disk_state_show(struct device *dev,
 567                                    struct device_attribute *attr, char *buf)
 568 {
 569         struct regulator_dev *rdev = dev_get_drvdata(dev);
 570
 571         return regulator_print_state(buf,
 572                         rdev->constraints->state_disk.enabled);
 573 }
 574 static DEVICE_ATTR(suspend_disk_state, 0444,
 575                 regulator_suspend_disk_state_show, NULL);
 576
 577 static ssize_t regulator_suspend_standby_state_show(struct device *dev,
 578                                    struct device_attribute *attr, char *buf)
 579 {
 580         struct regulator_dev *rdev = dev_get_drvdata(dev);
 581
 582         return regulator_print_state(buf,
 583                         rdev->constraints->state_standby.enabled);
 584 }
 585 static DEVICE_ATTR(suspend_standby_state, 0444,
 586                 regulator_suspend_standby_state_show, NULL);
 587
 588
 589 /*
 590  * These are the only attributes are present for all regulators.
 591  * Other attributes are a function of regulator functionality.
 592  */
 593 static struct device_attribute regulator_dev_attrs[] = {
 594         __ATTR(name, 0444, regulator_name_show, NULL),
 595         __ATTR(num_users, 0444, regulator_num_users_show, NULL),
 596         __ATTR(type, 0444, regulator_type_show, NULL),
 597         __ATTR_NULL,
 598 };
 599
 600 static void regulator_dev_release(struct device *dev)
 601 {
 602         struct regulator_dev *rdev = dev_get_drvdata(dev);
 603         kfree(rdev);
 604 }
 605
 606 static struct class regulator_class = {
 607         .name = "regulator",
 608         .dev_release = regulator_dev_release,
 609         .dev_attrs = regulator_dev_attrs,
 610 };
 611
 612 /* Calculate the new optimum regulator operating mode based on the new total
 613  * consumer load. All locks held by caller */
 614 static void drms_uA_update(struct regulator_dev *rdev)
 615 {
 616         struct regulator *sibling;
 617         int current_uA = 0, output_uV, input_uV, err;
 618         unsigned int mode;
 619
 620         err = regulator_check_drms(rdev);
 621         if (err < 0 || !rdev->desc->ops->get_optimum_mode ||
 622             (!rdev->desc->ops->get_voltage &&
 623              !rdev->desc->ops->get_voltage_sel) ||
 624             !rdev->desc->ops->set_mode)
 625                 return;
 626
 627         /* get output voltage */
 628         output_uV = _regulator_get_voltage(rdev);
 629         if (output_uV <= 0)
 630                 return;
 631
 632         /* get input voltage */
 633         input_uV = 0;
 634         if (rdev->supply)
 635                 input_uV = regulator_get_voltage(rdev->supply);
 636         if (input_uV <= 0)
 637                 input_uV = rdev->constraints->input_uV;
 638         if (input_uV <= 0)
 639                 return;
 640
 641         /* calc total requested load */
 642         list_for_each_entry(sibling, &rdev->consumer_list, list)
 643                 current_uA += sibling->uA_load;
 644
 645         /* now get the optimum mode for our new total regulator load */
 646         mode = rdev->desc->ops->get_optimum_mode(rdev, input_uV,
 647                                                   output_uV, current_uA);
 648
 649         /* check the new mode is allowed */
 650         err = regulator_mode_constrain(rdev, &mode);
 651         if (err == 0)
 652                 rdev->desc->ops->set_mode(rdev, mode);
 653 }
 654
 655 static int suspend_set_state(struct regulator_dev *rdev,
 656         struct regulator_state *rstate)
 657 {
 658         int ret = 0;
 659
 660         /* If we have no suspend mode configration don't set anything;
 661          * only warn if the driver implements set_suspend_voltage or
 662          * set_suspend_mode callback.
 663          */
 664         if (!rstate->enabled && !rstate->disabled) {
 665                 if (rdev->desc->ops->set_suspend_voltage ||
 666                     rdev->desc->ops->set_suspend_mode)
 667                         rdev_warn(rdev, "No configuration\n");
 668                 return 0;
 669         }
 670
 671         if (rstate->enabled && rstate->disabled) {
 672                 rdev_err(rdev, "invalid configuration\n");
 673                 return -EINVAL;
 674         }
 675
 676         if (rstate->enabled && rdev->desc->ops->set_suspend_enable)
 677                 ret = rdev->desc->ops->set_suspend_enable(rdev);
 678         else if (rstate->disabled && rdev->desc->ops->set_suspend_disable)
 679                 ret = rdev->desc->ops->set_suspend_disable(rdev);
 680         else /* OK if set_suspend_enable or set_suspend_disable is NULL */
 681                 ret = 0;
 682
 683         if (ret < 0) {
 684                 rdev_err(rdev, "failed to enabled/disable\n");
 685                 return ret;
 686         }
 687
 688         if (rdev->desc->ops->set_suspend_voltage && rstate->uV > 0) {
 689                 ret = rdev->desc->ops->set_suspend_voltage(rdev, rstate->uV);
 690                 if (ret < 0) {
 691                         rdev_err(rdev, "failed to set voltage\n");
 692                         return ret;
 693                 }
 694         }
 695
 696         if (rdev->desc->ops->set_suspend_mode && rstate->mode > 0) {
 697                 ret = rdev->desc->ops->set_suspend_mode(rdev, rstate->mode);
 698                 if (ret < 0) {
 699                         rdev_err(rdev, "failed to set mode\n");
 700                         return ret;
 701                 }
 702         }
 703         return ret;
 704 }
 705
 706 /* locks held by caller */
 707 static int suspend_prepare(struct regulator_dev *rdev, suspend_state_t state)
 708 {
 709         if (!rdev->constraints)
 710                 return -EINVAL;
 711
 712         switch (state) {
 713         case PM_SUSPEND_STANDBY:
 714                 return suspend_set_state(rdev,
 715                         &rdev->constraints->state_standby);
 716         case PM_SUSPEND_MEM:
 717                 return suspend_set_state(rdev,
 718                         &rdev->constraints->state_mem);
 719         case PM_SUSPEND_MAX:
 720                 return suspend_set_state(rdev,
 721                         &rdev->constraints->state_disk);
 722         default:
 723                 return -EINVAL;
 724         }
 725 }
 726
 727 static void print_constraints(struct regulator_dev *rdev)
 728 {
 729         struct regulation_constraints *constraints = rdev->constraints;
 730         char buf[80] = "";
 731         int count = 0;
 732         int ret;
 733
 734         if (constraints->min_uV && constraints->max_uV) {
 735                 if (constraints->min_uV == constraints->max_uV)
 736                         count += sprintf(buf + count, "%d mV ",
 737                                          constraints->min_uV / 1000);
 738                 else
 739                         count += sprintf(buf + count, "%d <--> %d mV ",
 740                                          constraints->min_uV / 1000,
 741                                          constraints->max_uV / 1000);
 742         }
 743
 744         if (!constraints->min_uV ||
 745             constraints->min_uV != constraints->max_uV) {
 746                 ret = _regulator_get_voltage(rdev);
 747                 if (ret > 0)
 748                         count += sprintf(buf + count, "at %d mV ", ret / 1000);
 749         }
 750
 751         if (constraints->uV_offset)
 752                 count += sprintf(buf, "%dmV offset ",
 753                                  constraints->uV_offset / 1000);
 754
 755         if (constraints->min_uA && constraints->max_uA) {
 756                 if (constraints->min_uA == constraints->max_uA)
 757                         count += sprintf(buf + count, "%d mA ",
 758                                          constraints->min_uA / 1000);
 759                 else
 760                         count += sprintf(buf + count, "%d <--> %d mA ",
 761                                          constraints->min_uA / 1000,
 762                                          constraints->max_uA / 1000);
 763         }
 764
 765         if (!constraints->min_uA ||
 766             constraints->min_uA != constraints->max_uA) {
 767                 ret = _regulator_get_current_limit(rdev);
 768                 if (ret > 0)
 769                         count += sprintf(buf + count, "at %d mA ", ret / 1000);
 770         }
 771
 772         if (constraints->valid_modes_mask & REGULATOR_MODE_FAST)
 773                 count += sprintf(buf + count, "fast ");
 774         if (constraints->valid_modes_mask & REGULATOR_MODE_NORMAL)
 775                 count += sprintf(buf + count, "normal ");
 776         if (constraints->valid_modes_mask & REGULATOR_MODE_IDLE)
 777                 count += sprintf(buf + count, "idle ");
 778         if (constraints->valid_modes_mask & REGULATOR_MODE_STANDBY)
 779                 count += sprintf(buf + count, "standby");
 780
 781         if (!count)
 782                 sprintf(buf, "no parameters");
 783
 784         rdev_info(rdev, "%s\n", buf);
 785
 786         if ((constraints->min_uV != constraints->max_uV) &&
 787             !(constraints->valid_ops_mask & REGULATOR_CHANGE_VOLTAGE))
 788                 rdev_warn(rdev,
 789                           "Voltage range but no REGULATOR_CHANGE_VOLTAGE\n");
 790 }
 791
 792 static int machine_constraints_voltage(struct regulator_dev *rdev,
 793         struct regulation_constraints *constraints)
 794 {
 795         struct regulator_ops *ops = rdev->desc->ops;
 796         int ret;
 797
 798         /* do we need to apply the constraint voltage */
 799         if (rdev->constraints->apply_uV &&
 800             rdev->constraints->min_uV == rdev->constraints->max_uV) {
 801                 ret = _regulator_do_set_voltage(rdev,
 802                                                 rdev->constraints->min_uV,
 803                                                 rdev->constraints->max_uV);
 804                 if (ret < 0) {
 805                         rdev_err(rdev, "failed to apply %duV constraint\n",
 806                                  rdev->constraints->min_uV);
 807                         return ret;
 808                 }
 809         }
 810
 811         /* constrain machine-level voltage specs to fit
 812          * the actual range supported by this regulator.
 813          */
 814         if (ops->list_voltage && rdev->desc->n_voltages) {
 815                 int     count = rdev->desc->n_voltages;
 816                 int     i;
 817                 int     min_uV = INT_MAX;
 818                 int     max_uV = INT_MIN;
 819                 int     cmin = constraints->min_uV;
 820                 int     cmax = constraints->max_uV;
 821
 822                 /* it's safe to autoconfigure fixed-voltage supplies
 823                    and the constraints are used by list_voltage. */
 824                 if (count == 1 && !cmin) {
 825                         cmin = 1;
 826                         cmax = INT_MAX;
 827                         constraints->min_uV = cmin;
 828                         constraints->max_uV = cmax;
 829                 }
 830
 831                 /* voltage constraints are optional */
 832                 if ((cmin == 0) && (cmax == 0))
 833                         return 0;
 834
 835                 /* else require explicit machine-level constraints */
 836                 if (cmin <= 0 || cmax <= 0 || cmax < cmin) {
 837                         rdev_err(rdev, "invalid voltage constraints\n");
 838                         return -EINVAL;
 839                 }
 840
 841                 /* initial: [cmin..cmax] valid, [min_uV..max_uV] not */
 842                 for (i = 0; i < count; i++) {
 843                         int     value;
 844
 845                         value = ops->list_voltage(rdev, i);
 846                         if (value <= 0)
 847                                 continue;
 848
 849                         /* maybe adjust [min_uV..max_uV] */
 850                         if (value >= cmin && value < min_uV)
 851                                 min_uV = value;
 852                         if (value <= cmax && value > max_uV)
 853                                 max_uV = value;
 854                 }
 855
 856                 /* final: [min_uV..max_uV] valid iff constraints valid */
 857                 if (max_uV < min_uV) {
 858                         rdev_err(rdev, "unsupportable voltage constraints\n");
 859                         return -EINVAL;
 860                 }
 861
 862                 /* use regulator's subset of machine constraints */
 863                 if (constraints->min_uV < min_uV) {
 864                         rdev_dbg(rdev, "override min_uV, %d -> %d\n",
 865                                  constraints->min_uV, min_uV);
 866                         constraints->min_uV = min_uV;
 867                 }
 868                 if (constraints->max_uV > max_uV) {
 869                         rdev_dbg(rdev, "override max_uV, %d -> %d\n",
 870                                  constraints->max_uV, max_uV);
 871                         constraints->max_uV = max_uV;
 872                 }
 873         }
 874
 875         return 0;
 876 }
 877
 878 /**
 879  * set_machine_constraints - sets regulator constraints
 880  * @rdev: regulator source
 881  * @constraints: constraints to apply
 882  *
 883  * Allows platform initialisation code to define and constrain
 884  * regulator circuits e.g. valid voltage/current ranges, etc.  NOTE:
 885  * Constraints *must* be set by platform code in order for some
 886  * regulator operations to proceed i.e. set_voltage, set_current_limit,
 887  * set_mode.
 888  */
 889 static int set_machine_constraints(struct regulator_dev *rdev,
 890         const struct regulation_constraints *constraints)
 891 {
 892         int ret = 0;
 893         struct regulator_ops *ops = rdev->desc->ops;
 894
 895         if (constraints)
 896                 rdev->constraints = kmemdup(constraints, sizeof(*constraints),
 897                                             GFP_KERNEL);
 898         else
 899                 rdev->constraints = kzalloc(sizeof(*constraints),
 900                                             GFP_KERNEL);
 901         if (!rdev->constraints)
 902                 return -ENOMEM;
 903
 904         ret = machine_constraints_voltage(rdev, rdev->constraints);
 905         if (ret != 0)
 906                 goto out;
 907
 908         /* do we need to setup our suspend state */
 909         if (rdev->constraints->initial_state) {
 910                 ret = suspend_prepare(rdev, rdev->constraints->initial_state);
 911                 if (ret < 0) {
 912                         rdev_err(rdev, "failed to set suspend state\n");
 913                         goto out;
 914                 }
 915         }
 916
 917         if (rdev->constraints->initial_mode) {
 918                 if (!ops->set_mode) {
 919                         rdev_err(rdev, "no set_mode operation\n");
 920                         ret = -EINVAL;
 921                         goto out;
 922                 }
 923
 924                 ret = ops->set_mode(rdev, rdev->constraints->initial_mode);
 925                 if (ret < 0) {
 926                         rdev_err(rdev, "failed to set initial mode: %d\n", ret);
 927                         goto out;
 928                 }
 929         }
 930
 931         /* If the constraints say the regulator should be on at this point
 932          * and we have control then make sure it is enabled.
 933          */
 934         if ((rdev->constraints->always_on || rdev->constraints->boot_on) &&
 935             ops->enable) {
 936                 ret = ops->enable(rdev);
 937                 if (ret < 0) {
 938                         rdev_err(rdev, "failed to enable\n");
 939                         goto out;
 940                 }
 941         }
 942
 943         if (rdev->constraints->ramp_delay && ops->set_ramp_delay) {
 944                 ret = ops->set_ramp_delay(rdev, rdev->constraints->ramp_delay);
 945                 if (ret < 0) {
 946                         rdev_err(rdev, "failed to set ramp_delay\n");
 947                         goto out;
 948                 }
 949         }
 950
 951         print_constraints(rdev);
 952         return 0;
 953 out:
 954         kfree(rdev->constraints);
 955         rdev->constraints = NULL;
 956         return ret;
 957 }
 958
 959 /**
 960  * set_supply - set regulator supply regulator
 961  * @rdev: regulator name
 962  * @supply_rdev: supply regulator name
 963  *
 964  * Called by platform initialisation code to set the supply regulator for this
 965  * regulator. This ensures that a regulators supply will also be enabled by the
 966  * core if it's child is enabled.
 967  */
 968 static int set_supply(struct regulator_dev *rdev,
 969                       struct regulator_dev *supply_rdev)
 970 {
 971         int err;
 972
 973         rdev_info(rdev, "supplied by %s\n", rdev_get_name(supply_rdev));
 974
 975         rdev->supply = create_regulator(supply_rdev, &rdev->dev, "SUPPLY");
 976         if (rdev->supply == NULL) {
 977                 err = -ENOMEM;
 978                 return err;
 979         }
 980         supply_rdev->open_count++;
 981
 982         return 0;
 983 }
 984
 985 /**
 986  * set_consumer_device_supply - Bind a regulator to a symbolic supply
 987  * @rdev:         regulator source
 988  * @consumer_dev_name: dev_name() string for device supply applies to
 989  * @supply:       symbolic name for supply
 990  *
 991  * Allows platform initialisation code to map physical regulator
 992  * sources to symbolic names for supplies for use by devices.  Devices
 993  * should use these symbolic names to request regulators, avoiding the
 994  * need to provide board-specific regulator names as platform data.
 995  */
 996 static int set_consumer_device_supply(struct regulator_dev *rdev,
 997                                       const char *consumer_dev_name,
 998                                       const char *supply)
 999 {
1000         struct regulator_map *node;
1001         int has_dev;
1002
1003         if (supply == NULL)
1004                 return -EINVAL;
1005
1006         if (consumer_dev_name != NULL)
1007                 has_dev = 1;
1008         else
1009                 has_dev = 0;
1010
1011         list_for_each_entry(node, &regulator_map_list, list) {
1012                 if (node->dev_name && consumer_dev_name) {
1013                         if (strcmp(node->dev_name, consumer_dev_name) != 0)
1014                                 continue;
1015                 } else if (node->dev_name || consumer_dev_name) {
1016                         continue;
1017                 }
1018
1019                 if (strcmp(node->supply, supply) != 0)
1020                         continue;
1021
1022                 pr_debug("%s: %s/%s is '%s' supply; fail %s/%s\n",
1023                          consumer_dev_name,
1024                          dev_name(&node->regulator->dev),
1025                          node->regulator->desc->name,
1026                          supply,
1027                          dev_name(&rdev->dev), rdev_get_name(rdev));
1028                 return -EBUSY;
1029         }
1030
1031         node = kzalloc(sizeof(struct regulator_map), GFP_KERNEL);
1032         if (node == NULL)
1033                 return -ENOMEM;
1034
1035         node->regulator = rdev;
1036         node->supply = supply;
1037
1038         if (has_dev) {
1039                 node->dev_name = kstrdup(consumer_dev_name, GFP_KERNEL);
1040                 if (node->dev_name == NULL) {
1041                         kfree(node);
1042                         return -ENOMEM;
1043                 }
1044         }
1045
1046         list_add(&node->list, &regulator_map_list);
1047         return 0;
1048 }
1049
1050 static void unset_regulator_supplies(struct regulator_dev *rdev)
1051 {
1052         struct regulator_map *node, *n;
1053
1054         list_for_each_entry_safe(node, n, &regulator_map_list, list) {
1055                 if (rdev == node->regulator) {
1056                         list_del(&node->list);
1057                         kfree(node->dev_name);
1058                         kfree(node);
1059                 }
1060         }
1061 }
1062
1063 #define REG_STR_SIZE    64
1064
1065 static struct regulator *create_regulator(struct regulator_dev *rdev,
1066                                           struct device *dev,
1067                                           const char *supply_name)
1068 {
1069         struct regulator *regulator;
1070         char buf[REG_STR_SIZE];
1071         int err, size;
1072
1073         regulator = kzalloc(sizeof(*regulator), GFP_KERNEL);
1074         if (regulator == NULL)
1075                 return NULL;
1076
1077         mutex_lock(&rdev->mutex);
1078         regulator->rdev = rdev;
1079         list_add(&regulator->list, &rdev->consumer_list);
1080
1081         if (dev) {
1082                 regulator->dev = dev;
1083
1084                 /* Add a link to the device sysfs entry */
1085                 size = scnprintf(buf, REG_STR_SIZE, "%s-%s",
1086                                  dev->kobj.name, supply_name);
1087                 if (size >= REG_STR_SIZE)
1088                         goto overflow_err;
1089
1090                 regulator->supply_name = kstrdup(buf, GFP_KERNEL);
1091                 if (regulator->supply_name == NULL)
1092                         goto overflow_err;
1093
1094                 err = sysfs_create_link(&rdev->dev.kobj, &dev->kobj,
1095                                         buf);
1096                 if (err) {
1097                         rdev_warn(rdev, "could not add device link %s err %d\n",
1098                                   dev->kobj.name, err);
1099                         /* non-fatal */
1100                 }
1101         } else {
1102                 regulator->supply_name = kstrdup(supply_name, GFP_KERNEL);
1103                 if (regulator->supply_name == NULL)
1104                         goto overflow_err;
1105         }
1106
1107         regulator->debugfs = debugfs_create_dir(regulator->supply_name,
1108                                                 rdev->debugfs);
1109         if (!regulator->debugfs) {
1110                 rdev_warn(rdev, "Failed to create debugfs directory\n");
1111         } else {
1112                 debugfs_create_u32("uA_load", 0444, regulator->debugfs,
1113                                    &regulator->uA_load);
1114                 debugfs_create_u32("min_uV", 0444, regulator->debugfs,
1115                                    &regulator->min_uV);
1116                 debugfs_create_u32("max_uV", 0444, regulator->debugfs,
1117                                    &regulator->max_uV);
1118         }
1119
1120         /*
1121          * Check now if the regulator is an always on regulator - if
1122          * it is then we don't need to do nearly so much work for
1123          * enable/disable calls.
1124          */
1125         if (!_regulator_can_change_status(rdev) &&
1126             _regulator_is_enabled(rdev))
1127                 regulator->always_on = true;
1128
1129         mutex_unlock(&rdev->mutex);
1130         return regulator;
1131 overflow_err:
1132         list_del(&regulator->list);
1133         kfree(regulator);
1134         mutex_unlock(&rdev->mutex);
1135         return NULL;
1136 }
1137
1138 static int _regulator_get_enable_time(struct regulator_dev *rdev)
1139 {
1140         if (!rdev->desc->ops->enable_time)
1141                 return rdev->desc->enable_time;
1142         return rdev->desc->ops->enable_time(rdev);
1143 }
1144
1145 static struct regulator_dev *regulator_dev_lookup(struct device *dev,
1146                                                   const char *supply,
1147                                                   int *ret)
1148 {
1149         struct regulator_dev *r;
1150         struct device_node *node;
1151         struct regulator_map *map;
1152         const char *devname = NULL;
1153
1154         /* first do a dt based lookup */
1155         if (dev && dev->of_node) {
1156                 node = of_get_regulator(dev, supply);
1157                 if (node) {
1158                         list_for_each_entry(r, &regulator_list, list)
1159                                 if (r->dev.parent &&
1160                                         node == r->dev.of_node)
1161                                         return r;
1162                 } else {
1163                         /*
1164                          * If we couldn't even get the node then it's
1165                          * not just that the device didn't register
1166                          * yet, there's no node and we'll never
1167                          * succeed.
1168                          */
1169                         *ret = -ENODEV;
1170                 }
1171         }
1172
1173         /* if not found, try doing it non-dt way */
1174         if (dev)
1175                 devname = dev_name(dev);
1176
1177         list_for_each_entry(r, &regulator_list, list)
1178                 if (strcmp(rdev_get_name(r), supply) == 0)
1179                         return r;
1180
1181         list_for_each_entry(map, &regulator_map_list, list) {
1182                 /* If the mapping has a device set up it must match */
1183                 if (map->dev_name &&
1184                     (!devname || strcmp(map->dev_name, devname)))
1185                         continue;
1186
1187                 if (strcmp(map->supply, supply) == 0)
1188                         return map->regulator;
1189         }
1190
1191
1192         return NULL;
1193 }
1194
1195 /* Internal regulator request function */
1196 static struct regulator *_regulator_get(struct device *dev, const char *id,
1197                                         int exclusive)
1198 {
1199         struct regulator_dev *rdev;
1200         struct regulator *regulator = ERR_PTR(-EPROBE_DEFER);
1201         const char *devname = NULL;
1202         int ret;
1203
1204         if (id == NULL) {
1205                 pr_err("get() with no identifier\n");
1206                 return regulator;
1207         }
1208
1209         if (dev)
1210                 devname = dev_name(dev);
1211
1212         mutex_lock(&regulator_list_mutex);
1213
1214         rdev = regulator_dev_lookup(dev, id, &ret);
1215         if (rdev)
1216                 goto found;
1217
1218         if (board_wants_dummy_regulator) {
1219                 rdev = dummy_regulator_rdev;
1220                 goto found;
1221         }
1222
1223 #ifdef CONFIG_REGULATOR_DUMMY
1224         if (!devname)
1225                 devname = "deviceless";
1226
1227         /* If the board didn't flag that it was fully constrained then
1228          * substitute in a dummy regulator so consumers can continue.
1229          */
1230         if (!has_full_constraints) {
1231                 pr_warn("%s supply %s not found, using dummy regulator\n",
1232                         devname, id);
1233                 rdev = dummy_regulator_rdev;
1234                 goto found;
1235         }
1236 #endif
1237
1238         mutex_unlock(&regulator_list_mutex);
1239         return regulator;
1240
1241 found:
1242         if (rdev->exclusive) {
1243                 regulator = ERR_PTR(-EPERM);
1244                 goto out;
1245         }
1246
1247         if (exclusive && rdev->open_count) {
1248                 regulator = ERR_PTR(-EBUSY);
1249                 goto out;
1250         }
1251
1252         if (!try_module_get(rdev->owner))
1253                 goto out;
1254
1255         regulator = create_regulator(rdev, dev, id);
1256         if (regulator == NULL) {
1257                 regulator = ERR_PTR(-ENOMEM);
1258                 module_put(rdev->owner);
1259                 goto out;
1260         }
1261
1262         rdev->open_count++;
1263         if (exclusive) {
1264                 rdev->exclusive = 1;
1265
1266                 ret = _regulator_is_enabled(rdev);
1267                 if (ret > 0)
1268                         rdev->use_count = 1;
1269                 else
1270                         rdev->use_count = 0;
1271         }
1272
1273 out:
1274         mutex_unlock(&regulator_list_mutex);
1275
1276         return regulator;
1277 }
1278
1279 /**
1280  * regulator_get - lookup and obtain a reference to a regulator.
1281  * @dev: device for regulator "consumer"
1282  * @id: Supply name or regulator ID.
1283  *
1284  * Returns a struct regulator corresponding to the regulator producer,
1285  * or IS_ERR() condition containing errno.
1286  *
1287  * Use of supply names configured via regulator_set_device_supply() is
1288  * strongly encouraged.  It is recommended that the supply name used
1289  * should match the name used for the supply and/or the relevant
1290  * device pins in the datasheet.
1291  */
1292 struct regulator *regulator_get(struct device *dev, const char *id)
1293 {
1294         return _regulator_get(dev, id, 0);
1295 }
1296 EXPORT_SYMBOL_GPL(regulator_get);
1297
1298 static void devm_regulator_release(struct device *dev, void *res)
1299 {
1300         regulator_put(*(struct regulator **)res);
1301 }
1302
1303 /**
1304  * devm_regulator_get - Resource managed regulator_get()
1305  * @dev: device for regulator "consumer"
1306  * @id: Supply name or regulator ID.
1307  *
1308  * Managed regulator_get(). Regulators returned from this function are
1309  * automatically regulator_put() on driver detach. See regulator_get() for more
1310  * information.
1311  */
1312 struct regulator *devm_regulator_get(struct device *dev, const char *id)
1313 {
1314         struct regulator **ptr, *regulator;
1315
1316         ptr = devres_alloc(devm_regulator_release, sizeof(*ptr), GFP_KERNEL);
1317         if (!ptr)
1318                 return ERR_PTR(-ENOMEM);
1319
1320         regulator = regulator_get(dev, id);
1321         if (!IS_ERR(regulator)) {
1322                 *ptr = regulator;
1323                 devres_add(dev, ptr);
1324         } else {
1325                 devres_free(ptr);
1326         }
1327
1328         return regulator;
1329 }
1330 EXPORT_SYMBOL_GPL(devm_regulator_get);
1331
1332 /**
1333  * regulator_get_exclusive - obtain exclusive access to a regulator.
1334  * @dev: device for regulator "consumer"
1335  * @id: Supply name or regulator ID.
1336  *
1337  * Returns a struct regulator corresponding to the regulator producer,
1338  * or IS_ERR() condition containing errno.  Other consumers will be
1339  * unable to obtain this reference is held and the use count for the
1340  * regulator will be initialised to reflect the current state of the
1341  * regulator.
1342  *
1343  * This is intended for use by consumers which cannot tolerate shared
1344  * use of the regulator such as those which need to force the
1345  * regulator off for correct operation of the hardware they are
1346  * controlling.
1347  *
1348  * Use of supply names configured via regulator_set_device_supply() is
1349  * strongly encouraged.  It is recommended that the supply name used
1350  * should match the name used for the supply and/or the relevant
1351  * device pins in the datasheet.
1352  */
1353 struct regulator *regulator_get_exclusive(struct device *dev, const char *id)
1354 {
1355         return _regulator_get(dev, id, 1);
1356 }
1357 EXPORT_SYMBOL_GPL(regulator_get_exclusive);
1358
1359 /**
1360  * regulator_put - "free" the regulator source
1361  * @regulator: regulator source
1362  *
1363  * Note: drivers must ensure that all regulator_enable calls made on this
1364  * regulator source are balanced by regulator_disable calls prior to calling
1365  * this function.
1366  */
1367 void regulator_put(struct regulator *regulator)
1368 {
1369         struct regulator_dev *rdev;
1370
1371         if (regulator == NULL || IS_ERR(regulator))
1372                 return;
1373
1374         mutex_lock(&regulator_list_mutex);
1375         rdev = regulator->rdev;
1376
1377         debugfs_remove_recursive(regulator->debugfs);
1378
1379         /* remove any sysfs entries */
1380         if (regulator->dev)
1381                 sysfs_remove_link(&rdev->dev.kobj, regulator->supply_name);
1382         kfree(regulator->supply_name);
1383         list_del(&regulator->list);
1384         kfree(regulator);
1385
1386         rdev->open_count--;
1387         rdev->exclusive = 0;
1388
1389         module_put(rdev->owner);
1390         mutex_unlock(&regulator_list_mutex);
1391 }
1392 EXPORT_SYMBOL_GPL(regulator_put);
1393
1394 static int devm_regulator_match(struct device *dev, void *res, void *data)
1395 {
1396         struct regulator **r = res;
1397         if (!r || !*r) {
1398                 WARN_ON(!r || !*r);
1399                 return 0;
1400         }
1401         return *r == data;
1402 }
1403
1404 /**
1405  * devm_regulator_put - Resource managed regulator_put()
1406  * @regulator: regulator to free
1407  *
1408  * Deallocate a regulator allocated with devm_regulator_get(). Normally
1409  * this function will not need to be called and the resource management
1410  * code will ensure that the resource is freed.
1411  */
1412 void devm_regulator_put(struct regulator *regulator)
1413 {
1414         int rc;
1415
1416         rc = devres_release(regulator->dev, devm_regulator_release,
1417                             devm_regulator_match, regulator);
1418         if (rc != 0)
1419                 WARN_ON(rc);
1420 }
1421 EXPORT_SYMBOL_GPL(devm_regulator_put);
1422
1423 static int _regulator_do_enable(struct regulator_dev *rdev)
1424 {
1425         int ret, delay;
1426
1427         /* Query before enabling in case configuration dependent.  */
1428         ret = _regulator_get_enable_time(rdev);
1429         if (ret >= 0) {
1430                 delay = ret;
1431         } else {
1432                 rdev_warn(rdev, "enable_time() failed: %d\n", ret);
1433                 delay = 0;
1434         }
1435
1436         trace_regulator_enable(rdev_get_name(rdev));
1437
1438         if (rdev->ena_gpio) {
1439                 gpio_set_value_cansleep(rdev->ena_gpio,
1440                                         !rdev->ena_gpio_invert);
1441                 rdev->ena_gpio_state = 1;
1442         } else if (rdev->desc->ops->enable) {
1443                 ret = rdev->desc->ops->enable(rdev);
1444                 if (ret < 0)
1445                         return ret;
1446         } else {
1447                 return -EINVAL;
1448         }
1449
1450         /* Allow the regulator to ramp; it would be useful to extend
1451          * this for bulk operations so that the regulators can ramp
1452          * together.  */
1453         trace_regulator_enable_delay(rdev_get_name(rdev));
1454
1455         if (delay >= 1000) {
1456                 mdelay(delay / 1000);
1457                 udelay(delay % 1000);
1458         } else if (delay) {
1459                 udelay(delay);
1460         }
1461
1462         trace_regulator_enable_complete(rdev_get_name(rdev));
1463
1464         return 0;
1465 }
1466
1467 /* locks held by regulator_enable() */
1468 static int _regulator_enable(struct regulator_dev *rdev)
1469 {
1470         int ret;
1471
1472         /* check voltage and requested load before enabling */
1473         if (rdev->constraints &&
1474             (rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_DRMS))
1475                 drms_uA_update(rdev);
1476
1477         if (rdev->use_count == 0) {
1478                 /* The regulator may on if it's not switchable or left on */
1479                 ret = _regulator_is_enabled(rdev);
1480                 if (ret == -EINVAL || ret == 0) {
1481                         if (!_regulator_can_change_status(rdev))
1482                                 return -EPERM;
1483
1484                         ret = _regulator_do_enable(rdev);
1485                         if (ret < 0)
1486                                 return ret;
1487
1488                 } else if (ret < 0) {
1489                         rdev_err(rdev, "is_enabled() failed: %d\n", ret);
1490                         return ret;
1491                 }
1492                 /* Fallthrough on positive return values - already enabled */
1493         }
1494
1495         rdev->use_count++;
1496
1497         return 0;
1498 }
1499
1500 /**
1501  * regulator_enable - enable regulator output
1502  * @regulator: regulator source
1503  *
1504  * Request that the regulator be enabled with the regulator output at
1505  * the predefined voltage or current value.  Calls to regulator_enable()
1506  * must be balanced with calls to regulator_disable().
1507  *
1508  * NOTE: the output value can be set by other drivers, boot loader or may be
1509  * hardwired in the regulator.
1510  */
1511 int regulator_enable(struct regulator *regulator)
1512 {
1513         struct regulator_dev *rdev = regulator->rdev;
1514         int ret = 0;
1515
1516         if (regulator->always_on)
1517                 return 0;
1518
1519         if (rdev->supply) {
1520                 ret = regulator_enable(rdev->supply);
1521                 if (ret != 0)
1522                         return ret;
1523         }
1524
1525         mutex_lock(&rdev->mutex);
1526         ret = _regulator_enable(rdev);
1527         mutex_unlock(&rdev->mutex);
1528
1529         if (ret != 0 && rdev->supply)
1530                 regulator_disable(rdev->supply);
1531
1532         return ret;
1533 }
1534 EXPORT_SYMBOL_GPL(regulator_enable);
1535
1536 static int _regulator_do_disable(struct regulator_dev *rdev)
1537 {
1538         int ret;
1539
1540         trace_regulator_disable(rdev_get_name(rdev));
1541
1542         if (rdev->ena_gpio) {
1543                 gpio_set_value_cansleep(rdev->ena_gpio,
1544                                         rdev->ena_gpio_invert);
1545                 rdev->ena_gpio_state = 0;
1546
1547         } else if (rdev->desc->ops->disable) {
1548                 ret = rdev->desc->ops->disable(rdev);
1549                 if (ret != 0)
1550                         return ret;
1551         }
1552
1553         trace_regulator_disable_complete(rdev_get_name(rdev));
1554
1555         _notifier_call_chain(rdev, REGULATOR_EVENT_DISABLE,
1556                              NULL);
1557         return 0;
1558 }
1559
1560 /* locks held by regulator_disable() */
1561 static int _regulator_disable(struct regulator_dev *rdev)
1562 {
1563         int ret = 0;
1564
1565         if (WARN(rdev->use_count <= 0,
1566                  "unbalanced disables for %s\n", rdev_get_name(rdev)))
1567                 return -EIO;
1568
1569         /* are we the last user and permitted to disable ? */
1570         if (rdev->use_count == 1 &&
1571             (rdev->constraints && !rdev->constraints->always_on)) {
1572
1573                 /* we are last user */
1574                 if (_regulator_can_change_status(rdev)) {
1575                         ret = _regulator_do_disable(rdev);
1576                         if (ret < 0) {
1577                                 rdev_err(rdev, "failed to disable\n");
1578                                 return ret;
1579                         }
1580                 }
1581
1582                 rdev->use_count = 0;
1583         } else if (rdev->use_count > 1) {
1584
1585                 if (rdev->constraints &&
1586                         (rdev->constraints->valid_ops_mask &
1587                         REGULATOR_CHANGE_DRMS))
1588                         drms_uA_update(rdev);
1589
1590                 rdev->use_count--;
1591         }
1592
1593         return ret;
1594 }
1595
1596 /**
1597  * regulator_disable - disable regulator output
1598  * @regulator: regulator source
1599  *
1600  * Disable the regulator output voltage or current.  Calls to
1601  * regulator_enable() must be balanced with calls to
1602  * regulator_disable().
1603  *
1604  * NOTE: this will only disable the regulator output if no other consumer
1605  * devices have it enabled, the regulator device supports disabling and
1606  * machine constraints permit this operation.
1607  */
1608 int regulator_disable(struct regulator *regulator)
1609 {
1610         struct regulator_dev *rdev = regulator->rdev;
1611         int ret = 0;
1612
1613         if (regulator->always_on)
1614                 return 0;
1615
1616         mutex_lock(&rdev->mutex);
1617         ret = _regulator_disable(rdev);
1618         mutex_unlock(&rdev->mutex);
1619
1620         if (ret == 0 && rdev->supply)
1621                 regulator_disable(rdev->supply);
1622
1623         return ret;
1624 }
1625 EXPORT_SYMBOL_GPL(regulator_disable);
1626
1627 /* locks held by regulator_force_disable() */
1628 static int _regulator_force_disable(struct regulator_dev *rdev)
1629 {
1630         int ret = 0;
1631
1632         /* force disable */
1633         if (rdev->desc->ops->disable) {
1634                 /* ah well, who wants to live forever... */
1635                 ret = rdev->desc->ops->disable(rdev);
1636                 if (ret < 0) {
1637                         rdev_err(rdev, "failed to force disable\n");
1638                         return ret;
1639                 }
1640                 /* notify other consumers that power has been forced off */
1641                 _notifier_call_chain(rdev, REGULATOR_EVENT_FORCE_DISABLE |
1642                         REGULATOR_EVENT_DISABLE, NULL);
1643         }
1644
1645         return ret;
1646 }
1647
1648 /**
1649  * regulator_force_disable - force disable regulator output
1650  * @regulator: regulator source
1651  *
1652  * Forcibly disable the regulator output voltage or current.
1653  * NOTE: this *will* disable the regulator output even if other consumer
1654  * devices have it enabled. This should be used for situations when device
1655  * damage will likely occur if the regulator is not disabled (e.g. over temp).
1656  */
1657 int regulator_force_disable(struct regulator *regulator)
1658 {
1659         struct regulator_dev *rdev = regulator->rdev;
1660         int ret;
1661
1662         mutex_lock(&rdev->mutex);
1663         regulator->uA_load = 0;
1664         ret = _regulator_force_disable(regulator->rdev);
1665         mutex_unlock(&rdev->mutex);
1666
1667         if (rdev->supply)
1668                 while (rdev->open_count--)
1669                         regulator_disable(rdev->supply);
1670
1671         return ret;
1672 }
1673 EXPORT_SYMBOL_GPL(regulator_force_disable);
1674
1675 static void regulator_disable_work(struct work_struct *work)
1676 {
1677         struct regulator_dev *rdev = container_of(work, struct regulator_dev,
1678                                                   disable_work.work);
1679         int count, i, ret;
1680
1681         mutex_lock(&rdev->mutex);
1682
1683         BUG_ON(!rdev->deferred_disables);
1684
1685         count = rdev->deferred_disables;
1686         rdev->deferred_disables = 0;
1687
1688         for (i = 0; i < count; i++) {
1689                 ret = _regulator_disable(rdev);
1690                 if (ret != 0)
1691                         rdev_err(rdev, "Deferred disable failed: %d\n", ret);
1692         }
1693
1694         mutex_unlock(&rdev->mutex);
1695
1696         if (rdev->supply) {
1697                 for (i = 0; i < count; i++) {
1698                         ret = regulator_disable(rdev->supply);
1699                         if (ret != 0) {
1700                                 rdev_err(rdev,
1701                                          "Supply disable failed: %d\n", ret);
1702                         }
1703                 }
1704         }
1705 }
1706
1707 /**
1708  * regulator_disable_deferred - disable regulator output with delay
1709  * @regulator: regulator source
1710  * @ms: miliseconds until the regulator is disabled
1711  *
1712  * Execute regulator_disable() on the regulator after a delay.  This
1713  * is intended for use with devices that require some time to quiesce.
1714  *
1715  * NOTE: this will only disable the regulator output if no other consumer
1716  * devices have it enabled, the regulator device supports disabling and
1717  * machine constraints permit this operation.
1718  */
1719 int regulator_disable_deferred(struct regulator *regulator, int ms)
1720 {
1721         struct regulator_dev *rdev = regulator->rdev;
1722         int ret;
1723
1724         if (regulator->always_on)
1725                 return 0;
1726
1727         mutex_lock(&rdev->mutex);
1728         rdev->deferred_disables++;
1729         mutex_unlock(&rdev->mutex);
1730
1731         ret = schedule_delayed_work(&rdev->disable_work,
1732                                     msecs_to_jiffies(ms));
1733         if (ret < 0)
1734                 return ret;
1735         else
1736                 return 0;
1737 }
1738 EXPORT_SYMBOL_GPL(regulator_disable_deferred);
1739
1740 /**
1741  * regulator_is_enabled_regmap - standard is_enabled() for regmap users
1742  *
1743  * @rdev: regulator to operate on
1744  *
1745  * Regulators that use regmap for their register I/O can set the
1746  * enable_reg and enable_mask fields in their descriptor and then use
1747  * this as their is_enabled operation, saving some code.
1748  */
1749 int regulator_is_enabled_regmap(struct regulator_dev *rdev)
1750 {
1751         unsigned int val;
1752         int ret;
1753
1754         ret = regmap_read(rdev->regmap, rdev->desc->enable_reg, &val);
1755         if (ret != 0)
1756                 return ret;
1757
1758         return (val & rdev->desc->enable_mask) != 0;
1759 }
1760 EXPORT_SYMBOL_GPL(regulator_is_enabled_regmap);
1761
1762 /**
1763  * regulator_enable_regmap - standard enable() for regmap users
1764  *
1765  * @rdev: regulator to operate on
1766  *
1767  * Regulators that use regmap for their register I/O can set the
1768  * enable_reg and enable_mask fields in their descriptor and then use
1769  * this as their enable() operation, saving some code.
1770  */
1771 int regulator_enable_regmap(struct regulator_dev *rdev)
1772 {
1773         return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
1774                                   rdev->desc->enable_mask,
1775                                   rdev->desc->enable_mask);
1776 }
1777 EXPORT_SYMBOL_GPL(regulator_enable_regmap);
1778
1779 /**
1780  * regulator_disable_regmap - standard disable() for regmap users
1781  *
1782  * @rdev: regulator to operate on
1783  *
1784  * Regulators that use regmap for their register I/O can set the
1785  * enable_reg and enable_mask fields in their descriptor and then use
1786  * this as their disable() operation, saving some code.
1787  */
1788 int regulator_disable_regmap(struct regulator_dev *rdev)
1789 {
1790         return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
1791                                   rdev->desc->enable_mask, 0);
1792 }
1793 EXPORT_SYMBOL_GPL(regulator_disable_regmap);
1794
1795 static int _regulator_is_enabled(struct regulator_dev *rdev)
1796 {
1797         /* A GPIO control always takes precedence */
1798         if (rdev->ena_gpio)
1799                 return rdev->ena_gpio_state;
1800
1801         /* If we don't know then assume that the regulator is always on */
1802         if (!rdev->desc->ops->is_enabled)
1803                 return 1;
1804
1805         return rdev->desc->ops->is_enabled(rdev);
1806 }
1807
1808 /**
1809  * regulator_is_enabled - is the regulator output enabled
1810  * @regulator: regulator source
1811  *
1812  * Returns positive if the regulator driver backing the source/client
1813  * has requested that the device be enabled, zero if it hasn't, else a
1814  * negative errno code.
1815  *
1816  * Note that the device backing this regulator handle can have multiple
1817  * users, so it might be enabled even if regulator_enable() was never
1818  * called for this particular source.
1819  */
1820 int regulator_is_enabled(struct regulator *regulator)
1821 {
1822         int ret;
1823
1824         if (regulator->always_on)
1825                 return 1;
1826
1827         mutex_lock(&regulator->rdev->mutex);
1828         ret = _regulator_is_enabled(regulator->rdev);
1829         mutex_unlock(&regulator->rdev->mutex);
1830
1831         return ret;
1832 }
1833 EXPORT_SYMBOL_GPL(regulator_is_enabled);
1834
1835 /**
1836  * regulator_count_voltages - count regulator_list_voltage() selectors
1837  * @regulator: regulator source
1838  *
1839  * Returns number of selectors, or negative errno.  Selectors are
1840  * numbered starting at zero, and typically correspond to bitfields
1841  * in hardware registers.
1842  */
1843 int regulator_count_voltages(struct regulator *regulator)
1844 {
1845         struct regulator_dev    *rdev = regulator->rdev;
1846
1847         return rdev->desc->n_voltages ? : -EINVAL;
1848 }
1849 EXPORT_SYMBOL_GPL(regulator_count_voltages);
1850
1851 /**
1852  * regulator_list_voltage_linear - List voltages with simple calculation
1853  *
1854  * @rdev: Regulator device
1855  * @selector: Selector to convert into a voltage
1856  *
1857  * Regulators with a simple linear mapping between voltages and
1858  * selectors can set min_uV and uV_step in the regulator descriptor
1859  * and then use this function as their list_voltage() operation,
1860  */
1861 int regulator_list_voltage_linear(struct regulator_dev *rdev,
1862                                   unsigned int selector)
1863 {
1864         if (selector >= rdev->desc->n_voltages)
1865                 return -EINVAL;
1866
1867         return rdev->desc->min_uV + (rdev->desc->uV_step * selector);
1868 }
1869 EXPORT_SYMBOL_GPL(regulator_list_voltage_linear);
1870
1871 /**
1872  * regulator_list_voltage_table - List voltages with table based mapping
1873  *
1874  * @rdev: Regulator device
1875  * @selector: Selector to convert into a voltage
1876  *
1877  * Regulators with table based mapping between voltages and
1878  * selectors can set volt_table in the regulator descriptor
1879  * and then use this function as their list_voltage() operation.
1880  */
1881 int regulator_list_voltage_table(struct regulator_dev *rdev,
1882                                  unsigned int selector)
1883 {
1884         if (!rdev->desc->volt_table) {
1885                 BUG_ON(!rdev->desc->volt_table);
1886                 return -EINVAL;
1887         }
1888
1889         if (selector >= rdev->desc->n_voltages)
1890                 return -EINVAL;
1891
1892         return rdev->desc->volt_table[selector];
1893 }
1894 EXPORT_SYMBOL_GPL(regulator_list_voltage_table);
1895
1896 /**
1897  * regulator_list_voltage - enumerate supported voltages
1898  * @regulator: regulator source
1899  * @selector: identify voltage to list
1900  * Context: can sleep
1901  *
1902  * Returns a voltage that can be passed to @regulator_set_voltage(),
1903  * zero if this selector code can't be used on this system, or a
1904  * negative errno.
1905  */
1906 int regulator_list_voltage(struct regulator *regulator, unsigned selector)
1907 {
1908         struct regulator_dev    *rdev = regulator->rdev;
1909         struct regulator_ops    *ops = rdev->desc->ops;
1910         int                     ret;
1911
1912         if (!ops->list_voltage || selector >= rdev->desc->n_voltages)
1913                 return -EINVAL;
1914
1915         mutex_lock(&rdev->mutex);
1916         ret = ops->list_voltage(rdev, selector);
1917         mutex_unlock(&rdev->mutex);
1918
1919         if (ret > 0) {
1920                 if (ret < rdev->constraints->min_uV)
1921                         ret = 0;
1922                 else if (ret > rdev->constraints->max_uV)
1923                         ret = 0;
1924         }
1925
1926         return ret;
1927 }
1928 EXPORT_SYMBOL_GPL(regulator_list_voltage);
1929
1930 /**
1931  * regulator_is_supported_voltage - check if a voltage range can be supported
1932  *
1933  * @regulator: Regulator to check.
1934  * @min_uV: Minimum required voltage in uV.
1935  * @max_uV: Maximum required voltage in uV.
1936  *
1937  * Returns a boolean or a negative error code.
1938  */
1939 int regulator_is_supported_voltage(struct regulator *regulator,
1940                                    int min_uV, int max_uV)
1941 {
1942         struct regulator_dev *rdev = regulator->rdev;
1943         int i, voltages, ret;
1944
1945         /* If we can't change voltage check the current voltage */
1946         if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_VOLTAGE)) {
1947                 ret = regulator_get_voltage(regulator);
1948                 if (ret >= 0)
1949                         return (min_uV >= ret && ret <= max_uV);
1950                 else
1951                         return ret;
1952         }
1953
1954         ret = regulator_count_voltages(regulator);
1955         if (ret < 0)
1956                 return ret;
1957         voltages = ret;
1958
1959         for (i = 0; i < voltages; i++) {
1960                 ret = regulator_list_voltage(regulator, i);
1961
1962                 if (ret >= min_uV && ret <= max_uV)
1963                         return 1;
1964         }
1965
1966         return 0;
1967 }
1968 EXPORT_SYMBOL_GPL(regulator_is_supported_voltage);
1969
1970 /**
1971  * regulator_get_voltage_sel_regmap - standard get_voltage_sel for regmap users
1972  *
1973  * @rdev: regulator to operate on
1974  *
1975  * Regulators that use regmap for their register I/O can set the
1976  * vsel_reg and vsel_mask fields in their descriptor and then use this
1977  * as their get_voltage_vsel operation, saving some code.
1978  */
1979 int regulator_get_voltage_sel_regmap(struct regulator_dev *rdev)
1980 {
1981         unsigned int val;
1982         int ret;
1983
1984         ret = regmap_read(rdev->regmap, rdev->desc->vsel_reg, &val);
1985         if (ret != 0)
1986                 return ret;
1987
1988         val &= rdev->desc->vsel_mask;
1989         val >>= ffs(rdev->desc->vsel_mask) - 1;
1990
1991         return val;
1992 }
1993 EXPORT_SYMBOL_GPL(regulator_get_voltage_sel_regmap);
1994
1995 /**
1996  * regulator_set_voltage_sel_regmap - standard set_voltage_sel for regmap users
1997  *
1998  * @rdev: regulator to operate on
1999  * @sel: Selector to set
2000  *
2001  * Regulators that use regmap for their register I/O can set the
2002  * vsel_reg and vsel_mask fields in their descriptor and then use this
2003  * as their set_voltage_vsel operation, saving some code.
2004  */
2005 int regulator_set_voltage_sel_regmap(struct regulator_dev *rdev, unsigned sel)
2006 {
2007         sel <<= ffs(rdev->desc->vsel_mask) - 1;
2008
2009         return regmap_update_bits(rdev->regmap, rdev->desc->vsel_reg,
2010                                   rdev->desc->vsel_mask, sel);
2011 }
2012 EXPORT_SYMBOL_GPL(regulator_set_voltage_sel_regmap);
2013
2014 /**
2015  * regulator_map_voltage_iterate - map_voltage() based on list_voltage()
2016  *
2017  * @rdev: Regulator to operate on
2018  * @min_uV: Lower bound for voltage
2019  * @max_uV: Upper bound for voltage
2020  *
2021  * Drivers implementing set_voltage_sel() and list_voltage() can use
2022  * this as their map_voltage() operation.  It will find a suitable
2023  * voltage by calling list_voltage() until it gets something in bounds
2024  * for the requested voltages.
2025  */
2026 int regulator_map_voltage_iterate(struct regulator_dev *rdev,
2027                                   int min_uV, int max_uV)
2028 {
2029         int best_val = INT_MAX;
2030         int selector = 0;
2031         int i, ret;
2032
2033         /* Find the smallest voltage that falls within the specified
2034          * range.
2035          */
2036         for (i = 0; i < rdev->desc->n_voltages; i++) {
2037                 ret = rdev->desc->ops->list_voltage(rdev, i);
2038                 if (ret < 0)
2039                         continue;
2040
2041                 if (ret < best_val && ret >= min_uV && ret <= max_uV) {
2042                         best_val = ret;
2043                         selector = i;
2044                 }
2045         }
2046
2047         if (best_val != INT_MAX)
2048                 return selector;
2049         else
2050                 return -EINVAL;
2051 }
2052 EXPORT_SYMBOL_GPL(regulator_map_voltage_iterate);
2053
2054 /**
2055  * regulator_map_voltage_linear - map_voltage() for simple linear mappings
2056  *
2057  * @rdev: Regulator to operate on
2058  * @min_uV: Lower bound for voltage
2059  * @max_uV: Upper bound for voltage
2060  *
2061  * Drivers providing min_uV and uV_step in their regulator_desc can
2062  * use this as their map_voltage() operation.
2063  */
2064 int regulator_map_voltage_linear(struct regulator_dev *rdev,
2065                                  int min_uV, int max_uV)
2066 {
2067         int ret, voltage;
2068
2069         /* Allow uV_step to be 0 for fixed voltage */
2070         if (rdev->desc->n_voltages == 1 && rdev->desc->uV_step == 0) {
2071                 if (min_uV <= rdev->desc->min_uV && rdev->desc->min_uV <= max_uV)
2072                         return 0;
2073                 else
2074                         return -EINVAL;
2075         }
2076
2077         if (!rdev->desc->uV_step) {
2078                 BUG_ON(!rdev->desc->uV_step);
2079                 return -EINVAL;
2080         }
2081
2082         if (min_uV < rdev->desc->min_uV)
2083                 min_uV = rdev->desc->min_uV;
2084
2085         ret = DIV_ROUND_UP(min_uV - rdev->desc->min_uV, rdev->desc->uV_step);
2086         if (ret < 0)
2087                 return ret;
2088
2089         /* Map back into a voltage to verify we're still in bounds */
2090         voltage = rdev->desc->ops->list_voltage(rdev, ret);
2091         if (voltage < min_uV || voltage > max_uV)
2092                 return -EINVAL;
2093
2094         return ret;
2095 }
2096 EXPORT_SYMBOL_GPL(regulator_map_voltage_linear);
2097
2098 static int _regulator_do_set_voltage(struct regulator_dev *rdev,
2099                                      int min_uV, int max_uV)
2100 {
2101         int ret;
2102         int delay = 0;
2103         int best_val = 0;
2104         unsigned int selector;
2105         int old_selector = -1;
2106
2107         trace_regulator_set_voltage(rdev_get_name(rdev), min_uV, max_uV);
2108
2109         min_uV += rdev->constraints->uV_offset;
2110         max_uV += rdev->constraints->uV_offset;
2111
2112         /*
2113          * If we can't obtain the old selector there is not enough
2114          * info to call set_voltage_time_sel().
2115          */
2116         if (_regulator_is_enabled(rdev) &&
2117             rdev->desc->ops->set_voltage_time_sel &&
2118             rdev->desc->ops->get_voltage_sel) {
2119                 old_selector = rdev->desc->ops->get_voltage_sel(rdev);
2120                 if (old_selector < 0)
2121                         return old_selector;
2122         }
2123
2124         if (rdev->desc->ops->set_voltage) {
2125                 ret = rdev->desc->ops->set_voltage(rdev, min_uV, max_uV,
2126                                                    &selector);
2127
2128                 if (ret >= 0) {
2129                         if (rdev->desc->ops->list_voltage)
2130                                 best_val = rdev->desc->ops->list_voltage(rdev,
2131                                                                          selector);
2132                         else
2133                                 best_val = _regulator_get_voltage(rdev);
2134                 }
2135
2136         } else if (rdev->desc->ops->set_voltage_sel) {
2137                 if (rdev->desc->ops->map_voltage) {
2138                         ret = rdev->desc->ops->map_voltage(rdev, min_uV,
2139                                                            max_uV);
2140                 } else {
2141                         if (rdev->desc->ops->list_voltage ==
2142                             regulator_list_voltage_linear)
2143                                 ret = regulator_map_voltage_linear(rdev,
2144                                                                 min_uV, max_uV);
2145                         else
2146                                 ret = regulator_map_voltage_iterate(rdev,
2147                                                                 min_uV, max_uV);
2148                 }
2149
2150                 if (ret >= 0) {
2151                         best_val = rdev->desc->ops->list_voltage(rdev, ret);
2152                         if (min_uV <= best_val && max_uV >= best_val) {
2153                                 selector = ret;
2154                                 ret = rdev->desc->ops->set_voltage_sel(rdev,
2155                                                                        ret);
2156                         } else {
2157                                 ret = -EINVAL;
2158                         }
2159                 }
2160         } else {
2161                 ret = -EINVAL;
2162         }
2163
2164         /* Call set_voltage_time_sel if successfully obtained old_selector */
2165         if (ret == 0 && _regulator_is_enabled(rdev) && old_selector >= 0 &&
2166             rdev->desc->ops->set_voltage_time_sel) {
2167
2168                 delay = rdev->desc->ops->set_voltage_time_sel(rdev,
2169                                                 old_selector, selector);
2170                 if (delay < 0) {
2171                         rdev_warn(rdev, "set_voltage_time_sel() failed: %d\n",
2172                                   delay);
2173                         delay = 0;
2174                 }
2175
2176                 /* Insert any necessary delays */
2177                 if (delay >= 1000) {
2178                         mdelay(delay / 1000);
2179                         udelay(delay % 1000);
2180                 } else if (delay) {
2181                         udelay(delay);
2182                 }
2183         }
2184
2185         if (ret == 0 && best_val >= 0) {
2186                 unsigned long data = best_val;
2187
2188                 _notifier_call_chain(rdev, REGULATOR_EVENT_VOLTAGE_CHANGE,
2189                                      (void *)data);
2190         }
2191
2192         trace_regulator_set_voltage_complete(rdev_get_name(rdev), best_val);
2193
2194         return ret;
2195 }
2196
2197 /**
2198  * regulator_set_voltage - set regulator output voltage
2199  * @regulator: regulator source
2200  * @min_uV: Minimum required voltage in uV
2201  * @max_uV: Maximum acceptable voltage in uV
2202  *
2203  * Sets a voltage regulator to the desired output voltage. This can be set
2204  * during any regulator state. IOW, regulator can be disabled or enabled.
2205  *
2206  * If the regulator is enabled then the voltage will change to the new value
2207  * immediately otherwise if the regulator is disabled the regulator will
2208  * output at the new voltage when enabled.
2209  *
2210  * NOTE: If the regulator is shared between several devices then the lowest
2211  * request voltage that meets the system constraints will be used.
2212  * Regulator system constraints must be set for this regulator before
2213  * calling this function otherwise this call will fail.
2214  */
2215 int regulator_set_voltage(struct regulator *regulator, int min_uV, int max_uV)
2216 {
2217         struct regulator_dev *rdev = regulator->rdev;
2218         int ret = 0;
2219
2220         mutex_lock(&rdev->mutex);
2221
2222         /* If we're setting the same range as last time the change
2223          * should be a noop (some cpufreq implementations use the same
2224          * voltage for multiple frequencies, for example).
2225          */
2226         if (regulator->min_uV == min_uV && regulator->max_uV == max_uV)
2227                 goto out;
2228
2229         /* sanity check */
2230         if (!rdev->desc->ops->set_voltage &&
2231             !rdev->desc->ops->set_voltage_sel) {
2232                 ret = -EINVAL;
2233                 goto out;
2234         }
2235
2236         /* constraints check */
2237         ret = regulator_check_voltage(rdev, &min_uV, &max_uV);
2238         if (ret < 0)
2239                 goto out;
2240         regulator->min_uV = min_uV;
2241         regulator->max_uV = max_uV;
2242
2243         ret = regulator_check_consumers(rdev, &min_uV, &max_uV);
2244         if (ret < 0)
2245                 goto out;
2246
2247         ret = _regulator_do_set_voltage(rdev, min_uV, max_uV);
2248
2249 out:
2250         mutex_unlock(&rdev->mutex);
2251         return ret;
2252 }
2253 EXPORT_SYMBOL_GPL(regulator_set_voltage);
2254
2255 /**
2256  * regulator_set_voltage_time - get raise/fall time
2257  * @regulator: regulator source
2258  * @old_uV: starting voltage in microvolts
2259  * @new_uV: target voltage in microvolts
2260  *
2261  * Provided with the starting and ending voltage, this function attempts to
2262  * calculate the time in microseconds required to rise or fall to this new
2263  * voltage.
2264  */
2265 int regulator_set_voltage_time(struct regulator *regulator,
2266                                int old_uV, int new_uV)
2267 {
2268         struct regulator_dev    *rdev = regulator->rdev;
2269         struct regulator_ops    *ops = rdev->desc->ops;
2270         int old_sel = -1;
2271         int new_sel = -1;
2272         int voltage;
2273         int i;
2274
2275         /* Currently requires operations to do this */
2276         if (!ops->list_voltage || !ops->set_voltage_time_sel
2277             || !rdev->desc->n_voltages)
2278                 return -EINVAL;
2279
2280         for (i = 0; i < rdev->desc->n_voltages; i++) {
2281                 /* We only look for exact voltage matches here */
2282                 voltage = regulator_list_voltage(regulator, i);
2283                 if (voltage < 0)
2284                         return -EINVAL;
2285                 if (voltage == 0)
2286                         continue;
2287                 if (voltage == old_uV)
2288                         old_sel = i;
2289                 if (voltage == new_uV)
2290                         new_sel = i;
2291         }
2292
2293         if (old_sel < 0 || new_sel < 0)
2294                 return -EINVAL;
2295
2296         return ops->set_voltage_time_sel(rdev, old_sel, new_sel);
2297 }
2298 EXPORT_SYMBOL_GPL(regulator_set_voltage_time);
2299
2300 /**
2301  *regulator_set_voltage_time_sel - get raise/fall time
2302  * @regulator: regulator source
2303  * @old_selector: selector for starting voltage
2304  * @new_selector: selector for target voltage
2305  *
2306  * Provided with the starting and target voltage selectors, this function
2307  * returns time in microseconds required to rise or fall to this new voltage
2308  *
2309  * Drivers providing ramp_delay in regulation_constraints can use this as their
2310  * set_voltage_time_sel() operation.
2311  */
2312 int regulator_set_voltage_time_sel(struct regulator_dev *rdev,
2313                                    unsigned int old_selector,
2314                                    unsigned int new_selector)
2315 {
2316         unsigned int ramp_delay = 0;
2317         int old_volt, new_volt;
2318
2319         if (rdev->constraints->ramp_delay)
2320                 ramp_delay = rdev->constraints->ramp_delay;
2321         else if (rdev->desc->ramp_delay)
2322                 ramp_delay = rdev->desc->ramp_delay;
2323
2324         if (ramp_delay == 0) {
2325                 rdev_warn(rdev, "ramp_delay not set\n");
2326                 return 0;
2327         }
2328
2329         /* sanity check */
2330         if (!rdev->desc->ops->list_voltage)
2331                 return -EINVAL;
2332
2333         old_volt = rdev->desc->ops->list_voltage(rdev, old_selector);
2334         new_volt = rdev->desc->ops->list_voltage(rdev, new_selector);
2335
2336         return DIV_ROUND_UP(abs(new_volt - old_volt), ramp_delay);
2337 }
2338 EXPORT_SYMBOL_GPL(regulator_set_voltage_time_sel);
2339
2340 /**
2341  * regulator_sync_voltage - re-apply last regulator output voltage
2342  * @regulator: regulator source
2343  *
2344  * Re-apply the last configured voltage.  This is intended to be used
2345  * where some external control source the consumer is cooperating with
2346  * has caused the configured voltage to change.
2347  */
2348 int regulator_sync_voltage(struct regulator *regulator)
2349 {
2350         struct regulator_dev *rdev = regulator->rdev;
2351         int ret, min_uV, max_uV;
2352
2353         mutex_lock(&rdev->mutex);
2354
2355         if (!rdev->desc->ops->set_voltage &&
2356             !rdev->desc->ops->set_voltage_sel) {
2357                 ret = -EINVAL;
2358                 goto out;
2359         }
2360
2361         /* This is only going to work if we've had a voltage configured. */
2362         if (!regulator->min_uV && !regulator->max_uV) {
2363                 ret = -EINVAL;
2364                 goto out;
2365         }
2366
2367         min_uV = regulator->min_uV;
2368         max_uV = regulator->max_uV;
2369
2370         /* This should be a paranoia check... */
2371         ret = regulator_check_voltage(rdev, &min_uV, &max_uV);
2372         if (ret < 0)
2373                 goto out;
2374
2375         ret = regulator_check_consumers(rdev, &min_uV, &max_uV);
2376         if (ret < 0)
2377                 goto out;
2378
2379         ret = _regulator_do_set_voltage(rdev, min_uV, max_uV);
2380
2381 out:
2382         mutex_unlock(&rdev->mutex);
2383         return ret;
2384 }
2385 EXPORT_SYMBOL_GPL(regulator_sync_voltage);
2386
2387 static int _regulator_get_voltage(struct regulator_dev *rdev)
2388 {
2389         int sel, ret;
2390
2391         if (rdev->desc->ops->get_voltage_sel) {
2392                 sel = rdev->desc->ops->get_voltage_sel(rdev);
2393                 if (sel < 0)
2394                         return sel;
2395                 ret = rdev->desc->ops->list_voltage(rdev, sel);
2396         } else if (rdev->desc->ops->get_voltage) {
2397                 ret = rdev->desc->ops->get_voltage(rdev);
2398         } else if (rdev->desc->ops->list_voltage) {
2399                 ret = rdev->desc->ops->list_voltage(rdev, 0);
2400         } else {
2401                 return -EINVAL;
2402         }
2403
2404         if (ret < 0)
2405                 return ret;
2406         return ret - rdev->constraints->uV_offset;
2407 }
2408
2409 /**
2410  * regulator_get_voltage - get regulator output voltage
2411  * @regulator: regulator source
2412  *
2413  * This returns the current regulator voltage in uV.
2414  *
2415  * NOTE: If the regulator is disabled it will return the voltage value. This
2416  * function should not be used to determine regulator state.
2417  */
2418 int regulator_get_voltage(struct regulator *regulator)
2419 {
2420         int ret;
2421
2422         mutex_lock(&regulator->rdev->mutex);
2423
2424         ret = _regulator_get_voltage(regulator->rdev);
2425
2426         mutex_unlock(&regulator->rdev->mutex);
2427
2428         return ret;
2429 }
2430 EXPORT_SYMBOL_GPL(regulator_get_voltage);
2431
2432 /**
2433  * regulator_set_current_limit - set regulator output current limit
2434  * @regulator: regulator source
2435  * @min_uA: Minimuum supported current in uA
2436  * @max_uA: Maximum supported current in uA
2437  *
2438  * Sets current sink to the desired output current. This can be set during
2439  * any regulator state. IOW, regulator can be disabled or enabled.
2440  *
2441  * If the regulator is enabled then the current will change to the new value
2442  * immediately otherwise if the regulator is disabled the regulator will
2443  * output at the new current when enabled.
2444  *
2445  * NOTE: Regulator system constraints must be set for this regulator before
2446  * calling this function otherwise this call will fail.
2447  */
2448 int regulator_set_current_limit(struct regulator *regulator,
2449                                int min_uA, int max_uA)
2450 {
2451         struct regulator_dev *rdev = regulator->rdev;
2452         int ret;
2453
2454         mutex_lock(&rdev->mutex);
2455
2456         /* sanity check */
2457         if (!rdev->desc->ops->set_current_limit) {
2458                 ret = -EINVAL;
2459                 goto out;
2460         }
2461
2462         /* constraints check */
2463         ret = regulator_check_current_limit(rdev, &min_uA, &max_uA);
2464         if (ret < 0)
2465                 goto out;
2466
2467         ret = rdev->desc->ops->set_current_limit(rdev, min_uA, max_uA);
2468 out:
2469         mutex_unlock(&rdev->mutex);
2470         return ret;
2471 }
2472 EXPORT_SYMBOL_GPL(regulator_set_current_limit);
2473
2474 static int _regulator_get_current_limit(struct regulator_dev *rdev)
2475 {
2476         int ret;
2477
2478         mutex_lock(&rdev->mutex);
2479
2480         /* sanity check */
2481         if (!rdev->desc->ops->get_current_limit) {
2482                 ret = -EINVAL;
2483                 goto out;
2484         }
2485
2486         ret = rdev->desc->ops->get_current_limit(rdev);
2487 out:
2488         mutex_unlock(&rdev->mutex);
2489         return ret;
2490 }
2491
2492 /**
2493  * regulator_get_current_limit - get regulator output current
2494  * @regulator: regulator source
2495  *
2496  * This returns the current supplied by the specified current sink in uA.
2497  *
2498  * NOTE: If the regulator is disabled it will return the current value. This
2499  * function should not be used to determine regulator state.
2500  */
2501 int regulator_get_current_limit(struct regulator *regulator)
2502 {
2503         return _regulator_get_current_limit(regulator->rdev);
2504 }
2505 EXPORT_SYMBOL_GPL(regulator_get_current_limit);
2506
2507 /**
2508  * regulator_set_mode - set regulator operating mode
2509  * @regulator: regulator source
2510  * @mode: operating mode - one of the REGULATOR_MODE constants
2511  *
2512  * Set regulator operating mode to increase regulator efficiency or improve
2513  * regulation performance.
2514  *
2515  * NOTE: Regulator system constraints must be set for this regulator before
2516  * calling this function otherwise this call will fail.
2517  */
2518 int regulator_set_mode(struct regulator *regulator, unsigned int mode)
2519 {
2520         struct regulator_dev *rdev = regulator->rdev;
2521         int ret;
2522         int regulator_curr_mode;
2523
2524         mutex_lock(&rdev->mutex);
2525
2526         /* sanity check */
2527         if (!rdev->desc->ops->set_mode) {
2528                 ret = -EINVAL;
2529                 goto out;
2530         }
2531
2532         /* return if the same mode is requested */
2533         if (rdev->desc->ops->get_mode) {
2534                 regulator_curr_mode = rdev->desc->ops->get_mode(rdev);
2535                 if (regulator_curr_mode == mode) {
2536                         ret = 0;
2537                         goto out;
2538                 }
2539         }
2540
2541         /* constraints check */
2542         ret = regulator_mode_constrain(rdev, &mode);
2543         if (ret < 0)
2544                 goto out;
2545
2546         ret = rdev->desc->ops->set_mode(rdev, mode);
2547 out:
2548         mutex_unlock(&rdev->mutex);
2549         return ret;
2550 }
2551 EXPORT_SYMBOL_GPL(regulator_set_mode);
2552
2553 static unsigned int _regulator_get_mode(struct regulator_dev *rdev)
2554 {
2555         int ret;
2556
2557         mutex_lock(&rdev->mutex);
2558
2559         /* sanity check */
2560         if (!rdev->desc->ops->get_mode) {
2561                 ret = -EINVAL;
2562                 goto out;
2563         }
2564
2565         ret = rdev->desc->ops->get_mode(rdev);
2566 out:
2567         mutex_unlock(&rdev->mutex);
2568         return ret;
2569 }
2570
2571 /**
2572  * regulator_get_mode - get regulator operating mode
2573  * @regulator: regulator source
2574  *
2575  * Get the current regulator operating mode.
2576  */
2577 unsigned int regulator_get_mode(struct regulator *regulator)
2578 {
2579         return _regulator_get_mode(regulator->rdev);
2580 }
2581 EXPORT_SYMBOL_GPL(regulator_get_mode);
2582
2583 /**
2584  * regulator_set_optimum_mode - set regulator optimum operating mode
2585  * @regulator: regulator source
2586  * @uA_load: load current
2587  *
2588  * Notifies the regulator core of a new device load. This is then used by
2589  * DRMS (if enabled by constraints) to set the most efficient regulator
2590  * operating mode for the new regulator loading.
2591  *
2592  * Consumer devices notify their supply regulator of the maximum power
2593  * they will require (can be taken from device datasheet in the power
2594  * consumption tables) when they change operational status and hence power
2595  * state. Examples of operational state changes that can affect power
2596  * consumption are :-
2597  *
2598  *    o Device is opened / closed.
2599  *    o Device I/O is about to begin or has just finished.
2600  *    o Device is idling in between work.
2601  *
2602  * This information is also exported via sysfs to userspace.
2603  *
2604  * DRMS will sum the total requested load on the regulator and change
2605  * to the most efficient operating mode if platform constraints allow.
2606  *
2607  * Returns the new regulator mode or error.
2608  */
2609 int regulator_set_optimum_mode(struct regulator *regulator, int uA_load)
2610 {
2611         struct regulator_dev *rdev = regulator->rdev;
2612         struct regulator *consumer;
2613         int ret, output_uV, input_uV = 0, total_uA_load = 0;
2614         unsigned int mode;
2615
2616         if (rdev->supply)
2617                 input_uV = regulator_get_voltage(rdev->supply);
2618
2619         mutex_lock(&rdev->mutex);
2620
2621         /*
2622          * first check to see if we can set modes at all, otherwise just
2623          * tell the consumer everything is OK.
2624          */
2625         regulator->uA_load = uA_load;
2626         ret = regulator_check_drms(rdev);
2627         if (ret < 0) {
2628                 ret = 0;
2629                 goto out;
2630         }
2631
2632         if (!rdev->desc->ops->get_optimum_mode)
2633                 goto out;
2634
2635         /*
2636          * we can actually do this so any errors are indicators of
2637          * potential real failure.
2638          */
2639         ret = -EINVAL;
2640
2641         if (!rdev->desc->ops->set_mode)
2642                 goto out;
2643
2644         /* get output voltage */
2645         output_uV = _regulator_get_voltage(rdev);
2646         if (output_uV <= 0) {
2647                 rdev_err(rdev, "invalid output voltage found\n");
2648                 goto out;
2649         }
2650
2651         /* No supply? Use constraint voltage */
2652         if (input_uV <= 0)
2653                 input_uV = rdev->constraints->input_uV;
2654         if (input_uV <= 0) {
2655                 rdev_err(rdev, "invalid input voltage found\n");
2656                 goto out;
2657         }
2658
2659         /* calc total requested load for this regulator */
2660         list_for_each_entry(consumer, &rdev->consumer_list, list)
2661                 total_uA_load += consumer->uA_load;
2662
2663         mode = rdev->desc->ops->get_optimum_mode(rdev,
2664                                                  input_uV, output_uV,
2665                                                  total_uA_load);
2666         ret = regulator_mode_constrain(rdev, &mode);
2667         if (ret < 0) {
2668                 rdev_err(rdev, "failed to get optimum mode @ %d uA %d -> %d uV\n",
2669                          total_uA_load, input_uV, output_uV);
2670                 goto out;
2671         }
2672
2673         ret = rdev->desc->ops->set_mode(rdev, mode);
2674         if (ret < 0) {
2675                 rdev_err(rdev, "failed to set optimum mode %x\n", mode);
2676                 goto out;
2677         }
2678         ret = mode;
2679 out:
2680         mutex_unlock(&rdev->mutex);
2681         return ret;
2682 }
2683 EXPORT_SYMBOL_GPL(regulator_set_optimum_mode);
2684
2685 /**
2686  * regulator_register_notifier - register regulator event notifier
2687  * @regulator: regulator source
2688  * @nb: notifier block
2689  *
2690  * Register notifier block to receive regulator events.
2691  */
2692 int regulator_register_notifier(struct regulator *regulator,
2693                               struct notifier_block *nb)
2694 {
2695         return blocking_notifier_chain_register(&regulator->rdev->notifier,
2696                                                 nb);
2697 }
2698 EXPORT_SYMBOL_GPL(regulator_register_notifier);
2699
2700 /**
2701  * regulator_unregister_notifier - unregister regulator event notifier
2702  * @regulator: regulator source
2703  * @nb: notifier block
2704  *
2705  * Unregister regulator event notifier block.
2706  */
2707 int regulator_unregister_notifier(struct regulator *regulator,
2708                                 struct notifier_block *nb)
2709 {
2710         return blocking_notifier_chain_unregister(&regulator->rdev->notifier,
2711                                                   nb);
2712 }
2713 EXPORT_SYMBOL_GPL(regulator_unregister_notifier);
2714
2715 /* notify regulator consumers and downstream regulator consumers.
2716  * Note mutex must be held by caller.
2717  */
2718 static void _notifier_call_chain(struct regulator_dev *rdev,
2719                                   unsigned long event, void *data)
2720 {
2721         /* call rdev chain first */
2722         blocking_notifier_call_chain(&rdev->notifier, event, data);
2723 }
2724
2725 /**
2726  * regulator_bulk_get - get multiple regulator consumers
2727  *
2728  * @dev:           Device to supply
2729  * @num_consumers: Number of consumers to register
2730  * @consumers:     Configuration of consumers; clients are stored here.
2731  *
2732  * @return 0 on success, an errno on failure.
2733  *
2734  * This helper function allows drivers to get several regulator
2735  * consumers in one operation.  If any of the regulators cannot be
2736  * acquired then any regulators that were allocated will be freed
2737  * before returning to the caller.
2738  */
2739 int regulator_bulk_get(struct device *dev, int num_consumers,
2740                        struct regulator_bulk_data *consumers)
2741 {
2742         int i;
2743         int ret;
2744
2745         for (i = 0; i < num_consumers; i++)
2746                 consumers[i].consumer = NULL;
2747
2748         for (i = 0; i < num_consumers; i++) {
2749                 consumers[i].consumer = regulator_get(dev,
2750                                                       consumers[i].supply);
2751                 if (IS_ERR(consumers[i].consumer)) {
2752                         ret = PTR_ERR(consumers[i].consumer);
2753                         dev_err(dev, "Failed to get supply '%s': %d\n",
2754                                 consumers[i].supply, ret);
2755                         consumers[i].consumer = NULL;
2756                         goto err;
2757                 }
2758         }
2759
2760         return 0;
2761
2762 err:
2763         while (--i >= 0)
2764                 regulator_put(consumers[i].consumer);
2765
2766         return ret;
2767 }
2768 EXPORT_SYMBOL_GPL(regulator_bulk_get);
2769
2770 /**
2771  * devm_regulator_bulk_get - managed get multiple regulator consumers
2772  *
2773  * @dev:           Device to supply
2774  * @num_consumers: Number of consumers to register
2775  * @consumers:     Configuration of consumers; clients are stored here.
2776  *
2777  * @return 0 on success, an errno on failure.
2778  *
2779  * This helper function allows drivers to get several regulator
2780  * consumers in one operation with management, the regulators will
2781  * automatically be freed when the device is unbound.  If any of the
2782  * regulators cannot be acquired then any regulators that were
2783  * allocated will be freed before returning to the caller.
2784  */
2785 int devm_regulator_bulk_get(struct device *dev, int num_consumers,
2786                             struct regulator_bulk_data *consumers)
2787 {
2788         int i;
2789         int ret;
2790
2791         for (i = 0; i < num_consumers; i++)
2792                 consumers[i].consumer = NULL;
2793
2794         for (i = 0; i < num_consumers; i++) {
2795                 consumers[i].consumer = devm_regulator_get(dev,
2796                                                            consumers[i].supply);
2797                 if (IS_ERR(consumers[i].consumer)) {
2798                         ret = PTR_ERR(consumers[i].consumer);
2799                         dev_err(dev, "Failed to get supply '%s': %d\n",
2800                                 consumers[i].supply, ret);
2801                         consumers[i].consumer = NULL;
2802                         goto err;
2803                 }
2804         }
2805
2806         return 0;
2807
2808 err:
2809         for (i = 0; i < num_consumers && consumers[i].consumer; i++)
2810                 devm_regulator_put(consumers[i].consumer);
2811
2812         return ret;
2813 }
2814 EXPORT_SYMBOL_GPL(devm_regulator_bulk_get);
2815
2816 static void regulator_bulk_enable_async(void *data, async_cookie_t cookie)
2817 {
2818         struct regulator_bulk_data *bulk = data;
2819
2820         bulk->ret = regulator_enable(bulk->consumer);
2821 }
2822
2823 /**
2824  * regulator_bulk_enable - enable multiple regulator consumers
2825  *
2826  * @num_consumers: Number of consumers
2827  * @consumers:     Consumer data; clients are stored here.
2828  * @return         0 on success, an errno on failure
2829  *
2830  * This convenience API allows consumers to enable multiple regulator
2831  * clients in a single API call.  If any consumers cannot be enabled
2832  * then any others that were enabled will be disabled again prior to
2833  * return.
2834  */
2835 int regulator_bulk_enable(int num_consumers,
2836                           struct regulator_bulk_data *consumers)
2837 {
2838         ASYNC_DOMAIN_EXCLUSIVE(async_domain);
2839         int i;
2840         int ret = 0;
2841
2842         for (i = 0; i < num_consumers; i++) {
2843                 if (consumers[i].consumer->always_on)
2844                         consumers[i].ret = 0;
2845                 else
2846                         async_schedule_domain(regulator_bulk_enable_async,
2847                                               &consumers[i], &async_domain);
2848         }
2849
2850         async_synchronize_full_domain(&async_domain);
2851
2852         /* If any consumer failed we need to unwind any that succeeded */
2853         for (i = 0; i < num_consumers; i++) {
2854                 if (consumers[i].ret != 0) {
2855                         ret = consumers[i].ret;
2856                         goto err;
2857                 }
2858         }
2859
2860         return 0;
2861
2862 err:
2863         pr_err("Failed to enable %s: %d\n", consumers[i].supply, ret);
2864         while (--i >= 0)
2865                 regulator_disable(consumers[i].consumer);
2866
2867         return ret;
2868 }
2869 EXPORT_SYMBOL_GPL(regulator_bulk_enable);
2870
2871 /**
2872  * regulator_bulk_disable - disable multiple regulator consumers
2873  *
2874  * @num_consumers: Number of consumers
2875  * @consumers:     Consumer data; clients are stored here.
2876  * @return         0 on success, an errno on failure
2877  *
2878  * This convenience API allows consumers to disable multiple regulator
2879  * clients in a single API call.  If any consumers cannot be disabled
2880  * then any others that were disabled will be enabled again prior to
2881  * return.
2882  */
2883 int regulator_bulk_disable(int num_consumers,
2884                            struct regulator_bulk_data *consumers)
2885 {
2886         int i;
2887         int ret, r;
2888
2889         for (i = num_consumers - 1; i >= 0; --i) {
2890                 ret = regulator_disable(consumers[i].consumer);
2891                 if (ret != 0)
2892                         goto err;
2893         }
2894
2895         return 0;
2896
2897 err:
2898         pr_err("Failed to disable %s: %d\n", consumers[i].supply, ret);
2899         for (++i; i < num_consumers; ++i) {
2900                 r = regulator_enable(consumers[i].consumer);
2901                 if (r != 0)
2902                         pr_err("Failed to reename %s: %d\n",
2903                                consumers[i].supply, r);
2904         }
2905
2906         return ret;
2907 }
2908 EXPORT_SYMBOL_GPL(regulator_bulk_disable);
2909
2910 /**
2911  * regulator_bulk_force_disable - force disable multiple regulator consumers
2912  *
2913  * @num_consumers: Number of consumers
2914  * @consumers:     Consumer data; clients are stored here.
2915  * @return         0 on success, an errno on failure
2916  *
2917  * This convenience API allows consumers to forcibly disable multiple regulator
2918  * clients in a single API call.
2919  * NOTE: This should be used for situations when device damage will
2920  * likely occur if the regulators are not disabled (e.g. over temp).
2921  * Although regulator_force_disable function call for some consumers can
2922  * return error numbers, the function is called for all consumers.
2923  */
2924 int regulator_bulk_force_disable(int num_consumers,
2925                            struct regulator_bulk_data *consumers)
2926 {
2927         int i;
2928         int ret;
2929
2930         for (i = 0; i < num_consumers; i++)
2931                 consumers[i].ret =
2932                             regulator_force_disable(consumers[i].consumer);
2933
2934         for (i = 0; i < num_consumers; i++) {
2935                 if (consumers[i].ret != 0) {
2936                         ret = consumers[i].ret;
2937                         goto out;
2938                 }
2939         }
2940
2941         return 0;
2942 out:
2943         return ret;
2944 }
2945 EXPORT_SYMBOL_GPL(regulator_bulk_force_disable);
2946
2947 /**
2948  * regulator_bulk_free - free multiple regulator consumers
2949  *
2950  * @num_consumers: Number of consumers
2951  * @consumers:     Consumer data; clients are stored here.
2952  *
2953  * This convenience API allows consumers to free multiple regulator
2954  * clients in a single API call.
2955  */
2956 void regulator_bulk_free(int num_consumers,
2957                          struct regulator_bulk_data *consumers)
2958 {
2959         int i;
2960
2961         for (i = 0; i < num_consumers; i++) {
2962                 regulator_put(consumers[i].consumer);
2963                 consumers[i].consumer = NULL;
2964         }
2965 }
2966 EXPORT_SYMBOL_GPL(regulator_bulk_free);
2967
2968 /**
2969  * regulator_notifier_call_chain - call regulator event notifier
2970  * @rdev: regulator source
2971  * @event: notifier block
2972  * @data: callback-specific data.
2973  *
2974  * Called by regulator drivers to notify clients a regulator event has
2975  * occurred. We also notify regulator clients downstream.
2976  * Note lock must be held by caller.
2977  */
2978 int regulator_notifier_call_chain(struct regulator_dev *rdev,
2979                                   unsigned long event, void *data)
2980 {
2981         _notifier_call_chain(rdev, event, data);
2982         return NOTIFY_DONE;
2983
2984 }
2985 EXPORT_SYMBOL_GPL(regulator_notifier_call_chain);
2986
2987 /**
2988  * regulator_mode_to_status - convert a regulator mode into a status
2989  *
2990  * @mode: Mode to convert
2991  *
2992  * Convert a regulator mode into a status.
2993  */
2994 int regulator_mode_to_status(unsigned int mode)
2995 {
2996         switch (mode) {
2997         case REGULATOR_MODE_FAST:
2998                 return REGULATOR_STATUS_FAST;
2999         case REGULATOR_MODE_NORMAL:
3000                 return REGULATOR_STATUS_NORMAL;
3001         case REGULATOR_MODE_IDLE:
3002                 return REGULATOR_STATUS_IDLE;
3003         case REGULATOR_MODE_STANDBY:
3004                 return REGULATOR_STATUS_STANDBY;
3005         default:
3006                 return REGULATOR_STATUS_UNDEFINED;
3007         }
3008 }
3009 EXPORT_SYMBOL_GPL(regulator_mode_to_status);
3010
3011 /*
3012  * To avoid cluttering sysfs (and memory) with useless state, only
3013  * create attributes that can be meaningfully displayed.
3014  */
3015 static int add_regulator_attributes(struct regulator_dev *rdev)
3016 {
3017         struct device           *dev = &rdev->dev;
3018         struct regulator_ops    *ops = rdev->desc->ops;
3019         int                     status = 0;
3020
3021         /* some attributes need specific methods to be displayed */
3022         if ((ops->get_voltage && ops->get_voltage(rdev) >= 0) ||
3023             (ops->get_voltage_sel && ops->get_voltage_sel(rdev) >= 0)) {
3024                 status = device_create_file(dev, &dev_attr_microvolts);
3025                 if (status < 0)
3026                         return status;
3027         }
3028         if (ops->get_current_limit) {
3029                 status = device_create_file(dev, &dev_attr_microamps);
3030                 if (status < 0)
3031                         return status;
3032         }
3033         if (ops->get_mode) {
3034                 status = device_create_file(dev, &dev_attr_opmode);
3035                 if (status < 0)
3036                         return status;
3037         }
3038         if (ops->is_enabled) {
3039                 status = device_create_file(dev, &dev_attr_state);
3040                 if (status < 0)
3041                         return status;
3042         }
3043         if (ops->get_status) {
3044                 status = device_create_file(dev, &dev_attr_status);
3045                 if (status < 0)
3046                         return status;
3047         }
3048
3049         /* some attributes are type-specific */
3050         if (rdev->desc->type == REGULATOR_CURRENT) {
3051                 status = device_create_file(dev, &dev_attr_requested_microamps);
3052                 if (status < 0)
3053                         return status;
3054         }
3055
3056         /* all the other attributes exist to support constraints;
3057          * don't show them if there are no constraints, or if the
3058          * relevant supporting methods are missing.
3059          */
3060         if (!rdev->constraints)
3061                 return status;
3062
3063         /* constraints need specific supporting methods */
3064         if (ops->set_voltage || ops->set_voltage_sel) {
3065                 status = device_create_file(dev, &dev_attr_min_microvolts);
3066                 if (status < 0)
3067                         return status;
3068                 status = device_create_file(dev, &dev_attr_max_microvolts);
3069                 if (status < 0)
3070                         return status;
3071         }
3072         if (ops->set_current_limit) {
3073                 status = device_create_file(dev, &dev_attr_min_microamps);
3074                 if (status < 0)
3075                         return status;
3076                 status = device_create_file(dev, &dev_attr_max_microamps);
3077                 if (status < 0)
3078                         return status;
3079         }
3080
3081         status = device_create_file(dev, &dev_attr_suspend_standby_state);
3082         if (status < 0)
3083                 return status;
3084         status = device_create_file(dev, &dev_attr_suspend_mem_state);
3085         if (status < 0)
3086                 return status;
3087         status = device_create_file(dev, &dev_attr_suspend_disk_state);
3088         if (status < 0)
3089                 return status;
3090
3091         if (ops->set_suspend_voltage) {
3092                 status = device_create_file(dev,
3093                                 &dev_attr_suspend_standby_microvolts);
3094                 if (status < 0)
3095                         return status;
3096                 status = device_create_file(dev,
3097                                 &dev_attr_suspend_mem_microvolts);
3098                 if (status < 0)
3099                         return status;
3100                 status = device_create_file(dev,
3101                                 &dev_attr_suspend_disk_microvolts);
3102                 if (status < 0)
3103                         return status;
3104         }
3105
3106         if (ops->set_suspend_mode) {
3107                 status = device_create_file(dev,
3108                                 &dev_attr_suspend_standby_mode);
3109                 if (status < 0)
3110                         return status;
3111                 status = device_create_file(dev,
3112                                 &dev_attr_suspend_mem_mode);
3113                 if (status < 0)
3114                         return status;
3115                 status = device_create_file(dev,
3116                                 &dev_attr_suspend_disk_mode);
3117                 if (status < 0)
3118                         return status;
3119         }
3120
3121         return status;
3122 }
3123
3124 static void rdev_init_debugfs(struct regulator_dev *rdev)
3125 {
3126         rdev->debugfs = debugfs_create_dir(rdev_get_name(rdev), debugfs_root);
3127         if (!rdev->debugfs) {
3128                 rdev_warn(rdev, "Failed to create debugfs directory\n");
3129                 return;
3130         }
3131
3132         debugfs_create_u32("use_count", 0444, rdev->debugfs,
3133                            &rdev->use_count);
3134         debugfs_create_u32("open_count", 0444, rdev->debugfs,
3135                            &rdev->open_count);
3136 }
3137
3138 /**
3139  * regulator_register - register regulator
3140  * @regulator_desc: regulator to register
3141  * @config: runtime configuration for regulator
3142  *
3143  * Called by regulator drivers to register a regulator.
3144  * Returns 0 on success.
3145  */
3146 struct regulator_dev *
3147 regulator_register(const struct regulator_desc *regulator_desc,
3148                    const struct regulator_config *config)
3149 {
3150         const struct regulation_constraints *constraints = NULL;
3151         const struct regulator_init_data *init_data;
3152         static atomic_t regulator_no = ATOMIC_INIT(0);
3153         struct regulator_dev *rdev;
3154         struct device *dev;
3155         int ret, i;
3156         const char *supply = NULL;
3157
3158         if (regulator_desc == NULL || config == NULL)
3159                 return ERR_PTR(-EINVAL);
3160
3161         dev = config->dev;
3162         WARN_ON(!dev);
3163
3164         if (regulator_desc->name == NULL || regulator_desc->ops == NULL)
3165                 return ERR_PTR(-EINVAL);
3166
3167         if (regulator_desc->type != REGULATOR_VOLTAGE &&
3168             regulator_desc->type != REGULATOR_CURRENT)
3169                 return ERR_PTR(-EINVAL);
3170
3171         /* Only one of each should be implemented */
3172         WARN_ON(regulator_desc->ops->get_voltage &&
3173                 regulator_desc->ops->get_voltage_sel);
3174         WARN_ON(regulator_desc->ops->set_voltage &&
3175                 regulator_desc->ops->set_voltage_sel);
3176
3177         /* If we're using selectors we must implement list_voltage. */
3178         if (regulator_desc->ops->get_voltage_sel &&
3179             !regulator_desc->ops->list_voltage) {
3180                 return ERR_PTR(-EINVAL);
3181         }
3182         if (regulator_desc->ops->set_voltage_sel &&
3183             !regulator_desc->ops->list_voltage) {
3184                 return ERR_PTR(-EINVAL);
3185         }
3186
3187         init_data = config->init_data;
3188
3189         rdev = kzalloc(sizeof(struct regulator_dev), GFP_KERNEL);
3190         if (rdev == NULL)
3191                 return ERR_PTR(-ENOMEM);
3192
3193         mutex_lock(&regulator_list_mutex);
3194
3195         mutex_init(&rdev->mutex);
3196         rdev->reg_data = config->driver_data;
3197         rdev->owner = regulator_desc->owner;
3198         rdev->desc = regulator_desc;
3199         if (config->regmap)
3200                 rdev->regmap = config->regmap;
3201         else
3202                 rdev->regmap = dev_get_regmap(dev, NULL);
3203         INIT_LIST_HEAD(&rdev->consumer_list);
3204         INIT_LIST_HEAD(&rdev->list);
3205         BLOCKING_INIT_NOTIFIER_HEAD(&rdev->notifier);
3206         INIT_DELAYED_WORK(&rdev->disable_work, regulator_disable_work);
3207
3208         /* preform any regulator specific init */
3209         if (init_data && init_data->regulator_init) {
3210                 ret = init_data->regulator_init(rdev->reg_data);
3211                 if (ret < 0)
3212                         goto clean;
3213         }
3214
3215         /* register with sysfs */
3216         rdev->dev.class = &regulator_class;
3217         rdev->dev.of_node = config->of_node;
3218         rdev->dev.parent = dev;
3219         dev_set_name(&rdev->dev, "regulator.%d",
3220                      atomic_inc_return(&regulator_no) - 1);
3221         ret = device_register(&rdev->dev);
3222         if (ret != 0) {
3223                 put_device(&rdev->dev);
3224                 goto clean;
3225         }
3226
3227         dev_set_drvdata(&rdev->dev, rdev);
3228
3229         if (config->ena_gpio) {
3230                 ret = gpio_request_one(config->ena_gpio,
3231                                        GPIOF_DIR_OUT | config->ena_gpio_flags,
3232                                        rdev_get_name(rdev));
3233                 if (ret != 0) {
3234                         rdev_err(rdev, "Failed to request enable GPIO%d: %d\n",
3235                                  config->ena_gpio, ret);
3236                         goto clean;
3237                 }
3238
3239                 rdev->ena_gpio = config->ena_gpio;
3240                 rdev->ena_gpio_invert = config->ena_gpio_invert;
3241
3242                 if (config->ena_gpio_flags & GPIOF_OUT_INIT_HIGH)
3243                         rdev->ena_gpio_state = 1;
3244
3245                 if (rdev->ena_gpio_invert)
3246                         rdev->ena_gpio_state = !rdev->ena_gpio_state;
3247         }
3248
3249         /* set regulator constraints */
3250         if (init_data)
3251                 constraints = &init_data->constraints;
3252
3253         ret = set_machine_constraints(rdev, constraints);
3254         if (ret < 0)
3255                 goto scrub;
3256
3257         /* add attributes supported by this regulator */
3258         ret = add_regulator_attributes(rdev);
3259         if (ret < 0)
3260                 goto scrub;
3261
3262         if (init_data && init_data->supply_regulator)
3263                 supply = init_data->supply_regulator;
3264         else if (regulator_desc->supply_name)
3265                 supply = regulator_desc->supply_name;
3266
3267         if (supply) {
3268                 struct regulator_dev *r;
3269
3270                 r = regulator_dev_lookup(dev, supply, &ret);
3271
3272                 if (!r) {
3273                         dev_err(dev, "Failed to find supply %s\n", supply);
3274                         ret = -EPROBE_DEFER;
3275                         goto scrub;
3276                 }
3277
3278                 ret = set_supply(rdev, r);
3279                 if (ret < 0)
3280                         goto scrub;
3281
3282                 /* Enable supply if rail is enabled */
3283                 if (_regulator_is_enabled(rdev)) {
3284                         ret = regulator_enable(rdev->supply);
3285                         if (ret < 0)
3286                                 goto scrub;
3287                 }
3288         }
3289
3290         /* add consumers devices */
3291         if (init_data) {
3292                 for (i = 0; i < init_data->num_consumer_supplies; i++) {
3293                         ret = set_consumer_device_supply(rdev,
3294                                 init_data->consumer_supplies[i].dev_name,
3295                                 init_data->consumer_supplies[i].supply);
3296                         if (ret < 0) {
3297                                 dev_err(dev, "Failed to set supply %s\n",
3298                                         init_data->consumer_supplies[i].supply);
3299                                 goto unset_supplies;
3300                         }
3301                 }
3302         }
3303
3304         list_add(&rdev->list, &regulator_list);
3305
3306         rdev_init_debugfs(rdev);
3307 out:
3308         mutex_unlock(&regulator_list_mutex);
3309         return rdev;
3310
3311 unset_supplies:
3312         unset_regulator_supplies(rdev);
3313
3314 scrub:
3315         if (rdev->supply)
3316                 regulator_put(rdev->supply);
3317         if (rdev->ena_gpio)
3318                 gpio_free(rdev->ena_gpio);
3319         kfree(rdev->constraints);
3320         device_unregister(&rdev->dev);
3321         /* device core frees rdev */
3322         rdev = ERR_PTR(ret);
3323         goto out;
3324
3325 clean:
3326         kfree(rdev);
3327         rdev = ERR_PTR(ret);
3328         goto out;
3329 }
3330 EXPORT_SYMBOL_GPL(regulator_register);
3331
3332 /**
3333  * regulator_unregister - unregister regulator
3334  * @rdev: regulator to unregister
3335  *
3336  * Called by regulator drivers to unregister a regulator.
3337  */
3338 void regulator_unregister(struct regulator_dev *rdev)
3339 {
3340         if (rdev == NULL)
3341                 return;
3342
3343         if (rdev->supply)
3344                 regulator_put(rdev->supply);
3345         mutex_lock(&regulator_list_mutex);
3346         debugfs_remove_recursive(rdev->debugfs);
3347         flush_work_sync(&rdev->disable_work.work);
3348         WARN_ON(rdev->open_count);
3349         unset_regulator_supplies(rdev);
3350         list_del(&rdev->list);
3351         kfree(rdev->constraints);
3352         if (rdev->ena_gpio)
3353                 gpio_free(rdev->ena_gpio);
3354         device_unregister(&rdev->dev);
3355         mutex_unlock(&regulator_list_mutex);
3356 }
3357 EXPORT_SYMBOL_GPL(regulator_unregister);
3358
3359 /**
3360  * regulator_suspend_prepare - prepare regulators for system wide suspend
3361  * @state: system suspend state
3362  *
3363  * Configure each regulator with it's suspend operating parameters for state.
3364  * This will usually be called by machine suspend code prior to supending.
3365  */
3366 int regulator_suspend_prepare(suspend_state_t state)
3367 {
3368         struct regulator_dev *rdev;
3369         int ret = 0;
3370
3371         /* ON is handled by regulator active state */
3372         if (state == PM_SUSPEND_ON)
3373                 return -EINVAL;
3374
3375         mutex_lock(&regulator_list_mutex);
3376         list_for_each_entry(rdev, &regulator_list, list) {
3377
3378                 mutex_lock(&rdev->mutex);
3379                 ret = suspend_prepare(rdev, state);
3380                 mutex_unlock(&rdev->mutex);
3381
3382                 if (ret < 0) {
3383                         rdev_err(rdev, "failed to prepare\n");
3384                         goto out;
3385                 }
3386         }
3387 out:
3388         mutex_unlock(&regulator_list_mutex);
3389         return ret;
3390 }
3391 EXPORT_SYMBOL_GPL(regulator_suspend_prepare);
3392
3393 /**
3394  * regulator_suspend_finish - resume regulators from system wide suspend
3395  *
3396  * Turn on regulators that might be turned off by regulator_suspend_prepare
3397  * and that should be turned on according to the regulators properties.
3398  */
3399 int regulator_suspend_finish(void)
3400 {
3401         struct regulator_dev *rdev;
3402         int ret = 0, error;
3403
3404         mutex_lock(&regulator_list_mutex);
3405         list_for_each_entry(rdev, &regulator_list, list) {
3406                 struct regulator_ops *ops = rdev->desc->ops;
3407
3408                 mutex_lock(&rdev->mutex);
3409                 if ((rdev->use_count > 0  || rdev->constraints->always_on) &&
3410                                 ops->enable) {
3411                         error = ops->enable(rdev);
3412                         if (error)
3413                                 ret = error;
3414                 } else {
3415                         if (!has_full_constraints)
3416                                 goto unlock;
3417                         if (!ops->disable)
3418                                 goto unlock;
3419                         if (!_regulator_is_enabled(rdev))
3420                                 goto unlock;
3421
3422                         error = ops->disable(rdev);
3423                         if (error)
3424                                 ret = error;
3425                 }
3426 unlock:
3427                 mutex_unlock(&rdev->mutex);
3428         }
3429         mutex_unlock(&regulator_list_mutex);
3430         return ret;
3431 }
3432 EXPORT_SYMBOL_GPL(regulator_suspend_finish);
3433
3434 /**
3435  * regulator_has_full_constraints - the system has fully specified constraints
3436  *
3437  * Calling this function will cause the regulator API to disable all
3438  * regulators which have a zero use count and don't have an always_on
3439  * constraint in a late_initcall.
3440  *
3441  * The intention is that this will become the default behaviour in a
3442  * future kernel release so users are encouraged to use this facility
3443  * now.
3444  */
3445 void regulator_has_full_constraints(void)
3446 {
3447         has_full_constraints = 1;
3448 }
3449 EXPORT_SYMBOL_GPL(regulator_has_full_constraints);
3450
3451 /**
3452  * regulator_use_dummy_regulator - Provide a dummy regulator when none is found
3453  *
3454  * Calling this function will cause the regulator API to provide a
3455  * dummy regulator to consumers if no physical regulator is found,
3456  * allowing most consumers to proceed as though a regulator were
3457  * configured.  This allows systems such as those with software
3458  * controllable regulators for the CPU core only to be brought up more
3459  * readily.
3460  */
3461 void regulator_use_dummy_regulator(void)
3462 {
3463         board_wants_dummy_regulator = true;
3464 }
3465 EXPORT_SYMBOL_GPL(regulator_use_dummy_regulator);
3466
3467 /**
3468  * rdev_get_drvdata - get rdev regulator driver data
3469  * @rdev: regulator
3470  *
3471  * Get rdev regulator driver private data. This call can be used in the
3472  * regulator driver context.
3473  */
3474 void *rdev_get_drvdata(struct regulator_dev *rdev)
3475 {
3476         return rdev->reg_data;
3477 }
3478 EXPORT_SYMBOL_GPL(rdev_get_drvdata);
3479
3480 /**
3481  * regulator_get_drvdata - get regulator driver data
3482  * @regulator: regulator
3483  *
3484  * Get regulator driver private data. This call can be used in the consumer
3485  * driver context when non API regulator specific functions need to be called.
3486  */
3487 void *regulator_get_drvdata(struct regulator *regulator)
3488 {
3489         return regulator->rdev->reg_data;
3490 }
3491 EXPORT_SYMBOL_GPL(regulator_get_drvdata);
3492
3493 /**
3494  * regulator_set_drvdata - set regulator driver data
3495  * @regulator: regulator
3496  * @data: data
3497  */
3498 void regulator_set_drvdata(struct regulator *regulator, void *data)
3499 {
3500         regulator->rdev->reg_data = data;
3501 }
3502 EXPORT_SYMBOL_GPL(regulator_set_drvdata);
3503
3504 /**
3505  * regulator_get_id - get regulator ID
3506  * @rdev: regulator
3507  */
3508 int rdev_get_id(struct regulator_dev *rdev)
3509 {
3510         return rdev->desc->id;
3511 }
3512 EXPORT_SYMBOL_GPL(rdev_get_id);
3513
3514 struct device *rdev_get_dev(struct regulator_dev *rdev)
3515 {
3516         return &rdev->dev;
3517 }
3518 EXPORT_SYMBOL_GPL(rdev_get_dev);
3519
3520 void *regulator_get_init_drvdata(struct regulator_init_data *reg_init_data)
3521 {
3522         return reg_init_data->driver_data;
3523 }
3524 EXPORT_SYMBOL_GPL(regulator_get_init_drvdata);
3525
3526 #ifdef CONFIG_DEBUG_FS
3527 static ssize_t supply_map_read_file(struct file *file, char __user *user_buf,
3528                                     size_t count, loff_t *ppos)
3529 {
3530         char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
3531         ssize_t len, ret = 0;
3532         struct regulator_map *map;
3533
3534         if (!buf)
3535                 return -ENOMEM;
3536
3537         list_for_each_entry(map, &regulator_map_list, list) {
3538                 len = snprintf(buf + ret, PAGE_SIZE - ret,
3539                                "%s -> %s.%s\n",
3540                                rdev_get_name(map->regulator), map->dev_name,
3541                                map->supply);
3542                 if (len >= 0)
3543                         ret += len;
3544                 if (ret > PAGE_SIZE) {
3545                         ret = PAGE_SIZE;
3546                         break;
3547                 }
3548         }
3549
3550         ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
3551
3552         kfree(buf);
3553
3554         return ret;
3555 }
3556 #endif
3557
3558 static const struct file_operations supply_map_fops = {
3559 #ifdef CONFIG_DEBUG_FS
3560         .read = supply_map_read_file,
3561         .llseek = default_llseek,
3562 #endif
3563 };
3564
3565 static int __init regulator_init(void)
3566 {
3567         int ret;
3568
3569         ret = class_register(&regulator_class);
3570
3571         debugfs_root = debugfs_create_dir("regulator", NULL);
3572         if (!debugfs_root)
3573                 pr_warn("regulator: Failed to create debugfs directory\n");
3574
3575         debugfs_create_file("supply_map", 0444, debugfs_root, NULL,
3576                             &supply_map_fops);
3577
3578         regulator_dummy_init();
3579
3580         return ret;
3581 }
3582
3583 /* init early to allow our consumers to complete system booting */
3584 core_initcall(regulator_init);
3585
3586 static int __init regulator_init_complete(void)
3587 {
3588         struct regulator_dev *rdev;
3589         struct regulator_ops *ops;
3590         struct regulation_constraints *c;
3591         int enabled, ret;
3592
3593         /*
3594          * Since DT doesn't provide an idiomatic mechanism for
3595          * enabling full constraints and since it's much more natural
3596          * with DT to provide them just assume that a DT enabled
3597          * system has full constraints.
3598          */
3599         if (of_have_populated_dt())
3600                 has_full_constraints = true;
3601
3602         mutex_lock(&regulator_list_mutex);
3603
3604         /* If we have a full configuration then disable any regulators
3605          * which are not in use or always_on.  This will become the
3606          * default behaviour in the future.
3607          */
3608         list_for_each_entry(rdev, &regulator_list, list) {
3609                 ops = rdev->desc->ops;
3610                 c = rdev->constraints;
3611
3612                 if (!ops->disable || (c && c->always_on))
3613                         continue;
3614
3615                 mutex_lock(&rdev->mutex);
3616
3617                 if (rdev->use_count)
3618                         goto unlock;
3619
3620                 /* If we can't read the status assume it's on. */
3621                 if (ops->is_enabled)
3622                         enabled = ops->is_enabled(rdev);
3623                 else
3624                         enabled = 1;
3625
3626                 if (!enabled)
3627                         goto unlock;
3628
3629                 if (has_full_constraints) {
3630                         /* We log since this may kill the system if it
3631                          * goes wrong. */
3632                         rdev_info(rdev, "disabling\n");
3633                         ret = ops->disable(rdev);
3634                         if (ret != 0) {
3635                                 rdev_err(rdev, "couldn't disable: %d\n", ret);
3636                         }
3637                 } else {
3638                         /* The intention is that in future we will
3639                          * assume that full constraints are provided
3640                          * so warn even if we aren't going to do
3641                          * anything here.
3642                          */
3643                         rdev_warn(rdev, "incomplete constraints, leaving on\n");
3644                 }
3645
3646 unlock:
3647                 mutex_unlock(&rdev->mutex);
3648         }
3649
3650         mutex_unlock(&regulator_list_mutex);
3651
3652         return 0;
3653 }
3654 late_initcall(regulator_init_complete);