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