PageRenderTime 194ms CodeModel.GetById 29ms app.highlight 151ms RepoModel.GetById 1ms app.codeStats 1ms

/drivers/regulator/core.c

https://bitbucket.org/wisechild/galaxy-nexus
C | 2961 lines | 1949 code | 426 blank | 586 comment | 401 complexity | 2b3d507c313a74f8f6669437141af36c MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, AGPL-1.0

Large files files are truncated, but you can click here to view the full file

   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#define pr_fmt(fmt) "%s: " fmt, __func__
  17
  18#include <linux/kernel.h>
  19#include <linux/init.h>
  20#include <linux/debugfs.h>
  21#include <linux/device.h>
  22#include <linux/slab.h>
  23#include <linux/err.h>
  24#include <linux/mutex.h>
  25#include <linux/suspend.h>
  26#include <linux/delay.h>
  27#include <linux/regulator/consumer.h>
  28#include <linux/regulator/driver.h>
  29#include <linux/regulator/machine.h>
  30
  31#define CREATE_TRACE_POINTS
  32#include <trace/events/regulator.h>
  33
  34#include "dummy.h"
  35
  36#define rdev_err(rdev, fmt, ...)					\
  37	pr_err("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
  38#define rdev_warn(rdev, fmt, ...)					\
  39	pr_warn("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
  40#define rdev_info(rdev, fmt, ...)					\
  41	pr_info("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
  42#define rdev_dbg(rdev, fmt, ...)					\
  43	pr_debug("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
  44
  45static DEFINE_MUTEX(regulator_list_mutex);
  46static LIST_HEAD(regulator_list);
  47static LIST_HEAD(regulator_map_list);
  48static bool has_full_constraints;
  49static bool board_wants_dummy_regulator;
  50
  51#ifdef CONFIG_DEBUG_FS
  52static struct dentry *debugfs_root;
  53#endif
  54
  55/*
  56 * struct regulator_map
  57 *
  58 * Used to provide symbolic supply names to devices.
  59 */
  60struct regulator_map {
  61	struct list_head list;
  62	const char *dev_name;   /* The dev_name() for the consumer */
  63	const char *supply;
  64	struct regulator_dev *regulator;
  65};
  66
  67/*
  68 * struct regulator
  69 *
  70 * One for each consumer device.
  71 */
  72struct regulator {
  73	struct device *dev;
  74	struct list_head list;
  75	int uA_load;
  76	int min_uV;
  77	int max_uV;
  78	char *supply_name;
  79	struct device_attribute dev_attr;
  80	struct regulator_dev *rdev;
  81};
  82
  83static int _regulator_is_enabled(struct regulator_dev *rdev);
  84static int _regulator_disable(struct regulator_dev *rdev,
  85		struct regulator_dev **supply_rdev_ptr);
  86static int _regulator_get_voltage(struct regulator_dev *rdev);
  87static int _regulator_get_current_limit(struct regulator_dev *rdev);
  88static unsigned int _regulator_get_mode(struct regulator_dev *rdev);
  89static void _notifier_call_chain(struct regulator_dev *rdev,
  90				  unsigned long event, void *data);
  91static int _regulator_do_set_voltage(struct regulator_dev *rdev,
  92				     int min_uV, int max_uV);
  93
  94static const char *rdev_get_name(struct regulator_dev *rdev)
  95{
  96	if (rdev->constraints && rdev->constraints->name)
  97		return rdev->constraints->name;
  98	else if (rdev->desc->name)
  99		return rdev->desc->name;
 100	else
 101		return "";
 102}
 103
 104/* gets the regulator for a given consumer device */
 105static struct regulator *get_device_regulator(struct device *dev)
 106{
 107	struct regulator *regulator = NULL;
 108	struct regulator_dev *rdev;
 109
 110	mutex_lock(&regulator_list_mutex);
 111	list_for_each_entry(rdev, &regulator_list, list) {
 112		mutex_lock(&rdev->mutex);
 113		list_for_each_entry(regulator, &rdev->consumer_list, list) {
 114			if (regulator->dev == dev) {
 115				mutex_unlock(&rdev->mutex);
 116				mutex_unlock(&regulator_list_mutex);
 117				return regulator;
 118			}
 119		}
 120		mutex_unlock(&rdev->mutex);
 121	}
 122	mutex_unlock(&regulator_list_mutex);
 123	return NULL;
 124}
 125
 126/* Platform voltage constraint check */
 127static int regulator_check_voltage(struct regulator_dev *rdev,
 128				   int *min_uV, int *max_uV)
 129{
 130	BUG_ON(*min_uV > *max_uV);
 131
 132	if (!rdev->constraints) {
 133		rdev_err(rdev, "no constraints\n");
 134		return -ENODEV;
 135	}
 136	if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_VOLTAGE)) {
 137		rdev_err(rdev, "operation not allowed\n");
 138		return -EPERM;
 139	}
 140
 141	if (*max_uV > rdev->constraints->max_uV)
 142		*max_uV = rdev->constraints->max_uV;
 143	if (*min_uV < rdev->constraints->min_uV)
 144		*min_uV = rdev->constraints->min_uV;
 145
 146	if (*min_uV > *max_uV)
 147		return -EINVAL;
 148
 149	return 0;
 150}
 151
 152/* Make sure we select a voltage that suits the needs of all
 153 * regulator consumers
 154 */
 155static int regulator_check_consumers(struct regulator_dev *rdev,
 156				     int *min_uV, int *max_uV)
 157{
 158	struct regulator *regulator;
 159
 160	list_for_each_entry(regulator, &rdev->consumer_list, list) {
 161		/*
 162		 * Assume consumers that didn't say anything are OK
 163		 * with anything in the constraint range.
 164		 */
 165		if (!regulator->min_uV && !regulator->max_uV)
 166			continue;
 167
 168		if (*max_uV > regulator->max_uV)
 169			*max_uV = regulator->max_uV;
 170		if (*min_uV < regulator->min_uV)
 171			*min_uV = regulator->min_uV;
 172	}
 173
 174	if (*min_uV > *max_uV)
 175		return -EINVAL;
 176
 177	return 0;
 178}
 179
 180/* current constraint check */
 181static int regulator_check_current_limit(struct regulator_dev *rdev,
 182					int *min_uA, int *max_uA)
 183{
 184	BUG_ON(*min_uA > *max_uA);
 185
 186	if (!rdev->constraints) {
 187		rdev_err(rdev, "no constraints\n");
 188		return -ENODEV;
 189	}
 190	if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_CURRENT)) {
 191		rdev_err(rdev, "operation not allowed\n");
 192		return -EPERM;
 193	}
 194
 195	if (*max_uA > rdev->constraints->max_uA)
 196		*max_uA = rdev->constraints->max_uA;
 197	if (*min_uA < rdev->constraints->min_uA)
 198		*min_uA = rdev->constraints->min_uA;
 199
 200	if (*min_uA > *max_uA)
 201		return -EINVAL;
 202
 203	return 0;
 204}
 205
 206/* operating mode constraint check */
 207static int regulator_mode_constrain(struct regulator_dev *rdev, int *mode)
 208{
 209	switch (*mode) {
 210	case REGULATOR_MODE_FAST:
 211	case REGULATOR_MODE_NORMAL:
 212	case REGULATOR_MODE_IDLE:
 213	case REGULATOR_MODE_STANDBY:
 214		break;
 215	default:
 216		return -EINVAL;
 217	}
 218
 219	if (!rdev->constraints) {
 220		rdev_err(rdev, "no constraints\n");
 221		return -ENODEV;
 222	}
 223	if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_MODE)) {
 224		rdev_err(rdev, "operation not allowed\n");
 225		return -EPERM;
 226	}
 227
 228	/* The modes are bitmasks, the most power hungry modes having
 229	 * the lowest values. If the requested mode isn't supported
 230	 * try higher modes. */
 231	while (*mode) {
 232		if (rdev->constraints->valid_modes_mask & *mode)
 233			return 0;
 234		*mode /= 2;
 235	}
 236
 237	return -EINVAL;
 238}
 239
 240/* dynamic regulator mode switching constraint check */
 241static int regulator_check_drms(struct regulator_dev *rdev)
 242{
 243	if (!rdev->constraints) {
 244		rdev_err(rdev, "no constraints\n");
 245		return -ENODEV;
 246	}
 247	if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_DRMS)) {
 248		rdev_err(rdev, "operation not allowed\n");
 249		return -EPERM;
 250	}
 251	return 0;
 252}
 253
 254static ssize_t device_requested_uA_show(struct device *dev,
 255			     struct device_attribute *attr, char *buf)
 256{
 257	struct regulator *regulator;
 258
 259	regulator = get_device_regulator(dev);
 260	if (regulator == NULL)
 261		return 0;
 262
 263	return sprintf(buf, "%d\n", regulator->uA_load);
 264}
 265
 266static ssize_t regulator_uV_show(struct device *dev,
 267				struct device_attribute *attr, char *buf)
 268{
 269	struct regulator_dev *rdev = dev_get_drvdata(dev);
 270	ssize_t ret;
 271
 272	mutex_lock(&rdev->mutex);
 273	ret = sprintf(buf, "%d\n", _regulator_get_voltage(rdev));
 274	mutex_unlock(&rdev->mutex);
 275
 276	return ret;
 277}
 278static DEVICE_ATTR(microvolts, 0444, regulator_uV_show, NULL);
 279
 280static ssize_t regulator_uA_show(struct device *dev,
 281				struct device_attribute *attr, char *buf)
 282{
 283	struct regulator_dev *rdev = dev_get_drvdata(dev);
 284
 285	return sprintf(buf, "%d\n", _regulator_get_current_limit(rdev));
 286}
 287static DEVICE_ATTR(microamps, 0444, regulator_uA_show, NULL);
 288
 289static ssize_t regulator_name_show(struct device *dev,
 290			     struct device_attribute *attr, char *buf)
 291{
 292	struct regulator_dev *rdev = dev_get_drvdata(dev);
 293
 294	return sprintf(buf, "%s\n", rdev_get_name(rdev));
 295}
 296
 297static ssize_t regulator_print_opmode(char *buf, int mode)
 298{
 299	switch (mode) {
 300	case REGULATOR_MODE_FAST:
 301		return sprintf(buf, "fast\n");
 302	case REGULATOR_MODE_NORMAL:
 303		return sprintf(buf, "normal\n");
 304	case REGULATOR_MODE_IDLE:
 305		return sprintf(buf, "idle\n");
 306	case REGULATOR_MODE_STANDBY:
 307		return sprintf(buf, "standby\n");
 308	}
 309	return sprintf(buf, "unknown\n");
 310}
 311
 312static ssize_t regulator_opmode_show(struct device *dev,
 313				    struct device_attribute *attr, char *buf)
 314{
 315	struct regulator_dev *rdev = dev_get_drvdata(dev);
 316
 317	return regulator_print_opmode(buf, _regulator_get_mode(rdev));
 318}
 319static DEVICE_ATTR(opmode, 0444, regulator_opmode_show, NULL);
 320
 321static ssize_t regulator_print_state(char *buf, int state)
 322{
 323	if (state > 0)
 324		return sprintf(buf, "enabled\n");
 325	else if (state == 0)
 326		return sprintf(buf, "disabled\n");
 327	else
 328		return sprintf(buf, "unknown\n");
 329}
 330
 331static ssize_t regulator_state_show(struct device *dev,
 332				   struct device_attribute *attr, char *buf)
 333{
 334	struct regulator_dev *rdev = dev_get_drvdata(dev);
 335	ssize_t ret;
 336
 337	mutex_lock(&rdev->mutex);
 338	ret = regulator_print_state(buf, _regulator_is_enabled(rdev));
 339	mutex_unlock(&rdev->mutex);
 340
 341	return ret;
 342}
 343static DEVICE_ATTR(state, 0444, regulator_state_show, NULL);
 344
 345static ssize_t regulator_status_show(struct device *dev,
 346				   struct device_attribute *attr, char *buf)
 347{
 348	struct regulator_dev *rdev = dev_get_drvdata(dev);
 349	int status;
 350	char *label;
 351
 352	status = rdev->desc->ops->get_status(rdev);
 353	if (status < 0)
 354		return status;
 355
 356	switch (status) {
 357	case REGULATOR_STATUS_OFF:
 358		label = "off";
 359		break;
 360	case REGULATOR_STATUS_ON:
 361		label = "on";
 362		break;
 363	case REGULATOR_STATUS_ERROR:
 364		label = "error";
 365		break;
 366	case REGULATOR_STATUS_FAST:
 367		label = "fast";
 368		break;
 369	case REGULATOR_STATUS_NORMAL:
 370		label = "normal";
 371		break;
 372	case REGULATOR_STATUS_IDLE:
 373		label = "idle";
 374		break;
 375	case REGULATOR_STATUS_STANDBY:
 376		label = "standby";
 377		break;
 378	default:
 379		return -ERANGE;
 380	}
 381
 382	return sprintf(buf, "%s\n", label);
 383}
 384static DEVICE_ATTR(status, 0444, regulator_status_show, NULL);
 385
 386static ssize_t regulator_min_uA_show(struct device *dev,
 387				    struct device_attribute *attr, char *buf)
 388{
 389	struct regulator_dev *rdev = dev_get_drvdata(dev);
 390
 391	if (!rdev->constraints)
 392		return sprintf(buf, "constraint not defined\n");
 393
 394	return sprintf(buf, "%d\n", rdev->constraints->min_uA);
 395}
 396static DEVICE_ATTR(min_microamps, 0444, regulator_min_uA_show, NULL);
 397
 398static ssize_t regulator_max_uA_show(struct device *dev,
 399				    struct device_attribute *attr, char *buf)
 400{
 401	struct regulator_dev *rdev = dev_get_drvdata(dev);
 402
 403	if (!rdev->constraints)
 404		return sprintf(buf, "constraint not defined\n");
 405
 406	return sprintf(buf, "%d\n", rdev->constraints->max_uA);
 407}
 408static DEVICE_ATTR(max_microamps, 0444, regulator_max_uA_show, NULL);
 409
 410static ssize_t regulator_min_uV_show(struct device *dev,
 411				    struct device_attribute *attr, char *buf)
 412{
 413	struct regulator_dev *rdev = dev_get_drvdata(dev);
 414
 415	if (!rdev->constraints)
 416		return sprintf(buf, "constraint not defined\n");
 417
 418	return sprintf(buf, "%d\n", rdev->constraints->min_uV);
 419}
 420static DEVICE_ATTR(min_microvolts, 0444, regulator_min_uV_show, NULL);
 421
 422static ssize_t regulator_max_uV_show(struct device *dev,
 423				    struct device_attribute *attr, char *buf)
 424{
 425	struct regulator_dev *rdev = dev_get_drvdata(dev);
 426
 427	if (!rdev->constraints)
 428		return sprintf(buf, "constraint not defined\n");
 429
 430	return sprintf(buf, "%d\n", rdev->constraints->max_uV);
 431}
 432static DEVICE_ATTR(max_microvolts, 0444, regulator_max_uV_show, NULL);
 433
 434static ssize_t regulator_total_uA_show(struct device *dev,
 435				      struct device_attribute *attr, char *buf)
 436{
 437	struct regulator_dev *rdev = dev_get_drvdata(dev);
 438	struct regulator *regulator;
 439	int uA = 0;
 440
 441	mutex_lock(&rdev->mutex);
 442	list_for_each_entry(regulator, &rdev->consumer_list, list)
 443		uA += regulator->uA_load;
 444	mutex_unlock(&rdev->mutex);
 445	return sprintf(buf, "%d\n", uA);
 446}
 447static DEVICE_ATTR(requested_microamps, 0444, regulator_total_uA_show, NULL);
 448
 449static ssize_t regulator_num_users_show(struct device *dev,
 450				      struct device_attribute *attr, char *buf)
 451{
 452	struct regulator_dev *rdev = dev_get_drvdata(dev);
 453	return sprintf(buf, "%d\n", rdev->use_count);
 454}
 455
 456static ssize_t regulator_type_show(struct device *dev,
 457				  struct device_attribute *attr, char *buf)
 458{
 459	struct regulator_dev *rdev = dev_get_drvdata(dev);
 460
 461	switch (rdev->desc->type) {
 462	case REGULATOR_VOLTAGE:
 463		return sprintf(buf, "voltage\n");
 464	case REGULATOR_CURRENT:
 465		return sprintf(buf, "current\n");
 466	}
 467	return sprintf(buf, "unknown\n");
 468}
 469
 470static ssize_t regulator_suspend_mem_uV_show(struct device *dev,
 471				struct device_attribute *attr, char *buf)
 472{
 473	struct regulator_dev *rdev = dev_get_drvdata(dev);
 474
 475	return sprintf(buf, "%d\n", rdev->constraints->state_mem.uV);
 476}
 477static DEVICE_ATTR(suspend_mem_microvolts, 0444,
 478		regulator_suspend_mem_uV_show, NULL);
 479
 480static ssize_t regulator_suspend_disk_uV_show(struct device *dev,
 481				struct device_attribute *attr, char *buf)
 482{
 483	struct regulator_dev *rdev = dev_get_drvdata(dev);
 484
 485	return sprintf(buf, "%d\n", rdev->constraints->state_disk.uV);
 486}
 487static DEVICE_ATTR(suspend_disk_microvolts, 0444,
 488		regulator_suspend_disk_uV_show, NULL);
 489
 490static ssize_t regulator_suspend_standby_uV_show(struct device *dev,
 491				struct device_attribute *attr, char *buf)
 492{
 493	struct regulator_dev *rdev = dev_get_drvdata(dev);
 494
 495	return sprintf(buf, "%d\n", rdev->constraints->state_standby.uV);
 496}
 497static DEVICE_ATTR(suspend_standby_microvolts, 0444,
 498		regulator_suspend_standby_uV_show, NULL);
 499
 500static ssize_t regulator_suspend_mem_mode_show(struct device *dev,
 501				struct device_attribute *attr, char *buf)
 502{
 503	struct regulator_dev *rdev = dev_get_drvdata(dev);
 504
 505	return regulator_print_opmode(buf,
 506		rdev->constraints->state_mem.mode);
 507}
 508static DEVICE_ATTR(suspend_mem_mode, 0444,
 509		regulator_suspend_mem_mode_show, NULL);
 510
 511static ssize_t regulator_suspend_disk_mode_show(struct device *dev,
 512				struct device_attribute *attr, char *buf)
 513{
 514	struct regulator_dev *rdev = dev_get_drvdata(dev);
 515
 516	return regulator_print_opmode(buf,
 517		rdev->constraints->state_disk.mode);
 518}
 519static DEVICE_ATTR(suspend_disk_mode, 0444,
 520		regulator_suspend_disk_mode_show, NULL);
 521
 522static ssize_t regulator_suspend_standby_mode_show(struct device *dev,
 523				struct device_attribute *attr, char *buf)
 524{
 525	struct regulator_dev *rdev = dev_get_drvdata(dev);
 526
 527	return regulator_print_opmode(buf,
 528		rdev->constraints->state_standby.mode);
 529}
 530static DEVICE_ATTR(suspend_standby_mode, 0444,
 531		regulator_suspend_standby_mode_show, NULL);
 532
 533static ssize_t regulator_suspend_mem_state_show(struct device *dev,
 534				   struct device_attribute *attr, char *buf)
 535{
 536	struct regulator_dev *rdev = dev_get_drvdata(dev);
 537
 538	return regulator_print_state(buf,
 539			rdev->constraints->state_mem.enabled);
 540}
 541static DEVICE_ATTR(suspend_mem_state, 0444,
 542		regulator_suspend_mem_state_show, NULL);
 543
 544static ssize_t regulator_suspend_disk_state_show(struct device *dev,
 545				   struct device_attribute *attr, char *buf)
 546{
 547	struct regulator_dev *rdev = dev_get_drvdata(dev);
 548
 549	return regulator_print_state(buf,
 550			rdev->constraints->state_disk.enabled);
 551}
 552static DEVICE_ATTR(suspend_disk_state, 0444,
 553		regulator_suspend_disk_state_show, NULL);
 554
 555static ssize_t regulator_suspend_standby_state_show(struct device *dev,
 556				   struct device_attribute *attr, char *buf)
 557{
 558	struct regulator_dev *rdev = dev_get_drvdata(dev);
 559
 560	return regulator_print_state(buf,
 561			rdev->constraints->state_standby.enabled);
 562}
 563static DEVICE_ATTR(suspend_standby_state, 0444,
 564		regulator_suspend_standby_state_show, NULL);
 565
 566
 567/*
 568 * These are the only attributes are present for all regulators.
 569 * Other attributes are a function of regulator functionality.
 570 */
 571static struct device_attribute regulator_dev_attrs[] = {
 572	__ATTR(name, 0444, regulator_name_show, NULL),
 573	__ATTR(num_users, 0444, regulator_num_users_show, NULL),
 574	__ATTR(type, 0444, regulator_type_show, NULL),
 575	__ATTR_NULL,
 576};
 577
 578static void regulator_dev_release(struct device *dev)
 579{
 580	struct regulator_dev *rdev = dev_get_drvdata(dev);
 581	kfree(rdev);
 582}
 583
 584static struct class regulator_class = {
 585	.name = "regulator",
 586	.dev_release = regulator_dev_release,
 587	.dev_attrs = regulator_dev_attrs,
 588};
 589
 590/* Calculate the new optimum regulator operating mode based on the new total
 591 * consumer load. All locks held by caller */
 592static void drms_uA_update(struct regulator_dev *rdev)
 593{
 594	struct regulator *sibling;
 595	int current_uA = 0, output_uV, input_uV, err;
 596	unsigned int mode;
 597
 598	err = regulator_check_drms(rdev);
 599	if (err < 0 || !rdev->desc->ops->get_optimum_mode ||
 600	    (!rdev->desc->ops->get_voltage &&
 601	     !rdev->desc->ops->get_voltage_sel) ||
 602	    !rdev->desc->ops->set_mode)
 603		return;
 604
 605	/* get output voltage */
 606	output_uV = _regulator_get_voltage(rdev);
 607	if (output_uV <= 0)
 608		return;
 609
 610	/* get input voltage */
 611	input_uV = 0;
 612	if (rdev->supply)
 613		input_uV = _regulator_get_voltage(rdev);
 614	if (input_uV <= 0)
 615		input_uV = rdev->constraints->input_uV;
 616	if (input_uV <= 0)
 617		return;
 618
 619	/* calc total requested load */
 620	list_for_each_entry(sibling, &rdev->consumer_list, list)
 621		current_uA += sibling->uA_load;
 622
 623	/* now get the optimum mode for our new total regulator load */
 624	mode = rdev->desc->ops->get_optimum_mode(rdev, input_uV,
 625						  output_uV, current_uA);
 626
 627	/* check the new mode is allowed */
 628	err = regulator_mode_constrain(rdev, &mode);
 629	if (err == 0)
 630		rdev->desc->ops->set_mode(rdev, mode);
 631}
 632
 633static int suspend_set_state(struct regulator_dev *rdev,
 634	struct regulator_state *rstate)
 635{
 636	int ret = 0;
 637	bool can_set_state;
 638
 639	can_set_state = rdev->desc->ops->set_suspend_enable &&
 640		rdev->desc->ops->set_suspend_disable;
 641
 642	/* If we have no suspend mode configration don't set anything;
 643	 * only warn if the driver actually makes the suspend mode
 644	 * configurable.
 645	 */
 646	if (!rstate->enabled && !rstate->disabled) {
 647		if (can_set_state)
 648			rdev_warn(rdev, "No configuration\n");
 649		return 0;
 650	}
 651
 652	if (rstate->enabled && rstate->disabled) {
 653		rdev_err(rdev, "invalid configuration\n");
 654		return -EINVAL;
 655	}
 656
 657	if (!can_set_state) {
 658		rdev_err(rdev, "no way to set suspend state\n");
 659		return -EINVAL;
 660	}
 661
 662	if (rstate->enabled)
 663		ret = rdev->desc->ops->set_suspend_enable(rdev);
 664	else
 665		ret = rdev->desc->ops->set_suspend_disable(rdev);
 666	if (ret < 0) {
 667		rdev_err(rdev, "failed to enabled/disable\n");
 668		return ret;
 669	}
 670
 671	if (rdev->desc->ops->set_suspend_voltage && rstate->uV > 0) {
 672		ret = rdev->desc->ops->set_suspend_voltage(rdev, rstate->uV);
 673		if (ret < 0) {
 674			rdev_err(rdev, "failed to set voltage\n");
 675			return ret;
 676		}
 677	}
 678
 679	if (rdev->desc->ops->set_suspend_mode && rstate->mode > 0) {
 680		ret = rdev->desc->ops->set_suspend_mode(rdev, rstate->mode);
 681		if (ret < 0) {
 682			rdev_err(rdev, "failed to set mode\n");
 683			return ret;
 684		}
 685	}
 686	return ret;
 687}
 688
 689/* locks held by caller */
 690static int suspend_prepare(struct regulator_dev *rdev, suspend_state_t state)
 691{
 692	if (!rdev->constraints)
 693		return -EINVAL;
 694
 695	switch (state) {
 696	case PM_SUSPEND_STANDBY:
 697		return suspend_set_state(rdev,
 698			&rdev->constraints->state_standby);
 699	case PM_SUSPEND_MEM:
 700		return suspend_set_state(rdev,
 701			&rdev->constraints->state_mem);
 702	case PM_SUSPEND_MAX:
 703		return suspend_set_state(rdev,
 704			&rdev->constraints->state_disk);
 705	default:
 706		return -EINVAL;
 707	}
 708}
 709
 710static void print_constraints(struct regulator_dev *rdev)
 711{
 712	struct regulation_constraints *constraints = rdev->constraints;
 713	char buf[80] = "";
 714	int count = 0;
 715	int ret;
 716
 717	if (constraints->min_uV && constraints->max_uV) {
 718		if (constraints->min_uV == constraints->max_uV)
 719			count += sprintf(buf + count, "%d mV ",
 720					 constraints->min_uV / 1000);
 721		else
 722			count += sprintf(buf + count, "%d <--> %d mV ",
 723					 constraints->min_uV / 1000,
 724					 constraints->max_uV / 1000);
 725	}
 726
 727	if (!constraints->min_uV ||
 728	    constraints->min_uV != constraints->max_uV) {
 729		ret = _regulator_get_voltage(rdev);
 730		if (ret > 0)
 731			count += sprintf(buf + count, "at %d mV ", ret / 1000);
 732	}
 733
 734	if (constraints->uV_offset)
 735		count += sprintf(buf, "%dmV offset ",
 736				 constraints->uV_offset / 1000);
 737
 738	if (constraints->min_uA && constraints->max_uA) {
 739		if (constraints->min_uA == constraints->max_uA)
 740			count += sprintf(buf + count, "%d mA ",
 741					 constraints->min_uA / 1000);
 742		else
 743			count += sprintf(buf + count, "%d <--> %d mA ",
 744					 constraints->min_uA / 1000,
 745					 constraints->max_uA / 1000);
 746	}
 747
 748	if (!constraints->min_uA ||
 749	    constraints->min_uA != constraints->max_uA) {
 750		ret = _regulator_get_current_limit(rdev);
 751		if (ret > 0)
 752			count += sprintf(buf + count, "at %d mA ", ret / 1000);
 753	}
 754
 755	if (constraints->valid_modes_mask & REGULATOR_MODE_FAST)
 756		count += sprintf(buf + count, "fast ");
 757	if (constraints->valid_modes_mask & REGULATOR_MODE_NORMAL)
 758		count += sprintf(buf + count, "normal ");
 759	if (constraints->valid_modes_mask & REGULATOR_MODE_IDLE)
 760		count += sprintf(buf + count, "idle ");
 761	if (constraints->valid_modes_mask & REGULATOR_MODE_STANDBY)
 762		count += sprintf(buf + count, "standby");
 763
 764	rdev_info(rdev, "%s\n", buf);
 765}
 766
 767static int machine_constraints_voltage(struct regulator_dev *rdev,
 768	struct regulation_constraints *constraints)
 769{
 770	struct regulator_ops *ops = rdev->desc->ops;
 771	int ret;
 772
 773	/* do we need to apply the constraint voltage */
 774	if (rdev->constraints->apply_uV &&
 775	    rdev->constraints->min_uV == rdev->constraints->max_uV) {
 776		ret = _regulator_do_set_voltage(rdev,
 777						rdev->constraints->min_uV,
 778						rdev->constraints->max_uV);
 779		if (ret < 0) {
 780			rdev_err(rdev, "failed to apply %duV constraint\n",
 781				 rdev->constraints->min_uV);
 782			rdev->constraints = NULL;
 783			return ret;
 784		}
 785	}
 786
 787	/* constrain machine-level voltage specs to fit
 788	 * the actual range supported by this regulator.
 789	 */
 790	if (ops->list_voltage && rdev->desc->n_voltages) {
 791		int	count = rdev->desc->n_voltages;
 792		int	i;
 793		int	min_uV = INT_MAX;
 794		int	max_uV = INT_MIN;
 795		int	cmin = constraints->min_uV;
 796		int	cmax = constraints->max_uV;
 797
 798		/* it's safe to autoconfigure fixed-voltage supplies
 799		   and the constraints are used by list_voltage. */
 800		if (count == 1 && !cmin) {
 801			cmin = 1;
 802			cmax = INT_MAX;
 803			constraints->min_uV = cmin;
 804			constraints->max_uV = cmax;
 805		}
 806
 807		/* voltage constraints are optional */
 808		if ((cmin == 0) && (cmax == 0))
 809			return 0;
 810
 811		/* else require explicit machine-level constraints */
 812		if (cmin <= 0 || cmax <= 0 || cmax < cmin) {
 813			rdev_err(rdev, "invalid voltage constraints\n");
 814			return -EINVAL;
 815		}
 816
 817		/* initial: [cmin..cmax] valid, [min_uV..max_uV] not */
 818		for (i = 0; i < count; i++) {
 819			int	value;
 820
 821			value = ops->list_voltage(rdev, i);
 822			if (value <= 0)
 823				continue;
 824
 825			/* maybe adjust [min_uV..max_uV] */
 826			if (value >= cmin && value < min_uV)
 827				min_uV = value;
 828			if (value <= cmax && value > max_uV)
 829				max_uV = value;
 830		}
 831
 832		/* final: [min_uV..max_uV] valid iff constraints valid */
 833		if (max_uV < min_uV) {
 834			rdev_err(rdev, "unsupportable voltage constraints\n");
 835			return -EINVAL;
 836		}
 837
 838		/* use regulator's subset of machine constraints */
 839		if (constraints->min_uV < min_uV) {
 840			rdev_dbg(rdev, "override min_uV, %d -> %d\n",
 841				 constraints->min_uV, min_uV);
 842			constraints->min_uV = min_uV;
 843		}
 844		if (constraints->max_uV > max_uV) {
 845			rdev_dbg(rdev, "override max_uV, %d -> %d\n",
 846				 constraints->max_uV, max_uV);
 847			constraints->max_uV = max_uV;
 848		}
 849	}
 850
 851	return 0;
 852}
 853
 854/**
 855 * set_machine_constraints - sets regulator constraints
 856 * @rdev: regulator source
 857 * @constraints: constraints to apply
 858 *
 859 * Allows platform initialisation code to define and constrain
 860 * regulator circuits e.g. valid voltage/current ranges, etc.  NOTE:
 861 * Constraints *must* be set by platform code in order for some
 862 * regulator operations to proceed i.e. set_voltage, set_current_limit,
 863 * set_mode.
 864 */
 865static int set_machine_constraints(struct regulator_dev *rdev,
 866	const struct regulation_constraints *constraints)
 867{
 868	int ret = 0;
 869	struct regulator_ops *ops = rdev->desc->ops;
 870
 871	rdev->constraints = kmemdup(constraints, sizeof(*constraints),
 872				    GFP_KERNEL);
 873	if (!rdev->constraints)
 874		return -ENOMEM;
 875
 876	ret = machine_constraints_voltage(rdev, rdev->constraints);
 877	if (ret != 0)
 878		goto out;
 879
 880	/* do we need to setup our suspend state */
 881	if (constraints->initial_state) {
 882		ret = suspend_prepare(rdev, rdev->constraints->initial_state);
 883		if (ret < 0) {
 884			rdev_err(rdev, "failed to set suspend state\n");
 885			rdev->constraints = NULL;
 886			goto out;
 887		}
 888	}
 889
 890	if (constraints->initial_mode) {
 891		if (!ops->set_mode) {
 892			rdev_err(rdev, "no set_mode operation\n");
 893			ret = -EINVAL;
 894			goto out;
 895		}
 896
 897		ret = ops->set_mode(rdev, rdev->constraints->initial_mode);
 898		if (ret < 0) {
 899			rdev_err(rdev, "failed to set initial mode: %d\n", ret);
 900			goto out;
 901		}
 902	}
 903
 904	/* If the constraints say the regulator should be on at this point
 905	 * and we have control then make sure it is enabled.
 906	 */
 907	if ((rdev->constraints->always_on || rdev->constraints->boot_on) &&
 908	    ops->enable) {
 909		ret = ops->enable(rdev);
 910		if (ret < 0) {
 911			rdev_err(rdev, "failed to enable\n");
 912			rdev->constraints = NULL;
 913			goto out;
 914		}
 915	}
 916
 917	print_constraints(rdev);
 918out:
 919	return ret;
 920}
 921
 922/**
 923 * set_supply - set regulator supply regulator
 924 * @rdev: regulator name
 925 * @supply_rdev: supply regulator name
 926 *
 927 * Called by platform initialisation code to set the supply regulator for this
 928 * regulator. This ensures that a regulators supply will also be enabled by the
 929 * core if it's child is enabled.
 930 */
 931static int set_supply(struct regulator_dev *rdev,
 932	struct regulator_dev *supply_rdev)
 933{
 934	int err;
 935
 936	err = sysfs_create_link(&rdev->dev.kobj, &supply_rdev->dev.kobj,
 937				"supply");
 938	if (err) {
 939		rdev_err(rdev, "could not add device link %s err %d\n",
 940			 supply_rdev->dev.kobj.name, err);
 941		       goto out;
 942	}
 943	rdev->supply = supply_rdev;
 944	list_add(&rdev->slist, &supply_rdev->supply_list);
 945out:
 946	return err;
 947}
 948
 949/**
 950 * set_consumer_device_supply - Bind a regulator to a symbolic supply
 951 * @rdev:         regulator source
 952 * @consumer_dev: device the supply applies to
 953 * @consumer_dev_name: dev_name() string for device supply applies to
 954 * @supply:       symbolic name for supply
 955 *
 956 * Allows platform initialisation code to map physical regulator
 957 * sources to symbolic names for supplies for use by devices.  Devices
 958 * should use these symbolic names to request regulators, avoiding the
 959 * need to provide board-specific regulator names as platform data.
 960 *
 961 * Only one of consumer_dev and consumer_dev_name may be specified.
 962 */
 963static int set_consumer_device_supply(struct regulator_dev *rdev,
 964	struct device *consumer_dev, const char *consumer_dev_name,
 965	const char *supply)
 966{
 967	struct regulator_map *node;
 968	int has_dev;
 969
 970	if (consumer_dev && consumer_dev_name)
 971		return -EINVAL;
 972
 973	if (!consumer_dev_name && consumer_dev)
 974		consumer_dev_name = dev_name(consumer_dev);
 975
 976	if (supply == NULL)
 977		return -EINVAL;
 978
 979	if (consumer_dev_name != NULL)
 980		has_dev = 1;
 981	else
 982		has_dev = 0;
 983
 984	list_for_each_entry(node, &regulator_map_list, list) {
 985		if (node->dev_name && consumer_dev_name) {
 986			if (strcmp(node->dev_name, consumer_dev_name) != 0)
 987				continue;
 988		} else if (node->dev_name || consumer_dev_name) {
 989			continue;
 990		}
 991
 992		if (strcmp(node->supply, supply) != 0)
 993			continue;
 994
 995		dev_dbg(consumer_dev, "%s/%s is '%s' supply; fail %s/%s\n",
 996			dev_name(&node->regulator->dev),
 997			node->regulator->desc->name,
 998			supply,
 999			dev_name(&rdev->dev), rdev_get_name(rdev));
1000		return -EBUSY;
1001	}
1002
1003	node = kzalloc(sizeof(struct regulator_map), GFP_KERNEL);
1004	if (node == NULL)
1005		return -ENOMEM;
1006
1007	node->regulator = rdev;
1008	node->supply = supply;
1009
1010	if (has_dev) {
1011		node->dev_name = kstrdup(consumer_dev_name, GFP_KERNEL);
1012		if (node->dev_name == NULL) {
1013			kfree(node);
1014			return -ENOMEM;
1015		}
1016	}
1017
1018	list_add(&node->list, &regulator_map_list);
1019	return 0;
1020}
1021
1022static void unset_regulator_supplies(struct regulator_dev *rdev)
1023{
1024	struct regulator_map *node, *n;
1025
1026	list_for_each_entry_safe(node, n, &regulator_map_list, list) {
1027		if (rdev == node->regulator) {
1028			list_del(&node->list);
1029			kfree(node->dev_name);
1030			kfree(node);
1031		}
1032	}
1033}
1034
1035#define REG_STR_SIZE	32
1036
1037static struct regulator *create_regulator(struct regulator_dev *rdev,
1038					  struct device *dev,
1039					  const char *supply_name)
1040{
1041	struct regulator *regulator;
1042	char buf[REG_STR_SIZE];
1043	int err, size;
1044
1045	regulator = kzalloc(sizeof(*regulator), GFP_KERNEL);
1046	if (regulator == NULL)
1047		return NULL;
1048
1049	mutex_lock(&rdev->mutex);
1050	regulator->rdev = rdev;
1051	list_add(&regulator->list, &rdev->consumer_list);
1052
1053	if (dev) {
1054		/* create a 'requested_microamps_name' sysfs entry */
1055		size = scnprintf(buf, REG_STR_SIZE, "microamps_requested_%s",
1056			supply_name);
1057		if (size >= REG_STR_SIZE)
1058			goto overflow_err;
1059
1060		regulator->dev = dev;
1061		sysfs_attr_init(&regulator->dev_attr.attr);
1062		regulator->dev_attr.attr.name = kstrdup(buf, GFP_KERNEL);
1063		if (regulator->dev_attr.attr.name == NULL)
1064			goto attr_name_err;
1065
1066		regulator->dev_attr.attr.mode = 0444;
1067		regulator->dev_attr.show = device_requested_uA_show;
1068		err = device_create_file(dev, &regulator->dev_attr);
1069		if (err < 0) {
1070			rdev_warn(rdev, "could not add regulator_dev requested microamps sysfs entry\n");
1071			goto attr_name_err;
1072		}
1073
1074		/* also add a link to the device sysfs entry */
1075		size = scnprintf(buf, REG_STR_SIZE, "%s-%s",
1076				 dev->kobj.name, supply_name);
1077		if (size >= REG_STR_SIZE)
1078			goto attr_err;
1079
1080		regulator->supply_name = kstrdup(buf, GFP_KERNEL);
1081		if (regulator->supply_name == NULL)
1082			goto attr_err;
1083
1084		err = sysfs_create_link(&rdev->dev.kobj, &dev->kobj,
1085					buf);
1086		if (err) {
1087			rdev_warn(rdev, "could not add device link %s err %d\n",
1088				  dev->kobj.name, err);
1089			goto link_name_err;
1090		}
1091	}
1092	mutex_unlock(&rdev->mutex);
1093	return regulator;
1094link_name_err:
1095	kfree(regulator->supply_name);
1096attr_err:
1097	device_remove_file(regulator->dev, &regulator->dev_attr);
1098attr_name_err:
1099	kfree(regulator->dev_attr.attr.name);
1100overflow_err:
1101	list_del(&regulator->list);
1102	kfree(regulator);
1103	mutex_unlock(&rdev->mutex);
1104	return NULL;
1105}
1106
1107static int _regulator_get_enable_time(struct regulator_dev *rdev)
1108{
1109	if (!rdev->desc->ops->enable_time)
1110		return 0;
1111	return rdev->desc->ops->enable_time(rdev);
1112}
1113
1114/* Internal regulator request function */
1115static struct regulator *_regulator_get(struct device *dev, const char *id,
1116					int exclusive)
1117{
1118	struct regulator_dev *rdev;
1119	struct regulator_map *map;
1120	struct regulator *regulator = ERR_PTR(-ENODEV);
1121	const char *devname = NULL;
1122	int ret;
1123
1124	if (id == NULL) {
1125		pr_err("get() with no identifier\n");
1126		return regulator;
1127	}
1128
1129	if (dev)
1130		devname = dev_name(dev);
1131
1132	mutex_lock(&regulator_list_mutex);
1133
1134	list_for_each_entry(map, &regulator_map_list, list) {
1135		/* If the mapping has a device set up it must match */
1136		if (map->dev_name &&
1137		    (!devname || strcmp(map->dev_name, devname)))
1138			continue;
1139
1140		if (strcmp(map->supply, id) == 0) {
1141			rdev = map->regulator;
1142			goto found;
1143		}
1144	}
1145
1146	if (board_wants_dummy_regulator) {
1147		rdev = dummy_regulator_rdev;
1148		goto found;
1149	}
1150
1151#ifdef CONFIG_REGULATOR_DUMMY
1152	if (!devname)
1153		devname = "deviceless";
1154
1155	/* If the board didn't flag that it was fully constrained then
1156	 * substitute in a dummy regulator so consumers can continue.
1157	 */
1158	if (!has_full_constraints) {
1159		pr_warn("%s supply %s not found, using dummy regulator\n",
1160			devname, id);
1161		rdev = dummy_regulator_rdev;
1162		goto found;
1163	}
1164#endif
1165
1166	mutex_unlock(&regulator_list_mutex);
1167	return regulator;
1168
1169found:
1170	if (rdev->exclusive) {
1171		regulator = ERR_PTR(-EPERM);
1172		goto out;
1173	}
1174
1175	if (exclusive && rdev->open_count) {
1176		regulator = ERR_PTR(-EBUSY);
1177		goto out;
1178	}
1179
1180	if (!try_module_get(rdev->owner))
1181		goto out;
1182
1183	regulator = create_regulator(rdev, dev, id);
1184	if (regulator == NULL) {
1185		regulator = ERR_PTR(-ENOMEM);
1186		module_put(rdev->owner);
1187	}
1188
1189	rdev->open_count++;
1190	if (exclusive) {
1191		rdev->exclusive = 1;
1192
1193		ret = _regulator_is_enabled(rdev);
1194		if (ret > 0)
1195			rdev->use_count = 1;
1196		else
1197			rdev->use_count = 0;
1198	}
1199
1200out:
1201	mutex_unlock(&regulator_list_mutex);
1202
1203	return regulator;
1204}
1205
1206/**
1207 * regulator_get - lookup and obtain a reference to a regulator.
1208 * @dev: device for regulator "consumer"
1209 * @id: Supply name or regulator ID.
1210 *
1211 * Returns a struct regulator corresponding to the regulator producer,
1212 * or IS_ERR() condition containing errno.
1213 *
1214 * Use of supply names configured via regulator_set_device_supply() is
1215 * strongly encouraged.  It is recommended that the supply name used
1216 * should match the name used for the supply and/or the relevant
1217 * device pins in the datasheet.
1218 */
1219struct regulator *regulator_get(struct device *dev, const char *id)
1220{
1221	return _regulator_get(dev, id, 0);
1222}
1223EXPORT_SYMBOL_GPL(regulator_get);
1224
1225/**
1226 * regulator_get_exclusive - obtain exclusive access to a regulator.
1227 * @dev: device for regulator "consumer"
1228 * @id: Supply name or regulator ID.
1229 *
1230 * Returns a struct regulator corresponding to the regulator producer,
1231 * or IS_ERR() condition containing errno.  Other consumers will be
1232 * unable to obtain this reference is held and the use count for the
1233 * regulator will be initialised to reflect the current state of the
1234 * regulator.
1235 *
1236 * This is intended for use by consumers which cannot tolerate shared
1237 * use of the regulator such as those which need to force the
1238 * regulator off for correct operation of the hardware they are
1239 * controlling.
1240 *
1241 * Use of supply names configured via regulator_set_device_supply() is
1242 * strongly encouraged.  It is recommended that the supply name used
1243 * should match the name used for the supply and/or the relevant
1244 * device pins in the datasheet.
1245 */
1246struct regulator *regulator_get_exclusive(struct device *dev, const char *id)
1247{
1248	return _regulator_get(dev, id, 1);
1249}
1250EXPORT_SYMBOL_GPL(regulator_get_exclusive);
1251
1252/**
1253 * regulator_put - "free" the regulator source
1254 * @regulator: regulator source
1255 *
1256 * Note: drivers must ensure that all regulator_enable calls made on this
1257 * regulator source are balanced by regulator_disable calls prior to calling
1258 * this function.
1259 */
1260void regulator_put(struct regulator *regulator)
1261{
1262	struct regulator_dev *rdev;
1263
1264	if (regulator == NULL || IS_ERR(regulator))
1265		return;
1266
1267	mutex_lock(&regulator_list_mutex);
1268	rdev = regulator->rdev;
1269
1270	/* remove any sysfs entries */
1271	if (regulator->dev) {
1272		sysfs_remove_link(&rdev->dev.kobj, regulator->supply_name);
1273		kfree(regulator->supply_name);
1274		device_remove_file(regulator->dev, &regulator->dev_attr);
1275		kfree(regulator->dev_attr.attr.name);
1276	}
1277	list_del(&regulator->list);
1278	kfree(regulator);
1279
1280	rdev->open_count--;
1281	rdev->exclusive = 0;
1282
1283	module_put(rdev->owner);
1284	mutex_unlock(&regulator_list_mutex);
1285}
1286EXPORT_SYMBOL_GPL(regulator_put);
1287
1288static int _regulator_can_change_status(struct regulator_dev *rdev)
1289{
1290	if (!rdev->constraints)
1291		return 0;
1292
1293	if (rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_STATUS)
1294		return 1;
1295	else
1296		return 0;
1297}
1298
1299/* locks held by regulator_enable() */
1300static int _regulator_enable(struct regulator_dev *rdev)
1301{
1302	int ret, delay;
1303
1304	if (rdev->use_count == 0) {
1305		/* do we need to enable the supply regulator first */
1306		if (rdev->supply) {
1307			mutex_lock(&rdev->supply->mutex);
1308			ret = _regulator_enable(rdev->supply);
1309			mutex_unlock(&rdev->supply->mutex);
1310			if (ret < 0) {
1311				rdev_err(rdev, "failed to enable: %d\n", ret);
1312				return ret;
1313			}
1314		}
1315	}
1316
1317	/* check voltage and requested load before enabling */
1318	if (rdev->constraints &&
1319	    (rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_DRMS))
1320		drms_uA_update(rdev);
1321
1322	if (rdev->use_count == 0) {
1323		/* The regulator may on if it's not switchable or left on */
1324		ret = _regulator_is_enabled(rdev);
1325		if (ret == -EINVAL || ret == 0) {
1326			if (!_regulator_can_change_status(rdev))
1327				return -EPERM;
1328
1329			if (!rdev->desc->ops->enable)
1330				return -EINVAL;
1331
1332			/* Query before enabling in case configuration
1333			 * dependent.  */
1334			ret = _regulator_get_enable_time(rdev);
1335			if (ret >= 0) {
1336				delay = ret;
1337			} else {
1338				rdev_warn(rdev, "enable_time() failed: %d\n",
1339					   ret);
1340				delay = 0;
1341			}
1342
1343			trace_regulator_enable(rdev_get_name(rdev));
1344
1345			/* Allow the regulator to ramp; it would be useful
1346			 * to extend this for bulk operations so that the
1347			 * regulators can ramp together.  */
1348			ret = rdev->desc->ops->enable(rdev);
1349			if (ret < 0)
1350				return ret;
1351
1352			trace_regulator_enable_delay(rdev_get_name(rdev));
1353
1354			if (delay >= 1000) {
1355				mdelay(delay / 1000);
1356				udelay(delay % 1000);
1357			} else if (delay) {
1358				udelay(delay);
1359			}
1360
1361			trace_regulator_enable_complete(rdev_get_name(rdev));
1362
1363		} else if (ret < 0) {
1364			rdev_err(rdev, "is_enabled() failed: %d\n", ret);
1365			return ret;
1366		}
1367		/* Fallthrough on positive return values - already enabled */
1368	}
1369
1370	rdev->use_count++;
1371
1372	return 0;
1373}
1374
1375/**
1376 * regulator_enable - enable regulator output
1377 * @regulator: regulator source
1378 *
1379 * Request that the regulator be enabled with the regulator output at
1380 * the predefined voltage or current value.  Calls to regulator_enable()
1381 * must be balanced with calls to regulator_disable().
1382 *
1383 * NOTE: the output value can be set by other drivers, boot loader or may be
1384 * hardwired in the regulator.
1385 */
1386int regulator_enable(struct regulator *regulator)
1387{
1388	struct regulator_dev *rdev = regulator->rdev;
1389	int ret = 0;
1390
1391	mutex_lock(&rdev->mutex);
1392	ret = _regulator_enable(rdev);
1393	mutex_unlock(&rdev->mutex);
1394	return ret;
1395}
1396EXPORT_SYMBOL_GPL(regulator_enable);
1397
1398/* locks held by regulator_disable() */
1399static int _regulator_disable(struct regulator_dev *rdev,
1400		struct regulator_dev **supply_rdev_ptr)
1401{
1402	int ret = 0;
1403	*supply_rdev_ptr = NULL;
1404
1405	if (WARN(rdev->use_count <= 0,
1406		 "unbalanced disables for %s\n", rdev_get_name(rdev)))
1407		return -EIO;
1408
1409	/* are we the last user and permitted to disable ? */
1410	if (rdev->use_count == 1 &&
1411	    (rdev->constraints && !rdev->constraints->always_on)) {
1412
1413		/* we are last user */
1414		if (_regulator_can_change_status(rdev) &&
1415		    rdev->desc->ops->disable) {
1416			trace_regulator_disable(rdev_get_name(rdev));
1417
1418			ret = rdev->desc->ops->disable(rdev);
1419			if (ret < 0) {
1420				rdev_err(rdev, "failed to disable\n");
1421				return ret;
1422			}
1423
1424			trace_regulator_disable_complete(rdev_get_name(rdev));
1425
1426			_notifier_call_chain(rdev, REGULATOR_EVENT_DISABLE,
1427					     NULL);
1428		}
1429
1430		/* decrease our supplies ref count and disable if required */
1431		*supply_rdev_ptr = rdev->supply;
1432
1433		rdev->use_count = 0;
1434	} else if (rdev->use_count > 1) {
1435
1436		if (rdev->constraints &&
1437			(rdev->constraints->valid_ops_mask &
1438			REGULATOR_CHANGE_DRMS))
1439			drms_uA_update(rdev);
1440
1441		rdev->use_count--;
1442	}
1443	return ret;
1444}
1445
1446/**
1447 * regulator_disable - disable regulator output
1448 * @regulator: regulator source
1449 *
1450 * Disable the regulator output voltage or current.  Calls to
1451 * regulator_enable() must be balanced with calls to
1452 * regulator_disable().
1453 *
1454 * NOTE: this will only disable the regulator output if no other consumer
1455 * devices have it enabled, the regulator device supports disabling and
1456 * machine constraints permit this operation.
1457 */
1458int regulator_disable(struct regulator *regulator)
1459{
1460	struct regulator_dev *rdev = regulator->rdev;
1461	struct regulator_dev *supply_rdev = NULL;
1462	int ret = 0;
1463
1464	mutex_lock(&rdev->mutex);
1465	ret = _regulator_disable(rdev, &supply_rdev);
1466	mutex_unlock(&rdev->mutex);
1467
1468	/* decrease our supplies ref count and disable if required */
1469	while (supply_rdev != NULL) {
1470		rdev = supply_rdev;
1471
1472		mutex_lock(&rdev->mutex);
1473		_regulator_disable(rdev, &supply_rdev);
1474		mutex_unlock(&rdev->mutex);
1475	}
1476
1477	return ret;
1478}
1479EXPORT_SYMBOL_GPL(regulator_disable);
1480
1481/* locks held by regulator_force_disable() */
1482static int _regulator_force_disable(struct regulator_dev *rdev,
1483		struct regulator_dev **supply_rdev_ptr)
1484{
1485	int ret = 0;
1486
1487	/* force disable */
1488	if (rdev->desc->ops->disable) {
1489		/* ah well, who wants to live forever... */
1490		ret = rdev->desc->ops->disable(rdev);
1491		if (ret < 0) {
1492			rdev_err(rdev, "failed to force disable\n");
1493			return ret;
1494		}
1495		/* notify other consumers that power has been forced off */
1496		_notifier_call_chain(rdev, REGULATOR_EVENT_FORCE_DISABLE |
1497			REGULATOR_EVENT_DISABLE, NULL);
1498	}
1499
1500	/* decrease our supplies ref count and disable if required */
1501	*supply_rdev_ptr = rdev->supply;
1502
1503	rdev->use_count = 0;
1504	return ret;
1505}
1506
1507/**
1508 * regulator_force_disable - force disable regulator output
1509 * @regulator: regulator source
1510 *
1511 * Forcibly disable the regulator output voltage or current.
1512 * NOTE: this *will* disable the regulator output even if other consumer
1513 * devices have it enabled. This should be used for situations when device
1514 * damage will likely occur if the regulator is not disabled (e.g. over temp).
1515 */
1516int regulator_force_disable(struct regulator *regulator)
1517{
1518	struct regulator_dev *rdev = regulator->rdev;
1519	struct regulator_dev *supply_rdev = NULL;
1520	int ret;
1521
1522	mutex_lock(&rdev->mutex);
1523	regulator->uA_load = 0;
1524	ret = _regulator_force_disable(rdev, &supply_rdev);
1525	mutex_unlock(&rdev->mutex);
1526
1527	if (supply_rdev)
1528		regulator_disable(get_device_regulator(rdev_get_dev(supply_rdev)));
1529
1530	return ret;
1531}
1532EXPORT_SYMBOL_GPL(regulator_force_disable);
1533
1534static int _regulator_is_enabled(struct regulator_dev *rdev)
1535{
1536	/* If we don't know then assume that the regulator is always on */
1537	if (!rdev->desc->ops->is_enabled)
1538		return 1;
1539
1540	return rdev->desc->ops->is_enabled(rdev);
1541}
1542
1543/**
1544 * regulator_is_enabled - is the regulator output enabled
1545 * @regulator: regulator source
1546 *
1547 * Returns positive if the regulator driver backing the source/client
1548 * has requested that the device be enabled, zero if it hasn't, else a
1549 * negative errno code.
1550 *
1551 * Note that the device backing this regulator handle can have multiple
1552 * users, so it might be enabled even if regulator_enable() was never
1553 * called for this particular source.
1554 */
1555int regulator_is_enabled(struct regulator *regulator)
1556{
1557	int ret;
1558
1559	mutex_lock(&regulator->rdev->mutex);
1560	ret = _regulator_is_enabled(regulator->rdev);
1561	mutex_unlock(&regulator->rdev->mutex);
1562
1563	return ret;
1564}
1565EXPORT_SYMBOL_GPL(regulator_is_enabled);
1566
1567/**
1568 * regulator_count_voltages - count regulator_list_voltage() selectors
1569 * @regulator: regulator source
1570 *
1571 * Returns number of selectors, or negative errno.  Selectors are
1572 * numbered starting at zero, and typically correspond to bitfields
1573 * in hardware registers.
1574 */
1575int regulator_count_voltages(struct regulator *regulator)
1576{
1577	struct regulator_dev	*rdev = regulator->rdev;
1578
1579	return rdev->desc->n_voltages ? : -EINVAL;
1580}
1581EXPORT_SYMBOL_GPL(regulator_count_voltages);
1582
1583/**
1584 * regulator_list_voltage - enumerate supported voltages
1585 * @regulator: regulator source
1586 * @selector: identify voltage to list
1587 * Context: can sleep
1588 *
1589 * Returns a voltage that can be passed to @regulator_set_voltage(),
1590 * zero if this selector code can't be used on this system, or a
1591 * negative errno.
1592 */
1593int regulator_list_voltage(struct regulator *regulator, unsigned selector)
1594{
1595	struct regulator_dev	*rdev = regulator->rdev;
1596	struct regulator_ops	*ops = rdev->desc->ops;
1597	int			ret;
1598
1599	if (!ops->list_voltage || selector >= rdev->desc->n_voltages)
1600		return -EINVAL;
1601
1602	mutex_lock(&rdev->mutex);
1603	ret = ops->list_voltage(rdev, selector);
1604	mutex_unlock(&rdev->mutex);
1605
1606	if (ret > 0) {
1607		if (ret < rdev->constraints->min_uV)
1608			ret = 0;
1609		else if (ret > rdev->constraints->max_uV)
1610			ret = 0;
1611	}
1612
1613	return ret;
1614}
1615EXPORT_SYMBOL_GPL(regulator_list_voltage);
1616
1617/**
1618 * regulator_is_supported_voltage - check if a voltage range can be supported
1619 *
1620 * @regulator: Regulator to check.
1621 * @min_uV: Minimum required voltage in uV.
1622 * @max_uV: Maximum required voltage in uV.
1623 *
1624 * Returns a boolean or a negative error code.
1625 */
1626int regulator_is_supported_voltage(struct regulator *regulator,
1627				   int min_uV, int max_uV)
1628{
1629	int i, voltages, ret;
1630
1631	ret = regulator_count_voltages(regulator);
1632	if (ret < 0)
1633		return ret;
1634	voltages = ret;
1635
1636	for (i = 0; i < voltages; i++) {
1637		ret = regulator_list_voltage(regulator, i);
1638
1639		if (ret >= min_uV && ret <= max_uV)
1640			return 1;
1641	}
1642
1643	return 0;
1644}
1645
1646static int _regulator_do_set_voltage(struct regulator_dev *rdev,
1647				     int min_uV, int max_uV)
1648{
1649	int ret;
1650	int delay = 0;
1651	unsigned int selector;
1652
1653	trace_regulator_set_voltage(rdev_get_name(rdev), min_uV, max_uV);
1654
1655	min_uV += rdev->constraints->uV_offset;
1656	max_uV += rdev->constraints->uV_offset;
1657
1658	if (rdev->desc->ops->set_voltage) {
1659		ret = rdev->desc->ops->set_voltage(rdev, min_uV, max_uV,
1660						   &selector);
1661
1662		if (rdev->desc->ops->list_voltage)
1663			selector = rdev->desc->ops->list_voltage(rdev,
1664								 selector);
1665		else
1666			selector = -1;
1667	} else if (rdev->desc->ops->set_voltage_sel) {
1668		int best_val = INT_MAX;
1669		int i;
1670
1671		selector = 0;
1672
1673		/* Find the smallest voltage that falls within the specified
1674		 * range.
1675		 */
1676		for (i = 0; i < rdev->desc->n_voltages; i++) {
1677			ret = rdev->desc->ops->list_voltage(rdev, i);
1678			if (ret < 0)
1679				continue;
1680
1681			if (ret < best_val && ret >= min_uV && ret <= max_uV) {
1682				best_val = ret;
1683				selector = i;
1684			}
1685		}
1686
1687		/*
1688		 * If we can't obtain the old selector there is not enough
1689		 * info to call set_voltage_time_sel().
1690		 */
1691		if (rdev->desc->ops->set_voltage_time_sel &&
1692		    rdev->desc->ops->get_voltage_sel) {
1693			unsigned int old_selector = 0;
1694
1695			ret = rdev->desc->ops->get_voltage_sel(rdev);
1696			if (ret < 0)
1697				return ret;
1698			old_selector = ret;
1699			delay = rdev->desc->ops->set_voltage_time_sel(rdev,
1700						old_selector, selector);
1701		}
1702
1703		if (best_val != INT_MAX) {
1704			ret = rdev->desc->ops->set_voltage_sel(rdev, selector);
1705			selector = best_val;
1706		} else {
1707			ret = -EINVAL;
1708		}
1709	} else {
1710		ret = -EINVAL;
1711	}
1712
1713	/* Insert any necessary delays */
1714	if (delay >= 1000) {
1715		mdelay(delay / 1000);
1716		udelay(delay % 1000);
1717	} else if (delay) {
1718		udelay(delay);
1719	}
1720
1721	if (ret == 0)
1722		_notifier_call_chain(rdev, REGULATOR_EVENT_VOLTAGE_CHANGE,
1723				     NULL);
1724
1725	trace_regulator_set_voltage_complete(rdev_get_name(rdev), selector);
1726
1727	return ret;
1728}
1729
1730/**
1731 * regulator_set_voltage - set regulator output voltage
1732 * @regulator: regulator source
1733 * @min_uV: Minimum required voltage in uV
1734 * @max_uV: Maximum acceptable voltage in uV
1735 *
1736 * Sets a voltage regulator to the desired output voltage. This can be set
1737 * during any regulator state. IOW, regulator can be disabled or enabled.
1738 *
1739 * If the regulator is enabled then the voltage will change to the new value
1740 * immediately otherwise if the regulator is disabled the regulator will
1741 * output at the new voltage when enabled.
1742 *
1743 * NOTE: If the regulator is shared between several devices then the lowest
1744 * request voltage that meets the system constraints will be used.
1745 * Regulator system constraints must be set for this regulator before
1746 * calling this function otherwise this call will fail.
1747 */
1748int regulator_set_voltage(struct regulator *regulator, int min_uV, int max_uV)
1749{
1750	struct regulator_dev *rdev = regulator->rdev;
1751	int ret = 0;
1752
1753	mutex_lock(&rdev->mutex);
1754
1755	/* If we're setting the same range as last time the change
1756	 * should be a noop (some cpufreq implementations use the same
1757	 * voltage for multiple frequencies, for example).
1758	 */
1759	if (regulator->min_uV == min_uV && regulator->max_uV == max_uV)
1760		goto out;
1761
1762	/* sanity check */
1763	if (!rdev->desc->ops->set_voltage &&
1764	    !rdev->desc->ops->set_voltage_sel) {
1765		ret = -EINVAL;
1766		goto out;
1767	}
1768
1769	/* constraints check */
1770	ret = regulator_check_voltage(rdev, &min_uV, &max_uV);
1771	if (ret < 0)
1772		goto out;
1773	regulator->min_uV = min_uV;
1774	regulator->max_uV = max_uV;
1775
1776	ret = regulator_check_consumers(rdev, &min_uV, &max_uV);
1777	if (ret < 0)
1778		goto out;
1779
1780	ret = _regulator_do_set_voltage(rdev, min_uV, max_uV);
1781
1782out:
1783	mutex_unlock(&rdev->mutex);
1784	return ret;
1785}
1786EXPORT_SYMBOL_GPL(regulator_set_voltage);
1787
1788/**
1789 * regulator_set_voltage_time - get raise/fall time
1790 * @regulator: regulator source
1791 * @old_uV: starting voltage in microvolts
1792 * @new_uV: target voltage in microvolts
1793 *
1794 * Provided with the starting and ending voltage, this function attempts to
1795 * calculate the time in microseconds required to rise or fall to this new
1796 * voltage.
1797 */
1798int regulator_set_voltage_time(struct regulator *regulator,
1799			       int old_uV, int new_uV)
1800{
1801	struct regulator_dev	*rdev = regulator->rdev;
1802	struct regulator_ops	*ops = rdev->desc->ops;
1803	int old_sel = -1;
1804	int new_sel = -1;
1805	int voltage;
1806	int i;
1807
1808	/* Currently requires operations to do this */
1809	if (!ops->list_voltage || !ops->set_voltage_time_sel
1810	    || !rdev->desc->n_voltages)
1811		return -EINVAL;
1812
1813	for (i = 0; i < rdev->desc->n_voltages; i++) {
1814		/* We only look for exact voltage matches here */
1815		voltage = regulator_list_voltage(regulator, i);
1816		if (voltage < 0)
1817			return -EINVAL;
1818		if (voltage == 0)
1819			continue;
1820		if (voltage == old_uV)
1821			old_sel = i;
1822		if (voltage == new_uV)
1823			new_sel = i;
1824	}
1825
1826	if (old_sel < 0 || new_sel < 0)
1827		return -EINVAL;
1828
1829	return ops->set_voltage_time_sel(rdev, old_sel, new_sel);
1830}
1831EXPORT_SYMBOL_GPL(regulator_set_voltage_time);
1832
1833/**
1834 * regulator_sync_voltage - re-apply last regulator output voltage
1835 * @regulator: regulator source
1836 *
1837 * Re-apply the last configured voltage.  This is intended to be used
1838 * where some external control source the consumer is cooperating with
1839 * has caused the configured voltage to change.
1840 */
1841int regulator_sync_voltage(struct regulator *regulator)
1842{
1843	struct regulator_dev *rdev = regulator->rdev;
1844	int ret, min_uV, max_uV;
1845
1846	mutex_lock(&rdev->mutex);
1847
1848	if (!rdev->desc->ops->set_voltage &&
1849	    !rdev->desc->ops->set_voltage_sel) {
1850		ret = -EINVAL;
1851		goto out;
1852	}
1853
1854	/* This is only going to work if we've had a voltage configured. */
1855	if (!regulator->min_uV && !regulator->max_uV) {
1856		ret = -EINVAL;
1857		goto out;
1858	}
1859
1860	min_uV = regulator->min_uV;
1861	max_uV = regulator->max_uV;
1862
1863	/* This should be a paranoia check... */
1864	ret = regulator_check_voltage(rdev, &min_uV, &max_uV);
1865	if (ret < 0)
1866		goto out;
1867
1868	ret = regulator_check_consumers(rdev, &min_uV, &max_uV);
1869	if (ret < 0)
1870		goto out;
1871
1872	ret = _regulator_do_set_voltage(rdev, min_uV, max_uV);
1873
1874out:
1875	mutex_unlock(&rdev->mutex);
1876	return ret;
1877}
1878EXPORT_SYMBOL_GPL(regulator_sync_voltage);
1879
1880static int _regulator_get_voltage(struct regulator_dev *rdev)
1881{
1882	int sel, ret;
1883
1884	if (rdev->desc->ops->get_voltage_sel) {
1885		sel = rdev->desc->ops->get_voltage_sel(rdev);
1886		if (sel < 0)
1887			return sel;
1888		ret = rdev->desc->ops->list_voltage(rdev, sel);
1889	} else if (rdev->desc->ops->get_voltage) {
1890		ret = rdev->desc->ops->get_voltage(rdev);
1891	} else {
1892		return -EINVAL;
1893	}
1894
1895	if (ret < 0)
1896		return ret;
1897	return ret - rdev->constraints->uV_offset;
1898}
1899
1900/**
1901 * regulator_get_voltage - get regulator output voltage
1902 * @regulator: regulator source
1903 *
1904 * This r…

Large files files are truncated, but you can click here to view the full file