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