core.c revision 79fd114161a764dfa456191af89358b3f5201c87
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/debugfs.h> 19#include <linux/device.h> 20#include <linux/slab.h> 21#include <linux/async.h> 22#include <linux/err.h> 23#include <linux/mutex.h> 24#include <linux/suspend.h> 25#include <linux/delay.h> 26#include <linux/gpio.h> 27#include <linux/gpio/consumer.h> 28#include <linux/of.h> 29#include <linux/regmap.h> 30#include <linux/regulator/of_regulator.h> 31#include <linux/regulator/consumer.h> 32#include <linux/regulator/driver.h> 33#include <linux/regulator/machine.h> 34#include <linux/module.h> 35 36#define CREATE_TRACE_POINTS 37#include <trace/events/regulator.h> 38 39#include "dummy.h" 40#include "internal.h" 41 42#define rdev_crit(rdev, fmt, ...) \ 43 pr_crit("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__) 44#define rdev_err(rdev, fmt, ...) \ 45 pr_err("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__) 46#define rdev_warn(rdev, fmt, ...) \ 47 pr_warn("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__) 48#define rdev_info(rdev, fmt, ...) \ 49 pr_info("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__) 50#define rdev_dbg(rdev, fmt, ...) \ 51 pr_debug("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__) 52 53static DEFINE_MUTEX(regulator_list_mutex); 54static LIST_HEAD(regulator_list); 55static LIST_HEAD(regulator_map_list); 56static LIST_HEAD(regulator_ena_gpio_list); 57static LIST_HEAD(regulator_supply_alias_list); 58static bool has_full_constraints; 59 60static struct dentry *debugfs_root; 61 62/* 63 * struct regulator_map 64 * 65 * Used to provide symbolic supply names to devices. 66 */ 67struct regulator_map { 68 struct list_head list; 69 const char *dev_name; /* The dev_name() for the consumer */ 70 const char *supply; 71 struct regulator_dev *regulator; 72}; 73 74/* 75 * struct regulator_enable_gpio 76 * 77 * Management for shared enable GPIO pin 78 */ 79struct regulator_enable_gpio { 80 struct list_head list; 81 struct gpio_desc *gpiod; 82 u32 enable_count; /* a number of enabled shared GPIO */ 83 u32 request_count; /* a number of requested shared GPIO */ 84 unsigned int ena_gpio_invert:1; 85}; 86 87/* 88 * struct regulator_supply_alias 89 * 90 * Used to map lookups for a supply onto an alternative device. 91 */ 92struct regulator_supply_alias { 93 struct list_head list; 94 struct device *src_dev; 95 const char *src_supply; 96 struct device *alias_dev; 97 const char *alias_supply; 98}; 99 100static int _regulator_is_enabled(struct regulator_dev *rdev); 101static int _regulator_disable(struct regulator_dev *rdev); 102static int _regulator_get_voltage(struct regulator_dev *rdev); 103static int _regulator_get_current_limit(struct regulator_dev *rdev); 104static unsigned int _regulator_get_mode(struct regulator_dev *rdev); 105static void _notifier_call_chain(struct regulator_dev *rdev, 106 unsigned long event, void *data); 107static int _regulator_do_set_voltage(struct regulator_dev *rdev, 108 int min_uV, int max_uV); 109static struct regulator *create_regulator(struct regulator_dev *rdev, 110 struct device *dev, 111 const char *supply_name); 112 113static const char *rdev_get_name(struct regulator_dev *rdev) 114{ 115 if (rdev->constraints && rdev->constraints->name) 116 return rdev->constraints->name; 117 else if (rdev->desc->name) 118 return rdev->desc->name; 119 else 120 return ""; 121} 122 123static bool have_full_constraints(void) 124{ 125 return has_full_constraints || of_have_populated_dt(); 126} 127 128/** 129 * of_get_regulator - get a regulator device node based on supply name 130 * @dev: Device pointer for the consumer (of regulator) device 131 * @supply: regulator supply name 132 * 133 * Extract the regulator device node corresponding to the supply name. 134 * returns the device node corresponding to the regulator if found, else 135 * returns NULL. 136 */ 137static struct device_node *of_get_regulator(struct device *dev, const char *supply) 138{ 139 struct device_node *regnode = NULL; 140 char prop_name[32]; /* 32 is max size of property name */ 141 142 dev_dbg(dev, "Looking up %s-supply from device tree\n", supply); 143 144 snprintf(prop_name, 32, "%s-supply", supply); 145 regnode = of_parse_phandle(dev->of_node, prop_name, 0); 146 147 if (!regnode) { 148 dev_dbg(dev, "Looking up %s property in node %s failed", 149 prop_name, dev->of_node->full_name); 150 return NULL; 151 } 152 return regnode; 153} 154 155static int _regulator_can_change_status(struct regulator_dev *rdev) 156{ 157 if (!rdev->constraints) 158 return 0; 159 160 if (rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_STATUS) 161 return 1; 162 else 163 return 0; 164} 165 166/* Platform voltage constraint check */ 167static int regulator_check_voltage(struct regulator_dev *rdev, 168 int *min_uV, int *max_uV) 169{ 170 BUG_ON(*min_uV > *max_uV); 171 172 if (!rdev->constraints) { 173 rdev_err(rdev, "no constraints\n"); 174 return -ENODEV; 175 } 176 if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_VOLTAGE)) { 177 rdev_err(rdev, "operation not allowed\n"); 178 return -EPERM; 179 } 180 181 if (*max_uV > rdev->constraints->max_uV) 182 *max_uV = rdev->constraints->max_uV; 183 if (*min_uV < rdev->constraints->min_uV) 184 *min_uV = rdev->constraints->min_uV; 185 186 if (*min_uV > *max_uV) { 187 rdev_err(rdev, "unsupportable voltage range: %d-%duV\n", 188 *min_uV, *max_uV); 189 return -EINVAL; 190 } 191 192 return 0; 193} 194 195/* Make sure we select a voltage that suits the needs of all 196 * regulator consumers 197 */ 198static int regulator_check_consumers(struct regulator_dev *rdev, 199 int *min_uV, int *max_uV) 200{ 201 struct regulator *regulator; 202 203 list_for_each_entry(regulator, &rdev->consumer_list, list) { 204 /* 205 * Assume consumers that didn't say anything are OK 206 * with anything in the constraint range. 207 */ 208 if (!regulator->min_uV && !regulator->max_uV) 209 continue; 210 211 if (*max_uV > regulator->max_uV) 212 *max_uV = regulator->max_uV; 213 if (*min_uV < regulator->min_uV) 214 *min_uV = regulator->min_uV; 215 } 216 217 if (*min_uV > *max_uV) { 218 rdev_err(rdev, "Restricting voltage, %u-%uuV\n", 219 *min_uV, *max_uV); 220 return -EINVAL; 221 } 222 223 return 0; 224} 225 226/* current constraint check */ 227static int regulator_check_current_limit(struct regulator_dev *rdev, 228 int *min_uA, int *max_uA) 229{ 230 BUG_ON(*min_uA > *max_uA); 231 232 if (!rdev->constraints) { 233 rdev_err(rdev, "no constraints\n"); 234 return -ENODEV; 235 } 236 if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_CURRENT)) { 237 rdev_err(rdev, "operation not allowed\n"); 238 return -EPERM; 239 } 240 241 if (*max_uA > rdev->constraints->max_uA) 242 *max_uA = rdev->constraints->max_uA; 243 if (*min_uA < rdev->constraints->min_uA) 244 *min_uA = rdev->constraints->min_uA; 245 246 if (*min_uA > *max_uA) { 247 rdev_err(rdev, "unsupportable current range: %d-%duA\n", 248 *min_uA, *max_uA); 249 return -EINVAL; 250 } 251 252 return 0; 253} 254 255/* operating mode constraint check */ 256static int regulator_mode_constrain(struct regulator_dev *rdev, int *mode) 257{ 258 switch (*mode) { 259 case REGULATOR_MODE_FAST: 260 case REGULATOR_MODE_NORMAL: 261 case REGULATOR_MODE_IDLE: 262 case REGULATOR_MODE_STANDBY: 263 break; 264 default: 265 rdev_err(rdev, "invalid mode %x specified\n", *mode); 266 return -EINVAL; 267 } 268 269 if (!rdev->constraints) { 270 rdev_err(rdev, "no constraints\n"); 271 return -ENODEV; 272 } 273 if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_MODE)) { 274 rdev_err(rdev, "operation not allowed\n"); 275 return -EPERM; 276 } 277 278 /* The modes are bitmasks, the most power hungry modes having 279 * the lowest values. If the requested mode isn't supported 280 * try higher modes. */ 281 while (*mode) { 282 if (rdev->constraints->valid_modes_mask & *mode) 283 return 0; 284 *mode /= 2; 285 } 286 287 return -EINVAL; 288} 289 290/* dynamic regulator mode switching constraint check */ 291static int regulator_check_drms(struct regulator_dev *rdev) 292{ 293 if (!rdev->constraints) { 294 rdev_err(rdev, "no constraints\n"); 295 return -ENODEV; 296 } 297 if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_DRMS)) { 298 rdev_err(rdev, "operation not allowed\n"); 299 return -EPERM; 300 } 301 return 0; 302} 303 304static ssize_t regulator_uV_show(struct device *dev, 305 struct device_attribute *attr, char *buf) 306{ 307 struct regulator_dev *rdev = dev_get_drvdata(dev); 308 ssize_t ret; 309 310 mutex_lock(&rdev->mutex); 311 ret = sprintf(buf, "%d\n", _regulator_get_voltage(rdev)); 312 mutex_unlock(&rdev->mutex); 313 314 return ret; 315} 316static DEVICE_ATTR(microvolts, 0444, regulator_uV_show, NULL); 317 318static ssize_t regulator_uA_show(struct device *dev, 319 struct device_attribute *attr, char *buf) 320{ 321 struct regulator_dev *rdev = dev_get_drvdata(dev); 322 323 return sprintf(buf, "%d\n", _regulator_get_current_limit(rdev)); 324} 325static DEVICE_ATTR(microamps, 0444, regulator_uA_show, NULL); 326 327static ssize_t name_show(struct device *dev, struct device_attribute *attr, 328 char *buf) 329{ 330 struct regulator_dev *rdev = dev_get_drvdata(dev); 331 332 return sprintf(buf, "%s\n", rdev_get_name(rdev)); 333} 334static DEVICE_ATTR_RO(name); 335 336static ssize_t regulator_print_opmode(char *buf, int mode) 337{ 338 switch (mode) { 339 case REGULATOR_MODE_FAST: 340 return sprintf(buf, "fast\n"); 341 case REGULATOR_MODE_NORMAL: 342 return sprintf(buf, "normal\n"); 343 case REGULATOR_MODE_IDLE: 344 return sprintf(buf, "idle\n"); 345 case REGULATOR_MODE_STANDBY: 346 return sprintf(buf, "standby\n"); 347 } 348 return sprintf(buf, "unknown\n"); 349} 350 351static ssize_t regulator_opmode_show(struct device *dev, 352 struct device_attribute *attr, char *buf) 353{ 354 struct regulator_dev *rdev = dev_get_drvdata(dev); 355 356 return regulator_print_opmode(buf, _regulator_get_mode(rdev)); 357} 358static DEVICE_ATTR(opmode, 0444, regulator_opmode_show, NULL); 359 360static ssize_t regulator_print_state(char *buf, int state) 361{ 362 if (state > 0) 363 return sprintf(buf, "enabled\n"); 364 else if (state == 0) 365 return sprintf(buf, "disabled\n"); 366 else 367 return sprintf(buf, "unknown\n"); 368} 369 370static ssize_t regulator_state_show(struct device *dev, 371 struct device_attribute *attr, char *buf) 372{ 373 struct regulator_dev *rdev = dev_get_drvdata(dev); 374 ssize_t ret; 375 376 mutex_lock(&rdev->mutex); 377 ret = regulator_print_state(buf, _regulator_is_enabled(rdev)); 378 mutex_unlock(&rdev->mutex); 379 380 return ret; 381} 382static DEVICE_ATTR(state, 0444, regulator_state_show, NULL); 383 384static ssize_t regulator_status_show(struct device *dev, 385 struct device_attribute *attr, char *buf) 386{ 387 struct regulator_dev *rdev = dev_get_drvdata(dev); 388 int status; 389 char *label; 390 391 status = rdev->desc->ops->get_status(rdev); 392 if (status < 0) 393 return status; 394 395 switch (status) { 396 case REGULATOR_STATUS_OFF: 397 label = "off"; 398 break; 399 case REGULATOR_STATUS_ON: 400 label = "on"; 401 break; 402 case REGULATOR_STATUS_ERROR: 403 label = "error"; 404 break; 405 case REGULATOR_STATUS_FAST: 406 label = "fast"; 407 break; 408 case REGULATOR_STATUS_NORMAL: 409 label = "normal"; 410 break; 411 case REGULATOR_STATUS_IDLE: 412 label = "idle"; 413 break; 414 case REGULATOR_STATUS_STANDBY: 415 label = "standby"; 416 break; 417 case REGULATOR_STATUS_BYPASS: 418 label = "bypass"; 419 break; 420 case REGULATOR_STATUS_UNDEFINED: 421 label = "undefined"; 422 break; 423 default: 424 return -ERANGE; 425 } 426 427 return sprintf(buf, "%s\n", label); 428} 429static DEVICE_ATTR(status, 0444, regulator_status_show, NULL); 430 431static ssize_t regulator_min_uA_show(struct device *dev, 432 struct device_attribute *attr, char *buf) 433{ 434 struct regulator_dev *rdev = dev_get_drvdata(dev); 435 436 if (!rdev->constraints) 437 return sprintf(buf, "constraint not defined\n"); 438 439 return sprintf(buf, "%d\n", rdev->constraints->min_uA); 440} 441static DEVICE_ATTR(min_microamps, 0444, regulator_min_uA_show, NULL); 442 443static ssize_t regulator_max_uA_show(struct device *dev, 444 struct device_attribute *attr, char *buf) 445{ 446 struct regulator_dev *rdev = dev_get_drvdata(dev); 447 448 if (!rdev->constraints) 449 return sprintf(buf, "constraint not defined\n"); 450 451 return sprintf(buf, "%d\n", rdev->constraints->max_uA); 452} 453static DEVICE_ATTR(max_microamps, 0444, regulator_max_uA_show, NULL); 454 455static ssize_t regulator_min_uV_show(struct device *dev, 456 struct device_attribute *attr, char *buf) 457{ 458 struct regulator_dev *rdev = dev_get_drvdata(dev); 459 460 if (!rdev->constraints) 461 return sprintf(buf, "constraint not defined\n"); 462 463 return sprintf(buf, "%d\n", rdev->constraints->min_uV); 464} 465static DEVICE_ATTR(min_microvolts, 0444, regulator_min_uV_show, NULL); 466 467static ssize_t regulator_max_uV_show(struct device *dev, 468 struct device_attribute *attr, char *buf) 469{ 470 struct regulator_dev *rdev = dev_get_drvdata(dev); 471 472 if (!rdev->constraints) 473 return sprintf(buf, "constraint not defined\n"); 474 475 return sprintf(buf, "%d\n", rdev->constraints->max_uV); 476} 477static DEVICE_ATTR(max_microvolts, 0444, regulator_max_uV_show, NULL); 478 479static ssize_t regulator_total_uA_show(struct device *dev, 480 struct device_attribute *attr, char *buf) 481{ 482 struct regulator_dev *rdev = dev_get_drvdata(dev); 483 struct regulator *regulator; 484 int uA = 0; 485 486 mutex_lock(&rdev->mutex); 487 list_for_each_entry(regulator, &rdev->consumer_list, list) 488 uA += regulator->uA_load; 489 mutex_unlock(&rdev->mutex); 490 return sprintf(buf, "%d\n", uA); 491} 492static DEVICE_ATTR(requested_microamps, 0444, regulator_total_uA_show, NULL); 493 494static ssize_t num_users_show(struct device *dev, struct device_attribute *attr, 495 char *buf) 496{ 497 struct regulator_dev *rdev = dev_get_drvdata(dev); 498 return sprintf(buf, "%d\n", rdev->use_count); 499} 500static DEVICE_ATTR_RO(num_users); 501 502static ssize_t type_show(struct device *dev, struct device_attribute *attr, 503 char *buf) 504{ 505 struct regulator_dev *rdev = dev_get_drvdata(dev); 506 507 switch (rdev->desc->type) { 508 case REGULATOR_VOLTAGE: 509 return sprintf(buf, "voltage\n"); 510 case REGULATOR_CURRENT: 511 return sprintf(buf, "current\n"); 512 } 513 return sprintf(buf, "unknown\n"); 514} 515static DEVICE_ATTR_RO(type); 516 517static ssize_t regulator_suspend_mem_uV_show(struct device *dev, 518 struct device_attribute *attr, char *buf) 519{ 520 struct regulator_dev *rdev = dev_get_drvdata(dev); 521 522 return sprintf(buf, "%d\n", rdev->constraints->state_mem.uV); 523} 524static DEVICE_ATTR(suspend_mem_microvolts, 0444, 525 regulator_suspend_mem_uV_show, NULL); 526 527static ssize_t regulator_suspend_disk_uV_show(struct device *dev, 528 struct device_attribute *attr, char *buf) 529{ 530 struct regulator_dev *rdev = dev_get_drvdata(dev); 531 532 return sprintf(buf, "%d\n", rdev->constraints->state_disk.uV); 533} 534static DEVICE_ATTR(suspend_disk_microvolts, 0444, 535 regulator_suspend_disk_uV_show, NULL); 536 537static ssize_t regulator_suspend_standby_uV_show(struct device *dev, 538 struct device_attribute *attr, char *buf) 539{ 540 struct regulator_dev *rdev = dev_get_drvdata(dev); 541 542 return sprintf(buf, "%d\n", rdev->constraints->state_standby.uV); 543} 544static DEVICE_ATTR(suspend_standby_microvolts, 0444, 545 regulator_suspend_standby_uV_show, NULL); 546 547static ssize_t regulator_suspend_mem_mode_show(struct device *dev, 548 struct device_attribute *attr, char *buf) 549{ 550 struct regulator_dev *rdev = dev_get_drvdata(dev); 551 552 return regulator_print_opmode(buf, 553 rdev->constraints->state_mem.mode); 554} 555static DEVICE_ATTR(suspend_mem_mode, 0444, 556 regulator_suspend_mem_mode_show, NULL); 557 558static ssize_t regulator_suspend_disk_mode_show(struct device *dev, 559 struct device_attribute *attr, char *buf) 560{ 561 struct regulator_dev *rdev = dev_get_drvdata(dev); 562 563 return regulator_print_opmode(buf, 564 rdev->constraints->state_disk.mode); 565} 566static DEVICE_ATTR(suspend_disk_mode, 0444, 567 regulator_suspend_disk_mode_show, NULL); 568 569static ssize_t regulator_suspend_standby_mode_show(struct device *dev, 570 struct device_attribute *attr, char *buf) 571{ 572 struct regulator_dev *rdev = dev_get_drvdata(dev); 573 574 return regulator_print_opmode(buf, 575 rdev->constraints->state_standby.mode); 576} 577static DEVICE_ATTR(suspend_standby_mode, 0444, 578 regulator_suspend_standby_mode_show, NULL); 579 580static ssize_t regulator_suspend_mem_state_show(struct device *dev, 581 struct device_attribute *attr, char *buf) 582{ 583 struct regulator_dev *rdev = dev_get_drvdata(dev); 584 585 return regulator_print_state(buf, 586 rdev->constraints->state_mem.enabled); 587} 588static DEVICE_ATTR(suspend_mem_state, 0444, 589 regulator_suspend_mem_state_show, NULL); 590 591static ssize_t regulator_suspend_disk_state_show(struct device *dev, 592 struct device_attribute *attr, char *buf) 593{ 594 struct regulator_dev *rdev = dev_get_drvdata(dev); 595 596 return regulator_print_state(buf, 597 rdev->constraints->state_disk.enabled); 598} 599static DEVICE_ATTR(suspend_disk_state, 0444, 600 regulator_suspend_disk_state_show, NULL); 601 602static ssize_t regulator_suspend_standby_state_show(struct device *dev, 603 struct device_attribute *attr, char *buf) 604{ 605 struct regulator_dev *rdev = dev_get_drvdata(dev); 606 607 return regulator_print_state(buf, 608 rdev->constraints->state_standby.enabled); 609} 610static DEVICE_ATTR(suspend_standby_state, 0444, 611 regulator_suspend_standby_state_show, NULL); 612 613static ssize_t regulator_bypass_show(struct device *dev, 614 struct device_attribute *attr, char *buf) 615{ 616 struct regulator_dev *rdev = dev_get_drvdata(dev); 617 const char *report; 618 bool bypass; 619 int ret; 620 621 ret = rdev->desc->ops->get_bypass(rdev, &bypass); 622 623 if (ret != 0) 624 report = "unknown"; 625 else if (bypass) 626 report = "enabled"; 627 else 628 report = "disabled"; 629 630 return sprintf(buf, "%s\n", report); 631} 632static DEVICE_ATTR(bypass, 0444, 633 regulator_bypass_show, NULL); 634 635/* 636 * These are the only attributes are present for all regulators. 637 * Other attributes are a function of regulator functionality. 638 */ 639static struct attribute *regulator_dev_attrs[] = { 640 &dev_attr_name.attr, 641 &dev_attr_num_users.attr, 642 &dev_attr_type.attr, 643 NULL, 644}; 645ATTRIBUTE_GROUPS(regulator_dev); 646 647static void regulator_dev_release(struct device *dev) 648{ 649 struct regulator_dev *rdev = dev_get_drvdata(dev); 650 kfree(rdev); 651} 652 653static struct class regulator_class = { 654 .name = "regulator", 655 .dev_release = regulator_dev_release, 656 .dev_groups = regulator_dev_groups, 657}; 658 659/* Calculate the new optimum regulator operating mode based on the new total 660 * consumer load. All locks held by caller */ 661static void drms_uA_update(struct regulator_dev *rdev) 662{ 663 struct regulator *sibling; 664 int current_uA = 0, output_uV, input_uV, err; 665 unsigned int mode; 666 667 err = regulator_check_drms(rdev); 668 if (err < 0 || !rdev->desc->ops->get_optimum_mode || 669 (!rdev->desc->ops->get_voltage && 670 !rdev->desc->ops->get_voltage_sel) || 671 !rdev->desc->ops->set_mode) 672 return; 673 674 /* get output voltage */ 675 output_uV = _regulator_get_voltage(rdev); 676 if (output_uV <= 0) 677 return; 678 679 /* get input voltage */ 680 input_uV = 0; 681 if (rdev->supply) 682 input_uV = regulator_get_voltage(rdev->supply); 683 if (input_uV <= 0) 684 input_uV = rdev->constraints->input_uV; 685 if (input_uV <= 0) 686 return; 687 688 /* calc total requested load */ 689 list_for_each_entry(sibling, &rdev->consumer_list, list) 690 current_uA += sibling->uA_load; 691 692 /* now get the optimum mode for our new total regulator load */ 693 mode = rdev->desc->ops->get_optimum_mode(rdev, input_uV, 694 output_uV, current_uA); 695 696 /* check the new mode is allowed */ 697 err = regulator_mode_constrain(rdev, &mode); 698 if (err == 0) 699 rdev->desc->ops->set_mode(rdev, mode); 700} 701 702static int suspend_set_state(struct regulator_dev *rdev, 703 struct regulator_state *rstate) 704{ 705 int ret = 0; 706 707 /* If we have no suspend mode configration don't set anything; 708 * only warn if the driver implements set_suspend_voltage or 709 * set_suspend_mode callback. 710 */ 711 if (!rstate->enabled && !rstate->disabled) { 712 if (rdev->desc->ops->set_suspend_voltage || 713 rdev->desc->ops->set_suspend_mode) 714 rdev_warn(rdev, "No configuration\n"); 715 return 0; 716 } 717 718 if (rstate->enabled && rstate->disabled) { 719 rdev_err(rdev, "invalid configuration\n"); 720 return -EINVAL; 721 } 722 723 if (rstate->enabled && rdev->desc->ops->set_suspend_enable) 724 ret = rdev->desc->ops->set_suspend_enable(rdev); 725 else if (rstate->disabled && rdev->desc->ops->set_suspend_disable) 726 ret = rdev->desc->ops->set_suspend_disable(rdev); 727 else /* OK if set_suspend_enable or set_suspend_disable is NULL */ 728 ret = 0; 729 730 if (ret < 0) { 731 rdev_err(rdev, "failed to enabled/disable\n"); 732 return ret; 733 } 734 735 if (rdev->desc->ops->set_suspend_voltage && rstate->uV > 0) { 736 ret = rdev->desc->ops->set_suspend_voltage(rdev, rstate->uV); 737 if (ret < 0) { 738 rdev_err(rdev, "failed to set voltage\n"); 739 return ret; 740 } 741 } 742 743 if (rdev->desc->ops->set_suspend_mode && rstate->mode > 0) { 744 ret = rdev->desc->ops->set_suspend_mode(rdev, rstate->mode); 745 if (ret < 0) { 746 rdev_err(rdev, "failed to set mode\n"); 747 return ret; 748 } 749 } 750 return ret; 751} 752 753/* locks held by caller */ 754static int suspend_prepare(struct regulator_dev *rdev, suspend_state_t state) 755{ 756 if (!rdev->constraints) 757 return -EINVAL; 758 759 switch (state) { 760 case PM_SUSPEND_STANDBY: 761 return suspend_set_state(rdev, 762 &rdev->constraints->state_standby); 763 case PM_SUSPEND_MEM: 764 return suspend_set_state(rdev, 765 &rdev->constraints->state_mem); 766 case PM_SUSPEND_MAX: 767 return suspend_set_state(rdev, 768 &rdev->constraints->state_disk); 769 default: 770 return -EINVAL; 771 } 772} 773 774static void print_constraints(struct regulator_dev *rdev) 775{ 776 struct regulation_constraints *constraints = rdev->constraints; 777 char buf[80] = ""; 778 int count = 0; 779 int ret; 780 781 if (constraints->min_uV && constraints->max_uV) { 782 if (constraints->min_uV == constraints->max_uV) 783 count += sprintf(buf + count, "%d mV ", 784 constraints->min_uV / 1000); 785 else 786 count += sprintf(buf + count, "%d <--> %d mV ", 787 constraints->min_uV / 1000, 788 constraints->max_uV / 1000); 789 } 790 791 if (!constraints->min_uV || 792 constraints->min_uV != constraints->max_uV) { 793 ret = _regulator_get_voltage(rdev); 794 if (ret > 0) 795 count += sprintf(buf + count, "at %d mV ", ret / 1000); 796 } 797 798 if (constraints->uV_offset) 799 count += sprintf(buf, "%dmV offset ", 800 constraints->uV_offset / 1000); 801 802 if (constraints->min_uA && constraints->max_uA) { 803 if (constraints->min_uA == constraints->max_uA) 804 count += sprintf(buf + count, "%d mA ", 805 constraints->min_uA / 1000); 806 else 807 count += sprintf(buf + count, "%d <--> %d mA ", 808 constraints->min_uA / 1000, 809 constraints->max_uA / 1000); 810 } 811 812 if (!constraints->min_uA || 813 constraints->min_uA != constraints->max_uA) { 814 ret = _regulator_get_current_limit(rdev); 815 if (ret > 0) 816 count += sprintf(buf + count, "at %d mA ", ret / 1000); 817 } 818 819 if (constraints->valid_modes_mask & REGULATOR_MODE_FAST) 820 count += sprintf(buf + count, "fast "); 821 if (constraints->valid_modes_mask & REGULATOR_MODE_NORMAL) 822 count += sprintf(buf + count, "normal "); 823 if (constraints->valid_modes_mask & REGULATOR_MODE_IDLE) 824 count += sprintf(buf + count, "idle "); 825 if (constraints->valid_modes_mask & REGULATOR_MODE_STANDBY) 826 count += sprintf(buf + count, "standby"); 827 828 if (!count) 829 sprintf(buf, "no parameters"); 830 831 rdev_info(rdev, "%s\n", buf); 832 833 if ((constraints->min_uV != constraints->max_uV) && 834 !(constraints->valid_ops_mask & REGULATOR_CHANGE_VOLTAGE)) 835 rdev_warn(rdev, 836 "Voltage range but no REGULATOR_CHANGE_VOLTAGE\n"); 837} 838 839static int machine_constraints_voltage(struct regulator_dev *rdev, 840 struct regulation_constraints *constraints) 841{ 842 const struct regulator_ops *ops = rdev->desc->ops; 843 int ret; 844 845 /* do we need to apply the constraint voltage */ 846 if (rdev->constraints->apply_uV && 847 rdev->constraints->min_uV == rdev->constraints->max_uV) { 848 int current_uV = _regulator_get_voltage(rdev); 849 if (current_uV < 0) { 850 rdev_err(rdev, 851 "failed to get the current voltage(%d)\n", 852 current_uV); 853 return current_uV; 854 } 855 if (current_uV < rdev->constraints->min_uV || 856 current_uV > rdev->constraints->max_uV) { 857 ret = _regulator_do_set_voltage( 858 rdev, rdev->constraints->min_uV, 859 rdev->constraints->max_uV); 860 if (ret < 0) { 861 rdev_err(rdev, 862 "failed to apply %duV constraint(%d)\n", 863 rdev->constraints->min_uV, ret); 864 return ret; 865 } 866 } 867 } 868 869 /* constrain machine-level voltage specs to fit 870 * the actual range supported by this regulator. 871 */ 872 if (ops->list_voltage && rdev->desc->n_voltages) { 873 int count = rdev->desc->n_voltages; 874 int i; 875 int min_uV = INT_MAX; 876 int max_uV = INT_MIN; 877 int cmin = constraints->min_uV; 878 int cmax = constraints->max_uV; 879 880 /* it's safe to autoconfigure fixed-voltage supplies 881 and the constraints are used by list_voltage. */ 882 if (count == 1 && !cmin) { 883 cmin = 1; 884 cmax = INT_MAX; 885 constraints->min_uV = cmin; 886 constraints->max_uV = cmax; 887 } 888 889 /* voltage constraints are optional */ 890 if ((cmin == 0) && (cmax == 0)) 891 return 0; 892 893 /* else require explicit machine-level constraints */ 894 if (cmin <= 0 || cmax <= 0 || cmax < cmin) { 895 rdev_err(rdev, "invalid voltage constraints\n"); 896 return -EINVAL; 897 } 898 899 /* initial: [cmin..cmax] valid, [min_uV..max_uV] not */ 900 for (i = 0; i < count; i++) { 901 int value; 902 903 value = ops->list_voltage(rdev, i); 904 if (value <= 0) 905 continue; 906 907 /* maybe adjust [min_uV..max_uV] */ 908 if (value >= cmin && value < min_uV) 909 min_uV = value; 910 if (value <= cmax && value > max_uV) 911 max_uV = value; 912 } 913 914 /* final: [min_uV..max_uV] valid iff constraints valid */ 915 if (max_uV < min_uV) { 916 rdev_err(rdev, 917 "unsupportable voltage constraints %u-%uuV\n", 918 min_uV, max_uV); 919 return -EINVAL; 920 } 921 922 /* use regulator's subset of machine constraints */ 923 if (constraints->min_uV < min_uV) { 924 rdev_dbg(rdev, "override min_uV, %d -> %d\n", 925 constraints->min_uV, min_uV); 926 constraints->min_uV = min_uV; 927 } 928 if (constraints->max_uV > max_uV) { 929 rdev_dbg(rdev, "override max_uV, %d -> %d\n", 930 constraints->max_uV, max_uV); 931 constraints->max_uV = max_uV; 932 } 933 } 934 935 return 0; 936} 937 938static int machine_constraints_current(struct regulator_dev *rdev, 939 struct regulation_constraints *constraints) 940{ 941 const struct regulator_ops *ops = rdev->desc->ops; 942 int ret; 943 944 if (!constraints->min_uA && !constraints->max_uA) 945 return 0; 946 947 if (constraints->min_uA > constraints->max_uA) { 948 rdev_err(rdev, "Invalid current constraints\n"); 949 return -EINVAL; 950 } 951 952 if (!ops->set_current_limit || !ops->get_current_limit) { 953 rdev_warn(rdev, "Operation of current configuration missing\n"); 954 return 0; 955 } 956 957 /* Set regulator current in constraints range */ 958 ret = ops->set_current_limit(rdev, constraints->min_uA, 959 constraints->max_uA); 960 if (ret < 0) { 961 rdev_err(rdev, "Failed to set current constraint, %d\n", ret); 962 return ret; 963 } 964 965 return 0; 966} 967 968static int _regulator_do_enable(struct regulator_dev *rdev); 969 970/** 971 * set_machine_constraints - sets regulator constraints 972 * @rdev: regulator source 973 * @constraints: constraints to apply 974 * 975 * Allows platform initialisation code to define and constrain 976 * regulator circuits e.g. valid voltage/current ranges, etc. NOTE: 977 * Constraints *must* be set by platform code in order for some 978 * regulator operations to proceed i.e. set_voltage, set_current_limit, 979 * set_mode. 980 */ 981static int set_machine_constraints(struct regulator_dev *rdev, 982 const struct regulation_constraints *constraints) 983{ 984 int ret = 0; 985 const struct regulator_ops *ops = rdev->desc->ops; 986 987 if (constraints) 988 rdev->constraints = kmemdup(constraints, sizeof(*constraints), 989 GFP_KERNEL); 990 else 991 rdev->constraints = kzalloc(sizeof(*constraints), 992 GFP_KERNEL); 993 if (!rdev->constraints) 994 return -ENOMEM; 995 996 ret = machine_constraints_voltage(rdev, rdev->constraints); 997 if (ret != 0) 998 goto out; 999 1000 ret = machine_constraints_current(rdev, rdev->constraints); 1001 if (ret != 0) 1002 goto out; 1003 1004 /* do we need to setup our suspend state */ 1005 if (rdev->constraints->initial_state) { 1006 ret = suspend_prepare(rdev, rdev->constraints->initial_state); 1007 if (ret < 0) { 1008 rdev_err(rdev, "failed to set suspend state\n"); 1009 goto out; 1010 } 1011 } 1012 1013 if (rdev->constraints->initial_mode) { 1014 if (!ops->set_mode) { 1015 rdev_err(rdev, "no set_mode operation\n"); 1016 ret = -EINVAL; 1017 goto out; 1018 } 1019 1020 ret = ops->set_mode(rdev, rdev->constraints->initial_mode); 1021 if (ret < 0) { 1022 rdev_err(rdev, "failed to set initial mode: %d\n", ret); 1023 goto out; 1024 } 1025 } 1026 1027 /* If the constraints say the regulator should be on at this point 1028 * and we have control then make sure it is enabled. 1029 */ 1030 if (rdev->constraints->always_on || rdev->constraints->boot_on) { 1031 ret = _regulator_do_enable(rdev); 1032 if (ret < 0 && ret != -EINVAL) { 1033 rdev_err(rdev, "failed to enable\n"); 1034 goto out; 1035 } 1036 } 1037 1038 if ((rdev->constraints->ramp_delay || rdev->constraints->ramp_disable) 1039 && ops->set_ramp_delay) { 1040 ret = ops->set_ramp_delay(rdev, rdev->constraints->ramp_delay); 1041 if (ret < 0) { 1042 rdev_err(rdev, "failed to set ramp_delay\n"); 1043 goto out; 1044 } 1045 } 1046 1047 print_constraints(rdev); 1048 return 0; 1049out: 1050 kfree(rdev->constraints); 1051 rdev->constraints = NULL; 1052 return ret; 1053} 1054 1055/** 1056 * set_supply - set regulator supply regulator 1057 * @rdev: regulator name 1058 * @supply_rdev: supply regulator name 1059 * 1060 * Called by platform initialisation code to set the supply regulator for this 1061 * regulator. This ensures that a regulators supply will also be enabled by the 1062 * core if it's child is enabled. 1063 */ 1064static int set_supply(struct regulator_dev *rdev, 1065 struct regulator_dev *supply_rdev) 1066{ 1067 int err; 1068 1069 rdev_info(rdev, "supplied by %s\n", rdev_get_name(supply_rdev)); 1070 1071 rdev->supply = create_regulator(supply_rdev, &rdev->dev, "SUPPLY"); 1072 if (rdev->supply == NULL) { 1073 err = -ENOMEM; 1074 return err; 1075 } 1076 supply_rdev->open_count++; 1077 1078 return 0; 1079} 1080 1081/** 1082 * set_consumer_device_supply - Bind a regulator to a symbolic supply 1083 * @rdev: regulator source 1084 * @consumer_dev_name: dev_name() string for device supply applies to 1085 * @supply: symbolic name for supply 1086 * 1087 * Allows platform initialisation code to map physical regulator 1088 * sources to symbolic names for supplies for use by devices. Devices 1089 * should use these symbolic names to request regulators, avoiding the 1090 * need to provide board-specific regulator names as platform data. 1091 */ 1092static int set_consumer_device_supply(struct regulator_dev *rdev, 1093 const char *consumer_dev_name, 1094 const char *supply) 1095{ 1096 struct regulator_map *node; 1097 int has_dev; 1098 1099 if (supply == NULL) 1100 return -EINVAL; 1101 1102 if (consumer_dev_name != NULL) 1103 has_dev = 1; 1104 else 1105 has_dev = 0; 1106 1107 list_for_each_entry(node, ®ulator_map_list, list) { 1108 if (node->dev_name && consumer_dev_name) { 1109 if (strcmp(node->dev_name, consumer_dev_name) != 0) 1110 continue; 1111 } else if (node->dev_name || consumer_dev_name) { 1112 continue; 1113 } 1114 1115 if (strcmp(node->supply, supply) != 0) 1116 continue; 1117 1118 pr_debug("%s: %s/%s is '%s' supply; fail %s/%s\n", 1119 consumer_dev_name, 1120 dev_name(&node->regulator->dev), 1121 node->regulator->desc->name, 1122 supply, 1123 dev_name(&rdev->dev), rdev_get_name(rdev)); 1124 return -EBUSY; 1125 } 1126 1127 node = kzalloc(sizeof(struct regulator_map), GFP_KERNEL); 1128 if (node == NULL) 1129 return -ENOMEM; 1130 1131 node->regulator = rdev; 1132 node->supply = supply; 1133 1134 if (has_dev) { 1135 node->dev_name = kstrdup(consumer_dev_name, GFP_KERNEL); 1136 if (node->dev_name == NULL) { 1137 kfree(node); 1138 return -ENOMEM; 1139 } 1140 } 1141 1142 list_add(&node->list, ®ulator_map_list); 1143 return 0; 1144} 1145 1146static void unset_regulator_supplies(struct regulator_dev *rdev) 1147{ 1148 struct regulator_map *node, *n; 1149 1150 list_for_each_entry_safe(node, n, ®ulator_map_list, list) { 1151 if (rdev == node->regulator) { 1152 list_del(&node->list); 1153 kfree(node->dev_name); 1154 kfree(node); 1155 } 1156 } 1157} 1158 1159#define REG_STR_SIZE 64 1160 1161static struct regulator *create_regulator(struct regulator_dev *rdev, 1162 struct device *dev, 1163 const char *supply_name) 1164{ 1165 struct regulator *regulator; 1166 char buf[REG_STR_SIZE]; 1167 int err, size; 1168 1169 regulator = kzalloc(sizeof(*regulator), GFP_KERNEL); 1170 if (regulator == NULL) 1171 return NULL; 1172 1173 mutex_lock(&rdev->mutex); 1174 regulator->rdev = rdev; 1175 list_add(®ulator->list, &rdev->consumer_list); 1176 1177 if (dev) { 1178 regulator->dev = dev; 1179 1180 /* Add a link to the device sysfs entry */ 1181 size = scnprintf(buf, REG_STR_SIZE, "%s-%s", 1182 dev->kobj.name, supply_name); 1183 if (size >= REG_STR_SIZE) 1184 goto overflow_err; 1185 1186 regulator->supply_name = kstrdup(buf, GFP_KERNEL); 1187 if (regulator->supply_name == NULL) 1188 goto overflow_err; 1189 1190 err = sysfs_create_link(&rdev->dev.kobj, &dev->kobj, 1191 buf); 1192 if (err) { 1193 rdev_warn(rdev, "could not add device link %s err %d\n", 1194 dev->kobj.name, err); 1195 /* non-fatal */ 1196 } 1197 } else { 1198 regulator->supply_name = kstrdup(supply_name, GFP_KERNEL); 1199 if (regulator->supply_name == NULL) 1200 goto overflow_err; 1201 } 1202 1203 regulator->debugfs = debugfs_create_dir(regulator->supply_name, 1204 rdev->debugfs); 1205 if (!regulator->debugfs) { 1206 rdev_warn(rdev, "Failed to create debugfs directory\n"); 1207 } else { 1208 debugfs_create_u32("uA_load", 0444, regulator->debugfs, 1209 ®ulator->uA_load); 1210 debugfs_create_u32("min_uV", 0444, regulator->debugfs, 1211 ®ulator->min_uV); 1212 debugfs_create_u32("max_uV", 0444, regulator->debugfs, 1213 ®ulator->max_uV); 1214 } 1215 1216 /* 1217 * Check now if the regulator is an always on regulator - if 1218 * it is then we don't need to do nearly so much work for 1219 * enable/disable calls. 1220 */ 1221 if (!_regulator_can_change_status(rdev) && 1222 _regulator_is_enabled(rdev)) 1223 regulator->always_on = true; 1224 1225 mutex_unlock(&rdev->mutex); 1226 return regulator; 1227overflow_err: 1228 list_del(®ulator->list); 1229 kfree(regulator); 1230 mutex_unlock(&rdev->mutex); 1231 return NULL; 1232} 1233 1234static int _regulator_get_enable_time(struct regulator_dev *rdev) 1235{ 1236 if (rdev->constraints && rdev->constraints->enable_time) 1237 return rdev->constraints->enable_time; 1238 if (!rdev->desc->ops->enable_time) 1239 return rdev->desc->enable_time; 1240 return rdev->desc->ops->enable_time(rdev); 1241} 1242 1243static struct regulator_supply_alias *regulator_find_supply_alias( 1244 struct device *dev, const char *supply) 1245{ 1246 struct regulator_supply_alias *map; 1247 1248 list_for_each_entry(map, ®ulator_supply_alias_list, list) 1249 if (map->src_dev == dev && strcmp(map->src_supply, supply) == 0) 1250 return map; 1251 1252 return NULL; 1253} 1254 1255static void regulator_supply_alias(struct device **dev, const char **supply) 1256{ 1257 struct regulator_supply_alias *map; 1258 1259 map = regulator_find_supply_alias(*dev, *supply); 1260 if (map) { 1261 dev_dbg(*dev, "Mapping supply %s to %s,%s\n", 1262 *supply, map->alias_supply, 1263 dev_name(map->alias_dev)); 1264 *dev = map->alias_dev; 1265 *supply = map->alias_supply; 1266 } 1267} 1268 1269static struct regulator_dev *regulator_dev_lookup(struct device *dev, 1270 const char *supply, 1271 int *ret) 1272{ 1273 struct regulator_dev *r; 1274 struct device_node *node; 1275 struct regulator_map *map; 1276 const char *devname = NULL; 1277 1278 regulator_supply_alias(&dev, &supply); 1279 1280 /* first do a dt based lookup */ 1281 if (dev && dev->of_node) { 1282 node = of_get_regulator(dev, supply); 1283 if (node) { 1284 list_for_each_entry(r, ®ulator_list, list) 1285 if (r->dev.parent && 1286 node == r->dev.of_node) 1287 return r; 1288 *ret = -EPROBE_DEFER; 1289 return NULL; 1290 } else { 1291 /* 1292 * If we couldn't even get the node then it's 1293 * not just that the device didn't register 1294 * yet, there's no node and we'll never 1295 * succeed. 1296 */ 1297 *ret = -ENODEV; 1298 } 1299 } 1300 1301 /* if not found, try doing it non-dt way */ 1302 if (dev) 1303 devname = dev_name(dev); 1304 1305 list_for_each_entry(r, ®ulator_list, list) 1306 if (strcmp(rdev_get_name(r), supply) == 0) 1307 return r; 1308 1309 list_for_each_entry(map, ®ulator_map_list, list) { 1310 /* If the mapping has a device set up it must match */ 1311 if (map->dev_name && 1312 (!devname || strcmp(map->dev_name, devname))) 1313 continue; 1314 1315 if (strcmp(map->supply, supply) == 0) 1316 return map->regulator; 1317 } 1318 1319 1320 return NULL; 1321} 1322 1323/* Internal regulator request function */ 1324static struct regulator *_regulator_get(struct device *dev, const char *id, 1325 bool exclusive, bool allow_dummy) 1326{ 1327 struct regulator_dev *rdev; 1328 struct regulator *regulator = ERR_PTR(-EPROBE_DEFER); 1329 const char *devname = NULL; 1330 int ret; 1331 1332 if (id == NULL) { 1333 pr_err("get() with no identifier\n"); 1334 return ERR_PTR(-EINVAL); 1335 } 1336 1337 if (dev) 1338 devname = dev_name(dev); 1339 1340 if (have_full_constraints()) 1341 ret = -ENODEV; 1342 else 1343 ret = -EPROBE_DEFER; 1344 1345 mutex_lock(®ulator_list_mutex); 1346 1347 rdev = regulator_dev_lookup(dev, id, &ret); 1348 if (rdev) 1349 goto found; 1350 1351 regulator = ERR_PTR(ret); 1352 1353 /* 1354 * If we have return value from dev_lookup fail, we do not expect to 1355 * succeed, so, quit with appropriate error value 1356 */ 1357 if (ret && ret != -ENODEV) 1358 goto out; 1359 1360 if (!devname) 1361 devname = "deviceless"; 1362 1363 /* 1364 * Assume that a regulator is physically present and enabled 1365 * even if it isn't hooked up and just provide a dummy. 1366 */ 1367 if (have_full_constraints() && allow_dummy) { 1368 pr_warn("%s supply %s not found, using dummy regulator\n", 1369 devname, id); 1370 1371 rdev = dummy_regulator_rdev; 1372 goto found; 1373 /* Don't log an error when called from regulator_get_optional() */ 1374 } else if (!have_full_constraints() || exclusive) { 1375 dev_warn(dev, "dummy supplies not allowed\n"); 1376 } 1377 1378 mutex_unlock(®ulator_list_mutex); 1379 return regulator; 1380 1381found: 1382 if (rdev->exclusive) { 1383 regulator = ERR_PTR(-EPERM); 1384 goto out; 1385 } 1386 1387 if (exclusive && rdev->open_count) { 1388 regulator = ERR_PTR(-EBUSY); 1389 goto out; 1390 } 1391 1392 if (!try_module_get(rdev->owner)) 1393 goto out; 1394 1395 regulator = create_regulator(rdev, dev, id); 1396 if (regulator == NULL) { 1397 regulator = ERR_PTR(-ENOMEM); 1398 module_put(rdev->owner); 1399 goto out; 1400 } 1401 1402 rdev->open_count++; 1403 if (exclusive) { 1404 rdev->exclusive = 1; 1405 1406 ret = _regulator_is_enabled(rdev); 1407 if (ret > 0) 1408 rdev->use_count = 1; 1409 else 1410 rdev->use_count = 0; 1411 } 1412 1413out: 1414 mutex_unlock(®ulator_list_mutex); 1415 1416 return regulator; 1417} 1418 1419/** 1420 * regulator_get - lookup and obtain a reference to a regulator. 1421 * @dev: device for regulator "consumer" 1422 * @id: Supply name or regulator ID. 1423 * 1424 * Returns a struct regulator corresponding to the regulator producer, 1425 * or IS_ERR() condition containing errno. 1426 * 1427 * Use of supply names configured via regulator_set_device_supply() is 1428 * strongly encouraged. It is recommended that the supply name used 1429 * should match the name used for the supply and/or the relevant 1430 * device pins in the datasheet. 1431 */ 1432struct regulator *regulator_get(struct device *dev, const char *id) 1433{ 1434 return _regulator_get(dev, id, false, true); 1435} 1436EXPORT_SYMBOL_GPL(regulator_get); 1437 1438/** 1439 * regulator_get_exclusive - obtain exclusive access to a regulator. 1440 * @dev: device for regulator "consumer" 1441 * @id: Supply name or regulator ID. 1442 * 1443 * Returns a struct regulator corresponding to the regulator producer, 1444 * or IS_ERR() condition containing errno. Other consumers will be 1445 * unable to obtain this regulator while this reference is held and the 1446 * use count for the regulator will be initialised to reflect the current 1447 * state of the regulator. 1448 * 1449 * This is intended for use by consumers which cannot tolerate shared 1450 * use of the regulator such as those which need to force the 1451 * regulator off for correct operation of the hardware they are 1452 * controlling. 1453 * 1454 * Use of supply names configured via regulator_set_device_supply() is 1455 * strongly encouraged. It is recommended that the supply name used 1456 * should match the name used for the supply and/or the relevant 1457 * device pins in the datasheet. 1458 */ 1459struct regulator *regulator_get_exclusive(struct device *dev, const char *id) 1460{ 1461 return _regulator_get(dev, id, true, false); 1462} 1463EXPORT_SYMBOL_GPL(regulator_get_exclusive); 1464 1465/** 1466 * regulator_get_optional - obtain optional access to a regulator. 1467 * @dev: device for regulator "consumer" 1468 * @id: Supply name or regulator ID. 1469 * 1470 * Returns a struct regulator corresponding to the regulator producer, 1471 * or IS_ERR() condition containing errno. 1472 * 1473 * This is intended for use by consumers for devices which can have 1474 * some supplies unconnected in normal use, such as some MMC devices. 1475 * It can allow the regulator core to provide stub supplies for other 1476 * supplies requested using normal regulator_get() calls without 1477 * disrupting the operation of drivers that can handle absent 1478 * supplies. 1479 * 1480 * Use of supply names configured via regulator_set_device_supply() is 1481 * strongly encouraged. It is recommended that the supply name used 1482 * should match the name used for the supply and/or the relevant 1483 * device pins in the datasheet. 1484 */ 1485struct regulator *regulator_get_optional(struct device *dev, const char *id) 1486{ 1487 return _regulator_get(dev, id, false, false); 1488} 1489EXPORT_SYMBOL_GPL(regulator_get_optional); 1490 1491/* Locks held by regulator_put() */ 1492static void _regulator_put(struct regulator *regulator) 1493{ 1494 struct regulator_dev *rdev; 1495 1496 if (regulator == NULL || IS_ERR(regulator)) 1497 return; 1498 1499 rdev = regulator->rdev; 1500 1501 debugfs_remove_recursive(regulator->debugfs); 1502 1503 /* remove any sysfs entries */ 1504 if (regulator->dev) 1505 sysfs_remove_link(&rdev->dev.kobj, regulator->supply_name); 1506 kfree(regulator->supply_name); 1507 list_del(®ulator->list); 1508 kfree(regulator); 1509 1510 rdev->open_count--; 1511 rdev->exclusive = 0; 1512 1513 module_put(rdev->owner); 1514} 1515 1516/** 1517 * regulator_put - "free" the regulator source 1518 * @regulator: regulator source 1519 * 1520 * Note: drivers must ensure that all regulator_enable calls made on this 1521 * regulator source are balanced by regulator_disable calls prior to calling 1522 * this function. 1523 */ 1524void regulator_put(struct regulator *regulator) 1525{ 1526 mutex_lock(®ulator_list_mutex); 1527 _regulator_put(regulator); 1528 mutex_unlock(®ulator_list_mutex); 1529} 1530EXPORT_SYMBOL_GPL(regulator_put); 1531 1532/** 1533 * regulator_register_supply_alias - Provide device alias for supply lookup 1534 * 1535 * @dev: device that will be given as the regulator "consumer" 1536 * @id: Supply name or regulator ID 1537 * @alias_dev: device that should be used to lookup the supply 1538 * @alias_id: Supply name or regulator ID that should be used to lookup the 1539 * supply 1540 * 1541 * All lookups for id on dev will instead be conducted for alias_id on 1542 * alias_dev. 1543 */ 1544int regulator_register_supply_alias(struct device *dev, const char *id, 1545 struct device *alias_dev, 1546 const char *alias_id) 1547{ 1548 struct regulator_supply_alias *map; 1549 1550 map = regulator_find_supply_alias(dev, id); 1551 if (map) 1552 return -EEXIST; 1553 1554 map = kzalloc(sizeof(struct regulator_supply_alias), GFP_KERNEL); 1555 if (!map) 1556 return -ENOMEM; 1557 1558 map->src_dev = dev; 1559 map->src_supply = id; 1560 map->alias_dev = alias_dev; 1561 map->alias_supply = alias_id; 1562 1563 list_add(&map->list, ®ulator_supply_alias_list); 1564 1565 pr_info("Adding alias for supply %s,%s -> %s,%s\n", 1566 id, dev_name(dev), alias_id, dev_name(alias_dev)); 1567 1568 return 0; 1569} 1570EXPORT_SYMBOL_GPL(regulator_register_supply_alias); 1571 1572/** 1573 * regulator_unregister_supply_alias - Remove device alias 1574 * 1575 * @dev: device that will be given as the regulator "consumer" 1576 * @id: Supply name or regulator ID 1577 * 1578 * Remove a lookup alias if one exists for id on dev. 1579 */ 1580void regulator_unregister_supply_alias(struct device *dev, const char *id) 1581{ 1582 struct regulator_supply_alias *map; 1583 1584 map = regulator_find_supply_alias(dev, id); 1585 if (map) { 1586 list_del(&map->list); 1587 kfree(map); 1588 } 1589} 1590EXPORT_SYMBOL_GPL(regulator_unregister_supply_alias); 1591 1592/** 1593 * regulator_bulk_register_supply_alias - register multiple aliases 1594 * 1595 * @dev: device that will be given as the regulator "consumer" 1596 * @id: List of supply names or regulator IDs 1597 * @alias_dev: device that should be used to lookup the supply 1598 * @alias_id: List of supply names or regulator IDs that should be used to 1599 * lookup the supply 1600 * @num_id: Number of aliases to register 1601 * 1602 * @return 0 on success, an errno on failure. 1603 * 1604 * This helper function allows drivers to register several supply 1605 * aliases in one operation. If any of the aliases cannot be 1606 * registered any aliases that were registered will be removed 1607 * before returning to the caller. 1608 */ 1609int regulator_bulk_register_supply_alias(struct device *dev, 1610 const char *const *id, 1611 struct device *alias_dev, 1612 const char *const *alias_id, 1613 int num_id) 1614{ 1615 int i; 1616 int ret; 1617 1618 for (i = 0; i < num_id; ++i) { 1619 ret = regulator_register_supply_alias(dev, id[i], alias_dev, 1620 alias_id[i]); 1621 if (ret < 0) 1622 goto err; 1623 } 1624 1625 return 0; 1626 1627err: 1628 dev_err(dev, 1629 "Failed to create supply alias %s,%s -> %s,%s\n", 1630 id[i], dev_name(dev), alias_id[i], dev_name(alias_dev)); 1631 1632 while (--i >= 0) 1633 regulator_unregister_supply_alias(dev, id[i]); 1634 1635 return ret; 1636} 1637EXPORT_SYMBOL_GPL(regulator_bulk_register_supply_alias); 1638 1639/** 1640 * regulator_bulk_unregister_supply_alias - unregister multiple aliases 1641 * 1642 * @dev: device that will be given as the regulator "consumer" 1643 * @id: List of supply names or regulator IDs 1644 * @num_id: Number of aliases to unregister 1645 * 1646 * This helper function allows drivers to unregister several supply 1647 * aliases in one operation. 1648 */ 1649void regulator_bulk_unregister_supply_alias(struct device *dev, 1650 const char *const *id, 1651 int num_id) 1652{ 1653 int i; 1654 1655 for (i = 0; i < num_id; ++i) 1656 regulator_unregister_supply_alias(dev, id[i]); 1657} 1658EXPORT_SYMBOL_GPL(regulator_bulk_unregister_supply_alias); 1659 1660 1661/* Manage enable GPIO list. Same GPIO pin can be shared among regulators */ 1662static int regulator_ena_gpio_request(struct regulator_dev *rdev, 1663 const struct regulator_config *config) 1664{ 1665 struct regulator_enable_gpio *pin; 1666 struct gpio_desc *gpiod; 1667 int ret; 1668 1669 gpiod = gpio_to_desc(config->ena_gpio); 1670 1671 list_for_each_entry(pin, ®ulator_ena_gpio_list, list) { 1672 if (pin->gpiod == gpiod) { 1673 rdev_dbg(rdev, "GPIO %d is already used\n", 1674 config->ena_gpio); 1675 goto update_ena_gpio_to_rdev; 1676 } 1677 } 1678 1679 ret = gpio_request_one(config->ena_gpio, 1680 GPIOF_DIR_OUT | config->ena_gpio_flags, 1681 rdev_get_name(rdev)); 1682 if (ret) 1683 return ret; 1684 1685 pin = kzalloc(sizeof(struct regulator_enable_gpio), GFP_KERNEL); 1686 if (pin == NULL) { 1687 gpio_free(config->ena_gpio); 1688 return -ENOMEM; 1689 } 1690 1691 pin->gpiod = gpiod; 1692 pin->ena_gpio_invert = config->ena_gpio_invert; 1693 list_add(&pin->list, ®ulator_ena_gpio_list); 1694 1695update_ena_gpio_to_rdev: 1696 pin->request_count++; 1697 rdev->ena_pin = pin; 1698 return 0; 1699} 1700 1701static void regulator_ena_gpio_free(struct regulator_dev *rdev) 1702{ 1703 struct regulator_enable_gpio *pin, *n; 1704 1705 if (!rdev->ena_pin) 1706 return; 1707 1708 /* Free the GPIO only in case of no use */ 1709 list_for_each_entry_safe(pin, n, ®ulator_ena_gpio_list, list) { 1710 if (pin->gpiod == rdev->ena_pin->gpiod) { 1711 if (pin->request_count <= 1) { 1712 pin->request_count = 0; 1713 gpiod_put(pin->gpiod); 1714 list_del(&pin->list); 1715 kfree(pin); 1716 } else { 1717 pin->request_count--; 1718 } 1719 } 1720 } 1721} 1722 1723/** 1724 * regulator_ena_gpio_ctrl - balance enable_count of each GPIO and actual GPIO pin control 1725 * @rdev: regulator_dev structure 1726 * @enable: enable GPIO at initial use? 1727 * 1728 * GPIO is enabled in case of initial use. (enable_count is 0) 1729 * GPIO is disabled when it is not shared any more. (enable_count <= 1) 1730 */ 1731static int regulator_ena_gpio_ctrl(struct regulator_dev *rdev, bool enable) 1732{ 1733 struct regulator_enable_gpio *pin = rdev->ena_pin; 1734 1735 if (!pin) 1736 return -EINVAL; 1737 1738 if (enable) { 1739 /* Enable GPIO at initial use */ 1740 if (pin->enable_count == 0) 1741 gpiod_set_value_cansleep(pin->gpiod, 1742 !pin->ena_gpio_invert); 1743 1744 pin->enable_count++; 1745 } else { 1746 if (pin->enable_count > 1) { 1747 pin->enable_count--; 1748 return 0; 1749 } 1750 1751 /* Disable GPIO if not used */ 1752 if (pin->enable_count <= 1) { 1753 gpiod_set_value_cansleep(pin->gpiod, 1754 pin->ena_gpio_invert); 1755 pin->enable_count = 0; 1756 } 1757 } 1758 1759 return 0; 1760} 1761 1762/** 1763 * _regulator_enable_delay - a delay helper function 1764 * @delay: time to delay in microseconds 1765 * 1766 * Delay for the requested amount of time as per the guidelines in: 1767 * 1768 * Documentation/timers/timers-howto.txt 1769 * 1770 * The assumption here is that regulators will never be enabled in 1771 * atomic context and therefore sleeping functions can be used. 1772 */ 1773static void _regulator_enable_delay(unsigned int delay) 1774{ 1775 unsigned int ms = delay / 1000; 1776 unsigned int us = delay % 1000; 1777 1778 if (ms > 0) { 1779 /* 1780 * For small enough values, handle super-millisecond 1781 * delays in the usleep_range() call below. 1782 */ 1783 if (ms < 20) 1784 us += ms * 1000; 1785 else 1786 msleep(ms); 1787 } 1788 1789 /* 1790 * Give the scheduler some room to coalesce with any other 1791 * wakeup sources. For delays shorter than 10 us, don't even 1792 * bother setting up high-resolution timers and just busy- 1793 * loop. 1794 */ 1795 if (us >= 10) 1796 usleep_range(us, us + 100); 1797 else 1798 udelay(us); 1799} 1800 1801static int _regulator_do_enable(struct regulator_dev *rdev) 1802{ 1803 int ret, delay; 1804 1805 /* Query before enabling in case configuration dependent. */ 1806 ret = _regulator_get_enable_time(rdev); 1807 if (ret >= 0) { 1808 delay = ret; 1809 } else { 1810 rdev_warn(rdev, "enable_time() failed: %d\n", ret); 1811 delay = 0; 1812 } 1813 1814 trace_regulator_enable(rdev_get_name(rdev)); 1815 1816 if (rdev->ena_pin) { 1817 ret = regulator_ena_gpio_ctrl(rdev, true); 1818 if (ret < 0) 1819 return ret; 1820 rdev->ena_gpio_state = 1; 1821 } else if (rdev->desc->ops->enable) { 1822 ret = rdev->desc->ops->enable(rdev); 1823 if (ret < 0) 1824 return ret; 1825 } else { 1826 return -EINVAL; 1827 } 1828 1829 /* Allow the regulator to ramp; it would be useful to extend 1830 * this for bulk operations so that the regulators can ramp 1831 * together. */ 1832 trace_regulator_enable_delay(rdev_get_name(rdev)); 1833 1834 _regulator_enable_delay(delay); 1835 1836 trace_regulator_enable_complete(rdev_get_name(rdev)); 1837 1838 return 0; 1839} 1840 1841/* locks held by regulator_enable() */ 1842static int _regulator_enable(struct regulator_dev *rdev) 1843{ 1844 int ret; 1845 1846 /* check voltage and requested load before enabling */ 1847 if (rdev->constraints && 1848 (rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_DRMS)) 1849 drms_uA_update(rdev); 1850 1851 if (rdev->use_count == 0) { 1852 /* The regulator may on if it's not switchable or left on */ 1853 ret = _regulator_is_enabled(rdev); 1854 if (ret == -EINVAL || ret == 0) { 1855 if (!_regulator_can_change_status(rdev)) 1856 return -EPERM; 1857 1858 ret = _regulator_do_enable(rdev); 1859 if (ret < 0) 1860 return ret; 1861 1862 } else if (ret < 0) { 1863 rdev_err(rdev, "is_enabled() failed: %d\n", ret); 1864 return ret; 1865 } 1866 /* Fallthrough on positive return values - already enabled */ 1867 } 1868 1869 rdev->use_count++; 1870 1871 return 0; 1872} 1873 1874/** 1875 * regulator_enable - enable regulator output 1876 * @regulator: regulator source 1877 * 1878 * Request that the regulator be enabled with the regulator output at 1879 * the predefined voltage or current value. Calls to regulator_enable() 1880 * must be balanced with calls to regulator_disable(). 1881 * 1882 * NOTE: the output value can be set by other drivers, boot loader or may be 1883 * hardwired in the regulator. 1884 */ 1885int regulator_enable(struct regulator *regulator) 1886{ 1887 struct regulator_dev *rdev = regulator->rdev; 1888 int ret = 0; 1889 1890 if (regulator->always_on) 1891 return 0; 1892 1893 if (rdev->supply) { 1894 ret = regulator_enable(rdev->supply); 1895 if (ret != 0) 1896 return ret; 1897 } 1898 1899 mutex_lock(&rdev->mutex); 1900 ret = _regulator_enable(rdev); 1901 mutex_unlock(&rdev->mutex); 1902 1903 if (ret != 0 && rdev->supply) 1904 regulator_disable(rdev->supply); 1905 1906 return ret; 1907} 1908EXPORT_SYMBOL_GPL(regulator_enable); 1909 1910static int _regulator_do_disable(struct regulator_dev *rdev) 1911{ 1912 int ret; 1913 1914 trace_regulator_disable(rdev_get_name(rdev)); 1915 1916 if (rdev->ena_pin) { 1917 ret = regulator_ena_gpio_ctrl(rdev, false); 1918 if (ret < 0) 1919 return ret; 1920 rdev->ena_gpio_state = 0; 1921 1922 } else if (rdev->desc->ops->disable) { 1923 ret = rdev->desc->ops->disable(rdev); 1924 if (ret != 0) 1925 return ret; 1926 } 1927 1928 trace_regulator_disable_complete(rdev_get_name(rdev)); 1929 1930 return 0; 1931} 1932 1933/* locks held by regulator_disable() */ 1934static int _regulator_disable(struct regulator_dev *rdev) 1935{ 1936 int ret = 0; 1937 1938 if (WARN(rdev->use_count <= 0, 1939 "unbalanced disables for %s\n", rdev_get_name(rdev))) 1940 return -EIO; 1941 1942 /* are we the last user and permitted to disable ? */ 1943 if (rdev->use_count == 1 && 1944 (rdev->constraints && !rdev->constraints->always_on)) { 1945 1946 /* we are last user */ 1947 if (_regulator_can_change_status(rdev)) { 1948 ret = _regulator_do_disable(rdev); 1949 if (ret < 0) { 1950 rdev_err(rdev, "failed to disable\n"); 1951 return ret; 1952 } 1953 _notifier_call_chain(rdev, REGULATOR_EVENT_DISABLE, 1954 NULL); 1955 } 1956 1957 rdev->use_count = 0; 1958 } else if (rdev->use_count > 1) { 1959 1960 if (rdev->constraints && 1961 (rdev->constraints->valid_ops_mask & 1962 REGULATOR_CHANGE_DRMS)) 1963 drms_uA_update(rdev); 1964 1965 rdev->use_count--; 1966 } 1967 1968 return ret; 1969} 1970 1971/** 1972 * regulator_disable - disable regulator output 1973 * @regulator: regulator source 1974 * 1975 * Disable the regulator output voltage or current. Calls to 1976 * regulator_enable() must be balanced with calls to 1977 * regulator_disable(). 1978 * 1979 * NOTE: this will only disable the regulator output if no other consumer 1980 * devices have it enabled, the regulator device supports disabling and 1981 * machine constraints permit this operation. 1982 */ 1983int regulator_disable(struct regulator *regulator) 1984{ 1985 struct regulator_dev *rdev = regulator->rdev; 1986 int ret = 0; 1987 1988 if (regulator->always_on) 1989 return 0; 1990 1991 mutex_lock(&rdev->mutex); 1992 ret = _regulator_disable(rdev); 1993 mutex_unlock(&rdev->mutex); 1994 1995 if (ret == 0 && rdev->supply) 1996 regulator_disable(rdev->supply); 1997 1998 return ret; 1999} 2000EXPORT_SYMBOL_GPL(regulator_disable); 2001 2002/* locks held by regulator_force_disable() */ 2003static int _regulator_force_disable(struct regulator_dev *rdev) 2004{ 2005 int ret = 0; 2006 2007 ret = _regulator_do_disable(rdev); 2008 if (ret < 0) { 2009 rdev_err(rdev, "failed to force disable\n"); 2010 return ret; 2011 } 2012 2013 _notifier_call_chain(rdev, REGULATOR_EVENT_FORCE_DISABLE | 2014 REGULATOR_EVENT_DISABLE, NULL); 2015 2016 return 0; 2017} 2018 2019/** 2020 * regulator_force_disable - force disable regulator output 2021 * @regulator: regulator source 2022 * 2023 * Forcibly disable the regulator output voltage or current. 2024 * NOTE: this *will* disable the regulator output even if other consumer 2025 * devices have it enabled. This should be used for situations when device 2026 * damage will likely occur if the regulator is not disabled (e.g. over temp). 2027 */ 2028int regulator_force_disable(struct regulator *regulator) 2029{ 2030 struct regulator_dev *rdev = regulator->rdev; 2031 int ret; 2032 2033 mutex_lock(&rdev->mutex); 2034 regulator->uA_load = 0; 2035 ret = _regulator_force_disable(regulator->rdev); 2036 mutex_unlock(&rdev->mutex); 2037 2038 if (rdev->supply) 2039 while (rdev->open_count--) 2040 regulator_disable(rdev->supply); 2041 2042 return ret; 2043} 2044EXPORT_SYMBOL_GPL(regulator_force_disable); 2045 2046static void regulator_disable_work(struct work_struct *work) 2047{ 2048 struct regulator_dev *rdev = container_of(work, struct regulator_dev, 2049 disable_work.work); 2050 int count, i, ret; 2051 2052 mutex_lock(&rdev->mutex); 2053 2054 BUG_ON(!rdev->deferred_disables); 2055 2056 count = rdev->deferred_disables; 2057 rdev->deferred_disables = 0; 2058 2059 for (i = 0; i < count; i++) { 2060 ret = _regulator_disable(rdev); 2061 if (ret != 0) 2062 rdev_err(rdev, "Deferred disable failed: %d\n", ret); 2063 } 2064 2065 mutex_unlock(&rdev->mutex); 2066 2067 if (rdev->supply) { 2068 for (i = 0; i < count; i++) { 2069 ret = regulator_disable(rdev->supply); 2070 if (ret != 0) { 2071 rdev_err(rdev, 2072 "Supply disable failed: %d\n", ret); 2073 } 2074 } 2075 } 2076} 2077 2078/** 2079 * regulator_disable_deferred - disable regulator output with delay 2080 * @regulator: regulator source 2081 * @ms: miliseconds until the regulator is disabled 2082 * 2083 * Execute regulator_disable() on the regulator after a delay. This 2084 * is intended for use with devices that require some time to quiesce. 2085 * 2086 * NOTE: this will only disable the regulator output if no other consumer 2087 * devices have it enabled, the regulator device supports disabling and 2088 * machine constraints permit this operation. 2089 */ 2090int regulator_disable_deferred(struct regulator *regulator, int ms) 2091{ 2092 struct regulator_dev *rdev = regulator->rdev; 2093 int ret; 2094 2095 if (regulator->always_on) 2096 return 0; 2097 2098 if (!ms) 2099 return regulator_disable(regulator); 2100 2101 mutex_lock(&rdev->mutex); 2102 rdev->deferred_disables++; 2103 mutex_unlock(&rdev->mutex); 2104 2105 ret = queue_delayed_work(system_power_efficient_wq, 2106 &rdev->disable_work, 2107 msecs_to_jiffies(ms)); 2108 if (ret < 0) 2109 return ret; 2110 else 2111 return 0; 2112} 2113EXPORT_SYMBOL_GPL(regulator_disable_deferred); 2114 2115static int _regulator_is_enabled(struct regulator_dev *rdev) 2116{ 2117 /* A GPIO control always takes precedence */ 2118 if (rdev->ena_pin) 2119 return rdev->ena_gpio_state; 2120 2121 /* If we don't know then assume that the regulator is always on */ 2122 if (!rdev->desc->ops->is_enabled) 2123 return 1; 2124 2125 return rdev->desc->ops->is_enabled(rdev); 2126} 2127 2128/** 2129 * regulator_is_enabled - is the regulator output enabled 2130 * @regulator: regulator source 2131 * 2132 * Returns positive if the regulator driver backing the source/client 2133 * has requested that the device be enabled, zero if it hasn't, else a 2134 * negative errno code. 2135 * 2136 * Note that the device backing this regulator handle can have multiple 2137 * users, so it might be enabled even if regulator_enable() was never 2138 * called for this particular source. 2139 */ 2140int regulator_is_enabled(struct regulator *regulator) 2141{ 2142 int ret; 2143 2144 if (regulator->always_on) 2145 return 1; 2146 2147 mutex_lock(®ulator->rdev->mutex); 2148 ret = _regulator_is_enabled(regulator->rdev); 2149 mutex_unlock(®ulator->rdev->mutex); 2150 2151 return ret; 2152} 2153EXPORT_SYMBOL_GPL(regulator_is_enabled); 2154 2155/** 2156 * regulator_can_change_voltage - check if regulator can change voltage 2157 * @regulator: regulator source 2158 * 2159 * Returns positive if the regulator driver backing the source/client 2160 * can change its voltage, false otherwise. Useful for detecting fixed 2161 * or dummy regulators and disabling voltage change logic in the client 2162 * driver. 2163 */ 2164int regulator_can_change_voltage(struct regulator *regulator) 2165{ 2166 struct regulator_dev *rdev = regulator->rdev; 2167 2168 if (rdev->constraints && 2169 (rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_VOLTAGE)) { 2170 if (rdev->desc->n_voltages - rdev->desc->linear_min_sel > 1) 2171 return 1; 2172 2173 if (rdev->desc->continuous_voltage_range && 2174 rdev->constraints->min_uV && rdev->constraints->max_uV && 2175 rdev->constraints->min_uV != rdev->constraints->max_uV) 2176 return 1; 2177 } 2178 2179 return 0; 2180} 2181EXPORT_SYMBOL_GPL(regulator_can_change_voltage); 2182 2183/** 2184 * regulator_count_voltages - count regulator_list_voltage() selectors 2185 * @regulator: regulator source 2186 * 2187 * Returns number of selectors, or negative errno. Selectors are 2188 * numbered starting at zero, and typically correspond to bitfields 2189 * in hardware registers. 2190 */ 2191int regulator_count_voltages(struct regulator *regulator) 2192{ 2193 struct regulator_dev *rdev = regulator->rdev; 2194 2195 if (rdev->desc->n_voltages) 2196 return rdev->desc->n_voltages; 2197 2198 if (!rdev->supply) 2199 return -EINVAL; 2200 2201 return regulator_count_voltages(rdev->supply); 2202} 2203EXPORT_SYMBOL_GPL(regulator_count_voltages); 2204 2205/** 2206 * regulator_list_voltage - enumerate supported voltages 2207 * @regulator: regulator source 2208 * @selector: identify voltage to list 2209 * Context: can sleep 2210 * 2211 * Returns a voltage that can be passed to @regulator_set_voltage(), 2212 * zero if this selector code can't be used on this system, or a 2213 * negative errno. 2214 */ 2215int regulator_list_voltage(struct regulator *regulator, unsigned selector) 2216{ 2217 struct regulator_dev *rdev = regulator->rdev; 2218 const struct regulator_ops *ops = rdev->desc->ops; 2219 int ret; 2220 2221 if (rdev->desc->fixed_uV && rdev->desc->n_voltages == 1 && !selector) 2222 return rdev->desc->fixed_uV; 2223 2224 if (ops->list_voltage) { 2225 if (selector >= rdev->desc->n_voltages) 2226 return -EINVAL; 2227 mutex_lock(&rdev->mutex); 2228 ret = ops->list_voltage(rdev, selector); 2229 mutex_unlock(&rdev->mutex); 2230 } else if (rdev->supply) { 2231 ret = regulator_list_voltage(rdev->supply, selector); 2232 } else { 2233 return -EINVAL; 2234 } 2235 2236 if (ret > 0) { 2237 if (ret < rdev->constraints->min_uV) 2238 ret = 0; 2239 else if (ret > rdev->constraints->max_uV) 2240 ret = 0; 2241 } 2242 2243 return ret; 2244} 2245EXPORT_SYMBOL_GPL(regulator_list_voltage); 2246 2247/** 2248 * regulator_get_regmap - get the regulator's register map 2249 * @regulator: regulator source 2250 * 2251 * Returns the register map for the given regulator, or an ERR_PTR value 2252 * if the regulator doesn't use regmap. 2253 */ 2254struct regmap *regulator_get_regmap(struct regulator *regulator) 2255{ 2256 struct regmap *map = regulator->rdev->regmap; 2257 2258 return map ? map : ERR_PTR(-EOPNOTSUPP); 2259} 2260 2261/** 2262 * regulator_get_hardware_vsel_register - get the HW voltage selector register 2263 * @regulator: regulator source 2264 * @vsel_reg: voltage selector register, output parameter 2265 * @vsel_mask: mask for voltage selector bitfield, output parameter 2266 * 2267 * Returns the hardware register offset and bitmask used for setting the 2268 * regulator voltage. This might be useful when configuring voltage-scaling 2269 * hardware or firmware that can make I2C requests behind the kernel's back, 2270 * for example. 2271 * 2272 * On success, the output parameters @vsel_reg and @vsel_mask are filled in 2273 * and 0 is returned, otherwise a negative errno is returned. 2274 */ 2275int regulator_get_hardware_vsel_register(struct regulator *regulator, 2276 unsigned *vsel_reg, 2277 unsigned *vsel_mask) 2278{ 2279 struct regulator_dev *rdev = regulator->rdev; 2280 struct regulator_ops *ops = rdev->desc->ops; 2281 2282 if (ops->set_voltage_sel != regulator_set_voltage_sel_regmap) 2283 return -EOPNOTSUPP; 2284 2285 *vsel_reg = rdev->desc->vsel_reg; 2286 *vsel_mask = rdev->desc->vsel_mask; 2287 2288 return 0; 2289} 2290EXPORT_SYMBOL_GPL(regulator_get_hardware_vsel_register); 2291 2292/** 2293 * regulator_list_hardware_vsel - get the HW-specific register value for a selector 2294 * @regulator: regulator source 2295 * @selector: identify voltage to list 2296 * 2297 * Converts the selector to a hardware-specific voltage selector that can be 2298 * directly written to the regulator registers. The address of the voltage 2299 * register can be determined by calling @regulator_get_hardware_vsel_register. 2300 * 2301 * On error a negative errno is returned. 2302 */ 2303int regulator_list_hardware_vsel(struct regulator *regulator, 2304 unsigned selector) 2305{ 2306 struct regulator_dev *rdev = regulator->rdev; 2307 struct regulator_ops *ops = rdev->desc->ops; 2308 2309 if (selector >= rdev->desc->n_voltages) 2310 return -EINVAL; 2311 if (ops->set_voltage_sel != regulator_set_voltage_sel_regmap) 2312 return -EOPNOTSUPP; 2313 2314 return selector; 2315} 2316EXPORT_SYMBOL_GPL(regulator_list_hardware_vsel); 2317 2318/** 2319 * regulator_get_linear_step - return the voltage step size between VSEL values 2320 * @regulator: regulator source 2321 * 2322 * Returns the voltage step size between VSEL values for linear 2323 * regulators, or return 0 if the regulator isn't a linear regulator. 2324 */ 2325unsigned int regulator_get_linear_step(struct regulator *regulator) 2326{ 2327 struct regulator_dev *rdev = regulator->rdev; 2328 2329 return rdev->desc->uV_step; 2330} 2331EXPORT_SYMBOL_GPL(regulator_get_linear_step); 2332 2333/** 2334 * regulator_is_supported_voltage - check if a voltage range can be supported 2335 * 2336 * @regulator: Regulator to check. 2337 * @min_uV: Minimum required voltage in uV. 2338 * @max_uV: Maximum required voltage in uV. 2339 * 2340 * Returns a boolean or a negative error code. 2341 */ 2342int regulator_is_supported_voltage(struct regulator *regulator, 2343 int min_uV, int max_uV) 2344{ 2345 struct regulator_dev *rdev = regulator->rdev; 2346 int i, voltages, ret; 2347 2348 /* If we can't change voltage check the current voltage */ 2349 if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_VOLTAGE)) { 2350 ret = regulator_get_voltage(regulator); 2351 if (ret >= 0) 2352 return min_uV <= ret && ret <= max_uV; 2353 else 2354 return ret; 2355 } 2356 2357 /* Any voltage within constrains range is fine? */ 2358 if (rdev->desc->continuous_voltage_range) 2359 return min_uV >= rdev->constraints->min_uV && 2360 max_uV <= rdev->constraints->max_uV; 2361 2362 ret = regulator_count_voltages(regulator); 2363 if (ret < 0) 2364 return ret; 2365 voltages = ret; 2366 2367 for (i = 0; i < voltages; i++) { 2368 ret = regulator_list_voltage(regulator, i); 2369 2370 if (ret >= min_uV && ret <= max_uV) 2371 return 1; 2372 } 2373 2374 return 0; 2375} 2376EXPORT_SYMBOL_GPL(regulator_is_supported_voltage); 2377 2378static int _regulator_do_set_voltage(struct regulator_dev *rdev, 2379 int min_uV, int max_uV) 2380{ 2381 int ret; 2382 int delay = 0; 2383 int best_val = 0; 2384 unsigned int selector; 2385 int old_selector = -1; 2386 2387 trace_regulator_set_voltage(rdev_get_name(rdev), min_uV, max_uV); 2388 2389 min_uV += rdev->constraints->uV_offset; 2390 max_uV += rdev->constraints->uV_offset; 2391 2392 /* 2393 * If we can't obtain the old selector there is not enough 2394 * info to call set_voltage_time_sel(). 2395 */ 2396 if (_regulator_is_enabled(rdev) && 2397 rdev->desc->ops->set_voltage_time_sel && 2398 rdev->desc->ops->get_voltage_sel) { 2399 old_selector = rdev->desc->ops->get_voltage_sel(rdev); 2400 if (old_selector < 0) 2401 return old_selector; 2402 } 2403 2404 if (rdev->desc->ops->set_voltage) { 2405 ret = rdev->desc->ops->set_voltage(rdev, min_uV, max_uV, 2406 &selector); 2407 2408 if (ret >= 0) { 2409 if (rdev->desc->ops->list_voltage) 2410 best_val = rdev->desc->ops->list_voltage(rdev, 2411 selector); 2412 else 2413 best_val = _regulator_get_voltage(rdev); 2414 } 2415 2416 } else if (rdev->desc->ops->set_voltage_sel) { 2417 if (rdev->desc->ops->map_voltage) { 2418 ret = rdev->desc->ops->map_voltage(rdev, min_uV, 2419 max_uV); 2420 } else { 2421 if (rdev->desc->ops->list_voltage == 2422 regulator_list_voltage_linear) 2423 ret = regulator_map_voltage_linear(rdev, 2424 min_uV, max_uV); 2425 else if (rdev->desc->ops->list_voltage == 2426 regulator_list_voltage_linear_range) 2427 ret = regulator_map_voltage_linear_range(rdev, 2428 min_uV, max_uV); 2429 else 2430 ret = regulator_map_voltage_iterate(rdev, 2431 min_uV, max_uV); 2432 } 2433 2434 if (ret >= 0) { 2435 best_val = rdev->desc->ops->list_voltage(rdev, ret); 2436 if (min_uV <= best_val && max_uV >= best_val) { 2437 selector = ret; 2438 if (old_selector == selector) 2439 ret = 0; 2440 else 2441 ret = rdev->desc->ops->set_voltage_sel( 2442 rdev, ret); 2443 } else { 2444 ret = -EINVAL; 2445 } 2446 } 2447 } else { 2448 ret = -EINVAL; 2449 } 2450 2451 /* Call set_voltage_time_sel if successfully obtained old_selector */ 2452 if (ret == 0 && !rdev->constraints->ramp_disable && old_selector >= 0 2453 && old_selector != selector) { 2454 2455 delay = rdev->desc->ops->set_voltage_time_sel(rdev, 2456 old_selector, selector); 2457 if (delay < 0) { 2458 rdev_warn(rdev, "set_voltage_time_sel() failed: %d\n", 2459 delay); 2460 delay = 0; 2461 } 2462 2463 /* Insert any necessary delays */ 2464 if (delay >= 1000) { 2465 mdelay(delay / 1000); 2466 udelay(delay % 1000); 2467 } else if (delay) { 2468 udelay(delay); 2469 } 2470 } 2471 2472 if (ret == 0 && best_val >= 0) { 2473 unsigned long data = best_val; 2474 2475 _notifier_call_chain(rdev, REGULATOR_EVENT_VOLTAGE_CHANGE, 2476 (void *)data); 2477 } 2478 2479 trace_regulator_set_voltage_complete(rdev_get_name(rdev), best_val); 2480 2481 return ret; 2482} 2483 2484/** 2485 * regulator_set_voltage - set regulator output voltage 2486 * @regulator: regulator source 2487 * @min_uV: Minimum required voltage in uV 2488 * @max_uV: Maximum acceptable voltage in uV 2489 * 2490 * Sets a voltage regulator to the desired output voltage. This can be set 2491 * during any regulator state. IOW, regulator can be disabled or enabled. 2492 * 2493 * If the regulator is enabled then the voltage will change to the new value 2494 * immediately otherwise if the regulator is disabled the regulator will 2495 * output at the new voltage when enabled. 2496 * 2497 * NOTE: If the regulator is shared between several devices then the lowest 2498 * request voltage that meets the system constraints will be used. 2499 * Regulator system constraints must be set for this regulator before 2500 * calling this function otherwise this call will fail. 2501 */ 2502int regulator_set_voltage(struct regulator *regulator, int min_uV, int max_uV) 2503{ 2504 struct regulator_dev *rdev = regulator->rdev; 2505 int ret = 0; 2506 int old_min_uV, old_max_uV; 2507 int current_uV; 2508 2509 mutex_lock(&rdev->mutex); 2510 2511 /* If we're setting the same range as last time the change 2512 * should be a noop (some cpufreq implementations use the same 2513 * voltage for multiple frequencies, for example). 2514 */ 2515 if (regulator->min_uV == min_uV && regulator->max_uV == max_uV) 2516 goto out; 2517 2518 /* If we're trying to set a range that overlaps the current voltage, 2519 * return succesfully even though the regulator does not support 2520 * changing the voltage. 2521 */ 2522 if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_VOLTAGE)) { 2523 current_uV = _regulator_get_voltage(rdev); 2524 if (min_uV <= current_uV && current_uV <= max_uV) { 2525 regulator->min_uV = min_uV; 2526 regulator->max_uV = max_uV; 2527 goto out; 2528 } 2529 } 2530 2531 /* sanity check */ 2532 if (!rdev->desc->ops->set_voltage && 2533 !rdev->desc->ops->set_voltage_sel) { 2534 ret = -EINVAL; 2535 goto out; 2536 } 2537 2538 /* constraints check */ 2539 ret = regulator_check_voltage(rdev, &min_uV, &max_uV); 2540 if (ret < 0) 2541 goto out; 2542 2543 /* restore original values in case of error */ 2544 old_min_uV = regulator->min_uV; 2545 old_max_uV = regulator->max_uV; 2546 regulator->min_uV = min_uV; 2547 regulator->max_uV = max_uV; 2548 2549 ret = regulator_check_consumers(rdev, &min_uV, &max_uV); 2550 if (ret < 0) 2551 goto out2; 2552 2553 ret = _regulator_do_set_voltage(rdev, min_uV, max_uV); 2554 if (ret < 0) 2555 goto out2; 2556 2557out: 2558 mutex_unlock(&rdev->mutex); 2559 return ret; 2560out2: 2561 regulator->min_uV = old_min_uV; 2562 regulator->max_uV = old_max_uV; 2563 mutex_unlock(&rdev->mutex); 2564 return ret; 2565} 2566EXPORT_SYMBOL_GPL(regulator_set_voltage); 2567 2568/** 2569 * regulator_set_voltage_time - get raise/fall time 2570 * @regulator: regulator source 2571 * @old_uV: starting voltage in microvolts 2572 * @new_uV: target voltage in microvolts 2573 * 2574 * Provided with the starting and ending voltage, this function attempts to 2575 * calculate the time in microseconds required to rise or fall to this new 2576 * voltage. 2577 */ 2578int regulator_set_voltage_time(struct regulator *regulator, 2579 int old_uV, int new_uV) 2580{ 2581 struct regulator_dev *rdev = regulator->rdev; 2582 const struct regulator_ops *ops = rdev->desc->ops; 2583 int old_sel = -1; 2584 int new_sel = -1; 2585 int voltage; 2586 int i; 2587 2588 /* Currently requires operations to do this */ 2589 if (!ops->list_voltage || !ops->set_voltage_time_sel 2590 || !rdev->desc->n_voltages) 2591 return -EINVAL; 2592 2593 for (i = 0; i < rdev->desc->n_voltages; i++) { 2594 /* We only look for exact voltage matches here */ 2595 voltage = regulator_list_voltage(regulator, i); 2596 if (voltage < 0) 2597 return -EINVAL; 2598 if (voltage == 0) 2599 continue; 2600 if (voltage == old_uV) 2601 old_sel = i; 2602 if (voltage == new_uV) 2603 new_sel = i; 2604 } 2605 2606 if (old_sel < 0 || new_sel < 0) 2607 return -EINVAL; 2608 2609 return ops->set_voltage_time_sel(rdev, old_sel, new_sel); 2610} 2611EXPORT_SYMBOL_GPL(regulator_set_voltage_time); 2612 2613/** 2614 * regulator_set_voltage_time_sel - get raise/fall time 2615 * @rdev: regulator source device 2616 * @old_selector: selector for starting voltage 2617 * @new_selector: selector for target voltage 2618 * 2619 * Provided with the starting and target voltage selectors, this function 2620 * returns time in microseconds required to rise or fall to this new voltage 2621 * 2622 * Drivers providing ramp_delay in regulation_constraints can use this as their 2623 * set_voltage_time_sel() operation. 2624 */ 2625int regulator_set_voltage_time_sel(struct regulator_dev *rdev, 2626 unsigned int old_selector, 2627 unsigned int new_selector) 2628{ 2629 unsigned int ramp_delay = 0; 2630 int old_volt, new_volt; 2631 2632 if (rdev->constraints->ramp_delay) 2633 ramp_delay = rdev->constraints->ramp_delay; 2634 else if (rdev->desc->ramp_delay) 2635 ramp_delay = rdev->desc->ramp_delay; 2636 2637 if (ramp_delay == 0) { 2638 rdev_warn(rdev, "ramp_delay not set\n"); 2639 return 0; 2640 } 2641 2642 /* sanity check */ 2643 if (!rdev->desc->ops->list_voltage) 2644 return -EINVAL; 2645 2646 old_volt = rdev->desc->ops->list_voltage(rdev, old_selector); 2647 new_volt = rdev->desc->ops->list_voltage(rdev, new_selector); 2648 2649 return DIV_ROUND_UP(abs(new_volt - old_volt), ramp_delay); 2650} 2651EXPORT_SYMBOL_GPL(regulator_set_voltage_time_sel); 2652 2653/** 2654 * regulator_sync_voltage - re-apply last regulator output voltage 2655 * @regulator: regulator source 2656 * 2657 * Re-apply the last configured voltage. This is intended to be used 2658 * where some external control source the consumer is cooperating with 2659 * has caused the configured voltage to change. 2660 */ 2661int regulator_sync_voltage(struct regulator *regulator) 2662{ 2663 struct regulator_dev *rdev = regulator->rdev; 2664 int ret, min_uV, max_uV; 2665 2666 mutex_lock(&rdev->mutex); 2667 2668 if (!rdev->desc->ops->set_voltage && 2669 !rdev->desc->ops->set_voltage_sel) { 2670 ret = -EINVAL; 2671 goto out; 2672 } 2673 2674 /* This is only going to work if we've had a voltage configured. */ 2675 if (!regulator->min_uV && !regulator->max_uV) { 2676 ret = -EINVAL; 2677 goto out; 2678 } 2679 2680 min_uV = regulator->min_uV; 2681 max_uV = regulator->max_uV; 2682 2683 /* This should be a paranoia check... */ 2684 ret = regulator_check_voltage(rdev, &min_uV, &max_uV); 2685 if (ret < 0) 2686 goto out; 2687 2688 ret = regulator_check_consumers(rdev, &min_uV, &max_uV); 2689 if (ret < 0) 2690 goto out; 2691 2692 ret = _regulator_do_set_voltage(rdev, min_uV, max_uV); 2693 2694out: 2695 mutex_unlock(&rdev->mutex); 2696 return ret; 2697} 2698EXPORT_SYMBOL_GPL(regulator_sync_voltage); 2699 2700static int _regulator_get_voltage(struct regulator_dev *rdev) 2701{ 2702 int sel, ret; 2703 2704 if (rdev->desc->ops->get_voltage_sel) { 2705 sel = rdev->desc->ops->get_voltage_sel(rdev); 2706 if (sel < 0) 2707 return sel; 2708 ret = rdev->desc->ops->list_voltage(rdev, sel); 2709 } else if (rdev->desc->ops->get_voltage) { 2710 ret = rdev->desc->ops->get_voltage(rdev); 2711 } else if (rdev->desc->ops->list_voltage) { 2712 ret = rdev->desc->ops->list_voltage(rdev, 0); 2713 } else if (rdev->desc->fixed_uV && (rdev->desc->n_voltages == 1)) { 2714 ret = rdev->desc->fixed_uV; 2715 } else if (rdev->supply) { 2716 ret = regulator_get_voltage(rdev->supply); 2717 } else { 2718 return -EINVAL; 2719 } 2720 2721 if (ret < 0) 2722 return ret; 2723 return ret - rdev->constraints->uV_offset; 2724} 2725 2726/** 2727 * regulator_get_voltage - get regulator output voltage 2728 * @regulator: regulator source 2729 * 2730 * This returns the current regulator voltage in uV. 2731 * 2732 * NOTE: If the regulator is disabled it will return the voltage value. This 2733 * function should not be used to determine regulator state. 2734 */ 2735int regulator_get_voltage(struct regulator *regulator) 2736{ 2737 int ret; 2738 2739 mutex_lock(®ulator->rdev->mutex); 2740 2741 ret = _regulator_get_voltage(regulator->rdev); 2742 2743 mutex_unlock(®ulator->rdev->mutex); 2744 2745 return ret; 2746} 2747EXPORT_SYMBOL_GPL(regulator_get_voltage); 2748 2749/** 2750 * regulator_set_current_limit - set regulator output current limit 2751 * @regulator: regulator source 2752 * @min_uA: Minimum supported current in uA 2753 * @max_uA: Maximum supported current in uA 2754 * 2755 * Sets current sink to the desired output current. This can be set during 2756 * any regulator state. IOW, regulator can be disabled or enabled. 2757 * 2758 * If the regulator is enabled then the current will change to the new value 2759 * immediately otherwise if the regulator is disabled the regulator will 2760 * output at the new current when enabled. 2761 * 2762 * NOTE: Regulator system constraints must be set for this regulator before 2763 * calling this function otherwise this call will fail. 2764 */ 2765int regulator_set_current_limit(struct regulator *regulator, 2766 int min_uA, int max_uA) 2767{ 2768 struct regulator_dev *rdev = regulator->rdev; 2769 int ret; 2770 2771 mutex_lock(&rdev->mutex); 2772 2773 /* sanity check */ 2774 if (!rdev->desc->ops->set_current_limit) { 2775 ret = -EINVAL; 2776 goto out; 2777 } 2778 2779 /* constraints check */ 2780 ret = regulator_check_current_limit(rdev, &min_uA, &max_uA); 2781 if (ret < 0) 2782 goto out; 2783 2784 ret = rdev->desc->ops->set_current_limit(rdev, min_uA, max_uA); 2785out: 2786 mutex_unlock(&rdev->mutex); 2787 return ret; 2788} 2789EXPORT_SYMBOL_GPL(regulator_set_current_limit); 2790 2791static int _regulator_get_current_limit(struct regulator_dev *rdev) 2792{ 2793 int ret; 2794 2795 mutex_lock(&rdev->mutex); 2796 2797 /* sanity check */ 2798 if (!rdev->desc->ops->get_current_limit) { 2799 ret = -EINVAL; 2800 goto out; 2801 } 2802 2803 ret = rdev->desc->ops->get_current_limit(rdev); 2804out: 2805 mutex_unlock(&rdev->mutex); 2806 return ret; 2807} 2808 2809/** 2810 * regulator_get_current_limit - get regulator output current 2811 * @regulator: regulator source 2812 * 2813 * This returns the current supplied by the specified current sink in uA. 2814 * 2815 * NOTE: If the regulator is disabled it will return the current value. This 2816 * function should not be used to determine regulator state. 2817 */ 2818int regulator_get_current_limit(struct regulator *regulator) 2819{ 2820 return _regulator_get_current_limit(regulator->rdev); 2821} 2822EXPORT_SYMBOL_GPL(regulator_get_current_limit); 2823 2824/** 2825 * regulator_set_mode - set regulator operating mode 2826 * @regulator: regulator source 2827 * @mode: operating mode - one of the REGULATOR_MODE constants 2828 * 2829 * Set regulator operating mode to increase regulator efficiency or improve 2830 * regulation performance. 2831 * 2832 * NOTE: Regulator system constraints must be set for this regulator before 2833 * calling this function otherwise this call will fail. 2834 */ 2835int regulator_set_mode(struct regulator *regulator, unsigned int mode) 2836{ 2837 struct regulator_dev *rdev = regulator->rdev; 2838 int ret; 2839 int regulator_curr_mode; 2840 2841 mutex_lock(&rdev->mutex); 2842 2843 /* sanity check */ 2844 if (!rdev->desc->ops->set_mode) { 2845 ret = -EINVAL; 2846 goto out; 2847 } 2848 2849 /* return if the same mode is requested */ 2850 if (rdev->desc->ops->get_mode) { 2851 regulator_curr_mode = rdev->desc->ops->get_mode(rdev); 2852 if (regulator_curr_mode == mode) { 2853 ret = 0; 2854 goto out; 2855 } 2856 } 2857 2858 /* constraints check */ 2859 ret = regulator_mode_constrain(rdev, &mode); 2860 if (ret < 0) 2861 goto out; 2862 2863 ret = rdev->desc->ops->set_mode(rdev, mode); 2864out: 2865 mutex_unlock(&rdev->mutex); 2866 return ret; 2867} 2868EXPORT_SYMBOL_GPL(regulator_set_mode); 2869 2870static unsigned int _regulator_get_mode(struct regulator_dev *rdev) 2871{ 2872 int ret; 2873 2874 mutex_lock(&rdev->mutex); 2875 2876 /* sanity check */ 2877 if (!rdev->desc->ops->get_mode) { 2878 ret = -EINVAL; 2879 goto out; 2880 } 2881 2882 ret = rdev->desc->ops->get_mode(rdev); 2883out: 2884 mutex_unlock(&rdev->mutex); 2885 return ret; 2886} 2887 2888/** 2889 * regulator_get_mode - get regulator operating mode 2890 * @regulator: regulator source 2891 * 2892 * Get the current regulator operating mode. 2893 */ 2894unsigned int regulator_get_mode(struct regulator *regulator) 2895{ 2896 return _regulator_get_mode(regulator->rdev); 2897} 2898EXPORT_SYMBOL_GPL(regulator_get_mode); 2899 2900/** 2901 * regulator_set_optimum_mode - set regulator optimum operating mode 2902 * @regulator: regulator source 2903 * @uA_load: load current 2904 * 2905 * Notifies the regulator core of a new device load. This is then used by 2906 * DRMS (if enabled by constraints) to set the most efficient regulator 2907 * operating mode for the new regulator loading. 2908 * 2909 * Consumer devices notify their supply regulator of the maximum power 2910 * they will require (can be taken from device datasheet in the power 2911 * consumption tables) when they change operational status and hence power 2912 * state. Examples of operational state changes that can affect power 2913 * consumption are :- 2914 * 2915 * o Device is opened / closed. 2916 * o Device I/O is about to begin or has just finished. 2917 * o Device is idling in between work. 2918 * 2919 * This information is also exported via sysfs to userspace. 2920 * 2921 * DRMS will sum the total requested load on the regulator and change 2922 * to the most efficient operating mode if platform constraints allow. 2923 * 2924 * Returns the new regulator mode or error. 2925 */ 2926int regulator_set_optimum_mode(struct regulator *regulator, int uA_load) 2927{ 2928 struct regulator_dev *rdev = regulator->rdev; 2929 struct regulator *consumer; 2930 int ret, output_uV, input_uV = 0, total_uA_load = 0; 2931 unsigned int mode; 2932 2933 if (rdev->supply) 2934 input_uV = regulator_get_voltage(rdev->supply); 2935 2936 mutex_lock(&rdev->mutex); 2937 2938 /* 2939 * first check to see if we can set modes at all, otherwise just 2940 * tell the consumer everything is OK. 2941 */ 2942 regulator->uA_load = uA_load; 2943 ret = regulator_check_drms(rdev); 2944 if (ret < 0) { 2945 ret = 0; 2946 goto out; 2947 } 2948 2949 if (!rdev->desc->ops->get_optimum_mode) 2950 goto out; 2951 2952 /* 2953 * we can actually do this so any errors are indicators of 2954 * potential real failure. 2955 */ 2956 ret = -EINVAL; 2957 2958 if (!rdev->desc->ops->set_mode) 2959 goto out; 2960 2961 /* get output voltage */ 2962 output_uV = _regulator_get_voltage(rdev); 2963 if (output_uV <= 0) { 2964 rdev_err(rdev, "invalid output voltage found\n"); 2965 goto out; 2966 } 2967 2968 /* No supply? Use constraint voltage */ 2969 if (input_uV <= 0) 2970 input_uV = rdev->constraints->input_uV; 2971 if (input_uV <= 0) { 2972 rdev_err(rdev, "invalid input voltage found\n"); 2973 goto out; 2974 } 2975 2976 /* calc total requested load for this regulator */ 2977 list_for_each_entry(consumer, &rdev->consumer_list, list) 2978 total_uA_load += consumer->uA_load; 2979 2980 mode = rdev->desc->ops->get_optimum_mode(rdev, 2981 input_uV, output_uV, 2982 total_uA_load); 2983 ret = regulator_mode_constrain(rdev, &mode); 2984 if (ret < 0) { 2985 rdev_err(rdev, "failed to get optimum mode @ %d uA %d -> %d uV\n", 2986 total_uA_load, input_uV, output_uV); 2987 goto out; 2988 } 2989 2990 ret = rdev->desc->ops->set_mode(rdev, mode); 2991 if (ret < 0) { 2992 rdev_err(rdev, "failed to set optimum mode %x\n", mode); 2993 goto out; 2994 } 2995 ret = mode; 2996out: 2997 mutex_unlock(&rdev->mutex); 2998 return ret; 2999} 3000EXPORT_SYMBOL_GPL(regulator_set_optimum_mode); 3001 3002/** 3003 * regulator_allow_bypass - allow the regulator to go into bypass mode 3004 * 3005 * @regulator: Regulator to configure 3006 * @enable: enable or disable bypass mode 3007 * 3008 * Allow the regulator to go into bypass mode if all other consumers 3009 * for the regulator also enable bypass mode and the machine 3010 * constraints allow this. Bypass mode means that the regulator is 3011 * simply passing the input directly to the output with no regulation. 3012 */ 3013int regulator_allow_bypass(struct regulator *regulator, bool enable) 3014{ 3015 struct regulator_dev *rdev = regulator->rdev; 3016 int ret = 0; 3017 3018 if (!rdev->desc->ops->set_bypass) 3019 return 0; 3020 3021 if (rdev->constraints && 3022 !(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_BYPASS)) 3023 return 0; 3024 3025 mutex_lock(&rdev->mutex); 3026 3027 if (enable && !regulator->bypass) { 3028 rdev->bypass_count++; 3029 3030 if (rdev->bypass_count == rdev->open_count) { 3031 ret = rdev->desc->ops->set_bypass(rdev, enable); 3032 if (ret != 0) 3033 rdev->bypass_count--; 3034 } 3035 3036 } else if (!enable && regulator->bypass) { 3037 rdev->bypass_count--; 3038 3039 if (rdev->bypass_count != rdev->open_count) { 3040 ret = rdev->desc->ops->set_bypass(rdev, enable); 3041 if (ret != 0) 3042 rdev->bypass_count++; 3043 } 3044 } 3045 3046 if (ret == 0) 3047 regulator->bypass = enable; 3048 3049 mutex_unlock(&rdev->mutex); 3050 3051 return ret; 3052} 3053EXPORT_SYMBOL_GPL(regulator_allow_bypass); 3054 3055/** 3056 * regulator_register_notifier - register regulator event notifier 3057 * @regulator: regulator source 3058 * @nb: notifier block 3059 * 3060 * Register notifier block to receive regulator events. 3061 */ 3062int regulator_register_notifier(struct regulator *regulator, 3063 struct notifier_block *nb) 3064{ 3065 return blocking_notifier_chain_register(®ulator->rdev->notifier, 3066 nb); 3067} 3068EXPORT_SYMBOL_GPL(regulator_register_notifier); 3069 3070/** 3071 * regulator_unregister_notifier - unregister regulator event notifier 3072 * @regulator: regulator source 3073 * @nb: notifier block 3074 * 3075 * Unregister regulator event notifier block. 3076 */ 3077int regulator_unregister_notifier(struct regulator *regulator, 3078 struct notifier_block *nb) 3079{ 3080 return blocking_notifier_chain_unregister(®ulator->rdev->notifier, 3081 nb); 3082} 3083EXPORT_SYMBOL_GPL(regulator_unregister_notifier); 3084 3085/* notify regulator consumers and downstream regulator consumers. 3086 * Note mutex must be held by caller. 3087 */ 3088static void _notifier_call_chain(struct regulator_dev *rdev, 3089 unsigned long event, void *data) 3090{ 3091 /* call rdev chain first */ 3092 blocking_notifier_call_chain(&rdev->notifier, event, data); 3093} 3094 3095/** 3096 * regulator_bulk_get - get multiple regulator consumers 3097 * 3098 * @dev: Device to supply 3099 * @num_consumers: Number of consumers to register 3100 * @consumers: Configuration of consumers; clients are stored here. 3101 * 3102 * @return 0 on success, an errno on failure. 3103 * 3104 * This helper function allows drivers to get several regulator 3105 * consumers in one operation. If any of the regulators cannot be 3106 * acquired then any regulators that were allocated will be freed 3107 * before returning to the caller. 3108 */ 3109int regulator_bulk_get(struct device *dev, int num_consumers, 3110 struct regulator_bulk_data *consumers) 3111{ 3112 int i; 3113 int ret; 3114 3115 for (i = 0; i < num_consumers; i++) 3116 consumers[i].consumer = NULL; 3117 3118 for (i = 0; i < num_consumers; i++) { 3119 consumers[i].consumer = regulator_get(dev, 3120 consumers[i].supply); 3121 if (IS_ERR(consumers[i].consumer)) { 3122 ret = PTR_ERR(consumers[i].consumer); 3123 dev_err(dev, "Failed to get supply '%s': %d\n", 3124 consumers[i].supply, ret); 3125 consumers[i].consumer = NULL; 3126 goto err; 3127 } 3128 } 3129 3130 return 0; 3131 3132err: 3133 while (--i >= 0) 3134 regulator_put(consumers[i].consumer); 3135 3136 return ret; 3137} 3138EXPORT_SYMBOL_GPL(regulator_bulk_get); 3139 3140static void regulator_bulk_enable_async(void *data, async_cookie_t cookie) 3141{ 3142 struct regulator_bulk_data *bulk = data; 3143 3144 bulk->ret = regulator_enable(bulk->consumer); 3145} 3146 3147/** 3148 * regulator_bulk_enable - enable multiple regulator consumers 3149 * 3150 * @num_consumers: Number of consumers 3151 * @consumers: Consumer data; clients are stored here. 3152 * @return 0 on success, an errno on failure 3153 * 3154 * This convenience API allows consumers to enable multiple regulator 3155 * clients in a single API call. If any consumers cannot be enabled 3156 * then any others that were enabled will be disabled again prior to 3157 * return. 3158 */ 3159int regulator_bulk_enable(int num_consumers, 3160 struct regulator_bulk_data *consumers) 3161{ 3162 ASYNC_DOMAIN_EXCLUSIVE(async_domain); 3163 int i; 3164 int ret = 0; 3165 3166 for (i = 0; i < num_consumers; i++) { 3167 if (consumers[i].consumer->always_on) 3168 consumers[i].ret = 0; 3169 else 3170 async_schedule_domain(regulator_bulk_enable_async, 3171 &consumers[i], &async_domain); 3172 } 3173 3174 async_synchronize_full_domain(&async_domain); 3175 3176 /* If any consumer failed we need to unwind any that succeeded */ 3177 for (i = 0; i < num_consumers; i++) { 3178 if (consumers[i].ret != 0) { 3179 ret = consumers[i].ret; 3180 goto err; 3181 } 3182 } 3183 3184 return 0; 3185 3186err: 3187 for (i = 0; i < num_consumers; i++) { 3188 if (consumers[i].ret < 0) 3189 pr_err("Failed to enable %s: %d\n", consumers[i].supply, 3190 consumers[i].ret); 3191 else 3192 regulator_disable(consumers[i].consumer); 3193 } 3194 3195 return ret; 3196} 3197EXPORT_SYMBOL_GPL(regulator_bulk_enable); 3198 3199/** 3200 * regulator_bulk_disable - disable multiple regulator consumers 3201 * 3202 * @num_consumers: Number of consumers 3203 * @consumers: Consumer data; clients are stored here. 3204 * @return 0 on success, an errno on failure 3205 * 3206 * This convenience API allows consumers to disable multiple regulator 3207 * clients in a single API call. If any consumers cannot be disabled 3208 * then any others that were disabled will be enabled again prior to 3209 * return. 3210 */ 3211int regulator_bulk_disable(int num_consumers, 3212 struct regulator_bulk_data *consumers) 3213{ 3214 int i; 3215 int ret, r; 3216 3217 for (i = num_consumers - 1; i >= 0; --i) { 3218 ret = regulator_disable(consumers[i].consumer); 3219 if (ret != 0) 3220 goto err; 3221 } 3222 3223 return 0; 3224 3225err: 3226 pr_err("Failed to disable %s: %d\n", consumers[i].supply, ret); 3227 for (++i; i < num_consumers; ++i) { 3228 r = regulator_enable(consumers[i].consumer); 3229 if (r != 0) 3230 pr_err("Failed to reename %s: %d\n", 3231 consumers[i].supply, r); 3232 } 3233 3234 return ret; 3235} 3236EXPORT_SYMBOL_GPL(regulator_bulk_disable); 3237 3238/** 3239 * regulator_bulk_force_disable - force disable multiple regulator consumers 3240 * 3241 * @num_consumers: Number of consumers 3242 * @consumers: Consumer data; clients are stored here. 3243 * @return 0 on success, an errno on failure 3244 * 3245 * This convenience API allows consumers to forcibly disable multiple regulator 3246 * clients in a single API call. 3247 * NOTE: This should be used for situations when device damage will 3248 * likely occur if the regulators are not disabled (e.g. over temp). 3249 * Although regulator_force_disable function call for some consumers can 3250 * return error numbers, the function is called for all consumers. 3251 */ 3252int regulator_bulk_force_disable(int num_consumers, 3253 struct regulator_bulk_data *consumers) 3254{ 3255 int i; 3256 int ret; 3257 3258 for (i = 0; i < num_consumers; i++) 3259 consumers[i].ret = 3260 regulator_force_disable(consumers[i].consumer); 3261 3262 for (i = 0; i < num_consumers; i++) { 3263 if (consumers[i].ret != 0) { 3264 ret = consumers[i].ret; 3265 goto out; 3266 } 3267 } 3268 3269 return 0; 3270out: 3271 return ret; 3272} 3273EXPORT_SYMBOL_GPL(regulator_bulk_force_disable); 3274 3275/** 3276 * regulator_bulk_free - free multiple regulator consumers 3277 * 3278 * @num_consumers: Number of consumers 3279 * @consumers: Consumer data; clients are stored here. 3280 * 3281 * This convenience API allows consumers to free multiple regulator 3282 * clients in a single API call. 3283 */ 3284void regulator_bulk_free(int num_consumers, 3285 struct regulator_bulk_data *consumers) 3286{ 3287 int i; 3288 3289 for (i = 0; i < num_consumers; i++) { 3290 regulator_put(consumers[i].consumer); 3291 consumers[i].consumer = NULL; 3292 } 3293} 3294EXPORT_SYMBOL_GPL(regulator_bulk_free); 3295 3296/** 3297 * regulator_notifier_call_chain - call regulator event notifier 3298 * @rdev: regulator source 3299 * @event: notifier block 3300 * @data: callback-specific data. 3301 * 3302 * Called by regulator drivers to notify clients a regulator event has 3303 * occurred. We also notify regulator clients downstream. 3304 * Note lock must be held by caller. 3305 */ 3306int regulator_notifier_call_chain(struct regulator_dev *rdev, 3307 unsigned long event, void *data) 3308{ 3309 _notifier_call_chain(rdev, event, data); 3310 return NOTIFY_DONE; 3311 3312} 3313EXPORT_SYMBOL_GPL(regulator_notifier_call_chain); 3314 3315/** 3316 * regulator_mode_to_status - convert a regulator mode into a status 3317 * 3318 * @mode: Mode to convert 3319 * 3320 * Convert a regulator mode into a status. 3321 */ 3322int regulator_mode_to_status(unsigned int mode) 3323{ 3324 switch (mode) { 3325 case REGULATOR_MODE_FAST: 3326 return REGULATOR_STATUS_FAST; 3327 case REGULATOR_MODE_NORMAL: 3328 return REGULATOR_STATUS_NORMAL; 3329 case REGULATOR_MODE_IDLE: 3330 return REGULATOR_STATUS_IDLE; 3331 case REGULATOR_MODE_STANDBY: 3332 return REGULATOR_STATUS_STANDBY; 3333 default: 3334 return REGULATOR_STATUS_UNDEFINED; 3335 } 3336} 3337EXPORT_SYMBOL_GPL(regulator_mode_to_status); 3338 3339/* 3340 * To avoid cluttering sysfs (and memory) with useless state, only 3341 * create attributes that can be meaningfully displayed. 3342 */ 3343static int add_regulator_attributes(struct regulator_dev *rdev) 3344{ 3345 struct device *dev = &rdev->dev; 3346 const struct regulator_ops *ops = rdev->desc->ops; 3347 int status = 0; 3348 3349 /* some attributes need specific methods to be displayed */ 3350 if ((ops->get_voltage && ops->get_voltage(rdev) >= 0) || 3351 (ops->get_voltage_sel && ops->get_voltage_sel(rdev) >= 0) || 3352 (ops->list_voltage && ops->list_voltage(rdev, 0) >= 0) || 3353 (rdev->desc->fixed_uV && (rdev->desc->n_voltages == 1))) { 3354 status = device_create_file(dev, &dev_attr_microvolts); 3355 if (status < 0) 3356 return status; 3357 } 3358 if (ops->get_current_limit) { 3359 status = device_create_file(dev, &dev_attr_microamps); 3360 if (status < 0) 3361 return status; 3362 } 3363 if (ops->get_mode) { 3364 status = device_create_file(dev, &dev_attr_opmode); 3365 if (status < 0) 3366 return status; 3367 } 3368 if (rdev->ena_pin || ops->is_enabled) { 3369 status = device_create_file(dev, &dev_attr_state); 3370 if (status < 0) 3371 return status; 3372 } 3373 if (ops->get_status) { 3374 status = device_create_file(dev, &dev_attr_status); 3375 if (status < 0) 3376 return status; 3377 } 3378 if (ops->get_bypass) { 3379 status = device_create_file(dev, &dev_attr_bypass); 3380 if (status < 0) 3381 return status; 3382 } 3383 3384 /* some attributes are type-specific */ 3385 if (rdev->desc->type == REGULATOR_CURRENT) { 3386 status = device_create_file(dev, &dev_attr_requested_microamps); 3387 if (status < 0) 3388 return status; 3389 } 3390 3391 /* all the other attributes exist to support constraints; 3392 * don't show them if there are no constraints, or if the 3393 * relevant supporting methods are missing. 3394 */ 3395 if (!rdev->constraints) 3396 return status; 3397 3398 /* constraints need specific supporting methods */ 3399 if (ops->set_voltage || ops->set_voltage_sel) { 3400 status = device_create_file(dev, &dev_attr_min_microvolts); 3401 if (status < 0) 3402 return status; 3403 status = device_create_file(dev, &dev_attr_max_microvolts); 3404 if (status < 0) 3405 return status; 3406 } 3407 if (ops->set_current_limit) { 3408 status = device_create_file(dev, &dev_attr_min_microamps); 3409 if (status < 0) 3410 return status; 3411 status = device_create_file(dev, &dev_attr_max_microamps); 3412 if (status < 0) 3413 return status; 3414 } 3415 3416 status = device_create_file(dev, &dev_attr_suspend_standby_state); 3417 if (status < 0) 3418 return status; 3419 status = device_create_file(dev, &dev_attr_suspend_mem_state); 3420 if (status < 0) 3421 return status; 3422 status = device_create_file(dev, &dev_attr_suspend_disk_state); 3423 if (status < 0) 3424 return status; 3425 3426 if (ops->set_suspend_voltage) { 3427 status = device_create_file(dev, 3428 &dev_attr_suspend_standby_microvolts); 3429 if (status < 0) 3430 return status; 3431 status = device_create_file(dev, 3432 &dev_attr_suspend_mem_microvolts); 3433 if (status < 0) 3434 return status; 3435 status = device_create_file(dev, 3436 &dev_attr_suspend_disk_microvolts); 3437 if (status < 0) 3438 return status; 3439 } 3440 3441 if (ops->set_suspend_mode) { 3442 status = device_create_file(dev, 3443 &dev_attr_suspend_standby_mode); 3444 if (status < 0) 3445 return status; 3446 status = device_create_file(dev, 3447 &dev_attr_suspend_mem_mode); 3448 if (status < 0) 3449 return status; 3450 status = device_create_file(dev, 3451 &dev_attr_suspend_disk_mode); 3452 if (status < 0) 3453 return status; 3454 } 3455 3456 return status; 3457} 3458 3459static void rdev_init_debugfs(struct regulator_dev *rdev) 3460{ 3461 rdev->debugfs = debugfs_create_dir(rdev_get_name(rdev), debugfs_root); 3462 if (!rdev->debugfs) { 3463 rdev_warn(rdev, "Failed to create debugfs directory\n"); 3464 return; 3465 } 3466 3467 debugfs_create_u32("use_count", 0444, rdev->debugfs, 3468 &rdev->use_count); 3469 debugfs_create_u32("open_count", 0444, rdev->debugfs, 3470 &rdev->open_count); 3471 debugfs_create_u32("bypass_count", 0444, rdev->debugfs, 3472 &rdev->bypass_count); 3473} 3474 3475/** 3476 * regulator_register - register regulator 3477 * @regulator_desc: regulator to register 3478 * @config: runtime configuration for regulator 3479 * 3480 * Called by regulator drivers to register a regulator. 3481 * Returns a valid pointer to struct regulator_dev on success 3482 * or an ERR_PTR() on error. 3483 */ 3484struct regulator_dev * 3485regulator_register(const struct regulator_desc *regulator_desc, 3486 const struct regulator_config *config) 3487{ 3488 const struct regulation_constraints *constraints = NULL; 3489 const struct regulator_init_data *init_data; 3490 static atomic_t regulator_no = ATOMIC_INIT(0); 3491 struct regulator_dev *rdev; 3492 struct device *dev; 3493 int ret, i; 3494 const char *supply = NULL; 3495 3496 if (regulator_desc == NULL || config == NULL) 3497 return ERR_PTR(-EINVAL); 3498 3499 dev = config->dev; 3500 WARN_ON(!dev); 3501 3502 if (regulator_desc->name == NULL || regulator_desc->ops == NULL) 3503 return ERR_PTR(-EINVAL); 3504 3505 if (regulator_desc->type != REGULATOR_VOLTAGE && 3506 regulator_desc->type != REGULATOR_CURRENT) 3507 return ERR_PTR(-EINVAL); 3508 3509 /* Only one of each should be implemented */ 3510 WARN_ON(regulator_desc->ops->get_voltage && 3511 regulator_desc->ops->get_voltage_sel); 3512 WARN_ON(regulator_desc->ops->set_voltage && 3513 regulator_desc->ops->set_voltage_sel); 3514 3515 /* If we're using selectors we must implement list_voltage. */ 3516 if (regulator_desc->ops->get_voltage_sel && 3517 !regulator_desc->ops->list_voltage) { 3518 return ERR_PTR(-EINVAL); 3519 } 3520 if (regulator_desc->ops->set_voltage_sel && 3521 !regulator_desc->ops->list_voltage) { 3522 return ERR_PTR(-EINVAL); 3523 } 3524 3525 init_data = config->init_data; 3526 3527 rdev = kzalloc(sizeof(struct regulator_dev), GFP_KERNEL); 3528 if (rdev == NULL) 3529 return ERR_PTR(-ENOMEM); 3530 3531 mutex_lock(®ulator_list_mutex); 3532 3533 mutex_init(&rdev->mutex); 3534 rdev->reg_data = config->driver_data; 3535 rdev->owner = regulator_desc->owner; 3536 rdev->desc = regulator_desc; 3537 if (config->regmap) 3538 rdev->regmap = config->regmap; 3539 else if (dev_get_regmap(dev, NULL)) 3540 rdev->regmap = dev_get_regmap(dev, NULL); 3541 else if (dev->parent) 3542 rdev->regmap = dev_get_regmap(dev->parent, NULL); 3543 INIT_LIST_HEAD(&rdev->consumer_list); 3544 INIT_LIST_HEAD(&rdev->list); 3545 BLOCKING_INIT_NOTIFIER_HEAD(&rdev->notifier); 3546 INIT_DELAYED_WORK(&rdev->disable_work, regulator_disable_work); 3547 3548 /* preform any regulator specific init */ 3549 if (init_data && init_data->regulator_init) { 3550 ret = init_data->regulator_init(rdev->reg_data); 3551 if (ret < 0) 3552 goto clean; 3553 } 3554 3555 /* register with sysfs */ 3556 rdev->dev.class = ®ulator_class; 3557 rdev->dev.of_node = of_node_get(config->of_node); 3558 rdev->dev.parent = dev; 3559 dev_set_name(&rdev->dev, "regulator.%d", 3560 atomic_inc_return(®ulator_no) - 1); 3561 ret = device_register(&rdev->dev); 3562 if (ret != 0) { 3563 put_device(&rdev->dev); 3564 goto clean; 3565 } 3566 3567 dev_set_drvdata(&rdev->dev, rdev); 3568 3569 if (config->ena_gpio && gpio_is_valid(config->ena_gpio)) { 3570 ret = regulator_ena_gpio_request(rdev, config); 3571 if (ret != 0) { 3572 rdev_err(rdev, "Failed to request enable GPIO%d: %d\n", 3573 config->ena_gpio, ret); 3574 goto wash; 3575 } 3576 3577 if (config->ena_gpio_flags & GPIOF_OUT_INIT_HIGH) 3578 rdev->ena_gpio_state = 1; 3579 3580 if (config->ena_gpio_invert) 3581 rdev->ena_gpio_state = !rdev->ena_gpio_state; 3582 } 3583 3584 /* set regulator constraints */ 3585 if (init_data) 3586 constraints = &init_data->constraints; 3587 3588 ret = set_machine_constraints(rdev, constraints); 3589 if (ret < 0) 3590 goto scrub; 3591 3592 /* add attributes supported by this regulator */ 3593 ret = add_regulator_attributes(rdev); 3594 if (ret < 0) 3595 goto scrub; 3596 3597 if (init_data && init_data->supply_regulator) 3598 supply = init_data->supply_regulator; 3599 else if (regulator_desc->supply_name) 3600 supply = regulator_desc->supply_name; 3601 3602 if (supply) { 3603 struct regulator_dev *r; 3604 3605 r = regulator_dev_lookup(dev, supply, &ret); 3606 3607 if (ret == -ENODEV) { 3608 /* 3609 * No supply was specified for this regulator and 3610 * there will never be one. 3611 */ 3612 ret = 0; 3613 goto add_dev; 3614 } else if (!r) { 3615 dev_err(dev, "Failed to find supply %s\n", supply); 3616 ret = -EPROBE_DEFER; 3617 goto scrub; 3618 } 3619 3620 ret = set_supply(rdev, r); 3621 if (ret < 0) 3622 goto scrub; 3623 3624 /* Enable supply if rail is enabled */ 3625 if (_regulator_is_enabled(rdev)) { 3626 ret = regulator_enable(rdev->supply); 3627 if (ret < 0) 3628 goto scrub; 3629 } 3630 } 3631 3632add_dev: 3633 /* add consumers devices */ 3634 if (init_data) { 3635 for (i = 0; i < init_data->num_consumer_supplies; i++) { 3636 ret = set_consumer_device_supply(rdev, 3637 init_data->consumer_supplies[i].dev_name, 3638 init_data->consumer_supplies[i].supply); 3639 if (ret < 0) { 3640 dev_err(dev, "Failed to set supply %s\n", 3641 init_data->consumer_supplies[i].supply); 3642 goto unset_supplies; 3643 } 3644 } 3645 } 3646 3647 list_add(&rdev->list, ®ulator_list); 3648 3649 rdev_init_debugfs(rdev); 3650out: 3651 mutex_unlock(®ulator_list_mutex); 3652 return rdev; 3653 3654unset_supplies: 3655 unset_regulator_supplies(rdev); 3656 3657scrub: 3658 if (rdev->supply) 3659 _regulator_put(rdev->supply); 3660 regulator_ena_gpio_free(rdev); 3661 kfree(rdev->constraints); 3662wash: 3663 device_unregister(&rdev->dev); 3664 /* device core frees rdev */ 3665 rdev = ERR_PTR(ret); 3666 goto out; 3667 3668clean: 3669 kfree(rdev); 3670 rdev = ERR_PTR(ret); 3671 goto out; 3672} 3673EXPORT_SYMBOL_GPL(regulator_register); 3674 3675/** 3676 * regulator_unregister - unregister regulator 3677 * @rdev: regulator to unregister 3678 * 3679 * Called by regulator drivers to unregister a regulator. 3680 */ 3681void regulator_unregister(struct regulator_dev *rdev) 3682{ 3683 if (rdev == NULL) 3684 return; 3685 3686 if (rdev->supply) { 3687 while (rdev->use_count--) 3688 regulator_disable(rdev->supply); 3689 regulator_put(rdev->supply); 3690 } 3691 mutex_lock(®ulator_list_mutex); 3692 debugfs_remove_recursive(rdev->debugfs); 3693 flush_work(&rdev->disable_work.work); 3694 WARN_ON(rdev->open_count); 3695 unset_regulator_supplies(rdev); 3696 list_del(&rdev->list); 3697 kfree(rdev->constraints); 3698 regulator_ena_gpio_free(rdev); 3699 of_node_put(rdev->dev.of_node); 3700 device_unregister(&rdev->dev); 3701 mutex_unlock(®ulator_list_mutex); 3702} 3703EXPORT_SYMBOL_GPL(regulator_unregister); 3704 3705/** 3706 * regulator_suspend_prepare - prepare regulators for system wide suspend 3707 * @state: system suspend state 3708 * 3709 * Configure each regulator with it's suspend operating parameters for state. 3710 * This will usually be called by machine suspend code prior to supending. 3711 */ 3712int regulator_suspend_prepare(suspend_state_t state) 3713{ 3714 struct regulator_dev *rdev; 3715 int ret = 0; 3716 3717 /* ON is handled by regulator active state */ 3718 if (state == PM_SUSPEND_ON) 3719 return -EINVAL; 3720 3721 mutex_lock(®ulator_list_mutex); 3722 list_for_each_entry(rdev, ®ulator_list, list) { 3723 3724 mutex_lock(&rdev->mutex); 3725 ret = suspend_prepare(rdev, state); 3726 mutex_unlock(&rdev->mutex); 3727 3728 if (ret < 0) { 3729 rdev_err(rdev, "failed to prepare\n"); 3730 goto out; 3731 } 3732 } 3733out: 3734 mutex_unlock(®ulator_list_mutex); 3735 return ret; 3736} 3737EXPORT_SYMBOL_GPL(regulator_suspend_prepare); 3738 3739/** 3740 * regulator_suspend_finish - resume regulators from system wide suspend 3741 * 3742 * Turn on regulators that might be turned off by regulator_suspend_prepare 3743 * and that should be turned on according to the regulators properties. 3744 */ 3745int regulator_suspend_finish(void) 3746{ 3747 struct regulator_dev *rdev; 3748 int ret = 0, error; 3749 3750 mutex_lock(®ulator_list_mutex); 3751 list_for_each_entry(rdev, ®ulator_list, list) { 3752 mutex_lock(&rdev->mutex); 3753 if (rdev->use_count > 0 || rdev->constraints->always_on) { 3754 error = _regulator_do_enable(rdev); 3755 if (error) 3756 ret = error; 3757 } else { 3758 if (!have_full_constraints()) 3759 goto unlock; 3760 if (!_regulator_is_enabled(rdev)) 3761 goto unlock; 3762 3763 error = _regulator_do_disable(rdev); 3764 if (error) 3765 ret = error; 3766 } 3767unlock: 3768 mutex_unlock(&rdev->mutex); 3769 } 3770 mutex_unlock(®ulator_list_mutex); 3771 return ret; 3772} 3773EXPORT_SYMBOL_GPL(regulator_suspend_finish); 3774 3775/** 3776 * regulator_has_full_constraints - the system has fully specified constraints 3777 * 3778 * Calling this function will cause the regulator API to disable all 3779 * regulators which have a zero use count and don't have an always_on 3780 * constraint in a late_initcall. 3781 * 3782 * The intention is that this will become the default behaviour in a 3783 * future kernel release so users are encouraged to use this facility 3784 * now. 3785 */ 3786void regulator_has_full_constraints(void) 3787{ 3788 has_full_constraints = 1; 3789} 3790EXPORT_SYMBOL_GPL(regulator_has_full_constraints); 3791 3792/** 3793 * rdev_get_drvdata - get rdev regulator driver data 3794 * @rdev: regulator 3795 * 3796 * Get rdev regulator driver private data. This call can be used in the 3797 * regulator driver context. 3798 */ 3799void *rdev_get_drvdata(struct regulator_dev *rdev) 3800{ 3801 return rdev->reg_data; 3802} 3803EXPORT_SYMBOL_GPL(rdev_get_drvdata); 3804 3805/** 3806 * regulator_get_drvdata - get regulator driver data 3807 * @regulator: regulator 3808 * 3809 * Get regulator driver private data. This call can be used in the consumer 3810 * driver context when non API regulator specific functions need to be called. 3811 */ 3812void *regulator_get_drvdata(struct regulator *regulator) 3813{ 3814 return regulator->rdev->reg_data; 3815} 3816EXPORT_SYMBOL_GPL(regulator_get_drvdata); 3817 3818/** 3819 * regulator_set_drvdata - set regulator driver data 3820 * @regulator: regulator 3821 * @data: data 3822 */ 3823void regulator_set_drvdata(struct regulator *regulator, void *data) 3824{ 3825 regulator->rdev->reg_data = data; 3826} 3827EXPORT_SYMBOL_GPL(regulator_set_drvdata); 3828 3829/** 3830 * regulator_get_id - get regulator ID 3831 * @rdev: regulator 3832 */ 3833int rdev_get_id(struct regulator_dev *rdev) 3834{ 3835 return rdev->desc->id; 3836} 3837EXPORT_SYMBOL_GPL(rdev_get_id); 3838 3839struct device *rdev_get_dev(struct regulator_dev *rdev) 3840{ 3841 return &rdev->dev; 3842} 3843EXPORT_SYMBOL_GPL(rdev_get_dev); 3844 3845void *regulator_get_init_drvdata(struct regulator_init_data *reg_init_data) 3846{ 3847 return reg_init_data->driver_data; 3848} 3849EXPORT_SYMBOL_GPL(regulator_get_init_drvdata); 3850 3851#ifdef CONFIG_DEBUG_FS 3852static ssize_t supply_map_read_file(struct file *file, char __user *user_buf, 3853 size_t count, loff_t *ppos) 3854{ 3855 char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL); 3856 ssize_t len, ret = 0; 3857 struct regulator_map *map; 3858 3859 if (!buf) 3860 return -ENOMEM; 3861 3862 list_for_each_entry(map, ®ulator_map_list, list) { 3863 len = snprintf(buf + ret, PAGE_SIZE - ret, 3864 "%s -> %s.%s\n", 3865 rdev_get_name(map->regulator), map->dev_name, 3866 map->supply); 3867 if (len >= 0) 3868 ret += len; 3869 if (ret > PAGE_SIZE) { 3870 ret = PAGE_SIZE; 3871 break; 3872 } 3873 } 3874 3875 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret); 3876 3877 kfree(buf); 3878 3879 return ret; 3880} 3881#endif 3882 3883static const struct file_operations supply_map_fops = { 3884#ifdef CONFIG_DEBUG_FS 3885 .read = supply_map_read_file, 3886 .llseek = default_llseek, 3887#endif 3888}; 3889 3890static int __init regulator_init(void) 3891{ 3892 int ret; 3893 3894 ret = class_register(®ulator_class); 3895 3896 debugfs_root = debugfs_create_dir("regulator", NULL); 3897 if (!debugfs_root) 3898 pr_warn("regulator: Failed to create debugfs directory\n"); 3899 3900 debugfs_create_file("supply_map", 0444, debugfs_root, NULL, 3901 &supply_map_fops); 3902 3903 regulator_dummy_init(); 3904 3905 return ret; 3906} 3907 3908/* init early to allow our consumers to complete system booting */ 3909core_initcall(regulator_init); 3910 3911static int __init regulator_init_complete(void) 3912{ 3913 struct regulator_dev *rdev; 3914 const struct regulator_ops *ops; 3915 struct regulation_constraints *c; 3916 int enabled, ret; 3917 3918 /* 3919 * Since DT doesn't provide an idiomatic mechanism for 3920 * enabling full constraints and since it's much more natural 3921 * with DT to provide them just assume that a DT enabled 3922 * system has full constraints. 3923 */ 3924 if (of_have_populated_dt()) 3925 has_full_constraints = true; 3926 3927 mutex_lock(®ulator_list_mutex); 3928 3929 /* If we have a full configuration then disable any regulators 3930 * we have permission to change the status for and which are 3931 * not in use or always_on. This is effectively the default 3932 * for DT and ACPI as they have full constraints. 3933 */ 3934 list_for_each_entry(rdev, ®ulator_list, list) { 3935 ops = rdev->desc->ops; 3936 c = rdev->constraints; 3937 3938 if (c && c->always_on) 3939 continue; 3940 3941 if (c && !(c->valid_ops_mask & REGULATOR_CHANGE_STATUS)) 3942 continue; 3943 3944 mutex_lock(&rdev->mutex); 3945 3946 if (rdev->use_count) 3947 goto unlock; 3948 3949 /* If we can't read the status assume it's on. */ 3950 if (ops->is_enabled) 3951 enabled = ops->is_enabled(rdev); 3952 else 3953 enabled = 1; 3954 3955 if (!enabled) 3956 goto unlock; 3957 3958 if (have_full_constraints()) { 3959 /* We log since this may kill the system if it 3960 * goes wrong. */ 3961 rdev_info(rdev, "disabling\n"); 3962 ret = _regulator_do_disable(rdev); 3963 if (ret != 0) 3964 rdev_err(rdev, "couldn't disable: %d\n", ret); 3965 } else { 3966 /* The intention is that in future we will 3967 * assume that full constraints are provided 3968 * so warn even if we aren't going to do 3969 * anything here. 3970 */ 3971 rdev_warn(rdev, "incomplete constraints, leaving on\n"); 3972 } 3973 3974unlock: 3975 mutex_unlock(&rdev->mutex); 3976 } 3977 3978 mutex_unlock(®ulator_list_mutex); 3979 3980 return 0; 3981} 3982late_initcall_sync(regulator_init_complete); 3983