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