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