core.c 69.9 KB
Newer Older
1 2 3 4
/*
 * core.c  --  Voltage/Current Regulator framework.
 *
 * Copyright 2007, 2008 Wolfson Microelectronics PLC.
5
 * Copyright 2008 SlimLogic Ltd.
6
 *
7
 * Author: Liam Girdwood <lrg@slimlogic.co.uk>
8 9 10 11 12 13 14 15
 *
 *  This program is free software; you can redistribute  it and/or modify it
 *  under  the terms of  the GNU General  Public License as published by the
 *  Free Software Foundation;  either version 2 of the  License, or (at your
 *  option) any later version.
 *
 */

16
#define pr_fmt(fmt) "%s: " fmt, __func__
17

18 19 20
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/device.h>
21
#include <linux/slab.h>
22 23 24
#include <linux/err.h>
#include <linux/mutex.h>
#include <linux/suspend.h>
25
#include <linux/delay.h>
26 27 28 29
#include <linux/regulator/consumer.h>
#include <linux/regulator/driver.h>
#include <linux/regulator/machine.h>

30 31 32
#define CREATE_TRACE_POINTS
#include <trace/events/regulator.h>

33 34
#include "dummy.h"

35 36 37 38 39 40 41 42 43
#define rdev_err(rdev, fmt, ...)					\
	pr_err("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
#define rdev_warn(rdev, fmt, ...)					\
	pr_warn("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
#define rdev_info(rdev, fmt, ...)					\
	pr_info("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
#define rdev_dbg(rdev, fmt, ...)					\
	pr_debug("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)

44 45 46
static DEFINE_MUTEX(regulator_list_mutex);
static LIST_HEAD(regulator_list);
static LIST_HEAD(regulator_map_list);
47
static int has_full_constraints;
48
static bool board_wants_dummy_regulator;
49

50
/*
51 52 53 54 55 56
 * struct regulator_map
 *
 * Used to provide symbolic supply names to devices.
 */
struct regulator_map {
	struct list_head list;
57
	const char *dev_name;   /* The dev_name() for the consumer */
58
	const char *supply;
59
	struct regulator_dev *regulator;
60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78
};

/*
 * struct regulator
 *
 * One for each consumer device.
 */
struct regulator {
	struct device *dev;
	struct list_head list;
	int uA_load;
	int min_uV;
	int max_uV;
	char *supply_name;
	struct device_attribute dev_attr;
	struct regulator_dev *rdev;
};

static int _regulator_is_enabled(struct regulator_dev *rdev);
79 80
static int _regulator_disable(struct regulator_dev *rdev,
		struct regulator_dev **supply_rdev_ptr);
81 82 83 84 85
static int _regulator_get_voltage(struct regulator_dev *rdev);
static int _regulator_get_current_limit(struct regulator_dev *rdev);
static unsigned int _regulator_get_mode(struct regulator_dev *rdev);
static void _notifier_call_chain(struct regulator_dev *rdev,
				  unsigned long event, void *data);
86 87
static int _regulator_do_set_voltage(struct regulator_dev *rdev,
				     int min_uV, int max_uV);
88

89 90 91 92 93 94 95 96 97 98
static const char *rdev_get_name(struct regulator_dev *rdev)
{
	if (rdev->constraints && rdev->constraints->name)
		return rdev->constraints->name;
	else if (rdev->desc->name)
		return rdev->desc->name;
	else
		return "";
}

99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127
/* gets the regulator for a given consumer device */
static struct regulator *get_device_regulator(struct device *dev)
{
	struct regulator *regulator = NULL;
	struct regulator_dev *rdev;

	mutex_lock(&regulator_list_mutex);
	list_for_each_entry(rdev, &regulator_list, list) {
		mutex_lock(&rdev->mutex);
		list_for_each_entry(regulator, &rdev->consumer_list, list) {
			if (regulator->dev == dev) {
				mutex_unlock(&rdev->mutex);
				mutex_unlock(&regulator_list_mutex);
				return regulator;
			}
		}
		mutex_unlock(&rdev->mutex);
	}
	mutex_unlock(&regulator_list_mutex);
	return NULL;
}

/* Platform voltage constraint check */
static int regulator_check_voltage(struct regulator_dev *rdev,
				   int *min_uV, int *max_uV)
{
	BUG_ON(*min_uV > *max_uV);

	if (!rdev->constraints) {
128
		rdev_err(rdev, "no constraints\n");
129 130 131
		return -ENODEV;
	}
	if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_VOLTAGE)) {
132
		rdev_err(rdev, "operation not allowed\n");
133 134 135 136 137 138 139 140 141 142 143 144 145 146
		return -EPERM;
	}

	if (*max_uV > rdev->constraints->max_uV)
		*max_uV = rdev->constraints->max_uV;
	if (*min_uV < rdev->constraints->min_uV)
		*min_uV = rdev->constraints->min_uV;

	if (*min_uV > *max_uV)
		return -EINVAL;

	return 0;
}

147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167
/* Make sure we select a voltage that suits the needs of all
 * regulator consumers
 */
static int regulator_check_consumers(struct regulator_dev *rdev,
				     int *min_uV, int *max_uV)
{
	struct regulator *regulator;

	list_for_each_entry(regulator, &rdev->consumer_list, list) {
		if (*max_uV > regulator->max_uV)
			*max_uV = regulator->max_uV;
		if (*min_uV < regulator->min_uV)
			*min_uV = regulator->min_uV;
	}

	if (*min_uV > *max_uV)
		return -EINVAL;

	return 0;
}

168 169 170 171 172 173 174
/* current constraint check */
static int regulator_check_current_limit(struct regulator_dev *rdev,
					int *min_uA, int *max_uA)
{
	BUG_ON(*min_uA > *max_uA);

	if (!rdev->constraints) {
175
		rdev_err(rdev, "no constraints\n");
176 177 178
		return -ENODEV;
	}
	if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_CURRENT)) {
179
		rdev_err(rdev, "operation not allowed\n");
180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196
		return -EPERM;
	}

	if (*max_uA > rdev->constraints->max_uA)
		*max_uA = rdev->constraints->max_uA;
	if (*min_uA < rdev->constraints->min_uA)
		*min_uA = rdev->constraints->min_uA;

	if (*min_uA > *max_uA)
		return -EINVAL;

	return 0;
}

/* operating mode constraint check */
static int regulator_check_mode(struct regulator_dev *rdev, int mode)
{
197 198 199 200 201 202 203 204 205 206
	switch (mode) {
	case REGULATOR_MODE_FAST:
	case REGULATOR_MODE_NORMAL:
	case REGULATOR_MODE_IDLE:
	case REGULATOR_MODE_STANDBY:
		break;
	default:
		return -EINVAL;
	}

207
	if (!rdev->constraints) {
208
		rdev_err(rdev, "no constraints\n");
209 210 211
		return -ENODEV;
	}
	if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_MODE)) {
212
		rdev_err(rdev, "operation not allowed\n");
213 214 215
		return -EPERM;
	}
	if (!(rdev->constraints->valid_modes_mask & mode)) {
216
		rdev_err(rdev, "invalid mode %x\n", mode);
217 218 219 220 221 222 223 224 225
		return -EINVAL;
	}
	return 0;
}

/* dynamic regulator mode switching constraint check */
static int regulator_check_drms(struct regulator_dev *rdev)
{
	if (!rdev->constraints) {
226
		rdev_err(rdev, "no constraints\n");
227 228 229
		return -ENODEV;
	}
	if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_DRMS)) {
230
		rdev_err(rdev, "operation not allowed\n");
231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250
		return -EPERM;
	}
	return 0;
}

static ssize_t device_requested_uA_show(struct device *dev,
			     struct device_attribute *attr, char *buf)
{
	struct regulator *regulator;

	regulator = get_device_regulator(dev);
	if (regulator == NULL)
		return 0;

	return sprintf(buf, "%d\n", regulator->uA_load);
}

static ssize_t regulator_uV_show(struct device *dev,
				struct device_attribute *attr, char *buf)
{
251
	struct regulator_dev *rdev = dev_get_drvdata(dev);
252 253 254 255 256 257 258 259
	ssize_t ret;

	mutex_lock(&rdev->mutex);
	ret = sprintf(buf, "%d\n", _regulator_get_voltage(rdev));
	mutex_unlock(&rdev->mutex);

	return ret;
}
260
static DEVICE_ATTR(microvolts, 0444, regulator_uV_show, NULL);
261 262 263 264

static ssize_t regulator_uA_show(struct device *dev,
				struct device_attribute *attr, char *buf)
{
265
	struct regulator_dev *rdev = dev_get_drvdata(dev);
266 267 268

	return sprintf(buf, "%d\n", _regulator_get_current_limit(rdev));
}
269
static DEVICE_ATTR(microamps, 0444, regulator_uA_show, NULL);
270

271 272 273 274 275
static ssize_t regulator_name_show(struct device *dev,
			     struct device_attribute *attr, char *buf)
{
	struct regulator_dev *rdev = dev_get_drvdata(dev);

276
	return sprintf(buf, "%s\n", rdev_get_name(rdev));
277 278
}

D
David Brownell 已提交
279
static ssize_t regulator_print_opmode(char *buf, int mode)
280 281 282 283 284 285 286 287 288 289 290 291 292 293
{
	switch (mode) {
	case REGULATOR_MODE_FAST:
		return sprintf(buf, "fast\n");
	case REGULATOR_MODE_NORMAL:
		return sprintf(buf, "normal\n");
	case REGULATOR_MODE_IDLE:
		return sprintf(buf, "idle\n");
	case REGULATOR_MODE_STANDBY:
		return sprintf(buf, "standby\n");
	}
	return sprintf(buf, "unknown\n");
}

D
David Brownell 已提交
294 295
static ssize_t regulator_opmode_show(struct device *dev,
				    struct device_attribute *attr, char *buf)
296
{
297
	struct regulator_dev *rdev = dev_get_drvdata(dev);
298

D
David Brownell 已提交
299 300
	return regulator_print_opmode(buf, _regulator_get_mode(rdev));
}
301
static DEVICE_ATTR(opmode, 0444, regulator_opmode_show, NULL);
D
David Brownell 已提交
302 303 304

static ssize_t regulator_print_state(char *buf, int state)
{
305 306 307 308 309 310 311 312
	if (state > 0)
		return sprintf(buf, "enabled\n");
	else if (state == 0)
		return sprintf(buf, "disabled\n");
	else
		return sprintf(buf, "unknown\n");
}

D
David Brownell 已提交
313 314 315 316
static ssize_t regulator_state_show(struct device *dev,
				   struct device_attribute *attr, char *buf)
{
	struct regulator_dev *rdev = dev_get_drvdata(dev);
317 318 319 320 321
	ssize_t ret;

	mutex_lock(&rdev->mutex);
	ret = regulator_print_state(buf, _regulator_is_enabled(rdev));
	mutex_unlock(&rdev->mutex);
D
David Brownell 已提交
322

323
	return ret;
D
David Brownell 已提交
324
}
325
static DEVICE_ATTR(state, 0444, regulator_state_show, NULL);
D
David Brownell 已提交
326

D
David Brownell 已提交
327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367
static ssize_t regulator_status_show(struct device *dev,
				   struct device_attribute *attr, char *buf)
{
	struct regulator_dev *rdev = dev_get_drvdata(dev);
	int status;
	char *label;

	status = rdev->desc->ops->get_status(rdev);
	if (status < 0)
		return status;

