core.c revision 39f5460d7f9cc57d3dd745301bf60ca5d65a6e7b
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->desc->off_on_delay) { 1817 /* if needed, keep a distance of off_on_delay from last time 1818 * this regulator was disabled. 1819 */ 1820 unsigned long start_jiffy = jiffies; 1821 unsigned long intended, max_delay, remaining; 1822 1823 max_delay = usecs_to_jiffies(rdev->desc->off_on_delay); 1824 intended = rdev->last_off_jiffy + max_delay; 1825 1826 if (time_before(start_jiffy, intended)) { 1827 /* calc remaining jiffies to deal with one-time 1828 * timer wrapping. 1829 * in case of multiple timer wrapping, either it can be 1830 * detected by out-of-range remaining, or it cannot be 1831 * detected and we gets a panelty of 1832 * _regulator_enable_delay(). 1833 */ 1834 remaining = intended - start_jiffy; 1835 if (remaining <= max_delay) 1836 _regulator_enable_delay( 1837 jiffies_to_usecs(remaining)); 1838 } 1839 } 1840 1841 if (rdev->ena_pin) { 1842 ret = regulator_ena_gpio_ctrl(rdev, true); 1843 if (ret < 0) 1844 return ret; 1845 rdev->ena_gpio_state = 1; 1846 } else if (rdev->desc->ops->enable) { 1847 ret = rdev->desc->ops->enable(rdev); 1848 if (ret < 0) 1849 return ret; 1850 } else { 1851 return -EINVAL; 1852 } 1853 1854 /* Allow the regulator to ramp; it would be useful to extend 1855 * this for bulk operations so that the regulators can ramp 1856 * together. */ 1857 trace_regulator_enable_delay(rdev_get_name(rdev)); 1858 1859 _regulator_enable_delay(delay); 1860 1861 trace_regulator_enable_complete(rdev_get_name(rdev)); 1862 1863 return 0; 1864} 1865 1866/* locks held by regulator_enable() */ 1867static int _regulator_enable(struct regulator_dev *rdev) 1868{ 1869 int ret; 1870 1871 /* check voltage and requested load before enabling */ 1872 if (rdev->constraints && 1873 (rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_DRMS)) 1874 drms_uA_update(rdev); 1875 1876 if (rdev->use_count == 0) { 1877 /* The regulator may on if it's not switchable or left on */ 1878 ret = _regulator_is_enabled(rdev); 1879 if (ret == -EINVAL || ret == 0) { 1880 if (!_regulator_can_change_status(rdev)) 1881 return -EPERM; 1882 1883 ret = _regulator_do_enable(rdev); 1884 if (ret < 0) 1885 return ret; 1886 1887 } else if (ret < 0) { 1888 rdev_err(rdev, "is_enabled() failed: %d\n", ret); 1889 return ret; 1890 } 1891 /* Fallthrough on positive return values - already enabled */ 1892 } 1893 1894 rdev->use_count++; 1895 1896 return 0; 1897} 1898 1899/** 1900 * regulator_enable - enable regulator output 1901 * @regulator: regulator source 1902 * 1903 * Request that the regulator be enabled with the regulator output at 1904 * the predefined voltage or current value. Calls to regulator_enable() 1905 * must be balanced with calls to regulator_disable(). 1906 * 1907 * NOTE: the output value can be set by other drivers, boot loader or may be 1908 * hardwired in the regulator. 1909 */ 1910int regulator_enable(struct regulator *regulator) 1911{ 1912 struct regulator_dev *rdev = regulator->rdev; 1913 int ret = 0; 1914 1915 if (regulator->always_on) 1916 return 0; 1917 1918 if (rdev->supply) { 1919 ret = regulator_enable(rdev->supply); 1920 if (ret != 0) 1921 return ret; 1922 } 1923 1924 mutex_lock(&rdev->mutex); 1925 ret = _regulator_enable(rdev); 1926 mutex_unlock(&rdev->mutex); 1927 1928 if (ret != 0 && rdev->supply) 1929 regulator_disable(rdev->supply); 1930 1931 return ret; 1932} 1933EXPORT_SYMBOL_GPL(regulator_enable); 1934 1935static int _regulator_do_disable(struct regulator_dev *rdev) 1936{ 1937 int ret; 1938 1939 trace_regulator_disable(rdev_get_name(rdev)); 1940 1941 if (rdev->ena_pin) { 1942 ret = regulator_ena_gpio_ctrl(rdev, false); 1943 if (ret < 0) 1944 return ret; 1945 rdev->ena_gpio_state = 0; 1946 1947 } else if (rdev->desc->ops->disable) { 1948 ret = rdev->desc->ops->disable(rdev); 1949 if (ret != 0) 1950 return ret; 1951 } 1952 1953 /* cares about last_off_jiffy only if off_on_delay is required by 1954 * device. 1955 */ 1956 if (rdev->desc->off_on_delay) 1957 rdev->last_off_jiffy = jiffies; 1958 1959 trace_regulator_disable_complete(rdev_get_name(rdev)); 1960 1961 return 0; 1962} 1963 1964/* locks held by regulator_disable() */ 1965static int _regulator_disable(struct regulator_dev *rdev) 1966{ 1967 int ret = 0; 1968 1969 if (WARN(rdev->use_count <= 0, 1970 "unbalanced disables for %s\n", rdev_get_name(rdev))) 1971 return -EIO; 1972 1973 /* are we the last user and permitted to disable ? */ 1974 if (rdev->use_count == 1 && 1975 (rdev->constraints && !rdev->constraints->always_on)) { 1976 1977 /* we are last user */ 1978 if (_regulator_can_change_status(rdev)) { 1979 ret = _regulator_do_disable(rdev); 1980 if (ret < 0) { 1981 rdev_err(rdev, "failed to disable\n"); 1982 return ret; 1983 } 1984 _notifier_call_chain(rdev, REGULATOR_EVENT_DISABLE, 1985 NULL); 1986 } 1987 1988 rdev->use_count = 0; 1989 } else if (rdev->use_count > 1) { 1990 1991 if (rdev->constraints && 1992 (rdev->constraints->valid_ops_mask & 1993 REGULATOR_CHANGE_DRMS)) 1994 drms_uA_update(rdev); 1995 1996 rdev->use_count--; 1997 } 1998 1999 return ret; 2000} 2001 2002/** 2003 * regulator_disable - disable regulator output 2004 * @regulator: regulator source 2005 * 2006 * Disable the regulator output voltage or current. Calls to 2007 * regulator_enable() must be balanced with calls to 2008 * regulator_disable(). 2009 * 2010 * NOTE: this will only disable the regulator output if no other consumer 2011 * devices have it enabled, the regulator device supports disabling and 2012 * machine constraints permit this operation. 2013 */ 2014int regulator_disable(struct regulator *regulator) 2015{ 2016 struct regulator_dev *rdev = regulator->rdev; 2017 int ret = 0; 2018 2019 if (regulator->always_on) 2020 return 0; 2021 2022 mutex_lock(&rdev->mutex); 2023 ret = _regulator_disable(rdev); 2024 mutex_unlock(&rdev->mutex); 2025 2026 if (ret == 0 && rdev->supply) 2027 regulator_disable(rdev->supply); 2028 2029 return ret; 2030} 2031EXPORT_SYMBOL_GPL(regulator_disable); 2032 2033/* locks held by regulator_force_disable() */ 2034static int _regulator_force_disable(struct regulator_dev *rdev) 2035{ 2036 int ret = 0; 2037 2038 ret = _regulator_do_disable(rdev); 2039 if (ret < 0) { 2040 rdev_err(rdev, "failed to force disable\n"); 2041 return ret; 2042 } 2043 2044 _notifier_call_chain(rdev, REGULATOR_EVENT_FORCE_DISABLE | 2045 REGULATOR_EVENT_DISABLE, NULL); 2046 2047 return 0; 2048} 2049 2050/** 2051 * regulator_force_disable - force disable regulator output 2052 * @regulator: regulator source 2053 * 2054 * Forcibly disable the regulator output voltage or current. 2055 * NOTE: this *will* disable the regulator output even if other consumer 2056 * devices have it enabled. This should be used for situations when device 2057 * damage will likely occur if the regulator is not disabled (e.g. over temp). 2058 */ 2059int regulator_force_disable(struct regulator *regulator) 2060{ 2061 struct regulator_dev *rdev = regulator->rdev; 2062 int ret; 2063 2064 mutex_lock(&rdev->mutex); 2065 regulator->uA_load = 0; 2066 ret = _regulator_force_disable(regulator->rdev); 2067 mutex_unlock(&rdev->mutex); 2068 2069 if (rdev->supply) 2070 while (rdev->open_count--) 2071 regulator_disable(rdev->supply); 2072 2073 return ret; 2074} 2075EXPORT_SYMBOL_GPL(regulator_force_disable); 2076 2077static void regulator_disable_work(struct work_struct *work) 2078{ 2079 struct regulator_dev *rdev = container_of(work, struct regulator_dev, 2080 disable_work.work); 2081 int count, i, ret; 2082 2083 mutex_lock(&rdev->mutex); 2084 2085 BUG_ON(!rdev->deferred_disables); 2086 2087 count = rdev->deferred_disables; 2088 rdev->deferred_disables = 0; 2089 2090 for (i = 0; i < count; i++) { 2091 ret = _regulator_disable(rdev); 2092 if (ret != 0) 2093 rdev_err(rdev, "Deferred disable failed: %d\n", ret); 2094 } 2095 2096 mutex_unlock(&rdev->mutex); 2097 2098 if (rdev->supply) { 2099 for (i = 0; i < count; i++) { 2100 ret = regulator_disable(rdev->supply); 2101 if (ret != 0) { 2102 rdev_err(rdev, 2103 "Supply disable failed: %d\n", ret); 2104 } 2105 } 2106 } 2107} 2108 2109/** 2110 * regulator_disable_deferred - disable regulator output with delay 2111 * @regulator: regulator source 2112 * @ms: miliseconds until the regulator is disabled 2113 * 2114 * Execute regulator_disable() on the regulator after a delay. This 2115 * is intended for use with devices that require some time to quiesce. 2116 * 2117 * NOTE: this will only disable the regulator output if no other consumer 2118 * devices have it enabled, the regulator device supports disabling and 2119 * machine constraints permit this operation. 2120 */ 2121int regulator_disable_deferred(struct regulator *regulator, int ms) 2122{ 2123 struct regulator_dev *rdev = regulator->rdev; 2124 int ret; 2125 2126 if (regulator->always_on) 2127 return 0; 2128 2129 if (!ms) 2130 return regulator_disable(regulator); 2131 2132 mutex_lock(&rdev->mutex); 2133 rdev->deferred_disables++; 2134 mutex_unlock(&rdev->mutex); 2135 2136 ret = queue_delayed_work(system_power_efficient_wq, 2137 &rdev->disable_work, 2138 msecs_to_jiffies(ms)); 2139 if (ret < 0) 2140 return ret; 2141 else 2142 return 0; 2143} 2144EXPORT_SYMBOL_GPL(regulator_disable_deferred); 2145 2146static int _regulator_is_enabled(struct regulator_dev *rdev) 2147{ 2148 /* A GPIO control always takes precedence */ 2149 if (rdev->ena_pin) 2150 return rdev->ena_gpio_state; 2151 2152 /* If we don't know then assume that the regulator is always on */ 2153 if (!rdev->desc->ops->is_enabled) 2154 return 1; 2155 2156 return rdev->desc->ops->is_enabled(rdev); 2157} 2158 2159/** 2160 * regulator_is_enabled - is the regulator output enabled 2161 * @regulator: regulator source 2162 * 2163 * Returns positive if the regulator driver backing the source/client 2164 * has requested that the device be enabled, zero if it hasn't, else a 2165 * negative errno code. 2166 * 2167 * Note that the device backing this regulator handle can have multiple 2168 * users, so it might be enabled even if regulator_enable() was never 2169 * called for this particular source. 2170 */ 2171int regulator_is_enabled(struct regulator *regulator) 2172{ 2173 int ret; 2174 2175 if (regulator->always_on) 2176 return 1; 2177 2178 mutex_lock(®ulator->rdev->mutex); 2179 ret = _regulator_is_enabled(regulator->rdev); 2180 mutex_unlock(®ulator->rdev->mutex); 2181 2182 return ret; 2183} 2184EXPORT_SYMBOL_GPL(regulator_is_enabled); 2185 2186/** 2187 * regulator_can_change_voltage - check if regulator can change voltage 2188 * @regulator: regulator source 2189 * 2190 * Returns positive if the regulator driver backing the source/client 2191 * can change its voltage, false otherwise. Useful for detecting fixed 2192 * or dummy regulators and disabling voltage change logic in the client 2193 * driver. 2194 */ 2195int regulator_can_change_voltage(struct regulator *regulator) 2196{ 2197 struct regulator_dev *rdev = regulator->rdev; 2198 2199 if (rdev->constraints && 2200 (rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_VOLTAGE)) { 2201 if (rdev->desc->n_voltages - rdev->desc->linear_min_sel > 1) 2202 return 1; 2203 2204 if (rdev->desc->continuous_voltage_range && 2205 rdev->constraints->min_uV && rdev->constraints->max_uV && 2206 rdev->constraints->min_uV != rdev->constraints->max_uV) 2207 return 1; 2208 } 2209 2210 return 0; 2211} 2212EXPORT_SYMBOL_GPL(regulator_can_change_voltage); 2213 2214/** 2215 * regulator_count_voltages - count regulator_list_voltage() selectors 2216 * @regulator: regulator source 2217 * 2218 * Returns number of selectors, or negative errno. Selectors are 2219 * numbered starting at zero, and typically correspond to bitfields 2220 * in hardware registers. 2221 */ 2222int regulator_count_voltages(struct regulator *regulator) 2223{ 2224 struct regulator_dev *rdev = regulator->rdev; 2225 2226 if (rdev->desc->n_voltages) 2227 return rdev->desc->n_voltages; 2228 2229 if (!rdev->supply) 2230 return -EINVAL; 2231 2232 return regulator_count_voltages(rdev->supply); 2233} 2234EXPORT_SYMBOL_GPL(regulator_count_voltages); 2235 2236/** 2237 * regulator_list_voltage - enumerate supported voltages 2238 * @regulator: regulator source 2239 * @selector: identify voltage to list 2240 * Context: can sleep 2241 * 2242 * Returns a voltage that can be passed to @regulator_set_voltage(), 2243 * zero if this selector code can't be used on this system, or a 2244 * negative errno. 2245 */ 2246int regulator_list_voltage(struct regulator *regulator, unsigned selector) 2247{ 2248 struct regulator_dev *rdev = regulator->rdev; 2249 const struct regulator_ops *ops = rdev->desc->ops; 2250 int ret; 2251 2252 if (rdev->desc->fixed_uV && rdev->desc->n_voltages == 1 && !selector) 2253 return rdev->desc->fixed_uV; 2254 2255 if (ops->list_voltage) { 2256 if (selector >= rdev->desc->n_voltages) 2257 return -EINVAL; 2258 mutex_lock(&rdev->mutex); 2259 ret = ops->list_voltage(rdev, selector); 2260 mutex_unlock(&rdev->mutex); 2261 } else if (rdev->supply) { 2262 ret = regulator_list_voltage(rdev->supply, selector); 2263 } else { 2264 return -EINVAL; 2265 } 2266 2267 if (ret > 0) { 2268 if (ret < rdev->constraints->min_uV) 2269 ret = 0; 2270 else if (ret > rdev->constraints->max_uV) 2271 ret = 0; 2272 } 2273 2274 return ret; 2275} 2276EXPORT_SYMBOL_GPL(regulator_list_voltage); 2277 2278/** 2279 * regulator_get_regmap - get the regulator's register map 2280 * @regulator: regulator source 2281 * 2282 * Returns the register map for the given regulator, or an ERR_PTR value 2283 * if the regulator doesn't use regmap. 2284 */ 2285struct regmap *regulator_get_regmap(struct regulator *regulator) 2286{ 2287 struct regmap *map = regulator->rdev->regmap; 2288 2289 return map ? map : ERR_PTR(-EOPNOTSUPP); 2290} 2291 2292/** 2293 * regulator_get_hardware_vsel_register - get the HW voltage selector register 2294 * @regulator: regulator source 2295 * @vsel_reg: voltage selector register, output parameter 2296 * @vsel_mask: mask for voltage selector bitfield, output parameter 2297 * 2298 * Returns the hardware register offset and bitmask used for setting the 2299 * regulator voltage. This might be useful when configuring voltage-scaling 2300 * hardware or firmware that can make I2C requests behind the kernel's back, 2301 * for example. 2302 * 2303 * On success, the output parameters @vsel_reg and @vsel_mask are filled in 2304 * and 0 is returned, otherwise a negative errno is returned. 2305 */ 2306int regulator_get_hardware_vsel_register(struct regulator *regulator, 2307 unsigned *vsel_reg, 2308 unsigned *vsel_mask) 2309{ 2310 struct regulator_dev *rdev = regulator->rdev; 2311 const struct regulator_ops *ops = rdev->desc->ops; 2312 2313 if (ops->set_voltage_sel != regulator_set_voltage_sel_regmap) 2314 return -EOPNOTSUPP; 2315 2316 *vsel_reg = rdev->desc->vsel_reg; 2317 *vsel_mask = rdev->desc->vsel_mask; 2318 2319 return 0; 2320} 2321EXPORT_SYMBOL_GPL(regulator_get_hardware_vsel_register); 2322 2323/** 2324 * regulator_list_hardware_vsel - get the HW-specific register value for a selector 2325 * @regulator: regulator source 2326 * @selector: identify voltage to list 2327 * 2328 * Converts the selector to a hardware-specific voltage selector that can be 2329 * directly written to the regulator registers. The address of the voltage 2330 * register can be determined by calling @regulator_get_hardware_vsel_register. 2331 * 2332 * On error a negative errno is returned. 2333 */ 2334int regulator_list_hardware_vsel(struct regulator *regulator, 2335 unsigned selector) 2336{ 2337 struct regulator_dev *rdev = regulator->rdev; 2338 const struct regulator_ops *ops = rdev->desc->ops; 2339 2340 if (selector >= rdev->desc->n_voltages) 2341 return -EINVAL; 2342 if (ops->set_voltage_sel != regulator_set_voltage_sel_regmap) 2343 return -EOPNOTSUPP; 2344 2345 return selector; 2346} 2347EXPORT_SYMBOL_GPL(regulator_list_hardware_vsel); 2348 2349/** 2350 * regulator_get_linear_step - return the voltage step size between VSEL values 2351 * @regulator: regulator source 2352 * 2353 * Returns the voltage step size between VSEL values for linear 2354 * regulators, or return 0 if the regulator isn't a linear regulator. 2355 */ 2356unsigned int regulator_get_linear_step(struct regulator *regulator) 2357{ 2358 struct regulator_dev *rdev = regulator->rdev; 2359 2360 return rdev->desc->uV_step; 2361} 2362EXPORT_SYMBOL_GPL(regulator_get_linear_step); 2363 2364/** 2365 * regulator_is_supported_voltage - check if a voltage range can be supported 2366 * 2367 * @regulator: Regulator to check. 2368 * @min_uV: Minimum required voltage in uV. 2369 * @max_uV: Maximum required voltage in uV. 2370 * 2371 * Returns a boolean or a negative error code. 2372 */ 2373int regulator_is_supported_voltage(struct regulator *regulator, 2374 int min_uV, int max_uV) 2375{ 2376 struct regulator_dev *rdev = regulator->rdev; 2377 int i, voltages, ret; 2378 2379 /* If we can't change voltage check the current voltage */ 2380 if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_VOLTAGE)) { 2381 ret = regulator_get_voltage(regulator); 2382 if (ret >= 0) 2383 return min_uV <= ret && ret <= max_uV; 2384 else 2385 return ret; 2386 } 2387 2388 /* Any voltage within constrains range is fine? */ 2389 if (rdev->desc->continuous_voltage_range) 2390 return min_uV >= rdev->constraints->min_uV && 2391 max_uV <= rdev->constraints->max_uV; 2392 2393 ret = regulator_count_voltages(regulator); 2394 if (ret < 0) 2395 return ret; 2396 voltages = ret; 2397 2398 for (i = 0; i < voltages; i++) { 2399 ret = regulator_list_voltage(regulator, i); 2400 2401 if (ret >= min_uV && ret <= max_uV) 2402 return 1; 2403 } 2404 2405 return 0; 2406} 2407EXPORT_SYMBOL_GPL(regulator_is_supported_voltage); 2408 2409static int _regulator_do_set_voltage(struct regulator_dev *rdev, 2410 int min_uV, int max_uV) 2411{ 2412 int ret; 2413 int delay = 0; 2414 int best_val = 0; 2415 unsigned int selector; 2416 int old_selector = -1; 2417 2418 trace_regulator_set_voltage(rdev_get_name(rdev), min_uV, max_uV); 2419 2420 min_uV += rdev->constraints->uV_offset; 2421 max_uV += rdev->constraints->uV_offset; 2422 2423 /* 2424 * If we can't obtain the old selector there is not enough 2425 * info to call set_voltage_time_sel(). 2426 */ 2427 if (_regulator_is_enabled(rdev) && 2428 rdev->desc->ops->set_voltage_time_sel && 2429 rdev->desc->ops->get_voltage_sel) { 2430 old_selector = rdev->desc->ops->get_voltage_sel(rdev); 2431 if (old_selector < 0) 2432 return old_selector; 2433 } 2434 2435 if (rdev->desc->ops->set_voltage) { 2436 ret = rdev->desc->ops->set_voltage(rdev, min_uV, max_uV, 2437 &selector); 2438 2439 if (ret >= 0) { 2440 if (rdev->desc->ops->list_voltage) 2441 best_val = rdev->desc->ops->list_voltage(rdev, 2442 selector); 2443 else 2444 best_val = _regulator_get_voltage(rdev); 2445 } 2446 2447 } else if (rdev->desc->ops->set_voltage_sel) { 2448 if (rdev->desc->ops->map_voltage) { 2449 ret = rdev->desc->ops->map_voltage(rdev, min_uV, 2450 max_uV); 2451 } else { 2452 if (rdev->desc->ops->list_voltage == 2453 regulator_list_voltage_linear) 2454 ret = regulator_map_voltage_linear(rdev, 2455 min_uV, max_uV); 2456 else if (rdev->desc->ops->list_voltage == 2457 regulator_list_voltage_linear_range) 2458 ret = regulator_map_voltage_linear_range(rdev, 2459 min_uV, max_uV); 2460 else 2461 ret = regulator_map_voltage_iterate(rdev, 2462 min_uV, max_uV); 2463 } 2464 2465 if (ret >= 0) { 2466 best_val = rdev->desc->ops->list_voltage(rdev, ret); 2467 if (min_uV <= best_val && max_uV >= best_val) { 2468 selector = ret; 2469 if (old_selector == selector) 2470 ret = 0; 2471 else 2472 ret = rdev->desc->ops->set_voltage_sel( 2473 rdev, ret); 2474 } else { 2475 ret = -EINVAL; 2476 } 2477 } 2478 } else { 2479 ret = -EINVAL; 2480 } 2481 2482 /* Call set_voltage_time_sel if successfully obtained old_selector */ 2483 if (ret == 0 && !rdev->constraints->ramp_disable && old_selector >= 0 2484 && old_selector != selector) { 2485 2486 delay = rdev->desc->ops->set_voltage_time_sel(rdev, 2487 old_selector, selector); 2488 if (delay < 0) { 2489 rdev_warn(rdev, "set_voltage_time_sel() failed: %d\n", 2490 delay); 2491 delay = 0; 2492 } 2493 2494 /* Insert any necessary delays */ 2495 if (delay >= 1000) { 2496 mdelay(delay / 1000); 2497 udelay(delay % 1000); 2498 } else if (delay) { 2499 udelay(delay); 2500 } 2501 } 2502 2503 if (ret == 0 && best_val >= 0) { 2504 unsigned long data = best_val; 2505 2506 _notifier_call_chain(rdev, REGULATOR_EVENT_VOLTAGE_CHANGE, 2507 (void *)data); 2508 } 2509 2510 trace_regulator_set_voltage_complete(rdev_get_name(rdev), best_val); 2511 2512 return ret; 2513} 2514 2515/** 2516 * regulator_set_voltage - set regulator output voltage 2517 * @regulator: regulator source 2518 * @min_uV: Minimum required voltage in uV 2519 * @max_uV: Maximum acceptable voltage in uV 2520 * 2521 * Sets a voltage regulator to the desired output voltage. This can be set 2522 * during any regulator state. IOW, regulator can be disabled or enabled. 2523 * 2524 * If the regulator is enabled then the voltage will change to the new value 2525 * immediately otherwise if the regulator is disabled the regulator will 2526 * output at the new voltage when enabled. 2527 * 2528 * NOTE: If the regulator is shared between several devices then the lowest 2529 * request voltage that meets the system constraints will be used. 2530 * Regulator system constraints must be set for this regulator before 2531 * calling this function otherwise this call will fail. 2532 */ 2533int regulator_set_voltage(struct regulator *regulator, int min_uV, int max_uV) 2534{ 2535 struct regulator_dev *rdev = regulator->rdev; 2536 int ret = 0; 2537 int old_min_uV, old_max_uV; 2538 int current_uV; 2539 2540 mutex_lock(&rdev->mutex); 2541 2542 /* If we're setting the same range as last time the change 2543 * should be a noop (some cpufreq implementations use the same 2544 * voltage for multiple frequencies, for example). 2545 */ 2546 if (regulator->min_uV == min_uV && regulator->max_uV == max_uV) 2547 goto out; 2548 2549 /* If we're trying to set a range that overlaps the current voltage, 2550 * return succesfully even though the regulator does not support 2551 * changing the voltage. 2552 */ 2553 if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_VOLTAGE)) { 2554 current_uV = _regulator_get_voltage(rdev); 2555 if (min_uV <= current_uV && current_uV <= max_uV) { 2556 regulator->min_uV = min_uV; 2557 regulator->max_uV = max_uV; 2558 goto out; 2559 } 2560 } 2561 2562 /* sanity check */ 2563 if (!rdev->desc->ops->set_voltage && 2564 !rdev->desc->ops->set_voltage_sel) { 2565 ret = -EINVAL; 2566 goto out; 2567 } 2568 2569 /* constraints check */ 2570 ret = regulator_check_voltage(rdev, &min_uV, &max_uV); 2571 if (ret < 0) 2572 goto out; 2573 2574 /* restore original values in case of error */ 2575 old_min_uV = regulator->min_uV; 2576 old_max_uV = regulator->max_uV; 2577 regulator->min_uV = min_uV; 2578 regulator->max_uV = max_uV; 2579 2580 ret = regulator_check_consumers(rdev, &min_uV, &max_uV); 2581 if (ret < 0) 2582 goto out2; 2583 2584 ret = _regulator_do_set_voltage(rdev, min_uV, max_uV); 2585 if (ret < 0) 2586 goto out2; 2587 2588out: 2589 mutex_unlock(&rdev->mutex); 2590 return ret; 2591out2: 2592 regulator->min_uV = old_min_uV; 2593 regulator->max_uV = old_max_uV; 2594 mutex_unlock(&rdev->mutex); 2595 return ret; 2596} 2597EXPORT_SYMBOL_GPL(regulator_set_voltage); 2598 2599/** 2600 * regulator_set_voltage_time - get raise/fall time 2601 * @regulator: regulator source 2602 * @old_uV: starting voltage in microvolts 2603 * @new_uV: target voltage in microvolts 2604 * 2605 * Provided with the starting and ending voltage, this function attempts to 2606 * calculate the time in microseconds required to rise or fall to this new 2607 * voltage. 2608 */ 2609int regulator_set_voltage_time(struct regulator *regulator, 2610 int old_uV, int new_uV) 2611{ 2612 struct regulator_dev *rdev = regulator->rdev; 2613 const struct regulator_ops *ops = rdev->desc->ops; 2614 int old_sel = -1; 2615 int new_sel = -1; 2616 int voltage; 2617 int i; 2618 2619 /* Currently requires operations to do this */ 2620 if (!ops->list_voltage || !ops->set_voltage_time_sel 2621 || !rdev->desc->n_voltages) 2622 return -EINVAL; 2623 2624 for (i = 0; i < rdev->desc->n_voltages; i++) { 2625 /* We only look for exact voltage matches here */ 2626 voltage = regulator_list_voltage(regulator, i); 2627 if (voltage < 0) 2628 return -EINVAL; 2629 if (voltage == 0) 2630 continue; 2631 if (voltage == old_uV) 2632 old_sel = i; 2633 if (voltage == new_uV) 2634 new_sel = i; 2635 } 2636 2637 if (old_sel < 0 || new_sel < 0) 2638 return -EINVAL; 2639 2640 return ops->set_voltage_time_sel(rdev, old_sel, new_sel); 2641} 2642EXPORT_SYMBOL_GPL(regulator_set_voltage_time); 2643 2644/** 2645 * regulator_set_voltage_time_sel - get raise/fall time 2646 * @rdev: regulator source device 2647 * @old_selector: selector for starting voltage 2648 * @new_selector: selector for target voltage 2649 * 2650 * Provided with the starting and target voltage selectors, this function 2651 * returns time in microseconds required to rise or fall to this new voltage 2652 * 2653 * Drivers providing ramp_delay in regulation_constraints can use this as their 2654 * set_voltage_time_sel() operation. 2655 */ 2656int regulator_set_voltage_time_sel(struct regulator_dev *rdev, 2657 unsigned int old_selector, 2658 unsigned int new_selector) 2659{ 2660 unsigned int ramp_delay = 0; 2661 int old_volt, new_volt; 2662 2663 if (rdev->constraints->ramp_delay) 2664 ramp_delay = rdev->constraints->ramp_delay; 2665 else if (rdev->desc->ramp_delay) 2666 ramp_delay = rdev->desc->ramp_delay; 2667 2668 if (ramp_delay == 0) { 2669 rdev_warn(rdev, "ramp_delay not set\n"); 2670 return 0; 2671 } 2672 2673 /* sanity check */ 2674 if (!rdev->desc->ops->list_voltage) 2675 return -EINVAL; 2676 2677 old_volt = rdev->desc->ops->list_voltage(rdev, old_selector); 2678 new_volt = rdev->desc->ops->list_voltage(rdev, new_selector); 2679 2680 return DIV_ROUND_UP(abs(new_volt - old_volt), ramp_delay); 2681} 2682EXPORT_SYMBOL_GPL(regulator_set_voltage_time_sel); 2683 2684/** 2685 * regulator_sync_voltage - re-apply last regulator output voltage 2686 * @regulator: regulator source 2687 * 2688 * Re-apply the last configured voltage. This is intended to be used 2689 * where some external control source the consumer is cooperating with 2690 * has caused the configured voltage to change. 2691 */ 2692int regulator_sync_voltage(struct regulator *regulator) 2693{ 2694 struct regulator_dev *rdev = regulator->rdev; 2695 int ret, min_uV, max_uV; 2696 2697 mutex_lock(&rdev->mutex); 2698 2699 if (!rdev->desc->ops->set_voltage && 2700 !rdev->desc->ops->set_voltage_sel) { 2701 ret = -EINVAL; 2702 goto out; 2703 } 2704 2705 /* This is only going to work if we've had a voltage configured. */ 2706 if (!regulator->min_uV && !regulator->max_uV) { 2707 ret = -EINVAL; 2708 goto out; 2709 } 2710 2711 min_uV = regulator->min_uV; 2712 max_uV = regulator->max_uV; 2713 2714 /* This should be a paranoia check... */ 2715 ret = regulator_check_voltage(rdev, &min_uV, &max_uV); 2716 if (ret < 0) 2717 goto out; 2718 2719 ret = regulator_check_consumers(rdev, &min_uV, &max_uV); 2720 if (ret < 0) 2721 goto out; 2722 2723 ret = _regulator_do_set_voltage(rdev, min_uV, max_uV); 2724 2725out: 2726 mutex_unlock(&rdev->mutex); 2727 return ret; 2728} 2729EXPORT_SYMBOL_GPL(regulator_sync_voltage); 2730 2731static int _regulator_get_voltage(struct regulator_dev *rdev) 2732{ 2733 int sel, ret; 2734 2735 if (rdev->desc->ops->get_voltage_sel) { 2736 sel = rdev->desc->ops->get_voltage_sel(rdev); 2737 if (sel < 0) 2738 return sel; 2739 ret = rdev->desc->ops->list_voltage(rdev, sel); 2740 } else if (rdev->desc->ops->get_voltage) { 2741 ret = rdev->desc->ops->get_voltage(rdev); 2742 } else if (rdev->desc->ops->list_voltage) { 2743 ret = rdev->desc->ops->list_voltage(rdev, 0); 2744 } else if (rdev->desc->fixed_uV && (rdev->desc->n_voltages == 1)) { 2745 ret = rdev->desc->fixed_uV; 2746 } else if (rdev->supply) { 2747 ret = regulator_get_voltage(rdev->supply); 2748 } else { 2749 return -EINVAL; 2750 } 2751 2752 if (ret < 0) 2753 return ret; 2754 return ret - rdev->constraints->uV_offset; 2755} 2756 2757/** 2758 * regulator_get_voltage - get regulator output voltage 2759 * @regulator: regulator source 2760 * 2761 * This returns the current regulator voltage in uV. 2762 * 2763 * NOTE: If the regulator is disabled it will return the voltage value. This 2764 * function should not be used to determine regulator state. 2765 */ 2766int regulator_get_voltage(struct regulator *regulator) 2767{ 2768 int ret; 2769 2770 mutex_lock(®ulator->rdev->mutex); 2771 2772 ret = _regulator_get_voltage(regulator->rdev); 2773 2774 mutex_unlock(®ulator->rdev->mutex); 2775 2776 return ret; 2777} 2778EXPORT_SYMBOL_GPL(regulator_get_voltage); 2779 2780/** 2781 * regulator_set_current_limit - set regulator output current limit 2782 * @regulator: regulator source 2783 * @min_uA: Minimum supported current in uA 2784 * @max_uA: Maximum supported current in uA 2785 * 2786 * Sets current sink to the desired output current. This can be set during 2787 * any regulator state. IOW, regulator can be disabled or enabled. 2788 * 2789 * If the regulator is enabled then the current will change to the new value 2790 * immediately otherwise if the regulator is disabled the regulator will 2791 * output at the new current when enabled. 2792 * 2793 * NOTE: Regulator system constraints must be set for this regulator before 2794 * calling this function otherwise this call will fail. 2795 */ 2796int regulator_set_current_limit(struct regulator *regulator, 2797 int min_uA, int max_uA) 2798{ 2799 struct regulator_dev *rdev = regulator->rdev; 2800 int ret; 2801 2802 mutex_lock(&rdev->mutex); 2803 2804 /* sanity check */ 2805 if (!rdev->desc->ops->set_current_limit) { 2806 ret = -EINVAL; 2807 goto out; 2808 } 2809 2810 /* constraints check */ 2811 ret = regulator_check_current_limit(rdev, &min_uA, &max_uA); 2812 if (ret < 0) 2813 goto out; 2814 2815 ret = rdev->desc->ops->set_current_limit(rdev, min_uA, max_uA); 2816out: 2817 mutex_unlock(&rdev->mutex); 2818 return ret; 2819} 2820EXPORT_SYMBOL_GPL(regulator_set_current_limit); 2821 2822static int _regulator_get_current_limit(struct regulator_dev *rdev) 2823{ 2824 int ret; 2825 2826 mutex_lock(&rdev->mutex); 2827 2828 /* sanity check */ 2829 if (!rdev->desc->ops->get_current_limit) { 2830 ret = -EINVAL; 2831 goto out; 2832 } 2833 2834 ret = rdev->desc->ops->get_current_limit(rdev); 2835out: 2836 mutex_unlock(&rdev->mutex); 2837 return ret; 2838} 2839 2840/** 2841 * regulator_get_current_limit - get regulator output current 2842 * @regulator: regulator source 2843 * 2844 * This returns the current supplied by the specified current sink in uA. 2845 * 2846 * NOTE: If the regulator is disabled it will return the current value. This 2847 * function should not be used to determine regulator state. 2848 */ 2849int regulator_get_current_limit(struct regulator *regulator) 2850{ 2851 return _regulator_get_current_limit(regulator->rdev); 2852} 2853EXPORT_SYMBOL_GPL(regulator_get_current_limit); 2854 2855/** 2856 * regulator_set_mode - set regulator operating mode 2857 * @regulator: regulator source 2858 * @mode: operating mode - one of the REGULATOR_MODE constants 2859 * 2860 * Set regulator operating mode to increase regulator efficiency or improve 2861 * regulation performance. 2862 * 2863 * NOTE: Regulator system constraints must be set for this regulator before 2864 * calling this function otherwise this call will fail. 2865 */ 2866int regulator_set_mode(struct regulator *regulator, unsigned int mode) 2867{ 2868 struct regulator_dev *rdev = regulator->rdev; 2869 int ret; 2870 int regulator_curr_mode; 2871 2872 mutex_lock(&rdev->mutex); 2873 2874 /* sanity check */ 2875 if (!rdev->desc->ops->set_mode) { 2876 ret = -EINVAL; 2877 goto out; 2878 } 2879 2880 /* return if the same mode is requested */ 2881 if (rdev->desc->ops->get_mode) { 2882 regulator_curr_mode = rdev->desc->ops->get_mode(rdev); 2883 if (regulator_curr_mode == mode) { 2884 ret = 0; 2885 goto out; 2886 } 2887 } 2888 2889 /* constraints check */ 2890 ret = regulator_mode_constrain(rdev, &mode); 2891 if (ret < 0) 2892 goto out; 2893 2894 ret = rdev->desc->ops->set_mode(rdev, mode); 2895out: 2896 mutex_unlock(&rdev->mutex); 2897 return ret; 2898} 2899EXPORT_SYMBOL_GPL(regulator_set_mode); 2900 2901static unsigned int _regulator_get_mode(struct regulator_dev *rdev) 2902{ 2903 int ret; 2904 2905 mutex_lock(&rdev->mutex); 2906 2907 /* sanity check */ 2908 if (!rdev->desc->ops->get_mode) { 2909 ret = -EINVAL; 2910 goto out; 2911 } 2912 2913 ret = rdev->desc->ops->get_mode(rdev); 2914out: 2915 mutex_unlock(&rdev->mutex); 2916 return ret; 2917} 2918 2919/** 2920 * regulator_get_mode - get regulator operating mode 2921 * @regulator: regulator source 2922 * 2923 * Get the current regulator operating mode. 2924 */ 2925unsigned int regulator_get_mode(struct regulator *regulator) 2926{ 2927 return _regulator_get_mode(regulator->rdev); 2928} 2929EXPORT_SYMBOL_GPL(regulator_get_mode); 2930 2931/** 2932 * regulator_set_optimum_mode - set regulator optimum operating mode 2933 * @regulator: regulator source 2934 * @uA_load: load current 2935 * 2936 * Notifies the regulator core of a new device load. This is then used by 2937 * DRMS (if enabled by constraints) to set the most efficient regulator 2938 * operating mode for the new regulator loading. 2939 * 2940 * Consumer devices notify their supply regulator of the maximum power 2941 * they will require (can be taken from device datasheet in the power 2942 * consumption tables) when they change operational status and hence power 2943 * state. Examples of operational state changes that can affect power 2944 * consumption are :- 2945 * 2946 * o Device is opened / closed. 2947 * o Device I/O is about to begin or has just finished. 2948 * o Device is idling in between work. 2949 * 2950 * This information is also exported via sysfs to userspace. 2951 * 2952 * DRMS will sum the total requested load on the regulator and change 2953 * to the most efficient operating mode if platform constraints allow. 2954 * 2955 * Returns the new regulator mode or error. 2956 */ 2957int regulator_set_optimum_mode(struct regulator *regulator, int uA_load) 2958{ 2959 struct regulator_dev *rdev = regulator->rdev; 2960 struct regulator *consumer; 2961 int ret, output_uV, input_uV = 0, total_uA_load = 0; 2962 unsigned int mode; 2963 2964 if (rdev->supply) 2965 input_uV = regulator_get_voltage(rdev->supply); 2966 2967 mutex_lock(&rdev->mutex); 2968 2969 /* 2970 * first check to see if we can set modes at all, otherwise just 2971 * tell the consumer everything is OK. 2972 */ 2973 regulator->uA_load = uA_load; 2974 ret = regulator_check_drms(rdev); 2975 if (ret < 0) { 2976 ret = 0; 2977 goto out; 2978 } 2979 2980 if (!rdev->desc->ops->get_optimum_mode) 2981 goto out; 2982 2983 /* 2984 * we can actually do this so any errors are indicators of 2985 * potential real failure. 2986 */ 2987 ret = -EINVAL; 2988 2989 if (!rdev->desc->ops->set_mode) 2990 goto out; 2991 2992 /* get output voltage */ 2993 output_uV = _regulator_get_voltage(rdev); 2994 if (output_uV <= 0) { 2995 rdev_err(rdev, "invalid output voltage found\n"); 2996 goto out; 2997 } 2998 2999 /* No supply? Use constraint voltage */ 3000 if (input_uV <= 0) 3001 input_uV = rdev->constraints->input_uV; 3002 if (input_uV <= 0) { 3003 rdev_err(rdev, "invalid input voltage found\n"); 3004 goto out; 3005 } 3006 3007 /* calc total requested load for this regulator */ 3008 list_for_each_entry(consumer, &rdev->consumer_list, list) 3009 total_uA_load += consumer->uA_load; 3010 3011 mode = rdev->desc->ops->get_optimum_mode(rdev, 3012 input_uV, output_uV, 3013 total_uA_load); 3014 ret = regulator_mode_constrain(rdev, &mode); 3015 if (ret < 0) { 3016 rdev_err(rdev, "failed to get optimum mode @ %d uA %d -> %d uV\n", 3017 total_uA_load, input_uV, output_uV); 3018 goto out; 3019 } 3020 3021 ret = rdev->desc->ops->set_mode(rdev, mode); 3022 if (ret < 0) { 3023 rdev_err(rdev, "failed to set optimum mode %x\n", mode); 3024 goto out; 3025 } 3026 ret = mode; 3027out: 3028 mutex_unlock(&rdev->mutex); 3029 return ret; 3030} 3031EXPORT_SYMBOL_GPL(regulator_set_optimum_mode); 3032 3033/** 3034 * regulator_allow_bypass - allow the regulator to go into bypass mode 3035 * 3036 * @regulator: Regulator to configure 3037 * @enable: enable or disable bypass mode 3038 * 3039 * Allow the regulator to go into bypass mode if all other consumers 3040 * for the regulator also enable bypass mode and the machine 3041 * constraints allow this. Bypass mode means that the regulator is 3042 * simply passing the input directly to the output with no regulation. 3043 */ 3044int regulator_allow_bypass(struct regulator *regulator, bool enable) 3045{ 3046 struct regulator_dev *rdev = regulator->rdev; 3047 int ret = 0; 3048 3049 if (!rdev->desc->ops->set_bypass) 3050 return 0; 3051 3052 if (rdev->constraints && 3053 !(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_BYPASS)) 3054 return 0; 3055 3056 mutex_lock(&rdev->mutex); 3057 3058 if (enable && !regulator->bypass) { 3059 rdev->bypass_count++; 3060 3061 if (rdev->bypass_count == rdev->open_count) { 3062 ret = rdev->desc->ops->set_bypass(rdev, enable); 3063 if (ret != 0) 3064 rdev->bypass_count--; 3065 } 3066 3067 } else if (!enable && regulator->bypass) { 3068 rdev->bypass_count--; 3069 3070 if (rdev->bypass_count != rdev->open_count) { 3071 ret = rdev->desc->ops->set_bypass(rdev, enable); 3072 if (ret != 0) 3073 rdev->bypass_count++; 3074 } 3075 } 3076 3077 if (ret == 0) 3078 regulator->bypass = enable; 3079 3080 mutex_unlock(&rdev->mutex); 3081 3082 return ret; 3083} 3084EXPORT_SYMBOL_GPL(regulator_allow_bypass); 3085 3086/** 3087 * regulator_register_notifier - register regulator event notifier 3088 * @regulator: regulator source 3089 * @nb: notifier block 3090 * 3091 * Register notifier block to receive regulator events. 3092 */ 3093int regulator_register_notifier(struct regulator *regulator, 3094 struct notifier_block *nb) 3095{ 3096 return blocking_notifier_chain_register(®ulator->rdev->notifier, 3097 nb); 3098} 3099EXPORT_SYMBOL_GPL(regulator_register_notifier); 3100 3101/** 3102 * regulator_unregister_notifier - unregister regulator event notifier 3103 * @regulator: regulator source 3104 * @nb: notifier block 3105 * 3106 * Unregister regulator event notifier block. 3107 */ 3108int regulator_unregister_notifier(struct regulator *regulator, 3109 struct notifier_block *nb) 3110{ 3111 return blocking_notifier_chain_unregister(®ulator->rdev->notifier, 3112 nb); 3113} 3114EXPORT_SYMBOL_GPL(regulator_unregister_notifier); 3115 3116/* notify regulator consumers and downstream regulator consumers. 3117 * Note mutex must be held by caller. 3118 */ 3119static void _notifier_call_chain(struct regulator_dev *rdev, 3120 unsigned long event, void *data) 3121{ 3122 /* call rdev chain first */ 3123 blocking_notifier_call_chain(&rdev->notifier, event, data); 3124} 3125 3126/** 3127 * regulator_bulk_get - get multiple regulator consumers 3128 * 3129 * @dev: Device to supply 3130 * @num_consumers: Number of consumers to register 3131 * @consumers: Configuration of consumers; clients are stored here. 3132 * 3133 * @return 0 on success, an errno on failure. 3134 * 3135 * This helper function allows drivers to get several regulator 3136 * consumers in one operation. If any of the regulators cannot be 3137 * acquired then any regulators that were allocated will be freed 3138 * before returning to the caller. 3139 */ 3140int regulator_bulk_get(struct device *dev, int num_consumers, 3141 struct regulator_bulk_data *consumers) 3142{ 3143 int i; 3144 int ret; 3145 3146 for (i = 0; i < num_consumers; i++) 3147 consumers[i].consumer = NULL; 3148 3149 for (i = 0; i < num_consumers; i++) { 3150 consumers[i].consumer = regulator_get(dev, 3151 consumers[i].supply); 3152 if (IS_ERR(consumers[i].consumer)) { 3153 ret = PTR_ERR(consumers[i].consumer); 3154 dev_err(dev, "Failed to get supply '%s': %d\n", 3155 consumers[i].supply, ret); 3156 consumers[i].consumer = NULL; 3157 goto err; 3158 } 3159 } 3160 3161 return 0; 3162 3163err: 3164 while (--i >= 0) 3165 regulator_put(consumers[i].consumer); 3166 3167 return ret; 3168} 3169EXPORT_SYMBOL_GPL(regulator_bulk_get); 3170 3171static void regulator_bulk_enable_async(void *data, async_cookie_t cookie) 3172{ 3173 struct regulator_bulk_data *bulk = data; 3174 3175 bulk->ret = regulator_enable(bulk->consumer); 3176} 3177 3178/** 3179 * regulator_bulk_enable - enable multiple regulator consumers 3180 * 3181 * @num_consumers: Number of consumers 3182 * @consumers: Consumer data; clients are stored here. 3183 * @return 0 on success, an errno on failure 3184 * 3185 * This convenience API allows consumers to enable multiple regulator 3186 * clients in a single API call. If any consumers cannot be enabled 3187 * then any others that were enabled will be disabled again prior to 3188 * return. 3189 */ 3190int regulator_bulk_enable(int num_consumers, 3191 struct regulator_bulk_data *consumers) 3192{ 3193 ASYNC_DOMAIN_EXCLUSIVE(async_domain); 3194 int i; 3195 int ret = 0; 3196 3197 for (i = 0; i < num_consumers; i++) { 3198 if (consumers[i].consumer->always_on) 3199 consumers[i].ret = 0; 3200 else 3201 async_schedule_domain(regulator_bulk_enable_async, 3202 &consumers[i], &async_domain); 3203 } 3204 3205 async_synchronize_full_domain(&async_domain); 3206 3207 /* If any consumer failed we need to unwind any that succeeded */ 3208 for (i = 0; i < num_consumers; i++) { 3209 if (consumers[i].ret != 0) { 3210 ret = consumers[i].ret; 3211 goto err; 3212 } 3213 } 3214 3215 return 0; 3216 3217err: 3218 for (i = 0; i < num_consumers; i++) { 3219 if (consumers[i].ret < 0) 3220 pr_err("Failed to enable %s: %d\n", consumers[i].supply, 3221 consumers[i].ret); 3222 else 3223 regulator_disable(consumers[i].consumer); 3224 } 3225 3226 return ret; 3227} 3228EXPORT_SYMBOL_GPL(regulator_bulk_enable); 3229 3230/** 3231 * regulator_bulk_disable - disable multiple regulator consumers 3232 * 3233 * @num_consumers: Number of consumers 3234 * @consumers: Consumer data; clients are stored here. 3235 * @return 0 on success, an errno on failure 3236 * 3237 * This convenience API allows consumers to disable multiple regulator 3238 * clients in a single API call. If any consumers cannot be disabled 3239 * then any others that were disabled will be enabled again prior to 3240 * return. 3241 */ 3242int regulator_bulk_disable(int num_consumers, 3243 struct regulator_bulk_data *consumers) 3244{ 3245 int i; 3246 int ret, r; 3247 3248 for (i = num_consumers - 1; i >= 0; --i) { 3249 ret = regulator_disable(consumers[i].consumer); 3250 if (ret != 0) 3251 goto err; 3252 } 3253 3254 return 0; 3255 3256err: 3257 pr_err("Failed to disable %s: %d\n", consumers[i].supply, ret); 3258 for (++i; i < num_consumers; ++i) { 3259 r = regulator_enable(consumers[i].consumer); 3260 if (r != 0) 3261 pr_err("Failed to reename %s: %d\n", 3262 consumers[i].supply, r); 3263 } 3264 3265 return ret; 3266} 3267EXPORT_SYMBOL_GPL(regulator_bulk_disable); 3268 3269/** 3270 * regulator_bulk_force_disable - force disable multiple regulator consumers 3271 * 3272 * @num_consumers: Number of consumers 3273 * @consumers: Consumer data; clients are stored here. 3274 * @return 0 on success, an errno on failure 3275 * 3276 * This convenience API allows consumers to forcibly disable multiple regulator 3277 * clients in a single API call. 3278 * NOTE: This should be used for situations when device damage will 3279 * likely occur if the regulators are not disabled (e.g. over temp). 3280 * Although regulator_force_disable function call for some consumers can 3281 * return error numbers, the function is called for all consumers. 3282 */ 3283int regulator_bulk_force_disable(int num_consumers, 3284 struct regulator_bulk_data *consumers) 3285{ 3286 int i; 3287 int ret; 3288 3289 for (i = 0; i < num_consumers; i++) 3290 consumers[i].ret = 3291 regulator_force_disable(consumers[i].consumer); 3292 3293 for (i = 0; i < num_consumers; i++) { 3294 if (consumers[i].ret != 0) { 3295 ret = consumers[i].ret; 3296 goto out; 3297 } 3298 } 3299 3300 return 0; 3301out: 3302 return ret; 3303} 3304EXPORT_SYMBOL_GPL(regulator_bulk_force_disable); 3305 3306/** 3307 * regulator_bulk_free - free multiple regulator consumers 3308 * 3309 * @num_consumers: Number of consumers 3310 * @consumers: Consumer data; clients are stored here. 3311 * 3312 * This convenience API allows consumers to free multiple regulator 3313 * clients in a single API call. 3314 */ 3315void regulator_bulk_free(int num_consumers, 3316 struct regulator_bulk_data *consumers) 3317{ 3318 int i; 3319 3320 for (i = 0; i < num_consumers; i++) { 3321 regulator_put(consumers[i].consumer); 3322 consumers[i].consumer = NULL; 3323 } 3324} 3325EXPORT_SYMBOL_GPL(regulator_bulk_free); 3326 3327/** 3328 * regulator_notifier_call_chain - call regulator event notifier 3329 * @rdev: regulator source 3330 * @event: notifier block 3331 * @data: callback-specific data. 3332 * 3333 * Called by regulator drivers to notify clients a regulator event has 3334 * occurred. We also notify regulator clients downstream. 3335 * Note lock must be held by caller. 3336 */ 3337int regulator_notifier_call_chain(struct regulator_dev *rdev, 3338 unsigned long event, void *data) 3339{ 3340 _notifier_call_chain(rdev, event, data); 3341 return NOTIFY_DONE; 3342 3343} 3344EXPORT_SYMBOL_GPL(regulator_notifier_call_chain); 3345 3346/** 3347 * regulator_mode_to_status - convert a regulator mode into a status 3348 * 3349 * @mode: Mode to convert 3350 * 3351 * Convert a regulator mode into a status. 3352 */ 3353int regulator_mode_to_status(unsigned int mode) 3354{ 3355 switch (mode) { 3356 case REGULATOR_MODE_FAST: 3357 return REGULATOR_STATUS_FAST; 3358 case REGULATOR_MODE_NORMAL: 3359 return REGULATOR_STATUS_NORMAL; 3360 case REGULATOR_MODE_IDLE: 3361 return REGULATOR_STATUS_IDLE; 3362 case REGULATOR_MODE_STANDBY: 3363 return REGULATOR_STATUS_STANDBY; 3364 default: 3365 return REGULATOR_STATUS_UNDEFINED; 3366 } 3367} 3368EXPORT_SYMBOL_GPL(regulator_mode_to_status); 3369 3370/* 3371 * To avoid cluttering sysfs (and memory) with useless state, only 3372 * create attributes that can be meaningfully displayed. 3373 */ 3374static int add_regulator_attributes(struct regulator_dev *rdev) 3375{ 3376 struct device *dev = &rdev->dev; 3377 const struct regulator_ops *ops = rdev->desc->ops; 3378 int status = 0; 3379 3380 /* some attributes need specific methods to be displayed */ 3381 if ((ops->get_voltage && ops->get_voltage(rdev) >= 0) || 3382 (ops->get_voltage_sel && ops->get_voltage_sel(rdev) >= 0) || 3383 (ops->list_voltage && ops->list_voltage(rdev, 0) >= 0) || 3384 (rdev->desc->fixed_uV && (rdev->desc->n_voltages == 1))) { 3385 status = device_create_file(dev, &dev_attr_microvolts); 3386 if (status < 0) 3387 return status; 3388 } 3389 if (ops->get_current_limit) { 3390 status = device_create_file(dev, &dev_attr_microamps); 3391 if (status < 0) 3392 return status; 3393 } 3394 if (ops->get_mode) { 3395 status = device_create_file(dev, &dev_attr_opmode); 3396 if (status < 0) 3397 return status; 3398 } 3399 if (rdev->ena_pin || ops->is_enabled) { 3400 status = device_create_file(dev, &dev_attr_state); 3401 if (status < 0) 3402 return status; 3403 } 3404 if (ops->get_status) { 3405 status = device_create_file(dev, &dev_attr_status); 3406 if (status < 0) 3407 return status; 3408 } 3409 if (ops->get_bypass) { 3410 status = device_create_file(dev, &dev_attr_bypass); 3411 if (status < 0) 3412 return status; 3413 } 3414 3415 /* some attributes are type-specific */ 3416 if (rdev->desc->type == REGULATOR_CURRENT) { 3417 status = device_create_file(dev, &dev_attr_requested_microamps); 3418 if (status < 0) 3419 return status; 3420 } 3421 3422 /* all the other attributes exist to support constraints; 3423 * don't show them if there are no constraints, or if the 3424 * relevant supporting methods are missing. 3425 */ 3426 if (!rdev->constraints) 3427 return status; 3428 3429 /* constraints need specific supporting methods */ 3430 if (ops->set_voltage || ops->set_voltage_sel) { 3431 status = device_create_file(dev, &dev_attr_min_microvolts); 3432 if (status < 0) 3433 return status; 3434 status = device_create_file(dev, &dev_attr_max_microvolts); 3435 if (status < 0) 3436 return status; 3437 } 3438 if (ops->set_current_limit) { 3439 status = device_create_file(dev, &dev_attr_min_microamps); 3440 if (status < 0) 3441 return status; 3442 status = device_create_file(dev, &dev_attr_max_microamps); 3443 if (status < 0) 3444 return status; 3445 } 3446 3447 status = device_create_file(dev, &dev_attr_suspend_standby_state); 3448 if (status < 0) 3449 return status; 3450 status = device_create_file(dev, &dev_attr_suspend_mem_state); 3451 if (status < 0) 3452 return status; 3453 status = device_create_file(dev, &dev_attr_suspend_disk_state); 3454 if (status < 0) 3455 return status; 3456 3457 if (ops->set_suspend_voltage) { 3458 status = device_create_file(dev, 3459 &dev_attr_suspend_standby_microvolts); 3460 if (status < 0) 3461 return status; 3462 status = device_create_file(dev, 3463 &dev_attr_suspend_mem_microvolts); 3464 if (status < 0) 3465 return status; 3466 status = device_create_file(dev, 3467 &dev_attr_suspend_disk_microvolts); 3468 if (status < 0) 3469 return status; 3470 } 3471 3472 if (ops->set_suspend_mode) { 3473 status = device_create_file(dev, 3474 &dev_attr_suspend_standby_mode); 3475 if (status < 0) 3476 return status; 3477 status = device_create_file(dev, 3478 &dev_attr_suspend_mem_mode); 3479 if (status < 0) 3480 return status; 3481 status = device_create_file(dev, 3482 &dev_attr_suspend_disk_mode); 3483 if (status < 0) 3484 return status; 3485 } 3486 3487 return status; 3488} 3489 3490static void rdev_init_debugfs(struct regulator_dev *rdev) 3491{ 3492 rdev->debugfs = debugfs_create_dir(rdev_get_name(rdev), debugfs_root); 3493 if (!rdev->debugfs) { 3494 rdev_warn(rdev, "Failed to create debugfs directory\n"); 3495 return; 3496 } 3497 3498 debugfs_create_u32("use_count", 0444, rdev->debugfs, 3499 &rdev->use_count); 3500 debugfs_create_u32("open_count", 0444, rdev->debugfs, 3501 &rdev->open_count); 3502 debugfs_create_u32("bypass_count", 0444, rdev->debugfs, 3503 &rdev->bypass_count); 3504} 3505 3506/** 3507 * regulator_register - register regulator 3508 * @regulator_desc: regulator to register 3509 * @config: runtime configuration for regulator 3510 * 3511 * Called by regulator drivers to register a regulator. 3512 * Returns a valid pointer to struct regulator_dev on success 3513 * or an ERR_PTR() on error. 3514 */ 3515struct regulator_dev * 3516regulator_register(const struct regulator_desc *regulator_desc, 3517 const struct regulator_config *config) 3518{ 3519 const struct regulation_constraints *constraints = NULL; 3520 const struct regulator_init_data *init_data; 3521 static atomic_t regulator_no = ATOMIC_INIT(0); 3522 struct regulator_dev *rdev; 3523 struct device *dev; 3524 int ret, i; 3525 const char *supply = NULL; 3526 3527 if (regulator_desc == NULL || config == NULL) 3528 return ERR_PTR(-EINVAL); 3529 3530 dev = config->dev; 3531 WARN_ON(!dev); 3532 3533 if (regulator_desc->name == NULL || regulator_desc->ops == NULL) 3534 return ERR_PTR(-EINVAL); 3535 3536 if (regulator_desc->type != REGULATOR_VOLTAGE && 3537 regulator_desc->type != REGULATOR_CURRENT) 3538 return ERR_PTR(-EINVAL); 3539 3540 /* Only one of each should be implemented */ 3541 WARN_ON(regulator_desc->ops->get_voltage && 3542 regulator_desc->ops->get_voltage_sel); 3543 WARN_ON(regulator_desc->ops->set_voltage && 3544 regulator_desc->ops->set_voltage_sel); 3545 3546 /* If we're using selectors we must implement list_voltage. */ 3547 if (regulator_desc->ops->get_voltage_sel && 3548 !regulator_desc->ops->list_voltage) { 3549 return ERR_PTR(-EINVAL); 3550 } 3551 if (regulator_desc->ops->set_voltage_sel && 3552 !regulator_desc->ops->list_voltage) { 3553 return ERR_PTR(-EINVAL); 3554 } 3555 3556 init_data = config->init_data; 3557 3558 rdev = kzalloc(sizeof(struct regulator_dev), GFP_KERNEL); 3559 if (rdev == NULL) 3560 return ERR_PTR(-ENOMEM); 3561 3562 mutex_lock(®ulator_list_mutex); 3563 3564 mutex_init(&rdev->mutex); 3565 rdev->reg_data = config->driver_data; 3566 rdev->owner = regulator_desc->owner; 3567 rdev->desc = regulator_desc; 3568 if (config->regmap) 3569 rdev->regmap = config->regmap; 3570 else if (dev_get_regmap(dev, NULL)) 3571 rdev->regmap = dev_get_regmap(dev, NULL); 3572 else if (dev->parent) 3573 rdev->regmap = dev_get_regmap(dev->parent, NULL); 3574 INIT_LIST_HEAD(&rdev->consumer_list); 3575 INIT_LIST_HEAD(&rdev->list); 3576 BLOCKING_INIT_NOTIFIER_HEAD(&rdev->notifier); 3577 INIT_DELAYED_WORK(&rdev->disable_work, regulator_disable_work); 3578 3579 /* preform any regulator specific init */ 3580 if (init_data && init_data->regulator_init) { 3581 ret = init_data->regulator_init(rdev->reg_data); 3582 if (ret < 0) 3583 goto clean; 3584 } 3585 3586 /* register with sysfs */ 3587 rdev->dev.class = ®ulator_class; 3588 rdev->dev.of_node = of_node_get(config->of_node); 3589 rdev->dev.parent = dev; 3590 dev_set_name(&rdev->dev, "regulator.%d", 3591 atomic_inc_return(®ulator_no) - 1); 3592 ret = device_register(&rdev->dev); 3593 if (ret != 0) { 3594 put_device(&rdev->dev); 3595 goto clean; 3596 } 3597 3598 dev_set_drvdata(&rdev->dev, rdev); 3599 3600 if (config->ena_gpio && gpio_is_valid(config->ena_gpio)) { 3601 ret = regulator_ena_gpio_request(rdev, config); 3602 if (ret != 0) { 3603 rdev_err(rdev, "Failed to request enable GPIO%d: %d\n", 3604 config->ena_gpio, ret); 3605 goto wash; 3606 } 3607 3608 if (config->ena_gpio_flags & GPIOF_OUT_INIT_HIGH) 3609 rdev->ena_gpio_state = 1; 3610 3611 if (config->ena_gpio_invert) 3612 rdev->ena_gpio_state = !rdev->ena_gpio_state; 3613 } 3614 3615 /* set regulator constraints */ 3616 if (init_data) 3617 constraints = &init_data->constraints; 3618 3619 ret = set_machine_constraints(rdev, constraints); 3620 if (ret < 0) 3621 goto scrub; 3622 3623 /* add attributes supported by this regulator */ 3624 ret = add_regulator_attributes(rdev); 3625 if (ret < 0) 3626 goto scrub; 3627 3628 if (init_data && init_data->supply_regulator) 3629 supply = init_data->supply_regulator; 3630 else if (regulator_desc->supply_name) 3631 supply = regulator_desc->supply_name; 3632 3633 if (supply) { 3634 struct regulator_dev *r; 3635 3636 r = regulator_dev_lookup(dev, supply, &ret); 3637 3638 if (ret == -ENODEV) { 3639 /* 3640 * No supply was specified for this regulator and 3641 * there will never be one. 3642 */ 3643 ret = 0; 3644 goto add_dev; 3645 } else if (!r) { 3646 dev_err(dev, "Failed to find supply %s\n", supply); 3647 ret = -EPROBE_DEFER; 3648 goto scrub; 3649 } 3650 3651 ret = set_supply(rdev, r); 3652 if (ret < 0) 3653 goto scrub; 3654 3655 /* Enable supply if rail is enabled */ 3656 if (_regulator_is_enabled(rdev)) { 3657 ret = regulator_enable(rdev->supply); 3658 if (ret < 0) 3659 goto scrub; 3660 } 3661 } 3662 3663add_dev: 3664 /* add consumers devices */ 3665 if (init_data) { 3666 for (i = 0; i < init_data->num_consumer_supplies; i++) { 3667 ret = set_consumer_device_supply(rdev, 3668 init_data->consumer_supplies[i].dev_name, 3669 init_data->consumer_supplies[i].supply); 3670 if (ret < 0) { 3671 dev_err(dev, "Failed to set supply %s\n", 3672 init_data->consumer_supplies[i].supply); 3673 goto unset_supplies; 3674 } 3675 } 3676 } 3677 3678 list_add(&rdev->list, ®ulator_list); 3679 3680 rdev_init_debugfs(rdev); 3681out: 3682 mutex_unlock(®ulator_list_mutex); 3683 return rdev; 3684 3685unset_supplies: 3686 unset_regulator_supplies(rdev); 3687 3688scrub: 3689 if (rdev->supply) 3690 _regulator_put(rdev->supply); 3691 regulator_ena_gpio_free(rdev); 3692 kfree(rdev->constraints); 3693wash: 3694 device_unregister(&rdev->dev); 3695 /* device core frees rdev */ 3696 rdev = ERR_PTR(ret); 3697 goto out; 3698 3699clean: 3700 kfree(rdev); 3701 rdev = ERR_PTR(ret); 3702 goto out; 3703} 3704EXPORT_SYMBOL_GPL(regulator_register); 3705 3706/** 3707 * regulator_unregister - unregister regulator 3708 * @rdev: regulator to unregister 3709 * 3710 * Called by regulator drivers to unregister a regulator. 3711 */ 3712void regulator_unregister(struct regulator_dev *rdev) 3713{ 3714 if (rdev == NULL) 3715 return; 3716 3717 if (rdev->supply) { 3718 while (rdev->use_count--) 3719 regulator_disable(rdev->supply); 3720 regulator_put(rdev->supply); 3721 } 3722 mutex_lock(®ulator_list_mutex); 3723 debugfs_remove_recursive(rdev->debugfs); 3724 flush_work(&rdev->disable_work.work); 3725 WARN_ON(rdev->open_count); 3726 unset_regulator_supplies(rdev); 3727 list_del(&rdev->list); 3728 kfree(rdev->constraints); 3729 regulator_ena_gpio_free(rdev); 3730 of_node_put(rdev->dev.of_node); 3731 device_unregister(&rdev->dev); 3732 mutex_unlock(®ulator_list_mutex); 3733} 3734EXPORT_SYMBOL_GPL(regulator_unregister); 3735 3736/** 3737 * regulator_suspend_prepare - prepare regulators for system wide suspend 3738 * @state: system suspend state 3739 * 3740 * Configure each regulator with it's suspend operating parameters for state. 3741 * This will usually be called by machine suspend code prior to supending. 3742 */ 3743int regulator_suspend_prepare(suspend_state_t state) 3744{ 3745 struct regulator_dev *rdev; 3746 int ret = 0; 3747 3748 /* ON is handled by regulator active state */ 3749 if (state == PM_SUSPEND_ON) 3750 return -EINVAL; 3751 3752 mutex_lock(®ulator_list_mutex); 3753 list_for_each_entry(rdev, ®ulator_list, list) { 3754 3755 mutex_lock(&rdev->mutex); 3756 ret = suspend_prepare(rdev, state); 3757 mutex_unlock(&rdev->mutex); 3758 3759 if (ret < 0) { 3760 rdev_err(rdev, "failed to prepare\n"); 3761 goto out; 3762 } 3763 } 3764out: 3765 mutex_unlock(®ulator_list_mutex); 3766 return ret; 3767} 3768EXPORT_SYMBOL_GPL(regulator_suspend_prepare); 3769 3770/** 3771 * regulator_suspend_finish - resume regulators from system wide suspend 3772 * 3773 * Turn on regulators that might be turned off by regulator_suspend_prepare 3774 * and that should be turned on according to the regulators properties. 3775 */ 3776int regulator_suspend_finish(void) 3777{ 3778 struct regulator_dev *rdev; 3779 int ret = 0, error; 3780 3781 mutex_lock(®ulator_list_mutex); 3782 list_for_each_entry(rdev, ®ulator_list, list) { 3783 mutex_lock(&rdev->mutex); 3784 if (rdev->use_count > 0 || rdev->constraints->always_on) { 3785 error = _regulator_do_enable(rdev); 3786 if (error) 3787 ret = error; 3788 } else { 3789 if (!have_full_constraints()) 3790 goto unlock; 3791 if (!_regulator_is_enabled(rdev)) 3792 goto unlock; 3793 3794 error = _regulator_do_disable(rdev); 3795 if (error) 3796 ret = error; 3797 } 3798unlock: 3799 mutex_unlock(&rdev->mutex); 3800 } 3801 mutex_unlock(®ulator_list_mutex); 3802 return ret; 3803} 3804EXPORT_SYMBOL_GPL(regulator_suspend_finish); 3805 3806/** 3807 * regulator_has_full_constraints - the system has fully specified constraints 3808 * 3809 * Calling this function will cause the regulator API to disable all 3810 * regulators which have a zero use count and don't have an always_on 3811 * constraint in a late_initcall. 3812 * 3813 * The intention is that this will become the default behaviour in a 3814 * future kernel release so users are encouraged to use this facility 3815 * now. 3816 */ 3817void regulator_has_full_constraints(void) 3818{ 3819 has_full_constraints = 1; 3820} 3821EXPORT_SYMBOL_GPL(regulator_has_full_constraints); 3822 3823/** 3824 * rdev_get_drvdata - get rdev regulator driver data 3825 * @rdev: regulator 3826 * 3827 * Get rdev regulator driver private data. This call can be used in the 3828 * regulator driver context. 3829 */ 3830void *rdev_get_drvdata(struct regulator_dev *rdev) 3831{ 3832 return rdev->reg_data; 3833} 3834EXPORT_SYMBOL_GPL(rdev_get_drvdata); 3835 3836/** 3837 * regulator_get_drvdata - get regulator driver data 3838 * @regulator: regulator 3839 * 3840 * Get regulator driver private data. This call can be used in the consumer 3841 * driver context when non API regulator specific functions need to be called. 3842 */ 3843void *regulator_get_drvdata(struct regulator *regulator) 3844{ 3845 return regulator->rdev->reg_data; 3846} 3847EXPORT_SYMBOL_GPL(regulator_get_drvdata); 3848 3849/** 3850 * regulator_set_drvdata - set regulator driver data 3851 * @regulator: regulator 3852 * @data: data 3853 */ 3854void regulator_set_drvdata(struct regulator *regulator, void *data) 3855{ 3856 regulator->rdev->reg_data = data; 3857} 3858EXPORT_SYMBOL_GPL(regulator_set_drvdata); 3859 3860/** 3861 * regulator_get_id - get regulator ID 3862 * @rdev: regulator 3863 */ 3864int rdev_get_id(struct regulator_dev *rdev) 3865{ 3866 return rdev->desc->id; 3867} 3868EXPORT_SYMBOL_GPL(rdev_get_id); 3869 3870struct device *rdev_get_dev(struct regulator_dev *rdev) 3871{ 3872 return &rdev->dev; 3873} 3874EXPORT_SYMBOL_GPL(rdev_get_dev); 3875 3876void *regulator_get_init_drvdata(struct regulator_init_data *reg_init_data) 3877{ 3878 return reg_init_data->driver_data; 3879} 3880EXPORT_SYMBOL_GPL(regulator_get_init_drvdata); 3881 3882#ifdef CONFIG_DEBUG_FS 3883static ssize_t supply_map_read_file(struct file *file, char __user *user_buf, 3884 size_t count, loff_t *ppos) 3885{ 3886 char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL); 3887 ssize_t len, ret = 0; 3888 struct regulator_map *map; 3889 3890 if (!buf) 3891 return -ENOMEM; 3892 3893 list_for_each_entry(map, ®ulator_map_list, list) { 3894 len = snprintf(buf + ret, PAGE_SIZE - ret, 3895 "%s -> %s.%s\n", 3896 rdev_get_name(map->regulator), map->dev_name, 3897 map->supply); 3898 if (len >= 0) 3899 ret += len; 3900 if (ret > PAGE_SIZE) { 3901 ret = PAGE_SIZE; 3902 break; 3903 } 3904 } 3905 3906 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret); 3907 3908 kfree(buf); 3909 3910 return ret; 3911} 3912#endif 3913 3914static const struct file_operations supply_map_fops = { 3915#ifdef CONFIG_DEBUG_FS 3916 .read = supply_map_read_file, 3917 .llseek = default_llseek, 3918#endif 3919}; 3920 3921static int __init regulator_init(void) 3922{ 3923 int ret; 3924 3925 ret = class_register(®ulator_class); 3926 3927 debugfs_root = debugfs_create_dir("regulator", NULL); 3928 if (!debugfs_root) 3929 pr_warn("regulator: Failed to create debugfs directory\n"); 3930 3931 debugfs_create_file("supply_map", 0444, debugfs_root, NULL, 3932 &supply_map_fops); 3933 3934 regulator_dummy_init(); 3935 3936 return ret; 3937} 3938 3939/* init early to allow our consumers to complete system booting */ 3940core_initcall(regulator_init); 3941 3942static int __init regulator_init_complete(void) 3943{ 3944 struct regulator_dev *rdev; 3945 const struct regulator_ops *ops; 3946 struct regulation_constraints *c; 3947 int enabled, ret; 3948 3949 /* 3950 * Since DT doesn't provide an idiomatic mechanism for 3951 * enabling full constraints and since it's much more natural 3952 * with DT to provide them just assume that a DT enabled 3953 * system has full constraints. 3954 */ 3955 if (of_have_populated_dt()) 3956 has_full_constraints = true; 3957 3958 mutex_lock(®ulator_list_mutex); 3959 3960 /* If we have a full configuration then disable any regulators 3961 * we have permission to change the status for and which are 3962 * not in use or always_on. This is effectively the default 3963 * for DT and ACPI as they have full constraints. 3964 */ 3965 list_for_each_entry(rdev, ®ulator_list, list) { 3966 ops = rdev->desc->ops; 3967 c = rdev->constraints; 3968 3969 if (c && c->always_on) 3970 continue; 3971 3972 if (c && !(c->valid_ops_mask & REGULATOR_CHANGE_STATUS)) 3973 continue; 3974 3975 mutex_lock(&rdev->mutex); 3976 3977 if (rdev->use_count) 3978 goto unlock; 3979 3980 /* If we can't read the status assume it's on. */ 3981 if (ops->is_enabled) 3982 enabled = ops->is_enabled(rdev); 3983 else 3984 enabled = 1; 3985 3986 if (!enabled) 3987 goto unlock; 3988 3989 if (have_full_constraints()) { 3990 /* We log since this may kill the system if it 3991 * goes wrong. */ 3992 rdev_info(rdev, "disabling\n"); 3993 ret = _regulator_do_disable(rdev); 3994 if (ret != 0) 3995 rdev_err(rdev, "couldn't disable: %d\n", ret); 3996 } else { 3997 /* The intention is that in future we will 3998 * assume that full constraints are provided 3999 * so warn even if we aren't going to do 4000 * anything here. 4001 */ 4002 rdev_warn(rdev, "incomplete constraints, leaving on\n"); 4003 } 4004 4005unlock: 4006 mutex_unlock(&rdev->mutex); 4007 } 4008 4009 mutex_unlock(®ulator_list_mutex); 4010 4011 return 0; 4012} 4013late_initcall_sync(regulator_init_complete); 4014