drivers/regulator/core.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 //
   3 // core.c  --  Voltage/Current Regulator framework.
   4 //
   5 // Copyright 2007, 2008 Wolfson Microelectronics PLC.
   6 // Copyright 2008 SlimLogic Ltd.
   7 //
   8 // Author: Liam Girdwood <lrg@slimlogic.co.uk>
   9
  10 #include <linux/kernel.h>
  11 #include <linux/init.h>
  12 #include <linux/debugfs.h>
  13 #include <linux/device.h>
  14 #include <linux/slab.h>
  15 #include <linux/async.h>
  16 #include <linux/err.h>
  17 #include <linux/mutex.h>
  18 #include <linux/suspend.h>
  19 #include <linux/delay.h>
  20 #include <linux/gpio/consumer.h>
  21 #include <linux/of.h>
  22 #include <linux/regmap.h>
  23 #include <linux/regulator/of_regulator.h>
  24 #include <linux/regulator/consumer.h>
  25 #include <linux/regulator/coupler.h>
  26 #include <linux/regulator/driver.h>
  27 #include <linux/regulator/machine.h>
  28 #include <linux/module.h>
  29
  30 #define CREATE_TRACE_POINTS
  31 #include <trace/events/regulator.h>
  32
  33 #include "dummy.h"
  34 #include "internal.h"
  35
  36 static DEFINE_WW_CLASS(regulator_ww_class);
  37 static DEFINE_MUTEX(regulator_nesting_mutex);
  38 static DEFINE_MUTEX(regulator_list_mutex);
  39 static LIST_HEAD(regulator_map_list);
  40 static LIST_HEAD(regulator_ena_gpio_list);
  41 static LIST_HEAD(regulator_supply_alias_list);
  42 static LIST_HEAD(regulator_coupler_list);
  43 static bool has_full_constraints;
  44
  45 static struct dentry *debugfs_root;
  46
  47 /*
  48  * struct regulator_map
  49  *
  50  * Used to provide symbolic supply names to devices.
  51  */
  52 struct regulator_map {
  53         struct list_head list;
  54         const char *dev_name;   /* The dev_name() for the consumer */
  55         const char *supply;
  56         struct regulator_dev *regulator;
  57 };
  58
  59 /*
  60  * struct regulator_enable_gpio
  61  *
  62  * Management for shared enable GPIO pin
  63  */
  64 struct regulator_enable_gpio {
  65         struct list_head list;
  66         struct gpio_desc *gpiod;
  67         u32 enable_count;       /* a number of enabled shared GPIO */
  68         u32 request_count;      /* a number of requested shared GPIO */
  69 };
  70
  71 /*
  72  * struct regulator_supply_alias
  73  *
  74  * Used to map lookups for a supply onto an alternative device.
  75  */
  76 struct regulator_supply_alias {
  77         struct list_head list;
  78         struct device *src_dev;
  79         const char *src_supply;
  80         struct device *alias_dev;
  81         const char *alias_supply;
  82 };
  83
  84 static int _regulator_is_enabled(struct regulator_dev *rdev);
  85 static int _regulator_disable(struct regulator *regulator);
  86 static int _regulator_get_error_flags(struct regulator_dev *rdev, unsigned int *flags);
  87 static int _regulator_get_current_limit(struct regulator_dev *rdev);
  88 static unsigned int _regulator_get_mode(struct regulator_dev *rdev);
  89 static int _notifier_call_chain(struct regulator_dev *rdev,
  90                                   unsigned long event, void *data);
  91 static int _regulator_do_set_voltage(struct regulator_dev *rdev,
  92                                      int min_uV, int max_uV);
  93 static int regulator_balance_voltage(struct regulator_dev *rdev,
  94                                      suspend_state_t state);
  95 static struct regulator *create_regulator(struct regulator_dev *rdev,
  96                                           struct device *dev,
  97                                           const char *supply_name);
  98 static void destroy_regulator(struct regulator *regulator);
  99 static void _regulator_put(struct regulator *regulator);
 100
 101 const char *rdev_get_name(struct regulator_dev *rdev)
 102 {
 103         if (rdev->constraints && rdev->constraints->name)
 104                 return rdev->constraints->name;
 105         else if (rdev->desc->name)
 106                 return rdev->desc->name;
 107         else
 108                 return "";
 109 }
 110 EXPORT_SYMBOL_GPL(rdev_get_name);
 111
 112 static bool have_full_constraints(void)
 113 {
 114         return has_full_constraints || of_have_populated_dt();
 115 }
 116
 117 static bool regulator_ops_is_valid(struct regulator_dev *rdev, int ops)
 118 {
 119         if (!rdev->constraints) {
 120                 rdev_err(rdev, "no constraints\n");
 121                 return false;
 122         }
 123
 124         if (rdev->constraints->valid_ops_mask & ops)
 125                 return true;
 126
 127         return false;
 128 }
 129
 130 /**
 131  * regulator_lock_nested - lock a single regulator
 132  * @rdev:               regulator source
 133  * @ww_ctx:             w/w mutex acquire context
 134  *
 135  * This function can be called many times by one task on
 136  * a single regulator and its mutex will be locked only
 137  * once. If a task, which is calling this function is other
 138  * than the one, which initially locked the mutex, it will
 139  * wait on mutex.
 140  */
 141 static inline int regulator_lock_nested(struct regulator_dev *rdev,
 142                                         struct ww_acquire_ctx *ww_ctx)
 143 {
 144         bool lock = false;
 145         int ret = 0;
 146
 147         mutex_lock(&regulator_nesting_mutex);
 148
 149         if (!ww_mutex_trylock(&rdev->mutex, ww_ctx)) {
 150                 if (rdev->mutex_owner == current)
 151                         rdev->ref_cnt++;
 152                 else
 153                         lock = true;
 154
 155                 if (lock) {
 156                         mutex_unlock(&regulator_nesting_mutex);
 157                         ret = ww_mutex_lock(&rdev->mutex, ww_ctx);
 158                         mutex_lock(&regulator_nesting_mutex);
 159                 }
 160         } else {
 161                 lock = true;
 162         }
 163
 164         if (lock && ret != -EDEADLK) {
 165                 rdev->ref_cnt++;
 166                 rdev->mutex_owner = current;
 167         }
 168
 169         mutex_unlock(&regulator_nesting_mutex);
 170
 171         return ret;
 172 }
 173
 174 /**
 175  * regulator_lock - lock a single regulator
 176  * @rdev:               regulator source
 177  *
 178  * This function can be called many times by one task on
 179  * a single regulator and its mutex will be locked only
 180  * once. If a task, which is calling this function is other
 181  * than the one, which initially locked the mutex, it will
 182  * wait on mutex.
 183  */
 184 static void regulator_lock(struct regulator_dev *rdev)
 185 {
 186         regulator_lock_nested(rdev, NULL);
 187 }
 188
 189 /**
 190  * regulator_unlock - unlock a single regulator
 191  * @rdev:               regulator_source
 192  *
 193  * This function unlocks the mutex when the
 194  * reference counter reaches 0.
 195  */
 196 static void regulator_unlock(struct regulator_dev *rdev)
 197 {
 198         mutex_lock(&regulator_nesting_mutex);
 199
 200         if (--rdev->ref_cnt == 0) {
 201                 rdev->mutex_owner = NULL;
 202                 ww_mutex_unlock(&rdev->mutex);
 203         }
 204
 205         WARN_ON_ONCE(rdev->ref_cnt < 0);
 206
 207         mutex_unlock(&regulator_nesting_mutex);
 208 }
 209
 210 static bool regulator_supply_is_couple(struct regulator_dev *rdev)
 211 {
 212         struct regulator_dev *c_rdev;
 213         int i;
 214
 215         for (i = 1; i < rdev->coupling_desc.n_coupled; i++) {
 216                 c_rdev = rdev->coupling_desc.coupled_rdevs[i];
 217
 218                 if (rdev->supply->rdev == c_rdev)
 219                         return true;
 220         }
 221
 222         return false;
 223 }
 224
 225 static void regulator_unlock_recursive(struct regulator_dev *rdev,
 226                                        unsigned int n_coupled)
 227 {
 228         struct regulator_dev *c_rdev, *supply_rdev;
 229         int i, supply_n_coupled;
 230
 231         for (i = n_coupled; i > 0; i--) {
 232                 c_rdev = rdev->coupling_desc.coupled_rdevs[i - 1];
 233
 234                 if (!c_rdev)
 235                         continue;
 236
 237                 if (c_rdev->supply && !regulator_supply_is_couple(c_rdev)) {
 238                         supply_rdev = c_rdev->supply->rdev;
 239                         supply_n_coupled = supply_rdev->coupling_desc.n_coupled;
 240
 241                         regulator_unlock_recursive(supply_rdev,
 242                                                    supply_n_coupled);
 243                 }
 244
 245                 regulator_unlock(c_rdev);
 246         }
 247 }
 248
 249 static int regulator_lock_recursive(struct regulator_dev *rdev,
 250                                     struct regulator_dev **new_contended_rdev,
 251                                     struct regulator_dev **old_contended_rdev,
 252                                     struct ww_acquire_ctx *ww_ctx)
 253 {
 254         struct regulator_dev *c_rdev;
 255         int i, err;
 256
 257         for (i = 0; i < rdev->coupling_desc.n_coupled; i++) {
 258                 c_rdev = rdev->coupling_desc.coupled_rdevs[i];
 259
 260                 if (!c_rdev)
 261                         continue;
 262
 263                 if (c_rdev != *old_contended_rdev) {
 264                         err = regulator_lock_nested(c_rdev, ww_ctx);
 265                         if (err) {
 266                                 if (err == -EDEADLK) {
 267                                         *new_contended_rdev = c_rdev;
 268                                         goto err_unlock;
 269                                 }
 270
 271                                 /* shouldn't happen */
 272                                 WARN_ON_ONCE(err != -EALREADY);
 273                         }
 274                 } else {
 275                         *old_contended_rdev = NULL;
 276                 }
 277
 278                 if (c_rdev->supply && !regulator_supply_is_couple(c_rdev)) {
 279                         err = regulator_lock_recursive(c_rdev->supply->rdev,
 280                                                        new_contended_rdev,
 281                                                        old_contended_rdev,
 282                                                        ww_ctx);
 283                         if (err) {
 284                                 regulator_unlock(c_rdev);
 285                                 goto err_unlock;
 286                         }
 287                 }
 288         }
 289
 290         return 0;
 291
 292 err_unlock:
 293         regulator_unlock_recursive(rdev, i);
 294
 295         return err;
 296 }
 297
 298 /**
 299  * regulator_unlock_dependent - unlock regulator's suppliers and coupled
 300  *                              regulators
 301  * @rdev:                       regulator source
 302  * @ww_ctx:                     w/w mutex acquire context
 303  *
 304  * Unlock all regulators related with rdev by coupling or supplying.
 305  */
 306 static void regulator_unlock_dependent(struct regulator_dev *rdev,
 307                                        struct ww_acquire_ctx *ww_ctx)
 308 {
 309         regulator_unlock_recursive(rdev, rdev->coupling_desc.n_coupled);
 310         ww_acquire_fini(ww_ctx);
 311 }
 312
 313 /**
 314  * regulator_lock_dependent - lock regulator's suppliers and coupled regulators
 315  * @rdev:                       regulator source
 316  * @ww_ctx:                     w/w mutex acquire context
 317  *
 318  * This function as a wrapper on regulator_lock_recursive(), which locks
 319  * all regulators related with rdev by coupling or supplying.
 320  */
 321 static void regulator_lock_dependent(struct regulator_dev *rdev,
 322                                      struct ww_acquire_ctx *ww_ctx)
 323 {
 324         struct regulator_dev *new_contended_rdev = NULL;
 325         struct regulator_dev *old_contended_rdev = NULL;
 326         int err;
 327
 328         mutex_lock(&regulator_list_mutex);
 329
 330         ww_acquire_init(ww_ctx, &regulator_ww_class);
 331
 332         do {
 333                 if (new_contended_rdev) {
 334                         ww_mutex_lock_slow(&new_contended_rdev->mutex, ww_ctx);
 335                         old_contended_rdev = new_contended_rdev;
 336                         old_contended_rdev->ref_cnt++;
 337                 }
 338
 339                 err = regulator_lock_recursive(rdev,
 340                                                &new_contended_rdev,
 341                                                &old_contended_rdev,
 342                                                ww_ctx);
 343
 344                 if (old_contended_rdev)
 345                         regulator_unlock(old_contended_rdev);
 346
 347         } while (err == -EDEADLK);
 348
 349         ww_acquire_done(ww_ctx);
 350
 351         mutex_unlock(&regulator_list_mutex);
 352 }
 353
 354 /**
 355  * of_get_child_regulator - get a child regulator device node
 356  * based on supply name
 357  * @parent: Parent device node
 358  * @prop_name: Combination regulator supply name and "-supply"
 359  *
 360  * Traverse all child nodes.
 361  * Extract the child regulator device node corresponding to the supply name.
 362  * returns the device node corresponding to the regulator if found, else
 363  * returns NULL.
 364  */
 365 static struct device_node *of_get_child_regulator(struct device_node *parent,
 366                                                   const char *prop_name)
 367 {
 368         struct device_node *regnode = NULL;
 369         struct device_node *child = NULL;
 370
 371         for_each_child_of_node(parent, child) {
 372                 regnode = of_parse_phandle(child, prop_name, 0);
 373
 374                 if (!regnode) {
 375                         regnode = of_get_child_regulator(child, prop_name);
 376                         if (regnode)
 377                                 goto err_node_put;
 378                 } else {
 379                         goto err_node_put;
 380                 }
 381         }
 382         return NULL;
 383
 384 err_node_put:
 385         of_node_put(child);
 386         return regnode;
 387 }
 388
 389 /**
 390  * of_get_regulator - get a regulator device node based on supply name
 391  * @dev: Device pointer for the consumer (of regulator) device
 392  * @supply: regulator supply name
 393  *
 394  * Extract the regulator device node corresponding to the supply name.
 395  * returns the device node corresponding to the regulator if found, else
 396  * returns NULL.
 397  */
 398 static struct device_node *of_get_regulator(struct device *dev, const char *supply)
 399 {
 400         struct device_node *regnode = NULL;
 401         char prop_name[64]; /* 64 is max size of property name */
 402
 403         dev_dbg(dev, "Looking up %s-supply from device tree\n", supply);
 404
 405         snprintf(prop_name, 64, "%s-supply", supply);
 406         regnode = of_parse_phandle(dev->of_node, prop_name, 0);
 407
 408         if (!regnode) {
 409                 regnode = of_get_child_regulator(dev->of_node, prop_name);
 410                 if (regnode)
 411                         return regnode;
 412
 413                 dev_dbg(dev, "Looking up %s property in node %pOF failed\n",
 414                                 prop_name, dev->of_node);
 415                 return NULL;
 416         }
 417         return regnode;
 418 }
 419
 420 /* Platform voltage constraint check */
 421 int regulator_check_voltage(struct regulator_dev *rdev,
 422                             int *min_uV, int *max_uV)
 423 {
 424         BUG_ON(*min_uV > *max_uV);
 425
 426         if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_VOLTAGE)) {
 427                 rdev_err(rdev, "voltage operation not allowed\n");
 428                 return -EPERM;
 429         }
 430
 431         if (*max_uV > rdev->constraints->max_uV)
 432                 *max_uV = rdev->constraints->max_uV;
 433         if (*min_uV < rdev->constraints->min_uV)
 434                 *min_uV = rdev->constraints->min_uV;
 435
 436         if (*min_uV > *max_uV) {
 437                 rdev_err(rdev, "unsupportable voltage range: %d-%duV\n",
 438                          *min_uV, *max_uV);
 439                 return -EINVAL;
 440         }
 441
 442         return 0;
 443 }
 444
 445 /* return 0 if the state is valid */
 446 static int regulator_check_states(suspend_state_t state)
 447 {
 448         return (state > PM_SUSPEND_MAX || state == PM_SUSPEND_TO_IDLE);
 449 }
 450
 451 /* Make sure we select a voltage that suits the needs of all
 452  * regulator consumers
 453  */
 454 int regulator_check_consumers(struct regulator_dev *rdev,
 455                               int *min_uV, int *max_uV,
 456                               suspend_state_t state)
 457 {
 458         struct regulator *regulator;
 459         struct regulator_voltage *voltage;
 460
 461         list_for_each_entry(regulator, &rdev->consumer_list, list) {
 462                 voltage = &regulator->voltage[state];
 463                 /*
 464                  * Assume consumers that didn't say anything are OK
 465                  * with anything in the constraint range.
 466                  */
 467                 if (!voltage->min_uV && !voltage->max_uV)
 468                         continue;
 469
 470                 if (*max_uV > voltage->max_uV)
 471                         *max_uV = voltage->max_uV;
 472                 if (*min_uV < voltage->min_uV)
 473                         *min_uV = voltage->min_uV;
 474         }
 475
 476         if (*min_uV > *max_uV) {
 477                 rdev_err(rdev, "Restricting voltage, %u-%uuV\n",
 478                         *min_uV, *max_uV);
 479                 return -EINVAL;
 480         }
 481
 482         return 0;
 483 }
 484
 485 /* current constraint check */
 486 static int regulator_check_current_limit(struct regulator_dev *rdev,
 487                                         int *min_uA, int *max_uA)
 488 {
 489         BUG_ON(*min_uA > *max_uA);
 490
 491         if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_CURRENT)) {
 492                 rdev_err(rdev, "current operation not allowed\n");
 493                 return -EPERM;
 494         }
 495
 496         if (*max_uA > rdev->constraints->max_uA)
 497                 *max_uA = rdev->constraints->max_uA;
 498         if (*min_uA < rdev->constraints->min_uA)
 499                 *min_uA = rdev->constraints->min_uA;
 500
 501         if (*min_uA > *max_uA) {
 502                 rdev_err(rdev, "unsupportable current range: %d-%duA\n",
 503                          *min_uA, *max_uA);
 504                 return -EINVAL;
 505         }
 506
 507         return 0;
 508 }
 509
 510 /* operating mode constraint check */
 511 static int regulator_mode_constrain(struct regulator_dev *rdev,
 512                                     unsigned int *mode)
 513 {
 514         switch (*mode) {
 515         case REGULATOR_MODE_FAST:
 516         case REGULATOR_MODE_NORMAL:
 517         case REGULATOR_MODE_IDLE:
 518         case REGULATOR_MODE_STANDBY:
 519                 break;
 520         default:
 521                 rdev_err(rdev, "invalid mode %x specified\n", *mode);
 522                 return -EINVAL;
 523         }
 524
 525         if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_MODE)) {
 526                 rdev_err(rdev, "mode operation not allowed\n");
 527                 return -EPERM;
 528         }
 529
 530         /* The modes are bitmasks, the most power hungry modes having
 531          * the lowest values. If the requested mode isn't supported
 532          * try higher modes.
 533          */
 534         while (*mode) {
 535                 if (rdev->constraints->valid_modes_mask & *mode)
 536                         return 0;
 537                 *mode /= 2;
 538         }
 539
 540         return -EINVAL;
 541 }
 542
 543 static inline struct regulator_state *
 544 regulator_get_suspend_state(struct regulator_dev *rdev, suspend_state_t state)
 545 {
 546         if (rdev->constraints == NULL)
 547                 return NULL;
 548
 549         switch (state) {
 550         case PM_SUSPEND_STANDBY:
 551                 return &rdev->constraints->state_standby;
 552         case PM_SUSPEND_MEM:
 553                 return &rdev->constraints->state_mem;
 554         case PM_SUSPEND_MAX:
 555                 return &rdev->constraints->state_disk;
 556         default:
 557                 return NULL;
 558         }
 559 }
 560
 561 static const struct regulator_state *
 562 regulator_get_suspend_state_check(struct regulator_dev *rdev, suspend_state_t state)
 563 {
 564         const struct regulator_state *rstate;
 565
 566         rstate = regulator_get_suspend_state(rdev, state);
 567         if (rstate == NULL)
 568                 return NULL;
 569
 570         /* If we have no suspend mode configuration don't set anything;
 571          * only warn if the driver implements set_suspend_voltage or
 572          * set_suspend_mode callback.
 573          */
 574         if (rstate->enabled != ENABLE_IN_SUSPEND &&
 575             rstate->enabled != DISABLE_IN_SUSPEND) {
 576                 if (rdev->desc->ops->set_suspend_voltage ||
 577                     rdev->desc->ops->set_suspend_mode)
 578                         rdev_warn(rdev, "No configuration\n");
 579                 return NULL;
 580         }
 581
 582         return rstate;
 583 }
 584
 585 static ssize_t microvolts_show(struct device *dev,
 586                                struct device_attribute *attr, char *buf)
 587 {
 588         struct regulator_dev *rdev = dev_get_drvdata(dev);
 589         int uV;
 590
 591         regulator_lock(rdev);
 592         uV = regulator_get_voltage_rdev(rdev);
 593         regulator_unlock(rdev);
 594
 595         if (uV < 0)
 596                 return uV;
 597         return sprintf(buf, "%d\n", uV);
 598 }
 599 static DEVICE_ATTR_RO(microvolts);
 600
 601 static ssize_t microamps_show(struct device *dev,
 602                               struct device_attribute *attr, char *buf)
 603 {
 604         struct regulator_dev *rdev = dev_get_drvdata(dev);
 605
 606         return sprintf(buf, "%d\n", _regulator_get_current_limit(rdev));
 607 }
 608 static DEVICE_ATTR_RO(microamps);
 609
 610 static ssize_t name_show(struct device *dev, struct device_attribute *attr,
 611                          char *buf)
 612 {
 613         struct regulator_dev *rdev = dev_get_drvdata(dev);
 614
 615         return sprintf(buf, "%s\n", rdev_get_name(rdev));
 616 }
 617 static DEVICE_ATTR_RO(name);
 618
 619 static const char *regulator_opmode_to_str(int mode)
 620 {
 621         switch (mode) {
 622         case REGULATOR_MODE_FAST:
 623                 return "fast";
 624         case REGULATOR_MODE_NORMAL:
 625                 return "normal";
 626         case REGULATOR_MODE_IDLE:
 627                 return "idle";
 628         case REGULATOR_MODE_STANDBY:
 629                 return "standby";
 630         }
 631         return "unknown";
 632 }
 633
 634 static ssize_t regulator_print_opmode(char *buf, int mode)
 635 {
 636         return sprintf(buf, "%s\n", regulator_opmode_to_str(mode));
 637 }
 638
 639 static ssize_t opmode_show(struct device *dev,
 640                            struct device_attribute *attr, char *buf)
 641 {
 642         struct regulator_dev *rdev = dev_get_drvdata(dev);
 643
 644         return regulator_print_opmode(buf, _regulator_get_mode(rdev));
 645 }
 646 static DEVICE_ATTR_RO(opmode);
 647
 648 static ssize_t regulator_print_state(char *buf, int state)
 649 {
 650         if (state > 0)
 651                 return sprintf(buf, "enabled\n");
 652         else if (state == 0)
 653                 return sprintf(buf, "disabled\n");
 654         else
 655                 return sprintf(buf, "unknown\n");
 656 }
 657
 658 static ssize_t state_show(struct device *dev,
 659                           struct device_attribute *attr, char *buf)
 660 {
 661         struct regulator_dev *rdev = dev_get_drvdata(dev);
 662         ssize_t ret;
 663
 664         regulator_lock(rdev);
 665         ret = regulator_print_state(buf, _regulator_is_enabled(rdev));
 666         regulator_unlock(rdev);
 667
 668         return ret;
 669 }
 670 static DEVICE_ATTR_RO(state);
 671
 672 static ssize_t status_show(struct device *dev,
 673                            struct device_attribute *attr, char *buf)
 674 {
 675         struct regulator_dev *rdev = dev_get_drvdata(dev);
 676         int status;
 677         char *label;
 678
 679         status = rdev->desc->ops->get_status(rdev);
 680         if (status < 0)
 681                 return status;
 682
 683         switch (status) {
 684         case REGULATOR_STATUS_OFF:
 685                 label = "off";
 686                 break;
 687         case REGULATOR_STATUS_ON:
 688                 label = "on";
 689                 break;
 690         case REGULATOR_STATUS_ERROR:
 691                 label = "error";
 692                 break;
 693         case REGULATOR_STATUS_FAST:
 694                 label = "fast";
 695                 break;
 696         case REGULATOR_STATUS_NORMAL:
 697                 label = "normal";
 698                 break;
 699         case REGULATOR_STATUS_IDLE:
 700                 label = "idle";
 701                 break;
 702         case REGULATOR_STATUS_STANDBY:
 703                 label = "standby";
 704                 break;
 705         case REGULATOR_STATUS_BYPASS:
 706                 label = "bypass";
 707                 break;
 708         case REGULATOR_STATUS_UNDEFINED:
 709                 label = "undefined";
 710                 break;
 711         default:
 712                 return -ERANGE;
 713         }
 714
 715         return sprintf(buf, "%s\n", label);
 716 }
 717 static DEVICE_ATTR_RO(status);
 718
 719 static ssize_t min_microamps_show(struct device *dev,
 720                                   struct device_attribute *attr, char *buf)
 721 {
 722         struct regulator_dev *rdev = dev_get_drvdata(dev);
 723
 724         if (!rdev->constraints)
 725                 return sprintf(buf, "constraint not defined\n");
 726
 727         return sprintf(buf, "%d\n", rdev->constraints->min_uA);
 728 }
 729 static DEVICE_ATTR_RO(min_microamps);
 730
 731 static ssize_t max_microamps_show(struct device *dev,
 732                                   struct device_attribute *attr, char *buf)
 733 {
 734         struct regulator_dev *rdev = dev_get_drvdata(dev);
 735
 736         if (!rdev->constraints)
 737                 return sprintf(buf, "constraint not defined\n");
 738
 739         return sprintf(buf, "%d\n", rdev->constraints->max_uA);
 740 }
 741 static DEVICE_ATTR_RO(max_microamps);
 742
 743 static ssize_t min_microvolts_show(struct device *dev,
 744                                    struct device_attribute *attr, char *buf)
 745 {
 746         struct regulator_dev *rdev = dev_get_drvdata(dev);
 747
 748         if (!rdev->constraints)
 749                 return sprintf(buf, "constraint not defined\n");
 750
 751         return sprintf(buf, "%d\n", rdev->constraints->min_uV);
 752 }
 753 static DEVICE_ATTR_RO(min_microvolts);
 754
 755 static ssize_t max_microvolts_show(struct device *dev,
 756                                    struct device_attribute *attr, char *buf)
 757 {
 758         struct regulator_dev *rdev = dev_get_drvdata(dev);
 759
 760         if (!rdev->constraints)
 761                 return sprintf(buf, "constraint not defined\n");
 762
 763         return sprintf(buf, "%d\n", rdev->constraints->max_uV);
 764 }
 765 static DEVICE_ATTR_RO(max_microvolts);
 766
 767 static ssize_t requested_microamps_show(struct device *dev,
 768                                         struct device_attribute *attr, char *buf)
 769 {
 770         struct regulator_dev *rdev = dev_get_drvdata(dev);
 771         struct regulator *regulator;
 772         int uA = 0;
 773
 774         regulator_lock(rdev);
 775         list_for_each_entry(regulator, &rdev->consumer_list, list) {
 776                 if (regulator->enable_count)
 777                         uA += regulator->uA_load;
 778         }
 779         regulator_unlock(rdev);
 780         return sprintf(buf, "%d\n", uA);
 781 }
 782 static DEVICE_ATTR_RO(requested_microamps);
 783
 784 static ssize_t num_users_show(struct device *dev, struct device_attribute *attr,
 785                               char *buf)
 786 {
 787         struct regulator_dev *rdev = dev_get_drvdata(dev);
 788         return sprintf(buf, "%d\n", rdev->use_count);
 789 }
 790 static DEVICE_ATTR_RO(num_users);
 791
 792 static ssize_t type_show(struct device *dev, struct device_attribute *attr,
 793                          char *buf)
 794 {
 795         struct regulator_dev *rdev = dev_get_drvdata(dev);
 796
 797         switch (rdev->desc->type) {
 798         case REGULATOR_VOLTAGE:
 799                 return sprintf(buf, "voltage\n");
 800         case REGULATOR_CURRENT:
 801                 return sprintf(buf, "current\n");
 802         }
 803         return sprintf(buf, "unknown\n");
 804 }
 805 static DEVICE_ATTR_RO(type);
 806
 807 static ssize_t suspend_mem_microvolts_show(struct device *dev,
 808                                            struct device_attribute *attr, char *buf)
 809 {
 810         struct regulator_dev *rdev = dev_get_drvdata(dev);
 811
 812         return sprintf(buf, "%d\n", rdev->constraints->state_mem.uV);
 813 }
 814 static DEVICE_ATTR_RO(suspend_mem_microvolts);
 815
 816 static ssize_t suspend_disk_microvolts_show(struct device *dev,
 817                                             struct device_attribute *attr, char *buf)
 818 {
 819         struct regulator_dev *rdev = dev_get_drvdata(dev);
 820
 821         return sprintf(buf, "%d\n", rdev->constraints->state_disk.uV);
 822 }
 823 static DEVICE_ATTR_RO(suspend_disk_microvolts);
 824
 825 static ssize_t suspend_standby_microvolts_show(struct device *dev,
 826                                                struct device_attribute *attr, char *buf)
 827 {
 828         struct regulator_dev *rdev = dev_get_drvdata(dev);
 829
 830         return sprintf(buf, "%d\n", rdev->constraints->state_standby.uV);
 831 }
 832 static DEVICE_ATTR_RO(suspend_standby_microvolts);
 833
 834 static ssize_t suspend_mem_mode_show(struct device *dev,
 835                                      struct device_attribute *attr, char *buf)
 836 {
 837         struct regulator_dev *rdev = dev_get_drvdata(dev);
 838
 839         return regulator_print_opmode(buf,
 840                 rdev->constraints->state_mem.mode);
 841 }
 842 static DEVICE_ATTR_RO(suspend_mem_mode);
 843
 844 static ssize_t suspend_disk_mode_show(struct device *dev,
 845                                       struct device_attribute *attr, char *buf)
 846 {
 847         struct regulator_dev *rdev = dev_get_drvdata(dev);
 848
 849         return regulator_print_opmode(buf,
 850                 rdev->constraints->state_disk.mode);
 851 }
 852 static DEVICE_ATTR_RO(suspend_disk_mode);
 853
 854 static ssize_t suspend_standby_mode_show(struct device *dev,
 855                                          struct device_attribute *attr, char *buf)
 856 {
 857         struct regulator_dev *rdev = dev_get_drvdata(dev);
 858
 859         return regulator_print_opmode(buf,
 860                 rdev->constraints->state_standby.mode);
 861 }
 862 static DEVICE_ATTR_RO(suspend_standby_mode);
 863
 864 static ssize_t suspend_mem_state_show(struct device *dev,
 865                                       struct device_attribute *attr, char *buf)
 866 {
 867         struct regulator_dev *rdev = dev_get_drvdata(dev);
 868
 869         return regulator_print_state(buf,
 870                         rdev->constraints->state_mem.enabled);
 871 }
 872 static DEVICE_ATTR_RO(suspend_mem_state);
 873
 874 static ssize_t suspend_disk_state_show(struct device *dev,
 875                                        struct device_attribute *attr, char *buf)
 876 {
 877         struct regulator_dev *rdev = dev_get_drvdata(dev);
 878
 879         return regulator_print_state(buf,
 880                         rdev->constraints->state_disk.enabled);
 881 }
 882 static DEVICE_ATTR_RO(suspend_disk_state);
 883
 884 static ssize_t suspend_standby_state_show(struct device *dev,
 885                                           struct device_attribute *attr, char *buf)
 886 {
 887         struct regulator_dev *rdev = dev_get_drvdata(dev);
 888
 889         return regulator_print_state(buf,
 890                         rdev->constraints->state_standby.enabled);
 891 }
 892 static DEVICE_ATTR_RO(suspend_standby_state);
 893
 894 static ssize_t bypass_show(struct device *dev,
 895                            struct device_attribute *attr, char *buf)
 896 {
 897         struct regulator_dev *rdev = dev_get_drvdata(dev);
 898         const char *report;
 899         bool bypass;
 900         int ret;
 901
 902         ret = rdev->desc->ops->get_bypass(rdev, &bypass);
 903
 904         if (ret != 0)
 905                 report = "unknown";
 906         else if (bypass)
 907                 report = "enabled";
 908         else
 909                 report = "disabled";
 910
 911         return sprintf(buf, "%s\n", report);
 912 }
 913 static DEVICE_ATTR_RO(bypass);
 914
 915 #define REGULATOR_ERROR_ATTR(name, bit)                                                 \
 916         static ssize_t name##_show(struct device *dev, struct device_attribute *attr,   \
 917                                    char *buf)                                           \
 918         {                                                                               \
 919                 int ret;                                                                \
 920                 unsigned int flags;                                                     \
 921                 struct regulator_dev *rdev = dev_get_drvdata(dev);                      \
 922                 ret = _regulator_get_error_flags(rdev, &flags);                         \
 923                 if (ret)                                                                \
 924                         return ret;                                                     \
 925                 return sysfs_emit(buf, "%d\n", !!(flags & (bit)));                      \
 926         }                                                                               \
 927         static DEVICE_ATTR_RO(name)
 928
 929 REGULATOR_ERROR_ATTR(under_voltage, REGULATOR_ERROR_UNDER_VOLTAGE);
 930 REGULATOR_ERROR_ATTR(over_current, REGULATOR_ERROR_OVER_CURRENT);
 931 REGULATOR_ERROR_ATTR(regulation_out, REGULATOR_ERROR_REGULATION_OUT);
 932 REGULATOR_ERROR_ATTR(fail, REGULATOR_ERROR_FAIL);
 933 REGULATOR_ERROR_ATTR(over_temp, REGULATOR_ERROR_OVER_TEMP);
 934 REGULATOR_ERROR_ATTR(under_voltage_warn, REGULATOR_ERROR_UNDER_VOLTAGE_WARN);
 935 REGULATOR_ERROR_ATTR(over_current_warn, REGULATOR_ERROR_OVER_CURRENT_WARN);
 936 REGULATOR_ERROR_ATTR(over_voltage_warn, REGULATOR_ERROR_OVER_VOLTAGE_WARN);
 937 REGULATOR_ERROR_ATTR(over_temp_warn, REGULATOR_ERROR_OVER_TEMP_WARN);
 938
 939 /* Calculate the new optimum regulator operating mode based on the new total
 940  * consumer load. All locks held by caller
 941  */
 942 static int drms_uA_update(struct regulator_dev *rdev)
 943 {
 944         struct regulator *sibling;
 945         int current_uA = 0, output_uV, input_uV, err;
 946         unsigned int mode;
 947
 948         /*
 949          * first check to see if we can set modes at all, otherwise just
 950          * tell the consumer everything is OK.
 951          */
 952         if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_DRMS)) {
 953                 rdev_dbg(rdev, "DRMS operation not allowed\n");
 954                 return 0;
 955         }
 956
 957         if (!rdev->desc->ops->get_optimum_mode &&
 958             !rdev->desc->ops->set_load)
 959                 return 0;
 960
 961         if (!rdev->desc->ops->set_mode &&
 962             !rdev->desc->ops->set_load)
 963                 return -EINVAL;
 964
 965         /* calc total requested load */
 966         list_for_each_entry(sibling, &rdev->consumer_list, list) {
 967                 if (sibling->enable_count)
 968                         current_uA += sibling->uA_load;
 969         }
 970
 971         current_uA += rdev->constraints->system_load;
 972
 973         if (rdev->desc->ops->set_load) {
 974                 /* set the optimum mode for our new total regulator load */
 975                 err = rdev->desc->ops->set_load(rdev, current_uA);
 976                 if (err < 0)
 977                         rdev_err(rdev, "failed to set load %d: %pe\n",
 978                                  current_uA, ERR_PTR(err));
 979         } else {
 980                 /*
 981                  * Unfortunately in some cases the constraints->valid_ops has
 982                  * REGULATOR_CHANGE_DRMS but there are no valid modes listed.
 983                  * That's not really legit but we won't consider it a fatal
 984                  * error here. We'll treat it as if REGULATOR_CHANGE_DRMS
 985                  * wasn't set.
 986                  */
 987                 if (!rdev->constraints->valid_modes_mask) {
 988                         rdev_dbg(rdev, "Can change modes; but no valid mode\n");
 989                         return 0;
 990                 }
 991
 992                 /* get output voltage */
 993                 output_uV = regulator_get_voltage_rdev(rdev);
 994
 995                 /*
 996                  * Don't return an error; if regulator driver cares about
 997                  * output_uV then it's up to the driver to validate.
 998                  */
 999                 if (output_uV <= 0)
1000                         rdev_dbg(rdev, "invalid output voltage found\n");
1001
1002                 /* get input voltage */
1003                 input_uV = 0;
1004                 if (rdev->supply)
1005                         input_uV = regulator_get_voltage_rdev(rdev->supply->rdev);
1006                 if (input_uV <= 0)
1007                         input_uV = rdev->constraints->input_uV;
1008
1009                 /*
1010                  * Don't return an error; if regulator driver cares about
1011                  * input_uV then it's up to the driver to validate.
1012                  */
1013                 if (input_uV <= 0)
1014                         rdev_dbg(rdev, "invalid input voltage found\n");
1015
1016                 /* now get the optimum mode for our new total regulator load */
1017                 mode = rdev->desc->ops->get_optimum_mode(rdev, input_uV,
1018                                                          output_uV, current_uA);
1019
1020                 /* check the new mode is allowed */
1021                 err = regulator_mode_constrain(rdev, &mode);
1022                 if (err < 0) {
1023                         rdev_err(rdev, "failed to get optimum mode @ %d uA %d -> %d uV: %pe\n",
1024                                  current_uA, input_uV, output_uV, ERR_PTR(err));
1025                         return err;
1026                 }
1027
1028                 err = rdev->desc->ops->set_mode(rdev, mode);
1029                 if (err < 0)
1030                         rdev_err(rdev, "failed to set optimum mode %x: %pe\n",
1031                                  mode, ERR_PTR(err));
1032         }
1033
1034         return err;
1035 }
1036
1037 static int __suspend_set_state(struct regulator_dev *rdev,
1038                                const struct regulator_state *rstate)
1039 {
1040         int ret = 0;
1041
1042         if (rstate->enabled == ENABLE_IN_SUSPEND &&
1043                 rdev->desc->ops->set_suspend_enable)
1044                 ret = rdev->desc->ops->set_suspend_enable(rdev);
1045         else if (rstate->enabled == DISABLE_IN_SUSPEND &&
1046                 rdev->desc->ops->set_suspend_disable)
1047                 ret = rdev->desc->ops->set_suspend_disable(rdev);
1048         else /* OK if set_suspend_enable or set_suspend_disable is NULL */
1049                 ret = 0;
1050
1051         if (ret < 0) {
1052                 rdev_err(rdev, "failed to enabled/disable: %pe\n", ERR_PTR(ret));
1053                 return ret;
1054         }
1055
1056         if (rdev->desc->ops->set_suspend_voltage && rstate->uV > 0) {
1057                 ret = rdev->desc->ops->set_suspend_voltage(rdev, rstate->uV);
1058                 if (ret < 0) {
1059                         rdev_err(rdev, "failed to set voltage: %pe\n", ERR_PTR(ret));
1060                         return ret;
1061                 }
1062         }
1063
1064         if (rdev->desc->ops->set_suspend_mode && rstate->mode > 0) {
1065                 ret = rdev->desc->ops->set_suspend_mode(rdev, rstate->mode);
1066                 if (ret < 0) {
1067                         rdev_err(rdev, "failed to set mode: %pe\n", ERR_PTR(ret));
1068                         return ret;
1069                 }
1070         }
1071
1072         return ret;
1073 }
1074
1075 static int suspend_set_initial_state(struct regulator_dev *rdev)
1076 {
1077         const struct regulator_state *rstate;
1078
1079         rstate = regulator_get_suspend_state_check(rdev,
1080                         rdev->constraints->initial_state);
1081         if (!rstate)
1082                 return 0;
1083
1084         return __suspend_set_state(rdev, rstate);
1085 }
1086
1087 #if defined(DEBUG) || defined(CONFIG_DYNAMIC_DEBUG)
1088 static void print_constraints_debug(struct regulator_dev *rdev)
1089 {
1090         struct regulation_constraints *constraints = rdev->constraints;
1091         char buf[160] = "";
1092         size_t len = sizeof(buf) - 1;
1093         int count = 0;
1094         int ret;
1095
1096         if (constraints->min_uV && constraints->max_uV) {
1097                 if (constraints->min_uV == constraints->max_uV)
1098                         count += scnprintf(buf + count, len - count, "%d mV ",
1099                                            constraints->min_uV / 1000);
1100                 else
1101                         count += scnprintf(buf + count, len - count,
1102                                            "%d <--> %d mV ",
1103                                            constraints->min_uV / 1000,
1104                                            constraints->max_uV / 1000);
1105         }
1106
1107         if (!constraints->min_uV ||
1108             constraints->min_uV != constraints->max_uV) {
1109                 ret = regulator_get_voltage_rdev(rdev);
1110                 if (ret > 0)
1111                         count += scnprintf(buf + count, len - count,
1112                                            "at %d mV ", ret / 1000);
1113         }
1114
1115         if (constraints->uV_offset)
1116                 count += scnprintf(buf + count, len - count, "%dmV offset ",
1117                                    constraints->uV_offset / 1000);
1118
1119         if (constraints->min_uA && constraints->max_uA) {
1120                 if (constraints->min_uA == constraints->max_uA)
1121                         count += scnprintf(buf + count, len - count, "%d mA ",
1122                                            constraints->min_uA / 1000);
1123                 else
1124                         count += scnprintf(buf + count, len - count,
1125                                            "%d <--> %d mA ",
1126                                            constraints->min_uA / 1000,
1127                                            constraints->max_uA / 1000);
1128         }
1129
1130         if (!constraints->min_uA ||
1131             constraints->min_uA != constraints->max_uA) {
1132                 ret = _regulator_get_current_limit(rdev);
1133                 if (ret > 0)
1134                         count += scnprintf(buf + count, len - count,
1135                                            "at %d mA ", ret / 1000);
1136         }
1137
1138         if (constraints->valid_modes_mask & REGULATOR_MODE_FAST)
1139                 count += scnprintf(buf + count, len - count, "fast ");
1140         if (constraints->valid_modes_mask & REGULATOR_MODE_NORMAL)
1141                 count += scnprintf(buf + count, len - count, "normal ");
1142         if (constraints->valid_modes_mask & REGULATOR_MODE_IDLE)
1143                 count += scnprintf(buf + count, len - count, "idle ");
1144         if (constraints->valid_modes_mask & REGULATOR_MODE_STANDBY)
1145                 count += scnprintf(buf + count, len - count, "standby ");
1146
1147         if (!count)
1148                 count = scnprintf(buf, len, "no parameters");
1149         else
1150                 --count;
1151
1152         count += scnprintf(buf + count, len - count, ", %s",
1153                 _regulator_is_enabled(rdev) ? "enabled" : "disabled");
1154
1155         rdev_dbg(rdev, "%s\n", buf);
1156 }
1157 #else /* !DEBUG && !CONFIG_DYNAMIC_DEBUG */
1158 static inline void print_constraints_debug(struct regulator_dev *rdev) {}
1159 #endif /* !DEBUG && !CONFIG_DYNAMIC_DEBUG */
1160
1161 static void print_constraints(struct regulator_dev *rdev)
1162 {
1163         struct regulation_constraints *constraints = rdev->constraints;
1164
1165         print_constraints_debug(rdev);
1166
1167         if ((constraints->min_uV != constraints->max_uV) &&
1168             !regulator_ops_is_valid(rdev, REGULATOR_CHANGE_VOLTAGE))
1169                 rdev_warn(rdev,
1170                           "Voltage range but no REGULATOR_CHANGE_VOLTAGE\n");
1171 }
1172
1173 static int machine_constraints_voltage(struct regulator_dev *rdev,
1174         struct regulation_constraints *constraints)
1175 {
1176         const struct regulator_ops *ops = rdev->desc->ops;
1177         int ret;
1178
1179         /* do we need to apply the constraint voltage */
1180         if (rdev->constraints->apply_uV &&
1181             rdev->constraints->min_uV && rdev->constraints->max_uV) {
1182                 int target_min, target_max;
1183                 int current_uV = regulator_get_voltage_rdev(rdev);
1184
1185                 if (current_uV == -ENOTRECOVERABLE) {
1186                         /* This regulator can't be read and must be initialized */
1187                         rdev_info(rdev, "Setting %d-%duV\n",
1188                                   rdev->constraints->min_uV,
1189                                   rdev->constraints->max_uV);
1190                         _regulator_do_set_voltage(rdev,
1191                                                   rdev->constraints->min_uV,
1192                                                   rdev->constraints->max_uV);
1193                         current_uV = regulator_get_voltage_rdev(rdev);
1194                 }
1195
1196                 if (current_uV < 0) {
1197                         if (current_uV != -EPROBE_DEFER)
1198                                 rdev_err(rdev,
1199                                          "failed to get the current voltage: %pe\n",
1200                                          ERR_PTR(current_uV));
1201                         return current_uV;
1202                 }
1203
1204                 /*
1205                  * If we're below the minimum voltage move up to the
1206                  * minimum voltage, if we're above the maximum voltage
1207                  * then move down to the maximum.
1208                  */
1209                 target_min = current_uV;
1210                 target_max = current_uV;
1211
1212                 if (current_uV < rdev->constraints->min_uV) {
1213                         target_min = rdev->constraints->min_uV;
1214                         target_max = rdev->constraints->min_uV;
1215                 }
1216
1217                 if (current_uV > rdev->constraints->max_uV) {
1218                         target_min = rdev->constraints->max_uV;
1219                         target_max = rdev->constraints->max_uV;
1220                 }
1221
1222                 if (target_min != current_uV || target_max != current_uV) {
1223                         rdev_info(rdev, "Bringing %duV into %d-%duV\n",
1224                                   current_uV, target_min, target_max);
1225                         ret = _regulator_do_set_voltage(
1226                                 rdev, target_min, target_max);
1227                         if (ret < 0) {
1228                                 rdev_err(rdev,
1229                                         "failed to apply %d-%duV constraint: %pe\n",
1230                                         target_min, target_max, ERR_PTR(ret));
1231                                 return ret;
1232                         }
1233                 }
1234         }
1235
1236         /* constrain machine-level voltage specs to fit
1237          * the actual range supported by this regulator.
1238          */
1239         if (ops->list_voltage && rdev->desc->n_voltages) {
1240                 int     count = rdev->desc->n_voltages;
1241                 int     i;
1242                 int     min_uV = INT_MAX;
1243                 int     max_uV = INT_MIN;
1244                 int     cmin = constraints->min_uV;
1245                 int     cmax = constraints->max_uV;
1246
1247                 /* it's safe to autoconfigure fixed-voltage supplies
1248                  * and the constraints are used by list_voltage.
1249                  */
1250                 if (count == 1 && !cmin) {
1251                         cmin = 1;
1252                         cmax = INT_MAX;
1253                         constraints->min_uV = cmin;
1254                         constraints->max_uV = cmax;
1255                 }
1256
1257                 /* voltage constraints are optional */
1258                 if ((cmin == 0) && (cmax == 0))
1259                         return 0;
1260
1261                 /* else require explicit machine-level constraints */
1262                 if (cmin <= 0 || cmax <= 0 || cmax < cmin) {
1263                         rdev_err(rdev, "invalid voltage constraints\n");
1264                         return -EINVAL;
1265                 }
1266
1267                 /* no need to loop voltages if range is continuous */
1268                 if (rdev->desc->continuous_voltage_range)
1269                         return 0;
1270
1271                 /* initial: [cmin..cmax] valid, [min_uV..max_uV] not */
1272                 for (i = 0; i < count; i++) {
1273                         int     value;
1274
1275                         value = ops->list_voltage(rdev, i);
1276                         if (value <= 0)
1277                                 continue;
1278
1279                         /* maybe adjust [min_uV..max_uV] */
1280                         if (value >= cmin && value < min_uV)
1281                                 min_uV = value;
1282                         if (value <= cmax && value > max_uV)
1283                                 max_uV = value;
1284                 }
1285
1286                 /* final: [min_uV..max_uV] valid iff constraints valid */
1287                 if (max_uV < min_uV) {
1288                         rdev_err(rdev,
1289                                  "unsupportable voltage constraints %u-%uuV\n",
1290                                  min_uV, max_uV);
1291                         return -EINVAL;
1292                 }
1293
1294                 /* use regulator's subset of machine constraints */
1295                 if (constraints->min_uV < min_uV) {
1296                         rdev_dbg(rdev, "override min_uV, %d -> %d\n",
1297                                  constraints->min_uV, min_uV);
1298                         constraints->min_uV = min_uV;
1299                 }
1300                 if (constraints->max_uV > max_uV) {
1301                         rdev_dbg(rdev, "override max_uV, %d -> %d\n",
1302                                  constraints->max_uV, max_uV);
1303                         constraints->max_uV = max_uV;
1304                 }
1305         }
1306
1307         return 0;
1308 }
1309
1310 static int machine_constraints_current(struct regulator_dev *rdev,
1311         struct regulation_constraints *constraints)
1312 {
1313         const struct regulator_ops *ops = rdev->desc->ops;
1314         int ret;
1315
1316         if (!constraints->min_uA && !constraints->max_uA)
1317                 return 0;
1318
1319         if (constraints->min_uA > constraints->max_uA) {
1320                 rdev_err(rdev, "Invalid current constraints\n");
1321                 return -EINVAL;
1322         }
1323
1324         if (!ops->set_current_limit || !ops->get_current_limit) {
1325                 rdev_warn(rdev, "Operation of current configuration missing\n");
1326                 return 0;
1327         }
1328
1329         /* Set regulator current in constraints range */
1330         ret = ops->set_current_limit(rdev, constraints->min_uA,
1331                         constraints->max_uA);
1332         if (ret < 0) {
1333                 rdev_err(rdev, "Failed to set current constraint, %d\n", ret);
1334                 return ret;
1335         }
1336
1337         return 0;
1338 }
1339
1340 static int _regulator_do_enable(struct regulator_dev *rdev);
1341
1342 static int notif_set_limit(struct regulator_dev *rdev,
1343                            int (*set)(struct regulator_dev *, int, int, bool),
1344                            int limit, int severity)
1345 {
1346         bool enable;
1347
1348         if (limit == REGULATOR_NOTIF_LIMIT_DISABLE) {
1349                 enable = false;
1350                 limit = 0;
1351         } else {
1352                 enable = true;
1353         }
1354
1355         if (limit == REGULATOR_NOTIF_LIMIT_ENABLE)
1356                 limit = 0;
1357
1358         return set(rdev, limit, severity, enable);
1359 }
1360
1361 static int handle_notify_limits(struct regulator_dev *rdev,
1362                         int (*set)(struct regulator_dev *, int, int, bool),
1363                         struct notification_limit *limits)
1364 {
1365         int ret = 0;
1366
1367         if (!set)
1368                 return -EOPNOTSUPP;
1369
1370         if (limits->prot)
1371                 ret = notif_set_limit(rdev, set, limits->prot,
1372                                       REGULATOR_SEVERITY_PROT);
1373         if (ret)
1374                 return ret;
1375
1376         if (limits->err)
1377                 ret = notif_set_limit(rdev, set, limits->err,
1378                                       REGULATOR_SEVERITY_ERR);
1379         if (ret)
1380                 return ret;
1381
1382         if (limits->warn)
1383                 ret = notif_set_limit(rdev, set, limits->warn,
1384                                       REGULATOR_SEVERITY_WARN);
1385
1386         return ret;
1387 }
1388 /**
1389  * set_machine_constraints - sets regulator constraints
1390  * @rdev: regulator source
1391  *
1392  * Allows platform initialisation code to define and constrain
1393  * regulator circuits e.g. valid voltage/current ranges, etc.  NOTE:
1394  * Constraints *must* be set by platform code in order for some
1395  * regulator operations to proceed i.e. set_voltage, set_current_limit,
1396  * set_mode.
1397  */
1398 static int set_machine_constraints(struct regulator_dev *rdev)
1399 {
1400         int ret = 0;
1401         const struct regulator_ops *ops = rdev->desc->ops;
1402
1403         ret = machine_constraints_voltage(rdev, rdev->constraints);
1404         if (ret != 0)
1405                 return ret;
1406
1407         ret = machine_constraints_current(rdev, rdev->constraints);
1408         if (ret != 0)
1409                 return ret;
1410
1411         if (rdev->constraints->ilim_uA && ops->set_input_current_limit) {
1412                 ret = ops->set_input_current_limit(rdev,
1413                                                    rdev->constraints->ilim_uA);
1414                 if (ret < 0) {
1415                         rdev_err(rdev, "failed to set input limit: %pe\n", ERR_PTR(ret));
1416                         return ret;
1417                 }
1418         }
1419
1420         /* do we need to setup our suspend state */
1421         if (rdev->constraints->initial_state) {
1422                 ret = suspend_set_initial_state(rdev);
1423                 if (ret < 0) {
1424                         rdev_err(rdev, "failed to set suspend state: %pe\n", ERR_PTR(ret));
1425                         return ret;
1426                 }
1427         }
1428
1429         if (rdev->constraints->initial_mode) {
1430                 if (!ops->set_mode) {
1431                         rdev_err(rdev, "no set_mode operation\n");
1432                         return -EINVAL;
1433                 }
1434
1435                 ret = ops->set_mode(rdev, rdev->constraints->initial_mode);
1436                 if (ret < 0) {
1437                         rdev_err(rdev, "failed to set initial mode: %pe\n", ERR_PTR(ret));
1438                         return ret;
1439                 }
1440         } else if (rdev->constraints->system_load) {
1441                 /*
1442                  * We'll only apply the initial system load if an
1443                  * initial mode wasn't specified.
1444                  */
1445                 drms_uA_update(rdev);
1446         }
1447
1448         if ((rdev->constraints->ramp_delay || rdev->constraints->ramp_disable)
1449                 && ops->set_ramp_delay) {
1450                 ret = ops->set_ramp_delay(rdev, rdev->constraints->ramp_delay);
1451                 if (ret < 0) {
1452                         rdev_err(rdev, "failed to set ramp_delay: %pe\n", ERR_PTR(ret));
1453                         return ret;
1454                 }
1455         }
1456
1457         if (rdev->constraints->pull_down && ops->set_pull_down) {
1458                 ret = ops->set_pull_down(rdev);
1459                 if (ret < 0) {
1460                         rdev_err(rdev, "failed to set pull down: %pe\n", ERR_PTR(ret));
1461                         return ret;
1462                 }
1463         }
1464
1465         if (rdev->constraints->soft_start && ops->set_soft_start) {
1466                 ret = ops->set_soft_start(rdev);
1467                 if (ret < 0) {
1468                         rdev_err(rdev, "failed to set soft start: %pe\n", ERR_PTR(ret));
1469                         return ret;
1470                 }
1471         }
1472
1473         /*
1474          * Existing logic does not warn if over_current_protection is given as
1475          * a constraint but driver does not support that. I think we should
1476          * warn about this type of issues as it is possible someone changes
1477          * PMIC on board to another type - and the another PMIC's driver does
1478          * not support setting protection. Board composer may happily believe
1479          * the DT limits are respected - especially if the new PMIC HW also
1480          * supports protection but the driver does not. I won't change the logic
1481          * without hearing more experienced opinion on this though.
1482          *
1483          * If warning is seen as a good idea then we can merge handling the
1484          * over-curret protection and detection and get rid of this special
1485          * handling.
1486          */
1487         if (rdev->constraints->over_current_protection
1488                 && ops->set_over_current_protection) {
1489                 int lim = rdev->constraints->over_curr_limits.prot;
1490
1491                 ret = ops->set_over_current_protection(rdev, lim,
1492                                                        REGULATOR_SEVERITY_PROT,
1493                                                        true);
1494                 if (ret < 0) {
1495                         rdev_err(rdev, "failed to set over current protection: %pe\n",
1496                                  ERR_PTR(ret));
1497                         return ret;
1498                 }
1499         }
1500
1501         if (rdev->constraints->over_current_detection)
1502                 ret = handle_notify_limits(rdev,
1503                                            ops->set_over_current_protection,
1504                                            &rdev->constraints->over_curr_limits);
1505         if (ret) {
1506                 if (ret != -EOPNOTSUPP) {
1507                         rdev_err(rdev, "failed to set over current limits: %pe\n",
1508                                  ERR_PTR(ret));
1509                         return ret;
1510                 }
1511                 rdev_warn(rdev,
1512                           "IC does not support requested over-current limits\n");
1513         }
1514
1515         if (rdev->constraints->over_voltage_detection)
1516                 ret = handle_notify_limits(rdev,
1517                                            ops->set_over_voltage_protection,
1518                                            &rdev->constraints->over_voltage_limits);
1519         if (ret) {
1520                 if (ret != -EOPNOTSUPP) {
1521                         rdev_err(rdev, "failed to set over voltage limits %pe\n",
1522                                  ERR_PTR(ret));
1523                         return ret;
1524                 }
1525                 rdev_warn(rdev,
1526                           "IC does not support requested over voltage limits\n");
1527         }
1528
1529         if (rdev->constraints->under_voltage_detection)
1530                 ret = handle_notify_limits(rdev,
1531                                            ops->set_under_voltage_protection,
1532                                            &rdev->constraints->under_voltage_limits);
1533         if (ret) {
1534                 if (ret != -EOPNOTSUPP) {
1535                         rdev_err(rdev, "failed to set under voltage limits %pe\n",
1536                                  ERR_PTR(ret));
1537                         return ret;
1538                 }
1539                 rdev_warn(rdev,
1540                           "IC does not support requested under voltage limits\n");
1541         }
1542
1543         if (rdev->constraints->over_temp_detection)
1544                 ret = handle_notify_limits(rdev,
1545                                            ops->set_thermal_protection,
1546                                            &rdev->constraints->temp_limits);
1547         if (ret) {
1548                 if (ret != -EOPNOTSUPP) {
1549                         rdev_err(rdev, "failed to set temperature limits %pe\n",
1550                                  ERR_PTR(ret));
1551                         return ret;
1552                 }
1553                 rdev_warn(rdev,
1554                           "IC does not support requested temperature limits\n");
1555         }
1556
1557         if (rdev->constraints->active_discharge && ops->set_active_discharge) {
1558                 bool ad_state = (rdev->constraints->active_discharge ==
1559                               REGULATOR_ACTIVE_DISCHARGE_ENABLE) ? true : false;
1560
1561                 ret = ops->set_active_discharge(rdev, ad_state);
1562                 if (ret < 0) {
1563                         rdev_err(rdev, "failed to set active discharge: %pe\n", ERR_PTR(ret));
1564                         return ret;
1565                 }
1566         }
1567
1568         /*
1569          * If there is no mechanism for controlling the regulator then
1570          * flag it as always_on so we don't end up duplicating checks
1571          * for this so much.  Note that we could control the state of
1572          * a supply to control the output on a regulator that has no
1573          * direct control.
1574          */
1575         if (!rdev->ena_pin && !ops->enable) {
1576                 if (rdev->supply_name && !rdev->supply)
1577                         return -EPROBE_DEFER;
1578
1579                 if (rdev->supply)
1580                         rdev->constraints->always_on =
1581                                 rdev->supply->rdev->constraints->always_on;
1582                 else
1583                         rdev->constraints->always_on = true;
1584         }
1585
1586         if (rdev->desc->off_on_delay)
1587                 rdev->last_off = ktime_get();
1588
1589         /* If the constraints say the regulator should be on at this point
1590          * and we have control then make sure it is enabled.
1591          */
1592         if (rdev->constraints->always_on || rdev->constraints->boot_on) {
1593                 /* If we want to enable this regulator, make sure that we know
1594                  * the supplying regulator.
1595                  */
1596                 if (rdev->supply_name && !rdev->supply)
1597                         return -EPROBE_DEFER;
1598
1599                 /* If supplying regulator has already been enabled,
1600                  * it's not intended to have use_count increment
1601                  * when rdev is only boot-on.
1602                  */
1603                 if (rdev->supply &&
1604                     (rdev->constraints->always_on ||
1605                      !regulator_is_enabled(rdev->supply))) {
1606                         ret = regulator_enable(rdev->supply);
1607                         if (ret < 0) {
1608                                 _regulator_put(rdev->supply);
1609                                 rdev->supply = NULL;
1610                                 return ret;
1611                         }
1612                 }
1613
1614                 ret = _regulator_do_enable(rdev);
1615                 if (ret < 0 && ret != -EINVAL) {
1616                         rdev_err(rdev, "failed to enable: %pe\n", ERR_PTR(ret));
1617                         return ret;
1618                 }
1619
1620                 if (rdev->constraints->always_on)
1621                         rdev->use_count++;
1622         }
1623
1624         print_constraints(rdev);
1625         return 0;
1626 }
1627
1628 /**
1629  * set_supply - set regulator supply regulator
1630  * @rdev: regulator name
1631  * @supply_rdev: supply regulator name
1632  *
1633  * Called by platform initialisation code to set the supply regulator for this
1634  * regulator. This ensures that a regulators supply will also be enabled by the
1635  * core if it's child is enabled.
1636  */
1637 static int set_supply(struct regulator_dev *rdev,
1638                       struct regulator_dev *supply_rdev)
1639 {
1640         int err;
1641
1642         rdev_dbg(rdev, "supplied by %s\n", rdev_get_name(supply_rdev));
1643
1644         if (!try_module_get(supply_rdev->owner))
1645                 return -ENODEV;
1646
1647         rdev->supply = create_regulator(supply_rdev, &rdev->dev, "SUPPLY");
1648         if (rdev->supply == NULL) {
1649                 module_put(supply_rdev->owner);
1650                 err = -ENOMEM;
1651                 return err;
1652         }
1653         supply_rdev->open_count++;
1654
1655         return 0;
1656 }
1657
1658 /**
1659  * set_consumer_device_supply - Bind a regulator to a symbolic supply
1660  * @rdev:         regulator source
1661  * @consumer_dev_name: dev_name() string for device supply applies to
1662  * @supply:       symbolic name for supply
1663  *
1664  * Allows platform initialisation code to map physical regulator
1665  * sources to symbolic names for supplies for use by devices.  Devices
1666  * should use these symbolic names to request regulators, avoiding the
1667  * need to provide board-specific regulator names as platform data.
1668  */
1669 static int set_consumer_device_supply(struct regulator_dev *rdev,
1670                                       const char *consumer_dev_name,
1671                                       const char *supply)
1672 {
1673         struct regulator_map *node, *new_node;
1674         int has_dev;
1675
1676         if (supply == NULL)
1677                 return -EINVAL;
1678
1679         if (consumer_dev_name != NULL)
1680                 has_dev = 1;
1681         else
1682                 has_dev = 0;
1683
1684         new_node = kzalloc(sizeof(struct regulator_map), GFP_KERNEL);
1685         if (new_node == NULL)
1686                 return -ENOMEM;
1687
1688         new_node->regulator = rdev;
1689         new_node->supply = supply;
1690
1691         if (has_dev) {
1692                 new_node->dev_name = kstrdup(consumer_dev_name, GFP_KERNEL);
1693                 if (new_node->dev_name == NULL) {
1694                         kfree(new_node);
1695                         return -ENOMEM;
1696                 }
1697         }
1698
1699         mutex_lock(&regulator_list_mutex);
1700         list_for_each_entry(node, &regulator_map_list, list) {
1701                 if (node->dev_name && consumer_dev_name) {
1702                         if (strcmp(node->dev_name, consumer_dev_name) != 0)
1703                                 continue;
1704                 } else if (node->dev_name || consumer_dev_name) {
1705                         continue;
1706                 }
1707
1708                 if (strcmp(node->supply, supply) != 0)
1709                         continue;
1710
1711                 pr_debug("%s: %s/%s is '%s' supply; fail %s/%s\n",
1712                          consumer_dev_name,
1713                          dev_name(&node->regulator->dev),
1714                          node->regulator->desc->name,
1715                          supply,
1716                          dev_name(&rdev->dev), rdev_get_name(rdev));
1717                 goto fail;
1718         }
1719
1720         list_add(&new_node->list, &regulator_map_list);
1721         mutex_unlock(&regulator_list_mutex);
1722
1723         return 0;
1724
1725 fail:
1726         mutex_unlock(&regulator_list_mutex);
1727         kfree(new_node->dev_name);
1728         kfree(new_node);
1729         return -EBUSY;
1730 }
1731
1732 static void unset_regulator_supplies(struct regulator_dev *rdev)
1733 {
1734         struct regulator_map *node, *n;
1735
1736         list_for_each_entry_safe(node, n, &regulator_map_list, list) {
1737                 if (rdev == node->regulator) {
1738                         list_del(&node->list);
1739                         kfree(node->dev_name);
1740                         kfree(node);
1741                 }
1742         }
1743 }
1744
1745 #ifdef CONFIG_DEBUG_FS
1746 static ssize_t constraint_flags_read_file(struct file *file,
1747                                           char __user *user_buf,
1748                                           size_t count, loff_t *ppos)
1749 {
1750         const struct regulator *regulator = file->private_data;
1751         const struct regulation_constraints *c = regulator->rdev->constraints;
1752         char *buf;
1753         ssize_t ret;
1754
1755         if (!c)
1756                 return 0;
1757
1758         buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
1759         if (!buf)
1760                 return -ENOMEM;
1761
1762         ret = snprintf(buf, PAGE_SIZE,
1763                         "always_on: %u\n"
1764                         "boot_on: %u\n"
1765                         "apply_uV: %u\n"
1766                         "ramp_disable: %u\n"
1767                         "soft_start: %u\n"
1768                         "pull_down: %u\n"
1769                         "over_current_protection: %u\n",
1770                         c->always_on,
1771                         c->boot_on,
1772                         c->apply_uV,
1773                         c->ramp_disable,
1774                         c->soft_start,
1775                         c->pull_down,
1776                         c->over_current_protection);
1777
1778         ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
1779         kfree(buf);
1780
1781         return ret;
1782 }
1783
1784 #endif
1785
1786 static const struct file_operations constraint_flags_fops = {
1787 #ifdef CONFIG_DEBUG_FS
1788         .open = simple_open,
1789         .read = constraint_flags_read_file,
1790         .llseek = default_llseek,
1791 #endif
1792 };
1793
1794 #define REG_STR_SIZE    64
1795
1796 static struct regulator *create_regulator(struct regulator_dev *rdev,
1797                                           struct device *dev,
1798                                           const char *supply_name)
1799 {
1800         struct regulator *regulator;
1801         int err = 0;
1802
1803         if (dev) {
1804                 char buf[REG_STR_SIZE];
1805                 int size;
1806
1807                 size = snprintf(buf, REG_STR_SIZE, "%s-%s",
1808                                 dev->kobj.name, supply_name);
1809                 if (size >= REG_STR_SIZE)
1810                         return NULL;
1811
1812                 supply_name = kstrdup(buf, GFP_KERNEL);
1813                 if (supply_name == NULL)
1814                         return NULL;
1815         } else {
1816                 supply_name = kstrdup_const(supply_name, GFP_KERNEL);
1817                 if (supply_name == NULL)
1818                         return NULL;
1819         }
1820
1821         regulator = kzalloc(sizeof(*regulator), GFP_KERNEL);
1822         if (regulator == NULL) {
1823                 kfree_const(supply_name);
1824                 return NULL;
1825         }
1826
1827         regulator->rdev = rdev;
1828         regulator->supply_name = supply_name;
1829
1830         regulator_lock(rdev);
1831         list_add(&regulator->list, &rdev->consumer_list);
1832         regulator_unlock(rdev);
1833
1834         if (dev) {
1835                 regulator->dev = dev;
1836
1837                 /* Add a link to the device sysfs entry */
1838                 err = sysfs_create_link_nowarn(&rdev->dev.kobj, &dev->kobj,
1839                                                supply_name);
1840                 if (err) {
1841                         rdev_dbg(rdev, "could not add device link %s: %pe\n",
1842                                   dev->kobj.name, ERR_PTR(err));
1843                         /* non-fatal */
1844                 }
1845         }
1846
1847         if (err != -EEXIST)
1848                 regulator->debugfs = debugfs_create_dir(supply_name, rdev->debugfs);
1849         if (!regulator->debugfs) {
1850                 rdev_dbg(rdev, "Failed to create debugfs directory\n");
1851         } else {
1852                 debugfs_create_u32("uA_load", 0444, regulator->debugfs,
1853                                    &regulator->uA_load);
1854                 debugfs_create_u32("min_uV", 0444, regulator->debugfs,
1855                                    &regulator->voltage[PM_SUSPEND_ON].min_uV);
1856                 debugfs_create_u32("max_uV", 0444, regulator->debugfs,
1857                                    &regulator->voltage[PM_SUSPEND_ON].max_uV);
1858                 debugfs_create_file("constraint_flags", 0444,
1859                                     regulator->debugfs, regulator,
1860                                     &constraint_flags_fops);
1861         }
1862
1863         /*
1864          * Check now if the regulator is an always on regulator - if
1865          * it is then we don't need to do nearly so much work for
1866          * enable/disable calls.
1867          */
1868         if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_STATUS) &&
1869             _regulator_is_enabled(rdev))
1870                 regulator->always_on = true;
1871
1872         return regulator;
1873 }
1874
1875 static int _regulator_get_enable_time(struct regulator_dev *rdev)
1876 {
1877         if (rdev->constraints && rdev->constraints->enable_time)
1878                 return rdev->constraints->enable_time;
1879         if (rdev->desc->ops->enable_time)
1880                 return rdev->desc->ops->enable_time(rdev);
1881         return rdev->desc->enable_time;
1882 }
1883
1884 static struct regulator_supply_alias *regulator_find_supply_alias(
1885                 struct device *dev, const char *supply)
1886 {
1887         struct regulator_supply_alias *map;
1888
1889         list_for_each_entry(map, &regulator_supply_alias_list, list)
1890                 if (map->src_dev == dev && strcmp(map->src_supply, supply) == 0)
1891                         return map;
1892
1893         return NULL;
1894 }
1895
1896 static void regulator_supply_alias(struct device **dev, const char **supply)
1897 {
1898         struct regulator_supply_alias *map;
1899
1900         map = regulator_find_supply_alias(*dev, *supply);
1901         if (map) {
1902                 dev_dbg(*dev, "Mapping supply %s to %s,%s\n",
1903                                 *supply, map->alias_supply,
1904                                 dev_name(map->alias_dev));
1905                 *dev = map->alias_dev;
1906                 *supply = map->alias_supply;
1907         }
1908 }
1909
1910 static int regulator_match(struct device *dev, const void *data)
1911 {
1912         struct regulator_dev *r = dev_to_rdev(dev);
1913
1914         return strcmp(rdev_get_name(r), data) == 0;
1915 }
1916
1917 static struct regulator_dev *regulator_lookup_by_name(const char *name)
1918 {
1919         struct device *dev;
1920
1921         dev = class_find_device(&regulator_class, NULL, name, regulator_match);
1922
1923         return dev ? dev_to_rdev(dev) : NULL;
1924 }
1925
1926 /**
1927  * regulator_dev_lookup - lookup a regulator device.
1928  * @dev: device for regulator "consumer".
1929  * @supply: Supply name or regulator ID.
1930  *
1931  * If successful, returns a struct regulator_dev that corresponds to the name
1932  * @supply and with the embedded struct device refcount incremented by one.
1933  * The refcount must be dropped by calling put_device().
1934  * On failure one of the following ERR-PTR-encoded values is returned:
1935  * -ENODEV if lookup fails permanently, -EPROBE_DEFER if lookup could succeed
1936  * in the future.
1937  */
1938 static struct regulator_dev *regulator_dev_lookup(struct device *dev,
1939                                                   const char *supply)
1940 {
1941         struct regulator_dev *r = NULL;
1942         struct device_node *node;
1943         struct regulator_map *map;
1944         const char *devname = NULL;
1945
1946         regulator_supply_alias(&dev, &supply);
1947
1948         /* first do a dt based lookup */
1949         if (dev && dev->of_node) {
1950                 node = of_get_regulator(dev, supply);
1951                 if (node) {
1952                         r = of_find_regulator_by_node(node);
1953                         of_node_put(node);
1954                         if (r)
1955                                 return r;
1956
1957                         /*
1958                          * We have a node, but there is no device.
1959                          * assume it has not registered yet.
1960                          */
1961                         return ERR_PTR(-EPROBE_DEFER);
1962                 }
1963         }
1964
1965         /* if not found, try doing it non-dt way */
1966         if (dev)
1967                 devname = dev_name(dev);
1968
1969         mutex_lock(&regulator_list_mutex);
1970         list_for_each_entry(map, &regulator_map_list, list) {
1971                 /* If the mapping has a device set up it must match */
1972                 if (map->dev_name &&
1973                     (!devname || strcmp(map->dev_name, devname)))
1974                         continue;
1975
1976                 if (strcmp(map->supply, supply) == 0 &&
1977                     get_device(&map->regulator->dev)) {
1978                         r = map->regulator;
1979                         break;
1980                 }
1981         }
1982         mutex_unlock(&regulator_list_mutex);
1983
1984         if (r)
1985                 return r;
1986
1987         r = regulator_lookup_by_name(supply);
1988         if (r)
1989                 return r;
1990
1991         return ERR_PTR(-ENODEV);
1992 }
1993
1994 static int regulator_resolve_supply(struct regulator_dev *rdev)
1995 {
1996         struct regulator_dev *r;
1997         struct device *dev = rdev->dev.parent;
1998         int ret = 0;
1999
2000         /* No supply to resolve? */
2001         if (!rdev->supply_name)
2002                 return 0;
2003
2004         /* Supply already resolved? (fast-path without locking contention) */
2005         if (rdev->supply)
2006                 return 0;
2007
2008         r = regulator_dev_lookup(dev, rdev->supply_name);
2009         if (IS_ERR(r)) {
2010                 ret = PTR_ERR(r);
2011
2012                 /* Did the lookup explicitly defer for us? */
2013                 if (ret == -EPROBE_DEFER)
2014                         goto out;
2015
2016                 if (have_full_constraints()) {
2017                         r = dummy_regulator_rdev;
2018                         get_device(&r->dev);
2019                 } else {
2020                         dev_err(dev, "Failed to resolve %s-supply for %s\n",
2021                                 rdev->supply_name, rdev->desc->name);
2022                         ret = -EPROBE_DEFER;
2023                         goto out;
2024                 }
2025         }
2026
2027         if (r == rdev) {
2028                 dev_err(dev, "Supply for %s (%s) resolved to itself\n",
2029                         rdev->desc->name, rdev->supply_name);
2030                 if (!have_full_constraints()) {
2031                         ret = -EINVAL;
2032                         goto out;
2033                 }
2034                 r = dummy_regulator_rdev;
2035                 get_device(&r->dev);
2036         }
2037
2038         /*
2039          * If the supply's parent device is not the same as the
2040          * regulator's parent device, then ensure the parent device
2041          * is bound before we resolve the supply, in case the parent
2042          * device get probe deferred and unregisters the supply.
2043          */
2044         if (r->dev.parent && r->dev.parent != rdev->dev.parent) {
2045                 if (!device_is_bound(r->dev.parent)) {
2046                         put_device(&r->dev);
2047                         ret = -EPROBE_DEFER;
2048                         goto out;
2049                 }
2050         }
2051
2052         /* Recursively resolve the supply of the supply */
2053         ret = regulator_resolve_supply(r);
2054         if (ret < 0) {
2055                 put_device(&r->dev);
2056                 goto out;
2057         }
2058
2059         /*
2060          * Recheck rdev->supply with rdev->mutex lock held to avoid a race
2061          * between rdev->supply null check and setting rdev->supply in
2062          * set_supply() from concurrent tasks.
2063          */
2064         regulator_lock(rdev);
2065
2066         /* Supply just resolved by a concurrent task? */
2067         if (rdev->supply) {
2068                 regulator_unlock(rdev);
2069                 put_device(&r->dev);
2070                 goto out;
2071         }
2072
2073         ret = set_supply(rdev, r);
2074         if (ret < 0) {
2075                 regulator_unlock(rdev);
2076                 put_device(&r->dev);
2077                 goto out;
2078         }
2079
2080         regulator_unlock(rdev);
2081
2082         /*
2083          * In set_machine_constraints() we may have turned this regulator on
2084          * but we couldn't propagate to the supply if it hadn't been resolved
2085          * yet.  Do it now.
2086          */
2087         if (rdev->use_count) {
2088                 ret = regulator_enable(rdev->supply);
2089                 if (ret < 0) {
2090                         _regulator_put(rdev->supply);
2091                         rdev->supply = NULL;
2092                         goto out;
2093                 }
2094         }
2095
2096 out:
2097         return ret;
2098 }
2099
2100 /* Internal regulator request function */
2101 struct regulator *_regulator_get(struct device *dev, const char *id,
2102                                  enum regulator_get_type get_type)
2103 {
2104         struct regulator_dev *rdev;
2105         struct regulator *regulator;
2106         struct device_link *link;
2107         int ret;
2108
2109         if (get_type >= MAX_GET_TYPE) {
2110                 dev_err(dev, "invalid type %d in %s\n", get_type, __func__);
2111                 return ERR_PTR(-EINVAL);
2112         }
2113
2114         if (id == NULL) {
2115                 pr_err("get() with no identifier\n");
2116                 return ERR_PTR(-EINVAL);
2117         }
2118
2119         rdev = regulator_dev_lookup(dev, id);
2120         if (IS_ERR(rdev)) {
2121                 ret = PTR_ERR(rdev);
2122
2123                 /*
2124                  * If regulator_dev_lookup() fails with error other
2125                  * than -ENODEV our job here is done, we simply return it.
2126                  */
2127                 if (ret != -ENODEV)
2128                         return ERR_PTR(ret);
2129
2130                 if (!have_full_constraints()) {
2131                         dev_warn(dev,
2132                                  "incomplete constraints, dummy supplies not allowed\n");
2133                         return ERR_PTR(-ENODEV);
2134                 }
2135
2136                 switch (get_type) {
2137                 case NORMAL_GET:
2138                         /*
2139                          * Assume that a regulator is physically present and
2140                          * enabled, even if it isn't hooked up, and just
2141                          * provide a dummy.
2142                          */
2143                         dev_warn(dev, "supply %s not found, using dummy regulator\n", id);
2144                         rdev = dummy_regulator_rdev;
2145                         get_device(&rdev->dev);
2146                         break;
2147
2148                 case EXCLUSIVE_GET:
2149                         dev_warn(dev,
2150                                  "dummy supplies not allowed for exclusive requests\n");
2151                         fallthrough;
2152
2153                 default:
2154                         return ERR_PTR(-ENODEV);
2155                 }
2156         }
2157
2158         if (rdev->exclusive) {
2159                 regulator = ERR_PTR(-EPERM);
2160                 put_device(&rdev->dev);
2161                 return regulator;
2162         }
2163
2164         if (get_type == EXCLUSIVE_GET && rdev->open_count) {
2165                 regulator = ERR_PTR(-EBUSY);
2166                 put_device(&rdev->dev);
2167                 return regulator;
2168         }
2169
2170         mutex_lock(&regulator_list_mutex);
2171         ret = (rdev->coupling_desc.n_resolved != rdev->coupling_desc.n_coupled);
2172         mutex_unlock(&regulator_list_mutex);
2173
2174         if (ret != 0) {
2175                 regulator = ERR_PTR(-EPROBE_DEFER);
2176                 put_device(&rdev->dev);
2177                 return regulator;
2178         }
2179
2180         ret = regulator_resolve_supply(rdev);
2181         if (ret < 0) {
2182                 regulator = ERR_PTR(ret);
2183                 put_device(&rdev->dev);
2184                 return regulator;
2185         }
2186
2187         if (!try_module_get(rdev->owner)) {
2188                 regulator = ERR_PTR(-EPROBE_DEFER);
2189                 put_device(&rdev->dev);
2190                 return regulator;
2191         }
2192
2193         regulator = create_regulator(rdev, dev, id);
2194         if (regulator == NULL) {
2195                 regulator = ERR_PTR(-ENOMEM);
2196                 module_put(rdev->owner);
2197                 put_device(&rdev->dev);
2198                 return regulator;
2199         }
2200
2201         rdev->open_count++;
2202         if (get_type == EXCLUSIVE_GET) {
2203                 rdev->exclusive = 1;
2204
2205                 ret = _regulator_is_enabled(rdev);
2206                 if (ret > 0) {
2207                         rdev->use_count = 1;
2208                         regulator->enable_count = 1;
2209                 } else {
2210                         rdev->use_count = 0;
2211                         regulator->enable_count = 0;
2212                 }
2213         }
2214
2215         link = device_link_add(dev, &rdev->dev, DL_FLAG_STATELESS);
2216         if (!IS_ERR_OR_NULL(link))
2217                 regulator->device_link = true;
2218
2219         return regulator;
2220 }
2221
2222 /**
2223  * regulator_get - lookup and obtain a reference to a regulator.
2224  * @dev: device for regulator "consumer"
2225  * @id: Supply name or regulator ID.
2226  *
2227  * Returns a struct regulator corresponding to the regulator producer,
2228  * or IS_ERR() condition containing errno.
2229  *
2230  * Use of supply names configured via set_consumer_device_supply() is
2231  * strongly encouraged.  It is recommended that the supply name used
2232  * should match the name used for the supply and/or the relevant
2233  * device pins in the datasheet.
2234  */
2235 struct regulator *regulator_get(struct device *dev, const char *id)
2236 {
2237         return _regulator_get(dev, id, NORMAL_GET);
2238 }
2239 EXPORT_SYMBOL_GPL(regulator_get);
2240
2241 /**
2242  * regulator_get_exclusive - obtain exclusive access to a regulator.
2243  * @dev: device for regulator "consumer"
2244  * @id: Supply name or regulator ID.
2245  *
2246  * Returns a struct regulator corresponding to the regulator producer,
2247  * or IS_ERR() condition containing errno.  Other consumers will be
2248  * unable to obtain this regulator while this reference is held and the
2249  * use count for the regulator will be initialised to reflect the current
2250  * state of the regulator.
2251  *
2252  * This is intended for use by consumers which cannot tolerate shared
2253  * use of the regulator such as those which need to force the
2254  * regulator off for correct operation of the hardware they are
2255  * controlling.
2256  *
2257  * Use of supply names configured via set_consumer_device_supply() is
2258  * strongly encouraged.  It is recommended that the supply name used
2259  * should match the name used for the supply and/or the relevant
2260  * device pins in the datasheet.
2261  */
2262 struct regulator *regulator_get_exclusive(struct device *dev, const char *id)
2263 {
2264         return _regulator_get(dev, id, EXCLUSIVE_GET);
2265 }
2266 EXPORT_SYMBOL_GPL(regulator_get_exclusive);
2267
2268 /**
2269  * regulator_get_optional - obtain optional access to a regulator.
2270  * @dev: device for regulator "consumer"
2271  * @id: Supply name or regulator ID.
2272  *
2273  * Returns a struct regulator corresponding to the regulator producer,
2274  * or IS_ERR() condition containing errno.
2275  *
2276  * This is intended for use by consumers for devices which can have
2277  * some supplies unconnected in normal use, such as some MMC devices.
2278  * It can allow the regulator core to provide stub supplies for other
2279  * supplies requested using normal regulator_get() calls without
2280  * disrupting the operation of drivers that can handle absent
2281  * supplies.
2282  *
2283  * Use of supply names configured via set_consumer_device_supply() is
2284  * strongly encouraged.  It is recommended that the supply name used
2285  * should match the name used for the supply and/or the relevant
2286  * device pins in the datasheet.
2287  */
2288 struct regulator *regulator_get_optional(struct device *dev, const char *id)
2289 {
2290         return _regulator_get(dev, id, OPTIONAL_GET);
2291 }
2292 EXPORT_SYMBOL_GPL(regulator_get_optional);
2293
2294 static void destroy_regulator(struct regulator *regulator)
2295 {
2296         struct regulator_dev *rdev = regulator->rdev;
2297
2298         debugfs_remove_recursive(regulator->debugfs);
2299
2300         if (regulator->dev) {
2301                 if (regulator->device_link)
2302                         device_link_remove(regulator->dev, &rdev->dev);
2303
2304                 /* remove any sysfs entries */
2305                 sysfs_remove_link(&rdev->dev.kobj, regulator->supply_name);
2306         }
2307
2308         regulator_lock(rdev);
2309         list_del(&regulator->list);
2310
2311         rdev->open_count--;
2312         rdev->exclusive = 0;
2313         regulator_unlock(rdev);
2314
2315         kfree_const(regulator->supply_name);
2316         kfree(regulator);
2317 }
2318
2319 /* regulator_list_mutex lock held by regulator_put() */
2320 static void _regulator_put(struct regulator *regulator)
2321 {
2322         struct regulator_dev *rdev;
2323
2324         if (IS_ERR_OR_NULL(regulator))
2325                 return;
2326
2327         lockdep_assert_held_once(&regulator_list_mutex);
2328
2329         /* Docs say you must disable before calling regulator_put() */
2330         WARN_ON(regulator->enable_count);
2331
2332         rdev = regulator->rdev;
2333
2334         destroy_regulator(regulator);
2335
2336         module_put(rdev->owner);
2337         put_device(&rdev->dev);
2338 }
2339
2340 /**
2341  * regulator_put - "free" the regulator source
2342  * @regulator: regulator source
2343  *
2344  * Note: drivers must ensure that all regulator_enable calls made on this
2345  * regulator source are balanced by regulator_disable calls prior to calling
2346  * this function.
2347  */
2348 void regulator_put(struct regulator *regulator)
2349 {
2350         mutex_lock(&regulator_list_mutex);
2351         _regulator_put(regulator);
2352         mutex_unlock(&regulator_list_mutex);
2353 }
2354 EXPORT_SYMBOL_GPL(regulator_put);
2355
2356 /**
2357  * regulator_register_supply_alias - Provide device alias for supply lookup
2358  *
2359  * @dev: device that will be given as the regulator "consumer"
2360  * @id: Supply name or regulator ID
2361  * @alias_dev: device that should be used to lookup the supply
2362  * @alias_id: Supply name or regulator ID that should be used to lookup the
2363  * supply
2364  *
2365  * All lookups for id on dev will instead be conducted for alias_id on
2366  * alias_dev.
2367  */
2368 int regulator_register_supply_alias(struct device *dev, const char *id,
2369                                     struct device *alias_dev,
2370                                     const char *alias_id)
2371 {
2372         struct regulator_supply_alias *map;
2373
2374         map = regulator_find_supply_alias(dev, id);
2375         if (map)
2376                 return -EEXIST;
2377
2378         map = kzalloc(sizeof(struct regulator_supply_alias), GFP_KERNEL);
2379         if (!map)
2380                 return -ENOMEM;
2381
2382         map->src_dev = dev;
2383         map->src_supply = id;
2384         map->alias_dev = alias_dev;
2385         map->alias_supply = alias_id;
2386
2387         list_add(&map->list, &regulator_supply_alias_list);
2388
2389         pr_info("Adding alias for supply %s,%s -> %s,%s\n",
2390                 id, dev_name(dev), alias_id, dev_name(alias_dev));
2391
2392         return 0;
2393 }
2394 EXPORT_SYMBOL_GPL(regulator_register_supply_alias);
2395
2396 /**
2397  * regulator_unregister_supply_alias - Remove device alias
2398  *
2399  * @dev: device that will be given as the regulator "consumer"
2400  * @id: Supply name or regulator ID
2401  *
2402  * Remove a lookup alias if one exists for id on dev.
2403  */
2404 void regulator_unregister_supply_alias(struct device *dev, const char *id)
2405 {
2406         struct regulator_supply_alias *map;
2407
2408         map = regulator_find_supply_alias(dev, id);
2409         if (map) {
2410                 list_del(&map->list);
2411                 kfree(map);
2412         }
2413 }
2414 EXPORT_SYMBOL_GPL(regulator_unregister_supply_alias);
2415
2416 /**
2417  * regulator_bulk_register_supply_alias - register multiple aliases
2418  *
2419  * @dev: device that will be given as the regulator "consumer"
2420  * @id: List of supply names or regulator IDs
2421  * @alias_dev: device that should be used to lookup the supply
2422  * @alias_id: List of supply names or regulator IDs that should be used to
2423  * lookup the supply
2424  * @num_id: Number of aliases to register
2425  *
2426  * @return 0 on success, an errno on failure.
2427  *
2428  * This helper function allows drivers to register several supply
2429  * aliases in one operation.  If any of the aliases cannot be
2430  * registered any aliases that were registered will be removed
2431  * before returning to the caller.
2432  */
2433 int regulator_bulk_register_supply_alias(struct device *dev,
2434                                          const char *const *id,
2435                                          struct device *alias_dev,
2436                                          const char *const *alias_id,
2437                                          int num_id)
2438 {
2439         int i;
2440         int ret;
2441
2442         for (i = 0; i < num_id; ++i) {
2443                 ret = regulator_register_supply_alias(dev, id[i], alias_dev,
2444                                                       alias_id[i]);
2445                 if (ret < 0)
2446                         goto err;
2447         }
2448
2449         return 0;
2450
2451 err:
2452         dev_err(dev,
2453                 "Failed to create supply alias %s,%s -> %s,%s\n",
2454                 id[i], dev_name(dev), alias_id[i], dev_name(alias_dev));
2455
2456         while (--i >= 0)
2457                 regulator_unregister_supply_alias(dev, id[i]);
2458
2459         return ret;
2460 }
2461 EXPORT_SYMBOL_GPL(regulator_bulk_register_supply_alias);
2462
2463 /**
2464  * regulator_bulk_unregister_supply_alias - unregister multiple aliases
2465  *
2466  * @dev: device that will be given as the regulator "consumer"
2467  * @id: List of supply names or regulator IDs
2468  * @num_id: Number of aliases to unregister
2469  *
2470  * This helper function allows drivers to unregister several supply
2471  * aliases in one operation.
2472  */
2473 void regulator_bulk_unregister_supply_alias(struct device *dev,
2474                                             const char *const *id,
2475                                             int num_id)
2476 {
2477         int i;
2478
2479         for (i = 0; i < num_id; ++i)
2480                 regulator_unregister_supply_alias(dev, id[i]);
2481 }
2482 EXPORT_SYMBOL_GPL(regulator_bulk_unregister_supply_alias);
2483
2484
2485 /* Manage enable GPIO list. Same GPIO pin can be shared among regulators */
2486 static int regulator_ena_gpio_request(struct regulator_dev *rdev,
2487                                 const struct regulator_config *config)
2488 {
2489         struct regulator_enable_gpio *pin, *new_pin;
2490         struct gpio_desc *gpiod;
2491
2492         gpiod = config->ena_gpiod;
2493         new_pin = kzalloc(sizeof(*new_pin), GFP_KERNEL);
2494
2495         mutex_lock(&regulator_list_mutex);
2496
2497         list_for_each_entry(pin, &regulator_ena_gpio_list, list) {
2498                 if (pin->gpiod == gpiod) {
2499                         rdev_dbg(rdev, "GPIO is already used\n");
2500                         goto update_ena_gpio_to_rdev;
2501                 }
2502         }
2503
2504         if (new_pin == NULL) {
2505                 mutex_unlock(&regulator_list_mutex);
2506                 return -ENOMEM;
2507         }
2508
2509         pin = new_pin;
2510         new_pin = NULL;
2511
2512         pin->gpiod = gpiod;
2513         list_add(&pin->list, &regulator_ena_gpio_list);
2514
2515 update_ena_gpio_to_rdev:
2516         pin->request_count++;
2517         rdev->ena_pin = pin;
2518
2519         mutex_unlock(&regulator_list_mutex);
2520         kfree(new_pin);
2521
2522         return 0;
2523 }
2524
2525 static void regulator_ena_gpio_free(struct regulator_dev *rdev)
2526 {
2527         struct regulator_enable_gpio *pin, *n;
2528
2529         if (!rdev->ena_pin)
2530                 return;
2531
2532         /* Free the GPIO only in case of no use */
2533         list_for_each_entry_safe(pin, n, &regulator_ena_gpio_list, list) {
2534                 if (pin != rdev->ena_pin)
2535                         continue;
2536
2537                 if (--pin->request_count)
2538                         break;
2539
2540                 gpiod_put(pin->gpiod);
2541                 list_del(&pin->list);
2542                 kfree(pin);
2543                 break;
2544         }
2545
2546         rdev->ena_pin = NULL;
2547 }
2548
2549 /**
2550  * regulator_ena_gpio_ctrl - balance enable_count of each GPIO and actual GPIO pin control
2551  * @rdev: regulator_dev structure
2552  * @enable: enable GPIO at initial use?
2553  *
2554  * GPIO is enabled in case of initial use. (enable_count is 0)
2555  * GPIO is disabled when it is not shared any more. (enable_count <= 1)
2556  */
2557 static int regulator_ena_gpio_ctrl(struct regulator_dev *rdev, bool enable)
2558 {
2559         struct regulator_enable_gpio *pin = rdev->ena_pin;
2560
2561         if (!pin)
2562                 return -EINVAL;
2563
2564         if (enable) {
2565                 /* Enable GPIO at initial use */
2566                 if (pin->enable_count == 0)
2567                         gpiod_set_value_cansleep(pin->gpiod, 1);
2568
2569                 pin->enable_count++;
2570         } else {
2571                 if (pin->enable_count > 1) {
2572                         pin->enable_count--;
2573                         return 0;
2574                 }
2575
2576                 /* Disable GPIO if not used */
2577                 if (pin->enable_count <= 1) {
2578                         gpiod_set_value_cansleep(pin->gpiod, 0);
2579                         pin->enable_count = 0;
2580                 }
2581         }
2582
2583         return 0;
2584 }
2585
2586 /**
2587  * _regulator_delay_helper - a delay helper function
2588  * @delay: time to delay in microseconds
2589  *
2590  * Delay for the requested amount of time as per the guidelines in:
2591  *
2592  *     Documentation/timers/timers-howto.rst
2593  *
2594  * The assumption here is that these regulator operations will never used in
2595  * atomic context and therefore sleeping functions can be used.
2596  */
2597 static void _regulator_delay_helper(unsigned int delay)
2598 {
2599         unsigned int ms = delay / 1000;
2600         unsigned int us = delay % 1000;
2601
2602         if (ms > 0) {
2603                 /*
2604                  * For small enough values, handle super-millisecond
2605                  * delays in the usleep_range() call below.
2606                  */
2607                 if (ms < 20)
2608                         us += ms * 1000;
2609                 else
2610                         msleep(ms);
2611         }
2612
2613         /*
2614          * Give the scheduler some room to coalesce with any other
2615          * wakeup sources. For delays shorter than 10 us, don't even
2616          * bother setting up high-resolution timers and just busy-
2617          * loop.
2618          */
2619         if (us >= 10)
2620                 usleep_range(us, us + 100);
2621         else
2622                 udelay(us);
2623 }
2624
2625 /**
2626  * _regulator_check_status_enabled
2627  *
2628  * A helper function to check if the regulator status can be interpreted
2629  * as 'regulator is enabled'.
2630  * @rdev: the regulator device to check
2631  *
2632  * Return:
2633  * * 1                  - if status shows regulator is in enabled state
2634  * * 0                  - if not enabled state
2635  * * Error Value        - as received from ops->get_status()
2636  */
2637 static inline int _regulator_check_status_enabled(struct regulator_dev *rdev)
2638 {
2639         int ret = rdev->desc->ops->get_status(rdev);
2640
2641         if (ret < 0) {
2642                 rdev_info(rdev, "get_status returned error: %d\n", ret);
2643                 return ret;
2644         }
2645
2646         switch (ret) {
2647         case REGULATOR_STATUS_OFF:
2648         case REGULATOR_STATUS_ERROR:
2649         case REGULATOR_STATUS_UNDEFINED:
2650                 return 0;
2651         default:
2652                 return 1;
2653         }
2654 }
2655
2656 static int _regulator_do_enable(struct regulator_dev *rdev)
2657 {
2658         int ret, delay;
2659
2660         /* Query before enabling in case configuration dependent.  */
2661         ret = _regulator_get_enable_time(rdev);
2662         if (ret >= 0) {
2663                 delay = ret;
2664         } else {
2665                 rdev_warn(rdev, "enable_time() failed: %pe\n", ERR_PTR(ret));
2666                 delay = 0;
2667         }
2668
2669         trace_regulator_enable(rdev_get_name(rdev));
2670
2671         if (rdev->desc->off_on_delay && rdev->last_off) {
2672                 /* if needed, keep a distance of off_on_delay from last time
2673                  * this regulator was disabled.
2674                  */
2675                 ktime_t end = ktime_add_us(rdev->last_off, rdev->desc->off_on_delay);
2676                 s64 remaining = ktime_us_delta(end, ktime_get());
2677
2678                 if (remaining > 0)
2679                         _regulator_delay_helper(remaining);
2680         }
2681
2682         if (rdev->ena_pin) {
2683                 if (!rdev->ena_gpio_state) {
2684                         ret = regulator_ena_gpio_ctrl(rdev, true);
2685                         if (ret < 0)
2686                                 return ret;
2687                         rdev->ena_gpio_state = 1;
2688                 }
2689         } else if (rdev->desc->ops->enable) {
2690                 ret = rdev->desc->ops->enable(rdev);
2691                 if (ret < 0)
2692                         return ret;
2693         } else {
2694                 return -EINVAL;
2695         }
2696
2697         /* Allow the regulator to ramp; it would be useful to extend
2698          * this for bulk operations so that the regulators can ramp
2699          * together.
2700          */
2701         trace_regulator_enable_delay(rdev_get_name(rdev));
2702
2703         /* If poll_enabled_time is set, poll upto the delay calculated
2704          * above, delaying poll_enabled_time uS to check if the regulator
2705          * actually got enabled.
2706          * If the regulator isn't enabled after our delay helper has expired,
2707          * return -ETIMEDOUT.
2708          */
2709         if (rdev->desc->poll_enabled_time) {
2710                 int time_remaining = delay;
2711
2712                 while (time_remaining > 0) {
2713                         _regulator_delay_helper(rdev->desc->poll_enabled_time);
2714
2715                         if (rdev->desc->ops->get_status) {
2716                                 ret = _regulator_check_status_enabled(rdev);
2717                                 if (ret < 0)
2718                                         return ret;
2719                                 else if (ret)
2720                                         break;
2721                         } else if (rdev->desc->ops->is_enabled(rdev))
2722                                 break;
2723
2724                         time_remaining -= rdev->desc->poll_enabled_time;
2725                 }
2726
2727                 if (time_remaining <= 0) {
2728                         rdev_err(rdev, "Enabled check timed out\n");
2729                         return -ETIMEDOUT;
2730                 }
2731         } else {
2732                 _regulator_delay_helper(delay);
2733         }
2734
2735         trace_regulator_enable_complete(rdev_get_name(rdev));
2736
2737         return 0;
2738 }
2739
2740 /**
2741  * _regulator_handle_consumer_enable - handle that a consumer enabled
2742  * @regulator: regulator source
2743  *
2744  * Some things on a regulator consumer (like the contribution towards total
2745  * load on the regulator) only have an effect when the consumer wants the
2746  * regulator enabled.  Explained in example with two consumers of the same
2747  * regulator:
2748  *   consumer A: set_load(100);       => total load = 0
2749  *   consumer A: regulator_enable();  => total load = 100
2750  *   consumer B: set_load(1000);      => total load = 100
2751  *   consumer B: regulator_enable();  => total load = 1100
2752  *   consumer A: regulator_disable(); => total_load = 1000
2753  *
2754  * This function (together with _regulator_handle_consumer_disable) is
2755  * responsible for keeping track of the refcount for a given regulator consumer
2756  * and applying / unapplying these things.
2757  *
2758  * Returns 0 upon no error; -error upon error.
2759  */
2760 static int _regulator_handle_consumer_enable(struct regulator *regulator)
2761 {
2762         int ret;
2763         struct regulator_dev *rdev = regulator->rdev;
2764
2765         lockdep_assert_held_once(&rdev->mutex.base);
2766
2767         regulator->enable_count++;
2768         if (regulator->uA_load && regulator->enable_count == 1) {
2769                 ret = drms_uA_update(rdev);
2770                 if (ret)
2771                         regulator->enable_count--;
2772                 return ret;
2773         }
2774
2775         return 0;
2776 }
2777
2778 /**
2779  * _regulator_handle_consumer_disable - handle that a consumer disabled
2780  * @regulator: regulator source
2781  *
2782  * The opposite of _regulator_handle_consumer_enable().
2783  *
2784  * Returns 0 upon no error; -error upon error.
2785  */
2786 static int _regulator_handle_consumer_disable(struct regulator *regulator)
2787 {
2788         struct regulator_dev *rdev = regulator->rdev;
2789
2790         lockdep_assert_held_once(&rdev->mutex.base);
2791
2792         if (!regulator->enable_count) {
2793                 rdev_err(rdev, "Underflow of regulator enable count\n");
2794                 return -EINVAL;
2795         }
2796
2797         regulator->enable_count--;
2798         if (regulator->uA_load && regulator->enable_count == 0)
2799                 return drms_uA_update(rdev);
2800
2801         return 0;
2802 }
2803
2804 /* locks held by regulator_enable() */
2805 static int _regulator_enable(struct regulator *regulator)
2806 {
2807         struct regulator_dev *rdev = regulator->rdev;
2808         int ret;
2809
2810         lockdep_assert_held_once(&rdev->mutex.base);
2811
2812         if (rdev->use_count == 0 && rdev->supply) {
2813                 ret = _regulator_enable(rdev->supply);
2814                 if (ret < 0)
2815                         return ret;
2816         }
2817
2818         /* balance only if there are regulators coupled */
2819         if (rdev->coupling_desc.n_coupled > 1) {
2820                 ret = regulator_balance_voltage(rdev, PM_SUSPEND_ON);
2821                 if (ret < 0)
2822                         goto err_disable_supply;
2823         }
2824
2825         ret = _regulator_handle_consumer_enable(regulator);
2826         if (ret < 0)
2827                 goto err_disable_supply;
2828
2829         if (rdev->use_count == 0) {
2830                 /*
2831                  * The regulator may already be enabled if it's not switchable
2832                  * or was left on
2833                  */
2834                 ret = _regulator_is_enabled(rdev);
2835                 if (ret == -EINVAL || ret == 0) {
2836                         if (!regulator_ops_is_valid(rdev,
2837                                         REGULATOR_CHANGE_STATUS)) {
2838                                 ret = -EPERM;
2839                                 goto err_consumer_disable;
2840                         }
2841
2842                         ret = _regulator_do_enable(rdev);
2843                         if (ret < 0)
2844                                 goto err_consumer_disable;
2845
2846                         _notifier_call_chain(rdev, REGULATOR_EVENT_ENABLE,
2847                                              NULL);
2848                 } else if (ret < 0) {
2849                         rdev_err(rdev, "is_enabled() failed: %pe\n", ERR_PTR(ret));
2850                         goto err_consumer_disable;
2851                 }
2852                 /* Fallthrough on positive return values - already enabled */
2853         }
2854
2855         rdev->use_count++;
2856
2857         return 0;
2858
2859 err_consumer_disable:
2860         _regulator_handle_consumer_disable(regulator);
2861
2862 err_disable_supply:
2863         if (rdev->use_count == 0 && rdev->supply)
2864                 _regulator_disable(rdev->supply);
2865
2866         return ret;
2867 }
2868
2869 /**
2870  * regulator_enable - enable regulator output
2871  * @regulator: regulator source
2872  *
2873  * Request that the regulator be enabled with the regulator output at
2874  * the predefined voltage or current value.  Calls to regulator_enable()
2875  * must be balanced with calls to regulator_disable().
2876  *
2877  * NOTE: the output value can be set by other drivers, boot loader or may be
2878  * hardwired in the regulator.
2879  */
2880 int regulator_enable(struct regulator *regulator)
2881 {
2882         struct regulator_dev *rdev = regulator->rdev;
2883         struct ww_acquire_ctx ww_ctx;
2884         int ret;
2885
2886         regulator_lock_dependent(rdev, &ww_ctx);
2887         ret = _regulator_enable(regulator);
2888         regulator_unlock_dependent(rdev, &ww_ctx);
2889
2890         return ret;
2891 }
2892 EXPORT_SYMBOL_GPL(regulator_enable);
2893
2894 static int _regulator_do_disable(struct regulator_dev *rdev)
2895 {
2896         int ret;
2897
2898         trace_regulator_disable(rdev_get_name(rdev));
2899
2900         if (rdev->ena_pin) {
2901                 if (rdev->ena_gpio_state) {
2902                         ret = regulator_ena_gpio_ctrl(rdev, false);
2903                         if (ret < 0)
2904                                 return ret;
2905                         rdev->ena_gpio_state = 0;
2906                 }
2907
2908         } else if (rdev->desc->ops->disable) {
2909                 ret = rdev->desc->ops->disable(rdev);
2910                 if (ret != 0)
2911                         return ret;
2912         }
2913
2914         if (rdev->desc->off_on_delay)
2915                 rdev->last_off = ktime_get();
2916
2917         trace_regulator_disable_complete(rdev_get_name(rdev));
2918
2919         return 0;
2920 }
2921
2922 /* locks held by regulator_disable() */
2923 static int _regulator_disable(struct regulator *regulator)
2924 {
2925         struct regulator_dev *rdev = regulator->rdev;
2926         int ret = 0;
2927
2928         lockdep_assert_held_once(&rdev->mutex.base);
2929
2930         if (WARN(rdev->use_count <= 0,
2931                  "unbalanced disables for %s\n", rdev_get_name(rdev)))
2932                 return -EIO;
2933
2934         /* are we the last user and permitted to disable ? */
2935         if (rdev->use_count == 1 &&
2936             (rdev->constraints && !rdev->constraints->always_on)) {
2937
2938                 /* we are last user */
2939                 if (regulator_ops_is_valid(rdev, REGULATOR_CHANGE_STATUS)) {
2940                         ret = _notifier_call_chain(rdev,
2941                                                    REGULATOR_EVENT_PRE_DISABLE,
2942                                                    NULL);
2943                         if (ret & NOTIFY_STOP_MASK)
2944                                 return -EINVAL;
2945
2946                         ret = _regulator_do_disable(rdev);
2947                         if (ret < 0) {
2948                                 rdev_err(rdev, "failed to disable: %pe\n", ERR_PTR(ret));
2949                                 _notifier_call_chain(rdev,
2950                                                 REGULATOR_EVENT_ABORT_DISABLE,
2951                                                 NULL);
2952                                 return ret;
2953                         }
2954                         _notifier_call_chain(rdev, REGULATOR_EVENT_DISABLE,
2955                                         NULL);
2956                 }
2957
2958                 rdev->use_count = 0;
2959         } else if (rdev->use_count > 1) {
2960                 rdev->use_count--;
2961         }
2962
2963         if (ret == 0)
2964                 ret = _regulator_handle_consumer_disable(regulator);
2965
2966         if (ret == 0 && rdev->coupling_desc.n_coupled > 1)
2967                 ret = regulator_balance_voltage(rdev, PM_SUSPEND_ON);
2968
2969         if (ret == 0 && rdev->use_count == 0 && rdev->supply)
2970                 ret = _regulator_disable(rdev->supply);
2971
2972         return ret;
2973 }
2974
2975 /**
2976  * regulator_disable - disable regulator output
2977  * @regulator: regulator source
2978  *
2979  * Disable the regulator output voltage or current.  Calls to
2980  * regulator_enable() must be balanced with calls to
2981  * regulator_disable().
2982  *
2983  * NOTE: this will only disable the regulator output if no other consumer
2984  * devices have it enabled, the regulator device supports disabling and
2985  * machine constraints permit this operation.
2986  */
2987 int regulator_disable(struct regulator *regulator)
2988 {
2989         struct regulator_dev *rdev = regulator->rdev;
2990         struct ww_acquire_ctx ww_ctx;
2991         int ret;
2992
2993         regulator_lock_dependent(rdev, &ww_ctx);
2994         ret = _regulator_disable(regulator);
2995         regulator_unlock_dependent(rdev, &ww_ctx);
2996
2997         return ret;
2998 }
2999 EXPORT_SYMBOL_GPL(regulator_disable);
3000
3001 /* locks held by regulator_force_disable() */
3002 static int _regulator_force_disable(struct regulator_dev *rdev)
3003 {
3004         int ret = 0;
3005
3006         lockdep_assert_held_once(&rdev->mutex.base);
3007
3008         ret = _notifier_call_chain(rdev, REGULATOR_EVENT_FORCE_DISABLE |
3009                         REGULATOR_EVENT_PRE_DISABLE, NULL);
3010         if (ret & NOTIFY_STOP_MASK)
3011                 return -EINVAL;
3012
3013         ret = _regulator_do_disable(rdev);
3014         if (ret < 0) {
3015                 rdev_err(rdev, "failed to force disable: %pe\n", ERR_PTR(ret));
3016                 _notifier_call_chain(rdev, REGULATOR_EVENT_FORCE_DISABLE |
3017                                 REGULATOR_EVENT_ABORT_DISABLE, NULL);
3018                 return ret;
3019         }
3020
3021         _notifier_call_chain(rdev, REGULATOR_EVENT_FORCE_DISABLE |
3022                         REGULATOR_EVENT_DISABLE, NULL);
3023
3024         return 0;
3025 }
3026
3027 /**
3028  * regulator_force_disable - force disable regulator output
3029  * @regulator: regulator source
3030  *
3031  * Forcibly disable the regulator output voltage or current.
3032  * NOTE: this *will* disable the regulator output even if other consumer
3033  * devices have it enabled. This should be used for situations when device
3034  * damage will likely occur if the regulator is not disabled (e.g. over temp).
3035  */
3036 int regulator_force_disable(struct regulator *regulator)
3037 {
3038         struct regulator_dev *rdev = regulator->rdev;
3039         struct ww_acquire_ctx ww_ctx;
3040         int ret;
3041
3042         regulator_lock_dependent(rdev, &ww_ctx);
3043
3044         ret = _regulator_force_disable(regulator->rdev);
3045
3046         if (rdev->coupling_desc.n_coupled > 1)
3047                 regulator_balance_voltage(rdev, PM_SUSPEND_ON);
3048
3049         if (regulator->uA_load) {
3050                 regulator->uA_load = 0;
3051                 ret = drms_uA_update(rdev);
3052         }
3053
3054         if (rdev->use_count != 0 && rdev->supply)
3055                 _regulator_disable(rdev->supply);
3056
3057         regulator_unlock_dependent(rdev, &ww_ctx);
3058
3059         return ret;
3060 }
3061 EXPORT_SYMBOL_GPL(regulator_force_disable);
3062
3063 static void regulator_disable_work(struct work_struct *work)
3064 {
3065         struct regulator_dev *rdev = container_of(work, struct regulator_dev,
3066                                                   disable_work.work);
3067         struct ww_acquire_ctx ww_ctx;
3068         int count, i, ret;
3069         struct regulator *regulator;
3070         int total_count = 0;
3071
3072         regulator_lock_dependent(rdev, &ww_ctx);
3073
3074         /*
3075          * Workqueue functions queue the new work instance while the previous
3076          * work instance is being processed. Cancel the queued work instance
3077          * as the work instance under processing does the job of the queued
3078          * work instance.
3079          */
3080         cancel_delayed_work(&rdev->disable_work);
3081
3082         list_for_each_entry(regulator, &rdev->consumer_list, list) {
3083                 count = regulator->deferred_disables;
3084
3085                 if (!count)
3086                         continue;
3087
3088                 total_count += count;
3089                 regulator->deferred_disables = 0;
3090
3091                 for (i = 0; i < count; i++) {
3092                         ret = _regulator_disable(regulator);
3093                         if (ret != 0)
3094                                 rdev_err(rdev, "Deferred disable failed: %pe\n",
3095                                          ERR_PTR(ret));
3096                 }
3097         }
3098         WARN_ON(!total_count);
3099
3100         if (rdev->coupling_desc.n_coupled > 1)
3101                 regulator_balance_voltage(rdev, PM_SUSPEND_ON);
3102
3103         regulator_unlock_dependent(rdev, &ww_ctx);
3104 }
3105
3106 /**
3107  * regulator_disable_deferred - disable regulator output with delay
3108  * @regulator: regulator source
3109  * @ms: milliseconds until the regulator is disabled
3110  *
3111  * Execute regulator_disable() on the regulator after a delay.  This
3112  * is intended for use with devices that require some time to quiesce.
3113  *
3114  * NOTE: this will only disable the regulator output if no other consumer
3115  * devices have it enabled, the regulator device supports disabling and
3116  * machine constraints permit this operation.
3117  */
3118 int regulator_disable_deferred(struct regulator *regulator, int ms)
3119 {
3120         struct regulator_dev *rdev = regulator->rdev;
3121
3122         if (!ms)
3123                 return regulator_disable(regulator);
3124
3125         regulator_lock(rdev);
3126         regulator->deferred_disables++;
3127         mod_delayed_work(system_power_efficient_wq, &rdev->disable_work,
3128                          msecs_to_jiffies(ms));
3129         regulator_unlock(rdev);
3130
3131         return 0;
3132 }
3133 EXPORT_SYMBOL_GPL(regulator_disable_deferred);
3134
3135 static int _regulator_is_enabled(struct regulator_dev *rdev)
3136 {
3137         /* A GPIO control always takes precedence */
3138         if (rdev->ena_pin)
3139                 return rdev->ena_gpio_state;
3140
3141         /* If we don't know then assume that the regulator is always on */
3142         if (!rdev->desc->ops->is_enabled)
3143                 return 1;
3144
3145         return rdev->desc->ops->is_enabled(rdev);
3146 }
3147
3148 static int _regulator_list_voltage(struct regulator_dev *rdev,
3149                                    unsigned selector, int lock)
3150 {
3151         const struct regulator_ops *ops = rdev->desc->ops;
3152         int ret;
3153
3154         if (rdev->desc->fixed_uV && rdev->desc->n_voltages == 1 && !selector)
3155                 return rdev->desc->fixed_uV;
3156
3157         if (ops->list_voltage) {
3158                 if (selector >= rdev->desc->n_voltages)
3159                         return -EINVAL;
3160                 if (selector < rdev->desc->linear_min_sel)
3161                         return 0;
3162                 if (lock)
3163                         regulator_lock(rdev);
3164                 ret = ops->list_voltage(rdev, selector);
3165                 if (lock)
3166                         regulator_unlock(rdev);
3167         } else if (rdev->is_switch && rdev->supply) {
3168                 ret = _regulator_list_voltage(rdev->supply->rdev,
3169                                               selector, lock);
3170         } else {
3171                 return -EINVAL;
3172         }
3173
3174         if (ret > 0) {
3175                 if (ret < rdev->constraints->min_uV)
3176                         ret = 0;
3177                 else if (ret > rdev->constraints->max_uV)
3178                         ret = 0;
3179         }
3180
3181         return ret;
3182 }
3183
3184 /**
3185  * regulator_is_enabled - is the regulator output enabled
3186  * @regulator: regulator source
3187  *
3188  * Returns positive if the regulator driver backing the source/client
3189  * has requested that the device be enabled, zero if it hasn't, else a
3190  * negative errno code.
3191  *
3192  * Note that the device backing this regulator handle can have multiple
3193  * users, so it might be enabled even if regulator_enable() was never
3194  * called for this particular source.
3195  */
3196 int regulator_is_enabled(struct regulator *regulator)
3197 {
3198         int ret;
3199
3200         if (regulator->always_on)
3201                 return 1;
3202
3203         regulator_lock(regulator->rdev);
3204         ret = _regulator_is_enabled(regulator->rdev);
3205         regulator_unlock(regulator->rdev);
3206
3207         return ret;
3208 }
3209 EXPORT_SYMBOL_GPL(regulator_is_enabled);
3210
3211 /**
3212  * regulator_count_voltages - count regulator_list_voltage() selectors
3213  * @regulator: regulator source
3214  *
3215  * Returns number of selectors, or negative errno.  Selectors are
3216  * numbered starting at zero, and typically correspond to bitfields
3217  * in hardware registers.
3218  */
3219 int regulator_count_voltages(struct regulator *regulator)
3220 {
3221         struct regulator_dev    *rdev = regulator->rdev;
3222
3223         if (rdev->desc->n_voltages)
3224                 return rdev->desc->n_voltages;
3225
3226         if (!rdev->is_switch || !rdev->supply)
3227                 return -EINVAL;
3228
3229         return regulator_count_voltages(rdev->supply);
3230 }
3231 EXPORT_SYMBOL_GPL(regulator_count_voltages);
3232
3233 /**
3234  * regulator_list_voltage - enumerate supported voltages
3235  * @regulator: regulator source
3236  * @selector: identify voltage to list
3237  * Context: can sleep
3238  *
3239  * Returns a voltage that can be passed to @regulator_set_voltage(),
3240  * zero if this selector code can't be used on this system, or a
3241  * negative errno.
3242  */
3243 int regulator_list_voltage(struct regulator *regulator, unsigned selector)
3244 {
3245         return _regulator_list_voltage(regulator->rdev, selector, 1);
3246 }
3247 EXPORT_SYMBOL_GPL(regulator_list_voltage);
3248
3249 /**
3250  * regulator_get_regmap - get the regulator's register map
3251  * @regulator: regulator source
3252  *
3253  * Returns the register map for the given regulator, or an ERR_PTR value
3254  * if the regulator doesn't use regmap.
3255  */
3256 struct regmap *regulator_get_regmap(struct regulator *regulator)
3257 {
3258         struct regmap *map = regulator->rdev->regmap;
3259
3260         return map ? map : ERR_PTR(-EOPNOTSUPP);
3261 }
3262
3263 /**
3264  * regulator_get_hardware_vsel_register - get the HW voltage selector register
3265  * @regulator: regulator source
3266  * @vsel_reg: voltage selector register, output parameter
3267  * @vsel_mask: mask for voltage selector bitfield, output parameter
3268  *
3269  * Returns the hardware register offset and bitmask used for setting the
3270  * regulator voltage. This might be useful when configuring voltage-scaling
3271  * hardware or firmware that can make I2C requests behind the kernel's back,
3272  * for example.
3273  *
3274  * On success, the output parameters @vsel_reg and @vsel_mask are filled in
3275  * and 0 is returned, otherwise a negative errno is returned.
3276  */
3277 int regulator_get_hardware_vsel_register(struct regulator *regulator,
3278                                          unsigned *vsel_reg,
3279                                          unsigned *vsel_mask)
3280 {
3281         struct regulator_dev *rdev = regulator->rdev;
3282         const struct regulator_ops *ops = rdev->desc->ops;
3283
3284         if (ops->set_voltage_sel != regulator_set_voltage_sel_regmap)
3285                 return -EOPNOTSUPP;
3286
3287         *vsel_reg = rdev->desc->vsel_reg;
3288         *vsel_mask = rdev->desc->vsel_mask;
3289
3290         return 0;
3291 }
3292 EXPORT_SYMBOL_GPL(regulator_get_hardware_vsel_register);
3293
3294 /**
3295  * regulator_list_hardware_vsel - get the HW-specific register value for a selector
3296  * @regulator: regulator source
3297  * @selector: identify voltage to list
3298  *
3299  * Converts the selector to a hardware-specific voltage selector that can be
3300  * directly written to the regulator registers. The address of the voltage
3301  * register can be determined by calling @regulator_get_hardware_vsel_register.
3302  *
3303  * On error a negative errno is returned.
3304  */
3305 int regulator_list_hardware_vsel(struct regulator *regulator,
3306                                  unsigned selector)
3307 {
3308         struct regulator_dev *rdev = regulator->rdev;
3309         const struct regulator_ops *ops = rdev->desc->ops;
3310
3311         if (selector >= rdev->desc->n_voltages)
3312                 return -EINVAL;
3313         if (selector < rdev->desc->linear_min_sel)
3314                 return 0;
3315         if (ops->set_voltage_sel != regulator_set_voltage_sel_regmap)
3316                 return -EOPNOTSUPP;
3317
3318         return selector;
3319 }
3320 EXPORT_SYMBOL_GPL(regulator_list_hardware_vsel);
3321
3322 /**
3323  * regulator_get_linear_step - return the voltage step size between VSEL values
3324  * @regulator: regulator source
3325  *
3326  * Returns the voltage step size between VSEL values for linear
3327  * regulators, or return 0 if the regulator isn't a linear regulator.
3328  */
3329 unsigned int regulator_get_linear_step(struct regulator *regulator)
3330 {
3331         struct regulator_dev *rdev = regulator->rdev;
3332
3333         return rdev->desc->uV_step;
3334 }
3335 EXPORT_SYMBOL_GPL(regulator_get_linear_step);
3336
3337 /**
3338  * regulator_is_supported_voltage - check if a voltage range can be supported
3339  *
3340  * @regulator: Regulator to check.
3341  * @min_uV: Minimum required voltage in uV.
3342  * @max_uV: Maximum required voltage in uV.
3343  *
3344  * Returns a boolean.
3345  */
3346 int regulator_is_supported_voltage(struct regulator *regulator,
3347                                    int min_uV, int max_uV)
3348 {
3349         struct regulator_dev *rdev = regulator->rdev;
3350         int i, voltages, ret;
3351
3352         /* If we can't change voltage check the current voltage */
3353         if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_VOLTAGE)) {
3354                 ret = regulator_get_voltage(regulator);
3355                 if (ret >= 0)
3356                         return min_uV <= ret && ret <= max_uV;
3357                 else
3358                         return ret;
3359         }
3360
3361         /* Any voltage within constrains range is fine? */
3362         if (rdev->desc->continuous_voltage_range)
3363                 return min_uV >= rdev->constraints->min_uV &&
3364                                 max_uV <= rdev->constraints->max_uV;
3365
3366         ret = regulator_count_voltages(regulator);
3367         if (ret < 0)
3368                 return 0;
3369         voltages = ret;
3370
3371         for (i = 0; i < voltages; i++) {
3372                 ret = regulator_list_voltage(regulator, i);
3373
3374                 if (ret >= min_uV && ret <= max_uV)
3375                         return 1;
3376         }
3377
3378         return 0;
3379 }
3380 EXPORT_SYMBOL_GPL(regulator_is_supported_voltage);
3381
3382 static int regulator_map_voltage(struct regulator_dev *rdev, int min_uV,
3383                                  int max_uV)
3384 {
3385         const struct regulator_desc *desc = rdev->desc;
3386
3387         if (desc->ops->map_voltage)
3388                 return desc->ops->map_voltage(rdev, min_uV, max_uV);
3389
3390         if (desc->ops->list_voltage == regulator_list_voltage_linear)
3391                 return regulator_map_voltage_linear(rdev, min_uV, max_uV);
3392
3393         if (desc->ops->list_voltage == regulator_list_voltage_linear_range)
3394                 return regulator_map_voltage_linear_range(rdev, min_uV, max_uV);
3395
3396         if (desc->ops->list_voltage ==
3397                 regulator_list_voltage_pickable_linear_range)
3398                 return regulator_map_voltage_pickable_linear_range(rdev,
3399                                                         min_uV, max_uV);
3400
3401         return regulator_map_voltage_iterate(rdev, min_uV, max_uV);
3402 }
3403
3404 static int _regulator_call_set_voltage(struct regulator_dev *rdev,
3405                                        int min_uV, int max_uV,
3406                                        unsigned *selector)
3407 {
3408         struct pre_voltage_change_data data;
3409         int ret;
3410
3411         data.old_uV = regulator_get_voltage_rdev(rdev);
3412         data.min_uV = min_uV;
3413         data.max_uV = max_uV;
3414         ret = _notifier_call_chain(rdev, REGULATOR_EVENT_PRE_VOLTAGE_CHANGE,
3415                                    &data);
3416         if (ret & NOTIFY_STOP_MASK)
3417                 return -EINVAL;
3418
3419         ret = rdev->desc->ops->set_voltage(rdev, min_uV, max_uV, selector);
3420         if (ret >= 0)
3421                 return ret;
3422
3423         _notifier_call_chain(rdev, REGULATOR_EVENT_ABORT_VOLTAGE_CHANGE,
3424                              (void *)data.old_uV);
3425
3426         return ret;
3427 }
3428
3429 static int _regulator_call_set_voltage_sel(struct regulator_dev *rdev,
3430                                            int uV, unsigned selector)
3431 {
3432         struct pre_voltage_change_data data;
3433         int ret;
3434
3435         data.old_uV = regulator_get_voltage_rdev(rdev);
3436         data.min_uV = uV;
3437         data.max_uV = uV;
3438         ret = _notifier_call_chain(rdev, REGULATOR_EVENT_PRE_VOLTAGE_CHANGE,
3439                                    &data);
3440         if (ret & NOTIFY_STOP_MASK)
3441                 return -EINVAL;
3442
3443         ret = rdev->desc->ops->set_voltage_sel(rdev, selector);
3444         if (ret >= 0)
3445                 return ret;
3446
3447         _notifier_call_chain(rdev, REGULATOR_EVENT_ABORT_VOLTAGE_CHANGE,
3448                              (void *)data.old_uV);
3449
3450         return ret;
3451 }
3452
3453 static int _regulator_set_voltage_sel_step(struct regulator_dev *rdev,
3454                                            int uV, int new_selector)
3455 {
3456         const struct regulator_ops *ops = rdev->desc->ops;
3457         int diff, old_sel, curr_sel, ret;
3458
3459         /* Stepping is only needed if the regulator is enabled. */
3460         if (!_regulator_is_enabled(rdev))
3461                 goto final_set;
3462
3463         if (!ops->get_voltage_sel)
3464                 return -EINVAL;
3465
3466         old_sel = ops->get_voltage_sel(rdev);
3467         if (old_sel < 0)
3468                 return old_sel;
3469
3470         diff = new_selector - old_sel;
3471         if (diff == 0)
3472                 return 0; /* No change needed. */
3473
3474         if (diff > 0) {
3475                 /* Stepping up. */
3476                 for (curr_sel = old_sel + rdev->desc->vsel_step;
3477                      curr_sel < new_selector;
3478                      curr_sel += rdev->desc->vsel_step) {
3479                         /*
3480                          * Call the callback directly instead of using
3481                          * _regulator_call_set_voltage_sel() as we don't
3482                          * want to notify anyone yet. Same in the branch
3483                          * below.
3484                          */
3485                         ret = ops->set_voltage_sel(rdev, curr_sel);
3486                         if (ret)
3487                                 goto try_revert;
3488                 }
3489         } else {
3490                 /* Stepping down. */
3491                 for (curr_sel = old_sel - rdev->desc->vsel_step;
3492                      curr_sel > new_selector;
3493                      curr_sel -= rdev->desc->vsel_step) {
3494                         ret = ops->set_voltage_sel(rdev, curr_sel);
3495                         if (ret)
3496                                 goto try_revert;
3497                 }
3498         }
3499
3500 final_set:
3501         /* The final selector will trigger the notifiers. */
3502         return _regulator_call_set_voltage_sel(rdev, uV, new_selector);
3503
3504 try_revert:
3505         /*
3506          * At least try to return to the previous voltage if setting a new
3507          * one failed.
3508          */
3509         (void)ops->set_voltage_sel(rdev, old_sel);
3510         return ret;
3511 }
3512
3513 static int _regulator_set_voltage_time(struct regulator_dev *rdev,
3514                                        int old_uV, int new_uV)
3515 {
3516         unsigned int ramp_delay = 0;
3517
3518         if (rdev->constraints->ramp_delay)
3519                 ramp_delay = rdev->constraints->ramp_delay;
3520         else if (rdev->desc->ramp_delay)
3521                 ramp_delay = rdev->desc->ramp_delay;
3522         else if (rdev->constraints->settling_time)
3523                 return rdev->constraints->settling_time;
3524         else if (rdev->constraints->settling_time_up &&
3525                  (new_uV > old_uV))
3526                 return rdev->constraints->settling_time_up;
3527         else if (rdev->constraints->settling_time_down &&
3528                  (new_uV < old_uV))
3529                 return rdev->constraints->settling_time_down;
3530
3531         if (ramp_delay == 0)
3532                 return 0;
3533
3534         return DIV_ROUND_UP(abs(new_uV - old_uV), ramp_delay);
3535 }
3536
3537 static int _regulator_do_set_voltage(struct regulator_dev *rdev,
3538                                      int min_uV, int max_uV)
3539 {
3540         int ret;
3541         int delay = 0;
3542         int best_val = 0;
3543         unsigned int selector;
3544         int old_selector = -1;
3545         const struct regulator_ops *ops = rdev->desc->ops;
3546         int old_uV = regulator_get_voltage_rdev(rdev);
3547
3548         trace_regulator_set_voltage(rdev_get_name(rdev), min_uV, max_uV);
3549
3550         min_uV += rdev->constraints->uV_offset;
3551         max_uV += rdev->constraints->uV_offset;
3552
3553         /*
3554          * If we can't obtain the old selector there is not enough
3555          * info to call set_voltage_time_sel().
3556          */
3557         if (_regulator_is_enabled(rdev) &&
3558             ops->set_voltage_time_sel && ops->get_voltage_sel) {
3559                 old_selector = ops->get_voltage_sel(rdev);
3560                 if (old_selector < 0)
3561                         return old_selector;
3562         }
3563
3564         if (ops->set_voltage) {
3565                 ret = _regulator_call_set_voltage(rdev, min_uV, max_uV,
3566                                                   &selector);
3567
3568                 if (ret >= 0) {
3569                         if (ops->list_voltage)
3570                                 best_val = ops->list_voltage(rdev,
3571                                                              selector);
3572                         else
3573                                 best_val = regulator_get_voltage_rdev(rdev);
3574                 }
3575
3576         } else if (ops->set_voltage_sel) {
3577                 ret = regulator_map_voltage(rdev, min_uV, max_uV);
3578                 if (ret >= 0) {
3579                         best_val = ops->list_voltage(rdev, ret);
3580                         if (min_uV <= best_val && max_uV >= best_val) {
3581                                 selector = ret;
3582                                 if (old_selector == selector)
3583                                         ret = 0;
3584                                 else if (rdev->desc->vsel_step)
3585                                         ret = _regulator_set_voltage_sel_step(
3586                                                 rdev, best_val, selector);
3587                                 else
3588                                         ret = _regulator_call_set_voltage_sel(
3589                                                 rdev, best_val, selector);
3590                         } else {
3591                                 ret = -EINVAL;
3592                         }
3593                 }
3594         } else {
3595                 ret = -EINVAL;
3596         }
3597
3598         if (ret)
3599                 goto out;
3600
3601         if (ops->set_voltage_time_sel) {
3602                 /*
3603                  * Call set_voltage_time_sel if successfully obtained
3604                  * old_selector
3605                  */
3606                 if (old_selector >= 0 && old_selector != selector)
3607                         delay = ops->set_voltage_time_sel(rdev, old_selector,
3608                                                           selector);
3609         } else {
3610                 if (old_uV != best_val) {
3611                         if (ops->set_voltage_time)
3612                                 delay = ops->set_voltage_time(rdev, old_uV,
3613                                                               best_val);
3614                         else
3615                                 delay = _regulator_set_voltage_time(rdev,
3616                                                                     old_uV,
3617                                                                     best_val);
3618                 }
3619         }
3620
3621         if (delay < 0) {
3622                 rdev_warn(rdev, "failed to get delay: %pe\n", ERR_PTR(delay));
3623                 delay = 0;
3624         }
3625
3626         /* Insert any necessary delays */
3627         _regulator_delay_helper(delay);
3628
3629         if (best_val >= 0) {
3630                 unsigned long data = best_val;
3631
3632                 _notifier_call_chain(rdev, REGULATOR_EVENT_VOLTAGE_CHANGE,
3633                                      (void *)data);
3634         }
3635
3636 out:
3637         trace_regulator_set_voltage_complete(rdev_get_name(rdev), best_val);
3638
3639         return ret;
3640 }
3641
3642 static int _regulator_do_set_suspend_voltage(struct regulator_dev *rdev,
3643                                   int min_uV, int max_uV, suspend_state_t state)
3644 {
3645         struct regulator_state *rstate;
3646         int uV, sel;
3647
3648         rstate = regulator_get_suspend_state(rdev, state);
3649         if (rstate == NULL)
3650                 return -EINVAL;
3651
3652         if (min_uV < rstate->min_uV)
3653                 min_uV = rstate->min_uV;
3654         if (max_uV > rstate->max_uV)
3655                 max_uV = rstate->max_uV;
3656
3657         sel = regulator_map_voltage(rdev, min_uV, max_uV);
3658         if (sel < 0)
3659                 return sel;
3660
3661         uV = rdev->desc->ops->list_voltage(rdev, sel);
3662         if (uV >= min_uV && uV <= max_uV)
3663                 rstate->uV = uV;
3664
3665         return 0;
3666 }
3667
3668 static int regulator_set_voltage_unlocked(struct regulator *regulator,
3669                                           int min_uV, int max_uV,
3670                                           suspend_state_t state)
3671 {
3672         struct regulator_dev *rdev = regulator->rdev;
3673         struct regulator_voltage *voltage = &regulator->voltage[state];
3674         int ret = 0;
3675         int old_min_uV, old_max_uV;
3676         int current_uV;
3677
3678         /* If we're setting the same range as last time the change
3679          * should be a noop (some cpufreq implementations use the same
3680          * voltage for multiple frequencies, for example).
3681          */
3682         if (voltage->min_uV == min_uV && voltage->max_uV == max_uV)
3683                 goto out;
3684
3685         /* If we're trying to set a range that overlaps the current voltage,
3686          * return successfully even though the regulator does not support
3687          * changing the voltage.
3688          */
3689         if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_VOLTAGE)) {
3690                 current_uV = regulator_get_voltage_rdev(rdev);
3691                 if (min_uV <= current_uV && current_uV <= max_uV) {
3692                         voltage->min_uV = min_uV;
3693                         voltage->max_uV = max_uV;
3694                         goto out;
3695                 }
3696         }
3697
3698         /* sanity check */
3699         if (!rdev->desc->ops->set_voltage &&
3700             !rdev->desc->ops->set_voltage_sel) {
3701                 ret = -EINVAL;
3702                 goto out;
3703         }
3704
3705         /* constraints check */
3706         ret = regulator_check_voltage(rdev, &min_uV, &max_uV);
3707         if (ret < 0)
3708                 goto out;
3709
3710         /* restore original values in case of error */
3711         old_min_uV = voltage->min_uV;
3712         old_max_uV = voltage->max_uV;
3713         voltage->min_uV = min_uV;
3714         voltage->max_uV = max_uV;
3715
3716         /* for not coupled regulators this will just set the voltage */
3717         ret = regulator_balance_voltage(rdev, state);
3718         if (ret < 0) {
3719                 voltage->min_uV = old_min_uV;
3720                 voltage->max_uV = old_max_uV;
3721         }
3722
3723 out:
3724         return ret;
3725 }
3726
3727 int regulator_set_voltage_rdev(struct regulator_dev *rdev, int min_uV,
3728                                int max_uV, suspend_state_t state)
3729 {
3730         int best_supply_uV = 0;
3731         int supply_change_uV = 0;
3732         int ret;
3733
3734         if (rdev->supply &&
3735             regulator_ops_is_valid(rdev->supply->rdev,
3736                                    REGULATOR_CHANGE_VOLTAGE) &&
3737             (rdev->desc->min_dropout_uV || !(rdev->desc->ops->get_voltage ||
3738                                            rdev->desc->ops->get_voltage_sel))) {
3739                 int current_supply_uV;
3740                 int selector;
3741
3742                 selector = regulator_map_voltage(rdev, min_uV, max_uV);
3743                 if (selector < 0) {
3744                         ret = selector;
3745                         goto out;
3746                 }
3747
3748                 best_supply_uV = _regulator_list_voltage(rdev, selector, 0);
3749                 if (best_supply_uV < 0) {
3750                         ret = best_supply_uV;
3751                         goto out;
3752                 }
3753
3754                 best_supply_uV += rdev->desc->min_dropout_uV;
3755
3756                 current_supply_uV = regulator_get_voltage_rdev(rdev->supply->rdev);
3757                 if (current_supply_uV < 0) {
3758                         ret = current_supply_uV;
3759                         goto out;
3760                 }
3761
3762                 supply_change_uV = best_supply_uV - current_supply_uV;
3763         }
3764
3765         if (supply_change_uV > 0) {
3766                 ret = regulator_set_voltage_unlocked(rdev->supply,
3767                                 best_supply_uV, INT_MAX, state);
3768                 if (ret) {
3769                         dev_err(&rdev->dev, "Failed to increase supply voltage: %pe\n",
3770                                 ERR_PTR(ret));
3771                         goto out;
3772                 }
3773         }
3774
3775         if (state == PM_SUSPEND_ON)
3776                 ret = _regulator_do_set_voltage(rdev, min_uV, max_uV);
3777         else
3778                 ret = _regulator_do_set_suspend_voltage(rdev, min_uV,
3779                                                         max_uV, state);
3780         if (ret < 0)
3781                 goto out;
3782
3783         if (supply_change_uV < 0) {
3784                 ret = regulator_set_voltage_unlocked(rdev->supply,
3785                                 best_supply_uV, INT_MAX, state);
3786                 if (ret)
3787                         dev_warn(&rdev->dev, "Failed to decrease supply voltage: %pe\n",
3788                                  ERR_PTR(ret));
3789                 /* No need to fail here */
3790                 ret = 0;
3791         }
3792
3793 out:
3794         return ret;
3795 }
3796 EXPORT_SYMBOL_GPL(regulator_set_voltage_rdev);
3797
3798 static int regulator_limit_voltage_step(struct regulator_dev *rdev,
3799                                         int *current_uV, int *min_uV)
3800 {
3801         struct regulation_constraints *constraints = rdev->constraints;
3802
3803         /* Limit voltage change only if necessary */
3804         if (!constraints->max_uV_step || !_regulator_is_enabled(rdev))
3805                 return 1;
3806
3807         if (*current_uV < 0) {
3808                 *current_uV = regulator_get_voltage_rdev(rdev);
3809
3810                 if (*current_uV < 0)
3811                         return *current_uV;
3812         }
3813
3814         if (abs(*current_uV - *min_uV) <= constraints->max_uV_step)
3815                 return 1;
3816
3817         /* Clamp target voltage within the given step */
3818         if (*current_uV < *min_uV)
3819                 *min_uV = min(*current_uV + constraints->max_uV_step,
3820                               *min_uV);
3821         else
3822                 *min_uV = max(*current_uV - constraints->max_uV_step,
3823                               *min_uV);
3824
3825         return 0;
3826 }
3827
3828 static int regulator_get_optimal_voltage(struct regulator_dev *rdev,
3829                                          int *current_uV,
3830                                          int *min_uV, int *max_uV,
3831                                          suspend_state_t state,
3832                                          int n_coupled)
3833 {
3834         struct coupling_desc *c_desc = &rdev->coupling_desc;
3835         struct regulator_dev **c_rdevs = c_desc->coupled_rdevs;
3836         struct regulation_constraints *constraints = rdev->constraints;
3837         int desired_min_uV = 0, desired_max_uV = INT_MAX;
3838         int max_current_uV = 0, min_current_uV = INT_MAX;
3839         int highest_min_uV = 0, target_uV, possible_uV;
3840         int i, ret, max_spread;
3841         bool done;
3842
3843         *current_uV = -1;
3844
3845         /*
3846          * If there are no coupled regulators, simply set the voltage
3847          * demanded by consumers.
3848          */
3849         if (n_coupled == 1) {
3850                 /*
3851                  * If consumers don't provide any demands, set voltage
3852                  * to min_uV
3853                  */
3854                 desired_min_uV = constraints->min_uV;
3855                 desired_max_uV = constraints->max_uV;
3856
3857                 ret = regulator_check_consumers(rdev,
3858                                                 &desired_min_uV,
3859                                                 &desired_max_uV, state);
3860                 if (ret < 0)
3861                         return ret;
3862
3863                 possible_uV = desired_min_uV;
3864                 done = true;
3865
3866                 goto finish;
3867         }
3868
3869         /* Find highest min desired voltage */
3870         for (i = 0; i < n_coupled; i++) {
3871                 int tmp_min = 0;
3872                 int tmp_max = INT_MAX;
3873
3874                 lockdep_assert_held_once(&c_rdevs[i]->mutex.base);
3875
3876                 ret = regulator_check_consumers(c_rdevs[i],
3877                                                 &tmp_min,
3878                                                 &tmp_max, state);
3879                 if (ret < 0)
3880                         return ret;
3881
3882                 ret = regulator_check_voltage(c_rdevs[i], &tmp_min, &tmp_max);
3883                 if (ret < 0)
3884                         return ret;
3885
3886                 highest_min_uV = max(highest_min_uV, tmp_min);
3887
3888                 if (i == 0) {
3889                         desired_min_uV = tmp_min;
3890                         desired_max_uV = tmp_max;
3891                 }
3892         }
3893
3894         max_spread = constraints->max_spread[0];
3895
3896         /*
3897          * Let target_uV be equal to the desired one if possible.
3898          * If not, set it to minimum voltage, allowed by other coupled
3899          * regulators.
3900          */
3901         target_uV = max(desired_min_uV, highest_min_uV - max_spread);
3902
3903         /*
3904          * Find min and max voltages, which currently aren't violating
3905          * max_spread.
3906          */
3907         for (i = 1; i < n_coupled; i++) {
3908                 int tmp_act;
3909
3910                 if (!_regulator_is_enabled(c_rdevs[i]))
3911                         continue;
3912
3913                 tmp_act = regulator_get_voltage_rdev(c_rdevs[i]);
3914                 if (tmp_act < 0)
3915                         return tmp_act;
3916
3917                 min_current_uV = min(tmp_act, min_current_uV);
3918                 max_current_uV = max(tmp_act, max_current_uV);
3919         }
3920
3921         /* There aren't any other regulators enabled */
3922         if (max_current_uV == 0) {
3923                 possible_uV = target_uV;
3924         } else {
3925                 /*
3926                  * Correct target voltage, so as it currently isn't
3927                  * violating max_spread
3928                  */
3929                 possible_uV = max(target_uV, max_current_uV - max_spread);
3930                 possible_uV = min(possible_uV, min_current_uV + max_spread);
3931         }
3932
3933         if (possible_uV > desired_max_uV)
3934                 return -EINVAL;
3935
3936         done = (possible_uV == target_uV);
3937         desired_min_uV = possible_uV;
3938
3939 finish:
3940         /* Apply max_uV_step constraint if necessary */
3941         if (state == PM_SUSPEND_ON) {
3942                 ret = regulator_limit_voltage_step(rdev, current_uV,
3943                                                    &desired_min_uV);
3944                 if (ret < 0)
3945                         return ret;
3946
3947                 if (ret == 0)
3948                         done = false;
3949         }
3950
3951         /* Set current_uV if wasn't done earlier in the code and if necessary */
3952         if (n_coupled > 1 && *current_uV == -1) {
3953
3954                 if (_regulator_is_enabled(rdev)) {
3955                         ret = regulator_get_voltage_rdev(rdev);
3956                         if (ret < 0)
3957                                 return ret;
3958
3959                         *current_uV = ret;
3960                 } else {
3961                         *current_uV = desired_min_uV;
3962                 }
3963         }
3964
3965         *min_uV = desired_min_uV;
3966         *max_uV = desired_max_uV;
3967
3968         return done;
3969 }
3970
3971 int regulator_do_balance_voltage(struct regulator_dev *rdev,
3972                                  suspend_state_t state, bool skip_coupled)
3973 {
3974         struct regulator_dev **c_rdevs;
3975         struct regulator_dev *best_rdev;
3976         struct coupling_desc *c_desc = &rdev->coupling_desc;
3977         int i, ret, n_coupled, best_min_uV, best_max_uV, best_c_rdev;
3978         unsigned int delta, best_delta;
3979         unsigned long c_rdev_done = 0;
3980         bool best_c_rdev_done;
3981
3982         c_rdevs = c_desc->coupled_rdevs;
3983         n_coupled = skip_coupled ? 1 : c_desc->n_coupled;
3984
3985         /*
3986          * Find the best possible voltage change on each loop. Leave the loop
3987          * if there isn't any possible change.
3988          */
3989         do {
3990                 best_c_rdev_done = false;
3991                 best_delta = 0;
3992                 best_min_uV = 0;
3993                 best_max_uV = 0;
3994                 best_c_rdev = 0;
3995                 best_rdev = NULL;
3996
3997                 /*
3998                  * Find highest difference between optimal voltage
3999                  * and current voltage.
4000                  */
4001                 for (i = 0; i < n_coupled; i++) {
4002                         /*
4003                          * optimal_uV is the best voltage that can be set for
4004                          * i-th regulator at the moment without violating
4005                          * max_spread constraint in order to balance
4006                          * the coupled voltages.
4007                          */
4008                         int optimal_uV = 0, optimal_max_uV = 0, current_uV = 0;
4009
4010                         if (test_bit(i, &c_rdev_done))
4011                                 continue;
4012
4013                         ret = regulator_get_optimal_voltage(c_rdevs[i],
4014                                                             &current_uV,
4015                                                             &optimal_uV,
4016                                                             &optimal_max_uV,
4017                                                             state, n_coupled);
4018                         if (ret < 0)
4019                                 goto out;
4020
4021                         delta = abs(optimal_uV - current_uV);
4022
4023                         if (delta && best_delta <= delta) {
4024                                 best_c_rdev_done = ret;
4025                                 best_delta = delta;
4026                                 best_rdev = c_rdevs[i];
4027                                 best_min_uV = optimal_uV;
4028                                 best_max_uV = optimal_max_uV;
4029                                 best_c_rdev = i;
4030                         }
4031                 }
4032
4033                 /* Nothing to change, return successfully */
4034                 if (!best_rdev) {
4035                         ret = 0;
4036                         goto out;
4037                 }
4038
4039                 ret = regulator_set_voltage_rdev(best_rdev, best_min_uV,
4040                                                  best_max_uV, state);
4041
4042                 if (ret < 0)
4043                         goto out;
4044
4045                 if (best_c_rdev_done)
4046                         set_bit(best_c_rdev, &c_rdev_done);
4047
4048         } while (n_coupled > 1);
4049
4050 out:
4051         return ret;
4052 }
4053
4054 static int regulator_balance_voltage(struct regulator_dev *rdev,
4055                                      suspend_state_t state)
4056 {
4057         struct coupling_desc *c_desc = &rdev->coupling_desc;
4058         struct regulator_coupler *coupler = c_desc->coupler;
4059         bool skip_coupled = false;
4060
4061         /*
4062          * If system is in a state other than PM_SUSPEND_ON, don't check
4063          * other coupled regulators.
4064          */
4065         if (state != PM_SUSPEND_ON)
4066                 skip_coupled = true;
4067
4068         if (c_desc->n_resolved < c_desc->n_coupled) {
4069                 rdev_err(rdev, "Not all coupled regulators registered\n");
4070                 return -EPERM;
4071         }
4072
4073         /* Invoke custom balancer for customized couplers */
4074         if (coupler && coupler->balance_voltage)
4075                 return coupler->balance_voltage(coupler, rdev, state);
4076
4077         return regulator_do_balance_voltage(rdev, state, skip_coupled);
4078 }
4079
4080 /**
4081  * regulator_set_voltage - set regulator output voltage
4082  * @regulator: regulator source
4083  * @min_uV: Minimum required voltage in uV
4084  * @max_uV: Maximum acceptable voltage in uV
4085  *
4086  * Sets a voltage regulator to the desired output voltage. This can be set
4087  * during any regulator state. IOW, regulator can be disabled or enabled.
4088  *
4089  * If the regulator is enabled then the voltage will change to the new value
4090  * immediately otherwise if the regulator is disabled the regulator will
4091  * output at the new voltage when enabled.
4092  *
4093  * NOTE: If the regulator is shared between several devices then the lowest
4094  * request voltage that meets the system constraints will be used.
4095  * Regulator system constraints must be set for this regulator before
4096  * calling this function otherwise this call will fail.
4097  */
4098 int regulator_set_voltage(struct regulator *regulator, int min_uV, int max_uV)
4099 {
4100         struct ww_acquire_ctx ww_ctx;
4101         int ret;
4102
4103         regulator_lock_dependent(regulator->rdev, &ww_ctx);
4104
4105         ret = regulator_set_voltage_unlocked(regulator, min_uV, max_uV,
4106                                              PM_SUSPEND_ON);
4107
4108         regulator_unlock_dependent(regulator->rdev, &ww_ctx);
4109
4110         return ret;
4111 }
4112 EXPORT_SYMBOL_GPL(regulator_set_voltage);
4113
4114 static inline int regulator_suspend_toggle(struct regulator_dev *rdev,
4115                                            suspend_state_t state, bool en)
4116 {
4117         struct regulator_state *rstate;
4118
4119         rstate = regulator_get_suspend_state(rdev, state);
4120         if (rstate == NULL)
4121                 return -EINVAL;
4122
4123         if (!rstate->changeable)
4124                 return -EPERM;
4125
4126         rstate->enabled = (en) ? ENABLE_IN_SUSPEND : DISABLE_IN_SUSPEND;
4127
4128         return 0;
4129 }
4130
4131 int regulator_suspend_enable(struct regulator_dev *rdev,
4132                                     suspend_state_t state)
4133 {
4134         return regulator_suspend_toggle(rdev, state, true);
4135 }
4136 EXPORT_SYMBOL_GPL(regulator_suspend_enable);
4137
4138 int regulator_suspend_disable(struct regulator_dev *rdev,
4139                                      suspend_state_t state)
4140 {
4141         struct regulator *regulator;
4142         struct regulator_voltage *voltage;
4143
4144         /*
4145          * if any consumer wants this regulator device keeping on in
4146          * suspend states, don't set it as disabled.
4147          */
4148         list_for_each_entry(regulator, &rdev->consumer_list, list) {
4149                 voltage = &regulator->voltage[state];
4150                 if (voltage->min_uV || voltage->max_uV)
4151                         return 0;
4152         }
4153
4154         return regulator_suspend_toggle(rdev, state, false);
4155 }
4156 EXPORT_SYMBOL_GPL(regulator_suspend_disable);
4157
4158 static int _regulator_set_suspend_voltage(struct regulator *regulator,
4159                                           int min_uV, int max_uV,
4160                                           suspend_state_t state)
4161 {
4162         struct regulator_dev *rdev = regulator->rdev;
4163         struct regulator_state *rstate;
4164
4165         rstate = regulator_get_suspend_state(rdev, state);
4166         if (rstate == NULL)
4167                 return -EINVAL;
4168
4169         if (rstate->min_uV == rstate->max_uV) {
4170                 rdev_err(rdev, "The suspend voltage can't be changed!\n");
4171                 return -EPERM;
4172         }
4173
4174         return regulator_set_voltage_unlocked(regulator, min_uV, max_uV, state);
4175 }
4176
4177 int regulator_set_suspend_voltage(struct regulator *regulator, int min_uV,
4178                                   int max_uV, suspend_state_t state)
4179 {
4180         struct ww_acquire_ctx ww_ctx;
4181         int ret;
4182
4183         /* PM_SUSPEND_ON is handled by regulator_set_voltage() */
4184         if (regulator_check_states(state) || state == PM_SUSPEND_ON)
4185                 return -EINVAL;
4186
4187         regulator_lock_dependent(regulator->rdev, &ww_ctx);
4188
4189         ret = _regulator_set_suspend_voltage(regulator, min_uV,
4190                                              max_uV, state);
4191
4192         regulator_unlock_dependent(regulator->rdev, &ww_ctx);
4193
4194         return ret;
4195 }
4196 EXPORT_SYMBOL_GPL(regulator_set_suspend_voltage);
4197
4198 /**
4199  * regulator_set_voltage_time - get raise/fall time
4200  * @regulator: regulator source
4201  * @old_uV: starting voltage in microvolts
4202  * @new_uV: target voltage in microvolts
4203  *
4204  * Provided with the starting and ending voltage, this function attempts to
4205  * calculate the time in microseconds required to rise or fall to this new
4206  * voltage.
4207  */
4208 int regulator_set_voltage_time(struct regulator *regulator,
4209                                int old_uV, int new_uV)
4210 {
4211         struct regulator_dev *rdev = regulator->rdev;
4212         const struct regulator_ops *ops = rdev->desc->ops;
4213         int old_sel = -1;
4214         int new_sel = -1;
4215         int voltage;
4216         int i;
4217
4218         if (ops->set_voltage_time)
4219                 return ops->set_voltage_time(rdev, old_uV, new_uV);
4220         else if (!ops->set_voltage_time_sel)
4221                 return _regulator_set_voltage_time(rdev, old_uV, new_uV);
4222
4223         /* Currently requires operations to do this */
4224         if (!ops->list_voltage || !rdev->desc->n_voltages)
4225                 return -EINVAL;
4226
4227         for (i = 0; i < rdev->desc->n_voltages; i++) {
4228                 /* We only look for exact voltage matches here */
4229                 if (i < rdev->desc->linear_min_sel)
4230                         continue;
4231
4232                 if (old_sel >= 0 && new_sel >= 0)
4233                         break;
4234
4235                 voltage = regulator_list_voltage(regulator, i);
4236                 if (voltage < 0)
4237                         return -EINVAL;
4238                 if (voltage == 0)
4239                         continue;
4240                 if (voltage == old_uV)
4241                         old_sel = i;
4242                 if (voltage == new_uV)
4243                         new_sel = i;
4244         }
4245
4246         if (old_sel < 0 || new_sel < 0)
4247                 return -EINVAL;
4248
4249         return ops->set_voltage_time_sel(rdev, old_sel, new_sel);
4250 }
4251 EXPORT_SYMBOL_GPL(regulator_set_voltage_time);
4252
4253 /**
4254  * regulator_set_voltage_time_sel - get raise/fall time
4255  * @rdev: regulator source device
4256  * @old_selector: selector for starting voltage
4257  * @new_selector: selector for target voltage
4258  *
4259  * Provided with the starting and target voltage selectors, this function
4260  * returns time in microseconds required to rise or fall to this new voltage
4261  *
4262  * Drivers providing ramp_delay in regulation_constraints can use this as their
4263  * set_voltage_time_sel() operation.
4264  */
4265 int regulator_set_voltage_time_sel(struct regulator_dev *rdev,
4266                                    unsigned int old_selector,
4267                                    unsigned int new_selector)
4268 {
4269         int old_volt, new_volt;
4270
4271         /* sanity check */
4272         if (!rdev->desc->ops->list_voltage)
4273                 return -EINVAL;
4274
4275         old_volt = rdev->desc->ops->list_voltage(rdev, old_selector);
4276         new_volt = rdev->desc->ops->list_voltage(rdev, new_selector);
4277
4278         if (rdev->desc->ops->set_voltage_time)
4279                 return rdev->desc->ops->set_voltage_time(rdev, old_volt,
4280                                                          new_volt);
4281         else
4282                 return _regulator_set_voltage_time(rdev, old_volt, new_volt);
4283 }
4284 EXPORT_SYMBOL_GPL(regulator_set_voltage_time_sel);
4285
4286 int regulator_sync_voltage_rdev(struct regulator_dev *rdev)
4287 {
4288         int ret;
4289
4290         regulator_lock(rdev);
4291
4292         if (!rdev->desc->ops->set_voltage &&
4293             !rdev->desc->ops->set_voltage_sel) {
4294                 ret = -EINVAL;
4295                 goto out;
4296         }
4297
4298         /* balance only, if regulator is coupled */
4299         if (rdev->coupling_desc.n_coupled > 1)
4300                 ret = regulator_balance_voltage(rdev, PM_SUSPEND_ON);
4301         else
4302                 ret = -EOPNOTSUPP;
4303
4304 out:
4305         regulator_unlock(rdev);
4306         return ret;
4307 }
4308
4309 /**
4310  * regulator_sync_voltage - re-apply last regulator output voltage
4311  * @regulator: regulator source
4312  *
4313  * Re-apply the last configured voltage.  This is intended to be used
4314  * where some external control source the consumer is cooperating with
4315  * has caused the configured voltage to change.
4316  */
4317 int regulator_sync_voltage(struct regulator *regulator)
4318 {
4319         struct regulator_dev *rdev = regulator->rdev;
4320         struct regulator_voltage *voltage = &regulator->voltage[PM_SUSPEND_ON];
4321         int ret, min_uV, max_uV;
4322
4323         if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_VOLTAGE))
4324                 return 0;
4325
4326         regulator_lock(rdev);
4327
4328         if (!rdev->desc->ops->set_voltage &&
4329             !rdev->desc->ops->set_voltage_sel) {
4330                 ret = -EINVAL;
4331                 goto out;
4332         }
4333
4334         /* This is only going to work if we've had a voltage configured. */
4335         if (!voltage->min_uV && !voltage->max_uV) {
4336                 ret = -EINVAL;
4337                 goto out;
4338         }
4339
4340         min_uV = voltage->min_uV;
4341         max_uV = voltage->max_uV;
4342
4343         /* This should be a paranoia check... */
4344         ret = regulator_check_voltage(rdev, &min_uV, &max_uV);
4345         if (ret < 0)
4346                 goto out;
4347
4348         ret = regulator_check_consumers(rdev, &min_uV, &max_uV, 0);
4349         if (ret < 0)
4350                 goto out;
4351
4352         /* balance only, if regulator is coupled */
4353         if (rdev->coupling_desc.n_coupled > 1)
4354                 ret = regulator_balance_voltage(rdev, PM_SUSPEND_ON);
4355         else
4356                 ret = _regulator_do_set_voltage(rdev, min_uV, max_uV);
4357
4358 out:
4359         regulator_unlock(rdev);
4360         return ret;
4361 }
4362 EXPORT_SYMBOL_GPL(regulator_sync_voltage);
4363
4364 int regulator_get_voltage_rdev(struct regulator_dev *rdev)
4365 {
4366         int sel, ret;
4367         bool bypassed;
4368
4369         if (rdev->desc->ops->get_bypass) {
4370                 ret = rdev->desc->ops->get_bypass(rdev, &bypassed);
4371                 if (ret < 0)
4372                         return ret;
4373                 if (bypassed) {
4374                         /* if bypassed the regulator must have a supply */
4375                         if (!rdev->supply) {
4376                                 rdev_err(rdev,
4377                                          "bypassed regulator has no supply!\n");
4378                                 return -EPROBE_DEFER;
4379                         }
4380
4381                         return regulator_get_voltage_rdev(rdev->supply->rdev);
4382                 }
4383         }
4384
4385         if (rdev->desc->ops->get_voltage_sel) {
4386                 sel = rdev->desc->ops->get_voltage_sel(rdev);
4387                 if (sel < 0)
4388                         return sel;
4389                 ret = rdev->desc->ops->list_voltage(rdev, sel);
4390         } else if (rdev->desc->ops->get_voltage) {
4391                 ret = rdev->desc->ops->get_voltage(rdev);
4392         } else if (rdev->desc->ops->list_voltage) {
4393                 ret = rdev->desc->ops->list_voltage(rdev, 0);
4394         } else if (rdev->desc->fixed_uV && (rdev->desc->n_voltages == 1)) {
4395                 ret = rdev->desc->fixed_uV;
4396         } else if (rdev->supply) {
4397                 ret = regulator_get_voltage_rdev(rdev->supply->rdev);
4398         } else if (rdev->supply_name) {
4399                 return -EPROBE_DEFER;
4400         } else {
4401                 return -EINVAL;
4402         }
4403
4404         if (ret < 0)
4405                 return ret;
4406         return ret - rdev->constraints->uV_offset;
4407 }
4408 EXPORT_SYMBOL_GPL(regulator_get_voltage_rdev);
4409
4410 /**
4411  * regulator_get_voltage - get regulator output voltage
4412  * @regulator: regulator source
4413  *
4414  * This returns the current regulator voltage in uV.
4415  *
4416  * NOTE: If the regulator is disabled it will return the voltage value. This
4417  * function should not be used to determine regulator state.
4418  */
4419 int regulator_get_voltage(struct regulator *regulator)
4420 {
4421         struct ww_acquire_ctx ww_ctx;
4422         int ret;
4423
4424         regulator_lock_dependent(regulator->rdev, &ww_ctx);
4425         ret = regulator_get_voltage_rdev(regulator->rdev);
4426         regulator_unlock_dependent(regulator->rdev, &ww_ctx);
4427
4428         return ret;
4429 }
4430 EXPORT_SYMBOL_GPL(regulator_get_voltage);
4431
4432 /**
4433  * regulator_set_current_limit - set regulator output current limit
4434  * @regulator: regulator source
4435  * @min_uA: Minimum supported current in uA
4436  * @max_uA: Maximum supported current in uA
4437  *
4438  * Sets current sink to the desired output current. This can be set during
4439  * any regulator state. IOW, regulator can be disabled or enabled.
4440  *
4441  * If the regulator is enabled then the current will change to the new value
4442  * immediately otherwise if the regulator is disabled the regulator will
4443  * output at the new current when enabled.
4444  *
4445  * NOTE: Regulator system constraints must be set for this regulator before
4446  * calling this function otherwise this call will fail.
4447  */
4448 int regulator_set_current_limit(struct regulator *regulator,
4449                                int min_uA, int max_uA)
4450 {
4451         struct regulator_dev *rdev = regulator->rdev;
4452         int ret;
4453
4454         regulator_lock(rdev);
4455
4456         /* sanity check */
4457         if (!rdev->desc->ops->set_current_limit) {
4458                 ret = -EINVAL;
4459                 goto out;
4460         }
4461
4462         /* constraints check */
4463         ret = regulator_check_current_limit(rdev, &min_uA, &max_uA);
4464         if (ret < 0)
4465                 goto out;
4466
4467         ret = rdev->desc->ops->set_current_limit(rdev, min_uA, max_uA);
4468 out:
4469         regulator_unlock(rdev);
4470         return ret;
4471 }
4472 EXPORT_SYMBOL_GPL(regulator_set_current_limit);
4473
4474 static int _regulator_get_current_limit_unlocked(struct regulator_dev *rdev)
4475 {
4476         /* sanity check */
4477         if (!rdev->desc->ops->get_current_limit)
4478                 return -EINVAL;
4479
4480         return rdev->desc->ops->get_current_limit(rdev);
4481 }
4482
4483 static int _regulator_get_current_limit(struct regulator_dev *rdev)
4484 {
4485         int ret;
4486
4487         regulator_lock(rdev);
4488         ret = _regulator_get_current_limit_unlocked(rdev);
4489         regulator_unlock(rdev);
4490
4491         return ret;
4492 }
4493
4494 /**
4495  * regulator_get_current_limit - get regulator output current
4496  * @regulator: regulator source
4497  *
4498  * This returns the current supplied by the specified current sink in uA.
4499  *
4500  * NOTE: If the regulator is disabled it will return the current value. This
4501  * function should not be used to determine regulator state.
4502  */
4503 int regulator_get_current_limit(struct regulator *regulator)
4504 {
4505         return _regulator_get_current_limit(regulator->rdev);
4506 }
4507 EXPORT_SYMBOL_GPL(regulator_get_current_limit);
4508
4509 /**
4510  * regulator_set_mode - set regulator operating mode
4511  * @regulator: regulator source
4512  * @mode: operating mode - one of the REGULATOR_MODE constants
4513  *
4514  * Set regulator operating mode to increase regulator efficiency or improve
4515  * regulation performance.
4516  *
4517  * NOTE: Regulator system constraints must be set for this regulator before
4518  * calling this function otherwise this call will fail.
4519  */
4520 int regulator_set_mode(struct regulator *regulator, unsigned int mode)
4521 {
4522         struct regulator_dev *rdev = regulator->rdev;
4523         int ret;
4524         int regulator_curr_mode;
4525
4526         regulator_lock(rdev);
4527
4528         /* sanity check */
4529         if (!rdev->desc->ops->set_mode) {
4530                 ret = -EINVAL;
4531                 goto out;
4532         }
4533
4534         /* return if the same mode is requested */
4535         if (rdev->desc->ops->get_mode) {
4536                 regulator_curr_mode = rdev->desc->ops->get_mode(rdev);
4537                 if (regulator_curr_mode == mode) {
4538                         ret = 0;
4539                         goto out;
4540                 }
4541         }
4542
4543         /* constraints check */
4544         ret = regulator_mode_constrain(rdev, &mode);
4545         if (ret < 0)
4546                 goto out;
4547
4548         ret = rdev->desc->ops->set_mode(rdev, mode);
4549 out:
4550         regulator_unlock(rdev);
4551         return ret;
4552 }
4553 EXPORT_SYMBOL_GPL(regulator_set_mode);
4554
4555 static unsigned int _regulator_get_mode_unlocked(struct regulator_dev *rdev)
4556 {
4557         /* sanity check */
4558         if (!rdev->desc->ops->get_mode)
4559                 return -EINVAL;
4560
4561         return rdev->desc->ops->get_mode(rdev);
4562 }
4563
4564 static unsigned int _regulator_get_mode(struct regulator_dev *rdev)
4565 {
4566         int ret;
4567
4568         regulator_lock(rdev);
4569         ret = _regulator_get_mode_unlocked(rdev);
4570         regulator_unlock(rdev);
4571
4572         return ret;
4573 }
4574
4575 /**
4576  * regulator_get_mode - get regulator operating mode
4577  * @regulator: regulator source
4578  *
4579  * Get the current regulator operating mode.
4580  */
4581 unsigned int regulator_get_mode(struct regulator *regulator)
4582 {
4583         return _regulator_get_mode(regulator->rdev);
4584 }
4585 EXPORT_SYMBOL_GPL(regulator_get_mode);
4586
4587 static int rdev_get_cached_err_flags(struct regulator_dev *rdev)
4588 {
4589         int ret = 0;
4590
4591         if (rdev->use_cached_err) {
4592                 spin_lock(&rdev->err_lock);
4593                 ret = rdev->cached_err;
4594                 spin_unlock(&rdev->err_lock);
4595         }
4596         return ret;
4597 }
4598
4599 static int _regulator_get_error_flags(struct regulator_dev *rdev,
4600                                         unsigned int *flags)
4601 {
4602         int cached_flags, ret = 0;
4603
4604         regulator_lock(rdev);
4605
4606         cached_flags = rdev_get_cached_err_flags(rdev);
4607
4608         if (rdev->desc->ops->get_error_flags)
4609                 ret = rdev->desc->ops->get_error_flags(rdev, flags);
4610         else if (!rdev->use_cached_err)
4611                 ret = -EINVAL;
4612
4613         *flags |= cached_flags;
4614
4615         regulator_unlock(rdev);
4616
4617         return ret;
4618 }
4619
4620 /**
4621  * regulator_get_error_flags - get regulator error information
4622  * @regulator: regulator source
4623  * @flags: pointer to store error flags
4624  *
4625  * Get the current regulator error information.
4626  */
4627 int regulator_get_error_flags(struct regulator *regulator,
4628                                 unsigned int *flags)
4629 {
4630         return _regulator_get_error_flags(regulator->rdev, flags);
4631 }
4632 EXPORT_SYMBOL_GPL(regulator_get_error_flags);
4633
4634 /**
4635  * regulator_set_load - set regulator load
4636  * @regulator: regulator source
4637  * @uA_load: load current
4638  *
4639  * Notifies the regulator core of a new device load. This is then used by
4640  * DRMS (if enabled by constraints) to set the most efficient regulator
4641  * operating mode for the new regulator loading.
4642  *
4643  * Consumer devices notify their supply regulator of the maximum power
4644  * they will require (can be taken from device datasheet in the power
4645  * consumption tables) when they change operational status and hence power
4646  * state. Examples of operational state changes that can affect power
4647  * consumption are :-
4648  *
4649  *    o Device is opened / closed.
4650  *    o Device I/O is about to begin or has just finished.
4651  *    o Device is idling in between work.
4652  *
4653  * This information is also exported via sysfs to userspace.
4654  *
4655  * DRMS will sum the total requested load on the regulator and change
4656  * to the most efficient operating mode if platform constraints allow.
4657  *
4658  * NOTE: when a regulator consumer requests to have a regulator
4659  * disabled then any load that consumer requested no longer counts
4660  * toward the total requested load.  If the regulator is re-enabled
4661  * then the previously requested load will start counting again.
4662  *
4663  * If a regulator is an always-on regulator then an individual consumer's
4664  * load will still be removed if that consumer is fully disabled.
4665  *
4666  * On error a negative errno is returned.
4667  */
4668 int regulator_set_load(struct regulator *regulator, int uA_load)
4669 {
4670         struct regulator_dev *rdev = regulator->rdev;
4671         int old_uA_load;
4672         int ret = 0;
4673
4674         regulator_lock(rdev);
4675         old_uA_load = regulator->uA_load;
4676         regulator->uA_load = uA_load;
4677         if (regulator->enable_count && old_uA_load != uA_load) {
4678                 ret = drms_uA_update(rdev);
4679                 if (ret < 0)
4680                         regulator->uA_load = old_uA_load;
4681         }
4682         regulator_unlock(rdev);
4683
4684         return ret;
4685 }
4686 EXPORT_SYMBOL_GPL(regulator_set_load);
4687
4688 /**
4689  * regulator_allow_bypass - allow the regulator to go into bypass mode
4690  *
4691  * @regulator: Regulator to configure
4692  * @enable: enable or disable bypass mode
4693  *
4694  * Allow the regulator to go into bypass mode if all other consumers
4695  * for the regulator also enable bypass mode and the machine
4696  * constraints allow this.  Bypass mode means that the regulator is
4697  * simply passing the input directly to the output with no regulation.
4698  */
4699 int regulator_allow_bypass(struct regulator *regulator, bool enable)
4700 {
4701         struct regulator_dev *rdev = regulator->rdev;
4702         const char *name = rdev_get_name(rdev);
4703         int ret = 0;
4704
4705         if (!rdev->desc->ops->set_bypass)
4706                 return 0;
4707
4708         if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_BYPASS))
4709                 return 0;
4710
4711         regulator_lock(rdev);
4712
4713         if (enable && !regulator->bypass) {
4714                 rdev->bypass_count++;
4715
4716                 if (rdev->bypass_count == rdev->open_count) {
4717                         trace_regulator_bypass_enable(name);
4718
4719                         ret = rdev->desc->ops->set_bypass(rdev, enable);
4720                         if (ret != 0)
4721                                 rdev->bypass_count--;
4722                         else
4723                                 trace_regulator_bypass_enable_complete(name);
4724                 }
4725
4726         } else if (!enable && regulator->bypass) {
4727                 rdev->bypass_count--;
4728
4729                 if (rdev->bypass_count != rdev->open_count) {
4730                         trace_regulator_bypass_disable(name);
4731
4732                         ret = rdev->desc->ops->set_bypass(rdev, enable);
4733                         if (ret != 0)
4734                                 rdev->bypass_count++;
4735                         else
4736                                 trace_regulator_bypass_disable_complete(name);
4737                 }
4738         }
4739
4740         if (ret == 0)
4741                 regulator->bypass = enable;
4742
4743         regulator_unlock(rdev);
4744
4745         return ret;
4746 }
4747 EXPORT_SYMBOL_GPL(regulator_allow_bypass);
4748
4749 /**
4750  * regulator_register_notifier - register regulator event notifier
4751  * @regulator: regulator source
4752  * @nb: notifier block
4753  *
4754  * Register notifier block to receive regulator events.
4755  */
4756 int regulator_register_notifier(struct regulator *regulator,
4757                               struct notifier_block *nb)
4758 {
4759         return blocking_notifier_chain_register(&regulator->rdev->notifier,
4760                                                 nb);
4761 }
4762 EXPORT_SYMBOL_GPL(regulator_register_notifier);
4763
4764 /**
4765  * regulator_unregister_notifier - unregister regulator event notifier
4766  * @regulator: regulator source
4767  * @nb: notifier block
4768  *
4769  * Unregister regulator event notifier block.
4770  */
4771 int regulator_unregister_notifier(struct regulator *regulator,
4772                                 struct notifier_block *nb)
4773 {
4774         return blocking_notifier_chain_unregister(&regulator->rdev->notifier,
4775                                                   nb);
4776 }
4777 EXPORT_SYMBOL_GPL(regulator_unregister_notifier);
4778
4779 /* notify regulator consumers and downstream regulator consumers.
4780  * Note mutex must be held by caller.
4781  */
4782 static int _notifier_call_chain(struct regulator_dev *rdev,
4783                                   unsigned long event, void *data)
4784 {
4785         /* call rdev chain first */
4786         return blocking_notifier_call_chain(&rdev->notifier, event, data);
4787 }
4788
4789 int _regulator_bulk_get(struct device *dev, int num_consumers,
4790                         struct regulator_bulk_data *consumers, enum regulator_get_type get_type)
4791 {
4792         int i;
4793         int ret;
4794
4795         for (i = 0; i < num_consumers; i++)
4796                 consumers[i].consumer = NULL;
4797
4798         for (i = 0; i < num_consumers; i++) {
4799                 consumers[i].consumer = _regulator_get(dev,
4800                                                        consumers[i].supply, get_type);
4801                 if (IS_ERR(consumers[i].consumer)) {
4802                         ret = dev_err_probe(dev, PTR_ERR(consumers[i].consumer),
4803                                             "Failed to get supply '%s'",
4804                                             consumers[i].supply);
4805                         consumers[i].consumer = NULL;
4806                         goto err;
4807                 }
4808
4809                 if (consumers[i].init_load_uA > 0) {
4810                         ret = regulator_set_load(consumers[i].consumer,
4811                                                  consumers[i].init_load_uA);
4812                         if (ret) {
4813                                 i++;
4814                                 goto err;
4815                         }
4816                 }
4817         }
4818
4819         return 0;
4820
4821 err:
4822         while (--i >= 0)
4823                 regulator_put(consumers[i].consumer);
4824
4825         return ret;
4826 }
4827
4828 /**
4829  * regulator_bulk_get - get multiple regulator consumers
4830  *
4831  * @dev:           Device to supply
4832  * @num_consumers: Number of consumers to register
4833  * @consumers:     Configuration of consumers; clients are stored here.
4834  *
4835  * @return 0 on success, an errno on failure.
4836  *
4837  * This helper function allows drivers to get several regulator
4838  * consumers in one operation.  If any of the regulators cannot be
4839  * acquired then any regulators that were allocated will be freed
4840  * before returning to the caller.
4841  */
4842 int regulator_bulk_get(struct device *dev, int num_consumers,
4843                        struct regulator_bulk_data *consumers)
4844 {
4845         return _regulator_bulk_get(dev, num_consumers, consumers, NORMAL_GET);
4846 }
4847 EXPORT_SYMBOL_GPL(regulator_bulk_get);
4848
4849 static void regulator_bulk_enable_async(void *data, async_cookie_t cookie)
4850 {
4851         struct regulator_bulk_data *bulk = data;
4852
4853         bulk->ret = regulator_enable(bulk->consumer);
4854 }
4855
4856 /**
4857  * regulator_bulk_enable - enable multiple regulator consumers
4858  *
4859  * @num_consumers: Number of consumers
4860  * @consumers:     Consumer data; clients are stored here.
4861  * @return         0 on success, an errno on failure
4862  *
4863  * This convenience API allows consumers to enable multiple regulator
4864  * clients in a single API call.  If any consumers cannot be enabled
4865  * then any others that were enabled will be disabled again prior to
4866  * return.
4867  */
4868 int regulator_bulk_enable(int num_consumers,
4869                           struct regulator_bulk_data *consumers)
4870 {
4871         ASYNC_DOMAIN_EXCLUSIVE(async_domain);
4872         int i;
4873         int ret = 0;
4874
4875         for (i = 0; i < num_consumers; i++) {
4876                 async_schedule_domain(regulator_bulk_enable_async,
4877                                       &consumers[i], &async_domain);
4878         }
4879
4880         async_synchronize_full_domain(&async_domain);
4881
4882         /* If any consumer failed we need to unwind any that succeeded */
4883         for (i = 0; i < num_consumers; i++) {
4884                 if (consumers[i].ret != 0) {
4885                         ret = consumers[i].ret;
4886                         goto err;
4887                 }
4888         }
4889
4890         return 0;
4891
4892 err:
4893         for (i = 0; i < num_consumers; i++) {
4894                 if (consumers[i].ret < 0)
4895                         pr_err("Failed to enable %s: %pe\n", consumers[i].supply,
4896                                ERR_PTR(consumers[i].ret));
4897                 else
4898                         regulator_disable(consumers[i].consumer);
4899         }
4900
4901         return ret;
4902 }
4903 EXPORT_SYMBOL_GPL(regulator_bulk_enable);
4904
4905 /**
4906  * regulator_bulk_disable - disable multiple regulator consumers
4907  *
4908  * @num_consumers: Number of consumers
4909  * @consumers:     Consumer data; clients are stored here.
4910  * @return         0 on success, an errno on failure
4911  *
4912  * This convenience API allows consumers to disable multiple regulator
4913  * clients in a single API call.  If any consumers cannot be disabled
4914  * then any others that were disabled will be enabled again prior to
4915  * return.
4916  */
4917 int regulator_bulk_disable(int num_consumers,
4918                            struct regulator_bulk_data *consumers)
4919 {
4920         int i;
4921         int ret, r;
4922
4923         for (i = num_consumers - 1; i >= 0; --i) {
4924                 ret = regulator_disable(consumers[i].consumer);
4925                 if (ret != 0)
4926                         goto err;
4927         }
4928
4929         return 0;
4930
4931 err:
4932         pr_err("Failed to disable %s: %pe\n", consumers[i].supply, ERR_PTR(ret));
4933         for (++i; i < num_consumers; ++i) {
4934                 r = regulator_enable(consumers[i].consumer);
4935                 if (r != 0)
4936                         pr_err("Failed to re-enable %s: %pe\n",
4937                                consumers[i].supply, ERR_PTR(r));
4938         }
4939
4940         return ret;
4941 }
4942 EXPORT_SYMBOL_GPL(regulator_bulk_disable);
4943
4944 /**
4945  * regulator_bulk_force_disable - force disable multiple regulator consumers
4946  *
4947  * @num_consumers: Number of consumers
4948  * @consumers:     Consumer data; clients are stored here.
4949  * @return         0 on success, an errno on failure
4950  *
4951  * This convenience API allows consumers to forcibly disable multiple regulator
4952  * clients in a single API call.
4953  * NOTE: This should be used for situations when device damage will
4954  * likely occur if the regulators are not disabled (e.g. over temp).
4955  * Although regulator_force_disable function call for some consumers can
4956  * return error numbers, the function is called for all consumers.
4957  */
4958 int regulator_bulk_force_disable(int num_consumers,
4959                            struct regulator_bulk_data *consumers)
4960 {
4961         int i;
4962         int ret = 0;
4963
4964         for (i = 0; i < num_consumers; i++) {
4965                 consumers[i].ret =
4966                             regulator_force_disable(consumers[i].consumer);
4967
4968                 /* Store first error for reporting */
4969                 if (consumers[i].ret && !ret)
4970                         ret = consumers[i].ret;
4971         }
4972
4973         return ret;
4974 }
4975 EXPORT_SYMBOL_GPL(regulator_bulk_force_disable);
4976
4977 /**
4978  * regulator_bulk_free - free multiple regulator consumers
4979  *
4980  * @num_consumers: Number of consumers
4981  * @consumers:     Consumer data; clients are stored here.
4982  *
4983  * This convenience API allows consumers to free multiple regulator
4984  * clients in a single API call.
4985  */
4986 void regulator_bulk_free(int num_consumers,
4987                          struct regulator_bulk_data *consumers)
4988 {
4989         int i;
4990
4991         for (i = 0; i < num_consumers; i++) {
4992                 regulator_put(consumers[i].consumer);
4993                 consumers[i].consumer = NULL;
4994         }
4995 }
4996 EXPORT_SYMBOL_GPL(regulator_bulk_free);
4997
4998 /**
4999  * regulator_notifier_call_chain - call regulator event notifier
5000  * @rdev: regulator source
5001  * @event: notifier block
5002  * @data: callback-specific data.
5003  *
5004  * Called by regulator drivers to notify clients a regulator event has
5005  * occurred.
5006  */
5007 int regulator_notifier_call_chain(struct regulator_dev *rdev,
5008                                   unsigned long event, void *data)
5009 {
5010         _notifier_call_chain(rdev, event, data);
5011         return NOTIFY_DONE;
5012
5013 }
5014 EXPORT_SYMBOL_GPL(regulator_notifier_call_chain);
5015
5016 /**
5017  * regulator_mode_to_status - convert a regulator mode into a status
5018  *
5019  * @mode: Mode to convert
5020  *
5021  * Convert a regulator mode into a status.
5022  */
5023 int regulator_mode_to_status(unsigned int mode)
5024 {
5025         switch (mode) {
5026         case REGULATOR_MODE_FAST:
5027                 return REGULATOR_STATUS_FAST;
5028         case REGULATOR_MODE_NORMAL:
5029                 return REGULATOR_STATUS_NORMAL;
5030         case REGULATOR_MODE_IDLE:
5031                 return REGULATOR_STATUS_IDLE;
5032         case REGULATOR_MODE_STANDBY:
5033                 return REGULATOR_STATUS_STANDBY;
5034         default:
5035                 return REGULATOR_STATUS_UNDEFINED;
5036         }
5037 }
5038 EXPORT_SYMBOL_GPL(regulator_mode_to_status);
5039
5040 static struct attribute *regulator_dev_attrs[] = {
5041         &dev_attr_name.attr,
5042         &dev_attr_num_users.attr,
5043         &dev_attr_type.attr,
5044         &dev_attr_microvolts.attr,
5045         &dev_attr_microamps.attr,
5046         &dev_attr_opmode.attr,
5047         &dev_attr_state.attr,
5048         &dev_attr_status.attr,
5049         &dev_attr_bypass.attr,
5050         &dev_attr_requested_microamps.attr,
5051         &dev_attr_min_microvolts.attr,
5052         &dev_attr_max_microvolts.attr,
5053         &dev_attr_min_microamps.attr,
5054         &dev_attr_max_microamps.attr,
5055         &dev_attr_under_voltage.attr,
5056         &dev_attr_over_current.attr,
5057         &dev_attr_regulation_out.attr,
5058         &dev_attr_fail.attr,
5059         &dev_attr_over_temp.attr,
5060         &dev_attr_under_voltage_warn.attr,
5061         &dev_attr_over_current_warn.attr,
5062         &dev_attr_over_voltage_warn.attr,
5063         &dev_attr_over_temp_warn.attr,
5064         &dev_attr_suspend_standby_state.attr,
5065         &dev_attr_suspend_mem_state.attr,
5066         &dev_attr_suspend_disk_state.attr,
5067         &dev_attr_suspend_standby_microvolts.attr,
5068         &dev_attr_suspend_mem_microvolts.attr,
5069         &dev_attr_suspend_disk_microvolts.attr,
5070         &dev_attr_suspend_standby_mode.attr,
5071         &dev_attr_suspend_mem_mode.attr,
5072         &dev_attr_suspend_disk_mode.attr,
5073         NULL
5074 };
5075
5076 /*
5077  * To avoid cluttering sysfs (and memory) with useless state, only
5078  * create attributes that can be meaningfully displayed.
5079  */
5080 static umode_t regulator_attr_is_visible(struct kobject *kobj,
5081                                          struct attribute *attr, int idx)
5082 {
5083         struct device *dev = kobj_to_dev(kobj);
5084         struct regulator_dev *rdev = dev_to_rdev(dev);
5085         const struct regulator_ops *ops = rdev->desc->ops;
5086         umode_t mode = attr->mode;
5087
5088         /* these three are always present */
5089         if (attr == &dev_attr_name.attr ||
5090             attr == &dev_attr_num_users.attr ||
5091             attr == &dev_attr_type.attr)
5092                 return mode;
5093
5094         /* some attributes need specific methods to be displayed */
5095         if (attr == &dev_attr_microvolts.attr) {
5096                 if ((ops->get_voltage && ops->get_voltage(rdev) >= 0) ||
5097                     (ops->get_voltage_sel && ops->get_voltage_sel(rdev) >= 0) ||
5098                     (ops->list_voltage && ops->list_voltage(rdev, 0) >= 0) ||
5099                     (rdev->desc->fixed_uV && rdev->desc->n_voltages == 1))
5100                         return mode;
5101                 return 0;
5102         }
5103
5104         if (attr == &dev_attr_microamps.attr)
5105                 return ops->get_current_limit ? mode : 0;
5106
5107         if (attr == &dev_attr_opmode.attr)
5108                 return ops->get_mode ? mode : 0;
5109
5110         if (attr == &dev_attr_state.attr)
5111                 return (rdev->ena_pin || ops->is_enabled) ? mode : 0;
5112
5113         if (attr == &dev_attr_status.attr)
5114                 return ops->get_status ? mode : 0;
5115
5116         if (attr == &dev_attr_bypass.attr)
5117                 return ops->get_bypass ? mode : 0;
5118
5119         if (attr == &dev_attr_under_voltage.attr ||
5120             attr == &dev_attr_over_current.attr ||
5121             attr == &dev_attr_regulation_out.attr ||
5122             attr == &dev_attr_fail.attr ||
5123             attr == &dev_attr_over_temp.attr ||
5124             attr == &dev_attr_under_voltage_warn.attr ||
5125             attr == &dev_attr_over_current_warn.attr ||
5126             attr == &dev_attr_over_voltage_warn.attr ||
5127             attr == &dev_attr_over_temp_warn.attr)
5128                 return ops->get_error_flags ? mode : 0;
5129
5130         /* constraints need specific supporting methods */
5131         if (attr == &dev_attr_min_microvolts.attr ||
5132             attr == &dev_attr_max_microvolts.attr)
5133                 return (ops->set_voltage || ops->set_voltage_sel) ? mode : 0;
5134
5135         if (attr == &dev_attr_min_microamps.attr ||
5136             attr == &dev_attr_max_microamps.attr)
5137                 return ops->set_current_limit ? mode : 0;
5138
5139         if (attr == &dev_attr_suspend_standby_state.attr ||
5140             attr == &dev_attr_suspend_mem_state.attr ||
5141             attr == &dev_attr_suspend_disk_state.attr)
5142                 return mode;
5143
5144         if (attr == &dev_attr_suspend_standby_microvolts.attr ||
5145             attr == &dev_attr_suspend_mem_microvolts.attr ||
5146             attr == &dev_attr_suspend_disk_microvolts.attr)
5147                 return ops->set_suspend_voltage ? mode : 0;
5148
5149         if (attr == &dev_attr_suspend_standby_mode.attr ||
5150             attr == &dev_attr_suspend_mem_mode.attr ||
5151             attr == &dev_attr_suspend_disk_mode.attr)
5152                 return ops->set_suspend_mode ? mode : 0;
5153
5154         return mode;
5155 }
5156
5157 static const struct attribute_group regulator_dev_group = {
5158         .attrs = regulator_dev_attrs,
5159         .is_visible = regulator_attr_is_visible,
5160 };
5161
5162 static const struct attribute_group *regulator_dev_groups[] = {
5163         &regulator_dev_group,
5164         NULL
5165 };
5166
5167 static void regulator_dev_release(struct device *dev)
5168 {
5169         struct regulator_dev *rdev = dev_get_drvdata(dev);
5170
5171         debugfs_remove_recursive(rdev->debugfs);
5172         kfree(rdev->constraints);
5173         of_node_put(rdev->dev.of_node);
5174         kfree(rdev);
5175 }
5176
5177 static void rdev_init_debugfs(struct regulator_dev *rdev)
5178 {
5179         struct device *parent = rdev->dev.parent;
5180         const char *rname = rdev_get_name(rdev);
5181         char name[NAME_MAX];
5182
5183         /* Avoid duplicate debugfs directory names */
5184         if (parent && rname == rdev->desc->name) {
5185                 snprintf(name, sizeof(name), "%s-%s", dev_name(parent),
5186                          rname);
5187                 rname = name;
5188         }
5189
5190         rdev->debugfs = debugfs_create_dir(rname, debugfs_root);
5191         if (!rdev->debugfs) {
5192                 rdev_warn(rdev, "Failed to create debugfs directory\n");
5193                 return;
5194         }
5195
5196         debugfs_create_u32("use_count", 0444, rdev->debugfs,
5197                            &rdev->use_count);
5198         debugfs_create_u32("open_count", 0444, rdev->debugfs,
5199                            &rdev->open_count);
5200         debugfs_create_u32("bypass_count", 0444, rdev->debugfs,
5201                            &rdev->bypass_count);
5202 }
5203
5204 static int regulator_register_resolve_supply(struct device *dev, void *data)
5205 {
5206         struct regulator_dev *rdev = dev_to_rdev(dev);
5207
5208         if (regulator_resolve_supply(rdev))
5209                 rdev_dbg(rdev, "unable to resolve supply\n");
5210
5211         return 0;
5212 }
5213
5214 int regulator_coupler_register(struct regulator_coupler *coupler)
5215 {
5216         mutex_lock(&regulator_list_mutex);
5217         list_add_tail(&coupler->list, &regulator_coupler_list);
5218         mutex_unlock(&regulator_list_mutex);
5219
5220         return 0;
5221 }
5222
5223 static struct regulator_coupler *
5224 regulator_find_coupler(struct regulator_dev *rdev)
5225 {
5226         struct regulator_coupler *coupler;
5227         int err;
5228
5229         /*
5230          * Note that regulators are appended to the list and the generic
5231          * coupler is registered first, hence it will be attached at last
5232          * if nobody cared.
5233          */
5234         list_for_each_entry_reverse(coupler, &regulator_coupler_list, list) {
5235                 err = coupler->attach_regulator(coupler, rdev);
5236                 if (!err) {
5237                         if (!coupler->balance_voltage &&
5238                             rdev->coupling_desc.n_coupled > 2)
5239                                 goto err_unsupported;
5240
5241                         return coupler;
5242                 }
5243
5244                 if (err < 0)
5245                         return ERR_PTR(err);
5246
5247                 if (err == 1)
5248                         continue;
5249
5250                 break;
5251         }
5252
5253         return ERR_PTR(-EINVAL);
5254
5255 err_unsupported:
5256         if (coupler->detach_regulator)
5257                 coupler->detach_regulator(coupler, rdev);
5258
5259         rdev_err(rdev,
5260                 "Voltage balancing for multiple regulator couples is unimplemented\n");
5261
5262         return ERR_PTR(-EPERM);
5263 }
5264
5265 static void regulator_resolve_coupling(struct regulator_dev *rdev)
5266 {
5267         struct regulator_coupler *coupler = rdev->coupling_desc.coupler;
5268         struct coupling_desc *c_desc = &rdev->coupling_desc;
5269         int n_coupled = c_desc->n_coupled;
5270         struct regulator_dev *c_rdev;
5271         int i;
5272
5273         for (i = 1; i < n_coupled; i++) {
5274                 /* already resolved */
5275                 if (c_desc->coupled_rdevs[i])
5276                         continue;
5277
5278                 c_rdev = of_parse_coupled_regulator(rdev, i - 1);
5279
5280                 if (!c_rdev)
5281                         continue;
5282
5283                 if (c_rdev->coupling_desc.coupler != coupler) {
5284                         rdev_err(rdev, "coupler mismatch with %s\n",
5285                                  rdev_get_name(c_rdev));
5286                         return;
5287                 }
5288
5289                 c_desc->coupled_rdevs[i] = c_rdev;
5290                 c_desc->n_resolved++;
5291
5292                 regulator_resolve_coupling(c_rdev);
5293         }
5294 }
5295
5296 static void regulator_remove_coupling(struct regulator_dev *rdev)
5297 {
5298         struct regulator_coupler *coupler = rdev->coupling_desc.coupler;
5299         struct coupling_desc *__c_desc, *c_desc = &rdev->coupling_desc;
5300         struct regulator_dev *__c_rdev, *c_rdev;
5301         unsigned int __n_coupled, n_coupled;
5302         int i, k;
5303         int err;
5304
5305         n_coupled = c_desc->n_coupled;
5306
5307         for (i = 1; i < n_coupled; i++) {
5308                 c_rdev = c_desc->coupled_rdevs[i];
5309
5310                 if (!c_rdev)
5311                         continue;
5312
5313                 regulator_lock(c_rdev);
5314
5315                 __c_desc = &c_rdev->coupling_desc;
5316                 __n_coupled = __c_desc->n_coupled;
5317
5318                 for (k = 1; k < __n_coupled; k++) {
5319                         __c_rdev = __c_desc->coupled_rdevs[k];
5320
5321                         if (__c_rdev == rdev) {
5322                                 __c_desc->coupled_rdevs[k] = NULL;
5323                                 __c_desc->n_resolved--;
5324                                 break;
5325                         }
5326                 }
5327
5328                 regulator_unlock(c_rdev);
5329
5330                 c_desc->coupled_rdevs[i] = NULL;
5331                 c_desc->n_resolved--;
5332         }
5333
5334         if (coupler && coupler->detach_regulator) {
5335                 err = coupler->detach_regulator(coupler, rdev);
5336                 if (err)
5337                         rdev_err(rdev, "failed to detach from coupler: %pe\n",
5338                                  ERR_PTR(err));
5339         }
5340
5341         kfree(rdev->coupling_desc.coupled_rdevs);
5342         rdev->coupling_desc.coupled_rdevs = NULL;
5343 }
5344
5345 static int regulator_init_coupling(struct regulator_dev *rdev)
5346 {
5347         struct regulator_dev **coupled;
5348         int err, n_phandles;
5349
5350         if (!IS_ENABLED(CONFIG_OF))
5351                 n_phandles = 0;
5352         else
5353                 n_phandles = of_get_n_coupled(rdev);
5354
5355         coupled = kcalloc(n_phandles + 1, sizeof(*coupled), GFP_KERNEL);
5356         if (!coupled)
5357                 return -ENOMEM;
5358
5359         rdev->coupling_desc.coupled_rdevs = coupled;
5360
5361         /*
5362          * Every regulator should always have coupling descriptor filled with
5363          * at least pointer to itself.
5364          */
5365         rdev->coupling_desc.coupled_rdevs[0] = rdev;
5366         rdev->coupling_desc.n_coupled = n_phandles + 1;
5367         rdev->coupling_desc.n_resolved++;
5368
5369         /* regulator isn't coupled */
5370         if (n_phandles == 0)
5371                 return 0;
5372
5373         if (!of_check_coupling_data(rdev))
5374                 return -EPERM;
5375
5376         mutex_lock(&regulator_list_mutex);
5377         rdev->coupling_desc.coupler = regulator_find_coupler(rdev);
5378         mutex_unlock(&regulator_list_mutex);
5379
5380         if (IS_ERR(rdev->coupling_desc.coupler)) {
5381                 err = PTR_ERR(rdev->coupling_desc.coupler);
5382                 rdev_err(rdev, "failed to get coupler: %pe\n", ERR_PTR(err));
5383                 return err;
5384         }
5385
5386         return 0;
5387 }
5388
5389 static int generic_coupler_attach(struct regulator_coupler *coupler,
5390                                   struct regulator_dev *rdev)
5391 {
5392         if (rdev->coupling_desc.n_coupled > 2) {
5393                 rdev_err(rdev,
5394                          "Voltage balancing for multiple regulator couples is unimplemented\n");
5395                 return -EPERM;
5396         }
5397
5398         if (!rdev->constraints->always_on) {
5399                 rdev_err(rdev,
5400                          "Coupling of a non always-on regulator is unimplemented\n");
5401                 return -ENOTSUPP;
5402         }
5403
5404         return 0;
5405 }
5406
5407 static struct regulator_coupler generic_regulator_coupler = {
5408         .attach_regulator = generic_coupler_attach,
5409 };
5410
5411 /**
5412  * regulator_register - register regulator
5413  * @dev: the device that drive the regulator
5414  * @regulator_desc: regulator to register
5415  * @cfg: runtime configuration for regulator
5416  *
5417  * Called by regulator drivers to register a regulator.
5418  * Returns a valid pointer to struct regulator_dev on success
5419  * or an ERR_PTR() on error.
5420  */
5421 struct regulator_dev *
5422 regulator_register(struct device *dev,
5423                    const struct regulator_desc *regulator_desc,
5424                    const struct regulator_config *cfg)
5425 {
5426         const struct regulator_init_data *init_data;
5427         struct regulator_config *config = NULL;
5428         static atomic_t regulator_no = ATOMIC_INIT(-1);
5429         struct regulator_dev *rdev;
5430         bool dangling_cfg_gpiod = false;
5431         bool dangling_of_gpiod = false;
5432         int ret, i;
5433         bool resolved_early = false;
5434
5435         if (cfg == NULL)
5436                 return ERR_PTR(-EINVAL);
5437         if (cfg->ena_gpiod)
5438                 dangling_cfg_gpiod = true;
5439         if (regulator_desc == NULL) {
5440                 ret = -EINVAL;
5441                 goto rinse;
5442         }
5443
5444         WARN_ON(!dev || !cfg->dev);
5445
5446         if (regulator_desc->name == NULL || regulator_desc->ops == NULL) {
5447                 ret = -EINVAL;
5448                 goto rinse;
5449         }
5450
5451         if (regulator_desc->type != REGULATOR_VOLTAGE &&
5452             regulator_desc->type != REGULATOR_CURRENT) {
5453                 ret = -EINVAL;
5454                 goto rinse;
5455         }
5456
5457         /* Only one of each should be implemented */
5458         WARN_ON(regulator_desc->ops->get_voltage &&
5459                 regulator_desc->ops->get_voltage_sel);
5460         WARN_ON(regulator_desc->ops->set_voltage &&
5461                 regulator_desc->ops->set_voltage_sel);
5462
5463         /* If we're using selectors we must implement list_voltage. */
5464         if (regulator_desc->ops->get_voltage_sel &&
5465             !regulator_desc->ops->list_voltage) {
5466                 ret = -EINVAL;
5467                 goto rinse;
5468         }
5469         if (regulator_desc->ops->set_voltage_sel &&
5470             !regulator_desc->ops->list_voltage) {
5471                 ret = -EINVAL;
5472                 goto rinse;
5473         }
5474
5475         rdev = kzalloc(sizeof(struct regulator_dev), GFP_KERNEL);
5476         if (rdev == NULL) {
5477                 ret = -ENOMEM;
5478                 goto rinse;
5479         }
5480         device_initialize(&rdev->dev);
5481         spin_lock_init(&rdev->err_lock);
5482
5483         /*
5484          * Duplicate the config so the driver could override it after
5485          * parsing init data.
5486          */
5487         config = kmemdup(cfg, sizeof(*cfg), GFP_KERNEL);
5488         if (config == NULL) {
5489                 ret = -ENOMEM;
5490                 goto clean;
5491         }
5492
5493         init_data = regulator_of_get_init_data(dev, regulator_desc, config,
5494                                                &rdev->dev.of_node);
5495
5496         /*
5497          * Sometimes not all resources are probed already so we need to take
5498          * that into account. This happens most the time if the ena_gpiod comes
5499          * from a gpio extender or something else.
5500          */
5501         if (PTR_ERR(init_data) == -EPROBE_DEFER) {
5502                 ret = -EPROBE_DEFER;
5503                 goto clean;
5504         }
5505
5506         /*
5507          * We need to keep track of any GPIO descriptor coming from the
5508          * device tree until we have handled it over to the core. If the
5509          * config that was passed in to this function DOES NOT contain
5510          * a descriptor, and the config after this call DOES contain
5511          * a descriptor, we definitely got one from parsing the device
5512          * tree.
5513          */
5514         if (!cfg->ena_gpiod && config->ena_gpiod)
5515                 dangling_of_gpiod = true;
5516         if (!init_data) {
5517                 init_data = config->init_data;
5518                 rdev->dev.of_node = of_node_get(config->of_node);
5519         }
5520
5521         ww_mutex_init(&rdev->mutex, &regulator_ww_class);
5522         rdev->reg_data = config->driver_data;
5523         rdev->owner = regulator_desc->owner;
5524         rdev->desc = regulator_desc;
5525         if (config->regmap)
5526                 rdev->regmap = config->regmap;
5527         else if (dev_get_regmap(dev, NULL))
5528                 rdev->regmap = dev_get_regmap(dev, NULL);
5529         else if (dev->parent)
5530                 rdev->regmap = dev_get_regmap(dev->parent, NULL);
5531         INIT_LIST_HEAD(&rdev->consumer_list);
5532         INIT_LIST_HEAD(&rdev->list);
5533         BLOCKING_INIT_NOTIFIER_HEAD(&rdev->notifier);
5534         INIT_DELAYED_WORK(&rdev->disable_work, regulator_disable_work);
5535
5536         if (init_data && init_data->supply_regulator)
5537                 rdev->supply_name = init_data->supply_regulator;
5538         else if (regulator_desc->supply_name)
5539                 rdev->supply_name = regulator_desc->supply_name;
5540
5541         /* register with sysfs */
5542         rdev->dev.class = &regulator_class;
5543         rdev->dev.parent = config->dev;
5544         dev_set_name(&rdev->dev, "regulator.%lu",
5545                     (unsigned long) atomic_inc_return(&regulator_no));
5546         dev_set_drvdata(&rdev->dev, rdev);
5547
5548         /* set regulator constraints */
5549         if (init_data)
5550                 rdev->constraints = kmemdup(&init_data->constraints,
5551                                             sizeof(*rdev->constraints),
5552                                             GFP_KERNEL);
5553         else
5554                 rdev->constraints = kzalloc(sizeof(*rdev->constraints),
5555                                             GFP_KERNEL);
5556         if (!rdev->constraints) {
5557                 ret = -ENOMEM;
5558                 goto wash;
5559         }
5560
5561         if ((rdev->supply_name && !rdev->supply) &&
5562                 (rdev->constraints->always_on ||
5563                  rdev->constraints->boot_on)) {
5564                 ret = regulator_resolve_supply(rdev);
5565                 if (ret)
5566                         rdev_dbg(rdev, "unable to resolve supply early: %pe\n",
5567                                          ERR_PTR(ret));
5568
5569                 resolved_early = true;
5570         }
5571
5572         /* perform any regulator specific init */
5573         if (init_data && init_data->regulator_init) {
5574                 ret = init_data->regulator_init(rdev->reg_data);
5575                 if (ret < 0)
5576                         goto wash;
5577         }
5578
5579         if (config->ena_gpiod) {
5580                 ret = regulator_ena_gpio_request(rdev, config);
5581                 if (ret != 0) {
5582                         rdev_err(rdev, "Failed to request enable GPIO: %pe\n",
5583                                  ERR_PTR(ret));
5584                         goto wash;
5585                 }
5586                 /* The regulator core took over the GPIO descriptor */
5587                 dangling_cfg_gpiod = false;
5588                 dangling_of_gpiod = false;
5589         }
5590
5591         ret = set_machine_constraints(rdev);
5592         if (ret == -EPROBE_DEFER && !resolved_early) {
5593                 /* Regulator might be in bypass mode and so needs its supply
5594                  * to set the constraints
5595                  */
5596                 /* FIXME: this currently triggers a chicken-and-egg problem
5597                  * when creating -SUPPLY symlink in sysfs to a regulator
5598                  * that is just being created
5599                  */
5600                 rdev_dbg(rdev, "will resolve supply early: %s\n",
5601                          rdev->supply_name);
5602                 ret = regulator_resolve_supply(rdev);
5603                 if (!ret)
5604                         ret = set_machine_constraints(rdev);
5605                 else
5606                         rdev_dbg(rdev, "unable to resolve supply early: %pe\n",
5607                                  ERR_PTR(ret));
5608         }
5609         if (ret < 0)
5610                 goto wash;
5611
5612         ret = regulator_init_coupling(rdev);
5613         if (ret < 0)
5614                 goto wash;
5615
5616         /* add consumers devices */
5617         if (init_data) {
5618                 for (i = 0; i < init_data->num_consumer_supplies; i++) {
5619                         ret = set_consumer_device_supply(rdev,
5620                                 init_data->consumer_supplies[i].dev_name,
5621                                 init_data->consumer_supplies[i].supply);
5622                         if (ret < 0) {
5623                                 dev_err(dev, "Failed to set supply %s\n",
5624                                         init_data->consumer_supplies[i].supply);
5625                                 goto unset_supplies;
5626                         }
5627                 }
5628         }
5629
5630         if (!rdev->desc->ops->get_voltage &&
5631             !rdev->desc->ops->list_voltage &&
5632             !rdev->desc->fixed_uV)
5633                 rdev->is_switch = true;
5634
5635         ret = device_add(&rdev->dev);
5636         if (ret != 0)
5637                 goto unset_supplies;
5638
5639         rdev_init_debugfs(rdev);
5640
5641         /* try to resolve regulators coupling since a new one was registered */
5642         mutex_lock(&regulator_list_mutex);
5643         regulator_resolve_coupling(rdev);
5644         mutex_unlock(&regulator_list_mutex);
5645
5646         /* try to resolve regulators supply since a new one was registered */
5647         class_for_each_device(&regulator_class, NULL, NULL,
5648                               regulator_register_resolve_supply);
5649         kfree(config);
5650         return rdev;
5651
5652 unset_supplies:
5653         mutex_lock(&regulator_list_mutex);
5654         unset_regulator_supplies(rdev);
5655         regulator_remove_coupling(rdev);
5656         mutex_unlock(&regulator_list_mutex);
5657 wash:
5658         regulator_put(rdev->supply);
5659         kfree(rdev->coupling_desc.coupled_rdevs);
5660         mutex_lock(&regulator_list_mutex);
5661         regulator_ena_gpio_free(rdev);
5662         mutex_unlock(&regulator_list_mutex);
5663         put_device(&rdev->dev);
5664         rdev = NULL;
5665 clean:
5666         if (dangling_of_gpiod)
5667                 gpiod_put(config->ena_gpiod);
5668         if (rdev && rdev->dev.of_node)
5669                 of_node_put(rdev->dev.of_node);
5670         kfree(rdev);
5671         kfree(config);
5672 rinse:
5673         if (dangling_cfg_gpiod)
5674                 gpiod_put(cfg->ena_gpiod);
5675         return ERR_PTR(ret);
5676 }
5677 EXPORT_SYMBOL_GPL(regulator_register);
5678
5679 /**
5680  * regulator_unregister - unregister regulator
5681  * @rdev: regulator to unregister
5682  *
5683  * Called by regulator drivers to unregister a regulator.
5684  */
5685 void regulator_unregister(struct regulator_dev *rdev)
5686 {
5687         if (rdev == NULL)
5688                 return;
5689
5690         if (rdev->supply) {
5691                 while (rdev->use_count--)
5692                         regulator_disable(rdev->supply);
5693                 regulator_put(rdev->supply);
5694         }
5695
5696         flush_work(&rdev->disable_work.work);
5697
5698         mutex_lock(&regulator_list_mutex);
5699
5700         WARN_ON(rdev->open_count);
5701         regulator_remove_coupling(rdev);
5702         unset_regulator_supplies(rdev);
5703         list_del(&rdev->list);
5704         regulator_ena_gpio_free(rdev);
5705         device_unregister(&rdev->dev);
5706
5707         mutex_unlock(&regulator_list_mutex);
5708 }
5709 EXPORT_SYMBOL_GPL(regulator_unregister);
5710
5711 #ifdef CONFIG_SUSPEND
5712 /**
5713  * regulator_suspend - prepare regulators for system wide suspend
5714  * @dev: ``&struct device`` pointer that is passed to _regulator_suspend()
5715  *
5716  * Configure each regulator with it's suspend operating parameters for state.
5717  */
5718 static int regulator_suspend(struct device *dev)
5719 {
5720         struct regulator_dev *rdev = dev_to_rdev(dev);
5721         suspend_state_t state = pm_suspend_target_state;
5722         int ret;
5723         const struct regulator_state *rstate;
5724
5725         rstate = regulator_get_suspend_state_check(rdev, state);
5726         if (!rstate)
5727                 return 0;
5728
5729         regulator_lock(rdev);
5730         ret = __suspend_set_state(rdev, rstate);
5731         regulator_unlock(rdev);
5732
5733         return ret;
5734 }
5735
5736 static int regulator_resume(struct device *dev)
5737 {
5738         suspend_state_t state = pm_suspend_target_state;
5739         struct regulator_dev *rdev = dev_to_rdev(dev);
5740         struct regulator_state *rstate;
5741         int ret = 0;
5742
5743         rstate = regulator_get_suspend_state(rdev, state);
5744         if (rstate == NULL)
5745                 return 0;
5746
5747         /* Avoid grabbing the lock if we don't need to */
5748         if (!rdev->desc->ops->resume)
5749                 return 0;
5750
5751         regulator_lock(rdev);
5752
5753         if (rstate->enabled == ENABLE_IN_SUSPEND ||
5754             rstate->enabled == DISABLE_IN_SUSPEND)
5755                 ret = rdev->desc->ops->resume(rdev);
5756
5757         regulator_unlock(rdev);
5758
5759         return ret;
5760 }
5761 #else /* !CONFIG_SUSPEND */
5762
5763 #define regulator_suspend       NULL
5764 #define regulator_resume        NULL
5765
5766 #endif /* !CONFIG_SUSPEND */
5767
5768 #ifdef CONFIG_PM
5769 static const struct dev_pm_ops __maybe_unused regulator_pm_ops = {
5770         .suspend        = regulator_suspend,
5771         .resume         = regulator_resume,
5772 };
5773 #endif
5774
5775 struct class regulator_class = {
5776         .name = "regulator",
5777         .dev_release = regulator_dev_release,
5778         .dev_groups = regulator_dev_groups,
5779 #ifdef CONFIG_PM
5780         .pm = &regulator_pm_ops,
5781 #endif
5782 };
5783 /**
5784  * regulator_has_full_constraints - the system has fully specified constraints
5785  *
5786  * Calling this function will cause the regulator API to disable all
5787  * regulators which have a zero use count and don't have an always_on
5788  * constraint in a late_initcall.
5789  *
5790  * The intention is that this will become the default behaviour in a
5791  * future kernel release so users are encouraged to use this facility
5792  * now.
5793  */
5794 void regulator_has_full_constraints(void)
5795 {
5796         has_full_constraints = 1;
5797 }
5798 EXPORT_SYMBOL_GPL(regulator_has_full_constraints);
5799
5800 /**
5801  * rdev_get_drvdata - get rdev regulator driver data
5802  * @rdev: regulator
5803  *
5804  * Get rdev regulator driver private data. This call can be used in the
5805  * regulator driver context.
5806  */
5807 void *rdev_get_drvdata(struct regulator_dev *rdev)
5808 {
5809         return rdev->reg_data;
5810 }
5811 EXPORT_SYMBOL_GPL(rdev_get_drvdata);
5812
5813 /**
5814  * regulator_get_drvdata - get regulator driver data
5815  * @regulator: regulator
5816  *
5817  * Get regulator driver private data. This call can be used in the consumer
5818  * driver context when non API regulator specific functions need to be called.
5819  */
5820 void *regulator_get_drvdata(struct regulator *regulator)
5821 {
5822         return regulator->rdev->reg_data;
5823 }
5824 EXPORT_SYMBOL_GPL(regulator_get_drvdata);
5825
5826 /**
5827  * regulator_set_drvdata - set regulator driver data
5828  * @regulator: regulator
5829  * @data: data
5830  */
5831 void regulator_set_drvdata(struct regulator *regulator, void *data)
5832 {
5833         regulator->rdev->reg_data = data;
5834 }
5835 EXPORT_SYMBOL_GPL(regulator_set_drvdata);
5836
5837 /**
5838  * rdev_get_id - get regulator ID
5839  * @rdev: regulator
5840  */
5841 int rdev_get_id(struct regulator_dev *rdev)
5842 {
5843         return rdev->desc->id;
5844 }
5845 EXPORT_SYMBOL_GPL(rdev_get_id);
5846
5847 struct device *rdev_get_dev(struct regulator_dev *rdev)
5848 {
5849         return &rdev->dev;
5850 }
5851 EXPORT_SYMBOL_GPL(rdev_get_dev);
5852
5853 struct regmap *rdev_get_regmap(struct regulator_dev *rdev)
5854 {
5855         return rdev->regmap;
5856 }
5857 EXPORT_SYMBOL_GPL(rdev_get_regmap);
5858
5859 void *regulator_get_init_drvdata(struct regulator_init_data *reg_init_data)
5860 {
5861         return reg_init_data->driver_data;
5862 }
5863 EXPORT_SYMBOL_GPL(regulator_get_init_drvdata);
5864
5865 #ifdef CONFIG_DEBUG_FS
5866 static int supply_map_show(struct seq_file *sf, void *data)
5867 {
5868         struct regulator_map *map;
5869
5870         list_for_each_entry(map, &regulator_map_list, list) {
5871                 seq_printf(sf, "%s -> %s.%s\n",
5872                                 rdev_get_name(map->regulator), map->dev_name,
5873                                 map->supply);
5874         }
5875
5876         return 0;
5877 }
5878 DEFINE_SHOW_ATTRIBUTE(supply_map);
5879
5880 struct summary_data {
5881         struct seq_file *s;
5882         struct regulator_dev *parent;
5883         int level;
5884 };
5885
5886 static void regulator_summary_show_subtree(struct seq_file *s,
5887                                            struct regulator_dev *rdev,
5888                                            int level);
5889
5890 static int regulator_summary_show_children(struct device *dev, void *data)
5891 {
5892         struct regulator_dev *rdev = dev_to_rdev(dev);
5893         struct summary_data *summary_data = data;
5894
5895         if (rdev->supply && rdev->supply->rdev == summary_data->parent)
5896                 regulator_summary_show_subtree(summary_data->s, rdev,
5897                                                summary_data->level + 1);
5898
5899         return 0;
5900 }
5901
5902 static void regulator_summary_show_subtree(struct seq_file *s,
5903                                            struct regulator_dev *rdev,
5904                                            int level)
5905 {
5906         struct regulation_constraints *c;
5907         struct regulator *consumer;
5908         struct summary_data summary_data;
5909         unsigned int opmode;
5910
5911         if (!rdev)
5912                 return;
5913
5914         opmode = _regulator_get_mode_unlocked(rdev);
5915         seq_printf(s, "%*s%-*s %3d %4d %6d %7s ",
5916                    level * 3 + 1, "",
5917                    30 - level * 3, rdev_get_name(rdev),
5918                    rdev->use_count, rdev->open_count, rdev->bypass_count,
5919                    regulator_opmode_to_str(opmode));
5920
5921         seq_printf(s, "%5dmV ", regulator_get_voltage_rdev(rdev) / 1000);
5922         seq_printf(s, "%5dmA ",
5923                    _regulator_get_current_limit_unlocked(rdev) / 1000);
5924
5925         c = rdev->constraints;
5926         if (c) {
5927                 switch (rdev->desc->type) {
5928                 case REGULATOR_VOLTAGE:
5929                         seq_printf(s, "%5dmV %5dmV ",
5930                                    c->min_uV / 1000, c->max_uV / 1000);
5931                         break;
5932                 case REGULATOR_CURRENT:
5933                         seq_printf(s, "%5dmA %5dmA ",
5934                                    c->min_uA / 1000, c->max_uA / 1000);
5935                         break;
5936                 }
5937         }
5938
5939         seq_puts(s, "\n");
5940
5941         list_for_each_entry(consumer, &rdev->consumer_list, list) {
5942                 if (consumer->dev && consumer->dev->class == &regulator_class)
5943                         continue;
5944
5945                 seq_printf(s, "%*s%-*s ",
5946                            (level + 1) * 3 + 1, "",
5947                            30 - (level + 1) * 3,
5948                            consumer->supply_name ? consumer->supply_name :
5949                            consumer->dev ? dev_name(consumer->dev) : "deviceless");
5950
5951                 switch (rdev->desc->type) {
5952                 case REGULATOR_VOLTAGE:
5953                         seq_printf(s, "%3d %33dmA%c%5dmV %5dmV",
5954                                    consumer->enable_count,
5955                                    consumer->uA_load / 1000,
5956                                    consumer->uA_load && !consumer->enable_count ?
5957                                    '*' : ' ',
5958                                    consumer->voltage[PM_SUSPEND_ON].min_uV / 1000,
5959                                    consumer->voltage[PM_SUSPEND_ON].max_uV / 1000);
5960                         break;
5961                 case REGULATOR_CURRENT:
5962                         break;
5963                 }
5964
5965                 seq_puts(s, "\n");
5966         }
5967
5968         summary_data.s = s;
5969         summary_data.level = level;
5970         summary_data.parent = rdev;
5971
5972         class_for_each_device(&regulator_class, NULL, &summary_data,
5973                               regulator_summary_show_children);
5974 }
5975
5976 struct summary_lock_data {
5977         struct ww_acquire_ctx *ww_ctx;
5978         struct regulator_dev **new_contended_rdev;
5979         struct regulator_dev **old_contended_rdev;
5980 };
5981
5982 static int regulator_summary_lock_one(struct device *dev, void *data)
5983 {
5984         struct regulator_dev *rdev = dev_to_rdev(dev);
5985         struct summary_lock_data *lock_data = data;
5986         int ret = 0;
5987
5988         if (rdev != *lock_data->old_contended_rdev) {
5989                 ret = regulator_lock_nested(rdev, lock_data->ww_ctx);
5990
5991                 if (ret == -EDEADLK)
5992                         *lock_data->new_contended_rdev = rdev;
5993                 else
5994                         WARN_ON_ONCE(ret);
5995         } else {
5996                 *lock_data->old_contended_rdev = NULL;
5997         }
5998
5999         return ret;
6000 }
6001
6002 static int regulator_summary_unlock_one(struct device *dev, void *data)
6003 {
6004         struct regulator_dev *rdev = dev_to_rdev(dev);
6005         struct summary_lock_data *lock_data = data;
6006
6007         if (lock_data) {
6008                 if (rdev == *lock_data->new_contended_rdev)
6009                         return -EDEADLK;
6010         }
6011
6012         regulator_unlock(rdev);
6013
6014         return 0;
6015 }
6016
6017 static int regulator_summary_lock_all(struct ww_acquire_ctx *ww_ctx,
6018                                       struct regulator_dev **new_contended_rdev,
6019                                       struct regulator_dev **old_contended_rdev)
6020 {
6021         struct summary_lock_data lock_data;
6022         int ret;
6023
6024         lock_data.ww_ctx = ww_ctx;
6025         lock_data.new_contended_rdev = new_contended_rdev;
6026         lock_data.old_contended_rdev = old_contended_rdev;
6027
6028         ret = class_for_each_device(&regulator_class, NULL, &lock_data,
6029                                     regulator_summary_lock_one);
6030         if (ret)
6031                 class_for_each_device(&regulator_class, NULL, &lock_data,
6032                                       regulator_summary_unlock_one);
6033
6034         return ret;
6035 }
6036
6037 static void regulator_summary_lock(struct ww_acquire_ctx *ww_ctx)
6038 {
6039         struct regulator_dev *new_contended_rdev = NULL;
6040         struct regulator_dev *old_contended_rdev = NULL;
6041         int err;
6042
6043         mutex_lock(&regulator_list_mutex);
6044
6045         ww_acquire_init(ww_ctx, &regulator_ww_class);
6046
6047         do {
6048                 if (new_contended_rdev) {
6049                         ww_mutex_lock_slow(&new_contended_rdev->mutex, ww_ctx);
6050                         old_contended_rdev = new_contended_rdev;
6051                         old_contended_rdev->ref_cnt++;
6052                 }
6053
6054                 err = regulator_summary_lock_all(ww_ctx,
6055                                                  &new_contended_rdev,
6056                                                  &old_contended_rdev);
6057
6058                 if (old_contended_rdev)
6059                         regulator_unlock(old_contended_rdev);
6060
6061         } while (err == -EDEADLK);
6062
6063         ww_acquire_done(ww_ctx);
6064 }
6065
6066 static void regulator_summary_unlock(struct ww_acquire_ctx *ww_ctx)
6067 {
6068         class_for_each_device(&regulator_class, NULL, NULL,
6069                               regulator_summary_unlock_one);
6070         ww_acquire_fini(ww_ctx);
6071
6072         mutex_unlock(&regulator_list_mutex);
6073 }
6074
6075 static int regulator_summary_show_roots(struct device *dev, void *data)
6076 {
6077         struct regulator_dev *rdev = dev_to_rdev(dev);
6078         struct seq_file *s = data;
6079
6080         if (!rdev->supply)
6081                 regulator_summary_show_subtree(s, rdev, 0);
6082
6083         return 0;
6084 }
6085
6086 static int regulator_summary_show(struct seq_file *s, void *data)
6087 {
6088         struct ww_acquire_ctx ww_ctx;
6089
6090         seq_puts(s, " regulator                      use open bypass  opmode voltage current     min     max\n");
6091         seq_puts(s, "---------------------------------------------------------------------------------------\n");
6092
6093         regulator_summary_lock(&ww_ctx);
6094
6095         class_for_each_device(&regulator_class, NULL, s,
6096                               regulator_summary_show_roots);
6097
6098         regulator_summary_unlock(&ww_ctx);
6099
6100         return 0;
6101 }
6102 DEFINE_SHOW_ATTRIBUTE(regulator_summary);
6103 #endif /* CONFIG_DEBUG_FS */
6104
6105 static int __init regulator_init(void)
6106 {
6107         int ret;
6108
6109         ret = class_register(&regulator_class);
6110
6111         debugfs_root = debugfs_create_dir("regulator", NULL);
6112         if (!debugfs_root)
6113                 pr_warn("regulator: Failed to create debugfs directory\n");
6114
6115 #ifdef CONFIG_DEBUG_FS
6116         debugfs_create_file("supply_map", 0444, debugfs_root, NULL,
6117                             &supply_map_fops);
6118
6119         debugfs_create_file("regulator_summary", 0444, debugfs_root,
6120                             NULL, &regulator_summary_fops);
6121 #endif
6122         regulator_dummy_init();
6123
6124         regulator_coupler_register(&generic_regulator_coupler);
6125
6126         return ret;
6127 }
6128
6129 /* init early to allow our consumers to complete system booting */
6130 core_initcall(regulator_init);
6131
6132 static int regulator_late_cleanup(struct device *dev, void *data)
6133 {
6134         struct regulator_dev *rdev = dev_to_rdev(dev);
6135         struct regulation_constraints *c = rdev->constraints;
6136         int ret;
6137
6138         if (c && c->always_on)
6139                 return 0;
6140
6141         if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_STATUS))
6142                 return 0;
6143
6144         regulator_lock(rdev);
6145
6146         if (rdev->use_count)
6147                 goto unlock;
6148
6149         /* If reading the status failed, assume that it's off. */
6150         if (_regulator_is_enabled(rdev) <= 0)
6151                 goto unlock;
6152
6153         if (have_full_constraints()) {
6154                 /* We log since this may kill the system if it goes
6155                  * wrong.
6156                  */
6157                 rdev_info(rdev, "disabling\n");
6158                 ret = _regulator_do_disable(rdev);
6159                 if (ret != 0)
6160                         rdev_err(rdev, "couldn't disable: %pe\n", ERR_PTR(ret));
6161         } else {
6162                 /* The intention is that in future we will
6163                  * assume that full constraints are provided
6164                  * so warn even if we aren't going to do
6165                  * anything here.
6166                  */
6167                 rdev_warn(rdev, "incomplete constraints, leaving on\n");
6168         }
6169
6170 unlock:
6171         regulator_unlock(rdev);
6172
6173         return 0;
6174 }
6175
6176 static void regulator_init_complete_work_function(struct work_struct *work)
6177 {
6178         /*
6179          * Regulators may had failed to resolve their input supplies
6180          * when were registered, either because the input supply was
6181          * not registered yet or because its parent device was not
6182          * bound yet. So attempt to resolve the input supplies for
6183          * pending regulators before trying to disable unused ones.
6184          */
6185         class_for_each_device(&regulator_class, NULL, NULL,
6186                               regulator_register_resolve_supply);
6187
6188         /* If we have a full configuration then disable any regulators
6189          * we have permission to change the status for and which are
6190          * not in use or always_on.  This is effectively the default
6191          * for DT and ACPI as they have full constraints.
6192          */
6193         class_for_each_device(&regulator_class, NULL, NULL,
6194                               regulator_late_cleanup);
6195 }
6196
6197 static DECLARE_DELAYED_WORK(regulator_init_complete_work,
6198                             regulator_init_complete_work_function);
6199
6200 static int __init regulator_init_complete(void)
6201 {
6202         /*
6203          * Since DT doesn't provide an idiomatic mechanism for
6204          * enabling full constraints and since it's much more natural
6205          * with DT to provide them just assume that a DT enabled
6206          * system has full constraints.
6207          */
6208         if (of_have_populated_dt())
6209                 has_full_constraints = true;
6210
6211         /*
6212          * We punt completion for an arbitrary amount of time since
6213          * systems like distros will load many drivers from userspace
6214          * so consumers might not always be ready yet, this is
6215          * particularly an issue with laptops where this might bounce
6216          * the display off then on.  Ideally we'd get a notification
6217          * from userspace when this happens but we don't so just wait
6218          * a bit and hope we waited long enough.  It'd be better if
6219          * we'd only do this on systems that need it, and a kernel
6220          * command line option might be useful.
6221          */
6222         schedule_delayed_work(&regulator_init_complete_work,
6223                               msecs_to_jiffies(30000));
6224
6225         return 0;
6226 }
6227 late_initcall_sync(regulator_init_complete);