	switch (status) {
	case REGULATOR_STATUS_OFF:
		label = "off";
		break;
	case REGULATOR_STATUS_ON:
		label = "on";
		break;
	case REGULATOR_STATUS_ERROR:
		label = "error";
		break;
	case REGULATOR_STATUS_FAST:
		label = "fast";
		break;
	case REGULATOR_STATUS_NORMAL:
		label = "normal";
		break;
	case REGULATOR_STATUS_IDLE:
		label = "idle";
		break;
	case REGULATOR_STATUS_STANDBY:
		label = "standby";
		break;
	default:
		return -ERANGE;
	}

	return sprintf(buf, "%s\n", label);
}
static DEVICE_ATTR(status, 0444, regulator_status_show, NULL);

368 369 370
static ssize_t regulator_min_uA_show(struct device *dev,
				    struct device_attribute *attr, char *buf)
{
371
	struct regulator_dev *rdev = dev_get_drvdata(dev);
372 373 374 375 376 377

	if (!rdev->constraints)
		return sprintf(buf, "constraint not defined\n");

	return sprintf(buf, "%d\n", rdev->constraints->min_uA);
}
378
static DEVICE_ATTR(min_microamps, 0444, regulator_min_uA_show, NULL);
379 380 381 382

static ssize_t regulator_max_uA_show(struct device *dev,
				    struct device_attribute *attr, char *buf)
{
383
	struct regulator_dev *rdev = dev_get_drvdata(dev);
384 385 386 387 388 389

	if (!rdev->constraints)
		return sprintf(buf, "constraint not defined\n");

	return sprintf(buf, "%d\n", rdev->constraints->max_uA);
}
390
static DEVICE_ATTR(max_microamps, 0444, regulator_max_uA_show, NULL);
391 392 393 394

static ssize_t regulator_min_uV_show(struct device *dev,
				    struct device_attribute *attr, char *buf)
{
395
	struct regulator_dev *rdev = dev_get_drvdata(dev);
396 397 398 399 400 401

	if (!rdev->constraints)
		return sprintf(buf, "constraint not defined\n");

	return sprintf(buf, "%d\n", rdev->constraints->min_uV);
}
402
static DEVICE_ATTR(min_microvolts, 0444, regulator_min_uV_show, NULL);
403 404 405 406

static ssize_t regulator_max_uV_show(struct device *dev,
				    struct device_attribute *attr, char *buf)
{
407
	struct regulator_dev *rdev = dev_get_drvdata(dev);
408 409 410 411 412 413

	if (!rdev->constraints)
		return sprintf(buf, "constraint not defined\n");

	return sprintf(buf, "%d\n", rdev->constraints->max_uV);
}
414
static DEVICE_ATTR(max_microvolts, 0444, regulator_max_uV_show, NULL);
415 416 417 418

static ssize_t regulator_total_uA_show(struct device *dev,
				      struct device_attribute *attr, char *buf)
{
419
	struct regulator_dev *rdev = dev_get_drvdata(dev);
420 421 422 423 424
	struct regulator *regulator;
	int uA = 0;

	mutex_lock(&rdev->mutex);
	list_for_each_entry(regulator, &rdev->consumer_list, list)
425
		uA += regulator->uA_load;
426 427 428
	mutex_unlock(&rdev->mutex);
	return sprintf(buf, "%d\n", uA);
}
429
static DEVICE_ATTR(requested_microamps, 0444, regulator_total_uA_show, NULL);
430 431 432 433

static ssize_t regulator_num_users_show(struct device *dev,
				      struct device_attribute *attr, char *buf)
{
434
	struct regulator_dev *rdev = dev_get_drvdata(dev);
435 436 437 438 439 440
	return sprintf(buf, "%d\n", rdev->use_count);
}

static ssize_t regulator_type_show(struct device *dev,
				  struct device_attribute *attr, char *buf)
{
441
	struct regulator_dev *rdev = dev_get_drvdata(dev);
442 443 444 445 446 447 448 449 450 451 452 453 454

	switch (rdev->desc->type) {
	case REGULATOR_VOLTAGE:
		return sprintf(buf, "voltage\n");
	case REGULATOR_CURRENT:
		return sprintf(buf, "current\n");
	}
	return sprintf(buf, "unknown\n");
}

static ssize_t regulator_suspend_mem_uV_show(struct device *dev,
				struct device_attribute *attr, char *buf)
{
455
	struct regulator_dev *rdev = dev_get_drvdata(dev);
456 457 458

	return sprintf(buf, "%d\n", rdev->constraints->state_mem.uV);
}
459 460
static DEVICE_ATTR(suspend_mem_microvolts, 0444,
		regulator_suspend_mem_uV_show, NULL);
461 462 463 464

static ssize_t regulator_suspend_disk_uV_show(struct device *dev,
				struct device_attribute *attr, char *buf)
{
465
	struct regulator_dev *rdev = dev_get_drvdata(dev);
466 467 468

	return sprintf(buf, "%d\n", rdev->constraints->state_disk.uV);
}
469 470
static DEVICE_ATTR(suspend_disk_microvolts, 0444,
		regulator_suspend_disk_uV_show, NULL);
471 472 473 474

static ssize_t regulator_suspend_standby_uV_show(struct device *dev,
				struct device_attribute *attr, char *buf)
{
475
	struct regulator_dev *rdev = dev_get_drvdata(dev);
476 477 478

	return sprintf(buf, "%d\n", rdev->constraints->state_standby.uV);
}
479 480
static DEVICE_ATTR(suspend_standby_microvolts, 0444,
		regulator_suspend_standby_uV_show, NULL);
481 482 483 484

static ssize_t regulator_suspend_mem_mode_show(struct device *dev,
				struct device_attribute *attr, char *buf)
{
485
	struct regulator_dev *rdev = dev_get_drvdata(dev);
486

D
David Brownell 已提交
487 488
	return regulator_print_opmode(buf,
		rdev->constraints->state_mem.mode);
489
}
490 491
static DEVICE_ATTR(suspend_mem_mode, 0444,
		regulator_suspend_mem_mode_show, NULL);
492 493 494 495

static ssize_t regulator_suspend_disk_mode_show(struct device *dev,
				struct device_attribute *attr, char *buf)
{
496
	struct regulator_dev *rdev = dev_get_drvdata(dev);
497

D
David Brownell 已提交
498 499
	return regulator_print_opmode(buf,
		rdev->constraints->state_disk.mode);
500
}
501 502
static DEVICE_ATTR(suspend_disk_mode, 0444,
		regulator_suspend_disk_mode_show, NULL);
503 504 505 506

static ssize_t regulator_suspend_standby_mode_show(struct device *dev,
				struct device_attribute *attr, char *buf)
{
507
	struct regulator_dev *rdev = dev_get_drvdata(dev);
508

D
David Brownell 已提交
509 510
	return regulator_print_opmode(buf,
		rdev->constraints->state_standby.mode);
511
}
512 513
static DEVICE_ATTR(suspend_standby_mode, 0444,
		regulator_suspend_standby_mode_show, NULL);
514 515 516 517

static ssize_t regulator_suspend_mem_state_show(struct device *dev,
				   struct device_attribute *attr, char *buf)
{
518
	struct regulator_dev *rdev = dev_get_drvdata(dev);
519

D
David Brownell 已提交
520 521
	return regulator_print_state(buf,
			rdev->constraints->state_mem.enabled);
522
}
523 524
static DEVICE_ATTR(suspend_mem_state, 0444,
		regulator_suspend_mem_state_show, NULL);
525 526 527 528

static ssize_t regulator_suspend_disk_state_show(struct device *dev,
				   struct device_attribute *attr, char *buf)
{
529
	struct regulator_dev *rdev = dev_get_drvdata(dev);
530

D
David Brownell 已提交
531 532
	return regulator_print_state(buf,
			rdev->constraints->state_disk.enabled);
533
}
534 535
static DEVICE_ATTR(suspend_disk_state, 0444,
		regulator_suspend_disk_state_show, NULL);
536 537 538 539

static ssize_t regulator_suspend_standby_state_show(struct device *dev,
				   struct device_attribute *attr, char *buf)
{
540
	struct regulator_dev *rdev = dev_get_drvdata(dev);
541

D
David Brownell 已提交
542 543
	return regulator_print_state(buf,
			rdev->constraints->state_standby.enabled);
544
}
545 546 547
static DEVICE_ATTR(suspend_standby_state, 0444,
		regulator_suspend_standby_state_show, NULL);

548

549 550 551 552
/*
 * These are the only attributes are present for all regulators.
 * Other attributes are a function of regulator functionality.
 */
553
static struct device_attribute regulator_dev_attrs[] = {
554
	__ATTR(name, 0444, regulator_name_show, NULL),
555 556 557 558 559 560 561
	__ATTR(num_users, 0444, regulator_num_users_show, NULL),
	__ATTR(type, 0444, regulator_type_show, NULL),
	__ATTR_NULL,
};

static void regulator_dev_release(struct device *dev)
{
562
	struct regulator_dev *rdev = dev_get_drvdata(dev);
563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581
	kfree(rdev);
}

static struct class regulator_class = {
	.name = "regulator",
	.dev_release = regulator_dev_release,
	.dev_attrs = regulator_dev_attrs,
};

/* Calculate the new optimum regulator operating mode based on the new total
 * consumer load. All locks held by caller */
static void drms_uA_update(struct regulator_dev *rdev)
{
	struct regulator *sibling;
	int current_uA = 0, output_uV, input_uV, err;
	unsigned int mode;

	err = regulator_check_drms(rdev);
	if (err < 0 || !rdev->desc->ops->get_optimum_mode ||
582 583 584
	    (!rdev->desc->ops->get_voltage &&
	     !rdev->desc->ops->get_voltage_sel) ||
	    !rdev->desc->ops->set_mode)
585
		return;
586 587

	/* get output voltage */
588
	output_uV = _regulator_get_voltage(rdev);
589 590 591 592
	if (output_uV <= 0)
		return;

	/* get input voltage */
593 594 595 596
	input_uV = 0;
	if (rdev->supply)
		input_uV = _regulator_get_voltage(rdev);
	if (input_uV <= 0)
597 598 599 600 601 602
		input_uV = rdev->constraints->input_uV;
	if (input_uV <= 0)
		return;

	/* calc total requested load */
	list_for_each_entry(sibling, &rdev->consumer_list, list)
603
		current_uA += sibling->uA_load;
604 605 606 607 608 609 610 611 612 613 614 615 616 617 618

	/* now get the optimum mode for our new total regulator load */
	mode = rdev->desc->ops->get_optimum_mode(rdev, input_uV,
						  output_uV, current_uA);

	/* check the new mode is allowed */
	err = regulator_check_mode(rdev, mode);
	if (err == 0)
		rdev->desc->ops->set_mode(rdev, mode);
}

static int suspend_set_state(struct regulator_dev *rdev,
	struct regulator_state *rstate)
{
	int ret = 0;
619 620 621 622 623 624 625 626 627 628 629
	bool can_set_state;

	can_set_state = rdev->desc->ops->set_suspend_enable &&
		rdev->desc->ops->set_suspend_disable;

	/* If we have no suspend mode configration don't set anything;
	 * only warn if the driver actually makes the suspend mode
	 * configurable.
	 */
	if (!rstate->enabled && !rstate->disabled) {
		if (can_set_state)
630
			rdev_warn(rdev, "No configuration\n");
631 632 633 634
		return 0;
	}

	if (rstate->enabled && rstate->disabled) {
635
		rdev_err(rdev, "invalid configuration\n");
636 637
		return -EINVAL;
	}
638

639
	if (!can_set_state) {
640
		rdev_err(rdev, "no way to set suspend state\n");
641
		return -EINVAL;
642
	}
643 644 645 646 647 648

