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