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