	if (rstate->enabled)
		ret = rdev->desc->ops->set_suspend_enable(rdev);
	else
		ret = rdev->desc->ops->set_suspend_disable(rdev);
	if (ret < 0) {
649
		rdev_err(rdev, "failed to enabled/disable\n");
650 651 652 653 654 655
		return ret;
	}

	if (rdev->desc->ops->set_suspend_voltage && rstate->uV > 0) {
		ret = rdev->desc->ops->set_suspend_voltage(rdev, rstate->uV);
		if (ret < 0) {
656
			rdev_err(rdev, "failed to set voltage\n");
657 658 659 660 661 662 663
			return ret;
		}
	}

	if (rdev->desc->ops->set_suspend_mode && rstate->mode > 0) {
		ret = rdev->desc->ops->set_suspend_mode(rdev, rstate->mode);
		if (ret < 0) {
664
			rdev_err(rdev, "failed to set mode\n");
665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694
			return ret;
		}
	}
	return ret;
}

/* locks held by caller */
static int suspend_prepare(struct regulator_dev *rdev, suspend_state_t state)
{
	if (!rdev->constraints)
		return -EINVAL;

	switch (state) {
	case PM_SUSPEND_STANDBY:
		return suspend_set_state(rdev,
			&rdev->constraints->state_standby);
	case PM_SUSPEND_MEM:
		return suspend_set_state(rdev,
			&rdev->constraints->state_mem);
	case PM_SUSPEND_MAX:
		return suspend_set_state(rdev,
			&rdev->constraints->state_disk);
	default:
		return -EINVAL;
	}
}

static void print_constraints(struct regulator_dev *rdev)
{
	struct regulation_constraints *constraints = rdev->constraints;
695
	char buf[80] = "";
696 697
	int count = 0;
	int ret;
698

699
	if (constraints->min_uV && constraints->max_uV) {
700
		if (constraints->min_uV == constraints->max_uV)
701 702
			count += sprintf(buf + count, "%d mV ",
					 constraints->min_uV / 1000);
703
		else
704 705 706 707 708 709 710 711 712 713 714 715 716
			count += sprintf(buf + count, "%d <--> %d mV ",
					 constraints->min_uV / 1000,
					 constraints->max_uV / 1000);
	}

	if (!constraints->min_uV ||
	    constraints->min_uV != constraints->max_uV) {
		ret = _regulator_get_voltage(rdev);
		if (ret > 0)
			count += sprintf(buf + count, "at %d mV ", ret / 1000);
	}

	if (constraints->min_uA && constraints->max_uA) {
717
		if (constraints->min_uA == constraints->max_uA)
718 719
			count += sprintf(buf + count, "%d mA ",
					 constraints->min_uA / 1000);
720
		else
721 722 723 724 725 726 727 728 729
			count += sprintf(buf + count, "%d <--> %d mA ",
					 constraints->min_uA / 1000,
					 constraints->max_uA / 1000);
	}

	if (!constraints->min_uA ||
	    constraints->min_uA != constraints->max_uA) {
		ret = _regulator_get_current_limit(rdev);
		if (ret > 0)
730
			count += sprintf(buf + count, "at %d mA ", ret / 1000);
731
	}
732

733 734 735 736 737 738 739 740 741
	if (constraints->valid_modes_mask & REGULATOR_MODE_FAST)
		count += sprintf(buf + count, "fast ");
	if (constraints->valid_modes_mask & REGULATOR_MODE_NORMAL)
		count += sprintf(buf + count, "normal ");
	if (constraints->valid_modes_mask & REGULATOR_MODE_IDLE)
		count += sprintf(buf + count, "idle ");
	if (constraints->valid_modes_mask & REGULATOR_MODE_STANDBY)
		count += sprintf(buf + count, "standby");

742
	rdev_info(rdev, "regulator: %s\n", buf);
743 744
}

745
static int machine_constraints_voltage(struct regulator_dev *rdev,
746
	struct regulation_constraints *constraints)
747
{
748
	struct regulator_ops *ops = rdev->desc->ops;
749 750 751 752
	int ret;

	/* do we need to apply the constraint voltage */
	if (rdev->constraints->apply_uV &&
753 754 755 756 757 758 759 760 761 762
	    rdev->constraints->min_uV == rdev->constraints->max_uV) {
		ret = _regulator_do_set_voltage(rdev,
						rdev->constraints->min_uV,
						rdev->constraints->max_uV);
		if (ret < 0) {
			rdev_err(rdev, "failed to apply %duV constraint\n",
				 rdev->constraints->min_uV);
			rdev->constraints = NULL;
			return ret;
		}
763
	}
764

765 766 767 768 769 770 771 772 773 774 775
	/* constrain machine-level voltage specs to fit
	 * the actual range supported by this regulator.
	 */
	if (ops->list_voltage && rdev->desc->n_voltages) {
		int	count = rdev->desc->n_voltages;
		int	i;
		int	min_uV = INT_MAX;
		int	max_uV = INT_MIN;
		int	cmin = constraints->min_uV;
		int	cmax = constraints->max_uV;

776 777
		/* it's safe to autoconfigure fixed-voltage supplies
		   and the constraints are used by list_voltage. */
778
		if (count == 1 && !cmin) {
779
			cmin = 1;
780
			cmax = INT_MAX;
781 782
			constraints->min_uV = cmin;
			constraints->max_uV = cmax;
783 784
		}

785 786
		/* voltage constraints are optional */
		if ((cmin == 0) && (cmax == 0))
787
			return 0;
788

789
		/* else require explicit machine-level constraints */
790
		if (cmin <= 0 || cmax <= 0 || cmax < cmin) {
791
			rdev_err(rdev, "invalid voltage constraints\n");
792
			return -EINVAL;
793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811
		}

		/* initial: [cmin..cmax] valid, [min_uV..max_uV] not */
		for (i = 0; i < count; i++) {
			int	value;

			value = ops->list_voltage(rdev, i);
			if (value <= 0)
				continue;

			/* maybe adjust [min_uV..max_uV] */
			if (value >= cmin && value < min_uV)
				min_uV = value;
			if (value <= cmax && value > max_uV)
				max_uV = value;
		}

		/* final: [min_uV..max_uV] valid iff constraints valid */
		if (max_uV < min_uV) {
812
			rdev_err(rdev, "unsupportable voltage constraints\n");
813
			return -EINVAL;
814 815 816 817
		}

		/* use regulator's subset of machine constraints */
		if (constraints->min_uV < min_uV) {
818 819
			rdev_dbg(rdev, "override min_uV, %d -> %d\n",
				 constraints->min_uV, min_uV);
820 821 822
			constraints->min_uV = min_uV;
		}
		if (constraints->max_uV > max_uV) {
823 824
			rdev_dbg(rdev, "override max_uV, %d -> %d\n",
				 constraints->max_uV, max_uV);
825 826 827 828
			constraints->max_uV = max_uV;
		}
	}

829 830 831 832 833 834 835 836 837 838 839 840 841 842 843
	return 0;
}

/**
 * set_machine_constraints - sets regulator constraints
 * @rdev: regulator source
 * @constraints: constraints to apply
 *
 * Allows platform initialisation code to define and constrain
 * regulator circuits e.g. valid voltage/current ranges, etc.  NOTE:
 * Constraints *must* be set by platform code in order for some
 * regulator operations to proceed i.e. set_voltage, set_current_limit,
 * set_mode.
 */
static int set_machine_constraints(struct regulator_dev *rdev,
844
	const struct regulation_constraints *constraints)
845 846 847 848
{
	int ret = 0;
	struct regulator_ops *ops = rdev->desc->ops;

849 850 851 852
	rdev->constraints = kmemdup(constraints, sizeof(*constraints),
				    GFP_KERNEL);
	if (!rdev->constraints)
		return -ENOMEM;
853

854
	ret = machine_constraints_voltage(rdev, rdev->constraints);
855 856 857
	if (ret != 0)
		goto out;

858
	/* do we need to setup our suspend state */
859
	if (constraints->initial_state) {
860
		ret = suspend_prepare(rdev, rdev->constraints->initial_state);
861
		if (ret < 0) {
862
			rdev_err(rdev, "failed to set suspend state\n");
863 864 865 866
			rdev->constraints = NULL;
			goto out;
		}
	}
867

868 869
	if (constraints->initial_mode) {
		if (!ops->set_mode) {
870
			rdev_err(rdev, "no set_mode operation\n");
871 872 873 874
			ret = -EINVAL;
			goto out;
		}

875
		ret = ops->set_mode(rdev, rdev->constraints->initial_mode);
876
		if (ret < 0) {
877
			rdev_err(rdev, "failed to set initial mode: %d\n", ret);
878 879 880 881
			goto out;
		}
	}

882 883 884
	/* If the constraints say the regulator should be on at this point
	 * and we have control then make sure it is enabled.
	 */
885 886
	if ((rdev->constraints->always_on || rdev->constraints->boot_on) &&
	    ops->enable) {
887 888
		ret = ops->enable(rdev);
		if (ret < 0) {
889
			rdev_err(rdev, "failed to enable\n");
890 891 892 893 894
			rdev->constraints = NULL;
			goto out;
		}
	}

895 896 897 898 899 900 901
	print_constraints(rdev);
out:
	return ret;
}

/**
 * set_supply - set regulator supply regulator
902 903
 * @rdev: regulator name
 * @supply_rdev: supply regulator name
904 905 906 907 908 909 910 911 912 913 914 915 916
 *
 * Called by platform initialisation code to set the supply regulator for this
 * regulator. This ensures that a regulators supply will also be enabled by the
 * core if it's child is enabled.
 */
static int set_supply(struct regulator_dev *rdev,
	struct regulator_dev *supply_rdev)
{
	int err;

	err = sysfs_create_link(&rdev->dev.kobj, &supply_rdev->dev.kobj,
				"supply");
	if (err) {
917 918
		rdev_err(rdev, "could not add device link %s err %d\n",
			 supply_rdev->dev.kobj.name, err);
919 920 921 922 923 924 925 926 927
		       goto out;
	}
	rdev->supply = supply_rdev;
	list_add(&rdev->slist, &supply_rdev->supply_list);
out:
	return err;
}

/**
928
 * set_consumer_device_supply - Bind a regulator to a symbolic supply
929 930
 * @rdev:         regulator source
 * @consumer_dev: device the supply applies to
931
 * @consumer_dev_name: dev_name() string for device supply applies to
932
 * @supply:       symbolic name for supply
933 934 935 936 937
 *
 * Allows platform initialisation code to map physical regulator
 * sources to symbolic names for supplies for use by devices.  Devices
 * should use these symbolic names to request regulators, avoiding the
 * need to provide board-specific regulator names as platform data.
938 939
 *
 * Only one of consumer_dev and consumer_dev_name may be specified.
940 941
 */
static int set_consumer_device_supply(struct regulator_dev *rdev,
942 943
	struct device *consumer_dev, const char *consumer_dev_name,
	const char *supply)
