core.c revision da07ecd93b196819dcec488b7ebec69a71f3819e
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#define pr_fmt(fmt) "%s: " fmt, __func__ 17 18#include <linux/kernel.h> 19#include <linux/init.h> 20#include <linux/debugfs.h> 21#include <linux/device.h> 22#include <linux/slab.h> 23#include <linux/async.h> 24#include <linux/err.h> 25#include <linux/mutex.h> 26#include <linux/suspend.h> 27#include <linux/delay.h> 28#include <linux/regulator/consumer.h> 29#include <linux/regulator/driver.h> 30#include <linux/regulator/machine.h> 31 32#define CREATE_TRACE_POINTS 33#include <trace/events/regulator.h> 34 35#include "dummy.h" 36 37#define rdev_crit(rdev, fmt, ...) \ 38 pr_crit("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__) 39#define rdev_err(rdev, fmt, ...) \ 40 pr_err("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__) 41#define rdev_warn(rdev, fmt, ...) \ 42 pr_warn("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__) 43#define rdev_info(rdev, fmt, ...) \ 44 pr_info("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__) 45#define rdev_dbg(rdev, fmt, ...) \ 46 pr_debug("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__) 47 48static DEFINE_MUTEX(regulator_list_mutex); 49static LIST_HEAD(regulator_list); 50static LIST_HEAD(regulator_map_list); 51static bool has_full_constraints; 52static bool board_wants_dummy_regulator; 53 54#ifdef CONFIG_DEBUG_FS 55static struct dentry *debugfs_root; 56#endif 57 58/* 59 * struct regulator_map 60 * 61 * Used to provide symbolic supply names to devices. 62 */ 63struct regulator_map { 64 struct list_head list; 65 const char *dev_name; /* The dev_name() for the consumer */ 66 const char *supply; 67 struct regulator_dev *regulator; 68}; 69 70/* 71 * struct regulator 72 * 73 * One for each consumer device. 74 */ 75struct regulator { 76 struct device *dev; 77 struct list_head list; 78 int uA_load; 79 int min_uV; 80 int max_uV; 81 char *supply_name; 82 struct device_attribute dev_attr; 83 struct regulator_dev *rdev; 84#ifdef CONFIG_DEBUG_FS 85 struct dentry *debugfs; 86#endif 87}; 88 89static int _regulator_is_enabled(struct regulator_dev *rdev); 90static int _regulator_disable(struct regulator_dev *rdev); 91static int _regulator_get_voltage(struct regulator_dev *rdev); 92static int _regulator_get_current_limit(struct regulator_dev *rdev); 93static unsigned int _regulator_get_mode(struct regulator_dev *rdev); 94static void _notifier_call_chain(struct regulator_dev *rdev, 95 unsigned long event, void *data); 96static int _regulator_do_set_voltage(struct regulator_dev *rdev, 97 int min_uV, int max_uV); 98static struct regulator *create_regulator(struct regulator_dev *rdev, 99 struct device *dev, 100 const char *supply_name); 101 102static const char *rdev_get_name(struct regulator_dev *rdev) 103{ 104 if (rdev->constraints && rdev->constraints->name) 105 return rdev->constraints->name; 106 else if (rdev->desc->name) 107 return rdev->desc->name; 108 else 109 return ""; 110} 111 112/* gets the regulator for a given consumer device */ 113static struct regulator *get_device_regulator(struct device *dev) 114{ 115 struct regulator *regulator = NULL; 116 struct regulator_dev *rdev; 117 118 mutex_lock(®ulator_list_mutex); 119 list_for_each_entry(rdev, ®ulator_list, list) { 120 mutex_lock(&rdev->mutex); 121 list_for_each_entry(regulator, &rdev->consumer_list, list) { 122 if (regulator->dev == dev) { 123 mutex_unlock(&rdev->mutex); 124 mutex_unlock(®ulator_list_mutex); 125 return regulator; 126 } 127 } 128 mutex_unlock(&rdev->mutex); 129 } 130 mutex_unlock(®ulator_list_mutex); 131 return NULL; 132} 133 134/* Platform voltage constraint check */ 135static int regulator_check_voltage(struct regulator_dev *rdev, 136 int *min_uV, int *max_uV) 137{ 138 BUG_ON(*min_uV > *max_uV); 139 140 if (!rdev->constraints) { 141 rdev_err(rdev, "no constraints\n"); 142 return -ENODEV; 143 } 144 if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_VOLTAGE)) { 145 rdev_err(rdev, "operation not allowed\n"); 146 return -EPERM; 147 } 148 149 if (*max_uV > rdev->constraints->max_uV) 150 *max_uV = rdev->constraints->max_uV; 151 if (*min_uV < rdev->constraints->min_uV) 152 *min_uV = rdev->constraints->min_uV; 153 154 if (*min_uV > *max_uV) { 155 rdev_err(rdev, "unsupportable voltage range: %d-%duV\n", 156 *min_uV, *max_uV); 157 return -EINVAL; 158 } 159 160 return 0; 161} 162 163/* Make sure we select a voltage that suits the needs of all 164 * regulator consumers 165 */ 166static int regulator_check_consumers(struct regulator_dev *rdev, 167 int *min_uV, int *max_uV) 168{ 169 struct regulator *regulator; 170 171 list_for_each_entry(regulator, &rdev->consumer_list, list) { 172 /* 173 * Assume consumers that didn't say anything are OK 174 * with anything in the constraint range. 175 */ 176 if (!regulator->min_uV && !regulator->max_uV) 177 continue; 178 179 if (*max_uV > regulator->max_uV) 180 *max_uV = regulator->max_uV; 181 if (*min_uV < regulator->min_uV) 182 *min_uV = regulator->min_uV; 183 } 184 185 if (*min_uV > *max_uV) 186 return -EINVAL; 187 188 return 0; 189} 190 191/* current constraint check */ 192static int regulator_check_current_limit(struct regulator_dev *rdev, 193 int *min_uA, int *max_uA) 194{ 195 BUG_ON(*min_uA > *max_uA); 196 197 if (!rdev->constraints) { 198 rdev_err(rdev, "no constraints\n"); 199 return -ENODEV; 200 } 201 if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_CURRENT)) { 202 rdev_err(rdev, "operation not allowed\n"); 203 return -EPERM; 204 } 205 206 if (*max_uA > rdev->constraints->max_uA) 207 *max_uA = rdev->constraints->max_uA; 208 if (*min_uA < rdev->constraints->min_uA) 209 *min_uA = rdev->constraints->min_uA; 210 211 if (*min_uA > *max_uA) { 212 rdev_err(rdev, "unsupportable current range: %d-%duA\n", 213 *min_uA, *max_uA); 214 return -EINVAL; 215 } 216 217 return 0; 218} 219 220/* operating mode constraint check */ 221static int regulator_mode_constrain(struct regulator_dev *rdev, int *mode) 222{ 223 switch (*mode) { 224 case REGULATOR_MODE_FAST: 225 case REGULATOR_MODE_NORMAL: 226 case REGULATOR_MODE_IDLE: 227 case REGULATOR_MODE_STANDBY: 228 break; 229 default: 230 rdev_err(rdev, "invalid mode %x specified\n", *mode); 231 return -EINVAL; 232 } 233 234 if (!rdev->constraints) { 235 rdev_err(rdev, "no constraints\n"); 236 return -ENODEV; 237 } 238 if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_MODE)) { 239 rdev_err(rdev, "operation not allowed\n"); 240 return -EPERM; 241 } 242 243 /* The modes are bitmasks, the most power hungry modes having 244 * the lowest values. If the requested mode isn't supported 245 * try higher modes. */ 246 while (*mode) { 247 if (rdev->constraints->valid_modes_mask & *mode) 248 return 0; 249 *mode /= 2; 250 } 251 252 return -EINVAL; 253} 254 255/* dynamic regulator mode switching constraint check */ 256static int regulator_check_drms(struct regulator_dev *rdev) 257{ 258 if (!rdev->constraints) { 259 rdev_err(rdev, "no constraints\n"); 260 return -ENODEV; 261 } 262 if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_DRMS)) { 263 rdev_err(rdev, "operation not allowed\n"); 264 return -EPERM; 265 } 266 return 0; 267} 268 269static ssize_t device_requested_uA_show(struct device *dev, 270 struct device_attribute *attr, char *buf) 271{ 272 struct regulator *regulator; 273 274 regulator = get_device_regulator(dev); 275 if (regulator == NULL) 276 return 0; 277 278 return sprintf(buf, "%d\n", regulator->uA_load); 279} 280 281static ssize_t regulator_uV_show(struct device *dev, 282 struct device_attribute *attr, char *buf) 283{ 284 struct regulator_dev *rdev = dev_get_drvdata(dev); 285 ssize_t ret; 286 287 mutex_lock(&rdev->mutex); 288 ret = sprintf(buf, "%d\n", _regulator_get_voltage(rdev)); 289 mutex_unlock(&rdev->mutex); 290 291 return ret; 292} 293static DEVICE_ATTR(microvolts, 0444, regulator_uV_show, NULL); 294 295static ssize_t regulator_uA_show(struct device *dev, 296 struct device_attribute *attr, char *buf) 297{ 298 struct regulator_dev *rdev = dev_get_drvdata(dev); 299 300 return sprintf(buf, "%d\n", _regulator_get_current_limit(rdev)); 301} 302static DEVICE_ATTR(microamps, 0444, regulator_uA_show, NULL); 303 304static ssize_t regulator_name_show(struct device *dev, 305 struct device_attribute *attr, char *buf) 306{ 307 struct regulator_dev *rdev = dev_get_drvdata(dev); 308 309 return sprintf(buf, "%s\n", rdev_get_name(rdev)); 310} 311 312static ssize_t regulator_print_opmode(char *buf, int mode) 313{ 314 switch (mode) { 315 case REGULATOR_MODE_FAST: 316 return sprintf(buf, "fast\n"); 317 case REGULATOR_MODE_NORMAL: 318 return sprintf(buf, "normal\n"); 319 case REGULATOR_MODE_IDLE: 320 return sprintf(buf, "idle\n"); 321 case REGULATOR_MODE_STANDBY: 322 return sprintf(buf, "standby\n"); 323 } 324 return sprintf(buf, "unknown\n"); 325} 326 327static ssize_t regulator_opmode_show(struct device *dev, 328 struct device_attribute *attr, char *buf) 329{ 330 struct regulator_dev *rdev = dev_get_drvdata(dev); 331 332 return regulator_print_opmode(buf, _regulator_get_mode(rdev)); 333} 334static DEVICE_ATTR(opmode, 0444, regulator_opmode_show, NULL); 335 336static ssize_t regulator_print_state(char *buf, int state) 337{ 338 if (state > 0) 339 return sprintf(buf, "enabled\n"); 340 else if (state == 0) 341 return sprintf(buf, "disabled\n"); 342 else 343 return sprintf(buf, "unknown\n"); 344} 345 346static ssize_t regulator_state_show(struct device *dev, 347 struct device_attribute *attr, char *buf) 348{ 349 struct regulator_dev *rdev = dev_get_drvdata(dev); 350 ssize_t ret; 351 352 mutex_lock(&rdev->mutex); 353 ret = regulator_print_state(buf, _regulator_is_enabled(rdev)); 354 mutex_unlock(&rdev->mutex); 355 356 return ret; 357} 358static DEVICE_ATTR(state, 0444, regulator_state_show, NULL); 359 360static ssize_t regulator_status_show(struct device *dev, 361 struct device_attribute *attr, char *buf) 362{ 363 struct regulator_dev *rdev = dev_get_drvdata(dev); 364 int status; 365 char *label; 366 367 status = rdev->desc->ops->get_status(rdev); 368 if (status < 0) 369 return status; 370 371 switch (status) { 372 case REGULATOR_STATUS_OFF: 373 label = "off"; 374 break; 375 case REGULATOR_STATUS_ON: 376 label = "on"; 377 break; 378 case REGULATOR_STATUS_ERROR: 379 label = "error"; 380 break; 381 case REGULATOR_STATUS_FAST: 382 label = "fast"; 383 break; 384 case REGULATOR_STATUS_NORMAL: 385 label = "normal"; 386 break; 387 case REGULATOR_STATUS_IDLE: 388 label = "idle"; 389 break; 390 case REGULATOR_STATUS_STANDBY: 391 label = "standby"; 392 break; 393 default: 394 return -ERANGE; 395 } 396 397 return sprintf(buf, "%s\n", label); 398} 399static DEVICE_ATTR(status, 0444, regulator_status_show, NULL); 400 401static ssize_t regulator_min_uA_show(struct device *dev, 402 struct device_attribute *attr, char *buf) 403{ 404 struct regulator_dev *rdev = dev_get_drvdata(dev); 405 406 if (!rdev->constraints) 407 return sprintf(buf, "constraint not defined\n"); 408 409 return sprintf(buf, "%d\n", rdev->constraints->min_uA); 410} 411static DEVICE_ATTR(min_microamps, 0444, regulator_min_uA_show, NULL); 412 413static ssize_t regulator_max_uA_show(struct device *dev, 414 struct device_attribute *attr, char *buf) 415{ 416 struct regulator_dev *rdev = dev_get_drvdata(dev); 417 418 if (!rdev->constraints) 419 return sprintf(buf, "constraint not defined\n"); 420 421 return sprintf(buf, "%d\n", rdev->constraints->max_uA); 422} 423static DEVICE_ATTR(max_microamps, 0444, regulator_max_uA_show, NULL); 424 425static ssize_t regulator_min_uV_show(struct device *dev, 426 struct device_attribute *attr, char *buf) 427{ 428 struct regulator_dev *rdev = dev_get_drvdata(dev); 429 430 if (!rdev->constraints) 431 return sprintf(buf, "constraint not defined\n"); 432 433 return sprintf(buf, "%d\n", rdev->constraints->min_uV); 434} 435static DEVICE_ATTR(min_microvolts, 0444, regulator_min_uV_show, NULL); 436 437static ssize_t regulator_max_uV_show(struct device *dev, 438 struct device_attribute *attr, char *buf) 439{ 440 struct regulator_dev *rdev = dev_get_drvdata(dev); 441 442 if (!rdev->constraints) 443 return sprintf(buf, "constraint not defined\n"); 444 445 return sprintf(buf, "%d\n", rdev->constraints->max_uV); 446} 447static DEVICE_ATTR(max_microvolts, 0444, regulator_max_uV_show, NULL); 448 449static ssize_t regulator_total_uA_show(struct device *dev, 450 struct device_attribute *attr, char *buf) 451{ 452 struct regulator_dev *rdev = dev_get_drvdata(dev); 453 struct regulator *regulator; 454 int uA = 0; 455 456 mutex_lock(&rdev->mutex); 457 list_for_each_entry(regulator, &rdev->consumer_list, list) 458 uA += regulator->uA_load; 459 mutex_unlock(&rdev->mutex); 460 return sprintf(buf, "%d\n", uA); 461} 462static DEVICE_ATTR(requested_microamps, 0444, regulator_total_uA_show, NULL); 463 464static ssize_t regulator_num_users_show(struct device *dev, 465 struct device_attribute *attr, char *buf) 466{ 467 struct regulator_dev *rdev = dev_get_drvdata(dev); 468 return sprintf(buf, "%d\n", rdev->use_count); 469} 470 471static ssize_t regulator_type_show(struct device *dev, 472 struct device_attribute *attr, char *buf) 473{ 474 struct regulator_dev *rdev = dev_get_drvdata(dev); 475 476 switch (rdev->desc->type) { 477 case REGULATOR_VOLTAGE: 478 return sprintf(buf, "voltage\n"); 479 case REGULATOR_CURRENT: 480 return sprintf(buf, "current\n"); 481 } 482 return sprintf(buf, "unknown\n"); 483} 484 485static ssize_t regulator_suspend_mem_uV_show(struct device *dev, 486 struct device_attribute *attr, char *buf) 487{ 488 struct regulator_dev *rdev = dev_get_drvdata(dev); 489 490 return sprintf(buf, "%d\n", rdev->constraints->state_mem.uV); 491} 492static DEVICE_ATTR(suspend_mem_microvolts, 0444, 493 regulator_suspend_mem_uV_show, NULL); 494 495static ssize_t regulator_suspend_disk_uV_show(struct device *dev, 496 struct device_attribute *attr, char *buf) 497{ 498 struct regulator_dev *rdev = dev_get_drvdata(dev); 499 500 return sprintf(buf, "%d\n", rdev->constraints->state_disk.uV); 501} 502static DEVICE_ATTR(suspend_disk_microvolts, 0444, 503 regulator_suspend_disk_uV_show, NULL); 504 505static ssize_t regulator_suspend_standby_uV_show(struct device *dev, 506 struct device_attribute *attr, char *buf) 507{ 508 struct regulator_dev *rdev = dev_get_drvdata(dev); 509 510 return sprintf(buf, "%d\n", rdev->constraints->state_standby.uV); 511} 512static DEVICE_ATTR(suspend_standby_microvolts, 0444, 513 regulator_suspend_standby_uV_show, NULL); 514 515static ssize_t regulator_suspend_mem_mode_show(struct device *dev, 516 struct device_attribute *attr, char *buf) 517{ 518 struct regulator_dev *rdev = dev_get_drvdata(dev); 519 520 return regulator_print_opmode(buf, 521 rdev->constraints->state_mem.mode); 522} 523static DEVICE_ATTR(suspend_mem_mode, 0444, 524 regulator_suspend_mem_mode_show, NULL); 525 526static ssize_t regulator_suspend_disk_mode_show(struct device *dev, 527 struct device_attribute *attr, char *buf) 528{ 529 struct regulator_dev *rdev = dev_get_drvdata(dev); 530 531 return regulator_print_opmode(buf, 532 rdev->constraints->state_disk.mode); 533} 534static DEVICE_ATTR(suspend_disk_mode, 0444, 535 regulator_suspend_disk_mode_show, NULL); 536 537static ssize_t regulator_suspend_standby_mode_show(struct device *dev, 538 struct device_attribute *attr, char *buf) 539{ 540 struct regulator_dev *rdev = dev_get_drvdata(dev); 541 542 return regulator_print_opmode(buf, 543 rdev->constraints->state_standby.mode); 544} 545static DEVICE_ATTR(suspend_standby_mode, 0444, 546 regulator_suspend_standby_mode_show, NULL); 547 548static ssize_t regulator_suspend_mem_state_show(struct device *dev, 549 struct device_attribute *attr, char *buf) 550{ 551 struct regulator_dev *rdev = dev_get_drvdata(dev); 552 553 return regulator_print_state(buf, 554 rdev->constraints->state_mem.enabled); 555} 556static DEVICE_ATTR(suspend_mem_state, 0444, 557 regulator_suspend_mem_state_show, NULL); 558 559static ssize_t regulator_suspend_disk_state_show(struct device *dev, 560 struct device_attribute *attr, char *buf) 561{ 562 struct regulator_dev *rdev = dev_get_drvdata(dev); 563 564 return regulator_print_state(buf, 565 rdev->constraints->state_disk.enabled); 566} 567static DEVICE_ATTR(suspend_disk_state, 0444, 568 regulator_suspend_disk_state_show, NULL); 569 570static ssize_t regulator_suspend_standby_state_show(struct device *dev, 571 struct device_attribute *attr, char *buf) 572{ 573 struct regulator_dev *rdev = dev_get_drvdata(dev); 574 575 return regulator_print_state(buf, 576 rdev->constraints->state_standby.enabled); 577} 578static DEVICE_ATTR(suspend_standby_state, 0444, 579 regulator_suspend_standby_state_show, NULL); 580 581 582/* 583 * These are the only attributes are present for all regulators. 584 * Other attributes are a function of regulator functionality. 585 */ 586static struct device_attribute regulator_dev_attrs[] = { 587 __ATTR(name, 0444, regulator_name_show, NULL), 588 __ATTR(num_users, 0444, regulator_num_users_show, NULL), 589 __ATTR(type, 0444, regulator_type_show, NULL), 590 __ATTR_NULL, 591}; 592 593static void regulator_dev_release(struct device *dev) 594{ 595 struct regulator_dev *rdev = dev_get_drvdata(dev); 596 kfree(rdev); 597} 598 599static struct class regulator_class = { 600 .name = "regulator", 601 .dev_release = regulator_dev_release, 602 .dev_attrs = regulator_dev_attrs, 603}; 604 605/* Calculate the new optimum regulator operating mode based on the new total 606 * consumer load. All locks held by caller */ 607static void drms_uA_update(struct regulator_dev *rdev) 608{ 609 struct regulator *sibling; 610 int current_uA = 0, output_uV, input_uV, err; 611 unsigned int mode; 612 613 err = regulator_check_drms(rdev); 614 if (err < 0 || !rdev->desc->ops->get_optimum_mode || 615 (!rdev->desc->ops->get_voltage && 616 !rdev->desc->ops->get_voltage_sel) || 617 !rdev->desc->ops->set_mode) 618 return; 619 620 /* get output voltage */ 621 output_uV = _regulator_get_voltage(rdev); 622 if (output_uV <= 0) 623 return; 624 625 /* get input voltage */ 626 input_uV = 0; 627 if (rdev->supply) 628 input_uV = _regulator_get_voltage(rdev); 629 if (input_uV <= 0) 630 input_uV = rdev->constraints->input_uV; 631 if (input_uV <= 0) 632 return; 633 634 /* calc total requested load */ 635 list_for_each_entry(sibling, &rdev->consumer_list, list) 636 current_uA += sibling->uA_load; 637 638 /* now get the optimum mode for our new total regulator load */ 639 mode = rdev->desc->ops->get_optimum_mode(rdev, input_uV, 640 output_uV, current_uA); 641 642 /* check the new mode is allowed */ 643 err = regulator_mode_constrain(rdev, &mode); 644 if (err == 0) 645 rdev->desc->ops->set_mode(rdev, mode); 646} 647 648static int suspend_set_state(struct regulator_dev *rdev, 649 struct regulator_state *rstate) 650{ 651 int ret = 0; 652 bool can_set_state; 653 654 can_set_state = rdev->desc->ops->set_suspend_enable && 655 rdev->desc->ops->set_suspend_disable; 656 657 /* If we have no suspend mode configration don't set anything; 658 * only warn if the driver actually makes the suspend mode 659 * configurable. 660 */ 661 if (!rstate->enabled && !rstate->disabled) { 662 if (can_set_state) 663 rdev_warn(rdev, "No configuration\n"); 664 return 0; 665 } 666 667 if (rstate->enabled && rstate->disabled) { 668 rdev_err(rdev, "invalid configuration\n"); 669 return -EINVAL; 670 } 671 672 if (!can_set_state) { 673 rdev_err(rdev, "no way to set suspend state\n"); 674 return -EINVAL; 675 } 676 677 if (rstate->enabled) 678 ret = rdev->desc->ops->set_suspend_enable(rdev); 679 else 680 ret = rdev->desc->ops->set_suspend_disable(rdev); 681 if (ret < 0) { 682 rdev_err(rdev, "failed to enabled/disable\n"); 683 return ret; 684 } 685 686 if (rdev->desc->ops->set_suspend_voltage && rstate->uV > 0) { 687 ret = rdev->desc->ops->set_suspend_voltage(rdev, rstate->uV); 688 if (ret < 0) { 689 rdev_err(rdev, "failed to set voltage\n"); 690 return ret; 691 } 692 } 693 694 if (rdev->desc->ops->set_suspend_mode && rstate->mode > 0) { 695 ret = rdev->desc->ops->set_suspend_mode(rdev, rstate->mode); 696 if (ret < 0) { 697 rdev_err(rdev, "failed to set mode\n"); 698 return ret; 699 } 700 } 701 return ret; 702} 703 704/* locks held by caller */ 705static int suspend_prepare(struct regulator_dev *rdev, suspend_state_t state) 706{ 707 if (!rdev->constraints) 708 return -EINVAL; 709 710 switch (state) { 711 case PM_SUSPEND_STANDBY: 712 return suspend_set_state(rdev, 713 &rdev->constraints->state_standby); 714 case PM_SUSPEND_MEM: 715 return suspend_set_state(rdev, 716 &rdev->constraints->state_mem); 717 case PM_SUSPEND_MAX: 718 return suspend_set_state(rdev, 719 &rdev->constraints->state_disk); 720 default: 721 return -EINVAL; 722 } 723} 724 725static void print_constraints(struct regulator_dev *rdev) 726{ 727 struct regulation_constraints *constraints = rdev->constraints; 728 char buf[80] = ""; 729 int count = 0; 730 int ret; 731 732 if (constraints->min_uV && constraints->max_uV) { 733 if (constraints->min_uV == constraints->max_uV) 734 count += sprintf(buf + count, "%d mV ", 735 constraints->min_uV / 1000); 736 else 737 count += sprintf(buf + count, "%d <--> %d mV ", 738 constraints->min_uV / 1000, 739 constraints->max_uV / 1000); 740 } 741 742 if (!constraints->min_uV || 743 constraints->min_uV != constraints->max_uV) { 744 ret = _regulator_get_voltage(rdev); 745 if (ret > 0) 746 count += sprintf(buf + count, "at %d mV ", ret / 1000); 747 } 748 749 if (constraints->uV_offset) 750 count += sprintf(buf, "%dmV offset ", 751 constraints->uV_offset / 1000); 752 753 if (constraints->min_uA && constraints->max_uA) { 754 if (constraints->min_uA == constraints->max_uA) 755 count += sprintf(buf + count, "%d mA ", 756 constraints->min_uA / 1000); 757 else 758 count += sprintf(buf + count, "%d <--> %d mA ", 759 constraints->min_uA / 1000, 760 constraints->max_uA / 1000); 761 } 762 763 if (!constraints->min_uA || 764 constraints->min_uA != constraints->max_uA) { 765 ret = _regulator_get_current_limit(rdev); 766 if (ret > 0) 767 count += sprintf(buf + count, "at %d mA ", ret / 1000); 768 } 769 770 if (constraints->valid_modes_mask & REGULATOR_MODE_FAST) 771 count += sprintf(buf + count, "fast "); 772 if (constraints->valid_modes_mask & REGULATOR_MODE_NORMAL) 773 count += sprintf(buf + count, "normal "); 774 if (constraints->valid_modes_mask & REGULATOR_MODE_IDLE) 775 count += sprintf(buf + count, "idle "); 776 if (constraints->valid_modes_mask & REGULATOR_MODE_STANDBY) 777 count += sprintf(buf + count, "standby"); 778 779 rdev_info(rdev, "%s\n", buf); 780} 781 782static int machine_constraints_voltage(struct regulator_dev *rdev, 783 struct regulation_constraints *constraints) 784{ 785 struct regulator_ops *ops = rdev->desc->ops; 786 int ret; 787 788 /* do we need to apply the constraint voltage */ 789 if (rdev->constraints->apply_uV && 790 rdev->constraints->min_uV == rdev->constraints->max_uV) { 791 ret = _regulator_do_set_voltage(rdev, 792 rdev->constraints->min_uV, 793 rdev->constraints->max_uV); 794 if (ret < 0) { 795 rdev_err(rdev, "failed to apply %duV constraint\n", 796 rdev->constraints->min_uV); 797 return ret; 798 } 799 } 800 801 /* constrain machine-level voltage specs to fit 802 * the actual range supported by this regulator. 803 */ 804 if (ops->list_voltage && rdev->desc->n_voltages) { 805 int count = rdev->desc->n_voltages; 806 int i; 807 int min_uV = INT_MAX; 808 int max_uV = INT_MIN; 809 int cmin = constraints->min_uV; 810 int cmax = constraints->max_uV; 811 812 /* it's safe to autoconfigure fixed-voltage supplies 813 and the constraints are used by list_voltage. */ 814 if (count == 1 && !cmin) { 815 cmin = 1; 816 cmax = INT_MAX; 817 constraints->min_uV = cmin; 818 constraints->max_uV = cmax; 819 } 820 821 /* voltage constraints are optional */ 822 if ((cmin == 0) && (cmax == 0)) 823 return 0; 824 825 /* else require explicit machine-level constraints */ 826 if (cmin <= 0 || cmax <= 0 || cmax < cmin) { 827 rdev_err(rdev, "invalid voltage constraints\n"); 828 return -EINVAL; 829 } 830 831 /* initial: [cmin..cmax] valid, [min_uV..max_uV] not */ 832 for (i = 0; i < count; i++) { 833 int value; 834 835 value = ops->list_voltage(rdev, i); 836 if (value <= 0) 837 continue; 838 839 /* maybe adjust [min_uV..max_uV] */ 840 if (value >= cmin && value < min_uV) 841 min_uV = value; 842 if (value <= cmax && value > max_uV) 843 max_uV = value; 844 } 845 846 /* final: [min_uV..max_uV] valid iff constraints valid */ 847 if (max_uV < min_uV) { 848 rdev_err(rdev, "unsupportable voltage constraints\n"); 849 return -EINVAL; 850 } 851 852 /* use regulator's subset of machine constraints */ 853 if (constraints->min_uV < min_uV) { 854 rdev_dbg(rdev, "override min_uV, %d -> %d\n", 855 constraints->min_uV, min_uV); 856 constraints->min_uV = min_uV; 857 } 858 if (constraints->max_uV > max_uV) { 859 rdev_dbg(rdev, "override max_uV, %d -> %d\n", 860 constraints->max_uV, max_uV); 861 constraints->max_uV = max_uV; 862 } 863 } 864 865 return 0; 866} 867 868/** 869 * set_machine_constraints - sets regulator constraints 870 * @rdev: regulator source 871 * @constraints: constraints to apply 872 * 873 * Allows platform initialisation code to define and constrain 874 * regulator circuits e.g. valid voltage/current ranges, etc. NOTE: 875 * Constraints *must* be set by platform code in order for some 876 * regulator operations to proceed i.e. set_voltage, set_current_limit, 877 * set_mode. 878 */ 879static int set_machine_constraints(struct regulator_dev *rdev, 880 const struct regulation_constraints *constraints) 881{ 882 int ret = 0; 883 struct regulator_ops *ops = rdev->desc->ops; 884 885 rdev->constraints = kmemdup(constraints, sizeof(*constraints), 886 GFP_KERNEL); 887 if (!rdev->constraints) 888 return -ENOMEM; 889 890 ret = machine_constraints_voltage(rdev, rdev->constraints); 891 if (ret != 0) 892 goto out; 893 894 /* do we need to setup our suspend state */ 895 if (constraints->initial_state) { 896 ret = suspend_prepare(rdev, rdev->constraints->initial_state); 897 if (ret < 0) { 898 rdev_err(rdev, "failed to set suspend state\n"); 899 goto out; 900 } 901 } 902 903 if (constraints->initial_mode) { 904 if (!ops->set_mode) { 905 rdev_err(rdev, "no set_mode operation\n"); 906 ret = -EINVAL; 907 goto out; 908 } 909 910 ret = ops->set_mode(rdev, rdev->constraints->initial_mode); 911 if (ret < 0) { 912 rdev_err(rdev, "failed to set initial mode: %d\n", ret); 913 goto out; 914 } 915 } 916 917 /* If the constraints say the regulator should be on at this point 918 * and we have control then make sure it is enabled. 919 */ 920 if ((rdev->constraints->always_on || rdev->constraints->boot_on) && 921 ops->enable) { 922 ret = ops->enable(rdev); 923 if (ret < 0) { 924 rdev_err(rdev, "failed to enable\n"); 925 goto out; 926 } 927 } 928 929 print_constraints(rdev); 930 return 0; 931out: 932 kfree(rdev->constraints); 933 rdev->constraints = NULL; 934 return ret; 935} 936 937/** 938 * set_supply - set regulator supply regulator 939 * @rdev: regulator name 940 * @supply_rdev: supply regulator name 941 * 942 * Called by platform initialisation code to set the supply regulator for this 943 * regulator. This ensures that a regulators supply will also be enabled by the 944 * core if it's child is enabled. 945 */ 946static int set_supply(struct regulator_dev *rdev, 947 struct regulator_dev *supply_rdev) 948{ 949 int err; 950 951 rdev_info(rdev, "supplied by %s\n", rdev_get_name(supply_rdev)); 952 953 rdev->supply = create_regulator(supply_rdev, &rdev->dev, "SUPPLY"); 954 if (IS_ERR(rdev->supply)) { 955 err = PTR_ERR(rdev->supply); 956 rdev->supply = NULL; 957 return err; 958 } 959 960 return 0; 961} 962 963/** 964 * set_consumer_device_supply - Bind a regulator to a symbolic supply 965 * @rdev: regulator source 966 * @consumer_dev: device the supply applies to 967 * @consumer_dev_name: dev_name() string for device supply applies to 968 * @supply: symbolic name for supply 969 * 970 * Allows platform initialisation code to map physical regulator 971 * sources to symbolic names for supplies for use by devices. Devices 972 * should use these symbolic names to request regulators, avoiding the 973 * need to provide board-specific regulator names as platform data. 974 * 975 * Only one of consumer_dev and consumer_dev_name may be specified. 976 */ 977static int set_consumer_device_supply(struct regulator_dev *rdev, 978 struct device *consumer_dev, const char *consumer_dev_name, 979 const char *supply) 980{ 981 struct regulator_map *node; 982 int has_dev; 983 984 if (consumer_dev && consumer_dev_name) 985 return -EINVAL; 986 987 if (!consumer_dev_name && consumer_dev) 988 consumer_dev_name = dev_name(consumer_dev); 989 990 if (supply == NULL) 991 return -EINVAL; 992 993 if (consumer_dev_name != NULL) 994 has_dev = 1; 995 else 996 has_dev = 0; 997 998 list_for_each_entry(node, ®ulator_map_list, list) { 999 if (node->dev_name && consumer_dev_name) { 1000 if (strcmp(node->dev_name, consumer_dev_name) != 0) 1001 continue; 1002 } else if (node->dev_name || consumer_dev_name) { 1003 continue; 1004 } 1005 1006 if (strcmp(node->supply, supply) != 0) 1007 continue; 1008 1009 dev_dbg(consumer_dev, "%s/%s is '%s' supply; fail %s/%s\n", 1010 dev_name(&node->regulator->dev), 1011 node->regulator->desc->name, 1012 supply, 1013 dev_name(&rdev->dev), rdev_get_name(rdev)); 1014 return -EBUSY; 1015 } 1016 1017 node = kzalloc(sizeof(struct regulator_map), GFP_KERNEL); 1018 if (node == NULL) 1019 return -ENOMEM; 1020 1021 node->regulator = rdev; 1022 node->supply = supply; 1023 1024 if (has_dev) { 1025 node->dev_name = kstrdup(consumer_dev_name, GFP_KERNEL); 1026 if (node->dev_name == NULL) { 1027 kfree(node); 1028 return -ENOMEM; 1029 } 1030 } 1031 1032 list_add(&node->list, ®ulator_map_list); 1033 return 0; 1034} 1035 1036static void unset_regulator_supplies(struct regulator_dev *rdev) 1037{ 1038 struct regulator_map *node, *n; 1039 1040 list_for_each_entry_safe(node, n, ®ulator_map_list, list) { 1041 if (rdev == node->regulator) { 1042 list_del(&node->list); 1043 kfree(node->dev_name); 1044 kfree(node); 1045 } 1046 } 1047} 1048 1049#define REG_STR_SIZE 64 1050 1051static struct regulator *create_regulator(struct regulator_dev *rdev, 1052 struct device *dev, 1053 const char *supply_name) 1054{ 1055 struct regulator *regulator; 1056 char buf[REG_STR_SIZE]; 1057 int err, size; 1058 1059 regulator = kzalloc(sizeof(*regulator), GFP_KERNEL); 1060 if (regulator == NULL) 1061 return NULL; 1062 1063 mutex_lock(&rdev->mutex); 1064 regulator->rdev = rdev; 1065 list_add(®ulator->list, &rdev->consumer_list); 1066 1067 if (dev) { 1068 /* create a 'requested_microamps_name' sysfs entry */ 1069 size = scnprintf(buf, REG_STR_SIZE, 1070 "microamps_requested_%s-%s", 1071 dev_name(dev), supply_name); 1072 if (size >= REG_STR_SIZE) 1073 goto overflow_err; 1074 1075 regulator->dev = dev; 1076 sysfs_attr_init(®ulator->dev_attr.attr); 1077 regulator->dev_attr.attr.name = kstrdup(buf, GFP_KERNEL); 1078 if (regulator->dev_attr.attr.name == NULL) 1079 goto attr_name_err; 1080 1081 regulator->dev_attr.attr.mode = 0444; 1082 regulator->dev_attr.show = device_requested_uA_show; 1083 err = device_create_file(dev, ®ulator->dev_attr); 1084 if (err < 0) { 1085 rdev_warn(rdev, "could not add regulator_dev requested microamps sysfs entry\n"); 1086 goto attr_name_err; 1087 } 1088 1089 /* also add a link to the device sysfs entry */ 1090 size = scnprintf(buf, REG_STR_SIZE, "%s-%s", 1091 dev->kobj.name, supply_name); 1092 if (size >= REG_STR_SIZE) 1093 goto attr_err; 1094 1095 regulator->supply_name = kstrdup(buf, GFP_KERNEL); 1096 if (regulator->supply_name == NULL) 1097 goto attr_err; 1098 1099 err = sysfs_create_link(&rdev->dev.kobj, &dev->kobj, 1100 buf); 1101 if (err) { 1102 rdev_warn(rdev, "could not add device link %s err %d\n", 1103 dev->kobj.name, err); 1104 goto link_name_err; 1105 } 1106 } else { 1107 regulator->supply_name = kstrdup(supply_name, GFP_KERNEL); 1108 if (regulator->supply_name == NULL) 1109 goto attr_err; 1110 } 1111 1112#ifdef CONFIG_DEBUG_FS 1113 regulator->debugfs = debugfs_create_dir(regulator->supply_name, 1114 rdev->debugfs); 1115 if (IS_ERR_OR_NULL(regulator->debugfs)) { 1116 rdev_warn(rdev, "Failed to create debugfs directory\n"); 1117 regulator->debugfs = NULL; 1118 } else { 1119 debugfs_create_u32("uA_load", 0444, regulator->debugfs, 1120 ®ulator->uA_load); 1121 debugfs_create_u32("min_uV", 0444, regulator->debugfs, 1122 ®ulator->min_uV); 1123 debugfs_create_u32("max_uV", 0444, regulator->debugfs, 1124 ®ulator->max_uV); 1125 } 1126#endif 1127 1128 mutex_unlock(&rdev->mutex); 1129 return regulator; 1130link_name_err: 1131 kfree(regulator->supply_name); 1132attr_err: 1133 device_remove_file(regulator->dev, ®ulator->dev_attr); 1134attr_name_err: 1135 kfree(regulator->dev_attr.attr.name); 1136overflow_err: 1137 list_del(®ulator->list); 1138 kfree(regulator); 1139 mutex_unlock(&rdev->mutex); 1140 return NULL; 1141} 1142 1143static int _regulator_get_enable_time(struct regulator_dev *rdev) 1144{ 1145 if (!rdev->desc->ops->enable_time) 1146 return 0; 1147 return rdev->desc->ops->enable_time(rdev); 1148} 1149 1150/* Internal regulator request function */ 1151static struct regulator *_regulator_get(struct device *dev, const char *id, 1152 int exclusive) 1153{ 1154 struct regulator_dev *rdev; 1155 struct regulator_map *map; 1156 struct regulator *regulator = ERR_PTR(-ENODEV); 1157 const char *devname = NULL; 1158 int ret; 1159 1160 if (id == NULL) { 1161 pr_err("get() with no identifier\n"); 1162 return regulator; 1163 } 1164 1165 if (dev) 1166 devname = dev_name(dev); 1167 1168 mutex_lock(®ulator_list_mutex); 1169 1170 list_for_each_entry(map, ®ulator_map_list, list) { 1171 /* If the mapping has a device set up it must match */ 1172 if (map->dev_name && 1173 (!devname || strcmp(map->dev_name, devname))) 1174 continue; 1175 1176 if (strcmp(map->supply, id) == 0) { 1177 rdev = map->regulator; 1178 goto found; 1179 } 1180 } 1181 1182 if (board_wants_dummy_regulator) { 1183 rdev = dummy_regulator_rdev; 1184 goto found; 1185 } 1186 1187#ifdef CONFIG_REGULATOR_DUMMY 1188 if (!devname) 1189 devname = "deviceless"; 1190 1191 /* If the board didn't flag that it was fully constrained then 1192 * substitute in a dummy regulator so consumers can continue. 1193 */ 1194 if (!has_full_constraints) { 1195 pr_warn("%s supply %s not found, using dummy regulator\n", 1196 devname, id); 1197 rdev = dummy_regulator_rdev; 1198 goto found; 1199 } 1200#endif 1201 1202 mutex_unlock(®ulator_list_mutex); 1203 return regulator; 1204 1205found: 1206 if (rdev->exclusive) { 1207 regulator = ERR_PTR(-EPERM); 1208 goto out; 1209 } 1210 1211 if (exclusive && rdev->open_count) { 1212 regulator = ERR_PTR(-EBUSY); 1213 goto out; 1214 } 1215 1216 if (!try_module_get(rdev->owner)) 1217 goto out; 1218 1219 regulator = create_regulator(rdev, dev, id); 1220 if (regulator == NULL) { 1221 regulator = ERR_PTR(-ENOMEM); 1222 module_put(rdev->owner); 1223 } 1224 1225 rdev->open_count++; 1226 if (exclusive) { 1227 rdev->exclusive = 1; 1228 1229 ret = _regulator_is_enabled(rdev); 1230 if (ret > 0) 1231 rdev->use_count = 1; 1232 else 1233 rdev->use_count = 0; 1234 } 1235 1236out: 1237 mutex_unlock(®ulator_list_mutex); 1238 1239 return regulator; 1240} 1241 1242/** 1243 * regulator_get - lookup and obtain a reference to a regulator. 1244 * @dev: device for regulator "consumer" 1245 * @id: Supply name or regulator ID. 1246 * 1247 * Returns a struct regulator corresponding to the regulator producer, 1248 * or IS_ERR() condition containing errno. 1249 * 1250 * Use of supply names configured via regulator_set_device_supply() is 1251 * strongly encouraged. It is recommended that the supply name used 1252 * should match the name used for the supply and/or the relevant 1253 * device pins in the datasheet. 1254 */ 1255struct regulator *regulator_get(struct device *dev, const char *id) 1256{ 1257 return _regulator_get(dev, id, 0); 1258} 1259EXPORT_SYMBOL_GPL(regulator_get); 1260 1261/** 1262 * regulator_get_exclusive - obtain exclusive access to a regulator. 1263 * @dev: device for regulator "consumer" 1264 * @id: Supply name or regulator ID. 1265 * 1266 * Returns a struct regulator corresponding to the regulator producer, 1267 * or IS_ERR() condition containing errno. Other consumers will be 1268 * unable to obtain this reference is held and the use count for the 1269 * regulator will be initialised to reflect the current state of the 1270 * regulator. 1271 * 1272 * This is intended for use by consumers which cannot tolerate shared 1273 * use of the regulator such as those which need to force the 1274 * regulator off for correct operation of the hardware they are 1275 * controlling. 1276 * 1277 * Use of supply names configured via regulator_set_device_supply() is 1278 * strongly encouraged. It is recommended that the supply name used 1279 * should match the name used for the supply and/or the relevant 1280 * device pins in the datasheet. 1281 */ 1282struct regulator *regulator_get_exclusive(struct device *dev, const char *id) 1283{ 1284 return _regulator_get(dev, id, 1); 1285} 1286EXPORT_SYMBOL_GPL(regulator_get_exclusive); 1287 1288/** 1289 * regulator_put - "free" the regulator source 1290 * @regulator: regulator source 1291 * 1292 * Note: drivers must ensure that all regulator_enable calls made on this 1293 * regulator source are balanced by regulator_disable calls prior to calling 1294 * this function. 1295 */ 1296void regulator_put(struct regulator *regulator) 1297{ 1298 struct regulator_dev *rdev; 1299 1300 if (regulator == NULL || IS_ERR(regulator)) 1301 return; 1302 1303 mutex_lock(®ulator_list_mutex); 1304 rdev = regulator->rdev; 1305 1306#ifdef CONFIG_DEBUG_FS 1307 debugfs_remove_recursive(regulator->debugfs); 1308#endif 1309 1310 /* remove any sysfs entries */ 1311 if (regulator->dev) { 1312 sysfs_remove_link(&rdev->dev.kobj, regulator->supply_name); 1313 device_remove_file(regulator->dev, ®ulator->dev_attr); 1314 kfree(regulator->dev_attr.attr.name); 1315 } 1316 kfree(regulator->supply_name); 1317 list_del(®ulator->list); 1318 kfree(regulator); 1319 1320 rdev->open_count--; 1321 rdev->exclusive = 0; 1322 1323 module_put(rdev->owner); 1324 mutex_unlock(®ulator_list_mutex); 1325} 1326EXPORT_SYMBOL_GPL(regulator_put); 1327 1328static int _regulator_can_change_status(struct regulator_dev *rdev) 1329{ 1330 if (!rdev->constraints) 1331 return 0; 1332 1333 if (rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_STATUS) 1334 return 1; 1335 else 1336 return 0; 1337} 1338 1339/* locks held by regulator_enable() */ 1340static int _regulator_enable(struct regulator_dev *rdev) 1341{ 1342 int ret, delay; 1343 1344 /* check voltage and requested load before enabling */ 1345 if (rdev->constraints && 1346 (rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_DRMS)) 1347 drms_uA_update(rdev); 1348 1349 if (rdev->use_count == 0) { 1350 /* The regulator may on if it's not switchable or left on */ 1351 ret = _regulator_is_enabled(rdev); 1352 if (ret == -EINVAL || ret == 0) { 1353 if (!_regulator_can_change_status(rdev)) 1354 return -EPERM; 1355 1356 if (!rdev->desc->ops->enable) 1357 return -EINVAL; 1358 1359 /* Query before enabling in case configuration 1360 * dependent. */ 1361 ret = _regulator_get_enable_time(rdev); 1362 if (ret >= 0) { 1363 delay = ret; 1364 } else { 1365 rdev_warn(rdev, "enable_time() failed: %d\n", 1366 ret); 1367 delay = 0; 1368 } 1369 1370 trace_regulator_enable(rdev_get_name(rdev)); 1371 1372 /* Allow the regulator to ramp; it would be useful 1373 * to extend this for bulk operations so that the 1374 * regulators can ramp together. */ 1375 ret = rdev->desc->ops->enable(rdev); 1376 if (ret < 0) 1377 return ret; 1378 1379 trace_regulator_enable_delay(rdev_get_name(rdev)); 1380 1381 if (delay >= 1000) { 1382 mdelay(delay / 1000); 1383 udelay(delay % 1000); 1384 } else if (delay) { 1385 udelay(delay); 1386 } 1387 1388 trace_regulator_enable_complete(rdev_get_name(rdev)); 1389 1390 } else if (ret < 0) { 1391 rdev_err(rdev, "is_enabled() failed: %d\n", ret); 1392 return ret; 1393 } 1394 /* Fallthrough on positive return values - already enabled */ 1395 } 1396 1397 rdev->use_count++; 1398 1399 return 0; 1400} 1401 1402/** 1403 * regulator_enable - enable regulator output 1404 * @regulator: regulator source 1405 * 1406 * Request that the regulator be enabled with the regulator output at 1407 * the predefined voltage or current value. Calls to regulator_enable() 1408 * must be balanced with calls to regulator_disable(). 1409 * 1410 * NOTE: the output value can be set by other drivers, boot loader or may be 1411 * hardwired in the regulator. 1412 */ 1413int regulator_enable(struct regulator *regulator) 1414{ 1415 struct regulator_dev *rdev = regulator->rdev; 1416 int ret = 0; 1417 1418 if (rdev->supply) { 1419 ret = regulator_enable(rdev->supply); 1420 if (ret != 0) 1421 return ret; 1422 } 1423 1424 mutex_lock(&rdev->mutex); 1425 ret = _regulator_enable(rdev); 1426 mutex_unlock(&rdev->mutex); 1427 1428 if (ret != 0) 1429 regulator_disable(rdev->supply); 1430 1431 return ret; 1432} 1433EXPORT_SYMBOL_GPL(regulator_enable); 1434 1435/* locks held by regulator_disable() */ 1436static int _regulator_disable(struct regulator_dev *rdev) 1437{ 1438 int ret = 0; 1439 1440 if (WARN(rdev->use_count <= 0, 1441 "unbalanced disables for %s\n", rdev_get_name(rdev))) 1442 return -EIO; 1443 1444 /* are we the last user and permitted to disable ? */ 1445 if (rdev->use_count == 1 && 1446 (rdev->constraints && !rdev->constraints->always_on)) { 1447 1448 /* we are last user */ 1449 if (_regulator_can_change_status(rdev) && 1450 rdev->desc->ops->disable) { 1451 trace_regulator_disable(rdev_get_name(rdev)); 1452 1453 ret = rdev->desc->ops->disable(rdev); 1454 if (ret < 0) { 1455 rdev_err(rdev, "failed to disable\n"); 1456 return ret; 1457 } 1458 1459 trace_regulator_disable_complete(rdev_get_name(rdev)); 1460 1461 _notifier_call_chain(rdev, REGULATOR_EVENT_DISABLE, 1462 NULL); 1463 } 1464 1465 rdev->use_count = 0; 1466 } else if (rdev->use_count > 1) { 1467 1468 if (rdev->constraints && 1469 (rdev->constraints->valid_ops_mask & 1470 REGULATOR_CHANGE_DRMS)) 1471 drms_uA_update(rdev); 1472 1473 rdev->use_count--; 1474 } 1475 1476 return ret; 1477} 1478 1479/** 1480 * regulator_disable - disable regulator output 1481 * @regulator: regulator source 1482 * 1483 * Disable the regulator output voltage or current. Calls to 1484 * regulator_enable() must be balanced with calls to 1485 * regulator_disable(). 1486 * 1487 * NOTE: this will only disable the regulator output if no other consumer 1488 * devices have it enabled, the regulator device supports disabling and 1489 * machine constraints permit this operation. 1490 */ 1491int regulator_disable(struct regulator *regulator) 1492{ 1493 struct regulator_dev *rdev = regulator->rdev; 1494 int ret = 0; 1495 1496 mutex_lock(&rdev->mutex); 1497 ret = _regulator_disable(rdev); 1498 mutex_unlock(&rdev->mutex); 1499 1500 if (ret == 0 && rdev->supply) 1501 regulator_disable(rdev->supply); 1502 1503 return ret; 1504} 1505EXPORT_SYMBOL_GPL(regulator_disable); 1506 1507/* locks held by regulator_force_disable() */ 1508static int _regulator_force_disable(struct regulator_dev *rdev) 1509{ 1510 int ret = 0; 1511 1512 /* force disable */ 1513 if (rdev->desc->ops->disable) { 1514 /* ah well, who wants to live forever... */ 1515 ret = rdev->desc->ops->disable(rdev); 1516 if (ret < 0) { 1517 rdev_err(rdev, "failed to force disable\n"); 1518 return ret; 1519 } 1520 /* notify other consumers that power has been forced off */ 1521 _notifier_call_chain(rdev, REGULATOR_EVENT_FORCE_DISABLE | 1522 REGULATOR_EVENT_DISABLE, NULL); 1523 } 1524 1525 return ret; 1526} 1527 1528/** 1529 * regulator_force_disable - force disable regulator output 1530 * @regulator: regulator source 1531 * 1532 * Forcibly disable the regulator output voltage or current. 1533 * NOTE: this *will* disable the regulator output even if other consumer 1534 * devices have it enabled. This should be used for situations when device 1535 * damage will likely occur if the regulator is not disabled (e.g. over temp). 1536 */ 1537int regulator_force_disable(struct regulator *regulator) 1538{ 1539 struct regulator_dev *rdev = regulator->rdev; 1540 int ret; 1541 1542 mutex_lock(&rdev->mutex); 1543 regulator->uA_load = 0; 1544 ret = _regulator_force_disable(regulator->rdev); 1545 mutex_unlock(&rdev->mutex); 1546 1547 if (rdev->supply) 1548 while (rdev->open_count--) 1549 regulator_disable(rdev->supply); 1550 1551 return ret; 1552} 1553EXPORT_SYMBOL_GPL(regulator_force_disable); 1554 1555static void regulator_disable_work(struct work_struct *work) 1556{ 1557 struct regulator_dev *rdev = container_of(work, struct regulator_dev, 1558 disable_work.work); 1559 int count, i, ret; 1560 1561 mutex_lock(&rdev->mutex); 1562 1563 BUG_ON(!rdev->deferred_disables); 1564 1565 count = rdev->deferred_disables; 1566 rdev->deferred_disables = 0; 1567 1568 for (i = 0; i < count; i++) { 1569 ret = _regulator_disable(rdev); 1570 if (ret != 0) 1571 rdev_err(rdev, "Deferred disable failed: %d\n", ret); 1572 } 1573 1574 mutex_unlock(&rdev->mutex); 1575 1576 if (rdev->supply) { 1577 for (i = 0; i < count; i++) { 1578 ret = regulator_disable(rdev->supply); 1579 if (ret != 0) { 1580 rdev_err(rdev, 1581 "Supply disable failed: %d\n", ret); 1582 } 1583 } 1584 } 1585} 1586 1587/** 1588 * regulator_disable_deferred - disable regulator output with delay 1589 * @regulator: regulator source 1590 * @ms: miliseconds until the regulator is disabled 1591 * 1592 * Execute regulator_disable() on the regulator after a delay. This 1593 * is intended for use with devices that require some time to quiesce. 1594 * 1595 * NOTE: this will only disable the regulator output if no other consumer 1596 * devices have it enabled, the regulator device supports disabling and 1597 * machine constraints permit this operation. 1598 */ 1599int regulator_disable_deferred(struct regulator *regulator, int ms) 1600{ 1601 struct regulator_dev *rdev = regulator->rdev; 1602 1603 mutex_lock(&rdev->mutex); 1604 rdev->deferred_disables++; 1605 mutex_unlock(&rdev->mutex); 1606 1607 return schedule_delayed_work(&rdev->disable_work, 1608 msecs_to_jiffies(ms)); 1609} 1610EXPORT_SYMBOL_GPL(regulator_disable_deferred); 1611 1612static int _regulator_is_enabled(struct regulator_dev *rdev) 1613{ 1614 /* If we don't know then assume that the regulator is always on */ 1615 if (!rdev->desc->ops->is_enabled) 1616 return 1; 1617 1618 return rdev->desc->ops->is_enabled(rdev); 1619} 1620 1621/** 1622 * regulator_is_enabled - is the regulator output enabled 1623 * @regulator: regulator source 1624 * 1625 * Returns positive if the regulator driver backing the source/client 1626 * has requested that the device be enabled, zero if it hasn't, else a 1627 * negative errno code. 1628 * 1629 * Note that the device backing this regulator handle can have multiple 1630 * users, so it might be enabled even if regulator_enable() was never 1631 * called for this particular source. 1632 */ 1633int regulator_is_enabled(struct regulator *regulator) 1634{ 1635 int ret; 1636 1637 mutex_lock(®ulator->rdev->mutex); 1638 ret = _regulator_is_enabled(regulator->rdev); 1639 mutex_unlock(®ulator->rdev->mutex); 1640 1641 return ret; 1642} 1643EXPORT_SYMBOL_GPL(regulator_is_enabled); 1644 1645/** 1646 * regulator_count_voltages - count regulator_list_voltage() selectors 1647 * @regulator: regulator source 1648 * 1649 * Returns number of selectors, or negative errno. Selectors are 1650 * numbered starting at zero, and typically correspond to bitfields 1651 * in hardware registers. 1652 */ 1653int regulator_count_voltages(struct regulator *regulator) 1654{ 1655 struct regulator_dev *rdev = regulator->rdev; 1656 1657 return rdev->desc->n_voltages ? : -EINVAL; 1658} 1659EXPORT_SYMBOL_GPL(regulator_count_voltages); 1660 1661/** 1662 * regulator_list_voltage - enumerate supported voltages 1663 * @regulator: regulator source 1664 * @selector: identify voltage to list 1665 * Context: can sleep 1666 * 1667 * Returns a voltage that can be passed to @regulator_set_voltage(), 1668 * zero if this selector code can't be used on this system, or a 1669 * negative errno. 1670 */ 1671int regulator_list_voltage(struct regulator *regulator, unsigned selector) 1672{ 1673 struct regulator_dev *rdev = regulator->rdev; 1674 struct regulator_ops *ops = rdev->desc->ops; 1675 int ret; 1676 1677 if (!ops->list_voltage || selector >= rdev->desc->n_voltages) 1678 return -EINVAL; 1679 1680 mutex_lock(&rdev->mutex); 1681 ret = ops->list_voltage(rdev, selector); 1682 mutex_unlock(&rdev->mutex); 1683 1684 if (ret > 0) { 1685 if (ret < rdev->constraints->min_uV) 1686 ret = 0; 1687 else if (ret > rdev->constraints->max_uV) 1688 ret = 0; 1689 } 1690 1691 return ret; 1692} 1693EXPORT_SYMBOL_GPL(regulator_list_voltage); 1694 1695/** 1696 * regulator_is_supported_voltage - check if a voltage range can be supported 1697 * 1698 * @regulator: Regulator to check. 1699 * @min_uV: Minimum required voltage in uV. 1700 * @max_uV: Maximum required voltage in uV. 1701 * 1702 * Returns a boolean or a negative error code. 1703 */ 1704int regulator_is_supported_voltage(struct regulator *regulator, 1705 int min_uV, int max_uV) 1706{ 1707 int i, voltages, ret; 1708 1709 ret = regulator_count_voltages(regulator); 1710 if (ret < 0) 1711 return ret; 1712 voltages = ret; 1713 1714 for (i = 0; i < voltages; i++) { 1715 ret = regulator_list_voltage(regulator, i); 1716 1717 if (ret >= min_uV && ret <= max_uV) 1718 return 1; 1719 } 1720 1721 return 0; 1722} 1723 1724static int _regulator_do_set_voltage(struct regulator_dev *rdev, 1725 int min_uV, int max_uV) 1726{ 1727 int ret; 1728 int delay = 0; 1729 unsigned int selector; 1730 1731 trace_regulator_set_voltage(rdev_get_name(rdev), min_uV, max_uV); 1732 1733 min_uV += rdev->constraints->uV_offset; 1734 max_uV += rdev->constraints->uV_offset; 1735 1736 if (rdev->desc->ops->set_voltage) { 1737 ret = rdev->desc->ops->set_voltage(rdev, min_uV, max_uV, 1738 &selector); 1739 1740 if (rdev->desc->ops->list_voltage) 1741 selector = rdev->desc->ops->list_voltage(rdev, 1742 selector); 1743 else 1744 selector = -1; 1745 } else if (rdev->desc->ops->set_voltage_sel) { 1746 int best_val = INT_MAX; 1747 int i; 1748 1749 selector = 0; 1750 1751 /* Find the smallest voltage that falls within the specified 1752 * range. 1753 */ 1754 for (i = 0; i < rdev->desc->n_voltages; i++) { 1755 ret = rdev->desc->ops->list_voltage(rdev, i); 1756 if (ret < 0) 1757 continue; 1758 1759 if (ret < best_val && ret >= min_uV && ret <= max_uV) { 1760 best_val = ret; 1761 selector = i; 1762 } 1763 } 1764 1765 /* 1766 * If we can't obtain the old selector there is not enough 1767 * info to call set_voltage_time_sel(). 1768 */ 1769 if (rdev->desc->ops->set_voltage_time_sel && 1770 rdev->desc->ops->get_voltage_sel) { 1771 unsigned int old_selector = 0; 1772 1773 ret = rdev->desc->ops->get_voltage_sel(rdev); 1774 if (ret < 0) 1775 return ret; 1776 old_selector = ret; 1777 delay = rdev->desc->ops->set_voltage_time_sel(rdev, 1778 old_selector, selector); 1779 } 1780 1781 if (best_val != INT_MAX) { 1782 ret = rdev->desc->ops->set_voltage_sel(rdev, selector); 1783 selector = best_val; 1784 } else { 1785 ret = -EINVAL; 1786 } 1787 } else { 1788 ret = -EINVAL; 1789 } 1790 1791 /* Insert any necessary delays */ 1792 if (delay >= 1000) { 1793 mdelay(delay / 1000); 1794 udelay(delay % 1000); 1795 } else if (delay) { 1796 udelay(delay); 1797 } 1798 1799 if (ret == 0) 1800 _notifier_call_chain(rdev, REGULATOR_EVENT_VOLTAGE_CHANGE, 1801 NULL); 1802 1803 trace_regulator_set_voltage_complete(rdev_get_name(rdev), selector); 1804 1805 return ret; 1806} 1807 1808/** 1809 * regulator_set_voltage - set regulator output voltage 1810 * @regulator: regulator source 1811 * @min_uV: Minimum required voltage in uV 1812 * @max_uV: Maximum acceptable voltage in uV 1813 * 1814 * Sets a voltage regulator to the desired output voltage. This can be set 1815 * during any regulator state. IOW, regulator can be disabled or enabled. 1816 * 1817 * If the regulator is enabled then the voltage will change to the new value 1818 * immediately otherwise if the regulator is disabled the regulator will 1819 * output at the new voltage when enabled. 1820 * 1821 * NOTE: If the regulator is shared between several devices then the lowest 1822 * request voltage that meets the system constraints will be used. 1823 * Regulator system constraints must be set for this regulator before 1824 * calling this function otherwise this call will fail. 1825 */ 1826int regulator_set_voltage(struct regulator *regulator, int min_uV, int max_uV) 1827{ 1828 struct regulator_dev *rdev = regulator->rdev; 1829 int ret = 0; 1830 1831 mutex_lock(&rdev->mutex); 1832 1833 /* If we're setting the same range as last time the change 1834 * should be a noop (some cpufreq implementations use the same 1835 * voltage for multiple frequencies, for example). 1836 */ 1837 if (regulator->min_uV == min_uV && regulator->max_uV == max_uV) 1838 goto out; 1839 1840 /* sanity check */ 1841 if (!rdev->desc->ops->set_voltage && 1842 !rdev->desc->ops->set_voltage_sel) { 1843 ret = -EINVAL; 1844 goto out; 1845 } 1846 1847 /* constraints check */ 1848 ret = regulator_check_voltage(rdev, &min_uV, &max_uV); 1849 if (ret < 0) 1850 goto out; 1851 regulator->min_uV = min_uV; 1852 regulator->max_uV = max_uV; 1853 1854 ret = regulator_check_consumers(rdev, &min_uV, &max_uV); 1855 if (ret < 0) 1856 goto out; 1857 1858 ret = _regulator_do_set_voltage(rdev, min_uV, max_uV); 1859 1860out: 1861 mutex_unlock(&rdev->mutex); 1862 return ret; 1863} 1864EXPORT_SYMBOL_GPL(regulator_set_voltage); 1865 1866/** 1867 * regulator_set_voltage_time - get raise/fall time 1868 * @regulator: regulator source 1869 * @old_uV: starting voltage in microvolts 1870 * @new_uV: target voltage in microvolts 1871 * 1872 * Provided with the starting and ending voltage, this function attempts to 1873 * calculate the time in microseconds required to rise or fall to this new 1874 * voltage. 1875 */ 1876int regulator_set_voltage_time(struct regulator *regulator, 1877 int old_uV, int new_uV) 1878{ 1879 struct regulator_dev *rdev = regulator->rdev; 1880 struct regulator_ops *ops = rdev->desc->ops; 1881 int old_sel = -1; 1882 int new_sel = -1; 1883 int voltage; 1884 int i; 1885 1886 /* Currently requires operations to do this */ 1887 if (!ops->list_voltage || !ops->set_voltage_time_sel 1888 || !rdev->desc->n_voltages) 1889 return -EINVAL; 1890 1891 for (i = 0; i < rdev->desc->n_voltages; i++) { 1892 /* We only look for exact voltage matches here */ 1893 voltage = regulator_list_voltage(regulator, i); 1894 if (voltage < 0) 1895 return -EINVAL; 1896 if (voltage == 0) 1897 continue; 1898 if (voltage == old_uV) 1899 old_sel = i; 1900 if (voltage == new_uV) 1901 new_sel = i; 1902 } 1903 1904 if (old_sel < 0 || new_sel < 0) 1905 return -EINVAL; 1906 1907 return ops->set_voltage_time_sel(rdev, old_sel, new_sel); 1908} 1909EXPORT_SYMBOL_GPL(regulator_set_voltage_time); 1910 1911/** 1912 * regulator_sync_voltage - re-apply last regulator output voltage 1913 * @regulator: regulator source 1914 * 1915 * Re-apply the last configured voltage. This is intended to be used 1916 * where some external control source the consumer is cooperating with 1917 * has caused the configured voltage to change. 1918 */ 1919int regulator_sync_voltage(struct regulator *regulator) 1920{ 1921 struct regulator_dev *rdev = regulator->rdev; 1922 int ret, min_uV, max_uV; 1923 1924 mutex_lock(&rdev->mutex); 1925 1926 if (!rdev->desc->ops->set_voltage && 1927 !rdev->desc->ops->set_voltage_sel) { 1928 ret = -EINVAL; 1929 goto out; 1930 } 1931 1932 /* This is only going to work if we've had a voltage configured. */ 1933 if (!regulator->min_uV && !regulator->max_uV) { 1934 ret = -EINVAL; 1935 goto out; 1936 } 1937 1938 min_uV = regulator->min_uV; 1939 max_uV = regulator->max_uV; 1940 1941 /* This should be a paranoia check... */ 1942 ret = regulator_check_voltage(rdev, &min_uV, &max_uV); 1943 if (ret < 0) 1944 goto out; 1945 1946 ret = regulator_check_consumers(rdev, &min_uV, &max_uV); 1947 if (ret < 0) 1948 goto out; 1949 1950 ret = _regulator_do_set_voltage(rdev, min_uV, max_uV); 1951 1952out: 1953 mutex_unlock(&rdev->mutex); 1954 return ret; 1955} 1956EXPORT_SYMBOL_GPL(regulator_sync_voltage); 1957 1958static int _regulator_get_voltage(struct regulator_dev *rdev) 1959{ 1960 int sel, ret; 1961 1962 if (rdev->desc->ops->get_voltage_sel) { 1963 sel = rdev->desc->ops->get_voltage_sel(rdev); 1964 if (sel < 0) 1965 return sel; 1966 ret = rdev->desc->ops->list_voltage(rdev, sel); 1967 } else if (rdev->desc->ops->get_voltage) { 1968 ret = rdev->desc->ops->get_voltage(rdev); 1969 } else { 1970 return -EINVAL; 1971 } 1972 1973 if (ret < 0) 1974 return ret; 1975 return ret - rdev->constraints->uV_offset; 1976} 1977 1978/** 1979 * regulator_get_voltage - get regulator output voltage 1980 * @regulator: regulator source 1981 * 1982 * This returns the current regulator voltage in uV. 1983 * 1984 * NOTE: If the regulator is disabled it will return the voltage value. This 1985 * function should not be used to determine regulator state. 1986 */ 1987int regulator_get_voltage(struct regulator *regulator) 1988{ 1989 int ret; 1990 1991 mutex_lock(®ulator->rdev->mutex); 1992 1993 ret = _regulator_get_voltage(regulator->rdev); 1994 1995 mutex_unlock(®ulator->rdev->mutex); 1996 1997 return ret; 1998} 1999EXPORT_SYMBOL_GPL(regulator_get_voltage); 2000 2001/** 2002 * regulator_set_current_limit - set regulator output current limit 2003 * @regulator: regulator source 2004 * @min_uA: Minimuum supported current in uA 2005 * @max_uA: Maximum supported current in uA 2006 * 2007 * Sets current sink to the desired output current. This can be set during 2008 * any regulator state. IOW, regulator can be disabled or enabled. 2009 * 2010 * If the regulator is enabled then the current will change to the new value 2011 * immediately otherwise if the regulator is disabled the regulator will 2012 * output at the new current when enabled. 2013 * 2014 * NOTE: Regulator system constraints must be set for this regulator before 2015 * calling this function otherwise this call will fail. 2016 */ 2017int regulator_set_current_limit(struct regulator *regulator, 2018 int min_uA, int max_uA) 2019{ 2020 struct regulator_dev *rdev = regulator->rdev; 2021 int ret; 2022 2023 mutex_lock(&rdev->mutex); 2024 2025 /* sanity check */ 2026 if (!rdev->desc->ops->set_current_limit) { 2027 ret = -EINVAL; 2028 goto out; 2029 } 2030 2031 /* constraints check */ 2032 ret = regulator_check_current_limit(rdev, &min_uA, &max_uA); 2033 if (ret < 0) 2034 goto out; 2035 2036 ret = rdev->desc->ops->set_current_limit(rdev, min_uA, max_uA); 2037out: 2038 mutex_unlock(&rdev->mutex); 2039 return ret; 2040} 2041EXPORT_SYMBOL_GPL(regulator_set_current_limit); 2042 2043static int _regulator_get_current_limit(struct regulator_dev *rdev) 2044{ 2045 int ret; 2046 2047 mutex_lock(&rdev->mutex); 2048 2049 /* sanity check */ 2050 if (!rdev->desc->ops->get_current_limit) { 2051 ret = -EINVAL; 2052 goto out; 2053 } 2054 2055 ret = rdev->desc->ops->get_current_limit(rdev); 2056out: 2057 mutex_unlock(&rdev->mutex); 2058 return ret; 2059} 2060 2061/** 2062 * regulator_get_current_limit - get regulator output current 2063 * @regulator: regulator source 2064 * 2065 * This returns the current supplied by the specified current sink in uA. 2066 * 2067 * NOTE: If the regulator is disabled it will return the current value. This 2068 * function should not be used to determine regulator state. 2069 */ 2070int regulator_get_current_limit(struct regulator *regulator) 2071{ 2072 return _regulator_get_current_limit(regulator->rdev); 2073} 2074EXPORT_SYMBOL_GPL(regulator_get_current_limit); 2075 2076/** 2077 * regulator_set_mode - set regulator operating mode 2078 * @regulator: regulator source 2079 * @mode: operating mode - one of the REGULATOR_MODE constants 2080 * 2081 * Set regulator operating mode to increase regulator efficiency or improve 2082 * regulation performance. 2083 * 2084 * NOTE: Regulator system constraints must be set for this regulator before 2085 * calling this function otherwise this call will fail. 2086 */ 2087int regulator_set_mode(struct regulator *regulator, unsigned int mode) 2088{ 2089 struct regulator_dev *rdev = regulator->rdev; 2090 int ret; 2091 int regulator_curr_mode; 2092 2093 mutex_lock(&rdev->mutex); 2094 2095 /* sanity check */ 2096 if (!rdev->desc->ops->set_mode) { 2097 ret = -EINVAL; 2098 goto out; 2099 } 2100 2101 /* return if the same mode is requested */ 2102 if (rdev->desc->ops->get_mode) { 2103 regulator_curr_mode = rdev->desc->ops->get_mode(rdev); 2104 if (regulator_curr_mode == mode) { 2105 ret = 0; 2106 goto out; 2107 } 2108 } 2109 2110 /* constraints check */ 2111 ret = regulator_mode_constrain(rdev, &mode); 2112 if (ret < 0) 2113 goto out; 2114 2115 ret = rdev->desc->ops->set_mode(rdev, mode); 2116out: 2117 mutex_unlock(&rdev->mutex); 2118 return ret; 2119} 2120EXPORT_SYMBOL_GPL(regulator_set_mode); 2121 2122static unsigned int _regulator_get_mode(struct regulator_dev *rdev) 2123{ 2124 int ret; 2125 2126 mutex_lock(&rdev->mutex); 2127 2128 /* sanity check */ 2129 if (!rdev->desc->ops->get_mode) { 2130 ret = -EINVAL; 2131 goto out; 2132 } 2133 2134 ret = rdev->desc->ops->get_mode(rdev); 2135out: 2136 mutex_unlock(&rdev->mutex); 2137 return ret; 2138} 2139 2140/** 2141 * regulator_get_mode - get regulator operating mode 2142 * @regulator: regulator source 2143 * 2144 * Get the current regulator operating mode. 2145 */ 2146unsigned int regulator_get_mode(struct regulator *regulator) 2147{ 2148 return _regulator_get_mode(regulator->rdev); 2149} 2150EXPORT_SYMBOL_GPL(regulator_get_mode); 2151 2152/** 2153 * regulator_set_optimum_mode - set regulator optimum operating mode 2154 * @regulator: regulator source 2155 * @uA_load: load current 2156 * 2157 * Notifies the regulator core of a new device load. This is then used by 2158 * DRMS (if enabled by constraints) to set the most efficient regulator 2159 * operating mode for the new regulator loading. 2160 * 2161 * Consumer devices notify their supply regulator of the maximum power 2162 * they will require (can be taken from device datasheet in the power 2163 * consumption tables) when they change operational status and hence power 2164 * state. Examples of operational state changes that can affect power 2165 * consumption are :- 2166 * 2167 * o Device is opened / closed. 2168 * o Device I/O is about to begin or has just finished. 2169 * o Device is idling in between work. 2170 * 2171 * This information is also exported via sysfs to userspace. 2172 * 2173 * DRMS will sum the total requested load on the regulator and change 2174 * to the most efficient operating mode if platform constraints allow. 2175 * 2176 * Returns the new regulator mode or error. 2177 */ 2178int regulator_set_optimum_mode(struct regulator *regulator, int uA_load) 2179{ 2180 struct regulator_dev *rdev = regulator->rdev; 2181 struct regulator *consumer; 2182 int ret, output_uV, input_uV, total_uA_load = 0; 2183 unsigned int mode; 2184 2185 mutex_lock(&rdev->mutex); 2186 2187 /* 2188 * first check to see if we can set modes at all, otherwise just 2189 * tell the consumer everything is OK. 2190 */ 2191 regulator->uA_load = uA_load; 2192 ret = regulator_check_drms(rdev); 2193 if (ret < 0) { 2194 ret = 0; 2195 goto out; 2196 } 2197 2198 if (!rdev->desc->ops->get_optimum_mode) 2199 goto out; 2200 2201 /* 2202 * we can actually do this so any errors are indicators of 2203 * potential real failure. 2204 */ 2205 ret = -EINVAL; 2206 2207 /* get output voltage */ 2208 output_uV = _regulator_get_voltage(rdev); 2209 if (output_uV <= 0) { 2210 rdev_err(rdev, "invalid output voltage found\n"); 2211 goto out; 2212 } 2213 2214 /* get input voltage */ 2215 input_uV = 0; 2216 if (rdev->supply) 2217 input_uV = regulator_get_voltage(rdev->supply); 2218 if (input_uV <= 0) 2219 input_uV = rdev->constraints->input_uV; 2220 if (input_uV <= 0) { 2221 rdev_err(rdev, "invalid input voltage found\n"); 2222 goto out; 2223 } 2224 2225 /* calc total requested load for this regulator */ 2226 list_for_each_entry(consumer, &rdev->consumer_list, list) 2227 total_uA_load += consumer->uA_load; 2228 2229 mode = rdev->desc->ops->get_optimum_mode(rdev, 2230 input_uV, output_uV, 2231 total_uA_load); 2232 ret = regulator_mode_constrain(rdev, &mode); 2233 if (ret < 0) { 2234 rdev_err(rdev, "failed to get optimum mode @ %d uA %d -> %d uV\n", 2235 total_uA_load, input_uV, output_uV); 2236 goto out; 2237 } 2238 2239 ret = rdev->desc->ops->set_mode(rdev, mode); 2240 if (ret < 0) { 2241 rdev_err(rdev, "failed to set optimum mode %x\n", mode); 2242 goto out; 2243 } 2244 ret = mode; 2245out: 2246 mutex_unlock(&rdev->mutex); 2247 return ret; 2248} 2249EXPORT_SYMBOL_GPL(regulator_set_optimum_mode); 2250 2251/** 2252 * regulator_register_notifier - register regulator event notifier 2253 * @regulator: regulator source 2254 * @nb: notifier block 2255 * 2256 * Register notifier block to receive regulator events. 2257 */ 2258int regulator_register_notifier(struct regulator *regulator, 2259 struct notifier_block *nb) 2260{ 2261 return blocking_notifier_chain_register(®ulator->rdev->notifier, 2262 nb); 2263} 2264EXPORT_SYMBOL_GPL(regulator_register_notifier); 2265 2266/** 2267 * regulator_unregister_notifier - unregister regulator event notifier 2268 * @regulator: regulator source 2269 * @nb: notifier block 2270 * 2271 * Unregister regulator event notifier block. 2272 */ 2273int regulator_unregister_notifier(struct regulator *regulator, 2274 struct notifier_block *nb) 2275{ 2276 return blocking_notifier_chain_unregister(®ulator->rdev->notifier, 2277 nb); 2278} 2279EXPORT_SYMBOL_GPL(regulator_unregister_notifier); 2280 2281/* notify regulator consumers and downstream regulator consumers. 2282 * Note mutex must be held by caller. 2283 */ 2284static void _notifier_call_chain(struct regulator_dev *rdev, 2285 unsigned long event, void *data) 2286{ 2287 /* call rdev chain first */ 2288 blocking_notifier_call_chain(&rdev->notifier, event, NULL); 2289} 2290 2291/** 2292 * regulator_bulk_get - get multiple regulator consumers 2293 * 2294 * @dev: Device to supply 2295 * @num_consumers: Number of consumers to register 2296 * @consumers: Configuration of consumers; clients are stored here. 2297 * 2298 * @return 0 on success, an errno on failure. 2299 * 2300 * This helper function allows drivers to get several regulator 2301 * consumers in one operation. If any of the regulators cannot be 2302 * acquired then any regulators that were allocated will be freed 2303 * before returning to the caller. 2304 */ 2305int regulator_bulk_get(struct device *dev, int num_consumers, 2306 struct regulator_bulk_data *consumers) 2307{ 2308 int i; 2309 int ret; 2310 2311 for (i = 0; i < num_consumers; i++) 2312 consumers[i].consumer = NULL; 2313 2314 for (i = 0; i < num_consumers; i++) { 2315 consumers[i].consumer = regulator_get(dev, 2316 consumers[i].supply); 2317 if (IS_ERR(consumers[i].consumer)) { 2318 ret = PTR_ERR(consumers[i].consumer); 2319 dev_err(dev, "Failed to get supply '%s': %d\n", 2320 consumers[i].supply, ret); 2321 consumers[i].consumer = NULL; 2322 goto err; 2323 } 2324 } 2325 2326 return 0; 2327 2328err: 2329 for (i = 0; i < num_consumers && consumers[i].consumer; i++) 2330 regulator_put(consumers[i].consumer); 2331 2332 return ret; 2333} 2334EXPORT_SYMBOL_GPL(regulator_bulk_get); 2335 2336static void regulator_bulk_enable_async(void *data, async_cookie_t cookie) 2337{ 2338 struct regulator_bulk_data *bulk = data; 2339 2340 bulk->ret = regulator_enable(bulk->consumer); 2341} 2342 2343/** 2344 * regulator_bulk_enable - enable multiple regulator consumers 2345 * 2346 * @num_consumers: Number of consumers 2347 * @consumers: Consumer data; clients are stored here. 2348 * @return 0 on success, an errno on failure 2349 * 2350 * This convenience API allows consumers to enable multiple regulator 2351 * clients in a single API call. If any consumers cannot be enabled 2352 * then any others that were enabled will be disabled again prior to 2353 * return. 2354 */ 2355int regulator_bulk_enable(int num_consumers, 2356 struct regulator_bulk_data *consumers) 2357{ 2358 LIST_HEAD(async_domain); 2359 int i; 2360 int ret = 0; 2361 2362 for (i = 0; i < num_consumers; i++) 2363 async_schedule_domain(regulator_bulk_enable_async, 2364 &consumers[i], &async_domain); 2365 2366 async_synchronize_full_domain(&async_domain); 2367 2368 /* If any consumer failed we need to unwind any that succeeded */ 2369 for (i = 0; i < num_consumers; i++) { 2370 if (consumers[i].ret != 0) { 2371 ret = consumers[i].ret; 2372 goto err; 2373 } 2374 } 2375 2376 return 0; 2377 2378err: 2379 for (i = 0; i < num_consumers; i++) 2380 if (consumers[i].ret == 0) 2381 regulator_disable(consumers[i].consumer); 2382 else 2383 pr_err("Failed to enable %s: %d\n", 2384 consumers[i].supply, consumers[i].ret); 2385 2386 return ret; 2387} 2388EXPORT_SYMBOL_GPL(regulator_bulk_enable); 2389 2390/** 2391 * regulator_bulk_disable - disable multiple regulator consumers 2392 * 2393 * @num_consumers: Number of consumers 2394 * @consumers: Consumer data; clients are stored here. 2395 * @return 0 on success, an errno on failure 2396 * 2397 * This convenience API allows consumers to disable multiple regulator 2398 * clients in a single API call. If any consumers cannot be enabled 2399 * then any others that were disabled will be disabled again prior to 2400 * return. 2401 */ 2402int regulator_bulk_disable(int num_consumers, 2403 struct regulator_bulk_data *consumers) 2404{ 2405 int i; 2406 int ret; 2407 2408 for (i = 0; i < num_consumers; i++) { 2409 ret = regulator_disable(consumers[i].consumer); 2410 if (ret != 0) 2411 goto err; 2412 } 2413 2414 return 0; 2415 2416err: 2417 pr_err("Failed to disable %s: %d\n", consumers[i].supply, ret); 2418 for (--i; i >= 0; --i) 2419 regulator_enable(consumers[i].consumer); 2420 2421 return ret; 2422} 2423EXPORT_SYMBOL_GPL(regulator_bulk_disable); 2424 2425/** 2426 * regulator_bulk_free - free multiple regulator consumers 2427 * 2428 * @num_consumers: Number of consumers 2429 * @consumers: Consumer data; clients are stored here. 2430 * 2431 * This convenience API allows consumers to free multiple regulator 2432 * clients in a single API call. 2433 */ 2434void regulator_bulk_free(int num_consumers, 2435 struct regulator_bulk_data *consumers) 2436{ 2437 int i; 2438 2439 for (i = 0; i < num_consumers; i++) { 2440 regulator_put(consumers[i].consumer); 2441 consumers[i].consumer = NULL; 2442 } 2443} 2444EXPORT_SYMBOL_GPL(regulator_bulk_free); 2445 2446/** 2447 * regulator_notifier_call_chain - call regulator event notifier 2448 * @rdev: regulator source 2449 * @event: notifier block 2450 * @data: callback-specific data. 2451 * 2452 * Called by regulator drivers to notify clients a regulator event has 2453 * occurred. We also notify regulator clients downstream. 2454 * Note lock must be held by caller. 2455 */ 2456int regulator_notifier_call_chain(struct regulator_dev *rdev, 2457 unsigned long event, void *data) 2458{ 2459 _notifier_call_chain(rdev, event, data); 2460 return NOTIFY_DONE; 2461 2462} 2463EXPORT_SYMBOL_GPL(regulator_notifier_call_chain); 2464 2465/** 2466 * regulator_mode_to_status - convert a regulator mode into a status 2467 * 2468 * @mode: Mode to convert 2469 * 2470 * Convert a regulator mode into a status. 2471 */ 2472int regulator_mode_to_status(unsigned int mode) 2473{ 2474 switch (mode) { 2475 case REGULATOR_MODE_FAST: 2476 return REGULATOR_STATUS_FAST; 2477 case REGULATOR_MODE_NORMAL: 2478 return REGULATOR_STATUS_NORMAL; 2479 case REGULATOR_MODE_IDLE: 2480 return REGULATOR_STATUS_IDLE; 2481 case REGULATOR_STATUS_STANDBY: 2482 return REGULATOR_STATUS_STANDBY; 2483 default: 2484 return 0; 2485 } 2486} 2487EXPORT_SYMBOL_GPL(regulator_mode_to_status); 2488 2489/* 2490 * To avoid cluttering sysfs (and memory) with useless state, only 2491 * create attributes that can be meaningfully displayed. 2492 */ 2493static int add_regulator_attributes(struct regulator_dev *rdev) 2494{ 2495 struct device *dev = &rdev->dev; 2496 struct regulator_ops *ops = rdev->desc->ops; 2497 int status = 0; 2498 2499 /* some attributes need specific methods to be displayed */ 2500 if (ops->get_voltage || ops->get_voltage_sel) { 2501 status = device_create_file(dev, &dev_attr_microvolts); 2502 if (status < 0) 2503 return status; 2504 } 2505 if (ops->get_current_limit) { 2506 status = device_create_file(dev, &dev_attr_microamps); 2507 if (status < 0) 2508 return status; 2509 } 2510 if (ops->get_mode) { 2511 status = device_create_file(dev, &dev_attr_opmode); 2512 if (status < 0) 2513 return status; 2514 } 2515 if (ops->is_enabled) { 2516 status = device_create_file(dev, &dev_attr_state); 2517 if (status < 0) 2518 return status; 2519 } 2520 if (ops->get_status) { 2521 status = device_create_file(dev, &dev_attr_status); 2522 if (status < 0) 2523 return status; 2524 } 2525 2526 /* some attributes are type-specific */ 2527 if (rdev->desc->type == REGULATOR_CURRENT) { 2528 status = device_create_file(dev, &dev_attr_requested_microamps); 2529 if (status < 0) 2530 return status; 2531 } 2532 2533 /* all the other attributes exist to support constraints; 2534 * don't show them if there are no constraints, or if the 2535 * relevant supporting methods are missing. 2536 */ 2537 if (!rdev->constraints) 2538 return status; 2539 2540 /* constraints need specific supporting methods */ 2541 if (ops->set_voltage || ops->set_voltage_sel) { 2542 status = device_create_file(dev, &dev_attr_min_microvolts); 2543 if (status < 0) 2544 return status; 2545 status = device_create_file(dev, &dev_attr_max_microvolts); 2546 if (status < 0) 2547 return status; 2548 } 2549 if (ops->set_current_limit) { 2550 status = device_create_file(dev, &dev_attr_min_microamps); 2551 if (status < 0) 2552 return status; 2553 status = device_create_file(dev, &dev_attr_max_microamps); 2554 if (status < 0) 2555 return status; 2556 } 2557 2558 /* suspend mode constraints need multiple supporting methods */ 2559 if (!(ops->set_suspend_enable && ops->set_suspend_disable)) 2560 return status; 2561 2562 status = device_create_file(dev, &dev_attr_suspend_standby_state); 2563 if (status < 0) 2564 return status; 2565 status = device_create_file(dev, &dev_attr_suspend_mem_state); 2566 if (status < 0) 2567 return status; 2568 status = device_create_file(dev, &dev_attr_suspend_disk_state); 2569 if (status < 0) 2570 return status; 2571 2572 if (ops->set_suspend_voltage) { 2573 status = device_create_file(dev, 2574 &dev_attr_suspend_standby_microvolts); 2575 if (status < 0) 2576 return status; 2577 status = device_create_file(dev, 2578 &dev_attr_suspend_mem_microvolts); 2579 if (status < 0) 2580 return status; 2581 status = device_create_file(dev, 2582 &dev_attr_suspend_disk_microvolts); 2583 if (status < 0) 2584 return status; 2585 } 2586 2587 if (ops->set_suspend_mode) { 2588 status = device_create_file(dev, 2589 &dev_attr_suspend_standby_mode); 2590 if (status < 0) 2591 return status; 2592 status = device_create_file(dev, 2593 &dev_attr_suspend_mem_mode); 2594 if (status < 0) 2595 return status; 2596 status = device_create_file(dev, 2597 &dev_attr_suspend_disk_mode); 2598 if (status < 0) 2599 return status; 2600 } 2601 2602 return status; 2603} 2604 2605static void rdev_init_debugfs(struct regulator_dev *rdev) 2606{ 2607#ifdef CONFIG_DEBUG_FS 2608 rdev->debugfs = debugfs_create_dir(rdev_get_name(rdev), debugfs_root); 2609 if (IS_ERR(rdev->debugfs) || !rdev->debugfs) { 2610 rdev_warn(rdev, "Failed to create debugfs directory\n"); 2611 rdev->debugfs = NULL; 2612 return; 2613 } 2614 2615 debugfs_create_u32("use_count", 0444, rdev->debugfs, 2616 &rdev->use_count); 2617 debugfs_create_u32("open_count", 0444, rdev->debugfs, 2618 &rdev->open_count); 2619#endif 2620} 2621 2622/** 2623 * regulator_register - register regulator 2624 * @regulator_desc: regulator to register 2625 * @dev: struct device for the regulator 2626 * @init_data: platform provided init data, passed through by driver 2627 * @driver_data: private regulator data 2628 * 2629 * Called by regulator drivers to register a regulator. 2630 * Returns 0 on success. 2631 */ 2632struct regulator_dev *regulator_register(struct regulator_desc *regulator_desc, 2633 struct device *dev, const struct regulator_init_data *init_data, 2634 void *driver_data) 2635{ 2636 static atomic_t regulator_no = ATOMIC_INIT(0); 2637 struct regulator_dev *rdev; 2638 int ret, i; 2639 2640 if (regulator_desc == NULL) 2641 return ERR_PTR(-EINVAL); 2642 2643 if (regulator_desc->name == NULL || regulator_desc->ops == NULL) 2644 return ERR_PTR(-EINVAL); 2645 2646 if (regulator_desc->type != REGULATOR_VOLTAGE && 2647 regulator_desc->type != REGULATOR_CURRENT) 2648 return ERR_PTR(-EINVAL); 2649 2650 if (!init_data) 2651 return ERR_PTR(-EINVAL); 2652 2653 /* Only one of each should be implemented */ 2654 WARN_ON(regulator_desc->ops->get_voltage && 2655 regulator_desc->ops->get_voltage_sel); 2656 WARN_ON(regulator_desc->ops->set_voltage && 2657 regulator_desc->ops->set_voltage_sel); 2658 2659 /* If we're using selectors we must implement list_voltage. */ 2660 if (regulator_desc->ops->get_voltage_sel && 2661 !regulator_desc->ops->list_voltage) { 2662 return ERR_PTR(-EINVAL); 2663 } 2664 if (regulator_desc->ops->set_voltage_sel && 2665 !regulator_desc->ops->list_voltage) { 2666 return ERR_PTR(-EINVAL); 2667 } 2668 2669 rdev = kzalloc(sizeof(struct regulator_dev), GFP_KERNEL); 2670 if (rdev == NULL) 2671 return ERR_PTR(-ENOMEM); 2672 2673 mutex_lock(®ulator_list_mutex); 2674 2675 mutex_init(&rdev->mutex); 2676 rdev->reg_data = driver_data; 2677 rdev->owner = regulator_desc->owner; 2678 rdev->desc = regulator_desc; 2679 INIT_LIST_HEAD(&rdev->consumer_list); 2680 INIT_LIST_HEAD(&rdev->list); 2681 BLOCKING_INIT_NOTIFIER_HEAD(&rdev->notifier); 2682 INIT_DELAYED_WORK(&rdev->disable_work, regulator_disable_work); 2683 2684 /* preform any regulator specific init */ 2685 if (init_data->regulator_init) { 2686 ret = init_data->regulator_init(rdev->reg_data); 2687 if (ret < 0) 2688 goto clean; 2689 } 2690 2691 /* register with sysfs */ 2692 rdev->dev.class = ®ulator_class; 2693 rdev->dev.parent = dev; 2694 dev_set_name(&rdev->dev, "regulator.%d", 2695 atomic_inc_return(®ulator_no) - 1); 2696 ret = device_register(&rdev->dev); 2697 if (ret != 0) { 2698 put_device(&rdev->dev); 2699 goto clean; 2700 } 2701 2702 dev_set_drvdata(&rdev->dev, rdev); 2703 2704 /* set regulator constraints */ 2705 ret = set_machine_constraints(rdev, &init_data->constraints); 2706 if (ret < 0) 2707 goto scrub; 2708 2709 /* add attributes supported by this regulator */ 2710 ret = add_regulator_attributes(rdev); 2711 if (ret < 0) 2712 goto scrub; 2713 2714 if (init_data->supply_regulator) { 2715 struct regulator_dev *r; 2716 int found = 0; 2717 2718 list_for_each_entry(r, ®ulator_list, list) { 2719 if (strcmp(rdev_get_name(r), 2720 init_data->supply_regulator) == 0) { 2721 found = 1; 2722 break; 2723 } 2724 } 2725 2726 if (!found) { 2727 dev_err(dev, "Failed to find supply %s\n", 2728 init_data->supply_regulator); 2729 ret = -ENODEV; 2730 goto scrub; 2731 } 2732 2733 ret = set_supply(rdev, r); 2734 if (ret < 0) 2735 goto scrub; 2736 } 2737 2738 /* add consumers devices */ 2739 for (i = 0; i < init_data->num_consumer_supplies; i++) { 2740 ret = set_consumer_device_supply(rdev, 2741 init_data->consumer_supplies[i].dev, 2742 init_data->consumer_supplies[i].dev_name, 2743 init_data->consumer_supplies[i].supply); 2744 if (ret < 0) { 2745 dev_err(dev, "Failed to set supply %s\n", 2746 init_data->consumer_supplies[i].supply); 2747 goto unset_supplies; 2748 } 2749 } 2750 2751 list_add(&rdev->list, ®ulator_list); 2752 2753 rdev_init_debugfs(rdev); 2754out: 2755 mutex_unlock(®ulator_list_mutex); 2756 return rdev; 2757 2758unset_supplies: 2759 unset_regulator_supplies(rdev); 2760 2761scrub: 2762 kfree(rdev->constraints); 2763 device_unregister(&rdev->dev); 2764 /* device core frees rdev */ 2765 rdev = ERR_PTR(ret); 2766 goto out; 2767 2768clean: 2769 kfree(rdev); 2770 rdev = ERR_PTR(ret); 2771 goto out; 2772} 2773EXPORT_SYMBOL_GPL(regulator_register); 2774 2775/** 2776 * regulator_unregister - unregister regulator 2777 * @rdev: regulator to unregister 2778 * 2779 * Called by regulator drivers to unregister a regulator. 2780 */ 2781void regulator_unregister(struct regulator_dev *rdev) 2782{ 2783 if (rdev == NULL) 2784 return; 2785 2786 mutex_lock(®ulator_list_mutex); 2787#ifdef CONFIG_DEBUG_FS 2788 debugfs_remove_recursive(rdev->debugfs); 2789#endif 2790 flush_work_sync(&rdev->disable_work.work); 2791 WARN_ON(rdev->open_count); 2792 unset_regulator_supplies(rdev); 2793 list_del(&rdev->list); 2794 if (rdev->supply) 2795 regulator_put(rdev->supply); 2796 device_unregister(&rdev->dev); 2797 kfree(rdev->constraints); 2798 mutex_unlock(®ulator_list_mutex); 2799} 2800EXPORT_SYMBOL_GPL(regulator_unregister); 2801 2802/** 2803 * regulator_suspend_prepare - prepare regulators for system wide suspend 2804 * @state: system suspend state 2805 * 2806 * Configure each regulator with it's suspend operating parameters for state. 2807 * This will usually be called by machine suspend code prior to supending. 2808 */ 2809int regulator_suspend_prepare(suspend_state_t state) 2810{ 2811 struct regulator_dev *rdev; 2812 int ret = 0; 2813 2814 /* ON is handled by regulator active state */ 2815 if (state == PM_SUSPEND_ON) 2816 return -EINVAL; 2817 2818 mutex_lock(®ulator_list_mutex); 2819 list_for_each_entry(rdev, ®ulator_list, list) { 2820 2821 mutex_lock(&rdev->mutex); 2822 ret = suspend_prepare(rdev, state); 2823 mutex_unlock(&rdev->mutex); 2824 2825 if (ret < 0) { 2826 rdev_err(rdev, "failed to prepare\n"); 2827 goto out; 2828 } 2829 } 2830out: 2831 mutex_unlock(®ulator_list_mutex); 2832 return ret; 2833} 2834EXPORT_SYMBOL_GPL(regulator_suspend_prepare); 2835 2836/** 2837 * regulator_suspend_finish - resume regulators from system wide suspend 2838 * 2839 * Turn on regulators that might be turned off by regulator_suspend_prepare 2840 * and that should be turned on according to the regulators properties. 2841 */ 2842int regulator_suspend_finish(void) 2843{ 2844 struct regulator_dev *rdev; 2845 int ret = 0, error; 2846 2847 mutex_lock(®ulator_list_mutex); 2848 list_for_each_entry(rdev, ®ulator_list, list) { 2849 struct regulator_ops *ops = rdev->desc->ops; 2850 2851 mutex_lock(&rdev->mutex); 2852 if ((rdev->use_count > 0 || rdev->constraints->always_on) && 2853 ops->enable) { 2854 error = ops->enable(rdev); 2855 if (error) 2856 ret = error; 2857 } else { 2858 if (!has_full_constraints) 2859 goto unlock; 2860 if (!ops->disable) 2861 goto unlock; 2862 if (ops->is_enabled && !ops->is_enabled(rdev)) 2863 goto unlock; 2864 2865 error = ops->disable(rdev); 2866 if (error) 2867 ret = error; 2868 } 2869unlock: 2870 mutex_unlock(&rdev->mutex); 2871 } 2872 mutex_unlock(®ulator_list_mutex); 2873 return ret; 2874} 2875EXPORT_SYMBOL_GPL(regulator_suspend_finish); 2876 2877/** 2878 * regulator_has_full_constraints - the system has fully specified constraints 2879 * 2880 * Calling this function will cause the regulator API to disable all 2881 * regulators which have a zero use count and don't have an always_on 2882 * constraint in a late_initcall. 2883 * 2884 * The intention is that this will become the default behaviour in a 2885 * future kernel release so users are encouraged to use this facility 2886 * now. 2887 */ 2888void regulator_has_full_constraints(void) 2889{ 2890 has_full_constraints = 1; 2891} 2892EXPORT_SYMBOL_GPL(regulator_has_full_constraints); 2893 2894/** 2895 * regulator_use_dummy_regulator - Provide a dummy regulator when none is found 2896 * 2897 * Calling this function will cause the regulator API to provide a 2898 * dummy regulator to consumers if no physical regulator is found, 2899 * allowing most consumers to proceed as though a regulator were 2900 * configured. This allows systems such as those with software 2901 * controllable regulators for the CPU core only to be brought up more 2902 * readily. 2903 */ 2904void regulator_use_dummy_regulator(void) 2905{ 2906 board_wants_dummy_regulator = true; 2907} 2908EXPORT_SYMBOL_GPL(regulator_use_dummy_regulator); 2909 2910/** 2911 * rdev_get_drvdata - get rdev regulator driver data 2912 * @rdev: regulator 2913 * 2914 * Get rdev regulator driver private data. This call can be used in the 2915 * regulator driver context. 2916 */ 2917void *rdev_get_drvdata(struct regulator_dev *rdev) 2918{ 2919 return rdev->reg_data; 2920} 2921EXPORT_SYMBOL_GPL(rdev_get_drvdata); 2922 2923/** 2924 * regulator_get_drvdata - get regulator driver data 2925 * @regulator: regulator 2926 * 2927 * Get regulator driver private data. This call can be used in the consumer 2928 * driver context when non API regulator specific functions need to be called. 2929 */ 2930void *regulator_get_drvdata(struct regulator *regulator) 2931{ 2932 return regulator->rdev->reg_data; 2933} 2934EXPORT_SYMBOL_GPL(regulator_get_drvdata); 2935 2936/** 2937 * regulator_set_drvdata - set regulator driver data 2938 * @regulator: regulator 2939 * @data: data 2940 */ 2941void regulator_set_drvdata(struct regulator *regulator, void *data) 2942{ 2943 regulator->rdev->reg_data = data; 2944} 2945EXPORT_SYMBOL_GPL(regulator_set_drvdata); 2946 2947/** 2948 * regulator_get_id - get regulator ID 2949 * @rdev: regulator 2950 */ 2951int rdev_get_id(struct regulator_dev *rdev) 2952{ 2953 return rdev->desc->id; 2954} 2955EXPORT_SYMBOL_GPL(rdev_get_id); 2956 2957struct device *rdev_get_dev(struct regulator_dev *rdev) 2958{ 2959 return &rdev->dev; 2960} 2961EXPORT_SYMBOL_GPL(rdev_get_dev); 2962 2963void *regulator_get_init_drvdata(struct regulator_init_data *reg_init_data) 2964{ 2965 return reg_init_data->driver_data; 2966} 2967EXPORT_SYMBOL_GPL(regulator_get_init_drvdata); 2968 2969static int __init regulator_init(void) 2970{ 2971 int ret; 2972 2973 ret = class_register(®ulator_class); 2974 2975#ifdef CONFIG_DEBUG_FS 2976 debugfs_root = debugfs_create_dir("regulator", NULL); 2977 if (IS_ERR(debugfs_root) || !debugfs_root) { 2978 pr_warn("regulator: Failed to create debugfs directory\n"); 2979 debugfs_root = NULL; 2980 } 2981#endif 2982 2983 regulator_dummy_init(); 2984 2985 return ret; 2986} 2987 2988/* init early to allow our consumers to complete system booting */ 2989core_initcall(regulator_init); 2990 2991static int __init regulator_init_complete(void) 2992{ 2993 struct regulator_dev *rdev; 2994 struct regulator_ops *ops; 2995 struct regulation_constraints *c; 2996 int enabled, ret; 2997 2998 mutex_lock(®ulator_list_mutex); 2999 3000 /* If we have a full configuration then disable any regulators 3001 * which are not in use or always_on. This will become the 3002 * default behaviour in the future. 3003 */ 3004 list_for_each_entry(rdev, ®ulator_list, list) { 3005 ops = rdev->desc->ops; 3006 c = rdev->constraints; 3007 3008 if (!ops->disable || (c && c->always_on)) 3009 continue; 3010 3011 mutex_lock(&rdev->mutex); 3012 3013 if (rdev->use_count) 3014 goto unlock; 3015 3016 /* If we can't read the status assume it's on. */ 3017 if (ops->is_enabled) 3018 enabled = ops->is_enabled(rdev); 3019 else 3020 enabled = 1; 3021 3022 if (!enabled) 3023 goto unlock; 3024 3025 if (has_full_constraints) { 3026 /* We log since this may kill the system if it 3027 * goes wrong. */ 3028 rdev_info(rdev, "disabling\n"); 3029 ret = ops->disable(rdev); 3030 if (ret != 0) { 3031 rdev_err(rdev, "couldn't disable: %d\n", ret); 3032 } 3033 } else { 3034 /* The intention is that in future we will 3035 * assume that full constraints are provided 3036 * so warn even if we aren't going to do 3037 * anything here. 3038 */ 3039 rdev_warn(rdev, "incomplete constraints, leaving on\n"); 3040 } 3041 3042unlock: 3043 mutex_unlock(&rdev->mutex); 3044 } 3045 3046 mutex_unlock(®ulator_list_mutex); 3047 3048 return 0; 3049} 3050late_initcall(regulator_init_complete); 3051