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