944 945
{
	struct regulator_map *node;
946
	int has_dev;
947

948 949 950 951 952 953
	if (consumer_dev && consumer_dev_name)
		return -EINVAL;

	if (!consumer_dev_name && consumer_dev)
		consumer_dev_name = dev_name(consumer_dev);

954 955 956
	if (supply == NULL)
		return -EINVAL;

957 958 959 960 961
	if (consumer_dev_name != NULL)
		has_dev = 1;
	else
		has_dev = 0;

962
	list_for_each_entry(node, &regulator_map_list, list) {
963 964 965 966
		if (node->dev_name && consumer_dev_name) {
			if (strcmp(node->dev_name, consumer_dev_name) != 0)
				continue;
		} else if (node->dev_name || consumer_dev_name) {
967
			continue;
968 969
		}

970 971 972 973
		if (strcmp(node->supply, supply) != 0)
			continue;

		dev_dbg(consumer_dev, "%s/%s is '%s' supply; fail %s/%s\n",
974 975 976 977
			dev_name(&node->regulator->dev),
			node->regulator->desc->name,
			supply,
			dev_name(&rdev->dev), rdev_get_name(rdev));
978 979 980
		return -EBUSY;
	}

981
	node = kzalloc(sizeof(struct regulator_map), GFP_KERNEL);
982 983 984 985 986 987
	if (node == NULL)
		return -ENOMEM;

	node->regulator = rdev;
	node->supply = supply;

988 989 990 991 992 993
	if (has_dev) {
		node->dev_name = kstrdup(consumer_dev_name, GFP_KERNEL);
		if (node->dev_name == NULL) {
			kfree(node);
			return -ENOMEM;
		}
994 995
	}

996 997 998 999
	list_add(&node->list, &regulator_map_list);
	return 0;
}

1000 1001 1002 1003 1004 1005 1006
static void unset_regulator_supplies(struct regulator_dev *rdev)
{
	struct regulator_map *node, *n;

	list_for_each_entry_safe(node, n, &regulator_map_list, list) {
		if (rdev == node->regulator) {
			list_del(&node->list);
1007
			kfree(node->dev_name);
1008 1009 1010 1011 1012
			kfree(node);
		}
	}
}

1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038
#define REG_STR_SIZE	32

static struct regulator *create_regulator(struct regulator_dev *rdev,
					  struct device *dev,
					  const char *supply_name)
{
	struct regulator *regulator;
	char buf[REG_STR_SIZE];
	int err, size;

	regulator = kzalloc(sizeof(*regulator), GFP_KERNEL);
	if (regulator == NULL)
		return NULL;

	mutex_lock(&rdev->mutex);
	regulator->rdev = rdev;
	list_add(&regulator->list, &rdev->consumer_list);

	if (dev) {
		/* create a 'requested_microamps_name' sysfs entry */
		size = scnprintf(buf, REG_STR_SIZE, "microamps_requested_%s",
			supply_name);
		if (size >= REG_STR_SIZE)
			goto overflow_err;

		regulator->dev = dev;
1039
		sysfs_attr_init(&regulator->dev_attr.attr);
1040 1041 1042 1043 1044 1045 1046 1047
		regulator->dev_attr.attr.name = kstrdup(buf, GFP_KERNEL);
		if (regulator->dev_attr.attr.name == NULL)
			goto attr_name_err;

		regulator->dev_attr.attr.mode = 0444;
		regulator->dev_attr.show = device_requested_uA_show;
		err = device_create_file(dev, &regulator->dev_attr);
		if (err < 0) {
1048
			rdev_warn(rdev, "could not add regulator_dev requested microamps sysfs entry\n");
1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064
			goto attr_name_err;
		}

		/* also add a link to the device sysfs entry */
		size = scnprintf(buf, REG_STR_SIZE, "%s-%s",
				 dev->kobj.name, supply_name);
		if (size >= REG_STR_SIZE)
			goto attr_err;

		regulator->supply_name = kstrdup(buf, GFP_KERNEL);
		if (regulator->supply_name == NULL)
			goto attr_err;

		err = sysfs_create_link(&rdev->dev.kobj, &dev->kobj,
					buf);
		if (err) {
1065 1066
			rdev_warn(rdev, "could not add device link %s err %d\n",
				  dev->kobj.name, err);
1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084
			goto link_name_err;
		}
	}
	mutex_unlock(&rdev->mutex);
	return regulator;
link_name_err:
	kfree(regulator->supply_name);
attr_err:
	device_remove_file(regulator->dev, &regulator->dev_attr);
attr_name_err:
	kfree(regulator->dev_attr.attr.name);
overflow_err:
	list_del(&regulator->list);
	kfree(regulator);
	mutex_unlock(&rdev->mutex);
	return NULL;
}

1085 1086 1087 1088 1089 1090 1091
static int _regulator_get_enable_time(struct regulator_dev *rdev)
{
	if (!rdev->desc->ops->enable_time)
		return 0;
	return rdev->desc->ops->enable_time(rdev);
}

1092 1093 1094
/* Internal regulator request function */
static struct regulator *_regulator_get(struct device *dev, const char *id,
					int exclusive)
1095 1096 1097 1098
{
	struct regulator_dev *rdev;
	struct regulator_map *map;
	struct regulator *regulator = ERR_PTR(-ENODEV);
1099
	const char *devname = NULL;
1100
	int ret;
1101 1102

	if (id == NULL) {
1103
		pr_err("get() with no identifier\n");
1104 1105 1106
		return regulator;
	}

1107 1108 1109
	if (dev)
		devname = dev_name(dev);

1110 1111 1112
	mutex_lock(&regulator_list_mutex);

	list_for_each_entry(map, &regulator_map_list, list) {
1113 1114 1115 1116 1117 1118
		/* If the mapping has a device set up it must match */
		if (map->dev_name &&
		    (!devname || strcmp(map->dev_name, devname)))
			continue;

		if (strcmp(map->supply, id) == 0) {
1119
			rdev = map->regulator;
1120
			goto found;
1121
		}
1122
	}
1123

1124 1125 1126 1127 1128
	if (board_wants_dummy_regulator) {
		rdev = dummy_regulator_rdev;
		goto found;
	}

1129 1130 1131 1132 1133 1134 1135 1136
#ifdef CONFIG_REGULATOR_DUMMY
	if (!devname)
		devname = "deviceless";

	/* If the board didn't flag that it was fully constrained then
	 * substitute in a dummy regulator so consumers can continue.
	 */
	if (!has_full_constraints) {
1137 1138
		pr_warn("%s supply %s not found, using dummy regulator\n",
			devname, id);
1139 1140 1141 1142 1143
		rdev = dummy_regulator_rdev;
		goto found;
	}
#endif

1144 1145 1146 1147
	mutex_unlock(&regulator_list_mutex);
	return regulator;

found:
1148 1149 1150 1151 1152 1153 1154 1155 1156 1157
	if (rdev->exclusive) {
		regulator = ERR_PTR(-EPERM);
		goto out;
	}

	if (exclusive && rdev->open_count) {
		regulator = ERR_PTR(-EBUSY);
		goto out;
	}

1158 1159 1160
	if (!try_module_get(rdev->owner))
		goto out;

1161 1162 1163 1164 1165 1166
	regulator = create_regulator(rdev, dev, id);
	if (regulator == NULL) {
		regulator = ERR_PTR(-ENOMEM);
		module_put(rdev->owner);
	}

1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177
	rdev->open_count++;
	if (exclusive) {
		rdev->exclusive = 1;

		ret = _regulator_is_enabled(rdev);
		if (ret > 0)
			rdev->use_count = 1;
		else
			rdev->use_count = 0;
	}

1178
out:
1179
	mutex_unlock(&regulator_list_mutex);
1180

1181 1182
	return regulator;
}
1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200

/**
 * regulator_get - lookup and obtain a reference to a regulator.
 * @dev: device for regulator "consumer"
 * @id: Supply name or regulator ID.
 *
 * Returns a struct regulator corresponding to the regulator producer,
 * or IS_ERR() condition containing errno.
 *
 * Use of supply names configured via regulator_set_device_supply() is
 * strongly encouraged.  It is recommended that the supply name used
 * should match the name used for the supply and/or the relevant
 * device pins in the datasheet.
 */
struct regulator *regulator_get(struct device *dev, const char *id)
{
	return _regulator_get(dev, id, 0);
}
1201 1202
EXPORT_SYMBOL_GPL(regulator_get);

1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229
/**
 * regulator_get_exclusive - obtain exclusive access to a regulator.
 * @dev: device for regulator "consumer"
 * @id: Supply name or regulator ID.
 *
 * Returns a struct regulator corresponding to the regulator producer,
 * or IS_ERR() condition containing errno.  Other consumers will be
 * unable to obtain this reference is held and the use count for the
 * regulator will be initialised to reflect the current state of the
 * regulator.
 *
 * This is intended for use by consumers which cannot tolerate shared
 * use of the regulator such as those which need to force the
 * regulator off for correct operation of the hardware they are
 * controlling.
 *
 * Use of supply names configured via regulator_set_device_supply() is
 * strongly encouraged.  It is recommended that the supply name used
 * should match the name used for the supply and/or the relevant
 * device pins in the datasheet.
 */
struct regulator *regulator_get_exclusive(struct device *dev, const char *id)
{
	return _regulator_get(dev, id, 1);
}
EXPORT_SYMBOL_GPL(regulator_get_exclusive);

1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257
/**
 * regulator_put - "free" the regulator source
 * @regulator: regulator source
 *
 * Note: drivers must ensure that all regulator_enable calls made on this
 * regulator source are balanced by regulator_disable calls prior to calling
 * this function.
 */
void regulator_put(struct regulator *regulator)
{
	struct regulator_dev *rdev;

	if (regulator == NULL || IS_ERR(regulator))
		return;

	mutex_lock(&regulator_list_mutex);
	rdev = regulator->rdev;

	/* remove any sysfs entries */
	if (regulator->dev) {
		sysfs_remove_link(&rdev->dev.kobj, regulator->supply_name);
		kfree(regulator->supply_name);
		device_remove_file(regulator->dev, &regulator->dev_attr);
		kfree(regulator->dev_attr.attr.name);
	}
	list_del(&regulator->list);
	kfree(regulator);

1258 1259 1260
	rdev->open_count--;
	rdev->exclusive = 0;

1261 1262 1263 1264 1265
	module_put(rdev->owner);
	mutex_unlock(&regulator_list_mutex);
}
EXPORT_SYMBOL_GPL(regulator_put);

1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276
static int _regulator_can_change_status(struct regulator_dev *rdev)
{
	if (!rdev->constraints)
		return 0;

	if (rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_STATUS)
		return 1;
	else
		return 0;
}

1277 1278 1279
/* locks held by regulator_enable() */
static int _regulator_enable(struct regulator_dev *rdev)
{
1280
	int ret, delay;
1281

1282 1283 1284 1285 1286 1287 1288
	if (rdev->use_count == 0) {
		/* do we need to enable the supply regulator first */
		if (rdev->supply) {
			mutex_lock(&rdev->supply->mutex);
			ret = _regulator_enable(rdev->supply);
			mutex_unlock(&rdev->supply->mutex);
			if (ret < 0) {
1289
				rdev_err(rdev, "failed to enable: %d\n", ret);
1290 1291
				return ret;
			}
1292 1293 1294 1295
		}
	}

	/* check voltage and requested load before enabling */
1296 1297 1298
	if (rdev->constraints &&
	    (rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_DRMS))
		drms_uA_update(rdev);
1299

1300 1301 1302 1303 1304 1305 1306
	if (rdev->use_count == 0) {
		/* The regulator may on if it's not switchable or left on */
		ret = _regulator_is_enabled(rdev);
		if (ret == -EINVAL || ret == 0) {
			if (!_regulator_can_change_status(rdev))
				return -EPERM;

1307
			if (!rdev->desc->ops->enable)
1308
				return -EINVAL;
1309 1310 1311 1312 1313 1314 1315

			/* Query before enabling in case configuration
			 * dependant.  */
			ret = _regulator_get_enable_time(rdev);
			if (ret >= 0) {
				delay = ret;
			} else {
1316
				rdev_warn(rdev, "enable_time() failed: %d\n",
1317
					   ret);
1318
				delay = 0;
1319
			}
1320

1321 1322
			trace_regulator_enable(rdev_get_name(rdev));

1323 1324 1325 1326 1327 1328 1329
			/* Allow the regulator to ramp; it would be useful
			 * to extend this for bulk operations so that the
			 * regulators can ramp together.  */
			ret = rdev->desc->ops->enable(rdev);
			if (ret < 0)
				return ret;

1330 1331
			trace_regulator_enable_delay(rdev_get_name(rdev));

1332
			if (delay >= 1000) {
1333
				mdelay(delay / 1000);
1334 1335
				udelay(delay % 1000);
			} else if (delay) {
1336
				udelay(delay);
1337
			}
1338

1339 1340
			trace_regulator_enable_complete(rdev_get_name(rdev));

1341
		} else if (ret < 0) {
1342
			rdev_err(rdev, "is_enabled() failed: %d\n", ret);
1343 1344
			return ret;
		}
1345
		/* Fallthrough on positive return values - already enabled */
1346 1347
	}

1348 1349 1350
	rdev->use_count++;

	return 0;
1351 1352 1353 1354 1355 1356
}

