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