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