/**
 * regulator_enable - enable regulator output
 * @regulator: regulator source
 *
1357 1358 1359 1360
 * Request that the regulator be enabled with the regulator output at
 * the predefined voltage or current value.  Calls to regulator_enable()
 * must be balanced with calls to regulator_disable().
 *
1361
 * NOTE: the output value can be set by other drivers, boot loader or may be
1362
 * hardwired in the regulator.
1363 1364 1365
 */
int regulator_enable(struct regulator *regulator)
{
1366 1367
	struct regulator_dev *rdev = regulator->rdev;
	int ret = 0;
1368

1369
	mutex_lock(&rdev->mutex);
D
David Brownell 已提交
1370
	ret = _regulator_enable(rdev);
1371
	mutex_unlock(&rdev->mutex);
1372 1373 1374 1375 1376
	return ret;
}
EXPORT_SYMBOL_GPL(regulator_enable);

/* locks held by regulator_disable() */
1377 1378
static int _regulator_disable(struct regulator_dev *rdev,
		struct regulator_dev **supply_rdev_ptr)
1379 1380
{
	int ret = 0;
1381
	*supply_rdev_ptr = NULL;
1382

D
David Brownell 已提交
1383
	if (WARN(rdev->use_count <= 0,
1384
		 "unbalanced disables for %s\n", rdev_get_name(rdev)))
D
David Brownell 已提交
1385 1386
		return -EIO;

1387
	/* are we the last user and permitted to disable ? */
1388 1389
	if (rdev->use_count == 1 &&
	    (rdev->constraints && !rdev->constraints->always_on)) {
1390 1391

		/* we are last user */
1392 1393
		if (_regulator_can_change_status(rdev) &&
		    rdev->desc->ops->disable) {
1394 1395
			trace_regulator_disable(rdev_get_name(rdev));

1396 1397
			ret = rdev->desc->ops->disable(rdev);
			if (ret < 0) {
1398
				rdev_err(rdev, "failed to disable\n");
1399 1400
				return ret;
			}
1401

1402 1403
			trace_regulator_disable_complete(rdev_get_name(rdev));

1404 1405
			_notifier_call_chain(rdev, REGULATOR_EVENT_DISABLE,
					     NULL);
1406 1407 1408
		}

		/* decrease our supplies ref count and disable if required */
1409
		*supply_rdev_ptr = rdev->supply;
1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427

		rdev->use_count = 0;
	} else if (rdev->use_count > 1) {

		if (rdev->constraints &&
			(rdev->constraints->valid_ops_mask &
			REGULATOR_CHANGE_DRMS))
			drms_uA_update(rdev);

		rdev->use_count--;
	}
	return ret;
}

/**
 * regulator_disable - disable regulator output
 * @regulator: regulator source
 *
1428 1429 1430
 * Disable the regulator output voltage or current.  Calls to
 * regulator_enable() must be balanced with calls to
 * regulator_disable().
1431
 *
1432
 * NOTE: this will only disable the regulator output if no other consumer
1433 1434
 * devices have it enabled, the regulator device supports disabling and
 * machine constraints permit this operation.
1435 1436 1437
 */
int regulator_disable(struct regulator *regulator)
{
1438
	struct regulator_dev *rdev = regulator->rdev;
1439
	struct regulator_dev *supply_rdev = NULL;
1440
	int ret = 0;
1441

1442
	mutex_lock(&rdev->mutex);
1443
	ret = _regulator_disable(rdev, &supply_rdev);
1444
	mutex_unlock(&rdev->mutex);
1445 1446 1447 1448 1449 1450 1451 1452 1453 1454

	/* decrease our supplies ref count and disable if required */
	while (supply_rdev != NULL) {
		rdev = supply_rdev;

		mutex_lock(&rdev->mutex);
		_regulator_disable(rdev, &supply_rdev);
		mutex_unlock(&rdev->mutex);
	}

1455 1456 1457 1458 1459
	return ret;
}
EXPORT_SYMBOL_GPL(regulator_disable);

/* locks held by regulator_force_disable() */
1460 1461
static int _regulator_force_disable(struct regulator_dev *rdev,
		struct regulator_dev **supply_rdev_ptr)
1462 1463 1464 1465 1466 1467 1468 1469
{
	int ret = 0;

	/* force disable */
	if (rdev->desc->ops->disable) {
		/* ah well, who wants to live forever... */
		ret = rdev->desc->ops->disable(rdev);
		if (ret < 0) {
1470
			rdev_err(rdev, "failed to force disable\n");
1471 1472 1473
			return ret;
		}
		/* notify other consumers that power has been forced off */
1474 1475
		_notifier_call_chain(rdev, REGULATOR_EVENT_FORCE_DISABLE |
			REGULATOR_EVENT_DISABLE, NULL);
1476 1477 1478
	}

	/* decrease our supplies ref count and disable if required */
1479
	*supply_rdev_ptr = rdev->supply;
1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495

	rdev->use_count = 0;
	return ret;
}

/**
 * regulator_force_disable - force disable regulator output
 * @regulator: regulator source
 *
 * Forcibly disable the regulator output voltage or current.
 * NOTE: this *will* disable the regulator output even if other consumer
 * devices have it enabled. This should be used for situations when device
 * damage will likely occur if the regulator is not disabled (e.g. over temp).
 */
int regulator_force_disable(struct regulator *regulator)
{
1496
	struct regulator_dev *supply_rdev = NULL;
1497 1498 1499 1500
	int ret;

	mutex_lock(&regulator->rdev->mutex);
	regulator->uA_load = 0;
1501
	ret = _regulator_force_disable(regulator->rdev, &supply_rdev);
1502
	mutex_unlock(&regulator->rdev->mutex);
1503 1504 1505 1506

	if (supply_rdev)
		regulator_disable(get_device_regulator(rdev_get_dev(supply_rdev)));

1507 1508 1509 1510 1511 1512
	return ret;
}
EXPORT_SYMBOL_GPL(regulator_force_disable);

static int _regulator_is_enabled(struct regulator_dev *rdev)
{
1513
	/* If we don't know then assume that the regulator is always on */
1514
	if (!rdev->desc->ops->is_enabled)
1515
		return 1;
1516

1517
	return rdev->desc->ops->is_enabled(rdev);
1518 1519 1520 1521 1522 1523
}

/**
 * regulator_is_enabled - is the regulator output enabled
 * @regulator: regulator source
 *
1524 1525 1526 1527 1528 1529 1530
 * Returns positive if the regulator driver backing the source/client
 * has requested that the device be enabled, zero if it hasn't, else a
 * negative errno code.
 *
 * Note that the device backing this regulator handle can have multiple
 * users, so it might be enabled even if regulator_enable() was never
 * called for this particular source.
1531 1532 1533
 */
int regulator_is_enabled(struct regulator *regulator)
{
1534 1535 1536 1537 1538 1539 1540
	int ret;

	mutex_lock(&regulator->rdev->mutex);
	ret = _regulator_is_enabled(regulator->rdev);
	mutex_unlock(&regulator->rdev->mutex);

	return ret;
1541 1542 1543
}
EXPORT_SYMBOL_GPL(regulator_is_enabled);

1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566
/**
 * regulator_count_voltages - count regulator_list_voltage() selectors
 * @regulator: regulator source
 *
 * Returns number of selectors, or negative errno.  Selectors are
 * numbered starting at zero, and typically correspond to bitfields
 * in hardware registers.
 */
int regulator_count_voltages(struct regulator *regulator)
{
	struct regulator_dev	*rdev = regulator->rdev;

	return rdev->desc->n_voltages ? : -EINVAL;
}
EXPORT_SYMBOL_GPL(regulator_count_voltages);

/**
 * regulator_list_voltage - enumerate supported voltages
 * @regulator: regulator source
 * @selector: identify voltage to list
 * Context: can sleep
 *
 * Returns a voltage that can be passed to @regulator_set_voltage(),
T
Thomas Weber 已提交
1567
 * zero if this selector code can't be used on this system, or a
1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593
 * negative errno.
 */
int regulator_list_voltage(struct regulator *regulator, unsigned selector)
{
	struct regulator_dev	*rdev = regulator->rdev;
	struct regulator_ops	*ops = rdev->desc->ops;
	int			ret;

	if (!ops->list_voltage || selector >= rdev->desc->n_voltages)
		return -EINVAL;

	mutex_lock(&rdev->mutex);
	ret = ops->list_voltage(rdev, selector);
	mutex_unlock(&rdev->mutex);

	if (ret > 0) {
		if (ret < rdev->constraints->min_uV)
			ret = 0;
		else if (ret > rdev->constraints->max_uV)
			ret = 0;
	}

	return ret;
}
EXPORT_SYMBOL_GPL(regulator_list_voltage);

1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622
/**
 * regulator_is_supported_voltage - check if a voltage range can be supported
 *
 * @regulator: Regulator to check.
 * @min_uV: Minimum required voltage in uV.
 * @max_uV: Maximum required voltage in uV.
 *
 * Returns a boolean or a negative error code.
 */
int regulator_is_supported_voltage(struct regulator *regulator,
				   int min_uV, int max_uV)
{
	int i, voltages, ret;

	ret = regulator_count_voltages(regulator);
	if (ret < 0)
		return ret;
	voltages = ret;

	for (i = 0; i < voltages; i++) {
		ret = regulator_list_voltage(regulator, i);

		if (ret >= min_uV && ret <= max_uV)
			return 1;
	}

	return 0;
}

1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639
static int _regulator_do_set_voltage(struct regulator_dev *rdev,
				     int min_uV, int max_uV)
{
	int ret;
	unsigned int selector;

	trace_regulator_set_voltage(rdev_get_name(rdev), min_uV, max_uV);

	if (rdev->desc->ops->set_voltage) {
		ret = rdev->desc->ops->set_voltage(rdev, min_uV, max_uV,
						   &selector);

		if (rdev->desc->ops->list_voltage)
			selector = rdev->desc->ops->list_voltage(rdev,
								 selector);
		else
			selector = -1;
1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665
	} else if (rdev->desc->ops->set_voltage_sel) {
		int best_val = INT_MAX;
		int i;

		selector = 0;

		/* Find the smallest voltage that falls within the specified
		 * range.
		 */
		for (i = 0; i < rdev->desc->n_voltages; i++) {
			ret = rdev->desc->ops->list_voltage(rdev, i);
			if (ret < 0)
				continue;

			if (ret < best_val && ret >= min_uV && ret <= max_uV) {
				best_val = ret;
				selector = i;
			}
		}

		if (best_val != INT_MAX) {
			ret = rdev->desc->ops->set_voltage_sel(rdev, selector);
			selector = best_val;
		} else {
			ret = -EINVAL;
		}
1666 1667 1668 1669
	} else {
		ret = -EINVAL;
	}

1670 1671 1672 1673
	if (ret == 0)
		_notifier_call_chain(rdev, REGULATOR_EVENT_VOLTAGE_CHANGE,
				     NULL);

1674 1675 1676 1677 1678
	trace_regulator_set_voltage_complete(rdev_get_name(rdev), selector);

	return ret;
}

