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