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