1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693
/**
 * regulator_set_voltage - set regulator output voltage
 * @regulator: regulator source
 * @min_uV: Minimum required voltage in uV
 * @max_uV: Maximum acceptable voltage in uV
 *
 * Sets a voltage regulator to the desired output voltage. This can be set
 * during any regulator state. IOW, regulator can be disabled or enabled.
 *
 * If the regulator is enabled then the voltage will change to the new value
 * immediately otherwise if the regulator is disabled the regulator will
 * output at the new voltage when enabled.
 *
 * NOTE: If the regulator is shared between several devices then the lowest
 * request voltage that meets the system constraints will be used.
1694
 * Regulator system constraints must be set for this regulator before
1695 1696 1697 1698 1699 1700 1701 1702 1703 1704
 * calling this function otherwise this call will fail.
 */
int regulator_set_voltage(struct regulator *regulator, int min_uV, int max_uV)
{
	struct regulator_dev *rdev = regulator->rdev;
	int ret;

	mutex_lock(&rdev->mutex);

	/* sanity check */
1705 1706
	if (!rdev->desc->ops->set_voltage &&
	    !rdev->desc->ops->set_voltage_sel) {
1707 1708 1709 1710 1711 1712 1713 1714 1715 1716
		ret = -EINVAL;
		goto out;
	}

	/* constraints check */
	ret = regulator_check_voltage(rdev, &min_uV, &max_uV);
	if (ret < 0)
		goto out;
	regulator->min_uV = min_uV;
	regulator->max_uV = max_uV;
1717

1718 1719 1720 1721
	ret = regulator_check_consumers(rdev, &min_uV, &max_uV);
	if (ret < 0)
		goto out;

1722
	ret = _regulator_do_set_voltage(rdev, min_uV, max_uV);
1723

1724 1725 1726 1727 1728 1729 1730 1731
out:
	mutex_unlock(&rdev->mutex);
	return ret;
}
EXPORT_SYMBOL_GPL(regulator_set_voltage);

static int _regulator_get_voltage(struct regulator_dev *rdev)
{
1732 1733 1734 1735 1736 1737 1738 1739
	int sel;

	if (rdev->desc->ops->get_voltage_sel) {
		sel = rdev->desc->ops->get_voltage_sel(rdev);
		if (sel < 0)
			return sel;
		return rdev->desc->ops->list_voltage(rdev, sel);
	}
1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858
	if (rdev->desc->ops->get_voltage)
		return rdev->desc->ops->get_voltage(rdev);
	else
		return -EINVAL;
}

/**
 * regulator_get_voltage - get regulator output voltage
 * @regulator: regulator source
 *
 * This returns the current regulator voltage in uV.
 *
 * NOTE: If the regulator is disabled it will return the voltage value. This
 * function should not be used to determine regulator state.
 */
int regulator_get_voltage(struct regulator *regulator)
{
	int ret;

	mutex_lock(&regulator->rdev->mutex);

	ret = _regulator_get_voltage(regulator->rdev);

	mutex_unlock(&regulator->rdev->mutex);

	return ret;
}
EXPORT_SYMBOL_GPL(regulator_get_voltage);

/**
 * regulator_set_current_limit - set regulator output current limit
 * @regulator: regulator source
 * @min_uA: Minimuum supported current in uA
 * @max_uA: Maximum supported current in uA
 *
 * Sets current sink to the desired output current. This can be set during
 * any regulator state. IOW, regulator can be disabled or enabled.
 *
 * If the regulator is enabled then the current will change to the new value
 * immediately otherwise if the regulator is disabled the regulator will
 * output at the new current when enabled.
 *
 * NOTE: Regulator system constraints must be set for this regulator before
 * calling this function otherwise this call will fail.
 */
int regulator_set_current_limit(struct regulator *regulator,
			       int min_uA, int max_uA)
{
	struct regulator_dev *rdev = regulator->rdev;
	int ret;

	mutex_lock(&rdev->mutex);

	/* sanity check */
	if (!rdev->desc->ops->set_current_limit) {
		ret = -EINVAL;
		goto out;
	}

	/* constraints check */
	ret = regulator_check_current_limit(rdev, &min_uA, &max_uA);
	if (ret < 0)
		goto out;

	ret = rdev->desc->ops->set_current_limit(rdev, min_uA, max_uA);
out:
	mutex_unlock(&rdev->mutex);
	return ret;
}
EXPORT_SYMBOL_GPL(regulator_set_current_limit);

static int _regulator_get_current_limit(struct regulator_dev *rdev)
{
	int ret;

	mutex_lock(&rdev->mutex);

	/* sanity check */
	if (!rdev->desc->ops->get_current_limit) {
		ret = -EINVAL;
		goto out;
	}

	ret = rdev->desc->ops->get_current_limit(rdev);
out:
	mutex_unlock(&rdev->mutex);
	return ret;
}

/**
 * regulator_get_current_limit - get regulator output current
 * @regulator: regulator source
 *
 * This returns the current supplied by the specified current sink in uA.
 *
 * NOTE: If the regulator is disabled it will return the current value. This
 * function should not be used to determine regulator state.
 */
int regulator_get_current_limit(struct regulator *regulator)
{
	return _regulator_get_current_limit(regulator->rdev);
}
EXPORT_SYMBOL_GPL(regulator_get_current_limit);

/**
 * regulator_set_mode - set regulator operating mode
 * @regulator: regulator source
 * @mode: operating mode - one of the REGULATOR_MODE constants
 *
 * Set regulator operating mode to increase regulator efficiency or improve
 * regulation performance.
 *
 * NOTE: Regulator system constraints must be set for this regulator before
 * calling this function otherwise this call will fail.
 */
int regulator_set_mode(struct regulator *regulator, unsigned int mode)
{
	struct regulator_dev *rdev = regulator->rdev;
	int ret;
1859
	int regulator_curr_mode;
1860 1861 1862 1863 1864 1865 1866 1867 1868

	mutex_lock(&rdev->mutex);

	/* sanity check */
	if (!rdev->desc->ops->set_mode) {
		ret = -EINVAL;
		goto out;
	}

1869 1870 1871 1872 1873 1874 1875 1876 1877
	/* return if the same mode is requested */
	if (rdev->desc->ops->get_mode) {
		regulator_curr_mode = rdev->desc->ops->get_mode(rdev);
		if (regulator_curr_mode == mode) {
			ret = 0;
			goto out;
		}
	}

1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965
	/* constraints check */
	ret = regulator_check_mode(rdev, mode);
	if (ret < 0)
		goto out;

	ret = rdev->desc->ops->set_mode(rdev, mode);
out:
	mutex_unlock(&rdev->mutex);
	return ret;
}
EXPORT_SYMBOL_GPL(regulator_set_mode);

static unsigned int _regulator_get_mode(struct regulator_dev *rdev)
{
	int ret;

	mutex_lock(&rdev->mutex);

	/* sanity check */
	if (!rdev->desc->ops->get_mode) {
		ret = -EINVAL;
		goto out;
	}

	ret = rdev->desc->ops->get_mode(rdev);
out:
	mutex_unlock(&rdev->mutex);
	return ret;
}

/**
 * regulator_get_mode - get regulator operating mode
 * @regulator: regulator source
 *
 * Get the current regulator operating mode.
 */
unsigned int regulator_get_mode(struct regulator *regulator)
{
	return _regulator_get_mode(regulator->rdev);
}
EXPORT_SYMBOL_GPL(regulator_get_mode);

/**
 * regulator_set_optimum_mode - set regulator optimum operating mode
 * @regulator: regulator source
 * @uA_load: load current
 *
 * Notifies the regulator core of a new device load. This is then used by
 * DRMS (if enabled by constraints) to set the most efficient regulator
 * operating mode for the new regulator loading.
 *
 * Consumer devices notify their supply regulator of the maximum power
 * they will require (can be taken from device datasheet in the power
 * consumption tables) when they change operational status and hence power
 * state. Examples of operational state changes that can affect power
 * consumption are :-
 *
 *    o Device is opened / closed.
 *    o Device I/O is about to begin or has just finished.
 *    o Device is idling in between work.
 *
 * This information is also exported via sysfs to userspace.
 *
 * DRMS will sum the total requested load on the regulator and change
 * to the most efficient operating mode if platform constraints allow.
 *
 * Returns the new regulator mode or error.
 */
int regulator_set_optimum_mode(struct regulator *regulator, int uA_load)
{
	struct regulator_dev *rdev = regulator->rdev;
	struct regulator *consumer;
	int ret, output_uV, input_uV, total_uA_load = 0;
	unsigned int mode;

	mutex_lock(&rdev->mutex);

	regulator->uA_load = uA_load;
	ret = regulator_check_drms(rdev);
	if (ret < 0)
		goto out;
	ret = -EINVAL;

	/* sanity check */
	if (!rdev->desc->ops->get_optimum_mode)
		goto out;

	/* get output voltage */
1966
	output_uV = _regulator_get_voltage(rdev);
1967
	if (output_uV <= 0) {
1968
		rdev_err(rdev, "invalid output voltage found\n");
1969 1970 1971 1972
		goto out;
	}

	/* get input voltage */
1973 1974 1975 1976
	input_uV = 0;
	if (rdev->supply)
		input_uV = _regulator_get_voltage(rdev->supply);
	if (input_uV <= 0)
1977 1978
		input_uV = rdev->constraints->input_uV;
	if (input_uV <= 0) {
1979
		rdev_err(rdev, "invalid input voltage found\n");
1980 1981 1982 1983 1984
		goto out;
	}

	/* calc total requested load for this regulator */
	list_for_each_entry(consumer, &rdev->consumer_list, list)
1985
		total_uA_load += consumer->uA_load;
1986 1987 1988 1989

	mode = rdev->desc->ops->get_optimum_mode(rdev,
						 input_uV, output_uV,
						 total_uA_load);
1990 1991
	ret = regulator_check_mode(rdev, mode);
	if (ret < 0) {
1992 1993
		rdev_err(rdev, "failed to get optimum mode @ %d uA %d -> %d uV\n",
			 total_uA_load, input_uV, output_uV);
1994 1995 1996 1997
		goto out;
	}

	ret = rdev->desc->ops->set_mode(rdev, mode);
1998
	if (ret < 0) {
1999
		rdev_err(rdev, "failed to set optimum mode %x\n", mode);
2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011
		goto out;
	}
	ret = mode;
out:
	mutex_unlock(&rdev->mutex);
	return ret;
}
EXPORT_SYMBOL_GPL(regulator_set_optimum_mode);

/**
 * regulator_register_notifier - register regulator event notifier
 * @regulator: regulator source
2012
 * @nb: notifier block
2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026
 *
 * Register notifier block to receive regulator events.
 */
int regulator_register_notifier(struct regulator *regulator,
			      struct notifier_block *nb)
{
	return blocking_notifier_chain_register(&regulator->rdev->notifier,
						nb);
}
EXPORT_SYMBOL_GPL(regulator_register_notifier);

/**
 * regulator_unregister_notifier - unregister regulator event notifier
 * @regulator: regulator source
2027
 * @nb: notifier block
2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038
 *
 * Unregister regulator event notifier block.
 */
int regulator_unregister_notifier(struct regulator *regulator,
				struct notifier_block *nb)
{
	return blocking_notifier_chain_unregister(&regulator->rdev->notifier,
						  nb);
}
EXPORT_SYMBOL_GPL(regulator_unregister_notifier);

2039 2040 2041
/* notify regulator consumers and downstream regulator consumers.
 * Note mutex must be held by caller.
 */
2042 2043 2044 2045 2046 2047 2048 2049 2050
static void _notifier_call_chain(struct regulator_dev *rdev,
				  unsigned long event, void *data)
{
	struct regulator_dev *_rdev;

	/* call rdev chain first */
	blocking_notifier_call_chain(&rdev->notifier, event, NULL);

	/* now notify regulator we supply */
2051
	list_for_each_entry(_rdev, &rdev->supply_list, slist) {
2052 2053 2054
		mutex_lock(&_rdev->mutex);
		_notifier_call_chain(_rdev, event, data);
		mutex_unlock(&_rdev->mutex);
2055
	}
2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085
}

/**
 * regulator_bulk_get - get multiple regulator consumers
 *
 * @dev:           Device to supply
 * @num_consumers: Number of consumers to register
 * @consumers:     Configuration of consumers; clients are stored here.
 *
 * @return 0 on success, an errno on failure.
 *
 * This helper function allows drivers to get several regulator
 * consumers in one operation.  If any of the regulators cannot be
 * acquired then any regulators that were allocated will be freed
 * before returning to the caller.
 */
int regulator_bulk_get(struct device *dev, int num_consumers,
		       struct regulator_bulk_data *consumers)
{
	int i;
	int ret;

	for (i = 0; i < num_consumers; i++)
		consumers[i].consumer = NULL;

	for (i = 0; i < num_consumers; i++) {
		consumers[i].consumer = regulator_get(dev,
						      consumers[i].supply);
		if (IS_ERR(consumers[i].consumer)) {
			ret = PTR_ERR(consumers[i].consumer);
2086 2087
			dev_err(dev, "Failed to get supply '%s': %d\n",
				consumers[i].supply, ret);
2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129
			consumers[i].consumer = NULL;
			goto err;
		}
	}

	return 0;

err:
	for (i = 0; i < num_consumers && consumers[i].consumer; i++)
		regulator_put(consumers[i].consumer);

	return ret;
}
EXPORT_SYMBOL_GPL(regulator_bulk_get);

/**
 * regulator_bulk_enable - enable multiple regulator consumers
 *
 * @num_consumers: Number of consumers
 * @consumers:     Consumer data; clients are stored here.
 * @return         0 on success, an errno on failure
 *
 * This convenience API allows consumers to enable multiple regulator
 * clients in a single API call.  If any consumers cannot be enabled
 * then any others that were enabled will be disabled again prior to
 * return.
 */
int regulator_bulk_enable(int num_consumers,
			  struct regulator_bulk_data *consumers)
{
	int i;
	int ret;

	for (i = 0; i < num_consumers; i++) {
		ret = regulator_enable(consumers[i].consumer);
		if (ret != 0)
			goto err;
	}

	return 0;

err:
2130
	pr_err("Failed to enable %s: %d\n", consumers[i].supply, ret);
2131
	for (--i; i >= 0; --i)
2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164
		regulator_disable(consumers[i].consumer);

	return ret;
}
EXPORT_SYMBOL_GPL(regulator_bulk_enable);

/**
 * regulator_bulk_disable - disable multiple regulator consumers
 *
 * @num_consumers: Number of consumers
 * @consumers:     Consumer data; clients are stored here.
 * @return         0 on success, an errno on failure
 *
 * This convenience API allows consumers to disable multiple regulator
 * clients in a single API call.  If any consumers cannot be enabled
 * then any others that were disabled will be disabled again prior to
 * return.
 */
int regulator_bulk_disable(int num_consumers,
			   struct regulator_bulk_data *consumers)
{
	int i;
	int ret;

	for (i = 0; i < num_consumers; i++) {
		ret = regulator_disable(consumers[i].consumer);
		if (ret != 0)
			goto err;
	}

	return 0;

err:
2165
	pr_err("Failed to disable %s: %d\n", consumers[i].supply, ret);
2166
	for (--i; i >= 0; --i)
2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195
		regulator_enable(consumers[i].consumer);

	return ret;
}
EXPORT_SYMBOL_GPL(regulator_bulk_disable);

/**
 * regulator_bulk_free - free multiple regulator consumers
 *
 * @num_consumers: Number of consumers
 * @consumers:     Consumer data; clients are stored here.
 *
 * This convenience API allows consumers to free multiple regulator
 * clients in a single API call.
 */
void regulator_bulk_free(int num_consumers,
			 struct regulator_bulk_data *consumers)
{
	int i;

	for (i = 0; i < num_consumers; i++) {
		regulator_put(consumers[i].consumer);
		consumers[i].consumer = NULL;
	}
}
EXPORT_SYMBOL_GPL(regulator_bulk_free);

/**
 * regulator_notifier_call_chain - call regulator event notifier
2196
 * @rdev: regulator source
2197
 * @event: notifier block
2198
 * @data: callback-specific data.
2199 2200 2201
 *
 * Called by regulator drivers to notify clients a regulator event has
 * occurred. We also notify regulator clients downstream.
2202
 * Note lock must be held by caller.
2203 2204 2205 2206 2207 2208 2209 2210 2211 2212
 */
int regulator_notifier_call_chain(struct regulator_dev *rdev,
				  unsigned long event, void *data)
{
	_notifier_call_chain(rdev, event, data);
	return NOTIFY_DONE;

}
EXPORT_SYMBOL_GPL(regulator_notifier_call_chain);

2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236
/**
 * regulator_mode_to_status - convert a regulator mode into a status
 *
 * @mode: Mode to convert
 *
 * Convert a regulator mode into a status.
 */
int regulator_mode_to_status(unsigned int mode)
{
	switch (mode) {
	case REGULATOR_MODE_FAST:
		return REGULATOR_STATUS_FAST;
	case REGULATOR_MODE_NORMAL:
		return REGULATOR_STATUS_NORMAL;
	case REGULATOR_MODE_IDLE:
		return REGULATOR_STATUS_IDLE;
	case REGULATOR_STATUS_STANDBY:
		return REGULATOR_STATUS_STANDBY;
	default:
		return 0;
	}
}
EXPORT_SYMBOL_GPL(regulator_mode_to_status);

2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247
/*
 * To avoid cluttering sysfs (and memory) with useless state, only
 * create attributes that can be meaningfully displayed.
 */
static int add_regulator_attributes(struct regulator_dev *rdev)
{
	struct device		*dev = &rdev->dev;
	struct regulator_ops	*ops = rdev->desc->ops;
	int			status = 0;

	/* some attributes need specific methods to be displayed */
2248
	if (ops->get_voltage || ops->get_voltage_sel) {
2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267
		status = device_create_file(dev, &dev_attr_microvolts);
		if (status < 0)
			return status;
	}
	if (ops->get_current_limit) {
		status = device_create_file(dev, &dev_attr_microamps);
		if (status < 0)
			return status;
	}
	if (ops->get_mode) {
		status = device_create_file(dev, &dev_attr_opmode);
		if (status < 0)
			return status;
	}
	if (ops->is_enabled) {
		status = device_create_file(dev, &dev_attr_state);
		if (status < 0)
			return status;
	}
D
David Brownell 已提交
2268 2269 2270 2271 2272
	if (ops->get_status) {
		status = device_create_file(dev, &dev_attr_status);
		if (status < 0)
			return status;
	}
2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288

	/* some attributes are type-specific */
	if (rdev->desc->type == REGULATOR_CURRENT) {
		status = device_create_file(dev, &dev_attr_requested_microamps);
		if (status < 0)
			return status;
	}

	/* all the other attributes exist to support constraints;
	 * don't show them if there are no constraints, or if the
	 * relevant supporting methods are missing.
	 */
	if (!rdev->constraints)
		return status;

	/* constraints need specific supporting methods */
2289
	if (ops->set_voltage || ops->set_voltage_sel) {
2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352
		status = device_create_file(dev, &dev_attr_min_microvolts);
		if (status < 0)
			return status;
		status = device_create_file(dev, &dev_attr_max_microvolts);
		if (status < 0)
			return status;
	}
	if (ops->set_current_limit) {
		status = device_create_file(dev, &dev_attr_min_microamps);
		if (status < 0)
			return status;
		status = device_create_file(dev, &dev_attr_max_microamps);
		if (status < 0)
			return status;
	}

	/* suspend mode constraints need multiple supporting methods */
	if (!(ops->set_suspend_enable && ops->set_suspend_disable))
		return status;

	status = device_create_file(dev, &dev_attr_suspend_standby_state);
	if (status < 0)
		return status;
	status = device_create_file(dev, &dev_attr_suspend_mem_state);
	if (status < 0)
		return status;
	status = device_create_file(dev, &dev_attr_suspend_disk_state);
	if (status < 0)
		return status;

	if (ops->set_suspend_voltage) {
		status = device_create_file(dev,
				&dev_attr_suspend_standby_microvolts);
		if (status < 0)
			return status;
		status = device_create_file(dev,
				&dev_attr_suspend_mem_microvolts);
		if (status < 0)
			return status;
		status = device_create_file(dev,
				&dev_attr_suspend_disk_microvolts);
		if (status < 0)
			return status;
	}

	if (ops->set_suspend_mode) {
		status = device_create_file(dev,
				&dev_attr_suspend_standby_mode);
		if (status < 0)
			return status;
		status = device_create_file(dev,
				&dev_attr_suspend_mem_mode);
		if (status < 0)
			return status;
		status = device_create_file(dev,
				&dev_attr_suspend_disk_mode);
		if (status < 0)
			return status;
	}

	return status;
}

2353 2354
/**
 * regulator_register - register regulator
2355 2356
 * @regulator_desc: regulator to register
 * @dev: struct device for the regulator
2357
 * @init_data: platform provided init data, passed through by driver
2358
 * @driver_data: private regulator data
2359 2360 2361 2362 2363
 *
 * Called by regulator drivers to register a regulator.
 * Returns 0 on success.
 */
struct regulator_dev *regulator_register(struct regulator_desc *regulator_desc,
2364
	struct device *dev, const struct regulator_init_data *init_data,
2365
	void *driver_data)
2366 2367 2368
{
	static atomic_t regulator_no = ATOMIC_INIT(0);
	struct regulator_dev *rdev;
2369
	int ret, i;
2370 2371 2372 2373 2374 2375 2376

	if (regulator_desc == NULL)
		return ERR_PTR(-EINVAL);

	if (regulator_desc->name == NULL || regulator_desc->ops == NULL)
		return ERR_PTR(-EINVAL);

2377 2378
	if (regulator_desc->type != REGULATOR_VOLTAGE &&
	    regulator_desc->type != REGULATOR_CURRENT)
2379 2380
		return ERR_PTR(-EINVAL);

2381 2382 2383
	if (!init_data)
		return ERR_PTR(-EINVAL);

2384 2385 2386
	/* Only one of each should be implemented */
	WARN_ON(regulator_desc->ops->get_voltage &&
		regulator_desc->ops->get_voltage_sel);
2387 2388
	WARN_ON(regulator_desc->ops->set_voltage &&
		regulator_desc->ops->set_voltage_sel);
2389 2390 2391 2392 2393 2394

	/* If we're using selectors we must implement list_voltage. */
	if (regulator_desc->ops->get_voltage_sel &&
	    !regulator_desc->ops->list_voltage) {
		return ERR_PTR(-EINVAL);
	}
2395 2396 2397 2398
	if (regulator_desc->ops->set_voltage_sel &&
	    !regulator_desc->ops->list_voltage) {
		return ERR_PTR(-EINVAL);
	}
2399

2400 2401 2402 2403 2404 2405 2406
	rdev = kzalloc(sizeof(struct regulator_dev), GFP_KERNEL);
	if (rdev == NULL)
		return ERR_PTR(-ENOMEM);

	mutex_lock(&regulator_list_mutex);

	mutex_init(&rdev->mutex);
2407
	rdev->reg_data = driver_data;
2408 2409 2410 2411 2412 2413 2414 2415
	rdev->owner = regulator_desc->owner;
	rdev->desc = regulator_desc;
	INIT_LIST_HEAD(&rdev->consumer_list);
	INIT_LIST_HEAD(&rdev->supply_list);
	INIT_LIST_HEAD(&rdev->list);
	INIT_LIST_HEAD(&rdev->slist);
	BLOCKING_INIT_NOTIFIER_HEAD(&rdev->notifier);

2416 2417 2418
	/* preform any regulator specific init */
	if (init_data->regulator_init) {
		ret = init_data->regulator_init(rdev->reg_data);
D
David Brownell 已提交
2419 2420
		if (ret < 0)
			goto clean;
2421 2422 2423
	}

	/* register with sysfs */
2424
	rdev->dev.class = &regulator_class;
2425
	rdev->dev.parent = dev;
2426 2427
	dev_set_name(&rdev->dev, "regulator.%d",
		     atomic_inc_return(&regulator_no) - 1);
2428
	ret = device_register(&rdev->dev);
2429 2430
	if (ret != 0) {
		put_device(&rdev->dev);
D
David Brownell 已提交
2431
		goto clean;
2432
	}
2433 2434 2435

	dev_set_drvdata(&rdev->dev, rdev);

2436 2437 2438 2439 2440
	/* set regulator constraints */
	ret = set_machine_constraints(rdev, &init_data->constraints);
	if (ret < 0)
		goto scrub;

2441 2442 2443 2444 2445
	/* add attributes supported by this regulator */
	ret = add_regulator_attributes(rdev);
	if (ret < 0)
		goto scrub;

2446
	/* set supply regulator if it exists */
2447 2448 2449
	if (init_data->supply_regulator && init_data->supply_regulator_dev) {
		dev_err(dev,
			"Supply regulator specified by both name and dev\n");
2450
		ret = -EINVAL;
2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468
		goto scrub;
	}

	if (init_data->supply_regulator) {
		struct regulator_dev *r;
		int found = 0;

		list_for_each_entry(r, &regulator_list, list) {
			if (strcmp(rdev_get_name(r),
				   init_data->supply_regulator) == 0) {
				found = 1;
				break;
			}
		}

		if (!found) {
			dev_err(dev, "Failed to find supply %s\n",
				init_data->supply_regulator);
2469
			ret = -ENODEV;
2470 2471 2472 2473 2474 2475 2476 2477
			goto scrub;
		}

		ret = set_supply(rdev, r);
		if (ret < 0)
			goto scrub;
	}

2478
	if (init_data->supply_regulator_dev) {
2479
		dev_warn(dev, "Uses supply_regulator_dev instead of regulator_supply\n");
2480 2481
		ret = set_supply(rdev,
			dev_get_drvdata(init_data->supply_regulator_dev));
D
David Brownell 已提交
2482 2483
		if (ret < 0)
			goto scrub;
2484 2485 2486 2487 2488 2489
	}

	/* add consumers devices */
	for (i = 0; i < init_data->num_consumer_supplies; i++) {
		ret = set_consumer_device_supply(rdev,
			init_data->consumer_supplies[i].dev,
2490
			init_data->consumer_supplies[i].dev_name,
2491
			init_data->consumer_supplies[i].supply);
2492 2493
		if (ret < 0)
			goto unset_supplies;
2494
	}
2495 2496 2497

	list_add(&rdev->list, &regulator_list);
out:
2498 2499
	mutex_unlock(&regulator_list_mutex);
	return rdev;
D
David Brownell 已提交
2500

2501 2502 2503
unset_supplies:
	unset_regulator_supplies(rdev);

D
David Brownell 已提交
2504 2505
scrub:
	device_unregister(&rdev->dev);
2506 2507 2508 2509
	/* device core frees rdev */
	rdev = ERR_PTR(ret);
	goto out;

D
David Brownell 已提交
2510 2511 2512 2513
clean:
	kfree(rdev);
	rdev = ERR_PTR(ret);
	goto out;
2514 2515 2516 2517 2518
}
EXPORT_SYMBOL_GPL(regulator_register);

/**
 * regulator_unregister - unregister regulator
2519
 * @rdev: regulator to unregister
2520 2521 2522 2523 2524 2525 2526 2527 2528
 *
 * Called by regulator drivers to unregister a regulator.
 */
void regulator_unregister(struct regulator_dev *rdev)
{
	if (rdev == NULL)
		return;

	mutex_lock(&regulator_list_mutex);
2529
	WARN_ON(rdev->open_count);
2530
	unset_regulator_supplies(rdev);
2531 2532 2533 2534
	list_del(&rdev->list);
	if (rdev->supply)
		sysfs_remove_link(&rdev->dev.kobj, "supply");
	device_unregister(&rdev->dev);
2535
	kfree(rdev->constraints);
2536 2537 2538 2539 2540
	mutex_unlock(&regulator_list_mutex);
}
EXPORT_SYMBOL_GPL(regulator_unregister);

/**
2541
 * regulator_suspend_prepare - prepare regulators for system wide suspend
2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563
 * @state: system suspend state
 *
 * Configure each regulator with it's suspend operating parameters for state.
 * This will usually be called by machine suspend code prior to supending.
 */
int regulator_suspend_prepare(suspend_state_t state)
{
	struct regulator_dev *rdev;
	int ret = 0;

	/* ON is handled by regulator active state */
	if (state == PM_SUSPEND_ON)
		return -EINVAL;

	mutex_lock(&regulator_list_mutex);
	list_for_each_entry(rdev, &regulator_list, list) {

		mutex_lock(&rdev->mutex);
		ret = suspend_prepare(rdev, state);
		mutex_unlock(&rdev->mutex);

		if (ret < 0) {
2564
			rdev_err(rdev, "failed to prepare\n");
2565 2566 2567 2568 2569 2570 2571 2572 2573
			goto out;
		}
	}
out:
	mutex_unlock(&regulator_list_mutex);
	return ret;
}
EXPORT_SYMBOL_GPL(regulator_suspend_prepare);

2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590
/**
 * regulator_has_full_constraints - the system has fully specified constraints
 *
 * Calling this function will cause the regulator API to disable all
 * regulators which have a zero use count and don't have an always_on
 * constraint in a late_initcall.
 *
 * The intention is that this will become the default behaviour in a
 * future kernel release so users are encouraged to use this facility
 * now.
 */
void regulator_has_full_constraints(void)
{
	has_full_constraints = 1;
}
EXPORT_SYMBOL_GPL(regulator_has_full_constraints);

2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606
/**
 * regulator_use_dummy_regulator - Provide a dummy regulator when none is found
 *
 * Calling this function will cause the regulator API to provide a
 * dummy regulator to consumers if no physical regulator is found,
 * allowing most consumers to proceed as though a regulator were
 * configured.  This allows systems such as those with software
 * controllable regulators for the CPU core only to be brought up more
 * readily.
 */
void regulator_use_dummy_regulator(void)
{
	board_wants_dummy_regulator = true;
}
EXPORT_SYMBOL_GPL(regulator_use_dummy_regulator);

2607 2608
/**
 * rdev_get_drvdata - get rdev regulator driver data
2609
 * @rdev: regulator
2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645
 *
 * Get rdev regulator driver private data. This call can be used in the
 * regulator driver context.
 */
void *rdev_get_drvdata(struct regulator_dev *rdev)
{
	return rdev->reg_data;
}
EXPORT_SYMBOL_GPL(rdev_get_drvdata);

/**
 * regulator_get_drvdata - get regulator driver data
 * @regulator: regulator
 *
 * Get regulator driver private data. This call can be used in the consumer
 * driver context when non API regulator specific functions need to be called.
 */
void *regulator_get_drvdata(struct regulator *regulator)
{
	return regulator->rdev->reg_data;
}
EXPORT_SYMBOL_GPL(regulator_get_drvdata);

/**
 * regulator_set_drvdata - set regulator driver data
 * @regulator: regulator
 * @data: data
 */
void regulator_set_drvdata(struct regulator *regulator, void *data)
{
	regulator->rdev->reg_data = data;
}
EXPORT_SYMBOL_GPL(regulator_set_drvdata);

/**
 * regulator_get_id - get regulator ID
2646
 * @rdev: regulator
2647 2648 2649 2650 2651 2652 2653
 */
int rdev_get_id(struct regulator_dev *rdev)
{
	return rdev->desc->id;
}
EXPORT_SYMBOL_GPL(rdev_get_id);

2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665
struct device *rdev_get_dev(struct regulator_dev *rdev)
{
	return &rdev->dev;
}
EXPORT_SYMBOL_GPL(rdev_get_dev);

void *regulator_get_init_drvdata(struct regulator_init_data *reg_init_data)
{
	return reg_init_data->driver_data;
}
EXPORT_SYMBOL_GPL(regulator_get_init_drvdata);

2666 2667
static int __init regulator_init(void)
{
2668 2669 2670 2671 2672 2673 2674
	int ret;

	ret = class_register(&regulator_class);

	regulator_dummy_init();

	return ret;
2675 2676 2677 2678
}

/* init early to allow our consumers to complete system booting */
core_initcall(regulator_init);
2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696

static int __init regulator_init_complete(void)
{
	struct regulator_dev *rdev;
	struct regulator_ops *ops;
	struct regulation_constraints *c;
	int enabled, ret;

	mutex_lock(&regulator_list_mutex);

	/* If we have a full configuration then disable any regulators
	 * which are not in use or always_on.  This will become the
	 * default behaviour in the future.
	 */
	list_for_each_entry(rdev, &regulator_list, list) {
		ops = rdev->desc->ops;
		c = rdev->constraints;

2697
		if (!ops->disable || (c && c->always_on))
2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716
			continue;

		mutex_lock(&rdev->mutex);

		if (rdev->use_count)
			goto unlock;

		/* If we can't read the status assume it's on. */
		if (ops->is_enabled)
			enabled = ops->is_enabled(rdev);
		else
			enabled = 1;

		if (!enabled)
			goto unlock;

		if (has_full_constraints) {
			/* We log since this may kill the system if it
			 * goes wrong. */
2717
			rdev_info(rdev, "disabling\n");
2718 2719
			ret = ops->disable(rdev);
			if (ret != 0) {
2720
				rdev_err(rdev, "couldn't disable: %d\n", ret);
2721 2722 2723 2724 2725 2726 2727
			}
		} else {
			/* The intention is that in future we will
			 * assume that full constraints are provided
			 * so warn even if we aren't going to do
			 * anything here.
			 */
2728
			rdev_warn(rdev, "incomplete constraints, leaving on\n");
2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739
		}

unlock:
		mutex_unlock(&rdev->mutex);
	}

	mutex_unlock(&regulator_list_mutex);

	return 0;
}
late_initcall(regulator_init_complete);